udc.patch

patches for linux-2.6.

+
+		CHECK_STATE (otg, OTG_STATE_A_WAIT_VFALL, pEvt_mask);
+
+		if (IS_BIT_RES (OTG_STS_SESSEND, uoc_status)) {
+
+			/* VBus on => no state change                        */
+			/*            Discharge VBus                         */
+			/* TODO kboge: need a time-out here                  */
+
+			if (OTG_STATE_A_WAIT_VFALL_DN !=
+			    otg->transceiver.state) {
+				CHANGE_STATE (otg, OTG_STATE_A_WAIT_VFALL_DN,
+				              pEvt_mask);
+			}
+
+		}
+		else {
+
+			/* Session end => A_IDLE (=> B_IDLE)                 */
+			/*                Set state                          */
+
+			RES_EVENT ((OTG_INT_IDC | OTG_INT_PCC), event_code);
+			CHANGE_STATE (otg, OTG_STATE_A_IDLE, pEvt_mask);
+
+		}
+		break;
+
+	case OTG_STATE_A_VBUS_ERR :
+
+		/* A_VBUS_ERR: VBus valid was de-asserted                    */
+		/*             no VBus, no connect, no activity              */
+
+		CHECK_STATE (otg, OTG_STATE_A_VBUS_ERR, pEvt_mask);
+		SET_FLAG (otg, OTG_A_VBUS_FAILED);
+
+		if (IS_BIT_SET (OTG_STS_ID, uoc_status) ||
+		    IS_FLAG_SET (otg, OTG_A_BUS_DROP | OTG_A_CLR_ERR)) {
+
+			/* Set state                                         */
+
+			RES_EVENT (OTG_INT_IDC, event_code);
+			RES_FLAG (otg, OTG_A_CLR_ERR | OTG_A_BUS_DROP);
+			CHANGE_STATE (otg, OTG_STATE_A_WAIT_VFALL, pEvt_mask);
+		}
+		break;
+
+	/* B: ID pin is not connected                                        */
+	/* ==========================                                        */
+
+	case OTG_STATE_B_IDLE :
+
+		/* B_IDLE: init state for B-devices                          */
+		/*         monitor VBus, no connection, no activity          */
+
+		CHECK_STATE (otg, OTG_STATE_B_IDLE, pEvt_mask);
+
+		if (IS_BIT_RES (OTG_STS_ID, uoc_status)) {
+
+			/* ID pin changed => A_IDLE                          */
+			/*                   Set state, request "A-bus"      */
+
+                    if (IS_FLAG_SET (otg, OTG_HOST_READY)) {
+
+				SET_FLAG (otg, OTG_A_BUS_REQ);
+			}
+			RES_EVENT (OTG_INT_IDC, event_code);
+			CHANGE_STATE (otg, OTG_STATE_A_IDLE, pEvt_mask);
+		}
+		else if (IS_BIT_SET (OTG_STS_SESSVLD, uoc_status)) {
+
+			/* Session valid => B_PERIPHERAL                     */
+			/*                  Set state                        */
+
+			RES_EVENT (OTG_INT_SVC, event_code);
+			CHANGE_STATE (otg, OTG_STATE_B_PERIPHERAL, pEvt_mask);
+#ifndef CONFIG_TEST_MODE_ONLY
+			if (otg_gadget_extension.notify) {
+				otg_gadget_extension.notify (
+					OTG_GADGET_EVT_SVALID);
+			}
+#endif
+		}
+		else if (IS_BIT_SET (OTG_STS_SESSEND, uoc_status) &&
+		         IS_FLAG_SET (otg, OTG_GADGET_READY) &&
+		         IS_FLAG_SET (otg, OTG_B_aSSN_REQ)) {
+
+			/* Session end & Gadget ready & SRP request          */
+			/*                => B_SRP_INIT  Set state           */
+
+			RES_FLAG (otg, OTG_B_SRP_ERROR);
+			CHANGE_STATE (otg, OTG_STATE_B_SRP_INIT, pEvt_mask);
+		}
+		else if (IS_FLAG_SET (otg, OTG_B_aSSN_REQ)) {
+
+			RES_FLAG (otg, OTG_B_aSSN_REQ);
+		}
+		break;
+
+	case OTG_STATE_B_SRP_INIT :
+
+		/* B_SRP_INIT: device initiates a session request            */
+		/*             pulse charge VBus, no activity                */
+
+		CHECK_STATE (otg, OTG_STATE_B_SRP_INIT, pEvt_mask);
+
+		if (IS_BIT_RES (OTG_STS_ID, uoc_status)) {
+
+			/* ID pin changed => B_IDLE                          */
+			/*               Stop timer, set resistors and state */
+			RES_EVENT ((OTG_INT_IDC | OTG_INT_TMX), event_code);
+			CHANGE_STATE (otg, OTG_STATE_B_IDLE, pEvt_mask);
+		}
+		else {
+
+			/* Process the SRP as required                       */
+
+			process_srp (otg, uoc_status, event_code, pEvt_mask);
+			RES_EVENT ((OTG_INT_SEC | OTG_INT_TMX), event_code);
+		}
+		break;
+
+	case OTG_STATE_B_PERIPHERAL :
+
+		/* B_PERIPHERAL: connected to A-host, responding             */
+		/*               VBus driven by A, remote activity           */
+
+		CHECK_STATE (otg, OTG_STATE_B_PERIPHERAL, pEvt_mask);
+
+		if (IS_BIT_RES (OTG_STS_ID, uoc_status) ||
+		    IS_BIT_RES (OTG_STS_SESSVLD, uoc_status)) {
+
+			/* ID pin changed | ~Session valid => B_IDLE         */
+			/*                                    Set state      */
+
+			RES_EVENT ((OTG_INT_IDC | OTG_INT_SVC), event_code);
+			CHANGE_STATE (otg, OTG_STATE_B_IDLE, pEvt_mask);
+#ifndef CONFIG_TEST_MODE_ONLY
+			if (otg_gadget_extension.notify) {
+				otg_gadget_extension.notify (
+					OTG_GADGET_EVT_SVDROP);
+			}
+#endif
+		}
+		else if (OTG_STATE_B_PERIPHERAL_DC ==
+		         otg->transceiver.state) {
+
+			CHECK_STATE (otg, OTG_STATE_B_PERIPHERAL_DC,
+			             pEvt_mask);
+			/* TODO kboge: do we need a better TO condition here */
+
+			/* Waiting for clean disconnect state                */
+
+			if (IS_BIT_RES (OTG_STS_PCON, uoc_status) ||
+			    IS_BIT_RES (OTG_STS_LST, uoc_status)) {
+
+				/* now disconnected, set new state           */
+
+				RES_EVENT ((OTG_INT_PCC | OTG_INT_TMX),
+				           event_code);
+				SET_OTG_TIMER (otg, B_ASE0_BRST);
+				CHANGE_STATE (otg, OTG_STATE_B_WAIT_ACON,
+				              pEvt_mask);
+			}
+			else if (GOT_EVENT (OTG_INT_TMX, event_code)) {
+
+				/* Time over, still connected, asume this is */
+				/*            already the A-peripheral       */
+
+				RES_EVENT (OTG_INT_TMX, event_code);
+				CHANGE_STATE (otg, OTG_STATE_B_HOST,
+				              pEvt_mask);
+				otg_hnp_start_enum (&otg->transceiver);
+#ifndef CONFIG_TEST_MODE_ONLY
+				if (otg_gadget_extension.notify) {
+					otg_gadget_extension.notify (
+						OTG_GADGET_EVT_SVDROP);
+				}
+#endif
+			}
+		}
+		else if (IS_BIT_SET (OTG_STS_HNP_EN, uoc_status) &&
+		         IS_FLAG_SET (otg, OTG_HOST_READY) &&
+		         IS_FLAG_SET (otg, OTG_B_BUS_REQ) &&
+		         IS_BIT_SET (OTG_STS_PSUS, uoc_status)) {
+
+			/* BBus req & BHnp en & Bus suspended => B_WAIT_ACON */
+			/*                      Wait, enable host, set state */
+
+			if (OTG_STATE_B_PERIPHERAL_WT !=
+			    otg->transceiver.state) {
+
+				/* Wait _Ta_idle_bdis_ before disconnect     */
+
+				RES_EVENT (OTG_INT_PSC, event_code);
+				/* SET_OTG_TIMER_LONG (otg, B_AIDL_BDIS); */
+				SET_OTG_TIMER (otg, B_AIDL_BDIS);
+				CHANGE_STATE (otg, OTG_STATE_B_PERIPHERAL_WT,
+				              pEvt_mask);
+			}
+			else {
+				CHECK_STATE (otg, OTG_STATE_B_PERIPHERAL_WT,
+				             pEvt_mask);
+
+				if (GOT_EVENT (OTG_INT_TMX, event_code)) {
+
+					/* Time over,                        */
+					/* disconnect and change state       */
+
+					RES_EVENT (OTG_INT_TMX, event_code);
+					SET_OTG_TIMER_SHORT (otg,
+					                     B_WAIT_ADISCON);
+
+					/* dis-re-connect time could be ~0   */
+					CHANGE_STATE (otg,
+					              OTG_STATE_B_PERIPHERAL_DC,
+						      pEvt_mask);
+				}
+			}
+		}
+		else if (OTG_STATE_B_PERIPHERAL_WT ==
+		         otg->transceiver.state) {
+
+			CHECK_STATE (otg, OTG_STATE_B_PERIPHERAL_WT,
+			             pEvt_mask);
+			if (IS_BIT_RES (OTG_STS_PSUS, uoc_status)) {
+
+				/* Resumed during wait time                  */
+
+				CHANGE_STATE (otg, OTG_STATE_B_PERIPHERAL,
+				              pEvt_mask);
+			}
+		}
+#ifdef VERBOSE
+		else {
+			if (!(OTG_STS_PSPD & uoc_status)) {
+				DBG ("    port is in HIGH_SPEED\n");
+			}
+			else {
+				DBG ("    port is in FULL_SPEED\n");
+			}
+		}
+#endif
+		break;
+
+	case OTG_STATE_B_WAIT_ACON :
+
+		/* B_WAIT_ACON: B-device waits for A-device connect          */
+		/*              no device connect, no bus activity           */
+
+		CHECK_STATE (otg, OTG_STATE_B_WAIT_ACON, pEvt_mask);
+
+		if (IS_BIT_RES (OTG_STS_ID, uoc_status) ||
+		    IS_BIT_RES (OTG_STS_SESSVLD, uoc_status)) {
+
+			/* ID pin changed | ~Session valid => B_IDLE         */
+			/*                         Enable device, set state  */
+
+			RES_EVENT ((OTG_INT_IDC | OTG_INT_SVC | OTG_INT_TMX),
+			            event_code);
+			CHANGE_STATE (otg, OTG_STATE_B_IDLE, pEvt_mask);
+#ifndef CONFIG_TEST_MODE_ONLY
+			if (otg_gadget_extension.notify) {
+				otg_gadget_extension.notify (
+					OTG_GADGET_EVT_SVDROP);
+			}
+#endif
+		}
+		else if ((IS_BIT_SET (OTG_STS_PCON, uoc_status)) &&
+		         !(IS_BIT_RES (OTG_STS_LST, uoc_status))) {
+
+			/* Port connect => B_HOST                            */
+			/*       Set wait time before reset, set state       */
+
+			RES_EVENT ((OTG_INT_PCC | OTG_INT_TMX), event_code);
+			SET_OTG_TIMER_SHORT (otg, B_ACON_BRST);
+			CHANGE_STATE (otg, OTG_STATE_B_HOST_WT, pEvt_mask);
+		}
+		else if (GOT_EVENT (OTG_INT_TMX, event_code)) {
+
+			/* Time out => B_PERIPHERAL                          */
+			/*             Set state                             */
+
+			RES_EVENT ((OTG_INT_PSC | OTG_INT_HNPFC | OTG_INT_TMX),
+			           event_code);
+
+			/* NOTE: no UDC notification here                    */
+			/*       don't want to confuse the UDC               */
+
+			ERR ("HNP: Device Not Responding, giving up\n");
+			CHANGE_STATE (otg, OTG_STATE_B_PERIPHERAL, pEvt_mask);
+		}
+		break;
+
+	case OTG_STATE_B_HOST :
+
+		/* B_HOST: A-peripheral connected, ready for USB ops         */
+		/*         VBus is driven by A, bus is activ (SOF)           */
+
+		CHECK_STATE (otg, OTG_STATE_B_HOST, pEvt_mask);
+
+		if (OTG_STATE_B_HOST_WT == otg->transceiver.state) {
+
+			CHECK_STATE (otg, OTG_STATE_B_HOST_WT, pEvt_mask);
+
+			if (GOT_EVENT (OTG_INT_TMX, event_code)) {
+
+				/* time over, now starting reset ...         */
+			
+				RES_EVENT (OTG_INT_TMX, event_code);
+				CHANGE_STATE (otg, OTG_STATE_B_HOST,
+				              pEvt_mask);
+				otg_hnp_start_enum (&otg->transceiver);
+#ifndef CONFIG_TEST_MODE_ONLY
+				if (otg_gadget_extension.notify) {
+					otg_gadget_extension.notify (
+						OTG_GADGET_EVT_SVDROP);
+				}
+#endif
+			}
+		}
+		else if (IS_BIT_RES (OTG_STS_ID, uoc_status) ||
+		         IS_BIT_RES (OTG_STS_SESSVLD, uoc_status)) {
+
+			/* ID pin changed | ~Session valid => B_IDLE         */
+			/*                          Enable device, set state */
+
+			CHANGE_STATE (otg, OTG_STATE_B_IDLE, pEvt_mask);
+		}
+		else if (IS_BIT_RES (OTG_STS_PCON, uoc_status)) {
+
+			/* Port disconnect & Session valid                   */
+			/*         => B_PERIPHERAL, Enable device, set state */
+
+			CHANGE_STATE (otg, OTG_STATE_B_PERIPHERAL, pEvt_mask);
+#ifndef CONFIG_TEST_MODE_ONLY
+			if (otg_gadget_extension.notify) {
+				otg_gadget_extension.notify (
+					OTG_GADGET_EVT_SVALID);
+			}
+#endif
+		}
+#ifdef VERBOSE
+		else {
+			if (!(OTG_STS_PSPD & uoc_status)) {
+				DBG ("    port is in HIGH_SPEED\n");
+			}
+			else if (OTG_STS_PSPD_LS & uoc_status) {
+				DBG ("    port is in LOW_SPEED\n");
+			}
+			else {
+				DBG ("    port is in FULL_SPEED\n");
+			}
+		}
+#endif
+		break;
+
+	/* unlikely */ default :
+
+		/* something went wrong */
+
+		BUG ();
+		break;
+	}
+	while ((otg->transceiver.state ^ otg->transceiver.prv_state) &
+	       OTG_STATE_MASK);
+
+	DBG ("OTG-state change done\n");
+	}
+
+	return event_code;
+}
+
+
+/* This comment closes the module definition from above. There can be multiple 
+   definitions of this kind in a file. See the doxygen documentation for more
+   information. */
+/** \}*/
diff -Nru linux26-cvs/drivers/usb/gadget/amd5536otg.h linux26-amd/drivers/usb/gadget/amd5536otg.h
--- linux26-cvs/drivers/usb/gadget/amd5536otg.h	1970-01-01 01:00:00.000000000 +0100
+++ linux26-amd/drivers/usb/gadget/amd5536otg.h	2005-07-15 12:29:18.000000000 +0200
@@ -0,0 +1,183 @@
+/*
+ * AMD 5536 USB OTG driver
+ */
+
+/*
+ * Copyright (C) 2005 AMD (http://www.amd.com)
+ * Author: Karsten Boge 
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.