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

/*
 * Tahvo USB transceiver driver
 *
 * Copyright (C) 2005-2006 Nokia Corporation
 *
 * Parts copied from isp1301_omap.c.
 * Copyright (C) 2004 Texas Instruments
 * Copyright (C) 2004 David Brownell
 *
 * Original driver written by Juha Yrjölä, Tony Lindgren and Timo Teräs.
 * Modified for Retu/Tahvo MFD by Aaro Koskinen.
 *
 * This file is subject to the terms and conditions of the GNU General
 * Public License. See the file "COPYING" in the main directory of this
 * archive for more details.
 *
 * 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.
 */

#include <linux/io.h>
#include <linux/clk.h>
#include <linux/usb.h>
#include <linux/extcon.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/usb/otg.h>
#include <linux/mfd/retu.h>
#include <linux/usb/gadget.h>
#include <linux/platform_device.h>

#define DRIVER_NAME     "tahvo-usb"

#define TAHVO_REG_IDSR	0x02
#define TAHVO_REG_USBR	0x06

#define USBR_SLAVE_CONTROL	(1 << 8)
#define USBR_VPPVIO_SW		(1 << 7)
#define USBR_SPEED		(1 << 6)
#define USBR_REGOUT		(1 << 5)
#define USBR_MASTER_SW2		(1 << 4)
#define USBR_MASTER_SW1		(1 << 3)
#define USBR_SLAVE_SW		(1 << 2)
#define USBR_NSUSPEND		(1 << 1)
#define USBR_SEMODE		(1 << 0)

#define TAHVO_MODE_HOST		0
#define TAHVO_MODE_PERIPHERAL	1

struct tahvo_usb {
	struct platform_device	*pt_dev;
	struct usb_phy		phy;
	int			vbus_state;
	struct mutex		serialize;
	struct clk		*ick;
	int			irq;
	int			tahvo_mode;
	struct extcon_dev	extcon;
};

static const char *tahvo_cable[] = {
	"USB-HOST",
	"USB",
	NULL,
};

static ssize_t vbus_state_show(struct device *device,
			       struct device_attribute *attr, char *buf)
{
	struct tahvo_usb *tu = dev_get_drvdata(device);
	return sprintf(buf, "%s\n", tu->vbus_state ? "on" : "off");
}
static DEVICE_ATTR(vbus, 0444, vbus_state_show, NULL);

static void check_vbus_state(struct tahvo_usb *tu)
{
	struct retu_dev *rdev = dev_get_drvdata(tu->pt_dev->dev.parent);
	int reg, prev_state;

	reg = retu_read(rdev, TAHVO_REG_IDSR);
	if (reg & TAHVO_STAT_VBUS) {
		switch (tu->phy.state) {
		case OTG_STATE_B_IDLE:
			/* Enable the gadget driver */
			if (tu->phy.otg->gadget)
				usb_gadget_vbus_connect(tu->phy.otg->gadget);
			tu->phy.state = OTG_STATE_B_PERIPHERAL;
			break;
		case OTG_STATE_A_IDLE:
			/*
			 * Session is now valid assuming the USB hub is driving
			 * Vbus.
			 */
			tu->phy.state = OTG_STATE_A_HOST;
			break;
		default:
			break;
		}
		dev_info(&tu->pt_dev->dev, "USB cable connected\n");
	} else {
		switch (tu->phy.state) {
		case OTG_STATE_B_PERIPHERAL:
			if (tu->phy.otg->gadget)
				usb_gadget_vbus_disconnect(tu->phy.otg->gadget);
			tu->phy.state = OTG_STATE_B_IDLE;
			break;
		case OTG_STATE_A_HOST:
			tu->phy.state = OTG_STATE_A_IDLE;
			break;
		default:
			break;
		}
		dev_info(&tu->pt_dev->dev, "USB cable disconnected\n");
	}

	prev_state = tu->vbus_state;
	tu->vbus_state = reg & TAHVO_STAT_VBUS;
	if (prev_state != tu->vbus_state) {
		extcon_set_cable_state(&tu->extcon, "USB", tu->vbus_state);
		sysfs_notify(&tu->pt_dev->dev.kobj, NULL, "vbus_state");
	}
}

