drivers/usb/early/ehci-dbgp.c

   1 /*
   2  * Standalone EHCI usb debug driver
   3  *
   4  * Originally written by:
   5  *  Eric W. Biederman" <ebiederm@xmission.com> and
   6  *  Yinghai Lu <yhlu.kernel@gmail.com>
   7  *
   8  * Changes for early/late printk and HW errata:
   9  *  Jason Wessel <jason.wessel@windriver.com>
  10  *  Copyright (C) 2009 Wind River Systems, Inc.
  11  *
  12  */
  13
  14 #include <linux/console.h>
  15 #include <linux/errno.h>
  16 #include <linux/module.h>
  17 #include <linux/pci_regs.h>
  18 #include <linux/pci_ids.h>
  19 #include <linux/usb/ch9.h>
  20 #include <linux/usb/ehci_def.h>
  21 #include <linux/delay.h>
  22 #include <asm/io.h>
  23 #include <asm/pci-direct.h>
  24 #include <asm/fixmap.h>
  25
  26 /* The code here is intended to talk directly to the EHCI debug port
  27  * and does not require that you have any kind of USB host controller
  28  * drivers or USB device drivers compiled into the kernel.
  29  *
  30  * If you make a change to anything in here, the following test cases
  31  * need to pass where a USB debug device works in the following
  32  * configurations.
  33  *
  34  * 1. boot args:  earlyprintk=dbgp
  35  *     o kernel compiled with # CONFIG_USB_EHCI_HCD is not set
  36  *     o kernel compiled with CONFIG_USB_EHCI_HCD=y
  37  * 2. boot args: earlyprintk=dbgp,keep
  38  *     o kernel compiled with # CONFIG_USB_EHCI_HCD is not set
  39  *     o kernel compiled with CONFIG_USB_EHCI_HCD=y
  40  * 3. boot args: earlyprintk=dbgp console=ttyUSB0
  41  *     o kernel has CONFIG_USB_EHCI_HCD=y and
  42  *       CONFIG_USB_SERIAL_DEBUG=y
  43  * 4. boot args: earlyprintk=vga,dbgp
  44  *     o kernel compiled with # CONFIG_USB_EHCI_HCD is not set
  45  *     o kernel compiled with CONFIG_USB_EHCI_HCD=y
  46  *
  47  * For the 4th configuration you can turn on or off the DBGP_DEBUG
  48  * such that you can debug the dbgp device's driver code.
  49  */
  50
  51 static int dbgp_phys_port = 1;
  52
  53 static struct ehci_caps __iomem *ehci_caps;
  54 static struct ehci_regs __iomem *ehci_regs;
  55 static struct ehci_dbg_port __iomem *ehci_debug;
  56 static int dbgp_not_safe; /* Cannot use debug device during ehci reset */
  57 static unsigned int dbgp_endpoint_out;
  58
  59 struct ehci_dev {
  60         u32 bus;
  61         u32 slot;
  62         u32 func;
  63 };
  64
  65 static struct ehci_dev ehci_dev;
  66
  67 #define USB_DEBUG_DEVNUM 127
  68
  69 #define DBGP_DATA_TOGGLE        0x8800
  70
  71 #ifdef DBGP_DEBUG
  72 #define dbgp_printk printk
  73 static void dbgp_ehci_status(char *str)
  74 {
  75         if (!ehci_debug)
  76                 return;
  77         dbgp_printk("dbgp: %s\n", str);
  78         dbgp_printk("  Debug control: %08x", readl(&ehci_debug->control));
  79         dbgp_printk("  ehci cmd     : %08x", readl(&ehci_regs->command));
  80         dbgp_printk("  ehci conf flg: %08x\n",
  81                     readl(&ehci_regs->configured_flag));
  82         dbgp_printk("  ehci status  : %08x", readl(&ehci_regs->status));
  83         dbgp_printk("  ehci portsc  : %08x\n",
  84                     readl(&ehci_regs->port_status[dbgp_phys_port - 1]));
  85 }
  86 #else
  87 static inline void dbgp_ehci_status(char *str) { }
  88 static inline void dbgp_printk(const char *fmt, ...) { }
  89 #endif
  90
  91 static inline u32 dbgp_pid_update(u32 x, u32 tok)
  92 {
  93         return ((x ^ DBGP_DATA_TOGGLE) & 0xffff00) | (tok & 0xff);
  94 }
  95
  96 static inline u32 dbgp_len_update(u32 x, u32 len)
  97 {
  98         return (x & ~0x0f) | (len & 0x0f);
  99 }
 100
 101 /*
 102  * USB Packet IDs (PIDs)
 103  */
 104
 105 /* token */
 106 #define USB_PID_OUT             0xe1
 107 #define USB_PID_IN              0x69
 108 #define USB_PID_SOF             0xa5
 109 #define USB_PID_SETUP           0x2d
 110 /* handshake */
 111 #define USB_PID_ACK             0xd2
 112 #define USB_PID_NAK             0x5a
 113 #define USB_PID_STALL           0x1e
 114 #define USB_PID_NYET            0x96
 115 /* data */
 116 #define USB_PID_DATA0           0xc3
 117 #define USB_PID_DATA1           0x4b
 118 #define USB_PID_DATA2           0x87
 119 #define USB_PID_MDATA           0x0f
 120 /* Special */
 121 #define USB_PID_PREAMBLE        0x3c
 122 #define USB_PID_ERR             0x3c
 123 #define USB_PID_SPLIT           0x78
 124 #define USB_PID_PING            0xb4
 125 #define USB_PID_UNDEF_0         0xf0
 126
 127 #define USB_PID_DATA_TOGGLE     0x88
 128 #define DBGP_CLAIM (DBGP_OWNER | DBGP_ENABLED | DBGP_INUSE)
 129
 130 #define PCI_CAP_ID_EHCI_DEBUG   0xa
 131
 132 #define HUB_ROOT_RESET_TIME     50      /* times are in msec */
 133 #define HUB_SHORT_RESET_TIME    10
 134 #define HUB_LONG_RESET_TIME     200
 135 #define HUB_RESET_TIMEOUT       500
 136
 137 #define DBGP_MAX_PACKET         8
 138 #define DBGP_TIMEOUT            (250 * 1000)
 139
 140 static int dbgp_wait_until_complete(void)
 141 {
 142         u32 ctrl;
 143         int loop = DBGP_TIMEOUT;
 144
 145         do {
 146                 ctrl = readl(&ehci_debug->control);
 147                 /* Stop when the transaction is finished */
 148                 if (ctrl & DBGP_DONE)
 149                         break;
 150                 udelay(1);
 151         } while (--loop > 0);
 152
 153         if (!loop)
 154                 return -DBGP_TIMEOUT;
 155
 156         /*
 157          * Now that we have observed the completed transaction,
 158          * clear the done bit.
 159          */
 160         writel(ctrl | DBGP_DONE, &ehci_debug->control);
 161         return (ctrl & DBGP_ERROR) ? -DBGP_ERRCODE(ctrl) : DBGP_LEN(ctrl);
 162 }
 163
 164 static inline void dbgp_mdelay(int ms)
 165 {
 166         int i;
 167
 168         while (ms--) {
 169                 for (i = 0; i < 1000; i++)
 170                         outb(0x1, 0x80);
 171         }
 172 }
 173
 174 static void dbgp_breath(void)
 175 {
 176         /* Sleep to give the debug port a chance to breathe */
 177 }
 178
 179 static int dbgp_wait_until_done(unsigned ctrl)
 180 {
 181         u32 pids, lpid;
 182         int ret;
 183         int loop = 3;
 184
 185 retry:
 186         writel(ctrl | DBGP_GO, &ehci_debug->control);
 187         ret = dbgp_wait_until_complete();
 188         pids = readl(&ehci_debug->pids);
 189         lpid = DBGP_PID_GET(pids);
 190
 191         if (ret < 0) {
 192                 /* A -DBGP_TIMEOUT failure here means the device has
 193                  * failed, perhaps because it was unplugged, in which
 194                  * case we do not want to hang the system so the dbgp
 195                  * will be marked as unsafe to use.  EHCI reset is the
 196                  * only way to recover if you unplug the dbgp device.
 197                  */
 198                 if (ret == -DBGP_TIMEOUT && !dbgp_not_safe)
 199                         dbgp_not_safe = 1;
 200                 return ret;
 201         }
 202
 203         /*
 204          * If the port is getting full or it has dropped data
 205          * start pacing ourselves, not necessary but it's friendly.
 206          */
 207         if ((lpid == USB_PID_NAK) || (lpid == USB_PID_NYET))
 208                 dbgp_breath();
 209
 210         /* If I get a NACK reissue the transmission */
 211         if (lpid == USB_PID_NAK) {
 212                 if (--loop > 0)
 213                         goto retry;
 214         }
 215
 216         return ret;
 217 }
 218
 219 static inline void dbgp_set_data(const void *buf, int size)
 220 {
 221         const unsigned char *bytes = buf;
 222         u32 lo, hi;
 223         int i;
 224
 225         lo = hi = 0;
 226         for (i = 0; i < 4 && i < size; i++)
 227                 lo |= bytes[i] << (8*i);
 228         for (; i < 8 && i < size; i++)
 229                 hi |= bytes[i] << (8*(i - 4));
 230         writel(lo, &ehci_debug->data03);
 231         writel(hi, &ehci_debug->data47);
 232 }
 233
 234 static inline void dbgp_get_data(void *buf, int size)
 235 {
 236         unsigned char *bytes = buf;
 237         u32 lo, hi;
 238         int i;
 239
 240         lo = readl(&ehci_debug->data03);
 241         hi = readl(&ehci_debug->data47);
 242         for (i = 0; i < 4 && i < size; i++)
 243                 bytes[i] = (lo >> (8*i)) & 0xff;
 244         for (; i < 8 && i < size; i++)
 245                 bytes[i] = (hi >> (8*(i - 4))) & 0xff;
 246 }
 247
 248 static int dbgp_bulk_write(unsigned devnum, unsigned endpoint,
 249                          const char *bytes, int size)
 250 {
 251         u32 pids, addr, ctrl;
 252         int ret;
 253
 254         if (size > DBGP_MAX_PACKET)
 255                 return -1;
 256
 257         addr = DBGP_EPADDR(devnum, endpoint);
 258
 259         pids = readl(&ehci_debug->pids);
 260         pids = dbgp_pid_update(pids, USB_PID_OUT);
 261
 262         ctrl = readl(&ehci_debug->control);
 263         ctrl = dbgp_len_update(ctrl, size);
 264         ctrl |= DBGP_OUT;
 265         ctrl |= DBGP_GO;
 266
 267         dbgp_set_data(bytes, size);
 268         writel(addr, &ehci_debug->address);
 269         writel(pids, &ehci_debug->pids);
 270
 271         ret = dbgp_wait_until_done(ctrl);
 272         if (ret < 0)
 273                 return ret;
 274
 275         return ret;
 276 }
 277
 278 static int dbgp_bulk_read(unsigned devnum, unsigned endpoint, void *data,
 279                                  int size)
 280 {
 281         u32 pids, addr, ctrl;
 282         int ret;
 283
 284         if (size > DBGP_MAX_PACKET)
 285                 return -1;
 286
 287         addr = DBGP_EPADDR(devnum, endpoint);
 288
 289         pids = readl(&ehci_debug->pids);
 290         pids = dbgp_pid_update(pids, USB_PID_IN);
 291
 292         ctrl = readl(&ehci_debug->control);
 293         ctrl = dbgp_len_update(ctrl, size);
 294         ctrl &= ~DBGP_OUT;
 295         ctrl |= DBGP_GO;
 296
 297         writel(addr, &ehci_debug->address);
 298         writel(pids, &ehci_debug->pids);
 299         ret = dbgp_wait_until_done(ctrl);
 300         if (ret < 0)
 301                 return ret;
 302
 303         if (size > ret)
 304                 size = ret;
 305         dbgp_get_data(data, size);
 306         return ret;
 307 }
 308
 309 static int dbgp_control_msg(unsigned devnum, int requesttype,
 310         int request, int value, int index, void *data, int size)
 311 {
 312         u32 pids, addr, ctrl;
 313         struct usb_ctrlrequest req;
 314         int read;
 315         int ret;
 316
 317         read = (requesttype & USB_DIR_IN) != 0;
 318         if (size > (read ? DBGP_MAX_PACKET:0))
 319                 return -1;
 320
 321         /* Compute the control message */
 322         req.bRequestType = requesttype;
 323         req.bRequest = request;
 324         req.wValue = cpu_to_le16(value);
 325         req.wIndex = cpu_to_le16(index);
 326         req.wLength = cpu_to_le16(size);
 327
 328         pids = DBGP_PID_SET(USB_PID_DATA0, USB_PID_SETUP);
 329         addr = DBGP_EPADDR(devnum, 0);
 330
 331         ctrl = readl(&ehci_debug->control);
 332         ctrl = dbgp_len_update(ctrl, sizeof(req));
 333         ctrl |= DBGP_OUT;
 334         ctrl |= DBGP_GO;
 335
 336         /* Send the setup message */
 337         dbgp_set_data(&req, sizeof(req));
 338         writel(addr, &ehci_debug->address);
 339         writel(pids, &ehci_debug->pids);
 340         ret = dbgp_wait_until_done(ctrl);
 341         if (ret < 0)
 342                 return ret;
 343
 344         /* Read the result */
 345         return dbgp_bulk_read(devnum, 0, data, size);
 346 }
 347
 348
 349 /* Find a PCI capability */
 350 static u32 __init find_cap(u32 num, u32 slot, u32 func, int cap)
 351 {
 352         u8 pos;
 353         int bytes;
 354
 355         if (!(read_pci_config_16(num, slot, func, PCI_STATUS) &
 356                 PCI_STATUS_CAP_LIST))
 357                 return 0;
 358
 359         pos = read_pci_config_byte(num, slot, func, PCI_CAPABILITY_LIST);
 360         for (bytes = 0; bytes < 48 && pos >= 0x40; bytes++) {
 361                 u8 id;
 362
 363                 pos &= ~3;
 364                 id = read_pci_config_byte(num, slot, func, pos+PCI_CAP_LIST_ID);
 365                 if (id == 0xff)
 366                         break;
 367                 if (id == cap)
 368                         return pos;
 369
 370                 pos = read_pci_config_byte(num, slot, func,
 371                                                  pos+PCI_CAP_LIST_NEXT);
 372         }
 373         return 0;
 374 }
 375
 376 static u32 __init __find_dbgp(u32 bus, u32 slot, u32 func)
 377 {
 378         u32 class;
 379
 380         class = read_pci_config(bus, slot, func, PCI_CLASS_REVISION);
 381         if ((class >> 8) != PCI_CLASS_SERIAL_USB_EHCI)
 382                 return 0;
 383
 384         return find_cap(bus, slot, func, PCI_CAP_ID_EHCI_DEBUG);
 385 }
 386
 387 static u32 __init find_dbgp(int ehci_num, u32 *rbus, u32 *rslot, u32 *rfunc)
 388 {
 389         u32 bus, slot, func;
 390
 391         for (bus = 0; bus < 256; bus++) {
 392                 for (slot = 0; slot < 32; slot++) {
 393                         for (func = 0; func < 8; func++) {
 394                                 unsigned cap;
 395
 396                                 cap = __find_dbgp(bus, slot, func);
 397
 398                                 if (!cap)
 399                                         continue;
 400                                 if (ehci_num-- != 0)
 401                                         continue;
 402                                 *rbus = bus;
 403                                 *rslot = slot;
 404                                 *rfunc = func;
 405                                 return cap;
 406                         }
 407                 }
 408         }
 409         return 0;
 410 }
 411
 412 static int dbgp_ehci_startup(void)
 413 {
 414         u32 ctrl, cmd, status;
 415         int loop;
 416
 417         /* Claim ownership, but do not enable yet */
 418         ctrl = readl(&ehci_debug->control);
 419         ctrl |= DBGP_OWNER;
 420         ctrl &= ~(DBGP_ENABLED | DBGP_INUSE);
 421         writel(ctrl, &ehci_debug->control);
 422         udelay(1);
 423
 424         dbgp_ehci_status("EHCI startup");
 425         /* Start the ehci running */
 426         cmd = readl(&ehci_regs->command);
 427         cmd &= ~(CMD_LRESET | CMD_IAAD | CMD_PSE | CMD_ASE | CMD_RESET);
 428         cmd |= CMD_RUN;
 429         writel(cmd, &ehci_regs->command);
 430
 431         /* Ensure everything is routed to the EHCI */
 432         writel(FLAG_CF, &ehci_regs->configured_flag);
 433
 434         /* Wait until the controller is no longer halted */
 435         loop = 10;
 436         do {
 437                 status = readl(&ehci_regs->status);
 438                 if (!(status & STS_HALT))
 439                         break;
 440                 udelay(1);
 441         } while (--loop > 0);
 442
 443         if (!loop) {
 444                 dbgp_printk("ehci can not be started\n");
 445                 return -ENODEV;
 446         }
 447         dbgp_printk("ehci started\n");
 448         return 0;
 449 }
 450
 451 static int dbgp_ehci_controller_reset(void)
 452 {
 453         int loop = 250 * 1000;
 454         u32 cmd;
 455
 456         /* Reset the EHCI controller */
 457         cmd = readl(&ehci_regs->command);
 458         cmd |= CMD_RESET;
 459         writel(cmd, &ehci_regs->command);
 460         do {
 461                 cmd = readl(&ehci_regs->command);
 462         } while ((cmd & CMD_RESET) && (--loop > 0));
 463
 464         if (!loop) {
 465                 dbgp_printk("can not reset ehci\n");
 466                 return -1;
 467         }
 468         dbgp_ehci_status("ehci reset done");
 469         return 0;
 470 }
 471 static int ehci_wait_for_port(int port);
 472 /* Return 0 on success
 473  * Return -ENODEV for any general failure
 474  * Return -EIO if wait for port fails
 475  */
 476 int dbgp_external_startup(void)
 477 {
 478         int devnum;
 479         struct usb_debug_descriptor dbgp_desc;
 480         int ret;
 481         u32 ctrl, portsc;
 482         int dbg_port = dbgp_phys_port;
 483         int tries = 3;
 484
 485         ret = dbgp_ehci_startup();
 486         if (ret)
 487                 return ret;
 488
 489         /* Wait for a device to show up in the debug port */
 490         ret = ehci_wait_for_port(dbg_port);
 491         if (ret < 0) {
 492                 portsc = readl(&ehci_regs->port_status[dbg_port - 1]);
 493                 dbgp_printk("No device found in debug port\n");
 494                 return -EIO;
 495         }
 496         dbgp_ehci_status("wait for port done");
 497
 498         /* Enable the debug port */
 499         ctrl = readl(&ehci_debug->control);
 500         ctrl |= DBGP_CLAIM;
 501         writel(ctrl, &ehci_debug->control);
 502         ctrl = readl(&ehci_debug->control);
 503         if ((ctrl & DBGP_CLAIM) != DBGP_CLAIM) {
 504                 dbgp_printk("No device in debug port\n");
 505                 writel(ctrl & ~DBGP_CLAIM, &ehci_debug->control);
 506                 return -ENODEV;
 507         }
 508         dbgp_ehci_status("debug ported enabled");
 509
 510         /* Completely transfer the debug device to the debug controller */
 511         portsc = readl(&ehci_regs->port_status[dbg_port - 1]);
 512         portsc &= ~PORT_PE;
 513         writel(portsc, &ehci_regs->port_status[dbg_port - 1]);
 514
 515         dbgp_mdelay(100);
 516
 517 try_again:
 518         /* Find the debug device and make it device number 127 */
 519         for (devnum = 0; devnum <= 127; devnum++) {
 520                 ret = dbgp_control_msg(devnum,
 521                         USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
 522                         USB_REQ_GET_DESCRIPTOR, (USB_DT_DEBUG << 8), 0,
 523                         &dbgp_desc, sizeof(dbgp_desc));
 524                 if (ret > 0)
 525                         break;
 526         }
 527         if (devnum > 127) {
 528                 dbgp_printk("Could not find attached debug device\n");
 529                 goto err;
 530         }
 531         if (ret < 0) {
 532                 dbgp_printk("Attached device is not a debug device\n");
 533                 goto err;
 534         }
 535         dbgp_endpoint_out = dbgp_desc.bDebugOutEndpoint;
 536
 537         /* Move the device to 127 if it isn't already there */
 538         if (devnum != USB_DEBUG_DEVNUM) {
 539                 ret = dbgp_control_msg(devnum,
 540                         USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
 541                         USB_REQ_SET_ADDRESS, USB_DEBUG_DEVNUM, 0, NULL, 0);
 542                 if (ret < 0) {
 543                         dbgp_printk("Could not move attached device to %d\n",
 544                                 USB_DEBUG_DEVNUM);
 545                         goto err;
 546                 }
 547                 devnum = USB_DEBUG_DEVNUM;
 548                 dbgp_printk("debug device renamed to 127\n");
 549         }
 550
 551         /* Enable the debug interface */
 552         ret = dbgp_control_msg(USB_DEBUG_DEVNUM,
 553                 USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
 554                 USB_REQ_SET_FEATURE, USB_DEVICE_DEBUG_MODE, 0, NULL, 0);
 555         if (ret < 0) {
 556                 dbgp_printk(" Could not enable the debug device\n");
 557                 goto err;
 558         }
 559         dbgp_printk("debug interface enabled\n");
 560         /* Perform a small write to get the even/odd data state in sync
 561          */
 562         ret = dbgp_bulk_write(USB_DEBUG_DEVNUM, dbgp_endpoint_out, " ", 1);
 563         if (ret < 0) {
 564                 dbgp_printk("dbgp_bulk_write failed: %d\n", ret);
 565                 goto err;
 566         }
 567         dbgp_printk("small write doned\n");
 568         dbgp_not_safe = 0;
 569
 570         return 0;
 571 err:
 572         if (tries--)
 573                 goto try_again;
 574         return -ENODEV;
 575 }
 576 EXPORT_SYMBOL_GPL(dbgp_external_startup);
 577
 578 static int __init ehci_reset_port(int port)
 579 {
 580         u32 portsc;
 581         u32 delay_time, delay;
 582         int loop;
 583
 584         dbgp_ehci_status("reset port");
 585         /* Reset the usb debug port */
 586         portsc = readl(&ehci_regs->port_status[port - 1]);
 587         portsc &= ~PORT_PE;
 588         portsc |= PORT_RESET;
 589         writel(portsc, &ehci_regs->port_status[port - 1]);
 590
 591         delay = HUB_ROOT_RESET_TIME;
 592         for (delay_time = 0; delay_time < HUB_RESET_TIMEOUT;
 593              delay_time += delay) {
 594                 dbgp_mdelay(delay);
 595                 portsc = readl(&ehci_regs->port_status[port - 1]);
 596                 if (!(portsc & PORT_RESET))
 597                         break;
 598         }
 599                 if (portsc & PORT_RESET) {
 600                         /* force reset to complete */
 601                         loop = 100 * 1000;
 602                         writel(portsc & ~(PORT_RWC_BITS | PORT_RESET),
 603                                 &ehci_regs->port_status[port - 1]);
 604                         do {
 605                                 udelay(1);
 606                                 portsc = readl(&ehci_regs->port_status[port-1]);
 607                         } while ((portsc & PORT_RESET) && (--loop > 0));
 608                 }
 609
 610                 /* Device went away? */
 611                 if (!(portsc & PORT_CONNECT))
 612                         return -ENOTCONN;
 613
 614                 /* bomb out completely if something weird happend */
 615                 if ((portsc & PORT_CSC))
 616                         return -EINVAL;
 617
 618                 /* If we've finished resetting, then break out of the loop */
 619                 if (!(portsc & PORT_RESET) && (portsc & PORT_PE))
 620                         return 0;
 621         return -EBUSY;
 622 }
 623
 624 static int ehci_wait_for_port(int port)
 625 {
 626         u32 status;
 627         int ret, reps;
 628
 629         for (reps = 0; reps < 300; reps++) {
 630                 status = readl(&ehci_regs->status);
 631                 if (status & STS_PCD)
 632                         break;
 633                 dbgp_mdelay(1);
 634         }
 635         ret = ehci_reset_port(port);
 636         if (ret == 0)
 637                 return 0;
 638         return -ENOTCONN;
 639 }
 640
 641 typedef void (*set_debug_port_t)(int port);
 642
 643 static void __init default_set_debug_port(int port)
 644 {
 645 }
 646
 647 static set_debug_port_t __initdata set_debug_port = default_set_debug_port;
 648
 649 static void __init nvidia_set_debug_port(int port)
 650 {
 651         u32 dword;
 652         dword = read_pci_config(ehci_dev.bus, ehci_dev.slot, ehci_dev.func,
 653                                  0x74);
 654         dword &= ~(0x0f<<12);
 655         dword |= ((port & 0x0f)<<12);
 656         write_pci_config(ehci_dev.bus, ehci_dev.slot, ehci_dev.func, 0x74,
 657                                  dword);
 658         dbgp_printk("set debug port to %d\n", port);
 659 }
 660
 661 static void __init detect_set_debug_port(void)
 662 {
 663         u32 vendorid;
 664
 665         vendorid = read_pci_config(ehci_dev.bus, ehci_dev.slot, ehci_dev.func,
 666                  0x00);
 667
 668         if ((vendorid & 0xffff) == 0x10de) {
 669                 dbgp_printk("using nvidia set_debug_port\n");
 670                 set_debug_port = nvidia_set_debug_port;
 671         }
 672 }
 673
 674 /* The code in early_ehci_bios_handoff() is derived from the usb pci
 675  * quirk initialization, but altered so as to use the early PCI
 676  * routines. */
 677 #define EHCI_USBLEGSUP_BIOS     (1 << 16)       /* BIOS semaphore */
 678 #define EHCI_USBLEGCTLSTS       4               /* legacy control/status */
 679 static void __init early_ehci_bios_handoff(void)
 680 {
 681         u32 hcc_params = readl(&ehci_caps->hcc_params);
 682         int offset = (hcc_params >> 8) & 0xff;
 683         u32 cap;
 684         int msec;
 685
 686         if (!offset)
 687                 return;
 688
 689         cap = read_pci_config(ehci_dev.bus, ehci_dev.slot,
 690                               ehci_dev.func, offset);
 691         dbgp_printk("dbgp: ehci BIOS state %08x\n", cap);
 692
 693         if ((cap & 0xff) == 1 && (cap & EHCI_USBLEGSUP_BIOS)) {
 694                 dbgp_printk("dbgp: BIOS handoff\n");
 695                 write_pci_config_byte(ehci_dev.bus, ehci_dev.slot,
 696                                       ehci_dev.func, offset + 3, 1);
 697         }
 698
 699         /* if boot firmware now owns EHCI, spin till it hands it over. */
 700         msec = 1000;
 701         while ((cap & EHCI_USBLEGSUP_BIOS) && (msec > 0)) {
 702                 mdelay(10);
 703                 msec -= 10;
 704                 cap = read_pci_config(ehci_dev.bus, ehci_dev.slot,
 705                                       ehci_dev.func, offset);
 706         }
 707
 708         if (cap & EHCI_USBLEGSUP_BIOS) {
 709                 /* well, possibly buggy BIOS... try to shut it down,
 710                  * and hope nothing goes too wrong */
 711                 dbgp_printk("dbgp: BIOS handoff failed: %08x\n", cap);
 712                 write_pci_config_byte(ehci_dev.bus, ehci_dev.slot,
 713                                       ehci_dev.func, offset + 2, 0);
 714         }
 715
 716         /* just in case, always disable EHCI SMIs */
 717         write_pci_config_byte(ehci_dev.bus, ehci_dev.slot, ehci_dev.func,
 718                               offset + EHCI_USBLEGCTLSTS, 0);
 719 }
 720
 721 static int __init ehci_setup(void)
 722 {
 723         u32 ctrl, portsc, hcs_params;
 724         u32 debug_port, new_debug_port = 0, n_ports;
 725         int ret, i;
 726         int port_map_tried;
 727         int playtimes = 3;
 728
 729         early_ehci_bios_handoff();
 730
 731 try_next_time:
 732         port_map_tried = 0;
 733
 734 try_next_port:
 735
 736         hcs_params = readl(&ehci_caps->hcs_params);
 737         debug_port = HCS_DEBUG_PORT(hcs_params);
 738         dbgp_phys_port = debug_port;
 739         n_ports    = HCS_N_PORTS(hcs_params);
 740
 741         dbgp_printk("debug_port: %d\n", debug_port);
 742         dbgp_printk("n_ports:    %d\n", n_ports);
 743         dbgp_ehci_status("");
 744
 745         for (i = 1; i <= n_ports; i++) {
 746                 portsc = readl(&ehci_regs->port_status[i-1]);
 747                 dbgp_printk("portstatus%d: %08x\n", i, portsc);
 748         }
 749
 750         if (port_map_tried && (new_debug_port != debug_port)) {
 751                 if (--playtimes) {
 752                         set_debug_port(new_debug_port);
 753                         goto try_next_time;
 754                 }
 755                 return -1;
 756         }
 757
 758         /* Only reset the controller if it is not already in the
 759          * configured state */
 760         if (!(readl(&ehci_regs->configured_flag) & FLAG_CF)) {
 761                 if (dbgp_ehci_controller_reset() != 0)
 762                         return -1;
 763         } else {
 764                 dbgp_ehci_status("ehci skip - already configured");
 765         }
 766
 767         ret = dbgp_external_startup();
 768         if (ret == -EIO)
 769                 goto next_debug_port;
 770
 771         if (ret < 0) {
 772                 /* Things didn't work so remove my claim */
 773                 ctrl = readl(&ehci_debug->control);
 774                 ctrl &= ~(DBGP_CLAIM | DBGP_OUT);
 775                 writel(ctrl, &ehci_debug->control);
 776                 return -1;
 777         }
 778         return 0;
 779
 780 next_debug_port:
 781         port_map_tried |= (1<<(debug_port - 1));
 782         new_debug_port = ((debug_port-1+1)%n_ports) + 1;
 783         if (port_map_tried != ((1<<n_ports) - 1)) {
 784                 set_debug_port(new_debug_port);
 785                 goto try_next_port;
 786         }
 787         if (--playtimes) {
 788                 set_debug_port(new_debug_port);
 789                 goto try_next_time;
 790         }
 791
 792         return -1;
 793 }
 794
 795 int __init early_dbgp_init(char *s)
 796 {
 797         u32 debug_port, bar, offset;
 798         u32 bus, slot, func, cap;
 799         void __iomem *ehci_bar;
 800         u32 dbgp_num;
 801         u32 bar_val;
 802         char *e;
 803         int ret;
 804         u8 byte;
 805
 806         if (!early_pci_allowed())
 807                 return -1;
 808
 809         dbgp_num = 0;
 810         if (*s)
 811                 dbgp_num = simple_strtoul(s, &e, 10);
 812         dbgp_printk("dbgp_num: %d\n", dbgp_num);
 813
 814         cap = find_dbgp(dbgp_num, &bus, &slot, &func);
 815         if (!cap)
 816                 return -1;
 817
 818         dbgp_printk("Found EHCI debug port on %02x:%02x.%1x\n", bus, slot,
 819                          func);
 820
 821         debug_port = read_pci_config(bus, slot, func, cap);
 822         bar = (debug_port >> 29) & 0x7;
 823         bar = (bar * 4) + 0xc;
 824         offset = (debug_port >> 16) & 0xfff;
 825         dbgp_printk("bar: %02x offset: %03x\n", bar, offset);
 826         if (bar != PCI_BASE_ADDRESS_0) {
 827                 dbgp_printk("only debug ports on bar 1 handled.\n");
 828
 829                 return -1;
 830         }
 831
 832         bar_val = read_pci_config(bus, slot, func, PCI_BASE_ADDRESS_0);
 833         dbgp_printk("bar_val: %02x offset: %03x\n", bar_val, offset);
 834         if (bar_val & ~PCI_BASE_ADDRESS_MEM_MASK) {
 835                 dbgp_printk("only simple 32bit mmio bars supported\n");
 836
 837                 return -1;
 838         }
 839
 840         /* double check if the mem space is enabled */
 841         byte = read_pci_config_byte(bus, slot, func, 0x04);
 842         if (!(byte & 0x2)) {
 843                 byte  |= 0x02;
 844                 write_pci_config_byte(bus, slot, func, 0x04, byte);
 845                 dbgp_printk("mmio for ehci enabled\n");
 846         }
 847
 848         /*
 849          * FIXME I don't have the bar size so just guess PAGE_SIZE is more
 850          * than enough.  1K is the biggest I have seen.
 851          */
 852         set_fixmap_nocache(FIX_DBGP_BASE, bar_val & PAGE_MASK);
 853         ehci_bar = (void __iomem *)__fix_to_virt(FIX_DBGP_BASE);
 854         ehci_bar += bar_val & ~PAGE_MASK;
 855         dbgp_printk("ehci_bar: %p\n", ehci_bar);
 856
 857         ehci_caps  = ehci_bar;
 858         ehci_regs  = ehci_bar + HC_LENGTH(readl(&ehci_caps->hc_capbase));
 859         ehci_debug = ehci_bar + offset;
 860         ehci_dev.bus = bus;
 861         ehci_dev.slot = slot;
 862         ehci_dev.func = func;
 863
 864         detect_set_debug_port();
 865
 866         ret = ehci_setup();
 867         if (ret < 0) {
 868                 dbgp_printk("ehci_setup failed\n");
 869                 ehci_debug = NULL;
 870
 871                 return -1;
 872         }
 873         dbgp_ehci_status("early_init_complete");
 874
 875         return 0;
 876 }
 877
 878 static void early_dbgp_write(struct console *con, const char *str, u32 n)
 879 {
 880         int chunk, ret;
 881         char buf[DBGP_MAX_PACKET];
 882         int use_cr = 0;
 883         u32 cmd, ctrl;
 884         int reset_run = 0;
 885
 886         if (!ehci_debug || dbgp_not_safe)
 887                 return;
 888
 889         cmd = readl(&ehci_regs->command);
 890         if (unlikely(!(cmd & CMD_RUN))) {
 891                 /* If the ehci controller is not in the run state do extended
 892                  * checks to see if the acpi or some other initialization also
 893                  * reset the ehci debug port */
 894                 ctrl = readl(&ehci_debug->control);
 895                 if (!(ctrl & DBGP_ENABLED)) {
 896                         dbgp_not_safe = 1;
 897                         dbgp_external_startup();
 898                 } else {
 899                         cmd |= CMD_RUN;
 900                         writel(cmd, &ehci_regs->command);
 901                         reset_run = 1;
 902                 }
 903         }
 904         while (n > 0) {
 905                 for (chunk = 0; chunk < DBGP_MAX_PACKET && n > 0;
 906                      str++, chunk++, n--) {
 907                         if (!use_cr && *str == '\n') {
 908                                 use_cr = 1;
 909                                 buf[chunk] = '\r';
 910                                 str--;
 911                                 n++;
 912                                 continue;
 913                         }
 914                         if (use_cr)
 915                                 use_cr = 0;
 916                         buf[chunk] = *str;
 917                 }
 918                 if (chunk > 0) {
 919                         ret = dbgp_bulk_write(USB_DEBUG_DEVNUM,
 920                                       dbgp_endpoint_out, buf, chunk);
 921                 }
 922         }
 923         if (unlikely(reset_run)) {
 924                 cmd = readl(&ehci_regs->command);
 925                 cmd &= ~CMD_RUN;
 926                 writel(cmd, &ehci_regs->command);
 927         }
 928 }
 929
 930 struct console early_dbgp_console = {
 931         .name =         "earlydbg",
 932         .write =        early_dbgp_write,
 933         .flags =        CON_PRINTBUFFER,
 934         .index =        -1,
 935 };