keychron_qmk_firmware/drivers/sensors/adns5050.c

/* Copyright 2021 Colin Lam (Ploopy Corporation)
 * Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
 * Copyright 2019 Sunjun Kim
 * Copyright 2019 Hiroyuki Okada
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


#include "adns5050.h"
#include "wait.h"
#include "debug.h"
#include "print.h"
#include "gpio.h"

#ifndef OPTIC_ROTATED
#    define OPTIC_ROTATED false
#endif

// Definitions for the ADNS serial line.
#ifndef ADNS_SCLK_PIN
#    define ADNS_SCLK_PIN B7
#endif

#ifndef ADNS_SDIO_PIN
#    define ADNS_SDIO_PIN C6
#endif

#ifndef ADNS_CS_PIN
#    define ADNS_CS_PIN B4
#endif

#ifdef CONSOLE_ENABLE
void print_byte(uint8_t byte) { dprintf("%c%c%c%c%c%c%c%c|", (byte & 0x80 ? '1' : '0'), (byte & 0x40 ? '1' : '0'), (byte & 0x20 ? '1' : '0'), (byte & 0x10 ? '1' : '0'), (byte & 0x08 ? '1' : '0'), (byte & 0x04 ? '1' : '0'), (byte & 0x02 ? '1' : '0'), (byte & 0x01 ? '1' : '0')); }
#endif

// Initialize the ADNS serial pins.
void adns_init(void) {
    setPinOutput(ADNS_SCLK_PIN);
    setPinOutput(ADNS_SDIO_PIN);
    setPinOutput(ADNS_CS_PIN);
}

// Perform a synchronization with the ADNS.
// Just as with the serial protocol, this is used by the slave to send a
// synchronization signal to the master.
void adns_sync(void) {
    writePinLow(ADNS_CS_PIN);
    wait_us(1);
    writePinHigh(ADNS_CS_PIN);
}

void adns_cs_select(void) {
    writePinLow(ADNS_CS_PIN);
}

void adns_cs_deselect(void) {
    writePinHigh(ADNS_CS_PIN);
}

uint8_t adns_serial_read(void) {
    setPinInput(ADNS_SDIO_PIN);
    uint8_t byte = 0;

    for (uint8_t i = 0; i < 8; ++i) {
        writePinLow(ADNS_SCLK_PIN);
        wait_us(1);

        byte = (byte << 1) | readPin(ADNS_SDIO_PIN);

        writePinHigh(ADNS_SCLK_PIN);
        wait_us(1);
    }

    return byte;
}

void adns_serial_write(uint8_t data) {
    setPinOutput(ADNS_SDIO_PIN);

    for (int8_t b = 7; b >= 0; b--) {
        writePinLow(ADNS_SCLK_PIN);

        if (data & (1 << b))
            writePinHigh(ADNS_SDIO_PIN);
        else
            writePinLow(ADNS_SDIO_PIN);

        wait_us(2);

        writePinHigh(ADNS_SCLK_PIN);
    }

    // tSWR. See page 15 of the ADNS spec sheet.
    // Technically, this is only necessary if the next operation is an SDIO
    // read. This is not guaranteed to be the case, but we're being lazy.
    wait_us(4);

    // Note that tSWW is never necessary. All write operations require at
    // least 32us, which exceeds tSWW, so there's never a need to wait for it.
}

// Read a byte of data from a register on the ADNS.
// Don't forget to use the register map (as defined in the header file).
uint8_t adns_read_reg(uint8_t reg_addr) {
    adns_cs_select();

    adns_serial_write(reg_addr);

    // We don't need a minimum tSRAD here. That's because a 4ms wait time is
    // already included in adns_serial_write(), so we're good.
    // See page 10 and 15 of the ADNS spec sheet.
    //wait_us(4);

    uint8_t byte = adns_serial_read();

    // tSRW & tSRR. See page 15 of the ADNS spec sheet.
    // Technically, this is only necessary if the next operation is an SDIO
    // read or write. This is not guaranteed to be the case.
    // Honestly, this wait could probably be removed.
    wait_us(1);

    adns_cs_deselect();

    return byte;
}

void adns_write_reg(uint8_t reg_addr, uint8_t data) {
    adns_cs_select();
    adns_serial_write( 0b10000000 | reg_addr );
    adns_serial_write(data);
    adns_cs_deselect();
}

report_adns_t adns_read_burst(void) {
    adns_cs_select();

    report_adns_t data;
    data.dx = 0;
    data.dy = 0;

    adns_serial_write(REG_MOTION_BURST);

    // We don't need a minimum tSRAD here. That's because a 4ms wait time is
    // already included in adns_serial_write(), so we're good.
    // See page 10 and 15 of the ADNS spec sheet.
    //wait_us(4);

    uint8_t x = adns_serial_read();
    uint8_t y = adns_serial_read();

    // Burst mode returns a bunch of other shit that we don't really need.
    // Setting CS to high ends burst mode early.
    adns_cs_deselect();

    data.dx = convert_twoscomp(x);
    data.dy = convert_twoscomp(y);

    return data;
}

// Convert a two's complement byte from an unsigned data type into a signed
// data type.
int8_t convert_twoscomp(uint8_t data) {
    if ((data & 0x80) == 0x80)
        return -128 + (data & 0x7F);
    else
        return data;
}

// Don't forget to use the definitions for CPI in the header file.
void adns_set_cpi(uint8_t cpi) {
    adns_write_reg(REG_MOUSE_CONTROL2, cpi);
}

bool adns_check_signature(void) {
    uint8_t pid = adns_read_reg(REG_PRODUCT_ID);
    uint8_t rid = adns_read_reg(REG_REVISION_ID);
    uint8_t pid2 = adns_read_reg(REG_PRODUCT_ID2);

    return (pid == 0x12 && rid == 0x01 && pid2 == 0x26);
}