X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=usb%2Fcore%2Fcore.c;h=c3574283e0610562cfc13bf7b26d61aad61e8d0a;hb=e8dd6b27d501339472cb5c8e0c94f3d2484e7810;hp=95b8091e4a175849857bd6dd7118530c60c6d08e;hpb=d1cba441ac7e5fe718de986a3404085cecdc2e1a;p=ppcskel.git

diff --git a/usb/core/core.c b/usb/core/core.c
index 95b8091..c357428 100644
--- a/usb/core/core.c
+++ b/usb/core/core.c
@@ -71,10 +71,10 @@ u8 usb_next_address()
 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;
 	}
@@ -86,11 +86,13 @@ void usb_periodic()
  * 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;
-	dev->bMaxPacketSize0 = 8; 	/* send at first time only 8 bytes */
+	/* send at first time only 8 bytes */
+	dev->bMaxPacketSize0 = 8;
 
 	dev->epSize[0] = 64;
 	dev->epSize[1] = 64;
@@ -100,78 +102,28 @@ usb_device *usb_add_device()
 	dev->epTogl[1] = 0;
 	dev->epTogl[2] = 0;
 
-	char buf[64];
-	memset(buf, 0, sizeof(buf));
-
-	/* ask first 8 bytes of device descriptor with this special 
-	 * GET Descriptor Request, when device address = 0
-	 */
-
-	/*
-	 * see page 253 in usb_20.pdf
-	 * 
-	 * bmRequestType = 0x80 = 10000000B
-	 * bRequest = GET_DESCRIPTOR
-	 * wValue = DEVICE (Descriptor Type)
-	 * wIndex = 0
-	 * wLength = 8 (in Bytes!?)
-	 */
-	usb_control_msg(dev, 0x80, GET_DESCRIPTOR, DEVICE << 8, 0, 64, buf, 8, 0);
-	//usb_control_msg(dev, 0x80, GET_DESCRIPTOR, DEVICE, 0, 64, buf, 8, 0);
+	s8 ret;
+	ret = usb_get_desc_dev_simple(dev);
+	if(ret < 0) {
+		return (void*) -1;
+	}
 
-	/* 
-	 * length (here =64) should be "number of byte to transfer", not 
-	 * (as here) "number of bits to transfer.
-	 * ?
-	 */
-	//usb_control_msg(dev, 0x80, GET_DESCRIPTOR, 1, 0, 64, buf, 8, 0);
-	printf("===========\nafter usb control msg:\n");
-	hexdump(buf, sizeof(buf));
+	/* set MaxPacketSize */
 
-#if 0
-	u8 devdescr_size;
 	u8 address = usb_next_address();
-	dev->bMaxPacketSize0 = (u8) buf[7] ? (u8) buf[7] : 1; //dirty?	/* setup real ep0 fifo size */
-	devdescr_size = (u8) buf[0];	/* save real length of device descriptor */
-
-	/* define new adress */
-	usb_control_msg(dev, 0x00, SET_ADDRESS, address << 8, 0, 0, buf, 8, 0);
+	ret = usb_set_address(dev, address);
 	dev->address = address;
+	printf("set address to %d\n", dev->address);
 
-	/* get complete device descriptor */
-	usb_control_msg(dev, 0x80, GET_DESCRIPTOR, 1, 0, devdescr_size, buf, 8,
-									0);
-
-	/* save only really neccessary values for this small usbstack */
-	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"
-			"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);
-	/* for lewurms keyboard it should be:
-	 * bDeviceClass			0
-	 * bDeviceSubClass		0
-	 * bDeviceClass			0
-	 * idVendor						0x049f
-	 * idProduct					0x000e
-	 * bcdDevice						1.00
-	 */
+	ret = usb_get_desc_dev(dev);
 
+	/* select configuration */
+	ret = usb_set_configuration(dev, dev->conf->bConfigurationValue);
+	printf("=============\nusb_set_configuration(ret: %d) %d\n", ret, dev->conf->bConfigurationValue);
 
-	// string descriptoren werden nicht im arbeitsspeicher gehalten -> on demand mit 
-	// entprechenden funktionen
-	// hier muss man noch mehr abholen, konfigurationene, interfaces und endpunkte
+	lsusb(dev);
 
+#if 0
 	/* add device to device list */
 	element *tmp = (element *) malloc(sizeof(element));
 	tmp->data = (void *) dev;
