drivers/usb/otg/langwell_otg.c

/*
 * Intel Langwell USB OTG transceiver driver
 * Copyright (C) 2008 - 2009, Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope 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.,
 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */
/* This driver helps to switch Langwell OTG controller function between host
 * and peripheral. It works with EHCI driver and Langwell client controller
 * driver together.
 */
#include <linux/module.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/moduleparam.h>
#include <linux/usb/ch9.h>
#include <linux/usb/gadget.h>
#include <linux/usb.h>
#include <linux/usb/otg.h>
#include <linux/notifier.h>
#include <asm/ipc_defs.h>
#include <linux/delay.h>
#include "../core/hcd.h"

#include <linux/usb/langwell_otg.h>

#define	DRIVER_DESC		"Intel Langwell USB OTG transceiver driver"
#define	DRIVER_VERSION		"3.0.0.32L.0002"

MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_AUTHOR("Henry Yuan <hang.yuan@intel.com>, Hao Wu <hao.wu@intel.com>");
MODULE_VERSION(DRIVER_VERSION);
MODULE_LICENSE("GPL");

static const char driver_name[] = "langwell_otg";

static int langwell_otg_probe(struct pci_dev *pdev,
			const struct pci_device_id *id);
static void langwell_otg_remove(struct pci_dev *pdev);
static int langwell_otg_suspend(struct pci_dev *pdev, pm_message_t message);
static int langwell_otg_resume(struct pci_dev *pdev);

static int langwell_otg_set_host(struct otg_transceiver *otg,
				struct usb_bus *host);
static int langwell_otg_set_peripheral(struct otg_transceiver *otg,
				struct usb_gadget *gadget);
static int langwell_otg_start_srp(struct otg_transceiver *otg);

static const struct pci_device_id pci_ids[] = {{
	.class =        ((PCI_CLASS_SERIAL_USB << 8) | 0xfe),
	.class_mask =   ~0,
	.vendor =	0x8086,
	.device =	0x0811,
	.subvendor =	PCI_ANY_ID,
	.subdevice =	PCI_ANY_ID,
}, { /* end: all zeroes */ }
};

static struct pci_driver otg_pci_driver = {
	.name =		(char *) driver_name,
	.id_table =	pci_ids,

	.probe =	langwell_otg_probe,
	.remove =	langwell_otg_remove,

	.suspend =	langwell_otg_suspend,
	.resume =	langwell_otg_resume,
};

static const char *state_string(enum usb_otg_state state)
{
	switch (state) {
	case OTG_STATE_A_IDLE:
		return "a_idle";
	case OTG_STATE_A_WAIT_VRISE:
		return "a_wait_vrise";
	case OTG_STATE_A_WAIT_BCON:
		return "a_wait_bcon";
	case OTG_STATE_A_HOST:
		return "a_host";
	case OTG_STATE_A_SUSPEND:
		return "a_suspend";
	case OTG_STATE_A_PERIPHERAL:
		return "a_peripheral";
	case OTG_STATE_A_WAIT_VFALL:
		return "a_wait_vfall";
	case OTG_STATE_A_VBUS_ERR:
		return "a_vbus_err";
	case OTG_STATE_B_IDLE:
		return "b_idle";
	case OTG_STATE_B_SRP_INIT:
		return "b_srp_init";
	case OTG_STATE_B_PERIPHERAL:
		return "b_peripheral";
	case OTG_STATE_B_WAIT_ACON:
		return "b_wait_acon";
	case OTG_STATE_B_HOST:
		return "b_host";
	default:
		return "UNDEFINED";
	}
}

/* HSM timers */
static inline struct langwell_otg_timer *otg_timer_initializer
(void (*function)(unsigned long), unsigned long expires, unsigned long data)
{
	struct langwell_otg_timer *timer;
	timer = kmalloc(sizeof(struct langwell_otg_timer), GFP_KERNEL);
	timer->function = function;
	timer->expires = expires;
	timer->data = data;
	return timer;
}

static struct langwell_otg_timer *a_wait_vrise_tmr, *a_wait_bcon_tmr,
	*a_aidl_bdis_tmr, *b_ase0_brst_tmr, *b_se0_srp_tmr, *b_srp_res_tmr,
	*b_bus_suspend_tmr;

static struct list_head active_timers;

static struct langwell_otg *the_transceiver;

/* host/client notify transceiver when event affects HNP state */
void langwell_update_transceiver()
{
	otg_dbg("transceiver driver is notified\n");
	queue_work(the_transceiver->qwork, &the_transceiver->work);
}
EXPORT_SYMBOL(langwell_update_transceiver);

static int langwell_otg_set_host(struct otg_transceiver *otg,
					struct usb_bus *host)
{
	otg->host = host;

	return 0;
}

static int langwell_otg_set_peripheral(struct otg_transceiver *otg,
					struct usb_gadget *gadget)
{
	otg->gadget = gadget;

	return 0;
}

static int langwell_otg_set_power(struct otg_transceiver *otg,
				unsigned mA)
{
	return 0;
}

/* A-device drives vbus, controlled through PMIC CHRGCNTL register*/
static void langwell_otg_drv_vbus(int on)
{
	struct ipc_pmic_reg_data	pmic_data = {0};
	struct ipc_pmic_reg_data	battery_data;

	/* Check if battery is attached or not */
	battery_data.pmic_reg_data[0].register_address = 0xd2;
	battery_data.ioc = 0;
	battery_data.num_entries = 1;
	if (ipc_pmic_register_read(&battery_data)) {
		otg_dbg("Failed to read PMIC register 0xd2.\n");
		return;
	}

	if ((battery_data.pmic_reg_data[0].value & 0x20) == 0) {
		otg_dbg("no battery attached\n");
		return;
	}

	/* Workaround for battery attachment issue */
	if (battery_data.pmic_reg_data[0].value == 0x34) {
		otg_dbg("battery \n");
		return;
	}

	otg_dbg("battery attached\n");

	pmic_data.ioc = 0;
	pmic_data.pmic_reg_data[0].register_address = 0xD4;
	pmic_data.num_entries = 1;
	if (on)
		pmic_data.pmic_reg_data[0].value = 0x20;
	else
		pmic_data.pmic_reg_data[0].value = 0xc0;

	if (ipc_pmic_register_write(&pmic_data, TRUE))
		otg_dbg("Failed to write PMIC.\n");

}

/* charge vbus or discharge vbus through a resistor to ground */
static void langwell_otg_chrg_vbus(int on)
{

	u32	val;

	val = readl(the_transceiver->regs + CI_OTGSC);

	if (on)
		writel((val & ~OTGSC_INTSTS_MASK) | OTGSC_VC,
				the_transceiver->regs + CI_OTGSC);
	else
		writel((val & ~OTGSC_INTSTS_MASK) | OTGSC_VD,
				the_transceiver->regs + CI_OTGSC);

}

/* Start SRP */
static int langwell_otg_start_srp(struct otg_transceiver *otg)
{
	u32	val;

	otg_dbg("Start SRP ->\n");

	val = readl(the_transceiver->regs + CI_OTGSC);

	writel((val & ~OTGSC_INTSTS_MASK) | OTGSC_HADP,
		the_transceiver->regs + CI_OTGSC);

	/* Check if the data plus is finished or not */
	msleep(8);
	val = readl(the_transceiver->regs + CI_OTGSC);
	if (val & (OTGSC_HADP | OTGSC_DP))
		otg_dbg("DataLine SRP Error\n");

	/* FIXME: VBus SRP */

	return 0;
}


/* stop SOF via bus_suspend */
static void langwell_otg_loc_sof(int on)
{
	struct usb_hcd	*hcd;
	int		err;

	otg_dbg("loc_sof -> %d\n", on);

	hcd = bus_to_hcd(the_transceiver->otg.host);
	if (on)
		err = hcd->driver->bus_resume(hcd);
	else
		err = hcd->driver->bus_suspend(hcd);

	if (err)
		otg_dbg("Failed to resume/suspend bus - %d\n", err);
}

static void langwell_otg_phy_low_power(int on)
{
	u32	val;

	otg_dbg("phy low power mode-> %d\n", on);

	val = readl(the_transceiver->regs + CI_HOSTPC1);
	if (on)
		writel(val | HOSTPC1_PHCD, the_transceiver->regs + CI_HOSTPC1);
	else
		writel(val & ~HOSTPC1_PHCD, the_transceiver->regs + CI_HOSTPC1);
}

