1 files changed, 192 insertions, 97 deletions

diff --git a/drivers/sensors/cirque_pinnacle.c b/drivers/sensors/cirque_pinnacle.c
index 2db7f916fe..8bd4eb736e 100644
--- a/drivers/sensors/cirque_pinnacle.c
+++ b/drivers/sensors/cirque_pinnacle.c
@@ -1,52 +1,26 @@
 // Copyright (c) 2018 Cirque Corp. Restrictions apply. See: www.cirque.com/sw-license
+// based on https://github.com/cirque-corp/Cirque_Pinnacle_1CA027/tree/master/Circular_Trackpad
+// with modifications and changes for QMK
+// refer to documentation: Gen2 and Gen3 (Pinnacle ASIC) at https://www.cirque.com/documentation
+
 #include "cirque_pinnacle.h"
 #include "print.h"
 #include "debug.h"
 #include "wait.h"
+#include "timer.h"
+
+#include <stdlib.h>
 
-// Registers for RAP
-// clang-format off
-#define FIRMWARE_ID          0x00
-#define FIRMWARE_VERSION_C   0x01
-#define STATUS_1             0x02
-#define SYSCONFIG_1          0x03
-#define FEEDCONFIG_1         0x04
-#define FEEDCONFIG_2         0x05
-#define CALIBRATION_CONFIG_1 0x07
-#define PS2_AU_CONTROL       0x08
-#define SAMPLE_RATE          0x09
-#define Z_IDLE_COUNT         0x0A
-#define Z_SCALER             0x0B
-#define SLEEP_INTERVAL       0x0C
-#define SLEEP_TIMER          0x0D
-#define PACKET_BYTE_0        0x12
-#define PACKET_BYTE_1        0x13
-#define PACKET_BYTE_2        0x14
-#define PACKET_BYTE_3        0x15
-#define PACKET_BYTE_4        0x16
-#define PACKET_BYTE_5        0x17
-
-#define ERA_VALUE            0x1B
-#define ERA_HIGH_BYTE        0x1C
-#define ERA_LOW_BYTE         0x1D
-#define ERA_CONTROL          0x1E
-
-// ADC-attenuation settings (held in BIT_7 and BIT_6)
-// 1X = most sensitive, 4X = least sensitive
-#define ADC_ATTENUATE_1X     0x00
-#define ADC_ATTENUATE_2X     0x40
-#define ADC_ATTENUATE_3X     0x80
-#define ADC_ATTENUATE_4X     0xC0
-
-// Register config values for this demo
-#define SYSCONFIG_1_VALUE    0x00
-#define FEEDCONFIG_1_VALUE   0x03  // 0x03 for absolute mode 0x01 for relative mode
-#define FEEDCONFIG_2_VALUE   0x1C  // 0x1F for normal functionality 0x1E for intellimouse disabled
-#define Z_IDLE_COUNT_VALUE   0x05
-// clang-format on
+#ifndef CIRQUE_PINNACLE_ATTENUATION
+#    ifdef CIRQUE_PINNACLE_CURVED_OVERLAY
+#        define CIRQUE_PINNACLE_ATTENUATION EXTREG__TRACK_ADCCONFIG__ADC_ATTENUATE_2X
+#    else
+#        define CIRQUE_PINNACLE_ATTENUATION EXTREG__TRACK_ADCCONFIG__ADC_ATTENUATE_4X
+#    endif
+#endif
 
 bool     touchpad_init;
-uint16_t scale_data = 1024;
+uint16_t scale_data = CIRQUE_PINNACLE_DEFAULT_SCALE;
 
 void cirque_pinnacle_clear_flags(void);
 void cirque_pinnacle_enable_feed(bool feedEnable);
@@ -59,6 +33,7 @@ void print_byte(uint8_t byte) {
 }
 #endif
 
