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