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