/* Enable/Disable OTG interrupt */
static void langwell_otg_intr(int on)
{
	u32 val;

	otg_dbg("interrupt -> %d\n", on);

	val = readl(the_transceiver->regs + CI_OTGSC);
	if (on) {
		val = val | (OTGSC_INTEN_MASK | OTGSC_IDPU);
		writel(val, the_transceiver->regs + CI_OTGSC);
	} else {
		val = val & ~(OTGSC_INTEN_MASK | OTGSC_IDPU);
		writel(val, the_transceiver->regs + CI_OTGSC);
	}
}

/* set HAAR: Hardware Assist Auto-Reset */
static void langwell_otg_HAAR(int on)
{
	u32	val;

	otg_dbg("HAAR -> %d\n", on);

	val = readl(the_transceiver->regs + CI_OTGSC);
	if (on)
		writel((val & ~OTGSC_INTSTS_MASK) | OTGSC_HAAR,
				the_transceiver->regs + CI_OTGSC);
	else
		writel((val & ~OTGSC_INTSTS_MASK) & ~OTGSC_HAAR,
				the_transceiver->regs + CI_OTGSC);
}

/* set HABA: Hardware Assist B-Disconnect to A-Connect */
static void langwell_otg_HABA(int on)
{
	u32	val;

	otg_dbg("HABA -> %d\n", on);

	val = readl(the_transceiver->regs + CI_OTGSC);
	if (on)
		writel((val & ~OTGSC_INTSTS_MASK) | OTGSC_HABA,
				the_transceiver->regs + CI_OTGSC);
	else
		writel((val & ~OTGSC_INTSTS_MASK) & ~OTGSC_HABA,
				the_transceiver->regs + CI_OTGSC);
}

static int langwell_otg_check_se0_srp(int on)
{
	u32 val;

	int delay_time = TB_SE0_SRP * 10; /* step is 100us */

	otg_dbg("check_se0_srp -> \n");

	do {
		udelay(100);
		if (!delay_time--)
			break;
		val = readl(the_transceiver->regs + CI_PORTSC1);
		val &= PORTSC_LS;
	} while (!val);

	otg_dbg("check_se0_srp <- \n");
	return val;
}

/* The timeout callback function to set time out bit */
static void set_tmout(unsigned long indicator)
{
	*(int *)indicator = 1;
}

void langwell_otg_nsf_msg(unsigned long indicator)
{
	switch (indicator) {
	case 2:
	case 4:
	case 6:
	case 7:
		printk(KERN_ERR "OTG:NSF-%lu - deivce not responding\n",
				indicator);
		break;
	case 3:
		printk(KERN_ERR "OTG:NSF-%lu - deivce not supported\n",
				indicator);
		break;
	default:
		printk(KERN_ERR "Do not have this kind of NSF\n");
		break;
	}
}

/* Initialize timers */
static void langwell_otg_init_timers(struct otg_hsm *hsm)
{
	/* HSM used timers */
	a_wait_vrise_tmr = otg_timer_initializer(&set_tmout, TA_WAIT_VRISE,
				(unsigned long)&hsm->a_wait_vrise_tmout);
	a_wait_bcon_tmr = otg_timer_initializer(&set_tmout, TA_WAIT_BCON,
				(unsigned long)&hsm->a_wait_bcon_tmout);
	a_aidl_bdis_tmr = otg_timer_initializer(&set_tmout, TA_AIDL_BDIS,
				(unsigned long)&hsm->a_aidl_bdis_tmout);
	b_ase0_brst_tmr = otg_timer_initializer(&set_tmout, TB_ASE0_BRST,
				(unsigned long)&hsm->b_ase0_brst_tmout);
	b_se0_srp_tmr = otg_timer_initializer(&set_tmout, TB_SE0_SRP,
				(unsigned long)&hsm->b_se0_srp);
	b_srp_res_tmr = otg_timer_initializer(&set_tmout, TB_SRP_RES,
				(unsigned long)&hsm->b_srp_res_tmout);
	b_bus_suspend_tmr = otg_timer_initializer(&set_tmout, TB_BUS_SUSPEND,
				(unsigned long)&hsm->b_bus_suspend_tmout);
}

/* Free timers */
static void langwell_otg_free_timers(void)
{
	kfree(a_wait_vrise_tmr);
	kfree(a_wait_bcon_tmr);
	kfree(a_aidl_bdis_tmr);
	kfree(b_ase0_brst_tmr);
	kfree(b_se0_srp_tmr);
	kfree(b_srp_res_tmr);
	kfree(b_bus_suspend_tmr);
}

/* Add timer to timer list */
static void langwell_otg_add_timer(void *gtimer)
{
	struct langwell_otg_timer *timer = (struct langwell_otg_timer *)gtimer;
	struct langwell_otg_timer *tmp_timer;
	u32	val32;

	/* Check if the timer is already in the active list,
	 * if so update timer count
	 */
	list_for_each_entry(tmp_timer, &active_timers, list)
		if (tmp_timer == timer) {
			timer->count = timer->expires;
			return;
		}
	timer->count = timer->expires;

	if (list_empty(&active_timers)) {
		val32 = readl(the_transceiver->regs + CI_OTGSC);
		writel(val32 | OTGSC_1MSE, the_transceiver->regs + CI_OTGSC);
	}

	list_add_tail(&timer->list, &active_timers);
}

/* Remove timer from the timer list; clear timeout status */
static void langwell_otg_del_timer(void *gtimer)
{
	struct langwell_otg_timer *timer = (struct langwell_otg_timer *)gtimer;
	struct langwell_otg_timer *tmp_timer, *del_tmp;
	u32 val32;

	list_for_each_entry_safe(tmp_timer, del_tmp, &active_timers, list)
		if (tmp_timer == timer)
			list_del(&timer->list);

	if (list_empty(&active_timers)) {
		val32 = readl(the_transceiver->regs + CI_OTGSC);
		writel(val32 & ~OTGSC_1MSE, the_transceiver->regs + CI_OTGSC);
	}
}

/* Reduce timer count by 1, and find timeout conditions.*/
static int langwell_otg_tick_timer(u32 *int_sts)
{
	struct langwell_otg_timer *tmp_timer, *del_tmp;
	int expired = 0;

	list_for_each_entry_safe(tmp_timer, del_tmp, &active_timers, list) {
		tmp_timer->count--;
		/* check if timer expires */
		if (!tmp_timer->count) {
			list_del(&tmp_timer->list);
			tmp_timer->function(tmp_timer->data);
			expired = 1;
		}
	}

	if (list_empty(&active_timers)) {
		otg_dbg("tick timer: disable 1ms int\n");
		*int_sts = *int_sts & ~OTGSC_1MSE;
	}
	return expired;
}

static void reset_otg(void)
{
	u32	val;
	int	delay_time = 1000;

	otg_dbg("reseting OTG controller ...\n");
	val = readl(the_transceiver->regs + CI_USBCMD);
	writel(val | USBCMD_RST, the_transceiver->regs + CI_USBCMD);
	do {
		udelay(100);
		if (!delay_time--)
			otg_dbg("reset timeout\n");
		val = readl(the_transceiver->regs + CI_USBCMD);
		val &= USBCMD_RST;
	} while (val != 0);
	otg_dbg("reset done.\n");
}

static void set_host_mode(void)
{
	u32 	val;

	reset_otg();
	val = readl(the_transceiver->regs + CI_USBMODE);
	val = (val & (~USBMODE_CM)) | USBMODE_HOST;
	writel(val, the_transceiver->regs + CI_USBMODE);
}

static void set_client_mode(void)
{
	u32 	val;

	reset_otg();
	val = readl(the_transceiver->regs + CI_USBMODE);
	val = (val & (~USBMODE_CM)) | USBMODE_DEVICE;
	writel(val, the_transceiver->regs + CI_USBMODE);
}

