di0ib/tmk_keyboard_custom
Archived
1
0
Fork 0
Code Releases Activity

Squashed 'tmk_core/' changes from ee8c5ba..d5c5ac6

Browse Source 
d5c5ac6 Merge branch 'develop'
5957682 Merge branch 'hotfix-mediakey'
a478c62 Merge branch 'hotfix-vusb'
cccebfe Merge branch 'njbair-docfix'
0aaab57 Clean up wording in keymap example
dc8bbc3 Clarify layer precedence
9e0b4c1 clarify layer documentation
915eb48 core: Fix media/consumer keys
88f90f3 Fix for VUSB configuration
3e290cd Fix including board.mk in chibios.mk
32c69e0 Merge branch 'newapi' into develop
c9a56f9 Merge remote-tracking branch 'flabbergast/chibios' into develop
01e33ea Fix chibios and mbed common.mk for hook.c
bea79d9 hook: Change func name of usb events
3e97536 hook: Change file and func names(*_hook -> hook_*)
c286d8c Merge pull request #10 from fredizzimo/chibios-contrib2
062d74e Update ChibiOS instructions
d47150f Add support for new version of ChibiOS and Contrib
62b5401 Chibios: disable LTO (link-time optimisation).
c64e9aa hooks: Fix for LUFA
54e68b0 hooks: Remove led_restore_hook
325c09d Chibios: make the default bootloader_jump redefinable (weak).
078c722 Chibios: fix STM32_BOOTLOADER_ADDRESS name.
e73cfe5 hooks: Fix for keyboard LED update
e6120c5 Implement basic hooks.
7c370e9 Chibios: Update the main chibios README.
7f0198d Chibios: implement sleep LED for STM32.
afef9b4 Fix hard-coded path of CHIBIOS
95c5b19 Merge pull request #7 from fredizzimo/sysvsize
27128a8 Sysv format for ChibiOS arm-none-eabi-size
d4b8e68 core: Fix chibios user compile options
b85d462 Merge branch 'chibios' of https://github.com/flabbergast/tmk_keyboard into flabbergast_chibios
de41aa1 core: Fix ps2_mouse.c debug print
d79d925 Removed duplicate debug message code and surrounded it with IFDEF as needed
8f28589 Chibios: Revert common.mk change (fix AVR linking problem).
ec9eff2 Chibios: cleanup usb_main code.
28c4665 Chibios: Fix a HardFault bug (wait after start).

git-subtree-dir: tmk_core
git-subtree-split: d5c5ac63e60dfc6da6661a21bd968b4d577a27d5
This commit is contained in:
tmk 2016-04-21 14:35:48 +09:00
parent 657d9f23fe
commit 71381457fa
22 changed files with 446 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
common.mk
View File

@ -10,6 +10,7 @@ SRC += $(COMMON_DIR)/host.c \
$(COMMON_DIR)/print.c \
$(COMMON_DIR)/debug.c \
$(COMMON_DIR)/util.c \
$(COMMON_DIR)/hook.c \
$(COMMON_DIR)/avr/suspend.c \
$(COMMON_DIR)/avr/xprintf.S \
$(COMMON_DIR)/avr/timer.c \

2
common/action.c
View File

@ -26,6 +26,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "action_macro.h"
#include "action_util.h"
#include "action.h"
#include "hook.h"
#ifdef DEBUG_ACTION
#include "debug.h"
@ -39,6 +40,7 @@ void action_exec(keyevent_t event)
if (!IS_NOEVENT(event)) {
dprint("\n---- action_exec: start -----\n");
dprint("EVENT: "); debug_event(event); dprintln();
hook_matrix_change(event);
}
keyrecord_t record = { .event = event };

2
common/action_layer.c
View File

@ -3,6 +3,7 @@
#include "action.h"
#include "util.h"
#include "action_layer.h"
#include "hook.h"
#ifdef DEBUG_ACTION
#include "debug.h"
@ -62,6 +63,7 @@ static void layer_state_set(uint32_t state)
dprint("layer_state: ");
layer_debug(); dprint(" to ");
layer_state = state;
hook_layer_change(layer_state);
layer_debug(); dprintln();
clear_keyboard_but_mods(); // To avoid stuck keys
}

4
common/bootmagic.c
View File

