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 * (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.
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.
33 *****************************************************************************/
36 * This is the code behind /dev/icap* -- it allows a user-space
37 * application to use the Xilinx ICAP subsystem.
39 * The following operations are possible:
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.
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
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:
67 * cp foo.bit /dev/icap0
69 * Note that unless foo.bit is an appropriately constructed partial
70 * bitstream, this has a high likelyhood of overwriting the design
71 * currently programmed in the FPGA.
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/smp_lock.h>
85 #include <linux/sysctl.h>
87 #include <linux/cdev.h>
88 #include <linux/platform_device.h>
89 #include <linux/slab.h>
92 #include <asm/uaccess.h>
93 #include <asm/system.h>
96 /* For open firmware. */
97 #include <linux/of_device.h>
98 #include <linux/of_platform.h>
101 #include "xilinx_hwicap.h"
102 #include "buffer_icap.h"
103 #include "fifo_icap.h"
105 #define DRIVER_NAME "icap"
107 #define HWICAP_REGS (0x10000)
109 #define XHWICAP_MAJOR 259
110 #define XHWICAP_MINOR 0
111 #define HWICAP_DEVICES 1
113 /* An array, which is set to true when the device is registered. */
114 static bool probed_devices[HWICAP_DEVICES];
115 static struct mutex icap_sem;
117 static struct class *icap_class;
119 #define UNIMPLEMENTED 0xFFFF
121 static const struct config_registers v2_config_registers = {
137 .AXSS = UNIMPLEMENTED,
138 .C0R_1 = UNIMPLEMENTED,
139 .CSOB = UNIMPLEMENTED,
140 .WBSTAR = UNIMPLEMENTED,
141 .TIMER = UNIMPLEMENTED,
142 .BOOTSTS = UNIMPLEMENTED,
143 .CTL_1 = UNIMPLEMENTED,
146 static const struct config_registers v4_config_registers = {
158 .FLR = UNIMPLEMENTED,
159 .KEY = UNIMPLEMENTED,
163 .C0R_1 = UNIMPLEMENTED,
164 .CSOB = UNIMPLEMENTED,
165 .WBSTAR = UNIMPLEMENTED,
166 .TIMER = UNIMPLEMENTED,
167 .BOOTSTS = UNIMPLEMENTED,
168 .CTL_1 = UNIMPLEMENTED,
170 static const struct config_registers v5_config_registers = {
182 .FLR = UNIMPLEMENTED,
183 .KEY = UNIMPLEMENTED,
196 * hwicap_command_desync - Send a DESYNC command to the ICAP port.
197 * @drvdata: a pointer to the drvdata.
199 * This command desynchronizes the ICAP After this command, a
200 * bitstream containing a NULL packet, followed by a SYNCH packet is
201 * required before the ICAP will recognize commands.
203 static int hwicap_command_desync(struct hwicap_drvdata *drvdata)
209 * Create the data to be written to the ICAP.
211 buffer[index++] = hwicap_type_1_write(drvdata->config_regs->CMD) | 1;
212 buffer[index++] = XHI_CMD_DESYNCH;
213 buffer[index++] = XHI_NOOP_PACKET;
214 buffer[index++] = XHI_NOOP_PACKET;
217 * Write the data to the FIFO and intiate the transfer of data present
218 * in the FIFO to the ICAP device.
220 return drvdata->config->set_configuration(drvdata,
225 * hwicap_get_configuration_register - Query a configuration register.
226 * @drvdata: a pointer to the drvdata.
227 * @reg: a constant which represents the configuration
228 * register value to be returned.
229 * Examples: XHI_IDCODE, XHI_FLR.
230 * @reg_data: returns the value of the register.
232 * Sends a query packet to the ICAP and then receives the response.
233 * The icap is left in Synched state.
235 static int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata,
236 u32 reg, u32 *reg_data)
243 * Create the data to be written to the ICAP.
245 buffer[index++] = XHI_DUMMY_PACKET;
246 buffer[index++] = XHI_NOOP_PACKET;
247 buffer[index++] = XHI_SYNC_PACKET;
248 buffer[index++] = XHI_NOOP_PACKET;
249 buffer[index++] = XHI_NOOP_PACKET;
252 * Write the data to the FIFO and initiate the transfer of data present
253 * in the FIFO to the ICAP device.
255 status = drvdata->config->set_configuration(drvdata,
260 /* If the syncword was not found, then we need to start over. */
261 status = drvdata->config->get_status(drvdata);
262 if ((status & XHI_SR_DALIGN_MASK) != XHI_SR_DALIGN_MASK)
266 buffer[index++] = hwicap_type_1_read(reg) | 1;
267 buffer[index++] = XHI_NOOP_PACKET;
268 buffer[index++] = XHI_NOOP_PACKET;
271 * Write the data to the FIFO and intiate the transfer of data present
272 * in the FIFO to the ICAP device.
274 status = drvdata->config->set_configuration(drvdata,
280 * Read the configuration register
282 status = drvdata->config->get_configuration(drvdata, reg_data, 1);
289 static int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata)
294 dev_dbg(drvdata->dev, "initializing\n");
296 /* Abort any current transaction, to make sure we have the
297 * ICAP in a good state. */
298 dev_dbg(drvdata->dev, "Reset...\n");
299 drvdata->config->reset(drvdata);
301 dev_dbg(drvdata->dev, "Desync...\n");
302 status = hwicap_command_desync(drvdata);
306 /* Attempt to read the IDCODE from ICAP. This
307 * may not be returned correctly, due to the design of the
310 dev_dbg(drvdata->dev, "Reading IDCODE...\n");
311 status = hwicap_get_configuration_register(
312 drvdata, drvdata->config_regs->IDCODE, &idcode);
313 dev_dbg(drvdata->dev, "IDCODE = %x\n", idcode);
317 dev_dbg(drvdata->dev, "Desync...\n");
318 status = hwicap_command_desync(drvdata);
326 hwicap_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
328 struct hwicap_drvdata *drvdata = file->private_data;
329 ssize_t bytes_to_read = 0;
335 status = mutex_lock_interruptible(&drvdata->sem);
339 if (drvdata->read_buffer_in_use) {
340 /* If there are leftover bytes in the buffer, just */
341 /* return them and don't try to read more from the */
344 (count < drvdata->read_buffer_in_use) ? count :
345 drvdata->read_buffer_in_use;
347 /* Return the data currently in the read buffer. */
348 if (copy_to_user(buf, drvdata->read_buffer, bytes_to_read)) {
352 drvdata->read_buffer_in_use -= bytes_to_read;
353 memmove(drvdata->read_buffer,
354 drvdata->read_buffer + bytes_to_read,
357 /* Get new data from the ICAP, and return was was requested. */
358 kbuf = (u32 *) get_zeroed_page(GFP_KERNEL);
364 /* The ICAP device is only able to read complete */
365 /* words. If a number of bytes that do not correspond */
366 /* to complete words is requested, then we read enough */
367 /* words to get the required number of bytes, and then */
368 /* save the remaining bytes for the next read. */
370 /* Determine the number of words to read, rounding up */
372 words = ((count + 3) >> 2);
373 bytes_to_read = words << 2;
375 if (bytes_to_read > PAGE_SIZE)
376 bytes_to_read = PAGE_SIZE;
378 /* Ensure we only read a complete number of words. */
379 bytes_remaining = bytes_to_read & 3;
381 words = bytes_to_read >> 2;
383 status = drvdata->config->get_configuration(drvdata,
386 /* If we didn't read correctly, then bail out. */
388 free_page((unsigned long)kbuf);
392 /* If we fail to return the data to the user, then bail out. */
393 if (copy_to_user(buf, kbuf, bytes_to_read)) {
394 free_page((unsigned long)kbuf);
398 memcpy(drvdata->read_buffer,
401 drvdata->read_buffer_in_use = bytes_remaining;
402 free_page((unsigned long)kbuf);
404 status = bytes_to_read;
406 mutex_unlock(&drvdata->sem);
411 hwicap_write(struct file *file, const char __user *buf,
412 size_t count, loff_t *ppos)
414 struct hwicap_drvdata *drvdata = file->private_data;
416 ssize_t left = count;
421 status = mutex_lock_interruptible(&drvdata->sem);
425 left += drvdata->write_buffer_in_use;
427 /* Only write multiples of 4 bytes. */
433 kbuf = (u32 *) __get_free_page(GFP_KERNEL);
440 /* only write multiples of 4 bytes, so there might */
441 /* be as many as 3 bytes left (at the end). */
448 if (drvdata->write_buffer_in_use) {
449 memcpy(kbuf, drvdata->write_buffer,
450 drvdata->write_buffer_in_use);
452 (((char *)kbuf) + drvdata->write_buffer_in_use),
454 len - (drvdata->write_buffer_in_use))) {
455 free_page((unsigned long)kbuf);
460 if (copy_from_user(kbuf, buf + written, len)) {
461 free_page((unsigned long)kbuf);
467 status = drvdata->config->set_configuration(drvdata,
471 free_page((unsigned long)kbuf);
475 if (drvdata->write_buffer_in_use) {
476 len -= drvdata->write_buffer_in_use;
477 left -= drvdata->write_buffer_in_use;
478 drvdata->write_buffer_in_use = 0;
483 if ((left > 0) && (left < 4)) {
484 if (!copy_from_user(drvdata->write_buffer,
485 buf + written, left)) {
486 drvdata->write_buffer_in_use = left;
492 free_page((unsigned long)kbuf);
495 mutex_unlock(&drvdata->sem);
499 static int hwicap_open(struct inode *inode, struct file *file)
501 struct hwicap_drvdata *drvdata;
505 drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev);
507 status = mutex_lock_interruptible(&drvdata->sem);
511 if (drvdata->is_open) {
516 status = hwicap_initialize_hwicap(drvdata);
518 dev_err(drvdata->dev, "Failed to open file");
522 file->private_data = drvdata;
523 drvdata->write_buffer_in_use = 0;
524 drvdata->read_buffer_in_use = 0;
525 drvdata->is_open = 1;
528 mutex_unlock(&drvdata->sem);
534 static int hwicap_release(struct inode *inode, struct file *file)
536 struct hwicap_drvdata *drvdata = file->private_data;
540 mutex_lock(&drvdata->sem);
542 if (drvdata->write_buffer_in_use) {
543 /* Flush write buffer. */
544 for (i = drvdata->write_buffer_in_use; i < 4; i++)
545 drvdata->write_buffer[i] = 0;
547 status = drvdata->config->set_configuration(drvdata,
548 (u32 *) drvdata->write_buffer, 1);
553 status = hwicap_command_desync(drvdata);
558 drvdata->is_open = 0;
559 mutex_unlock(&drvdata->sem);
563 static const struct file_operations hwicap_fops = {
564 .owner = THIS_MODULE,
565 .write = hwicap_write,
568 .release = hwicap_release,
571 static int __devinit hwicap_setup(struct device *dev, int id,
572 const struct resource *regs_res,
573 const struct hwicap_driver_config *config,
574 const struct config_registers *config_regs)
577 struct hwicap_drvdata *drvdata = NULL;
580 dev_info(dev, "Xilinx icap port driver\n");
582 mutex_lock(&icap_sem);
585 for (id = 0; id < HWICAP_DEVICES; id++)
586 if (!probed_devices[id])
589 if (id < 0 || id >= HWICAP_DEVICES) {
590 mutex_unlock(&icap_sem);
591 dev_err(dev, "%s%i too large\n", DRIVER_NAME, id);
594 if (probed_devices[id]) {
595 mutex_unlock(&icap_sem);
596 dev_err(dev, "cannot assign to %s%i; it is already in use\n",
601 probed_devices[id] = 1;
602 mutex_unlock(&icap_sem);
604 devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR + id);
606 drvdata = kzalloc(sizeof(struct hwicap_drvdata), GFP_KERNEL);
608 dev_err(dev, "Couldn't allocate device private record\n");
612 dev_set_drvdata(dev, (void *)drvdata);
615 dev_err(dev, "Couldn't get registers resource\n");
620 drvdata->mem_start = regs_res->start;
621 drvdata->mem_end = regs_res->end;
622 drvdata->mem_size = regs_res->end - regs_res->start + 1;
624 if (!request_mem_region(drvdata->mem_start,
625 drvdata->mem_size, DRIVER_NAME)) {
626 dev_err(dev, "Couldn't lock memory region at %Lx\n",
627 (unsigned long long) regs_res->start);
632 drvdata->devt = devt;
634 drvdata->base_address = ioremap(drvdata->mem_start, drvdata->mem_size);
635 if (!drvdata->base_address) {
636 dev_err(dev, "ioremap() failed\n");
640 drvdata->config = config;
641 drvdata->config_regs = config_regs;
643 mutex_init(&drvdata->sem);
644 drvdata->is_open = 0;
646 dev_info(dev, "ioremap %llx to %p with size %llx\n",
647 (unsigned long long) drvdata->mem_start,
648 drvdata->base_address,
649 (unsigned long long) drvdata->mem_size);
651 cdev_init(&drvdata->cdev, &hwicap_fops);
652 drvdata->cdev.owner = THIS_MODULE;
653 retval = cdev_add(&drvdata->cdev, devt, 1);
655 dev_err(dev, "cdev_add() failed\n");
659 device_create(icap_class, dev, devt, NULL, "%s%d", DRIVER_NAME, id);
660 return 0; /* success */
663 iounmap(drvdata->base_address);
666 release_mem_region(regs_res->start, drvdata->mem_size);
672 mutex_lock(&icap_sem);
673 probed_devices[id] = 0;
674 mutex_unlock(&icap_sem);
679 static struct hwicap_driver_config buffer_icap_config = {
680 .get_configuration = buffer_icap_get_configuration,
681 .set_configuration = buffer_icap_set_configuration,
682 .get_status = buffer_icap_get_status,
683 .reset = buffer_icap_reset,
686 static struct hwicap_driver_config fifo_icap_config = {
687 .get_configuration = fifo_icap_get_configuration,
688 .set_configuration = fifo_icap_set_configuration,
689 .get_status = fifo_icap_get_status,
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 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);
709 mutex_lock(&icap_sem);
710 probed_devices[MINOR(dev->devt)-XHWICAP_MINOR] = 0;
711 mutex_unlock(&icap_sem);
712 return 0; /* success */
715 static int __devinit hwicap_drv_probe(struct platform_device *pdev)
717 struct resource *res;
718 const struct config_registers *regs;
721 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
725 /* It's most likely that we're using V4, if the family is not
727 regs = &v4_config_registers;
728 family = pdev->dev.platform_data;
731 if (!strcmp(family, "virtex2p")) {
732 regs = &v2_config_registers;
733 } else if (!strcmp(family, "virtex4")) {
734 regs = &v4_config_registers;
735 } else if (!strcmp(family, "virtex5")) {
736 regs = &v5_config_registers;
740 return hwicap_setup(&pdev->dev, pdev->id, res,
741 &buffer_icap_config, regs);
744 static int __devexit hwicap_drv_remove(struct platform_device *pdev)
746 return hwicap_remove(&pdev->dev);
749 static struct platform_driver hwicap_platform_driver = {
750 .probe = hwicap_drv_probe,
751 .remove = hwicap_drv_remove,
753 .owner = THIS_MODULE,
758 /* ---------------------------------------------------------------------
762 #if defined(CONFIG_OF)
764 hwicap_of_probe(struct platform_device *op, const struct of_device_id *match)
767 const unsigned int *id;
770 const struct hwicap_driver_config *config = match->data;
771 const struct config_registers *regs;
773 dev_dbg(&op->dev, "hwicap_of_probe(%p, %p)\n", op, match);
775 rc = of_address_to_resource(op->dev.of_node, 0, &res);
777 dev_err(&op->dev, "invalid address\n");
781 id = of_get_property(op->dev.of_node, "port-number", NULL);
783 /* It's most likely that we're using V4, if the family is not
785 regs = &v4_config_registers;
786 family = of_get_property(op->dev.of_node, "xlnx,family", NULL);
789 if (!strcmp(family, "virtex2p")) {
790 regs = &v2_config_registers;
791 } else if (!strcmp(family, "virtex4")) {
792 regs = &v4_config_registers;
793 } else if (!strcmp(family, "virtex5")) {
794 regs = &v5_config_registers;
797 return hwicap_setup(&op->dev, id ? *id : -1, &res, config,
801 static int __devexit hwicap_of_remove(struct platform_device *op)
803 return hwicap_remove(&op->dev);
806 /* Match table for of_platform binding */
807 static const struct of_device_id __devinitconst hwicap_of_match[] = {
808 { .compatible = "xlnx,opb-hwicap-1.00.b", .data = &buffer_icap_config},
809 { .compatible = "xlnx,xps-hwicap-1.00.a", .data = &fifo_icap_config},
812 MODULE_DEVICE_TABLE(of, hwicap_of_match);
814 static struct of_platform_driver hwicap_of_driver = {
815 .probe = hwicap_of_probe,
816 .remove = __devexit_p(hwicap_of_remove),
819 .owner = THIS_MODULE,
820 .of_match_table = hwicap_of_match,
824 /* Registration helpers to keep the number of #ifdefs to a minimum */
825 static inline int __init hwicap_of_register(void)
827 pr_debug("hwicap: calling of_register_platform_driver()\n");
828 return of_register_platform_driver(&hwicap_of_driver);
831 static inline void __exit hwicap_of_unregister(void)
833 of_unregister_platform_driver(&hwicap_of_driver);
835 #else /* CONFIG_OF */
836 /* CONFIG_OF not enabled; do nothing helpers */
837 static inline int __init hwicap_of_register(void) { return 0; }
838 static inline void __exit hwicap_of_unregister(void) { }
839 #endif /* CONFIG_OF */
841 static int __init hwicap_module_init(void)
846 icap_class = class_create(THIS_MODULE, "xilinx_config");
847 mutex_init(&icap_sem);
849 devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR);
850 retval = register_chrdev_region(devt,
856 retval = platform_driver_register(&hwicap_platform_driver);
861 retval = hwicap_of_register();
869 platform_driver_unregister(&hwicap_platform_driver);
872 unregister_chrdev_region(devt, HWICAP_DEVICES);
877 static void __exit hwicap_module_cleanup(void)
879 dev_t devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR);
881 class_destroy(icap_class);
883 platform_driver_unregister(&hwicap_platform_driver);
885 hwicap_of_unregister();
887 unregister_chrdev_region(devt, HWICAP_DEVICES);
890 module_init(hwicap_module_init);
891 module_exit(hwicap_module_cleanup);
893 MODULE_AUTHOR("Xilinx, Inc; Xilinx Research Labs Group");
894 MODULE_DESCRIPTION("Xilinx ICAP Port Driver");
895 MODULE_LICENSE("GPL");