Merge tag 'armsoc-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc
[linux-2.6-microblaze.git] / 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
19 #include <linux/init.h>
20 #include <linux/module.h>
21 #include <linux/ioctl.h>
22 #include <linux/fs.h>
23 #include <linux/device.h>
24 #include <linux/err.h>
25 #include <linux/list.h>
26 #include <linux/errno.h>
27 #include <linux/mutex.h>
28 #include <linux/slab.h>
29 #include <linux/compat.h>
30 #include <linux/of.h>
31 #include <linux/of_device.h>
32 #include <linux/acpi.h>
33
34 #include <linux/spi/spi.h>
35 #include <linux/spi/spidev.h>
36
37 #include <linux/uaccess.h>
38
39
40 /*
41  * This supports access to SPI devices using normal userspace I/O calls.
42  * Note that while traditional UNIX/POSIX I/O semantics are half duplex,
43  * and often mask message boundaries, full SPI support requires full duplex
44  * transfers.  There are several kinds of internal message boundaries to
45  * handle chipselect management and other protocol options.
46  *
47  * SPI has a character major number assigned.  We allocate minor numbers
48  * dynamically using a bitmask.  You must use hotplug tools, such as udev
49  * (or mdev with busybox) to create and destroy the /dev/spidevB.C device
50  * nodes, since there is no fixed association of minor numbers with any
51  * particular SPI bus or device.
52  */
53 #define SPIDEV_MAJOR                    153     /* assigned */
54 #define N_SPI_MINORS                    32      /* ... up to 256 */
55
56 static DECLARE_BITMAP(minors, N_SPI_MINORS);
57
58
59 /* Bit masks for spi_device.mode management.  Note that incorrect
60  * settings for some settings can cause *lots* of trouble for other
61  * devices on a shared bus:
62  *
63  *  - CS_HIGH ... this device will be active when it shouldn't be
64  *  - 3WIRE ... when active, it won't behave as it should
65  *  - NO_CS ... there will be no explicit message boundaries; this
66  *      is completely incompatible with the shared bus model
67  *  - READY ... transfers may proceed when they shouldn't.
68  *
69  * REVISIT should changing those flags be privileged?
70  */
71 #define SPI_MODE_MASK           (SPI_CPHA | SPI_CPOL | SPI_CS_HIGH \
72                                 | SPI_LSB_FIRST | SPI_3WIRE | SPI_LOOP \
73                                 | SPI_NO_CS | SPI_READY | SPI_TX_DUAL \
74                                 | SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD)
75
76 struct spidev_data {
77         dev_t                   devt;
78         spinlock_t              spi_lock;
79         struct spi_device       *spi;
80         struct list_head        device_entry;
81
82         /* TX/RX buffers are NULL unless this device is open (users > 0) */
83         struct mutex            buf_lock;
84         unsigned                users;
85         u8                      *tx_buffer;
86         u8                      *rx_buffer;
87         u32                     speed_hz;
88 };
89
90 static LIST_HEAD(device_list);
91 static DEFINE_MUTEX(device_list_lock);
92
93 static unsigned bufsiz = 4096;
94 module_param(bufsiz, uint, S_IRUGO);
95 MODULE_PARM_DESC(bufsiz, "data bytes in biggest supported SPI message");
96
97 /*-------------------------------------------------------------------------*/
98
99 static ssize_t
100 spidev_sync(struct spidev_data *spidev, struct spi_message *message)
101 {
102         int status;
103         struct spi_device *spi;
104
105         spin_lock_irq(&spidev->spi_lock);
106         spi = spidev->spi;
107         spin_unlock_irq(&spidev->spi_lock);
108
109         if (spi == NULL)
110                 status = -ESHUTDOWN;
111         else
112                 status = spi_sync(spi, message);
113
114         if (status == 0)
115                 status = message->actual_length;
116
117         return status;
118 }
119
120 static inline ssize_t
121 spidev_sync_write(struct spidev_data *spidev, size_t len)
122 {
123         struct spi_transfer     t = {
124                         .tx_buf         = spidev->tx_buffer,
125                         .len            = len,
126                         .speed_hz       = spidev->speed_hz,
127                 };
128         struct spi_message      m;
129
130         spi_message_init(&m);
131         spi_message_add_tail(&t, &m);
132         return spidev_sync(spidev, &m);
133 }
134
135 static inline ssize_t
136 spidev_sync_read(struct spidev_data *spidev, size_t len)
137 {
138         struct spi_transfer     t = {
139                         .rx_buf         = spidev->rx_buffer,
140                         .len            = len,
141                         .speed_hz       = spidev->speed_hz,
142                 };
143         struct spi_message      m;
144
145         spi_message_init(&m);
146         spi_message_add_tail(&t, &m);
147         return spidev_sync(spidev, &m);
148 }
149
150 /*-------------------------------------------------------------------------*/
151
152 /* Read-only message with current device setup */
153 static ssize_t
154 spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
155 {
156         struct spidev_data      *spidev;
157         ssize_t                 status = 0;
158
159         /* chipselect only toggles at start or end of operation */
160         if (count > bufsiz)
161                 return -EMSGSIZE;
162
163         spidev = filp->private_data;
164
165         mutex_lock(&spidev->buf_lock);
166         status = spidev_sync_read(spidev, count);
167         if (status > 0) {
168                 unsigned long   missing;
169
170                 missing = copy_to_user(buf, spidev->rx_buffer, status);
171                 if (missing == status)
172                         status = -EFAULT;
173                 else
174                         status = status - missing;
175         }
176         mutex_unlock(&spidev->buf_lock);
177
178         return status;
179 }
180
181 /* Write-only message with current device setup */
182 static ssize_t
183 spidev_write(struct file *filp, const char __user *buf,
184                 size_t count, loff_t *f_pos)
185 {
186         struct spidev_data      *spidev;
187         ssize_t                 status = 0;
188         unsigned long           missing;
189
190         /* chipselect only toggles at start or end of operation */
191         if (count > bufsiz)
192                 return -EMSGSIZE;
193
194         spidev = filp->private_data;
195
196         mutex_lock(&spidev->buf_lock);
197         missing = copy_from_user(spidev->tx_buffer, buf, count);
198         if (missing == 0)
199                 status = spidev_sync_write(spidev, count);
200         else
201                 status = -EFAULT;
202         mutex_unlock(&spidev->buf_lock);
203
204         return status;
205 }
206
207 static int spidev_message(struct spidev_data *spidev,
208                 struct spi_ioc_transfer *u_xfers, unsigned n_xfers)
209 {
210         struct spi_message      msg;
211         struct spi_transfer     *k_xfers;
212         struct spi_transfer     *k_tmp;
213         struct spi_ioc_transfer *u_tmp;
214         unsigned                n, total, tx_total, rx_total;
215         u8                      *tx_buf, *rx_buf;
216         int                     status = -EFAULT;
217
218         spi_message_init(&msg);
219         k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL);
220         if (k_xfers == NULL)
221                 return -ENOMEM;
222
223         /* Construct spi_message, copying any tx data to bounce buffer.
224          * We walk the array of user-provided transfers, using each one
225          * to initialize a kernel version of the same transfer.
226          */
227         tx_buf = spidev->tx_buffer;
228         rx_buf = spidev->rx_buffer;
229         total = 0;
230         tx_total = 0;
231         rx_total = 0;
232         for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;
233                         n;
234                         n--, k_tmp++, u_tmp++) {
235                 k_tmp->len = u_tmp->len;
236
237                 total += k_tmp->len;
238                 /* Since the function returns the total length of transfers
239                  * on success, restrict the total to positive int values to
240                  * avoid the return value looking like an error.  Also check
241                  * each transfer length to avoid arithmetic overflow.
242                  */
243                 if (total > INT_MAX || k_tmp->len > INT_MAX) {
244                         status = -EMSGSIZE;
245                         goto done;
246                 }
247
248                 if (u_tmp->rx_buf) {
249                         /* this transfer needs space in RX bounce buffer */
250                         rx_total += k_tmp->len;
251                         if (rx_total > bufsiz) {
252                                 status = -EMSGSIZE;
253                                 goto done;
254                         }
255                         k_tmp->rx_buf = rx_buf;
256                         rx_buf += k_tmp->len;
257                 }
258                 if (u_tmp->tx_buf) {
259                         /* this transfer needs space in TX bounce buffer */
260                         tx_total += k_tmp->len;
261                         if (tx_total > bufsiz) {
262                                 status = -EMSGSIZE;
263                                 goto done;
264                         }
265                         k_tmp->tx_buf = tx_buf;
266                         if (copy_from_user(tx_buf, (const u8 __user *)
267                                                 (uintptr_t) u_tmp->tx_buf,
268                                         u_tmp->len))
269                                 goto done;
270                         tx_buf += k_tmp->len;
271                 }
272
273                 k_tmp->cs_change = !!u_tmp->cs_change;
274                 k_tmp->tx_nbits = u_tmp->tx_nbits;
275                 k_tmp->rx_nbits = u_tmp->rx_nbits;
276                 k_tmp->bits_per_word = u_tmp->bits_per_word;
277                 k_tmp->delay_usecs = u_tmp->delay_usecs;
278                 k_tmp->speed_hz = u_tmp->speed_hz;
279                 if (!k_tmp->speed_hz)
280                         k_tmp->speed_hz = spidev->speed_hz;
281 #ifdef VERBOSE
282                 dev_dbg(&spidev->spi->dev,
283                         "  xfer len %u %s%s%s%dbits %u usec %uHz\n",
284                         u_tmp->len,
285                         u_tmp->rx_buf ? "rx " : "",
286                         u_tmp->tx_buf ? "tx " : "",
287                         u_tmp->cs_change ? "cs " : "",
288                         u_tmp->bits_per_word ? : spidev->spi->bits_per_word,
289                         u_tmp->delay_usecs,
290                         u_tmp->speed_hz ? : spidev->spi->max_speed_hz);
291 #endif
292                 spi_message_add_tail(k_tmp, &msg);
293         }
294
295         status = spidev_sync(spidev, &msg);
296         if (status < 0)
297                 goto done;
298
299         /* copy any rx data out of bounce buffer */
300         rx_buf = spidev->rx_buffer;
301         for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) {
302                 if (u_tmp->rx_buf) {
303                         if (copy_to_user((u8 __user *)
304                                         (uintptr_t) u_tmp->rx_buf, rx_buf,
305                                         u_tmp->len)) {
306                                 status = -EFAULT;
307                                 goto done;
308                         }
309                         rx_buf += u_tmp->len;
310                 }
311         }
312         status = total;
313
314 done:
315         kfree(k_xfers);
316         return status;
317 }
318
319 static struct spi_ioc_transfer *
320 spidev_get_ioc_message(unsigned int cmd, struct spi_ioc_transfer __user *u_ioc,
321                 unsigned *n_ioc)
322 {
323         u32     tmp;
324
325         /* Check type, command number and direction */
326         if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC
327                         || _IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))
328                         || _IOC_DIR(cmd) != _IOC_WRITE)
329                 return ERR_PTR(-ENOTTY);
330
331         tmp = _IOC_SIZE(cmd);
332         if ((tmp % sizeof(struct spi_ioc_transfer)) != 0)
333                 return ERR_PTR(-EINVAL);
334         *n_ioc = tmp / sizeof(struct spi_ioc_transfer);
335         if (*n_ioc == 0)
336                 return NULL;
337
338         /* copy into scratch area */
339         return memdup_user(u_ioc, tmp);
340 }
341
342 static long
343 spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
344 {
345         int                     retval = 0;
346         struct spidev_data      *spidev;
347         struct spi_device       *spi;
348         u32                     tmp;
349         unsigned                n_ioc;
350         struct spi_ioc_transfer *ioc;
351
352         /* Check type and command number */
353         if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)
354                 return -ENOTTY;
355
356         /* guard against device removal before, or while,
357          * we issue this ioctl.
358          */
359         spidev = filp->private_data;
360         spin_lock_irq(&spidev->spi_lock);
361         spi = spi_dev_get(spidev->spi);
362         spin_unlock_irq(&spidev->spi_lock);
363
364         if (spi == NULL)
365                 return -ESHUTDOWN;
366
367         /* use the buffer lock here for triple duty:
368          *  - prevent I/O (from us) so calling spi_setup() is safe;
369          *  - prevent concurrent SPI_IOC_WR_* from morphing
370          *    data fields while SPI_IOC_RD_* reads them;
371          *  - SPI_IOC_MESSAGE needs the buffer locked "normally".
372          */
373         mutex_lock(&spidev->buf_lock);
374
375         switch (cmd) {
376         /* read requests */
377         case SPI_IOC_RD_MODE:
378                 retval = put_user(spi->mode & SPI_MODE_MASK,
379                                         (__u8 __user *)arg);
380                 break;
381         case SPI_IOC_RD_MODE32:
382                 retval = put_user(spi->mode & SPI_MODE_MASK,
383                                         (__u32 __user *)arg);
384                 break;
385         case SPI_IOC_RD_LSB_FIRST:
386                 retval = put_user((spi->mode & SPI_LSB_FIRST) ?  1 : 0,
387                                         (__u8 __user *)arg);
388                 break;
389         case SPI_IOC_RD_BITS_PER_WORD:
390                 retval = put_user(spi->bits_per_word, (__u8 __user *)arg);
391                 break;
392         case SPI_IOC_RD_MAX_SPEED_HZ:
393                 retval = put_user(spidev->speed_hz, (__u32 __user *)arg);
394                 break;
395
396         /* write requests */
397         case SPI_IOC_WR_MODE:
398         case SPI_IOC_WR_MODE32:
399                 if (cmd == SPI_IOC_WR_MODE)
400                         retval = get_user(tmp, (u8 __user *)arg);
401                 else
402                         retval = get_user(tmp, (u32 __user *)arg);
403                 if (retval == 0) {
404                         u32     save = spi->mode;
405
406                         if (tmp & ~SPI_MODE_MASK) {
407                                 retval = -EINVAL;
408                                 break;
409                         }
410
411                         tmp |= spi->mode & ~SPI_MODE_MASK;
412                         spi->mode = (u16)tmp;
413                         retval = spi_setup(spi);
414                         if (retval < 0)
415                                 spi->mode = save;
416                         else
417                                 dev_dbg(&spi->dev, "spi mode %x\n", tmp);
418                 }
419                 break;
420         case SPI_IOC_WR_LSB_FIRST:
421                 retval = get_user(tmp, (__u8 __user *)arg);
422                 if (retval == 0) {
423                         u32     save = spi->mode;
424
425                         if (tmp)
426                                 spi->mode |= SPI_LSB_FIRST;
427                         else
428                                 spi->mode &= ~SPI_LSB_FIRST;
429                         retval = spi_setup(spi);
430                         if (retval < 0)
431                                 spi->mode = save;
432                         else
433                                 dev_dbg(&spi->dev, "%csb first\n",
434                                                 tmp ? 'l' : 'm');
435                 }
436                 break;
437         case SPI_IOC_WR_BITS_PER_WORD:
438                 retval = get_user(tmp, (__u8 __user *)arg);
439                 if (retval == 0) {
440                         u8      save = spi->bits_per_word;
441
442                         spi->bits_per_word = tmp;
443                         retval = spi_setup(spi);
444                         if (retval < 0)
445                                 spi->bits_per_word = save;
446                         else
447                                 dev_dbg(&spi->dev, "%d bits per word\n", tmp);
448                 }
449                 break;
450         case SPI_IOC_WR_MAX_SPEED_HZ:
451                 retval = get_user(tmp, (__u32 __user *)arg);
452                 if (retval == 0) {
453                         u32     save = spi->max_speed_hz;
454
455                         spi->max_speed_hz = tmp;
456                         retval = spi_setup(spi);
457                         if (retval >= 0)
458                                 spidev->speed_hz = tmp;
459                         else
460                                 dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);
461                         spi->max_speed_hz = save;
462                 }
463                 break;
464
465         default:
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);
470                 if (IS_ERR(ioc)) {
471                         retval = PTR_ERR(ioc);
472                         break;
473                 }
474                 if (!ioc)
475                         break;  /* n_ioc is also 0 */
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_ioc_message(struct file *filp, unsigned int cmd,
491                 unsigned long arg)
492 {
493         struct spi_ioc_transfer __user  *u_ioc;
494         int                             retval = 0;
495         struct spidev_data              *spidev;
496         struct spi_device               *spi;
497         unsigned                        n_ioc, n;
498         struct spi_ioc_transfer         *ioc;
499
500         u_ioc = (struct spi_ioc_transfer __user *) compat_ptr(arg);
501
502         /* guard against device removal before, or while,
503          * we issue this ioctl.
504          */
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);
509
510         if (spi == NULL)
511                 return -ESHUTDOWN;
512
513         /* SPI_IOC_MESSAGE needs the buffer locked "normally" */
514         mutex_lock(&spidev->buf_lock);
515
516         /* Check message and copy into scratch area */
517         ioc = spidev_get_ioc_message(cmd, u_ioc, &n_ioc);
518         if (IS_ERR(ioc)) {
519                 retval = PTR_ERR(ioc);
520                 goto done;
521         }
522         if (!ioc)
523                 goto done;      /* n_ioc is also 0 */
524
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);
529         }
530
531         /* translate to spi_message, execute */
532         retval = spidev_message(spidev, ioc, n_ioc);
533         kfree(ioc);
534
535 done:
536         mutex_unlock(&spidev->buf_lock);
537         spi_dev_put(spi);
538         return retval;
539 }
540
541 static long
542 spidev_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
543 {
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);
548
549         return spidev_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
550 }
551 #else
552 #define spidev_compat_ioctl NULL
553 #endif /* CONFIG_COMPAT */
554
555 static int spidev_open(struct inode *inode, struct file *filp)
556 {
557         struct spidev_data      *spidev;
558         int                     status = -ENXIO;
559
560         mutex_lock(&device_list_lock);
561
562         list_for_each_entry(spidev, &device_list, device_entry) {
563                 if (spidev->devt == inode->i_rdev) {
564                         status = 0;
565                         break;
566                 }
567         }
568
569         if (status) {
570                 pr_debug("spidev: nothing for minor %d\n", iminor(inode));
571                 goto err_find_dev;
572         }
573
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");
578                         status = -ENOMEM;
579                         goto err_find_dev;
580                 }
581         }
582
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");
587                         status = -ENOMEM;
588                         goto err_alloc_rx_buf;
589                 }
590         }
591
592         spidev->users++;
593         filp->private_data = spidev;
594         nonseekable_open(inode, filp);
595
596         mutex_unlock(&device_list_lock);
597         return 0;
598
599 err_alloc_rx_buf:
600         kfree(spidev->tx_buffer);
601         spidev->tx_buffer = NULL;
602 err_find_dev:
603         mutex_unlock(&device_list_lock);
604         return status;
605 }
606
607 static int spidev_release(struct inode *inode, struct file *filp)
608 {
609         struct spidev_data      *spidev;
610
611         mutex_lock(&device_list_lock);
612         spidev = filp->private_data;
613         filp->private_data = NULL;
614
615         /* last close? */
616         spidev->users--;
617         if (!spidev->users) {
618                 int             dofree;
619
620                 kfree(spidev->tx_buffer);
621                 spidev->tx_buffer = NULL;
622
623                 kfree(spidev->rx_buffer);
624                 spidev->rx_buffer = NULL;
625
626                 spin_lock_irq(&spidev->spi_lock);
627                 if (spidev->spi)
628                         spidev->speed_hz = spidev->spi->max_speed_hz;
629
630                 /* ... after we unbound from the underlying device? */
631                 dofree = (spidev->spi == NULL);
632                 spin_unlock_irq(&spidev->spi_lock);
633
634                 if (dofree)
635                         kfree(spidev);
636         }
637         mutex_unlock(&device_list_lock);
638
639         return 0;
640 }
641
642 static const struct file_operations spidev_fops = {
643         .owner =        THIS_MODULE,
644         /* REVISIT switch to aio primitives, so that userspace
645          * gets more complete API coverage.  It'll simplify things
646          * too, except for the locking.
647          */
648         .write =        spidev_write,
649         .read =         spidev_read,
650         .unlocked_ioctl = spidev_ioctl,
651         .compat_ioctl = spidev_compat_ioctl,
652         .open =         spidev_open,
653         .release =      spidev_release,
654         .llseek =       no_llseek,
655 };
656
657 /*-------------------------------------------------------------------------*/
658
659 /* The main reason to have this class is to make mdev/udev create the
660  * /dev/spidevB.C character device nodes exposing our userspace API.
661  * It also simplifies memory management.
662  */
663
664 static struct class *spidev_class;
665
666 #ifdef CONFIG_OF
667 static const struct of_device_id spidev_dt_ids[] = {
668         { .compatible = "rohm,dh2228fv" },
669         { .compatible = "lineartechnology,ltc2488" },
670         { .compatible = "ge,achc" },
671         { .compatible = "semtech,sx1301" },
672         {},
673 };
674 MODULE_DEVICE_TABLE(of, spidev_dt_ids);
675 #endif
676
677 #ifdef CONFIG_ACPI
678
679 /* Dummy SPI devices not to be used in production systems */
680 #define SPIDEV_ACPI_DUMMY       1
681
682 static const struct acpi_device_id spidev_acpi_ids[] = {
683         /*
684          * The ACPI SPT000* devices are only meant for development and
685          * testing. Systems used in production should have a proper ACPI
686          * description of the connected peripheral and they should also use
687          * a proper driver instead of poking directly to the SPI bus.
688          */
689         { "SPT0001", SPIDEV_ACPI_DUMMY },
690         { "SPT0002", SPIDEV_ACPI_DUMMY },
691         { "SPT0003", SPIDEV_ACPI_DUMMY },
692         {},
693 };
694 MODULE_DEVICE_TABLE(acpi, spidev_acpi_ids);
695
696 static void spidev_probe_acpi(struct spi_device *spi)
697 {
698         const struct acpi_device_id *id;
699
700         if (!has_acpi_companion(&spi->dev))
701                 return;
702
703         id = acpi_match_device(spidev_acpi_ids, &spi->dev);
704         if (WARN_ON(!id))
705                 return;
706
707         if (id->driver_data == SPIDEV_ACPI_DUMMY)
708                 dev_warn(&spi->dev, "do not use this driver in production systems!\n");
709 }
710 #else
711 static inline void spidev_probe_acpi(struct spi_device *spi) {}
712 #endif
713
714 /*-------------------------------------------------------------------------*/
715
716 static int spidev_probe(struct spi_device *spi)
717 {
718         struct spidev_data      *spidev;
719         int                     status;
720         unsigned long           minor;
721
722         /*
723          * spidev should never be referenced in DT without a specific
724          * compatible string, it is a Linux implementation thing
725          * rather than a description of the hardware.
726          */
727         if (spi->dev.of_node && !of_match_device(spidev_dt_ids, &spi->dev)) {
728                 dev_err(&spi->dev, "buggy DT: spidev listed directly in DT\n");
729                 WARN_ON(spi->dev.of_node &&
730                         !of_match_device(spidev_dt_ids, &spi->dev));
731         }
732
733         spidev_probe_acpi(spi);
734
735         /* Allocate driver data */
736         spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
737         if (!spidev)
738                 return -ENOMEM;
739
740         /* Initialize the driver data */
741         spidev->spi = spi;
742         spin_lock_init(&spidev->spi_lock);
743         mutex_init(&spidev->buf_lock);
744
745         INIT_LIST_HEAD(&spidev->device_entry);
746
747         /* If we can allocate a minor number, hook up this device.
748          * Reusing minors is fine so long as udev or mdev is working.
749          */
750         mutex_lock(&device_list_lock);
751         minor = find_first_zero_bit(minors, N_SPI_MINORS);
752         if (minor < N_SPI_MINORS) {
753                 struct device *dev;
754
755                 spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
756                 dev = device_create(spidev_class, &spi->dev, spidev->devt,
757                                     spidev, "spidev%d.%d",
758                                     spi->master->bus_num, spi->chip_select);
759                 status = PTR_ERR_OR_ZERO(dev);
760         } else {
761                 dev_dbg(&spi->dev, "no minor number available!\n");
762                 status = -ENODEV;
763         }
764         if (status == 0) {
765                 set_bit(minor, minors);
766                 list_add(&spidev->device_entry, &device_list);
767         }
768         mutex_unlock(&device_list_lock);
769
770         spidev->speed_hz = spi->max_speed_hz;
771
772         if (status == 0)
773                 spi_set_drvdata(spi, spidev);
774         else
775                 kfree(spidev);
776
777         return status;
778 }
779
780 static int spidev_remove(struct spi_device *spi)
781 {
782         struct spidev_data      *spidev = spi_get_drvdata(spi);
783
784         /* make sure ops on existing fds can abort cleanly */
785         spin_lock_irq(&spidev->spi_lock);
786         spidev->spi = NULL;
787         spin_unlock_irq(&spidev->spi_lock);
788
789         /* prevent new opens */
790         mutex_lock(&device_list_lock);
791         list_del(&spidev->device_entry);
792         device_destroy(spidev_class, spidev->devt);
793         clear_bit(MINOR(spidev->devt), minors);
794         if (spidev->users == 0)
795                 kfree(spidev);
796         mutex_unlock(&device_list_lock);
797
798         return 0;
799 }
800
801 static struct spi_driver spidev_spi_driver = {
802         .driver = {
803                 .name =         "spidev",
804                 .of_match_table = of_match_ptr(spidev_dt_ids),
805                 .acpi_match_table = ACPI_PTR(spidev_acpi_ids),
806         },
807         .probe =        spidev_probe,
808         .remove =       spidev_remove,
809
810         /* NOTE:  suspend/resume methods are not necessary here.
811          * We don't do anything except pass the requests to/from
812          * the underlying controller.  The refrigerator handles
813          * most issues; the controller driver handles the rest.
814          */
815 };
816
817 /*-------------------------------------------------------------------------*/
818
819 static int __init spidev_init(void)
820 {
821         int status;
822
823         /* Claim our 256 reserved device numbers.  Then register a class
824          * that will key udev/mdev to add/remove /dev nodes.  Last, register
825          * the driver which manages those device numbers.
826          */
827         BUILD_BUG_ON(N_SPI_MINORS > 256);
828         status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
829         if (status < 0)
830                 return status;
831
832         spidev_class = class_create(THIS_MODULE, "spidev");
833         if (IS_ERR(spidev_class)) {
834                 unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
835                 return PTR_ERR(spidev_class);
836         }
837
838         status = spi_register_driver(&spidev_spi_driver);
839         if (status < 0) {
840                 class_destroy(spidev_class);
841                 unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
842         }
843         return status;
844 }
845 module_init(spidev_init);
846
847 static void __exit spidev_exit(void)
848 {
849         spi_unregister_driver(&spidev_spi_driver);
850         class_destroy(spidev_class);
851         unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
852 }
853 module_exit(spidev_exit);
854
855 MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
856 MODULE_DESCRIPTION("User mode SPI device interface");
857 MODULE_LICENSE("GPL");
858 MODULE_ALIAS("spi:spidev");