drivers/char/xilinx_hwicap/xilinx_hwicap.c

   1 /*****************************************************************************
   2  *
   3  *     Author: Xilinx, Inc.
   4  *
   5  *     This program is free software; you can redistribute it and/or modify it
   6  *     under the terms of the GNU General Public License as published by the
   7  *     Free Software Foundation; either version 2 of the License, or (at your
   8  *     option) any later version.
   9  *
  10  *     XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS"
  11  *     AS A COURTESY TO YOU, SOLELY FOR USE IN DEVELOPING PROGRAMS AND
  12  *     SOLUTIONS FOR XILINX DEVICES.  BY PROVIDING THIS DESIGN, CODE,
  13  *     OR INFORMATION AS ONE POSSIBLE IMPLEMENTATION OF THIS FEATURE,
  14  *     APPLICATION OR STANDARD, XILINX IS MAKING NO REPRESENTATION
  15  *     THAT THIS IMPLEMENTATION IS FREE FROM ANY CLAIMS OF INFRINGEMENT,
  16  *     AND YOU ARE RESPONSIBLE FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE
  17  *     FOR YOUR IMPLEMENTATION.  XILINX EXPRESSLY DISCLAIMS ANY
  18  *     WARRANTY WHATSOEVER WITH RESPECT TO THE ADEQUACY OF THE
  19  *     IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OR
  20  *     REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM CLAIMS OF
  21  *     INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  22  *     FOR A PARTICULAR PURPOSE.
  23  *
  24  *     (c) Copyright 2002 Xilinx Inc., Systems Engineering Group
  25  *     (c) Copyright 2004 Xilinx Inc., Systems Engineering Group
  26  *     (c) Copyright 2007-2008 Xilinx Inc.
  27  *     All rights reserved.
  28  *
  29  *     You should have received a copy of the GNU General Public License along
  30  *     with this program; if not, write to the Free Software Foundation, Inc.,
  31  *     675 Mass Ave, Cambridge, MA 02139, USA.
  32  *
  33  *****************************************************************************/
  34
  35 /*
  36  * This is the code behind /dev/icap* -- it allows a user-space
  37  * application to use the Xilinx ICAP subsystem.
  38  *
  39  * The following operations are possible:
  40  *
  41  * open         open the port and initialize for access.
  42  * release      release port
  43  * write        Write a bitstream to the configuration processor.
  44  * read         Read a data stream from the configuration processor.
  45  *
  46  * After being opened, the port is initialized and accessed to avoid a
  47  * corrupted first read which may occur with some hardware.  The port
  48  * is left in a desynched state, requiring that a synch sequence be
  49  * transmitted before any valid configuration data.  A user will have
  50  * exclusive access to the device while it remains open, and the state
  51  * of the ICAP cannot be guaranteed after the device is closed.  Note
  52  * that a complete reset of the core and the state of the ICAP cannot
  53  * be performed on many versions of the cores, hence users of this
  54  * device should avoid making inconsistent accesses to the device.  In
  55  * particular, accessing the read interface, without first generating
  56  * a write containing a readback packet can leave the ICAP in an
  57  * inaccessible state.
  58  *
  59  * Note that in order to use the read interface, it is first necessary
  60  * to write a request packet to the write interface.  i.e., it is not
  61  * possible to simply readback the bitstream (or any configuration
  62  * bits) from a device without specifically requesting them first.
  63  * The code to craft such packets is intended to be part of the
  64  * user-space application code that uses this device.  The simplest
  65  * way to use this interface is simply:
  66  *
  67  * cp foo.bit /dev/icap0
  68  *
  69  * Note that unless foo.bit is an appropriately constructed partial
  70  * bitstream, this has a high likelihood of overwriting the design
  71  * currently programmed in the FPGA.
  72  */
  73
  74 #include <linux/module.h>
  75 #include <linux/kernel.h>
  76 #include <linux/types.h>
  77 #include <linux/ioport.h>
  78 #include <linux/interrupt.h>
  79 #include <linux/fcntl.h>
  80 #include <linux/init.h>
  81 #include <linux/poll.h>
  82 #include <linux/proc_fs.h>
  83 #include <linux/mutex.h>
  84 #include <linux/sysctl.h>
  85 #include <linux/fs.h>
  86 #include <linux/cdev.h>
  87 #include <linux/platform_device.h>
  88 #include <linux/slab.h>
  89
  90 #include <asm/io.h>
  91 #include <asm/uaccess.h>
  92 #include <asm/system.h>
  93
  94 #ifdef CONFIG_OF
  95 /* For open firmware. */
  96 #include <linux/of_address.h>
  97 #include <linux/of_device.h>
  98 #include <linux/of_platform.h>
  99 #endif
 100
 101 #include "xilinx_hwicap.h"
 102 #include "buffer_icap.h"
 103 #include "fifo_icap.h"
 104
 105 #define DRIVER_NAME "icap"
 106
 107 #define HWICAP_REGS   (0x10000)
 108
 109 #define XHWICAP_MAJOR 259
 110 #define XHWICAP_MINOR 0
 111 #define HWICAP_DEVICES 1
 112
 113 /* An array, which is set to true when the device is registered. */
 114 static DEFINE_MUTEX(hwicap_mutex);
 115 static bool probed_devices[HWICAP_DEVICES];
 116 static struct mutex icap_sem;
 117
 118 static struct class *icap_class;
 119
 120 #define UNIMPLEMENTED 0xFFFF
 121
 122 static const struct config_registers v2_config_registers = {
 123         .CRC = 0,
 124         .FAR = 1,
 125         .FDRI = 2,
 126         .FDRO = 3,
 127         .CMD = 4,
 128         .CTL = 5,
 129         .MASK = 6,
 130         .STAT = 7,
 131         .LOUT = 8,
 132         .COR = 9,
 133         .MFWR = 10,
 134         .FLR = 11,
 135         .KEY = 12,
 136         .CBC = 13,
 137         .IDCODE = 14,
 138         .AXSS = UNIMPLEMENTED,
 139         .C0R_1 = UNIMPLEMENTED,
 140         .CSOB = UNIMPLEMENTED,
 141         .WBSTAR = UNIMPLEMENTED,
 142         .TIMER = UNIMPLEMENTED,
 143         .BOOTSTS = UNIMPLEMENTED,
 144         .CTL_1 = UNIMPLEMENTED,
 145 };
 146
 147 static const struct config_registers v4_config_registers = {
 148         .CRC = 0,
 149         .FAR = 1,
 150         .FDRI = 2,
 151         .FDRO = 3,
 152         .CMD = 4,
 153         .CTL = 5,
 154         .MASK = 6,
 155         .STAT = 7,
 156         .LOUT = 8,
 157         .COR = 9,
 158         .MFWR = 10,
 159         .FLR = UNIMPLEMENTED,
 160         .KEY = UNIMPLEMENTED,
 161         .CBC = 11,
 162         .IDCODE = 12,
 163         .AXSS = 13,
 164         .C0R_1 = UNIMPLEMENTED,
 165         .CSOB = UNIMPLEMENTED,
 166         .WBSTAR = UNIMPLEMENTED,
 167         .TIMER = UNIMPLEMENTED,
 168         .BOOTSTS = UNIMPLEMENTED,
 169         .CTL_1 = UNIMPLEMENTED,
 170 };
 171 static const struct config_registers v5_config_registers = {
 172         .CRC = 0,
 173         .FAR = 1,
 174         .FDRI = 2,
 175         .FDRO = 3,
 176         .CMD = 4,
 177         .CTL = 5,
 178         .MASK = 6,
 179         .STAT = 7,
 180         .LOUT = 8,
 181         .COR = 9,
 182         .MFWR = 10,
 183         .FLR = UNIMPLEMENTED,
 184         .KEY = UNIMPLEMENTED,
 185         .CBC = 11,
 186         .IDCODE = 12,
 187         .AXSS = 13,
 188         .C0R_1 = 14,
 189         .CSOB = 15,
 190         .WBSTAR = 16,
 191         .TIMER = 17,
 192         .BOOTSTS = 18,
 193         .CTL_1 = 19,
 194 };
 195
 196 /**
 197  * hwicap_command_desync - Send a DESYNC command to the ICAP port.
 198  * @drvdata: a pointer to the drvdata.
 199  *
 200  * This command desynchronizes the ICAP After this command, a
 201  * bitstream containing a NULL packet, followed by a SYNCH packet is
 202  * required before the ICAP will recognize commands.
 203  */
 204 static int hwicap_command_desync(struct hwicap_drvdata *drvdata)
 205 {
 206         u32 buffer[4];
 207         u32 index = 0;
 208
 209         /*
 210          * Create the data to be written to the ICAP.
 211          */
 212         buffer[index++] = hwicap_type_1_write(drvdata->config_regs->CMD) | 1;
 213         buffer[index++] = XHI_CMD_DESYNCH;
 214         buffer[index++] = XHI_NOOP_PACKET;
 215         buffer[index++] = XHI_NOOP_PACKET;
 216
 217         /*
 218          * Write the data to the FIFO and intiate the transfer of data present
 219          * in the FIFO to the ICAP device.
 220          */
 221         return drvdata->config->set_configuration(drvdata,
 222                         &buffer[0], index);
 223 }
 224
 225 /**
 226  * hwicap_get_configuration_register - Query a configuration register.
 227  * @drvdata: a pointer to the drvdata.
 228  * @reg: a constant which represents the configuration
 229  *              register value to be returned.
 230  *              Examples:  XHI_IDCODE, XHI_FLR.
 231  * @reg_data: returns the value of the register.
 232  *
 233  * Sends a query packet to the ICAP and then receives the response.
 234  * The icap is left in Synched state.
 235  */
 236 static int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata,
 237                 u32 reg, u32 *reg_data)
 238 {
 239         int status;
 240         u32 buffer[6];
 241         u32 index = 0;
 242
 243         /*
 244          * Create the data to be written to the ICAP.
 245          */
 246         buffer[index++] = XHI_DUMMY_PACKET;
 247         buffer[index++] = XHI_NOOP_PACKET;
 248         buffer[index++] = XHI_SYNC_PACKET;
 249         buffer[index++] = XHI_NOOP_PACKET;
 250         buffer[index++] = XHI_NOOP_PACKET;
 251
 252         /*
 253          * Write the data to the FIFO and initiate the transfer of data present
 254          * in the FIFO to the ICAP device.
 255          */
 256         status = drvdata->config->set_configuration(drvdata,
 257                                                     &buffer[0], index);
 258         if (status)
 259                 return status;
 260
 261         /* If the syncword was not found, then we need to start over. */
 262         status = drvdata->config->get_status(drvdata);
 263         if ((status & XHI_SR_DALIGN_MASK) != XHI_SR_DALIGN_MASK)
 264                 return -EIO;
 265
 266         index = 0;
 267         buffer[index++] = hwicap_type_1_read(reg) | 1;
 268         buffer[index++] = XHI_NOOP_PACKET;
 269         buffer[index++] = XHI_NOOP_PACKET;
 270
 271         /*
 272          * Write the data to the FIFO and intiate the transfer of data present
 273          * in the FIFO to the ICAP device.
 274          */
 275         status = drvdata->config->set_configuration(drvdata,
 276                         &buffer[0], index);
 277         if (status)
 278                 return status;
 279
 280         /*
 281          * Read the configuration register
 282          */
 283         status = drvdata->config->get_configuration(drvdata, reg_data, 1);
 284         if (status)
 285                 return status;
 286
 287         return 0;
 288 }
 289
 290 static int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata)
 291 {
 292         int status;
 293         u32 idcode;
 294
 295         dev_dbg(drvdata->dev, "initializing\n");
 296
 297         /* Abort any current transaction, to make sure we have the
 298          * ICAP in a good state. */
 299         dev_dbg(drvdata->dev, "Reset...\n");
 300         drvdata->config->reset(drvdata);
 301
 302         dev_dbg(drvdata->dev, "Desync...\n");
 303         status = hwicap_command_desync(drvdata);
 304         if (status)
 305                 return status;
 306
 307         /* Attempt to read the IDCODE from ICAP.  This
 308          * may not be returned correctly, due to the design of the
 309          * hardware.
 310          */
 311         dev_dbg(drvdata->dev, "Reading IDCODE...\n");
 312         status = hwicap_get_configuration_register(
 313                         drvdata, drvdata->config_regs->IDCODE, &idcode);
 314         dev_dbg(drvdata->dev, "IDCODE = %x\n", idcode);
 315         if (status)
 316                 return status;
 317
 318         dev_dbg(drvdata->dev, "Desync...\n");
 319         status = hwicap_command_desync(drvdata);
 320         if (status)
 321                 return status;
 322
 323         return 0;
 324 }
 325
 326 static ssize_t
 327 hwicap_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 328 {
 329         struct hwicap_drvdata *drvdata = file->private_data;
 330         ssize_t bytes_to_read = 0;
 331         u32 *kbuf;
 332         u32 words;
 333         u32 bytes_remaining;
 334         int status;
 335
 336         status = mutex_lock_interruptible(&drvdata->sem);
 337         if (status)
 338                 return status;
 339
 340         if (drvdata->read_buffer_in_use) {
 341                 /* If there are leftover bytes in the buffer, just */
 342                 /* return them and don't try to read more from the */
 343                 /* ICAP device. */
 344                 bytes_to_read =
 345                         (count < drvdata->read_buffer_in_use) ? count :
 346                         drvdata->read_buffer_in_use;
 347
 348                 /* Return the data currently in the read buffer. */
 349                 if (copy_to_user(buf, drvdata->read_buffer, bytes_to_read)) {
 350                         status = -EFAULT;
 351                         goto error;
 352                 }
 353                 drvdata->read_buffer_in_use -= bytes_to_read;
 354                 memmove(drvdata->read_buffer,
 355                        drvdata->read_buffer + bytes_to_read,
 356                        4 - bytes_to_read);
 357         } else {
 358                 /* Get new data from the ICAP, and return was was requested. */
 359                 kbuf = (u32 *) get_zeroed_page(GFP_KERNEL);
 360                 if (!kbuf) {
 361                         status = -ENOMEM;
 362                         goto error;
 363                 }
 364
 365                 /* The ICAP device is only able to read complete */
 366                 /* words.  If a number of bytes that do not correspond */
 367                 /* to complete words is requested, then we read enough */
 368                 /* words to get the required number of bytes, and then */
 369                 /* save the remaining bytes for the next read. */
 370
 371                 /* Determine the number of words to read, rounding up */
 372                 /* if necessary. */
 373                 words = ((count + 3) >> 2);
 374                 bytes_to_read = words << 2;
 375
 376                 if (bytes_to_read > PAGE_SIZE)
 377                         bytes_to_read = PAGE_SIZE;
 378
 379                 /* Ensure we only read a complete number of words. */
 380                 bytes_remaining = bytes_to_read & 3;
 381                 bytes_to_read &= ~3;
 382                 words = bytes_to_read >> 2;
 383
 384                 status = drvdata->config->get_configuration(drvdata,
 385                                 kbuf, words);
 386
 387                 /* If we didn't read correctly, then bail out. */
 388                 if (status) {
 389                         free_page((unsigned long)kbuf);
 390                         goto error;
 391                 }
 392
 393                 /* If we fail to return the data to the user, then bail out. */
 394                 if (copy_to_user(buf, kbuf, bytes_to_read)) {
 395                         free_page((unsigned long)kbuf);
 396                         status = -EFAULT;
 397                         goto error;
 398                 }
 399                 memcpy(drvdata->read_buffer,
 400                        kbuf,
 401                        bytes_remaining);
 402                 drvdata->read_buffer_in_use = bytes_remaining;
 403                 free_page((unsigned long)kbuf);
 404         }
 405         status = bytes_to_read;
 406  error:
 407         mutex_unlock(&drvdata->sem);
 408         return status;
 409 }
 410
 411 static ssize_t
 412 hwicap_write(struct file *file, const char __user *buf,
 413                 size_t count, loff_t *ppos)
 414 {
 415         struct hwicap_drvdata *drvdata = file->private_data;
 416         ssize_t written = 0;
 417         ssize_t left = count;
 418         u32 *kbuf;
 419         ssize_t len;
 420         ssize_t status;
 421
 422         status = mutex_lock_interruptible(&drvdata->sem);
 423         if (status)
 424                 return status;
 425
 426         left += drvdata->write_buffer_in_use;
 427
 428         /* Only write multiples of 4 bytes. */
 429         if (left < 4) {
 430                 status = 0;
 431                 goto error;
 432         }
 433
 434         kbuf = (u32 *) __get_free_page(GFP_KERNEL);
 435         if (!kbuf) {
 436                 status = -ENOMEM;
 437                 goto error;
 438         }
 439
 440         while (left > 3) {
 441                 /* only write multiples of 4 bytes, so there might */
 442                 /* be as many as 3 bytes left (at the end). */
 443                 len = left;
 444
 445                 if (len > PAGE_SIZE)
 446                         len = PAGE_SIZE;
 447                 len &= ~3;
 448
 449                 if (drvdata->write_buffer_in_use) {
 450                         memcpy(kbuf, drvdata->write_buffer,
 451                                         drvdata->write_buffer_in_use);
 452                         if (copy_from_user(
 453                             (((char *)kbuf) + drvdata->write_buffer_in_use),
 454                             buf + written,
 455                             len - (drvdata->write_buffer_in_use))) {
 456                                 free_page((unsigned long)kbuf);
 457                                 status = -EFAULT;
 458                                 goto error;
 459                         }
 460                 } else {
 461                         if (copy_from_user(kbuf, buf + written, len)) {
 462                                 free_page((unsigned long)kbuf);
 463                                 status = -EFAULT;
 464                                 goto error;
 465                         }
 466                 }
 467
 468                 status = drvdata->config->set_configuration(drvdata,
 469                                 kbuf, len >> 2);
 470
 471                 if (status) {
 472                         free_page((unsigned long)kbuf);
 473                         status = -EFAULT;
 474                         goto error;
 475                 }
 476                 if (drvdata->write_buffer_in_use) {
 477                         len -= drvdata->write_buffer_in_use;
 478                         left -= drvdata->write_buffer_in_use;
 479                         drvdata->write_buffer_in_use = 0;
 480                 }
 481                 written += len;
 482                 left -= len;
 483         }
 484         if ((left > 0) && (left < 4)) {
 485                 if (!copy_from_user(drvdata->write_buffer,
 486                                                 buf + written, left)) {
 487                         drvdata->write_buffer_in_use = left;
 488                         written += left;
 489                         left = 0;
 490                 }
 491         }
 492
 493         free_page((unsigned long)kbuf);
 494         status = written;
 495  error:
 496         mutex_unlock(&drvdata->sem);
 497         return status;
 498 }
 499
 500 static int hwicap_open(struct inode *inode, struct file *file)
 501 {
 502         struct hwicap_drvdata *drvdata;
 503         int status;
 504
 505         mutex_lock(&hwicap_mutex);
 506         drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev);
 507
 508         status = mutex_lock_interruptible(&drvdata->sem);
 509         if (status)
 510                 goto out;
 511
 512         if (drvdata->is_open) {
 513                 status = -EBUSY;
 514                 goto error;
 515         }
 516
 517         status = hwicap_initialize_hwicap(drvdata);
 518         if (status) {
 519                 dev_err(drvdata->dev, "Failed to open file");
 520                 goto error;
 521         }
 522
 523         file->private_data = drvdata;
 524         drvdata->write_buffer_in_use = 0;
 525         drvdata->read_buffer_in_use = 0;
 526         drvdata->is_open = 1;
 527
 528  error:
 529         mutex_unlock(&drvdata->sem);
 530  out:
 531         mutex_unlock(&hwicap_mutex);
 532         return status;
 533 }
 534
 535 static int hwicap_release(struct inode *inode, struct file *file)
 536 {
 537         struct hwicap_drvdata *drvdata = file->private_data;
 538         int i;
 539         int status = 0;
 540
 541         mutex_lock(&drvdata->sem);
 542
 543         if (drvdata->write_buffer_in_use) {
 544                 /* Flush write buffer. */
 545                 for (i = drvdata->write_buffer_in_use; i < 4; i++)
 546                         drvdata->write_buffer[i] = 0;
 547
 548                 status = drvdata->config->set_configuration(drvdata,
 549                                 (u32 *) drvdata->write_buffer, 1);
 550                 if (status)
 551                         goto error;
 552         }
 553
 554         status = hwicap_command_desync(drvdata);
 555         if (status)
 556                 goto error;
 557
 558  error:
 559         drvdata->is_open = 0;
 560         mutex_unlock(&drvdata->sem);
 561         return status;
 562 }
 563
 564 static const struct file_operations hwicap_fops = {
 565         .owner = THIS_MODULE,
 566         .write = hwicap_write,
 567         .read = hwicap_read,
 568         .open = hwicap_open,
 569         .release = hwicap_release,
 570         .llseek = noop_llseek,
 571 };
 572
 573 static int __devinit hwicap_setup(struct device *dev, int id,
 574                 const struct resource *regs_res,
 575                 const struct hwicap_driver_config *config,
 576                 const struct config_registers *config_regs)
 577 {
 578         dev_t devt;
 579         struct hwicap_drvdata *drvdata = NULL;
 580         int retval = 0;
 581
 582         dev_info(dev, "Xilinx icap port driver\n");
 583
 584         mutex_lock(&icap_sem);
 585
 586         if (id < 0) {
 587                 for (id = 0; id < HWICAP_DEVICES; id++)
 588                         if (!probed_devices[id])
 589                                 break;
 590         }
 591         if (id < 0 || id >= HWICAP_DEVICES) {
 592                 mutex_unlock(&icap_sem);
 593                 dev_err(dev, "%s%i too large\n", DRIVER_NAME, id);
 594                 return -EINVAL;
 595         }
 596         if (probed_devices[id]) {
 597                 mutex_unlock(&icap_sem);
 598                 dev_err(dev, "cannot assign to %s%i; it is already in use\n",
 599                         DRIVER_NAME, id);
 600                 return -EBUSY;
 601         }
 602
 603         probed_devices[id] = 1;
 604         mutex_unlock(&icap_sem);
 605
 606         devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR + id);
 607
 608         drvdata = kzalloc(sizeof(struct hwicap_drvdata), GFP_KERNEL);
 609         if (!drvdata) {
 610                 dev_err(dev, "Couldn't allocate device private record\n");
 611                 retval = -ENOMEM;
 612                 goto failed0;
 613         }
 614         dev_set_drvdata(dev, (void *)drvdata);
 615
 616         if (!regs_res) {
 617                 dev_err(dev, "Couldn't get registers resource\n");
 618                 retval = -EFAULT;
 619                 goto failed1;
 620         }
 621
 622         drvdata->mem_start = regs_res->start;
 623         drvdata->mem_end = regs_res->end;
 624         drvdata->mem_size = regs_res->end - regs_res->start + 1;
 625
 626         if (!request_mem_region(drvdata->mem_start,
 627                                         drvdata->mem_size, DRIVER_NAME)) {
 628                 dev_err(dev, "Couldn't lock memory region at %Lx\n",
 629                         (unsigned long long) regs_res->start);
 630                 retval = -EBUSY;
 631                 goto failed1;
 632         }
 633
 634         drvdata->devt = devt;
 635         drvdata->dev = dev;
 636         drvdata->base_address = ioremap(drvdata->mem_start, drvdata->mem_size);
 637         if (!drvdata->base_address) {
 638                 dev_err(dev, "ioremap() failed\n");
 639                 goto failed2;
 640         }
 641
 642         drvdata->config = config;
 643         drvdata->config_regs = config_regs;
 644
 645         mutex_init(&drvdata->sem);
 646         drvdata->is_open = 0;
 647
 648         dev_info(dev, "ioremap %llx to %p with size %llx\n",
 649                  (unsigned long long) drvdata->mem_start,
 650                  drvdata->base_address,
 651                  (unsigned long long) drvdata->mem_size);
 652
 653         cdev_init(&drvdata->cdev, &hwicap_fops);
 654         drvdata->cdev.owner = THIS_MODULE;
 655         retval = cdev_add(&drvdata->cdev, devt, 1);
 656         if (retval) {
 657                 dev_err(dev, "cdev_add() failed\n");
 658                 goto failed3;
 659         }
 660
 661         device_create(icap_class, dev, devt, NULL, "%s%d", DRIVER_NAME, id);
 662         return 0;               /* success */
 663
 664  failed3:
 665         iounmap(drvdata->base_address);
 666
 667  failed2:
 668         release_mem_region(regs_res->start, drvdata->mem_size);
 669
 670  failed1:
 671         kfree(drvdata);
 672
 673  failed0:
 674         mutex_lock(&icap_sem);
 675         probed_devices[id] = 0;
 676         mutex_unlock(&icap_sem);
 677
 678         return retval;
 679 }
 680
 681 static struct hwicap_driver_config buffer_icap_config = {
 682         .get_configuration = buffer_icap_get_configuration,
 683         .set_configuration = buffer_icap_set_configuration,
 684         .get_status = buffer_icap_get_status,
 685         .reset = buffer_icap_reset,
 686 };
 687
 688 static struct hwicap_driver_config fifo_icap_config = {
 689         .get_configuration = fifo_icap_get_configuration,
 690         .set_configuration = fifo_icap_set_configuration,
 691         .get_status = fifo_icap_get_status,
 692         .reset = fifo_icap_reset,
 693 };
 694
 695 static int __devexit hwicap_remove(struct device *dev)
 696 {
 697         struct hwicap_drvdata *drvdata;
 698
 699         drvdata = (struct hwicap_drvdata *)dev_get_drvdata(dev);
 700
 701         if (!drvdata)
 702                 return 0;
 703
 704         device_destroy(icap_class, drvdata->devt);
 705         cdev_del(&drvdata->cdev);
 706         iounmap(drvdata->base_address);
 707         release_mem_region(drvdata->mem_start, drvdata->mem_size);
 708         kfree(drvdata);
 709         dev_set_drvdata(dev, NULL);
 710
 711         mutex_lock(&icap_sem);
 712         probed_devices[MINOR(dev->devt)-XHWICAP_MINOR] = 0;
 713         mutex_unlock(&icap_sem);
 714         return 0;               /* success */
 715 }
 716
 717 #ifdef CONFIG_OF
 718 static int __devinit hwicap_of_probe(struct platform_device *op)
 719 {
 720         struct resource res;
 721         const unsigned int *id;
 722         const char *family;
 723         int rc;
 724         const struct hwicap_driver_config *config = op->dev.of_match->data;
 725         const struct config_registers *regs;
 726
 727
 728         rc = of_address_to_resource(op->dev.of_node, 0, &res);
 729         if (rc) {
 730                 dev_err(&op->dev, "invalid address\n");
 731                 return rc;
 732         }
 733
 734         id = of_get_property(op->dev.of_node, "port-number", NULL);
 735
 736         /* It's most likely that we're using V4, if the family is not
 737            specified */
 738         regs = &v4_config_registers;
 739         family = of_get_property(op->dev.of_node, "xlnx,family", NULL);
 740
 741         if (family) {
 742                 if (!strcmp(family, "virtex2p")) {
 743                         regs = &v2_config_registers;
 744                 } else if (!strcmp(family, "virtex4")) {
 745                         regs = &v4_config_registers;
 746                 } else if (!strcmp(family, "virtex5")) {
 747                         regs = &v5_config_registers;
 748                 }
 749         }
 750         return hwicap_setup(&op->dev, id ? *id : -1, &res, config,
 751                         regs);
 752 }
 753 #else
 754 static inline int hwicap_of_probe(struct platform_device *op)
 755 {
 756         return -EINVAL;
 757 }
 758 #endif /* CONFIG_OF */
 759
 760 static int __devinit hwicap_drv_probe(struct platform_device *pdev)
 761 {
 762         struct resource *res;
 763         const struct config_registers *regs;
 764         const char *family;
 765
 766         if (pdev->dev.of_match)
 767                 return hwicap_of_probe(pdev);
 768
 769         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 770         if (!res)
 771                 return -ENODEV;
 772
 773         /* It's most likely that we're using V4, if the family is not
 774            specified */
 775         regs = &v4_config_registers;
 776         family = pdev->dev.platform_data;
 777
 778         if (family) {
 779                 if (!strcmp(family, "virtex2p")) {
 780                         regs = &v2_config_registers;
 781                 } else if (!strcmp(family, "virtex4")) {
 782                         regs = &v4_config_registers;
 783                 } else if (!strcmp(family, "virtex5")) {
 784                         regs = &v5_config_registers;
 785                 }
 786         }
 787
 788         return hwicap_setup(&pdev->dev, pdev->id, res,
 789                         &buffer_icap_config, regs);
 790 }
 791
 792 static int __devexit hwicap_drv_remove(struct platform_device *pdev)
 793 {
 794         return hwicap_remove(&pdev->dev);
 795 }
 796
 797 #ifdef CONFIG_OF
 798 /* Match table for device tree binding */
 799 static const struct of_device_id __devinitconst hwicap_of_match[] = {
 800         { .compatible = "xlnx,opb-hwicap-1.00.b", .data = &buffer_icap_config},
 801         { .compatible = "xlnx,xps-hwicap-1.00.a", .data = &fifo_icap_config},
 802         {},
 803 };
 804 MODULE_DEVICE_TABLE(of, hwicap_of_match);
 805 #else
 806 #define hwicap_of_match NULL
 807 #endif
 808
 809 static struct platform_driver hwicap_platform_driver = {
 810         .probe = hwicap_drv_probe,
 811         .remove = hwicap_drv_remove,
 812         .driver = {
 813                 .owner = THIS_MODULE,
 814                 .name = DRIVER_NAME,
 815                 .of_match_table = hwicap_of_match,
 816         },
 817 };
 818
 819 static int __init hwicap_module_init(void)
 820 {
 821         dev_t devt;
 822         int retval;
 823
 824         icap_class = class_create(THIS_MODULE, "xilinx_config");
 825         mutex_init(&icap_sem);
 826
 827         devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR);
 828         retval = register_chrdev_region(devt,
 829                                         HWICAP_DEVICES,
 830                                         DRIVER_NAME);
 831         if (retval < 0)
 832                 return retval;
 833
 834         retval = platform_driver_register(&hwicap_platform_driver);
 835         if (retval)
 836                 goto failed;
 837
 838         return retval;
 839
 840  failed:
 841         unregister_chrdev_region(devt, HWICAP_DEVICES);
 842
 843         return retval;
 844 }
 845
 846 static void __exit hwicap_module_cleanup(void)
 847 {
 848         dev_t devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR);
 849
 850         class_destroy(icap_class);
 851
 852         platform_driver_unregister(&hwicap_platform_driver);
 853
 854         unregister_chrdev_region(devt, HWICAP_DEVICES);
 855 }
 856
 857 module_init(hwicap_module_init);
 858 module_exit(hwicap_module_cleanup);
 859
 860 MODULE_AUTHOR("Xilinx, Inc; Xilinx Research Labs Group");
 861 MODULE_DESCRIPTION("Xilinx ICAP Port Driver");
 862 MODULE_LICENSE("GPL");