static void tahvo_usb_become_host(struct tahvo_usb *tu)
{
	struct retu_dev *rdev = dev_get_drvdata(tu->pt_dev->dev.parent);

	extcon_set_cable_state(&tu->extcon, "USB-HOST", true);

	/* Power up the transceiver in USB host mode */
	retu_write(rdev, TAHVO_REG_USBR, USBR_REGOUT | USBR_NSUSPEND |
		   USBR_MASTER_SW2 | USBR_MASTER_SW1);
	tu->phy.state = OTG_STATE_A_IDLE;

	check_vbus_state(tu);
}

static void tahvo_usb_stop_host(struct tahvo_usb *tu)
{
	tu->phy.state = OTG_STATE_A_IDLE;
}

static void tahvo_usb_become_peripheral(struct tahvo_usb *tu)
{
	struct retu_dev *rdev = dev_get_drvdata(tu->pt_dev->dev.parent);

	extcon_set_cable_state(&tu->extcon, "USB-HOST", false);

	/* Power up transceiver and set it in USB peripheral mode */
	retu_write(rdev, TAHVO_REG_USBR, USBR_SLAVE_CONTROL | USBR_REGOUT |
		   USBR_NSUSPEND | USBR_SLAVE_SW);
	tu->phy.state = OTG_STATE_B_IDLE;

	check_vbus_state(tu);
}

static void tahvo_usb_stop_peripheral(struct tahvo_usb *tu)
{
	if (tu->phy.otg->gadget)
		usb_gadget_vbus_disconnect(tu->phy.otg->gadget);
	tu->phy.state = OTG_STATE_B_IDLE;
}

static void tahvo_usb_power_off(struct tahvo_usb *tu)
{
	struct retu_dev *rdev = dev_get_drvdata(tu->pt_dev->dev.parent);

	/* Disable gadget controller if any */
	if (tu->phy.otg->gadget)
		usb_gadget_vbus_disconnect(tu->phy.otg->gadget);

	/* Power off transceiver */
	retu_write(rdev, TAHVO_REG_USBR, 0);
	tu->phy.state = OTG_STATE_UNDEFINED;
}

static int tahvo_usb_set_suspend(struct usb_phy *dev, int suspend)
{
	struct tahvo_usb *tu = container_of(dev, struct tahvo_usb, phy);
	struct retu_dev *rdev = dev_get_drvdata(tu->pt_dev->dev.parent);
	u16 w;

	dev_dbg(&tu->pt_dev->dev, "%s\n", __func__);

	w = retu_read(rdev, TAHVO_REG_USBR);
	if (suspend)
		w &= ~USBR_NSUSPEND;
	else
		w |= USBR_NSUSPEND;
	retu_write(rdev, TAHVO_REG_USBR, w);

	return 0;
}

static int tahvo_usb_set_host(struct usb_otg *otg, struct usb_bus *host)
{
	struct tahvo_usb *tu = container_of(otg->phy, struct tahvo_usb, phy);

	dev_dbg(&tu->pt_dev->dev, "%s %p\n", __func__, host);

	mutex_lock(&tu->serialize);

	if (host == NULL) {
		if (tu->tahvo_mode == TAHVO_MODE_HOST)
			tahvo_usb_power_off(tu);
		otg->host = NULL;
		mutex_unlock(&tu->serialize);
		return 0;
	}

	if (tu->tahvo_mode == TAHVO_MODE_HOST) {
		otg->host = NULL;
		tahvo_usb_become_host(tu);
	}

	otg->host = host;

	mutex_unlock(&tu->serialize);

	return 0;
}

static int tahvo_usb_set_peripheral(struct usb_otg *otg,
				    struct usb_gadget *gadget)
{
	struct tahvo_usb *tu = container_of(otg->phy, struct tahvo_usb, phy);

	dev_dbg(&tu->pt_dev->dev, "%s %p\n", __func__, gadget);

	mutex_lock(&tu->serialize);

	if (!gadget) {
		if (tu->tahvo_mode == TAHVO_MODE_PERIPHERAL)
			tahvo_usb_power_off(tu);
		tu->phy.otg->gadget = NULL;
		mutex_unlock(&tu->serialize);
		return 0;
	}

	tu->phy.otg->gadget = gadget;
	if (tu->tahvo_mode == TAHVO_MODE_PERIPHERAL)
		tahvo_usb_become_peripheral(tu);

