1 /*****************************************************************************
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.
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.
24 * Xilinx products are not intended for use in life support appliances,
25 * devices, or systems. Use in such applications is expressly prohibited.
27 * (c) Copyright 2002 Xilinx Inc., Systems Engineering Group
28 * (c) Copyright 2004 Xilinx Inc., Systems Engineering Group
29 * (c) Copyright 2007-2008 Xilinx Inc.
30 * All rights reserved.
32 * You should have received a copy of the GNU General Public License along
33 * with this program; if not, write to the Free Software Foundation, Inc.,
34 * 675 Mass Ave, Cambridge, MA 02139, USA.
36 *****************************************************************************/
39 * This is the code behind /dev/xilinx_icap -- it allows a user-space
40 * application to use the Xilinx ICAP subsystem.
42 * The following operations are possible:
44 * open open the port and initialize for access.
45 * release release port
46 * write Write a bitstream to the configuration processor.
47 * read Read a data stream from the configuration processor.
49 * After being opened, the port is initialized and accessed to avoid a
50 * corrupted first read which may occur with some hardware. The port
51 * is left in a desynched state, requiring that a synch sequence be
52 * transmitted before any valid configuration data. A user will have
53 * exclusive access to the device while it remains open, and the state
54 * of the ICAP cannot be guaranteed after the device is closed. Note
55 * that a complete reset of the core and the state of the ICAP cannot
56 * be performed on many versions of the cores, hence users of this
57 * device should avoid making inconsistent accesses to the device. In
58 * particular, accessing the read interface, without first generating
59 * a write containing a readback packet can leave the ICAP in an
62 * Note that in order to use the read interface, it is first necessary
63 * to write a request packet to the write interface. i.e., it is not
64 * possible to simply readback the bitstream (or any configuration
65 * bits) from a device without specifically requesting them first.
66 * The code to craft such packets is intended to be part of the
67 * user-space application code that uses this device. The simplest
68 * way to use this interface is simply:
70 * cp foo.bit /dev/xilinx_icap
72 * Note that unless foo.bit is an appropriately constructed partial
73 * bitstream, this has a high likelyhood of overwriting the design
74 * currently programmed in the FPGA.
77 #include <linux/version.h>
78 #include <linux/module.h>
79 #include <linux/kernel.h>
80 #include <linux/types.h>
81 #include <linux/ioport.h>
82 #include <linux/interrupt.h>
83 #include <linux/fcntl.h>
84 #include <linux/init.h>
85 #include <linux/poll.h>
86 #include <linux/proc_fs.h>
87 #include <asm/semaphore.h>
88 #include <linux/sysctl.h>
89 #include <linux/version.h>
91 #include <linux/cdev.h>
92 #include <linux/platform_device.h>
95 #include <asm/uaccess.h>
96 #include <asm/system.h>
99 /* For open firmware. */
100 #include <linux/of_device.h>
101 #include <linux/of_platform.h>
104 #include "xilinx_hwicap.h"
105 #include "buffer_icap.h"
106 #include "fifo_icap.h"
108 #define DRIVER_NAME "xilinx_icap"
110 #define HWICAP_REGS (0x10000)
112 /* dynamically allocate device number */
113 static int xhwicap_major;
114 static int xhwicap_minor;
115 #define HWICAP_DEVICES 1
117 module_param(xhwicap_major, int, S_IRUGO);
118 module_param(xhwicap_minor, int, S_IRUGO);
120 /* An array, which is set to true when the device is registered. */
121 static bool probed_devices[HWICAP_DEVICES];
123 static struct class *icap_class;
125 #define UNIMPLEMENTED 0xFFFF
127 static const struct config_registers v2_config_registers = {
143 .AXSS = UNIMPLEMENTED,
144 .C0R_1 = UNIMPLEMENTED,
145 .CSOB = UNIMPLEMENTED,
146 .WBSTAR = UNIMPLEMENTED,
147 .TIMER = UNIMPLEMENTED,
148 .BOOTSTS = UNIMPLEMENTED,
149 .CTL_1 = UNIMPLEMENTED,
152 static const struct config_registers v4_config_registers = {
164 .FLR = UNIMPLEMENTED,
165 .KEY = UNIMPLEMENTED,
169 .C0R_1 = UNIMPLEMENTED,
170 .CSOB = UNIMPLEMENTED,
171 .WBSTAR = UNIMPLEMENTED,
172 .TIMER = UNIMPLEMENTED,
173 .BOOTSTS = UNIMPLEMENTED,
174 .CTL_1 = UNIMPLEMENTED,
176 static const struct config_registers v5_config_registers = {
188 .FLR = UNIMPLEMENTED,
189 .KEY = UNIMPLEMENTED,
202 * hwicap_command_desync: Send a DESYNC command to the ICAP port.
203 * @parameter drvdata: a pointer to the drvdata.
205 * This command desynchronizes the ICAP After this command, a
206 * bitstream containing a NULL packet, followed by a SYNCH packet is
207 * required before the ICAP will recognize commands.
209 int hwicap_command_desync(struct hwicap_drvdata *drvdata)
215 * Create the data to be written to the ICAP.
217 buffer[index++] = hwicap_type_1_write(drvdata->config_regs->CMD) | 1;
218 buffer[index++] = XHI_CMD_DESYNCH;
219 buffer[index++] = XHI_NOOP_PACKET;
220 buffer[index++] = XHI_NOOP_PACKET;
223 * Write the data to the FIFO and intiate the transfer of data present
224 * in the FIFO to the ICAP device.
226 return drvdata->config->set_configuration(drvdata,
231 * hwicap_command_capture: Send a CAPTURE command to the ICAP port.
232 * @parameter drvdata: a pointer to the drvdata.
234 * This command captures all of the flip flop states so they will be
235 * available during readback. One can use this command instead of
236 * enabling the CAPTURE block in the design.
238 int hwicap_command_capture(struct hwicap_drvdata *drvdata)
244 * Create the data to be written to the ICAP.
246 buffer[index++] = XHI_DUMMY_PACKET;
247 buffer[index++] = XHI_SYNC_PACKET;
248 buffer[index++] = XHI_NOOP_PACKET;
249 buffer[index++] = hwicap_type_1_write(drvdata->config_regs->CMD) | 1;
250 buffer[index++] = XHI_CMD_GCAPTURE;
251 buffer[index++] = XHI_DUMMY_PACKET;
252 buffer[index++] = XHI_DUMMY_PACKET;
255 * Write the data to the FIFO and intiate the transfer of data
256 * present in the FIFO to the ICAP device.
258 return drvdata->config->set_configuration(drvdata,
264 * hwicap_get_configuration_register: Query a configuration register.
265 * @parameter drvdata: a pointer to the drvdata.
266 * @parameter reg: a constant which represents the configuration
267 * register value to be returned.
268 * Examples: XHI_IDCODE, XHI_FLR.
269 * @parameter RegData: returns the value of the register.
271 * Sends a query packet to the ICAP and then receives the response.
272 * The icap is left in Synched state.
274 int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata,
275 u32 reg, u32 *RegData)
282 * Create the data to be written to the ICAP.
284 buffer[index++] = XHI_DUMMY_PACKET;
285 buffer[index++] = XHI_SYNC_PACKET;
286 buffer[index++] = XHI_NOOP_PACKET;
287 buffer[index++] = hwicap_type_1_read(reg) | 1;
288 buffer[index++] = XHI_NOOP_PACKET;
289 buffer[index++] = XHI_NOOP_PACKET;
292 * Write the data to the FIFO and intiate the transfer of data present
293 * in the FIFO to the ICAP device.
295 status = drvdata->config->set_configuration(drvdata,
301 * Read the configuration register
303 status = drvdata->config->get_configuration(drvdata, RegData, 1);
310 int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata)
315 dev_dbg(drvdata->dev, "initializing\n");
317 /* Abort any current transaction, to make sure we have the
318 * ICAP in a good state. */
319 dev_dbg(drvdata->dev, "Reset...\n");
320 drvdata->config->reset(drvdata);
322 dev_dbg(drvdata->dev, "Desync...\n");
323 status = hwicap_command_desync(drvdata);
327 /* Attempt to read the IDCODE from ICAP. This
328 * may not be returned correctly, due to the design of the
331 dev_dbg(drvdata->dev, "Reading IDCODE...\n");
332 status = hwicap_get_configuration_register(
333 drvdata, drvdata->config_regs->IDCODE, &idcode);
334 dev_dbg(drvdata->dev, "IDCODE = %x\n", idcode);
338 dev_dbg(drvdata->dev, "Desync...\n");
339 status = hwicap_command_desync(drvdata);
347 hwicap_read(struct file *file, char *buf, size_t count, loff_t *ppos)
349 struct hwicap_drvdata *drvdata = file->private_data;
350 ssize_t bytes_to_read = 0;
356 if (down_interruptible(&drvdata->sem))
359 if (drvdata->read_buffer_in_use) {
360 /* If there are leftover bytes in the buffer, just */
361 /* return them and don't try to read more from the */
364 (count < drvdata->read_buffer_in_use) ? count :
365 drvdata->read_buffer_in_use;
367 /* Return the data currently in the read buffer. */
368 if (copy_to_user(buf, drvdata->read_buffer, bytes_to_read)) {
372 drvdata->read_buffer_in_use -= bytes_to_read;
373 memcpy(drvdata->read_buffer + bytes_to_read,
374 drvdata->read_buffer, 4 - bytes_to_read);
376 /* Get new data from the ICAP, and return was was requested. */
377 kbuf = (u32 *) get_zeroed_page(GFP_KERNEL);
383 /* The ICAP device is only able to read complete */
384 /* words. If a number of bytes that do not correspond */
385 /* to complete words is requested, then we read enough */
386 /* words to get the required number of bytes, and then */
387 /* save the remaining bytes for the next read. */
389 /* Determine the number of words to read, rounding up */
391 words = ((count + 3) >> 2);
392 bytes_to_read = words << 2;
394 if (bytes_to_read > PAGE_SIZE)
395 bytes_to_read = PAGE_SIZE;
397 /* Ensure we only read a complete number of words. */
398 bytes_remaining = bytes_to_read & 3;
400 words = bytes_to_read >> 2;
402 status = drvdata->config->get_configuration(drvdata,
405 /* If we didn't read correctly, then bail out. */
407 free_page((unsigned long)kbuf);
411 /* If we fail to return the data to the user, then bail out. */
412 if (copy_to_user(buf, kbuf, bytes_to_read)) {
413 free_page((unsigned long)kbuf);
417 memcpy(kbuf, drvdata->read_buffer, bytes_remaining);
418 drvdata->read_buffer_in_use = bytes_remaining;
419 free_page((unsigned long)kbuf);
421 status = bytes_to_read;
428 hwicap_write(struct file *file, const char *buf,
429 size_t count, loff_t *ppos)
431 struct hwicap_drvdata *drvdata = file->private_data;
433 ssize_t left = count;
438 if (down_interruptible(&drvdata->sem))
441 left += drvdata->write_buffer_in_use;
443 /* Only write multiples of 4 bytes. */
449 kbuf = (u32 *) __get_free_page(GFP_KERNEL);
456 /* only write multiples of 4 bytes, so there might */
457 /* be as many as 3 bytes left (at the end). */
464 if (drvdata->write_buffer_in_use) {
465 memcpy(kbuf, drvdata->write_buffer,
466 drvdata->write_buffer_in_use);
468 (((char *)kbuf) + (drvdata->write_buffer_in_use)),
470 len - (drvdata->write_buffer_in_use))) {
471 free_page((unsigned long)kbuf);
476 if (copy_from_user(kbuf, buf + written, len)) {
477 free_page((unsigned long)kbuf);
483 status = drvdata->config->set_configuration(drvdata,
487 free_page((unsigned long)kbuf);
491 if (drvdata->write_buffer_in_use) {
492 len -= drvdata->write_buffer_in_use;
493 left -= drvdata->write_buffer_in_use;
494 drvdata->write_buffer_in_use = 0;
499 if ((left > 0) && (left < 4)) {
500 if (!copy_from_user(drvdata->write_buffer,
501 buf + written, left)) {
502 drvdata->write_buffer_in_use = left;
508 free_page((unsigned long)kbuf);
515 static int hwicap_open(struct inode *inode, struct file *file)
517 struct hwicap_drvdata *drvdata;
520 drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev);
522 if (down_interruptible(&drvdata->sem))
525 if (drvdata->is_open) {
530 status = hwicap_initialize_hwicap(drvdata);
532 dev_err(drvdata->dev, "Failed to open file");
536 file->private_data = drvdata;
537 drvdata->write_buffer_in_use = 0;
538 drvdata->read_buffer_in_use = 0;
539 drvdata->is_open = 1;
546 static int hwicap_release(struct inode *inode, struct file *file)
548 struct hwicap_drvdata *drvdata = file->private_data;
552 if (down_interruptible(&drvdata->sem))
555 if (drvdata->write_buffer_in_use) {
556 /* Flush write buffer. */
557 for (i = drvdata->write_buffer_in_use; i < 4; i++)
558 drvdata->write_buffer[i] = 0;
560 status = drvdata->config->set_configuration(drvdata,
561 (u32 *) drvdata->write_buffer, 1);
566 status = hwicap_command_desync(drvdata);
571 drvdata->is_open = 0;
576 static struct file_operations hwicap_fops = {
577 .owner = THIS_MODULE,
578 .write = hwicap_write,
581 .release = hwicap_release,
584 static int __devinit hwicap_setup(struct device *dev, int id,
585 const struct resource *regs_res,
586 const struct hwicap_driver_config *config,
587 const struct config_registers *config_regs)
590 struct hwicap_drvdata *drvdata = NULL;
593 dev_info(dev, "Xilinx icap port driver\n");
596 for (id = 0; id < HWICAP_DEVICES; id++)
597 if (!probed_devices[id])
600 if (id < 0 || id >= HWICAP_DEVICES) {
601 dev_err(dev, "%s%i too large\n", DRIVER_NAME, id);
604 if (probed_devices[id]) {
605 dev_err(dev, "cannot assign to %s%i; it is already in use\n",
610 probed_devices[id] = 1;
612 devt = MKDEV(xhwicap_major, xhwicap_minor + id);
614 drvdata = kmalloc(sizeof(struct hwicap_drvdata), GFP_KERNEL);
616 dev_err(dev, "Couldn't allocate device private record\n");
619 memset((void *)drvdata, 0, sizeof(struct hwicap_drvdata));
620 dev_set_drvdata(dev, (void *)drvdata);
623 dev_err(dev, "Couldn't get registers resource\n");
628 drvdata->mem_start = regs_res->start;
629 drvdata->mem_end = regs_res->end;
630 drvdata->mem_size = regs_res->end - regs_res->start + 1;
632 if (!request_mem_region(drvdata->mem_start,
633 drvdata->mem_size, DRIVER_NAME)) {
634 dev_err(dev, "Couldn't lock memory region at %p\n",
635 (void *)regs_res->start);
640 drvdata->devt = devt;
642 drvdata->base_address = ioremap(drvdata->mem_start, drvdata->mem_size);
643 if (!drvdata->base_address) {
644 dev_err(dev, "ioremap() failed\n");
648 drvdata->config = config;
649 drvdata->config_regs = config_regs;
651 init_MUTEX(&drvdata->sem);
652 drvdata->is_open = 0;
654 dev_info(dev, "ioremap %lx to %p with size %x\n",
655 (unsigned long int)drvdata->mem_start,
656 drvdata->base_address, drvdata->mem_size);
658 cdev_init(&drvdata->cdev, &hwicap_fops);
659 drvdata->cdev.owner = THIS_MODULE;
660 retval = cdev_add(&drvdata->cdev, devt, 1);
662 dev_err(dev, "cdev_add() failed\n");
665 /* devfs_mk_cdev(devt, S_IFCHR|S_IRUGO|S_IWUGO, DRIVER_NAME); */
666 class_device_create(icap_class, NULL, devt, NULL, DRIVER_NAME);
667 return 0; /* success */
670 iounmap(drvdata->base_address);
673 release_mem_region(regs_res->start, drvdata->mem_size);
681 static struct hwicap_driver_config buffer_icap_config = {
682 .get_configuration = buffer_icap_get_configuration,
683 .set_configuration = buffer_icap_set_configuration,
684 .reset = buffer_icap_reset,
687 static struct hwicap_driver_config fifo_icap_config = {
688 .get_configuration = fifo_icap_get_configuration,
689 .set_configuration = fifo_icap_set_configuration,
690 .reset = fifo_icap_reset,
693 static int __devexit hwicap_remove(struct device *dev)
695 struct hwicap_drvdata *drvdata;
697 drvdata = (struct hwicap_drvdata *)dev_get_drvdata(dev);
702 class_device_destroy(icap_class, drvdata->devt);
703 cdev_del(&drvdata->cdev);
704 iounmap(drvdata->base_address);
705 release_mem_region(drvdata->mem_start, drvdata->mem_size);
707 dev_set_drvdata(dev, NULL);
708 probed_devices[MINOR(dev->devt)-xhwicap_minor] = 0;
710 return 0; /* success */
713 static int __devinit hwicap_drv_probe(struct platform_device *pdev)
715 struct resource *res;
716 const struct config_registers *regs;
719 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
723 /* It's most likely that we're using V4, if the family is not
725 regs = &v4_config_registers;
726 family = pdev->dev.platform_data;
729 if (!strcmp(family, "virtex2p")) {
730 regs = &v2_config_registers;
731 } else if (!strcmp(family, "virtex4")) {
732 regs = &v4_config_registers;
733 } else if (!strcmp(family, "virtex5")) {
734 regs = &v5_config_registers;
738 return hwicap_setup(&pdev->dev, pdev->id, res,
739 &buffer_icap_config, regs);
742 static int __devexit hwicap_drv_remove(struct platform_device *pdev)
744 return hwicap_remove(&pdev->dev);
747 static struct platform_driver hwicap_platform_driver = {
748 .probe = hwicap_drv_probe,
749 .remove = hwicap_drv_remove,
751 .owner = THIS_MODULE,
756 /* ---------------------------------------------------------------------
760 #if defined(CONFIG_OF)
762 hwicap_of_probe(struct of_device *op, const struct of_device_id *match)
765 const unsigned int *id;
768 const struct hwicap_driver_config *config = match->data;
769 const struct config_registers *regs;
771 dev_dbg(&op->dev, "hwicap_of_probe(%p, %p)\n", op, match);
773 rc = of_address_to_resource(op->node, 0, &res);
775 dev_err(&op->dev, "invalid address\n");
779 id = of_get_property(op->node, "port-number", NULL);
781 /* It's most likely that we're using V4, if the family is not
783 regs = &v4_config_registers;
784 family = of_get_property(op->node, "xlnx,family", NULL);
787 if (!strcmp(family, "virtex2p")) {
788 regs = &v2_config_registers;
789 } else if (!strcmp(family, "virtex4")) {
790 regs = &v4_config_registers;
791 } else if (!strcmp(family, "virtex5")) {
792 regs = &v5_config_registers;
795 return hwicap_setup(&op->dev, id ? *id : -1, &res, config,
799 static int __devexit hwicap_of_remove(struct of_device *op)
801 return hwicap_remove(&op->dev);
804 /* Match table for of_platform binding */
805 static const struct of_device_id __devinit hwicap_of_match[] = {
806 { .compatible = "xlnx,opb-hwicap-1.00.b", .data = &buffer_icap_config},
807 { .compatible = "xlnx,xps-hwicap-1.00.a", .data = &fifo_icap_config},
810 MODULE_DEVICE_TABLE(of, hwicap_of_match);
812 static struct of_platform_driver hwicap_of_driver = {
813 .owner = THIS_MODULE,
815 .match_table = hwicap_of_match,
816 .probe = hwicap_of_probe,
817 .remove = __devexit_p(hwicap_of_remove),
823 /* Registration helpers to keep the number of #ifdefs to a minimum */
824 static inline int __devinit hwicap_of_register(void)
826 pr_debug("hwicap: calling of_register_platform_driver()\n");
827 return of_register_platform_driver(&hwicap_of_driver);
830 static inline void __devexit hwicap_of_unregister(void)
832 of_unregister_platform_driver(&hwicap_of_driver);
834 #else /* CONFIG_OF */
835 /* CONFIG_OF not enabled; do nothing helpers */
836 static inline int __devinit hwicap_of_register(void) { return 0; }
837 static inline void __devexit hwicap_of_unregister(void) { }
838 #endif /* CONFIG_OF */
840 static int __devinit hwicap_module_init(void)
845 icap_class = class_create(THIS_MODULE, "xilinx_config");
848 devt = MKDEV(xhwicap_major, xhwicap_minor);
849 retval = register_chrdev_region(
856 retval = alloc_chrdev_region(&devt,
862 xhwicap_major = MAJOR(devt);
865 retval = platform_driver_register(&hwicap_platform_driver);
870 retval = hwicap_of_register();
878 platform_driver_unregister(&hwicap_platform_driver);
881 unregister_chrdev_region(devt, HWICAP_DEVICES);
886 static void __devexit hwicap_module_cleanup(void)
888 dev_t devt = MKDEV(xhwicap_major, xhwicap_minor);
890 class_destroy(icap_class);
892 platform_driver_unregister(&hwicap_platform_driver);
894 hwicap_of_unregister();
896 unregister_chrdev_region(devt, HWICAP_DEVICES);
899 module_init(hwicap_module_init);
900 module_exit(hwicap_module_cleanup);
902 MODULE_AUTHOR("Xilinx, Inc; Xilinx Research Labs Group");
903 MODULE_DESCRIPTION("Xilinx ICAP Port Driver");
904 MODULE_LICENSE("GPL");