musb_virthub.c revision 3df004532582d0cc721da0df28311bcedd639724 
1/*
2 * MUSB OTG driver virtual root hub support
3 *
4 * Copyright 2005 Mentor Graphics Corporation
5 * Copyright (C) 2005-2006 by Texas Instruments
6 * Copyright (C) 2006-2007 Nokia Corporation
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA
21 *
22 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
23 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
24 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
25 * NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
28 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
29 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 *
33 */
34
35#include <linux/module.h>
36#include <linux/kernel.h>
37#include <linux/sched.h>
38#include <linux/errno.h>
39#include <linux/init.h>
40#include <linux/time.h>
41#include <linux/timer.h>
42
43#include <asm/unaligned.h>
44
45#include "musb_core.h"
46
47
48static void musb_port_suspend(struct musb *musb, bool do_suspend)
49{
50	u8		power;
51	void __iomem	*mbase = musb->mregs;
52
53	if (!is_host_active(musb))
54		return;
55
56	/* NOTE:  this doesn't necessarily put PHY into low power mode,
57	 * turning off its clock; that's a function of PHY integration and
58	 * MUSB_POWER_ENSUSPEND.  PHY may need a clock (sigh) to detect
59	 * SE0 changing to connect (J) or wakeup (K) states.
60	 */
61	power = musb_readb(mbase, MUSB_POWER);
62	if (do_suspend) {
63		int retries = 10000;
64
65		power &= ~MUSB_POWER_RESUME;
66		power |= MUSB_POWER_SUSPENDM;
67		musb_writeb(mbase, MUSB_POWER, power);
68
69		/* Needed for OPT A tests */
70		power = musb_readb(mbase, MUSB_POWER);
71		while (power & MUSB_POWER_SUSPENDM) {
72			power = musb_readb(mbase, MUSB_POWER);
73			if (retries-- < 1)
74				break;
75		}
76
77		DBG(3, "Root port suspended, power %02x\n", power);
78
79		musb->port1_status |= USB_PORT_STAT_SUSPEND;
80		switch (musb->xceiv->state) {
81		case OTG_STATE_A_HOST:
82			musb->xceiv->state = OTG_STATE_A_SUSPEND;
83			musb->is_active = is_otg_enabled(musb)
84					&& musb->xceiv->host->b_hnp_enable;
85			if (musb->is_active)
86				mod_timer(&musb->otg_timer, jiffies
87					+ msecs_to_jiffies(
88						OTG_TIME_A_AIDL_BDIS));
89			musb_platform_try_idle(musb, 0);
90			break;
91#ifdef	CONFIG_USB_MUSB_OTG
92		case OTG_STATE_B_HOST:
93			musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
94			musb->is_active = is_otg_enabled(musb)
95					&& musb->xceiv->host->b_hnp_enable;
96			musb_platform_try_idle(musb, 0);
97			break;
98#endif
99		default:
100			DBG(1, "bogus rh suspend? %s\n",
101				otg_state_string(musb->xceiv->state));
102		}
103	} else if (power & MUSB_POWER_SUSPENDM) {
104		power &= ~MUSB_POWER_SUSPENDM;
105		power |= MUSB_POWER_RESUME;
106		musb_writeb(mbase, MUSB_POWER, power);
107
108		DBG(3, "Root port resuming, power %02x\n", power);
109
110		/* later, GetPortStatus will stop RESUME signaling */
111		musb->port1_status |= MUSB_PORT_STAT_RESUME;
112		musb->rh_timer = jiffies + msecs_to_jiffies(20);
113	}
114}
115
116static void musb_port_reset(struct musb *musb, bool do_reset)
117{
118	u8		power;
119	void __iomem	*mbase = musb->mregs;
120
121#ifdef CONFIG_USB_MUSB_OTG
122	if (musb->xceiv->state == OTG_STATE_B_IDLE) {
123		DBG(2, "HNP: Returning from HNP; no hub reset from b_idle\n");
124		musb->port1_status &= ~USB_PORT_STAT_RESET;
125		return;
126	}
127#endif
128
129	if (!is_host_active(musb))
130		return;
131
132	/* NOTE:  caller guarantees it will turn off the reset when
133	 * the appropriate amount of time has passed
134	 */
135	power = musb_readb(mbase, MUSB_POWER);
136	if (do_reset) {
137
138		/*
139		 * If RESUME is set, we must make sure it stays minimum 20 ms.
140		 * Then we must clear RESUME and wait a bit to let musb start
141		 * generating SOFs. If we don't do this, OPT HS A 6.8 tests
142		 * fail with "Error! Did not receive an SOF before suspend
143		 * detected".
144		 */
145		if (power &  MUSB_POWER_RESUME) {
146			while (time_before(jiffies, musb->rh_timer))
147				msleep(1);
148			musb_writeb(mbase, MUSB_POWER,
149				power & ~MUSB_POWER_RESUME);
150			msleep(1);
151		}
152
153		musb->ignore_disconnect = true;
154		power &= 0xf0;
155		musb_writeb(mbase, MUSB_POWER,
156				power | MUSB_POWER_RESET);
157
158		musb->port1_status |= USB_PORT_STAT_RESET;
159		musb->port1_status &= ~USB_PORT_STAT_ENABLE;
160		musb->rh_timer = jiffies + msecs_to_jiffies(50);
161	} else {
162		DBG(4, "root port reset stopped\n");
163		musb_writeb(mbase, MUSB_POWER,
164				power & ~MUSB_POWER_RESET);
165
166		musb->ignore_disconnect = false;
167
168		power = musb_readb(mbase, MUSB_POWER);
169		if (power & MUSB_POWER_HSMODE) {
170			DBG(4, "high-speed device connected\n");
171			musb->port1_status |= USB_PORT_STAT_HIGH_SPEED;
172		}
173
174		musb->port1_status &= ~USB_PORT_STAT_RESET;
175		musb->port1_status |= USB_PORT_STAT_ENABLE
176					| (USB_PORT_STAT_C_RESET << 16)
177					| (USB_PORT_STAT_C_ENABLE << 16);
178		usb_hcd_poll_rh_status(musb_to_hcd(musb));
179
180		musb->vbuserr_retry = VBUSERR_RETRY_COUNT;
181	}
182}
183
184void musb_root_disconnect(struct musb *musb)
185{
186	musb->port1_status = USB_PORT_STAT_POWER
187			| (USB_PORT_STAT_C_CONNECTION << 16);
188
189	usb_hcd_poll_rh_status(musb_to_hcd(musb));
190	musb->is_active = 0;
191
192	switch (musb->xceiv->state) {
193	case OTG_STATE_A_SUSPEND:
194#ifdef	CONFIG_USB_MUSB_OTG
195		if (is_otg_enabled(musb)
196				&& musb->xceiv->host->b_hnp_enable) {
197			musb->xceiv->state = OTG_STATE_A_PERIPHERAL;
198			musb->g.is_a_peripheral = 1;
199			break;
200		}
201#endif
202		/* FALLTHROUGH */
203	case OTG_STATE_A_HOST:
204		musb->xceiv->state = OTG_STATE_A_WAIT_BCON;
205		musb->is_active = 0;
206		break;
207	case OTG_STATE_A_WAIT_VFALL:
208		musb->xceiv->state = OTG_STATE_B_IDLE;
209		break;
210	default:
211		DBG(1, "host disconnect (%s)\n",
212			otg_state_string(musb->xceiv->state));
213	}
214}
215
216
217/*---------------------------------------------------------------------*/
218
219/* Caller may or may not hold musb->lock */
220int musb_hub_status_data(struct usb_hcd *hcd, char *buf)
221{
222	struct musb	*musb = hcd_to_musb(hcd);
223	int		retval = 0;
224
225	/* called in_irq() via usb_hcd_poll_rh_status() */
226	if (musb->port1_status & 0xffff0000) {
227		*buf = 0x02;
228		retval = 1;
229	}
230	return retval;
231}
232
233int musb_hub_control(
234	struct usb_hcd	*hcd,
235	u16		typeReq,
236	u16		wValue,
237	u16		wIndex,
238	char		*buf,
239	u16		wLength)
240{
241	struct musb	*musb = hcd_to_musb(hcd);
242	u32		temp;
243	int		retval = 0;
244	unsigned long	flags;
245
246	spin_lock_irqsave(&musb->lock, flags);
247
248	if (unlikely(!HCD_HW_ACCESSIBLE(hcd))) {
249		spin_unlock_irqrestore(&musb->lock, flags);
250		return -ESHUTDOWN;
251	}
252
253	/* hub features:  always zero, setting is a NOP
254	 * port features: reported, sometimes updated when host is active
255	 * no indicators
256	 */
257	switch (typeReq) {
258	case ClearHubFeature:
259	case SetHubFeature:
260		switch (wValue) {
261		case C_HUB_OVER_CURRENT:
262		case C_HUB_LOCAL_POWER:
263			break;
264		default:
265			goto error;
266		}
267		break;
268	case ClearPortFeature:
269		if ((wIndex & 0xff) != 1)
270			goto error;
271
272		switch (wValue) {
273		case USB_PORT_FEAT_ENABLE:
274			break;
275		case USB_PORT_FEAT_SUSPEND:
276			musb_port_suspend(musb, false);
277			break;
278		case USB_PORT_FEAT_POWER:
279			if (!(is_otg_enabled(musb) && hcd->self.is_b_host))
280				musb_platform_set_vbus(musb, 0);
281			break;
282		case USB_PORT_FEAT_C_CONNECTION:
283		case USB_PORT_FEAT_C_ENABLE:
284		case USB_PORT_FEAT_C_OVER_CURRENT:
285		case USB_PORT_FEAT_C_RESET:
286		case USB_PORT_FEAT_C_SUSPEND:
287			break;
288		default:
289			goto error;
290		}
291		DBG(5, "clear feature %d\n", wValue);
292		musb->port1_status &= ~(1 << wValue);
293		break;
294	case GetHubDescriptor:
295		{
296		struct usb_hub_descriptor *desc = (void *)buf;
297
298		desc->bDescLength = 9;
299		desc->bDescriptorType = 0x29;
300		desc->bNbrPorts = 1;
301		desc->wHubCharacteristics = cpu_to_le16(
302				  0x0001	/* per-port power switching */
303				| 0x0010	/* no overcurrent reporting */
304				);
305		desc->bPwrOn2PwrGood = 5;	/* msec/2 */
306		desc->bHubContrCurrent = 0;
307
308		/* workaround bogus struct definition */
309		desc->u.hs.DeviceRemovable[0] = 0x02;	/* port 1 */
310		desc->u.hs.DeviceRemovable[1] = 0xff;
311		}
312		break;
313	case GetHubStatus:
314		temp = 0;
315		*(__le32 *) buf = cpu_to_le32(temp);
316		break;
317	case GetPortStatus:
318		if (wIndex != 1)
319			goto error;
320
321		/* finish RESET signaling? */
322		if ((musb->port1_status & USB_PORT_STAT_RESET)
323				&& time_after_eq(jiffies, musb->rh_timer))
324			musb_port_reset(musb, false);
325
326		/* finish RESUME signaling? */
327		if ((musb->port1_status & MUSB_PORT_STAT_RESUME)
328				&& time_after_eq(jiffies, musb->rh_timer)) {
329			u8		power;
330
331			power = musb_readb(musb->mregs, MUSB_POWER);
332			power &= ~MUSB_POWER_RESUME;
333			DBG(4, "root port resume stopped, power %02x\n",
334					power);
335			musb_writeb(musb->mregs, MUSB_POWER, power);
336
337			/* ISSUE:  DaVinci (RTL 1.300) disconnects after
338			 * resume of high speed peripherals (but not full
339			 * speed ones).
340			 */
341
342			musb->is_active = 1;
343			musb->port1_status &= ~(USB_PORT_STAT_SUSPEND
344					| MUSB_PORT_STAT_RESUME);
345			musb->port1_status |= USB_PORT_STAT_C_SUSPEND << 16;
346			usb_hcd_poll_rh_status(musb_to_hcd(musb));
347			/* NOTE: it might really be A_WAIT_BCON ... */
348			musb->xceiv->state = OTG_STATE_A_HOST;
349		}
350
351		put_unaligned(cpu_to_le32(musb->port1_status
352					& ~MUSB_PORT_STAT_RESUME),
353				(__le32 *) buf);
354
355		/* port change status is more interesting */
356		DBG(get_unaligned((u16 *)(buf+2)) ? 2 : 5, "port status %08x\n",
357				musb->port1_status);
358		break;
359	case SetPortFeature:
360		if ((wIndex & 0xff) != 1)
361			goto error;
362
363		switch (wValue) {
364		case USB_PORT_FEAT_POWER:
365			/* NOTE: this controller has a strange state machine
366			 * that involves "requesting sessions" according to
367			 * magic side effects from incompletely-described
368			 * rules about startup...
369			 *
370			 * This call is what really starts the host mode; be
371			 * very careful about side effects if you reorder any
372			 * initialization logic, e.g. for OTG, or change any
373			 * logic relating to VBUS power-up.
374			 */
375			if (!(is_otg_enabled(musb) && hcd->self.is_b_host))
376				musb_start(musb);
377			break;
378		case USB_PORT_FEAT_RESET:
379			musb_port_reset(musb, true);
380			break;
381		case USB_PORT_FEAT_SUSPEND:
382			musb_port_suspend(musb, true);
383			break;
384		case USB_PORT_FEAT_TEST:
385			if (unlikely(is_host_active(musb)))
386				goto error;
387
388			wIndex >>= 8;
389			switch (wIndex) {
390			case 1:
391				pr_debug("TEST_J\n");
392				temp = MUSB_TEST_J;
393				break;
394			case 2:
395				pr_debug("TEST_K\n");
396				temp = MUSB_TEST_K;
397				break;
398			case 3:
399				pr_debug("TEST_SE0_NAK\n");
400				temp = MUSB_TEST_SE0_NAK;
401				break;
402			case 4:
403				pr_debug("TEST_PACKET\n");
404				temp = MUSB_TEST_PACKET;
405				musb_load_testpacket(musb);
406				break;
407			case 5:
408				pr_debug("TEST_FORCE_ENABLE\n");
409				temp = MUSB_TEST_FORCE_HOST
410					| MUSB_TEST_FORCE_HS;
411
412				musb_writeb(musb->mregs, MUSB_DEVCTL,
413						MUSB_DEVCTL_SESSION);
414				break;
415			case 6:
416				pr_debug("TEST_FIFO_ACCESS\n");
417				temp = MUSB_TEST_FIFO_ACCESS;
418				break;
419			default:
420				goto error;
421			}
422			musb_writeb(musb->mregs, MUSB_TESTMODE, temp);
423			break;
424		default:
425			goto error;
426		}
427		DBG(5, "set feature %d\n", wValue);
428		musb->port1_status |= 1 << wValue;
429		break;
430
431	default:
432error:
433		/* "protocol stall" on error */
434		retval = -EPIPE;
435	}
436	spin_unlock_irqrestore(&musb->lock, flags);
437	return retval;
438}
439