Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/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  *     (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.
 28  *
 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.
 32  *
 33  *****************************************************************************/
 34 
 35 /*
 36  * This is the code behind /dev/icap* -- it allows a user-space
 37  * application to use the Xilinx ICAP subsystem.
 38  *
 39  * The following operations are possible:
 40  *
 41  * open         open the port and initialize for access.
 42  * release      release port
 43  * write        Write a bitstream to the configuration processor.
 44  * read         Read a data stream from the configuration processor.
 45  *
 46  * After being opened, the port is initialized and accessed to avoid 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
 57  * inaccessible state.
 58  *
 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:
 66  *
 67  * cp foo.bit /dev/icap0
 68  *
 69  * Note that unless foo.bit is an appropriately constructed partial
 70  * bitstream, this has a high likelihood of overwriting the design
 71  * currently programmed in the FPGA.
 72  */
 73 
 74 #include <linux/module.h>
 75 #include <linux/kernel.h>
 76 #include <linux/types.h>
 77 #include <linux/ioport.h>
 78 #include <linux/interrupt.h>
 79 #include <linux/fcntl.h>
 80 #include <linux/init.h>
 81 #include <linux/poll.h>
 82 #include <linux/proc_fs.h>
 83 #include <linux/mutex.h>
 84 #include <linux/sysctl.h>
 85 #include <linux/fs.h>
 86 #include <linux/cdev.h>
 87 #include <linux/platform_device.h>
 88 #include <linux/slab.h>
 89 
 90 #include <asm/io.h>
 91 #include <asm/uaccess.h>
 92 
 93 #ifdef CONFIG_OF
 94 /* For open firmware. */
 95 #include <linux/of_address.h>
 96 #include <linux/of_device.h>
 97 #include <linux/of_platform.h>
 98 #endif
 99 
100 #include "xilinx_hwicap.h"
101 #include "buffer_icap.h"
102 #include "fifo_icap.h"
103 
104 #define DRIVER_NAME "icap"
105 
106 #define HWICAP_REGS   (0x10000)
107 
108 #define XHWICAP_MAJOR 259
109 #define XHWICAP_MINOR 0
110 #define HWICAP_DEVICES 1
111 
112 /* An array, which is set to true when the device is registered. */
113 static DEFINE_MUTEX(hwicap_mutex);
114 static bool probed_devices[HWICAP_DEVICES];
115 static struct mutex icap_sem;
116 
117 static struct class *icap_class;
118 
119 #define UNIMPLEMENTED 0xFFFF
120 
121 static const struct config_registers v2_config_registers = {
122         .CRC = 0,
123         .FAR = 1,
124         .FDRI = 2,
125         .FDRO = 3,
126         .CMD = 4,
127         .CTL = 5,
128         .MASK = 6,
129         .STAT = 7,
130         .LOUT = 8,
131         .COR = 9,
132         .MFWR = 10,
133         .FLR = 11,
134         .KEY = 12,
135         .CBC = 13,
136         .IDCODE = 14,
137         .AXSS = UNIMPLEMENTED,
138         .C0R_1 = UNIMPLEMENTED,
139         .CSOB = UNIMPLEMENTED,
140         .WBSTAR = UNIMPLEMENTED,
141         .TIMER = UNIMPLEMENTED,
142         .BOOTSTS = UNIMPLEMENTED,
143         .CTL_1 = UNIMPLEMENTED,
144 };
145 
146 static const struct config_registers v4_config_registers = {
147         .CRC = 0,
148         .FAR = 1,
149         .FDRI = 2,
150         .FDRO = 3,
151         .CMD = 4,
152         .CTL = 5,
153         .MASK = 6,
154         .STAT = 7,
155         .LOUT = 8,
156         .COR = 9,
157         .MFWR = 10,
158         .FLR = UNIMPLEMENTED,
159         .KEY = UNIMPLEMENTED,
160         .CBC = 11,
161         .IDCODE = 12,
162         .AXSS = 13,
163         .C0R_1 = UNIMPLEMENTED,
164         .CSOB = UNIMPLEMENTED,
165         .WBSTAR = UNIMPLEMENTED,
166         .TIMER = UNIMPLEMENTED,
167         .BOOTSTS = UNIMPLEMENTED,
168         .CTL_1 = UNIMPLEMENTED,
169 };
170 
171 static const struct config_registers v5_config_registers = {
172         .CRC = 0,
173         .FAR = 1,
174         .FDRI = 2,
175         .FDRO = 3,
176         .CMD = 4,
177         .CTL = 5,
178         .MASK = 6,
179         .STAT = 7,
180         .LOUT = 8,
181         .COR = 9,
182         .MFWR = 10,
183         .FLR = UNIMPLEMENTED,
184         .KEY = UNIMPLEMENTED,
185         .CBC = 11,
186         .IDCODE = 12,
187         .AXSS = 13,
188         .C0R_1 = 14,
189         .CSOB = 15,
190         .WBSTAR = 16,
191         .TIMER = 17,
192         .BOOTSTS = 18,
193         .CTL_1 = 19,
194 };
195 
196 static const struct config_registers v6_config_registers = {
197         .CRC = 0,
198         .FAR = 1,
199         .FDRI = 2,
200         .FDRO = 3,
201         .CMD = 4,
202         .CTL = 5,
203         .MASK = 6,
204         .STAT = 7,
205         .LOUT = 8,
206         .COR = 9,
207         .MFWR = 10,
208         .FLR = UNIMPLEMENTED,
209         .KEY = UNIMPLEMENTED,
210         .CBC = 11,
211         .IDCODE = 12,
212         .AXSS = 13,
213         .C0R_1 = 14,
214         .CSOB = 15,
215         .WBSTAR = 16,
216         .TIMER = 17,
217         .BOOTSTS = 22,
218         .CTL_1 = 24,
219 };
220 
221 /**
222  * hwicap_command_desync - Send a DESYNC command to the ICAP port.
223  * @drvdata: a pointer to the drvdata.
224  *
225  * This command desynchronizes the ICAP After this command, a
226  * bitstream containing a NULL packet, followed by a SYNCH packet is
227  * required before the ICAP will recognize commands.
228  */
229 static int hwicap_command_desync(struct hwicap_drvdata *drvdata)
230 {
231         u32 buffer[4];
232         u32 index = 0;
233 
234         /*
235          * Create the data to be written to the ICAP.
236          */
237         buffer[index++] = hwicap_type_1_write(drvdata->config_regs->CMD) | 1;
238         buffer[index++] = XHI_CMD_DESYNCH;
239         buffer[index++] = XHI_NOOP_PACKET;
240         buffer[index++] = XHI_NOOP_PACKET;
241 
242         /*
243          * Write the data to the FIFO and intiate the transfer of data present
244          * in the FIFO to the ICAP device.
245          */
246         return drvdata->config->set_configuration(drvdata,
247                         &buffer[0], index);
248 }
249 
250 /**
251  * hwicap_get_configuration_register - Query a configuration register.
252  * @drvdata: a pointer to the drvdata.
253  * @reg: a constant which represents the configuration
254  *              register value to be returned.
255  *              Examples:  XHI_IDCODE, XHI_FLR.
256  * @reg_data: returns the value of the register.
257  *
258  * Sends a query packet to the ICAP and then receives the response.
259  * The icap is left in Synched state.
260  */
261 static int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata,
262                 u32 reg, u32 *reg_data)
263 {
264         int status;
265         u32 buffer[6];
266         u32 index = 0;
267 
268         /*
269          * Create the data to be written to the ICAP.
270          */
271         buffer[index++] = XHI_DUMMY_PACKET;
272         buffer[index++] = XHI_NOOP_PACKET;
273         buffer[index++] = XHI_SYNC_PACKET;
274         buffer[index++] = XHI_NOOP_PACKET;
275         buffer[index++] = XHI_NOOP_PACKET;
276 
277         /*
278          * Write the data to the FIFO and initiate the transfer of data present
279          * in the FIFO to the ICAP device.
280          */
281         status = drvdata->config->set_configuration(drvdata,
282                                                     &buffer[0], index);
283         if (status)
284                 return status;
285 
286         /* If the syncword was not found, then we need to start over. */
287         status = drvdata->config->get_status(drvdata);
288         if ((status & XHI_SR_DALIGN_MASK) != XHI_SR_DALIGN_MASK)
289                 return -EIO;
290 
291         index = 0;
292         buffer[index++] = hwicap_type_1_read(reg) | 1;
293         buffer[index++] = XHI_NOOP_PACKET;
294         buffer[index++] = XHI_NOOP_PACKET;
295 
296         /*
297          * Write the data to the FIFO and intiate the transfer of data present
298          * in the FIFO to the ICAP device.
299          */
300         status = drvdata->config->set_configuration(drvdata,
301                         &buffer[0], index);
302         if (status)
303                 return status;
304 
305         /*
306          * Read the configuration register
307          */
308         status = drvdata->config->get_configuration(drvdata, reg_data, 1);
309         if (status)
310                 return status;
311 
312         return 0;
313 }
314 
315 static int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata)
316 {
317         int status;
318         u32 idcode;
319 
320         dev_dbg(drvdata->dev, "initializing\n");
321 
322         /* Abort any current transaction, to make sure we have the
323          * ICAP in a good state. */
324         dev_dbg(drvdata->dev, "Reset...\n");
325         drvdata->config->reset(drvdata);
326 
327         dev_dbg(drvdata->dev, "Desync...\n");
328         status = hwicap_command_desync(drvdata);
329         if (status)
330                 return status;
331 
332         /* Attempt to read the IDCODE from ICAP.  This
333          * may not be returned correctly, due to the design of the
334          * hardware.
335          */
336         dev_dbg(drvdata->dev, "Reading IDCODE...\n");
337         status = hwicap_get_configuration_register(
338                         drvdata, drvdata->config_regs->IDCODE, &idcode);
339         dev_dbg(drvdata->dev, "IDCODE = %x\n", idcode);
340         if (status)
341                 return status;
342 
343         dev_dbg(drvdata->dev, "Desync...\n");
344         status = hwicap_command_desync(drvdata);
345         if (status)
346                 return status;
347 
348         return 0;
349 }
350 
351 static ssize_t
352 hwicap_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
353 {
354         struct hwicap_drvdata *drvdata = file->private_data;
355         ssize_t bytes_to_read = 0;
356         u32 *kbuf;
357         u32 words;
358         u32 bytes_remaining;
359         int status;
360 
361         status = mutex_lock_interruptible(&drvdata->sem);
362         if (status)
363                 return status;
364 
365         if (drvdata->read_buffer_in_use) {
366                 /* If there are leftover bytes in the buffer, just */
367                 /* return them and don't try to read more from the */
368                 /* ICAP device. */
369                 bytes_to_read =
370                         (count < drvdata->read_buffer_in_use) ? count :
371                         drvdata->read_buffer_in_use;
372 
373                 /* Return the data currently in the read buffer. */
374                 if (copy_to_user(buf, drvdata->read_buffer, bytes_to_read)) {
375                         status = -EFAULT;
376                         goto error;
377                 }
378                 drvdata->read_buffer_in_use -= bytes_to_read;
379                 memmove(drvdata->read_buffer,
380                        drvdata->read_buffer + bytes_to_read,
381                        4 - bytes_to_read);
382         } else {
383                 /* Get new data from the ICAP, and return was was requested. */
384                 kbuf = (u32 *) get_zeroed_page(GFP_KERNEL);
385                 if (!kbuf) {
386                         status = -ENOMEM;
387                         goto error;
388                 }
389 
390                 /* The ICAP device is only able to read complete */
391                 /* words.  If a number of bytes that do not correspond */
392                 /* to complete words is requested, then we read enough */
393                 /* words to get the required number of bytes, and then */
394                 /* save the remaining bytes for the next read. */
395 
396                 /* Determine the number of words to read, rounding up */
397                 /* if necessary. */
398                 words = ((count + 3) >> 2);
399                 bytes_to_read = words << 2;
400 
401                 if (bytes_to_read > PAGE_SIZE)
402                         bytes_to_read = PAGE_SIZE;
403 
404                 /* Ensure we only read a complete number of words. */
405                 bytes_remaining = bytes_to_read & 3;
406                 bytes_to_read &= ~3;
407                 words = bytes_to_read >> 2;
408 
409                 status = drvdata->config->get_configuration(drvdata,
410                                 kbuf, words);
411 
412                 /* If we didn't read correctly, then bail out. */
413                 if (status) {
414                         free_page((unsigned long)kbuf);
415                         goto error;
416                 }
417 
418                 /* If we fail to return the data to the user, then bail out. */
419                 if (copy_to_user(buf, kbuf, bytes_to_read)) {
420                         free_page((unsigned long)kbuf);
421                         status = -EFAULT;
422                         goto error;
423                 }
424                 memcpy(drvdata->read_buffer,
425                        kbuf,
426                        bytes_remaining);
427                 drvdata->read_buffer_in_use = bytes_remaining;
428                 free_page((unsigned long)kbuf);
429         }
430         status = bytes_to_read;
431  error:
432         mutex_unlock(&drvdata->sem);
433         return status;
434 }
435 
436 static ssize_t
437 hwicap_write(struct file *file, const char __user *buf,
438                 size_t count, loff_t *ppos)
439 {
440         struct hwicap_drvdata *drvdata = file->private_data;
441         ssize_t written = 0;
442         ssize_t left = count;
443         u32 *kbuf;
444         ssize_t len;
445         ssize_t status;
446 
447         status = mutex_lock_interruptible(&drvdata->sem);
448         if (status)
449                 return status;
450 
451         left += drvdata->write_buffer_in_use;
452 
453         /* Only write multiples of 4 bytes. */
454         if (left < 4) {
455                 status = 0;
456                 goto error;
457         }
458 
459         kbuf = (u32 *) __get_free_page(GFP_KERNEL);
460         if (!kbuf) {
461                 status = -ENOMEM;
462                 goto error;
463         }
464 
465         while (left > 3) {
466                 /* only write multiples of 4 bytes, so there might */
467                 /* be as many as 3 bytes left (at the end). */
468                 len = left;
469 
470                 if (len > PAGE_SIZE)
471                         len = PAGE_SIZE;
472                 len &= ~3;
473 
474                 if (drvdata->write_buffer_in_use) {
475                         memcpy(kbuf, drvdata->write_buffer,
476                                         drvdata->write_buffer_in_use);
477                         if (copy_from_user(
478                             (((char *)kbuf) + drvdata->write_buffer_in_use),
479                             buf + written,
480                             len - (drvdata->write_buffer_in_use))) {
481                                 free_page((unsigned long)kbuf);
482                                 status = -EFAULT;
483                                 goto error;
484                         }
485                 } else {
486                         if (copy_from_user(kbuf, buf + written, len)) {
487                                 free_page((unsigned long)kbuf);
488                                 status = -EFAULT;
489                                 goto error;
490                         }
491                 }
492 
493                 status = drvdata->config->set_configuration(drvdata,
494                                 kbuf, len >> 2);
495 
496                 if (status) {
497                         free_page((unsigned long)kbuf);
498                         status = -EFAULT;
499                         goto error;
500                 }
501                 if (drvdata->write_buffer_in_use) {
502                         len -= drvdata->write_buffer_in_use;
503                         left -= drvdata->write_buffer_in_use;
504                         drvdata->write_buffer_in_use = 0;
505                 }
506                 written += len;
507                 left -= len;
508         }
509         if ((left > 0) && (left < 4)) {
510                 if (!copy_from_user(drvdata->write_buffer,
511                                                 buf + written, left)) {
512                         drvdata->write_buffer_in_use = left;
513                         written += left;
514                         left = 0;
515                 }
516         }
517 
518         free_page((unsigned long)kbuf);
519         status = written;
520  error:
521         mutex_unlock(&drvdata->sem);
522         return status;
523 }
524 
525 static int hwicap_open(struct inode *inode, struct file *file)
526 {
527         struct hwicap_drvdata *drvdata;
528         int status;
529 
530         mutex_lock(&hwicap_mutex);
531         drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev);
532 
533         status = mutex_lock_interruptible(&drvdata->sem);
534         if (status)
535                 goto out;
536 
537         if (drvdata->is_open) {
538                 status = -EBUSY;
539                 goto error;
540         }
541 
542         status = hwicap_initialize_hwicap(drvdata);
543         if (status) {
544                 dev_err(drvdata->dev, "Failed to open file");
545                 goto error;
546         }
547 
548         file->private_data = drvdata;
549         drvdata->write_buffer_in_use = 0;
550         drvdata->read_buffer_in_use = 0;
551         drvdata->is_open = 1;
552 
553  error:
554         mutex_unlock(&drvdata->sem);
555  out:
556         mutex_unlock(&hwicap_mutex);
557         return status;
558 }
559 
560 static int hwicap_release(struct inode *inode, struct file *file)
561 {
562         struct hwicap_drvdata *drvdata = file->private_data;
563         int i;
564         int status = 0;
565 
566         mutex_lock(&drvdata->sem);
567 
568         if (drvdata->write_buffer_in_use) {
569                 /* Flush write buffer. */
570                 for (i = drvdata->write_buffer_in_use; i < 4; i++)
571                         drvdata->write_buffer[i] = 0;
572 
573                 status = drvdata->config->set_configuration(drvdata,
574                                 (u32 *) drvdata->write_buffer, 1);
575                 if (status)
576                         goto error;
577         }
578 
579         status = hwicap_command_desync(drvdata);
580         if (status)
581                 goto error;
582 
583  error:
584         drvdata->is_open = 0;
585         mutex_unlock(&drvdata->sem);
586         return status;
587 }
588 
589 static const struct file_operations hwicap_fops = {
590         .owner = THIS_MODULE,
591         .write = hwicap_write,
592         .read = hwicap_read,
593         .open = hwicap_open,
594         .release = hwicap_release,
595         .llseek = noop_llseek,
596 };
597 
598 static int hwicap_setup(struct device *dev, int id,
599                 const struct resource *regs_res,
600                 const struct hwicap_driver_config *config,
601                 const struct config_registers *config_regs)
602 {
603         dev_t devt;
604         struct hwicap_drvdata *drvdata = NULL;
605         int retval = 0;
606 
607         dev_info(dev, "Xilinx icap port driver\n");
608 
609         mutex_lock(&icap_sem);
610 
611         if (id < 0) {
612                 for (id = 0; id < HWICAP_DEVICES; id++)
613                         if (!probed_devices[id])
614                                 break;
615         }
616         if (id < 0 || id >= HWICAP_DEVICES) {
617                 mutex_unlock(&icap_sem);
618                 dev_err(dev, "%s%i too large\n", DRIVER_NAME, id);
619                 return -EINVAL;
620         }
621         if (probed_devices[id]) {
622                 mutex_unlock(&icap_sem);
623                 dev_err(dev, "cannot assign to %s%i; it is already in use\n",
624                         DRIVER_NAME, id);
625                 return -EBUSY;
626         }
627 
628         probed_devices[id] = 1;
629         mutex_unlock(&icap_sem);
630 
631         devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR + id);
632 
633         drvdata = kzalloc(sizeof(struct hwicap_drvdata), GFP_KERNEL);
634         if (!drvdata) {
635                 dev_err(dev, "Couldn't allocate device private record\n");
636                 retval = -ENOMEM;
637                 goto failed0;
638         }
639         dev_set_drvdata(dev, (void *)drvdata);
640 
641         if (!regs_res) {
642                 dev_err(dev, "Couldn't get registers resource\n");
643                 retval = -EFAULT;
644                 goto failed1;
645         }
646 
647         drvdata->mem_start = regs_res->start;
648         drvdata->mem_end = regs_res->end;
649         drvdata->mem_size = resource_size(regs_res);
650 
651         if (!request_mem_region(drvdata->mem_start,
652                                         drvdata->mem_size, DRIVER_NAME)) {
653                 dev_err(dev, "Couldn't lock memory region at %Lx\n",
654                         (unsigned long long) regs_res->start);
655                 retval = -EBUSY;
656                 goto failed1;
657         }
658 
659         drvdata->devt = devt;
660         drvdata->dev = dev;
661         drvdata->base_address = ioremap(drvdata->mem_start, drvdata->mem_size);
662         if (!drvdata->base_address) {
663                 dev_err(dev, "ioremap() failed\n");
664                 retval = -ENOMEM;
665                 goto failed2;
666         }
667 
668         drvdata->config = config;
669         drvdata->config_regs = config_regs;
670 
671         mutex_init(&drvdata->sem);
672         drvdata->is_open = 0;
673 
674         dev_info(dev, "ioremap %llx to %p with size %llx\n",
675                  (unsigned long long) drvdata->mem_start,
676                  drvdata->base_address,
677                  (unsigned long long) drvdata->mem_size);
678 
679         cdev_init(&drvdata->cdev, &hwicap_fops);
680         drvdata->cdev.owner = THIS_MODULE;
681         retval = cdev_add(&drvdata->cdev, devt, 1);
682         if (retval) {
683                 dev_err(dev, "cdev_add() failed\n");
684                 goto failed3;
685         }
686 
687         device_create(icap_class, dev, devt, NULL, "%s%d", DRIVER_NAME, id);
688         return 0;               /* success */
689 
690  failed3:
691         iounmap(drvdata->base_address);
692 
693  failed2:
694         release_mem_region(regs_res->start, drvdata->mem_size);
695 
696  failed1:
697         kfree(drvdata);
698 
699  failed0:
700         mutex_lock(&icap_sem);
701         probed_devices[id] = 0;
702         mutex_unlock(&icap_sem);
703 
704         return retval;
705 }
706 
707 static struct hwicap_driver_config buffer_icap_config = {
708         .get_configuration = buffer_icap_get_configuration,
709         .set_configuration = buffer_icap_set_configuration,
710         .get_status = buffer_icap_get_status,
711         .reset = buffer_icap_reset,
712 };
713 
714 static struct hwicap_driver_config fifo_icap_config = {
715         .get_configuration = fifo_icap_get_configuration,
716         .set_configuration = fifo_icap_set_configuration,
717         .get_status = fifo_icap_get_status,
718         .reset = fifo_icap_reset,
719 };
720 
721 static int hwicap_remove(struct device *dev)
722 {
723         struct hwicap_drvdata *drvdata;
724 
725         drvdata = dev_get_drvdata(dev);
726 
727         if (!drvdata)
728                 return 0;
729 
730         device_destroy(icap_class, drvdata->devt);
731         cdev_del(&drvdata->cdev);
732         iounmap(drvdata->base_address);
733         release_mem_region(drvdata->mem_start, drvdata->mem_size);
734         kfree(drvdata);
735 
736         mutex_lock(&icap_sem);
737         probed_devices[MINOR(dev->devt)-XHWICAP_MINOR] = 0;
738         mutex_unlock(&icap_sem);
739         return 0;               /* success */
740 }
741 
742 #ifdef CONFIG_OF
743 static int hwicap_of_probe(struct platform_device *op,
744                                      const struct hwicap_driver_config *config)
745 {
746         struct resource res;
747         const unsigned int *id;
748         const char *family;
749         int rc;
750         const struct config_registers *regs;
751 
752 
753         rc = of_address_to_resource(op->dev.of_node, 0, &res);
754         if (rc) {
755                 dev_err(&op->dev, "invalid address\n");
756                 return rc;
757         }
758 
759         id = of_get_property(op->dev.of_node, "port-number", NULL);
760 
761         /* It's most likely that we're using V4, if the family is not
762            specified */
763         regs = &v4_config_registers;
764         family = of_get_property(op->dev.of_node, "xlnx,family", NULL);
765 
766         if (family) {
767                 if (!strcmp(family, "virtex2p")) {
768                         regs = &v2_config_registers;
769                 } else if (!strcmp(family, "virtex4")) {
770                         regs = &v4_config_registers;
771                 } else if (!strcmp(family, "virtex5")) {
772                         regs = &v5_config_registers;
773                 } else if (!strcmp(family, "virtex6")) {
774                         regs = &v6_config_registers;
775                 }
776         }
777         return hwicap_setup(&op->dev, id ? *id : -1, &res, config,
778                         regs);
779 }
780 #else
781 static inline int hwicap_of_probe(struct platform_device *op,
782                                   const struct hwicap_driver_config *config)
783 {
784         return -EINVAL;
785 }
786 #endif /* CONFIG_OF */
787 
788 static const struct of_device_id hwicap_of_match[];
789 static int hwicap_drv_probe(struct platform_device *pdev)
790 {
791         const struct of_device_id *match;
792         struct resource *res;
793         const struct config_registers *regs;
794         const char *family;
795 
796         match = of_match_device(hwicap_of_match, &pdev->dev);
797         if (match)
798                 return hwicap_of_probe(pdev, match->data);
799 
800         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
801         if (!res)
802                 return -ENODEV;
803 
804         /* It's most likely that we're using V4, if the family is not
805            specified */
806         regs = &v4_config_registers;
807         family = pdev->dev.platform_data;
808 
809         if (family) {
810                 if (!strcmp(family, "virtex2p")) {
811                         regs = &v2_config_registers;
812                 } else if (!strcmp(family, "virtex4")) {
813                         regs = &v4_config_registers;
814                 } else if (!strcmp(family, "virtex5")) {
815                         regs = &v5_config_registers;
816                 } else if (!strcmp(family, "virtex6")) {
817                         regs = &v6_config_registers;
818                 }
819         }
820 
821         return hwicap_setup(&pdev->dev, pdev->id, res,
822                         &buffer_icap_config, regs);
823 }
824 
825 static int hwicap_drv_remove(struct platform_device *pdev)
826 {
827         return hwicap_remove(&pdev->dev);
828 }
829 
830 #ifdef CONFIG_OF
831 /* Match table for device tree binding */
832 static const struct of_device_id hwicap_of_match[] = {
833         { .compatible = "xlnx,opb-hwicap-1.00.b", .data = &buffer_icap_config},
834         { .compatible = "xlnx,xps-hwicap-1.00.a", .data = &fifo_icap_config},
835         {},
836 };
837 MODULE_DEVICE_TABLE(of, hwicap_of_match);
838 #else
839 #define hwicap_of_match NULL
840 #endif
841 
842 static struct platform_driver hwicap_platform_driver = {
843         .probe = hwicap_drv_probe,
844         .remove = hwicap_drv_remove,
845         .driver = {
846                 .name = DRIVER_NAME,
847                 .of_match_table = hwicap_of_match,
848         },
849 };
850 
851 static int __init hwicap_module_init(void)
852 {
853         dev_t devt;
854         int retval;
855 
856         icap_class = class_create(THIS_MODULE, "xilinx_config");
857         mutex_init(&icap_sem);
858 
859         devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR);
860         retval = register_chrdev_region(devt,
861                                         HWICAP_DEVICES,
862                                         DRIVER_NAME);
863         if (retval < 0)
864                 return retval;
865 
866         retval = platform_driver_register(&hwicap_platform_driver);
867         if (retval)
868                 goto failed;
869 
870         return retval;
871 
872  failed:
873         unregister_chrdev_region(devt, HWICAP_DEVICES);
874 
875         return retval;
876 }
877 
878 static void __exit hwicap_module_cleanup(void)
879 {
880         dev_t devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR);
881 
882         class_destroy(icap_class);
883 
884         platform_driver_unregister(&hwicap_platform_driver);
885 
886         unregister_chrdev_region(devt, HWICAP_DEVICES);
887 }
888 
889 module_init(hwicap_module_init);
890 module_exit(hwicap_module_cleanup);
891 
892 MODULE_AUTHOR("Xilinx, Inc; Xilinx Research Labs Group");
893 MODULE_DESCRIPTION("Xilinx ICAP Port Driver");
894 MODULE_LICENSE("GPL");
895 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us