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