static void init_hsm(void)
{
	struct langwell_otg	*langwell = the_transceiver;
	u32			val32;

	/* read OTGSC after reset */
	val32 = readl(langwell->regs + CI_OTGSC);
	otg_dbg("%s: OTGSC init value = 0x%x\n", __func__, val32);

	/* set init state */
	if (val32 & OTGSC_ID) {
		langwell->hsm.id = 1;
		langwell->otg.default_a = 0;
		set_client_mode();
		langwell->otg.state = OTG_STATE_B_IDLE;
		langwell_otg_drv_vbus(0);
	} else {
		langwell->hsm.id = 0;
		langwell->otg.default_a = 1;
		set_host_mode();
		langwell->otg.state = OTG_STATE_A_IDLE;
	}

	/* set session indicator */
	if (val32 & OTGSC_BSE)
		langwell->hsm.b_sess_end = 1;
	if (val32 & OTGSC_BSV)
		langwell->hsm.b_sess_vld = 1;
	if (val32 & OTGSC_ASV)
		langwell->hsm.a_sess_vld = 1;
	if (val32 & OTGSC_AVV)
		langwell->hsm.a_vbus_vld = 1;

	/* defautly power the bus */
	langwell->hsm.a_bus_req = 1;
	langwell->hsm.a_bus_drop = 0;
	/* defautly don't request bus as B device */
	langwell->hsm.b_bus_req = 0;
	/* no system error */
	langwell->hsm.a_clr_err = 0;
}

static irqreturn_t otg_dummy_irq(int irq, void *_dev)
{
	void __iomem	*reg_base = _dev;
	u32	val;
	u32	int_mask = 0;

	val = readl(reg_base + CI_USBMODE);
	if ((val & USBMODE_CM) != USBMODE_DEVICE)
		return IRQ_NONE;

	val = readl(reg_base + CI_USBSTS);
	int_mask = val & INTR_DUMMY_MASK;

	if (int_mask == 0)
		return IRQ_NONE;

	/* clear hsm.b_conn here since host driver can't detect it
	*  otg_dummy_irq called means B-disconnect happened.
	*/
	if (the_transceiver->hsm.b_conn) {
		the_transceiver->hsm.b_conn = 0;
		if (spin_trylock(&the_transceiver->wq_lock)) {
			queue_work(the_transceiver->qwork,
				&the_transceiver->work);
			spin_unlock(&the_transceiver->wq_lock);
		}
	}
	/* Clear interrupts */
	writel(int_mask, reg_base + CI_USBSTS);
	return IRQ_HANDLED;
}

static irqreturn_t otg_irq(int irq, void *_dev)
{
	struct	langwell_otg *langwell = _dev;
	u32	int_sts, int_en;
	u32	int_mask = 0;
	int	flag = 0;

	int_sts = readl(langwell->regs + CI_OTGSC);
	int_en = (int_sts & OTGSC_INTEN_MASK) >> 8;
	int_mask = int_sts & int_en;
	if (int_mask == 0)
		return IRQ_NONE;

	if (int_mask & OTGSC_IDIS) {
		otg_dbg("%s: id change int\n", __func__);
		langwell->hsm.id = (int_sts & OTGSC_ID) ? 1 : 0;
		flag = 1;
	}
	if (int_mask & OTGSC_DPIS) {
		otg_dbg("%s: data pulse int\n", __func__);
		langwell->hsm.a_srp_det = (int_sts & OTGSC_DPS) ? 1 : 0;
		flag = 1;
	}
	if (int_mask & OTGSC_BSEIS) {
		otg_dbg("%s: b session end int\n", __func__);
		langwell->hsm.b_sess_end = (int_sts & OTGSC_BSE) ? 1 : 0;
		flag = 1;
	}
	if (int_mask & OTGSC_BSVIS) {
		otg_dbg("%s: b session valid int\n", __func__);
		langwell->hsm.b_sess_vld = (int_sts & OTGSC_BSV) ? 1 : 0;
		flag = 1;
	}
	if (int_mask & OTGSC_ASVIS) {
		otg_dbg("%s: a session valid int\n", __func__);
		langwell->hsm.a_sess_vld = (int_sts & OTGSC_ASV) ? 1 : 0;
		flag = 1;
	}
	if (int_mask & OTGSC_AVVIS) {
		otg_dbg("%s: a vbus valid int\n", __func__);
		langwell->hsm.a_vbus_vld = (int_sts & OTGSC_AVV) ? 1 : 0;
		flag = 1;
	}

	if (int_mask & OTGSC_1MSS) {
		/* need to schedule otg_work if any timer is expired */
		if (langwell_otg_tick_timer(&int_sts))
			flag = 1;
	}

	writel((int_sts & ~OTGSC_INTSTS_MASK) | int_mask,
			langwell->regs + CI_OTGSC);
	if (flag)
		queue_work(langwell->qwork, &langwell->work);

	return IRQ_HANDLED;
}

