forked from mfulz_github/qmk_firmware
fced377ac0
* Branch point for 2020 May 30 Breaking Change * Migrate `ACTION_LAYER_TOGGLE` to `TG()` (#8954) * Migrate `ACTION_MODS_ONESHOT` to `OSM()` (#8957) * Migrate `ACTION_DEFAULT_LAYER_SET` to `DF()` (#8958) * Migrate `ACTION_LAYER_MODS` to `LM()` (#8959) * Migrate `ACTION_MODS_TAP_KEY` to `MT()` (#8968) * Convert V-USB usbdrv to a submodule (#8321) * Unify Tap Hold functions and documentation (#8348) * Changing board names to prevent confusion (#8412) * Move the Keyboardio Model01 to a keyboardio/ subdir (#8499) * Move spaceman keyboards (#8830) * Migrate miscellaneous `fn_actions` entries (#8977) * Migrate `ACTION_MODS_KEY` to chained mod keycodes (#8979) * Organizing my keyboards (plaid, tartan, ergoinu) (#8537) * Refactor Lily58 to use split_common (#6260) * Refactor zinc to use split_common (#7114) * Add a message if bin/qmk doesn't work (#9000) * Fix conflicting types for 'tfp_printf' (#8269) * Fixed RGB_DISABLE_AFTER_TIMEOUT to be seconds based & small internals cleanup (#6480) * Refactor and updates to TKC1800 code (#8472) * Switch to qmk forks for everything (#9019) * audio refactor: replace deprecated PLAY_NOTE_ARRAY (#8484) * Audio enable corrections (2/3) (#8903) * Split HHKB to ANSI and JP layouts and Add VIA support for each (#8582) * Audio enable corrections (Part 4) (#8974) * Fix typo from PR7114 (#9171) * Augment future branch Changelogs (#8978) * Revert "Branch point for 2020 May 30 Breaking Change"
413 lines
9.8 KiB
C
413 lines
9.8 KiB
C
/*
|
|
Copyright 2011 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 <stdint.h>
|
|
#include <avr/interrupt.h>
|
|
#include <avr/io.h>
|
|
//#include <avr/wdt.h>
|
|
#include "wd.h" // in order to use watchdog in interrupt mode
|
|
#include <avr/sleep.h>
|
|
#include <util/delay.h>
|
|
#include <avr/power.h>
|
|
#include "keyboard.h"
|
|
#include "matrix.h"
|
|
#include "host.h"
|
|
#include "action.h"
|
|
#include "iwrap.h"
|
|
#ifdef PROTOCOL_VUSB
|
|
# include "vusb.h"
|
|
# include <usbdrv/usbdrv.h>
|
|
#endif
|
|
#include "uart.h"
|
|
#include "suart.h"
|
|
#include "timer.h"
|
|
#include "debug.h"
|
|
#include "keycode.h"
|
|
#include "command.h"
|
|
|
|
static void sleep(uint8_t term);
|
|
static bool console(void);
|
|
static bool console_command(uint8_t c);
|
|
static uint8_t key2asc(uint8_t key);
|
|
|
|
/*
|
|
static void set_prr(void)
|
|
{
|
|
power_adc_disable();
|
|
power_spi_disable();
|
|
power_twi_disable();
|
|
#ifndef TIMER_H
|
|
//power_timer0_disable(); // used in timer.c
|
|
#endif
|
|
power_timer1_disable();
|
|
power_timer2_disable();
|
|
}
|
|
*/
|
|
|
|
/*
|
|
static void pullup_pins(void)
|
|
{
|
|
// DDRs are set to 0(input) by default.
|
|
#ifdef PORTA
|
|
PORTA = 0xFF;
|
|
#endif
|
|
PORTB = 0xFF;
|
|
PORTC = 0xFF;
|
|
PORTD = 0xFF;
|
|
#ifdef PORTE
|
|
PORTE = 0xFF;
|
|
#endif
|
|
#ifdef PORTE
|
|
PORTF = 0xFF;
|
|
#endif
|
|
}
|
|
*/
|
|
|
|
#ifdef PROTOCOL_VUSB
|
|
static void disable_vusb(void) {
|
|
// disable interrupt & disconnect to prevent host from enumerating
|
|
USB_INTR_ENABLE &= ~(1 << USB_INTR_ENABLE_BIT);
|
|
usbDeviceDisconnect();
|
|
}
|
|
|
|
static void enable_vusb(void) {
|
|
USB_INTR_ENABLE |= (1 << USB_INTR_ENABLE_BIT);
|
|
usbDeviceConnect();
|
|
}
|
|
|
|
static void init_vusb(void) {
|
|
uint8_t i = 0;
|
|
|
|
usbInit();
|
|
disable_vusb();
|
|
/* fake USB disconnect for > 250 ms */
|
|
while (--i) {
|
|
_delay_ms(1);
|
|
}
|
|
enable_vusb();
|
|
}
|
|
#endif
|
|
|
|
void change_driver(host_driver_t *driver) {
|
|
/*
|
|
host_clear_keyboard_report();
|
|
host_swap_keyboard_report();
|
|
host_clear_keyboard_report();
|
|
host_send_keyboard_report();
|
|
*/
|
|
clear_keyboard();
|
|
_delay_ms(1000);
|
|
host_set_driver(driver);
|
|
}
|
|
|
|
static bool sleeping = false;
|
|
static bool insomniac = false; // TODO: should be false for power saving
|
|
static uint16_t last_timer = 0;
|
|
|
|
int main(void) {
|
|
MCUSR = 0;
|
|
clock_prescale_set(clock_div_1);
|
|
WD_SET(WD_OFF);
|
|
|
|
// power saving: the result is worse than nothing... why?
|
|
// pullup_pins();
|
|
// set_prr();
|
|
|
|
#ifdef PROTOCOL_VUSB
|
|
disable_vusb();
|
|
#endif
|
|
uart_init(115200);
|
|
keyboard_init();
|
|
print("\nSend BREAK for UART Console Commands.\n");
|
|
|
|
// TODO: move to iWRAP/suart file
|
|
print("suart init\n");
|
|
// suart init
|
|
// PC4: Tx Output IDLE(Hi)
|
|
PORTC |= (1 << 4);
|
|
DDRC |= (1 << 4);
|
|
// PC5: Rx Input(pull-up)
|
|
PORTC |= (1 << 5);
|
|
DDRC &= ~(1 << 5);
|
|
// suart receive interrut(PC5/PCINT13)
|
|
PCMSK1 = 0b00100000;
|
|
PCICR = 0b00000010;
|
|
|
|
host_set_driver(iwrap_driver());
|
|
|
|
print("iwrap_init()\n");
|
|
iwrap_init();
|
|
iwrap_call();
|
|
|
|
last_timer = timer_read();
|
|
while (true) {
|
|
#ifdef PROTOCOL_VUSB
|
|
if (host_get_driver() == vusb_driver()) usbPoll();
|
|
#endif
|
|
keyboard_task();
|
|
#ifdef PROTOCOL_VUSB
|
|
if (host_get_driver() == vusb_driver()) vusb_transfer_keyboard();
|
|
#endif
|
|
// TODO: depricated
|
|
if (matrix_is_modified() || console()) {
|
|
last_timer = timer_read();
|
|
sleeping = false;
|
|
} else if (!sleeping && timer_elapsed(last_timer) > 4000) {
|
|
sleeping = true;
|
|
iwrap_check_connection();
|
|
}
|
|
|
|
// TODO: suspend.h
|
|
if (host_get_driver() == iwrap_driver()) {
|
|
if (sleeping && !insomniac) {
|
|
_delay_ms(1); // wait for UART to send
|
|
iwrap_sleep();
|
|
sleep(WDTO_60MS);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void sleep(uint8_t term) {
|
|
WD_SET(WD_IRQ, term);
|
|
|
|
cli();
|
|
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
|
|
sleep_enable();
|
|
sleep_bod_disable();
|
|
sei();
|
|
sleep_cpu();
|
|
sleep_disable();
|
|
|
|
WD_SET(WD_OFF);
|
|
}
|
|
|
|
static bool console(void) {
|
|
// Send to Bluetoot module WT12
|
|
static bool breaked = false;
|
|
if (!uart_available())
|
|
return false;
|
|
else {
|
|
uint8_t c;
|
|
c = uart_getchar();
|
|
uart_putchar(c);
|
|
switch (c) {
|
|
case 0x00: // BREAK signal
|
|
if (!breaked) {
|
|
print("break(? for help): ");
|
|
breaked = true;
|
|
}
|
|
break;
|
|
case '\r':
|
|
uart_putchar('\n');
|
|
iwrap_buf_send();
|
|
break;
|
|
case '\b':
|
|
iwrap_buf_del();
|
|
break;
|
|
default:
|
|
if (breaked) {
|
|
print("\n");
|
|
console_command(c);
|
|
breaked = false;
|
|
} else {
|
|
iwrap_buf_add(c);
|
|
}
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool command_extra(uint8_t code) { return console_command(key2asc(code)); }
|
|
|
|
static bool console_command(uint8_t c) {
|
|
switch (c) {
|
|
case 'h':
|
|
case '?':
|
|
print("\nCommands for Bluetooth(WT12/iWRAP):\n");
|
|
print("r: reset. software reset by watchdog\n");
|
|
print("i: insomniac. prevent KB from sleeping\n");
|
|
print("c: iwrap_call. CALL for BT connection.\n");
|
|
#ifdef PROTOCOL_VUSB
|
|
print("u: USB mode. switch to USB.\n");
|
|
print("w: BT mode. switch to Bluetooth.\n");
|
|
#endif
|
|
print("k: kill first connection.\n");
|
|
print("Del: unpair first pairing.\n");
|
|
print("\n");
|
|
return 0;
|
|
case 'r':
|
|
print("reset\n");
|
|
WD_AVR_RESET();
|
|
return 1;
|
|
case 'i':
|
|
insomniac = !insomniac;
|
|
if (insomniac)
|
|
print("insomniac\n");
|
|
else
|
|
print("not insomniac\n");
|
|
return 1;
|
|
case 'c':
|
|
print("iwrap_call()\n");
|
|
iwrap_call();
|
|
return 1;
|
|
#ifdef PROTOCOL_VUSB
|
|
case 'u':
|
|
print("USB mode\n");
|
|
init_vusb();
|
|
change_driver(vusb_driver());
|
|
// iwrap_kill();
|
|
// iwrap_sleep();
|
|
// disable suart receive interrut(PC5/PCINT13)
|
|
PCMSK1 &= ~(0b00100000);
|
|
PCICR &= ~(0b00000010);
|
|
return 1;
|
|
case 'w':
|
|
print("iWRAP mode\n");
|
|
change_driver(iwrap_driver());
|
|
disable_vusb();
|
|
// enable suart receive interrut(PC5/PCINT13)
|
|
PCMSK1 |= 0b00100000;
|
|
PCICR |= 0b00000010;
|
|
return 1;
|
|
#endif
|
|
case 'k':
|
|
print("kill\n");
|
|
iwrap_kill();
|
|
return 1;
|
|
case 0x7F: // DELETE
|
|
print("unpair\n");
|
|
iwrap_unpair();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// convert keycode into ascii charactor
|
|
static uint8_t key2asc(uint8_t key) {
|
|
switch (key) {
|
|
case KC_A:
|
|
return 'a';
|
|
case KC_B:
|
|
return 'b';
|
|
case KC_C:
|
|
return 'c';
|
|
case KC_D:
|
|
return 'd';
|
|
case KC_E:
|
|
return 'e';
|
|
case KC_F:
|
|
return 'f';
|
|
case KC_G:
|
|
return 'g';
|
|
case KC_H:
|
|
return 'h';
|
|
case KC_I:
|
|
return 'i';
|
|
case KC_J:
|
|
return 'j';
|
|
case KC_K:
|
|
return 'k';
|
|
case KC_L:
|
|
return 'l';
|
|
case KC_M:
|
|
return 'm';
|
|
case KC_N:
|
|
return 'n';
|
|
case KC_O:
|
|
return 'o';
|
|
case KC_P:
|
|
return 'p';
|
|
case KC_Q:
|
|
return 'q';
|
|
case KC_R:
|
|
return 'r';
|
|
case KC_S:
|
|
return 's';
|
|
case KC_T:
|
|
return 't';
|
|
case KC_U:
|
|
return 'u';
|
|
case KC_V:
|
|
return 'v';
|
|
case KC_W:
|
|
return 'w';
|
|
case KC_X:
|
|
return 'x';
|
|
case KC_Y:
|
|
return 'y';
|
|
case KC_Z:
|
|
return 'z';
|
|
case KC_1:
|
|
return '1';
|
|
case KC_2:
|
|
return '2';
|
|
case KC_3:
|
|
return '3';
|
|
case KC_4:
|
|
return '4';
|
|
case KC_5:
|
|
return '5';
|
|
case KC_6:
|
|
return '6';
|
|
case KC_7:
|
|
return '7';
|
|
case KC_8:
|
|
return '8';
|
|
case KC_9:
|
|
return '9';
|
|
case KC_0:
|
|
return '0';
|
|
case KC_ENTER:
|
|
return '\n';
|
|
case KC_ESCAPE:
|
|
return 0x1B;
|
|
case KC_BSPACE:
|
|
return '\b';
|
|
case KC_TAB:
|
|
return '\t';
|
|
case KC_SPACE:
|
|
return ' ';
|
|
case KC_MINUS:
|
|
return '-';
|
|
case KC_EQUAL:
|
|
return '=';
|
|
case KC_LBRACKET:
|
|
return '[';
|
|
case KC_RBRACKET:
|
|
return ']';
|
|
case KC_BSLASH:
|
|
return '\\';
|
|
case KC_NONUS_HASH:
|
|
return '#';
|
|
case KC_SCOLON:
|
|
return ';';
|
|
case KC_QUOTE:
|
|
return '\'';
|
|
case KC_GRAVE:
|
|
return '`';
|
|
case KC_COMMA:
|
|
return ',';
|
|
case KC_DOT:
|
|
return '.';
|
|
case KC_SLASH:
|
|
return '/';
|
|
default:
|
|
return 0x00;
|
|
}
|
|
}
|