udcd.h

Go to the documentation of this file.

 
#ifndef _PSP2KERN_UDCD_H_
#define _PSP2KERN_UDCD_H_
 
#include <vitasdk/build_utils.h>
#include <psp2kern/types.h>
#include <psp2common/udcd.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum SceUdcdUsbClass {
    USB_CLASS_PER_INTERFACE       = 0x00,  
    USB_CLASS_AUDIO               = 0x01,
    USB_CLASS_COMM                = 0x02,
    USB_CLASS_HID                 = 0x03,
    USB_CLASS_PTP                 = 0x06,
    USB_CLASS_PRINTER             = 0x07,
    USB_CLASS_MASS_STORAGE        = 0x08,
    USB_CLASS_HUB                 = 0x09,
    USB_CLASS_DATA                = 0x0A,
    USB_CLASS_VIDEO               = 0x0E,
    USB_CLASS_VENDOR_SPEC         = 0xFF
} SceUdcdUsbClass;
 
typedef enum SceUdcdUsbDt {
    USB_DT_DEVICE         = 0x01,
    USB_DT_CONFIG         = 0x02,
    USB_DT_STRING         = 0x03,
    USB_DT_INTERFACE      = 0x04,
    USB_DT_ENDPOINT       = 0x05
} SceUdcdUsbDt;
 
typedef enum SceUdcdUsbReq {
    USB_REQ_GET_STATUS      = 0x00,
    USB_REQ_CLEAR_FEATURE   = 0x01,
    USB_REQ_SET_FEATURE     = 0x03,
    USB_REQ_SET_ADDRESS     = 0x05,
    USB_REQ_GET_DESCRIPTOR  = 0x06,
    USB_REQ_SET_DESCRIPTOR  = 0x07,
    USB_REQ_GET_CONFIG      = 0x08,
    USB_REQ_SET_CONFIG      = 0x09,
    USB_REQ_GET_INTERFACE   = 0x0A,
    USB_REQ_SET_INTERFACE   = 0x0B,
    USB_REQ_SYNC_FRAME      = 0x0C
} SceUdcdUsbReq;
 
#define USB_DT_DEVICE_SIZE      18
#define USB_DT_CONFIG_SIZE      9
#define USB_DT_INTERFACE_SIZE       9
#define USB_DT_ENDPOINT_SIZE        7
#define USB_DT_ENDPOINT_AUDIO_SIZE  9   
#define USB_DT_HUB_NONVAR_SIZE      7
 
#define USB_CTRLTYPE_DIR_MASK       0x80
#define USB_CTRLTYPE_DIR_HOST2DEVICE    (0 << 7)
#define USB_CTRLTYPE_DIR_DEVICE2HOST    (1 << 7)
#define USB_CTRLTYPE_TYPE_MASK      0x60
#define USB_CTRLTYPE_TYPE_STANDARD  (0 << 5)
#define USB_CTRLTYPE_TYPE_CLASS     (1 << 5)
#define USB_CTRLTYPE_TYPE_VENDOR    (2 << 5)
#define USB_CTRLTYPE_TYPE_RESERVED  (3 << 5)
#define USB_CTRLTYPE_REC_MASK       0x1f
#define USB_CTRLTYPE_REC_DEVICE     0
#define USB_CTRLTYPE_REC_INTERFACE  1
#define USB_CTRLTYPE_REC_ENDPOINT   2
#define USB_CTRLTYPE_REC_OTHER      3
 
#define USB_ENDPOINT_ADDRESS_MASK       0x0f    /* in bEndpointAddress */
#define USB_ENDPOINT_DIR_MASK           0x80
 
#define USB_FEATURE_ENDPOINT_HALT   0
 
#define USB_ENDPOINT_IN         0x80
#define USB_ENDPOINT_OUT        0x00
 
#define USB_ENDPOINT_TYPE_MASK          0x03    /* in bmAttributes */
#define USB_ENDPOINT_TYPE_CONTROL       0
#define USB_ENDPOINT_TYPE_ISOCHRONOUS   1
#define USB_ENDPOINT_TYPE_BULK          2
#define USB_ENDPOINT_TYPE_INTERRUPT     3
 
/* HID constants. Not part of chapter 9 */
 
typedef enum SceUdcdHidRequest {
    HID_REQUEST_GET_REPORT     = 0x01,
    HID_REQUEST_GET_IDLE       = 0x02,
    HID_REQUEST_GET_PROTOCOL   = 0x03,
    HID_REQUEST_SET_REPORT     = 0x09,
    HID_REQUEST_SET_IDLE       = 0x0A,
    HID_REQUEST_SET_PROTOCOL   = 0x0B
} SceUdcdHidRequest;
 
