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