default_if_spi.c 3.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119
  1. /**
  2. * Copyright (c) 2017-2018 Tara Keeling
  3. *
  4. * This software is released under the MIT License.
  5. * https://opensource.org/licenses/MIT
  6. */
  7. #include <stdio.h>
  8. #include <stdint.h>
  9. #include <stdbool.h>
  10. #include <string.h>
  11. #include <driver/spi_master.h>
  12. #include <driver/gpio.h>
  13. #include <freertos/task.h>
  14. #include "gds.h"
  15. #include "gds_err.h"
  16. #include "gds_private.h"
  17. #include "gds_default_if.h"
  18. static const int GDS_SPI_Command_Mode = 0;
  19. static const int GDS_SPI_Data_Mode = 1;
  20. static spi_host_device_t SPIHost;
  21. static int DCPin;
  22. static bool SPIDefaultWriteBytes( spi_device_handle_t SPIHandle, int WriteMode, const uint8_t* Data, size_t DataLength );
  23. static bool SPIDefaultWriteCommand( struct GDS_Device* Device, uint8_t Command );
  24. static bool SPIDefaultWriteData( struct GDS_Device* Device, const uint8_t* Data, size_t DataLength );
  25. bool GDS_SPIInit( int SPI, int DC ) {
  26. SPIHost = SPI;
  27. DCPin = DC;
  28. return true;
  29. }
  30. bool GDS_SPIAttachDevice( struct GDS_Device* Device, int Width, int Height, int CSPin, int RSTPin, int BackLightPin, int Speed, int Mode ) {
  31. spi_device_interface_config_t SPIDeviceConfig = { };
  32. spi_device_handle_t SPIDevice;
  33. NullCheck( Device, return false );
  34. if (CSPin >= 0) {
  35. ESP_ERROR_CHECK_NONFATAL( gpio_set_direction( CSPin, GPIO_MODE_OUTPUT ), return false );
  36. ESP_ERROR_CHECK_NONFATAL( gpio_set_level( CSPin, 0 ), return false );
  37. }
  38. SPIDeviceConfig.clock_speed_hz = Speed > 0 ? Speed : SPI_MASTER_FREQ_8M;
  39. SPIDeviceConfig.spics_io_num = CSPin;
  40. SPIDeviceConfig.queue_size = 1;
  41. SPIDeviceConfig.mode = Mode;
  42. SPIDeviceConfig.flags = SPI_DEVICE_NO_DUMMY;
  43. if (Device->SPIParams) Device->SPIParams(SPIDeviceConfig.clock_speed_hz, &SPIDeviceConfig.mode,
  44. &SPIDeviceConfig.cs_ena_pretrans, &SPIDeviceConfig.cs_ena_posttrans);
  45. ESP_ERROR_CHECK_NONFATAL( spi_bus_add_device( SPIHost, &SPIDeviceConfig, &SPIDevice ), return false );
  46. Device->WriteCommand = SPIDefaultWriteCommand;
  47. Device->WriteData = SPIDefaultWriteData;
  48. Device->SPIHandle = SPIDevice;
  49. Device->RSTPin = RSTPin;
  50. Device->CSPin = CSPin;
  51. Device->Backlight.Pin = BackLightPin;
  52. Device->IF = GDS_IF_SPI;
  53. Device->Width = Device->TextWidth = Width;
  54. Device->Height = Height;
  55. if ( RSTPin >= 0 ) {
  56. ESP_ERROR_CHECK_NONFATAL( gpio_set_direction( RSTPin, GPIO_MODE_OUTPUT ), return false );
  57. ESP_ERROR_CHECK_NONFATAL( gpio_set_level( RSTPin, 0 ), return false );
  58. GDS_Reset( Device );
  59. }
  60. return GDS_Init( Device );
  61. }
  62. static bool SPIDefaultWriteBytes( spi_device_handle_t SPIHandle, int WriteMode, const uint8_t* Data, size_t DataLength ) {
  63. spi_transaction_t SPITransaction = { };
  64. NullCheck( SPIHandle, return false );
  65. NullCheck( Data, return false );
  66. if ( DataLength > 0 ) {
  67. gpio_set_level( DCPin, WriteMode );
  68. SPITransaction.length = DataLength * 8;
  69. if (DataLength <= 4) {
  70. SPITransaction.flags = SPI_TRANS_USE_TXDATA;
  71. SPITransaction.tx_data[0] = *Data++; SPITransaction.tx_data[1] = *Data++;
  72. SPITransaction.tx_data[2] = *Data++; SPITransaction.tx_data[3] = *Data;
  73. } else {
  74. SPITransaction.tx_buffer = Data;
  75. }
  76. // only do polling as we don't have contention on SPI (otherwise DMA for transfers > 16 bytes)
  77. ESP_ERROR_CHECK_NONFATAL( spi_device_polling_transmit(SPIHandle, &SPITransaction), return false );
  78. }
  79. return true;
  80. }
  81. static bool SPIDefaultWriteCommand( struct GDS_Device* Device, uint8_t Command ) {
  82. static uint8_t CommandByte = 0;
  83. NullCheck( Device, return false );
  84. NullCheck( Device->SPIHandle, return false );
  85. CommandByte = Command;
  86. return SPIDefaultWriteBytes( Device->SPIHandle, GDS_SPI_Command_Mode, &CommandByte, 1 );
  87. }
  88. static bool SPIDefaultWriteData( struct GDS_Device* Device, const uint8_t* Data, size_t DataLength ) {
  89. NullCheck( Device, return false );
  90. NullCheck( Device->SPIHandle, return false );
  91. return SPIDefaultWriteBytes( Device->SPIHandle, GDS_SPI_Data_Mode, Data, DataLength );
  92. }