2 * Copyright (C) 2011 Red Hat, Inc.
4 * CCID Device emulation
6 * Written by Alon Levy, with contributions from Robert Relyea.
8 * Based on usb-serial.c, see its copyright and attributions below.
10 * This work is licensed under the terms of the GNU GPL, version 2.1 or later.
11 * See the COPYING file in the top-level directory.
12 * ------- (original copyright & attribution for usb-serial.c below) --------
13 * Copyright (c) 2006 CodeSourcery.
14 * Copyright (c) 2008 Samuel Thibault <samuel.thibault@ens-lyon.org>
15 * Written by Paul Brook, reused for FTDI by Samuel Thibault,
21 * CCID Specification Revision 1.1 April 22nd 2005
22 * "Universal Serial Bus, Device Class: Smart Card"
23 * Specification for Integrated Circuit(s) Cards Interface Devices
25 * Endianness note: from the spec (1.3)
26 * "Fields that are larger than a byte are stored in little endian"
29 * 1. remove/insert can sometimes result in removed state instead of inserted.
30 * This is a result of the following:
31 * symptom: dmesg shows ERMOTEIO (-121), pcscd shows -99. This can happen
32 * when a short packet is sent, as seen in uhci-usb.c, resulting from a urb
33 * from the guest requesting SPD and us returning a smaller packet.
34 * Not sure which messages trigger this.
37 #include "qemu/osdep.h"
38 #include "qemu/units.h"
39 #include "qapi/error.h"
40 #include "qemu-common.h"
41 #include "qemu/error-report.h"
42 #include "qemu/module.h"
43 #include "hw/qdev-properties.h"
45 #include "migration/vmstate.h"
49 #include "qom/object.h"
51 #define DPRINTF(s, lvl, fmt, ...) \
53 if (lvl <= s->debug) { \
54 printf("usb-ccid: " fmt , ## __VA_ARGS__); \
63 #define TYPE_USB_CCID_DEV "usb-ccid"
64 typedef struct USBCCIDState USBCCIDState
;
65 DECLARE_INSTANCE_CHECKER(USBCCIDState
, USB_CCID_DEV
,
68 * The two options for variable sized buffers:
69 * make them constant size, for large enough constant,
70 * or handle the migration complexity - VMState doesn't handle this case.
71 * sizes are expected never to be exceeded, unless guest misbehaves.
73 #define BULK_OUT_DATA_SIZE (64 * KiB)
74 #define PENDING_ANSWERS_NUM 128
76 #define BULK_IN_BUF_SIZE 384
77 #define BULK_IN_PENDING_NUM 8
79 #define CCID_MAX_PACKET_SIZE 64
81 #define CCID_CONTROL_ABORT 0x1
82 #define CCID_CONTROL_GET_CLOCK_FREQUENCIES 0x2
83 #define CCID_CONTROL_GET_DATA_RATES 0x3
85 #define CCID_PRODUCT_DESCRIPTION "QEMU USB CCID"
86 #define CCID_VENDOR_DESCRIPTION "QEMU"
87 #define CCID_INTERFACE_NAME "CCID Interface"
88 #define CCID_SERIAL_NUMBER_STRING "1"
90 * Using Gemplus Vendor and Product id
91 * Effect on various drivers:
92 * usbccid.sys (winxp, others untested) is a class driver so it doesn't care.
93 * linux has a number of class drivers, but openct filters based on
94 * vendor/product (/etc/openct.conf under fedora), hence Gemplus.
96 #define CCID_VENDOR_ID 0x08e6
97 #define CCID_PRODUCT_ID 0x4433
98 #define CCID_DEVICE_VERSION 0x0000
101 * BULK_OUT messages from PC to Reader
102 * Defined in CCID Rev 1.1 6.1 (page 26)
104 #define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn 0x62
105 #define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff 0x63
106 #define CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus 0x65
107 #define CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock 0x6f
108 #define CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters 0x6c
109 #define CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters 0x6d
110 #define CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters 0x61
111 #define CCID_MESSAGE_TYPE_PC_to_RDR_Escape 0x6b
112 #define CCID_MESSAGE_TYPE_PC_to_RDR_IccClock 0x6e
113 #define CCID_MESSAGE_TYPE_PC_to_RDR_T0APDU 0x6a
114 #define CCID_MESSAGE_TYPE_PC_to_RDR_Secure 0x69
115 #define CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical 0x71
116 #define CCID_MESSAGE_TYPE_PC_to_RDR_Abort 0x72
117 #define CCID_MESSAGE_TYPE_PC_to_RDR_SetDataRateAndClockFrequency 0x73
120 * BULK_IN messages from Reader to PC
121 * Defined in CCID Rev 1.1 6.2 (page 48)
123 #define CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock 0x80
124 #define CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus 0x81
125 #define CCID_MESSAGE_TYPE_RDR_to_PC_Parameters 0x82
126 #define CCID_MESSAGE_TYPE_RDR_to_PC_Escape 0x83
127 #define CCID_MESSAGE_TYPE_RDR_to_PC_DataRateAndClockFrequency 0x84
130 * INTERRUPT_IN messages from Reader to PC
131 * Defined in CCID Rev 1.1 6.3 (page 56)
133 #define CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange 0x50
134 #define CCID_MESSAGE_TYPE_RDR_to_PC_HardwareError 0x51
137 * Endpoints for CCID - addresses are up to us to decide.
138 * To support slot insertion and removal we must have an interrupt in ep
139 * in addition we need a bulk in and bulk out ep
142 #define CCID_INT_IN_EP 1
143 #define CCID_BULK_IN_EP 2
144 #define CCID_BULK_OUT_EP 3
146 /* bmSlotICCState masks */
147 #define SLOT_0_STATE_MASK 1
148 #define SLOT_0_CHANGED_MASK 2
150 /* Status codes that go in bStatus (see 6.2.6) */
152 ICC_STATUS_PRESENT_ACTIVE
= 0,
153 ICC_STATUS_PRESENT_INACTIVE
,
154 ICC_STATUS_NOT_PRESENT
158 COMMAND_STATUS_NO_ERROR
= 0,
159 COMMAND_STATUS_FAILED
,
160 COMMAND_STATUS_TIME_EXTENSION_REQUIRED
163 /* Error codes that go in bError (see 6.2.6) */
165 ERROR_CMD_NOT_SUPPORTED
= 0,
166 ERROR_CMD_ABORTED
= -1,
168 ERROR_XFR_PARITY_ERROR
= -3,
169 ERROR_XFR_OVERRUN
= -4,
173 /* 6.2.6 RDR_to_PC_SlotStatus definitions */
175 CLOCK_STATUS_RUNNING
= 0,
177 * 0 - Clock Running, 1 - Clock stopped in State L, 2 - H,
178 * 3 - unknown state. rest are RFU
182 typedef struct QEMU_PACKED CCID_Header
{
183 uint8_t bMessageType
;
189 typedef struct QEMU_PACKED CCID_BULK_IN
{
191 uint8_t bStatus
; /* Only used in BULK_IN */
192 uint8_t bError
; /* Only used in BULK_IN */
195 typedef struct QEMU_PACKED CCID_SlotStatus
{
197 uint8_t bClockStatus
;
200 typedef struct QEMU_PACKED CCID_T0ProtocolDataStructure
{
201 uint8_t bmFindexDindex
;
203 uint8_t bGuardTimeT0
;
204 uint8_t bWaitingIntegerT0
;
206 } CCID_T0ProtocolDataStructure
;
208 typedef struct QEMU_PACKED CCID_T1ProtocolDataStructure
{
209 uint8_t bmFindexDindex
;
211 uint8_t bGuardTimeT1
;
212 uint8_t bWaitingIntegerT1
;
216 } CCID_T1ProtocolDataStructure
;
218 typedef union CCID_ProtocolDataStructure
{
219 CCID_T0ProtocolDataStructure t0
;
220 CCID_T1ProtocolDataStructure t1
;
221 uint8_t data
[7]; /* must be = max(sizeof(t0), sizeof(t1)) */
222 } CCID_ProtocolDataStructure
;
224 typedef struct QEMU_PACKED CCID_Parameter
{
226 uint8_t bProtocolNum
;
227 CCID_ProtocolDataStructure abProtocolDataStructure
;
230 typedef struct QEMU_PACKED CCID_DataBlock
{
232 uint8_t bChainParameter
;
236 /* 6.1.4 PC_to_RDR_XfrBlock */
237 typedef struct QEMU_PACKED CCID_XferBlock
{
239 uint8_t bBWI
; /* Block Waiting Timeout */
240 uint16_t wLevelParameter
; /* XXX currently unused */
244 typedef struct QEMU_PACKED CCID_IccPowerOn
{
246 uint8_t bPowerSelect
;
250 typedef struct QEMU_PACKED CCID_IccPowerOff
{
255 typedef struct QEMU_PACKED CCID_SetParameters
{
257 uint8_t bProtocolNum
;
259 CCID_ProtocolDataStructure abProtocolDataStructure
;
260 } CCID_SetParameters
;
262 typedef struct CCID_Notify_Slot_Change
{
263 uint8_t bMessageType
; /* CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange */
264 uint8_t bmSlotICCState
;
265 } CCID_Notify_Slot_Change
;
267 /* used for DataBlock response to XferBlock */
268 typedef struct Answer
{
273 /* pending BULK_IN messages */
274 typedef struct BulkIn
{
275 uint8_t data
[BULK_IN_BUF_SIZE
];
283 typedef struct CCIDBus CCIDBus
;
286 * powered - defaults to true, changed by PowerOn/PowerOff messages
288 struct USBCCIDState
{
294 BulkIn bulk_in_pending
[BULK_IN_PENDING_NUM
]; /* circular */
295 uint32_t bulk_in_pending_start
;
296 uint32_t bulk_in_pending_end
; /* first free */
297 uint32_t bulk_in_pending_num
;
298 BulkIn
*current_bulk_in
;
299 uint8_t bulk_out_data
[BULK_OUT_DATA_SIZE
];
300 uint32_t bulk_out_pos
;
301 uint64_t last_answer_error
;
302 Answer pending_answers
[PENDING_ANSWERS_NUM
];
303 uint32_t pending_answers_start
;
304 uint32_t pending_answers_end
;
305 uint32_t pending_answers_num
;
307 uint8_t bmCommandStatus
;
308 uint8_t bProtocolNum
;
309 CCID_ProtocolDataStructure abProtocolDataStructure
;
310 uint32_t ulProtocolDataStructureSize
;
311 uint32_t state_vmstate
;
312 uint8_t bmSlotICCState
;
314 uint8_t notify_slot_change
;
319 * CCID Spec chapter 4: CCID uses a standard device descriptor per Chapter 9,
320 * "USB Device Framework", section 9.6.1, in the Universal Serial Bus
323 * This device implemented based on the spec and with an Athena Smart Card
324 * Reader as reference:
325 * 0dc3:1004 Athena Smartcard Solutions, Inc.
328 static const uint8_t qemu_ccid_descriptor
[] = {
329 /* Smart Card Device Class Descriptor */
330 0x36, /* u8 bLength; */
331 0x21, /* u8 bDescriptorType; Functional */
332 0x10, 0x01, /* u16 bcdCCID; CCID Specification Release Number. */
334 * u8 bMaxSlotIndex; The index of the highest available
335 * slot on this device. All slots are consecutive starting
338 0x07, /* u8 bVoltageSupport; 01h - 5.0v, 02h - 3.0, 03 - 1.8 */
340 0x01, 0x00, /* u32 dwProtocols; RRRR PPPP. RRRR = 0000h.*/
341 0x00, 0x00, /* PPPP: 0001h = Protocol T=0, 0002h = Protocol T=1 */
342 /* u32 dwDefaultClock; in kHZ (0x0fa0 is 4 MHz) */
343 0xa0, 0x0f, 0x00, 0x00,
344 /* u32 dwMaximumClock; */
345 0x00, 0x00, 0x01, 0x00,
346 0x00, /* u8 bNumClockSupported; *
347 * 0 means just the default and max. */
348 /* u32 dwDataRate ;bps. 9600 == 00002580h */
349 0x80, 0x25, 0x00, 0x00,
350 /* u32 dwMaxDataRate ; 11520 bps == 0001C200h */
351 0x00, 0xC2, 0x01, 0x00,
352 0x00, /* u8 bNumDataRatesSupported; 00 means all rates between
355 * maximum IFSD supported by CCID for protocol *
356 * T=1 (Maximum seen from various cards) */
357 0xfe, 0x00, 0x00, 0x00,
358 /* u32 dwSyncProtocols; 1 - 2-wire, 2 - 3-wire, 4 - I2C */
359 0x00, 0x00, 0x00, 0x00,
360 /* u32 dwMechanical; 0 - no special characteristics. */
361 0x00, 0x00, 0x00, 0x00,
364 * 0 - No special characteristics
365 * + 2 Automatic parameter configuration based on ATR data
366 * + 4 Automatic activation of ICC on inserting
367 * + 8 Automatic ICC voltage selection
368 * + 10 Automatic ICC clock frequency change
369 * + 20 Automatic baud rate change
370 * + 40 Automatic parameters negotiation made by the CCID
371 * + 80 automatic PPS made by the CCID
372 * 100 CCID can set ICC in clock stop mode
373 * 200 NAD value other then 00 accepted (T=1 protocol)
374 * + 400 Automatic IFSD exchange as first exchange (T=1)
375 * One of the following only:
376 * + 10000 TPDU level exchanges with CCID
377 * 20000 Short APDU level exchange with CCID
378 * 40000 Short and Extended APDU level exchange with CCID
380 * 100000 USB Wake up signaling supported on card
381 * insertion and removal. Must set bit 5 in bmAttributes
382 * in Configuration descriptor if 100000 is set.
384 0xfe, 0x04, 0x01, 0x00,
386 * u32 dwMaxCCIDMessageLength; For extended APDU in
387 * [261 + 10 , 65544 + 10]. Otherwise the minimum is
388 * wMaxPacketSize of the Bulk-OUT endpoint
390 0x12, 0x00, 0x01, 0x00,
392 * u8 bClassGetResponse; Significant only for CCID that
393 * offers an APDU level for exchanges. Indicates the
394 * default class value used by the CCID when it sends a
395 * Get Response command to perform the transportation of
396 * an APDU by T=0 protocol
397 * FFh indicates that the CCID echos the class of the APDU.
400 * u8 bClassEnvelope; EAPDU only. Envelope command for
404 * u16 wLcdLayout; XXYY Number of lines (XX) and chars per
405 * line for LCD display used for PIN entry. 0000 - no LCD
408 * u8 bPINSupport; 01h PIN Verification,
409 * 02h PIN Modification
411 0x01, /* u8 bMaxCCIDBusySlots; */
415 STR_MANUFACTURER
= 1,
421 static const USBDescStrings desc_strings
= {
422 [STR_MANUFACTURER
] = "QEMU",
423 [STR_PRODUCT
] = "QEMU USB CCID",
424 [STR_SERIALNUMBER
] = "1",
425 [STR_INTERFACE
] = "CCID Interface",
428 static const USBDescIface desc_iface0
= {
429 .bInterfaceNumber
= 0,
431 .bInterfaceClass
= USB_CLASS_CSCID
,
432 .bInterfaceSubClass
= USB_SUBCLASS_UNDEFINED
,
433 .bInterfaceProtocol
= 0x00,
434 .iInterface
= STR_INTERFACE
,
436 .descs
= (USBDescOther
[]) {
438 /* smartcard descriptor */
439 .data
= qemu_ccid_descriptor
,
442 .eps
= (USBDescEndpoint
[]) {
444 .bEndpointAddress
= USB_DIR_IN
| CCID_INT_IN_EP
,
445 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
447 .wMaxPacketSize
= 64,
449 .bEndpointAddress
= USB_DIR_IN
| CCID_BULK_IN_EP
,
450 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
451 .wMaxPacketSize
= 64,
453 .bEndpointAddress
= USB_DIR_OUT
| CCID_BULK_OUT_EP
,
454 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
455 .wMaxPacketSize
= 64,
460 static const USBDescDevice desc_device
= {
462 .bMaxPacketSize0
= 64,
463 .bNumConfigurations
= 1,
464 .confs
= (USBDescConfig
[]) {
467 .bConfigurationValue
= 1,
468 .bmAttributes
= USB_CFG_ATT_ONE
| USB_CFG_ATT_SELFPOWER
|
477 static const USBDesc desc_ccid
= {
479 .idVendor
= CCID_VENDOR_ID
,
480 .idProduct
= CCID_PRODUCT_ID
,
481 .bcdDevice
= CCID_DEVICE_VERSION
,
482 .iManufacturer
= STR_MANUFACTURER
,
483 .iProduct
= STR_PRODUCT
,
484 .iSerialNumber
= STR_SERIALNUMBER
,
486 .full
= &desc_device
,
490 static const uint8_t *ccid_card_get_atr(CCIDCardState
*card
, uint32_t *len
)
492 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
495 return cc
->get_atr(card
, len
);
500 static void ccid_card_apdu_from_guest(CCIDCardState
*card
,
504 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
506 if (cc
->apdu_from_guest
) {
507 cc
->apdu_from_guest(card
, apdu
, len
);
511 static bool ccid_has_pending_answers(USBCCIDState
*s
)
513 return s
->pending_answers_num
> 0;
516 static void ccid_clear_pending_answers(USBCCIDState
*s
)
518 s
->pending_answers_num
= 0;
519 s
->pending_answers_start
= 0;
520 s
->pending_answers_end
= 0;
523 static void ccid_print_pending_answers(USBCCIDState
*s
)
528 DPRINTF(s
, D_VERBOSE
, "usb-ccid: pending answers:");
529 if (!ccid_has_pending_answers(s
)) {
530 DPRINTF(s
, D_VERBOSE
, " empty\n");
533 for (i
= s
->pending_answers_start
, count
= s
->pending_answers_num
;
534 count
> 0; count
--, i
++) {
535 answer
= &s
->pending_answers
[i
% PENDING_ANSWERS_NUM
];
537 DPRINTF(s
, D_VERBOSE
, "%d:%d\n", answer
->slot
, answer
->seq
);
539 DPRINTF(s
, D_VERBOSE
, "%d:%d,", answer
->slot
, answer
->seq
);
544 static void ccid_add_pending_answer(USBCCIDState
*s
, CCID_Header
*hdr
)
548 assert(s
->pending_answers_num
< PENDING_ANSWERS_NUM
);
549 s
->pending_answers_num
++;
551 &s
->pending_answers
[(s
->pending_answers_end
++) % PENDING_ANSWERS_NUM
];
552 answer
->slot
= hdr
->bSlot
;
553 answer
->seq
= hdr
->bSeq
;
554 ccid_print_pending_answers(s
);
557 static void ccid_remove_pending_answer(USBCCIDState
*s
,
558 uint8_t *slot
, uint8_t *seq
)
562 assert(s
->pending_answers_num
> 0);
563 s
->pending_answers_num
--;
565 &s
->pending_answers
[(s
->pending_answers_start
++) % PENDING_ANSWERS_NUM
];
566 *slot
= answer
->slot
;
568 ccid_print_pending_answers(s
);
571 static void ccid_bulk_in_clear(USBCCIDState
*s
)
573 s
->bulk_in_pending_start
= 0;
574 s
->bulk_in_pending_end
= 0;
575 s
->bulk_in_pending_num
= 0;
578 static void ccid_bulk_in_release(USBCCIDState
*s
)
580 assert(s
->current_bulk_in
!= NULL
);
581 s
->current_bulk_in
->pos
= 0;
582 s
->current_bulk_in
= NULL
;
585 static void ccid_bulk_in_get(USBCCIDState
*s
)
587 if (s
->current_bulk_in
!= NULL
|| s
->bulk_in_pending_num
== 0) {
590 assert(s
->bulk_in_pending_num
> 0);
591 s
->bulk_in_pending_num
--;
593 &s
->bulk_in_pending
[(s
->bulk_in_pending_start
++) % BULK_IN_PENDING_NUM
];
596 static void *ccid_reserve_recv_buf(USBCCIDState
*s
, uint16_t len
)
600 DPRINTF(s
, D_VERBOSE
, "%s: QUEUE: reserve %d bytes\n", __func__
, len
);
602 /* look for an existing element */
603 if (len
> BULK_IN_BUF_SIZE
) {
604 DPRINTF(s
, D_WARN
, "usb-ccid.c: %s: len larger then max (%d>%d). "
605 "discarding message.\n",
606 __func__
, len
, BULK_IN_BUF_SIZE
);
609 if (s
->bulk_in_pending_num
>= BULK_IN_PENDING_NUM
) {
610 DPRINTF(s
, D_WARN
, "usb-ccid.c: %s: No free bulk_in buffers. "
611 "discarding message.\n", __func__
);
615 &s
->bulk_in_pending
[(s
->bulk_in_pending_end
++) % BULK_IN_PENDING_NUM
];
616 s
->bulk_in_pending_num
++;
618 return bulk_in
->data
;
621 static void ccid_reset(USBCCIDState
*s
)
623 ccid_bulk_in_clear(s
);
624 ccid_clear_pending_answers(s
);
627 static void ccid_detach(USBCCIDState
*s
)
632 static void ccid_handle_reset(USBDevice
*dev
)
634 USBCCIDState
*s
= USB_CCID_DEV(dev
);
636 DPRINTF(s
, 1, "Reset\n");
641 static const char *ccid_control_to_str(USBCCIDState
*s
, int request
)
644 /* generic - should be factored out if there are other debugees */
645 case DeviceOutRequest
| USB_REQ_SET_ADDRESS
:
646 return "(generic) set address";
647 case DeviceRequest
| USB_REQ_GET_DESCRIPTOR
:
648 return "(generic) get descriptor";
649 case DeviceRequest
| USB_REQ_GET_CONFIGURATION
:
650 return "(generic) get configuration";
651 case DeviceOutRequest
| USB_REQ_SET_CONFIGURATION
:
652 return "(generic) set configuration";
653 case DeviceRequest
| USB_REQ_GET_STATUS
:
654 return "(generic) get status";
655 case DeviceOutRequest
| USB_REQ_CLEAR_FEATURE
:
656 return "(generic) clear feature";
657 case DeviceOutRequest
| USB_REQ_SET_FEATURE
:
658 return "(generic) set_feature";
659 case InterfaceRequest
| USB_REQ_GET_INTERFACE
:
660 return "(generic) get interface";
661 case InterfaceOutRequest
| USB_REQ_SET_INTERFACE
:
662 return "(generic) set interface";
664 case ClassInterfaceOutRequest
| CCID_CONTROL_ABORT
:
666 case ClassInterfaceRequest
| CCID_CONTROL_GET_CLOCK_FREQUENCIES
:
667 return "GET_CLOCK_FREQUENCIES";
668 case ClassInterfaceRequest
| CCID_CONTROL_GET_DATA_RATES
:
669 return "GET_DATA_RATES";
674 static void ccid_handle_control(USBDevice
*dev
, USBPacket
*p
, int request
,
675 int value
, int index
, int length
, uint8_t *data
)
677 USBCCIDState
*s
= USB_CCID_DEV(dev
);
680 DPRINTF(s
, 1, "%s: got control %s (%x), value %x\n", __func__
,
681 ccid_control_to_str(s
, request
), request
, value
);
682 ret
= usb_desc_handle_control(dev
, p
, request
, value
, index
, length
, data
);
688 /* Class specific requests. */
689 case ClassInterfaceOutRequest
| CCID_CONTROL_ABORT
:
690 DPRINTF(s
, 1, "ccid_control abort UNIMPLEMENTED\n");
691 p
->status
= USB_RET_STALL
;
693 case ClassInterfaceRequest
| CCID_CONTROL_GET_CLOCK_FREQUENCIES
:
694 DPRINTF(s
, 1, "ccid_control get clock frequencies UNIMPLEMENTED\n");
695 p
->status
= USB_RET_STALL
;
697 case ClassInterfaceRequest
| CCID_CONTROL_GET_DATA_RATES
:
698 DPRINTF(s
, 1, "ccid_control get data rates UNIMPLEMENTED\n");
699 p
->status
= USB_RET_STALL
;
702 DPRINTF(s
, 1, "got unsupported/bogus control %x, value %x\n",
704 p
->status
= USB_RET_STALL
;
709 static bool ccid_card_inserted(USBCCIDState
*s
)
711 return s
->bmSlotICCState
& SLOT_0_STATE_MASK
;
714 static uint8_t ccid_card_status(USBCCIDState
*s
)
716 return ccid_card_inserted(s
)
718 ICC_STATUS_PRESENT_ACTIVE
719 : ICC_STATUS_PRESENT_INACTIVE
721 : ICC_STATUS_NOT_PRESENT
;
724 static uint8_t ccid_calc_status(USBCCIDState
*s
)
727 * page 55, 6.2.6, calculation of bStatus from bmICCStatus and
730 uint8_t ret
= ccid_card_status(s
) | (s
->bmCommandStatus
<< 6);
731 DPRINTF(s
, D_VERBOSE
, "%s: status = %d\n", __func__
, ret
);
735 static void ccid_reset_error_status(USBCCIDState
*s
)
737 s
->bError
= ERROR_CMD_NOT_SUPPORTED
;
738 s
->bmCommandStatus
= COMMAND_STATUS_NO_ERROR
;
741 static void ccid_write_slot_status(USBCCIDState
*s
, CCID_Header
*recv
)
743 CCID_SlotStatus
*h
= ccid_reserve_recv_buf(s
, sizeof(CCID_SlotStatus
));
747 h
->b
.hdr
.bMessageType
= CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus
;
748 h
->b
.hdr
.dwLength
= 0;
749 h
->b
.hdr
.bSlot
= recv
->bSlot
;
750 h
->b
.hdr
.bSeq
= recv
->bSeq
;
751 h
->b
.bStatus
= ccid_calc_status(s
);
752 h
->b
.bError
= s
->bError
;
753 h
->bClockStatus
= CLOCK_STATUS_RUNNING
;
754 ccid_reset_error_status(s
);
755 usb_wakeup(s
->bulk
, 0);
758 static void ccid_write_parameters(USBCCIDState
*s
, CCID_Header
*recv
)
761 uint32_t len
= s
->ulProtocolDataStructureSize
;
763 h
= ccid_reserve_recv_buf(s
, sizeof(CCID_Parameter
) + len
);
767 h
->b
.hdr
.bMessageType
= CCID_MESSAGE_TYPE_RDR_to_PC_Parameters
;
768 h
->b
.hdr
.dwLength
= 0;
769 h
->b
.hdr
.bSlot
= recv
->bSlot
;
770 h
->b
.hdr
.bSeq
= recv
->bSeq
;
771 h
->b
.bStatus
= ccid_calc_status(s
);
772 h
->b
.bError
= s
->bError
;
773 h
->bProtocolNum
= s
->bProtocolNum
;
774 h
->abProtocolDataStructure
= s
->abProtocolDataStructure
;
775 ccid_reset_error_status(s
);
776 usb_wakeup(s
->bulk
, 0);
779 static void ccid_write_data_block(USBCCIDState
*s
, uint8_t slot
, uint8_t seq
,
780 const uint8_t *data
, uint32_t len
)
782 CCID_DataBlock
*p
= ccid_reserve_recv_buf(s
, sizeof(*p
) + len
);
787 p
->b
.hdr
.bMessageType
= CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock
;
788 p
->b
.hdr
.dwLength
= cpu_to_le32(len
);
789 p
->b
.hdr
.bSlot
= slot
;
791 p
->b
.bStatus
= ccid_calc_status(s
);
792 p
->b
.bError
= s
->bError
;
794 DPRINTF(s
, D_VERBOSE
, "error %d\n", p
->b
.bError
);
798 memcpy(p
->abData
, data
, len
);
800 ccid_reset_error_status(s
);
801 usb_wakeup(s
->bulk
, 0);
804 static void ccid_report_error_failed(USBCCIDState
*s
, uint8_t error
)
806 s
->bmCommandStatus
= COMMAND_STATUS_FAILED
;
810 static void ccid_write_data_block_answer(USBCCIDState
*s
,
811 const uint8_t *data
, uint32_t len
)
816 if (!ccid_has_pending_answers(s
)) {
817 DPRINTF(s
, D_WARN
, "error: no pending answer to return to guest\n");
818 ccid_report_error_failed(s
, ERROR_ICC_MUTE
);
821 ccid_remove_pending_answer(s
, &slot
, &seq
);
822 ccid_write_data_block(s
, slot
, seq
, data
, len
);
825 static uint8_t atr_get_protocol_num(const uint8_t *atr
, uint32_t len
)
829 if (len
< 2 || !(atr
[1] & 0x80)) {
830 /* too short or TD1 not included */
831 return 0; /* T=0, default */
833 i
= 1 + !!(atr
[1] & 0x10) + !!(atr
[1] & 0x20) + !!(atr
[1] & 0x40);
834 i
+= !!(atr
[1] & 0x80);
835 return atr
[i
] & 0x0f;
838 static void ccid_write_data_block_atr(USBCCIDState
*s
, CCID_Header
*recv
)
840 const uint8_t *atr
= NULL
;
842 uint8_t atr_protocol_num
;
843 CCID_T0ProtocolDataStructure
*t0
= &s
->abProtocolDataStructure
.t0
;
844 CCID_T1ProtocolDataStructure
*t1
= &s
->abProtocolDataStructure
.t1
;
847 atr
= ccid_card_get_atr(s
->card
, &len
);
849 atr_protocol_num
= atr_get_protocol_num(atr
, len
);
850 DPRINTF(s
, D_VERBOSE
, "%s: atr contains protocol=%d\n", __func__
,
852 /* set parameters from ATR - see spec page 109 */
853 s
->bProtocolNum
= (atr_protocol_num
<= 1 ? atr_protocol_num
855 switch (atr_protocol_num
) {
857 /* TODO: unimplemented ATR T0 parameters */
858 t0
->bmFindexDindex
= 0;
860 t0
->bGuardTimeT0
= 0;
861 t0
->bWaitingIntegerT0
= 0;
865 /* TODO: unimplemented ATR T1 parameters */
866 t1
->bmFindexDindex
= 0;
868 t1
->bGuardTimeT1
= 0;
869 t1
->bWaitingIntegerT1
= 0;
875 DPRINTF(s
, D_WARN
, "%s: error: unsupported ATR protocol %d\n",
876 __func__
, atr_protocol_num
);
878 ccid_write_data_block(s
, recv
->bSlot
, recv
->bSeq
, atr
, len
);
881 static void ccid_set_parameters(USBCCIDState
*s
, CCID_Header
*recv
)
883 CCID_SetParameters
*ph
= (CCID_SetParameters
*) recv
;
884 uint32_t protocol_num
= ph
->bProtocolNum
& 3;
886 if (protocol_num
!= 0 && protocol_num
!= 1) {
887 ccid_report_error_failed(s
, ERROR_CMD_NOT_SUPPORTED
);
890 s
->bProtocolNum
= protocol_num
;
891 s
->abProtocolDataStructure
= ph
->abProtocolDataStructure
;
895 * must be 5 bytes for T=0, 7 bytes for T=1
898 static const CCID_ProtocolDataStructure defaultProtocolDataStructure
= {
900 .bmFindexDindex
= 0x77,
902 .bGuardTimeT1
= 0x00,
903 .bWaitingIntegerT1
= 0x00,
910 static void ccid_reset_parameters(USBCCIDState
*s
)
912 s
->bProtocolNum
= 0; /* T=0 */
913 s
->abProtocolDataStructure
= defaultProtocolDataStructure
;
916 /* NOTE: only a single slot is supported (SLOT_0) */
917 static void ccid_on_slot_change(USBCCIDState
*s
, bool full
)
919 /* RDR_to_PC_NotifySlotChange, 6.3.1 page 56 */
920 uint8_t current
= s
->bmSlotICCState
;
922 s
->bmSlotICCState
|= SLOT_0_STATE_MASK
;
924 s
->bmSlotICCState
&= ~SLOT_0_STATE_MASK
;
926 if (current
!= s
->bmSlotICCState
) {
927 s
->bmSlotICCState
|= SLOT_0_CHANGED_MASK
;
929 s
->notify_slot_change
= true;
930 usb_wakeup(s
->intr
, 0);
933 static void ccid_write_data_block_error(
934 USBCCIDState
*s
, uint8_t slot
, uint8_t seq
)
936 ccid_write_data_block(s
, slot
, seq
, NULL
, 0);
939 static void ccid_on_apdu_from_guest(USBCCIDState
*s
, CCID_XferBlock
*recv
)
943 if (ccid_card_status(s
) != ICC_STATUS_PRESENT_ACTIVE
) {
945 "usb-ccid: not sending apdu to client, no card connected\n");
946 ccid_write_data_block_error(s
, recv
->hdr
.bSlot
, recv
->hdr
.bSeq
);
949 len
= le32_to_cpu(recv
->hdr
.dwLength
);
950 DPRINTF(s
, 1, "%s: seq %d, len %d\n", __func__
,
951 recv
->hdr
.bSeq
, len
);
952 ccid_add_pending_answer(s
, (CCID_Header
*)recv
);
953 if (s
->card
&& len
<= BULK_OUT_DATA_SIZE
) {
954 ccid_card_apdu_from_guest(s
->card
, recv
->abData
, len
);
956 DPRINTF(s
, D_WARN
, "warning: discarded apdu\n");
960 static const char *ccid_message_type_to_str(uint8_t type
)
963 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn
: return "IccPowerOn";
964 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff
: return "IccPowerOff";
965 case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus
: return "GetSlotStatus";
966 case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock
: return "XfrBlock";
967 case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters
: return "GetParameters";
968 case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters
: return "ResetParameters";
969 case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters
: return "SetParameters";
970 case CCID_MESSAGE_TYPE_PC_to_RDR_Escape
: return "Escape";
971 case CCID_MESSAGE_TYPE_PC_to_RDR_IccClock
: return "IccClock";
972 case CCID_MESSAGE_TYPE_PC_to_RDR_T0APDU
: return "T0APDU";
973 case CCID_MESSAGE_TYPE_PC_to_RDR_Secure
: return "Secure";
974 case CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical
: return "Mechanical";
975 case CCID_MESSAGE_TYPE_PC_to_RDR_Abort
: return "Abort";
976 case CCID_MESSAGE_TYPE_PC_to_RDR_SetDataRateAndClockFrequency
:
977 return "SetDataRateAndClockFrequency";
982 static void ccid_handle_bulk_out(USBCCIDState
*s
, USBPacket
*p
)
984 CCID_Header
*ccid_header
;
986 if (p
->iov
.size
+ s
->bulk_out_pos
> BULK_OUT_DATA_SIZE
) {
989 usb_packet_copy(p
, s
->bulk_out_data
+ s
->bulk_out_pos
, p
->iov
.size
);
990 s
->bulk_out_pos
+= p
->iov
.size
;
991 if (s
->bulk_out_pos
< 10) {
992 DPRINTF(s
, 1, "%s: header incomplete\n", __func__
);
996 ccid_header
= (CCID_Header
*)s
->bulk_out_data
;
997 if ((s
->bulk_out_pos
- 10 < ccid_header
->dwLength
) &&
998 (p
->iov
.size
== CCID_MAX_PACKET_SIZE
)) {
999 DPRINTF(s
, D_VERBOSE
,
1000 "usb-ccid: bulk_in: expecting more packets (%d/%d)\n",
1001 s
->bulk_out_pos
- 10, ccid_header
->dwLength
);
1004 if (s
->bulk_out_pos
- 10 != ccid_header
->dwLength
) {
1006 "usb-ccid: bulk_in: message size mismatch (got %d, expected %d)\n",
1007 s
->bulk_out_pos
- 10, ccid_header
->dwLength
);
1011 DPRINTF(s
, D_MORE_INFO
, "%s %x %s\n", __func__
,
1012 ccid_header
->bMessageType
,
1013 ccid_message_type_to_str(ccid_header
->bMessageType
));
1014 switch (ccid_header
->bMessageType
) {
1015 case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus
:
1016 ccid_write_slot_status(s
, ccid_header
);
1018 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn
:
1019 DPRINTF(s
, 1, "%s: PowerOn: %d\n", __func__
,
1020 ((CCID_IccPowerOn
*)(ccid_header
))->bPowerSelect
);
1022 if (!ccid_card_inserted(s
)) {
1023 ccid_report_error_failed(s
, ERROR_ICC_MUTE
);
1025 /* atr is written regardless of error. */
1026 ccid_write_data_block_atr(s
, ccid_header
);
1028 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff
:
1029 ccid_reset_error_status(s
);
1031 ccid_write_slot_status(s
, ccid_header
);
1033 case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock
:
1034 ccid_on_apdu_from_guest(s
, (CCID_XferBlock
*)s
->bulk_out_data
);
1036 case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters
:
1037 ccid_reset_error_status(s
);
1038 ccid_set_parameters(s
, ccid_header
);
1039 ccid_write_parameters(s
, ccid_header
);
1041 case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters
:
1042 ccid_reset_error_status(s
);
1043 ccid_reset_parameters(s
);
1044 ccid_write_parameters(s
, ccid_header
);
1046 case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters
:
1047 ccid_reset_error_status(s
);
1048 ccid_write_parameters(s
, ccid_header
);
1050 case CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical
:
1051 ccid_report_error_failed(s
, 0);
1052 ccid_write_slot_status(s
, ccid_header
);
1056 "handle_data: ERROR: unhandled message type %Xh\n",
1057 ccid_header
->bMessageType
);
1059 * The caller is expecting the device to respond, tell it we
1060 * don't support the operation.
1062 ccid_report_error_failed(s
, ERROR_CMD_NOT_SUPPORTED
);
1063 ccid_write_slot_status(s
, ccid_header
);
1066 s
->bulk_out_pos
= 0;
1070 p
->status
= USB_RET_STALL
;
1071 s
->bulk_out_pos
= 0;
1075 static void ccid_bulk_in_copy_to_guest(USBCCIDState
*s
, USBPacket
*p
,
1076 unsigned int max_packet_size
)
1080 ccid_bulk_in_get(s
);
1081 if (s
->current_bulk_in
!= NULL
) {
1082 len
= MIN(s
->current_bulk_in
->len
- s
->current_bulk_in
->pos
,
1085 usb_packet_copy(p
, s
->current_bulk_in
->data
+
1086 s
->current_bulk_in
->pos
, len
);
1088 s
->current_bulk_in
->pos
+= len
;
1089 if (s
->current_bulk_in
->pos
== s
->current_bulk_in
->len
1090 && len
!= max_packet_size
) {
1091 ccid_bulk_in_release(s
);
1094 /* return when device has no data - usb 2.0 spec Table 8-4 */
1095 p
->status
= USB_RET_NAK
;
1098 DPRINTF(s
, D_MORE_INFO
,
1099 "%s: %zd/%d req/act to guest (BULK_IN)\n",
1100 __func__
, p
->iov
.size
, len
);
1102 if (len
< p
->iov
.size
) {
1104 "%s: returning short (EREMOTEIO) %d < %zd\n",
1105 __func__
, len
, p
->iov
.size
);
1109 static void ccid_handle_data(USBDevice
*dev
, USBPacket
*p
)
1111 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1116 ccid_handle_bulk_out(s
, p
);
1120 switch (p
->ep
->nr
) {
1121 case CCID_BULK_IN_EP
:
1122 ccid_bulk_in_copy_to_guest(s
, p
, dev
->ep_ctl
.max_packet_size
);
1124 case CCID_INT_IN_EP
:
1125 if (s
->notify_slot_change
) {
1126 /* page 56, RDR_to_PC_NotifySlotChange */
1127 buf
[0] = CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange
;
1128 buf
[1] = s
->bmSlotICCState
;
1129 usb_packet_copy(p
, buf
, 2);
1130 s
->notify_slot_change
= false;
1131 s
->bmSlotICCState
&= ~SLOT_0_CHANGED_MASK
;
1133 "handle_data: int_in: notify_slot_change %X, "
1134 "requested len %zd\n",
1135 s
->bmSlotICCState
, p
->iov
.size
);
1137 p
->status
= USB_RET_NAK
;
1141 DPRINTF(s
, 1, "Bad endpoint\n");
1142 p
->status
= USB_RET_STALL
;
1147 DPRINTF(s
, 1, "Bad token\n");
1148 p
->status
= USB_RET_STALL
;
1153 static void ccid_unrealize(USBDevice
*dev
)
1155 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1157 ccid_bulk_in_clear(s
);
1160 static void ccid_flush_pending_answers(USBCCIDState
*s
)
1162 while (ccid_has_pending_answers(s
)) {
1163 ccid_write_data_block_answer(s
, NULL
, 0);
1167 static Answer
*ccid_peek_next_answer(USBCCIDState
*s
)
1169 return s
->pending_answers_num
== 0
1171 : &s
->pending_answers
[s
->pending_answers_start
% PENDING_ANSWERS_NUM
];
1174 static Property ccid_props
[] = {
1175 DEFINE_PROP_UINT32("slot", struct CCIDCardState
, slot
, 0),
1176 DEFINE_PROP_END_OF_LIST(),
1179 #define TYPE_CCID_BUS "ccid-bus"
1180 DECLARE_INSTANCE_CHECKER(CCIDBus
, CCID_BUS
,
1183 static const TypeInfo ccid_bus_info
= {
1184 .name
= TYPE_CCID_BUS
,
1186 .instance_size
= sizeof(CCIDBus
),
1189 void ccid_card_send_apdu_to_guest(CCIDCardState
*card
,
1190 uint8_t *apdu
, uint32_t len
)
1192 DeviceState
*qdev
= DEVICE(card
);
1193 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1194 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1197 if (!ccid_has_pending_answers(s
)) {
1198 DPRINTF(s
, 1, "CCID ERROR: got an APDU without pending answers\n");
1201 s
->bmCommandStatus
= COMMAND_STATUS_NO_ERROR
;
1202 answer
= ccid_peek_next_answer(s
);
1203 if (answer
== NULL
) {
1204 DPRINTF(s
, D_WARN
, "%s: error: unexpected lack of answer\n", __func__
);
1205 ccid_report_error_failed(s
, ERROR_HW_ERROR
);
1208 DPRINTF(s
, 1, "APDU returned to guest %d (answer seq %d, slot %d)\n",
1209 len
, answer
->seq
, answer
->slot
);
1210 ccid_write_data_block_answer(s
, apdu
, len
);
1213 void ccid_card_card_removed(CCIDCardState
*card
)
1215 DeviceState
*qdev
= DEVICE(card
);
1216 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1217 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1219 ccid_on_slot_change(s
, false);
1220 ccid_flush_pending_answers(s
);
1224 int ccid_card_ccid_attach(CCIDCardState
*card
)
1226 DeviceState
*qdev
= DEVICE(card
);
1227 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1228 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1230 DPRINTF(s
, 1, "CCID Attach\n");
1234 void ccid_card_ccid_detach(CCIDCardState
*card
)
1236 DeviceState
*qdev
= DEVICE(card
);
1237 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1238 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1240 DPRINTF(s
, 1, "CCID Detach\n");
1241 if (ccid_card_inserted(s
)) {
1242 ccid_on_slot_change(s
, false);
1247 void ccid_card_card_error(CCIDCardState
*card
, uint64_t error
)
1249 DeviceState
*qdev
= DEVICE(card
);
1250 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1251 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1253 s
->bmCommandStatus
= COMMAND_STATUS_FAILED
;
1254 s
->last_answer_error
= error
;
1255 DPRINTF(s
, 1, "VSC_Error: %" PRIX64
"\n", s
->last_answer_error
);
1256 /* TODO: these errors should be more verbose and propagated to the guest.*/
1258 * We flush all pending answers on CardRemove message in ccid-card-passthru,
1259 * so check that first to not trigger abort
1261 if (ccid_has_pending_answers(s
)) {
1262 ccid_write_data_block_answer(s
, NULL
, 0);
1266 void ccid_card_card_inserted(CCIDCardState
*card
)
1268 DeviceState
*qdev
= DEVICE(card
);
1269 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1270 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1272 s
->bmCommandStatus
= COMMAND_STATUS_NO_ERROR
;
1273 ccid_flush_pending_answers(s
);
1274 ccid_on_slot_change(s
, true);
1277 static void ccid_card_unrealize(DeviceState
*qdev
)
1279 CCIDCardState
*card
= CCID_CARD(qdev
);
1280 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
1281 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1282 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1284 if (ccid_card_inserted(s
)) {
1285 ccid_card_card_removed(card
);
1287 if (cc
->unrealize
) {
1288 cc
->unrealize(card
);
1293 static void ccid_card_realize(DeviceState
*qdev
, Error
**errp
)
1295 CCIDCardState
*card
= CCID_CARD(qdev
);
1296 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
1297 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1298 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1299 Error
*local_err
= NULL
;
1301 if (card
->slot
!= 0) {
1302 error_setg(errp
, "usb-ccid supports one slot, can't add %d",
1306 if (s
->card
!= NULL
) {
1307 error_setg(errp
, "usb-ccid card already full, not adding");
1311 cc
->realize(card
, &local_err
);
1312 if (local_err
!= NULL
) {
1313 error_propagate(errp
, local_err
);
1320 static void ccid_realize(USBDevice
*dev
, Error
**errp
)
1322 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1324 usb_desc_create_serial(dev
);
1326 qbus_create_inplace(&s
->bus
, sizeof(s
->bus
), TYPE_CCID_BUS
, DEVICE(dev
),
1328 qbus_set_hotplug_handler(BUS(&s
->bus
), OBJECT(dev
));
1329 s
->intr
= usb_ep_get(dev
, USB_TOKEN_IN
, CCID_INT_IN_EP
);
1330 s
->bulk
= usb_ep_get(dev
, USB_TOKEN_IN
, CCID_BULK_IN_EP
);
1332 s
->dev
.speed
= USB_SPEED_FULL
;
1333 s
->dev
.speedmask
= USB_SPEED_MASK_FULL
;
1334 s
->notify_slot_change
= false;
1336 s
->pending_answers_num
= 0;
1337 s
->last_answer_error
= 0;
1338 s
->bulk_in_pending_start
= 0;
1339 s
->bulk_in_pending_end
= 0;
1340 s
->current_bulk_in
= NULL
;
1341 ccid_reset_error_status(s
);
1342 s
->bulk_out_pos
= 0;
1343 ccid_reset_parameters(s
);
1345 s
->debug
= parse_debug_env("QEMU_CCID_DEBUG", D_VERBOSE
, s
->debug
);
1348 static int ccid_post_load(void *opaque
, int version_id
)
1350 USBCCIDState
*s
= opaque
;
1353 * This must be done after usb_device_attach, which sets state to ATTACHED,
1354 * while it must be DEFAULT in order to accept packets (like it is after
1355 * reset, but reset will reset our addr and call our reset handler which
1356 * may change state, and we don't want to do that when migrating).
1358 s
->dev
.state
= s
->state_vmstate
;
1362 static int ccid_pre_save(void *opaque
)
1364 USBCCIDState
*s
= opaque
;
1366 s
->state_vmstate
= s
->dev
.state
;
1371 static VMStateDescription bulk_in_vmstate
= {
1372 .name
= "CCID BulkIn state",
1374 .minimum_version_id
= 1,
1375 .fields
= (VMStateField
[]) {
1376 VMSTATE_BUFFER(data
, BulkIn
),
1377 VMSTATE_UINT32(len
, BulkIn
),
1378 VMSTATE_UINT32(pos
, BulkIn
),
1379 VMSTATE_END_OF_LIST()
1383 static VMStateDescription answer_vmstate
= {
1384 .name
= "CCID Answer state",
1386 .minimum_version_id
= 1,
1387 .fields
= (VMStateField
[]) {
1388 VMSTATE_UINT8(slot
, Answer
),
1389 VMSTATE_UINT8(seq
, Answer
),
1390 VMSTATE_END_OF_LIST()
1394 static VMStateDescription usb_device_vmstate
= {
1395 .name
= "usb_device",
1397 .minimum_version_id
= 1,
1398 .fields
= (VMStateField
[]) {
1399 VMSTATE_UINT8(addr
, USBDevice
),
1400 VMSTATE_BUFFER(setup_buf
, USBDevice
),
1401 VMSTATE_BUFFER(data_buf
, USBDevice
),
1402 VMSTATE_END_OF_LIST()
1406 static VMStateDescription ccid_vmstate
= {
1409 .minimum_version_id
= 1,
1410 .post_load
= ccid_post_load
,
1411 .pre_save
= ccid_pre_save
,
1412 .fields
= (VMStateField
[]) {
1413 VMSTATE_STRUCT(dev
, USBCCIDState
, 1, usb_device_vmstate
, USBDevice
),
1414 VMSTATE_UINT8(debug
, USBCCIDState
),
1415 VMSTATE_BUFFER(bulk_out_data
, USBCCIDState
),
1416 VMSTATE_UINT32(bulk_out_pos
, USBCCIDState
),
1417 VMSTATE_UINT8(bmSlotICCState
, USBCCIDState
),
1418 VMSTATE_UINT8(powered
, USBCCIDState
),
1419 VMSTATE_UINT8(notify_slot_change
, USBCCIDState
),
1420 VMSTATE_UINT64(last_answer_error
, USBCCIDState
),
1421 VMSTATE_UINT8(bError
, USBCCIDState
),
1422 VMSTATE_UINT8(bmCommandStatus
, USBCCIDState
),
1423 VMSTATE_UINT8(bProtocolNum
, USBCCIDState
),
1424 VMSTATE_BUFFER(abProtocolDataStructure
.data
, USBCCIDState
),
1425 VMSTATE_UINT32(ulProtocolDataStructureSize
, USBCCIDState
),
1426 VMSTATE_STRUCT_ARRAY(bulk_in_pending
, USBCCIDState
,
1427 BULK_IN_PENDING_NUM
, 1, bulk_in_vmstate
, BulkIn
),
1428 VMSTATE_UINT32(bulk_in_pending_start
, USBCCIDState
),
1429 VMSTATE_UINT32(bulk_in_pending_end
, USBCCIDState
),
1430 VMSTATE_STRUCT_ARRAY(pending_answers
, USBCCIDState
,
1431 PENDING_ANSWERS_NUM
, 1, answer_vmstate
, Answer
),
1432 VMSTATE_UINT32(pending_answers_num
, USBCCIDState
),
1433 VMSTATE_UNUSED(1), /* was migration_state */
1434 VMSTATE_UINT32(state_vmstate
, USBCCIDState
),
1435 VMSTATE_END_OF_LIST()
1439 static Property ccid_properties
[] = {
1440 DEFINE_PROP_UINT8("debug", USBCCIDState
, debug
, 0),
1441 DEFINE_PROP_END_OF_LIST(),
1444 static void ccid_class_initfn(ObjectClass
*klass
, void *data
)
1446 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1447 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
1448 HotplugHandlerClass
*hc
= HOTPLUG_HANDLER_CLASS(klass
);
1450 uc
->realize
= ccid_realize
;
1451 uc
->product_desc
= "QEMU USB CCID";
1452 uc
->usb_desc
= &desc_ccid
;
1453 uc
->handle_reset
= ccid_handle_reset
;
1454 uc
->handle_control
= ccid_handle_control
;
1455 uc
->handle_data
= ccid_handle_data
;
1456 uc
->unrealize
= ccid_unrealize
;
1457 dc
->desc
= "CCID Rev 1.1 smartcard reader";
1458 dc
->vmsd
= &ccid_vmstate
;
1459 device_class_set_props(dc
, ccid_properties
);
1460 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
1461 hc
->unplug
= qdev_simple_device_unplug_cb
;
1464 static const TypeInfo ccid_info
= {
1465 .name
= TYPE_USB_CCID_DEV
,
1466 .parent
= TYPE_USB_DEVICE
,
1467 .instance_size
= sizeof(USBCCIDState
),
1468 .class_init
= ccid_class_initfn
,
1469 .interfaces
= (InterfaceInfo
[]) {
1470 { TYPE_HOTPLUG_HANDLER
},
1475 static void ccid_card_class_init(ObjectClass
*klass
, void *data
)
1477 DeviceClass
*k
= DEVICE_CLASS(klass
);
1478 k
->bus_type
= TYPE_CCID_BUS
;
1479 k
->realize
= ccid_card_realize
;
1480 k
->unrealize
= ccid_card_unrealize
;
1481 device_class_set_props(k
, ccid_props
);
1484 static const TypeInfo ccid_card_type_info
= {
1485 .name
= TYPE_CCID_CARD
,
1486 .parent
= TYPE_DEVICE
,
1487 .instance_size
= sizeof(CCIDCardState
),
1489 .class_size
= sizeof(CCIDCardClass
),
1490 .class_init
= ccid_card_class_init
,
1493 static void ccid_register_types(void)
1495 type_register_static(&ccid_bus_info
);
1496 type_register_static(&ccid_card_type_info
);
1497 type_register_static(&ccid_info
);
1498 usb_legacy_register(TYPE_USB_CCID_DEV
, "ccid", NULL
);
1501 type_init(ccid_register_types
)