+#if CIRQUE_PINNACLE_POSITION_MODE
 /*  Logical Scaling Functions */
 // Clips raw coordinates to "reachable" window of sensor
 // NOTE: values outside this window can only appear as a result of noise
@@ -74,6 +49,7 @@ void ClipCoordinates(pinnacle_data_t* coordinates) {
         coordinates->yValue = CIRQUE_PINNACLE_Y_UPPER;
     }
 }
+#endif
 
 uint16_t cirque_pinnacle_get_scale(void) {
     return scale_data;
@@ -84,6 +60,7 @@ void cirque_pinnacle_set_scale(uint16_t scale) {
 
 // Scales data to desired X & Y resolution
 void cirque_pinnacle_scale_data(pinnacle_data_t* coordinates, uint16_t xResolution, uint16_t yResolution) {
+#if CIRQUE_PINNACLE_POSITION_MODE
     uint32_t xTemp = 0;
     uint32_t yTemp = 0;
 
@@ -99,49 +76,65 @@ void cirque_pinnacle_scale_data(pinnacle_data_t* coordinates, uint16_t xResoluti
     // scale coordinates to (xResolution, yResolution) range
     coordinates->xValue = (uint16_t)(xTemp * xResolution / CIRQUE_PINNACLE_X_RANGE);
     coordinates->yValue = (uint16_t)(yTemp * yResolution / CIRQUE_PINNACLE_Y_RANGE);
+#else
+    int32_t        xTemp = 0, yTemp = 0;
+    ldiv_t         temp;
+    static int32_t xRemainder, yRemainder;
+
+    temp       = ldiv(((int32_t)coordinates->xDelta) * (int32_t)xResolution + xRemainder, (int32_t)CIRQUE_PINNACLE_X_RANGE);
+    xTemp      = temp.quot;
+    xRemainder = temp.rem;
+
+    temp       = ldiv(((int32_t)coordinates->yDelta) * (int32_t)yResolution + yRemainder, (int32_t)CIRQUE_PINNACLE_Y_RANGE);
+    yTemp      = temp.quot;
+    yRemainder = temp.rem;
+
+    coordinates->xDelta = (int16_t)xTemp;
+    coordinates->yDelta = (int16_t)yTemp;
+#endif
 }
 
 // Clears Status1 register flags (SW_CC and SW_DR)
 void cirque_pinnacle_clear_flags() {
-    RAP_Write(STATUS_1, 0x00);
+    RAP_Write(HOSTREG__STATUS1, HOSTREG__STATUS1_DEFVAL & ~(HOSTREG__STATUS1__COMMAND_COMPLETE | HOSTREG__STATUS1__DATA_READY));
     wait_us(50);
 }
 
 // Enables/Disables the feed
 void cirque_pinnacle_enable_feed(bool feedEnable) {
-    uint8_t temp;
-
-    RAP_ReadBytes(FEEDCONFIG_1, &temp, 1); // Store contents of FeedConfig1 register
+    uint8_t feedconfig1;
+    RAP_ReadBytes(HOSTREG__FEEDCONFIG1, &feedconfig1, 1);
 
     if (feedEnable) {
-        temp |= 0x01; // Set Feed Enable bit
-        RAP_Write(0x04, temp);
+        feedconfig1 |= HOSTREG__FEEDCONFIG1__FEED_ENABLE;
     } else {
-        temp &= ~0x01; // Clear Feed Enable bit
-        RAP_Write(0x04, temp);
+        feedconfig1 &= ~HOSTREG__FEEDCONFIG1__FEED_ENABLE;
     }
+    RAP_Write(HOSTREG__FEEDCONFIG1, feedconfig1);
 }
 
 /*  ERA (Extended Register Access) Functions  */
 // Reads <count> bytes from an extended register at <address> (16-bit address),
 // stores values in <*data>
 void ERA_ReadBytes(uint16_t address, uint8_t* data, uint16_t count) {
-    uint8_t ERAControlValue = 0xFF;
+    uint8_t  ERAControlValue = 0xFF;
+    uint16_t timeout_timer;
 
     cirque_pinnacle_enable_feed(false); // Disable feed
 
-    RAP_Write(ERA_HIGH_BYTE, (uint8_t)(address >> 8));    // Send upper byte of ERA address
-    RAP_Write(ERA_LOW_BYTE, (uint8_t)(address & 0x00FF)); // Send lower byte of ERA address
+    RAP_Write(HOSTREG__EXT_REG_AXS_ADDR_HIGH, (uint8_t)(address >> 8));    // Send upper byte of ERA address
+    RAP_Write(HOSTREG__EXT_REG_AXS_ADDR_LOW, (uint8_t)(address & 0x00FF)); // Send lower byte of ERA address
 
     for (uint16_t i = 0; i < count; i++) {
-        RAP_Write(ERA_CONTROL, 0x05); // Signal ERA-read (auto-increment) to Pinnacle
+        RAP_Write(HOSTREG__EXT_REG_AXS_CTRL, HOSTREG__EREG_AXS__INC_ADDR_READ | HOSTREG__EREG_AXS__READ); // Signal ERA-read (auto-increment) to Pinnacle
 
         // Wait for status register 0x1E to clear
+        timeout_timer = timer_read();
         do {
-            RAP_ReadBytes(ERA_CONTROL, &ERAControlValue, 1);
-        } while (ERAControlValue != 0x00);
+            RAP_ReadBytes(HOSTREG__EXT_REG_AXS_CTRL, &ERAControlValue, 1);
+        } while ((ERAControlValue != 0x00) && (timer_elapsed(timeout_timer) <= CIRQUE_PINNACLE_TIMEOUT));
 
-        RAP_ReadBytes(ERA_VALUE, data + i, 1);
+        RAP_ReadBytes(HOSTREG__EXT_REG_AXS_VALUE, data + i, 1);
 
         cirque_pinnacle_clear_flags();
     }
@@ -149,49 +142,89 @@ void ERA_ReadBytes(uint16_t address, uint8_t* data, uint16_t count) {
 
 // Writes a byte, <data>, to an extended register at <address> (16-bit address)
 void ERA_WriteByte(uint16_t address, uint8_t data) {
-    uint8_t ERAControlValue = 0xFF;
+    uint8_t  ERAControlValue = 0xFF;
+    uint16_t timeout_timer;
 
     cirque_pinnacle_enable_feed(false); // Disable feed
 
-    RAP_Write(ERA_VALUE, data); // Send data byte to be written
+    RAP_Write(HOSTREG__EXT_REG_AXS_VALUE, data); // Send data byte to be written
 
-    RAP_Write(ERA_HIGH_BYTE, (uint8_t)(address >> 8));    // Upper byte of ERA address
-    RAP_Write(ERA_LOW_BYTE, (uint8_t)(address & 0x00FF)); // Lower byte of ERA address
+    RAP_Write(HOSTREG__EXT_REG_AXS_ADDR_HIGH, (uint8_t)(address >> 8));    // Upper byte of ERA address
+    RAP_Write(HOSTREG__EXT_REG_AXS_ADDR_LOW, (uint8_t)(address & 0x00FF)); // Lower byte of ERA address
 
-    RAP_Write(ERA_CONTROL, 0x02); // Signal an ERA-write to Pinnacle
+    RAP_Write(HOSTREG__EXT_REG_AXS_CTRL, HOSTREG__EREG_AXS__WRITE); // Signal an ERA-write to Pinnacle
 
     // Wait for status register 0x1E to clear
+    timeout_timer = timer_read();
     do {
-        RAP_ReadBytes(ERA_CONTROL, &ERAControlValue, 1);
-    } while (ERAControlValue != 0x00);
+        RAP_ReadBytes(HOSTREG__EXT_REG_AXS_CTRL, &ERAControlValue, 1);
+    } while ((ERAControlValue != 0x00) && (timer_elapsed(timeout_timer) <= CIRQUE_PINNACLE_TIMEOUT));
 
     cirque_pinnacle_clear_flags();
 }
 
-void cirque_pinnacle_set_adc_attenuation(uint8_t adcGain) {
-    uint8_t temp = 0x00;
+bool cirque_pinnacle_set_adc_attenuation(uint8_t adcGain) {
+    uint8_t adcconfig = 0x00;
+
+    ERA_ReadBytes(EXTREG__TRACK_ADCCONFIG, &adcconfig, 1);
+    adcGain &= EXTREG__TRACK_ADCCONFIG__ADC_ATTENUATE_MASK;
+    if (adcGain == (adcconfig & EXTREG__TRACK_ADCCONFIG__ADC_ATTENUATE_MASK)) {
+        return false;
+    }
+    adcconfig &= ~EXTREG__TRACK_ADCCONFIG__ADC_ATTENUATE_MASK;
+    adcconfig |= adcGain;
+    ERA_WriteByte(EXTREG__TRACK_ADCCONFIG, adcconfig);
+    ERA_ReadBytes(EXTREG__TRACK_ADCCONFIG, &adcconfig, 1);
 
-    ERA_ReadBytes(0x0187, &temp, 1);
-    temp &= 0x3F; // clear top two bits
-    temp |= adcGain;
-    ERA_WriteByte(0x0187, temp);
-    ERA_ReadBytes(0x0187, &temp, 1);
+    return true;
 }
 
 // Changes thresholds to improve detection of fingers
+// Not needed for flat overlay?
 void cirque_pinnacle_tune_edge_sensitivity(void) {
-    uint8_t temp = 0x00;
+    uint8_t widezmin = 0x00;
+
+    ERA_ReadBytes(EXTREG__XAXIS_WIDEZMIN, &widezmin, 1);
+    ERA_WriteByte(EXTREG__XAXIS_WIDEZMIN, 0x04); // magic number from Cirque sample code
+    ERA_ReadBytes(EXTREG__XAXIS_WIDEZMIN, &widezmin, 1);
+
+    ERA_ReadBytes(EXTREG__YAXIS_WIDEZMIN, &widezmin, 1);
+    ERA_WriteByte(EXTREG__YAXIS_WIDEZMIN, 0x03); // magic number from Cirque sample code
+    ERA_ReadBytes(EXTREG__YAXIS_WIDEZMIN, &widezmin, 1);
+}
+
+// Perform calibration
+void cirque_pinnacle_calibrate(void) {
+    uint8_t  calconfig;
+    uint16_t timeout_timer;
+
+    RAP_ReadBytes(HOSTREG__CALCONFIG1, &calconfig, 1);
+    calconfig |= HOSTREG__CALCONFIG1__CALIBRATE;
+    RAP_Write(HOSTREG__CALCONFIG1, calconfig);
+
+    // Calibration takes ~100ms according to GT-AN-090624, doubling the timeout just to be safe
+    timeout_timer = timer_read();
+    do {
+        RAP_ReadBytes(HOSTREG__CALCONFIG1, &calconfig, 1);
+    } while ((calconfig & HOSTREG__CALCONFIG1__CALIBRATE) && (timer_elapsed(timeout_timer) <= 200));
+
+    cirque_pinnacle_clear_flags();
+}
 
-    ERA_ReadBytes(0x0149, &temp, 1);
-    ERA_WriteByte(0x0149, 0x04);
-    ERA_ReadBytes(0x0149, &temp, 1);
+// Enable/disable cursor smoothing, smoothing is enabled by default
+void cirque_pinnacle_cursor_smoothing(bool enable) {
+    uint8_t feedconfig3;
 
-    ERA_ReadBytes(0x0168, &temp, 1);
-    ERA_WriteByte(0x0168, 0x03);
-    ERA_ReadBytes(0x0168, &temp, 1);
+    RAP_ReadBytes(HOSTREG__FEEDCONFIG3, &feedconfig3, 1);
+    if (enable) {
+        feedconfig3 &= ~HOSTREG__FEEDCONFIG3__DISABLE_CROSS_RATE_SMOOTHING;
+    } else {
+        feedconfig3 |= HOSTREG__FEEDCONFIG3__DISABLE_CROSS_RATE_SMOOTHING;
+    }
+    RAP_Write(HOSTREG__FEEDCONFIG3, feedconfig3);
 }
 
-/*  Pinnacle-based TM040040 Functions  */
+/*  Pinnacle-based TM040040/TM035035/TM023023 Functions  */
 void cirque_pinnacle_init(void) {
 #if defined(POINTING_DEVICE_DRIVER_cirque_pinnacle_spi)
     spi_init();
@@ -200,39 +233,101 @@ void cirque_pinnacle_init(void) {
 #endif
 
     touchpad_init = true;
+
+    // send a RESET command now, in case QMK had a soft-reset without a power cycle
+    RAP_Write(HOSTREG__SYSCONFIG1, HOSTREG__SYSCONFIG1__RESET);
+    wait_ms(30); // Pinnacle needs 10-15ms to boot, so wait long enough before configuring
+    RAP_Write(HOSTREG__SYSCONFIG1, HOSTREG__SYSCONFIG1_DEFVAL);
+    wait_us(50);
+
     // Host clears SW_CC flag
     cirque_pinnacle_clear_flags();
 
-    // Host configures bits of registers 0x03 and 0x05
-    RAP_Write(SYSCONFIG_1, SYSCONFIG_1_VALUE);
-    RAP_Write(FEEDCONFIG_2, FEEDCONFIG_2_VALUE);
+#if CIRQUE_PINNACLE_POSITION_MODE
+    RAP_Write(HOSTREG__FEEDCONFIG2, HOSTREG__FEEDCONFIG2_DEFVAL);
+#else
+    // FeedConfig2 (Feature flags for Relative Mode Only)
+    uint8_t feedconfig2 = HOSTREG__FEEDCONFIG2__GLIDE_EXTEND_DISABLE | HOSTREG__FEEDCONFIG2__INTELLIMOUSE_MODE;
+#    if !defined(CIRQUE_PINNACLE_TAP_ENABLE)
+    feedconfig2 |= HOSTREG__FEEDCONFIG2__ALL_TAP_DISABLE;
+#    endif
+#    if !defined(CIRQUE_PINNACLE_SECONDARY_TAP_ENABLE)
+    feedconfig2 |= HOSTREG__FEEDCONFIG2__SECONDARY_TAP_DISABLE;
+#    elif !defined(CIRQUE_PINNACLE_TAP_ENABLE)
+#        error CIRQUE_PINNACLE_TAP_ENABLE must be defined for CIRQUE_PINNACLE_SECONDARY_TAP_ENABLE to work
+#    endif
+#    if !defined(CIRQUE_PINNACLE_SIDE_SCROLL_ENABLE)
+    feedconfig2 |= HOSTREG__FEEDCONFIG2__SCROLL_DISABLE;
+#    endif
+    RAP_Write(HOSTREG__FEEDCONFIG2, feedconfig2);
+#endif
 
-    // Host enables preferred output mode (absolute)
-    RAP_Write(FEEDCONFIG_1, FEEDCONFIG_1_VALUE);
+    // FeedConfig1 (Data Output Flags)
+    RAP_Write(HOSTREG__FEEDCONFIG1, CIRQUE_PINNACLE_POSITION_MODE ? HOSTREG__FEEDCONFIG1__DATA_TYPE__REL0_ABS1 : HOSTREG__FEEDCONFIG1_DEFVAL);
 
-    // Host sets z-idle packet count to 5 (default is 30)
-    RAP_Write(Z_IDLE_COUNT, Z_IDLE_COUNT_VALUE);
+#if CIRQUE_PINNACLE_POSITION_MODE
+    // Host sets z-idle packet count to 5 (default is 0x1E/30)
+    RAP_Write(HOSTREG__ZIDLE, 5);
+#endif
 
-    cirque_pinnacle_set_adc_attenuation(0xFF);
+    bool calibrate = cirque_pinnacle_set_adc_attenuation(CIRQUE_PINNACLE_ATTENUATION);
+
+#ifdef CIRQUE_PINNACLE_CURVED_OVERLAY
     cirque_pinnacle_tune_edge_sensitivity();
+    calibrate = true;
+#endif
+    if (calibrate) {
+        // Force a calibration after setting ADC attenuation
+        cirque_pinnacle_calibrate();
+    }
+
     cirque_pinnacle_enable_feed(true);
 }
 
-// Reads XYZ data from Pinnacle registers 0x14 through 0x17
-// Stores result in pinnacle_data_t struct with xValue, yValue, and zValue members
 pinnacle_data_t cirque_pinnacle_read_data(void) {
-    uint8_t         data[6] = {0};
-    pinnacle_data_t result  = {0};
-    RAP_ReadBytes(PACKET_BYTE_0, data, 6);
+    uint8_t         data_ready = 0;
+    uint8_t         data[6]    = {0};
+    pinnacle_data_t result     = {0};
+
+    // Check if there is valid data available
+    RAP_ReadBytes(HOSTREG__STATUS1, &data_ready, 1);
+    if ((data_ready & HOSTREG__STATUS1__DATA_READY) == 0) {
+        // no data available yet
+        result.valid = false; // be explicit
+        return result;
+    }
 
-    cirque_pinnacle_clear_flags();
+    // Read all data bytes
+    RAP_ReadBytes(HOSTREG__PACKETBYTE_0, data, 6);
 
-    result.buttonFlags = data[0] & 0x3F;
-    result.xValue      = data[2] | ((data[4] & 0x0F) << 8);
-    result.yValue      = data[3] | ((data[4] & 0xF0) << 4);
-    result.zValue      = data[5] & 0x3F;
+    // Get ready for the next data sample
+    cirque_pinnacle_clear_flags();
 
-    result.touchDown = (result.xValue != 0 || result.yValue != 0);
+#if CIRQUE_PINNACLE_POSITION_MODE
+    // Decode data for absolute mode
+    // Register 0x13 is unused in this mode (palm detection area)
+    result.buttonFlags = data[0] & 0x3F;                             // bit0 to bit5 are switch 0-5, only hardware button presses (from input pin on the Pinnacle chip)
+    result.xValue      = data[2] | ((data[4] & 0x0F) << 8);          // merge high and low bits for X
+    result.yValue      = data[3] | ((data[4] & 0xF0) << 4);          // merge high and low bits for Y
+    result.zValue      = data[5] & 0x3F;                             // Z is only lower 6 bits, upper 2 bits are reserved/unused
+    result.touchDown   = (result.xValue != 0 || result.yValue != 0); // (0,0) is a "magic coordinate" to indicate "finger touched down"
+#else
+    // Decode data for relative mode
+    // Registers 0x16 and 0x17 are unused in this mode
+    result.buttons = data[0] & 0x07; // Only three buttons are supported
+    if ((data[0] & 0x10) && data[1] != 0) {
+        result.xDelta = -((int16_t)256 - (int16_t)(data[1]));
+    } else {
+        result.xDelta = data[1];
+    }
+    if ((data[0] & 0x20) && data[2] != 0) {
+        result.yDelta = ((int16_t)256 - (int16_t)(data[2]));
+    } else {
+        result.yDelta = -((int16_t)data[2]);
+    }
+    result.wheelCount = ((int8_t*)data)[3];
+#endif
 
+    result.valid = true;
     return result;
 }