📄 usbhost.c
字号:
}
HOSTPRINTF("DEVICE DESC TYPE %d FAILED\n", type);
return 0;
}
Sint16 USB_GetConfiguration(void)
{
Boolean gotIface;
Uint8 bf[512];
Uint8 Config_no, EndPointCount;
Uint16 length, i, config_length;
Uint16 lang_id;
EndPointCount = 0;
// MassStorage.Config = 0;
// StillImage.Config = 0;
/* Get full 18 bytes of the device descriptor */
HOSTPRINTF("Configuration: Get full DEVICE DESC addr %d\n", *regADDR);
length = USB_GetDescriptor(DEVICE_TYPE, 0, &DeviceDesc, sizeof(DEVICE_DESC));
if (length < 18)
return FALSE;
/*Get Configuration Length*/
length = USB_GetDescriptor(CONFIGURATION_TYPE, 0, &ConfigDesc, sizeof(CONFIG_DESC));
if (length < sizeof(CONFIG_DESC)) {
HOSTPRINTF("Configuration: CONFIG DESC FAILED: length %d\n", length);
return FALSE;
}
/*********************/
/* Device Descriptor */
/*********************/
#if USBH_VERBOSE
length = USB_GetString(0, 0);
if (length < 2)
return FALSE;
lang_id = ((Uint16)dev_request_buffer[WLANGID0_HIGH] << 8) |
(Uint16)dev_request_buffer[WLANGID0_LOW];
if (DeviceDesc.bManufacturer) {
HOSTPRINTF("\n\nManufacturer: ");
USB_PrintString(DeviceDesc.bManufacturer, lang_id);
}
if (DeviceDesc.bProduct) {
HOSTPRINTF("Product: ");
USB_PrintString(DeviceDesc.bProduct, lang_id);
}
if (DeviceDesc.iSerialNumber) {
HOSTPRINTF("Serial no.: ");
USB_PrintString(DeviceDesc.iSerialNumber, lang_id);
}
HOSTPRINTF("Supports USB %x.%02x\n",
DeviceDesc.bcdUSB_high, DeviceDesc.bcdUSB_low);
HOSTPRINTF("Class: %02x, Subclass %02x, Protocol %02x\n",
DeviceDesc.bDeviceClass, DeviceDesc.bDeviceSubclass,
DeviceDesc.bDeviceProtocol);
HOSTPRINTF("VID: %02x%02x, PID %02x%02x\n",
DeviceDesc.idVendor_high, DeviceDesc.idVendor_low,
DeviceDesc.idProduct_high, DeviceDesc.idProduct_low);
HOSTPRINTF("Device release: %x.%02x\n",
DeviceDesc.bcdDevice_high, DeviceDesc.bcdDevice_low);
HOSTPRINTF("No. of configurations: %d\n", DeviceDesc.bNumConfigurations);
#endif
config_length = ConfigDesc.wTotalLength_high*256 +
ConfigDesc.wTotalLength_low;
/*Get Info in bf[]*/
length = USB_GetDescriptor(CONFIGURATION_TYPE, 0, bf, config_length);
if (length < config_length) {
HOSTPRINTF("CONFIG DESC FAILED: length %d vs. expected %d\n",
length, config_length);
return FALSE;
}
/*Analysis bf[] Info*/
gotIface = FALSE;
i = 0;
Config_no = 0;
MassStorage.needClass = TRUE;
StillImage.needClass = TRUE;
while (i < length) {
switch (bf[i+1]) {
case CONFIGURATION_TYPE:
++Config_no;
if (Config_no > DeviceDesc.bNumConfigurations) {
HOSTPRINTF("More than %d many configurations\n",
DeviceDesc.bNumConfigurations);
return FALSE;
}
memcpy((Uint8 *)&ConfigDesc,&bf[i], sizeof(CONFIG_DESC));
#if USBH_VERBOSE
HOSTPRINTF("\nConfiguration no.: %d\n",
ConfigDesc.bConfigurationValue);
HOSTPRINTF(" Total length of configuration: %d\n",
ConfigDesc.wTotalLength_high*256 +
ConfigDesc.wTotalLength_low);
HOSTPRINTF(" No. of Interfaces: %d\n", ConfigDesc.bNumInterfaces);
if (ConfigDesc.iConfiguration) {
HOSTPRINTF("Configuration name: ");
USB_PrintString(ConfigDesc.iConfiguration, lang_id);
}
HOSTPRINTF(" Configuration attributes: %02x\n Max Power: %d mA.\n",
ConfigDesc.bmAttributes, ConfigDesc.bMaxPower);
#endif
break;
case INTERFACE_TYPE:
if (bf[i] != sizeof(INTERFACE_DESC)) {
HOSTPRINTF("Bad Interface desc, size %d\n", bf[i]);
return FALSE;
}
memcpy((Uint8 *)&InterfaceDesc, &bf[i], sizeof(INTERFACE_DESC));
gotIface = TRUE;
EndPointCount = 0;
#if USBH_VERBOSE
HOSTPRINTF("\n Interface Descriptor %02x Alt: %02x:\n",
InterfaceDesc.bInterfaceNumber,
InterfaceDesc.bAlternateSetting);
if (InterfaceDesc.iInterface) {
HOSTPRINTF(" Interface[%d]: ", InterfaceDesc.iInterface);
USB_PrintString(InterfaceDesc.iInterface, lang_id);
}
HOSTPRINTF(" %d endpoints\n Class %02x ",
InterfaceDesc.bNumEndpoints,
InterfaceDesc.bInterfaceClass);
switch (InterfaceDesc.bInterfaceClass) {
case 3:
HOSTPRINTF("HID Class\n");
break;
case 6:
HOSTPRINTF("Still Image Capture Device Class\n");
break;
case 7:
HOSTPRINTF("Printer Class\n");
break;
case 8:
HOSTPRINTF("Mass Storage Class\n");
break;
case 0xff:
HOSTPRINTF("Vendor specific\n");
break;
default:
HOSTPRINTF("class unknown\n");
}
HOSTPRINTF(" Subclass %02x\n Protocol %02x\n",
InterfaceDesc.bInterfaceSubClass,
InterfaceDesc.bInterfaceProtocol);
#endif
if (InterfaceDesc.bInterfaceNumber >= ConfigDesc.bNumInterfaces) {
HOSTPRINTF("ERROR: InterfaceNumber %d > NumInterfaces %d\n",
InterfaceDesc.bInterfaceNumber,
ConfigDesc.bNumInterfaces);
gotIface = FALSE;
}
else if (MassStorage.needClass &&
InterfaceDesc.bInterfaceClass == 8 &&
InterfaceDesc.bInterfaceSubClass == 6 &&
InterfaceDesc.bInterfaceProtocol == 0x50)
{
MassStorage.Config = Config_no;
MassStorage.iface = InterfaceDesc.bInterfaceNumber;
MassStorage.ifaceAlt = InterfaceDesc.bAlternateSetting;
MassStorage.ep_in = 0;
MassStorage.ep_out = 0;
MassStorage.ep_intr = 0;
}
else if (StillImage.needClass &&
InterfaceDesc.bInterfaceClass == 6 &&
InterfaceDesc.bInterfaceSubClass == 1 &&
InterfaceDesc.bInterfaceProtocol == 1)
{
StillImage.Config = Config_no;
StillImage.iface = InterfaceDesc.bInterfaceNumber;
StillImage.ifaceAlt = InterfaceDesc.bAlternateSetting;
StillImage.ep_in = 0;
StillImage.ep_out = 0;
StillImage.ep_intr = 0;
}
else{
HOSTPRINTF("Configuration: UnSupport Device\n");
return FALSE;
}
break;
case ENDPOINT_TYPE:
if (bf[i] != sizeof(ENDPOINT_DESC)) {
HOSTPRINTF("Bad Endpoint desc, size %d\n", bf[i]);
return FALSE;
}
memcpy((Uint8 *)&EndpointDesc,&bf[i], sizeof(ENDPOINT_DESC));
++EndPointCount;
#if USBH_VERBOSE
HOSTPRINTF("\n Endpoint Descriptor[%d]%s: EP %d %s\n",
EndPointCount, (gotIface ? "" : " (ignored)"),
(EndpointDesc.bEPAddress & 15),
((EndpointDesc.bEPAddress & 0x80) ? "IN":"OUT"));
if ((EndpointDesc.bmAttributes & 3) == 0)
HOSTPRINTF(" CNTRL");
else if ((EndpointDesc.bmAttributes & 3) == 1)
HOSTPRINTF(" ISO ");
else if ((EndpointDesc.bmAttributes & 3) == 2)
HOSTPRINTF(" BULK");
else
HOSTPRINTF(" INTR");
HOSTPRINTF(", Packet Size %d, Interval %d\n",
EndpointDesc.wMaxPacketSize_high*256 +
EndpointDesc.wMaxPacketSize_low,
EndpointDesc.bInterval);
if (EndPointCount > InterfaceDesc.bNumEndpoints) {
HOSTPRINTF("End point no. %d > NumEndpoints %d\n",
EndPointCount, InterfaceDesc.bNumEndpoints);
}
#endif
if (MassStorage.needClass && MassStorage.Config) {
if ((EndpointDesc.bmAttributes & 3) == 2) {
if (EndpointDesc.bEPAddress & 0x80) {
if (MassStorage.ep_in) {
HOSTPRINTF("multiple BULK IN endpoints\n");
MassStorage.Config = 0;
}
else {
MassStorage.ep_in = EndpointDesc.bEPAddress & 0x7f;
MassStorage.ep_in_pksize =
EndpointDesc.wMaxPacketSize_low +
256*EndpointDesc.wMaxPacketSize_high;
}
}
else {
if (MassStorage.ep_out) {
HOSTPRINTF("multiple BULK OUT endpoints\n");
MassStorage.Config = 0;
}
else {
MassStorage.ep_out = EndpointDesc.bEPAddress & 0x7f;
MassStorage.ep_out_pksize =
EndpointDesc.wMaxPacketSize_low +
256*EndpointDesc.wMaxPacketSize_high;
}
}
}
else if ((EndpointDesc.bmAttributes & 3) == 3 &&
(EndpointDesc.bEPAddress & 0x80))
{
if (MassStorage.ep_intr) {
HOSTPRINTF("multiple INTERRUPT IN endpoints\n");
MassStorage.Config = 0;
}
else {
MassStorage.ep_intr = EndpointDesc.bEPAddress & 0x7f;
MassStorage.ep_intr_pksize =
EndpointDesc.wMaxPacketSize_low +
256*EndpointDesc.wMaxPacketSize_high;
}
}
}
if (StillImage.needClass && StillImage.Config) {
if ((EndpointDesc.bmAttributes & 3) == 2) {
if (EndpointDesc.bEPAddress & 0x80) {
if (StillImage.ep_in) {
HOSTPRINTF("multiple BULK IN endpoints\n");
StillImage.Config = 0;
}
else {
StillImage.ep_in = EndpointDesc.bEPAddress & 0x7f;
StillImage.ep_in_pksize =
EndpointDesc.wMaxPacketSize_low +
256*EndpointDesc.wMaxPacketSize_high;
}
}
else {
if (StillImage.ep_out) {
HOSTPRINTF("multiple BULK OUT endpoints\n");
StillImage.Config = 0;
}
else {
StillImage.ep_out = EndpointDesc.bEPAddress & 0x7f;
StillImage.ep_out_pksize =
EndpointDesc.wMaxPacketSize_low +
256*EndpointDesc.wMaxPacketSize_high;
}
}
}
else if ((EndpointDesc.bmAttributes & 3) == 3 &&
(EndpointDesc.bEPAddress & 0x80))
{
if (StillImage.ep_intr) {
HOSTPRINTF("multiple INTERRUPT IN endpoints\n");
StillImage.Config = 0;
}
else {
StillImage.ep_intr = EndpointDesc.bEPAddress & 0x7f;
StillImage.ep_intr_pksize =
EndpointDesc.wMaxPacketSize_low +
256*EndpointDesc.wMaxPacketSize_high;
StillImage.ep_intr_pollms = EndpointDesc.bInterval;
}
}
}
break;
case HID_TYPE:
if (bf[i] != 9) {
HOSTPRINTF("Bad HID desc, size %d\n", bf[i]);
return FALSE;
}
HOSTPRINTF("\n HID Descriptor %s\n", (gotIface ? "" : "ignored"));
break;
default:
HOSTPRINTF("\n Descriptor type %d ignored.\n", bf[i+1]);
gotIface = FALSE;
break;
}//end switch
i += bf[i];
}//end while
#if USBH_VERBOSE
HOSTPRINTF("****************************************************\n");
if (StillImage.Config) {
HOSTPRINTF("Still Image Class:\n");
HOSTPRINTF("Configuration %d, interface %d [alternate %d]\n",
StillImage.Config, StillImage.iface, StillImage.ifaceAlt);
HOSTPRINTF("IN EP%d [%d], OUT EP%d [%d], INTR EP%d [%d] %d msec. polling\n",
StillImage.ep_in, StillImage.ep_in_pksize,
StillImage.ep_out, StillImage.ep_out_pksize,
StillImage.ep_intr, StillImage.ep_intr_pksize,
StillImage.ep_intr_pollms);
}
if (MassStorage.Config) {
HOSTPRINTF("Mass Storage Class:\n");
HOSTPRINTF("Config %d, interface %d [a %d], in %d [%d], out %d [%d]\n",
MassStorage.Config, MassStorage.iface, MassStorage.ifaceAlt,
MassStorage.ep_in, MassStorage.ep_in_pksize,
MassStorage.ep_out, MassStorage.ep_out_pksize);
}
#endif
return TRUE;
}
static Boolean USB_DoConfiguration(USB_CLASS *class)
{
Uint8 SetConfiguration[8] = { 0, 9, 0, 0, 0, 0, 0, 0};
Uint8 SetInterface[8] = { 1, 11, 0, 0, 0, 0, 0, 0};
Uint32 rstatus;
EP_DATA *ep1, *ep2, *ep3;
/* Set configuration to one containing desired interface */
HOSTPRINTF("DoConfiguration: SET CONFIG %d\n", class->Config);
SetConfiguration[wValue_low] = class->Config;
if(USB_device_request(SetConfiguration)){
HOSTPRINTF("DoConfiguration: Set Configuration Fail\n");
return FALSE;
}
if (class->ifaceAlt) {
HOSTPRINTF("DoConfiguration: SET IFACE %d to alternate %d\n", class->iface, class->ifaceAlt);
SetInterface[wIndex_low] = class->iface;
SetInterface[wValue_low] = class->ifaceAlt;
/* If power is off (or printer powering down) return immediately */
if(USB_device_request(SetInterface)){
HOSTPRINTF("DoConfiguration: Set Interface Fail\n");
return FALSE;
}
class->iface = class->ifaceAlt;
}
if (class->ep_in_pksize > FS_BULK_PKCT_SIZE)
class->ep_in_pksize = FS_BULK_PKCT_SIZE;
if (class->ep_out_pksize > FS_BULK_PKCT_SIZE)
class->ep_out_pksize = FS_BULK_PKCT_SIZE;
//Save StillImage EP Info
ep1=(EP_DATA*)malloc(sizeof(EP_DATA));
ep2=(EP_DATA*)malloc(sizeof(EP_DATA));
ep3=(EP_DATA*)malloc(sizeof(EP_DATA));
memset(ep1,0,sizeof(EP_DATA));
memset(ep2,0,sizeof(EP_DATA));
memset(ep3,0,sizeof(EP_DATA));
ep1->pipe_type = PIPE_IN;
ep1->EP = class->ep_in;
ep1->pksize = class->ep_in_pksize;
ep1->type = ENDPT_BULK_RX;
ep1->pid_ep = VUSB_TOKEN_IN | class->ep_in;
ep1->DATAx = 0;
device_info[DEVID_STILL_IMAGE].ep_list[0]=(Uint32*)ep1;
ep2->pipe_type = PIPE_OUT;
ep2->EP = class->ep_out;
ep2->pksize = class->ep_out_pksize;
ep2->type = ENDPT_BULK_TX;
ep2->pid_ep = VUSB_TOKEN_OUT | class->ep_out;
ep2->DATAx = 0;
device_info[DEVID_STILL_IMAGE].ep_list[1]=(Uint32*)ep2;
ep3->pipe_type = PIPE_INT;
ep3->EP = class->ep_intr;
ep3->pksize = class->ep_intr_pksize;
ep3->type = ENDPT_INT_RX;
ep3->pid_ep = VUSB_TOKEN_IN | class->ep_intr;
ep3->DATAx = 0;
device_info[DEVID_STILL_IMAGE].ep_list[2]=(Uint32*)ep3;
device_info[DEVID_STILL_IMAGE].ep_num=3;
device_info[DEVID_STILL_IMAGE].addr=*regADDR;
return TRUE;
}
Sint16 USB_enumerate(void)
{
int length;
MSG_Q CtrlMsg;
STATUS status;
UNSIGNED actual_size;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -