drivers/spi/spidev.c - kernel/common - Git at Google

 /*
  * Simple synchronous userspace interface to SPI devices
  *
  * Copyright (C) 2006 SWAPP
  *	Andrea Paterniani <[email protected]>
  * 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.
  */

 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/ioctl.h>
 #include <linux/fs.h>
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/list.h>
 #include <linux/errno.h>
 #include <linux/mutex.h>
 #include <linux/slab.h>
 #include <linux/compat.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/acpi.h>

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

 #include <linux/uaccess.h>


 /*
  * This supports access 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 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 DECLARE_BITMAP(minors, N_SPI_MINORS);


 /* Bit masks for spi_device.mode management.  Note that incorrect
  * settings for some settings can cause *lots* of trouble for other
  * devices on a shared bus:
  *
  *  - CS_HIGH ... this device will be active when it shouldn't be
  *  - 3WIRE ... when active, it won't behave as it should
  *  - NO_CS ... there will be no explicit message boundaries; this
  *	is completely incompatible with the shared bus model
  *  - READY ... transfers may proceed when they shouldn't.
  *
  * REVISIT should changing those flags be privileged?
  */
 #define SPI_MODE_MASK		(SPI_CPHA | SPI_CPOL | SPI_CS_HIGH \
 				| SPI_LSB_FIRST | SPI_3WIRE | SPI_LOOP \
 				| SPI_NO_CS | SPI_READY | SPI_TX_DUAL \
 				| SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD)

 struct spidev_data {
 	dev_t			devt;
 	spinlock_t		spi_lock;
 	struct spi_device	*spi;
 	struct list_head	device_entry;

 	/* TX/RX buffers are NULL unless this device is open (users > 0) */
 	struct mutex		buf_lock;
 	unsigned		users;
 	u8			*tx_buffer;
 	u8			*rx_buffer;
 	u32			speed_hz;
 };

 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");

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

 static ssize_t
 spidev_sync(struct spidev_data *spidev, struct spi_message *message)
 {
 	int status;
 	struct spi_device *spi;

 	spin_lock_irq(&spidev->spi_lock);
 	spi = spidev->spi;
 	spin_unlock_irq(&spidev->spi_lock);

 	if (spi == NULL)
 		status = -ESHUTDOWN;
 	else
 		status = spi_sync(spi, message);

 	if (status == 0)
 		status = message->actual_length;

 	return status;
 }

 static inline ssize_t
 spidev_sync_write(struct spidev_data *spidev, size_t len)
 {
 	struct spi_transfer	t = {
 			.tx_buf		= spidev->tx_buffer,
 			.len		= len,
 			.speed_hz	= spidev->speed_hz,
 		};
 	struct spi_message	m;

 	spi_message_init(&m);
 	spi_message_add_tail(&t, &m);
 	return spidev_sync(spidev, &m);
 }

 static inline ssize_t
 spidev_sync_read(struct spidev_data *spidev, size_t len)
 {
 	struct spi_transfer	t = {
 			.rx_buf		= spidev->rx_buffer,
 			.len		= len,
 			.speed_hz	= spidev->speed_hz,
 		};
 	struct spi_message	m;

 	spi_message_init(&m);
 	spi_message_add_tail(&t, &m);
 	return spidev_sync(spidev, &m);
 }

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

 /* 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;
 	ssize_t			status = 0;

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

 	spidev = filp->private_data;

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

 		missing = copy_to_user(buf, spidev->rx_buffer, status);
 		if (missing == status)
 			status = -EFAULT;
 		else
 			status = status - 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;
 	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;

 	mutex_lock(&spidev->buf_lock);
 	missing = copy_from_user(spidev->tx_buffer, buf, count);
 	if (missing == 0)
 		status = spidev_sync_write(spidev, 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;
 	unsigned		n, total, tx_total, rx_total;
 	u8			*tx_buf, *rx_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.
 	 */
 	tx_buf = spidev->tx_buffer;
 	rx_buf = spidev->rx_buffer;
 	total = 0;
 	tx_total = 0;
 	rx_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;
 		/* Since the function returns the total length of transfers
 		 * on success, restrict the total to positive int values to
 		 * avoid the return value looking like an error.  Also check
 		 * each transfer length to avoid arithmetic overflow.
 		 */
 		if (total > INT_MAX || k_tmp->len > INT_MAX) {
 			status = -EMSGSIZE;
 			goto done;
 		}

 		if (u_tmp->rx_buf) {
 			/* this transfer needs space in RX bounce buffer */
 			rx_total += k_tmp->len;
 			if (rx_total > bufsiz) {
 				status = -EMSGSIZE;
 				goto done;
 			}
 			k_tmp->rx_buf = rx_buf;
 			rx_buf += k_tmp->len;
 		}
 		if (u_tmp->tx_buf) {
 			/* this transfer needs space in TX bounce buffer */
 			tx_total += k_tmp->len;
 			if (tx_total > bufsiz) {
 				status = -EMSGSIZE;
 				goto done;
 			}
 			k_tmp->tx_buf = tx_buf;
 			if (copy_from_user(tx_buf, (const u8 __user *)
 						(uintptr_t) u_tmp->tx_buf,
 					u_tmp->len))
 				goto done;
 			tx_buf += k_tmp->len;
 		}

 		k_tmp->cs_change = !!u_tmp->cs_change;
 		k_tmp->tx_nbits = u_tmp->tx_nbits;
 		k_tmp->rx_nbits = u_tmp->rx_nbits;
 		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;
 		if (!k_tmp->speed_hz)
 			k_tmp->speed_hz = spidev->speed_hz;
 #ifdef VERBOSE
 		dev_dbg(&spidev->spi->dev,
 			"  xfer len %u %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 ? : spidev->spi->bits_per_word,
 			u_tmp->delay_usecs,
 			u_tmp->speed_hz ? : spidev->spi->max_speed_hz);
 #endif
 		spi_message_add_tail(k_tmp, &msg);
 	}

 	status = spidev_sync(spidev, &msg);
 	if (status < 0)
 		goto done;

 	/* copy any rx data out of bounce buffer */
 	rx_buf = spidev->rx_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, rx_buf,
 					u_tmp->len)) {
 				status = -EFAULT;
 				goto done;
 			}
 			rx_buf += u_tmp->len;
 		}
 	}
 	status = total;

 done:
 	kfree(k_xfers);
 	return status;
 }

 static struct spi_ioc_transfer *
 spidev_get_ioc_message(unsigned int cmd, struct spi_ioc_transfer __user *u_ioc,
 		unsigned *n_ioc)
 {
 	u32	tmp;

 	/* Check type, command number and direction */
 	if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC
 			|| _IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))
 			|| _IOC_DIR(cmd) != _IOC_WRITE)
 		return ERR_PTR(-ENOTTY);

 	tmp = _IOC_SIZE(cmd);
 	if ((tmp % sizeof(struct spi_ioc_transfer)) != 0)
 		return ERR_PTR(-EINVAL);
 	*n_ioc = tmp / sizeof(struct spi_ioc_transfer);
 	if (*n_ioc == 0)
 		return NULL;

 	/* copy into scratch area */
 	return memdup_user(u_ioc, tmp);
 }

 static long
 spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
 	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;

 	/* guard against device removal before, or while,
 	 * we issue this ioctl.
 	 */
 	spidev = filp->private_data;
 	spin_lock_irq(&spidev->spi_lock);
 	spi = spi_dev_get(spidev->spi);
 	spin_unlock_irq(&spidev->spi_lock);

 	if (spi == NULL)
 		return -ESHUTDOWN;

 	/* use the buffer lock here for triple duty:
 	 *  - prevent I/O (from us) so calling spi_setup() is safe;
 	 *  - prevent concurrent SPI_IOC_WR_* from morphing
 	 *    data fields while SPI_IOC_RD_* reads them;
 	 *  - SPI_IOC_MESSAGE needs the buffer locked "normally".
 	 */
 	mutex_lock(&spidev->buf_lock);

 	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_MODE32:
 		retval = put_user(spi->mode & SPI_MODE_MASK,
 					(__u32 __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(spidev->speed_hz, (__u32 __user *)arg);
 		break;

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

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

 			tmp |= spi->mode & ~SPI_MODE_MASK;
 			spi->mode = (u16)tmp;
 			retval = spi_setup(spi);
 			if (retval < 0)
 				spi->mode = save;
 			else
 				dev_dbg(&spi->dev, "spi mode %x\n", tmp);
 		}
 		break;
 	case SPI_IOC_WR_LSB_FIRST:
 		retval = get_user(tmp, (__u8 __user *)arg);
 		if (retval == 0) {
 			u32	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)
 				spidev->speed_hz = tmp;
 			else
 				dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);
 			spi->max_speed_hz = save;
 		}
 		break;

 	default:
 		/* segmented and/or full-duplex I/O request */
 		/* Check message and copy into scratch area */
 		ioc = spidev_get_ioc_message(cmd,
 				(struct spi_ioc_transfer __user *)arg, &n_ioc);
 		if (IS_ERR(ioc)) {
 			retval = PTR_ERR(ioc);
 			break;
 		}
 		if (!ioc)
 			break;	/* n_ioc is also 0 */

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

 	mutex_unlock(&spidev->buf_lock);
 	spi_dev_put(spi);
 	return retval;
 }

 #ifdef CONFIG_COMPAT
 static long
 spidev_compat_ioc_message(struct file *filp, unsigned int cmd,
 		unsigned long arg)
 {
 	struct spi_ioc_transfer __user	*u_ioc;
 	int				retval = 0;
 	struct spidev_data		*spidev;
 	struct spi_device		*spi;
 	unsigned			n_ioc, n;
 	struct spi_ioc_transfer		*ioc;

 	u_ioc = (struct spi_ioc_transfer __user *) compat_ptr(arg);

 	/* guard against device removal before, or while,
 	 * we issue this ioctl.
 	 */
 	spidev = filp->private_data;
 	spin_lock_irq(&spidev->spi_lock);
 	spi = spi_dev_get(spidev->spi);
 	spin_unlock_irq(&spidev->spi_lock);

 	if (spi == NULL)
 		return -ESHUTDOWN;

 	/* SPI_IOC_MESSAGE needs the buffer locked "normally" */
 	mutex_lock(&spidev->buf_lock);

 	/* Check message and copy into scratch area */
 	ioc = spidev_get_ioc_message(cmd, u_ioc, &n_ioc);
 	if (IS_ERR(ioc)) {
 		retval = PTR_ERR(ioc);
 		goto done;
 	}
 	if (!ioc)
 		goto done;	/* n_ioc is also 0 */

 	/* Convert buffer pointers */
 	for (n = 0; n < n_ioc; n++) {
 		ioc[n].rx_buf = (uintptr_t) compat_ptr(ioc[n].rx_buf);
 		ioc[n].tx_buf = (uintptr_t) compat_ptr(ioc[n].tx_buf);
 	}

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

 done:
 	mutex_unlock(&spidev->buf_lock);
 	spi_dev_put(spi);
 	return retval;
 }

 static long
 spidev_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
 	if (_IOC_TYPE(cmd) == SPI_IOC_MAGIC
 			&& _IOC_NR(cmd) == _IOC_NR(SPI_IOC_MESSAGE(0))
 			&& _IOC_DIR(cmd) == _IOC_WRITE)
 		return spidev_compat_ioc_message(filp, cmd, arg);

 	return spidev_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
 }
 #else
 #define spidev_compat_ioctl NULL
 #endif /* CONFIG_COMPAT */

 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->devt == inode->i_rdev) {
 			status = 0;
 			break;
 		}
 	}

 	if (status) {
 		pr_debug("spidev: nothing for minor %d\n", iminor(inode));
 		goto err_find_dev;
 	}

 	if (!spidev->tx_buffer) {
 		spidev->tx_buffer = kmalloc(bufsiz, GFP_KERNEL);
 		if (!spidev->tx_buffer) {
 			dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
 			status = -ENOMEM;
 			goto err_find_dev;
 		}
 	}

 	if (!spidev->rx_buffer) {
 		spidev->rx_buffer = kmalloc(bufsiz, GFP_KERNEL);
 		if (!spidev->rx_buffer) {
 			dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
 			status = -ENOMEM;
 			goto err_alloc_rx_buf;
 		}
 	}

 	spidev->users++;
 	filp->private_data = spidev;
 	nonseekable_open(inode, filp);

 	mutex_unlock(&device_list_lock);
 	return 0;

 err_alloc_rx_buf:
 	kfree(spidev->tx_buffer);
 	spidev->tx_buffer = NULL;
 err_find_dev:
 	mutex_unlock(&device_list_lock);
 	return status;
 }

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

 	mutex_lock(&device_list_lock);
 	spidev = filp->private_data;
 	filp->private_data = NULL;

 	/* last close? */
 	spidev->users--;
 	if (!spidev->users) {
 		int		dofree;

 		kfree(spidev->tx_buffer);
 		spidev->tx_buffer = NULL;

 		kfree(spidev->rx_buffer);
 		spidev->rx_buffer = NULL;

 		spin_lock_irq(&spidev->spi_lock);
 		if (spidev->spi)
 			spidev->speed_hz = spidev->spi->max_speed_hz;

 		/* ... after we unbound from the underlying device? */
 		dofree = (spidev->spi == NULL);
 		spin_unlock_irq(&spidev->spi_lock);

 		if (dofree)
 			kfree(spidev);
 	}
 	mutex_unlock(&device_list_lock);

 	return 0;
 }

 static const 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,
 	.unlocked_ioctl = spidev_ioctl,
 	.compat_ioctl = spidev_compat_ioctl,
 	.open =		spidev_open,
 	.release =	spidev_release,
 	.llseek =	no_llseek,
 };

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

 /* 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 struct class *spidev_class;

 #ifdef CONFIG_OF
 static const struct of_device_id spidev_dt_ids[] = {
 	{ .compatible = "rohm,dh2228fv" },
 	{ .compatible = "lineartechnology,ltc2488" },
 	{ .compatible = "ge,achc" },
 	{ .compatible = "semtech,sx1301" },
 	{},
 };
 MODULE_DEVICE_TABLE(of, spidev_dt_ids);
 #endif

 #ifdef CONFIG_ACPI

 /* Dummy SPI devices not to be used in production systems */
 #define SPIDEV_ACPI_DUMMY	1

 static const struct acpi_device_id spidev_acpi_ids[] = {
 	/*
 	 * The ACPI SPT000* devices are only meant for development and
 	 * testing. Systems used in production should have a proper ACPI
 	 * description of the connected peripheral and they should also use
 	 * a proper driver instead of poking directly to the SPI bus.
 	 */
 	{ "SPT0001", SPIDEV_ACPI_DUMMY },
 	{ "SPT0002", SPIDEV_ACPI_DUMMY },
 	{ "SPT0003", SPIDEV_ACPI_DUMMY },
 	{},
 };
 MODULE_DEVICE_TABLE(acpi, spidev_acpi_ids);

 static void spidev_probe_acpi(struct spi_device *spi)
 {
 	const struct acpi_device_id *id;

 	if (!has_acpi_companion(&spi->dev))
 		return;

 	id = acpi_match_device(spidev_acpi_ids, &spi->dev);
 	if (WARN_ON(!id))
 		return;

 	if (id->driver_data == SPIDEV_ACPI_DUMMY)
 		dev_warn(&spi->dev, "do not use this driver in production systems!\n");
 }
 #else
 static inline void spidev_probe_acpi(struct spi_device *spi) {}
 #endif

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

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

 	/*
 	 * spidev should never be referenced in DT without a specific
 	 * compatible string, it is a Linux implementation thing
 	 * rather than a description of the hardware.
 	 */
 	if (spi->dev.of_node && !of_match_device(spidev_dt_ids, &spi->dev)) {
 		dev_err(&spi->dev, "buggy DT: spidev listed directly in DT\n");
 		WARN_ON(spi->dev.of_node &&
 			!of_match_device(spidev_dt_ids, &spi->dev));
 	}

 	spidev_probe_acpi(spi);

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

 	/* Initialize the driver data */
 	spidev->spi = spi;
 	spin_lock_init(&spidev->spi_lock);
 	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) {
 		struct device *dev;

 		spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
 		dev = device_create(spidev_class, &spi->dev, spidev->devt,
 				    spidev, "spidev%d.%d",
 				    spi->master->bus_num, spi->chip_select);
 		status = PTR_ERR_OR_ZERO(dev);
 	} else {
 		dev_dbg(&spi->dev, "no minor number available!\n");
 		status = -ENODEV;
 	}
 	if (status == 0) {
 		set_bit(minor, minors);
 		list_add(&spidev->device_entry, &device_list);
 	}
 	mutex_unlock(&device_list_lock);

 	spidev->speed_hz = spi->max_speed_hz;

 	if (status == 0)
 		spi_set_drvdata(spi, spidev);
 	else
 		kfree(spidev);

 	return status;
 }

 static int spidev_remove(struct spi_device *spi)
 {
 	struct spidev_data	*spidev = spi_get_drvdata(spi);

 	/* make sure ops on existing fds can abort cleanly */
 	spin_lock_irq(&spidev->spi_lock);
 	spidev->spi = NULL;
 	spin_unlock_irq(&spidev->spi_lock);

 	/* prevent new opens */
 	mutex_lock(&device_list_lock);
 	list_del(&spidev->device_entry);
 	device_destroy(spidev_class, spidev->devt);
 	clear_bit(MINOR(spidev->devt), minors);
 	if (spidev->users == 0)
 		kfree(spidev);
 	mutex_unlock(&device_list_lock);

 	return 0;
 }

 static struct spi_driver spidev_spi_driver = {
 	.driver = {
 		.name =		"spidev",
 		.of_match_table = of_match_ptr(spidev_dt_ids),
 		.acpi_match_table = ACPI_PTR(spidev_acpi_ids),
 	},
 	.probe =	spidev_probe,
 	.remove =	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;

 	spidev_class = class_create(THIS_MODULE, "spidev");
 	if (IS_ERR(spidev_class)) {
 		unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
 		return PTR_ERR(spidev_class);
 	}

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

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

 MODULE_AUTHOR("Andrea Paterniani, <[email protected]>");
 MODULE_DESCRIPTION("User mode SPI device interface");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("spi:spidev");
	/*
	* Simple synchronous userspace interface to SPI devices
	*
	* Copyright (C) 2006 SWAPP
	* Andrea Paterniani <[email protected]>
	* 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.
	*/

	#include <linux/init.h>
	#include <linux/module.h>
	#include <linux/ioctl.h>
	#include <linux/fs.h>
	#include <linux/device.h>
	#include <linux/err.h>
	#include <linux/list.h>
	#include <linux/errno.h>
	#include <linux/mutex.h>
	#include <linux/slab.h>
	#include <linux/compat.h>
	#include <linux/of.h>
	#include <linux/of_device.h>
	#include <linux/acpi.h>

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

	#include <linux/uaccess.h>


	/*
	* This supports access 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 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 DECLARE_BITMAP(minors, N_SPI_MINORS);


	/* Bit masks for spi_device.mode management. Note that incorrect
	* settings for some settings can cause lots of trouble for other
	* devices on a shared bus:
	*
	* - CS_HIGH ... this device will be active when it shouldn't be
	* - 3WIRE ... when active, it won't behave as it should
	* - NO_CS ... there will be no explicit message boundaries; this
	* is completely incompatible with the shared bus model
	* - READY ... transfers may proceed when they shouldn't.
	*
	* REVISIT should changing those flags be privileged?
	*/
	#define SPI_MODE_MASK (SPI_CPHA \| SPI_CPOL \| SPI_CS_HIGH \
	\| SPI_LSB_FIRST \| SPI_3WIRE \| SPI_LOOP \
	\| SPI_NO_CS \| SPI_READY \| SPI_TX_DUAL \
	\| SPI_TX_QUAD \| SPI_RX_DUAL \| SPI_RX_QUAD)

	struct spidev_data {
	dev_t devt;
	spinlock_t spi_lock;
	struct spi_device *spi;
	struct list_head device_entry;

	/* TX/RX buffers are NULL unless this device is open (users > 0) */
	struct mutex buf_lock;
	unsigned users;
	u8 *tx_buffer;
	u8 *rx_buffer;
	u32 speed_hz;
	};

	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");

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

	static ssize_t
	spidev_sync(struct spidev_data spidev, struct spi_message message)
	{
	int status;
	struct spi_device *spi;

	spin_lock_irq(&spidev->spi_lock);
	spi = spidev->spi;
	spin_unlock_irq(&spidev->spi_lock);

	if (spi == NULL)
	status = -ESHUTDOWN;
	else
	status = spi_sync(spi, message);

	if (status == 0)
	status = message->actual_length;

	return status;
	}

	static inline ssize_t
	spidev_sync_write(struct spidev_data *spidev, size_t len)
	{
	struct spi_transfer t = {
	.tx_buf = spidev->tx_buffer,
	.len = len,
	.speed_hz = spidev->speed_hz,
	};
	struct spi_message m;

	spi_message_init(&m);
	spi_message_add_tail(&t, &m);
	return spidev_sync(spidev, &m);
	}

	static inline ssize_t
	spidev_sync_read(struct spidev_data *spidev, size_t len)
	{
	struct spi_transfer t = {
	.rx_buf = spidev->rx_buffer,
	.len = len,
	.speed_hz = spidev->speed_hz,
	};
	struct spi_message m;

	spi_message_init(&m);
	spi_message_add_tail(&t, &m);
	return spidev_sync(spidev, &m);
	}

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

	/* 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;
	ssize_t status = 0;

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

	spidev = filp->private_data;

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

	missing = copy_to_user(buf, spidev->rx_buffer, status);
	if (missing == status)
	status = -EFAULT;
	else
	status = status - 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;
	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;

	mutex_lock(&spidev->buf_lock);
	missing = copy_from_user(spidev->tx_buffer, buf, count);
	if (missing == 0)
	status = spidev_sync_write(spidev, 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;
	unsigned n, total, tx_total, rx_total;
	u8 tx_buf, rx_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.
	*/
	tx_buf = spidev->tx_buffer;
	rx_buf = spidev->rx_buffer;
	total = 0;
	tx_total = 0;
	rx_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;
	/* Since the function returns the total length of transfers
	* on success, restrict the total to positive int values to
	* avoid the return value looking like an error. Also check
	* each transfer length to avoid arithmetic overflow.
	*/
	if (total > INT_MAX \|\| k_tmp->len > INT_MAX) {
	status = -EMSGSIZE;
	goto done;
	}

	if (u_tmp->rx_buf) {
	/* this transfer needs space in RX bounce buffer */
	rx_total += k_tmp->len;
	if (rx_total > bufsiz) {
	status = -EMSGSIZE;
	goto done;
	}
	k_tmp->rx_buf = rx_buf;
	rx_buf += k_tmp->len;
	}
	if (u_tmp->tx_buf) {
	/* this transfer needs space in TX bounce buffer */
	tx_total += k_tmp->len;
	if (tx_total > bufsiz) {
	status = -EMSGSIZE;
	goto done;
	}
	k_tmp->tx_buf = tx_buf;
	if (copy_from_user(tx_buf, (const u8 __user *)
	(uintptr_t) u_tmp->tx_buf,
	u_tmp->len))
	goto done;
	tx_buf += k_tmp->len;
	}

	k_tmp->cs_change = !!u_tmp->cs_change;
	k_tmp->tx_nbits = u_tmp->tx_nbits;
	k_tmp->rx_nbits = u_tmp->rx_nbits;
	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;
	if (!k_tmp->speed_hz)
	k_tmp->speed_hz = spidev->speed_hz;
	#ifdef VERBOSE
	dev_dbg(&spidev->spi->dev,
	" xfer len %u %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 ? : spidev->spi->bits_per_word,
	u_tmp->delay_usecs,
	u_tmp->speed_hz ? : spidev->spi->max_speed_hz);
	#endif
	spi_message_add_tail(k_tmp, &msg);
	}

	status = spidev_sync(spidev, &msg);
	if (status < 0)
	goto done;

	/* copy any rx data out of bounce buffer */
	rx_buf = spidev->rx_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, rx_buf,
	u_tmp->len)) {
	status = -EFAULT;
	goto done;
	}
	rx_buf += u_tmp->len;
	}
	}
	status = total;

	done:
	kfree(k_xfers);
	return status;
	}

	static struct spi_ioc_transfer *
	spidev_get_ioc_message(unsigned int cmd, struct spi_ioc_transfer __user *u_ioc,
	unsigned *n_ioc)
	{
	u32 tmp;

	/* Check type, command number and direction */
	if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC
	\|\| _IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))
	\|\| _IOC_DIR(cmd) != _IOC_WRITE)
	return ERR_PTR(-ENOTTY);

	tmp = _IOC_SIZE(cmd);
	if ((tmp % sizeof(struct spi_ioc_transfer)) != 0)
	return ERR_PTR(-EINVAL);
	*n_ioc = tmp / sizeof(struct spi_ioc_transfer);
	if (*n_ioc == 0)
	return NULL;

	/* copy into scratch area */
	return memdup_user(u_ioc, tmp);
	}

	static long
	spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
	{
	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;

	/* guard against device removal before, or while,
	* we issue this ioctl.
	*/
	spidev = filp->private_data;
	spin_lock_irq(&spidev->spi_lock);
	spi = spi_dev_get(spidev->spi);
	spin_unlock_irq(&spidev->spi_lock);

	if (spi == NULL)
	return -ESHUTDOWN;

	/* use the buffer lock here for triple duty:
	* - prevent I/O (from us) so calling spi_setup() is safe;
	* - prevent concurrent SPI_IOC_WR_* from morphing
	* data fields while SPI_IOC_RD_* reads them;
	* - SPI_IOC_MESSAGE needs the buffer locked "normally".
	*/
	mutex_lock(&spidev->buf_lock);

	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_MODE32:
	retval = put_user(spi->mode & SPI_MODE_MASK,
	(__u32 __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(spidev->speed_hz, (__u32 __user *)arg);
	break;

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

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

	tmp \|= spi->mode & ~SPI_MODE_MASK;
	spi->mode = (u16)tmp;
	retval = spi_setup(spi);
	if (retval < 0)
	spi->mode = save;
	else
	dev_dbg(&spi->dev, "spi mode %x\n", tmp);
	}
	break;
	case SPI_IOC_WR_LSB_FIRST:
	retval = get_user(tmp, (__u8 __user *)arg);
	if (retval == 0) {
	u32 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)
	spidev->speed_hz = tmp;
	else
	dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);
	spi->max_speed_hz = save;
	}
	break;

	default:
	/* segmented and/or full-duplex I/O request */
	/* Check message and copy into scratch area */
	ioc = spidev_get_ioc_message(cmd,
	(struct spi_ioc_transfer __user *)arg, &n_ioc);
	if (IS_ERR(ioc)) {
	retval = PTR_ERR(ioc);
	break;
	}
	if (!ioc)
	break; /* n_ioc is also 0 */

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

	mutex_unlock(&spidev->buf_lock);
	spi_dev_put(spi);
	return retval;
	}

	#ifdef CONFIG_COMPAT
	static long
	spidev_compat_ioc_message(struct file *filp, unsigned int cmd,
	unsigned long arg)
	{
	struct spi_ioc_transfer __user *u_ioc;
	int retval = 0;
	struct spidev_data *spidev;
	struct spi_device *spi;
	unsigned n_ioc, n;
	struct spi_ioc_transfer *ioc;

	u_ioc = (struct spi_ioc_transfer __user *) compat_ptr(arg);

	/* guard against device removal before, or while,
	* we issue this ioctl.
	*/
	spidev = filp->private_data;
	spin_lock_irq(&spidev->spi_lock);
	spi = spi_dev_get(spidev->spi);
	spin_unlock_irq(&spidev->spi_lock);

	if (spi == NULL)
	return -ESHUTDOWN;

	/* SPI_IOC_MESSAGE needs the buffer locked "normally" */
	mutex_lock(&spidev->buf_lock);

	/* Check message and copy into scratch area */
	ioc = spidev_get_ioc_message(cmd, u_ioc, &n_ioc);
	if (IS_ERR(ioc)) {
	retval = PTR_ERR(ioc);
	goto done;
	}
	if (!ioc)
	goto done; /* n_ioc is also 0 */

	/* Convert buffer pointers */
	for (n = 0; n < n_ioc; n++) {
	ioc[n].rx_buf = (uintptr_t) compat_ptr(ioc[n].rx_buf);
	ioc[n].tx_buf = (uintptr_t) compat_ptr(ioc[n].tx_buf);
	}

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

	done:
	mutex_unlock(&spidev->buf_lock);
	spi_dev_put(spi);
	return retval;
	}

	static long
	spidev_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
	{
	if (_IOC_TYPE(cmd) == SPI_IOC_MAGIC
	&& _IOC_NR(cmd) == _IOC_NR(SPI_IOC_MESSAGE(0))
	&& _IOC_DIR(cmd) == _IOC_WRITE)
	return spidev_compat_ioc_message(filp, cmd, arg);

	return spidev_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
	}
	#else
	#define spidev_compat_ioctl NULL
	#endif /* CONFIG_COMPAT */

	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->devt == inode->i_rdev) {
	status = 0;
	break;
	}
	}

	if (status) {
	pr_debug("spidev: nothing for minor %d\n", iminor(inode));
	goto err_find_dev;
	}

	if (!spidev->tx_buffer) {
	spidev->tx_buffer = kmalloc(bufsiz, GFP_KERNEL);
	if (!spidev->tx_buffer) {
	dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
	status = -ENOMEM;
	goto err_find_dev;
	}
	}

	if (!spidev->rx_buffer) {
	spidev->rx_buffer = kmalloc(bufsiz, GFP_KERNEL);
	if (!spidev->rx_buffer) {
	dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
	status = -ENOMEM;
	goto err_alloc_rx_buf;
	}
	}

	spidev->users++;
	filp->private_data = spidev;
	nonseekable_open(inode, filp);

	mutex_unlock(&device_list_lock);
	return 0;

	err_alloc_rx_buf:
	kfree(spidev->tx_buffer);
	spidev->tx_buffer = NULL;
	err_find_dev:
	mutex_unlock(&device_list_lock);
	return status;
	}

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

	mutex_lock(&device_list_lock);
	spidev = filp->private_data;
	filp->private_data = NULL;

	/* last close? */
	spidev->users--;
	if (!spidev->users) {
	int dofree;

	kfree(spidev->tx_buffer);
	spidev->tx_buffer = NULL;

	kfree(spidev->rx_buffer);
	spidev->rx_buffer = NULL;

	spin_lock_irq(&spidev->spi_lock);
	if (spidev->spi)
	spidev->speed_hz = spidev->spi->max_speed_hz;

	/* ... after we unbound from the underlying device? */
	dofree = (spidev->spi == NULL);
	spin_unlock_irq(&spidev->spi_lock);

	if (dofree)
	kfree(spidev);
	}
	mutex_unlock(&device_list_lock);

	return 0;
	}

	static const 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,
	.unlocked_ioctl = spidev_ioctl,
	.compat_ioctl = spidev_compat_ioctl,
	.open = spidev_open,
	.release = spidev_release,
	.llseek = no_llseek,
	};

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

	/* 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 struct class *spidev_class;

	#ifdef CONFIG_OF
	static const struct of_device_id spidev_dt_ids[] = {
	{ .compatible = "rohm,dh2228fv" },
	{ .compatible = "lineartechnology,ltc2488" },
	{ .compatible = "ge,achc" },
	{ .compatible = "semtech,sx1301" },
	{},
	};
	MODULE_DEVICE_TABLE(of, spidev_dt_ids);
	#endif

	#ifdef CONFIG_ACPI

	/* Dummy SPI devices not to be used in production systems */
	#define SPIDEV_ACPI_DUMMY 1

	static const struct acpi_device_id spidev_acpi_ids[] = {
	/*
	* The ACPI SPT000* devices are only meant for development and
	* testing. Systems used in production should have a proper ACPI
	* description of the connected peripheral and they should also use
	* a proper driver instead of poking directly to the SPI bus.
	*/
	{ "SPT0001", SPIDEV_ACPI_DUMMY },
	{ "SPT0002", SPIDEV_ACPI_DUMMY },
	{ "SPT0003", SPIDEV_ACPI_DUMMY },
	{},
	};
	MODULE_DEVICE_TABLE(acpi, spidev_acpi_ids);

	static void spidev_probe_acpi(struct spi_device *spi)
	{
	const struct acpi_device_id *id;

	if (!has_acpi_companion(&spi->dev))
	return;

	id = acpi_match_device(spidev_acpi_ids, &spi->dev);
	if (WARN_ON(!id))
	return;

	if (id->driver_data == SPIDEV_ACPI_DUMMY)
	dev_warn(&spi->dev, "do not use this driver in production systems!\n");
	}
	#else
	static inline void spidev_probe_acpi(struct spi_device *spi) {}
	#endif

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

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

	/*
	* spidev should never be referenced in DT without a specific
	* compatible string, it is a Linux implementation thing
	* rather than a description of the hardware.
	*/
	if (spi->dev.of_node && !of_match_device(spidev_dt_ids, &spi->dev)) {
	dev_err(&spi->dev, "buggy DT: spidev listed directly in DT\n");
	WARN_ON(spi->dev.of_node &&
	!of_match_device(spidev_dt_ids, &spi->dev));
	}

	spidev_probe_acpi(spi);

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

	/* Initialize the driver data */
	spidev->spi = spi;
	spin_lock_init(&spidev->spi_lock);
	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) {
	struct device *dev;

	spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
	dev = device_create(spidev_class, &spi->dev, spidev->devt,
	spidev, "spidev%d.%d",
	spi->master->bus_num, spi->chip_select);
	status = PTR_ERR_OR_ZERO(dev);
	} else {
	dev_dbg(&spi->dev, "no minor number available!\n");
	status = -ENODEV;
	}
	if (status == 0) {
	set_bit(minor, minors);
	list_add(&spidev->device_entry, &device_list);
	}
	mutex_unlock(&device_list_lock);

	spidev->speed_hz = spi->max_speed_hz;

	if (status == 0)
	spi_set_drvdata(spi, spidev);
	else
	kfree(spidev);

	return status;
	}

	static int spidev_remove(struct spi_device *spi)
	{
	struct spidev_data *spidev = spi_get_drvdata(spi);

	/* make sure ops on existing fds can abort cleanly */
	spin_lock_irq(&spidev->spi_lock);
	spidev->spi = NULL;
	spin_unlock_irq(&spidev->spi_lock);

	/* prevent new opens */
	mutex_lock(&device_list_lock);
	list_del(&spidev->device_entry);
	device_destroy(spidev_class, spidev->devt);
	clear_bit(MINOR(spidev->devt), minors);
	if (spidev->users == 0)
	kfree(spidev);
	mutex_unlock(&device_list_lock);

	return 0;
	}

	static struct spi_driver spidev_spi_driver = {
	.driver = {
	.name = "spidev",
	.of_match_table = of_match_ptr(spidev_dt_ids),
	.acpi_match_table = ACPI_PTR(spidev_acpi_ids),
	},
	.probe = spidev_probe,
	.remove = 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;

	spidev_class = class_create(THIS_MODULE, "spidev");
	if (IS_ERR(spidev_class)) {
	unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
	return PTR_ERR(spidev_class);
	}

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

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

	MODULE_AUTHOR("Andrea Paterniani, <[email protected]>");
	MODULE_DESCRIPTION("User mode SPI device interface");
	MODULE_LICENSE("GPL");
	MODULE_ALIAS("spi:spidev");