1 /* SPDX-License-Identifier: GPL-2.0+ */
3 * Copyright (C) 2018 Exceet Electronics GmbH
4 * Copyright (C) 2018 Bootlin
7 * Peter Pan <peterpandong@micron.com>
8 * Boris Brezillon <boris.brezillon@bootlin.com>
11 #ifndef __UBOOT_SPI_MEM_H
12 #define __UBOOT_SPI_MEM_H
16 #define SPI_MEM_OP_CMD(__opcode, __buswidth) \
18 .buswidth = __buswidth, \
22 #define SPI_MEM_OP_ADDR(__nbytes, __val, __buswidth) \
26 .buswidth = __buswidth, \
29 #define SPI_MEM_OP_NO_ADDR { }
31 #define SPI_MEM_OP_DUMMY(__nbytes, __buswidth) \
34 .buswidth = __buswidth, \
37 #define SPI_MEM_OP_NO_DUMMY { }
39 #define SPI_MEM_OP_DATA_IN(__nbytes, __buf, __buswidth) \
41 .dir = SPI_MEM_DATA_IN, \
44 .buswidth = __buswidth, \
47 #define SPI_MEM_OP_DATA_OUT(__nbytes, __buf, __buswidth) \
49 .dir = SPI_MEM_DATA_OUT, \
52 .buswidth = __buswidth, \
55 #define SPI_MEM_OP_NO_DATA { }
58 * enum spi_mem_data_dir - describes the direction of a SPI memory data
59 * transfer from the controller perspective
60 * @SPI_MEM_NO_DATA: no data transferred
61 * @SPI_MEM_DATA_IN: data coming from the SPI memory
62 * @SPI_MEM_DATA_OUT: data sent the SPI memory
64 enum spi_mem_data_dir {
71 * struct spi_mem_op - describes a SPI memory operation
72 * @cmd.buswidth: number of IO lines used to transmit the command
73 * @cmd.opcode: operation opcode
74 * @cmd.dtr: whether the command opcode should be sent in DTR mode or not
75 * @addr.nbytes: number of address bytes to send. Can be zero if the operation
76 * does not need to send an address
77 * @addr.buswidth: number of IO lines used to transmit the address cycles
78 * @addr.val: address value. This value is always sent MSB first on the bus.
79 * Note that only @addr.nbytes are taken into account in this
80 * address value, so users should make sure the value fits in the
81 * assigned number of bytes.
82 * @addr.dtr: whether the address should be sent in DTR mode or not
83 * @dummy.nbytes: number of dummy bytes to send after an opcode or address. Can
84 * be zero if the operation does not require dummy bytes
85 * @dummy.buswidth: number of IO lanes used to transmit the dummy bytes
86 * @dummy.dtr: whether the dummy bytes should be sent in DTR mode or not
87 * @data.buswidth: number of IO lanes used to send/receive the data
88 * @data.dtr: whether the data should be sent in DTR mode or not
89 * @data.dir: direction of the transfer
90 * @data.buf.in: input buffer
91 * @data.buf.out: output buffer
116 enum spi_mem_data_dir dir;
118 /* buf.{in,out} must be DMA-able. */
126 #define SPI_MEM_OP(__cmd, __addr, __dummy, __data) \
136 * struct spi_mem - describes a SPI memory device
137 * @spi: the underlying SPI device
138 * @drvpriv: spi_mem_driver private data
140 * Extra information that describe the SPI memory device and may be needed by
141 * the controller to properly handle this device should be placed here.
143 * One example would be the device size since some controller expose their SPI
144 * mem devices through a io-mapped region.
152 * struct spi_mem_set_drvdata() - attach driver private data to a SPI mem
154 * @mem: memory device
155 * @data: data to attach to the memory device
157 static inline void spi_mem_set_drvdata(struct spi_mem *mem, void *data)
163 * struct spi_mem_get_drvdata() - get driver private data attached to a SPI mem
165 * @mem: memory device
167 * Return: the data attached to the mem device.
169 static inline void *spi_mem_get_drvdata(struct spi_mem *mem)
173 #endif /* __UBOOT__ */
176 * struct spi_controller_mem_ops - SPI memory operations
177 * @adjust_op_size: shrink the data xfer of an operation to match controller's
178 * limitations (can be alignment of max RX/TX size
180 * @supports_op: check if an operation is supported by the controller
181 * @exec_op: execute a SPI memory operation
183 * This interface should be implemented by SPI controllers providing an
184 * high-level interface to execute SPI memory operation, which is usually the
185 * case for QSPI controllers.
187 struct spi_controller_mem_ops {
188 int (*adjust_op_size)(struct spi_slave *slave, struct spi_mem_op *op);
189 bool (*supports_op)(struct spi_slave *slave,
190 const struct spi_mem_op *op);
191 int (*exec_op)(struct spi_slave *slave,
192 const struct spi_mem_op *op);
197 * struct spi_mem_driver - SPI memory driver
198 * @spidrv: inherit from a SPI driver
199 * @probe: probe a SPI memory. Usually where detection/initialization takes
201 * @remove: remove a SPI memory
202 * @shutdown: take appropriate action when the system is shutdown
204 * This is just a thin wrapper around a spi_driver. The core takes care of
205 * allocating the spi_mem object and forwarding the probe/remove/shutdown
206 * request to the spi_mem_driver. The reason we use this wrapper is because
207 * we might have to stuff more information into the spi_mem struct to let
208 * SPI controllers know more about the SPI memory they interact with, and
209 * having this intermediate layer allows us to do that without adding more
210 * useless fields to the spi_device object.
212 struct spi_mem_driver {
213 struct spi_driver spidrv;
214 int (*probe)(struct spi_mem *mem);
215 int (*remove)(struct spi_mem *mem);
216 void (*shutdown)(struct spi_mem *mem);
219 #if IS_ENABLED(CONFIG_SPI_MEM)
220 int spi_controller_dma_map_mem_op_data(struct spi_controller *ctlr,
221 const struct spi_mem_op *op,
222 struct sg_table *sg);
224 void spi_controller_dma_unmap_mem_op_data(struct spi_controller *ctlr,
225 const struct spi_mem_op *op,
226 struct sg_table *sg);
229 spi_controller_dma_map_mem_op_data(struct spi_controller *ctlr,
230 const struct spi_mem_op *op,
237 spi_controller_dma_unmap_mem_op_data(struct spi_controller *ctlr,
238 const struct spi_mem_op *op,
242 #endif /* CONFIG_SPI_MEM */
243 #endif /* __UBOOT__ */
245 int spi_mem_adjust_op_size(struct spi_slave *slave, struct spi_mem_op *op);
247 bool spi_mem_supports_op(struct spi_slave *slave, const struct spi_mem_op *op);
249 int spi_mem_exec_op(struct spi_slave *slave, const struct spi_mem_op *op);
251 bool spi_mem_default_supports_op(struct spi_slave *mem,
252 const struct spi_mem_op *op);
255 int spi_mem_driver_register_with_owner(struct spi_mem_driver *drv,
256 struct module *owner);
258 void spi_mem_driver_unregister(struct spi_mem_driver *drv);
260 #define spi_mem_driver_register(__drv) \
261 spi_mem_driver_register_with_owner(__drv, THIS_MODULE)
263 #define module_spi_mem_driver(__drv) \
264 module_driver(__drv, spi_mem_driver_register, \
265 spi_mem_driver_unregister)
268 #endif /* __LINUX_SPI_MEM_H */