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