Subversion Repositories shark

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
846 giacomo 1
/*
2
 * UHCI-specific debugging code. Invaluable when something
3
 * goes wrong, but don't get in my face.
4
 *
5
 * Kernel visible pointers are surrounded in []'s and bus
6
 * visible pointers are surrounded in ()'s
7
 *
8
 * (C) Copyright 1999 Linus Torvalds
9
 * (C) Copyright 1999-2001 Johannes Erdfelt
10
 */
11
 
12
#include <linuxcomp.h>
13
 
14
#include <linux/config.h>
15
#include <linux/kernel.h>
16
#include <linux/proc_fs.h>
17
#include <linux/smp_lock.h>
18
#include <asm/io.h>
19
 
20
#include "uhci-hcd.h"
21
 
22
/* Handle REALLY large printk's so we don't overflow buffers */
23
static inline void lprintk(char *buf)
24
{
25
        char *p;
26
 
27
        /* Just write one line at a time */
28
        while (buf) {
29
                p = strchr(buf, '\n');
30
                if (p)
31
                        *p = 0;
32
                printk("%s\n", buf);
33
                buf = p;
34
                if (buf)
35
                        buf++;
36
        }
37
}
38
 
39
static inline int uhci_is_skeleton_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
40
{
41
        int i;
42
 
43
        for (i = 0; i < UHCI_NUM_SKELQH; i++)
44
                if (qh == uhci->skelqh[i])
45
                        return 1;
46
 
47
        return 0;
48
}
49
 
50
static int uhci_show_td(struct uhci_td *td, char *buf, int len, int space)
51
{
52
        char *out = buf;
53
        char *spid;
54
        u32 status, token;
55
 
56
        /* Try to make sure there's enough memory */
57
        if (len < 160)
58
                return 0;
59
 
60
        status = td_status(td);
61
        out += sprintf26(out, "%*s[%p] link (%08x) ", space, "", td, le32_to_cpu(td->link));
62
        out += sprintf26(out, "e%d %s%s%s%s%s%s%s%s%s%sLength=%x ",
63
                ((status >> 27) & 3),
64
                (status & TD_CTRL_SPD) ?      "SPD " : "",
65
                (status & TD_CTRL_LS) ?       "LS " : "",
66
                (status & TD_CTRL_IOC) ?      "IOC " : "",
67
                (status & TD_CTRL_ACTIVE) ?   "Active " : "",
68
                (status & TD_CTRL_STALLED) ?  "Stalled " : "",
69
                (status & TD_CTRL_DBUFERR) ?  "DataBufErr " : "",
70
                (status & TD_CTRL_BABBLE) ?   "Babble " : "",
71
                (status & TD_CTRL_NAK) ?      "NAK " : "",
72
                (status & TD_CTRL_CRCTIMEO) ? "CRC/Timeo " : "",
73
                (status & TD_CTRL_BITSTUFF) ? "BitStuff " : "",
74
                status & 0x7ff);
75
 
76
        token = td_token(td);
77
        switch (uhci_packetid(token)) {
78
                case USB_PID_SETUP:
79
                        spid = "SETUP";
80
                        break;
81
                case USB_PID_OUT:
82
                        spid = "OUT";
83
                        break;
84
                case USB_PID_IN:
85
                        spid = "IN";
86
                        break;
87
                default:
88
                        spid = "?";
89
                        break;
90
        }
91
 
92
        out += sprintf26(out, "MaxLen=%x DT%d EndPt=%x Dev=%x, PID=%x(%s) ",
93
                token >> 21,
94
                ((token >> 19) & 1),
95
                (token >> 15) & 15,
96
                (token >> 8) & 127,
97
                (token & 0xff),
98
                spid);
99
        out += sprintf26(out, "(buf=%08x)\n", le32_to_cpu(td->buffer));
100
 
101
        return out - buf;
102
}
103
 
104
static int uhci_show_qh(struct uhci_qh *qh, char *buf, int len, int space)
105
{
106
        char *out = buf;
107
        struct urb_priv *urbp;
108
        struct list_head *head, *tmp;
109
        struct uhci_td *td;
110
        int i = 0, checked = 0, prevactive = 0;
111
 
112
        /* Try to make sure there's enough memory */
113
        if (len < 80 * 6)
114
                return 0;
115
 
116
        out += sprintf26(out, "%*s[%p] link (%08x) element (%08x)\n", space, "",
117
                        qh, le32_to_cpu(qh->link), le32_to_cpu(qh->element));
118
 
119
        if (qh->element & UHCI_PTR_QH)
120
                out += sprintf26(out, "%*s  Element points to QH (bug?)\n", space, "");
121
 
122
        if (qh->element & UHCI_PTR_DEPTH)
123
                out += sprintf26(out, "%*s  Depth traverse\n", space, "");
124
 
125
        if (qh->element & cpu_to_le32(8))
126
                out += sprintf26(out, "%*s  Bit 3 set (bug?)\n", space, "");
127
 
128
        if (!(qh->element & ~(UHCI_PTR_QH | UHCI_PTR_DEPTH)))
129
                out += sprintf26(out, "%*s  Element is NULL (bug?)\n", space, "");
130
 
131
        if (!qh->urbp) {
132
                out += sprintf26(out, "%*s  urbp == NULL\n", space, "");
133
                goto out;
134
        }
135
 
136
        urbp = qh->urbp;
137
 
138
        head = &urbp->td_list;
139
        tmp = head->next;
140
 
141
        td = list_entry(tmp, struct uhci_td, list);
142
 
143
        if (cpu_to_le32(td->dma_handle) != (qh->element & ~UHCI_PTR_BITS))
144
                out += sprintf26(out, "%*s Element != First TD\n", space, "");
145
 
146
        while (tmp != head) {
147
                struct uhci_td *td = list_entry(tmp, struct uhci_td, list);
148
 
149
                tmp = tmp->next;
150
 
151
                out += sprintf26(out, "%*s%d: ", space + 2, "", i++);
152
                out += uhci_show_td(td, out, len - (out - buf), 0);
153
 
154
                if (i > 10 && !checked && prevactive && tmp != head &&
155
                    debug <= 2) {
156
                        struct list_head *ntmp = tmp;
157
                        struct uhci_td *ntd = td;
158
                        int active = 1, ni = i;
159
 
160
                        checked = 1;
161
 
162
                        while (ntmp != head && ntmp->next != head && active) {
163
                                ntd = list_entry(ntmp, struct uhci_td, list);
164
 
165
                                ntmp = ntmp->next;
166
 
167
                                active = td_status(ntd) & TD_CTRL_ACTIVE;
168
 
169
                                ni++;
170
                        }
171
 
172
                        if (active && ni > i) {
173
                                out += sprintf26(out, "%*s[skipped %d active TD's]\n", space, "", ni - i);
174
                                tmp = ntmp;
175
                                td = ntd;
176
                                i = ni;
177
                        }
178
                }
179
 
180
                prevactive = td_status(td) & TD_CTRL_ACTIVE;
181
        }
182
 
183
        if (list_empty(&urbp->queue_list) || urbp->queued)
184
                goto out;
185
 
186
        out += sprintf26(out, "%*sQueued QH's:\n", -space, "--");
187
 
188
        head = &urbp->queue_list;
189
        tmp = head->next;
190
 
191
        while (tmp != head) {
192
                struct urb_priv *nurbp = list_entry(tmp, struct urb_priv,
193
                                                queue_list);
194
                tmp = tmp->next;
195
 
196
                out += uhci_show_qh(nurbp->qh, out, len - (out - buf), space);
197
        }
198
 
199
out:
200
        return out - buf;
201
}
202
 
203
#define show_frame_num()        \
204
        if (!shown) {           \
205
          shown = 1;            \
206
          out += sprintf26(out, "- Frame %d\n", i); \
207
        }
208
 
209
#ifdef CONFIG_PROC_FS
210
static const char *qh_names[] = {
211
  "skel_int128_qh", "skel_int64_qh",
212
  "skel_int32_qh", "skel_int16_qh",
213
  "skel_int8_qh", "skel_int4_qh",
214
  "skel_int2_qh", "skel_int1_qh",
215
  "skel_ls_control_qh", "skel_hs_control_qh",
216
  "skel_bulk_qh", "skel_term_qh"
217
};
218
 
219
#define show_qh_name()          \
220
        if (!shown) {           \
221
          shown = 1;            \
222
          out += sprintf26(out, "- %s\n", qh_names[i]); \
223
        }
224
 
225
static int uhci_show_sc(int port, unsigned short status, char *buf, int len)
226
{
227
        char *out = buf;
228
 
229
        /* Try to make sure there's enough memory */
230
        if (len < 80)
231
                return 0;
232
 
233
        out += sprintf26(out, "  stat%d     =     %04x   %s%s%s%s%s%s%s%s\n",
234
                port,
235
                status,
236
                (status & USBPORTSC_SUSP) ? "PortSuspend " : "",
237
                (status & USBPORTSC_PR) ?   "PortReset " : "",
238
                (status & USBPORTSC_LSDA) ? "LowSpeed " : "",
239
                (status & USBPORTSC_RD) ?   "ResumeDetect " : "",
240
                (status & USBPORTSC_PEC) ?  "EnableChange " : "",
241
                (status & USBPORTSC_PE) ?   "PortEnabled " : "",
242
                (status & USBPORTSC_CSC) ?  "ConnectChange " : "",
243
                (status & USBPORTSC_CCS) ?  "PortConnected " : "");
244
 
245
        return out - buf;
246
}
247
 
248
static int uhci_show_status(struct uhci_hcd *uhci, char *buf, int len)
249
{
250
        char *out = buf;
251
        unsigned int io_addr = uhci->io_addr;
252
        unsigned short usbcmd, usbstat, usbint, usbfrnum;
253
        unsigned int flbaseadd;
254
        unsigned char sof;
255
        unsigned short portsc1, portsc2;
256
 
257
        /* Try to make sure there's enough memory */
258
        if (len < 80 * 6)
259
                return 0;
260
 
261
        usbcmd    = inw(io_addr + 0);
262
        usbstat   = inw(io_addr + 2);
263
        usbint    = inw(io_addr + 4);
264
        usbfrnum  = inw(io_addr + 6);
265
        flbaseadd = inl(io_addr + 8);
266
        sof       = inb(io_addr + 12);
267
        portsc1   = inw(io_addr + 16);
268
        portsc2   = inw(io_addr + 18);
269
 
270
        out += sprintf26(out, "  usbcmd    =     %04x   %s%s%s%s%s%s%s%s\n",
271
                usbcmd,
272
                (usbcmd & USBCMD_MAXP) ?    "Maxp64 " : "Maxp32 ",
273
                (usbcmd & USBCMD_CF) ?      "CF " : "",
274
                (usbcmd & USBCMD_SWDBG) ?   "SWDBG " : "",
275
                (usbcmd & USBCMD_FGR) ?     "FGR " : "",
276
                (usbcmd & USBCMD_EGSM) ?    "EGSM " : "",
277
                (usbcmd & USBCMD_GRESET) ?  "GRESET " : "",
278
                (usbcmd & USBCMD_HCRESET) ? "HCRESET " : "",
279
                (usbcmd & USBCMD_RS) ?      "RS " : "");
280
 
281
        out += sprintf26(out, "  usbstat   =     %04x   %s%s%s%s%s%s\n",
282
                usbstat,
283
                (usbstat & USBSTS_HCH) ?    "HCHalted " : "",
284
                (usbstat & USBSTS_HCPE) ?   "HostControllerProcessError " : "",
285
                (usbstat & USBSTS_HSE) ?    "HostSystemError " : "",
286
                (usbstat & USBSTS_RD) ?     "ResumeDetect " : "",
287
                (usbstat & USBSTS_ERROR) ?  "USBError " : "",
288
                (usbstat & USBSTS_USBINT) ? "USBINT " : "");
289
 
290
        out += sprintf26(out, "  usbint    =     %04x\n", usbint);
291
        out += sprintf26(out, "  usbfrnum  =   (%d)%03x\n", (usbfrnum >> 10) & 1,
292
                0xfff & (4*(unsigned int)usbfrnum));
293
        out += sprintf26(out, "  flbaseadd = %08x\n", flbaseadd);
294
        out += sprintf26(out, "  sof       =       %02x\n", sof);
295
        out += uhci_show_sc(1, portsc1, out, len - (out - buf));
296
        out += uhci_show_sc(2, portsc2, out, len - (out - buf));
297
 
298
        return out - buf;
299
}
300
 
