Version:  2.0.40 2.2.26 2.4.37 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 3.17 3.18

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

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