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 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 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 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 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 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 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 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 * 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 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_get_chipselect(spi, 0)]) 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_get_chipselect(spi, 0)]) 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 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 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 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 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 */ 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 */ 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 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_get_chipselect(spi, 0)); 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 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 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("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 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