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