int mass_stor_probe(int devId) { UsbDeviceDescriptor *device = NULL; UsbConfigDescriptor *config = NULL; UsbInterfaceDescriptor *intf = NULL; XPRINTF("USBHDFSD: probe: devId=%i\n", devId); mass_dev* mass_device = mass_stor_findDevice(devId, 0); /* only one device supported */ if ((mass_device != NULL) && (mass_device->status & USBMASS_DEV_STAT_CONN)) { printf("USBHDFSD: Error - only one mass storage device allowed ! \n"); return 0; } /* get device descriptor */ device = (UsbDeviceDescriptor*)UsbGetDeviceStaticDescriptor(devId, NULL, USB_DT_DEVICE); if (device == NULL) { XPRINTF("USBHDFSD: Error - Couldn't get device descriptor\n"); return 0; } /* Check if the device has at least one configuration */ if (device->bNumConfigurations < 1) { return 0; } /* read configuration */ config = (UsbConfigDescriptor*)UsbGetDeviceStaticDescriptor(devId, device, USB_DT_CONFIG); if (config == NULL) { XPRINTF("USBHDFSD: Error - Couldn't get configuration descriptor\n"); return 0; } /* check that at least one interface exists */ XPRINTF("USBHDFSD: bNumInterfaces %d\n", config->bNumInterfaces); if ((config->bNumInterfaces < 1) || (config->wTotalLength < (sizeof(UsbConfigDescriptor) + sizeof(UsbInterfaceDescriptor)))) { XPRINTF("USBHDFSD: Error - No interfaces available\n"); return 0; } /* get interface */ intf = (UsbInterfaceDescriptor *) ((char *) config + config->bLength); /* Get first interface */ XPRINTF("USBHDFSD: bInterfaceClass %X bInterfaceSubClass %X bInterfaceProtocol %X\n", intf->bInterfaceClass, intf->bInterfaceSubClass, intf->bInterfaceProtocol); if ((intf->bInterfaceClass != USB_CLASS_MASS_STORAGE) || (intf->bInterfaceSubClass != USB_SUBCLASS_MASS_SCSI && intf->bInterfaceSubClass != USB_SUBCLASS_MASS_SFF_8070I) || (intf->bInterfaceProtocol != USB_PROTOCOL_MASS_BULK_ONLY) || (intf->bNumEndpoints < 2)) { //one bulk endpoint is not enough because return 0; //we send the CBW to te bulk out endpoint } return 1; }
int usb_connect(int devId) { UsbDeviceDescriptor *dev; UsbConfigDescriptor *conf; dev = UsbGetDeviceStaticDescriptor(devId, NULL, USB_DT_DEVICE); conf = UsbGetDeviceStaticDescriptor(devId, dev, USB_DT_CONFIG); controlEndp = UsbOpenEndpoint(devId, NULL); int slot = 0; if (ds3_list[0].connected) slot = 1; ds3_list[slot].endp = controlEndp; ds3_list[slot].connected = 1; ds3_list[slot].devID = devId; UsbSetDevicePrivateData(devId, NULL); UsbSetDeviceConfiguration(controlEndp, conf->bConfigurationValue, config_set, (void*)slot); return 0; }
int usb_probe(int devId) { UsbDeviceDescriptor *dev = NULL; dev = UsbGetDeviceStaticDescriptor(devId, NULL, USB_DT_DEVICE); if (!dev) return 0; if (dev->idVendor == DS3_VID && dev->idProduct == DS3_PID) { //Check if there's an available slot if (ds3_list[0].connected && ds3_list[1].connected) return 0; return 1; } return 0; }
/** called after a camera is accepted */ void PS2CamInitializeNewDevice(CAMERA_DEVICE *cam) { unsigned char *temp_str; UsbDeviceDescriptor *d; PS2CamSetDeviceConfiguration(cam,1); camStopStream(cam); PS2CamSelectInterface(cam,0,0); camStartStream(cam); PS2CamSetDeviceDefaults(cam); /* camStopStream(dev); setReg16(dev, 0x30, 384); camStartStream(dev); */ camStopStream(cam); PS2CamSelectInterface(cam,0,EYETOY_ALTERNATE_SIZE_384); camStartStream(cam); cam->status = CAM_STATUS_CONNECTEDREADY; // connected message (alloc som mem and get device string then print it and free the mem we alloced) d = UsbGetDeviceStaticDescriptor(cam->device_id, NULL, USB_DT_DEVICE); temp_str = AllocSysMemory(0, 128, 0); temp_str[0]=0x00; PS2CamGetDeviceSring(cam, d->iProduct, (char *)temp_str, 128); printf("cam initialized(%s)\n",temp_str); FreeSysMemory(temp_str); DeleteThread(maintain_thread); return; }
/** this is executed when a compatible camera is detected */ int PS2CamConnect(int devId) { int i; UsbDeviceDescriptor *dev; UsbInterfaceDescriptor *intf0,*intf1; UsbEndpointDescriptor *endp1; CAMERA_DEVICE *cam = NULL; iop_thread_t param; printf("camera was connected\n"); dev = UsbGetDeviceStaticDescriptor(devId, NULL, USB_DT_DEVICE); intf0 = UsbGetDeviceStaticDescriptor(devId, dev, USB_DT_INTERFACE); intf1 = UsbGetDeviceStaticDescriptor(devId, intf0, USB_DT_INTERFACE); endp1= (UsbEndpointDescriptor *) ((char *) intf1 + intf1->bLength); //get a free device slot for(i=0;i<MAX_CAM_DEVICE;i++) { if(Camera[i].status == 0) { cam = (CAMERA_DEVICE *)&Camera[i]; cam->status = CAM_STATUS_CONNECTED; break; } } cam->device_id = devId; cam->controll = UsbOpenEndpoint(devId, NULL); cam->stream = UsbOpenEndpoint(devId, endp1); cam->stream_pocket_size = (endp1->wMaxPacketSizeHB * 256 + endp1->wMaxPacketSizeLB); /*create thread that will execute funtions that cant be called*/ /*in this funtion*/ param.attr = TH_C; param.thread = (void *)PS2CamInitializeNewDevice; param.priority = 40; param.stacksize = 0x800; param.option = 0; maintain_thread = CreateThread(¶m); StartThread(maintain_thread, cam); return 0; }
/** check if the device is pluged in */ int PS2CamProbe(int devId) { static short count; int i; UsbDeviceDescriptor *dev; UsbConfigDescriptor *conf; UsbInterfaceDescriptor *intf; dev = UsbGetDeviceStaticDescriptor(devId, NULL, USB_DT_DEVICE); conf = UsbGetDeviceStaticDescriptor(devId, dev, USB_DT_CONFIG); intf = (UsbInterfaceDescriptor *) ((char *) conf + conf->bLength); // check for a free device slot. if none just ignore new device count=0; for(i=0;i<MAX_CAM_DEVICE;i++) { if(Camera[i].status==0)count++; } if(count <= 0) return 0; if(intf->bInterfaceClass == USB_CLASS_VENDOR_SPEC) { // eyetoy 1 if(dev->idVendor == PS2CAM_VEND_SONY && dev->idProduct == PS2CAM_PROD_EYETOY); { return 1; } // eyetoy 2 if(dev->idVendor == PS2CAM_VEND_SONY && dev->idProduct == PS2CAM_PROD_EYETOY2); { return 1; } // eyetoy 3 if(dev->idVendor == PS2CAM_VEND_SONY && dev->idProduct == PS2CAM_PROD_EYETOY3); { return 1; } // eyetoy 4 if(dev->idVendor == PS2CAM_VEND_SONY && dev->idProduct == PS2CAM_PROD_EYETOY4); { return 1; } // D-Link VisualStream DSB-C310 if(dev->idVendor == PS2CAM_VEND_DLINK && dev->idProduct == PS2CAM_PROD_VISUALSTREAM); { return 1; } } return 0; }
int ps2kbd_connect(int devId) { /* Assume we can only get here if we have already checked the device is kosher */ UsbDeviceDescriptor *dev; UsbConfigDescriptor *conf; UsbInterfaceDescriptor *intf; UsbEndpointDescriptor *endp; kbd_dev *currDev; int devLoop; //printf("PS2Kbd_connect devId %d\n", devId); dev = UsbGetDeviceStaticDescriptor(devId, NULL, USB_DT_DEVICE); /* Get device descriptor */ if(!dev) { printf("ERROR: Couldn't get device descriptor\n"); return 1; } conf = UsbGetDeviceStaticDescriptor(devId, dev, USB_DT_CONFIG); if(!conf) { printf("ERROR: Couldn't get configuration descriptor\n"); return 1; } intf = (UsbInterfaceDescriptor *) ((char *) conf + conf->bLength); /* Get first interface */ endp = (UsbEndpointDescriptor *) ((char *) intf + intf->bLength); endp = (UsbEndpointDescriptor *) ((char *) endp + endp->bLength); /* Go to the data endpoint */ for(devLoop = 0; devLoop < PS2KBD_MAXDEV; devLoop++) { if(devices[devLoop] == NULL) { break; } } if(devLoop == PS2KBD_MAXDEV) { /* How the f*** did we end up here ??? */ printf("ERROR: Device Weirdness!!\n"); return 1; } currDev = (kbd_dev *) AllocSysMemory(0, sizeof(kbd_dev), NULL); if(!currDev) { printf("ERROR: Couldn't allocate a device point for the kbd\n"); return 1; } devices[devLoop] = currDev; memset(currDev, 0, sizeof(kbd_dev)); currDev->configEndp = UsbOpenEndpoint(devId, NULL); currDev->dataEndp = UsbOpenEndpoint(devId, endp); currDev->packetSize = endp->wMaxPacketSizeLB | ((int) endp->wMaxPacketSizeHB << 8); currDev->eventmask = (1 << devLoop); if(currDev->packetSize > sizeof(kbd_data_recv)) { currDev->packetSize = sizeof(kbd_data_recv); } if(dev->iManufacturer != 0) { usb_getstring(currDev->configEndp, dev->iManufacturer, "Keyboard Manufacturer"); } if(dev->iProduct != 0) { usb_getstring(currDev->configEndp, dev->iProduct, "Keyboard Product"); } currDev->devId = devId; currDev->interfaceNo = intf->bInterfaceNumber; currDev->ledStatus = 0; UsbSetDevicePrivateData(devId, currDev); /* Set the index for the device data */ //printf("Configuration value %d\n", conf->bConfigurationValue); UsbSetDeviceConfiguration(currDev->configEndp, conf->bConfigurationValue, ps2kbd_config_set, currDev); dev_count++; /* Increment device count */ printf("PS2KBD: Connected device\n"); return 0; }
int ps2kbd_probe(int devId) { UsbDeviceDescriptor *dev; UsbConfigDescriptor *conf; UsbInterfaceDescriptor *intf; UsbEndpointDescriptor *endp; //UsbStringDescriptor *str; if(dev_count >= PS2KBD_MAXDEV) { printf("ERROR: Maximum keyboard devices reached\n"); return 0; } //printf("PS2Kbd_probe devId %d\n", devId); dev = UsbGetDeviceStaticDescriptor(devId, NULL, USB_DT_DEVICE); /* Get device descriptor */ if(!dev) { printf("ERROR: Couldn't get device descriptor\n"); return 0; } //printf("Device class %d, Size %d, Man %d, Product %d Cpnfigurations %d\n", dev->bDeviceClass, dev->bMaxPacketSize0, dev->iManufacturer, dev->iProduct, dev->bNumConfigurations); /* Check that the device class is specified in the interfaces and it has at least one configuration */ if((dev->bDeviceClass != USB_CLASS_PER_INTERFACE) || (dev->bNumConfigurations < 1)) { //printf("This is not the droid you're looking for\n"); return 0; } conf = UsbGetDeviceStaticDescriptor(devId, dev, USB_DT_CONFIG); if(!conf) { printf("ERROR: Couldn't get configuration descriptor\n"); return 0; } //printf("Config Length %d Total %d Interfaces %d\n", conf->bLength, conf->wTotalLength, conf->bNumInterfaces); if((conf->bNumInterfaces < 1) || (conf->wTotalLength < (sizeof(UsbConfigDescriptor) + sizeof(UsbInterfaceDescriptor)))) { printf("ERROR: No interfaces available\n"); return 0; } intf = (UsbInterfaceDescriptor *) ((char *) conf + conf->bLength); /* Get first interface */ /* printf("Interface Length %d Endpoints %d Class %d Sub %d Proto %d\n", intf->bLength, */ /* intf->bNumEndpoints, intf->bInterfaceClass, intf->bInterfaceSubClass, */ /* intf->bInterfaceProtocol); */ if((intf->bInterfaceClass != USB_CLASS_HID) || (intf->bInterfaceSubClass != USB_SUBCLASS_BOOT) || (intf->bInterfaceProtocol != USB_HIDPROTO_KEYBOARD) || (intf->bNumEndpoints < 1)) { //printf("We came, we saw, we told it to f**k off\n"); return 0; } endp = (UsbEndpointDescriptor *) ((char *) intf + intf->bLength); endp = (UsbEndpointDescriptor *) ((char *) endp + endp->bLength); /* Go to the data endpoint */ //printf("Endpoint 1 Addr %d, Attr %d, MaxPacket %d\n", endp->bEndpointAddress, endp->bmAttributes, endp->wMaxPacketSizeLB); if(((endp->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_INT) || ((endp->bEndpointAddress & USB_ENDPOINT_DIR_MASK) != USB_DIR_IN)) { printf("ERROR: Endpoint not interrupt type and/or an input\n"); return 0; } printf("PS2KBD: Found a keyboard device\n"); return 1; }
int mass_stor_connect(int devId) { int i; int epCount; UsbDeviceDescriptor *device; UsbConfigDescriptor *config; UsbInterfaceDescriptor *interface; UsbEndpointDescriptor *endpoint; iop_sema_t SemaData; mass_dev* dev; printf("USBHDFSD: connect: devId=%i\n", devId); dev = mass_stor_findDevice(devId, 1); if (dev == NULL) { printf("USBHDFSD: Error - unable to allocate space!\n"); return 1; } /* only one mass device allowed */ if (dev->devId != -1) { printf("USBHDFSD: Error - only one mass storage device allowed !\n"); return 1; } dev->status = 0; dev->sectorSize = 0; dev->bulkEpI = -1; dev->bulkEpO = -1; /* open the config endpoint */ dev->controlEp = UsbOpenEndpoint(devId, NULL); device = (UsbDeviceDescriptor*)UsbGetDeviceStaticDescriptor(devId, NULL, USB_DT_DEVICE); config = (UsbConfigDescriptor*)UsbGetDeviceStaticDescriptor(devId, device, USB_DT_CONFIG); interface = (UsbInterfaceDescriptor *) ((char *) config + config->bLength); /* Get first interface */ // store interface numbers dev->interfaceNumber = interface->bInterfaceNumber; dev->interfaceAlt = interface->bAlternateSetting; epCount = interface->bNumEndpoints; endpoint = (UsbEndpointDescriptor*)UsbGetDeviceStaticDescriptor(devId, NULL, USB_DT_ENDPOINT); usb_bulk_probeEndpoint(devId, dev, endpoint); for (i = 1; i < epCount; i++) { endpoint = (UsbEndpointDescriptor*) ((char *) endpoint + endpoint->bLength); usb_bulk_probeEndpoint(devId, dev, endpoint); } // Bail out if we do NOT have enough bulk endpoints. if (dev->bulkEpI < 0 || dev->bulkEpO < 0) { mass_stor_release(dev); printf("USBHDFSD: Error - connect failed: not enough bulk endpoints! \n"); return -1; } SemaData.initial = 0; SemaData.max = 1; SemaData.option = 0; SemaData.attr = 0; if((dev->ioSema = CreateSema(&SemaData)) <0){ printf("USBHDFSD: Failed to allocate I/O semaphore.\n"); return -1; } /*store current configuration id - can't call set_configuration here */ dev->devId = devId; dev->configId = config->bConfigurationValue; dev->status = USBMASS_DEV_STAT_CONN; XPRINTF("USBHDFSD: connect ok: epI=%i, epO=%i \n", dev->bulkEpI, dev->bulkEpO); if(dev->callback != NULL) dev->callback(USBMASS_DEV_EV_CONN); return 0; }
int mass_stor_connect(int devId) { int i; int epCount; UsbDeviceDescriptor *device; UsbConfigDescriptor *config; UsbInterfaceDescriptor *interface; UsbEndpointDescriptor *endpoint; mass_dev* dev; //wait_for_connect = 0; printf("USBHDFSD: connect: devId=%i\n", devId); dev = mass_stor_findDevice(devId, 1); if (dev == NULL) { printf("USBHDFSD: Error - unable to allocate space!\n"); return 1; } /* only one mass device allowed */ if (dev->devId != -1) { printf("USBHDFSD: Error - only one mass storage device allowed !\n"); return 1; } dev->status = 0; dev->sectorSize = 0; dev->bulkEpI = -1; dev->bulkEpO = -1; /* open the config endpoint */ dev->controlEp = UsbOpenEndpoint(devId, NULL); device = (UsbDeviceDescriptor*)UsbGetDeviceStaticDescriptor(devId, NULL, USB_DT_DEVICE); config = (UsbConfigDescriptor*)UsbGetDeviceStaticDescriptor(devId, device, USB_DT_CONFIG); interface = (UsbInterfaceDescriptor *) ((char *) config + config->bLength); /* Get first interface */ // store interface numbers dev->interfaceNumber = interface->bInterfaceNumber; dev->interfaceAlt = interface->bAlternateSetting; epCount = interface->bNumEndpoints; endpoint = (UsbEndpointDescriptor*) UsbGetDeviceStaticDescriptor(devId, NULL, USB_DT_ENDPOINT); usb_bulk_probeEndpoint(devId, dev, endpoint); for (i = 1; i < epCount; i++) { endpoint = (UsbEndpointDescriptor*) ((char *) endpoint + endpoint->bLength); usb_bulk_probeEndpoint(devId, dev, endpoint); } /* we do NOT have enough bulk endpoints */ if (dev->bulkEpI < 0 /* || dev->bulkEpO < 0 */ ) { /* the bulkOut is not needed now */ if (dev->bulkEpI >= 0) { UsbCloseEndpoint(dev->bulkEpI); } if (dev->bulkEpO >= 0) { UsbCloseEndpoint(dev->bulkEpO); } printf("USBHDFSD: Error - connect failed: not enough bulk endpoints! \n"); return -1; } /*store current configuration id - can't call set_configuration here */ dev->devId = devId; dev->configId = config->bConfigurationValue; dev->status = DEVICE_DETECTED; XPRINTF("USBHDFSD: connect ok: epI=%i, epO=%i \n", dev->bulkEpI, dev->bulkEpO); return 0; }