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 } }