void usb_periodic()
{
// call ever registered driver
- usb_driver *drv;
- element *iterator = core.drivers->head;
+ struct usb_driver *drv;
+ struct element *iterator = core.drivers->head;
while (iterator != NULL) {
- drv = (usb_driver *) iterator->data;
+ drv = (struct usb_driver *) iterator->data;
drv->check();
iterator = iterator->next;
}
* for the core. usb_add_device expected that
* the device answers to address zero.
*/
-usb_device *usb_add_device()
+struct usb_device *usb_add_device()
{
- usb_device *dev = (usb_device *) malloc(sizeof(usb_device));
+ struct usb_device *dev = (struct usb_device *) malloc(sizeof(struct usb_device));
+ dev->conf = (struct usb_conf *) malloc(sizeof(struct usb_conf));
dev->address = 0;
/* send at first time only 8 bytes */
dev->bMaxPacketSize0 = 8;
memset(buf, 0, sizeof(buf));
s8 ret;
- u8 dev_desc_size;
memset(buf, 0, sizeof(buf));
- ret = usb_get_dev_desc_simple(dev, buf, sizeof(buf));
- printf("=============\nbuf: 0x%08X\nafter usb control msg(ret: %d):\n", buf, ret);
+ ret = usb_get_desc_dev_simple(dev, buf, sizeof(buf));
+#ifdef _DU_CORE_ADD
+ printf("=============\nbuf: 0x%08X\nafter usb_get_dev_desc_simple(ret: %d):\n", buf, ret);
hexdump(buf, sizeof(buf));
+#endif
+ if(ret < 0) {
+ return (void*) -1;
+ }
/* set MaxPacketSize */
- dev->bMaxPacketSize0 = (u8) buf[7];
- if(!(u8)buf[7]) {
- printf("FU\n");
- return (void*)1;
- }
- /* save device descriptor size */
- dev_desc_size = buf[0];
u8 address = usb_next_address();
ret = usb_set_address(dev, address);
dev->address = address;
+#ifdef _DU_CORE_ADD
printf("set address to %d\n", dev->address);
+#endif
memset(buf, 0, sizeof(buf));
- ret = usb_get_dev_desc(dev, buf, sizeof(buf), dev_desc_size);
- printf("=============\nbuf: 0x%08X\nafter usb control msg(ret: %d):\n", buf, ret);
+ ret = usb_get_desc_dev(dev, buf, sizeof(buf));
+#ifdef _DU_CORE_ADD
+ printf("=============\nbuf: 0x%08X\nafter usb_get_dev_desc(ret: %d):\n", buf, ret);
hexdump(buf, sizeof(buf));
+#endif
+
+ char *man, *prod, *serial;
+ if(dev->iManufacturer) {
+ memset(buf, 0, sizeof(buf));
+ man = usb_get_string_simple(dev, dev->iManufacturer, buf, sizeof(buf));
+ } else {
+ man = (char*) malloc(11);
+ memset(man, '\0', sizeof(man));
+ strlcpy(man, "no String", 10);
+ }
+ if(dev->iProduct) {
+ memset(buf, 0, sizeof(buf));
+ prod = usb_get_string_simple(dev, dev->iProduct, buf, sizeof(buf));
+ } else {
+ prod = (char*) malloc(11);
+ memset(prod, '\0', sizeof(prod));
+ strlcpy(prod, "no String", 10);
+ }
+ if(dev->iSerialNumber) {
+ memset(buf, 0, sizeof(buf));
+ serial = usb_get_string_simple(dev, dev->iSerialNumber, buf, sizeof(buf));
+ } else {
+ serial = (char*) malloc(11);
+ memset(serial, '\0', sizeof(serial));
+ strlcpy(serial, "no String", 10);
+ }
- dev->bDeviceClass = (u8) buf[4];
- dev->bDeviceSubClass = (u8) buf[5];
- dev->bDeviceProtocoll = (u8) buf[6];
- dev->idVendor = (u16) (buf[9] << 8) | (buf[8]);
- dev->idProduct = (u16) (buf[11] << 8) | (buf[10]);
- dev->bcdDevice = (u16) (buf[13] << 8) | (buf[12]);
- printf( "bDeviceClass 0x%02X\n"
+ printf( "bLength 0x%02X\n"
+ "bDescriptorType 0x%02X\n"
+ "bcdUSB 0x%02X\n"
+ "bDeviceClass 0x%02X\n"
"bDeviceSubClass 0x%02X\n"
"bDeviceProtocoll 0x%02X\n"
"idVendor 0x%04X\n"
"idProduct 0x%04X\n"
- "bcdDevice 0x%04X\n", dev->bDeviceClass,
- dev->bDeviceSubClass, dev->bDeviceProtocoll,
- dev->idVendor, dev->idProduct, dev->bcdDevice);
+ "bcdDevice 0x%04X\n"
+ "iManufacturer(0x%02X): \"%s\"\n"
+ "iProduct(0x%02X): \"%s\"\n"
+ "iSerialNumber(0x%02X): \"%s\"\n"
+ "bNumConfigurations 0x%02X\n", dev->bLength, dev->bDeviceClass,
+ dev->bcdUSB, dev->bDescriptorType, dev->bDeviceSubClass,
+ dev->bDeviceProtocoll, dev->idVendor, dev->idProduct, dev->bcdDevice,
+ dev->iManufacturer, man,
+ dev->iProduct, prod,
+ dev->iSerialNumber, serial,
+ dev->bNumConfigurations);
+
+ memset(buf, 0, sizeof(buf));
+ /* in the most cases usb devices have just one configuration descriptor */
+ ret = usb_get_desc_configuration(dev, 0, buf, sizeof(buf));
+ printf("=============\nbuf: 0x%08X\nafter usb_get_desc_configuration(ret: %d):\n", buf, ret);
+ hexdump(buf, sizeof(buf));
+
+ printf("interfaces: %d\n", dev->conf->bNumInterfaces);
+ u8 i;
+ for(i = 1; i <= dev->conf->bNumInterfaces; i++) {
+ memset(buf, 0, sizeof(buf));
+ ret = usb_get_desc_interface(dev, i, buf, sizeof(buf));
+ printf("=============\nbuf: 0x%08X\nafter usb_get_desc_interface_%d(ret: %d):\n", buf, i, ret);
+ hexdump(buf, sizeof(buf));
+ }
+
+
/*
usb_get_descriptor(dev, DEVICE, 0, buf, 8);
* Find currently detached device and remove
* data structures
*/
-u8 usb_remove_device(usb_device * dev)
+u8 usb_remove_device(struct usb_device * dev)
{
// FIXME!!!! dieser quatsch ist nur temporaer
free(core.devices->head);
/**
* Register new driver at usb stack.
*/
-u8 usb_register_driver(usb_driver * dev)
+u8 usb_register_driver(struct usb_driver * dev)
{
/* add driver to driver list */
- element *tmp = (element *) malloc(sizeof(element));
+ struct element *tmp = (struct element *) malloc(sizeof(struct element));
tmp->data = (void *) dev;
tmp->next = NULL;
list_add_tail(core.drivers, tmp);
void usb_probe_driver()
{
// call ever registered driver
- usb_driver *drv;
- element *iterator = core.drivers->head;
+ struct usb_driver *drv;
+ struct element *iterator = core.drivers->head;
while (iterator != NULL) {
- drv = (usb_driver *) iterator->data;
+ drv = (struct usb_driver *) iterator->data;
drv->probe();
iterator = iterator->next;
}
/**
* Not implemented.
*/
-usb_irp *usb_get_irp()
+struct usb_irp *usb_get_irp()
{
return 0;
}
/**
* Not implemented.
*/
-u8 usb_remove_irp(usb_irp * irp)
+u8 usb_remove_irp(struct usb_irp *irp)
{
return 1;
* In the usbstack they are transported with the
* usb_transfer_descriptor data structure.
*/
-u16 usb_submit_irp(usb_irp *irp)
+u16 usb_submit_irp(struct usb_irp *irp)
{
- usb_transfer_descriptor *td;
+ struct usb_transfer_descriptor *td;
u8 runloop = 1;
u16 restlength = irp->len;
u8 *td_buf_ptr = irp->buffer;
if (bmRequestType & 0x80) {
/* schleife die die tds generiert */
while (runloop && (restlength > 0)) {
- printf("restlength: %d\t irp->epsize: %d\n", restlength, irp->epsize);
td = usb_create_transfer_descriptor(irp);
td->actlen = irp->epsize;
/* stop loop if all bytes are send */
/**
* Create a transfer descriptor with an parent irp.
*/
-usb_transfer_descriptor *usb_create_transfer_descriptor(usb_irp * irp)
+struct usb_transfer_descriptor *usb_create_transfer_descriptor(struct usb_irp * irp)
{
- usb_transfer_descriptor *td =
- (usb_transfer_descriptor *) malloc(sizeof(usb_transfer_descriptor));
+ struct usb_transfer_descriptor *td =
+ (struct usb_transfer_descriptor *) malloc(sizeof(struct usb_transfer_descriptor));
td->devaddress = irp->dev->address;
td->endpoint = irp->endpoint;
projects / ppcskel.git / blobdiff