1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Simple synchronous userspace interface to SPI devices
5 * Copyright (C) 2006 SWAPP
6 * Andrea Paterniani <a.paterniani@swapp-eng.it>
7 * Copyright (C) 2007 David Brownell (simplification, cleanup)
10 #include <linux/init.h>
11 #include <linux/module.h>
12 #include <linux/ioctl.h>
14 #include <linux/device.h>
15 #include <linux/err.h>
16 #include <linux/list.h>
17 #include <linux/errno.h>
18 #include <linux/mutex.h>
19 #include <linux/slab.h>
20 #include <linux/compat.h>
22 #include <linux/of_device.h>
23 #include <linux/acpi.h>
25 #include <linux/spi/spi.h>
26 #include <linux/spi/spidev.h>
28 #include <linux/uaccess.h>
32 * This supports access to SPI devices using normal userspace I/O calls.
33 * Note that while traditional UNIX/POSIX I/O semantics are half duplex,
34 * and often mask message boundaries, full SPI support requires full duplex
35 * transfers. There are several kinds of internal message boundaries to
36 * handle chipselect management and other protocol options.
38 * SPI has a character major number assigned. We allocate minor numbers
39 * dynamically using a bitmask. You must use hotplug tools, such as udev
40 * (or mdev with busybox) to create and destroy the /dev/spidevB.C device
41 * nodes, since there is no fixed association of minor numbers with any
42 * particular SPI bus or device.
44 #define SPIDEV_MAJOR 153 /* assigned */
45 #define N_SPI_MINORS 32 /* ... up to 256 */
47 static DECLARE_BITMAP(minors
, N_SPI_MINORS
);
50 /* Bit masks for spi_device.mode management. Note that incorrect
51 * settings for some settings can cause *lots* of trouble for other
52 * devices on a shared bus:
54 * - CS_HIGH ... this device will be active when it shouldn't be
55 * - 3WIRE ... when active, it won't behave as it should
56 * - NO_CS ... there will be no explicit message boundaries; this
57 * is completely incompatible with the shared bus model
58 * - READY ... transfers may proceed when they shouldn't.
60 * REVISIT should changing those flags be privileged?
62 #define SPI_MODE_MASK (SPI_CPHA | SPI_CPOL | SPI_CS_HIGH \
63 | SPI_LSB_FIRST | SPI_3WIRE | SPI_LOOP \
64 | SPI_NO_CS | SPI_READY | SPI_TX_DUAL \
65 | SPI_TX_QUAD | SPI_TX_OCTAL | SPI_RX_DUAL \
66 | SPI_RX_QUAD | SPI_RX_OCTAL)
71 struct spi_device
*spi
;
72 struct list_head device_entry
;
74 /* TX/RX buffers are NULL unless this device is open (users > 0) */
75 struct mutex buf_lock
;
82 static LIST_HEAD(device_list
);
83 static DEFINE_MUTEX(device_list_lock
);
85 static unsigned bufsiz
= 4096;
86 module_param(bufsiz
, uint
, S_IRUGO
);
87 MODULE_PARM_DESC(bufsiz
, "data bytes in biggest supported SPI message");
89 /*-------------------------------------------------------------------------*/
92 spidev_sync(struct spidev_data
*spidev
, struct spi_message
*message
)
95 struct spi_device
*spi
;
97 spin_lock_irq(&spidev
->spi_lock
);
99 spin_unlock_irq(&spidev
->spi_lock
);
104 status
= spi_sync(spi
, message
);
107 status
= message
->actual_length
;
112 static inline ssize_t
113 spidev_sync_write(struct spidev_data
*spidev
, size_t len
)
115 struct spi_transfer t
= {
116 .tx_buf
= spidev
->tx_buffer
,
118 .speed_hz
= spidev
->speed_hz
,
120 struct spi_message m
;
122 spi_message_init(&m
);
123 spi_message_add_tail(&t
, &m
);
124 return spidev_sync(spidev
, &m
);
127 static inline ssize_t
128 spidev_sync_read(struct spidev_data
*spidev
, size_t len
)
130 struct spi_transfer t
= {
131 .rx_buf
= spidev
->rx_buffer
,
133 .speed_hz
= spidev
->speed_hz
,
135 struct spi_message m
;
137 spi_message_init(&m
);
138 spi_message_add_tail(&t
, &m
);
139 return spidev_sync(spidev
, &m
);
142 /*-------------------------------------------------------------------------*/
144 /* Read-only message with current device setup */
146 spidev_read(struct file
*filp
, char __user
*buf
, size_t count
, loff_t
*f_pos
)
148 struct spidev_data
*spidev
;
151 /* chipselect only toggles at start or end of operation */
155 spidev
= filp
->private_data
;
157 mutex_lock(&spidev
->buf_lock
);
158 status
= spidev_sync_read(spidev
, count
);
160 unsigned long missing
;
162 missing
= copy_to_user(buf
, spidev
->rx_buffer
, status
);
163 if (missing
== status
)
166 status
= status
- missing
;
168 mutex_unlock(&spidev
->buf_lock
);
173 /* Write-only message with current device setup */
175 spidev_write(struct file
*filp
, const char __user
*buf
,
176 size_t count
, loff_t
*f_pos
)
178 struct spidev_data
*spidev
;
180 unsigned long missing
;
182 /* chipselect only toggles at start or end of operation */
186 spidev
= filp
->private_data
;
188 mutex_lock(&spidev
->buf_lock
);
189 missing
= copy_from_user(spidev
->tx_buffer
, buf
, count
);
191 status
= spidev_sync_write(spidev
, count
);
194 mutex_unlock(&spidev
->buf_lock
);
199 static int spidev_message(struct spidev_data
*spidev
,
200 struct spi_ioc_transfer
*u_xfers
, unsigned n_xfers
)
202 struct spi_message msg
;
203 struct spi_transfer
*k_xfers
;
204 struct spi_transfer
*k_tmp
;
205 struct spi_ioc_transfer
*u_tmp
;
206 unsigned n
, total
, tx_total
, rx_total
;
208 int status
= -EFAULT
;
210 spi_message_init(&msg
);
211 k_xfers
= kcalloc(n_xfers
, sizeof(*k_tmp
), GFP_KERNEL
);
215 /* Construct spi_message, copying any tx data to bounce buffer.
216 * We walk the array of user-provided transfers, using each one
217 * to initialize a kernel version of the same transfer.
219 tx_buf
= spidev
->tx_buffer
;
220 rx_buf
= spidev
->rx_buffer
;
224 for (n
= n_xfers
, k_tmp
= k_xfers
, u_tmp
= u_xfers
;
226 n
--, k_tmp
++, u_tmp
++) {
227 /* Ensure that also following allocations from rx_buf/tx_buf will meet
228 * DMA alignment requirements.
230 unsigned int len_aligned
= ALIGN(u_tmp
->len
, ARCH_KMALLOC_MINALIGN
);
232 k_tmp
->len
= u_tmp
->len
;
235 /* Since the function returns the total length of transfers
236 * on success, restrict the total to positive int values to
237 * avoid the return value looking like an error. Also check
238 * each transfer length to avoid arithmetic overflow.
240 if (total
> INT_MAX
|| k_tmp
->len
> INT_MAX
) {
246 /* this transfer needs space in RX bounce buffer */
247 rx_total
+= len_aligned
;
248 if (rx_total
> bufsiz
) {
252 k_tmp
->rx_buf
= rx_buf
;
253 rx_buf
+= len_aligned
;
256 /* this transfer needs space in TX bounce buffer */
257 tx_total
+= len_aligned
;
258 if (tx_total
> bufsiz
) {
262 k_tmp
->tx_buf
= tx_buf
;
263 if (copy_from_user(tx_buf
, (const u8 __user
*)
264 (uintptr_t) u_tmp
->tx_buf
,
267 tx_buf
+= len_aligned
;
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
.value
= u_tmp
->delay_usecs
;
275 k_tmp
->delay
.unit
= SPI_DELAY_UNIT_USECS
;
276 k_tmp
->speed_hz
= u_tmp
->speed_hz
;
277 k_tmp
->word_delay
.value
= u_tmp
->word_delay_usecs
;
278 k_tmp
->word_delay
.unit
= SPI_DELAY_UNIT_USECS
;
279 if (!k_tmp
->speed_hz
)
280 k_tmp
->speed_hz
= spidev
->speed_hz
;
282 dev_dbg(&spidev
->spi
->dev
,
283 " xfer len %u %s%s%s%dbits %u usec %u usec %uHz\n",
285 k_tmp
->rx_buf
? "rx " : "",
286 k_tmp
->tx_buf
? "tx " : "",
287 k_tmp
->cs_change
? "cs " : "",
288 k_tmp
->bits_per_word
? : spidev
->spi
->bits_per_word
,
290 k_tmp
->word_delay
.value
,
291 k_tmp
->speed_hz
? : spidev
->spi
->max_speed_hz
);
293 spi_message_add_tail(k_tmp
, &msg
);
296 status
= spidev_sync(spidev
, &msg
);
300 /* copy any rx data out of bounce buffer */
301 for (n
= n_xfers
, k_tmp
= k_xfers
, u_tmp
= u_xfers
;
303 n
--, k_tmp
++, u_tmp
++) {
305 if (copy_to_user((u8 __user
*)
306 (uintptr_t) u_tmp
->rx_buf
, k_tmp
->rx_buf
,
320 static struct spi_ioc_transfer
*
321 spidev_get_ioc_message(unsigned int cmd
, struct spi_ioc_transfer __user
*u_ioc
,
326 /* Check type, command number and direction */
327 if (_IOC_TYPE(cmd
) != SPI_IOC_MAGIC
328 || _IOC_NR(cmd
) != _IOC_NR(SPI_IOC_MESSAGE(0))
329 || _IOC_DIR(cmd
) != _IOC_WRITE
)
330 return ERR_PTR(-ENOTTY
);
332 tmp
= _IOC_SIZE(cmd
);
333 if ((tmp
% sizeof(struct spi_ioc_transfer
)) != 0)
334 return ERR_PTR(-EINVAL
);
335 *n_ioc
= tmp
/ sizeof(struct spi_ioc_transfer
);
339 /* copy into scratch area */
340 return memdup_user(u_ioc
, tmp
);
344 spidev_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
347 struct spidev_data
*spidev
;
348 struct spi_device
*spi
;
351 struct spi_ioc_transfer
*ioc
;
353 /* Check type and command number */
354 if (_IOC_TYPE(cmd
) != SPI_IOC_MAGIC
)
357 /* guard against device removal before, or while,
358 * we issue this ioctl.
360 spidev
= filp
->private_data
;
361 spin_lock_irq(&spidev
->spi_lock
);
362 spi
= spi_dev_get(spidev
->spi
);
363 spin_unlock_irq(&spidev
->spi_lock
);
368 /* use the buffer lock here for triple duty:
369 * - prevent I/O (from us) so calling spi_setup() is safe;
370 * - prevent concurrent SPI_IOC_WR_* from morphing
371 * data fields while SPI_IOC_RD_* reads them;
372 * - SPI_IOC_MESSAGE needs the buffer locked "normally".
374 mutex_lock(&spidev
->buf_lock
);
378 case SPI_IOC_RD_MODE
:
379 retval
= put_user(spi
->mode
& SPI_MODE_MASK
,
382 case SPI_IOC_RD_MODE32
:
383 retval
= put_user(spi
->mode
& SPI_MODE_MASK
,
384 (__u32 __user
*)arg
);
386 case SPI_IOC_RD_LSB_FIRST
:
387 retval
= put_user((spi
->mode
& SPI_LSB_FIRST
) ? 1 : 0,
390 case SPI_IOC_RD_BITS_PER_WORD
:
391 retval
= put_user(spi
->bits_per_word
, (__u8 __user
*)arg
);
393 case SPI_IOC_RD_MAX_SPEED_HZ
:
394 retval
= put_user(spidev
->speed_hz
, (__u32 __user
*)arg
);
398 case SPI_IOC_WR_MODE
:
399 case SPI_IOC_WR_MODE32
:
400 if (cmd
== SPI_IOC_WR_MODE
)
401 retval
= get_user(tmp
, (u8 __user
*)arg
);
403 retval
= get_user(tmp
, (u32 __user
*)arg
);
405 struct spi_controller
*ctlr
= spi
->controller
;
406 u32 save
= spi
->mode
;
408 if (tmp
& ~SPI_MODE_MASK
) {
413 if (ctlr
->use_gpio_descriptors
&& ctlr
->cs_gpiods
&&
414 ctlr
->cs_gpiods
[spi
->chip_select
])
417 tmp
|= spi
->mode
& ~SPI_MODE_MASK
;
418 spi
->mode
= (u16
)tmp
;
419 retval
= spi_setup(spi
);
423 dev_dbg(&spi
->dev
, "spi mode %x\n", tmp
);
426 case SPI_IOC_WR_LSB_FIRST
:
427 retval
= get_user(tmp
, (__u8 __user
*)arg
);
429 u32 save
= spi
->mode
;
432 spi
->mode
|= SPI_LSB_FIRST
;
434 spi
->mode
&= ~SPI_LSB_FIRST
;
435 retval
= spi_setup(spi
);
439 dev_dbg(&spi
->dev
, "%csb first\n",
443 case SPI_IOC_WR_BITS_PER_WORD
:
444 retval
= get_user(tmp
, (__u8 __user
*)arg
);
446 u8 save
= spi
->bits_per_word
;
448 spi
->bits_per_word
= tmp
;
449 retval
= spi_setup(spi
);
451 spi
->bits_per_word
= save
;
453 dev_dbg(&spi
->dev
, "%d bits per word\n", tmp
);
456 case SPI_IOC_WR_MAX_SPEED_HZ
:
457 retval
= get_user(tmp
, (__u32 __user
*)arg
);
459 u32 save
= spi
->max_speed_hz
;
461 spi
->max_speed_hz
= tmp
;
462 retval
= spi_setup(spi
);
464 spidev
->speed_hz
= tmp
;
465 dev_dbg(&spi
->dev
, "%d Hz (max)\n",
468 spi
->max_speed_hz
= save
;
473 /* segmented and/or full-duplex I/O request */
474 /* Check message and copy into scratch area */
475 ioc
= spidev_get_ioc_message(cmd
,
476 (struct spi_ioc_transfer __user
*)arg
, &n_ioc
);
478 retval
= PTR_ERR(ioc
);
482 break; /* n_ioc is also 0 */
484 /* translate to spi_message, execute */
485 retval
= spidev_message(spidev
, ioc
, n_ioc
);
490 mutex_unlock(&spidev
->buf_lock
);
497 spidev_compat_ioc_message(struct file
*filp
, unsigned int cmd
,
500 struct spi_ioc_transfer __user
*u_ioc
;
502 struct spidev_data
*spidev
;
503 struct spi_device
*spi
;
505 struct spi_ioc_transfer
*ioc
;
507 u_ioc
= (struct spi_ioc_transfer __user
*) compat_ptr(arg
);
509 /* guard against device removal before, or while,
510 * we issue this ioctl.
512 spidev
= filp
->private_data
;
513 spin_lock_irq(&spidev
->spi_lock
);
514 spi
= spi_dev_get(spidev
->spi
);
515 spin_unlock_irq(&spidev
->spi_lock
);
520 /* SPI_IOC_MESSAGE needs the buffer locked "normally" */
521 mutex_lock(&spidev
->buf_lock
);
523 /* Check message and copy into scratch area */
524 ioc
= spidev_get_ioc_message(cmd
, u_ioc
, &n_ioc
);
526 retval
= PTR_ERR(ioc
);
530 goto done
; /* n_ioc is also 0 */
532 /* Convert buffer pointers */
533 for (n
= 0; n
< n_ioc
; n
++) {
534 ioc
[n
].rx_buf
= (uintptr_t) compat_ptr(ioc
[n
].rx_buf
);
535 ioc
[n
].tx_buf
= (uintptr_t) compat_ptr(ioc
[n
].tx_buf
);
538 /* translate to spi_message, execute */
539 retval
= spidev_message(spidev
, ioc
, n_ioc
);
543 mutex_unlock(&spidev
->buf_lock
);
549 spidev_compat_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
551 if (_IOC_TYPE(cmd
) == SPI_IOC_MAGIC
552 && _IOC_NR(cmd
) == _IOC_NR(SPI_IOC_MESSAGE(0))
553 && _IOC_DIR(cmd
) == _IOC_WRITE
)
554 return spidev_compat_ioc_message(filp
, cmd
, arg
);
556 return spidev_ioctl(filp
, cmd
, (unsigned long)compat_ptr(arg
));
559 #define spidev_compat_ioctl NULL
560 #endif /* CONFIG_COMPAT */
562 static int spidev_open(struct inode
*inode
, struct file
*filp
)
564 struct spidev_data
*spidev
;
567 mutex_lock(&device_list_lock
);
569 list_for_each_entry(spidev
, &device_list
, device_entry
) {
570 if (spidev
->devt
== inode
->i_rdev
) {
577 pr_debug("spidev: nothing for minor %d\n", iminor(inode
));
581 if (!spidev
->tx_buffer
) {
582 spidev
->tx_buffer
= kmalloc(bufsiz
, GFP_KERNEL
);
583 if (!spidev
->tx_buffer
) {
584 dev_dbg(&spidev
->spi
->dev
, "open/ENOMEM\n");
590 if (!spidev
->rx_buffer
) {
591 spidev
->rx_buffer
= kmalloc(bufsiz
, GFP_KERNEL
);
592 if (!spidev
->rx_buffer
) {
593 dev_dbg(&spidev
->spi
->dev
, "open/ENOMEM\n");
595 goto err_alloc_rx_buf
;
600 filp
->private_data
= spidev
;
601 stream_open(inode
, filp
);
603 mutex_unlock(&device_list_lock
);
607 kfree(spidev
->tx_buffer
);
608 spidev
->tx_buffer
= NULL
;
610 mutex_unlock(&device_list_lock
);
614 static int spidev_release(struct inode
*inode
, struct file
*filp
)
616 struct spidev_data
*spidev
;
619 mutex_lock(&device_list_lock
);
620 spidev
= filp
->private_data
;
621 filp
->private_data
= NULL
;
623 spin_lock_irq(&spidev
->spi_lock
);
624 /* ... after we unbound from the underlying device? */
625 dofree
= (spidev
->spi
== NULL
);
626 spin_unlock_irq(&spidev
->spi_lock
);
630 if (!spidev
->users
) {
632 kfree(spidev
->tx_buffer
);
633 spidev
->tx_buffer
= NULL
;
635 kfree(spidev
->rx_buffer
);
636 spidev
->rx_buffer
= NULL
;
641 spidev
->speed_hz
= spidev
->spi
->max_speed_hz
;
643 #ifdef CONFIG_SPI_SLAVE
645 spi_slave_abort(spidev
->spi
);
647 mutex_unlock(&device_list_lock
);
652 static const struct file_operations spidev_fops
= {
653 .owner
= THIS_MODULE
,
654 /* REVISIT switch to aio primitives, so that userspace
655 * gets more complete API coverage. It'll simplify things
656 * too, except for the locking.
658 .write
= spidev_write
,
660 .unlocked_ioctl
= spidev_ioctl
,
661 .compat_ioctl
= spidev_compat_ioctl
,
663 .release
= spidev_release
,
667 /*-------------------------------------------------------------------------*/
669 /* The main reason to have this class is to make mdev/udev create the
670 * /dev/spidevB.C character device nodes exposing our userspace API.
671 * It also simplifies memory management.
674 static struct class *spidev_class
;
677 static const struct of_device_id spidev_dt_ids
[] = {
678 { .compatible
= "rohm,dh2228fv" },
679 { .compatible
= "lineartechnology,ltc2488" },
680 { .compatible
= "ge,achc" },
681 { .compatible
= "semtech,sx1301" },
682 { .compatible
= "lwn,bk4" },
683 { .compatible
= "dh,dhcom-board" },
684 { .compatible
= "menlo,m53cpld" },
687 MODULE_DEVICE_TABLE(of
, spidev_dt_ids
);
692 /* Dummy SPI devices not to be used in production systems */
693 #define SPIDEV_ACPI_DUMMY 1
695 static const struct acpi_device_id spidev_acpi_ids
[] = {
697 * The ACPI SPT000* devices are only meant for development and
698 * testing. Systems used in production should have a proper ACPI
699 * description of the connected peripheral and they should also use
700 * a proper driver instead of poking directly to the SPI bus.
702 { "SPT0001", SPIDEV_ACPI_DUMMY
},
703 { "SPT0002", SPIDEV_ACPI_DUMMY
},
704 { "SPT0003", SPIDEV_ACPI_DUMMY
},
707 MODULE_DEVICE_TABLE(acpi
, spidev_acpi_ids
);
709 static void spidev_probe_acpi(struct spi_device
*spi
)
711 const struct acpi_device_id
*id
;
713 if (!has_acpi_companion(&spi
->dev
))
716 id
= acpi_match_device(spidev_acpi_ids
, &spi
->dev
);
720 if (id
->driver_data
== SPIDEV_ACPI_DUMMY
)
721 dev_warn(&spi
->dev
, "do not use this driver in production systems!\n");
724 static inline void spidev_probe_acpi(struct spi_device
*spi
) {}
727 /*-------------------------------------------------------------------------*/
729 static int spidev_probe(struct spi_device
*spi
)
731 struct spidev_data
*spidev
;
736 * spidev should never be referenced in DT without a specific
737 * compatible string, it is a Linux implementation thing
738 * rather than a description of the hardware.
740 WARN(spi
->dev
.of_node
&&
741 of_device_is_compatible(spi
->dev
.of_node
, "spidev"),
742 "%pOF: buggy DT: spidev listed directly in DT\n", spi
->dev
.of_node
);
744 spidev_probe_acpi(spi
);
746 /* Allocate driver data */
747 spidev
= kzalloc(sizeof(*spidev
), GFP_KERNEL
);
751 /* Initialize the driver data */
753 spin_lock_init(&spidev
->spi_lock
);
754 mutex_init(&spidev
->buf_lock
);
756 INIT_LIST_HEAD(&spidev
->device_entry
);
758 /* If we can allocate a minor number, hook up this device.
759 * Reusing minors is fine so long as udev or mdev is working.
761 mutex_lock(&device_list_lock
);
762 minor
= find_first_zero_bit(minors
, N_SPI_MINORS
);
763 if (minor
< N_SPI_MINORS
) {
766 spidev
->devt
= MKDEV(SPIDEV_MAJOR
, minor
);
767 dev
= device_create(spidev_class
, &spi
->dev
, spidev
->devt
,
768 spidev
, "spidev%d.%d",
769 spi
->master
->bus_num
, spi
->chip_select
);
770 status
= PTR_ERR_OR_ZERO(dev
);
772 dev_dbg(&spi
->dev
, "no minor number available!\n");
776 set_bit(minor
, minors
);
777 list_add(&spidev
->device_entry
, &device_list
);
779 mutex_unlock(&device_list_lock
);
781 spidev
->speed_hz
= spi
->max_speed_hz
;
784 spi_set_drvdata(spi
, spidev
);
791 static int spidev_remove(struct spi_device
*spi
)
793 struct spidev_data
*spidev
= spi_get_drvdata(spi
);
795 /* prevent new opens */
796 mutex_lock(&device_list_lock
);
797 /* make sure ops on existing fds can abort cleanly */
798 spin_lock_irq(&spidev
->spi_lock
);
800 spin_unlock_irq(&spidev
->spi_lock
);
802 list_del(&spidev
->device_entry
);
803 device_destroy(spidev_class
, spidev
->devt
);
804 clear_bit(MINOR(spidev
->devt
), minors
);
805 if (spidev
->users
== 0)
807 mutex_unlock(&device_list_lock
);
812 static struct spi_driver spidev_spi_driver
= {
815 .of_match_table
= of_match_ptr(spidev_dt_ids
),
816 .acpi_match_table
= ACPI_PTR(spidev_acpi_ids
),
818 .probe
= spidev_probe
,
819 .remove
= spidev_remove
,
821 /* NOTE: suspend/resume methods are not necessary here.
822 * We don't do anything except pass the requests to/from
823 * the underlying controller. The refrigerator handles
824 * most issues; the controller driver handles the rest.
828 /*-------------------------------------------------------------------------*/
830 static int __init
spidev_init(void)
834 /* Claim our 256 reserved device numbers. Then register a class
835 * that will key udev/mdev to add/remove /dev nodes. Last, register
836 * the driver which manages those device numbers.
838 BUILD_BUG_ON(N_SPI_MINORS
> 256);
839 status
= register_chrdev(SPIDEV_MAJOR
, "spi", &spidev_fops
);
843 spidev_class
= class_create(THIS_MODULE
, "spidev");
844 if (IS_ERR(spidev_class
)) {
845 unregister_chrdev(SPIDEV_MAJOR
, spidev_spi_driver
.driver
.name
);
846 return PTR_ERR(spidev_class
);
849 status
= spi_register_driver(&spidev_spi_driver
);
851 class_destroy(spidev_class
);
852 unregister_chrdev(SPIDEV_MAJOR
, spidev_spi_driver
.driver
.name
);
856 module_init(spidev_init
);
858 static void __exit
spidev_exit(void)
860 spi_unregister_driver(&spidev_spi_driver
);
861 class_destroy(spidev_class
);
862 unregister_chrdev(SPIDEV_MAJOR
, spidev_spi_driver
.driver
.name
);
864 module_exit(spidev_exit
);
866 MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
867 MODULE_DESCRIPTION("User mode SPI device interface");
868 MODULE_LICENSE("GPL");
869 MODULE_ALIAS("spi:spidev");