blob: b3518ca9f04e01b0d3115908988f9e4ccd8d2aed [file] [log] [blame]
Andrea Paterniani814a8d52007-05-08 00:32:15 -07001/*
2 * spidev.c -- 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/list.h>
29#include <linux/errno.h>
30#include <linux/mutex.h>
31#include <linux/slab.h>
32
33#include <linux/spi/spi.h>
34#include <linux/spi/spidev.h>
35
36#include <asm/uaccess.h>
37
38
39/*
40 * This supports acccess to SPI devices using normal userspace I/O calls.
41 * Note that while traditional UNIX/POSIX I/O semantics are half duplex,
42 * and often mask message boundaries, full SPI support requires full duplex
43 * transfers. There are several kinds of of internal message boundaries to
44 * handle chipselect management and other protocol options.
45 *
46 * SPI has a character major number assigned. We allocate minor numbers
47 * dynamically using a bitmask. You must use hotplug tools, such as udev
48 * (or mdev with busybox) to create and destroy the /dev/spidevB.C device
49 * nodes, since there is no fixed association of minor numbers with any
50 * particular SPI bus or device.
51 */
52#define SPIDEV_MAJOR 153 /* assigned */
53#define N_SPI_MINORS 32 /* ... up to 256 */
54
55static unsigned long minors[N_SPI_MINORS / BITS_PER_LONG];
56
57
Anton Vorontsov6f166e32007-07-31 00:38:43 -070058/* Bit masks for spi_device.mode management. Note that incorrect
59 * settings for CS_HIGH and 3WIRE can cause *lots* of trouble for other
60 * devices on a shared bus: CS_HIGH, because this device will be
61 * active when it shouldn't be; 3WIRE, because when active it won't
62 * behave as it should.
63 *
64 * REVISIT should changing those two modes be privileged?
65 */
66#define SPI_MODE_MASK (SPI_CPHA | SPI_CPOL | SPI_CS_HIGH \
67 | SPI_LSB_FIRST | SPI_3WIRE | SPI_LOOP)
Andrea Paterniani814a8d52007-05-08 00:32:15 -070068
69struct spidev_data {
70 struct device dev;
71 struct spi_device *spi;
72 struct list_head device_entry;
73
74 struct mutex buf_lock;
75 unsigned users;
76 u8 *buffer;
77};
78
79static LIST_HEAD(device_list);
80static DEFINE_MUTEX(device_list_lock);
81
82static unsigned bufsiz = 4096;
83module_param(bufsiz, uint, S_IRUGO);
84MODULE_PARM_DESC(bufsiz, "data bytes in biggest supported SPI message");
85
86/*-------------------------------------------------------------------------*/
87
88/* Read-only message with current device setup */
89static ssize_t
90spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
91{
92 struct spidev_data *spidev;
93 struct spi_device *spi;
94 ssize_t status = 0;
95
96 /* chipselect only toggles at start or end of operation */
97 if (count > bufsiz)
98 return -EMSGSIZE;
99
100 spidev = filp->private_data;
101 spi = spidev->spi;
102
103 mutex_lock(&spidev->buf_lock);
104 status = spi_read(spi, spidev->buffer, count);
105 if (status == 0) {
106 unsigned long missing;
107
108 missing = copy_to_user(buf, spidev->buffer, count);
109 if (count && missing == count)
110 status = -EFAULT;
111 else
112 status = count - missing;
113 }
114 mutex_unlock(&spidev->buf_lock);
115
116 return status;
117}
118
119/* Write-only message with current device setup */
120static ssize_t
121spidev_write(struct file *filp, const char __user *buf,
122 size_t count, loff_t *f_pos)
123{
124 struct spidev_data *spidev;
125 struct spi_device *spi;
126 ssize_t status = 0;
127 unsigned long missing;
128
129 /* chipselect only toggles at start or end of operation */
130 if (count > bufsiz)
131 return -EMSGSIZE;
132
133 spidev = filp->private_data;
134 spi = spidev->spi;
135
136 mutex_lock(&spidev->buf_lock);
137 missing = copy_from_user(spidev->buffer, buf, count);
138 if (missing == 0) {
139 status = spi_write(spi, spidev->buffer, count);
140 if (status == 0)
141 status = count;
142 } else
143 status = -EFAULT;
144 mutex_unlock(&spidev->buf_lock);
145
146 return status;
147}
148
149static int spidev_message(struct spidev_data *spidev,
150 struct spi_ioc_transfer *u_xfers, unsigned n_xfers)
151{
152 struct spi_message msg;
153 struct spi_transfer *k_xfers;
154 struct spi_transfer *k_tmp;
155 struct spi_ioc_transfer *u_tmp;
156 struct spi_device *spi = spidev->spi;
157 unsigned n, total;
158 u8 *buf;
159 int status = -EFAULT;
160
161 spi_message_init(&msg);
162 k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL);
163 if (k_xfers == NULL)
164 return -ENOMEM;
165
166 /* Construct spi_message, copying any tx data to bounce buffer.
167 * We walk the array of user-provided transfers, using each one
168 * to initialize a kernel version of the same transfer.
169 */
170 mutex_lock(&spidev->buf_lock);
171 buf = spidev->buffer;
172 total = 0;
173 for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;
174 n;
175 n--, k_tmp++, u_tmp++) {
176 k_tmp->len = u_tmp->len;
177
Domen Puncerda90fa82007-05-23 13:57:39 -0700178 total += k_tmp->len;
179 if (total > bufsiz) {
180 status = -EMSGSIZE;
181 goto done;
182 }
183
Andrea Paterniani814a8d52007-05-08 00:32:15 -0700184 if (u_tmp->rx_buf) {
185 k_tmp->rx_buf = buf;
David Brownell96ddbf52007-08-10 13:01:09 -0700186 if (!access_ok(VERIFY_WRITE, (u8 __user *)
Al Viro142956a2007-10-29 05:11:28 +0000187 (uintptr_t) u_tmp->rx_buf,
David Brownell96ddbf52007-08-10 13:01:09 -0700188 u_tmp->len))
Andrea Paterniani814a8d52007-05-08 00:32:15 -0700189 goto done;
190 }
191 if (u_tmp->tx_buf) {
192 k_tmp->tx_buf = buf;
David Brownell4917d922007-07-17 04:04:04 -0700193 if (copy_from_user(buf, (const u8 __user *)
Al Viro142956a2007-10-29 05:11:28 +0000194 (uintptr_t) u_tmp->tx_buf,
Andrea Paterniani814a8d52007-05-08 00:32:15 -0700195 u_tmp->len))
196 goto done;
197 }
Andrea Paterniani814a8d52007-05-08 00:32:15 -0700198 buf += k_tmp->len;
199
200 k_tmp->cs_change = !!u_tmp->cs_change;
201 k_tmp->bits_per_word = u_tmp->bits_per_word;
202 k_tmp->delay_usecs = u_tmp->delay_usecs;
203 k_tmp->speed_hz = u_tmp->speed_hz;
204#ifdef VERBOSE
205 dev_dbg(&spi->dev,
206 " xfer len %zd %s%s%s%dbits %u usec %uHz\n",
207 u_tmp->len,
208 u_tmp->rx_buf ? "rx " : "",
209 u_tmp->tx_buf ? "tx " : "",
210 u_tmp->cs_change ? "cs " : "",
211 u_tmp->bits_per_word ? : spi->bits_per_word,
212 u_tmp->delay_usecs,
213 u_tmp->speed_hz ? : spi->max_speed_hz);
214#endif
215 spi_message_add_tail(k_tmp, &msg);
216 }
217
218 status = spi_sync(spi, &msg);
219 if (status < 0)
220 goto done;
221
222 /* copy any rx data out of bounce buffer */
223 buf = spidev->buffer;
224 for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) {
225 if (u_tmp->rx_buf) {
David Brownell4917d922007-07-17 04:04:04 -0700226 if (__copy_to_user((u8 __user *)
Al Viro142956a2007-10-29 05:11:28 +0000227 (uintptr_t) u_tmp->rx_buf, buf,
Andrea Paterniani814a8d52007-05-08 00:32:15 -0700228 u_tmp->len)) {
229 status = -EFAULT;
230 goto done;
231 }
232 }
233 buf += u_tmp->len;
234 }
235 status = total;
236
237done:
238 mutex_unlock(&spidev->buf_lock);
239 kfree(k_xfers);
240 return status;
241}
242
243static int
244spidev_ioctl(struct inode *inode, struct file *filp,
245 unsigned int cmd, unsigned long arg)
246{
247 int err = 0;
248 int retval = 0;
249 struct spidev_data *spidev;
250 struct spi_device *spi;
251 u32 tmp;
252 unsigned n_ioc;
253 struct spi_ioc_transfer *ioc;
254
255 /* Check type and command number */
256 if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)
257 return -ENOTTY;
258
259 /* Check access direction once here; don't repeat below.
260 * IOC_DIR is from the user perspective, while access_ok is
261 * from the kernel perspective; so they look reversed.
262 */
263 if (_IOC_DIR(cmd) & _IOC_READ)
264 err = !access_ok(VERIFY_WRITE,
265 (void __user *)arg, _IOC_SIZE(cmd));
266 if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE)
267 err = !access_ok(VERIFY_READ,
268 (void __user *)arg, _IOC_SIZE(cmd));
269 if (err)
270 return -EFAULT;
271
272 spidev = filp->private_data;
273 spi = spidev->spi;
274
275 switch (cmd) {
276 /* read requests */
277 case SPI_IOC_RD_MODE:
278 retval = __put_user(spi->mode & SPI_MODE_MASK,
279 (__u8 __user *)arg);
280 break;
281 case SPI_IOC_RD_LSB_FIRST:
282 retval = __put_user((spi->mode & SPI_LSB_FIRST) ? 1 : 0,
283 (__u8 __user *)arg);
284 break;
285 case SPI_IOC_RD_BITS_PER_WORD:
286 retval = __put_user(spi->bits_per_word, (__u8 __user *)arg);
287 break;
288 case SPI_IOC_RD_MAX_SPEED_HZ:
289 retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg);
290 break;
291
292 /* write requests */
293 case SPI_IOC_WR_MODE:
294 retval = __get_user(tmp, (u8 __user *)arg);
295 if (retval == 0) {
296 u8 save = spi->mode;
297
298 if (tmp & ~SPI_MODE_MASK) {
299 retval = -EINVAL;
300 break;
301 }
302
303 tmp |= spi->mode & ~SPI_MODE_MASK;
304 spi->mode = (u8)tmp;
305 retval = spi_setup(spi);
306 if (retval < 0)
307 spi->mode = save;
308 else
309 dev_dbg(&spi->dev, "spi mode %02x\n", tmp);
310 }
311 break;
312 case SPI_IOC_WR_LSB_FIRST:
313 retval = __get_user(tmp, (__u8 __user *)arg);
314 if (retval == 0) {
315 u8 save = spi->mode;
316
317 if (tmp)
318 spi->mode |= SPI_LSB_FIRST;
319 else
320 spi->mode &= ~SPI_LSB_FIRST;
321 retval = spi_setup(spi);
322 if (retval < 0)
323 spi->mode = save;
324 else
325 dev_dbg(&spi->dev, "%csb first\n",
326 tmp ? 'l' : 'm');
327 }
328 break;
329 case SPI_IOC_WR_BITS_PER_WORD:
330 retval = __get_user(tmp, (__u8 __user *)arg);
331 if (retval == 0) {
332 u8 save = spi->bits_per_word;
333
334 spi->bits_per_word = tmp;
335 retval = spi_setup(spi);
336 if (retval < 0)
337 spi->bits_per_word = save;
338 else
339 dev_dbg(&spi->dev, "%d bits per word\n", tmp);
340 }
341 break;
342 case SPI_IOC_WR_MAX_SPEED_HZ:
343 retval = __get_user(tmp, (__u32 __user *)arg);
344 if (retval == 0) {
345 u32 save = spi->max_speed_hz;
346
347 spi->max_speed_hz = tmp;
348 retval = spi_setup(spi);
349 if (retval < 0)
350 spi->max_speed_hz = save;
351 else
352 dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);
353 }
354 break;
355
356 default:
357 /* segmented and/or full-duplex I/O request */
358 if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))
359 || _IOC_DIR(cmd) != _IOC_WRITE)
360 return -ENOTTY;
361
362 tmp = _IOC_SIZE(cmd);
363 if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) {
364 retval = -EINVAL;
365 break;
366 }
367 n_ioc = tmp / sizeof(struct spi_ioc_transfer);
368 if (n_ioc == 0)
369 break;
370
371 /* copy into scratch area */
372 ioc = kmalloc(tmp, GFP_KERNEL);
373 if (!ioc) {
374 retval = -ENOMEM;
375 break;
376 }
377 if (__copy_from_user(ioc, (void __user *)arg, tmp)) {
Florin Malita9bea3f22007-05-23 13:57:45 -0700378 kfree(ioc);
Andrea Paterniani814a8d52007-05-08 00:32:15 -0700379 retval = -EFAULT;
380 break;
381 }
382
383 /* translate to spi_message, execute */
384 retval = spidev_message(spidev, ioc, n_ioc);
385 kfree(ioc);
386 break;
387 }
388 return retval;
389}
390
391static int spidev_open(struct inode *inode, struct file *filp)
392{
393 struct spidev_data *spidev;
394 int status = -ENXIO;
395
396 mutex_lock(&device_list_lock);
397
398 list_for_each_entry(spidev, &device_list, device_entry) {
399 if (spidev->dev.devt == inode->i_rdev) {
400 status = 0;
401 break;
402 }
403 }
404 if (status == 0) {
405 if (!spidev->buffer) {
406 spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);
407 if (!spidev->buffer) {
408 dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
409 status = -ENOMEM;
410 }
411 }
412 if (status == 0) {
413 spidev->users++;
414 filp->private_data = spidev;
415 nonseekable_open(inode, filp);
416 }
417 } else
418 pr_debug("spidev: nothing for minor %d\n", iminor(inode));
419
420 mutex_unlock(&device_list_lock);
421 return status;
422}
423
424static int spidev_release(struct inode *inode, struct file *filp)
425{
426 struct spidev_data *spidev;
427 int status = 0;
428
429 mutex_lock(&device_list_lock);
430 spidev = filp->private_data;
431 filp->private_data = NULL;
432 spidev->users--;
433 if (!spidev->users) {
434 kfree(spidev->buffer);
435 spidev->buffer = NULL;
436 }
437 mutex_unlock(&device_list_lock);
438
439 return status;
440}
441
442static struct file_operations spidev_fops = {
443 .owner = THIS_MODULE,
444 /* REVISIT switch to aio primitives, so that userspace
445 * gets more complete API coverage. It'll simplify things
446 * too, except for the locking.
447 */
448 .write = spidev_write,
449 .read = spidev_read,
450 .ioctl = spidev_ioctl,
451 .open = spidev_open,
452 .release = spidev_release,
453};
454
455/*-------------------------------------------------------------------------*/
456
457/* The main reason to have this class is to make mdev/udev create the
458 * /dev/spidevB.C character device nodes exposing our userspace API.
459 * It also simplifies memory management.
460 */
461
462static void spidev_classdev_release(struct device *dev)
463{
464 struct spidev_data *spidev;
465
466 spidev = container_of(dev, struct spidev_data, dev);
467 kfree(spidev);
468}
469
470static struct class spidev_class = {
471 .name = "spidev",
472 .owner = THIS_MODULE,
473 .dev_release = spidev_classdev_release,
474};
475
476/*-------------------------------------------------------------------------*/
477
478static int spidev_probe(struct spi_device *spi)
479{
480 struct spidev_data *spidev;
481 int status;
482 unsigned long minor;
483
484 /* Allocate driver data */
485 spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
486 if (!spidev)
487 return -ENOMEM;
488
489 /* Initialize the driver data */
490 spidev->spi = spi;
491 mutex_init(&spidev->buf_lock);
492
493 INIT_LIST_HEAD(&spidev->device_entry);
494
495 /* If we can allocate a minor number, hook up this device.
496 * Reusing minors is fine so long as udev or mdev is working.
497 */
498 mutex_lock(&device_list_lock);
Domen Puncer0a4dd772007-05-15 23:57:05 -0700499 minor = find_first_zero_bit(minors, N_SPI_MINORS);
Andrea Paterniani814a8d52007-05-08 00:32:15 -0700500 if (minor < N_SPI_MINORS) {
501 spidev->dev.parent = &spi->dev;
502 spidev->dev.class = &spidev_class;
503 spidev->dev.devt = MKDEV(SPIDEV_MAJOR, minor);
504 snprintf(spidev->dev.bus_id, sizeof spidev->dev.bus_id,
505 "spidev%d.%d",
506 spi->master->bus_num, spi->chip_select);
507 status = device_register(&spidev->dev);
508 } else {
509 dev_dbg(&spi->dev, "no minor number available!\n");
510 status = -ENODEV;
511 }
512 if (status == 0) {
513 set_bit(minor, minors);
514 dev_set_drvdata(&spi->dev, spidev);
515 list_add(&spidev->device_entry, &device_list);
516 }
517 mutex_unlock(&device_list_lock);
518
519 if (status != 0)
520 kfree(spidev);
521
522 return status;
523}
524
525static int spidev_remove(struct spi_device *spi)
526{
527 struct spidev_data *spidev = dev_get_drvdata(&spi->dev);
528
529 mutex_lock(&device_list_lock);
530
531 list_del(&spidev->device_entry);
532 dev_set_drvdata(&spi->dev, NULL);
533 clear_bit(MINOR(spidev->dev.devt), minors);
534 device_unregister(&spidev->dev);
535
536 mutex_unlock(&device_list_lock);
537
538 return 0;
539}
540
541static struct spi_driver spidev_spi = {
542 .driver = {
543 .name = "spidev",
544 .owner = THIS_MODULE,
545 },
546 .probe = spidev_probe,
547 .remove = __devexit_p(spidev_remove),
548
549 /* NOTE: suspend/resume methods are not necessary here.
550 * We don't do anything except pass the requests to/from
551 * the underlying controller. The refrigerator handles
552 * most issues; the controller driver handles the rest.
553 */
554};
555
556/*-------------------------------------------------------------------------*/
557
558static int __init spidev_init(void)
559{
560 int status;
561
562 /* Claim our 256 reserved device numbers. Then register a class
563 * that will key udev/mdev to add/remove /dev nodes. Last, register
564 * the driver which manages those device numbers.
565 */
566 BUILD_BUG_ON(N_SPI_MINORS > 256);
567 status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
568 if (status < 0)
569 return status;
570
571 status = class_register(&spidev_class);
572 if (status < 0) {
573 unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
574 return status;
575 }
576
577 status = spi_register_driver(&spidev_spi);
578 if (status < 0) {
579 class_unregister(&spidev_class);
580 unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
581 }
582 return status;
583}
584module_init(spidev_init);
585
586static void __exit spidev_exit(void)
587{
588 spi_unregister_driver(&spidev_spi);
589 class_unregister(&spidev_class);
590 unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
591}
592module_exit(spidev_exit);
593
594MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
595MODULE_DESCRIPTION("User mode SPI device interface");
596MODULE_LICENSE("GPL");