| /***************************************************************************** |
| * |
| * Author: Xilinx, Inc. |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License as published by the |
| * Free Software Foundation; either version 2 of the License, or (at your |
| * option) any later version. |
| * |
| * XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS" |
| * AS A COURTESY TO YOU, SOLELY FOR USE IN DEVELOPING PROGRAMS AND |
| * SOLUTIONS FOR XILINX DEVICES. BY PROVIDING THIS DESIGN, CODE, |
| * OR INFORMATION AS ONE POSSIBLE IMPLEMENTATION OF THIS FEATURE, |
| * APPLICATION OR STANDARD, XILINX IS MAKING NO REPRESENTATION |
| * THAT THIS IMPLEMENTATION IS FREE FROM ANY CLAIMS OF INFRINGEMENT, |
| * AND YOU ARE RESPONSIBLE FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE |
| * FOR YOUR IMPLEMENTATION. XILINX EXPRESSLY DISCLAIMS ANY |
| * WARRANTY WHATSOEVER WITH RESPECT TO THE ADEQUACY OF THE |
| * IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OR |
| * REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM CLAIMS OF |
| * INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
| * FOR A PARTICULAR PURPOSE. |
| * |
| * (c) Copyright 2002 Xilinx Inc., Systems Engineering Group |
| * (c) Copyright 2004 Xilinx Inc., Systems Engineering Group |
| * (c) Copyright 2007-2008 Xilinx Inc. |
| * All rights reserved. |
| * |
| * You should have received a copy of the GNU General Public License along |
| * with this program; if not, write to the Free Software Foundation, Inc., |
| * 675 Mass Ave, Cambridge, MA 02139, USA. |
| * |
| *****************************************************************************/ |
| |
| /* |
| * This is the code behind /dev/icap* -- it allows a user-space |
| * application to use the Xilinx ICAP subsystem. |
| * |
| * The following operations are possible: |
| * |
| * open open the port and initialize for access. |
| * release release port |
| * write Write a bitstream to the configuration processor. |
| * read Read a data stream from the configuration processor. |
| * |
| * After being opened, the port is initialized and accessed to avoid a |
| * corrupted first read which may occur with some hardware. The port |
| * is left in a desynched state, requiring that a synch sequence be |
| * transmitted before any valid configuration data. A user will have |
| * exclusive access to the device while it remains open, and the state |
| * of the ICAP cannot be guaranteed after the device is closed. Note |
| * that a complete reset of the core and the state of the ICAP cannot |
| * be performed on many versions of the cores, hence users of this |
| * device should avoid making inconsistent accesses to the device. In |
| * particular, accessing the read interface, without first generating |
| * a write containing a readback packet can leave the ICAP in an |
| * inaccessible state. |
| * |
| * Note that in order to use the read interface, it is first necessary |
| * to write a request packet to the write interface. i.e., it is not |
| * possible to simply readback the bitstream (or any configuration |
| * bits) from a device without specifically requesting them first. |
| * The code to craft such packets is intended to be part of the |
| * user-space application code that uses this device. The simplest |
| * way to use this interface is simply: |
| * |
| * cp foo.bit /dev/icap0 |
| * |
| * Note that unless foo.bit is an appropriately constructed partial |
| * bitstream, this has a high likelyhood of overwriting the design |
| * currently programmed in the FPGA. |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/kernel.h> |
| #include <linux/types.h> |
| #include <linux/ioport.h> |
| #include <linux/interrupt.h> |
| #include <linux/fcntl.h> |
| #include <linux/init.h> |
| #include <linux/poll.h> |
| #include <linux/proc_fs.h> |
| #include <linux/mutex.h> |
| #include <linux/smp_lock.h> |
| #include <linux/sysctl.h> |
| #include <linux/fs.h> |
| #include <linux/cdev.h> |
| #include <linux/platform_device.h> |
| #include <linux/slab.h> |
| |
| #include <asm/io.h> |
| #include <asm/uaccess.h> |
| #include <asm/system.h> |
| |
| #ifdef CONFIG_OF |
| /* For open firmware. */ |
| #include <linux/of_device.h> |
| #include <linux/of_platform.h> |
| #endif |
| |
| #include "xilinx_hwicap.h" |
| #include "buffer_icap.h" |
| #include "fifo_icap.h" |
| |
| #define DRIVER_NAME "icap" |
| |
| #define HWICAP_REGS (0x10000) |
| |
| #define XHWICAP_MAJOR 259 |
| #define XHWICAP_MINOR 0 |
| #define HWICAP_DEVICES 1 |
| |
| /* An array, which is set to true when the device is registered. */ |
| static bool probed_devices[HWICAP_DEVICES]; |
| static struct mutex icap_sem; |
| |
| static struct class *icap_class; |
| |
| #define UNIMPLEMENTED 0xFFFF |
| |
| static const struct config_registers v2_config_registers = { |
| .CRC = 0, |
| .FAR = 1, |
| .FDRI = 2, |
| .FDRO = 3, |
| .CMD = 4, |
| .CTL = 5, |
| .MASK = 6, |
| .STAT = 7, |
| .LOUT = 8, |
| .COR = 9, |
| .MFWR = 10, |
| .FLR = 11, |
| .KEY = 12, |
| .CBC = 13, |
| .IDCODE = 14, |
| .AXSS = UNIMPLEMENTED, |
| .C0R_1 = UNIMPLEMENTED, |
| .CSOB = UNIMPLEMENTED, |
| .WBSTAR = UNIMPLEMENTED, |
| .TIMER = UNIMPLEMENTED, |
| .BOOTSTS = UNIMPLEMENTED, |
| .CTL_1 = UNIMPLEMENTED, |
| }; |
| |
| static const struct config_registers v4_config_registers = { |
| .CRC = 0, |
| .FAR = 1, |
| .FDRI = 2, |
| .FDRO = 3, |
| .CMD = 4, |
| .CTL = 5, |
| .MASK = 6, |
| .STAT = 7, |
| .LOUT = 8, |
| .COR = 9, |
| .MFWR = 10, |
| .FLR = UNIMPLEMENTED, |
| .KEY = UNIMPLEMENTED, |
| .CBC = 11, |
| .IDCODE = 12, |
| .AXSS = 13, |
| .C0R_1 = UNIMPLEMENTED, |
| .CSOB = UNIMPLEMENTED, |
| .WBSTAR = UNIMPLEMENTED, |
| .TIMER = UNIMPLEMENTED, |
| .BOOTSTS = UNIMPLEMENTED, |
| .CTL_1 = UNIMPLEMENTED, |
| }; |
| static const struct config_registers v5_config_registers = { |
| .CRC = 0, |
| .FAR = 1, |
| .FDRI = 2, |
| .FDRO = 3, |
| .CMD = 4, |
| .CTL = 5, |
| .MASK = 6, |
| .STAT = 7, |
| .LOUT = 8, |
| .COR = 9, |
| .MFWR = 10, |
| .FLR = UNIMPLEMENTED, |
| .KEY = UNIMPLEMENTED, |
| .CBC = 11, |
| .IDCODE = 12, |
| .AXSS = 13, |
| .C0R_1 = 14, |
| .CSOB = 15, |
| .WBSTAR = 16, |
| .TIMER = 17, |
| .BOOTSTS = 18, |
| .CTL_1 = 19, |
| }; |
| |
| /** |
| * hwicap_command_desync - Send a DESYNC command to the ICAP port. |
| * @drvdata: a pointer to the drvdata. |
| * |
| * This command desynchronizes the ICAP After this command, a |
| * bitstream containing a NULL packet, followed by a SYNCH packet is |
| * required before the ICAP will recognize commands. |
| */ |
| static int hwicap_command_desync(struct hwicap_drvdata *drvdata) |
| { |
| u32 buffer[4]; |
| u32 index = 0; |
| |
| /* |
| * Create the data to be written to the ICAP. |
| */ |
| buffer[index++] = hwicap_type_1_write(drvdata->config_regs->CMD) | 1; |
| buffer[index++] = XHI_CMD_DESYNCH; |
| buffer[index++] = XHI_NOOP_PACKET; |
| buffer[index++] = XHI_NOOP_PACKET; |
| |
| /* |
| * Write the data to the FIFO and intiate the transfer of data present |
| * in the FIFO to the ICAP device. |
| */ |
| return drvdata->config->set_configuration(drvdata, |
| &buffer[0], index); |
| } |
| |
| /** |
| * hwicap_get_configuration_register - Query a configuration register. |
| * @drvdata: a pointer to the drvdata. |
| * @reg: a constant which represents the configuration |
| * register value to be returned. |
| * Examples: XHI_IDCODE, XHI_FLR. |
| * @reg_data: returns the value of the register. |
| * |
| * Sends a query packet to the ICAP and then receives the response. |
| * The icap is left in Synched state. |
| */ |
| static int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata, |
| u32 reg, u32 *reg_data) |
| { |
| int status; |
| u32 buffer[6]; |
| u32 index = 0; |
| |
| /* |
| * Create the data to be written to the ICAP. |
| */ |
| buffer[index++] = XHI_DUMMY_PACKET; |
| buffer[index++] = XHI_NOOP_PACKET; |
| buffer[index++] = XHI_SYNC_PACKET; |
| buffer[index++] = XHI_NOOP_PACKET; |
| buffer[index++] = XHI_NOOP_PACKET; |
| |
| /* |
| * Write the data to the FIFO and initiate the transfer of data present |
| * in the FIFO to the ICAP device. |
| */ |
| status = drvdata->config->set_configuration(drvdata, |
| &buffer[0], index); |
| if (status) |
| return status; |
| |
| /* If the syncword was not found, then we need to start over. */ |
| status = drvdata->config->get_status(drvdata); |
| if ((status & XHI_SR_DALIGN_MASK) != XHI_SR_DALIGN_MASK) |
| return -EIO; |
| |
| index = 0; |
| buffer[index++] = hwicap_type_1_read(reg) | 1; |
| buffer[index++] = XHI_NOOP_PACKET; |
| buffer[index++] = XHI_NOOP_PACKET; |
| |
| /* |
| * Write the data to the FIFO and intiate the transfer of data present |
| * in the FIFO to the ICAP device. |
| */ |
| status = drvdata->config->set_configuration(drvdata, |
| &buffer[0], index); |
| if (status) |
| return status; |
| |
| /* |
| * Read the configuration register |
| */ |
| status = drvdata->config->get_configuration(drvdata, reg_data, 1); |
| if (status) |
| return status; |
| |
| return 0; |
| } |
| |
| static int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata) |
| { |
| int status; |
| u32 idcode; |
| |
| dev_dbg(drvdata->dev, "initializing\n"); |
| |
| /* Abort any current transaction, to make sure we have the |
| * ICAP in a good state. */ |
| dev_dbg(drvdata->dev, "Reset...\n"); |
| drvdata->config->reset(drvdata); |
| |
| dev_dbg(drvdata->dev, "Desync...\n"); |
| status = hwicap_command_desync(drvdata); |
| if (status) |
| return status; |
| |
| /* Attempt to read the IDCODE from ICAP. This |
| * may not be returned correctly, due to the design of the |
| * hardware. |
| */ |
| dev_dbg(drvdata->dev, "Reading IDCODE...\n"); |
| status = hwicap_get_configuration_register( |
| drvdata, drvdata->config_regs->IDCODE, &idcode); |
| dev_dbg(drvdata->dev, "IDCODE = %x\n", idcode); |
| if (status) |
| return status; |
| |
| dev_dbg(drvdata->dev, "Desync...\n"); |
| status = hwicap_command_desync(drvdata); |
| if (status) |
| return status; |
| |
| return 0; |
| } |
| |
| static ssize_t |
| hwicap_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) |
| { |
| struct hwicap_drvdata *drvdata = file->private_data; |
| ssize_t bytes_to_read = 0; |
| u32 *kbuf; |
| u32 words; |
| u32 bytes_remaining; |
| int status; |
| |
| status = mutex_lock_interruptible(&drvdata->sem); |
| if (status) |
| return status; |
| |
| if (drvdata->read_buffer_in_use) { |
| /* If there are leftover bytes in the buffer, just */ |
| /* return them and don't try to read more from the */ |
| /* ICAP device. */ |
| bytes_to_read = |
| (count < drvdata->read_buffer_in_use) ? count : |
| drvdata->read_buffer_in_use; |
| |
| /* Return the data currently in the read buffer. */ |
| if (copy_to_user(buf, drvdata->read_buffer, bytes_to_read)) { |
| status = -EFAULT; |
| goto error; |
| } |
| drvdata->read_buffer_in_use -= bytes_to_read; |
| memmove(drvdata->read_buffer, |
| drvdata->read_buffer + bytes_to_read, |
| 4 - bytes_to_read); |
| } else { |
| /* Get new data from the ICAP, and return was was requested. */ |
| kbuf = (u32 *) get_zeroed_page(GFP_KERNEL); |
| if (!kbuf) { |
| status = -ENOMEM; |
| goto error; |
| } |
| |
| /* The ICAP device is only able to read complete */ |
| /* words. If a number of bytes that do not correspond */ |
| /* to complete words is requested, then we read enough */ |
| /* words to get the required number of bytes, and then */ |
| /* save the remaining bytes for the next read. */ |
| |
| /* Determine the number of words to read, rounding up */ |
| /* if necessary. */ |
| words = ((count + 3) >> 2); |
| bytes_to_read = words << 2; |
| |
| if (bytes_to_read > PAGE_SIZE) |
| bytes_to_read = PAGE_SIZE; |
| |
| /* Ensure we only read a complete number of words. */ |
| bytes_remaining = bytes_to_read & 3; |
| bytes_to_read &= ~3; |
| words = bytes_to_read >> 2; |
| |
| status = drvdata->config->get_configuration(drvdata, |
| kbuf, words); |
| |
| /* If we didn't read correctly, then bail out. */ |
| if (status) { |
| free_page((unsigned long)kbuf); |
| goto error; |
| } |
| |
| /* If we fail to return the data to the user, then bail out. */ |
| if (copy_to_user(buf, kbuf, bytes_to_read)) { |
| free_page((unsigned long)kbuf); |
| status = -EFAULT; |
| goto error; |
| } |
| memcpy(drvdata->read_buffer, |
| kbuf, |
| bytes_remaining); |
| drvdata->read_buffer_in_use = bytes_remaining; |
| free_page((unsigned long)kbuf); |
| } |
| status = bytes_to_read; |
| error: |
| mutex_unlock(&drvdata->sem); |
| return status; |
| } |
| |
| static ssize_t |
| hwicap_write(struct file *file, const char __user *buf, |
| size_t count, loff_t *ppos) |
| { |
| struct hwicap_drvdata *drvdata = file->private_data; |
| ssize_t written = 0; |
| ssize_t left = count; |
| u32 *kbuf; |
| ssize_t len; |
| ssize_t status; |
| |
| status = mutex_lock_interruptible(&drvdata->sem); |
| if (status) |
| return status; |
| |
| left += drvdata->write_buffer_in_use; |
| |
| /* Only write multiples of 4 bytes. */ |
| if (left < 4) { |
| status = 0; |
| goto error; |
| } |
| |
| kbuf = (u32 *) __get_free_page(GFP_KERNEL); |
| if (!kbuf) { |
| status = -ENOMEM; |
| goto error; |
| } |
| |
| while (left > 3) { |
| /* only write multiples of 4 bytes, so there might */ |
| /* be as many as 3 bytes left (at the end). */ |
| len = left; |
| |
| if (len > PAGE_SIZE) |
| len = PAGE_SIZE; |
| len &= ~3; |
| |
| if (drvdata->write_buffer_in_use) { |
| memcpy(kbuf, drvdata->write_buffer, |
| drvdata->write_buffer_in_use); |
| if (copy_from_user( |
| (((char *)kbuf) + drvdata->write_buffer_in_use), |
| buf + written, |
| len - (drvdata->write_buffer_in_use))) { |
| free_page((unsigned long)kbuf); |
| status = -EFAULT; |
| goto error; |
| } |
| } else { |
| if (copy_from_user(kbuf, buf + written, len)) { |
| free_page((unsigned long)kbuf); |
| status = -EFAULT; |
| goto error; |
| } |
| } |
| |
| status = drvdata->config->set_configuration(drvdata, |
| kbuf, len >> 2); |
| |
| if (status) { |
| free_page((unsigned long)kbuf); |
| status = -EFAULT; |
| goto error; |
| } |
| if (drvdata->write_buffer_in_use) { |
| len -= drvdata->write_buffer_in_use; |
| left -= drvdata->write_buffer_in_use; |
| drvdata->write_buffer_in_use = 0; |
| } |
| written += len; |
| left -= len; |
| } |
| if ((left > 0) && (left < 4)) { |
| if (!copy_from_user(drvdata->write_buffer, |
| buf + written, left)) { |
| drvdata->write_buffer_in_use = left; |
| written += left; |
| left = 0; |
| } |
| } |
| |
| free_page((unsigned long)kbuf); |
| status = written; |
| error: |
| mutex_unlock(&drvdata->sem); |
| return status; |
| } |
| |
| static int hwicap_open(struct inode *inode, struct file *file) |
| { |
| struct hwicap_drvdata *drvdata; |
| int status; |
| |
| lock_kernel(); |
| drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev); |
| |
| status = mutex_lock_interruptible(&drvdata->sem); |
| if (status) |
| goto out; |
| |
| if (drvdata->is_open) { |
| status = -EBUSY; |
| goto error; |
| } |
| |
| status = hwicap_initialize_hwicap(drvdata); |
| if (status) { |
| dev_err(drvdata->dev, "Failed to open file"); |
| goto error; |
| } |
| |
| file->private_data = drvdata; |
| drvdata->write_buffer_in_use = 0; |
| drvdata->read_buffer_in_use = 0; |
| drvdata->is_open = 1; |
| |
| error: |
| mutex_unlock(&drvdata->sem); |
| out: |
| unlock_kernel(); |
| return status; |
| } |
| |
| static int hwicap_release(struct inode *inode, struct file *file) |
| { |
| struct hwicap_drvdata *drvdata = file->private_data; |
| int i; |
| int status = 0; |
| |
| mutex_lock(&drvdata->sem); |
| |
| if (drvdata->write_buffer_in_use) { |
| /* Flush write buffer. */ |
| for (i = drvdata->write_buffer_in_use; i < 4; i++) |
| drvdata->write_buffer[i] = 0; |
| |
| status = drvdata->config->set_configuration(drvdata, |
| (u32 *) drvdata->write_buffer, 1); |
| if (status) |
| goto error; |
| } |
| |
| status = hwicap_command_desync(drvdata); |
| if (status) |
| goto error; |
| |
| error: |
| drvdata->is_open = 0; |
| mutex_unlock(&drvdata->sem); |
| return status; |
| } |
| |
| static const struct file_operations hwicap_fops = { |
| .owner = THIS_MODULE, |
| .write = hwicap_write, |
| .read = hwicap_read, |
| .open = hwicap_open, |
| .release = hwicap_release, |
| }; |
| |
| static int __devinit hwicap_setup(struct device *dev, int id, |
| const struct resource *regs_res, |
| const struct hwicap_driver_config *config, |
| const struct config_registers *config_regs) |
| { |
| dev_t devt; |
| struct hwicap_drvdata *drvdata = NULL; |
| int retval = 0; |
| |
| dev_info(dev, "Xilinx icap port driver\n"); |
| |
| mutex_lock(&icap_sem); |
| |
| if (id < 0) { |
| for (id = 0; id < HWICAP_DEVICES; id++) |
| if (!probed_devices[id]) |
| break; |
| } |
| if (id < 0 || id >= HWICAP_DEVICES) { |
| mutex_unlock(&icap_sem); |
| dev_err(dev, "%s%i too large\n", DRIVER_NAME, id); |
| return -EINVAL; |
| } |
| if (probed_devices[id]) { |
| mutex_unlock(&icap_sem); |
| dev_err(dev, "cannot assign to %s%i; it is already in use\n", |
| DRIVER_NAME, id); |
| return -EBUSY; |
| } |
| |
| probed_devices[id] = 1; |
| mutex_unlock(&icap_sem); |
| |
| devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR + id); |
| |
| drvdata = kzalloc(sizeof(struct hwicap_drvdata), GFP_KERNEL); |
| if (!drvdata) { |
| dev_err(dev, "Couldn't allocate device private record\n"); |
| retval = -ENOMEM; |
| goto failed0; |
| } |
| dev_set_drvdata(dev, (void *)drvdata); |
| |
| if (!regs_res) { |
| dev_err(dev, "Couldn't get registers resource\n"); |
| retval = -EFAULT; |
| goto failed1; |
| } |
| |
| drvdata->mem_start = regs_res->start; |
| drvdata->mem_end = regs_res->end; |
| drvdata->mem_size = regs_res->end - regs_res->start + 1; |
| |
| if (!request_mem_region(drvdata->mem_start, |
| drvdata->mem_size, DRIVER_NAME)) { |
| dev_err(dev, "Couldn't lock memory region at %Lx\n", |
| (unsigned long long) regs_res->start); |
| retval = -EBUSY; |
| goto failed1; |
| } |
| |
| drvdata->devt = devt; |
| drvdata->dev = dev; |
| drvdata->base_address = ioremap(drvdata->mem_start, drvdata->mem_size); |
| if (!drvdata->base_address) { |
| dev_err(dev, "ioremap() failed\n"); |
| goto failed2; |
| } |
| |
| drvdata->config = config; |
| drvdata->config_regs = config_regs; |
| |
| mutex_init(&drvdata->sem); |
| drvdata->is_open = 0; |
| |
| dev_info(dev, "ioremap %llx to %p with size %llx\n", |
| (unsigned long long) drvdata->mem_start, |
| drvdata->base_address, |
| (unsigned long long) drvdata->mem_size); |
| |
| cdev_init(&drvdata->cdev, &hwicap_fops); |
| drvdata->cdev.owner = THIS_MODULE; |
| retval = cdev_add(&drvdata->cdev, devt, 1); |
| if (retval) { |
| dev_err(dev, "cdev_add() failed\n"); |
| goto failed3; |
| } |
| |
| device_create(icap_class, dev, devt, NULL, "%s%d", DRIVER_NAME, id); |
| return 0; /* success */ |
| |
| failed3: |
| iounmap(drvdata->base_address); |
| |
| failed2: |
| release_mem_region(regs_res->start, drvdata->mem_size); |
| |
| failed1: |
| kfree(drvdata); |
| |
| failed0: |
| mutex_lock(&icap_sem); |
| probed_devices[id] = 0; |
| mutex_unlock(&icap_sem); |
| |
| return retval; |
| } |
| |
| static struct hwicap_driver_config buffer_icap_config = { |
| .get_configuration = buffer_icap_get_configuration, |
| .set_configuration = buffer_icap_set_configuration, |
| .get_status = buffer_icap_get_status, |
| .reset = buffer_icap_reset, |
| }; |
| |
| static struct hwicap_driver_config fifo_icap_config = { |
| .get_configuration = fifo_icap_get_configuration, |
| .set_configuration = fifo_icap_set_configuration, |
| .get_status = fifo_icap_get_status, |
| .reset = fifo_icap_reset, |
| }; |
| |
| static int __devexit hwicap_remove(struct device *dev) |
| { |
| struct hwicap_drvdata *drvdata; |
| |
| drvdata = (struct hwicap_drvdata *)dev_get_drvdata(dev); |
| |
| if (!drvdata) |
| return 0; |
| |
| device_destroy(icap_class, drvdata->devt); |
| cdev_del(&drvdata->cdev); |
| iounmap(drvdata->base_address); |
| release_mem_region(drvdata->mem_start, drvdata->mem_size); |
| kfree(drvdata); |
| dev_set_drvdata(dev, NULL); |
| |
| mutex_lock(&icap_sem); |
| probed_devices[MINOR(dev->devt)-XHWICAP_MINOR] = 0; |
| mutex_unlock(&icap_sem); |
| return 0; /* success */ |
| } |
| |
| static int __devinit hwicap_drv_probe(struct platform_device *pdev) |
| { |
| struct resource *res; |
| const struct config_registers *regs; |
| const char *family; |
| |
| res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| if (!res) |
| return -ENODEV; |
| |
| /* It's most likely that we're using V4, if the family is not |
| specified */ |
| regs = &v4_config_registers; |
| family = pdev->dev.platform_data; |
| |
| if (family) { |
| if (!strcmp(family, "virtex2p")) { |
| regs = &v2_config_registers; |
| } else if (!strcmp(family, "virtex4")) { |
| regs = &v4_config_registers; |
| } else if (!strcmp(family, "virtex5")) { |
| regs = &v5_config_registers; |
| } |
| } |
| |
| return hwicap_setup(&pdev->dev, pdev->id, res, |
| &buffer_icap_config, regs); |
| } |
| |
| static int __devexit hwicap_drv_remove(struct platform_device *pdev) |
| { |
| return hwicap_remove(&pdev->dev); |
| } |
| |
| static struct platform_driver hwicap_platform_driver = { |
| .probe = hwicap_drv_probe, |
| .remove = hwicap_drv_remove, |
| .driver = { |
| .owner = THIS_MODULE, |
| .name = DRIVER_NAME, |
| }, |
| }; |
| |
| /* --------------------------------------------------------------------- |
| * OF bus binding |
| */ |
| |
| #if defined(CONFIG_OF) |
| static int __devinit |
| hwicap_of_probe(struct platform_device *op, const struct of_device_id *match) |
| { |
| struct resource res; |
| const unsigned int *id; |
| const char *family; |
| int rc; |
| const struct hwicap_driver_config *config = match->data; |
| const struct config_registers *regs; |
| |
| dev_dbg(&op->dev, "hwicap_of_probe(%p, %p)\n", op, match); |
| |
| rc = of_address_to_resource(op->dev.of_node, 0, &res); |
| if (rc) { |
| dev_err(&op->dev, "invalid address\n"); |
| return rc; |
| } |
| |
| id = of_get_property(op->dev.of_node, "port-number", NULL); |
| |
| /* It's most likely that we're using V4, if the family is not |
| specified */ |
| regs = &v4_config_registers; |
| family = of_get_property(op->dev.of_node, "xlnx,family", NULL); |
| |
| if (family) { |
| if (!strcmp(family, "virtex2p")) { |
| regs = &v2_config_registers; |
| } else if (!strcmp(family, "virtex4")) { |
| regs = &v4_config_registers; |
| } else if (!strcmp(family, "virtex5")) { |
| regs = &v5_config_registers; |
| } |
| } |
| return hwicap_setup(&op->dev, id ? *id : -1, &res, config, |
| regs); |
| } |
| |
| static int __devexit hwicap_of_remove(struct platform_device *op) |
| { |
| return hwicap_remove(&op->dev); |
| } |
| |
| /* Match table for of_platform binding */ |
| static const struct of_device_id __devinitconst hwicap_of_match[] = { |
| { .compatible = "xlnx,opb-hwicap-1.00.b", .data = &buffer_icap_config}, |
| { .compatible = "xlnx,xps-hwicap-1.00.a", .data = &fifo_icap_config}, |
| {}, |
| }; |
| MODULE_DEVICE_TABLE(of, hwicap_of_match); |
| |
| static struct of_platform_driver hwicap_of_driver = { |
| .probe = hwicap_of_probe, |
| .remove = __devexit_p(hwicap_of_remove), |
| .driver = { |
| .name = DRIVER_NAME, |
| .owner = THIS_MODULE, |
| .of_match_table = hwicap_of_match, |
| }, |
| }; |
| |
| /* Registration helpers to keep the number of #ifdefs to a minimum */ |
| static inline int __init hwicap_of_register(void) |
| { |
| pr_debug("hwicap: calling of_register_platform_driver()\n"); |
| return of_register_platform_driver(&hwicap_of_driver); |
| } |
| |
| static inline void __exit hwicap_of_unregister(void) |
| { |
| of_unregister_platform_driver(&hwicap_of_driver); |
| } |
| #else /* CONFIG_OF */ |
| /* CONFIG_OF not enabled; do nothing helpers */ |
| static inline int __init hwicap_of_register(void) { return 0; } |
| static inline void __exit hwicap_of_unregister(void) { } |
| #endif /* CONFIG_OF */ |
| |
| static int __init hwicap_module_init(void) |
| { |
| dev_t devt; |
| int retval; |
| |
| icap_class = class_create(THIS_MODULE, "xilinx_config"); |
| mutex_init(&icap_sem); |
| |
| devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR); |
| retval = register_chrdev_region(devt, |
| HWICAP_DEVICES, |
| DRIVER_NAME); |
| if (retval < 0) |
| return retval; |
| |
| retval = platform_driver_register(&hwicap_platform_driver); |
| |
| if (retval) |
| goto failed1; |
| |
| retval = hwicap_of_register(); |
| |
| if (retval) |
| goto failed2; |
| |
| return retval; |
| |
| failed2: |
| platform_driver_unregister(&hwicap_platform_driver); |
| |
| failed1: |
| unregister_chrdev_region(devt, HWICAP_DEVICES); |
| |
| return retval; |
| } |
| |
| static void __exit hwicap_module_cleanup(void) |
| { |
| dev_t devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR); |
| |
| class_destroy(icap_class); |
| |
| platform_driver_unregister(&hwicap_platform_driver); |
| |
| hwicap_of_unregister(); |
| |
| unregister_chrdev_region(devt, HWICAP_DEVICES); |
| } |
| |
| module_init(hwicap_module_init); |
| module_exit(hwicap_module_cleanup); |
| |
| MODULE_AUTHOR("Xilinx, Inc; Xilinx Research Labs Group"); |
| MODULE_DESCRIPTION("Xilinx ICAP Port Driver"); |
| MODULE_LICENSE("GPL"); |