Merge tag 'dt-for-linus' of git://git.secretlab.ca/git/linux-2.6
[~shefty/rdma-dev.git] / include / linux / spi / spi.h
1 /*
2  * Copyright (C) 2005 David Brownell
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #ifndef __LINUX_SPI_H
20 #define __LINUX_SPI_H
21
22 #include <linux/device.h>
23 #include <linux/mod_devicetable.h>
24 #include <linux/slab.h>
25
26 /*
27  * INTERFACES between SPI master-side drivers and SPI infrastructure.
28  * (There's no SPI slave support for Linux yet...)
29  */
30 extern struct bus_type spi_bus_type;
31
32 /**
33  * struct spi_device - Master side proxy for an SPI slave device
34  * @dev: Driver model representation of the device.
35  * @master: SPI controller used with the device.
36  * @max_speed_hz: Maximum clock rate to be used with this chip
37  *      (on this board); may be changed by the device's driver.
38  *      The spi_transfer.speed_hz can override this for each transfer.
39  * @chip_select: Chipselect, distinguishing chips handled by @master.
40  * @mode: The spi mode defines how data is clocked out and in.
41  *      This may be changed by the device's driver.
42  *      The "active low" default for chipselect mode can be overridden
43  *      (by specifying SPI_CS_HIGH) as can the "MSB first" default for
44  *      each word in a transfer (by specifying SPI_LSB_FIRST).
45  * @bits_per_word: Data transfers involve one or more words; word sizes
46  *      like eight or 12 bits are common.  In-memory wordsizes are
47  *      powers of two bytes (e.g. 20 bit samples use 32 bits).
48  *      This may be changed by the device's driver, or left at the
49  *      default (0) indicating protocol words are eight bit bytes.
50  *      The spi_transfer.bits_per_word can override this for each transfer.
51  * @irq: Negative, or the number passed to request_irq() to receive
52  *      interrupts from this device.
53  * @controller_state: Controller's runtime state
54  * @controller_data: Board-specific definitions for controller, such as
55  *      FIFO initialization parameters; from board_info.controller_data
56  * @modalias: Name of the driver to use with this device, or an alias
57  *      for that name.  This appears in the sysfs "modalias" attribute
58  *      for driver coldplugging, and in uevents used for hotplugging
59  *
60  * A @spi_device is used to interchange data between an SPI slave
61  * (usually a discrete chip) and CPU memory.
62  *
63  * In @dev, the platform_data is used to hold information about this
64  * device that's meaningful to the device's protocol driver, but not
65  * to its controller.  One example might be an identifier for a chip
66  * variant with slightly different functionality; another might be
67  * information about how this particular board wires the chip's pins.
68  */
69 struct spi_device {
70         struct device           dev;
71         struct spi_master       *master;
72         u32                     max_speed_hz;
73         u8                      chip_select;
74         u8                      mode;
75 #define SPI_CPHA        0x01                    /* clock phase */
76 #define SPI_CPOL        0x02                    /* clock polarity */
77 #define SPI_MODE_0      (0|0)                   /* (original MicroWire) */
78 #define SPI_MODE_1      (0|SPI_CPHA)
79 #define SPI_MODE_2      (SPI_CPOL|0)
80 #define SPI_MODE_3      (SPI_CPOL|SPI_CPHA)
81 #define SPI_CS_HIGH     0x04                    /* chipselect active high? */
82 #define SPI_LSB_FIRST   0x08                    /* per-word bits-on-wire */
83 #define SPI_3WIRE       0x10                    /* SI/SO signals shared */
84 #define SPI_LOOP        0x20                    /* loopback mode */
85 #define SPI_NO_CS       0x40                    /* 1 dev/bus, no chipselect */
86 #define SPI_READY       0x80                    /* slave pulls low to pause */
87         u8                      bits_per_word;
88         int                     irq;
89         void                    *controller_state;
90         void                    *controller_data;
91         char                    modalias[SPI_NAME_SIZE];
92
93         /*
94          * likely need more hooks for more protocol options affecting how
95          * the controller talks to each chip, like:
96          *  - memory packing (12 bit samples into low bits, others zeroed)
97          *  - priority
98          *  - drop chipselect after each word
99          *  - chipselect delays
100          *  - ...
101          */
102 };
103
104 static inline struct spi_device *to_spi_device(struct device *dev)
105 {
106         return dev ? container_of(dev, struct spi_device, dev) : NULL;
107 }
108
109 /* most drivers won't need to care about device refcounting */
110 static inline struct spi_device *spi_dev_get(struct spi_device *spi)
111 {
112         return (spi && get_device(&spi->dev)) ? spi : NULL;
113 }
114
115 static inline void spi_dev_put(struct spi_device *spi)
116 {
117         if (spi)
118                 put_device(&spi->dev);
119 }
120
121 /* ctldata is for the bus_master driver's runtime state */
122 static inline void *spi_get_ctldata(struct spi_device *spi)
123 {
124         return spi->controller_state;
125 }
126
127 static inline void spi_set_ctldata(struct spi_device *spi, void *state)
128 {
129         spi->controller_state = state;
130 }
131
132 /* device driver data */
133
134 static inline void spi_set_drvdata(struct spi_device *spi, void *data)
135 {
136         dev_set_drvdata(&spi->dev, data);
137 }
138
139 static inline void *spi_get_drvdata(struct spi_device *spi)
140 {
141         return dev_get_drvdata(&spi->dev);
142 }
143
144 struct spi_message;
145
146
147
148 /**
149  * struct spi_driver - Host side "protocol" driver
150  * @id_table: List of SPI devices supported by this driver
151  * @probe: Binds this driver to the spi device.  Drivers can verify
152  *      that the device is actually present, and may need to configure
153  *      characteristics (such as bits_per_word) which weren't needed for
154  *      the initial configuration done during system setup.
155  * @remove: Unbinds this driver from the spi device
156  * @shutdown: Standard shutdown callback used during system state
157  *      transitions such as powerdown/halt and kexec
158  * @suspend: Standard suspend callback used during system state transitions
159  * @resume: Standard resume callback used during system state transitions
160  * @driver: SPI device drivers should initialize the name and owner
161  *      field of this structure.
162  *
163  * This represents the kind of device driver that uses SPI messages to
164  * interact with the hardware at the other end of a SPI link.  It's called
165  * a "protocol" driver because it works through messages rather than talking
166  * directly to SPI hardware (which is what the underlying SPI controller
167  * driver does to pass those messages).  These protocols are defined in the
168  * specification for the device(s) supported by the driver.
169  *
170  * As a rule, those device protocols represent the lowest level interface
171  * supported by a driver, and it will support upper level interfaces too.
172  * Examples of such upper levels include frameworks like MTD, networking,
173  * MMC, RTC, filesystem character device nodes, and hardware monitoring.
174  */
175 struct spi_driver {
176         const struct spi_device_id *id_table;
177         int                     (*probe)(struct spi_device *spi);
178         int                     (*remove)(struct spi_device *spi);
179         void                    (*shutdown)(struct spi_device *spi);
180         int                     (*suspend)(struct spi_device *spi, pm_message_t mesg);
181         int                     (*resume)(struct spi_device *spi);
182         struct device_driver    driver;
183 };
184
185 static inline struct spi_driver *to_spi_driver(struct device_driver *drv)
186 {
187         return drv ? container_of(drv, struct spi_driver, driver) : NULL;
188 }
189
190 extern int spi_register_driver(struct spi_driver *sdrv);
191
192 /**
193  * spi_unregister_driver - reverse effect of spi_register_driver
194  * @sdrv: the driver to unregister
195  * Context: can sleep
196  */
197 static inline void spi_unregister_driver(struct spi_driver *sdrv)
198 {
199         if (sdrv)
200                 driver_unregister(&sdrv->driver);
201 }
202
203 /**
204  * module_spi_driver() - Helper macro for registering a SPI driver
205  * @__spi_driver: spi_driver struct
206  *
207  * Helper macro for SPI drivers which do not do anything special in module
208  * init/exit. This eliminates a lot of boilerplate. Each module may only
209  * use this macro once, and calling it replaces module_init() and module_exit()
210  */
211 #define module_spi_driver(__spi_driver) \
212         module_driver(__spi_driver, spi_register_driver, \
213                         spi_unregister_driver)
214
215 /**
216  * struct spi_master - interface to SPI master controller
217  * @dev: device interface to this driver
218  * @list: link with the global spi_master list
219  * @bus_num: board-specific (and often SOC-specific) identifier for a
220  *      given SPI controller.
221  * @num_chipselect: chipselects are used to distinguish individual
222  *      SPI slaves, and are numbered from zero to num_chipselects.
223  *      each slave has a chipselect signal, but it's common that not
224  *      every chipselect is connected to a slave.
225  * @dma_alignment: SPI controller constraint on DMA buffers alignment.
226  * @mode_bits: flags understood by this controller driver
227  * @flags: other constraints relevant to this driver
228  * @bus_lock_spinlock: spinlock for SPI bus locking
229  * @bus_lock_mutex: mutex for SPI bus locking
230  * @bus_lock_flag: indicates that the SPI bus is locked for exclusive use
231  * @setup: updates the device mode and clocking records used by a
232  *      device's SPI controller; protocol code may call this.  This
233  *      must fail if an unrecognized or unsupported mode is requested.
234  *      It's always safe to call this unless transfers are pending on
235  *      the device whose settings are being modified.
236  * @transfer: adds a message to the controller's transfer queue.
237  * @cleanup: frees controller-specific state
238  *
239  * Each SPI master controller can communicate with one or more @spi_device
240  * children.  These make a small bus, sharing MOSI, MISO and SCK signals
241  * but not chip select signals.  Each device may be configured to use a
242  * different clock rate, since those shared signals are ignored unless
243  * the chip is selected.
244  *
245  * The driver for an SPI controller manages access to those devices through
246  * a queue of spi_message transactions, copying data between CPU memory and
247  * an SPI slave device.  For each such message it queues, it calls the
248  * message's completion function when the transaction completes.
249  */
250 struct spi_master {
251         struct device   dev;
252
253         struct list_head list;
254
255         /* other than negative (== assign one dynamically), bus_num is fully
256          * board-specific.  usually that simplifies to being SOC-specific.
257          * example:  one SOC has three SPI controllers, numbered 0..2,
258          * and one board's schematics might show it using SPI-2.  software
259          * would normally use bus_num=2 for that controller.
260          */
261         s16                     bus_num;
262
263         /* chipselects will be integral to many controllers; some others
264          * might use board-specific GPIOs.
265          */
266         u16                     num_chipselect;
267
268         /* some SPI controllers pose alignment requirements on DMAable
269          * buffers; let protocol drivers know about these requirements.
270          */
271         u16                     dma_alignment;
272
273         /* spi_device.mode flags understood by this controller driver */
274         u16                     mode_bits;
275
276         /* other constraints relevant to this driver */
277         u16                     flags;
278 #define SPI_MASTER_HALF_DUPLEX  BIT(0)          /* can't do full duplex */
279 #define SPI_MASTER_NO_RX        BIT(1)          /* can't do buffer read */
280 #define SPI_MASTER_NO_TX        BIT(2)          /* can't do buffer write */
281
282         /* lock and mutex for SPI bus locking */
283         spinlock_t              bus_lock_spinlock;
284         struct mutex            bus_lock_mutex;
285
286         /* flag indicating that the SPI bus is locked for exclusive use */
287         bool                    bus_lock_flag;
288
289         /* Setup mode and clock, etc (spi driver may call many times).
290          *
291          * IMPORTANT:  this may be called when transfers to another
292          * device are active.  DO NOT UPDATE SHARED REGISTERS in ways
293          * which could break those transfers.
294          */
295         int                     (*setup)(struct spi_device *spi);
296
297         /* bidirectional bulk transfers
298          *
299          * + The transfer() method may not sleep; its main role is
300          *   just to add the message to the queue.
301          * + For now there's no remove-from-queue operation, or
302          *   any other request management
303          * + To a given spi_device, message queueing is pure fifo
304          *
305          * + The master's main job is to process its message queue,
306          *   selecting a chip then transferring data
307          * + If there are multiple spi_device children, the i/o queue
308          *   arbitration algorithm is unspecified (round robin, fifo,
309          *   priority, reservations, preemption, etc)
310          *
311          * + Chipselect stays active during the entire message
312          *   (unless modified by spi_transfer.cs_change != 0).
313          * + The message transfers use clock and SPI mode parameters
314          *   previously established by setup() for this device
315          */
316         int                     (*transfer)(struct spi_device *spi,
317                                                 struct spi_message *mesg);
318
319         /* called on release() to free memory provided by spi_master */
320         void                    (*cleanup)(struct spi_device *spi);
321 };
322
323 static inline void *spi_master_get_devdata(struct spi_master *master)
324 {
325         return dev_get_drvdata(&master->dev);
326 }
327
328 static inline void spi_master_set_devdata(struct spi_master *master, void *data)
329 {
330         dev_set_drvdata(&master->dev, data);
331 }
332
333 static inline struct spi_master *spi_master_get(struct spi_master *master)
334 {
335         if (!master || !get_device(&master->dev))
336                 return NULL;
337         return master;
338 }
339
340 static inline void spi_master_put(struct spi_master *master)
341 {
342         if (master)
343                 put_device(&master->dev);
344 }
345
346
347 /* the spi driver core manages memory for the spi_master classdev */
348 extern struct spi_master *
349 spi_alloc_master(struct device *host, unsigned size);
350
351 extern int spi_register_master(struct spi_master *master);
352 extern void spi_unregister_master(struct spi_master *master);
353
354 extern struct spi_master *spi_busnum_to_master(u16 busnum);
355
356 /*---------------------------------------------------------------------------*/
357
358 /*
359  * I/O INTERFACE between SPI controller and protocol drivers
360  *
361  * Protocol drivers use a queue of spi_messages, each transferring data
362  * between the controller and memory buffers.
363  *
364  * The spi_messages themselves consist of a series of read+write transfer
365  * segments.  Those segments always read the same number of bits as they
366  * write; but one or the other is easily ignored by passing a null buffer
367  * pointer.  (This is unlike most types of I/O API, because SPI hardware
368  * is full duplex.)
369  *
370  * NOTE:  Allocation of spi_transfer and spi_message memory is entirely
371  * up to the protocol driver, which guarantees the integrity of both (as
372  * well as the data buffers) for as long as the message is queued.
373  */
374
375 /**
376  * struct spi_transfer - a read/write buffer pair
377  * @tx_buf: data to be written (dma-safe memory), or NULL
378  * @rx_buf: data to be read (dma-safe memory), or NULL
379  * @tx_dma: DMA address of tx_buf, if @spi_message.is_dma_mapped
380  * @rx_dma: DMA address of rx_buf, if @spi_message.is_dma_mapped
381  * @len: size of rx and tx buffers (in bytes)
382  * @speed_hz: Select a speed other than the device default for this
383  *      transfer. If 0 the default (from @spi_device) is used.
384  * @bits_per_word: select a bits_per_word other than the device default
385  *      for this transfer. If 0 the default (from @spi_device) is used.
386  * @cs_change: affects chipselect after this transfer completes
387  * @delay_usecs: microseconds to delay after this transfer before
388  *      (optionally) changing the chipselect status, then starting
389  *      the next transfer or completing this @spi_message.
390  * @transfer_list: transfers are sequenced through @spi_message.transfers
391  *
392  * SPI transfers always write the same number of bytes as they read.
393  * Protocol drivers should always provide @rx_buf and/or @tx_buf.
394  * In some cases, they may also want to provide DMA addresses for
395  * the data being transferred; that may reduce overhead, when the
396  * underlying driver uses dma.
397  *
398  * If the transmit buffer is null, zeroes will be shifted out
399  * while filling @rx_buf.  If the receive buffer is null, the data
400  * shifted in will be discarded.  Only "len" bytes shift out (or in).
401  * It's an error to try to shift out a partial word.  (For example, by
402  * shifting out three bytes with word size of sixteen or twenty bits;
403  * the former uses two bytes per word, the latter uses four bytes.)
404  *
405  * In-memory data values are always in native CPU byte order, translated
406  * from the wire byte order (big-endian except with SPI_LSB_FIRST).  So
407  * for example when bits_per_word is sixteen, buffers are 2N bytes long
408  * (@len = 2N) and hold N sixteen bit words in CPU byte order.
409  *
410  * When the word size of the SPI transfer is not a power-of-two multiple
411  * of eight bits, those in-memory words include extra bits.  In-memory
412  * words are always seen by protocol drivers as right-justified, so the
413  * undefined (rx) or unused (tx) bits are always the most significant bits.
414  *
415  * All SPI transfers start with the relevant chipselect active.  Normally
416  * it stays selected until after the last transfer in a message.  Drivers
417  * can affect the chipselect signal using cs_change.
418  *
419  * (i) If the transfer isn't the last one in the message, this flag is
420  * used to make the chipselect briefly go inactive in the middle of the
421  * message.  Toggling chipselect in this way may be needed to terminate
422  * a chip command, letting a single spi_message perform all of group of
423  * chip transactions together.
424  *
425  * (ii) When the transfer is the last one in the message, the chip may
426  * stay selected until the next transfer.  On multi-device SPI busses
427  * with nothing blocking messages going to other devices, this is just
428  * a performance hint; starting a message to another device deselects
429  * this one.  But in other cases, this can be used to ensure correctness.
430  * Some devices need protocol transactions to be built from a series of
431  * spi_message submissions, where the content of one message is determined
432  * by the results of previous messages and where the whole transaction
433  * ends when the chipselect goes intactive.
434  *
435  * The code that submits an spi_message (and its spi_transfers)
436  * to the lower layers is responsible for managing its memory.
437  * Zero-initialize every field you don't set up explicitly, to
438  * insulate against future API updates.  After you submit a message
439  * and its transfers, ignore them until its completion callback.
440  */
441 struct spi_transfer {
442         /* it's ok if tx_buf == rx_buf (right?)
443          * for MicroWire, one buffer must be null
444          * buffers must work with dma_*map_single() calls, unless
445          *   spi_message.is_dma_mapped reports a pre-existing mapping
446          */
447         const void      *tx_buf;
448         void            *rx_buf;
449         unsigned        len;
450
451         dma_addr_t      tx_dma;
452         dma_addr_t      rx_dma;
453
454         unsigned        cs_change:1;
455         u8              bits_per_word;
456         u16             delay_usecs;
457         u32             speed_hz;
458
459         struct list_head transfer_list;
460 };
461
462 /**
463  * struct spi_message - one multi-segment SPI transaction
464  * @transfers: list of transfer segments in this transaction
465  * @spi: SPI device to which the transaction is queued
466  * @is_dma_mapped: if true, the caller provided both dma and cpu virtual
467  *      addresses for each transfer buffer
468  * @complete: called to report transaction completions
469  * @context: the argument to complete() when it's called
470  * @actual_length: the total number of bytes that were transferred in all
471  *      successful segments
472  * @status: zero for success, else negative errno
473  * @queue: for use by whichever driver currently owns the message
474  * @state: for use by whichever driver currently owns the message
475  *
476  * A @spi_message is used to execute an atomic sequence of data transfers,
477  * each represented by a struct spi_transfer.  The sequence is "atomic"
478  * in the sense that no other spi_message may use that SPI bus until that
479  * sequence completes.  On some systems, many such sequences can execute as
480  * as single programmed DMA transfer.  On all systems, these messages are
481  * queued, and might complete after transactions to other devices.  Messages
482  * sent to a given spi_device are alway executed in FIFO order.
483  *
484  * The code that submits an spi_message (and its spi_transfers)
485  * to the lower layers is responsible for managing its memory.
486  * Zero-initialize every field you don't set up explicitly, to
487  * insulate against future API updates.  After you submit a message
488  * and its transfers, ignore them until its completion callback.
489  */
490 struct spi_message {
491         struct list_head        transfers;
492
493         struct spi_device       *spi;
494
495         unsigned                is_dma_mapped:1;
496
497         /* REVISIT:  we might want a flag affecting the behavior of the
498          * last transfer ... allowing things like "read 16 bit length L"
499          * immediately followed by "read L bytes".  Basically imposing
500          * a specific message scheduling algorithm.
501          *
502          * Some controller drivers (message-at-a-time queue processing)
503          * could provide that as their default scheduling algorithm.  But
504          * others (with multi-message pipelines) could need a flag to
505          * tell them about such special cases.
506          */
507
508         /* completion is reported through a callback */
509         void                    (*complete)(void *context);
510         void                    *context;
511         unsigned                actual_length;
512         int                     status;
513
514         /* for optional use by whatever driver currently owns the
515          * spi_message ...  between calls to spi_async and then later
516          * complete(), that's the spi_master controller driver.
517          */
518         struct list_head        queue;
519         void                    *state;
520 };
521
522 static inline void spi_message_init(struct spi_message *m)
523 {
524         memset(m, 0, sizeof *m);
525         INIT_LIST_HEAD(&m->transfers);
526 }
527
528 static inline void
529 spi_message_add_tail(struct spi_transfer *t, struct spi_message *m)
530 {
531         list_add_tail(&t->transfer_list, &m->transfers);
532 }
533
534 static inline void
535 spi_transfer_del(struct spi_transfer *t)
536 {
537         list_del(&t->transfer_list);
538 }
539
540 /* It's fine to embed message and transaction structures in other data
541  * structures so long as you don't free them while they're in use.
542  */
543
544 static inline struct spi_message *spi_message_alloc(unsigned ntrans, gfp_t flags)
545 {
546         struct spi_message *m;
547
548         m = kzalloc(sizeof(struct spi_message)
549                         + ntrans * sizeof(struct spi_transfer),
550                         flags);
551         if (m) {
552                 int i;
553                 struct spi_transfer *t = (struct spi_transfer *)(m + 1);
554
555                 INIT_LIST_HEAD(&m->transfers);
556                 for (i = 0; i < ntrans; i++, t++)
557                         spi_message_add_tail(t, m);
558         }
559         return m;
560 }
561
562 static inline void spi_message_free(struct spi_message *m)
563 {
564         kfree(m);
565 }
566
567 extern int spi_setup(struct spi_device *spi);
568 extern int spi_async(struct spi_device *spi, struct spi_message *message);
569 extern int spi_async_locked(struct spi_device *spi,
570                             struct spi_message *message);
571
572 /*---------------------------------------------------------------------------*/
573
574 /* All these synchronous SPI transfer routines are utilities layered
575  * over the core async transfer primitive.  Here, "synchronous" means
576  * they will sleep uninterruptibly until the async transfer completes.
577  */
578
579 extern int spi_sync(struct spi_device *spi, struct spi_message *message);
580 extern int spi_sync_locked(struct spi_device *spi, struct spi_message *message);
581 extern int spi_bus_lock(struct spi_master *master);
582 extern int spi_bus_unlock(struct spi_master *master);
583
584 /**
585  * spi_write - SPI synchronous write
586  * @spi: device to which data will be written
587  * @buf: data buffer
588  * @len: data buffer size
589  * Context: can sleep
590  *
591  * This writes the buffer and returns zero or a negative error code.
592  * Callable only from contexts that can sleep.
593  */
594 static inline int
595 spi_write(struct spi_device *spi, const void *buf, size_t len)
596 {
597         struct spi_transfer     t = {
598                         .tx_buf         = buf,
599                         .len            = len,
600                 };
601         struct spi_message      m;
602
603         spi_message_init(&m);
604         spi_message_add_tail(&t, &m);
605         return spi_sync(spi, &m);
606 }
607
608 /**
609  * spi_read - SPI synchronous read
610  * @spi: device from which data will be read
611  * @buf: data buffer
612  * @len: data buffer size
613  * Context: can sleep
614  *
615  * This reads the buffer and returns zero or a negative error code.
616  * Callable only from contexts that can sleep.
617  */
618 static inline int
619 spi_read(struct spi_device *spi, void *buf, size_t len)
620 {
621         struct spi_transfer     t = {
622                         .rx_buf         = buf,
623                         .len            = len,
624                 };
625         struct spi_message      m;
626
627         spi_message_init(&m);
628         spi_message_add_tail(&t, &m);
629         return spi_sync(spi, &m);
630 }
631
632 /* this copies txbuf and rxbuf data; for small transfers only! */
633 extern int spi_write_then_read(struct spi_device *spi,
634                 const void *txbuf, unsigned n_tx,
635                 void *rxbuf, unsigned n_rx);
636
637 /**
638  * spi_w8r8 - SPI synchronous 8 bit write followed by 8 bit read
639  * @spi: device with which data will be exchanged
640  * @cmd: command to be written before data is read back
641  * Context: can sleep
642  *
643  * This returns the (unsigned) eight bit number returned by the
644  * device, or else a negative error code.  Callable only from
645  * contexts that can sleep.
646  */
647 static inline ssize_t spi_w8r8(struct spi_device *spi, u8 cmd)
648 {
649         ssize_t                 status;
650         u8                      result;
651
652         status = spi_write_then_read(spi, &cmd, 1, &result, 1);
653
654         /* return negative errno or unsigned value */
655         return (status < 0) ? status : result;
656 }
657
658 /**
659  * spi_w8r16 - SPI synchronous 8 bit write followed by 16 bit read
660  * @spi: device with which data will be exchanged
661  * @cmd: command to be written before data is read back
662  * Context: can sleep
663  *
664  * This returns the (unsigned) sixteen bit number returned by the
665  * device, or else a negative error code.  Callable only from
666  * contexts that can sleep.
667  *
668  * The number is returned in wire-order, which is at least sometimes
669  * big-endian.
670  */
671 static inline ssize_t spi_w8r16(struct spi_device *spi, u8 cmd)
672 {
673         ssize_t                 status;
674         u16                     result;
675
676         status = spi_write_then_read(spi, &cmd, 1, (u8 *) &result, 2);
677
678         /* return negative errno or unsigned value */
679         return (status < 0) ? status : result;
680 }
681
682 /*---------------------------------------------------------------------------*/
683
684 /*
685  * INTERFACE between board init code and SPI infrastructure.
686  *
687  * No SPI driver ever sees these SPI device table segments, but
688  * it's how the SPI core (or adapters that get hotplugged) grows
689  * the driver model tree.
690  *
691  * As a rule, SPI devices can't be probed.  Instead, board init code
692  * provides a table listing the devices which are present, with enough
693  * information to bind and set up the device's driver.  There's basic
694  * support for nonstatic configurations too; enough to handle adding
695  * parport adapters, or microcontrollers acting as USB-to-SPI bridges.
696  */
697
698 /**
699  * struct spi_board_info - board-specific template for a SPI device
700  * @modalias: Initializes spi_device.modalias; identifies the driver.
701  * @platform_data: Initializes spi_device.platform_data; the particular
702  *      data stored there is driver-specific.
703  * @controller_data: Initializes spi_device.controller_data; some
704  *      controllers need hints about hardware setup, e.g. for DMA.
705  * @irq: Initializes spi_device.irq; depends on how the board is wired.
706  * @max_speed_hz: Initializes spi_device.max_speed_hz; based on limits
707  *      from the chip datasheet and board-specific signal quality issues.
708  * @bus_num: Identifies which spi_master parents the spi_device; unused
709  *      by spi_new_device(), and otherwise depends on board wiring.
710  * @chip_select: Initializes spi_device.chip_select; depends on how
711  *      the board is wired.
712  * @mode: Initializes spi_device.mode; based on the chip datasheet, board
713  *      wiring (some devices support both 3WIRE and standard modes), and
714  *      possibly presence of an inverter in the chipselect path.
715  *
716  * When adding new SPI devices to the device tree, these structures serve
717  * as a partial device template.  They hold information which can't always
718  * be determined by drivers.  Information that probe() can establish (such
719  * as the default transfer wordsize) is not included here.
720  *
721  * These structures are used in two places.  Their primary role is to
722  * be stored in tables of board-specific device descriptors, which are
723  * declared early in board initialization and then used (much later) to
724  * populate a controller's device tree after the that controller's driver
725  * initializes.  A secondary (and atypical) role is as a parameter to
726  * spi_new_device() call, which happens after those controller drivers
727  * are active in some dynamic board configuration models.
728  */
729 struct spi_board_info {
730         /* the device name and module name are coupled, like platform_bus;
731          * "modalias" is normally the driver name.
732          *
733          * platform_data goes to spi_device.dev.platform_data,
734          * controller_data goes to spi_device.controller_data,
735          * irq is copied too
736          */
737         char            modalias[SPI_NAME_SIZE];
738         const void      *platform_data;
739         void            *controller_data;
740         int             irq;
741
742         /* slower signaling on noisy or low voltage boards */
743         u32             max_speed_hz;
744
745
746         /* bus_num is board specific and matches the bus_num of some
747          * spi_master that will probably be registered later.
748          *
749          * chip_select reflects how this chip is wired to that master;
750          * it's less than num_chipselect.
751          */
752         u16             bus_num;
753         u16             chip_select;
754
755         /* mode becomes spi_device.mode, and is essential for chips
756          * where the default of SPI_CS_HIGH = 0 is wrong.
757          */
758         u8              mode;
759
760         /* ... may need additional spi_device chip config data here.
761          * avoid stuff protocol drivers can set; but include stuff
762          * needed to behave without being bound to a driver:
763          *  - quirks like clock rate mattering when not selected
764          */
765 };
766
767 #ifdef  CONFIG_SPI
768 extern int
769 spi_register_board_info(struct spi_board_info const *info, unsigned n);
770 #else
771 /* board init code may ignore whether SPI is configured or not */
772 static inline int
773 spi_register_board_info(struct spi_board_info const *info, unsigned n)
774         { return 0; }
775 #endif
776
777
778 /* If you're hotplugging an adapter with devices (parport, usb, etc)
779  * use spi_new_device() to describe each device.  You can also call
780  * spi_unregister_device() to start making that device vanish, but
781  * normally that would be handled by spi_unregister_master().
782  *
783  * You can also use spi_alloc_device() and spi_add_device() to use a two
784  * stage registration sequence for each spi_device.  This gives the caller
785  * some more control over the spi_device structure before it is registered,
786  * but requires that caller to initialize fields that would otherwise
787  * be defined using the board info.
788  */
789 extern struct spi_device *
790 spi_alloc_device(struct spi_master *master);
791
792 extern int
793 spi_add_device(struct spi_device *spi);
794
795 extern struct spi_device *
796 spi_new_device(struct spi_master *, struct spi_board_info *);
797
798 static inline void
799 spi_unregister_device(struct spi_device *spi)
800 {
801         if (spi)
802                 device_unregister(&spi->dev);
803 }
804
805 extern const struct spi_device_id *
806 spi_get_device_id(const struct spi_device *sdev);
807
808 #endif /* __LINUX_SPI_H */