static void langwell_otg_work(struct work_struct *work)
{
	struct langwell_otg *langwell = container_of(work,
					struct langwell_otg, work);
	int	retval;

	otg_dbg("%s: old state = %s\n", __func__,
			state_string(langwell->otg.state));

	switch (langwell->otg.state) {
	case OTG_STATE_UNDEFINED:
	case OTG_STATE_B_IDLE:
		if (!langwell->hsm.id) {
			langwell_otg_del_timer(b_srp_res_tmr);
			langwell->otg.default_a = 1;
			langwell->hsm.a_srp_det = 0;

			langwell_otg_chrg_vbus(0);
			langwell_otg_drv_vbus(0);

			set_host_mode();
			langwell->otg.state = OTG_STATE_A_IDLE;
			queue_work(langwell->qwork, &langwell->work);
		} else if (langwell->hsm.b_srp_res_tmout) {
			langwell->hsm.b_srp_res_tmout = 0;
			langwell->hsm.b_bus_req = 0;
			langwell_otg_nsf_msg(6);
		} else if (langwell->hsm.b_sess_vld) {
			langwell_otg_del_timer(b_srp_res_tmr);
			langwell->hsm.b_sess_end = 0;
			langwell->hsm.a_bus_suspend = 0;

			langwell_otg_chrg_vbus(0);
			if (langwell->client_ops) {
				langwell->client_ops->resume(langwell->pdev);
				langwell->otg.state = OTG_STATE_B_PERIPHERAL;
			} else
				otg_dbg("client driver not loaded.\n");

		} else if (langwell->hsm.b_bus_req &&
				(langwell->hsm.b_sess_end)) {
			/* workaround for b_se0_srp detection */
			retval = langwell_otg_check_se0_srp(0);
			if (retval) {
				langwell->hsm.b_bus_req = 0;
				otg_dbg("LS is not SE0, try again later\n");
			} else {
				/* Start SRP */
				langwell_otg_start_srp(&langwell->otg);
				langwell_otg_add_timer(b_srp_res_tmr);
			}
		}
		break;
	case OTG_STATE_B_SRP_INIT:
		if (!langwell->hsm.id) {
			langwell->otg.default_a = 1;
			langwell->hsm.a_srp_det = 0;

			langwell_otg_drv_vbus(0);
			langwell_otg_chrg_vbus(0);

			langwell->otg.state = OTG_STATE_A_IDLE;
			queue_work(langwell->qwork, &langwell->work);
		} else if (langwell->hsm.b_sess_vld) {
			langwell_otg_chrg_vbus(0);
			if (langwell->client_ops) {
				langwell->client_ops->resume(langwell->pdev);
				langwell->otg.state = OTG_STATE_B_PERIPHERAL;
			} else
				otg_dbg("client driver not loaded.\n");
		}
		break;
	case OTG_STATE_B_PERIPHERAL:
		if (!langwell->hsm.id) {
			langwell->otg.default_a = 1;
			langwell->hsm.a_srp_det = 0;

			langwell_otg_drv_vbus(0);
			langwell_otg_chrg_vbus(0);
			set_host_mode();

			if (langwell->client_ops) {
				langwell->client_ops->suspend(langwell->pdev,
					PMSG_FREEZE);
			} else
				otg_dbg("client driver has been removed.\n");

			langwell->otg.state = OTG_STATE_A_IDLE;
			queue_work(langwell->qwork, &langwell->work);
		} else if (!langwell->hsm.b_sess_vld) {
			langwell->hsm.b_hnp_enable = 0;

			if (langwell->client_ops) {
				langwell->client_ops->suspend(langwell->pdev,
					PMSG_FREEZE);
			} else
				otg_dbg("client driver has been removed.\n");

			langwell->otg.state = OTG_STATE_B_IDLE;
		} else if (langwell->hsm.b_bus_req && langwell->hsm.b_hnp_enable
			&& langwell->hsm.a_bus_suspend) {

			if (langwell->client_ops) {
				langwell->client_ops->suspend(langwell->pdev,
					PMSG_FREEZE);
			} else
				otg_dbg("client driver has been removed.\n");

			langwell_otg_HAAR(1);
			langwell->hsm.a_conn = 0;

			if (langwell->host_ops) {
				langwell->host_ops->probe(langwell->pdev,
					langwell->host_ops->id_table);
				langwell->otg.state = OTG_STATE_B_WAIT_ACON;
			} else
				otg_dbg("host driver not loaded.\n");

			langwell->hsm.a_bus_resume = 0;
			langwell->hsm.b_ase0_brst_tmout = 0;
			langwell_otg_add_timer(b_ase0_brst_tmr);
		}
		break;

	case OTG_STATE_B_WAIT_ACON:
		if (!langwell->hsm.id) {
			langwell_otg_del_timer(b_ase0_brst_tmr);
			langwell->otg.default_a = 1;
			langwell->hsm.a_srp_det = 0;

			langwell_otg_drv_vbus(0);
			langwell_otg_chrg_vbus(0);
			set_host_mode();

			langwell_otg_HAAR(0);
			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");
			langwell->otg.state = OTG_STATE_A_IDLE;
			queue_work(langwell->qwork, &langwell->work);
		} else if (!langwell->hsm.b_sess_vld) {
			langwell_otg_del_timer(b_ase0_brst_tmr);
			langwell->hsm.b_hnp_enable = 0;
			langwell->hsm.b_bus_req = 0;
			langwell_otg_chrg_vbus(0);
			langwell_otg_HAAR(0);

			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");
			langwell->otg.state = OTG_STATE_B_IDLE;
		} else if (langwell->hsm.a_conn) {
			langwell_otg_del_timer(b_ase0_brst_tmr);
			langwell_otg_HAAR(0);
			langwell->otg.state = OTG_STATE_B_HOST;
			queue_work(langwell->qwork, &langwell->work);
		} else if (langwell->hsm.a_bus_resume ||
				langwell->hsm.b_ase0_brst_tmout) {
			langwell_otg_del_timer(b_ase0_brst_tmr);
			langwell_otg_HAAR(0);
			langwell_otg_nsf_msg(7);

			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");

			langwell->hsm.a_bus_suspend = 0;
			langwell->hsm.b_bus_req = 0;

			if (langwell->client_ops)
				langwell->client_ops->resume(langwell->pdev);
			else
				otg_dbg("client driver not loaded.\n");

			langwell->otg.state = OTG_STATE_B_PERIPHERAL;
		}
		break;

	case OTG_STATE_B_HOST:
		if (!langwell->hsm.id) {
			langwell->otg.default_a = 1;
			langwell->hsm.a_srp_det = 0;

			langwell_otg_drv_vbus(0);
			langwell_otg_chrg_vbus(0);
			set_host_mode();
			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");
			langwell->otg.state = OTG_STATE_A_IDLE;
			queue_work(langwell->qwork, &langwell->work);
		} else if (!langwell->hsm.b_sess_vld) {
			langwell->hsm.b_hnp_enable = 0;
			langwell->hsm.b_bus_req = 0;
			langwell_otg_chrg_vbus(0);
			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");
			langwell->otg.state = OTG_STATE_B_IDLE;
		} else if ((!langwell->hsm.b_bus_req) ||
				(!langwell->hsm.a_conn)) {
			langwell->hsm.b_bus_req = 0;
			langwell_otg_loc_sof(0);
			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");

			langwell->hsm.a_bus_suspend = 0;

			if (langwell->client_ops)
				langwell->client_ops->resume(langwell->pdev);
			else
				otg_dbg("client driver not loaded.\n");

			langwell->otg.state = OTG_STATE_B_PERIPHERAL;
		}
		break;

	case OTG_STATE_A_IDLE:
		langwell->otg.default_a = 1;
		if (langwell->hsm.id) {
			langwell->otg.default_a = 0;
			langwell->hsm.b_bus_req = 0;
			langwell_otg_drv_vbus(0);
			langwell_otg_chrg_vbus(0);

			langwell->otg.state = OTG_STATE_B_IDLE;
			queue_work(langwell->qwork, &langwell->work);
		} else if (langwell->hsm.a_sess_vld) {
			langwell_otg_drv_vbus(1);
			langwell->hsm.a_srp_det = 1;
			langwell->hsm.a_wait_vrise_tmout = 0;
			langwell_otg_add_timer(a_wait_vrise_tmr);
			langwell->otg.state = OTG_STATE_A_WAIT_VRISE;
			queue_work(langwell->qwork, &langwell->work);
		} else if (!langwell->hsm.a_bus_drop &&
			(langwell->hsm.a_srp_det || langwell->hsm.a_bus_req)) {
			langwell_otg_drv_vbus(1);
			langwell->hsm.a_wait_vrise_tmout = 0;
			langwell_otg_add_timer(a_wait_vrise_tmr);
			langwell->otg.state = OTG_STATE_A_WAIT_VRISE;
			queue_work(langwell->qwork, &langwell->work);
		}
		break;
	case OTG_STATE_A_WAIT_VRISE:
		if (langwell->hsm.id) {
			langwell_otg_del_timer(a_wait_vrise_tmr);
			langwell->hsm.b_bus_req = 0;
			langwell->otg.default_a = 0;
			langwell_otg_drv_vbus(0);
			langwell->otg.state = OTG_STATE_B_IDLE;
		} else if (langwell->hsm.a_vbus_vld) {
			langwell_otg_del_timer(a_wait_vrise_tmr);
			if (langwell->host_ops)
				langwell->host_ops->probe(langwell->pdev,
						langwell->host_ops->id_table);
			else
				otg_dbg("host driver not loaded.\n");
			langwell->hsm.b_conn = 0;
			langwell->hsm.a_set_b_hnp_en = 0;
			langwell->hsm.a_wait_bcon_tmout = 0;
			langwell_otg_add_timer(a_wait_bcon_tmr);
			langwell->otg.state = OTG_STATE_A_WAIT_BCON;
		} else if (langwell->hsm.a_wait_vrise_tmout) {
			if (langwell->hsm.a_vbus_vld) {
				if (langwell->host_ops)
					langwell->host_ops->probe(
						langwell->pdev,
						langwell->host_ops->id_table);
				else
					otg_dbg("host driver not loaded.\n");
				langwell->hsm.b_conn = 0;
				langwell->hsm.a_set_b_hnp_en = 0;
				langwell->hsm.a_wait_bcon_tmout = 0;
				langwell_otg_add_timer(a_wait_bcon_tmr);
				langwell->otg.state = OTG_STATE_A_WAIT_BCON;
			} else {
				langwell_otg_drv_vbus(0);
				langwell->otg.state = OTG_STATE_A_VBUS_ERR;
			}
		}
		break;
	case OTG_STATE_A_WAIT_BCON:
		if (langwell->hsm.id) {
			langwell_otg_del_timer(a_wait_bcon_tmr);

			langwell->otg.default_a = 0;
			langwell->hsm.b_bus_req = 0;
			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");
			langwell_otg_drv_vbus(0);
			langwell->otg.state = OTG_STATE_B_IDLE;
			queue_work(langwell->qwork, &langwell->work);
		} else if (!langwell->hsm.a_vbus_vld) {
			langwell_otg_del_timer(a_wait_bcon_tmr);

			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");
			langwell_otg_drv_vbus(0);
			langwell->otg.state = OTG_STATE_A_VBUS_ERR;
		} else if (langwell->hsm.a_bus_drop ||
				(langwell->hsm.a_wait_bcon_tmout &&
				!langwell->hsm.a_bus_req)) {
			langwell_otg_del_timer(a_wait_bcon_tmr);

			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");
			langwell_otg_drv_vbus(0);
			langwell->otg.state = OTG_STATE_A_WAIT_VFALL;
		} else if (langwell->hsm.b_conn) {
			langwell_otg_del_timer(a_wait_bcon_tmr);

			langwell->hsm.a_suspend_req = 0;
			langwell->otg.state = OTG_STATE_A_HOST;
			if (!langwell->hsm.a_bus_req &&
				langwell->hsm.a_set_b_hnp_en) {
				/* It is not safe enough to do a fast
				 * transistion from A_WAIT_BCON to
				 * A_SUSPEND */
				msleep(10000);
				if (langwell->hsm.a_bus_req)
					break;

				if (request_irq(langwell->pdev->irq,
					otg_dummy_irq, IRQF_SHARED,
					driver_name, langwell->regs) != 0) {
					otg_dbg("request interrupt %d fail\n",
					langwell->pdev->irq);
				}

				langwell_otg_HABA(1);
				langwell->hsm.b_bus_resume = 0;
				langwell->hsm.a_aidl_bdis_tmout = 0;
				langwell_otg_add_timer(a_aidl_bdis_tmr);

				langwell_otg_loc_sof(0);
				langwell->otg.state = OTG_STATE_A_SUSPEND;
			} else if (!langwell->hsm.a_bus_req &&
				!langwell->hsm.a_set_b_hnp_en) {
				struct pci_dev *pdev = langwell->pdev;
				if (langwell->host_ops)
					langwell->host_ops->remove(pdev);
				else
					otg_dbg("host driver removed.\n");
				langwell_otg_drv_vbus(0);
				langwell->otg.state = OTG_STATE_A_WAIT_VFALL;
			}
		}
		break;
	case OTG_STATE_A_HOST:
		if (langwell->hsm.id) {
			langwell->otg.default_a = 0;
			langwell->hsm.b_bus_req = 0;
			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");
			langwell_otg_drv_vbus(0);
			langwell->otg.state = OTG_STATE_B_IDLE;
			queue_work(langwell->qwork, &langwell->work);
		} else if (langwell->hsm.a_bus_drop ||
		(!langwell->hsm.a_set_b_hnp_en && !langwell->hsm.a_bus_req)) {
			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");
			langwell_otg_drv_vbus(0);
			langwell->otg.state = OTG_STATE_A_WAIT_VFALL;
		} else if (!langwell->hsm.a_vbus_vld) {
			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");
			langwell_otg_drv_vbus(0);
			langwell->otg.state = OTG_STATE_A_VBUS_ERR;
		} else if (langwell->hsm.a_set_b_hnp_en
				&& !langwell->hsm.a_bus_req) {
			/* Set HABA to enable hardware assistance to signal
			 *  A-connect after receiver B-disconnect. Hardware
			 *  will then set client mode and enable URE, SLE and
			 *  PCE after the assistance. otg_dummy_irq is used to
			 *  clean these ints when client driver is not resumed.
			 */
			if (request_irq(langwell->pdev->irq,
				otg_dummy_irq, IRQF_SHARED, driver_name,
				langwell->regs) != 0) {
				otg_dbg("request interrupt %d failed\n",
						langwell->pdev->irq);
			}

			/* set HABA */
			langwell_otg_HABA(1);
			langwell->hsm.b_bus_resume = 0;
			langwell->hsm.a_aidl_bdis_tmout = 0;
			langwell_otg_add_timer(a_aidl_bdis_tmr);
			langwell_otg_loc_sof(0);
			langwell->otg.state = OTG_STATE_A_SUSPEND;
		} else if (!langwell->hsm.b_conn || !langwell->hsm.a_bus_req) {
			langwell->hsm.a_wait_bcon_tmout = 0;
			langwell->hsm.a_set_b_hnp_en = 0;
			langwell_otg_add_timer(a_wait_bcon_tmr);
			langwell->otg.state = OTG_STATE_A_WAIT_BCON;
		}
		break;
	case OTG_STATE_A_SUSPEND:
		if (langwell->hsm.id) {
			langwell_otg_del_timer(a_aidl_bdis_tmr);
			langwell_otg_HABA(0);
			free_irq(langwell->pdev->irq, langwell->regs);
			langwell->otg.default_a = 0;
			langwell->hsm.b_bus_req = 0;
			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");
			langwell_otg_drv_vbus(0);
			langwell->otg.state = OTG_STATE_B_IDLE;
			queue_work(langwell->qwork, &langwell->work);
		} else if (langwell->hsm.a_bus_req ||
				langwell->hsm.b_bus_resume) {
			langwell_otg_del_timer(a_aidl_bdis_tmr);
			langwell_otg_HABA(0);
			free_irq(langwell->pdev->irq, langwell->regs);
			langwell->hsm.a_suspend_req = 0;
			langwell_otg_loc_sof(1);
			langwell->otg.state = OTG_STATE_A_HOST;
		} else if (langwell->hsm.a_aidl_bdis_tmout ||
				langwell->hsm.a_bus_drop) {
			langwell_otg_del_timer(a_aidl_bdis_tmr);
			langwell_otg_HABA(0);
			free_irq(langwell->pdev->irq, langwell->regs);
			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");
			langwell_otg_drv_vbus(0);
			langwell->otg.state = OTG_STATE_A_WAIT_VFALL;
		} else if (!langwell->hsm.b_conn &&
				langwell->hsm.a_set_b_hnp_en) {
			langwell_otg_del_timer(a_aidl_bdis_tmr);
			langwell_otg_HABA(0);
			free_irq(langwell->pdev->irq, langwell->regs);

			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");

			langwell->hsm.b_bus_suspend = 0;
			langwell->hsm.b_bus_suspend_vld = 0;
			langwell->hsm.b_bus_suspend_tmout = 0;

			/* msleep(200); */
			if (langwell->client_ops)
				langwell->client_ops->resume(langwell->pdev);
			else
				otg_dbg("client driver not loaded.\n");

			langwell_otg_add_timer(b_bus_suspend_tmr);
			langwell->otg.state = OTG_STATE_A_PERIPHERAL;
			break;
		} else if (!langwell->hsm.a_vbus_vld) {
			langwell_otg_del_timer(a_aidl_bdis_tmr);
			langwell_otg_HABA(0);
			free_irq(langwell->pdev->irq, langwell->regs);
			if (langwell->host_ops)
				langwell->host_ops->remove(langwell->pdev);
			else
				otg_dbg("host driver has been removed.\n");
			langwell_otg_drv_vbus(0);
			langwell->otg.state = OTG_STATE_A_VBUS_ERR;
		}
		break;
	case OTG_STATE_A_PERIPHERAL:
		if (langwell->hsm.id) {
			langwell_otg_del_timer(b_bus_suspend_tmr);
			langwell->otg.default_a = 0;
			langwell->hsm.b_bus_req = 0;
			if (langwell->client_ops)
				langwell->client_ops->suspend(langwell->pdev,
					PMSG_FREEZE);
			else
				otg_dbg("client driver has been removed.\n");
			langwell_otg_drv_vbus(0);
			langwell->otg.state = OTG_STATE_B_IDLE;
			queue_work(langwell->qwork, &langwell->work);
		} else if (!langwell->hsm.a_vbus_vld) {
			langwell_otg_del_timer(b_bus_suspend_tmr);
			if (langwell->client_ops)
				langwell->client_ops->suspend(langwell->pdev,
					PMSG_FREEZE);
			else
				otg_dbg("client driver has been removed.\n");
			langwell_otg_drv_vbus(0);
			langwell->otg.state = OTG_STATE_A_VBUS_ERR;
		} else if (langwell->hsm.a_bus_drop) {
			langwell_otg_del_timer(b_bus_suspend_tmr);
			if (langwell->client_ops)
				langwell->client_ops->suspend(langwell->pdev,
					PMSG_FREEZE);
			else
				otg_dbg("client driver has been removed.\n");
			langwell_otg_drv_vbus(0);
			langwell->otg.state = OTG_STATE_A_WAIT_VFALL;
		} else if (langwell->hsm.b_bus_suspend) {
			langwell_otg_del_timer(b_bus_suspend_tmr);
			if (langwell->client_ops)
				langwell->client_ops->suspend(langwell->pdev,
					PMSG_FREEZE);
			else
				otg_dbg("client driver has been removed.\n");

			if (langwell->host_ops)
				langwell->host_ops->probe(langwell->pdev,
						langwell->host_ops->id_table);
			else
				otg_dbg("host driver not loaded.\n");
			langwell->hsm.a_set_b_hnp_en = 0;
			langwell->hsm.a_wait_bcon_tmout = 0;
			langwell_otg_add_timer(a_wait_bcon_tmr);
			langwell->otg.state = OTG_STATE_A_WAIT_BCON;
		} else if (langwell->hsm.b_bus_suspend_tmout) {
			u32	val;
			val = readl(langwell->regs + CI_PORTSC1);
			if (!(val & PORTSC_SUSP))
				break;
			if (langwell->client_ops)
				langwell->client_ops->suspend(langwell->pdev,
						PMSG_FREEZE);
			else
				otg_dbg("client driver has been removed.\n");
			if (langwell->host_ops)
				langwell->host_ops->probe(langwell->pdev,
						langwell->host_ops->id_table);
			else
				otg_dbg("host driver not loaded.\n");
			langwell->hsm.a_set_b_hnp_en = 0;
			langwell->hsm.a_wait_bcon_tmout = 0;
			langwell_otg_add_timer(a_wait_bcon_tmr);
			langwell->otg.state = OTG_STATE_A_WAIT_BCON;
		}
		break;
	case OTG_STATE_A_VBUS_ERR:
		if (langwell->hsm.id) {
			langwell->otg.default_a = 0;
			langwell->hsm.a_clr_err = 0;
			langwell->hsm.a_srp_det = 0;
			langwell->otg.state = OTG_STATE_B_IDLE;
			queue_work(langwell->qwork, &langwell->work);
		} else if (langwell->hsm.a_clr_err) {
			langwell->hsm.a_clr_err = 0;
			langwell->hsm.a_srp_det = 0;
			reset_otg();
			init_hsm();
			if (langwell->otg.state == OTG_STATE_A_IDLE)
				queue_work(langwell->qwork, &langwell->work);
		}
		break;
	case OTG_STATE_A_WAIT_VFALL:
		if (langwell->hsm.id) {
			langwell->otg.default_a = 0;
			langwell->otg.state = OTG_STATE_B_IDLE;
			queue_work(langwell->qwork, &langwell->work);
		} else if (langwell->hsm.a_bus_req) {
			langwell_otg_drv_vbus(1);
			langwell->hsm.a_wait_vrise_tmout = 0;
			langwell_otg_add_timer(a_wait_vrise_tmr);
			langwell->otg.state = OTG_STATE_A_WAIT_VRISE;
		} else if (!langwell->hsm.a_sess_vld) {
			langwell->hsm.a_srp_det = 0;
			langwell_otg_drv_vbus(0);
			set_host_mode();
			langwell->otg.state = OTG_STATE_A_IDLE;
		}
		break;
	default:
		;
	}

	otg_dbg("%s: new state = %s\n", __func__,
			state_string(langwell->otg.state));
}

	static ssize_t
