|
|
@@ -1,830 +0,0 @@
|
|
|
-/*
|
|
|
- * MUSB OTG driver debug support
|
|
|
- *
|
|
|
- * Copyright 2005 Mentor Graphics Corporation
|
|
|
- * Copyright (C) 2005-2006 by Texas Instruments
|
|
|
- * Copyright (C) 2006-2007 Nokia Corporation
|
|
|
- *
|
|
|
- * This program is free software; you can redistribute it and/or
|
|
|
- * modify it under the terms of the GNU General Public License
|
|
|
- * version 2 as published by the Free Software Foundation.
|
|
|
- *
|
|
|
- * 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., 51 Franklin St, Fifth Floor, Boston, MA
|
|
|
- * 02110-1301 USA
|
|
|
- *
|
|
|
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
|
|
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
|
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
|
|
|
- * NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
|
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
|
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
|
|
|
- * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
|
- * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
|
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
- *
|
|
|
- */
|
|
|
-
|
|
|
-#include <linux/kernel.h>
|
|
|
-#include <linux/proc_fs.h>
|
|
|
-#include <linux/seq_file.h>
|
|
|
-#include <linux/uaccess.h> /* FIXME remove procfs writes */
|
|
|
-#include <asm/arch/hardware.h>
|
|
|
-
|
|
|
-#include "musb_core.h"
|
|
|
-
|
|
|
-#include "davinci.h"
|
|
|
-
|
|
|
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
|
|
|
-
|
|
|
-static int dump_qh(struct musb_qh *qh, char *buf, unsigned max)
|
|
|
-{
|
|
|
- int count;
|
|
|
- int tmp;
|
|
|
- struct usb_host_endpoint *hep = qh->hep;
|
|
|
- struct urb *urb;
|
|
|
-
|
|
|
- count = snprintf(buf, max, " qh %p dev%d ep%d%s max%d\n",
|
|
|
- qh, qh->dev->devnum, qh->epnum,
|
|
|
- ({ char *s; switch (qh->type) {
|
|
|
- case USB_ENDPOINT_XFER_BULK:
|
|
|
- s = "-bulk"; break;
|
|
|
- case USB_ENDPOINT_XFER_INT:
|
|
|
- s = "-int"; break;
|
|
|
- case USB_ENDPOINT_XFER_CONTROL:
|
|
|
- s = ""; break;
|
|
|
- default:
|
|
|
- s = "iso"; break;
|
|
|
- }; s; }),
|
|
|
- qh->maxpacket);
|
|
|
- if (count <= 0)
|
|
|
- return 0;
|
|
|
- buf += count;
|
|
|
- max -= count;
|
|
|
-
|
|
|
- list_for_each_entry(urb, &hep->urb_list, urb_list) {
|
|
|
- tmp = snprintf(buf, max, "\t%s urb %p %d/%d\n",
|
|
|
- usb_pipein(urb->pipe) ? "in" : "out",
|
|
|
- urb, urb->actual_length,
|
|
|
- urb->transfer_buffer_length);
|
|
|
- if (tmp <= 0)
|
|
|
- break;
|
|
|
- tmp = min(tmp, (int)max);
|
|
|
- count += tmp;
|
|
|
- buf += tmp;
|
|
|
- max -= tmp;
|
|
|
- }
|
|
|
- return count;
|
|
|
-}
|
|
|
-
|
|
|
-static int
|
|
|
-dump_queue(struct list_head *q, char *buf, unsigned max)
|
|
|
-{
|
|
|
- int count = 0;
|
|
|
- struct musb_qh *qh;
|
|
|
-
|
|
|
- list_for_each_entry(qh, q, ring) {
|
|
|
- int tmp;
|
|
|
-
|
|
|
- tmp = dump_qh(qh, buf, max);
|
|
|
- if (tmp <= 0)
|
|
|
- break;
|
|
|
- tmp = min(tmp, (int)max);
|
|
|
- count += tmp;
|
|
|
- buf += tmp;
|
|
|
- max -= tmp;
|
|
|
- }
|
|
|
- return count;
|
|
|
-}
|
|
|
-
|
|
|
-#endif /* HCD */
|
|
|
-
|
|
|
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
|
|
|
-static int dump_ep(struct musb_ep *ep, char *buffer, unsigned max)
|
|
|
-{
|
|
|
- char *buf = buffer;
|
|
|
- int code = 0;
|
|
|
- void __iomem *regs = ep->hw_ep->regs;
|
|
|
- char *mode = "1buf";
|
|
|
-
|
|
|
- if (ep->is_in) {
|
|
|
- if (ep->hw_ep->tx_double_buffered)
|
|
|
- mode = "2buf";
|
|
|
- } else {
|
|
|
- if (ep->hw_ep->rx_double_buffered)
|
|
|
- mode = "2buf";
|
|
|
- }
|
|
|
-
|
|
|
- do {
|
|
|
- struct usb_request *req;
|
|
|
-
|
|
|
- code = snprintf(buf, max,
|
|
|
- "\n%s (hw%d): %s%s, csr %04x maxp %04x\n",
|
|
|
- ep->name, ep->current_epnum,
|
|
|
- mode, ep->dma ? " dma" : "",
|
|
|
- musb_readw(regs,
|
|
|
- (ep->is_in || !ep->current_epnum)
|
|
|
- ? MUSB_TXCSR
|
|
|
- : MUSB_RXCSR),
|
|
|
- musb_readw(regs, ep->is_in
|
|
|
- ? MUSB_TXMAXP
|
|
|
- : MUSB_RXMAXP)
|
|
|
- );
|
|
|
- if (code <= 0)
|
|
|
- break;
|
|
|
- code = min(code, (int) max);
|
|
|
- buf += code;
|
|
|
- max -= code;
|
|
|
-
|
|
|
- if (is_cppi_enabled() && ep->current_epnum) {
|
|
|
- unsigned cppi = ep->current_epnum - 1;
|
|
|
- void __iomem *base = ep->musb->ctrl_base;
|
|
|
- unsigned off1 = cppi << 2;
|
|
|
- void __iomem *ram = base;
|
|
|
- char tmp[16];
|
|
|
-
|
|
|
- if (ep->is_in) {
|
|
|
- ram += DAVINCI_TXCPPI_STATERAM_OFFSET(cppi);
|
|
|
- tmp[0] = 0;
|
|
|
- } else {
|
|
|
- ram += DAVINCI_RXCPPI_STATERAM_OFFSET(cppi);
|
|
|
- snprintf(tmp, sizeof tmp, "%d left, ",
|
|
|
- musb_readl(base,
|
|
|
- DAVINCI_RXCPPI_BUFCNT0_REG + off1));
|
|
|
- }
|
|
|
-
|
|
|
- code = snprintf(buf, max, "%cX DMA%d: %s"
|
|
|
- "%08x %08x, %08x %08x; "
|
|
|
- "%08x %08x %08x .. %08x\n",
|
|
|
- ep->is_in ? 'T' : 'R',
|
|
|
- ep->current_epnum - 1, tmp,
|
|
|
- musb_readl(ram, 0 * 4),
|
|
|
- musb_readl(ram, 1 * 4),
|
|
|
- musb_readl(ram, 2 * 4),
|
|
|
- musb_readl(ram, 3 * 4),
|
|
|
- musb_readl(ram, 4 * 4),
|
|
|
- musb_readl(ram, 5 * 4),
|
|
|
- musb_readl(ram, 6 * 4),
|
|
|
- musb_readl(ram, 7 * 4));
|
|
|
- if (code <= 0)
|
|
|
- break;
|
|
|
- code = min(code, (int) max);
|
|
|
- buf += code;
|
|
|
- max -= code;
|
|
|
- }
|
|
|
-
|
|
|
- if (list_empty(&ep->req_list)) {
|
|
|
- code = snprintf(buf, max, "\t(queue empty)\n");
|
|
|
- if (code <= 0)
|
|
|
- break;
|
|
|
- code = min(code, (int) max);
|
|
|
- buf += code;
|
|
|
- max -= code;
|
|
|
- break;
|
|
|
- }
|
|
|
- list_for_each_entry(req, &ep->req_list, list) {
|
|
|
- code = snprintf(buf, max, "\treq %p, %s%s%d/%d\n",
|
|
|
- req,
|
|
|
- req->zero ? "zero, " : "",
|
|
|
- req->short_not_ok ? "!short, " : "",
|
|
|
- req->actual, req->length);
|
|
|
- if (code <= 0)
|
|
|
- break;
|
|
|
- code = min(code, (int) max);
|
|
|
- buf += code;
|
|
|
- max -= code;
|
|
|
- }
|
|
|
- } while (0);
|
|
|
- return buf - buffer;
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
-static int
|
|
|
-dump_end_info(struct musb *musb, u8 epnum, char *aBuffer, unsigned max)
|
|
|
-{
|
|
|
- int code = 0;
|
|
|
- char *buf = aBuffer;
|
|
|
- struct musb_hw_ep *hw_ep = &musb->endpoints[epnum];
|
|
|
-
|
|
|
- do {
|
|
|
- musb_ep_select(musb->mregs, epnum);
|
|
|
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
|
|
|
- if (is_host_active(musb)) {
|
|
|
- int dump_rx, dump_tx;
|
|
|
- void __iomem *regs = hw_ep->regs;
|
|
|
-
|
|
|
- /* TEMPORARY (!) until we have a real periodic
|
|
|
- * schedule tree ...
|
|
|
- */
|
|
|
- if (!epnum) {
|
|
|
- /* control is shared, uses RX queue
|
|
|
- * but (mostly) shadowed tx registers
|
|
|
- */
|
|
|
- dump_tx = !list_empty(&musb->control);
|
|
|
- dump_rx = 0;
|
|
|
- } else if (hw_ep == musb->bulk_ep) {
|
|
|
- dump_tx = !list_empty(&musb->out_bulk);
|
|
|
- dump_rx = !list_empty(&musb->in_bulk);
|
|
|
- } else if (musb->periodic[epnum]) {
|
|
|
- struct usb_host_endpoint *hep;
|
|
|
-
|
|
|
- hep = musb->periodic[epnum]->hep;
|
|
|
- dump_rx = hep->desc.bEndpointAddress
|
|
|
- & USB_ENDPOINT_DIR_MASK;
|
|
|
- dump_tx = !dump_rx;
|
|
|
- } else
|
|
|
- break;
|
|
|
- /* END TEMPORARY */
|
|
|
-
|
|
|
-
|
|
|
- if (dump_rx) {
|
|
|
- code = snprintf(buf, max,
|
|
|
- "\nRX%d: %s rxcsr %04x interval %02x "
|
|
|
- "max %04x type %02x; "
|
|
|
- "dev %d hub %d port %d"
|
|
|
- "\n",
|
|
|
- epnum,
|
|
|
- hw_ep->rx_double_buffered
|
|
|
- ? "2buf" : "1buf",
|
|
|
- musb_readw(regs, MUSB_RXCSR),
|
|
|
- musb_readb(regs, MUSB_RXINTERVAL),
|
|
|
- musb_readw(regs, MUSB_RXMAXP),
|
|
|
- musb_readb(regs, MUSB_RXTYPE),
|
|
|
- /* FIXME: assumes multipoint */
|
|
|
- musb_readb(musb->mregs,
|
|
|
- MUSB_BUSCTL_OFFSET(epnum,
|
|
|
- MUSB_RXFUNCADDR)),
|
|
|
- musb_readb(musb->mregs,
|
|
|
- MUSB_BUSCTL_OFFSET(epnum,
|
|
|
- MUSB_RXHUBADDR)),
|
|
|
- musb_readb(musb->mregs,
|
|
|
- MUSB_BUSCTL_OFFSET(epnum,
|
|
|
- MUSB_RXHUBPORT))
|
|
|
- );
|
|
|
- if (code <= 0)
|
|
|
- break;
|
|
|
- code = min(code, (int) max);
|
|
|
- buf += code;
|
|
|
- max -= code;
|
|
|
-
|
|
|
- if (is_cppi_enabled()
|
|
|
- && epnum
|
|
|
- && hw_ep->rx_channel) {
|
|
|
- unsigned cppi = epnum - 1;
|
|
|
- unsigned off1 = cppi << 2;
|
|
|
- void __iomem *base;
|
|
|
- void __iomem *ram;
|
|
|
- char tmp[16];
|
|
|
-
|
|
|
- base = musb->ctrl_base;
|
|
|
- ram = DAVINCI_RXCPPI_STATERAM_OFFSET(
|
|
|
- cppi) + base;
|
|
|
- snprintf(tmp, sizeof tmp, "%d left, ",
|
|
|
- musb_readl(base,
|
|
|
- DAVINCI_RXCPPI_BUFCNT0_REG
|
|
|
- + off1));
|
|
|
-
|
|
|
- code = snprintf(buf, max,
|
|
|
- " rx dma%d: %s"
|
|
|
- "%08x %08x, %08x %08x; "
|
|
|
- "%08x %08x %08x .. %08x\n",
|
|
|
- cppi, tmp,
|
|
|
- musb_readl(ram, 0 * 4),
|
|
|
- musb_readl(ram, 1 * 4),
|
|
|
- musb_readl(ram, 2 * 4),
|
|
|
- musb_readl(ram, 3 * 4),
|
|
|
- musb_readl(ram, 4 * 4),
|
|
|
- musb_readl(ram, 5 * 4),
|
|
|
- musb_readl(ram, 6 * 4),
|
|
|
- musb_readl(ram, 7 * 4));
|
|
|
- if (code <= 0)
|
|
|
- break;
|
|
|
- code = min(code, (int) max);
|
|
|
- buf += code;
|
|
|
- max -= code;
|
|
|
- }
|
|
|
-
|
|
|
- if (hw_ep == musb->bulk_ep
|
|
|
- && !list_empty(
|
|
|
- &musb->in_bulk)) {
|
|
|
- code = dump_queue(&musb->in_bulk,
|
|
|
- buf, max);
|
|
|
- if (code <= 0)
|
|
|
- break;
|
|
|
- code = min(code, (int) max);
|
|
|
- buf += code;
|
|
|
- max -= code;
|
|
|
- } else if (musb->periodic[epnum]) {
|
|
|
- code = dump_qh(musb->periodic[epnum],
|
|
|
- buf, max);
|
|
|
- if (code <= 0)
|
|
|
- break;
|
|
|
- code = min(code, (int) max);
|
|
|
- buf += code;
|
|
|
- max -= code;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (dump_tx) {
|
|
|
- code = snprintf(buf, max,
|
|
|
- "\nTX%d: %s txcsr %04x interval %02x "
|
|
|
- "max %04x type %02x; "
|
|
|
- "dev %d hub %d port %d"
|
|
|
- "\n",
|
|
|
- epnum,
|
|
|
- hw_ep->tx_double_buffered
|
|
|
- ? "2buf" : "1buf",
|
|
|
- musb_readw(regs, MUSB_TXCSR),
|
|
|
- musb_readb(regs, MUSB_TXINTERVAL),
|
|
|
- musb_readw(regs, MUSB_TXMAXP),
|
|
|
- musb_readb(regs, MUSB_TXTYPE),
|
|
|
- /* FIXME: assumes multipoint */
|
|
|
- musb_readb(musb->mregs,
|
|
|
- MUSB_BUSCTL_OFFSET(epnum,
|
|
|
- MUSB_TXFUNCADDR)),
|
|
|
- musb_readb(musb->mregs,
|
|
|
- MUSB_BUSCTL_OFFSET(epnum,
|
|
|
- MUSB_TXHUBADDR)),
|
|
|
- musb_readb(musb->mregs,
|
|
|
- MUSB_BUSCTL_OFFSET(epnum,
|
|
|
- MUSB_TXHUBPORT))
|
|
|
- );
|
|
|
- if (code <= 0)
|
|
|
- break;
|
|
|
- code = min(code, (int) max);
|
|
|
- buf += code;
|
|
|
- max -= code;
|
|
|
-
|
|
|
- if (is_cppi_enabled()
|
|
|
- && epnum
|
|
|
- && hw_ep->tx_channel) {
|
|
|
- unsigned cppi = epnum - 1;
|
|
|
- void __iomem *base;
|
|
|
- void __iomem *ram;
|
|
|
-
|
|
|
- base = musb->ctrl_base;
|
|
|
- ram = DAVINCI_RXCPPI_STATERAM_OFFSET(
|
|
|
- cppi) + base;
|
|
|
- code = snprintf(buf, max,
|
|
|
- " tx dma%d: "
|
|
|
- "%08x %08x, %08x %08x; "
|
|
|
- "%08x %08x %08x .. %08x\n",
|
|
|
- cppi,
|
|
|
- musb_readl(ram, 0 * 4),
|
|
|
- musb_readl(ram, 1 * 4),
|
|
|
- musb_readl(ram, 2 * 4),
|
|
|
- musb_readl(ram, 3 * 4),
|
|
|
- musb_readl(ram, 4 * 4),
|
|
|
- musb_readl(ram, 5 * 4),
|
|
|
- musb_readl(ram, 6 * 4),
|
|
|
- musb_readl(ram, 7 * 4));
|
|
|
- if (code <= 0)
|
|
|
- break;
|
|
|
- code = min(code, (int) max);
|
|
|
- buf += code;
|
|
|
- max -= code;
|
|
|
- }
|
|
|
-
|
|
|
- if (hw_ep == musb->control_ep
|
|
|
- && !list_empty(
|
|
|
- &musb->control)) {
|
|
|
- code = dump_queue(&musb->control,
|
|
|
- buf, max);
|
|
|
- if (code <= 0)
|
|
|
- break;
|
|
|
- code = min(code, (int) max);
|
|
|
- buf += code;
|
|
|
- max -= code;
|
|
|
- } else if (hw_ep == musb->bulk_ep
|
|
|
- && !list_empty(
|
|
|
- &musb->out_bulk)) {
|
|
|
- code = dump_queue(&musb->out_bulk,
|
|
|
- buf, max);
|
|
|
- if (code <= 0)
|
|
|
- break;
|
|
|
- code = min(code, (int) max);
|
|
|
- buf += code;
|
|
|
- max -= code;
|
|
|
- } else if (musb->periodic[epnum]) {
|
|
|
- code = dump_qh(musb->periodic[epnum],
|
|
|
- buf, max);
|
|
|
- if (code <= 0)
|
|
|
- break;
|
|
|
- code = min(code, (int) max);
|
|
|
- buf += code;
|
|
|
- max -= code;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-#endif
|
|
|
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
|
|
|
- if (is_peripheral_active(musb)) {
|
|
|
- code = 0;
|
|
|
-
|
|
|
- if (hw_ep->ep_in.desc || !epnum) {
|
|
|
- code = dump_ep(&hw_ep->ep_in, buf, max);
|
|
|
- if (code <= 0)
|
|
|
- break;
|
|
|
- code = min(code, (int) max);
|
|
|
- buf += code;
|
|
|
- max -= code;
|
|
|
- }
|
|
|
- if (hw_ep->ep_out.desc) {
|
|
|
- code = dump_ep(&hw_ep->ep_out, buf, max);
|
|
|
- if (code <= 0)
|
|
|
- break;
|
|
|
- code = min(code, (int) max);
|
|
|
- buf += code;
|
|
|
- max -= code;
|
|
|
- }
|
|
|
- }
|
|
|
-#endif
|
|
|
- } while (0);
|
|
|
-
|
|
|
- return buf - aBuffer;
|
|
|
-}
|
|
|
-
|
|
|
-/* Dump the current status and compile options.
|
|
|
- * @param musb the device driver instance
|
|
|
- * @param buffer where to dump the status; it must be big enough to hold the
|
|
|
- * result otherwise "BAD THINGS HAPPENS(TM)".
|
|
|
- */
|
|
|
-static int dump_header_stats(struct musb *musb, char *buffer)
|
|
|
-{
|
|
|
- int code, count = 0;
|
|
|
- const void __iomem *mbase = musb->mregs;
|
|
|
-
|
|
|
- *buffer = 0;
|
|
|
- count = sprintf(buffer, "Status: %sHDRC, Mode=%s "
|
|
|
- "(Power=%02x, DevCtl=%02x)\n",
|
|
|
- (musb->is_multipoint ? "M" : ""), MUSB_MODE(musb),
|
|
|
- musb_readb(mbase, MUSB_POWER),
|
|
|
- musb_readb(mbase, MUSB_DEVCTL));
|
|
|
- if (count <= 0)
|
|
|
- return 0;
|
|
|
- buffer += count;
|
|
|
-
|
|
|
- code = sprintf(buffer, "OTG state: %s; %sactive\n",
|
|
|
- otg_state_string(musb),
|
|
|
- musb->is_active ? "" : "in");
|
|
|
- if (code <= 0)
|
|
|
- goto done;
|
|
|
- buffer += code;
|
|
|
- count += code;
|
|
|
-
|
|
|
- code = sprintf(buffer,
|
|
|
- "Options: "
|
|
|
-#ifdef CONFIG_MUSB_PIO_ONLY
|
|
|
- "pio"
|
|
|
-#elif defined(CONFIG_USB_TI_CPPI_DMA)
|
|
|
- "cppi-dma"
|
|
|
-#elif defined(CONFIG_USB_INVENTRA_DMA)
|
|
|
- "musb-dma"
|
|
|
-#elif defined(CONFIG_USB_TUSB_OMAP_DMA)
|
|
|
- "tusb-omap-dma"
|
|
|
-#else
|
|
|
- "?dma?"
|
|
|
-#endif
|
|
|
- ", "
|
|
|
-#ifdef CONFIG_USB_MUSB_OTG
|
|
|
- "otg (peripheral+host)"
|
|
|
-#elif defined(CONFIG_USB_GADGET_MUSB_HDRC)
|
|
|
- "peripheral"
|
|
|
-#elif defined(CONFIG_USB_MUSB_HDRC_HCD)
|
|
|
- "host"
|
|
|
-#endif
|
|
|
- ", debug=%d [eps=%d]\n",
|
|
|
- debug,
|
|
|
- musb->nr_endpoints);
|
|
|
- if (code <= 0)
|
|
|
- goto done;
|
|
|
- count += code;
|
|
|
- buffer += code;
|
|
|
-
|
|
|
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
|
|
|
- code = sprintf(buffer, "Peripheral address: %02x\n",
|
|
|
- musb_readb(musb->ctrl_base, MUSB_FADDR));
|
|
|
- if (code <= 0)
|
|
|
- goto done;
|
|
|
- buffer += code;
|
|
|
- count += code;
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
|
|
|
- code = sprintf(buffer, "Root port status: %08x\n",
|
|
|
- musb->port1_status);
|
|
|
- if (code <= 0)
|
|
|
- goto done;
|
|
|
- buffer += code;
|
|
|
- count += code;
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifdef CONFIG_ARCH_DAVINCI
|
|
|
- code = sprintf(buffer,
|
|
|
- "DaVinci: ctrl=%02x stat=%1x phy=%03x\n"
|
|
|
- "\trndis=%05x auto=%04x intsrc=%08x intmsk=%08x"
|
|
|
- "\n",
|
|
|
- musb_readl(musb->ctrl_base, DAVINCI_USB_CTRL_REG),
|
|
|
- musb_readl(musb->ctrl_base, DAVINCI_USB_STAT_REG),
|
|
|
- __raw_readl((void __force __iomem *)
|
|
|
- IO_ADDRESS(USBPHY_CTL_PADDR)),
|
|
|
- musb_readl(musb->ctrl_base, DAVINCI_RNDIS_REG),
|
|
|
- musb_readl(musb->ctrl_base, DAVINCI_AUTOREQ_REG),
|
|
|
- musb_readl(musb->ctrl_base,
|
|
|
- DAVINCI_USB_INT_SOURCE_REG),
|
|
|
- musb_readl(musb->ctrl_base,
|
|
|
- DAVINCI_USB_INT_MASK_REG));
|
|
|
- if (code <= 0)
|
|
|
- goto done;
|
|
|
- count += code;
|
|
|
- buffer += code;
|
|
|
-#endif /* DAVINCI */
|
|
|
-
|
|
|
-#ifdef CONFIG_USB_TUSB6010
|
|
|
- code = sprintf(buffer,
|
|
|
- "TUSB6010: devconf %08x, phy enable %08x drive %08x"
|
|
|
- "\n\totg %03x timer %08x"
|
|
|
- "\n\tprcm conf %08x mgmt %08x; int src %08x mask %08x"
|
|
|
- "\n",
|
|
|
- musb_readl(musb->ctrl_base, TUSB_DEV_CONF),
|
|
|
- musb_readl(musb->ctrl_base, TUSB_PHY_OTG_CTRL_ENABLE),
|
|
|
- musb_readl(musb->ctrl_base, TUSB_PHY_OTG_CTRL),
|
|
|
- musb_readl(musb->ctrl_base, TUSB_DEV_OTG_STAT),
|
|
|
- musb_readl(musb->ctrl_base, TUSB_DEV_OTG_TIMER),
|
|
|
- musb_readl(musb->ctrl_base, TUSB_PRCM_CONF),
|
|
|
- musb_readl(musb->ctrl_base, TUSB_PRCM_MNGMT),
|
|
|
- musb_readl(musb->ctrl_base, TUSB_INT_SRC),
|
|
|
- musb_readl(musb->ctrl_base, TUSB_INT_MASK));
|
|
|
- if (code <= 0)
|
|
|
- goto done;
|
|
|
- count += code;
|
|
|
- buffer += code;
|
|
|
-#endif /* DAVINCI */
|
|
|
-
|
|
|
- if (is_cppi_enabled() && musb->dma_controller) {
|
|
|
- code = sprintf(buffer,
|
|
|
- "CPPI: txcr=%d txsrc=%01x txena=%01x; "
|
|
|
- "rxcr=%d rxsrc=%01x rxena=%01x "
|
|
|
- "\n",
|
|
|
- musb_readl(musb->ctrl_base,
|
|
|
- DAVINCI_TXCPPI_CTRL_REG),
|
|
|
- musb_readl(musb->ctrl_base,
|
|
|
- DAVINCI_TXCPPI_RAW_REG),
|
|
|
- musb_readl(musb->ctrl_base,
|
|
|
- DAVINCI_TXCPPI_INTENAB_REG),
|
|
|
- musb_readl(musb->ctrl_base,
|
|
|
- DAVINCI_RXCPPI_CTRL_REG),
|
|
|
- musb_readl(musb->ctrl_base,
|
|
|
- DAVINCI_RXCPPI_RAW_REG),
|
|
|
- musb_readl(musb->ctrl_base,
|
|
|
- DAVINCI_RXCPPI_INTENAB_REG));
|
|
|
- if (code <= 0)
|
|
|
- goto done;
|
|
|
- count += code;
|
|
|
- buffer += code;
|
|
|
- }
|
|
|
-
|
|
|
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
|
|
|
- if (is_peripheral_enabled(musb)) {
|
|
|
- code = sprintf(buffer, "Gadget driver: %s\n",
|
|
|
- musb->gadget_driver
|
|
|
- ? musb->gadget_driver->driver.name
|
|
|
- : "(none)");
|
|
|
- if (code <= 0)
|
|
|
- goto done;
|
|
|
- count += code;
|
|
|
- buffer += code;
|
|
|
- }
|
|
|
-#endif
|
|
|
-
|
|
|
-done:
|
|
|
- return count;
|
|
|
-}
|
|
|
-
|
|
|
-/* Write to ProcFS
|
|
|
- *
|
|
|
- * C soft-connect
|
|
|
- * c soft-disconnect
|
|
|
- * I enable HS
|
|
|
- * i disable HS
|
|
|
- * s stop session
|
|
|
- * F force session (OTG-unfriendly)
|
|
|
- * E rElinquish bus (OTG)
|
|
|
- * H request host mode
|
|
|
- * h cancel host request
|
|
|
- * T start sending TEST_PACKET
|
|
|
- * D<num> set/query the debug level
|
|
|
- */
|
|
|
-static int musb_proc_write(struct file *file, const char __user *buffer,
|
|
|
- unsigned long count, void *data)
|
|
|
-{
|
|
|
- char cmd;
|
|
|
- u8 reg;
|
|
|
- struct musb *musb = (struct musb *)data;
|
|
|
- void __iomem *mbase = musb->mregs;
|
|
|
-
|
|
|
- /* MOD_INC_USE_COUNT; */
|
|
|
-
|
|
|
- if (unlikely(copy_from_user(&cmd, buffer, 1)))
|
|
|
- return -EFAULT;
|
|
|
-
|
|
|
- switch (cmd) {
|
|
|
- case 'C':
|
|
|
- if (mbase) {
|
|
|
- reg = musb_readb(mbase, MUSB_POWER)
|
|
|
- | MUSB_POWER_SOFTCONN;
|
|
|
- musb_writeb(mbase, MUSB_POWER, reg);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case 'c':
|
|
|
- if (mbase) {
|
|
|
- reg = musb_readb(mbase, MUSB_POWER)
|
|
|
- & ~MUSB_POWER_SOFTCONN;
|
|
|
- musb_writeb(mbase, MUSB_POWER, reg);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case 'I':
|
|
|
- if (mbase) {
|
|
|
- reg = musb_readb(mbase, MUSB_POWER)
|
|
|
- | MUSB_POWER_HSENAB;
|
|
|
- musb_writeb(mbase, MUSB_POWER, reg);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case 'i':
|
|
|
- if (mbase) {
|
|
|
- reg = musb_readb(mbase, MUSB_POWER)
|
|
|
- & ~MUSB_POWER_HSENAB;
|
|
|
- musb_writeb(mbase, MUSB_POWER, reg);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case 'F':
|
|
|
- reg = musb_readb(mbase, MUSB_DEVCTL);
|
|
|
- reg |= MUSB_DEVCTL_SESSION;
|
|
|
- musb_writeb(mbase, MUSB_DEVCTL, reg);
|
|
|
- break;
|
|
|
-
|
|
|
- case 'H':
|
|
|
- if (mbase) {
|
|
|
- reg = musb_readb(mbase, MUSB_DEVCTL);
|
|
|
- reg |= MUSB_DEVCTL_HR;
|
|
|
- musb_writeb(mbase, MUSB_DEVCTL, reg);
|
|
|
- /* MUSB_HST_MODE( ((struct musb*)data) ); */
|
|
|
- /* WARNING("Host Mode\n"); */
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case 'h':
|
|
|
- if (mbase) {
|
|
|
- reg = musb_readb(mbase, MUSB_DEVCTL);
|
|
|
- reg &= ~MUSB_DEVCTL_HR;
|
|
|
- musb_writeb(mbase, MUSB_DEVCTL, reg);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case 'T':
|
|
|
- if (mbase) {
|
|
|
- musb_load_testpacket(musb);
|
|
|
- musb_writeb(mbase, MUSB_TESTMODE,
|
|
|
- MUSB_TEST_PACKET);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
-#if (MUSB_DEBUG > 0)
|
|
|
- /* set/read debug level */
|
|
|
- case 'D':{
|
|
|
- if (count > 1) {
|
|
|
- char digits[8], *p = digits;
|
|
|
- int i = 0, level = 0, sign = 1;
|
|
|
- int len = min(count - 1, (unsigned long)8);
|
|
|
-
|
|
|
- if (copy_from_user(&digits, &buffer[1], len))
|
|
|
- return -EFAULT;
|
|
|
-
|
|
|
- /* optional sign */
|
|
|
- if (*p == '-') {
|
|
|
- len -= 1;
|
|
|
- sign = -sign;
|
|
|
- p++;
|
|
|
- }
|
|
|
-
|
|
|
- /* read it */
|
|
|
- while (i++ < len && *p > '0' && *p < '9') {
|
|
|
- level = level * 10 + (*p - '0');
|
|
|
- p++;
|
|
|
- }
|
|
|
-
|
|
|
- level *= sign;
|
|
|
- DBG(1, "debug level %d\n", level);
|
|
|
- debug = level;
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
-
|
|
|
- case '?':
|
|
|
- INFO("?: you are seeing it\n");
|
|
|
- INFO("C/c: soft connect enable/disable\n");
|
|
|
- INFO("I/i: hispeed enable/disable\n");
|
|
|
- INFO("F: force session start\n");
|
|
|
- INFO("H: host mode\n");
|
|
|
- INFO("T: start sending TEST_PACKET\n");
|
|
|
- INFO("D: set/read dbug level\n");
|
|
|
- break;
|
|
|
-#endif
|
|
|
-
|
|
|
- default:
|
|
|
- ERR("Command %c not implemented\n", cmd);
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- musb_platform_try_idle(musb, 0);
|
|
|
-
|
|
|
- return count;
|
|
|
-}
|
|
|
-
|
|
|
-static int musb_proc_read(char *page, char **start,
|
|
|
- off_t off, int count, int *eof, void *data)
|
|
|
-{
|
|
|
- char *buffer = page;
|
|
|
- int code = 0;
|
|
|
- unsigned long flags;
|
|
|
- struct musb *musb = data;
|
|
|
- unsigned epnum;
|
|
|
-
|
|
|
- count -= off;
|
|
|
- count -= 1; /* for NUL at end */
|
|
|
- if (count <= 0)
|
|
|
- return -EINVAL;
|
|
|
-
|
|
|
- spin_lock_irqsave(&musb->lock, flags);
|
|
|
-
|
|
|
- code = dump_header_stats(musb, buffer);
|
|
|
- if (code > 0) {
|
|
|
- buffer += code;
|
|
|
- count -= code;
|
|
|
- }
|
|
|
-
|
|
|
- /* generate the report for the end points */
|
|
|
- /* REVISIT ... not unless something's connected! */
|
|
|
- for (epnum = 0; count >= 0 && epnum < musb->nr_endpoints;
|
|
|
- epnum++) {
|
|
|
- code = dump_end_info(musb, epnum, buffer, count);
|
|
|
- if (code > 0) {
|
|
|
- buffer += code;
|
|
|
- count -= code;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- musb_platform_try_idle(musb, 0);
|
|
|
-
|
|
|
- spin_unlock_irqrestore(&musb->lock, flags);
|
|
|
- *eof = 1;
|
|
|
-
|
|
|
- return buffer - page;
|
|
|
-}
|
|
|
-
|
|
|
-void __devexit musb_debug_delete(char *name, struct musb *musb)
|
|
|
-{
|
|
|
- if (musb->proc_entry)
|
|
|
- remove_proc_entry(name, NULL);
|
|
|
-}
|
|
|
-
|
|
|
-struct proc_dir_entry *__init
|
|
|
-musb_debug_create(char *name, struct musb *data)
|
|
|
-{
|
|
|
- struct proc_dir_entry *pde;
|
|
|
-
|
|
|
- /* FIXME convert everything to seq_file; then later, debugfs */
|
|
|
-
|
|
|
- if (!name)
|
|
|
- return NULL;
|
|
|
-
|
|
|
- pde = create_proc_entry(name, S_IFREG | S_IRUGO | S_IWUSR, NULL);
|
|
|
- data->proc_entry = pde;
|
|
|
- if (pde) {
|
|
|
- pde->data = data;
|
|
|
- /* pde->owner = THIS_MODULE; */
|
|
|
-
|
|
|
- pde->read_proc = musb_proc_read;
|
|
|
- pde->write_proc = musb_proc_write;
|
|
|
-
|
|
|
- pde->size = 0;
|
|
|
-
|
|
|
- pr_debug("Registered /proc/%s\n", name);
|
|
|
- } else {
|
|
|
- pr_debug("Cannot create a valid proc file entry");
|
|
|
- }
|
|
|
-
|
|
|
- return pde;
|
|
|
-}
|
Linus Torvalds