logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

cirque_pinnacle.c (18091B)

    

  1. // Copyright (c) 2018 Cirque Corp. Restrictions apply. See: www.cirque.com/sw-license
  2. // based on https://github.com/cirque-corp/Cirque_Pinnacle_1CA027/tree/master/Circular_Trackpad
  3. // with modifications and changes for QMK
  4. // refer to documentation: Gen2 and Gen3 (Pinnacle ASIC) at https://www.cirque.com/documentation
  6. #include "cirque_pinnacle.h"
  7. #include "cirque_pinnacle_gestures.h"
  8. #include "wait.h"
  9. #include "timer.h"
  11. #include <stdlib.h>
  13. #ifndef CIRQUE_PINNACLE_ATTENUATION
  14. #    ifdef CIRQUE_PINNACLE_CURVED_OVERLAY
  15. #        define CIRQUE_PINNACLE_ATTENUATION EXTREG__TRACK_ADCCONFIG__ADC_ATTENUATE_2X
  16. #    else
  17. #        define CIRQUE_PINNACLE_ATTENUATION EXTREG__TRACK_ADCCONFIG__ADC_ATTENUATE_4X
  18. #    endif
  19. #endif
  21. bool     touchpad_init;
  22. uint16_t scale_data = CIRQUE_PINNACLE_DEFAULT_SCALE;
  24. void cirque_pinnacle_clear_flags(void);
  25. void cirque_pinnacle_enable_feed(bool feedEnable);
  26. void RAP_ReadBytes(uint8_t address, uint8_t* data, uint8_t count);
  27. void RAP_Write(uint8_t address, uint8_t data);
  29. #if CIRQUE_PINNACLE_POSITION_MODE
  30. /*  Logical Scaling Functions */
  31. // Clips raw coordinates to "reachable" window of sensor
  32. // NOTE: values outside this window can only appear as a result of noise
  33. void ClipCoordinates(pinnacle_data_t* coordinates) {
  34.     if (coordinates->xValue < CIRQUE_PINNACLE_X_LOWER) {
  35.         coordinates->xValue = CIRQUE_PINNACLE_X_LOWER;
  36.     } else if (coordinates->xValue > CIRQUE_PINNACLE_X_UPPER) {
  37.         coordinates->xValue = CIRQUE_PINNACLE_X_UPPER;
  38.     }
  39.     if (coordinates->yValue < CIRQUE_PINNACLE_Y_LOWER) {
  40.         coordinates->yValue = CIRQUE_PINNACLE_Y_LOWER;
  41.     } else if (coordinates->yValue > CIRQUE_PINNACLE_Y_UPPER) {
  42.         coordinates->yValue = CIRQUE_PINNACLE_Y_UPPER;
  43.     }
  44. }
  45. #endif
  47. uint16_t cirque_pinnacle_get_scale(void) {
  48.     return scale_data;
  49. }
  50. void cirque_pinnacle_set_scale(uint16_t scale) {
  51.     scale_data = scale;
  52. }
  54. // Scales data to desired X & Y resolution
  55. void cirque_pinnacle_scale_data(pinnacle_data_t* coordinates, uint16_t xResolution, uint16_t yResolution) {
  56. #if CIRQUE_PINNACLE_POSITION_MODE
  57.     uint32_t xTemp = 0;
  58.     uint32_t yTemp = 0;
  60.     ClipCoordinates(coordinates);
  62.     xTemp = coordinates->xValue;
  63.     yTemp = coordinates->yValue;
  65.     // translate coordinates to (0, 0) reference by subtracting edge-offset
  66.     xTemp -= CIRQUE_PINNACLE_X_LOWER;
  67.     yTemp -= CIRQUE_PINNACLE_Y_LOWER;
  69.     // scale coordinates to (xResolution, yResolution) range
  70.     coordinates->xValue = (uint16_t)(xTemp * xResolution / CIRQUE_PINNACLE_X_RANGE);
  71.     coordinates->yValue = (uint16_t)(yTemp * yResolution / CIRQUE_PINNACLE_Y_RANGE);
  72. #else
  73.     int32_t        xTemp = 0, yTemp = 0;
  74.     ldiv_t         temp;
  75.     static int32_t xRemainder, yRemainder;
  77.     temp       = ldiv(((int32_t)coordinates->xDelta) * (int32_t)xResolution + xRemainder, (int32_t)CIRQUE_PINNACLE_X_RANGE);
  78.     xTemp      = temp.quot;
  79.     xRemainder = temp.rem;
  81.     temp       = ldiv(((int32_t)coordinates->yDelta) * (int32_t)yResolution + yRemainder, (int32_t)CIRQUE_PINNACLE_Y_RANGE);
  82.     yTemp      = temp.quot;
  83.     yRemainder = temp.rem;
  85.     coordinates->xDelta = (int16_t)xTemp;
  86.     coordinates->yDelta = (int16_t)yTemp;
  87. #endif
  88. }
  90. // Clears Status1 register flags (SW_CC and SW_DR)
  91. void cirque_pinnacle_clear_flags(void) {
  92.     RAP_Write(HOSTREG__STATUS1, HOSTREG__STATUS1_DEFVAL & ~(HOSTREG__STATUS1__COMMAND_COMPLETE | HOSTREG__STATUS1__DATA_READY));
  93.     wait_us(50);
  94. }
  96. // Enables/Disables the feed
  97. void cirque_pinnacle_enable_feed(bool feedEnable) {
  98.     uint8_t feedconfig1;
  99.     RAP_ReadBytes(HOSTREG__FEEDCONFIG1, &feedconfig1, 1);
  101.     if (feedEnable) {
  102.         feedconfig1 |= HOSTREG__FEEDCONFIG1__FEED_ENABLE;
  103.     } else {
  104.         feedconfig1 &= ~HOSTREG__FEEDCONFIG1__FEED_ENABLE;
  105.     }
  106.     RAP_Write(HOSTREG__FEEDCONFIG1, feedconfig1);
  107. }
  109. /*  ERA (Extended Register Access) Functions  */
  110. // Reads <count> bytes from an extended register at <address> (16-bit address),
  111. // stores values in <*data>
  112. void ERA_ReadBytes(uint16_t address, uint8_t* data, uint16_t count) {
  113.     uint8_t  ERAControlValue = 0xFF;
  114.     uint16_t timeout_timer;
  116.     cirque_pinnacle_enable_feed(false); // Disable feed
  118.     RAP_Write(HOSTREG__EXT_REG_AXS_ADDR_HIGH, (uint8_t)(address >> 8));    // Send upper byte of ERA address
  119.     RAP_Write(HOSTREG__EXT_REG_AXS_ADDR_LOW, (uint8_t)(address & 0x00FF)); // Send lower byte of ERA address
  121.     for (uint16_t i = 0; i < count; i++) {
  122.         RAP_Write(HOSTREG__EXT_REG_AXS_CTRL, HOSTREG__EREG_AXS__INC_ADDR_READ | HOSTREG__EREG_AXS__READ); // Signal ERA-read (auto-increment) to Pinnacle
  124.         // Wait for status register 0x1E to clear
  125.         timeout_timer = timer_read();
  126.         do {
  127.             RAP_ReadBytes(HOSTREG__EXT_REG_AXS_CTRL, &ERAControlValue, 1);
  128.         } while ((ERAControlValue != 0x00) && (timer_elapsed(timeout_timer) <= CIRQUE_PINNACLE_TIMEOUT));
  130.         RAP_ReadBytes(HOSTREG__EXT_REG_AXS_VALUE, data + i, 1);
  132.         cirque_pinnacle_clear_flags();
  133.     }
  134. }
  136. // Writes a byte, <data>, to an extended register at <address> (16-bit address)
  137. void ERA_WriteByte(uint16_t address, uint8_t data) {
  138.     uint8_t  ERAControlValue = 0xFF;
  139.     uint16_t timeout_timer;
  141.     cirque_pinnacle_enable_feed(false); // Disable feed
  143.     RAP_Write(HOSTREG__EXT_REG_AXS_VALUE, data); // Send data byte to be written
  145.     RAP_Write(HOSTREG__EXT_REG_AXS_ADDR_HIGH, (uint8_t)(address >> 8));    // Upper byte of ERA address
  146.     RAP_Write(HOSTREG__EXT_REG_AXS_ADDR_LOW, (uint8_t)(address & 0x00FF)); // Lower byte of ERA address
  148.     RAP_Write(HOSTREG__EXT_REG_AXS_CTRL, HOSTREG__EREG_AXS__WRITE); // Signal an ERA-write to Pinnacle
  150.     // Wait for status register 0x1E to clear
  151.     timeout_timer = timer_read();
  152.     do {
  153.         RAP_ReadBytes(HOSTREG__EXT_REG_AXS_CTRL, &ERAControlValue, 1);
  154.     } while ((ERAControlValue != 0x00) && (timer_elapsed(timeout_timer) <= CIRQUE_PINNACLE_TIMEOUT));
  156.     cirque_pinnacle_clear_flags();
  157. }
  159. bool cirque_pinnacle_set_adc_attenuation(uint8_t adcGain) {
  160.     uint8_t adcconfig = 0x00;
  162.     ERA_ReadBytes(EXTREG__TRACK_ADCCONFIG, &adcconfig, 1);
  163.     adcGain &= EXTREG__TRACK_ADCCONFIG__ADC_ATTENUATE_MASK;
  164.     if (adcGain == (adcconfig & EXTREG__TRACK_ADCCONFIG__ADC_ATTENUATE_MASK)) {
  165.         return false;
  166.     }
  167.     adcconfig &= ~EXTREG__TRACK_ADCCONFIG__ADC_ATTENUATE_MASK;
  168.     adcconfig |= adcGain;
  169.     ERA_WriteByte(EXTREG__TRACK_ADCCONFIG, adcconfig);
  170.     ERA_ReadBytes(EXTREG__TRACK_ADCCONFIG, &adcconfig, 1);
  172.     return true;
  173. }
  175. // Changes thresholds to improve detection of fingers
  176. // Not needed for flat overlay?
  177. void cirque_pinnacle_tune_edge_sensitivity(void) {
  178.     uint8_t widezmin = 0x00;
  180.     ERA_ReadBytes(EXTREG__XAXIS_WIDEZMIN, &widezmin, 1);
  181.     ERA_WriteByte(EXTREG__XAXIS_WIDEZMIN, 0x04); // magic number from Cirque sample code
  182.     ERA_ReadBytes(EXTREG__XAXIS_WIDEZMIN, &widezmin, 1);
  184.     ERA_ReadBytes(EXTREG__YAXIS_WIDEZMIN, &widezmin, 1);
  185.     ERA_WriteByte(EXTREG__YAXIS_WIDEZMIN, 0x03); // magic number from Cirque sample code
  186.     ERA_ReadBytes(EXTREG__YAXIS_WIDEZMIN, &widezmin, 1);
  187. }
  189. // Perform calibration
  190. void cirque_pinnacle_calibrate(void) {
  191.     uint8_t  calconfig;
  192.     uint16_t timeout_timer;
  194.     RAP_ReadBytes(HOSTREG__CALCONFIG1, &calconfig, 1);
  195.     calconfig |= HOSTREG__CALCONFIG1__CALIBRATE;
  196.     RAP_Write(HOSTREG__CALCONFIG1, calconfig);
  198.     // Calibration takes ~100ms according to GT-AN-090624, doubling the timeout just to be safe
  199.     timeout_timer = timer_read();
  200.     do {
  201.         RAP_ReadBytes(HOSTREG__CALCONFIG1, &calconfig, 1);
  202.     } while ((calconfig & HOSTREG__CALCONFIG1__CALIBRATE) && (timer_elapsed(timeout_timer) <= 200));
  204.     cirque_pinnacle_clear_flags();
  205. }
  207. // Enable/disable cursor smoothing, smoothing is enabled by default
  208. void cirque_pinnacle_cursor_smoothing(bool enable) {
  209.     uint8_t feedconfig3;
  211.     RAP_ReadBytes(HOSTREG__FEEDCONFIG3, &feedconfig3, 1);
  212.     if (enable) {
  213.         feedconfig3 &= ~HOSTREG__FEEDCONFIG3__DISABLE_CROSS_RATE_SMOOTHING;
  214.     } else {
  215.         feedconfig3 |= HOSTREG__FEEDCONFIG3__DISABLE_CROSS_RATE_SMOOTHING;
  216.     }
  217.     RAP_Write(HOSTREG__FEEDCONFIG3, feedconfig3);
  218. }
  220. // Check sensor is connected
  221. bool cirque_pinnacle_connected(void) {
  222.     uint8_t current_zidle = 0;
  223.     uint8_t temp_zidle    = 0;
  224.     RAP_ReadBytes(HOSTREG__ZIDLE, &current_zidle, 1);
  225.     RAP_Write(HOSTREG__ZIDLE, HOSTREG__ZIDLE_DEFVAL);
  226.     RAP_ReadBytes(HOSTREG__ZIDLE, &temp_zidle, 1);
  227.     if (temp_zidle == HOSTREG__ZIDLE_DEFVAL) {
  228.         RAP_Write(HOSTREG__ZIDLE, current_zidle);
  229.         return true;
  230.     }
  231.     return false;
  232. }
  234. /*  Pinnacle-based TM040040/TM035035/TM023023 Functions  */
  235. void cirque_pinnacle_init(void) {
  236. #if defined(POINTING_DEVICE_DRIVER_cirque_pinnacle_spi)
  237.     spi_init();
  238. #elif defined(POINTING_DEVICE_DRIVER_cirque_pinnacle_i2c)
  239.     i2c_init();
  240. #endif
  242.     touchpad_init = true;
  244.     // send a RESET command now, in case QMK had a soft-reset without a power cycle
  245.     RAP_Write(HOSTREG__SYSCONFIG1, HOSTREG__SYSCONFIG1__RESET);
  246.     wait_ms(30); // Pinnacle needs 10-15ms to boot, so wait long enough before configuring
  247.     RAP_Write(HOSTREG__SYSCONFIG1, HOSTREG__SYSCONFIG1_DEFVAL);
  248.     wait_us(50);
  250.     // Host clears SW_CC flag
  251.     cirque_pinnacle_clear_flags();
  253. #if CIRQUE_PINNACLE_POSITION_MODE
  254.     RAP_Write(HOSTREG__FEEDCONFIG2, HOSTREG__FEEDCONFIG2_DEFVAL);
  255. #else
  256.     // FeedConfig2 (Feature flags for Relative Mode Only)
  257.     uint8_t feedconfig2 = HOSTREG__FEEDCONFIG2__GLIDE_EXTEND_DISABLE | HOSTREG__FEEDCONFIG2__INTELLIMOUSE_MODE;
  258. #    if !defined(CIRQUE_PINNACLE_TAP_ENABLE)
  259.     feedconfig2 |= HOSTREG__FEEDCONFIG2__ALL_TAP_DISABLE;
  260. #    endif
  261. #    if !defined(CIRQUE_PINNACLE_SECONDARY_TAP_ENABLE)
  262.     feedconfig2 |= HOSTREG__FEEDCONFIG2__SECONDARY_TAP_DISABLE;
  263. #    elif !defined(CIRQUE_PINNACLE_TAP_ENABLE)
  264. #        error CIRQUE_PINNACLE_TAP_ENABLE must be defined for CIRQUE_PINNACLE_SECONDARY_TAP_ENABLE to work
  265. #    endif
  266. #    if !defined(CIRQUE_PINNACLE_SIDE_SCROLL_ENABLE)
  267.     feedconfig2 |= HOSTREG__FEEDCONFIG2__SCROLL_DISABLE;
  268. #    endif
  269.     RAP_Write(HOSTREG__FEEDCONFIG2, feedconfig2);
  270. #endif
  272.     // FeedConfig1 (Data Output Flags)
  273.     RAP_Write(HOSTREG__FEEDCONFIG1, CIRQUE_PINNACLE_POSITION_MODE ? HOSTREG__FEEDCONFIG1__DATA_TYPE__REL0_ABS1 : HOSTREG__FEEDCONFIG1_DEFVAL);
  275. #if CIRQUE_PINNACLE_POSITION_MODE
  276.     // Host sets z-idle packet count to 5 (default is 0x1E/30)
  277.     RAP_Write(HOSTREG__ZIDLE, 5);
  278. #endif
  280.     bool calibrate = cirque_pinnacle_set_adc_attenuation(CIRQUE_PINNACLE_ATTENUATION);
  282. #ifdef CIRQUE_PINNACLE_CURVED_OVERLAY
  283.     cirque_pinnacle_tune_edge_sensitivity();
  284.     calibrate = true;
  285. #endif
  286.     if (calibrate) {
  287.         // Force a calibration after setting ADC attenuation
  288.         cirque_pinnacle_calibrate();
  289.     }
  291.     cirque_pinnacle_enable_feed(true);
  293. #ifndef CIRQUE_PINNACLE_SKIP_SENSOR_CHECK
  294.     touchpad_init = cirque_pinnacle_connected();
  295. #endif
  296. }
  298. pinnacle_data_t cirque_pinnacle_read_data(void) {
  299.     uint8_t         data_ready = 0;
  300.     uint8_t         data[6]    = {0};
  301.     pinnacle_data_t result     = {0};
  303.     // Check if there is valid data available
  304.     RAP_ReadBytes(HOSTREG__STATUS1, &data_ready, 1);
  305.     if ((data_ready & HOSTREG__STATUS1__DATA_READY) == 0) {
  306.         // no data available yet
  307.         result.valid = false; // be explicit
  308.         return result;
  309.     }
  311.     // Read all data bytes
  312.     RAP_ReadBytes(HOSTREG__PACKETBYTE_0, data, 6);
  314.     // Get ready for the next data sample
  315.     cirque_pinnacle_clear_flags();
  317. #if CIRQUE_PINNACLE_POSITION_MODE
  318.     // Decode data for absolute mode
  319.     // Register 0x13 is unused in this mode (palm detection area)
  320.     result.buttonFlags = data[0] & 0x3F;                             // bit0 to bit5 are switch 0-5, only hardware button presses (from input pin on the Pinnacle chip)
  321.     result.xValue      = data[2] | ((data[4] & 0x0F) << 8);          // merge high and low bits for X
  322.     result.yValue      = data[3] | ((data[4] & 0xF0) << 4);          // merge high and low bits for Y
  323.     result.zValue      = data[5] & 0x3F;                             // Z is only lower 6 bits, upper 2 bits are reserved/unused
  324.     result.touchDown   = (result.xValue != 0 || result.yValue != 0); // (0,0) is a "magic coordinate" to indicate "finger touched down"
  325. #else
  326.     // Decode data for relative mode
  327.     // Registers 0x16 and 0x17 are unused in this mode
  328.     result.buttons = data[0] & 0x07; // Only three buttons are supported
  329.     if ((data[0] & 0x10) && data[1] != 0) {
  330.         result.xDelta = -((int16_t)256 - (int16_t)(data[1]));
  331.     } else {
  332.         result.xDelta = data[1];
  333.     }
  334.     if ((data[0] & 0x20) && data[2] != 0) {
  335.         result.yDelta = ((int16_t)256 - (int16_t)(data[2]));
  336.     } else {
  337.         result.yDelta = -((int16_t)data[2]);
  338.     }
  339.     result.wheelCount = ((int8_t*)data)[3];
  340. #endif
  342. #ifdef CIRQUE_PINNACLE_REACHABLE_CALIBRATION
  343.     static uint16_t xMin = UINT16_MAX, yMin = UINT16_MAX, yMax = 0, xMax = 0;
  344.     if (result.xValue < xMin) xMin = result.xValue;
  345.     if (result.xValue > xMax) xMax = result.xValue;
  346.     if (result.yValue < yMin) yMin = result.yValue;
  347.     if (result.yValue > yMax) yMax = result.yValue;
  348.     pd_dprintf("%s: xLo=%3d xHi=%3d yLo=%3d yHi=%3d\n", __FUNCTION__, xMin, xMax, yMin, yMax);
  349. #endif
  351.     result.valid = true;
  352.     return result;
  353. }
  355. #ifdef POINTING_DEVICE_GESTURES_CURSOR_GLIDE_ENABLE
  356. static bool cursor_glide_enable = true;
  358. static cursor_glide_context_t glide = {.config = {
  359.                                            .coef       = 102, /* Good default friction coef */
  360.                                            .interval   = 10,  /* 100sps */
  361.                                            .trigger_px = 10,  /* Default threshold in case of hover, set to 0 if you'd like */
  362.                                        }};
  364. void cirque_pinnacle_enable_cursor_glide(bool enable) {
  365.     cursor_glide_enable = enable;
  366. }
  368. void cirque_pinnacle_configure_cursor_glide(float trigger_px) {
  369.     glide.config.trigger_px = trigger_px;
  370. }
  371. #endif
  373. #if CIRQUE_PINNACLE_POSITION_MODE
  375. #    ifdef POINTING_DEVICE_AUTO_MOUSE_ENABLE
  376. static bool is_touch_down;
  378. bool auto_mouse_activation(report_mouse_t mouse_report) {
  379.     return is_touch_down || mouse_report.x != 0 || mouse_report.y != 0 || mouse_report.h != 0 || mouse_report.v != 0 || mouse_report.buttons;
  380. }
  381. #    endif
  383. report_mouse_t cirque_pinnacle_get_report(report_mouse_t mouse_report) {
  384.     uint16_t          scale     = cirque_pinnacle_get_scale();
  385.     pinnacle_data_t   touchData = cirque_pinnacle_read_data();
  386.     mouse_xy_report_t report_x = 0, report_y = 0;
  387.     static uint16_t   x = 0, y = 0, last_scale = 0;
  389. #    if defined(CIRQUE_PINNACLE_TAP_ENABLE)
  390.     mouse_report.buttons = pointing_device_handle_buttons(mouse_report.buttons, false, POINTING_DEVICE_BUTTON1);
  391. #    endif
  392. #    ifdef POINTING_DEVICE_GESTURES_CURSOR_GLIDE_ENABLE
  393.     cursor_glide_t glide_report = {0};
  395.     if (cursor_glide_enable) {
  396.         glide_report = cursor_glide_check(&glide);
  397.     }
  398. #    endif
  400.     if (!touchData.valid) {
  401. #    ifdef POINTING_DEVICE_GESTURES_CURSOR_GLIDE_ENABLE
  402.         if (cursor_glide_enable && glide_report.valid) {
  403.             report_x = glide_report.dx;
  404.             report_y = glide_report.dy;
  405.             goto mouse_report_update;
  406.         }
  407. #    endif
  408.         return mouse_report;
  409.     }
  411.     if (touchData.touchDown) {
  412.         pd_dprintf("cirque_pinnacle touchData x=%4d y=%4d z=%2d\n", touchData.xValue, touchData.yValue, touchData.zValue);
  413.     }
  415. #    ifdef POINTING_DEVICE_AUTO_MOUSE_ENABLE
  416.     is_touch_down = touchData.touchDown;
  417. #    endif
  419.     // Scale coordinates to arbitrary X, Y resolution
  420.     cirque_pinnacle_scale_data(&touchData, scale, scale);
  422.     if (!cirque_pinnacle_gestures(&mouse_report, touchData)) {
  423.         if (last_scale && scale == last_scale && x && y && touchData.xValue && touchData.yValue) {
  424.             report_x = CONSTRAIN_HID_XY((int16_t)(touchData.xValue - x));
  425.             report_y = CONSTRAIN_HID_XY((int16_t)(touchData.yValue - y));
  426.         }
  427.         x          = touchData.xValue;
  428.         y          = touchData.yValue;
  429.         last_scale = scale;
  431. #    ifdef POINTING_DEVICE_GESTURES_CURSOR_GLIDE_ENABLE
  432.         if (cursor_glide_enable) {
  433.             if (touchData.touchDown) {
  434.                 cursor_glide_update(&glide, report_x, report_y, touchData.zValue);
  435.             } else if (!glide_report.valid) {
  436.                 glide_report = cursor_glide_start(&glide);
  437.                 if (glide_report.valid) {
  438.                     report_x = glide_report.dx;
  439.                     report_y = glide_report.dy;
  440.                 }
  441.             }
  442.         }
  443. #    endif
  444.     }
  446. #    ifdef POINTING_DEVICE_GESTURES_CURSOR_GLIDE_ENABLE
  447. mouse_report_update:
  448. #    endif
  449.     mouse_report.x = report_x;
  450.     mouse_report.y = report_y;
  452.     return mouse_report;
  453. }
  455. uint16_t cirque_pinnacle_get_cpi(void) {
  456.     return CIRQUE_PINNACLE_PX_TO_INCH(cirque_pinnacle_get_scale());
  457. }
  458. void cirque_pinnacle_set_cpi(uint16_t cpi) {
  459.     cirque_pinnacle_set_scale(CIRQUE_PINNACLE_INCH_TO_PX(cpi));
  460. }
  462. // clang-format off
  463. const pointing_device_driver_t cirque_pinnacle_pointing_device_driver = {
  464.     .init       = cirque_pinnacle_init,
  465.     .get_report = cirque_pinnacle_get_report,
  466.     .set_cpi    = cirque_pinnacle_set_cpi,
  467.     .get_cpi    = cirque_pinnacle_get_cpi
  468. };
  469. // clang-format on
  470. #else
  471. report_mouse_t cirque_pinnacle_get_report(report_mouse_t mouse_report) {
  472.     pinnacle_data_t touchData = cirque_pinnacle_read_data();
  474.     // Scale coordinates to arbitrary X, Y resolution
  475.     cirque_pinnacle_scale_data(&touchData, cirque_pinnacle_get_scale(), cirque_pinnacle_get_scale());
  477.     if (touchData.valid) {
  478.         mouse_report.buttons = touchData.buttons;
  479.         mouse_report.x = CONSTRAIN_HID_XY(touchData.xDelta);
  480.         mouse_report.y = CONSTRAIN_HID_XY(touchData.yDelta);
  481.         mouse_report.v = touchData.wheelCount;
  482.     }
  483.     return mouse_report;
  484. }
  486. // clang-format off
  487. const pointing_device_driver_t cirque_pinnacle_pointing_device_driver = {
  488.     .init       = cirque_pinnacle_init,
  489.     .get_report = cirque_pinnacle_get_report,
  490.     .set_cpi    = cirque_pinnacle_set_scale,
  491.     .get_cpi    = cirque_pinnacle_get_scale
  492. };
  493. // clang-format on
  494. #endif