Dev branch

.vscode/settings.json

@@ -18,7 +18,9 @@
         "xstddef": "c",
         "type_traits": "c",
         "utility": "c",
-        "ranges": "c"
+        "ranges": "c",
+        "chrono": "c",
+        "cmath": "c"
     },
     "[markdown]": {
         "editor.trimAutoWhitespace": false,

builddefs/common_features.mk

@@ -171,9 +171,13 @@ ifeq ($(strip $(POINTING_DEVICE_ENABLE)), yes)
         else ifeq ($(strip $(POINTING_DEVICE_DRIVER)), pimoroni_trackball)
             OPT_DEFS += -DSTM32_SPI -DHAL_USE_I2C=TRUE
             QUANTUM_LIB_SRC += i2c_master.c
-        else ifneq ($(filter $(strip $(POINTING_DEVICE_DRIVER)),pmw3360 pmw3389),)
+        else ifeq ($(strip $(POINTING_DEVICE_DRIVER)), pmw3360)
             OPT_DEFS += -DSTM32_SPI -DHAL_USE_SPI=TRUE
-            SRC += drivers/sensors/pmw33xx_common.c
+            SRC += drivers/sensors/pmw3360_common.c
+            QUANTUM_LIB_SRC += spi_master.c
+        else ifeq ($(strip $(POINTING_DEVICE_DRIVER)), pmw3389)
+            OPT_DEFS += -DSTM32_SPI -DHAL_USE_SPI=TRUE
+            SRC += drivers/sensors/pmw3389.c
             QUANTUM_LIB_SRC += spi_master.c
         endif
     endif

drivers/sensors/pmw3360.c

@@ -6,7 +6,7 @@
 // Copyright 2020 Ploopy Corporation
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "pmw33xx_common.h"
+#include "pmw3360_common.h"
 #include "progmem.h"
 
 uint16_t pmw33xx_get_cpi(uint8_t sensor) {

drivers/sensors/pmw33xx_common.c → drivers/sensors/pmw3360_common.c

@@ -9,7 +9,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "pointing_device_internal.h"
-#include "pmw33xx_common.h"
+#include "pmw3360_common.h"
 #include "string.h"
 #include "wait.h"
 #include "spi_master.h"

drivers/sensors/pmw3389.c

@@ -1,18 +1,249 @@
+// Copyright 2022 Pablo Martinez (@elpekenin)
+// Copyright 2022 Daniel Kao (dkao)
 // Copyright 2022 Stefan Kerkmann (KarlK90)
+// Copyright 2022 Ulrich Spörlein (@uqs)
 // Copyright 2021 Alabastard (@Alabastard-64)
 // Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <[email protected]>
 // Copyright 2019 Sunjun Kim
 // Copyright 2020 Ploopy Corporation
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "pmw33xx_common.h"
+#include "pmw3389.h"
 #include "progmem.h"
+#include "pointing_device_internal.h"
+#include "string.h"
+#include "wait.h"
+#include "spi_master.h"
+
+extern const uint8_t pmw33xx_firmware_data[PMW33XX_FIRMWARE_LENGTH] PROGMEM;
+extern const uint8_t pmw33xx_firmware_signature[3] PROGMEM;
+
+static const pin_t cs_pins_left[]  = PMW33XX_CS_PINS;
+static const pin_t cs_pins_right[] = PMW33XX_CS_PINS_RIGHT;
+
+static bool in_burst_left[ARRAY_SIZE(cs_pins_left)]   = {0};
+static bool in_burst_right[ARRAY_SIZE(cs_pins_right)] = {0};
+
+bool __attribute__((cold)) pmw33xx_upload_firmware(uint8_t sensor);
+bool __attribute__((cold)) pmw33xx_check_signature(uint8_t sensor);
+
+void pmw33xx_set_cpi_all_sensors(uint16_t cpi) {
+    for (uint8_t sensor = 0; sensor < pmw33xx_number_of_sensors; sensor++) {
+        pmw33xx_set_cpi(sensor, cpi);
+    }
+}
+
+bool pmw33xx_spi_start(uint8_t sensor) {
+    if (!spi_start(cs_pins[sensor], false, 3, PMW33XX_SPI_DIVISOR)) {
+        spi_stop();
+        return false;
+    }
+    // tNCS-SCLK, 10ns
+    wait_us(1);
+    return true;
+}
+
+bool pmw33xx_write(uint8_t sensor, uint8_t reg_addr, uint8_t data) {
+    if (!pmw33xx_spi_start(sensor)) {
+        pd_dprintf("Failed to start SPI for pmw33xx_write function - register %2x.\n", reg_addr);
+        return false;
+    }
+
+    if (reg_addr != REG_Motion_Burst) {
+        in_burst[sensor] = false;
+    }
+
+    // send address of the register, with MSBit = 1 to indicate it's a write
+    uint8_t command[2] = {reg_addr | 0x80, data};
+    if (spi_transmit(command, sizeof(command)) != SPI_STATUS_SUCCESS) {
+        return false;
+    }
+
+    // tSCLK-NCS for write operation is 35us
+    wait_us(35);
+    spi_stop();
+
+    // tSWW/tSWR (=18us) minus tSCLK-NCS. Could be shortened, but it looks like
+    // a safe lower bound
+    wait_us(145);
+    return true;
+}
+
+uint8_t pmw33xx_read(uint8_t sensor, uint8_t reg_addr) {
+    if (!pmw33xx_spi_start(sensor)) {
+        pd_dprintf("Failed to start SPI for pmw33xx_read function - register %2x.\n", reg_addr);
+        return 0;
+    }
+
+    // send adress of the register, with MSBit = 0 to indicate it's a read
+    spi_write(reg_addr & 0x7f);
+    // tSRAD (=160us)
+    wait_us(160);
+    uint8_t data = spi_read();
+    //pd_dprintf("Read from register %2x the following data: %2x\n", reg_addr, data);
+
+    // tSCLK-NCS, 120ns
+    wait_us(1);
+    spi_stop();
+
+    //  tSRW/tSRR (=20us) mins tSCLK-NCS
+    wait_us(19);
+    return data;
+}
+
+bool pmw33xx_check_signature(uint8_t sensor) {
+    uint8_t signature_dump[3] = {
+        pmw33xx_read(sensor, REG_Product_ID),
+        pmw33xx_read(sensor, REG_Inverse_Product_ID),
+        pmw33xx_read(sensor, REG_SROM_ID),
+    };
+
+    pd_dprintf("Signature: Product_ID %x, Inverse_Product_ID %x, SROM_ID %x\n", signature_dump[0], signature_dump[1], signature_dump[2]);
+
+    return memcmp(pmw33xx_firmware_signature, signature_dump, sizeof(signature_dump)) == 0;
+}
+
+bool pmw33xx_upload_firmware(uint8_t sensor) {
+    // Datasheet claims we need to disable REST mode first, but during startup
+    // it's already disabled and we're not turning it on ...
+    // pmw33xx_write(REG_Config2, 0x00);  // disable REST mode
+    pd_dprintf("In the pmw33xx_upload_firmware Function.\n");
+    pmw33xx_write(sensor, REG_Config2, 0x00); // Added here specific to the 3389 datasheet.
+    if (!pmw33xx_write(sensor, REG_SROM_Enable, 0x1d)) {
+        return false;
+    }
+    wait_ms(10);
+    pmw33xx_write(sensor, REG_SROM_Enable, 0x18);
+
+    if (!pmw33xx_spi_start(sensor)) {
+        return false;
+    }
+
+    spi_write(REG_SROM_Load_Burst | 0x80);
+    wait_us(15);
+
+    for (size_t i = 0; i < PMW33XX_FIRMWARE_LENGTH; i++) {
+        spi_write(pgm_read_byte(pmw33xx_firmware_data + i));
+        wait_us(15);
+    }
+    wait_us(200);
+
+    //pd_dprintf("Sensor SROM_ID: %x\n", pmw33xx_read(sensor, REG_SROM_ID));
+    //pmw33xx_write(sensor, REG_Config2, 0x00); // Appears to be out of order for the 3389 datasheet. 
+
+    return true;
+}
+
+bool pmw33xx_init(uint8_t sensor) {
+    pd_dprintf("In the pmw33xx_init function.\n");
+    if (sensor >= pmw33xx_number_of_sensors) {
+        return false;
+    }
+    spi_init();
+
+    // power up, need to first drive NCS high then low. the datasheet does not
+    // say for how long, 40us works well in practice.
+    if (!pmw33xx_spi_start(sensor)) {
+        return false;
+    }
+    wait_us(40);
+    spi_stop();
+    wait_us(40);
+
+    if (!pmw33xx_write(sensor, REG_Power_Up_Reset, 0x5a)) {
+        return false;
+    }
+    wait_ms(50);
+
+    // read registers and discard
+    pmw33xx_read(sensor, REG_Motion);
+    pmw33xx_read(sensor, REG_Delta_X_L);
+    pmw33xx_read(sensor, REG_Delta_X_H);
+    pmw33xx_read(sensor, REG_Delta_Y_L);
+    pmw33xx_read(sensor, REG_Delta_Y_H);
+
+    if (!pmw33xx_upload_firmware(sensor)) {
+        pd_dprintf("PMW33XX (%d): firmware upload failed!\n", sensor);
+        return false;
+    }
+
+    // Extra steps per 3389 datasheet.
+    pmw33xx_write(sensor, 0x3D, 0x80);
+    for (int i = 0; i < 55; i++) {
+        wait_ms(1);
+        if (pmw33xx_read(sensor, 0x3D) == 0xC0) {
+            pd_dprintf("Register 0x3D reached value 0xC0 after %d ms.\n", i);
+            break;
+        }
+    }
+    pmw33xx_write(sensor, 0x3D, 0x00);
+    pmw33xx_write(sensor, REG_Config2, 0x10);
+
+    // Configure the rest of the registers
+    wait_ms(10);
+    pmw33xx_set_cpi(sensor, PMW33XX_CPI);
+
+    wait_ms(1);
+
+    pmw33xx_write(sensor, REG_Config2, 0x00);
+    pmw33xx_write(sensor, REG_Angle_Tune, CONSTRAIN(ROTATIONAL_TRANSFORM_ANGLE, -127, 127));
+    pmw33xx_write(sensor, REG_Lift_Config, PMW33XX_LIFTOFF_DISTANCE);
+
+    if (!pmw33xx_check_signature(sensor)) {
+        pd_dprintf("PMW33XX (%d): firmware signature verification failed!\n", sensor);
+        return false;
+    }
+    pd_dprintf("Leaving the pmw33xx_init function.\n");
+    return true;
+}
+
+pmw33xx_report_t pmw33xx_read_burst(uint8_t sensor) {
+    pmw33xx_report_t report = {0};
+
+    if (sensor >= pmw33xx_number_of_sensors) {
+        return report;
+    }
+
+    if (!in_burst[sensor]) {
+        //pd_dprintf("PMW33XX (%d): burst\n", sensor);
+        if (!pmw33xx_write(sensor, REG_Motion_Burst, 0x00)) {
+            return report;
+        }
+        in_burst[sensor] = true;
+    }
+
+    if (!pmw33xx_spi_start(sensor)) {
+        return report;
+    }
+
+    spi_write(REG_Motion_Burst);
+    wait_us(35); // waits for tSRAD_MOTBR
+
+    spi_receive((uint8_t*)&report, sizeof(report));
+
+    // panic recovery, sometimes burst mode works weird.
+    if (report.motion.w & 0b111) {
+        in_burst[sensor] = false;
+    }
+
+    spi_stop();
+
+    //pd_dprintf("PMW33XX (%d): motion: 0x%x dx: %i dy: %i\n", sensor, report.motion.w, report.delta_x, report.delta_y);
+
+    report.delta_x *= -1;
+    report.delta_y *= -1;
+
+    return report;
+}
 
 uint16_t pmw33xx_get_cpi(uint8_t sensor) {
     if (sensor >= pmw33xx_number_of_sensors) {
         return 0;
     }
 
+    // pd_dprintf("Reading CPI... 0x%02x", pmw33xx_read(sensor, REG_Resolution_H));
+    // wait_ms(10);
+    // pd_dprintf("%02x\n", pmw33xx_read(sensor, REG_Resolution_L));
     uint16_t cpival = (pmw33xx_read(sensor, REG_Resolution_H) << 8) | pmw33xx_read(sensor, REG_Resolution_L);
     return (uint16_t)((cpival + 1) & 0xFFFF) * PMW33XX_CPI_STEP;
 }