xref: /openbmc/u-boot/include/spi.h (revision 6f94fa21cc7552dae9bf452e12eaa85c8897fcbb)
1  /*
2   * Common SPI Interface: Controller-specific definitions
3   *
4   * (C) Copyright 2001
5   * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com.
6   *
7   * SPDX-License-Identifier:	GPL-2.0+
8   */
9  
10  #ifndef _SPI_H_
11  #define _SPI_H_
12  
13  /* SPI mode flags */
14  #define SPI_CPHA	BIT(0)			/* clock phase */
15  #define SPI_CPOL	BIT(1)			/* clock polarity */
16  #define SPI_MODE_0	(0|0)			/* (original MicroWire) */
17  #define SPI_MODE_1	(0|SPI_CPHA)
18  #define SPI_MODE_2	(SPI_CPOL|0)
19  #define SPI_MODE_3	(SPI_CPOL|SPI_CPHA)
20  #define SPI_CS_HIGH	BIT(2)			/* CS active high */
21  #define SPI_LSB_FIRST	BIT(3)			/* per-word bits-on-wire */
22  #define SPI_3WIRE	BIT(4)			/* SI/SO signals shared */
23  #define SPI_LOOP	BIT(5)			/* loopback mode */
24  #define SPI_SLAVE	BIT(6)			/* slave mode */
25  #define SPI_PREAMBLE	BIT(7)			/* Skip preamble bytes */
26  #define SPI_TX_BYTE	BIT(8)			/* transmit with 1 wire byte */
27  #define SPI_TX_DUAL	BIT(9)			/* transmit with 2 wires */
28  #define SPI_TX_QUAD	BIT(10)			/* transmit with 4 wires */
29  #define SPI_RX_SLOW	BIT(11)			/* receive with 1 wire slow */
30  #define SPI_RX_DUAL	BIT(12)			/* receive with 2 wires */
31  #define SPI_RX_QUAD	BIT(13)			/* receive with 4 wires */
32  
33  /* SPI bus connection options - see enum spi_dual_flash */
34  #define SPI_CONN_DUAL_SHARED		(1 << 0)
35  #define SPI_CONN_DUAL_SEPARATED	(1 << 1)
36  
37  /* Header byte that marks the start of the message */
38  #define SPI_PREAMBLE_END_BYTE	0xec
39  
40  #define SPI_DEFAULT_WORDLEN	8
41  
42  #ifdef CONFIG_DM_SPI
43  /* TODO(sjg@chromium.org): Remove this and use max_hz from struct spi_slave */
44  struct dm_spi_bus {
45  	uint max_hz;
46  };
47  
48  /**
49   * struct dm_spi_platdata - platform data for all SPI slaves
50   *
51   * This describes a SPI slave, a child device of the SPI bus. To obtain this
52   * struct from a spi_slave, use dev_get_parent_platdata(dev) or
53   * dev_get_parent_platdata(slave->dev).
54   *
55   * This data is immuatable. Each time the device is probed, @max_hz and @mode
56   * will be copied to struct spi_slave.
57   *
58   * @cs:		Chip select number (0..n-1)
59   * @max_hz:	Maximum bus speed that this slave can tolerate
60   * @mode:	SPI mode to use for this device (see SPI mode flags)
61   */
62  struct dm_spi_slave_platdata {
63  	unsigned int cs;
64  	uint max_hz;
65  	uint mode;
66  };
67  
68  #endif /* CONFIG_DM_SPI */
69  
70  /**
71   * struct spi_slave - Representation of a SPI slave
72   *
73   * For driver model this is the per-child data used by the SPI bus. It can
74   * be accessed using dev_get_parent_priv() on the slave device. The SPI uclass
75   * sets uip per_child_auto_alloc_size to sizeof(struct spi_slave), and the
76   * driver should not override it. Two platform data fields (max_hz and mode)
77   * are copied into this structure to provide an initial value. This allows
78   * them to be changed, since we should never change platform data in drivers.
79   *
80   * If not using driver model, drivers are expected to extend this with
81   * controller-specific data.
82   *
83   * @dev:		SPI slave device
84   * @max_hz:		Maximum speed for this slave
85   * @speed:		Current bus speed. This is 0 until the bus is first
86   *			claimed.
87   * @bus:		ID of the bus that the slave is attached to. For
88   *			driver model this is the sequence number of the SPI
89   *			bus (bus->seq) so does not need to be stored
90   * @cs:			ID of the chip select connected to the slave.
91   * @mode:		SPI mode to use for this slave (see SPI mode flags)
92   * @wordlen:		Size of SPI word in number of bits
93   * @max_write_size:	If non-zero, the maximum number of bytes which can
94   *			be written at once, excluding command bytes.
95   * @memory_map:		Address of read-only SPI flash access.
96   * @option:		Varies SPI bus options - separate, shared bus.
97   * @flags:		Indication of SPI flags.
98   */
99  struct spi_slave {
100  #ifdef CONFIG_DM_SPI
101  	struct udevice *dev;	/* struct spi_slave is dev->parentdata */
102  	uint max_hz;
103  	uint speed;
104  #else
105  	unsigned int bus;
106  	unsigned int cs;
107  #endif
108  	uint mode;
109  	unsigned int wordlen;
110  	unsigned int max_write_size;
111  	void *memory_map;
112  	u8 option;
113  
114  	u8 flags;
115  #define SPI_XFER_BEGIN		BIT(0)	/* Assert CS before transfer */
116  #define SPI_XFER_END		BIT(1)	/* Deassert CS after transfer */
117  #define SPI_XFER_ONCE		(SPI_XFER_BEGIN | SPI_XFER_END)
118  #define SPI_XFER_MMAP		BIT(2)	/* Memory Mapped start */
119  #define SPI_XFER_MMAP_END	BIT(3)	/* Memory Mapped End */
120  #define SPI_XFER_U_PAGE		BIT(4)
121  };
122  
123  /**
124   * Initialization, must be called once on start up.
125   *
126   * TODO: I don't think we really need this.
127   */
128  void spi_init(void);
129  
130  /**
131   * spi_do_alloc_slave - Allocate a new SPI slave (internal)
132   *
133   * Allocate and zero all fields in the spi slave, and set the bus/chip
134   * select. Use the helper macro spi_alloc_slave() to call this.
135   *
136   * @offset:	Offset of struct spi_slave within slave structure.
137   * @size:	Size of slave structure.
138   * @bus:	Bus ID of the slave chip.
139   * @cs:		Chip select ID of the slave chip on the specified bus.
140   */
141  void *spi_do_alloc_slave(int offset, int size, unsigned int bus,
142  			 unsigned int cs);
143  
144  /**
145   * spi_alloc_slave - Allocate a new SPI slave
146   *
147   * Allocate and zero all fields in the spi slave, and set the bus/chip
148   * select.
149   *
150   * @_struct:	Name of structure to allocate (e.g. struct tegra_spi).
151   *		This structure must contain a member 'struct spi_slave *slave'.
152   * @bus:	Bus ID of the slave chip.
153   * @cs:		Chip select ID of the slave chip on the specified bus.
154   */
155  #define spi_alloc_slave(_struct, bus, cs) \
156  	spi_do_alloc_slave(offsetof(_struct, slave), \
157  			    sizeof(_struct), bus, cs)
158  
159  /**
160   * spi_alloc_slave_base - Allocate a new SPI slave with no private data
161   *
162   * Allocate and zero all fields in the spi slave, and set the bus/chip
163   * select.
164   *
165   * @bus:	Bus ID of the slave chip.
166   * @cs:		Chip select ID of the slave chip on the specified bus.
167   */
168  #define spi_alloc_slave_base(bus, cs) \
169  	spi_do_alloc_slave(0, sizeof(struct spi_slave), bus, cs)
170  
171  /**
172   * Set up communications parameters for a SPI slave.
173   *
174   * This must be called once for each slave. Note that this function
175   * usually doesn't touch any actual hardware, it only initializes the
176   * contents of spi_slave so that the hardware can be easily
177   * initialized later.
178   *
179   * @bus:	Bus ID of the slave chip.
180   * @cs:		Chip select ID of the slave chip on the specified bus.
181   * @max_hz:	Maximum SCK rate in Hz.
182   * @mode:	Clock polarity, clock phase and other parameters.
183   *
184   * Returns: A spi_slave reference that can be used in subsequent SPI
185   * calls, or NULL if one or more of the parameters are not supported.
186   */
187  struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs,
188  		unsigned int max_hz, unsigned int mode);
189  
190  /**
191   * Free any memory associated with a SPI slave.
192   *
193   * @slave:	The SPI slave
194   */
195  void spi_free_slave(struct spi_slave *slave);
196  
197  /**
198   * Claim the bus and prepare it for communication with a given slave.
199   *
200   * This must be called before doing any transfers with a SPI slave. It
201   * will enable and initialize any SPI hardware as necessary, and make
202   * sure that the SCK line is in the correct idle state. It is not
203   * allowed to claim the same bus for several slaves without releasing
204   * the bus in between.
205   *
206   * @slave:	The SPI slave
207   *
208   * Returns: 0 if the bus was claimed successfully, or a negative value
209   * if it wasn't.
210   */
211  int spi_claim_bus(struct spi_slave *slave);
212  
213  /**
214   * Release the SPI bus
215   *
216   * This must be called once for every call to spi_claim_bus() after
217   * all transfers have finished. It may disable any SPI hardware as
218   * appropriate.
219   *
220   * @slave:	The SPI slave
221   */
222  void spi_release_bus(struct spi_slave *slave);
223  
224  /**
225   * Set the word length for SPI transactions
226   *
227   * Set the word length (number of bits per word) for SPI transactions.
228   *
229   * @slave:	The SPI slave
230   * @wordlen:	The number of bits in a word
231   *
232   * Returns: 0 on success, -1 on failure.
233   */
234  int spi_set_wordlen(struct spi_slave *slave, unsigned int wordlen);
235  
236  /**
237   * SPI transfer
238   *
239   * This writes "bitlen" bits out the SPI MOSI port and simultaneously clocks
240   * "bitlen" bits in the SPI MISO port.  That's just the way SPI works.
241   *
242   * The source of the outgoing bits is the "dout" parameter and the
243   * destination of the input bits is the "din" parameter.  Note that "dout"
244   * and "din" can point to the same memory location, in which case the
245   * input data overwrites the output data (since both are buffered by
246   * temporary variables, this is OK).
247   *
248   * spi_xfer() interface:
249   * @slave:	The SPI slave which will be sending/receiving the data.
250   * @bitlen:	How many bits to write and read.
251   * @dout:	Pointer to a string of bits to send out.  The bits are
252   *		held in a byte array and are sent MSB first.
253   * @din:	Pointer to a string of bits that will be filled in.
254   * @flags:	A bitwise combination of SPI_XFER_* flags.
255   *
256   * Returns: 0 on success, not 0 on failure
257   */
258  int  spi_xfer(struct spi_slave *slave, unsigned int bitlen, const void *dout,
259  		void *din, unsigned long flags);
260  
261  /* Copy memory mapped data */
262  void spi_flash_copy_mmap(void *data, void *offset, size_t len);
263  
264  /**
265   * Determine if a SPI chipselect is valid.
266   * This function is provided by the board if the low-level SPI driver
267   * needs it to determine if a given chipselect is actually valid.
268   *
269   * Returns: 1 if bus:cs identifies a valid chip on this board, 0
270   * otherwise.
271   */
272  int spi_cs_is_valid(unsigned int bus, unsigned int cs);
273  
274  #ifndef CONFIG_DM_SPI
275  /**
276   * Activate a SPI chipselect.
277   * This function is provided by the board code when using a driver
278   * that can't control its chipselects automatically (e.g.
279   * common/soft_spi.c). When called, it should activate the chip select
280   * to the device identified by "slave".
281   */
282  void spi_cs_activate(struct spi_slave *slave);
283  
284  /**
285   * Deactivate a SPI chipselect.
286   * This function is provided by the board code when using a driver
287   * that can't control its chipselects automatically (e.g.
288   * common/soft_spi.c). When called, it should deactivate the chip
289   * select to the device identified by "slave".
290   */
291  void spi_cs_deactivate(struct spi_slave *slave);
292  
293  /**
294   * Set transfer speed.
295   * This sets a new speed to be applied for next spi_xfer().
296   * @slave:	The SPI slave
297   * @hz:		The transfer speed
298   */
299  void spi_set_speed(struct spi_slave *slave, uint hz);
300  #endif
301  
302  /**
303   * Write 8 bits, then read 8 bits.
304   * @slave:	The SPI slave we're communicating with
305   * @byte:	Byte to be written
306   *
307   * Returns: The value that was read, or a negative value on error.
308   *
309   * TODO: This function probably shouldn't be inlined.
310   */
311  static inline int spi_w8r8(struct spi_slave *slave, unsigned char byte)
312  {
313  	unsigned char dout[2];
314  	unsigned char din[2];
315  	int ret;
316  
317  	dout[0] = byte;
318  	dout[1] = 0;
319  
320  	ret = spi_xfer(slave, 16, dout, din, SPI_XFER_BEGIN | SPI_XFER_END);
321  	return ret < 0 ? ret : din[1];
322  }
323  
324  /**
325   * Set up a SPI slave for a particular device tree node
326   *
327   * This calls spi_setup_slave() with the correct bus number. Call
328   * spi_free_slave() to free it later.
329   *
330   * @param blob:		Device tree blob
331   * @param slave_node:	Slave node to use
332   * @param spi_node:	SPI peripheral node to use
333   * @return pointer to new spi_slave structure
334   */
335  struct spi_slave *spi_setup_slave_fdt(const void *blob, int slave_node,
336  				      int spi_node);
337  
338  /**
339   * spi_base_setup_slave_fdt() - helper function to set up a SPI slace
340   *
341   * This decodes SPI properties from the slave node to determine the
342   * chip select and SPI parameters.
343   *
344   * @blob:	Device tree blob
345   * @busnum:	Bus number to use
346   * @node:	Device tree node for the SPI bus
347   */
348  struct spi_slave *spi_base_setup_slave_fdt(const void *blob, int busnum,
349  					   int node);
350  
351  #ifdef CONFIG_DM_SPI
352  
353  /**
354   * struct spi_cs_info - Information about a bus chip select
355   *
356   * @dev:	Connected device, or NULL if none
357   */
358  struct spi_cs_info {
359  	struct udevice *dev;
360  };
361  
362  /**
363   * struct struct dm_spi_ops - Driver model SPI operations
364   *
365   * The uclass interface is implemented by all SPI devices which use
366   * driver model.
367   */
368  struct dm_spi_ops {
369  	/**
370  	 * Claim the bus and prepare it for communication.
371  	 *
372  	 * The device provided is the slave device. It's parent controller
373  	 * will be used to provide the communication.
374  	 *
375  	 * This must be called before doing any transfers with a SPI slave. It
376  	 * will enable and initialize any SPI hardware as necessary, and make
377  	 * sure that the SCK line is in the correct idle state. It is not
378  	 * allowed to claim the same bus for several slaves without releasing
379  	 * the bus in between.
380  	 *
381  	 * @dev:	The SPI slave
382  	 *
383  	 * Returns: 0 if the bus was claimed successfully, or a negative value
384  	 * if it wasn't.
385  	 */
386  	int (*claim_bus)(struct udevice *dev);
387  
388  	/**
389  	 * Release the SPI bus
390  	 *
391  	 * This must be called once for every call to spi_claim_bus() after
392  	 * all transfers have finished. It may disable any SPI hardware as
393  	 * appropriate.
394  	 *
395  	 * @dev:	The SPI slave
396  	 */
397  	int (*release_bus)(struct udevice *dev);
398  
399  	/**
400  	 * Set the word length for SPI transactions
401  	 *
402  	 * Set the word length (number of bits per word) for SPI transactions.
403  	 *
404  	 * @bus:	The SPI slave
405  	 * @wordlen:	The number of bits in a word
406  	 *
407  	 * Returns: 0 on success, -ve on failure.
408  	 */
409  	int (*set_wordlen)(struct udevice *dev, unsigned int wordlen);
410  
411  	/**
412  	 * SPI transfer
413  	 *
414  	 * This writes "bitlen" bits out the SPI MOSI port and simultaneously
415  	 * clocks "bitlen" bits in the SPI MISO port.  That's just the way SPI
416  	 * works.
417  	 *
418  	 * The source of the outgoing bits is the "dout" parameter and the
419  	 * destination of the input bits is the "din" parameter.  Note that
420  	 * "dout" and "din" can point to the same memory location, in which
421  	 * case the input data overwrites the output data (since both are
422  	 * buffered by temporary variables, this is OK).
423  	 *
424  	 * spi_xfer() interface:
425  	 * @dev:	The slave device to communicate with
426  	 * @bitlen:	How many bits to write and read.
427  	 * @dout:	Pointer to a string of bits to send out.  The bits are
428  	 *		held in a byte array and are sent MSB first.
429  	 * @din:	Pointer to a string of bits that will be filled in.
430  	 * @flags:	A bitwise combination of SPI_XFER_* flags.
431  	 *
432  	 * Returns: 0 on success, not -1 on failure
433  	 */
434  	int (*xfer)(struct udevice *dev, unsigned int bitlen, const void *dout,
435  		    void *din, unsigned long flags);
436  
437  	/**
438  	 * Set transfer speed.
439  	 * This sets a new speed to be applied for next spi_xfer().
440  	 * @bus:	The SPI bus
441  	 * @hz:		The transfer speed
442  	 * @return 0 if OK, -ve on error
443  	 */
444  	int (*set_speed)(struct udevice *bus, uint hz);
445  
446  	/**
447  	 * Set the SPI mode/flags
448  	 *
449  	 * It is unclear if we want to set speed and mode together instead
450  	 * of separately.
451  	 *
452  	 * @bus:	The SPI bus
453  	 * @mode:	Requested SPI mode (SPI_... flags)
454  	 * @return 0 if OK, -ve on error
455  	 */
456  	int (*set_mode)(struct udevice *bus, uint mode);
457  
458  	/**
459  	 * Get information on a chip select
460  	 *
461  	 * This is only called when the SPI uclass does not know about a
462  	 * chip select, i.e. it has no attached device. It gives the driver
463  	 * a chance to allow activity on that chip select even so.
464  	 *
465  	 * @bus:	The SPI bus
466  	 * @cs:		The chip select (0..n-1)
467  	 * @info:	Returns information about the chip select, if valid.
468  	 *		On entry info->dev is NULL
469  	 * @return 0 if OK (and @info is set up), -ENODEV if the chip select
470  	 *	   is invalid, other -ve value on error
471  	 */
472  	int (*cs_info)(struct udevice *bus, uint cs, struct spi_cs_info *info);
473  };
474  
475  struct dm_spi_emul_ops {
476  	/**
477  	 * SPI transfer
478  	 *
479  	 * This writes "bitlen" bits out the SPI MOSI port and simultaneously
480  	 * clocks "bitlen" bits in the SPI MISO port.  That's just the way SPI
481  	 * works. Here the device is a slave.
482  	 *
483  	 * The source of the outgoing bits is the "dout" parameter and the
484  	 * destination of the input bits is the "din" parameter.  Note that
485  	 * "dout" and "din" can point to the same memory location, in which
486  	 * case the input data overwrites the output data (since both are
487  	 * buffered by temporary variables, this is OK).
488  	 *
489  	 * spi_xfer() interface:
490  	 * @slave:	The SPI slave which will be sending/receiving the data.
491  	 * @bitlen:	How many bits to write and read.
492  	 * @dout:	Pointer to a string of bits sent to the device. The
493  	 *		bits are held in a byte array and are sent MSB first.
494  	 * @din:	Pointer to a string of bits that will be sent back to
495  	 *		the master.
496  	 * @flags:	A bitwise combination of SPI_XFER_* flags.
497  	 *
498  	 * Returns: 0 on success, not -1 on failure
499  	 */
500  	int (*xfer)(struct udevice *slave, unsigned int bitlen,
501  		    const void *dout, void *din, unsigned long flags);
502  };
503  
504  /**
505   * spi_find_bus_and_cs() - Find bus and slave devices by number
506   *
507   * Given a bus number and chip select, this finds the corresponding bus
508   * device and slave device. Neither device is activated by this function,
509   * although they may have been activated previously.
510   *
511   * @busnum:	SPI bus number
512   * @cs:		Chip select to look for
513   * @busp:	Returns bus device
514   * @devp:	Return slave device
515   * @return 0 if found, -ENODEV on error
516   */
517  int spi_find_bus_and_cs(int busnum, int cs, struct udevice **busp,
518  			struct udevice **devp);
519  
520  /**
521   * spi_get_bus_and_cs() - Find and activate bus and slave devices by number
522   *
523   * Given a bus number and chip select, this finds the corresponding bus
524   * device and slave device.
525   *
526   * If no such slave exists, and drv_name is not NULL, then a new slave device
527   * is automatically bound on this chip select.
528   *
529   * Ths new slave device is probed ready for use with the given speed and mode.
530   *
531   * @busnum:	SPI bus number
532   * @cs:		Chip select to look for
533   * @speed:	SPI speed to use for this slave
534   * @mode:	SPI mode to use for this slave
535   * @drv_name:	Name of driver to attach to this chip select
536   * @dev_name:	Name of the new device thus created
537   * @busp:	Returns bus device
538   * @devp:	Return slave device
539   * @return 0 if found, -ve on error
540   */
541  int spi_get_bus_and_cs(int busnum, int cs, int speed, int mode,
542  			const char *drv_name, const char *dev_name,
543  			struct udevice **busp, struct spi_slave **devp);
544  
545  /**
546   * spi_chip_select() - Get the chip select for a slave
547   *
548   * @return the chip select this slave is attached to
549   */
550  int spi_chip_select(struct udevice *slave);
551  
552  /**
553   * spi_find_chip_select() - Find the slave attached to chip select
554   *
555   * @bus:	SPI bus to search
556   * @cs:		Chip select to look for
557   * @devp:	Returns the slave device if found
558   * @return 0 if found, -ENODEV on error
559   */
560  int spi_find_chip_select(struct udevice *bus, int cs, struct udevice **devp);
561  
562  /**
563   * spi_slave_ofdata_to_platdata() - decode standard SPI platform data
564   *
565   * This decodes the speed and mode for a slave from a device tree node
566   *
567   * @blob:	Device tree blob
568   * @node:	Node offset to read from
569   * @plat:	Place to put the decoded information
570   */
571  int spi_slave_ofdata_to_platdata(const void *blob, int node,
572  				 struct dm_spi_slave_platdata *plat);
573  
574  /**
575   * spi_cs_info() - Check information on a chip select
576   *
577   * This checks a particular chip select on a bus to see if it has a device
578   * attached, or is even valid.
579   *
580   * @bus:	The SPI bus
581   * @cs:		The chip select (0..n-1)
582   * @info:	Returns information about the chip select, if valid
583   * @return 0 if OK (and @info is set up), -ENODEV if the chip select
584   *	   is invalid, other -ve value on error
585   */
586  int spi_cs_info(struct udevice *bus, uint cs, struct spi_cs_info *info);
587  
588  struct sandbox_state;
589  
590  /**
591   * sandbox_spi_get_emul() - get an emulator for a SPI slave
592   *
593   * This provides a way to attach an emulated SPI device to a particular SPI
594   * slave, so that xfer() operations on the slave will be handled by the
595   * emulator. If a emulator already exists on that chip select it is returned.
596   * Otherwise one is created.
597   *
598   * @state:	Sandbox state
599   * @bus:	SPI bus requesting the emulator
600   * @slave:	SPI slave device requesting the emulator
601   * @emuip:	Returns pointer to emulator
602   * @return 0 if OK, -ve on error
603   */
604  int sandbox_spi_get_emul(struct sandbox_state *state,
605  			 struct udevice *bus, struct udevice *slave,
606  			 struct udevice **emulp);
607  
608  /**
609   * Claim the bus and prepare it for communication with a given slave.
610   *
611   * This must be called before doing any transfers with a SPI slave. It
612   * will enable and initialize any SPI hardware as necessary, and make
613   * sure that the SCK line is in the correct idle state. It is not
614   * allowed to claim the same bus for several slaves without releasing
615   * the bus in between.
616   *
617   * @dev:	The SPI slave device
618   *
619   * Returns: 0 if the bus was claimed successfully, or a negative value
620   * if it wasn't.
621   */
622  int dm_spi_claim_bus(struct udevice *dev);
623  
624  /**
625   * Release the SPI bus
626   *
627   * This must be called once for every call to dm_spi_claim_bus() after
628   * all transfers have finished. It may disable any SPI hardware as
629   * appropriate.
630   *
631   * @slave:	The SPI slave device
632   */
633  void dm_spi_release_bus(struct udevice *dev);
634  
635  /**
636   * SPI transfer
637   *
638   * This writes "bitlen" bits out the SPI MOSI port and simultaneously clocks
639   * "bitlen" bits in the SPI MISO port.  That's just the way SPI works.
640   *
641   * The source of the outgoing bits is the "dout" parameter and the
642   * destination of the input bits is the "din" parameter.  Note that "dout"
643   * and "din" can point to the same memory location, in which case the
644   * input data overwrites the output data (since both are buffered by
645   * temporary variables, this is OK).
646   *
647   * dm_spi_xfer() interface:
648   * @dev:	The SPI slave device which will be sending/receiving the data.
649   * @bitlen:	How many bits to write and read.
650   * @dout:	Pointer to a string of bits to send out.  The bits are
651   *		held in a byte array and are sent MSB first.
652   * @din:	Pointer to a string of bits that will be filled in.
653   * @flags:	A bitwise combination of SPI_XFER_* flags.
654   *
655   * Returns: 0 on success, not 0 on failure
656   */
657  int dm_spi_xfer(struct udevice *dev, unsigned int bitlen,
658  		const void *dout, void *din, unsigned long flags);
659  
660  /* Access the operations for a SPI device */
661  #define spi_get_ops(dev)	((struct dm_spi_ops *)(dev)->driver->ops)
662  #define spi_emul_get_ops(dev)	((struct dm_spi_emul_ops *)(dev)->driver->ops)
663  #endif /* CONFIG_DM_SPI */
664  
665  #endif	/* _SPI_H_ */
666