This source file includes following definitions.
- spidev_sync
- spidev_sync_write
- spidev_sync_read
- spidev_read
- spidev_write
- spidev_message
- spidev_get_ioc_message
- spidev_ioctl
- spidev_compat_ioc_message
- spidev_compat_ioctl
- spidev_open
- spidev_release
- spidev_probe_acpi
- spidev_probe_acpi
- spidev_probe
- spidev_remove
- spidev_init
- spidev_exit
1
2
3
4
5
6
7
8
9
10 #include <linux/init.h>
11 #include <linux/module.h>
12 #include <linux/ioctl.h>
13 #include <linux/fs.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>
21 #include <linux/of.h>
22 #include <linux/of_device.h>
23 #include <linux/acpi.h>
24
25 #include <linux/spi/spi.h>
26 #include <linux/spi/spidev.h>
27
28 #include <linux/uaccess.h>
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44 #define SPIDEV_MAJOR 153
45 #define N_SPI_MINORS 32
46
47 static DECLARE_BITMAP(minors, N_SPI_MINORS);
48
49
50
51
52
53
54
55
56
57
58
59
60
61
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)
66
67 struct spidev_data {
68 dev_t devt;
69 spinlock_t spi_lock;
70 struct spi_device *spi;
71 struct list_head device_entry;
72
73
74 struct mutex buf_lock;
75 unsigned users;
76 u8 *tx_buffer;
77 u8 *rx_buffer;
78 u32 speed_hz;
79 };
80
81 static LIST_HEAD(device_list);
82 static DEFINE_MUTEX(device_list_lock);
83
84 static unsigned bufsiz = 4096;
85 module_param(bufsiz, uint, S_IRUGO);
86 MODULE_PARM_DESC(bufsiz, "data bytes in biggest supported SPI message");
87
88
89
90 static ssize_t
91 spidev_sync(struct spidev_data *spidev, struct spi_message *message)
92 {
93 int status;
94 struct spi_device *spi;
95
96 spin_lock_irq(&spidev->spi_lock);
97 spi = spidev->spi;
98 spin_unlock_irq(&spidev->spi_lock);
99
100 if (spi == NULL)
101 status = -ESHUTDOWN;
102 else
103 status = spi_sync(spi, message);
104
105 if (status == 0)
106 status = message->actual_length;
107
108 return status;
109 }
110
111 static inline ssize_t
112 spidev_sync_write(struct spidev_data *spidev, size_t len)
113 {
114 struct spi_transfer t = {
115 .tx_buf = spidev->tx_buffer,
116 .len = len,
117 .speed_hz = spidev->speed_hz,
118 };
119 struct spi_message m;
120
121 spi_message_init(&m);
122 spi_message_add_tail(&t, &m);
123 return spidev_sync(spidev, &m);
124 }
125
126 static inline ssize_t
127 spidev_sync_read(struct spidev_data *spidev, size_t len)
128 {
129 struct spi_transfer t = {
130 .rx_buf = spidev->rx_buffer,
131 .len = len,
132 .speed_hz = spidev->speed_hz,
133 };
134 struct spi_message m;
135
136 spi_message_init(&m);
137 spi_message_add_tail(&t, &m);
138 return spidev_sync(spidev, &m);
139 }
140
141
142
143
144 static ssize_t
145 spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
146 {
147 struct spidev_data *spidev;
148 ssize_t status = 0;
149
150
151 if (count > bufsiz)
152 return -EMSGSIZE;
153
154 spidev = filp->private_data;
155
156 mutex_lock(&spidev->buf_lock);
157 status = spidev_sync_read(spidev, count);
158 if (status > 0) {
159 unsigned long missing;
160
161 missing = copy_to_user(buf, spidev->rx_buffer, status);
162 if (missing == status)
163 status = -EFAULT;
164 else
165 status = status - missing;
166 }
167 mutex_unlock(&spidev->buf_lock);
168
169 return status;
170 }
171
172
173 static ssize_t
174 spidev_write(struct file *filp, const char __user *buf,
175 size_t count, loff_t *f_pos)
176 {
177 struct spidev_data *spidev;
178 ssize_t status = 0;
179 unsigned long missing;
180
181
182 if (count > bufsiz)
183 return -EMSGSIZE;
184
185 spidev = filp->private_data;
186
187 mutex_lock(&spidev->buf_lock);
188 missing = copy_from_user(spidev->tx_buffer, buf, count);
189 if (missing == 0)
190 status = spidev_sync_write(spidev, count);
191 else
192 status = -EFAULT;
193 mutex_unlock(&spidev->buf_lock);
194
195 return status;
196 }
197
198 static int spidev_message(struct spidev_data *spidev,
199 struct spi_ioc_transfer *u_xfers, unsigned n_xfers)
200 {
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;
206 u8 *tx_buf, *rx_buf;
207 int status = -EFAULT;
208
209 spi_message_init(&msg);
210 k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL);
211 if (k_xfers == NULL)
212 return -ENOMEM;
213
214
215
216
217
218 tx_buf = spidev->tx_buffer;
219 rx_buf = spidev->rx_buffer;
220 total = 0;
221 tx_total = 0;
222 rx_total = 0;
223 for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;
224 n;
225 n--, k_tmp++, u_tmp++) {
226 k_tmp->len = u_tmp->len;
227
228 total += k_tmp->len;
229
230
231
232
233
234 if (total > INT_MAX || k_tmp->len > INT_MAX) {
235 status = -EMSGSIZE;
236 goto done;
237 }
238
239 if (u_tmp->rx_buf) {
240
241 rx_total += k_tmp->len;
242 if (rx_total > bufsiz) {
243 status = -EMSGSIZE;
244 goto done;
245 }
246 k_tmp->rx_buf = rx_buf;
247 rx_buf += k_tmp->len;
248 }
249 if (u_tmp->tx_buf) {
250
251 tx_total += k_tmp->len;
252 if (tx_total > bufsiz) {
253 status = -EMSGSIZE;
254 goto done;
255 }
256 k_tmp->tx_buf = tx_buf;
257 if (copy_from_user(tx_buf, (const u8 __user *)
258 (uintptr_t) u_tmp->tx_buf,
259 u_tmp->len))
260 goto done;
261 tx_buf += k_tmp->len;
262 }
263
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;
273 #ifdef VERBOSE
274 dev_dbg(&spidev->spi->dev,
275 " xfer len %u %s%s%s%dbits %u usec %u usec %uHz\n",
276 u_tmp->len,
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,
281 u_tmp->delay_usecs,
282 u_tmp->word_delay_usecs,
283 u_tmp->speed_hz ? : spidev->spi->max_speed_hz);
284 #endif
285 spi_message_add_tail(k_tmp, &msg);
286 }
287
288 status = spidev_sync(spidev, &msg);
289 if (status < 0)
290 goto done;
291
292
293 rx_buf = spidev->rx_buffer;
294 for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) {
295 if (u_tmp->rx_buf) {
296 if (copy_to_user((u8 __user *)
297 (uintptr_t) u_tmp->rx_buf, rx_buf,
298 u_tmp->len)) {
299 status = -EFAULT;
300 goto done;
301 }
302 rx_buf += u_tmp->len;
303 }
304 }
305 status = total;
306
307 done:
308 kfree(k_xfers);
309 return status;
310 }
311
312 static struct spi_ioc_transfer *
313 spidev_get_ioc_message(unsigned int cmd, struct spi_ioc_transfer __user *u_ioc,
314 unsigned *n_ioc)
315 {
316 u32 tmp;
317
318
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);
323
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);
328 if (*n_ioc == 0)
329 return NULL;
330
331
332 return memdup_user(u_ioc, tmp);
333 }
334
335 static long
336 spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
337 {
338 int retval = 0;
339 struct spidev_data *spidev;
340 struct spi_device *spi;
341 u32 tmp;
342 unsigned n_ioc;
343 struct spi_ioc_transfer *ioc;
344
345
346 if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)
347 return -ENOTTY;
348
349
350
351
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);
356
357 if (spi == NULL)
358 return -ESHUTDOWN;
359
360
361
362
363
364
365
366 mutex_lock(&spidev->buf_lock);
367
368 switch (cmd) {
369
370 case SPI_IOC_RD_MODE:
371 retval = put_user(spi->mode & SPI_MODE_MASK,
372 (__u8 __user *)arg);
373 break;
374 case SPI_IOC_RD_MODE32:
375 retval = put_user(spi->mode & SPI_MODE_MASK,
376 (__u32 __user *)arg);
377 break;
378 case SPI_IOC_RD_LSB_FIRST:
379 retval = put_user((spi->mode & SPI_LSB_FIRST) ? 1 : 0,
380 (__u8 __user *)arg);
381 break;
382 case SPI_IOC_RD_BITS_PER_WORD:
383 retval = put_user(spi->bits_per_word, (__u8 __user *)arg);
384 break;
385 case SPI_IOC_RD_MAX_SPEED_HZ:
386 retval = put_user(spidev->speed_hz, (__u32 __user *)arg);
387 break;
388
389
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);
394 else
395 retval = get_user(tmp, (u32 __user *)arg);
396 if (retval == 0) {
397 struct spi_controller *ctlr = spi->controller;
398 u32 save = spi->mode;
399
400 if (tmp & ~SPI_MODE_MASK) {
401 retval = -EINVAL;
402 break;
403 }
404
405 if (ctlr->use_gpio_descriptors && ctlr->cs_gpiods &&
406 ctlr->cs_gpiods[spi->chip_select])
407 tmp |= SPI_CS_HIGH;
408
409 tmp |= spi->mode & ~SPI_MODE_MASK;
410 spi->mode = (u16)tmp;
411 retval = spi_setup(spi);
412 if (retval < 0)
413 spi->mode = save;
414 else
415 dev_dbg(&spi->dev, "spi mode %x\n", tmp);
416 }
417 break;
418 case SPI_IOC_WR_LSB_FIRST:
419 retval = get_user(tmp, (__u8 __user *)arg);
420 if (retval == 0) {
421 u32 save = spi->mode;
422
423 if (tmp)
424 spi->mode |= SPI_LSB_FIRST;
425 else
426 spi->mode &= ~SPI_LSB_FIRST;
427 retval = spi_setup(spi);
428 if (retval < 0)
429 spi->mode = save;
430 else
431 dev_dbg(&spi->dev, "%csb first\n",
432 tmp ? 'l' : 'm');
433 }
434 break;
435 case SPI_IOC_WR_BITS_PER_WORD:
436 retval = get_user(tmp, (__u8 __user *)arg);
437 if (retval == 0) {
438 u8 save = spi->bits_per_word;
439
440 spi->bits_per_word = tmp;
441 retval = spi_setup(spi);
442 if (retval < 0)
443 spi->bits_per_word = save;
444 else
445 dev_dbg(&spi->dev, "%d bits per word\n", tmp);
446 }
447 break;
448 case SPI_IOC_WR_MAX_SPEED_HZ:
449 retval = get_user(tmp, (__u32 __user *)arg);
450 if (retval == 0) {
451 u32 save = spi->max_speed_hz;
452
453 spi->max_speed_hz = tmp;
454 retval = spi_setup(spi);
455 if (retval >= 0)
456 spidev->speed_hz = tmp;
457 else
458 dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);
459 spi->max_speed_hz = save;
460 }
461 break;
462
463 default:
464
465
466 ioc = spidev_get_ioc_message(cmd,
467 (struct spi_ioc_transfer __user *)arg, &n_ioc);
468 if (IS_ERR(ioc)) {
469 retval = PTR_ERR(ioc);
470 break;
471 }
472 if (!ioc)
473 break;
474
475
476 retval = spidev_message(spidev, ioc, n_ioc);
477 kfree(ioc);
478 break;
479 }
480
481 mutex_unlock(&spidev->buf_lock);
482 spi_dev_put(spi);
483 return retval;
484 }
485
486 #ifdef CONFIG_COMPAT
487 static long
488 spidev_compat_ioc_message(struct file *filp, unsigned int cmd,
489 unsigned long arg)
490 {
491 struct spi_ioc_transfer __user *u_ioc;
492 int retval = 0;
493 struct spidev_data *spidev;
494 struct spi_device *spi;
495 unsigned n_ioc, n;
496 struct spi_ioc_transfer *ioc;
497
498 u_ioc = (struct spi_ioc_transfer __user *) compat_ptr(arg);
499
500
501
502
503 spidev = filp->private_data;
504 spin_lock_irq(&spidev->spi_lock);
505 spi = spi_dev_get(spidev->spi);
506 spin_unlock_irq(&spidev->spi_lock);
507
508 if (spi == NULL)
509 return -ESHUTDOWN;
510
511
512 mutex_lock(&spidev->buf_lock);
513
514
515 ioc = spidev_get_ioc_message(cmd, u_ioc, &n_ioc);
516 if (IS_ERR(ioc)) {
517 retval = PTR_ERR(ioc);
518 goto done;
519 }
520 if (!ioc)
521 goto done;
522
523
524 for (n = 0; n < n_ioc; n++) {
525 ioc[n].rx_buf = (uintptr_t) compat_ptr(ioc[n].rx_buf);
526 ioc[n].tx_buf = (uintptr_t) compat_ptr(ioc[n].tx_buf);
527 }
528
529
530 retval = spidev_message(spidev, ioc, n_ioc);
531 kfree(ioc);
532
533 done:
534 mutex_unlock(&spidev->buf_lock);
535 spi_dev_put(spi);
536 return retval;
537 }
538
539 static long
540 spidev_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
541 {
542 if (_IOC_TYPE(cmd) == SPI_IOC_MAGIC
543 && _IOC_NR(cmd) == _IOC_NR(SPI_IOC_MESSAGE(0))
544 && _IOC_DIR(cmd) == _IOC_WRITE)
545 return spidev_compat_ioc_message(filp, cmd, arg);
546
547 return spidev_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
548 }
549 #else
550 #define spidev_compat_ioctl NULL
551 #endif
552
553 static int spidev_open(struct inode *inode, struct file *filp)
554 {
555 struct spidev_data *spidev;
556 int status = -ENXIO;
557
558 mutex_lock(&device_list_lock);
559
560 list_for_each_entry(spidev, &device_list, device_entry) {
561 if (spidev->devt == inode->i_rdev) {
562 status = 0;
563 break;
564 }
565 }
566
567 if (status) {
568 pr_debug("spidev: nothing for minor %d\n", iminor(inode));
569 goto err_find_dev;
570 }
571
572 if (!spidev->tx_buffer) {
573 spidev->tx_buffer = kmalloc(bufsiz, GFP_KERNEL);
574 if (!spidev->tx_buffer) {
575 dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
576 status = -ENOMEM;
577 goto err_find_dev;
578 }
579 }
580
581 if (!spidev->rx_buffer) {
582 spidev->rx_buffer = kmalloc(bufsiz, GFP_KERNEL);
583 if (!spidev->rx_buffer) {
584 dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
585 status = -ENOMEM;
586 goto err_alloc_rx_buf;
587 }
588 }
589
590 spidev->users++;
591 filp->private_data = spidev;
592 stream_open(inode, filp);
593
594 mutex_unlock(&device_list_lock);
595 return 0;
596
597 err_alloc_rx_buf:
598 kfree(spidev->tx_buffer);
599 spidev->tx_buffer = NULL;
600 err_find_dev:
601 mutex_unlock(&device_list_lock);
602 return status;
603 }
604
605 static int spidev_release(struct inode *inode, struct file *filp)
606 {
607 struct spidev_data *spidev;
608
609 mutex_lock(&device_list_lock);
610 spidev = filp->private_data;
611 filp->private_data = NULL;
612
613
614 spidev->users--;
615 if (!spidev->users) {
616 int dofree;
617
618 kfree(spidev->tx_buffer);
619 spidev->tx_buffer = NULL;
620
621 kfree(spidev->rx_buffer);
622 spidev->rx_buffer = NULL;
623
624 spin_lock_irq(&spidev->spi_lock);
625 if (spidev->spi)
626 spidev->speed_hz = spidev->spi->max_speed_hz;
627
628
629 dofree = (spidev->spi == NULL);
630 spin_unlock_irq(&spidev->spi_lock);
631
632 if (dofree)
633 kfree(spidev);
634 }
635 #ifdef CONFIG_SPI_SLAVE
636 spi_slave_abort(spidev->spi);
637 #endif
638 mutex_unlock(&device_list_lock);
639
640 return 0;
641 }
642
643 static const struct file_operations spidev_fops = {
644 .owner = THIS_MODULE,
645
646
647
648
649 .write = spidev_write,
650 .read = spidev_read,
651 .unlocked_ioctl = spidev_ioctl,
652 .compat_ioctl = spidev_compat_ioctl,
653 .open = spidev_open,
654 .release = spidev_release,
655 .llseek = no_llseek,
656 };
657
658
659
660
661
662
663
664
665 static struct class *spidev_class;
666
667 #ifdef CONFIG_OF
668 static const struct of_device_id spidev_dt_ids[] = {
669 { .compatible = "rohm,dh2228fv" },
670 { .compatible = "lineartechnology,ltc2488" },
671 { .compatible = "ge,achc" },
672 { .compatible = "semtech,sx1301" },
673 { .compatible = "lwn,bk4" },
674 { .compatible = "dh,dhcom-board" },
675 { .compatible = "menlo,m53cpld" },
676 {},
677 };
678 MODULE_DEVICE_TABLE(of, spidev_dt_ids);
679 #endif
680
681 #ifdef CONFIG_ACPI
682
683
684 #define SPIDEV_ACPI_DUMMY 1
685
686 static const struct acpi_device_id spidev_acpi_ids[] = {
687
688
689
690
691
692
693 { "SPT0001", SPIDEV_ACPI_DUMMY },
694 { "SPT0002", SPIDEV_ACPI_DUMMY },
695 { "SPT0003", SPIDEV_ACPI_DUMMY },
696 {},
697 };
698 MODULE_DEVICE_TABLE(acpi, spidev_acpi_ids);
699
700 static void spidev_probe_acpi(struct spi_device *spi)
701 {
702 const struct acpi_device_id *id;
703
704 if (!has_acpi_companion(&spi->dev))
705 return;
706
707 id = acpi_match_device(spidev_acpi_ids, &spi->dev);
708 if (WARN_ON(!id))
709 return;
710
711 if (id->driver_data == SPIDEV_ACPI_DUMMY)
712 dev_warn(&spi->dev, "do not use this driver in production systems!\n");
713 }
714 #else
715 static inline void spidev_probe_acpi(struct spi_device *spi) {}
716 #endif
717
718
719
720 static int spidev_probe(struct spi_device *spi)
721 {
722 struct spidev_data *spidev;
723 int status;
724 unsigned long minor;
725
726
727
728
729
730
731 WARN(spi->dev.of_node &&
732 of_device_is_compatible(spi->dev.of_node, "spidev"),
733 "%pOF: buggy DT: spidev listed directly in DT\n", spi->dev.of_node);
734
735 spidev_probe_acpi(spi);
736
737
738 spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
739 if (!spidev)
740 return -ENOMEM;
741
742
743 spidev->spi = spi;
744 spin_lock_init(&spidev->spi_lock);
745 mutex_init(&spidev->buf_lock);
746
747 INIT_LIST_HEAD(&spidev->device_entry);
748
749
750
751
752 mutex_lock(&device_list_lock);
753 minor = find_first_zero_bit(minors, N_SPI_MINORS);
754 if (minor < N_SPI_MINORS) {
755 struct device *dev;
756
757 spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
758 dev = device_create(spidev_class, &spi->dev, spidev->devt,
759 spidev, "spidev%d.%d",
760 spi->master->bus_num, spi->chip_select);
761 status = PTR_ERR_OR_ZERO(dev);
762 } else {
763 dev_dbg(&spi->dev, "no minor number available!\n");
764 status = -ENODEV;
765 }
766 if (status == 0) {
767 set_bit(minor, minors);
768 list_add(&spidev->device_entry, &device_list);
769 }
770 mutex_unlock(&device_list_lock);
771
772 spidev->speed_hz = spi->max_speed_hz;
773
774 if (status == 0)
775 spi_set_drvdata(spi, spidev);
776 else
777 kfree(spidev);
778
779 return status;
780 }
781
782 static int spidev_remove(struct spi_device *spi)
783 {
784 struct spidev_data *spidev = spi_get_drvdata(spi);
785
786
787 spin_lock_irq(&spidev->spi_lock);
788 spidev->spi = NULL;
789 spin_unlock_irq(&spidev->spi_lock);
790
791
792 mutex_lock(&device_list_lock);
793 list_del(&spidev->device_entry);
794 device_destroy(spidev_class, spidev->devt);
795 clear_bit(MINOR(spidev->devt), minors);
796 if (spidev->users == 0)
797 kfree(spidev);
798 mutex_unlock(&device_list_lock);
799
800 return 0;
801 }
802
803 static struct spi_driver spidev_spi_driver = {
804 .driver = {
805 .name = "spidev",
806 .of_match_table = of_match_ptr(spidev_dt_ids),
807 .acpi_match_table = ACPI_PTR(spidev_acpi_ids),
808 },
809 .probe = spidev_probe,
810 .remove = spidev_remove,
811
812
813
814
815
816
817 };
818
819
820
821 static int __init spidev_init(void)
822 {
823 int status;
824
825
826
827
828
829 BUILD_BUG_ON(N_SPI_MINORS > 256);
830 status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
831 if (status < 0)
832 return status;
833
834 spidev_class = class_create(THIS_MODULE, "spidev");
835 if (IS_ERR(spidev_class)) {
836 unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
837 return PTR_ERR(spidev_class);
838 }
839
840 status = spi_register_driver(&spidev_spi_driver);
841 if (status < 0) {
842 class_destroy(spidev_class);
843 unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
844 }
845 return status;
846 }
847 module_init(spidev_init);
848
849 static void __exit spidev_exit(void)
850 {
851 spi_unregister_driver(&spidev_spi_driver);
852 class_destroy(spidev_class);
853 unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
854 }
855 module_exit(spidev_exit);
856
857 MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
858 MODULE_DESCRIPTION("User mode SPI device interface");
859 MODULE_LICENSE("GPL");
860 MODULE_ALIAS("spi:spidev");