[POWERPC] Xilinx: hwicap cleanup (f62f2fdd) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/char/xilinx_hwicap/buffer_icap.c

+40 −40

drivers/char/xilinx_hwicap/fifo_icap.c

+30 −30

Original line number	Original line	Diff line number	Diff line
	@@ -94,9 +94,9 @@


	/**		/**
	* fifo_icap_fifo_write: Write data to the write FIFO.		* fifo_icap_fifo_write - Write data to the write FIFO.
	* @parameter drvdata: a pointer to the drvdata.		* @drvdata: a pointer to the drvdata.
	* @parameter data: the 32-bit value to be written to the FIFO.		* @data: the 32-bit value to be written to the FIFO.
	*		*
	* This function will silently fail if the fifo is full.		* This function will silently fail if the fifo is full.
	**/		**/
	@@ -108,8 +108,8 @@ static inline void fifo_icap_fifo_write(struct hwicap_drvdata *drvdata,
	}		}

	/**		/**
	* fifo_icap_fifo_read: Read data from the Read FIFO.		* fifo_icap_fifo_read - Read data from the Read FIFO.
	* @parameter drvdata: a pointer to the drvdata.		* @drvdata: a pointer to the drvdata.
	*		*
	* This function will silently fail if the fifo is empty.		* This function will silently fail if the fifo is empty.
	**/		**/
	@@ -121,9 +121,9 @@ static inline u32 fifo_icap_fifo_read(struct hwicap_drvdata *drvdata)
	}		}

	/**		/**
	* fifo_icap_set_read_size: Set the the size register.		* fifo_icap_set_read_size - Set the the size register.
	* @parameter drvdata: a pointer to the drvdata.		* @drvdata: a pointer to the drvdata.
	* @parameter data: the size of the following read transaction, in words.		* @data: the size of the following read transaction, in words.
	**/		**/
	static inline void fifo_icap_set_read_size(struct hwicap_drvdata *drvdata,		static inline void fifo_icap_set_read_size(struct hwicap_drvdata *drvdata,
	u32 data)		u32 data)
	@@ -132,8 +132,8 @@ static inline void fifo_icap_set_read_size(struct hwicap_drvdata *drvdata,
	}		}

	/**		/**
	* fifo_icap_start_config: Initiate a configuration (write) to the device.		* fifo_icap_start_config - Initiate a configuration (write) to the device.
	* @parameter drvdata: a pointer to the drvdata.		* @drvdata: a pointer to the drvdata.
	**/		**/
	static inline void fifo_icap_start_config(struct hwicap_drvdata *drvdata)		static inline void fifo_icap_start_config(struct hwicap_drvdata *drvdata)
	{		{
	@@ -142,8 +142,8 @@ static inline void fifo_icap_start_config(struct hwicap_drvdata *drvdata)
	}		}

	/**		/**
	* fifo_icap_start_readback: Initiate a readback from the device.		* fifo_icap_start_readback - Initiate a readback from the device.
	* @parameter drvdata: a pointer to the drvdata.		* @drvdata: a pointer to the drvdata.
	**/		**/
	static inline void fifo_icap_start_readback(struct hwicap_drvdata *drvdata)		static inline void fifo_icap_start_readback(struct hwicap_drvdata *drvdata)
	{		{
	@@ -152,8 +152,8 @@ static inline void fifo_icap_start_readback(struct hwicap_drvdata *drvdata)
	}		}

	/**		/**
	* fifo_icap_busy: Return true if the ICAP is still processing a transaction.		* fifo_icap_busy - Return true if the ICAP is still processing a transaction.
	* @parameter drvdata: a pointer to the drvdata.		* @drvdata: a pointer to the drvdata.
	**/		**/
	static inline u32 fifo_icap_busy(struct hwicap_drvdata *drvdata)		static inline u32 fifo_icap_busy(struct hwicap_drvdata *drvdata)
	{		{
	@@ -163,8 +163,8 @@ static inline u32 fifo_icap_busy(struct hwicap_drvdata *drvdata)
	}		}

	/**		/**
	* fifo_icap_write_fifo_vacancy: Query the write fifo available space.		* fifo_icap_write_fifo_vacancy - Query the write fifo available space.
	* @parameter drvdata: a pointer to the drvdata.		* @drvdata: a pointer to the drvdata.
	*		*
	* Return the number of words that can be safely pushed into the write fifo.		* Return the number of words that can be safely pushed into the write fifo.
	**/		**/
	@@ -175,8 +175,8 @@ static inline u32 fifo_icap_write_fifo_vacancy(
	}		}

	/**		/**
	* fifo_icap_read_fifo_occupancy: Query the read fifo available data.		* fifo_icap_read_fifo_occupancy - Query the read fifo available data.
	* @parameter drvdata: a pointer to the drvdata.		* @drvdata: a pointer to the drvdata.
	*		*
	* Return the number of words that can be safely read from the read fifo.		* Return the number of words that can be safely read from the read fifo.
	**/		**/
	@@ -187,11 +187,11 @@ static inline u32 fifo_icap_read_fifo_occupancy(
	}		}

	/**		/**
	* fifo_icap_set_configuration: Send configuration data to the ICAP.		* fifo_icap_set_configuration - Send configuration data to the ICAP.
	* @parameter drvdata: a pointer to the drvdata.		* @drvdata: a pointer to the drvdata.
	* @parameter frame_buffer: a pointer to the data to be written to the		* @frame_buffer: a pointer to the data to be written to the
	* ICAP device.		* ICAP device.
	* @parameter num_words: the number of words (32 bit) to write to the ICAP		* @num_words: the number of words (32 bit) to write to the ICAP
	* device.		* device.

	* This function writes the given user data to the Write FIFO in		* This function writes the given user data to the Write FIFO in
	@@ -266,10 +266,10 @@ int fifo_icap_set_configuration(struct hwicap_drvdata *drvdata,
	}		}

	/**		/**
	* fifo_icap_get_configuration: Read configuration data from the device.		* fifo_icap_get_configuration - Read configuration data from the device.
	* @parameter drvdata: a pointer to the drvdata.		* @drvdata: a pointer to the drvdata.
	* @parameter data: Address of the data representing the partial bitstream		* @data: Address of the data representing the partial bitstream
	* @parameter size: the size of the partial bitstream in 32 bit words.		* @size: the size of the partial bitstream in 32 bit words.
	*		*
	* This function reads the specified number of words from the ICAP device in		* This function reads the specified number of words from the ICAP device in
	* the polled mode.		* the polled mode.
	@@ -335,8 +335,8 @@ int fifo_icap_get_configuration(struct hwicap_drvdata *drvdata,
	}		}

	/**		/**
	* buffer_icap_reset: Reset the logic of the icap device.		* buffer_icap_reset - Reset the logic of the icap device.
	* @parameter drvdata: a pointer to the drvdata.		* @drvdata: a pointer to the drvdata.
	*		*
	* This function forces the software reset of the complete HWICAP device.		* This function forces the software reset of the complete HWICAP device.
	* All the registers will return to the default value and the FIFO is also		* All the registers will return to the default value and the FIFO is also
	@@ -360,8 +360,8 @@ void fifo_icap_reset(struct hwicap_drvdata *drvdata)
	}		}

	/**		/**
	* fifo_icap_flush_fifo: This function flushes the FIFOs in the device.		* fifo_icap_flush_fifo - This function flushes the FIFOs in the device.
	* @parameter drvdata: a pointer to the drvdata.		* @drvdata: a pointer to the drvdata.
	*/		*/
	void fifo_icap_flush_fifo(struct hwicap_drvdata *drvdata)		void fifo_icap_flush_fifo(struct hwicap_drvdata *drvdata)
	{		{

drivers/char/xilinx_hwicap/xilinx_hwicap.c

+62 −76

Original line number	Original line	Diff line number	Diff line
	@@ -84,7 +84,7 @@
	#include <linux/init.h>		#include <linux/init.h>
	#include <linux/poll.h>		#include <linux/poll.h>
	#include <linux/proc_fs.h>		#include <linux/proc_fs.h>
	#include <asm/semaphore.h>		#include <linux/mutex.h>
	#include <linux/sysctl.h>		#include <linux/sysctl.h>
	#include <linux/version.h>		#include <linux/version.h>
	#include <linux/fs.h>		#include <linux/fs.h>
	@@ -119,6 +119,7 @@ module_param(xhwicap_minor, int, S_IRUGO);

	/* An array, which is set to true when the device is registered. */		/* An array, which is set to true when the device is registered. */
	static bool probed_devices[HWICAP_DEVICES];		static bool probed_devices[HWICAP_DEVICES];
			static struct mutex icap_sem;

	static struct class *icap_class;		static struct class *icap_class;

	@@ -199,14 +200,14 @@ static const struct config_registers v5_config_registers = {
	};		};

	/**		/**
	* hwicap_command_desync: Send a DESYNC command to the ICAP port.		* hwicap_command_desync - Send a DESYNC command to the ICAP port.
	* @parameter drvdata: a pointer to the drvdata.		* @drvdata: a pointer to the drvdata.
	*		*
	* This command desynchronizes the ICAP After this command, a		* This command desynchronizes the ICAP After this command, a
	* bitstream containing a NULL packet, followed by a SYNCH packet is		* bitstream containing a NULL packet, followed by a SYNCH packet is
	* required before the ICAP will recognize commands.		* required before the ICAP will recognize commands.
	*/		*/
	int hwicap_command_desync(struct hwicap_drvdata *drvdata)		static int hwicap_command_desync(struct hwicap_drvdata *drvdata)
	{		{
	u32 buffer[4];		u32 buffer[4];
	u32 index = 0;		u32 index = 0;
	@@ -228,51 +229,18 @@ int hwicap_command_desync(struct hwicap_drvdata *drvdata)
	}		}

	/**		/**
	* hwicap_command_capture: Send a CAPTURE command to the ICAP port.		* hwicap_get_configuration_register - Query a configuration register.
	* @parameter drvdata: a pointer to the drvdata.		* @drvdata: a pointer to the drvdata.
	*		* @reg: a constant which represents the configuration
	* This command captures all of the flip flop states so they will be
	* available during readback. One can use this command instead of
	* enabling the CAPTURE block in the design.
	*/
	int hwicap_command_capture(struct hwicap_drvdata *drvdata)
	{
	u32 buffer[7];
	u32 index = 0;

	/*
	* Create the data to be written to the ICAP.
	*/
	buffer[index++] = XHI_DUMMY_PACKET;
	buffer[index++] = XHI_SYNC_PACKET;
	buffer[index++] = XHI_NOOP_PACKET;
	buffer[index++] = hwicap_type_1_write(drvdata->config_regs->CMD) \| 1;
	buffer[index++] = XHI_CMD_GCAPTURE;
	buffer[index++] = XHI_DUMMY_PACKET;
	buffer[index++] = XHI_DUMMY_PACKET;

	/*
	* Write the data to the FIFO and intiate the transfer of data
	* present in the FIFO to the ICAP device.
	*/
	return drvdata->config->set_configuration(drvdata,
	&buffer[0], index);

	}

	/**
	* hwicap_get_configuration_register: Query a configuration register.
	* @parameter drvdata: a pointer to the drvdata.
	* @parameter reg: a constant which represents the configuration
	* register value to be returned.		* register value to be returned.
	* Examples: XHI_IDCODE, XHI_FLR.		* Examples: XHI_IDCODE, XHI_FLR.
	* @parameter RegData: returns the value of the register.		* @reg_data: returns the value of the register.
	*		*
	* Sends a query packet to the ICAP and then receives the response.		* Sends a query packet to the ICAP and then receives the response.
	* The icap is left in Synched state.		* The icap is left in Synched state.
	*/		*/
	int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata,		static int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata,
	u32 reg, u32 *RegData)		u32 reg, u32 *reg_data)
	{		{
	int status;		int status;
	u32 buffer[6];		u32 buffer[6];
	@@ -300,14 +268,14 @@ int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata,
	/*		/*
	* Read the configuration register		* Read the configuration register
	*/		*/
	status = drvdata->config->get_configuration(drvdata, RegData, 1);		status = drvdata->config->get_configuration(drvdata, reg_data, 1);
	if (status)		if (status)
	return status;		return status;

	return 0;		return 0;
	}		}

	int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata)		static int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata)
	{		{
	int status;		int status;
	u32 idcode;		u32 idcode;
	@@ -344,7 +312,7 @@ int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata)
	}		}

	static ssize_t		static ssize_t
	hwicap_read(struct file file, char buf, size_t count, loff_t *ppos)		hwicap_read(struct file file, char __user buf, size_t count, loff_t *ppos)
	{		{
	struct hwicap_drvdata *drvdata = file->private_data;		struct hwicap_drvdata *drvdata = file->private_data;
	ssize_t bytes_to_read = 0;		ssize_t bytes_to_read = 0;
	@@ -353,8 +321,9 @@ hwicap_read(struct file file, char buf, size_t count, loff_t *ppos)
	u32 bytes_remaining;		u32 bytes_remaining;
	int status;		int status;

	if (down_interruptible(&drvdata->sem))		status = mutex_lock_interruptible(&drvdata->sem);
	return -ERESTARTSYS;		if (status)
			return status;

	if (drvdata->read_buffer_in_use) {		if (drvdata->read_buffer_in_use) {
	/* If there are leftover bytes in the buffer, just */		/* If there are leftover bytes in the buffer, just */
	@@ -370,8 +339,9 @@ hwicap_read(struct file file, char buf, size_t count, loff_t *ppos)
	goto error;		goto error;
	}		}
	drvdata->read_buffer_in_use -= bytes_to_read;		drvdata->read_buffer_in_use -= bytes_to_read;
	memcpy(drvdata->read_buffer + bytes_to_read,		memmove(drvdata->read_buffer,
	drvdata->read_buffer, 4 - bytes_to_read);		drvdata->read_buffer + bytes_to_read,
			4 - bytes_to_read);
	} else {		} else {
	/* Get new data from the ICAP, and return was was requested. */		/* Get new data from the ICAP, and return was was requested. */
	kbuf = (u32 *) get_zeroed_page(GFP_KERNEL);		kbuf = (u32 *) get_zeroed_page(GFP_KERNEL);
	@@ -414,18 +384,20 @@ hwicap_read(struct file file, char buf, size_t count, loff_t *ppos)
	status = -EFAULT;		status = -EFAULT;
	goto error;		goto error;
	}		}
	memcpy(kbuf, drvdata->read_buffer, bytes_remaining);		memcpy(drvdata->read_buffer,
			kbuf,
			bytes_remaining);
	drvdata->read_buffer_in_use = bytes_remaining;		drvdata->read_buffer_in_use = bytes_remaining;
	free_page((unsigned long)kbuf);		free_page((unsigned long)kbuf);
	}		}
	status = bytes_to_read;		status = bytes_to_read;
	error:		error:
	up(&drvdata->sem);		mutex_unlock(&drvdata->sem);
	return status;		return status;
	}		}

	static ssize_t		static ssize_t
	hwicap_write(struct file file, const char buf,		hwicap_write(struct file file, const char __user buf,
	size_t count, loff_t *ppos)		size_t count, loff_t *ppos)
	{		{
	struct hwicap_drvdata *drvdata = file->private_data;		struct hwicap_drvdata *drvdata = file->private_data;
	@@ -435,8 +407,9 @@ hwicap_write(struct file file, const char buf,
	ssize_t len;		ssize_t len;
	ssize_t status;		ssize_t status;

	if (down_interruptible(&drvdata->sem))		status = mutex_lock_interruptible(&drvdata->sem);
	return -ERESTARTSYS;		if (status)
			return status;

	left += drvdata->write_buffer_in_use;		left += drvdata->write_buffer_in_use;

	@@ -465,7 +438,7 @@ hwicap_write(struct file file, const char buf,
	memcpy(kbuf, drvdata->write_buffer,		memcpy(kbuf, drvdata->write_buffer,
	drvdata->write_buffer_in_use);		drvdata->write_buffer_in_use);
	if (copy_from_user(		if (copy_from_user(
	(((char *)kbuf) + (drvdata->write_buffer_in_use)),		(((char *)kbuf) + drvdata->write_buffer_in_use),
	buf + written,		buf + written,
	len - (drvdata->write_buffer_in_use))) {		len - (drvdata->write_buffer_in_use))) {
	free_page((unsigned long)kbuf);		free_page((unsigned long)kbuf);
	@@ -508,7 +481,7 @@ hwicap_write(struct file file, const char buf,
	free_page((unsigned long)kbuf);		free_page((unsigned long)kbuf);
	status = written;		status = written;
	error:		error:
	up(&drvdata->sem);		mutex_unlock(&drvdata->sem);
	return status;		return status;
	}		}

	@@ -519,8 +492,9 @@ static int hwicap_open(struct inode inode, struct file file)

	drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev);		drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev);

	if (down_interruptible(&drvdata->sem))		status = mutex_lock_interruptible(&drvdata->sem);
	return -ERESTARTSYS;		if (status)
			return status;

	if (drvdata->is_open) {		if (drvdata->is_open) {
	status = -EBUSY;		status = -EBUSY;
	@@ -539,7 +513,7 @@ static int hwicap_open(struct inode inode, struct file file)
	drvdata->is_open = 1;		drvdata->is_open = 1;

	error:		error:
	up(&drvdata->sem);		mutex_unlock(&drvdata->sem);
	return status;		return status;
	}		}

	@@ -549,8 +523,7 @@ static int hwicap_release(struct inode inode, struct file file)
	int i;		int i;
	int status = 0;		int status = 0;

	if (down_interruptible(&drvdata->sem))		mutex_lock(&drvdata->sem);
	return -ERESTARTSYS;

	if (drvdata->write_buffer_in_use) {		if (drvdata->write_buffer_in_use) {
	/* Flush write buffer. */		/* Flush write buffer. */
	@@ -569,7 +542,7 @@ static int hwicap_release(struct inode inode, struct file file)

	error:		error:
	drvdata->is_open = 0;		drvdata->is_open = 0;
	up(&drvdata->sem);		mutex_unlock(&drvdata->sem);
	return status;		return status;
	}		}

	@@ -592,31 +565,36 @@ static int __devinit hwicap_setup(struct device *dev, int id,

	dev_info(dev, "Xilinx icap port driver\n");		dev_info(dev, "Xilinx icap port driver\n");

			mutex_lock(&icap_sem);

	if (id < 0) {		if (id < 0) {
	for (id = 0; id < HWICAP_DEVICES; id++)		for (id = 0; id < HWICAP_DEVICES; id++)
	if (!probed_devices[id])		if (!probed_devices[id])
	break;		break;
	}		}
	if (id < 0 \|\| id >= HWICAP_DEVICES) {		if (id < 0 \|\| id >= HWICAP_DEVICES) {
			mutex_unlock(&icap_sem);
	dev_err(dev, "%s%i too large\n", DRIVER_NAME, id);		dev_err(dev, "%s%i too large\n", DRIVER_NAME, id);
	return -EINVAL;		return -EINVAL;
	}		}
	if (probed_devices[id]) {		if (probed_devices[id]) {
			mutex_unlock(&icap_sem);
	dev_err(dev, "cannot assign to %s%i; it is already in use\n",		dev_err(dev, "cannot assign to %s%i; it is already in use\n",
	DRIVER_NAME, id);		DRIVER_NAME, id);
	return -EBUSY;		return -EBUSY;
	}		}

	probed_devices[id] = 1;		probed_devices[id] = 1;
			mutex_unlock(&icap_sem);

	devt = MKDEV(xhwicap_major, xhwicap_minor + id);		devt = MKDEV(xhwicap_major, xhwicap_minor + id);

	drvdata = kmalloc(sizeof(struct hwicap_drvdata), GFP_KERNEL);		drvdata = kzalloc(sizeof(struct hwicap_drvdata), GFP_KERNEL);
	if (!drvdata) {		if (!drvdata) {
	dev_err(dev, "Couldn't allocate device private record\n");		dev_err(dev, "Couldn't allocate device private record\n");
	return -ENOMEM;		retval = -ENOMEM;
			goto failed0;
	}		}
	memset((void *)drvdata, 0, sizeof(struct hwicap_drvdata));
	dev_set_drvdata(dev, (void *)drvdata);		dev_set_drvdata(dev, (void *)drvdata);

	if (!regs_res) {		if (!regs_res) {
	@@ -648,7 +626,7 @@ static int __devinit hwicap_setup(struct device *dev, int id,
	drvdata->config = config;		drvdata->config = config;
	drvdata->config_regs = config_regs;		drvdata->config_regs = config_regs;

	init_MUTEX(&drvdata->sem);		mutex_init(&drvdata->sem);
	drvdata->is_open = 0;		drvdata->is_open = 0;

	dev_info(dev, "ioremap %lx to %p with size %x\n",		dev_info(dev, "ioremap %lx to %p with size %x\n",
	@@ -663,7 +641,7 @@ static int __devinit hwicap_setup(struct device *dev, int id,
	goto failed3;		goto failed3;
	}		}
	/* devfs_mk_cdev(devt, S_IFCHR\|S_IRUGO\|S_IWUGO, DRIVER_NAME); */		/* devfs_mk_cdev(devt, S_IFCHR\|S_IRUGO\|S_IWUGO, DRIVER_NAME); */
	class_device_create(icap_class, NULL, devt, NULL, DRIVER_NAME);		device_create(icap_class, dev, devt, "%s%d", DRIVER_NAME, id);
	return 0; /* success */		return 0; /* success */

	failed3:		failed3:
	@@ -675,6 +653,11 @@ static int __devinit hwicap_setup(struct device *dev, int id,
	failed1:		failed1:
	kfree(drvdata);		kfree(drvdata);

			failed0:
			mutex_lock(&icap_sem);
			probed_devices[id] = 0;
			mutex_unlock(&icap_sem);

	return retval;		return retval;
	}		}

	@@ -699,14 +682,16 @@ static int __devexit hwicap_remove(struct device *dev)
	if (!drvdata)		if (!drvdata)
	return 0;		return 0;

	class_device_destroy(icap_class, drvdata->devt);		device_destroy(icap_class, drvdata->devt);
	cdev_del(&drvdata->cdev);		cdev_del(&drvdata->cdev);
	iounmap(drvdata->base_address);		iounmap(drvdata->base_address);
	release_mem_region(drvdata->mem_start, drvdata->mem_size);		release_mem_region(drvdata->mem_start, drvdata->mem_size);
	kfree(drvdata);		kfree(drvdata);
	dev_set_drvdata(dev, NULL);		dev_set_drvdata(dev, NULL);
	probed_devices[MINOR(dev->devt)-xhwicap_minor] = 0;

			mutex_lock(&icap_sem);
			probed_devices[MINOR(dev->devt)-xhwicap_minor] = 0;
			mutex_unlock(&icap_sem);
	return 0; /* success */		return 0; /* success */
	}		}

	@@ -821,28 +806,29 @@ static struct of_platform_driver hwicap_of_driver = {
	};		};

	/* Registration helpers to keep the number of #ifdefs to a minimum */		/* Registration helpers to keep the number of #ifdefs to a minimum */
	static inline int __devinit hwicap_of_register(void)		static inline int __init hwicap_of_register(void)
	{		{
	pr_debug("hwicap: calling of_register_platform_driver()\n");		pr_debug("hwicap: calling of_register_platform_driver()\n");
	return of_register_platform_driver(&hwicap_of_driver);		return of_register_platform_driver(&hwicap_of_driver);
	}		}

	static inline void __devexit hwicap_of_unregister(void)		static inline void __exit hwicap_of_unregister(void)
	{		{
	of_unregister_platform_driver(&hwicap_of_driver);		of_unregister_platform_driver(&hwicap_of_driver);
	}		}
	#else /* CONFIG_OF */		#else /* CONFIG_OF */
	/* CONFIG_OF not enabled; do nothing helpers */		/* CONFIG_OF not enabled; do nothing helpers */
	static inline int __devinit hwicap_of_register(void) { return 0; }		static inline int __init hwicap_of_register(void) { return 0; }
	static inline void __devexit hwicap_of_unregister(void) { }		static inline void __exit hwicap_of_unregister(void) { }
	#endif /* CONFIG_OF */		#endif /* CONFIG_OF */

	static int __devinit hwicap_module_init(void)		static int __init hwicap_module_init(void)
	{		{
	dev_t devt;		dev_t devt;
	int retval;		int retval;

	icap_class = class_create(THIS_MODULE, "xilinx_config");		icap_class = class_create(THIS_MODULE, "xilinx_config");
			mutex_init(&icap_sem);

	if (xhwicap_major) {		if (xhwicap_major) {
	devt = MKDEV(xhwicap_major, xhwicap_minor);		devt = MKDEV(xhwicap_major, xhwicap_minor);
	@@ -883,7 +869,7 @@ static int __devinit hwicap_module_init(void)
	return retval;		return retval;
	}		}

	static void __devexit hwicap_module_cleanup(void)		static void __exit hwicap_module_cleanup(void)
	{		{
	dev_t devt = MKDEV(xhwicap_major, xhwicap_minor);		dev_t devt = MKDEV(xhwicap_major, xhwicap_minor);

drivers/char/xilinx_hwicap/xilinx_hwicap.h

+12 −12

Original line number	Original line	Diff line number	Diff line
	@@ -48,9 +48,9 @@ struct hwicap_drvdata {
	u8 write_buffer[4];		u8 write_buffer[4];
	u32 read_buffer_in_use; /* Always in [0,3] */		u32 read_buffer_in_use; /* Always in [0,3] */
	u8 read_buffer[4];		u8 read_buffer[4];
	u32 mem_start; /* phys. address of the control registers */		resource_size_t mem_start;/* phys. address of the control registers */
	u32 mem_end; /* phys. address of the control registers */		resource_size_t mem_end; /* phys. address of the control registers */
	u32 mem_size;		resource_size_t mem_size;
	void __iomem base_address;/ virt. address of the control registers */		void __iomem base_address;/ virt. address of the control registers */

	struct device *dev;		struct device *dev;
	@@ -61,7 +61,7 @@ struct hwicap_drvdata {
	const struct config_registers *config_regs;		const struct config_registers *config_regs;
	void *private_data;		void *private_data;
	bool is_open;		bool is_open;
	struct semaphore sem;		struct mutex sem;
	};		};

	struct hwicap_driver_config {		struct hwicap_driver_config {
	@@ -164,29 +164,29 @@ struct config_registers {
	#define XHI_DISABLED_AUTO_CRC 0x0000DEFCUL		#define XHI_DISABLED_AUTO_CRC 0x0000DEFCUL

	/**		/**
	* hwicap_type_1_read: Generates a Type 1 read packet header.		* hwicap_type_1_read - Generates a Type 1 read packet header.
	* @parameter: Register is the address of the register to be read back.		* @reg: is the address of the register to be read back.
	*		*
	* Generates a Type 1 read packet header, which is used to indirectly		* Generates a Type 1 read packet header, which is used to indirectly
	* read registers in the configuration logic. This packet must then		* read registers in the configuration logic. This packet must then
	* be sent through the icap device, and a return packet received with		* be sent through the icap device, and a return packet received with
	* the information.		* the information.
	**/		**/
	static inline u32 hwicap_type_1_read(u32 Register)		static inline u32 hwicap_type_1_read(u32 reg)
	{		{
	return (XHI_TYPE_1 << XHI_TYPE_SHIFT) \|		return (XHI_TYPE_1 << XHI_TYPE_SHIFT) \|
	(Register << XHI_REGISTER_SHIFT) \|		(reg << XHI_REGISTER_SHIFT) \|
	(XHI_OP_READ << XHI_OP_SHIFT);		(XHI_OP_READ << XHI_OP_SHIFT);
	}		}

	/**		/**
	* hwicap_type_1_write: Generates a Type 1 write packet header		* hwicap_type_1_write - Generates a Type 1 write packet header
	* @parameter: Register is the address of the register to be read back.		* @reg: is the address of the register to be read back.
	**/		**/
	static inline u32 hwicap_type_1_write(u32 Register)		static inline u32 hwicap_type_1_write(u32 reg)
	{		{
	return (XHI_TYPE_1 << XHI_TYPE_SHIFT) \|		return (XHI_TYPE_1 << XHI_TYPE_SHIFT) \|
	(Register << XHI_REGISTER_SHIFT) \|		(reg << XHI_REGISTER_SHIFT) \|
	(XHI_OP_WRITE << XHI_OP_SHIFT);		(XHI_OP_WRITE << XHI_OP_SHIFT);
	}		}