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_RX_DUAL | SPI_RX_QUAD)
70 struct spi_device
*spi
;
71 struct list_head device_entry
;
73 /* TX/RX buffers are NULL unless this device is open (users > 0) */
74 struct mutex buf_lock
;
81 static LIST_HEAD(device_list
);
82 static DEFINE_MUTEX(device_list_lock
);
84 static unsigned bufsiz
= 4096;
85 module_param(bufsiz
, uint
, S_IRUGO
);
86 MODULE_PARM_DESC(bufsiz
, "data bytes in biggest supported SPI message");
88 /*-------------------------------------------------------------------------*/
91 spidev_sync(struct spidev_data
*spidev
, struct spi_message
*message
)
94 struct spi_device
*spi
;
96 spin_lock_irq(&spidev
->spi_lock
);
98 spin_unlock_irq(&spidev
->spi_lock
);
103 status
= spi_sync(spi
, message
);
106 status
= message
->actual_length
;
111 static inline ssize_t
112 spidev_sync_write(struct spidev_data
*spidev
, size_t len
)
114 struct spi_transfer t
= {
115 .tx_buf
= spidev
->tx_buffer
,
117 .speed_hz
= spidev
->speed_hz
,
119 struct spi_message m
;
121 spi_message_init(&m
);
122 spi_message_add_tail(&t
, &m
);
123 return spidev_sync(spidev
, &m
);
126 static inline ssize_t
127 spidev_sync_read(struct spidev_data
*spidev
, size_t len
)
129 struct spi_transfer t
= {
130 .rx_buf
= spidev
->rx_buffer
,
132 .speed_hz
= spidev
->speed_hz
,
134 struct spi_message m
;
136 spi_message_init(&m
);
137 spi_message_add_tail(&t
, &m
);
138 return spidev_sync(spidev
, &m
);
141 /*-------------------------------------------------------------------------*/
143 /* Read-only message with current device setup */
145 spidev_read(struct file
*filp
, char __user
*buf
, size_t count
, loff_t
*f_pos
)
147 struct spidev_data
*spidev
;
150 /* chipselect only toggles at start or end of operation */
154 spidev
= filp
->private_data
;
156 mutex_lock(&spidev
->buf_lock
);
157 status
= spidev_sync_read(spidev
, count
);
159 unsigned long missing
;
161 missing
= copy_to_user(buf
, spidev
->rx_buffer
, status
);
162 if (missing
== status
)
165 status
= status
- missing
;
167 mutex_unlock(&spidev
->buf_lock
);
172 /* Write-only message with current device setup */
174 spidev_write(struct file
*filp
, const char __user
*buf
,
175 size_t count
, loff_t
*f_pos
)
177 struct spidev_data
*spidev
;
179 unsigned long missing
;
181 /* chipselect only toggles at start or end of operation */
185 spidev
= filp
->private_data
;
187 mutex_lock(&spidev
->buf_lock
);
188 missing
= copy_from_user(spidev
->tx_buffer
, buf
, count
);
190 status
= spidev_sync_write(spidev
, count
);
193 mutex_unlock(&spidev
->buf_lock
);
198 static int spidev_message(struct spidev_data
*spidev
,
199 struct spi_ioc_transfer
*u_xfers
, unsigned n_xfers
)
201 struct spi_message msg
;
202 struct spi_transfer
*k_xfers
;
203 struct spi_transfer
*k_tmp
;
204 struct spi_ioc_transfer
*u_tmp
;
205 unsigned n
, total
, tx_total
, rx_total
;
207 int status
= -EFAULT
;
209 spi_message_init(&msg
);
210 k_xfers
= kcalloc(n_xfers
, sizeof(*k_tmp
), GFP_KERNEL
);
214 /* Construct spi_message, copying any tx data to bounce buffer.
215 * We walk the array of user-provided transfers, using each one
216 * to initialize a kernel version of the same transfer.
218 tx_buf
= spidev
->tx_buffer
;
219 rx_buf
= spidev
->rx_buffer
;
223 for (n
= n_xfers
, k_tmp
= k_xfers
, u_tmp
= u_xfers
;
225 n
--, k_tmp
++, u_tmp
++) {
226 k_tmp
->len
= u_tmp
->len
;
229 /* Since the function returns the total length of transfers
230 * on success, restrict the total to positive int values to
231 * avoid the return value looking like an error. Also check
232 * each transfer length to avoid arithmetic overflow.
234 if (total
> INT_MAX
|| k_tmp
->len
> INT_MAX
) {
240 /* this transfer needs space in RX bounce buffer */
241 rx_total
+= k_tmp
->len
;
242 if (rx_total
> bufsiz
) {
246 k_tmp
->rx_buf
= rx_buf
;
247 rx_buf
+= k_tmp
->len
;
250 /* this transfer needs space in TX bounce buffer */
251 tx_total
+= k_tmp
->len
;
252 if (tx_total
> bufsiz
) {
256 k_tmp
->tx_buf
= tx_buf
;
257 if (copy_from_user(tx_buf
, (const u8 __user
*)
258 (uintptr_t) u_tmp
->tx_buf
,
261 tx_buf
+= k_tmp
->len
;
264 k_tmp
->cs_change
= !!u_tmp
->cs_change
;
265 k_tmp
->tx_nbits
= u_tmp
->tx_nbits
;
266 k_tmp
->rx_nbits
= u_tmp
->rx_nbits
;
267 k_tmp
->bits_per_word
= u_tmp
->bits_per_word
;
268 k_tmp
->delay_usecs
= u_tmp
->delay_usecs
;
269 k_tmp
->speed_hz
= u_tmp
->speed_hz
;
270 k_tmp
->word_delay_usecs
= u_tmp
->word_delay_usecs
;
271 if (!k_tmp
->speed_hz
)
272 k_tmp
->speed_hz
= spidev
->speed_hz
;
274 dev_dbg(&spidev
->spi
->dev
,
275 " xfer len %u %s%s%s%dbits %u usec %u usec %uHz\n",
277 u_tmp
->rx_buf
? "rx " : "",
278 u_tmp
->tx_buf
? "tx " : "",
279 u_tmp
->cs_change
? "cs " : "",
280 u_tmp
->bits_per_word
? : spidev
->spi
->bits_per_word
,
282 u_tmp
->word_delay_usecs
,
283 u_tmp
->speed_hz
? : spidev
->spi
->max_speed_hz
);
285 spi_message_add_tail(k_tmp
, &msg
);
288 status
= spidev_sync(spidev
, &msg
);
292 /* copy any rx data out of bounce buffer */
293 rx_buf
= spidev
->rx_buffer
;
294 for (n
= n_xfers
, u_tmp
= u_xfers
; n
; n
--, u_tmp
++) {
296 if (copy_to_user((u8 __user
*)
297 (uintptr_t) u_tmp
->rx_buf
, rx_buf
,
302 rx_buf
+= u_tmp
->len
;
312 static struct spi_ioc_transfer
*
313 spidev_get_ioc_message(unsigned int cmd
, struct spi_ioc_transfer __user
*u_ioc
,
318 /* Check type, command number and direction */
319 if (_IOC_TYPE(cmd
) != SPI_IOC_MAGIC
320 || _IOC_NR(cmd
) != _IOC_NR(SPI_IOC_MESSAGE(0))
321 || _IOC_DIR(cmd
) != _IOC_WRITE
)
322 return ERR_PTR(-ENOTTY
);
324 tmp
= _IOC_SIZE(cmd
);
325 if ((tmp
% sizeof(struct spi_ioc_transfer
)) != 0)
326 return ERR_PTR(-EINVAL
);
327 *n_ioc
= tmp
/ sizeof(struct spi_ioc_transfer
);
331 /* copy into scratch area */
332 return memdup_user(u_ioc
, tmp
);
336 spidev_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
339 struct spidev_data
*spidev
;
340 struct spi_device
*spi
;
343 struct spi_ioc_transfer
*ioc
;
345 /* Check type and command number */
346 if (_IOC_TYPE(cmd
) != SPI_IOC_MAGIC
)
349 /* guard against device removal before, or while,
350 * we issue this ioctl.
352 spidev
= filp
->private_data
;
353 spin_lock_irq(&spidev
->spi_lock
);
354 spi
= spi_dev_get(spidev
->spi
);
355 spin_unlock_irq(&spidev
->spi_lock
);
360 /* use the buffer lock here for triple duty:
361 * - prevent I/O (from us) so calling spi_setup() is safe;
362 * - prevent concurrent SPI_IOC_WR_* from morphing
363 * data fields while SPI_IOC_RD_* reads them;
364 * - SPI_IOC_MESSAGE needs the buffer locked "normally".
366 mutex_lock(&spidev
->buf_lock
);
370 case SPI_IOC_RD_MODE
:
371 retval
= put_user(spi
->mode
& SPI_MODE_MASK
,
374 case SPI_IOC_RD_MODE32
:
375 retval
= put_user(spi
->mode
& SPI_MODE_MASK
,
376 (__u32 __user
*)arg
);
378 case SPI_IOC_RD_LSB_FIRST
:
379 retval
= put_user((spi
->mode
& SPI_LSB_FIRST
) ? 1 : 0,
382 case SPI_IOC_RD_BITS_PER_WORD
:
383 retval
= put_user(spi
->bits_per_word
, (__u8 __user
*)arg
);
385 case SPI_IOC_RD_MAX_SPEED_HZ
:
386 retval
= put_user(spidev
->speed_hz
, (__u32 __user
*)arg
);
390 case SPI_IOC_WR_MODE
:
391 case SPI_IOC_WR_MODE32
:
392 if (cmd
== SPI_IOC_WR_MODE
)
393 retval
= get_user(tmp
, (u8 __user
*)arg
);
395 retval
= get_user(tmp
, (u32 __user
*)arg
);
397 u32 save
= spi
->mode
;
399 if (tmp
& ~SPI_MODE_MASK
) {
404 tmp
|= spi
->mode
& ~SPI_MODE_MASK
;
405 spi
->mode
= (u16
)tmp
;
406 retval
= spi_setup(spi
);
410 dev_dbg(&spi
->dev
, "spi mode %x\n", tmp
);
413 case SPI_IOC_WR_LSB_FIRST
:
414 retval
= get_user(tmp
, (__u8 __user
*)arg
);
416 u32 save
= spi
->mode
;
419 spi
->mode
|= SPI_LSB_FIRST
;
421 spi
->mode
&= ~SPI_LSB_FIRST
;
422 retval
= spi_setup(spi
);
426 dev_dbg(&spi
->dev
, "%csb first\n",
430 case SPI_IOC_WR_BITS_PER_WORD
:
431 retval
= get_user(tmp
, (__u8 __user
*)arg
);
433 u8 save
= spi
->bits_per_word
;
435 spi
->bits_per_word
= tmp
;
436 retval
= spi_setup(spi
);
438 spi
->bits_per_word
= save
;
440 dev_dbg(&spi
->dev
, "%d bits per word\n", tmp
);
443 case SPI_IOC_WR_MAX_SPEED_HZ
:
444 retval
= get_user(tmp
, (__u32 __user
*)arg
);
446 u32 save
= spi
->max_speed_hz
;
448 spi
->max_speed_hz
= tmp
;
449 retval
= spi_setup(spi
);
451 spidev
->speed_hz
= tmp
;
453 dev_dbg(&spi
->dev
, "%d Hz (max)\n", tmp
);
454 spi
->max_speed_hz
= save
;
459 /* segmented and/or full-duplex I/O request */
460 /* Check message and copy into scratch area */
461 ioc
= spidev_get_ioc_message(cmd
,
462 (struct spi_ioc_transfer __user
*)arg
, &n_ioc
);
464 retval
= PTR_ERR(ioc
);
468 break; /* n_ioc is also 0 */
470 /* translate to spi_message, execute */
471 retval
= spidev_message(spidev
, ioc
, n_ioc
);
476 mutex_unlock(&spidev
->buf_lock
);
483 spidev_compat_ioc_message(struct file
*filp
, unsigned int cmd
,
486 struct spi_ioc_transfer __user
*u_ioc
;
488 struct spidev_data
*spidev
;
489 struct spi_device
*spi
;
491 struct spi_ioc_transfer
*ioc
;
493 u_ioc
= (struct spi_ioc_transfer __user
*) compat_ptr(arg
);
495 /* guard against device removal before, or while,
496 * we issue this ioctl.
498 spidev
= filp
->private_data
;
499 spin_lock_irq(&spidev
->spi_lock
);
500 spi
= spi_dev_get(spidev
->spi
);
501 spin_unlock_irq(&spidev
->spi_lock
);
506 /* SPI_IOC_MESSAGE needs the buffer locked "normally" */
507 mutex_lock(&spidev
->buf_lock
);
509 /* Check message and copy into scratch area */
510 ioc
= spidev_get_ioc_message(cmd
, u_ioc
, &n_ioc
);
512 retval
= PTR_ERR(ioc
);
516 goto done
; /* n_ioc is also 0 */
518 /* Convert buffer pointers */
519 for (n
= 0; n
< n_ioc
; n
++) {
520 ioc
[n
].rx_buf
= (uintptr_t) compat_ptr(ioc
[n
].rx_buf
);
521 ioc
[n
].tx_buf
= (uintptr_t) compat_ptr(ioc
[n
].tx_buf
);
524 /* translate to spi_message, execute */
525 retval
= spidev_message(spidev
, ioc
, n_ioc
);
529 mutex_unlock(&spidev
->buf_lock
);
535 spidev_compat_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
537 if (_IOC_TYPE(cmd
) == SPI_IOC_MAGIC
538 && _IOC_NR(cmd
) == _IOC_NR(SPI_IOC_MESSAGE(0))
539 && _IOC_DIR(cmd
) == _IOC_WRITE
)
540 return spidev_compat_ioc_message(filp
, cmd
, arg
);
542 return spidev_ioctl(filp
, cmd
, (unsigned long)compat_ptr(arg
));
545 #define spidev_compat_ioctl NULL
546 #endif /* CONFIG_COMPAT */
548 static int spidev_open(struct inode
*inode
, struct file
*filp
)
550 struct spidev_data
*spidev
;
553 mutex_lock(&device_list_lock
);
555 list_for_each_entry(spidev
, &device_list
, device_entry
) {
556 if (spidev
->devt
== inode
->i_rdev
) {
563 pr_debug("spidev: nothing for minor %d\n", iminor(inode
));
567 if (!spidev
->tx_buffer
) {
568 spidev
->tx_buffer
= kmalloc(bufsiz
, GFP_KERNEL
);
569 if (!spidev
->tx_buffer
) {
570 dev_dbg(&spidev
->spi
->dev
, "open/ENOMEM\n");
576 if (!spidev
->rx_buffer
) {
577 spidev
->rx_buffer
= kmalloc(bufsiz
, GFP_KERNEL
);
578 if (!spidev
->rx_buffer
) {
579 dev_dbg(&spidev
->spi
->dev
, "open/ENOMEM\n");
581 goto err_alloc_rx_buf
;
586 filp
->private_data
= spidev
;
587 stream_open(inode
, filp
);
589 mutex_unlock(&device_list_lock
);
593 kfree(spidev
->tx_buffer
);
594 spidev
->tx_buffer
= NULL
;
596 mutex_unlock(&device_list_lock
);
600 static int spidev_release(struct inode
*inode
, struct file
*filp
)
602 struct spidev_data
*spidev
;
604 mutex_lock(&device_list_lock
);
605 spidev
= filp
->private_data
;
606 filp
->private_data
= NULL
;
610 if (!spidev
->users
) {
613 kfree(spidev
->tx_buffer
);
614 spidev
->tx_buffer
= NULL
;
616 kfree(spidev
->rx_buffer
);
617 spidev
->rx_buffer
= NULL
;
619 spin_lock_irq(&spidev
->spi_lock
);
621 spidev
->speed_hz
= spidev
->spi
->max_speed_hz
;
623 /* ... after we unbound from the underlying device? */
624 dofree
= (spidev
->spi
== NULL
);
625 spin_unlock_irq(&spidev
->spi_lock
);
630 mutex_unlock(&device_list_lock
);
635 static const struct file_operations spidev_fops
= {
636 .owner
= THIS_MODULE
,
637 /* REVISIT switch to aio primitives, so that userspace
638 * gets more complete API coverage. It'll simplify things
639 * too, except for the locking.
641 .write
= spidev_write
,
643 .unlocked_ioctl
= spidev_ioctl
,
644 .compat_ioctl
= spidev_compat_ioctl
,
646 .release
= spidev_release
,
650 /*-------------------------------------------------------------------------*/
652 /* The main reason to have this class is to make mdev/udev create the
653 * /dev/spidevB.C character device nodes exposing our userspace API.
654 * It also simplifies memory management.
657 static struct class *spidev_class
;
660 static const struct of_device_id spidev_dt_ids
[] = {
661 { .compatible
= "rohm,dh2228fv" },
662 { .compatible
= "lineartechnology,ltc2488" },
663 { .compatible
= "ge,achc" },
664 { .compatible
= "semtech,sx1301" },
665 { .compatible
= "lwn,bk4" },
666 { .compatible
= "dh,dhcom-board" },
667 { .compatible
= "menlo,m53cpld" },
670 MODULE_DEVICE_TABLE(of
, spidev_dt_ids
);
675 /* Dummy SPI devices not to be used in production systems */
676 #define SPIDEV_ACPI_DUMMY 1
678 static const struct acpi_device_id spidev_acpi_ids
[] = {
680 * The ACPI SPT000* devices are only meant for development and
681 * testing. Systems used in production should have a proper ACPI
682 * description of the connected peripheral and they should also use
683 * a proper driver instead of poking directly to the SPI bus.
685 { "SPT0001", SPIDEV_ACPI_DUMMY
},
686 { "SPT0002", SPIDEV_ACPI_DUMMY
},
687 { "SPT0003", SPIDEV_ACPI_DUMMY
},
690 MODULE_DEVICE_TABLE(acpi
, spidev_acpi_ids
);
692 static void spidev_probe_acpi(struct spi_device
*spi
)
694 const struct acpi_device_id
*id
;
696 if (!has_acpi_companion(&spi
->dev
))
699 id
= acpi_match_device(spidev_acpi_ids
, &spi
->dev
);
703 if (id
->driver_data
== SPIDEV_ACPI_DUMMY
)
704 dev_warn(&spi
->dev
, "do not use this driver in production systems!\n");
707 static inline void spidev_probe_acpi(struct spi_device
*spi
) {}
710 /*-------------------------------------------------------------------------*/
712 static int spidev_probe(struct spi_device
*spi
)
714 struct spidev_data
*spidev
;
719 * spidev should never be referenced in DT without a specific
720 * compatible string, it is a Linux implementation thing
721 * rather than a description of the hardware.
723 WARN(spi
->dev
.of_node
&&
724 of_device_is_compatible(spi
->dev
.of_node
, "spidev"),
725 "%pOF: buggy DT: spidev listed directly in DT\n", spi
->dev
.of_node
);
727 spidev_probe_acpi(spi
);
729 /* Allocate driver data */
730 spidev
= kzalloc(sizeof(*spidev
), GFP_KERNEL
);
734 /* Initialize the driver data */
736 spin_lock_init(&spidev
->spi_lock
);
737 mutex_init(&spidev
->buf_lock
);
739 INIT_LIST_HEAD(&spidev
->device_entry
);
741 /* If we can allocate a minor number, hook up this device.
742 * Reusing minors is fine so long as udev or mdev is working.
744 mutex_lock(&device_list_lock
);
745 minor
= find_first_zero_bit(minors
, N_SPI_MINORS
);
746 if (minor
< N_SPI_MINORS
) {
749 spidev
->devt
= MKDEV(SPIDEV_MAJOR
, minor
);
750 dev
= device_create(spidev_class
, &spi
->dev
, spidev
->devt
,
751 spidev
, "spidev%d.%d",
752 spi
->master
->bus_num
, spi
->chip_select
);
753 status
= PTR_ERR_OR_ZERO(dev
);
755 dev_dbg(&spi
->dev
, "no minor number available!\n");
759 set_bit(minor
, minors
);
760 list_add(&spidev
->device_entry
, &device_list
);
762 mutex_unlock(&device_list_lock
);
764 spidev
->speed_hz
= spi
->max_speed_hz
;
767 spi_set_drvdata(spi
, spidev
);
774 static int spidev_remove(struct spi_device
*spi
)
776 struct spidev_data
*spidev
= spi_get_drvdata(spi
);
778 /* make sure ops on existing fds can abort cleanly */
779 spin_lock_irq(&spidev
->spi_lock
);
781 spin_unlock_irq(&spidev
->spi_lock
);
783 /* prevent new opens */
784 mutex_lock(&device_list_lock
);
785 list_del(&spidev
->device_entry
);
786 device_destroy(spidev_class
, spidev
->devt
);
787 clear_bit(MINOR(spidev
->devt
), minors
);
788 if (spidev
->users
== 0)
790 mutex_unlock(&device_list_lock
);
795 static struct spi_driver spidev_spi_driver
= {
798 .of_match_table
= of_match_ptr(spidev_dt_ids
),
799 .acpi_match_table
= ACPI_PTR(spidev_acpi_ids
),
801 .probe
= spidev_probe
,
802 .remove
= spidev_remove
,
804 /* NOTE: suspend/resume methods are not necessary here.
805 * We don't do anything except pass the requests to/from
806 * the underlying controller. The refrigerator handles
807 * most issues; the controller driver handles the rest.
811 /*-------------------------------------------------------------------------*/
813 static int __init
spidev_init(void)
817 /* Claim our 256 reserved device numbers. Then register a class
818 * that will key udev/mdev to add/remove /dev nodes. Last, register
819 * the driver which manages those device numbers.
821 BUILD_BUG_ON(N_SPI_MINORS
> 256);
822 status
= register_chrdev(SPIDEV_MAJOR
, "spi", &spidev_fops
);
826 spidev_class
= class_create(THIS_MODULE
, "spidev");
827 if (IS_ERR(spidev_class
)) {
828 unregister_chrdev(SPIDEV_MAJOR
, spidev_spi_driver
.driver
.name
);
829 return PTR_ERR(spidev_class
);
832 status
= spi_register_driver(&spidev_spi_driver
);
834 class_destroy(spidev_class
);
835 unregister_chrdev(SPIDEV_MAJOR
, spidev_spi_driver
.driver
.name
);
839 module_init(spidev_init
);
841 static void __exit
spidev_exit(void)
843 spi_unregister_driver(&spidev_spi_driver
);
844 class_destroy(spidev_class
);
845 unregister_chrdev(SPIDEV_MAJOR
, spidev_spi_driver
.driver
.name
);
847 module_exit(spidev_exit
);
849 MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
850 MODULE_DESCRIPTION("User mode SPI device interface");
851 MODULE_LICENSE("GPL");
852 MODULE_ALIAS("spi:spidev");