imx21-dbg.c

Go to the documentation of this file.

/*
 * Copyright (c) 2009 by Martin Fuzzey
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/* this file is part of imx21-hcd.c */

#ifndef DEBUG

static inline void create_debug_files(struct imx21 *imx21) { }
static inline void remove_debug_files(struct imx21 *imx21) { }
static inline void debug_urb_submitted(struct imx21 *imx21, struct urb *urb) {}
static inline void debug_urb_completed(struct imx21 *imx21, struct urb *urb,
    int status) {}
static inline void debug_urb_unlinked(struct imx21 *imx21, struct urb *urb) {}
static inline void debug_urb_queued_for_etd(struct imx21 *imx21,
    struct urb *urb) {}
static inline void debug_urb_queued_for_dmem(struct imx21 *imx21,
    struct urb *urb) {}
static inline void debug_etd_allocated(struct imx21 *imx21) {}
static inline void debug_etd_freed(struct imx21 *imx21) {}
static inline void debug_dmem_allocated(struct imx21 *imx21, int size) {}
static inline void debug_dmem_freed(struct imx21 *imx21, int size) {}
static inline void debug_isoc_submitted(struct imx21 *imx21,
    int frame, struct td *td) {}
static inline void debug_isoc_completed(struct imx21 *imx21,
    int frame, struct td *td, int cc, int len) {}

#else

#include <linux/debugfs.h>
#include <linux/seq_file.h>

static const char *dir_labels[] = {
    "TD 0",
    "OUT",
    "IN",
    "TD 1"
};

static const char *speed_labels[] = {
    "Full",
    "Low"
};

static const char *format_labels[] = {
    "Control",
    "ISO",
    "Bulk",
    "Interrupt"
};

static inline struct debug_stats *stats_for_urb(struct imx21 *imx21,
    struct urb *urb)
{
    return usb_pipeisoc(urb->pipe) ?
        &imx21->isoc_stats : &imx21->nonisoc_stats;
}

static void debug_urb_submitted(struct imx21 *imx21, struct urb *urb)
{
    stats_for_urb(imx21, urb)->submitted++;
}

static void debug_urb_completed(struct imx21 *imx21, struct urb *urb, int st)
{
    if (st)
        stats_for_urb(imx21, urb)->completed_failed++;
    else
        stats_for_urb(imx21, urb)->completed_ok++;
}

static void debug_urb_unlinked(struct imx21 *imx21, struct urb *urb)
{
    stats_for_urb(imx21, urb)->unlinked++;
}

static void debug_urb_queued_for_etd(struct imx21 *imx21, struct urb *urb)
{
    stats_for_urb(imx21, urb)->queue_etd++;
}

static void debug_urb_queued_for_dmem(struct imx21 *imx21, struct urb *urb)
{
    stats_for_urb(imx21, urb)->queue_dmem++;
}

static inline void debug_etd_allocated(struct imx21 *imx21)
{
    imx21->etd_usage.maximum = max(
            ++(imx21->etd_usage.value),
            imx21->etd_usage.maximum);
}

static inline void debug_etd_freed(struct imx21 *imx21)
{
    imx21->etd_usage.value--;
}

static inline void debug_dmem_allocated(struct imx21 *imx21, int size)
{
    imx21->dmem_usage.value += size;
    imx21->dmem_usage.maximum = max(
            imx21->dmem_usage.value,
            imx21->dmem_usage.maximum);
}

static inline void debug_dmem_freed(struct imx21 *imx21, int size)
{
    imx21->dmem_usage.value -= size;
}


static void debug_isoc_submitted(struct imx21 *imx21,
    int frame, struct td *td)
{
    struct debug_isoc_trace *trace = &imx21->isoc_trace[
        imx21->isoc_trace_index++];

    imx21->isoc_trace_index %= ARRAY_SIZE(imx21->isoc_trace);
    trace->schedule_frame = td->frame;
    trace->submit_frame = frame;
    trace->request_len = td->len;
    trace->td = td;
}

