Fix timeout initialization at receiving command.
[gnuk/gnuk.git] / src / usb-ccid.c
1 /*
2  * usb-ccid.c -- USB CCID protocol handling
3  *
4  * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018,
5  *               2019
6  *               Free Software Initiative of Japan
7  * Author: NIIBE Yutaka <gniibe@fsij.org>
8  *
9  * This file is a part of Gnuk, a GnuPG USB Token implementation.
10  *
11  * Gnuk is free software: you can redistribute it and/or modify it
12  * under the terms of the GNU General Public License as published by
13  * the Free Software Foundation, either version 3 of the License, or
14  * (at your option) any later version.
15  *
16  * Gnuk is distributed in the hope that it will be useful, but WITHOUT
17  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
18  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
19  * License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
23  *
24  */
25
26 #include <stdint.h>
27 #include <string.h>
28 #include <chopstx.h>
29 #include <eventflag.h>
30
31 #include "config.h"
32
33 #ifdef ACKBTN_SUPPORT
34 #include <contrib/ackbtn.h>
35 #endif
36
37 #ifdef DEBUG
38 #include "usb-cdc.h"
39 #include "debug.h"
40 struct stdout stdout;
41 #endif
42
43 #include "gnuk.h"
44 #include "usb_lld.h"
45 #include "usb_conf.h"
46
47 /*
48  * USB buffer size of USB-CCID driver
49  */
50 #if MAX_RES_APDU_DATA_SIZE > MAX_CMD_APDU_DATA_SIZE
51 #define USB_BUF_SIZE (MAX_RES_APDU_DATA_SIZE+5)
52 #else
53 #define USB_BUF_SIZE (MAX_CMD_APDU_DATA_SIZE+5)
54 #endif
55
56 struct apdu apdu;
57
58 /*
59  * There are three layers in USB CCID implementation
60  *
61  *   +-------------------+
62  *   | Application Layer |
63  *   +-------------------+
64  *      ^ command APDU |
65  *      |              v response APDU
66  *   +-------------------+
67  *   |    CCID Layer     |
68  *   +-------------------+
69  *    ^ CCID PC_to_RDR  | CCID RDR_to_PC
70  *    | Message         v Message
71  *   +-------------------+
72  *   |    USB Layer      |
73  *   +-------------------+
74  *    ^ USB             | USB
75  *    | Bulk-OUT Packet v Bulk-IN Packet
76  *
77  */
78
79 /*
80  * USB layer data structures
81  */
82
83 struct ep_in {
84   uint8_t ep_num;
85   uint8_t tx_done;
86   const uint8_t *buf;
87   size_t cnt;
88   size_t buf_len;
89   void *priv;
90   void (*next_buf) (struct ep_in *epi, size_t len);
91 };
92
93 static void epi_init (struct ep_in *epi, int ep_num, void *priv)
94 {
95   epi->ep_num = ep_num;
96   epi->tx_done = 0;
97   epi->buf = NULL;
98   epi->cnt = 0;
99   epi->buf_len = 0;
100   epi->priv = priv;
101   epi->next_buf = NULL;
102 }
103
104 struct ep_out {
105   uint8_t ep_num;
106   uint8_t err;
107   uint8_t *buf;
108   size_t cnt;
109   size_t buf_len;
110   void *priv;
111   void (*next_buf) (struct ep_out *epo, size_t len);
112   int  (*end_rx) (struct ep_out *epo, size_t orig_len);
113 };
114
115 static struct ep_out endpoint_out;
116 static struct ep_in endpoint_in;
117
118 static void epo_init (struct ep_out *epo, int ep_num, void *priv)
119 {
120   epo->ep_num = ep_num;
121   epo->err = 0;
122   epo->buf = NULL;
123   epo->cnt = 0;
124   epo->buf_len = 0;
125   epo->priv = priv;
126   epo->next_buf = NULL;
127   epo->end_rx = NULL;
128 }
129
130 /*
131  * CCID Layer
132  */
133
134 /*
135  * Buffer of USB communication: for both of RX and TX
136  *
137  * The buffer will be filled by multiple RX packets (Bulk-OUT)
138  * or will be used for multiple TX packets (Bulk-IN)
139  */
140 static uint8_t ccid_buffer[USB_BUF_SIZE];
141
142 #define CCID_SET_PARAMS         0x61 /* non-ICCD command  */
143 #define CCID_POWER_ON           0x62
144 #define CCID_POWER_OFF          0x63
145 #define CCID_SLOT_STATUS        0x65 /* non-ICCD command */
146 #define CCID_SECURE             0x69 /* non-ICCD command */
147 #define CCID_GET_PARAMS         0x6C /* non-ICCD command */
148 #define CCID_RESET_PARAMS       0x6D /* non-ICCD command */
149 #define CCID_XFR_BLOCK          0x6F
150 #define CCID_DATA_BLOCK_RET     0x80
151 #define CCID_SLOT_STATUS_RET    0x81 /* non-ICCD result */
152 #define CCID_PARAMS_RET         0x82 /* non-ICCD result */
153
154 #define CCID_MSG_SEQ_OFFSET     6
155 #define CCID_MSG_STATUS_OFFSET  7
156 #define CCID_MSG_ERROR_OFFSET   8
157 #define CCID_MSG_CHAIN_OFFSET   9
158 #define CCID_MSG_DATA_OFFSET    10      /* == CCID_MSG_HEADER_SIZE */
159 #define CCID_MAX_MSG_DATA_SIZE  USB_BUF_SIZE
160
161 #define CCID_STATUS_RUN         0x00
162 #define CCID_STATUS_PRESENT     0x01
163 #define CCID_STATUS_NOTPRESENT  0x02
164 #define CCID_CMD_STATUS_OK      0x00
165 #define CCID_CMD_STATUS_ERROR   0x40
166 #define CCID_CMD_STATUS_TIMEEXT 0x80
167
168 #define CCID_ERROR_XFR_OVERRUN  0xFC
169
170 /*
171  * Since command-byte is at offset 0,
172  * error with offset 0 means "command not supported".
173  */
174 #define CCID_OFFSET_CMD_NOT_SUPPORTED 0
175 #define CCID_OFFSET_DATA_LEN 1
176 #define CCID_OFFSET_PARAM 8
177
178 struct ccid_header {
179   uint8_t msg_type;
180   uint32_t data_len;
181   uint8_t slot;
182   uint8_t seq;
183   uint8_t rsvd;
184   uint16_t param;
185 } __attribute__((packed));
186
187
188 /* Data structure handled by CCID layer */
189 struct ccid {
190   uint32_t ccid_state : 4;
191   uint32_t state      : 4;
192   uint32_t err        : 1;
193   uint32_t tx_busy    : 1;
194   uint32_t timeout_cnt: 3;
195
196   uint8_t *p;
197   size_t len;
198
199   struct ccid_header ccid_header;
200
201   uint8_t sw1sw2[2];
202   uint8_t chained_cls_ins_p1_p2[4];
203
204   /* lower layer */
205   struct ep_out *epo;
206   struct ep_in *epi;
207
208   /* from both layers */
209   struct eventflag ccid_comm;
210
211   /* upper layer */
212   struct eventflag openpgp_comm;
213   chopstx_t application;
214   struct apdu *a;
215 };
216
217 /*
218  * APDU_STATE_WAIT_COMMAND           +---------+
219  *        |           |              |         |
220  *        |           v              v         |
221  *        |      APDU_STATE_COMMAND_CHAINING --+
222  *        |                 |
223  *        v                 v
224  *      APDU_STATE_COMMAND_RECEIVED
225  *                  |
226  *                  v
227  *          ===================
228  *          | Process COMMAND |
229  *          ===================
230  *                  |
231  *                  v
232  *            +-----+----------+                  +---------+
233  *            |                |                  |         |
234  *            v                v                  v         |
235  * APDU_STATE_RESULT <---- APDU_STATE_RESULT_GET_RESPONSE --+
236  *         |
237  *         |
238  *         v
239  * APDU_STATE_WAIT_COMMAND
240  */
241
242 #define APDU_STATE_WAIT_COMMAND        0
243 #define APDU_STATE_COMMAND_CHAINING    1
244 #define APDU_STATE_COMMAND_RECEIVED    2
245 #define APDU_STATE_RESULT              3
246 #define APDU_STATE_RESULT_GET_RESPONSE 4
247
248 static void ccid_reset (struct ccid *c)
249 {
250   c->err = 0;
251   c->tx_busy = 0;
252   c->state = APDU_STATE_WAIT_COMMAND;
253   c->p = c->a->cmd_apdu_data;
254   c->len = MAX_CMD_APDU_DATA_SIZE;
255   c->a->cmd_apdu_data_len = 0;
256   c->a->expected_res_size = 0;
257 }
258
259 static void ccid_init (struct ccid *c, struct ep_in *epi, struct ep_out *epo,
260                        struct apdu *a)
261 {
262   c->ccid_state = CCID_STATE_START;
263   c->err = 0;
264   c->tx_busy = 0;
265   c->state = APDU_STATE_WAIT_COMMAND;
266   c->p = a->cmd_apdu_data;
267   c->len = MAX_CMD_APDU_DATA_SIZE;
268   memset (&c->ccid_header, 0, sizeof (struct ccid_header));
269   c->sw1sw2[0] = 0x90;
270   c->sw1sw2[1] = 0x00;
271   c->application = 0;
272   c->epi = epi;
273   c->epo = epo;
274   c->a = a;
275 }
276
277 /*
278  * Application layer
279  */
280
281 /*
282  * USB-CCID communication could be considered "half duplex".
283  *
284  * While the device is sending something, there is no possibility for
285  * the device to receive anything.
286  *
287  * While the device is receiving something, there is no possibility
288  * for the device to send anything.
289  *
290  * Thus, the buffer can be shared for RX and TX.
291  *
292  * Exception: When we support ABORT of CCID, it is possible to receive
293  * ABORT Class Specific Request to control pipe while we are
294  * receiving/sending something at OUT/IN endpoint.
295  *
296  */
297
298 #define CMD_APDU_HEAD_SIZE 5
299
300 static void apdu_init (struct apdu *a)
301 {
302   a->seq = 0;                   /* will be set by lower layer */
303   a->cmd_apdu_head = &ccid_buffer[0];
304   a->cmd_apdu_data = &ccid_buffer[5];
305   a->cmd_apdu_data_len = 0;     /* will be set by lower layer */
306   a->expected_res_size = 0;     /* will be set by lower layer */
307
308   a->sw = 0x9000;                    /* will be set by upper layer */
309   a->res_apdu_data = &ccid_buffer[5]; /* will be set by upper layer */
310   a->res_apdu_data_len = 0;          /* will be set by upper layer */
311 }
312
313
314 static void notify_tx (struct ep_in *epi)
315 {
316   struct ccid *c = (struct ccid *)epi->priv;
317
318   /* The sequence of Bulk-IN transactions finished */
319   eventflag_signal (&c->ccid_comm, EV_TX_FINISHED);
320 }
321
322 static void no_buf (struct ep_in *epi, size_t len)
323 {
324   (void)len;
325   epi->buf = NULL;
326   epi->cnt = 0;
327   epi->buf_len = 0;
328 }
329
330 static void set_sw1sw2 (struct ccid *c, size_t chunk_len)
331 {
332   if (c->a->expected_res_size >= c->len)
333     {
334       c->sw1sw2[0] = 0x90;
335       c->sw1sw2[1] = 0x00;
336     }
337   else
338     {
339       c->sw1sw2[0] = 0x61;
340       if (c->len - chunk_len >= 256)
341         c->sw1sw2[1] = 0;
342       else
343         c->sw1sw2[1] = (uint8_t)(c->len - chunk_len);
344     }
345 }
346
347 static void get_sw1sw2 (struct ep_in *epi, size_t len)
348 {
349   struct ccid *c = (struct ccid *)epi->priv;
350
351   (void)len;
352   epi->buf = c->sw1sw2;
353   epi->cnt = 0;
354   epi->buf_len = 2;
355   epi->next_buf = no_buf;
356 }
357
358 #ifdef GNU_LINUX_EMULATION
359 static uint8_t endp1_tx_buf[64]; /* Only support single CCID interface.  */
360 #endif
361
362 /*
363  * Tx done callback
364  */
365 static void
366 ccid_tx_done (uint8_t ep_num, uint16_t len)
367 {
368   /*
369    * If we support multiple CCID interfaces, we select endpoint object
370    * by EP_NUM.  Because it has only single CCID interface now, it's
371    * hard-coded, here.
372    */
373   struct ep_in *epi = &endpoint_in;
374
375   (void)len;
376   if (epi->buf == NULL)
377     if (epi->tx_done)
378       notify_tx (epi);
379     else
380       {
381         epi->tx_done = 1;
382         /* send ZLP */
383 #ifdef GNU_LINUX_EMULATION
384         usb_lld_tx_enable_buf (ep_num, endp1_tx_buf, 0);
385 #else
386         usb_lld_tx_enable (ep_num, 0);
387 #endif
388       }
389   else
390     {
391       int tx_size = 0;
392       size_t remain = USB_LL_BUF_SIZE;
393       int offset = 0;
394
395       while (epi->buf)
396         if (epi->buf_len < remain)
397           {
398 #ifdef GNU_LINUX_EMULATION
399             memcpy (endp1_tx_buf+offset, epi->buf, epi->buf_len);
400 #else
401             usb_lld_txcpy (epi->buf, ep_num, offset, epi->buf_len);
402 #endif
403             offset += epi->buf_len;
404             remain -= epi->buf_len;
405             tx_size += epi->buf_len;
406             epi->next_buf (epi, remain); /* Update epi->buf, cnt, buf_len */
407           }
408         else
409           {
410 #ifdef GNU_LINUX_EMULATION
411             memcpy (endp1_tx_buf+offset, epi->buf, remain);
412 #else
413             usb_lld_txcpy (epi->buf, ep_num, offset, remain);
414 #endif
415             epi->buf += remain;
416             epi->cnt += remain;
417             epi->buf_len -= remain;
418             tx_size += remain;
419             break;
420           }
421
422       if (tx_size < USB_LL_BUF_SIZE)
423         epi->tx_done = 1;
424
425 #ifdef GNU_LINUX_EMULATION
426       usb_lld_tx_enable_buf (ep_num, endp1_tx_buf, tx_size);
427 #else
428       usb_lld_tx_enable (ep_num, tx_size);
429 #endif
430     }
431 }
432
433
434 static void notify_icc (struct ep_out *epo)
435 {
436   struct ccid *c = (struct ccid *)epo->priv;
437
438   c->err = epo->err;
439   eventflag_signal (&c->ccid_comm, EV_RX_DATA_READY);
440 }
441
442 static int end_ccid_rx (struct ep_out *epo, size_t orig_len)
443 {
444   (void)orig_len;
445   if (epo->cnt < sizeof (struct ccid_header))
446     /* short packet, just ignore */
447     return 1;
448
449   /* icc message with no abdata */
450   return 0;
451 }
452
453 static int end_abdata (struct ep_out *epo, size_t orig_len)
454 {
455   struct ccid *c = (struct ccid *)epo->priv;
456   size_t len = epo->cnt;
457
458   if (orig_len == USB_LL_BUF_SIZE && len < c->ccid_header.data_len)
459     /* more packet comes */
460     return 1;
461
462   if (len != c->ccid_header.data_len)
463     epo->err = 1;
464
465   return 0;
466 }
467
468 static int end_cmd_apdu_head (struct ep_out *epo, size_t orig_len)
469 {
470   struct ccid *c = (struct ccid *)epo->priv;
471
472   (void)orig_len;
473
474   if (epo->cnt < 4 || epo->cnt != c->ccid_header.data_len)
475     {
476       epo->err = 1;
477       return 0;
478     }
479
480   if ((c->state == APDU_STATE_COMMAND_CHAINING)
481       && (c->chained_cls_ins_p1_p2[0] != (c->a->cmd_apdu_head[0] & ~0x10)
482           || c->chained_cls_ins_p1_p2[1] != c->a->cmd_apdu_head[1]
483           || c->chained_cls_ins_p1_p2[2] != c->a->cmd_apdu_head[2]
484           || c->chained_cls_ins_p1_p2[3] != c->a->cmd_apdu_head[3]))
485     /*
486      * Handling exceptional request.
487      *
488      * Host stops sending command APDU using command chaining,
489      * and start another command APDU.
490      *
491      * Discard old one, and start handling new one.
492      */
493     {
494       c->state = APDU_STATE_WAIT_COMMAND;
495       c->p = c->a->cmd_apdu_data;
496       c->len = MAX_CMD_APDU_DATA_SIZE;
497     }
498
499   if (epo->cnt == 4)
500     /* No Lc and Le */
501     c->a->expected_res_size = 0;
502   else if (epo->cnt == 5)
503     {
504       /* No Lc but Le */
505       c->a->expected_res_size = c->a->cmd_apdu_head[4];
506       if (c->a->expected_res_size == 0)
507         c->a->expected_res_size = 256;
508       c->a->cmd_apdu_head[4] = 0;
509     }
510
511   c->a->cmd_apdu_data_len = 0;
512   return 0;
513 }
514
515
516 static int end_nomore_data (struct ep_out *epo, size_t orig_len)
517 {
518   (void)epo;
519   if (orig_len == USB_LL_BUF_SIZE)
520     return 1;
521   else
522     return 0;
523 }
524
525
526 static int end_cmd_apdu_data (struct ep_out *epo, size_t orig_len)
527 {
528   struct ccid *c = (struct ccid *)epo->priv;
529   size_t len = epo->cnt;
530
531   if (orig_len == USB_LL_BUF_SIZE
532       && CMD_APDU_HEAD_SIZE + len < c->ccid_header.data_len)
533     /* more packet comes */
534     return 1;
535
536   if (CMD_APDU_HEAD_SIZE + len != c->ccid_header.data_len)
537     goto error;
538
539   if (len == c->a->cmd_apdu_head[4])
540     /* No Le field*/
541     c->a->expected_res_size = 0;
542   else if (len == (size_t)c->a->cmd_apdu_head[4] + 1)
543     {
544       /* it has Le field*/
545       c->a->expected_res_size = epo->buf[-1];
546       if (c->a->expected_res_size == 0)
547         c->a->expected_res_size = 256;
548       len--;
549     }
550   else
551     {
552     error:
553       epo->err = 1;
554       return 0;
555     }
556
557   c->a->cmd_apdu_data_len += len;
558   return 0;
559 }
560
561
562 static void nomore_data (struct ep_out *epo, size_t len)
563 {
564   (void)len;
565   epo->err = 1;
566   epo->end_rx = end_nomore_data;
567   epo->buf = NULL;
568   epo->buf_len = 0;
569   epo->cnt = 0;
570   epo->next_buf = nomore_data;
571 }
572
573 #define INS_GET_RESPONSE 0xc0
574
575 static void ccid_cmd_apdu_data (struct ep_out *epo, size_t len)
576 {
577   struct ccid *c = (struct ccid *)epo->priv;
578
579   (void)len;
580   if (c->state == APDU_STATE_RESULT_GET_RESPONSE
581       && c->a->cmd_apdu_head[1] != INS_GET_RESPONSE)
582     {
583       /*
584        * Handling exceptional request.
585        *
586        * Host didn't finish receiving the whole response APDU by GET RESPONSE,
587        * but initiates another command.
588        */
589
590       c->state = APDU_STATE_WAIT_COMMAND;
591       c->p = c->a->cmd_apdu_data;
592       c->len = MAX_CMD_APDU_DATA_SIZE;
593     }
594   else if (c->state == APDU_STATE_COMMAND_CHAINING)
595     {
596       if (c->chained_cls_ins_p1_p2[0] != (c->a->cmd_apdu_head[0] & ~0x10)
597           || c->chained_cls_ins_p1_p2[1] != c->a->cmd_apdu_head[1]
598           || c->chained_cls_ins_p1_p2[2] != c->a->cmd_apdu_head[2]
599           || c->chained_cls_ins_p1_p2[3] != c->a->cmd_apdu_head[3])
600         /*
601          * Handling exceptional request.
602          *
603          * Host stops sending command APDU using command chaining,
604          * and start another command APDU.
605          *
606          * Discard old one, and start handling new one.
607          */
608         {
609           c->state = APDU_STATE_WAIT_COMMAND;
610           c->p = c->a->cmd_apdu_data;
611           c->len = MAX_CMD_APDU_DATA_SIZE;
612           c->a->cmd_apdu_data_len = 0;
613         }
614     }
615
616   epo->end_rx = end_cmd_apdu_data;
617   epo->buf = c->p;
618   epo->buf_len = c->len;
619   epo->cnt = 0;
620   epo->next_buf = nomore_data;
621 }
622
623 static void ccid_abdata (struct ep_out *epo, size_t len)
624 {
625   struct ccid *c = (struct ccid *)epo->priv;
626
627   (void)len;
628   c->a->seq = c->ccid_header.seq;
629   if (c->ccid_header.msg_type == CCID_XFR_BLOCK)
630     {
631       c->a->seq = c->ccid_header.seq;
632       epo->end_rx = end_cmd_apdu_head;
633       epo->buf = c->a->cmd_apdu_head;
634       epo->buf_len = 5;
635       epo->cnt = 0;
636       epo->next_buf = ccid_cmd_apdu_data;
637     }
638   else
639     {
640       epo->end_rx = end_abdata;
641       epo->buf = c->p;
642       epo->buf_len = c->len;
643       epo->cnt = 0;
644       epo->next_buf = nomore_data;
645     }
646 }
647
648 #ifdef GNU_LINUX_EMULATION
649 static uint8_t endp1_rx_buf[64]; /* Only support single CCID interface.  */
650 #endif
651
652 static void
653 ccid_prepare_receive (struct ccid *c)
654 {
655   c->epo->err = 0;
656   c->epo->buf = (uint8_t *)&c->ccid_header;
657   c->epo->buf_len = sizeof (struct ccid_header);
658   c->epo->cnt = 0;
659   c->epo->next_buf = ccid_abdata;
660   c->epo->end_rx = end_ccid_rx;
661 #ifdef GNU_LINUX_EMULATION
662   usb_lld_rx_enable_buf (c->epo->ep_num, endp1_rx_buf, 64);
663 #else
664   usb_lld_rx_enable (c->epo->ep_num);
665 #endif
666   DEBUG_INFO ("Rx ready\r\n");
667 }
668
669 /*
670  * Rx ready callback
671  */
672 static void
673 ccid_rx_ready (uint8_t ep_num, uint16_t len)
674 {
675   /*
676    * If we support multiple CCID interfaces, we select endpoint object
677    * by EP_NUM.  Because it has only single CCID interface now, it's
678    * hard-coded, here.
679    */
680   struct ep_out *epo = &endpoint_out;
681   int offset = 0;
682   int cont;
683   size_t orig_len = len;
684
685   while (epo->err == 0)
686     if (len == 0)
687       break;
688     else if (len <= epo->buf_len)
689       {
690 #ifdef GNU_LINUX_EMULATION
691         memcpy (epo->buf, endp1_rx_buf + offset, len);
692 #else
693         usb_lld_rxcpy (epo->buf, ep_num, offset, len);
694 #endif
695         epo->buf += len;
696         epo->cnt += len;
697         epo->buf_len -= len;
698         break;
699       }
700     else /* len > buf_len */
701       {
702 #ifdef GNU_LINUX_EMULATION
703         memcpy (epo->buf, endp1_rx_buf + offset, epo->buf_len);
704 #else
705         usb_lld_rxcpy (epo->buf, ep_num, offset, epo->buf_len);
706 #endif
707         len -= epo->buf_len;
708         offset += epo->buf_len;
709         epo->next_buf (epo, len); /* Update epo->buf, cnt, buf_len */
710       }
711
712   /*
713    * ORIG_LEN to distingush ZLP and the end of transaction
714    *  (ORIG_LEN != USB_LL_BUF_SIZE)
715    */
716   cont = epo->end_rx (epo, orig_len);
717
718   if (cont)
719 #ifdef GNU_LINUX_EMULATION
720     usb_lld_rx_enable_buf (ep_num, endp1_rx_buf, 64);
721 #else
722     usb_lld_rx_enable (ep_num);
723 #endif
724   else
725     notify_icc (epo);
726 }
727
728
729 extern void EP6_IN_Callback (uint16_t len);
730
731 #if defined(DEBUG) && defined(GNU_LINUX_EMULATION)
732 static uint8_t endp5_buf[VIRTUAL_COM_PORT_DATA_SIZE];
733 #endif
734
735 static void
736 usb_rx_ready (uint8_t ep_num, uint16_t len)
737 {
738   if (ep_num == ENDP1)
739     ccid_rx_ready (ep_num, len);
740 #ifdef DEBUG
741   else if (ep_num == ENDP5)
742     {
743       chopstx_mutex_lock (&stdout.m_dev);
744 #ifdef GNU_LINUX_EMULATION
745       usb_lld_rx_enable (ep_num, endp5_buf, VIRTUAL_COM_PORT_DATA_SIZE);
746 #else
747       usb_lld_rx_enable (ep_num);
748 #endif
749       chopstx_mutex_unlock (&stdout.m_dev);
750     }
751 #endif
752 }
753
754 static void
755 usb_tx_done (uint8_t ep_num, uint16_t len)
756 {
757   if (ep_num == ENDP1)
758     ccid_tx_done (ep_num, len);
759   else if (ep_num == ENDP2)
760     {
761       /* INTERRUPT Transfer done */
762     }
763 #ifdef DEBUG
764   else if (ep_num == ENDP3)
765     {
766       chopstx_mutex_lock (&stdout.m_dev);
767       chopstx_cond_signal (&stdout.cond_dev);
768       chopstx_mutex_unlock (&stdout.m_dev);
769     }
770 #endif
771 #ifdef PINPAD_DND_SUPPORT
772   else if (ep_num == ENDP6)
773     EP6_IN_Callback (len);
774 #endif
775 }
776
777
778 /*
779  * ATR (Answer To Reset) string
780  *
781  * TS = 0x3b: Direct conversion
782  * T0 = 0xda: TA1, TC1 and TD1 follow, 10 historical bytes
783  * TA1 = 0x11: FI=1, DI=1
784  * TC1 = 0xff
785  * TD1 = 0x81: TD2 follows, T=1
786  * TD2 = 0xb1: TA3, TB3 and TD3 follow, T=1
787  * TA3 = 0xFE: IFSC = 254 bytes
788  * TB3 = 0x55: BWI = 5, CWI = 5   (BWT timeout 3.2 sec)
789  * TD3 = 0x1f: TA4 follows, T=15
790  * TA4 = 0x03: 5V or 3.3V
791  *
792  * Minimum: 0x3b, 0x8a, 0x80, 0x01
793  *
794  */
795 static const uint8_t ATR_head[] = {
796   0x3b, 0xda, 0x11, 0xff, 0x81, 0xb1, 0xfe, 0x55, 0x1f, 0x03,
797 };
798
799 /*
800  * Send back error
801  */
802 static void ccid_error (struct ccid *c, int offset)
803 {
804   uint8_t ccid_reply[CCID_MSG_HEADER_SIZE];
805
806   ccid_reply[0] = CCID_SLOT_STATUS_RET; /* Any value should be OK */
807   ccid_reply[1] = 0x00;
808   ccid_reply[2] = 0x00;
809   ccid_reply[3] = 0x00;
810   ccid_reply[4] = 0x00;
811   ccid_reply[5] = 0x00; /* Slot */
812   ccid_reply[CCID_MSG_SEQ_OFFSET] = c->ccid_header.seq;
813   if (c->ccid_state == CCID_STATE_NOCARD)
814     ccid_reply[CCID_MSG_STATUS_OFFSET] = 2; /* 2: No ICC present */
815   else if (c->ccid_state == CCID_STATE_START)
816     /* 1: ICC present but not activated */
817     ccid_reply[CCID_MSG_STATUS_OFFSET] = 1;
818   else
819     ccid_reply[CCID_MSG_STATUS_OFFSET] = 0; /* An ICC is present and active */
820   ccid_reply[CCID_MSG_STATUS_OFFSET] |= CCID_CMD_STATUS_ERROR; /* Failed */
821   ccid_reply[CCID_MSG_ERROR_OFFSET] = offset;
822   ccid_reply[CCID_MSG_CHAIN_OFFSET] = 0x00;
823
824   /* This is a single packet Bulk-IN transaction */
825   c->epi->buf = NULL;
826   c->epi->tx_done = 1;
827 #ifdef GNU_LINUX_EMULATION
828   memcpy (endp1_tx_buf, ccid_reply, CCID_MSG_HEADER_SIZE);
829   usb_lld_tx_enable_buf (c->epi->ep_num, endp1_tx_buf, CCID_MSG_HEADER_SIZE);
830 #else
831   usb_lld_write (c->epi->ep_num, ccid_reply, CCID_MSG_HEADER_SIZE);
832 #endif
833   c->tx_busy = 1;
834 }
835
836 extern void *openpgp_card_thread (void *arg);
837
838 #define STACK_PROCESS_3
839 #include "stack-def.h"
840 #define STACK_ADDR_GPG ((uintptr_t)process3_base)
841 #define STACK_SIZE_GPG (sizeof process3_base)
842
843 #define PRIO_GPG 1
844
845
846 /* Send back ATR (Answer To Reset) */
847 static enum ccid_state
848 ccid_power_on (struct ccid *c)
849 {
850   uint8_t p[CCID_MSG_HEADER_SIZE+1]; /* >= size of historical_bytes -1 */
851   int hist_len = historical_bytes[0];
852   size_t size_atr = sizeof (ATR_head) + hist_len + 1;
853   uint8_t xor_check = 0;
854   int i;
855
856   if (c->application == 0)
857     c->application = chopstx_create (PRIO_GPG, STACK_ADDR_GPG,
858                                      STACK_SIZE_GPG, openpgp_card_thread,
859                                      (void *)&c->ccid_comm);
860
861   p[0] = CCID_DATA_BLOCK_RET;
862   p[1] = size_atr;
863   p[2] = 0x00;
864   p[3] = 0x00;
865   p[4] = 0x00;
866   p[5] = 0x00;  /* Slot */
867   p[CCID_MSG_SEQ_OFFSET] = c->ccid_header.seq;
868   p[CCID_MSG_STATUS_OFFSET] = 0x00;
869   p[CCID_MSG_ERROR_OFFSET] = 0x00;
870   p[CCID_MSG_CHAIN_OFFSET] = 0x00;
871
872 #ifdef GNU_LINUX_EMULATION
873   memcpy (endp1_tx_buf, p, CCID_MSG_HEADER_SIZE);
874   memcpy (endp1_tx_buf+CCID_MSG_HEADER_SIZE, ATR_head, sizeof (ATR_head));
875 #else
876   usb_lld_txcpy (p, c->epi->ep_num, 0, CCID_MSG_HEADER_SIZE);
877   usb_lld_txcpy (ATR_head, c->epi->ep_num, CCID_MSG_HEADER_SIZE,
878                  sizeof (ATR_head));
879 #endif
880   for (i = 1; i < (int)sizeof (ATR_head); i++)
881     xor_check ^= ATR_head[i];
882   memcpy (p, historical_bytes + 1, hist_len);
883 #ifdef LIFE_CYCLE_MANAGEMENT_SUPPORT
884   if (file_selection == 255)
885     p[7] = 0x03;
886 #endif
887   for (i = 0; i < hist_len; i++)
888     xor_check ^= p[i];
889   p[i] = xor_check;
890 #ifdef GNU_LINUX_EMULATION
891   memcpy (endp1_tx_buf+CCID_MSG_HEADER_SIZE+sizeof (ATR_head), p, hist_len+1);
892 #else
893   usb_lld_txcpy (p, c->epi->ep_num, CCID_MSG_HEADER_SIZE + sizeof (ATR_head),
894                  hist_len+1);
895 #endif
896
897   /* This is a single packet Bulk-IN transaction */
898   c->epi->buf = NULL;
899   c->epi->tx_done = 1;
900 #ifdef GNU_LINUX_EMULATION
901   usb_lld_tx_enable_buf (c->epi->ep_num, endp1_tx_buf,
902                          CCID_MSG_HEADER_SIZE + size_atr);
903 #else
904   usb_lld_tx_enable (c->epi->ep_num, CCID_MSG_HEADER_SIZE + size_atr);
905 #endif
906   DEBUG_INFO ("ON\r\n");
907   c->tx_busy = 1;
908   return CCID_STATE_WAIT;
909 }
910
911 static void
912 ccid_send_status (struct ccid *c)
913 {
914   uint8_t ccid_reply[CCID_MSG_HEADER_SIZE];
915
916   ccid_reply[0] = CCID_SLOT_STATUS_RET;
917   ccid_reply[1] = 0x00;
918   ccid_reply[2] = 0x00;
919   ccid_reply[3] = 0x00;
920   ccid_reply[4] = 0x00;
921   ccid_reply[5] = 0x00; /* Slot */
922   ccid_reply[CCID_MSG_SEQ_OFFSET] = c->ccid_header.seq;
923   if (c->ccid_state == CCID_STATE_NOCARD)
924     ccid_reply[CCID_MSG_STATUS_OFFSET] = 2; /* 2: No ICC present */
925   else if (c->ccid_state == CCID_STATE_START)
926     /* 1: ICC present but not activated */
927     ccid_reply[CCID_MSG_STATUS_OFFSET] = 1;
928   else
929     ccid_reply[CCID_MSG_STATUS_OFFSET] = 0; /* An ICC is present and active */
930   ccid_reply[CCID_MSG_ERROR_OFFSET] = 0x00;
931   ccid_reply[CCID_MSG_CHAIN_OFFSET] = 0x00;
932
933   /* This is a single packet Bulk-IN transaction */
934   c->epi->buf = NULL;
935   c->epi->tx_done = 1;
936
937 #ifdef GNU_LINUX_EMULATION
938   memcpy (endp1_tx_buf, ccid_reply, CCID_MSG_HEADER_SIZE);
939   usb_lld_tx_enable_buf (c->epi->ep_num, endp1_tx_buf, CCID_MSG_HEADER_SIZE);
940 #else
941   usb_lld_write (c->epi->ep_num, ccid_reply, CCID_MSG_HEADER_SIZE);
942 #endif
943
944   led_blink (LED_SHOW_STATUS);
945 #ifdef DEBUG_MORE
946   DEBUG_INFO ("St\r\n");
947 #endif
948   c->tx_busy = 1;
949 }
950
951 static enum ccid_state
952 ccid_power_off (struct ccid *c)
953 {
954   if (c->application)
955     {
956       eventflag_signal (&c->openpgp_comm, EV_EXIT);
957       chopstx_join (c->application, NULL);
958       c->application = 0;
959     }
960
961   c->ccid_state = CCID_STATE_START; /* This status change should be here */
962   ccid_send_status (c);
963   DEBUG_INFO ("OFF\r\n");
964   c->tx_busy = 1;
965   return CCID_STATE_START;
966 }
967
968 static void
969 ccid_send_data_block_internal (struct ccid *c, uint8_t status, uint8_t error)
970 {
971   int tx_size = USB_LL_BUF_SIZE;
972   uint8_t p[CCID_MSG_HEADER_SIZE];
973   size_t len;
974
975   if (status == 0)
976     len = c->a->res_apdu_data_len + 2;
977   else
978     len = 0;
979
980   p[0] = CCID_DATA_BLOCK_RET;
981   p[1] = len & 0xFF;
982   p[2] = (len >> 8)& 0xFF;
983   p[3] = (len >> 16)& 0xFF;
984   p[4] = (len >> 24)& 0xFF;
985   p[5] = 0x00;  /* Slot */
986   p[CCID_MSG_SEQ_OFFSET] = c->a->seq;
987   p[CCID_MSG_STATUS_OFFSET] = status;
988   p[CCID_MSG_ERROR_OFFSET] = error;
989   p[CCID_MSG_CHAIN_OFFSET] = 0;
990
991 #ifdef GNU_LINUX_EMULATION
992   memcpy (endp1_tx_buf, p, CCID_MSG_HEADER_SIZE);
993 #else
994   usb_lld_txcpy (p, c->epi->ep_num, 0, CCID_MSG_HEADER_SIZE);
995 #endif
996   if (len == 0)
997     {
998       c->epi->buf = NULL;
999       c->epi->tx_done = 1;
1000
1001 #ifdef GNU_LINUX_EMULATION
1002       usb_lld_tx_enable_buf (c->epi->ep_num, endp1_tx_buf,
1003                              CCID_MSG_HEADER_SIZE);
1004 #else
1005       usb_lld_tx_enable (c->epi->ep_num, CCID_MSG_HEADER_SIZE);
1006 #endif
1007       c->tx_busy = 1;
1008       return;
1009     }
1010
1011   if (CCID_MSG_HEADER_SIZE + len <= USB_LL_BUF_SIZE)
1012     {
1013 #ifdef GNU_LINUX_EMULATION
1014       memcpy (endp1_tx_buf+CCID_MSG_HEADER_SIZE,
1015               c->a->res_apdu_data, c->a->res_apdu_data_len);
1016       memcpy (endp1_tx_buf+CCID_MSG_HEADER_SIZE+c->a->res_apdu_data_len,
1017               c->sw1sw2, 2);
1018 #else
1019       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num,
1020                      CCID_MSG_HEADER_SIZE, c->a->res_apdu_data_len);
1021       usb_lld_txcpy (c->sw1sw2, c->epi->ep_num,
1022                      CCID_MSG_HEADER_SIZE + c->a->res_apdu_data_len, 2);
1023 #endif
1024       c->epi->buf = NULL;
1025       if (CCID_MSG_HEADER_SIZE + len < USB_LL_BUF_SIZE)
1026         c->epi->tx_done = 1;
1027       tx_size = CCID_MSG_HEADER_SIZE + len;
1028     }
1029   else if (CCID_MSG_HEADER_SIZE + len - 1 == USB_LL_BUF_SIZE)
1030     {
1031 #ifdef GNU_LINUX_EMULATION
1032       memcpy (endp1_tx_buf+CCID_MSG_HEADER_SIZE,
1033               c->a->res_apdu_data, c->a->res_apdu_data_len);
1034       memcpy (endp1_tx_buf+CCID_MSG_HEADER_SIZE+c->a->res_apdu_data_len,
1035               c->sw1sw2, 1);
1036 #else
1037       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num,
1038                      CCID_MSG_HEADER_SIZE, c->a->res_apdu_data_len);
1039       usb_lld_txcpy (c->sw1sw2, c->epi->ep_num,
1040                      CCID_MSG_HEADER_SIZE + c->a->res_apdu_data_len, 1);
1041 #endif
1042       c->epi->buf = &c->sw1sw2[1];
1043       c->epi->cnt = 1;
1044       c->epi->buf_len = 1;
1045       c->epi->next_buf = no_buf;
1046     }
1047   else if (CCID_MSG_HEADER_SIZE + len - 2 == USB_LL_BUF_SIZE)
1048     {
1049 #ifdef GNU_LINUX_EMULATION
1050       memcpy (endp1_tx_buf+CCID_MSG_HEADER_SIZE,
1051               c->a->res_apdu_data, c->a->res_apdu_data_len);
1052 #else
1053       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num,
1054                      CCID_MSG_HEADER_SIZE, c->a->res_apdu_data_len);
1055 #endif
1056       c->epi->buf = &c->sw1sw2[0];
1057       c->epi->cnt = 0;
1058       c->epi->buf_len = 2;
1059       c->epi->next_buf = no_buf;
1060     }
1061   else
1062     {
1063 #ifdef GNU_LINUX_EMULATION
1064       memcpy (endp1_tx_buf+CCID_MSG_HEADER_SIZE,
1065               c->a->res_apdu_data, USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE);
1066 #else
1067       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num, CCID_MSG_HEADER_SIZE,
1068                      USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE);
1069 #endif
1070       c->epi->buf = c->a->res_apdu_data + USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE;
1071       c->epi->cnt = USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE;
1072       c->epi->buf_len = c->a->res_apdu_data_len
1073         - (USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE);
1074       c->epi->next_buf = get_sw1sw2;
1075     }
1076
1077 #ifdef GNU_LINUX_EMULATION
1078   usb_lld_tx_enable_buf (c->epi->ep_num, endp1_tx_buf, tx_size);
1079 #else
1080   usb_lld_tx_enable (c->epi->ep_num, tx_size);
1081 #endif
1082 #ifdef DEBUG_MORE
1083   DEBUG_INFO ("DATA\r\n");
1084 #endif
1085   c->tx_busy = 1;
1086 }
1087
1088 static void
1089 ccid_send_data_block (struct ccid *c)
1090 {
1091   ccid_send_data_block_internal (c, 0, 0);
1092 }
1093
1094 static void
1095 ccid_send_data_block_time_extension (struct ccid *c)
1096 {
1097   ccid_send_data_block_internal (c, CCID_CMD_STATUS_TIMEEXT,
1098                                  c->ccid_state == CCID_STATE_EXECUTE? 1: 0xff);
1099 }
1100
1101 static void
1102 ccid_send_data_block_0x9000 (struct ccid *c)
1103 {
1104   uint8_t p[CCID_MSG_HEADER_SIZE+2];
1105   size_t len = 2;
1106
1107   p[0] = CCID_DATA_BLOCK_RET;
1108   p[1] = len & 0xFF;
1109   p[2] = (len >> 8)& 0xFF;
1110   p[3] = (len >> 16)& 0xFF;
1111   p[4] = (len >> 24)& 0xFF;
1112   p[5] = 0x00;  /* Slot */
1113   p[CCID_MSG_SEQ_OFFSET] = c->a->seq;
1114   p[CCID_MSG_STATUS_OFFSET] = 0;
1115   p[CCID_MSG_ERROR_OFFSET] = 0;
1116   p[CCID_MSG_CHAIN_OFFSET] = 0;
1117   p[CCID_MSG_CHAIN_OFFSET+1] = 0x90;
1118   p[CCID_MSG_CHAIN_OFFSET+2] = 0x00;
1119
1120 #ifdef GNU_LINUX_EMULATION
1121   memcpy (endp1_tx_buf, p, CCID_MSG_HEADER_SIZE + len);
1122 #else
1123   usb_lld_txcpy (p, c->epi->ep_num, 0, CCID_MSG_HEADER_SIZE + len);
1124 #endif
1125   c->epi->buf = NULL;
1126   c->epi->tx_done = 1;
1127
1128 #ifdef GNU_LINUX_EMULATION
1129   usb_lld_tx_enable_buf (c->epi->ep_num, endp1_tx_buf,
1130                          CCID_MSG_HEADER_SIZE + len);
1131 #else
1132   usb_lld_tx_enable (c->epi->ep_num, CCID_MSG_HEADER_SIZE + len);
1133 #endif
1134 #ifdef DEBUG_MORE
1135   DEBUG_INFO ("DATA\r\n");
1136 #endif
1137   c->tx_busy = 1;
1138 }
1139
1140 /*
1141  * Reply to the host for "GET RESPONSE".
1142  */
1143 static void
1144 ccid_send_data_block_gr (struct ccid *c, size_t chunk_len)
1145 {
1146   int tx_size = USB_LL_BUF_SIZE;
1147   uint8_t p[CCID_MSG_HEADER_SIZE];
1148   size_t len = chunk_len + 2;
1149
1150   p[0] = CCID_DATA_BLOCK_RET;
1151   p[1] = len & 0xFF;
1152   p[2] = (len >> 8)& 0xFF;
1153   p[3] = (len >> 16)& 0xFF;
1154   p[4] = (len >> 24)& 0xFF;
1155   p[5] = 0x00;  /* Slot */
1156   p[CCID_MSG_SEQ_OFFSET] = c->a->seq;
1157   p[CCID_MSG_STATUS_OFFSET] = 0;
1158   p[CCID_MSG_ERROR_OFFSET] = 0;
1159   p[CCID_MSG_CHAIN_OFFSET] = 0;
1160
1161 #ifdef GNU_LINUX_EMULATION
1162   memcpy (endp1_tx_buf, p, CCID_MSG_HEADER_SIZE);
1163 #else
1164   usb_lld_txcpy (p, c->epi->ep_num, 0, CCID_MSG_HEADER_SIZE);
1165 #endif
1166
1167   set_sw1sw2 (c, chunk_len);
1168
1169   if (chunk_len <= USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE)
1170     {
1171       int size_for_sw;
1172
1173       if (chunk_len <= USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE - 2)
1174         size_for_sw = 2;
1175       else if (chunk_len == USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE - 1)
1176         size_for_sw = 1;
1177       else
1178         size_for_sw = 0;
1179
1180 #ifdef GNU_LINUX_EMULATION
1181       memcpy (endp1_tx_buf+CCID_MSG_HEADER_SIZE, c->p, chunk_len);
1182 #else
1183       usb_lld_txcpy (c->p, c->epi->ep_num, CCID_MSG_HEADER_SIZE, chunk_len);
1184 #endif
1185       if (size_for_sw)
1186 #ifdef GNU_LINUX_EMULATION
1187         memcpy (endp1_tx_buf+CCID_MSG_HEADER_SIZE+chunk_len,
1188                 c->sw1sw2, size_for_sw);
1189 #else
1190         usb_lld_txcpy (c->sw1sw2, c->epi->ep_num,
1191                        CCID_MSG_HEADER_SIZE + chunk_len, size_for_sw);
1192 #endif
1193       tx_size = CCID_MSG_HEADER_SIZE + chunk_len + size_for_sw;
1194       if (size_for_sw == 2)
1195         {
1196           c->epi->buf = NULL;
1197           if (tx_size < USB_LL_BUF_SIZE)
1198             c->epi->tx_done = 1;
1199           /* Don't set epi->tx_done = 1, when it requires ZLP */
1200         }
1201       else
1202         {
1203           c->epi->buf = c->sw1sw2 + size_for_sw;
1204           c->epi->cnt = size_for_sw;
1205           c->epi->buf_len = 2 - size_for_sw;
1206           c->epi->next_buf = no_buf;
1207         }
1208     }
1209   else
1210     {
1211 #ifdef GNU_LINUX_EMULATION
1212       memcpy (endp1_tx_buf+CCID_MSG_HEADER_SIZE,
1213               c->p, USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE);
1214 #else
1215       usb_lld_txcpy (c->p, c->epi->ep_num, CCID_MSG_HEADER_SIZE,
1216                      USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE);
1217 #endif
1218       c->epi->buf = c->p + USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE;
1219       c->epi->cnt = 0;
1220       c->epi->buf_len = chunk_len - (USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE);
1221       c->epi->next_buf = get_sw1sw2;
1222     }
1223
1224   c->p += chunk_len;
1225   c->len -= chunk_len;
1226 #ifdef GNU_LINUX_EMULATION
1227   usb_lld_tx_enable_buf (c->epi->ep_num, endp1_tx_buf, tx_size);
1228 #else
1229   usb_lld_tx_enable (c->epi->ep_num, tx_size);
1230 #endif
1231 #ifdef DEBUG_MORE
1232   DEBUG_INFO ("DATA\r\n");
1233 #endif
1234   c->tx_busy = 1;
1235 }
1236
1237
1238 static void
1239 ccid_send_params (struct ccid *c)
1240 {
1241   uint8_t p[CCID_MSG_HEADER_SIZE];
1242   const uint8_t params[] =  {
1243     0x11,   /* bmFindexDindex */
1244     0x11, /* bmTCCKST1 */
1245     0xFE, /* bGuardTimeT1 */
1246     0x55, /* bmWaitingIntegersT1 */
1247     0x03, /* bClockStop */
1248     0xFE, /* bIFSC */
1249     0    /* bNadValue */
1250   };
1251
1252   p[0] = CCID_PARAMS_RET;
1253   p[1] = 0x07;  /* Length = 0x00000007 */
1254   p[2] = 0;
1255   p[3] = 0;
1256   p[4] = 0;
1257   p[5] = 0x00;  /* Slot */
1258   p[CCID_MSG_SEQ_OFFSET] = c->ccid_header.seq;
1259   p[CCID_MSG_STATUS_OFFSET] = 0;
1260   p[CCID_MSG_ERROR_OFFSET] = 0;
1261   p[CCID_MSG_CHAIN_OFFSET] = 0x01;  /* ProtocolNum: T=1 */
1262
1263 #ifdef GNU_LINUX_EMULATION
1264   memcpy (endp1_tx_buf, p, CCID_MSG_HEADER_SIZE);
1265   memcpy (endp1_tx_buf+CCID_MSG_HEADER_SIZE, params, sizeof params);
1266 #else
1267   usb_lld_txcpy (p, c->epi->ep_num, 0, CCID_MSG_HEADER_SIZE);
1268   usb_lld_txcpy (params, c->epi->ep_num, CCID_MSG_HEADER_SIZE, sizeof params);
1269 #endif
1270
1271   /* This is a single packet Bulk-IN transaction */
1272   c->epi->buf = NULL;
1273   c->epi->tx_done = 1;
1274 #ifdef GNU_LINUX_EMULATION
1275   usb_lld_tx_enable_buf (c->epi->ep_num, endp1_tx_buf,
1276                          CCID_MSG_HEADER_SIZE + sizeof params);
1277 #else
1278   usb_lld_tx_enable (c->epi->ep_num, CCID_MSG_HEADER_SIZE + sizeof params);
1279 #endif
1280 #ifdef DEBUG_MORE
1281   DEBUG_INFO ("PARAMS\r\n");
1282 #endif
1283   c->tx_busy = 1;
1284 }
1285
1286
1287 static enum ccid_state
1288 ccid_handle_data (struct ccid *c)
1289 {
1290   enum ccid_state next_state = c->ccid_state;
1291
1292   if (c->err != 0)
1293     {
1294       ccid_reset (c);
1295       ccid_error (c, CCID_OFFSET_DATA_LEN);
1296       return next_state;
1297     }
1298
1299   switch (c->ccid_state)
1300     {
1301     case CCID_STATE_NOCARD:
1302       if (c->ccid_header.msg_type == CCID_SLOT_STATUS)
1303         ccid_send_status (c);
1304       else
1305         {
1306           DEBUG_INFO ("ERR00\r\n");
1307           ccid_error (c, CCID_OFFSET_CMD_NOT_SUPPORTED);
1308         }
1309       break;
1310     case CCID_STATE_START:
1311       if (c->ccid_header.msg_type == CCID_POWER_ON)
1312         {
1313           ccid_reset (c);
1314           next_state = ccid_power_on (c);
1315         }
1316       else if (c->ccid_header.msg_type == CCID_POWER_OFF)
1317         {
1318           ccid_reset (c);
1319           next_state = ccid_power_off (c);
1320         }
1321       else if (c->ccid_header.msg_type == CCID_SLOT_STATUS)
1322         ccid_send_status (c);
1323       else
1324         {
1325           DEBUG_INFO ("ERR01\r\n");
1326           ccid_error (c, CCID_OFFSET_CMD_NOT_SUPPORTED);
1327         }
1328       break;
1329     case CCID_STATE_WAIT:
1330       if (c->ccid_header.msg_type == CCID_POWER_ON)
1331         {
1332           /* Not in the spec., but pcscd/libccid */
1333           ccid_reset (c);
1334           next_state = ccid_power_on (c);
1335         }
1336       else if (c->ccid_header.msg_type == CCID_POWER_OFF)
1337         {
1338           ccid_reset (c);
1339           next_state = ccid_power_off (c);
1340         }
1341       else if (c->ccid_header.msg_type == CCID_SLOT_STATUS)
1342         ccid_send_status (c);
1343       else if (c->ccid_header.msg_type == CCID_XFR_BLOCK)
1344         {
1345           if (c->ccid_header.param == 0)
1346             {
1347               if ((c->a->cmd_apdu_head[0] & 0x10) == 0)
1348                 {
1349                   if (c->state == APDU_STATE_COMMAND_CHAINING)
1350                     {           /* command chaining finished */
1351                       c->p += c->a->cmd_apdu_head[4];
1352                       c->a->cmd_apdu_head[4] = 0;
1353                       DEBUG_INFO ("CMD chaning finished.\r\n");
1354                     }
1355
1356                   if (c->a->cmd_apdu_head[1] == INS_GET_RESPONSE
1357                       && c->state == APDU_STATE_RESULT_GET_RESPONSE)
1358                     {
1359                       size_t len = c->a->expected_res_size;
1360
1361                       if (c->len <= c->a->expected_res_size)
1362                         len = c->len;
1363
1364                       ccid_send_data_block_gr (c, len);
1365                       if (c->len == 0)
1366                         c->state = APDU_STATE_RESULT;
1367                       c->ccid_state = CCID_STATE_WAIT;
1368                       DEBUG_INFO ("GET Response.\r\n");
1369                     }
1370                   else
1371                     {             /* Give this message to GPG thread */
1372                       c->state = APDU_STATE_COMMAND_RECEIVED;
1373
1374                       c->a->sw = 0x9000;
1375                       c->a->res_apdu_data_len = 0;
1376                       c->a->res_apdu_data = &ccid_buffer[5];
1377
1378                       eventflag_signal (&c->openpgp_comm, EV_CMD_AVAILABLE);
1379                       next_state = CCID_STATE_EXECUTE;
1380                     }
1381                 }
1382               else
1383                 {
1384                   if (c->state == APDU_STATE_WAIT_COMMAND)
1385                     {           /* command chaining is started */
1386                       c->a->cmd_apdu_head[0] &= ~0x10;
1387                       memcpy (c->chained_cls_ins_p1_p2, c->a->cmd_apdu_head, 4);
1388                       c->state = APDU_STATE_COMMAND_CHAINING;
1389                     }
1390
1391                   c->p += c->a->cmd_apdu_head[4];
1392                   c->len -= c->a->cmd_apdu_head[4];
1393                   ccid_send_data_block_0x9000 (c);
1394                   DEBUG_INFO ("CMD chaning...\r\n");
1395                 }
1396             }
1397           else
1398             {                /* ICC block chaining is not supported. */
1399               DEBUG_INFO ("ERR02\r\n");
1400               ccid_error (c, CCID_OFFSET_PARAM);
1401             }
1402         }
1403       else if (c->ccid_header.msg_type == CCID_SET_PARAMS
1404                || c->ccid_header.msg_type == CCID_GET_PARAMS
1405                || c->ccid_header.msg_type == CCID_RESET_PARAMS)
1406         ccid_send_params (c);
1407       else if (c->ccid_header.msg_type == CCID_SECURE)
1408         {
1409           if (c->p != c->a->cmd_apdu_data)
1410             {
1411               /* SECURE received in the middle of command chaining */
1412               ccid_reset (c);
1413               ccid_error (c, CCID_OFFSET_DATA_LEN);
1414               return next_state;
1415             }
1416
1417           if (c->p[10-10] == 0x00) /* PIN verification */
1418             {
1419               c->a->cmd_apdu_head[0] = c->p[25-10];
1420               c->a->cmd_apdu_head[1] = c->p[26-10];
1421               c->a->cmd_apdu_head[2] = c->p[27-10];
1422               c->a->cmd_apdu_head[3] = c->p[28-10];
1423               /**/
1424               c->a->cmd_apdu_data[0] = 0; /* bConfirmPIN */
1425               c->a->cmd_apdu_data[1] = c->p[17-10]; /* bEntryValidationCondition */
1426               c->a->cmd_apdu_data[2] = c->p[18-10]; /* bNumberMessage */
1427               c->a->cmd_apdu_data[3] = c->p[19-10]; /* wLangId L */
1428               c->a->cmd_apdu_data[4] = c->p[20-10]; /* wLangId H */
1429               c->a->cmd_apdu_data[5] = c->p[21-10]; /* bMsgIndex */
1430
1431               c->a->cmd_apdu_data_len = 6;
1432               c->a->expected_res_size = 0;
1433
1434               c->a->sw = 0x9000;
1435               c->a->res_apdu_data_len = 0;
1436               c->a->res_apdu_data = &c->p[5];
1437
1438               c->state = APDU_STATE_COMMAND_RECEIVED;
1439               eventflag_signal (&c->openpgp_comm, EV_VERIFY_CMD_AVAILABLE);
1440               next_state = CCID_STATE_EXECUTE;
1441             }
1442           else if (c->p[10-10] == 0x01) /* PIN Modification */
1443             {
1444               uint8_t num_msgs = c->p[21-10];
1445
1446               if (num_msgs == 0x00)
1447                 num_msgs = 1;
1448               else if (num_msgs == 0xff)
1449                 num_msgs = 3;
1450               c->a->cmd_apdu_head[0] = c->p[27 + num_msgs-10];
1451               c->a->cmd_apdu_head[1] = c->p[28 + num_msgs-10];
1452               c->a->cmd_apdu_head[2] = c->p[29 + num_msgs-10];
1453               c->a->cmd_apdu_head[3] = c->p[30 + num_msgs-10];
1454               /**/
1455               c->a->cmd_apdu_data[0] = c->p[19-10]; /* bConfirmPIN */
1456               c->a->cmd_apdu_data[1] = c->p[20-10]; /* bEntryValidationCondition */
1457               c->a->cmd_apdu_data[2] = c->p[21-10]; /* bNumberMessage */
1458               c->a->cmd_apdu_data[3] = c->p[22-10]; /* wLangId L */
1459               c->a->cmd_apdu_data[4] = c->p[23-10]; /* wLangId H */
1460               c->a->cmd_apdu_data[5] = c->p[24-10]; /* bMsgIndex, bMsgIndex1 */
1461               if (num_msgs >= 2)
1462                 c->a->cmd_apdu_data[6] = c->p[25-10]; /* bMsgIndex2 */
1463               if (num_msgs == 3)
1464                 c->a->cmd_apdu_data[7] = c->p[26-10]; /* bMsgIndex3 */
1465
1466               c->a->cmd_apdu_data_len = 5 + num_msgs;
1467               c->a->expected_res_size = 0;
1468
1469               c->a->sw = 0x9000;
1470               c->a->res_apdu_data_len = 0;
1471               c->a->res_apdu_data = &ccid_buffer[5];
1472
1473               c->state = APDU_STATE_COMMAND_RECEIVED;
1474               eventflag_signal (&c->openpgp_comm, EV_MODIFY_CMD_AVAILABLE);
1475               next_state = CCID_STATE_EXECUTE;
1476             }
1477           else
1478             ccid_error (c, CCID_MSG_DATA_OFFSET);
1479         }
1480       else
1481         {
1482           DEBUG_INFO ("ERR03\r\n");
1483           DEBUG_BYTE (c->ccid_header.msg_type);
1484           ccid_error (c, CCID_OFFSET_CMD_NOT_SUPPORTED);
1485         }
1486       break;
1487     case CCID_STATE_EXECUTE:
1488     case CCID_STATE_ACK_REQUIRED_0:
1489     case CCID_STATE_ACK_REQUIRED_1:
1490       if (c->ccid_header.msg_type == CCID_POWER_OFF)
1491         next_state = ccid_power_off (c);
1492       else if (c->ccid_header.msg_type == CCID_SLOT_STATUS)
1493         ccid_send_status (c);
1494       else
1495         {
1496           DEBUG_INFO ("ERR04\r\n");
1497           DEBUG_BYTE (c->ccid_header.msg_type);
1498           ccid_error (c, CCID_OFFSET_CMD_NOT_SUPPORTED);
1499         }
1500       break;
1501     default:
1502       next_state = CCID_STATE_START;
1503       DEBUG_INFO ("ERR10\r\n");
1504       break;
1505     }
1506
1507   return next_state;
1508 }
1509
1510 static enum ccid_state
1511 ccid_handle_timeout (struct ccid *c)
1512 {
1513   enum ccid_state next_state = c->ccid_state;
1514
1515   switch (c->ccid_state)
1516     {
1517     case CCID_STATE_EXECUTE:
1518     case CCID_STATE_ACK_REQUIRED_0:
1519     case CCID_STATE_ACK_REQUIRED_1:
1520       ccid_send_data_block_time_extension (c);
1521       break;
1522     default:
1523       break;
1524     }
1525
1526   led_blink (LED_ONESHOT);
1527   return next_state;
1528 }
1529
1530 static struct ccid ccid;
1531
1532 enum ccid_state
1533 ccid_get_ccid_state (void)
1534 {
1535   return ccid.ccid_state;
1536 }
1537
1538
1539 void
1540 ccid_card_change_signal (int how)
1541 {
1542   struct ccid *c = &ccid;
1543
1544   if (how == CARD_CHANGE_TOGGLE
1545       || (c->ccid_state == CCID_STATE_NOCARD && how == CARD_CHANGE_INSERT)
1546       || (c->ccid_state != CCID_STATE_NOCARD && how == CARD_CHANGE_REMOVE))
1547     eventflag_signal (&c->ccid_comm, EV_CARD_CHANGE);
1548 }
1549
1550
1551 #ifdef GNU_LINUX_EMULATION
1552 static uint8_t endp2_tx_buf[2];
1553 #endif
1554
1555 #define NOTIFY_SLOT_CHANGE 0x50
1556 static void
1557 ccid_notify_slot_change (struct ccid *c)
1558 {
1559   uint8_t msg;
1560   uint8_t notification[2];
1561
1562   if (c->ccid_state == CCID_STATE_NOCARD)
1563     msg = 0x02;
1564   else
1565     msg = 0x03;
1566
1567   notification[0] = NOTIFY_SLOT_CHANGE;
1568   notification[1] = msg;
1569 #ifdef GNU_LINUX_EMULATION
1570   memcpy (endp2_tx_buf, notification, sizeof notification);
1571   usb_lld_tx_enable_buf (ENDP2, endp2_tx_buf, sizeof notification);
1572 #else
1573   usb_lld_write (ENDP2, notification, sizeof notification);
1574 #endif
1575   led_blink (LED_TWOSHOTS);
1576 }
1577
1578
1579 #define USB_CCID_TIMEOUT (1950*1000)
1580
1581 #define GPG_THREAD_TERMINATED 0xffff
1582 #define GPG_ACK_TIMEOUT 0x6600
1583
1584 extern uint32_t bDeviceState;
1585 extern void usb_device_reset (struct usb_dev *dev);
1586 extern int usb_setup (struct usb_dev *dev);
1587 extern void usb_ctrl_write_finish (struct usb_dev *dev);
1588 extern int usb_set_configuration (struct usb_dev *dev);
1589 extern int usb_set_interface (struct usb_dev *dev);
1590 extern int usb_get_interface (struct usb_dev *dev);
1591 extern int usb_get_status_interface (struct usb_dev *dev);
1592
1593 extern int usb_get_descriptor (struct usb_dev *dev);
1594
1595 extern void random_init (void);
1596 extern void random_fini (void);
1597
1598 #ifdef ACKBTN_SUPPORT
1599 static chopstx_intr_t ack_intr;
1600 #endif
1601 static chopstx_intr_t usb_intr;
1602
1603 /*
1604  * Return 0 for normal USB event
1605  *       -1 for USB reset
1606  *        1 for SET_INTERFACE or SET_CONFIGURATION
1607  */
1608 static int
1609 usb_event_handle (struct usb_dev *dev)
1610 {
1611   uint8_t ep_num;
1612   int e;
1613
1614   e = usb_lld_event_handler (dev);
1615   ep_num = USB_EVENT_ENDP (e);
1616   chopstx_intr_done (&usb_intr);
1617
1618   /* Transfer to endpoint (not control endpoint) */
1619   if (ep_num != 0)
1620     {
1621       if (USB_EVENT_TXRX (e))
1622         usb_tx_done (ep_num, USB_EVENT_LEN (e));
1623       else
1624         usb_rx_ready (ep_num, USB_EVENT_LEN (e));
1625       return 0;
1626     }
1627
1628   /* Control endpoint */
1629   switch (USB_EVENT_ID (e))
1630     {
1631     case USB_EVENT_DEVICE_RESET:
1632       usb_device_reset (dev);
1633       return -1;
1634
1635     case USB_EVENT_DEVICE_ADDRESSED:
1636       bDeviceState = USB_DEVICE_STATE_ADDRESSED;
1637       break;
1638
1639     case USB_EVENT_GET_DESCRIPTOR:
1640       if (usb_get_descriptor (dev) < 0)
1641         usb_lld_ctrl_error (dev);
1642       break;
1643
1644     case USB_EVENT_SET_CONFIGURATION:
1645       if (usb_set_configuration (dev) < 0)
1646         usb_lld_ctrl_error (dev);
1647       else
1648         {
1649           if (bDeviceState == USB_DEVICE_STATE_ADDRESSED)
1650             /* de-Configured */
1651             return -1;
1652           else
1653             /* Configured */
1654             return 1;
1655         }
1656       break;
1657
1658     case USB_EVENT_SET_INTERFACE:
1659       if (usb_set_interface (dev) < 0)
1660         usb_lld_ctrl_error (dev);
1661       else
1662         return 1;
1663       break;
1664
1665     case USB_EVENT_CTRL_REQUEST:
1666       /* Device specific device request.  */
1667       if (usb_setup (dev) < 0)
1668         usb_lld_ctrl_error (dev);
1669       break;
1670
1671     case USB_EVENT_GET_STATUS_INTERFACE:
1672       if (usb_get_status_interface (dev) < 0)
1673         usb_lld_ctrl_error (dev);
1674       break;
1675
1676     case USB_EVENT_GET_INTERFACE:
1677       if (usb_get_interface (dev) < 0)
1678         usb_lld_ctrl_error (dev);
1679       break;
1680
1681     case USB_EVENT_SET_FEATURE_DEVICE:
1682     case USB_EVENT_SET_FEATURE_ENDPOINT:
1683     case USB_EVENT_CLEAR_FEATURE_DEVICE:
1684     case USB_EVENT_CLEAR_FEATURE_ENDPOINT:
1685       usb_lld_ctrl_ack (dev);
1686       break;
1687
1688     case USB_EVENT_CTRL_WRITE_FINISH:
1689       /* Control WRITE transfer finished.  */
1690       usb_ctrl_write_finish (dev);
1691       break;
1692
1693     case USB_EVENT_DEVICE_SUSPEND:
1694       led_blink (LED_OFF);
1695       chopstx_usec_wait (10);   /* Make sure LED off */
1696       random_fini ();
1697       chopstx_conf_idle (2);
1698       bDeviceState |= USB_DEVICE_STATE_SUSPEND;
1699       break;
1700
1701     case USB_EVENT_DEVICE_WAKEUP:
1702       chopstx_conf_idle (1);
1703       random_init ();
1704       bDeviceState &= ~USB_DEVICE_STATE_SUSPEND;
1705       break;
1706
1707     case USB_EVENT_OK:
1708     default:
1709       break;
1710     }
1711
1712   return 0;
1713 }
1714
1715
1716 static chopstx_poll_cond_t ccid_event_poll_desc;
1717 static struct chx_poll_head *const ccid_poll[] = {
1718   (struct chx_poll_head *const)&usb_intr,
1719   (struct chx_poll_head *const)&ccid_event_poll_desc,
1720 #ifdef ACKBTN_SUPPORT
1721   (struct chx_poll_head *const)&ack_intr
1722 #endif
1723 };
1724 #define CCID_POLL_NUM (sizeof (ccid_poll)/sizeof (struct chx_poll_head *))
1725
1726 void *
1727 ccid_thread (void *arg)
1728 {
1729   uint32_t timeout;
1730   struct usb_dev dev;
1731   struct ccid *c = &ccid;
1732   uint32_t *timeout_p;
1733   int ackbtn_active = 0;
1734
1735   (void)arg;
1736
1737   eventflag_init (&ccid.ccid_comm);
1738   eventflag_init (&ccid.openpgp_comm);
1739
1740   usb_lld_init (&dev, USB_INITIAL_FEATURE);
1741   chopstx_claim_irq (&usb_intr, INTR_REQ_USB);
1742   usb_event_handle (&dev);      /* For old SYS < 3.0 */
1743
1744 #ifdef ACKBTN_SUPPORT
1745   ackbtn_init (&ack_intr);
1746 #endif
1747   eventflag_prepare_poll (&c->ccid_comm, &ccid_event_poll_desc);
1748
1749  reset:
1750   {
1751     struct ep_in *epi = &endpoint_in;
1752     struct ep_out *epo = &endpoint_out;
1753     struct apdu *a = &apdu;
1754
1755     if (ackbtn_active)
1756       {
1757         ackbtn_active = 0;
1758         ackbtn_disable ();
1759         led_blink (LED_WAIT_FOR_BUTTON);
1760       }
1761
1762     epi_init (epi, ENDP1, c);
1763     epo_init (epo, ENDP1, c);
1764     apdu_init (a);
1765     ccid_init (c, epi, epo, a);
1766   }
1767
1768   timeout = USB_CCID_TIMEOUT;
1769   if (bDeviceState == USB_DEVICE_STATE_CONFIGURED)
1770     {
1771       ccid_prepare_receive (c);
1772       ccid_notify_slot_change (c);
1773     }
1774
1775   while (1)
1776     {
1777       eventmask_t m;
1778
1779       if (!c->tx_busy && bDeviceState == USB_DEVICE_STATE_CONFIGURED)
1780         timeout_p = &timeout;
1781       else
1782         timeout_p = NULL;
1783
1784       eventflag_set_mask (&c->ccid_comm, c->tx_busy ? EV_TX_FINISHED : ~0);
1785
1786 #ifdef ACKBTN_SUPPORT
1787       chopstx_poll (timeout_p, CCID_POLL_NUM - (c->tx_busy || !ackbtn_active),
1788                     ccid_poll);
1789 #else
1790       chopstx_poll (timeout_p, CCID_POLL_NUM, ccid_poll);
1791 #endif
1792
1793       if (usb_intr.ready)
1794         {
1795           if (usb_event_handle (&dev) == 0)
1796             continue;
1797
1798           /* RESET handling:
1799            * (1) After DEVICE_RESET, it needs to re-start out of the loop.
1800            * (2) After SET_CONFIGURATION or SET_INTERFACE, the
1801            *     endpoint is reset to RX_NAK.  It needs to prepare
1802            *     receive again.
1803            */
1804           if (c->application)
1805             {
1806               chopstx_cancel (c->application);
1807               chopstx_join (c->application, NULL);
1808               c->application = 0;
1809             }
1810           goto reset;
1811         }
1812
1813 #ifdef ACKBTN_SUPPORT
1814       if (!c->tx_busy && ack_intr.ready)
1815         {
1816           ackbtn_active = 0;
1817           ackbtn_disable ();
1818           led_blink (LED_WAIT_FOR_BUTTON);
1819           chopstx_intr_done (&ack_intr);
1820           if (c->ccid_state == CCID_STATE_ACK_REQUIRED_1)
1821             goto exec_done;
1822
1823           c->ccid_state = CCID_STATE_EXECUTE;
1824           continue;
1825         }
1826 #endif
1827
1828       if (timeout == 0)
1829         {
1830           timeout = USB_CCID_TIMEOUT;
1831           c->timeout_cnt++;
1832         }
1833       m = eventflag_get (&c->ccid_comm);
1834
1835       if (m == EV_CARD_CHANGE)
1836         {
1837           if (c->ccid_state == CCID_STATE_NOCARD)
1838             /* Inserted!  */
1839             c->ccid_state = CCID_STATE_START;
1840           else
1841             { /* Removed!  */
1842               if (c->application)
1843                 {
1844                   eventflag_signal (&c->openpgp_comm, EV_EXIT);
1845                   chopstx_join (c->application, NULL);
1846                   c->application = 0;
1847                 }
1848
1849               c->ccid_state = CCID_STATE_NOCARD;
1850             }
1851
1852           ccid_notify_slot_change (c);
1853         }
1854       else if (m == EV_RX_DATA_READY)
1855         {
1856           c->ccid_state = ccid_handle_data (c);
1857           timeout = 0;
1858           c->timeout_cnt = 0;
1859         }
1860       else if (m == EV_EXEC_FINISHED)
1861         if (c->ccid_state == CCID_STATE_EXECUTE)
1862           {
1863 #ifdef ACKBTN_SUPPORT
1864           exec_done:
1865 #endif
1866             if (c->a->sw == GPG_THREAD_TERMINATED)
1867               {
1868                 c->sw1sw2[0] = 0x90;
1869                 c->sw1sw2[1] = 0x00;
1870                 c->state = APDU_STATE_RESULT;
1871                 ccid_send_data_block (c);
1872                 c->ccid_state = CCID_STATE_EXITED;
1873                 break;
1874               }
1875
1876             c->a->cmd_apdu_data_len = 0;
1877             c->sw1sw2[0] = c->a->sw >> 8;
1878             c->sw1sw2[1] = c->a->sw & 0xff;
1879
1880             if (c->a->res_apdu_data_len <= c->a->expected_res_size)
1881               {
1882                 c->state = APDU_STATE_RESULT;
1883                 ccid_send_data_block (c);
1884                 c->ccid_state = CCID_STATE_WAIT;
1885               }
1886             else
1887               {
1888                 c->state = APDU_STATE_RESULT_GET_RESPONSE;
1889                 c->p = c->a->res_apdu_data;
1890                 c->len = c->a->res_apdu_data_len;
1891                 ccid_send_data_block_gr (c, c->a->expected_res_size);
1892                 c->ccid_state = CCID_STATE_WAIT;
1893               }
1894           }
1895 #ifdef ACKBTN_SUPPORT
1896         else if (c->ccid_state == CCID_STATE_ACK_REQUIRED_0)
1897           c->ccid_state = CCID_STATE_ACK_REQUIRED_1;
1898 #endif
1899         else
1900           {
1901             DEBUG_INFO ("ERR05\r\n");
1902           }
1903 #ifdef ACKBTN_SUPPORT
1904       else if (m == EV_EXEC_ACK_REQUIRED)
1905         if (c->ccid_state == CCID_STATE_EXECUTE)
1906           {
1907             ackbtn_enable ();
1908             ackbtn_active = 1;
1909             led_blink (LED_WAIT_FOR_BUTTON);
1910             c->ccid_state = CCID_STATE_ACK_REQUIRED_0;
1911             ccid_send_data_block_time_extension (c);
1912           }
1913         else
1914           {
1915             DEBUG_INFO ("ERR06\r\n");
1916           }
1917 #endif
1918       else if (m == EV_TX_FINISHED)
1919         {
1920           if (c->state == APDU_STATE_RESULT)
1921             ccid_reset (c);
1922           else
1923             c->tx_busy = 0;
1924
1925           if (c->state == APDU_STATE_WAIT_COMMAND
1926               || c->state == APDU_STATE_COMMAND_CHAINING
1927               || c->state == APDU_STATE_RESULT_GET_RESPONSE)
1928             ccid_prepare_receive (c);
1929         }
1930       else                      /* Timeout */
1931         {
1932           if (c->timeout_cnt == 7
1933               && c->ccid_state == CCID_STATE_ACK_REQUIRED_1)
1934             {
1935               ackbtn_active = 0;
1936               ackbtn_disable ();
1937               led_blink (LED_WAIT_FOR_BUTTON);
1938               c->a->sw = GPG_ACK_TIMEOUT;
1939               c->a->res_apdu_data_len = 0;
1940               goto exec_done;
1941             }
1942           else
1943             c->ccid_state = ccid_handle_timeout (c);
1944         }
1945     }
1946
1947   if (c->application)
1948     {
1949       chopstx_join (c->application, NULL);
1950       c->application = 0;
1951     }
1952
1953   /* Loading reGNUal.  */
1954   while (bDeviceState != USB_DEVICE_STATE_UNCONNECTED)
1955     {
1956       chopstx_intr_wait (&usb_intr);
1957       usb_event_handle (&dev);
1958     }
1959
1960   return NULL;
1961 }
1962
1963
1964 #ifdef DEBUG
1965 #include "usb-cdc.h"
1966
1967 void
1968 stdout_init (void)
1969 {
1970   chopstx_mutex_init (&stdout.m);
1971   chopstx_mutex_init (&stdout.m_dev);
1972   chopstx_cond_init (&stdout.cond_dev);
1973   stdout.connected = 0;
1974 }
1975
1976 void
1977 _write (const char *s, int len)
1978 {
1979   int packet_len;
1980
1981   if (len == 0)
1982     return;
1983
1984   chopstx_mutex_lock (&stdout.m);
1985
1986   chopstx_mutex_lock (&stdout.m_dev);
1987   if (!stdout.connected)
1988     chopstx_cond_wait (&stdout.cond_dev, &stdout.m_dev);
1989   chopstx_mutex_unlock (&stdout.m_dev);
1990
1991   do
1992     {
1993       packet_len =
1994         (len < VIRTUAL_COM_PORT_DATA_SIZE) ? len : VIRTUAL_COM_PORT_DATA_SIZE;
1995
1996       chopstx_mutex_lock (&stdout.m_dev);
1997 #ifdef GNU_LINUX_EMULATION
1998       usb_lld_tx_enable_buf (ENDP3, s, packet_len);
1999 #else
2000       usb_lld_write (ENDP3, s, packet_len);
2001 #endif
2002       chopstx_cond_wait (&stdout.cond_dev, &stdout.m_dev);
2003       chopstx_mutex_unlock (&stdout.m_dev);
2004
2005       s += packet_len;
2006       len -= packet_len;
2007     }
2008   /* Send a Zero-Length-Packet if the last packet is full size.  */
2009   while (len != 0 || packet_len == VIRTUAL_COM_PORT_DATA_SIZE);
2010
2011   chopstx_mutex_unlock (&stdout.m);
2012 }
2013
2014 #else
2015 void
2016 _write (const char *s, int size)
2017 {
2018   (void)s;
2019   (void)size;
2020 }
2021 #endif