show_registers(struct device *_dev, struct device_attribute *attr, char *buf)
{
	struct langwell_otg *langwell;
	char *next;
	unsigned size;
	unsigned t;

	langwell = the_transceiver;
	next = buf;
	size = PAGE_SIZE;

	t = scnprintf(next, size,
		"\n"
		"USBCMD = 0x%08x \n"
		"USBSTS = 0x%08x \n"
		"USBINTR = 0x%08x \n"
		"ASYNCLISTADDR = 0x%08x \n"
		"PORTSC1 = 0x%08x \n"
		"HOSTPC1 = 0x%08x \n"
		"OTGSC = 0x%08x \n"
		"USBMODE = 0x%08x \n",
		readl(langwell->regs + 0x30),
		readl(langwell->regs + 0x34),
		readl(langwell->regs + 0x38),
		readl(langwell->regs + 0x48),
		readl(langwell->regs + 0x74),
		readl(langwell->regs + 0xb4),
		readl(langwell->regs + 0xf4),
		readl(langwell->regs + 0xf8)
		);
	size -= t;
	next += t;

	return PAGE_SIZE - size;
}
static DEVICE_ATTR(registers, S_IRUGO, show_registers, NULL);

static ssize_t
show_hsm(struct device *_dev, struct device_attribute *attr, char *buf)
{
	struct langwell_otg *langwell;
	char *next;
	unsigned size;
	unsigned t;

	langwell = the_transceiver;
	next = buf;
	size = PAGE_SIZE;

	t = scnprintf(next, size,
		"\n"
		"current state = %s\n"
		"a_bus_resume = \t%d\n"
		"a_bus_suspend = \t%d\n"
		"a_conn = \t%d\n"
		"a_sess_vld = \t%d\n"
		"a_srp_det = \t%d\n"
		"a_vbus_vld = \t%d\n"
		"b_bus_resume = \t%d\n"
		"b_bus_suspend = \t%d\n"
		"b_conn = \t%d\n"
		"b_se0_srp = \t%d\n"
		"b_sess_end = \t%d\n"
		"b_sess_vld = \t%d\n"
		"id = \t%d\n"
		"a_set_b_hnp_en = \t%d\n"
		"b_srp_done = \t%d\n"
		"b_hnp_enable = \t%d\n"
		"a_wait_vrise_tmout = \t%d\n"
		"a_wait_bcon_tmout = \t%d\n"
		"a_aidl_bdis_tmout = \t%d\n"
		"b_ase0_brst_tmout = \t%d\n"
		"a_bus_drop = \t%d\n"
		"a_bus_req = \t%d\n"
		"a_clr_err = \t%d\n"
		"a_suspend_req = \t%d\n"
		"b_bus_req = \t%d\n"
		"b_bus_suspend_tmout = \t%d\n"
		"b_bus_suspend_vld = \t%d\n",
		state_string(langwell->otg.state),
		langwell->hsm.a_bus_resume,
		langwell->hsm.a_bus_suspend,
		langwell->hsm.a_conn,
		langwell->hsm.a_sess_vld,
		langwell->hsm.a_srp_det,
		langwell->hsm.a_vbus_vld,
		langwell->hsm.b_bus_resume,
		langwell->hsm.b_bus_suspend,
		langwell->hsm.b_conn,
		langwell->hsm.b_se0_srp,
		langwell->hsm.b_sess_end,
		langwell->hsm.b_sess_vld,
		langwell->hsm.id,
		langwell->hsm.a_set_b_hnp_en,
		langwell->hsm.b_srp_done,
		langwell->hsm.b_hnp_enable,
		langwell->hsm.a_wait_vrise_tmout,
		langwell->hsm.a_wait_bcon_tmout,
		langwell->hsm.a_aidl_bdis_tmout,
		langwell->hsm.b_ase0_brst_tmout,
		langwell->hsm.a_bus_drop,
		langwell->hsm.a_bus_req,
		langwell->hsm.a_clr_err,
		langwell->hsm.a_suspend_req,
		langwell->hsm.b_bus_req,
		langwell->hsm.b_bus_suspend_tmout,
		langwell->hsm.b_bus_suspend_vld
		);
	size -= t;
	next += t;

	return PAGE_SIZE - size;
}
static DEVICE_ATTR(hsm, S_IRUGO, show_hsm, NULL);

