2 * 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/err.h>
29 #include <linux/list.h>
30 #include <linux/errno.h>
31 #include <linux/mutex.h>
32 #include <linux/slab.h>
33 #include <linux/compat.h>
35 #include <linux/of_device.h>
37 #include <linux/spi/spi.h>
38 #include <linux/spi/spidev.h>
40 #include <linux/uaccess.h>
44 * This supports access to SPI devices using normal userspace I/O calls.
45 * Note that while traditional UNIX/POSIX I/O semantics are half duplex,
46 * and often mask message boundaries, full SPI support requires full duplex
47 * transfers. There are several kinds of internal message boundaries to
48 * handle chipselect management and other protocol options.
50 * SPI has a character major number assigned. We allocate minor numbers
51 * dynamically using a bitmask. You must use hotplug tools, such as udev
52 * (or mdev with busybox) to create and destroy the /dev/spidevB.C device
53 * nodes, since there is no fixed association of minor numbers with any
54 * particular SPI bus or device.
56 #define SPIDEV_MAJOR 153 /* assigned */
57 #define N_SPI_MINORS 32 /* ... up to 256 */
59 static DECLARE_BITMAP(minors
, N_SPI_MINORS
);
62 /* Bit masks for spi_device.mode management. Note that incorrect
63 * settings for some settings can cause *lots* of trouble for other
64 * devices on a shared bus:
66 * - CS_HIGH ... this device will be active when it shouldn't be
67 * - 3WIRE ... when active, it won't behave as it should
68 * - NO_CS ... there will be no explicit message boundaries; this
69 * is completely incompatible with the shared bus model
70 * - READY ... transfers may proceed when they shouldn't.
72 * REVISIT should changing those flags be privileged?
74 #define SPI_MODE_MASK (SPI_CPHA | SPI_CPOL | SPI_CS_HIGH \
75 | SPI_LSB_FIRST | SPI_3WIRE | SPI_LOOP \
76 | SPI_NO_CS | SPI_READY | SPI_TX_DUAL \
77 | SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD)
82 struct spi_device
*spi
;
83 struct list_head device_entry
;
85 /* TX/RX buffers are NULL unless this device is open (users > 0) */
86 struct mutex buf_lock
;
92 static LIST_HEAD(device_list
);
93 static DEFINE_MUTEX(device_list_lock
);
95 static unsigned bufsiz
= 4096;
96 module_param(bufsiz
, uint
, S_IRUGO
);
97 MODULE_PARM_DESC(bufsiz
, "data bytes in biggest supported SPI message");
99 /*-------------------------------------------------------------------------*/
102 * We can't use the standard synchronous wrappers for file I/O; we
103 * need to protect against async removal of the underlying spi_device.
105 static void spidev_complete(void *arg
)
111 spidev_sync(struct spidev_data
*spidev
, struct spi_message
*message
)
113 DECLARE_COMPLETION_ONSTACK(done
);
116 message
->complete
= spidev_complete
;
117 message
->context
= &done
;
119 spin_lock_irq(&spidev
->spi_lock
);
120 if (spidev
->spi
== NULL
)
123 status
= spi_async(spidev
->spi
, message
);
124 spin_unlock_irq(&spidev
->spi_lock
);
127 wait_for_completion(&done
);
128 status
= message
->status
;
130 status
= message
->actual_length
;
135 static inline ssize_t
136 spidev_sync_write(struct spidev_data
*spidev
, size_t len
)
138 struct spi_transfer t
= {
139 .tx_buf
= spidev
->tx_buffer
,
142 struct spi_message m
;
144 spi_message_init(&m
);
145 spi_message_add_tail(&t
, &m
);
146 return spidev_sync(spidev
, &m
);
149 static inline ssize_t
150 spidev_sync_read(struct spidev_data
*spidev
, size_t len
)
152 struct spi_transfer t
= {
153 .rx_buf
= spidev
->rx_buffer
,
156 struct spi_message m
;
158 spi_message_init(&m
);
159 spi_message_add_tail(&t
, &m
);
160 return spidev_sync(spidev
, &m
);
163 /*-------------------------------------------------------------------------*/
165 /* Read-only message with current device setup */
167 spidev_read(struct file
*filp
, char __user
*buf
, size_t count
, loff_t
*f_pos
)
169 struct spidev_data
*spidev
;
172 /* chipselect only toggles at start or end of operation */
176 spidev
= filp
->private_data
;
178 mutex_lock(&spidev
->buf_lock
);
179 status
= spidev_sync_read(spidev
, count
);
181 unsigned long missing
;
183 missing
= copy_to_user(buf
, spidev
->rx_buffer
, status
);
184 if (missing
== status
)
187 status
= status
- missing
;
189 mutex_unlock(&spidev
->buf_lock
);
194 /* Write-only message with current device setup */
196 spidev_write(struct file
*filp
, const char __user
*buf
,
197 size_t count
, loff_t
*f_pos
)
199 struct spidev_data
*spidev
;
201 unsigned long missing
;
203 /* chipselect only toggles at start or end of operation */
207 spidev
= filp
->private_data
;
209 mutex_lock(&spidev
->buf_lock
);
210 missing
= copy_from_user(spidev
->tx_buffer
, buf
, count
);
212 status
= spidev_sync_write(spidev
, count
);
215 mutex_unlock(&spidev
->buf_lock
);
220 static int spidev_message(struct spidev_data
*spidev
,
221 struct spi_ioc_transfer
*u_xfers
, unsigned n_xfers
)
223 struct spi_message msg
;
224 struct spi_transfer
*k_xfers
;
225 struct spi_transfer
*k_tmp
;
226 struct spi_ioc_transfer
*u_tmp
;
229 int status
= -EFAULT
;
231 spi_message_init(&msg
);
232 k_xfers
= kcalloc(n_xfers
, sizeof(*k_tmp
), GFP_KERNEL
);
236 /* Construct spi_message, copying any tx data to bounce buffer.
237 * We walk the array of user-provided transfers, using each one
238 * to initialize a kernel version of the same transfer.
240 tx_buf
= spidev
->tx_buffer
;
241 rx_buf
= spidev
->rx_buffer
;
243 for (n
= n_xfers
, k_tmp
= k_xfers
, u_tmp
= u_xfers
;
245 n
--, k_tmp
++, u_tmp
++) {
246 k_tmp
->len
= u_tmp
->len
;
249 if (total
> bufsiz
) {
255 k_tmp
->rx_buf
= rx_buf
;
256 if (!access_ok(VERIFY_WRITE
, (u8 __user
*)
257 (uintptr_t) u_tmp
->rx_buf
,
262 k_tmp
->tx_buf
= tx_buf
;
263 if (copy_from_user(tx_buf
, (const u8 __user
*)
264 (uintptr_t) u_tmp
->tx_buf
,
268 tx_buf
+= k_tmp
->len
;
269 rx_buf
+= k_tmp
->len
;
271 k_tmp
->cs_change
= !!u_tmp
->cs_change
;
272 k_tmp
->tx_nbits
= u_tmp
->tx_nbits
;
273 k_tmp
->rx_nbits
= u_tmp
->rx_nbits
;
274 k_tmp
->bits_per_word
= u_tmp
->bits_per_word
;
275 k_tmp
->delay_usecs
= u_tmp
->delay_usecs
;
276 k_tmp
->speed_hz
= u_tmp
->speed_hz
;
278 dev_dbg(&spidev
->spi
->dev
,
279 " xfer len %zd %s%s%s%dbits %u usec %uHz\n",
281 u_tmp
->rx_buf
? "rx " : "",
282 u_tmp
->tx_buf
? "tx " : "",
283 u_tmp
->cs_change
? "cs " : "",
284 u_tmp
->bits_per_word
? : spidev
->spi
->bits_per_word
,
286 u_tmp
->speed_hz
? : spidev
->spi
->max_speed_hz
);
288 spi_message_add_tail(k_tmp
, &msg
);
291 status
= spidev_sync(spidev
, &msg
);
295 /* copy any rx data out of bounce buffer */
296 rx_buf
= spidev
->rx_buffer
;
297 for (n
= n_xfers
, u_tmp
= u_xfers
; n
; n
--, u_tmp
++) {
299 if (__copy_to_user((u8 __user
*)
300 (uintptr_t) u_tmp
->rx_buf
, rx_buf
,
306 rx_buf
+= u_tmp
->len
;
316 spidev_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
320 struct spidev_data
*spidev
;
321 struct spi_device
*spi
;
324 struct spi_ioc_transfer
*ioc
;
326 /* Check type and command number */
327 if (_IOC_TYPE(cmd
) != SPI_IOC_MAGIC
)
330 /* Check access direction once here; don't repeat below.
331 * IOC_DIR is from the user perspective, while access_ok is
332 * from the kernel perspective; so they look reversed.
334 if (_IOC_DIR(cmd
) & _IOC_READ
)
335 err
= !access_ok(VERIFY_WRITE
,
336 (void __user
*)arg
, _IOC_SIZE(cmd
));
337 if (err
== 0 && _IOC_DIR(cmd
) & _IOC_WRITE
)
338 err
= !access_ok(VERIFY_READ
,
339 (void __user
*)arg
, _IOC_SIZE(cmd
));
343 /* guard against device removal before, or while,
344 * we issue this ioctl.
346 spidev
= filp
->private_data
;
347 spin_lock_irq(&spidev
->spi_lock
);
348 spi
= spi_dev_get(spidev
->spi
);
349 spin_unlock_irq(&spidev
->spi_lock
);
354 /* use the buffer lock here for triple duty:
355 * - prevent I/O (from us) so calling spi_setup() is safe;
356 * - prevent concurrent SPI_IOC_WR_* from morphing
357 * data fields while SPI_IOC_RD_* reads them;
358 * - SPI_IOC_MESSAGE needs the buffer locked "normally".
360 mutex_lock(&spidev
->buf_lock
);
364 case SPI_IOC_RD_MODE
:
365 retval
= __put_user(spi
->mode
& SPI_MODE_MASK
,
368 case SPI_IOC_RD_MODE32
:
369 retval
= __put_user(spi
->mode
& SPI_MODE_MASK
,
370 (__u32 __user
*)arg
);
372 case SPI_IOC_RD_LSB_FIRST
:
373 retval
= __put_user((spi
->mode
& SPI_LSB_FIRST
) ? 1 : 0,
376 case SPI_IOC_RD_BITS_PER_WORD
:
377 retval
= __put_user(spi
->bits_per_word
, (__u8 __user
*)arg
);
379 case SPI_IOC_RD_MAX_SPEED_HZ
:
380 retval
= __put_user(spi
->max_speed_hz
, (__u32 __user
*)arg
);
384 case SPI_IOC_WR_MODE
:
385 case SPI_IOC_WR_MODE32
:
386 if (cmd
== SPI_IOC_WR_MODE
)
387 retval
= __get_user(tmp
, (u8 __user
*)arg
);
389 retval
= __get_user(tmp
, (u32 __user
*)arg
);
391 u32 save
= spi
->mode
;
393 if (tmp
& ~SPI_MODE_MASK
) {
398 tmp
|= spi
->mode
& ~SPI_MODE_MASK
;
399 spi
->mode
= (u16
)tmp
;
400 retval
= spi_setup(spi
);
404 dev_dbg(&spi
->dev
, "spi mode %x\n", tmp
);
407 case SPI_IOC_WR_LSB_FIRST
:
408 retval
= __get_user(tmp
, (__u8 __user
*)arg
);
410 u32 save
= spi
->mode
;
413 spi
->mode
|= SPI_LSB_FIRST
;
415 spi
->mode
&= ~SPI_LSB_FIRST
;
416 retval
= spi_setup(spi
);
420 dev_dbg(&spi
->dev
, "%csb first\n",
424 case SPI_IOC_WR_BITS_PER_WORD
:
425 retval
= __get_user(tmp
, (__u8 __user
*)arg
);
427 u8 save
= spi
->bits_per_word
;
429 spi
->bits_per_word
= tmp
;
430 retval
= spi_setup(spi
);
432 spi
->bits_per_word
= save
;
434 dev_dbg(&spi
->dev
, "%d bits per word\n", tmp
);
437 case SPI_IOC_WR_MAX_SPEED_HZ
:
438 retval
= __get_user(tmp
, (__u32 __user
*)arg
);
440 u32 save
= spi
->max_speed_hz
;
442 spi
->max_speed_hz
= tmp
;
443 retval
= spi_setup(spi
);
445 spi
->max_speed_hz
= save
;
447 dev_dbg(&spi
->dev
, "%d Hz (max)\n", tmp
);
452 /* segmented and/or full-duplex I/O request */
453 if (_IOC_NR(cmd
) != _IOC_NR(SPI_IOC_MESSAGE(0))
454 || _IOC_DIR(cmd
) != _IOC_WRITE
) {
459 tmp
= _IOC_SIZE(cmd
);
460 if ((tmp
% sizeof(struct spi_ioc_transfer
)) != 0) {
464 n_ioc
= tmp
/ sizeof(struct spi_ioc_transfer
);
468 /* copy into scratch area */
469 ioc
= kmalloc(tmp
, GFP_KERNEL
);
474 if (__copy_from_user(ioc
, (void __user
*)arg
, tmp
)) {
480 /* translate to spi_message, execute */
481 retval
= spidev_message(spidev
, ioc
, n_ioc
);
486 mutex_unlock(&spidev
->buf_lock
);
493 spidev_compat_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
495 return spidev_ioctl(filp
, cmd
, (unsigned long)compat_ptr(arg
));
498 #define spidev_compat_ioctl NULL
499 #endif /* CONFIG_COMPAT */
501 static int spidev_open(struct inode
*inode
, struct file
*filp
)
503 struct spidev_data
*spidev
;
506 mutex_lock(&device_list_lock
);
508 list_for_each_entry(spidev
, &device_list
, device_entry
) {
509 if (spidev
->devt
== inode
->i_rdev
) {
516 pr_debug("spidev: nothing for minor %d\n", iminor(inode
));
520 if (!spidev
->tx_buffer
) {
521 spidev
->tx_buffer
= kmalloc(bufsiz
, GFP_KERNEL
);
522 if (!spidev
->tx_buffer
) {
523 dev_dbg(&spidev
->spi
->dev
, "open/ENOMEM\n");
529 if (!spidev
->rx_buffer
) {
530 spidev
->rx_buffer
= kmalloc(bufsiz
, GFP_KERNEL
);
531 if (!spidev
->rx_buffer
) {
532 dev_dbg(&spidev
->spi
->dev
, "open/ENOMEM\n");
534 goto err_alloc_rx_buf
;
539 filp
->private_data
= spidev
;
540 nonseekable_open(inode
, filp
);
542 mutex_unlock(&device_list_lock
);
546 kfree(spidev
->tx_buffer
);
547 spidev
->tx_buffer
= NULL
;
549 mutex_unlock(&device_list_lock
);
553 static int spidev_release(struct inode
*inode
, struct file
*filp
)
555 struct spidev_data
*spidev
;
558 mutex_lock(&device_list_lock
);
559 spidev
= filp
->private_data
;
560 filp
->private_data
= NULL
;
564 if (!spidev
->users
) {
567 kfree(spidev
->tx_buffer
);
568 spidev
->tx_buffer
= NULL
;
570 kfree(spidev
->rx_buffer
);
571 spidev
->rx_buffer
= NULL
;
573 /* ... after we unbound from the underlying device? */
574 spin_lock_irq(&spidev
->spi_lock
);
575 dofree
= (spidev
->spi
== NULL
);
576 spin_unlock_irq(&spidev
->spi_lock
);
581 mutex_unlock(&device_list_lock
);
586 static const struct file_operations spidev_fops
= {
587 .owner
= THIS_MODULE
,
588 /* REVISIT switch to aio primitives, so that userspace
589 * gets more complete API coverage. It'll simplify things
590 * too, except for the locking.
592 .write
= spidev_write
,
594 .unlocked_ioctl
= spidev_ioctl
,
595 .compat_ioctl
= spidev_compat_ioctl
,
597 .release
= spidev_release
,
601 /*-------------------------------------------------------------------------*/
603 /* The main reason to have this class is to make mdev/udev create the
604 * /dev/spidevB.C character device nodes exposing our userspace API.
605 * It also simplifies memory management.
608 static struct class *spidev_class
;
610 /*-------------------------------------------------------------------------*/
612 static int spidev_probe(struct spi_device
*spi
)
614 struct spidev_data
*spidev
;
618 /* Allocate driver data */
619 spidev
= kzalloc(sizeof(*spidev
), GFP_KERNEL
);
623 /* Initialize the driver data */
625 spin_lock_init(&spidev
->spi_lock
);
626 mutex_init(&spidev
->buf_lock
);
628 INIT_LIST_HEAD(&spidev
->device_entry
);
630 /* If we can allocate a minor number, hook up this device.
631 * Reusing minors is fine so long as udev or mdev is working.
633 mutex_lock(&device_list_lock
);
634 minor
= find_first_zero_bit(minors
, N_SPI_MINORS
);
635 if (minor
< N_SPI_MINORS
) {
638 spidev
->devt
= MKDEV(SPIDEV_MAJOR
, minor
);
639 dev
= device_create(spidev_class
, &spi
->dev
, spidev
->devt
,
640 spidev
, "spidev%d.%d",
641 spi
->master
->bus_num
, spi
->chip_select
);
642 status
= PTR_ERR_OR_ZERO(dev
);
644 dev_dbg(&spi
->dev
, "no minor number available!\n");
648 set_bit(minor
, minors
);
649 list_add(&spidev
->device_entry
, &device_list
);
651 mutex_unlock(&device_list_lock
);
654 spi_set_drvdata(spi
, spidev
);
661 static int spidev_remove(struct spi_device
*spi
)
663 struct spidev_data
*spidev
= spi_get_drvdata(spi
);
665 /* make sure ops on existing fds can abort cleanly */
666 spin_lock_irq(&spidev
->spi_lock
);
668 spin_unlock_irq(&spidev
->spi_lock
);
670 /* prevent new opens */
671 mutex_lock(&device_list_lock
);
672 list_del(&spidev
->device_entry
);
673 device_destroy(spidev_class
, spidev
->devt
);
674 clear_bit(MINOR(spidev
->devt
), minors
);
675 if (spidev
->users
== 0)
677 mutex_unlock(&device_list_lock
);
682 static const struct of_device_id spidev_dt_ids
[] = {
683 { .compatible
= "rohm,dh2228fv" },
687 MODULE_DEVICE_TABLE(of
, spidev_dt_ids
);
689 static struct spi_driver spidev_spi_driver
= {
692 .owner
= THIS_MODULE
,
693 .of_match_table
= of_match_ptr(spidev_dt_ids
),
695 .probe
= spidev_probe
,
696 .remove
= spidev_remove
,
698 /* NOTE: suspend/resume methods are not necessary here.
699 * We don't do anything except pass the requests to/from
700 * the underlying controller. The refrigerator handles
701 * most issues; the controller driver handles the rest.
705 /*-------------------------------------------------------------------------*/
707 static int __init
spidev_init(void)
711 /* Claim our 256 reserved device numbers. Then register a class
712 * that will key udev/mdev to add/remove /dev nodes. Last, register
713 * the driver which manages those device numbers.
715 BUILD_BUG_ON(N_SPI_MINORS
> 256);
716 status
= register_chrdev(SPIDEV_MAJOR
, "spi", &spidev_fops
);
720 spidev_class
= class_create(THIS_MODULE
, "spidev");
721 if (IS_ERR(spidev_class
)) {
722 unregister_chrdev(SPIDEV_MAJOR
, spidev_spi_driver
.driver
.name
);
723 return PTR_ERR(spidev_class
);
726 status
= spi_register_driver(&spidev_spi_driver
);
728 class_destroy(spidev_class
);
729 unregister_chrdev(SPIDEV_MAJOR
, spidev_spi_driver
.driver
.name
);
733 module_init(spidev_init
);
735 static void __exit
spidev_exit(void)
737 spi_unregister_driver(&spidev_spi_driver
);
738 class_destroy(spidev_class
);
739 unregister_chrdev(SPIDEV_MAJOR
, spidev_spi_driver
.driver
.name
);
741 module_exit(spidev_exit
);
743 MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
744 MODULE_DESCRIPTION("User mode SPI device interface");
745 MODULE_LICENSE("GPL");
746 MODULE_ALIAS("spi:spidev");