vcs.maemo.org Git - kernel-bfs/blob - kernel-bfs-2.6.28/debian/patches/usbhost.diff

   1 --- kernel-power-2.6.28.orig/drivers/usb/core/generic.c
   2 +++ kernel-power-2.6.28/drivers/usb/core/generic.c
   3 @@ -97,10 +97,10 @@
   4                  */
   5
   6                 /* Rule out configs that draw too much bus current */
   7 -               if (c->desc.bMaxPower * 2 > udev->bus_mA) {
   8 +               /*if (c->desc.bMaxPower * 2 > udev->bus_mA) {
   9                         insufficient_power++;
  10                         continue;
  11 -               }
  12 +               }*/
  13
  14                 /* When the first config's first interface is one of Microsoft's
  15                  * pet nonstandard Ethernet-over-USB protocols, ignore it unless
  16 @@ -132,10 +132,10 @@
  17                         best = c;
  18         }
  19
  20 -       if (insufficient_power > 0)
  21 +       /*if (insufficient_power > 0)
  22                 dev_info(&udev->dev, "rejected %d configuration%s "
  23                         "due to insufficient available bus power\n",
  24 -                       insufficient_power, plural(insufficient_power));
  25 +                       insufficient_power, plural(insufficient_power));*/
  26
  27         if (best) {
  28                 i = best->desc.bConfigurationValue;
  29 --- kernel-power-2.6.28.orig/drivers/usb/core/otg_whitelist.h
  30 +++ kernel-power-2.6.28/drivers/usb/core/otg_whitelist.h
  31 @@ -14,7 +14,7 @@
  32  #else
  33  static inline int is_targeted(struct usb_device *d)
  34  {
  35 -       return 0;
  36 +       return 1;
  37  }
  38  #endif
  39
  40 --- kernel-power-2.6.28.orig/drivers/usb/gadget/ether.c
  41 +++ kernel-power-2.6.28/drivers/usb/gadget/ether.c
  42 @@ -241,7 +241,8 @@
  43         .bind                   = rndis_do_config,
  44         .bConfigurationValue    = 2,
  45         /* .iConfiguration = DYNAMIC */
  46 -       .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
  47 +       .bmAttributes   = USB_CONFIG_ATT_ONE,
  48 +       .bMaxPower      = 250, /* 500mA */
  49  };
  50
  51  /*-------------------------------------------------------------------------*/
  52 @@ -269,7 +270,8 @@
  53         .bind                   = eth_do_config,
  54         .bConfigurationValue    = 1,
  55         /* .iConfiguration = DYNAMIC */
  56 -       .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
  57 +       .bmAttributes   = USB_CONFIG_ATT_ONE,
  58 +       .bMaxPower      = 250, /* 500mA */
  59  };
  60
  61  /*-------------------------------------------------------------------------*/
  62 --- kernel-power-2.6.28.orig/drivers/usb/musb/isp1704.h
  63 +++ kernel-power-2.6.28/drivers/usb/musb/isp1704.h
  64 @@ -39,21 +39,24 @@
  65  #define ISP1704_PRODUCT_ID_HIGH                0x03
  66  #define ISP1704_FUNC_CTRL              0x04
  67  #define ISP1704_OTG_CTRL               0x0a
  68 -#define ISP1704_USB_INTRISE            0x0d
  69 -#define ISP1704_USB_INTFALL            0x10
  70 +#define ISP1704_USB_INTRISE            0x0d /* interrupt enable rising register (ds p. 35 ff)*/
  71 +#define ISP1704_USB_INTFALL            0x10 /* interrupt enable falling register */
  72 +#define ISP1704_USB_INTSTAT            0x13 /* interrupt status register */
  73  #define ISP1704_DEBUG                  0x15
  74  #define ISP1704_SCRATCH                        0x16
  75  #define ISP1704_PWR_CTRL               0x3d
  76
  77  /* Function control */
  78 -#define ISP1704_FUNC_CTRL_FULL_SPEED   (1 << 0)
  79 -#define ISP1704_FUNC_CTRL_XCVRSELECT   0x3
  80 -#define ISP1704_FUNC_CTRL_XCVRSELECT_SHIFT     (1 << 0)
  81 -#define ISP1704_FUNC_CTRL_TERMSELECT   (1 << 2)
  82 -#define ISP1704_FUNC_CTRL_OPMODE       (1 << 3)
  83 -#define ISP1704_FUNC_CTRL_OPMODE_SHIFT 3
  84 -#define ISP1704_FUNC_CTRL_RESET                (1 << 5)
  85 -#define ISP1704_FUNC_CTRL_SUSPENDM     (1 << 6)
  86 +#define ISP1704_FUNC_CTRL_XCVRSELECT_SHIFT     0
  87 +#define ISP1704_FUNC_CTRL_XCVRSELECT_MASK      (3 << 0)
  88 +#define ISP1704_FUNC_CTRL_HIGH_SPEED           (0 << 0)
  89 +#define ISP1704_FUNC_CTRL_FULL_SPEED           (1 << 0)
  90 +#define ISP1704_FUNC_CTRL_LOW_SPEED            (2 << 0)
  91 +#define ISP1704_FUNC_CTRL_TERMSELECT           (1 << 2)
  92 +#define ISP1704_FUNC_CTRL_OPMODE               (1 << 3)
  93 +#define ISP1704_FUNC_CTRL_OPMODE_SHIFT         3
  94 +#define ISP1704_FUNC_CTRL_RESET                        (1 << 5)
  95 +#define ISP1704_FUNC_CTRL_SUSPENDM             (1 << 6)
  96
  97  /* OTG Control */
  98  #define ISP1704_OTG_CTRL_IDPULLUP      (1 << 0)
  99 --- kernel-power-2.6.28.orig/drivers/usb/musb/musb_core.c
 100 +++ kernel-power-2.6.28/drivers/usb/musb/musb_core.c
 101 @@ -142,6 +142,51 @@
 102  MODULE_LICENSE("GPL");
 103  MODULE_ALIAS("platform:" MUSB_DRIVER_NAME);
 104
 105 +
 106 +void musb_force_term(void __iomem *addr, enum musb_term term)
 107 +{
 108 +       u8 r;
 109 +
 110 +       /* activate pulldown resistors on datalines */
 111 +       r = musb_ulpi_readb(addr, ISP1704_OTG_CTRL);
 112 +       r |= ISP1704_OTG_CTRL_DP_PULLDOWN | ISP1704_OTG_CTRL_DM_PULLDOWN;
 113 +       musb_ulpi_writeb(addr, ISP1704_OTG_CTRL, r);
 114 +
 115 +       r = musb_ulpi_readb(addr, ISP1704_FUNC_CTRL);
 116 +       /* clear speed-selection  bits */
 117 +       r &= ~ISP1704_FUNC_CTRL_XCVRSELECT_MASK;
 118 +       /* set new speed-selection bits */
 119 +       switch(term) {
 120 +
 121 +       case MUSB_TERM_HOST_HIGHSPEED:
 122 +               r |= ISP1704_FUNC_CTRL_HIGH_SPEED;
 123 +               r &= ~ISP1704_FUNC_CTRL_TERMSELECT;
 124 +               r &= ~ISP1704_FUNC_CTRL_OPMODE;
 125 +               break;
 126 +
 127 +       case MUSB_TERM_HOST_FULLSPEED:
 128 +               r |= ISP1704_FUNC_CTRL_FULL_SPEED;
 129 +               r |= ISP1704_FUNC_CTRL_TERMSELECT;
 130 +               r &= ~ISP1704_FUNC_CTRL_OPMODE;
 131 +               break;
 132 +
 133 +       case MUSB_TERM_HOST_LOWSPEED:
 134 +               r |= ISP1704_FUNC_CTRL_LOW_SPEED;
 135 +               r |= ISP1704_FUNC_CTRL_TERMSELECT;
 136 +               r &= ~ISP1704_FUNC_CTRL_OPMODE;
 137 +               break;
 138 +
 139 +       default:
 140 +               ERR("Unknown musb termination\n");
 141 +               return;
 142 +       }
 143 +
 144 +       musb_ulpi_writeb(addr, ISP1704_FUNC_CTRL, r);
 145 +
 146 +}
 147 +
 148 +
 149 +
 150  static inline int musb_verify_charger(void __iomem *addr)
 151  {
 152         u8 r, ret = 0;
 153 @@ -220,6 +265,8 @@
 154
 155         u8              vdat = 0;
 156         u8              r;
 157 +       u8 testmode;
 158 +       testmode = musb_readb(musb->mregs,MUSB_TESTMODE);
 159
 160         msleep(5);
 161
 162 @@ -297,7 +344,7 @@
 163                         break;
 164         }
 165
 166 -       if (vdat) {
 167 +       if (vdat && !(testmode & MUSB_TEST_FORCE_HOST)) {
 168                 /* REVISIT: This code works only with dedicated chargers!
 169                  * When support for HOST/HUB chargers is added, don't
 170                  * forget this.
 171 @@ -349,7 +396,7 @@
 172
 173         prefetch((u8 *)src);
 174
 175 -       DBG(4, "%cX ep%d fifo %p count %d buf %p\n",
 176 +       DBG(6, "%cX ep%d fifo %p count %d buf %p\n",
 177                         'T', hw_ep->epnum, fifo, len, src);
 178
 179         /* we can't assume unaligned reads work */
 180 @@ -387,7 +434,7 @@
 181  {
 182         void __iomem *fifo = hw_ep->fifo;
 183
 184 -       DBG(4, "%cX ep%d fifo %p count %d buf %p\n",
 185 +       DBG(6, "%cX ep%d fifo %p count %d buf %p\n",
 186                         'R', hw_ep->epnum, fifo, len, dst);
 187
 188         /* we can't assume unaligned writes work */
 189 @@ -490,7 +537,6 @@
 190  {
 191         struct musb     *musb = (struct musb *)data;
 192         unsigned long   flags;
 193 -
 194         spin_lock_irqsave(&musb->lock, flags);
 195         switch (musb->xceiv->state) {
 196         case OTG_STATE_B_WAIT_ACON:
 197 @@ -572,10 +618,19 @@
 198  static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 199                                 u8 devctl, u8 power)
 200  {
 201 +       u8 testmode;
 202         irqreturn_t handled = IRQ_NONE;
 203         void __iomem *mbase = musb->mregs;
 204         u8 r;
 205
 206 +       testmode = musb_readb(mbase,MUSB_TESTMODE);
 207 +  if(testmode & MUSB_TEST_FORCE_HOST) {
 208 +               if(int_usb & MUSB_INTR_SESSREQ) {
 209 +                       DBG(1,"Piggybacking CONNECT on SESS REQ\n");
 210 +                       musb->int_usb |= MUSB_INTR_CONNECT;
 211 +               }
 212 +       }
 213 +
 214         DBG(3, "<== Power=%02x, DevCtl=%02x, int_usb=0x%x\n", power, devctl,
 215                 int_usb);
 216
 217 @@ -630,6 +685,8 @@
 218                 } else {
 219                         switch (musb->xceiv->state) {
 220  #ifdef CONFIG_USB_MUSB_HDRC_HCD
 221 +                       case OTG_STATE_A_WAIT_BCON:
 222 +                       case OTG_STATE_A_HOST:
 223                         case OTG_STATE_A_SUSPEND:
 224                                 /* possibly DISCONNECT is upcoming */
 225                                 musb->xceiv->state = OTG_STATE_A_HOST;
 226 @@ -678,7 +735,7 @@
 227                  * be discarded silently.
 228                  */
 229                 if ((devctl & MUSB_DEVCTL_VBUS)
 230 -                   && !(devctl & MUSB_DEVCTL_BDEVICE)) {
 231 +                   && host_mode(musb->mregs)) {
 232                         musb_writeb(mbase, MUSB_DEVCTL, MUSB_DEVCTL_SESSION);
 233                         musb->ep0_stage = MUSB_EP0_START;
 234                         musb->xceiv->state = OTG_STATE_A_IDLE;
 235 @@ -796,9 +853,15 @@
 236                                         + msecs_to_jiffies(musb->a_wait_bcon));
 237                         break;
 238                 case OTG_STATE_A_HOST:
 239 +                       if(testmode & MUSB_TEST_FORCE_HOST) {
 240 +                               //                              musb->int_usb |= MUSB_INTR_RESUME;
 241 +                               break;
 242 +                       }
 243 +
 244                         musb->xceiv->state = OTG_STATE_A_SUSPEND;
 245                         musb->is_active = is_otg_enabled(musb)
 246                                         && musb->xceiv->host->b_hnp_enable;
 247 +
 248                         break;
 249                 case OTG_STATE_B_HOST:
 250                         /* Transition to B_PERIPHERAL, see 6.8.2.6 p 44 */
 251 @@ -818,6 +881,7 @@
 252                 musb->is_active = 1;
 253                 set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
 254
 255 +
 256                 musb->ep0_stage = MUSB_EP0_START;
 257
 258  #ifdef CONFIG_USB_MUSB_OTG
 259 @@ -836,9 +900,65 @@
 260                 musb->port1_status |= USB_PORT_STAT_CONNECTION
 261                                         |(USB_PORT_STAT_C_CONNECTION << 16);
 262
 263 -               /* high vs full speed is just a guess until after reset */
 264 -               if (devctl & MUSB_DEVCTL_LSDEV)
 265 -                       musb->port1_status |= USB_PORT_STAT_LOW_SPEED;
 266 +               if (testmode & MUSB_TEST_FORCE_HOST) {
 267 +                       u8 r,reg;
 268 +      void __iomem *mbase = musb->mregs;
 269 +
 270 +                       musb_force_term(musb->mregs,MUSB_TERM_HOST_HIGHSPEED);
 271 +
 272 +                       r = musb_ulpi_readb(mbase, ISP1704_DEBUG);
 273 +                       DBG(1,"Linestate %x\n",r);
 274 +                       switch(r) {
 275 +                       case 2:
 276 +                               musb->port1_status |= USB_PORT_STAT_LOW_SPEED;
 277 +                               reg = musb_readb(mbase, MUSB_TESTMODE);
 278 +                               reg &= ~MUSB_TEST_FORCE_FS;
 279 +                               reg &= ~MUSB_TEST_FORCE_HS;
 280 +                               musb_writeb(mbase, MUSB_TESTMODE, reg);
 281 +
 282 +                               reg = musb_readb(mbase, MUSB_POWER);
 283 +                               reg &= ~MUSB_POWER_HSENAB;
 284 +                               musb_writeb(mbase, MUSB_POWER, reg);
 285 +
 286 +                               musb_force_term(musb->mregs,MUSB_TERM_HOST_LOWSPEED);
 287 +                               break;
 288 +                       case 1:
 289 +                               /*High or full speed*/
 290 +                               reg = musb_readb(mbase, MUSB_TESTMODE);
 291 +                               if(reg &  MUSB_TEST_FORCE_HS) {
 292 +                                       /*High speed*/
 293 +                                       reg &= ~MUSB_TEST_FORCE_FS;
 294 +                                       musb_writeb(mbase, MUSB_TESTMODE, reg);
 295 +
 296 +                                       reg = musb_readb(mbase, MUSB_POWER);
 297 +                                       reg |= MUSB_POWER_HSENAB;
 298 +                                       musb_writeb(mbase, MUSB_POWER, reg);
 299 +                               } else {
 300 +                                       /*Full speed*/
 301 +                                       reg |= MUSB_TEST_FORCE_FS;
 302 +                                       musb_writeb(mbase, MUSB_TESTMODE, reg);
 303 +
 304 +                                       reg = musb_readb(mbase, MUSB_POWER);
 305 +                                       reg &= ~MUSB_POWER_HSENAB;
 306 +                                       musb_writeb(mbase, MUSB_POWER, reg);
 307 +                               }
 308 +
 309 +                               musb_force_term(mbase,MUSB_TERM_HOST_FULLSPEED);
 310 +
 311 +                               break;
 312 +                       case 0:
 313 +                       case 3:
 314 +                               /*invalid*/
 315 +                               WARNING("Invalid line state of %d\n",r);
 316 +                               break;
 317 +
 318 +                       }
 319 +               } else {
 320 +
 321 +                       /* high vs full speed is just a guess until after reset */
 322 +                       if (devctl & MUSB_DEVCTL_LSDEV)
 323 +                               musb->port1_status |= USB_PORT_STAT_LOW_SPEED;
 324 +               }
 325
 326                 if (hcd->status_urb)
 327                         usb_hcd_poll_rh_status(hcd);
 328 @@ -974,6 +1094,8 @@
 329                                 musb->ignore_disconnect = 1;
 330                                 musb_g_reset(musb);
 331                                 /* FALLTHROUGH */
 332 +                       case OTG_STATE_A_HOST:
 333 +                               musb->xceiv->state = OTG_STATE_A_WAIT_BCON;
 334                         case OTG_STATE_A_WAIT_BCON:     /* OPT TD.4.7-900ms */
 335                                 DBG(1, "HNP: Setting timer as %s\n",
 336                                                 otg_state_string(musb));
 337 @@ -2421,8 +2543,7 @@
 338                 DBG(1, "%s mode, status %d, devctl %02x %c\n",
 339                         "HOST", status,
 340                         musb_readb(musb->mregs, MUSB_DEVCTL),
 341 -                       (musb_readb(musb->mregs, MUSB_DEVCTL)
 342 -                                       & MUSB_DEVCTL_BDEVICE
 343 +                               (!host_mode(musb->mregs)
 344                                 ? 'B' : 'A'));
 345
 346         } else /* peripheral is enabled */ {
 347 --- kernel-power-2.6.28.orig/drivers/usb/musb/musb_core.h
 348 +++ kernel-power-2.6.28/drivers/usb/musb/musb_core.h
 349 @@ -85,6 +85,16 @@
 350  #define        is_host_active(musb)            is_host_capable()
 351  #endif
 352
 353 +static inline int host_mode(void __iomem *addr)
 354 +{
 355 +       u8              devctl,testmode;
 356 +       devctl = musb_readb(addr, MUSB_DEVCTL);
 357 +       testmode = musb_readb(addr,MUSB_TESTMODE);
 358 +
 359 +       return (testmode & MUSB_TEST_FORCE_HOST) || !(devctl & MUSB_DEVCTL_BDEVICE);
 360 +}
 361 +
 362 +
 363  #if defined(CONFIG_USB_MUSB_OTG) || defined(CONFIG_USB_MUSB_PERIPHERAL)
 364  /* for some reason, the "select USB_GADGET_MUSB_HDRC" doesn't always
 365   * override that choice selection (often USB_GADGET_DUMMY_HCD).
 366 @@ -593,6 +603,14 @@
 367
 368  extern int musb_platform_set_mode(struct musb *musb, u8 musb_mode);
 369
 370 +enum musb_term {
 371 +       MUSB_TERM_HOST_HIGHSPEED,
 372 +       MUSB_TERM_HOST_FULLSPEED,
 373 +       MUSB_TERM_HOST_LOWSPEED,
 374 +};
 375 +
 376 +extern void musb_force_term(void __iomem *addr, enum musb_term term);
 377 +
 378  #if defined(CONFIG_USB_TUSB6010) || defined(CONFIG_BLACKFIN) || \
 379         defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP34XX)
 380  extern void musb_platform_try_idle(struct musb *musb, unsigned long timeout);
 381 --- kernel-power-2.6.28.orig/drivers/usb/musb/musb_gadget.c
 382 +++ kernel-power-2.6.28/drivers/usb/musb/musb_gadget.c
 383 @@ -1957,7 +1957,7 @@
 384         u8              power;
 385
 386         DBG(3, "<== %s addr=%x driver '%s'\n",
 387 -                       (devctl & MUSB_DEVCTL_BDEVICE)
 388 +                       !host_mode(musb->mregs)
 389                                 ? "B-Device" : "A-Device",
 390                         musb_readb(mbase, MUSB_FADDR),
 391                         musb->gadget_driver
 392 @@ -1994,7 +1994,7 @@
 393         /* Normal reset, as B-Device;
 394          * or else after HNP, as A-Device
 395          */
 396 -       if (devctl & MUSB_DEVCTL_BDEVICE) {
 397 +       if (!host_mode(musb->mregs)) {
 398                 musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
 399                 musb->g.is_a_peripheral = 0;
 400         } else if (is_otg_enabled(musb)) {
 401 --- kernel-power-2.6.28.orig/drivers/usb/musb/musb_host.c
 402 +++ kernel-power-2.6.28/drivers/usb/musb/musb_host.c
 403 @@ -1863,8 +1863,10 @@
 404         unsigned                        interval;
 405
 406         /* host role must be active */
 407 -       if (!is_host_active(musb) || !musb->is_active)
 408 +       if (!is_host_active(musb) || !musb->is_active) {
 409 +               printk(KERN_ERR "musb is_host_active %d is_active %d\n",is_host_active(musb),musb->is_active);
 410                 return -ENODEV;
 411 +       }
 412
 413         spin_lock_irqsave(&musb->lock, flags);
 414         ret = usb_hcd_link_urb_to_ep(hcd, urb);
 415 @@ -2275,6 +2277,7 @@
 416         return 0;
 417  }
 418
 419 +
 420  const struct hc_driver musb_hc_driver = {
 421         .description            = "musb-hcd",
 422         .product_desc           = "MUSB HDRC host driver",
 423 @@ -2298,6 +2301,5 @@
 424         .hub_control            = musb_hub_control,
 425         .bus_suspend            = musb_bus_suspend,
 426         .bus_resume             = musb_bus_resume,
 427 -       /* .start_port_reset    = NULL, */
 428         /* .hub_irq_enable      = NULL, */
 429  };
 430 --- kernel-power-2.6.28.orig/drivers/usb/musb/musb_procfs.c
 431 +++ kernel-power-2.6.28/drivers/usb/musb/musb_procfs.c
 432 @@ -37,6 +37,7 @@
 433  #include <linux/seq_file.h>
 434  #include <linux/uaccess.h>     /* FIXME remove procfs writes */
 435  #include <mach/hardware.h>
 436 +#include <asm/mach-types.h>
 437
 438  #include "musb_core.h"
 439
 440 @@ -450,8 +451,8 @@
 441                 return 0;
 442         buffer += count;
 443
 444 -       code = sprintf(buffer, "OTG state: %s; %sactive\n",
 445 -                       otg_state_string(musb),
 446 +       code = sprintf(buffer, "OTG state: %s:%d; %sactive\n",
 447 +                                                                otg_state_string(musb),musb->xceiv->state,
 448                         musb->is_active ? "" : "in");
 449         if (code <= 0)
 450                 goto done;
 451 @@ -591,16 +592,33 @@
 452   *
 453   * C soft-connect
 454   * c soft-disconnect
 455 - * I enable HS
 456 - * i disable HS
 457 - * s stop session
 458 - * F force session (OTG-unfriendly)
 459 + * D<num> set/query the debug level
 460   * E rElinquish bus (OTG)
 461 + * e enumerate
 462 + * F force session (OTG-unfriendly)
 463   * H request host mode
 464   * h cancel host request
 465 + * I enable HS
 466 + * i disable HS
 467 + * J set HS test mode
 468 + * j clear HS test mode
 469 + * K set FS test mode
 470 + * k clear FS test mode
 471 + * M set host test mode
 472 + * m clear host test mode
 473 + * R reset peripheral
 474 + * r resume root hub
 475 + * s stop session
 476   * T start sending TEST_PACKET
 477 - * D<num> set/query the debug level
 478 + * X term highspeed
 479 + * Y term fullspeed
 480 + * Z term lowspeed
 481 + *
 482   */
 483 +
 484 +extern void musb_port_reset(struct musb *musb, bool do_reset);
 485 +extern void musb_port_suspend(struct musb *musb, bool do_suspend);
 486 +
 487  static int musb_proc_write(struct file *file, const char __user *buffer,
 488                         unsigned long count, void *data)
 489  {
 490 @@ -608,49 +626,63 @@
 491         u8 reg;
 492         struct musb *musb = (struct musb *)data;
 493         void __iomem *mbase = musb->mregs;
 494 +       unsigned long   flags;
 495 +       struct usb_hcd *hcd = musb_to_hcd(musb);
 496 +       struct usb_bus *bus = hcd_to_bus(hcd);
 497
 498         /* MOD_INC_USE_COUNT; */
 499
 500         if (unlikely(copy_from_user(&cmd, buffer, 1)))
 501                 return -EFAULT;
 502
 503 +
 504         switch (cmd) {
 505         case 'C':
 506                 if (mbase) {
 507 -                       reg = musb_readb(mbase, MUSB_POWER)
 508 -                                       | MUSB_POWER_SOFTCONN;
 509 +                       reg = musb_readb(mbase, MUSB_POWER);
 510 +                       reg |= MUSB_POWER_SOFTCONN;
 511                         musb_writeb(mbase, MUSB_POWER, reg);
 512                 }
 513                 break;
 514
 515         case 'c':
 516                 if (mbase) {
 517 -                       reg = musb_readb(mbase, MUSB_POWER)
 518 -                                       & ~MUSB_POWER_SOFTCONN;
 519 +                       reg = musb_readb(mbase, MUSB_POWER);
 520 +                       reg &= ~MUSB_POWER_SOFTCONN;
 521                         musb_writeb(mbase, MUSB_POWER, reg);
 522                 }
 523                 break;
 524
 525         case 'I':
 526                 if (mbase) {
 527 -                       reg = musb_readb(mbase, MUSB_POWER)
 528 -                                       | MUSB_POWER_HSENAB;
 529 +                       reg = musb_readb(mbase, MUSB_POWER);
 530 +                       reg |= MUSB_POWER_HSENAB;
 531                         musb_writeb(mbase, MUSB_POWER, reg);
 532                 }
 533                 break;
 534
 535         case 'i':
 536                 if (mbase) {
 537 -                       reg = musb_readb(mbase, MUSB_POWER)
 538 -                                       & ~MUSB_POWER_HSENAB;
 539 +                       reg = musb_readb(mbase, MUSB_POWER);
 540 +                       reg &= ~MUSB_POWER_HSENAB;
 541                         musb_writeb(mbase, MUSB_POWER, reg);
 542                 }
 543                 break;
 544
 545         case 'F':
 546 -               reg = musb_readb(mbase, MUSB_DEVCTL);
 547 -               reg |= MUSB_DEVCTL_SESSION;
 548 -               musb_writeb(mbase, MUSB_DEVCTL, reg);
 549 +               if (mbase) {
 550 +                       reg = musb_readb(mbase, MUSB_DEVCTL);
 551 +                       reg |= MUSB_DEVCTL_SESSION;
 552 +                       musb_writeb(mbase, MUSB_DEVCTL, reg);
 553 +               }
 554 +               break;
 555 +
 556 +       case 's':
 557 +               if (mbase) {
 558 +                       reg = musb_readb(mbase, MUSB_DEVCTL);
 559 +                       reg &= ~MUSB_DEVCTL_SESSION;
 560 +                       musb_writeb(mbase, MUSB_DEVCTL, reg);
 561 +               }
 562                 break;
 563
 564         case 'H':
 565 @@ -679,6 +711,114 @@
 566                 }
 567                 break;
 568
 569 +       case 'M':
 570 +               if (mbase) {
 571 +                       reg = musb_readb(mbase, MUSB_TESTMODE);
 572 +                       reg |= MUSB_TEST_FORCE_HOST;
 573 +                       musb_writeb(mbase, MUSB_TESTMODE, reg);
 574 +               }
 575 +               break;
 576 +
 577 +       case 'm':
 578 +               if (mbase) {
 579 +                       reg = musb_readb(mbase, MUSB_TESTMODE);
 580 +                       reg &= ~MUSB_TEST_FORCE_HOST;
 581 +                       musb_writeb(mbase, MUSB_TESTMODE, reg);
 582 +                       MUSB_DEV_MODE(musb);
 583 +                       musb->xceiv->state = OTG_STATE_B_IDLE;
 584 +               }
 585 +               break;
 586 +
 587 +  case 'L':
 588 +                       musb->xceiv->state = OTG_STATE_A_HOST;
 589 +                       MUSB_HST_MODE(musb);
 590 +               break;
 591 +
 592 +  case 'l':
 593 +                       musb->xceiv->state = OTG_STATE_A_WAIT_BCON;
 594 +                       MUSB_HST_MODE(musb);
 595 +               break;
 596 +
 597 +       case 'J':
 598 +               if (mbase) {
 599 +                       reg = musb_readb(mbase, MUSB_TESTMODE);
 600 +                       reg |= MUSB_TEST_FORCE_HS;
 601 +                       musb_writeb(mbase, MUSB_TESTMODE, reg);
 602 +               }
 603 +               break;
 604 +
 605 +       case 'j':
 606 +               if (mbase) {
 607 +                       reg = musb_readb(mbase, MUSB_TESTMODE);
 608 +                       reg &= ~MUSB_TEST_FORCE_HS;
 609 +                       musb_writeb(mbase, MUSB_TESTMODE, reg);
 610 +               }
 611 +               break;
 612 +
 613 +       case 'K':
 614 +               if (mbase) {
 615 +                       reg = musb_readb(mbase, MUSB_TESTMODE);
 616 +                       reg |= MUSB_TEST_FORCE_FS;
 617 +                       musb_writeb(mbase, MUSB_TESTMODE, reg);
 618 +               }
 619 +               break;
 620 +
 621 +       case 'k':
 622 +               if (mbase) {
 623 +                       reg = musb_readb(mbase, MUSB_TESTMODE);
 624 +                       reg &= ~MUSB_TEST_FORCE_FS;
 625 +                       musb_writeb(mbase, MUSB_TESTMODE, reg);
 626 +               }
 627 +               break;
 628 +
 629 +  case 'X':
 630 +    if (mbase)
 631 +                       musb_force_term(mbase,MUSB_TERM_HOST_HIGHSPEED);
 632 +               break;
 633 +
 634 +  case 'Y':
 635 +    if (mbase)
 636 +                       musb_force_term(mbase,MUSB_TERM_HOST_FULLSPEED);
 637 +               break;
 638 +
 639 +  case 'Z':
 640 +    if (mbase)
 641 +                       musb_force_term(mbase,MUSB_TERM_HOST_LOWSPEED);
 642 +               break;
 643 +
 644 +       case 'R':
 645 +               musb_port_reset(musb, true);
 646 +               while (time_before(jiffies, musb->rh_timer))
 647 +                       msleep(1);
 648 +               musb_port_reset(musb, false);
 649 +
 650 +               break;
 651 +
 652 +  case 'r':
 653 +               usb_hcd_resume_root_hub(hcd);
 654 +               break;
 655 +
 656 +  case 'e':
 657 +               if(bus)
 658 +                       usb_bus_start_enum(bus,bus->otg_port);
 659 +               break;
 660 +
 661 +       case 'U':
 662 +               /*Suspend*/
 663 +               musb_port_suspend(musb, true);
 664 +               break;
 665 +
 666 +       case 'u':
 667 +               /*Resume*/
 668 +               musb_port_suspend(musb, false);
 669 +               /*How to end sanely? */
 670 +               musb_port_reset(musb, true);
 671 +               while (time_before(jiffies, musb->rh_timer))
 672 +                       msleep(1);
 673 +               musb_port_reset(musb, false);
 674 +
 675 +       break;
 676 +
 677         case '?':
 678                 INFO("?: you are seeing it\n");
 679                 INFO("C/c: soft connect enable/disable\n");
 680 @@ -695,6 +835,7 @@
 681
 682         musb_platform_try_idle(musb, 0);
 683
 684 +
 685         return count;
 686  }
 687
 688 @@ -709,6 +850,8 @@
 689
 690         count -= off;
 691         count -= 1;             /* for NUL at end */
 692 +       count -= 20; /* Padding */
 693 +
 694         if (count <= 0)
 695                 return -EINVAL;
 696
 697 @@ -720,6 +863,9 @@
 698                 count -= code;
 699         }
 700
 701 +       if (count < 0)
 702 +               goto done;
 703 +
 704         /* generate the report for the end points */
 705         /* REVISIT ... not unless something's connected! */
 706         for (epnum = 0; count >= 0 && epnum < musb->nr_endpoints;
 707 @@ -728,14 +874,22 @@
 708                 if (code > 0) {
 709                         buffer += code;
 710                         count -= code;
 711 +                       if (count < 0)
 712 +                               goto done;
 713                 }
 714         }
 715
 716 +
 717 + done:
 718 +
 719         musb_platform_try_idle(musb, 0);
 720
 721         spin_unlock_irqrestore(&musb->lock, flags);
 722         *eof = 1;
 723
 724 +       if(count < 0)
 725 +               return -EINVAL;
 726 +
 727         return buffer - page;
 728  }
 729
 730 --- kernel-power-2.6.28.orig/drivers/usb/musb/musb_virthub.c
 731 +++ kernel-power-2.6.28/drivers/usb/musb/musb_virthub.c
 732 @@ -46,7 +46,7 @@
 733  #include "musb_core.h"
 734
 735
 736 -static void musb_port_suspend(struct musb *musb, bool do_suspend)
 737 +void musb_port_suspend(struct musb *musb, bool do_suspend)
 738  {
 739         u8              power;
 740         void __iomem    *mbase = musb->mregs;
 741 @@ -106,11 +106,13 @@
 742
 743                 /* later, GetPortStatus will stop RESUME signaling */
 744                 musb->port1_status |= MUSB_PORT_STAT_RESUME;
 745 -               musb->rh_timer = jiffies + msecs_to_jiffies(20);
 746 +               /*OMAP documentation states range of 10-15 ms */
 747 +               musb->rh_timer = jiffies + msecs_to_jiffies(13);
 748 +               //              musb->rh_timer = jiffies + msecs_to_jiffies(20);
 749         }
 750  }
 751
 752 -static void musb_port_reset(struct musb *musb, bool do_reset)
 753 +void musb_port_reset(struct musb *musb, bool do_reset)
 754  {
 755         u8              power;
 756         void __iomem    *mbase = musb->mregs;
 757 @@ -131,7 +133,7 @@
 758          */
 759         power = musb_readb(mbase, MUSB_POWER);
 760         if (do_reset) {
 761 -
 762 +               DBG(4, "root port reset started\n");
 763                 /*
 764                  * If RESUME is set, we must make sure it stays minimum 20 ms.
 765                  * Then we must clear RESUME and wait a bit to let musb start
 766 --- kernel-power-2.6.28.orig/drivers/usb/musb/omap2430.c
 767 +++ kernel-power-2.6.28/drivers/usb/musb/omap2430.c
 768 @@ -77,11 +77,14 @@
 769
 770         switch (musb->xceiv->state) {
 771         case OTG_STATE_A_WAIT_BCON:
 772 +               if(host_mode(musb->mregs))
 773 +                       break; /*Don't time out*/
 774 +
 775                 devctl &= ~MUSB_DEVCTL_SESSION;
 776                 musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
 777
 778                 devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 779 -               if (devctl & MUSB_DEVCTL_BDEVICE) {
 780 +               if (!host_mode(musb->mregs)) {
 781                         musb->xceiv->state = OTG_STATE_B_IDLE;
 782                         MUSB_DEV_MODE(musb);
 783                 } else {
 784 @@ -109,11 +112,14 @@
 785  #endif
 786  #ifdef CONFIG_USB_MUSB_HDRC_HCD
 787         case OTG_STATE_A_HOST:
 788 +
 789 +
 790                 devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 791 -               if (devctl &  MUSB_DEVCTL_BDEVICE)
 792 +               if (!host_mode(musb->mregs))
 793                         musb->xceiv->state = OTG_STATE_B_IDLE;
 794 -               else
 795 -                       musb->xceiv->state = OTG_STATE_A_WAIT_BCON;
 796 +               /*Don't time out if host*/
 797 +               //              else
 798 +               //      musb->xceiv->state = OTG_STATE_A_WAIT_BCON;
 799  #endif
 800         default:
 801                 break;
 802 @@ -133,7 +139,7 @@
 803         /* Never idle if active, or when VBUS timeout is not set as host */
 804         if (musb->is_active || ((musb->a_wait_bcon == 0)
 805                         && (musb->xceiv->state == OTG_STATE_A_WAIT_BCON))) {
 806 -               DBG(4, "%s active, deleting timer\n", otg_state_string(musb));
 807 +               DBG(6, "%s active, deleting timer\n", otg_state_string(musb));
 808                 del_timer(&musb_idle_timer);
 809                 last_timer = jiffies;
 810                 return;
 811 @@ -143,13 +149,13 @@
 812                 if (!timer_pending(&musb_idle_timer))
 813                         last_timer = timeout;
 814                 else {
 815 -                       DBG(4, "Longer idle timer already pending, ignoring\n");
 816 +                       DBG(6, "Longer idle timer already pending, ignoring\n");
 817                         return;
 818                 }
 819         }
 820         last_timer = timeout;
 821
 822 -       DBG(4, "%s inactive, for idle timer for %lu ms\n",
 823 +       DBG(6, "%s inactive, for idle timer for %lu ms\n",
 824                 otg_state_string(musb),
 825                 (unsigned long)jiffies_to_msecs(timeout - jiffies));
 826         mod_timer(&musb_idle_timer, timeout);
 827 @@ -182,8 +188,14 @@
 828                 musb->xceiv->default_a = 1;
 829                 musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
 830                 devctl |= MUSB_DEVCTL_SESSION;
 831 -
 832                 MUSB_HST_MODE(musb);
 833 +
 834 +               if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS) {
 835 +                       /*Power is already applied. Skip VRISE and go directly to BCON.*/
 836 +                       musb->xceiv->state = OTG_STATE_A_WAIT_BCON;
 837 +               }
 838 +
 839 +
 840         } else {
 841                 musb->is_active = 0;
 842
 843 @@ -420,7 +432,7 @@
 844         u8 r;
 845         unsigned long   flags;
 846
 847 -       DBG(3, "restoring register context\n");
 848 +       DBG(3, "restoring register context for %s\n","musb_restore_ctx_and_resume");
 849
 850         if (musb->board && musb->board->xceiv_power)
 851                 musb->board->xceiv_power(1);
 852 @@ -431,13 +443,17 @@
 853         else
 854                 clk_enable(musb->clock);
 855
 856 -       /* Recover OTG control */
 857 -       r = musb_ulpi_readb(musb->mregs, ISP1704_OTG_CTRL);
 858 -       r |= ISP1704_OTG_CTRL_IDPULLUP | ISP1704_OTG_CTRL_DP_PULLDOWN;
 859 -       musb_ulpi_writeb(musb->mregs, ISP1704_OTG_CTRL, r);
 860 -
 861 +       if(host_mode(musb->mregs)) {
 862 +               musb_force_term(musb->mregs,MUSB_TERM_HOST_FULLSPEED);
 863 +               r = musb_ulpi_readb(musb->mregs,ISP1704_FUNC_CTRL);
 864 +       } else {
 865 +               /* Recover OTG control */
 866 +               r = musb_ulpi_readb(musb->mregs, ISP1704_OTG_CTRL);
 867 +               r |= ISP1704_OTG_CTRL_IDPULLUP | ISP1704_OTG_CTRL_DP_PULLDOWN;
 868 +               musb_ulpi_writeb(musb->mregs, ISP1704_OTG_CTRL, r);
 869 +               r = ISP1704_FUNC_CTRL_FULL_SPEED;
 870 +       }
 871         /* Recover FUNC control */
 872 -       r = ISP1704_FUNC_CTRL_FULL_SPEED;
 873         r |= ISP1704_FUNC_CTRL_SUSPENDM | ISP1704_FUNC_CTRL_RESET;
 874         musb_ulpi_writeb(musb->mregs, ISP1704_FUNC_CTRL, r);
 875
 876 --- kernel-power-2.6.28.orig/drivers/usb/otg/otg.c
 877 +++ kernel-power-2.6.28/drivers/usb/otg/otg.c
 878 @@ -160,7 +160,8 @@
 879
 880         /* add other match criteria here ... */
 881
 882 -
 883 +       return 1;
 884 +
 885         /* OTG MESSAGE: report errors here, customize to match your product */
 886         dev_err(&dev->dev, "device v%04x p%04x is not supported\n",
 887                 le16_to_cpu(dev->descriptor.idVendor),
 888 --- kernel-power-2.6.28.orig/drivers/usb/otg/twl4030-usb.c
 889 +++ kernel-power-2.6.28/drivers/usb/otg/twl4030-usb.c
 890 @@ -239,9 +239,9 @@
 891
 892  enum linkstat {
 893         USB_LINK_UNKNOWN = 0,
 894 -       USB_LINK_NONE,
 895 -       USB_LINK_VBUS,
 896 -       USB_LINK_ID,
 897 +       USB_LINK_NONE = 1,
 898 +       USB_LINK_VBUS = 2,
 899 +       USB_LINK_ID = 3,
 900  };
 901
 902  struct twl4030_usb {