Merge commit 'v2.6.27-rc8' into x86/setup
[linux-2.6] / drivers / char / xilinx_hwicap / xilinx_hwicap.c
1 /*****************************************************************************
2  *
3  *     Author: Xilinx, Inc.
4  *
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.
9  *
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.
23  *
24  *     Xilinx products are not intended for use in life support appliances,
25  *     devices, or systems. Use in such applications is expressly prohibited.
26  *
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.
31  *
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.
35  *
36  *****************************************************************************/
37
38 /*
39  * This is the code behind /dev/icap* -- it allows a user-space
40  * application to use the Xilinx ICAP subsystem.
41  *
42  * The following operations are possible:
43  *
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.
48  *
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
60  * inaccessible state.
61  *
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:
69  *
70  * cp foo.bit /dev/icap0
71  *
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.
75  */
76
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>
89 #include <linux/fs.h>
90 #include <linux/cdev.h>
91 #include <linux/platform_device.h>
92
93 #include <asm/io.h>
94 #include <asm/uaccess.h>
95 #include <asm/system.h>
96
97 #ifdef CONFIG_OF
98 /* For open firmware. */
99 #include <linux/of_device.h>
100 #include <linux/of_platform.h>
101 #endif
102
103 #include "xilinx_hwicap.h"
104 #include "buffer_icap.h"
105 #include "fifo_icap.h"
106
107 #define DRIVER_NAME "icap"
108
109 #define HWICAP_REGS   (0x10000)
110
111 #define XHWICAP_MAJOR 259
112 #define XHWICAP_MINOR 0
113 #define HWICAP_DEVICES 1
114
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;
118
119 static struct class *icap_class;
120
121 #define UNIMPLEMENTED 0xFFFF
122
123 static const struct config_registers v2_config_registers = {
124         .CRC = 0,
125         .FAR = 1,
126         .FDRI = 2,
127         .FDRO = 3,
128         .CMD = 4,
129         .CTL = 5,
130         .MASK = 6,
131         .STAT = 7,
132         .LOUT = 8,
133         .COR = 9,
134         .MFWR = 10,
135         .FLR = 11,
136         .KEY = 12,
137         .CBC = 13,
138         .IDCODE = 14,
139         .AXSS = UNIMPLEMENTED,
140         .C0R_1 = UNIMPLEMENTED,
141         .CSOB = UNIMPLEMENTED,
142         .WBSTAR = UNIMPLEMENTED,
143         .TIMER = UNIMPLEMENTED,
144         .BOOTSTS = UNIMPLEMENTED,
145         .CTL_1 = UNIMPLEMENTED,
146 };
147
148 static const struct config_registers v4_config_registers = {
149         .CRC = 0,
150         .FAR = 1,
151         .FDRI = 2,
152         .FDRO = 3,
153         .CMD = 4,
154         .CTL = 5,
155         .MASK = 6,
156         .STAT = 7,
157         .LOUT = 8,
158         .COR = 9,
159         .MFWR = 10,
160         .FLR = UNIMPLEMENTED,
161         .KEY = UNIMPLEMENTED,
162         .CBC = 11,
163         .IDCODE = 12,
164         .AXSS = 13,
165         .C0R_1 = UNIMPLEMENTED,
166         .CSOB = UNIMPLEMENTED,
167         .WBSTAR = UNIMPLEMENTED,
168         .TIMER = UNIMPLEMENTED,
169         .BOOTSTS = UNIMPLEMENTED,
170         .CTL_1 = UNIMPLEMENTED,
171 };
172 static const struct config_registers v5_config_registers = {
173         .CRC = 0,
174         .FAR = 1,
175         .FDRI = 2,
176         .FDRO = 3,
177         .CMD = 4,
178         .CTL = 5,
179         .MASK = 6,
180         .STAT = 7,
181         .LOUT = 8,
182         .COR = 9,
183         .MFWR = 10,
184         .FLR = UNIMPLEMENTED,
185         .KEY = UNIMPLEMENTED,
186         .CBC = 11,
187         .IDCODE = 12,
188         .AXSS = 13,
189         .C0R_1 = 14,
190         .CSOB = 15,
191         .WBSTAR = 16,
192         .TIMER = 17,
193         .BOOTSTS = 18,
194         .CTL_1 = 19,
195 };
196
197 /**
198  * hwicap_command_desync - Send a DESYNC command to the ICAP port.
199  * @drvdata: a pointer to the drvdata.
200  *
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.
204  */
205 static int hwicap_command_desync(struct hwicap_drvdata *drvdata)
206 {
207         u32 buffer[4];
208         u32 index = 0;
209
210         /*
211          * Create the data to be written to the ICAP.
212          */
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;
217
218         /*
219          * Write the data to the FIFO and intiate the transfer of data present
220          * in the FIFO to the ICAP device.
221          */
222         return drvdata->config->set_configuration(drvdata,
223                         &buffer[0], index);
224 }
225
226 /**
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.
233  *
234  * Sends a query packet to the ICAP and then receives the response.
235  * The icap is left in Synched state.
236  */
237 static int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata,
238                 u32 reg, u32 *reg_data)
239 {
240         int status;
241         u32 buffer[6];
242         u32 index = 0;
243
244         /*
245          * Create the data to be written to the ICAP.
246          */
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;
252
253         /*
254          * Write the data to the FIFO and initiate the transfer of data present
255          * in the FIFO to the ICAP device.
256          */
257         status = drvdata->config->set_configuration(drvdata,
258                                                     &buffer[0], index);
259         if (status)
260                 return status;
261
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)
265                 return -EIO;
266
267         index = 0;
268         buffer[index++] = hwicap_type_1_read(reg) | 1;
269         buffer[index++] = XHI_NOOP_PACKET;
270         buffer[index++] = XHI_NOOP_PACKET;
271
272         /*
273          * Write the data to the FIFO and intiate the transfer of data present
274          * in the FIFO to the ICAP device.
275          */
276         status = drvdata->config->set_configuration(drvdata,
277                         &buffer[0], index);
278         if (status)
279                 return status;
280
281         /*
282          * Read the configuration register
283          */
284         status = drvdata->config->get_configuration(drvdata, reg_data, 1);
285         if (status)
286                 return status;
287
288         return 0;
289 }
290
291 static int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata)
292 {
293         int status;
294         u32 idcode;
295
296         dev_dbg(drvdata->dev, "initializing\n");
297
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);
302
303         dev_dbg(drvdata->dev, "Desync...\n");
304         status = hwicap_command_desync(drvdata);
305         if (status)
306                 return status;
307
308         /* Attempt to read the IDCODE from ICAP.  This
309          * may not be returned correctly, due to the design of the
310          * hardware.
311          */
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);
316         if (status)
317                 return status;
318
319         dev_dbg(drvdata->dev, "Desync...\n");
320         status = hwicap_command_desync(drvdata);
321         if (status)
322                 return status;
323
324         return 0;
325 }
326
327 static ssize_t
328 hwicap_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
329 {
330         struct hwicap_drvdata *drvdata = file->private_data;
331         ssize_t bytes_to_read = 0;
332         u32 *kbuf;
333         u32 words;
334         u32 bytes_remaining;
335         int status;
336
337         status = mutex_lock_interruptible(&drvdata->sem);
338         if (status)
339                 return status;
340
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 */
344                 /* ICAP device. */
345                 bytes_to_read =
346                         (count < drvdata->read_buffer_in_use) ? count :
347                         drvdata->read_buffer_in_use;
348
349                 /* Return the data currently in the read buffer. */
350                 if (copy_to_user(buf, drvdata->read_buffer, bytes_to_read)) {
351                         status = -EFAULT;
352                         goto error;
353                 }
354                 drvdata->read_buffer_in_use -= bytes_to_read;
355                 memmove(drvdata->read_buffer,
356                        drvdata->read_buffer + bytes_to_read,
357                        4 - bytes_to_read);
358         } else {
359                 /* Get new data from the ICAP, and return was was requested. */
360                 kbuf = (u32 *) get_zeroed_page(GFP_KERNEL);
361                 if (!kbuf) {
362                         status = -ENOMEM;
363                         goto error;
364                 }
365
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. */
371
372                 /* Determine the number of words to read, rounding up */
373                 /* if necessary. */
374                 words = ((count + 3) >> 2);
375                 bytes_to_read = words << 2;
376
377                 if (bytes_to_read > PAGE_SIZE)
378                         bytes_to_read = PAGE_SIZE;
379
380                 /* Ensure we only read a complete number of words. */
381                 bytes_remaining = bytes_to_read & 3;
382                 bytes_to_read &= ~3;
383                 words = bytes_to_read >> 2;
384
385                 status = drvdata->config->get_configuration(drvdata,
386                                 kbuf, words);
387
388                 /* If we didn't read correctly, then bail out. */
389                 if (status) {
390                         free_page((unsigned long)kbuf);
391                         goto error;
392                 }
393
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);
397                         status = -EFAULT;
398                         goto error;
399                 }
400                 memcpy(drvdata->read_buffer,
401                        kbuf,
402                        bytes_remaining);
403                 drvdata->read_buffer_in_use = bytes_remaining;
404                 free_page((unsigned long)kbuf);
405         }
406         status = bytes_to_read;
407  error:
408         mutex_unlock(&drvdata->sem);
409         return status;
410 }
411
412 static ssize_t
413 hwicap_write(struct file *file, const char __user *buf,
414                 size_t count, loff_t *ppos)
415 {
416         struct hwicap_drvdata *drvdata = file->private_data;
417         ssize_t written = 0;
418         ssize_t left = count;
419         u32 *kbuf;
420         ssize_t len;
421         ssize_t status;
422
423         status = mutex_lock_interruptible(&drvdata->sem);
424         if (status)
425                 return status;
426
427         left += drvdata->write_buffer_in_use;
428
429         /* Only write multiples of 4 bytes. */
430         if (left < 4) {
431                 status = 0;
432                 goto error;
433         }
434
435         kbuf = (u32 *) __get_free_page(GFP_KERNEL);
436         if (!kbuf) {
437                 status = -ENOMEM;
438                 goto error;
439         }
440
441         while (left > 3) {
442                 /* only write multiples of 4 bytes, so there might */
443                 /* be as many as 3 bytes left (at the end). */
444                 len = left;
445
446                 if (len > PAGE_SIZE)
447                         len = PAGE_SIZE;
448                 len &= ~3;
449
450                 if (drvdata->write_buffer_in_use) {
451                         memcpy(kbuf, drvdata->write_buffer,
452                                         drvdata->write_buffer_in_use);
453                         if (copy_from_user(
454                             (((char *)kbuf) + drvdata->write_buffer_in_use),
455                             buf + written,
456                             len - (drvdata->write_buffer_in_use))) {
457                                 free_page((unsigned long)kbuf);
458                                 status = -EFAULT;
459                                 goto error;
460                         }
461                 } else {
462                         if (copy_from_user(kbuf, buf + written, len)) {
463                                 free_page((unsigned long)kbuf);
464                                 status = -EFAULT;
465                                 goto error;
466                         }
467                 }
468
469                 status = drvdata->config->set_configuration(drvdata,
470                                 kbuf, len >> 2);
471
472                 if (status) {
473                         free_page((unsigned long)kbuf);
474                         status = -EFAULT;
475                         goto error;
476                 }
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;
481                 }
482                 written += len;
483                 left -= len;
484         }
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;
489                         written += left;
490                         left = 0;
491                 }
492         }
493
494         free_page((unsigned long)kbuf);
495         status = written;
496  error:
497         mutex_unlock(&drvdata->sem);
498         return status;
499 }
500
501 static int hwicap_open(struct inode *inode, struct file *file)
502 {
503         struct hwicap_drvdata *drvdata;
504         int status;
505
506         lock_kernel();
507         drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev);
508
509         status = mutex_lock_interruptible(&drvdata->sem);
510         if (status)
511                 goto out;
512
513         if (drvdata->is_open) {
514                 status = -EBUSY;
515                 goto error;
516         }
517
518         status = hwicap_initialize_hwicap(drvdata);
519         if (status) {
520                 dev_err(drvdata->dev, "Failed to open file");
521                 goto error;
522         }
523
524         file->private_data = drvdata;
525         drvdata->write_buffer_in_use = 0;
526         drvdata->read_buffer_in_use = 0;
527         drvdata->is_open = 1;
528
529  error:
530         mutex_unlock(&drvdata->sem);
531  out:
532         unlock_kernel();
533         return status;
534 }
535
536 static int hwicap_release(struct inode *inode, struct file *file)
537 {
538         struct hwicap_drvdata *drvdata = file->private_data;
539         int i;
540         int status = 0;
541
542         mutex_lock(&drvdata->sem);
543
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;
548
549                 status = drvdata->config->set_configuration(drvdata,
550                                 (u32 *) drvdata->write_buffer, 1);
551                 if (status)
552                         goto error;
553         }
554
555         status = hwicap_command_desync(drvdata);
556         if (status)
557                 goto error;
558
559  error:
560         drvdata->is_open = 0;
561         mutex_unlock(&drvdata->sem);
562         return status;
563 }
564
565 static struct file_operations hwicap_fops = {
566         .owner = THIS_MODULE,
567         .write = hwicap_write,
568         .read = hwicap_read,
569         .open = hwicap_open,
570         .release = hwicap_release,
571 };
572
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)
577 {
578         dev_t devt;
579         struct hwicap_drvdata *drvdata = NULL;
580         int retval = 0;
581
582         dev_info(dev, "Xilinx icap port driver\n");
583
584         mutex_lock(&icap_sem);
585
586         if (id < 0) {
587                 for (id = 0; id < HWICAP_DEVICES; id++)
588                         if (!probed_devices[id])
589                                 break;
590         }
591         if (id < 0 || id >= HWICAP_DEVICES) {
592                 mutex_unlock(&icap_sem);
593                 dev_err(dev, "%s%i too large\n", DRIVER_NAME, id);
594                 return -EINVAL;
595         }
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",
599                         DRIVER_NAME, id);
600                 return -EBUSY;
601         }
602
603         probed_devices[id] = 1;
604         mutex_unlock(&icap_sem);
605
606         devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR + id);
607
608         drvdata = kzalloc(sizeof(struct hwicap_drvdata), GFP_KERNEL);
609         if (!drvdata) {
610                 dev_err(dev, "Couldn't allocate device private record\n");
611                 retval = -ENOMEM;
612                 goto failed0;
613         }
614         dev_set_drvdata(dev, (void *)drvdata);
615
616         if (!regs_res) {
617                 dev_err(dev, "Couldn't get registers resource\n");
618                 retval = -EFAULT;
619                 goto failed1;
620         }
621
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;
625
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",
629                         regs_res->start);
630                 retval = -EBUSY;
631                 goto failed1;
632         }
633
634         drvdata->devt = devt;
635         drvdata->dev = dev;
636         drvdata->base_address = ioremap(drvdata->mem_start, drvdata->mem_size);
637         if (!drvdata->base_address) {
638                 dev_err(dev, "ioremap() failed\n");
639                 goto failed2;
640         }
641
642         drvdata->config = config;
643         drvdata->config_regs = config_regs;
644
645         mutex_init(&drvdata->sem);
646         drvdata->is_open = 0;
647
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);
651
652         cdev_init(&drvdata->cdev, &hwicap_fops);
653         drvdata->cdev.owner = THIS_MODULE;
654         retval = cdev_add(&drvdata->cdev, devt, 1);
655         if (retval) {
656                 dev_err(dev, "cdev_add() failed\n");
657                 goto failed3;
658         }
659
660         device_create_drvdata(icap_class, dev, devt, NULL,
661                               "%s%d", DRIVER_NAME, id);
662         return 0;               /* success */
663
664  failed3:
665         iounmap(drvdata->base_address);
666
667  failed2:
668         release_mem_region(regs_res->start, drvdata->mem_size);
669
670  failed1:
671         kfree(drvdata);
672
673  failed0:
674         mutex_lock(&icap_sem);
675         probed_devices[id] = 0;
676         mutex_unlock(&icap_sem);
677
678         return retval;
679 }
680
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,
686 };
687
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,
693 };
694
695 static int __devexit hwicap_remove(struct device *dev)
696 {
697         struct hwicap_drvdata *drvdata;
698
699         drvdata = (struct hwicap_drvdata *)dev_get_drvdata(dev);
700
701         if (!drvdata)
702                 return 0;
703
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);
708         kfree(drvdata);
709         dev_set_drvdata(dev, NULL);
710
711         mutex_lock(&icap_sem);
712         probed_devices[MINOR(dev->devt)-XHWICAP_MINOR] = 0;
713         mutex_unlock(&icap_sem);
714         return 0;               /* success */
715 }
716
717 static int __devinit hwicap_drv_probe(struct platform_device *pdev)
718 {
719         struct resource *res;
720         const struct config_registers *regs;
721         const char *family;
722
723         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
724         if (!res)
725                 return -ENODEV;
726
727         /* It's most likely that we're using V4, if the family is not
728            specified */
729         regs = &v4_config_registers;
730         family = pdev->dev.platform_data;
731
732         if (family) {
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;
739                 }
740         }
741
742         return hwicap_setup(&pdev->dev, pdev->id, res,
743                         &buffer_icap_config, regs);
744 }
745
746 static int __devexit hwicap_drv_remove(struct platform_device *pdev)
747 {
748         return hwicap_remove(&pdev->dev);
749 }
750
751 static struct platform_driver hwicap_platform_driver = {
752         .probe = hwicap_drv_probe,
753         .remove = hwicap_drv_remove,
754         .driver = {
755                 .owner = THIS_MODULE,
756                 .name = DRIVER_NAME,
757         },
758 };
759
760 /* ---------------------------------------------------------------------
761  * OF bus binding
762  */
763
764 #if defined(CONFIG_OF)
765 static int __devinit
766 hwicap_of_probe(struct of_device *op, const struct of_device_id *match)
767 {
768         struct resource res;
769         const unsigned int *id;
770         const char *family;
771         int rc;
772         const struct hwicap_driver_config *config = match->data;
773         const struct config_registers *regs;
774
775         dev_dbg(&op->dev, "hwicap_of_probe(%p, %p)\n", op, match);
776
777         rc = of_address_to_resource(op->node, 0, &res);
778         if (rc) {
779                 dev_err(&op->dev, "invalid address\n");
780                 return rc;
781         }
782
783         id = of_get_property(op->node, "port-number", NULL);
784
785         /* It's most likely that we're using V4, if the family is not
786            specified */
787         regs = &v4_config_registers;
788         family = of_get_property(op->node, "xlnx,family", NULL);
789
790         if (family) {
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;
797                 }
798         }
799         return hwicap_setup(&op->dev, id ? *id : -1, &res, config,
800                         regs);
801 }
802
803 static int __devexit hwicap_of_remove(struct of_device *op)
804 {
805         return hwicap_remove(&op->dev);
806 }
807
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},
812         {},
813 };
814 MODULE_DEVICE_TABLE(of, hwicap_of_match);
815
816 static struct of_platform_driver hwicap_of_driver = {
817         .owner = THIS_MODULE,
818         .name = DRIVER_NAME,
819         .match_table = hwicap_of_match,
820         .probe = hwicap_of_probe,
821         .remove = __devexit_p(hwicap_of_remove),
822         .driver = {
823                 .name = DRIVER_NAME,
824         },
825 };
826
827 /* Registration helpers to keep the number of #ifdefs to a minimum */
828 static inline int __init hwicap_of_register(void)
829 {
830         pr_debug("hwicap: calling of_register_platform_driver()\n");
831         return of_register_platform_driver(&hwicap_of_driver);
832 }
833
834 static inline void __exit hwicap_of_unregister(void)
835 {
836         of_unregister_platform_driver(&hwicap_of_driver);
837 }
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 */
843
844 static int __init hwicap_module_init(void)
845 {
846         dev_t devt;
847         int retval;
848
849         icap_class = class_create(THIS_MODULE, "xilinx_config");
850         mutex_init(&icap_sem);
851
852         devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR);
853         retval = register_chrdev_region(devt,
854                                         HWICAP_DEVICES,
855                                         DRIVER_NAME);
856         if (retval < 0)
857                 return retval;
858
859         retval = platform_driver_register(&hwicap_platform_driver);
860
861         if (retval)
862                 goto failed1;
863
864         retval = hwicap_of_register();
865
866         if (retval)
867                 goto failed2;
868
869         return retval;
870
871  failed2:
872         platform_driver_unregister(&hwicap_platform_driver);
873
874  failed1:
875         unregister_chrdev_region(devt, HWICAP_DEVICES);
876
877         return retval;
878 }
879
880 static void __exit hwicap_module_cleanup(void)
881 {
882         dev_t devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR);
883
884         class_destroy(icap_class);
885
886         platform_driver_unregister(&hwicap_platform_driver);
887
888         hwicap_of_unregister();
889
890         unregister_chrdev_region(devt, HWICAP_DEVICES);
891 }
892
893 module_init(hwicap_module_init);
894 module_exit(hwicap_module_cleanup);
895
896 MODULE_AUTHOR("Xilinx, Inc; Xilinx Research Labs Group");
897 MODULE_DESCRIPTION("Xilinx ICAP Port Driver");
898 MODULE_LICENSE("GPL");