Restructure hub driver to stateless approach

USBHost.h

 	// Linked list of queued, not-yet-completed transfers
 	Transfer_t *next_followup;
 	Transfer_t *prev_followup;
+	Pipe_t     *pipe;
 	// Data to be used by callback function.  When a group
 	// of Transfer_t are created, these fields and the
 	// interrupt-on-complete bit in the qTD token are only
 	// set in the last Transfer_t of the list.
-	Pipe_t     *pipe;
 	void       *buffer;
 	uint32_t   length;
-	setup_t    *setup;
+	setup_t    setup;
 	USBDriver  *driver;
-	uint32_t   unused;
 };
 
 
 	static void println(unsigned long n)	{ Serial.println(n); }
 	static void println()			{ Serial.println(); }
 	static void print(uint32_t n, uint8_t b) { Serial.print(n, b); }
-	static void println(uint32_t n, uint8_t b) { Serial.print(n, b); }
+	static void println(uint32_t n, uint8_t b) { Serial.println(n, b); }
 	static void println(const char *s, int n) {
 		Serial.print(s); Serial.println(n); }
 	static void println(const char *s, unsigned int n) {
 class USBHub : public USBDriver {
 public:
 	USBHub();
+	enum { MAXPORTS = 7 };
 protected:
 	virtual bool claim(Device_t *device, int type, const uint8_t *descriptors, uint32_t len);
 	virtual void control(const Transfer_t *transfer);
 	virtual void timer_event(USBDriverTimer *whichTimer);
 	virtual void disconnect();
-	void poweron(uint32_t port);
-	void getstatus(uint32_t port);
-	void clearstatus(uint32_t port);
-	void reset(uint32_t port);
+	void send_poweron(uint32_t port);
+	void send_getstatus(uint32_t port);
+	void send_clearstatus(uint32_t port);
+	void send_reset(uint32_t port);
 	static void callback(const Transfer_t *transfer);
 	void status_change(const Transfer_t *transfer);
 	void new_port_status(uint32_t port, uint32_t status);
-	void update_status();
+
 	USBDriverTimer mytimer;
 	USBDriverTimer othertimer;
-	USBDriverTimer mytimers[7];
-	setup_t setup;
+	USBDriverTimer mytimers[MAXPORTS];
+	setup_t setup[MAXPORTS+1];
 	uint8_t hub_desc[16];
 	uint8_t endpoint;
+	uint8_t interval;
 	uint8_t numports;
 	uint8_t characteristics;
 	uint8_t powertime;
-	uint8_t state;
 	Pipe_t *changepipe;
 	uint32_t changebits;
-	uint32_t statusbits;
-	uint16_t portstatus[7];
-	uint8_t  portstate[7];
+	uint32_t statusbits[MAXPORTS+1];
+	uint16_t portstatus[MAXPORTS];
+	uint8_t  portstate[MAXPORTS];
 };
 
 class KeyboardController : public USBDriver {

ehci.cpp

 	println("new_Control_Transfer");
 	if (setup->wLength > 16384) return false; // max 16K data for control
 	transfer = allocate_Transfer();
-	if (!transfer) return false;
+	if (!transfer) {
+		println("  error allocating setup transfer");
+		return false;
+	}
 	status = allocate_Transfer();
 	if (!status) {
+		println("  error allocating status transfer");
 		free_Transfer(transfer);
 		return false;
 	}
 	if (setup->wLength > 0) {
 		data = allocate_Transfer();
 		if (!data) {
+			println("  error allocating data transfer");
 			free_Transfer(transfer);
 			free_Transfer(status);
 			return false;
 	status->pipe = dev->control_pipe;
 	status->buffer = buf;
 	status->length = setup->wLength;
-	status->setup = setup;
+	status->setup.word1 = setup->word1;
+	status->setup.word2 = setup->word2;
 	status->driver = driver;
 	status->qtd.next = 1;
 	return queue_Transfer(dev->control_pipe, transfer);
 	data->pipe = pipe;
 	data->buffer = buffer;
 	data->length = len;
-	data->setup = NULL;
+	data->setup.word1 = 0;
+	data->setup.word2 = 0;
 	data->driver = driver;
 	// initialize all qTDs
 	data = transfer;
 		} else {
 			pipe->start_mask = 0x01 << (best_offset & 7);
 		}
-		uint32_t poffset = best_offset >> 3;
-		pipe->periodic_offset = (poffset > 0) ? poffset : 1;
+		pipe->periodic_offset = best_offset >> 3;
 		pipe->complete_mask = 0;
 	} else {
 		// full speed 12 Mbit/sec or low speed 1.5 Mbit/sec

hub.cpp

 	// only claim entire device, never at interface level
 	if (type != 0) return false;
 
+	println("USBHub memory usage = ", sizeof(USBHub));
 	println("USBHub claim_device this=", (uint32_t)this, HEX);
 
 	// timer testing  TODO: remove this later
 	mytimer.init(this);
 	mytimer.pointer = (void *)"This is mytimer";
-	mytimer.start(99129);
+	//mytimer.start(99129);
 	othertimer.pointer = (void *)"Hello, I'm othertimer";
-	othertimer.start(12345);
+	//othertimer.start(12345);
 	for (int i=0; i < 7; i++) {
 		mytimers[i].init(this);
 		//mytimers[i].start((i + 1) * 10000);
 	uint32_t maxsize = descriptors[13] | (descriptors[14] << 8);
 	if (maxsize == 0) return false;
 	if (maxsize > 1) return false; // do hub chips with > 7 ports exist?
-
+	interval = descriptors[15];
+	println("  polling interval = ", interval);
 	println(descriptors[9]);
 	println(descriptors[10]);
 	println(descriptors[11], HEX);
 	println("bDeviceSubClass = ", dev->bDeviceSubClass);
 	println("bDeviceProtocol = ", dev->bDeviceProtocol);
 
+	numports = 0; // unknown until hub descriptor is read
 	changepipe = NULL;
 	changebits = 0;
-	state = 0;
 	memset(portstatus, 0, sizeof(portstatus));
 	memset(portstate, 0, sizeof(portstate));
 
-	mk_setup(setup, 0xA0, 6, 0x2900, 0, sizeof(hub_desc));
-	queue_Control_Transfer(dev, &setup, hub_desc, this);
+	mk_setup(setup[0], 0xA0, 6, 0x2900, 0, sizeof(hub_desc));
+	queue_Control_Transfer(dev, &setup[0], hub_desc, this);
 
 	return true;
 }
 }
 
 
-void USBHub::poweron(uint32_t port)
+void USBHub::send_poweron(uint32_t port)
 {
-	mk_setup(setup, 0x23, 3, 8, port, 0);
-	queue_Control_Transfer(device, &setup, NULL, this);
+	if (port == 0 || port > numports) return;
+	mk_setup(setup[port], 0x23, 3, 8, port, 0);
+	queue_Control_Transfer(device, &setup[port], NULL, this);
 }
 
-void USBHub::getstatus(uint32_t port)
+void USBHub::send_getstatus(uint32_t port)
 {
-	if (port == 0) {
-		mk_setup(setup, 0xA0, 0, 0, port, 4); // get hub status
-	} else {
-		mk_setup(setup, 0xA3, 0, 0, port, 4); // get port status
-	}
-	queue_Control_Transfer(device, &setup, &statusbits, this);
+	if (port > numports) return;
+	println("getstatus, port = ", port);
+	mk_setup(setup[port], ((port > 0) ? 0xA3 : 0xA0), 0, 0, port, 4);
+	queue_Control_Transfer(device, &setup[port], &statusbits[port], this);
 }
 
-void USBHub::clearstatus(uint32_t port)
+void USBHub::send_clearstatus(uint32_t port)
 {
-	if (port == 0) {
-		mk_setup(setup, 0x20, 1, 0x10, port, 0); // clear hub status
-	} else {
-		mk_setup(setup, 0x23, 1, 0x10, port, 0); // clear port status
-	}
-	queue_Control_Transfer(device, &setup, NULL, this);
+	if (port > numports) return;
+	mk_setup(setup[port], ((port > 0) ? 0x23 : 0x20), 1, 0x10, port, 0);
+	queue_Control_Transfer(device, &setup[port], NULL, this);
 }
 
-void USBHub::reset(uint32_t port)
+void USBHub::send_reset(uint32_t port)
 {
-	mk_setup(setup, 0x23, 3, 4, port, 0); // set feature PORT_RESET
-	queue_Control_Transfer(device, &setup, NULL, this);
+	if (port == 0 || port > numports) return;
+	mk_setup(setup[port], 0x23, 3, 4, port, 0); // set feature PORT_RESET
+	queue_Control_Transfer(device, &setup[port], NULL, this);
 }
 
 
 	println("USBHub control callback");
 	print_hexbytes(transfer->buffer, transfer->length);
 
-	if (state == 0) {
-		// read hub descriptor to learn hub's capabilities
-		// Hub Descriptor, USB 2.0, 11.23.2.1 page 417
-		if (hub_desc[0] == 9 && hub_desc[1] == 0x29) {
-			numports = hub_desc[2];
-			characteristics = hub_desc[3];
-			powertime = hub_desc[5];
-			// TODO: do we need to use the DeviceRemovable
-			// bits to mke synthetic device connect events?
-			print("Hub has ");
-			print(numports);
-			println(" ports");
-			state = 1;
-			poweron(1);
+	uint32_t port = transfer->setup.wIndex;
+	uint32_t mesg = transfer->setup.word1;
+
+	switch (mesg) {
+	  case 0x290006A0: // read hub descriptor
+		numports = hub_desc[2];
+		characteristics = hub_desc[3];
+		powertime = hub_desc[5];
+		// TODO: do we need to use the DeviceRemovable
+		// bits to make synthetic device connect events?
+		println("Hub ports = ", numports);
+		for (uint32_t i=1; i <= numports; i++) {
+			send_poweron(i);
 		}
-	} else if (state < numports) {
-		// turn on power to all ports
-		poweron(++state);
-	} else if (state == numports) {
-		println("power turned on to all ports");
-		println("device addr = ", device->address);
-		// TODO: use hub's interrupt endpoint interval
-		changepipe = new_Pipe(device, 3, endpoint, 1, 1, 64);
-		println("pipe cap1 = ", changepipe->qh.capabilities[0], HEX);
-		changepipe->callback_function = callback;
-		queue_Data_Transfer(changepipe, &changebits, 1, this);
-		state = 255;
-	} else if (state == 255) {
-		// up and running...
-		switch (setup.word1) {
-		  case 0x000000A0: // get hub status
-			println("New Hub Status");
-			clearstatus(0);
-			return;
-		  case 0x000000A3: // get port status
-			new_port_status(setup.wIndex, statusbits);
-			clearstatus(setup.wIndex);
-			return;
-		  case 0x00100120: // clear hub status
-			println("Hub Status Cleared");
-			changebits &= ~1;
-			break;
-		  case 0x00100123: // clear port status
-			println("Port Status Cleared, port=", setup.wIndex);
-			changebits &= ~(1 << setup.wIndex);
-			break;
+		break;
+	  case 0x00080323: // power turned on
+		if (port == numports && changepipe == NULL) {
+			println("power turned on to all ports");
+			println("device addr = ", device->address);
+			changepipe = new_Pipe(device, 3, endpoint, 1, 1, interval);
+			println("pipe cap1 = ", changepipe->qh.capabilities[0], HEX);
+			changepipe->callback_function = callback;
+			queue_Data_Transfer(changepipe, &changebits, 1, this);
 		}
-		update_status();
+		break;
+
+	  case 0x000000A0: // get hub status
+		println("New Hub Status");
+		send_clearstatus(0);
+		break;
+	  case 0x000000A3: // get port status
+		println("New Port Status");
+		if (transfer->length == 4) {
+			uint32_t status = *(uint32_t *)(transfer->buffer);
+			if (status != statusbits[port]) println("ERROR: status not same");
+			new_port_status(port, status);
+		}
+		send_clearstatus(port);
+		break;
+	  case 0x00100120: // clear hub status
+		println("Hub Status Cleared");
+		break;
+	  case 0x00100123: // clear port status
+		println("Port Status Cleared, port=", port);
+		break;
+	  default:
+		println("unhandled setup, message = ", mesg, HEX);
 	}
 }
 
 void USBHub::callback(const Transfer_t *transfer)
 {
-	println("HUB Callback (static)");
+	//println("HUB Callback (static)");
 	if (transfer->driver) ((USBHub *)(transfer->driver))->status_change(transfer);
 }
 
 {
 	println("HUB Callback (member)");
 	println("status = ", changebits, HEX);
-	// TODO: do something with the status change info
-	update_status();
-	queue_Data_Transfer(changepipe, &changebits, 1, this);
-}
-
-void USBHub::update_status()
-{
-	uint32_t i, mask;
-
-	for (i=0, mask=1; i <= numports; i++, mask <<= 1) {
-		if (changebits & mask) {
-			getstatus(i);
-			return;
+	for (uint32_t i=0; i <= numports; i++) {
+		if (changebits & (1 << i)) {
+			send_getstatus(i);
 		}
 	}
+	queue_Data_Transfer(changepipe, &changebits, 1, this);
 }
 
 void USBHub::new_port_status(uint32_t port, uint32_t status)
 {
-	if (port < 1 || port > 7) return;
+	if (port == 0 || port > numports) return;
 	uint32_t priorstatus = portstatus[port - 1];
 	portstatus[port] = status;
 
-	print("New Port Status, port=");
+	print("  Status: port=");
 	print(port);
 	print(", status=");
 	println(status, HEX);
 	if ((status & 0x0001) && !(priorstatus & 0x0001)) {
 		println("    connect");
 		// 100 ms debounce (USB 2.0: TATTDB, page 150 & 188)
-		delay(100);  // TODO: horribly bad... need timing events
-		reset(port);
+		//delay(100);  // TODO: horribly bad... need timing events
+		//reset(port);
 		// TODO... reset timer?
 
 	} else if (!(status & 0x0001) && (priorstatus & 0x0001)) {

memory.cpp

 // Memory allocation
 
 static Device_t memory_Device[3];
-static Pipe_t memory_Pipe[6] __attribute__ ((aligned(64)));
-static Transfer_t memory_Transfer[24] __attribute__ ((aligned(64)));
+static Pipe_t memory_Pipe[8] __attribute__ ((aligned(32)));
+static Transfer_t memory_Transfer[34] __attribute__ ((aligned(32)));
 
 static Device_t * free_Device_list = NULL;
 static Pipe_t * free_Pipe_list = NULL;