* [Qemu-devel] [PATCH 0/7] usb-ccid (v14)
@ 2011-01-11 8:38 Alon Levy
2011-01-11 8:38 ` [Qemu-devel] [PATCH 1/7] usb-ccid: add CCID bus Alon Levy
2011-01-11 8:58 ` [Qemu-devel] [PATCH 0/7] usb-ccid (v14) Alon Levy
0 siblings, 2 replies; 5+ messages in thread
From: Alon Levy @ 2011-01-11 8:38 UTC (permalink / raw)
To: qemu-devel
This patchset adds three new devices, usb-ccid, ccid-card-passthru and
ccid-card-emulated, providing a CCID bus, a simple passthru protocol
implementing card requiring a client, and a standalone emulated card.
It also introduces a new directory libcaccard with CAC card emulation,
CAC is a type of ISO 7816 smart card.
Tree for pull: git://anongit.freedesktop.org/~alon/qemu usb_ccid.v14
v14-v15 changes:
* add patch with --enable-smartcard and --disable-smartcard and only
disable ccid-card-emulated if nss not found.
* add patch with description strings
* s/libcaccard/libcacard/ in docs/ccid.txt
v13-v14 changes:
- support device_del/device_add on ccid-card-* and usb-ccid
* usb-ccid:
* lose card reference when card device deleted
* check slot number and deny adding a slot if one is already added.
* ccid-card-*: use qdev_simple_unplug_cb in both emulated and passthru ccid cards,
the exitfn already takes care of triggering card removal in the usb dev.
* libcacard:
* remove double include of config-host.mak
* add replay of card events to libcacard to support second and more emulation
* don't initialize more then once (doesn't support it right now, so one
thread, NSS thread, is left when device_del is done)
* add VCARD_EMUL_INIT_ALREADY_INITED
* ccid-card-emulated:
* take correct mutexes on signaling to fix deadlocks on device_del
* allow card insertion/removal event without proper reader insertion event
v12-v13 changes:
* libcacard:
* fix Makefile clean to remove vscclient
* fix double include of config-host in Makefile
* usb-ccid: remove attach/detach logic, usb is always attached. Guest
doesn't care if there is a reader attached with no card anyway.
* ccid-card-passthru: don't close chr_dev on removal, makes it possible
to use device_del/device_add to create remove/insertion for debugging.
v11-v12 changes:
* fix out of tree build
v10-v11 changes:
* fix last patch that removed one of the doc files.
* updated flow table in docs/ccid.txt
v8-v10 changes:
* usb-ccid:
* add slot for future use (Gerd)
* ifdef ENABLE_MIGRATION for migration support on account of usb
migration not being ready in general. (Gerd)
* verbosified commit messages. (Gerd)
* put libcacard docs in libcacard commit. (Gerd)
v8-v9 changes:
* Blue Swirl comments:
* white space fixes
* enabled by default, disabled only if missing nss
* forgotten fix from v8 (don't build libcacard.so)
* added a note about device being little endian
* library renamed from libcaccard to libcacard
* squashed both of libcacard patches, they touched different files anyway.
v7-v8 changes:
* Blue Swirl comments:
* usb-ccid: deannonymize some structs
* usb-ccid: coding style change - answer_t and bulk_in_t fixed
* usb-ccid: handle endianess conversion between guest and host
* usb-ccid: s/ccid_bulk_in_copy_out/ccid_bulk_in_copy_to_guest/
* ccid-card-emulated: fix segfault if backend not specified
* ccid-card-emulated: let last reader inserted win
* libcaccard: remove double vscard_common.h
v6->v7 changes:
* external libcaccard became internal directory libcaccard
* statically link object files into qemu
* produce libcaccard.so for usage by external projects
* applied coding style to new code (please check me)
- did not use the qemu options parsing for libcaccard, since
it seems to draw large amounts of qemu code (monitor for instance).
v5->v6 changes:
* really remove static debug (I apologize for claiming to have done so before)
v4->v5 changes:
* rebased to latest
* remove static debug in card devices
* fix --enable-smartcard to link
* stall instead of assert when exceeding BULK_OUT_DATA_SIZE
* make ccid_reserve_recv_buf for too large len discard message, not exit
* make ccid_reserve_recv_buf return void*
* fix typo
* remove commented code in VMState
v3->v4:
* remove ccid field in CCIDBus
* remove static debug in bus
* add back docs
v2->v3:
* split into bus (usb-ccid.c, uses ccid.h) and card (ccid-card-passthru.c).
* removed documentation (being revised).
v1->v2:
* all QSIMPLEQ turned into fixed sized rings
* all allocated buffers turned into fixed size buffers
* added migration support
* added a message to tell client qemu has migrated to ip:port
* for lack of monitor commands ip:port are 0:0, which causes the updated
vscclient to connect to one port higher on the same host. will add monitor
commands in a separate patch. tested with current setup.
Alon Levy (6):
usb-ccid: add CCID bus
ccid: add passthru card device
ccid: add ccid-card-emulated device (v2)
ccid: add docs
ccid: configure: add --enable/disable and nss only disable
ccid: add qdev description strings
Robert Relyea (1):
libcacard: initial commit after coding style fixes
Makefile | 6 +-
Makefile.objs | 7 +
Makefile.target | 2 +
configure | 48 ++
docs/ccid.txt | 135 +++++
docs/libcacard.txt | 483 +++++++++++++++
hw/ccid-card-emulated.c | 535 +++++++++++++++++
hw/ccid-card-passthru.c | 273 +++++++++
hw/ccid.h | 35 ++
hw/usb-ccid.c | 1356 +++++++++++++++++++++++++++++++++++++++++++
libcacard/Makefile | 14 +
libcacard/cac.c | 411 +++++++++++++
libcacard/cac.h | 20 +
libcacard/card_7816.c | 780 +++++++++++++++++++++++++
libcacard/card_7816.h | 60 ++
libcacard/card_7816t.h | 163 ++++++
libcacard/config.h | 81 +++
libcacard/event.c | 112 ++++
libcacard/eventt.h | 28 +
libcacard/link_test.c | 20 +
libcacard/mutex.h | 59 ++
libcacard/passthru.c | 612 +++++++++++++++++++
libcacard/passthru.h | 50 ++
libcacard/vcard.c | 350 +++++++++++
libcacard/vcard.h | 85 +++
libcacard/vcard_emul.h | 62 ++
libcacard/vcard_emul_nss.c | 1171 +++++++++++++++++++++++++++++++++++++
libcacard/vcard_emul_type.c | 60 ++
libcacard/vcard_emul_type.h | 29 +
libcacard/vcardt.h | 66 +++
libcacard/vevent.h | 26 +
libcacard/vreader.c | 526 +++++++++++++++++
libcacard/vreader.h | 54 ++
libcacard/vreadert.h | 23 +
libcacard/vscard_common.h | 130 ++++
libcacard/vscclient.c | 710 ++++++++++++++++++++++
36 files changed, 8580 insertions(+), 2 deletions(-)
create mode 100644 docs/ccid.txt
create mode 100644 docs/libcacard.txt
create mode 100644 hw/ccid-card-emulated.c
create mode 100644 hw/ccid-card-passthru.c
create mode 100644 hw/ccid.h
create mode 100644 hw/usb-ccid.c
create mode 100644 libcacard/Makefile
create mode 100644 libcacard/cac.c
create mode 100644 libcacard/cac.h
create mode 100644 libcacard/card_7816.c
create mode 100644 libcacard/card_7816.h
create mode 100644 libcacard/card_7816t.h
create mode 100644 libcacard/config.h
create mode 100644 libcacard/event.c
create mode 100644 libcacard/eventt.h
create mode 100644 libcacard/link_test.c
create mode 100644 libcacard/mutex.h
create mode 100644 libcacard/passthru.c
create mode 100644 libcacard/passthru.h
create mode 100644 libcacard/vcard.c
create mode 100644 libcacard/vcard.h
create mode 100644 libcacard/vcard_emul.h
create mode 100644 libcacard/vcard_emul_nss.c
create mode 100644 libcacard/vcard_emul_type.c
create mode 100644 libcacard/vcard_emul_type.h
create mode 100644 libcacard/vcardt.h
create mode 100644 libcacard/vevent.h
create mode 100644 libcacard/vreader.c
create mode 100644 libcacard/vreader.h
create mode 100644 libcacard/vreadert.h
create mode 100644 libcacard/vscard_common.h
create mode 100644 libcacard/vscclient.c
--
1.7.3.4
^ permalink raw reply [flat|nested] 5+ messages in thread
* [Qemu-devel] [PATCH 1/7] usb-ccid: add CCID bus
2011-01-11 8:38 [Qemu-devel] [PATCH 0/7] usb-ccid (v14) Alon Levy
@ 2011-01-11 8:38 ` Alon Levy
2011-01-25 14:10 ` Anthony Liguori
2011-01-11 8:58 ` [Qemu-devel] [PATCH 0/7] usb-ccid (v14) Alon Levy
1 sibling, 1 reply; 5+ messages in thread
From: Alon Levy @ 2011-01-11 8:38 UTC (permalink / raw)
To: qemu-devel
A CCID device is a smart card reader. It is a USB device, defined at [1].
This patch introduces the usb-ccid device that is a ccid bus. Next patches will
introduce two card types to use it, a passthru card and an emulated card.
[1] http://www.usb.org/developers/devclass_docs/DWG_Smart-Card_CCID_Rev110.
Signed-off-by: Alon Levy <alevy@redhat.com>
---
Makefile.objs | 1 +
configure | 6 +
hw/ccid.h | 35 ++
hw/usb-ccid.c | 1355 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
4 files changed, 1397 insertions(+), 0 deletions(-)
create mode 100644 hw/ccid.h
create mode 100644 hw/usb-ccid.c
diff --git a/Makefile.objs b/Makefile.objs
index d6b3d60..7da4771 100644
--- a/Makefile.objs
+++ b/Makefile.objs
@@ -197,6 +197,7 @@ hw-obj-$(CONFIG_FDC) += fdc.o
hw-obj-$(CONFIG_ACPI) += acpi.o acpi_piix4.o
hw-obj-$(CONFIG_APM) += pm_smbus.o apm.o
hw-obj-$(CONFIG_DMA) += dma.o
+hw-obj-$(CONFIG_SMARTCARD) += usb-ccid.o
# PPC devices
hw-obj-$(CONFIG_OPENPIC) += openpic.o
diff --git a/configure b/configure
index 831a741..839980c 100755
--- a/configure
+++ b/configure
@@ -334,6 +334,7 @@ trace_backend="nop"
trace_file="trace"
spice=""
rbd=""
+smartcard="yes"
# OS specific
if check_define __linux__ ; then
@@ -2441,6 +2442,7 @@ echo "Trace output file $trace_file-<pid>"
echo "spice support $spice"
echo "rbd support $rbd"
echo "xfsctl support $xfs"
+echo "smartcard support $smartcard"
if test $sdl_too_old = "yes"; then
echo "-> Your SDL version is too old - please upgrade to have SDL support"
@@ -2710,6 +2712,10 @@ if test "$spice" = "yes" ; then
echo "CONFIG_SPICE=y" >> $config_host_mak
fi
+if test "$smartcard" = "yes" ; then
+ echo "CONFIG_SMARTCARD=y" >> $config_host_mak
+fi
+
# XXX: suppress that
if [ "$bsd" = "yes" ] ; then
echo "CONFIG_BSD=y" >> $config_host_mak
diff --git a/hw/ccid.h b/hw/ccid.h
new file mode 100644
index 0000000..af59070
--- /dev/null
+++ b/hw/ccid.h
@@ -0,0 +1,35 @@
+#ifndef __CCID_H__
+#define __CCID_H__
+
+#include "qdev.h"
+
+typedef struct CCIDCardState CCIDCardState;
+typedef struct CCIDCardInfo CCIDCardInfo;
+
+struct CCIDCardState {
+ DeviceState qdev;
+ uint32_t slot; // For future use with multiple slot reader.
+};
+
+struct CCIDCardInfo {
+ DeviceInfo qdev;
+ void (*print)(Monitor *mon, CCIDCardState *card, int indent);
+ const uint8_t *(*get_atr)(CCIDCardState *card, uint32_t *len);
+ void (*apdu_from_guest)(CCIDCardState *card, const uint8_t *apdu, uint32_t len);
+ int (*exitfn)(CCIDCardState *card);
+ int (*initfn)(CCIDCardState *card);
+};
+
+void ccid_card_send_apdu_to_guest(CCIDCardState *card, uint8_t* apdu, uint32_t len);
+void ccid_card_card_removed(CCIDCardState *card);
+void ccid_card_card_inserted(CCIDCardState *card);
+void ccid_card_card_error(CCIDCardState *card, uint64_t error);
+void ccid_card_qdev_register(CCIDCardInfo *card);
+
+/* support guest visible insertion/removal of ccid devices based on actual
+ * devices connected/removed. Called by card implementation (passthru, local) */
+int ccid_card_ccid_attach(CCIDCardState *card);
+void ccid_card_ccid_detach(CCIDCardState *card);
+
+#endif // __CCID_H__
+
diff --git a/hw/usb-ccid.c b/hw/usb-ccid.c
new file mode 100644
index 0000000..58f69a6
--- /dev/null
+++ b/hw/usb-ccid.c
@@ -0,0 +1,1355 @@
+/*
+ * CCID Device emulation
+ *
+ * Based on usb-serial.c:
+ * Copyright (c) 2006 CodeSourcery.
+ * Copyright (c) 2008 Samuel Thibault <samuel.thibault@ens-lyon.org>
+ * Written by Paul Brook, reused for FTDI by Samuel Thibault,
+ * Reused for CCID by Alon Levy.
+ * Contributed to by Robert Relyea
+ * Copyright (c) 2010 Red Hat.
+ *
+ * This code is licenced under the LGPL.
+ */
+
+/* References:
+ *
+ * CCID Specification Revision 1.1 April 22nd 2005
+ * "Universal Serial Bus, Device Class: Smart Card"
+ * Specification for Integrated Circuit(s) Cards Interface Devices
+ *
+ * Endianess note: from the spec (1.3)
+ * "Fields that are larger than a byte are stored in little endian
+ *
+ * KNOWN BUGS
+ * 1. remove/insert can sometimes result in removed state instead of inserted.
+ * This is a result of the following:
+ * symptom: dmesg shows ERMOTEIO (-121), pcscd shows -99. This happens
+ * when we send a too short packet, seen in uhci-usb.c, resulting from
+ * a urb requesting SPD and us returning a smaller packet.
+ * Not sure which messages trigger this.
+ *
+ * Migration note:
+ *
+ * All the VMStateDescription's are left here for future use, but
+ * not enabled right now since there is no support for USB migration.
+ *
+ * To enable define ENABLE_MIGRATION
+ */
+
+#include "qemu-common.h"
+#include "qemu-error.h"
+#include "usb.h"
+#include "monitor.h"
+
+#include "hw/ccid.h"
+
+//#define DEBUG_CCID
+
+#define DPRINTF(s, lvl, fmt, ...) \
+do { if (lvl <= s->debug) { printf("usb-ccid: " fmt , ## __VA_ARGS__); } } while (0)
+
+#define CCID_DEV_NAME "usb-ccid"
+
+/* The two options for variable sized buffers:
+ * make them constant size, for large enough constant,
+ * or handle the migration complexity - VMState doesn't handle this case.
+ * sizes are expected never to be exceeded, unless guest misbehaves. */
+#define BULK_OUT_DATA_SIZE 65536
+#define PENDING_ANSWERS_NUM 128
+
+#define BULK_IN_BUF_SIZE 384
+#define BULK_IN_PENDING_NUM 8
+
+#define InterfaceOutClass ((USB_DIR_OUT|USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8)
+#define InterfaceInClass ((USB_DIR_IN |USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8)
+
+#define CCID_CONTROL_ABORT 0x1
+#define CCID_CONTROL_GET_CLOCK_FREQUENCIES 0x2
+#define CCID_CONTROL_GET_DATA_RATES 0x3
+
+#define CCID_PRODUCT_DESCRIPTION "QEMU USB CCID"
+#define CCID_VENDOR_DESCRIPTION "QEMU " QEMU_VERSION
+#define CCID_INTERFACE_NAME "CCID Interface"
+#define CCID_SERIAL_NUMBER_STRING "1"
+/* Using Gemplus Vendor and Product id
+ Effect on various drivers:
+ * usbccid.sys (winxp, others untested) is a class driver so it doesn't care.
+ * linux has a number of class drivers, but openct filters based on
+ vendor/product (/etc/openct.conf under fedora), hence Gemplus.
+ */
+#define CCID_VENDOR_ID 0x08e6
+#define CCID_PRODUCT_ID 0x4433
+#define CCID_DEVICE_VERSION 0x0000
+
+/* BULK_OUT messages from PC to Reader
+ Defined in CCID Rev 1.1 6.1 (page 26)
+ */
+#define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn 0x62
+#define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff 0x63
+#define CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus 0x65
+#define CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock 0x6f
+#define CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters 0x6c
+#define CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters 0x6d
+#define CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters 0x61
+#define CCID_MESSAGE_TYPE_PC_to_RDR_Escape 0x6b
+#define CCID_MESSAGE_TYPE_PC_to_RDR_IccClock 0x6e
+#define CCID_MESSAGE_TYPE_PC_to_RDR_T0APDU 0x6a
+#define CCID_MESSAGE_TYPE_PC_to_RDR_Secure 0x69
+#define CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical 0x71
+#define CCID_MESSAGE_TYPE_PC_to_RDR_Abort 0x72
+#define CCID_MESSAGE_TYPE_PC_to_RDR_SetDataRateAndClockFrequency 0x73
+
+/* BULK_IN messages from Reader to PC
+ Defined in CCID Rev 1.1 6.2 (page 48)
+ */
+#define CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock 0x80
+#define CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus 0x81
+#define CCID_MESSAGE_TYPE_RDR_to_PC_Parameters 0x82
+#define CCID_MESSAGE_TYPE_RDR_to_PC_Escape 0x83
+#define CCID_MESSAGE_TYPE_RDR_to_PC_DataRateAndClockFrequency 0x84
+
+/* INTERRUPT_IN messages from Reader to PC
+ Defined in CCID Rev 1.1 6.3 (page 56)
+ */
+#define CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange 0x50
+#define CCID_MESSAGE_TYPE_RDR_to_PC_HardwareError 0x51
+
+/* Endpoints for CCID - addresses are up to us to decide.
+ To support slot insertion and removal we must have an interrupt in ep
+ in addition we need a bulk in and bulk out ep
+ 5.2, page 20
+ */
+#define CCID_INT_IN_EP 1
+#define CCID_BULK_IN_EP 2
+#define CCID_BULK_OUT_EP 3
+
+/* bmSlotICCState masks */
+#define SLOT_0_STATE_MASK 1
+#define SLOT_0_CHANGED_MASK 2
+
+/* Status codes that go in bStatus (see 6.2.6) */
+enum {
+ ICC_STATUS_PRESENT_ACTIVE = 0,
+ ICC_STATUS_PRESENT_INACTIVE,
+ ICC_STATUS_NOT_PRESENT
+};
+
+enum {
+ COMMAND_STATUS_NO_ERROR = 0,
+ COMMAND_STATUS_FAILED,
+ COMMAND_STATUS_TIME_EXTENSION_REQUIRED
+};
+
+/* Error codes that go in bError (see 6.2.6)
+ */
+enum {
+ ERROR_CMD_NOT_SUPPORTED = 0,
+ ERROR_CMD_ABORTED = -1,
+ ERROR_ICC_MUTE = -2,
+ ERROR_XFR_PARITY_ERROR = -3,
+ ERROR_XFR_OVERRUN = -4,
+ ERROR_HW_ERROR = -5,
+};
+
+/* 6.2.6 RDR_to_PC_SlotStatus definitions */
+enum {
+ CLOCK_STATUS_RUNNING = 0,
+ /* 0 - Clock Running, 1 - Clock stopped in State L, 2 - H,
+ 3 - unkonwn state. rest are RFU
+ */
+};
+
+typedef struct __attribute__ ((__packed__)) CCID_Header {
+ uint8_t bMessageType;
+ uint32_t dwLength;
+ uint8_t bSlot;
+ uint8_t bSeq;
+} CCID_Header;
+
+typedef struct __attribute__ ((__packed__)) CCID_BULK_IN {
+ CCID_Header hdr;
+ uint8_t bStatus; /* Only used in BULK_IN */
+ uint8_t bError; /* Only used in BULK_IN */
+} CCID_BULK_IN;
+
+typedef struct __attribute__ ((__packed__)) CCID_SlotStatus {
+ CCID_BULK_IN b;
+ uint8_t bClockStatus;
+} CCID_SlotStatus;
+
+typedef struct __attribute__ ((__packed__)) CCID_Parameter {
+ CCID_BULK_IN b;
+ uint8_t bProtocolNum;
+ uint8_t abProtocolDataStructure[0];
+} CCID_Parameter;
+
+typedef struct __attribute__ ((__packed__)) CCID_DataBlock {
+ CCID_BULK_IN b;
+ uint8_t bChainParameter;
+ uint8_t abData[0];
+} CCID_DataBlock;
+
+/* 6.1.4 PC_to_RDR_XfrBlock */
+typedef struct __attribute__ ((__packed__)) CCID_XferBlock {
+ CCID_Header hdr;
+ uint8_t bBWI; /* Block Waiting Timeout */
+ uint16_t wLevelParameter; /* XXX currently unused */
+ uint8_t abData[0];
+} CCID_XferBlock;
+
+typedef struct __attribute__ ((__packed__)) CCID_IccPowerOn {
+ CCID_Header hdr;
+ uint8_t bPowerSelect;
+ uint16_t abRFU;
+} CCID_IccPowerOn;
+
+typedef struct __attribute__ ((__packed__)) CCID_IccPowerOff {
+ CCID_Header hdr;
+ uint16_t abRFU;
+} CCID_IccPowerOff;
+
+typedef struct __attribute__ ((__packed__)) CCID_SetParameter {
+ CCID_Header hdr;
+ uint8_t bProtocolNum;
+ uint8_t abProtocolDataStructure[0];
+} CCID_SetParameter;
+
+typedef struct CCID_Notify_Slot_Change {
+ uint8_t bMessageType; /* CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange */
+ uint8_t bmSlotICCState;
+} CCID_Notify_Slot_Change;
+
+/* used for DataBlock response to XferBlock */
+typedef struct Answer {
+ uint8_t slot;
+ uint8_t seq;
+} Answer;
+
+/* pending BULK_IN messages */
+typedef struct BulkIn {
+ uint8_t data[BULK_IN_BUF_SIZE];
+ uint32_t len;
+ uint32_t pos;
+} BulkIn;
+
+enum {
+ MIGRATION_NONE,
+ MIGRATION_MIGRATED,
+};
+
+typedef struct CCIDBus CCIDBus;
+typedef struct USBCCIDState USBCCIDState;
+
+#define MAX_PROTOCOL_SIZE 7
+
+/**
+ * powered - defaults to true, changed by PowerOn/PowerOff messages
+ */
+struct USBCCIDState {
+ USBDevice dev;
+ CCIDBus *bus;
+ CCIDCardState *card;
+ CCIDCardInfo *cardinfo; /* caching the info pointer */
+ uint8_t debug;
+ BulkIn bulk_in_pending[BULK_IN_PENDING_NUM]; /* circular */
+ uint32_t bulk_in_pending_start;
+ uint32_t bulk_in_pending_end; /* first free */
+ uint32_t bulk_in_pending_num;
+ BulkIn *current_bulk_in;
+ uint8_t bulk_out_data[BULK_OUT_DATA_SIZE];
+ uint32_t bulk_out_pos;
+ uint8_t bmSlotICCState;
+ uint8_t powered;
+ uint8_t notify_slot_change;
+ uint64_t last_answer_error;
+ Answer pending_answers[PENDING_ANSWERS_NUM];
+ uint32_t pending_answers_start;
+ uint32_t pending_answers_end;
+ uint32_t pending_answers_num;
+ uint8_t bError;
+ uint8_t bmCommandStatus;
+ uint8_t bProtocolNum;
+ uint8_t abProtocolDataStructure[MAX_PROTOCOL_SIZE];
+ uint32_t ulProtocolDataStructureSize;
+ uint32_t state_vmstate;
+ uint8_t migration_state;
+ uint32_t migration_target_ip;
+ uint16_t migration_target_port;
+};
+
+/* Slot specific variables. We emulate a single slot card reader.
+ */
+
+
+/* CCID Spec chapter 4: CCID uses a standard device descriptor per Chapter 9,
+ * "USB Device Framework", section 9.6.1, in the Universal Serial Bus
+ * Specification.
+ *
+ * This device implemented based on the spec and with an Athena Smart Card
+ * Reader as reference:
+ * 0dc3:1004 Athena Smartcard Solutions, Inc.
+ */
+
+static const uint8_t qemu_ccid_dev_descriptor[] = {
+ 0x12, /* u8 bLength; */
+ USB_DT_DEVICE, /* u8 bDescriptorType; Device */
+ 0x10, 0x01, /* u16 bcdUSB; v1.1 */
+
+ 0x00, /* u8 bDeviceClass; */
+ 0x00, /* u8 bDeviceSubClass; */
+ 0x00, /* u8 bDeviceProtocol; [ low/full speeds only ] */
+ 0x40, /* u8 bMaxPacketSize0; 8 Bytes (valid: 8,16,32,64) */
+
+ /* Vendor and product id are arbitrary. */
+ /* u16 idVendor */
+ CCID_VENDOR_ID & 0xff, CCID_VENDOR_ID >> 8,
+ /* u16 idProduct */
+ CCID_PRODUCT_ID & 0xff, CCID_PRODUCT_ID >> 8,
+ /* u16 bcdDevice */
+ CCID_DEVICE_VERSION & 0xff, CCID_DEVICE_VERSION >> 8,
+ 0x01, /* u8 iManufacturer; */
+ 0x02, /* u8 iProduct; */
+ 0x03, /* u8 iSerialNumber; */
+ 0x01, /* u8 bNumConfigurations; */
+};
+
+static const uint8_t qemu_ccid_config_descriptor[] = {
+
+ /* one configuration */
+ 0x09, /* u8 bLength; */
+ USB_DT_CONFIG, /* u8 bDescriptorType; Configuration */
+ 0x5d, 0x00, /* u16 wTotalLength; 9+9+54+7+7+7 */
+ 0x01, /* u8 bNumInterfaces; (1) */
+ 0x01, /* u8 bConfigurationValue; */
+ 0x00, /* u8 iConfiguration; */
+ 0xe0, /* u8 bmAttributes;
+ Bit 7: must be set,
+ 6: Self-powered,
+ 5: Remote wakeup,
+ 4..0: resvd */
+ 100/2, /* u8 MaxPower; 50 == 100mA */
+
+ /* one interface */
+ 0x09, /* u8 if_bLength; */
+ USB_DT_INTERFACE, /* u8 if_bDescriptorType; Interface */
+ 0x00, /* u8 if_bInterfaceNumber; */
+ 0x00, /* u8 if_bAlternateSetting; */
+ 0x03, /* u8 if_bNumEndpoints; */
+ 0x0b, /* u8 if_bInterfaceClass; Smart Card Device Class */
+ 0x00, /* u8 if_bInterfaceSubClass; Subclass code */
+ 0x00, /* u8 if_bInterfaceProtocol; Protocol code */
+ 0x04, /* u8 if_iInterface; Index of string descriptor */
+
+ /* Smart Card Device Class Descriptor */
+ 0x36, /* u8 bLength; */
+ 0x21, /* u8 bDescriptorType; Functional */
+ 0x10, 0x01, /* u16 bcdCCID; CCID Specification Release Number. */
+ 0x00, /* u8 bMaxSlotIndex; The index of the highest available
+ slot on this device. All slots are consecutive starting
+ at 00h. */
+ 0x07, /* u8 bVoltageSupport; 01h - 5.0v, 02h - 3.0, 03 - 1.8 */
+
+ 0x03, 0x00, /* u32 dwProtocols; RRRR PPPP. RRRR = 0000h.*/
+ 0x00, 0x00, /* PPPP: 0001h = Protocol T=0, 0002h = Protocol T=1 */
+ /* u32 dwDefaultClock; in kHZ (0x0fa0 is 4 MHz) */
+ 0xa0, 0x0f, 0x00, 0x00,
+ /* u32 dwMaximumClock; */
+ 0x00, 0x00, 0x01, 0x00,
+ 0x00, /* u8 bNumClockSupported; 0 means just the default and max. */
+ /* u32 dwDataRate ;bps. 9600 == 00002580h */
+ 0x80, 0x25, 0x00, 0x00,
+ /* u32 dwMaxDataRate ; 11520 bps == 0001C200h */
+ 0x00, 0xC2, 0x01, 0x00,
+ 0x00, /* u8 bNumDataRatesSupported; 00 means all rates between
+ * default and max */
+ /* u32 dwMaxIFSD; maximum IFSD supported by CCID for protocol
+ * T=1 (Maximum seen from various cards) */
+ 0xfe, 0x00, 0x00, 0x00,
+ /* u32 dwSyncProtocols; 1 - 2-wire, 2 - 3-wire, 4 - I2C */
+ 0x00, 0x00, 0x00, 0x00,
+ /* u32 dwMechanical; 0 - no special characteristics. */
+ 0x00, 0x00, 0x00, 0x00,
+ /* u32 dwFeatures;
+ * 0 - No special characteristics
+ * + 2 Automatic parameter configuration based on ATR data
+ * + 4 Automatic activation of ICC on inserting
+ * + 8 Automatic ICC voltage selection
+ * + 10 Automatic ICC clock frequency change
+ * + 20 Automatic baud rate change
+ * + 40 Automatic parameters negotiation made by the CCID
+ * + 80 automatic PPS made by the CCID
+ * 100 CCID can set ICC in clock stop mode
+ * 200 NAD value other then 00 accepted (T=1 protocol)
+ * + 400 Automatic IFSD exchange as first exchange (T=1)
+ * One of the following only:
+ * + 10000 TPDU level exchanges with CCID
+ * 20000 Short APDU level exchange with CCID
+ * 40000 Short and Extended APDU level exchange with CCID
+ *
+ * + 100000 USB Wake up signaling supported on card insertion
+ * and removal. Must set bit 5 in bmAttributes in Configuration
+ * descriptor if 100000 is set.*/
+ 0xfe, 0x04, 0x11, 0x00,
+ /* u32 dwMaxCCIDMessageLength; For extended APDU in [261 + 10
+ * , 65544 + 10]. Otherwise the minimum is wMaxPacketSize of
+ * the Bulk-OUT endpoint */
+ 0x12, 0x00, 0x01, 0x00,
+ 0xFF, /* u8 bClassGetResponse; Significant only for CCID that
+ * offers an APDU level for exchanges. Indicates the default
+ * class value used by the CCID when it sends a Get Response
+ * command to perform the transportation of an APDU by T=0
+ * protocol
+ * FFh indicates that the CCID echos the class of the APDU.
+ */
+ 0xFF, /* u8 bClassEnvelope; EAPDU only. Envelope command for T=0 */
+ 0x00, 0x00, /* u16 wLcdLayout; XXYY Number of lines (XX) and chars per
+ * line for LCD display used for PIN entry. 0000 - no LCD */
+ 0x01, /* u8 bPINSupport; 01h PIN Verification,
+ * 02h PIN Modification */
+ 0x01, /* u8 bMaxCCIDBusySlots; */
+
+ /* Interrupt-IN endpoint */
+ 0x07, /* u8 ep_bLength; */
+ /* u8 ep_bDescriptorType; Endpoint */
+ USB_DT_ENDPOINT,
+ /* u8 ep_bEndpointAddress; IN Endpoint 1 */
+ 0x80 | CCID_INT_IN_EP,
+ 0x03, /* u8 ep_bmAttributes; Interrupt */
+ 0x40, 0x00, /* u16 ep_wMaxPacketSize; */
+ 0xff, /* u8 ep_bInterval; */
+
+ /* Bulk-In endpoint */
+ 0x07, /* u8 ep_bLength; */
+ /* u8 ep_bDescriptorType; Endpoint */
+ USB_DT_ENDPOINT,
+ /* u8 ep_bEndpointAddress; IN Endpoint 2 */
+ 0x80 | CCID_BULK_IN_EP,
+ 0x02, /* u8 ep_bmAttributes; Bulk */
+ 0x40, 0x00, /* u16 ep_wMaxPacketSize; */
+ 0x00, /* u8 ep_bInterval; */
+
+ /* Bulk-Out endpoint */
+ 0x07, /* u8 ep_bLength; */
+ /* u8 ep_bDescriptorType; Endpoint */
+ USB_DT_ENDPOINT,
+ /* u8 ep_bEndpointAddress; OUT Endpoint 3 */
+ CCID_BULK_OUT_EP,
+ 0x02, /* u8 ep_bmAttributes; Bulk */
+ 0x40, 0x00, /* u16 ep_wMaxPacketSize; */
+ 0x00, /* u8 ep_bInterval; */
+
+};
+
+static bool ccid_has_pending_answers(USBCCIDState *s)
+{
+ return s->pending_answers_num > 0;
+}
+
+static void ccid_clear_pending_answers(USBCCIDState *s)
+{
+ s->pending_answers_num = 0;
+ s->pending_answers_start = 0;
+ s->pending_answers_end = 0;
+}
+
+static void ccid_print_pending_answers(USBCCIDState *s)
+{
+#ifdef DEBUG_CCID
+ Answer *answer;
+ int i, count;
+
+ printf("usb-ccid: pending answers:");
+ if (!ccid_has_pending_answers(s)) {
+ printf(" empty\n");
+ return;
+ }
+ for (i = s->pending_answers_start, count=s->pending_answers_num ;
+ count > 0; count--, i++) {
+ answer = &s->pending_answers[i % PENDING_ANSWERS_NUM];
+ if (count == 1) {
+ printf("%d:%d\n", answer->slot, answer->seq);
+ } else {
+ printf("%d:%d,", answer->slot, answer->seq);
+ }
+ }
+#endif
+}
+
+static void ccid_add_pending_answer(USBCCIDState *s, CCID_Header *hdr)
+{
+ Answer* answer;
+
+ assert(s->pending_answers_num++ < PENDING_ANSWERS_NUM);
+ answer = &s->pending_answers[(s->pending_answers_end++) % PENDING_ANSWERS_NUM];
+ answer->slot = hdr->bSlot;
+ answer->seq = hdr->bSeq;
+ ccid_print_pending_answers(s);
+}
+
+static void ccid_remove_pending_answer(USBCCIDState *s,
+ uint8_t *slot, uint8_t *seq)
+{
+ Answer *answer;
+
+ assert(s->pending_answers_num-- > 0);
+ answer = &s->pending_answers[(s->pending_answers_start++) % PENDING_ANSWERS_NUM];
+ *slot = answer->slot;
+ *seq = answer->seq;
+ ccid_print_pending_answers(s);
+}
+
+static void ccid_bulk_in_clear(USBCCIDState *s)
+{
+ s->bulk_in_pending_start = 0;
+ s->bulk_in_pending_end = 0;
+ s->bulk_in_pending_num = 0;
+}
+
+static void ccid_bulk_in_release(USBCCIDState *s)
+{
+ assert(s->current_bulk_in != NULL);
+ s->current_bulk_in->pos = 0;
+ s->current_bulk_in = NULL;
+}
+
+static void ccid_bulk_in_get(USBCCIDState *s)
+{
+ if (s->current_bulk_in != NULL || s->bulk_in_pending_num == 0) {
+ return;
+ }
+ assert(s->bulk_in_pending_num > 0);
+ s->bulk_in_pending_num--;
+ s->current_bulk_in = &s->bulk_in_pending[
+ (s->bulk_in_pending_start++) % BULK_IN_PENDING_NUM];
+}
+
+static void* ccid_reserve_recv_buf(USBCCIDState* s, uint16_t len)
+{
+ BulkIn* bulk_in;
+
+ DPRINTF(s, 4, "%s: QUEUE: reserve %d bytes\n", __func__, len);
+
+ /* look for an existing element */
+ if (len > BULK_IN_BUF_SIZE) {
+ printf("usb-ccid.c: %s: len larger then max (%d>%d). discarding message.\n",
+ __func__, len, BULK_IN_BUF_SIZE);
+ return NULL;
+ }
+ if (s->bulk_in_pending_num >= BULK_IN_PENDING_NUM) {
+ printf("usb-ccid.c: %s: No free bulk_in buffers. discarding message.\n",
+ __func__);
+ return NULL;
+ }
+ bulk_in = &s->bulk_in_pending[(s->bulk_in_pending_end++) % BULK_IN_PENDING_NUM];
+ s->bulk_in_pending_num++;
+ bulk_in->len = len;
+ return bulk_in->data;
+}
+
+static void ccid_reset(USBCCIDState *s)
+{
+ ccid_bulk_in_clear(s);
+ ccid_clear_pending_answers(s);
+}
+
+static void ccid_detach(USBCCIDState *s)
+{
+ ccid_reset(s);
+}
+
+static void ccid_handle_reset(USBDevice *dev)
+{
+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
+
+ DPRINTF(s, 1, "Reset\n");
+
+ ccid_reset(s);
+}
+
+static int ccid_handle_control(USBDevice *dev, int request, int value,
+ int index, int length, uint8_t *data)
+{
+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
+ int ret = 0;
+
+ DPRINTF(s, 1, "got control %x, value %x\n",request, value);
+ switch (request) {
+ case DeviceRequest | USB_REQ_GET_STATUS:
+ data[0] = (0 << USB_DEVICE_SELF_POWERED) |
+ (dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
+ data[1] = 0x00;
+ ret = 2;
+ break;
+ case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
+ if (value == USB_DEVICE_REMOTE_WAKEUP) {
+ dev->remote_wakeup = 0;
+ } else {
+ goto fail;
+ }
+ ret = 0;
+ break;
+ case DeviceOutRequest | USB_REQ_SET_FEATURE:
+ if (value == USB_DEVICE_REMOTE_WAKEUP) {
+ dev->remote_wakeup = 1;
+ } else {
+ goto fail;
+ }
+ ret = 0;
+ break;
+ case DeviceOutRequest | USB_REQ_SET_ADDRESS:
+ dev->addr = value;
+ ret = 0;
+ break;
+ case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
+ switch(value >> 8) {
+ case USB_DT_DEVICE:
+ memcpy(data, qemu_ccid_dev_descriptor,
+ sizeof(qemu_ccid_dev_descriptor));
+ ret = sizeof(qemu_ccid_dev_descriptor);
+ break;
+ case USB_DT_CONFIG:
+ memcpy(data, qemu_ccid_config_descriptor,
+ sizeof(qemu_ccid_config_descriptor));
+ ret = sizeof(qemu_ccid_config_descriptor);
+ break;
+ case USB_DT_STRING:
+ switch(value & 0xff) {
+ case 0:
+ /* language ids */
+ data[0] = 4;
+ data[1] = 3;
+ data[2] = 0x09;
+ data[3] = 0x04;
+ ret = 4;
+ break;
+ case 1:
+ /* vendor description */
+ ret = set_usb_string(data, CCID_VENDOR_DESCRIPTION);
+ break;
+ case 2:
+ /* product description */
+ ret = set_usb_string(data, CCID_PRODUCT_DESCRIPTION);
+ break;
+ case 3:
+ /* serial number */
+ ret = set_usb_string(data, CCID_SERIAL_NUMBER_STRING);
+ break;
+ case 4:
+ /* interface name */
+ ret = set_usb_string(data, CCID_INTERFACE_NAME);
+ break;
+ default:
+ goto fail;
+ }
+ break;
+ default:
+ goto fail;
+ }
+ break;
+ case DeviceRequest | USB_REQ_GET_CONFIGURATION:
+ data[0] = 1;
+ ret = 1;
+ break;
+ case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
+ /* Only one configuration - we just ignore the request */
+ ret = 0;
+ break;
+ case DeviceRequest | USB_REQ_GET_INTERFACE:
+ data[0] = 0;
+ ret = 1;
+ break;
+ case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
+ ret = 0;
+ break;
+ case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
+ ret = 0;
+ break;
+
+ /* Class specific requests. */
+ case InterfaceOutClass | CCID_CONTROL_ABORT:
+ DPRINTF(s, 1, "ccid_control abort UNIMPLEMENTED\n");
+ ret = USB_RET_STALL;
+ break;
+ case InterfaceInClass | CCID_CONTROL_GET_CLOCK_FREQUENCIES:
+ DPRINTF(s, 1, "ccid_control get clock frequencies UNIMPLEMENTED\n");
+ ret = USB_RET_STALL;
+ break;
+ case InterfaceInClass | CCID_CONTROL_GET_DATA_RATES:
+ DPRINTF(s, 1, "ccid_control get data rates UNIMPLEMENTED\n");
+ ret = USB_RET_STALL;
+ break;
+ default:
+ fail:
+ DPRINTF(s, 1, "got unsupported/bogus control %x, value %x\n", request, value);
+ ret = USB_RET_STALL;
+ break;
+ }
+ return ret;
+}
+
+static bool ccid_card_inserted(USBCCIDState *s)
+{
+ return s->bmSlotICCState & SLOT_0_STATE_MASK;
+}
+
+static uint8_t ccid_card_status(USBCCIDState *s)
+{
+ return ccid_card_inserted(s)
+ ? (s->powered ?
+ ICC_STATUS_PRESENT_ACTIVE
+ : ICC_STATUS_PRESENT_INACTIVE
+ )
+ : ICC_STATUS_NOT_PRESENT;
+}
+
+static uint8_t ccid_calc_status(USBCCIDState *s)
+{
+ /* page 55, 6.2.6, calculation of bStatus from bmICCStatus and
+ bmCommandStatus
+ */
+ uint8_t ret = ccid_card_status(s) | (s->bmCommandStatus << 6);
+ DPRINTF(s, 4, "status = %d\n", ret);
+ return ret;
+}
+
+static void ccid_reset_error_status(USBCCIDState* s)
+{
+ s->bError = ERROR_CMD_NOT_SUPPORTED;
+ s->bmCommandStatus = COMMAND_STATUS_NO_ERROR;
+}
+
+static void ccid_write_slot_status(USBCCIDState* s, CCID_Header* recv)
+{
+ CCID_SlotStatus *h = ccid_reserve_recv_buf(s, sizeof(CCID_SlotStatus));
+ if (h == NULL) {
+ return;
+ }
+ h->b.hdr.bMessageType = CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus;
+ h->b.hdr.dwLength = 0;
+ h->b.hdr.bSlot = recv->bSlot;
+ h->b.hdr.bSeq = recv->bSeq;
+ h->b.bStatus = ccid_calc_status(s);
+ h->b.bError = s->bError;
+ h->bClockStatus = CLOCK_STATUS_RUNNING;
+ ccid_reset_error_status(s);
+}
+
+static void ccid_write_parameters(USBCCIDState* s, CCID_Header* recv)
+{
+ CCID_Parameter *h;
+ uint32_t len = s->ulProtocolDataStructureSize;
+
+ h = ccid_reserve_recv_buf(s, sizeof(CCID_Parameter) + len);
+ if (h == NULL) {
+ return;
+ }
+ h->b.hdr.bMessageType = CCID_MESSAGE_TYPE_RDR_to_PC_Parameters;
+ h->b.hdr.dwLength = 0;
+ h->b.hdr.bSlot = recv->bSlot;
+ h->b.hdr.bSeq = recv->bSeq;
+ h->b.bStatus = ccid_calc_status(s);
+ h->b.bError = s->bError;
+ h->bProtocolNum = s->bProtocolNum;
+ memcpy(h->abProtocolDataStructure, s->abProtocolDataStructure, len);
+ ccid_reset_error_status(s);
+}
+
+static void ccid_write_data_block(
+ USBCCIDState* s, uint8_t slot, uint8_t seq,
+ const uint8_t* data, uint32_t len)
+{
+ CCID_DataBlock *p = ccid_reserve_recv_buf(s, sizeof(*p) + len);
+
+ if (p == NULL) {
+ return;
+ }
+ p->b.hdr.bMessageType = CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock;
+ p->b.hdr.dwLength = cpu_to_le32(len);
+ p->b.hdr.bSlot = slot;
+ p->b.hdr.bSeq = seq;
+ p->b.bStatus = ccid_calc_status(s);
+ p->b.bError = s->bError;
+#ifdef DEBUG_CCID
+ if (p->b.bError) {
+ DPRINTF(s, 4, "error %d", p->b.bError);
+ }
+#endif
+ memcpy(p->abData, data, len);
+ ccid_reset_error_status(s);
+}
+
+static void ccid_write_data_block_answer(USBCCIDState* s,
+ const uint8_t* data, uint32_t len)
+{
+ uint8_t seq;
+ uint8_t slot;
+
+ if (!ccid_has_pending_answers(s)) {
+ abort();
+ }
+ ccid_remove_pending_answer(s, &slot, &seq);
+ ccid_write_data_block(s, slot, seq, data, len);
+}
+
+static void ccid_write_data_block_atr(USBCCIDState* s, CCID_Header* recv)
+{
+ const uint8_t *atr = NULL;
+ uint32_t len = 0;
+
+ if (s->card) {
+ atr = s->cardinfo->get_atr(s->card, &len);
+ }
+ ccid_write_data_block(s, recv->bSlot, recv->bSeq, atr, len);
+}
+
+static void ccid_set_parameters(USBCCIDState *s, CCID_Header *recv)
+{
+ CCID_SetParameter *ph = (CCID_SetParameter *) recv;
+ uint32_t len = 0;
+ if (ph->bProtocolNum == 0) {
+ len = 5;
+ }
+ if (ph->bProtocolNum == 1) {
+ len = 7;
+ }
+ if (len == 0) {
+ s->bmCommandStatus = COMMAND_STATUS_FAILED;
+ s->bError = 7; /* Protocol invalid or not supported */
+ return;
+ }
+ s->bProtocolNum = ph->bProtocolNum;
+ memcpy(s->abProtocolDataStructure, ph->abProtocolDataStructure, len);
+ s->ulProtocolDataStructureSize = len;
+ DPRINTF(s, 1, "%s: using len %d\n", __func__, len);
+}
+
+/* must be 5 bytes for T=0, 7 bytes for T=1
+ * See page 52 */
+static const uint8_t abDefaultProtocolDataStructure[7] =
+ { 0x77, 0x00, 0x00, 0x00, 0x00, 0xfe /*IFSC*/, 0x00 /*NAD*/ };
+
+static void ccid_reset_parameters(USBCCIDState *s)
+{
+ uint32_t len = sizeof(abDefaultProtocolDataStructure);
+
+ s->bProtocolNum = 1; /* T=1 */
+ s->ulProtocolDataStructureSize = len;
+ memcpy(s->abProtocolDataStructure, abDefaultProtocolDataStructure, len);
+}
+
+static void ccid_report_error_failed(USBCCIDState *s, uint8_t error)
+{
+ s->bmCommandStatus = COMMAND_STATUS_FAILED;
+ s->bError = error;
+}
+
+/* NOTE: only a single slot is supported (SLOT_0)
+ */
+static void ccid_on_slot_change(USBCCIDState* s, bool full)
+{
+ /* RDR_to_PC_NotifySlotChange, 6.3.1 page 56
+ */
+ uint8_t current = s->bmSlotICCState;
+ if (full) {
+ s->bmSlotICCState |= SLOT_0_STATE_MASK;
+ } else {
+ s->bmSlotICCState &= ~SLOT_0_STATE_MASK;
+ }
+ if (current != s->bmSlotICCState) {
+ s->bmSlotICCState |= SLOT_0_CHANGED_MASK;
+ }
+ s->notify_slot_change = true;
+}
+
+static void ccid_write_data_block_error(
+ USBCCIDState *s, uint8_t slot, uint8_t seq)
+{
+ ccid_write_data_block(s, slot, seq, NULL, 0);
+}
+
+static void ccid_on_apdu_from_guest(USBCCIDState *s, CCID_XferBlock *recv)
+{
+ uint32_t len;
+
+ if (ccid_card_status(s) != ICC_STATUS_PRESENT_ACTIVE) {
+ DPRINTF(s, 1, "usb-ccid: not sending apdu to client, no card connected\n");
+ ccid_write_data_block_error(s, recv->hdr.bSlot, recv->hdr.bSeq);
+ return;
+ }
+ len = le32_to_cpu(recv->hdr.dwLength);
+ DPRINTF(s, 1, "%s: seq %d, len %d\n", __FUNCTION__,
+ recv->hdr.bSeq, len);
+ ccid_add_pending_answer(s, (CCID_Header*)recv);
+ if (s->card) {
+ s->cardinfo->apdu_from_guest(s->card, recv->abData, len);
+ } else {
+ printf("warning: discarded apdu\n");
+ }
+}
+
+/* handle a single USB_TOKEN_OUT, return value returned to guest.
+ * 0 - all ok
+ * USB_RET_STALL - failed to handle packet */
+static int ccid_handle_bulk_out(USBCCIDState *s, USBPacket *p)
+{
+ CCID_Header* ccid_header;
+
+ if (p->len + s->bulk_out_pos > BULK_OUT_DATA_SIZE) {
+ return USB_RET_STALL;
+ }
+ ccid_header = (CCID_Header*)s->bulk_out_data;
+ memcpy(s->bulk_out_data + s->bulk_out_pos, p->data, p->len);
+ s->bulk_out_pos += p->len;
+ if (p->len == 64) {
+ DPRINTF(s, 4, "usb-ccid: bulk_in: expecting more packets (%d/%d)\n",
+ p->len, ccid_header->dwLength);
+ return 0;
+ }
+ if (s->bulk_out_pos < 10) {
+ DPRINTF(s, 1, "%s: bad USB_TOKEN_OUT length, should be at least 10 bytes\n", __func__);
+ } else {
+ DPRINTF(s, 3, "%s %x\n", __func__, ccid_header->bMessageType);
+ switch (ccid_header->bMessageType) {
+ case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus:
+ ccid_write_slot_status(s, ccid_header);
+ break;
+ case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn:
+ DPRINTF(s, 1, "PowerOn: %d\n",
+ ((CCID_IccPowerOn*)(ccid_header))->bPowerSelect);
+ s->powered = true;
+ if (!ccid_card_inserted(s)) {
+ ccid_report_error_failed(s, ERROR_ICC_MUTE);
+ }
+ /* atr is written regardless of error. */
+ ccid_write_data_block_atr(s, ccid_header);
+ break;
+ case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff:
+ DPRINTF(s, 1, "PowerOff\n");
+ ccid_reset_error_status(s);
+ s->powered = false;
+ ccid_write_slot_status(s, ccid_header);
+ break;
+ case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock:
+ ccid_on_apdu_from_guest(s, (CCID_XferBlock*)s->bulk_out_data);
+ break;
+ case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters:
+ ccid_reset_error_status(s);
+ ccid_set_parameters(s, ccid_header);
+ ccid_write_parameters(s, ccid_header);
+ break;
+ case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters:
+ ccid_reset_error_status(s);
+ ccid_reset_parameters(s);
+ ccid_write_parameters(s, ccid_header);
+ break;
+ case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters:
+ ccid_reset_error_status(s);
+ ccid_write_parameters(s, ccid_header);
+ break;
+ default:
+ DPRINTF(s, 1, "handle_data: ERROR: unhandled message type %Xh\n",
+ ccid_header->bMessageType);
+ /* the caller is expecting the device to respond, tell it we
+ * do't support the operation */
+ ccid_report_error_failed(s, ERROR_CMD_NOT_SUPPORTED);
+ ccid_write_slot_status(s, ccid_header);
+ break;
+ }
+ }
+ s->bulk_out_pos = 0;
+ return 0;
+}
+
+static int ccid_bulk_in_copy_to_guest(USBCCIDState *s, uint8_t *data, int len)
+{
+ int ret = 0;
+
+ assert(len>0);
+ ccid_bulk_in_get(s);
+ if (s->current_bulk_in != NULL) {
+ ret = MIN(s->current_bulk_in->len - s->current_bulk_in->pos, len);
+ memcpy(data, s->current_bulk_in->data + s->current_bulk_in->pos, ret);
+ s->current_bulk_in->pos += ret;
+ if (s->current_bulk_in->pos == s->current_bulk_in->len) {
+ ccid_bulk_in_release(s);
+ }
+ } else {
+ ret = USB_RET_NAK; /* return when device has no data - usb 2.0 spec Table 8-4 */
+ }
+ if (ret > 0) {
+ DPRINTF(s, 3, "%s: %d/%d req/act to guest (BULK_IN)\n", __func__, len, ret);
+ }
+ if (ret != USB_RET_NAK && ret < len) {
+ DPRINTF(s, 1, "%s: returning short (EREMOTEIO) %d < %d\n", __func__, ret, len);
+ }
+ return ret;
+}
+
+static int ccid_handle_data(USBDevice *dev, USBPacket *p)
+{
+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
+ int ret = 0;
+ uint8_t *data = p->data;
+ int len = p->len;
+
+ switch (p->pid) {
+ case USB_TOKEN_OUT:
+ ret = ccid_handle_bulk_out(s, p);
+ break;
+
+ case USB_TOKEN_IN:
+ switch (p->devep & 0xf) {
+ case CCID_BULK_IN_EP:
+ if (!len) {
+ ret = USB_RET_NAK;
+ } else {
+ ret = ccid_bulk_in_copy_to_guest(s, data, len);
+ }
+ break;
+ case CCID_INT_IN_EP:
+ if (s->notify_slot_change) {
+ /* page 56, RDR_to_PC_NotifySlotChange */
+ data[0] = CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange;
+ data[1] = s->bmSlotICCState;
+ ret = 2;
+ s->notify_slot_change = false;
+ s->bmSlotICCState &= ~SLOT_0_CHANGED_MASK;
+ DPRINTF(s, 2, "handle_data: int_in: notify_slot_change %X, requested len %d\n",
+ s->bmSlotICCState, len);
+ }
+ break;
+ default:
+ DPRINTF(s, 1, "Bad endpoint\n");
+ break;
+ }
+ break;
+ default:
+ DPRINTF(s, 1, "Bad token\n");
+ ret = USB_RET_STALL;
+ break;
+ }
+
+ return ret;
+}
+
+static void ccid_handle_destroy(USBDevice *dev)
+{
+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
+
+ ccid_bulk_in_clear(s);
+}
+
+static void ccid_flush_pending_answers(USBCCIDState *s) {
+ while (ccid_has_pending_answers(s)) {
+ ccid_write_data_block_answer(s, NULL, 0);
+ }
+}
+
+static Answer *ccid_peek_next_answer(USBCCIDState *s)
+{
+ return s->pending_answers_num == 0
+ ? NULL
+ : &s->pending_answers[s->pending_answers_start % PENDING_ANSWERS_NUM];
+}
+
+static void ccid_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent)
+{
+ CCIDCardState *card = DO_UPCAST(CCIDCardState, qdev, qdev);
+ CCIDCardInfo *info = DO_UPCAST(CCIDCardInfo, qdev, qdev->info);
+
+ if (info->print) {
+ info->print(mon, card, indent);
+ }
+}
+
+struct CCIDBus {
+ BusState qbus;
+};
+
+static struct BusInfo ccid_bus_info = {
+ .name = "ccid-bus",
+ .size = sizeof(CCIDBus),
+ .print_dev = ccid_bus_dev_print,
+ .props = (Property[]) {
+ DEFINE_PROP_UINT32("slot", struct CCIDCardState, slot, 0),
+ DEFINE_PROP_END_OF_LIST(),
+ }
+};
+
+static CCIDBus *ccid_bus_new(DeviceState *dev)
+{
+ CCIDBus *bus;
+
+ bus = FROM_QBUS(CCIDBus, qbus_create(&ccid_bus_info, dev, NULL));
+ bus->qbus.allow_hotplug = 1;
+
+ return bus;
+}
+
+void ccid_card_send_apdu_to_guest(CCIDCardState *card, uint8_t* apdu, uint32_t len)
+{
+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
+ Answer *answer;
+
+ if (!ccid_has_pending_answers(s)) {
+ DPRINTF(s, 1, "CCID ERROR: got an APDU without pending answers\n");
+ return;
+ }
+ s->bmCommandStatus = COMMAND_STATUS_NO_ERROR;
+ answer = ccid_peek_next_answer(s);
+ if (answer == NULL) {
+ abort();
+ }
+ DPRINTF(s, 1, "APDU returned to guest %d (answer seq %d, slot %d)\n",
+ len, answer->seq, answer->slot);
+ ccid_write_data_block_answer(s, apdu, len);
+}
+
+void ccid_card_card_removed(CCIDCardState *card)
+{
+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
+
+ ccid_on_slot_change(s, false);
+ ccid_flush_pending_answers(s);
+ ccid_reset(s);
+}
+
+int ccid_card_ccid_attach(CCIDCardState *card)
+{
+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
+
+ DPRINTF(s, 1, "CCID Attach\n");
+ if (s->migration_state == MIGRATION_MIGRATED) {
+ s->migration_state = MIGRATION_NONE;
+ }
+ return 0;
+}
+
+void ccid_card_ccid_detach(CCIDCardState *card)
+{
+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
+
+ DPRINTF(s, 1, "CCID Detach\n");
+ if (ccid_card_inserted(s)) {
+ ccid_on_slot_change(s, false);
+ }
+ ccid_detach(s);
+}
+
+void ccid_card_card_error(CCIDCardState *card, uint64_t error)
+{
+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
+
+ s->bmCommandStatus = COMMAND_STATUS_FAILED;
+ s->last_answer_error = error;
+ DPRINTF(s, 1, "VSC_Error: %lX\n", s->last_answer_error);
+ /* TODO: these error's should be more verbose and propogated to the guest.
+ * */
+ ccid_write_data_block_answer(s, NULL, 0);
+}
+
+void ccid_card_card_inserted(CCIDCardState *card)
+{
+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
+
+ s->bmCommandStatus = COMMAND_STATUS_NO_ERROR;
+ ccid_flush_pending_answers(s);
+ ccid_on_slot_change(s, true);
+}
+
+static int ccid_card_exit(DeviceState *qdev)
+{
+ int ret = 0;
+ CCIDCardState *card = DO_UPCAST(CCIDCardState, qdev, qdev);
+ CCIDCardInfo *info = DO_UPCAST(CCIDCardInfo, qdev, qdev->info);
+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
+
+ if (ccid_card_inserted(s)) {
+ ccid_card_card_removed(card);
+ }
+ if (info->exitfn) {
+ ret = info->exitfn(card);
+ }
+ s->card = NULL;
+ s->cardinfo = NULL;
+ return ret;
+}
+
+static int ccid_card_init(DeviceState *qdev, DeviceInfo *base)
+{
+ CCIDCardState *card = DO_UPCAST(CCIDCardState, qdev, qdev);
+ CCIDCardInfo *info = DO_UPCAST(CCIDCardInfo, qdev, base);
+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
+ int ret = 0;
+
+ if (card->slot != 0) {
+ fprintf(stderr, "Warning: usb-ccid supports one slot, can't add %d",
+ card->slot);
+ return -1;
+ }
+ if (s->card != NULL) {
+ fprintf(stderr, "Warning: usb-ccid card already full, not adding\n");
+ return -1;
+ }
+ ret = info->initfn ? info->initfn(card) : ret;
+ if (ret == 0) {
+ s->card = card;
+ s->cardinfo = info;
+ }
+ return ret;
+}
+
+void ccid_card_qdev_register(CCIDCardInfo *card)
+{
+ card->qdev.bus_info = &ccid_bus_info;
+ card->qdev.init = ccid_card_init;
+ card->qdev.exit = ccid_card_exit;
+ qdev_register(&card->qdev);
+}
+
+static int ccid_initfn(USBDevice *dev)
+{
+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
+
+ s->bus = ccid_bus_new(&dev->qdev);
+ s->card = NULL;
+ s->cardinfo = NULL;
+ s->migration_state = MIGRATION_NONE;
+ s->migration_target_ip = 0;
+ s->migration_target_port = 0;
+ s->dev.speed = USB_SPEED_FULL;
+ s->notify_slot_change = false;
+ s->powered = true;
+ s->pending_answers_num = 0;
+ s->last_answer_error = 0;
+ s->bulk_in_pending_start = 0;
+ s->bulk_in_pending_end = 0;
+ s->current_bulk_in = NULL;
+ ccid_reset_error_status(s);
+ s->bulk_out_pos = 0;
+ ccid_reset_parameters(s);
+ ccid_reset(s);
+ return 0;
+}
+
+#ifdef ENABLE_MIGRATION
+static int ccid_post_load(void *opaque, int version_id)
+{
+ USBCCIDState *s = opaque;
+
+ // This must be done after usb_device_attach, which sets state to ATTACHED,
+ // while it must be DEFAULT in order to accept packets (like it is after
+ // reset, but reset will reset our addr and call our reset handler which
+ // may change state, and we don't want to do that when migrating).
+ s->dev.state = s->state_vmstate;
+ return 0;
+}
+
+static void ccid_pre_save(void *opaque)
+{
+ USBCCIDState *s = opaque;
+
+ s->state_vmstate = s->dev.state;
+ if (s->dev.attached) {
+ // migrating an open device, ignore reconnection CHR_EVENT to avoid an
+ // erronous detach.
+ s->migration_state = MIGRATION_MIGRATED;
+ }
+}
+
+static VMStateDescription bulk_in_vmstate = {
+ .name = "CCID BulkIn state",
+ .version_id = 1,
+ .minimum_version_id = 1,
+ .fields = (VMStateField []) {
+ VMSTATE_BUFFER(data, BulkIn),
+ VMSTATE_UINT32(len, BulkIn),
+ VMSTATE_UINT32(pos, BulkIn),
+ VMSTATE_END_OF_LIST()
+ }
+};
+
+static VMStateDescription answer_vmstate = {
+ .name = "CCID Answer state",
+ .version_id = 1,
+ .minimum_version_id = 1,
+ .fields = (VMStateField []) {
+ VMSTATE_UINT8(slot, Answer),
+ VMSTATE_UINT8(seq, Answer),
+ VMSTATE_END_OF_LIST()
+ }
+};
+
+static VMStateDescription usb_device_vmstate = {
+ .name = "usb_device",
+ .version_id = 1,
+ .minimum_version_id = 1,
+ .fields = (VMStateField []) {
+ VMSTATE_UINT8(addr, USBDevice),
+ VMSTATE_BUFFER(setup_buf, USBDevice),
+ VMSTATE_BUFFER(data_buf, USBDevice),
+ VMSTATE_END_OF_LIST()
+ }
+};
+
+static VMStateDescription ccid_vmstate = {
+ .name = CCID_DEV_NAME,
+ .version_id = 1,
+ .minimum_version_id = 1,
+ .post_load = ccid_post_load,
+ .pre_save = ccid_pre_save,
+ .fields = (VMStateField []) {
+ VMSTATE_STRUCT(dev, USBCCIDState, 1, usb_device_vmstate, USBDevice),
+ VMSTATE_UINT8(debug, USBCCIDState),
+ VMSTATE_BUFFER(bulk_out_data, USBCCIDState),
+ VMSTATE_UINT32(bulk_out_pos, USBCCIDState),
+ VMSTATE_UINT8(bmSlotICCState, USBCCIDState),
+ VMSTATE_UINT8(powered, USBCCIDState),
+ VMSTATE_UINT8(notify_slot_change, USBCCIDState),
+ VMSTATE_UINT64(last_answer_error, USBCCIDState),
+ VMSTATE_UINT8(bError, USBCCIDState),
+ VMSTATE_UINT8(bmCommandStatus, USBCCIDState),
+ VMSTATE_UINT8(bProtocolNum, USBCCIDState),
+ VMSTATE_BUFFER(abProtocolDataStructure, USBCCIDState),
+ VMSTATE_UINT32(ulProtocolDataStructureSize, USBCCIDState),
+ VMSTATE_STRUCT_ARRAY(bulk_in_pending, USBCCIDState,
+ BULK_IN_PENDING_NUM, 1, bulk_in_vmstate, BulkIn),
+ VMSTATE_UINT32(bulk_in_pending_start, USBCCIDState),
+ VMSTATE_UINT32(bulk_in_pending_end, USBCCIDState),
+ VMSTATE_STRUCT_ARRAY(pending_answers, USBCCIDState,
+ PENDING_ANSWERS_NUM, 1, answer_vmstate, Answer),
+ VMSTATE_UINT32(pending_answers_num, USBCCIDState),
+ VMSTATE_UINT8(migration_state, USBCCIDState),
+ VMSTATE_UINT32(state_vmstate, USBCCIDState),
+ VMSTATE_END_OF_LIST()
+ }
+};
+#endif // ENABLE_MIGRATION
+
+static struct USBDeviceInfo ccid_info = {
+ .product_desc = "QEMU USB CCID",
+ .qdev.name = CCID_DEV_NAME,
+ .qdev.size = sizeof(USBCCIDState),
+ .init = ccid_initfn,
+ .handle_packet = usb_generic_handle_packet,
+ .handle_reset = ccid_handle_reset,
+ .handle_control = ccid_handle_control,
+ .handle_data = ccid_handle_data,
+ .handle_destroy = ccid_handle_destroy,
+ .usbdevice_name = "ccid",
+ .qdev.props = (Property[]) {
+ DEFINE_PROP_UINT8("debug", USBCCIDState, debug, 0),
+ DEFINE_PROP_END_OF_LIST(),
+ },
+#ifdef ENABLE_MIGRATION
+ .qdev.vmsd = &ccid_vmstate,
+#endif
+};
+
+
+static void ccid_register_devices(void)
+{
+ usb_qdev_register(&ccid_info);
+}
+device_init(ccid_register_devices)
--
1.7.3.4
^ permalink raw reply related [flat|nested] 5+ messages in thread
* Re: [Qemu-devel] [PATCH 0/7] usb-ccid (v14)
2011-01-11 8:38 [Qemu-devel] [PATCH 0/7] usb-ccid (v14) Alon Levy
2011-01-11 8:38 ` [Qemu-devel] [PATCH 1/7] usb-ccid: add CCID bus Alon Levy
@ 2011-01-11 8:58 ` Alon Levy
1 sibling, 0 replies; 5+ messages in thread
From: Alon Levy @ 2011-01-11 8:58 UTC (permalink / raw)
To: qemu-devel
On Tue, Jan 11, 2011 at 10:38:06AM +0200, Alon Levy wrote:
> This patchset adds three new devices, usb-ccid, ccid-card-passthru and
> ccid-card-emulated, providing a CCID bus, a simple passthru protocol
> implementing card requiring a client, and a standalone emulated card.
>
[snip]
Sorry about the triple sends of the last patch first few messages. Ignore
the 0/7 v14, it's a typo (was supposed to be v15), and the lonely 0/7 v15
(forgot to update git ref).
Alon
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [Qemu-devel] [PATCH 1/7] usb-ccid: add CCID bus
2011-01-11 8:38 ` [Qemu-devel] [PATCH 1/7] usb-ccid: add CCID bus Alon Levy
@ 2011-01-25 14:10 ` Anthony Liguori
2011-01-25 16:10 ` Alon Levy
0 siblings, 1 reply; 5+ messages in thread
From: Anthony Liguori @ 2011-01-25 14:10 UTC (permalink / raw)
To: Alon Levy; +Cc: qemu-devel
On 01/11/2011 02:38 AM, Alon Levy wrote:
> A CCID device is a smart card reader. It is a USB device, defined at [1].
> This patch introduces the usb-ccid device that is a ccid bus. Next patches will
> introduce two card types to use it, a passthru card and an emulated card.
>
> [1] http://www.usb.org/developers/devclass_docs/DWG_Smart-Card_CCID_Rev110.
>
> Signed-off-by: Alon Levy<alevy@redhat.com>
> ---
> Makefile.objs | 1 +
> configure | 6 +
> hw/ccid.h | 35 ++
> hw/usb-ccid.c | 1355 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 4 files changed, 1397 insertions(+), 0 deletions(-)
> create mode 100644 hw/ccid.h
> create mode 100644 hw/usb-ccid.c
>
> diff --git a/Makefile.objs b/Makefile.objs
> index d6b3d60..7da4771 100644
> --- a/Makefile.objs
> +++ b/Makefile.objs
> @@ -197,6 +197,7 @@ hw-obj-$(CONFIG_FDC) += fdc.o
> hw-obj-$(CONFIG_ACPI) += acpi.o acpi_piix4.o
> hw-obj-$(CONFIG_APM) += pm_smbus.o apm.o
> hw-obj-$(CONFIG_DMA) += dma.o
> +hw-obj-$(CONFIG_SMARTCARD) += usb-ccid.o
>
> # PPC devices
> hw-obj-$(CONFIG_OPENPIC) += openpic.o
> diff --git a/configure b/configure
> index 831a741..839980c 100755
> --- a/configure
> +++ b/configure
> @@ -334,6 +334,7 @@ trace_backend="nop"
> trace_file="trace"
> spice=""
> rbd=""
> +smartcard="yes"
>
> # OS specific
> if check_define __linux__ ; then
> @@ -2441,6 +2442,7 @@ echo "Trace output file $trace_file-<pid>"
> echo "spice support $spice"
> echo "rbd support $rbd"
> echo "xfsctl support $xfs"
> +echo "smartcard support $smartcard"
>
Device don't get printed out in configure because they aren't probed.
> diff --git a/hw/ccid.h b/hw/ccid.h
> new file mode 100644
> index 0000000..af59070
> --- /dev/null
> +++ b/hw/ccid.h
> @@ -0,0 +1,35 @@
> +#ifndef __CCID_H__
> +#define __CCID_H__
>
No copyright and this is not valid C (you're not support to use __ prefix).
> +#include "qdev.h"
> +
> +typedef struct CCIDCardState CCIDCardState;
> +typedef struct CCIDCardInfo CCIDCardInfo;
> +
> +struct CCIDCardState {
> + DeviceState qdev;
> + uint32_t slot; // For future use with multiple slot reader.
>
Don't use C99 comments.
> +};
> +
> +struct CCIDCardInfo {
> + DeviceInfo qdev;
> + void (*print)(Monitor *mon, CCIDCardState *card, int indent);
> + const uint8_t *(*get_atr)(CCIDCardState *card, uint32_t *len);
> + void (*apdu_from_guest)(CCIDCardState *card, const uint8_t *apdu, uint32_t len);
> + int (*exitfn)(CCIDCardState *card);
> + int (*initfn)(CCIDCardState *card);
> +};
> +
> +void ccid_card_send_apdu_to_guest(CCIDCardState *card, uint8_t* apdu, uint32_t len);
> +void ccid_card_card_removed(CCIDCardState *card);
> +void ccid_card_card_inserted(CCIDCardState *card);
> +void ccid_card_card_error(CCIDCardState *card, uint64_t error);
> +void ccid_card_qdev_register(CCIDCardInfo *card);
> +
> +/* support guest visible insertion/removal of ccid devices based on actual
> + * devices connected/removed. Called by card implementation (passthru, local) */
> +int ccid_card_ccid_attach(CCIDCardState *card);
> +void ccid_card_ccid_detach(CCIDCardState *card);
> +
> +#endif // __CCID_H__
> +
> diff --git a/hw/usb-ccid.c b/hw/usb-ccid.c
> new file mode 100644
> index 0000000..58f69a6
> --- /dev/null
> +++ b/hw/usb-ccid.c
> @@ -0,0 +1,1355 @@
> +/*
> + * CCID Device emulation
> + *
> + * Based on usb-serial.c:
> + * Copyright (c) 2006 CodeSourcery.
> + * Copyright (c) 2008 Samuel Thibault<samuel.thibault@ens-lyon.org>
> + * Written by Paul Brook, reused for FTDI by Samuel Thibault,
> + * Reused for CCID by Alon Levy.
> + * Contributed to by Robert Relyea
> + * Copyright (c) 2010 Red Hat.
> + *
> + * This code is licenced under the LGPL.
> + */
> +
> +/* References:
> + *
> + * CCID Specification Revision 1.1 April 22nd 2005
> + * "Universal Serial Bus, Device Class: Smart Card"
> + * Specification for Integrated Circuit(s) Cards Interface Devices
> + *
> + * Endianess note: from the spec (1.3)
> + * "Fields that are larger than a byte are stored in little endian
> + *
> + * KNOWN BUGS
> + * 1. remove/insert can sometimes result in removed state instead of inserted.
> + * This is a result of the following:
> + * symptom: dmesg shows ERMOTEIO (-121), pcscd shows -99. This happens
> + * when we send a too short packet, seen in uhci-usb.c, resulting from
> + * a urb requesting SPD and us returning a smaller packet.
> + * Not sure which messages trigger this.
> + *
> + * Migration note:
> + *
> + * All the VMStateDescription's are left here for future use, but
> + * not enabled right now since there is no support for USB migration.
> + *
> + * To enable define ENABLE_MIGRATION
> + */
> +
> +#include "qemu-common.h"
> +#include "qemu-error.h"
> +#include "usb.h"
> +#include "monitor.h"
> +
> +#include "hw/ccid.h"
> +
> +//#define DEBUG_CCID
> +
> +#define DPRINTF(s, lvl, fmt, ...) \
> +do { if (lvl<= s->debug) { printf("usb-ccid: " fmt , ## __VA_ARGS__); } } while (0)
> +
> +#define CCID_DEV_NAME "usb-ccid"
> +
> +/* The two options for variable sized buffers:
> + * make them constant size, for large enough constant,
> + * or handle the migration complexity - VMState doesn't handle this case.
> + * sizes are expected never to be exceeded, unless guest misbehaves. */
> +#define BULK_OUT_DATA_SIZE 65536
> +#define PENDING_ANSWERS_NUM 128
> +
> +#define BULK_IN_BUF_SIZE 384
> +#define BULK_IN_PENDING_NUM 8
> +
> +#define InterfaceOutClass ((USB_DIR_OUT|USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8)
> +#define InterfaceInClass ((USB_DIR_IN |USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8)
> +
> +#define CCID_CONTROL_ABORT 0x1
> +#define CCID_CONTROL_GET_CLOCK_FREQUENCIES 0x2
> +#define CCID_CONTROL_GET_DATA_RATES 0x3
> +
> +#define CCID_PRODUCT_DESCRIPTION "QEMU USB CCID"
> +#define CCID_VENDOR_DESCRIPTION "QEMU " QEMU_VERSION
>
Note the exposing the version creates a backwards compatibility issue.
> +#define CCID_INTERFACE_NAME "CCID Interface"
> +#define CCID_SERIAL_NUMBER_STRING "1"
> +/* Using Gemplus Vendor and Product id
> + Effect on various drivers:
> + * usbccid.sys (winxp, others untested) is a class driver so it doesn't care.
> + * linux has a number of class drivers, but openct filters based on
> + vendor/product (/etc/openct.conf under fedora), hence Gemplus.
> + */
> +#define CCID_VENDOR_ID 0x08e6
> +#define CCID_PRODUCT_ID 0x4433
> +#define CCID_DEVICE_VERSION 0x0000
> +
> +/* BULK_OUT messages from PC to Reader
> + Defined in CCID Rev 1.1 6.1 (page 26)
> + */
> +#define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn 0x62
> +#define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff 0x63
> +#define CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus 0x65
> +#define CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock 0x6f
> +#define CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters 0x6c
> +#define CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters 0x6d
> +#define CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters 0x61
> +#define CCID_MESSAGE_TYPE_PC_to_RDR_Escape 0x6b
> +#define CCID_MESSAGE_TYPE_PC_to_RDR_IccClock 0x6e
> +#define CCID_MESSAGE_TYPE_PC_to_RDR_T0APDU 0x6a
> +#define CCID_MESSAGE_TYPE_PC_to_RDR_Secure 0x69
> +#define CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical 0x71
> +#define CCID_MESSAGE_TYPE_PC_to_RDR_Abort 0x72
> +#define CCID_MESSAGE_TYPE_PC_to_RDR_SetDataRateAndClockFrequency 0x73
> +
> +/* BULK_IN messages from Reader to PC
> + Defined in CCID Rev 1.1 6.2 (page 48)
> + */
> +#define CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock 0x80
> +#define CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus 0x81
> +#define CCID_MESSAGE_TYPE_RDR_to_PC_Parameters 0x82
> +#define CCID_MESSAGE_TYPE_RDR_to_PC_Escape 0x83
> +#define CCID_MESSAGE_TYPE_RDR_to_PC_DataRateAndClockFrequency 0x84
> +
> +/* INTERRUPT_IN messages from Reader to PC
> + Defined in CCID Rev 1.1 6.3 (page 56)
> + */
> +#define CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange 0x50
> +#define CCID_MESSAGE_TYPE_RDR_to_PC_HardwareError 0x51
> +
> +/* Endpoints for CCID - addresses are up to us to decide.
> + To support slot insertion and removal we must have an interrupt in ep
> + in addition we need a bulk in and bulk out ep
> + 5.2, page 20
> + */
> +#define CCID_INT_IN_EP 1
> +#define CCID_BULK_IN_EP 2
> +#define CCID_BULK_OUT_EP 3
> +
> +/* bmSlotICCState masks */
> +#define SLOT_0_STATE_MASK 1
> +#define SLOT_0_CHANGED_MASK 2
> +
> +/* Status codes that go in bStatus (see 6.2.6) */
> +enum {
> + ICC_STATUS_PRESENT_ACTIVE = 0,
> + ICC_STATUS_PRESENT_INACTIVE,
> + ICC_STATUS_NOT_PRESENT
> +};
> +
> +enum {
> + COMMAND_STATUS_NO_ERROR = 0,
> + COMMAND_STATUS_FAILED,
> + COMMAND_STATUS_TIME_EXTENSION_REQUIRED
> +};
> +
> +/* Error codes that go in bError (see 6.2.6)
> + */
> +enum {
> + ERROR_CMD_NOT_SUPPORTED = 0,
> + ERROR_CMD_ABORTED = -1,
> + ERROR_ICC_MUTE = -2,
> + ERROR_XFR_PARITY_ERROR = -3,
> + ERROR_XFR_OVERRUN = -4,
> + ERROR_HW_ERROR = -5,
> +};
> +
> +/* 6.2.6 RDR_to_PC_SlotStatus definitions */
> +enum {
> + CLOCK_STATUS_RUNNING = 0,
> + /* 0 - Clock Running, 1 - Clock stopped in State L, 2 - H,
> + 3 - unkonwn state. rest are RFU
> + */
> +};
> +
> +typedef struct __attribute__ ((__packed__)) CCID_Header {
> + uint8_t bMessageType;
> + uint32_t dwLength;
> + uint8_t bSlot;
> + uint8_t bSeq;
> +} CCID_Header;
> +
> +typedef struct __attribute__ ((__packed__)) CCID_BULK_IN {
> + CCID_Header hdr;
> + uint8_t bStatus; /* Only used in BULK_IN */
> + uint8_t bError; /* Only used in BULK_IN */
> +} CCID_BULK_IN;
> +
> +typedef struct __attribute__ ((__packed__)) CCID_SlotStatus {
> + CCID_BULK_IN b;
> + uint8_t bClockStatus;
> +} CCID_SlotStatus;
> +
> +typedef struct __attribute__ ((__packed__)) CCID_Parameter {
> + CCID_BULK_IN b;
> + uint8_t bProtocolNum;
> + uint8_t abProtocolDataStructure[0];
> +} CCID_Parameter;
> +
> +typedef struct __attribute__ ((__packed__)) CCID_DataBlock {
> + CCID_BULK_IN b;
> + uint8_t bChainParameter;
> + uint8_t abData[0];
> +} CCID_DataBlock;
> +
> +/* 6.1.4 PC_to_RDR_XfrBlock */
> +typedef struct __attribute__ ((__packed__)) CCID_XferBlock {
> + CCID_Header hdr;
> + uint8_t bBWI; /* Block Waiting Timeout */
> + uint16_t wLevelParameter; /* XXX currently unused */
> + uint8_t abData[0];
> +} CCID_XferBlock;
> +
> +typedef struct __attribute__ ((__packed__)) CCID_IccPowerOn {
> + CCID_Header hdr;
> + uint8_t bPowerSelect;
> + uint16_t abRFU;
> +} CCID_IccPowerOn;
> +
> +typedef struct __attribute__ ((__packed__)) CCID_IccPowerOff {
> + CCID_Header hdr;
> + uint16_t abRFU;
> +} CCID_IccPowerOff;
> +
> +typedef struct __attribute__ ((__packed__)) CCID_SetParameter {
> + CCID_Header hdr;
> + uint8_t bProtocolNum;
> + uint8_t abProtocolDataStructure[0];
> +} CCID_SetParameter;
> +
> +typedef struct CCID_Notify_Slot_Change {
> + uint8_t bMessageType; /* CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange */
> + uint8_t bmSlotICCState;
> +} CCID_Notify_Slot_Change;
> +
> +/* used for DataBlock response to XferBlock */
> +typedef struct Answer {
> + uint8_t slot;
> + uint8_t seq;
> +} Answer;
> +
> +/* pending BULK_IN messages */
> +typedef struct BulkIn {
> + uint8_t data[BULK_IN_BUF_SIZE];
> + uint32_t len;
> + uint32_t pos;
> +} BulkIn;
> +
> +enum {
> + MIGRATION_NONE,
> + MIGRATION_MIGRATED,
> +};
> +
> +typedef struct CCIDBus CCIDBus;
> +typedef struct USBCCIDState USBCCIDState;
> +
> +#define MAX_PROTOCOL_SIZE 7
> +
> +/**
> + * powered - defaults to true, changed by PowerOn/PowerOff messages
> + */
> +struct USBCCIDState {
> + USBDevice dev;
> + CCIDBus *bus;
> + CCIDCardState *card;
> + CCIDCardInfo *cardinfo; /* caching the info pointer */
> + uint8_t debug;
> + BulkIn bulk_in_pending[BULK_IN_PENDING_NUM]; /* circular */
> + uint32_t bulk_in_pending_start;
> + uint32_t bulk_in_pending_end; /* first free */
> + uint32_t bulk_in_pending_num;
> + BulkIn *current_bulk_in;
> + uint8_t bulk_out_data[BULK_OUT_DATA_SIZE];
> + uint32_t bulk_out_pos;
> + uint8_t bmSlotICCState;
> + uint8_t powered;
> + uint8_t notify_slot_change;
> + uint64_t last_answer_error;
> + Answer pending_answers[PENDING_ANSWERS_NUM];
> + uint32_t pending_answers_start;
> + uint32_t pending_answers_end;
> + uint32_t pending_answers_num;
> + uint8_t bError;
> + uint8_t bmCommandStatus;
> + uint8_t bProtocolNum;
> + uint8_t abProtocolDataStructure[MAX_PROTOCOL_SIZE];
> + uint32_t ulProtocolDataStructureSize;
> + uint32_t state_vmstate;
> + uint8_t migration_state;
> + uint32_t migration_target_ip;
> + uint16_t migration_target_port;
> +};
> +
> +/* Slot specific variables. We emulate a single slot card reader.
> + */
> +
> +
> +/* CCID Spec chapter 4: CCID uses a standard device descriptor per Chapter 9,
> + * "USB Device Framework", section 9.6.1, in the Universal Serial Bus
> + * Specification.
> + *
> + * This device implemented based on the spec and with an Athena Smart Card
> + * Reader as reference:
> + * 0dc3:1004 Athena Smartcard Solutions, Inc.
> + */
> +
> +static const uint8_t qemu_ccid_dev_descriptor[] = {
> + 0x12, /* u8 bLength; */
> + USB_DT_DEVICE, /* u8 bDescriptorType; Device */
> + 0x10, 0x01, /* u16 bcdUSB; v1.1 */
> +
> + 0x00, /* u8 bDeviceClass; */
> + 0x00, /* u8 bDeviceSubClass; */
> + 0x00, /* u8 bDeviceProtocol; [ low/full speeds only ] */
> + 0x40, /* u8 bMaxPacketSize0; 8 Bytes (valid: 8,16,32,64) */
> +
> + /* Vendor and product id are arbitrary. */
> + /* u16 idVendor */
> + CCID_VENDOR_ID& 0xff, CCID_VENDOR_ID>> 8,
> + /* u16 idProduct */
> + CCID_PRODUCT_ID& 0xff, CCID_PRODUCT_ID>> 8,
> + /* u16 bcdDevice */
> + CCID_DEVICE_VERSION& 0xff, CCID_DEVICE_VERSION>> 8,
> + 0x01, /* u8 iManufacturer; */
> + 0x02, /* u8 iProduct; */
> + 0x03, /* u8 iSerialNumber; */
> + 0x01, /* u8 bNumConfigurations; */
> +};
> +
> +static const uint8_t qemu_ccid_config_descriptor[] = {
> +
> + /* one configuration */
> + 0x09, /* u8 bLength; */
> + USB_DT_CONFIG, /* u8 bDescriptorType; Configuration */
> + 0x5d, 0x00, /* u16 wTotalLength; 9+9+54+7+7+7 */
> + 0x01, /* u8 bNumInterfaces; (1) */
> + 0x01, /* u8 bConfigurationValue; */
> + 0x00, /* u8 iConfiguration; */
> + 0xe0, /* u8 bmAttributes;
> + Bit 7: must be set,
> + 6: Self-powered,
> + 5: Remote wakeup,
> + 4..0: resvd */
> + 100/2, /* u8 MaxPower; 50 == 100mA */
> +
> + /* one interface */
> + 0x09, /* u8 if_bLength; */
> + USB_DT_INTERFACE, /* u8 if_bDescriptorType; Interface */
> + 0x00, /* u8 if_bInterfaceNumber; */
> + 0x00, /* u8 if_bAlternateSetting; */
> + 0x03, /* u8 if_bNumEndpoints; */
> + 0x0b, /* u8 if_bInterfaceClass; Smart Card Device Class */
> + 0x00, /* u8 if_bInterfaceSubClass; Subclass code */
> + 0x00, /* u8 if_bInterfaceProtocol; Protocol code */
> + 0x04, /* u8 if_iInterface; Index of string descriptor */
> +
> + /* Smart Card Device Class Descriptor */
> + 0x36, /* u8 bLength; */
> + 0x21, /* u8 bDescriptorType; Functional */
> + 0x10, 0x01, /* u16 bcdCCID; CCID Specification Release Number. */
> + 0x00, /* u8 bMaxSlotIndex; The index of the highest available
> + slot on this device. All slots are consecutive starting
> + at 00h. */
> + 0x07, /* u8 bVoltageSupport; 01h - 5.0v, 02h - 3.0, 03 - 1.8 */
> +
> + 0x03, 0x00, /* u32 dwProtocols; RRRR PPPP. RRRR = 0000h.*/
> + 0x00, 0x00, /* PPPP: 0001h = Protocol T=0, 0002h = Protocol T=1 */
> + /* u32 dwDefaultClock; in kHZ (0x0fa0 is 4 MHz) */
> + 0xa0, 0x0f, 0x00, 0x00,
> + /* u32 dwMaximumClock; */
> + 0x00, 0x00, 0x01, 0x00,
> + 0x00, /* u8 bNumClockSupported; 0 means just the default and max. */
> + /* u32 dwDataRate ;bps. 9600 == 00002580h */
> + 0x80, 0x25, 0x00, 0x00,
> + /* u32 dwMaxDataRate ; 11520 bps == 0001C200h */
> + 0x00, 0xC2, 0x01, 0x00,
> + 0x00, /* u8 bNumDataRatesSupported; 00 means all rates between
> + * default and max */
> + /* u32 dwMaxIFSD; maximum IFSD supported by CCID for protocol
> + * T=1 (Maximum seen from various cards) */
> + 0xfe, 0x00, 0x00, 0x00,
> + /* u32 dwSyncProtocols; 1 - 2-wire, 2 - 3-wire, 4 - I2C */
> + 0x00, 0x00, 0x00, 0x00,
> + /* u32 dwMechanical; 0 - no special characteristics. */
> + 0x00, 0x00, 0x00, 0x00,
> + /* u32 dwFeatures;
> + * 0 - No special characteristics
> + * + 2 Automatic parameter configuration based on ATR data
> + * + 4 Automatic activation of ICC on inserting
> + * + 8 Automatic ICC voltage selection
> + * + 10 Automatic ICC clock frequency change
> + * + 20 Automatic baud rate change
> + * + 40 Automatic parameters negotiation made by the CCID
> + * + 80 automatic PPS made by the CCID
> + * 100 CCID can set ICC in clock stop mode
> + * 200 NAD value other then 00 accepted (T=1 protocol)
> + * + 400 Automatic IFSD exchange as first exchange (T=1)
> + * One of the following only:
> + * + 10000 TPDU level exchanges with CCID
> + * 20000 Short APDU level exchange with CCID
> + * 40000 Short and Extended APDU level exchange with CCID
> + *
> + * + 100000 USB Wake up signaling supported on card insertion
> + * and removal. Must set bit 5 in bmAttributes in Configuration
> + * descriptor if 100000 is set.*/
> + 0xfe, 0x04, 0x11, 0x00,
> + /* u32 dwMaxCCIDMessageLength; For extended APDU in [261 + 10
> + * , 65544 + 10]. Otherwise the minimum is wMaxPacketSize of
> + * the Bulk-OUT endpoint */
> + 0x12, 0x00, 0x01, 0x00,
> + 0xFF, /* u8 bClassGetResponse; Significant only for CCID that
> + * offers an APDU level for exchanges. Indicates the default
> + * class value used by the CCID when it sends a Get Response
> + * command to perform the transportation of an APDU by T=0
> + * protocol
> + * FFh indicates that the CCID echos the class of the APDU.
> + */
> + 0xFF, /* u8 bClassEnvelope; EAPDU only. Envelope command for T=0 */
> + 0x00, 0x00, /* u16 wLcdLayout; XXYY Number of lines (XX) and chars per
> + * line for LCD display used for PIN entry. 0000 - no LCD */
> + 0x01, /* u8 bPINSupport; 01h PIN Verification,
> + * 02h PIN Modification */
> + 0x01, /* u8 bMaxCCIDBusySlots; */
> +
> + /* Interrupt-IN endpoint */
> + 0x07, /* u8 ep_bLength; */
> + /* u8 ep_bDescriptorType; Endpoint */
> + USB_DT_ENDPOINT,
> + /* u8 ep_bEndpointAddress; IN Endpoint 1 */
> + 0x80 | CCID_INT_IN_EP,
> + 0x03, /* u8 ep_bmAttributes; Interrupt */
> + 0x40, 0x00, /* u16 ep_wMaxPacketSize; */
> + 0xff, /* u8 ep_bInterval; */
> +
> + /* Bulk-In endpoint */
> + 0x07, /* u8 ep_bLength; */
> + /* u8 ep_bDescriptorType; Endpoint */
> + USB_DT_ENDPOINT,
> + /* u8 ep_bEndpointAddress; IN Endpoint 2 */
> + 0x80 | CCID_BULK_IN_EP,
> + 0x02, /* u8 ep_bmAttributes; Bulk */
> + 0x40, 0x00, /* u16 ep_wMaxPacketSize; */
> + 0x00, /* u8 ep_bInterval; */
> +
> + /* Bulk-Out endpoint */
> + 0x07, /* u8 ep_bLength; */
> + /* u8 ep_bDescriptorType; Endpoint */
> + USB_DT_ENDPOINT,
> + /* u8 ep_bEndpointAddress; OUT Endpoint 3 */
> + CCID_BULK_OUT_EP,
> + 0x02, /* u8 ep_bmAttributes; Bulk */
> + 0x40, 0x00, /* u16 ep_wMaxPacketSize; */
> + 0x00, /* u8 ep_bInterval; */
> +
> +};
> +
> +static bool ccid_has_pending_answers(USBCCIDState *s)
> +{
> + return s->pending_answers_num> 0;
> +}
> +
> +static void ccid_clear_pending_answers(USBCCIDState *s)
> +{
> + s->pending_answers_num = 0;
> + s->pending_answers_start = 0;
> + s->pending_answers_end = 0;
> +}
> +
> +static void ccid_print_pending_answers(USBCCIDState *s)
> +{
> +#ifdef DEBUG_CCID
> + Answer *answer;
> + int i, count;
> +
> + printf("usb-ccid: pending answers:");
> + if (!ccid_has_pending_answers(s)) {
> + printf(" empty\n");
> + return;
> + }
> + for (i = s->pending_answers_start, count=s->pending_answers_num ;
> + count> 0; count--, i++) {
> + answer =&s->pending_answers[i % PENDING_ANSWERS_NUM];
> + if (count == 1) {
> + printf("%d:%d\n", answer->slot, answer->seq);
> + } else {
> + printf("%d:%d,", answer->slot, answer->seq);
> + }
> + }
> +#endif
>
It's usually better to use a dprintf() instead of an #if block like
this. You'll be much more likely to notice when the debug code breaks
which tends to happen over time.
> +}
> +
> +static void ccid_add_pending_answer(USBCCIDState *s, CCID_Header *hdr)
> +{
> + Answer* answer;
> +
> + assert(s->pending_answers_num++< PENDING_ANSWERS_NUM);
>
Having side effects in an assert statement is a very bad idea.
> + answer =&s->pending_answers[(s->pending_answers_end++) % PENDING_ANSWERS_NUM];
> + answer->slot = hdr->bSlot;
> + answer->seq = hdr->bSeq;
> + ccid_print_pending_answers(s);
> +}
> +
> +static void ccid_remove_pending_answer(USBCCIDState *s,
> + uint8_t *slot, uint8_t *seq)
> +{
> + Answer *answer;
> +
> + assert(s->pending_answers_num--> 0);
> + answer =&s->pending_answers[(s->pending_answers_start++) % PENDING_ANSWERS_NUM];
> + *slot = answer->slot;
> + *seq = answer->seq;
> + ccid_print_pending_answers(s);
> +}
> +
> +static void ccid_bulk_in_clear(USBCCIDState *s)
> +{
> + s->bulk_in_pending_start = 0;
> + s->bulk_in_pending_end = 0;
> + s->bulk_in_pending_num = 0;
> +}
> +
> +static void ccid_bulk_in_release(USBCCIDState *s)
> +{
> + assert(s->current_bulk_in != NULL);
> + s->current_bulk_in->pos = 0;
> + s->current_bulk_in = NULL;
> +}
> +
> +static void ccid_bulk_in_get(USBCCIDState *s)
> +{
> + if (s->current_bulk_in != NULL || s->bulk_in_pending_num == 0) {
> + return;
> + }
> + assert(s->bulk_in_pending_num> 0);
> + s->bulk_in_pending_num--;
> + s->current_bulk_in =&s->bulk_in_pending[
> + (s->bulk_in_pending_start++) % BULK_IN_PENDING_NUM];
> +}
> +
> +static void* ccid_reserve_recv_buf(USBCCIDState* s, uint16_t len)
> +{
> + BulkIn* bulk_in;
> +
> + DPRINTF(s, 4, "%s: QUEUE: reserve %d bytes\n", __func__, len);
> +
> + /* look for an existing element */
> + if (len> BULK_IN_BUF_SIZE) {
> + printf("usb-ccid.c: %s: len larger then max (%d>%d). discarding message.\n",
> + __func__, len, BULK_IN_BUF_SIZE);
> + return NULL;
> + }
> + if (s->bulk_in_pending_num>= BULK_IN_PENDING_NUM) {
> + printf("usb-ccid.c: %s: No free bulk_in buffers. discarding message.\n",
> + __func__);
> + return NULL;
> + }
>
Looks like these are guest triggable printfs. You should avoid that.
> + bulk_in =&s->bulk_in_pending[(s->bulk_in_pending_end++) % BULK_IN_PENDING_NUM];
> + s->bulk_in_pending_num++;
> + bulk_in->len = len;
> + return bulk_in->data;
> +}
> +
> +static void ccid_reset(USBCCIDState *s)
> +{
> + ccid_bulk_in_clear(s);
> + ccid_clear_pending_answers(s);
> +}
> +
> +static void ccid_detach(USBCCIDState *s)
> +{
> + ccid_reset(s);
> +}
> +
> +static void ccid_handle_reset(USBDevice *dev)
> +{
> + USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
> +
> + DPRINTF(s, 1, "Reset\n");
> +
> + ccid_reset(s);
> +}
> +
> +static int ccid_handle_control(USBDevice *dev, int request, int value,
> + int index, int length, uint8_t *data)
> +{
> + USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
> + int ret = 0;
> +
> + DPRINTF(s, 1, "got control %x, value %x\n",request, value);
> + switch (request) {
> + case DeviceRequest | USB_REQ_GET_STATUS:
> + data[0] = (0<< USB_DEVICE_SELF_POWERED) |
> + (dev->remote_wakeup<< USB_DEVICE_REMOTE_WAKEUP);
> + data[1] = 0x00;
> + ret = 2;
> + break;
> + case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
> + if (value == USB_DEVICE_REMOTE_WAKEUP) {
> + dev->remote_wakeup = 0;
> + } else {
> + goto fail;
> + }
> + ret = 0;
> + break;
> + case DeviceOutRequest | USB_REQ_SET_FEATURE:
> + if (value == USB_DEVICE_REMOTE_WAKEUP) {
> + dev->remote_wakeup = 1;
> + } else {
> + goto fail;
> + }
> + ret = 0;
> + break;
> + case DeviceOutRequest | USB_REQ_SET_ADDRESS:
> + dev->addr = value;
> + ret = 0;
> + break;
> + case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
> + switch(value>> 8) {
> + case USB_DT_DEVICE:
> + memcpy(data, qemu_ccid_dev_descriptor,
> + sizeof(qemu_ccid_dev_descriptor));
> + ret = sizeof(qemu_ccid_dev_descriptor);
> + break;
> + case USB_DT_CONFIG:
> + memcpy(data, qemu_ccid_config_descriptor,
> + sizeof(qemu_ccid_config_descriptor));
> + ret = sizeof(qemu_ccid_config_descriptor);
> + break;
> + case USB_DT_STRING:
> + switch(value& 0xff) {
> + case 0:
> + /* language ids */
> + data[0] = 4;
> + data[1] = 3;
> + data[2] = 0x09;
> + data[3] = 0x04;
> + ret = 4;
> + break;
> + case 1:
> + /* vendor description */
> + ret = set_usb_string(data, CCID_VENDOR_DESCRIPTION);
> + break;
> + case 2:
> + /* product description */
> + ret = set_usb_string(data, CCID_PRODUCT_DESCRIPTION);
> + break;
> + case 3:
> + /* serial number */
> + ret = set_usb_string(data, CCID_SERIAL_NUMBER_STRING);
> + break;
> + case 4:
> + /* interface name */
> + ret = set_usb_string(data, CCID_INTERFACE_NAME);
> + break;
> + default:
> + goto fail;
> + }
> + break;
> + default:
> + goto fail;
> + }
> + break;
> + case DeviceRequest | USB_REQ_GET_CONFIGURATION:
> + data[0] = 1;
> + ret = 1;
> + break;
> + case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
> + /* Only one configuration - we just ignore the request */
> + ret = 0;
> + break;
> + case DeviceRequest | USB_REQ_GET_INTERFACE:
> + data[0] = 0;
> + ret = 1;
> + break;
> + case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
> + ret = 0;
> + break;
> + case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
> + ret = 0;
> + break;
> +
> + /* Class specific requests. */
> + case InterfaceOutClass | CCID_CONTROL_ABORT:
> + DPRINTF(s, 1, "ccid_control abort UNIMPLEMENTED\n");
> + ret = USB_RET_STALL;
> + break;
> + case InterfaceInClass | CCID_CONTROL_GET_CLOCK_FREQUENCIES:
> + DPRINTF(s, 1, "ccid_control get clock frequencies UNIMPLEMENTED\n");
> + ret = USB_RET_STALL;
> + break;
> + case InterfaceInClass | CCID_CONTROL_GET_DATA_RATES:
> + DPRINTF(s, 1, "ccid_control get data rates UNIMPLEMENTED\n");
> + ret = USB_RET_STALL;
> + break;
> + default:
> + fail:
> + DPRINTF(s, 1, "got unsupported/bogus control %x, value %x\n", request, value);
> + ret = USB_RET_STALL;
> + break;
> + }
> + return ret;
> +}
> +
> +static bool ccid_card_inserted(USBCCIDState *s)
> +{
> + return s->bmSlotICCState& SLOT_0_STATE_MASK;
> +}
> +
> +static uint8_t ccid_card_status(USBCCIDState *s)
> +{
> + return ccid_card_inserted(s)
> + ? (s->powered ?
> + ICC_STATUS_PRESENT_ACTIVE
> + : ICC_STATUS_PRESENT_INACTIVE
> + )
> + : ICC_STATUS_NOT_PRESENT;
> +}
> +
> +static uint8_t ccid_calc_status(USBCCIDState *s)
> +{
> + /* page 55, 6.2.6, calculation of bStatus from bmICCStatus and
> + bmCommandStatus
> + */
> + uint8_t ret = ccid_card_status(s) | (s->bmCommandStatus<< 6);
> + DPRINTF(s, 4, "status = %d\n", ret);
> + return ret;
> +}
> +
> +static void ccid_reset_error_status(USBCCIDState* s)
> +{
> + s->bError = ERROR_CMD_NOT_SUPPORTED;
> + s->bmCommandStatus = COMMAND_STATUS_NO_ERROR;
> +}
> +
> +static void ccid_write_slot_status(USBCCIDState* s, CCID_Header* recv)
> +{
> + CCID_SlotStatus *h = ccid_reserve_recv_buf(s, sizeof(CCID_SlotStatus));
> + if (h == NULL) {
> + return;
> + }
> + h->b.hdr.bMessageType = CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus;
> + h->b.hdr.dwLength = 0;
> + h->b.hdr.bSlot = recv->bSlot;
> + h->b.hdr.bSeq = recv->bSeq;
> + h->b.bStatus = ccid_calc_status(s);
> + h->b.bError = s->bError;
> + h->bClockStatus = CLOCK_STATUS_RUNNING;
> + ccid_reset_error_status(s);
> +}
> +
> +static void ccid_write_parameters(USBCCIDState* s, CCID_Header* recv)
> +{
> + CCID_Parameter *h;
> + uint32_t len = s->ulProtocolDataStructureSize;
> +
> + h = ccid_reserve_recv_buf(s, sizeof(CCID_Parameter) + len);
> + if (h == NULL) {
> + return;
> + }
> + h->b.hdr.bMessageType = CCID_MESSAGE_TYPE_RDR_to_PC_Parameters;
> + h->b.hdr.dwLength = 0;
> + h->b.hdr.bSlot = recv->bSlot;
> + h->b.hdr.bSeq = recv->bSeq;
> + h->b.bStatus = ccid_calc_status(s);
> + h->b.bError = s->bError;
> + h->bProtocolNum = s->bProtocolNum;
> + memcpy(h->abProtocolDataStructure, s->abProtocolDataStructure, len);
> + ccid_reset_error_status(s);
> +}
> +
> +static void ccid_write_data_block(
> + USBCCIDState* s, uint8_t slot, uint8_t seq,
> + const uint8_t* data, uint32_t len)
> +{
> + CCID_DataBlock *p = ccid_reserve_recv_buf(s, sizeof(*p) + len);
> +
> + if (p == NULL) {
> + return;
> + }
> + p->b.hdr.bMessageType = CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock;
> + p->b.hdr.dwLength = cpu_to_le32(len);
> + p->b.hdr.bSlot = slot;
> + p->b.hdr.bSeq = seq;
> + p->b.bStatus = ccid_calc_status(s);
> + p->b.bError = s->bError;
> +#ifdef DEBUG_CCID
> + if (p->b.bError) {
> + DPRINTF(s, 4, "error %d", p->b.bError);
> + }
> +#endif
> + memcpy(p->abData, data, len);
> + ccid_reset_error_status(s);
> +}
> +
> +static void ccid_write_data_block_answer(USBCCIDState* s,
> + const uint8_t* data, uint32_t len)
> +{
> + uint8_t seq;
> + uint8_t slot;
> +
> + if (!ccid_has_pending_answers(s)) {
> + abort();
> + }
> + ccid_remove_pending_answer(s,&slot,&seq);
> + ccid_write_data_block(s, slot, seq, data, len);
> +}
> +
> +static void ccid_write_data_block_atr(USBCCIDState* s, CCID_Header* recv)
> +{
> + const uint8_t *atr = NULL;
> + uint32_t len = 0;
> +
> + if (s->card) {
> + atr = s->cardinfo->get_atr(s->card,&len);
> + }
> + ccid_write_data_block(s, recv->bSlot, recv->bSeq, atr, len);
> +}
> +
> +static void ccid_set_parameters(USBCCIDState *s, CCID_Header *recv)
> +{
> + CCID_SetParameter *ph = (CCID_SetParameter *) recv;
> + uint32_t len = 0;
> + if (ph->bProtocolNum == 0) {
> + len = 5;
> + }
> + if (ph->bProtocolNum == 1) {
> + len = 7;
> + }
> + if (len == 0) {
> + s->bmCommandStatus = COMMAND_STATUS_FAILED;
> + s->bError = 7; /* Protocol invalid or not supported */
> + return;
> + }
> + s->bProtocolNum = ph->bProtocolNum;
> + memcpy(s->abProtocolDataStructure, ph->abProtocolDataStructure, len);
> + s->ulProtocolDataStructureSize = len;
> + DPRINTF(s, 1, "%s: using len %d\n", __func__, len);
> +}
> +
> +/* must be 5 bytes for T=0, 7 bytes for T=1
> + * See page 52 */
> +static const uint8_t abDefaultProtocolDataStructure[7] =
> + { 0x77, 0x00, 0x00, 0x00, 0x00, 0xfe /*IFSC*/, 0x00 /*NAD*/ };
> +
> +static void ccid_reset_parameters(USBCCIDState *s)
> +{
> + uint32_t len = sizeof(abDefaultProtocolDataStructure);
> +
> + s->bProtocolNum = 1; /* T=1 */
> + s->ulProtocolDataStructureSize = len;
> + memcpy(s->abProtocolDataStructure, abDefaultProtocolDataStructure, len);
> +}
> +
> +static void ccid_report_error_failed(USBCCIDState *s, uint8_t error)
> +{
> + s->bmCommandStatus = COMMAND_STATUS_FAILED;
> + s->bError = error;
> +}
> +
> +/* NOTE: only a single slot is supported (SLOT_0)
> + */
> +static void ccid_on_slot_change(USBCCIDState* s, bool full)
> +{
> + /* RDR_to_PC_NotifySlotChange, 6.3.1 page 56
> + */
> + uint8_t current = s->bmSlotICCState;
> + if (full) {
> + s->bmSlotICCState |= SLOT_0_STATE_MASK;
> + } else {
> + s->bmSlotICCState&= ~SLOT_0_STATE_MASK;
> + }
> + if (current != s->bmSlotICCState) {
> + s->bmSlotICCState |= SLOT_0_CHANGED_MASK;
> + }
> + s->notify_slot_change = true;
> +}
> +
> +static void ccid_write_data_block_error(
> + USBCCIDState *s, uint8_t slot, uint8_t seq)
> +{
> + ccid_write_data_block(s, slot, seq, NULL, 0);
> +}
> +
> +static void ccid_on_apdu_from_guest(USBCCIDState *s, CCID_XferBlock *recv)
> +{
> + uint32_t len;
> +
> + if (ccid_card_status(s) != ICC_STATUS_PRESENT_ACTIVE) {
> + DPRINTF(s, 1, "usb-ccid: not sending apdu to client, no card connected\n");
> + ccid_write_data_block_error(s, recv->hdr.bSlot, recv->hdr.bSeq);
> + return;
> + }
> + len = le32_to_cpu(recv->hdr.dwLength);
> + DPRINTF(s, 1, "%s: seq %d, len %d\n", __FUNCTION__,
> + recv->hdr.bSeq, len);
> + ccid_add_pending_answer(s, (CCID_Header*)recv);
> + if (s->card) {
> + s->cardinfo->apdu_from_guest(s->card, recv->abData, len);
> + } else {
> + printf("warning: discarded apdu\n");
>
Guest triggerable printf?
> + }
> +}
> +
> +/* handle a single USB_TOKEN_OUT, return value returned to guest.
> + * 0 - all ok
> + * USB_RET_STALL - failed to handle packet */
> +static int ccid_handle_bulk_out(USBCCIDState *s, USBPacket *p)
> +{
> + CCID_Header* ccid_header;
> +
> + if (p->len + s->bulk_out_pos> BULK_OUT_DATA_SIZE) {
> + return USB_RET_STALL;
> + }
> + ccid_header = (CCID_Header*)s->bulk_out_data;
> + memcpy(s->bulk_out_data + s->bulk_out_pos, p->data, p->len);
> + s->bulk_out_pos += p->len;
> + if (p->len == 64) {
> + DPRINTF(s, 4, "usb-ccid: bulk_in: expecting more packets (%d/%d)\n",
> + p->len, ccid_header->dwLength);
> + return 0;
> + }
> + if (s->bulk_out_pos< 10) {
> + DPRINTF(s, 1, "%s: bad USB_TOKEN_OUT length, should be at least 10 bytes\n", __func__);
> + } else {
> + DPRINTF(s, 3, "%s %x\n", __func__, ccid_header->bMessageType);
> + switch (ccid_header->bMessageType) {
> + case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus:
> + ccid_write_slot_status(s, ccid_header);
> + break;
> + case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn:
> + DPRINTF(s, 1, "PowerOn: %d\n",
> + ((CCID_IccPowerOn*)(ccid_header))->bPowerSelect);
> + s->powered = true;
> + if (!ccid_card_inserted(s)) {
> + ccid_report_error_failed(s, ERROR_ICC_MUTE);
> + }
> + /* atr is written regardless of error. */
> + ccid_write_data_block_atr(s, ccid_header);
> + break;
> + case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff:
> + DPRINTF(s, 1, "PowerOff\n");
> + ccid_reset_error_status(s);
> + s->powered = false;
> + ccid_write_slot_status(s, ccid_header);
> + break;
> + case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock:
> + ccid_on_apdu_from_guest(s, (CCID_XferBlock*)s->bulk_out_data);
> + break;
> + case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters:
> + ccid_reset_error_status(s);
> + ccid_set_parameters(s, ccid_header);
> + ccid_write_parameters(s, ccid_header);
> + break;
> + case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters:
> + ccid_reset_error_status(s);
> + ccid_reset_parameters(s);
> + ccid_write_parameters(s, ccid_header);
> + break;
> + case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters:
> + ccid_reset_error_status(s);
> + ccid_write_parameters(s, ccid_header);
> + break;
> + default:
> + DPRINTF(s, 1, "handle_data: ERROR: unhandled message type %Xh\n",
> + ccid_header->bMessageType);
> + /* the caller is expecting the device to respond, tell it we
> + * do't support the operation */
> + ccid_report_error_failed(s, ERROR_CMD_NOT_SUPPORTED);
> + ccid_write_slot_status(s, ccid_header);
> + break;
> + }
> + }
> + s->bulk_out_pos = 0;
> + return 0;
> +}
> +
> +static int ccid_bulk_in_copy_to_guest(USBCCIDState *s, uint8_t *data, int len)
> +{
> + int ret = 0;
> +
> + assert(len>0);
> + ccid_bulk_in_get(s);
> + if (s->current_bulk_in != NULL) {
> + ret = MIN(s->current_bulk_in->len - s->current_bulk_in->pos, len);
> + memcpy(data, s->current_bulk_in->data + s->current_bulk_in->pos, ret);
> + s->current_bulk_in->pos += ret;
> + if (s->current_bulk_in->pos == s->current_bulk_in->len) {
> + ccid_bulk_in_release(s);
> + }
> + } else {
> + ret = USB_RET_NAK; /* return when device has no data - usb 2.0 spec Table 8-4 */
> + }
> + if (ret> 0) {
> + DPRINTF(s, 3, "%s: %d/%d req/act to guest (BULK_IN)\n", __func__, len, ret);
> + }
> + if (ret != USB_RET_NAK&& ret< len) {
> + DPRINTF(s, 1, "%s: returning short (EREMOTEIO) %d< %d\n", __func__, ret, len);
> + }
> + return ret;
> +}
> +
> +static int ccid_handle_data(USBDevice *dev, USBPacket *p)
> +{
> + USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
> + int ret = 0;
> + uint8_t *data = p->data;
> + int len = p->len;
> +
> + switch (p->pid) {
> + case USB_TOKEN_OUT:
> + ret = ccid_handle_bulk_out(s, p);
> + break;
> +
> + case USB_TOKEN_IN:
> + switch (p->devep& 0xf) {
> + case CCID_BULK_IN_EP:
> + if (!len) {
> + ret = USB_RET_NAK;
> + } else {
> + ret = ccid_bulk_in_copy_to_guest(s, data, len);
> + }
> + break;
> + case CCID_INT_IN_EP:
> + if (s->notify_slot_change) {
> + /* page 56, RDR_to_PC_NotifySlotChange */
> + data[0] = CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange;
> + data[1] = s->bmSlotICCState;
> + ret = 2;
> + s->notify_slot_change = false;
> + s->bmSlotICCState&= ~SLOT_0_CHANGED_MASK;
> + DPRINTF(s, 2, "handle_data: int_in: notify_slot_change %X, requested len %d\n",
> + s->bmSlotICCState, len);
> + }
> + break;
> + default:
> + DPRINTF(s, 1, "Bad endpoint\n");
> + break;
> + }
> + break;
> + default:
> + DPRINTF(s, 1, "Bad token\n");
> + ret = USB_RET_STALL;
> + break;
> + }
> +
> + return ret;
> +}
> +
> +static void ccid_handle_destroy(USBDevice *dev)
> +{
> + USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
> +
> + ccid_bulk_in_clear(s);
> +}
> +
> +static void ccid_flush_pending_answers(USBCCIDState *s) {
> + while (ccid_has_pending_answers(s)) {
> + ccid_write_data_block_answer(s, NULL, 0);
> + }
> +}
> +
> +static Answer *ccid_peek_next_answer(USBCCIDState *s)
> +{
> + return s->pending_answers_num == 0
> + ? NULL
> + :&s->pending_answers[s->pending_answers_start % PENDING_ANSWERS_NUM];
> +}
> +
> +static void ccid_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent)
> +{
> + CCIDCardState *card = DO_UPCAST(CCIDCardState, qdev, qdev);
> + CCIDCardInfo *info = DO_UPCAST(CCIDCardInfo, qdev, qdev->info);
> +
> + if (info->print) {
> + info->print(mon, card, indent);
> + }
> +}
> +
> +struct CCIDBus {
> + BusState qbus;
> +};
> +
> +static struct BusInfo ccid_bus_info = {
> + .name = "ccid-bus",
> + .size = sizeof(CCIDBus),
> + .print_dev = ccid_bus_dev_print,
> + .props = (Property[]) {
> + DEFINE_PROP_UINT32("slot", struct CCIDCardState, slot, 0),
> + DEFINE_PROP_END_OF_LIST(),
> + }
> +};
> +
> +static CCIDBus *ccid_bus_new(DeviceState *dev)
> +{
> + CCIDBus *bus;
> +
> + bus = FROM_QBUS(CCIDBus, qbus_create(&ccid_bus_info, dev, NULL));
> + bus->qbus.allow_hotplug = 1;
> +
> + return bus;
> +}
> +
> +void ccid_card_send_apdu_to_guest(CCIDCardState *card, uint8_t* apdu, uint32_t len)
> +{
> + USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> + Answer *answer;
> +
> + if (!ccid_has_pending_answers(s)) {
> + DPRINTF(s, 1, "CCID ERROR: got an APDU without pending answers\n");
> + return;
> + }
> + s->bmCommandStatus = COMMAND_STATUS_NO_ERROR;
> + answer = ccid_peek_next_answer(s);
> + if (answer == NULL) {
> + abort();
> + }
> + DPRINTF(s, 1, "APDU returned to guest %d (answer seq %d, slot %d)\n",
> + len, answer->seq, answer->slot);
> + ccid_write_data_block_answer(s, apdu, len);
> +}
> +
> +void ccid_card_card_removed(CCIDCardState *card)
> +{
> + USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> +
> + ccid_on_slot_change(s, false);
> + ccid_flush_pending_answers(s);
> + ccid_reset(s);
> +}
> +
> +int ccid_card_ccid_attach(CCIDCardState *card)
> +{
> + USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> +
> + DPRINTF(s, 1, "CCID Attach\n");
> + if (s->migration_state == MIGRATION_MIGRATED) {
> + s->migration_state = MIGRATION_NONE;
> + }
> + return 0;
> +}
> +
> +void ccid_card_ccid_detach(CCIDCardState *card)
> +{
> + USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> +
> + DPRINTF(s, 1, "CCID Detach\n");
> + if (ccid_card_inserted(s)) {
> + ccid_on_slot_change(s, false);
> + }
> + ccid_detach(s);
> +}
> +
> +void ccid_card_card_error(CCIDCardState *card, uint64_t error)
> +{
> + USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> +
> + s->bmCommandStatus = COMMAND_STATUS_FAILED;
> + s->last_answer_error = error;
> + DPRINTF(s, 1, "VSC_Error: %lX\n", s->last_answer_error);
> + /* TODO: these error's should be more verbose and propogated to the guest.
> + * */
> + ccid_write_data_block_answer(s, NULL, 0);
> +}
> +
> +void ccid_card_card_inserted(CCIDCardState *card)
> +{
> + USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> +
> + s->bmCommandStatus = COMMAND_STATUS_NO_ERROR;
> + ccid_flush_pending_answers(s);
> + ccid_on_slot_change(s, true);
> +}
> +
> +static int ccid_card_exit(DeviceState *qdev)
> +{
> + int ret = 0;
> + CCIDCardState *card = DO_UPCAST(CCIDCardState, qdev, qdev);
> + CCIDCardInfo *info = DO_UPCAST(CCIDCardInfo, qdev, qdev->info);
> + USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> +
> + if (ccid_card_inserted(s)) {
> + ccid_card_card_removed(card);
> + }
> + if (info->exitfn) {
> + ret = info->exitfn(card);
> + }
> + s->card = NULL;
> + s->cardinfo = NULL;
> + return ret;
> +}
> +
> +static int ccid_card_init(DeviceState *qdev, DeviceInfo *base)
> +{
> + CCIDCardState *card = DO_UPCAST(CCIDCardState, qdev, qdev);
> + CCIDCardInfo *info = DO_UPCAST(CCIDCardInfo, qdev, base);
> + USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> + int ret = 0;
> +
> + if (card->slot != 0) {
> + fprintf(stderr, "Warning: usb-ccid supports one slot, can't add %d",
> + card->slot);
>
I think error_report is more appropriate here. That makes it visible
over QMP.
> + return -1;
> + }
> + if (s->card != NULL) {
> + fprintf(stderr, "Warning: usb-ccid card already full, not adding\n");
> + return -1;
> + }
> + ret = info->initfn ? info->initfn(card) : ret;
> + if (ret == 0) {
> + s->card = card;
> + s->cardinfo = info;
> + }
> + return ret;
> +}
> +
> +void ccid_card_qdev_register(CCIDCardInfo *card)
> +{
> + card->qdev.bus_info =&ccid_bus_info;
> + card->qdev.init = ccid_card_init;
> + card->qdev.exit = ccid_card_exit;
> + qdev_register(&card->qdev);
> +}
> +
> +static int ccid_initfn(USBDevice *dev)
> +{
> + USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
> +
> + s->bus = ccid_bus_new(&dev->qdev);
> + s->card = NULL;
> + s->cardinfo = NULL;
> + s->migration_state = MIGRATION_NONE;
> + s->migration_target_ip = 0;
> + s->migration_target_port = 0;
> + s->dev.speed = USB_SPEED_FULL;
> + s->notify_slot_change = false;
> + s->powered = true;
> + s->pending_answers_num = 0;
> + s->last_answer_error = 0;
> + s->bulk_in_pending_start = 0;
> + s->bulk_in_pending_end = 0;
> + s->current_bulk_in = NULL;
> + ccid_reset_error_status(s);
> + s->bulk_out_pos = 0;
> + ccid_reset_parameters(s);
> + ccid_reset(s);
> + return 0;
> +}
> +
> +#ifdef ENABLE_MIGRATION
>
Why is migration conditional?
> +static int ccid_post_load(void *opaque, int version_id)
> +{
> + USBCCIDState *s = opaque;
> +
> + // This must be done after usb_device_attach, which sets state to ATTACHED,
> + // while it must be DEFAULT in order to accept packets (like it is after
> + // reset, but reset will reset our addr and call our reset handler which
> + // may change state, and we don't want to do that when migrating).
> + s->dev.state = s->state_vmstate;
> + return 0;
> +}
> +
> +static void ccid_pre_save(void *opaque)
> +{
> + USBCCIDState *s = opaque;
> +
> + s->state_vmstate = s->dev.state;
> + if (s->dev.attached) {
> + // migrating an open device, ignore reconnection CHR_EVENT to avoid an
> + // erronous detach.
> + s->migration_state = MIGRATION_MIGRATED;
> + }
> +}
> +
> +static VMStateDescription bulk_in_vmstate = {
> + .name = "CCID BulkIn state",
> + .version_id = 1,
> + .minimum_version_id = 1,
> + .fields = (VMStateField []) {
> + VMSTATE_BUFFER(data, BulkIn),
> + VMSTATE_UINT32(len, BulkIn),
> + VMSTATE_UINT32(pos, BulkIn),
> + VMSTATE_END_OF_LIST()
> + }
> +};
> +
> +static VMStateDescription answer_vmstate = {
> + .name = "CCID Answer state",
> + .version_id = 1,
> + .minimum_version_id = 1,
> + .fields = (VMStateField []) {
> + VMSTATE_UINT8(slot, Answer),
> + VMSTATE_UINT8(seq, Answer),
> + VMSTATE_END_OF_LIST()
> + }
> +};
> +
> +static VMStateDescription usb_device_vmstate = {
> + .name = "usb_device",
> + .version_id = 1,
> + .minimum_version_id = 1,
> + .fields = (VMStateField []) {
> + VMSTATE_UINT8(addr, USBDevice),
> + VMSTATE_BUFFER(setup_buf, USBDevice),
> + VMSTATE_BUFFER(data_buf, USBDevice),
> + VMSTATE_END_OF_LIST()
> + }
> +};
> +
> +static VMStateDescription ccid_vmstate = {
> + .name = CCID_DEV_NAME,
> + .version_id = 1,
> + .minimum_version_id = 1,
> + .post_load = ccid_post_load,
> + .pre_save = ccid_pre_save,
> + .fields = (VMStateField []) {
> + VMSTATE_STRUCT(dev, USBCCIDState, 1, usb_device_vmstate, USBDevice),
> + VMSTATE_UINT8(debug, USBCCIDState),
> + VMSTATE_BUFFER(bulk_out_data, USBCCIDState),
> + VMSTATE_UINT32(bulk_out_pos, USBCCIDState),
> + VMSTATE_UINT8(bmSlotICCState, USBCCIDState),
> + VMSTATE_UINT8(powered, USBCCIDState),
> + VMSTATE_UINT8(notify_slot_change, USBCCIDState),
> + VMSTATE_UINT64(last_answer_error, USBCCIDState),
> + VMSTATE_UINT8(bError, USBCCIDState),
> + VMSTATE_UINT8(bmCommandStatus, USBCCIDState),
> + VMSTATE_UINT8(bProtocolNum, USBCCIDState),
> + VMSTATE_BUFFER(abProtocolDataStructure, USBCCIDState),
> + VMSTATE_UINT32(ulProtocolDataStructureSize, USBCCIDState),
> + VMSTATE_STRUCT_ARRAY(bulk_in_pending, USBCCIDState,
> + BULK_IN_PENDING_NUM, 1, bulk_in_vmstate, BulkIn),
> + VMSTATE_UINT32(bulk_in_pending_start, USBCCIDState),
> + VMSTATE_UINT32(bulk_in_pending_end, USBCCIDState),
> + VMSTATE_STRUCT_ARRAY(pending_answers, USBCCIDState,
> + PENDING_ANSWERS_NUM, 1, answer_vmstate, Answer),
> + VMSTATE_UINT32(pending_answers_num, USBCCIDState),
> + VMSTATE_UINT8(migration_state, USBCCIDState),
> + VMSTATE_UINT32(state_vmstate, USBCCIDState),
> + VMSTATE_END_OF_LIST()
> + }
> +};
> +#endif // ENABLE_MIGRATION
> +
> +static struct USBDeviceInfo ccid_info = {
> + .product_desc = "QEMU USB CCID",
> + .qdev.name = CCID_DEV_NAME,
> + .qdev.size = sizeof(USBCCIDState),
> + .init = ccid_initfn,
> + .handle_packet = usb_generic_handle_packet,
> + .handle_reset = ccid_handle_reset,
> + .handle_control = ccid_handle_control,
> + .handle_data = ccid_handle_data,
> + .handle_destroy = ccid_handle_destroy,
> + .usbdevice_name = "ccid",
> + .qdev.props = (Property[]) {
> + DEFINE_PROP_UINT8("debug", USBCCIDState, debug, 0),
> + DEFINE_PROP_END_OF_LIST(),
> + },
> +#ifdef ENABLE_MIGRATION
> + .qdev.vmsd =&ccid_vmstate,
> +#endif
> +};
> +
> +
> +static void ccid_register_devices(void)
> +{
> + usb_qdev_register(&ccid_info);
> +}
> +device_init(ccid_register_devices)
>
Regards,
Anthony Liguori
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [Qemu-devel] [PATCH 1/7] usb-ccid: add CCID bus
2011-01-25 14:10 ` Anthony Liguori
@ 2011-01-25 16:10 ` Alon Levy
0 siblings, 0 replies; 5+ messages in thread
From: Alon Levy @ 2011-01-25 16:10 UTC (permalink / raw)
To: Anthony Liguori; +Cc: qemu-devel
On Tue, Jan 25, 2011 at 08:10:11AM -0600, Anthony Liguori wrote:
This review is for v14 - there have been some changes in v15, perhaps you'll
want to go over it.
This is the change log:
v14-v15 changes:
* add patch with --enable-smartcard and --disable-smartcard and only
disable ccid-card-emulated if nss not found.
* add patch with description strings
* s/libcaccard/libcacard/ in docs/ccid.txt
> On 01/11/2011 02:38 AM, Alon Levy wrote:
> >A CCID device is a smart card reader. It is a USB device, defined at [1].
> >This patch introduces the usb-ccid device that is a ccid bus. Next patches will
> >introduce two card types to use it, a passthru card and an emulated card.
> >
> > [1] http://www.usb.org/developers/devclass_docs/DWG_Smart-Card_CCID_Rev110.
> >
> >Signed-off-by: Alon Levy<alevy@redhat.com>
> >---
> > Makefile.objs | 1 +
> > configure | 6 +
> > hw/ccid.h | 35 ++
> > hw/usb-ccid.c | 1355 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> > 4 files changed, 1397 insertions(+), 0 deletions(-)
> > create mode 100644 hw/ccid.h
> > create mode 100644 hw/usb-ccid.c
> >
> >diff --git a/Makefile.objs b/Makefile.objs
> >index d6b3d60..7da4771 100644
> >--- a/Makefile.objs
> >+++ b/Makefile.objs
> >@@ -197,6 +197,7 @@ hw-obj-$(CONFIG_FDC) += fdc.o
> > hw-obj-$(CONFIG_ACPI) += acpi.o acpi_piix4.o
> > hw-obj-$(CONFIG_APM) += pm_smbus.o apm.o
> > hw-obj-$(CONFIG_DMA) += dma.o
> >+hw-obj-$(CONFIG_SMARTCARD) += usb-ccid.o
> >
> > # PPC devices
> > hw-obj-$(CONFIG_OPENPIC) += openpic.o
> >diff --git a/configure b/configure
> >index 831a741..839980c 100755
> >--- a/configure
> >+++ b/configure
> >@@ -334,6 +334,7 @@ trace_backend="nop"
> > trace_file="trace"
> > spice=""
> > rbd=""
> >+smartcard="yes"
> >
> > # OS specific
> > if check_define __linux__ ; then
> >@@ -2441,6 +2442,7 @@ echo "Trace output file $trace_file-<pid>"
> > echo "spice support $spice"
> > echo "rbd support $rbd"
> > echo "xfsctl support $xfs"
> >+echo "smartcard support $smartcard"
>
> Device don't get printed out in configure because they aren't probed.
A later patch (either in the reviewed series v14 or in the newer on list v15)
adds nss, and that is probed for, I guess I'll leave it as nss support then (no
need to mention the smartcard).
> >diff --git a/hw/ccid.h b/hw/ccid.h
> >new file mode 100644
> >index 0000000..af59070
> >--- /dev/null
> >+++ b/hw/ccid.h
> >@@ -0,0 +1,35 @@
> >+#ifndef __CCID_H__
> >+#define __CCID_H__
>
> No copyright and this is not valid C (you're not support to use __ prefix).
>
will fix.
> >+#include "qdev.h"
> >+
> >+typedef struct CCIDCardState CCIDCardState;
> >+typedef struct CCIDCardInfo CCIDCardInfo;
> >+
> >+struct CCIDCardState {
> >+ DeviceState qdev;
> >+ uint32_t slot; // For future use with multiple slot reader.
>
> Don't use C99 comments.
>
will fix.
> >+};
> >+
> >+struct CCIDCardInfo {
> >+ DeviceInfo qdev;
> >+ void (*print)(Monitor *mon, CCIDCardState *card, int indent);
> >+ const uint8_t *(*get_atr)(CCIDCardState *card, uint32_t *len);
> >+ void (*apdu_from_guest)(CCIDCardState *card, const uint8_t *apdu, uint32_t len);
> >+ int (*exitfn)(CCIDCardState *card);
> >+ int (*initfn)(CCIDCardState *card);
> >+};
> >+
> >+void ccid_card_send_apdu_to_guest(CCIDCardState *card, uint8_t* apdu, uint32_t len);
> >+void ccid_card_card_removed(CCIDCardState *card);
> >+void ccid_card_card_inserted(CCIDCardState *card);
> >+void ccid_card_card_error(CCIDCardState *card, uint64_t error);
> >+void ccid_card_qdev_register(CCIDCardInfo *card);
> >+
> >+/* support guest visible insertion/removal of ccid devices based on actual
> >+ * devices connected/removed. Called by card implementation (passthru, local) */
> >+int ccid_card_ccid_attach(CCIDCardState *card);
> >+void ccid_card_ccid_detach(CCIDCardState *card);
> >+
> >+#endif // __CCID_H__
> >+
> >diff --git a/hw/usb-ccid.c b/hw/usb-ccid.c
> >new file mode 100644
> >index 0000000..58f69a6
> >--- /dev/null
> >+++ b/hw/usb-ccid.c
> >@@ -0,0 +1,1355 @@
> >+/*
> >+ * CCID Device emulation
> >+ *
> >+ * Based on usb-serial.c:
> >+ * Copyright (c) 2006 CodeSourcery.
> >+ * Copyright (c) 2008 Samuel Thibault<samuel.thibault@ens-lyon.org>
> >+ * Written by Paul Brook, reused for FTDI by Samuel Thibault,
> >+ * Reused for CCID by Alon Levy.
> >+ * Contributed to by Robert Relyea
> >+ * Copyright (c) 2010 Red Hat.
> >+ *
> >+ * This code is licenced under the LGPL.
> >+ */
> >+
> >+/* References:
> >+ *
> >+ * CCID Specification Revision 1.1 April 22nd 2005
> >+ * "Universal Serial Bus, Device Class: Smart Card"
> >+ * Specification for Integrated Circuit(s) Cards Interface Devices
> >+ *
> >+ * Endianess note: from the spec (1.3)
> >+ * "Fields that are larger than a byte are stored in little endian
> >+ *
> >+ * KNOWN BUGS
> >+ * 1. remove/insert can sometimes result in removed state instead of inserted.
> >+ * This is a result of the following:
> >+ * symptom: dmesg shows ERMOTEIO (-121), pcscd shows -99. This happens
> >+ * when we send a too short packet, seen in uhci-usb.c, resulting from
> >+ * a urb requesting SPD and us returning a smaller packet.
> >+ * Not sure which messages trigger this.
> >+ *
> >+ * Migration note:
> >+ *
> >+ * All the VMStateDescription's are left here for future use, but
> >+ * not enabled right now since there is no support for USB migration.
> >+ *
> >+ * To enable define ENABLE_MIGRATION
> >+ */
> >+
> >+#include "qemu-common.h"
> >+#include "qemu-error.h"
> >+#include "usb.h"
> >+#include "monitor.h"
> >+
> >+#include "hw/ccid.h"
> >+
> >+//#define DEBUG_CCID
> >+
> >+#define DPRINTF(s, lvl, fmt, ...) \
> >+do { if (lvl<= s->debug) { printf("usb-ccid: " fmt , ## __VA_ARGS__); } } while (0)
> >+
> >+#define CCID_DEV_NAME "usb-ccid"
> >+
> >+/* The two options for variable sized buffers:
> >+ * make them constant size, for large enough constant,
> >+ * or handle the migration complexity - VMState doesn't handle this case.
> >+ * sizes are expected never to be exceeded, unless guest misbehaves. */
> >+#define BULK_OUT_DATA_SIZE 65536
> >+#define PENDING_ANSWERS_NUM 128
> >+
> >+#define BULK_IN_BUF_SIZE 384
> >+#define BULK_IN_PENDING_NUM 8
> >+
> >+#define InterfaceOutClass ((USB_DIR_OUT|USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8)
> >+#define InterfaceInClass ((USB_DIR_IN |USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8)
> >+
> >+#define CCID_CONTROL_ABORT 0x1
> >+#define CCID_CONTROL_GET_CLOCK_FREQUENCIES 0x2
> >+#define CCID_CONTROL_GET_DATA_RATES 0x3
> >+
> >+#define CCID_PRODUCT_DESCRIPTION "QEMU USB CCID"
> >+#define CCID_VENDOR_DESCRIPTION "QEMU " QEMU_VERSION
>
> Note the exposing the version creates a backwards compatibility issue.
>
ok, so I guess I'll start an internal count.
> >+#define CCID_INTERFACE_NAME "CCID Interface"
> >+#define CCID_SERIAL_NUMBER_STRING "1"
> >+/* Using Gemplus Vendor and Product id
> >+ Effect on various drivers:
> >+ * usbccid.sys (winxp, others untested) is a class driver so it doesn't care.
> >+ * linux has a number of class drivers, but openct filters based on
> >+ vendor/product (/etc/openct.conf under fedora), hence Gemplus.
> >+ */
> >+#define CCID_VENDOR_ID 0x08e6
> >+#define CCID_PRODUCT_ID 0x4433
> >+#define CCID_DEVICE_VERSION 0x0000
> >+
> >+/* BULK_OUT messages from PC to Reader
> >+ Defined in CCID Rev 1.1 6.1 (page 26)
> >+ */
> >+#define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn 0x62
> >+#define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff 0x63
> >+#define CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus 0x65
> >+#define CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock 0x6f
> >+#define CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters 0x6c
> >+#define CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters 0x6d
> >+#define CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters 0x61
> >+#define CCID_MESSAGE_TYPE_PC_to_RDR_Escape 0x6b
> >+#define CCID_MESSAGE_TYPE_PC_to_RDR_IccClock 0x6e
> >+#define CCID_MESSAGE_TYPE_PC_to_RDR_T0APDU 0x6a
> >+#define CCID_MESSAGE_TYPE_PC_to_RDR_Secure 0x69
> >+#define CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical 0x71
> >+#define CCID_MESSAGE_TYPE_PC_to_RDR_Abort 0x72
> >+#define CCID_MESSAGE_TYPE_PC_to_RDR_SetDataRateAndClockFrequency 0x73
> >+
> >+/* BULK_IN messages from Reader to PC
> >+ Defined in CCID Rev 1.1 6.2 (page 48)
> >+ */
> >+#define CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock 0x80
> >+#define CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus 0x81
> >+#define CCID_MESSAGE_TYPE_RDR_to_PC_Parameters 0x82
> >+#define CCID_MESSAGE_TYPE_RDR_to_PC_Escape 0x83
> >+#define CCID_MESSAGE_TYPE_RDR_to_PC_DataRateAndClockFrequency 0x84
> >+
> >+/* INTERRUPT_IN messages from Reader to PC
> >+ Defined in CCID Rev 1.1 6.3 (page 56)
> >+ */
> >+#define CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange 0x50
> >+#define CCID_MESSAGE_TYPE_RDR_to_PC_HardwareError 0x51
> >+
> >+/* Endpoints for CCID - addresses are up to us to decide.
> >+ To support slot insertion and removal we must have an interrupt in ep
> >+ in addition we need a bulk in and bulk out ep
> >+ 5.2, page 20
> >+ */
> >+#define CCID_INT_IN_EP 1
> >+#define CCID_BULK_IN_EP 2
> >+#define CCID_BULK_OUT_EP 3
> >+
> >+/* bmSlotICCState masks */
> >+#define SLOT_0_STATE_MASK 1
> >+#define SLOT_0_CHANGED_MASK 2
> >+
> >+/* Status codes that go in bStatus (see 6.2.6) */
> >+enum {
> >+ ICC_STATUS_PRESENT_ACTIVE = 0,
> >+ ICC_STATUS_PRESENT_INACTIVE,
> >+ ICC_STATUS_NOT_PRESENT
> >+};
> >+
> >+enum {
> >+ COMMAND_STATUS_NO_ERROR = 0,
> >+ COMMAND_STATUS_FAILED,
> >+ COMMAND_STATUS_TIME_EXTENSION_REQUIRED
> >+};
> >+
> >+/* Error codes that go in bError (see 6.2.6)
> >+ */
> >+enum {
> >+ ERROR_CMD_NOT_SUPPORTED = 0,
> >+ ERROR_CMD_ABORTED = -1,
> >+ ERROR_ICC_MUTE = -2,
> >+ ERROR_XFR_PARITY_ERROR = -3,
> >+ ERROR_XFR_OVERRUN = -4,
> >+ ERROR_HW_ERROR = -5,
> >+};
> >+
> >+/* 6.2.6 RDR_to_PC_SlotStatus definitions */
> >+enum {
> >+ CLOCK_STATUS_RUNNING = 0,
> >+ /* 0 - Clock Running, 1 - Clock stopped in State L, 2 - H,
> >+ 3 - unkonwn state. rest are RFU
> >+ */
> >+};
> >+
> >+typedef struct __attribute__ ((__packed__)) CCID_Header {
> >+ uint8_t bMessageType;
> >+ uint32_t dwLength;
> >+ uint8_t bSlot;
> >+ uint8_t bSeq;
> >+} CCID_Header;
> >+
> >+typedef struct __attribute__ ((__packed__)) CCID_BULK_IN {
> >+ CCID_Header hdr;
> >+ uint8_t bStatus; /* Only used in BULK_IN */
> >+ uint8_t bError; /* Only used in BULK_IN */
> >+} CCID_BULK_IN;
> >+
> >+typedef struct __attribute__ ((__packed__)) CCID_SlotStatus {
> >+ CCID_BULK_IN b;
> >+ uint8_t bClockStatus;
> >+} CCID_SlotStatus;
> >+
> >+typedef struct __attribute__ ((__packed__)) CCID_Parameter {
> >+ CCID_BULK_IN b;
> >+ uint8_t bProtocolNum;
> >+ uint8_t abProtocolDataStructure[0];
> >+} CCID_Parameter;
> >+
> >+typedef struct __attribute__ ((__packed__)) CCID_DataBlock {
> >+ CCID_BULK_IN b;
> >+ uint8_t bChainParameter;
> >+ uint8_t abData[0];
> >+} CCID_DataBlock;
> >+
> >+/* 6.1.4 PC_to_RDR_XfrBlock */
> >+typedef struct __attribute__ ((__packed__)) CCID_XferBlock {
> >+ CCID_Header hdr;
> >+ uint8_t bBWI; /* Block Waiting Timeout */
> >+ uint16_t wLevelParameter; /* XXX currently unused */
> >+ uint8_t abData[0];
> >+} CCID_XferBlock;
> >+
> >+typedef struct __attribute__ ((__packed__)) CCID_IccPowerOn {
> >+ CCID_Header hdr;
> >+ uint8_t bPowerSelect;
> >+ uint16_t abRFU;
> >+} CCID_IccPowerOn;
> >+
> >+typedef struct __attribute__ ((__packed__)) CCID_IccPowerOff {
> >+ CCID_Header hdr;
> >+ uint16_t abRFU;
> >+} CCID_IccPowerOff;
> >+
> >+typedef struct __attribute__ ((__packed__)) CCID_SetParameter {
> >+ CCID_Header hdr;
> >+ uint8_t bProtocolNum;
> >+ uint8_t abProtocolDataStructure[0];
> >+} CCID_SetParameter;
> >+
> >+typedef struct CCID_Notify_Slot_Change {
> >+ uint8_t bMessageType; /* CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange */
> >+ uint8_t bmSlotICCState;
> >+} CCID_Notify_Slot_Change;
> >+
> >+/* used for DataBlock response to XferBlock */
> >+typedef struct Answer {
> >+ uint8_t slot;
> >+ uint8_t seq;
> >+} Answer;
> >+
> >+/* pending BULK_IN messages */
> >+typedef struct BulkIn {
> >+ uint8_t data[BULK_IN_BUF_SIZE];
> >+ uint32_t len;
> >+ uint32_t pos;
> >+} BulkIn;
> >+
> >+enum {
> >+ MIGRATION_NONE,
> >+ MIGRATION_MIGRATED,
> >+};
> >+
> >+typedef struct CCIDBus CCIDBus;
> >+typedef struct USBCCIDState USBCCIDState;
> >+
> >+#define MAX_PROTOCOL_SIZE 7
> >+
> >+/**
> >+ * powered - defaults to true, changed by PowerOn/PowerOff messages
> >+ */
> >+struct USBCCIDState {
> >+ USBDevice dev;
> >+ CCIDBus *bus;
> >+ CCIDCardState *card;
> >+ CCIDCardInfo *cardinfo; /* caching the info pointer */
> >+ uint8_t debug;
> >+ BulkIn bulk_in_pending[BULK_IN_PENDING_NUM]; /* circular */
> >+ uint32_t bulk_in_pending_start;
> >+ uint32_t bulk_in_pending_end; /* first free */
> >+ uint32_t bulk_in_pending_num;
> >+ BulkIn *current_bulk_in;
> >+ uint8_t bulk_out_data[BULK_OUT_DATA_SIZE];
> >+ uint32_t bulk_out_pos;
> >+ uint8_t bmSlotICCState;
> >+ uint8_t powered;
> >+ uint8_t notify_slot_change;
> >+ uint64_t last_answer_error;
> >+ Answer pending_answers[PENDING_ANSWERS_NUM];
> >+ uint32_t pending_answers_start;
> >+ uint32_t pending_answers_end;
> >+ uint32_t pending_answers_num;
> >+ uint8_t bError;
> >+ uint8_t bmCommandStatus;
> >+ uint8_t bProtocolNum;
> >+ uint8_t abProtocolDataStructure[MAX_PROTOCOL_SIZE];
> >+ uint32_t ulProtocolDataStructureSize;
> >+ uint32_t state_vmstate;
> >+ uint8_t migration_state;
> >+ uint32_t migration_target_ip;
> >+ uint16_t migration_target_port;
> >+};
> >+
> >+/* Slot specific variables. We emulate a single slot card reader.
> >+ */
> >+
> >+
> >+/* CCID Spec chapter 4: CCID uses a standard device descriptor per Chapter 9,
> >+ * "USB Device Framework", section 9.6.1, in the Universal Serial Bus
> >+ * Specification.
> >+ *
> >+ * This device implemented based on the spec and with an Athena Smart Card
> >+ * Reader as reference:
> >+ * 0dc3:1004 Athena Smartcard Solutions, Inc.
> >+ */
> >+
> >+static const uint8_t qemu_ccid_dev_descriptor[] = {
> >+ 0x12, /* u8 bLength; */
> >+ USB_DT_DEVICE, /* u8 bDescriptorType; Device */
> >+ 0x10, 0x01, /* u16 bcdUSB; v1.1 */
> >+
> >+ 0x00, /* u8 bDeviceClass; */
> >+ 0x00, /* u8 bDeviceSubClass; */
> >+ 0x00, /* u8 bDeviceProtocol; [ low/full speeds only ] */
> >+ 0x40, /* u8 bMaxPacketSize0; 8 Bytes (valid: 8,16,32,64) */
> >+
> >+ /* Vendor and product id are arbitrary. */
> >+ /* u16 idVendor */
> >+ CCID_VENDOR_ID& 0xff, CCID_VENDOR_ID>> 8,
> >+ /* u16 idProduct */
> >+ CCID_PRODUCT_ID& 0xff, CCID_PRODUCT_ID>> 8,
> >+ /* u16 bcdDevice */
> >+ CCID_DEVICE_VERSION& 0xff, CCID_DEVICE_VERSION>> 8,
> >+ 0x01, /* u8 iManufacturer; */
> >+ 0x02, /* u8 iProduct; */
> >+ 0x03, /* u8 iSerialNumber; */
> >+ 0x01, /* u8 bNumConfigurations; */
> >+};
> >+
> >+static const uint8_t qemu_ccid_config_descriptor[] = {
> >+
> >+ /* one configuration */
> >+ 0x09, /* u8 bLength; */
> >+ USB_DT_CONFIG, /* u8 bDescriptorType; Configuration */
> >+ 0x5d, 0x00, /* u16 wTotalLength; 9+9+54+7+7+7 */
> >+ 0x01, /* u8 bNumInterfaces; (1) */
> >+ 0x01, /* u8 bConfigurationValue; */
> >+ 0x00, /* u8 iConfiguration; */
> >+ 0xe0, /* u8 bmAttributes;
> >+ Bit 7: must be set,
> >+ 6: Self-powered,
> >+ 5: Remote wakeup,
> >+ 4..0: resvd */
> >+ 100/2, /* u8 MaxPower; 50 == 100mA */
> >+
> >+ /* one interface */
> >+ 0x09, /* u8 if_bLength; */
> >+ USB_DT_INTERFACE, /* u8 if_bDescriptorType; Interface */
> >+ 0x00, /* u8 if_bInterfaceNumber; */
> >+ 0x00, /* u8 if_bAlternateSetting; */
> >+ 0x03, /* u8 if_bNumEndpoints; */
> >+ 0x0b, /* u8 if_bInterfaceClass; Smart Card Device Class */
> >+ 0x00, /* u8 if_bInterfaceSubClass; Subclass code */
> >+ 0x00, /* u8 if_bInterfaceProtocol; Protocol code */
> >+ 0x04, /* u8 if_iInterface; Index of string descriptor */
> >+
> >+ /* Smart Card Device Class Descriptor */
> >+ 0x36, /* u8 bLength; */
> >+ 0x21, /* u8 bDescriptorType; Functional */
> >+ 0x10, 0x01, /* u16 bcdCCID; CCID Specification Release Number. */
> >+ 0x00, /* u8 bMaxSlotIndex; The index of the highest available
> >+ slot on this device. All slots are consecutive starting
> >+ at 00h. */
> >+ 0x07, /* u8 bVoltageSupport; 01h - 5.0v, 02h - 3.0, 03 - 1.8 */
> >+
> >+ 0x03, 0x00, /* u32 dwProtocols; RRRR PPPP. RRRR = 0000h.*/
> >+ 0x00, 0x00, /* PPPP: 0001h = Protocol T=0, 0002h = Protocol T=1 */
> >+ /* u32 dwDefaultClock; in kHZ (0x0fa0 is 4 MHz) */
> >+ 0xa0, 0x0f, 0x00, 0x00,
> >+ /* u32 dwMaximumClock; */
> >+ 0x00, 0x00, 0x01, 0x00,
> >+ 0x00, /* u8 bNumClockSupported; 0 means just the default and max. */
> >+ /* u32 dwDataRate ;bps. 9600 == 00002580h */
> >+ 0x80, 0x25, 0x00, 0x00,
> >+ /* u32 dwMaxDataRate ; 11520 bps == 0001C200h */
> >+ 0x00, 0xC2, 0x01, 0x00,
> >+ 0x00, /* u8 bNumDataRatesSupported; 00 means all rates between
> >+ * default and max */
> >+ /* u32 dwMaxIFSD; maximum IFSD supported by CCID for protocol
> >+ * T=1 (Maximum seen from various cards) */
> >+ 0xfe, 0x00, 0x00, 0x00,
> >+ /* u32 dwSyncProtocols; 1 - 2-wire, 2 - 3-wire, 4 - I2C */
> >+ 0x00, 0x00, 0x00, 0x00,
> >+ /* u32 dwMechanical; 0 - no special characteristics. */
> >+ 0x00, 0x00, 0x00, 0x00,
> >+ /* u32 dwFeatures;
> >+ * 0 - No special characteristics
> >+ * + 2 Automatic parameter configuration based on ATR data
> >+ * + 4 Automatic activation of ICC on inserting
> >+ * + 8 Automatic ICC voltage selection
> >+ * + 10 Automatic ICC clock frequency change
> >+ * + 20 Automatic baud rate change
> >+ * + 40 Automatic parameters negotiation made by the CCID
> >+ * + 80 automatic PPS made by the CCID
> >+ * 100 CCID can set ICC in clock stop mode
> >+ * 200 NAD value other then 00 accepted (T=1 protocol)
> >+ * + 400 Automatic IFSD exchange as first exchange (T=1)
> >+ * One of the following only:
> >+ * + 10000 TPDU level exchanges with CCID
> >+ * 20000 Short APDU level exchange with CCID
> >+ * 40000 Short and Extended APDU level exchange with CCID
> >+ *
> >+ * + 100000 USB Wake up signaling supported on card insertion
> >+ * and removal. Must set bit 5 in bmAttributes in Configuration
> >+ * descriptor if 100000 is set.*/
> >+ 0xfe, 0x04, 0x11, 0x00,
> >+ /* u32 dwMaxCCIDMessageLength; For extended APDU in [261 + 10
> >+ * , 65544 + 10]. Otherwise the minimum is wMaxPacketSize of
> >+ * the Bulk-OUT endpoint */
> >+ 0x12, 0x00, 0x01, 0x00,
> >+ 0xFF, /* u8 bClassGetResponse; Significant only for CCID that
> >+ * offers an APDU level for exchanges. Indicates the default
> >+ * class value used by the CCID when it sends a Get Response
> >+ * command to perform the transportation of an APDU by T=0
> >+ * protocol
> >+ * FFh indicates that the CCID echos the class of the APDU.
> >+ */
> >+ 0xFF, /* u8 bClassEnvelope; EAPDU only. Envelope command for T=0 */
> >+ 0x00, 0x00, /* u16 wLcdLayout; XXYY Number of lines (XX) and chars per
> >+ * line for LCD display used for PIN entry. 0000 - no LCD */
> >+ 0x01, /* u8 bPINSupport; 01h PIN Verification,
> >+ * 02h PIN Modification */
> >+ 0x01, /* u8 bMaxCCIDBusySlots; */
> >+
> >+ /* Interrupt-IN endpoint */
> >+ 0x07, /* u8 ep_bLength; */
> >+ /* u8 ep_bDescriptorType; Endpoint */
> >+ USB_DT_ENDPOINT,
> >+ /* u8 ep_bEndpointAddress; IN Endpoint 1 */
> >+ 0x80 | CCID_INT_IN_EP,
> >+ 0x03, /* u8 ep_bmAttributes; Interrupt */
> >+ 0x40, 0x00, /* u16 ep_wMaxPacketSize; */
> >+ 0xff, /* u8 ep_bInterval; */
> >+
> >+ /* Bulk-In endpoint */
> >+ 0x07, /* u8 ep_bLength; */
> >+ /* u8 ep_bDescriptorType; Endpoint */
> >+ USB_DT_ENDPOINT,
> >+ /* u8 ep_bEndpointAddress; IN Endpoint 2 */
> >+ 0x80 | CCID_BULK_IN_EP,
> >+ 0x02, /* u8 ep_bmAttributes; Bulk */
> >+ 0x40, 0x00, /* u16 ep_wMaxPacketSize; */
> >+ 0x00, /* u8 ep_bInterval; */
> >+
> >+ /* Bulk-Out endpoint */
> >+ 0x07, /* u8 ep_bLength; */
> >+ /* u8 ep_bDescriptorType; Endpoint */
> >+ USB_DT_ENDPOINT,
> >+ /* u8 ep_bEndpointAddress; OUT Endpoint 3 */
> >+ CCID_BULK_OUT_EP,
> >+ 0x02, /* u8 ep_bmAttributes; Bulk */
> >+ 0x40, 0x00, /* u16 ep_wMaxPacketSize; */
> >+ 0x00, /* u8 ep_bInterval; */
> >+
> >+};
> >+
> >+static bool ccid_has_pending_answers(USBCCIDState *s)
> >+{
> >+ return s->pending_answers_num> 0;
> >+}
> >+
> >+static void ccid_clear_pending_answers(USBCCIDState *s)
> >+{
> >+ s->pending_answers_num = 0;
> >+ s->pending_answers_start = 0;
> >+ s->pending_answers_end = 0;
> >+}
> >+
> >+static void ccid_print_pending_answers(USBCCIDState *s)
> >+{
> >+#ifdef DEBUG_CCID
> >+ Answer *answer;
> >+ int i, count;
> >+
> >+ printf("usb-ccid: pending answers:");
> >+ if (!ccid_has_pending_answers(s)) {
> >+ printf(" empty\n");
> >+ return;
> >+ }
> >+ for (i = s->pending_answers_start, count=s->pending_answers_num ;
> >+ count> 0; count--, i++) {
> >+ answer =&s->pending_answers[i % PENDING_ANSWERS_NUM];
> >+ if (count == 1) {
> >+ printf("%d:%d\n", answer->slot, answer->seq);
> >+ } else {
> >+ printf("%d:%d,", answer->slot, answer->seq);
> >+ }
> >+ }
> >+#endif
>
> It's usually better to use a dprintf() instead of an #if block like
> this. You'll be much more likely to notice when the debug code
> breaks which tends to happen over time.
>
will fix.
> >+}
> >+
> >+static void ccid_add_pending_answer(USBCCIDState *s, CCID_Header *hdr)
> >+{
> >+ Answer* answer;
> >+
> >+ assert(s->pending_answers_num++< PENDING_ANSWERS_NUM);
>
> Having side effects in an assert statement is a very bad idea.
>
yes, will fix.
> >+ answer =&s->pending_answers[(s->pending_answers_end++) % PENDING_ANSWERS_NUM];
> >+ answer->slot = hdr->bSlot;
> >+ answer->seq = hdr->bSeq;
> >+ ccid_print_pending_answers(s);
> >+}
> >+
> >+static void ccid_remove_pending_answer(USBCCIDState *s,
> >+ uint8_t *slot, uint8_t *seq)
> >+{
> >+ Answer *answer;
> >+
> >+ assert(s->pending_answers_num--> 0);
> >+ answer =&s->pending_answers[(s->pending_answers_start++) % PENDING_ANSWERS_NUM];
> >+ *slot = answer->slot;
> >+ *seq = answer->seq;
> >+ ccid_print_pending_answers(s);
> >+}
> >+
> >+static void ccid_bulk_in_clear(USBCCIDState *s)
> >+{
> >+ s->bulk_in_pending_start = 0;
> >+ s->bulk_in_pending_end = 0;
> >+ s->bulk_in_pending_num = 0;
> >+}
> >+
> >+static void ccid_bulk_in_release(USBCCIDState *s)
> >+{
> >+ assert(s->current_bulk_in != NULL);
> >+ s->current_bulk_in->pos = 0;
> >+ s->current_bulk_in = NULL;
> >+}
> >+
> >+static void ccid_bulk_in_get(USBCCIDState *s)
> >+{
> >+ if (s->current_bulk_in != NULL || s->bulk_in_pending_num == 0) {
> >+ return;
> >+ }
> >+ assert(s->bulk_in_pending_num> 0);
> >+ s->bulk_in_pending_num--;
> >+ s->current_bulk_in =&s->bulk_in_pending[
> >+ (s->bulk_in_pending_start++) % BULK_IN_PENDING_NUM];
> >+}
> >+
> >+static void* ccid_reserve_recv_buf(USBCCIDState* s, uint16_t len)
> >+{
> >+ BulkIn* bulk_in;
> >+
> >+ DPRINTF(s, 4, "%s: QUEUE: reserve %d bytes\n", __func__, len);
> >+
> >+ /* look for an existing element */
> >+ if (len> BULK_IN_BUF_SIZE) {
> >+ printf("usb-ccid.c: %s: len larger then max (%d>%d). discarding message.\n",
> >+ __func__, len, BULK_IN_BUF_SIZE);
> >+ return NULL;
> >+ }
> >+ if (s->bulk_in_pending_num>= BULK_IN_PENDING_NUM) {
> >+ printf("usb-ccid.c: %s: No free bulk_in buffers. discarding message.\n",
> >+ __func__);
> >+ return NULL;
> >+ }
>
> Looks like these are guest triggable printfs. You should avoid that.
>
will turn to dprintf.
> >+ bulk_in =&s->bulk_in_pending[(s->bulk_in_pending_end++) % BULK_IN_PENDING_NUM];
> >+ s->bulk_in_pending_num++;
> >+ bulk_in->len = len;
> >+ return bulk_in->data;
> >+}
> >+
> >+static void ccid_reset(USBCCIDState *s)
> >+{
> >+ ccid_bulk_in_clear(s);
> >+ ccid_clear_pending_answers(s);
> >+}
> >+
> >+static void ccid_detach(USBCCIDState *s)
> >+{
> >+ ccid_reset(s);
> >+}
> >+
> >+static void ccid_handle_reset(USBDevice *dev)
> >+{
> >+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
> >+
> >+ DPRINTF(s, 1, "Reset\n");
> >+
> >+ ccid_reset(s);
> >+}
> >+
> >+static int ccid_handle_control(USBDevice *dev, int request, int value,
> >+ int index, int length, uint8_t *data)
> >+{
> >+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
> >+ int ret = 0;
> >+
> >+ DPRINTF(s, 1, "got control %x, value %x\n",request, value);
> >+ switch (request) {
> >+ case DeviceRequest | USB_REQ_GET_STATUS:
> >+ data[0] = (0<< USB_DEVICE_SELF_POWERED) |
> >+ (dev->remote_wakeup<< USB_DEVICE_REMOTE_WAKEUP);
> >+ data[1] = 0x00;
> >+ ret = 2;
> >+ break;
> >+ case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
> >+ if (value == USB_DEVICE_REMOTE_WAKEUP) {
> >+ dev->remote_wakeup = 0;
> >+ } else {
> >+ goto fail;
> >+ }
> >+ ret = 0;
> >+ break;
> >+ case DeviceOutRequest | USB_REQ_SET_FEATURE:
> >+ if (value == USB_DEVICE_REMOTE_WAKEUP) {
> >+ dev->remote_wakeup = 1;
> >+ } else {
> >+ goto fail;
> >+ }
> >+ ret = 0;
> >+ break;
> >+ case DeviceOutRequest | USB_REQ_SET_ADDRESS:
> >+ dev->addr = value;
> >+ ret = 0;
> >+ break;
> >+ case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
> >+ switch(value>> 8) {
> >+ case USB_DT_DEVICE:
> >+ memcpy(data, qemu_ccid_dev_descriptor,
> >+ sizeof(qemu_ccid_dev_descriptor));
> >+ ret = sizeof(qemu_ccid_dev_descriptor);
> >+ break;
> >+ case USB_DT_CONFIG:
> >+ memcpy(data, qemu_ccid_config_descriptor,
> >+ sizeof(qemu_ccid_config_descriptor));
> >+ ret = sizeof(qemu_ccid_config_descriptor);
> >+ break;
> >+ case USB_DT_STRING:
> >+ switch(value& 0xff) {
> >+ case 0:
> >+ /* language ids */
> >+ data[0] = 4;
> >+ data[1] = 3;
> >+ data[2] = 0x09;
> >+ data[3] = 0x04;
> >+ ret = 4;
> >+ break;
> >+ case 1:
> >+ /* vendor description */
> >+ ret = set_usb_string(data, CCID_VENDOR_DESCRIPTION);
> >+ break;
> >+ case 2:
> >+ /* product description */
> >+ ret = set_usb_string(data, CCID_PRODUCT_DESCRIPTION);
> >+ break;
> >+ case 3:
> >+ /* serial number */
> >+ ret = set_usb_string(data, CCID_SERIAL_NUMBER_STRING);
> >+ break;
> >+ case 4:
> >+ /* interface name */
> >+ ret = set_usb_string(data, CCID_INTERFACE_NAME);
> >+ break;
> >+ default:
> >+ goto fail;
> >+ }
> >+ break;
> >+ default:
> >+ goto fail;
> >+ }
> >+ break;
> >+ case DeviceRequest | USB_REQ_GET_CONFIGURATION:
> >+ data[0] = 1;
> >+ ret = 1;
> >+ break;
> >+ case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
> >+ /* Only one configuration - we just ignore the request */
> >+ ret = 0;
> >+ break;
> >+ case DeviceRequest | USB_REQ_GET_INTERFACE:
> >+ data[0] = 0;
> >+ ret = 1;
> >+ break;
> >+ case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
> >+ ret = 0;
> >+ break;
> >+ case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
> >+ ret = 0;
> >+ break;
> >+
> >+ /* Class specific requests. */
> >+ case InterfaceOutClass | CCID_CONTROL_ABORT:
> >+ DPRINTF(s, 1, "ccid_control abort UNIMPLEMENTED\n");
> >+ ret = USB_RET_STALL;
> >+ break;
> >+ case InterfaceInClass | CCID_CONTROL_GET_CLOCK_FREQUENCIES:
> >+ DPRINTF(s, 1, "ccid_control get clock frequencies UNIMPLEMENTED\n");
> >+ ret = USB_RET_STALL;
> >+ break;
> >+ case InterfaceInClass | CCID_CONTROL_GET_DATA_RATES:
> >+ DPRINTF(s, 1, "ccid_control get data rates UNIMPLEMENTED\n");
> >+ ret = USB_RET_STALL;
> >+ break;
> >+ default:
> >+ fail:
> >+ DPRINTF(s, 1, "got unsupported/bogus control %x, value %x\n", request, value);
> >+ ret = USB_RET_STALL;
> >+ break;
> >+ }
> >+ return ret;
> >+}
> >+
> >+static bool ccid_card_inserted(USBCCIDState *s)
> >+{
> >+ return s->bmSlotICCState& SLOT_0_STATE_MASK;
> >+}
> >+
> >+static uint8_t ccid_card_status(USBCCIDState *s)
> >+{
> >+ return ccid_card_inserted(s)
> >+ ? (s->powered ?
> >+ ICC_STATUS_PRESENT_ACTIVE
> >+ : ICC_STATUS_PRESENT_INACTIVE
> >+ )
> >+ : ICC_STATUS_NOT_PRESENT;
> >+}
> >+
> >+static uint8_t ccid_calc_status(USBCCIDState *s)
> >+{
> >+ /* page 55, 6.2.6, calculation of bStatus from bmICCStatus and
> >+ bmCommandStatus
> >+ */
> >+ uint8_t ret = ccid_card_status(s) | (s->bmCommandStatus<< 6);
> >+ DPRINTF(s, 4, "status = %d\n", ret);
> >+ return ret;
> >+}
> >+
> >+static void ccid_reset_error_status(USBCCIDState* s)
> >+{
> >+ s->bError = ERROR_CMD_NOT_SUPPORTED;
> >+ s->bmCommandStatus = COMMAND_STATUS_NO_ERROR;
> >+}
> >+
> >+static void ccid_write_slot_status(USBCCIDState* s, CCID_Header* recv)
> >+{
> >+ CCID_SlotStatus *h = ccid_reserve_recv_buf(s, sizeof(CCID_SlotStatus));
> >+ if (h == NULL) {
> >+ return;
> >+ }
> >+ h->b.hdr.bMessageType = CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus;
> >+ h->b.hdr.dwLength = 0;
> >+ h->b.hdr.bSlot = recv->bSlot;
> >+ h->b.hdr.bSeq = recv->bSeq;
> >+ h->b.bStatus = ccid_calc_status(s);
> >+ h->b.bError = s->bError;
> >+ h->bClockStatus = CLOCK_STATUS_RUNNING;
> >+ ccid_reset_error_status(s);
> >+}
> >+
> >+static void ccid_write_parameters(USBCCIDState* s, CCID_Header* recv)
> >+{
> >+ CCID_Parameter *h;
> >+ uint32_t len = s->ulProtocolDataStructureSize;
> >+
> >+ h = ccid_reserve_recv_buf(s, sizeof(CCID_Parameter) + len);
> >+ if (h == NULL) {
> >+ return;
> >+ }
> >+ h->b.hdr.bMessageType = CCID_MESSAGE_TYPE_RDR_to_PC_Parameters;
> >+ h->b.hdr.dwLength = 0;
> >+ h->b.hdr.bSlot = recv->bSlot;
> >+ h->b.hdr.bSeq = recv->bSeq;
> >+ h->b.bStatus = ccid_calc_status(s);
> >+ h->b.bError = s->bError;
> >+ h->bProtocolNum = s->bProtocolNum;
> >+ memcpy(h->abProtocolDataStructure, s->abProtocolDataStructure, len);
> >+ ccid_reset_error_status(s);
> >+}
> >+
> >+static void ccid_write_data_block(
> >+ USBCCIDState* s, uint8_t slot, uint8_t seq,
> >+ const uint8_t* data, uint32_t len)
> >+{
> >+ CCID_DataBlock *p = ccid_reserve_recv_buf(s, sizeof(*p) + len);
> >+
> >+ if (p == NULL) {
> >+ return;
> >+ }
> >+ p->b.hdr.bMessageType = CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock;
> >+ p->b.hdr.dwLength = cpu_to_le32(len);
> >+ p->b.hdr.bSlot = slot;
> >+ p->b.hdr.bSeq = seq;
> >+ p->b.bStatus = ccid_calc_status(s);
> >+ p->b.bError = s->bError;
> >+#ifdef DEBUG_CCID
> >+ if (p->b.bError) {
> >+ DPRINTF(s, 4, "error %d", p->b.bError);
> >+ }
> >+#endif
> >+ memcpy(p->abData, data, len);
> >+ ccid_reset_error_status(s);
> >+}
> >+
> >+static void ccid_write_data_block_answer(USBCCIDState* s,
> >+ const uint8_t* data, uint32_t len)
> >+{
> >+ uint8_t seq;
> >+ uint8_t slot;
> >+
> >+ if (!ccid_has_pending_answers(s)) {
> >+ abort();
> >+ }
> >+ ccid_remove_pending_answer(s,&slot,&seq);
> >+ ccid_write_data_block(s, slot, seq, data, len);
> >+}
> >+
> >+static void ccid_write_data_block_atr(USBCCIDState* s, CCID_Header* recv)
> >+{
> >+ const uint8_t *atr = NULL;
> >+ uint32_t len = 0;
> >+
> >+ if (s->card) {
> >+ atr = s->cardinfo->get_atr(s->card,&len);
> >+ }
> >+ ccid_write_data_block(s, recv->bSlot, recv->bSeq, atr, len);
> >+}
> >+
> >+static void ccid_set_parameters(USBCCIDState *s, CCID_Header *recv)
> >+{
> >+ CCID_SetParameter *ph = (CCID_SetParameter *) recv;
> >+ uint32_t len = 0;
> >+ if (ph->bProtocolNum == 0) {
> >+ len = 5;
> >+ }
> >+ if (ph->bProtocolNum == 1) {
> >+ len = 7;
> >+ }
> >+ if (len == 0) {
> >+ s->bmCommandStatus = COMMAND_STATUS_FAILED;
> >+ s->bError = 7; /* Protocol invalid or not supported */
> >+ return;
> >+ }
> >+ s->bProtocolNum = ph->bProtocolNum;
> >+ memcpy(s->abProtocolDataStructure, ph->abProtocolDataStructure, len);
> >+ s->ulProtocolDataStructureSize = len;
> >+ DPRINTF(s, 1, "%s: using len %d\n", __func__, len);
> >+}
> >+
> >+/* must be 5 bytes for T=0, 7 bytes for T=1
> >+ * See page 52 */
> >+static const uint8_t abDefaultProtocolDataStructure[7] =
> >+ { 0x77, 0x00, 0x00, 0x00, 0x00, 0xfe /*IFSC*/, 0x00 /*NAD*/ };
> >+
> >+static void ccid_reset_parameters(USBCCIDState *s)
> >+{
> >+ uint32_t len = sizeof(abDefaultProtocolDataStructure);
> >+
> >+ s->bProtocolNum = 1; /* T=1 */
> >+ s->ulProtocolDataStructureSize = len;
> >+ memcpy(s->abProtocolDataStructure, abDefaultProtocolDataStructure, len);
> >+}
> >+
> >+static void ccid_report_error_failed(USBCCIDState *s, uint8_t error)
> >+{
> >+ s->bmCommandStatus = COMMAND_STATUS_FAILED;
> >+ s->bError = error;
> >+}
> >+
> >+/* NOTE: only a single slot is supported (SLOT_0)
> >+ */
> >+static void ccid_on_slot_change(USBCCIDState* s, bool full)
> >+{
> >+ /* RDR_to_PC_NotifySlotChange, 6.3.1 page 56
> >+ */
> >+ uint8_t current = s->bmSlotICCState;
> >+ if (full) {
> >+ s->bmSlotICCState |= SLOT_0_STATE_MASK;
> >+ } else {
> >+ s->bmSlotICCState&= ~SLOT_0_STATE_MASK;
> >+ }
> >+ if (current != s->bmSlotICCState) {
> >+ s->bmSlotICCState |= SLOT_0_CHANGED_MASK;
> >+ }
> >+ s->notify_slot_change = true;
> >+}
> >+
> >+static void ccid_write_data_block_error(
> >+ USBCCIDState *s, uint8_t slot, uint8_t seq)
> >+{
> >+ ccid_write_data_block(s, slot, seq, NULL, 0);
> >+}
> >+
> >+static void ccid_on_apdu_from_guest(USBCCIDState *s, CCID_XferBlock *recv)
> >+{
> >+ uint32_t len;
> >+
> >+ if (ccid_card_status(s) != ICC_STATUS_PRESENT_ACTIVE) {
> >+ DPRINTF(s, 1, "usb-ccid: not sending apdu to client, no card connected\n");
> >+ ccid_write_data_block_error(s, recv->hdr.bSlot, recv->hdr.bSeq);
> >+ return;
> >+ }
> >+ len = le32_to_cpu(recv->hdr.dwLength);
> >+ DPRINTF(s, 1, "%s: seq %d, len %d\n", __FUNCTION__,
> >+ recv->hdr.bSeq, len);
> >+ ccid_add_pending_answer(s, (CCID_Header*)recv);
> >+ if (s->card) {
> >+ s->cardinfo->apdu_from_guest(s->card, recv->abData, len);
> >+ } else {
> >+ printf("warning: discarded apdu\n");
>
> Guest triggerable printf?
>
another dprintf convert.
> >+ }
> >+}
> >+
> >+/* handle a single USB_TOKEN_OUT, return value returned to guest.
> >+ * 0 - all ok
> >+ * USB_RET_STALL - failed to handle packet */
> >+static int ccid_handle_bulk_out(USBCCIDState *s, USBPacket *p)
> >+{
> >+ CCID_Header* ccid_header;
> >+
> >+ if (p->len + s->bulk_out_pos> BULK_OUT_DATA_SIZE) {
> >+ return USB_RET_STALL;
> >+ }
> >+ ccid_header = (CCID_Header*)s->bulk_out_data;
> >+ memcpy(s->bulk_out_data + s->bulk_out_pos, p->data, p->len);
> >+ s->bulk_out_pos += p->len;
> >+ if (p->len == 64) {
> >+ DPRINTF(s, 4, "usb-ccid: bulk_in: expecting more packets (%d/%d)\n",
> >+ p->len, ccid_header->dwLength);
> >+ return 0;
> >+ }
> >+ if (s->bulk_out_pos< 10) {
> >+ DPRINTF(s, 1, "%s: bad USB_TOKEN_OUT length, should be at least 10 bytes\n", __func__);
> >+ } else {
> >+ DPRINTF(s, 3, "%s %x\n", __func__, ccid_header->bMessageType);
> >+ switch (ccid_header->bMessageType) {
> >+ case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus:
> >+ ccid_write_slot_status(s, ccid_header);
> >+ break;
> >+ case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn:
> >+ DPRINTF(s, 1, "PowerOn: %d\n",
> >+ ((CCID_IccPowerOn*)(ccid_header))->bPowerSelect);
> >+ s->powered = true;
> >+ if (!ccid_card_inserted(s)) {
> >+ ccid_report_error_failed(s, ERROR_ICC_MUTE);
> >+ }
> >+ /* atr is written regardless of error. */
> >+ ccid_write_data_block_atr(s, ccid_header);
> >+ break;
> >+ case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff:
> >+ DPRINTF(s, 1, "PowerOff\n");
> >+ ccid_reset_error_status(s);
> >+ s->powered = false;
> >+ ccid_write_slot_status(s, ccid_header);
> >+ break;
> >+ case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock:
> >+ ccid_on_apdu_from_guest(s, (CCID_XferBlock*)s->bulk_out_data);
> >+ break;
> >+ case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters:
> >+ ccid_reset_error_status(s);
> >+ ccid_set_parameters(s, ccid_header);
> >+ ccid_write_parameters(s, ccid_header);
> >+ break;
> >+ case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters:
> >+ ccid_reset_error_status(s);
> >+ ccid_reset_parameters(s);
> >+ ccid_write_parameters(s, ccid_header);
> >+ break;
> >+ case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters:
> >+ ccid_reset_error_status(s);
> >+ ccid_write_parameters(s, ccid_header);
> >+ break;
> >+ default:
> >+ DPRINTF(s, 1, "handle_data: ERROR: unhandled message type %Xh\n",
> >+ ccid_header->bMessageType);
> >+ /* the caller is expecting the device to respond, tell it we
> >+ * do't support the operation */
> >+ ccid_report_error_failed(s, ERROR_CMD_NOT_SUPPORTED);
> >+ ccid_write_slot_status(s, ccid_header);
> >+ break;
> >+ }
> >+ }
> >+ s->bulk_out_pos = 0;
> >+ return 0;
> >+}
> >+
> >+static int ccid_bulk_in_copy_to_guest(USBCCIDState *s, uint8_t *data, int len)
> >+{
> >+ int ret = 0;
> >+
> >+ assert(len>0);
> >+ ccid_bulk_in_get(s);
> >+ if (s->current_bulk_in != NULL) {
> >+ ret = MIN(s->current_bulk_in->len - s->current_bulk_in->pos, len);
> >+ memcpy(data, s->current_bulk_in->data + s->current_bulk_in->pos, ret);
> >+ s->current_bulk_in->pos += ret;
> >+ if (s->current_bulk_in->pos == s->current_bulk_in->len) {
> >+ ccid_bulk_in_release(s);
> >+ }
> >+ } else {
> >+ ret = USB_RET_NAK; /* return when device has no data - usb 2.0 spec Table 8-4 */
> >+ }
> >+ if (ret> 0) {
> >+ DPRINTF(s, 3, "%s: %d/%d req/act to guest (BULK_IN)\n", __func__, len, ret);
> >+ }
> >+ if (ret != USB_RET_NAK&& ret< len) {
> >+ DPRINTF(s, 1, "%s: returning short (EREMOTEIO) %d< %d\n", __func__, ret, len);
> >+ }
> >+ return ret;
> >+}
> >+
> >+static int ccid_handle_data(USBDevice *dev, USBPacket *p)
> >+{
> >+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
> >+ int ret = 0;
> >+ uint8_t *data = p->data;
> >+ int len = p->len;
> >+
> >+ switch (p->pid) {
> >+ case USB_TOKEN_OUT:
> >+ ret = ccid_handle_bulk_out(s, p);
> >+ break;
> >+
> >+ case USB_TOKEN_IN:
> >+ switch (p->devep& 0xf) {
> >+ case CCID_BULK_IN_EP:
> >+ if (!len) {
> >+ ret = USB_RET_NAK;
> >+ } else {
> >+ ret = ccid_bulk_in_copy_to_guest(s, data, len);
> >+ }
> >+ break;
> >+ case CCID_INT_IN_EP:
> >+ if (s->notify_slot_change) {
> >+ /* page 56, RDR_to_PC_NotifySlotChange */
> >+ data[0] = CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange;
> >+ data[1] = s->bmSlotICCState;
> >+ ret = 2;
> >+ s->notify_slot_change = false;
> >+ s->bmSlotICCState&= ~SLOT_0_CHANGED_MASK;
> >+ DPRINTF(s, 2, "handle_data: int_in: notify_slot_change %X, requested len %d\n",
> >+ s->bmSlotICCState, len);
> >+ }
> >+ break;
> >+ default:
> >+ DPRINTF(s, 1, "Bad endpoint\n");
> >+ break;
> >+ }
> >+ break;
> >+ default:
> >+ DPRINTF(s, 1, "Bad token\n");
> >+ ret = USB_RET_STALL;
> >+ break;
> >+ }
> >+
> >+ return ret;
> >+}
> >+
> >+static void ccid_handle_destroy(USBDevice *dev)
> >+{
> >+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
> >+
> >+ ccid_bulk_in_clear(s);
> >+}
> >+
> >+static void ccid_flush_pending_answers(USBCCIDState *s) {
> >+ while (ccid_has_pending_answers(s)) {
> >+ ccid_write_data_block_answer(s, NULL, 0);
> >+ }
> >+}
> >+
> >+static Answer *ccid_peek_next_answer(USBCCIDState *s)
> >+{
> >+ return s->pending_answers_num == 0
> >+ ? NULL
> >+ :&s->pending_answers[s->pending_answers_start % PENDING_ANSWERS_NUM];
> >+}
> >+
> >+static void ccid_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent)
> >+{
> >+ CCIDCardState *card = DO_UPCAST(CCIDCardState, qdev, qdev);
> >+ CCIDCardInfo *info = DO_UPCAST(CCIDCardInfo, qdev, qdev->info);
> >+
> >+ if (info->print) {
> >+ info->print(mon, card, indent);
> >+ }
> >+}
> >+
> >+struct CCIDBus {
> >+ BusState qbus;
> >+};
> >+
> >+static struct BusInfo ccid_bus_info = {
> >+ .name = "ccid-bus",
> >+ .size = sizeof(CCIDBus),
> >+ .print_dev = ccid_bus_dev_print,
> >+ .props = (Property[]) {
> >+ DEFINE_PROP_UINT32("slot", struct CCIDCardState, slot, 0),
> >+ DEFINE_PROP_END_OF_LIST(),
> >+ }
> >+};
> >+
> >+static CCIDBus *ccid_bus_new(DeviceState *dev)
> >+{
> >+ CCIDBus *bus;
> >+
> >+ bus = FROM_QBUS(CCIDBus, qbus_create(&ccid_bus_info, dev, NULL));
> >+ bus->qbus.allow_hotplug = 1;
> >+
> >+ return bus;
> >+}
> >+
> >+void ccid_card_send_apdu_to_guest(CCIDCardState *card, uint8_t* apdu, uint32_t len)
> >+{
> >+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> >+ Answer *answer;
> >+
> >+ if (!ccid_has_pending_answers(s)) {
> >+ DPRINTF(s, 1, "CCID ERROR: got an APDU without pending answers\n");
> >+ return;
> >+ }
> >+ s->bmCommandStatus = COMMAND_STATUS_NO_ERROR;
> >+ answer = ccid_peek_next_answer(s);
> >+ if (answer == NULL) {
> >+ abort();
> >+ }
> >+ DPRINTF(s, 1, "APDU returned to guest %d (answer seq %d, slot %d)\n",
> >+ len, answer->seq, answer->slot);
> >+ ccid_write_data_block_answer(s, apdu, len);
> >+}
> >+
> >+void ccid_card_card_removed(CCIDCardState *card)
> >+{
> >+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> >+
> >+ ccid_on_slot_change(s, false);
> >+ ccid_flush_pending_answers(s);
> >+ ccid_reset(s);
> >+}
> >+
> >+int ccid_card_ccid_attach(CCIDCardState *card)
> >+{
> >+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> >+
> >+ DPRINTF(s, 1, "CCID Attach\n");
> >+ if (s->migration_state == MIGRATION_MIGRATED) {
> >+ s->migration_state = MIGRATION_NONE;
> >+ }
> >+ return 0;
> >+}
> >+
> >+void ccid_card_ccid_detach(CCIDCardState *card)
> >+{
> >+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> >+
> >+ DPRINTF(s, 1, "CCID Detach\n");
> >+ if (ccid_card_inserted(s)) {
> >+ ccid_on_slot_change(s, false);
> >+ }
> >+ ccid_detach(s);
> >+}
> >+
> >+void ccid_card_card_error(CCIDCardState *card, uint64_t error)
> >+{
> >+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> >+
> >+ s->bmCommandStatus = COMMAND_STATUS_FAILED;
> >+ s->last_answer_error = error;
> >+ DPRINTF(s, 1, "VSC_Error: %lX\n", s->last_answer_error);
> >+ /* TODO: these error's should be more verbose and propogated to the guest.
> >+ * */
> >+ ccid_write_data_block_answer(s, NULL, 0);
> >+}
> >+
> >+void ccid_card_card_inserted(CCIDCardState *card)
> >+{
> >+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> >+
> >+ s->bmCommandStatus = COMMAND_STATUS_NO_ERROR;
> >+ ccid_flush_pending_answers(s);
> >+ ccid_on_slot_change(s, true);
> >+}
> >+
> >+static int ccid_card_exit(DeviceState *qdev)
> >+{
> >+ int ret = 0;
> >+ CCIDCardState *card = DO_UPCAST(CCIDCardState, qdev, qdev);
> >+ CCIDCardInfo *info = DO_UPCAST(CCIDCardInfo, qdev, qdev->info);
> >+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> >+
> >+ if (ccid_card_inserted(s)) {
> >+ ccid_card_card_removed(card);
> >+ }
> >+ if (info->exitfn) {
> >+ ret = info->exitfn(card);
> >+ }
> >+ s->card = NULL;
> >+ s->cardinfo = NULL;
> >+ return ret;
> >+}
> >+
> >+static int ccid_card_init(DeviceState *qdev, DeviceInfo *base)
> >+{
> >+ CCIDCardState *card = DO_UPCAST(CCIDCardState, qdev, qdev);
> >+ CCIDCardInfo *info = DO_UPCAST(CCIDCardInfo, qdev, base);
> >+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
> >+ int ret = 0;
> >+
> >+ if (card->slot != 0) {
> >+ fprintf(stderr, "Warning: usb-ccid supports one slot, can't add %d",
> >+ card->slot);
>
> I think error_report is more appropriate here. That makes it
> visible over QMP.
>
will fix.
> >+ return -1;
> >+ }
> >+ if (s->card != NULL) {
> >+ fprintf(stderr, "Warning: usb-ccid card already full, not adding\n");
> >+ return -1;
> >+ }
> >+ ret = info->initfn ? info->initfn(card) : ret;
> >+ if (ret == 0) {
> >+ s->card = card;
> >+ s->cardinfo = info;
> >+ }
> >+ return ret;
> >+}
> >+
> >+void ccid_card_qdev_register(CCIDCardInfo *card)
> >+{
> >+ card->qdev.bus_info =&ccid_bus_info;
> >+ card->qdev.init = ccid_card_init;
> >+ card->qdev.exit = ccid_card_exit;
> >+ qdev_register(&card->qdev);
> >+}
> >+
> >+static int ccid_initfn(USBDevice *dev)
> >+{
> >+ USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
> >+
> >+ s->bus = ccid_bus_new(&dev->qdev);
> >+ s->card = NULL;
> >+ s->cardinfo = NULL;
> >+ s->migration_state = MIGRATION_NONE;
> >+ s->migration_target_ip = 0;
> >+ s->migration_target_port = 0;
> >+ s->dev.speed = USB_SPEED_FULL;
> >+ s->notify_slot_change = false;
> >+ s->powered = true;
> >+ s->pending_answers_num = 0;
> >+ s->last_answer_error = 0;
> >+ s->bulk_in_pending_start = 0;
> >+ s->bulk_in_pending_end = 0;
> >+ s->current_bulk_in = NULL;
> >+ ccid_reset_error_status(s);
> >+ s->bulk_out_pos = 0;
> >+ ccid_reset_parameters(s);
> >+ ccid_reset(s);
> >+ return 0;
> >+}
> >+
> >+#ifdef ENABLE_MIGRATION
>
> Why is migration conditional?
>
I don't remember. Can't think of any good reason, will remove.
> >+static int ccid_post_load(void *opaque, int version_id)
> >+{
> >+ USBCCIDState *s = opaque;
> >+
> >+ // This must be done after usb_device_attach, which sets state to ATTACHED,
> >+ // while it must be DEFAULT in order to accept packets (like it is after
> >+ // reset, but reset will reset our addr and call our reset handler which
> >+ // may change state, and we don't want to do that when migrating).
> >+ s->dev.state = s->state_vmstate;
> >+ return 0;
> >+}
> >+
> >+static void ccid_pre_save(void *opaque)
> >+{
> >+ USBCCIDState *s = opaque;
> >+
> >+ s->state_vmstate = s->dev.state;
> >+ if (s->dev.attached) {
> >+ // migrating an open device, ignore reconnection CHR_EVENT to avoid an
> >+ // erronous detach.
> >+ s->migration_state = MIGRATION_MIGRATED;
> >+ }
> >+}
> >+
> >+static VMStateDescription bulk_in_vmstate = {
> >+ .name = "CCID BulkIn state",
> >+ .version_id = 1,
> >+ .minimum_version_id = 1,
> >+ .fields = (VMStateField []) {
> >+ VMSTATE_BUFFER(data, BulkIn),
> >+ VMSTATE_UINT32(len, BulkIn),
> >+ VMSTATE_UINT32(pos, BulkIn),
> >+ VMSTATE_END_OF_LIST()
> >+ }
> >+};
> >+
> >+static VMStateDescription answer_vmstate = {
> >+ .name = "CCID Answer state",
> >+ .version_id = 1,
> >+ .minimum_version_id = 1,
> >+ .fields = (VMStateField []) {
> >+ VMSTATE_UINT8(slot, Answer),
> >+ VMSTATE_UINT8(seq, Answer),
> >+ VMSTATE_END_OF_LIST()
> >+ }
> >+};
> >+
> >+static VMStateDescription usb_device_vmstate = {
> >+ .name = "usb_device",
> >+ .version_id = 1,
> >+ .minimum_version_id = 1,
> >+ .fields = (VMStateField []) {
> >+ VMSTATE_UINT8(addr, USBDevice),
> >+ VMSTATE_BUFFER(setup_buf, USBDevice),
> >+ VMSTATE_BUFFER(data_buf, USBDevice),
> >+ VMSTATE_END_OF_LIST()
> >+ }
> >+};
> >+
> >+static VMStateDescription ccid_vmstate = {
> >+ .name = CCID_DEV_NAME,
> >+ .version_id = 1,
> >+ .minimum_version_id = 1,
> >+ .post_load = ccid_post_load,
> >+ .pre_save = ccid_pre_save,
> >+ .fields = (VMStateField []) {
> >+ VMSTATE_STRUCT(dev, USBCCIDState, 1, usb_device_vmstate, USBDevice),
> >+ VMSTATE_UINT8(debug, USBCCIDState),
> >+ VMSTATE_BUFFER(bulk_out_data, USBCCIDState),
> >+ VMSTATE_UINT32(bulk_out_pos, USBCCIDState),
> >+ VMSTATE_UINT8(bmSlotICCState, USBCCIDState),
> >+ VMSTATE_UINT8(powered, USBCCIDState),
> >+ VMSTATE_UINT8(notify_slot_change, USBCCIDState),
> >+ VMSTATE_UINT64(last_answer_error, USBCCIDState),
> >+ VMSTATE_UINT8(bError, USBCCIDState),
> >+ VMSTATE_UINT8(bmCommandStatus, USBCCIDState),
> >+ VMSTATE_UINT8(bProtocolNum, USBCCIDState),
> >+ VMSTATE_BUFFER(abProtocolDataStructure, USBCCIDState),
> >+ VMSTATE_UINT32(ulProtocolDataStructureSize, USBCCIDState),
> >+ VMSTATE_STRUCT_ARRAY(bulk_in_pending, USBCCIDState,
> >+ BULK_IN_PENDING_NUM, 1, bulk_in_vmstate, BulkIn),
> >+ VMSTATE_UINT32(bulk_in_pending_start, USBCCIDState),
> >+ VMSTATE_UINT32(bulk_in_pending_end, USBCCIDState),
> >+ VMSTATE_STRUCT_ARRAY(pending_answers, USBCCIDState,
> >+ PENDING_ANSWERS_NUM, 1, answer_vmstate, Answer),
> >+ VMSTATE_UINT32(pending_answers_num, USBCCIDState),
> >+ VMSTATE_UINT8(migration_state, USBCCIDState),
> >+ VMSTATE_UINT32(state_vmstate, USBCCIDState),
> >+ VMSTATE_END_OF_LIST()
> >+ }
> >+};
> >+#endif // ENABLE_MIGRATION
> >+
> >+static struct USBDeviceInfo ccid_info = {
> >+ .product_desc = "QEMU USB CCID",
> >+ .qdev.name = CCID_DEV_NAME,
> >+ .qdev.size = sizeof(USBCCIDState),
> >+ .init = ccid_initfn,
> >+ .handle_packet = usb_generic_handle_packet,
> >+ .handle_reset = ccid_handle_reset,
> >+ .handle_control = ccid_handle_control,
> >+ .handle_data = ccid_handle_data,
> >+ .handle_destroy = ccid_handle_destroy,
> >+ .usbdevice_name = "ccid",
> >+ .qdev.props = (Property[]) {
> >+ DEFINE_PROP_UINT8("debug", USBCCIDState, debug, 0),
> >+ DEFINE_PROP_END_OF_LIST(),
> >+ },
> >+#ifdef ENABLE_MIGRATION
> >+ .qdev.vmsd =&ccid_vmstate,
> >+#endif
> >+};
> >+
> >+
> >+static void ccid_register_devices(void)
> >+{
> >+ usb_qdev_register(&ccid_info);
> >+}
> >+device_init(ccid_register_devices)
>
> Regards,
>
> Anthony Liguori
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2011-01-25 16:11 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2011-01-11 8:38 [Qemu-devel] [PATCH 0/7] usb-ccid (v14) Alon Levy
2011-01-11 8:38 ` [Qemu-devel] [PATCH 1/7] usb-ccid: add CCID bus Alon Levy
2011-01-25 14:10 ` Anthony Liguori
2011-01-25 16:10 ` Alon Levy
2011-01-11 8:58 ` [Qemu-devel] [PATCH 0/7] usb-ccid (v14) Alon Levy
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.