301
static int uhci_show_urbp(struct uhci_hcd *uhci, struct urb_priv *urbp, char *buf, int len)
302
{
303
        struct list_head *tmp;
304
        char *out = buf;
305
        int count = 0;
306
 
307
        if (len < 200)
308
                return 0;
309
 
310
        out += sprintf26(out, "urb_priv [%p] ", urbp);
311
        out += sprintf26(out, "urb [%p] ", urbp->urb);
312
        out += sprintf26(out, "qh [%p] ", urbp->qh);
313
        out += sprintf26(out, "Dev=%d ", usb_pipedevice(urbp->urb->pipe));
314
        out += sprintf26(out, "EP=%x(%s) ", usb_pipeendpoint(urbp->urb->pipe), (usb_pipein(urbp->urb->pipe) ? "IN" : "OUT"));
315
 
316
        switch (usb_pipetype(urbp->urb->pipe)) {
317
        case PIPE_ISOCHRONOUS: out += sprintf26(out, "ISO "); break;
318
        case PIPE_INTERRUPT: out += sprintf26(out, "INT "); break;
319
        case PIPE_BULK: out += sprintf26(out, "BLK "); break;
320
        case PIPE_CONTROL: out += sprintf26(out, "CTL "); break;
321
        }
322
 
323
        out += sprintf26(out, "%s", (urbp->fsbr ? "FSBR " : ""));
324
        out += sprintf26(out, "%s", (urbp->fsbr_timeout ? "FSBR_TO " : ""));
325
 
326
        if (urbp->status != -EINPROGRESS)
327
                out += sprintf26(out, "Status=%d ", urbp->status);
328
        //out += sprintf26(out, "Inserttime=%lx ",urbp->inserttime);
329
        //out += sprintf26(out, "FSBRtime=%lx ",urbp->fsbrtime);
330
 
331
        spin_lock(&urbp->urb->lock);
332
        count = 0;
333
        list_for_each(tmp, &urbp->td_list)
334
                count++;
335
        spin_unlock(&urbp->urb->lock);
336
        out += sprintf26(out, "TDs=%d ",count);
337
 
338
        if (urbp->queued)
339
                out += sprintf26(out, "queued\n");
340
        else {
341
                spin_lock(&uhci->frame_list_lock);
342
                count = 0;
343
                list_for_each(tmp, &urbp->queue_list)
344
                        count++;
345
                spin_unlock(&uhci->frame_list_lock);
346
                out += sprintf26(out, "queued URBs=%d\n", count);
347
        }
348
 
349
        return out - buf;
350
}
351
 