@@ -183,11 +135,74 @@ usb_device *usb_add_device()
 	return dev;
 }
 
+void lsusb(struct usb_device *dev)
+{
+	printf("=== Device Descriptor === \n");
+	printf("bLength 0x%02X\n", dev->bLength);
+	printf("bDescriptorType 0x%02X\n", dev->bDeviceClass);
+	printf("bcdUSB 0x%02X\n", dev->bcdUSB);
+	printf("bDeviceClass 0x%02X\n", dev->bDeviceClass);
+	printf("bDeviceSubClass 0x%02X\n", dev->bDeviceSubClass);
+	printf("bDeviceProtocoll 0x%02X\n", dev->bDeviceProtocoll);
+	printf("idVendor 0x%04X\n", dev->idVendor);
+	printf("idProduct 0x%04X\n", dev->idProduct);
+	printf("bcdDevice 0x%04X\n", dev->bcdDevice);
+	printf("iManufacturer(0x%02X): \"%s\"\n", dev->iManufacturer, dev->iManufacturer ? usb_get_string_simple(dev, dev->iManufacturer) : "no String");
+	printf("iProduct(0x%02X): \"%s\"\n", dev->iProduct, dev->iProduct ? usb_get_string_simple(dev, dev->iProduct) : "no String");
+	printf("iSerialNumber(0x%02X): \"%s\"\n", dev->iSerialNumber, dev->iSerialNumber ? usb_get_string_simple(dev, dev->iSerialNumber) : "no String");
+	printf("bNumConfigurations 0x%02X\n", dev->bNumConfigurations);
+	
+	u8 c, i, e;
+	struct usb_conf *conf = dev->conf;
+	for(c=0; c <= dev->bNumConfigurations; c++) {
+		printf("  === Configuration Descriptor %d ===\n", c+1);
+		printf("  bLength 0x%02X\n", conf->bLength);
+		printf("  bDescriptorType 0x%02X\n", conf->bDescriptorType);
+		printf("  wTotalLength 0x%04X\n", conf->wTotalLength);
+		printf("  bNumInterfaces 0x%02X\n", conf->bNumInterfaces);
+		printf("  bConfigurationValue 0x%02X\n", conf->bConfigurationValue);
+		printf("  iConfiguration (0x%02X): \"%s\"\n", conf->iConfiguration, conf->iConfiguration ? usb_get_string_simple(dev, conf->iConfiguration) : "no String");
+		printf("  bmAttributes 0x%02X\n", conf->bmAttributes);
+		printf("  bMaxPower 0x%02X\n", conf->bMaxPower);
+
+		struct usb_intf *ifs = conf->intf;
+		for(i=1; i <= conf->bNumInterfaces; i++) {
+			printf("    === Interface Descriptor %d ===\n", i);
+			printf("    bLength 0x%02X\n", ifs->bLength);
+			printf("    bDescriptorType 0x%02X\n", ifs->bDescriptorType);
+			printf("    bInterfaceNumber 0x%02X\n", ifs->bInterfaceNumber);
+			printf("    bAlternateSetting 0x%02X\n", ifs->bAlternateSetting);
+			printf("    bNumEndpoints 0x%02X\n", ifs->bNumEndpoints);
+			printf("    bInterfaceClass 0x%02X\n", ifs->bInterfaceClass);
+			printf("    bInterfaceSubClass 0x%02X\n", ifs->bInterfaceSubClass);
+			printf("    bInterfaceProtocol 0x%02X\n", ifs->bInterfaceProtocol);
+			printf("    iInterface (0x%02X): \"%s\"\n", ifs->iInterface, ifs->iInterface ? usb_get_string_simple(dev, ifs->iInterface) : "no String");
+
+			struct usb_endp *ed = ifs->endp;
+			for(e=1; e <= ifs->bNumEndpoints; e++) {
+				printf("      === Endpoint Descriptor %d ===\n", e);
+				printf("      bLength 0x%02X\n", ed->bLength);
+				printf("      bDescriptorType 0x%02X\n", ed->bDescriptorType);
+				printf("      bEndpointAddress 0x%02X\n", ed->bEndpointAddress);
+				printf("      bmAttributes 0x%02X\n", ed->bmAttributes);
+				printf("      wMaxPacketSize 0x%02X\n", ed->wMaxPacketSize);
+				printf("      bInterval 0x%02X\n", ed->bInterval);
+
+				ed = ed->next;
+			} //endpoint
+			
+			ifs = ifs->next;
+		} //interface
+
+		conf = conf->next;
+	} //configuration
+}
+
 /**
  * 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);
@@ -199,10 +214,10 @@ u8 usb_remove_device(usb_device * dev)
 /**
  * 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);
@@ -226,10 +241,10 @@ u8 usb_register_driver(usb_driver * dev)
 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;
 	}
@@ -238,7 +253,7 @@ void usb_probe_driver()
 /**
  * Not implemented.
  */
