drivers/spi/spidev.c

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