	mutex_unlock(&tu->serialize);

	return 0;
}

static irqreturn_t tahvo_usb_vbus_interrupt(int irq, void *_tu)
{
	struct tahvo_usb *tu = _tu;

	mutex_lock(&tu->serialize);
	check_vbus_state(tu);
	mutex_unlock(&tu->serialize);

	return IRQ_HANDLED;
}

static ssize_t otg_mode_show(struct device *device,
			     struct device_attribute *attr, char *buf)
{
	struct tahvo_usb *tu = dev_get_drvdata(device);

	switch (tu->tahvo_mode) {
	case TAHVO_MODE_HOST:
		return sprintf(buf, "host\n");
	case TAHVO_MODE_PERIPHERAL:
		return sprintf(buf, "peripheral\n");
	}

	return -EINVAL;
}

static ssize_t otg_mode_store(struct device *device,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
	struct tahvo_usb *tu = dev_get_drvdata(device);
	int r;

	mutex_lock(&tu->serialize);
	if (count >= 4 && strncmp(buf, "host", 4) == 0) {
		if (tu->tahvo_mode == TAHVO_MODE_PERIPHERAL)
			tahvo_usb_stop_peripheral(tu);
		tu->tahvo_mode = TAHVO_MODE_HOST;
		if (tu->phy.otg->host) {
			dev_info(device, "HOST mode: host controller present\n");
			tahvo_usb_become_host(tu);
		} else {
			dev_info(device, "HOST mode: no host controller, powering off\n");
			tahvo_usb_power_off(tu);
		}
		r = strlen(buf);
	} else if (count >= 10 && strncmp(buf, "peripheral", 10) == 0) {
		if (tu->tahvo_mode == TAHVO_MODE_HOST)
			tahvo_usb_stop_host(tu);
		tu->tahvo_mode = TAHVO_MODE_PERIPHERAL;
		if (tu->phy.otg->gadget) {
			dev_info(device, "PERIPHERAL mode: gadget driver present\n");
			tahvo_usb_become_peripheral(tu);
		} else {
			dev_info(device, "PERIPHERAL mode: no gadget driver, powering off\n");
			tahvo_usb_power_off(tu);
		}
		r = strlen(buf);
	} else {
		r = -EINVAL;
	}
	mutex_unlock(&tu->serialize);

	return r;
}
static DEVICE_ATTR(otg_mode, 0644, otg_mode_show, otg_mode_store);

static struct attribute *tahvo_attributes[] = {
	&dev_attr_vbus.attr,
	&dev_attr_otg_mode.attr,
	NULL
};

static struct attribute_group tahvo_attr_group = {
	.attrs = tahvo_attributes,
};

