[deliverable/linux.git] / drivers / usb / common / usb-otg-fsm.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/module.h>
#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;
}

/* 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:
		if (fsm->otg->gadget)
			fsm->otg->gadget->host_request_flag = 0;
		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;
		if (fsm->otg->gadget)
			fsm->otg->gadget->host_request_flag = 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;
	}
}

static void otg_hnp_polling_work(struct work_struct *work)
{
	struct otg_fsm *fsm = container_of(to_delayed_work(work),
				struct otg_fsm, hnp_polling_work);
	struct usb_device *udev;
	enum usb_otg_state state = fsm->otg->state;
	u8 flag;
	int retval;

	if (state != OTG_STATE_A_HOST && state != OTG_STATE_B_HOST)
		return;

	udev = usb_hub_find_child(fsm->otg->host->root_hub, 1);
	if (!udev) {
		dev_err(fsm->otg->host->controller,
			"no usb dev connected, can't start HNP polling\n");
		return;
	}

	*fsm->host_req_flag = 0;
	/* Get host request flag from connected USB device */
	retval = usb_control_msg(udev,
				usb_rcvctrlpipe(udev, 0),
				USB_REQ_GET_STATUS,
				USB_DIR_IN | USB_RECIP_DEVICE,
				0,
				OTG_STS_SELECTOR,
				fsm->host_req_flag,
				1,
				USB_CTRL_GET_TIMEOUT);
	if (retval != 1) {
		dev_err(&udev->dev, "Get one byte OTG status failed\n");
		return;
	}

	flag = *fsm->host_req_flag;
	if (flag == 0) {
		/* Continue HNP polling */
		schedule_delayed_work(&fsm->hnp_polling_work,
					msecs_to_jiffies(T_HOST_REQ_POLL));
		return;
	} else if (flag != HOST_REQUEST_FLAG) {
		dev_err(&udev->dev, "host request flag %d is invalid\n", flag);
		return;
	}

	/* Host request flag is set */
	if (state == OTG_STATE_A_HOST) {
		/* Set b_hnp_enable */
		if (!fsm->otg->host->b_hnp_enable) {
			retval = usb_control_msg(udev,
					usb_sndctrlpipe(udev, 0),
					USB_REQ_SET_FEATURE, 0,
					USB_DEVICE_B_HNP_ENABLE,
					0, NULL, 0,
					USB_CTRL_SET_TIMEOUT);
			if (retval >= 0)
				fsm->otg->host->b_hnp_enable = 1;
		}
		fsm->a_bus_req = 0;
	} else if (state == OTG_STATE_B_HOST) {
		fsm->b_bus_req = 0;
	}

	otg_statemachine(fsm);
}

static void otg_start_hnp_polling(struct otg_fsm *fsm)
{
	/*
	 * The memory of host_req_flag should be allocated by
	 * controller driver, otherwise, hnp polling is not started.
	 */
	if (!fsm->host_req_flag)
		return;

	INIT_DELAYED_WORK(&fsm->hnp_polling_work, otg_hnp_polling_work);
	schedule_delayed_work(&fsm->hnp_polling_work,
					msecs_to_jiffies(T_HOST_REQ_POLL));
}

/* Called when entering a state */
static int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
{
	if (fsm->otg->state == new_state)
		return 0;
	VDBG("Set state: %s\n", usb_otg_state_string(new_state));
	otg_leave_state(fsm, fsm->otg->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_sof(fsm, 0);
		otg_set_protocol(fsm, PROTO_GADGET);
		otg_loc_conn(fsm, 1);
		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);
		otg_start_hnp_polling(fsm);
		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);
		otg_start_hnp_polling(fsm);
		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_sof(fsm, 0);
		otg_set_protocol(fsm, PROTO_GADGET);
		otg_drv_vbus(fsm, 1);
		otg_loc_conn(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->state = new_state;
	fsm->state_changed = 1;
	return 0;
}

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

	mutex_lock(&fsm->lock);

	state = fsm->otg->state;
	fsm->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->a_vbus_vld)
			otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
		else if (fsm->id || fsm->a_bus_drop ||
				fsm->a_wait_vrise_tmout)
			otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
		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->id || fsm->a_bus_drop)
			otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
		else 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->b_conn)
			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)
			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", fsm->state_changed);
	return fsm->state_changed;
}
EXPORT_SYMBOL_GPL(otg_statemachine);
MODULE_LICENSE("GPL");
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
ea1d39a3	24	#include <linux/module.h>
0807c500 LY	25	#include <linux/kernel.h>
0807c500 LY	26	#include <linux/types.h>
16e569e9	27	#include <linux/mutex.h>
0807c500 LY	28	#include <linux/delay.h>
	29	#include <linux/usb.h>
	30	#include <linux/usb/gadget.h>
	31	#include <linux/usb/otg.h>
