drivers/spi/spidev.c - linux/kernel/git/mellanox/linux - Git at Google

 /*
  * spidev.c -- simple synchronous userspace interface to SPI devices
  *
  * Copyright (C) 2006 SWAPP
  *	Andrea Paterniani <a.paterniani@swapp-eng.it>
  * Copyright (C) 2007 David Brownell (simplification, cleanup)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */

 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/ioctl.h>
 #include <linux/fs.h>
 #include <linux/device.h>
 #include <linux/list.h>
 #include <linux/errno.h>
 #include <linux/mutex.h>
 #include <linux/slab.h>

 #include <linux/spi/spi.h>
 #include <linux/spi/spidev.h>

 #include <asm/uaccess.h>


 /*
  * This supports acccess to SPI devices using normal userspace I/O calls.
  * Note that while traditional UNIX/POSIX I/O semantics are half duplex,
  * and often mask message boundaries, full SPI support requires full duplex
  * transfers.  There are several kinds of of internal message boundaries to
  * handle chipselect management and other protocol options.
  *
  * SPI has a character major number assigned.  We allocate minor numbers
  * dynamically using a bitmask.  You must use hotplug tools, such as udev
  * (or mdev with busybox) to create and destroy the /dev/spidevB.C device
  * nodes, since there is no fixed association of minor numbers with any
  * particular SPI bus or device.
  */
 #define SPIDEV_MAJOR			153	/* assigned */
 #define N_SPI_MINORS			32	/* ... up to 256 */

 static unsigned long	minors[N_SPI_MINORS / BITS_PER_LONG];


 /* Bit masks for spi_device.mode management.  Note that incorrect
  * settings for CS_HIGH and 3WIRE can cause *lots* of trouble for other
  * devices on a shared bus:  CS_HIGH, because this device will be
  * active when it shouldn't be;  3WIRE, because when active it won't
  * behave as it should.
  *
  * REVISIT should changing those two modes be privileged?
  */
 #define SPI_MODE_MASK		(SPI_CPHA | SPI_CPOL | SPI_CS_HIGH \
 				| SPI_LSB_FIRST | SPI_3WIRE | SPI_LOOP)

 struct spidev_data {
 	struct device		dev;
 	struct spi_device	*spi;
 	struct list_head	device_entry;

 	struct mutex		buf_lock;
 	unsigned		users;
 	u8			*buffer;
 };

 static LIST_HEAD(device_list);
 static DEFINE_MUTEX(device_list_lock);

 static unsigned bufsiz = 4096;
 module_param(bufsiz, uint, S_IRUGO);
 MODULE_PARM_DESC(bufsiz, "data bytes in biggest supported SPI message");

 /*-------------------------------------------------------------------------*/

 /* Read-only message with current device setup */
 static ssize_t
 spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
 {
 	struct spidev_data	*spidev;
 	struct spi_device	*spi;
 	ssize_t			status = 0;

 	/* chipselect only toggles at start or end of operation */
 	if (count > bufsiz)
 		return -EMSGSIZE;

 	spidev = filp->private_data;
 	spi = spidev->spi;

 	mutex_lock(&spidev->buf_lock);
 	status = spi_read(spi, spidev->buffer, count);
 	if (status == 0) {
 		unsigned long	missing;

 		missing = copy_to_user(buf, spidev->buffer, count);
 		if (count && missing == count)
 			status = -EFAULT;
 		else
 			status = count - missing;
 	}
 	mutex_unlock(&spidev->buf_lock);

 	return status;
 }

 /* Write-only message with current device setup */
 static ssize_t
 spidev_write(struct file *filp, const char __user *buf,
 		size_t count, loff_t *f_pos)
 {
 	struct spidev_data	*spidev;
 	struct spi_device	*spi;
 	ssize_t			status = 0;
 	unsigned long		missing;

 	/* chipselect only toggles at start or end of operation */
 	if (count > bufsiz)
 		return -EMSGSIZE;

 	spidev = filp->private_data;
 	spi = spidev->spi;

 	mutex_lock(&spidev->buf_lock);
 	missing = copy_from_user(spidev->buffer, buf, count);
 	if (missing == 0) {
 		status = spi_write(spi, spidev->buffer, count);
 		if (status == 0)
 			status = count;
 	} else
 		status = -EFAULT;
 	mutex_unlock(&spidev->buf_lock);

 	return status;
 }

 static int spidev_message(struct spidev_data *spidev,
 		struct spi_ioc_transfer *u_xfers, unsigned n_xfers)
 {
 	struct spi_message	msg;
 	struct spi_transfer	*k_xfers;
 	struct spi_transfer	*k_tmp;
 	struct spi_ioc_transfer *u_tmp;
 	struct spi_device	*spi = spidev->spi;
 	unsigned		n, total;
 	u8			*buf;
 	int			status = -EFAULT;

 	spi_message_init(&msg);
 	k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL);
 	if (k_xfers == NULL)
 		return -ENOMEM;

 	/* Construct spi_message, copying any tx data to bounce buffer.
 	 * We walk the array of user-provided transfers, using each one
 	 * to initialize a kernel version of the same transfer.
 	 */
 	mutex_lock(&spidev->buf_lock);
 	buf = spidev->buffer;
 	total = 0;
 	for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;
 			n;
 			n--, k_tmp++, u_tmp++) {
 		k_tmp->len = u_tmp->len;

 		total += k_tmp->len;
 		if (total > bufsiz) {
 			status = -EMSGSIZE;
 			goto done;
 		}

 		if (u_tmp->rx_buf) {
 			k_tmp->rx_buf = buf;
 			if (!access_ok(VERIFY_WRITE, (u8 __user *)
 						(uintptr_t) u_tmp->rx_buf,
 						u_tmp->len))
 				goto done;
 		}
 		if (u_tmp->tx_buf) {
 			k_tmp->tx_buf = buf;
 			if (copy_from_user(buf, (const u8 __user *)
 						(uintptr_t) u_tmp->tx_buf,
 					u_tmp->len))
 				goto done;
 		}
 		buf += k_tmp->len;

 		k_tmp->cs_change = !!u_tmp->cs_change;
 		k_tmp->bits_per_word = u_tmp->bits_per_word;
 		k_tmp->delay_usecs = u_tmp->delay_usecs;
 		k_tmp->speed_hz = u_tmp->speed_hz;
 #ifdef VERBOSE
 		dev_dbg(&spi->dev,
 			"  xfer len %zd %s%s%s%dbits %u usec %uHz\n",
 			u_tmp->len,
 			u_tmp->rx_buf ? "rx " : "",
 			u_tmp->tx_buf ? "tx " : "",
 			u_tmp->cs_change ? "cs " : "",
 			u_tmp->bits_per_word ? : spi->bits_per_word,
 			u_tmp->delay_usecs,
 			u_tmp->speed_hz ? : spi->max_speed_hz);
 #endif
 		spi_message_add_tail(k_tmp, &msg);
 	}

 	status = spi_sync(spi, &msg);
 	if (status < 0)
 		goto done;

 	/* copy any rx data out of bounce buffer */
 	buf = spidev->buffer;
 	for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) {
 		if (u_tmp->rx_buf) {
 			if (__copy_to_user((u8 __user *)
 					(uintptr_t) u_tmp->rx_buf, buf,
 					u_tmp->len)) {
 				status = -EFAULT;
 				goto done;
 			}
 		}
 		buf += u_tmp->len;
 	}
 	status = total;

 done:
 	mutex_unlock(&spidev->buf_lock);
 	kfree(k_xfers);
 	return status;
 }

 static int
 spidev_ioctl(struct inode *inode, struct file *filp,
 		unsigned int cmd, unsigned long arg)
 {
 	int			err = 0;
 	int			retval = 0;
 	struct spidev_data	*spidev;
 	struct spi_device	*spi;
 	u32			tmp;
 	unsigned		n_ioc;
 	struct spi_ioc_transfer	*ioc;

 	/* Check type and command number */
 	if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)
 		return -ENOTTY;

 	/* Check access direction once here; don't repeat below.
 	 * IOC_DIR is from the user perspective, while access_ok is
 	 * from the kernel perspective; so they look reversed.
 	 */
 	if (_IOC_DIR(cmd) & _IOC_READ)
 		err = !access_ok(VERIFY_WRITE,
 				(void __user *)arg, _IOC_SIZE(cmd));
 	if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE)
 		err = !access_ok(VERIFY_READ,
 				(void __user *)arg, _IOC_SIZE(cmd));
 	if (err)
 		return -EFAULT;

 	spidev = filp->private_data;
 	spi = spidev->spi;

 	switch (cmd) {
 	/* read requests */
 	case SPI_IOC_RD_MODE:
 		retval = __put_user(spi->mode & SPI_MODE_MASK,
 					(__u8 __user *)arg);
 		break;
 	case SPI_IOC_RD_LSB_FIRST:
 		retval = __put_user((spi->mode & SPI_LSB_FIRST) ?  1 : 0,
 					(__u8 __user *)arg);
 		break;
 	case SPI_IOC_RD_BITS_PER_WORD:
 		retval = __put_user(spi->bits_per_word, (__u8 __user *)arg);
 		break;
 	case SPI_IOC_RD_MAX_SPEED_HZ:
 		retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg);
 		break;

 	/* write requests */
 	case SPI_IOC_WR_MODE:
 		retval = __get_user(tmp, (u8 __user *)arg);
 		if (retval == 0) {
 			u8	save = spi->mode;

 			if (tmp & ~SPI_MODE_MASK) {
 				retval = -EINVAL;
 				break;
 			}

 			tmp |= spi->mode & ~SPI_MODE_MASK;
 			spi->mode = (u8)tmp;
 			retval = spi_setup(spi);
 			if (retval < 0)
 				spi->mode = save;
 			else
 				dev_dbg(&spi->dev, "spi mode %02x\n", tmp);
 		}
 		break;
 	case SPI_IOC_WR_LSB_FIRST:
 		retval = __get_user(tmp, (__u8 __user *)arg);
 		if (retval == 0) {
 			u8	save = spi->mode;

 			if (tmp)
 				spi->mode |= SPI_LSB_FIRST;
 			else
 				spi->mode &= ~SPI_LSB_FIRST;
 			retval = spi_setup(spi);
 			if (retval < 0)
 				spi->mode = save;
 			else
 				dev_dbg(&spi->dev, "%csb first\n",
 						tmp ? 'l' : 'm');
 		}
 		break;
 	case SPI_IOC_WR_BITS_PER_WORD:
 		retval = __get_user(tmp, (__u8 __user *)arg);
 		if (retval == 0) {
 			u8	save = spi->bits_per_word;

 			spi->bits_per_word = tmp;
 			retval = spi_setup(spi);
 			if (retval < 0)
 				spi->bits_per_word = save;
 			else
 				dev_dbg(&spi->dev, "%d bits per word\n", tmp);
 		}
 		break;
 	case SPI_IOC_WR_MAX_SPEED_HZ:
 		retval = __get_user(tmp, (__u32 __user *)arg);
 		if (retval == 0) {
 			u32	save = spi->max_speed_hz;

 			spi->max_speed_hz = tmp;
 			retval = spi_setup(spi);
 			if (retval < 0)
 				spi->max_speed_hz = save;
 			else
 				dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);
 		}
 		break;

 	default:
 		/* segmented and/or full-duplex I/O request */
 		if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))
 				|| _IOC_DIR(cmd) != _IOC_WRITE)
 			return -ENOTTY;

 		tmp = _IOC_SIZE(cmd);
 		if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) {
 			retval = -EINVAL;
 			break;
 		}
 		n_ioc = tmp / sizeof(struct spi_ioc_transfer);
 		if (n_ioc == 0)
 			break;

 		/* copy into scratch area */
 		ioc = kmalloc(tmp, GFP_KERNEL);
 		if (!ioc) {
 			retval = -ENOMEM;
 			break;
 		}
 		if (__copy_from_user(ioc, (void __user *)arg, tmp)) {
 			kfree(ioc);
 			retval = -EFAULT;
 			break;
 		}

 		/* translate to spi_message, execute */
 		retval = spidev_message(spidev, ioc, n_ioc);
 		kfree(ioc);
 		break;
 	}
 	return retval;
 }

 static int spidev_open(struct inode *inode, struct file *filp)
 {
 	struct spidev_data	*spidev;
 	int			status = -ENXIO;

 	mutex_lock(&device_list_lock);

 	list_for_each_entry(spidev, &device_list, device_entry) {
 		if (spidev->dev.devt == inode->i_rdev) {
 			status = 0;
 			break;
 		}
 	}
 	if (status == 0) {
 		if (!spidev->buffer) {
 			spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);
 			if (!spidev->buffer) {
 				dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
 				status = -ENOMEM;
 			}
 		}
 		if (status == 0) {
 			spidev->users++;
 			filp->private_data = spidev;
 			nonseekable_open(inode, filp);
 		}
 	} else
 		pr_debug("spidev: nothing for minor %d\n", iminor(inode));

 	mutex_unlock(&device_list_lock);
 	return status;
 }

 static int spidev_release(struct inode *inode, struct file *filp)
 {
 	struct spidev_data	*spidev;
 	int			status = 0;

 	mutex_lock(&device_list_lock);
 	spidev = filp->private_data;
 	filp->private_data = NULL;
 	spidev->users--;
 	if (!spidev->users) {
 		kfree(spidev->buffer);
 		spidev->buffer = NULL;
 	}
 	mutex_unlock(&device_list_lock);

 	return status;
 }

 static struct file_operations spidev_fops = {
 	.owner =	THIS_MODULE,
 	/* REVISIT switch to aio primitives, so that userspace
 	 * gets more complete API coverage.  It'll simplify things
 	 * too, except for the locking.
 	 */
 	.write =	spidev_write,
 	.read =		spidev_read,
 	.ioctl =	spidev_ioctl,
 	.open =		spidev_open,
 	.release =	spidev_release,
 };

 /*-------------------------------------------------------------------------*/

 /* The main reason to have this class is to make mdev/udev create the
  * /dev/spidevB.C character device nodes exposing our userspace API.
  * It also simplifies memory management.
  */

 static void spidev_classdev_release(struct device *dev)
 {
 	struct spidev_data	*spidev;

 	spidev = container_of(dev, struct spidev_data, dev);
 	kfree(spidev);
 }

 static struct class spidev_class = {
 	.name		= "spidev",
 	.owner		= THIS_MODULE,
 	.dev_release	= spidev_classdev_release,
 };

 /*-------------------------------------------------------------------------*/

 static int spidev_probe(struct spi_device *spi)
 {
 	struct spidev_data	*spidev;
 	int			status;
 	unsigned long		minor;

 	/* Allocate driver data */
 	spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
 	if (!spidev)
 		return -ENOMEM;

 	/* Initialize the driver data */
 	spidev->spi = spi;
 	mutex_init(&spidev->buf_lock);

 	INIT_LIST_HEAD(&spidev->device_entry);

 	/* If we can allocate a minor number, hook up this device.
 	 * Reusing minors is fine so long as udev or mdev is working.
 	 */
 	mutex_lock(&device_list_lock);
 	minor = find_first_zero_bit(minors, N_SPI_MINORS);
 	if (minor < N_SPI_MINORS) {
 		spidev->dev.parent = &spi->dev;
 		spidev->dev.class = &spidev_class;
 		spidev->dev.devt = MKDEV(SPIDEV_MAJOR, minor);
 		snprintf(spidev->dev.bus_id, sizeof spidev->dev.bus_id,
 				"spidev%d.%d",
 				spi->master->bus_num, spi->chip_select);
 		status = device_register(&spidev->dev);
 	} else {
 		dev_dbg(&spi->dev, "no minor number available!\n");
 		status = -ENODEV;
 	}
 	if (status == 0) {
 		set_bit(minor, minors);
 		dev_set_drvdata(&spi->dev, spidev);
 		list_add(&spidev->device_entry, &device_list);
 	}
 	mutex_unlock(&device_list_lock);

 	if (status != 0)
 		kfree(spidev);

 	return status;
 }

 static int spidev_remove(struct spi_device *spi)
 {
 	struct spidev_data	*spidev = dev_get_drvdata(&spi->dev);

 	mutex_lock(&device_list_lock);

 	list_del(&spidev->device_entry);
 	dev_set_drvdata(&spi->dev, NULL);
 	clear_bit(MINOR(spidev->dev.devt), minors);
 	device_unregister(&spidev->dev);

 	mutex_unlock(&device_list_lock);

 	return 0;
 }

 static struct spi_driver spidev_spi = {
 	.driver = {
 		.name =		"spidev",
 		.owner =	THIS_MODULE,
 	},
 	.probe =	spidev_probe,
 	.remove =	__devexit_p(spidev_remove),

 	/* NOTE:  suspend/resume methods are not necessary here.
 	 * We don't do anything except pass the requests to/from
 	 * the underlying controller.  The refrigerator handles
 	 * most issues; the controller driver handles the rest.
 	 */
 };

 /*-------------------------------------------------------------------------*/

 static int __init spidev_init(void)
 {
 	int status;

 	/* Claim our 256 reserved device numbers.  Then register a class
 	 * that will key udev/mdev to add/remove /dev nodes.  Last, register
 	 * the driver which manages those device numbers.
 	 */
 	BUILD_BUG_ON(N_SPI_MINORS > 256);
 	status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
 	if (status < 0)
 		return status;

 	status = class_register(&spidev_class);
 	if (status < 0) {
 		unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
 		return status;
 	}

 	status = spi_register_driver(&spidev_spi);
 	if (status < 0) {
 		class_unregister(&spidev_class);
 		unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
 	}
 	return status;
 }
 module_init(spidev_init);

 static void __exit spidev_exit(void)
 {
 	spi_unregister_driver(&spidev_spi);
 	class_unregister(&spidev_class);
 	unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
 }
 module_exit(spidev_exit);

 MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
 MODULE_DESCRIPTION("User mode SPI device interface");
 MODULE_LICENSE("GPL");
	/*
	* spidev.c -- simple synchronous userspace interface to SPI devices
	*
	* Copyright (C) 2006 SWAPP
	* Andrea Paterniani <a.paterniani@swapp-eng.it>
	* Copyright (C) 2007 David Brownell (simplification, cleanup)
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	*/

	#include <linux/init.h>
	#include <linux/module.h>
	#include <linux/ioctl.h>
	#include <linux/fs.h>
	#include <linux/device.h>
	#include <linux/list.h>
	#include <linux/errno.h>
	#include <linux/mutex.h>
	#include <linux/slab.h>

	#include <linux/spi/spi.h>
	#include <linux/spi/spidev.h>

	#include <asm/uaccess.h>


	/*
	* This supports acccess to SPI devices using normal userspace I/O calls.
	* Note that while traditional UNIX/POSIX I/O semantics are half duplex,
	* and often mask message boundaries, full SPI support requires full duplex
	* transfers. There are several kinds of of internal message boundaries to
	* handle chipselect management and other protocol options.
	*
	* SPI has a character major number assigned. We allocate minor numbers
	* dynamically using a bitmask. You must use hotplug tools, such as udev
	* (or mdev with busybox) to create and destroy the /dev/spidevB.C device
	* nodes, since there is no fixed association of minor numbers with any
	* particular SPI bus or device.
	*/
	#define SPIDEV_MAJOR 153 /* assigned */
	#define N_SPI_MINORS 32 /* ... up to 256 */

	static unsigned long minors[N_SPI_MINORS / BITS_PER_LONG];


	/* Bit masks for spi_device.mode management. Note that incorrect
	* settings for CS_HIGH and 3WIRE can cause lots of trouble for other
	* devices on a shared bus: CS_HIGH, because this device will be
	* active when it shouldn't be; 3WIRE, because when active it won't
	* behave as it should.
	*
	* REVISIT should changing those two modes be privileged?
	*/
	#define SPI_MODE_MASK (SPI_CPHA \| SPI_CPOL \| SPI_CS_HIGH \
	\| SPI_LSB_FIRST \| SPI_3WIRE \| SPI_LOOP)

	struct spidev_data {
	struct device dev;
	struct spi_device *spi;
	struct list_head device_entry;

	struct mutex buf_lock;
	unsigned users;
	u8 *buffer;
	};

	static LIST_HEAD(device_list);
	static DEFINE_MUTEX(device_list_lock);

	static unsigned bufsiz = 4096;
	module_param(bufsiz, uint, S_IRUGO);
	MODULE_PARM_DESC(bufsiz, "data bytes in biggest supported SPI message");

	/-------------------------------------------------------------------------/

	/* Read-only message with current device setup */
	static ssize_t
	spidev_read(struct file filp, char __user buf, size_t count, loff_t *f_pos)
	{
	struct spidev_data *spidev;
	struct spi_device *spi;
	ssize_t status = 0;

	/* chipselect only toggles at start or end of operation */
	if (count > bufsiz)
	return -EMSGSIZE;

	spidev = filp->private_data;
	spi = spidev->spi;

	mutex_lock(&spidev->buf_lock);
	status = spi_read(spi, spidev->buffer, count);
	if (status == 0) {
	unsigned long missing;

	missing = copy_to_user(buf, spidev->buffer, count);
	if (count && missing == count)
	status = -EFAULT;
	else
	status = count - missing;
	}
	mutex_unlock(&spidev->buf_lock);

	return status;
	}

	/* Write-only message with current device setup */
	static ssize_t
	spidev_write(struct file filp, const char __user buf,
	size_t count, loff_t *f_pos)
	{
	struct spidev_data *spidev;
	struct spi_device *spi;
	ssize_t status = 0;
	unsigned long missing;

	/* chipselect only toggles at start or end of operation */
	if (count > bufsiz)
	return -EMSGSIZE;

	spidev = filp->private_data;
	spi = spidev->spi;

	mutex_lock(&spidev->buf_lock);
	missing = copy_from_user(spidev->buffer, buf, count);
	if (missing == 0) {
	status = spi_write(spi, spidev->buffer, count);
	if (status == 0)
	status = count;
	} else
	status = -EFAULT;
	mutex_unlock(&spidev->buf_lock);

	return status;
	}

	static int spidev_message(struct spidev_data *spidev,
	struct spi_ioc_transfer *u_xfers, unsigned n_xfers)
	{
	struct spi_message msg;
	struct spi_transfer *k_xfers;
	struct spi_transfer *k_tmp;
	struct spi_ioc_transfer *u_tmp;
	struct spi_device *spi = spidev->spi;
	unsigned n, total;
	u8 *buf;
	int status = -EFAULT;

	spi_message_init(&msg);
	k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL);
	if (k_xfers == NULL)
	return -ENOMEM;

	/* Construct spi_message, copying any tx data to bounce buffer.
	* We walk the array of user-provided transfers, using each one
	* to initialize a kernel version of the same transfer.
	*/
	mutex_lock(&spidev->buf_lock);
	buf = spidev->buffer;
	total = 0;
	for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;
	n;
	n--, k_tmp++, u_tmp++) {
	k_tmp->len = u_tmp->len;

	total += k_tmp->len;
	if (total > bufsiz) {
	status = -EMSGSIZE;
	goto done;
	}

	if (u_tmp->rx_buf) {
	k_tmp->rx_buf = buf;
	if (!access_ok(VERIFY_WRITE, (u8 __user *)
	(uintptr_t) u_tmp->rx_buf,
	u_tmp->len))
	goto done;
	}
	if (u_tmp->tx_buf) {
	k_tmp->tx_buf = buf;
	if (copy_from_user(buf, (const u8 __user *)
	(uintptr_t) u_tmp->tx_buf,
	u_tmp->len))
	goto done;
	}
	buf += k_tmp->len;

	k_tmp->cs_change = !!u_tmp->cs_change;
	k_tmp->bits_per_word = u_tmp->bits_per_word;
	k_tmp->delay_usecs = u_tmp->delay_usecs;
	k_tmp->speed_hz = u_tmp->speed_hz;
	#ifdef VERBOSE
	dev_dbg(&spi->dev,
	" xfer len %zd %s%s%s%dbits %u usec %uHz\n",
	u_tmp->len,
	u_tmp->rx_buf ? "rx " : "",
	u_tmp->tx_buf ? "tx " : "",
	u_tmp->cs_change ? "cs " : "",
	u_tmp->bits_per_word ? : spi->bits_per_word,
	u_tmp->delay_usecs,
	u_tmp->speed_hz ? : spi->max_speed_hz);
	#endif
	spi_message_add_tail(k_tmp, &msg);
	}

	status = spi_sync(spi, &msg);
	if (status < 0)
	goto done;

	/* copy any rx data out of bounce buffer */
	buf = spidev->buffer;
	for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) {
	if (u_tmp->rx_buf) {
	if (__copy_to_user((u8 __user *)
	(uintptr_t) u_tmp->rx_buf, buf,
	u_tmp->len)) {
	status = -EFAULT;
	goto done;
	}
	}
	buf += u_tmp->len;
	}
	status = total;

	done:
	mutex_unlock(&spidev->buf_lock);
	kfree(k_xfers);
	return status;
	}

	static int
	spidev_ioctl(struct inode inode, struct file filp,
	unsigned int cmd, unsigned long arg)
	{
	int err = 0;
	int retval = 0;
	struct spidev_data *spidev;
	struct spi_device *spi;
	u32 tmp;
	unsigned n_ioc;
	struct spi_ioc_transfer *ioc;

	/* Check type and command number */
	if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)
	return -ENOTTY;

	/* Check access direction once here; don't repeat below.
	* IOC_DIR is from the user perspective, while access_ok is
	* from the kernel perspective; so they look reversed.
	*/
	if (_IOC_DIR(cmd) & _IOC_READ)
	err = !access_ok(VERIFY_WRITE,
	(void __user *)arg, _IOC_SIZE(cmd));
	if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE)
	err = !access_ok(VERIFY_READ,
	(void __user *)arg, _IOC_SIZE(cmd));
	if (err)
	return -EFAULT;

	spidev = filp->private_data;
	spi = spidev->spi;

	switch (cmd) {
	/* read requests */
	case SPI_IOC_RD_MODE:
	retval = __put_user(spi->mode & SPI_MODE_MASK,
	(__u8 __user *)arg);
	break;
	case SPI_IOC_RD_LSB_FIRST:
	retval = __put_user((spi->mode & SPI_LSB_FIRST) ? 1 : 0,
	(__u8 __user *)arg);
	break;
	case SPI_IOC_RD_BITS_PER_WORD:
	retval = __put_user(spi->bits_per_word, (__u8 __user *)arg);
	break;
	case SPI_IOC_RD_MAX_SPEED_HZ:
	retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg);
	break;

	/* write requests */
	case SPI_IOC_WR_MODE:
	retval = __get_user(tmp, (u8 __user *)arg);
	if (retval == 0) {
	u8 save = spi->mode;

	if (tmp & ~SPI_MODE_MASK) {
	retval = -EINVAL;
	break;
	}

	tmp \|= spi->mode & ~SPI_MODE_MASK;
	spi->mode = (u8)tmp;
	retval = spi_setup(spi);
	if (retval < 0)
	spi->mode = save;
	else
	dev_dbg(&spi->dev, "spi mode %02x\n", tmp);
	}
	break;
	case SPI_IOC_WR_LSB_FIRST:
	retval = __get_user(tmp, (__u8 __user *)arg);
	if (retval == 0) {
	u8 save = spi->mode;

	if (tmp)
	spi->mode \|= SPI_LSB_FIRST;
	else
	spi->mode &= ~SPI_LSB_FIRST;
	retval = spi_setup(spi);
	if (retval < 0)
	spi->mode = save;
	else
	dev_dbg(&spi->dev, "%csb first\n",
	tmp ? 'l' : 'm');
	}
	break;
	case SPI_IOC_WR_BITS_PER_WORD:
	retval = __get_user(tmp, (__u8 __user *)arg);
	if (retval == 0) {
	u8 save = spi->bits_per_word;

	spi->bits_per_word = tmp;
	retval = spi_setup(spi);
	if (retval < 0)
	spi->bits_per_word = save;
	else
	dev_dbg(&spi->dev, "%d bits per word\n", tmp);
	}
	break;
	case SPI_IOC_WR_MAX_SPEED_HZ:
	retval = __get_user(tmp, (__u32 __user *)arg);
	if (retval == 0) {
	u32 save = spi->max_speed_hz;

	spi->max_speed_hz = tmp;
	retval = spi_setup(spi);
	if (retval < 0)
	spi->max_speed_hz = save;
	else
	dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);
	}
	break;

	default:
	/* segmented and/or full-duplex I/O request */
	if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))
	\|\| _IOC_DIR(cmd) != _IOC_WRITE)
	return -ENOTTY;

	tmp = _IOC_SIZE(cmd);
	if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) {
	retval = -EINVAL;
	break;
	}
	n_ioc = tmp / sizeof(struct spi_ioc_transfer);
	if (n_ioc == 0)
	break;

	/* copy into scratch area */
	ioc = kmalloc(tmp, GFP_KERNEL);
	if (!ioc) {
	retval = -ENOMEM;
	break;
	}
	if (__copy_from_user(ioc, (void __user *)arg, tmp)) {
	kfree(ioc);
	retval = -EFAULT;
	break;
	}

	/* translate to spi_message, execute */
	retval = spidev_message(spidev, ioc, n_ioc);
	kfree(ioc);
	break;
	}
	return retval;
	}

	static int spidev_open(struct inode inode, struct file filp)
	{
	struct spidev_data *spidev;
	int status = -ENXIO;

	mutex_lock(&device_list_lock);

	list_for_each_entry(spidev, &device_list, device_entry) {
	if (spidev->dev.devt == inode->i_rdev) {
	status = 0;
	break;
	}
	}
	if (status == 0) {
	if (!spidev->buffer) {
	spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);
	if (!spidev->buffer) {
	dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
	status = -ENOMEM;
	}
	}
	if (status == 0) {
	spidev->users++;
	filp->private_data = spidev;
	nonseekable_open(inode, filp);
	}
	} else
	pr_debug("spidev: nothing for minor %d\n", iminor(inode));

	mutex_unlock(&device_list_lock);
	return status;
	}

	static int spidev_release(struct inode inode, struct file filp)
	{
	struct spidev_data *spidev;
	int status = 0;

	mutex_lock(&device_list_lock);
	spidev = filp->private_data;
	filp->private_data = NULL;
	spidev->users--;
	if (!spidev->users) {
	kfree(spidev->buffer);
	spidev->buffer = NULL;
	}
	mutex_unlock(&device_list_lock);

	return status;
	}

	static struct file_operations spidev_fops = {
	.owner = THIS_MODULE,
	/* REVISIT switch to aio primitives, so that userspace
	* gets more complete API coverage. It'll simplify things
	* too, except for the locking.
	*/
	.write = spidev_write,
	.read = spidev_read,
	.ioctl = spidev_ioctl,
	.open = spidev_open,
	.release = spidev_release,
	};

	/-------------------------------------------------------------------------/

	/* The main reason to have this class is to make mdev/udev create the
	* /dev/spidevB.C character device nodes exposing our userspace API.
	* It also simplifies memory management.
	*/

	static void spidev_classdev_release(struct device *dev)
	{
	struct spidev_data *spidev;

	spidev = container_of(dev, struct spidev_data, dev);
	kfree(spidev);
	}

	static struct class spidev_class = {
	.name = "spidev",
	.owner = THIS_MODULE,
	.dev_release = spidev_classdev_release,
	};

	/-------------------------------------------------------------------------/

	static int spidev_probe(struct spi_device *spi)
	{
	struct spidev_data *spidev;
	int status;
	unsigned long minor;

	/* Allocate driver data */
	spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
	if (!spidev)
	return -ENOMEM;

	/* Initialize the driver data */
	spidev->spi = spi;
	mutex_init(&spidev->buf_lock);

	INIT_LIST_HEAD(&spidev->device_entry);

	/* If we can allocate a minor number, hook up this device.
	* Reusing minors is fine so long as udev or mdev is working.
	*/
	mutex_lock(&device_list_lock);
	minor = find_first_zero_bit(minors, N_SPI_MINORS);
	if (minor < N_SPI_MINORS) {
	spidev->dev.parent = &spi->dev;
	spidev->dev.class = &spidev_class;
	spidev->dev.devt = MKDEV(SPIDEV_MAJOR, minor);
	snprintf(spidev->dev.bus_id, sizeof spidev->dev.bus_id,
	"spidev%d.%d",
	spi->master->bus_num, spi->chip_select);
	status = device_register(&spidev->dev);
	} else {
	dev_dbg(&spi->dev, "no minor number available!\n");
	status = -ENODEV;
	}
	if (status == 0) {
	set_bit(minor, minors);
	dev_set_drvdata(&spi->dev, spidev);
	list_add(&spidev->device_entry, &device_list);
	}
	mutex_unlock(&device_list_lock);

	if (status != 0)
	kfree(spidev);

	return status;
	}

	static int spidev_remove(struct spi_device *spi)
	{
	struct spidev_data *spidev = dev_get_drvdata(&spi->dev);

	mutex_lock(&device_list_lock);

	list_del(&spidev->device_entry);
	dev_set_drvdata(&spi->dev, NULL);
	clear_bit(MINOR(spidev->dev.devt), minors);
	device_unregister(&spidev->dev);

	mutex_unlock(&device_list_lock);

	return 0;
	}

	static struct spi_driver spidev_spi = {
	.driver = {
	.name = "spidev",
	.owner = THIS_MODULE,
	},
	.probe = spidev_probe,
	.remove = __devexit_p(spidev_remove),

	/* NOTE: suspend/resume methods are not necessary here.
	* We don't do anything except pass the requests to/from
	* the underlying controller. The refrigerator handles
	* most issues; the controller driver handles the rest.
	*/
	};

	/-------------------------------------------------------------------------/

	static int __init spidev_init(void)
	{
	int status;

	/* Claim our 256 reserved device numbers. Then register a class
	* that will key udev/mdev to add/remove /dev nodes. Last, register
	* the driver which manages those device numbers.
	*/
	BUILD_BUG_ON(N_SPI_MINORS > 256);
	status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
	if (status < 0)
	return status;

	status = class_register(&spidev_class);
	if (status < 0) {
	unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
	return status;
	}

	status = spi_register_driver(&spidev_spi);
	if (status < 0) {
	class_unregister(&spidev_class);
	unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
	}
	return status;
	}
	module_init(spidev_init);

	static void __exit spidev_exit(void)
	{
	spi_unregister_driver(&spidev_spi);
	class_unregister(&spidev_class);
	unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
	}
	module_exit(spidev_exit);

	MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
	MODULE_DESCRIPTION("User mode SPI device interface");
	MODULE_LICENSE("GPL");