usb_host.h

/*
 * Copyright (c) 2015 - 2016, Freescale Semiconductor, Inc.
 * Copyright 2016 - 2019 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _USB_HOST_H_
#define _USB_HOST_H_
 
#include "nxp_usb.h"
#include "usb_misc.h"
#include "usb_spec.h"
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
 
struct _usb_host_transfer; /* for cross reference */
 
typedef void *usb_host_class_handle;
 
typedef void *usb_host_controller_handle;
 
typedef void *usb_host_configuration_handle;
 
typedef void *usb_host_interface_handle;
 
typedef void *usb_host_pipe_handle;
 
typedef enum _usb_host_event
{
    kUSB_HostEventAttach = 1U,     
    kUSB_HostEventDetach,          
    kUSB_HostEventEnumerationDone, 
    kUSB_HostEventNotSupported,    
    kUSB_HostEventEnumerationFail,
#if ((defined(USB_HOST_CONFIG_LOW_POWER_MODE)) && (USB_HOST_CONFIG_LOW_POWER_MODE > 0U))
    kUSB_HostEventNotSuspended,      
    kUSB_HostEventSuspended,         
    kUSB_HostEventNotResumed,        
    kUSB_HostEventDetectResume,      
    kUSB_HostEventResumed,           
    kUSB_HostEventL1Sleeped,         
    kUSB_HostEventL1SleepNYET,       
    kUSB_HostEventL1SleepNotSupport, 
    kUSB_HostEventL1SleepError,      
    kUSB_HostEventL1NotResumed,      
    kUSB_HostEventL1DetectResume,    
    kUSB_HostEventL1Resumed,         
#endif
} usb_host_event_t;
 
typedef enum _usb_host_dev_info
{
    kUSB_HostGetDeviceAddress = 1U,  
    kUSB_HostGetDeviceHubNumber,     
    kUSB_HostGetDevicePortNumber,    
    kUSB_HostGetDeviceSpeed,         
    kUSB_HostGetDeviceHSHubNumber,   
    kUSB_HostGetDeviceHSHubPort,     
    kUSB_HostGetDeviceLevel,         
    kUSB_HostGetHostHandle,          
    kUSB_HostGetDeviceControlPipe,   
    kUSB_HostGetDevicePID,           
    kUSB_HostGetDeviceVID,           
    kUSB_HostGetHubThinkTime,        
    kUSB_HostGetDeviceConfigIndex,   
    kUSB_HostGetConfigurationDes,    
    kUSB_HostGetConfigurationLength, 
} usb_host_dev_info_t;
typedef enum _usb_host_request_type
{
    kRequestDevice = 1U, 
    kRequestInterface,   
    kRequestEndpoint,    
} usb_host_request_type_t;
typedef struct _usb_host_process_descriptor_param
{
    uint8_t descriptorType;    
    uint8_t descriptorIndex;   
    uint16_t languageId;        
    uint8_t *descriptorBuffer; 
    uint16_t descriptorLength; 
} usb_host_process_descriptor_param_t;
typedef struct _usb_host_process_feature_param
{
    uint8_t requestType;         
    uint8_t featureSelector;     
    uint8_t interfaceOrEndpoint; 
} usb_host_process_feature_param_t;
typedef struct _usb_host_get_interface_param
{
    uint8_t interface;                 
    uint8_t *alternateInterfaceBuffer; 
} usb_host_get_interface_param_t;
 
typedef struct _usb_host_get_status_param
{
    uint16_t statusSelector; 
    uint8_t requestType;     
    uint8_t *statusBuffer;   
} usb_host_get_status_param_t;
 
typedef struct _usb_host_set_interface_param
{
    uint8_t alternateSetting; 
    uint8_t interface;        
} usb_host_set_interface_param_t;
 
typedef struct _usb_host_synch_frame_param
{
    uint8_t endpoint;           
    uint8_t *frameNumberBuffer; 
} usb_host_synch_frame_param_t;
typedef usb_status_t (*host_callback_t)(usb_device_handle deviceHandle,
                                        usb_host_configuration_handle configurationHandle,
                                        uint32_t eventCode);
 
typedef void (*transfer_callback_t)(void *param, uint8_t *data, uint32_t dataLen, usb_status_t status);
 
typedef void (*host_inner_transfer_callback_t)(void *param, struct _usb_host_transfer *transfer, usb_status_t status);
 