typedef enum SceUdcdHidDescriptor {
    HID_DESCRIPTOR_HID     = 0x21,
    HID_DESCRIPTOR_REPORT  = 0x22,
    HID_DESRIPTOR_PHY      = 0x23
} SceUdcdHidDescriptor;
 
typedef enum SceUdcdProtocol {
    BOOT_PROTOCOL  = 0x00,
    RPT_PROTOCOL   = 0x01
} SceUdcdProtocol;
 
#define HID_INTF            0x03
 
#define BOOT_INTF_SUBCLASS      0x01
 
typedef enum SceUdcdHidProtocol {
    HID_PROTOCOL_NONE      = 0x00,
    HID_PROTOCOL_KEYBOARD  = 0x01,
    HID_PROTOCOL_MOUSE     = 0x02
} SceUdcdHidProtocol;
 
#define SCE_UDCD_MAX_INTERFACES     8
#define SCE_UDCD_MAX_ENDPOINTS      9
#define SCE_UDCD_MAX_ALTERNATE      2
 
typedef enum SceUdcdRetcode {
    SCE_UDCD_RETCODE_CANCEL              = -1,
    SCE_UDCD_RETCODE_CANCEL_ALL          = -2,
    SCE_UDCD_RETCODE_CANCEL_TRANSMISSION = -3,
    SCE_UDCD_RETCODE_SUCCESS             =  0,
    SCE_UDCD_RETCODE_SEND                =  1,
    SCE_UDCD_RETCODE_RECV                =  2
} SceUdcdRetcode;
 
typedef enum SceUdcdErrorCode {
    SCE_UDCD_ERROR_ILLEGAL_CONTEXT          = 0x80000030,
    SCE_UDCD_ERROR_INVALID_POINTER          = 0x80000103,
    SCE_UDCD_ERROR_INVALID_FLAG             = 0x80000105,
    SCE_UDCD_ERROR_INVALID_VALUE            = 0x800001FE,
    SCE_UDCD_ERROR_ALREADY_DONE             = 0x80243001,
    SCE_UDCD_ERROR_INVALID_ARGUMENT         = 0x80243002,
    SCE_UDCD_ERROR_ARGUMENT_EXCEEDED_LIMIT  = 0x80243003,
    SCE_UDCD_ERROR_MEMORY_EXHAUSTED         = 0x80243004,
    SCE_UDCD_ERROR_DRIVER_NOT_FOUND         = 0x80243005,
    SCE_UDCD_ERROR_DRIVER_IN_PROGRESS       = 0x80243006,
    SCE_UDCD_ERROR_BUS_DRIVER_NOT_STARTED   = 0x80243007,
    SCE_UDCD_ERROR_WAIT_TIMEOUT             = 0x80243008,
    SCE_UDCD_ERROR_WAIT_CANCEL              = 0x80243009,
    SCE_UDCD_ERROR_USBDRIVER_INVALID_DRIVER = 0x80243200,
    SCE_UDCD_ERROR_USBDRIVER_INVALID_NAME   = 0x80243201,
    SCE_UDCD_ERROR_USBDRIVER_INVALID_FUNCS  = 0x80243202
} SceUdcdErrorCode;
 
typedef enum SceUdcdDeviceRequestAttr {
    SCE_UDCD_DEVICE_REQUEST_ATTR_PHYCONT = 0x00000001
} SceUdcdDeviceRequestAttr;
 
typedef struct SceUdcdStringDescriptor {
    unsigned char bLength;
    unsigned char bDescriptorType;
    short         bString[31];
} SceUdcdStringDescriptor;
VITASDK_BUILD_ASSERT_EQ(0x40, SceUdcdStringDescriptor);
 
typedef struct SCE_ALIGN(4) SceUdcdDeviceDescriptor {
    unsigned char  bLength;
    unsigned char  bDescriptorType;
    unsigned short bcdUSB;
    unsigned char  bDeviceClass;
    unsigned char  bDeviceSubClass;
    unsigned char  bDeviceProtocol;
    unsigned char  bMaxPacketSize0;
    unsigned short idVendor;
    unsigned short idProduct;
    unsigned short bcdDevice;
    unsigned char  iManufacturer;
    unsigned char  iProduct;
    unsigned char  iSerialNumber;
    unsigned char  bNumConfigurations;
} SceUdcdDeviceDescriptor;
VITASDK_BUILD_ASSERT_EQ(0x14, SceUdcdDeviceDescriptor);
 