352
static int uhci_show_lists(struct uhci_hcd *uhci, char *buf, int len)
353
{
354
        char *out = buf;
355
        unsigned long flags;
356
        struct list_head *head, *tmp;
357
        int count;
358
 
359
        out += sprintf26(out, "Main list URBs:");
360
        spin_lock_irqsave(&uhci->urb_list_lock, flags);
361
        if (list_empty(&uhci->urb_list))
362
                out += sprintf26(out, " Empty\n");
363
        else {
364
                out += sprintf26(out, "\n");
365
                count = 0;
366
                head = &uhci->urb_list;
367
                tmp = head->next;
368
                while (tmp != head) {
369
                        struct urb_priv *urbp = list_entry(tmp, struct urb_priv, urb_list);
370
 
371
                        out += sprintf26(out, "  %d: ", ++count);
372
                        out += uhci_show_urbp(uhci, urbp, out, len - (out - buf));
373
                        tmp = tmp->next;
374
                }
375
        }
376
        spin_unlock_irqrestore(&uhci->urb_list_lock, flags);
377
 
378
        out += sprintf26(out, "Remove list URBs:");
379
        spin_lock_irqsave(&uhci->urb_remove_list_lock, flags);
380
        if (list_empty(&uhci->urb_remove_list))
381
                out += sprintf26(out, " Empty\n");
382
        else {
383
                out += sprintf26(out, "\n");
384
                count = 0;
385
                head = &uhci->urb_remove_list;
386
                tmp = head->next;
387
                while (tmp != head) {
388
                        struct urb_priv *urbp = list_entry(tmp, struct urb_priv, urb_list);
389
 
390
                        out += sprintf26(out, "  %d: ", ++count);
391
                        out += uhci_show_urbp(uhci, urbp, out, len - (out - buf));
392
                        tmp = tmp->next;
393
                }
394
        }
395
        spin_unlock_irqrestore(&uhci->urb_remove_list_lock, flags);
396
 
397
        out += sprintf26(out, "Complete list URBs:");
398
        spin_lock_irqsave(&uhci->complete_list_lock, flags);
399
        if (list_empty(&uhci->complete_list))
400
                out += sprintf26(out, " Empty\n");
401
        else {
402
                out += sprintf26(out, "\n");
403
                count = 0;
404
                head = &uhci->complete_list;
405
                tmp = head->next;
406
                while (tmp != head) {
407
                        struct urb_priv *urbp = list_entry(tmp, struct urb_priv, complete_list);
408
 
409
                        out += sprintf26(out, "  %d: ", ++count);
410
                        out += uhci_show_urbp(uhci, urbp, out, len - (out - buf));
411
                        tmp = tmp->next;
412
                }
413
        }
414
        spin_unlock_irqrestore(&uhci->complete_list_lock, flags);
415
 
416
        return out - buf;
417
}
418
 
419
static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len)
420
{
421
        unsigned long flags;
422
        char *out = buf;
423
        int i;
424
        struct uhci_qh *qh;
425
        struct uhci_td *td;
426
        struct list_head *tmp, *head;
427
 
428
        spin_lock_irqsave(&uhci->frame_list_lock, flags);
429
 
430
        out += sprintf26(out, "HC status\n");
431
        out += uhci_show_status(uhci, out, len - (out - buf));
432
 
433
        out += sprintf26(out, "Frame List\n");
434
        for (i = 0; i < UHCI_NUMFRAMES; ++i) {
435
                int shown = 0;
436
                td = uhci->fl->frame_cpu[i];
437
                if (!td)
438
                        continue;
439
 
440
                if (td->dma_handle != (dma_addr_t)uhci->fl->frame[i]) {
441
                        show_frame_num();
442
                        out += sprintf26(out, "    frame list does not match td->dma_handle!\n");
443
                }
444
                show_frame_num();
445
 
446
                head = &td->fl_list;
447
                tmp = head;
448
                do {
449
                        td = list_entry(tmp, struct uhci_td, fl_list);
450
                        tmp = tmp->next;
451
                        out += uhci_show_td(td, out, len - (out - buf), 4);
452
                } while (tmp != head);
453
        }
454
 
455
        out += sprintf26(out, "Skeleton QH's\n");
456
 
457
        for (i = 0; i < UHCI_NUM_SKELQH; ++i) {
458
                int shown = 0;
459
 
460
                qh = uhci->skelqh[i];
461
 
462
                if (debug > 1) {
463
                        show_qh_name();
464
                        out += uhci_show_qh(qh, out, len - (out - buf), 4);
465
                }
466
 
467
                /* Last QH is the Terminating QH, it's different */
468
                if (i == UHCI_NUM_SKELQH - 1) {
469
                        if (qh->link != UHCI_PTR_TERM)
470
                                out += sprintf26(out, "    bandwidth reclamation on!\n");
471
 
472
                        if (qh->element != cpu_to_le32(uhci->term_td->dma_handle))
473
                                out += sprintf26(out, "    skel_term_qh element is not set to term_td!\n");
474
 
475
                        continue;
476
                }
477
 
478
                if (list_empty(&qh->list)) {
479
                        if (i < UHCI_NUM_SKELQH - 1) {
480
                                if (qh->link !=
481
                                    (cpu_to_le32(uhci->skelqh[i + 1]->dma_handle) | UHCI_PTR_QH)) {
482
                                        show_qh_name();
483
                                        out += sprintf26(out, "    skeleton QH not linked to next skeleton QH!\n");
484
                                }
485
                        }
486
 
487
                        continue;
488
                }
489
 
490
                show_qh_name();
491
 
492
                head = &qh->list;
493
                tmp = head->next;
494
 
495
                while (tmp != head) {
496
                        qh = list_entry(tmp, struct uhci_qh, list);
497
 
498
                        tmp = tmp->next;
499
 
500
                        out += uhci_show_qh(qh, out, len - (out - buf), 4);
501
                }
502
 
503
                if (i < UHCI_NUM_SKELQH - 1) {
504
                        if (qh->link !=
505
                            (cpu_to_le32(uhci->skelqh[i + 1]->dma_handle) | UHCI_PTR_QH))
506
                                out += sprintf26(out, "    last QH not linked to next skeleton!\n");
507
                }
508
        }
509
 
510
        spin_unlock_irqrestore(&uhci->frame_list_lock, flags);
511
 
512
        if (debug > 2)
513
                out += uhci_show_lists(uhci, out, len - (out - buf));
514
 
515
        return out - buf;
516
}
517
 