typedef struct _usb_host_ep
{
    usb_descriptor_endpoint_t *epDesc; 
    uint8_t *epExtension;              
    uint16_t epExtensionLength;        
} usb_host_ep_t;
 
typedef struct _usb_host_interface
{
    usb_host_ep_t epList[USB_HOST_CONFIG_INTERFACE_MAX_EP]; 
    usb_descriptor_interface_t *interfaceDesc;              
    uint8_t *interfaceExtension;                            
    uint16_t interfaceExtensionLength;                      
    uint8_t interfaceIndex;                                 
    uint8_t alternateSettingNumber;                         
    uint8_t epCount;                                        
} usb_host_interface_t;
 
typedef struct _usb_host_configuration
{
    usb_host_interface_t interfaceList[USB_HOST_CONFIG_CONFIGURATION_MAX_INTERFACE]; 
    usb_descriptor_configuration_t *configurationDesc; 
    uint8_t *configurationExtension;                   
    uint16_t configurationExtensionLength;             
    uint8_t interfaceCount;                            
} usb_host_configuration_t;
 
typedef struct _usb_host_pipe
{
    struct _usb_host_pipe *next;    
    usb_device_handle deviceHandle; 
    uint16_t currentCount;          
    uint16_t nakCount;              
    uint16_t maxPacketSize;         
    uint16_t interval;              
    uint8_t open;                   
    uint8_t nextdata01;             
    uint8_t endpointAddress;        
    uint8_t direction;              
    uint8_t pipeType;               
    uint8_t numberPerUframe;        
} usb_host_pipe_t;
 
typedef struct _usb_host_transfer
{
    struct _usb_host_transfer *next;           
    uint8_t *transferBuffer;                   
    uint32_t transferLength;                   
    uint32_t transferSofar;                    
    host_inner_transfer_callback_t callbackFn; 
    void *callbackParam;                       
    usb_host_pipe_t *transferPipe;             
    usb_setup_struct_t *setupPacket;           
    uint8_t direction;                         
    uint8_t setupStatus;                       
    union
    {
        uint32_t unitHead;      
        int32_t transferResult; 
    } union1;
 
    union
    {
        uint32_t unitTail; 
        uint32_t frame;    
    } union2;
 
#if USB_HOST_CONFIG_KHCI
    uint16_t nakTimeout; 
    uint16_t retry;      
#endif
} usb_host_transfer_t;
 
typedef struct _usb_host_pipe_init
{
    void *devInstance;       
    uint16_t nakCount;       
    uint16_t maxPacketSize;  
    uint8_t interval;        
    uint8_t endpointAddress; 
    uint8_t direction;       
    uint8_t pipeType;        
    uint8_t numberPerUframe; 
} usb_host_pipe_init_t;
 