typedef struct SCE_ALIGN(4) SceUdcdDeviceQualifierDescriptor {
    unsigned char  bLength;
    unsigned char  bDescriptorType;
    unsigned short bcdUSB;
    unsigned char  bDeviceClass;
    unsigned char  bDeviceSubClass;
    unsigned char  bDeviceProtocol;
    unsigned char  bMaxPacketSize0;
    unsigned char  bNumConfigurations;
    unsigned char  bReserved;
} SceUdcdDeviceQualifierDescriptor;
VITASDK_BUILD_ASSERT_EQ(0xC, SceUdcdDeviceQualifierDescriptor);
 
typedef struct SceUdcdConfigDescriptor {
    unsigned char  bLength;
    unsigned char  bDescriptorType;
    unsigned short wTotalLength;
    unsigned char  bNumInterfaces;
    unsigned char  bConfigurationValue;
    unsigned char  iConfiguration;
    unsigned char  bmAttributes;
    unsigned char  bMaxPower;
    struct SceUdcdInterfaceSettings *settings;
    unsigned char *extra;                       
    int extraLength;
} SceUdcdConfigDescriptor;
VITASDK_BUILD_ASSERT_EQ(0x18, SceUdcdConfigDescriptor);
 
typedef struct SceUdcdInterfaceSettings {
    struct SceUdcdInterfaceDescriptor *descriptors; 
    unsigned int alternateSetting;
    unsigned int numDescriptors;                    
} SceUdcdInterfaceSettings;
VITASDK_BUILD_ASSERT_EQ(0xC, SceUdcdInterfaceSettings);
 
typedef struct SceUdcdInterfaceDescriptor {
    unsigned char bLength;
    unsigned char bDescriptorType;
    unsigned char bInterfaceNumber;
    unsigned char bAlternateSetting;
    unsigned char bNumEndpoints;
    unsigned char bInterfaceClass;
    unsigned char bInterfaceSubClass;
    unsigned char bInterfaceProtocol;
    unsigned char iInterface;
    struct SceUdcdEndpointDescriptor *endpoints;
    unsigned char *extra;                         
    int extraLength;
} SceUdcdInterfaceDescriptor;
VITASDK_BUILD_ASSERT_EQ(0x18, SceUdcdInterfaceDescriptor);
 
typedef struct SceUdcdEndpointDescriptor {
    unsigned char  bLength;
    unsigned char  bDescriptorType;
    unsigned char  bEndpointAddress;
    unsigned char  bmAttributes;
    unsigned short wMaxPacketSize;
    unsigned char  bInterval;
    unsigned char *extra;              
    int extraLength;
} SceUdcdEndpointDescriptor;
VITASDK_BUILD_ASSERT_EQ(0x10, SceUdcdEndpointDescriptor);
 
typedef struct SceUdcdInterface {
    int expectNumber;     
    int interfaceNumber;  
    int numInterfaces;    
} SceUdcdInterface;
VITASDK_BUILD_ASSERT_EQ(0xC, SceUdcdInterface);
 
typedef struct SceUdcdEndpoint {
    int direction;            
    int driverEndpointNumber; 
    int endpointNumber;       
    int transmittedBytes;     
} SceUdcdEndpoint;
VITASDK_BUILD_ASSERT_EQ(0x10, SceUdcdEndpoint);
 
typedef struct SceUdcdConfiguration {
    SceUdcdConfigDescriptor   *configDescriptors;     
    SceUdcdInterfaceSettings  *settings;              
    SceUdcdInterfaceDescriptor *interfaceDescriptors;  
    SceUdcdEndpointDescriptor *endpointDescriptors;   
} SceUdcdConfiguration;
VITASDK_BUILD_ASSERT_EQ(0x10, SceUdcdConfiguration);
 
typedef struct SceUdcdEP0DeviceRequest {
    unsigned char  bmRequestType;
    unsigned char  bRequest;
    unsigned short wValue;
    unsigned short wIndex;
    unsigned short wLength;
} SceUdcdEP0DeviceRequest;
VITASDK_BUILD_ASSERT_EQ(8, SceUdcdEP0DeviceRequest);
 
