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/of.h>
  88 #include <linux/platform_device.h>
  89 #include <linux/property.h>
  90 #include <linux/slab.h>
  91 #include <linux/io.h>
  92 #include <linux/uaccess.h>
  93
  94 #include "xilinx_hwicap.h"
  95 #include "buffer_icap.h"
  96 #include "fifo_icap.h"
  97
  98 #define DRIVER_NAME "icap"
  99
 100 #define HWICAP_REGS   (0x10000)
 101
 102 #define XHWICAP_MAJOR 259
 103 #define XHWICAP_MINOR 0
 104 #define HWICAP_DEVICES 1
 105
 106 /* An array, which is set to true when the device is registered. */
 107 static DEFINE_MUTEX(hwicap_mutex);
 108 static bool probed_devices[HWICAP_DEVICES];
 109 static struct mutex icap_sem;
 110
 111 static const struct class icap_class = {
 112         .name = "xilinx_config",
 113 };
 114
 115 #define UNIMPLEMENTED 0xFFFF
 116
 117 static const struct config_registers v2_config_registers = {
 118         .CRC = 0,
 119         .FAR = 1,
 120         .FDRI = 2,
 121         .FDRO = 3,
 122         .CMD = 4,
 123         .CTL = 5,
 124         .MASK = 6,
 125         .STAT = 7,
 126         .LOUT = 8,
 127         .COR = 9,
 128         .MFWR = 10,
 129         .FLR = 11,
 130         .KEY = 12,
 131         .CBC = 13,
 132         .IDCODE = 14,
 133         .AXSS = UNIMPLEMENTED,
 134         .C0R_1 = UNIMPLEMENTED,
 135         .CSOB = UNIMPLEMENTED,
 136         .WBSTAR = UNIMPLEMENTED,
 137         .TIMER = UNIMPLEMENTED,
 138         .BOOTSTS = UNIMPLEMENTED,
 139         .CTL_1 = UNIMPLEMENTED,
 140 };
 141
 142 static const struct config_registers v4_config_registers = {
 143         .CRC = 0,
 144         .FAR = 1,
 145         .FDRI = 2,
 146         .FDRO = 3,
 147         .CMD = 4,
 148         .CTL = 5,
 149         .MASK = 6,
 150         .STAT = 7,
 151         .LOUT = 8,
 152         .COR = 9,
 153         .MFWR = 10,
 154         .FLR = UNIMPLEMENTED,
 155         .KEY = UNIMPLEMENTED,
 156         .CBC = 11,
 157         .IDCODE = 12,
 158         .AXSS = 13,
 159         .C0R_1 = UNIMPLEMENTED,
 160         .CSOB = UNIMPLEMENTED,
 161         .WBSTAR = UNIMPLEMENTED,
 162         .TIMER = UNIMPLEMENTED,
 163         .BOOTSTS = UNIMPLEMENTED,
 164         .CTL_1 = UNIMPLEMENTED,
 165 };
 166
 167 static const struct config_registers v5_config_registers = {
 168         .CRC = 0,
 169         .FAR = 1,
 170         .FDRI = 2,
 171         .FDRO = 3,
 172         .CMD = 4,
 173         .CTL = 5,
 174         .MASK = 6,
 175         .STAT = 7,
 176         .LOUT = 8,
 177         .COR = 9,
 178         .MFWR = 10,
 179         .FLR = UNIMPLEMENTED,
 180         .KEY = UNIMPLEMENTED,
 181         .CBC = 11,
 182         .IDCODE = 12,
 183         .AXSS = 13,
 184         .C0R_1 = 14,
 185         .CSOB = 15,
 186         .WBSTAR = 16,
 187         .TIMER = 17,
 188         .BOOTSTS = 18,
 189         .CTL_1 = 19,
 190 };
 191
 192 static const struct config_registers v6_config_registers = {
 193         .CRC = 0,
 194         .FAR = 1,
 195         .FDRI = 2,
 196         .FDRO = 3,
 197         .CMD = 4,
 198         .CTL = 5,
 199         .MASK = 6,
 200         .STAT = 7,
 201         .LOUT = 8,
 202         .COR = 9,
 203         .MFWR = 10,
 204         .FLR = UNIMPLEMENTED,
 205         .KEY = UNIMPLEMENTED,
 206         .CBC = 11,
 207         .IDCODE = 12,
 208         .AXSS = 13,
 209         .C0R_1 = 14,
 210         .CSOB = 15,
 211         .WBSTAR = 16,
 212         .TIMER = 17,
 213         .BOOTSTS = 22,
 214         .CTL_1 = 24,
 215 };
 216
 217 /**
 218  * hwicap_command_desync - Send a DESYNC command to the ICAP port.
 219  * @drvdata: a pointer to the drvdata.
 220  *
 221  * Returns: '0' on success and failure value on error
 222  *
 223  * This command desynchronizes the ICAP After this command, a
 224  * bitstream containing a NULL packet, followed by a SYNCH packet is
 225  * required before the ICAP will recognize commands.
 226  */
 227 static int hwicap_command_desync(struct hwicap_drvdata *drvdata)
 228 {
 229         u32 buffer[4];
 230         u32 index = 0;
 231
 232         /*
 233          * Create the data to be written to the ICAP.
 234          */
 235         buffer[index++] = hwicap_type_1_write(drvdata->config_regs->CMD) | 1;
 236         buffer[index++] = XHI_CMD_DESYNCH;
 237         buffer[index++] = XHI_NOOP_PACKET;
 238         buffer[index++] = XHI_NOOP_PACKET;
 239
 240         /*
 241          * Write the data to the FIFO and initiate the transfer of data present
 242          * in the FIFO to the ICAP device.
 243          */
 244         return drvdata->config->set_configuration(drvdata,
 245                         &buffer[0], index);
 246 }
 247
 248 /**
 249  * hwicap_get_configuration_register - Query a configuration register.
 250  * @drvdata: a pointer to the drvdata.
 251  * @reg: a constant which represents the configuration
 252  * register value to be returned.
 253  * Examples: XHI_IDCODE, XHI_FLR.
 254  * @reg_data: returns the value of the register.
 255  *
 256  * Returns: '0' on success and failure value on error
 257  *
 258  * Sends a query packet to the ICAP and then receives the response.
 259  * The icap is left in Synched state.
 260  */
 261 static int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata,
 262                 u32 reg, u32 *reg_data)
 263 {
 264         int status;
 265         u32 buffer[6];
 266         u32 index = 0;
 267
 268         /*
 269          * Create the data to be written to the ICAP.
 270          */
 271         buffer[index++] = XHI_DUMMY_PACKET;
 272         buffer[index++] = XHI_NOOP_PACKET;
 273         buffer[index++] = XHI_SYNC_PACKET;
 274         buffer[index++] = XHI_NOOP_PACKET;
 275         buffer[index++] = XHI_NOOP_PACKET;
 276
 277         /*
 278          * Write the data to the FIFO and initiate the transfer of data present
 279          * in the FIFO to the ICAP device.
 280          */
 281         status = drvdata->config->set_configuration(drvdata,
 282                                                     &buffer[0], index);
 283         if (status)
 284                 return status;
 285
 286         /* If the syncword was not found, then we need to start over. */
 287         status = drvdata->config->get_status(drvdata);
 288         if ((status & XHI_SR_DALIGN_MASK) != XHI_SR_DALIGN_MASK)
 289                 return -EIO;
 290
 291         index = 0;
 292         buffer[index++] = hwicap_type_1_read(reg) | 1;
 293         buffer[index++] = XHI_NOOP_PACKET;
 294         buffer[index++] = XHI_NOOP_PACKET;
 295
 296         /*
 297          * Write the data to the FIFO and initiate the transfer of data present
 298          * in the FIFO to the ICAP device.
 299          */
 300         status = drvdata->config->set_configuration(drvdata,
 301                         &buffer[0], index);
 302         if (status)
 303                 return status;
 304
 305         /*
 306          * Read the configuration register
 307          */
 308         status = drvdata->config->get_configuration(drvdata, reg_data, 1);
 309         if (status)
 310                 return status;
 311
 312         return 0;
 313 }
 314
 315 static int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata)
 316 {
 317         int status;
 318         u32 idcode;
 319
 320         dev_dbg(drvdata->dev, "initializing\n");
 321
 322         /* Abort any current transaction, to make sure we have the
 323          * ICAP in a good state.
 324          */
 325         dev_dbg(drvdata->dev, "Reset...\n");
 326         drvdata->config->reset(drvdata);
 327
 328         dev_dbg(drvdata->dev, "Desync...\n");
 329         status = hwicap_command_desync(drvdata);
 330         if (status)
 331                 return status;
 332
 333         /* Attempt to read the IDCODE from ICAP.  This
 334          * may not be returned correctly, due to the design of the
 335          * hardware.
 336          */
 337         dev_dbg(drvdata->dev, "Reading IDCODE...\n");
 338         status = hwicap_get_configuration_register(
 339                         drvdata, drvdata->config_regs->IDCODE, &idcode);
 340         dev_dbg(drvdata->dev, "IDCODE = %x\n", idcode);
 341         if (status)
 342                 return status;
 343
 344         dev_dbg(drvdata->dev, "Desync...\n");
 345         status = hwicap_command_desync(drvdata);
 346         if (status)
 347                 return status;
 348
 349         return 0;
 350 }
 351
 352 static ssize_t
 353 hwicap_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 354 {
 355         struct hwicap_drvdata *drvdata = file->private_data;
 356         ssize_t bytes_to_read = 0;
 357         u32 *kbuf;
 358         u32 words;
 359         u32 bytes_remaining;
 360         int status;
 361
 362         status = mutex_lock_interruptible(&drvdata->sem);
 363         if (status)
 364                 return status;
 365
 366         if (drvdata->read_buffer_in_use) {
 367                 /* If there are leftover bytes in the buffer, just */
 368                 /* return them and don't try to read more from the */
 369                 /* ICAP device. */
 370                 bytes_to_read =
 371                         (count < drvdata->read_buffer_in_use) ? count :
 372                         drvdata->read_buffer_in_use;
 373
 374                 /* Return the data currently in the read buffer. */
 375                 if (copy_to_user(buf, drvdata->read_buffer, bytes_to_read)) {
 376                         status = -EFAULT;
 377                         goto error;
 378                 }
 379                 drvdata->read_buffer_in_use -= bytes_to_read;
 380                 memmove(drvdata->read_buffer,
 381                        drvdata->read_buffer + bytes_to_read,
 382                        4 - bytes_to_read);
 383         } else {
 384                 /* Get new data from the ICAP, and return what was requested. */
 385                 kbuf = (u32 *) get_zeroed_page(GFP_KERNEL);
 386                 if (!kbuf) {
 387                         status = -ENOMEM;
 388                         goto error;
 389                 }
 390
 391                 /* The ICAP device is only able to read complete */
 392                 /* words.  If a number of bytes that do not correspond */
 393                 /* to complete words is requested, then we read enough */
 394                 /* words to get the required number of bytes, and then */
 395                 /* save the remaining bytes for the next read. */
 396
 397                 /* Determine the number of words to read, rounding up */
 398                 /* if necessary. */
 399                 words = ((count + 3) >> 2);
 400                 bytes_to_read = words << 2;
 401
 402                 if (bytes_to_read > PAGE_SIZE)
 403                         bytes_to_read = PAGE_SIZE;
 404
 405                 /* Ensure we only read a complete number of words. */
 406                 bytes_remaining = bytes_to_read & 3;
 407                 bytes_to_read &= ~3;
 408                 words = bytes_to_read >> 2;
 409
 410                 status = drvdata->config->get_configuration(drvdata,
 411                                 kbuf, words);
 412
 413                 /* If we didn't read correctly, then bail out. */
 414                 if (status) {
 415                         free_page((unsigned long)kbuf);
 416                         goto error;
 417                 }
 418
 419                 /* If we fail to return the data to the user, then bail out. */
 420                 if (copy_to_user(buf, kbuf, bytes_to_read)) {
 421                         free_page((unsigned long)kbuf);
 422                         status = -EFAULT;
 423                         goto error;
 424                 }
 425                 memcpy(drvdata->read_buffer,
 426                        kbuf,
 427                        bytes_remaining);
 428                 drvdata->read_buffer_in_use = bytes_remaining;
 429                 free_page((unsigned long)kbuf);
 430         }
 431         status = bytes_to_read;
 432  error:
 433         mutex_unlock(&drvdata->sem);
 434         return status;
 435 }
 436
 437 static ssize_t
 438 hwicap_write(struct file *file, const char __user *buf,
 439                 size_t count, loff_t *ppos)
 440 {
 441         struct hwicap_drvdata *drvdata = file->private_data;
 442         ssize_t written = 0;
 443         ssize_t left = count;
 444         u32 *kbuf;
 445         ssize_t len;
 446         ssize_t status;
 447
 448         status = mutex_lock_interruptible(&drvdata->sem);
 449         if (status)
 450                 return status;
 451
 452         left += drvdata->write_buffer_in_use;
 453
 454         /* Only write multiples of 4 bytes. */
 455         if (left < 4) {
 456                 status = 0;
 457                 goto error;
 458         }
 459
 460         kbuf = (u32 *) __get_free_page(GFP_KERNEL);
 461         if (!kbuf) {
 462                 status = -ENOMEM;
 463                 goto error;
 464         }
 465
 466         while (left > 3) {
 467                 /* only write multiples of 4 bytes, so there might */
 468                 /* be as many as 3 bytes left (at the end). */
 469                 len = left;
 470
 471                 if (len > PAGE_SIZE)
 472                         len = PAGE_SIZE;
 473                 len &= ~3;
 474
 475                 if (drvdata->write_buffer_in_use) {
 476                         memcpy(kbuf, drvdata->write_buffer,
 477                                         drvdata->write_buffer_in_use);
 478                         if (copy_from_user(
 479                             (((char *)kbuf) + drvdata->write_buffer_in_use),
 480                             buf + written,
 481                             len - (drvdata->write_buffer_in_use))) {
 482                                 free_page((unsigned long)kbuf);
 483                                 status = -EFAULT;
 484                                 goto error;
 485                         }
 486                 } else {
 487                         if (copy_from_user(kbuf, buf + written, len)) {
 488                                 free_page((unsigned long)kbuf);
 489                                 status = -EFAULT;
 490                                 goto error;
 491                         }
 492                 }
 493
 494                 status = drvdata->config->set_configuration(drvdata,
 495                                 kbuf, len >> 2);
 496
 497                 if (status) {
 498                         free_page((unsigned long)kbuf);
 499                         status = -EFAULT;
 500                         goto error;
 501                 }
 502                 if (drvdata->write_buffer_in_use) {
 503                         len -= drvdata->write_buffer_in_use;
 504                         left -= drvdata->write_buffer_in_use;
 505                         drvdata->write_buffer_in_use = 0;
 506                 }
 507                 written += len;
 508                 left -= len;
 509         }
 510         if ((left > 0) && (left < 4)) {
 511                 if (!copy_from_user(drvdata->write_buffer,
 512                                                 buf + written, left)) {
 513                         drvdata->write_buffer_in_use = left;
 514                         written += left;
 515                         left = 0;
 516                 }
 517         }
 518
 519         free_page((unsigned long)kbuf);
 520         status = written;
 521  error:
 522         mutex_unlock(&drvdata->sem);
 523         return status;
 524 }
 525
 526 static int hwicap_open(struct inode *inode, struct file *file)
 527 {
 528         struct hwicap_drvdata *drvdata;
 529         int status;
 530
 531         mutex_lock(&hwicap_mutex);
 532         drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev);
 533
 534         status = mutex_lock_interruptible(&drvdata->sem);
 535         if (status)
 536                 goto out;
 537
 538         if (drvdata->is_open) {
 539                 status = -EBUSY;
 540                 goto error;
 541         }
 542
 543         status = hwicap_initialize_hwicap(drvdata);
 544         if (status) {
 545                 dev_err(drvdata->dev, "Failed to open file");
 546                 goto error;
 547         }
 548
 549         file->private_data = drvdata;
 550         drvdata->write_buffer_in_use = 0;
 551         drvdata->read_buffer_in_use = 0;
 552         drvdata->is_open = 1;
 553
 554  error:
 555         mutex_unlock(&drvdata->sem);
 556  out:
 557         mutex_unlock(&hwicap_mutex);
 558         return status;
 559 }
 560
 561 static int hwicap_release(struct inode *inode, struct file *file)
 562 {
 563         struct hwicap_drvdata *drvdata = file->private_data;
 564         int i;
 565         int status = 0;
 566
 567         mutex_lock(&drvdata->sem);
 568
 569         if (drvdata->write_buffer_in_use) {
 570                 /* Flush write buffer. */
 571                 for (i = drvdata->write_buffer_in_use; i < 4; i++)
 572                         drvdata->write_buffer[i] = 0;
 573
 574                 status = drvdata->config->set_configuration(drvdata,
 575                                 (u32 *) drvdata->write_buffer, 1);
 576                 if (status)
 577                         goto error;
 578         }
 579
 580         status = hwicap_command_desync(drvdata);
 581         if (status)
 582                 goto error;
 583
 584  error:
 585         drvdata->is_open = 0;
 586         mutex_unlock(&drvdata->sem);
 587         return status;
 588 }
 589
 590 static const struct file_operations hwicap_fops = {
 591         .owner = THIS_MODULE,
 592         .write = hwicap_write,
 593         .read = hwicap_read,
 594         .open = hwicap_open,
 595         .release = hwicap_release,
 596         .llseek = noop_llseek,
 597 };
 598
 599 static int hwicap_setup(struct platform_device *pdev, int id,
 600                 const struct hwicap_driver_config *config,
 601                 const struct config_registers *config_regs)
 602 {
 603         dev_t devt;
 604         struct hwicap_drvdata *drvdata = NULL;
 605         struct device *dev = &pdev->dev;
 606         int retval;
 607
 608         dev_info(dev, "Xilinx icap port driver\n");
 609
 610         mutex_lock(&icap_sem);
 611
 612         if (id < 0) {
 613                 for (id = 0; id < HWICAP_DEVICES; id++)
 614                         if (!probed_devices[id])
 615                                 break;
 616         }
 617         if (id < 0 || id >= HWICAP_DEVICES) {
 618                 mutex_unlock(&icap_sem);
 619                 dev_err(dev, "%s%i too large\n", DRIVER_NAME, id);
 620                 return -EINVAL;
 621         }
 622         if (probed_devices[id]) {
 623                 mutex_unlock(&icap_sem);
 624                 dev_err(dev, "cannot assign to %s%i; it is already in use\n",
 625                         DRIVER_NAME, id);
 626                 return -EBUSY;
 627         }
 628
 629         probed_devices[id] = 1;
 630         mutex_unlock(&icap_sem);
 631
 632         devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR + id);
 633
 634         drvdata = devm_kzalloc(dev, sizeof(struct hwicap_drvdata), GFP_KERNEL);
 635         if (!drvdata) {
 636                 retval = -ENOMEM;
 637                 goto failed;
 638         }
 639         dev_set_drvdata(dev, (void *)drvdata);
 640
 641         drvdata->base_address = devm_platform_ioremap_resource(pdev, 0);
 642         if (!drvdata->base_address) {
 643                 retval = -ENODEV;
 644                 goto failed;
 645         }
 646
 647         drvdata->devt = devt;
 648         drvdata->dev = dev;
 649         drvdata->config = config;
 650         drvdata->config_regs = config_regs;
 651
 652         mutex_init(&drvdata->sem);
 653         drvdata->is_open = 0;
 654
 655         cdev_init(&drvdata->cdev, &hwicap_fops);
 656         drvdata->cdev.owner = THIS_MODULE;
 657         retval = cdev_add(&drvdata->cdev, devt, 1);
 658         if (retval) {
 659                 dev_err(dev, "cdev_add() failed\n");
 660                 goto failed;
 661         }
 662
 663         device_create(&icap_class, dev, devt, NULL, "%s%d", DRIVER_NAME, id);
 664         return 0;               /* success */
 665
 666  failed:
 667         mutex_lock(&icap_sem);
 668         probed_devices[id] = 0;
 669         mutex_unlock(&icap_sem);
 670
 671         return retval;
 672 }
 673
 674 static struct hwicap_driver_config buffer_icap_config = {
 675         .get_configuration = buffer_icap_get_configuration,
 676         .set_configuration = buffer_icap_set_configuration,
 677         .get_status = buffer_icap_get_status,
 678         .reset = buffer_icap_reset,
 679 };
 680
 681 static struct hwicap_driver_config fifo_icap_config = {
 682         .get_configuration = fifo_icap_get_configuration,
 683         .set_configuration = fifo_icap_set_configuration,
 684         .get_status = fifo_icap_get_status,
 685         .reset = fifo_icap_reset,
 686 };
 687
 688 static int hwicap_drv_probe(struct platform_device *pdev)
 689 {
 690         const struct config_registers *regs;
 691         const struct hwicap_driver_config *config;
 692         const char *family;
 693         int id = -1;
 694
 695         config = device_get_match_data(&pdev->dev);
 696
 697         of_property_read_u32(pdev->dev.of_node, "port-number", &id);
 698
 699         /* It's most likely that we're using V4, if the family is not
 700          * specified
 701          */
 702         regs = &v4_config_registers;
 703         if (!of_property_read_string(pdev->dev.of_node, "xlnx,family", &family)) {
 704                 if (!strcmp(family, "virtex2p"))
 705                         regs = &v2_config_registers;
 706                 else if (!strcmp(family, "virtex4"))
 707                         regs = &v4_config_registers;
 708                 else if (!strcmp(family, "virtex5"))
 709                         regs = &v5_config_registers;
 710                 else if (!strcmp(family, "virtex6"))
 711                         regs = &v6_config_registers;
 712         }
 713         return hwicap_setup(pdev, id, config, regs);
 714 }
 715
 716 static void hwicap_drv_remove(struct platform_device *pdev)
 717 {
 718         struct device *dev = &pdev->dev;
 719         struct hwicap_drvdata *drvdata;
 720
 721         drvdata = dev_get_drvdata(dev);
 722
 723         device_destroy(&icap_class, drvdata->devt);
 724         cdev_del(&drvdata->cdev);
 725
 726         mutex_lock(&icap_sem);
 727         probed_devices[MINOR(dev->devt)-XHWICAP_MINOR] = 0;
 728         mutex_unlock(&icap_sem);
 729 }
 730
 731 /* Match table for device tree binding */
 732 static const struct of_device_id hwicap_of_match[] = {
 733         { .compatible = "xlnx,opb-hwicap-1.00.b", .data = &buffer_icap_config},
 734         { .compatible = "xlnx,xps-hwicap-1.00.a", .data = &fifo_icap_config},
 735         {},
 736 };
 737 MODULE_DEVICE_TABLE(of, hwicap_of_match);
 738
 739 static struct platform_driver hwicap_platform_driver = {
 740         .probe = hwicap_drv_probe,
 741         .remove_new = hwicap_drv_remove,
 742         .driver = {
 743                 .name = DRIVER_NAME,
 744                 .of_match_table = hwicap_of_match,
 745         },
 746 };
 747
 748 static int __init hwicap_module_init(void)
 749 {
 750         dev_t devt;
 751         int retval;
 752
 753         retval = class_register(&icap_class);
 754         if (retval)
 755                 return retval;
 756         mutex_init(&icap_sem);
 757
 758         devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR);
 759         retval = register_chrdev_region(devt,
 760                                         HWICAP_DEVICES,
 761                                         DRIVER_NAME);
 762         if (retval < 0)
 763                 return retval;
 764
 765         retval = platform_driver_register(&hwicap_platform_driver);
 766         if (retval)
 767                 goto failed;
 768
 769         return retval;
 770
 771  failed:
 772         unregister_chrdev_region(devt, HWICAP_DEVICES);
 773
 774         return retval;
 775 }
 776
 777 static void __exit hwicap_module_cleanup(void)
 778 {
 779         dev_t devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR);
 780
 781         class_unregister(&icap_class);
 782
 783         platform_driver_unregister(&hwicap_platform_driver);
 784
 785         unregister_chrdev_region(devt, HWICAP_DEVICES);
 786 }
 787
 788 module_init(hwicap_module_init);
 789 module_exit(hwicap_module_cleanup);
 790
 791 MODULE_AUTHOR("Xilinx, Inc; Xilinx Research Labs Group");
 792 MODULE_DESCRIPTION("Xilinx ICAP Port Driver");
 793 MODULE_LICENSE("GPL");