pmw33xx_common.c 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216
  1. // Copyright 2022 Daniel Kao (dkao)
  2. // Copyright 2022 Stefan Kerkmann (KarlK90)
  3. // Copyright 2022 Ulrich Spörlein (@uqs)
  4. // Copyright 2021 Alabastard (@Alabastard-64)
  5. // Copyright 2020 Christopher Courtney, aka Drashna Jael're (@drashna) <drashna@live.com>
  6. // Copyright 2019 Sunjun Kim
  7. // Copyright 2020 Ploopy Corporation
  8. // SPDX-License-Identifier: GPL-2.0-or-later
  9. #include "pointing_device_internal.h"
  10. #include "pmw33xx_common.h"
  11. #include "string.h"
  12. #include "wait.h"
  13. #include "spi_master.h"
  14. #include "progmem.h"
  15. extern const uint8_t pmw33xx_firmware_data[PMW33XX_FIRMWARE_LENGTH] PROGMEM;
  16. extern const uint8_t pmw33xx_firmware_signature[3] PROGMEM;
  17. static const pin_t cs_pins[] = PMW33XX_CS_PINS;
  18. static bool in_burst[ARRAY_SIZE(cs_pins)] = {0};
  19. const size_t pmw33xx_number_of_sensors = ARRAY_SIZE(cs_pins);
  20. bool __attribute__((cold)) pmw33xx_upload_firmware(uint8_t sensor);
  21. bool __attribute__((cold)) pmw33xx_check_signature(uint8_t sensor);
  22. void pmw33xx_set_cpi_all_sensors(uint16_t cpi) {
  23. for (uint8_t sensor = 0; sensor < pmw33xx_number_of_sensors; sensor++) {
  24. pmw33xx_set_cpi(sensor, cpi);
  25. }
  26. }
  27. bool pmw33xx_spi_start(uint8_t sensor) {
  28. if (!spi_start(cs_pins[sensor], false, 3, PMW33XX_SPI_DIVISOR)) {
  29. spi_stop();
  30. return false;
  31. }
  32. // tNCS-SCLK, 10ns
  33. wait_us(1);
  34. return true;
  35. }
  36. bool pmw33xx_write(uint8_t sensor, uint8_t reg_addr, uint8_t data) {
  37. if (!pmw33xx_spi_start(sensor)) {
  38. return false;
  39. }
  40. if (reg_addr != REG_Motion_Burst) {
  41. in_burst[sensor] = false;
  42. }
  43. // send address of the register, with MSBit = 1 to indicate it's a write
  44. uint8_t command[2] = {reg_addr | 0x80, data};
  45. if (spi_transmit(command, sizeof(command)) != SPI_STATUS_SUCCESS) {
  46. return false;
  47. }
  48. // tSCLK-NCS for write operation is 35us
  49. wait_us(35);
  50. spi_stop();
  51. // tSWW/tSWR (=18us) minus tSCLK-NCS. Could be shortened, but it looks like
  52. // a safe lower bound
  53. wait_us(145);
  54. return true;
  55. }
  56. uint8_t pmw33xx_read(uint8_t sensor, uint8_t reg_addr) {
  57. if (!pmw33xx_spi_start(sensor)) {
  58. return 0;
  59. }
  60. // send adress of the register, with MSBit = 0 to indicate it's a read
  61. spi_write(reg_addr & 0x7f);
  62. // tSRAD (=160us)
  63. wait_us(160);
  64. uint8_t data = spi_read();
  65. // tSCLK-NCS, 120ns
  66. wait_us(1);
  67. spi_stop();
  68. // tSRW/tSRR (=20us) mins tSCLK-NCS
  69. wait_us(19);
  70. return data;
  71. }
  72. bool pmw33xx_check_signature(uint8_t sensor) {
  73. uint8_t signature_dump[3] = {
  74. pmw33xx_read(sensor, REG_Product_ID),
  75. pmw33xx_read(sensor, REG_Inverse_Product_ID),
  76. pmw33xx_read(sensor, REG_SROM_ID),
  77. };
  78. return memcmp(pmw33xx_firmware_signature, signature_dump, sizeof(signature_dump)) == 0;
  79. }
  80. bool pmw33xx_upload_firmware(uint8_t sensor) {
  81. // Datasheet claims we need to disable REST mode first, but during startup
  82. // it's already disabled and we're not turning it on ...
  83. // pmw33xx_write(REG_Config2, 0x00); // disable REST mode
  84. if (!pmw33xx_write(sensor, REG_SROM_Enable, 0x1d)) {
  85. return false;
  86. }
  87. wait_ms(10);
  88. pmw33xx_write(sensor, REG_SROM_Enable, 0x18);
  89. if (!pmw33xx_spi_start(sensor)) {
  90. return false;
  91. }
  92. spi_write(REG_SROM_Load_Burst | 0x80);
  93. wait_us(15);
  94. for (size_t i = 0; i < PMW33XX_FIRMWARE_LENGTH; i++) {
  95. spi_write(pgm_read_byte(pmw33xx_firmware_data + i));
  96. wait_us(15);
  97. }
  98. wait_us(200);
  99. pmw33xx_read(sensor, REG_SROM_ID);
  100. pmw33xx_write(sensor, REG_Config2, 0x00);
  101. return true;
  102. }
  103. bool pmw33xx_init(uint8_t sensor) {
  104. if (sensor >= pmw33xx_number_of_sensors) {
  105. return false;
  106. }
  107. spi_init();
  108. // power up, need to first drive NCS high then low. the datasheet does not
  109. // say for how long, 40us works well in practice.
  110. if (!pmw33xx_spi_start(sensor)) {
  111. return false;
  112. }
  113. wait_us(40);
  114. spi_stop();
  115. wait_us(40);
  116. if (!pmw33xx_write(sensor, REG_Power_Up_Reset, 0x5a)) {
  117. return false;
  118. }
  119. wait_ms(50);
  120. // read registers and discard
  121. pmw33xx_read(sensor, REG_Motion);
  122. pmw33xx_read(sensor, REG_Delta_X_L);
  123. pmw33xx_read(sensor, REG_Delta_X_H);
  124. pmw33xx_read(sensor, REG_Delta_Y_L);
  125. pmw33xx_read(sensor, REG_Delta_Y_H);
  126. if (!pmw33xx_upload_firmware(sensor)) {
  127. pd_dprintf("PMW33XX (%d): firmware upload failed!\n", sensor);
  128. return false;
  129. }
  130. spi_stop();
  131. wait_ms(10);
  132. pmw33xx_set_cpi(sensor, PMW33XX_CPI);
  133. wait_ms(1);
  134. pmw33xx_write(sensor, REG_Config2, 0x00);
  135. pmw33xx_write(sensor, REG_Angle_Tune, CONSTRAIN(ROTATIONAL_TRANSFORM_ANGLE, -127, 127));
  136. pmw33xx_write(sensor, REG_Lift_Config, PMW33XX_LIFTOFF_DISTANCE);
  137. if (!pmw33xx_check_signature(sensor)) {
  138. pd_dprintf("PMW33XX (%d): firmware signature verification failed!\n", sensor);
  139. return false;
  140. }
  141. return true;
  142. }
  143. pmw33xx_report_t pmw33xx_read_burst(uint8_t sensor) {
  144. pmw33xx_report_t report = {0};
  145. if (sensor >= pmw33xx_number_of_sensors) {
  146. return report;
  147. }
  148. if (!in_burst[sensor]) {
  149. pd_dprintf("PMW33XX (%d): burst\n", sensor);
  150. if (!pmw33xx_write(sensor, REG_Motion_Burst, 0x00)) {
  151. return report;
  152. }
  153. in_burst[sensor] = true;
  154. }
  155. if (!pmw33xx_spi_start(sensor)) {
  156. return report;
  157. }
  158. spi_write(REG_Motion_Burst);
  159. wait_us(35); // waits for tSRAD_MOTBR
  160. spi_receive((uint8_t*)&report, sizeof(report));
  161. // panic recovery, sometimes burst mode works weird.
  162. if (report.motion.w & 0b111) {
  163. in_burst[sensor] = false;
  164. }
  165. spi_stop();
  166. pd_dprintf("PMW33XX (%d): motion: 0x%x dx: %i dy: %i\n", sensor, report.motion.w, report.delta_x, report.delta_y);
  167. report.delta_x *= -1;
  168. report.delta_y *= -1;
  169. return report;
  170. }