typedef struct SceUdcdDriver {
    const char *driverName;                         
    int numEndpoints;                               
    SceUdcdEndpoint *endpoints;                     
    SceUdcdInterface *interface;                    
    SceUdcdDeviceDescriptor *descriptor_hi;         
    SceUdcdConfiguration *configuration_hi;         
    SceUdcdDeviceDescriptor *descriptor;            
    SceUdcdConfiguration *configuration;            
    SceUdcdStringDescriptor *stringDescriptors; 
    SceUdcdStringDescriptor *stringDescriptorProduct; 
    SceUdcdStringDescriptor *stringDescriptorSerial; 
    int (*processRequest)(int recipient, int arg /* endpoint number or interface number */, SceUdcdEP0DeviceRequest *req, void *user_data); 
    int (*changeSetting)(int interfaceNumber, int alternateSetting, int bus); 
    int (*attach)(int usb_version, void *user_data);                                  
    void (*detach)(void *user_data);                                            
    void (*configure)(int usb_version, int desc_count, SceUdcdInterfaceSettings *settings, void *user_data); 
    int (*start)(int size, void *args, void *user_data); 
    int (*stop)(int size, void *args, void *user_data);  
    void *user_data;                   
    int bus;                   
    struct SceUdcdDriver *link;          
} SceUdcdDriver;
VITASDK_BUILD_ASSERT_EQ(0x54, SceUdcdDriver);
 
typedef struct SceUdcdDeviceRequest {
    SceUdcdEndpoint *endpoint;                            
    void *data;                                           
    unsigned int attributes;                              
    int  size;                                            
    int  isControlRequest;                                
    void (*onComplete)(struct SceUdcdDeviceRequest *req); 
    int  transmitted;                                     
    int  returnCode;                                      
    struct SceUdcdDeviceRequest *next;                    
    void *unused;                                         
    void *physicalAddress;                                
} SceUdcdDeviceRequest;
VITASDK_BUILD_ASSERT_EQ(0x2C, SceUdcdDeviceRequest);
 
typedef struct SCE_ALIGN(16) SceUdcdDriverName {
    int  size;
    char name[32];
    int  flags;
} SceUdcdDriverName;
VITASDK_BUILD_ASSERT_EQ(((0x28 + (0x10 - 1)) & ~(0x10 - 1)), SceUdcdDriverName);
 
int ksceUdcdWaitBusInitialized(unsigned int timeout, int bus);
 
int ksceUdcdStart(const char *driverName, int size, void *args);
 
int ksceUdcdStartInternal(const char *driverName, int size, void *args, int bus);
 
int ksceUdcdStartCurrentInternal(int unused, int bus);
 
int ksceUdcdStop(const char *driverName, int size, void *args);
 
int ksceUdcdStopInternal(const char *driverName, int size, void *args, int bus);
 
int ksceUdcdStopCurrentInternal(int bus);
 
int ksceUdcdActivate(unsigned int productId);
 
int ksceUdcdActivateInternal(unsigned int productId, unsigned int bus_powered, int bus);
 
int ksceUdcdDeactivate(void);
 
int ksceUdcdDeactivateInternal(int bus);
 
int ksceUdcdGetDeviceState(void);
 
int ksceUdcdGetDeviceStateInternal(int bus);
 
int ksceUdcdGetDeviceInfo(SceUdcdDeviceInfo *devInfo);
 
int ksceUdcdGetDeviceInfoInternal(SceUdcdDeviceInfo *devInfo, int bus);
 
int ksceUdcdGetDrvState(const char *driverName);
 
int ksceUdcdGetDrvStateInternal(const char *driverName, int bus);
 
int ksceUdcdWaitState(SceUdcdWaitParam *waitParam, unsigned int timeout);
 
int ksceUdcdWaitStateInternal(SceUdcdWaitParam *waitParam, unsigned int timeout, int bus);
 
int ksceUdcdRegister(SceUdcdDriver *drv);
 
int ksceUdcdRegisterInternal(SceUdcdDriver *drv, int bus);
 
int ksceUdcdUnregister(SceUdcdDriver *drv);
 
int ksceUdcdUnregisterInternal(SceUdcdDriver *drv, int bus);
 
int ksceUdcdClearFIFO(SceUdcdEndpoint *endp);
 
int ksceUdcdClearFIFOInternal(SceUdcdEndpoint *endp, int bus);
 
int ksceUdcdReqCancelAll(SceUdcdEndpoint *endp);
 
int ksceUdcdStall(SceUdcdEndpoint *endp);
 
int ksceUdcdStallInternal(SceUdcdEndpoint *endp, int bus);
 
int ksceUdcdReqSend(SceUdcdDeviceRequest *req);
 
int ksceUdcdReqSendInternal(SceUdcdDeviceRequest *req, int bus);
 
int ksceUdcdReqRecv(SceUdcdDeviceRequest *req);
 
int ksceUdcdReqRecvInternal(SceUdcdDeviceRequest *req, int bus);
 
#ifdef __cplusplus
}
#endif
 
#endif /* _PSP2KERN_UDCD_H_ */