5653668c	32	#include <linux/usb/otg-fsm.h>
0807c500 LY	33
	34	/* Change USB protocol when there is a protocol change */
	35	static int otg_set_protocol(struct otg_fsm *fsm, int protocol)
	36	{
	37	int ret = 0;
	38
	39	if (fsm->protocol != protocol) {
	40	VDBG("Changing role fsm->protocol= %d; new protocol= %d\n",
	41	fsm->protocol, protocol);
	42	/* stop old protocol */
	43	if (fsm->protocol == PROTO_HOST)
425d7101	44	ret = otg_start_host(fsm, 0);
0807c500	45	else if (fsm->protocol == PROTO_GADGET)
425d7101	46	ret = otg_start_gadget(fsm, 0);
0807c500 LY	47	if (ret)
	48	return ret;
	49
	50	/* start new protocol */
	51	if (protocol == PROTO_HOST)
425d7101	52	ret = otg_start_host(fsm, 1);
0807c500	53	else if (protocol == PROTO_GADGET)
425d7101	54	ret = otg_start_gadget(fsm, 1);
0807c500 LY	55	if (ret)
	56	return ret;
	57
	58	fsm->protocol = protocol;
	59	return 0;
	60	}
	61
	62	return 0;
	63	}
	64
0807c500	65	/* Called when leaving a state. Do state clean up jobs here */
7410f172	66	static void otg_leave_state(struct otg_fsm *fsm, enum usb_otg_state old_state)
0807c500 LY	67	{
	68	switch (old_state) {
	69	case OTG_STATE_B_IDLE:
f6de27ee	70	otg_del_timer(fsm, B_SE0_SRP);
0807c500	71	fsm->b_se0_srp = 0;
ec04996a AT	72	fsm->adp_sns = 0;
ec04996a AT	73	fsm->adp_prb = 0;
0807c500 LY	74	break;
0807c500 LY	75	case OTG_STATE_B_SRP_INIT:
ec04996a	76	fsm->data_pulse = 0;
0807c500 LY	77	fsm->b_srp_done = 0;
	78	break;
	79	case OTG_STATE_B_PERIPHERAL:
ae57e97a LJ	80	if (fsm->otg->gadget)
ae57e97a LJ	81	fsm->otg->gadget->host_request_flag = 0;
0807c500 LY	82	break;
0807c500 LY	83	case OTG_STATE_B_WAIT_ACON:
f6de27ee	84	otg_del_timer(fsm, B_ASE0_BRST);
0807c500 LY	85	fsm->b_ase0_brst_tmout = 0;
	86	break;
	87	case OTG_STATE_B_HOST:
	88	break;
	89	case OTG_STATE_A_IDLE:
ec04996a	90	fsm->adp_prb = 0;
0807c500 LY	91	break;
0807c500 LY	92	case OTG_STATE_A_WAIT_VRISE:
f6de27ee	93	otg_del_timer(fsm, A_WAIT_VRISE);
0807c500 LY	94	fsm->a_wait_vrise_tmout = 0;
	95	break;
	96	case OTG_STATE_A_WAIT_BCON:
f6de27ee	97	otg_del_timer(fsm, A_WAIT_BCON);
0807c500 LY	98	fsm->a_wait_bcon_tmout = 0;
	99	break;
	100	case OTG_STATE_A_HOST:
f6de27ee	101	otg_del_timer(fsm, A_WAIT_ENUM);
0807c500 LY	102	break;
0807c500 LY	103	case OTG_STATE_A_SUSPEND:
f6de27ee	104	otg_del_timer(fsm, A_AIDL_BDIS);
0807c500	105	fsm->a_aidl_bdis_tmout = 0;
cff4dab4	106	fsm->a_suspend_req_inf = 0;
0807c500 LY	107	break;
0807c500 LY	108	case OTG_STATE_A_PERIPHERAL:
3294908b AT	109	otg_del_timer(fsm, A_BIDL_ADIS);
3294908b AT	110	fsm->a_bidl_adis_tmout = 0;
ae57e97a LJ	111	if (fsm->otg->gadget)
ae57e97a LJ	112	fsm->otg->gadget->host_request_flag = 0;
0807c500 LY	113	break;
0807c500 LY	114	case OTG_STATE_A_WAIT_VFALL:
3294908b AT	115	otg_del_timer(fsm, A_WAIT_VFALL);
3294908b AT	116	fsm->a_wait_vfall_tmout = 0;
f6de27ee	117	otg_del_timer(fsm, A_WAIT_VRISE);
0807c500 LY	118	break;
	119	case OTG_STATE_A_VBUS_ERR:
	120	break;
	121	default:
	122	break;
	123	}
	124	}
	125
