[linux-2.6-block.git] / drivers / usb / phy / phy-fsm-usb.c

/*
 * OTG Finite State Machine from OTG spec
 *
 * Copyright (C) 2007,2008 Freescale Semiconductor, Inc.
 *
 * Author:	Li Yang <LeoLi@freescale.com>
 *		Jerry Huang <Chang-Ming.Huang@freescale.com>
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the  GNU General Public License along
 * with this program; if not, write  to the Free Software Foundation, Inc.,
 * 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/mutex.h>
#include <linux/delay.h>
#include <linux/usb.h>
#include <linux/usb/gadget.h>
#include <linux/usb/otg.h>
#include <linux/usb/otg-fsm.h>

/* Change USB protocol when there is a protocol change */
static int otg_set_protocol(struct otg_fsm *fsm, int protocol)
{
	int ret = 0;

	if (fsm->protocol != protocol) {
		VDBG("Changing role fsm->protocol= %d; new protocol= %d\n",
			fsm->protocol, protocol);
		/* stop old protocol */
		if (fsm->protocol == PROTO_HOST)
			ret = otg_start_host(fsm, 0);
		else if (fsm->protocol == PROTO_GADGET)
			ret = otg_start_gadget(fsm, 0);
		if (ret)
			return ret;

		/* start new protocol */
		if (protocol == PROTO_HOST)
			ret = otg_start_host(fsm, 1);
		else if (protocol == PROTO_GADGET)
			ret = otg_start_gadget(fsm, 1);
		if (ret)
			return ret;

		fsm->protocol = protocol;
		return 0;
	}

	return 0;
}

static int state_changed;

/* Called when leaving a state.  Do state clean up jobs here */
static void otg_leave_state(struct otg_fsm *fsm, enum usb_otg_state old_state)
{
	switch (old_state) {
	case OTG_STATE_B_IDLE:
		otg_del_timer(fsm, B_SE0_SRP);
		fsm->b_se0_srp = 0;
		fsm->adp_sns = 0;
		fsm->adp_prb = 0;
		break;
	case OTG_STATE_B_SRP_INIT:
		fsm->data_pulse = 0;
		fsm->b_srp_done = 0;
		break;
	case OTG_STATE_B_PERIPHERAL:
		break;
	case OTG_STATE_B_WAIT_ACON:
		otg_del_timer(fsm, B_ASE0_BRST);
		fsm->b_ase0_brst_tmout = 0;
		break;
	case OTG_STATE_B_HOST:
		break;
	case OTG_STATE_A_IDLE:
		fsm->adp_prb = 0;
		break;
	case OTG_STATE_A_WAIT_VRISE:
		otg_del_timer(fsm, A_WAIT_VRISE);
		fsm->a_wait_vrise_tmout = 0;
		break;
	case OTG_STATE_A_WAIT_BCON:
		otg_del_timer(fsm, A_WAIT_BCON);
		fsm->a_wait_bcon_tmout = 0;
		break;
	case OTG_STATE_A_HOST:
		otg_del_timer(fsm, A_WAIT_ENUM);
		break;
	case OTG_STATE_A_SUSPEND:
		otg_del_timer(fsm, A_AIDL_BDIS);
		fsm->a_aidl_bdis_tmout = 0;
		fsm->a_suspend_req_inf = 0;
		break;
	case OTG_STATE_A_PERIPHERAL:
		otg_del_timer(fsm, A_BIDL_ADIS);
		fsm->a_bidl_adis_tmout = 0;
		break;
	case OTG_STATE_A_WAIT_VFALL:
		otg_del_timer(fsm, A_WAIT_VFALL);
		fsm->a_wait_vfall_tmout = 0;
		otg_del_timer(fsm, A_WAIT_VRISE);
		break;
	case OTG_STATE_A_VBUS_ERR:
		break;
	default:
		break;
	}
}

