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;
}