static int tahvo_usb_probe(struct platform_device *pdev)
{
	struct retu_dev *rdev = dev_get_drvdata(pdev->dev.parent);
	struct tahvo_usb *tu;
	int ret;

	tu = devm_kzalloc(&pdev->dev, sizeof(*tu), GFP_KERNEL);
	if (!tu)
		return -ENOMEM;

	tu->phy.otg = devm_kzalloc(&pdev->dev, sizeof(*tu->phy.otg),
				   GFP_KERNEL);
	if (!tu->phy.otg)
		return -ENOMEM;

	tu->pt_dev = pdev;

	/* Default mode */
#ifdef CONFIG_TAHVO_USB_HOST_BY_DEFAULT
	tu->tahvo_mode = TAHVO_MODE_HOST;
#else
	tu->tahvo_mode = TAHVO_MODE_PERIPHERAL;
#endif

	mutex_init(&tu->serialize);

	tu->ick = devm_clk_get(&pdev->dev, "usb_l4_ick");
	if (!IS_ERR(tu->ick))
		clk_enable(tu->ick);

	/*
	 * Set initial state, so that we generate kevents only on state changes.
	 */
	tu->vbus_state = retu_read(rdev, TAHVO_REG_IDSR) & TAHVO_STAT_VBUS;

	tu->extcon.name = DRIVER_NAME;
	tu->extcon.supported_cable = tahvo_cable;
	tu->extcon.dev.parent = &pdev->dev;

	ret = extcon_dev_register(&tu->extcon);
	if (ret) {
		dev_err(&pdev->dev, "could not register extcon device: %d\n",
			ret);
		goto err_disable_clk;
	}

	/* Set the initial cable state. */
	extcon_set_cable_state(&tu->extcon, "USB-HOST",
			       tu->tahvo_mode == TAHVO_MODE_HOST);
	extcon_set_cable_state(&tu->extcon, "USB", tu->vbus_state);

	/* Create OTG interface */
	tahvo_usb_power_off(tu);
	tu->phy.dev = &pdev->dev;
	tu->phy.state = OTG_STATE_UNDEFINED;
	tu->phy.label = DRIVER_NAME;
	tu->phy.set_suspend = tahvo_usb_set_suspend;

	tu->phy.otg->phy = &tu->phy;
	tu->phy.otg->set_host = tahvo_usb_set_host;
	tu->phy.otg->set_peripheral = tahvo_usb_set_peripheral;

	ret = usb_add_phy(&tu->phy, USB_PHY_TYPE_USB2);
	if (ret < 0) {
		dev_err(&pdev->dev, "cannot register USB transceiver: %d\n",
			ret);
		goto err_extcon_unreg;
	}

	dev_set_drvdata(&pdev->dev, tu);

	tu->irq = platform_get_irq(pdev, 0);
	ret = request_threaded_irq(tu->irq, NULL, tahvo_usb_vbus_interrupt, 0,
				   "tahvo-vbus", tu);
	if (ret) {
		dev_err(&pdev->dev, "could not register tahvo-vbus irq: %d\n",
			ret);
		goto err_remove_phy;
	}

	/* Attributes */
	ret = sysfs_create_group(&pdev->dev.kobj, &tahvo_attr_group);
	if (ret) {
		dev_err(&pdev->dev, "cannot create sysfs group: %d\n", ret);
		goto err_free_irq;
	}

	return 0;

err_free_irq:
	free_irq(tu->irq, tu);
err_remove_phy:
	usb_remove_phy(&tu->phy);
err_extcon_unreg:
	extcon_dev_unregister(&tu->extcon);
err_disable_clk:
	if (!IS_ERR(tu->ick))
		clk_disable(tu->ick);

	return ret;
}

static int tahvo_usb_remove(struct platform_device *pdev)
{
	struct tahvo_usb *tu = platform_get_drvdata(pdev);

	sysfs_remove_group(&pdev->dev.kobj, &tahvo_attr_group);
	free_irq(tu->irq, tu);
	usb_remove_phy(&tu->phy);
	extcon_dev_unregister(&tu->extcon);
	if (!IS_ERR(tu->ick))
		clk_disable(tu->ick);

	return 0;
}

static struct platform_driver tahvo_usb_driver = {
	.probe		= tahvo_usb_probe,
	.remove		= tahvo_usb_remove,
	.driver		= {
		.name	= "tahvo-usb",
		.owner	= THIS_MODULE,
	},
};
module_platform_driver(tahvo_usb_driver);