static inline void debug_isoc_completed(struct imx21 *imx21,
    int frame, struct td *td, int cc, int len)
{
    struct debug_isoc_trace *trace, *trace_failed;
    int i;
    int found = 0;

    trace = imx21->isoc_trace;
    for (i = 0; i < ARRAY_SIZE(imx21->isoc_trace); i++, trace++) {
        if (trace->td == td) {
            trace->done_frame = frame;
            trace->done_len = len;
            trace->cc = cc;
            trace->td = NULL;
            found = 1;
            break;
        }
    }

    if (found && cc) {
        trace_failed = &imx21->isoc_trace_failed[
                    imx21->isoc_trace_index_failed++];

        imx21->isoc_trace_index_failed %= ARRAY_SIZE(
                        imx21->isoc_trace_failed);
        *trace_failed = *trace;
    }
}


static char *format_ep(struct usb_host_endpoint *ep, char *buf, int bufsize)
{
    if (ep)
        snprintf(buf, bufsize, "ep_%02x (type:%02X kaddr:%p)",
            ep->desc.bEndpointAddress,
            usb_endpoint_type(&ep->desc),
            ep);
    else
        snprintf(buf, bufsize, "none");
    return buf;
}

static char *format_etd_dword0(u32 value, char *buf, int bufsize)
{
    snprintf(buf, bufsize,
        "addr=%d ep=%d dir=%s speed=%s format=%s halted=%d",
        value & 0x7F,
        (value >> DW0_ENDPNT) & 0x0F,
        dir_labels[(value >> DW0_DIRECT) & 0x03],
        speed_labels[(value >> DW0_SPEED) & 0x01],
        format_labels[(value >> DW0_FORMAT) & 0x03],
        (value >> DW0_HALTED) & 0x01);
    return buf;
}

static int debug_status_show(struct seq_file *s, void *v)
{
    struct imx21 *imx21 = s->private;
    int etds_allocated = 0;
    int etds_sw_busy = 0;
    int etds_hw_busy = 0;
    int dmem_blocks = 0;
    int queued_for_etd = 0;
    int queued_for_dmem = 0;
    unsigned int dmem_bytes = 0;
    int i;
    struct etd_priv *etd;
    u32 etd_enable_mask;
    unsigned long flags;
    struct imx21_dmem_area *dmem;
    struct ep_priv *ep_priv;

    spin_lock_irqsave(&imx21->lock, flags);

    etd_enable_mask = readl(imx21->regs + USBH_ETDENSET);
    for (i = 0, etd = imx21->etd; i < USB_NUM_ETD; i++, etd++) {
        if (etd->alloc)
            etds_allocated++;
        if (etd->urb)
            etds_sw_busy++;
        if (etd_enable_mask & (1<<i))
            etds_hw_busy++;
    }

    list_for_each_entry(dmem, &imx21->dmem_list, list) {
        dmem_bytes += dmem->size;
        dmem_blocks++;
    }

    list_for_each_entry(ep_priv, &imx21->queue_for_etd, queue)
        queued_for_etd++;

    list_for_each_entry(etd, &imx21->queue_for_dmem, queue)
        queued_for_dmem++;

    spin_unlock_irqrestore(&imx21->lock, flags);

    seq_printf(s,
        "Frame: %d\n"
        "ETDs allocated: %d/%d (max=%d)\n"
        "ETDs in use sw: %d\n"
        "ETDs in use hw: %d\n"
        "DMEM allocated: %d/%d (max=%d)\n"
        "DMEM blocks: %d\n"
        "Queued waiting for ETD: %d\n"
        "Queued waiting for DMEM: %d\n",
        readl(imx21->regs + USBH_FRMNUB) & 0xFFFF,
        etds_allocated, USB_NUM_ETD, imx21->etd_usage.maximum,
        etds_sw_busy,
        etds_hw_busy,
        dmem_bytes, DMEM_SIZE, imx21->dmem_usage.maximum,
        dmem_blocks,
        queued_for_etd,
        queued_for_dmem);

    return 0;
}

