X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=usb%2Fcore%2Fusb.c;h=45ceba2ea51a4175010c4c774c858227717dec12;hb=34b9e07b8eafbaef3c81dd850cdaee8610efa1f1;hp=94676d3cddef0d808cf75f14aa5d9468885b3d84;hpb=6dfbb32b3c0be5f9a47fb094f378d76f53b0b4b2;p=ppcskel.git

diff --git a/usb/core/usb.c b/usb/core/usb.c
index 94676d3..45ceba2 100644
--- a/usb/core/usb.c
+++ b/usb/core/usb.c
@@ -34,6 +34,17 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+/*
+	ppcskel - a Free Software replacement for the Nintendo/BroadOn bootloader.
+	libusb like interface
+
+Copyright (C) 2009     Bernhard Urban <lewurm@gmx.net>
+Copyright (C) 2009     Sebastian Falbesoner <sebastian.falbesoner@gmail.com>
+
+# This code is licensed to you under the terms of the GNU GPL, version 2;
+# see file COPYING or http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
+*/
+
 #include "usb.h"
 #include "core.h"
 #include "../host/host.h"
@@ -41,9 +52,11 @@
 #include "../../malloc.h"
 #include "../../string.h"
 
+#define cleargbuf() memset(gbuf, 0, 0xffff)
+/* internal global buffer */
+static u8 gbuf[0xffff];
 
 /******************* Device Operations **********************/
-
 /**
  * Open a device with verndor- and product-id for a communication.
  */
@@ -99,19 +112,20 @@ s8 usb_reset(struct usb_device *dev)
 
 
 /******************* Control Transfer **********************/
