245 lines
7.1 KiB
C
245 lines
7.1 KiB
C
/*
|
|
This file implements libogc usb API, but with ehci direct call
|
|
|
|
most of the file credit goes to libogc devs
|
|
*/
|
|
|
|
#define __usb_control_message(fd, b, c,d, e, f, g, h, i) ehci_control_message(fd,b,c,d,e,f,g)
|
|
|
|
static s32 __usb_getdesc(struct ehci_device * fd, u8 *buffer, u8 type, u8 index, u8 size)
|
|
{
|
|
//printk("usb_get desc %X %X %p\n",type,index,buffer);
|
|
return __usb_control_message(fd, USB_ENDPOINT_IN ,USB_REQ_GETDESCRIPTOR, (type << 8) | index, 0, size, buffer, NULL, NULL);
|
|
}
|
|
|
|
s32 USB_GetDescriptors(struct ehci_device * fd, usb_devdesc *udd)
|
|
{
|
|
u8 *buffer = NULL;
|
|
u8 *ptr = NULL;
|
|
usb_configurationdesc *ucd = NULL;
|
|
usb_interfacedesc *uid = NULL;
|
|
usb_endpointdesc *ued = NULL;
|
|
s32 retval = 0;
|
|
u32 iConf, iInterface, iEndpoint;
|
|
|
|
buffer = USB_Alloc(sizeof(*udd));
|
|
if(buffer == NULL)
|
|
{
|
|
retval = -ENOMEM;
|
|
goto free_and_error;
|
|
}
|
|
|
|
retval = __usb_getdesc(fd, buffer, USB_DT_DEVICE, 0, USB_DT_DEVICE_SIZE);
|
|
if(retval < 0)
|
|
{
|
|
dbgprintf("USB:__usb_getdesc():%d failed\n", retval );
|
|
goto free_and_error;
|
|
}
|
|
|
|
memcpy( udd, buffer, USB_DT_DEVICE_SIZE );
|
|
USB_Free(buffer);
|
|
|
|
u32 *_udd = (u32*)udd;
|
|
|
|
_udd[1] = ( udd->bLength << 24 ) | ( udd->bDescriptorType << 16 ) | cpu_to_le16(udd->bcdUSB);
|
|
_udd[2] = ( cpu_to_le16(udd->idVendor) << 16 ) | cpu_to_le16(udd->idProduct);
|
|
_udd[3] = ( cpu_to_le16(udd->bcdDevice) << 16 ) | (udd->iManufacturer<<8) | udd->iProduct;
|
|
|
|
u32 _ptr = (u32)USB_Alloc( udd->bNumConfigurations * sizeof(*udd->configurations) );
|
|
|
|
//udd->configurations = USB_Alloc(udd->bNumConfigurations* sizeof(*udd->configurations));
|
|
if( _ptr == 0)
|
|
{
|
|
dbgprintf("USB:USB_Alloc():failed:%u\n", __LINE__ );
|
|
retval = -ENOMEM;
|
|
goto free_and_error;
|
|
}
|
|
|
|
_udd[4] = ( udd->iSerialNumber << 24 ) | ( udd->bNumConfigurations << 16 ) | (_ptr>>16);
|
|
_udd[5] = ((_ptr & 0xFFFF) << 16) | (_udd[5]&0xFFFF);
|
|
|
|
memset( udd->configurations, 0, udd->bNumConfigurations * sizeof(*udd->configurations) );
|
|
|
|
for( iConf = 0; iConf < udd->bNumConfigurations; iConf++)
|
|
{
|
|
buffer = USB_Alloc( USB_DT_CONFIG_SIZE );
|
|
if(buffer == NULL)
|
|
{
|
|
retval = -ENOMEM;
|
|
goto free_and_error;
|
|
}
|
|
|
|
retval = __usb_getdesc(fd, buffer, USB_DT_CONFIG, iConf, USB_DT_CONFIG_SIZE);
|
|
ucd = &udd->configurations[iConf];
|
|
memcpy( ucd, buffer, USB_DT_CONFIG_SIZE );
|
|
USB_Free( buffer );
|
|
|
|
u32 *_ucd = (u32*)ucd;
|
|
|
|
_ucd[0] = ( ucd->bLength << 24 ) | ( ucd->bDescriptorType << 16 ) | cpu_to_le16(ucd->wTotalLength);
|
|
|
|
//ucd->wTotalLength = cpu_to_le16(ucd->wTotalLength);
|
|
|
|
buffer = USB_Alloc( ucd->wTotalLength);
|
|
if(buffer == NULL)
|
|
{
|
|
retval = -ENOMEM;
|
|
goto free_and_error;
|
|
}
|
|
|
|
retval = __usb_getdesc(fd, buffer, USB_DT_CONFIG, iConf, ucd->wTotalLength);
|
|
if(retval < 0)
|
|
goto free_and_error;
|
|
|
|
ptr = buffer;
|
|
ptr += ucd->bLength;
|
|
|
|
retval = -ENOMEM;
|
|
//ucd->interfaces = USB_Alloc(ucd->bNumInterfaces* sizeof(*ucd->interfaces));
|
|
//if(ucd->interfaces == NULL)
|
|
// goto free_and_error;
|
|
|
|
|
|
|
|
u32 _ptrB = (u32)USB_Alloc(ucd->bNumInterfaces* sizeof(*ucd->interfaces));
|
|
if( _ptrB == 0 )
|
|
goto free_and_error;
|
|
|
|
_ucd[2] = ( ucd->bMaxPower << 24 ) | (_ptrB>>8);
|
|
_ucd[3] = ((_ptrB & 0xFF) << 24) | (_ucd[3]&0xFFFFFF);
|
|
|
|
//dbgprintf("ucd->interfaces:%p\n", ucd->interfaces );
|
|
memset( ucd->interfaces, 0, ucd->bNumInterfaces * sizeof(*ucd->interfaces) );
|
|
|
|
for(iInterface = 0; iInterface < ucd->bNumInterfaces; iInterface++)
|
|
{
|
|
uid = &ucd->interfaces[iInterface];
|
|
memcpy(uid, ptr, USB_DT_INTERFACE_SIZE);
|
|
ptr += uid->bLength;
|
|
|
|
//uid->endpoints = USB_Alloc(uid->bNumEndpoints* sizeof(*uid->endpoints));
|
|
//if(uid->endpoints == NULL)
|
|
// goto free_and_error;
|
|
|
|
u32 *_uid = (u32*)uid;
|
|
u32 _ptrC = (u32)USB_Alloc(uid->bNumEndpoints* sizeof(*uid->endpoints));
|
|
|
|
_uid[2] = (uid->iInterface<<24) | (_ptrC >> 8);
|
|
_uid[3] = (_ptrC<<24) | (_uid[3]&0xFFFFFF);
|
|
|
|
memset( uid->endpoints, 0, uid->bNumEndpoints * sizeof(*uid->endpoints) );
|
|
|
|
for( iEndpoint = 0; iEndpoint < uid->bNumEndpoints; iEndpoint++)
|
|
{
|
|
ued = &uid->endpoints[iEndpoint];
|
|
memcpy( ued, ptr, USB_DT_ENDPOINT_SIZE );
|
|
ptr += ued->bLength;
|
|
|
|
//ued->wMaxPacketSize = cpu_to_le16(ued->wMaxPacketSize);
|
|
u32 *_ued = (u32*)ued;
|
|
_ued[1] = (cpu_to_le16(ued->wMaxPacketSize) << 16 ) | (_ued[1] & 0xFFFF);
|
|
}
|
|
|
|
USB_Free((void*)_ptrC);
|
|
}
|
|
|
|
USB_Free((void*)_ptrB);
|
|
|
|
USB_Free( buffer);
|
|
buffer = (u8*)NULL;
|
|
}
|
|
retval = 0;
|
|
|
|
free_and_error:
|
|
if( _ptr != 0 )
|
|
USB_Free((void*)_ptr);
|
|
|
|
if(buffer != NULL)
|
|
USB_Free(buffer);
|
|
|
|
if(retval < 0)
|
|
USB_FreeDescriptors(udd);
|
|
|
|
return retval;
|
|
}
|
|
|
|
void USB_FreeDescriptors(usb_devdesc *udd)
|
|
{
|
|
int iConf, iInterface;
|
|
usb_configurationdesc *ucd;
|
|
usb_interfacedesc *uid;
|
|
if(udd->configurations != NULL)
|
|
{
|
|
for(iConf = 0; iConf < udd->bNumConfigurations; iConf++)
|
|
{
|
|
ucd = &udd->configurations[iConf];
|
|
if(ucd->interfaces != NULL)
|
|
{
|
|
for(iInterface = 0; iInterface < ucd->bNumInterfaces; iInterface++)
|
|
{
|
|
uid = &ucd->interfaces[iInterface];
|
|
if(uid->endpoints != NULL)
|
|
USB_Free(uid->endpoints);
|
|
}
|
|
USB_Free(ucd->interfaces);
|
|
}
|
|
}
|
|
USB_Free(udd->configurations);
|
|
}
|
|
}
|
|
|
|
|
|
void USB_SuspendDevice(struct ehci_device *fd)
|
|
{
|
|
return ;
|
|
}
|
|
void USB_ResumeDevice(struct ehci_device *fd)
|
|
{
|
|
return ;
|
|
}
|
|
|
|
|
|
s32 USB_WriteBlkMsg(struct ehci_device *fd,u8 bEndpoint,u16 wLength,void *rpData)
|
|
{
|
|
return ehci_bulk_message(fd,bEndpoint,wLength,rpData);
|
|
}
|
|
|
|
s32 USB_WriteCtrlMsg(struct ehci_device *fd,u8 bmRequestType,u8 bmRequest,u16 wValue,u16 wIndex,u16 wLength,void *rpData)
|
|
{
|
|
return __usb_control_message(fd,bmRequestType,bmRequest,wValue,wIndex,wLength,rpData,NULL,NULL);
|
|
}
|
|
|
|
s32 USB_GetConfiguration(struct ehci_device *fd, u8 *configuration)
|
|
{
|
|
u8 *_configuration;
|
|
s32 retval;
|
|
|
|
_configuration = USB_Alloc(1);
|
|
if(_configuration == NULL)
|
|
return -ENOMEM;
|
|
|
|
retval = __usb_control_message(fd, (USB_CTRLTYPE_DIR_DEVICE2HOST | USB_CTRLTYPE_TYPE_STANDARD | USB_CTRLTYPE_REC_DEVICE), USB_REQ_GETCONFIG, 0, 0, 1, _configuration, NULL, NULL);
|
|
if(retval >= 0)
|
|
*configuration = *_configuration;
|
|
USB_Free( _configuration);
|
|
|
|
return retval;
|
|
}
|
|
s32 USB_SetConfiguration(struct ehci_device *fd, u8 configuration)
|
|
{
|
|
return __usb_control_message(fd, (USB_CTRLTYPE_DIR_HOST2DEVICE | USB_CTRLTYPE_TYPE_STANDARD | USB_CTRLTYPE_REC_DEVICE), USB_REQ_SETCONFIG, configuration, 0, 0, NULL, NULL, NULL);
|
|
}
|
|
s32 USB_SetAlternativeInterface(struct ehci_device *fd, u8 interface, u8 alternateSetting)
|
|
{
|
|
if(alternateSetting == 0)
|
|
return -EINVAL;
|
|
return __usb_control_message(fd, (USB_CTRLTYPE_DIR_HOST2DEVICE | USB_CTRLTYPE_TYPE_STANDARD | USB_CTRLTYPE_REC_INTERFACE),
|
|
USB_REQ_SETINTERFACE, alternateSetting, interface, 0, NULL, NULL, NULL);
|
|
|
|
}
|
|
s32 USB_ClearHalt(struct ehci_device *fd, u8 endpoint)
|
|
{
|
|
return __usb_control_message(fd, (USB_CTRLTYPE_DIR_HOST2DEVICE | USB_CTRLTYPE_TYPE_STANDARD | USB_CTRLTYPE_REC_ENDPOINT),
|
|
USB_REQ_CLEARFEATURE, USB_FEATURE_ENDPOINT_HALT, endpoint, 0, NULL, NULL, NULL);
|
|
}
|