static int debug_dmem_show(struct seq_file *s, void *v)
{
    struct imx21 *imx21 = s->private;
    struct imx21_dmem_area *dmem;
    unsigned long flags;
    char ep_text[40];

    spin_lock_irqsave(&imx21->lock, flags);

    list_for_each_entry(dmem, &imx21->dmem_list, list)
        seq_printf(s,
            "%04X: size=0x%X "
            "ep=%s\n",
            dmem->offset, dmem->size,
            format_ep(dmem->ep, ep_text, sizeof(ep_text)));

    spin_unlock_irqrestore(&imx21->lock, flags);

    return 0;
}

static int debug_etd_show(struct seq_file *s, void *v)
{
    struct imx21 *imx21 = s->private;
    struct etd_priv *etd;
    char buf[60];
    u32 dword;
    int i, j;
    unsigned long flags;

    spin_lock_irqsave(&imx21->lock, flags);

    for (i = 0, etd = imx21->etd; i < USB_NUM_ETD; i++, etd++) {
        int state = -1;
        struct urb_priv *urb_priv;
        if (etd->urb) {
            urb_priv = etd->urb->hcpriv;
            if (urb_priv)
                state = urb_priv->state;
        }

        seq_printf(s,
            "etd_num: %d\n"
            "ep: %s\n"
            "alloc: %d\n"
            "len: %d\n"
            "busy sw: %d\n"
            "busy hw: %d\n"
            "urb state: %d\n"
            "current urb: %p\n",

            i,
            format_ep(etd->ep, buf, sizeof(buf)),
            etd->alloc,
            etd->len,
            etd->urb != NULL,
            (readl(imx21->regs + USBH_ETDENSET) & (1 << i)) > 0,
            state,
            etd->urb);

        for (j = 0; j < 4; j++) {
            dword = etd_readl(imx21, i, j);
            switch (j) {
            case 0:
                format_etd_dword0(dword, buf, sizeof(buf));
                break;
            case 2:
                snprintf(buf, sizeof(buf),
                    "cc=0X%02X", dword >> DW2_COMPCODE);
                break;
            default:
                *buf = 0;
                break;
            }
            seq_printf(s,
                "dword %d: submitted=%08X cur=%08X [%s]\n",
                j,
                etd->submitted_dwords[j],
                dword,
                buf);
        }
        seq_printf(s, "\n");
    }

    spin_unlock_irqrestore(&imx21->lock, flags);

    return 0;
}

static void debug_statistics_show_one(struct seq_file *s,
    const char *name, struct debug_stats *stats)
{
    seq_printf(s, "%s:\n"
        "submitted URBs: %lu\n"
        "completed OK: %lu\n"
        "completed failed: %lu\n"
        "unlinked: %lu\n"
        "queued for ETD: %lu\n"
        "queued for DMEM: %lu\n\n",
        name,
        stats->submitted,
        stats->completed_ok,
        stats->completed_failed,
        stats->unlinked,
        stats->queue_etd,
        stats->queue_dmem);
}

static int debug_statistics_show(struct seq_file *s, void *v)
{
    struct imx21 *imx21 = s->private;
    unsigned long flags;

    spin_lock_irqsave(&imx21->lock, flags);

    debug_statistics_show_one(s, "nonisoc", &imx21->nonisoc_stats);
    debug_statistics_show_one(s, "isoc", &imx21->isoc_stats);
    seq_printf(s, "unblock kludge triggers: %lu\n", imx21->debug_unblocks);
    spin_unlock_irqrestore(&imx21->lock, flags);

    return 0;
}

static void debug_isoc_show_one(struct seq_file *s,
    const char *name, int index,    struct debug_isoc_trace *trace)
{
    seq_printf(s, "%s %d:\n"
        "cc=0X%02X\n"
        "scheduled frame %d (%d)\n"
        "submitted frame %d (%d)\n"
        "completed frame %d (%d)\n"
        "requested length=%d\n"
        "completed length=%d\n\n",
        name, index,
        trace->cc,
        trace->schedule_frame, trace->schedule_frame & 0xFFFF,
        trace->submit_frame, trace->submit_frame & 0xFFFF,
        trace->done_frame, trace->done_frame & 0xFFFF,
        trace->request_len,
        trace->done_len);
}

