target/linux/adm5120/files/drivers/usb/host/adm5120-dbg.c

   1 /*
   2  * OHCI HCD (Host Controller Driver) for USB.
   3  *
   4  * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
   5  * (C) Copyright 2000-2002 David Brownell <dbrownell@users.sourceforge.net>
   6  *
   7  * This file is licenced under the GPL.
   8  */
   9
  10 /*-------------------------------------------------------------------------*/
  11
  12 #ifdef DEBUG
  13
  14 #define edstring(ed_type) ({ char *temp; \
  15         switch (ed_type) { \
  16         case PIPE_CONTROL:      temp = "ctrl"; break; \
  17         case PIPE_BULK:         temp = "bulk"; break; \
  18         case PIPE_INTERRUPT:    temp = "intr"; break; \
  19         default:                temp = "isoc"; break; \
  20         }; temp;})
  21 #define pipestring(pipe) edstring(usb_pipetype(pipe))
  22
  23 /* debug| print the main components of an URB
  24  * small: 0) header + data packets 1) just header
  25  */
  26 static void __attribute__((unused))
  27 urb_print(struct urb * urb, char * str, int small)
  28 {
  29         unsigned int pipe= urb->pipe;
  30
  31         if (!urb->dev || !urb->dev->bus) {
  32                 dbg("%s URB: no dev", str);
  33                 return;
  34         }
  35
  36 #ifndef ADMHC_VERBOSE_DEBUG
  37         if (urb->status != 0)
  38 #endif
  39         dbg("%s %p dev=%d ep=%d%s-%s flags=%x len=%d/%d stat=%d",
  40                     str,
  41                     urb,
  42                     usb_pipedevice (pipe),
  43                     usb_pipeendpoint (pipe),
  44                     usb_pipeout(pipe)? "out" : "in",
  45                     pipestring(pipe),
  46                     urb->transfer_flags,
  47                     urb->actual_length,
  48                     urb->transfer_buffer_length,
  49                     urb->status);
  50
  51 #ifdef  ADMHC_VERBOSE_DEBUG
  52         if (!small) {
  53                 int i, len;
  54
  55                 if (usb_pipecontrol(pipe)) {
  56                         printk(KERN_DEBUG __FILE__ ": setup(8):");
  57                         for (i = 0; i < 8 ; i++)
  58                                 printk (" %02x", ((__u8 *) urb->setup_packet) [i]);
  59                         printk ("\n");
  60                 }
  61                 if (urb->transfer_buffer_length > 0 && urb->transfer_buffer) {
  62                         printk(KERN_DEBUG __FILE__ ": data(%d/%d):",
  63                                 urb->actual_length,
  64                                 urb->transfer_buffer_length);
  65                         len = usb_pipeout(pipe)?
  66                                                 urb->transfer_buffer_length: urb->actual_length;
  67                         for (i = 0; i < 16 && i < len; i++)
  68                                 printk (" %02x", ((__u8 *) urb->transfer_buffer) [i]);
  69                         printk ("%s stat:%d\n", i < len? "...": "", urb->status);
  70                 }
  71         }
  72 #endif /* ADMHC_VERBOSE_DEBUG */
  73 }
  74
  75 #define admhc_dbg_sw(ahcd, next, size, format, arg...) \
  76         do { \
  77         if (next) { \
  78                 unsigned s_len; \
  79                 s_len = scnprintf(*next, *size, format, ## arg ); \
  80                 *size -= s_len; *next += s_len; \
  81         } else \
  82                 admhc_dbg(ahcd,format, ## arg ); \
  83         } while (0);
  84
  85
  86 static void admhc_dump_intr_mask (
  87         struct admhcd *ahcd,
  88         char *label,
  89         u32 mask,
  90         char **next,
  91         unsigned *size)
  92 {
  93         admhc_dbg_sw(ahcd, next, size, "%s 0x%08x%s%s%s%s%s%s%s%s%s%s\n",
  94                 label,
  95                 mask,
  96                 (mask & ADMHC_INTR_INTA) ? " INTA" : "",
  97                 (mask & ADMHC_INTR_FATI) ? " FATI" : "",
  98                 (mask & ADMHC_INTR_SWI) ? " SWI" : "",
  99                 (mask & ADMHC_INTR_TDC) ? " TDC" : "",
 100                 (mask & ADMHC_INTR_FNO) ? " FNO" : "",
 101                 (mask & ADMHC_INTR_SO) ? " SO" : "",
 102                 (mask & ADMHC_INTR_INSM) ? " INSM" : "",
 103                 (mask & ADMHC_INTR_BABI) ? " BABI" : "",
 104                 (mask & ADMHC_INTR_RESI) ? " RESI" : "",
 105                 (mask & ADMHC_INTR_SOFI) ? " SOFI" : ""
 106                 );
 107 }
 108
 109 static void maybe_print_eds (
 110         struct admhcd *ahcd,
 111         char *label,
 112         u32 value,
 113         char **next,
 114         unsigned *size)
 115 {
 116         if (value)
 117                 admhc_dbg_sw(ahcd, next, size, "%s %08x\n", label, value);
 118 }
 119
 120 static char *buss2string (int state)
 121 {
 122         switch (state) {
 123         case ADMHC_BUSS_RESET:
 124                 return "reset";
 125         case ADMHC_BUSS_RESUME:
 126                 return "resume";
 127         case ADMHC_BUSS_OPER:
 128                 return "operational";
 129         case ADMHC_BUSS_SUSPEND:
 130                 return "suspend";
 131         }
 132         return "(bad state)";
 133 }
 134
 135 static void
 136 admhc_dump_status(struct admhcd *ahcd, char **next, unsigned *size)
 137 {
 138         struct admhcd_regs __iomem *regs = ahcd->regs;
 139         u32                     temp;
 140
 141         temp = admhc_readl(ahcd, &regs->gencontrol);
 142         admhc_dbg_sw(ahcd, next, size,
 143                 "gencontrol 0x%08x%s%s%s%s\n",
 144                 temp,
 145                 (temp & ADMHC_CTRL_UHFE) ? " UHFE" : "",
 146                 (temp & ADMHC_CTRL_SIR) ? " SIR" : "",
 147                 (temp & ADMHC_CTRL_DMAA) ? " DMAA" : "",
 148                 (temp & ADMHC_CTRL_SR) ? " SR" : ""
 149                 );
 150
 151         temp = admhc_readl(ahcd, &regs->host_control);
 152         admhc_dbg_sw(ahcd, next, size,
 153                 "host_control 0x%08x BUSS=%s%s\n",
 154                 temp,
 155                 buss2string (temp & ADMHC_HC_BUSS),
 156                 (temp & ADMHC_HC_DMAE) ? " DMAE" : ""
 157                 );
 158
 159         admhc_dump_intr_mask(ahcd, "int_status",
 160                         admhc_readl(ahcd, &regs->int_status),
 161                         next, size);
 162         admhc_dump_intr_mask(ahcd, "int_enable",
 163                         admhc_readl(ahcd, &regs->int_enable),
 164                         next, size);
 165
 166         maybe_print_eds(ahcd, "hosthead",
 167                         admhc_readl(ahcd, &regs->hosthead), next, size);
 168 }
 169
 170 #define dbg_port_sw(hc,num,value,next,size) \
 171         admhc_dbg_sw(hc, next, size, \
 172                 "portstatus [%d] " \
 173                 "0x%08x%s%s%s%s%s%s%s%s%s%s%s%s\n", \
 174                 num, temp, \
 175                 (temp & ADMHC_PS_PRSC) ? " PRSC" : "", \
 176                 (temp & ADMHC_PS_OCIC) ? " OCIC" : "", \
 177                 (temp & ADMHC_PS_PSSC) ? " PSSC" : "", \
 178                 (temp & ADMHC_PS_PESC) ? " PESC" : "", \
 179                 (temp & ADMHC_PS_CSC) ? " CSC" : "", \
 180                 \
 181                 (temp & ADMHC_PS_LSDA) ? " LSDA" : "", \
 182                 (temp & ADMHC_PS_PPS) ? " PPS" : "", \
 183                 (temp & ADMHC_PS_PRS) ? " PRS" : "", \
 184                 (temp & ADMHC_PS_POCI) ? " POCI" : "", \
 185                 (temp & ADMHC_PS_PSS) ? " PSS" : "", \
 186                 \
 187                 (temp & ADMHC_PS_PES) ? " PES" : "", \
 188                 (temp & ADMHC_PS_CCS) ? " CCS" : "" \
 189                 );
 190
 191
 192 static void
 193 admhc_dump_roothub(
 194         struct admhcd *ahcd,
 195         int verbose,
 196         char **next,
 197         unsigned *size)
 198 {
 199         u32                     temp, i;
 200
 201         temp = admhc_get_rhdesc(ahcd);
 202         if (temp == ~(u32)0)
 203                 return;
 204
 205         if (verbose) {
 206                 admhc_dbg_sw(ahcd, next, size,
 207                         "rhdesc %08x%s%s%s%s%s%s PPCM=%02x%s%s%s%s NUMP=%d(%d)\n",
 208                         temp,
 209                         (temp & ADMHC_RH_CRWE) ? " CRWE" : "",
 210                         (temp & ADMHC_RH_OCIC) ? " OCIC" : "",
 211                         (temp & ADMHC_RH_LPSC) ? " LPSC" : "",
 212                         (temp & ADMHC_RH_LPSC) ? " DRWE" : "",
 213                         (temp & ADMHC_RH_LPSC) ? " OCI" : "",
 214                         (temp & ADMHC_RH_LPSC) ? " LPS" : "",
 215                         ((temp & ADMHC_RH_PPCM) >> 16),
 216                         (temp & ADMHC_RH_NOCP) ? " NOCP" : "",
 217                         (temp & ADMHC_RH_OCPM) ? " OCPM" : "",
 218                         (temp & ADMHC_RH_NPS) ? " NPS" : "",
 219                         (temp & ADMHC_RH_PSM) ? " PSM" : "",
 220                         (temp & ADMHC_RH_NUMP), ahcd->num_ports
 221                         );
 222         }
 223
 224         for (i = 0; i < ahcd->num_ports; i++) {
 225                 temp = admhc_get_portstatus(ahcd, i);
 226                 dbg_port_sw(ahcd, i, temp, next, size);
 227         }
 228 }
 229
 230 static void admhc_dump(struct admhcd *ahcd, int verbose)
 231 {
 232         admhc_dbg(ahcd, "ADMHC ahcd state\n");
 233
 234         /* dumps some of the state we know about */
 235         admhc_dump_status(ahcd, NULL, NULL);
 236         admhc_dbg(ahcd,"current frame #%04x\n",
 237                 admhc_frame_no(ahcd));
 238
 239         admhc_dump_roothub(ahcd, verbose, NULL, NULL);
 240 }
 241
 242 static const char data0[] = "DATA0";
 243 static const char data1[] = "DATA1";
 244
 245 static void admhc_dump_td(const struct admhcd *ahcd, const char *label,
 246                 const struct td *td)
 247 {
 248         u32     tmp = hc32_to_cpup(ahcd, &td->hwINFO);
 249
 250         admhc_dbg(ahcd, "%s td %p; urb %p index %d; hwNextTD %08x\n",
 251                 label, td,
 252                 td->urb, td->index,
 253                 hc32_to_cpup(ahcd, &td->hwNextTD));
 254
 255         if ((td->flags & TD_FLAG_ISO) == 0) {
 256                 const char      *toggle, *pid;
 257
 258                 switch (tmp & TD_T) {
 259                 case TD_T_DATA0: toggle = data0; break;
 260                 case TD_T_DATA1: toggle = data1; break;
 261                 case TD_T_CARRY: toggle = "CARRY"; break;
 262                 default: toggle = "(bad toggle)"; break;
 263                 }
 264                 switch (tmp & TD_DP) {
 265                 case TD_DP_SETUP: pid = "SETUP"; break;
 266                 case TD_DP_IN: pid = "IN"; break;
 267                 case TD_DP_OUT: pid = "OUT"; break;
 268                 default: pid = "(bad pid)"; break;
 269                 }
 270                 admhc_dbg(ahcd,
 271                         "     status %08x%s CC=%x EC=%d %s %s ISI=%x FN=%x\n",
 272                         tmp,
 273                         (tmp & TD_OWN) ? " OWN" : "",
 274                         TD_CC_GET(tmp),
 275                         TD_EC_GET(tmp),
 276                         toggle,
 277                         pid,
 278                         TD_ISI_GET(tmp),
 279                         TD_FN_GET(tmp));
 280         } else {
 281 #if 0           /* TODO: remove */
 282                 unsigned        i;
 283                 admhc_dbg(ahcd, "  info %08x CC=%x FC=%d DI=%d SF=%04x\n", tmp,
 284                         TD_CC_GET(tmp),
 285                         (tmp >> 24) & 0x07,
 286                         (tmp & TD_DI) >> 21,
 287                         tmp & 0x0000ffff);
 288                 admhc_dbg(ahcd, "  bp0 %08x be %08x\n",
 289                         hc32_to_cpup (ahcd, &td->hwCBP) & ~0x0fff,
 290                         hc32_to_cpup (ahcd, &td->hwBE));
 291 #endif
 292         }
 293
 294         tmp = hc32_to_cpup(ahcd, &td->hwCBL);
 295         admhc_dbg(ahcd, "     dbp %08x; cbl %08x; LEN=%d%s\n",
 296                 hc32_to_cpup (ahcd, &td->hwDBP),
 297                 tmp,
 298                 TD_BL_GET(tmp),
 299                 (tmp & TD_IE) ? " IE" : ""
 300         );
 301 }
 302
 303 /* caller MUST own hcd spinlock if verbose is set! */
 304 static void __attribute__((unused))
 305 admhc_dump_ed(const struct admhcd *ahcd, const char *label,
 306                 const struct ed *ed, int verbose)
 307 {
 308         u32 tmp = hc32_to_cpu(ahcd, ed->hwINFO);
 309
 310         admhc_dbg(ahcd, "%s ed %p state 0x%x type %s; next ed %08x\n",
 311                 label,
 312                 ed, ed->state, edstring (ed->type),
 313                 hc32_to_cpup (ahcd, &ed->hwNextED));
 314
 315         admhc_dbg(ahcd, "  info %08x MAX=%d%s%s%s%s EP=%d DEV=%d\n", tmp,
 316                 ED_MPS_GET(tmp),
 317                 (tmp & ED_ISO) ? " ISO" : "",
 318                 (tmp & ED_SKIP) ? " SKIP" : "",
 319                 (tmp & ED_SPEED_FULL) ? " FULL" : " LOW",
 320                 (tmp & ED_INT) ? " INT" : "",
 321                 ED_EN_GET(tmp),
 322                 ED_FA_GET(tmp));
 323
 324         tmp = hc32_to_cpup(ahcd, &ed->hwHeadP);
 325         admhc_dbg(ahcd, "  tds: head %08x tail %08x %s%s%s\n",
 326                 tmp & TD_MASK,
 327                 hc32_to_cpup (ahcd, &ed->hwTailP),
 328                 (tmp & ED_C) ? data1 : data0,
 329                 (tmp & ED_H) ? " HALT" : "",
 330                 verbose ? " td list follows" : " (not listing)");
 331
 332         if (verbose) {
 333                 struct list_head        *tmp;
 334
 335                 /* use ed->td_list because HC concurrently modifies
 336                  * hwNextTD as it accumulates ed_donelist.
 337                  */
 338                 list_for_each(tmp, &ed->td_list) {
 339                         struct td               *td;
 340                         td = list_entry(tmp, struct td, td_list);
 341                         admhc_dump_td (ahcd, "  ->", td);
 342                 }
 343         }
 344 }
 345
 346 #else /* ifdef DEBUG */
 347
 348 static inline void urb_print(struct urb * urb, char * str, int small) {}
 349 static inline void admhc_dump_ed(const struct admhcd *ahcd, const char *label,
 350         const struct ed *ed, int verbose) {}
 351 static inline void admhc_dump(struct admhcd *ahcd, int verbose) {}
 352
 353 #undef ADMHC_VERBOSE_DEBUG
 354
 355 #endif /* DEBUG */
 356
 357 /*-------------------------------------------------------------------------*/
 358
 359 #ifdef STUB_DEBUG_FILES
 360
 361 static inline void create_debug_files(struct admhcd *bus) { }
 362 static inline void remove_debug_files(struct admhcd *bus) { }
 363
 364 #else
 365
 366 static ssize_t
 367 show_list(struct admhcd *ahcd, char *buf, size_t count, struct ed *ed)
 368 {
 369         unsigned                temp, size = count;
 370
 371         if (!ed)
 372                 return 0;
 373
 374 #if 0
 375         /* print first --> last */
 376         while (ed->ed_prev)
 377                 ed = ed->ed_prev;
 378 #endif
 379
 380         /* dump a snapshot of the bulk or control schedule */
 381         while (ed) {
 382                 u32 info = hc32_to_cpu(ahcd, ed->hwINFO);
 383                 u32 headp = hc32_to_cpu(ahcd, ed->hwHeadP);
 384                 struct list_head *entry;
 385                 struct td       *td;
 386
 387                 temp = scnprintf(buf, size,
 388                         "ed/%p %s %cs dev%d ep%d %s%smax %d %08x%s%s %s",
 389                         ed,
 390                         edstring (ed->type),
 391                         (info & ED_SPEED_FULL) ? 'f' : 'l',
 392                         info & ED_FA_MASK,
 393                         (info >> ED_EN_SHIFT) & ED_EN_MASK,
 394                         (info & ED_INT) ? "INT " : "",
 395                         (info & ED_ISO) ? "ISO " : "",
 396                         (info >> ED_MPS_SHIFT) & ED_MPS_MASK ,
 397                         info,
 398                         (info & ED_SKIP) ? " S" : "",
 399                         (headp & ED_H) ? " H" : "",
 400                         (headp & ED_C) ? data1 : data0);
 401                 size -= temp;
 402                 buf += temp;
 403
 404                 list_for_each(entry, &ed->td_list) {
 405                         u32             dbp, cbl;
 406
 407                         td = list_entry(entry, struct td, td_list);
 408                         info = hc32_to_cpup (ahcd, &td->hwINFO);
 409                         dbp = hc32_to_cpup (ahcd, &td->hwDBP);
 410                         cbl = hc32_to_cpup (ahcd, &td->hwCBL);
 411
 412                         temp = scnprintf(buf, size,
 413                                 "\n\ttd %p %s %d %s%scc=%x urb %p (%08x,%08x)",
 414                                 td,
 415                                 ({ char *pid;
 416                                 switch (info & TD_DP) {
 417                                 case TD_DP_SETUP: pid = "setup"; break;
 418                                 case TD_DP_IN: pid = "in"; break;
 419                                 case TD_DP_OUT: pid = "out"; break;
 420                                 default: pid = "(bad pid)"; break;
 421                                  } pid;}),
 422                                 TD_BL_GET(cbl),
 423                                 (info & TD_OWN) ? "" : "DONE ",
 424                                 (cbl & TD_IE) ? "IE " : "",
 425                                 TD_CC_GET (info), td->urb, info, cbl);
 426                         size -= temp;
 427                         buf += temp;
 428                 }
 429
 430                 temp = scnprintf(buf, size, "\n");
 431                 size -= temp;
 432                 buf += temp;
 433
 434                 ed = ed->ed_next;
 435         }
 436         return count - size;
 437 }
 438
 439 static ssize_t
 440 show_async(struct class_device *class_dev, char *buf)
 441 {
 442         struct usb_bus          *bus;
 443         struct usb_hcd          *hcd;
 444         struct admhcd           *ahcd;
 445         size_t                  temp;
 446         unsigned long           flags;
 447
 448         bus = class_get_devdata(class_dev);
 449         hcd = bus_to_hcd(bus);
 450         ahcd = hcd_to_admhcd(hcd);
 451
 452         /* display control and bulk lists together, for simplicity */
 453         spin_lock_irqsave(&ahcd->lock, flags);
 454 #if 0
 455         temp = show_list (ahcd, buf, PAGE_SIZE, ahcd->ed_tails[ED_TAIL_CONTROL]);
 456         temp += show_list (ahcd, buf + temp, PAGE_SIZE - temp,
 457                 ahcd->ed_tails[ED_TAIL_BULK]);
 458 #else
 459 #ifdef ED_TAIL_ARRAY
 460         temp = show_list(ahcd, buf, PAGE_SIZE, ahcd->ed_head);
 461 #else
 462         temp = show_list(ahcd, buf, PAGE_SIZE, ahcd->ed_head);
 463 #endif
 464 #endif
 465         spin_unlock_irqrestore(&ahcd->lock, flags);
 466
 467         return temp;
 468 }
 469 static CLASS_DEVICE_ATTR(async, S_IRUGO, show_async, NULL);
 470
 471
 472 #define DBG_SCHED_LIMIT 64
 473
 474 static ssize_t
 475 show_periodic(struct class_device *class_dev, char *buf)
 476 {
 477         struct usb_bus          *bus;
 478         struct usb_hcd          *hcd;
 479         struct admhcd           *ahcd;
 480         struct ed               **seen, *ed;
 481         unsigned long           flags;
 482         unsigned                temp, size, seen_count;
 483         char                    *next;
 484         unsigned                i;
 485
 486         if (!(seen = kmalloc(DBG_SCHED_LIMIT * sizeof *seen, GFP_ATOMIC)))
 487                 return 0;
 488         seen_count = 0;
 489
 490         bus = class_get_devdata(class_dev);
 491         hcd = bus_to_hcd(bus);
 492         ahcd = hcd_to_admhcd(hcd);
 493         next = buf;
 494         size = PAGE_SIZE;
 495
 496         temp = scnprintf(next, size, "size = %d\n", NUM_INTS);
 497         size -= temp;
 498         next += temp;
 499
 500         /* dump a snapshot of the periodic schedule (and load) */
 501         spin_lock_irqsave(&ahcd->lock, flags);
 502         for (i = 0; i < NUM_INTS; i++) {
 503                 if (!(ed = ahcd->periodic [i]))
 504                         continue;
 505
 506                 temp = scnprintf(next, size, "%2d [%3d]:", i, ahcd->load [i]);
 507                 size -= temp;
 508                 next += temp;
 509
 510                 do {
 511                         temp = scnprintf(next, size, " ed%d/%p",
 512                                 ed->interval, ed);
 513                         size -= temp;
 514                         next += temp;
 515                         for (temp = 0; temp < seen_count; temp++) {
 516                                 if (seen [temp] == ed)
 517                                         break;
 518                         }
 519
 520                         /* show more info the first time around */
 521                         if (temp == seen_count) {
 522                                 u32     info = hc32_to_cpu (ahcd, ed->hwINFO);
 523                                 struct list_head        *entry;
 524                                 unsigned                qlen = 0;
 525
 526                                 /* qlen measured here in TDs, not urbs */
 527                                 list_for_each (entry, &ed->td_list)
 528                                         qlen++;
 529                                 temp = scnprintf(next, size,
 530                                         " (%cs dev%d ep%d%s qlen %u"
 531                                         " max %d %08x%s%s)",
 532                                         (info & ED_SPEED_FULL) ? 'f' : 'l',
 533                                         ED_FA_GET(info),
 534                                         ED_EN_GET(info),
 535                                         (info & ED_ISO) ? "iso" : "int",
 536                                         qlen,
 537                                         ED_MPS_GET(info),
 538                                         info,
 539                                         (info & ED_SKIP) ? " K" : "",
 540                                         (ed->hwHeadP &
 541                                                 cpu_to_hc32(ahcd, ED_H)) ?
 542                                                         " H" : "");
 543                                 size -= temp;
 544                                 next += temp;
 545
 546                                 if (seen_count < DBG_SCHED_LIMIT)
 547                                         seen [seen_count++] = ed;
 548
 549                                 ed = ed->ed_next;
 550
 551                         } else {
 552                                 /* we've seen it and what's after */
 553                                 temp = 0;
 554                                 ed = NULL;
 555                         }
 556
 557                 } while (ed);
 558
 559                 temp = scnprintf(next, size, "\n");
 560                 size -= temp;
 561                 next += temp;
 562         }
 563         spin_unlock_irqrestore(&ahcd->lock, flags);
 564         kfree (seen);
 565
 566         return PAGE_SIZE - size;
 567 }
 568 static CLASS_DEVICE_ATTR(periodic, S_IRUGO, show_periodic, NULL);
 569
 570
 571 #undef DBG_SCHED_LIMIT
 572
 573 static ssize_t
 574 show_registers(struct class_device *class_dev, char *buf)
 575 {
 576         struct usb_bus          *bus;
 577         struct usb_hcd          *hcd;
 578         struct admhcd           *ahcd;
 579         struct admhcd_regs __iomem *regs;
 580         unsigned long           flags;
 581         unsigned                temp, size;
 582         char                    *next;
 583         u32                     rdata;
 584
 585         bus = class_get_devdata(class_dev);
 586         hcd = bus_to_hcd(bus);
 587         ahcd = hcd_to_admhcd(hcd);
 588         regs = ahcd->regs;
 589         next = buf;
 590         size = PAGE_SIZE;
 591
 592         spin_lock_irqsave(&ahcd->lock, flags);
 593
 594         /* dump driver info, then registers in spec order */
 595
 596         admhc_dbg_sw(ahcd, &next, &size,
 597                 "bus %s, device %s\n"
 598                 "%s\n"
 599                 "%s version " DRIVER_VERSION "\n",
 600                 hcd->self.controller->bus->name,
 601                 hcd->self.controller->bus_id,
 602                 hcd->product_desc,
 603                 hcd_name);
 604
 605         if (bus->controller->power.power_state.event) {
 606                 size -= scnprintf(next, size,
 607                         "SUSPENDED (no register access)\n");
 608                 goto done;
 609         }
 610
 611         admhc_dump_status(ahcd, &next, &size);
 612
 613         /* other registers mostly affect frame timings */
 614         rdata = admhc_readl(ahcd, &regs->fminterval);
 615         temp = scnprintf(next, size,
 616                         "fmintvl 0x%08x %sFSLDP=0x%04x FI=0x%04x\n",
 617                         rdata, (rdata & ADMHC_SFI_FIT) ? "FIT " : "",
 618                         (rdata >> ADMHC_SFI_FSLDP_SHIFT) & ADMHC_SFI_FSLDP_MASK,
 619                         rdata  & ADMHC_SFI_FI_MASK);
 620         size -= temp;
 621         next += temp;
 622
 623         rdata = admhc_readl(ahcd, &regs->fmnumber);
 624         temp = scnprintf(next, size, "fmnumber 0x%08x %sFR=0x%04x FN=%04x\n",
 625                         rdata, (rdata & ADMHC_SFN_FRT) ? "FRT " : "",
 626                         (rdata >> ADMHC_SFN_FR_SHIFT) & ADMHC_SFN_FR_MASK,
 627                         rdata  & ADMHC_SFN_FN_MASK);
 628         size -= temp;
 629         next += temp;
 630
 631         /* TODO: use predefined bitmask */
 632         rdata = admhc_readl(ahcd, &regs->lsthresh);
 633         temp = scnprintf(next, size, "lsthresh 0x%04x\n",
 634                         rdata & 0x3fff);
 635         size -= temp;
 636         next += temp;
 637
 638         temp = scnprintf(next, size, "hub poll timer: %s\n",
 639                         admhcd_to_hcd(ahcd)->poll_rh ? "ON" : "OFF");
 640         size -= temp;
 641         next += temp;
 642
 643         /* roothub */
 644         admhc_dump_roothub(ahcd, 1, &next, &size);
 645
 646 done:
 647         spin_unlock_irqrestore(&ahcd->lock, flags);
 648         return PAGE_SIZE - size;
 649 }
 650 static CLASS_DEVICE_ATTR(registers, S_IRUGO, show_registers, NULL);
 651
 652
 653 static inline void create_debug_files (struct admhcd *ahcd)
 654 {
 655         struct class_device *cldev = admhcd_to_hcd(ahcd)->self.class_dev;
 656         int retval;
 657
 658         retval = class_device_create_file(cldev, &class_device_attr_async);
 659         retval = class_device_create_file(cldev, &class_device_attr_periodic);
 660         retval = class_device_create_file(cldev, &class_device_attr_registers);
 661         admhc_dbg(ahcd, "created debug files\n");
 662 }
 663
 664 static inline void remove_debug_files (struct admhcd *ahcd)
 665 {
 666         struct class_device *cldev = admhcd_to_hcd(ahcd)->self.class_dev;
 667
 668         class_device_remove_file(cldev, &class_device_attr_async);
 669         class_device_remove_file(cldev, &class_device_attr_periodic);
 670         class_device_remove_file(cldev, &class_device_attr_registers);
 671 }
 672
 673 #endif
 674
 675 /*-------------------------------------------------------------------------*/
 676