/* Called when entering a state */
static int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
{
	state_changed = 1;
	if (fsm->otg->phy->state == new_state)
		return 0;
	VDBG("Set state: %s\n", usb_otg_state_string(new_state));
	otg_leave_state(fsm, fsm->otg->phy->state);
	switch (new_state) {
	case OTG_STATE_B_IDLE:
		otg_drv_vbus(fsm, 0);
		otg_chrg_vbus(fsm, 0);
		otg_loc_conn(fsm, 0);
		otg_loc_sof(fsm, 0);
		/*
		 * Driver is responsible for starting ADP probing
		 * if ADP sensing times out.
		 */
		otg_start_adp_sns(fsm);
		otg_set_protocol(fsm, PROTO_UNDEF);
		otg_add_timer(fsm, B_SE0_SRP);
		break;
	case OTG_STATE_B_SRP_INIT:
		otg_start_pulse(fsm);
		otg_loc_sof(fsm, 0);
		otg_set_protocol(fsm, PROTO_UNDEF);
		otg_add_timer(fsm, B_SRP_FAIL);
		break;
	case OTG_STATE_B_PERIPHERAL:
		otg_chrg_vbus(fsm, 0);
		otg_loc_conn(fsm, 1);
		otg_loc_sof(fsm, 0);
		otg_set_protocol(fsm, PROTO_GADGET);
		break;
	case OTG_STATE_B_WAIT_ACON:
		otg_chrg_vbus(fsm, 0);
		otg_loc_conn(fsm, 0);
		otg_loc_sof(fsm, 0);
		otg_set_protocol(fsm, PROTO_HOST);
		otg_add_timer(fsm, B_ASE0_BRST);
		fsm->a_bus_suspend = 0;
		break;
	case OTG_STATE_B_HOST:
		otg_chrg_vbus(fsm, 0);
		otg_loc_conn(fsm, 0);
		otg_loc_sof(fsm, 1);
		otg_set_protocol(fsm, PROTO_HOST);
		usb_bus_start_enum(fsm->otg->host,
				fsm->otg->host->otg_port);
		break;
	case OTG_STATE_A_IDLE:
		otg_drv_vbus(fsm, 0);
		otg_chrg_vbus(fsm, 0);
		otg_loc_conn(fsm, 0);
		otg_loc_sof(fsm, 0);
		otg_start_adp_prb(fsm);
		otg_set_protocol(fsm, PROTO_HOST);
		break;
	case OTG_STATE_A_WAIT_VRISE:
		otg_drv_vbus(fsm, 1);
		otg_loc_conn(fsm, 0);
		otg_loc_sof(fsm, 0);
		otg_set_protocol(fsm, PROTO_HOST);
		otg_add_timer(fsm, A_WAIT_VRISE);
		break;
	case OTG_STATE_A_WAIT_BCON:
		otg_drv_vbus(fsm, 1);
		otg_loc_conn(fsm, 0);
		otg_loc_sof(fsm, 0);
		otg_set_protocol(fsm, PROTO_HOST);
		otg_add_timer(fsm, A_WAIT_BCON);
		break;
	case OTG_STATE_A_HOST:
		otg_drv_vbus(fsm, 1);
		otg_loc_conn(fsm, 0);
		otg_loc_sof(fsm, 1);
		otg_set_protocol(fsm, PROTO_HOST);
		/*
		 * When HNP is triggered while a_bus_req = 0, a_host will
		 * suspend too fast to complete a_set_b_hnp_en
		 */
		if (!fsm->a_bus_req || fsm->a_suspend_req_inf)
			otg_add_timer(fsm, A_WAIT_ENUM);
		break;
	case OTG_STATE_A_SUSPEND:
		otg_drv_vbus(fsm, 1);
		otg_loc_conn(fsm, 0);
		otg_loc_sof(fsm, 0);
		otg_set_protocol(fsm, PROTO_HOST);
		otg_add_timer(fsm, A_AIDL_BDIS);

		break;
	case OTG_STATE_A_PERIPHERAL:
		otg_loc_conn(fsm, 1);
		otg_loc_sof(fsm, 0);
		otg_set_protocol(fsm, PROTO_GADGET);
		otg_drv_vbus(fsm, 1);
		otg_add_timer(fsm, A_BIDL_ADIS);
		break;
	case OTG_STATE_A_WAIT_VFALL:
		otg_drv_vbus(fsm, 0);
		otg_loc_conn(fsm, 0);
		otg_loc_sof(fsm, 0);
		otg_set_protocol(fsm, PROTO_HOST);
		otg_add_timer(fsm, A_WAIT_VFALL);
		break;
	case OTG_STATE_A_VBUS_ERR:
		otg_drv_vbus(fsm, 0);
		otg_loc_conn(fsm, 0);
		otg_loc_sof(fsm, 0);
		otg_set_protocol(fsm, PROTO_UNDEF);
		break;
	default:
		break;
	}

	fsm->otg->phy->state = new_state;
	return 0;
}

