e02dfc5c21741973796c9625bf957761d29461c6
[gnuk/gnuk.git] / src / usb-icc.c
1 /*
2  * usb-icc.c -- USB CCID/ICCD protocol handling
3  *
4  * Copyright (C) 2010 Free Software Initiative of Japan
5  * Author: NIIBE Yutaka <gniibe@fsij.org>
6  *
7  * This file is a part of Gnuk, a GnuPG USB Token implementation.
8  *
9  * Gnuk is free software: you can redistribute it and/or modify it
10  * under the terms of the GNU General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * Gnuk is distributed in the hope that it will be useful, but WITHOUT
15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
17  * License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
21  *
22  */
23
24 #include "config.h"
25 #include "ch.h"
26 #include "hal.h"
27 #include "gnuk.h"
28 #include "usb_lib.h"
29 #include "usb_desc.h"
30 #include "usb_mem.h"
31 #include "hw_config.h"
32 #include "usb_istr.h"
33
34 extern void *memmove(void *dest, const void *src, size_t n);
35
36 #define ICC_SET_PARAMS          0x61 /* non-ICCD command  */
37 #define ICC_POWER_ON            0x62
38 #define ICC_POWER_OFF           0x63
39 #define ICC_SLOT_STATUS         0x65 /* non-ICCD command */
40 #define ICC_GET_PARAMS          0x6C /* non-ICCD command */
41 #define ICC_XFR_BLOCK           0x6F
42 #define ICC_DATA_BLOCK_RET      0x80
43 #define ICC_SLOT_STATUS_RET     0x81 /* non-ICCD result */
44 #define ICC_PARAMS_RET          0x82 /* non-ICCD result */
45
46 #define ICC_MSG_SEQ_OFFSET      6
47 #define ICC_MSG_STATUS_OFFSET   7
48 #define ICC_MSG_ERROR_OFFSET    8
49 #define ICC_MSG_CHAIN_OFFSET    9
50 #define ICC_MSG_DATA_OFFSET     10      /* == ICC_MSG_HEADER_SIZE */
51 #define ICC_MAX_MSG_DATA_SIZE   (USB_BUF_SIZE - ICC_MSG_HEADER_SIZE)
52
53 #define ICC_STATUS_RUN          0x00
54 #define ICC_STATUS_PRESENT      0x01
55 #define ICC_STATUS_NOTPRESENT   0x02
56 #define ICC_CMD_STATUS_OK       0x00
57 #define ICC_CMD_STATUS_ERROR    0x40
58 #define ICC_CMD_STATUS_TIMEEXT  0x80
59
60 #define ICC_ERROR_XFR_OVERRUN   0xFC
61
62 /*
63  * Since command-byte is at offset 0,
64  * error with offset 0 means "command not supported".
65  */
66 #define ICC_OFFSET_CMD_NOT_SUPPORTED 0
67 #define ICC_OFFSET_PARAM 8
68
69 struct icc_header {
70   uint8_t msg_type;
71   int32_t data_len;
72   uint8_t slot;
73   uint8_t seq;
74   uint8_t rsvd;
75   uint16_t param;
76 } __attribute__((packed));
77
78 int icc_data_size;
79
80 /*
81  * USB-ICC communication could be considered "half duplex".
82  *
83  * While the device is sending something, there is no possibility for
84  * the device to receive anything.
85  *
86  * While the device is receiving something, there is no possibility
87  * for the device to send anything.
88  * 
89  * Thus, the buffer can be shared for RX and TX.
90  */
91
92 /*
93  * Buffer of USB communication: for both of RX and TX
94  *
95  * The buffer will be filled by multiple RX transactions (Bulk-OUT)
96  * or will be used for multiple TX transactions (Bulk-IN)
97  */
98 uint8_t icc_buffer[USB_BUF_SIZE];
99 uint8_t icc_seq;
100
101 /*
102  * Pointer to ICC_BUFFER
103  */
104 static uint8_t *icc_next_p;
105
106 /*
107  * Chain pointer: This implementation support two packets in chain (not more)
108  */
109 static uint8_t *icc_chain_p;
110
111 /*
112  * Whole size of TX transfer (Bulk-IN transactions)
113  */
114 static int icc_tx_size;
115
116 static Thread *icc_thread;
117
118 #define EV_RX_DATA_READY (eventmask_t)1  /* USB Rx data available  */
119 /* EV_EXEC_FINISHED == 2 */
120 #define EV_TX_FINISHED (eventmask_t)4  /* USB Tx finished  */
121
122 /*
123  * Tx done callback
124  */
125 void
126 EP1_IN_Callback (void)
127 {
128   if (icc_next_p == NULL)
129     /* The sequence of Bulk-IN transactions finished */
130     chEvtSignalI (icc_thread, EV_TX_FINISHED);
131   else if (icc_next_p == &icc_buffer[icc_tx_size])
132     /* It was multiple of USB_LL_BUF_SIZE */
133     {
134       /* Send the last 0-DATA transcation of Bulk-IN in the transactions */
135       icc_next_p = NULL;
136       USB_SIL_Write (EP1_IN, icc_buffer, 0);
137       SetEPTxValid (ENDP1);
138     }
139   else
140     {
141       int tx_size = USB_LL_BUF_SIZE;
142       uint8_t *p = icc_next_p;
143
144       icc_next_p += USB_LL_BUF_SIZE;
145       if (icc_next_p > &icc_buffer[icc_tx_size])
146         {
147           icc_next_p = NULL;
148           tx_size = &icc_buffer[icc_tx_size] - p;
149         }
150
151       USB_SIL_Write (EP1_IN, p, tx_size);
152       SetEPTxValid (ENDP1);
153     }
154 }
155
156 static void
157 icc_prepare_receive (int chain)
158 {
159   if (chain)
160     icc_next_p = icc_chain_p;
161   else
162     icc_next_p = icc_buffer;
163
164   SetEPRxValid (ENDP2);
165 }
166
167 /*
168  * Rx ready callback
169  */
170 void
171 EP2_OUT_Callback (void)
172 {
173   int len;
174
175   len = USB_SIL_Read (EP2_OUT, icc_next_p);
176
177   if (len == USB_LL_BUF_SIZE) /* The sequence of transactions continues */
178     {
179       icc_next_p += USB_LL_BUF_SIZE;
180       SetEPRxValid (ENDP2);
181       if ((icc_next_p - icc_buffer) >= USB_BUF_SIZE)
182         /* No room to receive any more */
183         {
184           DEBUG_INFO ("ERR0F\r\n");
185           icc_next_p -= USB_LL_BUF_SIZE; /* Just for not overrun the buffer */
186           /*
187            * Receive until the end of the sequence
188            * (and discard the whole block)
189            */
190         }
191     }
192   else                          /* Finished */
193     {
194       struct icc_header *icc_header;
195       int data_len;
196
197       icc_next_p += len;
198       if (icc_chain_p)
199         {
200           icc_header = (struct icc_header *)icc_chain_p;
201           icc_data_size = (icc_next_p - icc_chain_p) - ICC_MSG_HEADER_SIZE;
202         }
203       else
204         {
205           icc_header = (struct icc_header *)icc_buffer;
206           icc_data_size = (icc_next_p - icc_buffer) - ICC_MSG_HEADER_SIZE;
207         }
208
209       /* NOTE: We're little endian, nothing to convert */
210       data_len = icc_header->data_len;
211       icc_seq = icc_header->seq;
212
213       if (icc_data_size != data_len)
214         {
215           DEBUG_INFO ("ERR0E\r\n");
216           /* Ignore the whole block */
217           icc_chain_p = NULL;
218           icc_prepare_receive (0);
219         }
220       else
221         /* Notify icc_thread */
222         chEvtSignalI (icc_thread, EV_RX_DATA_READY);
223     }
224 }
225
226 enum icc_state
227 {
228   ICC_STATE_START,              /* Initial */
229   ICC_STATE_WAIT,               /* Waiting APDU */
230                                 /* Busy1, Busy2, Busy3, Busy5 */
231   ICC_STATE_EXECUTE,            /* Busy4 */
232   ICC_STATE_RECEIVE,            /* APDU Received Partially */
233   /* Not used */
234   ICC_STATE_SEND,               /* APDU Sent Partially */
235 };
236
237 static enum icc_state icc_state;
238
239 /*
240  * ATR (Answer To Reset) string
241  *
242  * TS = 0x3B: Direct conversion
243  * T0 = 0x94: TA1 and TD1 follow, 4 historical bytes
244  * TA1 = 0x11: FI=1, DI=1
245  * TD1 = 0x81: TD2 follows, T=1
246  * TD2 = 0x31: TA3 and TB3 follow, T=1
247  * TA3 = 0xFE: IFSC = 254 bytes
248  * TB3 = 0x55: BWI = 5, CWI = 5   (BWT timeout 3.2 sec)
249  * Historical bytes: "FSIJ"
250  * XOR check
251  *
252  */
253 static const char ATR[] = {
254   0x3B, 0x94, 0x11, 0x81, 0x31, 0xFE, 0x55,
255  'F', 'S', 'I', 'J',
256  (0x94^0x11^0x81^0x31^0xFE^0x55^'F'^'S'^'I'^'J')
257 };
258
259 /*
260  * Send back error
261  */
262 void
263 icc_error (int offset)
264 {
265   uint8_t *icc_reply;
266
267   if (icc_chain_p)
268     icc_reply = icc_chain_p;
269   else
270     icc_reply = icc_buffer;
271
272   icc_reply[0] = ICC_SLOT_STATUS_RET; /* Any value should be OK */
273   icc_reply[1] = 0x00;
274   icc_reply[2] = 0x00;
275   icc_reply[3] = 0x00;
276   icc_reply[4] = 0x00;
277   icc_reply[5] = 0x00;  /* Slot */
278   icc_reply[ICC_MSG_SEQ_OFFSET] = icc_seq;
279   if (icc_state == ICC_STATE_START)
280     /* 1: ICC present but not activated 2: No ICC present */
281     icc_reply[ICC_MSG_STATUS_OFFSET] = 1;
282   else
283     /* An ICC is present and active */
284     icc_reply[ICC_MSG_STATUS_OFFSET] = 0;
285   icc_reply[ICC_MSG_STATUS_OFFSET] |= ICC_CMD_STATUS_ERROR; /* Failed */
286   icc_reply[ICC_MSG_ERROR_OFFSET] = offset;
287   icc_reply[ICC_MSG_CHAIN_OFFSET] = 0x00;
288
289   icc_next_p = NULL;    /* This is a single transaction Bulk-IN */
290   icc_tx_size = ICC_MSG_HEADER_SIZE;
291   USB_SIL_Write (EP1_IN, icc_reply, icc_tx_size);
292   SetEPTxValid (ENDP1);
293 }
294
295 static Thread *gpg_thread;
296 static WORKING_AREA(waGPGthread, 128*16);
297 extern msg_t GPGthread (void *arg);
298
299
300 /* Send back ATR (Answer To Reset) */
301 enum icc_state
302 icc_power_on (void)
303 {
304   int size_atr;
305
306   if (gpg_thread == NULL)
307     gpg_thread = chThdCreateStatic (waGPGthread, sizeof(waGPGthread),
308                                     NORMALPRIO, GPGthread, (void *)icc_thread);
309
310   size_atr = sizeof (ATR);
311   icc_buffer[0] = ICC_DATA_BLOCK_RET;
312   icc_buffer[1] = size_atr;
313   icc_buffer[2] = 0x00;
314   icc_buffer[3] = 0x00;
315   icc_buffer[4] = 0x00;
316   icc_buffer[5] = 0x00; /* Slot */
317   icc_buffer[ICC_MSG_SEQ_OFFSET] = icc_seq;
318   icc_buffer[ICC_MSG_STATUS_OFFSET] = 0x00;
319   icc_buffer[ICC_MSG_ERROR_OFFSET] = 0x00;
320   icc_buffer[ICC_MSG_CHAIN_OFFSET] = 0x00;
321   memcpy (&icc_buffer[ICC_MSG_DATA_OFFSET], ATR, size_atr);
322
323   icc_next_p = NULL;    /* This is a single transaction Bulk-IN */
324   icc_tx_size = ICC_MSG_HEADER_SIZE + size_atr;
325   USB_SIL_Write (EP1_IN, icc_buffer, icc_tx_size);
326   SetEPTxValid (ENDP1);
327   DEBUG_INFO ("ON\r\n");
328
329   return ICC_STATE_WAIT;
330 }
331
332 static void
333 icc_send_status (void)
334 {
335   uint8_t *icc_reply;
336
337   if (icc_chain_p)
338     icc_reply = icc_chain_p;
339   else
340     icc_reply = icc_buffer;
341
342   icc_reply[0] = ICC_SLOT_STATUS_RET;
343   icc_reply[1] = 0x00;
344   icc_reply[2] = 0x00;
345   icc_reply[3] = 0x00;
346   icc_reply[4] = 0x00;
347   icc_reply[5] = 0x00;  /* Slot */
348   icc_reply[ICC_MSG_SEQ_OFFSET] = icc_seq;
349   if (icc_state == ICC_STATE_START)
350     /* 1: ICC present but not activated 2: No ICC present */
351     icc_reply[ICC_MSG_STATUS_OFFSET] = 1;
352   else
353     /* An ICC is present and active */
354     icc_reply[ICC_MSG_STATUS_OFFSET] = 0;
355   icc_reply[ICC_MSG_ERROR_OFFSET] = 0x00;
356   icc_reply[ICC_MSG_CHAIN_OFFSET] = 0x00;
357
358   icc_next_p = NULL;    /* This is a single transaction Bulk-IN */
359   icc_tx_size = ICC_MSG_HEADER_SIZE;
360   USB_SIL_Write (EP1_IN, icc_reply, icc_tx_size);
361   SetEPTxValid (ENDP1);
362
363 #ifdef DEBUG_MORE
364   DEBUG_INFO ("St\r\n");
365 #endif
366 }
367
368 enum icc_state
369 icc_power_off (void)
370 {
371   if (gpg_thread)
372     {
373       chThdTerminate (gpg_thread);
374       chThdWait (gpg_thread);
375       gpg_thread = NULL;
376     }
377
378   icc_send_status ();
379   DEBUG_INFO ("OFF\r\n");
380   return ICC_STATE_START;
381 }
382
383 int res_APDU_size;
384
385 static void
386 icc_send_data_block_filling_header (int len)
387 {
388   int tx_size = USB_LL_BUF_SIZE;
389   uint8_t *p = icc_buffer;
390
391   icc_buffer[0] = ICC_DATA_BLOCK_RET;
392   icc_buffer[1] = len & 0xFF;
393   icc_buffer[2] = (len >> 8)& 0xFF;
394   icc_buffer[3] = (len >> 16)& 0xFF;
395   icc_buffer[4] = (len >> 24)& 0xFF;
396   icc_buffer[5] = 0x00; /* Slot */
397   icc_buffer[ICC_MSG_SEQ_OFFSET] = icc_seq;
398   icc_buffer[ICC_MSG_STATUS_OFFSET] = 0;
399   icc_buffer[ICC_MSG_ERROR_OFFSET] = 0;
400   icc_buffer[ICC_MSG_CHAIN_OFFSET] = 0;
401
402   icc_tx_size = ICC_MSG_HEADER_SIZE + len;
403   icc_next_p = icc_buffer + USB_LL_BUF_SIZE;
404   if (icc_next_p > &icc_buffer[icc_tx_size])
405     {
406       icc_next_p = NULL;
407       tx_size = &icc_buffer[icc_tx_size] - p;
408     }
409
410   USB_SIL_Write (EP1_IN, p, tx_size);
411   SetEPTxValid (ENDP1);
412 #ifdef DEBUG_MORE
413   DEBUG_INFO ("DATA\r\n");
414 #endif
415 }
416
417 static void
418 icc_send_data_block (uint8_t status, uint8_t chain)
419 {
420   uint8_t *icc_reply;
421
422   if (icc_chain_p)
423     icc_reply = icc_chain_p;
424   else
425     icc_reply = icc_buffer;
426
427   icc_reply[0] = ICC_DATA_BLOCK_RET;
428   icc_reply[1] = 0x00;
429   icc_reply[2] = 0x00;
430   icc_reply[3] = 0x00;
431   icc_reply[4] = 0x00;
432   icc_reply[5] = 0x00;  /* Slot */
433   icc_reply[ICC_MSG_SEQ_OFFSET] = icc_seq;
434   icc_reply[ICC_MSG_STATUS_OFFSET] = status;
435   icc_reply[ICC_MSG_ERROR_OFFSET] = 0x00;
436   icc_reply[ICC_MSG_CHAIN_OFFSET] = chain;
437
438   icc_next_p = NULL;    /* This is a single transaction Bulk-IN */
439   icc_tx_size = ICC_MSG_HEADER_SIZE;
440   USB_SIL_Write (EP1_IN, icc_reply, icc_tx_size);
441   SetEPTxValid (ENDP1);
442 #ifdef DEBUG_MORE
443   DEBUG_INFO ("DATA\r\n");
444 #endif
445 }
446
447
448 static void
449 icc_send_params (void)
450 {
451   icc_buffer[0] = ICC_PARAMS_RET;
452   icc_buffer[1] = 0x07; /* Length = 0x00000007 */
453   icc_buffer[2] = 0;
454   icc_buffer[3] = 0;
455   icc_buffer[4] = 0;
456   icc_buffer[5] = 0x00; /* Slot */
457   icc_buffer[ICC_MSG_SEQ_OFFSET] = icc_seq;
458   icc_buffer[ICC_MSG_STATUS_OFFSET] = 0;
459   icc_buffer[ICC_MSG_ERROR_OFFSET] = 0;
460   icc_buffer[ICC_MSG_CHAIN_OFFSET] = 0x01;  /* ProtocolNum: T=1 */
461   icc_buffer[ICC_MSG_DATA_OFFSET] = 0x11;   /* bmFindexDindex */
462   icc_buffer[ICC_MSG_DATA_OFFSET+1] = 0x11; /* bmTCCKST1 */
463   icc_buffer[ICC_MSG_DATA_OFFSET+2] = 0xFE; /* bGuardTimeT1 */
464   icc_buffer[ICC_MSG_DATA_OFFSET+3] = 0x55; /* bmWaitingIntegersT1 */
465   icc_buffer[ICC_MSG_DATA_OFFSET+4] = 0x03; /* bClockStop */
466   icc_buffer[ICC_MSG_DATA_OFFSET+5] = 0xFE; /* bIFSC */
467   icc_buffer[ICC_MSG_DATA_OFFSET+6] = 0;    /* bNadValue */
468
469   icc_next_p = NULL;    /* This is a single transaction Bulk-IN */
470   icc_tx_size = ICC_MSG_HEADER_SIZE + 7;
471   USB_SIL_Write (EP1_IN, icc_buffer, icc_tx_size);
472   SetEPTxValid (ENDP1);
473 #ifdef DEBUG_MORE
474   DEBUG_INFO ("DATA\r\n");
475 #endif
476 }
477
478 static enum icc_state
479 icc_handle_data (void)
480 {
481   enum icc_state next_state = icc_state;
482   struct icc_header *icc_header;
483
484   if (icc_chain_p)
485     icc_header = (struct icc_header *)icc_chain_p;
486   else
487     icc_header = (struct icc_header *)icc_buffer;
488
489   switch (icc_state)
490     {
491     case ICC_STATE_START:
492       if (icc_header->msg_type == ICC_POWER_ON)
493         next_state = icc_power_on ();
494       else if (icc_header->msg_type == ICC_POWER_OFF)
495         next_state = icc_power_off ();
496       else if (icc_header->msg_type == ICC_SLOT_STATUS)
497         icc_send_status ();
498       else
499         {
500           DEBUG_INFO ("ERR01\r\n");
501           icc_error (ICC_OFFSET_CMD_NOT_SUPPORTED);
502         }
503       break;
504     case ICC_STATE_WAIT:
505       if (icc_header->msg_type == ICC_POWER_ON)
506         /* Not in the spec., but pcscd/libccid */
507         next_state = icc_power_on ();
508       else if (icc_header->msg_type == ICC_POWER_OFF)
509         next_state = icc_power_off ();
510       else if (icc_header->msg_type == ICC_SLOT_STATUS)
511         icc_send_status ();
512       else if (icc_header->msg_type == ICC_XFR_BLOCK)
513         {
514           if (icc_header->param == 0)
515             {                   /* Give this message to GPG thread */
516               chEvtSignal (gpg_thread, (eventmask_t)1);
517               next_state = ICC_STATE_EXECUTE;
518               chEvtSignal (blinker_thread, EV_LED_ON);
519             }
520           else if (icc_header->param == 1)
521             {
522               icc_chain_p = icc_next_p;
523               icc_send_data_block (0, 0x10);
524               next_state = ICC_STATE_RECEIVE;
525             }
526           else
527             {
528               DEBUG_INFO ("ERR02\r\n");
529               icc_error (ICC_OFFSET_PARAM);
530             }
531         }
532       else if (icc_header->msg_type == ICC_SET_PARAMS
533                || icc_header->msg_type == ICC_GET_PARAMS)
534         icc_send_params ();
535       else
536         {
537           DEBUG_INFO ("ERR03\r\n");
538           DEBUG_BYTE (icc_header->msg_type);
539           icc_error (ICC_OFFSET_CMD_NOT_SUPPORTED);
540         }
541       break;
542     case ICC_STATE_RECEIVE:
543       if (icc_header->msg_type == ICC_POWER_OFF)
544         {
545           icc_chain_p = NULL;
546           next_state = icc_power_off ();
547         }
548       else if (icc_header->msg_type == ICC_SLOT_STATUS)
549         icc_send_status ();
550       else if (icc_header->msg_type == ICC_XFR_BLOCK)
551         {
552           if (icc_header->param == 2) /* Got the final block */
553             {                   /* Give this message to GPG thread */
554               int len = icc_next_p - icc_chain_p - ICC_MSG_HEADER_SIZE;
555
556               memmove (icc_chain_p, icc_chain_p + ICC_MSG_HEADER_SIZE, len);
557               icc_next_p -= ICC_MSG_HEADER_SIZE;
558               icc_data_size = icc_next_p - icc_buffer - ICC_MSG_HEADER_SIZE;
559               icc_chain_p = NULL;
560               next_state = ICC_STATE_EXECUTE;
561               chEvtSignal (blinker_thread, EV_LED_ON);
562               chEvtSignal (gpg_thread, (eventmask_t)1);
563             }
564           else                  /* icc_header->param == 3 is not supported. */
565             {
566               DEBUG_INFO ("ERR08\r\n");
567               icc_error (ICC_OFFSET_PARAM);
568             }
569         }
570       else
571         {
572           DEBUG_INFO ("ERR05\r\n");
573           DEBUG_BYTE (icc_header->msg_type);
574           icc_chain_p = NULL;
575           icc_error (ICC_OFFSET_CMD_NOT_SUPPORTED);
576           next_state = ICC_STATE_WAIT;
577         }
578       break;
579     case ICC_STATE_EXECUTE:
580       if (icc_header->msg_type == ICC_POWER_OFF)
581         next_state = icc_power_off ();
582       else if (icc_header->msg_type == ICC_SLOT_STATUS)
583         icc_send_status ();
584       else
585         {
586           DEBUG_INFO ("ERR04\r\n");
587           DEBUG_BYTE (icc_header->msg_type);
588           icc_error (ICC_OFFSET_CMD_NOT_SUPPORTED);
589         }
590       break;
591     default:
592       next_state = ICC_STATE_START;
593       DEBUG_INFO ("ERR10\r\n");
594       break;
595     }
596
597   return next_state;
598 }
599
600 static enum icc_state
601 icc_handle_timeout (void)
602 {
603   enum icc_state next_state = icc_state;
604
605   switch (icc_state)
606     {
607     case ICC_STATE_EXECUTE:
608       icc_send_data_block (ICC_CMD_STATUS_TIMEEXT, 0);
609       break;
610     default:
611       break;
612     }
613
614   return next_state;
615 }
616
617 #define USB_ICC_TIMEOUT MS2ST(1950)
618
619 msg_t
620 USBthread (void *arg)
621 {
622   (void)arg;
623
624   icc_thread = chThdSelf ();
625   chEvtClear (ALL_EVENTS);
626
627   icc_state = ICC_STATE_START;
628
629   icc_prepare_receive (0);
630   while (1)
631     {
632       eventmask_t m;
633
634       m = chEvtWaitOneTimeout (ALL_EVENTS, USB_ICC_TIMEOUT);
635
636       if (m == EV_RX_DATA_READY)
637         icc_state = icc_handle_data ();
638       else if (m == EV_EXEC_FINISHED)
639         {
640           if (icc_state == ICC_STATE_EXECUTE)
641             {
642               chEvtSignal (blinker_thread, EV_LED_OFF);
643
644               icc_send_data_block_filling_header (res_APDU_size);
645               icc_state = ICC_STATE_WAIT;
646             }
647           else
648             {                   /* XXX: error */
649               DEBUG_INFO ("ERR07\r\n");
650             }
651         }
652       else if (m == EV_TX_FINISHED)
653         {
654           if (icc_state == ICC_STATE_START || icc_state == ICC_STATE_WAIT)
655             icc_prepare_receive (0);
656           else if (icc_state == ICC_STATE_RECEIVE)
657             icc_prepare_receive (1);
658         }
659       else                      /* Timeout */
660         icc_state = icc_handle_timeout ();
661     }
662
663   return 0;
664 }