static ssize_t
get_a_bus_req(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct langwell_otg *langwell;
	char *next;
	unsigned size;
	unsigned t;

	langwell =  the_transceiver;
	next = buf;
	size = PAGE_SIZE;

	t = scnprintf(next, size, "%d", langwell->hsm.a_bus_req);
	size -= t;
	next += t;

	return PAGE_SIZE - size;
}

static ssize_t
set_a_bus_req(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t count)
{
	struct langwell_otg *langwell;
	langwell = the_transceiver;
	if (!langwell->otg.default_a)
		return -1;
	if (count > 2)
		return -1;

	if (buf[0] == '0') {
		langwell->hsm.a_bus_req = 0;
		otg_dbg("a_bus_req = 0\n");
	} else if (buf[0] == '1') {
		/* If a_bus_drop is TRUE, a_bus_req can't be set */
		if (langwell->hsm.a_bus_drop)
			return -1;
		langwell->hsm.a_bus_req = 1;
		otg_dbg("a_bus_req = 1\n");
	}
	if (spin_trylock(&langwell->wq_lock)) {
		queue_work(langwell->qwork, &langwell->work);
		spin_unlock(&langwell->wq_lock);
	}
	return count;
}
static DEVICE_ATTR(a_bus_req, S_IRUGO | S_IWUGO, get_a_bus_req, set_a_bus_req);

