794 lines · c
1/*****************************************************************************2 *3 * Author: Xilinx, Inc.4 *5 * This program is free software; you can redistribute it and/or modify it6 * under the terms of the GNU General Public License as published by the7 * Free Software Foundation; either version 2 of the License, or (at your8 * 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 AND12 * 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 REPRESENTATION15 * THAT THIS IMPLEMENTATION IS FREE FROM ANY CLAIMS OF INFRINGEMENT,16 * AND YOU ARE RESPONSIBLE FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE17 * FOR YOUR IMPLEMENTATION. XILINX EXPRESSLY DISCLAIMS ANY18 * WARRANTY WHATSOEVER WITH RESPECT TO THE ADEQUACY OF THE19 * IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OR20 * REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM CLAIMS OF21 * INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS22 * FOR A PARTICULAR PURPOSE.23 *24 * (c) Copyright 2002 Xilinx Inc., Systems Engineering Group25 * (c) Copyright 2004 Xilinx Inc., Systems Engineering Group26 * (c) Copyright 2007-2008 Xilinx Inc.27 * All rights reserved.28 *29 * You should have received a copy of the GNU General Public License along30 * 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-space37 * 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 port43 * 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 a47 * corrupted first read which may occur with some hardware. The port48 * is left in a desynched state, requiring that a synch sequence be49 * transmitted before any valid configuration data. A user will have50 * exclusive access to the device while it remains open, and the state51 * of the ICAP cannot be guaranteed after the device is closed. Note52 * that a complete reset of the core and the state of the ICAP cannot53 * be performed on many versions of the cores, hence users of this54 * device should avoid making inconsistent accesses to the device. In55 * particular, accessing the read interface, without first generating56 * a write containing a readback packet can leave the ICAP in an57 * inaccessible state.58 *59 * Note that in order to use the read interface, it is first necessary60 * to write a request packet to the write interface. i.e., it is not61 * possible to simply readback the bitstream (or any configuration62 * bits) from a device without specifically requesting them first.63 * The code to craft such packets is intended to be part of the64 * user-space application code that uses this device. The simplest65 * way to use this interface is simply:66 *67 * cp foo.bit /dev/icap068 *69 * Note that unless foo.bit is an appropriately constructed partial70 * bitstream, this has a high likelihood of overwriting the design71 * 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 259103#define XHWICAP_MINOR 0104#define HWICAP_DEVICES 1105 106/* An array, which is set to true when the device is registered. */107static DEFINE_MUTEX(hwicap_mutex);108static bool probed_devices[HWICAP_DEVICES];109static struct mutex icap_sem;110 111static const struct class icap_class = {112 .name = "xilinx_config",113};114 115#define UNIMPLEMENTED 0xFFFF116 117static 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 142static 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 167static 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 192static 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 error222 *223 * This command desynchronizes the ICAP After this command, a224 * bitstream containing a NULL packet, followed by a SYNCH packet is225 * required before the ICAP will recognize commands.226 */227static 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 present242 * 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 configuration252 * 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 error257 *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 present279 * 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 present298 * 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 register307 */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 the323 * 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. This334 * may not be returned correctly, due to the design of the335 * 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 352static ssize_t353hwicap_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 437static ssize_t438hwicap_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 526static 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 561static 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 590static 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 599static 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, drvdata);640 641 drvdata->base_address = devm_platform_ioremap_resource(pdev, 0);642 if (IS_ERR(drvdata->base_address)) {643 retval = PTR_ERR(drvdata->base_address);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 674static 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 681static 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 688static 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 not700 * specified701 */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 716static 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 */732static 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};737MODULE_DEVICE_TABLE(of, hwicap_of_match);738 739static 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 748static 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 777static 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 788module_init(hwicap_module_init);789module_exit(hwicap_module_cleanup);790 791MODULE_AUTHOR("Xilinx, Inc; Xilinx Research Labs Group");792MODULE_DESCRIPTION("Xilinx ICAP Port Driver");793MODULE_LICENSE("GPL");794