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.
19 #include <linux/init.h>
20 #include <linux/module.h>
21 #include <linux/ioctl.h>
23 #include <linux/device.h>
24 #include <linux/err.h>
25 #include <linux/list.h>
26 #include <linux/errno.h>
27 #include <linux/mutex.h>
28 #include <linux/slab.h>
29 #include <linux/compat.h>
31 #include <linux/of_device.h>
33 #include <linux/spi/spi.h>
34 #include <linux/spi/spidev.h>
36 #include <linux/uaccess.h>
40 * This supports access to SPI devices using normal userspace I/O calls.
41 * Note that while traditional UNIX/POSIX I/O semantics are half duplex,
42 * and often mask message boundaries, full SPI support requires full duplex
43 * transfers. There are several kinds of internal message boundaries to
44 * handle chipselect management and other protocol options.
46 * SPI has a character major number assigned. We allocate minor numbers
47 * dynamically using a bitmask. You must use hotplug tools, such as udev
48 * (or mdev with busybox) to create and destroy the /dev/spidevB.C device
49 * nodes, since there is no fixed association of minor numbers with any
50 * particular SPI bus or device.
52 #define SPIDEV_MAJOR 153 /* assigned */
53 #define N_SPI_MINORS 32 /* ... up to 256 */
55 static DECLARE_BITMAP(minors
, N_SPI_MINORS
);
58 /* Bit masks for spi_device.mode management. Note that incorrect
59 * settings for some settings can cause *lots* of trouble for other
60 * devices on a shared bus:
62 * - CS_HIGH ... this device will be active when it shouldn't be
63 * - 3WIRE ... when active, it won't behave as it should
64 * - NO_CS ... there will be no explicit message boundaries; this
65 * is completely incompatible with the shared bus model
66 * - READY ... transfers may proceed when they shouldn't.
68 * REVISIT should changing those flags be privileged?
70 #define SPI_MODE_MASK (SPI_CPHA | SPI_CPOL | SPI_CS_HIGH \
71 | SPI_LSB_FIRST | SPI_3WIRE | SPI_LOOP \
72 | SPI_NO_CS | SPI_READY | SPI_TX_DUAL \
73 | SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD)
78 struct spi_device
*spi
;
79 struct list_head device_entry
;
81 /* TX/RX buffers are NULL unless this device is open (users > 0) */
82 struct mutex buf_lock
;
89 static LIST_HEAD(device_list
);
90 static DEFINE_MUTEX(device_list_lock
);
92 static unsigned bufsiz
= 4096;
93 module_param(bufsiz
, uint
, S_IRUGO
);
94 MODULE_PARM_DESC(bufsiz
, "data bytes in biggest supported SPI message");
96 /*-------------------------------------------------------------------------*/
99 * We can't use the standard synchronous wrappers for file I/O; we
100 * need to protect against async removal of the underlying spi_device.
102 static void spidev_complete(void *arg
)
108 spidev_sync(struct spidev_data
*spidev
, struct spi_message
*message
)
110 DECLARE_COMPLETION_ONSTACK(done
);
113 message
->complete
= spidev_complete
;
114 message
->context
= &done
;
116 spin_lock_irq(&spidev
->spi_lock
);
117 if (spidev
->spi
== NULL
)
120 status
= spi_async(spidev
->spi
, message
);
121 spin_unlock_irq(&spidev
->spi_lock
);
124 wait_for_completion(&done
);
125 status
= message
->status
;
127 status
= message
->actual_length
;
132 static inline ssize_t
133 spidev_sync_write(struct spidev_data
*spidev
, size_t len
)
135 struct spi_transfer t
= {
136 .tx_buf
= spidev
->tx_buffer
,
138 .speed_hz
= spidev
->speed_hz
,
140 struct spi_message m
;
142 spi_message_init(&m
);
143 spi_message_add_tail(&t
, &m
);
144 return spidev_sync(spidev
, &m
);
147 static inline ssize_t
148 spidev_sync_read(struct spidev_data
*spidev
, size_t len
)
150 struct spi_transfer t
= {
151 .rx_buf
= spidev
->rx_buffer
,
153 .speed_hz
= spidev
->speed_hz
,
155 struct spi_message m
;
157 spi_message_init(&m
);
158 spi_message_add_tail(&t
, &m
);
159 return spidev_sync(spidev
, &m
);
162 /*-------------------------------------------------------------------------*/
164 /* Read-only message with current device setup */
166 spidev_read(struct file
*filp
, char __user
*buf
, size_t count
, loff_t
*f_pos
)
168 struct spidev_data
*spidev
;
171 /* chipselect only toggles at start or end of operation */
175 spidev
= filp
->private_data
;
177 mutex_lock(&spidev
->buf_lock
);
178 status
= spidev_sync_read(spidev
, count
);
180 unsigned long missing
;
182 missing
= copy_to_user(buf
, spidev
->rx_buffer
, status
);
183 if (missing
== status
)
186 status
= status
- missing
;
188 mutex_unlock(&spidev
->buf_lock
);
193 /* Write-only message with current device setup */
195 spidev_write(struct file
*filp
, const char __user
*buf
,
196 size_t count
, loff_t
*f_pos
)
198 struct spidev_data
*spidev
;
200 unsigned long missing
;
202 /* chipselect only toggles at start or end of operation */
206 spidev
= filp
->private_data
;
208 mutex_lock(&spidev
->buf_lock
);
209 missing
= copy_from_user(spidev
->tx_buffer
, buf
, count
);
211 status
= spidev_sync_write(spidev
, count
);
214 mutex_unlock(&spidev
->buf_lock
);
219 static int spidev_message(struct spidev_data
*spidev
,
220 struct spi_ioc_transfer
*u_xfers
, unsigned n_xfers
)
222 struct spi_message msg
;
223 struct spi_transfer
*k_xfers
;
224 struct spi_transfer
*k_tmp
;
225 struct spi_ioc_transfer
*u_tmp
;
228 int status
= -EFAULT
;
230 spi_message_init(&msg
);
231 k_xfers
= kcalloc(n_xfers
, sizeof(*k_tmp
), GFP_KERNEL
);
235 /* Construct spi_message, copying any tx data to bounce buffer.
236 * We walk the array of user-provided transfers, using each one
237 * to initialize a kernel version of the same transfer.
239 tx_buf
= spidev
->tx_buffer
;
240 rx_buf
= spidev
->rx_buffer
;
242 for (n
= n_xfers
, k_tmp
= k_xfers
, u_tmp
= u_xfers
;
244 n
--, k_tmp
++, u_tmp
++) {
245 k_tmp
->len
= u_tmp
->len
;
248 if (total
> bufsiz
) {
254 k_tmp
->rx_buf
= rx_buf
;
255 if (!access_ok(VERIFY_WRITE
, (u8 __user
*)
256 (uintptr_t) u_tmp
->rx_buf
,
261 k_tmp
->tx_buf
= tx_buf
;
262 if (copy_from_user(tx_buf
, (const u8 __user
*)
263 (uintptr_t) u_tmp
->tx_buf
,
267 tx_buf
+= k_tmp
->len
;
268 rx_buf
+= k_tmp
->len
;
270 k_tmp
->cs_change
= !!u_tmp
->cs_change
;
271 k_tmp
->tx_nbits
= u_tmp
->tx_nbits
;
272 k_tmp
->rx_nbits
= u_tmp
->rx_nbits
;
273 k_tmp
->bits_per_word
= u_tmp
->bits_per_word
;
274 k_tmp
->delay_usecs
= u_tmp
->delay_usecs
;
275 k_tmp
->speed_hz
= u_tmp
->speed_hz
;
276 if (!k_tmp
->speed_hz
)
277 k_tmp
->speed_hz
= spidev
->speed_hz
;
279 dev_dbg(&spidev
->spi
->dev
,
280 " xfer len %zd %s%s%s%dbits %u usec %uHz\n",
282 u_tmp
->rx_buf
? "rx " : "",
283 u_tmp
->tx_buf
? "tx " : "",
284 u_tmp
->cs_change
? "cs " : "",
285 u_tmp
->bits_per_word
? : spidev
->spi
->bits_per_word
,
287 u_tmp
->speed_hz
? : spidev
->spi
->max_speed_hz
);
289 spi_message_add_tail(k_tmp
, &msg
);
292 status
= spidev_sync(spidev
, &msg
);
296 /* copy any rx data out of bounce buffer */
297 rx_buf
= spidev
->rx_buffer
;
298 for (n
= n_xfers
, u_tmp
= u_xfers
; n
; n
--, u_tmp
++) {
300 if (__copy_to_user((u8 __user
*)
301 (uintptr_t) u_tmp
->rx_buf
, rx_buf
,
307 rx_buf
+= u_tmp
->len
;
317 spidev_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
321 struct spidev_data
*spidev
;
322 struct spi_device
*spi
;
325 struct spi_ioc_transfer
*ioc
;
327 /* Check type and command number */
328 if (_IOC_TYPE(cmd
) != SPI_IOC_MAGIC
)
331 /* Check access direction once here; don't repeat below.
332 * IOC_DIR is from the user perspective, while access_ok is
333 * from the kernel perspective; so they look reversed.
335 if (_IOC_DIR(cmd
) & _IOC_READ
)
336 err
= !access_ok(VERIFY_WRITE
,
337 (void __user
*)arg
, _IOC_SIZE(cmd
));
338 if (err
== 0 && _IOC_DIR(cmd
) & _IOC_WRITE
)
339 err
= !access_ok(VERIFY_READ
,
340 (void __user
*)arg
, _IOC_SIZE(cmd
));
344 /* guard against device removal before, or while,
345 * we issue this ioctl.
347 spidev
= filp
->private_data
;
348 spin_lock_irq(&spidev
->spi_lock
);
349 spi
= spi_dev_get(spidev
->spi
);
350 spin_unlock_irq(&spidev
->spi_lock
);
355 /* use the buffer lock here for triple duty:
356 * - prevent I/O (from us) so calling spi_setup() is safe;
357 * - prevent concurrent SPI_IOC_WR_* from morphing
358 * data fields while SPI_IOC_RD_* reads them;
359 * - SPI_IOC_MESSAGE needs the buffer locked "normally".
361 mutex_lock(&spidev
->buf_lock
);
365 case SPI_IOC_RD_MODE
:
366 retval
= __put_user(spi
->mode
& SPI_MODE_MASK
,
369 case SPI_IOC_RD_MODE32
:
370 retval
= __put_user(spi
->mode
& SPI_MODE_MASK
,
371 (__u32 __user
*)arg
);
373 case SPI_IOC_RD_LSB_FIRST
:
374 retval
= __put_user((spi
->mode
& SPI_LSB_FIRST
) ? 1 : 0,
377 case SPI_IOC_RD_BITS_PER_WORD
:
378 retval
= __put_user(spi
->bits_per_word
, (__u8 __user
*)arg
);
380 case SPI_IOC_RD_MAX_SPEED_HZ
:
381 retval
= __put_user(spidev
->speed_hz
, (__u32 __user
*)arg
);
385 case SPI_IOC_WR_MODE
:
386 case SPI_IOC_WR_MODE32
:
387 if (cmd
== SPI_IOC_WR_MODE
)
388 retval
= __get_user(tmp
, (u8 __user
*)arg
);
390 retval
= __get_user(tmp
, (u32 __user
*)arg
);
392 u32 save
= spi
->mode
;
394 if (tmp
& ~SPI_MODE_MASK
) {
399 tmp
|= spi
->mode
& ~SPI_MODE_MASK
;
400 spi
->mode
= (u16
)tmp
;
401 retval
= spi_setup(spi
);
405 dev_dbg(&spi
->dev
, "spi mode %x\n", tmp
);
408 case SPI_IOC_WR_LSB_FIRST
:
409 retval
= __get_user(tmp
, (__u8 __user
*)arg
);
411 u32 save
= spi
->mode
;
414 spi
->mode
|= SPI_LSB_FIRST
;
416 spi
->mode
&= ~SPI_LSB_FIRST
;
417 retval
= spi_setup(spi
);
421 dev_dbg(&spi
->dev
, "%csb first\n",
425 case SPI_IOC_WR_BITS_PER_WORD
:
426 retval
= __get_user(tmp
, (__u8 __user
*)arg
);
428 u8 save
= spi
->bits_per_word
;
430 spi
->bits_per_word
= tmp
;
431 retval
= spi_setup(spi
);
433 spi
->bits_per_word
= save
;
435 dev_dbg(&spi
->dev
, "%d bits per word\n", tmp
);
438 case SPI_IOC_WR_MAX_SPEED_HZ
:
439 retval
= __get_user(tmp
, (__u32 __user
*)arg
);
441 u32 save
= spi
->max_speed_hz
;
443 spi
->max_speed_hz
= tmp
;
444 retval
= spi_setup(spi
);
446 spidev
->speed_hz
= tmp
;
448 dev_dbg(&spi
->dev
, "%d Hz (max)\n", tmp
);
449 spi
->max_speed_hz
= save
;
454 /* segmented and/or full-duplex I/O request */
455 if (_IOC_NR(cmd
) != _IOC_NR(SPI_IOC_MESSAGE(0))
456 || _IOC_DIR(cmd
) != _IOC_WRITE
) {
461 tmp
= _IOC_SIZE(cmd
);
462 if ((tmp
% sizeof(struct spi_ioc_transfer
)) != 0) {
466 n_ioc
= tmp
/ sizeof(struct spi_ioc_transfer
);
470 /* copy into scratch area */
471 ioc
= kmalloc(tmp
, GFP_KERNEL
);
476 if (__copy_from_user(ioc
, (void __user
*)arg
, tmp
)) {
482 /* translate to spi_message, execute */
483 retval
= spidev_message(spidev
, ioc
, n_ioc
);
488 mutex_unlock(&spidev
->buf_lock
);
495 spidev_compat_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
497 return spidev_ioctl(filp
, cmd
, (unsigned long)compat_ptr(arg
));
500 #define spidev_compat_ioctl NULL
501 #endif /* CONFIG_COMPAT */
503 static int spidev_open(struct inode
*inode
, struct file
*filp
)
505 struct spidev_data
*spidev
;
508 mutex_lock(&device_list_lock
);
510 list_for_each_entry(spidev
, &device_list
, device_entry
) {
511 if (spidev
->devt
== inode
->i_rdev
) {
518 pr_debug("spidev: nothing for minor %d\n", iminor(inode
));
522 if (!spidev
->tx_buffer
) {
523 spidev
->tx_buffer
= kmalloc(bufsiz
, GFP_KERNEL
);
524 if (!spidev
->tx_buffer
) {
525 dev_dbg(&spidev
->spi
->dev
, "open/ENOMEM\n");
531 if (!spidev
->rx_buffer
) {
532 spidev
->rx_buffer
= kmalloc(bufsiz
, GFP_KERNEL
);
533 if (!spidev
->rx_buffer
) {
534 dev_dbg(&spidev
->spi
->dev
, "open/ENOMEM\n");
536 goto err_alloc_rx_buf
;
541 filp
->private_data
= spidev
;
542 nonseekable_open(inode
, filp
);
544 mutex_unlock(&device_list_lock
);
548 kfree(spidev
->tx_buffer
);
549 spidev
->tx_buffer
= NULL
;
551 mutex_unlock(&device_list_lock
);
555 static int spidev_release(struct inode
*inode
, struct file
*filp
)
557 struct spidev_data
*spidev
;
560 mutex_lock(&device_list_lock
);
561 spidev
= filp
->private_data
;
562 filp
->private_data
= NULL
;
566 if (!spidev
->users
) {
569 kfree(spidev
->tx_buffer
);
570 spidev
->tx_buffer
= NULL
;
572 kfree(spidev
->rx_buffer
);
573 spidev
->rx_buffer
= NULL
;
575 spidev
->speed_hz
= spidev
->spi
->max_speed_hz
;
577 /* ... after we unbound from the underlying device? */
578 spin_lock_irq(&spidev
->spi_lock
);
579 dofree
= (spidev
->spi
== NULL
);
580 spin_unlock_irq(&spidev
->spi_lock
);
585 mutex_unlock(&device_list_lock
);
590 static const struct file_operations spidev_fops
= {
591 .owner
= THIS_MODULE
,
592 /* REVISIT switch to aio primitives, so that userspace
593 * gets more complete API coverage. It'll simplify things
594 * too, except for the locking.
596 .write
= spidev_write
,
598 .unlocked_ioctl
= spidev_ioctl
,
599 .compat_ioctl
= spidev_compat_ioctl
,
601 .release
= spidev_release
,
605 /*-------------------------------------------------------------------------*/
607 /* The main reason to have this class is to make mdev/udev create the
608 * /dev/spidevB.C character device nodes exposing our userspace API.
609 * It also simplifies memory management.
612 static struct class *spidev_class
;
614 /*-------------------------------------------------------------------------*/
616 static int spidev_probe(struct spi_device
*spi
)
618 struct spidev_data
*spidev
;
622 /* Allocate driver data */
623 spidev
= kzalloc(sizeof(*spidev
), GFP_KERNEL
);
627 /* Initialize the driver data */
629 spin_lock_init(&spidev
->spi_lock
);
630 mutex_init(&spidev
->buf_lock
);
632 INIT_LIST_HEAD(&spidev
->device_entry
);
634 /* If we can allocate a minor number, hook up this device.
635 * Reusing minors is fine so long as udev or mdev is working.
637 mutex_lock(&device_list_lock
);
638 minor
= find_first_zero_bit(minors
, N_SPI_MINORS
);
639 if (minor
< N_SPI_MINORS
) {
642 spidev
->devt
= MKDEV(SPIDEV_MAJOR
, minor
);
643 dev
= device_create(spidev_class
, &spi
->dev
, spidev
->devt
,
644 spidev
, "spidev%d.%d",
645 spi
->master
->bus_num
, spi
->chip_select
);
646 status
= PTR_ERR_OR_ZERO(dev
);
648 dev_dbg(&spi
->dev
, "no minor number available!\n");
652 set_bit(minor
, minors
);
653 list_add(&spidev
->device_entry
, &device_list
);
655 mutex_unlock(&device_list_lock
);
657 spidev
->speed_hz
= spi
->max_speed_hz
;
660 spi_set_drvdata(spi
, spidev
);
667 static int spidev_remove(struct spi_device
*spi
)
669 struct spidev_data
*spidev
= spi_get_drvdata(spi
);
671 /* make sure ops on existing fds can abort cleanly */
672 spin_lock_irq(&spidev
->spi_lock
);
674 spin_unlock_irq(&spidev
->spi_lock
);
676 /* prevent new opens */
677 mutex_lock(&device_list_lock
);
678 list_del(&spidev
->device_entry
);
679 device_destroy(spidev_class
, spidev
->devt
);
680 clear_bit(MINOR(spidev
->devt
), minors
);
681 if (spidev
->users
== 0)
683 mutex_unlock(&device_list_lock
);
688 static const struct of_device_id spidev_dt_ids
[] = {
689 { .compatible
= "rohm,dh2228fv" },
693 MODULE_DEVICE_TABLE(of
, spidev_dt_ids
);
695 static struct spi_driver spidev_spi_driver
= {
698 .owner
= THIS_MODULE
,
699 .of_match_table
= of_match_ptr(spidev_dt_ids
),
701 .probe
= spidev_probe
,
702 .remove
= spidev_remove
,
704 /* NOTE: suspend/resume methods are not necessary here.
705 * We don't do anything except pass the requests to/from
706 * the underlying controller. The refrigerator handles
707 * most issues; the controller driver handles the rest.
711 /*-------------------------------------------------------------------------*/
713 static int __init
spidev_init(void)
717 /* Claim our 256 reserved device numbers. Then register a class
718 * that will key udev/mdev to add/remove /dev nodes. Last, register
719 * the driver which manages those device numbers.
721 BUILD_BUG_ON(N_SPI_MINORS
> 256);
722 status
= register_chrdev(SPIDEV_MAJOR
, "spi", &spidev_fops
);
726 spidev_class
= class_create(THIS_MODULE
, "spidev");
727 if (IS_ERR(spidev_class
)) {
728 unregister_chrdev(SPIDEV_MAJOR
, spidev_spi_driver
.driver
.name
);
729 return PTR_ERR(spidev_class
);
732 status
= spi_register_driver(&spidev_spi_driver
);
734 class_destroy(spidev_class
);
735 unregister_chrdev(SPIDEV_MAJOR
, spidev_spi_driver
.driver
.name
);
739 module_init(spidev_init
);
741 static void __exit
spidev_exit(void)
743 spi_unregister_driver(&spidev_spi_driver
);
744 class_destroy(spidev_class
);
745 unregister_chrdev(SPIDEV_MAJOR
, spidev_spi_driver
.driver
.name
);
747 module_exit(spidev_exit
);
749 MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
750 MODULE_DESCRIPTION("User mode SPI device interface");
751 MODULE_LICENSE("GPL");
752 MODULE_ALIAS("spi:spidev");