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-common.h"
38 #include "qemu/error-report.h"
40 #include "hw/usb/desc.h"
41 #include "monitor/monitor.h"
45 #define DPRINTF(s, lvl, fmt, ...) \
47 if (lvl <= s->debug) { \
48 printf("usb-ccid: " fmt , ## __VA_ARGS__); \
57 #define CCID_DEV_NAME "usb-ccid"
60 * The two options for variable sized buffers:
61 * make them constant size, for large enough constant,
62 * or handle the migration complexity - VMState doesn't handle this case.
63 * sizes are expected never to be exceeded, unless guest misbehaves.
65 #define BULK_OUT_DATA_SIZE 65536
66 #define PENDING_ANSWERS_NUM 128
68 #define BULK_IN_BUF_SIZE 384
69 #define BULK_IN_PENDING_NUM 8
71 #define InterfaceOutClass \
72 ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE)<<8)
74 #define InterfaceInClass \
75 ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE)<<8)
77 #define CCID_MAX_PACKET_SIZE 64
79 #define CCID_CONTROL_ABORT 0x1
80 #define CCID_CONTROL_GET_CLOCK_FREQUENCIES 0x2
81 #define CCID_CONTROL_GET_DATA_RATES 0x3
83 #define CCID_PRODUCT_DESCRIPTION "QEMU USB CCID"
84 #define CCID_VENDOR_DESCRIPTION "QEMU"
85 #define CCID_INTERFACE_NAME "CCID Interface"
86 #define CCID_SERIAL_NUMBER_STRING "1"
88 * Using Gemplus Vendor and Product id
89 * Effect on various drivers:
90 * usbccid.sys (winxp, others untested) is a class driver so it doesn't care.
91 * linux has a number of class drivers, but openct filters based on
92 * vendor/product (/etc/openct.conf under fedora), hence Gemplus.
94 #define CCID_VENDOR_ID 0x08e6
95 #define CCID_PRODUCT_ID 0x4433
96 #define CCID_DEVICE_VERSION 0x0000
99 * BULK_OUT messages from PC to Reader
100 * Defined in CCID Rev 1.1 6.1 (page 26)
102 #define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn 0x62
103 #define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff 0x63
104 #define CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus 0x65
105 #define CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock 0x6f
106 #define CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters 0x6c
107 #define CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters 0x6d
108 #define CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters 0x61
109 #define CCID_MESSAGE_TYPE_PC_to_RDR_Escape 0x6b
110 #define CCID_MESSAGE_TYPE_PC_to_RDR_IccClock 0x6e
111 #define CCID_MESSAGE_TYPE_PC_to_RDR_T0APDU 0x6a
112 #define CCID_MESSAGE_TYPE_PC_to_RDR_Secure 0x69
113 #define CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical 0x71
114 #define CCID_MESSAGE_TYPE_PC_to_RDR_Abort 0x72
115 #define CCID_MESSAGE_TYPE_PC_to_RDR_SetDataRateAndClockFrequency 0x73
118 * BULK_IN messages from Reader to PC
119 * Defined in CCID Rev 1.1 6.2 (page 48)
121 #define CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock 0x80
122 #define CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus 0x81
123 #define CCID_MESSAGE_TYPE_RDR_to_PC_Parameters 0x82
124 #define CCID_MESSAGE_TYPE_RDR_to_PC_Escape 0x83
125 #define CCID_MESSAGE_TYPE_RDR_to_PC_DataRateAndClockFrequency 0x84
128 * INTERRUPT_IN messages from Reader to PC
129 * Defined in CCID Rev 1.1 6.3 (page 56)
131 #define CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange 0x50
132 #define CCID_MESSAGE_TYPE_RDR_to_PC_HardwareError 0x51
135 * Endpoints for CCID - addresses are up to us to decide.
136 * To support slot insertion and removal we must have an interrupt in ep
137 * in addition we need a bulk in and bulk out ep
140 #define CCID_INT_IN_EP 1
141 #define CCID_BULK_IN_EP 2
142 #define CCID_BULK_OUT_EP 3
144 /* bmSlotICCState masks */
145 #define SLOT_0_STATE_MASK 1
146 #define SLOT_0_CHANGED_MASK 2
148 /* Status codes that go in bStatus (see 6.2.6) */
150 ICC_STATUS_PRESENT_ACTIVE
= 0,
151 ICC_STATUS_PRESENT_INACTIVE
,
152 ICC_STATUS_NOT_PRESENT
156 COMMAND_STATUS_NO_ERROR
= 0,
157 COMMAND_STATUS_FAILED
,
158 COMMAND_STATUS_TIME_EXTENSION_REQUIRED
161 /* Error codes that go in bError (see 6.2.6) */
163 ERROR_CMD_NOT_SUPPORTED
= 0,
164 ERROR_CMD_ABORTED
= -1,
166 ERROR_XFR_PARITY_ERROR
= -3,
167 ERROR_XFR_OVERRUN
= -4,
171 /* 6.2.6 RDR_to_PC_SlotStatus definitions */
173 CLOCK_STATUS_RUNNING
= 0,
175 * 0 - Clock Running, 1 - Clock stopped in State L, 2 - H,
176 * 3 - unknown state. rest are RFU
180 typedef struct QEMU_PACKED CCID_Header
{
181 uint8_t bMessageType
;
187 typedef struct QEMU_PACKED CCID_BULK_IN
{
189 uint8_t bStatus
; /* Only used in BULK_IN */
190 uint8_t bError
; /* Only used in BULK_IN */
193 typedef struct QEMU_PACKED CCID_SlotStatus
{
195 uint8_t bClockStatus
;
198 typedef struct QEMU_PACKED CCID_Parameter
{
200 uint8_t bProtocolNum
;
201 uint8_t abProtocolDataStructure
[0];
204 typedef struct QEMU_PACKED CCID_DataBlock
{
206 uint8_t bChainParameter
;
210 /* 6.1.4 PC_to_RDR_XfrBlock */
211 typedef struct QEMU_PACKED CCID_XferBlock
{
213 uint8_t bBWI
; /* Block Waiting Timeout */
214 uint16_t wLevelParameter
; /* XXX currently unused */
218 typedef struct QEMU_PACKED CCID_IccPowerOn
{
220 uint8_t bPowerSelect
;
224 typedef struct QEMU_PACKED CCID_IccPowerOff
{
229 typedef struct QEMU_PACKED CCID_SetParameters
{
231 uint8_t bProtocolNum
;
233 uint8_t abProtocolDataStructure
[0];
234 } CCID_SetParameters
;
236 typedef struct CCID_Notify_Slot_Change
{
237 uint8_t bMessageType
; /* CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange */
238 uint8_t bmSlotICCState
;
239 } CCID_Notify_Slot_Change
;
241 /* used for DataBlock response to XferBlock */
242 typedef struct Answer
{
247 /* pending BULK_IN messages */
248 typedef struct BulkIn
{
249 uint8_t data
[BULK_IN_BUF_SIZE
];
259 typedef struct CCIDBus
{
263 #define MAX_PROTOCOL_SIZE 7
266 * powered - defaults to true, changed by PowerOn/PowerOff messages
268 typedef struct USBCCIDState
{
273 BulkIn bulk_in_pending
[BULK_IN_PENDING_NUM
]; /* circular */
274 uint32_t bulk_in_pending_start
;
275 uint32_t bulk_in_pending_end
; /* first free */
276 uint32_t bulk_in_pending_num
;
277 BulkIn
*current_bulk_in
;
278 uint8_t bulk_out_data
[BULK_OUT_DATA_SIZE
];
279 uint32_t bulk_out_pos
;
280 uint64_t last_answer_error
;
281 Answer pending_answers
[PENDING_ANSWERS_NUM
];
282 uint32_t pending_answers_start
;
283 uint32_t pending_answers_end
;
284 uint32_t pending_answers_num
;
286 uint8_t bmCommandStatus
;
287 uint8_t bProtocolNum
;
288 uint8_t abProtocolDataStructure
[MAX_PROTOCOL_SIZE
];
289 uint32_t ulProtocolDataStructureSize
;
290 uint32_t state_vmstate
;
291 uint32_t migration_target_ip
;
292 uint16_t migration_target_port
;
293 uint8_t migration_state
;
294 uint8_t bmSlotICCState
;
296 uint8_t notify_slot_change
;
301 * CCID Spec chapter 4: CCID uses a standard device descriptor per Chapter 9,
302 * "USB Device Framework", section 9.6.1, in the Universal Serial Bus
305 * This device implemented based on the spec and with an Athena Smart Card
306 * Reader as reference:
307 * 0dc3:1004 Athena Smartcard Solutions, Inc.
310 static const uint8_t qemu_ccid_descriptor
[] = {
311 /* Smart Card Device Class Descriptor */
312 0x36, /* u8 bLength; */
313 0x21, /* u8 bDescriptorType; Functional */
314 0x10, 0x01, /* u16 bcdCCID; CCID Specification Release Number. */
316 * u8 bMaxSlotIndex; The index of the highest available
317 * slot on this device. All slots are consecutive starting
320 0x07, /* u8 bVoltageSupport; 01h - 5.0v, 02h - 3.0, 03 - 1.8 */
322 0x03, 0x00, /* u32 dwProtocols; RRRR PPPP. RRRR = 0000h.*/
323 0x00, 0x00, /* PPPP: 0001h = Protocol T=0, 0002h = Protocol T=1 */
324 /* u32 dwDefaultClock; in kHZ (0x0fa0 is 4 MHz) */
325 0xa0, 0x0f, 0x00, 0x00,
326 /* u32 dwMaximumClock; */
327 0x00, 0x00, 0x01, 0x00,
328 0x00, /* u8 bNumClockSupported; *
329 * 0 means just the default and max. */
330 /* u32 dwDataRate ;bps. 9600 == 00002580h */
331 0x80, 0x25, 0x00, 0x00,
332 /* u32 dwMaxDataRate ; 11520 bps == 0001C200h */
333 0x00, 0xC2, 0x01, 0x00,
334 0x00, /* u8 bNumDataRatesSupported; 00 means all rates between
337 * maximum IFSD supported by CCID for protocol *
338 * T=1 (Maximum seen from various cards) */
339 0xfe, 0x00, 0x00, 0x00,
340 /* u32 dwSyncProtocols; 1 - 2-wire, 2 - 3-wire, 4 - I2C */
341 0x00, 0x00, 0x00, 0x00,
342 /* u32 dwMechanical; 0 - no special characteristics. */
343 0x00, 0x00, 0x00, 0x00,
346 * 0 - No special characteristics
347 * + 2 Automatic parameter configuration based on ATR data
348 * + 4 Automatic activation of ICC on inserting
349 * + 8 Automatic ICC voltage selection
350 * + 10 Automatic ICC clock frequency change
351 * + 20 Automatic baud rate change
352 * + 40 Automatic parameters negotiation made by the CCID
353 * + 80 automatic PPS made by the CCID
354 * 100 CCID can set ICC in clock stop mode
355 * 200 NAD value other then 00 accepted (T=1 protocol)
356 * + 400 Automatic IFSD exchange as first exchange (T=1)
357 * One of the following only:
358 * + 10000 TPDU level exchanges with CCID
359 * 20000 Short APDU level exchange with CCID
360 * 40000 Short and Extended APDU level exchange with CCID
362 * + 100000 USB Wake up signaling supported on card
363 * insertion and removal. Must set bit 5 in bmAttributes
364 * in Configuration descriptor if 100000 is set.
366 0xfe, 0x04, 0x11, 0x00,
368 * u32 dwMaxCCIDMessageLength; For extended APDU in
369 * [261 + 10 , 65544 + 10]. Otherwise the minimum is
370 * wMaxPacketSize of the Bulk-OUT endpoint
372 0x12, 0x00, 0x01, 0x00,
374 * u8 bClassGetResponse; Significant only for CCID that
375 * offers an APDU level for exchanges. Indicates the
376 * default class value used by the CCID when it sends a
377 * Get Response command to perform the transportation of
378 * an APDU by T=0 protocol
379 * FFh indicates that the CCID echos the class of the APDU.
382 * u8 bClassEnvelope; EAPDU only. Envelope command for
386 * u16 wLcdLayout; XXYY Number of lines (XX) and chars per
387 * line for LCD display used for PIN entry. 0000 - no LCD
390 * u8 bPINSupport; 01h PIN Verification,
391 * 02h PIN Modification
393 0x01, /* u8 bMaxCCIDBusySlots; */
397 STR_MANUFACTURER
= 1,
403 static const USBDescStrings desc_strings
= {
404 [STR_MANUFACTURER
] = "QEMU",
405 [STR_PRODUCT
] = "QEMU USB CCID",
406 [STR_SERIALNUMBER
] = "1",
407 [STR_INTERFACE
] = "CCID Interface",
410 static const USBDescIface desc_iface0
= {
411 .bInterfaceNumber
= 0,
413 .bInterfaceClass
= 0x0b,
414 .bInterfaceSubClass
= 0x00,
415 .bInterfaceProtocol
= 0x00,
416 .iInterface
= STR_INTERFACE
,
418 .descs
= (USBDescOther
[]) {
420 /* smartcard descriptor */
421 .data
= qemu_ccid_descriptor
,
424 .eps
= (USBDescEndpoint
[]) {
426 .bEndpointAddress
= USB_DIR_IN
| CCID_INT_IN_EP
,
427 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
429 .wMaxPacketSize
= 64,
431 .bEndpointAddress
= USB_DIR_IN
| CCID_BULK_IN_EP
,
432 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
433 .wMaxPacketSize
= 64,
435 .bEndpointAddress
= USB_DIR_OUT
| CCID_BULK_OUT_EP
,
436 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
437 .wMaxPacketSize
= 64,
442 static const USBDescDevice desc_device
= {
444 .bMaxPacketSize0
= 64,
445 .bNumConfigurations
= 1,
446 .confs
= (USBDescConfig
[]) {
449 .bConfigurationValue
= 1,
450 .bmAttributes
= 0xe0,
458 static const USBDesc desc_ccid
= {
460 .idVendor
= CCID_VENDOR_ID
,
461 .idProduct
= CCID_PRODUCT_ID
,
462 .bcdDevice
= CCID_DEVICE_VERSION
,
463 .iManufacturer
= STR_MANUFACTURER
,
464 .iProduct
= STR_PRODUCT
,
465 .iSerialNumber
= STR_SERIALNUMBER
,
467 .full
= &desc_device
,
471 static const uint8_t *ccid_card_get_atr(CCIDCardState
*card
, uint32_t *len
)
473 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
476 return cc
->get_atr(card
, len
);
481 static void ccid_card_apdu_from_guest(CCIDCardState
*card
,
485 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
487 if (cc
->apdu_from_guest
) {
488 cc
->apdu_from_guest(card
, apdu
, len
);
492 static int ccid_card_exitfn(CCIDCardState
*card
)
494 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
497 return cc
->exitfn(card
);
502 static int ccid_card_initfn(CCIDCardState
*card
)
504 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
507 return cc
->initfn(card
);
512 static bool ccid_has_pending_answers(USBCCIDState
*s
)
514 return s
->pending_answers_num
> 0;
517 static void ccid_clear_pending_answers(USBCCIDState
*s
)
519 s
->pending_answers_num
= 0;
520 s
->pending_answers_start
= 0;
521 s
->pending_answers_end
= 0;
524 static void ccid_print_pending_answers(USBCCIDState
*s
)
529 DPRINTF(s
, D_VERBOSE
, "usb-ccid: pending answers:");
530 if (!ccid_has_pending_answers(s
)) {
531 DPRINTF(s
, D_VERBOSE
, " empty\n");
534 for (i
= s
->pending_answers_start
, count
= s
->pending_answers_num
;
535 count
> 0; count
--, i
++) {
536 answer
= &s
->pending_answers
[i
% PENDING_ANSWERS_NUM
];
538 DPRINTF(s
, D_VERBOSE
, "%d:%d\n", answer
->slot
, answer
->seq
);
540 DPRINTF(s
, D_VERBOSE
, "%d:%d,", answer
->slot
, answer
->seq
);
545 static void ccid_add_pending_answer(USBCCIDState
*s
, CCID_Header
*hdr
)
549 assert(s
->pending_answers_num
< PENDING_ANSWERS_NUM
);
550 s
->pending_answers_num
++;
552 &s
->pending_answers
[(s
->pending_answers_end
++) % PENDING_ANSWERS_NUM
];
553 answer
->slot
= hdr
->bSlot
;
554 answer
->seq
= hdr
->bSeq
;
555 ccid_print_pending_answers(s
);
558 static void ccid_remove_pending_answer(USBCCIDState
*s
,
559 uint8_t *slot
, uint8_t *seq
)
563 assert(s
->pending_answers_num
> 0);
564 s
->pending_answers_num
--;
566 &s
->pending_answers
[(s
->pending_answers_start
++) % PENDING_ANSWERS_NUM
];
567 *slot
= answer
->slot
;
569 ccid_print_pending_answers(s
);
572 static void ccid_bulk_in_clear(USBCCIDState
*s
)
574 s
->bulk_in_pending_start
= 0;
575 s
->bulk_in_pending_end
= 0;
576 s
->bulk_in_pending_num
= 0;
579 static void ccid_bulk_in_release(USBCCIDState
*s
)
581 assert(s
->current_bulk_in
!= NULL
);
582 s
->current_bulk_in
->pos
= 0;
583 s
->current_bulk_in
= NULL
;
586 static void ccid_bulk_in_get(USBCCIDState
*s
)
588 if (s
->current_bulk_in
!= NULL
|| s
->bulk_in_pending_num
== 0) {
591 assert(s
->bulk_in_pending_num
> 0);
592 s
->bulk_in_pending_num
--;
594 &s
->bulk_in_pending
[(s
->bulk_in_pending_start
++) % BULK_IN_PENDING_NUM
];
597 static void *ccid_reserve_recv_buf(USBCCIDState
*s
, uint16_t len
)
601 DPRINTF(s
, D_VERBOSE
, "%s: QUEUE: reserve %d bytes\n", __func__
, len
);
603 /* look for an existing element */
604 if (len
> BULK_IN_BUF_SIZE
) {
605 DPRINTF(s
, D_WARN
, "usb-ccid.c: %s: len larger then max (%d>%d). "
606 "discarding message.\n",
607 __func__
, len
, BULK_IN_BUF_SIZE
);
610 if (s
->bulk_in_pending_num
>= BULK_IN_PENDING_NUM
) {
611 DPRINTF(s
, D_WARN
, "usb-ccid.c: %s: No free bulk_in buffers. "
612 "discarding message.\n", __func__
);
616 &s
->bulk_in_pending
[(s
->bulk_in_pending_end
++) % BULK_IN_PENDING_NUM
];
617 s
->bulk_in_pending_num
++;
619 return bulk_in
->data
;
622 static void ccid_reset(USBCCIDState
*s
)
624 ccid_bulk_in_clear(s
);
625 ccid_clear_pending_answers(s
);
628 static void ccid_detach(USBCCIDState
*s
)
633 static void ccid_handle_reset(USBDevice
*dev
)
635 USBCCIDState
*s
= DO_UPCAST(USBCCIDState
, dev
, dev
);
637 DPRINTF(s
, 1, "Reset\n");
642 static const char *ccid_control_to_str(USBCCIDState
*s
, int request
)
645 /* generic - should be factored out if there are other debugees */
646 case DeviceOutRequest
| USB_REQ_SET_ADDRESS
:
647 return "(generic) set address";
648 case DeviceRequest
| USB_REQ_GET_DESCRIPTOR
:
649 return "(generic) get descriptor";
650 case DeviceRequest
| USB_REQ_GET_CONFIGURATION
:
651 return "(generic) get configuration";
652 case DeviceOutRequest
| USB_REQ_SET_CONFIGURATION
:
653 return "(generic) set configuration";
654 case DeviceRequest
| USB_REQ_GET_STATUS
:
655 return "(generic) get status";
656 case DeviceOutRequest
| USB_REQ_CLEAR_FEATURE
:
657 return "(generic) clear feature";
658 case DeviceOutRequest
| USB_REQ_SET_FEATURE
:
659 return "(generic) set_feature";
660 case InterfaceRequest
| USB_REQ_GET_INTERFACE
:
661 return "(generic) get interface";
662 case InterfaceOutRequest
| USB_REQ_SET_INTERFACE
:
663 return "(generic) set interface";
665 case ClassInterfaceOutRequest
| CCID_CONTROL_ABORT
:
667 case ClassInterfaceRequest
| CCID_CONTROL_GET_CLOCK_FREQUENCIES
:
668 return "GET_CLOCK_FREQUENCIES";
669 case ClassInterfaceRequest
| CCID_CONTROL_GET_DATA_RATES
:
670 return "GET_DATA_RATES";
675 static void ccid_handle_control(USBDevice
*dev
, USBPacket
*p
, int request
,
676 int value
, int index
, int length
, uint8_t *data
)
678 USBCCIDState
*s
= DO_UPCAST(USBCCIDState
, dev
, dev
);
681 DPRINTF(s
, 1, "%s: got control %s (%x), value %x\n", __func__
,
682 ccid_control_to_str(s
, request
), request
, value
);
683 ret
= usb_desc_handle_control(dev
, p
, request
, value
, index
, length
, data
);
689 /* Class specific requests. */
690 case InterfaceOutClass
| CCID_CONTROL_ABORT
:
691 DPRINTF(s
, 1, "ccid_control abort UNIMPLEMENTED\n");
692 p
->status
= USB_RET_STALL
;
694 case InterfaceInClass
| CCID_CONTROL_GET_CLOCK_FREQUENCIES
:
695 DPRINTF(s
, 1, "ccid_control get clock frequencies UNIMPLEMENTED\n");
696 p
->status
= USB_RET_STALL
;
698 case InterfaceInClass
| CCID_CONTROL_GET_DATA_RATES
:
699 DPRINTF(s
, 1, "ccid_control get data rates UNIMPLEMENTED\n");
700 p
->status
= USB_RET_STALL
;
703 DPRINTF(s
, 1, "got unsupported/bogus control %x, value %x\n",
705 p
->status
= USB_RET_STALL
;
710 static bool ccid_card_inserted(USBCCIDState
*s
)
712 return s
->bmSlotICCState
& SLOT_0_STATE_MASK
;
715 static uint8_t ccid_card_status(USBCCIDState
*s
)
717 return ccid_card_inserted(s
)
719 ICC_STATUS_PRESENT_ACTIVE
720 : ICC_STATUS_PRESENT_INACTIVE
722 : ICC_STATUS_NOT_PRESENT
;
725 static uint8_t ccid_calc_status(USBCCIDState
*s
)
728 * page 55, 6.2.6, calculation of bStatus from bmICCStatus and
731 uint8_t ret
= ccid_card_status(s
) | (s
->bmCommandStatus
<< 6);
732 DPRINTF(s
, D_VERBOSE
, "%s: status = %d\n", __func__
, ret
);
736 static void ccid_reset_error_status(USBCCIDState
*s
)
738 s
->bError
= ERROR_CMD_NOT_SUPPORTED
;
739 s
->bmCommandStatus
= COMMAND_STATUS_NO_ERROR
;
742 static void ccid_write_slot_status(USBCCIDState
*s
, CCID_Header
*recv
)
744 CCID_SlotStatus
*h
= ccid_reserve_recv_buf(s
, sizeof(CCID_SlotStatus
));
748 h
->b
.hdr
.bMessageType
= CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus
;
749 h
->b
.hdr
.dwLength
= 0;
750 h
->b
.hdr
.bSlot
= recv
->bSlot
;
751 h
->b
.hdr
.bSeq
= recv
->bSeq
;
752 h
->b
.bStatus
= ccid_calc_status(s
);
753 h
->b
.bError
= s
->bError
;
754 h
->bClockStatus
= CLOCK_STATUS_RUNNING
;
755 ccid_reset_error_status(s
);
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 memcpy(h
->abProtocolDataStructure
, s
->abProtocolDataStructure
, len
);
775 ccid_reset_error_status(s
);
778 static void ccid_write_data_block(USBCCIDState
*s
, uint8_t slot
, uint8_t seq
,
779 const uint8_t *data
, uint32_t len
)
781 CCID_DataBlock
*p
= ccid_reserve_recv_buf(s
, sizeof(*p
) + len
);
786 p
->b
.hdr
.bMessageType
= CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock
;
787 p
->b
.hdr
.dwLength
= cpu_to_le32(len
);
788 p
->b
.hdr
.bSlot
= slot
;
790 p
->b
.bStatus
= ccid_calc_status(s
);
791 p
->b
.bError
= s
->bError
;
793 DPRINTF(s
, D_VERBOSE
, "error %d\n", p
->b
.bError
);
795 memcpy(p
->abData
, data
, len
);
796 ccid_reset_error_status(s
);
799 static void ccid_write_data_block_answer(USBCCIDState
*s
,
800 const uint8_t *data
, uint32_t len
)
805 if (!ccid_has_pending_answers(s
)) {
808 ccid_remove_pending_answer(s
, &slot
, &seq
);
809 ccid_write_data_block(s
, slot
, seq
, data
, len
);
812 static void ccid_write_data_block_atr(USBCCIDState
*s
, CCID_Header
*recv
)
814 const uint8_t *atr
= NULL
;
818 atr
= ccid_card_get_atr(s
->card
, &len
);
820 ccid_write_data_block(s
, recv
->bSlot
, recv
->bSeq
, atr
, len
);
823 static void ccid_set_parameters(USBCCIDState
*s
, CCID_Header
*recv
)
825 CCID_SetParameters
*ph
= (CCID_SetParameters
*) recv
;
827 if ((ph
->bProtocolNum
& 3) == 0) {
830 if ((ph
->bProtocolNum
& 3) == 1) {
834 s
->bmCommandStatus
= COMMAND_STATUS_FAILED
;
835 s
->bError
= 7; /* Protocol invalid or not supported */
838 s
->bProtocolNum
= ph
->bProtocolNum
;
839 memcpy(s
->abProtocolDataStructure
, ph
->abProtocolDataStructure
, len
);
840 s
->ulProtocolDataStructureSize
= len
;
841 DPRINTF(s
, 1, "%s: using len %d\n", __func__
, len
);
845 * must be 5 bytes for T=0, 7 bytes for T=1
848 static const uint8_t abDefaultProtocolDataStructure
[7] = {
849 0x77, 0x00, 0x00, 0x00, 0x00, 0xfe /*IFSC*/, 0x00 /*NAD*/ };
851 static void ccid_reset_parameters(USBCCIDState
*s
)
853 uint32_t len
= sizeof(abDefaultProtocolDataStructure
);
855 s
->bProtocolNum
= 1; /* T=1 */
856 s
->ulProtocolDataStructureSize
= len
;
857 memcpy(s
->abProtocolDataStructure
, abDefaultProtocolDataStructure
, len
);
860 static void ccid_report_error_failed(USBCCIDState
*s
, uint8_t error
)
862 s
->bmCommandStatus
= COMMAND_STATUS_FAILED
;
866 /* NOTE: only a single slot is supported (SLOT_0) */
867 static void ccid_on_slot_change(USBCCIDState
*s
, bool full
)
869 /* RDR_to_PC_NotifySlotChange, 6.3.1 page 56 */
870 uint8_t current
= s
->bmSlotICCState
;
872 s
->bmSlotICCState
|= SLOT_0_STATE_MASK
;
874 s
->bmSlotICCState
&= ~SLOT_0_STATE_MASK
;
876 if (current
!= s
->bmSlotICCState
) {
877 s
->bmSlotICCState
|= SLOT_0_CHANGED_MASK
;
879 s
->notify_slot_change
= true;
880 usb_wakeup(s
->intr
, 0);
883 static void ccid_write_data_block_error(
884 USBCCIDState
*s
, uint8_t slot
, uint8_t seq
)
886 ccid_write_data_block(s
, slot
, seq
, NULL
, 0);
889 static void ccid_on_apdu_from_guest(USBCCIDState
*s
, CCID_XferBlock
*recv
)
893 if (ccid_card_status(s
) != ICC_STATUS_PRESENT_ACTIVE
) {
895 "usb-ccid: not sending apdu to client, no card connected\n");
896 ccid_write_data_block_error(s
, recv
->hdr
.bSlot
, recv
->hdr
.bSeq
);
899 len
= le32_to_cpu(recv
->hdr
.dwLength
);
900 DPRINTF(s
, 1, "%s: seq %d, len %d\n", __func__
,
901 recv
->hdr
.bSeq
, len
);
902 ccid_add_pending_answer(s
, (CCID_Header
*)recv
);
904 ccid_card_apdu_from_guest(s
->card
, recv
->abData
, len
);
906 DPRINTF(s
, D_WARN
, "warning: discarded apdu\n");
910 static const char *ccid_message_type_to_str(uint8_t type
)
913 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn
: return "IccPowerOn";
914 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff
: return "IccPowerOff";
915 case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus
: return "GetSlotStatus";
916 case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock
: return "XfrBlock";
917 case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters
: return "GetParameters";
918 case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters
: return "ResetParameters";
919 case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters
: return "SetParameters";
920 case CCID_MESSAGE_TYPE_PC_to_RDR_Escape
: return "Escape";
921 case CCID_MESSAGE_TYPE_PC_to_RDR_IccClock
: return "IccClock";
922 case CCID_MESSAGE_TYPE_PC_to_RDR_T0APDU
: return "T0APDU";
923 case CCID_MESSAGE_TYPE_PC_to_RDR_Secure
: return "Secure";
924 case CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical
: return "Mechanical";
925 case CCID_MESSAGE_TYPE_PC_to_RDR_Abort
: return "Abort";
926 case CCID_MESSAGE_TYPE_PC_to_RDR_SetDataRateAndClockFrequency
:
927 return "SetDataRateAndClockFrequency";
932 static void ccid_handle_bulk_out(USBCCIDState
*s
, USBPacket
*p
)
934 CCID_Header
*ccid_header
;
936 if (p
->iov
.size
+ s
->bulk_out_pos
> BULK_OUT_DATA_SIZE
) {
937 p
->status
= USB_RET_STALL
;
940 ccid_header
= (CCID_Header
*)s
->bulk_out_data
;
941 usb_packet_copy(p
, s
->bulk_out_data
+ s
->bulk_out_pos
, p
->iov
.size
);
942 s
->bulk_out_pos
+= p
->iov
.size
;
943 if (p
->iov
.size
== CCID_MAX_PACKET_SIZE
) {
944 DPRINTF(s
, D_VERBOSE
,
945 "usb-ccid: bulk_in: expecting more packets (%zd/%d)\n",
946 p
->iov
.size
, ccid_header
->dwLength
);
949 if (s
->bulk_out_pos
< 10) {
951 "%s: bad USB_TOKEN_OUT length, should be at least 10 bytes\n",
954 DPRINTF(s
, D_MORE_INFO
, "%s %x %s\n", __func__
,
955 ccid_header
->bMessageType
,
956 ccid_message_type_to_str(ccid_header
->bMessageType
));
957 switch (ccid_header
->bMessageType
) {
958 case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus
:
959 ccid_write_slot_status(s
, ccid_header
);
961 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn
:
962 DPRINTF(s
, 1, "%s: PowerOn: %d\n", __func__
,
963 ((CCID_IccPowerOn
*)(ccid_header
))->bPowerSelect
);
965 if (!ccid_card_inserted(s
)) {
966 ccid_report_error_failed(s
, ERROR_ICC_MUTE
);
968 /* atr is written regardless of error. */
969 ccid_write_data_block_atr(s
, ccid_header
);
971 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff
:
972 ccid_reset_error_status(s
);
974 ccid_write_slot_status(s
, ccid_header
);
976 case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock
:
977 ccid_on_apdu_from_guest(s
, (CCID_XferBlock
*)s
->bulk_out_data
);
979 case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters
:
980 ccid_reset_error_status(s
);
981 ccid_set_parameters(s
, ccid_header
);
982 ccid_write_parameters(s
, ccid_header
);
984 case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters
:
985 ccid_reset_error_status(s
);
986 ccid_reset_parameters(s
);
987 ccid_write_parameters(s
, ccid_header
);
989 case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters
:
990 ccid_reset_error_status(s
);
991 ccid_write_parameters(s
, ccid_header
);
995 "handle_data: ERROR: unhandled message type %Xh\n",
996 ccid_header
->bMessageType
);
998 * The caller is expecting the device to respond, tell it we
999 * don't support the operation.
1001 ccid_report_error_failed(s
, ERROR_CMD_NOT_SUPPORTED
);
1002 ccid_write_slot_status(s
, ccid_header
);
1006 s
->bulk_out_pos
= 0;
1009 static void ccid_bulk_in_copy_to_guest(USBCCIDState
*s
, USBPacket
*p
)
1013 ccid_bulk_in_get(s
);
1014 if (s
->current_bulk_in
!= NULL
) {
1015 len
= MIN(s
->current_bulk_in
->len
- s
->current_bulk_in
->pos
,
1017 usb_packet_copy(p
, s
->current_bulk_in
->data
+
1018 s
->current_bulk_in
->pos
, len
);
1019 s
->current_bulk_in
->pos
+= len
;
1020 if (s
->current_bulk_in
->pos
== s
->current_bulk_in
->len
) {
1021 ccid_bulk_in_release(s
);
1024 /* return when device has no data - usb 2.0 spec Table 8-4 */
1025 p
->status
= USB_RET_NAK
;
1028 DPRINTF(s
, D_MORE_INFO
,
1029 "%s: %zd/%d req/act to guest (BULK_IN)\n",
1030 __func__
, p
->iov
.size
, len
);
1032 if (len
< p
->iov
.size
) {
1034 "%s: returning short (EREMOTEIO) %d < %zd\n",
1035 __func__
, len
, p
->iov
.size
);
1039 static void ccid_handle_data(USBDevice
*dev
, USBPacket
*p
)
1041 USBCCIDState
*s
= DO_UPCAST(USBCCIDState
, dev
, dev
);
1046 ccid_handle_bulk_out(s
, p
);
1050 switch (p
->ep
->nr
) {
1051 case CCID_BULK_IN_EP
:
1052 ccid_bulk_in_copy_to_guest(s
, p
);
1054 case CCID_INT_IN_EP
:
1055 if (s
->notify_slot_change
) {
1056 /* page 56, RDR_to_PC_NotifySlotChange */
1057 buf
[0] = CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange
;
1058 buf
[1] = s
->bmSlotICCState
;
1059 usb_packet_copy(p
, buf
, 2);
1060 s
->notify_slot_change
= false;
1061 s
->bmSlotICCState
&= ~SLOT_0_CHANGED_MASK
;
1063 "handle_data: int_in: notify_slot_change %X, "
1064 "requested len %zd\n",
1065 s
->bmSlotICCState
, p
->iov
.size
);
1067 p
->status
= USB_RET_NAK
;
1071 DPRINTF(s
, 1, "Bad endpoint\n");
1072 p
->status
= USB_RET_STALL
;
1077 DPRINTF(s
, 1, "Bad token\n");
1078 p
->status
= USB_RET_STALL
;
1083 static void ccid_handle_destroy(USBDevice
*dev
)
1085 USBCCIDState
*s
= DO_UPCAST(USBCCIDState
, dev
, dev
);
1087 ccid_bulk_in_clear(s
);
1090 static void ccid_flush_pending_answers(USBCCIDState
*s
)
1092 while (ccid_has_pending_answers(s
)) {
1093 ccid_write_data_block_answer(s
, NULL
, 0);
1097 static Answer
*ccid_peek_next_answer(USBCCIDState
*s
)
1099 return s
->pending_answers_num
== 0
1101 : &s
->pending_answers
[s
->pending_answers_start
% PENDING_ANSWERS_NUM
];
1104 static Property ccid_props
[] = {
1105 DEFINE_PROP_UINT32("slot", struct CCIDCardState
, slot
, 0),
1106 DEFINE_PROP_END_OF_LIST(),
1109 #define TYPE_CCID_BUS "ccid-bus"
1110 #define CCID_BUS(obj) OBJECT_CHECK(CCIDBus, (obj), TYPE_CCID_BUS)
1112 static const TypeInfo ccid_bus_info
= {
1113 .name
= TYPE_CCID_BUS
,
1115 .instance_size
= sizeof(CCIDBus
),
1118 void ccid_card_send_apdu_to_guest(CCIDCardState
*card
,
1119 uint8_t *apdu
, uint32_t len
)
1121 USBCCIDState
*s
= DO_UPCAST(USBCCIDState
, dev
.qdev
,
1122 card
->qdev
.parent_bus
->parent
);
1125 if (!ccid_has_pending_answers(s
)) {
1126 DPRINTF(s
, 1, "CCID ERROR: got an APDU without pending answers\n");
1129 s
->bmCommandStatus
= COMMAND_STATUS_NO_ERROR
;
1130 answer
= ccid_peek_next_answer(s
);
1131 if (answer
== NULL
) {
1134 DPRINTF(s
, 1, "APDU returned to guest %d (answer seq %d, slot %d)\n",
1135 len
, answer
->seq
, answer
->slot
);
1136 ccid_write_data_block_answer(s
, apdu
, len
);
1139 void ccid_card_card_removed(CCIDCardState
*card
)
1142 DO_UPCAST(USBCCIDState
, dev
.qdev
, card
->qdev
.parent_bus
->parent
);
1144 ccid_on_slot_change(s
, false);
1145 ccid_flush_pending_answers(s
);
1149 int ccid_card_ccid_attach(CCIDCardState
*card
)
1152 DO_UPCAST(USBCCIDState
, dev
.qdev
, card
->qdev
.parent_bus
->parent
);
1154 DPRINTF(s
, 1, "CCID Attach\n");
1155 if (s
->migration_state
== MIGRATION_MIGRATED
) {
1156 s
->migration_state
= MIGRATION_NONE
;
1161 void ccid_card_ccid_detach(CCIDCardState
*card
)
1164 DO_UPCAST(USBCCIDState
, dev
.qdev
, card
->qdev
.parent_bus
->parent
);
1166 DPRINTF(s
, 1, "CCID Detach\n");
1167 if (ccid_card_inserted(s
)) {
1168 ccid_on_slot_change(s
, false);
1173 void ccid_card_card_error(CCIDCardState
*card
, uint64_t error
)
1176 DO_UPCAST(USBCCIDState
, dev
.qdev
, card
->qdev
.parent_bus
->parent
);
1178 s
->bmCommandStatus
= COMMAND_STATUS_FAILED
;
1179 s
->last_answer_error
= error
;
1180 DPRINTF(s
, 1, "VSC_Error: %" PRIX64
"\n", s
->last_answer_error
);
1181 /* TODO: these errors should be more verbose and propagated to the guest.*/
1183 * We flush all pending answers on CardRemove message in ccid-card-passthru,
1184 * so check that first to not trigger abort
1186 if (ccid_has_pending_answers(s
)) {
1187 ccid_write_data_block_answer(s
, NULL
, 0);
1191 void ccid_card_card_inserted(CCIDCardState
*card
)
1194 DO_UPCAST(USBCCIDState
, dev
.qdev
, card
->qdev
.parent_bus
->parent
);
1196 s
->bmCommandStatus
= COMMAND_STATUS_NO_ERROR
;
1197 ccid_flush_pending_answers(s
);
1198 ccid_on_slot_change(s
, true);
1201 static int ccid_card_exit(DeviceState
*qdev
)
1204 CCIDCardState
*card
= CCID_CARD(qdev
);
1206 DO_UPCAST(USBCCIDState
, dev
.qdev
, card
->qdev
.parent_bus
->parent
);
1208 if (ccid_card_inserted(s
)) {
1209 ccid_card_card_removed(card
);
1211 ret
= ccid_card_exitfn(card
);
1216 static int ccid_card_init(DeviceState
*qdev
)
1218 CCIDCardState
*card
= CCID_CARD(qdev
);
1220 DO_UPCAST(USBCCIDState
, dev
.qdev
, card
->qdev
.parent_bus
->parent
);
1223 if (card
->slot
!= 0) {
1224 error_report("Warning: usb-ccid supports one slot, can't add %d",
1228 if (s
->card
!= NULL
) {
1229 error_report("Warning: usb-ccid card already full, not adding");
1232 ret
= ccid_card_initfn(card
);
1239 static int ccid_initfn(USBDevice
*dev
)
1241 USBCCIDState
*s
= DO_UPCAST(USBCCIDState
, dev
, dev
);
1243 usb_desc_create_serial(dev
);
1245 qbus_create_inplace(&s
->bus
.qbus
, TYPE_CCID_BUS
, &dev
->qdev
, NULL
);
1246 s
->intr
= usb_ep_get(dev
, USB_TOKEN_IN
, CCID_INT_IN_EP
);
1247 s
->bus
.qbus
.allow_hotplug
= 1;
1249 s
->migration_state
= MIGRATION_NONE
;
1250 s
->migration_target_ip
= 0;
1251 s
->migration_target_port
= 0;
1252 s
->dev
.speed
= USB_SPEED_FULL
;
1253 s
->dev
.speedmask
= USB_SPEED_MASK_FULL
;
1254 s
->notify_slot_change
= false;
1256 s
->pending_answers_num
= 0;
1257 s
->last_answer_error
= 0;
1258 s
->bulk_in_pending_start
= 0;
1259 s
->bulk_in_pending_end
= 0;
1260 s
->current_bulk_in
= NULL
;
1261 ccid_reset_error_status(s
);
1262 s
->bulk_out_pos
= 0;
1263 ccid_reset_parameters(s
);
1268 static int ccid_post_load(void *opaque
, int version_id
)
1270 USBCCIDState
*s
= opaque
;
1273 * This must be done after usb_device_attach, which sets state to ATTACHED,
1274 * while it must be DEFAULT in order to accept packets (like it is after
1275 * reset, but reset will reset our addr and call our reset handler which
1276 * may change state, and we don't want to do that when migrating).
1278 s
->dev
.state
= s
->state_vmstate
;
1282 static void ccid_pre_save(void *opaque
)
1284 USBCCIDState
*s
= opaque
;
1286 s
->state_vmstate
= s
->dev
.state
;
1287 if (s
->dev
.attached
) {
1289 * Migrating an open device, ignore reconnection CHR_EVENT to avoid an
1292 s
->migration_state
= MIGRATION_MIGRATED
;
1296 static VMStateDescription bulk_in_vmstate
= {
1297 .name
= "CCID BulkIn state",
1299 .minimum_version_id
= 1,
1300 .fields
= (VMStateField
[]) {
1301 VMSTATE_BUFFER(data
, BulkIn
),
1302 VMSTATE_UINT32(len
, BulkIn
),
1303 VMSTATE_UINT32(pos
, BulkIn
),
1304 VMSTATE_END_OF_LIST()
1308 static VMStateDescription answer_vmstate
= {
1309 .name
= "CCID Answer state",
1311 .minimum_version_id
= 1,
1312 .fields
= (VMStateField
[]) {
1313 VMSTATE_UINT8(slot
, Answer
),
1314 VMSTATE_UINT8(seq
, Answer
),
1315 VMSTATE_END_OF_LIST()
1319 static VMStateDescription usb_device_vmstate
= {
1320 .name
= "usb_device",
1322 .minimum_version_id
= 1,
1323 .fields
= (VMStateField
[]) {
1324 VMSTATE_UINT8(addr
, USBDevice
),
1325 VMSTATE_BUFFER(setup_buf
, USBDevice
),
1326 VMSTATE_BUFFER(data_buf
, USBDevice
),
1327 VMSTATE_END_OF_LIST()
1331 static VMStateDescription ccid_vmstate
= {
1332 .name
= CCID_DEV_NAME
,
1334 .minimum_version_id
= 1,
1335 .post_load
= ccid_post_load
,
1336 .pre_save
= ccid_pre_save
,
1337 .fields
= (VMStateField
[]) {
1338 VMSTATE_STRUCT(dev
, USBCCIDState
, 1, usb_device_vmstate
, USBDevice
),
1339 VMSTATE_UINT8(debug
, USBCCIDState
),
1340 VMSTATE_BUFFER(bulk_out_data
, USBCCIDState
),
1341 VMSTATE_UINT32(bulk_out_pos
, USBCCIDState
),
1342 VMSTATE_UINT8(bmSlotICCState
, USBCCIDState
),
1343 VMSTATE_UINT8(powered
, USBCCIDState
),
1344 VMSTATE_UINT8(notify_slot_change
, USBCCIDState
),
1345 VMSTATE_UINT64(last_answer_error
, USBCCIDState
),
1346 VMSTATE_UINT8(bError
, USBCCIDState
),
1347 VMSTATE_UINT8(bmCommandStatus
, USBCCIDState
),
1348 VMSTATE_UINT8(bProtocolNum
, USBCCIDState
),
1349 VMSTATE_BUFFER(abProtocolDataStructure
, USBCCIDState
),
1350 VMSTATE_UINT32(ulProtocolDataStructureSize
, USBCCIDState
),
1351 VMSTATE_STRUCT_ARRAY(bulk_in_pending
, USBCCIDState
,
1352 BULK_IN_PENDING_NUM
, 1, bulk_in_vmstate
, BulkIn
),
1353 VMSTATE_UINT32(bulk_in_pending_start
, USBCCIDState
),
1354 VMSTATE_UINT32(bulk_in_pending_end
, USBCCIDState
),
1355 VMSTATE_STRUCT_ARRAY(pending_answers
, USBCCIDState
,
1356 PENDING_ANSWERS_NUM
, 1, answer_vmstate
, Answer
),
1357 VMSTATE_UINT32(pending_answers_num
, USBCCIDState
),
1358 VMSTATE_UINT8(migration_state
, USBCCIDState
),
1359 VMSTATE_UINT32(state_vmstate
, USBCCIDState
),
1360 VMSTATE_END_OF_LIST()
1364 static Property ccid_properties
[] = {
1365 DEFINE_PROP_UINT8("debug", USBCCIDState
, debug
, 0),
1366 DEFINE_PROP_END_OF_LIST(),
1369 static void ccid_class_initfn(ObjectClass
*klass
, void *data
)
1371 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1372 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
1374 uc
->init
= ccid_initfn
;
1375 uc
->product_desc
= "QEMU USB CCID";
1376 uc
->usb_desc
= &desc_ccid
;
1377 uc
->handle_reset
= ccid_handle_reset
;
1378 uc
->handle_control
= ccid_handle_control
;
1379 uc
->handle_data
= ccid_handle_data
;
1380 uc
->handle_destroy
= ccid_handle_destroy
;
1381 dc
->desc
= "CCID Rev 1.1 smartcard reader";
1382 dc
->vmsd
= &ccid_vmstate
;
1383 dc
->props
= ccid_properties
;
1386 static const TypeInfo ccid_info
= {
1387 .name
= CCID_DEV_NAME
,
1388 .parent
= TYPE_USB_DEVICE
,
1389 .instance_size
= sizeof(USBCCIDState
),
1390 .class_init
= ccid_class_initfn
,
1393 static void ccid_card_class_init(ObjectClass
*klass
, void *data
)
1395 DeviceClass
*k
= DEVICE_CLASS(klass
);
1396 k
->bus_type
= TYPE_CCID_BUS
;
1397 k
->init
= ccid_card_init
;
1398 k
->exit
= ccid_card_exit
;
1399 k
->props
= ccid_props
;
1402 static const TypeInfo ccid_card_type_info
= {
1403 .name
= TYPE_CCID_CARD
,
1404 .parent
= TYPE_DEVICE
,
1405 .instance_size
= sizeof(CCIDCardState
),
1407 .class_size
= sizeof(CCIDCardClass
),
1408 .class_init
= ccid_card_class_init
,
1411 static void ccid_register_types(void)
1413 type_register_static(&ccid_bus_info
);
1414 type_register_static(&ccid_card_type_info
);
1415 type_register_static(&ccid_info
);
1416 usb_legacy_register(CCID_DEV_NAME
, "ccid", NULL
);
1419 type_init(ccid_register_types
)