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 48 static 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 dev_dbg(musb->controller, "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 dev_dbg(musb->controller, "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 dev_dbg(musb->controller, "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 116 static 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 dev_dbg(musb->controller, "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 dev_dbg(musb->controller, "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 dev_dbg(musb->controller, "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 184 void 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 dev_dbg(musb->controller, "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 */ 220 int 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 233 int 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 dev_dbg(musb->controller, "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 dev_dbg(musb->controller, "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 dev_dbg(musb->controller, "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 dev_dbg(musb->controller, "set feature %d\n", wValue); 428 musb->port1_status |= 1 << wValue; 429 break; 430 431 default: 432 error: 433 /* "protocol stall" on error */ 434 retval = -EPIPE; 435 } 436 spin_unlock_irqrestore(&musb->lock, flags); 437 return retval; 438 } 439