ae57e97a LJ	126	static void otg_hnp_polling_work(struct work_struct *work)
	127	{
	128	struct otg_fsm *fsm = container_of(to_delayed_work(work),
	129	struct otg_fsm, hnp_polling_work);
	130	struct usb_device *udev;
	131	enum usb_otg_state state = fsm->otg->state;
	132	u8 flag;
	133	int retval;
	134
	135	if (state != OTG_STATE_A_HOST && state != OTG_STATE_B_HOST)
	136	return;
	137
	138	udev = usb_hub_find_child(fsm->otg->host->root_hub, 1);
	139	if (!udev) {
	140	dev_err(fsm->otg->host->controller,
	141	"no usb dev connected, can't start HNP polling\n");
	142	return;
	143	}
	144
	145	*fsm->host_req_flag = 0;
	146	/* Get host request flag from connected USB device */
	147	retval = usb_control_msg(udev,
	148	usb_rcvctrlpipe(udev, 0),
	149	USB_REQ_GET_STATUS,
	150	USB_DIR_IN \| USB_RECIP_DEVICE,
	151	0,
	152	OTG_STS_SELECTOR,
	153	fsm->host_req_flag,
	154	1,
	155	USB_CTRL_GET_TIMEOUT);
	156	if (retval != 1) {
	157	dev_err(&udev->dev, "Get one byte OTG status failed\n");
	158	return;
	159	}
	160
	161	flag = *fsm->host_req_flag;
	162	if (flag == 0) {
	163	/* Continue HNP polling */
	164	schedule_delayed_work(&fsm->hnp_polling_work,
	165	msecs_to_jiffies(T_HOST_REQ_POLL));
	166	return;
	167	} else if (flag != HOST_REQUEST_FLAG) {
	168	dev_err(&udev->dev, "host request flag %d is invalid\n", flag);
	169	return;
	170	}
	171
	172	/* Host request flag is set */
	173	if (state == OTG_STATE_A_HOST) {
	174	/* Set b_hnp_enable */
	175	if (!fsm->otg->host->b_hnp_enable) {
	176	retval = usb_control_msg(udev,
	177	usb_sndctrlpipe(udev, 0),
	178	USB_REQ_SET_FEATURE, 0,
	179	USB_DEVICE_B_HNP_ENABLE,
	180	0, NULL, 0,
	181	USB_CTRL_SET_TIMEOUT);
	182	if (retval >= 0)
	183	fsm->otg->host->b_hnp_enable = 1;
	184	}
	185	fsm->a_bus_req = 0;
	186	} else if (state == OTG_STATE_B_HOST) {
	187	fsm->b_bus_req = 0;
	188	}
	189
190	otg_statemachine(fsm);
191	}
192
193	static void otg_start_hnp_polling(struct otg_fsm *fsm)
194	{
195	/*
196	* The memory of host_req_flag should be allocated by
197	* controller driver, otherwise, hnp polling is not started.
198	*/
199	if (!fsm->host_req_flag)
200	return;
201
202	INIT_DELAYED_WORK(&fsm->hnp_polling_work, otg_hnp_polling_work);
203	schedule_delayed_work(&fsm->hnp_polling_work,
204	msecs_to_jiffies(T_HOST_REQ_POLL));
205	}
206
0807c500	207	/* Called when entering a state */
7410f172	208	static int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
0807c500	209	{
e47d9254	210	if (fsm->otg->state == new_state)
0807c500	211	return 0;
42c0bf1c	212	VDBG("Set state: %s\n", usb_otg_state_string(new_state));
e47d9254	213	otg_leave_state(fsm, fsm->otg->state);
0807c500 LY	214	switch (new_state) {
	215	case OTG_STATE_B_IDLE:
	216	otg_drv_vbus(fsm, 0);
	217	otg_chrg_vbus(fsm, 0);
	218	otg_loc_conn(fsm, 0);
	219	otg_loc_sof(fsm, 0);
ec04996a AT	220	/*
	221	* Driver is responsible for starting ADP probing
	222	* if ADP sensing times out.
	223	*/
	224	otg_start_adp_sns(fsm);
0807c500	225	otg_set_protocol(fsm, PROTO_UNDEF);
f6de27ee	226	otg_add_timer(fsm, B_SE0_SRP);
0807c500 LY	227	break;
	228	case OTG_STATE_B_SRP_INIT:
	229	otg_start_pulse(fsm);
	230	otg_loc_sof(fsm, 0);
	231	otg_set_protocol(fsm, PROTO_UNDEF);
f6de27ee	232	otg_add_timer(fsm, B_SRP_FAIL);
0807c500 LY	233	break;
	234	case OTG_STATE_B_PERIPHERAL:
	235	otg_chrg_vbus(fsm, 0);
0807c500 LY	236	otg_loc_sof(fsm, 0);
0807c500 LY	237	otg_set_protocol(fsm, PROTO_GADGET);
a886bd92	238	otg_loc_conn(fsm, 1);
0807c500 LY	239	break;
	240	case OTG_STATE_B_WAIT_ACON:
	241	otg_chrg_vbus(fsm, 0);
	242	otg_loc_conn(fsm, 0);
	243	otg_loc_sof(fsm, 0);
	244	otg_set_protocol(fsm, PROTO_HOST);
f6de27ee	245	otg_add_timer(fsm, B_ASE0_BRST);
0807c500 LY	246	fsm->a_bus_suspend = 0;
	247	break;
	248	case OTG_STATE_B_HOST:
	249	otg_chrg_vbus(fsm, 0);
	250	otg_loc_conn(fsm, 0);
	251	otg_loc_sof(fsm, 1);
	252	otg_set_protocol(fsm, PROTO_HOST);
7e062c0f HK	253	usb_bus_start_enum(fsm->otg->host,
7e062c0f HK	254	fsm->otg->host->otg_port);
ae57e97a	255	otg_start_hnp_polling(fsm);
0807c500 LY	256	break;
	257	case OTG_STATE_A_IDLE:
	258	otg_drv_vbus(fsm, 0);
	259	otg_chrg_vbus(fsm, 0);
	260	otg_loc_conn(fsm, 0);
	261	otg_loc_sof(fsm, 0);
ec04996a	262	otg_start_adp_prb(fsm);
0807c500 LY	263	otg_set_protocol(fsm, PROTO_HOST);
	264	break;
	265	case OTG_STATE_A_WAIT_VRISE:
	266	otg_drv_vbus(fsm, 1);
	267	otg_loc_conn(fsm, 0);
	268	otg_loc_sof(fsm, 0);
	269	otg_set_protocol(fsm, PROTO_HOST);
f6de27ee	270	otg_add_timer(fsm, A_WAIT_VRISE);
0807c500 LY	271	break;
	272	case OTG_STATE_A_WAIT_BCON:
	273	otg_drv_vbus(fsm, 1);
	274	otg_loc_conn(fsm, 0);
	275	otg_loc_sof(fsm, 0);
	276	otg_set_protocol(fsm, PROTO_HOST);
f6de27ee	277	otg_add_timer(fsm, A_WAIT_BCON);
0807c500 LY	278	break;
	279	case OTG_STATE_A_HOST:
	280	otg_drv_vbus(fsm, 1);
	281	otg_loc_conn(fsm, 0);
	282	otg_loc_sof(fsm, 1);
	283	otg_set_protocol(fsm, PROTO_HOST);
	284	/*
	285	* When HNP is triggered while a_bus_req = 0, a_host will
	286	* suspend too fast to complete a_set_b_hnp_en
	287	*/
cff4dab4	288	if (!fsm->a_bus_req \|\| fsm->a_suspend_req_inf)
f6de27ee	289	otg_add_timer(fsm, A_WAIT_ENUM);
ae57e97a	290	otg_start_hnp_polling(fsm);
0807c500 LY	291	break;
	292	case OTG_STATE_A_SUSPEND:
	293	otg_drv_vbus(fsm, 1);
	294	otg_loc_conn(fsm, 0);
	295	otg_loc_sof(fsm, 0);
	296	otg_set_protocol(fsm, PROTO_HOST);
f6de27ee	297	otg_add_timer(fsm, A_AIDL_BDIS);
0807c500 LY	298
	299	break;
	300	case OTG_STATE_A_PERIPHERAL:
0807c500 LY	301	otg_loc_sof(fsm, 0);
	302	otg_set_protocol(fsm, PROTO_GADGET);
	303	otg_drv_vbus(fsm, 1);
a886bd92	304	otg_loc_conn(fsm, 1);
3294908b	305	otg_add_timer(fsm, A_BIDL_ADIS);
0807c500 LY	306	break;
	307	case OTG_STATE_A_WAIT_VFALL:
	308	otg_drv_vbus(fsm, 0);
	309	otg_loc_conn(fsm, 0);
	310	otg_loc_sof(fsm, 0);
	311	otg_set_protocol(fsm, PROTO_HOST);
3294908b	312	otg_add_timer(fsm, A_WAIT_VFALL);
0807c500 LY	313	break;
	314	case OTG_STATE_A_VBUS_ERR:
	315	otg_drv_vbus(fsm, 0);
	316	otg_loc_conn(fsm, 0);
	317	otg_loc_sof(fsm, 0);
	318	otg_set_protocol(fsm, PROTO_UNDEF);
	319	break;
	320	default:
	321	break;
	322	}
	323
e47d9254	324	fsm->otg->state = new_state;
4e332df6	325	fsm->state_changed = 1;
0807c500 LY	326	return 0;
	327	}
	328
	329	/* State change judgement */
	330	int otg_statemachine(struct otg_fsm *fsm)
	331	{
	332	enum usb_otg_state state;
0807c500	333
16e569e9	334	mutex_lock(&fsm->lock);
0807c500	335
e47d9254	336	state = fsm->otg->state;
4e332df6	337	fsm->state_changed = 0;
0807c500 LY	338	/* State machine state change judgement */
	339
	340	switch (state) {
	341	case OTG_STATE_UNDEFINED:
	342	VDBG("fsm->id = %d\n", fsm->id);
	343	if (fsm->id)
	344	otg_set_state(fsm, OTG_STATE_B_IDLE);
	345	else
	346	otg_set_state(fsm, OTG_STATE_A_IDLE);
	347	break;
	348	case OTG_STATE_B_IDLE:
	349	if (!fsm->id)
	350	otg_set_state(fsm, OTG_STATE_A_IDLE);
7e062c0f	351	else if (fsm->b_sess_vld && fsm->otg->gadget)
0807c500	352	otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
ec04996a AT	353	else if ((fsm->b_bus_req \|\| fsm->adp_change \|\| fsm->power_up) &&
ec04996a AT	354	fsm->b_ssend_srp && fsm->b_se0_srp)
0807c500 LY	355	otg_set_state(fsm, OTG_STATE_B_SRP_INIT);
	356	break;
	357	case OTG_STATE_B_SRP_INIT:
	358	if (!fsm->id \|\| fsm->b_srp_done)
	359	otg_set_state(fsm, OTG_STATE_B_IDLE);
	360	break;
	361	case OTG_STATE_B_PERIPHERAL:
	362	if (!fsm->id \|\| !fsm->b_sess_vld)
	363	otg_set_state(fsm, OTG_STATE_B_IDLE);
7e062c0f	364	else if (fsm->b_bus_req && fsm->otg->
0807c500 LY	365	gadget->b_hnp_enable && fsm->a_bus_suspend)
	366	otg_set_state(fsm, OTG_STATE_B_WAIT_ACON);
	367	break;
	368	case OTG_STATE_B_WAIT_ACON:
	369	if (fsm->a_conn)
	370	otg_set_state(fsm, OTG_STATE_B_HOST);
	371	else if (!fsm->id \|\| !fsm->b_sess_vld)
	372	otg_set_state(fsm, OTG_STATE_B_IDLE);
	373	else if (fsm->a_bus_resume \|\| fsm->b_ase0_brst_tmout) {
	374	fsm->b_ase0_brst_tmout = 0;
	375	otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
	376	}
	377	break;
	378	case OTG_STATE_B_HOST:
	379	if (!fsm->id \|\| !fsm->b_sess_vld)
	380	otg_set_state(fsm, OTG_STATE_B_IDLE);
ec04996a	381	else if (!fsm->b_bus_req \|\| !fsm->a_conn \|\| fsm->test_device)
0807c500 LY	382	otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
	383	break;
	384	case OTG_STATE_A_IDLE:
	385	if (fsm->id)
	386	otg_set_state(fsm, OTG_STATE_B_IDLE);
ec04996a AT	387	else if (!fsm->a_bus_drop && (fsm->a_bus_req \|\|
ec04996a AT	388	fsm->a_srp_det \|\| fsm->adp_change \|\| fsm->power_up))
0807c500 LY	389	otg_set_state(fsm, OTG_STATE_A_WAIT_VRISE);
	390	break;
	391	case OTG_STATE_A_WAIT_VRISE:
2284bb35	392	if (fsm->a_vbus_vld)
0807c500	393	otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
2284bb35 LJ	394	else if (fsm->id \|\| fsm->a_bus_drop \|\|
	395	fsm->a_wait_vrise_tmout)
	396	otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
0807c500 LY	397	break;
	398	case OTG_STATE_A_WAIT_BCON:
	399	if (!fsm->a_vbus_vld)
	400	otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
	401	else if (fsm->b_conn)
	402	otg_set_state(fsm, OTG_STATE_A_HOST);
66668991	403	else if (fsm->id \|\| fsm->a_bus_drop \|\| fsm->a_wait_bcon_tmout)
0807c500 LY	404	otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
	405	break;
	406	case OTG_STATE_A_HOST:
8bebbe8d LJ	407	if (fsm->id \|\| fsm->a_bus_drop)
	408	otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
	409	else if ((!fsm->a_bus_req \|\| fsm->a_suspend_req_inf) &&
7e062c0f	410	fsm->otg->host->b_hnp_enable)
0807c500	411	otg_set_state(fsm, OTG_STATE_A_SUSPEND);
8bebbe8d	412	else if (!fsm->b_conn)
0807c500 LY	413	otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
	414	else if (!fsm->a_vbus_vld)
	415	otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
	416	break;
	417	case OTG_STATE_A_SUSPEND:
7e062c0f	418	if (!fsm->b_conn && fsm->otg->host->b_hnp_enable)
0807c500	419	otg_set_state(fsm, OTG_STATE_A_PERIPHERAL);
7e062c0f	420	else if (!fsm->b_conn && !fsm->otg->host->b_hnp_enable)
0807c500 LY	421	otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
	422	else if (fsm->a_bus_req \|\| fsm->b_bus_resume)
	423	otg_set_state(fsm, OTG_STATE_A_HOST);
	424	else if (fsm->id \|\| fsm->a_bus_drop \|\| fsm->a_aidl_bdis_tmout)
	425	otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
	426	else if (!fsm->a_vbus_vld)
	427	otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
	428	break;
	429	case OTG_STATE_A_PERIPHERAL:
	430	if (fsm->id \|\| fsm->a_bus_drop)
	431	otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
3294908b	432	else if (fsm->a_bidl_adis_tmout \|\| fsm->b_bus_suspend)
0807c500 LY	433	otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
	434	else if (!fsm->a_vbus_vld)
	435	otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
	436	break;
	437	case OTG_STATE_A_WAIT_VFALL:
8bebbe8d	438	if (fsm->a_wait_vfall_tmout)
0807c500 LY	439	otg_set_state(fsm, OTG_STATE_A_IDLE);
	440	break;
	441	case OTG_STATE_A_VBUS_ERR:
	442	if (fsm->id \|\| fsm->a_bus_drop \|\| fsm->a_clr_err)
	443	otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
	444	break;
	445	default:
	446	break;
	447	}
16da4b17	448	mutex_unlock(&fsm->lock);
0807c500	449
4e332df6 RQ	450	VDBG("quit statemachine, changed = %d\n", fsm->state_changed);
4e332df6 RQ	451	return fsm->state_changed;
0807c500	452	}
be696aac	453	EXPORT_SYMBOL_GPL(otg_statemachine);
ea1d39a3	454	MODULE_LICENSE("GPL");