linux/drivers/char/xilinx_hwicap/xilinx_hwicap.c
<<
>>
Prefs
   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
  93#ifdef CONFIG_OF
  94/* For open firmware. */
  95#include <linux/of_address.h>
  96#include <linux/of_device.h>
  97#include <linux/of_platform.h>
  98#endif
  99
 100#include "xilinx_hwicap.h"
 101#include "buffer_icap.h"
 102#include "fifo_icap.h"
 103
 104#define DRIVER_NAME "icap"
 105
 106#define HWICAP_REGS   (0x10000)
 107
 108#define XHWICAP_MAJOR 259
 109#define XHWICAP_MINOR 0
 110#define HWICAP_DEVICES 1
 111
 112/* An array, which is set to true when the device is registered. */
 113static DEFINE_MUTEX(hwicap_mutex);
 114static bool probed_devices[HWICAP_DEVICES];
 115static struct mutex icap_sem;
 116
 117static struct class *icap_class;
 118
 119#define UNIMPLEMENTED 0xFFFF
 120
 121static const struct config_registers v2_config_registers = {
 122        .CRC = 0,
 123        .FAR = 1,
 124        .FDRI = 2,
 125        .FDRO = 3,
 126        .CMD = 4,
 127        .CTL = 5,
 128        .MASK = 6,
 129        .STAT = 7,
 130        .LOUT = 8,
 131        .COR = 9,
 132        .MFWR = 10,
 133        .FLR = 11,
 134        .KEY = 12,
 135        .CBC = 13,
 136        .IDCODE = 14,
 137        .AXSS = UNIMPLEMENTED,
 138        .C0R_1 = UNIMPLEMENTED,
 139        .CSOB = UNIMPLEMENTED,
 140        .WBSTAR = UNIMPLEMENTED,
 141        .TIMER = UNIMPLEMENTED,
 142        .BOOTSTS = UNIMPLEMENTED,
 143        .CTL_1 = UNIMPLEMENTED,
 144};
 145
 146static const struct config_registers v4_config_registers = {
 147        .CRC = 0,
 148        .FAR = 1,
 149        .FDRI = 2,
 150        .FDRO = 3,
 151        .CMD = 4,
 152        .CTL = 5,
 153        .MASK = 6,
 154        .STAT = 7,
 155        .LOUT = 8,
 156        .COR = 9,
 157        .MFWR = 10,
 158        .FLR = UNIMPLEMENTED,
 159        .KEY = UNIMPLEMENTED,
 160        .CBC = 11,
 161        .IDCODE = 12,
 162        .AXSS = 13,
 163        .C0R_1 = UNIMPLEMENTED,
 164        .CSOB = UNIMPLEMENTED,
 165        .WBSTAR = UNIMPLEMENTED,
 166        .TIMER = UNIMPLEMENTED,
 167        .BOOTSTS = UNIMPLEMENTED,
 168        .CTL_1 = UNIMPLEMENTED,
 169};
 170
 171static 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
 196static const struct config_registers v6_config_registers = {
 197        .CRC = 0,
 198        .FAR = 1,
 199        .FDRI = 2,
 200        .FDRO = 3,
 201        .CMD = 4,
 202        .CTL = 5,
 203        .MASK = 6,
 204        .STAT = 7,
 205        .LOUT = 8,
 206        .COR = 9,
 207        .MFWR = 10,
 208        .FLR = UNIMPLEMENTED,
 209        .KEY = UNIMPLEMENTED,
 210        .CBC = 11,
 211        .IDCODE = 12,
 212        .AXSS = 13,
 213        .C0R_1 = 14,
 214        .CSOB = 15,
 215        .WBSTAR = 16,
 216        .TIMER = 17,
 217        .BOOTSTS = 22,
 218        .CTL_1 = 24,
 219};
 220
 221/**
 222 * hwicap_command_desync - Send a DESYNC command to the ICAP port.
 223 * @drvdata: a pointer to the drvdata.
 224 *
 225 * This command desynchronizes the ICAP After this command, a
 226 * bitstream containing a NULL packet, followed by a SYNCH packet is
 227 * required before the ICAP will recognize commands.
 228 */
 229static int hwicap_command_desync(struct hwicap_drvdata *drvdata)
 230{
 231        u32 buffer[4];
 232        u32 index = 0;
 233
 234        /*
 235         * Create the data to be written to the ICAP.
 236         */
 237        buffer[index++] = hwicap_type_1_write(drvdata->config_regs->CMD) | 1;
 238        buffer[index++] = XHI_CMD_DESYNCH;
 239        buffer[index++] = XHI_NOOP_PACKET;
 240        buffer[index++] = XHI_NOOP_PACKET;
 241
 242        /*
 243         * Write the data to the FIFO and intiate the transfer of data present
 244         * in the FIFO to the ICAP device.
 245         */
 246        return drvdata->config->set_configuration(drvdata,
 247                        &buffer[0], index);
 248}
 249
 250/**
 251 * hwicap_get_configuration_register - Query a configuration register.
 252 * @drvdata: a pointer to the drvdata.
 253 * @reg: a constant which represents the configuration
 254 *              register value to be returned.
 255 *              Examples:  XHI_IDCODE, XHI_FLR.
 256 * @reg_data: returns the value of the register.
 257 *
 258 * Sends a query packet to the ICAP and then receives the response.
 259 * The icap is left in Synched state.
 260 */
 261static 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 intiate 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
 315static 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        dev_dbg(drvdata->dev, "Reset...\n");
 325        drvdata->config->reset(drvdata);
 326
 327        dev_dbg(drvdata->dev, "Desync...\n");
 328        status = hwicap_command_desync(drvdata);
 329        if (status)
 330                return status;
 331
 332        /* Attempt to read the IDCODE from ICAP.  This
 333         * may not be returned correctly, due to the design of the
 334         * hardware.
 335         */
 336        dev_dbg(drvdata->dev, "Reading IDCODE...\n");
 337        status = hwicap_get_configuration_register(
 338                        drvdata, drvdata->config_regs->IDCODE, &idcode);
 339        dev_dbg(drvdata->dev, "IDCODE = %x\n", idcode);
 340        if (status)
 341                return status;
 342
 343        dev_dbg(drvdata->dev, "Desync...\n");
 344        status = hwicap_command_desync(drvdata);
 345        if (status)
 346                return status;
 347
 348        return 0;
 349}
 350
 351static ssize_t
 352hwicap_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 353{
 354        struct hwicap_drvdata *drvdata = file->private_data;
 355        ssize_t bytes_to_read = 0;
 356        u32 *kbuf;
 357        u32 words;
 358        u32 bytes_remaining;
 359        int status;
 360
 361        status = mutex_lock_interruptible(&drvdata->sem);
 362        if (status)
 363                return status;
 364
 365        if (drvdata->read_buffer_in_use) {
 366                /* If there are leftover bytes in the buffer, just */
 367                /* return them and don't try to read more from the */
 368                /* ICAP device. */
 369                bytes_to_read =
 370                        (count < drvdata->read_buffer_in_use) ? count :
 371                        drvdata->read_buffer_in_use;
 372
 373                /* Return the data currently in the read buffer. */
 374                if (copy_to_user(buf, drvdata->read_buffer, bytes_to_read)) {
 375                        status = -EFAULT;
 376                        goto error;
 377                }
 378                drvdata->read_buffer_in_use -= bytes_to_read;
 379                memmove(drvdata->read_buffer,
 380                       drvdata->read_buffer + bytes_to_read,
 381                       4 - bytes_to_read);
 382        } else {
 383                /* Get new data from the ICAP, and return was was requested. */
 384                kbuf = (u32 *) get_zeroed_page(GFP_KERNEL);
 385                if (!kbuf) {
 386                        status = -ENOMEM;
 387                        goto error;
 388                }
 389
 390                /* The ICAP device is only able to read complete */
 391                /* words.  If a number of bytes that do not correspond */
 392                /* to complete words is requested, then we read enough */
 393                /* words to get the required number of bytes, and then */
 394                /* save the remaining bytes for the next read. */
 395
 396                /* Determine the number of words to read, rounding up */
 397                /* if necessary. */
 398                words = ((count + 3) >> 2);
 399                bytes_to_read = words << 2;
 400
 401                if (bytes_to_read > PAGE_SIZE)
 402                        bytes_to_read = PAGE_SIZE;
 403
 404                /* Ensure we only read a complete number of words. */
 405                bytes_remaining = bytes_to_read & 3;
 406                bytes_to_read &= ~3;
 407                words = bytes_to_read >> 2;
 408
 409                status = drvdata->config->get_configuration(drvdata,
 410                                kbuf, words);
 411
 412                /* If we didn't read correctly, then bail out. */
 413                if (status) {
 414                        free_page((unsigned long)kbuf);
 415                        goto error;
 416                }
 417
 418                /* If we fail to return the data to the user, then bail out. */
 419                if (copy_to_user(buf, kbuf, bytes_to_read)) {
 420                        free_page((unsigned long)kbuf);
 421                        status = -EFAULT;
 422                        goto error;
 423                }
 424                memcpy(drvdata->read_buffer,
 425                       kbuf,
 426                       bytes_remaining);
 427                drvdata->read_buffer_in_use = bytes_remaining;
 428                free_page((unsigned long)kbuf);
 429        }
 430        status = bytes_to_read;
 431 error:
 432        mutex_unlock(&drvdata->sem);
 433        return status;
 434}
 435
 436static ssize_t
 437hwicap_write(struct file *file, const char __user *buf,
 438                size_t count, loff_t *ppos)
 439{
 440        struct hwicap_drvdata *drvdata = file->private_data;
 441        ssize_t written = 0;
 442        ssize_t left = count;
 443        u32 *kbuf;
 444        ssize_t len;
 445        ssize_t status;
 446
 447        status = mutex_lock_interruptible(&drvdata->sem);
 448        if (status)
 449                return status;
 450
 451        left += drvdata->write_buffer_in_use;
 452
 453        /* Only write multiples of 4 bytes. */
 454        if (left < 4) {
 455                status = 0;
 456                goto error;
 457        }
 458
 459        kbuf = (u32 *) __get_free_page(GFP_KERNEL);
 460        if (!kbuf) {
 461                status = -ENOMEM;
 462                goto error;
 463        }
 464
 465        while (left > 3) {
 466                /* only write multiples of 4 bytes, so there might */
 467                /* be as many as 3 bytes left (at the end). */
 468                len = left;
 469
 470                if (len > PAGE_SIZE)
 471                        len = PAGE_SIZE;
 472                len &= ~3;
 473
 474                if (drvdata->write_buffer_in_use) {
 475                        memcpy(kbuf, drvdata->write_buffer,
 476                                        drvdata->write_buffer_in_use);
 477                        if (copy_from_user(
 478                            (((char *)kbuf) + drvdata->write_buffer_in_use),
 479                            buf + written,
 480                            len - (drvdata->write_buffer_in_use))) {
 481                                free_page((unsigned long)kbuf);
 482                                status = -EFAULT;
 483                                goto error;
 484                        }
 485                } else {
 486                        if (copy_from_user(kbuf, buf + written, len)) {
 487                                free_page((unsigned long)kbuf);
 488                                status = -EFAULT;
 489                                goto error;
 490                        }
 491                }
 492
 493                status = drvdata->config->set_configuration(drvdata,
 494                                kbuf, len >> 2);
 495
 496                if (status) {
 497                        free_page((unsigned long)kbuf);
 498                        status = -EFAULT;
 499                        goto error;
 500                }
 501                if (drvdata->write_buffer_in_use) {
 502                        len -= drvdata->write_buffer_in_use;
 503                        left -= drvdata->write_buffer_in_use;
 504                        drvdata->write_buffer_in_use = 0;
 505                }
 506                written += len;
 507                left -= len;
 508        }
 509        if ((left > 0) && (left < 4)) {
 510                if (!copy_from_user(drvdata->write_buffer,
 511                                                buf + written, left)) {
 512                        drvdata->write_buffer_in_use = left;
 513                        written += left;
 514                        left = 0;
 515                }
 516        }
 517
 518        free_page((unsigned long)kbuf);
 519        status = written;
 520 error:
 521        mutex_unlock(&drvdata->sem);
 522        return status;
 523}
 524
 525static int hwicap_open(struct inode *inode, struct file *file)
 526{
 527        struct hwicap_drvdata *drvdata;
 528        int status;
 529
 530        mutex_lock(&hwicap_mutex);
 531        drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev);
 532
 533        status = mutex_lock_interruptible(&drvdata->sem);
 534        if (status)
 535                goto out;
 536
 537        if (drvdata->is_open) {
 538                status = -EBUSY;
 539                goto error;
 540        }
 541
 542        status = hwicap_initialize_hwicap(drvdata);
 543        if (status) {
 544                dev_err(drvdata->dev, "Failed to open file");
 545                goto error;
 546        }
 547
 548        file->private_data = drvdata;
 549        drvdata->write_buffer_in_use = 0;
 550        drvdata->read_buffer_in_use = 0;
 551        drvdata->is_open = 1;
 552
 553 error:
 554        mutex_unlock(&drvdata->sem);
 555 out:
 556        mutex_unlock(&hwicap_mutex);
 557        return status;
 558}
 559
 560static int hwicap_release(struct inode *inode, struct file *file)
 561{
 562        struct hwicap_drvdata *drvdata = file->private_data;
 563        int i;
 564        int status = 0;
 565
 566        mutex_lock(&drvdata->sem);
 567
 568        if (drvdata->write_buffer_in_use) {
 569                /* Flush write buffer. */
 570                for (i = drvdata->write_buffer_in_use; i < 4; i++)
 571                        drvdata->write_buffer[i] = 0;
 572
 573                status = drvdata->config->set_configuration(drvdata,
 574                                (u32 *) drvdata->write_buffer, 1);
 575                if (status)
 576                        goto error;
 577        }
 578
 579        status = hwicap_command_desync(drvdata);
 580        if (status)
 581                goto error;
 582
 583 error:
 584        drvdata->is_open = 0;
 585        mutex_unlock(&drvdata->sem);
 586        return status;
 587}
 588
 589static const struct file_operations hwicap_fops = {
 590        .owner = THIS_MODULE,
 591        .write = hwicap_write,
 592        .read = hwicap_read,
 593        .open = hwicap_open,
 594        .release = hwicap_release,
 595        .llseek = noop_llseek,
 596};
 597
 598static int hwicap_setup(struct device *dev, int id,
 599                const struct resource *regs_res,
 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        int retval = 0;
 606
 607        dev_info(dev, "Xilinx icap port driver\n");
 608
 609        mutex_lock(&icap_sem);
 610
 611        if (id < 0) {
 612                for (id = 0; id < HWICAP_DEVICES; id++)
 613                        if (!probed_devices[id])
 614                                break;
 615        }
 616        if (id < 0 || id >= HWICAP_DEVICES) {
 617                mutex_unlock(&icap_sem);
 618                dev_err(dev, "%s%i too large\n", DRIVER_NAME, id);
 619                return -EINVAL;
 620        }
 621        if (probed_devices[id]) {
 622                mutex_unlock(&icap_sem);
 623                dev_err(dev, "cannot assign to %s%i; it is already in use\n",
 624                        DRIVER_NAME, id);
 625                return -EBUSY;
 626        }
 627
 628        probed_devices[id] = 1;
 629        mutex_unlock(&icap_sem);
 630
 631        devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR + id);
 632
 633        drvdata = kzalloc(sizeof(struct hwicap_drvdata), GFP_KERNEL);
 634        if (!drvdata) {
 635                dev_err(dev, "Couldn't allocate device private record\n");
 636                retval = -ENOMEM;
 637                goto failed0;
 638        }
 639        dev_set_drvdata(dev, (void *)drvdata);
 640
 641        if (!regs_res) {
 642                dev_err(dev, "Couldn't get registers resource\n");
 643                retval = -EFAULT;
 644                goto failed1;
 645        }
 646
 647        drvdata->mem_start = regs_res->start;
 648        drvdata->mem_end = regs_res->end;
 649        drvdata->mem_size = resource_size(regs_res);
 650
 651        if (!request_mem_region(drvdata->mem_start,
 652                                        drvdata->mem_size, DRIVER_NAME)) {
 653                dev_err(dev, "Couldn't lock memory region at %Lx\n",
 654                        (unsigned long long) regs_res->start);
 655                retval = -EBUSY;
 656                goto failed1;
 657        }
 658
 659        drvdata->devt = devt;
 660        drvdata->dev = dev;
 661        drvdata->base_address = ioremap(drvdata->mem_start, drvdata->mem_size);
 662        if (!drvdata->base_address) {
 663                dev_err(dev, "ioremap() failed\n");
 664                goto failed2;
 665        }
 666
 667        drvdata->config = config;
 668        drvdata->config_regs = config_regs;
 669
 670        mutex_init(&drvdata->sem);
 671        drvdata->is_open = 0;
 672
 673        dev_info(dev, "ioremap %llx to %p with size %llx\n",
 674                 (unsigned long long) drvdata->mem_start,
 675                 drvdata->base_address,
 676                 (unsigned long long) drvdata->mem_size);
 677
 678        cdev_init(&drvdata->cdev, &hwicap_fops);
 679        drvdata->cdev.owner = THIS_MODULE;
 680        retval = cdev_add(&drvdata->cdev, devt, 1);
 681        if (retval) {
 682                dev_err(dev, "cdev_add() failed\n");
 683                goto failed3;
 684        }
 685
 686        device_create(icap_class, dev, devt, NULL, "%s%d", DRIVER_NAME, id);
 687        return 0;               /* success */
 688
 689 failed3:
 690        iounmap(drvdata->base_address);
 691
 692 failed2:
 693        release_mem_region(regs_res->start, drvdata->mem_size);
 694
 695 failed1:
 696        kfree(drvdata);
 697
 698 failed0:
 699        mutex_lock(&icap_sem);
 700        probed_devices[id] = 0;
 701        mutex_unlock(&icap_sem);
 702
 703        return retval;
 704}
 705
 706static struct hwicap_driver_config buffer_icap_config = {
 707        .get_configuration = buffer_icap_get_configuration,
 708        .set_configuration = buffer_icap_set_configuration,
 709        .get_status = buffer_icap_get_status,
 710        .reset = buffer_icap_reset,
 711};
 712
 713static struct hwicap_driver_config fifo_icap_config = {
 714        .get_configuration = fifo_icap_get_configuration,
 715        .set_configuration = fifo_icap_set_configuration,
 716        .get_status = fifo_icap_get_status,
 717        .reset = fifo_icap_reset,
 718};
 719
 720static int hwicap_remove(struct device *dev)
 721{
 722        struct hwicap_drvdata *drvdata;
 723
 724        drvdata = (struct hwicap_drvdata *)dev_get_drvdata(dev);
 725
 726        if (!drvdata)
 727                return 0;
 728
 729        device_destroy(icap_class, drvdata->devt);
 730        cdev_del(&drvdata->cdev);
 731        iounmap(drvdata->base_address);
 732        release_mem_region(drvdata->mem_start, drvdata->mem_size);
 733        kfree(drvdata);
 734        dev_set_drvdata(dev, NULL);
 735
 736        mutex_lock(&icap_sem);
 737        probed_devices[MINOR(dev->devt)-XHWICAP_MINOR] = 0;
 738        mutex_unlock(&icap_sem);
 739        return 0;               /* success */
 740}
 741
 742#ifdef CONFIG_OF
 743static int hwicap_of_probe(struct platform_device *op,
 744                                     const struct hwicap_driver_config *config)
 745{
 746        struct resource res;
 747        const unsigned int *id;
 748        const char *family;
 749        int rc;
 750        const struct config_registers *regs;
 751
 752
 753        rc = of_address_to_resource(op->dev.of_node, 0, &res);
 754        if (rc) {
 755                dev_err(&op->dev, "invalid address\n");
 756                return rc;
 757        }
 758
 759        id = of_get_property(op->dev.of_node, "port-number", NULL);
 760
 761        /* It's most likely that we're using V4, if the family is not
 762           specified */
 763        regs = &v4_config_registers;
 764        family = of_get_property(op->dev.of_node, "xlnx,family", NULL);
 765
 766        if (family) {
 767                if (!strcmp(family, "virtex2p")) {
 768                        regs = &v2_config_registers;
 769                } else if (!strcmp(family, "virtex4")) {
 770                        regs = &v4_config_registers;
 771                } else if (!strcmp(family, "virtex5")) {
 772                        regs = &v5_config_registers;
 773                } else if (!strcmp(family, "virtex6")) {
 774                        regs = &v6_config_registers;
 775                }
 776        }
 777        return hwicap_setup(&op->dev, id ? *id : -1, &res, config,
 778                        regs);
 779}
 780#else
 781static inline int hwicap_of_probe(struct platform_device *op,
 782                                  const struct hwicap_driver_config *config)
 783{
 784        return -EINVAL;
 785}
 786#endif /* CONFIG_OF */
 787
 788static const struct of_device_id hwicap_of_match[];
 789static int hwicap_drv_probe(struct platform_device *pdev)
 790{
 791        const struct of_device_id *match;
 792        struct resource *res;
 793        const struct config_registers *regs;
 794        const char *family;
 795
 796        match = of_match_device(hwicap_of_match, &pdev->dev);
 797        if (match)
 798                return hwicap_of_probe(pdev, match->data);
 799
 800        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 801        if (!res)
 802                return -ENODEV;
 803
 804        /* It's most likely that we're using V4, if the family is not
 805           specified */
 806        regs = &v4_config_registers;
 807        family = pdev->dev.platform_data;
 808
 809        if (family) {
 810                if (!strcmp(family, "virtex2p")) {
 811                        regs = &v2_config_registers;
 812                } else if (!strcmp(family, "virtex4")) {
 813                        regs = &v4_config_registers;
 814                } else if (!strcmp(family, "virtex5")) {
 815                        regs = &v5_config_registers;
 816                } else if (!strcmp(family, "virtex6")) {
 817                        regs = &v6_config_registers;
 818                }
 819        }
 820
 821        return hwicap_setup(&pdev->dev, pdev->id, res,
 822                        &buffer_icap_config, regs);
 823}
 824
 825static int hwicap_drv_remove(struct platform_device *pdev)
 826{
 827        return hwicap_remove(&pdev->dev);
 828}
 829
 830#ifdef CONFIG_OF
 831/* Match table for device tree binding */
 832static const struct of_device_id hwicap_of_match[] = {
 833        { .compatible = "xlnx,opb-hwicap-1.00.b", .data = &buffer_icap_config},
 834        { .compatible = "xlnx,xps-hwicap-1.00.a", .data = &fifo_icap_config},
 835        {},
 836};
 837MODULE_DEVICE_TABLE(of, hwicap_of_match);
 838#else
 839#define hwicap_of_match NULL
 840#endif
 841
 842static struct platform_driver hwicap_platform_driver = {
 843        .probe = hwicap_drv_probe,
 844        .remove = hwicap_drv_remove,
 845        .driver = {
 846                .owner = THIS_MODULE,
 847                .name = DRIVER_NAME,
 848                .of_match_table = hwicap_of_match,
 849        },
 850};
 851
 852static int __init hwicap_module_init(void)
 853{
 854        dev_t devt;
 855        int retval;
 856
 857        icap_class = class_create(THIS_MODULE, "xilinx_config");
 858        mutex_init(&icap_sem);
 859
 860        devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR);
 861        retval = register_chrdev_region(devt,
 862                                        HWICAP_DEVICES,
 863                                        DRIVER_NAME);
 864        if (retval < 0)
 865                return retval;
 866
 867        retval = platform_driver_register(&hwicap_platform_driver);
 868        if (retval)
 869                goto failed;
 870
 871        return retval;
 872
 873 failed:
 874        unregister_chrdev_region(devt, HWICAP_DEVICES);
 875
 876        return retval;
 877}
 878
 879static void __exit hwicap_module_cleanup(void)
 880{
 881        dev_t devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR);
 882
 883        class_destroy(icap_class);
 884
 885        platform_driver_unregister(&hwicap_platform_driver);
 886
 887        unregister_chrdev_region(devt, HWICAP_DEVICES);
 888}
 889
 890module_init(hwicap_module_init);
 891module_exit(hwicap_module_cleanup);
 892
 893MODULE_AUTHOR("Xilinx, Inc; Xilinx Research Labs Group");
 894MODULE_DESCRIPTION("Xilinx ICAP Port Driver");
 895MODULE_LICENSE("GPL");
 896