@ -9,6 +9,7 @@
#include "action_layer.h"
#include "eeconfig.h"
#include "bootmagic.h"
#include "hook.h"
keymap_config_t keymap_config;
@ -40,6 +41,9 @@ void bootmagic(void)
bootloader_jump();
}
/* user-defined checks */
hook_bootmagic();
/* debug enable */
debug_config.raw = eeconfig_read_debug();
if (bootmagic_scan_keycode(BOOTMAGIC_KEY_DEBUG_ENABLE)) {

1
common/chibios/bootloader.c
View File

@ -42,5 +42,6 @@ void bootloader_jump(void) {
#endif /* defined(KIIBOHD_BOOTLOADER) */
#else /* neither STM32 nor KINETIS */
__attribute__((weak))
void bootloader_jump(void) {}
#endif

74
common/chibios/sleep_led.c
View File

@ -4,11 +4,27 @@
#include "led.h"
#include "sleep_led.h"
#if defined(KL2x) || defined(K20x) /* platform selection: familiar Kinetis chips */
/* All right, we go the "software" way: LP timer, toggle LED in interrupt.
/* All right, we go the "software" way: timer, toggle LED in interrupt.
* Based on hasu's code for AVRs.
* Use LP timer on Kinetises, TIM14 on STM32F0.
*/
#if defined(KL2x) || defined(K20x)
/* Use Low Power Timer (LPTMR) */
#define TIMER_INTERRUPT_VECTOR KINETIS_LPTMR0_IRQ_VECTOR
#define RESET_COUNTER LPTMR0->CSR |= LPTMRx_CSR_TCF
#elif defined(STM32F0XX)
/* Use TIM14 manually */
#define TIMER_INTERRUPT_VECTOR STM32_TIM14_HANDLER
#define RESET_COUNTER STM32_TIM14->SR &= ~STM32_TIM_SR_UIF
#endif
#if defined(KL2x) || defined(K20x) || defined(STM32F0XX) /* common parts for timers/interrupts */
/* Breathing Sleep LED brighness(PWM On period) table
* (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
*
@ -22,8 +38,8 @@ static const uint8_t breathing_table[64] = {
15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
/* Low Power Timer interrupt handler */
OSAL_IRQ_HANDLER(KINETIS_LPTMR0_IRQ_VECTOR) {
/* interrupt handler */
OSAL_IRQ_HANDLER(TIMER_INTERRUPT_VECTOR) {
OSAL_IRQ_PROLOGUE();
/* Software PWM
@ -55,11 +71,16 @@ OSAL_IRQ_HANDLER(KINETIS_LPTMR0_IRQ_VECTOR) {
}
/* Reset the counter */
LPTMR0->CSR |= LPTMRx_CSR_TCF;
RESET_COUNTER;
OSAL_IRQ_EPILOGUE();
}
#endif /* common parts for known platforms */
#if defined(KL2x) || defined(K20x) /* platform selection: familiar Kinetis chips */
/* LPTMR clock options */
#define LPTMR_CLOCK_MCGIRCLK 0 /* 4MHz clock */
#define LPTMR_CLOCK_LPO 1 /* 1kHz clock */
@ -144,7 +165,48 @@ void sleep_led_toggle(void) {
LPTMR0->CSR ^= LPTMRx_CSR_TEN;
}
#else /* platform selection: not on familiar Kinetis chips */
#elif defined(STM32F0XX) /* platform selection: STM32F0XX */
/* Initialise the timer */
void sleep_led_init(void) {
/* enable clock */
rccEnableTIM14(FALSE); /* low power enable = FALSE */
rccResetTIM14();
/* prescale */
/* Assuming 48MHz internal clock */
/* getting cca 65484 irqs/sec */
STM32_TIM14->PSC = 733;
/* auto-reload */
/* 0 => interrupt every time */
STM32_TIM14->ARR = 3;
/* enable counter update event interrupt */
STM32_TIM14->DIER |= STM32_TIM_DIER_UIE;
/* register interrupt vector */
nvicEnableVector(STM32_TIM14_NUMBER, 2); /* vector, priority */
}
void sleep_led_enable(void) {
/* Enable the timer */
STM32_TIM14->CR1 = STM32_TIM_CR1_CEN | STM32_TIM_CR1_URS;
/* URS => update event only on overflow; setting UG bit disabled */
}
void sleep_led_disable(void) {
/* Disable the timer */
STM32_TIM14->CR1 = 0;
}
void sleep_led_toggle(void) {
/* Toggle the timer */
STM32_TIM14->CR1 ^= STM32_TIM_CR1_CEN;
}
#else /* platform selection: not on familiar chips */
void sleep_led_init(void) {
}

61
common/hook.c Normal file
View File

@ -0,0 +1,61 @@
/*
Copyright 2016 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 "keyboard.h"
#include "hook.h"
/* -------------------------------------------------
* Definitions of hardware-independent default hooks
* ------------------------------------------------- */
/* Called on layer state change event. */
/* Default behaviour: do nothing. */
__attribute__((weak))
void hook_layer_change(uint8_t layer_state) {
(void)layer_state;
}
/* Called periodically from the matrix scan loop (very often!) */
/* Default behaviour: do nothing. */
__attribute__((weak))
void hook_keyboard_loop(void) {}
/* Called on matrix state change event (every keypress => often!) */
/* Default behaviour: do nothing. */
__attribute__((weak))
void hook_matrix_change(keyevent_t event) {
(void)event;
}
/* Called on indicator LED update event (when reported from host). */
/* Default behaviour: calls led_set (for compatibility). */
__attribute__((weak))
void hook_keyboard_leds_change(uint8_t led_status) {
keyboard_set_leds(led_status);
}
/* Called once, on checking the bootmagic combos. */
/* Default behaviour: do nothing. */
__attribute__((weak))
void hook_bootmagic(void) {
/* An example: */
// #include "bootmagic.h"
// #include "keymap.h"
// if(bootmagic_scan_keycode(KC_W)) {
// // do something
// }
}

74
common/hook.h Normal file
View File

@ -0,0 +1,74 @@
/*
Copyright 2016 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/>.
*/
#ifndef _HOOKS_H_
#define _HOOKS_H_
#include "keyboard.h"
#include "led.h"
/* -------------------------------------
* Hardware / one-off hooks
* ------------------------------------- */
/* Called once, before initialising USB. */
/* Default behaviour: do nothing. */
void hook_early_init(void);
/* Called once, after USB is connected and keyboard initialised. */
/* Default behaviour: do nothing. */
void hook_late_init(void);
/* Called once, on getting SUSPEND event from USB. */
/* Default behaviour: do nothing. */
void hook_usb_suspend_entry(void);
/* Called repeatedly during the SUSPENDed state. */
/* Default behaviour: power down and periodically check
* the matrix, cause wakeup if needed. */
void hook_usb_suspend_loop(void);
/* Called once, on getting WAKE event from USB. */
/* Default behaviour: disables sleep LED breathing and restores
* the "normal" indicator LED status by default. */
void hook_usb_wakeup(void);
/* Called once, on checking the bootmagic combos. */
/* Default behaviour: do nothing. */
void hook_bootmagic(void);
/* -------------------------------------
* Keyboard / periodic hooks
* ------------------------------------- */
/* Called periodically from the keyboard loop (very often!) */
/* Default behaviour: do nothing. */
void hook_keyboard_loop(void);
/* Called on matrix state change event (every keypress => often!) */
/* Default behaviour: do nothing. */
void hook_matrix_change(keyevent_t event);
/* Called on layer state change event. */
/* Default behaviour: do nothing. */
void hook_layer_change(uint8_t layer_state);
/* Called on indicator LED update event (when reported from host). */
/* Default behaviour: calls keyboard_set_leds (for compatibility). */
void hook_keyboard_leds_change(uint8_t led_status);
#endif /* _HOOKS_H_ */

13
common/keyboard.c
View File

@ -30,6 +30,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "bootmagic.h"
#include "eeconfig.h"
#include "backlight.h"
#include "hook.h"
#ifdef MOUSEKEY_ENABLE
# include "mousekey.h"
#endif
@ -128,11 +129,13 @@ void keyboard_task(void)
if (debug_matrix) matrix_print();
for (uint8_t c = 0; c < MATRIX_COLS; c++) {
if (matrix_change & ((matrix_row_t)1<<c)) {
action_exec((keyevent_t){
keyevent_t e = (keyevent_t){
.key = (keypos_t){ .row = r, .col = c },
.pressed = (matrix_row & ((matrix_row_t)1<<c)),
.time = (timer_read() | 1) /* time should not be 0 */
});
};
action_exec(e);
hook_matrix_change(e);
// record a processed key
matrix_prev[r] ^= ((matrix_row_t)1<<c);
// process a key per task call
@ -146,6 +149,8 @@ void keyboard_task(void)
MATRIX_LOOP_END:
hook_keyboard_loop();
#ifdef MOUSEKEY_ENABLE
// mousekey repeat & acceleration
mousekey_task();
@ -166,12 +171,12 @@ MATRIX_LOOP_END:
// update LED
if (led_status != host_keyboard_leds()) {
led_status = host_keyboard_leds();
keyboard_set_leds(led_status);
if (debug_keyboard) dprintf("LED: %02X\n", led_status);
hook_keyboard_leds_change(led_status);
}
}
void keyboard_set_leds(uint8_t leds)
{
if (debug_keyboard) { debug("keyboard_set_led: "); debug_hex8(leds); debug("\n"); }
led_set(leds);
}

2
common/keymap.c
View File

@ -142,7 +142,7 @@ static action_t keycode_to_action(uint8_t keycode)
case KC_SYSTEM_POWER ... KC_SYSTEM_WAKE:
action.code = ACTION_USAGE_SYSTEM(KEYCODE2SYSTEM(keycode));
break;
case KC_AUDIO_MUTE ... KC_MEDIA_REWIND:
case KC_AUDIO_MUTE ... KC_WWW_FAVORITES:
action.code = ACTION_USAGE_CONSUMER(KEYCODE2CONSUMER(keycode));
break;
case KC_MS_UP ... KC_MS_ACCEL2:

88
doc/keymap.md
View File

@ -3,9 +3,9 @@ Keymap framework - how to define your keymap
***NOTE: This is not final version, may be inconsistent with source code and changed occasionally for a while.***
## 0. Keymap and layers
**Keymap** is comprised of multiple layers of key layout, you can define **32 layers** at most.
**Layer** is an array of **keycodes** to define **actions** for each physical keys.
respective layers can be validated simultaneously. Layers are indexed with 0 to 31 and higher layer has precedence.
The **keymap** is an array composed of one or more layers.
Each **layer** is an array of **keycodes**, defining **actions** for each physical key.
Layers can be activated and deactivated independently. Multiple layers may be active at once, resulting in the currently-active **layer state**. Each layer has an index between 0-31. As active layers are stacked together, higher layers take precedence over lower layers.
Keymap: 32 Layers Layer: Keycode matrix
----------------- ---------------------
@ -21,31 +21,17 @@ respective layers can be validated simultaneously. Layers are indexed with 0 to
1 /___________// | 1 `--------------------------
0 /___________/ V low 0 `--------------------------
**Note:** The keymap array is limited to **32 layers**.
### 0.1 Keymap status
Keymap has its state in two parameters:
**`default_layer`** indicates a base keymap layer(0-31) which is always valid and to be referred, **`keymap_stat`** is 16bit variable which has current on/off status of layers on its each bit.
Keymap layer '0' is usually `default_layer` and which is the only valid layer and other layers is initially off after boot up firmware, though, you can configured them in `config.h`.
To change `default_layer` will be useful when you switch key layout completely, say you want Colmak instead of Qwerty.
### 0.1 Layer state
The current keymap layer state is determined by two parameters: the *default layer*, and the individual *layer states*. Changing the default layer is useful for switching key layouts completely; for example, switching to Dvorak, Colemak or Workman instead of QWERTY. Individual layer states, on the other hand, can be used to overlay the base layer with other functions such as navigation keys, function keys (F1-F12), media keys or other actions.
Initial state of Keymap Change base layout
----------------------- ------------------
Because the default layer is really just a special case affecting the overall layer state, it is important to first understand how the layer state is determined.
31 31
30 30
29 29
: :
: : ____________
2 ____________ 2 / /
1 / / ,->1 /___________/
,->0 /___________/ | 0
| |
`--- default_layer = 0 `--- default_layer = 1
layer_state = 0x00000001 layer_state = 0x00000002
On the other hand, you shall change `layer_state` to overlay base layer with some layers for feature such as navigation keys, function key(F1-F12), media keys or special actions.
#### 0.1.1 The layer state
The **layer state** indicates the current on/off status of all layers. It is defined in the firmware by a 32-bit integer, `layer_state`, which stores each layer's on/off status in a single bit: 0 for off, 1 for on. As layers are activated and deactivated, their respective bits are flipped, changing the value of `layer_state`.
Overlay feature layer
--------------------- bit|status
@ -62,28 +48,64 @@ On the other hand, you shall change `layer_state` to overlay base layer with som
`--- default_layer = 1 |
layer_state = 0x60000002 <-'
#### 0.1.2 The default layer
The **default layer** is the base keymap layer (0-31) which is always active and considered the "bottom" of the stack. When the firmware boots, the default layer is the only active layer. It is set to layer 0 by default, though this can be changed ~~in *config.h*~~ via Boot Magic settings.
Initial state of Keymap Change base layout
----------------------- ------------------
31 31
30 30
29 29
: :
: : ____________
2 ____________ 2 / /
1 / / ,->1 /___________/
,->0 /___________/ | 0
| |
`--- default_layer = 0 `--- default_layer = 1
layer_state = 0x00000001 layer_state = 0x00000002
Note that the `default_layer_state` variable only determines the lowest value to which `layer_state` may be set, and that `default_layer_state` is used by the core firmware when determining the starting value of `layer_state` before applying changes. In other words, the default layer will *always* be set to *on* in `layer_state`.
The default layer is defined in the firmware by the `default_layer_state` variable, which is identical in format to the `layer_state` variable exlpained above. The value may be changed using the following functions:
- `default_layer_state_set(state)` sets the state to the specified 32-bit integer value.
- AND/OR/XOR functions set the state based on a boolean logic comparison between the current state and the specified 32-bit integer value:
- `default_layer_state_and(state)`
- `default_layer_state_or(state)`
- `default_layer_state_xor(state)`
For example, to set layer 3 as the default layer:
```C
// convert 3 to a 32-bit unsigned long value, and set the default layer
default_layer_state_set(1UL<<3);
```
### 0.2 Layer Precedence and Transparency
Note that ***higher layer has higher priority on stack of layers***, namely firmware falls down from top layer to bottom to look up keycode. Once it spots keycode other than **`KC_TRNS`**(transparent) on a layer it stops searching and lower layers aren't referred.
Note that ***higher layers have priority in the layer stack***. The firmware starts at the topmost active layer, and works down to the bottom to find the an active keycode. Once the search encounters any keycode other than **`KC_TRNS`** (transparent) on an active layer, the search is halted and the remaining lower layers aren't examined, even if they are active.
**Note:** a layer must be activated before it may be included in the stack search.
`KC_TRNS` is a special placeholder which can be used on overlay layers. This allows for the creation of "partial" layers which fall back on the lower layers, eliminating a good deal of repetition in keymap files.
You can place `KC_TRNS` on overlay layer changes just part of layout to fall back on lower or base layer.
Key with `KC_TRANS` doesn't has its own keycode and refers to lower valid layers for keycode, instead.
See example below.
### 0.3 Keymap Example
Keymap is **`keymaps[]`** C array in fact and you can define layers in it with **`KEYMAP()`** C macro and keycodes. To use complex actions you need to define `Fn` keycode in **`fn_actions[]`** array.
The keymap is defined in the **`keymaps[]`** array, a 2-dimensional array of rows and columns corresponding to positions in the keyboard matrix. But most often the layers are defined using C macros to allow for easier reading and editing of the keymap files. To use complex actions you need to define `Fn` keycodes in the **`fn_actions[]`** array.
This is a keymap example for [HHKB](http://en.wikipedia.org/wiki/Happy_Hacking_Keyboard) keyboard.
This example has three layers, 'Qwerty' as base layer, 'Cursor' and 'Mousekey'.
This is a keymap example for the [HHKB](http://en.wikipedia.org/wiki/Happy_Hacking_Keyboard) keyboard.
This example has three layers: the QWERTY base layer, and two overlay layers for cursor and mousekey control, respectively.
In this example,
`Fn0` is a **momentary layer switching** key, you can use keys on Cursor layer while holding the key.
`Fn0` is a **momentary layer switching** key--you can use keys on the Cursor layer while holding the key.
`Fn1` is a momentary layer switching key with tapping feature, you can get semicolon **';'** with taping the key and switch layers while holding the key. The word **'tap'** or **'tapping'** mean to press and release a key quickly.
`Fn1` is a momentary layer switching key with tapping function--tapping the key as one would normally use it, sends the semicolon **';'** keycode, while holding the key down switches layers.
`Fn2` is a **toggle layer switch** key, you can stay switched layer after releasing the key unlike momentary switching.
`Fn2` is a **toggle layer switch** key--pressing the key toggles the layer on until you press it again.
You can find other keymap definitions in file `keymap.c` located on project directories.

34
protocol/chibios/README.md
View File

@ -1,21 +1,30 @@
## TMK running on top of ChibiOS
This code can be used to run TMK keyboard logic on top of [ChibiOS], meaning that you can run TMK on whatever [ChibiOS] supports. The notable examples are ARM-based Teensies (3.x and LC) and on the boards with STM32 MCUs.
### Usage
- To use, unpack or symlink [ChibiOS] to `tmk_core/tool/chibios/chibios`. For Kinetis support (this means Teensies, Infinity keyboard, WhiteFox keyboard), you'll need a fork which implements the USB driver, e.g. [this one](https://github.com/flabbergast/ChibiOS/tree/kinetis).
- You will also need to install an ARM toolchain, for instance from [here](https://launchpad.net/gcc-arm-embedded). On linux, this is usually also present as a package for your distribution (as `gcc-arm` or something similar). On OS X, you can use [homebrew](http://brew.sh/) with an appropriate tap.
### Notes
- To use, unpack or symlink [ChibiOS] {currently 3.0.2} to `tmk_core/tool/chibios/chibios`. For Kinetis support, you'll need a fork which implements the USB driver, e.g. [this one](https://github.com/flabbergast/ChibiOS/tree/kinetis).
- Some comments about ChibiOS syntax and the most commonly used GPIO functions are, as well as an example for ARM Teensies, is [here](https://github.com/tmk/tmk_keyboard/blob/master/keyboard/teensy_lc_onekey/instructions.md).
- For gcc options, inspect `tmk_core/tool/chibios/chibios.mk`. For instance, I enabled `-Wno-missing-field-initializers`, because TMK common bits generated a lot of warnings on that.
Also pay attention to `-O0` (enabled for debugging); for deployment use `-O2`.
- USB string descriptors are messy. I did not find a way to cleanly generate the right structures from actual strings, so the definitions in individual keyboards' `config.h` are ugly as heck.
- There are some random constants left so far, e.g. 5ms sleep between calling `keyboard_task`, or 1.5sec wait for USB init, in `main.c`. There should be no such in `usb_main.c` (the main USB stack). Everything is based on timers/interrupts/kernel scheduling (well except `keyboard_task`), so no periodically called things (again, except `keyboard_task`, which is just how TMK is designed).
- It is easy to add some code for testing (e.g. blink LED, do stuff on button press, etc...) - just create another thread in `main.c`, it will run independently of the keyboard business.
- Jumping to (the built-in) bootloaders on STM32 works, but it is not entirely pleasant, since it is very much MCU dependent. So, one needs to dig out the right address to jump to, and either pass it to the compiler in the `Makefile`, or better, define it in `<your_kb>/bootloader_defs.h`. Also, a patch to upstream ChibiOS is needed (supplied), because it `ResetHandler` needs adjusting.
- Sleep LED works, but at the moment only on/off, i.e. no breathing.
- Jumping to (the built-in) bootloaders on STM32 works, but it is not entirely pleasant, since it is very much MCU dependent. So, one needs to dig out the right address to jump to, and either pass it to the compiler in the `Makefile`, or better, define it in `<your_kb>/bootloader_defs.h`. An additional startup code is also needed; the best way to deal with this is to define custom board files. (Example forthcoming.)
### Experimental pre-ChibiOS 4 support
- As an alternative to the mentioned flabbergast branch above, you can use the [master branch of ChibiOS](https://github.com/ChibiOS/ChibiOS).
- Note that the Kinetis support has moved to the [ChibiOS-Contrib repository](https://github.com/ChibiOS/ChibiOS-Contrib), so you need to put that into your repository in the same way as you did for the main ChibiOS repository.
- You also need to define CHIBIOS_CONTRIB in your makefile and point it to the right directory.
- You need to add some new options to chconf.h, or you will get compiler errors. Just copy the new options from samples provided by the ChibiOS-Contrib repository.
### Immediate todo
- host-wakeup packet sending during suspend
- power saving for suspend?
- PWM for sleep led
- power saving for suspend
### Not tested, but possibly working
@ -27,14 +36,14 @@ Also pay attention to `-O0` (enabled for debugging); for deployment use `-O2`.
### Tried with
- ChibiOS 3.0.1, 3.0.2 and ST F072RB DISCOVERY board.
- Need to test on other STM32 chips (F3, F4) to make it as much chip-independent as possible.
- ChibiOS with Kinetis patches and Teensy LC and 3.0.
- Infinity, WhiteFox keyboards
- all ARM-based Teensies
- some STM32-based boards (e.g. ST-F072RB-DISCOVERY board, STM32F042 breakout board, Maple Mini (STM32F103-based))
## ChibiOS-supported MCUs (as of 3.0.2)
## ChibiOS-supported MCUs
- Pretty much all STM32 chips.
- There is some support for K20x and KL2x Freescale chips (i.e. Teensy 3.x/LC, mchck, FRDM-KL2{5,6}Z, FRDM-K20D50M), but again, no official USB stack yet. However the `kinetis` branch of [my ChibiOS fork](https://github.com/flabbergast/ChibiOS). With this fork, TMK work normally on all the ARM Teensies.
- There is some support for K20x and KL2x Freescale chips (i.e. Teensy 3.x/LC, mchck, FRDM-KL2{5,6}Z, FRDM-K20D50M), but again, no official USB stack yet. However the `kinetis` branch of [flabbergast's ChibiOS fork](https://github.com/flabbergast/ChibiOS). With this fork, TMK work normally on all the ARM Teensies.
- There is also support for AVR8, but the USB stack is not implemented for them yet, and also the kernel itself takes about 1k of RAM. I think people managed to get ChibiOS running on atmega32[8p/u4] though.
- I've seen community support for Nordic NRF51822 (the chip in Adafruit's Bluefruit bluetooth-low-energy boards), but not sure about the extent.
@ -43,7 +52,6 @@ Also pay attention to `-O0` (enabled for debugging); for deployment use `-O2`.
- STM32F0x2 chips can do crystal-less USB, but they still need a 3.3V voltage regulator.
- The BOOT0 pin should be tied to GND.
- For a hardware way of accessing the in-built DFU bootloader, in addition to the reset button, put another button between the BOOT0 pin and 3V3.
- For breathing the caps lock LED during the suspended state ("sleep LED"), it is desirable to have that LED on a hardware PWM pin (there's usually plenty of those, look for TIMERs in the datasheet). However this is not strictly necessary, because instead of direct output of a timer to a pin (better of course), it is easy to define timer callbacks in ChibiOS that turn on/off an arbitrary pin.

37
protocol/chibios/main.c
View File

@ -35,6 +35,7 @@
#include "sleep_led.h"
#endif
#include "suspend.h"
#include "hook.h"
/* -------------------------
@ -58,6 +59,22 @@ host_driver_t chibios_driver = {
send_consumer
};
/* Default hooks definitions. */
__attribute__((weak))
void hook_early_init(void) {}
__attribute__((weak))
void hook_late_init(void) {}
__attribute__((weak))
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);
}
}
/* TESTING
* Amber LED blinker thread, times are in milliseconds.
@ -91,6 +108,8 @@ int main(void) {
// TESTING
// chThdCreateStatic(waBlinkerThread, sizeof(waBlinkerThread), NORMALPRIO, blinkerThread, NULL);
hook_early_init();
/* Init USB */
init_usb_driver(&USB_DRIVER);
@ -101,6 +120,13 @@ int main(void) {
while(USB_DRIVER.state != USB_ACTIVE)
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 */
@ -113,21 +139,18 @@ int main(void) {
print("Keyboard start.\n");
hook_late_init();
/* Main loop */
while(true) {
if(USB_DRIVER.state == USB_SUSPENDED) {
print("[s]");
while(USB_DRIVER.state == USB_SUSPENDED) {
/* 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);
}
hook_usb_suspend_loop();
}
/* Woken up */
// variables has been already cleared by the wakeup hook
// variables have been already cleared
send_keyboard_report();
#ifdef MOUSEKEY_ENABLE
mousekey_send();

37
protocol/chibios/usb_main.c
View File

@ -27,15 +27,34 @@
#include "sleep_led.h"
#include "led.h"
#endif
#include "hook.h"
/* TMK hooks */
__attribute__((weak))
void hook_usb_wakeup(void) {
#ifdef SLEEP_LED_ENABLE
sleep_led_disable();
// NOTE: converters may not accept this
led_set(host_keyboard_leds());
#endif /* SLEEP_LED_ENABLE */
}
__attribute__((weak))
void hook_usb_suspend_entry(void) {
#ifdef SLEEP_LED_ENABLE
sleep_led_enable();
#endif /* SLEEP_LED_ENABLE */
}
/* ---------------------------------------------------------
* Global interface variables and declarations
* ---------------------------------------------------------
*/
uint8_t keyboard_idle = 0;
uint8_t keyboard_protocol = 1;
uint16_t keyboard_led_stats = 0;
uint8_t keyboard_idle __attribute__((aligned(2))) = 0;
uint8_t keyboard_protocol __attribute__((aligned(2))) = 1;
uint16_t keyboard_led_stats __attribute__((aligned(2))) = 0;
volatile uint16_t keyboard_idle_count = 0;
static virtual_timer_t keyboard_idle_timer;
static void keyboard_idle_timer_cb(void *arg);
@ -795,19 +814,13 @@ static void usb_event_cb(USBDriver *usbp, usbevent_t event) {
case USB_EVENT_SUSPEND:
//TODO: from ISR! print("[S]");
#ifdef SLEEP_LED_ENABLE
sleep_led_enable();
#endif /* SLEEP_LED_ENABLE */
hook_usb_suspend_entry();
return;
case USB_EVENT_WAKEUP:
//TODO: from ISR! print("[W]");
suspend_wakeup_init();
#ifdef SLEEP_LED_ENABLE
sleep_led_disable();
// NOTE: converters may not accept this
led_set(host_keyboard_leds());
#endif /* SLEEP_LED_ENABLE */
hook_usb_wakeup();
return;
case USB_EVENT_STALLED:
@ -1350,7 +1363,7 @@ int8_t sendchar(uint8_t c) {
return 0;
}
osalSysUnlock();
/* Timeout after 5us if the queue is full.
/* Timeout after 100us if the queue is full.
* Increase this timeout if too much stuff is getting
* dropped (i.e. the buffer is getting full too fast
* for USB/HIDRAW to dequeue). Another possibility

6
protocol/chibios/usb_main.h
View File

@ -58,9 +58,6 @@ void send_remote_wakeup(USBDriver *usbp);
#define NKRO_REPORT_KEYS (NKRO_EPSIZE - 1)
#endif
/* this defines report_keyboard_t and computes REPORT_SIZE defines */
// #include "report.h"
/* extern report_keyboard_t keyboard_report_sent; */
/* keyboard IN request callback handler */
@ -122,8 +119,7 @@ typedef struct {
#define CONSOLE_EPSIZE 16
/* Number of IN reports that can be stored inside the output queue */
#define CONSOLE_QUEUE_CAPACITY 2
#define CONSOLE_QUEUE_BUFFER_SIZE (CONSOLE_QUEUE_CAPACITY * CONSOLE_EPSIZE)
#define CONSOLE_QUEUE_CAPACITY 4
/* Console flush time */
#define CONSOLE_FLUSH_MS 50

56
protocol/lufa/lufa.c
View File

@ -48,6 +48,7 @@
#include "sleep_led.h"
#endif
#include "suspend.h"
#include "hook.h"
#include "descriptor.h"
#include "lufa.h"
@ -180,21 +181,13 @@ void EVENT_USB_Device_Reset(void)
void EVENT_USB_Device_Suspend()
{
print("[S]");
#ifdef SLEEP_LED_ENABLE
sleep_led_enable();
#endif
hook_usb_suspend_entry();
}
void EVENT_USB_Device_WakeUp()
{
print("[W]");
suspend_wakeup_init();
#ifdef SLEEP_LED_ENABLE
sleep_led_disable();
// NOTE: converters may not accept this
led_set(host_keyboard_leds());
#endif
hook_usb_wakeup();
}
#ifdef CONSOLE_ENABLE
@ -592,6 +585,7 @@ int main(void) __attribute__ ((weak));
int main(void)
{
setup_mcu();
hook_early_init();
keyboard_setup();
setup_usb();
sei();
@ -614,13 +608,11 @@ int main(void)
#endif
print("Keyboard start.\n");
hook_late_init();
while (1) {
while (USB_DeviceState == DEVICE_STATE_Suspended) {
print("[s]");
suspend_power_down();
if (USB_Device_RemoteWakeupEnabled && suspend_wakeup_condition()) {
USB_Device_SendRemoteWakeup();
}
hook_usb_suspend_loop();
}
keyboard_task();
@ -630,3 +622,39 @@ int main(void)
#endif
}
}
/* hooks */
__attribute__((weak))
void hook_early_init(void) {}
__attribute__((weak))
void hook_late_init(void) {}
__attribute__((weak))
void hook_usb_suspend_entry(void)
{
#ifdef SLEEP_LED_ENABLE
sleep_led_enable();
#endif
}
__attribute__((weak))
void hook_usb_suspend_loop(void)
{
suspend_power_down();
if (USB_Device_RemoteWakeupEnabled && suspend_wakeup_condition()) {
USB_Device_SendRemoteWakeup();
}
}
__attribute__((weak))
void hook_usb_wakeup(void)
{
suspend_wakeup_init();
#ifdef SLEEP_LED_ENABLE
sleep_led_disable();
// NOTE: converters may not accept this
led_set(host_keyboard_leds());
#endif
}

6
protocol/ps2_mouse.c
View File

@ -85,17 +85,13 @@ void ps2_mouse_task(void)
if (debug_mouse) print("ps2_mouse: fail to get mouse packet\n");
return;
}
xprintf("%ud ", timer_read());
print("ps2_mouse raw: [");
phex(mouse_report.buttons); print("|");
print_hex8((uint8_t)mouse_report.x); print(" ");
print_hex8((uint8_t)mouse_report.y); print("]\n");
/* if mouse moves or buttons state changes */
if (mouse_report.x || mouse_report.y ||
((mouse_report.buttons ^ buttons_prev) & PS2_MOUSE_BTN_MASK)) {
#ifdef PS2_MOUSE_DEBUG
xprintf("%ud ", timer_read());
print("ps2_mouse raw: [");
phex(mouse_report.buttons); print("|");
print_hex8((uint8_t)mouse_report.x); print(" ");

1
protocol/vusb.mk
View File

@ -10,6 +10,7 @@ SRC += $(VUSB_DIR)/main.c \
ifdef NO_UART
OPT_DEFS += -DNO_UART
SRC += $(COMMON_DIR)/sendchar_null.c
else
SRC += $(COMMON_DIR)/sendchar_uart.c \

2
protocol/vusb/main.c
View File

@ -49,7 +49,7 @@ int main(void)
#endif
CLKPR = 0x80, CLKPR = 0;
#ifndef PS2_USE_USART
#ifndef NO_UART
uart_init(UART_BAUD_RATE);
#endif

58
tool/chibios/chibios.mk
View File

@ -35,7 +35,7 @@ endif
# Enable this if you want link time optimizations (LTO)
ifeq ($(USE_LTO),)
USE_LTO = yes
USE_LTO = no
endif
# If enabled, this option allows to compile the application in THUMB mode.
@ -83,21 +83,44 @@ endif
#
# Imported source files and paths
CHIBIOS = $(TMK_DIR)/tool/chibios/chibios
# Startup files.
include $(CHIBIOS)/os/common/ports/ARMCMx/compilers/GCC/mk/startup_$(MCU_STARTUP).mk
CHIBIOS ?= $(TMK_DIR)/tool/chibios/chibios
# Startup files. Try a few different locations, for compability with old versions and
# for things hardware in the contrib repository
STARTUP_MK = $(CHIBIOS)/os/common/ports/ARMCMx/compilers/GCC/mk/startup_$(MCU_STARTUP).mk
ifeq ("$(wildcard $(STARTUP_MK))","")
STARTUP_MK = $(CHIBIOS)/os/common/startup/ARMCMx/compilers/GCC/mk/startup_$(MCU_STARTUP).mk
ifeq ("$(wildcard $(STARTUP_MK))","")
STARTUP_MK = $(CHIBIOS_CONTRIB)/os/common/startup/ARMCMx/compilers/GCC/mk/startup_$(MCU_STARTUP).mk
endif
endif
include $(STARTUP_MK)
# HAL-OSAL files (optional).
include $(CHIBIOS)/os/hal/hal.mk
include $(CHIBIOS)/os/hal/ports/$(MCU_FAMILY)/$(MCU_SERIES)/platform.mk
ifneq ("$(wildcard $(TARGET_DIR)/boards/$(BOARD))","")
include $(TARGET_DIR)/boards/$(BOARD)/board.mk
else
include $(CHIBIOS)/os/hal/boards/$(BOARD)/board.mk
PLATFORM_MK = $(CHIBIOS)/os/hal/ports/$(MCU_FAMILY)/$(MCU_SERIES)/platform.mk
ifeq ("$(wildcard $(PLATFORM_MK))","")
PLATFORM_MK = $(CHIBIOS_CONTRIB)/os/hal/ports/$(MCU_FAMILY)/$(MCU_SERIES)/platform.mk
endif
include $(PLATFORM_MK)
BOARD_MK = $(TARGET_DIR)/boards/$(BOARD)/board.mk
ifeq ("$(wildcard $(BOARD_MK))","")
BOARD_MK = $(CHIBIOS)/os/hal/boards/$(BOARD)/board.mk
ifeq ("$(wildcard $(BOARD_MK))","")
BOARD_MK = $(CHIBIOS_CONTRIB)/os/hal/boards/$(BOARD)/board.mk
endif
endif
include $(BOARD_MK)
include $(CHIBIOS)/os/hal/osal/rt/osal.mk
# RTOS files (optional).
include $(CHIBIOS)/os/rt/rt.mk
include $(CHIBIOS)/os/rt/ports/ARMCMx/compilers/GCC/mk/port_v$(ARMV)m.mk
# Compability with old version
PORT_V = $(CHIBIOS)/os/rt/ports/ARMCMx/compilers/GCC/mk/port_v$(ARMV)m.mk
ifeq ("$(wildcard $(PORT_V))","")
PORT_V = $(CHIBIOS)/os/common/ports/ARMCMx/compilers/GCC/mk/port_v$(ARMV)m.mk
endif
include $(PORT_V)
# Other files (optional).
# Define linker script file here
@ -175,7 +198,7 @@ CP = $(TRGT)objcopy
AS = $(TRGT)gcc -x assembler-with-cpp
AR = $(TRGT)ar
OD = $(TRGT)objdump
SZ = $(TRGT)size
SZ = $(TRGT)size -A
HEX = $(CP) -O ihex
BIN = $(CP) -O binary
@ -201,10 +224,10 @@ CPPWARN = -Wall -Wextra -Wundef
# List all user C define here, like -D_DEBUG=1
## Select which interfaces to include here!
UDEFS = $(OPT_DEFS)
UDEFS += $(OPT_DEFS)
# Define ASM defines here
UADEFS = $(OPT_DEFS)
UADEFS += $(OPT_DEFS)
# bootloader definitions may be used in the startup .s file
ifneq ("$(wildcard $(TARGET_DIR)/bootloader_defs.h)","")
UADEFS += -include $(TARGET_DIR)/bootloader_defs.h
@ -215,17 +238,20 @@ else ifneq ("$(wildcard $(TARGET_DIR)/boards/$(BOARD)/bootloader_defs.h)","")
endif
# List all user directories here
UINCDIR =
#UINCDIR =
# List the user directory to look for the libraries here
ULIBDIR =
#ULIBDIR =
# List all user libraries here
ULIBS =
#ULIBS =
#
# End of user defines
##############################################################################
RULESPATH = $(CHIBIOS)/os/common/ports/ARMCMx/compilers/GCC
ifeq ("$(wildcard $(RULESPATH)/rules.mk)","")
RULESPATH = $(CHIBIOS)/os/common/startup/ARMCMx/compilers/GCC
endif
include $(RULESPATH)/rules.mk

5
tool/chibios/common.mk
View File

@ -10,6 +10,7 @@ SRC += $(COMMON_DIR)/host.c \
$(COMMON_DIR)/print.c \
$(COMMON_DIR)/debug.c \
$(COMMON_DIR)/util.c \
$(COMMON_DIR)/hook.c \
$(COMMON_DIR)/chibios/suspend.c \
$(COMMON_DIR)/chibios/printf.c \
$(COMMON_DIR)/chibios/timer.c \
@ -80,6 +81,6 @@ endif
OPT_DEFS += -DVERSION=$(shell (git describe --always --dirty || echo 'unknown') 2> /dev/null)
# Bootloader address
ifdef BOOTLOADER_ADDRESS
OPT_DEFS += -DBOOTLOADER_ADDRESS=$(BOOTLOADER_ADDRESS)
ifdef STM32_BOOTLOADER_ADDRESS
OPT_DEFS += -DSTM32_BOOTLOADER_ADDRESS=$(STM32_BOOTLOADER_ADDRESS)
endif

1
tool/mbed/common.mk
View File

@ -10,6 +10,7 @@ OBJECTS += \
$(OBJDIR)/common/print.o \
$(OBJDIR)/common/debug.o \
$(OBJDIR)/common/util.o \
$(OBJDIR)/common/hook.o \
$(OBJDIR)/common/mbed/suspend.o \
$(OBJDIR)/common/mbed/timer.o \
$(OBJDIR)/common/mbed/xprintf.o \