/* State change judgement */
int otg_statemachine(struct otg_fsm *fsm)
{
	enum usb_otg_state state;

	mutex_lock(&fsm->lock);

	state = fsm->otg->phy->state;
	state_changed = 0;
	/* State machine state change judgement */

	switch (state) {
	case OTG_STATE_UNDEFINED:
		VDBG("fsm->id = %d\n", fsm->id);
		if (fsm->id)
			otg_set_state(fsm, OTG_STATE_B_IDLE);
		else
			otg_set_state(fsm, OTG_STATE_A_IDLE);
		break;
	case OTG_STATE_B_IDLE:
		if (!fsm->id)
			otg_set_state(fsm, OTG_STATE_A_IDLE);
		else if (fsm->b_sess_vld && fsm->otg->gadget)
			otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
		else if ((fsm->b_bus_req || fsm->adp_change || fsm->power_up) &&
				fsm->b_ssend_srp && fsm->b_se0_srp)
			otg_set_state(fsm, OTG_STATE_B_SRP_INIT);
		break;
	case OTG_STATE_B_SRP_INIT:
		if (!fsm->id || fsm->b_srp_done)
			otg_set_state(fsm, OTG_STATE_B_IDLE);
		break;
	case OTG_STATE_B_PERIPHERAL:
		if (!fsm->id || !fsm->b_sess_vld)
			otg_set_state(fsm, OTG_STATE_B_IDLE);
		else if (fsm->b_bus_req && fsm->otg->
				gadget->b_hnp_enable && fsm->a_bus_suspend)
			otg_set_state(fsm, OTG_STATE_B_WAIT_ACON);
		break;
	case OTG_STATE_B_WAIT_ACON:
		if (fsm->a_conn)
			otg_set_state(fsm, OTG_STATE_B_HOST);
		else if (!fsm->id || !fsm->b_sess_vld)
			otg_set_state(fsm, OTG_STATE_B_IDLE);
		else if (fsm->a_bus_resume || fsm->b_ase0_brst_tmout) {
			fsm->b_ase0_brst_tmout = 0;
			otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
		}
		break;
	case OTG_STATE_B_HOST:
		if (!fsm->id || !fsm->b_sess_vld)
			otg_set_state(fsm, OTG_STATE_B_IDLE);
		else if (!fsm->b_bus_req || !fsm->a_conn || fsm->test_device)
			otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
		break;
	case OTG_STATE_A_IDLE:
		if (fsm->id)
			otg_set_state(fsm, OTG_STATE_B_IDLE);
		else if (!fsm->a_bus_drop && (fsm->a_bus_req ||
			  fsm->a_srp_det || fsm->adp_change || fsm->power_up))
			otg_set_state(fsm, OTG_STATE_A_WAIT_VRISE);
		break;
	case OTG_STATE_A_WAIT_VRISE:
		if (fsm->id || fsm->a_bus_drop || fsm->a_vbus_vld ||
				fsm->a_wait_vrise_tmout) {
			otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
		}
		break;
	case OTG_STATE_A_WAIT_BCON:
		if (!fsm->a_vbus_vld)
			otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
		else if (fsm->b_conn)
			otg_set_state(fsm, OTG_STATE_A_HOST);
		else if (fsm->id | fsm->a_bus_drop | fsm->a_wait_bcon_tmout)
			otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
		break;
	case OTG_STATE_A_HOST:
		if ((!fsm->a_bus_req || fsm->a_suspend_req_inf) &&
				fsm->otg->host->b_hnp_enable)
			otg_set_state(fsm, OTG_STATE_A_SUSPEND);
		else if (fsm->id || !fsm->b_conn || fsm->a_bus_drop)
			otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
		else if (!fsm->a_vbus_vld)
			otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
		break;
	case OTG_STATE_A_SUSPEND:
		if (!fsm->b_conn && fsm->otg->host->b_hnp_enable)
			otg_set_state(fsm, OTG_STATE_A_PERIPHERAL);
		else if (!fsm->b_conn && !fsm->otg->host->b_hnp_enable)
			otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
		else if (fsm->a_bus_req || fsm->b_bus_resume)
			otg_set_state(fsm, OTG_STATE_A_HOST);
		else if (fsm->id || fsm->a_bus_drop || fsm->a_aidl_bdis_tmout)
			otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
		else if (!fsm->a_vbus_vld)
			otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
		break;
	case OTG_STATE_A_PERIPHERAL:
		if (fsm->id || fsm->a_bus_drop)
			otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
		else if (fsm->a_bidl_adis_tmout || fsm->b_bus_suspend)
			otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
		else if (!fsm->a_vbus_vld)
			otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
		break;
	case OTG_STATE_A_WAIT_VFALL:
		if (fsm->a_wait_vfall_tmout || fsm->id || fsm->a_bus_req ||
				(!fsm->a_sess_vld && !fsm->b_conn))
			otg_set_state(fsm, OTG_STATE_A_IDLE);
		break;
	case OTG_STATE_A_VBUS_ERR:
		if (fsm->id || fsm->a_bus_drop || fsm->a_clr_err)
			otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
		break;
	default:
		break;
	}
	mutex_unlock(&fsm->lock);

	VDBG("quit statemachine, changed = %d\n", state_changed);
	return state_changed;
}
Commit	Line	Data
0807c500 LY	1	/*
	2	* OTG Finite State Machine from OTG spec
	3	*
	4	* Copyright (C) 2007,2008 Freescale Semiconductor, Inc.
	5	*
	6	* Author: Li Yang <LeoLi@freescale.com>
	7	* Jerry Huang <Chang-Ming.Huang@freescale.com>
	8	*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License as published by the
	11	* Free Software Foundation; either version 2 of the License, or (at your
	12	* option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful, but
	15	* WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License along
	20	* with this program; if not, write to the Free Software Foundation, Inc.,
	21	* 675 Mass Ave, Cambridge, MA 02139, USA.
	22	*/
	23
	24	#include <linux/kernel.h>
	25	#include <linux/types.h>
