Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/spi/spidev.c

  1 /*
  2  * Simple synchronous userspace interface to SPI devices
  3  *
  4  * Copyright (C) 2006 SWAPP
  5  *      Andrea Paterniani <a.paterniani@swapp-eng.it>
  6  * Copyright (C) 2007 David Brownell (simplification, cleanup)
  7  *
  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.
 12  *
 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.
 17  *
 18  * You should have received a copy of the GNU General Public License
 19  * along with this program; if not, write to the Free Software
 20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 21  */
 22 
 23 #include <linux/init.h>
 24 #include <linux/module.h>
 25 #include <linux/ioctl.h>
 26 #include <linux/fs.h>
 27 #include <linux/device.h>
 28 #include <linux/err.h>
 29 #include <linux/list.h>
 30 #include <linux/errno.h>
 31 #include <linux/mutex.h>
 32 #include <linux/slab.h>
 33 #include <linux/compat.h>
 34 #include <linux/of.h>
 35 #include <linux/of_device.h>
 36 
 37 #include <linux/spi/spi.h>
 38 #include <linux/spi/spidev.h>
 39 
 40 #include <linux/uaccess.h>
 41 
 42 
 43 /*
 44  * This supports access to SPI devices using normal userspace I/O calls.
 45  * Note that while traditional UNIX/POSIX I/O semantics are half duplex,
 46  * and often mask message boundaries, full SPI support requires full duplex
 47  * transfers.  There are several kinds of internal message boundaries to
 48  * handle chipselect management and other protocol options.
 49  *
 50  * SPI has a character major number assigned.  We allocate minor numbers
 51  * dynamically using a bitmask.  You must use hotplug tools, such as udev
 52  * (or mdev with busybox) to create and destroy the /dev/spidevB.C device
 53  * nodes, since there is no fixed association of minor numbers with any
 54  * particular SPI bus or device.
 55  */
 56 #define SPIDEV_MAJOR                    153     /* assigned */
 57 #define N_SPI_MINORS                    32      /* ... up to 256 */
 58 
 59 static DECLARE_BITMAP(minors, N_SPI_MINORS);
 60 
 61 
 62 /* Bit masks for spi_device.mode management.  Note that incorrect
 63  * settings for some settings can cause *lots* of trouble for other
 64  * devices on a shared bus:
 65  *
 66  *  - CS_HIGH ... this device will be active when it shouldn't be
 67  *  - 3WIRE ... when active, it won't behave as it should
 68  *  - NO_CS ... there will be no explicit message boundaries; this
 69  *      is completely incompatible with the shared bus model
 70  *  - READY ... transfers may proceed when they shouldn't.
 71  *
 72  * REVISIT should changing those flags be privileged?
 73  */
 74 #define SPI_MODE_MASK           (SPI_CPHA | SPI_CPOL | SPI_CS_HIGH \
 75                                 | SPI_LSB_FIRST | SPI_3WIRE | SPI_LOOP \
 76                                 | SPI_NO_CS | SPI_READY | SPI_TX_DUAL \
 77                                 | SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD)
 78 
 79 struct spidev_data {
 80         dev_t                   devt;
 81         spinlock_t              spi_lock;
 82         struct spi_device       *spi;
 83         struct list_head        device_entry;
 84 
 85         /* buffer is NULL unless this device is open (users > 0) */
 86         struct mutex            buf_lock;
 87         unsigned                users;
 88         u8                      *buffer;
 89 };
 90 
 91 static LIST_HEAD(device_list);
 92 static DEFINE_MUTEX(device_list_lock);
 93 
 94 static unsigned bufsiz = 4096;
 95 module_param(bufsiz, uint, S_IRUGO);
 96 MODULE_PARM_DESC(bufsiz, "data bytes in biggest supported SPI message");
 97 
 98 /*-------------------------------------------------------------------------*/
 99 