518
#define MAX_OUTPUT      (64 * 1024)
519
 
520
static struct proc_dir_entry *uhci_proc_root = NULL;
521
 
522
struct uhci_proc {
523
        int size;
524
        char *data;
525
        struct uhci_hcd *uhci;
526
};
527
 
528
static int uhci_proc_open(struct inode *inode, struct file *file)
529
{
530
        const struct proc_dir_entry *dp = PDE(inode);
531
        struct uhci_hcd *uhci = dp->data;
532
        struct uhci_proc *up;
533
        int ret = -ENOMEM;
534
 
535
        lock_kernel();
536
        up = kmalloc(sizeof(*up), GFP_KERNEL);
537
        if (!up)
538
                goto out;
539
 
540
        up->data = kmalloc(MAX_OUTPUT, GFP_KERNEL);
541
        if (!up->data) {
542
                kfree(up);
543
                goto out;
544
        }
545
 
546
        up->size = uhci_sprint_schedule(uhci, up->data, MAX_OUTPUT);
547
 
548
        file->private_data = up;
549
 
550
        ret = 0;
551
out:
552
        unlock_kernel();
553
        return ret;
554
}
555
 
556
static loff_t uhci_proc_lseek(struct file *file, loff_t off, int whence)
557
{
558
        struct uhci_proc *up;
559
        loff_t new = -1;
560
 
561
        lock_kernel();
562
        up = file->private_data;
563
 
564
        switch (whence) {
565
        case 0:
566
                new = off;
567
                break;
568
        case 1:
569
                new = file->f_pos + off;
570
                break;
571
        }
572
        if (new < 0 || new > up->size) {
573
                unlock_kernel();
574
                return -EINVAL;
575
        }
576
        unlock_kernel();
577
        return (file->f_pos = new);
578
}
579
 
580
static ssize_t uhci_proc_read(struct file *file, char *buf, size_t nbytes,
581
                        loff_t *ppos)
582
{
583
        struct uhci_proc *up = file->private_data;
584
        unsigned int pos;
585
        unsigned int size;
586
 
587
        pos = *ppos;
588
        size = up->size;
589
        if (pos >= size)
590
                return 0;
591
        if (nbytes >= size)
592
                nbytes = size;
593
        if (pos + nbytes > size)
594
                nbytes = size - pos;
595
 
596
        if (!access_ok(VERIFY_WRITE, buf, nbytes))
597
                return -EINVAL;
598
 
599
        if (copy_to_user(buf, up->data + pos, nbytes))
600
                return -EFAULT;
601
 
602
        *ppos += nbytes;
603
 
604
        return nbytes;
605
}
606
 
607
static int uhci_proc_release(struct inode *inode, struct file *file)
608
{
609
        struct uhci_proc *up = file->private_data;
610
 
611
        kfree(up->data);
612
        kfree(up);
613
 
614
        return 0;
615
}
616
 
617
static struct file_operations uhci_proc_operations = {
618
        .open =         uhci_proc_open,
619
        .llseek =       uhci_proc_lseek,
620
        .read =         uhci_proc_read,
621
//      write:          uhci_proc_write,
622
        .release =      uhci_proc_release,
623
};
624
#endif
625