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