static ssize_t
get_a_bus_drop(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct langwell_otg *langwell;
	char *next;
	unsigned size;
	unsigned t;

	langwell =  the_transceiver;
	next = buf;
	size = PAGE_SIZE;

	t = scnprintf(next, size, "%d", langwell->hsm.a_bus_drop);
	size -= t;
	next += t;

	return PAGE_SIZE - size;
}

static ssize_t
set_a_bus_drop(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t count)
{
	struct langwell_otg *langwell;
	langwell = the_transceiver;
	if (!langwell->otg.default_a)
		return -1;
	if (count > 2)
		return -1;

	if (buf[0] == '0') {
		langwell->hsm.a_bus_drop = 0;
		otg_dbg("a_bus_drop = 0\n");
	} else if (buf[0] == '1') {
		langwell->hsm.a_bus_drop = 1;
		langwell->hsm.a_bus_req = 0;
		otg_dbg("a_bus_drop = 1, then a_bus_req = 0\n");
	}
	if (spin_trylock(&langwell->wq_lock)) {
		queue_work(langwell->qwork, &langwell->work);
		spin_unlock(&langwell->wq_lock);
	}
	return count;
}
static DEVICE_ATTR(a_bus_drop, S_IRUGO | S_IWUGO,
	get_a_bus_drop, set_a_bus_drop);

static ssize_t
get_b_bus_req(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct langwell_otg *langwell;
	char *next;
	unsigned size;
	unsigned t;

	langwell =  the_transceiver;
	next = buf;
	size = PAGE_SIZE;

	t = scnprintf(next, size, "%d", langwell->hsm.b_bus_req);
	size -= t;
	next += t;

	return PAGE_SIZE - size;
}

static ssize_t
set_b_bus_req(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t count)
{
	struct langwell_otg *langwell;
	langwell = the_transceiver;

	if (langwell->otg.default_a)
		return -1;

	if (count > 2)
		return -1;

	if (buf[0] == '0') {
		langwell->hsm.b_bus_req = 0;
		otg_dbg("b_bus_req = 0\n");
	} else if (buf[0] == '1') {
		langwell->hsm.b_bus_req = 1;
		otg_dbg("b_bus_req = 1\n");
	}
	if (spin_trylock(&langwell->wq_lock)) {
		queue_work(langwell->qwork, &langwell->work);
		spin_unlock(&langwell->wq_lock);
	}
	return count;
}
static DEVICE_ATTR(b_bus_req, S_IRUGO | S_IWUGO, get_b_bus_req, set_b_bus_req);

static ssize_t
set_a_clr_err(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t count)
{
	struct langwell_otg *langwell;
	langwell = the_transceiver;

	if (!langwell->otg.default_a)
		return -1;
	if (count > 2)
		return -1;

	if (buf[0] == '1') {
		langwell->hsm.a_clr_err = 1;
		otg_dbg("a_clr_err = 1\n");
	}
	if (spin_trylock(&langwell->wq_lock)) {
		queue_work(langwell->qwork, &langwell->work);
		spin_unlock(&langwell->wq_lock);
	}
	return count;
}
static DEVICE_ATTR(a_clr_err, S_IWUGO, NULL, set_a_clr_err);

static struct attribute *inputs_attrs[] = {
	&dev_attr_a_bus_req.attr,
	&dev_attr_a_bus_drop.attr,
	&dev_attr_b_bus_req.attr,
	&dev_attr_a_clr_err.attr,
	NULL,
};

static struct attribute_group debug_dev_attr_group = {
	.name = "inputs",
	.attrs = inputs_attrs,
};

int langwell_register_host(struct pci_driver *host_driver)
{
	int	ret = 0;

	the_transceiver->host_ops = host_driver;
	queue_work(the_transceiver->qwork, &the_transceiver->work);
	otg_dbg("host controller driver is registered\n");

	return ret;
}
EXPORT_SYMBOL(langwell_register_host);

void langwell_unregister_host(struct pci_driver *host_driver)
{
	if (the_transceiver->host_ops)
		the_transceiver->host_ops->remove(the_transceiver->pdev);
	the_transceiver->host_ops = NULL;
	the_transceiver->hsm.a_bus_drop = 1;
	queue_work(the_transceiver->qwork, &the_transceiver->work);
	otg_dbg("host controller driver is unregistered\n");
}
EXPORT_SYMBOL(langwell_unregister_host);

int langwell_register_peripheral(struct pci_driver *client_driver)
{
	int	ret = 0;

	if (client_driver)
		ret = client_driver->probe(the_transceiver->pdev,
				client_driver->id_table);
	if (!ret) {
		the_transceiver->client_ops = client_driver;
		queue_work(the_transceiver->qwork, &the_transceiver->work);
		otg_dbg("client controller driver is registered\n");
	}

	return ret;
}
EXPORT_SYMBOL(langwell_register_peripheral);

void langwell_unregister_peripheral(struct pci_driver *client_driver)
{
	if (the_transceiver->client_ops)
		the_transceiver->client_ops->remove(the_transceiver->pdev);
	the_transceiver->client_ops = NULL;
	the_transceiver->hsm.b_bus_req = 0;
	queue_work(the_transceiver->qwork, &the_transceiver->work);
	otg_dbg("client controller driver is unregistered\n");
}
EXPORT_SYMBOL(langwell_unregister_peripheral);

static int langwell_otg_probe(struct pci_dev *pdev,
		const struct pci_device_id *id)
{
	unsigned long		resource, len;
	void __iomem 		*base = NULL;
	int			retval;
	u32			val32;
	struct langwell_otg	*langwell;
	char			qname[] = "langwell_otg_queue";

	retval = 0;
	otg_dbg("\notg controller is detected.\n");
	if (pci_enable_device(pdev) < 0) {
		retval = -ENODEV;
		goto done;
	}

	langwell = kzalloc(sizeof *langwell, GFP_KERNEL);
	if (langwell == NULL) {
		retval = -ENOMEM;
		goto done;
	}
	the_transceiver = langwell;

	/* control register: BAR 0 */
	resource = pci_resource_start(pdev, 0);
	len = pci_resource_len(pdev, 0);
	if (!request_mem_region(resource, len, driver_name)) {
		retval = -EBUSY;
		goto err;
	}
	langwell->region = 1;

	base = ioremap_nocache(resource, len);
	if (base == NULL) {
		retval = -EFAULT;
		goto err;
	}
	langwell->regs = base;

	if (!pdev->irq) {
		otg_dbg("No IRQ.\n");
		retval = -ENODEV;
		goto err;
	}

	langwell->qwork = create_workqueue(qname);
	if (!langwell->qwork) {
		otg_dbg("cannot create workqueue %s\n", qname);
		retval = -ENOMEM;
		goto err;
	}
	INIT_WORK(&langwell->work, langwell_otg_work);

	/* OTG common part */
	langwell->pdev = pdev;
	langwell->otg.dev = &pdev->dev;
	langwell->otg.label = driver_name;
	langwell->otg.set_host = langwell_otg_set_host;
	langwell->otg.set_peripheral = langwell_otg_set_peripheral;
	langwell->otg.set_power = langwell_otg_set_power;
	langwell->otg.start_srp = langwell_otg_start_srp;
	langwell->otg.state = OTG_STATE_UNDEFINED;
	if (otg_set_transceiver(&langwell->otg)) {
		otg_dbg("can't set transceiver\n");
		retval = -EBUSY;
		goto err;
	}

	reset_otg();
	init_hsm();

	spin_lock_init(&langwell->lock);
	spin_lock_init(&langwell->wq_lock);
	INIT_LIST_HEAD(&active_timers);
	langwell_otg_init_timers(&langwell->hsm);

	if (request_irq(pdev->irq, otg_irq, IRQF_SHARED,
				driver_name, langwell) != 0) {
		otg_dbg("request interrupt %d failed\n", pdev->irq);
		retval = -EBUSY;
		goto err;
	}

	/* enable OTGSC int */
	val32 = OTGSC_DPIE | OTGSC_BSEIE | OTGSC_BSVIE |
		OTGSC_ASVIE | OTGSC_AVVIE | OTGSC_IDIE | OTGSC_IDPU;
	writel(val32, langwell->regs + CI_OTGSC);

	retval = device_create_file(&pdev->dev, &dev_attr_registers);
	if (retval < 0) {
		otg_dbg("Can't register sysfs attribute: %d\n", retval);
		goto err;
	}

	retval = device_create_file(&pdev->dev, &dev_attr_hsm);
	if (retval < 0) {
		otg_dbg("Can't hsm sysfs attribute: %d\n", retval);
		goto err;
	}

	retval = sysfs_create_group(&pdev->dev.kobj, &debug_dev_attr_group);
	if (retval < 0) {
		otg_dbg("Can't register sysfs attr group: %d\n", retval);
		goto err;
	}

	if (langwell->otg.state == OTG_STATE_A_IDLE)
		queue_work(langwell->qwork, &langwell->work);

	return 0;

err:
	if (the_transceiver)
		langwell_otg_remove(pdev);
done:
	return retval;
}