-usb_irp *usb_get_irp()
+struct usb_irp *usb_get_irp()
 {
 	return 0;
 }
@@ -246,7 +261,7 @@ usb_irp *usb_get_irp()
 /**
  * Not implemented.
  */
-u8 usb_remove_irp(usb_irp * irp)
+u8 usb_remove_irp(struct usb_irp *irp)
 {
 
 	return 1;
@@ -258,21 +273,18 @@ u8 usb_remove_irp(usb_irp * irp)
  * 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;
-	char *td_buf_ptr = irp->buffer;
-	char mybuf[64];
+	u8 *td_buf_ptr = irp->buffer;
+	u8 mybuf[64];
 
-	//u8 togl=irp->dev->epTogl[(irp->endpoint & 0x7F)];
 	u8 togl = irp->dev->epTogl[(irp->endpoint & 0x7F)];
-	//u8 togl=0;
 
 	switch (irp->type) {
 	case USB_CTRL:
-
 		/* alle requests mit dem gleichen algorithmus zerteilen
 		 * das einzige ist der spezielle get_Device_descriptor request
 		 * bei dem eine laenge von 64 angegeben ist.
@@ -280,119 +292,110 @@ u16 usb_submit_irp(usb_irp *irp)
 		 * dann reichen die ersten 8 byte.
 		 */
 
-			/***************** Setup Stage ***********************/
+		/***************** Setup Stage ***********************/
 		td = usb_create_transfer_descriptor(irp);
 		td->pid = USB_PID_SETUP;
 		td->buffer = irp->buffer;
 
 		/* control message are always 8 bytes */
 		td->actlen = 8;
-		memcpy(mybuf, td->buffer, td->actlen);
 
 		togl = 0;
-		td->togl = togl;						/* start with data0 */
-		if (togl == 0)
-			togl = 1;
-		else
-			togl = 0;
-			/**** send token ****/
-		printf("togl: %d\n", togl);
+		/* start with data0 */
+		td->togl = togl;
+		togl = togl ? 0 : 1;
+
+		/**** send token ****/
 		hcdi_enqueue(td);
-#if 0
-		break;
-		memcpy(td->buffer, mybuf, td->actlen);
-#endif
 
-			/***************** Data Stage ***********************/
-			/**
-			 * You can see at bit 7 of bmRequestType if this stage is used,
-			 * default requests are always 8 byte greate, from
-			 * host to device. Stage 3 is only neccessary if the request
-			 * expected datas from the device.
-			 * bit7 - 1 = from device to host -> yes we need data stage
-			 * bit7 - 0 = from host to device -> no send zero packet
-			 *
-			 * nach einem setup token kann nur ein IN token in stage 3 folgen
-			 * nie aber ein OUT. Ein Zero OUT wird nur als Bestaetigung benoetigt.
-			 *
-			 *
-			 * bit7 = 1
-			 *	Device to Host
-			 *	- es kommen noch Daten mit PID_IN an
-			 *	- host beendet mit PID_OUT DATA1 Zero
-			 * bit7 - 0
-			 *	Host zu Device (wie set address)
-			 *	- device sendet ein PID_IN DATA1 Zero Packet als bestaetigung
-			 */
-		usb_device_request *setup = (usb_device_request *) irp->buffer;
+		/***************** Data Stage ***********************/
+		/**
+		 * You can see at bit 7 of bmRequestType if this stage is used,
+		 * default requests are always 8 byte greate, from
+		 * host to device. Stage 3 is only neccessary if the request
+		 * expected datas from the device.
+		 * bit7 - 1 = from device to host -> yes we need data stage
+		 * bit7 - 0 = from host to device -> no send zero packet
+		 *
+		 * nach einem setup token kann nur ein IN token in stage 3 folgen
+		 * nie aber ein OUT. Ein Zero OUT wird nur als Bestaetigung benoetigt.
+		 *
+		 *
+		 * bit7 = 1
+		 *	Device to Host
+		 *	- es kommen noch Daten mit PID_IN an
+		 *	- host beendet mit PID_OUT DATA1 Zero
+		 * bit7 - 0
+		 *	Host zu Device (wie set address)
+		 *	- device sendet ein PID_IN DATA1 Zero Packet als bestaetigung
+		 */
+		memcpy(mybuf, irp->buffer, td->actlen);
+		usb_device_request *setup = (usb_device_request *) mybuf;
 		u8 bmRequestType = setup->bmRequestType;
+		free(td);
 
-		if (bmRequestType & 0x80) { /* check bit 7 of bmRequestType */
-
+		/* check bit 7 of bmRequestType */
+		if (bmRequestType & 0x80) { 
 			/* schleife die die tds generiert */
-			while (runloop) {
+			while (runloop && (restlength > 0)) {
 				td = usb_create_transfer_descriptor(irp);
 				td->actlen = irp->epsize;
 				/* stop loop if all bytes are send */
-				if (restlength <= irp->epsize) {
+				if (restlength < irp->epsize) {
 					runloop = 0;
 					td->actlen = restlength;
 				}
 
 				td->buffer = td_buf_ptr;
 				/* move pointer for next packet */
-				td_buf_ptr = td_buf_ptr + irp->epsize;
+				td_buf_ptr += irp->epsize;
 
 				td->pid = USB_PID_IN;
 				td->togl = togl;
-				if (togl == 0)
-					togl = 1;
-				else
-					togl = 0;
+				togl = togl ? 0 : 1;
 
 				/* wenn device descriptor von adresse 0 angefragt wird werden nur
 				 * die ersten 8 byte abgefragt
 				 */
-				if (setup->bRequest == GET_DESCRIPTOR && (setup->wValue >> 8) == 1
+				if (setup->bRequest == GET_DESCRIPTOR && (setup->wValue & 0xff) == 1
 						&& td->devaddress == 0) {
-					runloop = 0;					/* stop loop */
+					/* stop loop */
+					runloop = 0;
 				}
 
-					/**** send token ****/
-				printf("togl: %d\n", togl);
+				/**** send token ****/
 				hcdi_enqueue(td);
 
 				/* pruefe ob noch weitere Pakete vom Device abgeholt werden muessen */
 				restlength = restlength - irp->epsize;
+				free(td);
 			}
 		}
 
 
-			/***************** Status Stage ***********************/
+		/***************** Status Stage ***********************/
 		/* Zero packet for end */
 		td = usb_create_transfer_descriptor(irp);
 		td->togl = 1;								/* zero data packet = always DATA1 packet */
 		td->actlen = 0;
 		td->buffer = NULL;
 
-			/**
-			 * bit7 = 1, host beendet mit PID_OUT DATA1 Zero
-			 * bit7 = 0, device sendet ein PID_IN DATA1 Zero Packet als bestaetigung
-			 */
-		if (bmRequestType & 0x80) { /* check bit 7 of bmRequestType */
+		/**
+		 * bit7 = 1, host beendet mit PID_OUT DATA1 Zero
+		 * bit7 = 0, device sendet ein PID_IN DATA1 Zero Packet als bestaetigung
+		 */
+		/* check bit 7 of bmRequestType */
+		if (bmRequestType & 0x80) {
 			td->pid = USB_PID_OUT;
 		} else {
 			td->pid = USB_PID_IN;
 		}
-			/**** send token ****/
-		printf("togl: %d\n", togl);
+		/**** send token ****/
 		hcdi_enqueue(td);
 		free(td);
-
-
 		break;
-	case USB_BULK:
 
+	case USB_BULK:
 		core.stdout("bulk\r\n");
 		//u8 runloop=1;
 		//u16 restlength = irp->len;
@@ -430,7 +433,6 @@ u16 usb_submit_irp(usb_irp *irp)
 			else
 				togl = 0;
 				/**** send token ****/
-			printf("togl: %d\n", togl);
 			hcdi_enqueue(td);
 			free(td);
 		}
@@ -442,6 +444,7 @@ u16 usb_submit_irp(usb_irp *irp)
 
 		break;
 	}
+	hcdi_fire();
 
 	return 1;
 }
@@ -451,10 +454,10 @@ u16 usb_submit_irp(usb_irp *irp)
 /** 
  * 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;