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-common.h"
39 #include "qemu/error-report.h"
41 #include "hw/usb/desc.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"
58 #define USB_CCID_DEV(obj) OBJECT_CHECK(USBCCIDState, (obj), CCID_DEV_NAME)
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 CCID_MAX_PACKET_SIZE 64
73 #define CCID_CONTROL_ABORT 0x1
74 #define CCID_CONTROL_GET_CLOCK_FREQUENCIES 0x2
75 #define CCID_CONTROL_GET_DATA_RATES 0x3
77 #define CCID_PRODUCT_DESCRIPTION "QEMU USB CCID"
78 #define CCID_VENDOR_DESCRIPTION "QEMU"
79 #define CCID_INTERFACE_NAME "CCID Interface"
80 #define CCID_SERIAL_NUMBER_STRING "1"
82 * Using Gemplus Vendor and Product id
83 * Effect on various drivers:
84 * usbccid.sys (winxp, others untested) is a class driver so it doesn't care.
85 * linux has a number of class drivers, but openct filters based on
86 * vendor/product (/etc/openct.conf under fedora), hence Gemplus.
88 #define CCID_VENDOR_ID 0x08e6
89 #define CCID_PRODUCT_ID 0x4433
90 #define CCID_DEVICE_VERSION 0x0000
93 * BULK_OUT messages from PC to Reader
94 * Defined in CCID Rev 1.1 6.1 (page 26)
96 #define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn 0x62
97 #define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff 0x63
98 #define CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus 0x65
99 #define CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock 0x6f
100 #define CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters 0x6c
101 #define CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters 0x6d
102 #define CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters 0x61
103 #define CCID_MESSAGE_TYPE_PC_to_RDR_Escape 0x6b
104 #define CCID_MESSAGE_TYPE_PC_to_RDR_IccClock 0x6e
105 #define CCID_MESSAGE_TYPE_PC_to_RDR_T0APDU 0x6a
106 #define CCID_MESSAGE_TYPE_PC_to_RDR_Secure 0x69
107 #define CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical 0x71
108 #define CCID_MESSAGE_TYPE_PC_to_RDR_Abort 0x72
109 #define CCID_MESSAGE_TYPE_PC_to_RDR_SetDataRateAndClockFrequency 0x73
112 * BULK_IN messages from Reader to PC
113 * Defined in CCID Rev 1.1 6.2 (page 48)
115 #define CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock 0x80
116 #define CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus 0x81
117 #define CCID_MESSAGE_TYPE_RDR_to_PC_Parameters 0x82
118 #define CCID_MESSAGE_TYPE_RDR_to_PC_Escape 0x83
119 #define CCID_MESSAGE_TYPE_RDR_to_PC_DataRateAndClockFrequency 0x84
122 * INTERRUPT_IN messages from Reader to PC
123 * Defined in CCID Rev 1.1 6.3 (page 56)
125 #define CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange 0x50
126 #define CCID_MESSAGE_TYPE_RDR_to_PC_HardwareError 0x51
129 * Endpoints for CCID - addresses are up to us to decide.
130 * To support slot insertion and removal we must have an interrupt in ep
131 * in addition we need a bulk in and bulk out ep
134 #define CCID_INT_IN_EP 1
135 #define CCID_BULK_IN_EP 2
136 #define CCID_BULK_OUT_EP 3
138 /* bmSlotICCState masks */
139 #define SLOT_0_STATE_MASK 1
140 #define SLOT_0_CHANGED_MASK 2
142 /* Status codes that go in bStatus (see 6.2.6) */
144 ICC_STATUS_PRESENT_ACTIVE
= 0,
145 ICC_STATUS_PRESENT_INACTIVE
,
146 ICC_STATUS_NOT_PRESENT
150 COMMAND_STATUS_NO_ERROR
= 0,
151 COMMAND_STATUS_FAILED
,
152 COMMAND_STATUS_TIME_EXTENSION_REQUIRED
155 /* Error codes that go in bError (see 6.2.6) */
157 ERROR_CMD_NOT_SUPPORTED
= 0,
158 ERROR_CMD_ABORTED
= -1,
160 ERROR_XFR_PARITY_ERROR
= -3,
161 ERROR_XFR_OVERRUN
= -4,
165 /* 6.2.6 RDR_to_PC_SlotStatus definitions */
167 CLOCK_STATUS_RUNNING
= 0,
169 * 0 - Clock Running, 1 - Clock stopped in State L, 2 - H,
170 * 3 - unknown state. rest are RFU
174 typedef struct QEMU_PACKED CCID_Header
{
175 uint8_t bMessageType
;
181 typedef struct QEMU_PACKED CCID_BULK_IN
{
183 uint8_t bStatus
; /* Only used in BULK_IN */
184 uint8_t bError
; /* Only used in BULK_IN */
187 typedef struct QEMU_PACKED CCID_SlotStatus
{
189 uint8_t bClockStatus
;
192 typedef struct QEMU_PACKED CCID_T0ProtocolDataStructure
{
193 uint8_t bmFindexDindex
;
195 uint8_t bGuardTimeT0
;
196 uint8_t bWaitingIntegerT0
;
198 } CCID_T0ProtocolDataStructure
;
200 typedef struct QEMU_PACKED CCID_T1ProtocolDataStructure
{
201 uint8_t bmFindexDindex
;
203 uint8_t bGuardTimeT1
;
204 uint8_t bWaitingIntegerT1
;
208 } CCID_T1ProtocolDataStructure
;
210 typedef union CCID_ProtocolDataStructure
{
211 CCID_T0ProtocolDataStructure t0
;
212 CCID_T1ProtocolDataStructure t1
;
213 uint8_t data
[7]; /* must be = max(sizeof(t0), sizeof(t1)) */
214 } CCID_ProtocolDataStructure
;
216 typedef struct QEMU_PACKED CCID_Parameter
{
218 uint8_t bProtocolNum
;
219 CCID_ProtocolDataStructure abProtocolDataStructure
;
222 typedef struct QEMU_PACKED CCID_DataBlock
{
224 uint8_t bChainParameter
;
228 /* 6.1.4 PC_to_RDR_XfrBlock */
229 typedef struct QEMU_PACKED CCID_XferBlock
{
231 uint8_t bBWI
; /* Block Waiting Timeout */
232 uint16_t wLevelParameter
; /* XXX currently unused */
236 typedef struct QEMU_PACKED CCID_IccPowerOn
{
238 uint8_t bPowerSelect
;
242 typedef struct QEMU_PACKED CCID_IccPowerOff
{
247 typedef struct QEMU_PACKED CCID_SetParameters
{
249 uint8_t bProtocolNum
;
251 CCID_ProtocolDataStructure abProtocolDataStructure
;
252 } CCID_SetParameters
;
254 typedef struct CCID_Notify_Slot_Change
{
255 uint8_t bMessageType
; /* CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange */
256 uint8_t bmSlotICCState
;
257 } CCID_Notify_Slot_Change
;
259 /* used for DataBlock response to XferBlock */
260 typedef struct Answer
{
265 /* pending BULK_IN messages */
266 typedef struct BulkIn
{
267 uint8_t data
[BULK_IN_BUF_SIZE
];
277 typedef struct CCIDBus
{
282 * powered - defaults to true, changed by PowerOn/PowerOff messages
284 typedef struct USBCCIDState
{
290 BulkIn bulk_in_pending
[BULK_IN_PENDING_NUM
]; /* circular */
291 uint32_t bulk_in_pending_start
;
292 uint32_t bulk_in_pending_end
; /* first free */
293 uint32_t bulk_in_pending_num
;
294 BulkIn
*current_bulk_in
;
295 uint8_t bulk_out_data
[BULK_OUT_DATA_SIZE
];
296 uint32_t bulk_out_pos
;
297 uint64_t last_answer_error
;
298 Answer pending_answers
[PENDING_ANSWERS_NUM
];
299 uint32_t pending_answers_start
;
300 uint32_t pending_answers_end
;
301 uint32_t pending_answers_num
;
303 uint8_t bmCommandStatus
;
304 uint8_t bProtocolNum
;
305 CCID_ProtocolDataStructure abProtocolDataStructure
;
306 uint32_t ulProtocolDataStructureSize
;
307 uint32_t state_vmstate
;
308 uint32_t migration_target_ip
;
309 uint16_t migration_target_port
;
310 uint8_t migration_state
;
311 uint8_t bmSlotICCState
;
313 uint8_t notify_slot_change
;
318 * CCID Spec chapter 4: CCID uses a standard device descriptor per Chapter 9,
319 * "USB Device Framework", section 9.6.1, in the Universal Serial Bus
322 * This device implemented based on the spec and with an Athena Smart Card
323 * Reader as reference:
324 * 0dc3:1004 Athena Smartcard Solutions, Inc.
327 static const uint8_t qemu_ccid_descriptor
[] = {
328 /* Smart Card Device Class Descriptor */
329 0x36, /* u8 bLength; */
330 0x21, /* u8 bDescriptorType; Functional */
331 0x10, 0x01, /* u16 bcdCCID; CCID Specification Release Number. */
333 * u8 bMaxSlotIndex; The index of the highest available
334 * slot on this device. All slots are consecutive starting
337 0x07, /* u8 bVoltageSupport; 01h - 5.0v, 02h - 3.0, 03 - 1.8 */
339 0x00, 0x00, /* u32 dwProtocols; RRRR PPPP. RRRR = 0000h.*/
340 0x01, 0x00, /* PPPP: 0001h = Protocol T=0, 0002h = Protocol T=1 */
341 /* u32 dwDefaultClock; in kHZ (0x0fa0 is 4 MHz) */
342 0xa0, 0x0f, 0x00, 0x00,
343 /* u32 dwMaximumClock; */
344 0x00, 0x00, 0x01, 0x00,
345 0x00, /* u8 bNumClockSupported; *
346 * 0 means just the default and max. */
347 /* u32 dwDataRate ;bps. 9600 == 00002580h */
348 0x80, 0x25, 0x00, 0x00,
349 /* u32 dwMaxDataRate ; 11520 bps == 0001C200h */
350 0x00, 0xC2, 0x01, 0x00,
351 0x00, /* u8 bNumDataRatesSupported; 00 means all rates between
354 * maximum IFSD supported by CCID for protocol *
355 * T=1 (Maximum seen from various cards) */
356 0xfe, 0x00, 0x00, 0x00,
357 /* u32 dwSyncProtocols; 1 - 2-wire, 2 - 3-wire, 4 - I2C */
358 0x00, 0x00, 0x00, 0x00,
359 /* u32 dwMechanical; 0 - no special characteristics. */
360 0x00, 0x00, 0x00, 0x00,
363 * 0 - No special characteristics
364 * + 2 Automatic parameter configuration based on ATR data
365 * + 4 Automatic activation of ICC on inserting
366 * + 8 Automatic ICC voltage selection
367 * + 10 Automatic ICC clock frequency change
368 * + 20 Automatic baud rate change
369 * + 40 Automatic parameters negotiation made by the CCID
370 * + 80 automatic PPS made by the CCID
371 * 100 CCID can set ICC in clock stop mode
372 * 200 NAD value other then 00 accepted (T=1 protocol)
373 * + 400 Automatic IFSD exchange as first exchange (T=1)
374 * One of the following only:
375 * + 10000 TPDU level exchanges with CCID
376 * 20000 Short APDU level exchange with CCID
377 * 40000 Short and Extended APDU level exchange with CCID
379 * 100000 USB Wake up signaling supported on card
380 * insertion and removal. Must set bit 5 in bmAttributes
381 * in Configuration descriptor if 100000 is set.
383 0xfe, 0x04, 0x01, 0x00,
385 * u32 dwMaxCCIDMessageLength; For extended APDU in
386 * [261 + 10 , 65544 + 10]. Otherwise the minimum is
387 * wMaxPacketSize of the Bulk-OUT endpoint
389 0x12, 0x00, 0x01, 0x00,
391 * u8 bClassGetResponse; Significant only for CCID that
392 * offers an APDU level for exchanges. Indicates the
393 * default class value used by the CCID when it sends a
394 * Get Response command to perform the transportation of
395 * an APDU by T=0 protocol
396 * FFh indicates that the CCID echos the class of the APDU.
399 * u8 bClassEnvelope; EAPDU only. Envelope command for
403 * u16 wLcdLayout; XXYY Number of lines (XX) and chars per
404 * line for LCD display used for PIN entry. 0000 - no LCD
407 * u8 bPINSupport; 01h PIN Verification,
408 * 02h PIN Modification
410 0x01, /* u8 bMaxCCIDBusySlots; */
414 STR_MANUFACTURER
= 1,
420 static const USBDescStrings desc_strings
= {
421 [STR_MANUFACTURER
] = "QEMU",
422 [STR_PRODUCT
] = "QEMU USB CCID",
423 [STR_SERIALNUMBER
] = "1",
424 [STR_INTERFACE
] = "CCID Interface",
427 static const USBDescIface desc_iface0
= {
428 .bInterfaceNumber
= 0,
430 .bInterfaceClass
= USB_CLASS_CSCID
,
431 .bInterfaceSubClass
= USB_SUBCLASS_UNDEFINED
,
432 .bInterfaceProtocol
= 0x00,
433 .iInterface
= STR_INTERFACE
,
435 .descs
= (USBDescOther
[]) {
437 /* smartcard descriptor */
438 .data
= qemu_ccid_descriptor
,
441 .eps
= (USBDescEndpoint
[]) {
443 .bEndpointAddress
= USB_DIR_IN
| CCID_INT_IN_EP
,
444 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
446 .wMaxPacketSize
= 64,
448 .bEndpointAddress
= USB_DIR_IN
| CCID_BULK_IN_EP
,
449 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
450 .wMaxPacketSize
= 64,
452 .bEndpointAddress
= USB_DIR_OUT
| CCID_BULK_OUT_EP
,
453 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
454 .wMaxPacketSize
= 64,
459 static const USBDescDevice desc_device
= {
461 .bMaxPacketSize0
= 64,
462 .bNumConfigurations
= 1,
463 .confs
= (USBDescConfig
[]) {
466 .bConfigurationValue
= 1,
467 .bmAttributes
= USB_CFG_ATT_ONE
| USB_CFG_ATT_SELFPOWER
|
476 static const USBDesc desc_ccid
= {
478 .idVendor
= CCID_VENDOR_ID
,
479 .idProduct
= CCID_PRODUCT_ID
,
480 .bcdDevice
= CCID_DEVICE_VERSION
,
481 .iManufacturer
= STR_MANUFACTURER
,
482 .iProduct
= STR_PRODUCT
,
483 .iSerialNumber
= STR_SERIALNUMBER
,
485 .full
= &desc_device
,
489 static const uint8_t *ccid_card_get_atr(CCIDCardState
*card
, uint32_t *len
)
491 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
494 return cc
->get_atr(card
, len
);
499 static void ccid_card_apdu_from_guest(CCIDCardState
*card
,
503 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
505 if (cc
->apdu_from_guest
) {
506 cc
->apdu_from_guest(card
, apdu
, len
);
510 static int ccid_card_exitfn(CCIDCardState
*card
)
512 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
515 return cc
->exitfn(card
);
520 static int ccid_card_initfn(CCIDCardState
*card
)
522 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
525 return cc
->initfn(card
);
530 static bool ccid_has_pending_answers(USBCCIDState
*s
)
532 return s
->pending_answers_num
> 0;
535 static void ccid_clear_pending_answers(USBCCIDState
*s
)
537 s
->pending_answers_num
= 0;
538 s
->pending_answers_start
= 0;
539 s
->pending_answers_end
= 0;
542 static void ccid_print_pending_answers(USBCCIDState
*s
)
547 DPRINTF(s
, D_VERBOSE
, "usb-ccid: pending answers:");
548 if (!ccid_has_pending_answers(s
)) {
549 DPRINTF(s
, D_VERBOSE
, " empty\n");
552 for (i
= s
->pending_answers_start
, count
= s
->pending_answers_num
;
553 count
> 0; count
--, i
++) {
554 answer
= &s
->pending_answers
[i
% PENDING_ANSWERS_NUM
];
556 DPRINTF(s
, D_VERBOSE
, "%d:%d\n", answer
->slot
, answer
->seq
);
558 DPRINTF(s
, D_VERBOSE
, "%d:%d,", answer
->slot
, answer
->seq
);
563 static void ccid_add_pending_answer(USBCCIDState
*s
, CCID_Header
*hdr
)
567 assert(s
->pending_answers_num
< PENDING_ANSWERS_NUM
);
568 s
->pending_answers_num
++;
570 &s
->pending_answers
[(s
->pending_answers_end
++) % PENDING_ANSWERS_NUM
];
571 answer
->slot
= hdr
->bSlot
;
572 answer
->seq
= hdr
->bSeq
;
573 ccid_print_pending_answers(s
);
576 static void ccid_remove_pending_answer(USBCCIDState
*s
,
577 uint8_t *slot
, uint8_t *seq
)
581 assert(s
->pending_answers_num
> 0);
582 s
->pending_answers_num
--;
584 &s
->pending_answers
[(s
->pending_answers_start
++) % PENDING_ANSWERS_NUM
];
585 *slot
= answer
->slot
;
587 ccid_print_pending_answers(s
);
590 static void ccid_bulk_in_clear(USBCCIDState
*s
)
592 s
->bulk_in_pending_start
= 0;
593 s
->bulk_in_pending_end
= 0;
594 s
->bulk_in_pending_num
= 0;
597 static void ccid_bulk_in_release(USBCCIDState
*s
)
599 assert(s
->current_bulk_in
!= NULL
);
600 s
->current_bulk_in
->pos
= 0;
601 s
->current_bulk_in
= NULL
;
604 static void ccid_bulk_in_get(USBCCIDState
*s
)
606 if (s
->current_bulk_in
!= NULL
|| s
->bulk_in_pending_num
== 0) {
609 assert(s
->bulk_in_pending_num
> 0);
610 s
->bulk_in_pending_num
--;
612 &s
->bulk_in_pending
[(s
->bulk_in_pending_start
++) % BULK_IN_PENDING_NUM
];
615 static void *ccid_reserve_recv_buf(USBCCIDState
*s
, uint16_t len
)
619 DPRINTF(s
, D_VERBOSE
, "%s: QUEUE: reserve %d bytes\n", __func__
, len
);
621 /* look for an existing element */
622 if (len
> BULK_IN_BUF_SIZE
) {
623 DPRINTF(s
, D_WARN
, "usb-ccid.c: %s: len larger then max (%d>%d). "
624 "discarding message.\n",
625 __func__
, len
, BULK_IN_BUF_SIZE
);
628 if (s
->bulk_in_pending_num
>= BULK_IN_PENDING_NUM
) {
629 DPRINTF(s
, D_WARN
, "usb-ccid.c: %s: No free bulk_in buffers. "
630 "discarding message.\n", __func__
);
634 &s
->bulk_in_pending
[(s
->bulk_in_pending_end
++) % BULK_IN_PENDING_NUM
];
635 s
->bulk_in_pending_num
++;
637 return bulk_in
->data
;
640 static void ccid_reset(USBCCIDState
*s
)
642 ccid_bulk_in_clear(s
);
643 ccid_clear_pending_answers(s
);
646 static void ccid_detach(USBCCIDState
*s
)
651 static void ccid_handle_reset(USBDevice
*dev
)
653 USBCCIDState
*s
= USB_CCID_DEV(dev
);
655 DPRINTF(s
, 1, "Reset\n");
660 static const char *ccid_control_to_str(USBCCIDState
*s
, int request
)
663 /* generic - should be factored out if there are other debugees */
664 case DeviceOutRequest
| USB_REQ_SET_ADDRESS
:
665 return "(generic) set address";
666 case DeviceRequest
| USB_REQ_GET_DESCRIPTOR
:
667 return "(generic) get descriptor";
668 case DeviceRequest
| USB_REQ_GET_CONFIGURATION
:
669 return "(generic) get configuration";
670 case DeviceOutRequest
| USB_REQ_SET_CONFIGURATION
:
671 return "(generic) set configuration";
672 case DeviceRequest
| USB_REQ_GET_STATUS
:
673 return "(generic) get status";
674 case DeviceOutRequest
| USB_REQ_CLEAR_FEATURE
:
675 return "(generic) clear feature";
676 case DeviceOutRequest
| USB_REQ_SET_FEATURE
:
677 return "(generic) set_feature";
678 case InterfaceRequest
| USB_REQ_GET_INTERFACE
:
679 return "(generic) get interface";
680 case InterfaceOutRequest
| USB_REQ_SET_INTERFACE
:
681 return "(generic) set interface";
683 case ClassInterfaceOutRequest
| CCID_CONTROL_ABORT
:
685 case ClassInterfaceRequest
| CCID_CONTROL_GET_CLOCK_FREQUENCIES
:
686 return "GET_CLOCK_FREQUENCIES";
687 case ClassInterfaceRequest
| CCID_CONTROL_GET_DATA_RATES
:
688 return "GET_DATA_RATES";
693 static void ccid_handle_control(USBDevice
*dev
, USBPacket
*p
, int request
,
694 int value
, int index
, int length
, uint8_t *data
)
696 USBCCIDState
*s
= USB_CCID_DEV(dev
);
699 DPRINTF(s
, 1, "%s: got control %s (%x), value %x\n", __func__
,
700 ccid_control_to_str(s
, request
), request
, value
);
701 ret
= usb_desc_handle_control(dev
, p
, request
, value
, index
, length
, data
);
707 /* Class specific requests. */
708 case ClassInterfaceOutRequest
| CCID_CONTROL_ABORT
:
709 DPRINTF(s
, 1, "ccid_control abort UNIMPLEMENTED\n");
710 p
->status
= USB_RET_STALL
;
712 case ClassInterfaceRequest
| CCID_CONTROL_GET_CLOCK_FREQUENCIES
:
713 DPRINTF(s
, 1, "ccid_control get clock frequencies UNIMPLEMENTED\n");
714 p
->status
= USB_RET_STALL
;
716 case ClassInterfaceRequest
| CCID_CONTROL_GET_DATA_RATES
:
717 DPRINTF(s
, 1, "ccid_control get data rates UNIMPLEMENTED\n");
718 p
->status
= USB_RET_STALL
;
721 DPRINTF(s
, 1, "got unsupported/bogus control %x, value %x\n",
723 p
->status
= USB_RET_STALL
;
728 static bool ccid_card_inserted(USBCCIDState
*s
)
730 return s
->bmSlotICCState
& SLOT_0_STATE_MASK
;
733 static uint8_t ccid_card_status(USBCCIDState
*s
)
735 return ccid_card_inserted(s
)
737 ICC_STATUS_PRESENT_ACTIVE
738 : ICC_STATUS_PRESENT_INACTIVE
740 : ICC_STATUS_NOT_PRESENT
;
743 static uint8_t ccid_calc_status(USBCCIDState
*s
)
746 * page 55, 6.2.6, calculation of bStatus from bmICCStatus and
749 uint8_t ret
= ccid_card_status(s
) | (s
->bmCommandStatus
<< 6);
750 DPRINTF(s
, D_VERBOSE
, "%s: status = %d\n", __func__
, ret
);
754 static void ccid_reset_error_status(USBCCIDState
*s
)
756 s
->bError
= ERROR_CMD_NOT_SUPPORTED
;
757 s
->bmCommandStatus
= COMMAND_STATUS_NO_ERROR
;
760 static void ccid_write_slot_status(USBCCIDState
*s
, CCID_Header
*recv
)
762 CCID_SlotStatus
*h
= ccid_reserve_recv_buf(s
, sizeof(CCID_SlotStatus
));
766 h
->b
.hdr
.bMessageType
= CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus
;
767 h
->b
.hdr
.dwLength
= 0;
768 h
->b
.hdr
.bSlot
= recv
->bSlot
;
769 h
->b
.hdr
.bSeq
= recv
->bSeq
;
770 h
->b
.bStatus
= ccid_calc_status(s
);
771 h
->b
.bError
= s
->bError
;
772 h
->bClockStatus
= CLOCK_STATUS_RUNNING
;
773 ccid_reset_error_status(s
);
774 usb_wakeup(s
->bulk
, 0);
777 static void ccid_write_parameters(USBCCIDState
*s
, CCID_Header
*recv
)
780 uint32_t len
= s
->ulProtocolDataStructureSize
;
782 h
= ccid_reserve_recv_buf(s
, sizeof(CCID_Parameter
) + len
);
786 h
->b
.hdr
.bMessageType
= CCID_MESSAGE_TYPE_RDR_to_PC_Parameters
;
787 h
->b
.hdr
.dwLength
= 0;
788 h
->b
.hdr
.bSlot
= recv
->bSlot
;
789 h
->b
.hdr
.bSeq
= recv
->bSeq
;
790 h
->b
.bStatus
= ccid_calc_status(s
);
791 h
->b
.bError
= s
->bError
;
792 h
->bProtocolNum
= s
->bProtocolNum
;
793 h
->abProtocolDataStructure
= s
->abProtocolDataStructure
;
794 ccid_reset_error_status(s
);
795 usb_wakeup(s
->bulk
, 0);
798 static void ccid_write_data_block(USBCCIDState
*s
, uint8_t slot
, uint8_t seq
,
799 const uint8_t *data
, uint32_t len
)
801 CCID_DataBlock
*p
= ccid_reserve_recv_buf(s
, sizeof(*p
) + len
);
806 p
->b
.hdr
.bMessageType
= CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock
;
807 p
->b
.hdr
.dwLength
= cpu_to_le32(len
);
808 p
->b
.hdr
.bSlot
= slot
;
810 p
->b
.bStatus
= ccid_calc_status(s
);
811 p
->b
.bError
= s
->bError
;
813 DPRINTF(s
, D_VERBOSE
, "error %d\n", p
->b
.bError
);
815 memcpy(p
->abData
, data
, len
);
816 ccid_reset_error_status(s
);
817 usb_wakeup(s
->bulk
, 0);
820 static void ccid_report_error_failed(USBCCIDState
*s
, uint8_t error
)
822 s
->bmCommandStatus
= COMMAND_STATUS_FAILED
;
826 static void ccid_write_data_block_answer(USBCCIDState
*s
,
827 const uint8_t *data
, uint32_t len
)
832 if (!ccid_has_pending_answers(s
)) {
833 DPRINTF(s
, D_WARN
, "error: no pending answer to return to guest\n");
834 ccid_report_error_failed(s
, ERROR_ICC_MUTE
);
837 ccid_remove_pending_answer(s
, &slot
, &seq
);
838 ccid_write_data_block(s
, slot
, seq
, data
, len
);
841 static uint8_t atr_get_protocol_num(const uint8_t *atr
, uint32_t len
)
845 if (len
< 2 || !(atr
[1] & 0x80)) {
846 /* too short or TD1 not included */
847 return 0; /* T=0, default */
849 i
= 1 + !!(atr
[1] & 0x10) + !!(atr
[1] & 0x20) + !!(atr
[1] & 0x40);
850 i
+= !!(atr
[1] & 0x80);
851 return atr
[i
] & 0x0f;
854 static void ccid_write_data_block_atr(USBCCIDState
*s
, CCID_Header
*recv
)
856 const uint8_t *atr
= NULL
;
858 uint8_t atr_protocol_num
;
859 CCID_T0ProtocolDataStructure
*t0
= &s
->abProtocolDataStructure
.t0
;
860 CCID_T1ProtocolDataStructure
*t1
= &s
->abProtocolDataStructure
.t1
;
863 atr
= ccid_card_get_atr(s
->card
, &len
);
865 atr_protocol_num
= atr_get_protocol_num(atr
, len
);
866 DPRINTF(s
, D_VERBOSE
, "%s: atr contains protocol=%d\n", __func__
,
868 /* set parameters from ATR - see spec page 109 */
869 s
->bProtocolNum
= (atr_protocol_num
<= 1 ? atr_protocol_num
871 switch (atr_protocol_num
) {
873 /* TODO: unimplemented ATR T0 parameters */
874 t0
->bmFindexDindex
= 0;
876 t0
->bGuardTimeT0
= 0;
877 t0
->bWaitingIntegerT0
= 0;
881 /* TODO: unimplemented ATR T1 parameters */
882 t1
->bmFindexDindex
= 0;
884 t1
->bGuardTimeT1
= 0;
885 t1
->bWaitingIntegerT1
= 0;
891 DPRINTF(s
, D_WARN
, "%s: error: unsupported ATR protocol %d\n",
892 __func__
, atr_protocol_num
);
894 ccid_write_data_block(s
, recv
->bSlot
, recv
->bSeq
, atr
, len
);
897 static void ccid_set_parameters(USBCCIDState
*s
, CCID_Header
*recv
)
899 CCID_SetParameters
*ph
= (CCID_SetParameters
*) recv
;
900 uint32_t protocol_num
= ph
->bProtocolNum
& 3;
902 if (protocol_num
!= 0 && protocol_num
!= 1) {
903 ccid_report_error_failed(s
, ERROR_CMD_NOT_SUPPORTED
);
906 s
->bProtocolNum
= protocol_num
;
907 s
->abProtocolDataStructure
= ph
->abProtocolDataStructure
;
911 * must be 5 bytes for T=0, 7 bytes for T=1
914 static const CCID_ProtocolDataStructure defaultProtocolDataStructure
= {
916 .bmFindexDindex
= 0x77,
918 .bGuardTimeT1
= 0x00,
919 .bWaitingIntegerT1
= 0x00,
926 static void ccid_reset_parameters(USBCCIDState
*s
)
928 s
->bProtocolNum
= 0; /* T=0 */
929 s
->abProtocolDataStructure
= defaultProtocolDataStructure
;
932 /* NOTE: only a single slot is supported (SLOT_0) */
933 static void ccid_on_slot_change(USBCCIDState
*s
, bool full
)
935 /* RDR_to_PC_NotifySlotChange, 6.3.1 page 56 */
936 uint8_t current
= s
->bmSlotICCState
;
938 s
->bmSlotICCState
|= SLOT_0_STATE_MASK
;
940 s
->bmSlotICCState
&= ~SLOT_0_STATE_MASK
;
942 if (current
!= s
->bmSlotICCState
) {
943 s
->bmSlotICCState
|= SLOT_0_CHANGED_MASK
;
945 s
->notify_slot_change
= true;
946 usb_wakeup(s
->intr
, 0);
949 static void ccid_write_data_block_error(
950 USBCCIDState
*s
, uint8_t slot
, uint8_t seq
)
952 ccid_write_data_block(s
, slot
, seq
, NULL
, 0);
955 static void ccid_on_apdu_from_guest(USBCCIDState
*s
, CCID_XferBlock
*recv
)
959 if (ccid_card_status(s
) != ICC_STATUS_PRESENT_ACTIVE
) {
961 "usb-ccid: not sending apdu to client, no card connected\n");
962 ccid_write_data_block_error(s
, recv
->hdr
.bSlot
, recv
->hdr
.bSeq
);
965 len
= le32_to_cpu(recv
->hdr
.dwLength
);
966 DPRINTF(s
, 1, "%s: seq %d, len %d\n", __func__
,
967 recv
->hdr
.bSeq
, len
);
968 ccid_add_pending_answer(s
, (CCID_Header
*)recv
);
970 ccid_card_apdu_from_guest(s
->card
, recv
->abData
, len
);
972 DPRINTF(s
, D_WARN
, "warning: discarded apdu\n");
976 static const char *ccid_message_type_to_str(uint8_t type
)
979 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn
: return "IccPowerOn";
980 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff
: return "IccPowerOff";
981 case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus
: return "GetSlotStatus";
982 case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock
: return "XfrBlock";
983 case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters
: return "GetParameters";
984 case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters
: return "ResetParameters";
985 case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters
: return "SetParameters";
986 case CCID_MESSAGE_TYPE_PC_to_RDR_Escape
: return "Escape";
987 case CCID_MESSAGE_TYPE_PC_to_RDR_IccClock
: return "IccClock";
988 case CCID_MESSAGE_TYPE_PC_to_RDR_T0APDU
: return "T0APDU";
989 case CCID_MESSAGE_TYPE_PC_to_RDR_Secure
: return "Secure";
990 case CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical
: return "Mechanical";
991 case CCID_MESSAGE_TYPE_PC_to_RDR_Abort
: return "Abort";
992 case CCID_MESSAGE_TYPE_PC_to_RDR_SetDataRateAndClockFrequency
:
993 return "SetDataRateAndClockFrequency";
998 static void ccid_handle_bulk_out(USBCCIDState
*s
, USBPacket
*p
)
1000 CCID_Header
*ccid_header
;
1002 if (p
->iov
.size
+ s
->bulk_out_pos
> BULK_OUT_DATA_SIZE
) {
1003 p
->status
= USB_RET_STALL
;
1006 ccid_header
= (CCID_Header
*)s
->bulk_out_data
;
1007 usb_packet_copy(p
, s
->bulk_out_data
+ s
->bulk_out_pos
, p
->iov
.size
);
1008 s
->bulk_out_pos
+= p
->iov
.size
;
1009 if (p
->iov
.size
== CCID_MAX_PACKET_SIZE
) {
1010 DPRINTF(s
, D_VERBOSE
,
1011 "usb-ccid: bulk_in: expecting more packets (%zd/%d)\n",
1012 p
->iov
.size
, ccid_header
->dwLength
);
1015 if (s
->bulk_out_pos
< 10) {
1017 "%s: bad USB_TOKEN_OUT length, should be at least 10 bytes\n",
1020 DPRINTF(s
, D_MORE_INFO
, "%s %x %s\n", __func__
,
1021 ccid_header
->bMessageType
,
1022 ccid_message_type_to_str(ccid_header
->bMessageType
));
1023 switch (ccid_header
->bMessageType
) {
1024 case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus
:
1025 ccid_write_slot_status(s
, ccid_header
);
1027 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn
:
1028 DPRINTF(s
, 1, "%s: PowerOn: %d\n", __func__
,
1029 ((CCID_IccPowerOn
*)(ccid_header
))->bPowerSelect
);
1031 if (!ccid_card_inserted(s
)) {
1032 ccid_report_error_failed(s
, ERROR_ICC_MUTE
);
1034 /* atr is written regardless of error. */
1035 ccid_write_data_block_atr(s
, ccid_header
);
1037 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff
:
1038 ccid_reset_error_status(s
);
1040 ccid_write_slot_status(s
, ccid_header
);
1042 case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock
:
1043 ccid_on_apdu_from_guest(s
, (CCID_XferBlock
*)s
->bulk_out_data
);
1045 case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters
:
1046 ccid_reset_error_status(s
);
1047 ccid_set_parameters(s
, ccid_header
);
1048 ccid_write_parameters(s
, ccid_header
);
1050 case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters
:
1051 ccid_reset_error_status(s
);
1052 ccid_reset_parameters(s
);
1053 ccid_write_parameters(s
, ccid_header
);
1055 case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters
:
1056 ccid_reset_error_status(s
);
1057 ccid_write_parameters(s
, ccid_header
);
1059 case CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical
:
1060 ccid_report_error_failed(s
, 0);
1061 ccid_write_slot_status(s
, ccid_header
);
1065 "handle_data: ERROR: unhandled message type %Xh\n",
1066 ccid_header
->bMessageType
);
1068 * The caller is expecting the device to respond, tell it we
1069 * don't support the operation.
1071 ccid_report_error_failed(s
, ERROR_CMD_NOT_SUPPORTED
);
1072 ccid_write_slot_status(s
, ccid_header
);
1076 s
->bulk_out_pos
= 0;
1079 static void ccid_bulk_in_copy_to_guest(USBCCIDState
*s
, USBPacket
*p
)
1083 ccid_bulk_in_get(s
);
1084 if (s
->current_bulk_in
!= NULL
) {
1085 len
= MIN(s
->current_bulk_in
->len
- s
->current_bulk_in
->pos
,
1087 usb_packet_copy(p
, s
->current_bulk_in
->data
+
1088 s
->current_bulk_in
->pos
, len
);
1089 s
->current_bulk_in
->pos
+= len
;
1090 if (s
->current_bulk_in
->pos
== s
->current_bulk_in
->len
) {
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
);
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_handle_destroy(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 #define CCID_BUS(obj) OBJECT_CHECK(CCIDBus, (obj), TYPE_CCID_BUS)
1182 static const TypeInfo ccid_bus_info
= {
1183 .name
= TYPE_CCID_BUS
,
1185 .instance_size
= sizeof(CCIDBus
),
1188 void ccid_card_send_apdu_to_guest(CCIDCardState
*card
,
1189 uint8_t *apdu
, uint32_t len
)
1191 DeviceState
*qdev
= DEVICE(card
);
1192 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1193 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1196 if (!ccid_has_pending_answers(s
)) {
1197 DPRINTF(s
, 1, "CCID ERROR: got an APDU without pending answers\n");
1200 s
->bmCommandStatus
= COMMAND_STATUS_NO_ERROR
;
1201 answer
= ccid_peek_next_answer(s
);
1202 if (answer
== NULL
) {
1203 DPRINTF(s
, D_WARN
, "%s: error: unexpected lack of answer\n", __func__
);
1204 ccid_report_error_failed(s
, ERROR_HW_ERROR
);
1207 DPRINTF(s
, 1, "APDU returned to guest %d (answer seq %d, slot %d)\n",
1208 len
, answer
->seq
, answer
->slot
);
1209 ccid_write_data_block_answer(s
, apdu
, len
);
1212 void ccid_card_card_removed(CCIDCardState
*card
)
1214 DeviceState
*qdev
= DEVICE(card
);
1215 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1216 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1218 ccid_on_slot_change(s
, false);
1219 ccid_flush_pending_answers(s
);
1223 int ccid_card_ccid_attach(CCIDCardState
*card
)
1225 DeviceState
*qdev
= DEVICE(card
);
1226 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1227 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1229 DPRINTF(s
, 1, "CCID Attach\n");
1230 if (s
->migration_state
== MIGRATION_MIGRATED
) {
1231 s
->migration_state
= MIGRATION_NONE
;
1236 void ccid_card_ccid_detach(CCIDCardState
*card
)
1238 DeviceState
*qdev
= DEVICE(card
);
1239 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1240 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1242 DPRINTF(s
, 1, "CCID Detach\n");
1243 if (ccid_card_inserted(s
)) {
1244 ccid_on_slot_change(s
, false);
1249 void ccid_card_card_error(CCIDCardState
*card
, uint64_t error
)
1251 DeviceState
*qdev
= DEVICE(card
);
1252 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1253 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1255 s
->bmCommandStatus
= COMMAND_STATUS_FAILED
;
1256 s
->last_answer_error
= error
;
1257 DPRINTF(s
, 1, "VSC_Error: %" PRIX64
"\n", s
->last_answer_error
);
1258 /* TODO: these errors should be more verbose and propagated to the guest.*/
1260 * We flush all pending answers on CardRemove message in ccid-card-passthru,
1261 * so check that first to not trigger abort
1263 if (ccid_has_pending_answers(s
)) {
1264 ccid_write_data_block_answer(s
, NULL
, 0);
1268 void ccid_card_card_inserted(CCIDCardState
*card
)
1270 DeviceState
*qdev
= DEVICE(card
);
1271 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1272 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1274 s
->bmCommandStatus
= COMMAND_STATUS_NO_ERROR
;
1275 ccid_flush_pending_answers(s
);
1276 ccid_on_slot_change(s
, true);
1279 static int ccid_card_exit(DeviceState
*qdev
)
1282 CCIDCardState
*card
= CCID_CARD(qdev
);
1283 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1284 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1286 if (ccid_card_inserted(s
)) {
1287 ccid_card_card_removed(card
);
1289 ret
= ccid_card_exitfn(card
);
1294 static int ccid_card_init(DeviceState
*qdev
)
1296 CCIDCardState
*card
= CCID_CARD(qdev
);
1297 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1298 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1301 if (card
->slot
!= 0) {
1302 error_report("Warning: usb-ccid supports one slot, can't add %d",
1306 if (s
->card
!= NULL
) {
1307 error_report("Warning: usb-ccid card already full, not adding");
1310 ret
= ccid_card_initfn(card
);
1317 static void ccid_realize(USBDevice
*dev
, Error
**errp
)
1319 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1321 usb_desc_create_serial(dev
);
1323 qbus_create_inplace(&s
->bus
, sizeof(s
->bus
), TYPE_CCID_BUS
, DEVICE(dev
),
1325 qbus_set_hotplug_handler(BUS(&s
->bus
), DEVICE(dev
), &error_abort
);
1326 s
->intr
= usb_ep_get(dev
, USB_TOKEN_IN
, CCID_INT_IN_EP
);
1327 s
->bulk
= usb_ep_get(dev
, USB_TOKEN_IN
, CCID_BULK_IN_EP
);
1329 s
->migration_state
= MIGRATION_NONE
;
1330 s
->migration_target_ip
= 0;
1331 s
->migration_target_port
= 0;
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 void ccid_pre_save(void *opaque
)
1364 USBCCIDState
*s
= opaque
;
1366 s
->state_vmstate
= s
->dev
.state
;
1367 if (s
->dev
.attached
) {
1369 * Migrating an open device, ignore reconnection CHR_EVENT to avoid an
1372 s
->migration_state
= MIGRATION_MIGRATED
;
1376 static VMStateDescription bulk_in_vmstate
= {
1377 .name
= "CCID BulkIn state",
1379 .minimum_version_id
= 1,
1380 .fields
= (VMStateField
[]) {
1381 VMSTATE_BUFFER(data
, BulkIn
),
1382 VMSTATE_UINT32(len
, BulkIn
),
1383 VMSTATE_UINT32(pos
, BulkIn
),
1384 VMSTATE_END_OF_LIST()
1388 static VMStateDescription answer_vmstate
= {
1389 .name
= "CCID Answer state",
1391 .minimum_version_id
= 1,
1392 .fields
= (VMStateField
[]) {
1393 VMSTATE_UINT8(slot
, Answer
),
1394 VMSTATE_UINT8(seq
, Answer
),
1395 VMSTATE_END_OF_LIST()
1399 static VMStateDescription usb_device_vmstate
= {
1400 .name
= "usb_device",
1402 .minimum_version_id
= 1,
1403 .fields
= (VMStateField
[]) {
1404 VMSTATE_UINT8(addr
, USBDevice
),
1405 VMSTATE_BUFFER(setup_buf
, USBDevice
),
1406 VMSTATE_BUFFER(data_buf
, USBDevice
),
1407 VMSTATE_END_OF_LIST()
1411 static VMStateDescription ccid_vmstate
= {
1414 .minimum_version_id
= 1,
1415 .post_load
= ccid_post_load
,
1416 .pre_save
= ccid_pre_save
,
1417 .fields
= (VMStateField
[]) {
1418 VMSTATE_STRUCT(dev
, USBCCIDState
, 1, usb_device_vmstate
, USBDevice
),
1419 VMSTATE_UINT8(debug
, USBCCIDState
),
1420 VMSTATE_BUFFER(bulk_out_data
, USBCCIDState
),
1421 VMSTATE_UINT32(bulk_out_pos
, USBCCIDState
),
1422 VMSTATE_UINT8(bmSlotICCState
, USBCCIDState
),
1423 VMSTATE_UINT8(powered
, USBCCIDState
),
1424 VMSTATE_UINT8(notify_slot_change
, USBCCIDState
),
1425 VMSTATE_UINT64(last_answer_error
, USBCCIDState
),
1426 VMSTATE_UINT8(bError
, USBCCIDState
),
1427 VMSTATE_UINT8(bmCommandStatus
, USBCCIDState
),
1428 VMSTATE_UINT8(bProtocolNum
, USBCCIDState
),
1429 VMSTATE_BUFFER(abProtocolDataStructure
.data
, USBCCIDState
),
1430 VMSTATE_UINT32(ulProtocolDataStructureSize
, USBCCIDState
),
1431 VMSTATE_STRUCT_ARRAY(bulk_in_pending
, USBCCIDState
,
1432 BULK_IN_PENDING_NUM
, 1, bulk_in_vmstate
, BulkIn
),
1433 VMSTATE_UINT32(bulk_in_pending_start
, USBCCIDState
),
1434 VMSTATE_UINT32(bulk_in_pending_end
, USBCCIDState
),
1435 VMSTATE_STRUCT_ARRAY(pending_answers
, USBCCIDState
,
1436 PENDING_ANSWERS_NUM
, 1, answer_vmstate
, Answer
),
1437 VMSTATE_UINT32(pending_answers_num
, USBCCIDState
),
1438 VMSTATE_UINT8(migration_state
, USBCCIDState
),
1439 VMSTATE_UINT32(state_vmstate
, USBCCIDState
),
1440 VMSTATE_END_OF_LIST()
1444 static Property ccid_properties
[] = {
1445 DEFINE_PROP_UINT8("debug", USBCCIDState
, debug
, 0),
1446 DEFINE_PROP_END_OF_LIST(),
1449 static void ccid_class_initfn(ObjectClass
*klass
, void *data
)
1451 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1452 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
1453 HotplugHandlerClass
*hc
= HOTPLUG_HANDLER_CLASS(klass
);
1455 uc
->realize
= ccid_realize
;
1456 uc
->product_desc
= "QEMU USB CCID";
1457 uc
->usb_desc
= &desc_ccid
;
1458 uc
->handle_reset
= ccid_handle_reset
;
1459 uc
->handle_control
= ccid_handle_control
;
1460 uc
->handle_data
= ccid_handle_data
;
1461 uc
->handle_destroy
= ccid_handle_destroy
;
1462 dc
->desc
= "CCID Rev 1.1 smartcard reader";
1463 dc
->vmsd
= &ccid_vmstate
;
1464 dc
->props
= ccid_properties
;
1465 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
1466 hc
->unplug
= qdev_simple_device_unplug_cb
;
1469 static const TypeInfo ccid_info
= {
1470 .name
= CCID_DEV_NAME
,
1471 .parent
= TYPE_USB_DEVICE
,
1472 .instance_size
= sizeof(USBCCIDState
),
1473 .class_init
= ccid_class_initfn
,
1474 .interfaces
= (InterfaceInfo
[]) {
1475 { TYPE_HOTPLUG_HANDLER
},
1480 static void ccid_card_class_init(ObjectClass
*klass
, void *data
)
1482 DeviceClass
*k
= DEVICE_CLASS(klass
);
1483 k
->bus_type
= TYPE_CCID_BUS
;
1484 k
->init
= ccid_card_init
;
1485 k
->exit
= ccid_card_exit
;
1486 k
->props
= ccid_props
;
1489 static const TypeInfo ccid_card_type_info
= {
1490 .name
= TYPE_CCID_CARD
,
1491 .parent
= TYPE_DEVICE
,
1492 .instance_size
= sizeof(CCIDCardState
),
1494 .class_size
= sizeof(CCIDCardClass
),
1495 .class_init
= ccid_card_class_init
,
1498 static void ccid_register_types(void)
1500 type_register_static(&ccid_bus_info
);
1501 type_register_static(&ccid_card_type_info
);
1502 type_register_static(&ccid_info
);
1503 usb_legacy_register(CCID_DEV_NAME
, "ccid", NULL
);
1506 type_init(ccid_register_types
)