16e569e9	26	#include <linux/mutex.h>
0807c500 LY	27	#include <linux/delay.h>
	28	#include <linux/usb.h>
	29	#include <linux/usb/gadget.h>
	30	#include <linux/usb/otg.h>
5653668c	31	#include <linux/usb/otg-fsm.h>
0807c500 LY	32
	33	/* Change USB protocol when there is a protocol change */
	34	static int otg_set_protocol(struct otg_fsm *fsm, int protocol)
	35	{
	36	int ret = 0;
	37
	38	if (fsm->protocol != protocol) {
	39	VDBG("Changing role fsm->protocol= %d; new protocol= %d\n",
	40	fsm->protocol, protocol);
	41	/* stop old protocol */
	42	if (fsm->protocol == PROTO_HOST)
425d7101	43	ret = otg_start_host(fsm, 0);
0807c500	44	else if (fsm->protocol == PROTO_GADGET)
425d7101	45	ret = otg_start_gadget(fsm, 0);
0807c500 LY	46	if (ret)
	47	return ret;
	48
	49	/* start new protocol */
	50	if (protocol == PROTO_HOST)
425d7101	51	ret = otg_start_host(fsm, 1);
0807c500	52	else if (protocol == PROTO_GADGET)
425d7101	53	ret = otg_start_gadget(fsm, 1);
0807c500 LY	54	if (ret)
	55	return ret;
	56
	57	fsm->protocol = protocol;
	58	return 0;
	59	}
	60
	61	return 0;
	62	}
	63
	64	static int state_changed;
	65
	66	/* Called when leaving a state. Do state clean up jobs here */
