musb_virthub.c revision ab983f2a1be582b00f706013f40f658769d0823a
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/slab.h> 39#include <linux/errno.h> 40#include <linux/init.h> 41#include <linux/time.h> 42#include <linux/timer.h> 43 44#include <asm/unaligned.h> 45 46#include "musb_core.h" 47 48 49static void musb_port_suspend(struct musb *musb, bool do_suspend) 50{ 51 u8 power; 52 void __iomem *mbase = musb->mregs; 53 54 if (!is_host_active(musb)) 55 return; 56 57 /* NOTE: this doesn't necessarily put PHY into low power mode, 58 * turning off its clock; that's a function of PHY integration and 59 * MUSB_POWER_ENSUSPEND. PHY may need a clock (sigh) to detect 60 * SE0 changing to connect (J) or wakeup (K) states. 61 */ 62 power = musb_readb(mbase, MUSB_POWER); 63 if (do_suspend) { 64 int retries = 10000; 65 66 power &= ~MUSB_POWER_RESUME; 67 power |= MUSB_POWER_SUSPENDM; 68 musb_writeb(mbase, MUSB_POWER, power); 69 70 /* Needed for OPT A tests */ 71 power = musb_readb(mbase, MUSB_POWER); 72 while (power & MUSB_POWER_SUSPENDM) { 73 power = musb_readb(mbase, MUSB_POWER); 74 if (retries-- < 1) 75 break; 76 } 77 78 DBG(3, "Root port suspended, power %02x\n", power); 79 80 musb->port1_status |= USB_PORT_STAT_SUSPEND; 81 switch (musb->xceiv->state) { 82 case OTG_STATE_A_HOST: 83 musb->xceiv->state = OTG_STATE_A_SUSPEND; 84 musb->is_active = is_otg_enabled(musb) 85 && musb->xceiv->host->b_hnp_enable; 86 if (musb->is_active) 87 mod_timer(&musb->otg_timer, jiffies 88 + msecs_to_jiffies( 89 OTG_TIME_A_AIDL_BDIS)); 90 musb_platform_try_idle(musb, 0); 91 break; 92#ifdef CONFIG_USB_MUSB_OTG 93 case OTG_STATE_B_HOST: 94 musb->xceiv->state = OTG_STATE_B_WAIT_ACON; 95 musb->is_active = is_otg_enabled(musb) 96 && musb->xceiv->host->b_hnp_enable; 97 musb_platform_try_idle(musb, 0); 98 break; 99#endif 100 default: 101 DBG(1, "bogus rh suspend? %s\n", 102 otg_state_string(musb)); 103 } 104 } else if (power & MUSB_POWER_SUSPENDM) { 105 power &= ~MUSB_POWER_SUSPENDM; 106 power |= MUSB_POWER_RESUME; 107 musb_writeb(mbase, MUSB_POWER, power); 108 109 DBG(3, "Root port resuming, power %02x\n", power); 110 111 /* later, GetPortStatus will stop RESUME signaling */ 112 musb->port1_status |= MUSB_PORT_STAT_RESUME; 113 musb->rh_timer = jiffies + msecs_to_jiffies(20); 114 } 115} 116 117static void musb_port_reset(struct musb *musb, bool do_reset) 118{ 119 u8 power; 120 void __iomem *mbase = musb->mregs; 121 122#ifdef CONFIG_USB_MUSB_OTG 123 if (musb->xceiv->state == OTG_STATE_B_IDLE) { 124 DBG(2, "HNP: Returning from HNP; no hub reset from b_idle\n"); 125 musb->port1_status &= ~USB_PORT_STAT_RESET; 126 return; 127 } 128#endif 129 130 if (!is_host_active(musb)) 131 return; 132 133 /* NOTE: caller guarantees it will turn off the reset when 134 * the appropriate amount of time has passed 135 */ 136 power = musb_readb(mbase, MUSB_POWER); 137 if (do_reset) { 138 139 /* 140 * If RESUME is set, we must make sure it stays minimum 20 ms. 141 * Then we must clear RESUME and wait a bit to let musb start 142 * generating SOFs. If we don't do this, OPT HS A 6.8 tests 143 * fail with "Error! Did not receive an SOF before suspend 144 * detected". 145 */ 146 if (power & MUSB_POWER_RESUME) { 147 while (time_before(jiffies, musb->rh_timer)) 148 msleep(1); 149 musb_writeb(mbase, MUSB_POWER, 150 power & ~MUSB_POWER_RESUME); 151 msleep(1); 152 } 153 154 musb->ignore_disconnect = true; 155 power &= 0xf0; 156 musb_writeb(mbase, MUSB_POWER, 157 power | MUSB_POWER_RESET); 158 159 musb->port1_status |= USB_PORT_STAT_RESET; 160 musb->port1_status &= ~USB_PORT_STAT_ENABLE; 161 musb->rh_timer = jiffies + msecs_to_jiffies(50); 162 } else { 163 DBG(4, "root port reset stopped\n"); 164 musb_writeb(mbase, MUSB_POWER, 165 power & ~MUSB_POWER_RESET); 166 167 musb->ignore_disconnect = false; 168 169 power = musb_readb(mbase, MUSB_POWER); 170 if (power & MUSB_POWER_HSMODE) { 171 DBG(4, "high-speed device connected\n"); 172 musb->port1_status |= USB_PORT_STAT_HIGH_SPEED; 173 } 174 175 musb->port1_status &= ~USB_PORT_STAT_RESET; 176 musb->port1_status |= USB_PORT_STAT_ENABLE 177 | (USB_PORT_STAT_C_RESET << 16) 178 | (USB_PORT_STAT_C_ENABLE << 16); 179 usb_hcd_poll_rh_status(musb_to_hcd(musb)); 180 181 musb->vbuserr_retry = VBUSERR_RETRY_COUNT; 182 } 183} 184 185void musb_root_disconnect(struct musb *musb) 186{ 187 musb->port1_status = (1 << USB_PORT_FEAT_POWER) 188 | (1 << USB_PORT_FEAT_C_CONNECTION); 189 190 usb_hcd_poll_rh_status(musb_to_hcd(musb)); 191 musb->is_active = 0; 192 193 switch (musb->xceiv->state) { 194 case OTG_STATE_A_SUSPEND: 195#ifdef CONFIG_USB_MUSB_OTG 196 if (is_otg_enabled(musb) 197 && musb->xceiv->host->b_hnp_enable) { 198 musb->xceiv->state = OTG_STATE_A_PERIPHERAL; 199 musb->g.is_a_peripheral = 1; 200 break; 201 } 202#endif 203 /* FALLTHROUGH */ 204 case OTG_STATE_A_HOST: 205 musb->xceiv->state = OTG_STATE_A_WAIT_BCON; 206 musb->is_active = 0; 207 break; 208 case OTG_STATE_A_WAIT_VFALL: 209 musb->xceiv->state = OTG_STATE_B_IDLE; 210 break; 211 default: 212 DBG(1, "host disconnect (%s)\n", otg_state_string(musb)); 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(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))) { 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_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->DeviceRemovable[0] = 0x02; /* port 1 */ 310 desc->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