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