musb_virthub.c revision dbe79bbe9dcb22cb3651c46f18943477141ca452
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)); 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", otg_state_string(musb)); 212 } 213} 214 215 216/*---------------------------------------------------------------------*/ 217 218/* Caller may or may not hold musb->lock */ 219int musb_hub_status_data(struct usb_hcd *hcd, char *buf) 220{ 221 struct musb *musb = hcd_to_musb(hcd); 222 int retval = 0; 223 224 /* called in_irq() via usb_hcd_poll_rh_status() */ 225 if (musb->port1_status & 0xffff0000) { 226 *buf = 0x02; 227 retval = 1; 228 } 229 return retval; 230} 231 232int musb_hub_control( 233 struct usb_hcd *hcd, 234 u16 typeReq, 235 u16 wValue, 236 u16 wIndex, 237 char *buf, 238 u16 wLength) 239{ 240 struct musb *musb = hcd_to_musb(hcd); 241 u32 temp; 242 int retval = 0; 243 unsigned long flags; 244 245 spin_lock_irqsave(&musb->lock, flags); 246 247 if (unlikely(!HCD_HW_ACCESSIBLE(hcd))) { 248 spin_unlock_irqrestore(&musb->lock, flags); 249 return -ESHUTDOWN; 250 } 251 252 /* hub features: always zero, setting is a NOP 253 * port features: reported, sometimes updated when host is active 254 * no indicators 255 */ 256 switch (typeReq) { 257 case ClearHubFeature: 258 case SetHubFeature: 259 switch (wValue) { 260 case C_HUB_OVER_CURRENT: 261 case C_HUB_LOCAL_POWER: 262 break; 263 default: 264 goto error; 265 } 266 break; 267 case ClearPortFeature: 268 if ((wIndex & 0xff) != 1) 269 goto error; 270 271 switch (wValue) { 272 case USB_PORT_FEAT_ENABLE: 273 break; 274 case USB_PORT_FEAT_SUSPEND: 275 musb_port_suspend(musb, false); 276 break; 277 case USB_PORT_FEAT_POWER: 278 if (!(is_otg_enabled(musb) && hcd->self.is_b_host)) 279 musb_platform_set_vbus(musb, 0); 280 break; 281 case USB_PORT_FEAT_C_CONNECTION: 282 case USB_PORT_FEAT_C_ENABLE: 283 case USB_PORT_FEAT_C_OVER_CURRENT: 284 case USB_PORT_FEAT_C_RESET: 285 case USB_PORT_FEAT_C_SUSPEND: 286 break; 287 default: 288 goto error; 289 } 290 DBG(5, "clear feature %d\n", wValue); 291 musb->port1_status &= ~(1 << wValue); 292 break; 293 case GetHubDescriptor: 294 { 295 struct usb_hub_descriptor *desc = (void *)buf; 296 297 desc->bDescLength = 9; 298 desc->bDescriptorType = 0x29; 299 desc->bNbrPorts = 1; 300 desc->wHubCharacteristics = cpu_to_le16( 301 0x0001 /* per-port power switching */ 302 | 0x0010 /* no overcurrent reporting */ 303 ); 304 desc->bPwrOn2PwrGood = 5; /* msec/2 */ 305 desc->bHubContrCurrent = 0; 306 307 /* workaround bogus struct definition */ 308 desc->u.hs.DeviceRemovable[0] = 0x02; /* port 1 */ 309 desc->u.hs.DeviceRemovable[1] = 0xff; 310 } 311 break; 312 case GetHubStatus: 313 temp = 0; 314 *(__le32 *) buf = cpu_to_le32(temp); 315 break; 316 case GetPortStatus: 317 if (wIndex != 1) 318 goto error; 319 320 /* finish RESET signaling? */ 321 if ((musb->port1_status & USB_PORT_STAT_RESET) 322 && time_after_eq(jiffies, musb->rh_timer)) 323 musb_port_reset(musb, false); 324 325 /* finish RESUME signaling? */ 326 if ((musb->port1_status & MUSB_PORT_STAT_RESUME) 327 && time_after_eq(jiffies, musb->rh_timer)) { 328 u8 power; 329 330 power = musb_readb(musb->mregs, MUSB_POWER); 331 power &= ~MUSB_POWER_RESUME; 332 DBG(4, "root port resume stopped, power %02x\n", 333 power); 334 musb_writeb(musb->mregs, MUSB_POWER, power); 335 336 /* ISSUE: DaVinci (RTL 1.300) disconnects after 337 * resume of high speed peripherals (but not full 338 * speed ones). 339 */ 340 341 musb->is_active = 1; 342 musb->port1_status &= ~(USB_PORT_STAT_SUSPEND 343 | MUSB_PORT_STAT_RESUME); 344 musb->port1_status |= USB_PORT_STAT_C_SUSPEND << 16; 345 usb_hcd_poll_rh_status(musb_to_hcd(musb)); 346 /* NOTE: it might really be A_WAIT_BCON ... */ 347 musb->xceiv->state = OTG_STATE_A_HOST; 348 } 349 350 put_unaligned(cpu_to_le32(musb->port1_status 351 & ~MUSB_PORT_STAT_RESUME), 352 (__le32 *) buf); 353 354 /* port change status is more interesting */ 355 DBG(get_unaligned((u16 *)(buf+2)) ? 2 : 5, "port status %08x\n", 356 musb->port1_status); 357 break; 358 case SetPortFeature: 359 if ((wIndex & 0xff) != 1) 360 goto error; 361 362 switch (wValue) { 363 case USB_PORT_FEAT_POWER: 364 /* NOTE: this controller has a strange state machine 365 * that involves "requesting sessions" according to 366 * magic side effects from incompletely-described 367 * rules about startup... 368 * 369 * This call is what really starts the host mode; be 370 * very careful about side effects if you reorder any 371 * initialization logic, e.g. for OTG, or change any 372 * logic relating to VBUS power-up. 373 */ 374 if (!(is_otg_enabled(musb) && hcd->self.is_b_host)) 375 musb_start(musb); 376 break; 377 case USB_PORT_FEAT_RESET: 378 musb_port_reset(musb, true); 379 break; 380 case USB_PORT_FEAT_SUSPEND: 381 musb_port_suspend(musb, true); 382 break; 383 case USB_PORT_FEAT_TEST: 384 if (unlikely(is_host_active(musb))) 385 goto error; 386 387 wIndex >>= 8; 388 switch (wIndex) { 389 case 1: 390 pr_debug("TEST_J\n"); 391 temp = MUSB_TEST_J; 392 break; 393 case 2: 394 pr_debug("TEST_K\n"); 395 temp = MUSB_TEST_K; 396 break; 397 case 3: 398 pr_debug("TEST_SE0_NAK\n"); 399 temp = MUSB_TEST_SE0_NAK; 400 break; 401 case 4: 402 pr_debug("TEST_PACKET\n"); 403 temp = MUSB_TEST_PACKET; 404 musb_load_testpacket(musb); 405 break; 406 case 5: 407 pr_debug("TEST_FORCE_ENABLE\n"); 408 temp = MUSB_TEST_FORCE_HOST 409 | MUSB_TEST_FORCE_HS; 410 411 musb_writeb(musb->mregs, MUSB_DEVCTL, 412 MUSB_DEVCTL_SESSION); 413 break; 414 case 6: 415 pr_debug("TEST_FIFO_ACCESS\n"); 416 temp = MUSB_TEST_FIFO_ACCESS; 417 break; 418 default: 419 goto error; 420 } 421 musb_writeb(musb->mregs, MUSB_TESTMODE, temp); 422 break; 423 default: 424 goto error; 425 } 426 DBG(5, "set feature %d\n", wValue); 427 musb->port1_status |= 1 << wValue; 428 break; 429 430 default: 431error: 432 /* "protocol stall" on error */ 433 retval = -EPIPE; 434 } 435 spin_unlock_irqrestore(&musb->lock, flags); 436 return retval; 437} 438