MODULE_DESCRIPTION("Tahvo USB transceiver driver");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Juha Yrjölä, Tony Lindgren, and Timo Teräs");
MODULE_AUTHOR("Aaro Koskinen <aaro.koskinen@iki.fi>");
Commit	Line	Data
9ba96ae5 AK	1	/*
	2	* Tahvo USB transceiver driver
	3	*
	4	* Copyright (C) 2005-2006 Nokia Corporation
	5	*
	6	* Parts copied from isp1301_omap.c.
	7	* Copyright (C) 2004 Texas Instruments
	8	* Copyright (C) 2004 David Brownell
	9	*
	10	* Original driver written by Juha Yrjölä, Tony Lindgren and Timo Teräs.
	11	* Modified for Retu/Tahvo MFD by Aaro Koskinen.
	12	*
	13	* This file is subject to the terms and conditions of the GNU General
	14	* Public License. See the file "COPYING" in the main directory of this
	15	* archive for more details.
	16	*
	17	* This program is distributed in the hope that it will be useful,
	18	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	20	* GNU General Public License for more details.
	21	*/
	22
	23	#include <linux/io.h>
	24	#include <linux/clk.h>
	25	#include <linux/usb.h>
	26	#include <linux/extcon.h>
	27	#include <linux/kernel.h>
	28	#include <linux/module.h>
	29	#include <linux/usb/otg.h>
	30	#include <linux/mfd/retu.h>
	31	#include <linux/usb/gadget.h>
	32	#include <linux/platform_device.h>
	33
	34	#define DRIVER_NAME "tahvo-usb"
	35
	36	#define TAHVO_REG_IDSR 0x02
	37	#define TAHVO_REG_USBR 0x06
	38
	39	#define USBR_SLAVE_CONTROL (1 << 8)
	40	#define USBR_VPPVIO_SW (1 << 7)
	41	#define USBR_SPEED (1 << 6)
	42	#define USBR_REGOUT (1 << 5)
	43	#define USBR_MASTER_SW2 (1 << 4)
	44	#define USBR_MASTER_SW1 (1 << 3)
	45	#define USBR_SLAVE_SW (1 << 2)
	46	#define USBR_NSUSPEND (1 << 1)
	47	#define USBR_SEMODE (1 << 0)
	48
	49	#define TAHVO_MODE_HOST 0
	50	#define TAHVO_MODE_PERIPHERAL 1
	51
	52	struct tahvo_usb {
	53	struct platform_device *pt_dev;
	54	struct usb_phy phy;
	55	int vbus_state;
	56	struct mutex serialize;
	57	struct clk *ick;
	58	int irq;
	59	int tahvo_mode;
	60	struct extcon_dev extcon;
	61	};
	62
	63	static const char *tahvo_cable[] = {
	64	"USB-HOST",
65	"USB",
66	NULL,
67	};
68
69	static ssize_t vbus_state_show(struct device *device,
70	struct device_attribute attr, char buf)
71	{
72	struct tahvo_usb *tu = dev_get_drvdata(device);
73	return sprintf(buf, "%s\n", tu->vbus_state ? "on" : "off");
74	}
75	static DEVICE_ATTR(vbus, 0444, vbus_state_show, NULL);
76
77	static void check_vbus_state(struct tahvo_usb *tu)
78	{
79	struct retu_dev *rdev = dev_get_drvdata(tu->pt_dev->dev.parent);
80	int reg, prev_state;
81
82	reg = retu_read(rdev, TAHVO_REG_IDSR);
83	if (reg & TAHVO_STAT_VBUS) {
84	switch (tu->phy.state) {
85	case OTG_STATE_B_IDLE:
86	/* Enable the gadget driver */
87	if (tu->phy.otg->gadget)
88	usb_gadget_vbus_connect(tu->phy.otg->gadget);
89	tu->phy.state = OTG_STATE_B_PERIPHERAL;
90	break;
91	case OTG_STATE_A_IDLE:
92	/*
93	* Session is now valid assuming the USB hub is driving
94	* Vbus.
95	*/
96	tu->phy.state = OTG_STATE_A_HOST;
97	break;
98	default:
99	break;
100	}
101	dev_info(&tu->pt_dev->dev, "USB cable connected\n");
102	} else {
103	switch (tu->phy.state) {
104	case OTG_STATE_B_PERIPHERAL:
105	if (tu->phy.otg->gadget)
106	usb_gadget_vbus_disconnect(tu->phy.otg->gadget);
107	tu->phy.state = OTG_STATE_B_IDLE;
108	break;
109	case OTG_STATE_A_HOST:
110	tu->phy.state = OTG_STATE_A_IDLE;
111	break;
112	default:
113	break;
114	}
115	dev_info(&tu->pt_dev->dev, "USB cable disconnected\n");
116	}
117
118	prev_state = tu->vbus_state;
119	tu->vbus_state = reg & TAHVO_STAT_VBUS;
120	if (prev_state != tu->vbus_state) {
121	extcon_set_cable_state(&tu->extcon, "USB", tu->vbus_state);
122	sysfs_notify(&tu->pt_dev->dev.kobj, NULL, "vbus_state");
123	}
124	}
125
126	static void tahvo_usb_become_host(struct tahvo_usb *tu)
127	{
128	struct retu_dev *rdev = dev_get_drvdata(tu->pt_dev->dev.parent);
129
130	extcon_set_cable_state(&tu->extcon, "USB-HOST", true);
131
132	/* Power up the transceiver in USB host mode */
133	retu_write(rdev, TAHVO_REG_USBR, USBR_REGOUT \| USBR_NSUSPEND \|
134	USBR_MASTER_SW2 \| USBR_MASTER_SW1);
135	tu->phy.state = OTG_STATE_A_IDLE;
136
137	check_vbus_state(tu);
138	}
139
140	static void tahvo_usb_stop_host(struct tahvo_usb *tu)
141	{
142	tu->phy.state = OTG_STATE_A_IDLE;
143	}
144
145	static void tahvo_usb_become_peripheral(struct tahvo_usb *tu)
146	{
147	struct retu_dev *rdev = dev_get_drvdata(tu->pt_dev->dev.parent);
148
149	extcon_set_cable_state(&tu->extcon, "USB-HOST", false);
150
151	/* Power up transceiver and set it in USB peripheral mode */
152	retu_write(rdev, TAHVO_REG_USBR, USBR_SLAVE_CONTROL \| USBR_REGOUT \|
153	USBR_NSUSPEND \| USBR_SLAVE_SW);
154	tu->phy.state = OTG_STATE_B_IDLE;
155
156	check_vbus_state(tu);
157	}
158
159	static void tahvo_usb_stop_peripheral(struct tahvo_usb *tu)
160	{
161	if (tu->phy.otg->gadget)
162	usb_gadget_vbus_disconnect(tu->phy.otg->gadget);
163	tu->phy.state = OTG_STATE_B_IDLE;
164	}
165
166	static void tahvo_usb_power_off(struct tahvo_usb *tu)
167	{
168	struct retu_dev *rdev = dev_get_drvdata(tu->pt_dev->dev.parent);
169
170	/* Disable gadget controller if any */
171	if (tu->phy.otg->gadget)
172	usb_gadget_vbus_disconnect(tu->phy.otg->gadget);
173
174	/* Power off transceiver */
175	retu_write(rdev, TAHVO_REG_USBR, 0);
176	tu->phy.state = OTG_STATE_UNDEFINED;
177	}
178
179	static int tahvo_usb_set_suspend(struct usb_phy *dev, int suspend)
180	{
181	struct tahvo_usb *tu = container_of(dev, struct tahvo_usb, phy);
182	struct retu_dev *rdev = dev_get_drvdata(tu->pt_dev->dev.parent);
183	u16 w;
184
185	dev_dbg(&tu->pt_dev->dev, "%s\n", __func__);
186
187	w = retu_read(rdev, TAHVO_REG_USBR);
188	if (suspend)
189	w &= ~USBR_NSUSPEND;
190	else
191	w \|= USBR_NSUSPEND;
192	retu_write(rdev, TAHVO_REG_USBR, w);
193
194	return 0;
195	}
196
197	static int tahvo_usb_set_host(struct usb_otg otg, struct usb_bus host)
198	{
199	struct tahvo_usb *tu = container_of(otg->phy, struct tahvo_usb, phy);
200
201	dev_dbg(&tu->pt_dev->dev, "%s %p\n", __func__, host);
202
9ba96ae5 AK	203	mutex_lock(&tu->serialize);
	204
	205	if (host == NULL) {
	206	if (tu->tahvo_mode == TAHVO_MODE_HOST)
	207	tahvo_usb_power_off(tu);
	208	otg->host = NULL;
	209	mutex_unlock(&tu->serialize);
	210	return 0;
	211	}
	212
	213	if (tu->tahvo_mode == TAHVO_MODE_HOST) {
	214	otg->host = NULL;
	215	tahvo_usb_become_host(tu);
	216	}
	217
	218	otg->host = host;
	219
	220	mutex_unlock(&tu->serialize);
	221
	222	return 0;
	223	}
	224
	225	static int tahvo_usb_set_peripheral(struct usb_otg *otg,
	226	struct usb_gadget *gadget)
	227	{
	228	struct tahvo_usb *tu = container_of(otg->phy, struct tahvo_usb, phy);
	229
	230	dev_dbg(&tu->pt_dev->dev, "%s %p\n", __func__, gadget);
	231
9ba96ae5 AK	232	mutex_lock(&tu->serialize);
	233
	234	if (!gadget) {
	235	if (tu->tahvo_mode == TAHVO_MODE_PERIPHERAL)
	236	tahvo_usb_power_off(tu);
	237	tu->phy.otg->gadget = NULL;
	238	mutex_unlock(&tu->serialize);
	239	return 0;
	240	}
	241
	242	tu->phy.otg->gadget = gadget;
	243	if (tu->tahvo_mode == TAHVO_MODE_PERIPHERAL)
	244	tahvo_usb_become_peripheral(tu);
	245
	246	mutex_unlock(&tu->serialize);
	247
	248	return 0;
	249	}
	250
	251	static irqreturn_t tahvo_usb_vbus_interrupt(int irq, void *_tu)
	252	{
	253	struct tahvo_usb *tu = _tu;
	254
	255	mutex_lock(&tu->serialize);
	256	check_vbus_state(tu);
	257	mutex_unlock(&tu->serialize);
	258
	259	return IRQ_HANDLED;
	260	}
	261
	262	static ssize_t otg_mode_show(struct device *device,
	263	struct device_attribute attr, char buf)
	264	{
	265	struct tahvo_usb *tu = dev_get_drvdata(device);
	266
	267	switch (tu->tahvo_mode) {
	268	case TAHVO_MODE_HOST:
	269	return sprintf(buf, "host\n");
	270	case TAHVO_MODE_PERIPHERAL:
	271	return sprintf(buf, "peripheral\n");
	272	}
	273
	274	return -EINVAL;
	275	}
	276
	277	static ssize_t otg_mode_store(struct device *device,
	278	struct device_attribute *attr,
	279	const char *buf, size_t count)
	280	{
	281	struct tahvo_usb *tu = dev_get_drvdata(device);
	282	int r;
	283
	284	mutex_lock(&tu->serialize);
	285	if (count >= 4 && strncmp(buf, "host", 4) == 0) {
	286	if (tu->tahvo_mode == TAHVO_MODE_PERIPHERAL)
	287	tahvo_usb_stop_peripheral(tu);
	288	tu->tahvo_mode = TAHVO_MODE_HOST;
	289	if (tu->phy.otg->host) {
	290	dev_info(device, "HOST mode: host controller present\n");
	291	tahvo_usb_become_host(tu);
	292	} else {
	293	dev_info(device, "HOST mode: no host controller, powering off\n");
	294	tahvo_usb_power_off(tu);
	295	}
296	r = strlen(buf);
297	} else if (count >= 10 && strncmp(buf, "peripheral", 10) == 0) {
298	if (tu->tahvo_mode == TAHVO_MODE_HOST)
299	tahvo_usb_stop_host(tu);
300	tu->tahvo_mode = TAHVO_MODE_PERIPHERAL;
301	if (tu->phy.otg->gadget) {
302	dev_info(device, "PERIPHERAL mode: gadget driver present\n");
303	tahvo_usb_become_peripheral(tu);
304	} else {
305	dev_info(device, "PERIPHERAL mode: no gadget driver, powering off\n");
306	tahvo_usb_power_off(tu);
307	}
308	r = strlen(buf);
309	} else {
310	r = -EINVAL;
311	}
312	mutex_unlock(&tu->serialize);
313
314	return r;
315	}
316	static DEVICE_ATTR(otg_mode, 0644, otg_mode_show, otg_mode_store);
317
318	static struct attribute *tahvo_attributes[] = {
319	&dev_attr_vbus.attr,
320	&dev_attr_otg_mode.attr,
321	NULL
322	};
323
324	static struct attribute_group tahvo_attr_group = {
325	.attrs = tahvo_attributes,
326	};
327
328	static int tahvo_usb_probe(struct platform_device *pdev)
329	{
330	struct retu_dev *rdev = dev_get_drvdata(pdev->dev.parent);
331	struct tahvo_usb *tu;
332	int ret;
333
334	tu = devm_kzalloc(&pdev->dev, sizeof(*tu), GFP_KERNEL);
335	if (!tu)
336	return -ENOMEM;
337
338	tu->phy.otg = devm_kzalloc(&pdev->dev, sizeof(*tu->phy.otg),
339	GFP_KERNEL);
340	if (!tu->phy.otg)
341	return -ENOMEM;
342
343	tu->pt_dev = pdev;
344
345	/* Default mode */
346	#ifdef CONFIG_TAHVO_USB_HOST_BY_DEFAULT
347	tu->tahvo_mode = TAHVO_MODE_HOST;
348	#else
349	tu->tahvo_mode = TAHVO_MODE_PERIPHERAL;
350	#endif
351
352	mutex_init(&tu->serialize);
353
354	tu->ick = devm_clk_get(&pdev->dev, "usb_l4_ick");
355	if (!IS_ERR(tu->ick))
356	clk_enable(tu->ick);
357
358	/*
359	* Set initial state, so that we generate kevents only on state changes.
360	*/
361	tu->vbus_state = retu_read(rdev, TAHVO_REG_IDSR) & TAHVO_STAT_VBUS;
362
363	tu->extcon.name = DRIVER_NAME;
364	tu->extcon.supported_cable = tahvo_cable;
365	tu->extcon.dev.parent = &pdev->dev;
366
367	ret = extcon_dev_register(&tu->extcon);
368	if (ret) {
369	dev_err(&pdev->dev, "could not register extcon device: %d\n",
370	ret);
371	goto err_disable_clk;
372	}
373
374	/* Set the initial cable state. */
375	extcon_set_cable_state(&tu->extcon, "USB-HOST",
376	tu->tahvo_mode == TAHVO_MODE_HOST);
377	extcon_set_cable_state(&tu->extcon, "USB", tu->vbus_state);
378
379	/* Create OTG interface */
380	tahvo_usb_power_off(tu);
381	tu->phy.dev = &pdev->dev;
382	tu->phy.state = OTG_STATE_UNDEFINED;
383	tu->phy.label = DRIVER_NAME;
384	tu->phy.set_suspend = tahvo_usb_set_suspend;
385
386	tu->phy.otg->phy = &tu->phy;
387	tu->phy.otg->set_host = tahvo_usb_set_host;
388	tu->phy.otg->set_peripheral = tahvo_usb_set_peripheral;
389
390	ret = usb_add_phy(&tu->phy, USB_PHY_TYPE_USB2);
391	if (ret < 0) {
392	dev_err(&pdev->dev, "cannot register USB transceiver: %d\n",
393	ret);
394	goto err_extcon_unreg;
395	}
396
397	dev_set_drvdata(&pdev->dev, tu);
398
399	tu->irq = platform_get_irq(pdev, 0);
400	ret = request_threaded_irq(tu->irq, NULL, tahvo_usb_vbus_interrupt, 0,
401	"tahvo-vbus", tu);
402	if (ret) {
403	dev_err(&pdev->dev, "could not register tahvo-vbus irq: %d\n",
404	ret);
405	goto err_remove_phy;
406	}
407
408	/* Attributes */
409	ret = sysfs_create_group(&pdev->dev.kobj, &tahvo_attr_group);
410	if (ret) {
411	dev_err(&pdev->dev, "cannot create sysfs group: %d\n", ret);
412	goto err_free_irq;
413	}
414
415	return 0;
416
417	err_free_irq:
418	free_irq(tu->irq, tu);
419	err_remove_phy:
420	usb_remove_phy(&tu->phy);
421	err_extcon_unreg:
422	extcon_dev_unregister(&tu->extcon);
423	err_disable_clk:
424	if (!IS_ERR(tu->ick))
425	clk_disable(tu->ick);
426
427	return ret;
428	}
429
430	static int tahvo_usb_remove(struct platform_device *pdev)
431	{
432	struct tahvo_usb *tu = platform_get_drvdata(pdev);
433
434	sysfs_remove_group(&pdev->dev.kobj, &tahvo_attr_group);
435	free_irq(tu->irq, tu);
436	usb_remove_phy(&tu->phy);
437	extcon_dev_unregister(&tu->extcon);
438	if (!IS_ERR(tu->ick))
439	clk_disable(tu->ick);
440
441	return 0;
442	}
443
444	static struct platform_driver tahvo_usb_driver = {
445	.probe = tahvo_usb_probe,
446	.remove = tahvo_usb_remove,
447	.driver = {
448	.name = "tahvo-usb",
449	.owner = THIS_MODULE,
450	},
451	};
452	module_platform_driver(tahvo_usb_driver);
453
454	MODULE_DESCRIPTION("Tahvo USB transceiver driver");
455	MODULE_LICENSE("GPL");
456	MODULE_AUTHOR("Juha Yrjölä, Tony Lindgren, and Timo Teräs");
457	MODULE_AUTHOR("Aaro Koskinen <aaro.koskinen@iki.fi>");