static int debug_isoc_show(struct seq_file *s, void *v)
{
    struct imx21 *imx21 = s->private;
    struct debug_isoc_trace *trace;
    unsigned long flags;
    int i;

    spin_lock_irqsave(&imx21->lock, flags);

    trace = imx21->isoc_trace_failed;
    for (i = 0; i < ARRAY_SIZE(imx21->isoc_trace_failed); i++, trace++)
        debug_isoc_show_one(s, "isoc failed", i, trace);

    trace = imx21->isoc_trace;
    for (i = 0; i < ARRAY_SIZE(imx21->isoc_trace); i++, trace++)
        debug_isoc_show_one(s, "isoc", i, trace);

    spin_unlock_irqrestore(&imx21->lock, flags);

    return 0;
}

static int debug_status_open(struct inode *inode, struct file *file)
{
    return single_open(file, debug_status_show, inode->i_private);
}

static int debug_dmem_open(struct inode *inode, struct file *file)
{
    return single_open(file, debug_dmem_show, inode->i_private);
}

static int debug_etd_open(struct inode *inode, struct file *file)
{
    return single_open(file, debug_etd_show, inode->i_private);
}

static int debug_statistics_open(struct inode *inode, struct file *file)
{
    return single_open(file, debug_statistics_show, inode->i_private);
}

static int debug_isoc_open(struct inode *inode, struct file *file)
{
    return single_open(file, debug_isoc_show, inode->i_private);
}

static const struct file_operations debug_status_fops = {
    .open = debug_status_open,
    .read = seq_read,
    .llseek = seq_lseek,
    .release = single_release,
};

static const struct file_operations debug_dmem_fops = {
    .open = debug_dmem_open,
    .read = seq_read,
    .llseek = seq_lseek,
    .release = single_release,
};

static const struct file_operations debug_etd_fops = {
    .open = debug_etd_open,
    .read = seq_read,
    .llseek = seq_lseek,
    .release = single_release,
};

static const struct file_operations debug_statistics_fops = {
    .open = debug_statistics_open,
    .read = seq_read,
    .llseek = seq_lseek,
    .release = single_release,
};

static const struct file_operations debug_isoc_fops = {
    .open = debug_isoc_open,
    .read = seq_read,
    .llseek = seq_lseek,
    .release = single_release,
};

static void create_debug_files(struct imx21 *imx21)
{
    imx21->debug_root = debugfs_create_dir(dev_name(imx21->dev), NULL);
    if (!imx21->debug_root)
        goto failed_create_rootdir;

    if (!debugfs_create_file("status", S_IRUGO,
            imx21->debug_root, imx21, &debug_status_fops))
        goto failed_create;

    if (!debugfs_create_file("dmem", S_IRUGO,
            imx21->debug_root, imx21, &debug_dmem_fops))
        goto failed_create;

    if (!debugfs_create_file("etd", S_IRUGO,
            imx21->debug_root, imx21, &debug_etd_fops))
        goto failed_create;

    if (!debugfs_create_file("statistics", S_IRUGO,
            imx21->debug_root, imx21, &debug_statistics_fops))
        goto failed_create;

    if (!debugfs_create_file("isoc", S_IRUGO,
            imx21->debug_root, imx21, &debug_isoc_fops))
        goto failed_create;

    return;

failed_create:
    debugfs_remove_recursive(imx21->debug_root);

failed_create_rootdir:
    imx21->debug_root = NULL;
}


static void remove_debug_files(struct imx21 *imx21)
{
    if (imx21->debug_root) {
        debugfs_remove_recursive(imx21->debug_root);
        imx21->debug_root = NULL;
    }
}

#endif