drivers/spi/spidev.c

   1 /*
   2  * Simple synchronous userspace interface to SPI devices
   3  *
   4  * Copyright (C) 2006 SWAPP
   5  *      Andrea Paterniani <[email protected]>
   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/err.h>
  29 #include <linux/list.h>
  30 #include <linux/errno.h>
  31 #include <linux/mutex.h>
  32 #include <linux/slab.h>
  33 #include <linux/compat.h>
  34 #include <linux/of.h>
  35 #include <linux/of_device.h>
  36
  37 #include <linux/spi/spi.h>
  38 #include <linux/spi/spidev.h>
  39
  40 #include <linux/uaccess.h>
  41
  42
  43 /*
  44  * This supports access to SPI devices using normal userspace I/O calls.
  45  * Note that while traditional UNIX/POSIX I/O semantics are half duplex,
  46  * and often mask message boundaries, full SPI support requires full duplex
  47  * transfers.  There are several kinds of internal message boundaries to
  48  * handle chipselect management and other protocol options.
  49  *
  50  * SPI has a character major number assigned.  We allocate minor numbers
  51  * dynamically using a bitmask.  You must use hotplug tools, such as udev
  52  * (or mdev with busybox) to create and destroy the /dev/spidevB.C device
  53  * nodes, since there is no fixed association of minor numbers with any
  54  * particular SPI bus or device.
  55  */
  56 #define SPIDEV_MAJOR                    153     /* assigned */
  57 #define N_SPI_MINORS                    32      /* ... up to 256 */
  58
  59 static DECLARE_BITMAP(minors, N_SPI_MINORS);
  60
  61
  62 /* Bit masks for spi_device.mode management.  Note that incorrect
  63  * settings for some settings can cause *lots* of trouble for other
  64  * devices on a shared bus:
  65  *
  66  *  - CS_HIGH ... this device will be active when it shouldn't be
  67  *  - 3WIRE ... when active, it won't behave as it should
  68  *  - NO_CS ... there will be no explicit message boundaries; this
  69  *      is completely incompatible with the shared bus model
  70  *  - READY ... transfers may proceed when they shouldn't.
  71  *
  72  * REVISIT should changing those flags be privileged?
  73  */
  74 #define SPI_MODE_MASK           (SPI_CPHA | SPI_CPOL | SPI_CS_HIGH \
  75                                 | SPI_LSB_FIRST | SPI_3WIRE | SPI_LOOP \
  76                                 | SPI_NO_CS | SPI_READY | SPI_TX_DUAL \
  77                                 | SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD)
  78
  79 struct spidev_data {
  80         dev_t                   devt;
  81         spinlock_t              spi_lock;
  82         struct spi_device       *spi;
  83         struct list_head        device_entry;
  84
  85         /* TX/RX buffers are NULL unless this device is open (users > 0) */
  86         struct mutex            buf_lock;
  87         unsigned                users;
  88         u8                      *tx_buffer;
  89         u8                      *rx_buffer;
  90 };
  91
  92 static LIST_HEAD(device_list);
  93 static DEFINE_MUTEX(device_list_lock);
  94
  95 static unsigned bufsiz = 4096;
  96 module_param(bufsiz, uint, S_IRUGO);
  97 MODULE_PARM_DESC(bufsiz, "data bytes in biggest supported SPI message");
  98
  99 /*-------------------------------------------------------------------------*/
 100
 101 /*
 102  * We can't use the standard synchronous wrappers for file I/O; we
 103  * need to protect against async removal of the underlying spi_device.
 104  */
 105 static void spidev_complete(void *arg)
 106 {
 107         complete(arg);
 108 }
 109
 110 static ssize_t
 111 spidev_sync(struct spidev_data *spidev, struct spi_message *message)
 112 {
 113         DECLARE_COMPLETION_ONSTACK(done);
 114         int status;
 115
 116         message->complete = spidev_complete;
 117         message->context = &done;
 118
 119         spin_lock_irq(&spidev->spi_lock);
 120         if (spidev->spi == NULL)
 121                 status = -ESHUTDOWN;
 122         else
 123                 status = spi_async(spidev->spi, message);
 124         spin_unlock_irq(&spidev->spi_lock);
 125
 126         if (status == 0) {
 127                 wait_for_completion(&done);
 128                 status = message->status;
 129                 if (status == 0)
 130                         status = message->actual_length;
 131         }
 132         return status;
 133 }
 134
 135 static inline ssize_t
 136 spidev_sync_write(struct spidev_data *spidev, size_t len)
 137 {
 138         struct spi_transfer     t = {
 139                         .tx_buf         = spidev->tx_buffer,
 140                         .len            = len,
 141                 };
 142         struct spi_message      m;
 143
 144         spi_message_init(&m);
 145         spi_message_add_tail(&t, &m);
 146         return spidev_sync(spidev, &m);
 147 }
 148
 149 static inline ssize_t
 150 spidev_sync_read(struct spidev_data *spidev, size_t len)
 151 {
 152         struct spi_transfer     t = {
 153                         .rx_buf         = spidev->rx_buffer,
 154                         .len            = len,
 155                 };
 156         struct spi_message      m;
 157
 158         spi_message_init(&m);
 159         spi_message_add_tail(&t, &m);
 160         return spidev_sync(spidev, &m);
 161 }
 162
 163 /*-------------------------------------------------------------------------*/
 164
 165 /* Read-only message with current device setup */
 166 static ssize_t
 167 spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
 168 {
 169         struct spidev_data      *spidev;
 170         ssize_t                 status = 0;
 171
 172         /* chipselect only toggles at start or end of operation */
 173         if (count > bufsiz)
 174                 return -EMSGSIZE;
 175
 176         spidev = filp->private_data;
 177
 178         mutex_lock(&spidev->buf_lock);
 179         status = spidev_sync_read(spidev, count);
 180         if (status > 0) {
 181                 unsigned long   missing;
 182
 183                 missing = copy_to_user(buf, spidev->rx_buffer, status);
 184                 if (missing == status)
 185                         status = -EFAULT;
 186                 else
 187                         status = status - missing;
 188         }
 189         mutex_unlock(&spidev->buf_lock);
 190
 191         return status;
 192 }
 193
 194 /* Write-only message with current device setup */
 195 static ssize_t
 196 spidev_write(struct file *filp, const char __user *buf,
 197                 size_t count, loff_t *f_pos)
 198 {
 199         struct spidev_data      *spidev;
 200         ssize_t                 status = 0;
 201         unsigned long           missing;
 202
 203         /* chipselect only toggles at start or end of operation */
 204         if (count > bufsiz)
 205                 return -EMSGSIZE;
 206
 207         spidev = filp->private_data;
 208
 209         mutex_lock(&spidev->buf_lock);
 210         missing = copy_from_user(spidev->tx_buffer, buf, count);
 211         if (missing == 0)
 212                 status = spidev_sync_write(spidev, count);
 213         else
 214                 status = -EFAULT;
 215         mutex_unlock(&spidev->buf_lock);
 216
 217         return status;
 218 }
 219
 220 static int spidev_message(struct spidev_data *spidev,
 221                 struct spi_ioc_transfer *u_xfers, unsigned n_xfers)
 222 {
 223         struct spi_message      msg;
 224         struct spi_transfer     *k_xfers;
 225         struct spi_transfer     *k_tmp;
 226         struct spi_ioc_transfer *u_tmp;
 227         unsigned                n, total;
 228         u8                      *tx_buf, *rx_buf;
 229         int                     status = -EFAULT;
 230
 231         spi_message_init(&msg);
 232         k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL);
 233         if (k_xfers == NULL)
 234                 return -ENOMEM;
 235
 236         /* Construct spi_message, copying any tx data to bounce buffer.
 237          * We walk the array of user-provided transfers, using each one
 238          * to initialize a kernel version of the same transfer.
 239          */
 240         tx_buf = spidev->tx_buffer;
 241         rx_buf = spidev->rx_buffer;
 242         total = 0;
 243         for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;
 244                         n;
 245                         n--, k_tmp++, u_tmp++) {
 246                 k_tmp->len = u_tmp->len;
 247
 248                 total += k_tmp->len;
 249                 if (total > bufsiz) {
 250                         status = -EMSGSIZE;
 251                         goto done;
 252                 }
 253
 254                 if (u_tmp->rx_buf) {
 255                         k_tmp->rx_buf = rx_buf;
 256                         if (!access_ok(VERIFY_WRITE, (u8 __user *)
 257                                                 (uintptr_t) u_tmp->rx_buf,
 258                                                 u_tmp->len))
 259                                 goto done;
 260                 }
 261                 if (u_tmp->tx_buf) {
 262                         k_tmp->tx_buf = tx_buf;
 263                         if (copy_from_user(tx_buf, (const u8 __user *)
 264                                                 (uintptr_t) u_tmp->tx_buf,
 265                                         u_tmp->len))
 266                                 goto done;
 267                 }
 268                 tx_buf += k_tmp->len;
 269                 rx_buf += k_tmp->len;
 270
 271                 k_tmp->cs_change = !!u_tmp->cs_change;
 272                 k_tmp->tx_nbits = u_tmp->tx_nbits;
 273                 k_tmp->rx_nbits = u_tmp->rx_nbits;
 274                 k_tmp->bits_per_word = u_tmp->bits_per_word;
 275                 k_tmp->delay_usecs = u_tmp->delay_usecs;
 276                 k_tmp->speed_hz = u_tmp->speed_hz;
 277 #ifdef VERBOSE
 278                 dev_dbg(&spidev->spi->dev,
 279                         "  xfer len %zd %s%s%s%dbits %u usec %uHz\n",
 280                         u_tmp->len,
 281                         u_tmp->rx_buf ? "rx " : "",
 282                         u_tmp->tx_buf ? "tx " : "",
 283                         u_tmp->cs_change ? "cs " : "",
 284                         u_tmp->bits_per_word ? : spidev->spi->bits_per_word,
 285                         u_tmp->delay_usecs,
 286                         u_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                 }
 306                 rx_buf += u_tmp->len;
 307         }
 308         status = total;
 309
 310 done:
 311         kfree(k_xfers);
 312         return status;
 313 }
 314
 315 static long
 316 spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 317 {
 318         int                     err = 0;
 319         int                     retval = 0;
 320         struct spidev_data      *spidev;
 321         struct spi_device       *spi;
 322         u32                     tmp;
 323         unsigned                n_ioc;
 324         struct spi_ioc_transfer *ioc;
 325
 326         /* Check type and command number */
 327         if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)
 328                 return -ENOTTY;
 329
 330         /* Check access direction once here; don't repeat below.
 331          * IOC_DIR is from the user perspective, while access_ok is
 332          * from the kernel perspective; so they look reversed.
 333          */
 334         if (_IOC_DIR(cmd) & _IOC_READ)
 335                 err = !access_ok(VERIFY_WRITE,
 336                                 (void __user *)arg, _IOC_SIZE(cmd));
 337         if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE)
 338                 err = !access_ok(VERIFY_READ,
 339                                 (void __user *)arg, _IOC_SIZE(cmd));
 340         if (err)
 341                 return -EFAULT;
 342
 343         /* guard against device removal before, or while,
 344          * we issue this ioctl.
 345          */
 346         spidev = filp->private_data;
 347         spin_lock_irq(&spidev->spi_lock);
 348         spi = spi_dev_get(spidev->spi);
 349         spin_unlock_irq(&spidev->spi_lock);
 350
 351         if (spi == NULL)
 352                 return -ESHUTDOWN;
 353
 354         /* use the buffer lock here for triple duty:
 355          *  - prevent I/O (from us) so calling spi_setup() is safe;
 356          *  - prevent concurrent SPI_IOC_WR_* from morphing
 357          *    data fields while SPI_IOC_RD_* reads them;
 358          *  - SPI_IOC_MESSAGE needs the buffer locked "normally".
 359          */
 360         mutex_lock(&spidev->buf_lock);
 361
 362         switch (cmd) {
 363         /* read requests */
 364         case SPI_IOC_RD_MODE:
 365                 retval = __put_user(spi->mode & SPI_MODE_MASK,
 366                                         (__u8 __user *)arg);
 367                 break;
 368         case SPI_IOC_RD_MODE32:
 369                 retval = __put_user(spi->mode & SPI_MODE_MASK,
 370                                         (__u32 __user *)arg);
 371                 break;
 372         case SPI_IOC_RD_LSB_FIRST:
 373                 retval = __put_user((spi->mode & SPI_LSB_FIRST) ?  1 : 0,
 374                                         (__u8 __user *)arg);
 375                 break;
 376         case SPI_IOC_RD_BITS_PER_WORD:
 377                 retval = __put_user(spi->bits_per_word, (__u8 __user *)arg);
 378                 break;
 379         case SPI_IOC_RD_MAX_SPEED_HZ:
 380                 retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg);
 381                 break;
 382
 383         /* write requests */
 384         case SPI_IOC_WR_MODE:
 385         case SPI_IOC_WR_MODE32:
 386                 if (cmd == SPI_IOC_WR_MODE)
 387                         retval = __get_user(tmp, (u8 __user *)arg);
 388                 else
 389                         retval = __get_user(tmp, (u32 __user *)arg);
 390                 if (retval == 0) {
 391                         u32     save = spi->mode;
 392
 393                         if (tmp & ~SPI_MODE_MASK) {
 394                                 retval = -EINVAL;
 395                                 break;
 396                         }
 397
 398                         tmp |= spi->mode & ~SPI_MODE_MASK;
 399                         spi->mode = (u16)tmp;
 400                         retval = spi_setup(spi);
 401                         if (retval < 0)
 402                                 spi->mode = save;
 403                         else
 404                                 dev_dbg(&spi->dev, "spi mode %x\n", tmp);
 405                 }
 406                 break;
 407         case SPI_IOC_WR_LSB_FIRST:
 408                 retval = __get_user(tmp, (__u8 __user *)arg);
 409                 if (retval == 0) {
 410                         u32     save = spi->mode;
 411
 412                         if (tmp)
 413                                 spi->mode |= SPI_LSB_FIRST;
 414                         else
 415                                 spi->mode &= ~SPI_LSB_FIRST;
 416                         retval = spi_setup(spi);
 417                         if (retval < 0)
 418                                 spi->mode = save;
 419                         else
 420                                 dev_dbg(&spi->dev, "%csb first\n",
 421                                                 tmp ? 'l' : 'm');
 422                 }
 423                 break;
 424         case SPI_IOC_WR_BITS_PER_WORD:
 425                 retval = __get_user(tmp, (__u8 __user *)arg);
 426                 if (retval == 0) {
 427                         u8      save = spi->bits_per_word;
 428
 429                         spi->bits_per_word = tmp;
 430                         retval = spi_setup(spi);
 431                         if (retval < 0)
 432                                 spi->bits_per_word = save;
 433                         else
 434                                 dev_dbg(&spi->dev, "%d bits per word\n", tmp);
 435                 }
 436                 break;
 437         case SPI_IOC_WR_MAX_SPEED_HZ:
 438                 retval = __get_user(tmp, (__u32 __user *)arg);
 439                 if (retval == 0) {
 440                         u32     save = spi->max_speed_hz;
 441
 442                         spi->max_speed_hz = tmp;
 443                         retval = spi_setup(spi);
 444                         if (retval < 0)
 445                                 spi->max_speed_hz = save;
 446                         else
 447                                 dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);
 448                 }
 449                 break;
 450
 451         default:
 452                 /* segmented and/or full-duplex I/O request */
 453                 if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))
 454                                 || _IOC_DIR(cmd) != _IOC_WRITE) {
 455                         retval = -ENOTTY;
 456                         break;
 457                 }
 458
 459                 tmp = _IOC_SIZE(cmd);
 460                 if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) {
 461                         retval = -EINVAL;
 462                         break;
 463                 }
 464                 n_ioc = tmp / sizeof(struct spi_ioc_transfer);
 465                 if (n_ioc == 0)
 466                         break;
 467
 468                 /* copy into scratch area */
 469                 ioc = kmalloc(tmp, GFP_KERNEL);
 470                 if (!ioc) {
 471                         retval = -ENOMEM;
 472                         break;
 473                 }
 474                 if (__copy_from_user(ioc, (void __user *)arg, tmp)) {
 475                         kfree(ioc);
 476                         retval = -EFAULT;
 477                         break;
 478                 }
 479
 480                 /* translate to spi_message, execute */
 481                 retval = spidev_message(spidev, ioc, n_ioc);
 482                 kfree(ioc);
 483                 break;
 484         }
 485
 486         mutex_unlock(&spidev->buf_lock);
 487         spi_dev_put(spi);
 488         return retval;
 489 }
 490
 491 #ifdef CONFIG_COMPAT
 492 static long
 493 spidev_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 494 {
 495         return spidev_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
 496 }
 497 #else
 498 #define spidev_compat_ioctl NULL
 499 #endif /* CONFIG_COMPAT */
 500
 501 static int spidev_open(struct inode *inode, struct file *filp)
 502 {
 503         struct spidev_data      *spidev;
 504         int                     status = -ENXIO;
 505
 506         mutex_lock(&device_list_lock);
 507
 508         list_for_each_entry(spidev, &device_list, device_entry) {
 509                 if (spidev->devt == inode->i_rdev) {
 510                         status = 0;
 511                         break;
 512                 }
 513         }
 514
 515         if (status) {
 516                 pr_debug("spidev: nothing for minor %d\n", iminor(inode));
 517                 goto err_find_dev;
 518         }
 519
 520         if (!spidev->tx_buffer) {
 521                 spidev->tx_buffer = kmalloc(bufsiz, GFP_KERNEL);
 522                 if (!spidev->tx_buffer) {
 523                                 dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
 524                                 status = -ENOMEM;
 525                         goto err_find_dev;
 526                         }
 527                 }
 528
 529         if (!spidev->rx_buffer) {
 530                 spidev->rx_buffer = kmalloc(bufsiz, GFP_KERNEL);
 531                 if (!spidev->rx_buffer) {
 532                         dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
 533                         status = -ENOMEM;
 534                         goto err_alloc_rx_buf;
 535                 }
 536         }
 537
 538         spidev->users++;
 539         filp->private_data = spidev;
 540         nonseekable_open(inode, filp);
 541
 542         mutex_unlock(&device_list_lock);
 543         return 0;
 544
 545 err_alloc_rx_buf:
 546         kfree(spidev->tx_buffer);
 547         spidev->tx_buffer = NULL;
 548 err_find_dev:
 549         mutex_unlock(&device_list_lock);
 550         return status;
 551 }
 552
 553 static int spidev_release(struct inode *inode, struct file *filp)
 554 {
 555         struct spidev_data      *spidev;
 556         int                     status = 0;
 557
 558         mutex_lock(&device_list_lock);
 559         spidev = filp->private_data;
 560         filp->private_data = NULL;
 561
 562         /* last close? */
 563         spidev->users--;
 564         if (!spidev->users) {
 565                 int             dofree;
 566
 567                 kfree(spidev->tx_buffer);
 568                 spidev->tx_buffer = NULL;
 569
 570                 kfree(spidev->rx_buffer);
 571                 spidev->rx_buffer = NULL;
 572
 573                 /* ... after we unbound from the underlying device? */
 574                 spin_lock_irq(&spidev->spi_lock);
 575                 dofree = (spidev->spi == NULL);
 576                 spin_unlock_irq(&spidev->spi_lock);
 577
 578                 if (dofree)
 579                         kfree(spidev);
 580         }
 581         mutex_unlock(&device_list_lock);
 582
 583         return status;
 584 }
 585
 586 static const struct file_operations spidev_fops = {
 587         .owner =        THIS_MODULE,
 588         /* REVISIT switch to aio primitives, so that userspace
 589          * gets more complete API coverage.  It'll simplify things
 590          * too, except for the locking.
 591          */
 592         .write =        spidev_write,
 593         .read =         spidev_read,
 594         .unlocked_ioctl = spidev_ioctl,
 595         .compat_ioctl = spidev_compat_ioctl,
 596         .open =         spidev_open,
 597         .release =      spidev_release,
 598         .llseek =       no_llseek,
 599 };
 600
 601 /*-------------------------------------------------------------------------*/
 602
 603 /* The main reason to have this class is to make mdev/udev create the
 604  * /dev/spidevB.C character device nodes exposing our userspace API.
 605  * It also simplifies memory management.
 606  */
 607
 608 static struct class *spidev_class;
 609
 610 /*-------------------------------------------------------------------------*/
 611
 612 static int spidev_probe(struct spi_device *spi)
 613 {
 614         struct spidev_data      *spidev;
 615         int                     status;
 616         unsigned long           minor;
 617
 618         /* Allocate driver data */
 619         spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
 620         if (!spidev)
 621                 return -ENOMEM;
 622
 623         /* Initialize the driver data */
 624         spidev->spi = spi;
 625         spin_lock_init(&spidev->spi_lock);
 626         mutex_init(&spidev->buf_lock);
 627
 628         INIT_LIST_HEAD(&spidev->device_entry);
 629
 630         /* If we can allocate a minor number, hook up this device.
 631          * Reusing minors is fine so long as udev or mdev is working.
 632          */
 633         mutex_lock(&device_list_lock);
 634         minor = find_first_zero_bit(minors, N_SPI_MINORS);
 635         if (minor < N_SPI_MINORS) {
 636                 struct device *dev;
 637
 638                 spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
 639                 dev = device_create(spidev_class, &spi->dev, spidev->devt,
 640                                     spidev, "spidev%d.%d",
 641                                     spi->master->bus_num, spi->chip_select);
 642                 status = PTR_ERR_OR_ZERO(dev);
 643         } else {
 644                 dev_dbg(&spi->dev, "no minor number available!\n");
 645                 status = -ENODEV;
 646         }
 647         if (status == 0) {
 648                 set_bit(minor, minors);
 649                 list_add(&spidev->device_entry, &device_list);
 650         }
 651         mutex_unlock(&device_list_lock);
 652
 653         if (status == 0)
 654                 spi_set_drvdata(spi, spidev);
 655         else
 656                 kfree(spidev);
 657
 658         return status;
 659 }
 660
 661 static int spidev_remove(struct spi_device *spi)
 662 {
 663         struct spidev_data      *spidev = spi_get_drvdata(spi);
 664
 665         /* make sure ops on existing fds can abort cleanly */
 666         spin_lock_irq(&spidev->spi_lock);
 667         spidev->spi = NULL;
 668         spin_unlock_irq(&spidev->spi_lock);
 669
 670         /* prevent new opens */
 671         mutex_lock(&device_list_lock);
 672         list_del(&spidev->device_entry);
 673         device_destroy(spidev_class, spidev->devt);
 674         clear_bit(MINOR(spidev->devt), minors);
 675         if (spidev->users == 0)
 676                 kfree(spidev);
 677         mutex_unlock(&device_list_lock);
 678
 679         return 0;
 680 }
 681
 682 static const struct of_device_id spidev_dt_ids[] = {
 683         { .compatible = "rohm,dh2228fv" },
 684         {},
 685 };
 686
 687 MODULE_DEVICE_TABLE(of, spidev_dt_ids);
 688
 689 static struct spi_driver spidev_spi_driver = {
 690         .driver = {
 691                 .name =         "spidev",
 692                 .owner =        THIS_MODULE,
 693                 .of_match_table = of_match_ptr(spidev_dt_ids),
 694         },
 695         .probe =        spidev_probe,
 696         .remove =       spidev_remove,
 697
 698         /* NOTE:  suspend/resume methods are not necessary here.
 699          * We don't do anything except pass the requests to/from
 700          * the underlying controller.  The refrigerator handles
 701          * most issues; the controller driver handles the rest.
 702          */
 703 };
 704
 705 /*-------------------------------------------------------------------------*/
 706
 707 static int __init spidev_init(void)
 708 {
 709         int status;
 710
 711         /* Claim our 256 reserved device numbers.  Then register a class
 712          * that will key udev/mdev to add/remove /dev nodes.  Last, register
 713          * the driver which manages those device numbers.
 714          */
 715         BUILD_BUG_ON(N_SPI_MINORS > 256);
 716         status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
 717         if (status < 0)
 718                 return status;
 719
 720         spidev_class = class_create(THIS_MODULE, "spidev");
 721         if (IS_ERR(spidev_class)) {
 722                 unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
 723                 return PTR_ERR(spidev_class);
 724         }
 725
 726         status = spi_register_driver(&spidev_spi_driver);
 727         if (status < 0) {
 728                 class_destroy(spidev_class);
 729                 unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
 730         }
 731         return status;
 732 }
 733 module_init(spidev_init);
 734
 735 static void __exit spidev_exit(void)
 736 {
 737         spi_unregister_driver(&spidev_spi_driver);
 738         class_destroy(spidev_class);
 739         unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
 740 }
 741 module_exit(spidev_exit);
 742
 743 MODULE_AUTHOR("Andrea Paterniani, <[email protected]>");
 744 MODULE_DESCRIPTION("User mode SPI device interface");
 745 MODULE_LICENSE("GPL");
 746 MODULE_ALIAS("spi:spidev");