2 * spidev.c -- simple synchronous userspace interface to SPI devices
4 * Copyright (C) 2006 SWAPP
5 * Andrea Paterniani <a.paterniani@swapp-eng.it>
6 * Copyright (C) 2007 David Brownell (simplification, cleanup)
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 #include <linux/init.h>
24 #include <linux/module.h>
25 #include <linux/ioctl.h>
27 #include <linux/device.h>
28 #include <linux/list.h>
29 #include <linux/errno.h>
30 #include <linux/mutex.h>
31 #include <linux/slab.h>
32 #include <linux/smp_lock.h>
34 #include <linux/spi/spi.h>
35 #include <linux/spi/spidev.h>
37 #include <asm/uaccess.h>
41 * This supports acccess to SPI devices using normal userspace I/O calls.
42 * Note that while traditional UNIX/POSIX I/O semantics are half duplex,
43 * and often mask message boundaries, full SPI support requires full duplex
44 * transfers. There are several kinds of of internal message boundaries to
45 * handle chipselect management and other protocol options.
47 * SPI has a character major number assigned. We allocate minor numbers
48 * dynamically using a bitmask. You must use hotplug tools, such as udev
49 * (or mdev with busybox) to create and destroy the /dev/spidevB.C device
50 * nodes, since there is no fixed association of minor numbers with any
51 * particular SPI bus or device.
53 #define SPIDEV_MAJOR 153 /* assigned */
54 #define N_SPI_MINORS 32 /* ... up to 256 */
56 static unsigned long minors[N_SPI_MINORS / BITS_PER_LONG];
59 /* Bit masks for spi_device.mode management. Note that incorrect
60 * settings for CS_HIGH and 3WIRE can cause *lots* of trouble for other
61 * devices on a shared bus: CS_HIGH, because this device will be
62 * active when it shouldn't be; 3WIRE, because when active it won't
63 * behave as it should.
65 * REVISIT should changing those two modes be privileged?
67 #define SPI_MODE_MASK (SPI_CPHA | SPI_CPOL | SPI_CS_HIGH \
68 | SPI_LSB_FIRST | SPI_3WIRE | SPI_LOOP)
72 struct spi_device *spi;
73 struct list_head device_entry;
75 struct mutex buf_lock;
80 static LIST_HEAD(device_list);
81 static DEFINE_MUTEX(device_list_lock);
83 static unsigned bufsiz = 4096;
84 module_param(bufsiz, uint, S_IRUGO);
85 MODULE_PARM_DESC(bufsiz, "data bytes in biggest supported SPI message");
87 /*-------------------------------------------------------------------------*/
89 /* Read-only message with current device setup */
91 spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
93 struct spidev_data *spidev;
94 struct spi_device *spi;
97 /* chipselect only toggles at start or end of operation */
101 spidev = filp->private_data;
104 mutex_lock(&spidev->buf_lock);
105 status = spi_read(spi, spidev->buffer, count);
107 unsigned long missing;
109 missing = copy_to_user(buf, spidev->buffer, count);
110 if (count && missing == count)
113 status = count - missing;
115 mutex_unlock(&spidev->buf_lock);
120 /* Write-only message with current device setup */
122 spidev_write(struct file *filp, const char __user *buf,
123 size_t count, loff_t *f_pos)
125 struct spidev_data *spidev;
126 struct spi_device *spi;
128 unsigned long missing;
130 /* chipselect only toggles at start or end of operation */
134 spidev = filp->private_data;
137 mutex_lock(&spidev->buf_lock);
138 missing = copy_from_user(spidev->buffer, buf, count);
140 status = spi_write(spi, spidev->buffer, count);
145 mutex_unlock(&spidev->buf_lock);
150 static int spidev_message(struct spidev_data *spidev,
151 struct spi_ioc_transfer *u_xfers, unsigned n_xfers)
153 struct spi_message msg;
154 struct spi_transfer *k_xfers;
155 struct spi_transfer *k_tmp;
156 struct spi_ioc_transfer *u_tmp;
157 struct spi_device *spi = spidev->spi;
160 int status = -EFAULT;
162 spi_message_init(&msg);
163 k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL);
167 /* Construct spi_message, copying any tx data to bounce buffer.
168 * We walk the array of user-provided transfers, using each one
169 * to initialize a kernel version of the same transfer.
171 mutex_lock(&spidev->buf_lock);
172 buf = spidev->buffer;
174 for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;
176 n--, k_tmp++, u_tmp++) {
177 k_tmp->len = u_tmp->len;
180 if (total > bufsiz) {
187 if (!access_ok(VERIFY_WRITE, (u8 __user *)
188 (uintptr_t) u_tmp->rx_buf,
194 if (copy_from_user(buf, (const u8 __user *)
195 (uintptr_t) u_tmp->tx_buf,
201 k_tmp->cs_change = !!u_tmp->cs_change;
202 k_tmp->bits_per_word = u_tmp->bits_per_word;
203 k_tmp->delay_usecs = u_tmp->delay_usecs;
204 k_tmp->speed_hz = u_tmp->speed_hz;
207 " xfer len %zd %s%s%s%dbits %u usec %uHz\n",
209 u_tmp->rx_buf ? "rx " : "",
210 u_tmp->tx_buf ? "tx " : "",
211 u_tmp->cs_change ? "cs " : "",
212 u_tmp->bits_per_word ? : spi->bits_per_word,
214 u_tmp->speed_hz ? : spi->max_speed_hz);
216 spi_message_add_tail(k_tmp, &msg);
219 status = spi_sync(spi, &msg);
223 /* copy any rx data out of bounce buffer */
224 buf = spidev->buffer;
225 for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) {
227 if (__copy_to_user((u8 __user *)
228 (uintptr_t) u_tmp->rx_buf, buf,
239 mutex_unlock(&spidev->buf_lock);
245 spidev_ioctl(struct inode *inode, struct file *filp,
246 unsigned int cmd, unsigned long arg)
250 struct spidev_data *spidev;
251 struct spi_device *spi;
254 struct spi_ioc_transfer *ioc;
256 /* Check type and command number */
257 if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)
260 /* Check access direction once here; don't repeat below.
261 * IOC_DIR is from the user perspective, while access_ok is
262 * from the kernel perspective; so they look reversed.
264 if (_IOC_DIR(cmd) & _IOC_READ)
265 err = !access_ok(VERIFY_WRITE,
266 (void __user *)arg, _IOC_SIZE(cmd));
267 if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE)
268 err = !access_ok(VERIFY_READ,
269 (void __user *)arg, _IOC_SIZE(cmd));
273 spidev = filp->private_data;
278 case SPI_IOC_RD_MODE:
279 retval = __put_user(spi->mode & SPI_MODE_MASK,
282 case SPI_IOC_RD_LSB_FIRST:
283 retval = __put_user((spi->mode & SPI_LSB_FIRST) ? 1 : 0,
286 case SPI_IOC_RD_BITS_PER_WORD:
287 retval = __put_user(spi->bits_per_word, (__u8 __user *)arg);
289 case SPI_IOC_RD_MAX_SPEED_HZ:
290 retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg);
294 case SPI_IOC_WR_MODE:
295 retval = __get_user(tmp, (u8 __user *)arg);
299 if (tmp & ~SPI_MODE_MASK) {
304 tmp |= spi->mode & ~SPI_MODE_MASK;
306 retval = spi_setup(spi);
310 dev_dbg(&spi->dev, "spi mode %02x\n", tmp);
313 case SPI_IOC_WR_LSB_FIRST:
314 retval = __get_user(tmp, (__u8 __user *)arg);
319 spi->mode |= SPI_LSB_FIRST;
321 spi->mode &= ~SPI_LSB_FIRST;
322 retval = spi_setup(spi);
326 dev_dbg(&spi->dev, "%csb first\n",
330 case SPI_IOC_WR_BITS_PER_WORD:
331 retval = __get_user(tmp, (__u8 __user *)arg);
333 u8 save = spi->bits_per_word;
335 spi->bits_per_word = tmp;
336 retval = spi_setup(spi);
338 spi->bits_per_word = save;
340 dev_dbg(&spi->dev, "%d bits per word\n", tmp);
343 case SPI_IOC_WR_MAX_SPEED_HZ:
344 retval = __get_user(tmp, (__u32 __user *)arg);
346 u32 save = spi->max_speed_hz;
348 spi->max_speed_hz = tmp;
349 retval = spi_setup(spi);
351 spi->max_speed_hz = save;
353 dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);
358 /* segmented and/or full-duplex I/O request */
359 if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))
360 || _IOC_DIR(cmd) != _IOC_WRITE)
363 tmp = _IOC_SIZE(cmd);
364 if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) {
368 n_ioc = tmp / sizeof(struct spi_ioc_transfer);
372 /* copy into scratch area */
373 ioc = kmalloc(tmp, GFP_KERNEL);
378 if (__copy_from_user(ioc, (void __user *)arg, tmp)) {
384 /* translate to spi_message, execute */
385 retval = spidev_message(spidev, ioc, n_ioc);
392 static int spidev_open(struct inode *inode, struct file *filp)
394 struct spidev_data *spidev;
398 mutex_lock(&device_list_lock);
400 list_for_each_entry(spidev, &device_list, device_entry) {
401 if (spidev->dev.devt == inode->i_rdev) {
407 if (!spidev->buffer) {
408 spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);
409 if (!spidev->buffer) {
410 dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
416 filp->private_data = spidev;
417 nonseekable_open(inode, filp);
420 pr_debug("spidev: nothing for minor %d\n", iminor(inode));
422 mutex_unlock(&device_list_lock);
427 static int spidev_release(struct inode *inode, struct file *filp)
429 struct spidev_data *spidev;
432 mutex_lock(&device_list_lock);
433 spidev = filp->private_data;
434 filp->private_data = NULL;
436 if (!spidev->users) {
437 kfree(spidev->buffer);
438 spidev->buffer = NULL;
440 mutex_unlock(&device_list_lock);
445 static struct file_operations spidev_fops = {
446 .owner = THIS_MODULE,
447 /* REVISIT switch to aio primitives, so that userspace
448 * gets more complete API coverage. It'll simplify things
449 * too, except for the locking.
451 .write = spidev_write,
453 .ioctl = spidev_ioctl,
455 .release = spidev_release,
458 /*-------------------------------------------------------------------------*/
460 /* The main reason to have this class is to make mdev/udev create the
461 * /dev/spidevB.C character device nodes exposing our userspace API.
462 * It also simplifies memory management.
465 static void spidev_classdev_release(struct device *dev)
467 struct spidev_data *spidev;
469 spidev = container_of(dev, struct spidev_data, dev);
473 static struct class spidev_class = {
475 .owner = THIS_MODULE,
476 .dev_release = spidev_classdev_release,
479 /*-------------------------------------------------------------------------*/
481 static int spidev_probe(struct spi_device *spi)
483 struct spidev_data *spidev;
487 /* Allocate driver data */
488 spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
492 /* Initialize the driver data */
494 mutex_init(&spidev->buf_lock);
496 INIT_LIST_HEAD(&spidev->device_entry);
498 /* If we can allocate a minor number, hook up this device.
499 * Reusing minors is fine so long as udev or mdev is working.
501 mutex_lock(&device_list_lock);
502 minor = find_first_zero_bit(minors, N_SPI_MINORS);
503 if (minor < N_SPI_MINORS) {
504 spidev->dev.parent = &spi->dev;
505 spidev->dev.class = &spidev_class;
506 spidev->dev.devt = MKDEV(SPIDEV_MAJOR, minor);
507 snprintf(spidev->dev.bus_id, sizeof spidev->dev.bus_id,
509 spi->master->bus_num, spi->chip_select);
510 status = device_register(&spidev->dev);
512 dev_dbg(&spi->dev, "no minor number available!\n");
516 set_bit(minor, minors);
517 dev_set_drvdata(&spi->dev, spidev);
518 list_add(&spidev->device_entry, &device_list);
520 mutex_unlock(&device_list_lock);
528 static int spidev_remove(struct spi_device *spi)
530 struct spidev_data *spidev = dev_get_drvdata(&spi->dev);
532 mutex_lock(&device_list_lock);
534 list_del(&spidev->device_entry);
535 dev_set_drvdata(&spi->dev, NULL);
536 clear_bit(MINOR(spidev->dev.devt), minors);
537 device_unregister(&spidev->dev);
539 mutex_unlock(&device_list_lock);
544 static struct spi_driver spidev_spi = {
547 .owner = THIS_MODULE,
549 .probe = spidev_probe,
550 .remove = __devexit_p(spidev_remove),
552 /* NOTE: suspend/resume methods are not necessary here.
553 * We don't do anything except pass the requests to/from
554 * the underlying controller. The refrigerator handles
555 * most issues; the controller driver handles the rest.
559 /*-------------------------------------------------------------------------*/
561 static int __init spidev_init(void)
565 /* Claim our 256 reserved device numbers. Then register a class
566 * that will key udev/mdev to add/remove /dev nodes. Last, register
567 * the driver which manages those device numbers.
569 BUILD_BUG_ON(N_SPI_MINORS > 256);
570 status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
574 status = class_register(&spidev_class);
576 unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
580 status = spi_register_driver(&spidev_spi);
582 class_unregister(&spidev_class);
583 unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
587 module_init(spidev_init);
589 static void __exit spidev_exit(void)
591 spi_unregister_driver(&spidev_spi);
592 class_unregister(&spidev_class);
593 unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
595 module_exit(spidev_exit);
597 MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
598 MODULE_DESCRIPTION("User mode SPI device interface");
599 MODULE_LICENSE("GPL");