static void langwell_otg_remove(struct pci_dev *pdev)
{
	struct langwell_otg *langwell;

	langwell = the_transceiver;

	if (langwell->qwork) {
		flush_workqueue(langwell->qwork);
		destroy_workqueue(langwell->qwork);
	}
	langwell_otg_free_timers();

	/* disable OTGSC interrupt as OTGSC doesn't change in reset */
	writel(0, langwell->regs + CI_OTGSC);

	if (pdev->irq)
		free_irq(pdev->irq, langwell);
	if (langwell->regs)
		iounmap(langwell->regs);
	if (langwell->region)
		release_mem_region(pci_resource_start(pdev, 0),
				pci_resource_len(pdev, 0));

	otg_set_transceiver(NULL);
	pci_disable_device(pdev);
	sysfs_remove_group(&pdev->dev.kobj, &debug_dev_attr_group);
	device_remove_file(&pdev->dev, &dev_attr_hsm);
	device_remove_file(&pdev->dev, &dev_attr_registers);
	kfree(langwell);
	langwell = NULL;
}

static void transceiver_suspend(struct pci_dev *pdev)
{
	pci_save_state(pdev);
	pci_set_power_state(pdev, PCI_D3hot);
	langwell_otg_phy_low_power(1);
}

static int langwell_otg_suspend(struct pci_dev *pdev, pm_message_t message)
{
	int 	ret = 0;
	struct langwell_otg *langwell;

	langwell = the_transceiver;

	/* Disbale OTG interrupts */
	langwell_otg_intr(0);

	if (pdev->irq)
		free_irq(pdev->irq, langwell);

	/* Prevent more otg_work */
	flush_workqueue(langwell->qwork);
	spin_lock(&langwell->wq_lock);

	/* start actions */
	switch (langwell->otg.state) {
	case OTG_STATE_A_IDLE:
	case OTG_STATE_B_IDLE:
	case OTG_STATE_A_WAIT_VFALL:
	case OTG_STATE_A_VBUS_ERR:
		transceiver_suspend(pdev);
		break;
	case OTG_STATE_A_WAIT_VRISE:
		langwell_otg_del_timer(a_wait_vrise_tmr);
		langwell->hsm.a_srp_det = 0;
		langwell_otg_drv_vbus(0);
		langwell->otg.state = OTG_STATE_A_IDLE;
		transceiver_suspend(pdev);
		break;
	case OTG_STATE_A_WAIT_BCON:
		langwell_otg_del_timer(a_wait_bcon_tmr);
		if (langwell->host_ops)
			ret = langwell->host_ops->suspend(pdev, message);
		langwell_otg_drv_vbus(0);
		break;
	case OTG_STATE_A_HOST:
		if (langwell->host_ops)
			ret = langwell->host_ops->suspend(pdev, message);
		langwell_otg_drv_vbus(0);
		langwell_otg_phy_low_power(1);
		break;
	case OTG_STATE_A_SUSPEND:
		langwell_otg_del_timer(a_aidl_bdis_tmr);
		langwell_otg_HABA(0);
		if (langwell->host_ops)
			langwell->host_ops->remove(pdev);
		else
			otg_dbg("host driver has been removed.\n");
		langwell_otg_drv_vbus(0);
		transceiver_suspend(pdev);
		langwell->otg.state = OTG_STATE_A_WAIT_VFALL;
		break;
	case OTG_STATE_A_PERIPHERAL:
		if (langwell->client_ops)
			ret = langwell->client_ops->suspend(pdev, message);
		else
			otg_dbg("client driver has been removed.\n");
		langwell_otg_drv_vbus(0);
		transceiver_suspend(pdev);
		langwell->otg.state = OTG_STATE_A_WAIT_VFALL;
		break;
	case OTG_STATE_B_HOST:
		if (langwell->host_ops)
			langwell->host_ops->remove(pdev);
		else
			otg_dbg("host driver has been removed.\n");
		langwell->hsm.b_bus_req = 0;
		transceiver_suspend(pdev);
		langwell->otg.state = OTG_STATE_B_IDLE;
		break;
	case OTG_STATE_B_PERIPHERAL:
		if (langwell->client_ops)
			ret = langwell->client_ops->suspend(pdev, message);
		else
			otg_dbg("client driver has been removed.\n");
		break;
	case OTG_STATE_B_WAIT_ACON:
		langwell_otg_del_timer(b_ase0_brst_tmr);
		langwell_otg_HAAR(0);
		if (langwell->host_ops)
			langwell->host_ops->remove(pdev);
		else
			otg_dbg("host driver has been removed.\n");
		langwell->hsm.b_bus_req = 0;
		langwell->otg.state = OTG_STATE_B_IDLE;
		transceiver_suspend(pdev);
		break;
	default:
		otg_dbg("error state before suspend\n ");
		break;
	}
	spin_unlock(&langwell->wq_lock);

	return ret;
}

static void transceiver_resume(struct pci_dev *pdev)
{
	pci_restore_state(pdev);
	pci_set_power_state(pdev, PCI_D0);
	langwell_otg_phy_low_power(0);
}

static int langwell_otg_resume(struct pci_dev *pdev)
{
	int 	ret = 0;
	struct langwell_otg *langwell;

	langwell = the_transceiver;

	spin_lock(&langwell->wq_lock);

	switch (langwell->otg.state) {
	case OTG_STATE_A_IDLE:
	case OTG_STATE_B_IDLE:
	case OTG_STATE_A_WAIT_VFALL:
	case OTG_STATE_A_VBUS_ERR:
		transceiver_resume(pdev);
		break;
	case OTG_STATE_A_WAIT_BCON:
		langwell_otg_add_timer(a_wait_bcon_tmr);
		langwell_otg_drv_vbus(1);
		if (langwell->host_ops)
			ret = langwell->host_ops->resume(pdev);
		break;
	case OTG_STATE_A_HOST:
		langwell_otg_drv_vbus(1);
		langwell_otg_phy_low_power(0);
		if (langwell->host_ops)
			ret = langwell->host_ops->resume(pdev);
		break;
	case OTG_STATE_B_PERIPHERAL:
		if (langwell->client_ops)
			ret = langwell->client_ops->resume(pdev);
		else
			otg_dbg("client driver not loaded.\n");
		break;
	default:
		otg_dbg("error state before suspend\n ");
		break;
	}

	if (request_irq(pdev->irq, otg_irq, IRQF_SHARED,
				driver_name, the_transceiver) != 0) {
		otg_dbg("request interrupt %d failed\n", pdev->irq);
		ret = -EBUSY;
	}

	/* enable OTG interrupts */
	langwell_otg_intr(1);

	spin_unlock(&langwell->wq_lock);

	queue_work(langwell->qwork, &langwell->work);


	return ret;
}

static int __init langwell_otg_init(void)
{
	return pci_register_driver(&otg_pci_driver);
}
module_init(langwell_otg_init);

static void __exit langwell_otg_cleanup(void)
{
	pci_unregister_driver(&otg_pci_driver);
}
module_exit(langwell_otg_cleanup);