100 /*
101  * We can't use the standard synchronous wrappers for file I/O; we
102  * need to protect against async removal of the underlying spi_device.
103  */
104 static void spidev_complete(void *arg)
105 {
106         complete(arg);
107 }
108 
109 static ssize_t
110 spidev_sync(struct spidev_data *spidev, struct spi_message *message)
111 {
112         DECLARE_COMPLETION_ONSTACK(done);
113         int status;
114 
115         message->complete = spidev_complete;
116         message->context = &done;
117 
118         spin_lock_irq(&spidev->spi_lock);
119         if (spidev->spi == NULL)
120                 status = -ESHUTDOWN;
121         else
122                 status = spi_async(spidev->spi, message);
123         spin_unlock_irq(&spidev->spi_lock);
124 
125         if (status == 0) {
126                 wait_for_completion(&done);
127                 status = message->status;
128                 if (status == 0)
129                         status = message->actual_length;
130         }
131         return status;
132 }
133 
134 static inline ssize_t
135 spidev_sync_write(struct spidev_data *spidev, size_t len)
136 {
137         struct spi_transfer     t = {
138                         .tx_buf         = spidev->buffer,
139                         .len            = len,
140                 };
141         struct spi_message      m;
142 
143         spi_message_init(&m);
144         spi_message_add_tail(&t, &m);
145         return spidev_sync(spidev, &m);
146 }
147 
148 static inline ssize_t
149 spidev_sync_read(struct spidev_data *spidev, size_t len)
150 {
151         struct spi_transfer     t = {
152                         .rx_buf         = spidev->buffer,
153                         .len            = len,
154                 };
155         struct spi_message      m;
156 
157         spi_message_init(&m);
158         spi_message_add_tail(&t, &m);
159         return spidev_sync(spidev, &m);
160 }
161 
162 /*-------------------------------------------------------------------------*/
163 
164 /* Read-only message with current device setup */
165 static ssize_t
166 spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
167 {
168         struct spidev_data      *spidev;
169         ssize_t                 status = 0;
170 
171         /* chipselect only toggles at start or end of operation */
172         if (count > bufsiz)
173                 return -EMSGSIZE;
174 
175         spidev = filp->private_data;
176 
177         mutex_lock(&spidev->buf_lock);
178         status = spidev_sync_read(spidev, count);
179         if (status > 0) {
180                 unsigned long   missing;
181 
182                 missing = copy_to_user(buf, spidev->buffer, status);
183                 if (missing == status)
184                         status = -EFAULT;
185                 else
186                         status = status - missing;
187         }
188         mutex_unlock(&spidev->buf_lock);
189 
190         return status;
191 }
192 
193 /* Write-only message with current device setup */
194 static ssize_t
195 spidev_write(struct file *filp, const char __user *buf,
196                 size_t count, loff_t *f_pos)
197 {
198         struct spidev_data      *spidev;
199         ssize_t                 status = 0;
200         unsigned long           missing;
201 
202         /* chipselect only toggles at start or end of operation */
203         if (count > bufsiz)
204                 return -EMSGSIZE;
205 
206         spidev = filp->private_data;
207 
208         mutex_lock(&spidev->buf_lock);
209         missing = copy_from_user(spidev->buffer, buf, count);
210         if (missing == 0)
211                 status = spidev_sync_write(spidev, count);
212         else
213                 status = -EFAULT;
214         mutex_unlock(&spidev->buf_lock);
215 
216         return status;
217 }
218 
219 static int spidev_message(struct spidev_data *spidev,
220                 struct spi_ioc_transfer *u_xfers, unsigned n_xfers)
221 {
222         struct spi_message      msg;
223         struct spi_transfer     *k_xfers;
224         struct spi_transfer     *k_tmp;
225         struct spi_ioc_transfer *u_tmp;
226         unsigned                n, total;
227         u8                      *buf;
228         int                     status = -EFAULT;
229 
230         spi_message_init(&msg);
231         k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL);
232         if (k_xfers == NULL)
233                 return -ENOMEM;
234 
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.
238          */
239         buf = spidev->buffer;
240         total = 0;
241         for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;
242                         n;
243                         n--, k_tmp++, u_tmp++) {
244                 k_tmp->len = u_tmp->len;
245 
246                 total += k_tmp->len;
247                 if (total > bufsiz) {
248                         status = -EMSGSIZE;
249                         goto done;
250                 }
251 
252                 if (u_tmp->rx_buf) {
253                         k_tmp->rx_buf = buf;
254                         if (!access_ok(VERIFY_WRITE, (u8 __user *)
255                                                 (uintptr_t) u_tmp->rx_buf,
256                                                 u_tmp->len))
257                                 goto done;
258                 }
259                 if (u_tmp->tx_buf) {
260                         k_tmp->tx_buf = buf;
261                         if (copy_from_user(buf, (const u8 __user *)
262                                                 (uintptr_t) u_tmp->tx_buf,
263                                         u_tmp->len))
264                                 goto done;
265                 }
266                 buf += k_tmp->len;
267 
268                 k_tmp->cs_change = !!u_tmp->cs_change;
269                 k_tmp->tx_nbits = u_tmp->tx_nbits;
270                 k_tmp->rx_nbits = u_tmp->rx_nbits;
271                 k_tmp->bits_per_word = u_tmp->bits_per_word;
272                 k_tmp->delay_usecs = u_tmp->delay_usecs;
273                 k_tmp->speed_hz = u_tmp->speed_hz;
274 #ifdef VERBOSE
275                 dev_dbg(&spidev->spi->dev,
276                         "  xfer len %zd %s%s%s%dbits %u usec %uHz\n",
277                         u_tmp->len,
278                         u_tmp->rx_buf ? "rx " : "",
279                         u_tmp->tx_buf ? "tx " : "",
280                         u_tmp->cs_change ? "cs " : "",
281                         u_tmp->bits_per_word ? : spidev->spi->bits_per_word,
282                         u_tmp->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         /* copy any rx data out of bounce buffer */
293         buf = spidev->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, buf,
298                                         u_tmp->len)) {
299                                 status = -EFAULT;
300                                 goto done;
301                         }
302                 }
303                 buf += u_tmp->len;
304         }
305         status = total;
306 
307 done:
308         kfree(k_xfers);
309         return status;
310 }
311 
312 static long
313 spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
314 {
315         int                     err = 0;
316         int                     retval = 0;
317         struct spidev_data      *spidev;
318         struct spi_device       *spi;
319         u32                     tmp;
320         unsigned                n_ioc;
321         struct spi_ioc_transfer *ioc;
322 
323         /* Check type and command number */
324         if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)
325                 return -ENOTTY;
326 
327         /* Check access direction once here; don't repeat below.
328          * IOC_DIR is from the user perspective, while access_ok is
329          * from the kernel perspective; so they look reversed.
330          */
331         if (_IOC_DIR(cmd) & _IOC_READ)
332                 err = !access_ok(VERIFY_WRITE,
333                                 (void __user *)arg, _IOC_SIZE(cmd));
334         if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE)
335                 err = !access_ok(VERIFY_READ,
336                                 (void __user *)arg, _IOC_SIZE(cmd));
337         if (err)
338                 return -EFAULT;
339 
340         /* guard against device removal before, or while,
341          * we issue this ioctl.
342          */
343         spidev = filp->private_data;
344         spin_lock_irq(&spidev->spi_lock);
345         spi = spi_dev_get(spidev->spi);
346         spin_unlock_irq(&spidev->spi_lock);
347 
348         if (spi == NULL)
349                 return -ESHUTDOWN;
350 
351         /* use the buffer lock here for triple duty:
352          *  - prevent I/O (from us) so calling spi_setup() is safe;
353          *  - prevent concurrent SPI_IOC_WR_* from morphing
354          *    data fields while SPI_IOC_RD_* reads them;
355          *  - SPI_IOC_MESSAGE needs the buffer locked "normally".
356          */
357         mutex_lock(&spidev->buf_lock);
358 
359         switch (cmd) {
360         /* read requests */
361         case SPI_IOC_RD_MODE:
362                 retval = __put_user(spi->mode & SPI_MODE_MASK,
363                                         (__u8 __user *)arg);
364                 break;
365         case SPI_IOC_RD_MODE32:
366                 retval = __put_user(spi->mode & SPI_MODE_MASK,
367                                         (__u32 __user *)arg);
368                 break;
369         case SPI_IOC_RD_LSB_FIRST:
370                 retval = __put_user((spi->mode & SPI_LSB_FIRST) ?  1 : 0,
371                                         (__u8 __user *)arg);
372                 break;
373         case SPI_IOC_RD_BITS_PER_WORD:
374                 retval = __put_user(spi->bits_per_word, (__u8 __user *)arg);
375                 break;
376         case SPI_IOC_RD_MAX_SPEED_HZ:
377                 retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg);
378                 break;
379 
380         /* write requests */
381         case SPI_IOC_WR_MODE:
382         case SPI_IOC_WR_MODE32:
383                 if (cmd == SPI_IOC_WR_MODE)
384                         retval = __get_user(tmp, (u8 __user *)arg);
385                 else
386                         retval = __get_user(tmp, (u32 __user *)arg);
387                 if (retval == 0) {
388                         u32     save = spi->mode;
389 
390                         if (tmp & ~SPI_MODE_MASK) {
391                                 retval = -EINVAL;
392                                 break;
393                         }
394 
395                         tmp |= spi->mode & ~SPI_MODE_MASK;
396                         spi->mode = (u16)tmp;
397                         retval = spi_setup(spi);
398                         if (retval < 0)
399                                 spi->mode = save;
400                         else
401                                 dev_dbg(&spi->dev, "spi mode %x\n", tmp);
402                 }
403                 break;
404         case SPI_IOC_WR_LSB_FIRST:
405                 retval = __get_user(tmp, (__u8 __user *)arg);
406                 if (retval == 0) {
407                         u32     save = spi->mode;
408 
409                         if (tmp)
410                                 spi->mode |= SPI_LSB_FIRST;
411                         else
412                                 spi->mode &= ~SPI_LSB_FIRST;
413                         retval = spi_setup(spi);
414                         if (retval < 0)
415                                 spi->mode = save;
416                         else
417                                 dev_dbg(&spi->dev, "%csb first\n",
418                                                 tmp ? 'l' : 'm');
419                 }
420                 break;
421         case SPI_IOC_WR_BITS_PER_WORD:
422                 retval = __get_user(tmp, (__u8 __user *)arg);
423                 if (retval == 0) {
424                         u8      save = spi->bits_per_word;
425 
426                         spi->bits_per_word = tmp;
427                         retval = spi_setup(spi);
428                         if (retval < 0)
429                                 spi->bits_per_word = save;
430                         else
431                                 dev_dbg(&spi->dev, "%d bits per word\n", tmp);
432                 }
433                 break;
434         case SPI_IOC_WR_MAX_SPEED_HZ:
435                 retval = __get_user(tmp, (__u32 __user *)arg);
436                 if (retval == 0) {
437                         u32     save = spi->max_speed_hz;
438 
439                         spi->max_speed_hz = tmp;
440                         retval = spi_setup(spi);
441                         if (retval < 0)
442                                 spi->max_speed_hz = save;
443                         else
444                                 dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);
445                 }
446                 break;
447 
448         default:
449                 /* segmented and/or full-duplex I/O request */
450                 if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))
451                                 || _IOC_DIR(cmd) != _IOC_WRITE) {
452                         retval = -ENOTTY;
453                         break;
454                 }
455 
456                 tmp = _IOC_SIZE(cmd);
457                 if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) {
458                         retval = -EINVAL;
459                         break;
460                 }
461                 n_ioc = tmp / sizeof(struct spi_ioc_transfer);
462                 if (n_ioc == 0)
463                         break;
464 
465                 /* copy into scratch area */
466                 ioc = kmalloc(tmp, GFP_KERNEL);
467                 if (!ioc) {
468                         retval = -ENOMEM;
469                         break;
470                 }
471                 if (__copy_from_user(ioc, (void __user *)arg, tmp)) {
472                         kfree(ioc);
473                         retval = -EFAULT;
474                         break;
475                 }
476 
477                 /* translate to spi_message, execute */
478                 retval = spidev_message(spidev, ioc, n_ioc);
479                 kfree(ioc);
480                 break;
481         }
482 
483         mutex_unlock(&spidev->buf_lock);
484         spi_dev_put(spi);
485         return retval;
486 }
487 
488 #ifdef CONFIG_COMPAT
489 static long
490 spidev_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
491 {
492         return spidev_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
493 }
494 #else
495 #define spidev_compat_ioctl NULL
496 #endif /* CONFIG_COMPAT */
497 
498 static int spidev_open(struct inode *inode, struct file *filp)
499 {
500         struct spidev_data      *spidev;
501         int                     status = -ENXIO;
502 
503         mutex_lock(&device_list_lock);
504 
505         list_for_each_entry(spidev, &device_list, device_entry) {
506                 if (spidev->devt == inode->i_rdev) {
507                         status = 0;
508                         break;
509                 }
510         }
511         if (status == 0) {
512                 if (!spidev->buffer) {
513                         spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);
514                         if (!spidev->buffer) {
515                                 dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
516                                 status = -ENOMEM;
517                         }
518                 }
519                 if (status == 0) {
520                         spidev->users++;
521                         filp->private_data = spidev;
522                         nonseekable_open(inode, filp);
523                 }
524         } else
525                 pr_debug("spidev: nothing for minor %d\n", iminor(inode));
526 
527         mutex_unlock(&device_list_lock);
528         return status;
529 }
530 
531 static int spidev_release(struct inode *inode, struct file *filp)
532 {
533         struct spidev_data      *spidev;
534         int                     status = 0;
535 
536         mutex_lock(&device_list_lock);
537         spidev = filp->private_data;
538         filp->private_data = NULL;
539 
540         /* last close? */
541         spidev->users--;
542         if (!spidev->users) {
543                 int             dofree;
544 
545                 kfree(spidev->buffer);
546                 spidev->buffer = NULL;
547 
548                 /* ... after we unbound from the underlying device? */
549                 spin_lock_irq(&spidev->spi_lock);
550                 dofree = (spidev->spi == NULL);
551                 spin_unlock_irq(&spidev->spi_lock);
552 
553                 if (dofree)
554                         kfree(spidev);
555         }
556         mutex_unlock(&device_list_lock);
557 
558         return status;
559 }
560 
561 static const struct file_operations spidev_fops = {
562         .owner =        THIS_MODULE,
563         /* REVISIT switch to aio primitives, so that userspace
564          * gets more complete API coverage.  It'll simplify things
565          * too, except for the locking.
566          */
567         .write =        spidev_write,
568         .read =         spidev_read,
569         .unlocked_ioctl = spidev_ioctl,
570         .compat_ioctl = spidev_compat_ioctl,
571         .open =         spidev_open,
572         .release =      spidev_release,
573         .llseek =       no_llseek,
574 };
575 
576 /*-------------------------------------------------------------------------*/
577 
578 /* The main reason to have this class is to make mdev/udev create the
579  * /dev/spidevB.C character device nodes exposing our userspace API.
580  * It also simplifies memory management.
581  */
582 
583 static struct class *spidev_class;
584 
585 /*-------------------------------------------------------------------------*/
586 
587 static int spidev_probe(struct spi_device *spi)
588 {
589         struct spidev_data      *spidev;
590         int                     status;
591         unsigned long           minor;
592 
593         /* Allocate driver data */
594         spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
595         if (!spidev)
596                 return -ENOMEM;
597 
598         /* Initialize the driver data */
599         spidev->spi = spi;
600         spin_lock_init(&spidev->spi_lock);
601         mutex_init(&spidev->buf_lock);
602 
603         INIT_LIST_HEAD(&spidev->device_entry);
604 
605         /* If we can allocate a minor number, hook up this device.
606          * Reusing minors is fine so long as udev or mdev is working.
607          */
608         mutex_lock(&device_list_lock);
609         minor = find_first_zero_bit(minors, N_SPI_MINORS);
610         if (minor < N_SPI_MINORS) {
611                 struct device *dev;
612 
613                 spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
614                 dev = device_create(spidev_class, &spi->dev, spidev->devt,
615                                     spidev, "spidev%d.%d",
616                                     spi->master->bus_num, spi->chip_select);
617                 status = PTR_ERR_OR_ZERO(dev);
618         } else {
619                 dev_dbg(&spi->dev, "no minor number available!\n");
620                 status = -ENODEV;
621         }
622         if (status == 0) {
623                 set_bit(minor, minors);
624                 list_add(&spidev->device_entry, &device_list);
625         }
626         mutex_unlock(&device_list_lock);
627 
628         if (status == 0)
629                 spi_set_drvdata(spi, spidev);
630         else
631                 kfree(spidev);
632 
633         return status;
634 }
635 
636 static int spidev_remove(struct spi_device *spi)
637 {
638         struct spidev_data      *spidev = spi_get_drvdata(spi);
639 
640         /* make sure ops on existing fds can abort cleanly */
641         spin_lock_irq(&spidev->spi_lock);
642         spidev->spi = NULL;
643         spin_unlock_irq(&spidev->spi_lock);
644 
645         /* prevent new opens */
646         mutex_lock(&device_list_lock);
647         list_del(&spidev->device_entry);
648         device_destroy(spidev_class, spidev->devt);
649         clear_bit(MINOR(spidev->devt), minors);
650         if (spidev->users == 0)
651                 kfree(spidev);
652         mutex_unlock(&device_list_lock);
653 
654         return 0;
655 }
656 
657 static const struct of_device_id spidev_dt_ids[] = {
658         { .compatible = "rohm,dh2228fv" },
659         {},
660 };
661 
662 MODULE_DEVICE_TABLE(of, spidev_dt_ids);
663 
664 static struct spi_driver spidev_spi_driver = {
665         .driver = {
666                 .name =         "spidev",
667                 .owner =        THIS_MODULE,
668                 .of_match_table = of_match_ptr(spidev_dt_ids),
669         },
670         .probe =        spidev_probe,
671         .remove =       spidev_remove,
672 
673         /* NOTE:  suspend/resume methods are not necessary here.
674          * We don't do anything except pass the requests to/from
675          * the underlying controller.  The refrigerator handles
676          * most issues; the controller driver handles the rest.
677          */
678 };
679 
680 /*-------------------------------------------------------------------------*/
681 
682 static int __init spidev_init(void)
683 {
684         int status;
685 
686         /* Claim our 256 reserved device numbers.  Then register a class
687          * that will key udev/mdev to add/remove /dev nodes.  Last, register
688          * the driver which manages those device numbers.
689          */
690         BUILD_BUG_ON(N_SPI_MINORS > 256);
691         status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
692         if (status < 0)
693                 return status;
694 
695         spidev_class = class_create(THIS_MODULE, "spidev");
696         if (IS_ERR(spidev_class)) {
697                 unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
698                 return PTR_ERR(spidev_class);
699         }
700 
701         status = spi_register_driver(&spidev_spi_driver);
702         if (status < 0) {
703                 class_destroy(spidev_class);
704                 unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
705         }
706         return status;
707 }
708 module_init(spidev_init);
709 
710 static void __exit spidev_exit(void)
711 {
712         spi_unregister_driver(&spidev_spi_driver);
713         class_destroy(spidev_class);
714         unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
715 }
716 module_exit(spidev_exit);
717 
718 MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
719 MODULE_DESCRIPTION("User mode SPI device interface");
720 MODULE_LICENSE("GPL");
721 MODULE_ALIAS("spi:spidev");
722 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us