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