1 files changed, 398 insertions, 0 deletions
diff --git a/keyboards/converter/palm_usb/matrix.c b/keyboards/converter/palm_usb/matrix.c
new file mode 100644
index 0000000000..49212f2ef1
--- /dev/null
+++ b/keyboards/converter/palm_usb/matrix.c
@@ -0,0 +1,398 @@
+/*
+Copyright 2018 milestogo 
+with elements Copyright 2014 cy384 under a modified BSD license
+building on qmk structure Copyright 2012 Jun Wako <wakojun@gmail.com>
+
+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 QMK_KEYBOARD_H
+#include "protocol/serial.h"
+#include "timer.h"
+#include "pincontrol.h"
+
+
+/*
+ * Matrix Array usage:
+ *
+ * ROW: 12(4bits)
+ * COL:  8(3bits)
+ *
+ *   +---------+
+ *  0|00 ... 07|
+ *  1|00 ... 07|
+ *  :|   ...   |
+ *  :|   ...   |
+ *  A|         |
+ *  B|         |
+ *   +---------+
+ */
+static uint8_t matrix[MATRIX_ROWS];
+
+
+// we're going to need a sleep timer
+static uint16_t last_activity ;
+// and a byte to track duplicate up events signalling all keys up. 
+static uint16_t last_upKey ;
+// serial device can disconnect. Check every MAXDROP characters. 
+static uint16_t disconnect_counter = 0;
+
+
+// bitmath masks. 
+#define KEY_MASK 0b10000000
+#define COL_MASK 0b00000111
+#define ROW_MASK 0b01111000
+
+
+#define ROW(code)    (( code & ROW_MASK ) >>3)
+#define COL(code)    ((code & COL_MASK) )
+#define KEYUP(code) ((code & KEY_MASK) >>7 )
+
+static bool is_modified = false;
+
+__attribute__ ((weak))
+void matrix_init_kb(void) {
+    matrix_init_user();
+}
+
+__attribute__ ((weak))
+void matrix_scan_kb(void) {
+    matrix_scan_user();
+}
+
+__attribute__ ((weak))
+void matrix_init_user(void) {
+}
+
+__attribute__ ((weak))
+void matrix_scan_user(void) {
+}
+
+inline
+uint8_t matrix_rows(void)
+{
+    return MATRIX_ROWS;
+}
+
+inline
+uint8_t matrix_cols(void)
+{
+    return MATRIX_COLS;
+}
+
+
+void pins_init(void) {
+ // set pins for pullups, Rts , power &etc. 
+
+    //print ("pins setup\n");
+    pinMode(VCC_PIN, PinDirectionOutput);
+    digitalWrite(VCC_PIN, PinLevelLow);
+
+#if ( HANDSPRING == 0)
+
+#ifdef CY835
+    pinMode(GND_PIN, PinDirectionOutput);
+    digitalWrite(GND_PIN, PinLevelLow);
+
+    pinMode(PULLDOWN_PIN, PinDirectionOutput);
+    digitalWrite(PULLDOWN_PIN, PinLevelLow);
+#endif
+
+    pinMode(DCD_PIN, PinDirectionInput);
+    pinMode(RTS_PIN, PinDirectionInput); 
+#endif
+
+/* check that the other side isn't powered up. 
+    test=digitalRead(DCD_PIN);
+    xprintf("b%02X:", test);
+    test=digitalRead(RTS_PIN);
+    xprintf("%02X\n", test);
+*/
+ 
+}
+
+uint8_t rts_reset(void) {
+    static uint8_t firstread ;
+/* bounce RTS so device knows it is rebooted */
+
+// On boot, we keep rts as input, then switch roles here
+// on leaving sleep, we toggle the same way
+
+    firstread=digitalRead(RTS_PIN);
+   // printf("r%02X:", firstread);
+
+    pinMode(RTS_PIN, PinDirectionOutput);
+
+    if (firstread == PinLevelHigh) {
+        digitalWrite(RTS_PIN, PinLevelLow);
+    } 
+     _delay_ms(10);
+    digitalWrite(RTS_PIN, PinLevelHigh);  
+    
+
+/* the future is Arm 
+    if (palReadPad(RTS_PIN_IOPRT) == PinLevelLow)
+  {
+    _delay_ms(10);
+    palSetPadMode(RTS_PINn_IOPORT, PinDirectionOutput_PUSHPULL);
+    palSetPad(RTS_PORT, RTS_PIN);
+  }
+  else
+  {
+    palSetPadMode(RTS_PIN_RTS_PORT, PinDirectionOutput_PUSHPULL);
+    palSetPad(RTS_PORT, RTS_PIN);
+    palClearPad(RTS_PORT, RTS_PIN);
+    _delay_ms(10);
+    palSetPad(RTS_PORT, RTS_PIN);
+  }
+*/
+
+
+ _delay_ms(5);  
+ //print("rts\n");
+ return 1;
+}
+
+uint8_t get_serial_byte(void) {
+    static uint8_t code;
+    while(1) {
+        code = serial_recv();
+        if (code) { 
+            debug_hex(code); debug(" ");
+            return code;
+        }
+    }
+}
+
+uint8_t palm_handshake(void) {
+    // assumes something has seen DCD go high, we've toggled RTS 
+    // and we now need to verify handshake. 
+    // listen for up to 4 packets before giving up. 
+    // usually I get the sequence FF FA FD
+    static uint8_t codeA=0;
+ 
+    for (uint8_t i=0; i < 5; i++) {
+        codeA=get_serial_byte();
+        if ( 0xFA == codeA) {
+            if( 0xFD == get_serial_byte()) {
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+uint8_t palm_reset(void) {
+    print("@");
+    rts_reset();  // shouldn't need to power cycle. 
+
+    if ( palm_handshake() ) {
+        last_activity = timer_read();
+        return 1;
+    } else { 
+        print("failed reset");
+        return 0;
+    }
+
+}
+
+uint8_t handspring_handshake(void) {
+    // should be sent 15 ms after power up. 
+    // listen for up to 4 packets before giving up. 
+    static uint8_t codeA=0;
+ 
+    for (uint8_t i=0; i < 5; i++) {
+        codeA=get_serial_byte();
+        if ( 0xF9 == codeA) {
+            if( 0xFB == get_serial_byte()) {
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+uint8_t handspring_reset(void) {
+    digitalWrite(VCC_PIN, PinLevelLow);
+    _delay_ms(5);
+    digitalWrite(VCC_PIN, PinLevelHigh);
+
+    if ( handspring_handshake() ) {
+        last_activity = timer_read();
+        disconnect_counter=0;
+        return 1;
+    } else { 
+        print("-HSreset");
+        return 0;   
+    }
+}
+
+void matrix_init(void)
+{
+    debug_enable = true;
+    //debug_matrix =true;
+    
+    serial_init(); // arguments all #defined 
+ 
+#if (HANDSPRING == 0)
+    pins_init(); // set all inputs and outputs. 
+#endif
+
+    print("power up\n");
+    digitalWrite(VCC_PIN, PinLevelHigh);
+
+    // wait for DCD strobe from keyboard - it will do this 
+    // up to 3 times, then the board needs the RTS toggled to try again
+  
+#if ( HANDSPRING == 1)
+    if ( handspring_handshake() ) {
+        last_activity = timer_read();
+    } else { 
+        print("failed handshake");
+        _delay_ms(1000);
+        //BUG /should/ power cycle or toggle RTS & reset, but this usually works. 
+    }
+
+#else  /// Palm / HP  device with DCD
+    while( digitalRead(DCD_PIN) != PinLevelHigh ) {;} 
+    print("dcd\n");
+
+    rts_reset(); // at this point the keyboard should think all is well. 
+
+    if ( palm_handshake() ) {
+        last_activity = timer_read();
+    } else { 
+        print("failed handshake");
+        _delay_ms(1000);
+        //BUG /should/ power cycle or toggle RTS & reset, but this usually works. 
+    }
+
+#endif
+
+    // initialize matrix state: all keys off
+    for (uint8_t i=0; i < MATRIX_ROWS; i++) matrix[i] = 0x00;
+
+    matrix_init_quantum();
+    return;
+    
+    
+}
+
+
+uint8_t matrix_scan(void)
+{
+    uint8_t code;
+    code = serial_recv();
+    if (!code) {
+/*         
+        disconnect_counter ++;
+        if (disconnect_counter > MAXDROP) {
+            //  set all keys off
+             for (uint8_t i=0; i < MATRIX_ROWS; i++) matrix[i] = 0x00; 
+        }
+*/
+        // check if the keyboard is asleep. 
+        if (timer_elapsed(last_activity) > SLEEP_TIMEOUT) {
+#if(HANDSPRING ==0 )
+            palm_reset();
+#else
+            handspring_reset();
+#endif
+            return 0;
+        } 
+
+    }
+
+   last_activity = timer_read();
+   disconnect_counter=0; // if we are getting serial data, we're connected. 
+
+    debug_hex(code); debug(" ");
+
+
+    switch (code) {
+        case 0xFD:  // unexpected reset byte 2
+             print("rstD ");
+            return 0;
+        case 0xFA:  // unexpected reset
+            print("rstA ");
+            return 0;
+    }
+
+    if (KEYUP(code)) {
+        if (code == last_upKey) {
+            // all keys are not pressed. 
+            // Manual says to disable all modifiers left open now. 
+            // but that could defeat sticky keys. 
+            // BUG? dropping this byte. 
+            last_upKey=0;
+            return 0;
+        }
+        // release
+        if (matrix_is_on(ROW(code), COL(code))) {
+            matrix[ROW(code)] &= ~(1<<COL(code));
+            last_upKey=code;
+        }
+    } else {
+       // press
+        if (!matrix_is_on(ROW(code), COL(code))) {
+            matrix[ROW(code)] |= (1<<COL(code));
+
+        }
+    }
+
+    matrix_scan_quantum();
+    return code;
+}
+
+bool matrix_is_modified(void)
+{
+    return is_modified;
+}
+
+inline
+bool matrix_has_ghost(void)
+{
+    return false;
+}
+
+inline
+bool matrix_is_on(uint8_t row, uint8_t col)
+{
+    return (matrix[row] & (1<<col));
+}
+
+inline
+uint8_t matrix_get_row(uint8_t row)
+{
+    return matrix[row];
+}
+
+void matrix_print(void)
+{
+    print("\nr/c 01234567\n");
+    for (uint8_t row = 0; row < matrix_rows(); row++) {
+        phex(row); print(": ");
+        pbin_reverse(matrix_get_row(row));
+        print("\n");
+    }
+}
+
+uint8_t matrix_key_count(void)
+{
+    uint8_t count = 0;
+    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+        count += bitpop(matrix[i]);
+    }
+    return count;
+}