Mon, 24 Jun 2024 17:05:20 +0200
Start migration to IDF 5.1
0 | 1 | // Copyright 2010-2016 Espressif Systems (Shanghai) PTE LTD |
2 | // | |
3 | // Licensed under the Apache License, Version 2.0 (the "License"); | |
4 | // you may not use this file except in compliance with the License. | |
5 | // You may obtain a copy of the License at | |
6 | ||
7 | // http://www.apache.org/licenses/LICENSE-2.0 | |
8 | // | |
9 | // Unless required by applicable law or agreed to in writing, software | |
10 | // distributed under the License is distributed on an "AS IS" BASIS, | |
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
12 | // See the License for the specific language governing permissions and | |
13 | // limitations under the License. | |
14 | ||
15 | ||
16 | #ifndef _DRIVER_SPI_MASTER_LOBO_H_ | |
17 | #define _DRIVER_SPI_MASTER_LOBO_H_ | |
18 | ||
129 | 19 | #include <stdbool.h> |
20 | #include <stdint.h> | |
21 | ||
0 | 22 | #include "esp_err.h" |
23 | #include "freertos/FreeRTOS.h" | |
24 | #include "freertos/semphr.h" | |
25 | #include "soc/spi_struct.h" | |
26 | ||
27 | #include "esp_intr_alloc.h" | |
34
5c92103c5e72
Version 0.2.10. Fixed spelling error in websocket component. Updated esp-idf to v4.0-dev-459-gba1ff1692 and adjusted several sources for changed headers. Finalized keeping the AP running at all times. Increased websocket server stack depth from 6000 to 7000.
Michiel Broek <mbroek@mbse.eu>
parents:
0
diff
changeset
|
28 | #include "esp32/rom/lldesc.h" |
0 | 29 | |
30 | ||
31 | #ifdef __cplusplus | |
32 | extern "C" | |
33 | { | |
34 | #endif | |
35 | ||
36 | ||
37 | //Maximum amount of bytes that can be put in one DMA descriptor | |
38 | #define SPI_MAX_DMA_LEN (4096-4) | |
39 | ||
40 | /** | |
41 | * @brief Enum with the three SPI peripherals that are software-accessible in it | |
42 | */ | |
43 | typedef enum { | |
44 | TFT_SPI_HOST=0, ///< SPI1, SPI; Cannot be used in this driver! | |
45 | TFT_HSPI_HOST=1, ///< SPI2, HSPI | |
46 | TFT_VSPI_HOST=2 ///< SPI3, VSPI | |
47 | } spi_lobo_host_device_t; | |
48 | ||
49 | ||
50 | /** | |
51 | * @brief This is a configuration structure for a SPI bus. | |
52 | * | |
53 | * You can use this structure to specify the GPIO pins of the bus. Normally, the driver will use the | |
54 | * GPIO matrix to route the signals. An exception is made when all signals either can be routed through | |
55 | * the IO_MUX or are -1. In that case, the IO_MUX is used, allowing for >40MHz speeds. | |
56 | */ | |
57 | typedef struct { | |
58 | int mosi_io_num; ///< GPIO pin for Master Out Slave In (=spi_d) signal, or -1 if not used. | |
59 | int miso_io_num; ///< GPIO pin for Master In Slave Out (=spi_q) signal, or -1 if not used. | |
60 | int sclk_io_num; ///< GPIO pin for Spi CLocK signal, or -1 if not used. | |
61 | int quadwp_io_num; ///< GPIO pin for WP (Write Protect) signal which is used as D2 in 4-bit communication modes, or -1 if not used. | |
62 | int quadhd_io_num; ///< GPIO pin for HD (HolD) signal which is used as D3 in 4-bit communication modes, or -1 if not used. | |
63 | int max_transfer_sz; ///< Maximum transfer size, in bytes. Defaults to 4094 if 0. | |
64 | } spi_lobo_bus_config_t; | |
65 | ||
66 | ||
67 | #define LB_SPI_DEVICE_TXBIT_LSBFIRST (1<<0) ///< Transmit command/address/data LSB first instead of the default MSB first | |
68 | #define LB_SPI_DEVICE_RXBIT_LSBFIRST (1<<1) ///< Receive data LSB first instead of the default MSB first | |
69 | #define LB_SPI_DEVICE_BIT_LSBFIRST (SPI_TXBIT_LSBFIRST|SPI_RXBIT_LSBFIRST); ///< Transmit and receive LSB first | |
70 | #define LB_SPI_DEVICE_3WIRE (1<<2) ///< Use spiq for both sending and receiving data | |
71 | #define LB_SPI_DEVICE_POSITIVE_CS (1<<3) ///< Make CS positive during a transaction instead of negative | |
72 | #define LB_SPI_DEVICE_HALFDUPLEX (1<<4) ///< Transmit data before receiving it, instead of simultaneously | |
73 | #define LB_SPI_DEVICE_CLK_AS_CS (1<<5) ///< Output clock on CS line if CS is active | |
74 | ||
75 | #define SPI_ERR_OTHER_CONFIG 7001 | |
76 | ||
77 | typedef struct spi_lobo_transaction_t spi_lobo_transaction_t; | |
78 | typedef void(*spi_lobo_transaction_cb_t)(spi_lobo_transaction_t *trans); | |
79 | ||
80 | /** | |
81 | * @brief This is a configuration for a SPI slave device that is connected to one of the SPI buses. | |
82 | */ | |
83 | typedef struct { | |
84 | uint8_t command_bits; ///< Amount of bits in command phase (0-16) | |
85 | uint8_t address_bits; ///< Amount of bits in address phase (0-64) | |
86 | uint8_t dummy_bits; ///< Amount of dummy bits to insert between address and data phase | |
87 | uint8_t mode; ///< SPI mode (0-3) | |
88 | uint8_t duty_cycle_pos; ///< Duty cycle of positive clock, in 1/256th increments (128 = 50%/50% duty). Setting this to 0 (=not setting it) is equivalent to setting this to 128. | |
89 | uint8_t cs_ena_pretrans; ///< Amount of SPI bit-cycles the cs should be activated before the transmission (0-16). This only works on half-duplex transactions. | |
90 | uint8_t cs_ena_posttrans; ///< Amount of SPI bit-cycles the cs should stay active after the transmission (0-16) | |
91 | int clock_speed_hz; ///< Clock speed, in Hz | |
92 | int spics_io_num; ///< CS GPIO pin for this device, handled by hardware; set to -1 if not used | |
93 | int spics_ext_io_num; ///< CS GPIO pin for this device, handled by software (spi_lobo_device_select/spi_lobo_device_deselect); only used if spics_io_num=-1 | |
94 | uint32_t flags; ///< Bitwise OR of LB_SPI_DEVICE_* flags | |
95 | spi_lobo_transaction_cb_t pre_cb; ///< Callback to be called before a transmission is started. This callback from 'spi_lobo_transfer_data' function. | |
96 | spi_lobo_transaction_cb_t post_cb; ///< Callback to be called after a transmission has completed. This callback from 'spi_lobo_transfer_data' function. | |
97 | uint8_t selected; ///< **INTERNAL** 1 if the device's CS pin is active | |
98 | } spi_lobo_device_interface_config_t; | |
99 | ||
100 | ||
101 | #define LB_SPI_TRANS_MODE_DIO (1<<0) ///< Transmit/receive data in 2-bit mode | |
102 | #define LB_SPI_TRANS_MODE_QIO (1<<1) ///< Transmit/receive data in 4-bit mode | |
103 | #define LB_SPI_TRANS_MODE_DIOQIO_ADDR (1<<2) ///< Also transmit address in mode selected by SPI_MODE_DIO/SPI_MODE_QIO | |
104 | #define LB_SPI_TRANS_USE_RXDATA (1<<3) ///< Receive into rx_data member of spi_lobo_transaction_t instead into memory at rx_buffer. | |
105 | #define LB_SPI_TRANS_USE_TXDATA (1<<4) ///< Transmit tx_data member of spi_lobo_transaction_t instead of data at tx_buffer. Do not set tx_buffer when using this. | |
106 | ||
107 | /** | |
108 | * This structure describes one SPI transmission | |
109 | */ | |
110 | struct spi_lobo_transaction_t { | |
111 | uint32_t flags; ///< Bitwise OR of LB_SPI_TRANS_* flags | |
112 | uint16_t command; ///< Command data. Specific length was given when device was added to the bus. | |
113 | uint64_t address; ///< Address. Specific length was given when device was added to the bus. | |
114 | size_t length; ///< Total data length to be transmitted to the device, in bits; if 0, no data is transmitted | |
115 | size_t rxlength; ///< Total data length to be received from the device, in bits; if 0, no data is received | |
116 | void *user; ///< User-defined variable. Can be used to store eg transaction ID or data to be used by pre_cb and/or post_cb callbacks. | |
117 | union { | |
118 | const void *tx_buffer; ///< Pointer to transmit buffer, or NULL for no MOSI phase | |
119 | uint8_t tx_data[4]; ///< If SPI_USE_TXDATA is set, data set here is sent directly from this variable. | |
120 | }; | |
121 | union { | |
122 | void *rx_buffer; ///< Pointer to receive buffer, or NULL for no MISO phase | |
123 | uint8_t rx_data[4]; ///< If SPI_USE_RXDATA is set, data is received directly to this variable | |
124 | }; | |
125 | }; | |
126 | ||
127 | #define NO_CS 3 // Number of CS pins per SPI host | |
128 | #define NO_DEV 6 // Number of spi devices per SPI host; more than 3 devices can be attached to the same bus if using software CS's | |
129 | #define SPI_SEMAPHORE_WAIT 2000 // Time in ms to wait for SPI mutex | |
130 | ||
131 | typedef struct spi_lobo_device_t spi_lobo_device_t; | |
132 | ||
133 | typedef struct { | |
134 | spi_lobo_device_t *device[NO_DEV]; | |
135 | intr_handle_t intr; | |
136 | spi_dev_t *hw; | |
137 | //spi_lobo_transaction_t *cur_trans; | |
138 | int cur_device; | |
139 | lldesc_t *dmadesc_tx; | |
140 | lldesc_t *dmadesc_rx; | |
141 | bool no_gpio_matrix; | |
142 | int dma_chan; | |
143 | int max_transfer_sz; | |
144 | QueueHandle_t spi_lobo_bus_mutex; | |
145 | spi_lobo_bus_config_t cur_bus_config; | |
146 | } spi_lobo_host_t; | |
147 | ||
148 | struct spi_lobo_device_t { | |
149 | spi_lobo_device_interface_config_t cfg; | |
150 | spi_lobo_host_t *host; | |
151 | spi_lobo_bus_config_t bus_config; | |
152 | spi_lobo_host_device_t host_dev; | |
153 | }; | |
154 | ||
155 | typedef spi_lobo_device_t* spi_lobo_device_handle_t; ///< Handle for a device on a SPI bus | |
156 | typedef spi_lobo_host_t* spi_lobo_host_handle_t; | |
157 | typedef spi_lobo_device_interface_config_t* spi_lobo_device_interface_config_handle_t; | |
158 | ||
159 | ||
160 | /** | |
161 | * @brief Add a device. This allocates a CS line for the device, allocates memory for the device structure and hooks | |
162 | * up the CS pin to whatever is specified. | |
163 | * | |
164 | * This initializes the internal structures for a device, plus allocates a CS pin on the indicated SPI master | |
165 | * peripheral and routes it to the indicated GPIO. All SPI master devices have three hw CS pins and can thus control | |
166 | * up to three devices. Software handled CS pin can also be used for additional devices on the same SPI bus. | |
167 | * | |
168 | * ### If selected SPI host device bus is not yet initialized, it is initialized first with 'bus_config' function ### | |
169 | * | |
170 | * @note While in general, speeds up to 80MHz on the dedicated SPI pins and 40MHz on GPIO-matrix-routed pins are | |
171 | * supported, full-duplex transfers routed over the GPIO matrix only support speeds up to 26MHz. | |
172 | * | |
173 | * @param host SPI peripheral to allocate device on (HSPI or VSPI) | |
174 | * @param dev_config SPI interface protocol config for the device | |
175 | * @param bus_config Pointer to a spi_lobo_bus_config_t struct specifying how the host device bus should be initialized | |
176 | * @param handle Pointer to variable to hold the device handle | |
177 | * @return | |
178 | * - ESP_ERR_INVALID_ARG if parameter is invalid | |
179 | * - ESP_ERR_NOT_FOUND if host doesn't have any free CS slots | |
180 | * - ESP_ERR_NO_MEM if out of memory | |
181 | * - ESP_OK on success | |
182 | */ | |
183 | esp_err_t spi_lobo_bus_add_device(spi_lobo_host_device_t host, spi_lobo_bus_config_t *bus_config, spi_lobo_device_interface_config_t *dev_config, spi_lobo_device_handle_t *handle); | |
184 | ||
185 | /** | |
186 | * @brief Remove a device from the SPI bus. If after removal no other device is attached to the spi bus device, it is freed. | |
187 | * | |
188 | * @param handle Device handle to free | |
189 | * @return | |
190 | * - ESP_ERR_INVALID_ARG if parameter is invalid | |
191 | * - ESP_ERR_INVALID_STATE if device already is freed | |
192 | * - ESP_OK on success | |
193 | */ | |
194 | esp_err_t spi_lobo_bus_remove_device(spi_lobo_device_handle_t handle); | |
195 | ||
196 | ||
197 | /** | |
198 | * @brief Return the actuall SPI bus speed for the spi device in Hz | |
199 | * | |
200 | * Some frequencies cannot be set, for example 30000000 will actually set SPI clock to 26666666 Hz | |
201 | * | |
202 | * @param handle Device handle obtained using spi_lobo_bus_add_device | |
203 | * | |
204 | * @return | |
205 | * - actuall SPI clock | |
206 | */ | |
207 | uint32_t spi_lobo_get_speed(spi_lobo_device_handle_t handle); | |
208 | ||
209 | /** | |
210 | * @brief Set the new clock speed for the device, return the actuall SPI bus speed set, in Hz | |
211 | * This function can be used after the device is initialized | |
212 | * | |
213 | * Some frequencies cannot be set, for example 30000000 will actually set SPI clock to 26666666 Hz | |
214 | * | |
215 | * @param handle Device handle obtained using spi_lobo_bus_add_device | |
216 | * @param speed New device spi clock to be set in Hz | |
217 | * | |
218 | * @return | |
219 | * - actuall SPI clock | |
220 | * - 0 if speed cannot be set | |
221 | */ | |
222 | uint32_t spi_lobo_set_speed(spi_lobo_device_handle_t handle, uint32_t speed); | |
223 | ||
224 | /** | |
225 | * @brief Select spi device for transmission | |
226 | * | |
227 | * It configures spi bus with selected spi device parameters if previously selected device was different than the current | |
228 | * If device's spics_io_num=-1 and spics_ext_io_num > 0 'spics_ext_io_num' pin is set to active state (low) | |
229 | * | |
230 | * spi bus device's semaphore is taken before selecting the device | |
231 | * | |
232 | * @param handle Device handle obtained using spi_lobo_bus_add_device | |
233 | * @param force configure spi bus even if the previous device was the same | |
234 | * | |
235 | * @return | |
236 | * - ESP_ERR_INVALID_ARG if parameter is invalid | |
237 | * - ESP_OK on success | |
238 | */ | |
239 | esp_err_t spi_lobo_device_select(spi_lobo_device_handle_t handle, int force); | |
240 | ||
241 | /** | |
242 | * @brief De-select spi device | |
243 | * | |
244 | * If device's spics_io_num=-1 and spics_ext_io_num > 0 'spics_ext_io_num' pin is set to inactive state (high) | |
245 | * | |
246 | * spi bus device's semaphore is given after selecting the device | |
247 | * | |
248 | * @param handle Device handle obtained using spi_lobo_bus_add_device | |
249 | * | |
250 | * @return | |
251 | * - ESP_ERR_INVALID_ARG if parameter is invalid | |
252 | * - ESP_OK on success | |
253 | */ | |
254 | esp_err_t spi_lobo_device_deselect(spi_lobo_device_handle_t handle); | |
255 | ||
256 | ||
257 | /** | |
258 | * @brief Check if spi bus uses native spi pins | |
259 | * | |
260 | * @param handle Device handle obtained using spi_lobo_bus_add_device | |
261 | * | |
262 | * @return | |
263 | * - true if native spi pins are used | |
264 | * - false if spi pins are routed through gpio matrix | |
265 | */ | |
266 | bool spi_lobo_uses_native_pins(spi_lobo_device_handle_t handle); | |
267 | ||
268 | /** | |
269 | * @brief Get spi bus native spi pins | |
270 | * | |
271 | * @param handle Device handle obtained using spi_lobo_bus_add_device | |
272 | * | |
273 | * @return | |
274 | * places spi bus native pins in provided pointers | |
275 | */ | |
276 | void spi_lobo_get_native_pins(int host, int *sdi, int *sdo, int *sck); | |
277 | ||
278 | /** | |
279 | * @brief Transimit and receive data to/from spi device based on transaction data | |
280 | * | |
281 | * TRANSMIT 8-bit data to spi device from 'trans->tx_buffer' or 'trans->tx_data' (trans->lenght/8 bytes) | |
282 | * and RECEIVE data to 'trans->rx_buffer' or 'trans->rx_data' (trans->rx_length/8 bytes) | |
283 | * Lengths must be 8-bit multiples! | |
284 | * If trans->rx_buffer is NULL or trans->rx_length is 0, only transmits data | |
285 | * If trans->tx_buffer is NULL or trans->length is 0, only receives data | |
286 | * If the device is in duplex mode (LB_SPI_DEVICE_HALFDUPLEX flag NOT set), data are transmitted and received simultaneously. | |
287 | * If the device is in half duplex mode (LB_SPI_DEVICE_HALFDUPLEX flag IS set), data are received after transmission | |
288 | * 'address', 'command' and 'dummy bits' are transmitted before data phase IF set in device's configuration | |
289 | * and IF 'trans->length' and 'trans->rx_length' are NOT both 0 | |
290 | * If device was not previously selected, it will be selected before transmission and deselected after transmission. | |
291 | * | |
292 | * @param handle Device handle obtained using spi_lobo_bus_add_device | |
293 | * | |
294 | * @param trans Pointer to variable containing the description of the transaction that is executed | |
295 | * | |
296 | * @return | |
297 | * - ESP_ERR_INVALID_ARG if parameter is invalid | |
298 | * - ESP error code if device cannot be selected | |
299 | * - ESP_OK on success | |
300 | * | |
301 | */ | |
302 | esp_err_t spi_lobo_transfer_data(spi_lobo_device_handle_t handle, spi_lobo_transaction_t *trans); | |
303 | ||
304 | ||
305 | /* | |
306 | * SPI transactions uses the semaphore (taken in select function) to protect the transfer | |
307 | */ | |
308 | esp_err_t spi_lobo_device_TakeSemaphore(spi_lobo_device_handle_t handle); | |
309 | void spi_lobo_device_GiveSemaphore(spi_lobo_device_handle_t handle); | |
310 | ||
311 | ||
312 | /** | |
313 | * @brief Setup a DMA link chain | |
314 | * | |
315 | * This routine will set up a chain of linked DMA descriptors in the array pointed to by | |
316 | * ``dmadesc``. Enough DMA descriptors will be used to fit the buffer of ``len`` bytes in, and the | |
317 | * descriptors will point to the corresponding positions in ``buffer`` and linked together. The | |
318 | * end result is that feeding ``dmadesc[0]`` into DMA hardware results in the entirety ``len`` bytes | |
319 | * of ``data`` being read or written. | |
320 | * | |
321 | * @param dmadesc Pointer to array of DMA descriptors big enough to be able to convey ``len`` bytes | |
322 | * @param len Length of buffer | |
323 | * @param data Data buffer to use for DMA transfer | |
324 | * @param isrx True if data is to be written into ``data``, false if it's to be read from ``data``. | |
325 | */ | |
326 | void spi_lobo_setup_dma_desc_links(lldesc_t *dmadesc, int len, const uint8_t *data, bool isrx); | |
327 | ||
328 | /** | |
329 | * @brief Check if a DMA reset is requested but has not completed yet | |
330 | * | |
331 | * @return True when a DMA reset is requested but hasn't completed yet. False otherwise. | |
332 | */ | |
333 | bool spi_lobo_dmaworkaround_reset_in_progress(); | |
334 | ||
335 | ||
336 | /** | |
337 | * @brief Mark a DMA channel as idle. | |
338 | * | |
339 | * A call to this function tells the workaround logic that this channel will | |
340 | * not be affected by a global SPI DMA reset. | |
341 | */ | |
342 | void spi_lobo_dmaworkaround_idle(int dmachan); | |
343 | ||
344 | /** | |
345 | * @brief Mark a DMA channel as active. | |
346 | * | |
347 | * A call to this function tells the workaround logic that this channel will | |
348 | * be affected by a global SPI DMA reset, and a reset like that should not be attempted. | |
349 | */ | |
350 | void spi_lobo_dmaworkaround_transfer_active(int dmachan); | |
351 | ||
352 | ||
353 | #ifdef __cplusplus | |
354 | } | |
355 | #endif | |
356 | ||
357 | #endif |