aboutsummaryrefslogtreecommitdiff
path: root/tmk_core/protocol/iwrap
diff options
context:
space:
mode:
authorskullY <skullydazed@gmail.com>2019-08-30 11:19:03 -0700
committerskullydazed <skullydazed@users.noreply.github.com>2019-08-30 15:01:52 -0700
commitb624f32f944acdc59dcb130674c09090c5c404cb (patch)
treebc13adbba137d122d9a2c2fb2fafcbb08ac10e25 /tmk_core/protocol/iwrap
parent61af76a10d00aba185b8338604171de490a13e3b (diff)
downloadqmk_firmware-b624f32f944acdc59dcb130674c09090c5c404cb.tar.gz
qmk_firmware-b624f32f944acdc59dcb130674c09090c5c404cb.zip
clang-format changes
Diffstat (limited to 'tmk_core/protocol/iwrap')
-rw-r--r--tmk_core/protocol/iwrap/iwrap.c202
-rw-r--r--tmk_core/protocol/iwrap/iwrap.h16
-rw-r--r--tmk_core/protocol/iwrap/main.c312
-rw-r--r--tmk_core/protocol/iwrap/suart.h4
-rw-r--r--tmk_core/protocol/iwrap/wd.h134
5 files changed, 327 insertions, 341 deletions
diff --git a/tmk_core/protocol/iwrap/iwrap.c b/tmk_core/protocol/iwrap/iwrap.c
index 71ccc493e..05e632da3 100644
--- a/tmk_core/protocol/iwrap/iwrap.c
+++ b/tmk_core/protocol/iwrap/iwrap.c
@@ -37,43 +37,39 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
37#include "iwrap.h" 37#include "iwrap.h"
38#include "print.h" 38#include "print.h"
39 39
40
41/* iWRAP MUX mode utils. 3.10 HID raw mode(iWRAP_HID_Application_Note.pdf) */ 40/* iWRAP MUX mode utils. 3.10 HID raw mode(iWRAP_HID_Application_Note.pdf) */
42#define MUX_HEADER(LINK, LENGTH) do { \ 41#define MUX_HEADER(LINK, LENGTH) \
43 xmit(0xbf); /* SOF */ \ 42 do { \
44 xmit(LINK); /* Link */ \ 43 xmit(0xbf); /* SOF */ \
45 xmit(0x00); /* Flags */ \ 44 xmit(LINK); /* Link */ \
46 xmit(LENGTH); /* Length */ \ 45 xmit(0x00); /* Flags */ \
47} while (0) 46 xmit(LENGTH); /* Length */ \
48#define MUX_FOOTER(LINK) xmit(LINK^0xff) 47 } while (0)
49 48#define MUX_FOOTER(LINK) xmit(LINK ^ 0xff)
50 49
51static uint8_t connected = 0; 50static uint8_t connected = 0;
52//static uint8_t channel = 1; 51// static uint8_t channel = 1;
53 52
54/* iWRAP buffer */ 53/* iWRAP buffer */
55#define MUX_BUF_SIZE 64 54#define MUX_BUF_SIZE 64
56static char buf[MUX_BUF_SIZE]; 55static char buf[MUX_BUF_SIZE];
57static uint8_t snd_pos = 0; 56static uint8_t snd_pos = 0;
58 57
59#define MUX_RCV_BUF_SIZE 256 58#define MUX_RCV_BUF_SIZE 256
60static char rcv_buf[MUX_RCV_BUF_SIZE]; 59static char rcv_buf[MUX_RCV_BUF_SIZE];
61static uint8_t rcv_head = 0; 60static uint8_t rcv_head = 0;
62static uint8_t rcv_tail = 0; 61static uint8_t rcv_tail = 0;
63 62
64
65/* receive buffer */ 63/* receive buffer */
66static void rcv_enq(char c) 64static void rcv_enq(char c) {
67{
68 uint8_t next = (rcv_head + 1) % MUX_RCV_BUF_SIZE; 65 uint8_t next = (rcv_head + 1) % MUX_RCV_BUF_SIZE;
69 if (next != rcv_tail) { 66 if (next != rcv_tail) {
70 rcv_buf[rcv_head] = c; 67 rcv_buf[rcv_head] = c;
71 rcv_head = next; 68 rcv_head = next;
72 } 69 }
73} 70}
74 71
75static char rcv_deq(void) 72static char rcv_deq(void) {
76{
77 char c = 0; 73 char c = 0;
78 if (rcv_head != rcv_tail) { 74 if (rcv_head != rcv_tail) {
79 c = rcv_buf[rcv_tail++]; 75 c = rcv_buf[rcv_tail++];
@@ -91,38 +87,33 @@ static char rcv_peek(void)
91} 87}
92*/ 88*/
93 89
94static void rcv_clear(void) 90static void rcv_clear(void) { rcv_tail = rcv_head = 0; }
95{
96 rcv_tail = rcv_head = 0;
97}
98 91
99/* iWRAP response */ 92/* iWRAP response */
100ISR(PCINT1_vect, ISR_BLOCK) // recv() runs away in case of ISR_NOBLOCK 93ISR(PCINT1_vect, ISR_BLOCK) // recv() runs away in case of ISR_NOBLOCK
101{ 94{
102 if ((SUART_IN_PIN & (1<<SUART_IN_BIT))) 95 if ((SUART_IN_PIN & (1 << SUART_IN_BIT))) return;
103 return;
104 96
105 static volatile uint8_t mux_state = 0xff; 97 static volatile uint8_t mux_state = 0xff;
106 static volatile uint8_t mux_link = 0xff; 98 static volatile uint8_t mux_link = 0xff;
107 uint8_t c = recv(); 99 uint8_t c = recv();
108 switch (mux_state) { 100 switch (mux_state) {
109 case 0xff: // SOF 101 case 0xff: // SOF
110 if (c == 0xbf) 102 if (c == 0xbf) mux_state--;
111 mux_state--;
112 break; 103 break;
113 case 0xfe: // Link 104 case 0xfe: // Link
114 mux_state--; 105 mux_state--;
115 mux_link = c; 106 mux_link = c;
116 break; 107 break;
117 case 0xfd: // Flags 108 case 0xfd: // Flags
118 mux_state--; 109 mux_state--;
119 break; 110 break;
120 case 0xfc: // Length 111 case 0xfc: // Length
121 mux_state = c; 112 mux_state = c;
122 break; 113 break;
123 case 0x00: 114 case 0x00:
124 mux_state = 0xff; 115 mux_state = 0xff;
125 mux_link = 0xff; 116 mux_link = 0xff;
126 break; 117 break;
127 default: 118 default:
128 if (mux_state--) { 119 if (mux_state--) {
@@ -132,12 +123,10 @@ ISR(PCINT1_vect, ISR_BLOCK) // recv() runs away in case of ISR_NOBLOCK
132 } 123 }
133} 124}
134 125
135
136/*------------------------------------------------------------------* 126/*------------------------------------------------------------------*
137 * iWRAP communication 127 * iWRAP communication
138 *------------------------------------------------------------------*/ 128 *------------------------------------------------------------------*/
139void iwrap_init(void) 129void iwrap_init(void) {
140{
141 // reset iWRAP if in already MUX mode after AVR software-reset 130 // reset iWRAP if in already MUX mode after AVR software-reset
142 iwrap_send("RESET"); 131 iwrap_send("RESET");
143 iwrap_mux_send("RESET"); 132 iwrap_mux_send("RESET");
@@ -147,43 +136,34 @@ void iwrap_init(void)
147 iwrap_check_connection(); 136 iwrap_check_connection();
148} 137}
149 138
150void iwrap_mux_send(const char *s) 139void iwrap_mux_send(const char *s) {
151{
152 rcv_clear(); 140 rcv_clear();
153 MUX_HEADER(0xff, strlen((char *)s)); 141 MUX_HEADER(0xff, strlen((char *)s));
154 iwrap_send(s); 142 iwrap_send(s);
155 MUX_FOOTER(0xff); 143 MUX_FOOTER(0xff);
156} 144}
157 145
158void iwrap_send(const char *s) 146void iwrap_send(const char *s) {
159{ 147 while (*s) xmit(*s++);
160 while (*s)
161 xmit(*s++);
162} 148}
163 149
164/* send buffer */ 150/* send buffer */
165void iwrap_buf_add(uint8_t c) 151void iwrap_buf_add(uint8_t c) {
166{
167 // need space for '\0' 152 // need space for '\0'
168 if (snd_pos < MUX_BUF_SIZE-1) 153 if (snd_pos < MUX_BUF_SIZE - 1) buf[snd_pos++] = c;
169 buf[snd_pos++] = c;
170} 154}
171 155
172void iwrap_buf_del(void) 156void iwrap_buf_del(void) {
173{ 157 if (snd_pos) snd_pos--;
174 if (snd_pos)
175 snd_pos--;
176} 158}
177 159
178void iwrap_buf_send(void) 160void iwrap_buf_send(void) {
179{
180 buf[snd_pos] = '\0'; 161 buf[snd_pos] = '\0';
181 snd_pos = 0; 162 snd_pos = 0;
182 iwrap_mux_send(buf); 163 iwrap_mux_send(buf);
183} 164}
184 165
185void iwrap_call(void) 166void iwrap_call(void) {
186{
187 char *p; 167 char *p;
188 168
189 iwrap_mux_send("SET BT PAIR"); 169 iwrap_mux_send("SET BT PAIR");
@@ -193,7 +173,7 @@ void iwrap_call(void)
193 while (!strncmp(p, "SET BT PAIR", 11)) { 173 while (!strncmp(p, "SET BT PAIR", 11)) {
194 p += 7; 174 p += 7;
195 strncpy(p, "CALL", 4); 175 strncpy(p, "CALL", 4);
196 strncpy(p+22, " 11 HID\n\0", 9); 176 strncpy(p + 22, " 11 HID\n\0", 9);
197 print_S(p); 177 print_S(p);
198 iwrap_mux_send(p); 178 iwrap_mux_send(p);
199 // TODO: skip to next line 179 // TODO: skip to next line
@@ -224,20 +204,21 @@ void iwrap_call(void)
224 iwrap_check_connection(); 204 iwrap_check_connection();
225} 205}
226 206
227void iwrap_kill(void) 207void iwrap_kill(void) {
228{
229 char c; 208 char c;
230 iwrap_mux_send("LIST"); 209 iwrap_mux_send("LIST");
231 _delay_ms(500); 210 _delay_ms(500);
232 211
233 while ((c = rcv_deq()) && c != '\n') ; 212 while ((c = rcv_deq()) && c != '\n')
213 ;
234 if (strncmp(rcv_buf + rcv_tail, "LIST ", 5)) { 214 if (strncmp(rcv_buf + rcv_tail, "LIST ", 5)) {
235 print("no connection to kill.\n"); 215 print("no connection to kill.\n");
236 return; 216 return;
237 } 217 }
238 // skip 10 'space' chars 218 // skip 10 'space' chars
239 for (uint8_t i = 10; i; i--) 219 for (uint8_t i = 10; i; i--)
240 while ((c = rcv_deq()) && c != ' ') ; 220 while ((c = rcv_deq()) && c != ' ')
221 ;
241 222
242 char *p = rcv_buf + rcv_tail - 5; 223 char *p = rcv_buf + rcv_tail - 5;
243 strncpy(p, "KILL ", 5); 224 strncpy(p, "KILL ", 5);
@@ -249,47 +230,34 @@ void iwrap_kill(void)
249 iwrap_check_connection(); 230 iwrap_check_connection();
250} 231}
251 232
252void iwrap_unpair(void) 233void iwrap_unpair(void) {
253{
254 iwrap_mux_send("SET BT PAIR"); 234 iwrap_mux_send("SET BT PAIR");
255 _delay_ms(500); 235 _delay_ms(500);
256 236
257 char *p = rcv_buf + rcv_tail; 237 char *p = rcv_buf + rcv_tail;
258 if (!strncmp(p, "SET BT PAIR", 11)) { 238 if (!strncmp(p, "SET BT PAIR", 11)) {
259 strncpy(p+29, "\n\0", 2); 239 strncpy(p + 29, "\n\0", 2);
260 print_S(p); 240 print_S(p);
261 iwrap_mux_send(p); 241 iwrap_mux_send(p);
262 } 242 }
263} 243}
264 244
265void iwrap_sleep(void) 245void iwrap_sleep(void) { iwrap_mux_send("SLEEP"); }
266{
267 iwrap_mux_send("SLEEP");
268}
269 246
270void iwrap_sniff(void) 247void iwrap_sniff(void) {}
271{
272}
273 248
274void iwrap_subrate(void) 249void iwrap_subrate(void) {}
275{
276}
277 250
278bool iwrap_failed(void) 251bool iwrap_failed(void) {
279{
280 if (strncmp(rcv_buf, "SYNTAX ERROR", 12)) 252 if (strncmp(rcv_buf, "SYNTAX ERROR", 12))
281 return true; 253 return true;
282 else 254 else
283 return false; 255 return false;
284} 256}
285 257
286uint8_t iwrap_connected(void) 258uint8_t iwrap_connected(void) { return connected; }
287{
288 return connected;
289}
290 259
291uint8_t iwrap_check_connection(void) 260uint8_t iwrap_check_connection(void) {
292{
293 iwrap_mux_send("LIST"); 261 iwrap_mux_send("LIST");
294 _delay_ms(100); 262 _delay_ms(100);
295 263
@@ -300,44 +268,31 @@ uint8_t iwrap_check_connection(void)
300 return connected; 268 return connected;
301} 269}
302 270
303
304/*------------------------------------------------------------------* 271/*------------------------------------------------------------------*
305 * Host driver 272 * Host driver
306 *------------------------------------------------------------------*/ 273 *------------------------------------------------------------------*/
307static uint8_t keyboard_leds(void); 274static uint8_t keyboard_leds(void);
308static void send_keyboard(report_keyboard_t *report); 275static void send_keyboard(report_keyboard_t *report);
309static void send_mouse(report_mouse_t *report); 276static void send_mouse(report_mouse_t *report);
310static void send_system(uint16_t data); 277static void send_system(uint16_t data);
311static void send_consumer(uint16_t data); 278static void send_consumer(uint16_t data);
312
313static host_driver_t driver = {
314 keyboard_leds,
315 send_keyboard,
316 send_mouse,
317 send_system,
318 send_consumer
319};
320
321host_driver_t *iwrap_driver(void)
322{
323 return &driver;
324}
325 279
326static uint8_t keyboard_leds(void) { 280static host_driver_t driver = {keyboard_leds, send_keyboard, send_mouse, send_system, send_consumer};
327 return 0;
328}
329 281
330static void send_keyboard(report_keyboard_t *report) 282host_driver_t *iwrap_driver(void) { return &driver; }
331{ 283
284static uint8_t keyboard_leds(void) { return 0; }
285
286static void send_keyboard(report_keyboard_t *report) {
332 if (!iwrap_connected() && !iwrap_check_connection()) return; 287 if (!iwrap_connected() && !iwrap_check_connection()) return;
333 MUX_HEADER(0x01, 0x0c); 288 MUX_HEADER(0x01, 0x0c);
334 // HID raw mode header 289 // HID raw mode header
335 xmit(0x9f); 290 xmit(0x9f);
336 xmit(0x0a); // Length 291 xmit(0x0a); // Length
337 xmit(0xa1); // DATA(Input) 292 xmit(0xa1); // DATA(Input)
338 xmit(0x01); // Report ID 293 xmit(0x01); // Report ID
339 xmit(report->mods); 294 xmit(report->mods);
340 xmit(0x00); // reserved byte(always 0) 295 xmit(0x00); // reserved byte(always 0)
341 xmit(report->keys[0]); 296 xmit(report->keys[0]);
342 xmit(report->keys[1]); 297 xmit(report->keys[1]);
343 xmit(report->keys[2]); 298 xmit(report->keys[2]);
@@ -347,16 +302,15 @@ static void send_keyboard(report_keyboard_t *report)
347 MUX_FOOTER(0x01); 302 MUX_FOOTER(0x01);
348} 303}
349 304
350static void send_mouse(report_mouse_t *report) 305static void send_mouse(report_mouse_t *report) {
351{
352#if defined(MOUSEKEY_ENABLE) || defined(PS2_MOUSE_ENABLE) || defined(POINTING_DEVICE_ENABLE) 306#if defined(MOUSEKEY_ENABLE) || defined(PS2_MOUSE_ENABLE) || defined(POINTING_DEVICE_ENABLE)
353 if (!iwrap_connected() && !iwrap_check_connection()) return; 307 if (!iwrap_connected() && !iwrap_check_connection()) return;
354 MUX_HEADER(0x01, 0x09); 308 MUX_HEADER(0x01, 0x09);
355 // HID raw mode header 309 // HID raw mode header
356 xmit(0x9f); 310 xmit(0x9f);
357 xmit(0x07); // Length 311 xmit(0x07); // Length
358 xmit(0xa1); // DATA(Input) 312 xmit(0xa1); // DATA(Input)
359 xmit(0x02); // Report ID 313 xmit(0x02); // Report ID
360 xmit(report->buttons); 314 xmit(report->buttons);
361 xmit(report->x); 315 xmit(report->x);
362 xmit(report->y); 316 xmit(report->y);
@@ -366,18 +320,14 @@ static void send_mouse(report_mouse_t *report)
366#endif 320#endif
367} 321}
368 322
369static void send_system(uint16_t data) 323static void send_system(uint16_t data) { /* not supported */ }
370{
371 /* not supported */
372}
373 324
374static void send_consumer(uint16_t data) 325static void send_consumer(uint16_t data) {
375{
376#ifdef EXTRAKEY_ENABLE 326#ifdef EXTRAKEY_ENABLE
377 static uint16_t last_data = 0; 327 static uint16_t last_data = 0;
378 uint8_t bits1 = 0; 328 uint8_t bits1 = 0;
379 uint8_t bits2 = 0; 329 uint8_t bits2 = 0;
380 uint8_t bits3 = 0; 330 uint8_t bits3 = 0;
381 331
382 if (!iwrap_connected() && !iwrap_check_connection()) return; 332 if (!iwrap_connected() && !iwrap_check_connection()) return;
383 if (data == last_data) return; 333 if (data == last_data) return;
@@ -458,9 +408,9 @@ static void send_consumer(uint16_t data)
458 408
459 MUX_HEADER(0x01, 0x07); 409 MUX_HEADER(0x01, 0x07);
460 xmit(0x9f); 410 xmit(0x9f);
461 xmit(0x05); // Length 411 xmit(0x05); // Length
462 xmit(0xa1); // DATA(Input) 412 xmit(0xa1); // DATA(Input)
463 xmit(0x03); // Report ID 413 xmit(0x03); // Report ID
464 xmit(bits1); 414 xmit(bits1);
465 xmit(bits2); 415 xmit(bits2);
466 xmit(bits3); 416 xmit(bits3);
diff --git a/tmk_core/protocol/iwrap/iwrap.h b/tmk_core/protocol/iwrap/iwrap.h
index ffaad9395..51f2b5670 100644
--- a/tmk_core/protocol/iwrap/iwrap.h
+++ b/tmk_core/protocol/iwrap/iwrap.h
@@ -22,11 +22,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
22#include <stdbool.h> 22#include <stdbool.h>
23#include "host_driver.h" 23#include "host_driver.h"
24 24
25
26/* enable iWRAP MUX mode */ 25/* enable iWRAP MUX mode */
27#define MUX_MODE 26#define MUX_MODE
28 27
29
30host_driver_t *iwrap_driver(void); 28host_driver_t *iwrap_driver(void);
31 29
32void iwrap_init(void); 30void iwrap_init(void);
@@ -36,13 +34,13 @@ void iwrap_buf_send(void);
36void iwrap_buf_add(uint8_t c); 34void iwrap_buf_add(uint8_t c);
37void iwrap_buf_del(void); 35void iwrap_buf_del(void);
38 36
39void iwrap_call(void); 37void iwrap_call(void);
40void iwrap_kill(void); 38void iwrap_kill(void);
41void iwrap_unpair(void); 39void iwrap_unpair(void);
42void iwrap_sleep(void); 40void iwrap_sleep(void);
43void iwrap_sniff(void); 41void iwrap_sniff(void);
44void iwrap_subrate(void); 42void iwrap_subrate(void);
45bool iwrap_failed(void); 43bool iwrap_failed(void);
46uint8_t iwrap_connected(void); 44uint8_t iwrap_connected(void);
47uint8_t iwrap_check_connection(void); 45uint8_t iwrap_check_connection(void);
48 46
diff --git a/tmk_core/protocol/iwrap/main.c b/tmk_core/protocol/iwrap/main.c
index 3abdce8df..7ba780ede 100644
--- a/tmk_core/protocol/iwrap/main.c
+++ b/tmk_core/protocol/iwrap/main.c
@@ -18,7 +18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
18#include <avr/interrupt.h> 18#include <avr/interrupt.h>
19#include <avr/io.h> 19#include <avr/io.h>
20//#include <avr/wdt.h> 20//#include <avr/wdt.h>
21#include "wd.h" // in order to use watchdog in interrupt mode 21#include "wd.h" // in order to use watchdog in interrupt mode
22#include <avr/sleep.h> 22#include <avr/sleep.h>
23#include <util/delay.h> 23#include <util/delay.h>
24#include <avr/power.h> 24#include <avr/power.h>
@@ -28,8 +28,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
28#include "action.h" 28#include "action.h"
29#include "iwrap.h" 29#include "iwrap.h"
30#ifdef PROTOCOL_VUSB 30#ifdef PROTOCOL_VUSB
31# include "vusb.h" 31# include "vusb.h"
32# include "usbdrv.h" 32# include "usbdrv.h"
33#endif 33#endif
34#include "uart.h" 34#include "uart.h"
35#include "suart.h" 35#include "suart.h"
@@ -38,13 +38,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
38#include "keycode.h" 38#include "keycode.h"
39#include "command.h" 39#include "command.h"
40 40
41 41static void sleep(uint8_t term);
42static void sleep(uint8_t term); 42static bool console(void);
43static bool console(void); 43static bool console_command(uint8_t c);
44static bool console_command(uint8_t c);
45static uint8_t key2asc(uint8_t key); 44static uint8_t key2asc(uint8_t key);
46 45
47
48/* 46/*
49static void set_prr(void) 47static void set_prr(void)
50{ 48{
@@ -78,37 +76,32 @@ static void pullup_pins(void)
78} 76}
79*/ 77*/
80 78
81
82#ifdef PROTOCOL_VUSB 79#ifdef PROTOCOL_VUSB
83static void disable_vusb(void) 80static void disable_vusb(void) {
84{
85 // disable interrupt & disconnect to prevent host from enumerating 81 // disable interrupt & disconnect to prevent host from enumerating
86 USB_INTR_ENABLE &= ~(1 << USB_INTR_ENABLE_BIT); 82 USB_INTR_ENABLE &= ~(1 << USB_INTR_ENABLE_BIT);
87 usbDeviceDisconnect(); 83 usbDeviceDisconnect();
88} 84}
89 85
90static void enable_vusb(void) 86static void enable_vusb(void) {
91{
92 USB_INTR_ENABLE |= (1 << USB_INTR_ENABLE_BIT); 87 USB_INTR_ENABLE |= (1 << USB_INTR_ENABLE_BIT);
93 usbDeviceConnect(); 88 usbDeviceConnect();
94} 89}
95 90
96static void init_vusb(void) 91static void init_vusb(void) {
97{
98 uint8_t i = 0; 92 uint8_t i = 0;
99 93
100 usbInit(); 94 usbInit();
101 disable_vusb(); 95 disable_vusb();
102 /* fake USB disconnect for > 250 ms */ 96 /* fake USB disconnect for > 250 ms */
103 while(--i){ 97 while (--i) {
104 _delay_ms(1); 98 _delay_ms(1);
105 } 99 }
106 enable_vusb(); 100 enable_vusb();
107} 101}
108#endif 102#endif
109 103
110void change_driver(host_driver_t *driver) 104void change_driver(host_driver_t *driver) {
111{
112 /* 105 /*
113 host_clear_keyboard_report(); 106 host_clear_keyboard_report();
114 host_swap_keyboard_report(); 107 host_swap_keyboard_report();
@@ -120,20 +113,18 @@ void change_driver(host_driver_t *driver)
120 host_set_driver(driver); 113 host_set_driver(driver);
121} 114}
122 115
123 116static bool sleeping = false;
124static bool sleeping = false; 117static bool insomniac = false; // TODO: should be false for power saving
125static bool insomniac = false; // TODO: should be false for power saving
126static uint16_t last_timer = 0; 118static uint16_t last_timer = 0;
127 119
128int main(void) 120int main(void) {
129{
130 MCUSR = 0; 121 MCUSR = 0;
131 clock_prescale_set(clock_div_1); 122 clock_prescale_set(clock_div_1);
132 WD_SET(WD_OFF); 123 WD_SET(WD_OFF);
133 124
134 // power saving: the result is worse than nothing... why? 125 // power saving: the result is worse than nothing... why?
135 //pullup_pins(); 126 // pullup_pins();
136 //set_prr(); 127 // set_prr();
137 128
138#ifdef PROTOCOL_VUSB 129#ifdef PROTOCOL_VUSB
139 disable_vusb(); 130 disable_vusb();
@@ -146,11 +137,11 @@ int main(void)
146 print("suart init\n"); 137 print("suart init\n");
147 // suart init 138 // suart init
148 // PC4: Tx Output IDLE(Hi) 139 // PC4: Tx Output IDLE(Hi)
149 PORTC |= (1<<4); 140 PORTC |= (1 << 4);
150 DDRC |= (1<<4); 141 DDRC |= (1 << 4);
151 // PC5: Rx Input(pull-up) 142 // PC5: Rx Input(pull-up)
152 PORTC |= (1<<5); 143 PORTC |= (1 << 5);
153 DDRC &= ~(1<<5); 144 DDRC &= ~(1 << 5);
154 // suart receive interrut(PC5/PCINT13) 145 // suart receive interrut(PC5/PCINT13)
155 PCMSK1 = 0b00100000; 146 PCMSK1 = 0b00100000;
156 PCICR = 0b00000010; 147 PCICR = 0b00000010;
@@ -164,18 +155,16 @@ int main(void)
164 last_timer = timer_read(); 155 last_timer = timer_read();
165 while (true) { 156 while (true) {
166#ifdef PROTOCOL_VUSB 157#ifdef PROTOCOL_VUSB
167 if (host_get_driver() == vusb_driver()) 158 if (host_get_driver() == vusb_driver()) usbPoll();
168 usbPoll();
169#endif 159#endif
170 keyboard_task(); 160 keyboard_task();
171#ifdef PROTOCOL_VUSB 161#ifdef PROTOCOL_VUSB
172 if (host_get_driver() == vusb_driver()) 162 if (host_get_driver() == vusb_driver()) vusb_transfer_keyboard();
173 vusb_transfer_keyboard();
174#endif 163#endif
175 // TODO: depricated 164 // TODO: depricated
176 if (matrix_is_modified() || console()) { 165 if (matrix_is_modified() || console()) {
177 last_timer = timer_read(); 166 last_timer = timer_read();
178 sleeping = false; 167 sleeping = false;
179 } else if (!sleeping && timer_elapsed(last_timer) > 4000) { 168 } else if (!sleeping && timer_elapsed(last_timer) > 4000) {
180 sleeping = true; 169 sleeping = true;
181 iwrap_check_connection(); 170 iwrap_check_connection();
@@ -184,7 +173,7 @@ int main(void)
184 // TODO: suspend.h 173 // TODO: suspend.h
185 if (host_get_driver() == iwrap_driver()) { 174 if (host_get_driver() == iwrap_driver()) {
186 if (sleeping && !insomniac) { 175 if (sleeping && !insomniac) {
187 _delay_ms(1); // wait for UART to send 176 _delay_ms(1); // wait for UART to send
188 iwrap_sleep(); 177 iwrap_sleep();
189 sleep(WDTO_60MS); 178 sleep(WDTO_60MS);
190 } 179 }
@@ -192,8 +181,7 @@ int main(void)
192 } 181 }
193} 182}
194 183
195static void sleep(uint8_t term) 184static void sleep(uint8_t term) {
196{
197 WD_SET(WD_IRQ, term); 185 WD_SET(WD_IRQ, term);
198 186
199 cli(); 187 cli();
@@ -207,51 +195,46 @@ static void sleep(uint8_t term)
207 WD_SET(WD_OFF); 195 WD_SET(WD_OFF);
208} 196}
209 197
210static bool console(void) 198static bool console(void) {
211{ 199 // Send to Bluetoot module WT12
212 // Send to Bluetoot module WT12 200 static bool breaked = false;
213 static bool breaked = false; 201 if (!uart_available())
214 if (!uart_available()) 202 return false;
215 return false; 203 else {
216 else { 204 uint8_t c;
217 uint8_t c; 205 c = uart_getchar();
218 c = uart_getchar(); 206 uart_putchar(c);
219 uart_putchar(c); 207 switch (c) {
220 switch (c) { 208 case 0x00: // BREAK signal
221 case 0x00: // BREAK signal 209 if (!breaked) {
222 if (!breaked) { 210 print("break(? for help): ");
223 print("break(? for help): "); 211 breaked = true;
224 breaked = true; 212 }
225 } 213 break;
226 break; 214 case '\r':
227 case '\r': 215 uart_putchar('\n');
228 uart_putchar('\n'); 216 iwrap_buf_send();
229 iwrap_buf_send(); 217 break;
230 break; 218 case '\b':
231 case '\b': 219 iwrap_buf_del();
232 iwrap_buf_del(); 220 break;
233 break; 221 default:
234 default: 222 if (breaked) {
235 if (breaked) { 223 print("\n");
236 print("\n"); 224 console_command(c);
237 console_command(c); 225 breaked = false;
238 breaked = false; 226 } else {
239 } else { 227 iwrap_buf_add(c);
240 iwrap_buf_add(c); 228 }
241 } 229 break;
242 break;
243 }
244 return true;
245 } 230 }
231 return true;
232 }
246} 233}
247 234
248bool command_extra(uint8_t code) 235bool command_extra(uint8_t code) { return console_command(key2asc(code)); }
249{
250 return console_command(key2asc(code));
251}
252 236
253static bool console_command(uint8_t c) 237static bool console_command(uint8_t c) {
254{
255 switch (c) { 238 switch (c) {
256 case 'h': 239 case 'h':
257 case '?': 240 case '?':
@@ -287,11 +270,11 @@ static bool console_command(uint8_t c)
287 print("USB mode\n"); 270 print("USB mode\n");
288 init_vusb(); 271 init_vusb();
289 change_driver(vusb_driver()); 272 change_driver(vusb_driver());
290 //iwrap_kill(); 273 // iwrap_kill();
291 //iwrap_sleep(); 274 // iwrap_sleep();
292 // disable suart receive interrut(PC5/PCINT13) 275 // disable suart receive interrut(PC5/PCINT13)
293 PCMSK1 &= ~(0b00100000); 276 PCMSK1 &= ~(0b00100000);
294 PCICR &= ~(0b00000010); 277 PCICR &= ~(0b00000010);
295 return 1; 278 return 1;
296 case 'w': 279 case 'w':
297 print("iWRAP mode\n"); 280 print("iWRAP mode\n");
@@ -299,7 +282,7 @@ static bool console_command(uint8_t c)
299 disable_vusb(); 282 disable_vusb();
300 // enable suart receive interrut(PC5/PCINT13) 283 // enable suart receive interrut(PC5/PCINT13)
301 PCMSK1 |= 0b00100000; 284 PCMSK1 |= 0b00100000;
302 PCICR |= 0b00000010; 285 PCICR |= 0b00000010;
303 return 1; 286 return 1;
304#endif 287#endif
305 case 'k': 288 case 'k':
@@ -315,62 +298,115 @@ static bool console_command(uint8_t c)
315} 298}
316 299
317// convert keycode into ascii charactor 300// convert keycode into ascii charactor
318static uint8_t key2asc(uint8_t key) 301static uint8_t key2asc(uint8_t key) {
319{
320 switch (key) { 302 switch (key) {
321 case KC_A: return 'a'; 303 case KC_A:
322 case KC_B: return 'b'; 304 return 'a';
323 case KC_C: return 'c'; 305 case KC_B:
324 case KC_D: return 'd'; 306 return 'b';
325 case KC_E: return 'e'; 307 case KC_C:
326 case KC_F: return 'f'; 308 return 'c';
327 case KC_G: return 'g'; 309 case KC_D:
328 case KC_H: return 'h'; 310 return 'd';
329 case KC_I: return 'i'; 311 case KC_E:
330 case KC_J: return 'j'; 312 return 'e';
331 case KC_K: return 'k'; 313 case KC_F:
332 case KC_L: return 'l'; 314 return 'f';
333 case KC_M: return 'm'; 315 case KC_G:
334 case KC_N: return 'n'; 316 return 'g';
335 case KC_O: return 'o'; 317 case KC_H:
336 case KC_P: return 'p'; 318 return 'h';
337 case KC_Q: return 'q'; 319 case KC_I:
338 case KC_R: return 'r'; 320 return 'i';
339 case KC_S: return 's'; 321 case KC_J:
340 case KC_T: return 't'; 322 return 'j';
341 case KC_U: return 'u'; 323 case KC_K:
342 case KC_V: return 'v'; 324 return 'k';
343 case KC_W: return 'w'; 325 case KC_L:
344 case KC_X: return 'x'; 326 return 'l';
345 case KC_Y: return 'y'; 327 case KC_M:
346 case KC_Z: return 'z'; 328 return 'm';
347 case KC_1: return '1'; 329 case KC_N:
348 case KC_2: return '2'; 330 return 'n';
349 case KC_3: return '3'; 331 case KC_O:
350 case KC_4: return '4'; 332 return 'o';
351 case KC_5: return '5'; 333 case KC_P:
352 case KC_6: return '6'; 334 return 'p';
353 case KC_7: return '7'; 335 case KC_Q:
354 case KC_8: return '8'; 336 return 'q';
355 case KC_9: return '9'; 337 case KC_R:
356 case KC_0: return '0'; 338 return 'r';
357 case KC_ENTER: return '\n'; 339 case KC_S:
358 case KC_ESCAPE: return 0x1B; 340 return 's';
359 case KC_BSPACE: return '\b'; 341 case KC_T:
360 case KC_TAB: return '\t'; 342 return 't';
361 case KC_SPACE: return ' '; 343 case KC_U:
362 case KC_MINUS: return '-'; 344 return 'u';
363 case KC_EQUAL: return '='; 345 case KC_V:
364 case KC_LBRACKET: return '['; 346 return 'v';
365 case KC_RBRACKET: return ']'; 347 case KC_W:
366 case KC_BSLASH: return '\\'; 348 return 'w';
367 case KC_NONUS_HASH: return '\\'; 349 case KC_X:
368 case KC_SCOLON: return ';'; 350 return 'x';
369 case KC_QUOTE: return '\''; 351 case KC_Y:
370 case KC_GRAVE: return '`'; 352 return 'y';
371 case KC_COMMA: return ','; 353 case KC_Z:
372 case KC_DOT: return '.'; 354 return 'z';
373 case KC_SLASH: return '/'; 355 case KC_1:
374 default: return 0x00; 356 return '1';
357 case KC_2:
358 return '2';
359 case KC_3:
360 return '3';
361 case KC_4:
362 return '4';
363 case KC_5:
364 return '5';
365 case KC_6:
366 return '6';
367 case KC_7:
368 return '7';
369 case KC_8:
370 return '8';
371 case KC_9:
372 return '9';
373 case KC_0:
374 return '0';
375 case KC_ENTER:
376 return '\n';
377 case KC_ESCAPE:
378 return 0x1B;
379 case KC_BSPACE:
380 return '\b';
381 case KC_TAB:
382 return '\t';
383 case KC_SPACE:
384 return ' ';
385 case KC_MINUS:
386 return '-';
387 case KC_EQUAL:
388 return '=';
389 case KC_LBRACKET:
390 return '[';
391 case KC_RBRACKET:
392 return ']';
393 case KC_BSLASH:
394 return '\\';
395 case KC_NONUS_HASH:
396 return '\\';
397 case KC_SCOLON:
398 return ';';
399 case KC_QUOTE:
400 return '\'';
401 case KC_GRAVE:
402 return '`';
403 case KC_COMMA:
404 return ',';
405 case KC_DOT:
406 return '.';
407 case KC_SLASH:
408 return '/';
409 default:
410 return 0x00;
375 } 411 }
376} 412}
diff --git a/tmk_core/protocol/iwrap/suart.h b/tmk_core/protocol/iwrap/suart.h
index 7d92be069..c634bbc2f 100644
--- a/tmk_core/protocol/iwrap/suart.h
+++ b/tmk_core/protocol/iwrap/suart.h
@@ -1,8 +1,8 @@
1#ifndef SUART 1#ifndef SUART
2#define SUART 2#define SUART
3 3
4void xmit(uint8_t); 4void xmit(uint8_t);
5uint8_t rcvr(void); 5uint8_t rcvr(void);
6uint8_t recv(void); 6uint8_t recv(void);
7 7
8#endif /* SUART */ 8#endif /* SUART */
diff --git a/tmk_core/protocol/iwrap/wd.h b/tmk_core/protocol/iwrap/wd.h
index 12395bf69..083d6d44d 100644
--- a/tmk_core/protocol/iwrap/wd.h
+++ b/tmk_core/protocol/iwrap/wd.h
@@ -61,55 +61,58 @@ cleared on every power up or reset, along with disabling the watchdog-
61 61
62*/ 62*/
63 63
64//reset registers to the same name (MCUCSR) 64// reset registers to the same name (MCUCSR)
65#if !defined(MCUCSR) 65#if !defined(MCUCSR)
66#define MCUCSR MCUSR 66# define MCUCSR MCUSR
67#endif 67#endif
68 68
69//watchdog registers to the same name (WDTCSR) 69// watchdog registers to the same name (WDTCSR)
70#if !defined(WDTCSR) 70#if !defined(WDTCSR)
71#define WDTCSR WDTCR 71# define WDTCSR WDTCR
72#endif 72#endif
73 73
74//if enhanced watchdog, define irq values, create disable macro 74// if enhanced watchdog, define irq values, create disable macro
75#if defined(WDIF) 75#if defined(WDIF)
76#define WD_IRQ 0xC0 76# define WD_IRQ 0xC0
77#define WD_RST_IRQ 0xC8 77# define WD_RST_IRQ 0xC8
78#define WD_DISABLE() do{ \ 78# define WD_DISABLE() \
79 MCUCSR &= ~(1<<WDRF); \ 79 do { \
80 WD_SET(WD_OFF); \ 80 MCUCSR &= ~(1 << WDRF); \
81 }while(0) 81 WD_SET(WD_OFF); \
82 } while (0)
82#endif 83#endif
83 84
84//all watchdogs 85// all watchdogs
85#define WD_RST 8 86#define WD_RST 8
86#define WD_OFF 0 87#define WD_OFF 0
87 88
88//prescale values 89// prescale values
89#define WDTO_15MS 0 90#define WDTO_15MS 0
90#define WDTO_30MS 1 91#define WDTO_30MS 1
91#define WDTO_60MS 2 92#define WDTO_60MS 2
92#define WDTO_120MS 3 93#define WDTO_120MS 3
93#define WDTO_250MS 4 94#define WDTO_250MS 4
94#define WDTO_500MS 5 95#define WDTO_500MS 5
95#define WDTO_1S 6 96#define WDTO_1S 6
96#define WDTO_2S 7 97#define WDTO_2S 7
97 98
98//prescale values for avrs with WDP3 99// prescale values for avrs with WDP3
99#if defined(WDP3) 100#if defined(WDP3)
100#define WDTO_4S 0x20 101# define WDTO_4S 0x20
101#define WDTO_8S 0x21 102# define WDTO_8S 0x21
102#endif 103#endif
103 104
104//watchdog reset 105// watchdog reset
105#define WDR() __asm__ __volatile__("wdr") 106#define WDR() __asm__ __volatile__("wdr")
106 107
107//avr reset using watchdog 108// avr reset using watchdog
108#define WD_AVR_RESET() do{ \ 109#define WD_AVR_RESET() \
109 __asm__ __volatile__("cli"); \ 110 do { \
110 WD_SET_UNSAFE(WD_RST); \ 111 __asm__ __volatile__("cli"); \
111 while(1); \ 112 WD_SET_UNSAFE(WD_RST); \
112 }while(0) 113 while (1) \
114 ; \
115 } while (0)
113 116
114/*set the watchdog- 117/*set the watchdog-
1151. save SREG 1181. save SREG
@@ -119,41 +122,40 @@ cleared on every power up or reset, along with disabling the watchdog-
1195. write watchdog value 1225. write watchdog value
1206. restore SREG (restoring irq status) 1236. restore SREG (restoring irq status)
121*/ 124*/
122#define WD_SET(val,...) \ 125#define WD_SET(val, ...) \
123 __asm__ __volatile__( \ 126 __asm__ __volatile__("in __tmp_reg__,__SREG__" \
124 "in __tmp_reg__,__SREG__" "\n\t" \ 127 "\n\t" \
125 "cli" "\n\t" \ 128 "cli" \
126 "wdr" "\n\t" \ 129 "\n\t" \
127 "sts %[wdreg],%[wden]" "\n\t" \ 130 "wdr" \
128 "sts %[wdreg],%[wdval]" "\n\t" \ 131 "\n\t" \
129 "out __SREG__,__tmp_reg__" "\n\t" \ 132 "sts %[wdreg],%[wden]" \
130 : \ 133 "\n\t" \
131 : [wdreg] "M" (&WDTCSR), \ 134 "sts %[wdreg],%[wdval]" \
132 [wden] "r" ((uint8_t)(0x18)), \ 135 "\n\t" \
133 [wdval] "r" ((uint8_t)(val|(__VA_ARGS__+0))) \ 136 "out __SREG__,__tmp_reg__" \
134 : "r0" \ 137 "\n\t" \
135) 138 : \
139 : [ wdreg ] "M"(&WDTCSR), [ wden ] "r"((uint8_t)(0x18)), [ wdval ] "r"((uint8_t)(val | (__VA_ARGS__ + 0))) \
140 : "r0")
136 141
137/*set the watchdog when I bit in SREG known to be clear- 142/*set the watchdog when I bit in SREG known to be clear-
1381. reset watchdog timer 1431. reset watchdog timer
1392. enable watchdog change 1442. enable watchdog change
1405. write watchdog value 1455. write watchdog value
141*/ 146*/
142#define WD_SET_UNSAFE(val,...) \ 147#define WD_SET_UNSAFE(val, ...) \
143 __asm__ __volatile__( \ 148 __asm__ __volatile__("wdr" \
144 "wdr" "\n\t" \ 149 "\n\t" \
145 "sts %[wdreg],%[wden]" "\n\t" \ 150 "sts %[wdreg],%[wden]" \
146 "sts %[wdreg],%[wdval]" "\n\t" \ 151 "\n\t" \
147 : \ 152 "sts %[wdreg],%[wdval]" \
148 : [wdreg] "M" (&WDTCSR), \ 153 "\n\t" \
149 [wden] "r" ((uint8_t)(0x18)), \ 154 : \
150 [wdval] "r" ((uint8_t)(val|(__VA_ARGS__+0))) \ 155 : [ wdreg ] "M"(&WDTCSR), [ wden ] "r"((uint8_t)(0x18)), [ wdval ] "r"((uint8_t)(val | (__VA_ARGS__ + 0))))
151) 156
152 157// for compatibility with avr/wdt.h
153 158#define wdt_enable(val) WD_SET(WD_RST, val)
154//for compatibility with avr/wdt.h 159#define wdt_disable() WD_SET(WD_OFF)
155#define wdt_enable(val) WD_SET(WD_RST,val)
156#define wdt_disable() WD_SET(WD_OFF)
157
158 160
159#endif /* _AVR_WD_H_ */ 161#endif /* _AVR_WD_H_ */
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-06 04:48:40 +0000