7410f172	67	static void otg_leave_state(struct otg_fsm *fsm, enum usb_otg_state old_state)
0807c500 LY	68	{
	69	switch (old_state) {
	70	case OTG_STATE_B_IDLE:
f6de27ee	71	otg_del_timer(fsm, B_SE0_SRP);
0807c500	72	fsm->b_se0_srp = 0;
ec04996a AT	73	fsm->adp_sns = 0;
ec04996a AT	74	fsm->adp_prb = 0;
0807c500 LY	75	break;
0807c500 LY	76	case OTG_STATE_B_SRP_INIT:
ec04996a	77	fsm->data_pulse = 0;
0807c500 LY	78	fsm->b_srp_done = 0;
	79	break;
	80	case OTG_STATE_B_PERIPHERAL:
	81	break;
	82	case OTG_STATE_B_WAIT_ACON:
f6de27ee	83	otg_del_timer(fsm, B_ASE0_BRST);
0807c500 LY	84	fsm->b_ase0_brst_tmout = 0;
	85	break;
	86	case OTG_STATE_B_HOST:
	87	break;
	88	case OTG_STATE_A_IDLE:
ec04996a	89	fsm->adp_prb = 0;
0807c500 LY	90	break;
0807c500 LY	91	case OTG_STATE_A_WAIT_VRISE:
f6de27ee	92	otg_del_timer(fsm, A_WAIT_VRISE);
0807c500 LY	93	fsm->a_wait_vrise_tmout = 0;
	94	break;
	95	case OTG_STATE_A_WAIT_BCON:
f6de27ee	96	otg_del_timer(fsm, A_WAIT_BCON);
0807c500 LY	97	fsm->a_wait_bcon_tmout = 0;
	98	break;
	99	case OTG_STATE_A_HOST:
f6de27ee	100	otg_del_timer(fsm, A_WAIT_ENUM);
0807c500 LY	101	break;
0807c500 LY	102	case OTG_STATE_A_SUSPEND:
f6de27ee	103	otg_del_timer(fsm, A_AIDL_BDIS);
0807c500	104	fsm->a_aidl_bdis_tmout = 0;
cff4dab4	105	fsm->a_suspend_req_inf = 0;
0807c500 LY	106	break;
0807c500 LY	107	case OTG_STATE_A_PERIPHERAL:
3294908b AT	108	otg_del_timer(fsm, A_BIDL_ADIS);
3294908b AT	109	fsm->a_bidl_adis_tmout = 0;
0807c500 LY	110	break;
0807c500 LY	111	case OTG_STATE_A_WAIT_VFALL:
3294908b AT	112	otg_del_timer(fsm, A_WAIT_VFALL);
3294908b AT	113	fsm->a_wait_vfall_tmout = 0;
f6de27ee	114	otg_del_timer(fsm, A_WAIT_VRISE);
0807c500 LY	115	break;
	116	case OTG_STATE_A_VBUS_ERR:
	117	break;
	118	default:
	119	break;
	120	}
	121	}
	122
	123	/* Called when entering a state */
