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