1f875bc28e727c53ec69d044cacc639e291b8330
[gnuk/gnuk.git] / src / usb-icc.c
1 /*
2  * usb-icc.c -- USB CCID/ICCD protocol handling
3  *
4  * Copyright (C) 2010, 2011, 2012 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_lld.h"
29
30 /*
31  * USB buffer size of USB-ICC driver
32  */
33 #if MAX_RES_APDU_DATA_SIZE > MAX_CMD_APDU_DATA_SIZE
34 #define USB_BUF_SIZE (MAX_RES_APDU_DATA_SIZE+5)
35 #else
36 #define USB_BUF_SIZE (MAX_CMD_APDU_DATA_SIZE+5)
37 #endif
38
39 struct apdu apdu;
40
41 /*
42  * There are three layers in USB CCID implementation
43  *
44  *   +-------------------+
45  *   | Application Layer |
46  *   +-------------------+
47  *      ^ command APDU |
48  *      |              v response APDU
49  *   +-------------------+
50  *   |    CCID Layer     |
51  *   +-------------------+
52  *    ^ CCID PC_to_RDR  | CCID RDR_to_PC
53  *    | Message         v Message
54  *   +-------------------+
55  *   |    USB Layer      |
56  *   +-------------------+
57  *    ^ USB             | USB
58  *    | Bulk-OUT Packet v Bulk-IN Packet
59  *
60  */
61
62 /*
63  * USB layer data structures
64  */
65
66 struct ep_in {
67   uint8_t ep_num;
68   uint8_t tx_done;
69   void (*notify) (struct ep_in *epi);
70   const uint8_t *buf;
71   size_t cnt;
72   size_t buf_len;
73   void *priv;
74   void (*next_buf) (struct ep_in *epi, size_t len);
75 };
76
77 static void epi_init (struct ep_in *epi, int ep_num,
78                       void (*notify) (struct ep_in *epi), void *priv)
79 {
80   epi->ep_num = ep_num;
81   epi->tx_done = 0;
82   epi->notify = notify;
83   epi->buf = NULL;
84   epi->cnt = 0;
85   epi->buf_len = 0;
86   epi->priv = priv;
87   epi->next_buf = NULL;
88 }
89
90 struct ep_out {
91   uint8_t ep_num;
92   uint8_t err;
93   void (*notify) (struct ep_out *epo);
94   uint8_t *buf;
95   size_t cnt;
96   size_t buf_len;
97   void *priv;
98   void (*next_buf) (struct ep_out *epo, size_t len);
99   int  (*end_rx) (struct ep_out *epo, size_t orig_len);
100 };
101
102 static struct ep_out endpoint_out;
103 static struct ep_in endpoint_in;
104
105 static void epo_init (struct ep_out *epo, int ep_num,
106                       void (*notify) (struct ep_out *epo), void *priv)
107 {
108   epo->ep_num = ep_num;
109   epo->err = 0;
110   epo->notify = notify;
111   epo->buf = NULL;
112   epo->cnt = 0;
113   epo->buf_len = 0;
114   epo->priv = priv;
115   epo->next_buf = NULL;
116   epo->end_rx = NULL;
117 }
118
119 /*
120  * CCID Layer
121  */
122
123 /*
124  * Buffer of USB communication: for both of RX and TX
125  *
126  * The buffer will be filled by multiple RX packets (Bulk-OUT)
127  * or will be used for multiple TX packets (Bulk-IN)
128  */
129 static uint8_t icc_buffer[USB_BUF_SIZE];
130
131 #define ICC_SET_PARAMS          0x61 /* non-ICCD command  */
132 #define ICC_POWER_ON            0x62
133 #define ICC_POWER_OFF           0x63
134 #define ICC_SLOT_STATUS         0x65 /* non-ICCD command */
135 #define ICC_SECURE              0x69 /* non-ICCD command */
136 #define ICC_GET_PARAMS          0x6C /* non-ICCD command */
137 #define ICC_XFR_BLOCK           0x6F
138 #define ICC_DATA_BLOCK_RET      0x80
139 #define ICC_SLOT_STATUS_RET     0x81 /* non-ICCD result */
140 #define ICC_PARAMS_RET          0x82 /* non-ICCD result */
141
142 #define ICC_MSG_SEQ_OFFSET      6
143 #define ICC_MSG_STATUS_OFFSET   7
144 #define ICC_MSG_ERROR_OFFSET    8
145 #define ICC_MSG_CHAIN_OFFSET    9
146 #define ICC_MSG_DATA_OFFSET     10      /* == ICC_MSG_HEADER_SIZE */
147 #define ICC_MAX_MSG_DATA_SIZE   USB_BUF_SIZE
148
149 #define ICC_STATUS_RUN          0x00
150 #define ICC_STATUS_PRESENT      0x01
151 #define ICC_STATUS_NOTPRESENT   0x02
152 #define ICC_CMD_STATUS_OK       0x00
153 #define ICC_CMD_STATUS_ERROR    0x40
154 #define ICC_CMD_STATUS_TIMEEXT  0x80
155
156 #define ICC_ERROR_XFR_OVERRUN   0xFC
157
158 /*
159  * Since command-byte is at offset 0,
160  * error with offset 0 means "command not supported".
161  */
162 #define ICC_OFFSET_CMD_NOT_SUPPORTED 0
163 #define ICC_OFFSET_DATA_LEN 1
164 #define ICC_OFFSET_PARAM 8
165
166 struct icc_header {
167   uint8_t msg_type;
168   uint32_t data_len;
169   uint8_t slot;
170   uint8_t seq;
171   uint8_t rsvd;
172   uint16_t param;
173 } __attribute__((packed));
174
175
176 enum icc_state *icc_state_p;
177
178 /* Data structure handled by CCID layer */
179 struct ccid {
180   enum icc_state icc_state;
181   uint8_t state;
182   uint8_t *p;
183   size_t len;
184
185   uint8_t err;
186
187   struct icc_header icc_header;
188
189   uint8_t sw1sw2[2];
190   uint8_t chained_cls_ins_p1_p2[4];
191
192   Thread *icc_thread;
193   Thread *application;
194
195   /* lower layer */
196   struct ep_out *epo;
197   struct ep_in *epi;
198
199   /* upper layer */
200   struct apdu *a;
201 };
202
203 /*
204  * APDU_STATE_WAIT_COMMAND           +---------+
205  *        |           |              |         |
206  *        |           v              v         |
207  *        |      APDU_STATE_COMMAND_CHAINING --+
208  *        |                 |
209  *        v                 v
210  *      APDU_STATE_COMMAND_RECEIVED
211  *                  |
212  *                  v
213  *          ===================
214  *          | Process COMMAND |
215  *          ===================
216  *                  |
217  *                  v
218  *            +-----+----------+                  +---------+
219  *            |                |                  |         |
220  *            v                v                  v         |
221  * APDU_STATE_RESULT <---- APDU_STATE_RESULT_GET_RESPONSE --+
222  *         |
223  *         |
224  *         v
225  * APDU_STATE_WAIT_COMMAND
226  */
227
228 #define APDU_STATE_WAIT_COMMAND        0
229 #define APDU_STATE_COMMAND_CHAINING    1
230 #define APDU_STATE_COMMAND_RECEIVED    2
231 #define APDU_STATE_RESULT              3
232 #define APDU_STATE_RESULT_GET_RESPONSE 4
233
234 static void ccid_reset (struct ccid *c)
235 {
236   c->err = 0;
237   c->state = APDU_STATE_WAIT_COMMAND;
238   c->p = c->a->cmd_apdu_data;
239   c->len = MAX_CMD_APDU_DATA_SIZE;
240   c->a->cmd_apdu_data_len = 0;
241   c->a->expected_res_size = 0;
242 }
243
244 static void ccid_init (struct ccid *c, struct ep_in *epi, struct ep_out *epo,
245                        struct apdu *a, Thread *t)
246 {
247   icc_state_p = &c->icc_state;
248
249   c->icc_state = ICC_STATE_START;
250   c->state = APDU_STATE_WAIT_COMMAND;
251   /*
252    * Note: a is not yet initialized yet, we can't use c->a->cmd_apdu_data here.
253    */
254   c->p = &icc_buffer[5];
255   c->len = MAX_CMD_APDU_DATA_SIZE;
256   c->err = 0;
257   memset (&c->icc_header, 0, sizeof (struct icc_header));
258   c->sw1sw2[0] = 0x90;
259   c->sw1sw2[1] = 0x00;
260   c->icc_thread = t;
261   c->application = NULL;
262   c->epi = epi;
263   c->epo = epo;
264   c->a = a;
265 }
266
267 /*
268  * Application layer
269  */
270
271 /*
272  * USB-CCID communication could be considered "half duplex".
273  *
274  * While the device is sending something, there is no possibility for
275  * the device to receive anything.
276  *
277  * While the device is receiving something, there is no possibility
278  * for the device to send anything.
279  *
280  * Thus, the buffer can be shared for RX and TX.
281  *
282  * Exception: When we support ABORT of CCID, it is possible to receive
283  * ABORT Class Specific Request to control pipe while we are
284  * receiving/sending something at OUT/IN endpoint.
285  *
286  */
287
288 #define CMD_APDU_HEAD_SIZE 5
289
290 static void apdu_init (struct apdu *a)
291 {
292   a->seq = 0;                   /* will be set by lower layer */
293   a->cmd_apdu_head = &icc_buffer[0];
294   a->cmd_apdu_data = &icc_buffer[5];
295   a->cmd_apdu_data_len = 0;     /* will be set by lower layer */
296   a->expected_res_size = 0;     /* will be set by lower layer */
297
298   a->sw = 0x9000;                    /* will be set by upper layer */
299   a->res_apdu_data = &icc_buffer[5]; /* will be set by upper layer */
300   a->res_apdu_data_len = 0;          /* will be set by upper layer */
301 }
302
303 #define EV_RX_DATA_READY (eventmask_t)1  /* USB Rx data available  */
304 /* EV_EXEC_FINISHED == 2 */
305 #define EV_TX_FINISHED (eventmask_t)4  /* USB Tx finished  */
306
307
308 static void notify_tx (struct ep_in *epi)
309 {
310   struct ccid *c = (struct ccid *)epi->priv;
311
312   /* The sequence of Bulk-IN transactions finished */
313   chEvtSignalI (c->icc_thread, EV_TX_FINISHED);
314 }
315
316 static void no_buf (struct ep_in *epi, size_t len)
317 {
318   (void)len;
319   epi->buf = NULL;
320   epi->cnt = 0;
321   epi->buf_len = 0;
322 }
323
324 static void set_sw1sw2 (struct ep_in *epi)
325 {
326   struct ccid *c = (struct ccid *)epi->priv;
327
328   if (c->a->expected_res_size >= c->len)
329     {
330       c->sw1sw2[0] = 0x90;
331       c->sw1sw2[1] = 0x00;
332     }
333   else
334     {
335       c->sw1sw2[0] = 0x61;
336       if (c->len >= 256)
337         c->sw1sw2[1] = 0;
338       else
339         c->sw1sw2[1] = (uint8_t)c->len;
340     }
341 }
342
343 static void get_sw1sw2 (struct ep_in *epi, size_t len)
344 {
345   struct ccid *c = (struct ccid *)epi->priv;
346
347   (void)len;
348   epi->buf = c->sw1sw2;
349   epi->cnt = 0;
350   epi->buf_len = 2;
351   epi->next_buf = no_buf;
352 }
353
354
355 /*
356  * Tx done callback
357  */
358 void
359 EP1_IN_Callback (void)
360 {
361   struct ep_in *epi = &endpoint_in;
362
363   if (epi->buf == NULL)
364     if (epi->tx_done)
365       epi->notify (epi);
366     else
367       {
368         epi->tx_done = 1;
369         usb_lld_tx_enable (epi->ep_num, 0); /* send ZLP */
370       }
371   else
372     {
373       int tx_size = 0;
374       size_t remain = USB_LL_BUF_SIZE;
375       int offset = 0;
376
377       while (epi->buf)
378         if (epi->buf_len < remain)
379           {
380             usb_lld_txcpy (epi->buf, epi->ep_num, offset, epi->buf_len);
381             offset += epi->buf_len;
382             remain -= epi->buf_len;
383             tx_size += epi->buf_len;
384             epi->next_buf (epi, remain); /* Update epi->buf, cnt, buf_len */
385           }
386         else
387           {
388             usb_lld_txcpy (epi->buf, epi->ep_num, offset, remain);
389             epi->buf += remain;
390             epi->cnt += remain;
391             epi->buf_len -= remain;
392             tx_size += remain;
393             break;
394           }
395
396       if (tx_size < USB_LL_BUF_SIZE)
397         epi->tx_done = 1;
398       usb_lld_tx_enable (epi->ep_num, tx_size);
399     }
400 }
401
402
403 static void notify_icc (struct ep_out *epo)
404 {
405   struct ccid *c = (struct ccid *)epo->priv;
406
407   c->err = epo->err;
408   chEvtSignalI (c->icc_thread, EV_RX_DATA_READY);
409 }
410
411 static int end_icc_rx (struct ep_out *epo, size_t orig_len)
412 {
413   (void)orig_len;
414   if (epo->cnt < sizeof (struct icc_header))
415     /* short packet, just ignore */
416     return 1;
417
418   /* icc message with no abdata */
419   return 0;
420 }
421
422 static int end_abdata (struct ep_out *epo, size_t orig_len)
423 {
424   struct ccid *c = (struct ccid *)epo->priv;
425   size_t len = epo->cnt;
426
427   if (orig_len == USB_LL_BUF_SIZE && len < c->icc_header.data_len)
428     /* more packet comes */
429     return 1;
430
431   if (len != c->icc_header.data_len)
432     epo->err = 1;
433
434   return 0;
435 }
436
437 static int end_cmd_apdu_head (struct ep_out *epo, size_t orig_len)
438 {
439   struct ccid *c = (struct ccid *)epo->priv;
440
441   (void)orig_len;
442
443   if (epo->cnt < 4 || epo->cnt != c->icc_header.data_len)
444     {
445       epo->err = 1;
446       return 0;
447     }
448
449   if ((c->state == APDU_STATE_COMMAND_CHAINING)
450       && (c->chained_cls_ins_p1_p2[0] != (c->a->cmd_apdu_head[0] & ~0x10)
451           || c->chained_cls_ins_p1_p2[1] != c->a->cmd_apdu_head[1]
452           || c->chained_cls_ins_p1_p2[2] != c->a->cmd_apdu_head[2]
453           || c->chained_cls_ins_p1_p2[3] != c->a->cmd_apdu_head[3]))
454     /*
455      * Handling exceptional request.
456      *
457      * Host stops sending command APDU using command chaining,
458      * and start another command APDU.
459      *
460      * Discard old one, and start handling new one.
461      */
462     {
463       c->state = APDU_STATE_WAIT_COMMAND;
464       c->p = c->a->cmd_apdu_data;
465       c->len = MAX_CMD_APDU_DATA_SIZE;
466     }
467
468   if (epo->cnt == 4)
469     {
470       /* No Lc and Le */
471       c->a->cmd_apdu_data_len = 0;
472       c->a->expected_res_size = 0;
473     }
474   else if (epo->cnt == 5)
475     {
476       /* No Lc but Le */
477       c->a->cmd_apdu_data_len = 0;
478       c->a->expected_res_size = c->a->cmd_apdu_head[4];
479       if (c->a->expected_res_size == 0)
480         c->a->expected_res_size = 256;
481       c->a->cmd_apdu_head[4] = 0;
482     }
483
484   return 0;
485 }
486
487
488 static int end_nomore_data (struct ep_out *epo, size_t orig_len)
489 {
490   (void)epo;
491   if (orig_len == USB_LL_BUF_SIZE)
492     return 1;
493   else
494     return 0;
495 }
496
497
498 static int end_cmd_apdu_data (struct ep_out *epo, size_t orig_len)
499 {
500   struct ccid *c = (struct ccid *)epo->priv;
501   size_t len = epo->cnt;
502
503   if (orig_len == USB_LL_BUF_SIZE
504       && CMD_APDU_HEAD_SIZE + len < c->icc_header.data_len)
505     /* more packet comes */
506     return 1;
507
508   if (CMD_APDU_HEAD_SIZE + len != c->icc_header.data_len)
509     goto error;
510
511   if (len == c->a->cmd_apdu_head[4])
512     /* No Le field*/
513     c->a->expected_res_size = 0;
514   else if (len == (size_t)c->a->cmd_apdu_head[4] + 1)
515     {
516       /* it has Le field*/
517       c->a->expected_res_size = epo->buf[-1];
518       len--;
519     }
520   else
521     {
522     error:
523       epo->err = 1;
524       return 0;
525     }
526
527   c->a->cmd_apdu_data_len += len;
528   return 0;
529 }
530
531
532 static void nomore_data (struct ep_out *epo, size_t len)
533 {
534   (void)len;
535   epo->err = 1;
536   epo->end_rx = end_nomore_data;
537   epo->buf = NULL;
538   epo->buf_len = 0;
539   epo->cnt = 0;
540   epo->next_buf = nomore_data;
541 }
542
543 #define INS_GET_RESPONSE 0xc0
544
545 static void icc_cmd_apdu_data (struct ep_out *epo, size_t len)
546 {
547   struct ccid *c = (struct ccid *)epo->priv;
548
549   (void)len;
550   if (c->state == APDU_STATE_RESULT_GET_RESPONSE
551       && c->a->cmd_apdu_head[1] != INS_GET_RESPONSE)
552     {
553       /*
554        * Handling exceptional request.
555        *
556        * Host didn't finish receiving the whole response APDU by GET RESPONSE,
557        * but initiates another command.
558        */
559
560       c->state = APDU_STATE_WAIT_COMMAND;
561       c->p = c->a->cmd_apdu_data;
562       c->len = MAX_CMD_APDU_DATA_SIZE;
563     }
564   else if (c->state == APDU_STATE_COMMAND_CHAINING)
565     {
566       if (c->chained_cls_ins_p1_p2[0] != (c->a->cmd_apdu_head[0] & ~0x10)
567           || c->chained_cls_ins_p1_p2[1] != c->a->cmd_apdu_head[1]
568           || c->chained_cls_ins_p1_p2[2] != c->a->cmd_apdu_head[2]
569           || c->chained_cls_ins_p1_p2[3] != c->a->cmd_apdu_head[3])
570         /*
571          * Handling exceptional request.
572          *
573          * Host stops sending command APDU using command chaining,
574          * and start another command APDU.
575          *
576          * Discard old one, and start handling new one.
577          */
578         {
579           c->state = APDU_STATE_WAIT_COMMAND;
580           c->p = c->a->cmd_apdu_data;
581           c->len = MAX_CMD_APDU_DATA_SIZE;
582           c->a->cmd_apdu_data_len = 0;
583         }
584     }
585
586   epo->end_rx = end_cmd_apdu_data;
587   epo->buf = c->p;
588   epo->buf_len = c->len;
589   epo->cnt = 0;
590   epo->next_buf = nomore_data;
591 }
592
593 static void icc_abdata (struct ep_out *epo, size_t len)
594 {
595   struct ccid *c = (struct ccid *)epo->priv;
596
597   (void)len;
598   c->a->seq = c->icc_header.seq;
599   if (c->icc_header.msg_type == ICC_XFR_BLOCK)
600     {
601       c->a->seq = c->icc_header.seq;
602       epo->end_rx = end_cmd_apdu_head;
603       epo->buf = c->a->cmd_apdu_head;
604       epo->buf_len = 5;
605       epo->cnt = 0;
606       epo->next_buf = icc_cmd_apdu_data;
607     }
608   else
609     {
610       epo->end_rx = end_abdata;
611       epo->buf = c->p;
612       epo->buf_len = c->len;
613       epo->cnt = 0;
614       epo->next_buf = nomore_data;
615     }
616 }
617
618
619 static void
620 icc_prepare_receive (struct ccid *c)
621 {
622   DEBUG_INFO ("Rx ready\r\n");
623
624   c->epo->err = 0;
625   c->epo->buf = (uint8_t *)&c->icc_header;
626   c->epo->buf_len = sizeof (struct icc_header);
627   c->epo->cnt = 0;
628   c->epo->next_buf = icc_abdata;
629   c->epo->end_rx = end_icc_rx;
630   usb_lld_rx_enable (c->epo->ep_num);
631 }
632
633 /*
634  * Rx ready callback
635  */
636
637 void
638 EP1_OUT_Callback (void)
639 {
640   struct ep_out *epo = &endpoint_out;
641   size_t len = usb_lld_rx_data_len (epo->ep_num);
642   int offset = 0;
643   int cont;
644   size_t orig_len = len;
645
646   while (epo->err == 0)
647     if (len == 0)
648       break;
649     else if (len <= epo->buf_len)
650       {
651         usb_lld_rxcpy (epo->buf, epo->ep_num, offset, len);
652         epo->buf += len;
653         epo->cnt += len;
654         epo->buf_len -= len;
655         break;
656       }
657     else /* len > buf_len */
658       {
659         usb_lld_rxcpy (epo->buf, epo->ep_num, offset, epo->buf_len);
660         len -= epo->buf_len;
661         offset += epo->buf_len;
662         epo->next_buf (epo, len); /* Update epo->buf, cnt, buf_len */
663       }
664
665   /*
666    * ORIG_LEN to distingush ZLP and the end of transaction
667    *  (ORIG_LEN != USB_LL_BUF_SIZE)
668    */
669   cont = epo->end_rx (epo, orig_len);
670
671   if (cont)
672     usb_lld_rx_enable (epo->ep_num);
673   else
674     epo->notify (epo);
675 }
676
677
678 /*
679  * ATR (Answer To Reset) string
680  *
681  * TS = 0x3b: Direct conversion
682  * T0 = 0xda: TA1, TC1 and TD1 follow, 10 historical bytes
683  * TA1 = 0x11: FI=1, DI=1
684  * TC1 = 0xff
685  * TD1 = 0x81: TD2 follows, T=1
686  * TD2 = 0xb1: TA3, TB3 and TD3 follow, T=1
687  * TA3 = 0xFE: IFSC = 254 bytes
688  * TB3 = 0x55: BWI = 5, CWI = 5   (BWT timeout 3.2 sec)
689  * TD3 = 0x1f: TA4 follows, T=15
690  * TA4 = 0x03: 5V or 3.3V
691  * Historical bytes: to be explained...
692  * XOR check
693  *
694  * Minimum: 0x3b, 0x8a, 0x80, 0x01, + historical bytes, xor check
695  *
696  */
697 static const uint8_t ATR[] = {
698   0x3b, 0xda, 0x11, 0xff, 0x81, 0xb1, 0xfe, 0x55, 0x1f, 0x03,
699   0x00,
700         0x31, 0x84, /* full DF name, GET DATA, MF */
701         0x73,
702               0x80, /* DF full name */
703               0x01, /* 1-byte */
704               0x80, /* Command chaining, No extended Lc and extended Le */
705         0x00,
706         0x90, 0x00,
707  (0xda^0x11^0xff^0x81^0xb1^0xfe^0x55^0x1f^0x03
708   ^0x00^0x31^0x84^0x73^0x80^0x01^0x80^0x00^0x90^0x00)
709 };
710
711 /*
712  * Send back error
713  */
714 static void icc_error (struct ccid *c, int offset)
715 {
716   uint8_t icc_reply[ICC_MSG_HEADER_SIZE];
717
718   icc_reply[0] = ICC_SLOT_STATUS_RET; /* Any value should be OK */
719   icc_reply[1] = 0x00;
720   icc_reply[2] = 0x00;
721   icc_reply[3] = 0x00;
722   icc_reply[4] = 0x00;
723   icc_reply[5] = 0x00;  /* Slot */
724   icc_reply[ICC_MSG_SEQ_OFFSET] = c->icc_header.seq;
725   if (c->icc_state == ICC_STATE_START)
726     /* 1: ICC present but not activated 2: No ICC present */
727     icc_reply[ICC_MSG_STATUS_OFFSET] = 1;
728   else
729     /* An ICC is present and active */
730     icc_reply[ICC_MSG_STATUS_OFFSET] = 0;
731   icc_reply[ICC_MSG_STATUS_OFFSET] |= ICC_CMD_STATUS_ERROR; /* Failed */
732   icc_reply[ICC_MSG_ERROR_OFFSET] = offset;
733   icc_reply[ICC_MSG_CHAIN_OFFSET] = 0x00;
734
735   /* This is a single packet Bulk-IN transaction */
736   c->epi->buf = NULL;
737   c->epi->tx_done = 1;
738   usb_lld_write (c->epi->ep_num, icc_reply, ICC_MSG_HEADER_SIZE);
739 }
740
741 static WORKING_AREA(waGPGthread, 128*16);
742 extern msg_t GPGthread (void *arg);
743
744
745 /* Send back ATR (Answer To Reset) */
746 enum icc_state
747 icc_power_on (struct ccid *c)
748 {
749   size_t size_atr = sizeof (ATR);
750   uint8_t p[ICC_MSG_HEADER_SIZE];
751
752   if (c->application == NULL)
753     c->application = chThdCreateStatic (waGPGthread, sizeof(waGPGthread),
754                                         NORMALPRIO, GPGthread,
755                                         (void *)c->icc_thread);
756
757   p[0] = ICC_DATA_BLOCK_RET;
758   p[1] = size_atr;
759   p[2] = 0x00;
760   p[3] = 0x00;
761   p[4] = 0x00;
762   p[5] = 0x00;  /* Slot */
763   p[ICC_MSG_SEQ_OFFSET] = c->icc_header.seq;
764   p[ICC_MSG_STATUS_OFFSET] = 0x00;
765   p[ICC_MSG_ERROR_OFFSET] = 0x00;
766   p[ICC_MSG_CHAIN_OFFSET] = 0x00;
767
768   usb_lld_txcpy (p, c->epi->ep_num, 0, ICC_MSG_HEADER_SIZE);
769   usb_lld_txcpy (ATR, c->epi->ep_num, ICC_MSG_HEADER_SIZE, size_atr);
770
771   /* This is a single packet Bulk-IN transaction */
772   c->epi->buf = NULL;
773   c->epi->tx_done = 1;
774   usb_lld_tx_enable (c->epi->ep_num, ICC_MSG_HEADER_SIZE + size_atr);
775   DEBUG_INFO ("ON\r\n");
776
777   return ICC_STATE_WAIT;
778 }
779
780 static void
781 icc_send_status (struct ccid *c)
782 {
783   uint8_t icc_reply[ICC_MSG_HEADER_SIZE];
784
785   icc_reply[0] = ICC_SLOT_STATUS_RET;
786   icc_reply[1] = 0x00;
787   icc_reply[2] = 0x00;
788   icc_reply[3] = 0x00;
789   icc_reply[4] = 0x00;
790   icc_reply[5] = 0x00;  /* Slot */
791   icc_reply[ICC_MSG_SEQ_OFFSET] = c->icc_header.seq;
792   if (c->icc_state == ICC_STATE_START)
793     /* 1: ICC present but not activated 2: No ICC present */
794     icc_reply[ICC_MSG_STATUS_OFFSET] = 1;
795   else
796     /* An ICC is present and active */
797     icc_reply[ICC_MSG_STATUS_OFFSET] = 0;
798   icc_reply[ICC_MSG_ERROR_OFFSET] = 0x00;
799   icc_reply[ICC_MSG_CHAIN_OFFSET] = 0x00;
800
801   /* This is a single packet Bulk-IN transaction */
802   c->epi->buf = NULL;
803   c->epi->tx_done = 1;
804   usb_lld_write (c->epi->ep_num, icc_reply, ICC_MSG_HEADER_SIZE);
805
806 #ifdef DEBUG_MORE
807   DEBUG_INFO ("St\r\n");
808 #endif
809 }
810
811 enum icc_state
812 icc_power_off (struct ccid *c)
813 {
814   if (c->application)
815     {
816       chThdTerminate (c->application);
817       chEvtSignal (c->application, EV_NOP);
818       chThdWait (c->application);
819       c->application = NULL;
820     }
821
822   c->icc_state = ICC_STATE_START; /* This status change should be here */
823   icc_send_status (c);
824   DEBUG_INFO ("OFF\r\n");
825   return ICC_STATE_START;
826 }
827
828 static void
829 icc_send_data_block_0x9000 (struct ccid *c)
830 {
831   uint8_t p[ICC_MSG_HEADER_SIZE+2];
832   size_t len = 2;
833
834   p[0] = ICC_DATA_BLOCK_RET;
835   p[1] = len & 0xFF;
836   p[2] = (len >> 8)& 0xFF;
837   p[3] = (len >> 16)& 0xFF;
838   p[4] = (len >> 24)& 0xFF;
839   p[5] = 0x00;  /* Slot */
840   p[ICC_MSG_SEQ_OFFSET] = c->a->seq;
841   p[ICC_MSG_STATUS_OFFSET] = 0;
842   p[ICC_MSG_ERROR_OFFSET] = 0;
843   p[ICC_MSG_CHAIN_OFFSET] = 0;
844   p[ICC_MSG_CHAIN_OFFSET+1] = 0x90;
845   p[ICC_MSG_CHAIN_OFFSET+2] = 0x00;
846
847   usb_lld_txcpy (p, c->epi->ep_num, 0, ICC_MSG_HEADER_SIZE + len);
848   c->epi->buf = NULL;
849   c->epi->tx_done = 1;
850
851   usb_lld_tx_enable (c->epi->ep_num, ICC_MSG_HEADER_SIZE + len);
852 #ifdef DEBUG_MORE
853   DEBUG_INFO ("DATA\r\n");
854 #endif
855 }
856
857 static void
858 icc_send_data_block (struct ccid *c, uint8_t status)
859 {
860   int tx_size = USB_LL_BUF_SIZE;
861   uint8_t p[ICC_MSG_HEADER_SIZE];
862   size_t len;
863
864   if (status == 0)
865     len = c->a->res_apdu_data_len + 2;
866   else
867     len = 0;
868
869   p[0] = ICC_DATA_BLOCK_RET;
870   p[1] = len & 0xFF;
871   p[2] = (len >> 8)& 0xFF;
872   p[3] = (len >> 16)& 0xFF;
873   p[4] = (len >> 24)& 0xFF;
874   p[5] = 0x00;  /* Slot */
875   p[ICC_MSG_SEQ_OFFSET] = c->a->seq;
876   p[ICC_MSG_STATUS_OFFSET] = status;
877   p[ICC_MSG_ERROR_OFFSET] = 0;
878   p[ICC_MSG_CHAIN_OFFSET] = 0;
879
880   usb_lld_txcpy (p, c->epi->ep_num, 0, ICC_MSG_HEADER_SIZE);
881   if (len == 0)
882     {
883       usb_lld_tx_enable (c->epi->ep_num, ICC_MSG_HEADER_SIZE);
884       return;
885     }
886
887   if (ICC_MSG_HEADER_SIZE + len <= USB_LL_BUF_SIZE)
888     {
889       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num,
890                      ICC_MSG_HEADER_SIZE, c->a->res_apdu_data_len);
891       usb_lld_txcpy (c->sw1sw2, c->epi->ep_num,
892                      ICC_MSG_HEADER_SIZE + c->a->res_apdu_data_len, 2);
893       c->epi->buf = NULL;
894       if (ICC_MSG_HEADER_SIZE + len < USB_LL_BUF_SIZE)
895         c->epi->tx_done = 1;
896       tx_size = ICC_MSG_HEADER_SIZE + len;
897     }
898   else if (ICC_MSG_HEADER_SIZE + len - 1 == USB_LL_BUF_SIZE)
899     {
900       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num,
901                      ICC_MSG_HEADER_SIZE, c->a->res_apdu_data_len);
902       usb_lld_txcpy (c->sw1sw2, c->epi->ep_num,
903                      ICC_MSG_HEADER_SIZE + c->a->res_apdu_data_len, 1);
904       c->epi->buf = &c->sw1sw2[1];
905       c->epi->cnt = 1;
906       c->epi->buf_len = 1;
907       c->epi->next_buf = no_buf;
908     }
909   else if (ICC_MSG_HEADER_SIZE + len - 2 == USB_LL_BUF_SIZE)
910     {
911       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num,
912                      ICC_MSG_HEADER_SIZE, c->a->res_apdu_data_len);
913       c->epi->buf = &c->sw1sw2[0];
914       c->epi->cnt = 0;
915       c->epi->buf_len = 2;
916       c->epi->next_buf = no_buf;
917     }
918   else
919     {
920       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num, ICC_MSG_HEADER_SIZE,
921                      USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE);
922       c->epi->buf = c->a->res_apdu_data + USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE;
923       c->epi->cnt = USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE;
924       c->epi->buf_len = c->a->res_apdu_data_len
925         - (USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE);
926       c->epi->next_buf = get_sw1sw2;
927     }
928
929   usb_lld_tx_enable (c->epi->ep_num, tx_size);
930 #ifdef DEBUG_MORE
931   DEBUG_INFO ("DATA\r\n");
932 #endif
933 }
934
935 static void
936 icc_send_data_block_gr (struct ccid *c, size_t chunk_len)
937 {
938   int tx_size = USB_LL_BUF_SIZE;
939   uint8_t p[ICC_MSG_HEADER_SIZE];
940   size_t len = chunk_len + 2;
941
942   p[0] = ICC_DATA_BLOCK_RET;
943   p[1] = len & 0xFF;
944   p[2] = (len >> 8)& 0xFF;
945   p[3] = (len >> 16)& 0xFF;
946   p[4] = (len >> 24)& 0xFF;
947   p[5] = 0x00;  /* Slot */
948   p[ICC_MSG_SEQ_OFFSET] = c->a->seq;
949   p[ICC_MSG_STATUS_OFFSET] = 0;
950   p[ICC_MSG_ERROR_OFFSET] = 0;
951   p[ICC_MSG_CHAIN_OFFSET] = 0;
952
953   usb_lld_txcpy (p, c->epi->ep_num, 0, ICC_MSG_HEADER_SIZE);
954
955   set_sw1sw2 (c->epi);
956
957   if (chunk_len <= USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE)
958     {
959       int size_for_sw;
960
961       if (chunk_len <= USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE - 2)
962         size_for_sw = 2;
963       else if (chunk_len == USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE - 1)
964         size_for_sw = 1;
965       else
966         size_for_sw = 0;
967
968       usb_lld_txcpy (c->p, c->epi->ep_num, ICC_MSG_HEADER_SIZE, chunk_len);
969       if (size_for_sw)
970         usb_lld_txcpy (c->sw1sw2, c->epi->ep_num,
971                        ICC_MSG_HEADER_SIZE + chunk_len, size_for_sw);
972       tx_size = ICC_MSG_HEADER_SIZE + chunk_len + size_for_sw;
973       if (size_for_sw == 2)
974         {
975           c->epi->buf = NULL;
976           if (tx_size < USB_LL_BUF_SIZE)
977             c->epi->tx_done = 1;
978           /* Don't set epi->tx_done = 1, when it requires ZLP */
979         }
980       else
981         {
982           c->epi->buf = c->sw1sw2 + size_for_sw;
983           c->epi->cnt = size_for_sw;
984           c->epi->buf_len = 2 - size_for_sw;
985           c->epi->next_buf = no_buf;
986         }
987     }
988   else
989     {
990       usb_lld_txcpy (c->p, c->epi->ep_num, ICC_MSG_HEADER_SIZE,
991                      USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE);
992       c->epi->buf = c->p + USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE;
993       c->epi->cnt = 0;
994       c->epi->buf_len = chunk_len - (USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE);
995       c->epi->next_buf = get_sw1sw2;
996     }
997
998   c->p += chunk_len;
999   c->len -= chunk_len;
1000   usb_lld_tx_enable (c->epi->ep_num, tx_size);
1001 #ifdef DEBUG_MORE
1002   DEBUG_INFO ("DATA\r\n");
1003 #endif
1004 }
1005
1006
1007 static void
1008 icc_send_params (struct ccid *c)
1009 {
1010   uint8_t p[ICC_MSG_HEADER_SIZE];
1011   const uint8_t params[] =  {
1012     0x11,   /* bmFindexDindex */
1013     0x11, /* bmTCCKST1 */
1014     0xFE, /* bGuardTimeT1 */
1015     0x55, /* bmWaitingIntegersT1 */
1016     0x03, /* bClockStop */
1017     0xFE, /* bIFSC */
1018     0    /* bNadValue */
1019   };
1020
1021   p[0] = ICC_PARAMS_RET;
1022   p[1] = 0x07;  /* Length = 0x00000007 */
1023   p[2] = 0;
1024   p[3] = 0;
1025   p[4] = 0;
1026   p[5] = 0x00;  /* Slot */
1027   p[ICC_MSG_SEQ_OFFSET] = c->icc_header.seq;
1028   p[ICC_MSG_STATUS_OFFSET] = 0;
1029   p[ICC_MSG_ERROR_OFFSET] = 0;
1030   p[ICC_MSG_CHAIN_OFFSET] = 0x01;  /* ProtocolNum: T=1 */
1031
1032   usb_lld_txcpy (p, c->epi->ep_num, 0, ICC_MSG_HEADER_SIZE);
1033   usb_lld_txcpy (params, c->epi->ep_num, ICC_MSG_HEADER_SIZE, sizeof params);
1034
1035   /* This is a single packet Bulk-IN transaction */
1036   c->epi->buf = NULL;
1037   c->epi->tx_done = 1;
1038   usb_lld_tx_enable (c->epi->ep_num, ICC_MSG_HEADER_SIZE + sizeof params);
1039 #ifdef DEBUG_MORE
1040   DEBUG_INFO ("PARAMS\r\n");
1041 #endif
1042 }
1043
1044
1045 static enum icc_state
1046 icc_handle_data (struct ccid *c)
1047 {
1048   enum icc_state next_state = c->icc_state;
1049
1050   if (c->err != 0)
1051     {
1052       ccid_reset (c);
1053       icc_error (c, ICC_OFFSET_DATA_LEN);
1054       return next_state;
1055     }
1056
1057   switch (c->icc_state)
1058     {
1059     case ICC_STATE_START:
1060       if (c->icc_header.msg_type == ICC_POWER_ON)
1061         {
1062           ccid_reset (c);
1063           next_state = icc_power_on (c);
1064         }
1065       else if (c->icc_header.msg_type == ICC_POWER_OFF)
1066         {
1067           ccid_reset (c);
1068           next_state = icc_power_off (c);
1069         }
1070       else if (c->icc_header.msg_type == ICC_SLOT_STATUS)
1071         icc_send_status (c);
1072       else
1073         {
1074           DEBUG_INFO ("ERR01\r\n");
1075           icc_error (c, ICC_OFFSET_CMD_NOT_SUPPORTED);
1076         }
1077       break;
1078     case ICC_STATE_WAIT:
1079       if (c->icc_header.msg_type == ICC_POWER_ON)
1080         {
1081           /* Not in the spec., but pcscd/libccid */
1082           ccid_reset (c);
1083           next_state = icc_power_on (c);
1084         }
1085       else if (c->icc_header.msg_type == ICC_POWER_OFF)
1086         {
1087           ccid_reset (c);
1088           next_state = icc_power_off (c);
1089         }
1090       else if (c->icc_header.msg_type == ICC_SLOT_STATUS)
1091         icc_send_status (c);
1092       else if (c->icc_header.msg_type == ICC_XFR_BLOCK)
1093         {
1094           if (c->icc_header.param == 0)
1095             {
1096               if ((c->a->cmd_apdu_head[0] & 0x10) == 0)
1097                 {
1098                   if (c->state == APDU_STATE_COMMAND_CHAINING)
1099                     {           /* command chaining finished */
1100                       c->p += c->a->cmd_apdu_head[4];
1101                       c->a->cmd_apdu_head[4] = 0;
1102                       DEBUG_INFO ("CMD chaning finished.\r\n");
1103                     }
1104
1105                   if (c->a->cmd_apdu_head[1] == INS_GET_RESPONSE
1106                       && c->state == APDU_STATE_RESULT_GET_RESPONSE)
1107                     {
1108                       size_t len = c->a->expected_res_size;
1109
1110                       if (c->len <= c->a->expected_res_size)
1111                         len = c->len;
1112
1113                       icc_send_data_block_gr (c, len);
1114                       if (c->len == 0)
1115                         c->state = APDU_STATE_RESULT;
1116                       c->icc_state = ICC_STATE_WAIT;
1117                       DEBUG_INFO ("GET Response.\r\n");
1118                     }
1119                   else
1120                     {             /* Give this message to GPG thread */
1121                       c->state = APDU_STATE_COMMAND_RECEIVED;
1122
1123                       c->a->sw = 0x9000;
1124                       c->a->res_apdu_data_len = 0;
1125                       c->a->res_apdu_data = &icc_buffer[5];
1126
1127                       chEvtSignal (c->application, EV_CMD_AVAILABLE);
1128                       next_state = ICC_STATE_EXECUTE;
1129                     }
1130                 }
1131               else
1132                 {
1133                   if (c->state == APDU_STATE_WAIT_COMMAND)
1134                     {           /* command chaining is started */
1135                       c->a->cmd_apdu_head[0] &= ~0x10;
1136                       memcpy (c->chained_cls_ins_p1_p2, c->a->cmd_apdu_head, 4);
1137                       c->state = APDU_STATE_COMMAND_CHAINING;
1138                     }
1139
1140                   c->p += c->a->cmd_apdu_head[4];
1141                   c->len -= c->a->cmd_apdu_head[4];
1142                   icc_send_data_block_0x9000 (c);
1143                   DEBUG_INFO ("CMD chaning...\r\n");
1144                 }
1145             }
1146           else
1147             {                /* ICC block chaining is not supported. */
1148               DEBUG_INFO ("ERR02\r\n");
1149               icc_error (c, ICC_OFFSET_PARAM);
1150             }
1151         }
1152       else if (c->icc_header.msg_type == ICC_SET_PARAMS
1153                || c->icc_header.msg_type == ICC_GET_PARAMS)
1154         icc_send_params (c);
1155       else if (c->icc_header.msg_type == ICC_SECURE)
1156         {
1157           if (c->p != c->a->cmd_apdu_data)
1158             {
1159               /* SECURE received in the middle of command chaining */
1160               ccid_reset (c);
1161               icc_error (c, ICC_OFFSET_DATA_LEN);
1162               return next_state;
1163             }
1164
1165           if (c->p[10-10] == 0x00) /* PIN verification */
1166             {
1167               c->a->cmd_apdu_head[0] = c->p[25-10];
1168               c->a->cmd_apdu_head[1] = c->p[26-10];
1169               c->a->cmd_apdu_head[2] = c->p[27-10];
1170               c->a->cmd_apdu_head[3] = c->p[28-10];
1171               /**/
1172               c->a->cmd_apdu_data[0] = 0; /* bConfirmPIN */
1173               c->a->cmd_apdu_data[1] = c->p[17-10]; /* bEntryValidationCondition */
1174               c->a->cmd_apdu_data[2] = c->p[18-10]; /* bNumberMessage */
1175               c->a->cmd_apdu_data[3] = c->p[19-10]; /* wLangId L */
1176               c->a->cmd_apdu_data[4] = c->p[20-10]; /* wLangId H */
1177               c->a->cmd_apdu_data[5] = c->p[21-10]; /* bMsgIndex */
1178
1179               c->a->cmd_apdu_data_len = 6;
1180               c->a->expected_res_size = 0;
1181
1182               c->a->sw = 0x9000;
1183               c->a->res_apdu_data_len = 0;
1184               c->a->res_apdu_data = &c->p[5];
1185
1186               chEvtSignal (c->application, EV_VERIFY_CMD_AVAILABLE);
1187               next_state = ICC_STATE_EXECUTE;
1188             }
1189           else if (c->p[10-10] == 0x01) /* PIN Modification */
1190             {
1191               uint8_t num_msgs = c->p[21-10];
1192
1193               if (num_msgs == 0x00)
1194                 num_msgs = 1;
1195               else if (num_msgs == 0xff)
1196                 num_msgs = 3;
1197               c->a->cmd_apdu_head[0] = c->p[27 + num_msgs-10];
1198               c->a->cmd_apdu_head[1] = c->p[28 + num_msgs-10];
1199               c->a->cmd_apdu_head[2] = c->p[29 + num_msgs-10];
1200               c->a->cmd_apdu_head[3] = c->p[30 + num_msgs-10];
1201               /**/
1202               c->a->cmd_apdu_data[0] = c->p[19-10]; /* bConfirmPIN */
1203               c->a->cmd_apdu_data[1] = c->p[20-10]; /* bEntryValidationCondition */
1204               c->a->cmd_apdu_data[2] = c->p[21-10]; /* bNumberMessage */
1205               c->a->cmd_apdu_data[3] = c->p[22-10]; /* wLangId L */
1206               c->a->cmd_apdu_data[4] = c->p[23-10]; /* wLangId H */
1207               c->a->cmd_apdu_data[5] = c->p[24-10]; /* bMsgIndex, bMsgIndex1 */
1208               if (num_msgs >= 2)
1209                 c->a->cmd_apdu_data[6] = c->p[25-10]; /* bMsgIndex2 */
1210               if (num_msgs == 3)
1211                 c->a->cmd_apdu_data[7] = c->p[26-10]; /* bMsgIndex3 */
1212
1213               c->a->cmd_apdu_data_len = 5 + num_msgs;
1214               c->a->expected_res_size = 0;
1215
1216               c->a->sw = 0x9000;
1217               c->a->res_apdu_data_len = 0;
1218               c->a->res_apdu_data = &icc_buffer[5];
1219
1220               chEvtSignal (c->application, EV_MODIFY_CMD_AVAILABLE);
1221               next_state = ICC_STATE_EXECUTE;
1222             }
1223           else
1224             icc_error (c, ICC_MSG_DATA_OFFSET);
1225         }
1226       else
1227         {
1228           DEBUG_INFO ("ERR03\r\n");
1229           DEBUG_BYTE (c->icc_header.msg_type);
1230           icc_error (c, ICC_OFFSET_CMD_NOT_SUPPORTED);
1231         }
1232       break;
1233     case ICC_STATE_EXECUTE:
1234       if (c->icc_header.msg_type == ICC_POWER_OFF)
1235         next_state = icc_power_off (c);
1236       else if (c->icc_header.msg_type == ICC_SLOT_STATUS)
1237         icc_send_status (c);
1238       else
1239         {
1240           DEBUG_INFO ("ERR04\r\n");
1241           DEBUG_BYTE (c->icc_header.msg_type);
1242           icc_error (c, ICC_OFFSET_CMD_NOT_SUPPORTED);
1243         }
1244       break;
1245     default:
1246       next_state = ICC_STATE_START;
1247       DEBUG_INFO ("ERR10\r\n");
1248       break;
1249     }
1250
1251   return next_state;
1252 }
1253
1254 static enum icc_state
1255 icc_handle_timeout (struct ccid *c)
1256 {
1257   enum icc_state next_state = c->icc_state;
1258
1259   switch (c->icc_state)
1260     {
1261     case ICC_STATE_EXECUTE:
1262       icc_send_data_block (c, ICC_CMD_STATUS_TIMEEXT);
1263       break;
1264     default:
1265       break;
1266     }
1267
1268   return next_state;
1269 }
1270
1271 #define USB_ICC_TIMEOUT MS2ST(1950)
1272
1273
1274 static struct ccid ccid;
1275
1276
1277 msg_t
1278 USBthread (void *arg)
1279 {
1280   struct ep_in *epi = &endpoint_in;
1281   struct ep_out *epo = &endpoint_out;
1282   struct ccid *c = &ccid;
1283   struct apdu *a = &apdu;
1284
1285   (void)arg;
1286
1287   epi_init (epi, ENDP1, notify_tx, c);
1288   epo_init (epo, ENDP1, notify_icc, c);
1289   ccid_init (c, epi, epo, a, chThdSelf ());
1290   apdu_init (a);
1291
1292   chEvtClear (ALL_EVENTS);
1293
1294   icc_prepare_receive (c);
1295   while (1)
1296     {
1297       eventmask_t m;
1298
1299       m = chEvtWaitOneTimeout (ALL_EVENTS, USB_ICC_TIMEOUT);
1300
1301       if (m == EV_RX_DATA_READY)
1302         c->icc_state = icc_handle_data (c);
1303       else if (m == EV_EXEC_FINISHED)
1304         if (c->icc_state == ICC_STATE_EXECUTE)
1305           {
1306             c->a->cmd_apdu_data_len = 0;
1307             c->sw1sw2[0] = c->a->sw >> 8;
1308             c->sw1sw2[1] = c->a->sw & 0xff;
1309
1310             if (c->a->res_apdu_data_len <= c->a->expected_res_size)
1311               {
1312                 c->state = APDU_STATE_RESULT;
1313                 icc_send_data_block (c, 0);
1314                 c->icc_state = ICC_STATE_WAIT;
1315               }
1316             else
1317               {
1318                 c->state = APDU_STATE_RESULT_GET_RESPONSE;
1319                 c->p = c->a->res_apdu_data;
1320                 c->len = c->a->res_apdu_data_len;
1321                 icc_send_data_block_gr (c, c->a->expected_res_size);
1322                 c->icc_state = ICC_STATE_WAIT;
1323               }
1324           }
1325         else
1326           {
1327             DEBUG_INFO ("ERR07\r\n");
1328           }
1329       else if (m == EV_TX_FINISHED)
1330         {
1331           if (c->state == APDU_STATE_RESULT)
1332             {
1333               c->state = APDU_STATE_WAIT_COMMAND;
1334               c->p = c->a->cmd_apdu_data;
1335               c->len = MAX_CMD_APDU_DATA_SIZE;
1336               c->err = 0;
1337               c->a->cmd_apdu_data_len = 0;
1338               c->a->expected_res_size = 0;
1339             }
1340
1341           if (c->state == APDU_STATE_WAIT_COMMAND
1342               || c->state == APDU_STATE_COMMAND_CHAINING
1343               || c->state == APDU_STATE_RESULT_GET_RESPONSE)
1344             icc_prepare_receive (c);
1345         }
1346       else                      /* Timeout */
1347         c->icc_state = icc_handle_timeout (c);
1348     }
1349
1350   return 0;
1351 }