int main(void)
{
// set for 16 MHz clock
CPU_PRESCALE(0);
// Initialize the USB, and then wait for the host to set configuration.
// If the Teensy is powered without a PC connected to the USB port,
// this will wait forever.
usb_init();
while (!usb_configured()) /* wait */ ;
keyboard_init();
host_set_driver(pjrc_driver());
#ifdef SLEEP_LED_ENABLE
sleep_led_init();
#endif
while (1) {
while (suspend) {
suspend_power_down();
if (remote_wakeup && suspend_wakeup_condition()) {
usb_remote_wakeup();
}
}
keyboard_task();
}
}
void do_magic_suspend_2(void)
{
int is_problem;
read_swapfiles();
is_problem = suspend_prepare_image();
spin_unlock_irq(&suspend_pagedir_lock);
if (!is_problem) {
kernel_fpu_end(); /* save_processor_state() does kernel_fpu_begin, and we need to revert it in order to pass in_atomic() checks */
BUG_ON(in_atomic());
suspend_save_image();
suspend_power_down(); /* FIXME: if suspend_power_down is commented out, console is lost after few suspends ?! */
}
printk(KERN_EMERG "%sSuspend failed, trying to recover...\n", name_suspend);
MDELAY(1000); /* So user can wait and report us messages if armageddon comes :-) */
barrier();
mb();
spin_lock_irq(&suspend_pagedir_lock); /* Done to disable interrupts */
mdelay(1000);
free_pages((unsigned long) pagedir_nosave, pagedir_order);
spin_unlock_irq(&suspend_pagedir_lock);
mark_swapfiles(((swp_entry_t) {0}), MARK_SWAP_RESUME);
}
int main(void)
{
setup_mcu();
keyboard_setup();
setup_usb();
sei();
/* init modules */
serial_init();
keyboard_init();
host_set_driver(&lufa_driver);
#ifdef SLEEP_LED_ENABLE
sleep_led_init();
#endif
print("Keyboard start.\n");
while (1) {
while (USB_DeviceState == DEVICE_STATE_Suspended) {
print("[s]");
matrix_power_down();
suspend_power_down();
if (USB_Device_RemoteWakeupEnabled && suspend_wakeup_condition()) {
USB_Device_SendRemoteWakeup();
}
}
keyboard_task();
#if !defined(INTERRUPT_CONTROL_ENDPOINT)
USB_USBTask();
#endif
}
}
void hook_usb_suspend_loop(void) {
/* Do this in the suspended state */
suspend_power_down(); // on AVR this deep sleeps for 15ms
/* Remote wakeup */
if((USB_DRIVER.status & 2) && suspend_wakeup_condition()) {
send_remote_wakeup(&USB_DRIVER);
}
}
void main_subtask_usb_state(void)
{
static uint64_t fsmstate_on_delay = 0; //Delay timer to be sure USB is actually operating before bringing up hardware
uint8_t fsmstate_now = USB->DEVICE.FSMSTATUS.reg; //Current state from hardware register
if (fsmstate_now == USB_FSMSTATUS_FSMSTATE_SUSPEND_Val) //If USB SUSPENDED
{
fsmstate_on_delay = 0; //Clear ON delay timer
if (g_usb_state != USB_FSMSTATUS_FSMSTATE_SUSPEND_Val) //If previously not SUSPENDED
{
suspend_power_down(); //Run suspend routine
g_usb_state = fsmstate_now; //Save current USB state
}
}
else if (fsmstate_now == USB_FSMSTATUS_FSMSTATE_SLEEP_Val) //Else if USB SLEEPING
{
fsmstate_on_delay = 0; //Clear ON delay timer
if (g_usb_state != USB_FSMSTATUS_FSMSTATE_SLEEP_Val) //If previously not SLEEPING
{
suspend_power_down(); //Run suspend routine
g_usb_state = fsmstate_now; //Save current USB state
}
}
else if (fsmstate_now == USB_FSMSTATUS_FSMSTATE_ON_Val) //Else if USB ON
{
if (g_usb_state != USB_FSMSTATUS_FSMSTATE_ON_Val) //If previously not ON
{
if (fsmstate_on_delay == 0) //If ON delay timer is cleared
{
fsmstate_on_delay = timer_read64() + 250; //Set ON delay timer
}
else if (timer_read64() > fsmstate_on_delay) //Else if ON delay timer is active and timed out
{
suspend_wakeup_init(); //Run wakeup routine
g_usb_state = fsmstate_now; //Save current USB state
}
}
}
else //Else if USB is in a state not being tracked
{
fsmstate_on_delay = 0; //Clear ON delay timer
}
}
void hook_usb_suspend_loop(void) {
serial_link_update();
visualizer_update(default_layer_state, layer_state, host_keyboard_leds());
/* Do this in the suspended state */
suspend_power_down(); // on AVR this deep sleeps for 15ms
/* Remote wakeup */
if((USB_DRIVER.status & 2) && suspend_wakeup_condition()) {
send_remote_wakeup(&USB_DRIVER);
}
}
int main(void)
{
// set for 16 MHz clock
CPU_PRESCALE(0);
// Initialize the USB, and then wait for the host to set configuration.
// If the Teensy is powered without a PC connected to the USB port,
// this will wait forever.
usb_init();
while (!usb_configured()) /* wait */ ;
print_set_sendchar(sendchar);
keyboard_init();
host_set_driver(pjrc_driver());
#ifdef SLEEP_LED_ENABLE
sleep_led_init();
#endif
while (1) {
uint32_t mtl_time = timer_read32();
for ( int i = 0; i < 1000; i++ ) {
/*print( "Main loop: i = " );*/
/*phex( (uint8_t) ( i >> 8 ) & 0xff );*/
/*phex( (uint8_t) ( i >> 0 ) & 0xff );*/
/*print( "\n" );*/
while (suspend) {
suspend_power_down();
if (remote_wakeup && suspend_wakeup_condition()) {
usb_remote_wakeup();
}
}
keyboard_task();
}
mtl_time = timer_elapsed32( mtl_time );
// No TP: 247 ms
// TP full: 10820 ms
// No usb report: same as TP full
// print( "Time for 1,000 keyboard_tasks: " );
// phex( (uint8_t) ( mtl_time >> 24 ) & 0xff );
// phex( (uint8_t) ( mtl_time >> 16 ) & 0xff );
// phex( (uint8_t) ( mtl_time >> 8 ) & 0xff );
// phex( (uint8_t) ( mtl_time >> 0 ) & 0xff );
// print( "\n" );
}
}
/* Main thread
*/
int main(void) {
/* ChibiOS/RT init */
halInit();
chSysInit();
// TESTING
// chThdCreateStatic(waBlinkerThread, sizeof(waBlinkerThread), NORMALPRIO, blinkerThread, NULL);
/* Init USB */
init_usb_driver(&USB_DRIVER);
/* init printf */
init_printf(NULL,sendchar_pf);
#ifdef SERIAL_LINK_ENABLE
init_serial_link();
#endif
#ifdef VISUALIZER_ENABLE
visualizer_init();
#endif
host_driver_t* driver = NULL;
/* Wait until the USB or serial link is active */
while (true) {
if(USB_DRIVER.state == USB_ACTIVE) {
driver = &chibios_driver;
break;
}
#ifdef SERIAL_LINK_ENABLE
if(is_serial_link_connected()) {
driver = get_serial_link_driver();
break;
}
serial_link_update();
#endif
chThdSleepMilliseconds(50);
}
/* Do need to wait here!
* Otherwise the next print might start a transfer on console EP
* before the USB is completely ready, which sometimes causes
* HardFaults.
*/
chThdSleepMilliseconds(50);
print("USB configured.\n");
/* init TMK modules */
keyboard_init();
host_set_driver(driver);
#ifdef SLEEP_LED_ENABLE
sleep_led_init();
#endif
print("Keyboard start.\n");
/* Main loop */
while(true) {
if(USB_DRIVER.state == USB_SUSPENDED) {
print("[s]");
#ifdef VISUALIZER_ENABLE
visualizer_suspend();
#endif
while(USB_DRIVER.state == USB_SUSPENDED) {
/* Do this in the suspended state */
#ifdef SERIAL_LINK_ENABLE
serial_link_update();
#endif
suspend_power_down(); // on AVR this deep sleeps for 15ms
/* Remote wakeup */
if((USB_DRIVER.status & 2) && suspend_wakeup_condition()) {
send_remote_wakeup(&USB_DRIVER);
}
}
/* Woken up */
// variables has been already cleared by the wakeup hook
send_keyboard_report();
#ifdef MOUSEKEY_ENABLE
mousekey_send();
#endif /* MOUSEKEY_ENABLE */
#ifdef VISUALIZER_ENABLE
visualizer_resume();
#endif
}
keyboard_task();
}
}
int main(void)
{
SetupHardware();
sei();
/* wait for USB startup to get ready for debug output */
uint8_t timeout = 255; // timeout when USB is not available(Bluetooth)
while (timeout-- && USB_DeviceState != DEVICE_STATE_Configured) {
wait_ms(4);
#if defined(INTERRUPT_CONTROL_ENDPOINT)
;
#else
USB_USBTask();
#endif
}
print("\nUSB init\n");
rn42_init();
rn42_task_init();
print("RN-42 init\n");
/* init modules */
keyboard_init();
if (!rn42_rts()) {
host_set_driver(&rn42_driver);
} else {
host_set_driver(&lufa_driver);
}
#ifdef SLEEP_LED_ENABLE
sleep_led_init();
#endif
print("Keyboard start\n");
while (1) {
while (rn42_rts() && // RN42 is off
USB_DeviceState == DEVICE_STATE_Suspended) {
print("[s]");
matrix_power_down();
suspend_power_down();
suspend_power_down();
suspend_power_down();
suspend_power_down();
suspend_power_down();
suspend_power_down();
suspend_power_down();
if (USB_Device_RemoteWakeupEnabled && suspend_wakeup_condition()) {
USB_Device_SendRemoteWakeup();
}
}
keyboard_task();
#if !defined(INTERRUPT_CONTROL_ENDPOINT)
USB_USBTask();
#endif
rn42_task();
}
}
uint8_t matrix_scan(void)
{
uint8_t *tmp;
tmp = matrix_prev;
matrix_prev = matrix;
matrix = tmp;
// power on
if (!KEY_POWER_STATE()) KEY_POWER_ON();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
for (uint8_t col = 0; col < MATRIX_COLS; col++) {
KEY_SELECT(row, col);
_delay_us(5);
// Not sure this is needed. This just emulates HHKB controller's behaviour.
if (matrix_prev[row] & (1<<col)) {
KEY_PREV_ON();
}
_delay_us(10);
// NOTE: KEY_STATE is valid only in 20us after KEY_ENABLE.
// If V-USB interrupts in this section we could lose 40us or so
// and would read invalid value from KEY_STATE.
uint8_t last = TIMER_RAW;
KEY_ENABLE();
// Wait for KEY_STATE outputs its value.
// 1us was ok on one HHKB, but not worked on another.
// no wait doesn't work on Teensy++ with pro(1us works)
// no wait does work on tmk PCB(8MHz) with pro2
// 1us wait does work on both of above
// 1us wait doesn't work on tmk(16MHz)
// 5us wait does work on tmk(16MHz)
// 5us wait does work on tmk(16MHz/2)
// 5us wait does work on tmk(8MHz)
// 10us wait does work on Teensy++ with pro
// 10us wait does work on 328p+iwrap with pro
// 10us wait doesn't work on tmk PCB(8MHz) with pro2(very lagged scan)
_delay_us(5);
if (KEY_STATE()) {
matrix[row] &= ~(1<<col);
} else {
matrix[row] |= (1<<col);
}
// Ignore if this code region execution time elapses more than 20us.
// MEMO: 20[us] * (TIMER_RAW_FREQ / 1000000)[count per us]
// MEMO: then change above using this rule: a/(b/c) = a*1/(b/c) = a*(c/b)
if (TIMER_DIFF_RAW(TIMER_RAW, last) > 20/(1000000/TIMER_RAW_FREQ)) {
matrix[row] = matrix_prev[row];
}
_delay_us(5);
KEY_PREV_OFF();
KEY_UNABLE();
// NOTE: KEY_STATE keep its state in 20us after KEY_ENABLE.
// This takes 25us or more to make sure KEY_STATE returns to idle state.
#ifdef HHKB_JP
// Looks like JP needs faster scan due to its twice larger matrix
// or it can drop keys in fast key typing
_delay_us(30);
#else
_delay_us(75);
#endif
}
if (matrix[row] ^ matrix_prev[row]) matrix_last_modified = timer_read32();
}
// power off
if (KEY_POWER_STATE() &&
(USB_DeviceState == DEVICE_STATE_Suspended ||
USB_DeviceState == DEVICE_STATE_Unattached ) &&
timer_elapsed32(matrix_last_modified) > MATRIX_POWER_SAVE) {
KEY_POWER_OFF();
suspend_power_down();
}
return 1;
}
/* Main thread
*/
int main(void) {
/* ChibiOS/RT init */
halInit();
chSysInit();
#ifdef STM32_EEPROM_ENABLE
EEPROM_Init();
#endif
// TESTING
// chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
keyboard_setup();
/* Init USB */
init_usb_driver(&USB_DRIVER);
/* init printf */
init_printf(NULL,sendchar_pf);
#ifdef MIDI_ENABLE
setup_midi();
#endif
#ifdef SERIAL_LINK_ENABLE
init_serial_link();
#endif
#ifdef VISUALIZER_ENABLE
visualizer_init();
#endif
host_driver_t* driver = NULL;
/* Wait until the USB or serial link is active */
while (true) {
#if defined(WAIT_FOR_USB) || defined(SERIAL_LINK_ENABLE)
if(USB_DRIVER.state == USB_ACTIVE) {
driver = &chibios_driver;
break;
}
#else
driver = &chibios_driver;
break;
#endif
#ifdef SERIAL_LINK_ENABLE
if(is_serial_link_connected()) {
driver = get_serial_link_driver();
break;
}
serial_link_update();
#endif
wait_ms(50);
}
/* Do need to wait here!
* Otherwise the next print might start a transfer on console EP
* before the USB is completely ready, which sometimes causes
* HardFaults.
*/
wait_ms(50);
print("USB configured.\n");
/* init TMK modules */
keyboard_init();
host_set_driver(driver);
#ifdef SLEEP_LED_ENABLE
sleep_led_init();
#endif
print("Keyboard start.\n");
/* Main loop */
while(true) {
#if !defined(NO_USB_STARTUP_CHECK)
if(USB_DRIVER.state == USB_SUSPENDED) {
print("[s]");
#ifdef VISUALIZER_ENABLE
visualizer_suspend();
#endif
while(USB_DRIVER.state == USB_SUSPENDED) {
/* Do this in the suspended state */
#ifdef SERIAL_LINK_ENABLE
serial_link_update();
#endif
suspend_power_down(); // on AVR this deep sleeps for 15ms
/* Remote wakeup */
if(suspend_wakeup_condition()) {
usbWakeupHost(&USB_DRIVER);
}
}
/* Woken up */
// variables has been already cleared by the wakeup hook
send_keyboard_report();
#ifdef MOUSEKEY_ENABLE
mousekey_send();
#endif /* MOUSEKEY_ENABLE */
#ifdef VISUALIZER_ENABLE
visualizer_resume();
#endif
}
#endif
keyboard_task();
#ifdef CONSOLE_ENABLE
console_task();
#endif
#ifdef VIRTSER_ENABLE
virtser_task();
#endif
#ifdef RAW_ENABLE
raw_hid_task();
#endif
}
}