blob: 5cc6d6e0087fa5b00eff5d9489ff4838cf2e0a6a [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 */
Jagan Teki465c00d2015-12-29 12:12:30 +053016#define SPI_CPHA BIT(0) /* clock phase */
17#define SPI_CPOL BIT(1) /* clock polarity */
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 */
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
Simon Glassd7af6a42014-10-13 23:41:52 -060042#ifdef CONFIG_DM_SPI
Simon Glassd0cff032015-01-25 08:27:12 -070043/* TODO(sjg@chromium.org): Remove this and use max_hz from struct spi_slave */
Simon Glassd7af6a42014-10-13 23:41:52 -060044struct dm_spi_bus {
45 uint max_hz;
46};
47
Simon Glassd0cff032015-01-25 08:27:12 -070048/**
49 * struct dm_spi_platdata - platform data for all SPI slaves
50 *
51 * This describes a SPI slave, a child device of the SPI bus. To obtain this
52 * struct from a spi_slave, use dev_get_parent_platdata(dev) or
53 * dev_get_parent_platdata(slave->dev).
54 *
55 * This data is immuatable. Each time the device is probed, @max_hz and @mode
56 * will be copied to struct spi_slave.
57 *
58 * @cs: Chip select number (0..n-1)
59 * @max_hz: Maximum bus speed that this slave can tolerate
60 * @mode: SPI mode to use for this device (see SPI mode flags)
61 */
62struct dm_spi_slave_platdata {
63 unsigned int cs;
64 uint max_hz;
65 uint mode;
66};
67
Simon Glassd7af6a42014-10-13 23:41:52 -060068#endif /* CONFIG_DM_SPI */
69
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +053070/**
Simon Glassb14ccfc2020-04-08 16:57:21 -060071 * enum spi_clock_phase - indicates the clock phase to use for SPI (CPHA)
72 *
73 * @SPI_CLOCK_PHASE_FIRST: Data sampled on the first phase
74 * @SPI_CLOCK_PHASE_SECOND: Data sampled on the second phase
75 */
76enum spi_clock_phase {
77 SPI_CLOCK_PHASE_FIRST,
78 SPI_CLOCK_PHASE_SECOND,
79};
80
81/**
82 * enum spi_wire_mode - indicates the number of wires used for SPI
83 *
84 * @SPI_4_WIRE_MODE: Normal bidirectional mode with MOSI and MISO
85 * @SPI_3_WIRE_MODE: Unidirectional version with a single data line SISO
86 */
87enum spi_wire_mode {
88 SPI_4_WIRE_MODE,
89 SPI_3_WIRE_MODE,
90};
91
92/**
93 * enum spi_polarity - indicates the polarity of the SPI bus (CPOL)
94 *
95 * @SPI_POLARITY_LOW: Clock is low in idle state
96 * @SPI_POLARITY_HIGH: Clock is high in idle state
97 */
98enum spi_polarity {
99 SPI_POLARITY_LOW,
100 SPI_POLARITY_HIGH,
101};
102
103/**
Jagannadha Sutradharudu Tekice22b922013-10-07 19:34:56 +0530104 * struct spi_slave - Representation of a SPI slave
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200105 *
Simon Glassd7af6a42014-10-13 23:41:52 -0600106 * For driver model this is the per-child data used by the SPI bus. It can
Simon Glassbcbe3d12015-09-28 23:32:01 -0600107 * be accessed using dev_get_parent_priv() on the slave device. The SPI uclass
Simon Glassd0cff032015-01-25 08:27:12 -0700108 * sets uip per_child_auto_alloc_size to sizeof(struct spi_slave), and the
109 * driver should not override it. Two platform data fields (max_hz and mode)
110 * are copied into this structure to provide an initial value. This allows
111 * them to be changed, since we should never change platform data in drivers.
Simon Glassd7af6a42014-10-13 23:41:52 -0600112 *
113 * If not using driver model, drivers are expected to extend this with
114 * controller-specific data.
115 *
116 * @dev: SPI slave device
117 * @max_hz: Maximum speed for this slave
Simon Glass60e28092015-02-17 15:29:35 -0700118 * @speed: Current bus speed. This is 0 until the bus is first
119 * claimed.
Simon Glassd7af6a42014-10-13 23:41:52 -0600120 * @bus: ID of the bus that the slave is attached to. For
121 * driver model this is the sequence number of the SPI
122 * bus (bus->seq) so does not need to be stored
Jagannadha Sutradharudu Tekice22b922013-10-07 19:34:56 +0530123 * @cs: ID of the chip select connected to the slave.
Jagan Tekif5c3c032015-12-14 12:15:17 +0530124 * @mode: SPI mode to use for this slave (see SPI mode flags)
Nikita Kiryanov5753d092013-10-16 17:23:25 +0300125 * @wordlen: Size of SPI word in number of bits
Álvaro Fernández Rojas8af74ed2018-01-23 17:14:56 +0100126 * @max_read_size: If non-zero, the maximum number of bytes which can
127 * be read at once.
Jagannadha Sutradharudu Tekice22b922013-10-07 19:34:56 +0530128 * @max_write_size: If non-zero, the maximum number of bytes which can
Álvaro Fernández Rojas6c94bd12018-01-23 17:14:57 +0100129 * be written at once.
Jagannadha Sutradharudu Tekice22b922013-10-07 19:34:56 +0530130 * @memory_map: Address of read-only SPI flash access.
Jagannadha Sutradharudu Tekif77f4692014-01-12 21:40:11 +0530131 * @flags: Indication of SPI flags.
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200132 */
133struct spi_slave {
Simon Glassd7af6a42014-10-13 23:41:52 -0600134#ifdef CONFIG_DM_SPI
135 struct udevice *dev; /* struct spi_slave is dev->parentdata */
136 uint max_hz;
Simon Glass60e28092015-02-17 15:29:35 -0700137 uint speed;
Simon Glassd7af6a42014-10-13 23:41:52 -0600138#else
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530139 unsigned int bus;
140 unsigned int cs;
Simon Glassd0cff032015-01-25 08:27:12 -0700141#endif
Jagan Tekif5c3c032015-12-14 12:15:17 +0530142 uint mode;
Nikita Kiryanov5753d092013-10-16 17:23:25 +0300143 unsigned int wordlen;
Álvaro Fernández Rojas8af74ed2018-01-23 17:14:56 +0100144 unsigned int max_read_size;
Simon Glass0c456ce2013-03-11 06:08:05 +0000145 unsigned int max_write_size;
Poddar, Sourav004f15b2013-10-07 15:53:01 +0530146 void *memory_map;
Jagan Tekic40f6002015-12-28 22:23:14 +0530147
Jagannadha Sutradharudu Tekif77f4692014-01-12 21:40:11 +0530148 u8 flags;
Jagan Teki29ee0262015-12-28 22:24:08 +0530149#define SPI_XFER_BEGIN BIT(0) /* Assert CS before transfer */
150#define SPI_XFER_END BIT(1) /* Deassert CS after transfer */
Jagan Tekic40f6002015-12-28 22:23:14 +0530151#define SPI_XFER_ONCE (SPI_XFER_BEGIN | SPI_XFER_END)
Jagan Teki29ee0262015-12-28 22:24:08 +0530152#define SPI_XFER_MMAP BIT(2) /* Memory Mapped start */
153#define SPI_XFER_MMAP_END BIT(3) /* Memory Mapped End */
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200154};
wdenk77f85582002-09-26 02:01:47 +0000155
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530156/**
Simon Glassba6c3ce2013-03-11 06:08:00 +0000157 * spi_do_alloc_slave - Allocate a new SPI slave (internal)
158 *
159 * Allocate and zero all fields in the spi slave, and set the bus/chip
160 * select. Use the helper macro spi_alloc_slave() to call this.
161 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530162 * @offset: Offset of struct spi_slave within slave structure.
163 * @size: Size of slave structure.
164 * @bus: Bus ID of the slave chip.
165 * @cs: Chip select ID of the slave chip on the specified bus.
Simon Glassba6c3ce2013-03-11 06:08:00 +0000166 */
167void *spi_do_alloc_slave(int offset, int size, unsigned int bus,
168 unsigned int cs);
169
170/**
171 * spi_alloc_slave - Allocate a new SPI slave
172 *
173 * Allocate and zero all fields in the spi slave, and set the bus/chip
174 * select.
175 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530176 * @_struct: Name of structure to allocate (e.g. struct tegra_spi).
177 * This structure must contain a member 'struct spi_slave *slave'.
178 * @bus: Bus ID of the slave chip.
179 * @cs: Chip select ID of the slave chip on the specified bus.
Simon Glassba6c3ce2013-03-11 06:08:00 +0000180 */
181#define spi_alloc_slave(_struct, bus, cs) \
182 spi_do_alloc_slave(offsetof(_struct, slave), \
183 sizeof(_struct), bus, cs)
184
185/**
186 * spi_alloc_slave_base - Allocate a new SPI slave with no private data
187 *
188 * Allocate and zero all fields in the spi slave, and set the bus/chip
189 * select.
190 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530191 * @bus: Bus ID of the slave chip.
192 * @cs: Chip select ID of the slave chip on the specified bus.
Simon Glassba6c3ce2013-03-11 06:08:00 +0000193 */
194#define spi_alloc_slave_base(bus, cs) \
195 spi_do_alloc_slave(0, sizeof(struct spi_slave), bus, cs)
196
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530197/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200198 * Set up communications parameters for a SPI slave.
199 *
200 * This must be called once for each slave. Note that this function
201 * usually doesn't touch any actual hardware, it only initializes the
202 * contents of spi_slave so that the hardware can be easily
203 * initialized later.
204 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530205 * @bus: Bus ID of the slave chip.
206 * @cs: Chip select ID of the slave chip on the specified bus.
207 * @max_hz: Maximum SCK rate in Hz.
208 * @mode: Clock polarity, clock phase and other parameters.
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200209 *
210 * Returns: A spi_slave reference that can be used in subsequent SPI
211 * calls, or NULL if one or more of the parameters are not supported.
212 */
213struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs,
214 unsigned int max_hz, unsigned int mode);
215
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530216/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200217 * Free any memory associated with a SPI slave.
218 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530219 * @slave: The SPI slave
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200220 */
221void spi_free_slave(struct spi_slave *slave);
222
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530223/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200224 * Claim the bus and prepare it for communication with a given slave.
225 *
226 * This must be called before doing any transfers with a SPI slave. It
227 * will enable and initialize any SPI hardware as necessary, and make
228 * sure that the SCK line is in the correct idle state. It is not
229 * allowed to claim the same bus for several slaves without releasing
230 * the bus in between.
231 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530232 * @slave: The SPI slave
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200233 *
234 * Returns: 0 if the bus was claimed successfully, or a negative value
235 * if it wasn't.
236 */
237int spi_claim_bus(struct spi_slave *slave);
238
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530239/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200240 * Release the SPI bus
241 *
242 * This must be called once for every call to spi_claim_bus() after
243 * all transfers have finished. It may disable any SPI hardware as
244 * appropriate.
245 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530246 * @slave: The SPI slave
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200247 */
248void spi_release_bus(struct spi_slave *slave);
wdenk77f85582002-09-26 02:01:47 +0000249
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530250/**
Nikita Kiryanov5753d092013-10-16 17:23:25 +0300251 * Set the word length for SPI transactions
252 *
253 * Set the word length (number of bits per word) for SPI transactions.
254 *
255 * @slave: The SPI slave
256 * @wordlen: The number of bits in a word
257 *
258 * Returns: 0 on success, -1 on failure.
259 */
260int spi_set_wordlen(struct spi_slave *slave, unsigned int wordlen);
261
262/**
Simon Glassccdabd82019-12-06 21:42:35 -0700263 * SPI transfer (optional if mem_ops is used)
wdenk77f85582002-09-26 02:01:47 +0000264 *
265 * This writes "bitlen" bits out the SPI MOSI port and simultaneously clocks
266 * "bitlen" bits in the SPI MISO port. That's just the way SPI works.
267 *
268 * The source of the outgoing bits is the "dout" parameter and the
269 * destination of the input bits is the "din" parameter. Note that "dout"
270 * and "din" can point to the same memory location, in which case the
271 * input data overwrites the output data (since both are buffered by
272 * temporary variables, this is OK).
273 *
wdenk77f85582002-09-26 02:01:47 +0000274 * spi_xfer() interface:
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530275 * @slave: The SPI slave which will be sending/receiving the data.
276 * @bitlen: How many bits to write and read.
277 * @dout: Pointer to a string of bits to send out. The bits are
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200278 * held in a byte array and are sent MSB first.
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530279 * @din: Pointer to a string of bits that will be filled in.
280 * @flags: A bitwise combination of SPI_XFER_* flags.
wdenk77f85582002-09-26 02:01:47 +0000281 *
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530282 * Returns: 0 on success, not 0 on failure
wdenk77f85582002-09-26 02:01:47 +0000283 */
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200284int spi_xfer(struct spi_slave *slave, unsigned int bitlen, const void *dout,
285 void *din, unsigned long flags);
Guennadi Liakhovetski38254f42008-04-15 14:14:25 +0200286
Jagan Teki8473b322019-07-22 17:22:56 +0530287/**
288 * spi_write_then_read - SPI synchronous write followed by read
289 *
290 * This performs a half duplex transaction in which the first transaction
291 * is to send the opcode and if the length of buf is non-zero then it start
292 * the second transaction as tx or rx based on the need from respective slave.
293 *
294 * @slave: The SPI slave device with which opcode/data will be exchanged
295 * @opcode: opcode used for specific transfer
296 * @n_opcode: size of opcode, in bytes
297 * @txbuf: buffer into which data to be written
298 * @rxbuf: buffer into which data will be read
299 * @n_buf: size of buf (whether it's [tx|rx]buf), in bytes
300 *
301 * Returns: 0 on success, not 0 on failure
302 */
303int spi_write_then_read(struct spi_slave *slave, const u8 *opcode,
304 size_t n_opcode, const u8 *txbuf, u8 *rxbuf,
305 size_t n_buf);
306
Tom Rini146bad92015-08-17 13:29:54 +0530307/* Copy memory mapped data */
308void spi_flash_copy_mmap(void *data, void *offset, size_t len);
309
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530310/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200311 * Determine if a SPI chipselect is valid.
312 * This function is provided by the board if the low-level SPI driver
313 * needs it to determine if a given chipselect is actually valid.
314 *
315 * Returns: 1 if bus:cs identifies a valid chip on this board, 0
316 * otherwise.
317 */
Simon Glassd7af6a42014-10-13 23:41:52 -0600318int spi_cs_is_valid(unsigned int bus, unsigned int cs);
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200319
Simon Glassd7af6a42014-10-13 23:41:52 -0600320#ifndef CONFIG_DM_SPI
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530321/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200322 * Activate a SPI chipselect.
323 * This function is provided by the board code when using a driver
324 * that can't control its chipselects automatically (e.g.
325 * common/soft_spi.c). When called, it should activate the chip select
326 * to the device identified by "slave".
327 */
328void spi_cs_activate(struct spi_slave *slave);
329
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530330/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200331 * Deactivate a SPI chipselect.
332 * This function is provided by the board code when using a driver
333 * that can't control its chipselects automatically (e.g.
334 * common/soft_spi.c). When called, it should deactivate the chip
335 * select to the device identified by "slave".
336 */
337void spi_cs_deactivate(struct spi_slave *slave);
338
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530339/**
Thomas Choufa1423e2010-12-24 15:16:07 +0800340 * Set transfer speed.
341 * This sets a new speed to be applied for next spi_xfer().
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530342 * @slave: The SPI slave
343 * @hz: The transfer speed
Thomas Choufa1423e2010-12-24 15:16:07 +0800344 */
345void spi_set_speed(struct spi_slave *slave, uint hz);
Simon Glassd7af6a42014-10-13 23:41:52 -0600346#endif
Thomas Choufa1423e2010-12-24 15:16:07 +0800347
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530348/**
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200349 * Write 8 bits, then read 8 bits.
Jagannadha Sutradharudu Teki1b1bd9a2013-09-25 15:47:36 +0530350 * @slave: The SPI slave we're communicating with
351 * @byte: Byte to be written
Haavard Skinnemoend255bb02008-05-16 11:10:31 +0200352 *
353 * Returns: The value that was read, or a negative value on error.
354 *
355 * TODO: This function probably shouldn't be inlined.
356 */
357static inline int spi_w8r8(struct spi_slave *slave, unsigned char byte)
358{
359 unsigned char dout[2];
360 unsigned char din[2];
361 int ret;
362
363 dout[0] = byte;
364 dout[1] = 0;
365
366 ret = spi_xfer(slave, 16, dout, din, SPI_XFER_BEGIN | SPI_XFER_END);
367 return ret < 0 ? ret : din[1];
368}
wdenk77f85582002-09-26 02:01:47 +0000369
Simon Glassd7af6a42014-10-13 23:41:52 -0600370#ifdef CONFIG_DM_SPI
371
372/**
373 * struct spi_cs_info - Information about a bus chip select
374 *
375 * @dev: Connected device, or NULL if none
376 */
377struct spi_cs_info {
378 struct udevice *dev;
379};
380
381/**
382 * struct struct dm_spi_ops - Driver model SPI operations
383 *
384 * The uclass interface is implemented by all SPI devices which use
385 * driver model.
386 */
387struct dm_spi_ops {
388 /**
389 * Claim the bus and prepare it for communication.
390 *
391 * The device provided is the slave device. It's parent controller
392 * will be used to provide the communication.
393 *
394 * This must be called before doing any transfers with a SPI slave. It
395 * will enable and initialize any SPI hardware as necessary, and make
396 * sure that the SCK line is in the correct idle state. It is not
397 * allowed to claim the same bus for several slaves without releasing
398 * the bus in between.
399 *
Simon Glass9694b722015-04-19 09:05:40 -0600400 * @dev: The SPI slave
Simon Glassd7af6a42014-10-13 23:41:52 -0600401 *
402 * Returns: 0 if the bus was claimed successfully, or a negative value
403 * if it wasn't.
404 */
Simon Glass9694b722015-04-19 09:05:40 -0600405 int (*claim_bus)(struct udevice *dev);
Simon Glassd7af6a42014-10-13 23:41:52 -0600406
407 /**
408 * Release the SPI bus
409 *
410 * This must be called once for every call to spi_claim_bus() after
411 * all transfers have finished. It may disable any SPI hardware as
412 * appropriate.
413 *
Simon Glass9694b722015-04-19 09:05:40 -0600414 * @dev: The SPI slave
Simon Glassd7af6a42014-10-13 23:41:52 -0600415 */
Simon Glass9694b722015-04-19 09:05:40 -0600416 int (*release_bus)(struct udevice *dev);
Simon Glassd7af6a42014-10-13 23:41:52 -0600417
418 /**
419 * Set the word length for SPI transactions
420 *
421 * Set the word length (number of bits per word) for SPI transactions.
422 *
423 * @bus: The SPI slave
424 * @wordlen: The number of bits in a word
425 *
426 * Returns: 0 on success, -ve on failure.
427 */
Simon Glass9694b722015-04-19 09:05:40 -0600428 int (*set_wordlen)(struct udevice *dev, unsigned int wordlen);
Simon Glassd7af6a42014-10-13 23:41:52 -0600429
430 /**
431 * SPI transfer
432 *
433 * This writes "bitlen" bits out the SPI MOSI port and simultaneously
434 * clocks "bitlen" bits in the SPI MISO port. That's just the way SPI
435 * works.
436 *
437 * The source of the outgoing bits is the "dout" parameter and the
438 * destination of the input bits is the "din" parameter. Note that
439 * "dout" and "din" can point to the same memory location, in which
440 * case the input data overwrites the output data (since both are
441 * buffered by temporary variables, this is OK).
442 *
443 * spi_xfer() interface:
444 * @dev: The slave device to communicate with
445 * @bitlen: How many bits to write and read.
446 * @dout: Pointer to a string of bits to send out. The bits are
447 * held in a byte array and are sent MSB first.
448 * @din: Pointer to a string of bits that will be filled in.
449 * @flags: A bitwise combination of SPI_XFER_* flags.
450 *
451 * Returns: 0 on success, not -1 on failure
452 */
453 int (*xfer)(struct udevice *dev, unsigned int bitlen, const void *dout,
454 void *din, unsigned long flags);
455
456 /**
Boris Brezillond13f5b22018-08-16 17:30:11 +0200457 * Optimized handlers for SPI memory-like operations.
458 *
459 * Optimized/dedicated operations for interactions with SPI memory. This
460 * field is optional and should only be implemented if the controller
461 * has native support for memory like operations.
462 */
463 const struct spi_controller_mem_ops *mem_ops;
464
465 /**
Simon Glassd7af6a42014-10-13 23:41:52 -0600466 * Set transfer speed.
467 * This sets a new speed to be applied for next spi_xfer().
468 * @bus: The SPI bus
469 * @hz: The transfer speed
470 * @return 0 if OK, -ve on error
471 */
472 int (*set_speed)(struct udevice *bus, uint hz);
473
474 /**
475 * Set the SPI mode/flags
476 *
477 * It is unclear if we want to set speed and mode together instead
478 * of separately.
479 *
480 * @bus: The SPI bus
481 * @mode: Requested SPI mode (SPI_... flags)
482 * @return 0 if OK, -ve on error
483 */
484 int (*set_mode)(struct udevice *bus, uint mode);
485
486 /**
487 * Get information on a chip select
488 *
489 * This is only called when the SPI uclass does not know about a
490 * chip select, i.e. it has no attached device. It gives the driver
491 * a chance to allow activity on that chip select even so.
492 *
493 * @bus: The SPI bus
494 * @cs: The chip select (0..n-1)
495 * @info: Returns information about the chip select, if valid.
496 * On entry info->dev is NULL
Bin Meng4b060002019-09-09 06:00:01 -0700497 * @return 0 if OK (and @info is set up), -EINVAL if the chip select
Simon Glassd7af6a42014-10-13 23:41:52 -0600498 * is invalid, other -ve value on error
499 */
500 int (*cs_info)(struct udevice *bus, uint cs, struct spi_cs_info *info);
Simon Glassc53b3182019-10-20 21:31:47 -0600501
502 /**
503 * get_mmap() - Get memory-mapped SPI
504 *
505 * @dev: The SPI flash slave device
506 * @map_basep: Returns base memory address for mapped SPI
507 * @map_sizep: Returns size of mapped SPI
508 * @offsetp: Returns start offset of SPI flash where the map works
509 * correctly (offsets before this are not visible)
510 * @return 0 if OK, -EFAULT if memory mapping is not available
511 */
512 int (*get_mmap)(struct udevice *dev, ulong *map_basep,
513 uint *map_sizep, uint *offsetp);
Simon Glassd7af6a42014-10-13 23:41:52 -0600514};
515
Simon Glassc60e1f22014-10-13 23:41:53 -0600516struct dm_spi_emul_ops {
517 /**
518 * SPI transfer
519 *
520 * This writes "bitlen" bits out the SPI MOSI port and simultaneously
521 * clocks "bitlen" bits in the SPI MISO port. That's just the way SPI
522 * works. Here the device is a slave.
523 *
524 * The source of the outgoing bits is the "dout" parameter and the
525 * destination of the input bits is the "din" parameter. Note that
526 * "dout" and "din" can point to the same memory location, in which
527 * case the input data overwrites the output data (since both are
528 * buffered by temporary variables, this is OK).
529 *
530 * spi_xfer() interface:
531 * @slave: The SPI slave which will be sending/receiving the data.
532 * @bitlen: How many bits to write and read.
533 * @dout: Pointer to a string of bits sent to the device. The
534 * bits are held in a byte array and are sent MSB first.
535 * @din: Pointer to a string of bits that will be sent back to
536 * the master.
537 * @flags: A bitwise combination of SPI_XFER_* flags.
538 *
539 * Returns: 0 on success, not -1 on failure
540 */
541 int (*xfer)(struct udevice *slave, unsigned int bitlen,
542 const void *dout, void *din, unsigned long flags);
543};
544
Simon Glassd7af6a42014-10-13 23:41:52 -0600545/**
546 * spi_find_bus_and_cs() - Find bus and slave devices by number
547 *
548 * Given a bus number and chip select, this finds the corresponding bus
549 * device and slave device. Neither device is activated by this function,
550 * although they may have been activated previously.
551 *
552 * @busnum: SPI bus number
553 * @cs: Chip select to look for
554 * @busp: Returns bus device
555 * @devp: Return slave device
556 * @return 0 if found, -ENODEV on error
557 */
558int spi_find_bus_and_cs(int busnum, int cs, struct udevice **busp,
559 struct udevice **devp);
560
561/**
562 * spi_get_bus_and_cs() - Find and activate bus and slave devices by number
563 *
564 * Given a bus number and chip select, this finds the corresponding bus
565 * device and slave device.
566 *
567 * If no such slave exists, and drv_name is not NULL, then a new slave device
Patrick Delaunayb0cc1b82019-02-27 15:36:44 +0100568 * is automatically bound on this chip select with requested speed and mode.
Simon Glassd7af6a42014-10-13 23:41:52 -0600569 *
Patrick Delaunayb0cc1b82019-02-27 15:36:44 +0100570 * Ths new slave device is probed ready for use with the speed and mode
571 * from platdata when available or the requested values.
Simon Glassd7af6a42014-10-13 23:41:52 -0600572 *
573 * @busnum: SPI bus number
574 * @cs: Chip select to look for
Patrick Delaunayb0cc1b82019-02-27 15:36:44 +0100575 * @speed: SPI speed to use for this slave when not available in platdata
576 * @mode: SPI mode to use for this slave when not available in platdata
Simon Glassd7af6a42014-10-13 23:41:52 -0600577 * @drv_name: Name of driver to attach to this chip select
578 * @dev_name: Name of the new device thus created
579 * @busp: Returns bus device
580 * @devp: Return slave device
581 * @return 0 if found, -ve on error
582 */
583int spi_get_bus_and_cs(int busnum, int cs, int speed, int mode,
584 const char *drv_name, const char *dev_name,
585 struct udevice **busp, struct spi_slave **devp);
586
587/**
588 * spi_chip_select() - Get the chip select for a slave
589 *
590 * @return the chip select this slave is attached to
591 */
592int spi_chip_select(struct udevice *slave);
593
594/**
Simon Glassff56bba2014-11-11 10:46:22 -0700595 * spi_find_chip_select() - Find the slave attached to chip select
596 *
597 * @bus: SPI bus to search
598 * @cs: Chip select to look for
599 * @devp: Returns the slave device if found
Bin Meng7bacce52019-09-09 06:00:02 -0700600 * @return 0 if found, -EINVAL if cs is invalid, -ENODEV if no device attached,
601 * other -ve value on error
Simon Glassff56bba2014-11-11 10:46:22 -0700602 */
603int spi_find_chip_select(struct udevice *bus, int cs, struct udevice **devp);
604
605/**
Simon Glassd0cff032015-01-25 08:27:12 -0700606 * spi_slave_ofdata_to_platdata() - decode standard SPI platform data
Simon Glassd7af6a42014-10-13 23:41:52 -0600607 *
Simon Glassd0cff032015-01-25 08:27:12 -0700608 * This decodes the speed and mode for a slave from a device tree node
Simon Glassd7af6a42014-10-13 23:41:52 -0600609 *
610 * @blob: Device tree blob
611 * @node: Node offset to read from
Simon Glassd0cff032015-01-25 08:27:12 -0700612 * @plat: Place to put the decoded information
Simon Glassd7af6a42014-10-13 23:41:52 -0600613 */
Simon Glass279e26f2017-05-18 20:09:54 -0600614int spi_slave_ofdata_to_platdata(struct udevice *dev,
Simon Glassd0cff032015-01-25 08:27:12 -0700615 struct dm_spi_slave_platdata *plat);
Simon Glassd7af6a42014-10-13 23:41:52 -0600616
617/**
618 * spi_cs_info() - Check information on a chip select
619 *
620 * This checks a particular chip select on a bus to see if it has a device
621 * attached, or is even valid.
622 *
623 * @bus: The SPI bus
624 * @cs: The chip select (0..n-1)
625 * @info: Returns information about the chip select, if valid
626 * @return 0 if OK (and @info is set up), -ENODEV if the chip select
627 * is invalid, other -ve value on error
628 */
629int spi_cs_info(struct udevice *bus, uint cs, struct spi_cs_info *info);
630
631struct sandbox_state;
Simon Glassc60e1f22014-10-13 23:41:53 -0600632
633/**
634 * sandbox_spi_get_emul() - get an emulator for a SPI slave
635 *
636 * This provides a way to attach an emulated SPI device to a particular SPI
637 * slave, so that xfer() operations on the slave will be handled by the
638 * emulator. If a emulator already exists on that chip select it is returned.
639 * Otherwise one is created.
640 *
641 * @state: Sandbox state
642 * @bus: SPI bus requesting the emulator
643 * @slave: SPI slave device requesting the emulator
644 * @emuip: Returns pointer to emulator
645 * @return 0 if OK, -ve on error
646 */
Simon Glassd7af6a42014-10-13 23:41:52 -0600647int sandbox_spi_get_emul(struct sandbox_state *state,
648 struct udevice *bus, struct udevice *slave,
649 struct udevice **emulp);
650
Peng Fan7a3eff42016-05-03 10:02:22 +0800651/**
652 * Claim the bus and prepare it for communication with a given slave.
653 *
654 * This must be called before doing any transfers with a SPI slave. It
655 * will enable and initialize any SPI hardware as necessary, and make
656 * sure that the SCK line is in the correct idle state. It is not
657 * allowed to claim the same bus for several slaves without releasing
658 * the bus in between.
659 *
660 * @dev: The SPI slave device
661 *
662 * Returns: 0 if the bus was claimed successfully, or a negative value
663 * if it wasn't.
664 */
665int dm_spi_claim_bus(struct udevice *dev);
666
667/**
668 * Release the SPI bus
669 *
670 * This must be called once for every call to dm_spi_claim_bus() after
671 * all transfers have finished. It may disable any SPI hardware as
672 * appropriate.
673 *
674 * @slave: The SPI slave device
675 */
676void dm_spi_release_bus(struct udevice *dev);
677
678/**
679 * SPI transfer
680 *
681 * This writes "bitlen" bits out the SPI MOSI port and simultaneously clocks
682 * "bitlen" bits in the SPI MISO port. That's just the way SPI works.
683 *
684 * The source of the outgoing bits is the "dout" parameter and the
685 * destination of the input bits is the "din" parameter. Note that "dout"
686 * and "din" can point to the same memory location, in which case the
687 * input data overwrites the output data (since both are buffered by
688 * temporary variables, this is OK).
689 *
690 * dm_spi_xfer() interface:
691 * @dev: The SPI slave device which will be sending/receiving the data.
692 * @bitlen: How many bits to write and read.
693 * @dout: Pointer to a string of bits to send out. The bits are
694 * held in a byte array and are sent MSB first.
695 * @din: Pointer to a string of bits that will be filled in.
696 * @flags: A bitwise combination of SPI_XFER_* flags.
697 *
698 * Returns: 0 on success, not 0 on failure
699 */
700int dm_spi_xfer(struct udevice *dev, unsigned int bitlen,
701 const void *dout, void *din, unsigned long flags);
702
Simon Glassc53b3182019-10-20 21:31:47 -0600703/**
704 * spi_get_mmap() - Get memory-mapped SPI
705 *
706 * @dev: SPI slave device to check
707 * @map_basep: Returns base memory address for mapped SPI
708 * @map_sizep: Returns size of mapped SPI
709 * @offsetp: Returns start offset of SPI flash where the map works
710 * correctly (offsets before this are not visible)
711 * @return 0 if OK, -ENOSYS if no operation, -EFAULT if memory mapping is not
712 * available
713 */
714int dm_spi_get_mmap(struct udevice *dev, ulong *map_basep, uint *map_sizep,
715 uint *offsetp);
716
Simon Glassbc5701e2015-04-20 12:37:12 -0600717/* Access the operations for a SPI device */
Simon Glassd7af6a42014-10-13 23:41:52 -0600718#define spi_get_ops(dev) ((struct dm_spi_ops *)(dev)->driver->ops)
Simon Glassc60e1f22014-10-13 23:41:53 -0600719#define spi_emul_get_ops(dev) ((struct dm_spi_emul_ops *)(dev)->driver->ops)
Simon Glassd7af6a42014-10-13 23:41:52 -0600720#endif /* CONFIG_DM_SPI */
721
wdenk77f85582002-09-26 02:01:47 +0000722#endif /* _SPI_H_ */