From 73b8f85816c3209f6213e358a0d3737c7a73d45f Mon Sep 17 00:00:00 2001 From: Dimitris Papavasiliou Date: Fri, 5 Mar 2021 20:25:20 +0200 Subject: [Keyboard] Lagrange handwired keyboard (#11374) * [Keyboard] Add the Lagrange keyboard * Covert the master side to use the SPI driver. --- keyboards/handwired/lagrange/transport.c | 175 +++++++++++++++++++++++++++++++ 1 file changed, 175 insertions(+) create mode 100644 keyboards/handwired/lagrange/transport.c (limited to 'keyboards/handwired/lagrange/transport.c') diff --git a/keyboards/handwired/lagrange/transport.c b/keyboards/handwired/lagrange/transport.c new file mode 100644 index 0000000000..2a567f24b9 --- /dev/null +++ b/keyboards/handwired/lagrange/transport.c @@ -0,0 +1,175 @@ +/* Copyright 2020 Dimitris Papavasiliou + * + * 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 3 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 . + */ + +#include + +#include "quantum.h" +#include "split_util.h" +#include "timer.h" + +#include "lagrange.h" + +struct led_context { + led_t led_state; + layer_state_t layer_state; +}; + +uint8_t transceive(uint8_t b) { + for (SPDR = b ; !(SPSR & _BV(SPIF)) ; ); + return SPDR; +} + +/* The SPI bus, doens't have any form of protocol built in, so when + * the other side isn't present, any old noise on the line will appear + * as matrix data. To avoid interpreting data as keystrokes, we do a + * simple n-way (8-way here) handshake before each scan, where each + * side sends a prearranged sequence of bytes. */ + +void shake_hands(bool master) { + const uint8_t m = master ? 0xf8 : 0; + const uint8_t a = 0xa8 ^ m, b = 0x50 ^ m; + + uint8_t i; + + i = SPSR; + i = SPDR; + + do { + /* Cylcling the SS pin on each attempt is necessary, as it + * resets the AVR's SPI core and guarantees proper + * alignment. */ + + if (master) { + writePinLow(SPI_SS_PIN); + } + + for (i = 0 ; i < 8 ; i += 1) { + if (transceive(a + i) != b + i) { + break; + } + } + + if (master) { + writePinHigh(SPI_SS_PIN); + } + } while (i < 8); +} + +bool transport_master(matrix_row_t matrix[]) { + const struct led_context context = { + host_keyboard_led_state(), + layer_state + }; + + uint8_t i; + + /* Shake hands and then receive the matrix from the other side, + * while transmitting LED and layer states. */ + + shake_hands(true); + + spi_start(SPI_SS_PIN, 0, 0, 4); + + for (i = 0 ; i < sizeof(matrix_row_t[MATRIX_ROWS / 2]) ; i += 1) { + spi_status_t x; + + x = spi_write(i < sizeof(struct led_context) ? + ((uint8_t *)&context)[i] : 0); + + if (x == SPI_STATUS_TIMEOUT) { + return false; + } + + ((uint8_t *)matrix)[i] = (uint8_t)x; + } + + spi_stop(); + + return true; +} + +void transport_slave(matrix_row_t matrix[]) { + static struct led_context context; + struct led_context new_context; + + uint8_t i; + + /* Do the reverse of master above. Note that timing is critical, + * so interrupts must be turned off. */ + + cli(); + shake_hands(false); + + for (i = 0 ; i < sizeof(matrix_row_t[MATRIX_ROWS / 2]) ; i += 1) { + uint8_t b; + + b = transceive(((uint8_t *)matrix)[i]); + + if (i < sizeof(struct led_context)) { + ((uint8_t *)&new_context)[i] = b; + } + } + + sei(); + + /* Update the layer and LED state if necessary. */ + + if (!isLeftHand) { + if (context.led_state.raw != new_context.led_state.raw) { + context.led_state.raw = new_context.led_state.raw; + led_update_kb(context.led_state); + } + + if (context.layer_state != new_context.layer_state) { + context.layer_state = new_context.layer_state; + layer_state_set_kb(context.layer_state); + } + } +} + +void transport_master_init(void) { + /* We need to set the SS pin as output as the handshake logic + * above depends on it and the SPI master driver won't do it + * before we call spi_start(). */ + + writePinHigh(SPI_SS_PIN); + setPinOutput(SPI_SS_PIN); + + spi_init(); + + shake_hands(true); +} + +void transport_slave_init(void) { + /* The datasheet isn't very clear on whether the internal pull-up + * is selectable when the SS pin is used by the SPI slave, but + * experimentations shows that it is, at least on the ATMega32u4. + * We enable the pull-up to guard against the case where both + * halves end up as slaves. In that case the SS pin would + * otherwise be floating and free to fluctuate due to picked up + * noise, etc. When reading low it would make both halves think + * they're asserted making the MISO pin an output on both ends and + * leading to potential shorts. */ + + setPinInputHigh(SPI_SS_PIN); + setPinInput(SPI_SCK_PIN); + setPinInput(SPI_MOSI_PIN); + setPinOutput(SPI_MISO_PIN); + + SPCR = _BV(SPE); + + shake_hands(false); +} -- cgit v1.2.3