spi.c

pxa3xx ssp driver for linux

 static void spi_master_release(struct class_device *cdev)
 {
         struct spi_master *master;
 
         master = container_of(cdev, struct spi_master, cdev);
         kfree(master);
 }
 
 static struct class spi_master_class = {
         .name           = "spi_master",
         .owner          = THIS_MODULE,
         .release        = spi_master_release,
 };
 
 
 /**
338  * spi_alloc_master - allocate SPI master controller
339  * @dev: the controller, possibly using the platform_bus
340  * @size: how much driver-private data to preallocate; the pointer to this
341  *      memory is in the class_data field of the returned class_device,
342  *      accessible with spi_master_get_devdata().
343  *
344  * This call is used only by SPI master controller drivers, which are the
345  * only ones directly touching chip registers.  It's how they allocate
346  * an spi_master structure, prior to calling spi_register_master().
347  *
348  * This must be called from context that can sleep.  It returns the SPI
349  * master structure on success, else NULL.
350  *
351  * The caller is responsible for assigning the bus number and initializing
352  * the master's methods before calling spi_register_master(); and (after errors
353  * adding the device) calling spi_master_put() to prevent a memory leak.
354  */
 struct spi_master * __init_or_module
 spi_alloc_master(struct device *dev, unsigned size)
 {
         struct spi_master       *master;
 
         if (!dev)
                 return NULL;
 
         master = kzalloc(size + sizeof *master, SLAB_KERNEL);
         if (!master)
                 return NULL;
 
         class_device_initialize(&master->cdev);
         master->cdev.class = &spi_master_class;
         master->cdev.dev = get_device(dev);
         spi_master_set_devdata(master, &master[1]);
 
         return master;
 }
 EXPORT_SYMBOL_GPL(spi_alloc_master);
 
 /**
377  * spi_register_master - register SPI master controller
378  * @master: initialized master, originally from spi_alloc_master()
379  *
380  * SPI master controllers connect to their drivers using some non-SPI bus,
381  * such as the platform bus.  The final stage of probe() in that code
382  * includes calling spi_register_master() to hook up to this SPI bus glue.
383  *
384  * SPI controllers use board specific (often SOC specific) bus numbers,
385  * and board-specific addressing for SPI devices combines those numbers
386  * with chip select numbers.  Since SPI does not directly support dynamic
387  * device identification, boards need configuration tables telling which
388  * chip is at which address.
389  *
390  * This must be called from context that can sleep.  It returns zero on
391  * success, else a negative error code (dropping the master's refcount).
392  * After a successful return, the caller is responsible for calling
393  * spi_unregister_master().
394  */
 int __init_or_module
 spi_register_master(struct spi_master *master)
 {
         static atomic_t         dyn_bus_id = ATOMIC_INIT((1<<16) - 1);
         struct device           *dev = master->cdev.dev;
         int                     status = -ENODEV;
         int                     dynamic = 0;
 
         if (!dev)
                 return -ENODEV;
 
         /* convention:  dynamically assigned bus IDs count down from the max */
         if (master->bus_num < 0) {
                 master->bus_num = atomic_dec_return(&dyn_bus_id);
                 dynamic = 1;
         }
 
         /* register the device, then userspace will see it.
413          * registration fails if the bus ID is in use.
414          */
         snprintf(master->cdev.class_id, sizeof master->cdev.class_id,
                 "spi%u", master->bus_num);
         status = class_device_add(&master->cdev);
         if (status < 0)
                 goto done;
         dev_dbg(dev, "registered master %s%s\n", master->cdev.class_id,
                         dynamic ? " (dynamic)" : "");
 
         /* populate children from any spi device tables */
         scan_boardinfo(master);
         status = 0;
 done:
         return status;
 }
 EXPORT_SYMBOL_GPL(spi_register_master);
 
 
 static int __unregister(struct device *dev, void *unused)
 {
         /* note: before about 2.6.14-rc1 this would corrupt memory: */
         spi_unregister_device(to_spi_device(dev));
         return 0;
 }
 
 /**
440  * spi_unregister_master - unregister SPI master controller
441  * @master: the master being unregistered
442  *
443  * This call is used only by SPI master controller drivers, which are the
444  * only ones directly touching chip registers.
445  *
446  * This must be called from context that can sleep.
447  */
 void spi_unregister_master(struct spi_master *master)
 {
         (void) device_for_each_child(master->cdev.dev, NULL, __unregister);
         class_device_unregister(&master->cdev);
 }
 EXPORT_SYMBOL_GPL(spi_unregister_master);
 
 /**
456  * spi_busnum_to_master - look up master associated with bus_num
457  * @bus_num: the master's bus number
458  *
459  * This call may be used with devices that are registered after
460  * arch init time.  It returns a refcounted pointer to the relevant
461  * spi_master (which the caller must release), or NULL if there is
462  * no such master registered.
463  */
 struct spi_master *spi_busnum_to_master(u16 bus_num)
 {
         if (bus_num) {
                 char                    name[8];
                 struct kobject          *bus;
 
                 snprintf(name, sizeof name, "spi%u", bus_num);
                 bus = kset_find_obj(&spi_master_class.subsys.kset, name);
                 if (bus)
                         return container_of(bus, struct spi_master, cdev.kobj);
         }
         return NULL;
 }
 EXPORT_SYMBOL_GPL(spi_busnum_to_master);
 
 
 /*-------------------------------------------------------------------------*/
 
 static void spi_complete(void *arg)
 {
         complete(arg);
 }
 
 /**
488  * spi_sync - blocking/synchronous SPI data transfers
489  * @spi: device with which data will be exchanged
490  * @message: describes the data transfers
491  *
492  * This call may only be used from a context that may sleep.  The sleep
493  * is non-interruptible, and has no timeout.  Low-overhead controller
494  * drivers may DMA directly into and out of the message buffers.
495  *
496  * Note that the SPI device's chip select is active during the message,
497  * and then is normally disabled between messages.  Drivers for some
498  * frequently-used devices may want to minimize costs of selecting a chip,
499  * by leaving it selected in anticipation that the next message will go
500  * to the same chip.  (That may increase power usage.)
501  *
502  * Also, the caller is guaranteeing that the memory associated with the
503  * message will not be freed before this call returns.
504  *
505  * The return value is a negative error code if the message could not be
506  * submitted, else zero.  When the value is zero, then message->status is
507  * also defined:  it's the completion code for the transfer, either zero
508  * or a negative error code from the controller driver.
509  */
 int spi_sync(struct spi_device *spi, struct spi_message *message)
 {
         DECLARE_COMPLETION(done);
         int status;
 
         message->complete = spi_complete;
         message->context = &done;
         status = spi_async(spi, message);
         if (status == 0)
                 wait_for_completion(&done);
         message->context = NULL;
         return status;
 }
 EXPORT_SYMBOL_GPL(spi_sync);
 
 /* portable code must never pass more than 32 bytes */
 #define SPI_BUFSIZ      max(32,SMP_CACHE_BYTES)
 
 static u8       *buf;
 
 /**
531  * spi_write_then_read - SPI synchronous write followed by read
532  * @spi: device with which data will be exchanged
533  * @txbuf: data to be written (need not be dma-safe)
534  * @n_tx: size of txbuf, in bytes
535  * @rxbuf: buffer into which data will be read
536  * @n_rx: size of rxbuf, in bytes (need not be dma-safe)
537  *
538  * This performs a half duplex MicroWire style transaction with the
539  * device, sending txbuf and then reading rxbuf.  The return value
540  * is zero for success, else a negative errno status code.
541  * This call may only be used from a context that may sleep.
542  *
543  * Parameters to this routine are always copied using a small buffer;
544  * performance-sensitive or bulk transfer code should instead use
545  * spi_{async,sync}() calls with dma-safe buffers.
546  */
 int spi_write_then_read(struct spi_device *spi,
                 const u8 *txbuf, unsigned n_tx,
                 u8 *rxbuf, unsigned n_rx)
 {
         static DECLARE_MUTEX(lock);
 
         int                     status;
         struct spi_message      message;
         struct spi_transfer     x[2];
         u8                      *local_buf;
 
         /* Use preallocated DMA-safe buffer.  We can't avoid copying here,
559          * (as a pure convenience thing), but we can keep heap costs
560          * out of the hot path ...
561          */
         if ((n_tx + n_rx) > SPI_BUFSIZ)
                 return -EINVAL;
 
         spi_message_init(&message);
         memset(x, 0, sizeof x);
         if (n_tx) {
                 x[0].len = n_tx;
                 spi_message_add_tail(&x[0], &message);
         }
         if (n_rx) {
                 x[1].len = n_rx;
                 spi_message_add_tail(&x[1], &message);
         }
 
         /* ... unless someone else is using the pre-allocated buffer */
         if (down_trylock(&lock)) {
                 local_buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
                 if (!local_buf)
                         return -ENOMEM;
         } else
                 local_buf = buf;
 
         memcpy(local_buf, txbuf, n_tx);
         x[0].tx_buf = local_buf;
         x[1].rx_buf = local_buf + n_tx;
 
         /* do the i/o */
         status = spi_sync(spi, &message);
         if (status == 0) {
                 memcpy(rxbuf, x[1].rx_buf, n_rx);
                 status = message.status;
         }
 
         if (x[0].tx_buf == buf)
                 up(&lock);
         else
                 kfree(local_buf);
 
         return status;
 }
 EXPORT_SYMBOL_GPL(spi_write_then_read);
 
 /*-------------------------------------------------------------------------*/
 
 static int __init spi_init(void)
 {
         int     status;
 
         buf = kmalloc(SPI_BUFSIZ, SLAB_KERNEL);
         if (!buf) {
                 status = -ENOMEM;
                 goto err0;
         }
 
         status = bus_register(&spi_bus_type);
         if (status < 0)
                 goto err1;
 
         status = class_register(&spi_master_class);
         if (status < 0)
                 goto err2;
         return 0;
 
err2:
         bus_unregister(&spi_bus_type);
err1:
         kfree(buf);
         buf = NULL;
 err0:
         return status;
 }
 
 /* board_info is normally registered in arch_initcall(),
635  * but even essential drivers wait till later
636  *
637  * REVISIT only boardinfo really needs static linking. the rest (device and
638  * driver registration) _could_ be dynamically linked (modular) ... costs
639  * include needing to have boardinfo data structures be much more public.
640  */
 subsys_initcall(spi_init);