From fc371d0d0e3a60b06dec862e37612375860c41d5 Mon Sep 17 00:00:00 2001 From: Dean Camera Date: Sun, 17 Jun 2018 14:21:45 +1000 Subject: Add CCID class driver and associated demos. --- LUFA/Drivers/USB/Class/CCIDClass.h | 83 +++++++ LUFA/Drivers/USB/Class/Common/CCIDClassCommon.h | 269 ++++++++++++++++++++ LUFA/Drivers/USB/Class/Device/CCIDClassDevice.c | 316 ++++++++++++++++++++++++ LUFA/Drivers/USB/Class/Device/CCIDClassDevice.h | 127 ++++++++++ LUFA/Drivers/USB/USB.h | 1 + 5 files changed, 796 insertions(+) create mode 100644 LUFA/Drivers/USB/Class/CCIDClass.h create mode 100644 LUFA/Drivers/USB/Class/Common/CCIDClassCommon.h create mode 100644 LUFA/Drivers/USB/Class/Device/CCIDClassDevice.c create mode 100644 LUFA/Drivers/USB/Class/Device/CCIDClassDevice.h (limited to 'LUFA/Drivers') diff --git a/LUFA/Drivers/USB/Class/CCIDClass.h b/LUFA/Drivers/USB/Class/CCIDClass.h new file mode 100644 index 000000000..681326f65 --- /dev/null +++ b/LUFA/Drivers/USB/Class/CCIDClass.h @@ -0,0 +1,83 @@ +/* + LUFA Library + Copyright (C) Dean Camera, 2018. + + dean [at] fourwalledcubicle [dot] com + www.lufa-lib.org +*/ + +/* + Copyright 2018 Dean Camera (dean [at] fourwalledcubicle [dot] com) + Copyright 2018 Filipe Rodrigues (filipepazrodrigues [at] gmail [dot] com) + + Permission to use, copy, modify, distribute, and sell this + software and its documentation for any purpose is hereby granted + without fee, provided that the above copyright notice appear in + all copies and that both that the copyright notice and this + permission notice and warranty disclaimer appear in supporting + documentation, and that the name of the author not be used in + advertising or publicity pertaining to distribution of the + software without specific, written prior permission. + + The author disclaims all warranties with regard to this + software, including all implied warranties of merchantability + and fitness. In no event shall the author be liable for any + special, indirect or consequential damages or any damages + whatsoever resulting from loss of use, data or profits, whether + in an action of contract, negligence or other tortious action, + arising out of or in connection with the use or performance of + this software. +*/ + +/** \file + * \brief Master include file for the library USB CCID Class driver. + * + * Master include file for the library USB CCID Class driver, for both host and device modes, where available. + * + * This file should be included in all user projects making use of this optional class driver, instead of + * including any headers in the USB/ClassDriver/Device, USB/ClassDriver/Host or USB/ClassDriver/Common subdirectories. + */ + +/** \ingroup Group_USBClassDrivers + * \defgroup Group_USBClassCCID CCID Class Driver + * \brief USB class driver for the USB-IF CCID class standard. + * + * \section Sec_USBClassCCID_Dependencies Module Source Dependencies + * The following files must be built with any user project that uses this module: + * - LUFA/Drivers/USB/Class/Device/CCIDClassDevice.c (Makefile source module name: LUFA_SRC_USBCLASS) + * - LUFA/Drivers/USB/Class/Host/CCIDClassHost.c (Makefile source module name: LUFA_SRC_USBCLASS) + * + * \section Sec_USBClassCCID_ModDescription Module Description + * CCID Class Driver module. This module contains an internal implementation of the USB CCID Class, for both Device + * and Host USB modes. User applications can use this class driver instead of implementing the CCID class manually + * via the low-level LUFA APIs. + * + * This module is designed to simplify the user code by exposing only the required interface needed to interface with + * Hosts or Devices using the USB CCID Class. + * + * \warning + * LUFA is not a secure USB stack, and has not undergone, not is it expected to pass, any form of security audit. The + * CCID class here is presented as-is and is intended for research purposes only, and *should not* be used in a security + * critical application under any circumstances. + * + * @{ + */ + +#ifndef _CCID_CLASS_H_ +#define _CCID_CLASS_H_ + + /* Macros: */ + #define __INCLUDE_FROM_USB_DRIVER + #define __INCLUDE_FROM_CCID_DRIVER + + /* Includes: */ + #include "../Core/USBMode.h" + + #if defined(USB_CAN_BE_DEVICE) + #include "Device/CCIDClassDevice.h" + #endif + +#endif + +/** @} */ + diff --git a/LUFA/Drivers/USB/Class/Common/CCIDClassCommon.h b/LUFA/Drivers/USB/Class/Common/CCIDClassCommon.h new file mode 100644 index 000000000..61239ec8a --- /dev/null +++ b/LUFA/Drivers/USB/Class/Common/CCIDClassCommon.h @@ -0,0 +1,269 @@ +/* + LUFA Library + Copyright (C) Dean Camera, 2018. + + dean [at] fourwalledcubicle [dot] com + www.lufa-lib.org +*/ + +/* + Copyright 2018 Dean Camera (dean [at] fourwalledcubicle [dot] com) + Copyright 2018 Filipe Rodrigues (filipepazrodrigues [at] gmail [dot] com) + + Permission to use, copy, modify, distribute, and sell this + software and its documentation for any purpose is hereby granted + without fee, provided that the above copyright notice appear in + all copies and that both that the copyright notice and this + permission notice and warranty disclaimer appear in supporting + documentation, and that the name of the author not be used in + advertising or publicity pertaining to distribution of the + software without specific, written prior permission. + + The author disclaims all warranties with regard to this + software, including all implied warranties of merchantability + and fitness. In no event shall the author be liable for any + special, indirect or consequential damages or any damages + whatsoever resulting from loss of use, data or profits, whether + in an action of contract, negligence or other tortious action, + arising out of or in connection with the use or performance of + this software. +*/ + +/** \file + * \brief Common definitions and declarations for the library USB CCID Class driver. + * + * Common definitions and declarations for the library USB CCID Class driver. + * + * \note This file should not be included directly. It is automatically included as needed by the USB module driver + * dispatch header located in LUFA/Drivers/USB.h. + */ + +/** \ingroup Group_USBClassCCID + * \defgroup Group_USBClassCCIDCommon Common Class Definitions + * + * \section Sec_USBClassCCIDCommon_ModDescription Module Description + * Constants, Types and Enum definitions that are common to both Device and Host modes for the USB + * CCID Class. + * + * @{ + */ + +#ifndef _CCID_CLASS_COMMON_H_ +#define _CCID_CLASS_COMMON_H_ + + /* Includes: */ + #include "../../Core/StdDescriptors.h" + + /* Enable C linkage for C++ Compilers: */ + #if defined(__cplusplus) + extern "C" { + #endif + + /* Preprocessor Checks: */ + #if !defined(__INCLUDE_FROM_CCID_DRIVER) + #error Do not include this file directly. Include LUFA/Drivers/USB.h instead. + #endif + + /* Macros: */ + #define CCID_CURRENT_SPEC_RELEASE_NUMBER 0x0110 + #define CCID_VOLTAGESUPPORT_5V 0 + #define CCID_VOLTAGESUPPORT_3V (1 << 0) + #define CCID_VOLTAGESUPPORT_1V8 (1 << 1) + + #define CCID_PROTOCOLS_T0 (1 << 0) + #define CCID_PROTOCOLS_T1 (1 << 1) + + #define CCID_PROTOCOLNUM_T0 0 + #define CCID_PROTOCOLNUM_T1 (1 << 0) + + #define CCID_ICCSTATUS_PRESENTANDACTIVE 0 + #define CCID_ICCSTATUS_PRESENTANDINACTIVE (1 << 0) + #define CCID_ICCSTATUS_NOICCPRESENT (1 << 1) + + #define CCID_COMMANDSTATUS_PROCESSEDWITHOUTERROR 0 + #define CCID_COMMANDSTATUS_FAILED (1 << 6) + #define CCID_COMMANDSTATUS_TIMEEXTENSIONREQUESTED (2 << 6) + #define CCID_COMMANDSTATUS_RFU (3 << 6) + + #define CCID_ERROR_RFU_START 0x80 + #define CCID_ERROR_NO_ERROR 0x80 + #define CCID_ERROR_NOT_SUPPORTED 0 + #define CCID_ERROR_CMD_ABORTED 0xFF + #define CCID_ERROR_CMD_NOT_ABORTED 0xFF + + #define CCID_ERROR_SLOT_NOT_FOUND 5 + + #define CCID_DESCRIPTOR_CLOCK_KHZ(khz) (khz) + #define CCID_DESCRIPTOR_CLOCK_MHZ(mhz) ((mhz) * 1000) + + + /* Enums: */ + /** Enum for possible Class, Subclass and Protocol values of device and interface descriptors relating to the CCID + * device class. + */ + enum CCID_Descriptor_ClassSubclassProtocol_t + { + CCID_CSCP_CCIDClass = 0x0b, /**< Descriptor Class value indicating that the device or interface + * belongs to the CCID class. + */ + CCID_CSCP_NoSpecificSubclass = 0x00, /**< Descriptor Subclass value indicating that the device or interface + * belongs to no specific subclass of the CCID class. + */ + CCID_CSCP_NoSpecificProtocol = 0x00, /**< Descriptor Protocol value indicating that the device or interface + * belongs to no specific protocol of the CCID class. + */ + }; + + /** Enum for possible bulk messages between PC and Reader */ + enum CCID_BulkOutMessages_t + { + CCID_PC_to_RDR_IccPowerOn = 0x62, + CCID_PC_to_RDR_IccPowerOff = 0x63, + CCID_PC_to_RDR_GetSlotStatus = 0x65, + CCID_PC_to_RDR_XfrBlock = 0x6f, + CCID_PC_to_RDR_GetParameters = 0x6c, + CCID_PC_to_RDR_ResetParameters = 0x6d, + CCID_PC_to_RDR_SetParameters = 0x61, + CCID_PC_to_RDR_Escape = 0x6b, + CCID_PC_to_RDR_IccClock = 0x6e, + CCID_PC_to_RDR_T0APDU = 0x6a, + CCID_PC_to_RDR_Secure = 0x69, + CCID_PC_to_RDR_Mechanical = 0x71, + CCID_PC_to_RDR_Abort = 0x72, + CCID_PC_to_RDR_SetDataRateAndClockFrequency = 0x73, + + CCID_RDR_to_PC_DataBlock = 0x80, + CCID_RDR_to_PC_SlotStatus = 0x81, + CCID_RDR_to_PC_Parameters = 0x82, + CCID_RDR_to_PC_Escape = 0x83, + CCID_RDR_to_PC_DataRateAndClockFrequency = 0x84, + }; + + /** Enum for the CCID class specific control requests that can be issued by the USB bus host. */ + enum CCID_ClassRequests_t + { + CCID_ABORT = 0x1, + CCID_GET_CLOCK_FREQUENCIES = 0x2, + CCID_GET_DATA_RATES = 0x3, + }; + + /** Enum for the CCID class specific descriptor types. */ + enum CCID_DescriptorTypes_t + { + CCID_DTYPE_Functional = 0x21, /**< CCID class specific Interface functional descriptor. */ + }; + + /* Type Defines: */ + typedef struct + { + USB_Descriptor_Header_t Header; /**< Regular descriptor header containing the descriptor's type and length. */ + + uint16_t CCID; + uint8_t MaxSlotIndex; + uint8_t VoltageSupport; + uint32_t Protocols; + uint32_t DefaultClock; + uint32_t MaximumClock; + uint8_t NumClockSupported; + uint32_t DataRate; + uint32_t MaxDataRate; + uint8_t NumDataRatesSupported; + uint32_t MaxIFSD; + uint32_t SynchProtocols; + uint32_t Mechanical; + uint32_t Features; + uint32_t MaxCCIDMessageLength; + uint8_t ClassGetResponse; + uint8_t ClassEnvelope; + uint16_t LcdLayout; + uint8_t PINSupport; + uint8_t MaxCCIDBusySlots; + } ATTR_PACKED USB_CCID_Descriptor_t; + + typedef struct + { + uint8_t FindexDindex; + uint8_t TCCKST0; + uint8_t GuardTimeT0; + uint8_t WaitingIntegerT0; + uint8_t ClockStop; + } ATTR_PACKED USB_CCID_ProtocolData_T0_t; + + typedef struct + { + uint8_t FindexDindex; + uint8_t TCCKST1; + uint8_t GuardTimeT1; + uint8_t WaitingIntegerT1; + uint8_t ClockStop; + uint8_t FSC; + uint8_t NadValue; + } ATTR_PACKED USB_CCID_ProtocolData_T1_t; + + + /** Enum for a common bulk message header. */ + typedef struct + { + uint8_t MessageType; + uint32_t Length; + uint8_t Slot; + uint8_t Seq; + } ATTR_PACKED USB_CCID_BulkMessage_Header_t; + + typedef struct + { + USB_CCID_BulkMessage_Header_t CCIDHeader; + uint8_t Status; + uint8_t Error; + uint8_t ChainParam; + uint8_t Data[0]; + } ATTR_PACKED USB_CCID_RDR_to_PC_DataBlock_t; + + typedef struct + { + USB_CCID_BulkMessage_Header_t CCIDHeader; + uint8_t Status; + uint8_t Error; + uint8_t ClockStatus; + } ATTR_PACKED USB_CCID_RDR_to_PC_SlotStatus_t; + + typedef struct + { + USB_CCID_BulkMessage_Header_t CCIDHeader; + uint8_t Status; + uint8_t Error; + uint8_t ProtocolNum; + union { + USB_CCID_ProtocolData_T0_t T0; + USB_CCID_ProtocolData_T1_t T1; + } ProtocolData; + } ATTR_PACKED USB_CCID_RDR_to_PC_Parameters_t; + + typedef struct + { + USB_CCID_BulkMessage_Header_t CCIDHeader; + uint8_t Status; + uint8_t Error; + uint8_t RFU; + uint8_t Data[0]; + } ATTR_PACKED USB_CCID_RDR_to_PC_Escape_t; + + typedef struct + { + USB_CCID_BulkMessage_Header_t CCIDHeader; + uint8_t Status; + uint8_t Error; + uint8_t RFU; + uint32_t ClockFrequency; + uint32_t DataRate; + } ATTR_PACKED USB_CCID_RDR_to_PC_DataRateAndClockFrequency_t; + + /* Disable C linkage for C++ Compilers: */ + #if defined(__cplusplus) + } + #endif + +#endif + +/** @} */ + diff --git a/LUFA/Drivers/USB/Class/Device/CCIDClassDevice.c b/LUFA/Drivers/USB/Class/Device/CCIDClassDevice.c new file mode 100644 index 000000000..edc125779 --- /dev/null +++ b/LUFA/Drivers/USB/Class/Device/CCIDClassDevice.c @@ -0,0 +1,316 @@ +/* + LUFA Library + Copyright (C) Dean Camera, 2018. + + dean [at] fourwalledcubicle [dot] com + www.lufa-lib.org +*/ + +/* + Copyright 2018 Dean Camera (dean [at] fourwalledcubicle [dot] com) + Copyright 2018 Filipe Rodrigues (filipepazrodrigues [at] gmail [dot] com) + + Permission to use, copy, modify, distribute, and sell this + software and its documentation for any purpose is hereby granted + without fee, provided that the above copyright notice appear in + all copies and that both that the copyright notice and this + permission notice and warranty disclaimer appear in supporting + documentation, and that the name of the author not be used in + advertising or publicity pertaining to distribution of the + software without specific, written prior permission. + + The author disclaims all warranties with regard to this + software, including all implied warranties of merchantability + and fitness. In no event shall the author be liable for any + special, indirect or consequential damages or any damages + whatsoever resulting from loss of use, data or profits, whether + in an action of contract, negligence or other tortious action, + arising out of or in connection with the use or performance of + this software. +*/ + +#define __INCLUDE_FROM_USB_DRIVER +#include "../../Core/USBMode.h" + +#if defined(USB_CAN_BE_DEVICE) + +#define __INCLUDE_FROM_CCID_DRIVER +#define __INCLUDE_FROM_CCID_DEVICE_C +#include "CCIDClassDevice.h" + + +bool CCID_CheckStatusNoError(int status) +{ + return (status & 0xC0) == 0x0; +} + +void CCID_Device_ProcessControlRequest(USB_ClassInfo_CCID_Device_t* const CCIDInterfaceInfo) +{ + if (!(Endpoint_IsSETUPReceived())) + return; + + if (USB_ControlRequest.wIndex != CCIDInterfaceInfo->Config.InterfaceNumber) + return; + + switch (USB_ControlRequest.bRequest) + { + case CCID_ABORT: + { + // Initiates the abort process. + // The host should send 2 messages in the following order: + // - CCID_ABORT control request + // - CCID_PC_t_PCo_RDR_Abort command + // + // If the device is still processing a message, it should fail it until receiving a CCIRPC_to_RDR_Abort + // command. + // + // When the device receives the CCIRPC_to_RDR_Abort message, it replies with RDR_to_PC_SlotStatus + // and the abort process ends. + + // The wValue field contains the slot number (bSlot) in the low byte and the sequence number (bSeq) in + // the high byte + uint8_t Slot = USB_ControlRequest.wValue & 0xFF; + uint8_t Seq = USB_ControlRequest.wValue >> 8; + + if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE) && Slot == 0) + { + Endpoint_ClearSETUP(); + + CCIDInterfaceInfo->State.Aborted = true; + CCIDInterfaceInfo->State.AbortedSeq = Seq; + + Endpoint_ClearOUT(); + } + + break; + } + case CCID_GET_CLOCK_FREQUENCIES: + { + if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)) + { + + Endpoint_ClearSETUP(); + Endpoint_Write_8(0); // Not supported + Endpoint_ClearOUT(); + } + break; + } + case CCID_GET_DATA_RATES: + { + if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)) + { + + Endpoint_ClearSETUP(); + Endpoint_Write_8(0); // Not supported + Endpoint_ClearOUT(); + } + break; + } + } +} + +bool CCID_Device_ConfigureEndpoints(USB_ClassInfo_CCID_Device_t* const CCIDInterfaceInfo) +{ + CCIDInterfaceInfo->Config.DataINEndpoint.Type = EP_TYPE_BULK; + CCIDInterfaceInfo->Config.DataOUTEndpoint.Type = EP_TYPE_BULK; + + if (!(Endpoint_ConfigureEndpointTable(&CCIDInterfaceInfo->Config.DataINEndpoint, 1))) + return false; + + if (!(Endpoint_ConfigureEndpointTable(&CCIDInterfaceInfo->Config.DataOUTEndpoint, 1))) + return false; + + return true; +} + +void CCID_Device_USBTask(USB_ClassInfo_CCID_Device_t* const CCIDInterfaceInfo) +{ + Endpoint_SelectEndpoint(CCIDInterfaceInfo->Config.DataOUTEndpoint.Address); + + uint8_t BlockBuffer[0x20]; + CCIDInterfaceInfo->State.Aborted = false; + CCIDInterfaceInfo->State.AbortedSeq = -1; + + if (Endpoint_IsOUTReceived()) + { + USB_CCID_BulkMessage_Header_t CCIDHeader; + CCIDHeader.MessageType = Endpoint_Read_8(); + CCIDHeader.Length = Endpoint_Read_32_LE(); + CCIDHeader.Slot = Endpoint_Read_8(); + CCIDHeader.Seq = Endpoint_Read_8(); + + uint8_t Status; + uint8_t Error = CCID_ERROR_NO_ERROR; + + switch (CCIDHeader.MessageType) + { + case CCID_PC_to_RDR_IccPowerOn: + { + uint8_t AtrLength; + USB_CCID_RDR_to_PC_DataBlock_t* ResponseATR = (USB_CCID_RDR_to_PC_DataBlock_t*)&BlockBuffer; + + ResponseATR->CCIDHeader.MessageType = CCID_RDR_to_PC_DataBlock; + ResponseATR->CCIDHeader.Slot = CCIDHeader.Slot; + ResponseATR->CCIDHeader.Seq = CCIDHeader.Seq; + ResponseATR->ChainParam = 0; + + Status = CALLBACK_CCID_IccPowerOn(ResponseATR->CCIDHeader.Slot, (uint8_t*)ResponseATR->Data, &AtrLength, &Error); + + if (CCID_CheckStatusNoError(Status) && !CCIDInterfaceInfo->State.Aborted) + { + ResponseATR->CCIDHeader.Length = AtrLength; + } + else if (CCIDInterfaceInfo->State.Aborted) + { + Status = CCID_COMMANDSTATUS_FAILED | CCID_ICCSTATUS_PRESENTANDACTIVE; + Error = CCID_ERROR_CMD_ABORTED; + AtrLength = 0; + } + else + { + AtrLength = 0; + } + + ResponseATR->Status = Status; + ResponseATR->Error = Error; + + Endpoint_ClearOUT(); + + Endpoint_SelectEndpoint(CCIDInterfaceInfo->Config.DataINEndpoint.Address); + Endpoint_Write_Stream_LE(ResponseATR, sizeof(USB_CCID_RDR_to_PC_DataBlock_t) + AtrLength, NULL); + Endpoint_ClearIN(); + break; + } + + case CCID_PC_to_RDR_IccPowerOff: + { + USB_CCID_RDR_to_PC_SlotStatus_t* ResponsePowerOff = (USB_CCID_RDR_to_PC_SlotStatus_t*)&BlockBuffer; + ResponsePowerOff->CCIDHeader.MessageType = CCID_RDR_to_PC_SlotStatus; + ResponsePowerOff->CCIDHeader.Length = 0; + ResponsePowerOff->CCIDHeader.Slot = CCIDHeader.Slot; + ResponsePowerOff->CCIDHeader.Seq = CCIDHeader.Seq; + + ResponsePowerOff->ClockStatus = 0; + + Status = CALLBACK_CCID_IccPowerOff(CCIDHeader.Slot, &Error); + + ResponsePowerOff->Status = Status; + ResponsePowerOff->Error = Error; + + Endpoint_ClearOUT(); + + Endpoint_SelectEndpoint(CCIDInterfaceInfo->Config.DataINEndpoint.Address); + Endpoint_Write_Stream_LE(ResponsePowerOff, sizeof(USB_CCID_RDR_to_PC_SlotStatus_t), NULL); + Endpoint_ClearIN(); + break; + } + + case CCID_PC_to_RDR_GetSlotStatus: + { + USB_CCID_RDR_to_PC_SlotStatus_t* ResponseSlotStatus = (USB_CCID_RDR_to_PC_SlotStatus_t*)&BlockBuffer; + ResponseSlotStatus->CCIDHeader.MessageType = CCID_RDR_to_PC_SlotStatus; + ResponseSlotStatus->CCIDHeader.Length = 0; + ResponseSlotStatus->CCIDHeader.Slot = CCIDHeader.Slot; + ResponseSlotStatus->CCIDHeader.Seq = CCIDHeader.Seq; + + ResponseSlotStatus->ClockStatus = 0; + + Status = CALLBACK_CCID_GetSlotStatus(CCIDHeader.Slot, &Error); + + ResponseSlotStatus->Status = Status; + ResponseSlotStatus->Error = Error; + + Endpoint_ClearOUT(); + + Endpoint_SelectEndpoint(CCIDInterfaceInfo->Config.DataINEndpoint.Address); + Endpoint_Write_Stream_LE(ResponseSlotStatus, sizeof(USB_CCID_RDR_to_PC_SlotStatus_t), NULL); + Endpoint_ClearIN(); + break; + } + + case CCID_PC_to_RDR_XfrBlock: + { + uint8_t Bwi = Endpoint_Read_8(); + uint16_t LevelParameter = Endpoint_Read_16_LE(); + uint8_t ReceivedBuffer[0x4]; + + (void)Bwi; + (void)LevelParameter; + + Endpoint_Read_Stream_LE(ReceivedBuffer, sizeof(ReceivedBuffer), NULL); + + uint8_t SendBuffer[0x2] = {0x90, 0x00}; + uint8_t SendLength = sizeof(SendBuffer); + + USB_CCID_RDR_to_PC_DataBlock_t* ResponseBlock = (USB_CCID_RDR_to_PC_DataBlock_t*)&BlockBuffer; + ResponseBlock->CCIDHeader.MessageType = CCID_RDR_to_PC_DataBlock; + ResponseBlock->CCIDHeader.Slot = CCIDHeader.Slot; + ResponseBlock->CCIDHeader.Seq = CCIDHeader.Seq; + + ResponseBlock->ChainParam = 0; + + //TODO: Callback + Status = CCID_COMMANDSTATUS_PROCESSEDWITHOUTERROR | CCID_ICCSTATUS_PRESENTANDACTIVE; + + if (CCID_CheckStatusNoError(Status) && !CCIDInterfaceInfo->State.Aborted) + { + ResponseBlock->CCIDHeader.Length = SendLength; + memcpy(&ResponseBlock->Data, SendBuffer, SendLength); + } + else if(CCIDInterfaceInfo->State.Aborted) + { + Status = CCID_COMMANDSTATUS_FAILED | CCID_ICCSTATUS_PRESENTANDACTIVE; + Error = CCID_ERROR_CMD_ABORTED; + SendLength = 0; + } + else + { + SendLength = 0; + } + + ResponseBlock->Status = Status; + ResponseBlock->Error = Error; + + Endpoint_ClearOUT(); + + Endpoint_SelectEndpoint(CCIDInterfaceInfo->Config.DataINEndpoint.Address); + Endpoint_Write_Stream_LE(ResponseBlock, sizeof(USB_CCID_RDR_to_PC_DataBlock_t) + SendLength, NULL); + Endpoint_ClearIN(); + break; + } + + case CCID_PC_to_RDR_Abort: + { + USB_CCID_RDR_to_PC_SlotStatus_t* ResponseAbort = (USB_CCID_RDR_to_PC_SlotStatus_t*)&BlockBuffer; + ResponseAbort->CCIDHeader.MessageType = CCID_RDR_to_PC_SlotStatus; + ResponseAbort->CCIDHeader.Length = 0; + ResponseAbort->CCIDHeader.Slot = CCIDHeader.Slot; + ResponseAbort->CCIDHeader.Seq = CCIDHeader.Seq; + + ResponseAbort->ClockStatus = 0; + + Status = CALLBACK_CCID_Abort(CCIDHeader.Slot, CCIDHeader.Seq, &Error); + + ResponseAbort->Status = Status; + ResponseAbort->Error = Error; + + Endpoint_ClearOUT(); + + Endpoint_SelectEndpoint(CCIDInterfaceInfo->Config.DataINEndpoint.Address); + Endpoint_Write_Stream_LE(ResponseAbort, sizeof(USB_CCID_RDR_to_PC_SlotStatus_t), NULL); + Endpoint_ClearIN(); + break; + } + default: + { + memset(BlockBuffer, 0x00, sizeof(BlockBuffer)); + + Endpoint_SelectEndpoint(CCIDInterfaceInfo->Config.DataINEndpoint.Address); + Endpoint_Write_Stream_LE(BlockBuffer, sizeof(BlockBuffer), NULL); + Endpoint_ClearIN(); + } + } + } +} + +#endif diff --git a/LUFA/Drivers/USB/Class/Device/CCIDClassDevice.h b/LUFA/Drivers/USB/Class/Device/CCIDClassDevice.h new file mode 100644 index 000000000..29a79f02d --- /dev/null +++ b/LUFA/Drivers/USB/Class/Device/CCIDClassDevice.h @@ -0,0 +1,127 @@ +/* + LUFA Library + Copyright (C) Dean Camera, 2018. + + dean [at] fourwalledcubicle [dot] com + www.lufa-lib.org +*/ + +/* + Copyright 2018 Dean Camera (dean [at] fourwalledcubicle [dot] com) + Copyright 2018 Filipe Rodrigues (filipepazrodrigues [at] gmail [dot] com) + + Permission to use, copy, modify, distribute, and sell this + software and its documentation for any purpose is hereby granted + without fee, provided that the above copyright notice appear in + all copies and that both that the copyright notice and this + permission notice and warranty disclaimer appear in supporting + documentation, and that the name of the author not be used in + advertising or publicity pertaining to distribution of the + software without specific, written prior permission. + + The author disclaims all warranties with regard to this + software, including all implied warranties of merchantability + and fitness. In no event shall the author be liable for any + special, indirect or consequential damages or any damages + whatsoever resulting from loss of use, data or profits, whether + in an action of contract, negligence or other tortious action, + arising out of or in connection with the use or performance of + this software. +*/ + +/** \file + * \brief Device mode driver for the library USB CCID Class driver. + * + * Device mode driver for the library USB CCID Class driver. + * + * \note This file should not be included directly. It is automatically included as needed by the USB module driver + * dispatch header located in LUFA/Drivers/USB.h. + */ + +/** \ingroup Group_USBClassCCID + * \defgroup Group_USBClassCCIDDevice CCID Class Device Mode Driver + * + * \section Sec_USBClassCCIDDevice_Dependencies Module Source Dependencies + * The following files must be built with any user project that uses this module: + * - LUFA/Drivers/USB/Class/Device/CCIDClassDevice.c (Makefile source module name: LUFA_SRC_USBCLASS) + * + * \section Sec_USBClassCCIDDevice_ModDescription Module Description + * Device Mode USB Class driver framework interface, for the CCID USB Class driver. + * + * @{ + */ + +#ifndef _CCID_CLASS_DEVICE_H_ +#define _CCID_CLASS_DEVICE_H_ + + /* Includes: */ + #include "../../USB.h" + #include "../Common/CCIDClassCommon.h" + + /* Public Interface - May be used in end-application: */ + /* Type Defines: */ + /** \brief CCID Class Device Mode Configuration and State Structure. + * + * Class state structure. An instance of this structure should be made for each CCID interface + * within the user application, and passed to each of the CCID class driver functions as the + * CCIDInterfaceInfo parameter. This stores each CCID interface's configuration and state information. + */ + typedef struct + { + struct + { + uint8_t InterfaceNumber; /**< Interface number of the CCID interface within the device. */ + uint8_t TotalSlots; /**< Total of slots no this device. */ + USB_Endpoint_Table_t DataINEndpoint; /**< Data IN endpoint configuration table. */ + USB_Endpoint_Table_t DataOUTEndpoint; /**< Data OUT endpoint configuration table. */ + } Config; /**< Config data for the USB class interface within the device. All elements in this section + * must be set or the interface will fail to enumerate and operate correctly. + */ + struct + { + bool Aborted; //< Set if host has started an abort process + uint8_t AbortedSeq; //< Sequence number for the current abort process + } State; /**< State data for the USB class interface within the device. All elements in this section + * are reset to their defaults when the interface is enumerated. + */ + } USB_ClassInfo_CCID_Device_t; + + /* Function Prototypes: */ + /** Configures the endpoints of a given CCID interface, ready for use. This should be linked to the library + * \ref EVENT_USB_Device_ConfigurationChanged() event so that the endpoints are configured when the configuration containing + * the given CCID interface is selected. + * + * \param[in,out] CCIDInterfaceInfo Pointer to a structure containing a CCID Class configuration. + * + * \return Boolean \c true if the endpoints were successfully configured, \c false otherwise. + */ + bool CCID_Device_ConfigureEndpoints(USB_ClassInfo_CCID_Device_t* const CCIDInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1); + + /** Processes incoming control requests from the host, that are directed to the given CCID class interface. This should be + * linked to the library \ref EVENT_USB_Device_ControlRequest() event. + * + * \param[in,out] CCIDInterfaceInfo Pointer to a structure containing a CCID Class configuration and state. + */ + void CCID_Device_ProcessControlRequest(USB_ClassInfo_CCID_Device_t* const CCIDInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1); + + /** General management task for a given CCID class interface, required for the correct operation of the interface. This should + * be called frequently in the main program loop, before the master USB management task \ref USB_USBTask(). + * + * \param[in,out] CCIDInterfaceInfo Pointer to a structure containing a CCID Class configuration and state. + */ + void CCID_Device_USBTask(USB_ClassInfo_CCID_Device_t* const CCIDInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1); + + uint8_t CALLBACK_CCID_IccPowerOn(uint8_t slot, uint8_t* atr, uint8_t* atrSize, uint8_t* error); + + uint8_t CALLBACK_CCID_IccPowerOff(uint8_t slot, uint8_t* error); + + uint8_t CALLBACK_CCID_GetSlotStatus(uint8_t slot, uint8_t* error); + + uint8_t CALLBACK_CCID_XfrBlock(uint8_t slot, uint8_t* error, uint8_t* receivedBuffer, uint8_t receivedBufferSize, uint8_t* sendBuffer, uint8_t* sentBufferSize); + + uint8_t CALLBACK_CCID_Abort(uint8_t slot, uint8_t seq, uint8_t* error); + + +#endif + +/** @} */ diff --git a/LUFA/Drivers/USB/USB.h b/LUFA/Drivers/USB/USB.h index afb823e13..1a3b283f3 100644 --- a/LUFA/Drivers/USB/USB.h +++ b/LUFA/Drivers/USB/USB.h @@ -410,6 +410,7 @@ #include "Class/AndroidAccessoryClass.h" #include "Class/AudioClass.h" + #include "Class/CCIDClass.h" #include "Class/CDCClass.h" #include "Class/HIDClass.h" #include "Class/MassStorageClass.h" -- cgit v1.2.3