7410f172	124	static int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
0807c500 LY	125	{
0807c500 LY	126	state_changed = 1;
7e062c0f	127	if (fsm->otg->phy->state == new_state)
0807c500	128	return 0;
42c0bf1c	129	VDBG("Set state: %s\n", usb_otg_state_string(new_state));
7e062c0f	130	otg_leave_state(fsm, fsm->otg->phy->state);
0807c500 LY	131	switch (new_state) {
	132	case OTG_STATE_B_IDLE:
	133	otg_drv_vbus(fsm, 0);
	134	otg_chrg_vbus(fsm, 0);
	135	otg_loc_conn(fsm, 0);
	136	otg_loc_sof(fsm, 0);
ec04996a AT	137	/*
	138	* Driver is responsible for starting ADP probing
	139	* if ADP sensing times out.
	140	*/
	141	otg_start_adp_sns(fsm);
0807c500	142	otg_set_protocol(fsm, PROTO_UNDEF);
f6de27ee	143	otg_add_timer(fsm, B_SE0_SRP);
0807c500 LY	144	break;
	145	case OTG_STATE_B_SRP_INIT:
	146	otg_start_pulse(fsm);
	147	otg_loc_sof(fsm, 0);
	148	otg_set_protocol(fsm, PROTO_UNDEF);
f6de27ee	149	otg_add_timer(fsm, B_SRP_FAIL);
0807c500 LY	150	break;
	151	case OTG_STATE_B_PERIPHERAL:
	152	otg_chrg_vbus(fsm, 0);
	153	otg_loc_conn(fsm, 1);
	154	otg_loc_sof(fsm, 0);
	155	otg_set_protocol(fsm, PROTO_GADGET);
	156	break;
	157	case OTG_STATE_B_WAIT_ACON:
	158	otg_chrg_vbus(fsm, 0);
	159	otg_loc_conn(fsm, 0);
	160	otg_loc_sof(fsm, 0);
	161	otg_set_protocol(fsm, PROTO_HOST);
f6de27ee	162	otg_add_timer(fsm, B_ASE0_BRST);
0807c500 LY	163	fsm->a_bus_suspend = 0;
	164	break;
	165	case OTG_STATE_B_HOST:
	166	otg_chrg_vbus(fsm, 0);
	167	otg_loc_conn(fsm, 0);
	168	otg_loc_sof(fsm, 1);
	169	otg_set_protocol(fsm, PROTO_HOST);
7e062c0f HK	170	usb_bus_start_enum(fsm->otg->host,
7e062c0f HK	171	fsm->otg->host->otg_port);
0807c500 LY	172	break;
	173	case OTG_STATE_A_IDLE:
	174	otg_drv_vbus(fsm, 0);
	175	otg_chrg_vbus(fsm, 0);
	176	otg_loc_conn(fsm, 0);
	177	otg_loc_sof(fsm, 0);
ec04996a	178	otg_start_adp_prb(fsm);
0807c500 LY	179	otg_set_protocol(fsm, PROTO_HOST);
	180	break;
	181	case OTG_STATE_A_WAIT_VRISE:
	182	otg_drv_vbus(fsm, 1);
	183	otg_loc_conn(fsm, 0);
	184	otg_loc_sof(fsm, 0);
	185	otg_set_protocol(fsm, PROTO_HOST);
f6de27ee	186	otg_add_timer(fsm, A_WAIT_VRISE);
0807c500 LY	187	break;
	188	case OTG_STATE_A_WAIT_BCON:
	189	otg_drv_vbus(fsm, 1);
	190	otg_loc_conn(fsm, 0);
	191	otg_loc_sof(fsm, 0);
	192	otg_set_protocol(fsm, PROTO_HOST);
f6de27ee	193	otg_add_timer(fsm, A_WAIT_BCON);
0807c500 LY	194	break;
	195	case OTG_STATE_A_HOST:
	196	otg_drv_vbus(fsm, 1);
	197	otg_loc_conn(fsm, 0);
	198	otg_loc_sof(fsm, 1);
	199	otg_set_protocol(fsm, PROTO_HOST);
	200	/*
	201	* When HNP is triggered while a_bus_req = 0, a_host will
	202	* suspend too fast to complete a_set_b_hnp_en
	203	*/
cff4dab4	204	if (!fsm->a_bus_req \|\| fsm->a_suspend_req_inf)
f6de27ee	205	otg_add_timer(fsm, A_WAIT_ENUM);
0807c500 LY	206	break;
	207	case OTG_STATE_A_SUSPEND:
	208	otg_drv_vbus(fsm, 1);
	209	otg_loc_conn(fsm, 0);
	210	otg_loc_sof(fsm, 0);
	211	otg_set_protocol(fsm, PROTO_HOST);
f6de27ee	212	otg_add_timer(fsm, A_AIDL_BDIS);
0807c500 LY	213
	214	break;
	215	case OTG_STATE_A_PERIPHERAL:
	216	otg_loc_conn(fsm, 1);
	217	otg_loc_sof(fsm, 0);
	218	otg_set_protocol(fsm, PROTO_GADGET);
	219	otg_drv_vbus(fsm, 1);
3294908b	220	otg_add_timer(fsm, A_BIDL_ADIS);
0807c500 LY	221	break;
	222	case OTG_STATE_A_WAIT_VFALL:
	223	otg_drv_vbus(fsm, 0);
	224	otg_loc_conn(fsm, 0);
	225	otg_loc_sof(fsm, 0);
	226	otg_set_protocol(fsm, PROTO_HOST);
3294908b	227	otg_add_timer(fsm, A_WAIT_VFALL);
0807c500 LY	228	break;
	229	case OTG_STATE_A_VBUS_ERR:
	230	otg_drv_vbus(fsm, 0);
	231	otg_loc_conn(fsm, 0);
	232	otg_loc_sof(fsm, 0);
	233	otg_set_protocol(fsm, PROTO_UNDEF);
	234	break;
	235	default:
	236	break;
	237	}
	238
7e062c0f	239	fsm->otg->phy->state = new_state;
0807c500 LY	240	return 0;
	241	}
	242
	243	/* State change judgement */
	244	int otg_statemachine(struct otg_fsm *fsm)
	245	{
	246	enum usb_otg_state state;
0807c500	247
16e569e9	248	mutex_lock(&fsm->lock);
0807c500	249
7e062c0f	250	state = fsm->otg->phy->state;
0807c500 LY	251	state_changed = 0;
	252	/* State machine state change judgement */
	253
	254	switch (state) {
	255	case OTG_STATE_UNDEFINED:
	256	VDBG("fsm->id = %d\n", fsm->id);
	257	if (fsm->id)
	258	otg_set_state(fsm, OTG_STATE_B_IDLE);
	259	else
	260	otg_set_state(fsm, OTG_STATE_A_IDLE);
	261	break;
	262	case OTG_STATE_B_IDLE:
	263	if (!fsm->id)
	264	otg_set_state(fsm, OTG_STATE_A_IDLE);
7e062c0f	265	else if (fsm->b_sess_vld && fsm->otg->gadget)
0807c500	266	otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
ec04996a AT	267	else if ((fsm->b_bus_req \|\| fsm->adp_change \|\| fsm->power_up) &&
ec04996a AT	268	fsm->b_ssend_srp && fsm->b_se0_srp)
0807c500 LY	269	otg_set_state(fsm, OTG_STATE_B_SRP_INIT);
	270	break;
	271	case OTG_STATE_B_SRP_INIT:
	272	if (!fsm->id \|\| fsm->b_srp_done)
	273	otg_set_state(fsm, OTG_STATE_B_IDLE);
	274	break;
	275	case OTG_STATE_B_PERIPHERAL:
	276	if (!fsm->id \|\| !fsm->b_sess_vld)
	277	otg_set_state(fsm, OTG_STATE_B_IDLE);
7e062c0f	278	else if (fsm->b_bus_req && fsm->otg->
0807c500 LY	279	gadget->b_hnp_enable && fsm->a_bus_suspend)
	280	otg_set_state(fsm, OTG_STATE_B_WAIT_ACON);
	281	break;
	282	case OTG_STATE_B_WAIT_ACON:
	283	if (fsm->a_conn)
	284	otg_set_state(fsm, OTG_STATE_B_HOST);
	285	else if (!fsm->id \|\| !fsm->b_sess_vld)
	286	otg_set_state(fsm, OTG_STATE_B_IDLE);
	287	else if (fsm->a_bus_resume \|\| fsm->b_ase0_brst_tmout) {
	288	fsm->b_ase0_brst_tmout = 0;
	289	otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
	290	}
	291	break;
	292	case OTG_STATE_B_HOST:
	293	if (!fsm->id \|\| !fsm->b_sess_vld)
	294	otg_set_state(fsm, OTG_STATE_B_IDLE);
ec04996a	295	else if (!fsm->b_bus_req \|\| !fsm->a_conn \|\| fsm->test_device)
0807c500 LY	296	otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
	297	break;
	298	case OTG_STATE_A_IDLE:
	299	if (fsm->id)
	300	otg_set_state(fsm, OTG_STATE_B_IDLE);
ec04996a AT	301	else if (!fsm->a_bus_drop && (fsm->a_bus_req \|\|
ec04996a AT	302	fsm->a_srp_det \|\| fsm->adp_change \|\| fsm->power_up))
0807c500 LY	303	otg_set_state(fsm, OTG_STATE_A_WAIT_VRISE);
	304	break;
	305	case OTG_STATE_A_WAIT_VRISE:
	306	if (fsm->id \|\| fsm->a_bus_drop \|\| fsm->a_vbus_vld \|\|
	307	fsm->a_wait_vrise_tmout) {
	308	otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
	309	}
	310	break;
	311	case OTG_STATE_A_WAIT_BCON:
	312	if (!fsm->a_vbus_vld)
	313	otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
	314	else if (fsm->b_conn)
	315	otg_set_state(fsm, OTG_STATE_A_HOST);
	316	else if (fsm->id \| fsm->a_bus_drop \| fsm->a_wait_bcon_tmout)
	317	otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
	318	break;
	319	case OTG_STATE_A_HOST:
cff4dab4	320	if ((!fsm->a_bus_req \|\| fsm->a_suspend_req_inf) &&
7e062c0f	321	fsm->otg->host->b_hnp_enable)
0807c500 LY	322	otg_set_state(fsm, OTG_STATE_A_SUSPEND);
	323	else if (fsm->id \|\| !fsm->b_conn \|\| fsm->a_bus_drop)
	324	otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
	325	else if (!fsm->a_vbus_vld)
	326	otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
	327	break;
	328	case OTG_STATE_A_SUSPEND:
7e062c0f	329	if (!fsm->b_conn && fsm->otg->host->b_hnp_enable)
0807c500	330	otg_set_state(fsm, OTG_STATE_A_PERIPHERAL);
7e062c0f	331	else if (!fsm->b_conn && !fsm->otg->host->b_hnp_enable)
0807c500 LY	332	otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
	333	else if (fsm->a_bus_req \|\| fsm->b_bus_resume)
	334	otg_set_state(fsm, OTG_STATE_A_HOST);
	335	else if (fsm->id \|\| fsm->a_bus_drop \|\| fsm->a_aidl_bdis_tmout)
	336	otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
	337	else if (!fsm->a_vbus_vld)
	338	otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
	339	break;
	340	case OTG_STATE_A_PERIPHERAL:
	341	if (fsm->id \|\| fsm->a_bus_drop)
	342	otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
3294908b	343	else if (fsm->a_bidl_adis_tmout \|\| fsm->b_bus_suspend)
0807c500 LY	344	otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
	345	else if (!fsm->a_vbus_vld)
	346	otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
	347	break;
	348	case OTG_STATE_A_WAIT_VFALL:
3294908b AT	349	if (fsm->a_wait_vfall_tmout \|\| fsm->id \|\| fsm->a_bus_req \|\|
3294908b AT	350	(!fsm->a_sess_vld && !fsm->b_conn))
0807c500 LY	351	otg_set_state(fsm, OTG_STATE_A_IDLE);
	352	break;
	353	case OTG_STATE_A_VBUS_ERR:
	354	if (fsm->id \|\| fsm->a_bus_drop \|\| fsm->a_clr_err)
	355	otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
	356	break;
	357	default:
	358	break;
	359	}
16da4b17	360	mutex_unlock(&fsm->lock);
0807c500 LY	361
	362	VDBG("quit statemachine, changed = %d\n", state_changed);
	363	return state_changed;
	364	}