blob: fa9ab12dbef4f47977ae143c4786b15d5ff9c13a [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001/* SPDX-License-Identifier: GPL-2.0+ */
wdenk77f85582002-09-26 02:01:47 +00002/*
Jagannadha Sutradharudu Teki469146c2013-10-10 22:14:09 +05303 * Common SPI Interface: Controller-specific definitions
4 *
wdenk77f85582002-09-26 02:01:47 +00005 * (C) Copyright 2001
6 * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com.
wdenk77f85582002-09-26 02:01:47 +00007 */
8
9#ifndef _SPI_H_
10#define _SPI_H_
11
Boris Brezillond13f5b22018-08-16 17:30:11 +020012#include <common.h>
Simon Glasscd93d622020-05-10 11:40:13 -060013#include <linux/bitops.h>
Boris Brezillond13f5b22018-08-16 17:30:11 +020014
Guennadi Liakhovetski38254f42008-04-15 14:14:25 +020015/* SPI mode flags */
Simon Glass70e5e672020-07-07 13:11:49 -060016#define SPI_CPHA BIT(0) /* clock phase (1 = SPI_CLOCK_PHASE_SECOND) */
17#define SPI_CPOL BIT(1) /* clock polarity (1 = SPI_POLARITY_HIGH) */
Jagan Teki465c00d2015-12-29 12:12:30 +053018#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 */
Jagan Teki29ee0262015-12-28 22:24:08 +053028#define SPI_TX_BYTE BIT(8) /* transmit with 1 wire byte */
Jagan Teki2b11a412015-12-28 22:55:50 +053029#define SPI_TX_DUAL BIT(9) /* transmit with 2 wires */
30#define SPI_TX_QUAD BIT(10) /* transmit with 4 wires */
Jagan Teki08fe9c22016-08-08 17:12:12 +053031#define SPI_RX_SLOW BIT(11) /* receive with 1 wire slow */
Jagan Teki3ac48d02016-08-10 20:48:14 +053032#define SPI_RX_DUAL BIT(12) /* receive with 2 wires */
33#define SPI_RX_QUAD BIT(13) /* receive with 4 wires */
Vignesh Raghavendra658df8b2019-12-05 15:46:05 +053034#define SPI_TX_OCTAL BIT(14) /* transmit with 8 wires */
35#define SPI_RX_OCTAL BIT(15) /* receive with 8 wires */
Jagannadha Sutradharudu Teki4e09cc12014-01-11 15:10:28 +053036
Rajeshwari Shindebb786b82013-05-28 20:10:37 +000037/* Header byte that marks the start of the message */
Jagannadha Sutradharudu Tekice22b922013-10-07 19:34:56 +053038#define SPI_PREAMBLE_END_BYTE 0xec
Rajeshwari Shindebb786b82013-05-28 20:10:37 +000039
Jagan Teki5d69df32015-06-27 00:51:30 +053040#define SPI_DEFAULT_WORDLEN 8
Nikita Kiryanov5753d092013-10-16 17:23:25 +030041
Ovidiu Panait741280e2020-12-14 19:06:50 +020042/**
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 */
Simon Glassd7af6a42014-10-13 23:41:52 -060054struct dm_spi_bus {
55 uint max_hz;
Ovidiu Panait741280e2020-12-14 19:06:50 +020056 uint speed;
57 uint mode;
Simon Glassd7af6a42014-10-13 23:41:52 -060058};
59
Simon Glassd0cff032015-01-25 08:27:12 -070060/**
Simon Glass8a8d24b2020-12-03 16:55:23 -070061 * struct dm_spi_plat - platform data for all SPI slaves
Simon Glassd0cff032015-01-25 08:27:12 -070062 *
63 * This describes a SPI slave, a child device of the SPI bus. To obtain this
Simon Glasscaa4daa2020-12-03 16:55:18 -070064 * struct from a spi_slave, use dev_get_parent_plat(dev) or
65 * dev_get_parent_plat(slave->dev).
Simon Glassd0cff032015-01-25 08:27:12 -070066 *
Sean Anderson40fc33f2020-08-07 13:13:34 -040067 * This data is immutable. Each time the device is probed, @max_hz and @mode
Simon Glassd0cff032015-01-25 08:27:12 -070068 * 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 */
Simon Glass8a8d24b2020-12-03 16:55:23 -070074struct dm_spi_slave_plat {
Simon Glassd0cff032015-01-25 08:27:12 -070075 unsigned int cs;
76 uint max_hz;
77 uint mode;
78};
79
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +053080/**
Simon Glassb14ccfc2020-04-08 16:57:21 -060081 * 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 */
86enum 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 */
97enum 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 */
108enum spi_polarity {
109 SPI_POLARITY_LOW,
110 SPI_POLARITY_HIGH,
111};
112
113/**
Jagannadha Sutradharudu Tekice22b922013-10-07 19:34:56 +0530114 * struct spi_slave - Representation of a SPI slave
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200115 *
Simon Glassd7af6a42014-10-13 23:41:52 -0600116 * For driver model this is the per-child data used by the SPI bus. It can
Simon Glassbcbe3d12015-09-28 23:32:01 -0600117 * be accessed using dev_get_parent_priv() on the slave device. The SPI uclass
Simon Glass41575d82020-12-03 16:55:17 -0700118 * sets up per_child_auto to sizeof(struct spi_slave), and the
Simon Glassd0cff032015-01-25 08:27:12 -0700119 * 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.
Simon Glassd7af6a42014-10-13 23:41:52 -0600122 *
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
Simon Glassd7af6a42014-10-13 23:41:52 -0600128 * @bus: ID of the bus that the slave is attached to. For
129 * driver model this is the sequence number of the SPI
Simon Glass8b85dfc2020-12-16 21:20:07 -0700130 * bus (dev_seq(bus)) so does not need to be stored
Jagannadha Sutradharudu Tekice22b922013-10-07 19:34:56 +0530131 * @cs: ID of the chip select connected to the slave.
Jagan Tekif5c3c032015-12-14 12:15:17 +0530132 * @mode: SPI mode to use for this slave (see SPI mode flags)
Nikita Kiryanov5753d092013-10-16 17:23:25 +0300133 * @wordlen: Size of SPI word in number of bits
Álvaro Fernández Rojas8af74ed2018-01-23 17:14:56 +0100134 * @max_read_size: If non-zero, the maximum number of bytes which can
135 * be read at once.
Jagannadha Sutradharudu Tekice22b922013-10-07 19:34:56 +0530136 * @max_write_size: If non-zero, the maximum number of bytes which can
Álvaro Fernández Rojas6c94bd12018-01-23 17:14:57 +0100137 * be written at once.
Jagannadha Sutradharudu Tekice22b922013-10-07 19:34:56 +0530138 * @memory_map: Address of read-only SPI flash access.
Jagannadha Sutradharudu Tekif77f4692014-01-12 21:40:11 +0530139 * @flags: Indication of SPI flags.
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200140 */
141struct spi_slave {
Lukasz Majewski56c40462020-06-04 23:11:53 +0800142#if CONFIG_IS_ENABLED(DM_SPI)
Simon Glassd7af6a42014-10-13 23:41:52 -0600143 struct udevice *dev; /* struct spi_slave is dev->parentdata */
144 uint max_hz;
Simon Glassd7af6a42014-10-13 23:41:52 -0600145#else
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530146 unsigned int bus;
147 unsigned int cs;
Simon Glassd0cff032015-01-25 08:27:12 -0700148#endif
Jagan Tekif5c3c032015-12-14 12:15:17 +0530149 uint mode;
Nikita Kiryanov5753d092013-10-16 17:23:25 +0300150 unsigned int wordlen;
Álvaro Fernández Rojas8af74ed2018-01-23 17:14:56 +0100151 unsigned int max_read_size;
Simon Glass0c456ce2013-03-11 06:08:05 +0000152 unsigned int max_write_size;
Poddar, Sourav004f15b2013-10-07 15:53:01 +0530153 void *memory_map;
Jagan Tekic40f6002015-12-28 22:23:14 +0530154
Jagannadha Sutradharudu Tekif77f4692014-01-12 21:40:11 +0530155 u8 flags;
Jagan Teki29ee0262015-12-28 22:24:08 +0530156#define SPI_XFER_BEGIN BIT(0) /* Assert CS before transfer */
157#define SPI_XFER_END BIT(1) /* Deassert CS after transfer */
Jagan Tekic40f6002015-12-28 22:23:14 +0530158#define SPI_XFER_ONCE (SPI_XFER_BEGIN | SPI_XFER_END)
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200159};
wdenk77f85582002-09-26 02:01:47 +0000160
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530161/**
Simon Glassba6c3ce2013-03-11 06:08:00 +0000162 * 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 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530167 * @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.
Simon Glassba6c3ce2013-03-11 06:08:00 +0000171 */
172void *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 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530181 * @_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.
Simon Glassba6c3ce2013-03-11 06:08:00 +0000185 */
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 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530196 * @bus: Bus ID of the slave chip.
197 * @cs: Chip select ID of the slave chip on the specified bus.
Simon Glassba6c3ce2013-03-11 06:08:00 +0000198 */
199#define spi_alloc_slave_base(bus, cs) \
200 spi_do_alloc_slave(0, sizeof(struct spi_slave), bus, cs)
201
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530202/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200203 * 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 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530210 * @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.
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200214 *
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 */
218struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs,
219 unsigned int max_hz, unsigned int mode);
220
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530221/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200222 * Free any memory associated with a SPI slave.
223 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530224 * @slave: The SPI slave
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200225 */
226void spi_free_slave(struct spi_slave *slave);
227
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530228/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200229 * 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 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530237 * @slave: The SPI slave
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200238 *
239 * Returns: 0 if the bus was claimed successfully, or a negative value
240 * if it wasn't.
241 */
242int spi_claim_bus(struct spi_slave *slave);
243
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530244/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200245 * 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 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530251 * @slave: The SPI slave
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200252 */
253void spi_release_bus(struct spi_slave *slave);
wdenk77f85582002-09-26 02:01:47 +0000254
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530255/**
Nikita Kiryanov5753d092013-10-16 17:23:25 +0300256 * 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 */
265int spi_set_wordlen(struct spi_slave *slave, unsigned int wordlen);
266
267/**
Simon Glassccdabd82019-12-06 21:42:35 -0700268 * SPI transfer (optional if mem_ops is used)
wdenk77f85582002-09-26 02:01:47 +0000269 *
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 *
wdenk77f85582002-09-26 02:01:47 +0000279 * spi_xfer() interface:
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530280 * @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
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200283 * held in a byte array and are sent MSB first.
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530284 * @din: Pointer to a string of bits that will be filled in.
285 * @flags: A bitwise combination of SPI_XFER_* flags.
wdenk77f85582002-09-26 02:01:47 +0000286 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530287 * Returns: 0 on success, not 0 on failure
wdenk77f85582002-09-26 02:01:47 +0000288 */
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200289int spi_xfer(struct spi_slave *slave, unsigned int bitlen, const void *dout,
290 void *din, unsigned long flags);
Guennadi Liakhovetski38254f42008-04-15 14:14:25 +0200291
Jagan Teki8473b322019-07-22 17:22:56 +0530292/**
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 */
308int 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
Tom Rini146bad92015-08-17 13:29:54 +0530312/* Copy memory mapped data */
313void spi_flash_copy_mmap(void *data, void *offset, size_t len);
314
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530315/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200316 * 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 */
Simon Glassd7af6a42014-10-13 23:41:52 -0600323int spi_cs_is_valid(unsigned int bus, unsigned int cs);
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200324
Simon Glass324ec5d2020-07-08 09:02:14 -0600325/*
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 */
Lukasz Majewski56c40462020-06-04 23:11:53 +0800330#if !CONFIG_IS_ENABLED(DM_SPI)
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530331/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200332 * 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 */
338void spi_cs_activate(struct spi_slave *slave);
339
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530340/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200341 * 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 */
347void spi_cs_deactivate(struct spi_slave *slave);
Simon Glass324ec5d2020-07-08 09:02:14 -0600348#endif
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200349
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530350/**
Thomas Choufa1423e2010-12-24 15:16:07 +0800351 * Set transfer speed.
352 * This sets a new speed to be applied for next spi_xfer().
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530353 * @slave: The SPI slave
354 * @hz: The transfer speed
Thomas Choufa1423e2010-12-24 15:16:07 +0800355 */
356void spi_set_speed(struct spi_slave *slave, uint hz);
357
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530358/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200359 * Write 8 bits, then read 8 bits.
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530360 * @slave: The SPI slave we're communicating with
361 * @byte: Byte to be written
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200362 *
363 * Returns: The value that was read, or a negative value on error.
364 *
365 * TODO: This function probably shouldn't be inlined.
366 */
367static 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}
wdenk77f85582002-09-26 02:01:47 +0000379
Simon Glassd7af6a42014-10-13 23:41:52 -0600380/**
381 * struct spi_cs_info - Information about a bus chip select
382 *
383 * @dev: Connected device, or NULL if none
384 */
385struct 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 */
395struct 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 *
Simon Glass9694b722015-04-19 09:05:40 -0600408 * @dev: The SPI slave
Simon Glassd7af6a42014-10-13 23:41:52 -0600409 *
410 * Returns: 0 if the bus was claimed successfully, or a negative value
411 * if it wasn't.
412 */
Simon Glass9694b722015-04-19 09:05:40 -0600413 int (*claim_bus)(struct udevice *dev);
Simon Glassd7af6a42014-10-13 23:41:52 -0600414
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 *
Simon Glass9694b722015-04-19 09:05:40 -0600422 * @dev: The SPI slave
Simon Glassd7af6a42014-10-13 23:41:52 -0600423 */
Simon Glass9694b722015-04-19 09:05:40 -0600424 int (*release_bus)(struct udevice *dev);
Simon Glassd7af6a42014-10-13 23:41:52 -0600425
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 */
Simon Glass9694b722015-04-19 09:05:40 -0600436 int (*set_wordlen)(struct udevice *dev, unsigned int wordlen);
Simon Glassd7af6a42014-10-13 23:41:52 -0600437
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 /**
Boris Brezillond13f5b22018-08-16 17:30:11 +0200465 * 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 /**
Simon Glassd7af6a42014-10-13 23:41:52 -0600474 * 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
Bin Meng4b060002019-09-09 06:00:01 -0700505 * @return 0 if OK (and @info is set up), -EINVAL if the chip select
Simon Glassd7af6a42014-10-13 23:41:52 -0600506 * is invalid, other -ve value on error
507 */
508 int (*cs_info)(struct udevice *bus, uint cs, struct spi_cs_info *info);
Simon Glassc53b3182019-10-20 21:31:47 -0600509
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);
Simon Glassd7af6a42014-10-13 23:41:52 -0600522};
523
Simon Glassc60e1f22014-10-13 23:41:53 -0600524struct 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
Simon Glassd7af6a42014-10-13 23:41:52 -0600553/**
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
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100564 * Return: 0 if found, -ENODEV on error
Simon Glassd7af6a42014-10-13 23:41:52 -0600565 */
566int 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
Patrick Delaunayb0cc1b82019-02-27 15:36:44 +0100576 * is automatically bound on this chip select with requested speed and mode.
Simon Glassd7af6a42014-10-13 23:41:52 -0600577 *
Patrick Delaunayb0cc1b82019-02-27 15:36:44 +0100578 * Ths new slave device is probed ready for use with the speed and mode
Simon Glasscaa4daa2020-12-03 16:55:18 -0700579 * from plat when available or the requested values.
Simon Glassd7af6a42014-10-13 23:41:52 -0600580 *
581 * @busnum: SPI bus number
582 * @cs: Chip select to look for
Simon Glasscaa4daa2020-12-03 16:55:18 -0700583 * @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
Simon Glassd7af6a42014-10-13 23:41:52 -0600585 * @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
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100589 * Return: 0 if found, -ve on error
Simon Glassd7af6a42014-10-13 23:41:52 -0600590 */
591int 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 *
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100598 * Return: the chip select this slave is attached to
Simon Glassd7af6a42014-10-13 23:41:52 -0600599 */
600int spi_chip_select(struct udevice *slave);
601
602/**
Simon Glassff56bba2014-11-11 10:46:22 -0700603 * 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
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100608 * Return: 0 if found, -EINVAL if cs is invalid, -ENODEV if no device attached,
Bin Meng7bacce52019-09-09 06:00:02 -0700609 * other -ve value on error
Simon Glassff56bba2014-11-11 10:46:22 -0700610 */
611int spi_find_chip_select(struct udevice *bus, int cs, struct udevice **devp);
612
613/**
Simon Glassd1998a92020-12-03 16:55:21 -0700614 * spi_slave_of_to_plat() - decode standard SPI platform data
Simon Glassd7af6a42014-10-13 23:41:52 -0600615 *
Simon Glassd0cff032015-01-25 08:27:12 -0700616 * This decodes the speed and mode for a slave from a device tree node
Simon Glassd7af6a42014-10-13 23:41:52 -0600617 *
618 * @blob: Device tree blob
619 * @node: Node offset to read from
Simon Glassd0cff032015-01-25 08:27:12 -0700620 * @plat: Place to put the decoded information
Simon Glassd7af6a42014-10-13 23:41:52 -0600621 */
Simon Glass8a8d24b2020-12-03 16:55:23 -0700622int spi_slave_of_to_plat(struct udevice *dev, struct dm_spi_slave_plat *plat);
Simon Glassd7af6a42014-10-13 23:41:52 -0600623
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
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100633 * Return: 0 if OK (and @info is set up), -ENODEV if the chip select
Simon Glassd7af6a42014-10-13 23:41:52 -0600634 * is invalid, other -ve value on error
635 */
636int spi_cs_info(struct udevice *bus, uint cs, struct spi_cs_info *info);
637
638struct sandbox_state;
Simon Glassc60e1f22014-10-13 23:41:53 -0600639
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
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100652 * Return: 0 if OK, -ve on error
Simon Glassc60e1f22014-10-13 23:41:53 -0600653 */
Simon Glassd7af6a42014-10-13 23:41:52 -0600654int sandbox_spi_get_emul(struct sandbox_state *state,
655 struct udevice *bus, struct udevice *slave,
656 struct udevice **emulp);
657
Peng Fan7a3eff42016-05-03 10:02:22 +0800658/**
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 */
672int 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 */
683void 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 */
707int dm_spi_xfer(struct udevice *dev, unsigned int bitlen,
708 const void *dout, void *din, unsigned long flags);
709
Simon Glassc53b3182019-10-20 21:31:47 -0600710/**
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)
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100718 * Return: 0 if OK, -ENOSYS if no operation, -EFAULT if memory mapping is not
Simon Glassc53b3182019-10-20 21:31:47 -0600719 * available
720 */
721int dm_spi_get_mmap(struct udevice *dev, ulong *map_basep, uint *map_sizep,
722 uint *offsetp);
723
Simon Glassbc5701e2015-04-20 12:37:12 -0600724/* Access the operations for a SPI device */
Simon Glassd7af6a42014-10-13 23:41:52 -0600725#define spi_get_ops(dev) ((struct dm_spi_ops *)(dev)->driver->ops)
Simon Glassc60e1f22014-10-13 23:41:53 -0600726#define spi_emul_get_ops(dev) ((struct dm_spi_emul_ops *)(dev)->driver->ops)
Simon Glassd7af6a42014-10-13 23:41:52 -0600727
wdenk77f85582002-09-26 02:01:47 +0000728#endif /* _SPI_H_ */