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