summaryrefslogtreecommitdiff
path: root/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib
diff options
context:
space:
mode:
Diffstat (limited to 'bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib')
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_core.c322
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_core.h74
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_funct.c124
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_funct.h23
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_core.c293
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_core.h72
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_keybd.c159
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_keybd.h27
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_mouse.c46
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_mouse.h24
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_bot.c323
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_bot.h51
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_core.c287
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_core.h66
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_scsi.c366
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_scsi.h24
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp.c1366
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp.h153
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp_ptp.c376
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp_ptp.h758
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_core.c664
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_core.h150
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_stdreq.c202
-rw-r--r--bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_stdreq.h18
24 files changed, 5968 insertions, 0 deletions
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_core.c b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_core.c
new file mode 100644
index 0000000000..fe9249111c
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_core.c
@@ -0,0 +1,322 @@
+/******************************************************************************************************************************************
+* 文件名称: usbh_cdc_core.c
+* 功能说明:
+* 技术支持: http://www.synwit.com.cn/e/tool/gbook/?bid=1
+* 注意事项:
+* 版本日期: V1.1.0 2020年11月3日
+* 升级记录:
+*
+*
+*******************************************************************************************************************************************
+* @attention
+*
+* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS WITH CODING INFORMATION
+* REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. AS A RESULT, SYNWIT SHALL NOT BE HELD LIABLE
+* FOR ANY DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+* OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION CONTAINED HEREIN IN CONN-
+* -ECTION WITH THEIR PRODUCTS.
+*
+* COPYRIGHT 2012 Synwit Technology
+*******************************************************************************************************************************************/
+#include <stdlib.h>
+#include <string.h>
+#include "SWM341.h"
+#include "usbh_core.h"
+#include "usbh_stdreq.h"
+#include "usbh_cdc_core.h"
+#include "usbh_cdc_funct.h"
+
+
+USBH_Class_cb_t USBH_CDC_cb =
+{
+ USBH_CDC_Init,
+ USBH_CDC_DeInit,
+ USBH_CDC_Request,
+ USBH_CDC_Process
+};
+
+
+volatile USBH_CDC_Info_t USBH_CDC_Info;
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_CDC_Init()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_CDC_Init(USBH_Info_t *phost)
+{
+ USB_EpDesc_t *pEpIn, *pEpOut, *pEpCtrl;
+
+ if((phost->Device.Dev_Desc.bDeviceClass == USB_CDC_CLASS) &&
+ (phost->Device.Intf_Desc[0].bInterfaceClass == USB_CDC_CTRL_CLASS) &&
+ (phost->Device.Intf_Desc[1].bInterfaceClass == USB_CDC_DATA_CLASS))
+ {
+ pEpCtrl = &phost->Device.Ep_Desc[0][0];
+
+ if(phost->Device.Ep_Desc[1][0].bEndpointAddress & USB_EP_IN)
+ {
+ pEpIn = &phost->Device.Ep_Desc[1][0];
+ pEpOut = &phost->Device.Ep_Desc[1][1];
+ }
+ else
+ {
+ pEpIn = &phost->Device.Ep_Desc[1][1];
+ pEpOut = &phost->Device.Ep_Desc[1][0];
+ }
+
+ USBH_CDC_Info.InEp = pEpIn->bEndpointAddress;
+ USBH_CDC_Info.InEpSize = pEpIn->wMaxPacketSize;
+ USBH_CDC_Info.OutEp = pEpOut->bEndpointAddress;
+ USBH_CDC_Info.OutEpSize = pEpOut->wMaxPacketSize;
+ USBH_CDC_Info.CtrlEp = pEpCtrl->bEndpointAddress;
+ USBH_CDC_Info.CtrlEpSize = pEpCtrl->wMaxPacketSize;
+
+ USBH_CDC_DeInit(phost);
+ }
+ else
+ {
+ if(phost->usr_cb->DeviceNotSupported)
+ phost->usr_cb->DeviceNotSupported();
+
+ return USBH_NOT_SUPPORTED;
+ }
+
+ return USBH_OK;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_CDC_DeInit()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void USBH_CDC_DeInit(USBH_Info_t *phost)
+{
+ USBH_CDC_Info.InEpDATAX = 0;
+ USBH_CDC_Info.OutEpDATAX = 0;
+ USBH_CDC_Info.CtrlEpDATAX = 0;
+
+ USBH_CDC_Info.TxWrPtr = 0;
+ USBH_CDC_Info.TxRdPtr = 0;
+ USBH_CDC_Info.RxWrPtr = 0;
+ USBH_CDC_Info.RxRdPtr = 0;
+
+ USBH_CDC_Info.state = USBH_CDC_SEND;
+ USBH_CDC_Info.reqState = CDC_GET_LINE_CODING;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_CDC_Request()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_CDC_Request(USBH_Info_t *phost)
+{
+ USBH_Status status = USBH_BUSY;
+ USBH_Status reqStatus;
+
+ switch(USBH_CDC_Info.reqState)
+ {
+ case CDC_SET_LINE_CODING:
+ reqStatus = USBH_CDC_SetLineCoding(phost);
+ if(reqStatus == USBH_OK)
+ {
+ USBH_CDC_Info.reqState = CDC_GET_LINE_CODING ;
+ }
+ if(reqStatus == USBH_NOT_SUPPORTED)
+ {
+ USBH_CDC_Info.reqState = CDC_CLR_STALL;
+ }
+ break;
+
+ case CDC_GET_LINE_CODING:
+ reqStatus = USBH_CDC_GetLineCoding(phost);
+ if(reqStatus == USBH_OK)
+ {
+ USBH_CDC_Info.reqState = CDC_SET_CONTROL_LINE;
+ }
+ break;
+
+ case CDC_SET_CONTROL_LINE:
+ reqStatus = USBH_CDC_SetControlLine(phost);
+ if(reqStatus == USBH_OK)
+ {
+ status = USBH_OK;
+ }
+ break;
+
+ case CDC_CLR_STALL:
+ reqStatus = USBH_ClrFeature(phost, 0);
+ if(reqStatus == USBH_OK )
+ {
+ phost->Ctrl.toggle_out = 0;
+
+ USBH_CDC_Info.reqState = CDC_GET_LINE_CODING ;
+ }
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_CDC_Process()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_CDC_Process(USBH_Info_t *phost)
+{
+ static uint32_t FrameNbr = 0;
+ static uint32_t size;
+ uint32_t available, space;
+ USBH_Status status = USBH_OK;
+ USBH_Resp resp;
+
+ switch(USBH_CDC_Info.state)
+ {
+ case USBH_CDC_SEND:
+ available = USBH_CDC_Info.TxWrPtr - USBH_CDC_Info.TxRdPtr;
+ if((available >= USBH_CDC_Info.OutEpSize) || ((available > 0) && (abs((int)USBH->FRAMENR - (int)USBH_CDC_Info.TxFrameNbr) > 10)))
+ {
+ USBH_CDC_Info.TxFrameNbr = USBH->FRAMENR;
+
+ size = (available > USBH_CDC_Info.OutEpSize) ? USBH_CDC_Info.OutEpSize : available;
+
+ if(USBH_SendOutPacket(phost->Device.Address, USBH_CDC_Info.OutEp, USBH_CDC_Info.OutEpDATAX, (uint8_t *)&USBH_CDC_Info.TxBuff[USBH_CDC_Info.TxRdPtr], size))
+ {
+ USBH_CDC_Info.state = USBH_CDC_SEND_WAIT;
+ }
+ }
+ else
+ {
+ USBH_CDC_Info.state = USBH_CDC_READ;
+ }
+ break;
+
+ case USBH_CDC_SEND_WAIT:
+ resp = USBH_State();
+ if(resp != USBR_NO)
+ {
+ if(resp == USBR_ACK)
+ {
+ USBH_CDC_Info.OutEpDATAX ^= 1;
+
+ USBH_CDC_Info.TxRdPtr += size;
+ if(USBH_CDC_Info.TxRdPtr == USBH_CDC_Info.TxWrPtr) // USBH_CDC_Info.TxBuff 中数据已全部发出
+ {
+ USBH_CDC_Info.TxRdPtr = 0;
+ USBH_CDC_Info.TxWrPtr = 0;
+ }
+ }
+
+ USBH_CDC_Info.state = USBH_CDC_READ;
+ }
+ break;
+
+ case USBH_CDC_READ:
+ space = USBH_CDC_BUFF_SIZE - USBH_CDC_Info.RxWrPtr;
+ if((space >= USBH_CDC_Info.InEpSize) && (abs((int)USBH->FRAMENR - (int)USBH_CDC_Info.TxFrameNbr) > 10))
+ {
+ USBH_CDC_Info.RxFrameNbr = USBH->FRAMENR;
+
+ if(USBH_SendInPacket(phost->Device.Address, USBH_CDC_Info.InEp, USBH_CDC_Info.InEpDATAX, USBH_CDC_Info.InEpSize))
+ {
+ USBH_CDC_Info.state = USBH_CDC_READ_WAIT;
+ }
+ }
+ break;
+
+ case USBH_CDC_READ_WAIT:
+ resp = USBH_State();
+ if(resp != USBR_NO)
+ {
+ if(resp == USBR_ACK)
+ {
+ USBH_CDC_Info.InEpDATAX ^= 1;
+
+ size = USBH_ReadRxBuffer((uint8_t *)&USBH_CDC_Info.RxBuff[USBH_CDC_Info.RxWrPtr], USBH_CDC_Info.InEpSize);
+ USBH_CDC_Info.RxWrPtr += size;
+ }
+
+ USBH_CDC_Info.state = USBH_CDC_SEND;
+ }
+ break;
+
+ case USBH_CDC_CTRL:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_CDC_Process()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+uint32_t USBH_CDC_Send(uint8_t *data, uint16_t size)
+{
+ uint16_t space = USBH_CDC_BUFF_SIZE - USBH_CDC_Info.TxWrPtr; // 可写入数据个数
+
+ if(space >= size)
+ {
+ __disable_irq();
+
+ memcpy((uint8_t *)&USBH_CDC_Info.TxBuff[USBH_CDC_Info.TxWrPtr], data, size);
+ USBH_CDC_Info.TxWrPtr += size;
+
+ __enable_irq();
+
+ return size;
+ }
+
+ return 0;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_CDC_Process()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+uint32_t USBH_CDC_Read(uint8_t *buff, uint16_t size)
+{
+ uint16_t available = USBH_CDC_Info.RxWrPtr - USBH_CDC_Info.RxRdPtr;
+
+ if(size > available)
+ size = available;
+
+ if(size)
+ {
+ __disable_irq();
+
+ memcpy(buff, (uint8_t *)&USBH_CDC_Info.RxBuff[USBH_CDC_Info.RxRdPtr], size);
+
+ USBH_CDC_Info.RxRdPtr += size;
+ if(USBH_CDC_Info.RxRdPtr == USBH_CDC_Info.RxWrPtr) // USBH_CDC_Info.RxBuff 中数据已全部读出
+ {
+ USBH_CDC_Info.RxRdPtr = 0;
+ USBH_CDC_Info.RxWrPtr = 0;
+ }
+
+ __enable_irq();
+ }
+
+ return size;
+}
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_core.h b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_core.h
new file mode 100644
index 0000000000..f92e30cf97
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_core.h
@@ -0,0 +1,74 @@
+#ifndef __USBH_CDC_CORE_H__
+#define __USBH_CDC_CORE_H__
+
+#include <stdint.h>
+
+
+typedef enum {
+ USBH_CDC_SEND = 0,
+ USBH_CDC_SEND_WAIT,
+ USBH_CDC_READ,
+ USBH_CDC_READ_WAIT,
+ USBH_CDC_CTRL
+} USBH_CDC_State;
+
+
+typedef enum {
+ CDC_SET_LINE_CODING = 0x20,
+ CDC_GET_LINE_CODING,
+ CDC_SET_CONTROL_LINE,
+ CDC_CLR_STALL,
+} USBH_CDC_ReqState;
+
+
+typedef struct {
+ void (*Send)(uint8_t *);
+ void (*Receive)(uint8_t *);
+} USBH_CDC_cb_t;
+
+
+typedef struct {
+ uint8_t InEp;
+ uint8_t OutEp;
+ uint16_t InEpSize;
+ uint16_t OutEpSize;
+ uint8_t InEpDATAX;
+ uint8_t OutEpDATAX;
+
+ uint8_t CtrlEp;
+ uint16_t CtrlEpSize;
+ uint8_t CtrlEpDATAX;
+
+ USBH_CDC_State state;
+ USBH_CDC_State stateBkp;
+ USBH_CDC_ReqState reqState;
+
+ uint8_t TxBuff[USBH_CDC_BUFF_SIZE];
+ uint8_t RxBuff[USBH_CDC_BUFF_SIZE];
+ uint16_t TxWrPtr, TxRdPtr;
+ uint16_t RxWrPtr, RxRdPtr;
+ uint16_t TxFrameNbr; // Frame Number
+ uint16_t RxFrameNbr;
+
+ USBH_CDC_cb_t *cdc_cb;
+} USBH_CDC_Info_t;
+
+
+extern volatile USBH_CDC_Info_t USBH_CDC_Info;
+
+
+
+extern USBH_Class_cb_t USBH_CDC_cb;
+
+
+USBH_Status USBH_CDC_Init(USBH_Info_t *phost);
+void USBH_CDC_DeInit(USBH_Info_t *phost);
+USBH_Status USBH_CDC_Request(USBH_Info_t *phost);
+USBH_Status USBH_CDC_Process(USBH_Info_t *phost);
+
+
+uint32_t USBH_CDC_Send(uint8_t *data, uint16_t size);
+uint32_t USBH_CDC_Read(uint8_t *buff, uint16_t size);
+
+
+#endif // __USBH_CDC_CORE_H__
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_funct.c b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_funct.c
new file mode 100644
index 0000000000..1c4903c733
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_funct.c
@@ -0,0 +1,124 @@
+/******************************************************************************************************************************************
+* 文件名称: usbh_cdc_funct.c
+* 功能说明:
+* 技术支持: http://www.synwit.com.cn/e/tool/gbook/?bid=1
+* 注意事项:
+* 版本日期: V1.1.0 2020年11月3日
+* 升级记录:
+*
+*
+*******************************************************************************************************************************************
+* @attention
+*
+* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS WITH CODING INFORMATION
+* REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. AS A RESULT, SYNWIT SHALL NOT BE HELD LIABLE
+* FOR ANY DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+* OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION CONTAINED HEREIN IN CONN-
+* -ECTION WITH THEIR PRODUCTS.
+*
+* COPYRIGHT 2012 Synwit Technology
+*******************************************************************************************************************************************/
+#include "SWM341.h"
+#include "usbh_core.h"
+#include "usbh_cdc_core.h"
+#include "usbh_cdc_funct.h"
+
+
+/* wValue for SetControlLineState */
+#define CDC_RTS_ACTIVATE 0x0002
+#define CDC_RTS_DEACTIVATE 0x0000
+#define CDC_DTR_ACTIVATE 0x0001
+#define CDC_DTR_DEACTIVATE 0x0000
+
+
+CDC_LineCoding_t CDC_GetLineCode;
+CDC_LineCoding_t CDC_SetLineCode;
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_CDC_GetLineCoding()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_CDC_GetLineCoding(USBH_Info_t *phost)
+{
+ phost->Ctrl.setup.bRequestType = USB_REQ_D2H | USB_REQ_CLASS | USB_REQ_TO_INTERFACE;
+ phost->Ctrl.setup.bRequest = CDC_GET_LINE_CODING;
+ phost->Ctrl.setup.wValue = 0;
+ phost->Ctrl.setup.wIndex = 0;
+ phost->Ctrl.setup.wLength = sizeof(CDC_LineCoding_t);
+
+ return USBH_CtrlTransfer(phost, (uint8_t *)&CDC_GetLineCode, sizeof(CDC_LineCoding_t));
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_CDC_SetLineCoding()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_CDC_SetLineCoding(USBH_Info_t *phost)
+{
+ phost->Ctrl.setup.bRequestType = USB_REQ_H2D | USB_REQ_CLASS | USB_REQ_TO_INTERFACE;
+ phost->Ctrl.setup.bRequest = CDC_SET_LINE_CODING;
+ phost->Ctrl.setup.wValue = 0;
+ phost->Ctrl.setup.wIndex = 0;
+ phost->Ctrl.setup.wLength = sizeof(CDC_LineCoding_t);
+
+ return USBH_CtrlTransfer(phost, (uint8_t *)&CDC_SetLineCode , sizeof(CDC_LineCoding_t));
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_CDC_SetControlLine()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_CDC_SetControlLine(USBH_Info_t *phost)
+{
+ phost->Ctrl.setup.bRequestType = USB_REQ_H2D | USB_REQ_CLASS | USB_REQ_TO_INTERFACE;
+ phost->Ctrl.setup.bRequest = CDC_SET_CONTROL_LINE;
+ phost->Ctrl.setup.wValue = CDC_RTS_DEACTIVATE | CDC_DTR_DEACTIVATE;
+ phost->Ctrl.setup.wIndex = 0;
+ phost->Ctrl.setup.wLength = 0;
+
+ return USBH_CtrlTransfer(phost, 0 , 0);
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_CDC_IssueSetLineCoding()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void USBH_CDC_IssueSetLineCoding(USBH_Info_t *phost)
+{
+ USBH_CDC_Info.reqState = CDC_SET_LINE_CODING;
+
+ phost->StateBkp = phost->State;
+ phost->State = HOST_CLASS_REQUEST;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_CDC_IssueGetLineCoding()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void USBH_CDC_IssueGetLineCoding(USBH_Info_t *phost)
+{
+ USBH_CDC_Info.reqState = CDC_GET_LINE_CODING;
+
+ phost->StateBkp = phost->State;
+ phost->State = HOST_CLASS_REQUEST;
+}
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_funct.h b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_funct.h
new file mode 100644
index 0000000000..a7b4ed7a6c
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/CDC/usbh_cdc_funct.h
@@ -0,0 +1,23 @@
+#ifndef __USBH_CDC_FUNCT_H__
+#define __USBH_CDC_FUNCT_H__
+
+#include <stdint.h>
+
+
+typedef struct __attribute__((packed)) {
+ uint32_t dwDTERate; // Data terminal rate, in bits per second
+ uint8_t bCharFormat; // Stop bits, 0 - 1 Stop bit, 1 - 1.5 Stop bits, 2 - 2 Stop bits
+ uint8_t bParityType; // Parity, 0 - None, 1 - Odd, 2 - Even, 3 - Mark, 4 - Space
+ uint8_t bDataBits; // Data bits (5, 6, 7, 8 or 16)
+} CDC_LineCoding_t;
+
+
+
+USBH_Status USBH_CDC_GetLineCoding(USBH_Info_t *phost);
+USBH_Status USBH_CDC_SetLineCoding(USBH_Info_t *phost);
+USBH_Status USBH_CDC_SetControlLine(USBH_Info_t *phost);
+void USBH_CDC_IssueSetLineCoding(USBH_Info_t *phost);
+void USBH_CDC_IssueGetLineCoding(USBH_Info_t *phost);
+
+
+#endif // __USBH_CDC_FUNCT_H__
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_core.c b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_core.c
new file mode 100644
index 0000000000..585aac8a99
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_core.c
@@ -0,0 +1,293 @@
+/******************************************************************************************************************************************
+* 文件名称: usbh_hid_core.c
+* 功能说明:
+* 技术支持: http://www.synwit.com.cn/e/tool/gbook/?bid=1
+* 注意事项:
+* 版本日期: V1.1.0 2020年11月3日
+* 升级记录:
+*
+*
+*******************************************************************************************************************************************
+* @attention
+*
+* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS WITH CODING INFORMATION
+* REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. AS A RESULT, SYNWIT SHALL NOT BE HELD LIABLE
+* FOR ANY DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+* OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION CONTAINED HEREIN IN CONN-
+* -ECTION WITH THEIR PRODUCTS.
+*
+* COPYRIGHT 2012 Synwit Technology
+*******************************************************************************************************************************************/
+#include "SWM341.h"
+#include "usbh_hid_core.h"
+#include "usbh_hid_keybd.h"
+#include "usbh_hid_mouse.h"
+
+
+USBH_Class_cb_t USBH_HID_cb =
+{
+ USBH_HID_Init,
+ USBH_HID_DeInit,
+ USBH_HID_Request,
+ USBH_HID_Process,
+};
+
+
+volatile USBH_HID_Info_t USBH_HID_Info;
+
+
+static uint8_t DataInBuffer[64];
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_HID_Init()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_HID_Init(USBH_Info_t *phost)
+{
+ USB_EpDesc_t *pEpIn, *pEpOut;
+
+ if(phost->Device.Intf_Desc[0].bInterfaceClass == USB_HID_CLASS)
+ {
+ if(phost->Device.Intf_Desc[0].bInterfaceProtocol == USB_HID_KEYBD)
+ {
+ USBH_HID_Info.hid_cb = &USBH_HID_KeyBD_cb;
+ }
+ else if(phost->Device.Intf_Desc[0].bInterfaceProtocol == USB_HID_MOUSE)
+ {
+ USBH_HID_Info.hid_cb = &USBH_HID_Mouse_cb;
+ }
+
+ if(phost->Device.Ep_Desc[0][0].bEndpointAddress & USB_EP_IN)
+ {
+ pEpIn = &phost->Device.Ep_Desc[0][0];
+ pEpOut = &phost->Device.Ep_Desc[0][1];
+ }
+ else
+ {
+ pEpIn = &phost->Device.Ep_Desc[0][1];
+ pEpOut = &phost->Device.Ep_Desc[0][0];
+ }
+
+ USBH_HID_Info.InEp = pEpIn->bEndpointAddress;
+ USBH_HID_Info.InEpSize = pEpIn->wMaxPacketSize;
+ USBH_HID_Info.InEpInterval = pEpIn->bInterval;
+ USBH_HID_Info.OutEp = pEpOut->bEndpointAddress;
+ USBH_HID_Info.OutEpSize = pEpOut->wMaxPacketSize;
+ USBH_HID_Info.OutEpInterval = pEpOut->bInterval;
+
+ USBH_HID_DeInit(phost);
+ }
+ else
+ {
+ if(phost->usr_cb->DeviceNotSupported)
+ phost->usr_cb->DeviceNotSupported();
+ }
+
+ return USBH_OK;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_HID_DeInit()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void USBH_HID_DeInit(USBH_Info_t *phost)
+{
+ USBH_HID_Info.InEpDATAX = 0;
+ USBH_HID_Info.InEpFrameNbr = 0;
+ USBH_HID_Info.OutEpDATAX = 0;
+ USBH_HID_Info.OutEpFrameNbr = 0;
+
+ USBH_HID_Info.state = USBH_HID_IDLE;
+ USBH_HID_Info.reqState = USBH_HID_REQ_GET_REPORT_DESC;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_HID_Request()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_HID_Request(USBH_Info_t *phost)
+{
+ USBH_Status status = USBH_BUSY;
+ USBH_Status reqStatus = USBH_BUSY;
+
+ switch(USBH_HID_Info.reqState)
+ {
+ case USBH_HID_REQ_GET_REPORT_DESC:
+ reqStatus = USBH_GetDescriptorEx(phost, USB_REQ_STANDARD, USB_REQ_TO_INTERFACE, USB_DESC_HID_RPT, 0, 0, phost->Device.HIDReport_Desc[0], phost->Device.HID_Desc[0].wItemLength);
+ if(reqStatus == USBH_OK)
+ {
+ USBH_HID_Info.reqState = USBH_HID_REQ_SET_IDLE;
+ }
+ break;
+
+ case USBH_HID_REQ_SET_IDLE:
+ reqStatus = USBH_Set_Idle(phost, 0, 0, 0);
+ if(reqStatus == USBH_OK)
+ {
+ status = USBH_OK;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_HID_Process()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_HID_Process(USBH_Info_t *phost)
+{
+ USBH_Status status = USBH_OK;
+ USBH_Resp resp;
+
+ switch(USBH_HID_Info.state)
+ {
+ case USBH_HID_IDLE:
+ USBH_HID_Info.hid_cb->Init();
+ USBH_HID_Info.state = USBH_HID_SYNC;
+
+ USBH->IF = USBH_IF_SOF_Msk;
+ break;
+
+ case USBH_HID_SYNC:
+ if(USBH->IF & USBH_IF_SOF_Msk)
+ {
+ USBH_HID_Info.state = USBH_HID_READ;
+ }
+ break;
+
+ case USBH_HID_READ:
+ if((USBH->FRAMENR + 65536 - USBH_HID_Info.InEpFrameNbr) % 65536 >= USBH_HID_Info.InEpInterval)
+ {
+ if(USBH_SendInPacket(phost->Device.Address, USBH_HID_Info.InEp, USBH_HID_Info.InEpDATAX, USBH_HID_Info.InEpSize))
+ {
+ USBH_HID_Info.InEpFrameNbr = USBH->FRAMENR;
+
+ USBH_HID_Info.state = USBH_HID_READ_WAIT;
+ }
+ }
+ break;
+
+ case USBH_HID_READ_WAIT:
+ resp = USBH_State();
+ if(resp == USBR_ACK)
+ {
+ USBH_HID_Info.InEpDATAX ^= 1;
+
+ USBH_ReadRxBuffer(DataInBuffer, USBH_HID_Info.InEpSize);
+ USBH_HID_Info.hid_cb->Decode(DataInBuffer);
+
+ USBH_HID_Info.state = USBH_HID_READ;
+ }
+ else if(resp == USBR_NAK)
+ {
+ USBH_HID_Info.state = USBH_HID_READ;
+ }
+ else if(resp == USBR_STALL)
+ {
+ USBH_HID_Info.state = USBH_HID_STALL_IN;
+ }
+ else if(resp == USBR_ERROR)
+ {
+ USBH_HID_Info.state = USBH_HID_READ;
+ }
+ break;
+
+ case USBH_HID_STALL_IN:
+ status = USBH_ClrFeature(phost, USBH_HID_Info.InEp);
+ if(status == USBH_OK)
+ {
+ USBH_HID_Info.InEpDATAX = 0;
+
+ USBH_HID_Info.state = USBH_HID_READ;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_Set_Idle()
+* 功能说明:
+* 输 入: uint8_t interface
+* uint8_t reportID Targeted report ID for Set Idle request
+* uint8_t duration Duration for HID Idle request, 单位 4ms
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_Set_Idle(USBH_Info_t *phost, uint8_t interface, uint8_t reportId, uint8_t duration)
+{
+ phost->Ctrl.setup.bRequestType = USB_REQ_H2D | USB_REQ_CLASS | USB_REQ_TO_INTERFACE;
+ phost->Ctrl.setup.bRequest = USB_HID_SET_IDLE;
+ phost->Ctrl.setup.wValue = (duration << 8 ) | reportId;
+ phost->Ctrl.setup.wIndex = interface;
+ phost->Ctrl.setup.wLength = 0;
+
+ return USBH_CtrlTransfer(phost, 0, 0);
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_Set_Report()
+* 功能说明:
+* 输 入: uint8_t interface
+* uint8_t reportId Targeted report ID for Set Report request
+* uint8_t reportType 1 Input,2 Output,3 Feature
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_Set_Report(USBH_Info_t *phost, uint8_t interface, uint8_t reportId, uint8_t reportType, uint8_t * reportData, uint16_t reportLen)
+{
+ phost->Ctrl.setup.bRequestType = USB_REQ_H2D | USB_REQ_CLASS | USB_REQ_TO_INTERFACE;
+ phost->Ctrl.setup.bRequest = USB_HID_SET_REPORT;
+ phost->Ctrl.setup.wValue = (reportType << 8 ) | reportId;
+ phost->Ctrl.setup.wIndex = interface;
+ phost->Ctrl.setup.wLength = reportLen;
+
+ return USBH_CtrlTransfer(phost, reportData, reportLen);
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_Set_Protocol()
+* 功能说明:
+* 输 入: uint8_t interface
+* uint8_t protocol 0 = Boot Protocol, 1 = Report Protocol
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_Set_Protocol(USBH_Info_t *phost, uint8_t interface, uint8_t protocol)
+{
+ phost->Ctrl.setup.bRequestType = USB_REQ_H2D | USB_REQ_CLASS | USB_REQ_TO_INTERFACE;
+ phost->Ctrl.setup.bRequest = USB_HID_SET_PROTOCOL;
+ phost->Ctrl.setup.wValue = protocol;
+ phost->Ctrl.setup.wIndex = interface;
+ phost->Ctrl.setup.wLength = 0;
+
+ return USBH_CtrlTransfer(phost, 0, 0);
+}
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_core.h b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_core.h
new file mode 100644
index 0000000000..9447fd7c5a
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_core.h
@@ -0,0 +1,72 @@
+#ifndef __USBH_HID_CORE_H__
+#define __USBH_HID_CORE_H__
+
+#include "usbh_core.h"
+#include "usbh_stdreq.h"
+
+
+typedef enum {
+ USBH_HID_IDLE = 0,
+ USBH_HID_SYNC,
+ USBH_HID_READ,
+ USBH_HID_READ_WAIT,
+ USBH_HID_SEND,
+ USBH_HID_SEND_WAIT,
+ USBH_HID_ERROR,
+ USBH_HID_STALL_IN,
+ USBH_HID_STALL_OUT
+} USBH_HID_State;
+
+
+typedef enum {
+ USBH_HID_REQ_IDLE = 0,
+ USBH_HID_REQ_GET_REPORT_DESC,
+ USBH_HID_REQ_SET_IDLE,
+ USBH_HID_REQ_SET_PROTOCOL,
+ USBH_HID_REQ_SET_REPORT,
+} USBH_HID_ReqState;
+
+
+typedef struct {
+ void (*Init)(void);
+ void (*Decode)(uint8_t *data);
+} USBH_HID_cb_t;
+
+
+typedef struct {
+ uint8_t InEp;
+ uint8_t OutEp;
+ uint16_t InEpSize;
+ uint16_t OutEpSize;
+ uint8_t InEpDATAX;
+ uint8_t OutEpDATAX;
+
+ uint8_t InEpInterval;
+ uint16_t InEpFrameNbr;
+ uint8_t OutEpInterval;
+ uint16_t OutEpFrameNbr;
+
+ USBH_HID_State state;
+ USBH_HID_State stateBkp;
+ USBH_HID_ReqState reqState;
+
+ USBH_HID_cb_t *hid_cb;
+} USBH_HID_Info_t;
+
+
+extern volatile USBH_HID_Info_t USBH_HID_Info;
+
+extern USBH_Class_cb_t USBH_HID_cb;
+
+USBH_Status USBH_HID_Init(USBH_Info_t *phost);
+void USBH_HID_DeInit(USBH_Info_t *phost);
+USBH_Status USBH_HID_Request(USBH_Info_t *phost);
+USBH_Status USBH_HID_Process(USBH_Info_t *phost);
+
+
+USBH_Status USBH_Set_Idle(USBH_Info_t *phost, uint8_t interface, uint8_t reportId, uint8_t duration);
+USBH_Status USBH_Set_Report(USBH_Info_t *phost, uint8_t interface, uint8_t reportId, uint8_t reportType, uint8_t * reportData, uint16_t reportLen);
+USBH_Status USBH_Set_Protocol(USBH_Info_t *phost, uint8_t interface, uint8_t protocol);
+
+
+#endif // __USBH_HID_CORE_H__
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_keybd.c b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_keybd.c
new file mode 100644
index 0000000000..7e817b1757
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_keybd.c
@@ -0,0 +1,159 @@
+/******************************************************************************************************************************************
+* 文件名称: usbh_hid_keybd.c
+* 功能说明:
+* 技术支持: http://www.synwit.com.cn/e/tool/gbook/?bid=1
+* 注意事项:
+* 版本日期: V1.1.0 2020年11月3日
+* 升级记录:
+*
+*
+*******************************************************************************************************************************************
+* @attention
+*
+* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS WITH CODING INFORMATION
+* REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. AS A RESULT, SYNWIT SHALL NOT BE HELD LIABLE
+* FOR ANY DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+* OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION CONTAINED HEREIN IN CONN-
+* -ECTION WITH THEIR PRODUCTS.
+*
+* COPYRIGHT 2012 Synwit Technology
+*******************************************************************************************************************************************/
+#include <string.h>
+#include "SWM341.h"
+#include "usbh_hid_core.h"
+#include "usbh_hid_keybd.h"
+
+
+USBH_HID_cb_t USBH_HID_KeyBD_cb =
+{
+ USBH_HID_KeyBD_Init,
+ USBH_HID_KeyBD_Decode
+};
+
+
+static const uint8_t HID_KEYBRD_Codes[] = {
+ 0, 0, 0, 0, 31, 50, 48, 33, 19, 34, 35, 36, 24, 37, 38, 39,
+ 52, 51, 25, 26, 17, 20, 32, 21, 23, 49, 18, 47, 22, 46, 2, 3,
+ 4, 5, 6, 7, 8, 9, 10, 11, 43, 110, 15, 16, 61, 12, 13, 27,
+ 28, 29, 42, 40, 41, 1, 53, 54, 55, 30, 112, 113, 114, 115, 116, 117,
+ 118, 119, 120, 121, 122, 123, 124, 125, 126, 75, 80, 85, 76, 81, 86, 89,
+ 79, 84, 83, 90, 95, 100, 105, 106, 108, 93, 98, 103, 92, 97, 102, 91,
+ 96, 101, 99, 104, 45, 129, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 107, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 58, 44, 60, 127, 64, 57, 62, 128,
+};
+
+static const uint8_t HID_KEYBRD_Key[] = {
+ '\0', '`', '1', '2', '3', '4', '5', '6', '7', '8',
+ '9', '0', '-', '=', '\0', '\r', '\t', 'q', 'w', 'e',
+ 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\\',
+ '\0', 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l',
+ ';', '\'', '\0', '\n', '\0', '\0', 'z', 'x', 'c', 'v',
+ 'b', 'n', 'm', ',', '.', '/', '\0', '\0', '\0', '\0',
+ '\0', ' ', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+ '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+ '\r', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+ '\0', '7', '4', '1', '\0', '/', '8', '5', '2', '0',
+ '*', '9', '6', '3', '.', '-', '+', '\0', '\n', '\0',
+ '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+ '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'
+};
+
+static const uint8_t HID_KEYBRD_ShiftKey[] = {
+ '\0', '~', '!', '@', '#', '$', '%', '^', '&', '*',
+ '(', ')', '_', '+', '\0', '\0', '\0', 'Q', 'W', 'E',
+ 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '{', '}', '|',
+ '\0', 'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L',
+ ':', '"', '\0', '\n', '\0', '\0', 'Z', 'X', 'C', 'V',
+ 'B', 'N', 'M', '<', '>', '?', '\0', '\0', '\0', '\0',
+ '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+ '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+ '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+ '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+ '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+ '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+ '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'
+};
+
+
+static uint8_t keys_last[6];
+static uint8_t nbr_keys_last;
+
+
+void USBH_HID_KeyBD_Init(void)
+{
+ nbr_keys_last = 0;
+ memset(keys_last, 0x00, 6);
+}
+
+
+void USBH_HID_KeyBD_Decode(uint8_t *pbuf)
+{
+ char key;
+ uint8_t i, j;
+ uint8_t keys[6];
+ uint8_t keys_new[6];
+ uint8_t nbr_keys;
+ uint8_t nbr_keys_new;
+
+ for(i = 2; i < 8; i++)
+ {
+ if((pbuf[i] == 0x01) || (pbuf[i] == 0x02) || (pbuf[i] == 0x03))
+ return;
+ }
+
+ nbr_keys = 0;
+ nbr_keys_new = 0;
+ for(i = 2; i < 8; i++)
+ {
+ if(pbuf[i] != 0x00)
+ {
+ keys[nbr_keys++] = pbuf[i];
+
+ for(j = 0; j < nbr_keys_last; j++)
+ {
+ if(pbuf[i] == keys_last[j])
+ break;
+ }
+
+ if(j == nbr_keys_last) // 遍历到了最后,说明 pbuf[i] 不在 keys_last 中,是新按下的
+ keys_new[nbr_keys_new++] = pbuf[i];
+ }
+ }
+
+ if(nbr_keys_new == 1)
+ {
+ if((pbuf[0] & KBD_LEFT_SHIFT) || (pbuf[0] & KBD_RIGHT_SHIFT))
+ {
+ key = HID_KEYBRD_ShiftKey[HID_KEYBRD_Codes[keys_new[0]]];
+ }
+ else
+ {
+ key = HID_KEYBRD_Key[HID_KEYBRD_Codes[keys_new[0]]];
+ }
+
+ USBH_HID_KeyBD_Handle(pbuf[0], key); // call user process handle
+ }
+
+ memcpy(keys_last, keys, 6);
+ nbr_keys_last = nbr_keys;
+}
+
+
+__attribute__((weak))
+void USBH_HID_KeyBD_Handle(uint8_t ctrl, char key)
+{
+ if((ctrl & KBD_LEFT_CTRL) | (ctrl & KBD_RIGHT_CTRL))
+ printf("Ctrl-");
+
+ if((ctrl & KBD_LEFT_ALT) | (ctrl & KBD_RIGHT_ALT))
+ printf("Alt-");
+
+ printf("%c\r\n", key);
+}
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_keybd.h b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_keybd.h
new file mode 100644
index 0000000000..df37b0de57
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_keybd.h
@@ -0,0 +1,27 @@
+#ifndef __USBH_HID_KEYBD_H__
+#define __USBH_HID_KEYBD_H__
+
+#include <stdint.h>
+
+
+#define KBD_LEFT_CTRL 0x01
+#define KBD_LEFT_SHIFT 0x02
+#define KBD_LEFT_ALT 0x04
+#define KBD_LEFT_CMD 0x08
+#define KBD_RIGHT_CTRL 0x10
+#define KBD_RIGHT_SHIFT 0x20
+#define KBD_RIGHT_ALT 0x40
+#define KBD_RIGHT_CMD 0x80
+
+
+extern USBH_HID_cb_t USBH_HID_KeyBD_cb;
+
+
+void USBH_HID_KeyBD_Init(void);
+void USBH_HID_KeyBD_Decode(uint8_t *pbuf);
+
+__attribute__((weak))
+void USBH_HID_KeyBD_Handle(uint8_t ctrl, char key);
+
+
+#endif // __USBH_HID_KEYBD_H__
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_mouse.c b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_mouse.c
new file mode 100644
index 0000000000..6551ad42af
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_mouse.c
@@ -0,0 +1,46 @@
+/******************************************************************************************************************************************
+* 文件名称: usbh_hid_mouse.c
+* 功能说明:
+* 技术支持: http://www.synwit.com.cn/e/tool/gbook/?bid=1
+* 注意事项:
+* 版本日期: V1.1.0 2020年11月3日
+* 升级记录:
+*
+*
+*******************************************************************************************************************************************
+* @attention
+*
+* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS WITH CODING INFORMATION
+* REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. AS A RESULT, SYNWIT SHALL NOT BE HELD LIABLE
+* FOR ANY DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+* OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION CONTAINED HEREIN IN CONN-
+* -ECTION WITH THEIR PRODUCTS.
+*
+* COPYRIGHT 2012 Synwit Technology
+*******************************************************************************************************************************************/
+#include "SWM341.h"
+#include "usbh_hid_core.h"
+#include "usbh_hid_mouse.h"
+
+
+USBH_HID_cb_t USBH_HID_Mouse_cb =
+{
+ USBH_HID_Mouse_Init,
+ USBH_HID_Mouse_Decode,
+};
+
+
+USBH_HID_Mouse_Data_t USBH_HID_Mouse_Data;
+
+
+void USBH_HID_Mouse_Init(void)
+{
+}
+
+
+void USBH_HID_Mouse_Decode(uint8_t *data)
+{
+ USBH_HID_Mouse_Data.button = data[0];
+ USBH_HID_Mouse_Data.x = data[1];
+ USBH_HID_Mouse_Data.y = data[2];
+}
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_mouse.h b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_mouse.h
new file mode 100644
index 0000000000..f2576d3eff
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/HID/usbh_hid_mouse.h
@@ -0,0 +1,24 @@
+#ifndef __USBH_HID_MOUSE_H__
+#define __USBH_HID_MOUSE_H__
+
+#include <stdint.h>
+
+
+typedef struct {
+ uint8_t button; // bit0 左键 bit1 右键 bit2 中键
+ uint8_t x;
+ uint8_t y;
+ uint8_t z; // Not Supported
+} USBH_HID_Mouse_Data_t;
+
+extern USBH_HID_Mouse_Data_t USBH_HID_Mouse_Data;
+
+
+extern USBH_HID_cb_t USBH_HID_Mouse_cb;
+
+
+void USBH_HID_Mouse_Init(void);
+void USBH_HID_Mouse_Decode(uint8_t *data);
+
+
+#endif // __USBH_HID_MOUSE_H__
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_bot.c b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_bot.c
new file mode 100644
index 0000000000..f68db994a6
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_bot.c
@@ -0,0 +1,323 @@
+/******************************************************************************************************************************************
+* 文件名称: usbh_msc_bot.c
+* 功能说明:
+* 技术支持: http://www.synwit.com.cn/e/tool/gbook/?bid=1
+* 注意事项:
+* 版本日期: V1.1.0 2020年11月3日
+* 升级记录:
+*
+*
+*******************************************************************************************************************************************
+* @attention
+*
+* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS WITH CODING INFORMATION
+* REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. AS A RESULT, SYNWIT SHALL NOT BE HELD LIABLE
+* FOR ANY DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+* OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION CONTAINED HEREIN IN CONN-
+* -ECTION WITH THEIR PRODUCTS.
+*
+* COPYRIGHT 2012 Synwit Technology
+*******************************************************************************************************************************************/
+#include "SWM341.h"
+#include "usbh_core.h"
+#include "usbh_stdreq.h"
+#include "usbh_msc_bot.h"
+#include "usbh_msc_core.h"
+#include "usbh_msc_scsi.h"
+
+
+#define MSC_CBW_SIGNATURE 0x43425355
+#define MSC_CBW_TAG 0x20304050
+#define MSC_CSW_SIGNATURE 0x53425355
+#define MSC_CBW_LENGTH 31
+#define MSC_CSW_LENGTH 13
+
+
+USBH_CBWPkt_t USBH_CBWData;
+USBH_CSWPkt_t USBH_CSWData;
+
+
+static uint32_t BOT_StallCount;
+static uint32_t BOT_ErrorCount;
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MSC_BOT_Init()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void USBH_MSC_BOT_Init(void)
+{
+ USBH_CBWData.CBWSignature = MSC_CBW_SIGNATURE;
+ USBH_CBWData.CBWTag = MSC_CBW_TAG;
+ USBH_CBWData.CBWLUN = 0;
+
+ BOT_StallCount = 0;
+ BOT_ErrorCount = 0;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MSC_BOT_Process()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void USBH_MSC_BOT_Process(USBH_Info_t *phost)
+{
+ static uint32_t remLen; // remaining length
+ static uint8_t *pdBuff;
+ USBH_Status stat;
+ USBH_Resp resp;
+ uint32_t size;
+
+ switch(USBH_BOTXfer.BOTState)
+ {
+ case USBH_MSC_BOT_CBW:
+ if(USBH_SendOutPacket(phost->Device.Address, USBH_MSC_Info.OutEp, USBH_MSC_Info.OutEpDATAX, (uint8_t *)&USBH_CBWData, MSC_CBW_LENGTH))
+ {
+ USBH_BOTXfer.BOTStateBkp = USBH_BOTXfer.BOTState;
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_CBW_WAIT;
+ BOT_ErrorCount = 0;
+ }
+ break;
+
+ case USBH_MSC_BOT_CBW_WAIT:
+ resp = USBH_State();
+ if(resp == USBR_ACK)
+ {
+ BOT_StallCount = 0;
+
+ USBH_MSC_Info.OutEpDATAX ^= 1;
+
+ if(USBH_CBWData.CBWTransferLength != 0)
+ {
+ remLen = USBH_CBWData.CBWTransferLength;
+ pdBuff = USBH_BOTXfer.pDataBuffer;
+
+ if((USBH_CBWData.CBWFlags & USB_REQ_DIR_MASK) == USB_REQ_D2H)
+ {
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_DIN;
+ }
+ else
+ {
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_DOUT;
+ }
+ }
+ else // NO Data Transfer Stage
+ {
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_CSW;
+ }
+ }
+ else if(resp == USBR_NAK)
+ {
+ USBH_BOTXfer.BOTState = USBH_BOTXfer.BOTStateBkp;
+ }
+ else if(resp == USBR_STALL)
+ {
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_HANDLE_STALL_OUT;
+ }
+ else if(resp == USBR_ERROR)
+ {
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_HANDLE_ERROR;
+ }
+ break;
+
+ case USBH_MSC_BOT_DIN:
+ size = (remLen > USBH_MSC_Info.InEpSize) ? USBH_MSC_Info.InEpSize : remLen;
+ if(USBH_SendInPacket(phost->Device.Address, USBH_MSC_Info.InEp, USBH_MSC_Info.InEpDATAX, size))
+ {
+ USBH_BOTXfer.BOTStateBkp = USBH_BOTXfer.BOTState;
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_DIN_WAIT;
+ }
+ break;
+
+ case USBH_MSC_BOT_DIN_WAIT:
+ resp = USBH_State();
+ if(resp == USBR_ACK)
+ {
+ BOT_StallCount = 0;
+
+ USBH_MSC_Info.InEpDATAX ^= 1;
+
+ if(remLen > USBH_MSC_Info.InEpSize)
+ {
+ USBH_ReadRxBuffer(pdBuff, USBH_MSC_Info.InEpSize);
+
+ remLen -= USBH_MSC_Info.InEpSize;
+ pdBuff += USBH_MSC_Info.InEpSize;
+
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_DIN;
+ }
+ else
+ {
+ USBH_ReadRxBuffer(pdBuff, remLen);
+
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_CSW;
+ }
+ }
+ else if(resp == USBR_NAK)
+ {
+ USBH_BOTXfer.BOTState = USBH_BOTXfer.BOTStateBkp;
+ }
+ else if(resp == USBR_STALL)
+ {
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_HANDLE_STALL_IN;
+ }
+ else if(resp == USBR_ERROR)
+ {
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_HANDLE_ERROR;
+ }
+ break;
+
+ case USBH_MSC_BOT_DOUT:
+ size = (remLen > USBH_MSC_Info.OutEpSize) ? USBH_MSC_Info.OutEpSize : remLen;
+ if(USBH_SendOutPacket(phost->Device.Address, USBH_MSC_Info.OutEp, USBH_MSC_Info.OutEpDATAX, pdBuff, size))
+ {
+ USBH_BOTXfer.BOTStateBkp = USBH_BOTXfer.BOTState;
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_DOUT_WAIT;
+ }
+ break;
+
+ case USBH_MSC_BOT_DOUT_WAIT:
+ resp = USBH_State();
+ if(resp == USBR_ACK)
+ {
+ BOT_StallCount = 0;
+
+ USBH_MSC_Info.OutEpDATAX ^= 1;
+
+ if(remLen > USBH_MSC_Info.OutEpSize)
+ {
+ remLen -= USBH_MSC_Info.OutEpSize;
+ pdBuff += USBH_MSC_Info.OutEpSize;
+
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_DOUT;
+ }
+ else
+ {
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_CSW;
+ }
+ }
+ else if(resp == USBR_NAK)
+ {
+ USBH_BOTXfer.BOTState = USBH_BOTXfer.BOTStateBkp;
+ }
+ else if(resp == USBR_STALL)
+ {
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_HANDLE_STALL_OUT;
+ }
+ else if(resp == USBR_ERROR)
+ {
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_HANDLE_ERROR;
+ }
+ break;
+
+ case USBH_MSC_BOT_CSW:
+ if(USBH_SendInPacket(phost->Device.Address, USBH_MSC_Info.InEp, USBH_MSC_Info.InEpDATAX, MSC_CSW_LENGTH))
+ {
+ USBH_BOTXfer.BOTStateBkp = USBH_BOTXfer.BOTState;
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_CSW_WAIT;
+ }
+ break;
+
+ case USBH_MSC_BOT_CSW_WAIT:
+ resp = USBH_State();
+ if(resp == USBR_ACK)
+ {
+ BOT_StallCount = 0;
+
+ USBH_MSC_Info.InEpDATAX ^= 1;
+
+ USBH_ReadRxBuffer((uint8_t *)&USBH_CSWData, MSC_CSW_LENGTH);
+ USBH_BOTXfer.bCSWStatus = USBH_MSC_BOT_DecodeCSW(phost);
+
+ USBH_BOTXfer.MSCState = USBH_BOTXfer.MSCStateBkp;
+ }
+ else if(resp == USBR_NAK)
+ {
+ USBH_BOTXfer.BOTState = USBH_BOTXfer.BOTStateBkp;
+ }
+ else if(resp == USBR_STALL)
+ {
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_HANDLE_STALL_IN;
+ }
+ else if(resp == USBR_ERROR)
+ {
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_HANDLE_ERROR;
+ }
+ break;
+
+ case USBH_MSC_BOT_HANDLE_ERROR:
+ BOT_ErrorCount++;
+ if(BOT_ErrorCount < 5)
+ {
+ USBH_BOTXfer.BOTState = USBH_BOTXfer.BOTStateBkp; // retry
+ }
+ else
+ {
+ USBH_BOTXfer.bCSWStatus = USBH_MSC_PHASE_ERROR; // unrecovered error
+
+ USBH_BOTXfer.MSCState = USBH_BOTXfer.MSCStateBkp;
+ }
+ break;
+
+ case USBH_MSC_BOT_HANDLE_STALL_IN:
+ stat = USBH_ClrFeature(phost, USBH_MSC_Info.InEp);
+ if(stat == USBH_OK)
+ {
+ USBH_MSC_Info.InEpDATAX = 0;
+
+ USBH_BOTXfer.BOTState = USBH_BOTXfer.BOTStateBkp;
+ }
+ break;
+
+ case USBH_MSC_BOT_HANDLE_STALL_OUT:
+ stat = USBH_ClrFeature(phost, USBH_MSC_Info.OutEp);
+ if(stat == USBH_OK)
+ {
+ USBH_MSC_Info.OutEpDATAX = 0;
+
+ USBH_BOTXfer.BOTState = USBH_BOTXfer.BOTStateBkp;
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MSC_BOT_DecodeCSW()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+uint8_t USBH_MSC_BOT_DecodeCSW(USBH_Info_t *phost)
+{
+ uint8_t status;
+
+ if(USBH_CSWData.CSWSignature == MSC_CSW_SIGNATURE)
+ {
+ if(USBH_CSWData.CSWTag == USBH_CBWData.CBWTag)
+ {
+ status = USBH_CSWData.CSWStatus;
+ }
+ else // CSW Tag Error
+ {
+ status = USBH_MSC_PHASE_ERROR;
+ }
+ }
+ else // CSW Signature Error
+ {
+ status = USBH_MSC_PHASE_ERROR;
+ }
+
+ return status;
+}
+
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_bot.h b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_bot.h
new file mode 100644
index 0000000000..843103eeb8
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_bot.h
@@ -0,0 +1,51 @@
+#ifndef __USBH_MSC_BOT_H__
+#define __USBH_MSC_BOT_H__
+
+#include <stdint.h>
+
+
+typedef enum {
+ USBH_MSC_BOT_CBW = 0,
+ USBH_MSC_BOT_CBW_WAIT,
+ USBH_MSC_BOT_DIN,
+ USBH_MSC_BOT_DIN_WAIT,
+ USBH_MSC_BOT_DOUT,
+ USBH_MSC_BOT_DOUT_WAIT,
+ USBH_MSC_BOT_CSW,
+ USBH_MSC_BOT_CSW_WAIT,
+ USBH_MSC_BOT_HANDLE_ERROR,
+ USBH_MSC_BOT_HANDLE_STALL_IN,
+ USBH_MSC_BOT_HANDLE_STALL_OUT,
+} USBH_MSC_BOT_State;
+
+
+typedef struct __attribute__((packed)) {
+ uint32_t CBWSignature;
+ uint32_t CBWTag;
+ uint32_t CBWTransferLength;
+ uint8_t CBWFlags;
+ uint8_t CBWLUN;
+ uint8_t CBWCBLength;
+ uint8_t CBWCB[16];
+} USBH_CBWPkt_t;
+
+
+typedef struct __attribute__((packed)) {
+ uint32_t CSWSignature;
+ uint32_t CSWTag;
+ uint32_t CSWDataResidue;
+ uint8_t CSWStatus;
+} USBH_CSWPkt_t;
+
+
+extern USBH_CBWPkt_t USBH_CBWData;
+extern USBH_CSWPkt_t USBH_CSWData;
+
+
+void USBH_MSC_BOT_Init(void);
+void USBH_MSC_BOT_Process(USBH_Info_t *phost);
+uint8_t USBH_MSC_BOT_DecodeCSW(USBH_Info_t *phost);
+
+
+#endif // __USBH_MSC_BOT_H__
+
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_core.c b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_core.c
new file mode 100644
index 0000000000..454712ab7a
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_core.c
@@ -0,0 +1,287 @@
+/******************************************************************************************************************************************
+* 文件名称: usbh_msc_core.c
+* 功能说明:
+* 技术支持: http://www.synwit.com.cn/e/tool/gbook/?bid=1
+* 注意事项:
+* 版本日期: V1.1.0 2020年11月3日
+* 升级记录:
+*
+*
+*******************************************************************************************************************************************
+* @attention
+*
+* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS WITH CODING INFORMATION
+* REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. AS A RESULT, SYNWIT SHALL NOT BE HELD LIABLE
+* FOR ANY DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+* OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION CONTAINED HEREIN IN CONN-
+* -ECTION WITH THEIR PRODUCTS.
+*
+* COPYRIGHT 2012 Synwit Technology
+*******************************************************************************************************************************************/
+#include "SWM341.h"
+#include "usbh_core.h"
+#include "usbh_stdreq.h"
+#include "usbh_msc_bot.h"
+#include "usbh_msc_core.h"
+#include "usbh_msc_scsi.h"
+
+
+USBH_Class_cb_t USBH_MSC_cb =
+{
+ USBH_MSC_Init,
+ USBH_MSC_DeInit,
+ USBH_MSC_Request,
+ USBH_MSC_Process,
+};
+
+
+volatile USBH_MSC_Info_t USBH_MSC_Info;
+volatile USBH_BOTXfer_t USBH_BOTXfer;
+
+
+static uint8_t DataInBuffer[64];
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MSC_Init()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MSC_Init(USBH_Info_t *phost)
+{
+ USB_EpDesc_t *pEpIn, *pEpOut;
+
+ if((phost->Device.Intf_Desc[0].bInterfaceClass == USB_MSC_CLASS) && \
+ (phost->Device.Intf_Desc[0].bInterfaceProtocol == USB_MSC_BOT))
+ {
+ if(phost->Device.Ep_Desc[0][0].bEndpointAddress & USB_EP_IN)
+ {
+ pEpIn = &phost->Device.Ep_Desc[0][0];
+ pEpOut = &phost->Device.Ep_Desc[0][1];
+ }
+ else
+ {
+ pEpIn = &phost->Device.Ep_Desc[0][1];
+ pEpOut = &phost->Device.Ep_Desc[0][0];
+ }
+
+ USBH_MSC_Info.InEp = pEpIn->bEndpointAddress;
+ USBH_MSC_Info.InEpSize = pEpIn->wMaxPacketSize;
+ USBH_MSC_Info.OutEp = pEpOut->bEndpointAddress;
+ USBH_MSC_Info.OutEpSize = pEpOut->wMaxPacketSize;
+
+ USBH_MSC_DeInit(phost);
+ }
+ else
+ {
+ if(phost->usr_cb->DeviceNotSupported)
+ phost->usr_cb->DeviceNotSupported();
+ }
+
+ return USBH_OK ;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MSC_DeInit()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void USBH_MSC_DeInit(USBH_Info_t *phost)
+{
+ USBH_MSC_Info.Ready = 0;
+ USBH_MSC_Info.InEpDATAX = 0;
+ USBH_MSC_Info.OutEpDATAX = 0;
+
+ USBH_MSC_BOT_Init();
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MSC_Request()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MSC_Request(USBH_Info_t *phost)
+{
+ USBH_BOTXfer.MSCState = USBH_MSC_GET_MAXLUN;
+
+ return USBH_OK;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MSC_Process()
+* 功能说明: MSC state machine handler
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MSC_Process(USBH_Info_t *phost)
+{
+ USBH_Status status = USBH_BUSY;
+
+ uint8_t mscStatus;
+ uint8_t appStatus;
+
+ switch(USBH_BOTXfer.MSCState)
+ {
+ case USBH_MSC_GET_MAXLUN:
+ status = USBH_MSC_getMaxLUN(phost);
+ if(status == USBH_OK)
+ {
+ USBH_MSC_Info.MaxLUN = DataInBuffer[0];
+
+ USBH_BOTXfer.MSCState = USBH_MSC_TEST_UNIT_READY;
+ }
+ else if(status == USBH_NOT_SUPPORTED)
+ {
+ /* 清除 STALL 后,进入 USBH_MSC_TEST_UNIT_READY */
+ USBH_BOTXfer.MSCStateBkp = USBH_MSC_TEST_UNIT_READY;
+
+ USBH_BOTXfer.MSCState = USBH_MSC_CLEAR_STALL;
+ }
+ break;
+
+ case USBH_MSC_CLEAR_STALL:
+ status = USBH_ClrFeature(phost, USBH_MSC_Info.InEp);
+ if(status == USBH_OK)
+ {
+ USBH_MSC_Info.MaxLUN = 0; // 不支持 GetMaxLUN 请求,假设只有一个逻辑单元
+
+ USBH_BOTXfer.MSCState = USBH_BOTXfer.MSCStateBkp;
+ }
+ break;
+
+ case USBH_MSC_TEST_UNIT_READY:
+ mscStatus = USBH_MSC_TestUnitReady();
+ if(mscStatus == USBH_MSC_OK)
+ {
+ USBH_BOTXfer.MSCState = USBH_MSC_READ_CAPACITY10;
+
+ status = USBH_OK;
+ }
+ else
+ {
+ USBH_MSC_ErrorHandle(mscStatus);
+ }
+ break;
+
+ case USBH_MSC_READ_CAPACITY10:
+ mscStatus = USBH_MSC_ReadCapacity10();
+ if(mscStatus == USBH_MSC_OK)
+ {
+ USBH_BOTXfer.MSCState = USBH_MSC_DEFAULT_APP;
+
+ USBH_MSC_Info.Ready = 1;
+
+ status = USBH_OK;
+ }
+ else
+ {
+ USBH_MSC_ErrorHandle(mscStatus);
+ }
+ break;
+
+ case USBH_MSC_MODE_SENSE6:
+ /* Issue ModeSense6 SCSI command for detecting if device is write-protected */
+ mscStatus = USBH_MSC_ModeSense6();
+ if(mscStatus == USBH_MSC_OK)
+ {
+ USBH_BOTXfer.MSCState = USBH_MSC_DEFAULT_APP;
+
+ status = USBH_OK;
+ }
+ else
+ {
+ USBH_MSC_ErrorHandle(mscStatus);
+ }
+ break;
+
+ case USBH_MSC_DEFAULT_APP:
+ /* Process Application callback for MSC */
+ appStatus = phost->usr_cb->UserApplication();
+ if(appStatus == 1)
+ {
+ /* De-init requested from application layer */
+ status = USBH_APPLY_DEINIT;
+ }
+ break;
+
+ case USBH_MSC_BOT_TRANSFER:
+ USBH_MSC_BOT_Process(phost);
+ break;
+
+ case USBH_MSC_UNRECOVERED_STATE:
+ status = USBH_UNRECOVERED_ERROR;
+ break;
+
+ case USBH_MSC_REQUEST_SENSE:
+ /* Issue RequestSense SCSI command for retrieving error code */
+ mscStatus = USBH_MSC_RequestSense();
+ if(mscStatus == USBH_MSC_OK)
+ {
+ USBH_BOTXfer.MSCState = USBH_BOTXfer.MSCStateBkp;
+
+ status = USBH_OK;
+ }
+ else
+ {
+ USBH_MSC_ErrorHandle(mscStatus);
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MSC_getMaxLUN()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MSC_getMaxLUN(USBH_Info_t *phost)
+{
+ phost->Ctrl.setup.bRequestType = USB_REQ_D2H | USB_REQ_CLASS | USB_REQ_TO_INTERFACE;
+
+ phost->Ctrl.setup.bRequest = 0xFE;
+ phost->Ctrl.setup.wValue = 0;
+ phost->Ctrl.setup.wIndex = 0;
+ phost->Ctrl.setup.wLength = 1;
+
+ return USBH_CtrlTransfer(phost, DataInBuffer , 1);
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MSC_ErrorHandle()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void USBH_MSC_ErrorHandle(uint8_t status)
+{
+ if(status == USBH_MSC_FAIL)
+ {
+ /* Try MSC level error recovery, Issue the request Sense to get Drive error reason */
+ USBH_BOTXfer.MSCState = USBH_MSC_REQUEST_SENSE;
+ }
+ else if(status == USBH_MSC_PHASE_ERROR)
+ {
+ /* Phase error, Go to Unrecovered state */
+ USBH_BOTXfer.MSCState = USBH_MSC_UNRECOVERED_STATE;
+ }
+}
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_core.h b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_core.h
new file mode 100644
index 0000000000..3ddab02fd1
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_core.h
@@ -0,0 +1,66 @@
+#ifndef __USBH_MSC_CORE_H__
+#define __USBH_MSC_CORE_H__
+
+#include <stdint.h>
+#include "usbh_core.h"
+
+
+typedef enum {
+ USBH_MSC_GET_MAXLUN = 0,
+ USBH_MSC_TEST_UNIT_READY,
+ USBH_MSC_READ_CAPACITY10,
+ USBH_MSC_MODE_SENSE6,
+ USBH_MSC_REQUEST_SENSE,
+ USBH_MSC_BOT_TRANSFER,
+ USBH_MSC_DEFAULT_APP,
+ USBH_MSC_CLEAR_STALL,
+ USBH_MSC_UNRECOVERED_STATE
+} USBH_MSC_State;
+
+
+typedef struct {
+ uint8_t InEp;
+ uint8_t OutEp;
+ uint16_t InEpSize;
+ uint16_t OutEpSize;
+ uint8_t InEpDATAX;
+ uint8_t OutEpDATAX;
+
+ uint8_t Ready;
+ uint8_t MaxLUN; // Max Logic Unit Number
+ uint32_t Capacity;
+ uint16_t PageSize;
+ uint8_t WProtect; // Write Protect
+ uint32_t SenseKey;
+} USBH_MSC_Info_t;
+
+
+typedef struct {
+ uint8_t MSCState;
+ uint8_t MSCStateBkp;
+ uint8_t BOTState;
+ uint8_t BOTStateBkp;
+ uint8_t bCSWStatus; // CSW.bCSWStatus
+ uint8_t *pDataBuffer;
+ uint8_t UDiskReady;
+} USBH_BOTXfer_t;
+
+
+extern volatile USBH_MSC_Info_t USBH_MSC_Info;
+extern volatile USBH_BOTXfer_t USBH_BOTXfer;
+
+
+extern USBH_Class_cb_t USBH_MSC_cb;
+
+
+USBH_Status USBH_MSC_Init(USBH_Info_t *phost);
+void USBH_MSC_DeInit(USBH_Info_t *phost);
+USBH_Status USBH_MSC_Request(USBH_Info_t *phost);
+USBH_Status USBH_MSC_Process(USBH_Info_t *phost);
+
+USBH_Status USBH_MSC_getMaxLUN(USBH_Info_t *phost);
+void USBH_MSC_ErrorHandle(uint8_t status);
+
+
+#endif // __USBH_MSC_CORE_H__
+
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_scsi.c b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_scsi.c
new file mode 100644
index 0000000000..05ec905d0c
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_scsi.c
@@ -0,0 +1,366 @@
+/******************************************************************************************************************************************
+* 文件名称: usbh_msc_scsi.c
+* 功能说明:
+* 技术支持: http://www.synwit.com.cn/e/tool/gbook/?bid=1
+* 注意事项:
+* 版本日期: V1.1.0 2020年11月3日
+* 升级记录:
+*
+*
+*******************************************************************************************************************************************
+* @attention
+*
+* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS WITH CODING INFORMATION
+* REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. AS A RESULT, SYNWIT SHALL NOT BE HELD LIABLE
+* FOR ANY DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+* OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION CONTAINED HEREIN IN CONN-
+* -ECTION WITH THEIR PRODUCTS.
+*
+* COPYRIGHT 2012 Synwit Technology
+*******************************************************************************************************************************************/
+#include "SWM341.h"
+#include "usbh_core.h"
+#include "usbh_msc_bot.h"
+#include "usbh_msc_core.h"
+#include "usbh_msc_scsi.h"
+
+
+#define OPCODE_TEST_UNIT_READY 0X00
+#define OPCODE_READ_CAPACITY10 0x25
+#define OPCODE_MODE_SENSE6 0x1A
+#define OPCODE_READ10 0x28
+#define OPCODE_WRITE10 0x2A
+#define OPCODE_REQUEST_SENSE 0x03
+
+#define DATLEN_READ_CAPACITY10 8 // Data Stage Length
+#define DATLEN_MODE_SENSE6 63
+#define DATLEN_REQUEST_SENSE 18
+
+
+static uint8_t SCSI_Busy = 0;
+
+static uint8_t DataInBuffer[64];
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MSC_TestUnitReady()
+* 功能说明: Issues 'Test unit ready' command to the device.
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_MSC_Status USBH_MSC_TestUnitReady(void)
+{
+ USBH_MSC_Status status = USBH_MSC_BUSY;
+
+ if(!SCSI_Busy)
+ {
+ USBH_CBWData.CBWTransferLength = 0; // No Data Stage
+ USBH_CBWData.CBWCBLength = 6;
+ USBH_CBWData.CBWCB[0] = OPCODE_TEST_UNIT_READY;
+ for(uint8_t i = 1; i < 16; i++) USBH_CBWData.CBWCB[i] = 0;
+
+ USBH_BOTXfer.bCSWStatus = USBH_MSC_BUSY;
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_CBW;
+
+ USBH_BOTXfer.MSCStateBkp = USBH_BOTXfer.MSCState;
+ USBH_BOTXfer.MSCState = USBH_MSC_BOT_TRANSFER;
+
+ SCSI_Busy = 1;
+ }
+ else
+ {
+ if(USBH_BOTXfer.bCSWStatus != USBH_MSC_BUSY)
+ {
+ status = USBH_BOTXfer.bCSWStatus;
+
+ SCSI_Busy = 0;
+ }
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MSC_ReadCapacity10()
+* 功能说明: Issue the read capacity command to the device.
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_MSC_Status USBH_MSC_ReadCapacity10(void)
+{
+ USBH_MSC_Status status = USBH_MSC_BUSY;
+
+ if(!SCSI_Busy)
+ {
+ USBH_CBWData.CBWTransferLength = DATLEN_READ_CAPACITY10;
+ USBH_CBWData.CBWFlags = USB_REQ_D2H;
+ USBH_CBWData.CBWCBLength = 10;
+ USBH_CBWData.CBWCB[0] = OPCODE_READ_CAPACITY10;
+ for(uint8_t i = 1; i < 16; i++) USBH_CBWData.CBWCB[i] = 0;
+
+ USBH_BOTXfer.pDataBuffer = DataInBuffer;
+
+ USBH_BOTXfer.bCSWStatus = USBH_MSC_BUSY;
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_CBW;
+
+ USBH_BOTXfer.MSCStateBkp = USBH_BOTXfer.MSCState;
+ USBH_BOTXfer.MSCState = USBH_MSC_BOT_TRANSFER;
+
+ SCSI_Busy = 1;
+ }
+ else
+ {
+ if(USBH_BOTXfer.bCSWStatus != USBH_MSC_BUSY)
+ {
+ if(USBH_BOTXfer.bCSWStatus == USBH_MSC_OK)
+ {
+ /* assign the capacity */
+ ((uint8_t *)&USBH_MSC_Info.Capacity)[3] = DataInBuffer[0];
+ ((uint8_t *)&USBH_MSC_Info.Capacity)[2] = DataInBuffer[1];
+ ((uint8_t *)&USBH_MSC_Info.Capacity)[1] = DataInBuffer[2];
+ ((uint8_t *)&USBH_MSC_Info.Capacity)[0] = DataInBuffer[3];
+
+ /* assign the page length */
+ ((uint8_t *)&USBH_MSC_Info.PageSize)[1] = DataInBuffer[6];
+ ((uint8_t *)&USBH_MSC_Info.PageSize)[0] = DataInBuffer[7];
+ }
+
+ status = USBH_BOTXfer.bCSWStatus;
+
+ SCSI_Busy = 0;
+ }
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MSC_ModeSense6()
+* 功能说明: Issue the Mode Sense6 Command to the device.
+* Used for reading the WriteProtect Status of the Mass-Storage device.
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_MSC_Status USBH_MSC_ModeSense6(void)
+{
+ USBH_MSC_Status status = USBH_MSC_BUSY;
+
+ if(!SCSI_Busy)
+ {
+ USBH_CBWData.CBWTransferLength = DATLEN_MODE_SENSE6;
+ USBH_CBWData.CBWFlags = USB_REQ_D2H;
+ USBH_CBWData.CBWCBLength = 10;
+ USBH_CBWData.CBWCB[0] = OPCODE_MODE_SENSE6;
+ USBH_CBWData.CBWCB[1] = 0x00;
+ USBH_CBWData.CBWCB[2] = 0x3F;
+ USBH_CBWData.CBWCB[3] = 0x00;
+ USBH_CBWData.CBWCB[4] = DATLEN_MODE_SENSE6;
+ for(uint8_t i = 5; i < 16; i++) USBH_CBWData.CBWCB[i] = 0;
+
+ USBH_BOTXfer.pDataBuffer = DataInBuffer;
+
+ USBH_BOTXfer.bCSWStatus = USBH_MSC_BUSY;
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_CBW;
+
+ USBH_BOTXfer.MSCStateBkp = USBH_BOTXfer.MSCState;
+ USBH_BOTXfer.MSCState = USBH_MSC_BOT_TRANSFER;
+
+ SCSI_Busy = 1;
+ }
+ else
+ {
+ if(USBH_BOTXfer.bCSWStatus != USBH_MSC_BUSY)
+ {
+ if(USBH_BOTXfer.bCSWStatus == USBH_MSC_OK)
+ {
+ /* Assign the Write Protect status */
+ if(DataInBuffer[2] & 0x80)
+ {
+ USBH_MSC_Info.WProtect = 1;
+ }
+ else
+ {
+ USBH_MSC_Info.WProtect = 0;
+ }
+ }
+
+ status = USBH_BOTXfer.bCSWStatus;
+
+ SCSI_Busy = 0;
+ }
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MSC_Read10()
+* 功能说明: Issue the read command to the device.
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_MSC_Status USBH_MSC_Read10(uint8_t *buffer, uint32_t address, uint32_t nbOfbytes)
+{
+ USBH_MSC_Status status = USBH_MSC_BUSY;
+ uint16_t nbOfPages;
+
+ if(!SCSI_Busy)
+ {
+ USBH_CBWData.CBWTransferLength = nbOfbytes;
+ USBH_CBWData.CBWFlags = USB_REQ_D2H;
+ USBH_CBWData.CBWCBLength = 10;
+ USBH_CBWData.CBWCB[0] = OPCODE_READ10;
+ USBH_CBWData.CBWCB[1] = 0x00;
+ /*logical block address*/
+ USBH_CBWData.CBWCB[2] = ((uint8_t *)&address)[3];
+ USBH_CBWData.CBWCB[3] = ((uint8_t *)&address)[2];
+ USBH_CBWData.CBWCB[4] = ((uint8_t *)&address)[1];
+ USBH_CBWData.CBWCB[5] = ((uint8_t *)&address)[0];
+ USBH_CBWData.CBWCB[6] = 0x00;
+ /*Transfer length */
+ nbOfPages = nbOfbytes / USBH_MSC_Info.PageSize;
+ USBH_CBWData.CBWCB[7] = ((uint8_t *)&nbOfPages)[1];
+ USBH_CBWData.CBWCB[8] = ((uint8_t *)&nbOfPages)[0];
+ for(uint8_t i = 9; i < 16; i++) USBH_CBWData.CBWCB[i] = 0;
+
+ USBH_BOTXfer.pDataBuffer = buffer;
+
+ USBH_BOTXfer.bCSWStatus = USBH_MSC_BUSY;
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_CBW;
+
+ USBH_BOTXfer.MSCStateBkp = USBH_BOTXfer.MSCState;
+ USBH_BOTXfer.MSCState = USBH_MSC_BOT_TRANSFER;
+
+ SCSI_Busy = 1;
+ }
+ else
+ {
+ if(USBH_BOTXfer.bCSWStatus != USBH_MSC_BUSY)
+ {
+ status = USBH_BOTXfer.bCSWStatus;
+
+ SCSI_Busy = 0;
+ }
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MSC_Write10()
+* 功能说明: Issue the write command to the device.
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_MSC_Status USBH_MSC_Write10(uint8_t *buffer, uint32_t address, uint32_t nbOfbytes)
+{
+ USBH_MSC_Status status = USBH_MSC_BUSY;
+ uint16_t nbOfPages;
+
+ if(!SCSI_Busy)
+ {
+ USBH_CBWData.CBWTransferLength = nbOfbytes;
+ USBH_CBWData.CBWFlags = USB_REQ_H2D;
+ USBH_CBWData.CBWCBLength = 10;
+ USBH_CBWData.CBWCB[0] = OPCODE_WRITE10;
+ USBH_CBWData.CBWCB[1] = 0x00;
+ /*logical block address*/
+ USBH_CBWData.CBWCB[2] = ((uint8_t *)&address)[3];
+ USBH_CBWData.CBWCB[3] = ((uint8_t *)&address)[2];
+ USBH_CBWData.CBWCB[4] = ((uint8_t *)&address)[1];
+ USBH_CBWData.CBWCB[5] = ((uint8_t *)&address)[0];
+ USBH_CBWData.CBWCB[6] = 0x00;
+ /*Transfer length */
+ nbOfPages = nbOfbytes / USBH_MSC_Info.PageSize;
+ USBH_CBWData.CBWCB[7] = ((uint8_t *)&nbOfPages)[1];
+ USBH_CBWData.CBWCB[8] = ((uint8_t *)&nbOfPages)[0];
+ for(uint8_t i = 9; i < 16; i++) USBH_CBWData.CBWCB[i] = 0;
+
+ USBH_BOTXfer.pDataBuffer = buffer;
+
+ USBH_BOTXfer.bCSWStatus = USBH_MSC_BUSY;
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_CBW;
+
+ USBH_BOTXfer.MSCStateBkp = USBH_BOTXfer.MSCState;
+ USBH_BOTXfer.MSCState = USBH_MSC_BOT_TRANSFER;
+
+ SCSI_Busy = 1;
+ }
+ else
+ {
+ if(USBH_BOTXfer.bCSWStatus != USBH_MSC_BUSY)
+ {
+ status = USBH_BOTXfer.bCSWStatus;
+
+ SCSI_Busy = 0;
+ }
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MSC_RequestSense()
+* 功能说明: Issues the Request Sense command to the device.
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_MSC_Status USBH_MSC_RequestSense(void)
+{
+ USBH_MSC_Status status = USBH_MSC_BUSY;
+
+ if(!SCSI_Busy)
+ {
+ USBH_CBWData.CBWTransferLength = DATLEN_REQUEST_SENSE;
+ USBH_CBWData.CBWFlags = USB_REQ_D2H;
+ USBH_CBWData.CBWCBLength = 6;
+ USBH_CBWData.CBWCB[0] = OPCODE_REQUEST_SENSE;
+ USBH_CBWData.CBWCB[1] = 0x00;
+ USBH_CBWData.CBWCB[2] = 0x00;
+ USBH_CBWData.CBWCB[3] = 0x00;
+ USBH_CBWData.CBWCB[4] = DATLEN_REQUEST_SENSE;
+ for(uint8_t i = 5; i < 16; i++) USBH_CBWData.CBWCB[i] = 0;
+
+ USBH_BOTXfer.pDataBuffer = DataInBuffer;
+
+ USBH_BOTXfer.bCSWStatus = USBH_MSC_BUSY;
+ USBH_BOTXfer.BOTState = USBH_MSC_BOT_CBW;
+
+ USBH_BOTXfer.MSCState = USBH_MSC_BOT_TRANSFER;
+
+ SCSI_Busy = 1;
+ }
+ else
+ {
+ if(USBH_BOTXfer.bCSWStatus != USBH_MSC_BUSY)
+ {
+ if(USBH_BOTXfer.bCSWStatus == USBH_MSC_OK)
+ {
+ /* Assign Sense data*/
+ ((uint8_t *)&USBH_MSC_Info.SenseKey)[3] = DataInBuffer[0];
+ ((uint8_t *)&USBH_MSC_Info.SenseKey)[2] = DataInBuffer[1];
+ ((uint8_t *)&USBH_MSC_Info.SenseKey)[1] = DataInBuffer[2];
+ ((uint8_t *)&USBH_MSC_Info.SenseKey)[0] = DataInBuffer[3];
+
+ status = USBH_MSC_OK;
+ }
+
+ status = USBH_BOTXfer.bCSWStatus;
+
+ SCSI_Busy = 0;
+ }
+ }
+
+ return status;
+}
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_scsi.h b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_scsi.h
new file mode 100644
index 0000000000..39e0220d1f
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MSC/usbh_msc_scsi.h
@@ -0,0 +1,24 @@
+#ifndef __USBH_MSC_SCSI_H__
+#define __USBH_MSC_SCSI_H__
+
+#include <stdint.h>
+
+
+typedef enum {
+ USBH_MSC_OK = 0,
+ USBH_MSC_FAIL,
+ USBH_MSC_PHASE_ERROR,
+ USBH_MSC_BUSY = 0xFF,
+} USBH_MSC_Status; // 见 CSW.bCSWStatus 取值
+
+
+USBH_MSC_Status USBH_MSC_TestUnitReady(void);
+USBH_MSC_Status USBH_MSC_ReadCapacity10(void);
+USBH_MSC_Status USBH_MSC_ModeSense6(void);
+USBH_MSC_Status USBH_MSC_RequestSense(void);
+USBH_MSC_Status USBH_MSC_Read10(uint8_t *buffer, uint32_t address, uint32_t nbOfbytes);
+USBH_MSC_Status USBH_MSC_Write10(uint8_t *buffer, uint32_t address, uint32_t nbOfbytes);
+
+
+#endif //__USBH_MSC_SCSI_H__
+
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp.c b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp.c
new file mode 100644
index 0000000000..2b78377dd4
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp.c
@@ -0,0 +1,1366 @@
+/******************************************************************************************************************************************
+* 文件名称: usbh_mtp.c
+* 功能说明: This file is the MTP Layer Handlers for USB Host MTP class.
+* 技术支持: http://www.synwit.com.cn/e/tool/gbook/?bid=1
+* 注意事项:
+* 版本日期: V1.1.0 2020年11月3日
+* 升级记录:
+*
+*
+*******************************************************************************************************************************************
+* @attention
+*
+* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS WITH CODING INFORMATION
+* REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. AS A RESULT, SYNWIT SHALL NOT BE HELD LIABLE
+* FOR ANY DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+* OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION CONTAINED HEREIN IN CONN-
+* -ECTION WITH THEIR PRODUCTS.
+*
+* COPYRIGHT 2012 Synwit Technology
+*******************************************************************************************************************************************/
+#include <stdlib.h>
+#include <string.h>
+#include "SWM341.h"
+#include "usbh_core.h"
+#include "usbh_mtp.h"
+
+
+static USBH_Status USBH_MTP_Init(USBH_Info_t *phost);
+static void USBH_MTP_DeInit(USBH_Info_t *phost);
+static USBH_Status USBH_MTP_Request(USBH_Info_t *phost);
+static USBH_Status USBH_MTP_Process(USBH_Info_t *phost);
+
+USBH_Class_cb_t USBH_MTP_cb =
+{
+ USBH_MTP_Init,
+ USBH_MTP_DeInit,
+ USBH_MTP_Request,
+ USBH_MTP_Process,
+};
+
+
+USBH_MTP_Info_t USBH_MTP_Info;
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_Init()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+static USBH_Status USBH_MTP_Init(USBH_Info_t *phost)
+{
+ USB_EpDesc_t *pEpIn, *pEpOut, *pEpNotify;
+
+ for(int i = 0; i < phost->Device.Cfg_Desc.bNumInterfaces; i++)
+ {
+ if(((phost->Device.Intf_Desc[i].bInterfaceClass == USB_MTP_CLASS) && (phost->Device.Intf_Desc[i].bNumEndpoints == 3)) ||
+ ((phost->Device.Intf_Desc[i].bInterfaceClass == 0xFF) && (phost->Device.Intf_Desc[i].bNumEndpoints == 3)))
+ {
+#define EpVerify(ep, dir, type) (((phost->Device.Ep_Desc[i][ep].bEndpointAddress & USB_EP_IN) == dir) && \
+ ((phost->Device.Ep_Desc[i][ep].bmAttributes & USB_EP_INT) == type))
+ if(EpVerify(0, USB_EP_IN, USB_EP_INT) && EpVerify(1, USB_EP_IN, USB_EP_BULK) && EpVerify(2, USB_EP_OUT, USB_EP_BULK))
+ {
+ pEpNotify = &phost->Device.Ep_Desc[i][0];
+ pEpIn = &phost->Device.Ep_Desc[i][1];
+ pEpOut = &phost->Device.Ep_Desc[i][2];
+ }
+ else if(EpVerify(0, USB_EP_IN, USB_EP_INT) && EpVerify(2, USB_EP_IN, USB_EP_BULK) && EpVerify(1, USB_EP_OUT, USB_EP_BULK))
+ {
+ pEpNotify = &phost->Device.Ep_Desc[i][0];
+ pEpIn = &phost->Device.Ep_Desc[i][2];
+ pEpOut = &phost->Device.Ep_Desc[i][1];
+ }
+ else if(EpVerify(1, USB_EP_IN, USB_EP_INT) && EpVerify(0, USB_EP_IN, USB_EP_BULK) && EpVerify(2, USB_EP_OUT, USB_EP_BULK))
+ {
+ pEpNotify = &phost->Device.Ep_Desc[i][1];
+ pEpIn = &phost->Device.Ep_Desc[i][0];
+ pEpOut = &phost->Device.Ep_Desc[i][2];
+ }
+ else if(EpVerify(1, USB_EP_IN, USB_EP_INT) && EpVerify(2, USB_EP_IN, USB_EP_BULK) && EpVerify(0, USB_EP_OUT, USB_EP_BULK))
+ {
+ pEpNotify = &phost->Device.Ep_Desc[i][1];
+ pEpIn = &phost->Device.Ep_Desc[i][2];
+ pEpOut = &phost->Device.Ep_Desc[i][0];
+ }
+ else if(EpVerify(2, USB_EP_IN, USB_EP_INT) && EpVerify(0, USB_EP_IN, USB_EP_BULK) && EpVerify(1, USB_EP_OUT, USB_EP_BULK))
+ {
+ pEpNotify = &phost->Device.Ep_Desc[i][2];
+ pEpIn = &phost->Device.Ep_Desc[i][0];
+ pEpOut = &phost->Device.Ep_Desc[i][1];
+ }
+ else if(EpVerify(2, USB_EP_IN, USB_EP_INT) && EpVerify(1, USB_EP_IN, USB_EP_BULK) && EpVerify(0, USB_EP_OUT, USB_EP_BULK))
+ {
+ pEpNotify = &phost->Device.Ep_Desc[i][2];
+ pEpIn = &phost->Device.Ep_Desc[i][1];
+ pEpOut = &phost->Device.Ep_Desc[i][0];
+ }
+ else
+ {
+ continue;
+ }
+
+ USBH_MTP_Info.InEp = pEpIn->bEndpointAddress;
+ USBH_MTP_Info.InEpSize = pEpIn->wMaxPacketSize;
+ USBH_MTP_Info.OutEp = pEpOut->bEndpointAddress;
+ USBH_MTP_Info.OutEpSize = pEpOut->wMaxPacketSize;
+ USBH_MTP_Info.NotifyEp = pEpNotify->bEndpointAddress;
+ USBH_MTP_Info.NotifyEpSize = pEpNotify->wMaxPacketSize;
+
+ USBH_MTP_Info.events.poll = pEpNotify->bInterval;
+
+ SW_LOG_INFO("InEp: %x, InEpSize: %d", pEpIn->bEndpointAddress, pEpIn->wMaxPacketSize);
+ SW_LOG_INFO("OutEp: %x, OutEpSize: %d", pEpOut->bEndpointAddress, pEpOut->wMaxPacketSize);
+ SW_LOG_INFO("NotifyEp: %x, NotifyEpSize: %d, NotifyInterval: %d", pEpNotify->bEndpointAddress, pEpNotify->wMaxPacketSize, pEpNotify->bInterval);
+
+ USBH_MTP_DeInit(phost);
+
+ return USBH_OK;
+ }
+ else
+ {
+ continue;
+ }
+ }
+
+ if(phost->usr_cb->DeviceNotSupported)
+ phost->usr_cb->DeviceNotSupported();
+
+ return USBH_NOT_SUPPORTED;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_DeInit()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+static void USBH_MTP_DeInit(USBH_Info_t *phost)
+{
+ USBH_MTP_Info.is_ready = 0;
+
+ USBH_MTP_Info.InEpDATAX = 0;
+ USBH_MTP_Info.OutEpDATAX = 0;
+ USBH_MTP_Info.NotifyEpDATAX = 0;
+
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_IDLE;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+
+ USBH_MTP_Info.state = USBH_MTP_GETDEVICEINFO;
+ USBH_MTP_Info.stateReq = USBH_MTP_IDLE;
+
+ SW_LOG_INFO("USBH_MTP_DeInit");
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_Request()
+* 功能说明: Used for handling Standard requests for MTP class.
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+static USBH_Status USBH_MTP_Request(USBH_Info_t *phost)
+{
+ return USBH_OK;
+}
+
+
+void USBH_MTP_XferProcess(USBH_Info_t *phost);
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_Process()
+* 功能说明: Used for managing state machine for MTP data transfers.
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+static USBH_Status USBH_MTP_Process(USBH_Info_t *phost)
+{
+ USBH_Resp resp;
+ USBH_Status status = USBH_BUSY;
+
+ if((USBH_MTP_Info.state != USBH_MTP_EVENT_WAIT) &&
+ (USBH_MTP_Info.state != USBH_MTP_EVENT_CHECK))
+ {
+ if(USBH_MTP_Info.stateReq != USBH_MTP_IDLE)
+ {
+ USBH_MTP_Info.stateBkp = USBH_MTP_Info.state;
+ USBH_MTP_Info.state = USBH_MTP_Info.stateReq;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_IDLE;
+ }
+ }
+
+ switch(USBH_MTP_Info.state)
+ {
+ case USBH_MTP_GETDEVICEINFO:
+ status = USBH_MTP_GetDeviceInfo(phost, &USBH_MTP_Info.devinfo);
+ if(status == USBH_OK)
+ {
+ SW_LOG_INFO("MTP Device Information");
+ SW_LOG_INFO(" Standard version : %x", USBH_MTP_Info.devinfo.StandardVersion);
+ SW_LOG_INFO(" Vendor ExtID : %s", USBH_MTP_Info.devinfo.VendorExtensionID == 6 ? "MTP" : "NOT SUPPORTED");
+ SW_LOG_INFO(" Functional mode : %s", USBH_MTP_Info.devinfo.FunctionalMode == 0 ? "Standard" : "Vendor");
+ SW_LOG_INFO(" Number of Supported Operation(s) : %d", USBH_MTP_Info.devinfo.OperationsSupportedNbr);
+ SW_LOG_INFO(" Number of Supported Events(s) : %d", USBH_MTP_Info.devinfo.EventsSupportedNbr);
+ SW_LOG_INFO(" Number of Supported Proprieties : %d", USBH_MTP_Info.devinfo.DevicePropertiesSupportedNbr);
+ SW_LOG_INFO(" Manufacturer : %s", USBH_MTP_Info.devinfo.Manufacturer);
+ SW_LOG_INFO(" Model : %s", USBH_MTP_Info.devinfo.Model);
+ SW_LOG_INFO(" Device version : %s", USBH_MTP_Info.devinfo.DeviceVersion);
+ SW_LOG_INFO(" Serial number : %s", USBH_MTP_Info.devinfo.SerialNumber);
+
+ USBH_MTP_Info.state = USBH_MTP_OPENSESSION;
+ }
+ break;
+
+ case USBH_MTP_OPENSESSION:
+ status = USBH_MTP_OpenSession(phost, 1);
+ if(status == USBH_OK)
+ {
+ SW_LOG_INFO("MTP Session #1 Opened");
+
+ USBH_MTP_Info.state = USBH_MTP_GETSTORAGEIDS;
+ }
+ break;
+
+ case USBH_MTP_GETSTORAGEIDS:
+ status = USBH_MTP_GetStorageIds(phost, &USBH_MTP_Info.storids);
+ if(status == USBH_OK)
+ {
+ SW_LOG_INFO("Number of storage ID items : %d", USBH_MTP_Info.storids.n);
+ for(int i = 0; i < USBH_MTP_Info.storids.n; i++)
+ {
+ SW_LOG_INFO("storage#%d ID : %x", i, USBH_MTP_Info.storids.Storage[i]);
+ }
+
+ USBH_MTP_Info.CurrentStorage = 0;
+ if(USBH_MTP_Info.storids.n)
+ USBH_MTP_Info.state = USBH_MTP_GETSTORAGEINFO;
+ }
+ break;
+
+ case USBH_MTP_GETSTORAGEINFO:
+ status = USBH_MTP_GetStorageInfo(phost, USBH_MTP_Info.storids.Storage[USBH_MTP_Info.CurrentStorage],
+ &USBH_MTP_Info.storinfo[USBH_MTP_Info.CurrentStorage]);
+ if(status == USBH_OK)
+ {
+ SW_LOG_INFO("Volume#%u: %s [%s]", USBH_MTP_Info.CurrentStorage, USBH_MTP_Info.storinfo[USBH_MTP_Info.CurrentStorage].StorageDescription,
+ USBH_MTP_Info.storinfo[USBH_MTP_Info.CurrentStorage].VolumeLabel);
+ USBH_MTP_Info.is_ready = 1;
+ USBH_MTP_Info.state = USBH_MTP_IDLE;
+ }
+ break;
+
+ case USBH_MTP_IDLE:
+ if(abs((int)USBH->FRAMENR - (int)USBH_MTP_Info.events.timer) >= USBH_MTP_Info.events.poll)
+ {
+ USBH_MTP_Info.events.timer = USBH->FRAMENR;
+
+ USBH_MTP_Info.state = USBH_MTP_EVENT;
+ }
+ else
+ {
+ status = USBH_OK;
+ }
+ break;
+
+ case USBH_MTP_EVENT_CHECK:
+ if(abs((int)USBH->FRAMENR - (int)USBH_MTP_Info.events.timer) >= USBH_MTP_Info.events.poll)
+ {
+ USBH_MTP_Info.events.timer = USBH->FRAMENR;
+
+ USBH_MTP_Info.state = USBH_MTP_EVENT;
+ }
+ else
+ {
+ USBH_MTP_Info.state = USBH_MTP_TRANSFER; // Event 查询是在数据传输中间插入的,返回数据传输
+ }
+ break;
+
+ case USBH_MTP_EVENT:
+ if(USBH_SendInPacket(phost->Device.Address, USBH_MTP_Info.NotifyEp, USBH_MTP_Info.NotifyEpDATAX, USBH_MTP_Info.NotifyEpSize))
+ {
+ USBH_MTP_Info.state = USBH_MTP_EVENT_WAIT;
+ }
+ break;
+
+ case USBH_MTP_EVENT_WAIT:
+ resp = USBH_State();
+ if(resp == USBR_ACK)
+ {
+ USBH_MTP_Info.NotifyEpDATAX ^= 1;
+
+ USBH_ReadRxBuffer((uint8_t *)&USBH_MTP_Info.events.container, USBH_MTP_Info.NotifyEpSize);
+
+ USBH_MTP_EventsCallback(phost, USBH_MTP_Info.events.container.code, USBH_MTP_Info.events.container.param1);
+ }
+
+ if((USBH_MTP_Info.XferState == USBH_MTP_XFER_DATA_OUT) ||
+ (USBH_MTP_Info.XferState == USBH_MTP_XFER_DATA_IN))
+ {
+ USBH_MTP_Info.state = USBH_MTP_TRANSFER; // Event 查询是在数据传输中间插入的,返回数据传输
+ }
+ else
+ {
+ USBH_MTP_Info.state = USBH_MTP_IDLE;
+ }
+ break;
+
+ case USBH_MTP_TRANSFER:
+ USBH_MTP_XferProcess(phost);
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_XferProcess()
+* 功能说明:
+* 输 入: USBH_Info_t *phost
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void USBH_MTP_XferProcess(USBH_Info_t *phost)
+{
+ USBH_Resp resp;
+ uint32_t size;
+
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ switch(USBH_MTP_Info.XferState)
+ {
+ case USBH_MTP_XFER_OP_REQ:
+ if(USBH_SendOutPacket(phost->Device.Address, USBH_MTP_Info.OutEp, USBH_MTP_Info.OutEpDATAX, (uint8_t *)&USBH_MTP_Info.op_container, USBH_MTP_Info.op_container.length))
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ_WAIT;
+ }
+ break;
+
+ case USBH_MTP_XFER_OP_REQ_WAIT:
+ resp = USBH_State();
+ if(resp == USBR_ACK)
+ {
+ USBH_MTP_Info.OutEpDATAX ^= 1;
+
+ if(USBH_MTP_Info.flags == PTP_DP_NODATA)
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_RESP;
+ }
+ else if(USBH_MTP_Info.flags == PTP_DP_SENDDATA)
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_DATA_OUT;
+ }
+ else if(USBH_MTP_Info.flags == PTP_DP_GETDATA)
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_DATA_IN;
+ }
+ }
+ else if(resp == USBR_NAK)
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ; // Resend Request
+ }
+ else if(resp == USBR_STALL)
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_ERROR;
+ }
+ break;
+
+ case USBH_MTP_XFER_DATA_OUT:
+ size = USBH_MTP_Info.data_len > USBH_MTP_Info.OutEpSize ? USBH_MTP_Info.OutEpSize : USBH_MTP_Info.data_len;
+ if(USBH_SendOutPacket(phost->Device.Address, USBH_MTP_Info.OutEp, USBH_MTP_Info.OutEpDATAX, USBH_MTP_Info.data_ptr, size))
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_DATA_OUT_WAIT;
+ }
+ break;
+
+ case USBH_MTP_XFER_DATA_OUT_WAIT:
+ resp = USBH_State();
+ if(resp == USBR_ACK)
+ {
+ USBH_MTP_Info.OutEpDATAX ^= 1;
+
+ if(USBH_MTP_Info.data_len > USBH_MTP_Info.OutEpSize)
+ {
+ USBH_MTP_Info.data_ptr += USBH_MTP_Info.OutEpSize;
+ USBH_MTP_Info.data_len -= USBH_MTP_Info.OutEpSize;
+ }
+ else
+ {
+ USBH_MTP_Info.data_len = 0;
+ }
+
+ if(USBH_MTP_Info.data_len > 0)
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_DATA_OUT;
+ }
+ else
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_RESP;
+ }
+ }
+ else if(resp == USBR_NAK)
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_DATA_OUT; // Resend same data
+
+ USBH_MTP_Info.state = USBH_MTP_EVENT_CHECK; // 从机返回 NAK 时,主机查询一下是否需要执行 Event 查询
+ }
+ else if(resp == USBR_STALL)
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_ERROR;
+ }
+ break;
+
+ case USBH_MTP_XFER_DATA_IN:
+ if(USBH_SendInPacket(phost->Device.Address, USBH_MTP_Info.InEp, USBH_MTP_Info.InEpDATAX, USBH_MTP_Info.InEpSize))
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_DATA_IN_WAIT;
+ }
+ break;
+
+ case USBH_MTP_XFER_DATA_IN_WAIT:
+ resp = USBH_State();
+ if(resp == USBR_ACK)
+ {
+ USBH_MTP_Info.InEpDATAX ^= 1;
+
+ uint32_t len = USBH_ReadRxBuffer(USBH_MTP_Info.data_ptr, USBH_MTP_Info.InEpSize);
+
+ if(USBH_MTP_Info.first_packet)
+ {
+ USBH_MTP_Info.data_len = *(uint32_t *)(void *)USBH_MTP_Info.data_ptr;
+
+ if(USBH_MTP_Info.first_packet == 3)
+ {
+ len -= PTP_USB_BULK_HDR_LEN;
+ USBH_MTP_Info.data_len -= PTP_USB_BULK_HDR_LEN;
+ memcpy(USBH_MTP_Info.data_ptr, USBH_MTP_Info.data_ptr + PTP_USB_BULK_HDR_LEN, len);
+ }
+
+ USBH_MTP_Info.first_packet = 0;
+ }
+
+ USBH_MTP_Info.data_ptr += len;
+ USBH_MTP_Info.data_len -= len;
+
+ if((USBH_MTP_Info.data_len > 0) || (len == USBH_MTP_Info.InEpSize))
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_DATA_IN;
+ }
+ else
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_RESP;
+ }
+ }
+ else if(resp == USBR_NAK)
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_DATA_IN;
+
+ USBH_MTP_Info.state = USBH_MTP_EVENT_CHECK; // 从机返回 NAK 时,主机查询一下是否需要执行 Event 查询
+ }
+ else if(resp == USBR_STALL)
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_ERROR;
+ }
+ break;
+
+ case USBH_MTP_XFER_RESP:
+ if(USBH_SendInPacket(phost->Device.Address, USBH_MTP_Info.InEp, USBH_MTP_Info.InEpDATAX, USBH_MTP_Info.InEpSize))
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_RESP_WAIT;
+ }
+ break;
+
+ case USBH_MTP_XFER_RESP_WAIT:
+ resp = USBH_State();
+ if(resp == USBR_ACK)
+ {
+ USBH_MTP_Info.InEpDATAX ^= 1;
+
+ USBH_ReadRxBuffer((uint8_t *)&USBH_MTP_Info.resp_container, USBH_MTP_Info.InEpSize);
+
+ if(USBH_MTP_Info.resp_container.code == PTP_RC_OK)
+ {
+ USBH_MTP_Info.XferStatus = USBH_OK;
+ }
+ else
+ {
+ USBH_MTP_Info.XferStatus = USBH_FAIL;
+ }
+ USBH_MTP_Info.state = USBH_MTP_Info.stateBkp;
+ }
+ else if(resp == USBR_NAK)
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_RESP;
+ }
+ else if(resp == USBR_STALL)
+ {
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_ERROR;
+ }
+ break;
+
+ case USBH_MTP_XFER_ERROR:
+ USBH_MTP_Info.XferStatus = USBH_FAIL;
+ USBH_MTP_Info.state = USBH_MTP_Info.stateBkp;
+ break;
+
+ default:
+ break;
+ }
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_GetDeviceInfo()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MTP_GetDeviceInfo(USBH_Info_t *phost, PTP_DeviceInfo_t *dev_info)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(USBH_MTP_Info.OpState)
+ {
+ case USBH_MTP_OP_SEND:
+ /* Set operation request type */
+ USBH_MTP_Info.flags = PTP_DP_GETDATA;
+ USBH_MTP_Info.data_ptr = (uint8_t *)(void *)&USBH_MTP_Info.data_container;
+ USBH_MTP_Info.data_len = 0;
+ USBH_MTP_Info.first_packet = 1;
+
+ /* Fill operation request params */
+ USBH_MTP_Info.op_container.type = PTP_USB_CONTAINER_COMMAND;
+ USBH_MTP_Info.op_container.code = PTP_OC_GetDeviceInfo;
+ USBH_MTP_Info.op_container.trans_id = USBH_MTP_Info.transaction_id++;
+ USBH_MTP_Info.op_container.length = PTP_USB_BULK_HDR_LEN + sizeof(uint32_t) * 0;
+
+ /* Setup State machine and start transfer */
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_WAIT;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_TRANSFER;
+ break;
+
+ case USBH_MTP_OP_WAIT:
+ if(USBH_MTP_Info.XferStatus != USBH_BUSY)
+ {
+ status = USBH_MTP_Info.XferStatus;
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+ }
+ if(status == USBH_OK)
+ {
+ PTP_DecodeDeviceInfo(phost, dev_info);
+ }
+ break;
+
+ default:
+ break;
+ }
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_OpenSession()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MTP_OpenSession(USBH_Info_t *phost, uint32_t session)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(USBH_MTP_Info.OpState)
+ {
+ case USBH_MTP_OP_SEND:
+ /* Init session params */
+ USBH_MTP_Info.transaction_id = 0x00000000U;
+ USBH_MTP_Info.session_id = session;
+ USBH_MTP_Info.flags = PTP_DP_NODATA;
+
+ /* Fill operation request params */
+ USBH_MTP_Info.op_container.type = PTP_USB_CONTAINER_COMMAND;
+ USBH_MTP_Info.op_container.code = PTP_OC_OpenSession;
+ USBH_MTP_Info.op_container.trans_id = USBH_MTP_Info.transaction_id++;
+ USBH_MTP_Info.op_container.param1 = session;
+ USBH_MTP_Info.op_container.length = PTP_USB_BULK_HDR_LEN + sizeof(uint32_t) * 1;
+
+ /* Setup State machine and start transfer */
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_WAIT;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_TRANSFER;
+ break;
+
+ case USBH_MTP_OP_WAIT:
+ if(USBH_MTP_Info.XferStatus != USBH_BUSY)
+ {
+ status = USBH_MTP_Info.XferStatus;
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_GetStorageIds()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MTP_GetStorageIds(USBH_Info_t *phost, PTP_StorageIDs_t *storage_ids)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(USBH_MTP_Info.OpState)
+ {
+ case USBH_MTP_OP_SEND:
+ /* Set operation request type */
+ USBH_MTP_Info.flags = PTP_DP_GETDATA;
+ USBH_MTP_Info.data_ptr = (uint8_t *)(void *)&USBH_MTP_Info.data_container;
+ USBH_MTP_Info.data_len = 0;
+ USBH_MTP_Info.first_packet = 1;
+
+ /* Fill operation request params */
+ USBH_MTP_Info.op_container.type = PTP_USB_CONTAINER_COMMAND;
+ USBH_MTP_Info.op_container.code = PTP_OC_GetStorageIDs;
+ USBH_MTP_Info.op_container.trans_id = USBH_MTP_Info.transaction_id++;
+ USBH_MTP_Info.op_container.length = PTP_USB_BULK_HDR_LEN + sizeof(uint32_t) * 0;
+
+ /* Setup State machine and start transfer */
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_WAIT;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_TRANSFER;
+ break;
+
+ case USBH_MTP_OP_WAIT:
+ if(USBH_MTP_Info.XferStatus != USBH_BUSY)
+ {
+ status = USBH_MTP_Info.XferStatus;
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+ }
+ if(status == USBH_OK)
+ {
+ storage_ids->n = PTP_GetArray32(storage_ids->Storage, USBH_MTP_Info.data_container.payload, 0U);
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_GetStorageInfo()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MTP_GetStorageInfo(USBH_Info_t *phost, uint32_t storage_id, PTP_StorageInfo_t *storage_info)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(USBH_MTP_Info.OpState)
+ {
+ case USBH_MTP_OP_SEND:
+ /* Set operation request type */
+ USBH_MTP_Info.flags = PTP_DP_GETDATA;
+ USBH_MTP_Info.data_ptr = (uint8_t *)(void *)&USBH_MTP_Info.data_container;
+ USBH_MTP_Info.data_len = 0;
+ USBH_MTP_Info.first_packet = 1;
+
+ /* Fill operation request params */
+ USBH_MTP_Info.op_container.type = PTP_USB_CONTAINER_COMMAND;
+ USBH_MTP_Info.op_container.code = PTP_OC_GetStorageInfo;
+ USBH_MTP_Info.op_container.trans_id = USBH_MTP_Info.transaction_id++;
+ USBH_MTP_Info.op_container.param1 = storage_id;
+ USBH_MTP_Info.op_container.length = PTP_USB_BULK_HDR_LEN + sizeof(uint32_t) * 1;
+
+ /* Setup State machine and start transfer */
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_WAIT;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_TRANSFER;
+ break;
+
+ case USBH_MTP_OP_WAIT:
+ if(USBH_MTP_Info.XferStatus != USBH_BUSY)
+ {
+ status = USBH_MTP_Info.XferStatus;
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+ }
+ if(status == USBH_OK)
+ {
+ PTP_DecodeStorageInfo(phost, storage_info);
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_GetNumObjects()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MTP_GetNumObjects(USBH_Info_t *phost, uint32_t storage_id, uint32_t format, uint32_t folder, uint32_t *numobs)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(USBH_MTP_Info.OpState)
+ {
+ case USBH_MTP_OP_SEND:
+ /* Set operation request type */
+ USBH_MTP_Info.flags = PTP_DP_NODATA;
+
+ /* Fill operation request params */
+ USBH_MTP_Info.op_container.type = PTP_USB_CONTAINER_COMMAND;
+ USBH_MTP_Info.op_container.code = PTP_OC_GetNumObjects;
+ USBH_MTP_Info.op_container.trans_id = USBH_MTP_Info.transaction_id++;
+ USBH_MTP_Info.op_container.param1 = storage_id;
+ USBH_MTP_Info.op_container.param2 = format;
+ USBH_MTP_Info.op_container.param3 = folder;
+ USBH_MTP_Info.op_container.length = PTP_USB_BULK_HDR_LEN + sizeof(uint32_t) * 3;
+
+ /* Setup State machine and start transfer */
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_WAIT;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_TRANSFER;
+ break;
+
+ case USBH_MTP_OP_WAIT:
+ if(USBH_MTP_Info.XferStatus != USBH_BUSY)
+ {
+ status = USBH_MTP_Info.XferStatus;
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+ }
+ if(status == USBH_OK)
+ {
+ *numobs = USBH_MTP_Info.resp_container.param1;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_GetObjectHandles()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MTP_GetObjectHandles(USBH_Info_t *phost, uint32_t storage_id, uint32_t format, uint32_t folder, PTP_ObjectHandles_t *handles)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(USBH_MTP_Info.OpState)
+ {
+ case USBH_MTP_OP_SEND:
+ /* Set operation request type */
+ USBH_MTP_Info.flags = PTP_DP_GETDATA;
+ USBH_MTP_Info.data_ptr = (uint8_t *)(void *)&USBH_MTP_Info.data_container;
+ USBH_MTP_Info.data_len = 0;
+ USBH_MTP_Info.first_packet = 1;
+
+ /* Fill operation request params */
+ USBH_MTP_Info.op_container.type = PTP_USB_CONTAINER_COMMAND;
+ USBH_MTP_Info.op_container.code = PTP_OC_GetObjectHandles;
+ USBH_MTP_Info.op_container.trans_id = USBH_MTP_Info.transaction_id++;
+ USBH_MTP_Info.op_container.param1 = storage_id;
+ USBH_MTP_Info.op_container.param2 = format;
+ USBH_MTP_Info.op_container.param3 = folder;
+ USBH_MTP_Info.op_container.length = PTP_USB_BULK_HDR_LEN + sizeof(uint32_t) * 3;
+
+ /* Setup State machine and start transfer */
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_WAIT;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_TRANSFER;
+ break;
+
+ case USBH_MTP_OP_WAIT:
+ if(USBH_MTP_Info.XferStatus != USBH_BUSY)
+ {
+ status = USBH_MTP_Info.XferStatus;
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+ }
+ if(status == USBH_OK)
+ {
+ handles->n = PTP_GetArray32(handles->Handler, USBH_MTP_Info.data_container.payload, 0U);
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_GetObjectInfo()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MTP_GetObjectInfo(USBH_Info_t *phost, uint32_t handle, PTP_ObjectInfo_t *object_info)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(USBH_MTP_Info.OpState)
+ {
+ case USBH_MTP_OP_SEND:
+ /* Set operation request type */
+ USBH_MTP_Info.flags = PTP_DP_GETDATA;
+ USBH_MTP_Info.data_ptr = (uint8_t *)(void *)&USBH_MTP_Info.data_container;
+ USBH_MTP_Info.data_len = 0;
+ USBH_MTP_Info.first_packet = 1;
+
+ /* Fill operation request params */
+ USBH_MTP_Info.op_container.type = PTP_USB_CONTAINER_COMMAND;
+ USBH_MTP_Info.op_container.code = PTP_OC_GetObjectInfo;
+ USBH_MTP_Info.op_container.trans_id = USBH_MTP_Info.transaction_id++;
+ USBH_MTP_Info.op_container.param1 = handle;
+ USBH_MTP_Info.op_container.length = PTP_USB_BULK_HDR_LEN + sizeof(uint32_t) * 1;
+
+ /* Setup State machine and start transfer */
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_WAIT;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_TRANSFER;
+ break;
+
+ case USBH_MTP_OP_WAIT:
+ if(USBH_MTP_Info.XferStatus != USBH_BUSY)
+ {
+ status = USBH_MTP_Info.XferStatus;
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+ }
+ if(status == USBH_OK)
+ {
+ PTP_DecodeObjectInfo(phost, object_info);
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_GetObject()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MTP_GetObject(USBH_Info_t *phost, uint32_t handle, uint8_t *object)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(USBH_MTP_Info.OpState)
+ {
+ case USBH_MTP_OP_SEND:
+ /* Set operation request type */
+ USBH_MTP_Info.flags = PTP_DP_GETDATA;
+ USBH_MTP_Info.data_ptr = object;
+ USBH_MTP_Info.data_len = 0;
+ USBH_MTP_Info.first_packet = 3;
+
+ /* Fill operation request params */
+ USBH_MTP_Info.op_container.type = PTP_USB_CONTAINER_COMMAND;
+ USBH_MTP_Info.op_container.code = PTP_OC_GetObject;
+ USBH_MTP_Info.op_container.trans_id = USBH_MTP_Info.transaction_id++;
+ USBH_MTP_Info.op_container.param1 = handle;
+ USBH_MTP_Info.op_container.length = PTP_USB_BULK_HDR_LEN + sizeof(uint32_t) * 1;
+
+ /* Setup State machine and start transfer */
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_WAIT;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_TRANSFER;
+ break;
+
+ case USBH_MTP_OP_WAIT:
+ if(USBH_MTP_Info.XferStatus != USBH_BUSY)
+ {
+ status = USBH_MTP_Info.XferStatus;
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_GetPartialObject()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MTP_GetPartialObject(USBH_Info_t *phost, uint32_t handle, uint32_t offset, uint32_t maxbytes, uint8_t *object, uint32_t *len)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(USBH_MTP_Info.OpState)
+ {
+ case USBH_MTP_OP_SEND:
+ /* Set operation request type */
+ USBH_MTP_Info.flags = PTP_DP_GETDATA;
+ USBH_MTP_Info.data_ptr = object;
+ USBH_MTP_Info.data_len = 0;
+ USBH_MTP_Info.first_packet = 3;
+
+ /* Fill operation request params */
+ USBH_MTP_Info.op_container.type = PTP_USB_CONTAINER_COMMAND;
+ USBH_MTP_Info.op_container.code = PTP_OC_GetPartialObject;
+ USBH_MTP_Info.op_container.trans_id = USBH_MTP_Info.transaction_id++;
+ USBH_MTP_Info.op_container.param1 = handle;
+ USBH_MTP_Info.op_container.param2 = offset;
+ USBH_MTP_Info.op_container.param3 = maxbytes;
+ USBH_MTP_Info.op_container.length = PTP_USB_BULK_HDR_LEN + sizeof(uint32_t) * 3;
+
+ /* Setup State machine and start transfer */
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_WAIT;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_TRANSFER;
+ break;
+
+ case USBH_MTP_OP_WAIT:
+ if(USBH_MTP_Info.XferStatus != USBH_BUSY)
+ {
+ status = USBH_MTP_Info.XferStatus;
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+ }
+ if(status == USBH_OK)
+ {
+ *len = USBH_MTP_Info.resp_container.param1;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_DeleteObject()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MTP_DeleteObject(USBH_Info_t *phost, uint32_t handle, uint32_t format)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(USBH_MTP_Info.OpState)
+ {
+ case USBH_MTP_OP_SEND:
+ /* Set operation request type */
+ USBH_MTP_Info.flags = PTP_DP_NODATA;
+
+ /* Fill operation request params */
+ USBH_MTP_Info.op_container.type = PTP_USB_CONTAINER_COMMAND;
+ USBH_MTP_Info.op_container.code = PTP_OC_DeleteObject;
+ USBH_MTP_Info.op_container.trans_id = USBH_MTP_Info.transaction_id++;
+ USBH_MTP_Info.op_container.param1 = handle;
+ USBH_MTP_Info.op_container.param2 = format;
+ USBH_MTP_Info.op_container.length = PTP_USB_BULK_HDR_LEN + sizeof(uint32_t) * 2;
+
+ /* Setup State machine and start transfer */
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_WAIT;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_TRANSFER;
+ break;
+
+ case USBH_MTP_OP_WAIT:
+ if(USBH_MTP_Info.XferStatus != USBH_BUSY)
+ {
+ status = USBH_MTP_Info.XferStatus;
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_SendObject()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MTP_SendObject(USBH_Info_t *phost, uint32_t handle, uint8_t *object, uint32_t size)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(USBH_MTP_Info.OpState)
+ {
+ case USBH_MTP_OP_SEND:
+ /* Set operation request type */
+ USBH_MTP_Info.flags = PTP_DP_SENDDATA;
+ USBH_MTP_Info.data_ptr = (uint8_t *)(void *)&USBH_MTP_Info.data_container;
+ USBH_MTP_Info.data_len = size + PTP_USB_BULK_HDR_LEN;
+ USBH_MTP_Info.first_packet = 1;
+
+ /* Fill operation request params */
+ USBH_MTP_Info.op_container.type = PTP_USB_CONTAINER_COMMAND;
+ USBH_MTP_Info.op_container.code = PTP_OC_SendObject;
+ USBH_MTP_Info.op_container.trans_id = USBH_MTP_Info.transaction_id++;
+ USBH_MTP_Info.op_container.length = PTP_USB_BULK_HDR_LEN + sizeof(uint32_t) * 0;
+
+ /* Fill data_container */
+ USBH_MTP_Info.data_container.length = USBH_MTP_Info.data_len;
+ USBH_MTP_Info.data_container.type = PTP_USB_CONTAINER_DATA;
+ USBH_MTP_Info.data_container.code = USBH_MTP_Info.op_container.code;
+ USBH_MTP_Info.data_container.trans_id = USBH_MTP_Info.op_container.trans_id;
+ memcpy(USBH_MTP_Info.data_container.payload, object, size);
+
+ /* Setup State machine and start transfer */
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_WAIT;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_TRANSFER;
+ break;
+
+ case USBH_MTP_OP_WAIT:
+ if(USBH_MTP_Info.XferStatus != USBH_BUSY)
+ {
+ status = USBH_MTP_Info.XferStatus;
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_GetDevicePropDesc()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MTP_GetDevicePropDesc(USBH_Info_t *phost, uint16_t propcode, PTP_DevicePropDesc_t *devicepropertydesc)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(USBH_MTP_Info.OpState)
+ {
+ case USBH_MTP_OP_SEND:
+ /* Set operation request type */
+ USBH_MTP_Info.flags = PTP_DP_GETDATA;
+ USBH_MTP_Info.data_ptr = (uint8_t *)(void *)&USBH_MTP_Info.data_container;
+ USBH_MTP_Info.data_len = 0;
+ USBH_MTP_Info.first_packet = 1;
+
+ /* Fill operation request params */
+ USBH_MTP_Info.op_container.type = PTP_USB_CONTAINER_COMMAND;
+ USBH_MTP_Info.op_container.code = PTP_OC_GetDevicePropDesc;
+ USBH_MTP_Info.op_container.trans_id = USBH_MTP_Info.transaction_id++;
+ USBH_MTP_Info.op_container.param1 = propcode;
+ USBH_MTP_Info.op_container.length = PTP_USB_BULK_HDR_LEN + sizeof(uint32_t) * 1;
+
+ /* Setup State machine and start transfer */
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_WAIT;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_TRANSFER;
+ break;
+
+ case USBH_MTP_OP_WAIT:
+ if(USBH_MTP_Info.XferStatus != USBH_BUSY)
+ {
+ status = USBH_MTP_Info.XferStatus;
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+ }
+ if(status == USBH_OK)
+ {
+ uint8_t *data = USBH_MTP_Info.data_container.payload;
+
+ devicepropertydesc->DevicePropertyCode = PTP_LE16(&data[PTP_dpd_DevicePropertyCode]);
+ devicepropertydesc->DataType = PTP_LE16(&data[PTP_dpd_DataType]);
+ devicepropertydesc->GetSet = *(uint8_t *)(&data[PTP_dpd_GetSet]);
+ devicepropertydesc->FormFlag = PTP_DPFF_None;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_GetObjectPropsSupported()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MTP_GetObjectPropsSupported(USBH_Info_t *phost, uint16_t ofc, uint32_t *propnum, uint16_t *props)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(USBH_MTP_Info.OpState)
+ {
+ case USBH_MTP_OP_SEND:
+ /* Set operation request type */
+ USBH_MTP_Info.flags = PTP_DP_GETDATA;
+ USBH_MTP_Info.data_ptr = (uint8_t *)(void *)&USBH_MTP_Info.data_container;
+ USBH_MTP_Info.data_len = 0;
+ USBH_MTP_Info.first_packet = 1;
+
+ /* Fill operation request params */
+ USBH_MTP_Info.op_container.type = PTP_USB_CONTAINER_COMMAND;
+ USBH_MTP_Info.op_container.code = PTP_OC_GetObjectPropsSupported;
+ USBH_MTP_Info.op_container.trans_id = USBH_MTP_Info.transaction_id++;
+ USBH_MTP_Info.op_container.param1 = ofc;
+ USBH_MTP_Info.op_container.length = PTP_USB_BULK_HDR_LEN + sizeof(uint32_t) * 1;
+
+ /* Setup State machine and start transfer */
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_WAIT;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_TRANSFER;
+ break;
+
+ case USBH_MTP_OP_WAIT:
+ if(USBH_MTP_Info.XferStatus != USBH_BUSY)
+ {
+ status = USBH_MTP_Info.XferStatus;
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+ }
+ if(status == USBH_OK)
+ {
+ *propnum = PTP_GetArray16(props, USBH_MTP_Info.data_container.payload, 0U);
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_GetObjectPropDesc()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MTP_GetObjectPropDesc(USBH_Info_t *phost, uint16_t opc, uint16_t ofc, PTP_ObjectPropDesc_t *opd)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(USBH_MTP_Info.OpState)
+ {
+ case USBH_MTP_OP_SEND:
+ /* Set operation request type */
+ USBH_MTP_Info.flags = PTP_DP_GETDATA;
+ USBH_MTP_Info.data_ptr = (uint8_t *)(void *)&USBH_MTP_Info.data_container;
+ USBH_MTP_Info.data_len = 0;
+ USBH_MTP_Info.first_packet = 1;
+
+ /* Fill operation request params */
+ USBH_MTP_Info.op_container.type = PTP_USB_CONTAINER_COMMAND;
+ USBH_MTP_Info.op_container.code = PTP_OC_GetObjectPropDesc;
+ USBH_MTP_Info.op_container.trans_id = USBH_MTP_Info.transaction_id++;
+ USBH_MTP_Info.op_container.param1 = opc;
+ USBH_MTP_Info.op_container.param2 = ofc;
+ USBH_MTP_Info.op_container.length = PTP_USB_BULK_HDR_LEN + sizeof(uint32_t) * 2;
+
+ /* Setup State machine and start transfer */
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_WAIT;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_TRANSFER;
+ break;
+
+ case USBH_MTP_OP_WAIT:
+ if(USBH_MTP_Info.XferStatus != USBH_BUSY)
+ {
+ status = USBH_MTP_Info.XferStatus;
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+ }
+ if(status == USBH_OK)
+ {
+ PTP_DecodeObjectPropDesc(phost, opd, USBH_MTP_Info.data_len);
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_GetObjectPropList()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_MTP_GetObjectPropList(USBH_Info_t *phost, uint32_t handle, MTP_Properties_t *pprops, uint32_t *nrofprops)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(USBH_MTP_Info.OpState)
+ {
+ case USBH_MTP_OP_SEND:
+ /* Set operation request type */
+ USBH_MTP_Info.flags = PTP_DP_GETDATA;
+ USBH_MTP_Info.data_ptr = (uint8_t *)(void *)&USBH_MTP_Info.data_container;
+ USBH_MTP_Info.data_len = 0;
+ USBH_MTP_Info.first_packet = 1;
+
+ /* Fill operation request params */
+ USBH_MTP_Info.op_container.type = PTP_USB_CONTAINER_COMMAND;
+ USBH_MTP_Info.op_container.code = PTP_OC_GetObjPropList;
+ USBH_MTP_Info.op_container.trans_id = USBH_MTP_Info.transaction_id++;
+ USBH_MTP_Info.op_container.param1 = handle;
+ USBH_MTP_Info.op_container.param2 = 0x00000000U; /* 0x00000000U should be "all formats" */
+ USBH_MTP_Info.op_container.param3 = 0xFFFFFFFFU; /* 0xFFFFFFFFU should be "all properties" */
+ USBH_MTP_Info.op_container.param4 = 0x00000000U;
+ USBH_MTP_Info.op_container.param5 = 0xFFFFFFFFU; /* Return full tree below the Param1 handle */
+ USBH_MTP_Info.op_container.length = PTP_USB_BULK_HDR_LEN + sizeof(uint32_t) * 5;
+
+ /* Setup State machine and start transfer */
+ USBH_MTP_Info.XferState = USBH_MTP_XFER_OP_REQ;
+ USBH_MTP_Info.OpState = USBH_MTP_OP_WAIT;
+
+ USBH_MTP_Info.stateReq = USBH_MTP_TRANSFER;
+ break;
+
+ case USBH_MTP_OP_WAIT:
+ if(USBH_MTP_Info.XferStatus != USBH_BUSY)
+ {
+ status = USBH_MTP_Info.XferStatus;
+ USBH_MTP_Info.XferStatus = USBH_BUSY;
+
+ USBH_MTP_Info.OpState = USBH_MTP_OP_SEND;
+ }
+ if(status == USBH_OK)
+ {
+ PTP_DecodeObjectPropList(phost, pprops, USBH_MTP_Info.data_len);
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_MTP_EventsCallback()
+* 功能说明: The function informs that host has received an event
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+__attribute__((weak)) void USBH_MTP_EventsCallback(USBH_Info_t *phost, uint32_t event, uint32_t param)
+{
+}
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp.h b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp.h
new file mode 100644
index 0000000000..f74a6e1f77
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp.h
@@ -0,0 +1,153 @@
+#ifndef __USBH_MTP_H__
+#define __USBH_MTP_H__
+
+#include "usbh_mtp_ptp.h"
+
+
+typedef enum {
+ USBH_MTP_IDLE = 0,
+ USBH_MTP_GETDEVICEINFO,
+ USBH_MTP_OPENSESSION,
+ USBH_MTP_GETSTORAGEIDS,
+ USBH_MTP_GETSTORAGEINFO,
+ USBH_MTP_TRANSFER,
+ USBH_MTP_EVENT,
+ USBH_MTP_EVENT_WAIT,
+
+ /* Events may be interleaved within a data stream during a transaction.
+ It may be assumed that the Operation Request Phase and Response Phase are atomic, but the Data Phase
+ must allow for events to be communicated in either direction without interrupting data transfer.
+ */
+ USBH_MTP_EVENT_CHECK,
+} USBH_MTP_State;
+
+typedef enum {
+ USBH_MTP_OP_IDLE = 0,
+ USBH_MTP_OP_SEND,
+ USBH_MTP_OP_WAIT,
+ USBH_MTP_OP_ERROR,
+} USBH_MTP_OpState;
+
+typedef enum {
+ USBH_MTP_XFER_IDLE = 0,
+ USBH_MTP_XFER_OP_REQ,
+ USBH_MTP_XFER_OP_REQ_WAIT,
+ USBH_MTP_XFER_DATA_OUT,
+ USBH_MTP_XFER_DATA_OUT_WAIT,
+ USBH_MTP_XFER_DATA_IN,
+ USBH_MTP_XFER_DATA_IN_WAIT,
+ USBH_MTP_XFER_RESP,
+ USBH_MTP_XFER_RESP_WAIT,
+ USBH_MTP_XFER_ERROR,
+} USBH_MTP_XferState;
+
+
+typedef struct {
+ uint32_t timer;
+ uint16_t poll;
+ PTP_EventContainer_t container;
+} MTP_EventHandle_t;
+
+
+typedef struct {
+ uint8_t InEp;
+ uint8_t OutEp;
+ uint8_t NotifyEp;
+ uint16_t InEpSize;
+ uint16_t OutEpSize;
+ uint16_t NotifyEpSize;
+ uint8_t InEpDATAX;
+ uint8_t OutEpDATAX;
+ uint8_t NotifyEpDATAX;
+
+ USBH_MTP_State state;
+ USBH_MTP_State stateReq;
+ USBH_MTP_State stateBkp;
+
+ USBH_MTP_OpState OpState;
+ USBH_MTP_XferState XferState;
+
+ USBH_Status XferStatus;
+
+ PTP_OpContainer_t op_container;
+ PTP_DataContainer_t data_container;
+ PTP_RespContainer_t resp_container;
+
+ uint32_t session_id;
+ uint32_t transaction_id;
+
+ uint32_t flags;
+
+ uint8_t *data_ptr;
+ uint32_t data_len;
+ uint8_t first_packet; // 1 数据第一帧 3 数据第一帧,且需丢弃 header 不存储
+
+ PTP_DeviceInfo_t devinfo;
+ PTP_StorageIDs_t storids;
+ PTP_StorageInfo_t storinfo[PTP_MAX_STORAGE_UNITS_NBR];
+
+ MTP_EventHandle_t events;
+
+ uint32_t CurrentStorage;
+ uint32_t is_ready;
+} USBH_MTP_Info_t;
+
+extern USBH_MTP_Info_t USBH_MTP_Info;
+
+
+static uint32_t USBH_MTP_Ready(void)
+{
+ return USBH_MTP_Info.is_ready;
+}
+
+static uint32_t USBH_MTP_StorageCount(void)
+{
+ return USBH_MTP_Info.storids.n;
+}
+
+static uint32_t USBH_MTP_Storage(uint32_t index)
+{
+ return USBH_MTP_Info.storids.Storage[index];
+}
+
+
+USBH_Status USBH_MTP_GetDeviceInfo(USBH_Info_t *phost, PTP_DeviceInfo_t *dev_info);
+
+USBH_Status USBH_MTP_OpenSession(USBH_Info_t *phost, uint32_t session);
+
+USBH_Status USBH_MTP_GetStorageIds(USBH_Info_t *phost, PTP_StorageIDs_t *storage_ids);
+USBH_Status USBH_MTP_GetStorageInfo(USBH_Info_t *phost, uint32_t storage_id, PTP_StorageInfo_t *storage_info);
+
+USBH_Status USBH_MTP_GetNumObjects(USBH_Info_t *phost, uint32_t storage_id, uint32_t format, uint32_t folder, uint32_t *numobs);
+USBH_Status USBH_MTP_GetObjectHandles(USBH_Info_t *phost, uint32_t storage_id, uint32_t format, uint32_t folder, PTP_ObjectHandles_t *handles);
+
+USBH_Status USBH_MTP_GetObjectInfo(USBH_Info_t *phost, uint32_t handle, PTP_ObjectInfo_t *object_info);
+
+USBH_Status USBH_MTP_GetObject(USBH_Info_t *phost, uint32_t handle, uint8_t *object);
+USBH_Status USBH_MTP_GetPartialObject(USBH_Info_t *phost, uint32_t handle, uint32_t offset, uint32_t maxbytes, uint8_t *object, uint32_t *len);
+
+USBH_Status USBH_MTP_DeleteObject(USBH_Info_t *phost, uint32_t handle, uint32_t format);
+USBH_Status USBH_MTP_SendObject(USBH_Info_t *phost, uint32_t handle, uint8_t *object, uint32_t size);
+
+USBH_Status USBH_MTP_GetDevicePropDesc(USBH_Info_t *phost, uint16_t propcode, PTP_DevicePropDesc_t *devicepropertydesc);
+
+USBH_Status USBH_MTP_GetObjectPropsSupported(USBH_Info_t *phost, uint16_t ofc, uint32_t *propnum, uint16_t *props);
+USBH_Status USBH_MTP_GetObjectPropDesc(USBH_Info_t *phost, uint16_t opc, uint16_t ofc, PTP_ObjectPropDesc_t *opd);
+USBH_Status USBH_MTP_GetObjectPropList(USBH_Info_t *phost, uint32_t handle, MTP_Properties_t *pprops, uint32_t *nrofprops);
+
+
+void USBH_MTP_EventsCallback(USBH_Info_t *phost, uint32_t event, uint32_t param);
+
+
+#define USBH_TObreak(ms) \
+ { \
+ static int start; \
+ start = USBH->FRAMENR; \
+ if(abs((int)USBH->FRAMENR - start) > ms) \
+ { \
+ break; \
+ } \
+ }
+
+
+#endif // __USBH_MTP_H__
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp_ptp.c b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp_ptp.c
new file mode 100644
index 0000000000..42fed1eb28
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp_ptp.c
@@ -0,0 +1,376 @@
+/******************************************************************************************************************************************
+* 文件名称: usbh_mtp.c
+* 功能说明: This file includes the PTP operations layer.
+* 技术支持: http://www.synwit.com.cn/e/tool/gbook/?bid=1
+* 注意事项:
+* 版本日期: V1.1.0 2020年11月3日
+* 升级记录:
+*
+*
+*******************************************************************************************************************************************
+* @attention
+*
+* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS WITH CODING INFORMATION
+* REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. AS A RESULT, SYNWIT SHALL NOT BE HELD LIABLE
+* FOR ANY DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+* OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION CONTAINED HEREIN IN CONN-
+* -ECTION WITH THEIR PRODUCTS.
+*
+* COPYRIGHT 2012 Synwit Technology
+*******************************************************************************************************************************************/
+#include <string.h>
+#include "SWM341.h"
+#include "usbh_core.h"
+#include "usbh_mtp.h"
+
+
+/******************************************************************************************************************************************
+* 函数名称: PTP_GetDevicePropValue()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void PTP_GetDevicePropValue(USBH_Info_t *phost, uint32_t *offset, uint32_t total, PTP_PropertyValue_t *value, uint16_t datatype)
+{
+ uint8_t *data = USBH_MTP_Info.data_container.payload;
+ uint16_t len;
+ switch(datatype)
+ {
+ case PTP_DTC_INT8:
+ value->i8 = *(int8_t *)(void *) & (data[*offset]);
+ *offset += 1U;
+ break;
+
+ case PTP_DTC_UINT8:
+ value->u8 = *(uint8_t *) & (data[*offset]);
+ *offset += 1U;
+ break;
+
+ case PTP_DTC_INT16:
+ value->i16 = *(int16_t *)(void *) & (data[*offset]);
+ *offset += 2U;
+ break;
+
+ case PTP_DTC_UINT16:
+ value->u16 = PTP_LE16(&(data[*offset]));
+ *offset += 2U;
+ break;
+
+ case PTP_DTC_INT32:
+ value->i32 = *(int32_t *)(void *)(&(data[*offset]));
+ *offset += 4U;
+ break;
+
+ case PTP_DTC_UINT32:
+ value->u32 = PTP_LE32(&(data[*offset]));
+ *offset += 4U;
+ break;
+
+ case PTP_DTC_INT64:
+ value->i64 = *(int64_t *)(void *)(&(data[*offset]));
+ *offset += 8U;
+ break;
+
+ case PTP_DTC_UINT64:
+ value->u64 = PTP_LE64(&(data[*offset]));
+ *offset += 8U;
+ break;
+
+ case PTP_DTC_UINT128:
+ *offset += 16U;
+ break;
+
+ case PTP_DTC_INT128:
+ *offset += 16U;
+ break;
+
+ case PTP_DTC_STR:
+ PTP_GetString((uint8_t *)(void *)value->str, (uint8_t *) & (data[*offset]), &len);
+ *offset += (uint32_t)(len * 2U) + 1U;
+ break;
+
+ default:
+ break;
+ }
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: PTP_GetString()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void PTP_GetString(uint8_t *str, uint8_t *data, uint16_t *len)
+{
+ uint16_t strlength;
+ uint16_t idx;
+
+ *len = data[0];
+ strlength = (uint16_t)(2U * (uint32_t)data[0]);
+ data ++; /* Adjust the offset ignoring the String Len */
+
+ for (idx = 0U; idx < strlength; idx += 2U)
+ {
+ /* Copy Only the string and ignore the UNICODE ID, hence add the src */
+ *str = data[idx];
+ str++;
+ }
+ *str = 0U; /* mark end of string */
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: PTP_GetArray16()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+uint32_t PTP_GetArray16(uint16_t *array, uint8_t *data, uint32_t offset)
+{
+ uint32_t size, idx = 0U;
+
+ size = PTP_LE32(&data[offset]);
+ while(size > idx)
+ {
+ array[idx] = (uint16_t)data[offset + (sizeof(uint16_t) * (idx + 2U))];
+ idx++;
+ }
+ return size;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: PTP_GetArray32()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+uint32_t PTP_GetArray32(uint32_t *array, uint8_t *data, uint32_t offset)
+{
+ uint32_t size, idx = 0U;
+
+ size = PTP_LE32(&data[offset]);
+ while(size > idx)
+ {
+ array[idx] = PTP_LE32(&data[offset + (sizeof(uint32_t) * (idx + 1U))]);
+ idx++;
+ }
+ return size;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: PTP_DecodeDeviceInfo()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void PTP_DecodeDeviceInfo(USBH_Info_t *phost, PTP_DeviceInfo_t *dev_info)
+{
+ uint8_t *data = USBH_MTP_Info.data_container.payload;
+ uint32_t totallen;
+ uint16_t len;
+
+ dev_info->StandardVersion = PTP_LE16(&data[PTP_di_StandardVersion]);
+ dev_info->VendorExtensionID = PTP_LE32(&data[PTP_di_VendorExtensionID]);
+ dev_info->VendorExtensionVersion = PTP_LE16(&data[PTP_di_VendorExtensionVersion]);
+ PTP_GetString(dev_info->VendorExtensionDesc, &data[PTP_di_VendorExtensionDesc], &len);
+
+ totallen = (uint32_t)(len * 2U) + 1U;
+ dev_info->FunctionalMode = PTP_LE16(&data[PTP_di_FunctionalMode + totallen]);
+ dev_info->OperationsSupportedNbr = PTP_GetArray16((uint16_t *)(void *)&dev_info->OperationsSupported, data, PTP_di_OperationsSupported + totallen);
+
+ totallen = totallen + (dev_info->OperationsSupportedNbr * sizeof(uint16_t)) + sizeof(uint32_t);
+ dev_info->EventsSupportedNbr = PTP_GetArray16((uint16_t *)(void *)&dev_info->EventsSupported, data, PTP_di_OperationsSupported + totallen);
+
+ totallen = totallen + (dev_info->EventsSupportedNbr * sizeof(uint16_t)) + sizeof(uint32_t);
+ dev_info->DevicePropertiesSupportedNbr = PTP_GetArray16((uint16_t *)(void *)&dev_info->DevicePropertiesSupported, data, PTP_di_OperationsSupported + totallen);
+
+ totallen = totallen + (dev_info->DevicePropertiesSupportedNbr * sizeof(uint16_t)) + sizeof(uint32_t);
+
+ dev_info->CaptureFormatsNbr = PTP_GetArray16((uint16_t *)(void *)&dev_info->CaptureFormats, data, PTP_di_OperationsSupported + totallen);
+
+ totallen = totallen + (dev_info->CaptureFormatsNbr * sizeof(uint16_t)) + sizeof(uint32_t);
+ dev_info->ImageFormatsNbr = PTP_GetArray16((uint16_t *)(void *)&dev_info->ImageFormats, data, PTP_di_OperationsSupported + totallen);
+
+ totallen = totallen + (dev_info->ImageFormatsNbr * sizeof(uint16_t)) + sizeof(uint32_t);
+ PTP_GetString(dev_info->Manufacturer, &data[PTP_di_OperationsSupported + totallen], &len);
+
+ totallen += (uint32_t)(len * 2U) + 1U;
+ PTP_GetString(dev_info->Model, &data[PTP_di_OperationsSupported + totallen], &len);
+
+ totallen += (uint32_t)(len * 2U) + 1U;
+ PTP_GetString(dev_info->DeviceVersion, &data[PTP_di_OperationsSupported + totallen], &len);
+
+ totallen += (uint32_t)(len * 2U) + 1U;
+ PTP_GetString(dev_info->SerialNumber, &data[PTP_di_OperationsSupported + totallen], &len);
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: PTP_DecodeStorageInfo()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void PTP_DecodeStorageInfo(USBH_Info_t *phost, PTP_StorageInfo_t *storage_info)
+{
+ uint8_t *data = USBH_MTP_Info.data_container.payload;
+ uint16_t len;
+
+ storage_info->StorageType = PTP_LE16(&data[PTP_si_StorageType]);
+ storage_info->FilesystemType = PTP_LE16(&data[PTP_si_FilesystemType]);
+ storage_info->AccessCapability = PTP_LE16(&data[PTP_si_AccessCapability]);
+ storage_info->MaxCapability = PTP_LE64(&data[PTP_si_MaxCapability]);
+ storage_info->FreeSpaceInBytes = PTP_LE64(&data[PTP_si_FreeSpaceInBytes]);
+ storage_info->FreeSpaceInImages = PTP_LE32(&data[PTP_si_FreeSpaceInImages]);
+
+ PTP_GetString(storage_info->StorageDescription, &data[PTP_si_StorageDescription], &len);
+ PTP_GetString(storage_info->VolumeLabel, &data[PTP_si_StorageDescription + (len * 2U) + 1U], &len);
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: PTP_DecodeObjectInfo()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void PTP_DecodeObjectInfo(USBH_Info_t *phost, PTP_ObjectInfo_t *object_info)
+{
+ uint8_t *data = USBH_MTP_Info.data_container.payload;
+ uint16_t filenamelen;
+
+ object_info->StorageID = PTP_LE32(&data[PTP_oi_StorageID]);
+ object_info->ObjectFormat = PTP_LE16(&data[PTP_oi_ObjectFormat]);
+ object_info->ProtectionStatus = PTP_LE16(&data[PTP_oi_ProtectionStatus]);
+ object_info->ObjectCompressedSize = PTP_LE64(&data[PTP_oi_ObjectCompressedSize]);
+
+ /* For Samsung Galaxy */
+ if((data[PTP_oi_filenamelen] == 0U) && (data[PTP_oi_filenamelen + 4U] != 0U))
+ {
+ data += 4;
+ }
+ object_info->ThumbFormat = PTP_LE16(&data[PTP_oi_ThumbFormat]);
+ object_info->ThumbCompressedSize = PTP_LE32(&data[PTP_oi_ThumbCompressedSize]);
+ object_info->ThumbPixWidth = PTP_LE32(&data[PTP_oi_ThumbPixWidth]);
+ object_info->ThumbPixHeight = PTP_LE32(&data[PTP_oi_ThumbPixHeight]);
+ object_info->ImagePixWidth = PTP_LE32(&data[PTP_oi_ImagePixWidth]);
+ object_info->ImagePixHeight = PTP_LE32(&data[PTP_oi_ImagePixHeight]);
+ object_info->ImageBitDepth = PTP_LE32(&data[PTP_oi_ImageBitDepth]);
+ object_info->ParentObject = PTP_LE32(&data[PTP_oi_ParentObject]);
+ object_info->AssociationType = PTP_LE16(&data[PTP_oi_AssociationType]);
+ object_info->AssociationDesc = PTP_LE32(&data[PTP_oi_AssociationDesc]);
+ object_info->SequenceNumber = PTP_LE32(&data[PTP_oi_SequenceNumber]);
+ PTP_GetString(object_info->Filename, &data[PTP_oi_filenamelen], &filenamelen);
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: PTP_DecodeObjectPropDesc()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void PTP_DecodeObjectPropDesc(USBH_Info_t *phost, PTP_ObjectPropDesc_t *opd, uint32_t opdlen)
+{
+ uint8_t *data = USBH_MTP_Info.data_container.payload;
+ uint32_t offset = 0U, i;
+
+ opd->ObjectPropertyCode = PTP_LE16(&data[PTP_opd_ObjectPropertyCode]);
+ opd->DataType = PTP_LE16(&data[PTP_opd_DataType]);
+ opd->GetSet = *(uint8_t *)(&data[PTP_opd_GetSet]);
+
+ offset = PTP_opd_FactoryDefaultValue;
+ PTP_GetDevicePropValue(phost, &offset, opdlen, &opd->FactoryDefaultValue, opd->DataType);
+
+ opd->GroupCode = PTP_LE32(&data[offset]);
+ offset += sizeof(uint32_t);
+
+ opd->FormFlag = *(uint8_t *)(&data[offset]);
+ offset += sizeof(uint8_t);
+
+ switch(opd->FormFlag)
+ {
+ case PTP_OPFF_Range:
+ PTP_GetDevicePropValue(phost, &offset, opdlen, &opd->FORM.Range.MinimumValue, opd->DataType);
+ PTP_GetDevicePropValue(phost, &offset, opdlen, &opd->FORM.Range.MaximumValue, opd->DataType);
+ PTP_GetDevicePropValue(phost, &offset, opdlen, &opd->FORM.Range.StepSize, opd->DataType);
+ break;
+
+ case PTP_OPFF_Enumeration:
+ opd->FORM.Enum.NumberOfValues = PTP_LE16(&data[offset]);
+ offset += sizeof(uint16_t);
+
+ for(i = 0U; i < opd->FORM.Enum.NumberOfValues ; i++)
+ {
+ PTP_GetDevicePropValue(phost, &offset, opdlen, &opd->FORM.Enum.SupportedValue[i], opd->DataType);
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: PTP_DecodeObjectPropList()
+* 功能说明:
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+uint32_t PTP_DecodeObjectPropList(USBH_Info_t *phost, MTP_Properties_t *props, uint32_t len)
+{
+ uint8_t *data = USBH_MTP_Info.data_container.payload;
+ uint32_t prop_count;
+ uint32_t offset = 0U, i;
+
+ prop_count = PTP_LE32(data);
+ if(prop_count == 0U)
+ {
+ return 0;
+ }
+
+ data += sizeof(uint32_t);
+ len -= sizeof(uint32_t);
+
+ for(i = 0U; i < prop_count; i++)
+ {
+ if(len <= 0U)
+ {
+ return 0;
+ }
+
+ props[i].ObjectHandle = PTP_LE32(data);
+ data += sizeof(uint32_t);
+ len -= sizeof(uint32_t);
+
+ props[i].property = PTP_LE16(data);
+ data += sizeof(uint16_t);
+ len -= sizeof(uint16_t);
+
+ props[i].datatype = PTP_LE16(data);
+ data += sizeof(uint16_t);
+ len -= sizeof(uint16_t);
+
+ offset = 0U;
+
+ PTP_GetDevicePropValue(phost, &offset, len, &props[i].propval, props[i].datatype);
+
+ data += offset;
+ len -= offset;
+ }
+
+ return prop_count;
+}
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp_ptp.h b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp_ptp.h
new file mode 100644
index 0000000000..aee37df260
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/MTP/usbh_mtp_ptp.h
@@ -0,0 +1,758 @@
+#ifndef __USBH_MTP_PTP_H__
+#define __USBH_MTP_PTP_H__
+
+#include <stdint.h>
+
+#define PTP_USB_BULK_HDR_LEN ((2 * sizeof(uint32_t)) + (2 * sizeof(uint16_t)))
+
+typedef struct {
+ uint32_t length;
+ uint16_t type;
+ uint16_t code;
+ uint32_t trans_id;
+ uint32_t param1;
+ uint32_t param2;
+ uint32_t param3;
+ uint32_t param4;
+ uint32_t param5;
+} PTP_OpContainer_t;
+
+typedef struct {
+ uint32_t length;
+ uint16_t type;
+ uint16_t code;
+ uint32_t trans_id;
+ uint8_t payload[4096];
+} PTP_DataContainer_t;
+
+typedef struct {
+ uint32_t length;
+ uint16_t type;
+ uint16_t code;
+ uint32_t trans_id;
+ uint32_t param1;
+ uint32_t param2;
+ uint32_t param3;
+ uint32_t param4;
+ uint32_t param5;
+} PTP_RespContainer_t;
+
+/* PTP USB Asynchronous Event Interrupt Data Format */
+typedef struct {
+ uint32_t length;
+ uint16_t type;
+ uint16_t code;
+ uint32_t trans_id;
+ uint32_t param1;
+ uint32_t param2;
+ uint32_t param3;
+} PTP_EventContainer_t;
+
+
+/* Operation Codes */
+
+/* PTP v1.0 operation codes */
+#define PTP_OC_Undefined 0x1000U
+#define PTP_OC_GetDeviceInfo 0x1001U
+#define PTP_OC_OpenSession 0x1002U
+#define PTP_OC_CloseSession 0x1003U
+#define PTP_OC_GetStorageIDs 0x1004U
+#define PTP_OC_GetStorageInfo 0x1005U
+#define PTP_OC_GetNumObjects 0x1006U
+#define PTP_OC_GetObjectHandles 0x1007U
+#define PTP_OC_GetObjectInfo 0x1008U
+#define PTP_OC_GetObject 0x1009U
+#define PTP_OC_GetThumb 0x100AU
+#define PTP_OC_DeleteObject 0x100BU
+#define PTP_OC_SendObjectInfo 0x100CU
+#define PTP_OC_SendObject 0x100DU
+#define PTP_OC_InitiateCapture 0x100EU
+#define PTP_OC_FormatStore 0x100FU
+#define PTP_OC_ResetDevice 0x1010U
+#define PTP_OC_SelfTest 0x1011U
+#define PTP_OC_SetObjectProtection 0x1012U
+#define PTP_OC_PowerDown 0x1013U
+#define PTP_OC_GetDevicePropDesc 0x1014U
+#define PTP_OC_GetDevicePropValue 0x1015U
+#define PTP_OC_SetDevicePropValue 0x1016U
+#define PTP_OC_ResetDevicePropValue 0x1017U
+#define PTP_OC_TerminateOpenCapture 0x1018U
+#define PTP_OC_MoveObject 0x1019U
+#define PTP_OC_CopyObject 0x101AU
+#define PTP_OC_GetPartialObject 0x101BU
+#define PTP_OC_InitiateOpenCapture 0x101CU
+
+/* PTP v1.1 operation codes */
+#define PTP_OC_StartEnumHandles 0x101DU
+#define PTP_OC_EnumHandles 0x101EU
+#define PTP_OC_StopEnumHandles 0x101FU
+#define PTP_OC_GetVendorExtensionMaps 0x1020U
+#define PTP_OC_GetVendorDeviceInfo 0x1021U
+#define PTP_OC_GetResizedImageObject 0x1022U
+#define PTP_OC_GetFilesystemManifest 0x1023U
+#define PTP_OC_GetStreamInfo 0x1024U
+#define PTP_OC_GetStream 0x1025U
+
+/* Microsoft / MTP extension codes */
+#define PTP_OC_GetObjectPropsSupported 0x9801U
+#define PTP_OC_GetObjectPropDesc 0x9802U
+#define PTP_OC_GetObjectPropValue 0x9803U
+#define PTP_OC_SetObjectPropValue 0x9804U
+#define PTP_OC_GetObjPropList 0x9805U
+#define PTP_OC_SetObjPropList 0x9806U
+#define PTP_OC_GetInterdependendPropdesc 0x9807U
+#define PTP_OC_SendObjectPropList 0x9808U
+#define PTP_OC_GetObjectReferences 0x9810U
+#define PTP_OC_SetObjectReferences 0x9811U
+#define PTP_OC_UpdateDeviceFirmware 0x9812U
+#define PTP_OC_Skip 0x9820U
+
+
+/* Response Codes */
+
+/* PTP v1.0 response codes */
+#define PTP_RC_Undefined 0x2000U
+#define PTP_RC_OK 0x2001U
+#define PTP_RC_GeneralError 0x2002U
+#define PTP_RC_SessionNotOpen 0x2003U
+#define PTP_RC_InvalidTransactionID 0x2004U
+#define PTP_RC_OperationNotSupported 0x2005U
+#define PTP_RC_ParameterNotSupported 0x2006U
+#define PTP_RC_IncompleteTransfer 0x2007U
+#define PTP_RC_InvalidStorageId 0x2008U
+#define PTP_RC_InvalidObjectHandle 0x2009U
+#define PTP_RC_DevicePropNotSupported 0x200AU
+#define PTP_RC_InvalidObjectFormatCode 0x200BU
+#define PTP_RC_StoreFull 0x200CU
+#define PTP_RC_ObjectWriteProtected 0x200DU
+#define PTP_RC_StoreReadOnly 0x200EU
+#define PTP_RC_AccessDenied 0x200FU
+#define PTP_RC_NoThumbnailPresent 0x2010U
+#define PTP_RC_SelfTestFailed 0x2011U
+#define PTP_RC_PartialDeletion 0x2012U
+#define PTP_RC_StoreNotAvailable 0x2013U
+#define PTP_RC_SpecByFormatUnsupported 0x2014U
+#define PTP_RC_NoValidObjectInfo 0x2015U
+#define PTP_RC_InvalidCodeFormat 0x2016U
+#define PTP_RC_UnknownVendorCode 0x2017U
+#define PTP_RC_CaptureAlreadyTerminated 0x2018U
+#define PTP_RC_DeviceBusy 0x2019U
+#define PTP_RC_InvalidParentObject 0x201AU
+#define PTP_RC_InvalidDevicePropFormat 0x201BU
+#define PTP_RC_InvalidDevicePropValue 0x201CU
+#define PTP_RC_InvalidParameter 0x201DU
+#define PTP_RC_SessionAlreadyOpened 0x201EU
+#define PTP_RC_TransactionCanceled 0x201FU
+#define PTP_RC_SpecOfDestinationUnsupported 0x2020U
+
+/* PTP v1.1 response codes */
+#define PTP_RC_InvalidEnumHandle 0x2021U
+#define PTP_RC_NoStreamEnabled 0x2022U
+#define PTP_RC_InvalidDataSet 0x2023U
+
+
+/* USB container types */
+#define PTP_USB_CONTAINER_UNDEFINED 0x0000U
+#define PTP_USB_CONTAINER_COMMAND 0x0001U
+#define PTP_USB_CONTAINER_DATA 0x0002U
+#define PTP_USB_CONTAINER_RESPONSE 0x0003U
+#define PTP_USB_CONTAINER_EVENT 0x0004U
+
+
+/* Transaction data phase description */
+#define PTP_DP_NODATA 0x0000U // no data phase
+#define PTP_DP_SENDDATA 0x0001U // sending data
+#define PTP_DP_GETDATA 0x0002U // receiving data
+#define PTP_DP_DATA_MASK 0x00ffU // data phase mask
+
+
+/* DeviceInfo data offset */
+#define PTP_di_StandardVersion 0U
+#define PTP_di_VendorExtensionID 2U
+#define PTP_di_VendorExtensionVersion 6U
+#define PTP_di_VendorExtensionDesc 8U
+#define PTP_di_FunctionalMode 8U
+#define PTP_di_OperationsSupported 10U
+
+/* Max info items size */
+#define PTP_SUPPORTED_OPERATIONS_NBR 100U
+#define PTP_SUPPORTED_EVENTS_NBR 100U
+#define PTP_SUPPORTED_PROPRIETIES_NBR 100U
+#define PTP_CAPTURE_FORMATS_NBR 100U
+#define PTP_IMAGE_FORMATS_NBR 100U
+#define PTP_MAX_STR_SIZE 255U
+
+/* PTP device info structure */
+typedef struct {
+ uint16_t StandardVersion;
+ uint32_t VendorExtensionID;
+ uint16_t VendorExtensionVersion;
+ uint8_t VendorExtensionDesc[PTP_MAX_STR_SIZE];
+ uint16_t FunctionalMode;
+ uint32_t OperationsSupportedNbr;
+ uint16_t OperationsSupported[PTP_SUPPORTED_OPERATIONS_NBR];
+ uint32_t EventsSupportedNbr;
+ uint16_t EventsSupported[PTP_SUPPORTED_EVENTS_NBR];
+ uint32_t DevicePropertiesSupportedNbr;
+ uint16_t DevicePropertiesSupported[PTP_SUPPORTED_PROPRIETIES_NBR];
+ uint32_t CaptureFormatsNbr;
+ uint16_t CaptureFormats[PTP_CAPTURE_FORMATS_NBR];
+ uint32_t ImageFormatsNbr;
+ uint16_t ImageFormats[PTP_IMAGE_FORMATS_NBR];
+ uint8_t Manufacturer[PTP_MAX_STR_SIZE];
+ uint8_t Model[PTP_MAX_STR_SIZE];
+ uint8_t DeviceVersion[PTP_MAX_STR_SIZE];
+ uint8_t SerialNumber[PTP_MAX_STR_SIZE];
+} PTP_DeviceInfo_t;
+
+
+#define PTP_MAX_STORAGE_UNITS_NBR 3
+
+/* PTP storageIDs structute (returned by GetStorageIDs) */
+typedef struct {
+ uint32_t n;
+ uint32_t Storage[PTP_MAX_STORAGE_UNITS_NBR];
+} PTP_StorageIDs_t;
+
+
+/* PTP StorageInfo structure (returned by GetStorageInfo) */
+#define PTP_si_StorageType 0U
+#define PTP_si_FilesystemType 2U
+#define PTP_si_AccessCapability 4U
+#define PTP_si_MaxCapability 6U
+#define PTP_si_FreeSpaceInBytes 14U
+#define PTP_si_FreeSpaceInImages 22U
+#define PTP_si_StorageDescription 26U
+
+/* PTP Storage Types */
+#define PTP_ST_Undefined 0x0000U
+#define PTP_ST_FixedROM 0x0001U
+#define PTP_ST_RemovableROM 0x0002U
+#define PTP_ST_FixedRAM 0x0003U
+#define PTP_ST_RemovableRAM 0x0004U
+
+/* PTP FilesystemType Values */
+#define PTP_FST_Undefined 0x0000U
+#define PTP_FST_GenericFlat 0x0001U
+#define PTP_FST_GenericHierarchical 0x0002U
+#define PTP_FST_DCF 0x0003U
+
+/* PTP StorageInfo AccessCapability Values */
+#define PTP_AC_ReadWrite 0x0000U
+#define PTP_AC_ReadOnly 0x0001U
+#define PTP_AC_ReadOnly_with_Object_Deletion 0x0002U
+
+typedef struct {
+ uint16_t StorageType;
+ uint16_t FilesystemType;
+ uint16_t AccessCapability;
+ uint64_t MaxCapability;
+ uint64_t FreeSpaceInBytes;
+ uint32_t FreeSpaceInImages;
+ uint8_t StorageDescription[PTP_MAX_STR_SIZE];
+ uint8_t VolumeLabel[PTP_MAX_STR_SIZE];
+} PTP_StorageInfo_t;
+
+
+/* PTP Object Format Codes */
+/* ancillary formats */
+#define PTP_OFC_Undefined 0x3000U
+#define PTP_OFC_Defined 0x3800U
+#define PTP_OFC_Association 0x3001U
+#define PTP_OFC_Script 0x3002U
+#define PTP_OFC_Executable 0x3003U
+#define PTP_OFC_Text 0x3004U
+#define PTP_OFC_HTML 0x3005U
+#define PTP_OFC_DPOF 0x3006U
+#define PTP_OFC_AIFF 0x3007U
+#define PTP_OFC_WAV 0x3008U
+#define PTP_OFC_MP3 0x3009U
+#define PTP_OFC_AVI 0x300AU
+#define PTP_OFC_MPEG 0x300BU
+#define PTP_OFC_ASF 0x300CU
+#define PTP_OFC_QT 0x300DU /* guessing */
+/* image formats */
+#define PTP_OFC_EXIF_JPEG 0x3801U
+#define PTP_OFC_TIFF_EP 0x3802U
+#define PTP_OFC_FlashPix 0x3803U
+#define PTP_OFC_BMP 0x3804U
+#define PTP_OFC_CIFF 0x3805U
+#define PTP_OFC_Undefined_0x3806 0x3806U
+#define PTP_OFC_GIF 0x3807U
+#define PTP_OFC_JFIF 0x3808U
+#define PTP_OFC_PCD 0x3809U
+#define PTP_OFC_PICT 0x380AU
+#define PTP_OFC_PNG 0x380BU
+#define PTP_OFC_Undefined_0x380C 0x380CU
+#define PTP_OFC_TIFF 0x380DU
+#define PTP_OFC_TIFF_IT 0x380EU
+#define PTP_OFC_JP2 0x380FU
+#define PTP_OFC_JPX 0x3810U
+/* ptp v1.1 has only DNG new */
+#define PTP_OFC_DNG 0x3811U
+
+/* MTP extensions */
+#define PTP_OFC_MTP_MediaCard 0xb211U
+#define PTP_OFC_MTP_MediaCardGroup 0xb212U
+#define PTP_OFC_MTP_Encounter 0xb213U
+#define PTP_OFC_MTP_EncounterBox 0xb214U
+#define PTP_OFC_MTP_M4A 0xb215U
+#define PTP_OFC_MTP_ZUNEUNDEFINED 0xb217U/* Unknown file type */
+#define PTP_OFC_MTP_Firmware 0xb802U
+#define PTP_OFC_MTP_WindowsImageFormat 0xb881U
+#define PTP_OFC_MTP_UndefinedAudio 0xb900U
+#define PTP_OFC_MTP_WMA 0xb901U
+#define PTP_OFC_MTP_OGG 0xb902U
+#define PTP_OFC_MTP_AAC 0xb903U
+#define PTP_OFC_MTP_AudibleCod 0xb904U
+#define PTP_OFC_MTP_FLAC 0xb906U
+#define PTP_OFC_MTP_SamsungPlaylist 0xb909U
+#define PTP_OFC_MTP_UndefinedVideo 0xb980U
+#define PTP_OFC_MTP_WMV 0xb981U
+#define PTP_OFC_MTP_MP4 0xb982U
+#define PTP_OFC_MTP_MP2 0xb983U
+#define PTP_OFC_MTP_3GP 0xb984U
+#define PTP_OFC_MTP_UndefinedCollection 0xba00U
+#define PTP_OFC_MTP_AbstractMultimediaAlbum 0xba01U
+#define PTP_OFC_MTP_AbstractImageAlbum 0xba02U
+#define PTP_OFC_MTP_AbstractAudioAlbum 0xba03U
+#define PTP_OFC_MTP_AbstractVideoAlbum 0xba04U
+#define PTP_OFC_MTP_AbstractAudioVideoPlaylist 0xba05U
+#define PTP_OFC_MTP_AbstractContactGroup 0xba06U
+#define PTP_OFC_MTP_AbstractMessageFolder 0xba07U
+#define PTP_OFC_MTP_AbstractChapteredProduction 0xba08U
+#define PTP_OFC_MTP_AbstractAudioPlaylist 0xba09U
+#define PTP_OFC_MTP_AbstractVideoPlaylist 0xba0aU
+#define PTP_OFC_MTP_AbstractMediacast 0xba0bU
+#define PTP_OFC_MTP_WPLPlaylist 0xba10U
+#define PTP_OFC_MTP_M3UPlaylist 0xba11U
+#define PTP_OFC_MTP_MPLPlaylist 0xba12U
+#define PTP_OFC_MTP_ASXPlaylist 0xba13U
+#define PTP_OFC_MTP_PLSPlaylist 0xba14U
+#define PTP_OFC_MTP_UndefinedDocument 0xba80U
+#define PTP_OFC_MTP_AbstractDocument 0xba81U
+#define PTP_OFC_MTP_XMLDocument 0xba82U
+#define PTP_OFC_MTP_MSWordDocument 0xba83U
+#define PTP_OFC_MTP_MHTCompiledHTMLDocument 0xba84U
+#define PTP_OFC_MTP_MSExcelSpreadsheetXLS 0xba85U
+#define PTP_OFC_MTP_MSPowerpointPresentationPPT 0xba86U
+#define PTP_OFC_MTP_UndefinedMessage 0xbb00U
+#define PTP_OFC_MTP_AbstractMessage 0xbb01U
+#define PTP_OFC_MTP_UndefinedContact 0xbb80U
+#define PTP_OFC_MTP_AbstractContact 0xbb81U
+#define PTP_OFC_MTP_vCard2 0xbb82U
+#define PTP_OFC_MTP_vCard3 0xbb83U
+#define PTP_OFC_MTP_UndefinedCalendarItem 0xbe00U
+#define PTP_OFC_MTP_AbstractCalendarItem 0xbe01U
+#define PTP_OFC_MTP_vCalendar1 0xbe02U
+#define PTP_OFC_MTP_vCalendar2 0xbe03U
+#define PTP_OFC_MTP_UndefinedWindowsExecutable 0xbe80U
+#define PTP_OFC_MTP_MediaCast 0xbe81U
+#define PTP_OFC_MTP_Section 0xbe82U
+
+/* MTP specific Object Properties */
+#define PTP_OPC_StorageID 0xDC01U
+#define PTP_OPC_ObjectFormat 0xDC02U
+#define PTP_OPC_ProtectionStatus 0xDC03U
+#define PTP_OPC_ObjectSize 0xDC04U
+#define PTP_OPC_AssociationType 0xDC05U
+#define PTP_OPC_AssociationDesc 0xDC06U
+#define PTP_OPC_ObjectFileName 0xDC07U
+#define PTP_OPC_DateCreated 0xDC08U
+#define PTP_OPC_DateModified 0xDC09U
+#define PTP_OPC_Keywords 0xDC0AU
+#define PTP_OPC_ParentObject 0xDC0BU
+#define PTP_OPC_AllowedFolderContents 0xDC0CU
+#define PTP_OPC_Hidden 0xDC0DU
+#define PTP_OPC_SystemObject 0xDC0EU
+#define PTP_OPC_PersistantUniqueObjectIdentifier 0xDC41U
+#define PTP_OPC_SyncID 0xDC42U
+#define PTP_OPC_PropertyBag 0xDC43U
+#define PTP_OPC_Name 0xDC44U
+#define PTP_OPC_CreatedBy 0xDC45U
+#define PTP_OPC_Artist 0xDC46U
+#define PTP_OPC_DateAuthored 0xDC47U
+#define PTP_OPC_Description 0xDC48U
+#define PTP_OPC_URLReference 0xDC49U
+#define PTP_OPC_LanguageLocale 0xDC4AU
+#define PTP_OPC_CopyrightInformation 0xDC4BU
+#define PTP_OPC_Source 0xDC4CU
+#define PTP_OPC_OriginLocation 0xDC4DU
+#define PTP_OPC_DateAdded 0xDC4EU
+#define PTP_OPC_NonConsumable 0xDC4FU
+#define PTP_OPC_CorruptOrUnplayable 0xDC50U
+#define PTP_OPC_ProducerSerialNumber 0xDC51U
+#define PTP_OPC_RepresentativeSampleFormat 0xDC81U
+#define PTP_OPC_RepresentativeSampleSize 0xDC82U
+#define PTP_OPC_RepresentativeSampleHeight 0xDC83U
+#define PTP_OPC_RepresentativeSampleWidth 0xDC84U
+#define PTP_OPC_RepresentativeSampleDuration 0xDC85U
+#define PTP_OPC_RepresentativeSampleData 0xDC86U
+#define PTP_OPC_Width 0xDC87U
+#define PTP_OPC_Height 0xDC88U
+#define PTP_OPC_Duration 0xDC89U
+#define PTP_OPC_Rating 0xDC8AU
+#define PTP_OPC_Track 0xDC8BU
+#define PTP_OPC_Genre 0xDC8CU
+#define PTP_OPC_Credits 0xDC8DU
+#define PTP_OPC_Lyrics 0xDC8EU
+#define PTP_OPC_SubscriptionContentID 0xDC8FU
+#define PTP_OPC_ProducedBy 0xDC90U
+#define PTP_OPC_UseCount 0xDC91U
+#define PTP_OPC_SkipCount 0xDC92U
+#define PTP_OPC_LastAccessed 0xDC93U
+#define PTP_OPC_ParentalRating 0xDC94U
+#define PTP_OPC_MetaGenre 0xDC95U
+#define PTP_OPC_Composer 0xDC96U
+#define PTP_OPC_EffectiveRating 0xDC97U
+#define PTP_OPC_Subtitle 0xDC98U
+#define PTP_OPC_OriginalReleaseDate 0xDC99U
+#define PTP_OPC_AlbumName 0xDC9AU
+#define PTP_OPC_AlbumArtist 0xDC9BU
+#define PTP_OPC_Mood 0xDC9CU
+#define PTP_OPC_DRMStatus 0xDC9DU
+#define PTP_OPC_SubDescription 0xDC9EU
+#define PTP_OPC_IsCropped 0xDCD1U
+#define PTP_OPC_IsColorCorrected 0xDCD2U
+#define PTP_OPC_ImageBitDepth 0xDCD3U
+#define PTP_OPC_Fnumber 0xDCD4U
+#define PTP_OPC_ExposureTime 0xDCD5U
+#define PTP_OPC_ExposureIndex 0xDCD6U
+#define PTP_OPC_DisplayName 0xDCE0U
+#define PTP_OPC_BodyText 0xDCE1U
+#define PTP_OPC_Subject 0xDCE2U
+#define PTP_OPC_Priority 0xDCE3U
+#define PTP_OPC_GivenName 0xDD00U
+#define PTP_OPC_MiddleNames 0xDD01U
+#define PTP_OPC_FamilyName 0xDD02U
+#define PTP_OPC_Prefix 0xDD03U
+#define PTP_OPC_Suffix 0xDD04U
+#define PTP_OPC_PhoneticGivenName 0xDD05U
+#define PTP_OPC_PhoneticFamilyName 0xDD06U
+#define PTP_OPC_EmailPrimary 0xDD07U
+#define PTP_OPC_EmailPersonal1 0xDD08U
+#define PTP_OPC_EmailPersonal2 0xDD09U
+#define PTP_OPC_EmailBusiness1 0xDD0AU
+#define PTP_OPC_EmailBusiness2 0xDD0BU
+#define PTP_OPC_EmailOthers 0xDD0CU
+#define PTP_OPC_PhoneNumberPrimary 0xDD0DU
+#define PTP_OPC_PhoneNumberPersonal 0xDD0EU
+#define PTP_OPC_PhoneNumberPersonal2 0xDD0FU
+#define PTP_OPC_PhoneNumberBusiness 0xDD10U
+#define PTP_OPC_PhoneNumberBusiness2 0xDD11U
+#define PTP_OPC_PhoneNumberMobile 0xDD12U
+#define PTP_OPC_PhoneNumberMobile2 0xDD13U
+#define PTP_OPC_FaxNumberPrimary 0xDD14U
+#define PTP_OPC_FaxNumberPersonal 0xDD15U
+#define PTP_OPC_FaxNumberBusiness 0xDD16U
+#define PTP_OPC_PagerNumber 0xDD17U
+#define PTP_OPC_PhoneNumberOthers 0xDD18U
+#define PTP_OPC_PrimaryWebAddress 0xDD19U
+#define PTP_OPC_PersonalWebAddress 0xDD1AU
+#define PTP_OPC_BusinessWebAddress 0xDD1BU
+#define PTP_OPC_InstantMessengerAddress 0xDD1CU
+#define PTP_OPC_InstantMessengerAddress2 0xDD1DU
+#define PTP_OPC_InstantMessengerAddress3 0xDD1EU
+#define PTP_OPC_PostalAddressPersonalFull 0xDD1FU
+#define PTP_OPC_PostalAddressPersonalFullLine1 0xDD20U
+#define PTP_OPC_PostalAddressPersonalFullLine2 0xDD21U
+#define PTP_OPC_PostalAddressPersonalFullCity 0xDD22U
+#define PTP_OPC_PostalAddressPersonalFullRegion 0xDD23U
+#define PTP_OPC_PostalAddressPersonalFullPostalCode 0xDD24U
+#define PTP_OPC_PostalAddressPersonalFullCountry 0xDD25U
+#define PTP_OPC_PostalAddressBusinessFull 0xDD26U
+#define PTP_OPC_PostalAddressBusinessLine1 0xDD27U
+#define PTP_OPC_PostalAddressBusinessLine2 0xDD28U
+#define PTP_OPC_PostalAddressBusinessCity 0xDD29U
+#define PTP_OPC_PostalAddressBusinessRegion 0xDD2AU
+#define PTP_OPC_PostalAddressBusinessPostalCode 0xDD2BU
+#define PTP_OPC_PostalAddressBusinessCountry 0xDD2CU
+#define PTP_OPC_PostalAddressOtherFull 0xDD2DU
+#define PTP_OPC_PostalAddressOtherLine1 0xDD2EU
+#define PTP_OPC_PostalAddressOtherLine2 0xDD2FU
+#define PTP_OPC_PostalAddressOtherCity 0xDD30U
+#define PTP_OPC_PostalAddressOtherRegion 0xDD31U
+#define PTP_OPC_PostalAddressOtherPostalCode 0xDD32U
+#define PTP_OPC_PostalAddressOtherCountry 0xDD33U
+#define PTP_OPC_OrganizationName 0xDD34U
+#define PTP_OPC_PhoneticOrganizationName 0xDD35U
+#define PTP_OPC_Role 0xDD36U
+#define PTP_OPC_Birthdate 0xDD37U
+#define PTP_OPC_MessageTo 0xDD40U
+#define PTP_OPC_MessageCC 0xDD41U
+#define PTP_OPC_MessageBCC 0xDD42U
+#define PTP_OPC_MessageRead 0xDD43U
+#define PTP_OPC_MessageReceivedTime 0xDD44U
+#define PTP_OPC_MessageSender 0xDD45U
+#define PTP_OPC_ActivityBeginTime 0xDD50U
+#define PTP_OPC_ActivityEndTime 0xDD51U
+#define PTP_OPC_ActivityLocation 0xDD52U
+#define PTP_OPC_ActivityRequiredAttendees 0xDD54U
+#define PTP_OPC_ActivityOptionalAttendees 0xDD55U
+#define PTP_OPC_ActivityResources 0xDD56U
+#define PTP_OPC_ActivityAccepted 0xDD57U
+#define PTP_OPC_Owner 0xDD5DU
+#define PTP_OPC_Editor 0xDD5EU
+#define PTP_OPC_Webmaster 0xDD5FU
+#define PTP_OPC_URLSource 0xDD60U
+#define PTP_OPC_URLDestination 0xDD61U
+#define PTP_OPC_TimeBookmark 0xDD62U
+#define PTP_OPC_ObjectBookmark 0xDD63U
+#define PTP_OPC_ByteBookmark 0xDD64U
+#define PTP_OPC_LastBuildDate 0xDD70U
+#define PTP_OPC_TimetoLive 0xDD71U
+#define PTP_OPC_MediaGUID 0xDD72U
+#define PTP_OPC_TotalBitRate 0xDE91U
+#define PTP_OPC_BitRateType 0xDE92U
+#define PTP_OPC_SampleRate 0xDE93U
+#define PTP_OPC_NumberOfChannels 0xDE94U
+#define PTP_OPC_AudioBitDepth 0xDE95U
+#define PTP_OPC_ScanDepth 0xDE97U
+#define PTP_OPC_AudioWAVECodec 0xDE99U
+#define PTP_OPC_AudioBitRate 0xDE9AU
+#define PTP_OPC_VideoFourCCCodec 0xDE9BU
+#define PTP_OPC_VideoBitRate 0xDE9CU
+#define PTP_OPC_FramesPerThousandSeconds 0xDE9DU
+#define PTP_OPC_KeyFrameDistance 0xDE9EU
+#define PTP_OPC_BufferSize 0xDE9FU
+#define PTP_OPC_EncodingQuality 0xDEA0U
+#define PTP_OPC_EncodingProfile 0xDEA1U
+#define PTP_OPC_BuyFlag 0xD901U
+
+/* WiFi Provisioning MTP Extension property codes */
+#define PTP_OPC_WirelessConfigurationFile 0xB104U
+
+
+/* PTP Association Types */
+#define PTP_AT_Undefined 0x0000U
+#define PTP_AT_GenericFolder 0x0001U
+#define PTP_AT_Album 0x0002U
+#define PTP_AT_TimeSequence 0x0003U
+#define PTP_AT_HorizontalPanoramic 0x0004U
+#define PTP_AT_VerticalPanoramic 0x0005U
+#define PTP_AT_2DPanoramic 0x0006U
+#define PTP_AT_AncillaryData 0x0007U
+
+
+#define PTP_MAX_HANDLER_NBR 0x255U
+
+typedef struct {
+ uint32_t n;
+ uint32_t Handler[PTP_MAX_HANDLER_NBR];
+} PTP_ObjectHandles_t;
+
+
+#define PTP_oi_StorageID 0U
+#define PTP_oi_ObjectFormat 4U
+#define PTP_oi_ProtectionStatus 6U
+#define PTP_oi_ObjectCompressedSize 8U
+#define PTP_oi_ThumbFormat 12U
+#define PTP_oi_ThumbCompressedSize 14U
+#define PTP_oi_ThumbPixWidth 18U
+#define PTP_oi_ThumbPixHeight 22U
+#define PTP_oi_ImagePixWidth 26U
+#define PTP_oi_ImagePixHeight 30U
+#define PTP_oi_ImageBitDepth 34U
+#define PTP_oi_ParentObject 38U
+#define PTP_oi_AssociationType 42U
+#define PTP_oi_AssociationDesc 44U
+#define PTP_oi_SequenceNumber 48U
+#define PTP_oi_filenamelen 52U
+#define PTP_oi_Filename 53U
+
+typedef struct {
+ uint32_t StorageID;
+ uint16_t ObjectFormat;
+ uint16_t ProtectionStatus;
+ /* In the regular objectinfo this is 32bit, but we keep the general object size here
+ that also arrives via other methods and so use 64bit */
+ uint64_t ObjectCompressedSize;
+ uint16_t ThumbFormat;
+ uint32_t ThumbCompressedSize;
+ uint32_t ThumbPixWidth;
+ uint32_t ThumbPixHeight;
+ uint32_t ImagePixWidth;
+ uint32_t ImagePixHeight;
+ uint32_t ImageBitDepth;
+ uint32_t ParentObject;
+ uint16_t AssociationType;
+ uint32_t AssociationDesc;
+ uint32_t SequenceNumber;
+ uint8_t Filename[PTP_MAX_STR_SIZE];
+ uint32_t CaptureDate;
+ uint32_t ModificationDate;
+ uint8_t Keywords[PTP_MAX_STR_SIZE];
+} PTP_ObjectInfo_t;
+
+
+/* Object Property Describing Dataset (DevicePropDesc) */
+typedef union _PTP_PropertyValue_t {
+ char str[PTP_MAX_STR_SIZE];
+ uint8_t u8;
+ int8_t i8;
+ uint16_t u16;
+ int16_t i16;
+ uint32_t u32;
+ int32_t i32;
+ uint64_t u64;
+ int64_t i64;
+ struct array
+ {
+ uint32_t count;
+ union _PTP_PropertyValue_t *v;
+ } a;
+} PTP_PropertyValue_t;
+
+typedef struct {
+ PTP_PropertyValue_t MinimumValue;
+ PTP_PropertyValue_t MaximumValue;
+ PTP_PropertyValue_t StepSize;
+} PTP_PropDescRangeForm_t;
+
+/* Property Describing Dataset, Enum Form */
+typedef struct {
+ uint16_t NumberOfValues;
+ PTP_PropertyValue_t SupportedValue[PTP_SUPPORTED_PROPRIETIES_NBR];
+} PTP_PropDescEnumForm_t;
+
+
+/* (MTP) Object Property pack/unpack */
+#define PTP_opd_ObjectPropertyCode 0U
+#define PTP_opd_DataType 2U
+#define PTP_opd_GetSet 4U
+#define PTP_opd_FactoryDefaultValue 5U
+
+typedef struct {
+ uint16_t ObjectPropertyCode;
+ uint16_t DataType;
+ uint8_t GetSet;
+ PTP_PropertyValue_t FactoryDefaultValue;
+ uint32_t GroupCode;
+ uint8_t FormFlag;
+ union
+ {
+ PTP_PropDescEnumForm_t Enum;
+ PTP_PropDescRangeForm_t Range;
+ } FORM;
+} PTP_ObjectPropDesc_t;
+
+
+/* Metadata lists for MTP operations */
+typedef struct {
+ uint16_t property;
+ uint16_t datatype;
+ uint32_t ObjectHandle;
+ PTP_PropertyValue_t propval;
+} MTP_Properties_t;
+
+
+/* Device Property Form Flag */
+#define PTP_DPFF_None 0x00U
+#define PTP_DPFF_Range 0x01U
+#define PTP_DPFF_Enumeration 0x02U
+
+/* Object Property Codes used by MTP (first 3 are same as DPFF codes) */
+#define PTP_OPFF_None 0x00U
+#define PTP_OPFF_Range 0x01U
+#define PTP_OPFF_Enumeration 0x02U
+#define PTP_OPFF_DateTime 0x03U
+#define PTP_OPFF_FixedLengthArray 0x04U
+#define PTP_OPFF_RegularExpression 0x05U
+#define PTP_OPFF_ByteArray 0x06U
+#define PTP_OPFF_LongString 0xFFU
+
+
+/* Device Property pack/unpack */
+#define PTP_dpd_DevicePropertyCode 0U
+#define PTP_dpd_DataType 2U
+#define PTP_dpd_GetSet 4U
+#define PTP_dpd_FactoryDefaultValue 5U
+
+/* Device Property Describing Dataset (DevicePropDesc) */
+typedef struct
+{
+ uint16_t DevicePropertyCode;
+ uint16_t DataType;
+ uint8_t GetSet;
+ PTP_PropertyValue_t FactoryDefaultValue;
+ PTP_PropertyValue_t CurrentValue;
+ uint8_t FormFlag;
+ union
+ {
+ PTP_PropDescEnumForm_t Enum;
+ PTP_PropDescRangeForm_t Range;
+ } FORM;
+} PTP_DevicePropDesc_t;
+
+
+/* DataType Codes */
+#define PTP_DTC_UNDEF 0x0000U
+#define PTP_DTC_INT8 0x0001U
+#define PTP_DTC_UINT8 0x0002U
+#define PTP_DTC_INT16 0x0003U
+#define PTP_DTC_UINT16 0x0004U
+#define PTP_DTC_INT32 0x0005U
+#define PTP_DTC_UINT32 0x0006U
+#define PTP_DTC_INT64 0x0007U
+#define PTP_DTC_UINT64 0x0008U
+#define PTP_DTC_INT128 0x0009U
+#define PTP_DTC_UINT128 0x000AU
+
+#define PTP_DTC_ARRAY_MASK 0x4000U
+
+#define PTP_DTC_AINT8 (PTP_DTC_ARRAY_MASK | PTP_DTC_INT8)
+#define PTP_DTC_AUINT8 (PTP_DTC_ARRAY_MASK | PTP_DTC_UINT8)
+#define PTP_DTC_AINT16 (PTP_DTC_ARRAY_MASK | PTP_DTC_INT16)
+#define PTP_DTC_AUINT16 (PTP_DTC_ARRAY_MASK | PTP_DTC_UINT16)
+#define PTP_DTC_AINT32 (PTP_DTC_ARRAY_MASK | PTP_DTC_INT32)
+#define PTP_DTC_AUINT32 (PTP_DTC_ARRAY_MASK | PTP_DTC_UINT32)
+#define PTP_DTC_AINT64 (PTP_DTC_ARRAY_MASK | PTP_DTC_INT64)
+#define PTP_DTC_AUINT64 (PTP_DTC_ARRAY_MASK | PTP_DTC_UINT64)
+#define PTP_DTC_AINT128 (PTP_DTC_ARRAY_MASK | PTP_DTC_INT128)
+#define PTP_DTC_AUINT128 (PTP_DTC_ARRAY_MASK | PTP_DTC_UINT128)
+
+#define PTP_DTC_STR 0xFFFFU
+
+
+/* PTP Event Codes */
+#define PTP_EC_Undefined 0x4000U
+#define PTP_EC_CancelTransaction 0x4001U
+#define PTP_EC_ObjectAdded 0x4002U
+#define PTP_EC_ObjectRemoved 0x4003U
+#define PTP_EC_StoreAdded 0x4004U
+#define PTP_EC_StoreRemoved 0x4005U
+#define PTP_EC_DevicePropChanged 0x4006U
+#define PTP_EC_ObjectInfoChanged 0x4007U
+#define PTP_EC_DeviceInfoChanged 0x4008U
+#define PTP_EC_RequestObjectTransfer 0x4009U
+#define PTP_EC_StoreFull 0x400AU
+#define PTP_EC_DeviceReset 0x400BU
+#define PTP_EC_StorageInfoChanged 0x400CU
+#define PTP_EC_CaptureComplete 0x400DU
+#define PTP_EC_UnreportedStatus 0x400EU
+
+
+void PTP_GetDevicePropValue(USBH_Info_t *phost, uint32_t *offset, uint32_t total, PTP_PropertyValue_t *value, uint16_t datatype);
+
+void PTP_GetString(uint8_t *str, uint8_t *data, uint16_t *len);
+
+uint32_t PTP_GetArray16(uint16_t *array, uint8_t *data, uint32_t offset);
+uint32_t PTP_GetArray32(uint32_t *array, uint8_t *data, uint32_t offset);
+
+void PTP_DecodeDeviceInfo(USBH_Info_t *phost, PTP_DeviceInfo_t *dev_info);
+
+void PTP_DecodeStorageInfo(USBH_Info_t *phost, PTP_StorageInfo_t *storage_info);
+
+void PTP_DecodeObjectInfo(USBH_Info_t *phost, PTP_ObjectInfo_t *object_info);
+
+void PTP_DecodeObjectPropDesc(USBH_Info_t *phost, PTP_ObjectPropDesc_t *opd, uint32_t opdlen);
+
+uint32_t PTP_DecodeObjectPropList(USBH_Info_t *phost, MTP_Properties_t *props, uint32_t len);
+
+
+#define PTP_LE16(addr) *((uint16_t *)(addr))
+#define PTP_LE32(addr) *((uint32_t *)(addr))
+#define PTP_LE64(addr) *((uint64_t *)(addr))
+
+
+#endif // __USBH_MTP_PTP_H__
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_core.c b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_core.c
new file mode 100644
index 0000000000..3dcfdd234e
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_core.c
@@ -0,0 +1,664 @@
+/******************************************************************************************************************************************
+* 文件名称: usbh_core.c
+* 功能说明:
+* 技术支持: http://www.synwit.com.cn/e/tool/gbook/?bid=1
+* 注意事项:
+* 版本日期: V1.1.0 2020年11月3日
+* 升级记录:
+*
+*
+*******************************************************************************************************************************************
+* @attention
+*
+* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS WITH CODING INFORMATION
+* REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. AS A RESULT, SYNWIT SHALL NOT BE HELD LIABLE
+* FOR ANY DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+* OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION CONTAINED HEREIN IN CONN-
+* -ECTION WITH THEIR PRODUCTS.
+*
+* COPYRIGHT 2012 Synwit Technology
+*******************************************************************************************************************************************/
+#include <stdlib.h>
+#include <string.h>
+#include "SWM341.h"
+#include "usbh_core.h"
+#include "usbh_stdreq.h"
+
+
+USBH_Info_t USBH_Info;
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_Init()
+* 功能说明: USB Host 初始化
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void USBH_Init(USBH_Class_cb_t *class_cb, USBH_User_cb_t *usr_cb)
+{
+ USBH_HW_Init();
+
+ USBH_DeInit();
+
+ /* Register class and user callbacks */
+ USBH_Info.class_cb = class_cb;
+ USBH_Info.usr_cb = usr_cb;
+
+ /* Upon Init call usr call back */
+ if(USBH_Info.usr_cb->Init)
+ USBH_Info.usr_cb->Init();
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_DeInit()
+* 功能说明: USB Host Re-Initialize
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void USBH_DeInit(void)
+{
+ USBH->PORTSR = USBH_PORTSR_CONNCHG_Msk | // 清零标志位
+ USBH_PORTSR_RSTCHG_Msk |
+ USBH_PORTSR_ENACHG_Msk;
+
+ USBH_Info.State = HOST_IDLE;
+ USBH_Info.EnumState = ENUM_GET_DEV_DESC;
+
+ USBH_Info.Ctrl.pksz = 8;
+
+ USBH_Info.Ctrl.toggle_in = 0;
+ USBH_Info.Ctrl.toggle_out = 0;
+
+ USBH_Info.Ctrl.state = CTRL_IDLE;
+
+ USBH_Info.Device.Address = 0;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_Process()
+* 功能说明: USB Host core main state machine process
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void USBH_Process(void)
+{
+ static uint32_t frameNbr;
+ USBH_Status status = USBH_FAIL;
+
+ if(USBH_Info.State != HOST_IDLE)
+ {
+ if(!USBH_IsDeviceConnected())
+ USBH_Info.State = HOST_DEV_DETACHED;
+ }
+
+ switch(USBH_Info.State)
+ {
+ case HOST_IDLE:
+ if(USBH_IsDeviceConnected())
+ {
+ USBH_Info.State = HOST_DEV_ATTACHED;
+
+ if(USBH_Info.usr_cb->DeviceAttached)
+ USBH_Info.usr_cb->DeviceAttached();
+
+ frameNbr = USBH->FRAMENR;
+ }
+ break;
+
+ case HOST_DEV_ATTACHED:
+ if(abs((int)frameNbr - (int)USBH->FRAMENR) > 100)
+ {
+ USBH_Info.State = HOST_PORT_RESETED;
+
+ USBH_ResetPort();
+ }
+ break;
+
+ case HOST_PORT_RESETED:
+ if(USBH_IsPortEnabled())
+ {
+ USBH_Info.State = HOST_PORT_ENABLED;
+
+ frameNbr = USBH->FRAMENR;
+ }
+ break;
+
+ case HOST_PORT_ENABLED:
+ if(abs((int)frameNbr - (int)USBH->FRAMENR) > 10)
+ {
+ USBH_Info.State = HOST_ENUMERATION;
+
+ USBH_Info.Device.Speed = USBH_GetDeviceSpeed();
+
+ if(USBH_Info.usr_cb->DeviceSpeedDetected)
+ USBH_Info.usr_cb->DeviceSpeedDetected(USBH_Info.Device.Speed);
+ }
+ break;
+
+ case HOST_ENUMERATION:
+ if(USBH_HandleEnum(&USBH_Info) == USBH_OK)
+ {
+ USBH_Info.State = HOST_USR_INPUT;
+
+ if(USBH_Info.usr_cb->EnumerationDone)
+ USBH_Info.usr_cb->EnumerationDone();
+ }
+ break;
+
+ case HOST_USR_INPUT:
+ /* The function should return user response true to move to class state */
+ if(USBH_Info.usr_cb->UserInput())
+ {
+ if((USBH_Info.class_cb->Init(&USBH_Info)) == USBH_OK)
+ {
+ USBH_Info.State = HOST_CLASS_REQUEST;
+ }
+ }
+ break;
+
+ case HOST_CLASS_REQUEST:
+ /* process class standard control requests state machine */
+ status = USBH_Info.class_cb->Request(&USBH_Info);
+ if(status == USBH_OK)
+ {
+ USBH_Info.State = HOST_CLASS;
+ }
+ else
+ {
+ USBH_ErrorHandle(&USBH_Info, status);
+ }
+ break;
+
+ case HOST_CLASS:
+ /* process class state machine */
+ status = USBH_Info.class_cb->Process(&USBH_Info);
+ USBH_ErrorHandle(&USBH_Info, status);
+ break;
+
+ case HOST_CTRL_XFER:
+ /* process control transfer state machine */
+ USBH_HandleControl(&USBH_Info);
+ break;
+
+ case HOST_DEV_DETACHED:
+ if(USBH_Info.usr_cb->DeviceDisconnected)
+ USBH_Info.usr_cb->DeviceDisconnected();
+
+ /* Re-Initialize Host for new Enumeration */
+ USBH_DeInit();
+ if(USBH_Info.usr_cb->DeInit)
+ USBH_Info.usr_cb->DeInit();
+ USBH_Info.class_cb->DeInit(&USBH_Info);
+
+ USBH_Info.State = HOST_IDLE;
+ break;
+
+ default :
+ break;
+ }
+}
+
+
+uint8_t USBH_Cfg_Desc_Buffer[USBH_MAX_CFG_SIZE];
+uint16_t USBH_Cfg_Desc_Length;
+/******************************************************************************************************************************************
+* 函数名称: USBH_HandleEnum()
+* 功能说明: Handle the USB device enumeration state machine
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_HandleEnum(USBH_Info_t *phost)
+{
+ USBH_Status status = USBH_BUSY;
+
+ switch(phost->EnumState)
+ {
+ case ENUM_GET_DEV_DESC:
+ if(USBH_GetDescriptor(phost, USB_DESC_DEVICE, 0, (uint8_t *)&phost->Device.Dev_Desc, 8) == USBH_OK)
+ {
+ phost->EnumState = ENUM_GET_FULL_DEV_DESC;
+
+ phost->Ctrl.pksz = phost->Device.Dev_Desc.bMaxPacketSize;
+ }
+ break;
+
+ case ENUM_GET_FULL_DEV_DESC:
+ if(USBH_GetDescriptor(phost, USB_DESC_DEVICE, 0, (uint8_t *)&phost->Device.Dev_Desc, sizeof(USB_DevDesc_t)) == USBH_OK)
+ {
+ phost->EnumState = ENUM_SET_ADDR;
+
+ if(phost->usr_cb->DeviceDescAvailable)
+ phost->usr_cb->DeviceDescAvailable(&phost->Device.Dev_Desc);
+ }
+ break;
+
+ case ENUM_SET_ADDR:
+ if(USBH_SetAddress(phost, USBH_DEVICE_ADDRESS) == USBH_OK)
+ {
+ phost->EnumState = ENUM_GET_CFG_DESC;
+
+ phost->Device.Address = USBH_DEVICE_ADDRESS;
+
+ if(phost->usr_cb->DeviceAddressAssigned)
+ phost->usr_cb->DeviceAddressAssigned();
+ }
+ break;
+
+ case ENUM_GET_CFG_DESC:
+ if(USBH_GetDescriptor(phost, USB_DESC_CONFIG, 0, (uint8_t *)&phost->Device.Cfg_Desc, sizeof(USB_CfgDesc_t)) == USBH_OK)
+ {
+ if(phost->Device.Cfg_Desc.wTotalLength <= USBH_MAX_CFG_SIZE)
+ {
+ phost->EnumState = ENUM_GET_FULL_CFG_DESC;
+ }
+ else
+ {
+ status = USBH_NOT_SUPPORTED;
+ }
+ }
+ break;
+
+ case ENUM_GET_FULL_CFG_DESC:
+ if(USBH_GetDescriptor(phost, USB_DESC_CONFIG, 0, USBH_Cfg_Desc_Buffer, phost->Device.Cfg_Desc.wTotalLength) == USBH_OK)
+ {
+ phost->EnumState = ENUM_GET_VENDOR_STRING_DESC;
+
+ USBH_Cfg_Desc_Length = phost->Device.Cfg_Desc.wTotalLength;
+ USBH_ParseCfgDesc(phost, USBH_Cfg_Desc_Buffer, USBH_Cfg_Desc_Length);
+
+ if(phost->usr_cb->ConfigDescAvailable)
+ phost->usr_cb->ConfigDescAvailable(&phost->Device.Cfg_Desc, phost->Device.Intf_Desc, phost->Device.Ep_Desc[0]);
+ }
+ break;
+
+ case ENUM_GET_VENDOR_STRING_DESC:
+ if(phost->Device.Dev_Desc.iManufacturer != 0)
+ {
+ USBH_Status stat = USBH_GetDescriptor(phost, USB_DESC_STRING, phost->Device.Dev_Desc.iManufacturer, (uint8_t *)phost->Device.strVender, sizeof(phost->Device.strVender));
+ if(stat == USBH_OK)
+ {
+ phost->EnumState = ENUM_GET_PRODUCT_STRING_DESC;
+
+ if(phost->usr_cb->VendorString)
+ phost->usr_cb->VendorString(phost->Device.strVender);
+ }
+ else if(stat == USBH_NOT_SUPPORTED)
+ {
+ phost->EnumState = ENUM_GET_PRODUCT_STRING_DESC;
+ }
+ }
+ else
+ {
+ phost->EnumState = ENUM_GET_PRODUCT_STRING_DESC;
+ }
+ break;
+
+ case ENUM_GET_PRODUCT_STRING_DESC:
+ if(phost->Device.Dev_Desc.iProduct != 0)
+ {
+ USBH_Status stat = USBH_GetDescriptor(phost, USB_DESC_STRING, phost->Device.Dev_Desc.iProduct, (uint8_t *)phost->Device.strProduct, sizeof(phost->Device.strProduct));
+ if(stat == USBH_OK)
+ {
+ phost->EnumState = ENUM_GET_SERIALNUM_STRING_DESC;
+
+ if(phost->usr_cb->ProductString)
+ phost->usr_cb->ProductString(phost->Device.strProduct);
+ }
+ else if(stat == USBH_NOT_SUPPORTED)
+ {
+ phost->EnumState = ENUM_GET_SERIALNUM_STRING_DESC;
+ }
+ }
+ else
+ {
+ phost->EnumState = ENUM_GET_SERIALNUM_STRING_DESC;
+ }
+ break;
+
+ case ENUM_GET_SERIALNUM_STRING_DESC:
+ if(phost->Device.Dev_Desc.iSerialNumber != 0)
+ {
+ USBH_Status stat = USBH_GetDescriptor(phost, USB_DESC_STRING, phost->Device.Dev_Desc.iSerialNumber, (uint8_t *)phost->Device.strSerialNumber, sizeof(phost->Device.strSerialNumber));
+ if(stat == USBH_OK)
+ {
+ phost->EnumState = ENUM_SET_CONFIGURATION;
+
+ if(phost->usr_cb->SerialNumString)
+ phost->usr_cb->SerialNumString(phost->Device.strSerialNumber);
+ }
+ else if(stat == USBH_NOT_SUPPORTED)
+ {
+ phost->EnumState = ENUM_SET_CONFIGURATION;
+ }
+ }
+ else
+ {
+ phost->EnumState = ENUM_SET_CONFIGURATION;
+ }
+ break;
+
+ case ENUM_SET_CONFIGURATION:
+ if(USBH_SetConfiguration(phost, phost->Device.Cfg_Desc.bConfigurationValue) == USBH_OK)
+ {
+ phost->EnumState = ENUM_DEV_CONFIGURED;
+ }
+ break;
+
+ case ENUM_DEV_CONFIGURED:
+ status = USBH_OK;
+ break;
+
+ default:
+ break;
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_HandleControl()
+* 功能说明: Handle the USB control transfer state machine
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void USBH_HandleControl(USBH_Info_t *phost)
+{
+ static uint32_t size;
+ uint32_t real_size;
+ USBH_Resp resp;
+
+ switch(phost->Ctrl.state)
+ {
+ case CTRL_SETUP:
+ if(USBH_SendSetupPacket(phost->Device.Address, (uint8_t *)&phost->Ctrl.setup, 8))
+ {
+ phost->Ctrl.state = CTRL_SETUP_WAIT;
+ }
+ break;
+
+ case CTRL_SETUP_WAIT:
+ resp = USBH_State();
+ if(resp == USBR_ACK)
+ {
+ phost->Ctrl.toggle_in = 1;
+ phost->Ctrl.toggle_out = 1;
+
+ if(phost->Ctrl.setup.wLength != 0)
+ {
+ if(phost->Ctrl.setup.bRequestType & USB_EP_IN)
+ {
+ phost->Ctrl.state = CTRL_DATA_IN;
+ }
+ else
+ {
+ phost->Ctrl.state = CTRL_DATA_OUT;
+ }
+ }
+ else // No Data Stage
+ {
+ if(phost->Ctrl.setup.bRequestType & USB_EP_IN)
+ {
+ phost->Ctrl.state = CTRL_STATUS_OUT;
+ }
+ else
+ {
+ phost->Ctrl.state = CTRL_STATUS_IN;
+ }
+ }
+ }
+ else if(resp == USBR_ERROR)
+ {
+ phost->Ctrl.state = CTRL_SETUP; // retry
+ }
+ break;
+
+ case CTRL_DATA_IN:
+ size = (phost->Ctrl.size > phost->Ctrl.pksz) ? phost->Ctrl.pksz : phost->Ctrl.size;
+ if(USBH_SendInPacket(phost->Device.Address, 0, phost->Ctrl.toggle_in, size))
+ {
+ phost->Ctrl.state = CTRL_DATA_IN_WAIT;
+ }
+ break;
+
+ case CTRL_DATA_IN_WAIT:
+ resp = USBH_State();
+ if(resp == USBR_ACK)
+ {
+ phost->Ctrl.toggle_in ^= 1;
+
+ real_size = USBH_ReadRxBuffer(phost->Ctrl.buff, size);
+ if(real_size < size)
+ {
+ phost->Ctrl.state = CTRL_STATUS_OUT;
+ }
+ else
+ {
+ phost->Ctrl.size -= size;
+ phost->Ctrl.buff += size;
+
+ if(phost->Ctrl.size)
+ {
+ phost->Ctrl.state = CTRL_DATA_IN;
+ }
+ else
+ {
+ phost->Ctrl.state = CTRL_STATUS_OUT;
+ }
+ }
+ }
+ else if(resp == USBR_NAK)
+ {
+ phost->Ctrl.state = CTRL_DATA_IN; // retry
+ }
+ else if(resp == USBR_STALL)
+ {
+ phost->Ctrl.state = CTRL_STALLED;
+ phost->State = phost->StateBkp;
+ }
+ else if(resp == USBR_ERROR)
+ {
+ phost->Ctrl.state = CTRL_ERROR;
+ phost->State = phost->StateBkp;
+ }
+ break;
+
+ case CTRL_DATA_OUT:
+ size = (phost->Ctrl.size > phost->Ctrl.pksz) ? phost->Ctrl.pksz : phost->Ctrl.size;
+ if(USBH_SendOutPacket(phost->Device.Address, 0, phost->Ctrl.toggle_out, phost->Ctrl.buff, size))
+ {
+ phost->Ctrl.state = CTRL_DATA_OUT_WAIT;
+ }
+ break;
+
+ case CTRL_DATA_OUT_WAIT:
+ resp = USBH_State();
+ if(resp == USBR_ACK)
+ {
+ phost->Ctrl.toggle_out ^= 1;
+
+ phost->Ctrl.size -= size;
+ phost->Ctrl.buff += size;
+
+ if(phost->Ctrl.size)
+ {
+ phost->Ctrl.state = CTRL_DATA_OUT;
+ }
+ else
+ {
+ phost->Ctrl.state = CTRL_STATUS_IN;
+ }
+ }
+ else if(resp == USBR_NAK)
+ {
+ phost->Ctrl.state = CTRL_DATA_OUT; // retry
+ }
+ else if(resp == USBR_STALL)
+ {
+ phost->Ctrl.state = CTRL_STALLED;
+ phost->State = phost->StateBkp;
+ }
+ else if(resp == USBR_ERROR)
+ {
+ phost->Ctrl.state = CTRL_ERROR;
+ phost->State = phost->StateBkp;
+ }
+ break;
+
+ case CTRL_STATUS_IN:
+ if(USBH_SendInPacket(phost->Device.Address, 0, phost->Ctrl.toggle_in, 0))
+ {
+ phost->Ctrl.state = CTRL_STATUS_IN_WAIT;
+ }
+ break;
+
+ case CTRL_STATUS_IN_WAIT:
+ resp = USBH_State();
+ if(resp == USBR_ACK)
+ {
+ phost->Ctrl.toggle_in ^= 1;
+
+ phost->Ctrl.state = CTRL_COMPLETE;
+ phost->State = phost->StateBkp;
+ }
+ else if(resp == USBR_NAK)
+ {
+ phost->Ctrl.state = CTRL_STATUS_IN; // retry
+ }
+ else if(resp == USBR_STALL)
+ {
+ phost->Ctrl.state = CTRL_STALLED;
+ phost->State = phost->StateBkp;
+ }
+ else if(resp == USBR_ERROR)
+ {
+ phost->Ctrl.state = CTRL_ERROR;
+ phost->State = phost->StateBkp;
+ }
+ break;
+
+ case CTRL_STATUS_OUT:
+ if(USBH_SendOutPacket(phost->Device.Address, 0, phost->Ctrl.toggle_out, 0, 0))
+ {
+ phost->Ctrl.state = CTRL_STATUS_OUT_WAIT;
+ }
+ break;
+
+ case CTRL_STATUS_OUT_WAIT:
+ resp = USBH_State();
+ if(resp == USBR_ACK)
+ {
+ phost->Ctrl.toggle_out ^= 1;
+
+ phost->Ctrl.state = CTRL_COMPLETE;
+ phost->State = phost->StateBkp;
+ }
+ else if(resp == USBR_NAK)
+ {
+ phost->Ctrl.state = CTRL_STATUS_OUT; // retry
+ }
+ else if(resp == USBR_STALL)
+ {
+ phost->Ctrl.state = CTRL_STALLED;
+ phost->State = phost->StateBkp;
+ }
+ else if(resp == USBR_ERROR)
+ {
+ phost->Ctrl.state = CTRL_ERROR;
+ phost->State = phost->StateBkp;
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_CtrlTransfer()
+* 功能说明: 控制传输
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_CtrlTransfer(USBH_Info_t *phost, uint8_t *buff, uint16_t size)
+{
+ USBH_Status status = USBH_BUSY;
+
+ if(phost->Ctrl.state == CTRL_IDLE)
+ {
+ phost->Ctrl.buff = buff;
+ phost->Ctrl.size = size;
+ phost->Ctrl.state = CTRL_SETUP;
+
+ phost->StateBkp = phost->State;
+ phost->State = HOST_CTRL_XFER;
+ }
+ else
+ {
+ switch(phost->Ctrl.state)
+ {
+ case CTRL_COMPLETE: // Commands successfully sent and Response Received
+ status = USBH_OK;
+ phost->Ctrl.state = CTRL_IDLE;
+ break;
+
+ case CTRL_STALLED:
+ status = USBH_NOT_SUPPORTED;
+ phost->Ctrl.state = CTRL_IDLE;
+ break;
+
+ case CTRL_ERROR:
+ status = USBH_FAIL;
+ phost->Ctrl.state = CTRL_IDLE;
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ return status;
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_ErrorHandle()
+* 功能说明: Handles the Error on Host side.
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+void USBH_ErrorHandle(USBH_Info_t *phost, USBH_Status errType)
+{
+ if(errType == USBH_UNRECOVERED_ERROR)
+ {
+ if(phost->usr_cb->UnrecoveredError)
+ phost->usr_cb->UnrecoveredError();
+
+ goto restart;
+ }
+ else if(errType == USBH_APPLY_DEINIT) // USB host restart requested from application layer
+ {
+ phost->usr_cb->Init();
+
+ goto restart;
+ }
+
+ return;
+
+restart:
+ /* Re-Initialize Host for new Enumeration */
+ USBH_DeInit();
+ USBH_Info.usr_cb->DeInit();
+ USBH_Info.class_cb->DeInit(&USBH_Info);
+}
+
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_core.h b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_core.h
new file mode 100644
index 0000000000..8d9435fe17
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_core.h
@@ -0,0 +1,150 @@
+#ifndef __USBH_CORE_H__
+#define __USBH_CORE_H__
+
+#include <stdint.h>
+#include "usbh_conf.h"
+
+
+typedef enum {
+ USBH_OK = 0,
+ USBH_BUSY,
+ USBH_FAIL,
+ USBH_NOT_SUPPORTED,
+ USBH_UNRECOVERED_ERROR,
+ USBH_APPLY_DEINIT
+} USBH_Status;
+
+
+typedef enum {
+ HOST_IDLE = 0,
+ HOST_DEV_ATTACHED,
+ HOST_PORT_RESETED,
+ HOST_PORT_ENABLED,
+ HOST_ENUMERATION,
+ HOST_CLASS_REQUEST,
+ HOST_CLASS,
+ HOST_CTRL_XFER,
+ HOST_USR_INPUT,
+ HOST_SUSPENDED,
+ HOST_WAKEUP,
+ HOST_DEV_DETACHED,
+} HOST_State;
+
+
+typedef enum {
+ ENUM_GET_DEV_DESC = 0,
+ ENUM_GET_FULL_DEV_DESC,
+ ENUM_SET_ADDR,
+ ENUM_GET_CFG_DESC,
+ ENUM_GET_FULL_CFG_DESC,
+ ENUM_GET_VENDOR_STRING_DESC,
+ ENUM_GET_PRODUCT_STRING_DESC,
+ ENUM_GET_SERIALNUM_STRING_DESC,
+ ENUM_SET_CONFIGURATION,
+ ENUM_DEV_CONFIGURED
+} ENUM_State;
+
+
+typedef enum {
+ CTRL_IDLE = 0,
+ CTRL_SETUP,
+ CTRL_SETUP_WAIT,
+ CTRL_DATA_IN,
+ CTRL_DATA_IN_WAIT,
+ CTRL_DATA_OUT,
+ CTRL_DATA_OUT_WAIT,
+ CTRL_STATUS_IN,
+ CTRL_STATUS_IN_WAIT,
+ CTRL_STATUS_OUT,
+ CTRL_STATUS_OUT_WAIT,
+ CTRL_ERROR,
+ CTRL_STALLED,
+ CTRL_COMPLETE
+} CTRL_State;
+
+
+typedef struct {
+ uint8_t pksz; // 控制传输包大小
+ uint8_t *buff; // 控制传输的数据阶段缓冲区
+ uint16_t size; // 控制传输的数据阶段缓冲区大小
+ CTRL_State state;
+ USB_Setup_Packet_t setup; // Setup 包
+
+ uint8_t toggle_in;
+ uint8_t toggle_out;
+} USBH_CtrlXfer_t;
+
+
+typedef struct {
+ uint8_t Address;
+ uint8_t Speed; // 2 低速 3 全速
+ USB_DevDesc_t Dev_Desc;
+ USB_CfgDesc_t Cfg_Desc;
+ USB_IntfDesc_t Intf_Desc[USBH_MAX_NUM_INTERFACES];
+ USB_EpDesc_t Ep_Desc[USBH_MAX_NUM_INTERFACES][USBH_MAX_NUM_ENDPOINTS];
+ USB_HIDDesc_t HID_Desc[USBH_MAX_NUM_INTERFACES];
+ uint8_t HIDReport_Desc[USBH_MAX_NUM_INTERFACES][USBH_HID_REPORT_SIZE];
+ char strVender[USBH_MAX_STR_SIZE];
+ char strProduct[USBH_MAX_STR_SIZE];
+ char strSerialNumber[USBH_MAX_STR_SIZE];
+} USBH_Device_t;
+
+extern uint8_t USBH_Cfg_Desc_Buffer[USBH_MAX_CFG_SIZE];
+extern uint16_t USBH_Cfg_Desc_Length;
+
+struct USBH_Info_T;
+typedef struct {
+ USBH_Status (*Init)(struct USBH_Info_T *phost);
+ void (*DeInit)(struct USBH_Info_T *phost);
+ USBH_Status (*Request)(struct USBH_Info_T *phost);
+ USBH_Status (*Process)(struct USBH_Info_T *phost);
+} USBH_Class_cb_t;
+
+
+typedef struct {
+ void (*Init)(void);
+ void (*DeInit)(void);
+ void (*DeviceAttached)(void);
+ void (*ResetDevice)(void);
+ void (*DeviceDisconnected)(void);
+ void (*OverCurrentDetected)(void);
+ void (*DeviceSpeedDetected)(uint8_t DeviceSpeed);
+ void (*DeviceDescAvailable)(USB_DevDesc_t *devDesc);
+ void (*DeviceAddressAssigned)(void);
+ void (*ConfigDescAvailable)(USB_CfgDesc_t *cfgDesc, USB_IntfDesc_t *intfDesc, USB_EpDesc_t *epDesc);
+ void (*VendorString)(char *);
+ void (*ProductString)(char *);
+ void (*SerialNumString)(char *);
+ void (*EnumerationDone)(void);
+ uint32_t (*UserInput)(void);
+ int (*UserApplication)(void);
+ void (*DeviceNotSupported)(void);
+ void (*UnrecoveredError)(void);
+} USBH_User_cb_t;
+
+
+typedef struct USBH_Info_T {
+ HOST_State State; // Host State Machine
+ HOST_State StateBkp; // State Backup
+ ENUM_State EnumState; // Enumeration state Machine
+
+ USBH_CtrlXfer_t Ctrl;
+ USBH_Device_t Device;
+
+ USBH_Class_cb_t *class_cb;
+ USBH_User_cb_t *usr_cb;
+} USBH_Info_t;
+
+
+void USBH_Init(USBH_Class_cb_t *class_cb, USBH_User_cb_t *usr_cb);
+void USBH_DeInit(void);
+
+void USBH_Process(void);
+USBH_Status USBH_HandleEnum(USBH_Info_t *phost);
+void USBH_HandleControl(USBH_Info_t *phost);
+USBH_Status USBH_CtrlTransfer(USBH_Info_t *phost, uint8_t *buff, uint16_t size);
+
+void USBH_ErrorHandle(USBH_Info_t *phost, USBH_Status errType);
+
+#endif
+
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_stdreq.c b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_stdreq.c
new file mode 100644
index 0000000000..bb8f53ffe8
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_stdreq.c
@@ -0,0 +1,202 @@
+/******************************************************************************************************************************************
+* 文件名称: usbh_stdreq.c
+* 功能说明:
+* 技术支持: http://www.synwit.com.cn/e/tool/gbook/?bid=1
+* 注意事项:
+* 版本日期: V1.1.0 2020年11月3日
+* 升级记录:
+*
+*
+*******************************************************************************************************************************************
+* @attention
+*
+* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS WITH CODING INFORMATION
+* REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. AS A RESULT, SYNWIT SHALL NOT BE HELD LIABLE
+* FOR ANY DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+* OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION CONTAINED HEREIN IN CONN-
+* -ECTION WITH THEIR PRODUCTS.
+*
+* COPYRIGHT 2012 Synwit Technology
+*******************************************************************************************************************************************/
+#include <string.h>
+#include "SWM341.h"
+#include "usbh_core.h"
+#include "usbh_stdreq.h"
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_GetDescriptor()
+* 功能说明: 获取描述符
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_GetDescriptor(USBH_Info_t *phost, uint8_t type, uint8_t index, uint8_t *buff, int size)
+{
+ phost->Ctrl.setup.bRequestType = USB_REQ_D2H | USB_REQ_STANDARD | USB_REQ_TO_DEVICE;
+ phost->Ctrl.setup.bRequest = USB_GET_DESCRIPTOR;
+ phost->Ctrl.setup.wValue = (type << 8) | index;
+ phost->Ctrl.setup.wIndex = (type == USB_DESC_STRING) ? 0x0409 : 0;
+ phost->Ctrl.setup.wLength = size;
+
+ return USBH_CtrlTransfer(phost, buff, size);
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_GetDescriptorEx()
+* 功能说明: 获取描述符
+* 输 入: uint8_t reqType USB_REQ_STANDARD、USB_REQ_CLASS、USB_REQ_VENDOR
+* uint8_t reqTarget USB_REQ_TO_DEVICE、USB_REQ_TO_INTERFACE、USB_REQ_TO_ENDPOINT
+* uint8_t type
+* uint8_t index
+* uint16_t wIndex
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_GetDescriptorEx(USBH_Info_t *phost, uint8_t reqType, uint8_t reqTarget, uint8_t type, uint8_t index, uint16_t wIndex, uint8_t *buff, int size)
+{
+ phost->Ctrl.setup.bRequestType = USB_REQ_D2H | reqType | reqTarget;
+ phost->Ctrl.setup.bRequest = USB_GET_DESCRIPTOR;
+ phost->Ctrl.setup.wValue = (type << 8) | index;
+ phost->Ctrl.setup.wIndex = wIndex;
+ phost->Ctrl.setup.wLength = size;
+
+ return USBH_CtrlTransfer(phost, buff, size);
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_SetAddress()
+* 功能说明: 设置设备地址
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_SetAddress(USBH_Info_t *phost, uint8_t addr)
+{
+ phost->Ctrl.setup.bRequestType = USB_REQ_H2D | USB_REQ_STANDARD | USB_REQ_TO_DEVICE;
+ phost->Ctrl.setup.bRequest = USB_SET_ADDRESS;
+ phost->Ctrl.setup.wValue = addr;
+ phost->Ctrl.setup.wIndex = 0;
+ phost->Ctrl.setup.wLength = 0;
+
+ return USBH_CtrlTransfer(phost, 0, 0);
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_SetConfiguration()
+* 功能说明: 设置 configuration
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_SetConfiguration(USBH_Info_t *phost, uint8_t cfg)
+{
+ phost->Ctrl.setup.bRequestType = USB_REQ_H2D | USB_REQ_STANDARD | USB_REQ_TO_DEVICE;
+ phost->Ctrl.setup.bRequest = USB_SET_CONFIGURATION;
+ phost->Ctrl.setup.wValue = cfg;
+ phost->Ctrl.setup.wIndex = 0;
+ phost->Ctrl.setup.wLength = 0;
+
+ return USBH_CtrlTransfer(phost, 0, 0);
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_SetInterface()
+* 功能说明: 设置 interface altSetting
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_SetInterface(USBH_Info_t *phost, uint8_t intf, uint8_t altSetting)
+{
+ phost->Ctrl.setup.bRequestType = USB_REQ_H2D | USB_REQ_STANDARD | USB_REQ_TO_INTERFACE;
+ phost->Ctrl.setup.bRequest = USB_SET_INTERFACE;
+ phost->Ctrl.setup.wValue = altSetting;
+ phost->Ctrl.setup.wIndex = intf;
+ phost->Ctrl.setup.wLength = 0;
+
+ return USBH_CtrlTransfer(phost, 0, 0);
+}
+
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_ClrFeature()
+* 功能说明: 清除端点 STALL
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_ClrFeature(USBH_Info_t *phost, uint8_t ep)
+{
+ phost->Ctrl.setup.bRequestType = USB_REQ_H2D | USB_REQ_STANDARD | USB_REQ_TO_ENDPOINT;
+ phost->Ctrl.setup.bRequest = USB_CLEAR_FEATURE;
+ phost->Ctrl.setup.wValue = 0x00;
+ phost->Ctrl.setup.wIndex = ep;
+ phost->Ctrl.setup.wLength = 0;
+
+ return USBH_CtrlTransfer(phost, 0, 0);
+}
+
+/******************************************************************************************************************************************
+* 函数名称: USBH_ParseCfgDesc()
+* 功能说明: 解析配置描述符
+* 输 入: 无
+* 输 出: 无
+* 注意事项: 无
+******************************************************************************************************************************************/
+USBH_Status USBH_ParseCfgDesc(USBH_Info_t *phost, uint8_t *buff, uint16_t size)
+{
+ USB_DescHeader_t *pdesc = (USB_DescHeader_t *)buff;
+ uint8_t if_ix, ep_ix;
+
+ memcpy(&phost->Device.Cfg_Desc, pdesc, sizeof(USB_CfgDesc_t));
+
+ if(phost->Device.Cfg_Desc.bNumInterfaces > USBH_MAX_NUM_INTERFACES)
+ {
+ return USBH_NOT_SUPPORTED;
+ }
+
+ while((uint8_t *)pdesc < &buff[size])
+ {
+ pdesc = (USB_DescHeader_t *)((uint8_t *)pdesc + pdesc->bLength);
+ switch(pdesc->bDescriptorType)
+ {
+ case USB_DESC_INTERFACE:
+ if_ix = ((USB_IntfDesc_t *)pdesc)->bInterfaceNumber;
+ if(if_ix >= USBH_MAX_NUM_INTERFACES)
+ {
+ return USBH_NOT_SUPPORTED;
+ }
+
+ memcpy(&phost->Device.Intf_Desc[if_ix], pdesc, sizeof(USB_IntfDesc_t));
+
+ if(phost->Device.Intf_Desc[if_ix].bNumEndpoints > USBH_MAX_NUM_ENDPOINTS)
+ {
+ return USBH_NOT_SUPPORTED;
+ }
+ ep_ix = 0;
+ break;
+
+ case USB_DESC_ENDPOINT:
+ memcpy(&phost->Device.Ep_Desc[if_ix][ep_ix], pdesc, sizeof(USB_EpDesc_t));
+ if(++ep_ix >= USBH_MAX_NUM_ENDPOINTS)
+ {
+ return USBH_NOT_SUPPORTED;
+ }
+ break;
+
+ case USB_DESC_HID:
+ memcpy(&phost->Device.HID_Desc[if_ix], pdesc, sizeof(USB_HIDDesc_t));
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ return USBH_OK ;
+}
diff --git a/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_stdreq.h b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_stdreq.h
new file mode 100644
index 0000000000..876005a3a8
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_CSL/SWM341_UsbHost_Lib/usbh_stdreq.h
@@ -0,0 +1,18 @@
+#ifndef __USBH_STDREQ_H__
+#define __USBH_STDREQ_H__
+
+#include <stdint.h>
+#include "usbh_core.h"
+
+
+USBH_Status USBH_GetDescriptor(USBH_Info_t *phost, uint8_t type, uint8_t index, uint8_t *buff, int size);
+USBH_Status USBH_GetDescriptorEx(USBH_Info_t *phost, uint8_t reqType, uint8_t reqTarget, uint8_t type, uint8_t index, uint16_t wIndex, uint8_t *buff, int size);
+
+USBH_Status USBH_SetAddress(USBH_Info_t *phost, uint8_t addr);
+USBH_Status USBH_SetConfiguration(USBH_Info_t *phost, uint8_t cfg);
+USBH_Status USBH_SetInterface(USBH_Info_t *phost, uint8_t intf, uint8_t altSetting);
+USBH_Status USBH_ClrFeature(USBH_Info_t *phost, uint8_t ep);
+
+USBH_Status USBH_ParseCfgDesc(USBH_Info_t *phost, uint8_t *buff, uint16_t size);
+
+#endif