typedef struct _usb_host_cancel_param
{
    usb_host_pipe_handle pipeHandle; 
    usb_host_transfer_t *transfer;   
} usb_host_cancel_param_t;
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
#ifdef __cplusplus
extern "C" {
#endif
 
extern usb_status_t USB_HostInit(uint8_t controllerId, usb_host_handle *hostHandle, host_callback_t callbackFn);
 
extern usb_status_t USB_HostDeinit(usb_host_handle hostHandle);
 
extern usb_status_t USB_HostHelperGetPeripheralInformation(usb_device_handle deviceHandle,
                                                           uint32_t infoCode,
                                                           uint32_t *infoValue);
 
extern usb_status_t USB_HostHelperParseAlternateSetting(usb_host_interface_handle interfaceHandle,
                                                        uint8_t alternateSetting,
                                                        usb_host_interface_t *interface);
 
extern usb_status_t USB_HostRemoveDevice(usb_host_handle hostHandle, usb_device_handle deviceHandle);
#if (defined(USB_HOST_CONFIG_KHCI) && (USB_HOST_CONFIG_KHCI > 0U))
extern void USB_HostKhciTaskFunction(void *hostHandle);
#endif
#if (defined(USB_HOST_CONFIG_EHCI) && (USB_HOST_CONFIG_EHCI > 0U))
extern void USB_HostEhciTaskFunction(void *hostHandle);
#endif
#if (defined(USB_HOST_CONFIG_OHCI) && (USB_HOST_CONFIG_OHCI > 0U))
extern void USB_HostOhciTaskFunction(void *hostHandle);
#endif
#if (defined(USB_HOST_CONFIG_IP3516HS) && (USB_HOST_CONFIG_IP3516HS > 0U))
extern void USB_HostIp3516HsTaskFunction(void *hostHandle);
#endif
#if (defined(USB_HOST_CONFIG_KHCI) && (USB_HOST_CONFIG_KHCI > 0U))
extern void USB_HostKhciIsrFunction(void *hostHandle);
#endif
#if (defined(USB_HOST_CONFIG_EHCI) && (USB_HOST_CONFIG_EHCI > 0U))
extern void USB_HostEhciIsrFunction(void *hostHandle);
#endif
#if (defined(USB_HOST_CONFIG_OHCI) && (USB_HOST_CONFIG_OHCI > 0U))
extern void USB_HostOhciIsrFunction(void *hostHandle);
#endif
#if (defined(USB_HOST_CONFIG_IP3516HS) && (USB_HOST_CONFIG_IP3516HS > 0U))
extern void USB_HostIp3516HsIsrFunction(void *hostHandle);
#endif
extern usb_status_t USB_HostOpenPipe(usb_host_handle hostHandle,
                                     usb_host_pipe_handle *pipeHandle,
                                     usb_host_pipe_init_t *pipeInit);
 
extern usb_status_t USB_HostClosePipe(usb_host_handle hostHandle, usb_host_pipe_handle pipeHandle);
 
extern usb_status_t USB_HostSend(usb_host_handle hostHandle,
                                 usb_host_pipe_handle pipeHandle,
                                 usb_host_transfer_t *transfer);
 
extern usb_status_t USB_HostSendSetup(usb_host_handle hostHandle,
                                      usb_host_pipe_handle pipeHandle,
                                      usb_host_transfer_t *transfer);
 
extern usb_status_t USB_HostRecv(usb_host_handle hostHandle,
                                 usb_host_pipe_handle pipeHandle,
                                 usb_host_transfer_t *transfer);
 
extern usb_status_t USB_HostCancelTransfer(usb_host_handle hostHandle,
                                           usb_host_pipe_handle pipeHandle,
                                           usb_host_transfer_t *transfer);
 
extern usb_status_t USB_HostMallocTransfer(usb_host_handle hostHandle, usb_host_transfer_t **transfer);
 
extern usb_status_t USB_HostFreeTransfer(usb_host_handle hostHandle, usb_host_transfer_t *transfer);
 
extern usb_status_t USB_HostRequestControl(usb_device_handle deviceHandle,
                                           uint8_t usbRequest,
                                           usb_host_transfer_t *transfer,
                                           void *param);
 
extern usb_status_t USB_HostOpenDeviceInterface(usb_device_handle deviceHandle,
                                                usb_host_interface_handle interfaceHandle);
 
extern usb_status_t USB_HostCloseDeviceInterface(usb_device_handle deviceHandle,
                                                 usb_host_interface_handle interfaceHandle);
 
extern void USB_HostGetVersion(uint32_t *version);
 
#if ((defined(USB_HOST_CONFIG_LOW_POWER_MODE)) && (USB_HOST_CONFIG_LOW_POWER_MODE > 0U))
extern usb_status_t USB_HostSuspendDeviceResquest(usb_host_handle hostHandle, usb_device_handle deviceHandle);
 
extern usb_status_t USB_HostResumeDeviceResquest(usb_host_handle hostHandle, usb_device_handle deviceHandle);
#if ((defined(USB_HOST_CONFIG_LPM_L1)) && (USB_HOST_CONFIG_LPM_L1 > 0U))
extern usb_status_t USB_HostL1SleepDeviceResquest(usb_host_handle hostHandle,
                                                  usb_device_handle deviceHandle,
                                                  uint8_t sleepType);
 
extern usb_status_t USB_HostL1ResumeDeviceResquest(usb_host_handle hostHandle,
                                                   usb_device_handle deviceHandle,
                                                   uint8_t sleepType);
extern usb_status_t USB_HostL1SleepDeviceResquestConfig(usb_host_handle hostHandle, uint8_t *lpmParam);
#endif
extern usb_status_t USB_HostUpdateHwTick(usb_host_handle hostHandle, uint64_t tick);
 
#endif
 
#if ((defined(USB_HOST_CONFIG_BATTERY_CHARGER)) && (USB_HOST_CONFIG_BATTERY_CHARGER > 0U))
extern usb_status_t USB_HostSetChargerType(usb_host_handle hostHandle, uint8_t type);
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* _USB_HOST_H_ */