1 /* 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 55 static unsigned long minors[N_SPI_MINORS / BITS_PER_LONG]; 56 57 58 /* 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) 68 69 struct 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 79 static LIST_HEAD(device_list); 80 static DEFINE_MUTEX(device_list_lock); 81 82 static unsigned bufsiz = 4096; 83 module_param(bufsiz, uint, S_IRUGO); 84 MODULE_PARM_DESC(bufsiz, "data bytes in biggest supported SPI message"); 85 86 /*-------------------------------------------------------------------------*/ 87 88 /* Read-only message with current device setup */ 89 static ssize_t 90 spidev_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 */ 120 static ssize_t 121 spidev_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 149 static 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 178 total += k_tmp->len; 179 if (total > bufsiz) { 180 status = -EMSGSIZE; 181 goto done; 182 } 183 184 if (u_tmp->rx_buf) { 185 k_tmp->rx_buf = buf; 186 if (!access_ok(VERIFY_WRITE, (u8 __user *) 187 (uintptr_t) u_tmp->rx_buf, 188 u_tmp->len)) 189 goto done; 190 } 191 if (u_tmp->tx_buf) { 192 k_tmp->tx_buf = buf; 193 if (copy_from_user(buf, (const u8 __user *) 194 (uintptr_t) u_tmp->tx_buf, 195 u_tmp->len)) 196 goto done; 197 } 198 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) { 226 if (__copy_to_user((u8 __user *) 227 (uintptr_t) u_tmp->rx_buf, buf, 228 u_tmp->len)) { 229 status = -EFAULT; 230 goto done; 231 } 232 } 233 buf += u_tmp->len; 234 } 235 status = total; 236 237 done: 238 mutex_unlock(&spidev->buf_lock); 239 kfree(k_xfers); 240 return status; 241 } 242 243 static int 244 spidev_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)) { 378 kfree(ioc); 379 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 391 static 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 424 static 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 442 static 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 462 static 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 470 static struct class spidev_class = { 471 .name = "spidev", 472 .owner = THIS_MODULE, 473 .dev_release = spidev_classdev_release, 474 }; 475 476 /*-------------------------------------------------------------------------*/ 477 478 static 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); 499 minor = find_first_zero_bit(minors, N_SPI_MINORS); 500 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 525 static 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 541 static 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 558 static 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 } 584 module_init(spidev_init); 585 586 static 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 } 592 module_exit(spidev_exit); 593 594 MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>"); 595 MODULE_DESCRIPTION("User mode SPI device interface"); 596 MODULE_LICENSE("GPL"); 597