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
.value
= u_tmp
->delay_usecs
;
269 k_tmp
->delay
.unit
= SPI_DELAY_UNIT_USECS
;
270 k_tmp
->speed_hz
= u_tmp
->speed_hz
;
271 k_tmp
->word_delay
.value
= u_tmp
->word_delay_usecs
;
272 k_tmp
->word_delay
.unit
= SPI_DELAY_UNIT_USECS
;
273 if (!k_tmp
->speed_hz
)
274 k_tmp
->speed_hz
= spidev
->speed_hz
;
276 dev_dbg(&spidev
->spi
->dev
,
277 " xfer len %u %s%s%s%dbits %u usec %u usec %uHz\n",
279 u_tmp
->rx_buf
? "rx " : "",
280 u_tmp
->tx_buf
? "tx " : "",
281 u_tmp
->cs_change
? "cs " : "",
282 u_tmp
->bits_per_word
? : spidev
->spi
->bits_per_word
,
284 u_tmp
->word_delay_usecs
,
285 u_tmp
->speed_hz
? : spidev
->spi
->max_speed_hz
);
287 spi_message_add_tail(k_tmp
, &msg
);
290 status
= spidev_sync(spidev
, &msg
);
294 /* copy any rx data out of bounce buffer */
295 rx_buf
= spidev
->rx_buffer
;
296 for (n
= n_xfers
, u_tmp
= u_xfers
; n
; n
--, u_tmp
++) {
298 if (copy_to_user((u8 __user
*)
299 (uintptr_t) u_tmp
->rx_buf
, rx_buf
,
304 rx_buf
+= u_tmp
->len
;
314 static struct spi_ioc_transfer
*
315 spidev_get_ioc_message(unsigned int cmd
, struct spi_ioc_transfer __user
*u_ioc
,
320 /* Check type, command number and direction */
321 if (_IOC_TYPE(cmd
) != SPI_IOC_MAGIC
322 || _IOC_NR(cmd
) != _IOC_NR(SPI_IOC_MESSAGE(0))
323 || _IOC_DIR(cmd
) != _IOC_WRITE
)
324 return ERR_PTR(-ENOTTY
);
326 tmp
= _IOC_SIZE(cmd
);
327 if ((tmp
% sizeof(struct spi_ioc_transfer
)) != 0)
328 return ERR_PTR(-EINVAL
);
329 *n_ioc
= tmp
/ sizeof(struct spi_ioc_transfer
);
333 /* copy into scratch area */
334 return memdup_user(u_ioc
, tmp
);
338 spidev_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
341 struct spidev_data
*spidev
;
342 struct spi_device
*spi
;
345 struct spi_ioc_transfer
*ioc
;
347 /* Check type and command number */
348 if (_IOC_TYPE(cmd
) != SPI_IOC_MAGIC
)
351 /* guard against device removal before, or while,
352 * we issue this ioctl.
354 spidev
= filp
->private_data
;
355 spin_lock_irq(&spidev
->spi_lock
);
356 spi
= spi_dev_get(spidev
->spi
);
357 spin_unlock_irq(&spidev
->spi_lock
);
362 /* use the buffer lock here for triple duty:
363 * - prevent I/O (from us) so calling spi_setup() is safe;
364 * - prevent concurrent SPI_IOC_WR_* from morphing
365 * data fields while SPI_IOC_RD_* reads them;
366 * - SPI_IOC_MESSAGE needs the buffer locked "normally".
368 mutex_lock(&spidev
->buf_lock
);
372 case SPI_IOC_RD_MODE
:
373 retval
= put_user(spi
->mode
& SPI_MODE_MASK
,
376 case SPI_IOC_RD_MODE32
:
377 retval
= put_user(spi
->mode
& SPI_MODE_MASK
,
378 (__u32 __user
*)arg
);
380 case SPI_IOC_RD_LSB_FIRST
:
381 retval
= put_user((spi
->mode
& SPI_LSB_FIRST
) ? 1 : 0,
384 case SPI_IOC_RD_BITS_PER_WORD
:
385 retval
= put_user(spi
->bits_per_word
, (__u8 __user
*)arg
);
387 case SPI_IOC_RD_MAX_SPEED_HZ
:
388 retval
= put_user(spidev
->speed_hz
, (__u32 __user
*)arg
);
392 case SPI_IOC_WR_MODE
:
393 case SPI_IOC_WR_MODE32
:
394 if (cmd
== SPI_IOC_WR_MODE
)
395 retval
= get_user(tmp
, (u8 __user
*)arg
);
397 retval
= get_user(tmp
, (u32 __user
*)arg
);
399 struct spi_controller
*ctlr
= spi
->controller
;
400 u32 save
= spi
->mode
;
402 if (tmp
& ~SPI_MODE_MASK
) {
407 if (ctlr
->use_gpio_descriptors
&& ctlr
->cs_gpiods
&&
408 ctlr
->cs_gpiods
[spi
->chip_select
])
411 tmp
|= spi
->mode
& ~SPI_MODE_MASK
;
412 spi
->mode
= (u16
)tmp
;
413 retval
= spi_setup(spi
);
417 dev_dbg(&spi
->dev
, "spi mode %x\n", tmp
);
420 case SPI_IOC_WR_LSB_FIRST
:
421 retval
= get_user(tmp
, (__u8 __user
*)arg
);
423 u32 save
= spi
->mode
;
426 spi
->mode
|= SPI_LSB_FIRST
;
428 spi
->mode
&= ~SPI_LSB_FIRST
;
429 retval
= spi_setup(spi
);
433 dev_dbg(&spi
->dev
, "%csb first\n",
437 case SPI_IOC_WR_BITS_PER_WORD
:
438 retval
= get_user(tmp
, (__u8 __user
*)arg
);
440 u8 save
= spi
->bits_per_word
;
442 spi
->bits_per_word
= tmp
;
443 retval
= spi_setup(spi
);
445 spi
->bits_per_word
= save
;
447 dev_dbg(&spi
->dev
, "%d bits per word\n", tmp
);
450 case SPI_IOC_WR_MAX_SPEED_HZ
:
451 retval
= get_user(tmp
, (__u32 __user
*)arg
);
453 u32 save
= spi
->max_speed_hz
;
455 spi
->max_speed_hz
= tmp
;
456 retval
= spi_setup(spi
);
458 spidev
->speed_hz
= tmp
;
460 dev_dbg(&spi
->dev
, "%d Hz (max)\n", tmp
);
461 spi
->max_speed_hz
= save
;
466 /* segmented and/or full-duplex I/O request */
467 /* Check message and copy into scratch area */
468 ioc
= spidev_get_ioc_message(cmd
,
469 (struct spi_ioc_transfer __user
*)arg
, &n_ioc
);
471 retval
= PTR_ERR(ioc
);
475 break; /* n_ioc is also 0 */
477 /* translate to spi_message, execute */
478 retval
= spidev_message(spidev
, ioc
, n_ioc
);
483 mutex_unlock(&spidev
->buf_lock
);
490 spidev_compat_ioc_message(struct file
*filp
, unsigned int cmd
,
493 struct spi_ioc_transfer __user
*u_ioc
;
495 struct spidev_data
*spidev
;
496 struct spi_device
*spi
;
498 struct spi_ioc_transfer
*ioc
;
500 u_ioc
= (struct spi_ioc_transfer __user
*) compat_ptr(arg
);
502 /* guard against device removal before, or while,
503 * we issue this ioctl.
505 spidev
= filp
->private_data
;
506 spin_lock_irq(&spidev
->spi_lock
);
507 spi
= spi_dev_get(spidev
->spi
);
508 spin_unlock_irq(&spidev
->spi_lock
);
513 /* SPI_IOC_MESSAGE needs the buffer locked "normally" */
514 mutex_lock(&spidev
->buf_lock
);
516 /* Check message and copy into scratch area */
517 ioc
= spidev_get_ioc_message(cmd
, u_ioc
, &n_ioc
);
519 retval
= PTR_ERR(ioc
);
523 goto done
; /* n_ioc is also 0 */
525 /* Convert buffer pointers */
526 for (n
= 0; n
< n_ioc
; n
++) {
527 ioc
[n
].rx_buf
= (uintptr_t) compat_ptr(ioc
[n
].rx_buf
);
528 ioc
[n
].tx_buf
= (uintptr_t) compat_ptr(ioc
[n
].tx_buf
);
531 /* translate to spi_message, execute */
532 retval
= spidev_message(spidev
, ioc
, n_ioc
);
536 mutex_unlock(&spidev
->buf_lock
);
542 spidev_compat_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
544 if (_IOC_TYPE(cmd
) == SPI_IOC_MAGIC
545 && _IOC_NR(cmd
) == _IOC_NR(SPI_IOC_MESSAGE(0))
546 && _IOC_DIR(cmd
) == _IOC_WRITE
)
547 return spidev_compat_ioc_message(filp
, cmd
, arg
);
549 return spidev_ioctl(filp
, cmd
, (unsigned long)compat_ptr(arg
));
552 #define spidev_compat_ioctl NULL
553 #endif /* CONFIG_COMPAT */
555 static int spidev_open(struct inode
*inode
, struct file
*filp
)
557 struct spidev_data
*spidev
;
560 mutex_lock(&device_list_lock
);
562 list_for_each_entry(spidev
, &device_list
, device_entry
) {
563 if (spidev
->devt
== inode
->i_rdev
) {
570 pr_debug("spidev: nothing for minor %d\n", iminor(inode
));
574 if (!spidev
->tx_buffer
) {
575 spidev
->tx_buffer
= kmalloc(bufsiz
, GFP_KERNEL
);
576 if (!spidev
->tx_buffer
) {
577 dev_dbg(&spidev
->spi
->dev
, "open/ENOMEM\n");
583 if (!spidev
->rx_buffer
) {
584 spidev
->rx_buffer
= kmalloc(bufsiz
, GFP_KERNEL
);
585 if (!spidev
->rx_buffer
) {
586 dev_dbg(&spidev
->spi
->dev
, "open/ENOMEM\n");
588 goto err_alloc_rx_buf
;
593 filp
->private_data
= spidev
;
594 stream_open(inode
, filp
);
596 mutex_unlock(&device_list_lock
);
600 kfree(spidev
->tx_buffer
);
601 spidev
->tx_buffer
= NULL
;
603 mutex_unlock(&device_list_lock
);
607 static int spidev_release(struct inode
*inode
, struct file
*filp
)
609 struct spidev_data
*spidev
;
611 mutex_lock(&device_list_lock
);
612 spidev
= filp
->private_data
;
613 filp
->private_data
= NULL
;
617 if (!spidev
->users
) {
620 kfree(spidev
->tx_buffer
);
621 spidev
->tx_buffer
= NULL
;
623 kfree(spidev
->rx_buffer
);
624 spidev
->rx_buffer
= NULL
;
626 spin_lock_irq(&spidev
->spi_lock
);
628 spidev
->speed_hz
= spidev
->spi
->max_speed_hz
;
630 /* ... after we unbound from the underlying device? */
631 dofree
= (spidev
->spi
== NULL
);
632 spin_unlock_irq(&spidev
->spi_lock
);
637 #ifdef CONFIG_SPI_SLAVE
638 spi_slave_abort(spidev
->spi
);
640 mutex_unlock(&device_list_lock
);
645 static const struct file_operations spidev_fops
= {
646 .owner
= THIS_MODULE
,
647 /* REVISIT switch to aio primitives, so that userspace
648 * gets more complete API coverage. It'll simplify things
649 * too, except for the locking.
651 .write
= spidev_write
,
653 .unlocked_ioctl
= spidev_ioctl
,
654 .compat_ioctl
= spidev_compat_ioctl
,
656 .release
= spidev_release
,
660 /*-------------------------------------------------------------------------*/
662 /* The main reason to have this class is to make mdev/udev create the
663 * /dev/spidevB.C character device nodes exposing our userspace API.
664 * It also simplifies memory management.
667 static struct class *spidev_class
;
670 static const struct of_device_id spidev_dt_ids
[] = {
671 { .compatible
= "rohm,dh2228fv" },
672 { .compatible
= "lineartechnology,ltc2488" },
673 { .compatible
= "ge,achc" },
674 { .compatible
= "semtech,sx1301" },
675 { .compatible
= "lwn,bk4" },
676 { .compatible
= "dh,dhcom-board" },
677 { .compatible
= "menlo,m53cpld" },
680 MODULE_DEVICE_TABLE(of
, spidev_dt_ids
);
685 /* Dummy SPI devices not to be used in production systems */
686 #define SPIDEV_ACPI_DUMMY 1
688 static const struct acpi_device_id spidev_acpi_ids
[] = {
690 * The ACPI SPT000* devices are only meant for development and
691 * testing. Systems used in production should have a proper ACPI
692 * description of the connected peripheral and they should also use
693 * a proper driver instead of poking directly to the SPI bus.
695 { "SPT0001", SPIDEV_ACPI_DUMMY
},
696 { "SPT0002", SPIDEV_ACPI_DUMMY
},
697 { "SPT0003", SPIDEV_ACPI_DUMMY
},
700 MODULE_DEVICE_TABLE(acpi
, spidev_acpi_ids
);
702 static void spidev_probe_acpi(struct spi_device
*spi
)
704 const struct acpi_device_id
*id
;
706 if (!has_acpi_companion(&spi
->dev
))
709 id
= acpi_match_device(spidev_acpi_ids
, &spi
->dev
);
713 if (id
->driver_data
== SPIDEV_ACPI_DUMMY
)
714 dev_warn(&spi
->dev
, "do not use this driver in production systems!\n");
717 static inline void spidev_probe_acpi(struct spi_device
*spi
) {}
720 /*-------------------------------------------------------------------------*/
722 static int spidev_probe(struct spi_device
*spi
)
724 struct spidev_data
*spidev
;
729 * spidev should never be referenced in DT without a specific
730 * compatible string, it is a Linux implementation thing
731 * rather than a description of the hardware.
733 WARN(spi
->dev
.of_node
&&
734 of_device_is_compatible(spi
->dev
.of_node
, "spidev"),
735 "%pOF: buggy DT: spidev listed directly in DT\n", spi
->dev
.of_node
);
737 spidev_probe_acpi(spi
);
739 /* Allocate driver data */
740 spidev
= kzalloc(sizeof(*spidev
), GFP_KERNEL
);
744 /* Initialize the driver data */
746 spin_lock_init(&spidev
->spi_lock
);
747 mutex_init(&spidev
->buf_lock
);
749 INIT_LIST_HEAD(&spidev
->device_entry
);
751 /* If we can allocate a minor number, hook up this device.
752 * Reusing minors is fine so long as udev or mdev is working.
754 mutex_lock(&device_list_lock
);
755 minor
= find_first_zero_bit(minors
, N_SPI_MINORS
);
756 if (minor
< N_SPI_MINORS
) {
759 spidev
->devt
= MKDEV(SPIDEV_MAJOR
, minor
);
760 dev
= device_create(spidev_class
, &spi
->dev
, spidev
->devt
,
761 spidev
, "spidev%d.%d",
762 spi
->master
->bus_num
, spi
->chip_select
);
763 status
= PTR_ERR_OR_ZERO(dev
);
765 dev_dbg(&spi
->dev
, "no minor number available!\n");
769 set_bit(minor
, minors
);
770 list_add(&spidev
->device_entry
, &device_list
);
772 mutex_unlock(&device_list_lock
);
774 spidev
->speed_hz
= spi
->max_speed_hz
;
777 spi_set_drvdata(spi
, spidev
);
784 static int spidev_remove(struct spi_device
*spi
)
786 struct spidev_data
*spidev
= spi_get_drvdata(spi
);
788 /* make sure ops on existing fds can abort cleanly */
789 spin_lock_irq(&spidev
->spi_lock
);
791 spin_unlock_irq(&spidev
->spi_lock
);
793 /* prevent new opens */
794 mutex_lock(&device_list_lock
);
795 list_del(&spidev
->device_entry
);
796 device_destroy(spidev_class
, spidev
->devt
);
797 clear_bit(MINOR(spidev
->devt
), minors
);
798 if (spidev
->users
== 0)
800 mutex_unlock(&device_list_lock
);
805 static struct spi_driver spidev_spi_driver
= {
808 .of_match_table
= of_match_ptr(spidev_dt_ids
),
809 .acpi_match_table
= ACPI_PTR(spidev_acpi_ids
),
811 .probe
= spidev_probe
,
812 .remove
= spidev_remove
,
814 /* NOTE: suspend/resume methods are not necessary here.
815 * We don't do anything except pass the requests to/from
816 * the underlying controller. The refrigerator handles
817 * most issues; the controller driver handles the rest.
821 /*-------------------------------------------------------------------------*/
823 static int __init
spidev_init(void)
827 /* Claim our 256 reserved device numbers. Then register a class
828 * that will key udev/mdev to add/remove /dev nodes. Last, register
829 * the driver which manages those device numbers.
831 BUILD_BUG_ON(N_SPI_MINORS
> 256);
832 status
= register_chrdev(SPIDEV_MAJOR
, "spi", &spidev_fops
);
836 spidev_class
= class_create(THIS_MODULE
, "spidev");
837 if (IS_ERR(spidev_class
)) {
838 unregister_chrdev(SPIDEV_MAJOR
, spidev_spi_driver
.driver
.name
);
839 return PTR_ERR(spidev_class
);
842 status
= spi_register_driver(&spidev_spi_driver
);
844 class_destroy(spidev_class
);
845 unregister_chrdev(SPIDEV_MAJOR
, spidev_spi_driver
.driver
.name
);
849 module_init(spidev_init
);
851 static void __exit
spidev_exit(void)
853 spi_unregister_driver(&spidev_spi_driver
);
854 class_destroy(spidev_class
);
855 unregister_chrdev(SPIDEV_MAJOR
, spidev_spi_driver
.driver
.name
);
857 module_exit(spidev_exit
);
859 MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
860 MODULE_DESCRIPTION("User mode SPI device interface");
861 MODULE_LICENSE("GPL");
862 MODULE_ALIAS("spi:spidev");