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/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/icap0
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/module.h>
78 #include <linux/kernel.h>
79 #include <linux/types.h>
80 #include <linux/ioport.h>
81 #include <linux/interrupt.h>
82 #include <linux/fcntl.h>
83 #include <linux/init.h>
84 #include <linux/poll.h>
85 #include <linux/proc_fs.h>
86 #include <linux/mutex.h>
87 #include <linux/smp_lock.h>
88 #include <linux/sysctl.h>
90 #include <linux/cdev.h>
91 #include <linux/platform_device.h>
94 #include <asm/uaccess.h>
95 #include <asm/system.h>
98 /* For open firmware. */
99 #include <linux/of_device.h>
100 #include <linux/of_platform.h>
103 #include "xilinx_hwicap.h"
104 #include "buffer_icap.h"
105 #include "fifo_icap.h"
107 #define DRIVER_NAME "icap"
109 #define HWICAP_REGS (0x10000)
111 #define XHWICAP_MAJOR 259
112 #define XHWICAP_MINOR 0
113 #define HWICAP_DEVICES 1
115 /* An array, which is set to true when the device is registered. */
116 static bool probed_devices
[HWICAP_DEVICES
];
117 static struct mutex icap_sem
;
119 static struct class *icap_class
;
121 #define UNIMPLEMENTED 0xFFFF
123 static const struct config_registers v2_config_registers
= {
139 .AXSS
= UNIMPLEMENTED
,
140 .C0R_1
= UNIMPLEMENTED
,
141 .CSOB
= UNIMPLEMENTED
,
142 .WBSTAR
= UNIMPLEMENTED
,
143 .TIMER
= UNIMPLEMENTED
,
144 .BOOTSTS
= UNIMPLEMENTED
,
145 .CTL_1
= UNIMPLEMENTED
,
148 static const struct config_registers v4_config_registers
= {
160 .FLR
= UNIMPLEMENTED
,
161 .KEY
= UNIMPLEMENTED
,
165 .C0R_1
= UNIMPLEMENTED
,
166 .CSOB
= UNIMPLEMENTED
,
167 .WBSTAR
= UNIMPLEMENTED
,
168 .TIMER
= UNIMPLEMENTED
,
169 .BOOTSTS
= UNIMPLEMENTED
,
170 .CTL_1
= UNIMPLEMENTED
,
172 static const struct config_registers v5_config_registers
= {
184 .FLR
= UNIMPLEMENTED
,
185 .KEY
= UNIMPLEMENTED
,
198 * hwicap_command_desync - Send a DESYNC command to the ICAP port.
199 * @drvdata: a pointer to the drvdata.
201 * This command desynchronizes the ICAP After this command, a
202 * bitstream containing a NULL packet, followed by a SYNCH packet is
203 * required before the ICAP will recognize commands.
205 static int hwicap_command_desync(struct hwicap_drvdata
*drvdata
)
211 * Create the data to be written to the ICAP.
213 buffer
[index
++] = hwicap_type_1_write(drvdata
->config_regs
->CMD
) | 1;
214 buffer
[index
++] = XHI_CMD_DESYNCH
;
215 buffer
[index
++] = XHI_NOOP_PACKET
;
216 buffer
[index
++] = XHI_NOOP_PACKET
;
219 * Write the data to the FIFO and intiate the transfer of data present
220 * in the FIFO to the ICAP device.
222 return drvdata
->config
->set_configuration(drvdata
,
227 * hwicap_get_configuration_register - Query a configuration register.
228 * @drvdata: a pointer to the drvdata.
229 * @reg: a constant which represents the configuration
230 * register value to be returned.
231 * Examples: XHI_IDCODE, XHI_FLR.
232 * @reg_data: returns the value of the register.
234 * Sends a query packet to the ICAP and then receives the response.
235 * The icap is left in Synched state.
237 static int hwicap_get_configuration_register(struct hwicap_drvdata
*drvdata
,
238 u32 reg
, u32
*reg_data
)
245 * Create the data to be written to the ICAP.
247 buffer
[index
++] = XHI_DUMMY_PACKET
;
248 buffer
[index
++] = XHI_NOOP_PACKET
;
249 buffer
[index
++] = XHI_SYNC_PACKET
;
250 buffer
[index
++] = XHI_NOOP_PACKET
;
251 buffer
[index
++] = XHI_NOOP_PACKET
;
254 * Write the data to the FIFO and initiate the transfer of data present
255 * in the FIFO to the ICAP device.
257 status
= drvdata
->config
->set_configuration(drvdata
,
262 /* If the syncword was not found, then we need to start over. */
263 status
= drvdata
->config
->get_status(drvdata
);
264 if ((status
& XHI_SR_DALIGN_MASK
) != XHI_SR_DALIGN_MASK
)
268 buffer
[index
++] = hwicap_type_1_read(reg
) | 1;
269 buffer
[index
++] = XHI_NOOP_PACKET
;
270 buffer
[index
++] = XHI_NOOP_PACKET
;
273 * Write the data to the FIFO and intiate the transfer of data present
274 * in the FIFO to the ICAP device.
276 status
= drvdata
->config
->set_configuration(drvdata
,
282 * Read the configuration register
284 status
= drvdata
->config
->get_configuration(drvdata
, reg_data
, 1);
291 static int hwicap_initialize_hwicap(struct hwicap_drvdata
*drvdata
)
296 dev_dbg(drvdata
->dev
, "initializing\n");
298 /* Abort any current transaction, to make sure we have the
299 * ICAP in a good state. */
300 dev_dbg(drvdata
->dev
, "Reset...\n");
301 drvdata
->config
->reset(drvdata
);
303 dev_dbg(drvdata
->dev
, "Desync...\n");
304 status
= hwicap_command_desync(drvdata
);
308 /* Attempt to read the IDCODE from ICAP. This
309 * may not be returned correctly, due to the design of the
312 dev_dbg(drvdata
->dev
, "Reading IDCODE...\n");
313 status
= hwicap_get_configuration_register(
314 drvdata
, drvdata
->config_regs
->IDCODE
, &idcode
);
315 dev_dbg(drvdata
->dev
, "IDCODE = %x\n", idcode
);
319 dev_dbg(drvdata
->dev
, "Desync...\n");
320 status
= hwicap_command_desync(drvdata
);
328 hwicap_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
330 struct hwicap_drvdata
*drvdata
= file
->private_data
;
331 ssize_t bytes_to_read
= 0;
337 status
= mutex_lock_interruptible(&drvdata
->sem
);
341 if (drvdata
->read_buffer_in_use
) {
342 /* If there are leftover bytes in the buffer, just */
343 /* return them and don't try to read more from the */
346 (count
< drvdata
->read_buffer_in_use
) ? count
:
347 drvdata
->read_buffer_in_use
;
349 /* Return the data currently in the read buffer. */
350 if (copy_to_user(buf
, drvdata
->read_buffer
, bytes_to_read
)) {
354 drvdata
->read_buffer_in_use
-= bytes_to_read
;
355 memmove(drvdata
->read_buffer
,
356 drvdata
->read_buffer
+ bytes_to_read
,
359 /* Get new data from the ICAP, and return was was requested. */
360 kbuf
= (u32
*) get_zeroed_page(GFP_KERNEL
);
366 /* The ICAP device is only able to read complete */
367 /* words. If a number of bytes that do not correspond */
368 /* to complete words is requested, then we read enough */
369 /* words to get the required number of bytes, and then */
370 /* save the remaining bytes for the next read. */
372 /* Determine the number of words to read, rounding up */
374 words
= ((count
+ 3) >> 2);
375 bytes_to_read
= words
<< 2;
377 if (bytes_to_read
> PAGE_SIZE
)
378 bytes_to_read
= PAGE_SIZE
;
380 /* Ensure we only read a complete number of words. */
381 bytes_remaining
= bytes_to_read
& 3;
383 words
= bytes_to_read
>> 2;
385 status
= drvdata
->config
->get_configuration(drvdata
,
388 /* If we didn't read correctly, then bail out. */
390 free_page((unsigned long)kbuf
);
394 /* If we fail to return the data to the user, then bail out. */
395 if (copy_to_user(buf
, kbuf
, bytes_to_read
)) {
396 free_page((unsigned long)kbuf
);
400 memcpy(drvdata
->read_buffer
,
403 drvdata
->read_buffer_in_use
= bytes_remaining
;
404 free_page((unsigned long)kbuf
);
406 status
= bytes_to_read
;
408 mutex_unlock(&drvdata
->sem
);
413 hwicap_write(struct file
*file
, const char __user
*buf
,
414 size_t count
, loff_t
*ppos
)
416 struct hwicap_drvdata
*drvdata
= file
->private_data
;
418 ssize_t left
= count
;
423 status
= mutex_lock_interruptible(&drvdata
->sem
);
427 left
+= drvdata
->write_buffer_in_use
;
429 /* Only write multiples of 4 bytes. */
435 kbuf
= (u32
*) __get_free_page(GFP_KERNEL
);
442 /* only write multiples of 4 bytes, so there might */
443 /* be as many as 3 bytes left (at the end). */
450 if (drvdata
->write_buffer_in_use
) {
451 memcpy(kbuf
, drvdata
->write_buffer
,
452 drvdata
->write_buffer_in_use
);
454 (((char *)kbuf
) + drvdata
->write_buffer_in_use
),
456 len
- (drvdata
->write_buffer_in_use
))) {
457 free_page((unsigned long)kbuf
);
462 if (copy_from_user(kbuf
, buf
+ written
, len
)) {
463 free_page((unsigned long)kbuf
);
469 status
= drvdata
->config
->set_configuration(drvdata
,
473 free_page((unsigned long)kbuf
);
477 if (drvdata
->write_buffer_in_use
) {
478 len
-= drvdata
->write_buffer_in_use
;
479 left
-= drvdata
->write_buffer_in_use
;
480 drvdata
->write_buffer_in_use
= 0;
485 if ((left
> 0) && (left
< 4)) {
486 if (!copy_from_user(drvdata
->write_buffer
,
487 buf
+ written
, left
)) {
488 drvdata
->write_buffer_in_use
= left
;
494 free_page((unsigned long)kbuf
);
497 mutex_unlock(&drvdata
->sem
);
501 static int hwicap_open(struct inode
*inode
, struct file
*file
)
503 struct hwicap_drvdata
*drvdata
;
507 drvdata
= container_of(inode
->i_cdev
, struct hwicap_drvdata
, cdev
);
509 status
= mutex_lock_interruptible(&drvdata
->sem
);
513 if (drvdata
->is_open
) {
518 status
= hwicap_initialize_hwicap(drvdata
);
520 dev_err(drvdata
->dev
, "Failed to open file");
524 file
->private_data
= drvdata
;
525 drvdata
->write_buffer_in_use
= 0;
526 drvdata
->read_buffer_in_use
= 0;
527 drvdata
->is_open
= 1;
530 mutex_unlock(&drvdata
->sem
);
536 static int hwicap_release(struct inode
*inode
, struct file
*file
)
538 struct hwicap_drvdata
*drvdata
= file
->private_data
;
542 mutex_lock(&drvdata
->sem
);
544 if (drvdata
->write_buffer_in_use
) {
545 /* Flush write buffer. */
546 for (i
= drvdata
->write_buffer_in_use
; i
< 4; i
++)
547 drvdata
->write_buffer
[i
] = 0;
549 status
= drvdata
->config
->set_configuration(drvdata
,
550 (u32
*) drvdata
->write_buffer
, 1);
555 status
= hwicap_command_desync(drvdata
);
560 drvdata
->is_open
= 0;
561 mutex_unlock(&drvdata
->sem
);
565 static struct file_operations hwicap_fops
= {
566 .owner
= THIS_MODULE
,
567 .write
= hwicap_write
,
570 .release
= hwicap_release
,
573 static int __devinit
hwicap_setup(struct device
*dev
, int id
,
574 const struct resource
*regs_res
,
575 const struct hwicap_driver_config
*config
,
576 const struct config_registers
*config_regs
)
579 struct hwicap_drvdata
*drvdata
= NULL
;
582 dev_info(dev
, "Xilinx icap port driver\n");
584 mutex_lock(&icap_sem
);
587 for (id
= 0; id
< HWICAP_DEVICES
; id
++)
588 if (!probed_devices
[id
])
591 if (id
< 0 || id
>= HWICAP_DEVICES
) {
592 mutex_unlock(&icap_sem
);
593 dev_err(dev
, "%s%i too large\n", DRIVER_NAME
, id
);
596 if (probed_devices
[id
]) {
597 mutex_unlock(&icap_sem
);
598 dev_err(dev
, "cannot assign to %s%i; it is already in use\n",
603 probed_devices
[id
] = 1;
604 mutex_unlock(&icap_sem
);
606 devt
= MKDEV(XHWICAP_MAJOR
, XHWICAP_MINOR
+ id
);
608 drvdata
= kzalloc(sizeof(struct hwicap_drvdata
), GFP_KERNEL
);
610 dev_err(dev
, "Couldn't allocate device private record\n");
614 dev_set_drvdata(dev
, (void *)drvdata
);
617 dev_err(dev
, "Couldn't get registers resource\n");
622 drvdata
->mem_start
= regs_res
->start
;
623 drvdata
->mem_end
= regs_res
->end
;
624 drvdata
->mem_size
= regs_res
->end
- regs_res
->start
+ 1;
626 if (!request_mem_region(drvdata
->mem_start
,
627 drvdata
->mem_size
, DRIVER_NAME
)) {
628 dev_err(dev
, "Couldn't lock memory region at %Lx\n",
634 drvdata
->devt
= devt
;
636 drvdata
->base_address
= ioremap(drvdata
->mem_start
, drvdata
->mem_size
);
637 if (!drvdata
->base_address
) {
638 dev_err(dev
, "ioremap() failed\n");
642 drvdata
->config
= config
;
643 drvdata
->config_regs
= config_regs
;
645 mutex_init(&drvdata
->sem
);
646 drvdata
->is_open
= 0;
648 dev_info(dev
, "ioremap %lx to %p with size %Lx\n",
649 (unsigned long int)drvdata
->mem_start
,
650 drvdata
->base_address
, drvdata
->mem_size
);
652 cdev_init(&drvdata
->cdev
, &hwicap_fops
);
653 drvdata
->cdev
.owner
= THIS_MODULE
;
654 retval
= cdev_add(&drvdata
->cdev
, devt
, 1);
656 dev_err(dev
, "cdev_add() failed\n");
660 device_create_drvdata(icap_class
, dev
, devt
, NULL
,
661 "%s%d", DRIVER_NAME
, id
);
662 return 0; /* success */
665 iounmap(drvdata
->base_address
);
668 release_mem_region(regs_res
->start
, drvdata
->mem_size
);
674 mutex_lock(&icap_sem
);
675 probed_devices
[id
] = 0;
676 mutex_unlock(&icap_sem
);
681 static struct hwicap_driver_config buffer_icap_config
= {
682 .get_configuration
= buffer_icap_get_configuration
,
683 .set_configuration
= buffer_icap_set_configuration
,
684 .get_status
= buffer_icap_get_status
,
685 .reset
= buffer_icap_reset
,
688 static struct hwicap_driver_config fifo_icap_config
= {
689 .get_configuration
= fifo_icap_get_configuration
,
690 .set_configuration
= fifo_icap_set_configuration
,
691 .get_status
= fifo_icap_get_status
,
692 .reset
= fifo_icap_reset
,
695 static int __devexit
hwicap_remove(struct device
*dev
)
697 struct hwicap_drvdata
*drvdata
;
699 drvdata
= (struct hwicap_drvdata
*)dev_get_drvdata(dev
);
704 device_destroy(icap_class
, drvdata
->devt
);
705 cdev_del(&drvdata
->cdev
);
706 iounmap(drvdata
->base_address
);
707 release_mem_region(drvdata
->mem_start
, drvdata
->mem_size
);
709 dev_set_drvdata(dev
, NULL
);
711 mutex_lock(&icap_sem
);
712 probed_devices
[MINOR(dev
->devt
)-XHWICAP_MINOR
] = 0;
713 mutex_unlock(&icap_sem
);
714 return 0; /* success */
717 static int __devinit
hwicap_drv_probe(struct platform_device
*pdev
)
719 struct resource
*res
;
720 const struct config_registers
*regs
;
723 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
727 /* It's most likely that we're using V4, if the family is not
729 regs
= &v4_config_registers
;
730 family
= pdev
->dev
.platform_data
;
733 if (!strcmp(family
, "virtex2p")) {
734 regs
= &v2_config_registers
;
735 } else if (!strcmp(family
, "virtex4")) {
736 regs
= &v4_config_registers
;
737 } else if (!strcmp(family
, "virtex5")) {
738 regs
= &v5_config_registers
;
742 return hwicap_setup(&pdev
->dev
, pdev
->id
, res
,
743 &buffer_icap_config
, regs
);
746 static int __devexit
hwicap_drv_remove(struct platform_device
*pdev
)
748 return hwicap_remove(&pdev
->dev
);
751 static struct platform_driver hwicap_platform_driver
= {
752 .probe
= hwicap_drv_probe
,
753 .remove
= hwicap_drv_remove
,
755 .owner
= THIS_MODULE
,
760 /* ---------------------------------------------------------------------
764 #if defined(CONFIG_OF)
766 hwicap_of_probe(struct of_device
*op
, const struct of_device_id
*match
)
769 const unsigned int *id
;
772 const struct hwicap_driver_config
*config
= match
->data
;
773 const struct config_registers
*regs
;
775 dev_dbg(&op
->dev
, "hwicap_of_probe(%p, %p)\n", op
, match
);
777 rc
= of_address_to_resource(op
->node
, 0, &res
);
779 dev_err(&op
->dev
, "invalid address\n");
783 id
= of_get_property(op
->node
, "port-number", NULL
);
785 /* It's most likely that we're using V4, if the family is not
787 regs
= &v4_config_registers
;
788 family
= of_get_property(op
->node
, "xlnx,family", NULL
);
791 if (!strcmp(family
, "virtex2p")) {
792 regs
= &v2_config_registers
;
793 } else if (!strcmp(family
, "virtex4")) {
794 regs
= &v4_config_registers
;
795 } else if (!strcmp(family
, "virtex5")) {
796 regs
= &v5_config_registers
;
799 return hwicap_setup(&op
->dev
, id
? *id
: -1, &res
, config
,
803 static int __devexit
hwicap_of_remove(struct of_device
*op
)
805 return hwicap_remove(&op
->dev
);
808 /* Match table for of_platform binding */
809 static const struct of_device_id __devinitconst hwicap_of_match
[] = {
810 { .compatible
= "xlnx,opb-hwicap-1.00.b", .data
= &buffer_icap_config
},
811 { .compatible
= "xlnx,xps-hwicap-1.00.a", .data
= &fifo_icap_config
},
814 MODULE_DEVICE_TABLE(of
, hwicap_of_match
);
816 static struct of_platform_driver hwicap_of_driver
= {
817 .owner
= THIS_MODULE
,
819 .match_table
= hwicap_of_match
,
820 .probe
= hwicap_of_probe
,
821 .remove
= __devexit_p(hwicap_of_remove
),
827 /* Registration helpers to keep the number of #ifdefs to a minimum */
828 static inline int __init
hwicap_of_register(void)
830 pr_debug("hwicap: calling of_register_platform_driver()\n");
831 return of_register_platform_driver(&hwicap_of_driver
);
834 static inline void __exit
hwicap_of_unregister(void)
836 of_unregister_platform_driver(&hwicap_of_driver
);
838 #else /* CONFIG_OF */
839 /* CONFIG_OF not enabled; do nothing helpers */
840 static inline int __init
hwicap_of_register(void) { return 0; }
841 static inline void __exit
hwicap_of_unregister(void) { }
842 #endif /* CONFIG_OF */
844 static int __init
hwicap_module_init(void)
849 icap_class
= class_create(THIS_MODULE
, "xilinx_config");
850 mutex_init(&icap_sem
);
852 devt
= MKDEV(XHWICAP_MAJOR
, XHWICAP_MINOR
);
853 retval
= register_chrdev_region(devt
,
859 retval
= platform_driver_register(&hwicap_platform_driver
);
864 retval
= hwicap_of_register();
872 platform_driver_unregister(&hwicap_platform_driver
);
875 unregister_chrdev_region(devt
, HWICAP_DEVICES
);
880 static void __exit
hwicap_module_cleanup(void)
882 dev_t devt
= MKDEV(XHWICAP_MAJOR
, XHWICAP_MINOR
);
884 class_destroy(icap_class
);
886 platform_driver_unregister(&hwicap_platform_driver
);
888 hwicap_of_unregister();
890 unregister_chrdev_region(devt
, HWICAP_DEVICES
);
893 module_init(hwicap_module_init
);
894 module_exit(hwicap_module_cleanup
);
896 MODULE_AUTHOR("Xilinx, Inc; Xilinx Research Labs Group");
897 MODULE_DESCRIPTION("Xilinx ICAP Port Driver");
898 MODULE_LICENSE("GPL");