-
 /**
  * Create a control transfer.
  */
 s8 usb_control_msg(struct usb_device *dev, u8 requesttype, u8 request,
 		u16 value, u16 index, u16 length, u8 *buf, u16 timeout)
 {
-	struct usb_irp *irp = (struct usb_irp*)malloc(sizeof(struct usb_irp));
-	irp->dev = dev;
-	irp->endpoint = 0;
-	
-	irp->epsize = dev->bMaxPacketSize0;
-	irp->type = USB_CTRL;
+	static struct usb_irp irp;
+	memset(&irp, 0, sizeof(struct usb_irp));
+
+	irp.dev = dev;
+	irp.endpoint = 0;
+
+	irp.epsize = dev->bMaxPacketSize0;
+	irp.type = USB_CTRL;
 
 	buf[0]=(u8)requesttype;
 	buf[1]=(u8)request;
@@ -122,134 +136,195 @@ s8 usb_control_msg(struct usb_device *dev, u8 requesttype, u8 request,
 	buf[6]=(u8)(length);
 	buf[7]=(u8)(length >> 8);
 
-	irp->buffer = buf;
-	irp->len = length;
-	irp->timeout = timeout;
+	irp.buffer = buf;
+	irp.len = length;
+	irp.timeout = timeout;
 
-	usb_submit_irp(irp);
-	free(irp);
+	usb_submit_irp(&irp);
 
 	return 0;
 }
 
+s8 usb_get_descriptor(struct usb_device *dev, u8 type, u8 index, u8 *buf, u8 size)
+{
+	usb_control_msg(dev, 0x80, GET_DESCRIPTOR, (type << 8) | index, 0, size, buf, 0);
+	return 0;
+}
 
-s8 usb_get_string(struct usb_device *dev, u8 index, u8 langid, u8 *buf, u8 buflen)
+s8 usb_get_string(struct usb_device *dev, u8 index, u8 langid)
 {
 
 	return 0;
 }
 
-
-char *usb_get_string_simple(struct usb_device *dev, u8 index, u8 *buf, u8 size)
+char *usb_get_string_simple(struct usb_device *dev, u8 index)
 {
-	if(size < 8) {
-		return (char*) -1;
-	}
-	usb_get_descriptor(dev, STRING, index, buf, (u8) 8);
-	size = size >= (buf[0]) ? (buf[0]) : size;
-	usb_get_descriptor(dev, STRING, index, buf, size);
+	cleargbuf();
+	usb_get_descriptor(dev, STRING, index, gbuf, (u8) 8);
+	usb_get_descriptor(dev, STRING, index, gbuf, gbuf[0]);
 
-	char *str = (char*)malloc((size/2));
-	memset(str, '\0', (size/2));
+	char *str = (char*)malloc((gbuf[0]/2));
+	memset(str, '\0', (gbuf[0]/2));
 
 	u16 i;
-	for(i=0; i<(size/2)-1; i++) {
-		str[i] = buf[2+(i*2)];
-		printf("%c", str[i]);
+	for(i=0; i<(gbuf[0]/2)-1; i++) {
+		str[i] = gbuf[2+(i*2)];
 	}
-	printf("\n");
 
 	return str;
 }
 
-s8 usb_get_descriptor(struct usb_device *dev, u8 type, u8 index, u8 *buf, u8 size)
-{
-	usb_control_msg(dev, 0x80, GET_DESCRIPTOR, (type << 8) | index, 0, size, buf, 0);
-	return 0;
-}
-
 /* ask first 8 bytes of device descriptor with this special 
  * GET Descriptor Request, when device address = 0
  */
-s8 usb_get_desc_dev_simple(struct usb_device *dev, u8 *buf, u8 size)
+s8 usb_get_desc_dev_simple(struct usb_device *dev)
 {
-	if(size < 8) {
-		return -1;
-	}
-	usb_get_descriptor(dev, DEVICE, 0, buf, 8);
+	cleargbuf();
+	usb_get_descriptor(dev, DEVICE, 0, gbuf, 8);
 
-	if(!buf[7]) {
-		printf("FU: %d\n", buf[7]);
+	if(!gbuf[7]) {
+		printf("FU: %d\n", gbuf[7]);
 		return -2;
 	}
-	dev->bMaxPacketSize0 = buf[7];
+	dev->bMaxPacketSize0 = gbuf[7];
 	return 0;
 }
 
-s8 usb_get_desc_dev(struct usb_device *dev, u8 *buf, u8 size)
+s8 usb_get_desc_dev(struct usb_device *dev)
 {
-	if (size < 0x12 || usb_get_desc_dev_simple(dev, buf, size) < 0) {
+	cleargbuf();
+	if (usb_get_desc_dev_simple(dev) < 0) {
 		return -1;
 	}
-	usb_get_descriptor(dev, DEVICE, 0, buf, size >= buf[0] ? buf[0] : size);
-
-	dev->bLength = buf[0];
-	dev->bDescriptorType = buf[1];
-	dev->bcdUSB = (u16) (buf[3] << 8 | buf[2]);
-	dev->bDeviceClass = buf[4];
-	dev->bDeviceSubClass = buf[5];
-	dev->bDeviceProtocoll = 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]);
-	dev->iManufacturer = buf[14];
-	dev->iProduct = buf[15];
-	dev->iSerialNumber = buf[16];
-	dev->bNumConfigurations = buf[17];
+	usb_get_descriptor(dev, DEVICE, 0, gbuf, gbuf[0]);
+
+	dev->bLength = gbuf[0];
+	dev->bDescriptorType = gbuf[1];
+	dev->bcdUSB = (u16) (gbuf[3] << 8 | gbuf[2]);
+	dev->bDeviceClass = gbuf[4];
+	dev->bDeviceSubClass = gbuf[5];
+	dev->bDeviceProtocoll = gbuf[6];
+	dev->idVendor = (u16) (gbuf[9] << 8) | (gbuf[8]);
+	dev->idProduct = (u16) (gbuf[11] << 8) | (gbuf[10]);
+	dev->bcdDevice = (u16) (gbuf[13] << 8) | (gbuf[12]);
+	dev->iManufacturer = gbuf[14];
+	dev->iProduct = gbuf[15];
+	dev->iSerialNumber = gbuf[16];
+	dev->bNumConfigurations = gbuf[17];
+
+	u8 i;
+	struct usb_conf *conf = dev->conf = (struct usb_conf*) malloc(sizeof(struct usb_conf));
+	for(i=0; i <= dev->bNumConfigurations; i++) {
+		if(i!=0) {
+			conf = (struct usb_conf*) malloc(sizeof(struct usb_conf));
+		}
+		usb_get_desc_config_ext(dev, i, conf);
+	}
 
 	return 0;
 }
 
-s8 usb_get_desc_configuration(struct usb_device *dev, u8 index, u8 *buf, u8 size)
+s8 usb_get_desc_configuration(struct usb_device *dev, u8 index, struct usb_conf *conf)
 {
-	if(size < 9) {
-		return -1;
-	}
-	usb_get_descriptor(dev, CONFIGURATION, index, buf, 8);
-	usb_get_descriptor(dev, CONFIGURATION, index, buf, size >= buf[0] ? buf[0] : size);
-
-	dev->conf->bLength = buf[0];
-	dev->conf->bDescriptorType = buf[1];
-	dev->conf->wTotalLength = (u16) (buf[3] << 8 | buf[2]);
-	dev->conf->bNumInterfaces = buf[4];
-	dev->conf->bConfigurationValue = buf[5];
-	dev->conf->iConfiguration = buf[6];
-	dev->conf->bmAttributes = buf[7];
-	dev->conf->bMaxPower = buf[8];
+	cleargbuf();
+	usb_get_descriptor(dev, CONFIGURATION, index, gbuf, 8);
+	usb_get_descriptor(dev, CONFIGURATION, index, gbuf, gbuf[0]);
+
+	conf->bLength = gbuf[0];
+	conf->bDescriptorType = gbuf[1];
+	conf->wTotalLength = (u16) (gbuf[3] << 8 | gbuf[2]);
+	conf->bNumInterfaces = gbuf[4];
+	conf->bConfigurationValue = gbuf[5];
+	conf->iConfiguration = gbuf[6];
+	conf->bmAttributes = gbuf[7];
+	conf->bMaxPower = gbuf[8];
+	conf->intf = NULL;
+
 	return 0;
 }
 
-s8 usb_get_desc_interface(struct usb_device *dev, u8 index, u8 *buf, u8 size)
+/* returns more information about CONFIGURATION, including
+ * INTERFACE(s) and ENDPOINT(s)
+ * usb_get_desc_configuration() must be called for this device before
+ */
+s8 usb_get_desc_config_ext(struct usb_device *dev, u8 index, struct usb_conf *conf)
 {
-	if(size < 9) {
-		return -1;
+	cleargbuf();
+
+	usb_get_desc_configuration(dev, index, conf);
+	usb_get_descriptor(dev, CONFIGURATION, index, gbuf, dev->conf->wTotalLength);
+
+	u8 i,j,off=9;
+	struct usb_intf *ifs = dev->conf->intf = (struct usb_intf*) malloc(sizeof(struct usb_intf));
+	for(i=1; i <= dev->conf->bNumInterfaces; i++) {
+		if(i!=1) {
+			ifs->next = (struct usb_intf*) malloc(sizeof(struct usb_intf));
+			ifs = ifs->next;
+		}
+		ifs->bLength = gbuf[off+0];
+		ifs->bDescriptorType = gbuf[off+1];
+		ifs->bInterfaceNumber = gbuf[off+2];
+		ifs->bAlternateSetting = gbuf[off+3];
+		ifs->bNumEndpoints = gbuf[off+4];
+		ifs->bInterfaceClass = gbuf[off+5];
+		ifs->bInterfaceSubClass = gbuf[off+6];
+		ifs->bInterfaceProtocol = gbuf[off+7];
+		ifs->iInterface = gbuf[off+8];
+
+		off += 9;
+
+		struct usb_endp *ep = ifs->endp = (struct usb_endp*) malloc(sizeof(struct usb_endp));
+		for(j=1; j <= ifs->bNumEndpoints; j++) {
+			/* skip HID Device Descriptor (see lsusb) */
+			if(gbuf[off+1] == 33) {
+				j--;
+				off += 9;
+				continue;
+			}
+
+			if(j!=1) {
+				ep->next = (struct usb_endp*) malloc(sizeof(struct usb_endp));
+				ep = ep->next;
+			}
+
+			ep->bLength = gbuf[off+0];
+			ep->bDescriptorType = gbuf[off+1];
+			ep->bEndpointAddress = gbuf[off+2];
+			ep->bmAttributes = gbuf[off+3];
+			ep->wMaxPacketSize = (u16) ((gbuf[off+5] << 8) | (gbuf[off+4]));
+			ep->bInterval = gbuf[off+6];
+
+			off += 7;
+		}
 	}
-	usb_get_descriptor(dev, INTERFACE, index, buf, 8);
-	usb_get_descriptor(dev, INTERFACE, index, buf, size >= buf[0] ? buf[0] : size);
-
 	return 0;
 }
 
 s8 usb_set_address(struct usb_device *dev, u8 address)
 {
-	u8 buf[64];
-	usb_control_msg(dev, 0x00, SET_ADDRESS, address, 0, 0, buf, 0);
+	cleargbuf();
+	usb_control_msg(dev, 0x00, SET_ADDRESS, address, 0, 0, gbuf, 0);
+	wait_ms(210);
 	return 0;
 }
 
-s8 usb_set_configuration(struct usb_device *dev, u8 configuration)
+
+u8 usb_get_configuration(struct usb_device *dev)
 {
+	cleargbuf();
+	usb_control_msg(dev, 0x80, GET_CONFIGURATION, 0, 0, 4, gbuf, 0);
+	printf("=============\nafter usb_get_configuration:\n");
+	hexdump((void*) gbuf, 8);
+	return gbuf[0];
+}
 
+s8 usb_set_configuration(struct usb_device *dev, u8 configuration)
+{
+	cleargbuf();
+	usb_control_msg(dev, 0x00, SET_CONFIGURATION, configuration, 0, 0, gbuf, 0);
+	printf("=============\nafter usb_set_configuration:\n");
+	hexdump((void*) gbuf, 8);
+	wait_ms(20);
 	return 0;
 }
 
@@ -259,31 +334,30 @@ s8 usb_set_altinterface(struct usb_device *dev, u8 alternate)
 	return 0;
 }
 
+static s8 usb_gen_rw(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout, u8 type) {
+	static struct usb_irp irp;
+	memset(&irp, 0, sizeof(struct usb_irp));
 
+	irp.dev = dev;
+	irp.endpoint = ep;
+	irp.epsize = dev->epSize[ep & 0x7F];
+	irp.type = type;
 
-/******************* Bulk Transfer **********************/
+	irp.buffer = buf;
+	irp.len = size;
+	irp.timeout = timeout;
+
+	usb_submit_irp(&irp);
+	return 0;
+}
 
+/******************* Bulk Transfer **********************/
 /**
  * Write to an a bulk endpoint.
  */
 s8 usb_bulk_write(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
 {
-	struct usb_irp * irp = (struct usb_irp*)malloc(sizeof(struct usb_irp));
-	irp->dev = dev;
-	//irp->devaddress = dev->address;
-	
-	irp->endpoint = ep;
-	irp->epsize = dev->epSize[ep]; // ermitteln
-	irp->type = USB_BULK;
-
-	irp->buffer = buf;
-	irp->len = size;
-	irp->timeout = timeout;
-
-	usb_submit_irp(irp);
-	free(irp);
-
-	return 0;
+	return usb_gen_rw(dev, ep, buf, size, timeout, USB_BULK);
 }
 
 /**
@@ -291,22 +365,7 @@ s8 usb_bulk_write(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
  */
 s8 usb_bulk_read(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
 {
-	struct usb_irp * irp = (struct usb_irp*)malloc(sizeof(struct usb_irp));
-	//irp->devaddress = dev->address;
-	irp->dev = dev;
-	
-	irp->endpoint = ep | 0x80;	// from device to host
-	irp->epsize = dev->epSize[ep]; // ermitteln
-	irp->type = USB_BULK;
-
-	irp->buffer = buf;
-	irp->len = size;
-	irp->timeout = timeout;
-
-	usb_submit_irp(irp);
-	free(irp);
-
-	return 0;
+	return usb_gen_rw(dev, ep|0x80, buf, size, timeout, USB_BULK);
 }
 
 
@@ -316,8 +375,7 @@ s8 usb_bulk_read(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
  */
 s8 usb_interrupt_write(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
 {
-
-	return 0;
+	return usb_gen_rw(dev, ep, buf, size, timeout, USB_INTR);
 }
 
 /**
@@ -325,8 +383,7 @@ s8 usb_interrupt_write(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeo
  */
 s8 usb_interrupt_read(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
 {
-
-	return 0;
+	return usb_gen_rw(dev, ep|0x80, buf, size, timeout, USB_INTR);
 }
 
 
@@ -351,5 +408,3 @@ s8 usb_isochron_read(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout
 	return 0;
 }
 
-
-//#endif	//_USB_H_