2 * MUSB OTG driver virtual root hub support
4 * Copyright 2005 Mentor Graphics Corporation
5 * Copyright (C) 2005-2006 by Texas Instruments
6 * Copyright (C) 2006-2007 Nokia Corporation
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.
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.
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
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.
35 #include <linux/module.h>
36 #include <linux/kernel.h>
37 #include <linux/sched.h>
38 #include <linux/errno.h>
39 #include <linux/time.h>
40 #include <linux/timer.h>
42 #include <asm/unaligned.h>
44 #include "musb_core.h"
46 void musb_host_finish_resume(struct work_struct
*work
)
52 musb
= container_of(work
, struct musb
, finish_resume_work
.work
);
54 spin_lock_irqsave(&musb
->lock
, flags
);
56 power
= musb_readb(musb
->mregs
, MUSB_POWER
);
57 power
&= ~MUSB_POWER_RESUME
;
58 musb_dbg(musb
, "root port resume stopped, power %02x", power
);
59 musb_writeb(musb
->mregs
, MUSB_POWER
, power
);
62 * ISSUE: DaVinci (RTL 1.300) disconnects after
63 * resume of high speed peripherals (but not full
67 musb
->port1_status
&= ~(USB_PORT_STAT_SUSPEND
| MUSB_PORT_STAT_RESUME
);
68 musb
->port1_status
|= USB_PORT_STAT_C_SUSPEND
<< 16;
69 usb_hcd_poll_rh_status(musb
->hcd
);
70 /* NOTE: it might really be A_WAIT_BCON ... */
71 musb
->xceiv
->otg
->state
= OTG_STATE_A_HOST
;
73 spin_unlock_irqrestore(&musb
->lock
, flags
);
76 void musb_port_suspend(struct musb
*musb
, bool do_suspend
)
78 struct usb_otg
*otg
= musb
->xceiv
->otg
;
80 void __iomem
*mbase
= musb
->mregs
;
82 if (!is_host_active(musb
))
85 /* NOTE: this doesn't necessarily put PHY into low power mode,
86 * turning off its clock; that's a function of PHY integration and
87 * MUSB_POWER_ENSUSPEND. PHY may need a clock (sigh) to detect
88 * SE0 changing to connect (J) or wakeup (K) states.
90 power
= musb_readb(mbase
, MUSB_POWER
);
94 power
&= ~MUSB_POWER_RESUME
;
95 power
|= MUSB_POWER_SUSPENDM
;
96 musb_writeb(mbase
, MUSB_POWER
, power
);
98 /* Needed for OPT A tests */
99 power
= musb_readb(mbase
, MUSB_POWER
);
100 while (power
& MUSB_POWER_SUSPENDM
) {
101 power
= musb_readb(mbase
, MUSB_POWER
);
106 musb_dbg(musb
, "Root port suspended, power %02x", power
);
108 musb
->port1_status
|= USB_PORT_STAT_SUSPEND
;
109 switch (musb
->xceiv
->otg
->state
) {
110 case OTG_STATE_A_HOST
:
111 musb
->xceiv
->otg
->state
= OTG_STATE_A_SUSPEND
;
112 musb
->is_active
= otg
->host
->b_hnp_enable
;
114 mod_timer(&musb
->otg_timer
, jiffies
116 OTG_TIME_A_AIDL_BDIS
));
117 musb_platform_try_idle(musb
, 0);
119 case OTG_STATE_B_HOST
:
120 musb
->xceiv
->otg
->state
= OTG_STATE_B_WAIT_ACON
;
121 musb
->is_active
= otg
->host
->b_hnp_enable
;
122 musb_platform_try_idle(musb
, 0);
125 musb_dbg(musb
, "bogus rh suspend? %s",
126 usb_otg_state_string(musb
->xceiv
->otg
->state
));
128 } else if (power
& MUSB_POWER_SUSPENDM
) {
129 power
&= ~MUSB_POWER_SUSPENDM
;
130 power
|= MUSB_POWER_RESUME
;
131 musb_writeb(mbase
, MUSB_POWER
, power
);
133 musb_dbg(musb
, "Root port resuming, power %02x", power
);
135 /* later, GetPortStatus will stop RESUME signaling */
136 musb
->port1_status
|= MUSB_PORT_STAT_RESUME
;
137 schedule_delayed_work(&musb
->finish_resume_work
,
138 msecs_to_jiffies(USB_RESUME_TIMEOUT
));
142 void musb_port_reset(struct musb
*musb
, bool do_reset
)
145 void __iomem
*mbase
= musb
->mregs
;
147 if (musb
->xceiv
->otg
->state
== OTG_STATE_B_IDLE
) {
148 musb_dbg(musb
, "HNP: Returning from HNP; no hub reset from b_idle");
149 musb
->port1_status
&= ~USB_PORT_STAT_RESET
;
153 if (!is_host_active(musb
))
156 /* NOTE: caller guarantees it will turn off the reset when
157 * the appropriate amount of time has passed
159 power
= musb_readb(mbase
, MUSB_POWER
);
162 * If RESUME is set, we must make sure it stays minimum 20 ms.
163 * Then we must clear RESUME and wait a bit to let musb start
164 * generating SOFs. If we don't do this, OPT HS A 6.8 tests
165 * fail with "Error! Did not receive an SOF before suspend
168 if (power
& MUSB_POWER_RESUME
) {
169 long remain
= (unsigned long) musb
->rh_timer
- jiffies
;
171 if (musb
->rh_timer
> 0 && remain
> 0) {
172 /* take into account the minimum delay after resume */
173 schedule_delayed_work(
174 &musb
->deassert_reset_work
, remain
);
178 musb_writeb(mbase
, MUSB_POWER
,
179 power
& ~MUSB_POWER_RESUME
);
181 /* Give the core 1 ms to clear MUSB_POWER_RESUME */
182 schedule_delayed_work(&musb
->deassert_reset_work
,
183 msecs_to_jiffies(1));
188 musb_writeb(mbase
, MUSB_POWER
,
189 power
| MUSB_POWER_RESET
);
191 musb
->port1_status
|= USB_PORT_STAT_RESET
;
192 musb
->port1_status
&= ~USB_PORT_STAT_ENABLE
;
193 schedule_delayed_work(&musb
->deassert_reset_work
,
194 msecs_to_jiffies(50));
196 musb_dbg(musb
, "root port reset stopped");
197 musb_platform_pre_root_reset_end(musb
);
198 musb_writeb(mbase
, MUSB_POWER
,
199 power
& ~MUSB_POWER_RESET
);
200 musb_platform_post_root_reset_end(musb
);
202 power
= musb_readb(mbase
, MUSB_POWER
);
203 if (power
& MUSB_POWER_HSMODE
) {
204 musb_dbg(musb
, "high-speed device connected");
205 musb
->port1_status
|= USB_PORT_STAT_HIGH_SPEED
;
208 musb
->port1_status
&= ~USB_PORT_STAT_RESET
;
209 musb
->port1_status
|= USB_PORT_STAT_ENABLE
210 | (USB_PORT_STAT_C_RESET
<< 16)
211 | (USB_PORT_STAT_C_ENABLE
<< 16);
212 usb_hcd_poll_rh_status(musb
->hcd
);
214 musb
->vbuserr_retry
= VBUSERR_RETRY_COUNT
;
218 void musb_root_disconnect(struct musb
*musb
)
220 struct usb_otg
*otg
= musb
->xceiv
->otg
;
222 musb
->port1_status
= USB_PORT_STAT_POWER
223 | (USB_PORT_STAT_C_CONNECTION
<< 16);
225 usb_hcd_poll_rh_status(musb
->hcd
);
228 switch (musb
->xceiv
->otg
->state
) {
229 case OTG_STATE_A_SUSPEND
:
230 if (otg
->host
->b_hnp_enable
) {
231 musb
->xceiv
->otg
->state
= OTG_STATE_A_PERIPHERAL
;
232 musb
->g
.is_a_peripheral
= 1;
236 case OTG_STATE_A_HOST
:
237 musb
->xceiv
->otg
->state
= OTG_STATE_A_WAIT_BCON
;
240 case OTG_STATE_A_WAIT_VFALL
:
241 musb
->xceiv
->otg
->state
= OTG_STATE_B_IDLE
;
244 musb_dbg(musb
, "host disconnect (%s)",
245 usb_otg_state_string(musb
->xceiv
->otg
->state
));
250 /*---------------------------------------------------------------------*/
252 /* Caller may or may not hold musb->lock */
253 int musb_hub_status_data(struct usb_hcd
*hcd
, char *buf
)
255 struct musb
*musb
= hcd_to_musb(hcd
);
258 /* called in_irq() via usb_hcd_poll_rh_status() */
259 if (musb
->port1_status
& 0xffff0000) {
266 static int musb_has_gadget(struct musb
*musb
)
269 * In host-only mode we start a connection right away. In OTG mode
270 * we have to wait until we loaded a gadget. We don't really need a
271 * gadget if we operate as a host but we should not start a session
272 * as a device without a gadget or else we explode.
274 #ifdef CONFIG_USB_MUSB_HOST
277 return musb
->port_mode
== MUSB_PORT_MODE_HOST
;
281 int musb_hub_control(
289 struct musb
*musb
= hcd_to_musb(hcd
);
294 spin_lock_irqsave(&musb
->lock
, flags
);
296 if (unlikely(!HCD_HW_ACCESSIBLE(hcd
))) {
297 spin_unlock_irqrestore(&musb
->lock
, flags
);
301 /* hub features: always zero, setting is a NOP
302 * port features: reported, sometimes updated when host is active
306 case ClearHubFeature
:
309 case C_HUB_OVER_CURRENT
:
310 case C_HUB_LOCAL_POWER
:
316 case ClearPortFeature
:
317 if ((wIndex
& 0xff) != 1)
321 case USB_PORT_FEAT_ENABLE
:
323 case USB_PORT_FEAT_SUSPEND
:
324 musb_port_suspend(musb
, false);
326 case USB_PORT_FEAT_POWER
:
327 if (!hcd
->self
.is_b_host
)
328 musb_platform_set_vbus(musb
, 0);
330 case USB_PORT_FEAT_C_CONNECTION
:
331 case USB_PORT_FEAT_C_ENABLE
:
332 case USB_PORT_FEAT_C_OVER_CURRENT
:
333 case USB_PORT_FEAT_C_RESET
:
334 case USB_PORT_FEAT_C_SUSPEND
:
339 musb_dbg(musb
, "clear feature %d", wValue
);
340 musb
->port1_status
&= ~(1 << wValue
);
342 case GetHubDescriptor
:
344 struct usb_hub_descriptor
*desc
= (void *)buf
;
346 desc
->bDescLength
= 9;
347 desc
->bDescriptorType
= USB_DT_HUB
;
349 desc
->wHubCharacteristics
= cpu_to_le16(
350 HUB_CHAR_INDV_PORT_LPSM
/* per-port power switching */
351 | HUB_CHAR_NO_OCPM
/* no overcurrent reporting */
353 desc
->bPwrOn2PwrGood
= 5; /* msec/2 */
354 desc
->bHubContrCurrent
= 0;
356 /* workaround bogus struct definition */
357 desc
->u
.hs
.DeviceRemovable
[0] = 0x02; /* port 1 */
358 desc
->u
.hs
.DeviceRemovable
[1] = 0xff;
363 *(__le32
*) buf
= cpu_to_le32(temp
);
369 put_unaligned(cpu_to_le32(musb
->port1_status
370 & ~MUSB_PORT_STAT_RESUME
),
373 /* port change status is more interesting */
374 musb_dbg(musb
, "port status %08x", musb
->port1_status
);
377 if ((wIndex
& 0xff) != 1)
381 case USB_PORT_FEAT_POWER
:
382 /* NOTE: this controller has a strange state machine
383 * that involves "requesting sessions" according to
384 * magic side effects from incompletely-described
385 * rules about startup...
387 * This call is what really starts the host mode; be
388 * very careful about side effects if you reorder any
389 * initialization logic, e.g. for OTG, or change any
390 * logic relating to VBUS power-up.
392 if (!hcd
->self
.is_b_host
&& musb_has_gadget(musb
))
395 case USB_PORT_FEAT_RESET
:
396 musb_port_reset(musb
, true);
398 case USB_PORT_FEAT_SUSPEND
:
399 musb_port_suspend(musb
, true);
401 case USB_PORT_FEAT_TEST
:
402 if (unlikely(is_host_active(musb
)))
408 pr_debug("TEST_J\n");
412 pr_debug("TEST_K\n");
416 pr_debug("TEST_SE0_NAK\n");
417 temp
= MUSB_TEST_SE0_NAK
;
420 pr_debug("TEST_PACKET\n");
421 temp
= MUSB_TEST_PACKET
;
422 musb_load_testpacket(musb
);
425 pr_debug("TEST_FORCE_ENABLE\n");
426 temp
= MUSB_TEST_FORCE_HOST
427 | MUSB_TEST_FORCE_HS
;
429 musb_writeb(musb
->mregs
, MUSB_DEVCTL
,
430 MUSB_DEVCTL_SESSION
);
433 pr_debug("TEST_FIFO_ACCESS\n");
434 temp
= MUSB_TEST_FIFO_ACCESS
;
439 musb_writeb(musb
->mregs
, MUSB_TESTMODE
, temp
);
444 musb_dbg(musb
, "set feature %d", wValue
);
445 musb
->port1_status
|= 1 << wValue
;
450 /* "protocol stall" on error */
453 spin_unlock_irqrestore(&musb
->lock
, flags
);