drivers/spi/spidev.c

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