some minor editings
[labortage2013badge.git] / firmware / main.c
1 /* Name: main.c
2  * Project: labortage-2013-badge
3  * Author: bg (bg@das-labor.org)
4  * Creation Date: 2013-10-16
5  * Tabsize: 4
6  * Copyright: (c) 2008 by OBJECTIVE DEVELOPMENT Software GmbH, (c) Daniel Otte
7  * License: GNU GPL v3
8  * This Revision: $Id: main.c 692 2008-11-07 15:07:40Z cs $
9  */
10
11 /*
12 This example should run on most AVRs with only little changes. No special
13 hardware resources except INT0 are used. You may have to change usbconfig.h for
14 different I/O pins for USB. Please note that USB D+ must be the INT0 pin, or
15 at least be connected to INT0 as well.
16 */
17
18 #define BUTTON_PIN 4
19
20 #define SIMPLE_COUNTER 1
21 #define NO_CHECK 1
22
23 #include <stdint.h>
24 #include <string.h>
25 #include <stdbool.h>
26
27 #include <avr/io.h>
28 #include <avr/wdt.h>
29 #include <avr/eeprom.h>
30 #include <avr/interrupt.h>  /* for sei() */
31 #include <util/delay.h>     /* for _delay_ms() */
32
33 #include <avr/pgmspace.h>   /* required by usbdrv.h */
34 #include "usbdrv.h"
35 #include "requests.h"       /* The custom request numbers we use */
36 #include "hotp.h"
37 #if !SIMPLE_COUNTER
38 #include "percnt2.h"
39 #endif
40 #include "usb_keyboard_codes.h"
41
42 /* ------------------------------------------------------------------------- */
43 /* ----------------------------- USB interface ----------------------------- */
44 /* ------------------------------------------------------------------------- */
45
46 #define STATE_WAIT 0
47 #define STATE_SEND_KEY 1
48 #define STATE_RELEASE_KEY 2
49 #define STATE_NEXT 3
50
51 PROGMEM const char usbHidReportDescriptor[USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH] = {
52     0x05, 0x01,                    /* USAGE_PAGE (Generic Desktop) */
53     0x09, 0x06,                    /* USAGE (Keyboard) */
54     0xa1, 0x01,                    /* COLLECTION (Application) */
55     0x75, 0x01,                    /*   REPORT_SIZE (1) */
56     0x95, 0x08,                    /*   REPORT_COUNT (8) */
57     0x05, 0x07,                    /*   USAGE_PAGE (Keyboard)(Key Codes) */
58     0x19, 0xe0,                    /*   USAGE_MINIMUM (Keyboard LeftControl)(224) */
59     0x29, 0xe7,                    /*   USAGE_MAXIMUM (Keyboard Right GUI)(231) */
60     0x15, 0x00,                    /*   LOGICAL_MINIMUM (0) */
61     0x25, 0x01,                    /*   LOGICAL_MAXIMUM (1) */
62     0x81, 0x02,                    /*   INPUT (Data,Var,Abs) ; Modifier byte */
63     0x95, 0x01,                    /*   REPORT_COUNT (1) */
64     0x75, 0x08,                    /*   REPORT_SIZE (8) */
65     0x81, 0x03,                    /*   INPUT (Cnst,Var,Abs) ; Reserved byte */
66     0x95, 0x05,                    /*   REPORT_COUNT (5) */
67     0x75, 0x01,                    /*   REPORT_SIZE (1) */
68     0x05, 0x08,                    /*   USAGE_PAGE (LEDs) */
69     0x19, 0x01,                    /*   USAGE_MINIMUM (Num Lock) */
70     0x29, 0x05,                    /*   USAGE_MAXIMUM (Kana) */
71     0x91, 0x02,                    /*   OUTPUT (Data,Var,Abs) ; LED report */
72     0x95, 0x01,                    /*   REPORT_COUNT (1) */
73     0x75, 0x03,                    /*   REPORT_SIZE (3) */
74     0x91, 0x03,                    /*   OUTPUT (Cnst,Var,Abs) ; LED report padding */
75     0x95, 0x06,                    /*   REPORT_COUNT (6) */
76     0x75, 0x08,                    /*   REPORT_SIZE (8) */
77     0x15, 0x00,                    /*   LOGICAL_MINIMUM (0) */
78     0x25, 0x65,                    /*   LOGICAL_MAXIMUM (101) */
79     0x05, 0x07,                    /*   USAGE_PAGE (Keyboard)(Key Codes) */
80     0x19, 0x00,                    /*   USAGE_MINIMUM (Reserved (no event indicated))(0) */
81     0x29, 0x65,                    /*   USAGE_MAXIMUM (Keyboard Application)(101) */
82     0x81, 0x00,                    /*   INPUT (Data,Ary,Abs) */
83     0xc0                           /* END_COLLECTION */
84 };
85
86 static uint16_t secret_length_ee EEMEM = 0;
87 static uint8_t  secret_ee[32] EEMEM;
88 static uint8_t  reset_counter_ee EEMEM = 0;
89 static uint8_t  digits_ee EEMEM = 8;
90
91 #if SIMPLE_COUNTER
92 static uint32_t counter_ee EEMEM = 0;
93 #endif
94
95 static uint8_t dbg_buffer[8];
96 static uint8_t secret[32];
97 static uint16_t secret_length_b;
98 static char token[10];
99
100 #define UNI_BUFFER_SIZE 16
101
102 static union __attribute__((packed)) {
103         uint8_t  w8[UNI_BUFFER_SIZE];
104         uint16_t w16[UNI_BUFFER_SIZE/2];
105         uint32_t w32[UNI_BUFFER_SIZE/4];
106         void*    ptr[UNI_BUFFER_SIZE/sizeof(void*)];
107 } uni_buffer;
108
109 static uint8_t current_command;
110
111 typedef struct __attribute__((packed)) {
112     uint8_t modifier;
113     uint8_t reserved;
114     uint8_t keycode[6];
115 } keyboard_report_t;
116
117 static keyboard_report_t keyboard_report; /* report sent to the host */
118 static uchar idleRate;  /* in 4 ms units */
119 static uchar key_state = STATE_WAIT;
120 volatile static uchar LED_state = 0xff;
121 /* ------------------------------------------------------------------------- */
122
123 static
124 void memory_clean(void) {
125     memset(secret, 0, 32);
126     secret_length_b = 0;
127 }
128
129 static
130 uint8_t secret_set(void){
131 #if !NO_CHECK
132     uint8_t r;
133     union {
134         uint8_t w8[32];
135         uint16_t w16[16];
136     } read_back;
137 #endif
138     const uint8_t length_B = (secret_length_b + 7) / 8;
139
140     eeprom_busy_wait();
141     eeprom_write_block(secret, secret_ee, length_B);
142 #if !NO_CHECK
143     eeprom_busy_wait();
144     eeprom_read_block(read_back.w8, secret_ee, length_B);
145     r = memcmp(secret, read_back.w8, length_B);
146     memory_clean();
147     memset(read_back.w8, 0, 32);
148     if (r) {
149         return 1;
150     }
151 #endif
152     eeprom_busy_wait();
153     eeprom_write_word(&secret_length_ee, secret_length_b);
154 #if !NO_CHECK
155     eeprom_busy_wait();
156     r = eeprom_read_word(&secret_length_ee) == secret_length_b;
157     memory_clean();
158     *read_back.w16 = 0;
159     if (!r) {
160         return 1;
161     }
162 #else
163     memory_clean();
164 #endif
165
166     return 0;
167 }
168
169 static
170 void counter_inc(void){
171 #if SIMPLE_COUNTER
172     uint32_t t;
173     eeprom_busy_wait();
174     t = eeprom_read_dword(&counter_ee);
175     eeprom_busy_wait();
176     eeprom_write_dword(&counter_ee, t + 1);
177 #else
178     percnt_inc(0);
179 #endif
180 }
181
182 static
183 void counter_reset(void) {
184     uint8_t reset_counter;
185     eeprom_busy_wait();
186     reset_counter = eeprom_read_byte(&reset_counter_ee);
187 #if SIMPLE_COUNTER
188     eeprom_busy_wait();
189     eeprom_write_dword(&counter_ee, 0);
190 #else
191     percnt_reset(0);
192 #endif
193     eeprom_busy_wait();
194     eeprom_write_byte(&reset_counter_ee, reset_counter + 1);
195 }
196
197 static
198 void counter_init(void) {
199 #if !SIMPLE_COUNTER
200     eeprom_busy_wait();
201     if (eeprom_read_byte(&reset_counter_ee) == 0) {
202         counter_reset();
203     }
204     percnt_init(0);
205 #endif
206 }
207
208 static
209 void token_generate(void) {
210     counter_inc();
211     eeprom_busy_wait();
212     eeprom_read_block(secret, secret_ee, 32);
213     eeprom_busy_wait();
214 #if SIMPLE_COUNTER
215     hotp(token, secret, eeprom_read_word(&secret_length_ee), eeprom_read_dword(&counter_ee), eeprom_read_byte(&digits_ee));
216 #else
217     hotp(token, secret, eeprom_read_word(&secret_length_ee), percnt_get(0), eeprom_read_byte(&digits_ee));
218 #endif
219     memory_clean();
220 }
221
222
223 static
224 void buildReport(uchar send_key) {
225     keyboard_report.modifier = 0;
226
227     switch (send_key) {
228     case '1' ... '9':
229         keyboard_report.keycode[0] = KEY_1 + (send_key-'1');
230         break;
231     case '0':
232         keyboard_report.keycode[0] = KEY_0;
233         break;
234     default:
235         keyboard_report.keycode[0] = 0;
236     }
237 }
238
239 static
240 int8_t button_get_debounced(volatile uint8_t debounce_count) {
241     uint8_t v;
242     v = PINB & _BV(BUTTON_PIN);
243     while (debounce_count-- && v == (PINB & _BV(BUTTON_PIN))) {
244         ;
245     }
246     if (debounce_count) {
247         return -1;
248     }
249     return v ? 0 : 1;
250 }
251
252 usbMsgLen_t usbFunctionSetup(uchar data[8])
253 {
254         usbRequest_t    *rq = (usbRequest_t *)data;
255         if ((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS) {    /* class request type */
256             switch(rq->bRequest) {
257         case USBRQ_HID_GET_REPORT: /* send "no keys pressed" if asked here */
258             /* wValue: ReportType (highbyte), ReportID (lowbyte) */
259             usbMsgPtr = (void *)&keyboard_report; /* we only have this one */
260             keyboard_report.modifier = 0;
261             keyboard_report.keycode[0] = 0;
262             return sizeof(keyboard_report);
263         case USBRQ_HID_SET_REPORT: /* if wLength == 1, should be LED state */
264             if (rq->wLength.word == 1) {
265                 current_command = LED_WRITE;
266                 return USB_NO_MSG;
267             }
268             return 0;
269         case USBRQ_HID_GET_IDLE: /* send idle rate to PC as required by spec */
270             usbMsgPtr = &idleRate;
271             return 1;
272         case USBRQ_HID_SET_IDLE: /* save idle rate as required by spec */
273             idleRate = rq->wValue.bytes[1];
274             return 0;
275         }
276     }
277     if ((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_VENDOR) {
278                 current_command = rq->bRequest;
279         usbMsgPtr = uni_buffer.w8;
280         switch(rq->bRequest)
281                 {
282         case CUSTOM_RQ_SET_SECRET:
283             secret_length_b = rq->wValue.word;
284             if (secret_length_b > 256) {
285                 secret_length_b = 256;
286             }
287             uni_buffer.w8[0] = 0;
288             return USB_NO_MSG;
289         case CUSTOM_RQ_INC_COUNTER:
290             counter_inc();
291             return 0;
292         case CUSTOM_RQ_GET_COUNTER:
293 #if SIMPLE_COUNTER
294             eeprom_busy_wait();
295             uni_buffer.w32[0] = eeprom_read_dword(&counter_ee);
296 #else
297             uni_buffer.w32[0] = percnt_get(0);
298 #endif
299             return 4;
300         case CUSTOM_RQ_RESET_COUNTER:
301             counter_reset();
302             return 0;
303         case CUSTOM_RQ_GET_RESET_COUNTER:
304             eeprom_busy_wait();
305             uni_buffer.w8[0] = eeprom_read_byte(&reset_counter_ee);
306             return 1;
307         case CUSTOM_RQ_SET_DIGITS:
308             if (rq->wValue.bytes[0] < 6) {
309                 rq->wValue.bytes[0] = 6;
310             }
311             if (rq->wValue.bytes[0] > 9) {
312                 rq->wValue.bytes[0] = 9;
313             }
314             eeprom_busy_wait();
315             eeprom_write_byte(&digits_ee, rq->wValue.bytes[0]);
316             return 0;
317         case CUSTOM_RQ_GET_DIGITS:
318             eeprom_busy_wait();
319             uni_buffer.w8[0] = eeprom_read_byte(&digits_ee);
320             return 1;
321         case CUSTOM_RQ_GET_TOKEN:
322             token_generate();
323             usbMsgPtr = (usbMsgPtr_t)token;
324             return strlen(token);
325         case CUSTOM_RQ_PRESS_BUTTON:
326             key_state = STATE_SEND_KEY;
327             return 0;
328         case CUSTOM_RQ_CLR_DBG:
329             memset(dbg_buffer, 0, sizeof(dbg_buffer));
330             return 0;
331                 case CUSTOM_RQ_SET_DBG:
332                         return USB_NO_MSG;
333                 case CUSTOM_RQ_GET_DBG:{
334                         usbMsgLen_t len = 8;
335                         if(len > rq->wLength.word){
336                                 len = rq->wLength.word;
337                         }
338                         usbMsgPtr = dbg_buffer;
339                         return len;
340                 }
341                 case CUSTOM_RQ_RESET:
342                         soft_reset((uint8_t)(rq->wValue.word));
343                         break;
344                 case CUSTOM_RQ_READ_BUTTON:
345                         uni_buffer.w8[0] = button_get_debounced(25);
346                         return 1;
347                 }
348     }
349
350     return 0;   /* default for not implemented requests: return no data back to host */
351 }
352
353
354 uchar usbFunctionWrite(uchar *data, uchar len)
355 {
356         switch(current_command){
357
358         case LED_WRITE:
359             if (data[0] != LED_state)
360                 LED_state = data[0];
361             return 1; /* Data read, not expecting more */
362         case CUSTOM_RQ_SET_SECRET:
363         {
364             if (uni_buffer.w8[0] < (secret_length_b + 7) / 8) {
365                 memcpy(&secret[uni_buffer.w8[0]], data, len);
366                 uni_buffer.w8[0] += len;
367             }
368             if (uni_buffer.w8[0] >= (secret_length_b + 7) / 8) {
369                 secret_set();
370                 return 1;
371             }
372             return 0;
373         }
374         case CUSTOM_RQ_SET_DBG:
375                 if(len > sizeof(dbg_buffer)){
376                         len = sizeof(dbg_buffer);
377                 }
378                 memcpy(dbg_buffer, data, len);
379                 return 1;
380         default:
381                 return 1;
382         }
383         return 0;
384 }
385 uchar usbFunctionRead(uchar *data, uchar len){
386         return 0;
387 }
388
389 static void calibrateOscillator(void)
390 {
391 uchar       step = 128;
392 uchar       trialValue = 0, optimumValue;
393 int         x, optimumDev, targetValue = (unsigned)(1499 * (double)F_CPU / 10.5e6 + 0.5);
394  
395     /* do a binary search: */
396     do {
397         OSCCAL = trialValue + step;
398         x = usbMeasureFrameLength();    /* proportional to current real frequency */
399         if(x < targetValue)             /* frequency still too low */
400             trialValue += step;
401         step >>= 1;
402     } while(step > 0);
403     /* We have a precision of +/- 1 for optimum OSCCAL here */
404     /* now do a neighborhood search for optimum value */
405     optimumValue = trialValue;
406     optimumDev = x; /* this is certainly far away from optimum */
407     for (OSCCAL = trialValue - 1; OSCCAL <= trialValue + 1; OSCCAL++){
408         x = usbMeasureFrameLength() - targetValue;
409         if (x < 0)
410             x = -x;
411         if (x < optimumDev) {
412             optimumDev = x;
413             optimumValue = OSCCAL;
414         }
415     }
416     OSCCAL = optimumValue;
417 }
418  
419
420 void usbEventResetReady(void)
421 {
422     cli();  /* usbMeasureFrameLength() counts CPU cycles, so disable interrupts. */
423     calibrateOscillator();
424     sei();
425 }
426
427 /* ------------------------------------------------------------------------- */
428
429 int main(void)
430 {
431         size_t idx = 0;
432         int8_t i = 0, last_stable_button_state = 0;
433
434     wdt_enable(WDTO_1S);
435     /* Even if you don't use the watchdog, turn it off here. On newer devices,
436      * the status of the watchdog (on/off, period) is PRESERVED OVER RESET!
437      */
438     /* RESET status: all port bits are inputs without pull-up.
439      * That's the way we need D+ and D-. Therefore we don't need any
440      * additional hardware initialization.
441      */
442
443     DDRB &= ~_BV(BUTTON_PIN); /* make button pin input */
444     PORTB |= _BV(BUTTON_PIN); /* turn on pull-up resistor */
445     counter_init();
446     usbInit();
447     usbDeviceDisconnect();  /* enforce re-enumeration, do this while interrupts are disabled! */
448     while(--i){             /* fake USB disconnect for ~512 ms */
449         wdt_reset();
450         _delay_ms(2);
451     }
452     usbDeviceConnect();
453         
454     sei();
455
456     for(;;){                /* main event loop */
457         wdt_reset();
458         usbPoll();
459
460         i = button_get_debounced(25);
461         if (i != -1) {
462             if (last_stable_button_state == 0 && i == 1) {
463                 key_state = STATE_SEND_KEY;
464             }
465             last_stable_button_state = i;
466         }
467
468         if(usbInterruptIsReady() && key_state != STATE_WAIT){
469             switch(key_state) {
470             case STATE_SEND_KEY:
471                 buildReport(token[idx]);
472                 key_state = STATE_RELEASE_KEY; /* release next */
473                 break;
474             case STATE_RELEASE_KEY:
475                 buildReport(0);
476                 ++idx;
477                 if (token[idx] == '\0') {
478                     idx = 0;
479                     key_state = STATE_WAIT;
480                 } else {
481                     key_state = STATE_SEND_KEY;
482                 }
483                 break;
484             default:
485                 key_state = STATE_WAIT; /* should not happen */
486             }
487                         /* start sending */
488             usbSetInterrupt((void *)&keyboard_report, sizeof(keyboard_report));
489
490         }
491
492     }
493     return 0;
494 }
495
496 /* ------------------------------------------------------------------------- */