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