aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorDavid Barksdale <amatus@amatus.name>2016-08-02 07:25:00 -0500
committerDavid Barksdale <amatus@amatus.name>2016-08-02 07:25:00 -0500
commit64e0bb76b28533578f855c8698f8c29d3c559b59 (patch)
tree2b1eeacc1915f00cd1143e270c5829de268b5d5d
parentd75001b8dab377b36310d6a92478700a916a2814 (diff)
Adding USB files from KSDK for mass-storage class
-rw-r--r--KSDK_1.2.0/usb/adapter/sources/adapter.h93
-rw-r--r--KSDK_1.2.0/usb/adapter/sources/adapter_types.h67
-rw-r--r--KSDK_1.2.0/usb/adapter/sources/sdk/adapter_cfg.h45
-rw-r--r--KSDK_1.2.0/usb/adapter/sources/sdk/adapter_sdk.c502
-rw-r--r--KSDK_1.2.0/usb/adapter/sources/sdk/adapter_sdk.h115
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/CMakeLists.txt138
-rwxr-xr-xKSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_all.bat5
-rwxr-xr-xKSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_all.sh5
-rwxr-xr-xKSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_debug.bat3
-rwxr-xr-xKSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_debug.sh3
-rwxr-xr-xKSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_release.bat3
-rwxr-xr-xKSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_release.sh3
-rwxr-xr-xKSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/clean.bat3
-rwxr-xr-xKSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/clean.sh3
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/include/frdmkl27z/usb_device_config.h159
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/include/usb_device_stack_interface.h618
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/bsp/frdmkl27z/usb_dev_bsp.c153
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/classes/common/usb_class.c376
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/classes/common/usb_class_internal.h186
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/classes/include/config/usb_msc_config.h54
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/classes/include/usb_class.h116
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/classes/include/usb_class_msc.h201
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc.c1580
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc.h612
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc_scsi.c1467
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc_scsi.h309
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/device_khci_interface.c75
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/khci_dev.c2339
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/khci_dev.h75
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/khci_dev_misc.h146
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_dev.c1560
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_dev.h136
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_framework.c1295
-rw-r--r--KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_framework.h188
-rw-r--r--KSDK_1.2.0/usb/usb_core/hal/fsl_usb_features.h126
-rw-r--r--KSDK_1.2.0/usb/usb_core/hal/fsl_usb_khci_hal.c36
-rw-r--r--KSDK_1.2.0/usb/usb_core/hal/fsl_usb_khci_hal.h1879
-rw-r--r--KSDK_1.2.0/usb/usb_core/include/compiler.h122
-rw-r--r--KSDK_1.2.0/usb/usb_core/include/types.h84
-rw-r--r--KSDK_1.2.0/usb/usb_core/include/usb.h40
-rw-r--r--KSDK_1.2.0/usb/usb_core/include/usb_desc.h348
-rw-r--r--KSDK_1.2.0/usb/usb_core/include/usb_error.h100
-rw-r--r--KSDK_1.2.0/usb/usb_core/include/usb_misc.h193
-rw-r--r--KSDK_1.2.0/usb/usb_core/include/usb_opt.h117
-rw-r--r--KSDK_1.2.0/usb/usb_core/include/usb_pin_detect.h68
-rw-r--r--KSDK_1.2.0/usb/usb_core/include/usb_types.h59
46 files changed, 15805 insertions, 0 deletions
diff --git a/KSDK_1.2.0/usb/adapter/sources/adapter.h b/KSDK_1.2.0/usb/adapter/sources/adapter.h
new file mode 100644
index 0000000..f67ddc6
--- /dev/null
+++ b/KSDK_1.2.0/usb/adapter/sources/adapter.h
@@ -0,0 +1,93 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2013 - 2014 Freescale Semiconductor;
+* All Rights Reserved
+*
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: osadapter.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+* @brief The file contains OS adapter layer api header function.
+*
+*****************************************************************************/
+
+#ifndef _USB_OSADAPTER_H
+#define _USB_OSADAPTER_H 1
+#include "adapter_cfg.h"
+#include "adapter_types.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX) /* USB stack running on MQX */
+#include "adapter_mqx.h"
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM) /* USB stack running on BM */
+#include "adapter_bm.h"
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK) /* USB stack running on SDK */
+#include "adapter_sdk.h"
+#endif
+
+extern uint32_t OS_Task_create(task_start_t pstart, void* param, uint32_t pri, uint32_t stack_size, char* task_name, void* opt);
+extern uint32_t OS_Task_delete(uint32_t task_id);
+extern uint32_t OS_Task_suspend(uint32_t task_id);
+extern uint32_t OS_Task_resume(uint32_t task_id);
+
+extern os_event_handle OS_Event_create(uint32_t flag);
+extern uint32_t OS_Event_destroy(os_event_handle handle);
+extern uint32_t OS_Event_set(os_event_handle handle, uint32_t bitmask);
+extern uint32_t OS_Event_check_bit(os_event_handle handle, uint32_t bitmask);
+//extern uint32_t OS_Event_set_auto_clear(os_event_handle event, uint32 bitmask);
+extern uint32_t OS_Event_clear(os_event_handle handle, uint32_t bitmask);
+extern uint32_t OS_Event_wait(os_event_handle handle, uint32_t bitmask, uint32_t flag, uint32_t timeout);
+//extern OS_Event_get_value(a,b) _lwevent_get_value(a,b)
+//#define OS_EVENT_WAIT_TIMEOUT 0x01
+
+
+extern os_msgq_handle OS_MsgQ_create(uint32_t max_msg_number, uint32_t msg_size);
+extern uint32_t OS_MsgQ_send(os_msgq_handle msgq, void* msg, uint32_t flag);
+extern uint32_t OS_MsgQ_recv(os_msgq_handle msgq, void* msg, uint32_t flag, uint32_t timeout);
+extern uint32_t OS_MsgQ_destroy(os_msgq_handle msgq);
+
+extern os_gpio_handle OS_Gpio_init(uint32_t id, uint32_t dir, uint32_t value);
+extern uint32_t OS_Gpio_set_functionality(os_gpio_handle handle, uint32_t function);
+extern uint32_t OS_Gpio_set_value(os_gpio_handle handle, uint32_t value);
+
+extern os_mutex_handle OS_Mutex_create(void);
+extern uint32_t OS_Mutex_lock(os_mutex_handle handle);
+extern uint32_t OS_Mutex_unlock(os_mutex_handle handle);
+extern uint32_t OS_Mutex_destroy(os_mutex_handle handle);
+
+
+extern os_sem_handle OS_Sem_create(uint32_t initial_number);
+extern uint32_t OS_Sem_post(os_sem_handle handle);
+extern uint32_t OS_Sem_wait(os_sem_handle handle,uint32_t timeout);
+extern uint32_t OS_Sem_destroy(os_sem_handle handle);
+
+#if defined(__cplusplus)
+}
+#endif
+
+
+#endif
+
+
diff --git a/KSDK_1.2.0/usb/adapter/sources/adapter_types.h b/KSDK_1.2.0/usb/adapter/sources/adapter_types.h
new file mode 100644
index 0000000..17203f1
--- /dev/null
+++ b/KSDK_1.2.0/usb/adapter/sources/adapter_types.h
@@ -0,0 +1,67 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2013 - 2014 Freescale Semiconductor;
+* All Rights Reserved
+*
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: osadapter_types.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+* @brief The file contains definition for OS adapter layer.
+*
+*****************************************************************************/
+
+#ifndef _OSADAPTER_TYPES_H
+#define _OSADAPTER_TYPES_H 1
+
+
+typedef void (* task_start_t)( void * param);
+typedef void (* osa_int_isr_fptr)(void * param);
+typedef void* os_event_handle;
+typedef void* os_msgq_handle;
+typedef void* os_gpio_handle;
+typedef void* os_mutex_handle;
+typedef void* os_sem_handle;
+
+
+#define OS_TASK_OK (0)
+#define OS_TASK_ERROR (-1)
+#define OS_EVENT_OK (0)
+#define OS_EVENT_ERROR (-1)
+#define OS_EVENT_TIMEOUT (-2)
+#define OS_MSGQ_OK (0)
+#define OS_MSGQ_ERROR (-1)
+#define OS_GPIO_OK (0)
+#define OS_GPIO_ERROR (-1)
+#define OS_MUTEX_OK (0)
+#define OS_MUTEX_ERROR (-1)
+#define OS_SEM_OK (0)
+#define OS_SEM_ERROR (-1)
+#define OS_SEM_TIMEOUT (-2)
+
+/* Block the reading task if msgq is empty */
+#define OS_MSGQ_RECEIVE_BLOCK_ON_EMPTY (0x04)
+
+
+#endif
+
+
diff --git a/KSDK_1.2.0/usb/adapter/sources/sdk/adapter_cfg.h b/KSDK_1.2.0/usb/adapter/sources/sdk/adapter_cfg.h
new file mode 100644
index 0000000..04418dd
--- /dev/null
+++ b/KSDK_1.2.0/usb/adapter/sources/sdk/adapter_cfg.h
@@ -0,0 +1,45 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2013 Freescale Semiconductor;
+* All Rights Reserved
+*
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: osadapter_cfg.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+* @brief The file contains OS adapter configuration inf.
+*
+*****************************************************************************/
+
+#ifndef _OSADAPTER_CFG_H
+#define _OSADAPTER_CFG_H 1
+
+#define OS_ADAPTER_MQX 1
+#define OS_ADAPTER_BM 2
+#define OS_ADAPTER_SDK 3
+#define OS_ADAPTER_UCOSIII 4
+/*#define OS_ADAPTER_ACTIVE_OS OS_ADAPTER_UCOSIII*/
+#define OS_ADAPTER_ACTIVE_OS OS_ADAPTER_SDK
+
+#endif
+
+
diff --git a/KSDK_1.2.0/usb/adapter/sources/sdk/adapter_sdk.c b/KSDK_1.2.0/usb/adapter/sources/sdk/adapter_sdk.c
new file mode 100644
index 0000000..02dd9e9
--- /dev/null
+++ b/KSDK_1.2.0/usb/adapter/sources/sdk/adapter_sdk.c
@@ -0,0 +1,502 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2013 - 2014 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: osadapter_ucos.c$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ * @brief The file includes the implementation of OS adapter based on SDK OSA.
+ *
+ *****************************************************************************/
+#include "adapter_cfg.h"
+#include "adapter_types.h"
+#include "adapter_sdk.h"
+#include "adapter.h"
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <assert.h>
+#include "fsl_device_registers.h"
+
+uint8_t soc_get_usb_vector_number(uint8_t controller_id)
+{
+ if (controller_id == 0)
+ {
+ return USB0_IRQn;
+ }
+#if defined (USBHS_BASE)
+ else if (controller_id == 2)
+ {
+ return USBHS_IRQn;
+ }
+#endif
+ return 0;
+}
+
+uint32_t soc_get_usb_base_address(uint8_t controller_id)
+{
+ if (controller_id == 0)
+ {
+ return (uint32_t) USB0_BASE;
+ }
+#if defined (USBHS_BASE)
+ else if (controller_id == 2)
+ {
+ return (uint32_t)USBHS_BASE;
+ }
+#endif
+ return (uint32_t) NULL;
+}
+
+os_gpio_handle OS_Gpio_init(uint32_t id, uint32_t dir, uint32_t value)
+{
+ return (os_gpio_handle)(0x0000FFFF);
+}
+
+uint32_t OS_Gpio_set_functionality(os_gpio_handle handle, uint32_t function)
+{
+ return OS_GPIO_OK;
+}
+
+uint32_t OS_Gpio_set_value(os_gpio_handle handle, uint32_t value)
+{
+ return OS_GPIO_OK;
+}
+
+uint32_t OS_Gpio_deinit(os_gpio_handle handle)
+{
+ return OS_GPIO_OK;
+}
+
+/* Structure for uC/OS to manage the task stack and task handler. */
+#if ((defined (FSL_RTOS_UCOSII)) || (defined (FSL_RTOS_UCOSIII)))
+typedef struct _usb_adapter_task_struct
+{
+ void *stack_mem; // Pointer to task stack.
+ task_handler_t handler;// Handler of task.
+}usb_adapter_task_struct;
+#endif
+
+uint32_t OS_Task_create(task_start_t pstart, void* param, uint32_t pri, uint32_t stack_size, char* task_name, void* opt)
+{
+ osa_status_t status;
+ /*
+ * For uC/OS, we should allocate memory for task stack.
+ */
+#if ((defined (FSL_RTOS_UCOSII)) || (defined (FSL_RTOS_UCOSIII)))
+ usb_adapter_task_struct* task_struct = OSA_MemAllocZero(sizeof(usb_adapter_task_struct));
+ if (!task_struct)
+ {
+ return (uint32_t)OS_TASK_ERROR;
+ }
+
+ task_struct->stack_mem = OSA_MemAlloc(stack_size);
+ if(!task_struct->stack_mem)
+ {
+ OSA_MemFree(task_struct);
+ return (uint32_t)OS_TASK_ERROR;
+ }
+
+#if defined (FSL_RTOS_UCOSIII)
+ task_struct->handler = OSA_MemAllocZero(sizeof(OS_TCB));
+ if(!task_struct->handler)
+ {
+ OSA_MemFree(task_struct->stack_mem);
+ OSA_MemFree(task_struct);
+ return (uint32_t)OS_TASK_ERROR;
+ }
+#endif
+ status = OSA_TaskCreate((task_t)pstart, (uint8_t*)task_name, stack_size,
+ task_struct->stack_mem, pri, (task_param_t)param, false, &task_struct->handler);
+ if (kStatus_OSA_Success == status)
+ {
+ return (uint32_t)task_struct;
+ }
+ else
+ {
+ return (uint32_t)OS_TASK_ERROR;
+ }
+
+#else //((defined (FSL_RTOS_UCOSII)) || (defined (FSL_RTOS_UCOSIII)))
+ task_handler_t task_handler;
+ status = OSA_TaskCreate((task_t) pstart, (uint8_t*) task_name, stack_size, NULL, pri, (task_param_t) param, false, &task_handler);
+
+ if (kStatus_OSA_Success == status)
+ {
+ return (uint32_t) task_handler;
+ }
+ else
+ {
+ return (uint32_t) OS_TASK_ERROR;
+ }
+#endif //((defined (FSL_RTOS_UCOSII)) || (defined (FSL_RTOS_UCOSIII)))
+}
+
+uint32_t OS_Task_delete(uint32_t task_id)
+{
+#if ((defined (FSL_RTOS_UCOSII)) || (defined (FSL_RTOS_UCOSIII)))
+ usb_adapter_task_struct* task_struct = (usb_adapter_task_struct*)task_id;
+
+ if (kStatus_OSA_Success != OSA_TaskDestroy(task_struct->handler))
+ {
+ return (uint32_t)OS_TASK_ERROR;
+ }
+#if defined (FSL_RTOS_UCOSIII)
+ OSA_MemFree(task_struct->handler); // Free TCB
+#endif
+ OSA_MemFree(task_struct->stack_mem); // Free stack memory
+ OSA_MemFree(task_struct);
+ return (uint32_t)OS_TASK_OK;
+#else
+ return (kStatus_OSA_Success == OSA_TaskDestroy((task_handler_t) task_id)) ? (uint32_t) OS_TASK_OK : (uint32_t) OS_TASK_ERROR;
+#endif
+}
+
+/* Event create and destroy */
+os_event_handle OS_Event_create(uint32_t flag)
+{
+ event_t *p_event = (event_t *) OSA_MemAllocZero(sizeof(event_t));
+
+ if (!p_event)
+ {
+ return (os_event_handle) 0;
+ }
+
+ if (kStatus_OSA_Success != OSA_EventCreate(p_event, flag ? kEventAutoClear : kEventManualClear))
+ {
+ OSA_MemFree(p_event);
+ return (os_event_handle) 0;
+ }
+ return (os_event_handle) p_event;
+}
+
+uint32_t OS_Event_destroy(os_event_handle handle)
+{
+ event_t* obj = (event_t*) handle;
+
+ if (kStatus_OSA_Success == OSA_EventDestroy(obj))
+ {
+ OSA_MemFree(handle);
+ return (uint32_t) OS_EVENT_OK;
+ }
+ else
+ {
+ return (uint32_t) OS_EVENT_ERROR;
+ }
+}
+
+/* Message queue create and destroy */
+/*
+ * NOTE: The msg_size here is counted by words, not bytes!
+ */
+os_msgq_handle OS_MsgQ_create(uint32_t max_msg_number, uint32_t msg_size)
+{
+ os_msgq_handle ret;
+#if defined (FSL_RTOS_UCOSII)
+ uint8_t *p_tmp;
+ uint32_t size = sizeof(msg_queue_t)
+ + (msg_size*sizeof(int32_t)+sizeof(void*))*max_msg_number;
+#elif defined (FSL_RTOS_UCOSIII)
+ uint8_t *p_tmp;
+ uint32_t size = sizeof(msg_queue_t) + (msg_size*sizeof(int32_t))*max_msg_number;
+#elif defined (FSL_RTOS_MQX)
+ uint32_t size = (SIZE_IN_MMT_UNITS(sizeof(LWMSGQ_STRUCT))
+ + SIZE_IN_MMT_UNITS((msg_size*sizeof(int32_t))*(max_msg_number)))
+ * sizeof(_mqx_max_type);
+#elif defined (FSL_RTOS_FREE_RTOS)
+#else /* Bare metal by default. */
+ uint8_t *p_tmp;
+ uint32_t size = sizeof(msg_queue_t) + sizeof(uint32_t) * max_msg_number * msg_size;
+#endif
+
+#if defined (FSL_RTOS_FREE_RTOS)
+ msg_queue_t* msgq = NULL;
+#else
+ msg_queue_t* msgq = (msg_queue_t*) OSA_MemAllocZero(size);
+
+ if (!msgq)
+ {
+ return (msg_queue_handler_t) 0;
+ }
+#endif
+ /* initialize the msg_queue_t */
+#if defined (FSL_RTOS_UCOSII)
+ p_tmp = (uint8_t*)msgq;
+ p_tmp += sizeof(msg_queue_t);
+ msgq->msgTbl = (void**)p_tmp;
+ p_tmp += max_msg_number*sizeof(void*);
+ msgq->msgs = (uint32_t*)p_tmp;
+#elif defined (FSL_RTOS_UCOSIII)
+ p_tmp = (uint8_t*)msgq;
+ p_tmp += sizeof(msg_queue_t);
+ msgq->msgs = (void*)p_tmp;
+#elif defined (FSL_RTOS_MQX)
+#elif defined (FSL_RTOS_FREE_RTOS)
+#else /* Bare metal by default. */
+ p_tmp = (uint8_t*) msgq;
+ p_tmp += sizeof(msg_queue_t);
+ msgq->queueMem = (uint32_t*) p_tmp;
+#endif
+ ret = OSA_MsgQCreate(msgq, max_msg_number, msg_size);
+#if !defined (FSL_RTOS_FREE_RTOS)
+ if (!ret)
+ {
+ OSA_MemFree(msgq);
+ }
+#endif
+ return ret;
+}
+
+uint32_t OS_MsgQ_destroy(os_msgq_handle msgq)
+{
+ if (kStatus_OSA_Success == OSA_MsgQDestroy((msg_queue_handler_t) msgq))
+ {
+#if !defined (FSL_RTOS_FREE_RTOS)
+ OSA_MemFree(msgq);
+#endif
+ return (uint32_t) OS_MSGQ_OK;
+ }
+ else
+ {
+ return (uint32_t) OS_MSGQ_ERROR;
+ }
+}
+
+/* Mutex create and destroy */
+os_mutex_handle OS_Mutex_create(void)
+{
+ mutex_t *p_mutex = (mutex_t *) OSA_MemAllocZero(sizeof(mutex_t));
+
+ if (!p_mutex)
+ {
+ return (os_mutex_handle) 0;
+ }
+ if (kStatus_OSA_Success != OSA_MutexCreate(p_mutex))
+ {
+ OSA_MemFree(p_mutex);
+ return (os_mutex_handle) 0;
+ }
+
+ return (os_mutex_handle) p_mutex;
+}
+
+uint32_t OS_Mutex_destroy(os_mutex_handle handle)
+{
+ if (kStatus_OSA_Success == OSA_MutexDestroy((mutex_t*) handle))
+ {
+ OSA_MemFree(handle);
+ return (uint32_t) OS_MUTEX_OK;
+ }
+ else
+ {
+ return (uint32_t) OS_MUTEX_ERROR;
+ }
+}
+
+/* Semaphore create and destroy */
+os_sem_handle OS_Sem_create(uint32_t initial_number)
+{
+ semaphore_t *p_sem = (semaphore_t *) OSA_MemAllocZero(sizeof(semaphore_t));
+
+ if (!p_sem)
+ {
+ return (os_sem_handle) 0;
+ }
+
+ if (kStatus_OSA_Success != OSA_SemaCreate(p_sem, initial_number))
+ {
+ OSA_MemFree(p_sem);
+ return (os_sem_handle) 0;
+ }
+
+ return (os_sem_handle) p_sem;
+}
+
+uint32_t OS_Sem_destroy(os_sem_handle handle)
+{
+ if (kStatus_OSA_Success == OSA_SemaDestroy((semaphore_t*) handle))
+ {
+ OSA_MemFree(handle);
+ return (uint32_t) OS_SEM_OK;
+ }
+ else
+ {
+ return (uint32_t) OS_SEM_ERROR;
+ }
+}
+
+/* Events */
+uint32_t OS_Event_check_bit(os_event_handle handle, uint32_t bitmask)
+{
+ event_t* event = (event_t*) handle;
+ return (((uint32_t) OSA_EventGetFlags(event)) & bitmask);
+}
+
+uint32_t OS_Event_set(os_event_handle handle, uint32_t bitmask)
+{
+ return ((kStatus_OSA_Success == OSA_EventSet((event_t*) (handle), (bitmask))) ? OS_EVENT_OK : OS_EVENT_ERROR);
+}
+
+uint32_t OS_Event_clear(os_event_handle handle, uint32_t bitmask)
+{
+ return ((kStatus_OSA_Success == OSA_EventClear((event_t*) (handle), (bitmask))) ? OS_EVENT_OK : OS_EVENT_ERROR);
+}
+
+uint32_t OS_Event_wait(os_event_handle handle, uint32_t bitmask, uint32_t flag, uint32_t timeout)
+{
+ osa_status_t status = kStatus_OSA_Idle;
+ event_flags_t event_bit;
+ uint32_t re;
+ event_t* event = (event_t*) handle;
+ // flag will always be false, so wait any bits
+#if (USE_RTOS)
+ if (0 == timeout)
+ {
+ timeout = OSA_WAIT_FOREVER;
+ }
+#endif
+ // Block or timeout mode
+ do
+ {
+ status = OSA_EventWait(event, bitmask, flag, timeout, &event_bit);
+ } while (kStatus_OSA_Idle == status);
+
+ switch(status)
+ {
+ case kStatus_OSA_Success:
+ re = (uint32_t) OS_EVENT_OK;
+ break;
+ case kStatus_OSA_Timeout:
+ re = (uint32_t) OS_EVENT_TIMEOUT;
+ break;
+ default:
+ re = (uint32_t) OS_EVENT_ERROR;
+ break;
+ }
+ return re;
+}
+
+/* Semaphore */
+uint32_t OS_Sem_post(os_sem_handle handle)
+{
+ return ((kStatus_OSA_Success == OSA_SemaPost((semaphore_t*) (handle))) ? OS_SEM_OK : OS_SEM_ERROR);
+}
+
+uint32_t OS_Sem_wait(os_sem_handle handle, uint32_t timeout)
+{
+ osa_status_t status = kStatus_OSA_Idle;
+ uint32_t re;
+#if (USE_RTOS)
+ if (0==timeout)
+ {
+ timeout = OSA_WAIT_FOREVER;
+ }
+#endif
+ do
+ {
+ status = OSA_SemaWait((semaphore_t*) handle, timeout);
+ } while (kStatus_OSA_Idle == status);
+
+ switch(status)
+ {
+ case kStatus_OSA_Success:
+ re = (uint32_t) OS_SEM_OK;
+ break;
+ case kStatus_OSA_Timeout:
+ re = (uint32_t) OS_SEM_TIMEOUT;
+ break;
+ default:
+ re = (uint32_t) OS_SEM_ERROR;
+ break;
+ }
+ return re;
+}
+
+/* Mutex */
+uint32_t OS_Mutex_lock(os_mutex_handle handle)
+{
+ osa_status_t status = kStatus_OSA_Idle;
+ uint32_t re;
+
+#if !(USE_RTOS)
+ status = OSA_MutexLock((mutex_t*) handle, 0);
+#else
+ status = OSA_MutexLock((mutex_t*)handle, OSA_WAIT_FOREVER);
+#endif
+
+ switch(status)
+ {
+ case kStatus_OSA_Success:
+ re = (uint32_t) OS_MUTEX_OK;
+ break;
+ default:
+ re = (uint32_t) OS_MUTEX_ERROR;
+ break;
+ }
+ return re;
+}
+
+uint32_t OS_Mutex_unlock(os_mutex_handle handle)
+{
+ return ((kStatus_OSA_Success == OSA_MutexUnlock((mutex_t*) (handle))) ? OS_MUTEX_OK : OS_MUTEX_ERROR);
+}
+
+/* Message queue */
+uint32_t OS_MsgQ_recv(os_msgq_handle msgq, void* msg, uint32_t flag, uint32_t timeout)
+{
+ osa_status_t status;
+ uint32_t re;
+
+ status = OSA_MsgQGet((msg_queue_handler_t)msgq, msg,
+ (!(OS_MSGQ_RECEIVE_BLOCK_ON_EMPTY & flag)) ?
+ 0u :
+ ((0==timeout) ? OSA_WAIT_FOREVER : timeout));
+
+ switch(status)
+ {
+ case kStatus_OSA_Success:
+ re = (uint32_t) OS_MSGQ_OK;
+ break;
+ case kStatus_OSA_Timeout:
+ re = (uint32_t) OS_MSGQ_TIMEOUT;
+ break;
+ default:
+ re = (uint32_t) OS_MSGQ_ERROR;
+ break;
+ }
+ return re;
+}
+
+uint32_t OS_MsgQ_send(os_msgq_handle msgq, void* msg, uint32_t flag)
+{
+ return ((kStatus_OSA_Success == OSA_MsgQPut((msg_queue_handler_t)(msgq),
+ msg
+ )) ? OS_MSGQ_OK : OS_MSGQ_ERROR);
+}
+
+uint32_t OS_MsgQ_Is_Empty(os_msgq_handle msgq, void* msg)
+{
+ return (kStatus_OSA_Success == OSA_MsgQGet((msg_queue_handler_t) msgq, msg, 0)) ? 0 : 1;
+}
+
diff --git a/KSDK_1.2.0/usb/adapter/sources/sdk/adapter_sdk.h b/KSDK_1.2.0/usb/adapter/sources/sdk/adapter_sdk.h
new file mode 100644
index 0000000..7e62da2
--- /dev/null
+++ b/KSDK_1.2.0/usb/adapter/sources/sdk/adapter_sdk.h
@@ -0,0 +1,115 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2013 Freescale Semiconductor;
+* All Rights Reserved
+*
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: osadapter_ucos.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+* @brief The file contains the definition of OS adapter base-on SDK OSA.
+*
+*****************************************************************************/
+
+#ifndef _USB_OSADAPTER_SDK_H
+#define _USB_OSADAPTER_SDK_H 1
+
+#include "fsl_os_abstraction.h"
+#if !defined (FSL_RTOS_MQX)
+#include "compiler.h"
+#endif
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "fsl_debug_console.h"
+
+#define BIG_ENDIAN 0
+#define LITTLE_ENDIAN 1
+
+#define ENDIANNESS LITTLE_ENDIAN
+
+#define _CODE_PTR_ *
+
+#ifndef FALSE
+#define FALSE ((bool)0)
+#endif
+
+#ifndef TRUE
+#define TRUE ((bool)1)
+#endif
+
+#define UNUSED(x) (void)x;
+
+#define OS_MSGQ_TIMEOUT (-2)
+//extern void * memset (void *, int32_t, unsigned);
+//extern int32_t printf_kinetis (const char *fmt, ...);
+
+#define USB_PRINTF PRINTF
+//#define OS_install_isr
+#define OS_install_isr(num, isr, data) OSA_InstallIntHandler(num, isr)
+#define OS_intr_init(num, prior, subprior, enable) \
+do { \
+ NVIC_SetPriority(num, prior); \
+ NVIC_EnableIRQ(num); \
+}while(0)
+
+#define TICKS_PER_SEC 1000
+
+//#define TICKS_TO_MSEC(ticks) ((ticks)*1000uL/OS_TICKS_PER_SEC)
+
+#define OS_Lock() OSA_EnterCritical(kCriticalDisableInt)
+#define OS_Unlock() OSA_ExitCritical(kCriticalDisableInt)
+
+/* Based on the targets it should be modified, for ColdFire it is MBYTES */
+#define OS_dcache_invalidate_mlines(p,n)
+#define OS_dcache_flush_mlines(p,n)
+
+
+#ifndef OS_Mem_alloc_uncached
+#define OS_Mem_alloc_uncached OS_Mem_alloc
+#endif
+
+#ifndef OS_Mem_alloc_uncached_zero
+#define OS_Mem_alloc_uncached_zero OS_Mem_alloc_zero
+#endif
+
+#define OS_Mem_alloc_zero(n) OSA_MemAllocZero(n)
+#define OS_Mem_alloc(n) OSA_MemAlloc(n)
+#define OS_Mem_free(ptr) OSA_MemFree(ptr)
+
+#define OS_Mem_zero(ptr,n) memset((ptr),(0),(n))
+#define OS_Mem_copy(src,dst,n) memcpy((dst),(src),(n))
+#if defined(__cplusplus)
+extern "C"{
+#endif
+extern uint32_t OS_MsgQ_Is_Empty(os_msgq_handle msgq, void* msg);
+
+#if defined(__cplusplus)
+}
+#endif
+/* TimeDelay */
+#define OS_Time_delay OSA_TimeDelay
+
+#endif
+
+
diff --git a/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/CMakeLists.txt b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/CMakeLists.txt
new file mode 100644
index 0000000..6e02997
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/CMakeLists.txt
@@ -0,0 +1,138 @@
+INCLUDE(CMakeForceCompiler)
+
+# CROSS COMPILER SETTING
+SET(CMAKE_SYSTEM_NAME Generic)
+CMAKE_MINIMUM_REQUIRED (VERSION 2.6)
+
+# THE VERSION NUMBER
+SET (Tutorial_VERSION_MAJOR 1)
+SET (Tutorial_VERSION_MINOR 0)
+
+# ENABLE ASM
+ENABLE_LANGUAGE(ASM)
+
+SET(CMAKE_STATIC_LIBRARY_PREFIX)
+SET(CMAKE_STATIC_LIBRARY_SUFFIX)
+
+SET(CMAKE_EXECUTABLE_LIBRARY_PREFIX)
+SET(CMAKE_EXECUTABLE_LIBRARY_SUFFIX)
+
+
+# CURRENT DIRECTORY
+SET(ProjDirPath ${CMAKE_CURRENT_SOURCE_DIR})
+
+# DEBUG ASM FLAGS
+SET(CMAKE_ASM_FLAGS_DEBUG "${CMAKE_ASM_FLAGS_DEBUG} -g -mcpu=cortex-m0plus -mthumb -Wall -fno-common -ffunction-sections -fdata-sections -ffreestanding -fno-builtin -Os -mapcs -std=gnu99 ")
+
+# DEBUG C FLAGS
+SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g -Wno-format -fno-strict-aliasing -mcpu=cortex-m0plus -mthumb -MMD -MP -Wall -fno-common -ffunction-sections -fdata-sections -ffreestanding -fno-builtin -Os -mapcs -std=gnu99")
+
+# RELEASE ASM FLAGS
+SET(CMAKE_ASM_FLAGS_RELEASE "${CMAKE_ASM_FLAGS_RELEASE} -mcpu=cortex-m0plus -mthumb -Wall -fno-common -ffunction-sections -fdata-sections -ffreestanding -fno-builtin -Os -mapcs -std=gnu99 ")
+
+# RELEASE C FLAGS
+SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -Wno-format -fno-strict-aliasing -mcpu=cortex-m0plus -mthumb -MMD -MP -Wall -fno-common -ffunction-sections -fdata-sections -ffreestanding -fno-builtin -Os -mapcs -std=gnu99")
+
+# ASM MACRO
+SET(CMAKE_ASM_FLAGS_DEBUG "${CMAKE_ASM_FLAGS_DEBUG} -DDEBUG")
+
+# C MACRO
+SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -D_DEBUG=1")
+SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DCPU_MKL27Z256VLH4")
+SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DFRDM_KL27Z")
+SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DFREEDOM")
+SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -D_DEBUG=0")
+SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -DCPU_MKL27Z256VLH4")
+SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -DFRDM_KL27Z")
+SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -DFREEDOM")
+
+# CXX MACRO
+
+# INCLUDE_DIRECTORIES
+IF(CMAKE_BUILD_TYPE MATCHES Debug)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../adapter/sources)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../adapter/sources/sdk)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../include)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../include)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../sources/classes/common)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../sources/classes/include)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../sources/classes/include/config)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../sources/classes/msd)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../sources/controller)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../sources/controller/khci)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../hal)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/osa/inc)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/utilities/inc)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/CMSIS/Include)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/devices)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/system/inc)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/hal/inc)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/drivers/inc)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../rtos)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/devices/MKL27Z4/include)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/devices/MKL27Z4/startup)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/devices/MKL27Z4)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../include/frdmkl27z)
+ELSEIF(CMAKE_BUILD_TYPE MATCHES Release)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../adapter/sources)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../adapter/sources/sdk)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../include)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../include)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../sources/classes/common)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../sources/classes/include)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../sources/classes/include/config)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../sources/classes/msd)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../sources/controller)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../sources/controller/khci)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../hal)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/osa/inc)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/utilities/inc)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/CMSIS/Include)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/devices)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/system/inc)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/hal/inc)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/drivers/inc)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../rtos)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/devices/MKL27Z4/include)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/devices/MKL27Z4/startup)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../../../../platform/devices/MKL27Z4)
+ INCLUDE_DIRECTORIES(${ProjDirPath}/../../../include/frdmkl27z)
+ENDIF()
+
+# ADD_LIBRARY
+ADD_LIBRARY(KsdkUsbDevicePlatformLib STATIC
+ "${ProjDirPath}/../../../../../adapter/sources/adapter.h"
+ "${ProjDirPath}/../../../../../adapter/sources/adapter_types.h"
+ "${ProjDirPath}/../../../../../adapter/sources/sdk/adapter_cfg.h"
+ "${ProjDirPath}/../../../../../adapter/sources/sdk/adapter_sdk.c"
+ "${ProjDirPath}/../../../../../adapter/sources/sdk/adapter_sdk.h"
+ "${ProjDirPath}/../../../../include/compiler.h"
+ "${ProjDirPath}/../../../../include/types.h"
+ "${ProjDirPath}/../../../../include/usb.h"
+ "${ProjDirPath}/../../../../include/usb_desc.h"
+ "${ProjDirPath}/../../../../include/usb_error.h"
+ "${ProjDirPath}/../../../../include/usb_misc.h"
+ "${ProjDirPath}/../../../../include/usb_opt.h"
+ "${ProjDirPath}/../../../../include/usb_types.h"
+ "${ProjDirPath}/../../../include/usb_device_stack_interface.h"
+ "${ProjDirPath}/../../../sources/classes/include/usb_class.h"
+ "${ProjDirPath}/../../../sources/classes/include/usb_class_msc.h"
+ "${ProjDirPath}/../../../sources/classes/common/usb_class.c"
+ "${ProjDirPath}/../../../sources/classes/common/usb_class_internal.h"
+ "${ProjDirPath}/../../../sources/classes/msd/usb_msc.c"
+ "${ProjDirPath}/../../../sources/classes/msd/usb_msc.h"
+ "${ProjDirPath}/../../../sources/classes/msd/usb_msc_scsi.c"
+ "${ProjDirPath}/../../../sources/classes/msd/usb_msc_scsi.h"
+ "${ProjDirPath}/../../../sources/controller/usb_dev.c"
+ "${ProjDirPath}/../../../sources/controller/usb_dev.h"
+ "${ProjDirPath}/../../../sources/controller/usb_framework.c"
+ "${ProjDirPath}/../../../sources/controller/usb_framework.h"
+ "${ProjDirPath}/../../../sources/controller/khci/device_khci_interface.c"
+ "${ProjDirPath}/../../../sources/controller/khci/khci_dev.c"
+ "${ProjDirPath}/../../../sources/controller/khci/khci_dev.h"
+ "${ProjDirPath}/../../../sources/controller/khci/khci_dev_misc.h"
+ "${ProjDirPath}/../../../include/frdmkl27z/usb_device_config.h"
+ "${ProjDirPath}/../../../sources/bsp/frdmkl27z/usb_dev_bsp.c"
+)
+
+SET_TARGET_PROPERTIES(KsdkUsbDevicePlatformLib PROPERTIES OUTPUT_NAME "libusbd_bm.a")
diff --git a/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_all.bat b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_all.bat
new file mode 100755
index 0000000..fedfe7c
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_all.bat
@@ -0,0 +1,5 @@
+cmake -DCMAKE_TOOLCHAIN_FILE="../../../../../../tools/cmake_toolchain_files/armgcc.cmake" -G "MinGW Makefiles" -DCMAKE_BUILD_TYPE=Debug .
+mingw32-make -j4
+cmake -DCMAKE_TOOLCHAIN_FILE="../../../../../../tools/cmake_toolchain_files/armgcc.cmake" -G "MinGW Makefiles" -DCMAKE_BUILD_TYPE=Release .
+mingw32-make -j4
+pause
diff --git a/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_all.sh b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_all.sh
new file mode 100755
index 0000000..3827529
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_all.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+cmake -DCMAKE_TOOLCHAIN_FILE="../../../../../../tools/cmake_toolchain_files/armgcc.cmake" -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Debug .
+make -j4
+cmake -DCMAKE_TOOLCHAIN_FILE="../../../../../../tools/cmake_toolchain_files/armgcc.cmake" -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release .
+make -j4
diff --git a/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_debug.bat b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_debug.bat
new file mode 100755
index 0000000..4f569ef
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_debug.bat
@@ -0,0 +1,3 @@
+cmake -DCMAKE_TOOLCHAIN_FILE="../../../../../../tools/cmake_toolchain_files/armgcc.cmake" -G "MinGW Makefiles" -DCMAKE_BUILD_TYPE=Debug .
+mingw32-make -j4
+pause
diff --git a/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_debug.sh b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_debug.sh
new file mode 100755
index 0000000..effd076
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_debug.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+cmake -DCMAKE_TOOLCHAIN_FILE="../../../../../../tools/cmake_toolchain_files/armgcc.cmake" -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Debug .
+make -j4
diff --git a/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_release.bat b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_release.bat
new file mode 100755
index 0000000..cc9d673
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_release.bat
@@ -0,0 +1,3 @@
+cmake -DCMAKE_TOOLCHAIN_FILE="../../../../../../tools/cmake_toolchain_files/armgcc.cmake" -G "MinGW Makefiles" -DCMAKE_BUILD_TYPE=Release .
+mingw32-make -j4
+pause
diff --git a/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_release.sh b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_release.sh
new file mode 100755
index 0000000..a12067d
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/build_release.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+cmake -DCMAKE_TOOLCHAIN_FILE="../../../../../../tools/cmake_toolchain_files/armgcc.cmake" -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release .
+make -j4
diff --git a/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/clean.bat b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/clean.bat
new file mode 100755
index 0000000..a3b733b
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/clean.bat
@@ -0,0 +1,3 @@
+RD /s /Q Debug Release CMakeFiles
+DEL /s /Q /F Makefile cmake_install.cmake CMakeCache.txt
+pause
diff --git a/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/clean.sh b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/clean.sh
new file mode 100755
index 0000000..795ad87
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/build/armgcc/usbd_sdk_frdmkl27z_bm/clean.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+rm -rf debug release CMakeFiles
+rm -rf Makefile cmake_install.cmake CMakeCache.txt
diff --git a/KSDK_1.2.0/usb/usb_core/device/include/frdmkl27z/usb_device_config.h b/KSDK_1.2.0/usb/usb_core/device/include/frdmkl27z/usb_device_config.h
new file mode 100644
index 0000000..5ae49f8
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/include/frdmkl27z/usb_device_config.h
@@ -0,0 +1,159 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2013 - 2015 Freescale Semiconductor;
+* All Rights Reserved
+*
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: usb_device_config.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+*
+*
+*END************************************************************************/
+
+#ifndef __usb_dev_config_h__
+#define __usb_dev_config_h__
+
+/* if KHCI device supported
+ * 1 supported
+ * 0 not supported
+ */
+#define USBCFG_DEV_KHCI 1
+
+/* if EHCI device supported
+ * 1 supported
+ * 0 not supported
+ */
+#define USBCFG_DEV_EHCI 0
+
+/* how many device KHCI instance supported */
+#if USBCFG_DEV_KHCI
+#define USBCFG_DEV_KHCI_NUM 1
+#else
+#define USBCFG_DEV_KHCI_NUM 0
+#endif
+
+/* how many device EHCI instance supported */
+#if USBCFG_DEV_EHCI
+#define USBCFG_DEV_EHCI_NUM 0
+#else
+#define USBCFG_DEV_EHCI_NUM 0
+#endif
+
+/* how many device instance supported */
+#define USBCFG_DEV_NUM (USBCFG_DEV_KHCI_NUM + USBCFG_DEV_EHCI_NUM)
+
+/* if HID device supported
+ * 1 supported
+ * 0 not supported
+ */
+#define USBCFG_DEV_HID 1
+
+/* if PHDC device supported
+ * 1 supported
+ * 0 not supported
+ */
+#define USBCFG_DEV_PHDC 1
+
+/* if AUDIO device supported
+ * 1 supported
+ * 0 not supported
+ */
+#define USBCFG_DEV_AUDIO 1
+
+/* if CDC device supported
+ * 1 supported
+ * 0 not supported
+ */
+#define USBCFG_DEV_CDC 1
+
+/* if MSC device supported
+ * 1 supported
+ * 0 not supported
+ */
+#define USBCFG_DEV_MSC 1
+
+/* if composite device supported
+ * 1 supported
+ * 0 not supported
+ */
+#define USBCFG_DEV_COMPOSITE 0
+
+/* if device is self powered
+ * 1 self power
+ * 0 bus power
+ */
+#define USBCFG_DEV_SELF_POWER 1
+
+/* if device remote wakeup supported
+ * 1 supported
+ * 0 not supported
+ */
+#define USBCFG_DEV_REMOTE_WAKEUP 0
+
+/* how many endpoints are supported */
+#define USBCFG_DEV_MAX_ENDPOINTS (6)
+
+/* how many XDs are supported at most */
+#define USBCFG_DEV_MAX_XDS (12)
+
+/* how many instance should be supported for one class type device */
+#define USBCFG_DEV_MAX_CLASS_OBJECT (1)
+
+#if USBCFG_DEV_KHCI
+ /*
+ ** Allow workaround for bug in the peripheral when unaligned buffer @4B address is used
+ */
+ #define USBCFG_KHCI_4BYTE_ALIGN_FIX (1)
+
+ #if USBCFG_KHCI_4BYTE_ALIGN_FIX
+ /*
+ ** The aligned buffer size for IN transactions, active when USBCFG_KHCI_4BYTE_ALIGN_FIX is defined
+ */
+ #define USBCFG_DEV_KHCI_SWAP_BUF_MAX (64)
+ #endif
+
+ #define USBCFG_DEV_KHCI_ADVANCED_ERROR_HANDLING (0)
+#endif
+
+/* if USB Keep Alive is enabled
+ * 1 enabled
+ * 0 not enabled
+ */
+#define USBCFG_DEV_KEEP_ALIVE_MODE (0)
+
+/* If the buffer provided by APP is cacheable
+* 1 cacheable, buffer cache maintenance is needed
+* 0 uncacheable, buffer cache maintenance is not needed
+*/
+#define USBCFG_DEV_BUFF_PROPERTY_CACHEABLE (0)
+
+#define USBCFG_DEV_ADVANCED_SUSPEND_RESUME (0)
+
+#define USBCFG_DEV_ADVANCED_CANCEL_ENABLE (1)
+
+#define USBCFG_DEV_DETACH_ENABLE (0)
+
+#define USBCFG_DEV_IO_DETACH_ENABLE (0)
+
+#endif
+
diff --git a/KSDK_1.2.0/usb/usb_core/device/include/usb_device_stack_interface.h b/KSDK_1.2.0/usb/usb_core/device/include/usb_device_stack_interface.h
new file mode 100644
index 0000000..ee2b1c9
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/include/usb_device_stack_interface.h
@@ -0,0 +1,618 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2008, 2013 - 2015 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ * Copyright (c) 1989-2008 ARC International;
+ * All Rights Reserved
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: usb_device_stack_interface.h$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ *
+ *
+ *END************************************************************************/
+/* Prototypes */
+#ifndef __usb_device_stack_interface_h__
+#define __usb_device_stack_interface_h__
+
+#include "usb_types.h"
+
+/* Informational Request/Set Types */
+#define USB_STATUS_DEVICE_STATE (0x01)
+#define USB_STATUS_INTERFACE (0x02)
+#define USB_STATUS_ADDRESS (0x03)
+#define USB_STATUS_CURRENT_CONFIG (0x04)
+#define USB_STATUS_SOF_COUNT (0x05)
+#define USB_STATUS_DEVICE (0x06)
+#define USB_STATUS_TEST_MODE (0x07)
+#define USB_STATUS_SPEED (0x08)
+
+#ifdef USBCFG_OTG
+#define USB_STATUS_OTG (0x09)
+#endif
+#define USB_STATUS_ENDPOINT (0x10)
+#define USB_STATUS_ENDPOINT_NUMBER_MASK (0x0F)
+
+#define USB_TEST_MODE_TEST_PACKET (0x0400)
+
+/* Available service types */
+/* Services 0 through 15 are reserved for endpoints */
+#define USB_SERVICE_EP0 (0x00)
+#define USB_SERVICE_EP1 (0x01)
+#define USB_SERVICE_EP2 (0x02)
+#define USB_SERVICE_EP3 (0x03)
+#define USB_SERVICE_BUS_RESET (0x10)
+#define USB_SERVICE_SUSPEND (0x11)
+//#define USB_SERVICE_SOF (0x12)
+#define USB_SERVICE_RESUME (0x13)
+#define USB_SERVICE_SLEEP (0x14)
+#define USB_SERVICE_SPEED_DETECTION (0x15)
+#define USB_SERVICE_ERROR (0x16)
+//#define USB_SERVICE_STALL (0x17)
+#define USB_SERVICE_REQUEST (0x18)
+#define USB_SERVICE_DETACH (0x19)
+
+#define USB_CONTROL_ENDPOINT (0)
+#define USB_SETUP_PKT_SIZE (8)/* Setup Packet Size */
+#define USB_UNINITIALIZED_VAL_32 (0xFFFFFFFF)
+
+#define USB_DEV_EVENT_BUS_RESET (0)
+#define USB_DEV_EVENT_CONFIG_CHANGED (1)
+#define USB_DEV_EVENT_INTERFACE_CHANGED (2)
+#define USB_DEV_EVENT_ENUM_COMPLETE (3)
+#define USB_DEV_EVENT_SEND_COMPLETE (4)
+#define USB_DEV_EVENT_DATA_RECEIVED (5)
+#define USB_DEV_EVENT_ERROR (6)
+#define USB_DEV_EVENT_GET_DATA_BUFF (7)
+#define USB_DEV_EVENT_EP_STALLED (8)
+#define USB_DEV_EVENT_EP_UNSTALLED (9)
+#define USB_DEV_EVENT_GET_TRANSFER_SIZE (0x10)
+#define USB_DEV_EVENT_TYPE_SET_REMOTE_WAKEUP (0x11)
+#define USB_DEV_EVENT_TYPE_CLR_REMOTE_WAKEUP (0x12)
+#define USB_DEV_EVENT_TYPE_SET_EP_HALT (0x13)
+#define USB_DEV_EVENT_TYPE_CLR_EP_HALT (0x14)
+#define USB_DEV_EVENT_DETACH (0x15)
+
+/* Macros for description of class, configuration, interface */
+#define USB_DESC_INTERFACE(index, ep_cnt, ep) \
+{ \
+ index, \
+ { \
+ ep_cnt, \
+ ep \
+ } \
+}
+#define USB_DESC_CONFIGURATION(intf_cnt, intf) \
+{ \
+ intf_cnt, \
+ intf \
+}
+#define USB_DESC_CLASS(type, config) \
+{ \
+ type, \
+ config, \
+}
+
+/* Go through each endpoint in class */
+#define for_each_ep_in_class_begin(epPtr, usbclassPtr, classtype) \
+ for(uint32_t class_i = 0; usbclassPtr[class_i].type != USB_CLASS_INVALID; class_i++) \
+ { \
+ if((usbclassPtr[class_i].type == classtype) || (classtype == USB_CLASS_ALL)) \
+ { \
+ for(uint32_t intf_i = 0; intf_i < usbclassPtr[class_i].interfaces.count; intf_i++) \
+ { \
+ for(uint32_t ep_i = 0; \
+ ((ep_i < usbclassPtr[class_i].interfaces.interface[intf_i].endpoints.count) && \
+ ((epPtr = usbclassPtr[class_i].interfaces.interface[intf_i].endpoints.ep + ep_i) != NULL)); \
+ ep_i++) \
+ {
+#define for_each_ep_in_class_end() }}}}
+
+/* Go through each interface in class */
+#define for_each_if_in_class_begin(ifPtr, usbclassPtr, classtype) \
+ for(uint32_t class_i = 0; usbclassPtr[class_i].type != USB_CLASS_INVALID; class_i++) \
+ { \
+ if((usbclassPtr[class_i].type == classtype) || (classtype == USB_CLASS_ALL)) \
+ { \
+ for(uint32_t intf_i = 0; ((intf_i < usbclassPtr[class_i].interfaces.count) \
+ && ((ifPtr = usbclassPtr[class_i].interfaces.interface + intf_i) != NULL)); \
+ intf_i++) \
+ {
+#define for_each_if_in_class_end() }}}
+
+typedef enum
+{
+ USB_CLASS_INFO = 0,
+ USB_COMPOSITE_INFO,
+ USB_AUDIO_UNITS,
+ USB_RNDIS_INFO,
+ USB_PHDC_QOS_INFO,
+ USB_MSC_LBA_INFO,
+ USB_CLASS_INTERFACE_INDEX_INFO,
+} entity_type;
+
+typedef enum
+{
+ USB_CLASS_HID = 0,
+ USB_CLASS_CDC,
+ USB_CLASS_MSC,
+ USB_CLASS_AUDIO,
+ USB_CLASS_PHDC,
+ USB_CLASS_ALL,
+ USB_CLASS_INVALID
+} class_type;
+/*!
+ * @brief Obtains the endpoint data structure.
+ *
+ * Define the endpoint data structure.
+ *
+ */
+typedef struct _usb_ep_struct
+{
+ uint8_t ep_num; /*!< endpoint number*/
+ uint8_t type; /*!< type of endpoint*/
+ uint8_t direction; /*!< direction of endpoint*/
+ uint32_t size; /*!< maximum packet size of endpoint*/
+} usb_ep_struct_t;
+
+/*!
+ * @brief Obtains the endpoint group.
+ *
+ * Structure Representing Endpoints and number of endpoints user want.
+ *
+ */
+typedef struct _usb_endpoints
+{
+ uint8_t count; /*!< how many endpoints are described*/
+ usb_ep_struct_t* ep; /*!< detailed information of each endpoint*/
+} usb_endpoints_t;
+
+/*!
+ * @brief Obtains the interface data structure.
+ *
+ * Structure Representing interface.
+ *
+ */
+typedef struct _usb_if_struct
+{
+ uint8_t index; /*!< interface index*/
+ usb_endpoints_t endpoints; /*!< endpoints in this interface*/
+} usb_if_struct_t;
+
+/*!
+ * @brief Obtains the interface group.
+ *
+ * Structure Representing how many interfaces in one class type.
+ *
+ */
+typedef struct _usb_interfaces_struct
+{
+ uint8_t count; /*!< how many interfaces are described*/
+ usb_if_struct_t* interface; /*!< detailed information of each interface*/
+} usb_interfaces_struct_t;
+
+/*!
+ * @brief Obtains the class data structure.
+ *
+ * Structure Representing class info.
+ *
+ */
+typedef struct _usb_class_struct
+{
+ class_type type; /*!< class type*/
+ usb_interfaces_struct_t interfaces; /*!< interfaces in this class*/
+} usb_class_struct_t;
+
+/*!
+ * @brief Obtains the composite information data structure.
+ *
+ * Structure Representing composite info.
+ *
+ */
+typedef struct _usb_composite_info_struct
+{
+ uint8_t count; /*!< how many classes in the composite device*/
+ usb_class_struct_t * class_handle; /*!< detailed information of each class*/
+} usb_composite_info_struct_t;
+
+/*!
+ * @brief Obtains the setup packet information data structure.
+ *
+ * Structure Representing setup packet.
+ *
+ */
+typedef struct _usb_setup_struct
+{
+ uint8_t request_type; /*!< type of request*/
+ uint8_t request; /*!< id of request*/
+ uint16_t value; /*!< value of request*/
+ uint16_t index; /*!< interface index*/
+ uint16_t length; /*!< data length of request*/
+} usb_setup_struct_t;
+
+/* USB Specs define CONTROL_MAX_PACKET_SIZE for High Speed device as only 64,
+ whereas for FS its allowed to be 8, 16, 32 or 64 */
+#define CONTROL_MAX_PACKET_SIZE (64)
+
+#if (USBCFG_DEV_EHCI && (CONTROL_MAX_PACKET_SIZE != 64))
+#error "For High Speed CONTROL_MAX_PACKET_SIZE should be 64"
+#endif
+
+/*!
+ * @brief Obtains the event information.
+ *
+ * Structure Representing event for an endpoint.
+ *
+ */
+typedef struct _usb_event_struct
+{
+ usb_device_handle handle; /* controller device handle*/
+ uint8_t* buffer_ptr; /* void* to buffer */
+ uint32_t len; /* the buffer len had been done
+ * special case: 0xFFFFFFFF means transfer cancel
+ * 0xFFFFFFFE means tansfer error */
+ uint8_t ep_num; /* endpoint number */
+ uint8_t type;
+ bool setup; /* is setup packet */
+ bool direction; /* direction of endpoint */
+} usb_event_struct_t;
+
+/* callback function pointer structure for Application to handle events */
+typedef void(_CODE_PTR_ usb_device_notify_t)(uint8_t event, void* val, void* arg);
+
+/* callback function pointer structure to handle USB framework request */
+typedef usb_status (_CODE_PTR_ usb_request_notify_t)(usb_setup_struct_t * setup,
+uint8_t **data,
+uint32_t *size,void* arg);
+
+typedef void(_CODE_PTR_ usb_event_service_t)(usb_event_struct_t* event, void* arg);
+
+/*!
+ * @brief Obtains the data structure of the descriptor related callback function. The application needs to implement them and passes it as the configuration parameter.
+ *
+ * Structure Representing the descriptor related callback function.
+ *
+ */
+typedef struct _usb_desc_request_notify_struct
+{
+#ifdef USBCFG_OTG
+ uint32_t handle;
+#endif
+ uint8_t (_CODE_PTR_ get_desc)(uint32_t class_handle,uint8_t type,uint8_t desc_index,
+ uint16_t index,uint8_t * *descriptor,uint32_t *size); /*!< to get the descriptor whose type is specified by the type*/
+ uint8_t (_CODE_PTR_ get_desc_interface)(uint32_t class_handle,uint8_t interface,
+ uint8_t * alt_interface); /*!< to get the interface's alternate setting*/
+ uint8_t (_CODE_PTR_ set_desc_interface)(uint32_t class_handle,uint8_t interface,
+ uint8_t alt_interface); /*!< to set the interface's alternate setting*/
+ uint8_t (_CODE_PTR_ set_configuration)(uint32_t class_handle, uint8_t config); /*!< to inform the application whose configuration is active */
+ uint8_t (_CODE_PTR_ get_desc_entity)(uint32_t class_handle, entity_type type, uint32_t * object); /*!< to get the descriptor/device related information*/
+} usb_desc_request_notify_struct_t;
+
+/*!
+ * @brief Obtains the callback for application.
+ *
+ * Structure Representing information for application callback.
+ *
+ */
+typedef struct usb_application_callback_struct
+{
+ usb_device_notify_t callback; /*!< application callback function*/
+ void* arg; /*!< parameter for callback function*/
+}usb_application_callback_struct_t;
+
+/*!
+ * @brief Obtains the callback for vendor request.
+ *
+ * Structure Representing information for vendor request callback.
+ *
+ */
+typedef struct usb_vendor_req_callback_struct
+{
+ usb_request_notify_t callback; /*!< vendor request callback function*/
+ void* arg; /*!< parameter for callback function*/
+}usb_vendor_req_callback_struct_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * @brief Initializes the USB device controller.
+ *
+ * The function initializes the device controller specified by the controller_id and a device
+ * handle can be returned from the handle.
+ *
+ * @param controller_id controller ID, such as USB_CONTROLLER_KHCI_0
+ * @param handle USB Device handle
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_init(uint8_t controller_id, usb_device_handle * handle);
+
+/*!
+ * @brief Un-initializes the USB device controller.
+ *
+ * The function un-initializes the device controller specified bcontroller_idy the handle.
+ *
+ * @param handle USB Device handle
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_deinit(usb_device_handle handle);
+
+/*!
+ * @brief Receives data from a specified endpoint.
+ *
+ * The function is used to receive data from a specified endpoint.
+ *
+ * @param handle USB Device handle
+ * @param ep_index endpoint index
+ * @param buff_ptr memory address to receive the data
+ * @param size length of the packet to be received
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_recv_data(usb_device_handle handle, uint8_t ep_num, uint8_t * buff_ptr, uint32_t size);
+
+/*!
+ * @brief Sends data from a specified endpoint.
+ *
+ * The function is used to send data to a specified endpoint.
+ *
+ * @param handle USB Device handle
+ * @param ep_index endpoint index
+ * @param buff_ptr memory address hold the data need to be sent
+ * @param size length of the packet to be sent
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_send_data(usb_device_handle handle, uint8_t ep_num, uint8_t * buff_ptr, uint32_t size);
+
+#if ((defined USBCFG_DEV_ADVANCED_CANCEL_ENABLE) && (USBCFG_DEV_ADVANCED_CANCEL_ENABLE))
+/*!
+ * @brief Cancels all the pending transfers in a specified endpoint.
+ *
+ * The function is used to cancel all the pending transfer in a specified endpoint which
+ * is determined by the endpoint index and the direction
+ *
+ * @param handle USB Device handle
+ * @param ep_index endpoint index
+ * @param direction direction of the endpoint
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_cancel_transfer(usb_device_handle handle, uint8_t ep_num, uint8_t direction);
+
+#endif
+/*!
+ * @brief Registers a callback function for one specified endpoint.
+ *
+ * The function is used to register a callback function for one specified endpoint.
+ *
+ * @param handle USB Device handle
+ * @param type service type, type & 0xF is the endpoint index
+ * @param service callback function
+ * @param arg second parameter for the callback function
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_register_service(usb_device_handle handle, uint8_t type, usb_event_service_t service, void* arg);
+
+/*!
+ * @brief Unregisters a callback function for one specified endpoint.
+ *
+ * The function is used to unregister a callback function for one specified endpoint.
+ *
+ * @param handle USB Device handle
+ * @param type service type, type & 0xF is the endpoint index
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_unregister_service(usb_device_handle handle, uint8_t type);
+
+#if ((defined USBCFG_DEV_ADVANCED_SUSPEND_RESUME) && (USBCFG_DEV_ADVANCED_SUSPEND_RESUME))
+/*!
+ * @brief Resume the process of usb.
+ *
+ * The function resumes the process of usb.
+ *
+ * @param handle USB Device handle
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_assert_resume(usb_device_handle handle);
+
+#endif
+/*!
+ * @brief Initializes the specified endpoint.
+ *
+ * The function is used to initialize a specific endpoint which is determined by the ep_ptr.
+ *
+ * @param handle USB Device handle
+ * @param ep_ptr endpoint information
+ * @param flag whether the ZLT is enabled for this endpoint
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_init_endpoint(usb_device_handle handle, usb_ep_struct_t* ep_ptr, uint8_t flag);
+
+/*!
+ * @brief Stalls the specified endpoint.
+ *
+ * The function is used to stall a specific endpoint which is determined by the endpoint
+ * index and endpoint direction.
+ *
+ * @param handle USB Device handle
+ * @param ep_num endpoint index
+ * @param direction endpoint direction
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_stall_endpoint(usb_device_handle handle, uint8_t ep_num, uint8_t direction);
+
+/*!
+ * @brief Un-stalls the specified endpoint.
+ *
+ * The function is used to un-stall a specific endpoint which is determined by the endpoint
+ * index and endpoint direction
+ *
+ * @param handle USB Device handle
+ * @param ep_num endpoint index
+ * @param direction endpoint direction
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_unstall_endpoint(usb_device_handle handle, uint8_t ep_num, uint8_t direction);
+
+/*!
+ * @brief Un-initializes the specified endpoint.
+ *
+ * The function is used to un-initialize a specific endpoint which is determined by the endpoint
+ * index and endpoint direction.
+ *
+ * @param handle USB Device handle
+ * @param ep_num endpoint index
+ * @param direction endpoint direction
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_deinit_endpoint(usb_device_handle handle, uint8_t ep_num, uint8_t direction);
+
+/*!
+ * @brief Registers the callback function for the application related event.
+ *
+ * The function is used to register a callback function for the application related event.
+ * Currently the following events are supported:
+ * Event Description
+ * USB_DEV_EVENT_BUS_RESET A BUS reset is received.
+ * USB_DEV_EVENT_ENUM_COMPLETE The device enumerated process completes.
+ * USB_DEV_EVENT_CONFIG_CHANGED Host sends a set_configuration.
+ * USB_DEV_EVENT_ERROR Error.
+ *
+ * @param handle USB Device handle
+ * @param device_notify_callback callback function
+ * @param device_notify_param parameter for the callback function
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_register_application_notify(usb_device_handle handle, usb_device_notify_t device_notify_callback, void* device_notify_param);
+
+/*!
+ * @brief Registers the callback function for the vendor class related event.
+ *
+ * The function is used to register a callback function for the vendor class request related event.
+ * Currently the vendor class is not implemented, so both the request_notify_callback and
+ * request_notify_param can be set to NULL.
+ *
+ * @param handle USB Device handle
+ * @param request_notify_callback callback function
+ * @param request_notify_param parameter for the callback function
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_register_vendor_class_request_notify(usb_device_handle handle, usb_request_notify_t request_notify_callback, void* request_notify_param);
+
+/*!
+ * @brief Registers the callback functions for the device descriptor related request.
+ *
+ * The function is used to register a set of callback functions for the device descriptor related event.
+ *
+ * @param handle USB Device handle
+ * @param desc_request_notify_callback callback function
+ * @param desc_request_notify_param parameter for the callback function
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_register_desc_request_notify(usb_device_handle handle,usb_desc_request_notify_struct_t* desc_request_notify_callback, void* desc_request_notify_param);
+
+/*!
+ * @brief Gets the internal USB device state.
+ *
+ * The function is used to get the status of the specified component. The supported components include:
+ * USB_STATUS_DEVICE_STATE
+ * USB_STATUS_OTG
+ * USB_STATUS_DEVICE
+ * USB_STATUS_ENDPOINT, the LSB nibble carries the endpoint number
+ *
+ * @param handle USB Device handle
+ * @param component callback function
+ * @param status requested status
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_get_status(usb_device_handle handle, uint8_t component, uint16_t* error);
+
+/*!
+ * @brief Sets the internal USB device state.
+ *
+ * The function is used to set the status of the specified component. The supported components include:
+ * USB_STATUS_DEVICE_STATE
+ * USB_STATUS_OTG
+ * USB_STATUS_DEVICE
+ *
+ * @param handle USB Device handle
+ * @param component callback function
+ * @param status status to set
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_set_status(usb_device_handle handle, uint8_t component, uint16_t setting);
+
+/*!
+ * @brief Initializes the USB device controller.
+ *
+ * The function starts the initialization process that cannot be done in the usb_device_init() API.
+ * For example, the call back functions need to be registered after the device handle can be
+ * obtained from the usb_device_init() API. Therefore, the USB interrupt cannot be enabled in
+ * usb_device_init(); otherwise, the USB interrupt can be issued before the callback functions are
+ * registered. To avoid this issue, the USB interrupt will be enabled in the post initialization process.
+ *
+ * @param controller_id controller ID, such as USB_CONTROLLER_KHCI_0
+ * @param handle USB Device handle
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_postinit(uint8_t controller_id, usb_device_handle handle);
+
+#ifdef USBCFG_OTG
+/*!
+ * @brief Initializes the USB device OTG.
+ *
+ * The function initializes the device OTG specified by the device handle.
+ *
+ * @param handle USB Device handle
+ * @param otg_attributes Attributes used to initialize otg. Currently supported are
+ * OTG_SRP_SUPPORT OTG_HNP_SUPPORT
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_otg_init(usb_device_handle handle, uint8_t otg_attributes);
+
+/*!
+ * @brief Get the status of whether OTG hnp is supported.
+ *
+ * The function get the status of whether OTG hnp is supported.
+ *
+ * @param handle USB Device handle
+ * @param hnp_support_ptr TRUE-supported/FALSE-not supported
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_otg_get_hnp_support(usb_device_handle handle, uint8_t* hnp_support_ptr);
+
+/*!
+ * @brief Enable the OTG hnp.
+ *
+ * The function enable the OTG hnp feature.
+ *
+ * @param handle USB Device handle
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_otg_set_hnp_enable(usb_device_handle handle);
+
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/bsp/frdmkl27z/usb_dev_bsp.c b/KSDK_1.2.0/usb/usb_core/device/sources/bsp/frdmkl27z/usb_dev_bsp.c
new file mode 100644
index 0000000..0827537
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/bsp/frdmkl27z/usb_dev_bsp.c
@@ -0,0 +1,153 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2013 - 2015 Freescale Semiconductor;
+* All Rights Reserved
+*
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* Comments:
+*
+*END************************************************************************/
+#include "adapter.h"
+#include "usb.h"
+#include "usb_device_config.h"
+#include "usb_misc.h"
+#include "fsl_usb_khci_hal.h"
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK)
+#include <stdint.h>
+#include <stdbool.h>
+#include <assert.h>
+#include "fsl_device_registers.h"
+#include "fsl_clock_manager.h"
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM)
+ #if (defined(CPU_MKL27Z64VLH4))
+#include "MKL27Z644/MKL27Z644_sim.h"
+#include "MKL27Z644/MKL27Z644_usb.h"
+ #endif
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+#include "MKL27Z644.h"
+#endif
+#include "usb_device_config.h"
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX) || (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM) || (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK)
+#define BSP_USB_INT_LEVEL (4)
+#define USB_CLK_RECOVER_IRC_EN (*(volatile unsigned char *)0x40072144)
+#define BSPCFG_USB_USE_IRC48M (1)
+
+extern uint8_t soc_get_usb_vector_number(uint8_t controller_id);
+extern uint32_t soc_get_usb_base_address(uint8_t controller_id);
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern _WEAK_FUNCTION(usb_status bsp_usb_dev_board_init(uint8_t controller_id));
+#ifdef __cplusplus
+ }
+#endif
+
+static usb_status bsp_usb_dev_soc_init
+(
+ uint8_t controller_id
+)
+{
+ int32_t ret = USB_OK;
+ uint8_t usb_instance = 0;
+ uint32_t base_addres = 0;
+ if (USB_CONTROLLER_KHCI_0==controller_id )
+ {
+ usb_instance = controller_id - USB_CONTROLLER_KHCI_0;
+ base_addres = soc_get_usb_base_address(controller_id);
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK)
+#if BSPCFG_USB_USE_IRC48M
+ /* IRC48MHz selected as CLK source */
+ CLOCK_SYS_SetUsbfsSrc(usb_instance, kClockUsbfsSrcIrc48M);
+ /* USB Clock Gating */
+ CLOCK_SYS_EnableUsbfsClock(usb_instance);
+ /* Enable IRC 48MHz for USB module, the regulator is always enabled on KL27 */
+ USB_CLK_RECOVER_IRC_EN = USB_CLK_RECOVER_IRC_EN_IRC_EN_MASK;
+#else
+ /* USB_CLKIN selected as CLK source */
+ CLOCK_SYS_SetUsbfsSrc(usb_instance, kClockUsbfsSrcExt);
+
+ /* USB Clock Gating */
+ CLOCK_SYS_EnableUsbfsClock(usb_instance);
+#endif
+
+ /* reset USB CTRL register */
+ usb_hal_khci_reset_control_register(base_addres);
+#if USBCFG_DEV_KEEP_ALIVE_MODE
+ USB0_CLK_RECOVER_CTRL |= USB_CLK_RECOVER_CTRL_CLOCK_RECOVER_EN_MASK;
+ USB0_KEEP_ALIVE_CTRL = USB_KEEP_ALIVE_CTRL_KEEP_ALIVE_EN_MASK|USB_KEEP_ALIVE_CTRL_OWN_OVERRD_EN_MASK
+ |USB_KEEP_ALIVE_CTRL_STOP_ACK_DLY_EN_MASK|USB_KEEP_ALIVE_CTRL_AHB_DLY_EN_MASK
+ |USB_KEEP_ALIVE_CTRL_WAKE_INT_EN_MASK;
+ /* wake on out and setup transaction */
+ USB0_KEEP_ALIVE_WKCTRL = 0x1;
+ MCG_MC |= MCG_MC_HIRCLPEN_MASK;
+ PMC_REGSC |= PMC_REGSC_BGEN_MASK|PMC_REGSC_VLPO_MASK;
+#endif
+
+ /* Enable internal pull-up resistor */
+ usb_hal_khci_set_internal_pullup(base_addres);
+ usb_hal_khci_set_trc0(base_addres); /* Software must set this bit to 1 */
+
+ /* setup interrupt */
+ OS_intr_init((IRQn_Type)soc_get_usb_vector_number(controller_id), BSP_USB_INT_LEVEL, 0, TRUE);
+
+#endif
+ }
+ else
+ {
+ ret = USBERR_BAD_STATUS; //unknow controller
+ }
+
+ return ret;
+}
+
+_WEAK_FUNCTION (usb_status bsp_usb_dev_board_init(uint8_t controller_id))
+{
+ usb_status ret = USB_OK;
+
+ controller_id = bsp_usb_dev_soc_init(controller_id);
+ if ( USB_CONTROLLER_KHCI_0==controller_id)
+ {
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK)
+
+#else
+
+#endif
+ }
+ else
+ {
+ ret = USBERR_BAD_STATUS;
+ }
+
+ return ret;
+}
+usb_status bsp_usb_dev_init(uint8_t controller_id)
+{
+ usb_status ret = USB_OK;
+
+ ret = bsp_usb_dev_soc_init(controller_id);
+ if (ret == USB_OK)
+ {
+ ret = bsp_usb_dev_board_init(controller_id);
+ }
+
+ return ret;
+}
+
+#endif
+/* EOF */
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/classes/common/usb_class.c b/KSDK_1.2.0/usb/usb_core/device/sources/classes/common/usb_class.c
new file mode 100644
index 0000000..6cb89ca
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/classes/common/usb_class.c
@@ -0,0 +1,376 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2008, 2013 - 2015 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ * Copyright (c) 1989-2008 ARC International;
+ * All Rights Reserved
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: usb_class.c$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ * @brief The file contains USB stack Class module implementation.
+ *
+ *****************************************************************************/
+
+/******************************************************************************
+ * Includes
+ *****************************************************************************/
+#include "usb_device_config.h"
+#include "usb.h"
+#include "usb_device_stack_interface.h"
+#include "usb_class_internal.h"
+
+#if USBCFG_DEV_HID || USBCFG_DEV_PHDC || USBCFG_DEV_AUDIO || USBCFG_DEV_CDC || USBCFG_DEV_MSC
+
+#include "usb_class_internal.h"
+#include "usb_framework.h"
+
+/*****************************************************************************
+ * Constant and Macro's
+ *****************************************************************************/
+
+/****************************************************************************
+ * Global Variables
+ ****************************************************************************/
+static usb_class_object_struct_t usb_class_object[USBCFG_DEV_MAX_CLASS_OBJECT];
+#if USBCFG_DEV_COMPOSITE
+static class_handle_t s_class_handle = USB_UNINITIALIZED_VAL_32;
+#endif
+/*****************************************************************************
+ * Local Types - None
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Local Functions Prototypes
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Local Variables
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Local Functions - None
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Global Functions
+ *****************************************************************************/
+
+/*************************************************************************//*!
+ *
+ * @name USB_Class_Allocate_Handle
+ *
+ * @brief The function reserves entry in device array and returns the index.
+ *
+ * @param none.
+ * @return returns the reserved handle or if no entry found device busy.
+ *
+ *****************************************************************************/
+static usb_status USB_Class_Allocate_Handle(usb_class_object_struct_t** pclassobj)
+{
+ int32_t cnt = 0;
+ for (;cnt< USBCFG_DEV_MAX_CLASS_OBJECT;cnt++)
+ {
+ if (usb_class_object[cnt].controller_handle == NULL)
+ {
+ *pclassobj = &usb_class_object[cnt];
+ return USB_OK;
+ }
+ }
+ return USBERR_DEVICE_BUSY;
+}
+
+/*************************************************************************//*!
+ *
+ * @name USB_Class_Free_Handle
+ *
+ * @brief The function releases entry in device array .
+ *
+ * @param handle index in device array to be released..
+ * @return returns and error code or USB_OK.
+ *
+ *****************************************************************************/
+static usb_status USB_Class_Free_Handle(usb_class_object_struct_t* handle)
+{
+ int32_t cnt = 0;
+ for (;cnt< USBCFG_DEV_MAX_CLASS_OBJECT;cnt++)
+ {
+ if (&usb_class_object[cnt] == handle)
+ {
+ usb_class_object[cnt].controller_handle = NULL;
+ usb_class_object[cnt].usb_fw_handle = 0;
+ usb_class_object[cnt].arg = NULL;
+ usb_class_object[cnt].class_callback = NULL;
+ return USB_OK;
+ }
+ }
+
+ return USBERR_INVALID_PARAM;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_Init
+ *
+ * @brief The function initializes the Class Module
+ *
+ * @param handle :handle to Identify the controller
+ * @param class_callback :event callback
+ * @param other_req_callback :call back for class/vendor specific requests on
+ * CONTROL ENDPOINT
+ *
+ * @return status
+ * USB_OK : When Successfully
+ * Others : Errors
+ *
+ *****************************************************************************/
+class_handle_t USB_Class_Init
+(
+usb_device_handle handle, /* [IN] the USB device controller to initialize */
+usb_device_notify_t class_callback,/*[IN]*/
+usb_request_notify_t other_req_callback,/*[IN]*/
+void* user_arg,/*[IN]*/
+usb_desc_request_notify_struct_t* desc_callback_ptr/*[IN]*/
+)
+{
+ usb_class_object_struct_t* class_object_ptr = NULL;
+ usb_status ret;
+
+ ret = USB_Class_Allocate_Handle(&class_object_ptr);
+ if (USBERR_DEVICE_BUSY == ret)
+ {
+ return USBERR_DEVICE_BUSY;
+ }
+
+ class_object_ptr->controller_handle = handle;
+ class_object_ptr->class_callback = class_callback;
+ class_object_ptr->arg = user_arg;
+
+ usb_device_register_application_notify(handle, class_callback, user_arg);
+ usb_device_register_vendor_class_request_notify(handle, other_req_callback, user_arg);
+ usb_device_register_desc_request_notify(handle, desc_callback_ptr, user_arg);
+
+#ifdef USBCFG_OTG
+ {
+ descriptor_union_t desc;
+ uint32_t config_size;
+ usb_status error;
+ uint8_t i;
+ uint8_t bm_attributes = 0;
+ error = desc_callback_ptr->get_desc(desc_callback_ptr->handle,USB_DESC_TYPE_CFG,0,0,(uint8_t **)&desc,&config_size);
+ if(error == USB_OK)
+ {
+ config_size = USB_SHORT_LE_TO_HOST(*(uint16_t*)&desc.cfig->wTotalLength[0]);
+ i= desc.cfig->bLength;
+ desc.word += desc.cfig->bLength;
+ while(i<config_size)
+ {
+ if (desc.otg->bDescriptorType == USB_DESC_TYPE_OTG)
+ {
+ /* Found the OTG descriptor */
+ bm_attributes = desc.otg->bmAttributes;
+ break;
+ } /* Endif */
+ i += desc.otg->bLength;
+ desc.word += desc.otg->bLength;
+ }
+ }
+ usb_device_otg_init(handle, bm_attributes);
+ }
+#endif
+#if USBCFG_DEV_COMPOSITE
+ /* Suppose only one class handle can be assigned */
+ s_class_handle = (class_handle_t)class_object_ptr;
+#endif
+ return (class_handle_t)class_object_ptr;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_Deinit
+ *
+ * @brief The function initializes the Class Module
+ *
+ * @param handle :handle to Identify the controller
+ * @param class_handle :class handle
+ *
+ * @return status
+ * USB_OK : When Successfully
+ * Others : Errors
+ *
+ *****************************************************************************/
+usb_status USB_Class_Deinit
+(
+usb_device_handle handle, /* [IN] the USB device controller to initialize */
+class_handle_t class_handle
+)
+{
+ usb_status error = USB_OK;
+
+ error = USB_Class_Free_Handle((usb_class_object_struct_t*)class_handle);
+
+#if USBCFG_DEV_COMPOSITE
+ /* Suppose only one class handle can be assigned */
+ s_class_handle = USB_UNINITIALIZED_VAL_32;
+#endif
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_Send_Data
+ *
+ * @brief The function calls the device to send data upon receiving an IN token
+ *
+ * @param handle: handle to Identify the controller
+ * @param ep_num: The endpoint number
+ * @param buff_ptr: buffer to send
+ * @param size: length of transfer
+ *
+ * @return status
+ * USB_OK : When Successfully
+ * Others : Errors
+ *
+ *****************************************************************************/
+usb_status USB_Class_Send_Data
+(
+class_handle_t handle, /*[IN]*/
+uint8_t ep_num, /* [IN] the Endpoint number */
+uint8_t * buff_ptr, /* [IN] buffer to send */
+uint32_t size /* [IN] length of the transfer */
+)
+{
+ usb_status error = USB_OK;
+ //uint16_t state;
+ usb_class_object_struct_t* class_object_ptr = (usb_class_object_struct_t*)handle;
+
+ if (NULL == class_object_ptr)
+ {
+ return USBERR_ERROR;
+ }
+
+ error = usb_device_send_data(class_object_ptr->controller_handle,
+ ep_num,buff_ptr,size);
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_Get_Status
+ *
+ * @brief The funtion calls the device to send data upon recieving an IN token
+ *
+ * @param handle: handle to Identify the controller
+ * @param component: component code
+ * @param error_code: the requested error
+ *
+ * @return status
+ * USB_OK : When Successfull
+ * Others : Errors
+ *
+ *****************************************************************************/
+usb_status USB_Class_Get_Status
+(
+class_handle_t handle, /* [IN] */
+uint8_t component, /* [IN] component code */
+uint16_t * error_code /* [OUT] the requested error */
+)
+{
+ usb_status error = USB_OK;
+ usb_class_object_struct_t* class_object_ptr = (usb_class_object_struct_t*)handle;
+
+ if (NULL == class_object_ptr)
+ {
+ return USBERR_ERROR;
+ }
+
+ error = usb_device_get_status(class_object_ptr->controller_handle,
+ component,error_code);
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_Periodic_Task
+ *
+ * @brief The function calls for periodic tasks
+ *
+ * @param None
+ *
+ * @return None
+ *
+ *****************************************************************************/
+void USB_Class_Periodic_Task(void)
+{
+#ifdef DELAYED_PROCESSING
+ USB_Framework_Periodic_Task();
+#endif
+}
+
+#if USBCFG_DEV_COMPOSITE
+/**************************************************************************//*!
+ *
+ * @name USB_Class_Get_Class_Handle
+ *
+ * @brief This function is called to return class handle.
+ *
+ * @return value:
+ * class handle
+ *
+ *****************************************************************************/
+class_handle_t USB_Class_Get_Class_Handle(void)
+{
+ return s_class_handle;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_Get_Ctrler_Handle
+ *
+ * @brief This function is called to return controller handle.
+ *
+ * @return value:
+ * controller handle
+ *
+ *****************************************************************************/
+usb_device_handle USB_Class_Get_Ctrler_Handle(class_handle_t class_handle)
+{
+ usb_device_handle ret;
+ if(USB_UNINITIALIZED_VAL_32 != class_handle)
+ {
+ ret = ((usb_class_object_struct_t*)class_handle)->controller_handle;
+ }
+ else
+ {
+ ret = NULL;
+ }
+ return ret;
+}
+#endif
+
+#endif
+/* EOF */
+
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/classes/common/usb_class_internal.h b/KSDK_1.2.0/usb/usb_core/device/sources/classes/common/usb_class_internal.h
new file mode 100644
index 0000000..e3cd99f
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/classes/common/usb_class_internal.h
@@ -0,0 +1,186 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2008, 2013 - 2014 Freescale Semiconductor;
+* All Rights Reserved
+*
+* Copyright (c) 1989-2008 ARC International;
+* All Rights Reserved
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: usb_class_internal.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+* @brief The file contains USB stack class layer api header function.
+*
+*****************************************************************************/
+
+#ifndef _USB_CLASS_INTERNAL_H
+#define _USB_CLASS_INTERNAL_H 1
+
+/******************************************************************************
+ * Includes
+ *****************************************************************************/
+#include "usb_class.h"
+
+
+/******************************************************************************
+ * Global Variables
+ *****************************************************************************/
+
+/******************************************************************************
+ * Macro's
+ *****************************************************************************/
+
+/******************************************************************************
+ * Types
+ *****************************************************************************/
+/* Structure holding USB class object state*/
+typedef struct _usb_class_object
+{
+ uint32_t usb_fw_handle;
+ usb_device_handle controller_handle;
+ void* arg;
+ usb_device_notify_t class_callback;
+} usb_class_object_struct_t;
+
+/******************************************************************************
+ * Global Functions
+ *****************************************************************************/
+/**************************************************************************//*!
+ *
+ * @name USB_Class_Init
+ *
+ * @brief The function initializes the Class Module
+ *
+ * @param handle :handle to Identify the controller
+ * @param class_callback :event callback
+ * @param other_req_callback :call back for class/vendor specific requests on
+ * CONTROL ENDPOINT
+ *
+ * @return status
+ * USB_OK : When Successfully
+ * Others : Errors
+ *
+ *****************************************************************************/
+class_handle_t USB_Class_Init
+(
+ usb_device_handle handle, /* [IN] the USB device controller to initialize */
+ usb_device_notify_t class_callback, /*[IN]*/
+ usb_request_notify_t other_req_callback,/*[IN]*/
+ void* user_arg, /*[IN]*/
+ usb_desc_request_notify_struct_t* desc_callback_ptr /*[IN]*/
+);
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_Deinit
+ *
+ * @brief The function initializes the Class Module
+ *
+ * @param handle :handle to Identify the controller
+ * @param class_handle :class handle
+ *
+ * @return status
+ * USB_OK : When Successfully
+ * Others : Errors
+ *
+ *****************************************************************************/
+usb_status USB_Class_Deinit
+(
+ usb_device_handle handle, /* [IN] the USB device controller to initialize */
+ class_handle_t class_handle
+ );
+ /**************************************************************************//*!
+ *
+ * @name USB_Class_Send_Data
+ *
+ * @brief The function calls the device to send data upon receiving an IN token
+ *
+ * @param handle: handle to Identify the controller
+ * @param ep_num: The endpoint number
+ * @param buff_ptr: buffer to send
+ * @param size: length of transfer
+ *
+ * @return status
+ * USB_OK : When Successfully
+ * Others : Errors
+ *
+ *****************************************************************************/
+usb_status USB_Class_Send_Data
+(
+ class_handle_t handle, /*[IN]*/
+ uint8_t ep_num, /* [IN] the Endpoint number */
+ uint8_t* buff_ptr, /* [IN] buffer to send */
+ uint32_t size /* [IN] length of the transfer */
+);
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_Get_Status
+ *
+ * @brief The funtion calls the device to send data upon recieving an IN token
+ *
+ * @param handle: handle to Identify the controller
+ * @param component: component code
+ * @param error_code: the requested error
+ *
+ * @return status
+ * USB_OK : When Successfull
+ * Others : Errors
+ *
+ *****************************************************************************/
+usb_status USB_Class_Get_Status
+(
+ class_handle_t handle, /* [IN] */
+ uint8_t component, /* [IN] component code */
+ uint16_t * error_code /* [OUT] the requested error */
+);
+
+
+#ifdef USBCFG_DEV_COMPOSITE
+/**************************************************************************//*!
+ *
+ * @name USB_Class_Get_Class_Handle
+ *
+ * @brief This function is called to return class handle.
+ *
+ * @return value:
+ * class handle
+ *
+ *****************************************************************************/
+class_handle_t USB_Class_Get_Class_Handle(void);
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_Get_Ctrler_Handle
+ *
+ * @brief This function is called to return controller handle.
+ *
+ * @return value:
+ * controller handle
+ *
+ *****************************************************************************/
+usb_device_handle USB_Class_Get_Ctrler_Handle(class_handle_t class_handle);
+#endif
+
+#endif
+
+/* EOF */
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/classes/include/config/usb_msc_config.h b/KSDK_1.2.0/usb/usb_core/device/sources/classes/include/config/usb_msc_config.h
new file mode 100644
index 0000000..3363cbb
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/classes/include/config/usb_msc_config.h
@@ -0,0 +1,54 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2014-2015 Freescale Semiconductor;
+* All Rights Reserved
+*
+* Copyright (c) 1989-2008 ARC International;
+* All Rights Reserved
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: usb_msc_config.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+* @brief The file contains USB stack MSC class layer api header function.
+*
+*****************************************************************************/
+
+#ifndef _USB_MSC_CONFIG_H
+#define _USB_MSC_CONFIG_H 1
+
+/******************************************************************************
+ * Macro's
+ *****************************************************************************/
+
+/* If Implementing Disk Drive then configure the macro below as TRUE,
+ otherwise keep it False(say for Hard Disk)*/
+#define IMPLEMENTING_DISK_DRIVE (0) /*1: TRUE; 0:FALSE*/
+
+#define MSD_RECV_MAX_TRANS_LENGTH (65536)
+#define MSD_SEND_MAX_TRANS_LENGTH (65536)
+
+#define MAX_MSC_DEVICE (0x01)
+#define MAX_MSC_SUPPORTED_INTERFACES (0x01)
+
+
+#endif
+
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/classes/include/usb_class.h b/KSDK_1.2.0/usb/usb_core/device/sources/classes/include/usb_class.h
new file mode 100644
index 0000000..883c8e3
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/classes/include/usb_class.h
@@ -0,0 +1,116 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2008, 2013 - 2014 Freescale Semiconductor;
+* All Rights Reserved
+*
+* Copyright (c) 1989-2008 ARC International;
+* All Rights Reserved
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: usb_class.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+* @brief The file contains USB stack class layer api header function.
+*
+*****************************************************************************/
+
+#ifndef _USB_CLASS_H
+#define _USB_CLASS_H 1
+
+/******************************************************************************
+ * Includes
+ *****************************************************************************/
+
+#include "types.h"
+
+/******************************************************************************
+ * Global Variables
+ *****************************************************************************/
+
+/******************************************************************************
+ * Macro's
+ *****************************************************************************/
+ /*#define DELAYED_PROCESSING 1 This define is used to delay the control
+ processing and not have it executed as part
+ of the interrupt routine */
+
+//#define UNINITIALISED_VAL (0xffffffff)
+/* Events to the Application */
+/*
+#define USB_APP_BUS_RESET (0)
+#define USB_APP_CONFIG_CHANGED (1)
+#define USB_APP_ENUM_COMPLETE (2)
+#define USB_APP_SEND_COMPLETE (3)
+#define USB_APP_DATA_RECEIVED (4)
+#define USB_APP_ERROR (5)
+#define USB_APP_GET_DATA_BUFF (6)
+#define USB_APP_EP_STALLED (7)
+#define USB_APP_EP_UNSTALLED (8)
+#define USB_APP_GET_TRANSFER_SIZE (9)
+*/
+
+/******************************************************************************
+ * Types
+ *****************************************************************************/
+typedef uint32_t class_handle_t;
+
+/*callback function pointer structure for application to provide class params*/
+typedef uint8_t (_CODE_PTR_ usb_class_specific_handler_func)(
+ uint8_t event,
+ uint16_t value,
+ uint8_t **data,
+ uint32_t* size,
+ void* arg);
+
+
+typedef struct usb_class_specific_handler_callback_struct
+{
+ usb_class_specific_handler_func callback;
+ void* arg;
+}usb_class_specific_callback_struct_t;
+
+
+/******************************************************************************
+ * Global Functions
+ *****************************************************************************/
+#if defined(__cplusplus)
+ extern "C" {
+#endif
+/**************************************************************************//*!
+ *
+ * @name USB_Class_Periodic_Task
+ *
+ * @brief The function calls for periodic tasks
+ *
+ * @param None
+ *
+ * @return None
+ *
+ *****************************************************************************/
+extern void USB_Class_Periodic_Task(void);
+
+#if defined(__cplusplus)
+ }
+#endif
+
+#endif
+
+/* EOF */
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/classes/include/usb_class_msc.h b/KSDK_1.2.0/usb/usb_core/device/sources/classes/include/usb_class_msc.h
new file mode 100644
index 0000000..3ada631
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/classes/include/usb_class_msc.h
@@ -0,0 +1,201 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2008, 2013 - 2014 Freescale Semiconductor;
+* All Rights Reserved
+*
+* Copyright (c) 1989-2008 ARC International;
+* All Rights Reserved
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: usb_class_msc.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+* @brief
+*
+*****************************************************************************/
+
+#ifndef _USB_CLASS_MSC_H
+#define _USB_CLASS_MSC_H 1
+
+/******************************************************************************
+ * Includes
+ *****************************************************************************/
+#include "usb_class.h"
+#include "usb_device_stack_interface.h"
+
+/******************************************************************************
+ * Constants - None
+ *****************************************************************************/
+
+/******************************************************************************
+ * Macro's
+ *****************************************************************************/
+#define MAX_MSC_CLASS_EP_NUM 2
+
+#define USB_MSC_DEVICE_READ_REQUEST (0x81)
+#define USB_MSC_DEVICE_WRITE_REQUEST (0x82)
+#define USB_MSC_DEVICE_FORMAT_COMPLETE (0x83)
+#define USB_MSC_DEVICE_REMOVAL_REQUEST (0x84)
+#define USB_MSC_DEVICE_GET_INFO (0x85)
+#define USB_MSC_START_STOP_EJECT_MEDIA (0x86)
+#define USB_MSC_DEVICE_GET_SEND_BUFF_INFO (0x87)
+#define USB_MSC_DEVICE_GET_RECV_BUFF_INFO (0x88)
+
+/* macros for queuing */
+ #define MSD_MAX_QUEUE_ELEMS (4)
+
+ #define USB_REQ_VAL_INVALID (0xFFFF)
+
+typedef uint32_t msd_handle_t;
+
+/*!
+ * @brief MSC app data structure.
+ *
+ * Holds the information of msc app data struct
+ *
+ */
+typedef struct _msc_app_data_struct
+{
+ uint8_t* data_ptr; /*!< pointer to buffer */
+ uint32_t data_size; /*!< buffer size of endpoint*/
+}msc_app_data_struct_t;
+
+/*!
+ * @brief MSC detailed information about the LAB structure.
+ *
+ * Holds the detailed information about the LAB
+ *
+ */
+typedef struct _device_lba_info_struct
+{
+ uint32_t total_lba_device_supports; /*!< blocks number */
+ uint32_t length_of_each_lab_of_device; /*!< size of each block*/
+ uint8_t num_lun_supported; /*!< number of LUN*/
+}device_lba_info_struct_t;
+
+/*!
+ * @brief MSC buffer information structure.
+ *
+ * Holds the detailed information about the buffer
+ *
+ */
+typedef struct _msd_buffers_info
+{
+ uint8_t* msc_bulk_in_ptr; /*!< pointer to bulk in buffer*/
+ uint8_t* msc_bulk_out_ptr; /*!< pointer to bulk out buffer*/
+ uint32_t msc_bulk_in_size; /*!< size of bulk in buffer*/
+ uint32_t msc_bulk_out_size;/*!< size of bulk out buffer*/
+}msc_buff_info_t;
+
+/*!
+ * @brief MSD Configuration structure to be passed by APP
+ *
+ * Holds the detailed information about the MSC configuration
+ *
+ */
+typedef struct _msc_config_struct
+{
+ /* SCSI related initialization data. To be moved to SCSI layer.*/
+
+ usb_application_callback_struct_t msc_application_callback; /*!< application callback function to handle the Device status related event*/
+ usb_vendor_req_callback_struct_t vendor_req_callback; /*!< application callback function to handle the vendor request related event, reserved for future use*/
+ usb_class_specific_callback_struct_t class_specific_callback; /*!< application callback function to handle all the class related event*/
+ usb_desc_request_notify_struct_t* desc_callback_ptr; /*!< descriptor related callback function data structure*/
+}msc_config_struct_t;
+
+/*!
+ * @brief MSC logical block access information structure.
+ *
+ * Holds the information used to perform the logical block access
+ *
+ */
+typedef struct _lba_app_struct
+{
+ uint32_t offset; /*!< offset of target block need to access*/
+ uint32_t size; /*!< size need to access*/
+ uint8_t* buff_ptr; /*!< used to save the content by access the target block*/
+}lba_app_struct_t;
+//extern void USB_Class_Periodic_Task(void);
+#define USB_MSC_Periodic_Task USB_Class_Periodic_Task
+/******************************************************************************
+ * Global Functions
+ *****************************************************************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*!
+* @brief The function initializes the Device and Controller layer.
+*
+* The application calls this API function to initialize the MSD class, the underlying layers, and
+* the controller hardware.
+*
+* @param controller_id controller ID, such as USB_CONTROLLER_KHCI_0
+* @param msd_config_ptr MSD configuration structure
+* @param msd_handle pointer point to the initialized MSD class
+* @return USB_OK-Success/Others-Fail
+*/
+extern usb_status USB_Class_MSC_Init
+(
+ uint8_t controller_id,
+ msc_config_struct_t* msd_config_ptr,
+ msd_handle_t * msd_handle
+);
+
+/*!
+ * @brief The function De-initializes the Device and Controller layer.
+ *
+ * The application calls this API function to de-initialize the MSD class, the underlying layers, and
+ * the controller hardware.
+ *
+ * @param msd_handle MSC class handler
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status USB_Class_MSC_Deinit
+(
+ msd_handle_t msd_handle
+);
+
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_MSC_Get_Speed
+ *
+ * @brief This functions get speed from Host.
+ *
+ * @param handle : handle returned by USB_Class_MSC_Init
+ * @param speed : speed
+ *
+ * @return status
+ * USB_OK : When Successfull
+ * Others : Errors
+ *****************************************************************************/
+extern usb_status USB_Class_MSC_Get_Speed
+(
+ msd_handle_t handle,
+ uint16_t * speed/* [OUT] the requested error */
+);
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc.c b/KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc.c
new file mode 100644
index 0000000..e29bca8
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc.c
@@ -0,0 +1,1580 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2008, 2013 - 2015 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ * Copyright (c) 1989-2008 ARC International;
+ * All Rights Reserved
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: usb_msc.c$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ * @brief The file contains USB stack MSC layer implementation.
+ *
+ *****************************************************************************/
+
+/******************************************************************************
+ * Includes
+ *****************************************************************************/
+#include "usb_device_config.h"
+#include "usb.h"
+#include "usb_device_stack_interface.h"
+
+#if USBCFG_DEV_MSC
+#include "usb_class_internal.h"
+#include "usb_msc.h"
+#include "usb_opt.h"
+/*****************************************************************************
+ * Constant and Macro's
+ *****************************************************************************/
+
+/****************************************************************************
+ * Global Variables
+ ****************************************************************************/
+msc_device_struct_t g_msc_class[MAX_MSC_DEVICE];
+
+#if ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM) || ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK)))
+cbw_t g_msc_class_cbw;
+csw_t g_msc_class_csw;
+#endif
+/*****************************************************************************
+ * Local Types - None
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Local Functions Prototypes
+ *****************************************************************************/
+usb_status process_mass_storage_command (msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr);
+
+/*****************************************************************************
+ * Local Variables - None
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Local Functions
+ *****************************************************************************/
+
+/*************************************************************************//*!
+ *
+ * @name USB_Msd_Allocate_Handle
+ *
+ * @brief The function reserves entry in device array and returns the index.
+ *
+ * @param none.
+ * @return returns the reserved handle or if no entry found device busy.
+ *
+ *****************************************************************************/
+static usb_status USB_Msd_Allocate_Handle(msc_device_struct_t** handle)
+{
+ uint32_t cnt = 0;
+ for (;cnt< MAX_MSC_DEVICE;cnt++)
+ {
+ if (g_msc_class[cnt].controller_handle == NULL)
+ {
+ *handle = (msc_device_struct_t*)&g_msc_class[cnt];
+ return USB_OK;
+ }
+ }
+ return USBERR_DEVICE_BUSY;
+}
+/*************************************************************************//*!
+ *
+ * @name USB_Msd_Free_Handle
+ *
+ * @brief The function releases entry in device array .
+ *
+ * @param handle index in device array to be released..
+ * @return returns and error code or USB_OK.
+ *
+ *****************************************************************************/
+
+static usb_status USB_Msd_Free_Handle(msc_device_struct_t* handle)
+{
+ int32_t cnt = 0;
+ for (;cnt< MAX_MSC_DEVICE;cnt++)
+ {
+ if ((&g_msc_class[cnt]) == handle)
+ {
+ OS_Mem_zero((void*)handle, sizeof(msc_device_struct_t));
+ return USB_OK;
+ }
+ }
+ return USBERR_INVALID_PARAM;
+}
+
+/*************************************************************************//*!
+ *
+ * @name USB_Msd_Get_Device_Ptr
+ *
+ * @brief The function gets the device pointer from device array .
+ *
+ * @param handle index in device array.
+ * @return returns returns pointer to MSD device structure..
+ *
+ *****************************************************************************/
+static msc_device_struct_t * USB_Msd_Get_Device_Ptr(msd_handle_t handle)
+{
+ return (msc_device_struct_t *)handle;
+}
+
+/*************************************************************************//*!
+ *
+ * @name USB_Msd_Get_Desc_Info
+ *
+ * @brief The function gets the info of the descriptors. .
+ *
+ * @param handle index in device array.
+ * @param type descriptor type.
+ * @param object store the returned value.
+ * @return returns USB_OK if successful.
+ *
+ *****************************************************************************/
+static usb_status USB_Msd_Get_Desc_Info(msc_device_struct_t * msc_dev_ptr,USB_MSD_DESC_INFO_T type, uint32_t * object)
+{
+#if USBCFG_DEV_COMPOSITE
+ uint32_t interface_index = 0xFF;
+#endif
+ /* Get class info */
+
+ switch(type)
+ {
+ case USB_MSD_INTERFACE_COUNT:
+#if USBCFG_DEV_COMPOSITE
+ *object = MAX_MSC_SUPPORTED_INTERFACES + 2;
+#else
+ *object = MAX_MSC_SUPPORTED_INTERFACES;
+#endif
+ break;
+#if USBCFG_DEV_COMPOSITE
+ case USB_MSD_CLASS_INFO:
+ {
+ uint32_t class_i;
+ usb_composite_info_struct_t* usbcompinfoPtr;
+ /* Get class info */
+ msc_dev_ptr->desc_callback.get_desc_entity((uint32_t)msc_dev_ptr->controller_handle,
+ USB_COMPOSITE_INFO,
+ (uint32_t *)&usbcompinfoPtr);
+ msc_dev_ptr->desc_callback.get_desc_entity((uint32_t)msc_dev_ptr,
+ USB_CLASS_INTERFACE_INDEX_INFO,
+ (uint32_t *)&interface_index);
+ *object = 0;
+ for (class_i = 0; class_i < usbcompinfoPtr->count; class_i++)
+ {
+ if ((USB_CLASS_MSC == usbcompinfoPtr->class_handle[class_i].type) && (class_i == interface_index))
+ {
+ *object = (uint32_t)&(usbcompinfoPtr->class_handle[class_i]);
+ break;
+ }
+ }
+ }
+ break;
+#endif
+ default :
+ break;
+ }
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ *
+ * @name process_mass_storage_command
+ *
+ * @brief Process a Mass storage class command
+ * This function is added here to add more sub class specific commands)
+ *
+ * @param msc_device_struct_t *
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status process_mass_storage_command
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ usb_status error = USBERR_ERROR;/* initializing to error value */
+ switch (cbw_ptr->command_block[0])
+ {
+ /* commands to be supported by all devices */
+ case INQUIRY_COMMAND : /*opcode : 0x12*/
+ error = msc_inquiry_command(msc_obj_ptr, cbw_ptr,csw_residue_ptr,
+ csw_status_ptr);
+ break;
+ case READ_10_COMMAND : /*opcode : 0x28 */
+ case READ_12_COMMAND : /*opcode : 0xA8 */
+ error = msc_read_command(msc_obj_ptr,
+ cbw_ptr,csw_residue_ptr,csw_status_ptr);
+ break;
+ case REQUEST_SENSE_COMMAND : /*opcode : 0x03*/
+ error = msc_request_sense_command(msc_obj_ptr, cbw_ptr,csw_residue_ptr,
+ csw_status_ptr);
+ break;
+ case TEST_UNIT_READY_COMMAND : /*opcode : 0x00 */
+ error = msc_test_unit_ready_command(msc_obj_ptr, cbw_ptr,csw_residue_ptr,
+ csw_status_ptr);
+ break;
+ case WRITE_10_COMMAND : /*opcode : 0x2A */
+ case WRITE_12_COMMAND : /*opcode : 0xAA */
+ error = msc_write_command(msc_obj_ptr, cbw_ptr,csw_residue_ptr,
+ csw_status_ptr);
+ break;
+ case PREVENT_ALLOW_MEDIUM_REM_COMMAND : /*opcode :0x1E */
+ error = msc_prevent_allow_medium_removal(msc_obj_ptr, cbw_ptr,csw_residue_ptr,
+ csw_status_ptr);
+ break;
+ case FORMAT_UNIT_COMMAND : /*opcode : 0x04*/
+ error = msc_format_unit_command(msc_obj_ptr, cbw_ptr,csw_residue_ptr,
+ csw_status_ptr);
+ break;
+ case READ_CAPACITY_10_COMMAND : /*opcode : 0x25*/
+ case READ_CAPACITY_16_COMMAND : /*opcode : 0x9E*/
+ error = msc_read_capacity_command(msc_obj_ptr, cbw_ptr,csw_residue_ptr,
+ csw_status_ptr);
+ break;
+ case MODE_SENSE_10_COMMAND : /* opcode :0x5A*/
+ case MODE_SENSE_6_COMMAND : /* opcode : 0x1A */
+ error = msc_mode_sense_command(msc_obj_ptr, cbw_ptr,csw_residue_ptr,
+ csw_status_ptr);
+ break;
+ case MODE_SELECT_10_COMMAND : /*opcode : 0x55 */
+ case MODE_SELECT_6_COMMAND : /*opcode : 0x15 */
+ error = msc_mode_select_command(msc_obj_ptr, cbw_ptr,csw_residue_ptr,
+ csw_status_ptr);
+ break;
+ case READ_FORMAT_CAPACITIES_COMMAND : /*opcode : 0x23 */
+ error = msc_read_format_capacity_command(msc_obj_ptr, cbw_ptr,csw_residue_ptr,
+ csw_status_ptr);
+ break;
+ case SEND_DIAGNOSTIC_COMMAND : /*opcode : 0x1D*/
+ error = msc_send_diagnostic_command(msc_obj_ptr, cbw_ptr,csw_residue_ptr,
+ csw_status_ptr);
+ break;
+ case VERIFY_COMMAND : /*opcode : 0x2F*/
+ error = msc_verify_command(msc_obj_ptr, cbw_ptr,csw_residue_ptr,
+ csw_status_ptr);
+ break;
+ case START_STOP_UNIT_COMMAND : /*opcode : 0x1B*/
+ error = msc_start_stop_unit_command(msc_obj_ptr, cbw_ptr,csw_residue_ptr,
+ csw_status_ptr);
+ break;
+ default: /* for all unsupported commands */
+ error = msc_unsupported_command(msc_obj_ptr, cbw_ptr,csw_residue_ptr,
+ csw_status_ptr);
+ msc_obj_ptr->out_flag = FALSE;
+ msc_obj_ptr->in_flag = FALSE;
+ msc_obj_ptr->out_stall_flag = FALSE;
+ msc_obj_ptr->in_stall_flag = FALSE;
+ msc_obj_ptr->need_out_stall_flag = FALSE;
+ msc_obj_ptr->need_in_stall_flag = FALSE;
+ break;
+ }
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Service_Bulk_In
+ *
+ * @brief The function is callback function of DIC Bulk In Endpoint
+ *
+ * @param event
+ * @param arg
+ * @return None
+ *
+ *****************************************************************************/
+void USB_Service_Bulk_In(usb_event_struct_t* event, void* arg)
+{
+ //uint8_t event_type;
+ csw_t * csw_ptr;
+ msc_device_struct_t * msc_obj_ptr;
+
+ msc_obj_ptr = (msc_device_struct_t *)arg;
+
+ if (NULL == msc_obj_ptr)
+ {
+#if _DEBUG
+ USB_PRINTF("USB_Service_Bulk_In: msc_obj_ptr is NULL\n");
+#endif
+ return;
+ }
+
+ if (event->len == 0xFFFFFFFF)
+ {
+ if((msc_obj_ptr->in_flag) && (msc_obj_ptr->class_specific_callback.callback != NULL)
+ && ((READ_10_COMMAND == msc_obj_ptr->cbw_ptr->command_block[0])
+ || (READ_12_COMMAND == msc_obj_ptr->cbw_ptr->command_block[0])))
+ {
+ lba_app_struct_t lba_data;
+
+ lba_data.size = 0;
+ lba_data.buff_ptr = event->buffer_ptr;
+ lba_data.offset = 0;
+ msc_obj_ptr->class_specific_callback.callback(USB_DEV_EVENT_SEND_COMPLETE,
+ USB_REQ_VAL_INVALID, NULL, (uint32_t *)&lba_data, msc_obj_ptr->class_specific_callback.arg);
+ }
+ return;
+ }
+
+ if(msc_obj_ptr->transfer_remaining >= event->len)
+ { /* decrement the global count */
+ msc_obj_ptr->transfer_remaining -= event->len;
+ }
+
+ /* check if there is need to stall BULK IN ENDPOINT And
+ there isn't any transfer in progress*/
+ if( (msc_obj_ptr->need_in_stall_flag == TRUE)&&
+ (!msc_obj_ptr->transfer_remaining))
+ {
+ msc_obj_ptr->need_in_stall_flag = FALSE; /* clear the flag */
+ msc_obj_ptr->in_stall_flag = TRUE;
+ msc_obj_ptr->in_flag = FALSE; /* clear send flag */
+ usb_device_stall_endpoint(msc_obj_ptr->controller_handle,event->ep_num,USB_SEND);
+ return;
+ }
+
+ /* If its not a data phase on bulk endpoint */
+ if ((!msc_obj_ptr->in_flag) && (event->len == MSC_CSW_LENGTH))
+ {
+ csw_ptr = (csw_t *)(event->buffer_ptr);
+ }
+
+ if(msc_obj_ptr->in_flag) /* bulk in transaction has occurred before CSW */
+ {
+ if(msc_obj_ptr->class_specific_callback.callback != NULL)
+ {
+ lba_app_struct_t lba_data;
+
+ lba_data.size = event->len;
+ lba_data.buff_ptr = event->buffer_ptr;
+ lba_data.offset = msc_obj_ptr->current_offset;
+
+ if((READ_10_COMMAND == msc_obj_ptr->cbw_ptr->command_block[0])
+ || (READ_12_COMMAND == msc_obj_ptr->cbw_ptr->command_block[0])
+ )
+ {
+ msc_obj_ptr->class_specific_callback.callback(USB_DEV_EVENT_SEND_COMPLETE,
+ USB_REQ_VAL_INVALID,NULL,(uint32_t *)&lba_data, msc_obj_ptr->class_specific_callback.arg);
+ }
+
+ if(msc_obj_ptr->transfer_remaining)
+ {
+ msc_obj_ptr->current_offset += event->len;
+ lba_data.offset = msc_obj_ptr->current_offset;
+ lba_data.size = (msc_obj_ptr->msd_buff.msc_bulk_in_size > MSD_SEND_MAX_TRANS_LENGTH ?
+ MSD_SEND_MAX_TRANS_LENGTH : msc_obj_ptr->msd_buff.msc_bulk_in_size); /* whichever is smaller */
+ lba_data.size = (msc_obj_ptr->transfer_remaining > lba_data.size ?
+ lba_data.size : msc_obj_ptr->transfer_remaining); /* whichever is smaller */
+
+ lba_data.buff_ptr = NULL; //msc_obj_ptr->msd_buff.msc_bulk_in_ptr;
+
+ /* fetch data from MSD App(e.g)ram disk or Sd card, etc*/
+ msc_obj_ptr->class_specific_callback.callback(USB_MSC_DEVICE_READ_REQUEST,
+ USB_REQ_VAL_INVALID,&msc_obj_ptr->msd_buff.msc_bulk_in_ptr,(uint32_t *)&lba_data, msc_obj_ptr->class_specific_callback.arg);
+
+ lba_data.buff_ptr = msc_obj_ptr->msd_buff.msc_bulk_in_ptr; //msc_obj_ptr->msd_buff.msc_disk_buff_ptr + msc_obj_ptr->current_offset;
+
+ if(msc_obj_ptr->current_offset < (msc_obj_ptr->device_info.total_lba_device_supports * msc_obj_ptr->device_info.length_of_each_lab_of_device))
+ {
+ /* Send data on USB Bus */
+ (void)USB_MSC_Bulk_Send_Data(msc_obj_ptr->msc_handle,
+ (uint8_t *)lba_data.buff_ptr,lba_data.size);
+ }
+ else
+ {
+ msc_obj_ptr->need_in_stall_flag = FALSE; /* clear the flag */
+ msc_obj_ptr->in_stall_flag = TRUE;
+ msc_obj_ptr->in_flag = FALSE; /* clear send flag */
+ msc_obj_ptr->stall_status = (uint8_t)STALL_IN_DATA_PHASE;
+ usb_device_stall_endpoint(msc_obj_ptr->controller_handle,msc_obj_ptr->bulk_in_endpoint,USB_SEND);
+ }
+ }
+ }
+
+ if(!msc_obj_ptr->transfer_remaining)
+ { /* marks the end of data phase */
+ msc_obj_ptr->in_flag = FALSE; /* clear the flag for next CBW */
+ //if(msc_obj_ptr->csw_prime_flag == FALSE)
+ {
+ /* Send the command status information */
+ (void)USB_MSC_Bulk_Send_Data(msc_obj_ptr->msc_handle,
+ (uint8_t *)msc_obj_ptr->csw_ptr, MSC_CSW_LENGTH);
+ msc_obj_ptr->csw_prime_flag = TRUE;
+ }
+ }
+ }
+ else if ((event->len == MSC_CSW_LENGTH) /* CSW is 13 bytes in length */
+ && (csw_ptr->signature == USB_DCSWSIGNATURE)) /*valid CSW signature*/
+ {
+ /* this flag will now be set on reset or after CSW being sent */
+ msc_obj_ptr->cbw_valid_flag = TRUE;
+ msc_obj_ptr->csw_prime_flag = FALSE;
+ /* prepare for next CBW */
+ //if (msc_obj_ptr->cbw_prime_flag == FALSE)
+ {
+ (void)USB_MSC_Bulk_Recv_Data(msc_obj_ptr->controller_handle,
+ (uint8_t*)msc_obj_ptr->cbw_ptr, MSC_CBW_LENGTH);
+ msc_obj_ptr->cbw_prime_flag = TRUE;
+ }
+ }
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Service_Bulk_Out
+ *
+ * @brief The function is callback function of DIC Bulk Out Endpoint
+ *
+ * @param event
+ * @param arg
+ * @return None
+ *
+ *****************************************************************************/
+void USB_Service_Bulk_Out(usb_event_struct_t* event,void* arg)
+{
+ //uint8_t event_type;
+ cbw_t * cbw_ptr = NULL;
+ uint8_t error;
+ msc_device_struct_t * msc_obj_ptr;
+ //uint32_t signature = USB_DCBWSIGNATURE;
+ //USB_PRINTF("\nsignature is :%x",signature);
+#if ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK) && (!USE_RTOS)) || (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM)
+ uint8_t have_transfer = 0;
+#endif
+
+ msc_obj_ptr = (msc_device_struct_t *)arg;
+
+ if (NULL == msc_obj_ptr)
+ {
+#if _DEBUG
+ USB_PRINTF("USB_Service_Bulk_Out: msc_dev_ptr is NULL\n");
+#endif
+ return;
+ }
+
+ if (event->len == 0xFFFFFFFF)
+ {
+ /* need to notify app that receives data Successfully and size is 0, app can release buffer */
+ if ((msc_obj_ptr->out_flag) && (msc_obj_ptr->class_specific_callback.callback != NULL)
+ && ((WRITE_10_COMMAND == msc_obj_ptr->cbw_ptr->command_block[0])
+ || (WRITE_12_COMMAND == msc_obj_ptr->cbw_ptr->command_block[0])))
+ {
+ lba_app_struct_t lba_data1;
+ lba_data1.offset = 0;
+ lba_data1.size = 0;
+ lba_data1.buff_ptr = msc_obj_ptr->msd_buff.msc_bulk_out_ptr;
+ msc_obj_ptr->class_specific_callback.callback(USB_DEV_EVENT_DATA_RECEIVED,
+ USB_REQ_VAL_INVALID,NULL,(uint32_t *)&lba_data1, msc_obj_ptr->class_specific_callback.arg);
+ }
+ return;
+ }
+ if(msc_obj_ptr->transfer_remaining >= event->len)
+ { /* decrement the global count */
+ msc_obj_ptr->transfer_remaining -= event->len;
+ }
+
+ /* check if there is need to stall BULK IN ENDPOINT */
+ if( (msc_obj_ptr->need_out_stall_flag == TRUE)&&
+ (!msc_obj_ptr->transfer_remaining))
+ {
+ //uint8_t component = (uint8_t)(event->ep_num |
+ // (USB_RECV<<COMPONENT_PREPARE_SHIFT));
+ msc_obj_ptr->need_out_stall_flag = FALSE; /* clear the flag */
+ msc_obj_ptr->out_stall_flag = TRUE; /* clear the flag */
+ msc_obj_ptr->out_flag = FALSE; /* clear send flag */
+ msc_obj_ptr->cbw_prime_flag = FALSE;
+ usb_device_stall_endpoint(msc_obj_ptr->controller_handle,event->ep_num,USB_RECV);
+ return;
+ }
+
+ /* If its not a data phase on bulk endpoint */
+ if ((!msc_obj_ptr->out_flag) && (event->len == MSC_CBW_LENGTH))
+ {
+ cbw_ptr = (cbw_t *)(event->buffer_ptr);
+ }
+
+ if(msc_obj_ptr->out_flag) /* bulk out transaction has occurred after CBW */
+ {
+// if(msc_obj_ptr->transfer_remaining >= event->len)
+// { /* decrement the global count */
+// msc_obj_ptr->transfer_remaining -= event->len;
+// }
+
+ if(msc_obj_ptr->class_specific_callback.callback != NULL)
+ {
+ lba_app_struct_t lba_data1;
+
+ lba_data1.size = event->len;
+ lba_data1.buff_ptr = msc_obj_ptr->msd_buff.msc_bulk_out_ptr;
+ lba_data1.offset = msc_obj_ptr->current_offset;
+
+ if((WRITE_10_COMMAND == msc_obj_ptr->cbw_ptr->command_block[0])
+ || (WRITE_12_COMMAND == msc_obj_ptr->cbw_ptr->command_block[0])
+ )
+ {
+//#ifdef MUTILE_BUFFER
+#if ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK) && (!USE_RTOS)) || (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM)
+ lba_app_struct_t lba_data2;
+ if (msc_obj_ptr->transfer_remaining)
+ {
+ msc_obj_ptr->class_specific_callback.callback(USB_MSC_DEVICE_WRITE_REQUEST,
+ USB_REQ_VAL_INVALID,&msc_obj_ptr->msd_buff.msc_bulk_out_ptr, NULL, msc_obj_ptr->class_specific_callback.arg);
+ if (msc_obj_ptr->msd_buff.msc_bulk_out_ptr != NULL)
+ {
+ have_transfer = 1;
+ msc_obj_ptr->current_offset += event->len;
+ lba_data2.offset = msc_obj_ptr->current_offset;
+ lba_data2.size = (msc_obj_ptr->msd_buff.msc_bulk_out_size > MSD_RECV_MAX_TRANS_LENGTH) ?
+ MSD_RECV_MAX_TRANS_LENGTH : msc_obj_ptr->msd_buff.msc_bulk_out_size; /* whichever is smaller */
+ lba_data2.size = (msc_obj_ptr->transfer_remaining > lba_data2.size) ?
+ lba_data2.size : msc_obj_ptr->transfer_remaining; /* whichever is smaller */
+
+ lba_data2.buff_ptr = msc_obj_ptr->msd_buff.msc_bulk_out_ptr;
+ if(msc_obj_ptr->current_offset < (msc_obj_ptr->device_info.total_lba_device_supports * msc_obj_ptr->device_info.length_of_each_lab_of_device))
+ {
+ (void)USB_MSC_Bulk_Recv_Data(msc_obj_ptr->controller_handle,
+ lba_data2.buff_ptr,lba_data2.size);
+ }
+ else
+ {
+ msc_obj_ptr->need_out_stall_flag = FALSE; /* clear the flag */
+ msc_obj_ptr->out_stall_flag = TRUE; /* clear the flag */
+ msc_obj_ptr->out_flag = FALSE; /* clear send flag */
+ msc_obj_ptr->stall_status = (uint8_t)STALL_IN_DATA_PHASE;
+ usb_device_stall_endpoint(msc_obj_ptr->controller_handle,msc_obj_ptr->bulk_out_endpoint,USB_RECV);
+ }
+ }
+ }
+#endif
+ msc_obj_ptr->class_specific_callback.callback(USB_DEV_EVENT_DATA_RECEIVED,
+ USB_REQ_VAL_INVALID,NULL,(uint32_t *)&lba_data1, msc_obj_ptr->class_specific_callback.arg);
+ }
+#if ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK) && (!USE_RTOS)) || (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM)
+ if((msc_obj_ptr->transfer_remaining) && (have_transfer == 0))
+#else
+ if(msc_obj_ptr->transfer_remaining)
+#endif
+ {
+
+ msc_obj_ptr->current_offset += event->len;
+ lba_data1.offset = msc_obj_ptr->current_offset;
+ lba_data1.size = (msc_obj_ptr->msd_buff.msc_bulk_out_size > MSD_RECV_MAX_TRANS_LENGTH) ?
+ MSD_RECV_MAX_TRANS_LENGTH : msc_obj_ptr->msd_buff.msc_bulk_out_size; /* whichever is smaller */
+ lba_data1.size = (msc_obj_ptr->transfer_remaining > lba_data1.size) ?
+ lba_data1.size : msc_obj_ptr->transfer_remaining; /* whichever is smaller */
+
+ lba_data1.buff_ptr = NULL; //msc_obj_ptr->msd_buff.msc_bulk_out_ptr;
+ /* copy the data received on USB Bus, to MSD Disk
+ (e.g.) CD/DVD or SD Card, etc */
+ msc_obj_ptr->class_specific_callback.callback(USB_MSC_DEVICE_WRITE_REQUEST,
+ USB_REQ_VAL_INVALID,&msc_obj_ptr->msd_buff.msc_bulk_out_ptr,(uint32_t *)&lba_data1, msc_obj_ptr->class_specific_callback.arg);
+
+ lba_data1.buff_ptr = msc_obj_ptr->msd_buff.msc_bulk_out_ptr;
+ if(msc_obj_ptr->current_offset < (msc_obj_ptr->device_info.total_lba_device_supports * msc_obj_ptr->device_info.length_of_each_lab_of_device))
+ {
+ (void)USB_MSC_Bulk_Recv_Data(msc_obj_ptr->controller_handle,
+ lba_data1.buff_ptr,lba_data1.size);
+ }
+ else
+ {
+ msc_obj_ptr->need_out_stall_flag = FALSE; /* clear the flag */
+ msc_obj_ptr->out_stall_flag = TRUE; /* clear the flag */
+ msc_obj_ptr->out_flag = FALSE; /* clear send flag */
+ msc_obj_ptr->stall_status = (uint8_t)STALL_IN_DATA_PHASE;
+ usb_device_stall_endpoint(msc_obj_ptr->controller_handle,msc_obj_ptr->bulk_out_endpoint,USB_RECV);
+ }
+ }
+ }
+
+// if((msc_obj_ptr->need_out_stall_flag == TRUE)&&
+// (!msc_obj_ptr->transfer_remaining))
+// {
+// msc_obj_ptr->need_out_stall_flag = FALSE; /* clear the flag */
+// msc_obj_ptr->out_stall_flag = TRUE; /* clear the flag */
+// msc_obj_ptr->out_flag = FALSE; /* clear send flag */
+// usb_device_stall_endpoint(msc_obj_ptr->controller_handle,event->ep_num,USB_SEND);
+// return;
+// }
+
+ if(!msc_obj_ptr->transfer_remaining)
+ { /* marks the end of data phase */
+ msc_obj_ptr->out_flag = FALSE; /* clear the flag for next CBW */
+ /* Send the command status information */
+ //if(msc_obj_ptr->csw_prime_flag == FALSE)
+ {
+ (void)USB_MSC_Bulk_Send_Data(msc_obj_ptr->msc_handle,
+ (uint8_t *)msc_obj_ptr->csw_ptr, MSC_CSW_LENGTH);
+ msc_obj_ptr->csw_prime_flag = TRUE;
+ }
+ }
+ }
+ else if(/* check for valid and meaningful CBW */
+ /* CBW received after device had sent a CSW or after a reset */
+ (msc_obj_ptr->cbw_valid_flag)
+ /* CBW is 31 bytes in length */
+ && (event->len == MSC_CBW_LENGTH)
+ /* valid CBW signature*/
+ && (cbw_ptr != NULL) && (cbw_ptr->signature == USB_DCBWSIGNATURE)
+ /* all reserved bits should be zero*/
+ && (!((cbw_ptr->lun & 0xF0) || (cbw_ptr->cb_length & 0xE0)))
+ /* host should send command to valid LUN */
+ && (cbw_ptr->lun<msc_obj_ptr->device_info.num_lun_supported)
+ /* valid cbwcb length*/
+ && ((cbw_ptr->cb_length >= 0x01)&&(cbw_ptr->cb_length <= 0x10))
+ )
+ {
+ msc_obj_ptr->re_stall_flag = TRUE;
+ msc_obj_ptr->cbw_prime_flag = FALSE;
+ msc_obj_ptr->transfer_remaining = 0;
+ /* A valid CBW was received */
+ msc_obj_ptr->csw_ptr->signature = USB_DCSWSIGNATURE;
+ msc_obj_ptr->csw_ptr->residue = 0;
+ msc_obj_ptr->csw_ptr->tag = cbw_ptr->tag;
+ /*this flag will now be set on reset or after CSW being sent */
+ msc_obj_ptr->cbw_valid_flag = FALSE;
+
+ cbw_ptr->data_length = USB_LONG_LE_TO_HOST(cbw_ptr->data_length);
+
+ /* set flag if device is going to recv data in coming transaction */
+ msc_obj_ptr->out_flag = (bool)(( (!(cbw_ptr->flag & USB_CBW_DIRECTION_BIT))
+ && (cbw_ptr->data_length))?TRUE:FALSE);
+ /* set flag if send is going to send data in coming transaction */
+ msc_obj_ptr->in_flag = (bool)(( (cbw_ptr->flag & USB_CBW_DIRECTION_BIT)
+ && (cbw_ptr->data_length))?TRUE:FALSE);
+ /* Process the command */
+ error = process_mass_storage_command(msc_obj_ptr, cbw_ptr,
+ &(msc_obj_ptr->csw_ptr->residue), &(msc_obj_ptr->csw_ptr->csw_status));
+
+ if (error == USBERR_ENDPOINT_STALLED)
+ {
+ if (msc_obj_ptr->out_flag==TRUE)
+ {
+ if (msc_obj_ptr->out_stall_flag == FALSE)
+ {
+ msc_obj_ptr->need_out_stall_flag = TRUE;
+ }
+ msc_obj_ptr->out_flag = FALSE; /* so as to send status phase */
+ }
+ else if (msc_obj_ptr->in_flag==TRUE)
+ {
+ if (msc_obj_ptr->in_stall_flag == FALSE)
+ {
+ msc_obj_ptr->need_in_stall_flag = TRUE;
+ }
+ msc_obj_ptr->in_flag = FALSE;
+ }
+ msc_obj_ptr->stall_status = (uint8_t)STALL_IN_DATA_PHASE;
+ }
+
+ /* if there is no data phase on bulk endpoints*/
+ /* even if need_out_stall_flag or need_in_stall_flag */
+ if(!((msc_obj_ptr->out_flag) || ((msc_obj_ptr->in_flag) || (msc_obj_ptr->need_in_stall_flag))))
+ {
+ /* Send the command status information */
+ (void)USB_MSC_Bulk_Send_Data(msc_obj_ptr->msc_handle,
+ (uint8_t *)msc_obj_ptr->csw_ptr, MSC_CSW_LENGTH);
+ msc_obj_ptr->csw_prime_flag = TRUE;
+ }
+ }
+ else /* Invalid/NMreceived */
+ {
+ //uint8_t direction;
+ //uint8_t ep_num;
+ /* prepare the component to be sent in lower layer with
+ endpoint number and direction*/
+ //uint8_t component;
+ //direction = USB_RECV;
+ //ep_num = msc_obj_ptr->bulk_out_endpoint;
+ //component = (uint8_t)(ep_num | (direction<<COMPONENT_PREPARE_SHIFT));
+ usb_device_stall_endpoint(msc_obj_ptr->controller_handle,msc_obj_ptr->bulk_out_endpoint,USB_RECV);
+ usb_device_stall_endpoint(msc_obj_ptr->controller_handle,msc_obj_ptr->bulk_in_endpoint,USB_SEND);
+ msc_obj_ptr->cbw_valid_flag = FALSE;
+ msc_obj_ptr->out_stall_flag = TRUE;
+ msc_obj_ptr->in_stall_flag = TRUE;
+ msc_obj_ptr->stall_status = (uint8_t)STALL_IN_CBW;
+ msc_obj_ptr->wait_for_reset_recovery = TRUE;
+ }
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_MSC_Event
+ *
+ * @brief The function initializes MSC endpoints
+ *
+ * @param arg handle to Identify class object.
+ * @param event pointer to event structure
+ * @param val gives the configuration value
+ *
+ * @return None
+ *
+ *****************************************************************************/
+void USB_Class_MSC_Event(uint8_t event, void* val,void* arg)
+{
+ usb_class_struct_t* usbclassPtr;
+ msc_device_struct_t * msc_dev_ptr;
+
+ usb_endpoints_t *usb_ep_data;
+ //uint8_t error;
+
+ //USB_PRINTF("\n USB_Class_MSD_Event: event: 0x%x", event);
+ msc_dev_ptr = (msc_device_struct_t *)arg;
+
+ if (NULL == msc_dev_ptr)
+ {
+#if _DEBUG
+ USB_PRINTF("USB_Class_MSC_Event: msc_dev_ptr is NULL\n");
+#endif
+ return;
+ }
+
+ if(event == USB_DEV_EVENT_CONFIG_CHANGED)
+ {
+ uint8_t count = 0;
+
+ //USB_PRINTF("\n 000, count: 0x%x", count);
+ //USB_PRINTF("\nUSB_DEV_EVENT_CONFIG_CHANGED");
+
+ if (*(uint16_t*)val == 0)
+ {
+#if _DEBUG
+ USB_PRINTF("only config change!\n");
+#endif
+ return;
+ }
+#if USBCFG_DEV_COMPOSITE
+ /* Get class info */
+ USB_Msd_Get_Desc_Info(msc_dev_ptr, USB_MSD_CLASS_INFO, (uint32_t *)&usbclassPtr);
+ USB_Msd_Get_Desc_Info(msc_dev_ptr, USB_MSD_INTERFACE_COUNT, &msc_dev_ptr->usb_max_suported_interfaces);
+#else
+ msc_dev_ptr->desc_callback.get_desc_entity((uint32_t)msc_dev_ptr->controller_handle,
+ USB_CLASS_INFO, (uint32_t*)&usbclassPtr);
+ USB_Msd_Get_Desc_Info(msc_dev_ptr, USB_MSD_INTERFACE_COUNT, &msc_dev_ptr->usb_max_suported_interfaces);
+#endif
+ if(usbclassPtr == NULL)
+ {
+ USB_PRINTF("not find msd interface\n");
+ return;
+ }
+
+ usb_ep_data = &(usbclassPtr[*(uint16_t*)val - 1].interfaces.interface[0].endpoints);
+ msc_dev_ptr->ep_desc_data = usb_ep_data;
+ msc_dev_ptr->msc_endpoint_data.count = usbclassPtr->interfaces.interface->endpoints.count;
+
+ if (msc_dev_ptr->msc_endpoint_data.count > MAX_MSC_CLASS_EP_NUM)
+ {
+ USB_PRINTF("too many msc endpoint for the class driver\n");
+ return;
+ }
+
+ for (int epindex = 0; epindex < usbclassPtr->interfaces.interface->endpoints.count; ++epindex)
+ {
+ if (usbclassPtr->interfaces.interface->endpoints.ep[epindex].direction == USB_SEND)
+ {
+ msc_dev_ptr->bulk_in_endpoint = usbclassPtr->interfaces.interface->endpoints.ep[epindex].ep_num;
+ msc_dev_ptr->bulk_in_endpoint_packet_size = usbclassPtr->interfaces.interface->endpoints.ep[epindex].size;
+ }
+ else if (usbclassPtr->interfaces.interface->endpoints.ep[epindex].direction == USB_RECV)
+ {
+ msc_dev_ptr->bulk_out_endpoint = usbclassPtr->interfaces.interface->endpoints.ep[epindex].ep_num;
+ }
+ }
+
+ /* initialize all non control endpoints */
+ while(count < usb_ep_data->count)
+ {
+#if _DEBUG
+ USB_PRINTF("\n 222, count: 0x%x", count);
+#endif
+ usb_ep_struct_t* ep_struct_ptr=
+ (usb_ep_struct_t*) (&usb_ep_data->ep[count]);
+
+ (void)usb_device_init_endpoint(msc_dev_ptr->controller_handle,
+ ep_struct_ptr, TRUE);
+
+ /* register callback service for Non Control EndPoints */
+ if(ep_struct_ptr->type == USB_BULK_PIPE)
+ {
+ if(ep_struct_ptr->direction == USB_RECV)
+ {
+ (void)usb_device_register_service(msc_dev_ptr->controller_handle,
+ (uint8_t)((uint8_t)(USB_SERVICE_EP0+ep_struct_ptr->ep_num) | ((uint8_t)(ep_struct_ptr->direction << 7))),
+ USB_Service_Bulk_Out,(void *)msc_dev_ptr);
+ }
+ else
+ {
+ (void)usb_device_register_service(msc_dev_ptr->controller_handle,
+ (uint8_t)((uint8_t)(USB_SERVICE_EP0+ep_struct_ptr->ep_num) | ((uint8_t)(ep_struct_ptr->direction << 7))),
+ USB_Service_Bulk_In,(void *)msc_dev_ptr);
+ }
+ }
+ count++;
+
+ }
+ msc_dev_ptr->re_stall_flag = FALSE;
+ msc_dev_ptr->out_flag = FALSE;
+ msc_dev_ptr->in_flag = FALSE;
+ msc_dev_ptr->out_stall_flag = FALSE;
+ msc_dev_ptr->in_stall_flag = FALSE;
+ msc_dev_ptr->need_out_stall_flag = FALSE;
+ msc_dev_ptr->need_in_stall_flag = FALSE;
+ msc_dev_ptr->cbw_valid_flag = TRUE; /*making the first CBW valid */
+ msc_dev_ptr->transfer_remaining = 0;
+ msc_dev_ptr->wait_for_reset_recovery = FALSE;
+ msc_dev_ptr->need_to_prepare_next = FALSE;
+ msc_dev_ptr->stall_status = 0;
+ }
+ else if(event == USB_DEV_EVENT_ENUM_COMPLETE)
+ {
+ /* To Do */
+ if(NULL == msc_dev_ptr->cbw_ptr)
+ {
+ USB_PRINTF("msc cbw buff error\n");
+ return;
+ }
+ //msc_dev_ptr->cbw_ptr = (cbw_t *)OS_Mem_alloc_uncached(MSC_CBW_LENGTH);
+
+ if(msc_dev_ptr->cbw_prime_flag == TRUE)
+ {
+#if USBCFG_DEV_ADVANCED_CANCEL_ENABLE
+ usb_device_cancel_transfer(msc_dev_ptr->controller_handle, msc_dev_ptr->bulk_out_endpoint, USB_RECV);
+#endif
+ }
+ usb_device_recv_data(msc_dev_ptr->controller_handle,
+ msc_dev_ptr->bulk_out_endpoint, (uint8_t*)msc_dev_ptr->cbw_ptr, MSC_CBW_LENGTH);
+ msc_dev_ptr->cbw_prime_flag = TRUE;
+#if _DEBUG
+ USB_PRINTF("\nUSB_MSC_Bulk_Recv_Data");
+#endif
+ //msc_dev_ptr->csw_ptr = (csw_t *)OS_mem_alloc_uncached(MSC_CSW_LENGTH);
+ //USB_Class_MSC_Send_Data(msc_dev_ptr->controller_handle,1,(uint8_t *)msc_dev_ptr->csw_ptr,MSC_CSW_LENGTH);
+ }
+ else if(event == USB_DEV_EVENT_BUS_RESET)
+ {
+
+ }
+ else if(event == USB_DEV_EVENT_EP_UNSTALLED)
+ {
+ uint8_t value;
+ value = *((uint8_t *)val);
+
+ if( (msc_dev_ptr->re_stall_flag == TRUE)
+ &&
+ (((value & 0x0F) == msc_dev_ptr->bulk_in_endpoint) ||
+ ((value & 0x0F) == msc_dev_ptr->bulk_out_endpoint)))
+ { /* For MASS Storage Class BULK ENDPOINTS have to be unstalled
+ only on receiving Bulk Only Reset.
+ Therefore, if Host sends clear feature to unstall these
+ endpoints, re-stall them
+ */
+ usb_device_stall_endpoint(msc_dev_ptr->controller_handle,value & 0x0F, (uint8_t)(value & 0x80) >> 7);
+ }
+ }
+ else if(event == USB_DEV_EVENT_EP_STALLED)
+ {
+ /* Code to be added here,
+ if there is some action needed at app level */
+ }
+ else if (event == USB_DEV_EVENT_TYPE_CLR_EP_HALT)
+ {
+ uint8_t value;
+ value = *((uint8_t *)val);
+ if (msc_dev_ptr->wait_for_reset_recovery != TRUE)
+ {
+ if (((value & 0x0F) == msc_dev_ptr->bulk_in_endpoint) && (msc_dev_ptr->in_stall_flag == TRUE))
+ {
+ usb_device_unstall_endpoint(msc_dev_ptr->controller_handle,value & 0x0F, (uint8_t)(value & 0x80) >> 7);
+ msc_dev_ptr->in_stall_flag = FALSE;
+ }
+ if (((value & 0x0F) == msc_dev_ptr->bulk_out_endpoint) && (msc_dev_ptr->out_stall_flag == TRUE))
+ {
+ usb_device_unstall_endpoint(msc_dev_ptr->controller_handle,value & 0x0F, (uint8_t)(value & 0x80) >> 7);
+ msc_dev_ptr->out_stall_flag = FALSE;
+ }
+
+ if ((msc_dev_ptr->need_to_prepare_next != TRUE) && ((msc_dev_ptr->stall_status == STALL_IN_DATA_PHASE) || (msc_dev_ptr->stall_status == STALL_IN_CSW)))
+ {
+ if (msc_dev_ptr->csw_prime_flag == TRUE)
+ {
+#if USBCFG_DEV_ADVANCED_CANCEL_ENABLE
+ usb_device_cancel_transfer(msc_dev_ptr->controller_handle, msc_dev_ptr->bulk_in_endpoint, USB_SEND);
+#endif
+ }
+ /* Send the command status information */
+ usb_device_send_data(msc_dev_ptr->controller_handle,
+ msc_dev_ptr->bulk_in_endpoint, (uint8_t*)msc_dev_ptr->csw_ptr, MSC_CSW_LENGTH);
+ msc_dev_ptr->csw_prime_flag = TRUE;
+ msc_dev_ptr->stall_status = 0;
+ }
+
+ if ((msc_dev_ptr->need_to_prepare_next == TRUE) && (msc_dev_ptr->out_stall_flag == FALSE) && (msc_dev_ptr->in_stall_flag == FALSE))
+ {
+ msc_dev_ptr->need_to_prepare_next = FALSE;
+ if (msc_dev_ptr->cbw_prime_flag == TRUE)
+ {
+#if USBCFG_DEV_ADVANCED_CANCEL_ENABLE
+ usb_device_cancel_transfer(msc_dev_ptr->controller_handle, msc_dev_ptr->bulk_out_endpoint, USB_RECV);
+#endif
+ }
+ usb_device_recv_data(msc_dev_ptr->controller_handle,
+ msc_dev_ptr->bulk_out_endpoint, (uint8_t*)msc_dev_ptr->cbw_ptr, MSC_CBW_LENGTH);
+ msc_dev_ptr->cbw_prime_flag = TRUE;
+ msc_dev_ptr->stall_status = 0;
+ }
+ }
+ }
+ else if(event == USB_DEV_EVENT_TYPE_SET_EP_HALT)
+ {
+ /* Code to be added here,
+ if there is some action needed at app level */
+ uint8_t value;
+ value = *((uint8_t *)val);
+ if (((value & 0x0F) == msc_dev_ptr->bulk_in_endpoint))
+ {
+ //usb_device_stall_endpoint(msc_dev_ptr->controller_handle,value & 0x0F, (value & 0x80) >> 7);
+ msc_dev_ptr->in_stall_flag = TRUE;
+ }
+ if (((value & 0x0F) == msc_dev_ptr->bulk_out_endpoint))
+ {
+ //usb_device_stall_endpoint(msc_dev_ptr->controller_handle,value & 0x0F, (value & 0x80) >> 7);
+ msc_dev_ptr->out_stall_flag = TRUE;
+ }
+ }
+
+ if(msc_dev_ptr->msc_application_callback.callback != NULL)
+ {
+ msc_dev_ptr->msc_application_callback.callback(event,val,
+ msc_dev_ptr->msc_application_callback.arg);
+ }
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_MSC_Other_Requests
+ *
+ * @brief The function provides flexibility to add class and vendor specific
+ * requests
+ *
+ * @param arg
+ * @param setup_packet: setup packet received
+ * @param data: data to be send back
+ * @param size: size to be returned
+ *
+ * @return status:
+ * USB_OK : When Successfully
+ * Others : When Error
+ *
+ *****************************************************************************/
+usb_status USB_MSC_Requests
+(
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size,
+void* arg
+)
+{
+ msc_device_struct_t * msc_dev_ptr;
+ usb_status error = USBERR_INVALID_REQ_TYPE;
+
+ msc_dev_ptr = (msc_device_struct_t *)arg;
+ //USB_PRINTF("\nsetup_packet->request: 0x%x", setup_packet->request);
+
+ if (NULL == msc_dev_ptr)
+ {
+#if _DEBUG
+ USB_PRINTF("USB_MSC_Other_Requests: msc_dev_ptr is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+
+ *size=0;
+
+ if((setup_packet->request_type & USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_POS) ==
+ USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_CLASS)
+ { /* class request so handle it here */
+
+ error = USB_OK;
+
+ /* call for class/subclass specific requests */
+ switch(setup_packet->request)
+ {
+ case GET_MAX_LUN :
+ if((setup_packet->index < msc_dev_ptr->usb_max_suported_interfaces) &&
+ (!setup_packet->value) && (setup_packet->length <= 0x0001) &&
+ ((setup_packet->request_type & USB_DEV_REQ_STD_REQUEST_TYPE_DIR_POS) == USB_DEV_REQ_STD_REQUEST_TYPE_DIR_IN)
+ )
+ {
+ /* return the maximum number of logical units supported */
+ *data = &msc_dev_ptr->lun;
+ *size= (uint32_t)setup_packet->length;
+ msc_dev_ptr->re_stall_flag = TRUE;
+ }
+ else
+ { /* for Get Max LUN request with invalid wIndex parameter,
+ host expects stall */
+ error = USBERR_INVALID_REQ_TYPE;
+ }
+ break;
+ case BULK_ONLY_MASS_STORAGE_RESET :
+ /* Steps to be taken in this command :
+ 1) ready the device for the next CBW from the host
+ 2) preserve the value of its bulk data toggle bits
+ 3) preserve the value of its bulk endpoint STALL conditions
+ 4) device shall NAK the status stage of device request until
+ command is complete*/
+
+ if( (setup_packet->index < msc_dev_ptr->usb_max_suported_interfaces) &&
+ (!setup_packet->value)&&(!setup_packet->length) &&
+ ((setup_packet->request_type & USB_DEV_REQ_STD_REQUEST_TYPE_DIR_POS) == USB_DEV_REQ_STD_REQUEST_TYPE_DIR_OUT)
+ )
+ {
+ /* get the endpoints from the descriptor module */
+ usb_endpoints_t *usb_ep_data = msc_dev_ptr->ep_desc_data;
+ uint8_t count = 0;
+
+ /* de-initialize and initialize bulk endpoints */
+ while(count < usb_ep_data->count)
+ {
+ usb_ep_struct_t* ep_struct_ptr=
+ (usb_ep_struct_t*) (&usb_ep_data->ep[count]);
+
+ if(ep_struct_ptr->type == USB_BULK_PIPE)
+ {
+ (void)usb_device_deinit_endpoint(msc_dev_ptr->controller_handle,
+ ep_struct_ptr->ep_num, ep_struct_ptr->direction);
+ (void)usb_device_init_endpoint(msc_dev_ptr->controller_handle,
+ ep_struct_ptr, TRUE);
+ }
+ count++;
+ }
+ msc_dev_ptr->out_flag = FALSE;
+ msc_dev_ptr->in_flag = FALSE;
+ msc_dev_ptr->need_out_stall_flag = FALSE;
+ msc_dev_ptr->need_in_stall_flag = FALSE;
+ /*making the first CBW valid */
+ msc_dev_ptr->cbw_valid_flag = TRUE;
+ msc_dev_ptr->re_stall_flag = FALSE;
+ msc_dev_ptr->transfer_remaining = 0;
+ msc_dev_ptr->wait_for_reset_recovery = FALSE;
+ msc_dev_ptr->cbw_prime_flag = FALSE;
+ msc_dev_ptr->csw_prime_flag = FALSE;
+ msc_dev_ptr->need_to_prepare_next = TRUE;
+// usb_device_recv_data(msc_dev_ptr->controller_handle,
+// msc_dev_ptr->bulk_out_endpoint, (uint8_t*)msc_dev_ptr->cbw_ptr, MSC_CBW_LENGTH);
+ }
+ else
+ { /* for Get Max LUN request with invalid wIndex parameter,
+ host expects stall */
+ error = USBERR_INVALID_REQ_TYPE;
+ }
+ break;
+ default :break;
+ }
+ }
+ else if((setup_packet->request_type & USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_POS) ==
+ USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_VENDOR)
+ { /* vendor specific request */
+ if(msc_dev_ptr->vendor_req_callback.callback != NULL)
+ {
+ error = msc_dev_ptr->vendor_req_callback.callback(setup_packet,
+ data,size,msc_dev_ptr->vendor_req_callback.arg);
+ }
+ }
+
+ return error;
+}
+
+/*****************************************************************************
+ * Global Functions
+ *****************************************************************************/
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_MSC_Init
+ *
+ * @brief The function initializes the Device and Controller layer
+ *
+ * @param msd_config_ptr : Configuration parameter structure pointer
+ * passed by APP.
+ * @return status
+ * MSD Handle : When Successfully
+ * Others : Errors
+ ******************************************************************************
+ *
+ *This function initializes the MSC Class layer and layers it is dependent on
+ ******************************************************************************/
+usb_status USB_Class_MSC_Init
+(
+uint8_t controller_id,
+msc_config_struct_t* msd_config_ptr,
+msd_handle_t * msd_handle
+
+)
+{
+#if _DEBUG
+ USB_PRINTF("Enter USB_Class_MSC_Init\n");
+#endif
+ usb_status error = USBERR_ERROR;
+ uint32_t implementing_disk_drive = IMPLEMENTING_DISK_DRIVE;
+ msc_device_struct_t * devicePtr = NULL;
+ usb_class_specific_callback_struct_t* scsi_cb_ptr;
+ device_lba_info_struct_t* usb_msd_lba_info_ptr = NULL;
+
+ if (msd_config_ptr == NULL)
+ {
+ return USBERR_ERROR;
+ }
+
+ error = USB_Msd_Allocate_Handle(&devicePtr);
+ if (USB_OK != error)
+ {
+ return error;
+ }
+
+#if ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM) || ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK)))
+ devicePtr->cbw_ptr = &g_msc_class_cbw; /* Initializing */
+ devicePtr->csw_ptr = &g_msc_class_csw;
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ devicePtr->cbw_ptr = (cbw_t *)OS_Mem_alloc_uncached_align(sizeof(cbw_t), 32);
+ if (NULL == devicePtr->cbw_ptr)
+ {
+#if _DEBUG
+ USB_PRINTF("6: USB_Class_MSC_Init: Memalloc failed\n");
+#endif
+ error = USBERR_ALLOC;
+ if(NULL != devicePtr->csw_ptr)
+ {
+ OS_Mem_free(devicePtr->csw_ptr);
+ devicePtr->csw_ptr = NULL;
+ }
+ if(NULL != devicePtr->cbw_ptr)
+ {
+ OS_Mem_free(devicePtr->cbw_ptr);
+ devicePtr->cbw_ptr = NULL;
+ }
+ *msd_handle = (unsigned long)0;
+ return error;
+ }
+ devicePtr->csw_ptr = (csw_t *)OS_Mem_alloc_uncached_align(sizeof(csw_t), 32);
+ if (NULL == devicePtr->csw_ptr)
+ {
+#if _DEBUG
+ USB_PRINTF("7: USB_Class_MSC_Init: Memalloc failed\n");
+#endif
+ error = USBERR_ALLOC;
+ if(NULL != devicePtr->csw_ptr)
+ {
+ OS_Mem_free(devicePtr->csw_ptr);
+ devicePtr->csw_ptr = NULL;
+ }
+ if(NULL != devicePtr->cbw_ptr)
+ {
+ OS_Mem_free(devicePtr->cbw_ptr);
+ devicePtr->cbw_ptr = NULL;
+ }
+ *msd_handle = (unsigned long)0;
+ return error;
+ }
+#endif
+ OS_Mem_zero(devicePtr->cbw_ptr, MSC_CBW_LENGTH);
+ OS_Mem_zero(devicePtr->csw_ptr, MSC_CSW_LENGTH);
+
+ OS_Mem_copy(msd_config_ptr->desc_callback_ptr,&devicePtr->desc_callback,sizeof(usb_desc_request_notify_struct_t));
+
+ /* save the callback pointer */
+ devicePtr->msc_application_callback.callback = msd_config_ptr->msc_application_callback.callback;
+ devicePtr->msc_application_callback.arg = msd_config_ptr->msc_application_callback.arg;
+
+ /* save the callback pointer */
+ devicePtr->vendor_req_callback.callback =
+ msd_config_ptr->vendor_req_callback.callback;
+ devicePtr->vendor_req_callback.arg = msd_config_ptr->vendor_req_callback.arg;
+
+ /* save the callback pointer */
+ devicePtr->class_specific_callback.callback = msd_config_ptr->class_specific_callback.callback;
+ devicePtr->class_specific_callback.arg = msd_config_ptr->class_specific_callback.arg;
+
+ if(devicePtr->msc_application_callback.callback)
+ {
+ devicePtr->msc_application_callback.callback(USB_MSC_DEVICE_GET_SEND_BUFF_INFO, &devicePtr->msd_buff.msc_bulk_in_size , NULL);
+ devicePtr->msc_application_callback.callback(USB_MSC_DEVICE_GET_RECV_BUFF_INFO, &devicePtr->msd_buff.msc_bulk_out_size , NULL);
+ }
+#if USBCFG_DEV_COMPOSITE
+ devicePtr->class_handle = USB_Class_Get_Class_Handle();
+
+ devicePtr->controller_handle = (usb_device_handle)USB_Class_Get_Ctrler_Handle(devicePtr->class_handle);
+ if(NULL == devicePtr->controller_handle)
+ {
+#if _DEBUG
+ USB_PRINTF("4: USB_Class_MSC_Init: call USB_Class_Get_Ctrler_Handle failed\n");
+#endif
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ if(NULL != devicePtr->csw_ptr)
+ {
+ OS_Mem_free(devicePtr->csw_ptr);
+ devicePtr->csw_ptr = NULL;
+ }
+ if(NULL != devicePtr->cbw_ptr)
+ {
+ OS_Mem_free(devicePtr->cbw_ptr);
+ devicePtr->cbw_ptr = NULL;
+ }
+#endif
+ *msd_handle = (unsigned long)0;
+ return error;
+ }
+#else
+ /* Initialize the device layer*/
+ error = usb_device_init(controller_id,(&devicePtr->controller_handle));
+ /* +1 is for Control Endpoint */
+ if(error != USB_OK)
+ {
+#if _DEBUG
+ USB_PRINTF("4: USB_Class_MSC_Init: call usb_device_init failed\n");
+#endif
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ if(NULL != devicePtr->csw_ptr)
+ {
+ OS_Mem_free(devicePtr->csw_ptr);
+ devicePtr->csw_ptr = NULL;
+ }
+ if(NULL != devicePtr->cbw_ptr)
+ {
+ OS_Mem_free(devicePtr->cbw_ptr);
+ devicePtr->cbw_ptr = NULL;
+ }
+#endif
+ *msd_handle = (unsigned long)0;
+ return error;
+ }
+ /* Initialize the generic class functions */
+ devicePtr->class_handle = USB_Class_Init(devicePtr->controller_handle,USB_Class_MSC_Event,
+ USB_MSC_Requests,(void *)devicePtr,msd_config_ptr->desc_callback_ptr);
+#endif
+
+ devicePtr->desc_callback.get_desc_entity((uint32_t)devicePtr,USB_MSC_LBA_INFO, (uint32_t *)&usb_msd_lba_info_ptr);
+ if(NULL == usb_msd_lba_info_ptr)
+ {
+#if _DEBUG
+ USB_PRINTF("9: USB_Class_MSC_Init: get msd lba info failed\n");
+#endif
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ if(NULL != devicePtr->csw_ptr)
+ {
+ OS_Mem_free(devicePtr->csw_ptr);
+ devicePtr->csw_ptr = NULL;
+ }
+ if(NULL != devicePtr->cbw_ptr)
+ {
+ OS_Mem_free(devicePtr->cbw_ptr);
+ devicePtr->cbw_ptr = NULL;
+ }
+#endif
+ *msd_handle = (unsigned long)0;
+ return error;
+ }
+ devicePtr->device_info.length_of_each_lab_of_device = usb_msd_lba_info_ptr->length_of_each_lab_of_device;
+ devicePtr->device_info.num_lun_supported = usb_msd_lba_info_ptr->num_lun_supported;
+ devicePtr->device_info.total_lba_device_supports = usb_msd_lba_info_ptr->total_lba_device_supports;
+
+ /* Initialize the scsi subclass functions */
+ //scsi_cb.callback = USB_Class_MSC_Event;
+ scsi_cb_ptr = &msd_config_ptr->class_specific_callback;
+ //scsi_cb.arg = devicePtr;
+ error = USB_MSC_SCSI_Init(devicePtr,scsi_cb_ptr, &devicePtr->device_info,
+ implementing_disk_drive);
+
+ if(error != USB_OK)
+ {
+#if _DEBUG
+ USB_PRINTF("10: USB_Class_MSC_Init: call USB_MSC_SCSI_Init failed\n");
+#endif
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ if(NULL != devicePtr->csw_ptr)
+ {
+ OS_Mem_free(devicePtr->csw_ptr);
+ devicePtr->csw_ptr = NULL;
+ }
+ if(NULL != devicePtr->cbw_ptr)
+ {
+ OS_Mem_free(devicePtr->cbw_ptr);
+ devicePtr->cbw_ptr = NULL;
+ }
+#endif
+ *msd_handle = (unsigned long)0;
+ return error;
+ }
+
+ devicePtr->cbw_prime_flag = FALSE;
+ devicePtr->csw_prime_flag = FALSE;
+
+ *msd_handle = (unsigned long)devicePtr;
+ devicePtr->msc_handle = *msd_handle;
+#if !USBCFG_DEV_COMPOSITE
+ usb_device_postinit(controller_id,devicePtr->controller_handle);
+#endif
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_MSC_Deinit
+ *
+ * @brief The function initializes the Device and Controller layer
+ *
+ * @param cdc_handle
+ *
+ * @return status
+ * USB_OK : When Successfully
+ * Others : Errors
+ ******************************************************************************
+ *
+ *This function initializes the MSC Class layer and layers it is dependent on
+ *
+ *****************************************************************************/
+usb_status USB_Class_MSC_Deinit
+(
+msd_handle_t msd_handle /*[IN]*/
+)
+{
+ usb_status error = USB_OK;
+ msc_device_struct_t * devicePtr = NULL;
+
+ if (msd_handle == 0)
+ {
+ return USBERR_ERROR;
+ }
+
+ devicePtr = USB_Msd_Get_Device_Ptr(msd_handle);
+
+ if(error == USB_OK)
+ {
+ /* De-initialize the scsi subclass functions */
+ error = USB_MSC_SCSI_Deinit(devicePtr);
+ }
+
+#if !USBCFG_DEV_COMPOSITE
+ if(error == USB_OK)
+ {
+ /* De-initialize the generic class functions */
+ error = USB_Class_Deinit(devicePtr->controller_handle,devicePtr->class_handle);
+ }
+ if(error == USB_OK)
+ {
+ /* De-initialize the device layer*/
+ error = usb_device_deinit(devicePtr->controller_handle);
+ }
+#endif
+ if(error == USB_OK)
+ {
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ if(NULL != devicePtr->csw_ptr)
+ {
+ OS_Mem_free(devicePtr->csw_ptr);
+ devicePtr->csw_ptr = NULL;
+ }
+ if(NULL != devicePtr->cbw_ptr)
+ {
+ OS_Mem_free(devicePtr->cbw_ptr);
+ devicePtr->cbw_ptr = NULL;
+ }
+#endif
+ USB_Msd_Free_Handle(devicePtr);
+ }
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_MSC_Send_Data
+ *
+ * @brief
+ *
+ * @param msc_handle : handle returned from USB_Class_MSC_Init
+ * @param ep_num : endpoint num
+ * @param app_buff : buffer to send
+ * @param size : length of the transfer
+ *
+ * @return status
+ * USB_OK : When Successfully
+ * Others : Errors
+ *****************************************************************************/
+usb_status USB_Class_MSC_Send_Data
+(
+msd_handle_t msc_handle, /*[IN]*/
+uint8_t ep_num, /*[IN]*/
+uint8_t * app_buff, /*[IN]*/
+uint32_t size /*[IN]*/
+)
+{
+ msc_device_struct_t * devicePtr;
+ usb_status error = USB_OK;
+
+ devicePtr = USB_Msd_Get_Device_Ptr(msc_handle);
+ if (devicePtr == NULL)
+ {
+ return USBERR_ERROR;
+ }
+
+ error = USB_Class_Send_Data(devicePtr->class_handle,
+ ep_num, app_buff,size);
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_MSC_LBA_Transfer
+ *
+ * @brief
+ *
+ * @param msc_device_struct_t *
+ * @param direction : transfer direction
+ * @param lba_info_ptr : buffer to send
+ *
+ * @return status
+ * USB_OK : When Successfully
+ * Others : Errors
+ *****************************************************************************/
+usb_status USB_MSC_LBA_Transfer
+(
+msc_device_struct_t * msc_obj_ptr,
+bool direction,
+lba_info_struct_t* lba_info_ptr
+)
+{
+ usb_status error;
+ lba_app_struct_t lba_data;
+
+// if((!((lba_info_ptr->starting_lba<msc_obj_ptr->device_info.total_lba_device_supports)&&
+// (lba_info_ptr->lba_transfer_num <= (msc_obj_ptr->device_info.total_lba_device_supports -
+// lba_info_ptr->starting_lba)))) || (msc_obj_ptr->class_specific_callback.callback == NULL))
+// {
+// /* host trying to access region beyond MASS STORAGE SPACE
+// Or no class_specific_callback is registered */
+// //return(uint8_t)((direction?USBERR_TX_FAILED:USBERR_RX_FAILED));
+// }
+
+ msc_obj_ptr->transfer_remaining = lba_info_ptr->lba_transfer_num *
+ msc_obj_ptr->device_info.length_of_each_lab_of_device;
+ msc_obj_ptr->current_offset = lba_info_ptr->starting_lba *
+ msc_obj_ptr->device_info.length_of_each_lab_of_device;
+
+ lba_data.offset = msc_obj_ptr->current_offset;
+
+ if(direction == USB_SEND)
+ {
+ lba_data.size = (msc_obj_ptr->msd_buff.msc_bulk_in_size > MSD_SEND_MAX_TRANS_LENGTH) ?
+ MSD_SEND_MAX_TRANS_LENGTH : msc_obj_ptr->msd_buff.msc_bulk_in_size; /* whichever is smaller */
+ lba_data.size = (msc_obj_ptr->transfer_remaining > lba_data.size) ?
+ lba_data.size : msc_obj_ptr->transfer_remaining; /* whichever is smaller */
+
+ lba_data.buff_ptr = NULL;
+ msc_obj_ptr->class_specific_callback.callback(USB_MSC_DEVICE_READ_REQUEST,
+ USB_REQ_VAL_INVALID,&msc_obj_ptr->msd_buff.msc_bulk_in_ptr,(uint32_t *)&lba_data, msc_obj_ptr->class_specific_callback.arg);
+
+ lba_data.buff_ptr = msc_obj_ptr->msd_buff.msc_bulk_in_ptr;
+
+ if(lba_info_ptr->starting_lba < msc_obj_ptr->device_info.total_lba_device_supports)
+ {
+ error = USB_MSC_Bulk_Send_Data(msc_obj_ptr->msc_handle,lba_data.buff_ptr,lba_data.size);
+ }
+ else
+ {
+ msc_obj_ptr->need_in_stall_flag = FALSE; /* clear the flag */
+ msc_obj_ptr->in_stall_flag = TRUE; /* clear the flag */
+ msc_obj_ptr->in_flag = FALSE; /* clear send flag */
+ msc_obj_ptr->stall_status = (uint8_t)STALL_IN_DATA_PHASE;
+ error = usb_device_stall_endpoint(msc_obj_ptr->controller_handle,msc_obj_ptr->bulk_in_endpoint,USB_SEND);
+ }
+ }
+ else
+ {
+ lba_data.size = (msc_obj_ptr->msd_buff.msc_bulk_out_size > MSD_RECV_MAX_TRANS_LENGTH) ?
+ MSD_RECV_MAX_TRANS_LENGTH : msc_obj_ptr->msd_buff.msc_bulk_out_size; /* whichever is smaller */
+ lba_data.size = (msc_obj_ptr->transfer_remaining > lba_data.size) ?
+ lba_data.size : msc_obj_ptr->transfer_remaining; /* whichever is smaller */
+
+ lba_data.buff_ptr = NULL;
+ msc_obj_ptr->class_specific_callback.callback(USB_MSC_DEVICE_WRITE_REQUEST,
+ USB_REQ_VAL_INVALID,&msc_obj_ptr->msd_buff.msc_bulk_out_ptr,(uint32_t *)&lba_data, msc_obj_ptr->class_specific_callback.arg);
+
+ lba_data.buff_ptr = msc_obj_ptr->msd_buff.msc_bulk_out_ptr;
+
+ if(lba_info_ptr->starting_lba < msc_obj_ptr->device_info.total_lba_device_supports)
+ {
+ error = USB_MSC_Bulk_Recv_Data(msc_obj_ptr->controller_handle,lba_data.buff_ptr,lba_data.size);
+ }
+ else
+ {
+ msc_obj_ptr->need_out_stall_flag = FALSE; /* clear the flag */
+ msc_obj_ptr->out_stall_flag = TRUE; /* clear the flag */
+ msc_obj_ptr->out_flag = FALSE; /* clear send flag */
+ msc_obj_ptr->stall_status = (uint8_t)STALL_IN_DATA_PHASE;
+ error = usb_device_stall_endpoint(msc_obj_ptr->controller_handle,msc_obj_ptr->bulk_out_endpoint,USB_RECV);
+ }
+ }
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_MSC_Get_Speed
+ *
+ * @brief This functions get speed from Host.
+ *
+ * @param handle : handle returned by USB_Class_MSC_Init
+ * @param speed : speed
+ *
+ * @return status
+ * USB_OK : When Successfull
+ * Others : Errors
+ *****************************************************************************/
+usb_status USB_Class_MSC_Get_Speed
+(
+msd_handle_t handle,
+uint16_t * speed/* [OUT] the requested error */
+)
+{
+ msc_device_struct_t * msd_obj_ptr;
+ usb_status error = USB_OK;
+
+ msd_obj_ptr = (msc_device_struct_t *)handle;
+ if (NULL == msd_obj_ptr)
+ {
+ return USBERR_NO_DEVICE_CLASS;
+ }
+ error = USB_Class_Get_Status(msd_obj_ptr->class_handle, USB_STATUS_SPEED, speed);
+
+ return error;
+}
+
+#endif /*MSD_CONFIG*/
+/* EOF */
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc.h b/KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc.h
new file mode 100644
index 0000000..9c3d919
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc.h
@@ -0,0 +1,612 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2008, 2013 - 2015 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ * Copyright (c) 1989-2008 ARC International;
+ * All Rights Reserved
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: usb_msc.h$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ * @brief The file contains USB stack MSC class layer api header function.
+ *
+ *****************************************************************************/
+
+#ifndef _USB_MSC_H
+#define _USB_MSC_H 1
+
+/******************************************************************************
+ * Includes
+ *****************************************************************************/
+#include "usb_device_stack_interface.h"
+
+#include "usb_class.h"
+
+#include "usb_class_msc.h"
+
+#include "usb_msc_config.h"
+
+/******************************************************************************
+ * Constants - None
+ *****************************************************************************/
+
+/******************************************************************************
+ * Macro's
+ *****************************************************************************/
+
+/* Class specific request Codes */
+#define BULK_ONLY_MASS_STORAGE_RESET (0xFF)
+#define GET_MAX_LUN (0xFE)
+#define PUT_REQUESTS (0xFD)
+#define GET_REQUESTS (0xFC)
+
+/* Events to the Application *//* 0 to 4 are reserved for class events */
+
+/* other macros */
+#define USB_DCBWSIGNATURE USB_LONG_BE_TO_HOST_CONST(0x55534243)
+#define USB_DCSWSIGNATURE USB_LONG_BE_TO_HOST_CONST(0x55534253)
+#define USB_CBW_DIRECTION_BIT (0x80)
+#define USB_CBW_DIRECTION_SHIFT (7)
+#define MSC_CBW_LENGTH (31)
+#define MSC_CSW_LENGTH (13)
+
+#define COMMAND_PASSED (0x00)
+#define COMMAND_FAILED (0x01)
+#define PHASE_ERROR (0x02)
+
+/* MACROS FOR COMMANDS SUPPORTED */
+#define INQUIRY_COMMAND (0x12)
+#define READ_10_COMMAND (0x28)
+#define READ_12_COMMAND (0xA8)
+#define REQUEST_SENSE_COMMAND (0x03)
+#define TEST_UNIT_READY_COMMAND (0x00)
+#define WRITE_10_COMMAND (0x2A)
+#define WRITE_12_COMMAND (0xAA)
+#define PREVENT_ALLOW_MEDIUM_REM_COMMAND (0x1E)
+#define FORMAT_UNIT_COMMAND (0x04)
+#define READ_CAPACITY_10_COMMAND (0x25)
+#define READ_CAPACITY_16_COMMAND (0x9E)
+#define READ_FORMAT_CAPACITIES_COMMAND (0x23)
+#define MODE_SENSE_10_COMMAND (0x5A)
+#define MODE_SENSE_6_COMMAND (0x1A)
+#define MODE_SELECT_10_COMMAND (0x55)
+#define MODE_SELECT_6_COMMAND (0x15)
+#define SEND_DIAGNOSTIC_COMMAND (0x1D)
+#define VERIFY_COMMAND (0x2F)
+#define START_STOP_UNIT_COMMAND (0x1B)
+
+/*****************************************************************************
+ * Local Functions
+ *****************************************************************************/
+void USB_Service_Bulk_In(usb_event_struct_t* event, void* arg);
+void USB_Service_Bulk_Out(usb_event_struct_t* event, void* arg);
+void USB_Class_MSC_Event(uint8_t event, void* val, void* arg);
+usb_status USB_MSC_Requests(usb_setup_struct_t * setup_packet, uint8_t * *data, uint32_t *size, void* arg);
+
+/******************************************************************************
+ * Types
+ *****************************************************************************/
+typedef enum
+{
+ USB_MSD_EP_COUNT = 1,
+ USB_MSD_INTERFACE_COUNT,
+ USB_MSD_CLASS_INFO,
+} USB_MSD_DESC_INFO_T;
+
+typedef enum
+{
+ STALL_IN_CBW = 1,
+ STALL_IN_DATA_PHASE,
+ STALL_IN_CSW,
+} STALL_TYPES_T;
+
+typedef struct _usb_msc_cbw /* Command Block Wrapper -- 31 bytes */
+{
+ uint32_t signature; /*0-3 : dCBWSignature*/
+ uint32_t tag; /*4-7 : dCBWTag*/
+ uint32_t data_length; /*8-11 : dCBWDataTransferLength*/
+ uint8_t flag; /*12 : bmCBWFlags*/
+ uint8_t lun; /*13 : bCBWLUN(bits 3 to 0)*/
+ uint8_t cb_length; /*14 : bCBWCBLength*/
+ uint8_t command_block[16];/*15-30 : CBWCB*/
+}cbw_t;
+
+typedef struct _usb_msc_csw /* Command Status Wrapper -- 13 bytes */
+{
+ uint32_t signature; /*0-3 : dCSWSignature*/
+ uint32_t tag; /*4-7 : dCSWTag*/
+ uint32_t residue; /*8-11 : dCSWDataResidue*/
+ uint8_t csw_status; /*12 : bCSWStatus*/
+}csw_t;
+
+typedef struct _lba_info_struct
+{
+ uint32_t starting_lba;/* LBA to start transferring with */
+ uint32_t lba_transfer_num;/* number of LBAs to transfer */
+} lba_info_struct_t;
+
+typedef struct _msc_thirteen_case_check
+{
+ usb_device_handle handle;
+ uint32_t host_expected_data_len;
+ uint32_t device_expected_data_len;
+ uint8_t* csw_status_ptr;
+ uint32_t* csw_residue_ptr;
+ uint8_t* buffer_ptr;
+ lba_info_struct_t lba_info;
+ bool lba_txrx_select;
+ uint8_t host_expected_direction;
+ uint8_t device_expected_direction;
+} msc_thirteen_case_struct_t;
+
+/* USB class msc endpoint data */
+typedef struct _msc_endpoint_struct
+{
+ uint8_t endpoint; /* endpoint num */
+ uint8_t type; /* type of endpoint (interrupt, bulk or isochronous) */
+} msc_endpoint_struct_t;
+
+typedef struct _msc_endpoint_data_struct
+{
+ uint8_t count;
+ msc_endpoint_struct_t ep[MAX_MSC_CLASS_EP_NUM];
+} msc_endpoint_data_struct_t;
+
+/* MSD Device Structure */
+typedef struct _msc_variable_struct
+{
+ usb_device_handle controller_handle;
+ uint32_t user_handle;
+ msd_handle_t msc_handle;
+ class_handle_t class_handle;
+ usb_endpoints_t* ep_desc_data;
+ usb_application_callback_struct_t msc_application_callback;
+ usb_vendor_req_callback_struct_t vendor_req_callback;
+ usb_class_specific_callback_struct_t class_specific_callback;
+ usb_desc_request_notify_struct_t desc_callback;
+ /* contains the endpoint info */
+ /* Memory Allocation for endpoint done at App layer. Only App
+ Knows how many endpoints to allocate.
+ */
+ void* scsi_object_ptr;
+ msc_endpoint_data_struct_t msc_endpoint_data;
+ /* macro configured by user*/
+ /* global structure for command status wrapper */
+ csw_t * csw_ptr;
+ /* global structure for command block wrapper */
+ cbw_t * cbw_ptr;
+ device_lba_info_struct_t device_info;
+ msc_buff_info_t msd_buff;
+ /* following two macros are used to manage transfers involving read/write
+ on APPLICATION MASS STORAGE DEVICE */
+ uint32_t transfer_remaining;
+ uint32_t current_offset;
+ uint32_t bulk_in_endpoint_packet_size;
+ uint32_t usb_max_suported_interfaces;
+ uint8_t bulk_in_endpoint;
+ uint8_t bulk_out_endpoint;
+ /* flag to track bulk out data processing after CBW if needed*/
+ bool out_flag;
+ /* flag to track bulk in data processing before CSW if needed*/
+ bool in_flag;
+ /* flag to track if there is stall BULK IN ENDPOINT because of BULK COMMAND*/
+ bool in_stall_flag;
+ /* flag to track if there is stall BULK OUT ENDPOIN because of BULK COMMAND */
+ bool out_stall_flag;
+ /* flag to validate CBW */
+ bool cbw_valid_flag;
+ bool re_stall_flag;
+ bool wait_for_reset_recovery;
+ bool need_to_prepare_next;
+ /* flag to track if there is need to stall BULK IN ENDPOINT because of BULK COMMAND*/
+ bool need_in_stall_flag;
+ /* flag to track if there is need to stall BULK OUT ENDPOIN because of BULK COMMAND */
+ bool need_out_stall_flag;
+ bool cbw_prime_flag;
+ bool csw_prime_flag;
+ uint8_t stall_status;
+ /* LUN can have value only from 0 to 15 decimal */
+ uint8_t lun;
+}msc_device_struct_t;
+
+/**************************************************************************//*!
+ *
+ * @name USB_Class_MSC_Send_Data
+ *
+ * @brief
+ *
+ * @param msc_handle : handle returned from USB_Class_MSC_Init
+ * @param ep_num : endpoint num
+ * @param app_buff : buffer to send
+ * @param size : length of the transfer
+ *
+ * @return status
+ * USB_OK : When Successfull
+ * Others : Errors
+ *****************************************************************************/
+extern usb_status USB_Class_MSC_Send_Data
+(
+ msd_handle_t msc_handle,
+ uint8_t ep_num,
+ uint8_t * app_buff, /* [IN] buffer to send */
+ uint32_t size /* [IN] length of the transfer */
+ );
+
+/**************************************************************************//*!
+ *
+ * @name USB_MSC_LBA_Transfer
+ *
+ * @brief
+ *
+ * @param msc_device_struct_t *
+ * @param direction : transfer direction
+ * @param lba_info_ptr : buffer to send
+ *
+ * @return status
+ * USB_OK : When Successfully
+ * Others : Errors
+ *****************************************************************************/
+extern usb_status USB_MSC_LBA_Transfer
+(
+ msc_device_struct_t * msc_obj_ptr,
+ bool direction,
+ lba_info_struct_t * lba_info_ptr
+ );
+
+#define USB_MSC_Bulk_Send_Data(a,b,c) USB_Class_MSC_Send_Data(a,msc_obj_ptr->bulk_in_endpoint,b,c)
+#define USB_MSC_Bulk_Recv_Data(a,b,c) usb_device_recv_data(a,msc_obj_ptr->bulk_out_endpoint,b,c)
+
+/* Sub Class Functions */
+
+/**************************************************************************//*!
+ *
+ * @name USB_MSC_SCSI_Init
+ *
+ * @brief The function initializes the SCSI parameters and callbacks
+ *
+ * @param msc_obj_ptr MSD class object pointer.
+ * @param cb: event callback
+ * @param storage_disk Ramdisk Memory pointer.
+ * @param lb logical block
+ * @param lab_len length of each logical blocks
+ *
+ * @return status
+ * USB_OK : When Successfully
+ * Others : Errors
+ *
+ *****************************************************************************/
+extern usb_status USB_MSC_SCSI_Init
+(
+ msc_device_struct_t * msc_obj_ptr,
+ usb_class_specific_callback_struct_t* cb,
+ device_lba_info_struct_t* device_info_ptr,
+ uint32_t implementing_disk_drive
+ );
+
+/**************************************************************************//*!
+ *
+ * @name USB_MSC_SCSI_Deinit
+ *
+ * @brief The function de-initializes the SCSI parameters and callbacks
+ *
+ * @param msc_obj_ptr MSD class object pointer.
+ * @return status
+ * USB_OK : When Successfully
+ * Others : Errors
+ *
+ *****************************************************************************/
+extern usb_status USB_MSC_SCSI_Deinit
+(
+ msc_device_struct_t * msc_obj_ptr
+ );
+
+/**************************************************************************//*!
+ *
+ * @name msc_inquiry_command
+ *
+ * @brief It requests that information regarding parameters of the Device be
+ * sent to the Host Computer
+ *
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+
+extern usb_status msc_inquiry_command(msc_device_struct_t * msc_obj_ptr,
+ cbw_t * cbw_ptr,
+ uint32_t* csw_residue_ptr,
+ uint8_t* csw_status_ptr);
+/**************************************************************************//*!
+ *
+ * @name msc_read_command
+ *
+ * @brief command requests that device transfer data to the host computer
+ * (read (10) command)
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+extern usb_status msc_read_command(msc_device_struct_t * msc_obj_ptr,
+ cbw_t * cbw_ptr,
+ uint32_t* csw_residue_ptr,
+ uint8_t* csw_status_ptr);
+/**************************************************************************//*!
+ *
+ * @name msc_request_sense_command
+ *
+ * @brief command instructs the Device to transfer sense data to host computer
+ *
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return NONE
+ *
+ *****************************************************************************/
+extern usb_status msc_request_sense_command(msc_device_struct_t * msc_obj_ptr,
+ cbw_t * cbw_ptr,
+ uint32_t* csw_residue_ptr,
+ uint8_t* csw_status_ptr);
+/**************************************************************************//*!
+ *
+ * @name msc_test_unit_ready_command
+ *
+ * @brief It provides a means to check if the device is ready
+ *
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+extern usb_status msc_test_unit_ready_command(msc_device_struct_t * msc_obj_ptr,
+ cbw_t * cbw_ptr,
+ uint32_t* csw_residue_ptr,
+ uint8_t* csw_status_ptr);
+/**************************************************************************//*!
+ *
+ * @name msc_verify_command
+ *
+ * @brief requests that device verifies the data on medium
+ *
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+extern usb_status msc_verify_command(msc_device_struct_t * msc_obj_ptr,
+ cbw_t * cbw_ptr,
+ uint32_t* csw_residue_ptr,
+ uint8_t* csw_status_ptr);
+/**************************************************************************//*!
+ *
+ * @name msc_mode_sense_command
+ *
+ * @brief command provides a means for a Device to report parameters to Host
+ * Computer.It is a complementary command to the MODE SELECT command.
+ *
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+extern usb_status msc_mode_sense_command(msc_device_struct_t * msc_obj_ptr,
+ cbw_t * cbw_ptr,
+ uint32_t* csw_residue_ptr,
+ uint8_t* csw_status_ptr);
+/**************************************************************************//*!
+ *
+ * @name msc_mode_select_command
+ *
+ * @brief command provides a means for a Device to report parameters to Host
+ * Computer.It is a complementary command to the MODE SENSE command.
+ *
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+extern usb_status msc_mode_select_command(msc_device_struct_t * msc_obj_ptr,
+ cbw_t * cbw_ptr,
+ uint32_t* csw_residue_ptr,
+ uint8_t* csw_status_ptr);
+/**************************************************************************//*!
+ *
+ * @name msc_read_capacity_command
+ *
+ * @brief command provides a means for the host computer to request information
+ * regarding the capacity of the installed medium of the device.
+ *
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+extern usb_status msc_read_capacity_command(msc_device_struct_t * msc_obj_ptr,
+ cbw_t * cbw_ptr,
+ uint32_t* csw_residue_ptr,
+ uint8_t* csw_status_ptr);
+/**************************************************************************//*!
+ *
+ * @name msc_format_unit_command
+ *
+ * @brief host sends the FORMAT UNIT command to physically format a diskette
+ * according to selected options
+ *
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+extern usb_status msc_format_unit_command(msc_device_struct_t * msc_obj_ptr,
+ cbw_t * cbw_ptr,
+ uint32_t* csw_residue_ptr,
+ uint8_t* csw_status_ptr);
+/**************************************************************************//*!
+ *
+ * @name msc_write_command
+ *
+ * @brief command requests that the Device write the data transferred by the
+ * Host Computer to the medium.
+ *
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+extern usb_status msc_write_command(msc_device_struct_t * msc_obj_ptr,
+ cbw_t * cbw_ptr,
+ uint32_t* csw_residue_ptr,
+ uint8_t* csw_status_ptr);
+/**************************************************************************//*!
+ *
+ * @name msc_start_stop_unit_command
+ *
+ * @brief command instructs device to enable or disable media access operations
+ *
+ * @param controller_ID: To identify the controller
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+extern usb_status msc_start_stop_unit_command
+(
+ msc_device_struct_t * msc_obj_ptr,
+ cbw_t * cbw_ptr,
+ uint32_t* csw_residue_ptr,
+ uint8_t* csw_status_ptr
+ );
+
+/**************************************************************************//*!
+ *
+ * @name msc_prevent_allow_medium_removal
+ *
+ * @brief command tells the UFI device to enable or disable the removal of the
+ * medium in the logical unit.
+ *
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+extern usb_status msc_prevent_allow_medium_removal(msc_device_struct_t * msc_obj_ptr,
+ cbw_t * cbw_ptr,
+ uint32_t* csw_residue_ptr,
+ uint8_t* csw_status_ptr);
+/**************************************************************************//*!
+ *
+ * @name msc_read_format_capacity_command
+ *
+ * @brief allows the host to request a list of the possible capacities that
+ * can be formatted on the currently installed medium
+ *
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+extern usb_status msc_read_format_capacity_command(msc_device_struct_t * msc_obj_ptr,
+ cbw_t * cbw_ptr,
+ uint32_t* csw_residue_ptr,
+ uint8_t* csw_status_ptr);
+
+/**************************************************************************//*!
+ *
+ * @name msc_send_diagnostic_command
+ *
+ * @brief requests the device to perform self test
+ *
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+extern usb_status msc_send_diagnostic_command(msc_device_struct_t * msc_obj_ptr,
+ cbw_t * cbw_ptr,
+ uint32_t* csw_residue_ptr,
+ uint8_t* csw_status_ptr);
+
+/**************************************************************************//*!
+ *
+ * @name msc_unsupported_command
+ *
+ * @brief Responds appropriately to unsupported commands
+ *
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+extern usb_status msc_unsupported_command(msc_device_struct_t * msc_obj_ptr,
+ cbw_t * cbw_ptr,
+ uint32_t* csw_residue_ptr,
+ uint8_t* csw_status_ptr);
+
+/* EOF */
+#endif
+
+/* EOF */
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc_scsi.c b/KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc_scsi.c
new file mode 100644
index 0000000..f30b5a3
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc_scsi.c
@@ -0,0 +1,1467 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2008, 2013 - 2014 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ * Copyright (c) 1989-2008 ARC International;
+ * All Rights Reserved
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: usb_msc_scsi.c$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ * @brief The file contains USB Mass Storage SCSI command set.
+ *
+ *****************************************************************************/
+
+/******************************************************************************
+ * Includes
+ *****************************************************************************/
+#include "usb_device_config.h"
+#include "usb.h"
+#include "usb_device_stack_interface.h"
+
+#if USBCFG_DEV_MSC
+#include "usb_class_internal.h"
+#include "usb_msc_scsi.h"
+
+/*****************************************************************************
+ * Constant and Macro's
+ *****************************************************************************/
+inquiry_data_struct_t inquiry_info = /* constant */
+{
+ (PERIPHERAL_QUALIFIER << PERIPHERAL_QUALIFIER_SHIFT)|PERIPHERAL_DEVICE_TYPE,
+ (uint8_t)(REMOVABLE_MEDIUM_BIT << REMOVABLE_MEDIUM_BIT_SHIFT),
+ SPC_VERSION, 0x02, ADDITIONAL_LENGTH, 0x00,0x00,0x00,
+ { 'F', 'S', 'L', ' ', 'S', 'E', 'M', 'I'},
+ { 'F','S','L',' ','M','A','S','S',' ','S','T','O','R','A','G','E'},
+ { '0', '0', '0', '1'}
+};
+
+mode_parameter_header_struct_t mode_param_header =
+{
+ 0x0000,/*no following data available because of reason given below*/
+ 0x00,/* 0x00 indicates current/default medium */
+ 0x00,/* for write_protect and DPOFUA - no write protection available*/
+ { 0x00,0x00,0x00,0x00} /* reserved bytes are always to be set to zero */
+};
+
+/*****************************************************************************
+ * Global Functions Prototypes
+ *****************************************************************************/
+/****************************************************************************
+ * Global Variables
+ ****************************************************************************/
+msc_scsi_struct_t g_msc_scsi[MAX_MSC_DEVICE];
+/* Add all the variables needed for usb_msc.c to this structure */
+/*****************************************************************************
+ * Local Types - None
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Local Functions Prototypes
+ *****************************************************************************/
+usb_status msc_thirteen_cases_check(msc_device_struct_t * msc_obj_ptr,msc_thirteen_case_struct_t* msc_check_event);
+/*****************************************************************************
+ * Local Variables
+ *****************************************************************************/
+//static read_capacity_data_struct_t read_capacity;
+//static read_capacity16_data_struct_t read_capacity16;
+//static uint8_t format_capacity_response_data[sizeof(capacity_list_header_struct_t) + sizeof(curr_max_capacity_desc_struct_t)+
+// sizeof(formattable_cap_desc_t) * 3];
+/*****************************************************************************
+ * Local Functions
+ *****************************************************************************/
+/*************************************************************************//*!
+ *
+ * @name USB_SCSI_Allocate_Handle
+ *
+ * @brief The funtion reserves entry in device array and returns the index.
+ *
+ * @param none.
+ * @return returns the reserved handle or if no entry found device busy.
+ *
+ *****************************************************************************/
+static usb_status USB_SCSI_Allocate_Handle(msc_scsi_struct_t** handle)
+{
+ uint32_t cnt = 0;
+ for (;cnt< MAX_MSC_DEVICE;cnt++)
+ {
+ if (g_msc_scsi[cnt].is_used == 0)
+ {
+ g_msc_scsi[cnt].is_used = 1;
+ *handle = (msc_scsi_struct_t*)&g_msc_scsi[cnt];
+ return USB_OK;
+ }
+ }
+ return USBERR_DEVICE_BUSY;
+}
+/*************************************************************************//*!
+ *
+ * @name USB_SCSI_Free_Handle
+ *
+ * @brief The funtion releases entry in device array .
+ *
+ * @param handle index in device array to be released..
+ * @return returns and error code or USB_OK.
+ *
+ *****************************************************************************/
+
+static usb_status USB_SCSI_Free_Handle(msc_scsi_struct_t* handle)
+{
+ int32_t cnt = 0;
+ for (;cnt< MAX_MSC_DEVICE;cnt++)
+ {
+ if ((&g_msc_scsi[cnt]) == handle)
+ {
+ OS_Mem_zero((void*)handle, sizeof(msc_scsi_struct_t));
+ return USB_OK;
+ }
+ }
+ return USBERR_INVALID_PARAM;
+}
+/**************************************************************************//*!
+ *
+ * @name msc_thirteen_cases_check
+ *
+ * @brief The funtion checks for thirteen error case of MSC and takes action
+ * appropriately
+ *
+ * @param scsi_ptr->thirteen_case: structure containing all necessary parameter to
+ * evaluate error scenarios
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status msc_thirteen_cases_check(msc_device_struct_t * msc_obj_ptr,
+msc_thirteen_case_struct_t* msc_check_event
+)
+{
+ usb_status error = USB_OK;
+ msc_scsi_struct_t* scsi_ptr;
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+
+ if(!msc_check_event->host_expected_data_len)
+ { /* host expects no data transfer */
+ *(msc_check_event->csw_residue_ptr) = 0;
+
+ if(!msc_check_event->device_expected_data_len)
+ { /* CASE 1: Device intends no data transfer : Thin Diagonal Case*/
+ *(msc_check_event->csw_status_ptr) = COMMAND_PASSED;
+ }
+ else
+ { /* if(msc_check_event->device_expected_direction) :
+ CASE 2: Device intends to send data to host
+ else
+ CASE 3: Device intends to receive data from host */
+ *(msc_check_event->csw_status_ptr) = PHASE_ERROR;
+ }
+ }
+ else if(msc_check_event->host_expected_direction)
+ { /* host expects to receive data from device (USB_SEND direction)*/
+ if(!msc_check_event->device_expected_data_len)
+ { /* CASE 4: Device intends no data transfer */
+ *(msc_check_event->csw_residue_ptr) =
+ msc_check_event->host_expected_data_len -
+ msc_check_event->device_expected_data_len;
+ /* sending zero bytes of data */
+ error = USB_MSC_Bulk_Send_Data(msc_obj_ptr->msc_handle,
+ msc_check_event->buffer_ptr,
+ msc_check_event->device_expected_data_len);
+
+ if(error == USB_OK)
+ {
+ *(msc_check_event->csw_status_ptr) = COMMAND_PASSED;
+ }
+ else
+ {
+ *(msc_check_event->csw_status_ptr) = COMMAND_FAILED;
+ scsi_ptr->request_sense.sense_key = MEDIUM_ERROR;
+ scsi_ptr->request_sense.add_sense_code = UNRECOVERED_READ_ERROR;
+ }
+
+ /* BULK IN PIPE TO BE STALLED for status phase */
+ error = USBERR_ENDPOINT_STALLED;
+ }
+ else if(msc_check_event->device_expected_direction)
+ { /* device intends to send data to host */
+ if(msc_check_event->host_expected_data_len >
+ msc_check_event->device_expected_data_len)
+ { /* CASE 5: Host intends more data to receive than device
+ intends to send*/
+ *(msc_check_event->csw_residue_ptr) =
+ msc_check_event->host_expected_data_len -
+ msc_check_event->device_expected_data_len;
+
+ if(scsi_ptr->thirteen_case.lba_txrx_select == TRUE)
+ {
+ error = USB_MSC_LBA_Transfer(msc_obj_ptr,USB_SEND,
+ &msc_check_event->lba_info);
+ }
+ else
+ {
+ error = USB_MSC_Bulk_Send_Data(msc_obj_ptr->msc_handle,
+ msc_check_event->buffer_ptr,
+ msc_check_event->device_expected_data_len);
+ }
+
+// if ((READ_10_COMMAND != msc_obj_ptr->cbw_ptr->command_block[0]) &&
+// (READ_12_COMMAND != msc_obj_ptr->cbw_ptr->command_block[0]) &&
+// (msc_check_event->device_expected_data_len%
+// msc_obj_ptr->bulk_in_endpoint_packet_size == 0))
+// { /* need to send zero bytes of data to tell host that device
+// does not have any more data. This is needed only if the
+// bytes send to host are integral multiple of max packet
+// size of Bulk In endpoint */
+// error |= USB_MSC_Bulk_Send_Data(msc_obj_ptr->msc_handle,
+// msc_check_event->buffer_ptr,0);
+// }
+
+ if(error == USB_OK)
+ {
+ *(msc_check_event->csw_status_ptr) = COMMAND_PASSED;
+ }
+ else
+ {
+ *(msc_check_event->csw_status_ptr) = COMMAND_FAILED;
+ scsi_ptr->request_sense.sense_key = MEDIUM_ERROR;
+ scsi_ptr->request_sense.add_sense_code = UNRECOVERED_READ_ERROR;
+ }
+ /* BULK IN PIPE TO BE STALLED for status phase */
+ error = USBERR_ENDPOINT_STALLED;
+ }
+ else if(msc_check_event->host_expected_data_len ==
+ msc_check_event->device_expected_data_len)
+ { /* CASE 6: Host intends exact amount of data to receive
+ as device intends to send : Thin Diagonal Case*/
+ *(msc_check_event->csw_residue_ptr) = 0;
+
+ if(scsi_ptr->thirteen_case.lba_txrx_select == TRUE)
+ {
+ error = USB_MSC_LBA_Transfer(msc_obj_ptr,USB_SEND,
+ &msc_check_event->lba_info);
+ }
+ else
+ {
+ error = USB_MSC_Bulk_Send_Data(msc_obj_ptr->msc_handle,
+ msc_check_event->buffer_ptr,
+ msc_check_event->device_expected_data_len);
+ }
+
+ if(error == USB_OK)
+ {
+ *(msc_check_event->csw_status_ptr) = COMMAND_PASSED;
+ }
+ else
+ {
+ *(msc_check_event->csw_status_ptr) = COMMAND_FAILED;
+ scsi_ptr->request_sense.sense_key = MEDIUM_ERROR;
+ scsi_ptr->request_sense.add_sense_code = UNRECOVERED_READ_ERROR;
+ }
+ }
+ else
+ {
+ /* CASE 7: Host intends less data to receive than device
+ intends to send*/
+ *(msc_check_event->csw_residue_ptr) = 0;
+
+ if (scsi_ptr->thirteen_case.lba_txrx_select == TRUE)
+ {
+ msc_check_event->lba_info.lba_transfer_num =
+ msc_check_event->host_expected_data_len /
+ scsi_ptr->length_of_each_lab;
+ *(msc_check_event->csw_residue_ptr) = msc_check_event->host_expected_data_len - msc_check_event->lba_info.lba_transfer_num * scsi_ptr->length_of_each_lab;
+ error = USB_MSC_LBA_Transfer(msc_obj_ptr,USB_SEND,
+ &msc_check_event->lba_info);
+ }
+ else
+ {
+ error = USB_MSC_Bulk_Send_Data(msc_obj_ptr->msc_handle,
+ msc_check_event->buffer_ptr,
+ msc_check_event->host_expected_data_len);
+ }
+
+ if(error == USB_OK)
+ {
+ if (scsi_ptr->thirteen_case.lba_txrx_select == TRUE) /* READ_COMMAND OR WRITE_COMMAND */
+ {
+ *(msc_check_event->csw_status_ptr) = PHASE_ERROR;
+ }
+ else
+ {
+ *(msc_check_event->csw_status_ptr) = COMMAND_PASSED;
+ }
+ }
+ else
+ {
+ *(msc_check_event->csw_status_ptr) = COMMAND_FAILED;
+ scsi_ptr->request_sense.sense_key = MEDIUM_ERROR;
+ scsi_ptr->request_sense.add_sense_code = UNRECOVERED_READ_ERROR;
+ }
+ }
+ }
+ else
+ { /* CASE 8: Device intends to receive data from host */
+ *(msc_check_event->csw_residue_ptr) =
+ msc_check_event->host_expected_data_len;
+ /* device has no data to send */
+ error = USB_MSC_Bulk_Send_Data(msc_obj_ptr->msc_handle,
+ msc_check_event->buffer_ptr,0);
+ *(msc_check_event->csw_status_ptr) = PHASE_ERROR;
+ /* BULK IN PIPE TO BE STALLED for status phase */
+ error = USBERR_ENDPOINT_STALLED;
+ }
+ }
+ else
+ { /* host expects to send data to device (USB_RECV direction)*/
+ if(!msc_check_event->device_expected_data_len)
+ { /* CASE 9: Device intends no data transfer */
+ usb_device_stall_endpoint(msc_obj_ptr->controller_handle,msc_obj_ptr->bulk_out_endpoint, USB_RECV);
+ *(msc_check_event->csw_residue_ptr) =
+ msc_check_event->host_expected_data_len;
+ *(msc_check_event->csw_status_ptr) = COMMAND_FAILED;
+ /* BULK OUT PIPE STALLED */
+ msc_obj_ptr->out_stall_flag = TRUE;
+ error = USBERR_ENDPOINT_STALLED;
+ }
+ else if(msc_check_event->device_expected_direction)
+ { /*CASE10: device intends to send data to host */
+ usb_device_stall_endpoint(msc_obj_ptr->controller_handle,msc_obj_ptr->bulk_out_endpoint, USB_RECV);
+ *(msc_check_event->csw_residue_ptr) =
+ msc_check_event->host_expected_data_len;
+ *(msc_check_event->csw_status_ptr) = PHASE_ERROR;
+ /* BULK OUT PIPE STALLED */
+ msc_obj_ptr->out_stall_flag = TRUE;
+ error = USBERR_ENDPOINT_STALLED;
+ }
+ else
+ { /*Device intends to receive data from host */
+ if(msc_check_event->host_expected_data_len >
+ msc_check_event->device_expected_data_len)
+ { /* CASE 11: Host intends more data to send than device
+ intends to receive*/
+ *(msc_check_event->csw_residue_ptr) =
+ msc_check_event->host_expected_data_len -
+ msc_check_event->device_expected_data_len;
+
+ if(scsi_ptr->thirteen_case.lba_txrx_select == TRUE)
+ {
+ error = USB_MSC_LBA_Transfer(msc_obj_ptr,USB_RECV,
+ &msc_check_event->lba_info);
+ }
+ else
+ {
+ error = USB_MSC_Bulk_Recv_Data(msc_obj_ptr->controller_handle,
+ msc_check_event->buffer_ptr,
+ msc_check_event->device_expected_data_len);
+ }
+
+ if(error == USB_OK)
+ {
+ *(msc_check_event->csw_status_ptr) = COMMAND_PASSED;
+ }
+ else
+ {
+ *(msc_check_event->csw_status_ptr) = COMMAND_FAILED;
+ scsi_ptr->request_sense.sense_key = MEDIUM_ERROR;
+ scsi_ptr->request_sense.add_sense_code = WRITE_FAULT;
+ }
+ /* BULK OUT PIPE TO BE STALLED for status phase */
+ error = USBERR_ENDPOINT_STALLED;
+ }
+ else if(msc_check_event->host_expected_data_len ==
+ msc_check_event->device_expected_data_len)
+ { /* CASE 12: Host intends exact amount of data to send
+ as device intends to receive : Thin Diagonal Case*/
+ *(msc_check_event->csw_residue_ptr) = 0;
+
+ if(scsi_ptr->thirteen_case.lba_txrx_select == TRUE)
+ {
+ error = USB_MSC_LBA_Transfer(msc_obj_ptr,USB_RECV,
+ &msc_check_event->lba_info);
+ }
+ else
+ {
+ error = USB_MSC_Bulk_Recv_Data(msc_obj_ptr->controller_handle,
+ msc_check_event->buffer_ptr,
+ msc_check_event->device_expected_data_len);
+ }
+
+ if(error == USB_OK)
+ {
+ *(msc_check_event->csw_status_ptr) = COMMAND_PASSED;
+ }
+ else
+ {
+ *(msc_check_event->csw_status_ptr) = COMMAND_FAILED;
+ scsi_ptr->request_sense.sense_key = MEDIUM_ERROR;
+ scsi_ptr->request_sense.add_sense_code = WRITE_FAULT;
+ }
+ }
+ else
+ {
+ /* CASE 13: Host intends less data to send than device
+ intends to receive*/
+ *(msc_check_event->csw_residue_ptr) = 0;
+
+ if(scsi_ptr->thirteen_case.lba_txrx_select == TRUE)
+ {
+ msc_check_event->lba_info.lba_transfer_num =
+ msc_check_event->host_expected_data_len /
+ scsi_ptr->length_of_each_lab;
+ *(msc_check_event->csw_residue_ptr) = msc_check_event->host_expected_data_len - msc_check_event->lba_info.lba_transfer_num * scsi_ptr->length_of_each_lab;
+ error = USB_MSC_LBA_Transfer(msc_obj_ptr,USB_RECV,
+ &msc_check_event->lba_info);
+ }
+ else
+ {
+ error = USB_MSC_Bulk_Recv_Data(msc_obj_ptr->controller_handle,
+ msc_check_event->buffer_ptr,
+ msc_check_event->host_expected_data_len);
+ }
+
+ if (error == USB_OK)
+ {
+ if (scsi_ptr->thirteen_case.lba_txrx_select == TRUE) /* READ_COMMAND OR WRITE_COMMAND */
+ {
+ *(msc_check_event->csw_status_ptr) = PHASE_ERROR;
+ }
+ else
+ {
+ *(msc_check_event->csw_status_ptr) = COMMAND_PASSED;
+ }
+ }
+ else
+ {
+ scsi_ptr->request_sense.sense_key = MEDIUM_ERROR;
+ scsi_ptr->request_sense.add_sense_code = WRITE_FAULT;
+ }
+ }
+ }
+ }
+ return error;
+}
+
+/*****************************************************************************
+ * Global Functions
+ *****************************************************************************/
+
+/**************************************************************************//*!
+ *
+ * @name USB_MSC_SCSI_Init
+ *
+ * @brief The funtion initializes the SCSI parameters and callbacks
+ *
+ * @param msc_obj_ptr MSD class object pointer.
+ * @param cb: event callback
+ * @param device_info_ptr : Contains MSD device info like number of LBA, etc
+ * @return status
+ * USB_OK : When Successfull
+ * Others : Errors
+ *
+ *****************************************************************************/
+usb_status USB_MSC_SCSI_Init
+(
+msc_device_struct_t * msc_obj_ptr,
+usb_class_specific_callback_struct_t* cb,
+device_lba_info_struct_t* device_info_ptr,
+uint32_t implementing_disk_drive
+)
+{
+ msc_scsi_struct_t* scsi_ptr = NULL;
+ usb_status error = USBERR_ERROR;
+ /* initialize the Global Variable Structure */
+
+ error = USB_SCSI_Allocate_Handle(&scsi_ptr);
+ if (USB_OK != error)
+ {
+ return error;
+ }
+
+ /* save input parameters */
+ scsi_ptr->scsi_callback.callback = cb->callback;
+ scsi_ptr->scsi_callback.arg = cb->arg;
+ scsi_ptr->total_logical_add_block =
+ device_info_ptr->total_lba_device_supports;
+ scsi_ptr->length_of_each_lab =
+ device_info_ptr->length_of_each_lab_of_device;
+ scsi_ptr->implementing_disk_drive = implementing_disk_drive;
+
+ /* no need to initialize other structure fields as g_resquest_sense has
+ been declared as static */
+ scsi_ptr->request_sense.valid_error_code = REQ_SENSE_VALID_ERROR_CODE;
+ scsi_ptr->request_sense.add_sense_len = REQ_SENSE_ADDITIONAL_SENSE_LEN;
+ scsi_ptr->request_sense.sense_key = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code_qual = NO_SENSE;
+
+ if(scsi_ptr->scsi_callback.callback != NULL)
+ {
+ scsi_ptr->scsi_callback.callback(USB_MSC_DEVICE_GET_INFO,USB_REQ_VAL_INVALID,NULL,(uint32_t *)device_info_ptr,NULL);
+ }
+
+ scsi_ptr->total_logical_add_block =
+ device_info_ptr->total_lba_device_supports;
+ scsi_ptr->length_of_each_lab =
+ device_info_ptr->length_of_each_lab_of_device;
+
+ scsi_ptr->read_capacity.last_logical_block_address = USB_LONG_BE_TO_HOST(scsi_ptr->total_logical_add_block -1);
+ scsi_ptr->read_capacity.block_size = USB_LONG_BE_TO_HOST((uint32_t) scsi_ptr->length_of_each_lab);
+ scsi_ptr->read_capacity16.last_logical_block_address1 = USB_LONG_BE_TO_HOST(scsi_ptr->total_logical_add_block -1);
+ scsi_ptr->read_capacity16.block_size = USB_LONG_BE_TO_HOST((uint32_t) scsi_ptr->length_of_each_lab);
+
+ msc_obj_ptr->scsi_object_ptr = scsi_ptr;
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_MSC_SCSI_Deinit
+ *
+ * @brief The funtion deinitializes the SCSI parameters and callbacks
+ *
+ * @param msc_obj_ptr MSD class object pointer.
+ * @return status
+ * USB_OK : When Successfull
+ * Others : Errors
+ *
+ *****************************************************************************/
+usb_status USB_MSC_SCSI_Deinit
+(
+msc_device_struct_t * msc_obj_ptr
+)
+{
+ if(NULL == msc_obj_ptr)
+ {
+ return USBERR_ERROR;
+ }
+ USB_SCSI_Free_Handle((msc_scsi_struct_t* )msc_obj_ptr->scsi_object_ptr);
+
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ *
+ * @name msc_request_sense_command
+ *
+ * @brief command instructs the Device to transfer sense data to host computer
+ *
+ * @param handle
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return NONE
+ *
+ *****************************************************************************/
+usb_status msc_request_sense_command
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ usb_status error;
+ msc_scsi_struct_t* scsi_ptr;
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+
+ scsi_ptr->thirteen_case.handle = msc_obj_ptr->controller_handle;
+ scsi_ptr->thirteen_case.host_expected_data_len = cbw_ptr->data_length;
+ scsi_ptr->thirteen_case.host_expected_direction =
+ (uint8_t)(cbw_ptr->flag >> USB_CBW_DIRECTION_SHIFT);
+ scsi_ptr->thirteen_case.device_expected_data_len = REQ_SENSE_DATA_LENGTH;
+ scsi_ptr->thirteen_case.device_expected_direction = USB_SEND;
+ scsi_ptr->thirteen_case.csw_status_ptr = csw_status_ptr;
+ scsi_ptr->thirteen_case.csw_residue_ptr = csw_residue_ptr;
+ scsi_ptr->thirteen_case.buffer_ptr = (uint8_t *)&scsi_ptr->request_sense;
+ scsi_ptr->thirteen_case.lba_txrx_select = FALSE;
+
+ error = msc_thirteen_cases_check(msc_obj_ptr, &scsi_ptr->thirteen_case);
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name msc_inquiry_command
+ *
+ * @brief It requests that information regarding parameters of the Device be
+ * sent to the Host Computer
+ *
+ * @param handle
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status msc_inquiry_command
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ msc_scsi_struct_t* scsi_ptr;
+ usb_status error = USBERR_TX_FAILED;
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+
+ /* initialize sense code values */
+ scsi_ptr->request_sense.sense_key = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code_qual = NO_SENSE;
+
+ scsi_ptr->thirteen_case.handle = msc_obj_ptr->controller_handle;
+ scsi_ptr->thirteen_case.host_expected_data_len = cbw_ptr->data_length;
+ scsi_ptr->thirteen_case.host_expected_direction =
+ (uint8_t)(cbw_ptr->flag >> USB_CBW_DIRECTION_SHIFT);
+ scsi_ptr->thirteen_case.device_expected_data_len = INQUIRY_ALLOCATION_LENGTH;
+ scsi_ptr->thirteen_case.device_expected_direction = USB_SEND;
+ scsi_ptr->thirteen_case.csw_status_ptr = csw_status_ptr;
+ scsi_ptr->thirteen_case.csw_residue_ptr = csw_residue_ptr;
+ scsi_ptr->thirteen_case.buffer_ptr = (uint8_t *)&inquiry_info;
+ scsi_ptr->thirteen_case.lba_txrx_select = FALSE;
+
+ error = msc_thirteen_cases_check(msc_obj_ptr, &scsi_ptr->thirteen_case);
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name msc_read_command
+ *
+ * @brief command requests that device transfer data to the host computer
+ * (read (10) command)
+ * @param handle
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status msc_read_command
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ msc_scsi_struct_t* scsi_ptr;
+ uint32_t lba = 0;
+ uint32_t num_lba_tx = 0;
+ usb_status error = USBERR_TX_FAILED;
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+
+ /* initialize sense code values */
+ scsi_ptr->request_sense.sense_key = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code_qual = NO_SENSE;
+
+ lba = ((uint32_t)cbw_ptr->command_block[2] << 24);
+ lba |= ((uint32_t)cbw_ptr->command_block[3] << 16);
+ lba |= ((uint32_t)cbw_ptr->command_block[4] << 8);
+ lba |= ((uint32_t)cbw_ptr->command_block[5]);
+
+ if(cbw_ptr->command_block[0] == READ_10_COMMAND)
+ {
+ num_lba_tx = (uint16_t)((uint16_t)cbw_ptr->command_block[7] << 8);
+ num_lba_tx |= (uint16_t)cbw_ptr->command_block[8];
+ }
+ else if(cbw_ptr->command_block[0] == READ_12_COMMAND)
+ {
+ num_lba_tx = ((uint32_t)cbw_ptr->command_block[6] << 24);
+ num_lba_tx |= ((uint32_t)cbw_ptr->command_block[7] << 16);
+ num_lba_tx |= ((uint32_t)cbw_ptr->command_block[8] << 8);
+ num_lba_tx |= ((uint32_t)cbw_ptr->command_block[9]);
+ }
+
+ scsi_ptr->thirteen_case.handle = msc_obj_ptr->controller_handle;
+ scsi_ptr->thirteen_case.host_expected_data_len = cbw_ptr->data_length;
+
+ scsi_ptr->thirteen_case.host_expected_direction =
+ (uint8_t)(cbw_ptr->flag >> USB_CBW_DIRECTION_SHIFT);
+ scsi_ptr->thirteen_case.device_expected_direction = USB_SEND;
+ scsi_ptr->thirteen_case.csw_status_ptr = csw_status_ptr;
+ scsi_ptr->thirteen_case.csw_residue_ptr = csw_residue_ptr;
+
+ scsi_ptr->thirteen_case.device_expected_data_len =
+ scsi_ptr->length_of_each_lab * num_lba_tx;
+ scsi_ptr->thirteen_case.buffer_ptr = NULL;
+
+ scsi_ptr->thirteen_case.lba_txrx_select = TRUE;
+ scsi_ptr->thirteen_case.lba_info.starting_lba = lba;
+ scsi_ptr->thirteen_case.lba_info.lba_transfer_num = num_lba_tx;
+
+ error = msc_thirteen_cases_check(msc_obj_ptr, &scsi_ptr->thirteen_case);
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name msc_write_command
+ *
+ * @brief command requests that the Device write the data transferred by the
+ * Host Computer to the medium.
+ *
+ * @param handle
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status msc_write_command
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ msc_scsi_struct_t* scsi_ptr;
+ uint32_t lba = 0;
+ uint32_t num_lba_rx = 0;
+ usb_status error = USBERR_RX_FAILED;
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+
+ /* initialize sense code values */
+ scsi_ptr->request_sense.sense_key = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code_qual = NO_SENSE;
+
+ lba = ((uint32_t)cbw_ptr->command_block[2] << 24);
+ lba |= ((uint32_t)cbw_ptr->command_block[3] << 16);
+ lba |= ((uint32_t)cbw_ptr->command_block[4] << 8);
+ lba |= ((uint32_t)cbw_ptr->command_block[5]);
+
+ if(cbw_ptr->command_block[0] == WRITE_10_COMMAND)
+ {
+ num_lba_rx = (uint16_t)((uint16_t)cbw_ptr->command_block[7] << 8);
+ num_lba_rx |= (uint16_t)cbw_ptr->command_block[8];
+ }
+ else if(cbw_ptr->command_block[0] == WRITE_12_COMMAND)
+ {
+ num_lba_rx = ((uint32_t)cbw_ptr->command_block[6] << 24);
+ num_lba_rx |= ((uint32_t)cbw_ptr->command_block[7] << 16);
+ num_lba_rx |= ((uint32_t)cbw_ptr->command_block[8] << 8);
+ num_lba_rx |= ((uint32_t)cbw_ptr->command_block[9]);
+ }
+
+ scsi_ptr->thirteen_case.handle = msc_obj_ptr->controller_handle;
+ scsi_ptr->thirteen_case.host_expected_data_len = cbw_ptr->data_length;
+ scsi_ptr->thirteen_case.host_expected_direction =
+ (uint8_t)(cbw_ptr->flag >> USB_CBW_DIRECTION_SHIFT);
+ scsi_ptr->thirteen_case.device_expected_direction = USB_RECV;
+ scsi_ptr->thirteen_case.csw_status_ptr = csw_status_ptr;
+ scsi_ptr->thirteen_case.csw_residue_ptr = csw_residue_ptr;
+
+ scsi_ptr->thirteen_case.buffer_ptr = NULL;
+
+#if 0
+ if(usb_device_get_transfer_status(msc_obj_ptr->controller_handle,
+ BULK_OUT_ENDPOINT, USB_RECV) != USB_STATUS_IDLE)
+ {
+ (void)usb_device_cancel_transfer(msc_obj_ptr->controller_handle,BULK_OUT_ENDPOINT,
+ USB_RECV);
+ }
+#endif
+
+ scsi_ptr->thirteen_case.device_expected_data_len =
+ scsi_ptr->length_of_each_lab * num_lba_rx;
+
+ scsi_ptr->thirteen_case.lba_txrx_select = TRUE;
+ scsi_ptr->thirteen_case.lba_info.starting_lba = lba;
+ scsi_ptr->thirteen_case.lba_info.lba_transfer_num = num_lba_rx;
+
+ error = msc_thirteen_cases_check(msc_obj_ptr, &scsi_ptr->thirteen_case);
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name msc_test_unit_ready_command
+ *
+ * @brief It provides a means to check if the device is ready
+ *
+ * @param handle
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status msc_test_unit_ready_command
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ msc_scsi_struct_t* scsi_ptr;
+ usb_status error;
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+ /* initialize sense code values */
+ scsi_ptr->request_sense.sense_key = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code_qual = NO_SENSE;
+
+ scsi_ptr->thirteen_case.handle = msc_obj_ptr->controller_handle;
+ scsi_ptr->thirteen_case.host_expected_data_len = cbw_ptr->data_length;
+ scsi_ptr->thirteen_case.host_expected_direction =
+ (uint8_t)(cbw_ptr->flag >> USB_CBW_DIRECTION_SHIFT);
+
+ scsi_ptr->thirteen_case.device_expected_data_len = 0;
+ scsi_ptr->thirteen_case.device_expected_direction = USB_SEND;
+ scsi_ptr->thirteen_case.csw_status_ptr = csw_status_ptr;
+ scsi_ptr->thirteen_case.csw_residue_ptr = csw_residue_ptr;
+ scsi_ptr->thirteen_case.buffer_ptr = NULL;
+ scsi_ptr->thirteen_case.lba_txrx_select = FALSE;
+
+ error = msc_thirteen_cases_check(msc_obj_ptr, &scsi_ptr->thirteen_case);
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name msc_verify_command
+ *
+ * @brief requests that device verifies the data on medium
+ *
+ * @param handle
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status msc_verify_command
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ msc_scsi_struct_t* scsi_ptr;
+ usb_status error;
+ /* Our Device has no mechanism to verify the blocks,
+ so just returning success status to host*/
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+ /* initialize sense code values */
+ scsi_ptr->request_sense.sense_key = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code_qual = NO_SENSE;
+
+ scsi_ptr->thirteen_case.handle = msc_obj_ptr->controller_handle;
+ scsi_ptr->thirteen_case.host_expected_data_len = cbw_ptr->data_length;
+ scsi_ptr->thirteen_case.host_expected_direction =
+ (uint8_t)(cbw_ptr->flag >> USB_CBW_DIRECTION_SHIFT);
+
+ scsi_ptr->thirteen_case.device_expected_data_len = 0;
+ scsi_ptr->thirteen_case.device_expected_direction = USB_SEND;
+ scsi_ptr->thirteen_case.csw_status_ptr = csw_status_ptr;
+ scsi_ptr->thirteen_case.csw_residue_ptr = csw_residue_ptr;
+ scsi_ptr->thirteen_case.buffer_ptr = NULL;
+ scsi_ptr->thirteen_case.lba_txrx_select = FALSE;
+
+ error = msc_thirteen_cases_check(msc_obj_ptr, &scsi_ptr->thirteen_case);
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name msc_mode_sense_command
+ *
+ * @brief command provides a means for a Device to report parameters to Host
+ * Computer.It is a complementary command to the MODE SELECT command.
+ *
+ * @param handle
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status msc_mode_sense_command
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ msc_scsi_struct_t* scsi_ptr;
+ usb_status error = USBERR_TX_FAILED;
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+ /* initialize sense code values */
+ scsi_ptr->request_sense.sense_key = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code_qual = NO_SENSE;
+
+ /* irrespective of DBD(Disable block descriptor) bit in Command Block
+ Wrapper we are not returning any block descriptors in the returned mode
+ sense data.Presently, we are just returning Mode Parameter Header */
+
+ scsi_ptr->thirteen_case.handle = msc_obj_ptr->controller_handle;
+ scsi_ptr->thirteen_case.host_expected_data_len = cbw_ptr->data_length;
+ scsi_ptr->thirteen_case.host_expected_direction =
+ (uint8_t)(cbw_ptr->flag >> USB_CBW_DIRECTION_SHIFT);
+ scsi_ptr->thirteen_case.device_expected_data_len = sizeof(mode_param_header);
+ scsi_ptr->thirteen_case.device_expected_direction = USB_SEND;
+ scsi_ptr->thirteen_case.csw_status_ptr = csw_status_ptr;
+ scsi_ptr->thirteen_case.csw_residue_ptr = csw_residue_ptr;
+ scsi_ptr->thirteen_case.buffer_ptr = (uint8_t *)&mode_param_header;
+ scsi_ptr->thirteen_case.lba_txrx_select = FALSE;
+
+ error = msc_thirteen_cases_check(msc_obj_ptr, &scsi_ptr->thirteen_case);
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name msc_mode_select_command
+ *
+ * @brief command provides a means for a Device to report parameters to Host
+ * Computer.It is a complementary command to the MODE SENSE command.
+ *
+ * @param handle
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status msc_mode_select_command
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ msc_scsi_struct_t* scsi_ptr;
+ usb_status error = USBERR_TX_FAILED;
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+ /* initialize sense code values */
+ scsi_ptr->request_sense.sense_key = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code_qual = NO_SENSE;
+
+ scsi_ptr->thirteen_case.handle = msc_obj_ptr->controller_handle;
+ scsi_ptr->thirteen_case.host_expected_data_len = cbw_ptr->data_length;
+ scsi_ptr->thirteen_case.host_expected_direction =
+ (uint8_t)(cbw_ptr->flag >> USB_CBW_DIRECTION_SHIFT);
+
+ scsi_ptr->thirteen_case.device_expected_data_len = sizeof(mode_param_header);
+ scsi_ptr->thirteen_case.device_expected_direction = USB_SEND;
+ scsi_ptr->thirteen_case.csw_status_ptr = csw_status_ptr;
+ scsi_ptr->thirteen_case.csw_residue_ptr = csw_residue_ptr;
+ scsi_ptr->thirteen_case.buffer_ptr = (uint8_t *)&mode_param_header;
+ scsi_ptr->thirteen_case.lba_txrx_select = FALSE;
+
+ error = msc_thirteen_cases_check(msc_obj_ptr, &scsi_ptr->thirteen_case);
+
+ if(cbw_ptr->command_block[1] & 0x01)/* checking Save Pages Bit in command*/
+ {
+ scsi_ptr->request_sense.sense_key = ILLEGAL_REQUEST;
+ scsi_ptr->request_sense.add_sense_code = INVALID_FIELD_IN_COMMAND_PKT;
+ /*logical unit does not implement save mode pages in our case*/
+ }
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name msc_read_capacity_command
+ *
+ * @brief command provides a means for the host computer to request information
+ * regarding the capacity of the installed medium of the device.
+ *
+ * @param handle
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status msc_read_capacity_command
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ msc_scsi_struct_t* scsi_ptr;
+ usb_status error = USBERR_TX_FAILED;
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+
+ /* initialize sense code values */
+ scsi_ptr->request_sense.sense_key = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code_qual = NO_SENSE;
+
+ scsi_ptr->thirteen_case.handle = msc_obj_ptr->controller_handle;
+ scsi_ptr->thirteen_case.host_expected_data_len = cbw_ptr->data_length;
+ scsi_ptr->thirteen_case.host_expected_direction =
+ (uint8_t)(cbw_ptr->flag >> USB_CBW_DIRECTION_SHIFT);
+ if(cbw_ptr->command_block[0] == READ_CAPACITY_10_COMMAND)
+ {
+ scsi_ptr->thirteen_case.device_expected_data_len = READ_CAPACITY_DATA_LENGTH;
+ scsi_ptr->thirteen_case.buffer_ptr = (uint8_t *)&(scsi_ptr->read_capacity);
+ }
+ else
+ {
+ scsi_ptr->thirteen_case.device_expected_data_len = READ_CAPACITY16_DATA_LENGTH;
+ scsi_ptr->thirteen_case.buffer_ptr = (uint8_t *)&(scsi_ptr->read_capacity16);
+ }
+ scsi_ptr->thirteen_case.device_expected_direction = USB_SEND;
+ scsi_ptr->thirteen_case.csw_status_ptr = csw_status_ptr;
+ scsi_ptr->thirteen_case.csw_residue_ptr = csw_residue_ptr;
+ scsi_ptr->thirteen_case.lba_txrx_select = FALSE;
+
+ error = msc_thirteen_cases_check(msc_obj_ptr, &scsi_ptr->thirteen_case);
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name msc_read_format_capacity_command
+ *
+ * @brief allows the host to request a list of the possible capacities that
+ * can be formatted on the currently installed medium
+ *
+ * @param handle
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status msc_read_format_capacity_command
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ msc_scsi_struct_t* scsi_ptr;
+ uint8_t num_formattable_cap_desc;
+ uint16_t allocation_length;
+ /* pointer to data to be sent in data phase for this command*/
+ //uint8_t * response_data_ptr = NULL;
+ /* size of data to be sent in data phase for this command*/
+ uint32_t response_size;
+ /* general variable for counting in loop */
+ uint8_t i;
+ curr_max_capacity_desc_struct_t curr_max_cap_header;
+ uint8_t desc_code;
+ formattable_cap_desc_t formattable_cap_descriptor;
+ capacity_list_header_struct_t capacity_list_header= {{0x00,0x00,0x00},0x00};
+ usb_status error = USBERR_TX_FAILED;
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+ allocation_length = (uint16_t)((uint8_t)(cbw_ptr->command_block[7] << 8) |
+ cbw_ptr->command_block[8]);
+
+ num_formattable_cap_desc = (uint8_t)(scsi_ptr->formatted_disk ?
+ (scsi_ptr->implementing_disk_drive?0x02:0x03):0x00);
+ /*
+ * gives the number of Formattable Capacity Descriptor to be sent by device
+ * in response to read format capacities command
+ */
+
+ /*
+ * 0x03 is number of formattable capcity desc for HD while for DD its 2 if
+ * formatted drive is there
+ */
+
+ formattable_cap_descriptor.num_blocks = scsi_ptr->total_logical_add_block;
+ formattable_cap_descriptor.block_len = scsi_ptr->length_of_each_lab;
+
+ desc_code = (uint8_t)(scsi_ptr->formatted_disk?FORMATTED_MEDIA:UNFORMATTED_MEDIA);
+ /* initialize sense code values */
+ scsi_ptr->request_sense.sense_key = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code_qual = NO_SENSE;
+
+ capacity_list_header.capacity_list_len = (uint8_t)(num_formattable_cap_desc * 8);
+ curr_max_cap_header.num_blocks = scsi_ptr->total_logical_add_block;
+ curr_max_cap_header.desc_code_and_block_len = (uint8_t)(desc_code << 24)|
+ scsi_ptr->length_of_each_lab;
+ response_size = sizeof(capacity_list_header) + sizeof(curr_max_cap_header)+
+ sizeof(formattable_cap_descriptor) * num_formattable_cap_desc;
+
+ if(response_size > allocation_length)
+ { /* comapring the length of data available with allocation length value
+ sent in CBW which indicates the length of buffer host has reserved
+ for data phase of this command */
+ response_size = allocation_length;
+ }
+
+ if(sizeof(scsi_ptr->format_capacity_response_data) < response_size)
+ {
+ USB_PRINTF("format_capacity_response_data buff size less than need\n");
+ }
+ OS_Mem_zero(scsi_ptr->format_capacity_response_data, response_size);
+
+ OS_Mem_copy(&capacity_list_header, scsi_ptr->format_capacity_response_data,
+ sizeof(capacity_list_header));
+ OS_Mem_copy(&curr_max_cap_header, scsi_ptr->format_capacity_response_data +
+ sizeof(capacity_list_header),sizeof(curr_max_cap_header));
+
+ if(scsi_ptr->formatted_disk)
+ {
+ for(i = 0; i < num_formattable_cap_desc; i++)
+ {
+ OS_Mem_copy(&formattable_cap_descriptor, scsi_ptr->format_capacity_response_data +
+ sizeof(capacity_list_header) + sizeof(curr_max_cap_header)+
+ sizeof(formattable_cap_descriptor) * i,
+ sizeof(formattable_cap_descriptor));
+ }
+ }
+
+ scsi_ptr->thirteen_case.handle = msc_obj_ptr->controller_handle;
+ scsi_ptr->thirteen_case.host_expected_data_len = cbw_ptr->data_length;
+ scsi_ptr->thirteen_case.host_expected_direction =
+ (uint8_t)(cbw_ptr->flag >> USB_CBW_DIRECTION_SHIFT);
+ scsi_ptr->thirteen_case.device_expected_data_len = response_size;
+ scsi_ptr->thirteen_case.device_expected_direction = USB_SEND;
+ scsi_ptr->thirteen_case.csw_status_ptr = csw_status_ptr;
+ scsi_ptr->thirteen_case.csw_residue_ptr = csw_residue_ptr;
+ scsi_ptr->thirteen_case.buffer_ptr = scsi_ptr->format_capacity_response_data;
+ scsi_ptr->thirteen_case.lba_txrx_select = FALSE;
+
+ error = msc_thirteen_cases_check(msc_obj_ptr, &scsi_ptr->thirteen_case);
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name msc_format_unit_command
+ *
+ * @brief host sends the FORMAT UNIT command to physically format a diskette
+ * according to selected options
+ *
+ * @param handle
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status msc_format_unit_command
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ msc_scsi_struct_t* scsi_ptr;
+ usb_status error;
+ *csw_residue_ptr = 0;
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+
+ /* initialize sense code values */
+ scsi_ptr->request_sense.sense_key = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code_qual = NO_SENSE;
+
+ scsi_ptr->thirteen_case.handle = msc_obj_ptr->controller_handle;
+ scsi_ptr->thirteen_case.host_expected_data_len = cbw_ptr->data_length;
+ scsi_ptr->thirteen_case.host_expected_direction =
+ (uint8_t)(cbw_ptr->flag >> USB_CBW_DIRECTION_SHIFT);
+ scsi_ptr->thirteen_case.device_expected_data_len = 0;
+ scsi_ptr->thirteen_case.device_expected_direction = USB_SEND;
+ scsi_ptr->thirteen_case.csw_status_ptr = csw_status_ptr;
+ scsi_ptr->thirteen_case.csw_residue_ptr = csw_residue_ptr;
+ scsi_ptr->thirteen_case.buffer_ptr = NULL;
+ scsi_ptr->thirteen_case.lba_txrx_select = FALSE;
+
+ error = msc_thirteen_cases_check(msc_obj_ptr, &scsi_ptr->thirteen_case);
+
+ if(*csw_status_ptr != PHASE_ERROR)
+ {
+ /* FmtData = 1, CmpList = 0, Defect List Format = 7 */
+ if((cbw_ptr->command_block[1] & 0x1F) == 0x17)
+ {
+ *csw_status_ptr = COMMAND_PASSED;
+ }
+ else
+ {
+ *csw_status_ptr = COMMAND_FAILED;
+ scsi_ptr->request_sense.sense_key = ILLEGAL_REQUEST;
+ scsi_ptr->request_sense.add_sense_code = INVALID_FIELD_IN_COMMAND_PKT;
+ }
+ }
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name msc_prevent_allow_medium_removal
+ *
+ * @brief command tells the UFI device to enable or disable the removal of the
+ * medium in the logical unit.
+ *
+ * @param handle
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status msc_prevent_allow_medium_removal
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ msc_scsi_struct_t* scsi_ptr;
+ usb_status error;
+ uint8_t prevent_removal = 0;
+ /* masking to obtain value of last bit */
+ prevent_removal = (uint8_t)(cbw_ptr->command_block[4] &
+ PREVENT_ALLOW_REMOVAL_MASK);
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+ /* initialize sense code values */
+ scsi_ptr->request_sense.sense_key = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code_qual = NO_SENSE;
+
+ scsi_ptr->thirteen_case.handle = msc_obj_ptr->controller_handle;
+ scsi_ptr->thirteen_case.host_expected_data_len = cbw_ptr->data_length;
+ scsi_ptr->thirteen_case.host_expected_direction =
+ (uint8_t)(cbw_ptr->flag >> USB_CBW_DIRECTION_SHIFT);
+ scsi_ptr->thirteen_case.device_expected_data_len = 0;
+ scsi_ptr->thirteen_case.device_expected_direction = USB_SEND;
+ scsi_ptr->thirteen_case.csw_status_ptr = csw_status_ptr;
+ scsi_ptr->thirteen_case.csw_residue_ptr = csw_residue_ptr;
+ scsi_ptr->thirteen_case.buffer_ptr = NULL;
+ scsi_ptr->thirteen_case.lba_txrx_select = FALSE;
+
+ error = msc_thirteen_cases_check(msc_obj_ptr, &scsi_ptr->thirteen_case);
+
+ if(*csw_status_ptr != PHASE_ERROR)
+ {
+ if((!SUPPORT_DISK_LOCKING_MECHANISM)&&(prevent_removal))
+ {/*there is no support for disk locking and removal of medium is disabled*/
+ scsi_ptr->request_sense.sense_key = ILLEGAL_REQUEST;
+ scsi_ptr->request_sense.add_sense_code = INVALID_FIELD_IN_COMMAND_PKT;
+ *csw_status_ptr = COMMAND_FAILED;
+ }
+ }
+
+ if(scsi_ptr->scsi_callback.callback != NULL)
+ {
+ scsi_ptr->scsi_callback.callback(USB_MSC_DEVICE_REMOVAL_REQUEST,
+ USB_REQ_VAL_INVALID,NULL,(uint32_t *)&prevent_removal, scsi_ptr->scsi_callback.arg);
+ }
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name msc_send_diagnostic_command
+ *
+ * @brief requests the device to perform self test
+ *
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status msc_send_diagnostic_command
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ msc_scsi_struct_t* scsi_ptr;
+ /* No Self Test Procedure available */
+ usb_status error;
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+
+ /* initialize sense code values */
+ scsi_ptr->request_sense.sense_key = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code_qual = NO_SENSE;
+
+ scsi_ptr->thirteen_case.handle = msc_obj_ptr->controller_handle;
+ scsi_ptr->thirteen_case.host_expected_data_len = cbw_ptr->data_length;
+ scsi_ptr->thirteen_case.host_expected_direction =
+ (uint8_t)(cbw_ptr->flag >> USB_CBW_DIRECTION_SHIFT);
+ scsi_ptr->thirteen_case.device_expected_data_len = 0;
+ scsi_ptr->thirteen_case.device_expected_direction = USB_SEND;
+ scsi_ptr->thirteen_case.csw_status_ptr = csw_status_ptr;
+ scsi_ptr->thirteen_case.csw_residue_ptr = csw_residue_ptr;
+ scsi_ptr->thirteen_case.buffer_ptr = NULL;
+ scsi_ptr->thirteen_case.lba_txrx_select = FALSE;
+
+ error = msc_thirteen_cases_check(msc_obj_ptr, &scsi_ptr->thirteen_case);
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name msc_start_stop_unit_command
+ *
+ * @brief command instructs device to enable or disable media access operations
+ *
+ * @param msc_obj_ptr:
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status msc_start_stop_unit_command
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ msc_scsi_struct_t* scsi_ptr;
+ usb_status error;
+ uint8_t load_eject_start;
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+
+ /* masking to obtain value of last bit */
+ load_eject_start = (uint8_t)(cbw_ptr->command_block[4] &
+ LOAD_EJECT_START_MASK);
+ /* initialize sense code values */
+ scsi_ptr->request_sense.sense_key = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code = NO_SENSE;
+ scsi_ptr->request_sense.add_sense_code_qual = NO_SENSE;
+
+ scsi_ptr->thirteen_case.handle = msc_obj_ptr->controller_handle;
+ scsi_ptr->thirteen_case.host_expected_data_len = cbw_ptr->data_length;
+ scsi_ptr->thirteen_case.host_expected_direction =
+ (uint8_t)(cbw_ptr->flag >> USB_CBW_DIRECTION_SHIFT);
+ scsi_ptr->thirteen_case.device_expected_data_len = 0;
+ scsi_ptr->thirteen_case.device_expected_direction = USB_SEND;
+ scsi_ptr->thirteen_case.csw_status_ptr = csw_status_ptr;
+ scsi_ptr->thirteen_case.csw_residue_ptr = csw_residue_ptr;
+ scsi_ptr->thirteen_case.buffer_ptr = NULL;
+ scsi_ptr->thirteen_case.lba_txrx_select = FALSE;
+
+ error = msc_thirteen_cases_check(msc_obj_ptr, &scsi_ptr->thirteen_case);
+
+ if(*csw_status_ptr != PHASE_ERROR)
+ {
+ if(scsi_ptr->scsi_callback.callback != NULL)
+ {
+ scsi_ptr->scsi_callback.callback(USB_MSC_START_STOP_EJECT_MEDIA,
+ USB_REQ_VAL_INVALID,NULL,(uint32_t *)&load_eject_start, scsi_ptr->scsi_callback.arg);
+ }
+ }
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name msc_unsupported_command
+ *
+ * @brief Responds appropriately to unsupported commands
+ *
+ * @param msc_obj_ptr
+ * @param cbw_ptr : pointer to Command Block Wrapper sent by host
+ * @param csw_residue_ptr: pointer to dCSWDataResidue of Command Status Wrapper
+ * @param csw_status_ptr : pointer to bCSWStatus of Command Status Wrapper
+ *
+ * @return error
+ *
+ *****************************************************************************/
+usb_status msc_unsupported_command
+(
+msc_device_struct_t * msc_obj_ptr,
+cbw_t * cbw_ptr,
+uint32_t* csw_residue_ptr,
+uint8_t* csw_status_ptr
+)
+{
+ msc_scsi_struct_t* scsi_ptr;
+
+ //UNUSED_ARGUMENT(cbw_ptr)
+
+ scsi_ptr = (msc_scsi_struct_t*)msc_obj_ptr->scsi_object_ptr;
+
+ *csw_residue_ptr = 0;
+ *csw_status_ptr = COMMAND_FAILED;
+
+ scsi_ptr->request_sense.sense_key = ILLEGAL_REQUEST;
+ scsi_ptr->request_sense.add_sense_code = INVALID_COMMAND_OPCODE;
+ scsi_ptr->request_sense.add_sense_code_qual = NO_SENSE;
+
+ return USB_OK;
+}
+#endif /*MSD_CONFIG*/
+/* EOF */
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc_scsi.h b/KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc_scsi.h
new file mode 100644
index 0000000..640aa33
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/classes/msd/usb_msc_scsi.h
@@ -0,0 +1,309 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2008, 2013 - 2014 Freescale Semiconductor;
+* All Rights Reserved
+*
+* Copyright (c) 1989-2008 ARC International;
+* All Rights Reserved
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: usb_msc_scsi.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+* @brief The file contains USB Mass Storage SCSI layer api header function
+*
+*****************************************************************************/
+
+#ifndef _USB_MSC_SCSI_H
+#define _USB_MSC_SCSI_H 1
+
+/******************************************************************************
+ * Includes
+ *****************************************************************************/
+ #include "usb_msc.h"
+/******************************************************************************
+ * Constants - None
+ *****************************************************************************/
+
+
+/******************************************************************************
+ * Macro's
+ *****************************************************************************/
+ /* macros for SENSE KEY Codes*/
+#define NO_SENSE (0x00)
+#define RECOVERED_ERROR (0x01)
+#define NOT_READY (0x02)
+#define MEDIUM_ERROR (0x03)
+#define HARDWARE_ERROR (0x04)
+#define ILLEGAL_REQUEST (0x05)
+#define UNIT_ATTENTION (0x06)
+#define DATA_PROTECT (0x07)
+#define BLANK_CHECK (0x08)
+#define VENDOR_SPECIFIC_ERROR (0x09)
+#define ABORTED_COMMAND (0x0B)
+#define VOLUME_OVERFLOW (0x0D)
+#define MISCOMPARE (0x0E)
+
+/* macros for ADDITIONAL SENSE Codes*/
+#define INVALID_COMMAND_OPCODE (0x20)
+#define WRITE_FAULT (0x03)
+#define UNRECOVERED_READ_ERROR (0x11)
+#define UNKNOWN_ERROR (0xFF)
+#define INVALID_FIELD_IN_COMMAND_PKT (0x24)
+#define LBA_OUT_OF_RANGE (0x21)
+
+/* other macros */
+#define REQ_SENSE_VALID_ERROR_CODE (0x70)
+#define REQ_SENSE_ADDITIONAL_SENSE_LEN (0x0A)
+#define PREVENT_ALLOW_REMOVAL_MASK (0x01)
+#define LOAD_EJECT_START_MASK (0x03)
+#define FORMATTED_MEDIA (0x02)
+#define UNFORMATTED_MEDIA (0x01)
+#define NO_CARTRIDGE_IN_DRIVE (0x03)
+
+#define INQUIRY_ALLOCATION_LENGTH (0x24)
+#define REQ_SENSE_DATA_LENGTH (18)
+#define READ_CAPACITY_DATA_LENGTH (0x08)
+#define READ_CAPACITY16_DATA_LENGTH (0x0C)
+
+#define PERIPHERAL_QUALIFIER (0)
+#define PERIPHERAL_QUALIFIER_SHIFT (5)
+#define SPC_VERSION (4)/*SPC3 is 5; SPC2 is 4*/
+#define PERIPHERAL_DEVICE_TYPE (0x00)
+#define REMOVABLE_MEDIUM_BIT (1)
+#define REMOVABLE_MEDIUM_BIT_SHIFT (7)
+#define ADDITIONAL_LENGTH (0x20)
+#define SUPPORT_DISK_LOCKING_MECHANISM (0) /*1: TRUE; 0:FALSE*/
+
+#define BULK_OUT_ENDPOINT msc_obj_ptr->bulk_out_endpoint
+
+/* Forward Declaration */
+/******************************************************************************
+ * Types
+ *****************************************************************************/
+/**** COMMAND STRUCTURES ******/
+typedef struct _inquiry_command
+{
+ uint8_t opcode; /* operation code : 0x12H*/
+ uint8_t lun_evpd; /* Logical Unit Number: bits 7-5, EVPD: bit 0 */
+ uint8_t page_code;
+ uint8_t reserved1; /* 1 bytes are reserved */
+ uint8_t alloc_length; /* allocation length : 0x24H*/
+ uint8_t reserved2[7];/* reserved and pad bits */
+}inquiry_command_struct_t, * PTR_INQUIRY_COMMAND_STRUCT;
+
+typedef struct _request_sense_command
+{
+ uint8_t opcode; /* operation code : 0x03H*/
+ uint8_t lun; /* Logical Unit Number: bits 7-5, rest reserved */
+ uint8_t reserved1[2]; /* 2 bytes are reserved */
+ uint8_t alloc_length; /* specs say it to be 252 bytes,
+ but windows request only 18 bytes*/
+ uint8_t reserved2[7];/* reserved and pad bits */
+}request_sense_command_struct_t;
+
+typedef struct _read_format_capacity_command
+{
+ uint8_t opcode; /* operation code : 0x23H*/
+ uint8_t lun; /* LUN : bits 7-5*/
+ uint8_t reserved1[5];
+ uint16_t alloc_len; /*Allocation length (MSB) :byte 7;
+ Allocation length (LSB) :byte 8*/
+ uint8_t reserved2[3];
+}read_format_capacity_command_struct_t;
+
+typedef struct _read_capacity_command
+{
+ uint8_t opcode; /* operation code : 0x25H*/
+ uint8_t lun_adr; /* LUN : bits 7-5, RelAdr : bit 0*/
+ uint32_t lba; /* Logical Block Address : 4 bytes */
+ uint8_t reserved1[2]; /* 2 bytes are reserved */
+ uint8_t pmi; /* always set to zero for UFI devices */
+ uint8_t reserved2[3];/* 3 bytes are reserved */
+} read_capacity_command_struct_t;
+
+typedef struct _read_write_10_command
+{
+ uint8_t opcode; /* operation code : 0x28H(read), 0x2A(write)*/
+ uint8_t lun_dpo_fua_adr;/*LUN:bits7-5, DPO:bit4, FUA:bit3, RelAdr:bit0*/
+ uint32_t lba;
+ uint8_t reserved1;
+ uint8_t transfer_length_msb;
+ uint8_t transfer_length_lsb;
+ uint8_t reserved2[3];
+}read_write_10_command_struct_t;
+
+
+/******* COMMAND RESPONSE DATA STRUCTURES */
+typedef struct _inquiry_data /* 36 bytes structure */
+{
+ uint8_t peripheral;/*Bits 7..5: PERIPHERAL QUALIFIER (000 = a device is
+ connected to this logical unit)
+ Bits 4..0: PERIPHERAL DEVICE TYPE (PDT) */
+ uint8_t rmb;/*Bit 7: RMB (0 = non-removable media; 1 = removable media)
+ Bits 6..0: reserved */
+ uint8_t version;/*VERSION of SPC standard (5 = SPC-3; 4 = SPC-2) */
+ uint8_t response_data_format;/*Bits 7..6: obsolete
+ Bit 5: NORMACA (normal ACA bit support)
+ Bit 4: HISUP(hierarchical addressing support)
+ Bits 3..0: response data format (must = 2) */
+ uint8_t additional_length;/*the number of additional bytes in the response).
+ Equal to (response length - 4). Set to 20h if
+ returning 36 (24h) bytes. */
+ uint8_t sccs;/*Bit 7: SCCS (0 = no embedded storage array controller
+ component present)
+ Bit 6: ACC (0 = no access controls coordinator present)
+ Bits 5..4: TPGS (0 = no support or vendor-specific support
+ for asymmetric logical unit access)
+ Bit 3: 3PC ((0 = no support for third-party copy commands)
+ Bits 2..1: reserved
+ Bit 0: PROTECT (0 = no support for protection information)*/
+ uint8_t bque;/*Bit 7: BQUE (0 = no support for basic task management)
+ Bit 6: ENCSERV (0=no support for embedded enclosure services)
+ Bit 5: VS (vendor specific)
+ Bit 4: MULTIP (0 = device has a single port)
+ Bit 3: MCHNGR (0 = no support for media changer)
+ Bits 2..1: obsolete
+ Bit 0: ADDR16 (not used with USB interface) */
+ uint8_t wbus;/*Bit 7..6: obsolete
+ Bit 5: WBUS16 (not used with USB interface)
+ Bit 4: SYNC (not used with USB interface)
+ Bit 3: LINKED (0 = no support for linked commands)
+ Bit 2: obsolete
+ Bit 1: CMDQUE (0 = no support for full task management)
+ Bit 0: VS (vendor specific)*/
+ uint8_t vendor_info[8]; /*T10 VENDOR IDENTIFICATION, MSB first */
+ uint8_t product_id[16]; /*PRODUCT IDENTIFICATION, MSB first*/
+ uint8_t product_rev_level[4];/*PRODUCT REVISION LEVEL, MSB first*/
+}inquiry_data_struct_t;
+
+typedef struct _request_sense_data /* 18 bytes structure */
+{
+ uint8_t valid_error_code;/*bit 7: VALID. Set to 1 if the INFORMATION field
+ contains valid information.
+ bits 6..0: RESPONSE CODE. Set to 70h for info on
+ current errors. Set to 71h for info on
+ deferred errors (used with commands
+ that use caching).*/
+ uint8_t reserved1; /* obsolete */
+ uint8_t sense_key;/*Bit7: FILEMARK. Used by streaming devices.
+ Bit6: EOM. End of medium. Used by streaming devices.
+ Bit5: ILI: Incorrect length indicator. Used with READ
+ LONG, WRITE LONG, and stream READ commands.
+ Bit4: Reserved
+ Bits3:0: SENSE KEY. Contains info describing the error*/
+ uint8_t information[4];/*Device-specific or command-specific info*/
+ uint8_t add_sense_len;/*number of additional sense bytes that follow this
+ field. Maximum is 244*/
+ uint8_t command_specific_info[4];
+ uint8_t add_sense_code;/*Provides additional information about the
+ error. Set to zero if unused */
+ uint8_t add_sense_code_qual;/*Provides additional info related to additional
+ sense code. Set to zero if unused */
+ uint8_t field_rep_uint_code;/*Identifies a failed component. Set to zero if
+ there is no component to identify */
+ uint8_t sense_key_specific[3];/*If byte 15, bit7(SKSV) equals 1,remainder of
+ the field contains SENSE KEY SPECIFIC info*/
+}request_sense_data_struct_t;
+
+typedef struct _read_capacity_data /* 8 bytes structure */
+{
+ uint32_t last_logical_block_address;/*last LBA number*/
+ uint32_t block_size; /* in bytes */
+}read_capacity_data_struct_t;
+
+typedef struct _read_capacity16_data /* 8 bytes structure */
+{
+ uint32_t last_logical_block_address0;/*last LBA number*/
+ uint32_t last_logical_block_address1;/*last LBA number*/
+ uint32_t block_size; /* in bytes */
+}read_capacity16_data_struct_t;
+
+typedef struct _capacity_list_header
+{
+ uint8_t reserved1[3];
+ uint8_t capacity_list_len;/*specifies the length in bytes of the Capacity
+ Descriptor that follow. Each capacity descriptor
+ is eight bytes in length, making the capacity
+ list length equal to eight times the number of
+ descriptors */
+}capacity_list_header_struct_t;
+
+typedef struct _curr_max_capacity_desc
+{
+ uint32_t num_blocks; /*byte 0-3 = total number of addressable blocks for the
+ descriptor's media type */
+ uint32_t desc_code_and_block_len;
+ /*byte 4: specifies the type of descriptor returned to host :
+ 01b : unformattable media - max formattable capacity for this cartridge
+ 10b : formatted media - current media capacity
+ 11b : no cartridge in drive - max formattable capacity for any cartridge*/
+ /* byte 5-7 : specifies the length in bytes of each logical block
+ Note: byte 5 holds most significant byteS*/
+}curr_max_capacity_desc_struct_t;
+
+typedef struct _formattable_cap_desc
+{
+ uint32_t num_blocks;/*byte 0-3 : fields indicates the number of addressable
+ blocks for the given capacity descriptor*/
+ uint32_t block_len;/*byte 4 : reserved;
+ byte5-7: specifies the length in bytes of each logical block for the given
+ capacity descriptor */
+}formattable_cap_desc_t;
+
+typedef struct _mode_parameter_header
+{
+ uint16_t mode_data_len;/*for MODE SELECT command, the mode data length field
+ should always be set to zero.
+ for MODE SENSE command, the mode data length field
+ specifies the length in bytes of the following data
+ that is available to be transfered(not including
+ itself)*/
+ uint8_t medium_type_code;/*specifies the inserted medium type. The value in
+ this field are vendor specific.
+ default value should be 0x00*/
+ uint8_t wp_dpofua;/* bit7:wp:write protect(ignored for mode select command)
+ bit4:dpofua; rest of the bits are reserved */
+ uint8_t reserved1[4];
+}mode_parameter_header_struct_t;
+
+typedef struct _msc_scsi_variable_struct
+{
+ /* disk space reserved . This Disk Space is reserved by the App.*/
+ uint32_t total_logical_add_block;
+ uint32_t length_of_each_lab;
+ uint32_t implementing_disk_drive;
+ /* structure to store request sense data for every
+ command received by device */
+ request_sense_data_struct_t request_sense;
+ /* flag to track if the msd device is formatted or not */
+ msc_thirteen_case_struct_t thirteen_case;
+ usb_class_specific_callback_struct_t scsi_callback;
+ read_capacity_data_struct_t read_capacity;
+ read_capacity16_data_struct_t read_capacity16;
+ uint8_t format_capacity_response_data[sizeof(capacity_list_header_struct_t) + sizeof(curr_max_capacity_desc_struct_t) + sizeof(formattable_cap_desc_t) * 3];
+ bool formatted_disk;
+ uint8_t is_used;
+}msc_scsi_struct_t;
+
+#endif
+
+/* EOF */
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/device_khci_interface.c b/KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/device_khci_interface.c
new file mode 100644
index 0000000..6cadcfa
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/device_khci_interface.c
@@ -0,0 +1,75 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2009, 2013 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: khci_interface.c$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ *
+ *END************************************************************************/
+#include "usb_device_config.h"
+#if USBCFG_DEV_KHCI
+//#include "types.h"
+#include "adapter.h"
+#include "adapter_cfg.h"
+#include "usb_types.h" //USB error definitions
+#include "compiler.h"
+#include "usb_desc.h" //USB descriptor macros
+#include "usb_misc.h"
+#include "adapter_types.h"
+#include "khci_dev.h"
+#include "usb_device_stack_interface.h"
+#include "usb_dev.h"
+#if defined(__cplusplus)
+extern const usb_dev_interface_functions_struct_t _usb_khci_dev_function_table =
+#else
+const usb_dev_interface_functions_struct_t _usb_khci_dev_function_table =
+#endif
+{
+ usb_dci_khci_preinit,
+ usb_dci_khci_init,
+ usb_dci_khci_postinit,
+ usb_dci_khci_send,
+ usb_dci_khci_recv,
+#if USBCFG_DEV_ADVANCED_CANCEL_ENABLE
+ usb_dci_khci_cancel,
+#endif
+ usb_dci_khci_init_endpoint,
+ usb_dci_khci_deinit_endpoint,
+ usb_dci_khci_unstall_endpoint,
+ usb_dci_khci_get_endpoint_status,
+ usb_dci_khci_set_endpoint_status,
+ NULL,
+ usb_dci_khci_set_addr,
+ usb_dci_khci_shutdown,
+ NULL,
+#if USBCFG_DEV_ADVANCED_SUSPEND_RESUME
+ usb_dci_khci_assert_resume,
+#endif
+ usb_dci_khci_stall_endpoint,
+ usb_dci_khci_set_status,
+ usb_dci_khci_get_status,
+ usb_dci_khci_get_xd,
+ usb_dci_khci_reset,
+};
+#endif
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/khci_dev.c b/KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/khci_dev.c
new file mode 100644
index 0000000..fccd87f
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/khci_dev.c
@@ -0,0 +1,2339 @@
+/**HEADER**********************************************************************
+ *
+ * Copyright (c) 2009, 2013 - 2015 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ *******************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: khci_dev.c$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ * This file contains the main usbfs USB Device Controller interface
+ * functions.
+ *
+ *END************************************************************************/
+
+/******************************************************************************
+ * BUFFER DISCRIPTOR TABLE (BDT) DISCRIPTION *
+ ******************************************************************************/
+/**
+ * The USB-FS implements a Buffer Descriptor Table (BDT) in system memory. The
+ * BDT resides on a 512 byte boundary in system memory and is pointed to by the
+ * BDT Page Registers. Every endpoint direction requires two eight-byte Buffer
+ * Descriptor entries.Therefore, a system with 16 fully bidirectional endpoints
+ * would require 512 bytes of system memory to implement the BDT.The two Buffer
+ * Descriptor (BD) entries allows for an EVEN BD and ODD BD entry for each
+ * endpoint direction. This allows the microprocessor to process one BD while
+ * the USB-FS is processing the other BD. Double buffering BDs in this way
+ * allows the USB-FS to easily transfer data at the maximum throughput provided
+ * by USB.
+ *
+ * Because the buffers are shared between the microprocessor and the USB-FS a
+ * simple semaphore mechanism is used to distinguish who is allowed to update
+ * the BDT and buffers in system memory. A semaphore bit, the OWN bit, is
+ * cleared to 0 when the BD entry is owned by the microprocessor. The
+ * microprocessor is allowed read and write access to the BD entry and the
+ * buffer in system memory when the OWN bit is 0.
+ * When the OWN bit is set to 1, the BD entry and the buffer in system memory
+ * are owned by the USB-FS. The USB-FS now has full read and write access and
+ * the microprocessor should not modify the BD or its corresponding data buffer.
+ * The BD also contains indirect address pointers to where the actual buffer
+ * resides in system memory.
+ ******************************************************************************
+ * BUFFER DISCRIPTOR FORMAT DISCRIPTION
+ ******************************************************************************
+ * The Buffer Descriptors have different meaning based on who is reading the BD
+ * in memory.The USB-FS Controller uses the data stored in BDs to determine:
+ *
+ * # Who owns the buffer in system memory
+ * # Data0 or Data1 PID
+ * # Release Own upon packet completion
+ * # No address increment (FIFO Mode)
+ * # Data toggle synchronization enable
+ * # How much data is to be transmitted or received
+ * # Where the buffer resides in system memory
+ *
+ * While the microprocessor uses the data stored in the BDs to determine:
+ * # Who owns the buffer in system memory
+ * # Data0 or Data1 PID
+ * # The received TOKEN PID
+ * # How much data was transmitted or received
+ * # Where the buffer resides in system memory
+ *
+ * ------ ------ ------ ------ -------- ---------- ---------- ---------- ---------- ---------- ----------
+ * |31-26 |25-16 | 15-8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
+ * |RSVD | BC | RSVD | OWN |DATA0/1 |TOK_PID[3]|TOK_PID[2]|TOK_PID[1]|TOK_PID[0]|TOK_PID[n]| reserved |
+ * ------ ------ ------ ------ -------- ---------- ---------- ---------- ---------- ---------- ----------
+ * | ADDRESS[31--0] |
+ * | |
+ * -------------------------------------------------------------------------------------------------------
+ *
+ * This Buffer Descriptor table is represented by the variable "BDT_BASE"
+ * defined in file usbfs_dev_main.h. Macros such as "BD_ADDR_RX" and
+ * "BD_ADDR_TX" is used to manipulate the address field and Macros such as
+ * BD_CTRL_RX and BD_CTRL_TX is used to manipulate the control fields.
+ */
+
+/******************************************************************************
+ * Includes
+ *****************************************************************************/
+#include "usb_device_config.h"
+#if USBCFG_DEV_KHCI
+#include "usb.h"
+#include "usb_device_stack_interface.h"
+#include "khci_dev.h"
+#include "khci_dev_misc.h"
+#include "fsl_usb_khci_hal.h"
+#ifdef USBCFG_OTG
+#include "usb_otg_main.h"
+#include "usb_otg_private.h"
+#endif
+
+/****************************************************************************
+ * Global Variables
+ ****************************************************************************/
+static uint8_t *bdt;
+
+#if (FSL_FEATURE_USB_KHCI_USB_RAM == 0)
+#if ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM) || (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK))
+#if defined( __ICCARM__ )
+ #pragma data_alignment=512
+ __no_init uint8_t g_khci_bdt_buffer[512];
+#elif defined (__CC_ARM) || defined(__GNUC__)
+ __attribute__((aligned(512))) uint8_t g_khci_bdt_buffer[512];
+#else
+ #error Unsupported compiler, please use IAR, Keil or arm gcc compiler and rebuild the project.
+#endif
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ uint8_t* g_khci_bdt_ptr = NULL;
+#endif
+#endif
+
+#if ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM) || (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK))
+ static usb_device_khci_data_t g_khci_data;
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ usb_device_khci_data_t* g_khci_data_ptr = NULL;
+#endif
+
+static bool g_zero_pkt_send = FALSE;
+
+static usb_khci_dev_state_struct_t g_khci_dev[USBCFG_DEV_KHCI_NUM];
+
+#if USBCFG_KHCI_4BYTE_ALIGN_FIX
+static uint8_t *_usb_khci_dev_swap_buf_ptr = NULL;
+#endif
+
+extern usb_status _usb_device_call_service(uint8_t type, usb_event_struct_t* event);
+extern uint32_t soc_get_usb_base_address(uint8_t controller_id);
+
+#ifdef USBCFG_OTG
+extern usb_otg_handle * g_usb_otg_handle;
+#endif
+extern uint8_t soc_get_usb_vector_number(uint8_t controller_id);
+#if USBCFG_DEV_DETACH_ENABLE
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_dci_khci_detach
+ * Returned Value : void
+ * Comments :
+ * this function is called if device known it's detached.
+ *
+ *END*-----------------------------------------------------------------*/
+void usb_dci_khci_detach(void)
+{
+ usb_event_struct_t event;
+ usb_khci_dev_state_struct_t* state_ptr;
+ state_ptr = (usb_khci_dev_state_struct_t*)(&g_khci_dev[0]);
+
+ /* Initialize the event structure to be passed to the upper layer*/
+ event.handle = (usb_device_handle)state_ptr->upper_layer_handle;
+ event.ep_num = 0;
+ event.setup = 0;
+ event.direction = 0;
+
+ /* propagate control to upper layers for processing */
+ _usb_device_call_service(USB_SERVICE_DETACH, &event);
+}
+#endif
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_dci_khci_free_xd
+ * Returned Value : void
+ * Comments :
+ * Enqueues a XD onto the free XD ring.
+ *
+ *END*-----------------------------------------------------------------*/
+void usb_dci_khci_free_xd
+(
+ usb_device_handle handle,
+ /* [IN] the dTD to enqueue */
+ xd_struct_t* xd_ptr
+)
+{ /* Body */
+ usb_khci_dev_state_struct_t* usb_dev_ptr = (usb_khci_dev_state_struct_t*)handle;
+
+ /*
+ ** This function can be called from any context, and it needs mutual
+ ** exclusion with itself.
+ */
+ OS_Lock();
+
+ /*
+ ** Add the XD to the free XD queue (linked via PRIVATE) and
+ ** increment the tail to the next descriptor
+ */
+ if (usb_dev_ptr->xd_head == NULL)
+ {
+ usb_dev_ptr->xd_head = xd_ptr;
+ }
+ else
+ {
+ usb_dev_ptr->xd_tail->next = xd_ptr;
+ }
+ usb_dev_ptr->xd_tail = xd_ptr;
+ xd_ptr->next = NULL;
+ usb_dev_ptr->xd_entries++;
+
+ OS_Unlock();
+} /* Endbody */
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_dci_khci_get_xd
+ * Returned Value : void
+ * Comments :
+ * get an XD from the free XD ring.
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_dci_khci_get_xd
+(
+ usb_device_handle handle,
+ /* [IN] the dTD to enqueue */
+ xd_struct_t** xd_ptr_ptr
+)
+{ /* Body */
+ usb_khci_dev_state_struct_t* usb_dev_ptr = (usb_khci_dev_state_struct_t*)handle;
+
+ /* This function can be called from any context, and it needs mutual
+ exclusion with itself.*/
+ OS_Lock();
+
+ /* Get a transfer descriptor for the specified endpoint
+ ** and direction
+ */
+ if (!usb_dev_ptr->xd_entries)
+ {
+ OS_Unlock();
+ return USBERR_DEVICE_BUSY;
+ }
+
+ *xd_ptr_ptr = usb_dev_ptr->xd_head;
+ if (usb_dev_ptr->xd_head)
+ {
+ usb_dev_ptr->xd_head = usb_dev_ptr->xd_head->next;
+ if (usb_dev_ptr->xd_head == NULL)
+ {
+ usb_dev_ptr->xd_tail = NULL;
+ }
+ }
+ usb_dev_ptr->xd_entries--;
+ OS_Unlock();
+
+ return USB_OK;
+} /* Endbody */
+
+/**************************************************************************//*!
+ *
+ * @name : usb_dci_khci_init_xd
+ * @brief : initialize the xd.
+ * @param handle: Handle to USB Device to be filled
+ * @return USB_OK on successful.
+ ******************************************************************************/
+usb_status usb_dci_khci_init_xd
+(
+ /* [IN] the USB device handle */
+ usb_device_handle handle
+)
+{
+ usb_khci_dev_state_struct_t* usb_dev_ptr = (usb_khci_dev_state_struct_t*)handle;
+ xd_struct_t* xd_ptr;
+ uint32_t j;
+
+#if ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM) || (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK))
+ usb_dev_ptr->setup_buff = (uint8_t *)(&g_khci_data.setup_packet);
+ usb_dev_ptr->xd_head = usb_dev_ptr->xd_base = (xd_struct_t*)(&g_khci_data.xd_base);
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ usb_dev_ptr->setup_buff = (uint8_t *) g_khci_data_ptr->setup_packet;
+ usb_dev_ptr->xd_head = usb_dev_ptr->xd_base = (xd_struct_t*) g_khci_data_ptr->xd_base;
+#endif
+#if FSL_FEATURE_USB_KHCI_USB_RAM
+ usb_dev_ptr->setup_buff = (uint8_t *)(usb_hal_khci_get_usbram_add(usb_dev_ptr->usbRegBase) + 480);
+#endif
+ usb_dev_ptr->xd_entries = USBCFG_DEV_MAX_XDS;
+
+ /* Enqueue all the XDs */
+ xd_ptr = (xd_struct_t*)usb_dev_ptr->xd_base;
+
+ for (j = 0; j < USBCFG_DEV_MAX_XDS - 1; j++)
+ {
+ xd_ptr->next = xd_ptr + 1;
+ //usb_dci_khci_free_xd(usb_dev_ptr, xd_ptr);
+ xd_ptr++;
+ }
+ xd_ptr->next = 0;
+ usb_dev_ptr->xd_tail = xd_ptr;
+
+ return USB_OK;
+}
+
+/*****************************************************************************
+ * Local Functions
+ *****************************************************************************/
+/*****************************************************************************
+ * Local Functions
+ *****************************************************************************/
+
+/******************************************************************************
+ *
+ * @name _usb_khci_next_setup_token_prep
+ *
+ * @brief The function prepares for next setup token
+ *
+ * @param state_ptr: Device info Structure.
+ *
+ * @return NONE
+ *****************************************************************************/
+static void _usb_khci_next_setup_token_prep
+(
+ usb_khci_dev_state_struct_t* state_ptr
+)
+{
+ xd_struct_t* xd_ptr_temp;
+ usb_dci_khci_get_xd(state_ptr, &xd_ptr_temp);
+ /* prepare XD queue for RECV CONTROL ENDPOINT*/
+ if (state_ptr->ep_info[USB_CONTROL_ENDPOINT].rx_buf_odd == 0x0)
+ {
+ //BD_ADDR_RX(USB_CONTROL_ENDPOINT, state_ptr->ep_info[USB_CONTROL_ENDPOINT].rx_buf_odd) =
+ // USB_LONG_LE_TO_HOST((uint32_t)state_ptr->setup_buff);
+ usb_hal_khci_bdt_set_address((uint32_t )bdt, USB_CONTROL_ENDPOINT, USB_RECV, 0, (uint32_t )state_ptr->setup_buff);
+ xd_ptr_temp->wstartaddress = state_ptr->setup_buff;
+ }
+ else
+ {
+ //BD_ADDR_RX(USB_CONTROL_ENDPOINT, state_ptr->ep_info[USB_CONTROL_ENDPOINT].rx_buf_odd) =
+ // USB_LONG_LE_TO_HOST((uint32_t)state_ptr->setup_buff+ SETUP_PACKET_LENGTH);
+ usb_hal_khci_bdt_set_address((uint32_t )bdt, USB_CONTROL_ENDPOINT, USB_RECV, 1, (uint32_t)(state_ptr->setup_buff+SETUP_PACKET_LENGTH));
+ xd_ptr_temp->wstartaddress = state_ptr->setup_buff + SETUP_PACKET_LENGTH;
+ }
+ xd_ptr_temp->ep_num = USB_CONTROL_ENDPOINT;
+ xd_ptr_temp->bdirection = USB_RECV;
+ xd_ptr_temp->wtotallength = ZERO_LENGTH;
+ xd_ptr_temp->ep_type = USB_CONTROL_PIPE;
+#if USBCFG_KHCI_4BYTE_ALIGN_FIX
+ xd_ptr_temp->internal_dma_align = TRUE;
+#endif
+ //USB_XD_QUEUE_ENQUEUE(&state_ptr->ep_info[USB_CONTROL_ENDPOINT].xd_queue_recv, xd_ptr_temp);
+ state_ptr->ep_info[USB_CONTROL_ENDPOINT].recv_xd = xd_ptr_temp;
+ /* toggle send buffer */
+ //state_ptr->ep_info[USB_CONTROL_ENDPOINT].tx_buf_odd ^= 1;
+ /* configure data pid for setup token and give control to SEI*/
+ state_ptr->ep_info[USB_CONTROL_ENDPOINT].rx_data0 = 0;
+ usb_hal_khci_bdt_set_control((uint32_t )bdt, USB_CONTROL_ENDPOINT, USB_RECV, state_ptr->ep_info[USB_CONTROL_ENDPOINT].rx_buf_odd,
+ USB_LONG_LE_TO_HOST((uint32_t)((uint32_t)USB_BD_BC(SETUP_PACKET_LENGTH)| (uint32_t)USB_BD_OWN | (uint32_t)USB_BD_DTS | (uint32_t)USB_BD_DATA01(state_ptr->ep_info[USB_CONTROL_ENDPOINT].rx_data0))));
+ //BD_CTRL_RX(USB_CONTROL_ENDPOINT, state_ptr->ep_info[USB_CONTROL_ENDPOINT].rx_buf_odd) =
+ //USB_LONG_LE_TO_HOST((uint32_t)(USB_BD_BC(SETUP_PACKET_LENGTH)|
+ // USB_BD_OWN | USB_BD_DTS | USB_BD_DATA01(state_ptr->ep_info[USB_CONTROL_ENDPOINT].rx_data0)));
+ //USB_PRINTF("ready to receive on EP0 setup\n");
+ /* setup token is always on DATA0 PID */
+ return;
+}
+
+/**************************************************************************//*!
+ *
+ * @name _usb_khci_ep_read
+ *
+ * @brief The function reads the endpoint buffers
+ *
+ * @param state_ptr: Device info Structure.
+ * @param ep_num: endpoint number
+ * @param buf_ptr: buffer to receive in
+ * @param buf_num_bytes: number of bytes to read
+ *
+ * @return USB_OK When Successfully
+ *****************************************************************************/
+static usb_status _usb_khci_ep_read
+(
+ /*[IN]*/
+ usb_khci_dev_state_struct_t* state_ptr,
+ /*[IN]*/
+ uint8_t ep_num,
+ /*[OUT]*/
+ uint8_t * buf_ptr,
+ /*[IN]*/
+ uint32_t buf_num_bytes
+)
+{
+ OS_Lock();
+
+ /* USB data is directly transferred to App Buffer to Avoid one level of
+ * memcpy. (i.e from Endpoint buffer to App buffer). So a hack here
+ * is been provided. This hack stores the current endpoint buffer
+ * address to a variable and programs the buffer address in the BDT
+ * as APP buffer. Later when TOKEN_DNE interrupt is received for this Token
+ * this buffer address saved is restored. Please note that at present
+ * App should not release the buffer passed till he gets a notification from
+ * interrupt handler.
+ */
+
+ usb_hal_khci_bdt_set_address((uint32_t )bdt, ep_num, USB_RECV, state_ptr->ep_info[ep_num].rx_buf_odd, (uint32_t )buf_ptr);
+ //BD_ADDR_RX(ep_num, state_ptr->ep_info[ep_num].rx_buf_odd) =
+ // USB_LONG_LE_TO_HOST((uint32_t)buf_ptr);
+
+ /* Program number of bytes to be received and give
+ * the Control to the SEI
+ */
+ usb_hal_khci_bdt_set_control((uint32_t )bdt, ep_num, USB_RECV, state_ptr->ep_info[ep_num].rx_buf_odd,
+ USB_LONG_LE_TO_HOST(USB_BD_BC(buf_num_bytes) | USB_BD_OWN | USB_BD_DTS | USB_BD_DATA01(state_ptr->ep_info[ep_num].rx_data0)));
+ //BD_CTRL_RX(ep_num, state_ptr->ep_info[ep_num].rx_buf_odd) =
+ // USB_LONG_LE_TO_HOST(USB_BD_BC(buf_num_bytes) |
+ // USB_BD_OWN | USB_BD_DTS | USB_BD_DATA01(state_ptr->ep_info[ep_num].rx_data0));
+
+ OS_Unlock();
+
+ usb_hal_khci_clr_token_busy(state_ptr->usbRegBase);
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ *
+ * @name _usb_khci_ep_write
+ *
+ * @brief The function writes the endpoint buffers
+ *
+ * @param state_ptr: Device info Structure.
+ * @param ep_num: endpoint number
+ * @param buf_ptr: buffer to send from
+ * @param buf_num_bytes: number of bytes to write
+ * @param bytes_written_ptr: buffer that will contain Number of bytes written
+ * to device.
+ *
+ * @return USB_OK When Successfully
+ *****************************************************************************/
+static usb_status _usb_khci_ep_write
+(
+ /*[IN]*/
+ usb_khci_dev_state_struct_t* state_ptr,
+ /*[IN]*/
+ uint8_t ep_num,
+ /*[IN]*/
+ uint8_t * buf_ptr,
+ /*[IN]*/
+ uint32_t buf_num_bytes,
+ /*[OUT]*/
+ uint32_t* bytes_written_ptr
+)
+{
+ uint16_t max_packet_size;
+
+ /* If the number of bytes to be sent is greater than the
+ * maximum data that can be sent on the USB bus, then split the
+ * transaction, into multiple transaction.
+ */
+ max_packet_size = state_ptr->ep_info[ep_num].max_packet_size;
+
+ if (buf_num_bytes > max_packet_size)
+ {
+ buf_num_bytes = max_packet_size;
+ }
+
+ *bytes_written_ptr = buf_num_bytes;
+
+ /* Program the endpoint buffer address in BDT
+ * from where DMA will pick the Data to be sent over USB bus.
+ */
+ //BD_ADDR_TX(ep_num, state_ptr->ep_info[ep_num].tx_buf_odd) =
+ // USB_LONG_LE_TO_HOST((uint32_t)buf_ptr);
+ usb_hal_khci_bdt_set_address((uint32_t )bdt, ep_num, USB_SEND, state_ptr->ep_info[ep_num].tx_buf_odd, (uint32_t )buf_ptr);
+ /* Program the number of bytes to be sent in BDT and Give
+ * the ownership to SEI
+ */
+ //BD_CTRL_TX(ep_num, state_ptr->ep_info[ep_num].tx_buf_odd) =
+ // USB_LONG_LE_TO_HOST((uint32_t)(USB_BD_BC(buf_num_bytes) |
+ // USB_BD_OWN | USB_BD_DTS | USB_BD_DATA01(state_ptr->ep_info[ep_num].tx_data0)));
+ usb_hal_khci_bdt_set_control((uint32_t )bdt, ep_num, USB_SEND, state_ptr->ep_info[ep_num].tx_buf_odd,
+ USB_LONG_LE_TO_HOST(USB_BD_BC(buf_num_bytes) | USB_BD_OWN | USB_BD_DTS | USB_BD_DATA01(state_ptr->ep_info[ep_num].tx_data0)));
+
+ usb_hal_khci_clr_token_busy(state_ptr->usbRegBase);
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ *
+ * @name _usb_khci_reset_ep_state
+ *
+ * @brief This Function Resets all the parameters required for End Point
+ * Initialization
+ *
+ * @param state_ptr: Device info Structure.
+ * @return USB_OK When Successfully
+ *****************************************************************************/
+static usb_status _usb_khci_reset_ep_state
+(
+ /*[IN]*/
+ usb_khci_dev_state_struct_t* state_ptr
+)
+{
+ //volatile USB_MemMapPtr usb_ptr;
+ uint32_t ep;
+
+ uint8_t interrupt_enable;
+
+ /* Clear all the error Status register */
+ usb_hal_khci_clr_all_error_interrupts(state_ptr->usbRegBase);
+
+ /*Reset all ODD and Even BDTs to Zero */
+ usb_hal_khci_set_oddrst(state_ptr->usbRegBase);
+
+ /* Initialize the address as zero in the Address register of USB IP*/
+ usb_hal_khci_set_device_addr(state_ptr->usbRegBase, 0);
+
+ for (ep = 0; ep < USBCFG_DEV_MAX_ENDPOINTS; ep++)
+ {
+ /* Clearing all buffer descriptors for both ODD and even
+ * for Both Receive and Transmit direction
+ */
+ usb_hal_khci_bdt_set_control((uint32_t )bdt, ep, USB_RECV, 0, 0);
+ usb_hal_khci_bdt_set_control((uint32_t )bdt, ep, USB_RECV, 1, 0);
+ usb_hal_khci_bdt_set_control((uint32_t )bdt, ep, USB_SEND, 0, 0);
+ usb_hal_khci_bdt_set_control((uint32_t )bdt, ep, USB_SEND, 1, 0);
+ //BD_CTRL_RX(ep, EVEN_BUFF) = 0;
+ //BD_CTRL_RX(ep, ODD_BUFF) = 0;
+
+ //BD_CTRL_TX(ep, EVEN_BUFF) = 0;
+ //BD_CTRL_TX(ep, ODD_BUFF) = 0;
+
+ state_ptr->ep_info[ep].rx_buf_odd = EVEN_BUFF;
+ state_ptr->ep_info[ep].tx_buf_odd = EVEN_BUFF;
+ //state_ptr->ep_info[ep].data_buffer = NULL;
+#if 0
+ if(ep == USB_CONTROL_ENDPOINT)
+ {
+ state_ptr->ep_info[ep].tx_buf_odd = ODD_BUFF;
+ }
+#endif
+ /* Initialize All End Point Control Registers with default value of 0*/
+ usb_hal_khci_endpoint_shut_down(state_ptr->usbRegBase, ep);
+ }
+
+ g_zero_pkt_send = FALSE;
+
+ /* Clear Reset Interrupt */
+ usb_hal_khci_clr_interrupt(state_ptr->usbRegBase, INTR_USBRST);
+
+ usb_hal_khci_clr_oddrst(state_ptr->usbRegBase);
+
+ /* initializing device address to default address
+ * value for USB in Device structure.
+ */
+ state_ptr->device_address = 0;
+
+ /* Set Default state of USB in Device Structure.*/
+ state_ptr->usb_state = USB_STATE_DEFAULT;
+
+ /* Set Default device status */
+ state_ptr->usb_device_status =
+ (USBCFG_DEV_SELF_POWER << (USB_GET_STATUS_ATTRIBUTES_SELF_POWERED_SHIFT)) |
+ (USBCFG_DEV_REMOTE_WAKEUP << (USB_GET_STATUS_ATTRIBUTES_REMOTE_WAKEUP_SHIFT));
+
+ /* Enable All Error Interrupts */
+ usb_hal_khci_enable_all_error_interrupts(state_ptr->usbRegBase);
+
+ interrupt_enable = INTR_USBRST | INTR_SOFTOK | INTR_TOKDNE | INTR_STALL;
+
+ /* Enable All Interrupts except RESUME */
+#if USBCFG_DEV_ADVANCED_SUSPEND_RESUME
+ interrupt_enable |= INTR_SLEEP;
+#endif
+
+#if USBCFG_DEV_KHCI_ADVANCED_ERROR_HANDLING
+ interrupt_enable |= INTR_ERROR;
+#endif
+ usb_hal_khci_enable_interrupts(state_ptr->usbRegBase, interrupt_enable);
+ /* SEI if, has suspended packet transmission resume packet transmission by
+ * clearing TXD_SUSPEND in CTL register.
+ */
+ usb_hal_khci_clr_token_busy(state_ptr->usbRegBase);
+
+ return USB_OK;
+}
+
+#if 0
+/**************************************************************************//*!
+ *
+ * @name _usb_khci_process_transmit_request
+ *
+ * @brief : Service TOKEN DONE Interrupt when there is transmission of packet.
+ *
+ * @param state_ptr: Device Structure Pointer Passed to ISR. The is the
+ * same structure which was passed in function OS_install_isr
+ * During ISR installation.
+ * @param ep_num: endpoint number
+ * @param buffer_ptr:Holds Data that is send to Host.
+ * @return USB_STATUS_TRANSFER_PENDING when there is split transaction or
+ * USB_OK.
+ *****************************************************************************/
+static usb_status _usb_khci_process_transmit_request
+(
+ /*[IN]*/
+ usb_khci_dev_state_struct_t* state_ptr,
+ /*[IN]*/
+ uint8_t ep_num,
+ /*[OUT]*/
+ uint8_t** buffer_ptr
+)
+{
+ xd_struct_t* xd_ptr = state_ptr->ep_info[ep_num].send_xd;
+
+ //USB_XD_QUEUE_GET_HEAD(&state_ptr->ep_info[ep_num].xd_queue_send,&xd_ptr);
+
+ //*buffer_ptr = (uint8_t *) USB_LONG_LE_TO_HOST(BD_ADDR_TX(ep_num,
+ // state_ptr->ep_info[ep_num].tx_buf_odd));
+
+ //*buffer_ptr = (uint8_t *)USB_LONG_LE_TO_HOST(usb_hal_khci_bdt_get_address(usb_dev_ptr->usbRegBase, (uint32_t)bdt, ep_num, USB_SEND, state_ptr->ep_info[ep_num].tx_buf_odd));
+
+ usb_dci_khci_send(state_ptr, xd_ptr);
+
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ *
+ * @name _usb_khci_process_receive_request
+ *
+ * @brief : Service TOKEN DONE Interrupt when there is receive packet scenario.
+ *
+ * @param state_ptr: Device Structure Pointer Passed to ISR. The is the
+ * same structure which was passed in function
+ * OS_install_isr during ISR installation.
+ * @param ep_num: endpoint number
+ * @param stat: status of last transaction.
+ * @param buffer_ptr:buffer holding data received from Host.
+ *
+ * @return USB_STATUS_TRANSFER_PENDING when there is split transaction else
+ * USB_OK
+ *****************************************************************************/
+static usb_status _usb_khci_process_receive_request
+(
+ /*[IN]*/
+ usb_khci_dev_state_struct_t* state_ptr,
+ /*[IN]*/
+ uint8_t ep_num,
+ /*[IN]*/
+ uint8_t stat,
+ /*[OUT]*/
+ uint8_t** buffer_ptr
+)
+{
+ xd_struct_t* xd_ptr = state_ptr->ep_info[ep_num].recv_xd;
+
+ //*buffer_ptr = (uint8_t *) USB_LONG_LE_TO_HOST(BD_ADDR_RX(ep_num,
+ // state_ptr->ep_info[ep_num].rx_buf_odd));
+ //*buffer_ptr = (uint8_t *)USB_LONG_LE_TO_HOST(usb_hal_khci_bdt_get_address(usb_dev_ptr->usbRegBase, (uint32_t)bdt, ep_num, USB_RECV, state_ptr->ep_info[ep_num].rx_buf_odd));
+
+ usb_dci_khci_recv(state_ptr, xd_ptr);
+ return USB_OK;
+}
+#endif
+
+#if USBCFG_DEV_KHCI_ADVANCED_ERROR_HANDLING
+/**************************************************************************//*!
+ *
+ * @name _usb_khci_service_err_intr
+ *
+ * @brief : Service Error Interrupt.
+ *
+ * @param state_ptr: Device Structure Pointer Passed to ISR. The is the
+ * same structure which was passed in function OS_install_isr
+ * During ISR installation.
+ *
+ * @return NONE
+ *****************************************************************************/
+static void _usb_khci_service_err_intr
+(
+ /*[IN]*/
+ usb_khci_dev_state_struct_t* state_ptr
+)
+{
+ uint8_t device_error = 0, stat, ep_num;
+ //volatile USB_MemMapPtr usb_ptr;
+ usb_event_struct_t event;
+
+ stat = usb_hal_khci_get_transfer_status(state_ptr->usbRegBase);
+
+ /* Clear the Error Interrupt */
+ usb_hal_khci_clr_interrupt(state_ptr->usbRegBase, INTR_ERROR);
+
+ /* Get the Endpoint number on which the transaction occurred.
+ * This is (7 - 5) [3:0] bit in STAT register.
+ */
+ ep_num = usb_hal_khci_get_transfer_done_ep_number(state_ptr->usbRegBase);
+
+ /* Read the ERRSTAT register to determine the source of the error
+ * It is Added with ERREN register to find out which of the
+ * Error was enabled and report only the enabled error to the App layer
+ */
+ device_error = (uint8_t)(usb_hal_khci_get_error_interrupt_status(state_ptr->usbRegBase) &
+ usb_hal_khci_get_error_interrupt_enable_status(state_ptr->usbRegBase));
+
+#if _DEBUG
+ USB_PRINTF("USB Err: 0x%x\n", device_error);
+#endif
+
+ /* Initialize the event structure to be passed to the upper layer*/
+ event.handle = (usb_device_handle)state_ptr->upper_layer_handle;
+ event.ep_num = ep_num;
+ event.setup = FALSE;
+ event.direction = (bool)(stat >> 3 & 1);
+ event.buffer_ptr = (uint8_t*)device_error;
+ event.len = ZERO_LENGTH;
+
+ /* Invoke Service Call */
+ (void)_usb_device_call_service(USB_SERVICE_ERROR,&event);
+
+ /*clear all errors*/
+ usb_hal_khci_clr_all_error_interrupts(state_ptr->usbRegBase);
+}
+#endif
+
+/**************************************************************************//*!
+ *
+ * @name _usb_khci_service_reset_intr
+ *
+ * @brief : Service reset Interrupt.
+ *
+ * @param state_ptr: Device Structure Pointer Passed to ISR. The is the
+ * same structure which was passed in function OS_install_isr
+ * During ISR installation.
+ *
+ * @return NONE
+ *****************************************************************************/
+static void _usb_khci_service_reset_intr
+(
+ /*[IN]*/
+ usb_khci_dev_state_struct_t* state_ptr
+)
+{
+ uint8_t ep_num;
+ //volatile USB_MemMapPtr usb_ptr;
+ usb_event_struct_t event;
+
+ state_ptr->is_reseting = 1;
+ /* Clear Reset Interrupt */
+ usb_hal_khci_clr_interrupt(state_ptr->usbRegBase, INTR_USBRST);
+
+ /* Get the Endpoint number on which the transaction occurred.
+ * This is (7 - 5) [3:0] bit in STAT register.
+ */
+ ep_num = usb_hal_khci_get_transfer_done_ep_number(state_ptr->usbRegBase);
+
+ /* Initialize the event structure to be passed to the upper layer*/
+ event.handle = (usb_device_handle)state_ptr->upper_layer_handle;
+ event.ep_num = ep_num;
+ event.setup = FALSE;
+ event.direction = USB_RECV;
+ event.buffer_ptr = (uint8_t*)NULL;
+ event.len = ZERO_LENGTH;
+ /* Inform Upper Layer of Reset Signal.
+ * Remember Upper layer i.e class driver invokes
+ * usb_dci_khci_init_endpoint() as part of reset callback
+ */
+ (void)_usb_device_call_service(USB_SERVICE_BUS_RESET, &event);
+}
+
+/**************************************************************************//*!
+ *
+ * @name _usb_khci_service_tk_dne_intr
+ *
+ * @brief : Service Error Interrupt.
+ *
+ * @param state_ptr: Device Structure Pointer Passed to ISR. It is the same
+ * structure which was passed in function OS_install_isr
+ * During ISR installation.
+ *
+ * @return NONE
+ *****************************************************************************/
+static void _usb_khci_service_tk_dne_intr
+(
+ /*[IN]*/
+ usb_khci_dev_state_struct_t* state_ptr
+)
+{
+ uint8_t ep_num, stat, dir, buf_odd, setup, token_pid;
+ uint32_t len = 0;
+ //usb_status error;
+ uint32_t buf_num_bytes;
+ //volatile USB_MemMapPtr usb_ptr;
+ xd_struct_t* xd_ptr;
+// uint8_t * buffer_ptr = NULL;
+ uint32_t control = 0;
+#if USBCFG_KHCI_4BYTE_ALIGN_FIX
+ uint8_t *src, *dst = NULL;
+#endif
+ usb_event_struct_t event;
+
+ /* Get the status of previous transaction*/
+ stat = usb_hal_khci_get_transfer_status(state_ptr->usbRegBase);
+
+ /* Get the Endpoint number on which the transaction occurred.
+ * This is (7 - 5) [3:0] bit in STAT register.
+ */
+ ep_num = usb_hal_khci_get_transfer_done_ep_number(state_ptr->usbRegBase);
+
+ /* Get the Direction of transaction. (i.e the transaction was a receive
+ * operation or transaction was a Transmit operation).It is Bit [3] in STAT
+ * register.
+ */
+ dir = usb_hal_khci_get_transfer_done_direction(state_ptr->usbRegBase);
+
+ /* Get the last buffer transaction was in ODD buffer or Even Buffer*/
+ buf_odd = usb_hal_khci_get_transfer_done_odd(state_ptr->usbRegBase);
+
+ /* Clear TOKEN Done Interrupt. This clearing of TOKEN_DONE
+ * should happen after STAT register is read. This is because
+ * STAT register has four byte fifo and if TOKEN_DONE is cleared
+ * in INT_STAT then the content of STAT register is updated with
+ * the next value in the STAT fifo.
+ */
+ usb_hal_khci_clr_interrupt(state_ptr->usbRegBase, INTR_TOKDNE);
+
+ control = usb_hal_khci_bdt_get_control((uint32_t )bdt, ep_num, dir, buf_odd);
+
+ /* Get length of Data transmitted or received in the last transaction. */
+ len = (USB_HOST_TO_LE_LONG(control) >> 16) & 0x3ff;
+
+ /* Get PID for this token */
+ token_pid = (uint8_t)((USB_HOST_TO_LE_LONG(control) >> 2) & 0x0000000f);
+
+ /* if token PID is a setup token */
+ setup = (token_pid == USB_SETUP_TOKEN) ? TRUE : FALSE;
+
+ //USB_PRINTF("23tk_dne ep %d dir %d len %d buff_odd %d\n", ep_num, dir, len, buf_odd);
+ if (dir)
+ {
+ /* direction is USB_SEND*/
+ /* Get head of the send queue */
+ //USB_XD_QUEUE_GET_HEAD(&state_ptr->ep_info[ep_num].xd_queue_send,&xd_ptr);
+ //USB_PRINTF("get send xd_ptr 0x%x\n", xd_ptr);
+ /* updating the WSOFAR field */
+ xd_ptr = state_ptr->ep_info[ep_num].send_xd;
+ if (xd_ptr == NULL)
+ {
+ return;
+ }
+ xd_ptr->wsofar += len;
+
+ buf_num_bytes = (uint32_t)(xd_ptr->wtotallength - xd_ptr->wsofar);
+
+ /* dequeue if all bytes have been send or the last send transaction was
+ of length less then the max packet size length configured for
+ corresponding endpoint */
+ state_ptr->ep_info[ep_num].tx_buf_odd ^= 1;
+ state_ptr->ep_info[ep_num].tx_data0 ^= 1;
+ if ((buf_num_bytes == 0) || (state_ptr->ep_info[ep_num].max_packet_size > len))
+ {
+ event.len = xd_ptr->wsofar;
+ /* buffer address is updated for upper layer */
+ event.buffer_ptr = xd_ptr->wstartaddress;
+ state_ptr->ep_info[ep_num].send_xd = NULL;
+ usb_dci_khci_free_xd(state_ptr, xd_ptr);
+ if ((len == state_ptr->ep_info[ep_num].max_packet_size) &&
+ (ep_num == USB_CONTROL_ENDPOINT))
+ {
+ g_zero_pkt_send = TRUE;
+ usb_device_send_data((usb_device_handle)state_ptr->upper_layer_handle, ep_num, NULL, 0);
+ return;
+ }
+ }
+ else
+ {
+ usb_dci_khci_send(state_ptr, xd_ptr);
+ //_usb_khci_process_transmit_request(state_ptr, ep_num, &buffer_ptr);
+ return;/*if above call returned USB_STATUS_TRANSFER_PENDING */
+ }
+ }
+ else
+ {
+
+ if ((ep_num == USB_CONTROL_ENDPOINT) && (!len))
+ {
+ /* Initialize the event structure to be passed to the upper layer*/
+ event.handle = (usb_device_handle)state_ptr->upper_layer_handle;
+ event.ep_num = ep_num;
+ event.setup = setup;
+ event.direction = (bool)(stat >> 3 & 1U);
+
+ /* propagate control to upper layers for processing */
+ _usb_device_call_service(ep_num, &event);
+ usb_hal_khci_clr_token_busy(state_ptr->usbRegBase);
+ return;
+ }
+ /* direction is USB_RECV*/
+ if (g_zero_pkt_send == TRUE)
+ {
+ g_zero_pkt_send = FALSE;
+ }
+ //USB_PRINTF("before ep %d : xd_head_ptr 0x%x xd_tail_ptr 0x%x\n", ep_num,
+ // state_ptr->EP_INFO[ep_num].xd_queue_recv.xd_head_ptr,
+ // state_ptr->EP_INFO[ep_num].xd_queue_recv.xd_tail_ptr);
+ /* Get head of the send queue */
+ //USB_XD_QUEUE_GET_HEAD(&state_ptr->ep_info[ep_num].xd_queue_recv, &xd_ptr);
+ xd_ptr = state_ptr->ep_info[ep_num].recv_xd;
+ if (xd_ptr == NULL)
+ {
+ return;
+ }
+#if USBCFG_KHCI_4BYTE_ALIGN_FIX
+ if (!xd_ptr->internal_dma_align)
+ {
+ //src = (uint8_t *)USB_LONG_LE_TO_HOST(BD_ADDR_RX(ep_num, state_ptr->ep_info[ep_num].rx_buf_odd));
+ src = (uint8_t*)USB_LONG_LE_TO_HOST(usb_hal_khci_bdt_get_address( (uint32_t)bdt, ep_num, USB_RECV, state_ptr->ep_info[ep_num].rx_buf_odd));
+ dst = xd_ptr->wstartaddress + xd_ptr->wsofar;
+ if (src != dst)
+ {
+ OS_Mem_copy(src, dst, len);
+ }
+ }
+#endif
+ xd_ptr->wsofar += len;/* updating the WSOFAR field */
+
+ buf_num_bytes = (uint32_t)(xd_ptr->wtotallength - xd_ptr->wsofar);
+
+ if ((ep_num == USB_CONTROL_ENDPOINT) && (token_pid == USB_SETUP_TOKEN))
+ {
+ /* cancel any pending transfers in SEND QUEUE if present*/
+ usb_dci_khci_cancel((usb_device_handle)state_ptr, ep_num, USB_SEND);
+ /* for first In/OUT after setup token DATA PID has to be always one */
+ state_ptr->ep_info[ep_num].tx_data0 = 1;
+ state_ptr->ep_info[ep_num].rx_data0 = 1;
+ state_ptr->ep_info[ep_num].rx_buf_odd ^= 1;
+ //state_ptr->ep_info[ep_num].tx_buf_odd ^= 1;
+ }
+ else
+ {
+ /* set DATA PID and buffer for next recv transaction */
+ state_ptr->ep_info[ep_num].rx_data0 ^= 1;
+ state_ptr->ep_info[ep_num].rx_buf_odd ^= 1;
+ }
+
+ //USB_PRINTF("max packet size %d\n",state_ptr->EP_INFO[ep_num].max_packet_size);
+ /* dequeue if all bytes have been received or the last send transaction
+ was of length less then the max packet size length configured for
+ corresponding endpoint */
+ if ((!xd_ptr->wtotallength) || (buf_num_bytes == 0) ||
+ (state_ptr->ep_info[ep_num].max_packet_size > len))
+ {
+ event.len = xd_ptr->wsofar;
+ /* buffer address is updated for upper layer */
+ event.buffer_ptr = xd_ptr->wstartaddress;
+ state_ptr->ep_info[ep_num].recv_xd = NULL;
+ usb_dci_khci_free_xd(state_ptr, xd_ptr);
+ }
+ else
+ {
+ usb_dci_khci_recv(state_ptr, xd_ptr);
+ //_usb_khci_process_receive_request(state_ptr,ep_num, stat, &buffer_ptr);
+ return;/*if above call returned USB_STATUS_TRANSFER_PENDING */
+ }
+ }
+
+ /* prepare for next setup token if needed*/
+ if ((ep_num == USB_CONTROL_ENDPOINT) && (!len) && (g_zero_pkt_send == FALSE))
+ {
+ _usb_khci_next_setup_token_prep(state_ptr);
+ }
+ /* Initialize the event structure to be passed to the upper layer*/
+ event.handle = (usb_device_handle)state_ptr->upper_layer_handle;
+ event.ep_num = ep_num;
+ event.setup = setup;
+ event.direction = (bool)(stat >> 3 & 1U);
+
+ /* propagate control to upper layers for processing */
+ _usb_device_call_service(ep_num, &event);
+
+ //USB_PRINTF("_usb_khci_service_tk_dne_intr 3-- :%d \n",ep_num);
+
+ usb_hal_khci_clr_token_busy(state_ptr->usbRegBase);
+
+}
+
+#if USBCFG_DEV_ADVANCED_SUSPEND_RESUME
+/**************************************************************************//*!
+ *
+ * @name _usb_khci_service_sleep_intr
+ *
+ * @brief : Service Sleep Interrupt.
+ *
+ * @param state_ptr: Device Structure Pointer Passed to ISR. The is the
+ * same structure which was passed in function OS_install_isr
+ * During ISR installation.
+ *
+ * @return NONE
+ *****************************************************************************/
+static void _usb_khci_service_sleep_intr
+(
+ /*[IN]*/
+ usb_khci_dev_state_struct_t* state_ptr
+)
+{
+ //volatile USB_MemMapPtr usb_ptr;
+ usb_event_struct_t event;
+
+ usb_hal_khci_clr_interrupt(state_ptr->usbRegBase, INTR_RESUME);
+
+ /* clear suspend interrupt */
+ usb_hal_khci_clr_interrupt(state_ptr->usbRegBase, INTR_SLEEP);
+
+ state_ptr->usb_dev_state_b4_suspend = state_ptr->usb_state;
+
+ state_ptr->usb_state = USB_STATE_SUSPEND;
+
+ /* Initialize the event structure to be passed to the upper layer*/
+ event.handle = (usb_device_handle)state_ptr->upper_layer_handle;
+ event.ep_num = (uint8_t)USB_UNINITIALIZED_VAL_32;
+ event.setup = 0;
+ event.direction = 0;
+ event.buffer_ptr = (uint8_t*)NULL;
+ event.len = ZERO_LENGTH;
+
+ /* Notify Device Layer of SLEEP Event */
+ /* this callback need only handle and type -
+ all other arguments are redundant */
+ (void)_usb_device_call_service(USB_SERVICE_SUSPEND, &event);
+
+ /* Enable RESUME Interrupt */
+ usb_hal_khci_enable_interrupts(state_ptr->usbRegBase, (INTR_RESUME));
+}
+
+/************************************************************************//*!
+ *
+ * @name _usb_khci_service_resume_intr
+ *
+ * @brief : Service resume Interrupt.
+ *
+ * @param state_ptr: Device Structure Pointer Passed to ISR. The is the
+ * same structure which was passed in function OS_install_isr
+ * During ISR installation.
+ *
+ * @return NONE
+ *****************************************************************************/
+static void _usb_khci_service_resume_intr
+(
+ /*[IN]*/
+ usb_khci_dev_state_struct_t* state_ptr
+)
+{
+ usb_event_struct_t event;
+
+ /* clear resume interrupt status bit */
+ usb_hal_khci_clr_interrupt(state_ptr->usbRegBase, INTR_RESUME);
+
+ state_ptr->usb_state = state_ptr->usb_dev_state_b4_suspend;
+
+ /* Initialize the event structure to be passed to the upper layer*/
+ event.handle = (usb_device_handle)state_ptr->upper_layer_handle;
+ event.ep_num = (uint8_t)USB_UNINITIALIZED_VAL_32;
+ event.setup = 0;
+ event.direction = 0;
+ event.buffer_ptr = (uint8_t*)NULL;
+ event.len = ZERO_LENGTH;
+
+ /* Notify Device Layer of RESUME Event */
+ /* this callback need only handle and type -
+ all other arguments are redundant */
+ (void)_usb_device_call_service(USB_SERVICE_RESUME,&event);
+
+ /* Disable RESUME Interrupt */
+ usb_hal_khci_disable_interrupts(state_ptr->usbRegBase, INTR_RESUME);
+}
+#endif
+/***********************************************************************//*!
+ *
+ * @name _usb_khci_service_sof_token_intr
+ *
+ * @brief : Service SOF Interrupt.
+ *
+ * @param state_ptr: Device Structure Pointer Passed to ISR. The is the
+ * same structure which was passed in function OS_install_isr
+ * During ISR installation.
+ *
+ * @return NONE
+ *****************************************************************************/
+static void _usb_khci_service_sof_token_intr
+(
+ /*[IN]*/
+ usb_khci_dev_state_struct_t* state_ptr
+)
+{
+ /* Clear SOF Interrupt */
+ usb_hal_khci_clr_interrupt(state_ptr->usbRegBase, INTR_SOFTOK);
+
+ state_ptr->usb_sof_count = usb_hal_khci_get_frame_number(state_ptr->usbRegBase);
+
+ /* address of Lower byte of Frame number.
+ */
+ //buffer_ptr = (uint8_t *)&(state_ptr->USB_SOF_COUNT);
+ /* clear resume interrupt status bit */
+ usb_hal_khci_clr_interrupt(state_ptr->usbRegBase, INTR_RESUME);
+}
+
+#if 0
+/**************************************************************************//*!
+ *
+ * @name _usb_khci_service_attach_intr
+ *
+ * @brief : Service attach Interrupt.
+ *
+ * @param state_ptr: Device Structure Pointer Passed to ISR. The is the
+ * same structure which was passed in function OS_install_isr
+ * During ISR installation.
+ *
+ * @return NONE
+ *****************************************************************************/
+static void _usb_khci_service_attach_intr
+(
+/*[IN]*/
+usb_khci_dev_state_struct_t* state_ptr
+)
+{
+ usb_hal_khci_clr_interrupt(state_ptr->usbRegBase, INTR_ATTACH);
+}
+#endif
+
+/************************************************************************//*!
+ *
+ * @name _usb_khci_service_stall_intr
+ *
+ * @brief : Service stall Interrupt.
+ *
+ * @param state_ptr: Device Structure Pointer Passed to ISR. The is the
+ * same structure which was passed in function OS_install_isr
+ * During ISR installation.
+ *
+ * @return NONE
+ *****************************************************************************/
+static void _usb_khci_service_stall_intr
+(
+ /*[IN]*/
+ usb_khci_dev_state_struct_t* state_ptr
+)
+{
+
+ uint8_t ep;
+
+ for (ep = 0; ep < USBCFG_DEV_MAX_ENDPOINTS; ep++)
+ {
+ if (state_ptr->ep_info[ep].endpoint_status == USB_STATUS_STALLED)
+ {
+ usb_hal_khci_endpoint_clr_stall(state_ptr->usbRegBase, ep);
+ usb_hal_khci_bdt_set_control((uint32_t )bdt, ep, USB_SEND, state_ptr->ep_info[ep].tx_buf_odd,
+ USB_LONG_LE_TO_HOST((uint32_t)(USB_BD_BC(state_ptr->ep_info[ep].max_packet_size)| USB_BD_DTS | USB_BD_DATA01(0))));
+ usb_hal_khci_bdt_set_control((uint32_t )bdt, ep, USB_RECV, state_ptr->ep_info[ep].rx_buf_odd,
+ USB_LONG_LE_TO_HOST((uint32_t)(USB_BD_BC(state_ptr->ep_info[ep].max_packet_size)| USB_BD_DTS | USB_BD_DATA01(0))));
+ }
+ }
+
+ /* Clear Stall Interrupt */
+ usb_hal_khci_clr_interrupt(state_ptr->usbRegBase, INTR_STALL);
+
+ /* check if the stall interrupt received was for CONTROL ENDPOINT */
+ if (state_ptr->ep_info[USB_CONTROL_ENDPOINT].endpoint_status == USB_STATUS_STALLED)
+ {
+ state_ptr->ep_info[USB_CONTROL_ENDPOINT].endpoint_status = USB_STATUS_IDLE;
+ _usb_khci_next_setup_token_prep(state_ptr);
+ }
+
+}
+
+/**************************************************************************//*!
+ *
+ * @name _usb_khci_isr
+ *
+ * @brief : Service all the interrupts in the kirin usb hardware
+ *
+ * @param state_ptr: Device Structure Pointer Passed to ISR. The is the
+ * same structure which was passed in function OS_install_isr
+ * During ISR installation.
+ *
+ * @return NONE
+ *****************************************************************************/
+#ifdef USBCFG_OTG
+void _usb_dev_khci_isr
+(
+ usb_khci_dev_state_struct_t* state_ptr
+)
+{
+ state_ptr = (usb_khci_dev_state_struct_t*)(&g_khci_dev[0]);
+#else
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK)
+static void _usb_khci_isr(void)
+{
+ usb_khci_dev_state_struct_t* state_ptr = (usb_khci_dev_state_struct_t*)(&g_khci_dev[0]);
+#else
+static void _usb_khci_isr(usb_khci_dev_state_struct_t* state_ptr)
+{
+ state_ptr = (usb_khci_dev_state_struct_t*)(&g_khci_dev[0]);
+#endif
+#endif
+ /* Get the USB IP base address in the controller */
+ //error = (uint8_t)usb_hal_get_interrupt_status(state_ptr->usbRegBase);
+#if FSL_FEATURE_USB_KHCI_KEEP_ALIVE_ENABLED && USBCFG_DEV_KEEP_ALIVE_MODE
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK)
+ if(usb_hal_khci_get_keepalive_wake_int_sts(state_ptr->usbRegBase))
+ {
+ usb_hal_khci_clr_keepalive_wake_int_sts(state_ptr->usbRegBase);
+ }
+#endif
+#endif
+ /* This interrupt comes when any of the error conditions within
+ * the ERRSTAT register occur. The ColdFire core must
+ * then read the ERRSTAT register to determine the source of the error.
+ */
+#if USBCFG_DEV_KHCI_ADVANCED_ERROR_HANDLING
+ if (usb_hal_khci_is_interrupt_issued(state_ptr->usbRegBase, INTR_ERROR))
+ {
+ _usb_khci_service_err_intr(state_ptr);
+ }
+#endif
+ /* This TOKEN_DONE interrupt comes when the current token being processed
+ * has completed. The ColdFire core should immediately read the STAT register
+ * to determine the EndPoint and BD used for this token. Clearing this bit
+ * (by writing a one) causes the STAT register to be cleared or the
+ * STAT holding register to be loaded into the STAT register.
+ */
+ if (usb_hal_khci_is_interrupt_issued(state_ptr->usbRegBase, INTR_TOKDNE))
+ {
+ // USB_PRINTF("done ++");
+ _usb_khci_service_tk_dne_intr(state_ptr);
+ }
+ /* This reset interrupt comes when the USB Module has decoded a valid USB reset.
+ * This informs the Microprocessor that it should write 0x00 into the address
+ * register and enable endpoint 0. USB_RST bit is set after a USB reset has been
+ * detected for 2.5 microseconds. It is not asserted again until the USB reset
+ * condition has been removed and then re-asserted.
+ */
+ if (usb_hal_khci_is_interrupt_issued(state_ptr->usbRegBase, INTR_USBRST))
+ {
+ _usb_khci_service_reset_intr(state_ptr);
+ }
+#if USBCFG_DEV_ADVANCED_SUSPEND_RESUME
+ /* This sleep interrupt comes when the USB Module detects a constant idle
+ * on the USB bus for 3 milliseconds.
+ */
+ if (usb_hal_khci_is_interrupt_issued(state_ptr->usbRegBase, INTR_SLEEP))
+ {
+ _usb_khci_service_sleep_intr(state_ptr);
+ }
+
+ /* This interrupt comes depending upon the DP/DM signals, and can be used
+ * to signal remote wake-up signaling on the USB bus. When not in suspend
+ * mode this interrupt should be disabled
+ */
+ if (usb_hal_khci_is_interrupt_issued(state_ptr->usbRegBase, INTR_RESUME))
+ {
+ _usb_khci_service_resume_intr(state_ptr);
+ }
+#endif
+ /* This interrupt comes when the USB Module receives a Start Of Frame
+ * (SOF) token.
+ */
+ if (usb_hal_khci_is_interrupt_issued(state_ptr->usbRegBase, INTR_SOFTOK))
+ {
+ _usb_khci_service_sof_token_intr(state_ptr);
+ }
+
+#if 0
+ /* This interrupt comes when the USB Module detects an attach of a
+ * USB device. This signal is only valid if HOST_MODE_EN is true.
+ * This interrupt signifies that a peripheral is now present and must
+ * be configured.
+ */
+ if(usb_hal_khci_is_interrupt_issued(state_ptr->usbRegBase, INTR_ATTACH))
+ {
+ _usb_khci_service_attach_intr(state_ptr);
+ }
+#endif
+ /* In Target mode this interrupt comes when a STALL handshake is sent
+ by the SIE.*/
+ if (usb_hal_khci_is_interrupt_issued(state_ptr->usbRegBase, INTR_STALL))
+ {
+ _usb_khci_service_stall_intr(state_ptr);
+ }
+
+ return;
+}
+/*****************************************************************************
+ * Global Functions
+ *****************************************************************************/
+/**************************************************************************//*!
+ *
+ * @name : usb_dci_khci_preinit
+ * @brief : Allocates space for the USB device controller.
+ * @param handle: Handle to USB Device to be filled
+ * @return USB_OK on successful.
+ ******************************************************************************/
+usb_status usb_dci_khci_preinit
+(
+ /* [IN] the USB device handle */
+ usb_device_handle upper_layer_handle,
+
+ usb_device_handle * handle_ptr
+ )
+{
+ usb_khci_dev_state_struct_t* usb_dev_ptr = (usb_khci_dev_state_struct_t*)(&g_khci_dev[0]);
+
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ if (NULL == g_khci_data_ptr)
+ {
+ g_khci_data_ptr = OS_Mem_alloc_uncached(sizeof(usb_device_khci_data_t));
+ }
+
+#if (FSL_FEATURE_USB_KHCI_USB_RAM == 0)
+ if (NULL == g_khci_bdt_ptr)
+ {
+ g_khci_bdt_ptr = OS_Mem_alloc_uncached_align(512, 512);
+ }
+#endif
+
+#endif
+
+ usb_dci_khci_init_xd((usb_device_handle)usb_dev_ptr);
+
+#if USBCFG_KHCI_4BYTE_ALIGN_FIX
+
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM) || (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK)
+ _usb_khci_dev_swap_buf_ptr = g_khci_data.swap_buf;
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ _usb_khci_dev_swap_buf_ptr = g_khci_data_ptr->swap_buf;
+#endif
+
+#endif
+ usb_dev_ptr->mutex = OS_Mutex_create();
+ *handle_ptr = (usb_device_handle)usb_dev_ptr;
+ usb_dev_ptr->upper_layer_handle = upper_layer_handle;
+
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ *
+ * @name : usb_dci_khci_init
+ * @brief : Initializes the USB device controller.
+ * @param handle: USB device handle.
+ * @param init_param: initialization parameters specific for device
+ * @return USB_OK on successful.
+ ******************************************************************************/
+usb_status usb_dci_khci_init
+(
+ uint8_t controller_id,
+ /* [IN] the USB device handle */
+
+ usb_device_handle handle
+ )
+{
+#ifdef USBCFG_OTG
+ usb_otg_state_struct_t * usb_otg_struct_ptr = (usb_otg_state_struct_t *)g_usb_otg_handle;
+ usb_otg_status_t * otg_status_ptr = &usb_otg_struct_ptr->otg_status;
+#endif
+ usb_khci_dev_state_struct_t* usb_dev_ptr = (usb_khci_dev_state_struct_t*)handle;
+ //volatile USB_MemMapPtr usb_ptr;
+
+ usb_dev_ptr->dev_vec = soc_get_usb_vector_number(controller_id);
+
+ usb_dev_ptr->is_reseting = 0;
+
+ usb_dev_ptr->usbRegBase = soc_get_usb_base_address(controller_id);
+ /* Get the maximum number of endpoints supported by this USB controller */
+ usb_dev_ptr->max_endpoints = KHCI_MAX_ENDPOINT;
+ usb_dev_ptr->speed = USB_SPEED_FULL;
+
+ /* Clear all interrupts and bring it to finite
+ * state before device starts functioning.
+ */
+ usb_hal_khci_clr_all_interrupts(usb_dev_ptr->usbRegBase);
+ usb_hal_khci_disable_dp_pull_up(usb_dev_ptr->usbRegBase);
+
+#ifndef USBCFG_OTG
+ /* Install the ISR
+ * Device Pointer is passed as an Argument when the
+ * ISR is invoked.
+ */
+#if (OS_ADAPTER_ACTIVE_OS != OS_ADAPTER_SDK)
+ if (!(OS_install_isr(usb_dev_ptr->dev_vec, (void (*)(void *))_usb_khci_isr, usb_dev_ptr)))
+ return USBERR_INSTALL_ISR;
+#else
+ OS_install_isr(usb_dev_ptr->dev_vec, (void (*)(void) )_usb_khci_isr, usb_dev_ptr);
+#endif
+#endif
+
+#if FSL_FEATURE_USB_KHCI_USB_RAM
+ bdt = (uint8_t *)usb_hal_khci_get_usbram_add(usb_dev_ptr->usbRegBase);
+#else
+
+#if ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM) || (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK))
+ bdt = g_khci_bdt_buffer;
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ bdt = g_khci_bdt_ptr;
+#endif
+
+#endif
+
+ /* Initialize BDT Page register 1,2,3. The Buffer
+ * Descriptor Table Page Register 1 2,3 contains an
+ * 8-bit value used to compute the address where
+ * the current Buffer Descriptor Table (BDT)
+ * resides in system memory.
+ */
+ usb_hal_khci_set_buffer_descriptor_table_addr(usb_dev_ptr->usbRegBase, (uint32_t)bdt);
+
+ /* Initialize the end point state*/
+ _usb_khci_reset_ep_state(usb_dev_ptr);
+
+ //USB_PRINTF("11usb_dci_khci_init ++");
+ /* Enable Sleep,Token Done,Error,USB Reset,Stall,
+ * Resume and SOF Interrupt.
+ */
+ //usb_hal_khci_enable_interrupts(usb_dev_ptr->usbRegBase,(INTR_USBRST | INTR_ERROR | INTR_SOFTOK | INTR_TOKDNE | INTR_SLEEP | INTR_STALL));
+#ifdef USBCFG_OTG
+ usb_dev_ptr->otg_handle = g_usb_otg_handle;
+ otg_status_ptr->active_stack = USB_ACTIVE_STACK_DEVICE;
+ /* set otg status to 0 */
+ usb_dci_khci_set_status(handle, USB_STATUS_OTG, 0);
+ /**/
+#endif
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ *
+ * @name : usb_dci_khci_init
+ * @brief : Initializes the USB device controller.
+ * @param handle: USB device handle.
+ * @param init_param: initialization parameters specific for device
+ * @return USB_OK on successful.
+ ******************************************************************************/
+usb_status usb_dci_khci_postinit
+(
+ uint8_t controller_id,
+ /* [IN] the USB device handle */
+
+ usb_device_handle handle
+ )
+{
+ /* Enable D+ pull up register
+ * Note, that this D+ external resistor is not applicable for some devices
+ */
+ usb_khci_dev_state_struct_t* usb_dev_ptr = (usb_khci_dev_state_struct_t*)(&g_khci_dev[controller_id - USB_CONTROLLER_KHCI_0]);
+ //usb_khci_dev_state_struct_t* state_ptr = *usb_dev_ptr;
+
+ usb_hal_khci_enable_dp_pull_up(usb_dev_ptr->usbRegBase);
+ /* Enable USB module*/
+ usb_hal_khci_enable_sof(usb_dev_ptr->usbRegBase);
+
+ /* Remove suspend state */
+ usb_hal_khci_clr_suspend(usb_dev_ptr->usbRegBase);
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ * @name : usb_dci_khci_init_endpoint
+ *
+ * @brief : Initialize the Endpoint
+ * @param handle: Handle to USB Device.
+ * @param xd_ptr: Transaction Descriptor.
+ * @return : USB_OK or error code
+ ******************************************************************************/
+usb_status usb_dci_khci_init_endpoint
+(
+ /*[IN]*/
+ usb_device_handle handle,
+ /*[IN]*/
+ xd_struct_t* xd_ptr
+ )
+{
+ //usb_status error = USB_OK;
+ uint16_t max_pkt_size = 0;
+
+ /* Get the device pointer initialized in usb_dci_khci_init*/
+ usb_khci_dev_state_struct_t* state_ptr = (usb_khci_dev_state_struct_t*)handle;
+ //volatile USB_MemMapPtr usb_ptr;
+#if 0
+ if (state_ptr == NULL)
+ {
+ return USBERR_ERROR;
+ }
+
+ if((xd_ptr->ep_type > USB_INTERRUPT_PIPE) ||
+ (xd_ptr->bdirection > USB_SEND))
+ {
+ return USBERR_EP_INIT_FAILED;
+ }
+#endif
+ //USB_PRINTF("init ep %d dir %d\n", xd_ptr->EP_NUM, xd_ptr->BDIRECTION);
+
+ /* mark this endpoint as initialized */
+ state_ptr->ep_info[xd_ptr->ep_num].ep_init_flag[xd_ptr->bdirection] = TRUE;
+
+ /*before initializing cancel all transfers on EP as there may be calls
+ for endpoint initialization more than once. This will free any allocated
+ queue*/
+
+ /*
+ * Since this is endpoint initialization section there will
+ * not be any pending transfers on this endpoint
+ */
+
+ /* The end point buffer size will be set as required by app.
+ * but if the size crosses MAX_EP_BUFFER_SIZE size then truncate the
+ * max packet size.
+ */
+ if (xd_ptr->ep_type == USB_ISOCHRONOUS_PIPE)
+ {
+ max_pkt_size = (uint16_t)((xd_ptr->wmaxpacketsize > MAX_FS_ISO_EP_BUFFER_SIZE)?
+ MAX_FS_ISO_EP_BUFFER_SIZE:xd_ptr->wmaxpacketsize);
+ }
+ else
+ {
+ max_pkt_size = (uint16_t)((xd_ptr->wmaxpacketsize > MAX_FS_NON_ISO_EP_BUFFER_SIZE)?
+ MAX_FS_NON_ISO_EP_BUFFER_SIZE:xd_ptr->wmaxpacketsize);
+ }
+
+ /* Initialize the End Point Information Structure which is part of device
+ * structure. It is done so that it can be used at later point of time
+ * like ISR handler, any other function call.
+ */
+ state_ptr->ep_info[xd_ptr->ep_num].type = xd_ptr->ep_type;
+ state_ptr->ep_info[xd_ptr->ep_num].direction = xd_ptr->bdirection;
+ state_ptr->ep_info[xd_ptr->ep_num].max_packet_size = max_pkt_size;
+ state_ptr->ep_info[xd_ptr->ep_num].endpoint_status = USB_STATUS_IDLE;
+ state_ptr->ep_info[xd_ptr->ep_num].stall_flag = FALSE;
+ if (USB_RECV == xd_ptr->bdirection)
+ {
+ state_ptr->ep_info[xd_ptr->ep_num].rx_data0 = 0;
+ state_ptr->ep_info[xd_ptr->ep_num].recv_xd = NULL;
+ }
+ else
+ {
+ state_ptr->ep_info[xd_ptr->ep_num].tx_data0 = 0;
+ state_ptr->ep_info[xd_ptr->ep_num].send_xd = NULL;
+ }
+
+ usb_hal_khci_endpoint_enable_handshake(state_ptr->usbRegBase, xd_ptr->ep_num, ((xd_ptr->ep_type != USB_ISOCHRONOUS_PIPE) ? 1 : 0));
+ usb_hal_khci_endpoint_set_direction(state_ptr->usbRegBase, xd_ptr->ep_num, (xd_ptr->bdirection ? 1 : 0));
+ if ((USB_RECV == xd_ptr->bdirection) && (xd_ptr->ep_num == USB_CONTROL_ENDPOINT))
+ {
+ _usb_khci_next_setup_token_prep(state_ptr);
+ }
+#if 0
+ /* Write the initialized control values to end point control register*/
+ //usb_hal_set_endpoint_ephshk(state_ptr->usbRegBase, xd_ptr->ep_num, (xd_ptr->ep_type != USB_ISOCHRONOUS_PIPE ? 1 : 0));
+ /*Configure this endpoint for receive or Send direction as required by APP*/
+ //usb_hal_set_endpoint_direction(state_ptr->usbRegBase, xd_ptr->ep_num, (xd_ptr->bdirection ? 1: 0));
+ /* Set the BDT and buffer data pointer for Receive Direction*/
+ if ((USB_RECV == xd_ptr->bdirection) && (xd_ptr->ep_num == USB_CONTROL_ENDPOINT) )
+ {
+ const uint8_t control[2] =
+ {
+ USB_BD_DATA01(0) | USB_BD_DTS | USB_BD_OWN,
+ USB_BD_DATA01(1) | USB_BD_DTS
+ };
+
+ /* configure first start address for recv transaction */
+ usb_dci_khci_get_xd (state_ptr, &xd_temp_ptr);
+ xd_temp_ptr->ep_num = xd_ptr->ep_num;
+ xd_temp_ptr->bdirection = xd_ptr->bdirection;
+ xd_temp_ptr->wtotallength =xd_ptr->wtotallength;
+#if USBCFG_4BYTE_ALIGN_FIX
+ xd_temp_ptr->internal_dma_align = TRUE;
+#endif
+ xd_temp_ptr->wsofar = xd_ptr->wsofar;
+ xd_temp_ptr->ep_type = xd_ptr->ep_type;
+ xd_temp_ptr->dont_zero_terminate = xd_ptr->dont_zero_terminate;
+ xd_temp_ptr->wstartaddress = (uint8_t *)USB_LONG_LE_TO_HOST((uint32_t)state_ptr->setup_buff);
+ USB_XD_QUEUE_ENQUEUE(&state_ptr->ep_info[xd_ptr->ep_num].xd_queue_recv, xd_temp_ptr);
+
+ /*Configure Even buff for the end point*/
+ BD_ADDR_RX(xd_ptr->ep_num, state_ptr->ep_info[xd_ptr->ep_num].rx_buf_odd) =
+ USB_LONG_LE_TO_HOST((uint32_t)state_ptr->setup_buff);
+
+ BD_CTRL_RX(xd_ptr->ep_num, state_ptr->ep_info[xd_ptr->ep_num].rx_buf_odd) =
+ USB_LONG_LE_TO_HOST((uint32_t)(USB_BD_BC(SETUP_PACKET_LENGTH) | control[0]));
+
+ /*Configure Even buff for odd end point*/
+ BD_ADDR_RX(xd_ptr->ep_num, state_ptr->ep_info[xd_ptr->ep_num].rx_buf_odd ^ 1) =
+ USB_LONG_LE_TO_HOST((uint32_t)
+ (state_ptr->setup_buff + SETUP_PACKET_LENGTH));
+ BD_CTRL_RX(xd_ptr->ep_num, state_ptr->ep_info[xd_ptr->ep_num].rx_buf_odd ^ 1) =
+ USB_LONG_LE_TO_HOST((uint32_t)(USB_BD_BC(SETUP_PACKET_LENGTH) | control[1]));
+ }
+ else /* Set the BDT and buffer data pointer for Send direction */
+ {
+ /* Initialize the DATA PID to DATA0*/
+ //state_ptr->EP_INFO[xd_ptr->EP_NUM].tx_data0 = 0;
+ }
+#endif
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ * @name : usb_dci_khci_deinit_endpoint
+ *
+ * @brief : De-Initialize the Endpoint
+ * @param handle: Handle to USB Device.
+ * @param ep_num: End Point Number.
+ * @param direction: USB_SEND or USB_RECV.
+ * @return : USB_OK or error code
+ ******************************************************************************/
+usb_status usb_dci_khci_deinit_endpoint
+(
+ /*[IN]*/
+ usb_device_handle handle,
+ /*[IN]*/
+ uint8_t ep_num,
+ /*[IN]*/
+ uint8_t direction
+)
+{
+ usb_khci_dev_state_struct_t* state_ptr = (usb_khci_dev_state_struct_t*)handle;
+ //volatile USB_MemMapPtr usb_ptr;
+
+ /*before de-initializing cancel all transfers on EP */
+ usb_dci_khci_cancel(handle, ep_num, direction);
+
+ /*Disable the transmit or receive endpoint*/
+ usb_hal_khci_endpoint_shut_down(state_ptr->usbRegBase, ep_num);
+
+ /* un-initialize the structure for this endpoint */
+ usb_hal_khci_bdt_set_address((uint32_t )bdt, ep_num, direction, EVEN_BUFF, USB_LONG_LE_TO_HOST_CONST((uint32_t)USB_UNINITIALIZED_VAL_32));
+ usb_hal_khci_bdt_set_address((uint32_t )bdt, ep_num, direction, ODD_BUFF, USB_LONG_LE_TO_HOST_CONST((uint32_t)USB_UNINITIALIZED_VAL_32));
+ //BD_ADDR(ep_num,direction,EVEN_BUFF) =
+ // USB_LONG_LE_TO_HOST_CONST((uint32_t)USB_UNINITIALIZED_VAL_32);
+ //BD_ADDR(ep_num,direction,ODD_BUFF) =
+ // USB_LONG_LE_TO_HOST_CONST((uint32_t)USB_UNINITIALIZED_VAL_32);
+
+ state_ptr->ep_info[ep_num].max_packet_size =
+ (uint16_t)USB_UNINITIALIZED_VAL_32;
+
+ /* mark this endpoint as de-initialized */
+ state_ptr->ep_info[ep_num].ep_init_flag[direction] = FALSE;
+
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ * @name usb_dci_khci_send
+ * @brief : Sends data. Non-blocking.
+ * @param handle: Handle to USB Device.
+ * @param xd_ptr: Transaction Descriptor.
+ * @return : USB_OK or error code
+ ******************************************************************************/
+usb_status usb_dci_khci_send
+(
+ /*[IN]*/
+ usb_device_handle handle,
+ /*[IN]*/
+ xd_struct_t* xd_ptr
+ )
+{
+ usb_status error = USBERR_TX_FAILED;/* initializing to failed value */
+ uint32_t buf_num_bytes = (uint32_t)(xd_ptr->wtotallength - xd_ptr->wsofar);
+ usb_khci_dev_state_struct_t* state_ptr = (usb_khci_dev_state_struct_t*)handle;
+
+ /* Allocate XD structure from Free List maintained by Device structure,
+ * if it is not any split transaction.
+ */
+ if (xd_ptr->wsofar == 0)
+ {
+ state_ptr->ep_info[xd_ptr->ep_num].send_xd = xd_ptr;
+ //USB_XD_QUEUE_ENQUEUE(&state_ptr->ep_info[xd_ptr->ep_num].xd_queue_send, xd_ptr);
+ //USB_PRINTF("after send ep %d enqueue: xd_head_ptr 0x%x xd_tail_ptr 0x%x\n", xd_ptr->EP_NUM,
+ // state_ptr->EP_INFO[xd_ptr->EP_NUM].xd_queue_send.xd_head_ptr,
+ // state_ptr->EP_INFO[xd_ptr->EP_NUM].xd_queue_send.xd_tail_ptr);
+
+ }
+
+#if 0
+ /* Upper layer wants to send Zero Packet data
+ * Note that this situation will only come when
+ * Upper layer wants to send Zero packet data not
+ * in case of split transaction
+ */
+ if (buf_num_bytes == 0)
+ {
+ error = _usb_khci_ep_write(state_ptr, xd_ptr->ep_num,
+ xd_ptr->wstartaddress, buf_num_bytes, (uint32_t*)&buf_num_bytes);
+
+ if (error != USB_OK)
+ {
+ /* If write returns error release the XD pointer
+ * from Endpoint send queue and return it to Free list of XD pointers.
+ */
+ xd_ptr->bstatus = USB_STATUS_IDLE;
+ //USB_XD_QUEUE_DEQUEUE (&state_ptr->ep_info[xd_ptr->ep_num].xd_queue_send, &xd_ptr);
+ //if (xd_ptr != NULL)
+ // _usb_khci_free_XD(state_ptr, xd_ptr);
+ }
+ return error;
+ }
+#endif
+ if (state_ptr->is_reseting == 0)
+ {
+ /* If not Zero Size packet send the data from here*/
+ error = _usb_khci_ep_write(state_ptr, xd_ptr->ep_num,
+ (uint8_t *)xd_ptr->wstartaddress + xd_ptr->wsofar, buf_num_bytes,
+ (uint32_t*)&buf_num_bytes);
+ }
+
+ if (error != USB_OK)
+ {
+ /* If write returns error release the XD pointer
+ * from Endpoint send queue and return it to Free list of XD pointers.
+ */
+ //xd_ptr->bstatus = USB_STATUS_IDLE;
+ state_ptr->ep_info[xd_ptr->ep_num].send_xd = NULL;
+ //USB_XD_QUEUE_DEQUEUE (&state_ptr->ep_info[xd_ptr->ep_num].xd_queue_send, &xd_ptr);
+ //if (xd_ptr != NULL)
+ usb_dci_khci_free_xd(state_ptr, xd_ptr);
+ }
+ return error;
+}
+
+/**************************************************************************//*!
+ * @name : usb_dci_khci_recv
+ * @brief : Receives data. Non-blocking.
+ * @param handle: Handle to USB Device.
+ * @param xd_ptr: Transaction Descriptor.
+ * @return : USB_OK or error code
+ ******************************************************************************/
+usb_status usb_dci_khci_recv
+(
+ /*[IN]*/
+ usb_device_handle handle,
+ /*[IN]*/
+ xd_struct_t* xd_ptr
+)
+{
+ usb_status error = USBERR_RX_FAILED;/* initializing to failed value */
+ uint32_t buf_num_bytes;
+ uint8_t *buf_ptr;
+ usb_khci_dev_state_struct_t* state_ptr = (usb_khci_dev_state_struct_t*)handle;
+
+ buf_num_bytes = xd_ptr->wtotallength - xd_ptr->wsofar;
+
+ /* Allocate XD structure from Free List maintained by Device structure,
+ * if it is not any split transaction.
+ */
+
+ if (xd_ptr->wsofar == 0)
+ {
+ //USB_XD_QUEUE_ENQUEUE(&state_ptr->ep_info[xd_ptr->ep_num].xd_queue_recv, xd_ptr);
+ state_ptr->ep_info[xd_ptr->ep_num].recv_xd = xd_ptr;
+ }
+
+ /* If the number of bytes to be received is greater than the
+ * maximum data that can be received on the USB bus, then split the
+ * transaction into multiple receive transaction.
+ */
+ if (buf_num_bytes > state_ptr->ep_info[xd_ptr->ep_num].max_packet_size)
+ {
+ buf_num_bytes = state_ptr->ep_info[xd_ptr->ep_num].max_packet_size;
+ }
+
+ /* Send the receive command to the device.*/
+ buf_ptr = (uint8_t *)((uint32_t)xd_ptr->wstartaddress + (uint32_t)xd_ptr->wsofar);
+#if USBCFG_KHCI_4BYTE_ALIGN_FIX
+ if ((_usb_khci_dev_swap_buf_ptr) && ((buf_num_bytes & USB_DMA_ALIGN_MASK) || ((uint32_t)buf_ptr & USB_DMA_ALIGN_MASK)))
+ {
+ xd_ptr->internal_dma_align = FALSE;
+ buf_ptr = (uint8_t*)USB_DMA_ALIGN((int32_t)_usb_khci_dev_swap_buf_ptr);
+ }
+#endif
+ if (state_ptr->is_reseting == 0)
+ {
+ error = _usb_khci_ep_read((usb_khci_dev_state_struct_t*)handle, xd_ptr->ep_num, buf_ptr, buf_num_bytes);
+ }
+
+ if (error != USB_OK)
+ {
+ //USB_XD_QUEUE_DEQUEUE(&state_ptr->ep_info[xd_ptr->ep_num].xd_queue_recv, &xd_ptr);
+ //_usb_khci_free_XD(state_ptr, xd_ptr);
+ state_ptr->ep_info[xd_ptr->ep_num].recv_xd = NULL;
+ usb_dci_khci_free_xd(state_ptr, xd_ptr);
+ }
+
+ if ((buf_num_bytes == 0) && (xd_ptr->ep_num == USB_CONTROL_ENDPOINT))
+ {
+ usb_dci_khci_free_xd(state_ptr, xd_ptr);
+
+ state_ptr->ep_info[USB_CONTROL_ENDPOINT].rx_buf_odd ^= 1;
+ _usb_khci_next_setup_token_prep(state_ptr);
+ // prime the next setup transaction here
+ }
+ return error;
+}
+
+/**************************************************************************//*!*
+ * @name : usb_dci_khci_stall_endpoint
+ * @brief : Stalls the specified endpoint
+ * @param handle: Handle to USB Device.
+ * @param ep_num: End Point Number.
+ * @param direction: USB_SEND or USB_RECV.
+ * @return : USB_OK or error code
+ ******************************************************************************/
+usb_status usb_dci_khci_stall_endpoint
+(
+ /*[IN]*/
+ usb_device_handle handle,
+ /*[IN]*/
+ uint8_t ep_num,
+ /*[IN]*/
+ uint8_t direction
+)
+{
+ usb_khci_dev_state_struct_t* state_ptr = (usb_khci_dev_state_struct_t*)handle;
+ //USB_MemMapPtr usb_ptr;
+
+ /* set the stall flag in device structure to be true */
+ state_ptr->ep_info[ep_num].stall_flag = TRUE;
+ state_ptr->ep_info[ep_num].endpoint_status = USB_STATUS_STALLED;
+
+ /* retiring pending IRPs on stall detection */
+ usb_dci_khci_cancel(handle, ep_num, direction);
+
+ /* If Stall is for Send packet update Send BDT */
+ if (direction)
+ {
+ /* USB_SEND */
+ usb_hal_khci_bdt_set_control((uint32_t )bdt, ep_num, USB_SEND, state_ptr->ep_info[ep_num].tx_buf_odd,
+ USB_LONG_LE_TO_HOST((uint32_t)(USB_BD_BC(state_ptr->ep_info[ep_num].max_packet_size)| USB_BD_OWN | USB_BD_STALL | USB_BD_DTS)));
+ //BD_CTRL_TX(ep_num, state_ptr->ep_info[ep_num].tx_buf_odd) =
+ // USB_LONG_LE_TO_HOST((uint32_t)(USB_BD_BC(state_ptr->ep_info[ep_num].max_packet_size)| USB_BD_OWN | USB_BD_STALL | USB_BD_DTS));
+ }
+ else
+ {
+ /* USB_RECV */
+ usb_hal_khci_bdt_set_control((uint32_t )bdt, ep_num, USB_RECV, state_ptr->ep_info[ep_num].rx_buf_odd,
+ USB_LONG_LE_TO_HOST((uint32_t)(USB_BD_BC(state_ptr->ep_info[ep_num].max_packet_size)| USB_BD_OWN | USB_BD_STALL | USB_BD_DTS)));
+ /* If Stall is for Receive transaction, Update Receive BDT*/
+ //BD_CTRL_RX(ep_num, state_ptr->ep_info[ep_num].rx_buf_odd) =
+ // USB_LONG_LE_TO_HOST((uint32_t)(USB_BD_BC(state_ptr->ep_info[ep_num].max_packet_size) | USB_BD_OWN | USB_BD_STALL | USB_BD_DTS));
+ }
+
+ /* Continue Further processing as the IP stops on receiving
+ * Setup Token.
+ */
+ usb_hal_khci_clr_token_busy(state_ptr->usbRegBase);
+
+ return USB_OK;
+}
+
+/**************************************************************************//*!*
+ * @name : usb_dci_khci_unstall_endpoint
+ * @brief : Unstall the Endpoint in specific direction
+ * @param handle: Handle to USB Device.
+ * @param ep_num: End Point Number.
+ * @param direction: USB_SEND or USB_RECV.
+ * @return : USB_OK or error code
+ ******************************************************************************/
+usb_status usb_dci_khci_unstall_endpoint
+(
+ /*[IN]*/
+ usb_device_handle handle,
+ /*[IN]*/
+ uint8_t ep_num,
+ /*[IN]*/
+ uint8_t direction
+)
+{
+ usb_khci_dev_state_struct_t* state_ptr = (usb_khci_dev_state_struct_t*)handle;
+ //USB_MemMapPtr usb_ptr;
+
+ /* clear the stall flag in device structure */
+ state_ptr->ep_info[ep_num].stall_flag = FALSE;
+ state_ptr->ep_info[ep_num].endpoint_status = USB_STATUS_IDLE;
+
+ usb_hal_khci_endpoint_clr_stall(state_ptr->usbRegBase, ep_num);
+
+ if (direction)
+ {/* USB_SEND */
+ usb_hal_khci_endpoint_enable_handshake(state_ptr->usbRegBase, ep_num, 1);
+ usb_hal_khci_endpoint_set_direction(state_ptr->usbRegBase, ep_num, 1);
+ state_ptr->ep_info[ep_num].tx_data0 = 0;
+ /*BD_CTRL_TX(ep_num, state_ptr->ep_info[ep_num].tx_buf_odd) =
+ USB_LONG_LE_TO_HOST((uint32_t)(USB_BD_BC(state_ptr->ep_info[ep_num].max_packet_size) |
+ USB_BD_DTS | USB_BD_DATA01(0)));*/
+ usb_hal_khci_bdt_set_control((uint32_t )bdt, ep_num, USB_SEND, state_ptr->ep_info[ep_num].tx_buf_odd,
+ USB_LONG_LE_TO_HOST((uint32_t)(USB_BD_BC(state_ptr->ep_info[ep_num].max_packet_size)| USB_BD_DTS | USB_BD_DATA01(0))));
+ }
+ else
+ {/* USB_RECV */
+ usb_hal_khci_endpoint_enable_handshake(state_ptr->usbRegBase, ep_num, 1);
+ usb_hal_khci_endpoint_set_direction(state_ptr->usbRegBase, ep_num, 0);
+ state_ptr->ep_info[ep_num].rx_data0 = 0;
+ if (ep_num == USB_CONTROL_ENDPOINT)
+ {
+ /* something important need to do is toggle the tx buffer odd */
+ //state_ptr->ep_info[USB_CONTROL_ENDPOINT].tx_buf_odd ^= 1;
+ _usb_khci_next_setup_token_prep(state_ptr);
+ }
+ else
+ {
+ usb_hal_khci_bdt_set_control((uint32_t )bdt, ep_num, USB_RECV, state_ptr->ep_info[ep_num].rx_buf_odd,
+ USB_LONG_LE_TO_HOST((uint32_t)(USB_BD_BC(state_ptr->ep_info[ep_num].max_packet_size)| USB_BD_DTS | USB_BD_DATA01(0))));
+ }
+ }
+
+ usb_hal_khci_clr_token_busy(state_ptr->usbRegBase);
+ return USB_OK;
+}
+
+/**************************************************************************//*!*
+ * @name : usb_dci_khci_cancel
+ * @brief : Cancels all pending transfers on an endpoint.
+ * @param handle: Handle to USB Device.
+ * @param ep_num: End Point Number.
+ * @param direction: USB_SEND or USB_RECV.
+ * @return : USB_OK or error code
+ ******************************************************************************/
+usb_status usb_dci_khci_cancel
+(
+ /*[IN]*/
+ usb_device_handle handle,
+ /*[IN]*/
+ uint8_t ep_num,
+ /*[IN]*/
+ uint8_t direction
+)
+{
+ usb_event_struct_t event;
+ xd_struct_t* xd_ptr = NULL;
+ usb_khci_dev_state_struct_t* state_ptr = (usb_khci_dev_state_struct_t*)handle;
+
+ if (direction == USB_RECV)
+ {
+ xd_ptr = state_ptr->ep_info[ep_num].recv_xd;
+ state_ptr->ep_info[ep_num].recv_xd = NULL;
+ }
+ else
+ {
+ xd_ptr = state_ptr->ep_info[ep_num].send_xd;
+ state_ptr->ep_info[ep_num].send_xd = NULL;
+ }
+ if (xd_ptr != NULL)
+ {
+ usb_dci_khci_free_xd(handle, xd_ptr);
+ event.len = 0xFFFFFFFF;
+ event.buffer_ptr = xd_ptr->wstartaddress;
+ event.handle = (usb_device_handle)state_ptr->upper_layer_handle;
+ event.ep_num = ep_num;
+ event.setup = FALSE;
+ event.direction = direction;
+ _usb_device_call_service(ep_num, &event);
+ }
+#if 0
+ if (direction)
+ {
+ tempQueue = &state_ptr->ep_info[ep_num].xd_queue_send;
+ }
+ else
+ {
+ tempQueue = &state_ptr->ep_info[ep_num].xd_queue_recv;
+ }
+
+ /* Empty the queue and add the XD release structure to the Free list*/
+ do
+ {
+ USB_XD_QUEUE_DEQUEUE(tempQueue, &xd_temp_ptr);
+
+ if (xd_temp_ptr)
+ {
+ xd_temp_ptr->bstatus = USB_STATUS_IDLE;
+ event.len = 0xFFFFFFFF;
+ event.buffer_ptr = xd_temp_ptr->wstartaddress;
+ event.handle = (usb_device_handle)state_ptr->upper_layer_handle;
+ event.ep_num = ep_num;
+ event.setup = FALSE;
+ event.direction = direction;
+ _usb_khci_free_XD(state_ptr, xd_temp_ptr);
+ _usb_device_call_service(ep_num,&event);
+ }
+ }
+ while (xd_temp_ptr);
+#endif
+ return USB_OK;
+}
+
+/**************************************************************************//*!*
+ * @name : usb_dci_khci_set_addr
+ * @brief : Set device address.
+ * @param handle : Device handle.
+ * @param addr : Address to be set into Device Address register.
+ * @return : Returns USB_OK or error code.
+ ******************************************************************************/
+usb_status usb_dci_khci_set_addr
+(
+ /*[IN]*/
+ usb_device_handle handle,
+ /*[IN]*/
+ uint8_t addr
+)
+{
+ usb_khci_dev_state_struct_t* state_ptr = (usb_khci_dev_state_struct_t*)handle;
+ //volatile USB_MemMapPtr usb_ptr;
+
+ /* Update USB address in Device registers. This 7-bit value
+ * defines the USB address that the USB Module decodes
+ * in device mode
+ */
+ usb_hal_khci_set_device_addr(state_ptr->usbRegBase, addr);
+
+ /* Update the USB device address in Device Info structure for
+ * Future References.
+ */
+ state_ptr->device_address = addr;
+ /* Set the Device Start as Address Assigned State.*/
+ state_ptr->usb_state = USB_STATE_ADDRESS;
+
+ return USB_OK;
+}
+
+/**************************************************************************//*!*
+ * @name : usb_dci_khci_shutdown
+ * @brief : Shuts down the usbfs Device Controller
+ * Note: There is no function in MQX to uninstall ISR.
+ * Hence ISR is not Uninstalled here.However, installing
+ * ISR twice will not have any negative impact.
+ * @param handle : Device handle.
+ * @return : Returns USB_OK or error code.
+ ******************************************************************************/
+usb_status usb_dci_khci_shutdown
+(
+ /*[IN]*/
+ usb_device_handle handle
+ )
+{
+#ifdef USBCFG_OTG
+ usb_otg_state_struct_t * usb_otg_struct_ptr = (usb_otg_state_struct_t *)g_usb_otg_handle;
+ usb_otg_status_t * otg_status_ptr = &usb_otg_struct_ptr->otg_status;
+#endif
+ usb_khci_dev_state_struct_t* state_ptr = (usb_khci_dev_state_struct_t*)handle;
+
+ /* Reset the Control Register */
+ //usb_hal_khci_reset_controller(handle->usbRegBase);/* disables the USB MODULE */
+ usb_hal_khci_disable_interrupts(state_ptr->usbRegBase, 0xFF);
+ usb_hal_khci_set_device_addr(state_ptr->usbRegBase, 0);
+
+ usb_hal_khci_clear_control_register(state_ptr->usbRegBase);
+
+ usb_hal_khci_enable_pull_down(state_ptr->usbRegBase);
+ usb_hal_khci_set_suspend(state_ptr->usbRegBase);
+
+ state_ptr->usb_state = USB_STATE_UNKNOWN;
+ OS_Mutex_destroy(state_ptr->mutex);
+
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ if (NULL != g_khci_data_ptr)
+ {
+ OS_Mem_free(g_khci_data_ptr);
+ g_khci_data_ptr = NULL;
+ }
+
+#if (FSL_FEATURE_USB_KHCI_USB_RAM == 0)
+ if (NULL != g_khci_bdt_ptr)
+ {
+ OS_Mem_free(g_khci_bdt_ptr);
+ g_khci_bdt_ptr = NULL;
+ }
+#endif
+
+#endif
+#ifdef USBCFG_OTG
+ otg_status_ptr->active_stack = USB_ACTIVE_STACK_NONE;
+ usb_otg_struct_ptr->dev_inst_ptr = NULL;
+#endif
+ return USB_OK;
+}
+
+#if USBCFG_DEV_ADVANCED_SUSPEND_RESUME
+/**************************************************************************//*!*
+ * @name : usb_dci_khci_assert_resume
+ * @brief : Resume signaling for remote wakeup
+ * @param handle: Handle to USB Device.
+ * @return : USB_OK or error code
+ ******************************************************************************/
+usb_status usb_dci_khci_assert_resume
+(
+ /*[IN]*/
+ usb_device_handle handle
+)
+{
+ uint16_t delay_count;
+ //volatile USB_MemMapPtr usb_ptr;
+ usb_khci_dev_state_struct_t* state_ptr = (usb_khci_dev_state_struct_t*)handle;
+
+ /* clear resume FLAG*/
+ usb_hal_khci_clr_interrupt(handle->usbRegBase, INTR_RESUME);
+
+ /* Disable RESUME Interrupt */
+// usb_ptr->INTEN &= ~USB_INTEN_RESUME_EN_MASK; //already done in RESUME interrupt
+ /* continue processing */
+ usb_hal_khci_clr_token_busy(handle->usbRegBase);
+
+ /* Start RESUME signaling and make SUSPEND bit 0*/
+ usb_hal_khci_start_resume(handle->usbRegBase);
+
+ /* Set RESUME line for 1-15 ms*/
+ delay_count = ASSERT_RESUME_DELAY_COUNT;
+ do
+ {
+ delay_count--;
+ }while (delay_count);
+
+ /* Stop RESUME signaling */
+ usb_hal_khci_stop_resume(handle->usbRegBase);
+
+ return USB_OK;
+}
+#endif
+
+/**************************************************************************//*!*
+ * @name : usb_dci_khci_get_endpoint_status
+ * @brief : Get Endpoint Transfer Status
+ * @param handle: Handle to USB Device.
+ * @param component: End Point Number.
+ * @param endp_status: Variable containing endpint status..
+ * @return : USB_OK or error code
+ ******************************************************************************/
+usb_status usb_dci_khci_get_endpoint_status
+(
+ /*[IN]*/
+ usb_device_handle handle,
+ /*[IN]*/
+ uint8_t component,
+ /*[OUT]*/
+ uint16_t* endp_status
+)
+{
+ usb_khci_dev_state_struct_t* state_ptr = (usb_khci_dev_state_struct_t*)handle;
+
+ *endp_status = state_ptr->ep_info[component & USB_STATUS_ENDPOINT_NUMBER_MASK].endpoint_status;
+ return USB_OK;
+}
+
+/**************************************************************************//*!*
+ * @name : usb_dci_khci_set_endpoint_status
+ * @brief : Set Endpoint Transfer Status
+ * @param handle: Handle to USB Device.
+ * @param component: End Point Number.
+ * @param setting: Variable containing new settings..
+ * @return : USB_OK or error code
+ ******************************************************************************/
+usb_status usb_dci_khci_set_endpoint_status
+(
+ /*[IN]*/
+ usb_device_handle handle,
+ /*[IN]*/
+ uint8_t component,
+ /*[IN]*/
+ uint16_t setting
+)
+{
+ usb_khci_dev_state_struct_t* state_ptr = (usb_khci_dev_state_struct_t*)handle;
+ usb_status error = USBERR_ERROR;/* initializing */
+ uint8_t ep_num = (uint8_t)(component & USB_STATUS_ENDPOINT_NUMBER_MASK);
+ /* direction is in most significant bit */
+ uint8_t direction = (uint8_t)((component >> COMPONENT_PREPARE_SHIFT) & 1U);
+
+ state_ptr->ep_info[ep_num].endpoint_status = setting;
+
+ /* check if the setting was to halt endpoint or unhalt it*/
+ if (setting == USB_STATUS_STALLED)
+ { /* stall the endpoint */
+ error = usb_dci_khci_stall_endpoint(handle, ep_num, direction);
+ }
+ else if ((setting == USB_STATUS_IDLE) && (state_ptr->ep_info[ep_num].stall_flag))
+ {
+ /* unstall the endpoint*/
+ /* need to update the direction here for unstalling
+ (as it was not passed from above layers for unstall because the
+ STAT register doesn't get updated in STALL ISR and we need to unstall
+ directly from STALL_SERVICE for CONTROL ENDPOINT. Therefore, this
+ method of unstall was employed to make the structure generic)*/
+ direction = state_ptr->ep_info[ep_num].direction;
+ error = usb_dci_khci_unstall_endpoint(handle, ep_num, direction);
+ }
+
+ return error;
+}
+
+/*FUNCTION*----------------------------------------------------------------
+ *
+ * Function Name : usb_dci_khci_set_status
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Provides API to set internal state
+ *
+ *END*--------------------------------------------------------------------*/
+usb_status usb_dci_khci_set_status
+(
+ /* [IN] Handle to the usb device */
+ usb_device_handle handle,
+
+ /* [IN] What to set the error of */
+ uint8_t component,
+
+ /* [IN] What to set the error to */
+ uint16_t setting
+)
+{
+ usb_khci_dev_state_struct_t* usb_dev_ptr;
+ uint8_t error = USB_OK;
+
+ usb_dev_ptr = (usb_khci_dev_state_struct_t*)handle;
+ OS_Mutex_lock(usb_dev_ptr->mutex);
+
+ switch(component)
+ {
+ case USB_STATUS_DEVICE_STATE:
+ usb_dev_ptr->usb_state = setting;
+ break;
+ case USB_STATUS_DEVICE:
+ usb_dev_ptr->usb_device_status = setting;
+ break;
+ case USB_STATUS_INTERFACE:
+ break;
+ case USB_STATUS_CURRENT_CONFIG:
+ usb_dev_ptr->usb_curr_config = setting;
+ break;
+ case USB_STATUS_SOF_COUNT:
+ usb_dev_ptr->usb_sof_count = setting;
+ break;
+#ifdef USBCFG_OTG
+ case USB_STATUS_OTG:
+ usb_dev_ptr->usb_otg_status = setting;
+ break;
+#endif
+ default:
+
+ break;
+ }/* Endswitch */
+
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return error;
+} /* EndBody */
+
+/*FUNCTION*----------------------------------------------------------------
+ *
+ * Function Name : usb_dci_khci_get_status
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Provides API to access the USB internal state.
+ *
+ *END*--------------------------------------------------------------------*/
+usb_status usb_dci_khci_get_status
+(
+ /* [IN] Handle to the USB device */
+ usb_device_handle handle,
+
+ /* [IN] What to get the error of */
+ uint8_t component,
+
+ /* [OUT] The requested error */
+ uint16_t* error
+)
+{
+ usb_khci_dev_state_struct_t* usb_dev_ptr;
+
+ usb_dev_ptr = (usb_khci_dev_state_struct_t*)handle;
+
+ OS_Mutex_lock(usb_dev_ptr->mutex);
+ switch(component)
+ {
+ case USB_STATUS_DEVICE_STATE:
+ *error = usb_dev_ptr->usb_state;
+ break;
+
+ case USB_STATUS_DEVICE:
+ *error = usb_dev_ptr->usb_device_status;
+ break;
+
+ case USB_STATUS_INTERFACE:
+ break;
+
+ case USB_STATUS_ADDRESS:
+ *error = usb_dev_ptr->device_address;
+ break;
+
+ case USB_STATUS_CURRENT_CONFIG:
+ *error = usb_dev_ptr->usb_curr_config;
+ break;
+ case USB_STATUS_SOF_COUNT:
+ *error = usb_dev_ptr->usb_sof_count;
+ break;
+ case USB_STATUS_SPEED:
+ *error = usb_dev_ptr->speed;
+ break;
+#ifdef USBCFG_OTG
+ case USB_STATUS_OTG:
+ *error = usb_dev_ptr->usb_otg_status;
+ break;
+#endif
+ default:
+ break;
+ } /* Endswitch */
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USB_OK;
+}
+
+usb_status usb_dci_khci_reset
+(
+ /* [IN] Handle to the USB device */
+ usb_device_handle handle
+)
+{
+ usb_khci_dev_state_struct_t* usb_dev_ptr;
+ uint8_t cnt = 0;
+
+ usb_dev_ptr = (usb_khci_dev_state_struct_t*)handle;
+
+ /* De-Init All the End Point. */
+ for (cnt = 0; cnt < USBCFG_DEV_MAX_ENDPOINTS; cnt++)
+ {
+ usb_dci_khci_deinit_endpoint(usb_dev_ptr, cnt, USB_RECV);
+ usb_dci_khci_deinit_endpoint(usb_dev_ptr, cnt, USB_SEND);
+ }
+
+ /* Re-Initialize All the end point */
+ _usb_khci_reset_ep_state((usb_khci_dev_state_struct_t*)usb_dev_ptr);
+ usb_dci_khci_init_xd((usb_device_handle)usb_dev_ptr);
+ usb_dev_ptr->is_reseting = 0;
+ return USB_OK;
+}
+#endif
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/khci_dev.h b/KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/khci_dev.h
new file mode 100644
index 0000000..97f4f81
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/khci_dev.h
@@ -0,0 +1,75 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2009, 2015 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: khci_dev.h$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ * This file contains the macros, function prototypes and data structure
+ * definitions required by the Full Speed USB Device Controller driver.
+ *
+ *END************************************************************************/
+
+#ifndef __khci_dev_h__
+#define __khci_dev_h__
+
+#define KHCI_MAX_ENDPOINT (16)
+
+/***************************************
+ **
+ ** Prototypes
+ **/
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+ usb_status usb_dci_khci_preinit(usb_device_handle upper_layer_handle, usb_device_handle *handle_ptr);
+ usb_status usb_dci_khci_postinit(uint8_t controller_id, usb_device_handle handle);
+ usb_status usb_dci_khci_init(uint8_t controller_id, usb_device_handle handle);
+ usb_status usb_dci_khci_send(usb_device_handle handle, xd_struct_t* xd_ptr);
+ usb_status usb_dci_khci_recv(usb_device_handle handle, xd_struct_t* xd_ptr);
+ usb_status usb_dci_khci_cancel(usb_device_handle handle, uint8_t ep_num, uint8_t direction);
+ usb_status usb_dci_khci_set_addr(usb_device_handle handle, uint8_t addr);
+ usb_status usb_dci_khci_shutdown(usb_device_handle handle);
+//usb_status usb_dci_khci_get_setup_data(usb_device_handle handle, uint8_t, uint8_t *);
+#if ((defined USBCFG_DEV_ADVANCED_SUSPEND_RESUME) && (USBCFG_DEV_ADVANCED_SUSPEND_RESUME))
+ usb_status usb_dci_khci_assert_resume(usb_device_handle handle);
+#endif
+ usb_status usb_dci_khci_init_endpoint(usb_device_handle handle, xd_struct_t* xd_ptr);
+ usb_status usb_dci_khci_stall_endpoint(usb_device_handle handle, uint8_t ep_num, uint8_t direction);
+ usb_status usb_dci_khci_unstall_endpoint(usb_device_handle handle, uint8_t ep_num, uint8_t direction);
+ usb_status usb_dci_khci_deinit_endpoint(usb_device_handle handle, uint8_t ep_num, uint8_t direction);
+ usb_status usb_dci_khci_get_endpoint_status(usb_device_handle handle, uint8_t component, uint16_t *endp_status);
+ usb_status usb_dci_khci_set_endpoint_status(usb_device_handle handle, uint8_t component, uint16_t setting);
+//usb_status usb_dci_khci_get_transfer_status(usb_device_handle handle,uint8_t,uint8_t);
+ usb_status usb_dci_khci_get_status(usb_device_handle handle, uint8_t component, uint16_t *error);
+ usb_status usb_dci_khci_set_status(usb_device_handle handle, uint8_t component, uint16_t setting);
+ usb_status usb_dci_khci_get_xd(usb_device_handle handle, xd_struct_t** xd_ptr_ptr);
+ usb_status usb_dci_khci_reset(usb_device_handle handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/khci_dev_misc.h b/KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/khci_dev_misc.h
new file mode 100644
index 0000000..e149332
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/controller/khci/khci_dev_misc.h
@@ -0,0 +1,146 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2009, 2013 - 2014 Freescale Semiconductor;
+* All Rights Reserved
+*
+* Copyright (c) 1989-2008 ARC International;
+* All Rights Reserved
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: khci_dev_misc.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+* This file contains the private defines, externs and data structure
+* definitions required by the Full Speed USB Device driver.
+*
+*END************************************************************************/
+
+#ifndef __khci_dev_misc_h__
+#define __khci_dev_misc_h__ 1
+
+#define EP_DISABLE (0)
+#define ASSERT_RESUME_DELAY_COUNT (8000)/* Delay for assert resume */
+#define BYTES_512 (512)
+#define BYTES_1024 (1024)
+#define ENDPOINT_NUMBER_SHIFT (4) /* endpoint shift & mask to */
+#define ENDPOINT_NUMBER_MASK (0xf0)/* use in setting and getting status */
+#define MAX_FS_NON_ISO_EP_BUFFER_SIZE (64)
+#define MAX_FS_ISO_EP_BUFFER_SIZE (1023)
+#define SETUP_PACKET_LENGTH (8)
+#define COMPONENT_PREPARE_SHIFT (7)
+
+#define ZERO_LENGTH (0)
+#define USB_SETUP_TOKEN (0x0d)/* Setup Token PID */
+#define FRAME_HIGH_BYTE_SHIFT (8)
+
+#define MAX_USB_DEVICES (1)
+#define ODD_BUFF (1)
+#define EVEN_BUFF (0)
+
+/* Define USB buffer descriptor definitions in case of their lack */
+#ifndef USB_BD_BC
+# define USB_BD_BC(n) (((uint32_t)n & 0x3ff) << 16)
+# define USB_BD_OWN 0x80
+# define USB_BD_DATA01(n) (((uint32_t)n & 1) << 6)
+# define USB_BD_DATA0 USB_BD_DATA01(0)
+# define USB_BD_DATA1 USB_BD_DATA01(1)
+# define USB_BD_KEEP 0x20
+# define USB_BD_NINC 0x10
+# define USB_BD_DTS 0x08
+# define USB_BD_STALL 0x04
+# define USB_BD_PID(n) (((uint32_t)n & 0x0f) << 2)
+#endif
+
+#ifndef USB_TOKEN_TOKENPID_SETUP
+# define USB_TOKEN_TOKENPID_OUT USB_TOKEN_TOKENPID(0x1)
+# define USB_TOKEN_TOKENPID_IN USB_TOKEN_TOKENPID(0x9)
+# define USB_TOKEN_TOKENPID_SETUP USB_TOKEN_TOKENPID(0xD)
+#endif
+
+typedef struct _usb_ep_info_struct
+{
+ //USB_XD_QUEUE xd_queue_send; /* FIFO queue for all XDs on this endpoint */
+ //USB_XD_QUEUE xd_queue_recv;
+ struct xd_struct* send_xd;
+ struct xd_struct* recv_xd;
+ uint16_t max_packet_size;
+ uint8_t endpoint_status;
+ uint8_t stall_flag;
+ /* Endpoint initialization flag for both direction */
+ uint8_t ep_init_flag[2];
+ uint8_t type;
+ uint8_t direction; /* for usb_device_call_service */
+ uint8_t tx_data0;
+ uint8_t rx_data0;
+ uint8_t tx_buf_odd;
+ uint8_t rx_buf_odd; /* next buffer is odd */
+} usb_ep_info_struct_t;
+
+/* The USB Device State Structure */
+typedef struct _usb_khci_device_state_struct
+{
+ uint32_t controller_id; /* Device controller ID */
+ usb_device_handle upper_layer_handle;
+ void* dev_ptr; /* Device Controller Register base address */
+ struct xd_struct* xd_base;
+ struct xd_struct* xd_head; /* Head Transaction descriptors */
+ struct xd_struct* xd_tail; /* Tail Transaction descriptors */
+ uint32_t xd_entries;
+ os_mutex_handle mutex;
+ uint32_t usbRegBase;
+
+ /* These fields are kept only for USB_shutdown() */
+ uint16_t usb_state;
+ uint16_t usb_device_status;
+ uint16_t usb_sof_count;
+ uint16_t errors;
+ uint16_t usb_dev_state_b4_suspend;
+ uint16_t usb_curr_config;
+ uint8_t dev_vec; /* Interrupt vector number for USB OTG */
+ uint8_t speed; /* Low Speed, High Speed, Full Speed */
+ uint8_t max_endpoints; /* Max endpoints supported by this device */
+ uint8_t device_address;
+ uint8_t * setup_buff;
+ usb_ep_info_struct_t ep_info[USBCFG_DEV_MAX_ENDPOINTS];
+#ifdef USBCFG_OTG
+ uint16_t usb_otg_status;
+ usb_otg_handle otg_handle;
+ uint8_t otg_attr_srp;
+ uint8_t otg_attr_hnp;
+#endif
+ uint8_t is_reseting;
+} usb_khci_dev_state_struct_t;
+
+/***************************************
+**
+** Prototypes
+**
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_dev.c b/KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_dev.c
new file mode 100644
index 0000000..c2d6979
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_dev.c
@@ -0,0 +1,1560 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2008, 2013 - 2014 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ * Copyright (c) 1989-2008 ARC International;
+ * All Rights Reserved
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: usb_dev.c$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ * This file contains the main USB device API functions that will be
+ * used by most applications.
+ *
+ *END*********************************************************************/
+#include "usb_device_config.h"
+#if USBCFG_DEV_KHCI || USBCFG_DEV_EHCI
+#include "usb.h"
+#include "usb_device_stack_interface.h"
+
+//#define USBCFG_DEV_USE_TASK (0)
+#define USBCFG_DEV_SERVICE_MSG_CNT (8)
+#define MSG_SIZE_IN_MAX_TYPE (1 + (sizeof(usb_event_struct_t) - 1) / sizeof(uint32_t))
+
+#include "usb_dev.h"
+#include "khci_dev_misc.h"
+#ifdef USBCFG_OTG
+#include "usb_otg_dev_api.h"
+#endif
+
+#if ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM) || ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK)))
+ #if defined( __ICCARM__ )
+ #pragma data_alignment=32
+ __no_init usb_dev_data_t g_usb_dev_data[USBCFG_DEV_NUM];
+ #elif defined (__CC_ARM) || defined(__GNUC__)
+ __attribute__((aligned(32))) usb_dev_data_t g_usb_dev_data[USBCFG_DEV_NUM];
+ #else
+ #error Unsupported compiler, please use IAR, Keil or arm gcc compiler and rebuild the project.
+ #endif
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ usb_dev_data_t* g_usb_dev_data_ptr[USBCFG_DEV_NUM] = {NULL};
+#endif
+
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM)
+#define OS_Mutex_lock(_M_) OS_Lock()
+#define OS_Mutex_unlock(_M_) OS_Unlock()
+#endif
+#define USB_DEV_HANDLE_OCCUPIED ((uint8_t)1)
+#define USB_DEV_HANDLE_FREE ((uint8_t)0)
+
+#if USBCFG_DEV_USE_TASK
+#define USB_DEVICE_TASK_TEMPLATE_INDEX 0
+
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX) /* USB stack running on MQX */
+#define USB_DEVICE_TASK_ADDRESS _usb_dev_task_stun
+
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM) /* USB stack running on BM */
+#define USB_DEVICE_TASK_ADDRESS _usb_dev_task
+
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK)
+#if USE_RTOS
+#define USB_DEVICE_TASK_ADDRESS _usb_dev_task_stun
+#else
+#define USB_DEVICE_TASK_ADDRESS _usb_dev_task
+#endif
+
+#endif
+
+#define USB_DEVICE_TASK_PRIORITY (6)
+#define USB_DEVICE_TASK_STACKSIZE (3500)
+#define USB_DEVICE_TASK_NAME "Device Task"
+#define USB_DEVICE_TASK_ATTRIBUTES (0)
+#define USB_DEVICE_TASK_CREATION_PARAMETER (0)
+#define USB_DEVICE_TASK_DEFAULT_TIME_SLICE (0)
+
+#endif
+extern usb_status bsp_usb_dev_init(uint8_t controller_id);
+#ifdef USBCFG_OTG
+extern usb_status bsp_usb_otg_dev_init(uint8_t controller_id);
+#endif
+#if USBCFG_DEV_KHCI && USBCFG_DEV_DETACH_ENABLE && USBCFG_DEV_IO_DETACH_ENABLE
+extern int32_t bsp_usb_detach_init(uint8_t controller_id);
+#endif
+extern void USB_Control_Service (void* handle, usb_event_struct_t* event,void* arg);
+extern void USB_Reset_Service(void* handle, usb_event_struct_t* event, void* arg);
+extern void USB_Error_Service(void* handle, usb_event_struct_t* event, void* arg);
+extern void USB_Suspend_Service(void* handle, usb_event_struct_t* event,void* arg);
+extern void USB_Resume_Service(void* handle,usb_event_struct_t* event,void* arg );
+
+static usb_dev_state_struct_t g_usb_dev[USBCFG_DEV_NUM] = {{0}};
+#if USBCFG_DEV_KHCI
+extern const usb_dev_interface_functions_struct_t _usb_khci_dev_function_table;
+#endif
+#if USBCFG_DEV_EHCI
+extern const usb_dev_interface_functions_struct_t _usb_ehci_dev_function_table;
+#endif
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : _usb_device_get_handle
+ * Returned Value : NULL
+ * Comments :
+ * This function is used to get one unused device object
+ *
+ *END*-----------------------------------------------------------------*/
+static usb_dev_state_struct_t* _usb_device_get_handle
+(
+ void
+)
+{
+ uint8_t i = 0;
+
+ for (; i < USBCFG_DEV_NUM; i++)
+ {
+ if (g_usb_dev[i].occupied != USB_DEV_HANDLE_OCCUPIED)
+ {
+ OS_Mem_zero(&g_usb_dev[i], sizeof(usb_dev_state_struct_t));
+ g_usb_dev[i].occupied = USB_DEV_HANDLE_OCCUPIED;
+ g_usb_dev[i].dev_index = i;
+ return &g_usb_dev[i];
+ }
+ }
+ return NULL;
+}
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : _usb_device_release_handle
+ * Returned Value : NULL
+ * Comments :
+ * This function is used to set one used device object to free
+ *
+ *END*-----------------------------------------------------------------*/
+static void _usb_device_release_handle
+(
+usb_dev_state_struct_t *usb_dev
+)
+{
+ usb_dev->occupied = USB_DEV_HANDLE_FREE;
+}
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : _usb_device_get_DCI
+ * Returned Value : NULL
+ * Comments :
+ * This function is used to get the device controller's interface table pointer
+ *
+ *END*-----------------------------------------------------------------*/
+static void _usb_device_get_DCI
+(
+ uint8_t controller_id,
+ const usb_dev_interface_functions_struct_t ** controller_if_ptr
+)
+{
+#if USBCFG_DEV_KHCI
+ if ((controller_id == USB_CONTROLLER_KHCI_0) || ((controller_id == USB_CONTROLLER_KHCI_1)))
+ {
+ *controller_if_ptr = (usb_dev_interface_functions_struct_t const*)&_usb_khci_dev_function_table;
+ }
+#endif
+
+#if USBCFG_DEV_EHCI
+ if ((controller_id == USB_CONTROLLER_EHCI_0) || (controller_id == USB_CONTROLLER_EHCI_1))
+ {
+ *controller_if_ptr = &_usb_ehci_dev_function_table;
+ }
+#endif
+}
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : _usb_device_shutdown
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Shutdown an initialized USB device
+ *
+ *END*-----------------------------------------------------------------*/
+static usb_status _usb_device_shutdown
+(
+ /* [IN] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle
+)
+{
+ usb_status error;
+ usb_dev_state_struct_t* usb_dev_ptr;
+
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+#if USBCFG_DEV_USE_TASK
+
+ if (usb_dev_ptr->task_id != (uint32_t)OS_TASK_ERROR)
+ {
+ OS_Task_delete(usb_dev_ptr->task_id);
+ }
+ if (NULL != usb_dev_ptr->usb_dev_service_que)
+ {
+ OS_MsgQ_destroy(usb_dev_ptr->usb_dev_service_que);
+ }
+#endif
+ if (usb_dev_ptr->usb_dev_interface->dev_shutdown != NULL)
+ {
+ error = (usb_dev_ptr->usb_dev_interface)->dev_shutdown(usb_dev_ptr->controller_handle);
+ return error;
+ }
+ else
+ {
+#if _DEBUG
+ USB_PRINTF("_usb_device_shutdown: DEV_SHUTDOWN is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+} /* EndBody */
+
+/*FUNCTION*----------------------------------------------------------------
+ *
+ * Function Name : usb_device_call_service
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Calls the appropriate service for the specified type, if one is
+ * registered. Used internally only.
+ *
+ *END*--------------------------------------------------------------------*/
+usb_status _usb_device_call_service_internal
+(
+ /* [IN] pointer to usb device status structure */
+ usb_dev_state_struct_t* usb_dev_ptr,
+ /* [IN] pointer to event structure */
+ usb_event_struct_t* event
+)
+{
+ service_struct_t* service_ptr = NULL;
+ uint32_t i;
+
+ /* Needs mutual exclusion */
+ //OS_Mutex_lock(usb_dev_ptr->mutex);
+ switch (event->type)
+ {
+ case USB_SERVICE_EP0:
+ USB_Control_Service(&usb_dev_ptr->usb_framework, event, NULL);
+ break;
+ case USB_SERVICE_BUS_RESET:
+ USB_Reset_Service(&usb_dev_ptr->usb_framework, event, NULL);
+ break;
+#if USBCFG_DEV_ADVANCED_SUSPEND_RESUME
+ case USB_SERVICE_SUSPEND:
+ USB_Suspend_Service(&usb_dev_ptr->usb_framework, event, NULL);
+ break;
+ case USB_SERVICE_RESUME:
+ USB_Resume_Service(&usb_dev_ptr->usb_framework, event, NULL);
+ break;
+#endif
+#if USBCFG_DEV_KHCI_ADVANCED_ERROR_HANDLING
+ case USB_SERVICE_ERROR:
+ USB_Error_Service(&usb_dev_ptr->usb_framework, event, NULL);
+ break;
+#endif
+#if USBCFG_DEV_DETACH_ENABLE
+ case USB_SERVICE_DETACH:
+ USB_Detach_Service(&usb_dev_ptr->usb_framework, event, NULL);
+ break;
+#endif
+ default:
+ break;
+ } /* Endswitch */
+
+ /* Search for an existing entry for type */
+ for (i = 0; i < MAX_DEVICE_SERVICE_NUMBER; i++)
+ {
+ service_ptr = &usb_dev_ptr->services[i];
+ if (service_ptr->type == event->type)
+ {
+ service_ptr->service(event,service_ptr->arg);
+ //OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USB_OK;
+ }
+ }
+
+ //OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USBERR_CLOSED_SERVICE;
+} /* EndBody */
+
+#if USBCFG_DEV_USE_TASK
+static void _usb_dev_task
+(
+ void* dev_inst_ptr
+)
+{
+ usb_dev_state_struct_t* usb_dev_ptr = (usb_dev_state_struct_t*)dev_inst_ptr;
+ static usb_event_struct_t msg = {0};
+
+ //if (!OS_MsgQ_Is_Empty(usb_device_ptr->isr_que,&msg))
+ while (!OS_MsgQ_recv(usb_dev_ptr->usb_dev_service_que, (uint32_t *) &msg, OS_MSGQ_RECEIVE_BLOCK_ON_EMPTY, 10))
+ {
+ _usb_device_call_service_internal(usb_dev_ptr, &msg);
+ }
+}
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : _usb_khci_task_stun
+ * Returned Value : none
+ * Comments :
+ * KHCI task
+ *END*-----------------------------------------------------------------*/
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX) || ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK) && USE_RTOS)
+static void _usb_dev_task_stun
+(
+ void* dev_inst_ptr
+)
+{
+ while (1)
+ {
+ _usb_dev_task(dev_inst_ptr);
+ }
+}
+#endif
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : _usb_task_create
+ * Returned Value : error or USB_OK
+ * Comments :
+ * Create device task
+ *END*-----------------------------------------------------------------*/
+static usb_status _usb_dev_task_create
+(
+ usb_device_handle handle
+)
+{
+ //USB_STATUS status;
+ //task_id = _task_create_blocked(0, 0, (uint32_t)&task_template);
+ usb_dev_state_struct_t* usb_dev_ptr;
+
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+ usb_dev_ptr->task_id = OS_Task_create(USB_DEVICE_TASK_ADDRESS, (void*)handle, (uint32_t)USB_DEVICE_TASK_PRIORITY, USB_DEVICE_TASK_STACKSIZE, USB_DEVICE_TASK_NAME, NULL);
+
+ if (usb_dev_ptr->task_id == (uint32_t)OS_TASK_ERROR)
+ {
+ return USBERR_ERROR;
+ }
+
+ //_task_ready(_task_get_td(task_id));
+ //OS_Task_resume(task_id);
+
+ return USB_OK;
+}
+
+#endif
+
+/*FUNCTION*----------------------------------------------------------------
+ *
+ * Function Name : usb_device_call_service
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Calls the appropriate service for the specified type, if one is
+ * registered. Used internally only.
+ *
+ *END*--------------------------------------------------------------------*/
+usb_status _usb_device_call_service
+(
+ /* [IN] Type of service or endpoint */
+ uint8_t type,
+ /* [IN] pointer to event structure */
+ usb_event_struct_t* event
+)
+{
+ usb_dev_state_struct_t* usb_dev_ptr;
+ usb_dev_ptr = (usb_dev_state_struct_t*)event->handle;
+
+ event->type = type;
+ if((type & 0x7F) && ((type & 0x7F) < 0x10))
+ {
+ event->type = (uint8_t)(((uint8_t)(event->direction << 7)) | (uint8_t)(type & 0x7F));
+ }
+#if USBCFG_DEV_USE_TASK
+ if (0 != OS_MsgQ_send(usb_dev_ptr->usb_dev_service_que, (void *)event, 0))
+ {
+ return USBERR_ALLOC_STATE;
+ }
+ return USB_OK;
+#else
+ return _usb_device_call_service_internal(usb_dev_ptr, event);
+#endif
+
+}
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_set_address
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Sets the device address as assigned by the host during enumeration
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_set_address
+(
+ /* [IN] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle,
+ /* [IN] the USB address to be set in the hardware */
+ uint8_t address
+)
+{
+ usb_dev_state_struct_t* usb_dev_ptr;
+ usb_status error;
+
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+
+ if ((usb_dev_ptr->usb_dev_interface)->dev_set_address != NULL)
+ {
+ error = (usb_dev_ptr->usb_dev_interface)->dev_set_address(usb_dev_ptr->controller_handle, address);
+ return error;
+ }
+ else
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_set_address: DEV_SET_ADDRESS is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+
+}
+
+/*FUNCTION*----------------------------------------------------------------
+ *
+ * Function Name : usb_device_get_status
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Provides API to access the USB internal state.
+ *
+ *END*--------------------------------------------------------------------*/
+usb_status usb_device_get_status
+(
+ /* [IN] Handle to the USB device */
+ usb_device_handle handle,
+ /* [IN] What to get the error of */
+ uint8_t component,
+ /* [OUT] The requested error */
+ uint16_t* error
+)
+{ /* Body */
+ usb_dev_state_struct_t* usb_dev_ptr;
+
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+
+ OS_Mutex_lock(usb_dev_ptr->mutex);
+ if (component & USB_STATUS_ENDPOINT)
+ {
+ if ((usb_dev_ptr->usb_dev_interface)->dev_get_endpoint_status != NULL)
+ {
+ (usb_dev_ptr->usb_dev_interface)->dev_get_endpoint_status(usb_dev_ptr->controller_handle,
+ (uint8_t)(component),error);
+ }
+ else
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_get_status: DEV_GET_ENDPOINT_STATUS is NULL\n");
+#endif
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USBERR_ERROR;
+ }
+ }
+ else
+ {
+ if ((usb_dev_ptr->usb_dev_interface)->dev_get_device_status != NULL)
+ {
+ (usb_dev_ptr->usb_dev_interface)->dev_get_device_status(usb_dev_ptr->controller_handle,
+ (uint8_t)(component),error);
+ }
+ else
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_get_status: DEV_GET_DEVICE_STATUS is NULL\n");
+#endif
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USBERR_ERROR;
+ }
+ }
+
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USB_OK;
+}
+
+/*FUNCTION*----------------------------------------------------------------
+ *
+ * Function Name : usb_device_set_status
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Provides API to set internal state
+ *
+ *END*--------------------------------------------------------------------*/
+usb_status usb_device_set_status
+(
+/* [IN] Handle to the usb device */
+usb_device_handle handle,
+/* [IN] What to set the error of */
+uint8_t component,
+/* [IN] What to set the error to */
+uint16_t setting
+)
+{
+ usb_dev_state_struct_t* usb_dev_ptr;
+ uint8_t error = USB_OK;
+
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+ OS_Mutex_lock(usb_dev_ptr->mutex);
+ if ((usb_dev_ptr->usb_dev_interface)->dev_set_device_status != NULL)
+ {
+ (usb_dev_ptr->usb_dev_interface)->dev_set_device_status(usb_dev_ptr->controller_handle,
+ (uint8_t)(component),setting);
+ }
+ else
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_set_status: dev_set_device_status is NULL\n");
+#endif
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USBERR_ERROR;
+ }
+
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return error;
+} /* EndBody */
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_init
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Initializes the USB device specific data structures and calls
+ * the low-level device controller chip initialization routine.
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_init
+(
+ /* [IN] the USB device controller to initialize */
+ uint8_t controller_id,
+ /* [OUT] the USB_USB_dev_initialize state structure */
+ usb_device_handle * handle
+)
+{
+ usb_dev_state_struct_t* usb_dev_ptr;
+ uint8_t i;
+ usb_status error = USB_OK;
+ const usb_dev_interface_functions_struct_t* dev_if = NULL;
+ usb_class_fw_object_struct_t* usb_fw_ptr = NULL;
+
+ //OS_Lock();
+
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ for(i = 0; i < USBCFG_DEV_NUM; i++)
+ {
+ if(NULL == g_usb_dev_data_ptr[i])
+ {
+ g_usb_dev_data_ptr[i] = OS_Mem_alloc_uncached_align(sizeof(usb_dev_data_t), 32);
+ }
+ }
+#endif
+
+ usb_dev_ptr = _usb_device_get_handle();
+
+ if(usb_dev_ptr == NULL)
+ {
+ /* The interface does not support device functionality */
+ //OS_Unlock();
+ return USBERR_DEVICE_BUSY;
+ }
+ usb_dev_ptr->controller_id = controller_id;
+ usb_fw_ptr = &usb_dev_ptr->usb_framework;
+ usb_dev_ptr->mutex = OS_Mutex_create();
+#if ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM) || ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK)))
+ usb_fw_ptr->ext_req_to_host = (uint8_t*)(&g_usb_dev_data[usb_dev_ptr->dev_index].control_out);
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ usb_fw_ptr->ext_req_to_host = (uint8_t*)g_usb_dev_data_ptr[usb_dev_ptr->dev_index]->control_out;
+#endif
+
+ for (i= 0; i < MAX_DEVICE_SERVICE_NUMBER; i++)
+ {
+ usb_dev_ptr->services[i].type = (uint8_t)-1;
+ }
+
+ _usb_device_get_DCI(controller_id, &dev_if);
+
+ if(dev_if == NULL)
+ {
+ _usb_device_release_handle(usb_dev_ptr);
+ //OS_Unlock();
+ return USBERR_DEVICE_NOT_FOUND;
+ }
+
+ usb_dev_ptr->usb_dev_interface = dev_if;
+
+#if USBCFG_DEV_USE_TASK
+ /* The _lwmsgq_init accepts the size of ISR_MSG_STRUCT as a multiplier of sizeof(_mqx_max_type) */
+ usb_dev_ptr->usb_dev_service_que = (os_msgq_handle)OS_MsgQ_create(USBCFG_DEV_SERVICE_MSG_CNT, MSG_SIZE_IN_MAX_TYPE);
+ _usb_dev_task_create(usb_dev_ptr);
+#endif
+
+ //OS_Unlock();
+ /* Initialize the USB interface. */
+ if (dev_if->dev_preint != NULL)
+ {
+ error = dev_if->dev_preint(usb_dev_ptr, (usb_device_handle *) (&usb_dev_ptr->controller_handle));
+ }
+
+ if (usb_dev_ptr->controller_handle == NULL)
+ {
+#if _DEBUG
+ USB_PRINTF("1 memalloc failed in usb_device_init\n");
+#endif
+ return USBERR_ALLOC_STATE;
+ } /* Endif */
+ usb_fw_ptr->controller_handle = usb_dev_ptr->controller_handle;
+ usb_fw_ptr->dev_handle = usb_dev_ptr;
+#ifndef USBCFG_OTG
+ error = bsp_usb_dev_init(controller_id);
+#if USBCFG_DEV_KHCI && USBCFG_DEV_DETACH_ENABLE && USBCFG_DEV_IO_DETACH_ENABLE
+ error = bsp_usb_detach_init(controller_id);
+#endif
+#else
+ error = bsp_usb_otg_dev_init(controller_id);
+#endif
+ if (error != USB_OK)
+ {
+ if (dev_if->dev_shutdown != NULL)
+ {
+ dev_if->dev_shutdown(usb_dev_ptr->controller_handle);
+ }
+ return USBERR_UNKNOWN_ERROR;
+ }
+
+ /* Initialize the USB controller chip */
+ if (dev_if->dev_init != NULL)
+ {
+ error = dev_if->dev_init(controller_id,usb_dev_ptr->controller_handle);
+ }
+ else
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_init: DEV_INIT is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+
+ if (error)
+ {
+ if (dev_if->dev_shutdown != NULL)
+ {
+ dev_if->dev_shutdown(usb_dev_ptr->controller_handle);
+ }
+ return USBERR_INIT_FAILED;
+ } /* Endif */
+
+ *handle = usb_dev_ptr;
+ return error;
+} /* EndBody */
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_postinit
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Initializes the USB device specific data structures and calls
+ * the low-level device controller chip initialization routine.
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_postinit
+(
+ /* [IN] the USB device controller to initialize */
+ uint8_t controller_id,
+ /* [OUT] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle
+)
+{
+ usb_dev_state_struct_t* usb_dev_ptr;
+ usb_status error = 0;
+
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+ if ((usb_dev_ptr->usb_dev_interface)->dev_postinit != NULL)
+ {
+ error = (usb_dev_ptr->usb_dev_interface)->dev_postinit(controller_id, handle);
+ }
+ return error;
+} /* EndBody */
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_deinit
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * uninitializes the USB device specific data structures and calls
+ * the low-level device controller chip initialization routine.
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_deinit
+(
+ /* [OUT] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle
+)
+{
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ uint32_t i;
+#endif
+ usb_dev_state_struct_t* usb_dev_ptr;
+ //usb_class_fw_object_struct_t* usb_fw_ptr = NULL;
+ if (handle == NULL)
+ {
+#if _DEBUG
+ USB_PRINTF("_usb_device_shutdowna: handle is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+
+ OS_Mutex_destroy(usb_dev_ptr->mutex);
+ _usb_device_shutdown(handle);
+
+ _usb_device_release_handle(usb_dev_ptr);
+
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ for(i = 0; i < USBCFG_DEV_NUM; i++)
+ {
+ if(NULL != g_usb_dev_data_ptr[i])
+ {
+ OS_Mem_free(g_usb_dev_data_ptr[i]);
+ g_usb_dev_data_ptr[i] = NULL;
+ }
+ }
+#endif
+
+ return USB_OK;
+} /* EndBody */
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_init_endpoint
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Initializes the endpoint and the data structures associated with the
+ * endpoint
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_init_endpoint
+(
+ /* [IN] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle,
+ /* [IN] the endpoint structure, include members such as endpoint number,
+ * endpoint type, endpoint direction and the max packet size
+ */
+ usb_ep_struct_t* ep_ptr,
+ /* [IN] After all data is transfered, should we terminate the transfer
+ * with a zero length packet if the last packet size == MAX_PACKET_SIZE?
+ */
+ uint8_t flag
+)
+{
+ usb_status error = 0;
+ usb_dev_state_struct_t* usb_dev_ptr;
+ struct xd_struct xd;
+ if (handle == NULL)
+ {
+#if _DEBUG
+ USB_PRINTF("_usb_device_shutdowna: handle is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+
+ /* Initialize the transfer descriptor */
+ xd.ep_num = ep_ptr->ep_num;
+ xd.bdirection = ep_ptr->direction;
+ xd.wmaxpacketsize = (uint16_t)(ep_ptr->size & 0x0000FFFF);
+ xd.ep_type = ep_ptr->type;
+ xd.dont_zero_terminate = flag;
+ xd.wtotallength = 0;
+ xd.wsofar = 0;
+
+ if ((usb_dev_ptr->usb_dev_interface)->dev_init_endoint != NULL)
+ {
+ error=(usb_dev_ptr->usb_dev_interface)->dev_init_endoint(usb_dev_ptr->controller_handle, &xd);
+ }
+ else
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_init_endpoint: DEV_INIT_ENDPOINT is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+
+ return error;
+} /* EndBody */
+
+/*FUNCTION*----------------------------------------------------------------
+ *
+ * Function Name : usb_device_register_service
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Registers a callback routine for a specified event or endpoint.
+ *
+ *END*--------------------------------------------------------------------*/
+usb_status usb_device_register_service
+(
+ /* [IN] Handle to the USB device */
+ usb_device_handle handle,
+ /* [IN] type of event or endpoint number to service */
+ uint8_t type,
+ /* [IN] Pointer to the service's callback function */
+ usb_event_service_t service,
+ /*[IN] User Argument to be passed to Services when invoked.*/
+ void* arg
+)
+{
+ usb_dev_state_struct_t* usb_dev_ptr;
+ service_struct_t* service_ptr;
+ uint32_t i;
+
+ if (handle == NULL)
+ {
+ return USBERR_ERROR;
+ }
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+
+ OS_Mutex_lock(usb_dev_ptr->mutex);
+
+ for (i = 0; i < MAX_DEVICE_SERVICE_NUMBER; i++)
+ {
+ service_ptr = &usb_dev_ptr->services[i];
+ if (service_ptr->type == type)
+ {
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USBERR_OPEN_SERVICE;
+ }
+ }
+
+ for (i = 0; i < MAX_DEVICE_SERVICE_NUMBER; i++)
+ {
+ service_ptr = &usb_dev_ptr->services[i];
+ if (service_ptr->type == (uint8_t)-1)
+ {
+ service_ptr->type = type;
+ service_ptr->service = service;
+ service_ptr->arg = arg;
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USB_OK;
+ }
+ }
+
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USBERR_ALLOC;
+} /* EndBody */
+
+/*FUNCTION*----------------------------------------------------------------
+ *
+ * Function Name : usb_device_unregister_service
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Unregisters a callback routine for a specified event or endpoint.
+ *
+ *END*--------------------------------------------------------------------*/
+usb_status usb_device_unregister_service
+(
+ /* [IN] Handle to the USB device */
+ usb_device_handle handle,
+ /* [IN] type of event or endpoint number to service */
+ uint8_t type
+)
+{ /* Body */
+ usb_dev_state_struct_t* usb_dev_ptr;
+ service_struct_t* service_ptr;
+ uint32_t i;
+
+ if (handle == NULL)
+ {
+ return USBERR_ERROR;
+ }
+
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+ /* Needs mutual exclusion */
+ OS_Mutex_lock(usb_dev_ptr->mutex);
+
+ for (i = 0; i < MAX_DEVICE_SERVICE_NUMBER; i++)
+ {
+ service_ptr = &usb_dev_ptr->services[i];
+ if (service_ptr->type == type)
+ {
+ service_ptr->type = (uint8_t)-1;
+ service_ptr->service = NULL;
+ service_ptr->arg = NULL;
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USB_OK;
+ }
+ }
+
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USBERR_CLOSED_SERVICE;
+} /* EndBody */
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_deinit_endpoint
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Disables the endpoint and the data structures associated with the
+ * endpoint
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_deinit_endpoint
+(
+ /* [IN] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle,
+ /* [IN] the Endpoint number */
+ uint8_t ep_num,
+ /* [IN] Direction */
+ uint8_t direction
+)
+{
+ uint8_t error = 0;
+ usb_dev_state_struct_t* usb_dev_ptr;
+
+ if (handle == NULL)
+ {
+ return USBERR_ERROR;
+ }
+
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+ OS_Mutex_lock(usb_dev_ptr->mutex);
+
+ if ((usb_dev_ptr->usb_dev_interface)->dev_deinit_endoint != NULL)
+ {
+ error = (usb_dev_ptr->usb_dev_interface)->dev_deinit_endoint(usb_dev_ptr->controller_handle,
+ ep_num, direction);
+ }
+ else
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_deinit_endpoint: DEV_DEINIT_ENDPOINT is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return error;
+}
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_recv_data
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Receives data on a specified endpoint.
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_recv_data
+(
+ /* [IN] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle,
+ /* [IN] the Endpoint number */
+ uint8_t ep_num,
+ /* [IN] buffer to receive data */
+ uint8_t * buff_ptr,
+ /* [IN] length of the transfer */
+ uint32_t size
+)
+{
+ usb_status error = USB_OK;
+ xd_struct_t* xd_ptr;
+ usb_dev_state_struct_t* usb_dev_ptr;
+
+ if (handle == NULL)
+ {
+ return USBERR_ERROR;
+ }
+
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+ if ((usb_dev_ptr->usb_dev_interface)->dev_get_xd != NULL)
+ {
+ error = (usb_dev_ptr->usb_dev_interface)->dev_get_xd(usb_dev_ptr->controller_handle, &xd_ptr);
+
+ if (USB_OK != error)
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_recv_data: DEV_GET_XD failed\n");
+#endif
+ return USBERR_ERROR;
+ }
+ }
+ else
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_recv_data: DEV_GET_XD is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+
+ OS_Mutex_lock(usb_dev_ptr->mutex);
+
+ /* Initialize the new transfer descriptor */
+ xd_ptr->ep_num = ep_num;
+ xd_ptr->bdirection = USB_RECV;
+ xd_ptr->wtotallength = size;
+ xd_ptr->wstartaddress = buff_ptr;
+ xd_ptr->wsofar = 0;
+ xd_ptr->bstatus = USB_STATUS_TRANSFER_ACCEPTED;
+
+ if ((usb_dev_ptr->usb_dev_interface)->dev_recv != NULL)
+ {
+
+#if (USBCFG_DEV_BUFF_PROPERTY_CACHEABLE)
+ if (size > 0)
+ {
+ OS_dcache_invalidate_mlines((void*)buff_ptr, size);
+ }
+#endif
+ error = (usb_dev_ptr->usb_dev_interface)->dev_recv(usb_dev_ptr->controller_handle, xd_ptr);
+ }
+ else
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_recv_data: DEV_RECV is NULL\n");
+#endif
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USBERR_ERROR;
+ }
+
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ if (error)
+ {
+ return USBERR_RX_FAILED;
+ } /* Endif */
+
+ return error;
+} /* EndBody */
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_send_data
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Sends data on a specified endpoint.
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_send_data
+(
+ /* [IN] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle,
+ /* [IN] the Endpoint number */
+ uint8_t ep_num,
+ /* [IN] buffer to send */
+ uint8_t * buff_ptr,
+ /* [IN] length of the transfer */
+ uint32_t size
+)
+{ /* Body */
+ usb_status error;
+ xd_struct_t* xd_ptr;
+ usb_dev_state_struct_t* usb_dev_ptr;
+
+ if (handle == NULL)
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_send_data: handle is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+
+ if ((usb_dev_ptr->usb_dev_interface)->dev_get_xd != NULL)
+ {
+ error = (usb_dev_ptr->usb_dev_interface)->dev_get_xd(usb_dev_ptr->controller_handle, &xd_ptr);
+
+ if (USB_OK != error)
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_send_data: DEV_GET_XD failed\n");
+#endif
+ return USBERR_ERROR;
+ }
+ }
+ else
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_send_data: DEV_GET_XD is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+
+ OS_Mutex_lock(usb_dev_ptr->mutex);
+
+ /* Initialize the new transfer descriptor */
+ xd_ptr->ep_num = ep_num;
+ xd_ptr->bdirection = USB_SEND;
+ xd_ptr->wtotallength = size;
+ xd_ptr->wstartaddress = buff_ptr;
+ xd_ptr->wsofar = 0;
+ xd_ptr->bstatus = USB_STATUS_TRANSFER_ACCEPTED;
+
+ if ((usb_dev_ptr->usb_dev_interface)->dev_send != NULL)
+ {
+#if (USBCFG_DEV_BUFF_PROPERTY_CACHEABLE)
+ if (size > 0)
+ {
+ /********************************************************
+ If system has a data cache, it is assumed that buffer
+ passed to this routine will be aligned on a cache line
+ boundary. The following code will flush the
+ buffer before passing it to hardware driver.
+ ********************************************************/
+ OS_dcache_flush_mlines((void*)buff_ptr, size);
+ }
+#endif
+ error = (usb_dev_ptr->usb_dev_interface)->dev_send(usb_dev_ptr->controller_handle, xd_ptr);
+ }
+ else
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_send_data: DEV_SEND is NULL\n");
+#endif
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USBERR_ERROR;
+ }
+
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ if (error)
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_send_data, transfer failed\n");
+#endif
+ return USBERR_TX_FAILED;
+ }
+ return error;
+}
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_unstall_endpoint
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Unstalls the endpoint in specified direction
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_unstall_endpoint
+(
+ /* [IN] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle,
+ /* [IN] the Endpoint number */
+ uint8_t ep_num,
+ /* [IN] direction */
+ uint8_t direction
+)
+{
+ usb_status error = USB_OK;
+ usb_dev_state_struct_t* usb_dev_ptr;
+
+ if (handle == NULL)
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_unstall_endpoint: handle is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+
+ OS_Mutex_lock(usb_dev_ptr->mutex);
+
+ if ((usb_dev_ptr->usb_dev_interface)->dev_unstall_endpoint != NULL)
+ {
+ error= (usb_dev_ptr->usb_dev_interface)->dev_unstall_endpoint(usb_dev_ptr->controller_handle, ep_num, direction);
+ }
+ else
+ {
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USBERR_ERROR;
+ }
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return error;
+} /* EndBody */
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_stall_endpoint
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Stalls the endpoint.
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_stall_endpoint
+(
+ /* [IN] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle,
+ /* [IN] the Endpoint number */
+ uint8_t ep_num,
+ /* [IN] direction */
+ uint8_t direction
+)
+{
+ usb_status error = 0;
+ usb_dev_state_struct_t* usb_dev_ptr;
+
+ if (handle == NULL)
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_stall_endpoint: handle is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+
+ if ((usb_dev_ptr->usb_dev_interface)->dev_stall_endpoint
+ != NULL)
+ {
+ error = (usb_dev_ptr->usb_dev_interface)->dev_stall_endpoint(usb_dev_ptr->controller_handle,
+ ep_num, direction);
+ }
+ else
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_stall_endpoint: DEV_STALL_ENDPOINT is NULL\n");
+#endif
+ error = USBERR_ERROR;
+ }
+
+ return error;
+}
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_register_application_notify
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Process Resume event
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_register_application_notify
+(
+ /* [IN] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle,
+ usb_device_notify_t device_notify_callback,
+ void* device_notify_param
+)
+{
+ usb_dev_state_struct_t* usb_dev_ptr;
+ usb_status error = USB_OK;
+
+ if (handle == NULL)
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_register_application_notify: handle is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+
+ usb_dev_ptr->usb_framework.device_notify_callback = device_notify_callback;
+ usb_dev_ptr->usb_framework.device_notify_param = device_notify_param;
+ return error;
+}
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_register_vendor_class_request_notify
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Process Resume event
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_register_vendor_class_request_notify
+(
+ /* [IN] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle,
+ usb_request_notify_t request_notify_callback,
+ void* request_notify_param
+)
+{
+ usb_dev_state_struct_t* usb_dev_ptr;
+ usb_status error = USB_OK;
+
+ if (handle == NULL)
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_register_vendor_class_request_notify: handle is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+
+ usb_dev_ptr->usb_framework.request_notify_callback = request_notify_callback;
+ usb_dev_ptr->usb_framework.request_notify_param = request_notify_param;
+
+ return error;
+}
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_register_desc_request_notify
+ * Returned Value : USB_OK or error code
+ * Comments :
+ *
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_register_desc_request_notify
+(
+ /* [IN] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle,
+ usb_desc_request_notify_struct_t* desc_request_notify_callback,
+ void* desc_request_notify_param
+)
+{
+ usb_dev_state_struct_t* usb_dev_ptr;
+ usb_status error = USB_OK;
+
+ if (handle == NULL)
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_register_desc_request_notify\n");
+#endif
+ return USBERR_ERROR;
+ }
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+
+ usb_dev_ptr->usb_framework.desc_notify_callback = desc_request_notify_callback;
+ usb_dev_ptr->usb_framework.desc_notify_param = desc_request_notify_param;
+
+ return error;
+}
+#if USBCFG_DEV_ADVANCED_CANCEL_ENABLE
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_cancel_transfer
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * returns the status of the transaction on the specified endpoint.
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_cancel_transfer
+(
+ /* [IN] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle,
+ /* [IN] the Endpoint number */
+ uint8_t ep_num,
+ /* [IN] direction */
+ uint8_t direction
+)
+{
+ uint8_t error = USB_OK;
+ usb_dev_state_struct_t* usb_dev_ptr;
+ if (handle == NULL)
+ {
+#if _DEBUG
+ USB_PRINTF("_usb_device_shutdowna: handle is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+ OS_Mutex_lock(usb_dev_ptr->mutex);
+
+ /* Cancel transfer on the specified endpoint for the specified
+ ** direction
+ */
+ if ((usb_dev_ptr->usb_dev_interface)->dev_cancel_transfer != NULL)
+ {
+ error = (usb_dev_ptr->usb_dev_interface)->dev_cancel_transfer(usb_dev_ptr->controller_handle,
+ ep_num, direction);
+ }
+ else
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_cancel_transfer: dev_cancel_transfer is NULL\n");
+#endif
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+ return USBERR_ERROR;
+ }
+
+ OS_Mutex_unlock(usb_dev_ptr->mutex);
+
+ return error;
+}
+#endif
+
+#if USBCFG_DEV_ADVANCED_SUSPEND_RESUME
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_process_resume
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Process Resume event
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_assert_resume
+(
+ /* [IN] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle
+)
+{
+ usb_dev_state_struct_t* usb_dev_ptr;
+ usb_status error = USB_OK;
+
+ if (handle == NULL)
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_assert_resume: handle is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+
+ if ((usb_dev_ptr->usb_dev_interface)->dev_assert_resume != NULL)
+ {
+ error= (usb_dev_ptr->usb_dev_interface)->dev_assert_resume(usb_dev_ptr->controller_handle);
+ }
+ else
+ {
+#if _DEBUG
+ USB_PRINTF("usb_device_assert_resume: dev_assert_resume is NULL\n");
+#endif
+ error = USBERR_ERROR;
+ }
+
+ return error;
+}
+#endif
+
+#ifdef USBCFG_OTG
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_otg_init
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Process Resume event
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_otg_init
+(
+ usb_device_handle handle,
+ uint8_t otg_attributes
+)
+{
+ usb_status error;
+ usb_khci_dev_state_struct_t* khci_dev_state_ptr;
+ if (handle == NULL)
+ {
+ return USBERR_ERROR;
+ }
+ khci_dev_state_ptr = (usb_khci_dev_state_struct_t*)((usb_dev_state_struct_t*)handle)->controller_handle;
+ khci_dev_state_ptr->otg_attr_srp = (otg_attributes & OTG_SRP_SUPPORT)?(TRUE):(FALSE);
+ khci_dev_state_ptr->otg_attr_hnp = (otg_attributes & OTG_HNP_SUPPORT)?(TRUE):(FALSE);
+ error = usb_otg_device_on_class_init(khci_dev_state_ptr->otg_handle, handle , otg_attributes );
+
+ return error;
+}
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_otg_get_hnp_support
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Process Resume event
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_otg_get_hnp_support
+(
+ usb_device_handle handle,
+ uint8_t* hnp_support_ptr
+)
+{
+ usb_khci_dev_state_struct_t* khci_dev_state_ptr;
+
+ if (handle == NULL)
+ {
+ *hnp_support_ptr = 0;
+ return USBERR_ERROR;
+ }
+ khci_dev_state_ptr = (usb_khci_dev_state_struct_t*)((usb_dev_state_struct_t*)handle)->controller_handle;
+ *hnp_support_ptr = khci_dev_state_ptr->otg_attr_hnp;
+ return USB_OK;
+}
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_otg_set_hnp_enable
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * Process Resume event
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_otg_set_hnp_enable
+(
+ usb_device_handle handle
+)
+{
+ usb_khci_dev_state_struct_t* khci_dev_state_ptr;
+ if (handle == NULL)
+ {
+ return USBERR_ERROR;
+ }
+ khci_dev_state_ptr = (usb_khci_dev_state_struct_t*)((usb_dev_state_struct_t*)handle)->controller_handle;
+ return usb_otg_device_hnp_enable(khci_dev_state_ptr->otg_handle, TRUE);
+}
+#endif /* USBCFG_OTG */
+
+/*FUNCTION*-------------------------------------------------------------
+ *
+ * Function Name : usb_device_reset
+ * Returned Value : USB_OK or error code
+ * Comments :
+ * reset device.
+ *
+ *END*-----------------------------------------------------------------*/
+usb_status usb_device_reset
+(
+ /* [IN] the USB_USB_dev_initialize state structure */
+ usb_device_handle handle
+)
+{
+ usb_status error = USB_OK;
+ usb_dev_state_struct_t* usb_dev_ptr;
+
+ if (handle == NULL)
+ {
+ return USBERR_ERROR;
+ }
+
+ usb_dev_ptr = (usb_dev_state_struct_t*)handle;
+
+ if ((usb_dev_ptr->usb_dev_interface)->dev_reset != NULL)
+ {
+ error = (usb_dev_ptr->usb_dev_interface)->dev_reset(usb_dev_ptr->controller_handle);
+ }
+ else
+ {
+#if _DEBUG
+ //USB_PRINTF("usb_device_reset: dev_reset is NULL\n");
+#endif
+ return USBERR_ERROR;
+ }
+
+ return error;
+} /* EndBody */
+#endif
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_dev.h b/KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_dev.h
new file mode 100644
index 0000000..254ca83
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_dev.h
@@ -0,0 +1,136 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2008, 2013 - 2014 Freescale Semiconductor;
+* All Rights Reserved
+*
+* Copyright (c) 1989-2008 ARC International;
+* All Rights Reserved
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: usb_dev.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+* This file contains the declarations specific to the USB Device API
+*
+*END*********************************************************************/
+#ifndef __USB_DEV_H__
+#define __USB_DEV_H__ 1
+
+#include "usb_framework.h"
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM)
+
+#undef USBCFG_DEV_USE_TASK
+#define USBCFG_DEV_USE_TASK 0
+
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+
+#undef USBCFG_DEV_USE_TASK
+#define USBCFG_DEV_USE_TASK 1
+
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK)
+#if USE_RTOS
+#define USBCFG_DEV_USE_TASK 1
+#else
+#define USBCFG_DEV_USE_TASK 0
+#endif
+
+#endif
+#define MAX_DEVICE_SERVICE_NUMBER 8
+
+/* Callback function storage structure */
+typedef struct service_struct
+{
+ usb_event_service_t service;
+ void* arg;
+ uint8_t type;
+} service_struct_t;
+
+typedef struct usb_dev_interface_functions_struct
+{
+ /* The Host/Device init function */
+ usb_status (_CODE_PTR_ dev_preint)(usb_device_handle upper_layer_handle, usb_device_handle *handle_ptr);
+
+ /* The Host/Device init function */
+ usb_status (_CODE_PTR_ dev_init)(uint8_t controller_id, usb_device_handle handle);
+
+ /* The Host/Device init function */
+ usb_status (_CODE_PTR_ dev_postinit)( uint8_t controller_id, usb_device_handle handle);
+
+ /* The function to send data */
+ usb_status (_CODE_PTR_ dev_send)(usb_device_handle handle, xd_struct_t* xd);
+
+ /* The function to receive data */
+ usb_status (_CODE_PTR_ dev_recv)(usb_device_handle handle, xd_struct_t* xd);
+#if USBCFG_DEV_ADVANCED_CANCEL_ENABLE
+ /* The function to cancel the transfer */
+ usb_status (_CODE_PTR_ dev_cancel_transfer)(usb_device_handle handle, uint8_t ep_num, uint8_t direction);
+#endif
+
+ usb_status (_CODE_PTR_ dev_init_endoint)(usb_device_handle handle, xd_struct_t* xd);
+
+ usb_status (_CODE_PTR_ dev_deinit_endoint)(usb_device_handle handle, uint8_t ep_num, uint8_t direction);
+
+ usb_status (_CODE_PTR_ dev_unstall_endpoint)(usb_device_handle handle, uint8_t ep_num, uint8_t direction);
+
+ usb_status (_CODE_PTR_ dev_get_endpoint_status)(usb_device_handle handle, uint8_t component, uint16_t *endp_status);
+
+ usb_status (_CODE_PTR_ dev_set_endpoint_status)(usb_device_handle handle, uint8_t component, uint16_t endp_status);
+
+ usb_status (_CODE_PTR_ dev_get_transfer_status)(usb_device_handle handle, uint8_t component, uint8_t status);
+
+ usb_status (_CODE_PTR_ dev_set_address)(usb_device_handle handle, uint8_t addr);
+
+ usb_status (_CODE_PTR_ dev_shutdown)(usb_device_handle handle);
+
+ usb_status (_CODE_PTR_ dev_get_setup_data)(usb_device_handle handle, uint8_t component, uint8_t *data);
+#if USBCFG_DEV_ADVANCED_SUSPEND_RESUME
+ usb_status (_CODE_PTR_ dev_assert_resume)(usb_device_handle handle);
+#endif
+
+ usb_status (_CODE_PTR_ dev_stall_endpoint)(usb_device_handle handle, uint8_t ep_num, uint8_t direction);
+
+ usb_status (_CODE_PTR_ dev_set_device_status)(usb_device_handle handle, uint8_t component, uint16_t setting);
+
+ usb_status (_CODE_PTR_ dev_get_device_status)(usb_device_handle handle, uint8_t component, uint16_t *error);
+
+ usb_status (_CODE_PTR_ dev_get_xd)(usb_device_handle handle, xd_struct_t** xd);
+
+ usb_status (_CODE_PTR_ dev_reset)(usb_device_handle handle);
+} usb_dev_interface_functions_struct_t;
+
+typedef struct usb_dev_state_struct
+{
+ usb_device_handle controller_handle;
+ const usb_dev_interface_functions_struct_t* usb_dev_interface;
+#if USBCFG_DEV_USE_TASK
+ os_msgq_handle usb_dev_service_que;
+ uint32_t task_id;
+#endif
+ usb_class_fw_object_struct_t usb_framework;
+ service_struct_t services[MAX_DEVICE_SERVICE_NUMBER];
+ os_mutex_handle mutex;
+ uint8_t occupied;
+ uint8_t controller_id; /* Device controller ID */
+ uint8_t dev_index;
+} usb_dev_state_struct_t;
+
+#endif
+/* EOF */
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_framework.c b/KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_framework.c
new file mode 100644
index 0000000..9017a11
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_framework.c
@@ -0,0 +1,1295 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2008, 2013 - 2015 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ * Copyright (c) 1989-2008 ARC International;
+ * All Rights Reserved
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: usb_framework.c$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ * @brief The file contains USB stack framework module implementation.
+ *
+ *****************************************************************************/
+
+/******************************************************************************
+ * Includes
+ *****************************************************************************/
+#include "usb_device_config.h"
+#if USBCFG_DEV_KHCI || USBCFG_DEV_EHCI
+#include "usb.h"
+#include "usb_device_stack_interface.h"
+#include "usb_framework.h"
+
+/*****************************************************************************
+ * Constant and Macro's
+ *****************************************************************************/
+
+/****************************************************************************
+ * Global Variables
+ ****************************************************************************/
+//usb_class_fw_object_struct_t* usb_class_fw_object[USB_MAX_CLASS_FW_OBJECT];
+#ifdef DELAYED_PROCESSING
+usb_event_struct_t g_f_event;
+bool g_control_pending=FALSE;
+#endif
+#if ((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX))
+static bool g_validate_request[MAX_STRD_REQ][3] =
+#else
+static uint8_t g_validate_request[MAX_STRD_REQ][3] =
+#endif
+
+{
+ {1, 1, 0,}, /*USB_Strd_Req_Get_Status*/
+ /* configured state: valid for existing interfaces/endpoints
+ address state : valid only for interface or endpoint 0
+ default state : not specified
+ */
+ {1, 1, 0,}, /* Clear Feature */
+ /* configured state: valid only for device in configured state
+ address state : valid only for device (in address state),
+ interface and endpoint 0
+ default state : not specified
+ */
+ {0, 0, 0,}, /*reserved for future use*/
+ /* configured state: request not supported
+ address state : request not supported
+ default state : request not supported
+ */
+#ifdef USBCFG_OTG
+ {1, 1, 1,}, /* Set Feature */
+ /* configured state: valid only for device in configured state
+ address state : valid only for interface or endpoint 0
+ default state : not specified
+ */
+#else
+ {1, 1, 0,}, /* Set Feature */
+ /* configured state: valid only for device in configured state
+ address state : valid only for interface or endpoint 0
+ default state : not specified
+ */
+#endif
+ {0, 0, 0,},/*reserved for future use*/
+ /* configured state: request not supported
+ address state : request not supported
+ default state : request not supported
+ */
+ {0, 1, 1,}, /*USB_Strd_Req_Set_Address*/
+ /* configured state: not specified
+ address state : changes to default state if specified addr == 0,
+ but uses newly specified address
+ default state : changes to address state if specified addr != 0
+ */
+ {1, 1, 1,}, /*USB_Strd_Req_Get_Descriptor*/
+ /* configured state: valid request
+ address state : valid request
+ default state : valid request
+ */
+ {0, 0, 0,}, /*Set Descriptor*/
+ /* configured state: request not supported
+ address state : request not supported
+ default state : request not supported
+ */
+ {1, 1, 0,}, /*USB_Strd_Req_Get_Config*/
+ /* configured state: bConfiguration Value of current config returned
+ address state : value zero must be returned
+ default state : not specified
+ */
+ {1, 1, 0,}, /*USB_Strd_Req_Set_Config*/
+ /* configured state: If the specified configuration value is zero,
+ then the device enters the Address state.If the
+ specified configuration value matches the
+ configuration value from a config descriptor,
+ then that config is selected and the device
+ remains in the Configured state. Otherwise, the
+ device responds with a Request Error.
+
+ address state : If the specified configuration value is zero,
+ then the device remains in the Address state. If
+ the specified configuration value matches the
+ configuration value from a configuration
+ descriptor, then that configuration is selected
+ and the device enters the Configured state.
+ Otherwise,response is Request Error.
+ default state : not specified
+ */
+ {1, 0, 0,}, /*USB_Strd_Req_Get_Interface*/
+ /* configured state: valid request
+ address state : request error
+ default state : not specified
+ */
+ {1, 0, 0,}, /*USB_Strd_Req_Set_Interface*/
+ /* configured state: valid request
+ address state : request error
+ default state : not specified
+ */
+ {1, 0, 0,}, /*USB_Strd_Req_Sync_Frame*/
+ /* configured state: valid request
+ address state : request error
+ default state : not specified
+ */
+};
+
+/****************************************************************************
+ * Global Functions
+ ****************************************************************************/
+
+/*****************************************************************************
+ * Local Types - None
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Local Functions
+ *****************************************************************************/
+usb_class_fw_handle USB_Framework_Init( usb_device_handle handle, /*[IN]*/
+usb_device_notify_t class_callback,/*[IN]*/
+usb_request_notify_t other_req_callback,/*[IN]*/
+void* callback_data,/*[IN]*/
+int32_t data,/*[IN]*/
+usb_desc_request_notify_struct_t* desc_callback_ptr /*[IN]*/);
+uint8_t USB_Framework_Deinit( usb_device_handle handle, /*[IN]*/
+usb_class_fw_handle fw_handle /*[IN]*/);
+uint8_t USB_Framework_Reset(usb_device_handle handle);
+void USB_Control_Service (void* handle, usb_event_struct_t* event,void* arg );
+void USB_Control_Service_Handler( usb_class_fw_object_struct_t* usb_fw_ptr,
+uint8_t error,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size);
+
+static uint8_t USB_Strd_Req_Get_Status(usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size);
+static uint8_t USB_Strd_Req_Feature(usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size);
+static uint8_t USB_Strd_Req_Set_Address(usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size);
+static uint8_t USB_Strd_Req_Assign_Address(usb_class_fw_object_struct_t* usb_fw_ptr);
+static uint8_t USB_Strd_Req_Get_Config(usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size);
+static uint8_t USB_Strd_Req_Set_Config(usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size);
+static uint8_t USB_Strd_Req_Get_Interface(usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size);
+static uint8_t USB_Strd_Req_Set_Interface(usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size);
+static uint8_t USB_Strd_Req_Sync_Frame(usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size);
+static uint8_t USB_Strd_Req_Get_Descriptor(usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size);
+
+#ifdef DELAYED_PROCESSING
+void USB_Control_Service_Callback( usb_event_struct_t* event,void* arg );
+#endif
+
+extern usb_status usb_device_set_address(usb_device_handle handle, uint8_t address);
+extern usb_status usb_device_reset(usb_device_handle handle);
+
+/*****************************************************************************
+ * Local Functions Prototypes
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Local Variables
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Global Functions
+ *****************************************************************************/
+static USB_FW_REQ_FUNC g_standard_request[MAX_STRD_REQ] =
+{
+ USB_Strd_Req_Get_Status,
+ USB_Strd_Req_Feature,
+ NULL,
+ USB_Strd_Req_Feature,
+ NULL,
+ USB_Strd_Req_Set_Address,
+ USB_Strd_Req_Get_Descriptor,
+ NULL,
+ USB_Strd_Req_Get_Config,
+ USB_Strd_Req_Set_Config,
+ USB_Strd_Req_Get_Interface,
+ USB_Strd_Req_Set_Interface,
+ USB_Strd_Req_Sync_Frame
+};
+
+#ifdef DELAYED_PROCESSING
+/**************************************************************************//*!
+ *
+ * @name USB_Framework_Periodic_Task
+ *
+ * @brief The function is called to respond to any control request
+ *
+ * @param None
+ *
+ * @return None
+ *
+ *****************************************************************************/
+static void USB_Framework_Periodic_Task
+(
+void
+)
+{
+ /* if control request pending to be completed */
+ if (g_control_pending==TRUE)
+ { /* handle pending control request */
+ USB_Control_Service(&g_f_event);
+ g_control_pending=FALSE;
+ }
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Control_Service_Callback
+ *
+ * @brief The function can be used as a callback function to the service.
+ *
+ * @param event: from Service callback function
+ *
+ * @return None
+ *
+ *****************************************************************************/
+static void USB_Control_Service_Callback
+(
+usb_event_struct_t* event,
+void* arg
+)
+{
+ UNUSED_ARGUMENT(arg)
+ /* save the event parameters */
+ g_f_event.buffer_ptr = event->buffer_ptr;
+ g_f_event.handle = event->handle;
+ g_f_event.ep_num = event->ep_num;
+ g_f_event.setup = event->setup;
+ g_f_event.len = event->len;
+ g_f_event.errors = event->errors;
+
+ /* set the pending request flag */
+ g_control_pending=TRUE;
+}
+#endif
+
+/**************************************************************************//*!
+ *
+ * @name USB_Framework_Reset
+ *
+ * @brief The function resets the framework
+ *
+ * @param handle: handle to Identify the controller
+ *
+ * @return status
+ * USB_OK : When Successfully
+ * Others : Errors
+ *
+ *****************************************************************************/
+uint8_t USB_Framework_Reset
+(
+usb_device_handle handle
+)
+{
+ //UNUSED_ARGUMENT(handle)
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Control_Service
+ *
+ * @brief Called upon a completed endpoint 0 (USB 1.1 Chapter 9) transfer
+ *
+ * @param event: from Service callback function
+ *
+ * @return None
+ *
+ *****************************************************************************/
+void USB_Control_Service
+(
+void* handle,
+usb_event_struct_t* event,
+void* arg
+)
+{
+ uint16_t device_state = 0;
+ uint8_t error = USBERR_INVALID_REQ_TYPE;
+ uint8_t * data = NULL;
+ uint32_t size;
+ usb_class_fw_object_struct_t* usb_fw_ptr;
+
+ usb_fw_ptr = (usb_class_fw_object_struct_t*)handle;
+
+ /* get the device state */
+ (void)usb_device_get_status(usb_fw_ptr->dev_handle, (uint8_t)USB_STATUS_DEVICE_STATE,
+ &device_state);
+ //USB_PRINTF("USB_Control_Service ++ \n");
+ if (event->setup == TRUE)
+ {
+ OS_Mem_copy(event->buffer_ptr,&usb_fw_ptr->setup_packet,USB_SETUP_PKT_SIZE);
+
+ /* take care of endianness of the 16 bit fields correctly */
+ usb_fw_ptr->setup_packet.index = USB_SHORT_LE_TO_HOST(usb_fw_ptr->setup_packet.index);
+ usb_fw_ptr->setup_packet.value = USB_SHORT_LE_TO_HOST(usb_fw_ptr->setup_packet.value);
+ usb_fw_ptr->setup_packet.length = USB_SHORT_LE_TO_HOST(usb_fw_ptr->setup_packet.length);
+ // USB_PRINTF("00++ Enter ++ type:%d \n",usb_fw_ptr->setup_packet.request_type);
+ /* if the request is standard request */
+ if ((usb_fw_ptr->setup_packet.request_type & USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_POS) ==
+ USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_STANDARD)
+ {
+ // USB_PRINTF("11++ Enter ++ :%d \n",usb_fw_ptr->setup_packet.request);
+ /* if callback is not NULL */
+ if (g_standard_request[usb_fw_ptr->setup_packet.request] != NULL)
+ {
+ // USB_PRINTF("22++ Enter ++ :%d \n",usb_fw_ptr->setup_packet.request);
+ /* if the request is valid in this device state */
+ if((device_state < USB_STATE_POWERED) &&
+ (g_validate_request[usb_fw_ptr->setup_packet.request][device_state]
+ == (uint8_t)1))
+ {
+ /* Standard Request function pointers */
+ error = g_standard_request[usb_fw_ptr->setup_packet.request]
+ (usb_fw_ptr,&usb_fw_ptr->setup_packet,&data,&size);
+ }
+ }
+ }
+ else /* for Class/Vendor requests */
+ {
+ /*get the length from the setup_request*/
+ size = usb_fw_ptr->setup_packet.length;
+
+ if( (size != 0) &&
+ ((usb_fw_ptr->setup_packet.request_type & USB_DEV_REQ_STD_REQUEST_TYPE_DIR_POS) == USB_DEV_REQ_STD_REQUEST_TYPE_DIR_OUT)
+ )
+ {
+ /* we have gone for one time memory allocation of ext_req_to_host
+ to avoid memory fragmentation, as there was memory crunch in
+ some of our Socs. */
+ if((size + USB_SETUP_PKT_SIZE) > MAX_EXPECTED_CONTROL_OUT_SIZE)
+ {
+#if _DEBUG
+ USB_PRINTF("MAX_EXPECTED_CONTROL_OUT_SIZE insufficient, needed %d\n", size + USB_SETUP_PKT_SIZE);
+ USB_PRINTF("Please change the macro!!!\n");
+#endif
+ usb_device_stall_endpoint(usb_fw_ptr->dev_handle,USB_CONTROL_ENDPOINT,USB_RECV);
+ return;
+ }
+
+ /* copy setup token to ext_req_to_host */
+ OS_Mem_copy(&usb_fw_ptr->setup_packet, usb_fw_ptr->ext_req_to_host,
+ USB_SETUP_PKT_SIZE);
+ /* expecting host to send data (OUT TRANSACTION)*/
+ (void)usb_device_recv_data(event->handle,
+ USB_CONTROL_ENDPOINT,(usb_fw_ptr->ext_req_to_host+USB_SETUP_PKT_SIZE),
+ (uint32_t)(size));
+ return;
+ }
+ /*call class/vendor request*/
+ else if(usb_fw_ptr->request_notify_callback != NULL)
+ {
+ // USB_PRINTF("USB_Control_Service_Handler ++ #### \n");
+ error = usb_fw_ptr->request_notify_callback(
+ &usb_fw_ptr->setup_packet,&data,&size,usb_fw_ptr->request_notify_param);
+ }
+ }
+ USB_Control_Service_Handler(usb_fw_ptr,error,&usb_fw_ptr->setup_packet,
+ &data,&size);
+ }
+ else if(device_state == USB_STATE_PENDING_ADDRESS)
+ {
+ /* Device state is PENDING_ADDRESS */
+ /* Assign the new address to the Device */
+ //USB_PRINTF("send ZLT done\n");
+ (void)USB_Strd_Req_Assign_Address(usb_fw_ptr);
+ }
+ else if( ((usb_fw_ptr->setup_packet.request_type & USB_DEV_REQ_STD_REQUEST_TYPE_DIR_POS) == USB_DEV_REQ_STD_REQUEST_TYPE_DIR_OUT) &&
+ (event->direction == USB_RECV) &&
+ (usb_fw_ptr->setup_packet.length)
+ )
+ {
+ /* execution enters Control Service because of
+ OUT transaction on USB_CONTROL_ENDPOINT*/
+ if(usb_fw_ptr->request_notify_callback != NULL)
+ {
+ /* class or vendor request */
+ size = event->len+USB_SETUP_PKT_SIZE;
+ error = usb_fw_ptr->request_notify_callback(
+ (usb_setup_struct_t*) usb_fw_ptr->ext_req_to_host,
+ &data,&size,usb_fw_ptr->request_notify_param);
+ }
+ /* if it is called by usb_dci_khci_cancel() in the reset procedure, there is no need to to prime the endpoint*/
+ if(event->len != 0xFFFFFFFF)
+ {
+ USB_Control_Service_Handler(usb_fw_ptr,error,&usb_fw_ptr->setup_packet,
+ &data,&size);
+ }
+ }
+ return;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Reset_Service
+ *
+ * @brief The function is called upon a bus reset event.
+ Initializes the control endpoint.
+ *
+ * @param event: for Service callback function
+ *
+ * @return None
+ *****************************************************************************/
+void USB_Reset_Service
+(
+void* handle,
+usb_event_struct_t* event,
+void* arg
+)
+{
+ usb_ep_struct_t ep_struct;
+ volatile usb_class_fw_object_struct_t* usb_fw_ptr;
+ void* temp;
+
+ usb_fw_ptr = (usb_class_fw_object_struct_t*)handle;
+
+ usb_device_reset(usb_fw_ptr->dev_handle);
+
+ /* Initialize the endpoint 0 in both directions */
+ ep_struct.direction = USB_RECV;
+ ep_struct.ep_num = USB_CONTROL_ENDPOINT;
+ ep_struct.size = CONTROL_MAX_PACKET_SIZE;
+ ep_struct.type = USB_CONTROL_PIPE;
+
+ usb_device_init_endpoint(event->handle, &ep_struct, TRUE);
+
+ ep_struct.direction = USB_SEND;
+ usb_device_init_endpoint(event->handle, &ep_struct, TRUE);
+ temp = usb_fw_ptr->device_notify_param;
+ /* let the application know that bus reset has taken place */
+ if (usb_fw_ptr->device_notify_callback != NULL)
+ {
+ usb_fw_ptr->device_notify_callback(USB_DEV_EVENT_BUS_RESET,NULL,temp);
+ }
+
+ return;
+}
+
+#if USBCFG_DEV_DETACH_ENABLE
+/**************************************************************************//*!
+ *
+ * @name USB_Detach_Service
+ *
+ * @brief The function is called upon a bus reset event.
+ Initializes the control endpoint.
+ *
+ * @param event: for Service callback function
+ *
+ * @return None
+ *****************************************************************************/
+void USB_Detach_Service
+(
+void* handle,
+usb_event_struct_t* event,
+void* arg
+)
+{
+ volatile usb_class_fw_object_struct_t* usb_fw_ptr;
+
+ usb_fw_ptr = (usb_class_fw_object_struct_t*)handle;
+
+ usb_device_reset(usb_fw_ptr->dev_handle);
+
+ /* let the application know that bus reset has taken place */
+ if (usb_fw_ptr->device_notify_callback != NULL)
+ {
+ usb_fw_ptr->device_notify_callback(USB_DEV_EVENT_DETACH, NULL, usb_fw_ptr->device_notify_param);
+ }
+
+ return;
+}
+#endif
+
+#if USBCFG_DEV_KHCI_ADVANCED_ERROR_HANDLING
+/**************************************************************************//*!
+ *
+ * @name USB_Error_Service
+ *
+ * @brief The function is called when an error has been detected
+ *
+ * @param event: for Service callback function
+ *
+ * @return None
+ *****************************************************************************/
+void USB_Error_Service
+(
+void* handle,
+usb_event_struct_t* event,
+void* arg
+)
+{
+ volatile usb_class_fw_object_struct_t* usb_fw_ptr;
+
+ usb_fw_ptr = (usb_class_fw_object_struct_t*)handle;
+
+ /* notify the application of the error */
+ if (usb_fw_ptr->device_notify_callback != NULL)
+ {
+ usb_fw_ptr->device_notify_callback(USB_DEV_EVENT_ERROR,event->buffer_ptr,usb_fw_ptr->device_notify_param);
+ }
+ return;
+}
+#endif
+
+#if USBCFG_DEV_ADVANCED_SUSPEND_RESUME
+/**************************************************************************//*!
+ *
+ * @name USB_Suspend_Service
+ *
+ * @brief The function is called when host suspends the USB port
+ *
+ * @param event: for Service callback function
+ *
+ * @return None
+ *****************************************************************************/
+void USB_Suspend_Service
+(
+void* handle,
+usb_event_struct_t* event,
+void* arg
+)
+{
+ UNUSED_ARGUMENT(handle)
+ UNUSED_ARGUMENT(event)
+ UNUSED_ARGUMENT(arg)
+ return;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Resume_Service
+ *
+ * @brief The function is called when host resumes the USB port
+ *
+ * @param event: for Service callback function
+ *
+ * @return None
+ *****************************************************************************/
+void USB_Resume_Service
+(
+void* handle,
+usb_event_struct_t* event,
+void* arg
+)
+{
+ UNUSED_ARGUMENT(handle)
+ UNUSED_ARGUMENT(event)
+ UNUSED_ARGUMENT(arg)
+ return;
+}
+#endif
+
+/**************************************************************************//*!
+ *
+ * @name USB_Control_Service_Handler
+ *
+ * @brief The function is used to send a response to the Host based.
+ *
+ * @param status: status of Device e.g USB_OK,USBERR_INVALID_REQ_TYPE
+ * @param setup_packet: setup packet received
+ * @param data: data to be send back
+ * @param size: size to be returned
+ *
+ * @return None
+ *
+ *****************************************************************************/
+void USB_Control_Service_Handler
+(
+usb_class_fw_object_struct_t* usb_fw_ptr,
+uint8_t error,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size
+)
+{
+ if (error == USBERR_INVALID_REQ_TYPE)
+ {
+ uint8_t direction = USB_SEND;
+ uint8_t ep_num = USB_CONTROL_ENDPOINT;
+
+ usb_device_stall_endpoint(usb_fw_ptr->dev_handle,ep_num,direction);
+ }
+ else /* Need to send Data to the USB Host */
+ {
+ /* send the data prepared by the handlers.*/
+ if (*size > setup_packet->length)
+ {
+ *size = setup_packet->length;
+ }
+
+ /* send the data to the host */
+ (void)usb_device_send_data(usb_fw_ptr->dev_handle,USB_CONTROL_ENDPOINT, *data, *size);
+ //USB_PRINTF("send %d to host\n", *size);
+
+ if ((setup_packet->request_type & USB_DEV_REQ_STD_REQUEST_TYPE_DIR_POS) == USB_DEV_REQ_STD_REQUEST_TYPE_DIR_IN)
+ {
+ /* Request was to Get Data from device */
+ /* setup recv to get status from host */
+ (void)usb_device_recv_data(usb_fw_ptr->dev_handle,
+ USB_CONTROL_ENDPOINT,NULL,0);
+ //USB_PRINTF("ready to receive ZLT on EP0\n");
+ }
+ }
+ return;
+}
+/*************************************************************************//*!
+ *
+ * @name USB_Strd_Req_Get_Status
+ *
+ * @brief This function is called in response to Get Status request
+ *
+ * @param setup_packet: setup packet received
+ * @param data: data to be send back
+ * @param size: size to be returned
+ *
+ * @return status:
+ * USB_OK : When Successfully
+ * Others : When Error
+ *
+ *****************************************************************************/
+static uint8_t USB_Strd_Req_Get_Status
+(
+usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size
+)
+{
+ uint8_t endpoint;
+ uint8_t error = USBERR_ERROR;
+
+ if ((setup_packet->request_type & USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_POS) == USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_DEVICE)
+ { /* request for Device */
+#ifdef USBCFG_OTG
+ if(setup_packet->index == USB_WINDEX_OTG_STATUS_SEL)
+ {
+ uint8_t hnp_support;
+ (void)usb_device_otg_get_hnp_support(usb_fw_ptr->dev_handle, &hnp_support);
+ if(hnp_support)
+ {
+ error = usb_device_get_status(usb_fw_ptr->dev_handle,
+ (uint8_t)USB_STATUS_OTG, &usb_fw_ptr->std_framework_data);
+ usb_fw_ptr->std_framework_data &= GET_STATUS_OTG_MASK;
+ usb_fw_ptr->std_framework_data = USB_SHORT_LE_TO_HOST(usb_fw_ptr->std_framework_data);
+ *size=OTG_STATUS_SIZE;
+ }
+ else
+ {
+ error = USBERR_INVALID_REQ_TYPE;
+ }
+ }
+ else
+#endif
+ {
+ error = usb_device_get_status(usb_fw_ptr->dev_handle,
+ (uint8_t)USB_STATUS_DEVICE, &usb_fw_ptr->std_framework_data);
+ usb_fw_ptr->std_framework_data &= GET_STATUS_DEVICE_MASK;
+ usb_fw_ptr->std_framework_data = USB_SHORT_LE_TO_HOST(usb_fw_ptr->std_framework_data);
+ *size=DEVICE_STATUS_SIZE;
+ }
+ }
+ else if ((setup_packet->request_type & USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_POS) == USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_INTERFACE)
+ { /* request for Interface */
+ usb_fw_ptr->std_framework_data = 0;
+ *size=INTERFACE_STATUS_SIZE;
+ }
+ else if ((setup_packet->request_type & USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_POS) == USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_ENDPOINT)
+ { /* request for Endpoint */
+ endpoint =(uint8_t)(((uint8_t)setup_packet->index)|USB_STATUS_ENDPOINT);
+ error = usb_device_get_status(usb_fw_ptr->dev_handle,
+ (uint8_t)endpoint,
+ &usb_fw_ptr->std_framework_data);
+ usb_fw_ptr->std_framework_data = USB_SHORT_LE_TO_HOST(usb_fw_ptr->std_framework_data);
+ *size=ENDP_STATUS_SIZE;
+ }
+
+ *data = (uint8_t *)&usb_fw_ptr->std_framework_data;
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Strd_Req_Feature
+ *
+ * @brief This function is called in response to Clear or Set Feature request
+ *
+ * @param setup_packet: setup packet received
+ * @param data: data to be send back
+ * @param size: size to be returned
+ *
+ * @return status:
+ * USB_OK : When Successfully
+ * Others : When Error
+ *
+ *****************************************************************************/
+static uint8_t USB_Strd_Req_Feature
+(
+usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size
+)
+{
+ //uint16_t device_status;
+ uint16_t set_request;
+ uint8_t error=USBERR_INVALID_REQ_TYPE;
+ uint8_t epinfo;
+ uint8_t event;
+ uint8_t feature;
+#if USBCFG_DEV_EHCI && USBCFG_DEV_EHCI_TEST_MODE
+ uint16_t ptc = 0;
+ volatile uint32_t loop = 10*1000*1000;
+#endif
+
+ //UNUSED_ARGUMENT(data)
+ *size=0;
+ /* find whether its a clear feature request or a set feature request */
+ set_request = (uint16_t)((uint16_t)(setup_packet->request & USB_SET_REQUEST_MASK)>>1);
+
+ if ((setup_packet->request_type & USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_POS) == USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_DEVICE)
+ {
+#ifdef USBCFG_OTG
+ if (set_request)
+ {
+ if ((setup_packet->value == USB_DEV_REQ_STD_FEATURE_B_HNP_ENABLE) || (setup_packet->value == USB_DEV_REQ_STD_FEATURE_A_HNP_SUPPORT))
+ {
+ uint8_t hnp_support;
+ (void)usb_device_otg_get_hnp_support(usb_fw_ptr->dev_handle, &hnp_support);
+ if (hnp_support)
+ {
+ error = USB_OK;
+ if (setup_packet->value == USB_DEV_REQ_STD_FEATURE_B_HNP_ENABLE)
+ {
+ (void)usb_device_otg_set_hnp_enable(usb_fw_ptr->dev_handle);
+ }
+ }
+ else
+ {
+ error = USBERR_INVALID_REQ_TYPE;
+ }
+ }
+ }
+#endif
+ /* request for Device */
+ feature = setup_packet->value & USB_DEV_REQ_STD_FEATURE_SELECTOR_MASK;
+ if (feature)
+ {
+ if (feature == USB_DEV_REQ_STD_FEATURE_SELECTOR_DEVICE_REMOTE_WAKEUP)
+ {
+ if (set_request == (uint16_t)TRUE)
+ {
+ event = USB_DEV_EVENT_TYPE_SET_REMOTE_WAKEUP;
+ }
+ else
+ { /* remove the request to be cleared from device_status */
+ event = USB_DEV_EVENT_TYPE_CLR_REMOTE_WAKEUP;
+ }
+ error = USB_OK;
+ if (usb_fw_ptr->device_notify_callback)
+ {
+ usb_fw_ptr->device_notify_callback(event, NULL, usb_fw_ptr->request_notify_param);
+ }
+ }
+ else if (feature == USB_DEV_REQ_STD_FEATURE_SELECTOR_TEST_MODE)
+ {
+#if USBCFG_DEV_EHCI && USBCFG_DEV_EHCI_TEST_MODE
+ (void)usb_device_send_data(usb_fw_ptr->dev_handle,USB_CONTROL_ENDPOINT, NULL, 0);
+ /* need add some delay to wait for zero length packet is sent complete */
+ while(loop --)
+ {
+ ;
+ }
+ ptc = setup_packet->index >> 8;
+ usb_device_set_status(usb_fw_ptr->dev_handle, USB_STATUS_TEST_MODE, ptc);
+ error = USB_OK;
+#endif
+ }
+ }
+ else
+ {
+ /* TODO */
+ /* if the feature is 0, a request error need to be sent out*/
+
+ }
+ }
+ else if ((setup_packet->request_type & USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_POS) == USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_ENDPOINT)
+ {
+ /* request for Endpoint */
+ feature = setup_packet->value & USB_DEV_REQ_STD_FEATURE_SELECTOR_MASK;
+ if (feature == 0)
+ {
+ epinfo = (uint8_t)(setup_packet->index & 0x00FF);
+ if(set_request)
+ {
+ event = USB_DEV_EVENT_TYPE_SET_EP_HALT;
+ error = usb_device_stall_endpoint(usb_fw_ptr->dev_handle,epinfo & 0x0F, (uint8_t)(epinfo & 0x80) >> 7);
+ }
+ else
+ {
+ event = USB_DEV_EVENT_TYPE_CLR_EP_HALT;
+ if ((epinfo & 0x0f) == 0)
+ {
+ error = usb_device_unstall_endpoint(usb_fw_ptr->dev_handle,epinfo & 0x0F, (uint8_t)(epinfo & 0x80) >> 7);
+ }
+ }
+ if(usb_fw_ptr->device_notify_callback)
+ {
+ usb_fw_ptr->device_notify_callback(event, (void*)&epinfo, usb_fw_ptr->request_notify_param);
+ error = USB_OK;
+ }
+ }
+ else
+ {
+ /* TODO */
+ /* if feature is not 0, request error need to be sent out */
+ }
+
+ }
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Strd_Req_Set_Address
+ *
+ * @brief This function is called in response to Set Address request
+ *
+ * @param setup_packet: setup packet received
+ * @param data: data to be send back
+ * @param size: size to be returned
+ *
+ * @return status:
+ * USB_OK : When Successfully
+ * Others : When Error
+ *
+ *****************************************************************************/
+static uint8_t USB_Strd_Req_Set_Address
+(
+usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size
+)
+{
+ //UNUSED_ARGUMENT(data)
+ *size=0;
+ /* update device state */
+ (void)usb_device_set_status(usb_fw_ptr->dev_handle,
+ (uint8_t)USB_STATUS_DEVICE_STATE,
+ (uint16_t)USB_STATE_PENDING_ADDRESS);
+ /*store the address from setup_packet into assigned_address*/
+ usb_fw_ptr->assigned_address = setup_packet->value;
+
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Strd_Req_Assign_Address
+ *
+ * @brief This function assigns the address to the Device
+ *
+ * @param handle
+ *
+ * @return status
+ * USB_OK: Always
+ *
+ *****************************************************************************/
+static uint8_t USB_Strd_Req_Assign_Address
+(
+usb_class_fw_object_struct_t* usb_fw_ptr
+)
+{
+ /* Set Device Address */
+ (void)usb_device_set_address(usb_fw_ptr->dev_handle,
+ (uint8_t)(usb_fw_ptr->assigned_address&0x00FF));
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Strd_Req_Get_Config
+ *
+ * @brief This function is called in response to Get Config request
+ *
+ * @param setup_packet: setup packet received
+ * @param data: data to be send back
+ * @param size: size to be returned
+ *
+ * @return status:
+ * USB_OK : Always
+ *
+ *****************************************************************************/
+static uint8_t USB_Strd_Req_Get_Config
+(
+usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size
+)
+{
+ //UNUSED_ARGUMENT(setup_packet)
+
+ *size = CONFIG_SIZE;
+ usb_fw_ptr->cur_config = USB_SHORT_LE_TO_HOST(usb_fw_ptr->cur_config);
+ *data = (uint8_t *)(&usb_fw_ptr->cur_config);
+
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Strd_Req_Set_Config
+ *
+ * @brief This function is called in response to Set Config request
+ *
+ * @param setup_packet: setup packet received
+ * @param data: data to be send back
+ * @param size: size to be returned
+ *
+ * @return status:
+ * USB_OK : When Successfully
+ * Others : When Error
+ *
+ *****************************************************************************/
+static uint8_t USB_Strd_Req_Set_Config
+(
+usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size
+)
+{
+ uint8_t error = USBERR_INVALID_REQ_TYPE;
+ uint16_t config_val;
+
+ uint16_t device_state = USB_STATE_CONFIG;
+ //UNUSED_ARGUMENT(data)
+ *size=0;
+ error = USB_STATUS_ERROR;
+ config_val = setup_packet->value;
+
+ if (!config_val) /* if config_val is 0 */
+ {
+ device_state = USB_STATE_ADDRESS;
+ }
+
+ error = usb_device_set_status(usb_fw_ptr->dev_handle,
+ (uint8_t)USB_STATUS_DEVICE_STATE,
+ (uint16_t)device_state);
+
+ usb_fw_ptr->cur_config = config_val;
+ /* Set configuration according to config number*/
+ if(NULL != usb_fw_ptr->desc_notify_callback->set_configuration)
+ {
+ usb_fw_ptr->desc_notify_callback->set_configuration((uint32_t)usb_fw_ptr->desc_notify_param,(uint8_t)config_val);
+ }
+ /* callback to the app. to let the application know about the new Config */
+ if (usb_fw_ptr->device_notify_callback != NULL)
+ {
+ usb_fw_ptr->device_notify_callback(USB_DEV_EVENT_CONFIG_CHANGED,
+ (void *)&config_val,usb_fw_ptr->device_notify_param);
+ if(config_val)
+ {
+ usb_fw_ptr->device_notify_callback(USB_DEV_EVENT_ENUM_COMPLETE,NULL,
+ usb_fw_ptr->device_notify_param);
+ }
+ }
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Strd_Req_Get_Interface
+ *
+ * @brief This function is called in response to Get Interface request
+ *
+ * @param setup_packet: setup packet received
+ * @param data: data to be send back
+ * @param size: size to be returned
+ *
+ * @return status:
+ * USB_OK : When Successfully
+ * Others : When Error
+ *
+ *****************************************************************************/
+static uint8_t USB_Strd_Req_Get_Interface
+(
+usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size
+)
+{
+ uint8_t error = USBERR_NULL_CALLBACK;
+
+ *size = INTERFACE_STATUS_SIZE;
+
+ if(!usb_fw_ptr->desc_notify_callback->get_desc_interface)
+ {
+ return error;
+ }
+
+ error = usb_fw_ptr->desc_notify_callback->get_desc_interface((uint32_t)(usb_fw_ptr->desc_notify_param),
+ (uint8_t)setup_packet->index, (uint8_t *)&usb_fw_ptr->std_framework_data);
+ usb_fw_ptr->std_framework_data = USB_SHORT_LE_TO_HOST(usb_fw_ptr->std_framework_data);
+ *data = (uint8_t *)&usb_fw_ptr->std_framework_data;
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Strd_Req_Set_Interface
+ *
+ * @brief This function is called in response to Set Interface request
+ *
+ * @param setup_packet: setup packet received
+ * @param data: data to be send back
+ * @param size: size to be returned
+ *
+ * @return status:
+ * USB_OK : Always
+ *
+ *****************************************************************************/
+static uint8_t USB_Strd_Req_Set_Interface
+(
+usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size
+)
+{
+ uint8_t error = USBERR_NULL_CALLBACK;
+ //UNUSED_ARGUMENT(data)
+ *size=0;
+
+ /* Request type not for interface */
+ if ((setup_packet->request_type & 0x03) != 0x01)
+ {
+ return USB_STATUS_ERROR;
+ }
+
+ if(!usb_fw_ptr->desc_notify_callback->set_desc_interface)
+ {
+ return error;
+ }
+
+ /* Get Interface and alternate interface from setup_packet */
+ error = usb_fw_ptr->desc_notify_callback->set_desc_interface((uint32_t)(usb_fw_ptr->desc_notify_param),
+ (uint8_t)setup_packet->index, (uint8_t)setup_packet->value);
+
+ if (usb_fw_ptr->device_notify_callback != NULL)
+ {
+ usb_fw_ptr->device_notify_callback(USB_DEV_EVENT_INTERFACE_CHANGED,
+ (void *)&setup_packet->value, usb_fw_ptr->device_notify_param);
+ }
+
+ return USB_OK;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Strd_Req_Sync_Frame
+ *
+ * @brief This function is called in response to Sync Frame request
+ *
+ * @param setup_packet: setup packet received
+ * @param data: data to be send back
+ * @param size: size to be returned
+ *
+ * @return status:
+ * USB_OK : When Successfully
+ * Others : When Error
+ *
+ *****************************************************************************/
+static uint8_t USB_Strd_Req_Sync_Frame
+(
+usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size
+)
+{
+ uint8_t error;
+ //UNUSED_ARGUMENT(setup_packet)
+
+ *size=FRAME_SIZE;
+ /* Get the frame number */
+ error = usb_device_get_status(usb_fw_ptr->dev_handle,
+ (uint8_t)USB_STATUS_SOF_COUNT,
+ &usb_fw_ptr->std_framework_data);
+ usb_fw_ptr->std_framework_data = USB_SHORT_LE_TO_HOST(usb_fw_ptr->std_framework_data);
+ *data= (uint8_t *)&usb_fw_ptr->std_framework_data;
+
+ return error;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Std_Req_Get_Descriptor
+ *
+ * @brief This function is called in response to Get Descriptor request
+ *
+ * @param setup_packet: setup packet received
+ * @param data: data to be send back
+ * @param size: size to be returned
+ *
+ * @return status:
+ * USB_OK : When Successfully
+ * Others : When Error
+ *
+ *****************************************************************************/
+static uint8_t USB_Strd_Req_Get_Descriptor
+(
+usb_class_fw_object_struct_t* usb_fw_ptr,
+usb_setup_struct_t * setup_packet,
+uint8_t * *data,
+uint32_t *size
+)
+{
+ /*g_setup_packet.hValue*/
+ uint8_t type = (uint8_t)(setup_packet->value >> 8) & 0xFF;
+ uint16_t index = (uint8_t)USB_UNINITIALIZED_VAL_32;
+ uint8_t str_num = (uint8_t)USB_UNINITIALIZED_VAL_32;
+ uint8_t error = USBERR_NULL_CALLBACK;
+
+ /* for string descriptor set the language and string number */
+ index = setup_packet->index;
+ /*g_setup_packet.lValue*/
+ str_num = setup_packet->value & 0xFF;
+
+ if(!usb_fw_ptr->desc_notify_callback->get_desc)
+ {
+ return error;
+ }
+ /* Call descriptor class to get descriptor */
+ error = usb_fw_ptr->desc_notify_callback->get_desc((uint32_t)(usb_fw_ptr->desc_notify_param),
+ type,str_num,index,data,size);
+
+ return error;
+}
+#if 0
+/**************************************************************************//*!
+ *
+ * @name USB_Framework_GetDesc
+ *
+ * @brief This function is called in to get the descriptor as specified in cmd.
+ *
+ * @param handle: USB framework handle. Received from
+ * USB_Framework_Init
+ * @param cmd: command for USB descriptor to get.
+ * @param in_data: input to the Application functions.
+ * @param in_buff buffer which will contain the descriptors.
+ * @return status:
+ * USB_OK : When Successfully
+ * Others : When Error
+ *
+ *****************************************************************************/
+static uint8_t USB_Framework_GetDesc
+(
+usb_class_fw_handle handle, /*[IN]*/
+int32_t cmd,/*[IN]*/
+uint8_t in_data,/*[IN]*/
+uint8_t * * in_buff/*[OUT]*/
+)
+{
+ return 0;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Framework_SetDesc
+ *
+ * @brief This function is called in to get the descriptor as specified in cmd.
+ *
+ * @param handle: USB framework handle. Received from
+ * USB_Framework_Init
+ * @param cmd: command for USB descriptor to get.
+ * @param in_data: input to the Application functions.
+ * @param outBuf buffer which will contain the descriptors.
+ * @return status:
+ * USB_OK : When Successfully
+ * Others : When Error
+ *
+ *****************************************************************************/
+static uint8_t USB_Framework_SetDesc
+(
+usb_class_fw_handle handle,/*[IN]*/
+int32_t cmd,/*[IN]*/
+uint8_t input_data,/*[IN]*/
+uint8_t * * outBuf/*[IN]*/
+)
+{
+ return 0;
+}
+
+/**************************************************************************//*!
+ *
+ * @name USB_Framework_Remote_wakeup
+ *
+ * @brief This function is called in to get the descriptor as specified in cmd.
+ *
+ * @param handle: USB framework handle. Received from
+ * USB_Framework_Init
+ * @param cmd: command for USB descriptor to get.
+ * @param in_data: input to the Application functions.
+ * @param in_buff buffer which will contain the descriptors.
+ * @return status:
+ * USB_OK : When Successfully
+ * Others : When Error
+ *
+ *****************************************************************************/
+bool USB_Framework_Remote_wakeup
+(
+usb_class_fw_handle handle
+)
+{
+ return 0;
+}
+#endif
+
+#endif
diff --git a/KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_framework.h b/KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_framework.h
new file mode 100644
index 0000000..e4362e5
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/device/sources/controller/usb_framework.h
@@ -0,0 +1,188 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2008, 2013 - 2014 Freescale Semiconductor;
+* All Rights Reserved
+*
+* Copyright (c) 1989-2008 ARC International;
+* All Rights Reserved
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: usb_framework.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+* @brief The file contains USB Framework module api header function.
+*
+*****************************************************************************/
+
+#ifndef _USB_FRAMEWORK_H
+#define _USB_FRAMEWORK_H 1
+
+/******************************************************************************
+ * Includes
+ *****************************************************************************/
+
+/******************************************************************************
+ * Constants - None
+ *****************************************************************************/
+
+/******************************************************************************
+ * Macro's
+ *****************************************************************************/
+#define MAX_STRD_REQ (13) /* Max value of standard request */
+/* size of data to be returned for various Get Desc calls */
+#define DEVICE_STATUS_SIZE (2)
+#define INTERFACE_STATUS_SIZE (1)
+#define CONFIG_SIZE (1)
+#define FRAME_SIZE (2)
+#define ENDP_STATUS_SIZE (2)
+#define USB_SET_REQUEST_MASK (0x02)
+/* wIndex values for GET_Status */
+#define USB_WINDEX_OTG_STATUS_SEL (0xF000)
+#define GET_STATUS_OTG_MASK (0x0001)
+#define OTG_STATUS_SIZE (1)
+/******************************************************************************
+ * Types
+ *****************************************************************************/
+typedef uint32_t usb_class_fw_handle;
+
+/* Strucutre holding USB state information and handles.*/
+typedef struct _usb_class_fw_object
+{
+ uint16_t std_framework_data;
+ uint16_t assigned_address;
+ usb_device_handle controller_handle;
+ usb_device_handle dev_handle;
+ usb_setup_struct_t setup_packet;
+ uint8_t* ext_req_to_host;
+ usb_device_notify_t device_notify_callback;
+ void* device_notify_param;
+ usb_request_notify_t request_notify_callback;
+ void* request_notify_param;
+ usb_desc_request_notify_struct_t* desc_notify_callback;
+ void* desc_notify_param;
+ uint16_t cur_config;
+}usb_class_fw_object_struct_t;
+
+ /* callback function pointer structure to handle USB framework request */
+typedef uint8_t (_CODE_PTR_ USB_FW_REQ_FUNC)(usb_class_fw_object_struct_t* usb_fw_ptr,
+ usb_setup_struct_t * setup_packet,
+ uint8_t * *data,
+ uint32_t *size);
+
+/******************************************************************************
+ * Global Functions
+ *****************************************************************************/
+/**************************************************************************//*!
+ *
+ * @name USB_Framework_Periodic_Task
+ *
+ * @brief The function is called to respond to any control request
+ *
+ * @param None
+ *
+ * @return None
+ *
+ *****************************************************************************/
+#ifdef DELAYED_PROCESSING
+extern void USB_Framework_Periodic_Task(void);
+#endif
+/**************************************************************************//*!
+ *
+ * @name USB_Framework_Reset
+ *
+ * @brief The function resets the framework
+ *
+ * @param handle: handle to Identify the controller
+ *
+ * @return status
+ * USB_OK : When Successfully
+ * Others : Errors
+ *
+ *****************************************************************************/
+extern uint8_t USB_Framework_Reset
+(
+ usb_device_handle handle /*[IN] the USB device controller to initialize*/
+);
+
+/**************************************************************************//*!
+ *
+ * @name USB_Framework_GetDesc
+ *
+ * @brief This function is called in to get the descriptor as specified in cmd.
+ *
+ * @param handle: USB framework handle. Received from
+ * USB_Framework_Init
+ * @param cmd: command for USB descriptor to get.
+ * @param in_data: input to the Application functions.
+ * @param in_buff buffer which will contain the descriptors.
+ * @return status:
+ * USB_OK : When Successfully
+ * Others : When Error
+ *
+ *****************************************************************************/
+uint8_t USB_Framework_GetDesc(usb_class_fw_handle handle, /*[IN]*/
+int32_t cmd,/*[IN]*/
+uint8_t in_data,/*[IN]*/
+uint8_t * * in_buff/*[OUT]*/
+);
+
+/**************************************************************************//*!
+ *
+ * @name USB_Framework_SetDesc
+ *
+ * @brief This function is called in to get the descriptor as specified in cmd.
+ *
+ * @param handle: USB framework handle. Received from
+ * USB_Framework_Init
+ * @param cmd: command for USB descriptor to get.
+ * @param in_data: input to the Application functions.
+ * @param outBuf buffer which will contain the descriptors.
+ * @return status:
+ * USB_OK : When Successfully
+ * Others : When Error
+ *
+ *****************************************************************************/
+uint8_t USB_Framework_SetDesc(usb_class_fw_handle handle,/*[IN]*/
+int32_t cmd,/*[IN]*/
+uint8_t input_data,/*[IN]*/
+uint8_t * * outBuf/*[IN]*/
+);
+/**************************************************************************//*!
+ *
+ * @name USB_Framework_Remote_wakeup
+ *
+ * @brief This function is called in to get the descriptor as specified in cmd.
+ *
+ * @param handle: USB framework handle. Received from
+ * USB_Framework_Init
+ * @param cmd: command for USB descriptor to get.
+ * @param in_data: input to the Application functions.
+ * @param in_buff buffer which will contain the descriptors.
+ * @return status:
+ * USB_OK : When Successfully
+ * Others : When Error
+ *
+ *****************************************************************************/
+bool USB_Framework_Remote_wakeup(usb_class_fw_handle handle/*[IN]*/);
+
+#endif
+
+/* EOF */
diff --git a/KSDK_1.2.0/usb/usb_core/hal/fsl_usb_features.h b/KSDK_1.2.0/usb/usb_core/hal/fsl_usb_features.h
new file mode 100644
index 0000000..998258a
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/hal/fsl_usb_features.h
@@ -0,0 +1,126 @@
+/*
+** ###################################################################
+** Version: rev. 1.0, 2015-01-16
+** Build: b150116
+**
+** Abstract:
+** Chip specific module features.
+**
+** Copyright (c) 2015 Freescale Semiconductor, Inc.
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+**
+** o Redistributions of source code must retain the above copyright notice, this list
+** of conditions and the following disclaimer.
+**
+** o Redistributions in binary form must reproduce the above copyright notice, this
+** list of conditions and the following disclaimer in the documentation and/or
+** other materials provided with the distribution.
+**
+** o Neither the name of Freescale Semiconductor, Inc. nor the names of its
+** contributors may be used to endorse or promote products derived from this
+** software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+** DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+** ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+** ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**
+** http: www.freescale.com
+** mail: support@freescale.com
+**
+** Revisions:
+** - rev. 1.0 (2015-01-16)
+** Initial version.
+**
+** ###################################################################
+*/
+
+#if !defined(__FSL_USB_FEATURES_H__)
+#define __FSL_USB_FEATURES_H__
+
+#if defined(CPU_MK20DN512VLK10) || defined(CPU_MK20DX256VLK10) || defined(CPU_MK20DN512VLL10) || defined(CPU_MK20DX256VLL10) || \
+ defined(CPU_MK20DX128VLQ10) || defined(CPU_MK20DX256VLQ10) || defined(CPU_MK20DN512VLQ10) || defined(CPU_MK20DX256VMC10) || \
+ defined(CPU_MK20DN512VMC10) || defined(CPU_MK20DX128VMD10) || defined(CPU_MK20DX256VMD10) || defined(CPU_MK20DN512VMD10) || \
+ defined(CPU_MK21DX128AVLK5) || defined(CPU_MK21DX256AVLK5) || defined(CPU_MK21DN512AVLK5) || defined(CPU_MK21DX128AVMC5) || \
+ defined(CPU_MK21DX256AVMC5) || defined(CPU_MK21DN512AVMC5) || defined(CPU_MK21FX512AVLQ12) || defined(CPU_MK21FN1M0AVLQ12) || \
+ defined(CPU_MK21FX512AVMC12) || defined(CPU_MK21FN1M0AVMC12) || defined(CPU_MK21FX512AVMD12) || defined(CPU_MK21FN1M0AVMD12) || \
+ defined(CPU_MK22FN128VDC10) || defined(CPU_MK22FN128VLH10) || defined(CPU_MK22FN128VLL10) || defined(CPU_MK22FN128VMP10) || \
+ defined(CPU_MK22FN256CAH12) || defined(CPU_MK22FN128CAH12) || defined(CPU_MK22FN256VDC12) || defined(CPU_MK22FN256VLH12) || \
+ defined(CPU_MK22FN256VLL12) || defined(CPU_MK22FN256VMP12) || defined(CPU_MK22FN512CAP12) || defined(CPU_MK22FN512VDC12) || \
+ defined(CPU_MK22FN512VLH12) || defined(CPU_MK22FN512VLL12) || defined(CPU_MK22FN512VMP12) || defined(CPU_MK24FN1M0VDC12) || \
+ defined(CPU_MK24FN1M0VLL12) || defined(CPU_MK24FN1M0VLQ12) || defined(CPU_MK24FN256VDC12) || defined(CPU_MK26FN2M0CAC18) || \
+ defined(CPU_MK40DN512VLK10) || defined(CPU_MK40DN512VLL10) || defined(CPU_MK40DX128VLQ10) || defined(CPU_MK40DX256VLQ10) || \
+ defined(CPU_MK40DN512VLQ10) || defined(CPU_MK40DN512VMC10) || defined(CPU_MK40DX128VMD10) || defined(CPU_MK40DX256VMD10) || \
+ defined(CPU_MK40DN512VMD10) || defined(CPU_MK50DX256CLL10) || defined(CPU_MK50DN512CLL10) || defined(CPU_MK50DN512CLQ10) || \
+ defined(CPU_MK50DX256CMC10) || defined(CPU_MK50DN512CMC10) || defined(CPU_MK50DN512CMD10) || defined(CPU_MK50DX256CMD10) || \
+ defined(CPU_MK50DX256CLK10) || defined(CPU_MK51DX256CLL10) || defined(CPU_MK51DN512CLL10) || defined(CPU_MK51DN256CLQ10) || \
+ defined(CPU_MK51DN512CLQ10) || defined(CPU_MK51DX256CMC10) || defined(CPU_MK51DN512CMC10) || defined(CPU_MK51DN256CMD10) || \
+ defined(CPU_MK51DN512CMD10) || defined(CPU_MK51DX256CLK10) || defined(CPU_MK52DN512CLQ10) || defined(CPU_MK52DN512CMD10) || \
+ defined(CPU_MK53DN512CLQ10) || defined(CPU_MK53DX256CLQ10) || defined(CPU_MK53DN512CMD10) || defined(CPU_MK53DX256CMD10) || \
+ defined(CPU_MK60DN256VLL10) || defined(CPU_MK60DX256VLL10) || defined(CPU_MK60DN512VLL10) || defined(CPU_MK60DN256VLQ10) || \
+ defined(CPU_MK60DX256VLQ10) || defined(CPU_MK60DN512VLQ10) || defined(CPU_MK60DN256VMC10) || defined(CPU_MK60DX256VMC10) || \
+ defined(CPU_MK60DN512VMC10) || defined(CPU_MK60DN256VMD10) || defined(CPU_MK60DX256VMD10) || defined(CPU_MK60DN512VMD10) || \
+ defined(CPU_MK63FN1M0VLQ12) || defined(CPU_MK63FN1M0VMD12) || defined(CPU_MK64FX512VDC12) || defined(CPU_MK64FN1M0VDC12) || \
+ defined(CPU_MK64FX512VLL12) || defined(CPU_MK64FN1M0VLL12) || defined(CPU_MK64FX512VLQ12) || defined(CPU_MK64FN1M0VLQ12) || \
+ defined(CPU_MK64FX512VMD12) || defined(CPU_MK64FN1M0VMD12) || defined(CPU_MK65FN2M0CAC18) || defined(CPU_MK65FX1M0CAC18) || \
+ defined(CPU_MK65FN2M0VMI18) || defined(CPU_MK65FX1M0VMI18) || defined(CPU_MK66FN2M0VLQ18) || defined(CPU_MK66FX1M0VLQ18) || \
+ defined(CPU_MK66FN2M0VMD18) || defined(CPU_MK66FX1M0VMD18) || defined(CPU_MKL24Z32VFM4) || defined(CPU_MKL24Z64VFM4) || \
+ defined(CPU_MKL24Z32VFT4) || defined(CPU_MKL24Z64VFT4) || defined(CPU_MKL24Z32VLH4) || defined(CPU_MKL24Z64VLH4) || \
+ defined(CPU_MKL24Z32VLK4) || defined(CPU_MKL24Z64VLK4) || defined(CPU_MKL25Z32VFM4) || defined(CPU_MKL25Z64VFM4) || \
+ defined(CPU_MKL25Z128VFM4) || defined(CPU_MKL25Z32VFT4) || defined(CPU_MKL25Z64VFT4) || defined(CPU_MKL25Z128VFT4) || \
+ defined(CPU_MKL25Z32VLH4) || defined(CPU_MKL25Z64VLH4) || defined(CPU_MKL25Z128VLH4) || defined(CPU_MKL25Z32VLK4) || \
+ defined(CPU_MKL25Z64VLK4) || defined(CPU_MKL25Z128VLK4) || defined(CPU_MKL26Z128CAL4) || defined(CPU_MKL26Z32VFM4) || \
+ defined(CPU_MKL26Z64VFM4) || defined(CPU_MKL26Z128VFM4) || defined(CPU_MKL26Z32VFT4) || defined(CPU_MKL26Z64VFT4) || \
+ defined(CPU_MKL26Z128VFT4) || defined(CPU_MKL26Z32VLH4) || defined(CPU_MKL26Z64VLH4) || defined(CPU_MKL26Z128VLH4) || \
+ defined(CPU_MKL26Z256VLH4) || defined(CPU_MKL26Z128VLL4) || defined(CPU_MKL26Z256VLL4) || defined(CPU_MKL26Z128VMC4) || \
+ defined(CPU_MKL26Z256VMC4) || defined(CPU_MKL26Z256VMP4) || defined(CPU_MKL46Z128VLH4) || defined(CPU_MKL46Z256VLH4) || \
+ defined(CPU_MKL46Z128VLL4) || defined(CPU_MKL46Z256VLL4) || defined(CPU_MKL46Z128VMC4) || defined(CPU_MKL46Z256VMC4) || \
+ defined(CPU_MKL46Z256VMP4) || defined(CPU_MKW22D512VHA5) || defined(CPU_MKW24D512VHA5)
+ /* @brief HOST mode enabled */
+ #define FSL_FEATURE_USB_KHCI_HOST_ENABLED (1)
+ /* @brief OTG mode enabled */
+ #define FSL_FEATURE_USB_KHCI_OTG_ENABLED (1)
+ /* @brief Size of the USB dedicated RAM */
+ #define FSL_FEATURE_USB_KHCI_USB_RAM (0)
+ /* @brief Has KEEP_ALIVE_CTRL register */
+ #define FSL_FEATURE_USB_KHCI_KEEP_ALIVE_ENABLED (0)
+#elif defined(CPU_MKL27Z128VFM4) || defined(CPU_MKL27Z256VFM4) || defined(CPU_MKL27Z128VFT4) || defined(CPU_MKL27Z256VFT4) || \
+ defined(CPU_MKL27Z128VLH4) || defined(CPU_MKL27Z256VLH4) || defined(CPU_MKL27Z128VMP4) || defined(CPU_MKL27Z256VMP4) || \
+ defined(CPU_MKL43Z128VLH4) || defined(CPU_MKL43Z256VLH4) || defined(CPU_MKL43Z128VMP4) || defined(CPU_MKL43Z256VMP4)
+ /* @brief HOST mode enabled */
+ #define FSL_FEATURE_USB_KHCI_HOST_ENABLED (0)
+ /* @brief OTG mode enabled */
+ #define FSL_FEATURE_USB_KHCI_OTG_ENABLED (0)
+ /* @brief Size of the USB dedicated RAM */
+ #define FSL_FEATURE_USB_KHCI_USB_RAM (0)
+ /* @brief Has KEEP_ALIVE_CTRL register */
+ #define FSL_FEATURE_USB_KHCI_KEEP_ALIVE_ENABLED (0)
+#elif defined(CPU_MKL27Z32VDA4) || defined(CPU_MKL27Z64VDA4) || defined(CPU_MKL27Z32VFM4) || defined(CPU_MKL27Z64VFM4) || \
+ defined(CPU_MKL27Z32VFT4) || defined(CPU_MKL27Z64VFT4) || defined(CPU_MKL27Z32VLH4) || defined(CPU_MKL27Z64VLH4) || \
+ defined(CPU_MKL27Z32VMP4) || defined(CPU_MKL27Z64VMP4)
+ /* @brief HOST mode enabled */
+ #define FSL_FEATURE_USB_KHCI_HOST_ENABLED (0)
+ /* @brief OTG mode enabled */
+ #define FSL_FEATURE_USB_KHCI_OTG_ENABLED (0)
+ /* @brief Size of the USB dedicated RAM */
+ #define FSL_FEATURE_USB_KHCI_USB_RAM (512)
+ /* @brief Has KEEP_ALIVE_CTRL register */
+ #define FSL_FEATURE_USB_KHCI_KEEP_ALIVE_ENABLED (1)
+#else
+ #error "No valid CPU defined!"
+#endif
+
+#endif /* __FSL_USB_FEATURES_H__ */
+
+/*******************************************************************************
+ * EOF
+ ******************************************************************************/
diff --git a/KSDK_1.2.0/usb/usb_core/hal/fsl_usb_khci_hal.c b/KSDK_1.2.0/usb/usb_core/hal/fsl_usb_khci_hal.c
new file mode 100644
index 0000000..c2ac8c1
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/hal/fsl_usb_khci_hal.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2013, Freescale Semiconductor, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * o Redistributions of source code must retain the above copyright notice, this list
+ * of conditions and the following disclaimer.
+ *
+ * o Redistributions in binary form must reproduce the above copyright notice, this
+ * list of conditions and the following disclaimer in the documentation and/or
+ * other materials provided with the distribution.
+ *
+ * o Neither the name of Freescale Semiconductor, Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "fsl_usb_khci_hal.h"
+//#include "fsl_platform_common.h"
+
+////////////////////////////////////////////////////////////////////////////////
+// Code
+////////////////////////////////////////////////////////////////////////////////
+
diff --git a/KSDK_1.2.0/usb/usb_core/hal/fsl_usb_khci_hal.h b/KSDK_1.2.0/usb/usb_core/hal/fsl_usb_khci_hal.h
new file mode 100644
index 0000000..7302bbe
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/hal/fsl_usb_khci_hal.h
@@ -0,0 +1,1879 @@
+/*
+ * Copyright (c) 2013 - 2015, Freescale Semiconductor, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * o Redistributions of source code must retain the above copyright notice, this list
+ * of conditions and the following disclaimer.
+ *
+ * o Redistributions in binary form must reproduce the above copyright notice, this
+ * list of conditions and the following disclaimer in the documentation and/or
+ * other materials provided with the distribution.
+ *
+ * o Neither the name of Freescale Semiconductor, Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __FSL_USB_KHCI_HAL_H__
+#define __FSL_USB_KHCI_HAL_H__
+
+#include "adapter.h"
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK)
+ #include <stdint.h>
+ #include <stdbool.h>
+ #include <assert.h>
+ #include "fsl_usb_features.h"
+ #include "fsl_device_registers.h"
+ #define NEW_USB_KHCI_HAL_ENABLE 1
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_BM)
+ #include "fsl_usb_features.h"
+ #if (defined(CPU_MK22F51212))
+ #include "MK22F51212.h"
+ #include "MK22F51212_usb.h"
+ #define NEW_USB_KHCI_HAL_ENABLE 0
+ #elif (defined(CPU_MK22F12810))
+ #include "MK22F12810.h"
+ #include "MK22F12810_usb.h"
+ #define NEW_USB_KHCI_HAL_ENABLE 0
+ #elif (defined(CPU_MK70F12))
+ #include "MK70F12.h"
+ #include "MK70F12_usb.h"
+ #define NEW_USB_KHCI_HAL_ENABLE 0
+ #elif (defined(CPU_MKL25Z))
+ #include "MKL25Z4.h"
+ #include "MKL25Z4_usb.h"
+ #define NEW_USB_KHCI_HAL_ENABLE 0
+ #elif (defined(CPU_MKL27Z64VLH4))
+ #include "MKL27Z644.h"
+ #include "MKL27Z644_usb.h"
+ #define NEW_USB_KHCI_HAL_ENABLE 0
+ #elif (defined(CPU_MKL26Z))
+ #include "MKL26Z4.h"
+ #include "MKL26Z4_usb.h"
+ #define NEW_USB_KHCI_HAL_ENABLE 0
+ #elif (defined(CPU_MK64F12))
+ #include "MK64F12.h"
+ #include "MK64F12_usb.h"
+ #define NEW_USB_KHCI_HAL_ENABLE 0
+ #endif
+#elif (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ #include "fsl_usb_features.h"
+ #if (defined(CPU_MK22F51212))
+ #include "MK22F51212.h"
+ #define NEW_USB_KHCI_HAL_ENABLE 0
+ #elif (defined(CPU_MK70F12))
+ #include "MK70F12.h"
+ #define NEW_USB_KHCI_HAL_ENABLE 0
+ #elif (defined(CPU_MK64F12))
+ #include "MK64F12.h"
+ #define NEW_USB_KHCI_HAL_ENABLE 0
+ #endif
+#endif
+
+
+#define usb_hal_khci_bdt_set_address(bdt_base, ep, direction, odd, address) \
+ *((uint32_t*)((bdt_base & 0xfffffe00) | (((uint32_t)ep & 0x0f) << 5) | (((uint32_t)direction & 1) << 4) | (((uint32_t)odd & 1) << 3)) + 1) = address
+
+
+#define usb_hal_khci_bdt_set_control(bdt_base, ep, direction, odd, control) \
+ *(uint32_t*)((bdt_base & 0xfffffe00) | (((uint32_t)ep & 0x0f) << 5) | (((uint32_t)direction & 1) << 4) | (((uint32_t)odd & 1) << 3)) = control
+
+#define usb_hal_khci_bdt_get_address(bdt_base, ep, direction, odd) \
+ (*((uint32_t*)((bdt_base & 0xfffffe00) | (((uint32_t)ep & 0x0f) << 5) | (((uint32_t)direction & 1) << 4) | (((uint32_t)odd & 1) << 3)) + 1))
+
+
+#define usb_hal_khci_bdt_get_control(bdt_base, ep, direction, odd) \
+ (*(uint32_t*)((bdt_base & 0xfffffe00) | (((uint32_t)ep & 0x0f) << 5) | (((uint32_t)direction & 1) << 4) | (((uint32_t)odd & 1) << 3)))
+
+
+
+
+#if NEW_USB_KHCI_HAL_ENABLE
+/*!
+ * @addtogroup usb_khci_hal
+ * @{
+ */
+
+/*******************************************************************************
+ * API
+ ******************************************************************************/
+
+#if defined(__cplusplus)
+ extern "C" {
+#endif
+
+
+/*!
+ * @name Initialization
+ * @{
+ */
+
+/*!
+ * @brief Init the BDT page register from the BDT table
+ *
+ * @param baseAddr USB baseAddr id
+ * @param bdtAddress the BDT address resides in memory
+ */
+static inline void usb_hal_khci_set_buffer_descriptor_table_addr(uint32_t baseAddr, uint32_t bdtAddress)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_BDTPAGE1(_baseAddr,(uint8_t)((uint32_t)bdtAddress >> 8));
+ USB_WR_BDTPAGE2(_baseAddr,(uint8_t)((uint32_t)bdtAddress >> 16));
+ USB_WR_BDTPAGE3(_baseAddr,(uint8_t)((uint32_t)bdtAddress >> 24));
+}
+
+
+/*!
+ * @brief Enable the specific Interrupt
+ *
+ * @param baseAddr USB baseAddr id
+ * @param intrType specific interrupt type
+ */
+static inline void usb_hal_khci_enable_interrupts(uint32_t baseAddr, uint32_t intrType)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_SET_INTEN(_baseAddr,(uint8_t)intrType);
+}
+
+#if (FSL_FEATURE_USB_KHCI_OTG_ENABLED)
+/*!
+ * @brief Enable the specific OTG Interrupt
+ *
+ * @param baseAddr USB baseAddr id
+ * @param specific interrupt type
+ *
+ */
+static inline void usb_hal_khci_enable_otg_interrupts(uint32_t baseAddr, uint32_t intrType)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_SET_OTGICR(_baseAddr,(uint8_t)intrType);
+}
+#endif
+
+/*!
+ * @brief Disable the specific Interrupt
+ *
+ * @param baseAddr USB baseAddr id
+ * @param intrType specific interrupt type
+ */
+static inline void usb_hal_khci_disable_interrupts(uint32_t baseAddr, uint32_t intrType)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_CLR_INTEN(_baseAddr, intrType);
+}
+
+/*!
+ * @brief Get the interrupt status
+ *
+ * @param baseAddr USB baseAddr id
+ * @return specific interrupt type
+ */
+static inline uint8_t usb_hal_khci_get_interrupt_status(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ return (USB_RD_ISTAT(_baseAddr));
+}
+
+#if (FSL_FEATURE_USB_KHCI_OTG_ENABLED)
+/*!
+ * @brief Get the otg interrupt status
+ *
+ * @param baseAddr USB baseAddr id
+ *
+ */
+static inline uint8_t usb_hal_khci_get_otg_interrupt_status(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ return (USB_RD_OTGISTAT(_baseAddr));
+}
+
+/*!
+* @brief Clear the specific otg interrupt
+*
+* @param baseAddr usb baseAddr id
+* @param intrType the interrupt type
+*/
+static inline void usb_hal_khci_clr_otg_interrupt(uint32_t baseAddr, uint32_t intrType)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ USB_WR_OTGISTAT(_baseAddr,(uint8_t)intrType);
+}
+
+/*!
+* @brief Clear all the otg interrupts
+*
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_clr_all_otg_interrupts(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ USB_WR_OTGISTAT(_baseAddr,0xFF);
+}
+
+/*!
+ * @brief Check if controller is busy on transferring.
+ *
+ * @param baseAddr USB baseAddr id.
+ * @return the value of the TOKENBUSY bit from the control register
+ */
+static inline uint8_t usb_hal_khci_is_line_stable(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ return ((USB_RD_OTGSTAT(_baseAddr) & USB_OTGSTAT_LINESTATESTABLE_MASK) ? 1:0);
+}
+#endif
+
+/*!
+ * @brief Get the interrupt enable status
+ *
+ * @param baseAddr USB baseAddr id
+ * @return current enabled interrupt types
+ */
+static inline uint8_t usb_hal_khci_get_interrupt_enable_status(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ return (USB_RD_INTEN(_baseAddr));
+}
+
+/*!
+* @brief Clear the specific interrupt
+*
+* @param baseAddr usb baseAddr id
+* @param intrType the interrupt type needs to be cleared
+*/
+static inline void usb_hal_khci_clr_interrupt(uint32_t baseAddr, uint32_t intrType)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+
+ USB_WR_ISTAT(_baseAddr,(uint8_t)intrType);
+}
+
+/*!
+* @brief Clear all the interrupts
+*
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_clr_all_interrupts(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_ISTAT(_baseAddr,0xff);
+}
+
+/*!
+* @brief Judge if an interrupt type happen
+*
+* @param baseAddr usb baseAddr id
+* @param intrType the interrupt type
+* @return the current interrupt type is happen or not
+*/
+static inline uint8_t usb_hal_khci_is_interrupt_issued(uint32_t baseAddr, uint32_t intrType)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ uint8_t temp = USB_RD_ISTAT(_baseAddr);
+ return ( temp & USB_RD_INTEN(_baseAddr) & (intrType));
+}
+
+/*!
+* @brief Enable all the error interrupt
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_enable_all_error_interrupts(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_ERREN(_baseAddr,0xFF);
+}
+
+/*!
+* @brief Disable all the error interrupts
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_disable_all_error_interrupts(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_ERREN(_baseAddr,0);
+}
+
+/*!
+* @brief Enable the specific error interrupts
+* @param baseAddr usb baseAddr id
+* @param errIntrType the error interrupt type
+*/
+static inline void usb_hal_khci_enable_error_interrupts(uint32_t baseAddr, uint32_t errIntrType)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_SET_ERREN(_baseAddr,(uint8_t)errIntrType);
+}
+
+/*!
+* @brief Disable the specific error interrupt
+* @param baseAddr usb baseAddr id
+* @param errIntrType the error interrupt type
+*/
+static inline void usb_hal_khci_disable_error_interrupts(uint32_t baseAddr, uint32_t errorIntrType)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_CLR_ERREN(_baseAddr, errorIntrType);
+}
+
+/*!
+* @brief Get the error interrupt status
+*
+* @param baseAddr usb baseAddr id
+* @return the error interrupt status
+*/
+static inline uint8_t usb_hal_khci_get_error_interrupt_status(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ return (USB_RD_ERRSTAT(_baseAddr));
+}
+
+/*!
+* @brief Get the error interrupt enable status
+*
+* @param baseAddr usb baseAddr id
+* @return the error interrupt enable status
+*/
+static inline uint8_t usb_hal_khci_get_error_interrupt_enable_status(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ return (USB_RD_ERREN(_baseAddr));
+}
+
+/*!
+* @brief Clear all the error interrupt happened
+*
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_clr_all_error_interrupts(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_ERRSTAT(_baseAddr,0xff);
+}
+
+/*!
+* @brief Check if the specific error happened
+*
+* @param baseAddr usb baseAddr id
+* @return the ERRSTAT register together with the error interrupt
+*/
+static inline uint8_t usb_hal_khci_is_error_happend(uint32_t baseAddr, uint32_t errorType)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ return ( USB_RD_ERRSTAT(_baseAddr) & (uint8_t)errorType);
+}
+
+/*!
+ * @brief Clear the TOKENBUSY flag.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_clr_token_busy(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ USB_CLR_CTL(_baseAddr,USB_CTL_TXSUSPENDTOKENBUSY_MASK);
+}
+
+/*!
+ * @brief Check if controller is busy on transferring.
+ *
+ * @param baseAddr USB baseAddr id.
+ * @return the value of the TOKENBUSY bit from the control register
+ */
+static inline uint8_t usb_hal_khci_is_token_busy(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ return (uint8_t)(USB_RD_CTL(_baseAddr) & USB_CTL_TXSUSPENDTOKENBUSY_MASK);
+}
+
+/*!
+ * @brief reset all the BDT odd ping/pong fields.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_set_oddrst(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ USB_SET_CTL(_baseAddr,USB_CTL_ODDRST_MASK);
+}
+
+/*!
+ * @brief clear the ODDRST flag.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_clr_oddrst(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ USB_CLR_CTL(_baseAddr,USB_CTL_ODDRST_MASK);
+}
+
+#if (FSL_FEATURE_USB_KHCI_HOST_ENABLED)
+/*!
+ * @brief Begin to issue RESET signal.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_start_bus_reset(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_SET_CTL(_baseAddr,USB_CTL_RESET_MASK);
+}
+
+/*!
+ * @brief Stop issuing RESET signal
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_stop_bus_reset(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_CLR_CTL(_baseAddr,USB_CTL_RESET_MASK);
+}
+
+/*!
+ * @brief Start to issue resume signal.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_start_resume(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_SET_CTL(_baseAddr,USB_CTL_RESUME_MASK);
+}
+
+/*!
+ * @brief Stop issuing resume signal.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_stop_resume(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_CLR_CTL(_baseAddr,USB_CTL_RESUME_MASK);
+}
+
+/*!
+ * @brief Set the USB controller to host mode
+ *
+ * @param baseAddr USB baseAddr id.
+ *
+ */
+static inline void usb_hal_khci_set_host_mode(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_CTL(_baseAddr,USB_CTL_HOSTMODEEN_MASK);
+}
+
+/*!
+ * @brief Set the USB controller to device mode
+ *
+ * @param baseAddr USB baseAddr id.
+ *
+ */
+static inline void usb_hal_khci_set_device_mode(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_CLR_CTL(_baseAddr,USB_CTL_HOSTMODEEN_MASK);
+}
+#endif
+
+#if (FSL_FEATURE_USB_KHCI_OTG_ENABLED)
+/*!
+ * @brief Set the USB controller to host mode
+ *
+ * @param baseAddr USB baseAddr id.
+ *
+ */
+static inline void usb_hal_khci_enable_otg(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ USB_SET_OTGCTL(_baseAddr,USB_OTGCTL_OTGEN_MASK);
+}
+
+#endif
+
+/*!
+ * @brief Enable SOF.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_enable_sof(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ USB_SET_CTL(_baseAddr,USB_CTL_USBENSOFEN_MASK);
+}
+
+/*!
+ * @brief Disable the USB module.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_disable_sof(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ USB_CLR_CTL(_baseAddr,USB_CTL_USBENSOFEN_MASK);
+}
+
+/*!
+ * @brief Clear the USB controller register
+ *
+ * @param baseAddr USB baseAddr id.
+ *
+ */
+static inline void usb_hal_khci_clear_control_register(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ USB_CLR_CTL(_baseAddr, 0xFFu);
+}
+
+/*!
+ * @brief Get the speed of the USB module.
+ *
+ * @param baseAddr USB baseAddr id.
+ * @return the current line status of the USB module
+ */
+static inline uint8_t usb_hal_khci_get_line_status(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ return ((USB_RD_CTL(_baseAddr) & USB_CTL_JSTATE_MASK) ? 0 : 1);
+}
+
+/*!
+ * @brief
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline uint8_t usb_hal_khci_get_se0_status(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ return ((USB_RD_CTL(_baseAddr) & USB_CTL_SE0_MASK) ? 1 : 0);
+}
+
+
+/*!
+* @brief Get current status
+*
+* @param baseAddr usb baseAddr id
+* @return current status
+*/
+static inline uint8_t usb_hal_khci_get_transfer_status(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ return USB_RD_STAT(_baseAddr);
+}
+
+/*!
+* @brief Get the endpoint number from STAT register
+*
+* @param baseAddr usb baseAddr id
+* @return endpoint number
+*/
+static inline uint8_t usb_hal_khci_get_transfer_done_ep_number(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ return ((uint8_t)(USB_RD_STAT(_baseAddr) & 0xf0) >> 4);
+}
+
+/*!
+* @brief Return the transmit dir from STAT register
+*
+* @param baseAddr usb baseAddr id
+* @return transmit direction
+*/
+static inline uint8_t usb_hal_khci_get_transfer_done_direction(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ return ((USB_RD_STAT(_baseAddr) & USB_STAT_TX_MASK) >>USB_STAT_TX_SHIFT);
+}
+
+/*!
+* @brief Return the even or odd bank from STAT register
+*
+* @param baseAddr usb baseAddr id
+* @return the even or odd bank
+*/
+static inline uint8_t usb_hal_khci_get_transfer_done_odd(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ return ((USB_RD_STAT(_baseAddr) & USB_STAT_ODD_MASK) >> USB_STAT_ODD_SHIFT);
+}
+
+/*!
+* @brief Returned the computed BDT address
+*
+* @param baseAddr usb baseAddr id
+* @return the computed BDT address
+*/
+static inline uint16_t usb_hal_khci_get_frame_number(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ uint16_t temp = (uint16_t)((uint16_t)(USB_RD_FRMNUMH(_baseAddr)) << 8);
+ return ( temp | USB_RD_FRMNUML(_baseAddr) );
+}
+
+/*!
+* @brief Set the device address
+*
+* @param baseAddr usb baseAddr id
+* @param addr the address used to set
+*/
+static inline void usb_hal_khci_set_device_addr(uint32_t baseAddr, uint32_t addr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_ADDR_ADDR(_baseAddr,addr);
+}
+
+#if (FSL_FEATURE_USB_KHCI_HOST_ENABLED == 1)
+/*!
+* @brief Set the transfer target
+*
+* @param baseAddr usb baseAddr id
+* @param address the address used to set
+* @param speed the speed used to set
+*/
+static inline void usb_hal_khci_set_transfer_target(uint32_t baseAddr, uint32_t address, uint32_t speed)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_ADDR(_baseAddr,(uint8_t)((speed == 0) ? (uint8_t)address : USB_ADDR_LSEN_MASK | (uint8_t)address));
+}
+#endif
+
+/*!
+* @brief Init the endpoint0
+*
+* @param baseAddr usb baseAddr id
+* @param isThoughHub endpoint0 is though hub or not
+* @param isIsochPipe current pipe is iso or not
+*/
+static inline void usb_hal_khci_endpoint0_init(uint32_t baseAddr, uint32_t isThoughHub, uint32_t isIsochPipe)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ uint8_t ep_ctl_val;
+#if (FSL_FEATURE_USB_KHCI_HOST_ENABLED)
+ ep_ctl_val = (isThoughHub == 1 ? USB_ENDPT_HOSTWOHUB_MASK : 0)| USB_ENDPT_RETRYDIS_MASK |
+ USB_ENDPT_EPTXEN_MASK | USB_ENDPT_EPRXEN_MASK | (isIsochPipe == 1 ? 0 : USB_ENDPT_EPHSHK_MASK);
+#else
+ ep_ctl_val = USB_ENDPT_EPTXEN_MASK | USB_ENDPT_EPRXEN_MASK |
+ (isIsochPipe == 1 ? 0 : USB_ENDPT_EPHSHK_MASK);
+#endif
+ USB_WR_ENDPT(_baseAddr, 0, ep_ctl_val);
+}
+
+/*!
+* @brief Stop the endpoint
+*
+* @param baseAddr usb baseAddr id
+* @param epNumber endpoint number
+*/
+static inline void usb_hal_khci_endpoint_shut_down(uint32_t baseAddr, uint32_t epNumber)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_ENDPT(_baseAddr,epNumber,0);
+}
+
+#if (FSL_FEATURE_USB_KHCI_HOST_ENABLED)
+/*!
+* @brief Set the flag to indicate if the endpoint is communicating with controller through the hub
+*
+* @param baseAddr usb baseAddr id
+* @param epNumber endpoint number
+*/
+static inline void usb_hal_khci_endpoint_on_hub(uint32_t baseAddr, uint32_t epNumber)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+
+ USB_SET_ENDPT(_baseAddr, epNumber,USB_ENDPT_HOSTWOHUB_MASK);
+}
+#endif
+
+/*!
+* @brief Set the endpoint in host mode which need handshake or not
+*
+* @param baseAddr usb baseAddr id
+* @param epNumber endpoint number
+* @param isEphshkSet needs handshake or not
+*/
+static inline void usb_hal_khci_endpoint_enable_handshake(uint32_t baseAddr, uint32_t epNumber, uint32_t isEphshkSet)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_SET_ENDPT(_baseAddr, epNumber,((isEphshkSet == 1) ? USB_ENDPT_EPHSHK_MASK : 0));
+}
+
+/*!
+* @brief Set the endpoint in host mode which in TX or RX
+*
+* @param baseAddr usb baseAddr id
+* @param epNumber endpoint number
+* @param isEptxenSet in TX or RX
+*/
+static inline void usb_hal_khci_endpoint_set_direction(uint32_t baseAddr, uint32_t epNumber, uint8_t isEptxenSet)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_SET_ENDPT(_baseAddr, epNumber,((isEptxenSet == 1) ? USB_ENDPT_EPTXEN_MASK : USB_ENDPT_EPRXEN_MASK));
+}
+
+/*!
+* @brief Clear the stall status of the endpoint
+*
+* @param baseAddr usb baseAddr id
+* @param epNumber endpoint number
+*/
+static inline void usb_hal_khci_endpoint_clr_stall(uint32_t baseAddr, uint32_t epNumber)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_CLR_ENDPT(_baseAddr, epNumber, USB_ENDPT_EPSTALL_MASK);
+
+}
+
+#if (FSL_FEATURE_USB_KHCI_HOST_ENABLED == 1)
+/*!
+* @brief Enable the support for low speed
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_enable_low_speed_support(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_SET_ADDR(_baseAddr, USB_ADDR_LSEN_MASK);
+}
+
+
+/*!
+* @brief Disable the support for low speed
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_disable_low_speed_support(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_CLR_ADDR(_baseAddr, USB_ADDR_LSEN_MASK);
+}
+#endif
+
+/*!
+* @brief Enable the pull down
+*
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_enable_pull_down(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_SET_USBCTRL(_baseAddr, USB_USBCTRL_PDE_MASK);
+}
+
+
+/*!
+* @brief Disable the pull down
+*
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_disable_pull_down(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_CLR_USBCTRL(_baseAddr, USB_USBCTRL_PDE_MASK);
+}
+
+#if (FSL_FEATURE_USB_KHCI_OTG_ENABLED)
+/*!
+* @brief Enable the pull up
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_enable_pull_up(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_OTGCTL(_baseAddr, USB_OTGCTL_DPHIGH_MASK | USB_OTGCTL_OTGEN_MASK |USB_OTGCTL_DMLOW_MASK |USB_OTGCTL_DPLOW_MASK);
+}
+
+/*!
+* @brief Disable the pull up
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_disable_pull_up(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_CLR_OTGCTL(_baseAddr, USB_OTGCTL_DPHIGH_MASK | USB_OTGCTL_OTGEN_MASK |USB_OTGCTL_DMLOW_MASK |USB_OTGCTL_DPLOW_MASK);
+}
+#endif
+
+/*!
+* @brief Enable the DP pull up
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_enable_dp_pull_up(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+#if (FSL_FEATURE_USB_KHCI_OTG_ENABLED)
+ if (USB_RD_OTGCTL_OTGEN(_baseAddr))
+ {
+ USB_SET_OTGCTL(_baseAddr, USB_OTGCTL_DPHIGH_MASK);
+ }
+ else
+ {
+ USB_SET_CONTROL(_baseAddr, USB_CONTROL_DPPULLUPNONOTG_MASK);
+ }
+#else
+ USB_SET_CONTROL(_baseAddr, USB_CONTROL_DPPULLUPNONOTG_MASK);
+#endif
+}
+
+/*!
+* @brief Disable the DP pull up
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_disable_dp_pull_up(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+#if (FSL_FEATURE_USB_KHCI_OTG_ENABLED)
+ if (USB_RD_OTGCTL_OTGEN(_baseAddr))
+ {
+ USB_CLR_OTGCTL(_baseAddr, USB_OTGCTL_DPHIGH_MASK);
+ }
+ else
+ {
+ USB_CLR_CONTROL(_baseAddr, USB_CONTROL_DPPULLUPNONOTG_MASK);
+ }
+#else
+ USB_CLR_CONTROL(_baseAddr, USB_CONTROL_DPPULLUPNONOTG_MASK);
+#endif
+}
+
+#if (FSL_FEATURE_USB_KHCI_HOST_ENABLED)
+//TODO:
+static inline uint8_t usb_hal_khci_set_pull_downs(uint32_t baseAddr, uint8_t bitfield )
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ USB_CLR_OTGCTL(_baseAddr,USB_OTGCTL_DMLOW_MASK | USB_OTGCTL_DPLOW_MASK);
+ if(bitfield & 0x01)
+ {
+ USB_SET_OTGCTL(_baseAddr,USB_OTGCTL_DPLOW_MASK);
+ }
+
+ if(bitfield & 0x02)
+ {
+ USB_SET_OTGCTL(_baseAddr,USB_OTGCTL_DMLOW_MASK);
+ }
+ return USB_OK;
+}
+#endif
+
+//TODO:
+static inline void usb_hal_khci_clr_usbtrc0(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_USBTRC0(_baseAddr, 0);
+}
+
+#if (FSL_FEATURE_USB_KHCI_OTG_ENABLED)
+/*!
+* @brief Get OTG status
+* @param baseAddr usb baseAddr id
+*/
+static inline uint8_t usb_hal_khci_get_otg_status(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+ return(USB_RD_OTGSTAT(_baseAddr));
+}
+#endif
+
+/*!
+* @brief Set the controller to the suspend state
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_set_suspend(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_SET_USBCTRL(_baseAddr, USB_USBCTRL_SUSP_MASK);
+}
+
+
+/*!
+* @brief Clear the suspend state of the controller
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_clr_suspend(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_CLR_USBCTRL(_baseAddr, USB_USBCTRL_SUSP_MASK);
+}
+
+#if (FSL_FEATURE_USB_KHCI_HOST_ENABLED)
+/*!
+* @brief Set the sof threshold
+* @param baseAddr usb baseAddr id
+* @param value value used to set
+*/
+static inline void usb_hal_khci_set_sof_theshold(uint32_t baseAddr, uint32_t value)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_SOFTHLD(_baseAddr, (uint8_t)value);
+}
+
+static inline void usb_hal_khci_set_target_token(uint32_t baseAddr, uint8_t token, uint8_t endpoint_number)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_TOKEN(_baseAddr, (uint8_t)(USB_TOKEN_TOKENENDPT(endpoint_number) | token));
+}
+#endif
+
+/*!
+* @brief Set weak pull down
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_set_weak_pulldown(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_CTL(_baseAddr, USB_CTL_SE0_MASK);
+}
+
+/*!
+* @brief Reset control register
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_reset_control_register(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_CTL(_baseAddr, 0UL);
+}
+
+/*!
+* @brief Set internal pull up
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_set_internal_pullup(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_WR_CONTROL(_baseAddr, USB_CONTROL_DPPULLUPNONOTG_MASK);
+}
+
+/*!
+* @brief Set trc0
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_set_trc0(uint32_t baseAddr)
+{
+ USB_MemMapPtr _baseAddr = (USB_MemMapPtr)baseAddr;
+
+ USB_SET_USBTRC0(_baseAddr, 0x40);
+}
+
+#else
+//#include <stdint.h>
+//#include <stdbool.h>
+#include <assert.h>
+
+
+//#include "fsl_usb_features.h"
+//#include "device/fsl_device_registers.h"
+
+//! @addtogroup usb_hal
+//! @{
+
+//! @file
+
+////////////////////////////////////////////////////////////////////////////////
+// Definitions
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+// API
+////////////////////////////////////////////////////////////////////////////////
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+#define HW_USB_INSTANCE_COUNT (1U)
+
+/*!
+ * @name Initialization
+ * @{
+ */
+
+/*!
+ * @brief Init the BDT page register from the BDT table
+ *
+ * @param baseAddr USB baseAddr id
+ * @param bdtAddress the BDT address resides in memory
+ *
+ */
+static inline void usb_hal_khci_set_buffer_descriptor_table_addr(uint32_t baseAddr, uint32_t bdtAddress)
+{
+
+ USB0_BDTPAGE1 = (uint8_t)((uint32_t)bdtAddress >> 8);
+ USB0_BDTPAGE2 = (uint8_t)((uint32_t)bdtAddress >> 16);
+ USB0_BDTPAGE3 = (uint8_t)((uint32_t)bdtAddress >> 24);
+}
+
+
+/*!
+ * @brief Enable the specific Interrupt
+ *
+ * @param baseAddr USB baseAddr id
+ * @param intrType specific interrupt type
+ */
+static inline void usb_hal_khci_enable_interrupts(uint32_t baseAddr, uint32_t intrType)
+{
+
+ USB0_INTEN |= (uint8_t)intrType;
+}
+#if (FSL_USB_KHCI_OTG_ENABLED)
+/*!
+ * @brief Enable the specific OTG Interrupt
+ *
+ * @param baseAddr USB baseAddr id
+ * @param specific interrupt type
+ *
+ */
+static inline void usb_hal_khci_enable_otg_interrupts(uint32_t baseAddr, uint32_t intrType)
+{
+
+ //HW_USB_OTGICR_SET((uint8_t)intrType);
+ USB0_OTGICR |= (uint8_t)intrType;
+}
+#endif
+
+/*!
+ * @brief Disable the specific Interrupt
+ *
+ * @param baseAddr USB baseAddr id
+ * @param intrType specific interrupt type
+ */
+static inline void usb_hal_khci_disable_interrupts(uint32_t baseAddr, uint32_t intrType)
+{
+
+ USB0_INTEN &= ~(uint8_t)intrType;
+}
+
+/*!
+ * @brief Get the interrupt status
+ *
+ * @param baseAddr USB baseAddr id
+ * @return specific interrupt type
+ */
+static inline uint8_t usb_hal_khci_get_interrupt_status(uint32_t baseAddr)
+{
+
+ return (USB0_ISTAT);
+}
+
+/*!
+ * @brief Get the otg interrupt status
+ *
+ * @param baseAddr USB baseAddr id
+ *
+ */
+#if (FSL_USB_KHCI_OTG_ENABLED)
+static inline uint8_t usb_hal_khci_get_otg_interrupt_status(uint32_t baseAddr)
+{
+ //return (HW_USB_OTGISTAT_RD);
+ return (USB0_OTGISTAT);
+}
+
+/*!
+* @brief Clear the specific otg interrupt
+*
+* @param baseAddr usb baseAddr id
+* @param intrType the interrupt type
+*/
+static inline void usb_hal_khci_clr_otg_interrupt(uint32_t baseAddr, uint32_t intrType)
+{
+ //HW_USB_OTGISTAT_WR((uint8_t)intrType);
+ USB0_OTGISTAT = (uint8_t)intrType;
+}
+
+/*!
+* @brief Clear all the otg interrupts
+*
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_clr_all_otg_interrupts(uint32_t baseAddr)
+{
+ //HW_USB_OTGISTAT_WR(0xFF);
+ USB0_OTGISTAT = 0xFF;
+}
+
+/*!
+ * @brief Check if controller is busy on transferring.
+ *
+ * @param baseAddr USB baseAddr id.
+ * @return the value of the TOKENBUSY bit from the control register
+ */
+static inline uint8_t usb_hal_khci_is_line_stable(uint32_t baseAddr)
+{
+ //return ((HW_USB_OTGSTAT_RD & USB_OTGSTAT_LINESTATESTABLE_MASK) ? 1:0);
+ return ((USB0_OTGSTAT & USB_OTGSTAT_LINESTATESTABLE_MASK) ? 1:0);
+}
+#endif
+/*!
+ * @brief Get the interrupt enable status
+ *
+ * @param baseAddr USB baseAddr id
+ * @return current enabled interrupt types
+ */
+static inline uint8_t usb_hal_khci_get_interrupt_enable_status(uint32_t baseAddr)
+{
+
+ return (USB0_INTEN);
+}
+
+/*!
+* @brief Clear the specific interrupt
+*
+* @param baseAddr usb baseAddr id
+* @param intrType the interrupt type needs to be cleared
+*/
+static inline void usb_hal_khci_clr_interrupt(uint32_t baseAddr, uint32_t intrType)
+{
+
+
+ USB0_ISTAT = (uint8_t)intrType;
+}
+
+/*!
+* @brief Clear all the interrupts
+*
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_clr_all_interrupts(uint32_t baseAddr)
+{
+
+ USB0_ISTAT = 0xff;
+}
+
+/*!
+* @brief Judge if an interrupt type happen
+*
+* @param baseAddr usb baseAddr id
+* @param intrType the interrupt type
+* @return the current interrupt type is happen or not
+*/
+static inline uint8_t usb_hal_khci_is_interrupt_issued(uint32_t baseAddr, uint32_t intrType)
+{
+
+ return (USB0_ISTAT & USB0_INTEN & (uint8_t)(intrType));
+}
+
+/*!
+* @brief Enable all the error interrupt
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_enable_all_error_interrupts(uint32_t baseAddr)
+{
+
+ USB0_ERREN = (uint8_t)0xFF;
+}
+
+
+/*!
+* @brief Disable all the error interrupts
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_disable_all_error_interrupts(uint32_t baseAddr)
+{
+
+ USB0_ERREN = (uint8_t)0;
+}
+
+
+/*!
+* @brief Enable error interrupts
+* @param baseAddr usb baseAddr id
+* @param errIntrType the error interrupt type
+*/
+static inline void usb_hal_khci_enable_error_interrupts(uint32_t baseAddr, uint32_t errIntrType)
+{
+
+ USB0_ERREN |= (uint8_t)errIntrType;
+}
+
+/*!
+* @brief Disable the specific error interrupt
+* @param baseAddr usb baseAddr id
+* @param errIntrType the error interrupt type
+*/
+static inline void usb_hal_khci_disable_error_interrupts(uint32_t baseAddr, uint32_t errorIntrType)
+{
+
+ USB0_ERREN &= ~(uint8_t)errorIntrType;
+}
+
+/*!
+* @brief Get the error interrupt status
+*
+* @param baseAddr usb baseAddr id
+* @return the error interrupt status
+*/
+static inline uint8_t usb_hal_khci_get_error_interrupt_status(uint32_t baseAddr)
+{
+
+ return (USB0_ERRSTAT);
+}
+
+/*!
+* @brief Get the error interrupt enable status
+*
+* @param baseAddr usb baseAddr id
+* @return the error interrupt enable status
+*/
+static inline uint8_t usb_hal_khci_get_error_interrupt_enable_status(uint32_t baseAddr)
+{
+
+ return (USB0_ERREN);
+}
+
+/*!
+* @brief Clear all the error interrupt happened
+*
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_clr_all_error_interrupts(uint32_t baseAddr)
+{
+
+ USB0_ERRSTAT = 0xff;
+}
+
+/*!
+* @brief Check if the specific error happened
+*
+* @param baseAddr usb baseAddr id
+* @return the ERRSTAT register together with the error interrupt
+*/
+static inline uint8_t usb_hal_khci_is_error_happend(uint32_t baseAddr, uint32_t errorType)
+{
+
+ return ( USB0_ERRSTAT & (uint8_t)errorType);
+}
+
+/*!
+ * @brief Clear the TOKENBUSY flag.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_clr_token_busy(uint32_t baseAddr)
+{
+ USB0_CTL &= ~USB_CTL_TXSUSPENDTOKENBUSY_MASK;
+}
+
+/*!
+ * @brief Check if controller is busy on transferring.
+ *
+ * @param baseAddr USB baseAddr id.
+ * @return the value of the TOKENBUSY bit from the control register
+ */
+static inline uint8_t usb_hal_khci_is_token_busy(uint32_t baseAddr)
+{
+ return (uint8_t)(USB0_CTL & USB_CTL_TXSUSPENDTOKENBUSY_MASK);
+}
+
+/*!
+ * @brief reset all the BDT odd ping/pong fields.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_set_oddrst(uint32_t baseAddr)
+{
+ USB0_CTL |= USB_CTL_ODDRST_MASK;
+}
+
+/*!
+ * @brief Clear the ODDRST flag.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_clr_oddrst(uint32_t baseAddr)
+{
+ USB0_CTL &= ~USB_CTL_ODDRST_MASK;
+}
+
+#if (FSL_USB_KHCI_HOST_ENABLED)
+/*!
+ * @brief Begin to issue RESET signal.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_start_bus_reset(uint32_t baseAddr)
+{
+
+ USB0_CTL |= USB_CTL_RESET_MASK;
+}
+
+/*!
+ * @brief Stop issuing RESET signal
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_stop_bus_reset(uint32_t baseAddr)
+{
+
+ USB0_CTL &= ~USB_CTL_RESET_MASK;
+}
+
+/*!
+ * @brief Start to issue resume signal.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_start_resume(uint32_t baseAddr)
+{
+
+ USB0_CTL |= USB_CTL_RESUME_MASK;
+}
+
+/*!
+ * @brief Stop issuing resume signal.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_stop_resume(uint32_t baseAddr)
+{
+ //HW_USB_CTL_CLR(USB_CTL_RESUME_MASK);
+ USB0_CTL &= ~USB_CTL_RESUME_MASK;
+}
+
+
+/*!
+ * @brief Set the USB controller to host mode
+ *
+ * @param baseAddr USB baseAddr id.
+ *
+ */
+static inline void usb_hal_khci_set_host_mode(uint32_t baseAddr)
+{
+
+ USB0_CTL = USB_CTL_HOSTMODEEN_MASK;
+}
+
+/*!
+ * @brief Set the USB controller to device mode
+ *
+ * @param baseAddr USB baseAddr id.
+ *
+ */
+static inline void usb_hal_khci_set_device_mode(uint32_t baseAddr)
+{
+
+
+ USB0_CTL &= ~USB_CTL_HOSTMODEEN_MASK;
+}
+#endif
+
+#if (FSL_USB_KHCI_OTG_ENABLED)
+/*!
+ * @brief Set the USB controller to host mode
+ *
+ * @param baseAddr USB baseAddr id.
+ *
+ */
+static inline void usb_hal_khci_enable_otg(uint32_t baseAddr)
+{
+ //HW_USB_OTGCTL_SET(USB_OTGCTL_OTGEN_MASK);
+ USB0_OTGCTL |= USB_OTGCTL_OTGEN_MASK;
+}
+#endif
+
+/*!
+ * @brief Enable the USB module.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_enable_sof(uint32_t baseAddr)
+{
+ USB0_CTL |= USB_CTL_USBENSOFEN_MASK;
+}
+
+/*!
+ * @brief Disable the USB module.
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline void usb_hal_khci_disable_sof(uint32_t baseAddr)
+{
+ USB0_CTL &= ~USB_CTL_USBENSOFEN_MASK;
+}
+
+/*!
+ * @brief Clear the USB controller register
+ *
+ * @param baseAddr USB baseAddr id.
+ *
+ */
+static inline void usb_hal_khci_clear_control_register(uint32_t baseAddr)
+{
+ USB0_CTL = 0;
+}
+
+/*!
+ * @brief Get the speed of the USB module.
+ *
+ * @param baseAddr USB baseAddr id.
+ * @return the current line status of the USB module
+ */
+static inline uint8_t usb_hal_khci_get_line_status(uint32_t baseAddr)
+{
+ return ((USB0_CTL & USB_CTL_JSTATE_MASK) ? 0 : 1);
+}
+
+/*!
+ * @brief
+ *
+ * @param baseAddr USB baseAddr id.
+ */
+static inline uint8_t usb_hal_khci_get_se0_status(uint32_t baseAddr)
+{
+ return ((USB0_CTL & USB_CTL_SE0_MASK) ? 1 : 0);
+}
+
+/*!
+* @brief Get current status
+*
+* @param baseAddr usb baseAddr id
+* @return current status
+*/
+static inline uint8_t usb_hal_khci_get_transfer_status(uint32_t baseAddr)
+{
+
+ return USB0_STAT;
+}
+
+/*!
+* @brief Get the endpoint number from STAT register
+*
+* @param baseAddr usb baseAddr id
+* @return endpoint number
+*/
+static inline uint8_t usb_hal_khci_get_transfer_done_ep_number(uint32_t baseAddr)
+{
+
+ return ((USB0_STAT & 0xf0) >> 4);
+}
+
+/*!
+* @brief Return the transmit dir from STAT register
+*
+* @param baseAddr usb baseAddr id
+* @return transmit direction
+*/
+static inline uint8_t usb_hal_khci_get_transfer_done_direction(uint32_t baseAddr)
+{
+
+ return ((USB0_STAT & USB_STAT_TX_MASK) >>USB_STAT_TX_SHIFT);
+}
+
+/*!
+* @brief Return the even or odd bank from STAT register
+*
+* @param baseAddr usb baseAddr id
+* @return the even or odd bank
+*/
+static inline uint8_t usb_hal_khci_get_transfer_done_odd(uint32_t baseAddr)
+{
+
+ return ((USB0_STAT & USB_STAT_ODD_MASK) >> USB_STAT_ODD_SHIFT);
+}
+
+
+/*!
+* @brief Returned the computed BDT address
+*
+* @param baseAddr usb baseAddr id
+* @return the computed BDT address
+*/
+static inline uint16_t usb_hal_khci_get_frame_number(uint32_t baseAddr)
+{
+
+ return ( USB0_FRMNUMH << 8 | USB0_FRMNUML);
+}
+
+/*!
+* @brief Set the device address
+*
+* @param baseAddr usb baseAddr id
+* @param addr the address used to set
+*/
+static inline void usb_hal_khci_set_device_addr(uint32_t baseAddr, uint32_t addr)
+{
+
+ USB0_ADDR = (uint8_t)((USB0_ADDR & ~0x7F) | addr);
+}
+
+#if (FSL_USB_KHCI_HOST_ENABLED == 1)
+/*!
+* @brief Set the transfer target
+*
+* @param baseAddr usb baseAddr id
+* @param addr the address used to set
+*/
+static inline void usb_hal_khci_set_transfer_target(uint32_t baseAddr, uint32_t address, uint32_t speed)
+{
+
+ USB0_ADDR = (uint8_t)((speed == 0) ? (uint8_t)address : USB_ADDR_LSEN_MASK | (uint8_t)address);
+}
+#endif
+
+/*!
+* @brief Init the endpoint0
+*
+* @param baseAddr usb baseAddr id
+* @param isThoughHub endpoint0 is though hub or not
+* @param isIsochPipe current pipe is iso or not
+*/
+static inline void usb_hal_khci_endpoint0_init(uint32_t baseAddr, uint32_t isThoughHub, uint32_t isIsochPipe)
+{
+#if (FSL_USB_KHCI_HOST_ENABLED)
+ USB0_ENDPT0 = (isThoughHub == 1 ? USB_ENDPT_HOSTWOHUB_MASK : 0)| USB_ENDPT_RETRYDIS_MASK |
+ USB_ENDPT_EPTXEN_MASK | USB_ENDPT_EPRXEN_MASK | (isIsochPipe == 1 ? 0 : USB_ENDPT_EPHSHK_MASK);
+#else
+ USB0_ENDPT0 = USB_ENDPT_EPTXEN_MASK | USB_ENDPT_EPRXEN_MASK | (isIsochPipe == 1 ? 0 : USB_ENDPT_EPHSHK_MASK);
+#endif
+}
+
+/*!
+* @brief Stop the endpoint
+*
+* @param baseAddr usb baseAddr id
+* @param epNumber endpoint number
+*/
+static inline void usb_hal_khci_endpoint_shut_down(uint32_t baseAddr, uint32_t epNumber)
+{
+
+ USB_ENDPT_REG(USB0_BASE_PTR, (uint8_t)epNumber) = 0;
+}
+
+#if (FSL_USB_KHCI_HOST_ENABLED)
+/*!
+* @brief Set the flag to indicate if the endpoint is communicating with controller through the hub
+*
+* @param baseAddr usb baseAddr id
+* @param epNumber endpoint number
+*/
+static inline void usb_hal_khci_endpoint_on_hub(uint32_t baseAddr, uint32_t epNumber)
+{
+
+
+ USB_ENDPT_REG(USB0_BASE_PTR, (uint8_t)epNumber) |= USB_ENDPT_HOSTWOHUB_MASK;
+}
+#endif
+
+/*!
+* @brief Set the endpoint in host mode which need handshake or not
+*
+* @param baseAddr usb baseAddr id
+* @param epNumber endpoint number
+* @param isEphshkSet needs handshake or not
+*/
+static inline void usb_hal_khci_endpoint_enable_handshake(uint32_t baseAddr, uint32_t epNumber, uint32_t isEphshkSet)
+{
+
+ USB_ENDPT_REG(USB0_BASE_PTR, (uint8_t)epNumber) |= ((isEphshkSet == 1) ? USB_ENDPT_EPHSHK_MASK : 0);
+
+}
+
+/*!
+* @brief Set the endpoint in host mode which in TX or RX
+*
+* @param baseAddr usb baseAddr id
+* @param epNumber endpoint number
+* @param isEptxenSet in TX or RX
+*/
+static inline void usb_hal_khci_endpoint_set_direction(uint32_t baseAddr, uint32_t epNumber, uint8_t isEptxenSet)
+{
+
+ USB_ENDPT_REG(USB0_BASE_PTR, (uint8_t)epNumber) |= ((isEptxenSet == 1) ? USB_ENDPT_EPTXEN_MASK : USB_ENDPT_EPRXEN_MASK);
+}
+
+/*!
+* @brief Clear the stall status of the endpoint
+*
+* @param baseAddr usb baseAddr id
+* @param epNumber endpoint number
+*/
+static inline void usb_hal_khci_endpoint_clr_stall(uint32_t baseAddr, uint32_t epNumber)
+{
+
+ USB_ENDPT_REG(USB0_BASE_PTR, (uint8_t)epNumber) &= ~USB_ENDPT_EPSTALL_MASK;
+
+}
+
+#if (FSL_USB_KHCI_HOST_ENABLED == 1)
+/*!
+* @brief Enable the support for low speed
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_enable_low_speed_support(uint32_t baseAddr)
+{
+
+ USB0_ADDR |= USB_ADDR_LSEN_MASK;
+}
+#endif
+
+/*!
+* @brief Disable the support for low speed
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_disable_low_speed_support(uint32_t baseAddr)
+{
+
+ USB0_ADDR &= ~USB_ADDR_LSEN_MASK;
+}
+
+
+/*!
+* @brief Enable the pull down
+*
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_enable_pull_down(uint32_t baseAddr)
+{
+
+ USB0_USBCTRL |= USB_USBCTRL_PDE_MASK;
+}
+
+
+/*!
+* @brief Disable the pull down
+*
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_disable_pull_down(uint32_t baseAddr)
+{
+
+ USB0_USBCTRL &= ~USB_USBCTRL_PDE_MASK;
+}
+
+#if (FSL_USB_KHCI_OTG_ENABLED)
+/*!
+* @brief Enable the pull up
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_enable_pull_up(uint32_t baseAddr)
+{
+
+ USB0_OTGCTL = USB_OTGCTL_DPHIGH_MASK | USB_OTGCTL_OTGEN_MASK |USB_OTGCTL_DMLOW_MASK |USB_OTGCTL_DPLOW_MASK;
+}
+
+/*!
+* @brief Disable the pull up
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_disable_pull_up(uint32_t baseAddr)
+{
+
+ USB0_OTGCTL &= ~(USB_OTGCTL_DPHIGH_MASK | USB_OTGCTL_OTGEN_MASK |USB_OTGCTL_DMLOW_MASK |USB_OTGCTL_DPLOW_MASK);
+}
+#endif
+/*!
+* @brief Enable the DP pull up
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_enable_dp_pull_up(uint32_t baseAddr)
+{
+#if (FSL_USB_KHCI_OTG_ENABLED)
+ if ((USB0_OTGCTL & USB_OTGCTL_OTGEN_MASK) >> USB_OTGCTL_OTGEN_SHIFT)
+ {
+ USB0_OTGCTL |= USB_OTGCTL_DPHIGH_MASK;
+ }
+ else
+ {
+ USB0_CONTROL |= USB_CONTROL_DPPULLUPNONOTG_MASK;
+ }
+#endif
+ USB0_CONTROL |= USB_CONTROL_DPPULLUPNONOTG_MASK;
+}
+
+/*!
+* @brief Disable the DP pull up
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_disable_dp_pull_up(uint32_t baseAddr)
+{
+#if (FSL_USB_KHCI_OTG_ENABLED)
+ if ((USB0_OTGCTL & USB_OTGCTL_OTGEN_MASK) >> USB_OTGCTL_OTGEN_SHIFT)
+ {
+ USB0_OTGCTL &= ~ USB_OTGCTL_DPHIGH_MASK;
+ }
+ else
+ {
+ USB0_CONTROL &= ~ USB_CONTROL_DPPULLUPNONOTG_MASK;
+ }
+#endif
+ USB0_CONTROL &= ~ USB_CONTROL_DPPULLUPNONOTG_MASK;
+}
+
+#if (FSL_USB_KHCI_OTG_ENABLED)
+//TODO:
+static inline uint8_t usb_hal_khci_set_pull_downs(uint32_t baseAddr, uint8_t bitfield )
+{
+ //HW_USB_OTGCTL_CLR(USB_OTGCTL_DMLOW_MASK | USB_OTGCTL_DPLOW_MASK);
+ USB0_OTGCTL &= ~(USB_OTGCTL_DMLOW_MASK | USB_OTGCTL_DPLOW_MASK);
+ if(bitfield & 0x01)
+ {
+ //HW_USB_OTGCTL_SET(USB_OTGCTL_DPLOW_MASK);
+ USB0_OTGCTL |= USB_OTGCTL_DPLOW_MASK;
+ }
+
+ if(bitfield & 0x02)
+ {
+ //HW_USB_OTGCTL_SET(USB_OTGCTL_DMLOW_MASK);
+ USB0_OTGCTL |= USB_OTGCTL_DMLOW_MASK;
+ }
+ return USB_OK;
+}
+#endif
+
+//TODO:
+static inline void usb_hal_khci_clr_usbtrc0(uint32_t baseAddr)
+{
+
+ //HW_USB_USBTRC0_WR(0);
+ USB0_USBTRC0 = 0;
+}
+
+#if (FSL_USB_KHCI_OTG_ENABLED)
+/*!
+* @brief Get OTG status
+* @param baseAddr usb baseAddr id
+*/
+static inline uint8_t usb_hal_khci_get_otg_status(uint32_t baseAddr)
+{
+ //return(HW_USB_OTGSTAT_RD);
+ return(USB0_OTGSTAT);
+}
+#endif
+
+/*!
+* @brief Set the controller to the suspend state
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_set_suspend(uint32_t baseAddr)
+{
+
+ USB0_USBCTRL |= USB_USBCTRL_SUSP_MASK;
+}
+
+
+/*!
+* @brief Clear the suspend state of the controller
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_clr_suspend(uint32_t baseAddr)
+{
+
+ USB0_USBCTRL &= ~USB_USBCTRL_SUSP_MASK;
+}
+
+#if (FSL_USB_KHCI_HOST_ENABLED)
+/*!
+* @brief Set the sof threshold
+* @param baseAddr usb baseAddr id
+* @param value value used to set
+*/
+static inline void usb_hal_khci_set_sof_theshold(uint32_t baseAddr, uint32_t value)
+{
+
+ USB0_SOFTHLD = (uint8_t)value;
+}
+
+static inline void usb_hal_khci_set_target_token(uint32_t baseAddr, uint8_t token, uint8_t endpoint_number)
+{
+
+ USB0_TOKEN = (uint8_t)(USB_TOKEN_TOKENENDPT(endpoint_number) | token);
+}
+#endif
+
+
+
+#endif
+#if (FSL_FEATURE_USB_KHCI_USB_RAM )
+#define USB_USBRAM_ADDRESS (0x400FE000)
+
+/*!
+* @brief Get the USB Ram address of the ctrol
+* @param baseAddr usb baseAddr id
+*/
+static inline uint32_t usb_hal_khci_get_usbram_add(uint32_t baseAddr)
+{
+ return USB_USBRAM_ADDRESS;
+}
+#endif
+
+#if (FSL_FEATURE_USB_KHCI_KEEP_ALIVE_ENABLED)
+/*!
+* @brief Clear the keep alive wake interrupt state of the controller
+* @param baseAddr usb baseAddr id
+*/
+static inline void usb_hal_khci_clr_keepalive_wake_int_sts(uint32_t baseAddr)
+{
+ USB0_KEEP_ALIVE_CTRL |= USB_KEEP_ALIVE_CTRL_WAKE_INT_STS_MASK;
+}
+
+/*!
+* @brief Getkeep alive wake interrupt status
+* @param baseAddr usb baseAddr id
+*/
+static inline uint8_t usb_hal_khci_get_keepalive_wake_int_sts(uint32_t baseAddr)
+{
+ return(USB0_KEEP_ALIVE_CTRL & USB_KEEP_ALIVE_CTRL_WAKE_INT_STS_MASK);
+}
+#endif
+#if defined(__cplusplus)
+ }
+#endif
+#endif
diff --git a/KSDK_1.2.0/usb/usb_core/include/compiler.h b/KSDK_1.2.0/usb/usb_core/include/compiler.h
new file mode 100644
index 0000000..3741e16
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/include/compiler.h
@@ -0,0 +1,122 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2013 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: compiler.h$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ * This file defines compiler related MACRO
+ *
+ *END************************************************************************/
+#ifndef __compiler_h__
+#define __compiler_h__ 1
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+#if ((defined __CWCC__)||(defined __GNUC__))
+#ifndef PACKED_STRUCT_BEGIN
+#define PACKED_STRUCT_BEGIN
+#endif
+
+#ifndef PACKED_STRUCT_END
+#define PACKED_STRUCT_END __attribute__((__packed__))
+#endif
+
+#ifndef PACKED_UNION_BEGIN
+#define PACKED_UNION_BEGIN
+#endif
+
+#ifndef PACKED_UNION_END
+#define PACKED_UNION_END __attribute__((__packed__))
+#endif
+
+#ifndef _WEAK_FUNCTION
+#define _WEAK_FUNCTION(x) __attribute__((weak)) x
+#endif
+
+#ifndef _WEAK_SYMBOL
+#define _WEAK_SYMBOL(x) x __attribute__((weak))
+#endif
+
+#elif (defined __IAR_SYSTEMS_ICC__)
+
+#ifndef PACKED_STRUCT_BEGIN
+#define PACKED_STRUCT_BEGIN __packed
+#endif
+
+#ifndef PACKED_STRUCT_END
+#define PACKED_STRUCT_END
+#endif
+
+#ifndef PACKED_UNION_BEGIN
+#define PACKED_UNION_BEGIN
+#endif
+
+#ifndef PACKED_UNION_END
+#define PACKED_UNION_END __packed
+#endif
+
+#ifndef _WEAK_FUNCTION
+#define _WEAK_FUNCTION(x) __weak x
+#endif
+
+#ifndef _WEAK_SYMBOL
+#define _WEAK_SYMBOL(x) __weak x
+#endif
+
+#elif (defined __CC_ARM)
+
+#ifndef PACKED_STRUCT_BEGIN
+#define PACKED_STRUCT_BEGIN _Pragma("pack(1)")
+#endif
+
+#ifndef PACKED_STRUCT_END
+#define PACKED_STRUCT_END _Pragma("pack()")
+#endif
+
+#ifndef PACKED_UNION_BEGIN
+#define PACKED_UNION_BEGIN _Pragma("pack()")
+#endif
+
+#ifndef PACKED_UNION_END
+#define PACKED_UNION_END _Pragma("pack()")
+#endif
+
+#ifndef _WEAK_FUNCTION
+#define _WEAK_FUNCTION(x) __weak x
+#endif
+
+#ifndef _WEAK_SYMBOL
+#define _WEAK_SYMBOL(x) __weak x
+#endif
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/KSDK_1.2.0/usb/usb_core/include/types.h b/KSDK_1.2.0/usb/usb_core/include/types.h
new file mode 100644
index 0000000..33c075c
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/include/types.h
@@ -0,0 +1,84 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2013 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: types.h$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ *
+ *
+ *END************************************************************************/
+#ifndef _types_h__
+#define _types_h__
+
+/*--------------------------------------------------------------------------*/
+/*
+ ** STANDARD TYPES
+ */
+
+/*
+ ** The following typedefs allow us to minimize portability problems
+ ** due to the various C compilers (even for the same processor) not
+ ** agreeing on the sizes of "int"s and "short int"s and "longs".
+ */
+
+//#define * *
+#define _CODE_PTR_ *
+
+typedef char * char_ptr; /* signed character */
+
+typedef unsigned char uchar; /* unsigned character */
+
+typedef signed char int8_t, *int_8_ptr; /* 8-bit signed integer */
+typedef unsigned char uint8_t; /* 8-bit signed integer */
+
+typedef short int16_t, *int_16_ptr; /* 16-bit signed integer */
+typedef unsigned short uint16_t, *uint_16_ptr; /* 16-bit unsigned integer*/
+
+typedef long int32_t, *int_32_ptr; /* 32-bit signed integer */
+typedef unsigned long uint32_t, *uint_32_ptr; /* 32-bit unsigned integer*/
+
+typedef long long int_64, *int_64_ptr; /* 64-bit signed */
+typedef unsigned long long uint64_t, *uint_64_ptr; /* 64-bit unsigned */
+
+#ifndef bool
+typedef unsigned long bool; /* Machine representation of a bool */
+#endif
+
+//typedef void * void*; /* Machine representation of a pointer */
+//typedef unsigned char uint8_t;
+//typedef unsigned short uint16_t;
+//typedef unsigned long uint32_t;
+#ifdef FALSE
+#undef FALSE
+#endif
+#define FALSE ((uint8_t)0)
+
+#ifdef TRUE
+#undef TRUE
+#endif
+#define TRUE ((uint8_t)1)
+
+#define UNUSED(x) (void)x;
+#endif
diff --git a/KSDK_1.2.0/usb/usb_core/include/usb.h b/KSDK_1.2.0/usb/usb_core/include/usb.h
new file mode 100644
index 0000000..0fbfe4f
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/include/usb.h
@@ -0,0 +1,40 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2013 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: usb.h$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ * This file includes all the necessary head files.
+ *
+ *END************************************************************************/
+#ifndef __usb_h__
+#define __usb_h__
+
+#include "adapter.h"
+#include "usb_types.h"
+#include "usb_desc.h" //USB descriptor macros
+#include "usb_misc.h"
+#include "usb_opt.h"
+#include "usb_error.h"
+#endif
diff --git a/KSDK_1.2.0/usb/usb_core/include/usb_desc.h b/KSDK_1.2.0/usb/usb_core/include/usb_desc.h
new file mode 100644
index 0000000..143f9f4
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/include/usb_desc.h
@@ -0,0 +1,348 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2008, 2013 Freescale Semiconductor;
+* All Rights Reserved
+*
+* Copyright (c) 1989-2008 ARC International;
+* All Rights Reserved
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: usb_desc.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+* This file contains struct definitions for USB descriptors.
+*
+*END************************************************************************/
+#ifndef __usb_desc_h__
+#define __usb_desc_h__
+
+//#include "compiler.h"
+
+/* USB Descriptor Endpoint types */
+#define USB_CONTROL_PIPE (0x00)
+#define USB_ISOCHRONOUS_PIPE (0x01)
+#define USB_BULK_PIPE (0x02)
+#define USB_INTERRUPT_PIPE (0x03)
+
+/* USB Descriptor Direction constants */
+#define USB_RECV (0)
+#define USB_SEND (1)
+
+/* USB Descriptor Lengths */
+#define USB_DESC_LEN_DEV (18)
+#define USB_DESC_LEN_CFG (9)
+#define USB_DESC_LEN_STR (2) /* minimum length */
+#define USB_DESC_LEN_IF (9)
+#define USB_DESC_LEN_EP (7)
+#define USB_DESC_LEN_DEV_QUALIFIER (10)
+#define USB_DESC_LEN_OTHER_SPEED_CFG (USB_DESC_LEN_CFG)
+
+/* USB Descriptor Types */
+#define USB_DESC_TYPE_DEV (1)
+#define USB_DESC_TYPE_CFG (2)
+#define USB_DESC_TYPE_STR (3)
+#define USB_DESC_TYPE_IF (4)
+#define USB_DESC_TYPE_EP (5)
+#define USB_DESC_TYPE_DEV_QUALIFIER (6)
+#define USB_DESC_TYPE_OTHER_SPEED_CFG (7)
+#define USB_DESC_TYPE_IF_POWER (8)
+#define USB_DESC_TYPE_OTG (9)
+#define USB_DESC_TYPE_HID (0x21)
+#define USB_DESC_TYPE_REPORT (0x22)
+
+/* USB Functional Descriptor Types */
+#define USB_DESC_TYPE_CS_INTERFACE (0x24)
+#define USB_DESC_TYPE_CS_ENDPOINT (0x25)
+
+
+/* USB Standard Device Requests - bmRequestType */
+#define USB_DEV_REQ_STD_REQUEST_TYPE_DIR_MASK (0x1)
+#define USB_DEV_REQ_STD_REQUEST_TYPE_DIR_SHIFT (7)
+#define USB_DEV_REQ_STD_REQUEST_TYPE_DIR_POS (USB_DEV_REQ_STD_REQUEST_TYPE_DIR_MASK << USB_DEV_REQ_STD_REQUEST_TYPE_DIR_SHIFT)
+
+#define USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_MASK (0x3)
+#define USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_SHIFT (5)
+#define USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_POS (USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_MASK << USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_SHIFT)
+
+#define USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_MASK (0x1F)
+#define USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_SHIFT (0)
+#define USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_POS (USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_MASK << USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_SHIFT)
+
+#define USB_DEV_REQ_STD_REQUEST_TYPE_DIR_OUT ((0x0 & USB_DEV_REQ_STD_REQUEST_TYPE_DIR_MASK) << USB_DEV_REQ_STD_REQUEST_TYPE_DIR_SHIFT)
+#define USB_DEV_REQ_STD_REQUEST_TYPE_DIR_IN ((0x1 & USB_DEV_REQ_STD_REQUEST_TYPE_DIR_MASK) << USB_DEV_REQ_STD_REQUEST_TYPE_DIR_SHIFT)
+
+#define USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_STANDARD ((0x0 & USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_MASK) << USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_SHIFT)
+#define USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_CLASS ((0x1 & USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_MASK) << USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_SHIFT)
+#define USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_VENDOR ((0x2 & USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_MASK) << USB_DEV_REQ_STD_REQUEST_TYPE_TYPE_SHIFT)
+
+#define USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_DEVICE ((0x00 & USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_MASK) << USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_SHIFT)
+#define USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_INTERFACE ((0x01 & USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_MASK) << USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_SHIFT)
+#define USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_ENDPOINT ((0x02 & USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_MASK) << USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_SHIFT)
+#define USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_OTHER ((0x03 & USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_MASK) << USB_DEV_REQ_STD_REQUEST_TYPE_RECIPIENT_SHIFT)
+
+/* USB Standard Request Codes - bRequest */
+#define USB_DEV_REQ_STD_REQUEST_GET_STATUS (0)
+#define USB_DEV_REQ_STD_REQUEST_CLEAR_FEATURE (1)
+#define USB_DEV_REQ_STD_REQUEST_SET_FEATURE (3)
+#define USB_DEV_REQ_STD_REQUEST_SET_ADDRESS (5)
+#define USB_DEV_REQ_STD_REQUEST_GET_DESCRIPTOR (6)
+#define USB_DEV_REQ_STD_REQUEST_SET_DESCRIPTOR (7)
+#define USB_DEV_REQ_STD_REQUEST_GET_CONFIGURATION (8)
+#define USB_DEV_REQ_STD_REQUEST_SET_CONFIGURATION (9)
+#define USB_DEV_REQ_STD_REQUEST_GET_INTERFACE (10)
+#define USB_DEV_REQ_STD_REQUEST_SET_INTERFACE (11)
+#define USB_DEV_REQ_STD_REQUEST_SYNCH_FRAME (12)
+
+#define GET_STATUS_DEVICE_MASK (0x0003)
+#define REMOTE_WAKEUP_STATUS_MASK (0x0002)
+/* identification values and masks to identify request types */
+//#define USB_REQUEST_CLASS_MASK (0x60)
+//#define USB_REQUEST_CLASS_STRD (0x00)
+//#define USB_REQUEST_CLASS_CLASS (0x20)
+//#define USB_REQUEST_CLASS_VENDOR (0x40)
+#define USB_GET_STATUS_ATTRIBUTES_SELF_POWERED_SHIFT (0)
+#define USB_GET_STATUS_ATTRIBUTES_REMOTE_WAKEUP_SHIFT (1)
+/* Configuration bmAttributes fields */
+#define USB_DESC_CFG_ATTRIBUTES_D7_MASK (0x1)
+#define USB_DESC_CFG_ATTRIBUTES_D7_SHIFT (7)
+#define USB_DESC_CFG_ATTRIBUTES_D7_POS (USB_DESC_CFG_ATTRIBUTES_D7_MASK << USB_DESC_CFG_ATTRIBUTES_D7_SHIFT)
+
+#define USB_DESC_CFG_ATTRIBUTES_SELF_POWERED_MASK (0x1)
+#define USB_DESC_CFG_ATTRIBUTES_SELF_POWERED_SHIFT (6)
+#define USB_DESC_CFG_ATTRIBUTES_SELF_POWERED_POS (USB_DESC_CFG_ATTRIBUTES_SELF_POWERED_MASK << USB_DESC_CFG_ATTRIBUTES_SELF_POWERED_SHIFT)
+
+#define USB_DESC_CFG_ATTRIBUTES_REMOTE_WAKEUP_MASK (0x1)
+#define USB_DESC_CFG_ATTRIBUTES_REMOTE_WAKEUP_SHIFT (5)
+#define USB_DESC_CFG_ATTRIBUTES_REMOTE_WAKEUP_POS (USB_DESC_CFG_ATTRIBUTES_REMOTE_WAKEUP_MASK << USB_DESC_CFG_ATTRIBUTES_REMOTE_WAKEUP_SHIFT)
+
+/* Endpoint bEndpointAddress fields */
+#define USB_DESC_EP_ENDPOINT_ADDRESS_DIR_MASK (0x1)
+#define USB_DESC_EP_ENDPOINT_ADDRESS_DIR_SHIFT (7)
+#define USB_DESC_EP_ENDPOINT_ADDRESS_DIR_POS (USB_DESC_EP_ENDPOINT_ADDRESS_DIR_MASK << USB_DESC_EP_ENDPOINT_ADDRESS_DIR_SHIFT)
+
+#define USB_DESC_EP_ENDPOINT_ADDRESS_EP_NUMBER_MASK (0xF)
+#define USB_DESC_EP_ENDPOINT_ADDRESS_EP_NUMBER_SHIFT (0)
+#define USB_DESC_EP_ENDPOINT_ADDRESS_EP_NUMBER_POS (USB_DESC_EP_ENDPOINT_ADDRESS_EP_NUMBER_MASK << USB_DESC_EP_ENDPOINT_ADDRESS_EP_NUMBER_SHIFT)
+
+#define USB_DESC_EP_ENDPOINT_ADDRESS_DIR_OUT ((0x0 & USB_DESC_EP_ENDPOINT_ADDRESS_DIR_MASK) << USB_DESC_EP_ENDPOINT_ADDRESS_DIR_SHIFT)
+#define USB_DESC_EP_ENDPOINT_ADDRESS_DIR_IN ((0x1 & USB_DESC_EP_ENDPOINT_ADDRESS_DIR_MASK) << USB_DESC_EP_ENDPOINT_ADDRESS_DIR_SHIFT)
+
+/* Endpoint bmAttributes fields */
+#define USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_MASK (0x3)
+#define USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_SHIFT (0)
+#define USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_POS (USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_MASK << USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_SHIFT)
+
+#define USB_DESC_EP_ATTRIBUTES_SYNC_TYPE_MASK (0x3)
+#define USB_DESC_EP_ATTRIBUTES_SYNC_TYPE_SHIFT (2)
+#define USB_DESC_EP_ATTRIBUTES_SYNC_TYPE_POS (USB_DESC_EP_ATTRIBUTES_SYNC_TYPE_MASK << USB_DESC_EP_ATTRIBUTES_SYNC_TYPE_SHIFT)
+
+#define USB_DESC_EP_ATTRIBUTES_USAGE_TYPE_MASK (0x3)
+#define USB_DESC_EP_ATTRIBUTES_USAGE_TYPE_SHIFT (4)
+#define USB_DESC_EP_ATTRIBUTES_USAGE_TYPE_POS (USB_DESC_EP_ATTRIBUTES_USAGE_TYPE_MASK << USB_DESC_EP_ATTRIBUTES_USAGE_TYPE_SHIFT)
+
+#define USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_CONTROL ((0x0 & USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_MASK) << USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_SHIFT)
+#define USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_ISOCHRONOUS ((0x1 & USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_MASK) << USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_SHIFT)
+#define USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_BULK ((0x2 & USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_MASK) << USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_SHIFT)
+#define USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_INTERRUPT ((0x3 & USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_MASK) << USB_DESC_EP_ATTRIBUTES_TRANSFER_TYPE_SHIFT)
+
+/* Standard Feature Selectors */
+#define USB_DEV_REQ_STD_FEATURE_SELECTOR_MASK (0x3)
+#define USB_DEV_REQ_STD_FEATURE_SELECTOR_SHIFT (0x0)
+#define USB_DEV_REQ_STD_FEATURE_SELECTOR_ENDPOINT_HALT (0)
+#define USB_DEV_REQ_STD_FEATURE_SELECTOR_DEVICE_REMOTE_WAKEUP (1)
+#define USB_DEV_REQ_STD_FEATURE_SELECTOR_TEST_MODE (2)
+
+#define USB_DEV_REQ_STD_FEATURE_B_HNP_ENABLE (0x0003) /* B HNP enable SET/CLEAR feature value */
+#define USB_DEV_REQ_STD_FEATURE_A_HNP_SUPPORT (0x0004) /* A HNP support SET/CLEAR feature value */
+
+ typedef struct _usb_language
+{
+ uint16_t language_id;
+ uint8_t ** lang_desc;
+ uint8_t * lang_desc_size;
+} usb_language_t;
+
+typedef struct _usb_all_languages
+{
+ uint8_t *languages_supported_string;
+ uint8_t languages_supported_size;
+ uint8_t languages_number;
+ /*Allocate Memory In App Layer*/
+ usb_language_t *usb_language;
+} usb_all_languages_t;
+
+PACKED_STRUCT_BEGIN
+struct usb_device_descriptor
+{
+ uint8_t bLength; /* Descriptor size in bytes = 18 */
+ uint8_t bDescriptorType; /* DEVICE descriptor type = 1 */
+ uint8_t bcdUSD[2]; /* USB spec in BCD, e.g. 0x0200 */
+ uint8_t bDeviceClass; /* Class code, if 0 see interface */
+ uint8_t bDeviceSubClass; /* Sub-Class code, 0 if class = 0 */
+ uint8_t bDeviceProtocol; /* Protocol, if 0 see interface */
+ uint8_t bMaxPacketSize; /* Endpoint 0 max. size */
+ uint8_t idVendor[2]; /* Vendor ID per USB-IF */
+ uint8_t idProduct[2]; /* Product ID per manufacturer */
+ uint8_t bcdDevice[2]; /* Device release # in BCD */
+ uint8_t iManufacturer; /* Index to manufacturer string */
+ uint8_t iProduct; /* Index to product string */
+ uint8_t iSerialNumber; /* Index to serial number string */
+ uint8_t bNumConfigurations; /* Number of possible configurations */
+} PACKED_STRUCT_END;
+typedef struct usb_device_descriptor device_descriptor_t;
+
+PACKED_STRUCT_BEGIN
+struct usb_configuration_descriptor
+{
+ uint8_t bLength; /* Descriptor size in bytes = 9 */
+ uint8_t bDescriptorType; /* CONFIGURATION type = 2 or 7 */
+ uint8_t wTotalLength[2]; /* Length of concatenated descriptors */
+ uint8_t bNumInterfaces; /* Number of interfaces, this config. */
+ uint8_t bConfigurationValue; /* Value to set this config. */
+ uint8_t iConfig; /* Index to configuration string */
+ uint8_t bmAttributes; /* Config. characteristics */
+ #define CONFIG_RES7 (0x80) /* Reserved, always = 1 */
+ #define CONFIG_SELF_PWR (0x40) /* Self-powered device */
+ #define CONFIG_WAKEUP (0x20) /* Remote wakeup */
+ uint8_t bMaxPower; /* Max.power from bus, 2mA units */
+} PACKED_STRUCT_END;
+typedef struct usb_configuration_descriptor usb_configuration_descriptor_t;
+
+PACKED_STRUCT_BEGIN
+struct usb_interface_descriptor
+{
+ uint8_t bLength; /* Descriptor size in bytes = 9 */
+ uint8_t bDescriptorType; /* INTERFACE descriptor type = 4 */
+ uint8_t bInterfaceNumber; /* Interface no.*/
+ uint8_t bAlternateSetting; /* Value to select this IF */
+ uint8_t bNumEndpoints; /* Number of endpoints excluding 0 */
+ uint8_t bInterfaceClass; /* Class code, 0xFF = vendor */
+ uint8_t bInterfaceSubClass; /* Sub-Class code, 0 if class = 0 */
+ uint8_t bInterfaceProtocol; /* Protocol, 0xFF = vendor */
+ uint8_t iInterface; /* Index to interface string */
+} PACKED_STRUCT_END;
+typedef struct usb_interface_descriptor interface_descriptor_t;
+
+PACKED_STRUCT_BEGIN
+struct usb_endpoint_descriptor
+{
+ uint8_t bLength; /* Descriptor size in bytes = 7 */
+ uint8_t bDescriptorType; /* ENDPOINT descriptor type = 5 */
+ uint8_t bEndpointAddress; /* Endpoint # 0 - 15 | IN/OUT */
+ #define IN_ENDPOINT (0x80) /* IN endpoint, device to host */
+ #define OUT_ENDPOINT (0x00) /* OUT endpoint, host to device */
+ #define ENDPOINT_MASK (0x0F) /* Mask endpoint # */
+ uint8_t bmAttributes; /* Transfer type */
+ #define CONTROL_ENDPOINT (0x00) /* Control transfers */
+ #define ISOCH_ENDPOINT (0x01) /* Isochronous transfers */
+ #define BULK_ENDPOINT (0x02) /* Bulk transfers */
+ #define IRRPT_ENDPOINT (0x03) /* Interrupt transfers */
+ #define EP_TYPE_MASK (0x03) /* Mask type bits */
+ /* Following must be zero except for isochronous endpoints */
+ #define ISOCH_NOSYNC (0x00) /* No synchronization */
+ #define ISOCH_ASYNC (0x04) /* Asynchronous */
+ #define ISOCH_ADAPT (0x08) /* Adaptive */
+ #define ISOCH_SYNCH (0x0C) /* Synchronous */
+ #define ISOCH_DATA (0x00) /* Data endpoint */
+ #define ISOCH_FEEDBACK (0x10) /* Feedback endpoint */
+ #define ISOCH_IMPLICIT (0x20) /* Implicit feedback */
+ #define ISOCH_RESERVED (0x30) /* Reserved */
+ uint8_t wMaxPacketSize[2]; /* Bits 10:0 = max. packet size */
+ /* For high-speed interrupt or isochronous only, additional
+ ** transaction opportunities per microframe follow.*/
+ #define PACKET_SIZE_MASK (0x7FFu) /* packet size bits */
+ #define NO_ADDITONAL (0x0000) /* 1 / microframe */
+ #define ONE_ADDITIONAL (0x0800) /* 2 / microframe */
+ #define TWO_ADDITIONAL (0x1000) /* 3 / microframe */
+ #define ADDITIONAL_MASK (ONE_ADDITIONAL | TWO_ADDITIONAL)
+ #define ADDITIONAL_POWER (11)
+ uint8_t iInterval; /* Polling interval in (micro) frames */
+} PACKED_STRUCT_END;
+typedef struct usb_endpoint_descriptor endpoint_descriptor_t;
+
+PACKED_STRUCT_BEGIN
+struct usb_qualifier_descriptor
+{
+ uint8_t bLength; /* Descriptor size in bytes = 10 */
+ uint8_t bDescriptorType; /* DEVICE QUALIFIER type = 6 */
+ uint8_t bcdUSD[2]; /* USB spec in BCD, e.g. 0x0200 */
+ uint8_t bDeviceClass; /* Class code, if 0 see interface */
+ uint8_t bDeviceSubClass; /* Sub-Class code, 0 if class = 0 */
+ uint8_t bDeviceProtocol; /* Protocol, if 0 see interface */
+ uint8_t bMaxPacketSize; /* Endpoint 0 max. size */
+ uint8_t bNumConfigurations; /* Number of possible configurations */
+ uint8_t bReserved; /* Reserved = 0 */
+} PACKED_STRUCT_END;
+typedef struct usb_qualifier_descriptor qualifier_descriptor_t;
+
+/* Other-Config type 7 fields are identical to type 2 above */
+
+/* Interface-Power descriptor type 8 not used in this version */
+
+PACKED_STRUCT_BEGIN
+struct usb_otg_descriptor
+{
+ uint8_t bLength; /* Descriptor size in bytes = 9 */
+ uint8_t bDescriptorType; /* CONFIGURATION type = 2 or 7 */
+ uint8_t bmAttributes; /* OTG characteristics */
+ #define OTG_SRP_SUPPORT (0x01) /* Supports SRP */
+ #define OTG_HNP_SUPPORT (0x02) /* Supports HNP */
+} PACKED_STRUCT_END;
+typedef struct usb_otg_descriptor otg_descriptor_t;
+
+PACKED_STRUCT_BEGIN
+struct usb_common_descriptor
+{
+ uint8_t bLength; /* Descriptor size in bytes = 9 */
+ uint8_t bDescriptorType; /* CONFIGURATION type = 2 or 7 */
+} PACKED_STRUCT_END;
+typedef struct usb_common_descriptor common_descriptor_t;
+
+
+typedef union descriptor_union
+{
+ uint32_t word;
+ uint8_t * bufr;
+ void* pntr;
+ device_descriptor_t dvic;
+ usb_configuration_descriptor_t* cfig;
+ interface_descriptor_t* intf;
+ endpoint_descriptor_t* ndpt;
+ qualifier_descriptor_t* qual;
+ otg_descriptor_t* otg;
+ common_descriptor_t* common;
+} descriptor_union_t;
+
+#define USB_uint_16_low(x) ((x) & 0xFF)
+#define USB_uint_16_high(x) ((uint8_t)((x) >> 8) & 0xFF)
+
+
+/* Prototypes */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/KSDK_1.2.0/usb/usb_core/include/usb_error.h b/KSDK_1.2.0/usb/usb_core/include/usb_error.h
new file mode 100644
index 0000000..e1184c8
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/include/usb_error.h
@@ -0,0 +1,100 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2008, 2013 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ * Copyright (c) 1989-2008 ARC International;
+ * All Rights Reserved
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: usb_error.h$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ * This file contains USB Device API defines for state and function
+ * returns.
+ *
+ *END************************************************************************/
+#ifndef __usb_error_h__
+#define __usb_error_h__ 1
+
+/* Error codes */
+#define USB_OK (0x00)
+#define USBERR_ALLOC (0x81)
+#define USBERR_BAD_STATUS (0x82)
+#define USBERR_CLOSED_SERVICE (0x83)
+#define USBERR_OPEN_SERVICE (0x84)
+#define USBERR_TRANSFER_IN_PROGRESS (0x85)
+#define USBERR_ENDPOINT_STALLED (0x86)
+#define USBERR_ALLOC_STATE (0x87)
+#define USBERR_DRIVER_INSTALL_FAILED (0x88)
+#define USBERR_DRIVER_NOT_INSTALLED (0x89)
+#define USBERR_INSTALL_ISR (0x8A)
+#define USBERR_INVALID_DEVICE_NUM (0x8B)
+#define USBERR_ALLOC_SERVICE (0x8C)
+#define USBERR_INIT_FAILED (0x8D)
+#define USBERR_SHUTDOWN (0x8E)
+#define USBERR_INVALID_PIPE_HANDLE (0x8F)
+#define USBERR_OPEN_PIPE_FAILED (0x90)
+#define USBERR_INIT_DATA (0x91)
+#define USBERR_SRP_REQ_INVALID_STATE (0x92)
+#define USBERR_TX_FAILED (0x93)
+#define USBERR_RX_FAILED (0x94)
+#define USBERR_EP_INIT_FAILED (0x95)
+#define USBERR_EP_DEINIT_FAILED (0x96)
+#define USBERR_TR_FAILED (0x97)
+#define USBERR_BANDWIDTH_ALLOC_FAILED (0x98)
+#define USBERR_INVALID_NUM_OF_ENDPOINTS (0x99)
+#define USBERR_ADDRESS_ALLOC_FAILED (0x9A)
+#define USBERR_PIPE_OPENED_FAILED (0x9B)
+#define USBERR_NOT_FOUND (0x9C)
+#define USBERR_HOST_BUSY (0x9D)
+#define USBERR_INVALID_PARAM (0x9E)
+#define USBERR_TR_RETRY_FAILED (0x9F)
+
+#define USBERR_DEVICE_NOT_FOUND (0xC0)
+#define USBERR_DEVICE_BUSY (0xC1)
+#define USBERR_NO_DEVICE_CLASS (0xC3)
+#define USBERR_UNKNOWN_ERROR (0xC4)
+#define USBERR_INVALID_BMREQ_TYPE (0xC5)
+#define USBERR_GET_MEMORY_FAILED (0xC6)
+#define USBERR_BAD_ALIGNMENT (0xC7)
+#define USBERR_INVALID_MEM_TYPE (0xC8)
+#define USBERR_NO_DESCRIPTOR (0xC9)
+#define USBERR_NULL_CALLBACK (0xCA)
+#define USBERR_NO_INTERFACE (0xCB)
+#define USBERR_INVALID_CFIG_NUM (0xCC)
+#define USBERR_INVALID_ANCHOR (0xCD)
+#define USBERR_INVALID_REQ_TYPE (0xCE)
+#define USBERR_DEVICE_DETACH (0xCF)
+#define USBERR_INTERFACE_NOT_OPENED (0xD0)
+#define USBERR_LACK_OF_SWAP_BUFFER (0xD1)
+#define USBERR_LEAK_OF_SWAP_BUFFER (0xD2)
+
+#define USBERR_ERROR (0xFF)
+
+/* Error Codes for lower-layer */
+#define USBERR_ALLOC_EP_QUEUE_HEAD (0xA8)
+#define USBERR_ALLOC_TR (0xA9)
+#define USBERR_ALLOC_DTD_BASE (0xAA)
+#define USBERR_CLASS_DRIVER_INSTALL (0xAB)
+#define USBERR_TR_CANCEL (0xAC)
+
+#endif
diff --git a/KSDK_1.2.0/usb/usb_core/include/usb_misc.h b/KSDK_1.2.0/usb/usb_core/include/usb_misc.h
new file mode 100644
index 0000000..d6247e6
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/include/usb_misc.h
@@ -0,0 +1,193 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2008, 2013 - 2014 Freescale Semiconductor;
+* All Rights Reserved
+*
+* Copyright (c) 1989-2008 ARC International;
+* All Rights Reserved
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: usb_misc.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+* This file contains USB Device API defines for state and function
+* returns.
+*
+*END************************************************************************/
+#ifndef __usb_misc_h__
+#define __usb_misc_h__ 1
+
+/* Host specific */
+#define USB_DEBOUNCE_DELAY (101)
+#define USB_RESET_RECOVERY_DELAY (11)
+#define USB_RESET_DELAY (10)
+
+/* USB device state- see USB 2.0 Documentation */
+#define USB_STATE_UNKNOWN (0xff)
+#define USB_STATE_PENDING_ADDRESS (0x04)
+#define USB_STATE_POWERED (0x03)
+#define USB_STATE_DEFAULT (0x02)
+#define USB_STATE_ADDRESS (0x01)
+#define USB_STATE_CONFIG (0x00)
+#define USB_STATE_SUSPEND (0x80)
+
+#define USB_STATUS_SELF_POWERED (0x01)
+#define USB_STATUS_REMOTE_WAKEUP (0x02)
+
+/* Bus Control values */
+#define USB_NO_OPERATION (0x00)
+#define USB_ASSERT_BUS_RESET (0x01)
+#define USB_DEASSERT_BUS_RESET (0x02)
+#define USB_ASSERT_RESUME (0x03)
+#define USB_DEASSERT_RESUME (0x04)
+#define USB_SUSPEND_SOF (0x05)
+#define USB_RESUME_SOF (0x06)
+
+/* possible values of XD->bStatus */
+#define USB_STATUS_IDLE (0)
+#define USB_STATUS_STALLED (1)
+#define USB_STATUS_TRANSFER_PENDING (2)
+#define USB_STATUS_TRANSFER_IN_PROGRESS (3)
+#define USB_STATUS_ERROR (4)
+#define USB_STATUS_DISABLED (5)
+#define USB_STATUS_TRANSFER_ACCEPTED (6)
+#define USB_STATUS_TRANSFER_QUEUED (7)
+#define USB_STATUS_TRANSFER_DONE (8)
+
+#define USB_DEVICE_DONT_ZERO_TERMINATE (0x1)
+
+#define USB_SETUP_DATA_XFER_DIRECTION (0x80)
+
+/* Speed definitions */
+#define USB_SPEED_FULL (0)
+#define USB_SPEED_LOW (1)
+#define USB_SPEED_HIGH (2)
+
+#define USB_MAX_PKTS_PER_UFRAME (0x6)
+
+/* Event codes for attach/detach etc. callback */
+#define USB_ATTACH_EVENT (1) /* device attach */
+#define USB_DETACH_EVENT (2) /* device detach */
+#define USB_CONFIG_EVENT (3) /* device reconfigured */
+#define USB_INTF_OPENED_EVENT (4) /* device interface opened */
+#define USB_ATTACH_INTF_NOT_SUPPORT (5) /* device attach while some interfaces not supported */
+#define USB_ATTACH_DEVICE_NOT_SUPPORT (6) /* device attach while all interfaces not supported */
+
+/* Alignment of buffer for DMA transfer, needed in some cases,
+** USB DMA bus could not possibly be initializes properly and
+** first data transfered is the one aligned at 4-byte boundary
+*/
+#define USB_MEM4_ALIGN(n) ((uint32_t)(n) + ((uint32_t)(-(n)) & 3U))
+#define USB_DMA_ALIGN(n) USB_MEM4_ALIGN(n)
+#define USB_DMA_ALIGN_MASK (0x03)
+#define USB_SETUP_PKT_SIZE (8)/* Setup Packet Size */
+#define MAX_EXPECTED_CONTROL_OUT_SIZE (76 + USB_SETUP_PKT_SIZE)
+
+typedef struct xd_struct
+{
+ uint8_t ep_num; /* Endpoint number */
+ uint8_t bdirection; /* Direction : Send/Receive */
+ uint8_t ep_type; /* Type of the endpoint: Ctrl, Isoch, Bulk, Int */
+ uint8_t bstatus; /* Current transfer status */
+ uint8_t * wstartaddress; /* Address of first byte */
+ uint32_t wtotallength; /* number of bytes to send/recv */
+ uint32_t wsofar; /* number of bytes recv'd so far */
+ struct xd_struct* next;
+ uint16_t wmaxpacketsize; /* max packet size */
+ uint8_t dont_zero_terminate;
+#if (defined USBCFG_KHCI_4BYTE_ALIGN_FIX && USBCFG_KHCI_4BYTE_ALIGN_FIX)
+ uint8_t internal_dma_align;
+#endif
+ uint8_t max_pkts_per_uframe;
+} xd_struct_t;
+
+typedef struct
+{
+ uint8_t* name;
+ uint8_t instance;
+} usb_instance_t;
+
+#if (defined USBCFG_DEV_KHCI && USBCFG_DEV_KHCI) || (defined USBCFG_DEV_EHCI && USBCFG_DEV_EHCI)
+typedef struct usb_dev_data
+{
+ uint8_t control_out[(((MAX_EXPECTED_CONTROL_OUT_SIZE-1)/32) + 1) * 32];
+ /* control_out must be 32 byte align,
+ ** 96 = (((MAX_EXPECTED_CONTROL_OUT_SIZE-1)/32) + 1) * 32
+ */
+} usb_dev_data_t;
+#endif
+
+#if (defined USBCFG_DEV_KHCI && USBCFG_DEV_KHCI)
+typedef struct usb_device_khci_data
+{
+ uint8_t setup_packet[16];
+#if (OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_MQX)
+ uint8_t reserver1[16];
+#endif
+#if USBCFG_KHCI_4BYTE_ALIGN_FIX
+ uint8_t swap_buf[USBCFG_DEV_KHCI_SWAP_BUF_MAX];
+#endif
+ uint8_t xd_base[USBCFG_DEV_MAX_XDS * sizeof(xd_struct_t)];
+}usb_device_khci_data_t;
+#endif
+
+#if (defined USBCFG_DEV_EHCI && USBCFG_DEV_EHCI)
+typedef struct usb_device_ehci_data
+{
+ uint8_t qh_base[USBCFG_DEV_EHCI_MAX_ENDPOINTS * 2 * 64];
+ uint8_t dtd_base[USBCFG_DEV_EHCI_MAX_DTD * 32];
+ uint8_t xd_base[USBCFG_DEV_MAX_XDS * sizeof(xd_struct_t)];
+ uint8_t reserved[688]; /* each ehci data should be 2048B aligned */
+}usb_device_ehci_data_t;
+#endif
+
+typedef enum
+{
+ INTR_USBRST = 0x01,
+ INTR_ERROR = 0x02,
+ INTR_SOFTOK = 0x04,
+ INTR_TOKDNE = 0x08,
+ INTR_SLEEP = 0x10,
+ INTR_RESUME = 0x20,
+ INTR_ATTACH = 0x40,
+ INTR_STALL = 0x80,
+}INTR_TYPE;
+
+typedef enum
+{
+ ERROR_PIDERR = 0x01,
+ ERROR_CRC5EOF = 0x02,
+ ERROR_CRC16 = 0x04,
+ ERROR_DFN8 = 0x08,
+ ERROR_BTOERR = 0x10,
+ ERROR_DMAERR = 0x20,
+ ERROR_BTSERR = 0x80,
+}ERROR_TYPE;
+
+typedef enum
+{
+ USB_CONTROLLER_KHCI_0 = 0x00,
+ USB_CONTROLLER_KHCI_1,
+ USB_CONTROLLER_EHCI_0,
+ USB_CONTROLLER_EHCI_1
+}CONTROLLER_INDEX;
+
+#endif
diff --git a/KSDK_1.2.0/usb/usb_core/include/usb_opt.h b/KSDK_1.2.0/usb/usb_core/include/usb_opt.h
new file mode 100644
index 0000000..507341a
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/include/usb_opt.h
@@ -0,0 +1,117 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2008, 2013 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: usb_opt.h$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ *
+ *
+ *END************************************************************************/
+#ifndef __usb_opt_h__
+#define __usb_opt_h__ 1
+
+#ifndef ENDIANNESS
+
+#error ENDIANNESS should be defined, and then rebulid the project.
+
+#endif
+
+#define SWAP2BYTE_CONST(n) ((((n) & 0x00FF) << 8) | (((n) & 0xFF00) >> 8))
+#define SWAP4BYTE_CONST(n) ((((n) & 0x000000FF) << 24) | (((n) & 0x0000FF00) << 8) | (((n) & 0x00FF0000) >> 8) | (((n) & 0xFF000000) >> 24))
+
+#if (ENDIANNESS == BIG_ENDIAN)
+#define USB_HOST_TO_BE_SHORT(n) (n)
+#define USB_HOST_TO_BE_SHORT_CONST(n) (n)
+#define USB_HOST_TO_LE_SHORT(n) SWAP2BYTE_CONST(n)
+#define USB_HOST_TO_LE_SHORT_CONST(n) SWAP2BYTE_CONST(n)
+#define USB_SHORT_BE_TO_HOST(n) (n)
+#define USB_SHORT_BE_TO_HOST_CONST(n) (n)
+#define USB_SHORT_LE_TO_HOST(n) SWAP2BYTE_CONST(n)
+#define USB_SHORT_LE_TO_HOST_CONST(n) SWAP2BYTE_CONST(n)
+#define USB_SHORT_UNALIGNED_LE_TO_HOST(n) ((n[1]<<8)|n[0])
+
+#define USB_HOST_TO_BE_LONG(n) (n)
+#define USB_HOST_TO_BE_LONG_CONST(n) (n)
+#define USB_HOST_TO_BE_UNALIGNED_LONG(n, m) \
+ { \
+ m[0]=((n>>24) & 0xFF); \
+ m[1]=((n>>16) & 0xFF); \
+ m[2]=((n>>8) & 0xFF); \
+ m[3]=(n & 0xFF); \
+ }
+#define USB_HOST_TO_LE_LONG(n) SWAP4BYTE_CONST(n)
+#define USB_HOST_TO_LE_LONG_CONST(n) SWAP4BYTE_CONST(n)
+#define USB_HOST_TO_LE_UNALIGNED_LONG(n, m) \
+ { \
+ m[0]=(n & 0xFF); \
+ m[1]=((n>>8) & 0xFF); \
+ m[2]=((n>>16) & 0xFF); \
+ m[3]=((n>>24) & 0xFF); \
+ }
+#define USB_LONG_BE_TO_HOST(n) (n)
+#define USB_LONG_BE_TO_HOST_CONST(n) (n)
+#define USB_LONG_LE_TO_HOST(n) SWAP4BYTE_CONST(n)
+#define USB_LONG_LE_TO_HOST_CONST(n) SWAP4BYTE_CONST(n)
+#define USB_LONG_UNALIGNED_LE_TO_HOST(n) ((n[3]<<24)|(n[2]<<16)|(n[1]<<8)|n[0])
+
+#else /* (PSP_ENDIAN == MQX_BIG_ENDIAN) */
+
+#define USB_HOST_TO_BE_SHORT(n) SWAP2BYTE_CONST(n)
+#define USB_HOST_TO_BE_SHORT_CONST(n) SWAP2BYTE_CONST(n)
+#define USB_HOST_TO_LE_SHORT(n) (n)
+#define USB_HOST_TO_LE_SHORT_CONST(n) (n)
+#define USB_SHORT_BE_TO_HOST(n) SWAP2BYTE_CONST(n)
+#define USB_SHORT_BE_TO_HOST_CONST(n) SWAP2BYTE_CONST(n)
+#define USB_SHORT_LE_TO_HOST(n) (n)
+#define USB_SHORT_LE_TO_HOST_CONST(n) (n)
+#define USB_SHORT_UNALIGNED_LE_TO_HOST(n) ((uint16_t)((uint16_t)n[1]<<8)|n[0])
+
+#define USB_HOST_TO_BE_LONG(n) SWAP4BYTE_CONST(n)
+#define USB_HOST_TO_BE_LONG_CONST(n) SWAP4BYTE_CONST(n)
+#define USB_HOST_TO_BE_UNALIGNED_LONG(n, m) \
+ { \
+ m[0]=((n>>24) & 0xFF); \
+ m[1]=((n>>16) & 0xFF); \
+ m[2]=((n>>8) & 0xFF); \
+ m[3]=(n & 0xFF); \
+ }
+#define USB_HOST_TO_LE_LONG(n) (n)
+#define USB_HOST_TO_LE_LONG_CONST(n) (n)
+#define USB_HOST_TO_LE_UNALIGNED_LONG(n, m) \
+ { \
+ m[0]=(n & 0xFF); \
+ m[1]=((n>>8) & 0xFF); \
+ m[2]=((n>>16) & 0xFF); \
+ m[3]=((n>>24) & 0xFF); \
+ }
+
+#define USB_LONG_BE_TO_HOST(n) SWAP4BYTE_CONST(n)
+#define USB_LONG_BE_TO_HOST_CONST(n) SWAP4BYTE_CONST(n)
+#define USB_LONG_LE_TO_HOST(n) (n)
+#define USB_LONG_LE_TO_HOST_CONST(n) (n)
+#define USB_LONG_UNALIGNED_LE_TO_HOST(n) (((uint32_t)n[3]<<24) | ((uint32_t)n[2]<<16) | ((uint32_t)n[1]<<8) | (uint32_t)n[0])
+#endif /* (PSP_ENDIAN == MQX_BIG_ENDIAN) */
+
+#endif
diff --git a/KSDK_1.2.0/usb/usb_core/include/usb_pin_detect.h b/KSDK_1.2.0/usb/usb_core/include/usb_pin_detect.h
new file mode 100644
index 0000000..135c8b8
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/include/usb_pin_detect.h
@@ -0,0 +1,68 @@
+/**HEADER********************************************************************
+*
+* Copyright (c) 2014 Freescale Semiconductor;
+* All Rights Reserved
+*
+*
+***************************************************************************
+*
+* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*
+**************************************************************************
+*
+* $FileName: usb_pin_detect.h$
+* $Version :
+* $Date :
+*
+* Comments:
+*
+*
+*
+*END************************************************************************/
+
+#ifndef __usb_pin_detect_h__
+#define __usb_pin_detect_h__
+
+typedef void(_CODE_PTR_ usb_pin_detect_service_t)(uint32_t event);
+
+
+#define USB_DEVICE_ID_CHANGE (1) /* id change from device mode*/
+#define USB_HOST_ID_CHANGE (2) /* id change from host mode */
+
+/*!
+ * @brief Registers a callback function for usb device pin detect
+ *
+ * The function is used to register a callback function for one specified endpoint.
+ *
+ * @param uint8_t USB controller id
+ * @param service callback function
+ * @param arg second parameter for the callback function
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_device_register_pin_detect_service(uint8_t controller_id, usb_pin_detect_service_t service, void* arg);
+
+/*!
+ * @brief Registers a callback function for usb host pin detect
+ *
+ * The function is used to register a callback function for one specified endpoint.
+ *
+ * @param uint8_t USB controller id
+ * @param service callback function
+ * @param arg second parameter for the callback function
+ * @return USB_OK-Success/Others-Fail
+ */
+extern usb_status usb_host_register_pin_detect_service(uint8_t controller_id, usb_pin_detect_service_t service, void* arg);
+
+
+#endif
+
diff --git a/KSDK_1.2.0/usb/usb_core/include/usb_types.h b/KSDK_1.2.0/usb/usb_core/include/usb_types.h
new file mode 100644
index 0000000..01dc026
--- /dev/null
+++ b/KSDK_1.2.0/usb/usb_core/include/usb_types.h
@@ -0,0 +1,59 @@
+/**HEADER********************************************************************
+ *
+ * Copyright (c) 2008, 2013 Freescale Semiconductor;
+ * All Rights Reserved
+ *
+ * Copyright (c) 1989-2008 ARC International;
+ * All Rights Reserved
+ *
+ ***************************************************************************
+ *
+ * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************
+ *
+ * $FileName: usb_types.h$
+ * $Version :
+ * $Date :
+ *
+ * Comments:
+ *
+ * This file contains appropriate processor specific header file include.
+ *
+ *END************************************************************************/
+#ifndef __usb_types_h__
+#define __usb_types_h__
+
+/*--------------------------------------------------------------------------*/
+/*
+ ** STANDARD TYPES
+ */
+
+typedef uint32_t usb_status;
+/* forward declarations */
+struct usb_interface_descriptor;
+struct pipe_struct;
+struct tr_struct;
+
+typedef void* usb_device_handle; /* device state struct */
+typedef void* usb_host_handle; /* host state struct */
+typedef void* usb_otg_handle; /* otg state struct */
+
+typedef void* usb_device_instance_handle; /* item on host's list */
+typedef void* usb_interface_descriptor_handle; /* Chapter 9 interface descriptor */
+typedef void* usb_pipe_handle; /* pipe or pipe-bundle */
+typedef void* usb_class_intf_handle; /* interface state struct (general data + class driver specific data) */
+
+#define UNUSED_ARGUMENT(x) (void)x;
+
+#endif