| /* |
| * Faraday FUSBH200 EHCI-like driver |
| * |
| * Copyright (c) 2013 Faraday Technology Corporation |
| * |
| * Author: Yuan-Hsin Chen <yhchen@faraday-tech.com> |
| * Feng-Hsin Chiang <john453@faraday-tech.com> |
| * Po-Yu Chuang <ratbert.chuang@gmail.com> |
| * |
| * Most of code borrowed from the Linux-3.7 EHCI driver |
| * |
| * 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. |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/device.h> |
| #include <linux/dmapool.h> |
| #include <linux/kernel.h> |
| #include <linux/delay.h> |
| #include <linux/ioport.h> |
| #include <linux/sched.h> |
| #include <linux/vmalloc.h> |
| #include <linux/errno.h> |
| #include <linux/init.h> |
| #include <linux/hrtimer.h> |
| #include <linux/list.h> |
| #include <linux/interrupt.h> |
| #include <linux/usb.h> |
| #include <linux/usb/hcd.h> |
| #include <linux/moduleparam.h> |
| #include <linux/dma-mapping.h> |
| #include <linux/debugfs.h> |
| #include <linux/slab.h> |
| #include <linux/uaccess.h> |
| #include <linux/platform_device.h> |
| |
| #include <asm/byteorder.h> |
| #include <asm/io.h> |
| #include <asm/irq.h> |
| #include <asm/unaligned.h> |
| |
| /*-------------------------------------------------------------------------*/ |
| #define DRIVER_AUTHOR "Yuan-Hsin Chen" |
| #define DRIVER_DESC "FUSBH200 Host Controller (EHCI) Driver" |
| |
| static const char hcd_name [] = "fusbh200_hcd"; |
| |
| #undef FUSBH200_URB_TRACE |
| |
| /* magic numbers that can affect system performance */ |
| #define FUSBH200_TUNE_CERR 3 /* 0-3 qtd retries; 0 == don't stop */ |
| #define FUSBH200_TUNE_RL_HS 4 /* nak throttle; see 4.9 */ |
| #define FUSBH200_TUNE_RL_TT 0 |
| #define FUSBH200_TUNE_MULT_HS 1 /* 1-3 transactions/uframe; 4.10.3 */ |
| #define FUSBH200_TUNE_MULT_TT 1 |
| /* |
| * Some drivers think it's safe to schedule isochronous transfers more than |
| * 256 ms into the future (partly as a result of an old bug in the scheduling |
| * code). In an attempt to avoid trouble, we will use a minimum scheduling |
| * length of 512 frames instead of 256. |
| */ |
| #define FUSBH200_TUNE_FLS 1 /* (medium) 512-frame schedule */ |
| |
| /* Initial IRQ latency: faster than hw default */ |
| static int log2_irq_thresh = 0; // 0 to 6 |
| module_param (log2_irq_thresh, int, S_IRUGO); |
| MODULE_PARM_DESC (log2_irq_thresh, "log2 IRQ latency, 1-64 microframes"); |
| |
| /* initial park setting: slower than hw default */ |
| static unsigned park = 0; |
| module_param (park, uint, S_IRUGO); |
| MODULE_PARM_DESC (park, "park setting; 1-3 back-to-back async packets"); |
| |
| /* for link power management(LPM) feature */ |
| static unsigned int hird; |
| module_param(hird, int, S_IRUGO); |
| MODULE_PARM_DESC(hird, "host initiated resume duration, +1 for each 75us"); |
| |
| #define INTR_MASK (STS_IAA | STS_FATAL | STS_PCD | STS_ERR | STS_INT) |
| |
| #include "fusbh200.h" |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| #define fusbh200_dbg(fusbh200, fmt, args...) \ |
| dev_dbg (fusbh200_to_hcd(fusbh200)->self.controller , fmt , ## args ) |
| #define fusbh200_err(fusbh200, fmt, args...) \ |
| dev_err (fusbh200_to_hcd(fusbh200)->self.controller , fmt , ## args ) |
| #define fusbh200_info(fusbh200, fmt, args...) \ |
| dev_info (fusbh200_to_hcd(fusbh200)->self.controller , fmt , ## args ) |
| #define fusbh200_warn(fusbh200, fmt, args...) \ |
| dev_warn (fusbh200_to_hcd(fusbh200)->self.controller , fmt , ## args ) |
| |
| /* check the values in the HCSPARAMS register |
| * (host controller _Structural_ parameters) |
| * see EHCI spec, Table 2-4 for each value |
| */ |
| static void dbg_hcs_params (struct fusbh200_hcd *fusbh200, char *label) |
| { |
| u32 params = fusbh200_readl(fusbh200, &fusbh200->caps->hcs_params); |
| |
| fusbh200_dbg (fusbh200, |
| "%s hcs_params 0x%x ports=%d\n", |
| label, params, |
| HCS_N_PORTS (params) |
| ); |
| } |
| |
| /* check the values in the HCCPARAMS register |
| * (host controller _Capability_ parameters) |
| * see EHCI Spec, Table 2-5 for each value |
| * */ |
| static void dbg_hcc_params (struct fusbh200_hcd *fusbh200, char *label) |
| { |
| u32 params = fusbh200_readl(fusbh200, &fusbh200->caps->hcc_params); |
| |
| fusbh200_dbg (fusbh200, |
| "%s hcc_params %04x uframes %s%s\n", |
| label, |
| params, |
| HCC_PGM_FRAMELISTLEN(params) ? "256/512/1024" : "1024", |
| HCC_CANPARK(params) ? " park" : ""); |
| } |
| |
| static void __maybe_unused |
| dbg_qtd (const char *label, struct fusbh200_hcd *fusbh200, struct fusbh200_qtd *qtd) |
| { |
| fusbh200_dbg(fusbh200, "%s td %p n%08x %08x t%08x p0=%08x\n", label, qtd, |
| hc32_to_cpup(fusbh200, &qtd->hw_next), |
| hc32_to_cpup(fusbh200, &qtd->hw_alt_next), |
| hc32_to_cpup(fusbh200, &qtd->hw_token), |
| hc32_to_cpup(fusbh200, &qtd->hw_buf [0])); |
| if (qtd->hw_buf [1]) |
| fusbh200_dbg(fusbh200, " p1=%08x p2=%08x p3=%08x p4=%08x\n", |
| hc32_to_cpup(fusbh200, &qtd->hw_buf[1]), |
| hc32_to_cpup(fusbh200, &qtd->hw_buf[2]), |
| hc32_to_cpup(fusbh200, &qtd->hw_buf[3]), |
| hc32_to_cpup(fusbh200, &qtd->hw_buf[4])); |
| } |
| |
| static void __maybe_unused |
| dbg_qh (const char *label, struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh) |
| { |
| struct fusbh200_qh_hw *hw = qh->hw; |
| |
| fusbh200_dbg (fusbh200, "%s qh %p n%08x info %x %x qtd %x\n", label, |
| qh, hw->hw_next, hw->hw_info1, hw->hw_info2, hw->hw_current); |
| dbg_qtd("overlay", fusbh200, (struct fusbh200_qtd *) &hw->hw_qtd_next); |
| } |
| |
| static void __maybe_unused |
| dbg_itd (const char *label, struct fusbh200_hcd *fusbh200, struct fusbh200_itd *itd) |
| { |
| fusbh200_dbg (fusbh200, "%s [%d] itd %p, next %08x, urb %p\n", |
| label, itd->frame, itd, hc32_to_cpu(fusbh200, itd->hw_next), |
| itd->urb); |
| fusbh200_dbg (fusbh200, |
| " trans: %08x %08x %08x %08x %08x %08x %08x %08x\n", |
| hc32_to_cpu(fusbh200, itd->hw_transaction[0]), |
| hc32_to_cpu(fusbh200, itd->hw_transaction[1]), |
| hc32_to_cpu(fusbh200, itd->hw_transaction[2]), |
| hc32_to_cpu(fusbh200, itd->hw_transaction[3]), |
| hc32_to_cpu(fusbh200, itd->hw_transaction[4]), |
| hc32_to_cpu(fusbh200, itd->hw_transaction[5]), |
| hc32_to_cpu(fusbh200, itd->hw_transaction[6]), |
| hc32_to_cpu(fusbh200, itd->hw_transaction[7])); |
| fusbh200_dbg (fusbh200, |
| " buf: %08x %08x %08x %08x %08x %08x %08x\n", |
| hc32_to_cpu(fusbh200, itd->hw_bufp[0]), |
| hc32_to_cpu(fusbh200, itd->hw_bufp[1]), |
| hc32_to_cpu(fusbh200, itd->hw_bufp[2]), |
| hc32_to_cpu(fusbh200, itd->hw_bufp[3]), |
| hc32_to_cpu(fusbh200, itd->hw_bufp[4]), |
| hc32_to_cpu(fusbh200, itd->hw_bufp[5]), |
| hc32_to_cpu(fusbh200, itd->hw_bufp[6])); |
| fusbh200_dbg (fusbh200, " index: %d %d %d %d %d %d %d %d\n", |
| itd->index[0], itd->index[1], itd->index[2], |
| itd->index[3], itd->index[4], itd->index[5], |
| itd->index[6], itd->index[7]); |
| } |
| |
| static int __maybe_unused |
| dbg_status_buf (char *buf, unsigned len, const char *label, u32 status) |
| { |
| return scnprintf (buf, len, |
| "%s%sstatus %04x%s%s%s%s%s%s%s%s%s%s", |
| label, label [0] ? " " : "", status, |
| (status & STS_ASS) ? " Async" : "", |
| (status & STS_PSS) ? " Periodic" : "", |
| (status & STS_RECL) ? " Recl" : "", |
| (status & STS_HALT) ? " Halt" : "", |
| (status & STS_IAA) ? " IAA" : "", |
| (status & STS_FATAL) ? " FATAL" : "", |
| (status & STS_FLR) ? " FLR" : "", |
| (status & STS_PCD) ? " PCD" : "", |
| (status & STS_ERR) ? " ERR" : "", |
| (status & STS_INT) ? " INT" : "" |
| ); |
| } |
| |
| static int __maybe_unused |
| dbg_intr_buf (char *buf, unsigned len, const char *label, u32 enable) |
| { |
| return scnprintf (buf, len, |
| "%s%sintrenable %02x%s%s%s%s%s%s", |
| label, label [0] ? " " : "", enable, |
| (enable & STS_IAA) ? " IAA" : "", |
| (enable & STS_FATAL) ? " FATAL" : "", |
| (enable & STS_FLR) ? " FLR" : "", |
| (enable & STS_PCD) ? " PCD" : "", |
| (enable & STS_ERR) ? " ERR" : "", |
| (enable & STS_INT) ? " INT" : "" |
| ); |
| } |
| |
| static const char *const fls_strings [] = |
| { "1024", "512", "256", "??" }; |
| |
| static int |
| dbg_command_buf (char *buf, unsigned len, const char *label, u32 command) |
| { |
| return scnprintf (buf, len, |
| "%s%scommand %07x %s=%d ithresh=%d%s%s%s " |
| "period=%s%s %s", |
| label, label [0] ? " " : "", command, |
| (command & CMD_PARK) ? " park" : "(park)", |
| CMD_PARK_CNT (command), |
| (command >> 16) & 0x3f, |
| (command & CMD_IAAD) ? " IAAD" : "", |
| (command & CMD_ASE) ? " Async" : "", |
| (command & CMD_PSE) ? " Periodic" : "", |
| fls_strings [(command >> 2) & 0x3], |
| (command & CMD_RESET) ? " Reset" : "", |
| (command & CMD_RUN) ? "RUN" : "HALT" |
| ); |
| } |
| |
| static int |
| dbg_port_buf (char *buf, unsigned len, const char *label, int port, u32 status) |
| { |
| char *sig; |
| |
| /* signaling state */ |
| switch (status & (3 << 10)) { |
| case 0 << 10: sig = "se0"; break; |
| case 1 << 10: sig = "k"; break; /* low speed */ |
| case 2 << 10: sig = "j"; break; |
| default: sig = "?"; break; |
| } |
| |
| return scnprintf (buf, len, |
| "%s%sport:%d status %06x %d " |
| "sig=%s%s%s%s%s%s%s%s", |
| label, label [0] ? " " : "", port, status, |
| status>>25,/*device address */ |
| sig, |
| (status & PORT_RESET) ? " RESET" : "", |
| (status & PORT_SUSPEND) ? " SUSPEND" : "", |
| (status & PORT_RESUME) ? " RESUME" : "", |
| (status & PORT_PEC) ? " PEC" : "", |
| (status & PORT_PE) ? " PE" : "", |
| (status & PORT_CSC) ? " CSC" : "", |
| (status & PORT_CONNECT) ? " CONNECT" : ""); |
| } |
| |
| /* functions have the "wrong" filename when they're output... */ |
| #define dbg_status(fusbh200, label, status) { \ |
| char _buf [80]; \ |
| dbg_status_buf (_buf, sizeof _buf, label, status); \ |
| fusbh200_dbg (fusbh200, "%s\n", _buf); \ |
| } |
| |
| #define dbg_cmd(fusbh200, label, command) { \ |
| char _buf [80]; \ |
| dbg_command_buf (_buf, sizeof _buf, label, command); \ |
| fusbh200_dbg (fusbh200, "%s\n", _buf); \ |
| } |
| |
| #define dbg_port(fusbh200, label, port, status) { \ |
| char _buf [80]; \ |
| dbg_port_buf (_buf, sizeof _buf, label, port, status); \ |
| fusbh200_dbg (fusbh200, "%s\n", _buf); \ |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* troubleshooting help: expose state in debugfs */ |
| |
| static int debug_async_open(struct inode *, struct file *); |
| static int debug_periodic_open(struct inode *, struct file *); |
| static int debug_registers_open(struct inode *, struct file *); |
| static int debug_async_open(struct inode *, struct file *); |
| |
| static ssize_t debug_output(struct file*, char __user*, size_t, loff_t*); |
| static int debug_close(struct inode *, struct file *); |
| |
| static const struct file_operations debug_async_fops = { |
| .owner = THIS_MODULE, |
| .open = debug_async_open, |
| .read = debug_output, |
| .release = debug_close, |
| .llseek = default_llseek, |
| }; |
| static const struct file_operations debug_periodic_fops = { |
| .owner = THIS_MODULE, |
| .open = debug_periodic_open, |
| .read = debug_output, |
| .release = debug_close, |
| .llseek = default_llseek, |
| }; |
| static const struct file_operations debug_registers_fops = { |
| .owner = THIS_MODULE, |
| .open = debug_registers_open, |
| .read = debug_output, |
| .release = debug_close, |
| .llseek = default_llseek, |
| }; |
| |
| static struct dentry *fusbh200_debug_root; |
| |
| struct debug_buffer { |
| ssize_t (*fill_func)(struct debug_buffer *); /* fill method */ |
| struct usb_bus *bus; |
| struct mutex mutex; /* protect filling of buffer */ |
| size_t count; /* number of characters filled into buffer */ |
| char *output_buf; |
| size_t alloc_size; |
| }; |
| |
| #define speed_char(info1) ({ char tmp; \ |
| switch (info1 & (3 << 12)) { \ |
| case QH_FULL_SPEED: tmp = 'f'; break; \ |
| case QH_LOW_SPEED: tmp = 'l'; break; \ |
| case QH_HIGH_SPEED: tmp = 'h'; break; \ |
| default: tmp = '?'; break; \ |
| } tmp; }) |
| |
| static inline char token_mark(struct fusbh200_hcd *fusbh200, __hc32 token) |
| { |
| __u32 v = hc32_to_cpu(fusbh200, token); |
| |
| if (v & QTD_STS_ACTIVE) |
| return '*'; |
| if (v & QTD_STS_HALT) |
| return '-'; |
| if (!IS_SHORT_READ (v)) |
| return ' '; |
| /* tries to advance through hw_alt_next */ |
| return '/'; |
| } |
| |
| static void qh_lines ( |
| struct fusbh200_hcd *fusbh200, |
| struct fusbh200_qh *qh, |
| char **nextp, |
| unsigned *sizep |
| ) |
| { |
| u32 scratch; |
| u32 hw_curr; |
| struct fusbh200_qtd *td; |
| unsigned temp; |
| unsigned size = *sizep; |
| char *next = *nextp; |
| char mark; |
| __le32 list_end = FUSBH200_LIST_END(fusbh200); |
| struct fusbh200_qh_hw *hw = qh->hw; |
| |
| if (hw->hw_qtd_next == list_end) /* NEC does this */ |
| mark = '@'; |
| else |
| mark = token_mark(fusbh200, hw->hw_token); |
| if (mark == '/') { /* qh_alt_next controls qh advance? */ |
| if ((hw->hw_alt_next & QTD_MASK(fusbh200)) |
| == fusbh200->async->hw->hw_alt_next) |
| mark = '#'; /* blocked */ |
| else if (hw->hw_alt_next == list_end) |
| mark = '.'; /* use hw_qtd_next */ |
| /* else alt_next points to some other qtd */ |
| } |
| scratch = hc32_to_cpup(fusbh200, &hw->hw_info1); |
| hw_curr = (mark == '*') ? hc32_to_cpup(fusbh200, &hw->hw_current) : 0; |
| temp = scnprintf (next, size, |
| "qh/%p dev%d %cs ep%d %08x %08x (%08x%c %s nak%d)", |
| qh, scratch & 0x007f, |
| speed_char (scratch), |
| (scratch >> 8) & 0x000f, |
| scratch, hc32_to_cpup(fusbh200, &hw->hw_info2), |
| hc32_to_cpup(fusbh200, &hw->hw_token), mark, |
| (cpu_to_hc32(fusbh200, QTD_TOGGLE) & hw->hw_token) |
| ? "data1" : "data0", |
| (hc32_to_cpup(fusbh200, &hw->hw_alt_next) >> 1) & 0x0f); |
| size -= temp; |
| next += temp; |
| |
| /* hc may be modifying the list as we read it ... */ |
| list_for_each_entry(td, &qh->qtd_list, qtd_list) { |
| scratch = hc32_to_cpup(fusbh200, &td->hw_token); |
| mark = ' '; |
| if (hw_curr == td->qtd_dma) |
| mark = '*'; |
| else if (hw->hw_qtd_next == cpu_to_hc32(fusbh200, td->qtd_dma)) |
| mark = '+'; |
| else if (QTD_LENGTH (scratch)) { |
| if (td->hw_alt_next == fusbh200->async->hw->hw_alt_next) |
| mark = '#'; |
| else if (td->hw_alt_next != list_end) |
| mark = '/'; |
| } |
| temp = snprintf (next, size, |
| "\n\t%p%c%s len=%d %08x urb %p", |
| td, mark, ({ char *tmp; |
| switch ((scratch>>8)&0x03) { |
| case 0: tmp = "out"; break; |
| case 1: tmp = "in"; break; |
| case 2: tmp = "setup"; break; |
| default: tmp = "?"; break; |
| } tmp;}), |
| (scratch >> 16) & 0x7fff, |
| scratch, |
| td->urb); |
| if (size < temp) |
| temp = size; |
| size -= temp; |
| next += temp; |
| if (temp == size) |
| goto done; |
| } |
| |
| temp = snprintf (next, size, "\n"); |
| if (size < temp) |
| temp = size; |
| size -= temp; |
| next += temp; |
| |
| done: |
| *sizep = size; |
| *nextp = next; |
| } |
| |
| static ssize_t fill_async_buffer(struct debug_buffer *buf) |
| { |
| struct usb_hcd *hcd; |
| struct fusbh200_hcd *fusbh200; |
| unsigned long flags; |
| unsigned temp, size; |
| char *next; |
| struct fusbh200_qh *qh; |
| |
| hcd = bus_to_hcd(buf->bus); |
| fusbh200 = hcd_to_fusbh200 (hcd); |
| next = buf->output_buf; |
| size = buf->alloc_size; |
| |
| *next = 0; |
| |
| /* dumps a snapshot of the async schedule. |
| * usually empty except for long-term bulk reads, or head. |
| * one QH per line, and TDs we know about |
| */ |
| spin_lock_irqsave (&fusbh200->lock, flags); |
| for (qh = fusbh200->async->qh_next.qh; size > 0 && qh; qh = qh->qh_next.qh) |
| qh_lines (fusbh200, qh, &next, &size); |
| if (fusbh200->async_unlink && size > 0) { |
| temp = scnprintf(next, size, "\nunlink =\n"); |
| size -= temp; |
| next += temp; |
| |
| for (qh = fusbh200->async_unlink; size > 0 && qh; |
| qh = qh->unlink_next) |
| qh_lines (fusbh200, qh, &next, &size); |
| } |
| spin_unlock_irqrestore (&fusbh200->lock, flags); |
| |
| return strlen(buf->output_buf); |
| } |
| |
| #define DBG_SCHED_LIMIT 64 |
| static ssize_t fill_periodic_buffer(struct debug_buffer *buf) |
| { |
| struct usb_hcd *hcd; |
| struct fusbh200_hcd *fusbh200; |
| unsigned long flags; |
| union fusbh200_shadow p, *seen; |
| unsigned temp, size, seen_count; |
| char *next; |
| unsigned i; |
| __hc32 tag; |
| |
| if (!(seen = kmalloc (DBG_SCHED_LIMIT * sizeof *seen, GFP_ATOMIC))) |
| return 0; |
| seen_count = 0; |
| |
| hcd = bus_to_hcd(buf->bus); |
| fusbh200 = hcd_to_fusbh200 (hcd); |
| next = buf->output_buf; |
| size = buf->alloc_size; |
| |
| temp = scnprintf (next, size, "size = %d\n", fusbh200->periodic_size); |
| size -= temp; |
| next += temp; |
| |
| /* dump a snapshot of the periodic schedule. |
| * iso changes, interrupt usually doesn't. |
| */ |
| spin_lock_irqsave (&fusbh200->lock, flags); |
| for (i = 0; i < fusbh200->periodic_size; i++) { |
| p = fusbh200->pshadow [i]; |
| if (likely (!p.ptr)) |
| continue; |
| tag = Q_NEXT_TYPE(fusbh200, fusbh200->periodic [i]); |
| |
| temp = scnprintf (next, size, "%4d: ", i); |
| size -= temp; |
| next += temp; |
| |
| do { |
| struct fusbh200_qh_hw *hw; |
| |
| switch (hc32_to_cpu(fusbh200, tag)) { |
| case Q_TYPE_QH: |
| hw = p.qh->hw; |
| temp = scnprintf (next, size, " qh%d-%04x/%p", |
| p.qh->period, |
| hc32_to_cpup(fusbh200, |
| &hw->hw_info2) |
| /* uframe masks */ |
| & (QH_CMASK | QH_SMASK), |
| p.qh); |
| size -= temp; |
| next += temp; |
| /* don't repeat what follows this qh */ |
| for (temp = 0; temp < seen_count; temp++) { |
| if (seen [temp].ptr != p.ptr) |
| continue; |
| if (p.qh->qh_next.ptr) { |
| temp = scnprintf (next, size, |
| " ..."); |
| size -= temp; |
| next += temp; |
| } |
| break; |
| } |
| /* show more info the first time around */ |
| if (temp == seen_count) { |
| u32 scratch = hc32_to_cpup(fusbh200, |
| &hw->hw_info1); |
| struct fusbh200_qtd *qtd; |
| char *type = ""; |
| |
| /* count tds, get ep direction */ |
| temp = 0; |
| list_for_each_entry (qtd, |
| &p.qh->qtd_list, |
| qtd_list) { |
| temp++; |
| switch (0x03 & (hc32_to_cpu( |
| fusbh200, |
| qtd->hw_token) >> 8)) { |
| case 0: type = "out"; continue; |
| case 1: type = "in"; continue; |
| } |
| } |
| |
| temp = scnprintf (next, size, |
| " (%c%d ep%d%s " |
| "[%d/%d] q%d p%d)", |
| speed_char (scratch), |
| scratch & 0x007f, |
| (scratch >> 8) & 0x000f, type, |
| p.qh->usecs, p.qh->c_usecs, |
| temp, |
| 0x7ff & (scratch >> 16)); |
| |
| if (seen_count < DBG_SCHED_LIMIT) |
| seen [seen_count++].qh = p.qh; |
| } else |
| temp = 0; |
| tag = Q_NEXT_TYPE(fusbh200, hw->hw_next); |
| p = p.qh->qh_next; |
| break; |
| case Q_TYPE_FSTN: |
| temp = scnprintf (next, size, |
| " fstn-%8x/%p", p.fstn->hw_prev, |
| p.fstn); |
| tag = Q_NEXT_TYPE(fusbh200, p.fstn->hw_next); |
| p = p.fstn->fstn_next; |
| break; |
| case Q_TYPE_ITD: |
| temp = scnprintf (next, size, |
| " itd/%p", p.itd); |
| tag = Q_NEXT_TYPE(fusbh200, p.itd->hw_next); |
| p = p.itd->itd_next; |
| break; |
| } |
| size -= temp; |
| next += temp; |
| } while (p.ptr); |
| |
| temp = scnprintf (next, size, "\n"); |
| size -= temp; |
| next += temp; |
| } |
| spin_unlock_irqrestore (&fusbh200->lock, flags); |
| kfree (seen); |
| |
| return buf->alloc_size - size; |
| } |
| #undef DBG_SCHED_LIMIT |
| |
| static const char *rh_state_string(struct fusbh200_hcd *fusbh200) |
| { |
| switch (fusbh200->rh_state) { |
| case FUSBH200_RH_HALTED: |
| return "halted"; |
| case FUSBH200_RH_SUSPENDED: |
| return "suspended"; |
| case FUSBH200_RH_RUNNING: |
| return "running"; |
| case FUSBH200_RH_STOPPING: |
| return "stopping"; |
| } |
| return "?"; |
| } |
| |
| static ssize_t fill_registers_buffer(struct debug_buffer *buf) |
| { |
| struct usb_hcd *hcd; |
| struct fusbh200_hcd *fusbh200; |
| unsigned long flags; |
| unsigned temp, size, i; |
| char *next, scratch [80]; |
| static char fmt [] = "%*s\n"; |
| static char label [] = ""; |
| |
| hcd = bus_to_hcd(buf->bus); |
| fusbh200 = hcd_to_fusbh200 (hcd); |
| next = buf->output_buf; |
| size = buf->alloc_size; |
| |
| spin_lock_irqsave (&fusbh200->lock, flags); |
| |
| if (!HCD_HW_ACCESSIBLE(hcd)) { |
| size = scnprintf (next, size, |
| "bus %s, device %s\n" |
| "%s\n" |
| "SUSPENDED (no register access)\n", |
| hcd->self.controller->bus->name, |
| dev_name(hcd->self.controller), |
| hcd->product_desc); |
| goto done; |
| } |
| |
| /* Capability Registers */ |
| i = HC_VERSION(fusbh200, fusbh200_readl(fusbh200, &fusbh200->caps->hc_capbase)); |
| temp = scnprintf (next, size, |
| "bus %s, device %s\n" |
| "%s\n" |
| "EHCI %x.%02x, rh state %s\n", |
| hcd->self.controller->bus->name, |
| dev_name(hcd->self.controller), |
| hcd->product_desc, |
| i >> 8, i & 0x0ff, rh_state_string(fusbh200)); |
| size -= temp; |
| next += temp; |
| |
| // FIXME interpret both types of params |
| i = fusbh200_readl(fusbh200, &fusbh200->caps->hcs_params); |
| temp = scnprintf (next, size, "structural params 0x%08x\n", i); |
| size -= temp; |
| next += temp; |
| |
| i = fusbh200_readl(fusbh200, &fusbh200->caps->hcc_params); |
| temp = scnprintf (next, size, "capability params 0x%08x\n", i); |
| size -= temp; |
| next += temp; |
| |
| /* Operational Registers */ |
| temp = dbg_status_buf (scratch, sizeof scratch, label, |
| fusbh200_readl(fusbh200, &fusbh200->regs->status)); |
| temp = scnprintf (next, size, fmt, temp, scratch); |
| size -= temp; |
| next += temp; |
| |
| temp = dbg_command_buf (scratch, sizeof scratch, label, |
| fusbh200_readl(fusbh200, &fusbh200->regs->command)); |
| temp = scnprintf (next, size, fmt, temp, scratch); |
| size -= temp; |
| next += temp; |
| |
| temp = dbg_intr_buf (scratch, sizeof scratch, label, |
| fusbh200_readl(fusbh200, &fusbh200->regs->intr_enable)); |
| temp = scnprintf (next, size, fmt, temp, scratch); |
| size -= temp; |
| next += temp; |
| |
| temp = scnprintf (next, size, "uframe %04x\n", |
| fusbh200_read_frame_index(fusbh200)); |
| size -= temp; |
| next += temp; |
| |
| if (fusbh200->async_unlink) { |
| temp = scnprintf(next, size, "async unlink qh %p\n", |
| fusbh200->async_unlink); |
| size -= temp; |
| next += temp; |
| } |
| |
| temp = scnprintf (next, size, |
| "irq normal %ld err %ld iaa %ld (lost %ld)\n", |
| fusbh200->stats.normal, fusbh200->stats.error, fusbh200->stats.iaa, |
| fusbh200->stats.lost_iaa); |
| size -= temp; |
| next += temp; |
| |
| temp = scnprintf (next, size, "complete %ld unlink %ld\n", |
| fusbh200->stats.complete, fusbh200->stats.unlink); |
| size -= temp; |
| next += temp; |
| |
| done: |
| spin_unlock_irqrestore (&fusbh200->lock, flags); |
| |
| return buf->alloc_size - size; |
| } |
| |
| static struct debug_buffer *alloc_buffer(struct usb_bus *bus, |
| ssize_t (*fill_func)(struct debug_buffer *)) |
| { |
| struct debug_buffer *buf; |
| |
| buf = kzalloc(sizeof(struct debug_buffer), GFP_KERNEL); |
| |
| if (buf) { |
| buf->bus = bus; |
| buf->fill_func = fill_func; |
| mutex_init(&buf->mutex); |
| buf->alloc_size = PAGE_SIZE; |
| } |
| |
| return buf; |
| } |
| |
| static int fill_buffer(struct debug_buffer *buf) |
| { |
| int ret = 0; |
| |
| if (!buf->output_buf) |
| buf->output_buf = vmalloc(buf->alloc_size); |
| |
| if (!buf->output_buf) { |
| ret = -ENOMEM; |
| goto out; |
| } |
| |
| ret = buf->fill_func(buf); |
| |
| if (ret >= 0) { |
| buf->count = ret; |
| ret = 0; |
| } |
| |
| out: |
| return ret; |
| } |
| |
| static ssize_t debug_output(struct file *file, char __user *user_buf, |
| size_t len, loff_t *offset) |
| { |
| struct debug_buffer *buf = file->private_data; |
| int ret = 0; |
| |
| mutex_lock(&buf->mutex); |
| if (buf->count == 0) { |
| ret = fill_buffer(buf); |
| if (ret != 0) { |
| mutex_unlock(&buf->mutex); |
| goto out; |
| } |
| } |
| mutex_unlock(&buf->mutex); |
| |
| ret = simple_read_from_buffer(user_buf, len, offset, |
| buf->output_buf, buf->count); |
| |
| out: |
| return ret; |
| |
| } |
| |
| static int debug_close(struct inode *inode, struct file *file) |
| { |
| struct debug_buffer *buf = file->private_data; |
| |
| if (buf) { |
| vfree(buf->output_buf); |
| kfree(buf); |
| } |
| |
| return 0; |
| } |
| static int debug_async_open(struct inode *inode, struct file *file) |
| { |
| file->private_data = alloc_buffer(inode->i_private, fill_async_buffer); |
| |
| return file->private_data ? 0 : -ENOMEM; |
| } |
| |
| static int debug_periodic_open(struct inode *inode, struct file *file) |
| { |
| struct debug_buffer *buf; |
| buf = alloc_buffer(inode->i_private, fill_periodic_buffer); |
| if (!buf) |
| return -ENOMEM; |
| |
| buf->alloc_size = (sizeof(void *) == 4 ? 6 : 8)*PAGE_SIZE; |
| file->private_data = buf; |
| return 0; |
| } |
| |
| static int debug_registers_open(struct inode *inode, struct file *file) |
| { |
| file->private_data = alloc_buffer(inode->i_private, |
| fill_registers_buffer); |
| |
| return file->private_data ? 0 : -ENOMEM; |
| } |
| |
| static inline void create_debug_files (struct fusbh200_hcd *fusbh200) |
| { |
| struct usb_bus *bus = &fusbh200_to_hcd(fusbh200)->self; |
| |
| fusbh200->debug_dir = debugfs_create_dir(bus->bus_name, fusbh200_debug_root); |
| if (!fusbh200->debug_dir) |
| return; |
| |
| if (!debugfs_create_file("async", S_IRUGO, fusbh200->debug_dir, bus, |
| &debug_async_fops)) |
| goto file_error; |
| |
| if (!debugfs_create_file("periodic", S_IRUGO, fusbh200->debug_dir, bus, |
| &debug_periodic_fops)) |
| goto file_error; |
| |
| if (!debugfs_create_file("registers", S_IRUGO, fusbh200->debug_dir, bus, |
| &debug_registers_fops)) |
| goto file_error; |
| |
| return; |
| |
| file_error: |
| debugfs_remove_recursive(fusbh200->debug_dir); |
| } |
| |
| static inline void remove_debug_files (struct fusbh200_hcd *fusbh200) |
| { |
| debugfs_remove_recursive(fusbh200->debug_dir); |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* |
| * handshake - spin reading hc until handshake completes or fails |
| * @ptr: address of hc register to be read |
| * @mask: bits to look at in result of read |
| * @done: value of those bits when handshake succeeds |
| * @usec: timeout in microseconds |
| * |
| * Returns negative errno, or zero on success |
| * |
| * Success happens when the "mask" bits have the specified value (hardware |
| * handshake done). There are two failure modes: "usec" have passed (major |
| * hardware flakeout), or the register reads as all-ones (hardware removed). |
| * |
| * That last failure should_only happen in cases like physical cardbus eject |
| * before driver shutdown. But it also seems to be caused by bugs in cardbus |
| * bridge shutdown: shutting down the bridge before the devices using it. |
| */ |
| static int handshake (struct fusbh200_hcd *fusbh200, void __iomem *ptr, |
| u32 mask, u32 done, int usec) |
| { |
| u32 result; |
| |
| do { |
| result = fusbh200_readl(fusbh200, ptr); |
| if (result == ~(u32)0) /* card removed */ |
| return -ENODEV; |
| result &= mask; |
| if (result == done) |
| return 0; |
| udelay (1); |
| usec--; |
| } while (usec > 0); |
| return -ETIMEDOUT; |
| } |
| |
| /* |
| * Force HC to halt state from unknown (EHCI spec section 2.3). |
| * Must be called with interrupts enabled and the lock not held. |
| */ |
| static int fusbh200_halt (struct fusbh200_hcd *fusbh200) |
| { |
| u32 temp; |
| |
| spin_lock_irq(&fusbh200->lock); |
| |
| /* disable any irqs left enabled by previous code */ |
| fusbh200_writel(fusbh200, 0, &fusbh200->regs->intr_enable); |
| |
| /* |
| * This routine gets called during probe before fusbh200->command |
| * has been initialized, so we can't rely on its value. |
| */ |
| fusbh200->command &= ~CMD_RUN; |
| temp = fusbh200_readl(fusbh200, &fusbh200->regs->command); |
| temp &= ~(CMD_RUN | CMD_IAAD); |
| fusbh200_writel(fusbh200, temp, &fusbh200->regs->command); |
| |
| spin_unlock_irq(&fusbh200->lock); |
| synchronize_irq(fusbh200_to_hcd(fusbh200)->irq); |
| |
| return handshake(fusbh200, &fusbh200->regs->status, |
| STS_HALT, STS_HALT, 16 * 125); |
| } |
| |
| /* |
| * Reset a non-running (STS_HALT == 1) controller. |
| * Must be called with interrupts enabled and the lock not held. |
| */ |
| static int fusbh200_reset (struct fusbh200_hcd *fusbh200) |
| { |
| int retval; |
| u32 command = fusbh200_readl(fusbh200, &fusbh200->regs->command); |
| |
| /* If the EHCI debug controller is active, special care must be |
| * taken before and after a host controller reset */ |
| if (fusbh200->debug && !dbgp_reset_prep(fusbh200_to_hcd(fusbh200))) |
| fusbh200->debug = NULL; |
| |
| command |= CMD_RESET; |
| dbg_cmd (fusbh200, "reset", command); |
| fusbh200_writel(fusbh200, command, &fusbh200->regs->command); |
| fusbh200->rh_state = FUSBH200_RH_HALTED; |
| fusbh200->next_statechange = jiffies; |
| retval = handshake (fusbh200, &fusbh200->regs->command, |
| CMD_RESET, 0, 250 * 1000); |
| |
| if (retval) |
| return retval; |
| |
| if (fusbh200->debug) |
| dbgp_external_startup(fusbh200_to_hcd(fusbh200)); |
| |
| fusbh200->port_c_suspend = fusbh200->suspended_ports = |
| fusbh200->resuming_ports = 0; |
| return retval; |
| } |
| |
| /* |
| * Idle the controller (turn off the schedules). |
| * Must be called with interrupts enabled and the lock not held. |
| */ |
| static void fusbh200_quiesce (struct fusbh200_hcd *fusbh200) |
| { |
| u32 temp; |
| |
| if (fusbh200->rh_state != FUSBH200_RH_RUNNING) |
| return; |
| |
| /* wait for any schedule enables/disables to take effect */ |
| temp = (fusbh200->command << 10) & (STS_ASS | STS_PSS); |
| handshake(fusbh200, &fusbh200->regs->status, STS_ASS | STS_PSS, temp, 16 * 125); |
| |
| /* then disable anything that's still active */ |
| spin_lock_irq(&fusbh200->lock); |
| fusbh200->command &= ~(CMD_ASE | CMD_PSE); |
| fusbh200_writel(fusbh200, fusbh200->command, &fusbh200->regs->command); |
| spin_unlock_irq(&fusbh200->lock); |
| |
| /* hardware can take 16 microframes to turn off ... */ |
| handshake(fusbh200, &fusbh200->regs->status, STS_ASS | STS_PSS, 0, 16 * 125); |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| static void end_unlink_async(struct fusbh200_hcd *fusbh200); |
| static void unlink_empty_async(struct fusbh200_hcd *fusbh200); |
| static void fusbh200_work(struct fusbh200_hcd *fusbh200); |
| static void start_unlink_intr(struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh); |
| static void end_unlink_intr(struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh); |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* Set a bit in the USBCMD register */ |
| static void fusbh200_set_command_bit(struct fusbh200_hcd *fusbh200, u32 bit) |
| { |
| fusbh200->command |= bit; |
| fusbh200_writel(fusbh200, fusbh200->command, &fusbh200->regs->command); |
| |
| /* unblock posted write */ |
| fusbh200_readl(fusbh200, &fusbh200->regs->command); |
| } |
| |
| /* Clear a bit in the USBCMD register */ |
| static void fusbh200_clear_command_bit(struct fusbh200_hcd *fusbh200, u32 bit) |
| { |
| fusbh200->command &= ~bit; |
| fusbh200_writel(fusbh200, fusbh200->command, &fusbh200->regs->command); |
| |
| /* unblock posted write */ |
| fusbh200_readl(fusbh200, &fusbh200->regs->command); |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* |
| * EHCI timer support... Now using hrtimers. |
| * |
| * Lots of different events are triggered from fusbh200->hrtimer. Whenever |
| * the timer routine runs, it checks each possible event; events that are |
| * currently enabled and whose expiration time has passed get handled. |
| * The set of enabled events is stored as a collection of bitflags in |
| * fusbh200->enabled_hrtimer_events, and they are numbered in order of |
| * increasing delay values (ranging between 1 ms and 100 ms). |
| * |
| * Rather than implementing a sorted list or tree of all pending events, |
| * we keep track only of the lowest-numbered pending event, in |
| * fusbh200->next_hrtimer_event. Whenever fusbh200->hrtimer gets restarted, its |
| * expiration time is set to the timeout value for this event. |
| * |
| * As a result, events might not get handled right away; the actual delay |
| * could be anywhere up to twice the requested delay. This doesn't |
| * matter, because none of the events are especially time-critical. The |
| * ones that matter most all have a delay of 1 ms, so they will be |
| * handled after 2 ms at most, which is okay. In addition to this, we |
| * allow for an expiration range of 1 ms. |
| */ |
| |
| /* |
| * Delay lengths for the hrtimer event types. |
| * Keep this list sorted by delay length, in the same order as |
| * the event types indexed by enum fusbh200_hrtimer_event in fusbh200.h. |
| */ |
| static unsigned event_delays_ns[] = { |
| 1 * NSEC_PER_MSEC, /* FUSBH200_HRTIMER_POLL_ASS */ |
| 1 * NSEC_PER_MSEC, /* FUSBH200_HRTIMER_POLL_PSS */ |
| 1 * NSEC_PER_MSEC, /* FUSBH200_HRTIMER_POLL_DEAD */ |
| 1125 * NSEC_PER_USEC, /* FUSBH200_HRTIMER_UNLINK_INTR */ |
| 2 * NSEC_PER_MSEC, /* FUSBH200_HRTIMER_FREE_ITDS */ |
| 6 * NSEC_PER_MSEC, /* FUSBH200_HRTIMER_ASYNC_UNLINKS */ |
| 10 * NSEC_PER_MSEC, /* FUSBH200_HRTIMER_IAA_WATCHDOG */ |
| 10 * NSEC_PER_MSEC, /* FUSBH200_HRTIMER_DISABLE_PERIODIC */ |
| 15 * NSEC_PER_MSEC, /* FUSBH200_HRTIMER_DISABLE_ASYNC */ |
| 100 * NSEC_PER_MSEC, /* FUSBH200_HRTIMER_IO_WATCHDOG */ |
| }; |
| |
| /* Enable a pending hrtimer event */ |
| static void fusbh200_enable_event(struct fusbh200_hcd *fusbh200, unsigned event, |
| bool resched) |
| { |
| ktime_t *timeout = &fusbh200->hr_timeouts[event]; |
| |
| if (resched) |
| *timeout = ktime_add(ktime_get(), |
| ktime_set(0, event_delays_ns[event])); |
| fusbh200->enabled_hrtimer_events |= (1 << event); |
| |
| /* Track only the lowest-numbered pending event */ |
| if (event < fusbh200->next_hrtimer_event) { |
| fusbh200->next_hrtimer_event = event; |
| hrtimer_start_range_ns(&fusbh200->hrtimer, *timeout, |
| NSEC_PER_MSEC, HRTIMER_MODE_ABS); |
| } |
| } |
| |
| |
| /* Poll the STS_ASS status bit; see when it agrees with CMD_ASE */ |
| static void fusbh200_poll_ASS(struct fusbh200_hcd *fusbh200) |
| { |
| unsigned actual, want; |
| |
| /* Don't enable anything if the controller isn't running (e.g., died) */ |
| if (fusbh200->rh_state != FUSBH200_RH_RUNNING) |
| return; |
| |
| want = (fusbh200->command & CMD_ASE) ? STS_ASS : 0; |
| actual = fusbh200_readl(fusbh200, &fusbh200->regs->status) & STS_ASS; |
| |
| if (want != actual) { |
| |
| /* Poll again later, but give up after about 20 ms */ |
| if (fusbh200->ASS_poll_count++ < 20) { |
| fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_POLL_ASS, true); |
| return; |
| } |
| fusbh200_dbg(fusbh200, "Waited too long for the async schedule status (%x/%x), giving up\n", |
| want, actual); |
| } |
| fusbh200->ASS_poll_count = 0; |
| |
| /* The status is up-to-date; restart or stop the schedule as needed */ |
| if (want == 0) { /* Stopped */ |
| if (fusbh200->async_count > 0) |
| fusbh200_set_command_bit(fusbh200, CMD_ASE); |
| |
| } else { /* Running */ |
| if (fusbh200->async_count == 0) { |
| |
| /* Turn off the schedule after a while */ |
| fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_DISABLE_ASYNC, |
| true); |
| } |
| } |
| } |
| |
| /* Turn off the async schedule after a brief delay */ |
| static void fusbh200_disable_ASE(struct fusbh200_hcd *fusbh200) |
| { |
| fusbh200_clear_command_bit(fusbh200, CMD_ASE); |
| } |
| |
| |
| /* Poll the STS_PSS status bit; see when it agrees with CMD_PSE */ |
| static void fusbh200_poll_PSS(struct fusbh200_hcd *fusbh200) |
| { |
| unsigned actual, want; |
| |
| /* Don't do anything if the controller isn't running (e.g., died) */ |
| if (fusbh200->rh_state != FUSBH200_RH_RUNNING) |
| return; |
| |
| want = (fusbh200->command & CMD_PSE) ? STS_PSS : 0; |
| actual = fusbh200_readl(fusbh200, &fusbh200->regs->status) & STS_PSS; |
| |
| if (want != actual) { |
| |
| /* Poll again later, but give up after about 20 ms */ |
| if (fusbh200->PSS_poll_count++ < 20) { |
| fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_POLL_PSS, true); |
| return; |
| } |
| fusbh200_dbg(fusbh200, "Waited too long for the periodic schedule status (%x/%x), giving up\n", |
| want, actual); |
| } |
| fusbh200->PSS_poll_count = 0; |
| |
| /* The status is up-to-date; restart or stop the schedule as needed */ |
| if (want == 0) { /* Stopped */ |
| if (fusbh200->periodic_count > 0) |
| fusbh200_set_command_bit(fusbh200, CMD_PSE); |
| |
| } else { /* Running */ |
| if (fusbh200->periodic_count == 0) { |
| |
| /* Turn off the schedule after a while */ |
| fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_DISABLE_PERIODIC, |
| true); |
| } |
| } |
| } |
| |
| /* Turn off the periodic schedule after a brief delay */ |
| static void fusbh200_disable_PSE(struct fusbh200_hcd *fusbh200) |
| { |
| fusbh200_clear_command_bit(fusbh200, CMD_PSE); |
| } |
| |
| |
| /* Poll the STS_HALT status bit; see when a dead controller stops */ |
| static void fusbh200_handle_controller_death(struct fusbh200_hcd *fusbh200) |
| { |
| if (!(fusbh200_readl(fusbh200, &fusbh200->regs->status) & STS_HALT)) { |
| |
| /* Give up after a few milliseconds */ |
| if (fusbh200->died_poll_count++ < 5) { |
| /* Try again later */ |
| fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_POLL_DEAD, true); |
| return; |
| } |
| fusbh200_warn(fusbh200, "Waited too long for the controller to stop, giving up\n"); |
| } |
| |
| /* Clean up the mess */ |
| fusbh200->rh_state = FUSBH200_RH_HALTED; |
| fusbh200_writel(fusbh200, 0, &fusbh200->regs->intr_enable); |
| fusbh200_work(fusbh200); |
| end_unlink_async(fusbh200); |
| |
| /* Not in process context, so don't try to reset the controller */ |
| } |
| |
| |
| /* Handle unlinked interrupt QHs once they are gone from the hardware */ |
| static void fusbh200_handle_intr_unlinks(struct fusbh200_hcd *fusbh200) |
| { |
| bool stopped = (fusbh200->rh_state < FUSBH200_RH_RUNNING); |
| |
| /* |
| * Process all the QHs on the intr_unlink list that were added |
| * before the current unlink cycle began. The list is in |
| * temporal order, so stop when we reach the first entry in the |
| * current cycle. But if the root hub isn't running then |
| * process all the QHs on the list. |
| */ |
| fusbh200->intr_unlinking = true; |
| while (fusbh200->intr_unlink) { |
| struct fusbh200_qh *qh = fusbh200->intr_unlink; |
| |
| if (!stopped && qh->unlink_cycle == fusbh200->intr_unlink_cycle) |
| break; |
| fusbh200->intr_unlink = qh->unlink_next; |
| qh->unlink_next = NULL; |
| end_unlink_intr(fusbh200, qh); |
| } |
| |
| /* Handle remaining entries later */ |
| if (fusbh200->intr_unlink) { |
| fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_UNLINK_INTR, true); |
| ++fusbh200->intr_unlink_cycle; |
| } |
| fusbh200->intr_unlinking = false; |
| } |
| |
| |
| /* Start another free-iTDs/siTDs cycle */ |
| static void start_free_itds(struct fusbh200_hcd *fusbh200) |
| { |
| if (!(fusbh200->enabled_hrtimer_events & BIT(FUSBH200_HRTIMER_FREE_ITDS))) { |
| fusbh200->last_itd_to_free = list_entry( |
| fusbh200->cached_itd_list.prev, |
| struct fusbh200_itd, itd_list); |
| fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_FREE_ITDS, true); |
| } |
| } |
| |
| /* Wait for controller to stop using old iTDs and siTDs */ |
| static void end_free_itds(struct fusbh200_hcd *fusbh200) |
| { |
| struct fusbh200_itd *itd, *n; |
| |
| if (fusbh200->rh_state < FUSBH200_RH_RUNNING) { |
| fusbh200->last_itd_to_free = NULL; |
| } |
| |
| list_for_each_entry_safe(itd, n, &fusbh200->cached_itd_list, itd_list) { |
| list_del(&itd->itd_list); |
| dma_pool_free(fusbh200->itd_pool, itd, itd->itd_dma); |
| if (itd == fusbh200->last_itd_to_free) |
| break; |
| } |
| |
| if (!list_empty(&fusbh200->cached_itd_list)) |
| start_free_itds(fusbh200); |
| } |
| |
| |
| /* Handle lost (or very late) IAA interrupts */ |
| static void fusbh200_iaa_watchdog(struct fusbh200_hcd *fusbh200) |
| { |
| if (fusbh200->rh_state != FUSBH200_RH_RUNNING) |
| return; |
| |
| /* |
| * Lost IAA irqs wedge things badly; seen first with a vt8235. |
| * So we need this watchdog, but must protect it against both |
| * (a) SMP races against real IAA firing and retriggering, and |
| * (b) clean HC shutdown, when IAA watchdog was pending. |
| */ |
| if (fusbh200->async_iaa) { |
| u32 cmd, status; |
| |
| /* If we get here, IAA is *REALLY* late. It's barely |
| * conceivable that the system is so busy that CMD_IAAD |
| * is still legitimately set, so let's be sure it's |
| * clear before we read STS_IAA. (The HC should clear |
| * CMD_IAAD when it sets STS_IAA.) |
| */ |
| cmd = fusbh200_readl(fusbh200, &fusbh200->regs->command); |
| |
| /* |
| * If IAA is set here it either legitimately triggered |
| * after the watchdog timer expired (_way_ late, so we'll |
| * still count it as lost) ... or a silicon erratum: |
| * - VIA seems to set IAA without triggering the IRQ; |
| * - IAAD potentially cleared without setting IAA. |
| */ |
| status = fusbh200_readl(fusbh200, &fusbh200->regs->status); |
| if ((status & STS_IAA) || !(cmd & CMD_IAAD)) { |
| COUNT(fusbh200->stats.lost_iaa); |
| fusbh200_writel(fusbh200, STS_IAA, &fusbh200->regs->status); |
| } |
| |
| fusbh200_dbg(fusbh200, "IAA watchdog: status %x cmd %x\n", |
| status, cmd); |
| end_unlink_async(fusbh200); |
| } |
| } |
| |
| |
| /* Enable the I/O watchdog, if appropriate */ |
| static void turn_on_io_watchdog(struct fusbh200_hcd *fusbh200) |
| { |
| /* Not needed if the controller isn't running or it's already enabled */ |
| if (fusbh200->rh_state != FUSBH200_RH_RUNNING || |
| (fusbh200->enabled_hrtimer_events & |
| BIT(FUSBH200_HRTIMER_IO_WATCHDOG))) |
| return; |
| |
| /* |
| * Isochronous transfers always need the watchdog. |
| * For other sorts we use it only if the flag is set. |
| */ |
| if (fusbh200->isoc_count > 0 || (fusbh200->need_io_watchdog && |
| fusbh200->async_count + fusbh200->intr_count > 0)) |
| fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_IO_WATCHDOG, true); |
| } |
| |
| |
| /* |
| * Handler functions for the hrtimer event types. |
| * Keep this array in the same order as the event types indexed by |
| * enum fusbh200_hrtimer_event in fusbh200.h. |
| */ |
| static void (*event_handlers[])(struct fusbh200_hcd *) = { |
| fusbh200_poll_ASS, /* FUSBH200_HRTIMER_POLL_ASS */ |
| fusbh200_poll_PSS, /* FUSBH200_HRTIMER_POLL_PSS */ |
| fusbh200_handle_controller_death, /* FUSBH200_HRTIMER_POLL_DEAD */ |
| fusbh200_handle_intr_unlinks, /* FUSBH200_HRTIMER_UNLINK_INTR */ |
| end_free_itds, /* FUSBH200_HRTIMER_FREE_ITDS */ |
| unlink_empty_async, /* FUSBH200_HRTIMER_ASYNC_UNLINKS */ |
| fusbh200_iaa_watchdog, /* FUSBH200_HRTIMER_IAA_WATCHDOG */ |
| fusbh200_disable_PSE, /* FUSBH200_HRTIMER_DISABLE_PERIODIC */ |
| fusbh200_disable_ASE, /* FUSBH200_HRTIMER_DISABLE_ASYNC */ |
| fusbh200_work, /* FUSBH200_HRTIMER_IO_WATCHDOG */ |
| }; |
| |
| static enum hrtimer_restart fusbh200_hrtimer_func(struct hrtimer *t) |
| { |
| struct fusbh200_hcd *fusbh200 = container_of(t, struct fusbh200_hcd, hrtimer); |
| ktime_t now; |
| unsigned long events; |
| unsigned long flags; |
| unsigned e; |
| |
| spin_lock_irqsave(&fusbh200->lock, flags); |
| |
| events = fusbh200->enabled_hrtimer_events; |
| fusbh200->enabled_hrtimer_events = 0; |
| fusbh200->next_hrtimer_event = FUSBH200_HRTIMER_NO_EVENT; |
| |
| /* |
| * Check each pending event. If its time has expired, handle |
| * the event; otherwise re-enable it. |
| */ |
| now = ktime_get(); |
| for_each_set_bit(e, &events, FUSBH200_HRTIMER_NUM_EVENTS) { |
| if (now.tv64 >= fusbh200->hr_timeouts[e].tv64) |
| event_handlers[e](fusbh200); |
| else |
| fusbh200_enable_event(fusbh200, e, false); |
| } |
| |
| spin_unlock_irqrestore(&fusbh200->lock, flags); |
| return HRTIMER_NORESTART; |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| #define fusbh200_bus_suspend NULL |
| #define fusbh200_bus_resume NULL |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| static int check_reset_complete ( |
| struct fusbh200_hcd *fusbh200, |
| int index, |
| u32 __iomem *status_reg, |
| int port_status |
| ) { |
| if (!(port_status & PORT_CONNECT)) |
| return port_status; |
| |
| /* if reset finished and it's still not enabled -- handoff */ |
| if (!(port_status & PORT_PE)) { |
| /* with integrated TT, there's nobody to hand it to! */ |
| fusbh200_dbg (fusbh200, |
| "Failed to enable port %d on root hub TT\n", |
| index+1); |
| return port_status; |
| } else { |
| fusbh200_dbg(fusbh200, "port %d reset complete, port enabled\n", |
| index + 1); |
| } |
| |
| return port_status; |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| |
| /* build "status change" packet (one or two bytes) from HC registers */ |
| |
| static int |
| fusbh200_hub_status_data (struct usb_hcd *hcd, char *buf) |
| { |
| struct fusbh200_hcd *fusbh200 = hcd_to_fusbh200 (hcd); |
| u32 temp, status; |
| u32 mask; |
| int retval = 1; |
| unsigned long flags; |
| |
| /* init status to no-changes */ |
| buf [0] = 0; |
| |
| /* Inform the core about resumes-in-progress by returning |
| * a non-zero value even if there are no status changes. |
| */ |
| status = fusbh200->resuming_ports; |
| |
| mask = PORT_CSC | PORT_PEC; |
| // PORT_RESUME from hardware ~= PORT_STAT_C_SUSPEND |
| |
| /* no hub change reports (bit 0) for now (power, ...) */ |
| |
| /* port N changes (bit N)? */ |
| spin_lock_irqsave (&fusbh200->lock, flags); |
| |
| temp = fusbh200_readl(fusbh200, &fusbh200->regs->port_status); |
| |
| /* |
| * Return status information even for ports with OWNER set. |
| * Otherwise khubd wouldn't see the disconnect event when a |
| * high-speed device is switched over to the companion |
| * controller by the user. |
| */ |
| |
| if ((temp & mask) != 0 || test_bit(0, &fusbh200->port_c_suspend) |
| || (fusbh200->reset_done[0] && time_after_eq( |
| jiffies, fusbh200->reset_done[0]))) { |
| buf [0] |= 1 << 1; |
| status = STS_PCD; |
| } |
| /* FIXME autosuspend idle root hubs */ |
| spin_unlock_irqrestore (&fusbh200->lock, flags); |
| return status ? retval : 0; |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| static void |
| fusbh200_hub_descriptor ( |
| struct fusbh200_hcd *fusbh200, |
| struct usb_hub_descriptor *desc |
| ) { |
| int ports = HCS_N_PORTS (fusbh200->hcs_params); |
| u16 temp; |
| |
| desc->bDescriptorType = 0x29; |
| desc->bPwrOn2PwrGood = 10; /* fusbh200 1.0, 2.3.9 says 20ms max */ |
| desc->bHubContrCurrent = 0; |
| |
| desc->bNbrPorts = ports; |
| temp = 1 + (ports / 8); |
| desc->bDescLength = 7 + 2 * temp; |
| |
| /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */ |
| memset(&desc->u.hs.DeviceRemovable[0], 0, temp); |
| memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp); |
| |
| temp = 0x0008; /* per-port overcurrent reporting */ |
| temp |= 0x0002; /* no power switching */ |
| desc->wHubCharacteristics = cpu_to_le16(temp); |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| static int fusbh200_hub_control ( |
| struct usb_hcd *hcd, |
| u16 typeReq, |
| u16 wValue, |
| u16 wIndex, |
| char *buf, |
| u16 wLength |
| ) { |
| struct fusbh200_hcd *fusbh200 = hcd_to_fusbh200 (hcd); |
| int ports = HCS_N_PORTS (fusbh200->hcs_params); |
| u32 __iomem *status_reg = &fusbh200->regs->port_status; |
| u32 temp, temp1, status; |
| unsigned long flags; |
| int retval = 0; |
| unsigned selector; |
| |
| /* |
| * FIXME: support SetPortFeatures USB_PORT_FEAT_INDICATOR. |
| * HCS_INDICATOR may say we can change LEDs to off/amber/green. |
| * (track current state ourselves) ... blink for diagnostics, |
| * power, "this is the one", etc. EHCI spec supports this. |
| */ |
| |
| spin_lock_irqsave (&fusbh200->lock, flags); |
| switch (typeReq) { |
| case ClearHubFeature: |
| switch (wValue) { |
| case C_HUB_LOCAL_POWER: |
| case C_HUB_OVER_CURRENT: |
| /* no hub-wide feature/status flags */ |
| break; |
| default: |
| goto error; |
| } |
| break; |
| case ClearPortFeature: |
| if (!wIndex || wIndex > ports) |
| goto error; |
| wIndex--; |
| temp = fusbh200_readl(fusbh200, status_reg); |
| temp &= ~PORT_RWC_BITS; |
| |
| /* |
| * Even if OWNER is set, so the port is owned by the |
| * companion controller, khubd needs to be able to clear |
| * the port-change status bits (especially |
| * USB_PORT_STAT_C_CONNECTION). |
| */ |
| |
| switch (wValue) { |
| case USB_PORT_FEAT_ENABLE: |
| fusbh200_writel(fusbh200, temp & ~PORT_PE, status_reg); |
| break; |
| case USB_PORT_FEAT_C_ENABLE: |
| fusbh200_writel(fusbh200, temp | PORT_PEC, status_reg); |
| break; |
| case USB_PORT_FEAT_SUSPEND: |
| if (temp & PORT_RESET) |
| goto error; |
| if (!(temp & PORT_SUSPEND)) |
| break; |
| if ((temp & PORT_PE) == 0) |
| goto error; |
| |
| /* resume signaling for 20 msec */ |
| fusbh200_writel(fusbh200, temp | PORT_RESUME, status_reg); |
| fusbh200->reset_done[wIndex] = jiffies |
| + msecs_to_jiffies(20); |
| break; |
| case USB_PORT_FEAT_C_SUSPEND: |
| clear_bit(wIndex, &fusbh200->port_c_suspend); |
| break; |
| case USB_PORT_FEAT_C_CONNECTION: |
| fusbh200_writel(fusbh200, temp | PORT_CSC, status_reg); |
| break; |
| case USB_PORT_FEAT_C_OVER_CURRENT: |
| fusbh200_writel(fusbh200, temp | BMISR_OVC, &fusbh200->regs->bmisr); |
| break; |
| case USB_PORT_FEAT_C_RESET: |
| /* GetPortStatus clears reset */ |
| break; |
| default: |
| goto error; |
| } |
| fusbh200_readl(fusbh200, &fusbh200->regs->command); /* unblock posted write */ |
| break; |
| case GetHubDescriptor: |
| fusbh200_hub_descriptor (fusbh200, (struct usb_hub_descriptor *) |
| buf); |
| break; |
| case GetHubStatus: |
| /* no hub-wide feature/status flags */ |
| memset (buf, 0, 4); |
| //cpu_to_le32s ((u32 *) buf); |
| break; |
| case GetPortStatus: |
| if (!wIndex || wIndex > ports) |
| goto error; |
| wIndex--; |
| status = 0; |
| temp = fusbh200_readl(fusbh200, status_reg); |
| |
| // wPortChange bits |
| if (temp & PORT_CSC) |
| status |= USB_PORT_STAT_C_CONNECTION << 16; |
| if (temp & PORT_PEC) |
| status |= USB_PORT_STAT_C_ENABLE << 16; |
| |
| temp1 = fusbh200_readl(fusbh200, &fusbh200->regs->bmisr); |
| if (temp1 & BMISR_OVC) |
| status |= USB_PORT_STAT_C_OVERCURRENT << 16; |
| |
| /* whoever resumes must GetPortStatus to complete it!! */ |
| if (temp & PORT_RESUME) { |
| |
| /* Remote Wakeup received? */ |
| if (!fusbh200->reset_done[wIndex]) { |
| /* resume signaling for 20 msec */ |
| fusbh200->reset_done[wIndex] = jiffies |
| + msecs_to_jiffies(20); |
| /* check the port again */ |
| mod_timer(&fusbh200_to_hcd(fusbh200)->rh_timer, |
| fusbh200->reset_done[wIndex]); |
| } |
| |
| /* resume completed? */ |
| else if (time_after_eq(jiffies, |
| fusbh200->reset_done[wIndex])) { |
| clear_bit(wIndex, &fusbh200->suspended_ports); |
| set_bit(wIndex, &fusbh200->port_c_suspend); |
| fusbh200->reset_done[wIndex] = 0; |
| |
| /* stop resume signaling */ |
| temp = fusbh200_readl(fusbh200, status_reg); |
| fusbh200_writel(fusbh200, |
| temp & ~(PORT_RWC_BITS | PORT_RESUME), |
| status_reg); |
| clear_bit(wIndex, &fusbh200->resuming_ports); |
| retval = handshake(fusbh200, status_reg, |
| PORT_RESUME, 0, 2000 /* 2msec */); |
| if (retval != 0) { |
| fusbh200_err(fusbh200, |
| "port %d resume error %d\n", |
| wIndex + 1, retval); |
| goto error; |
| } |
| temp &= ~(PORT_SUSPEND|PORT_RESUME|(3<<10)); |
| } |
| } |
| |
| /* whoever resets must GetPortStatus to complete it!! */ |
| if ((temp & PORT_RESET) |
| && time_after_eq(jiffies, |
| fusbh200->reset_done[wIndex])) { |
| status |= USB_PORT_STAT_C_RESET << 16; |
| fusbh200->reset_done [wIndex] = 0; |
| clear_bit(wIndex, &fusbh200->resuming_ports); |
| |
| /* force reset to complete */ |
| fusbh200_writel(fusbh200, temp & ~(PORT_RWC_BITS | PORT_RESET), |
| status_reg); |
| /* REVISIT: some hardware needs 550+ usec to clear |
| * this bit; seems too long to spin routinely... |
| */ |
| retval = handshake(fusbh200, status_reg, |
| PORT_RESET, 0, 1000); |
| if (retval != 0) { |
| fusbh200_err (fusbh200, "port %d reset error %d\n", |
| wIndex + 1, retval); |
| goto error; |
| } |
| |
| /* see what we found out */ |
| temp = check_reset_complete (fusbh200, wIndex, status_reg, |
| fusbh200_readl(fusbh200, status_reg)); |
| } |
| |
| if (!(temp & (PORT_RESUME|PORT_RESET))) { |
| fusbh200->reset_done[wIndex] = 0; |
| clear_bit(wIndex, &fusbh200->resuming_ports); |
| } |
| |
| /* transfer dedicated ports to the companion hc */ |
| if ((temp & PORT_CONNECT) && |
| test_bit(wIndex, &fusbh200->companion_ports)) { |
| temp &= ~PORT_RWC_BITS; |
| fusbh200_writel(fusbh200, temp, status_reg); |
| fusbh200_dbg(fusbh200, "port %d --> companion\n", wIndex + 1); |
| temp = fusbh200_readl(fusbh200, status_reg); |
| } |
| |
| /* |
| * Even if OWNER is set, there's no harm letting khubd |
| * see the wPortStatus values (they should all be 0 except |
| * for PORT_POWER anyway). |
| */ |
| |
| if (temp & PORT_CONNECT) { |
| status |= USB_PORT_STAT_CONNECTION; |
| status |= fusbh200_port_speed(fusbh200, temp); |
| } |
| if (temp & PORT_PE) |
| status |= USB_PORT_STAT_ENABLE; |
| |
| /* maybe the port was unsuspended without our knowledge */ |
| if (temp & (PORT_SUSPEND|PORT_RESUME)) { |
| status |= USB_PORT_STAT_SUSPEND; |
| } else if (test_bit(wIndex, &fusbh200->suspended_ports)) { |
| clear_bit(wIndex, &fusbh200->suspended_ports); |
| clear_bit(wIndex, &fusbh200->resuming_ports); |
| fusbh200->reset_done[wIndex] = 0; |
| if (temp & PORT_PE) |
| set_bit(wIndex, &fusbh200->port_c_suspend); |
| } |
| |
| temp1 = fusbh200_readl(fusbh200, &fusbh200->regs->bmisr); |
| if (temp1 & BMISR_OVC) |
| status |= USB_PORT_STAT_OVERCURRENT; |
| if (temp & PORT_RESET) |
| status |= USB_PORT_STAT_RESET; |
| if (test_bit(wIndex, &fusbh200->port_c_suspend)) |
| status |= USB_PORT_STAT_C_SUSPEND << 16; |
| |
| if (status & ~0xffff) /* only if wPortChange is interesting */ |
| dbg_port(fusbh200, "GetStatus", wIndex + 1, temp); |
| put_unaligned_le32(status, buf); |
| break; |
| case SetHubFeature: |
| switch (wValue) { |
| case C_HUB_LOCAL_POWER: |
| case C_HUB_OVER_CURRENT: |
| /* no hub-wide feature/status flags */ |
| break; |
| default: |
| goto error; |
| } |
| break; |
| case SetPortFeature: |
| selector = wIndex >> 8; |
| wIndex &= 0xff; |
| |
| if (!wIndex || wIndex > ports) |
| goto error; |
| wIndex--; |
| temp = fusbh200_readl(fusbh200, status_reg); |
| temp &= ~PORT_RWC_BITS; |
| switch (wValue) { |
| case USB_PORT_FEAT_SUSPEND: |
| if ((temp & PORT_PE) == 0 |
| || (temp & PORT_RESET) != 0) |
| goto error; |
| |
| /* After above check the port must be connected. |
| * Set appropriate bit thus could put phy into low power |
| * mode if we have hostpc feature |
| */ |
| fusbh200_writel(fusbh200, temp | PORT_SUSPEND, status_reg); |
| set_bit(wIndex, &fusbh200->suspended_ports); |
| break; |
| case USB_PORT_FEAT_RESET: |
| if (temp & PORT_RESUME) |
| goto error; |
| /* line status bits may report this as low speed, |
| * which can be fine if this root hub has a |
| * transaction translator built in. |
| */ |
| fusbh200_dbg(fusbh200, "port %d reset\n", wIndex + 1); |
| temp |= PORT_RESET; |
| temp &= ~PORT_PE; |
| |
| /* |
| * caller must wait, then call GetPortStatus |
| * usb 2.0 spec says 50 ms resets on root |
| */ |
| fusbh200->reset_done [wIndex] = jiffies |
| + msecs_to_jiffies (50); |
| fusbh200_writel(fusbh200, temp, status_reg); |
| break; |
| |
| /* For downstream facing ports (these): one hub port is put |
| * into test mode according to USB2 11.24.2.13, then the hub |
| * must be reset (which for root hub now means rmmod+modprobe, |
| * or else system reboot). See EHCI 2.3.9 and 4.14 for info |
| * about the EHCI-specific stuff. |
| */ |
| case USB_PORT_FEAT_TEST: |
| if (!selector || selector > 5) |
| goto error; |
| spin_unlock_irqrestore(&fusbh200->lock, flags); |
| fusbh200_quiesce(fusbh200); |
| spin_lock_irqsave(&fusbh200->lock, flags); |
| |
| /* Put all enabled ports into suspend */ |
| temp = fusbh200_readl(fusbh200, status_reg) & ~PORT_RWC_BITS; |
| if (temp & PORT_PE) |
| fusbh200_writel(fusbh200, temp | PORT_SUSPEND, |
| status_reg); |
| |
| spin_unlock_irqrestore(&fusbh200->lock, flags); |
| fusbh200_halt(fusbh200); |
| spin_lock_irqsave(&fusbh200->lock, flags); |
| |
| temp = fusbh200_readl(fusbh200, status_reg); |
| temp |= selector << 16; |
| fusbh200_writel(fusbh200, temp, status_reg); |
| break; |
| |
| default: |
| goto error; |
| } |
| fusbh200_readl(fusbh200, &fusbh200->regs->command); /* unblock posted writes */ |
| break; |
| |
| default: |
| error: |
| /* "stall" on error */ |
| retval = -EPIPE; |
| } |
| spin_unlock_irqrestore (&fusbh200->lock, flags); |
| return retval; |
| } |
| |
| static void __maybe_unused fusbh200_relinquish_port(struct usb_hcd *hcd, |
| int portnum) |
| { |
| return; |
| } |
| |
| static int __maybe_unused fusbh200_port_handed_over(struct usb_hcd *hcd, |
| int portnum) |
| { |
| return 0; |
| } |
| /*-------------------------------------------------------------------------*/ |
| /* |
| * There's basically three types of memory: |
| * - data used only by the HCD ... kmalloc is fine |
| * - async and periodic schedules, shared by HC and HCD ... these |
| * need to use dma_pool or dma_alloc_coherent |
| * - driver buffers, read/written by HC ... single shot DMA mapped |
| * |
| * There's also "register" data (e.g. PCI or SOC), which is memory mapped. |
| * No memory seen by this driver is pageable. |
| */ |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* Allocate the key transfer structures from the previously allocated pool */ |
| |
| static inline void fusbh200_qtd_init(struct fusbh200_hcd *fusbh200, struct fusbh200_qtd *qtd, |
| dma_addr_t dma) |
| { |
| memset (qtd, 0, sizeof *qtd); |
| qtd->qtd_dma = dma; |
| qtd->hw_token = cpu_to_hc32(fusbh200, QTD_STS_HALT); |
| qtd->hw_next = FUSBH200_LIST_END(fusbh200); |
| qtd->hw_alt_next = FUSBH200_LIST_END(fusbh200); |
| INIT_LIST_HEAD (&qtd->qtd_list); |
| } |
| |
| static struct fusbh200_qtd *fusbh200_qtd_alloc (struct fusbh200_hcd *fusbh200, gfp_t flags) |
| { |
| struct fusbh200_qtd *qtd; |
| dma_addr_t dma; |
| |
| qtd = dma_pool_alloc (fusbh200->qtd_pool, flags, &dma); |
| if (qtd != NULL) { |
| fusbh200_qtd_init(fusbh200, qtd, dma); |
| } |
| return qtd; |
| } |
| |
| static inline void fusbh200_qtd_free (struct fusbh200_hcd *fusbh200, struct fusbh200_qtd *qtd) |
| { |
| dma_pool_free (fusbh200->qtd_pool, qtd, qtd->qtd_dma); |
| } |
| |
| |
| static void qh_destroy(struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh) |
| { |
| /* clean qtds first, and know this is not linked */ |
| if (!list_empty (&qh->qtd_list) || qh->qh_next.ptr) { |
| fusbh200_dbg (fusbh200, "unused qh not empty!\n"); |
| BUG (); |
| } |
| if (qh->dummy) |
| fusbh200_qtd_free (fusbh200, qh->dummy); |
| dma_pool_free(fusbh200->qh_pool, qh->hw, qh->qh_dma); |
| kfree(qh); |
| } |
| |
| static struct fusbh200_qh *fusbh200_qh_alloc (struct fusbh200_hcd *fusbh200, gfp_t flags) |
| { |
| struct fusbh200_qh *qh; |
| dma_addr_t dma; |
| |
| qh = kzalloc(sizeof *qh, GFP_ATOMIC); |
| if (!qh) |
| goto done; |
| qh->hw = (struct fusbh200_qh_hw *) |
| dma_pool_alloc(fusbh200->qh_pool, flags, &dma); |
| if (!qh->hw) |
| goto fail; |
| memset(qh->hw, 0, sizeof *qh->hw); |
| qh->qh_dma = dma; |
| // INIT_LIST_HEAD (&qh->qh_list); |
| INIT_LIST_HEAD (&qh->qtd_list); |
| |
| /* dummy td enables safe urb queuing */ |
| qh->dummy = fusbh200_qtd_alloc (fusbh200, flags); |
| if (qh->dummy == NULL) { |
| fusbh200_dbg (fusbh200, "no dummy td\n"); |
| goto fail1; |
| } |
| done: |
| return qh; |
| fail1: |
| dma_pool_free(fusbh200->qh_pool, qh->hw, qh->qh_dma); |
| fail: |
| kfree(qh); |
| return NULL; |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* The queue heads and transfer descriptors are managed from pools tied |
| * to each of the "per device" structures. |
| * This is the initialisation and cleanup code. |
| */ |
| |
| static void fusbh200_mem_cleanup (struct fusbh200_hcd *fusbh200) |
| { |
| if (fusbh200->async) |
| qh_destroy(fusbh200, fusbh200->async); |
| fusbh200->async = NULL; |
| |
| if (fusbh200->dummy) |
| qh_destroy(fusbh200, fusbh200->dummy); |
| fusbh200->dummy = NULL; |
| |
| /* DMA consistent memory and pools */ |
| if (fusbh200->qtd_pool) |
| dma_pool_destroy (fusbh200->qtd_pool); |
| fusbh200->qtd_pool = NULL; |
| |
| if (fusbh200->qh_pool) { |
| dma_pool_destroy (fusbh200->qh_pool); |
| fusbh200->qh_pool = NULL; |
| } |
| |
| if (fusbh200->itd_pool) |
| dma_pool_destroy (fusbh200->itd_pool); |
| fusbh200->itd_pool = NULL; |
| |
| if (fusbh200->periodic) |
| dma_free_coherent (fusbh200_to_hcd(fusbh200)->self.controller, |
| fusbh200->periodic_size * sizeof (u32), |
| fusbh200->periodic, fusbh200->periodic_dma); |
| fusbh200->periodic = NULL; |
| |
| /* shadow periodic table */ |
| kfree(fusbh200->pshadow); |
| fusbh200->pshadow = NULL; |
| } |
| |
| /* remember to add cleanup code (above) if you add anything here */ |
| static int fusbh200_mem_init (struct fusbh200_hcd *fusbh200, gfp_t flags) |
| { |
| int i; |
| |
| /* QTDs for control/bulk/intr transfers */ |
| fusbh200->qtd_pool = dma_pool_create ("fusbh200_qtd", |
| fusbh200_to_hcd(fusbh200)->self.controller, |
| sizeof (struct fusbh200_qtd), |
| 32 /* byte alignment (for hw parts) */, |
| 4096 /* can't cross 4K */); |
| if (!fusbh200->qtd_pool) { |
| goto fail; |
| } |
| |
| /* QHs for control/bulk/intr transfers */ |
| fusbh200->qh_pool = dma_pool_create ("fusbh200_qh", |
| fusbh200_to_hcd(fusbh200)->self.controller, |
| sizeof(struct fusbh200_qh_hw), |
| 32 /* byte alignment (for hw parts) */, |
| 4096 /* can't cross 4K */); |
| if (!fusbh200->qh_pool) { |
| goto fail; |
| } |
| fusbh200->async = fusbh200_qh_alloc (fusbh200, flags); |
| if (!fusbh200->async) { |
| goto fail; |
| } |
| |
| /* ITD for high speed ISO transfers */ |
| fusbh200->itd_pool = dma_pool_create ("fusbh200_itd", |
| fusbh200_to_hcd(fusbh200)->self.controller, |
| sizeof (struct fusbh200_itd), |
| 64 /* byte alignment (for hw parts) */, |
| 4096 /* can't cross 4K */); |
| if (!fusbh200->itd_pool) { |
| goto fail; |
| } |
| |
| /* Hardware periodic table */ |
| fusbh200->periodic = (__le32 *) |
| dma_alloc_coherent (fusbh200_to_hcd(fusbh200)->self.controller, |
| fusbh200->periodic_size * sizeof(__le32), |
| &fusbh200->periodic_dma, 0); |
| if (fusbh200->periodic == NULL) { |
| goto fail; |
| } |
| |
| for (i = 0; i < fusbh200->periodic_size; i++) |
| fusbh200->periodic[i] = FUSBH200_LIST_END(fusbh200); |
| |
| /* software shadow of hardware table */ |
| fusbh200->pshadow = kcalloc(fusbh200->periodic_size, sizeof(void *), flags); |
| if (fusbh200->pshadow != NULL) |
| return 0; |
| |
| fail: |
| fusbh200_dbg (fusbh200, "couldn't init memory\n"); |
| fusbh200_mem_cleanup (fusbh200); |
| return -ENOMEM; |
| } |
| /*-------------------------------------------------------------------------*/ |
| /* |
| * EHCI hardware queue manipulation ... the core. QH/QTD manipulation. |
| * |
| * Control, bulk, and interrupt traffic all use "qh" lists. They list "qtd" |
| * entries describing USB transactions, max 16-20kB/entry (with 4kB-aligned |
| * buffers needed for the larger number). We use one QH per endpoint, queue |
| * multiple urbs (all three types) per endpoint. URBs may need several qtds. |
| * |
| * ISO traffic uses "ISO TD" (itd) records, and (along with |
| * interrupts) needs careful scheduling. Performance improvements can be |
| * an ongoing challenge. That's in "ehci-sched.c". |
| * |
| * USB 1.1 devices are handled (a) by "companion" OHCI or UHCI root hubs, |
| * or otherwise through transaction translators (TTs) in USB 2.0 hubs using |
| * (b) special fields in qh entries or (c) split iso entries. TTs will |
| * buffer low/full speed data so the host collects it at high speed. |
| */ |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* fill a qtd, returning how much of the buffer we were able to queue up */ |
| |
| static int |
| qtd_fill(struct fusbh200_hcd *fusbh200, struct fusbh200_qtd *qtd, dma_addr_t buf, |
| size_t len, int token, int maxpacket) |
| { |
| int i, count; |
| u64 addr = buf; |
| |
| /* one buffer entry per 4K ... first might be short or unaligned */ |
| qtd->hw_buf[0] = cpu_to_hc32(fusbh200, (u32)addr); |
| qtd->hw_buf_hi[0] = cpu_to_hc32(fusbh200, (u32)(addr >> 32)); |
| count = 0x1000 - (buf & 0x0fff); /* rest of that page */ |
| if (likely (len < count)) /* ... iff needed */ |
| count = len; |
| else { |
| buf += 0x1000; |
| buf &= ~0x0fff; |
| |
| /* per-qtd limit: from 16K to 20K (best alignment) */ |
| for (i = 1; count < len && i < 5; i++) { |
| addr = buf; |
| qtd->hw_buf[i] = cpu_to_hc32(fusbh200, (u32)addr); |
| qtd->hw_buf_hi[i] = cpu_to_hc32(fusbh200, |
| (u32)(addr >> 32)); |
| buf += 0x1000; |
| if ((count + 0x1000) < len) |
| count += 0x1000; |
| else |
| count = len; |
| } |
| |
| /* short packets may only terminate transfers */ |
| if (count != len) |
| count -= (count % maxpacket); |
| } |
| qtd->hw_token = cpu_to_hc32(fusbh200, (count << 16) | token); |
| qtd->length = count; |
| |
| return count; |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| static inline void |
| qh_update (struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh, struct fusbh200_qtd *qtd) |
| { |
| struct fusbh200_qh_hw *hw = qh->hw; |
| |
| /* writes to an active overlay are unsafe */ |
| BUG_ON(qh->qh_state != QH_STATE_IDLE); |
| |
| hw->hw_qtd_next = QTD_NEXT(fusbh200, qtd->qtd_dma); |
| hw->hw_alt_next = FUSBH200_LIST_END(fusbh200); |
| |
| /* Except for control endpoints, we make hardware maintain data |
| * toggle (like OHCI) ... here (re)initialize the toggle in the QH, |
| * and set the pseudo-toggle in udev. Only usb_clear_halt() will |
| * ever clear it. |
| */ |
| if (!(hw->hw_info1 & cpu_to_hc32(fusbh200, QH_TOGGLE_CTL))) { |
| unsigned is_out, epnum; |
| |
| is_out = qh->is_out; |
| epnum = (hc32_to_cpup(fusbh200, &hw->hw_info1) >> 8) & 0x0f; |
| if (unlikely (!usb_gettoggle (qh->dev, epnum, is_out))) { |
| hw->hw_token &= ~cpu_to_hc32(fusbh200, QTD_TOGGLE); |
| usb_settoggle (qh->dev, epnum, is_out, 1); |
| } |
| } |
| |
| hw->hw_token &= cpu_to_hc32(fusbh200, QTD_TOGGLE | QTD_STS_PING); |
| } |
| |
| /* if it weren't for a common silicon quirk (writing the dummy into the qh |
| * overlay, so qh->hw_token wrongly becomes inactive/halted), only fault |
| * recovery (including urb dequeue) would need software changes to a QH... |
| */ |
| static void |
| qh_refresh (struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh) |
| { |
| struct fusbh200_qtd *qtd; |
| |
| if (list_empty (&qh->qtd_list)) |
| qtd = qh->dummy; |
| else { |
| qtd = list_entry (qh->qtd_list.next, |
| struct fusbh200_qtd, qtd_list); |
| /* |
| * first qtd may already be partially processed. |
| * If we come here during unlink, the QH overlay region |
| * might have reference to the just unlinked qtd. The |
| * qtd is updated in qh_completions(). Update the QH |
| * overlay here. |
| */ |
| if (cpu_to_hc32(fusbh200, qtd->qtd_dma) == qh->hw->hw_current) { |
| qh->hw->hw_qtd_next = qtd->hw_next; |
| qtd = NULL; |
| } |
| } |
| |
| if (qtd) |
| qh_update (fusbh200, qh, qtd); |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| static void qh_link_async(struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh); |
| |
| static void fusbh200_clear_tt_buffer_complete(struct usb_hcd *hcd, |
| struct usb_host_endpoint *ep) |
| { |
| struct fusbh200_hcd *fusbh200 = hcd_to_fusbh200(hcd); |
| struct fusbh200_qh *qh = ep->hcpriv; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&fusbh200->lock, flags); |
| qh->clearing_tt = 0; |
| if (qh->qh_state == QH_STATE_IDLE && !list_empty(&qh->qtd_list) |
| && fusbh200->rh_state == FUSBH200_RH_RUNNING) |
| qh_link_async(fusbh200, qh); |
| spin_unlock_irqrestore(&fusbh200->lock, flags); |
| } |
| |
| static void fusbh200_clear_tt_buffer(struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh, |
| struct urb *urb, u32 token) |
| { |
| |
| /* If an async split transaction gets an error or is unlinked, |
| * the TT buffer may be left in an indeterminate state. We |
| * have to clear the TT buffer. |
| * |
| * Note: this routine is never called for Isochronous transfers. |
| */ |
| if (urb->dev->tt && !usb_pipeint(urb->pipe) && !qh->clearing_tt) { |
| struct usb_device *tt = urb->dev->tt->hub; |
| |
| dev_dbg(&tt->dev, |
| "clear tt buffer port %d, a%d ep%d t%08x\n", |
| urb->dev->ttport, urb->dev->devnum, |
| usb_pipeendpoint(urb->pipe), token); |
| |
| if (urb->dev->tt->hub != |
| fusbh200_to_hcd(fusbh200)->self.root_hub) { |
| if (usb_hub_clear_tt_buffer(urb) == 0) |
| qh->clearing_tt = 1; |
| } |
| } |
| } |
| |
| static int qtd_copy_status ( |
| struct fusbh200_hcd *fusbh200, |
| struct urb *urb, |
| size_t length, |
| u32 token |
| ) |
| { |
| int status = -EINPROGRESS; |
| |
| /* count IN/OUT bytes, not SETUP (even short packets) */ |
| if (likely (QTD_PID (token) != 2)) |
| urb->actual_length += length - QTD_LENGTH (token); |
| |
| /* don't modify error codes */ |
| if (unlikely(urb->unlinked)) |
| return status; |
| |
| /* force cleanup after short read; not always an error */ |
| if (unlikely (IS_SHORT_READ (token))) |
| status = -EREMOTEIO; |
| |
| /* serious "can't proceed" faults reported by the hardware */ |
| if (token & QTD_STS_HALT) { |
| if (token & QTD_STS_BABBLE) { |
| /* FIXME "must" disable babbling device's port too */ |
| status = -EOVERFLOW; |
| /* CERR nonzero + halt --> stall */ |
| } else if (QTD_CERR(token)) { |
| status = -EPIPE; |
| |
| /* In theory, more than one of the following bits can be set |
| * since they are sticky and the transaction is retried. |
| * Which to test first is rather arbitrary. |
| */ |
| } else if (token & QTD_STS_MMF) { |
| /* fs/ls interrupt xfer missed the complete-split */ |
| status = -EPROTO; |
| } else if (token & QTD_STS_DBE) { |
| status = (QTD_PID (token) == 1) /* IN ? */ |
| ? -ENOSR /* hc couldn't read data */ |
| : -ECOMM; /* hc couldn't write data */ |
| } else if (token & QTD_STS_XACT) { |
| /* timeout, bad CRC, wrong PID, etc */ |
| fusbh200_dbg(fusbh200, "devpath %s ep%d%s 3strikes\n", |
| urb->dev->devpath, |
| usb_pipeendpoint(urb->pipe), |
| usb_pipein(urb->pipe) ? "in" : "out"); |
| status = -EPROTO; |
| } else { /* unknown */ |
| status = -EPROTO; |
| } |
| |
| fusbh200_dbg(fusbh200, |
| "dev%d ep%d%s qtd token %08x --> status %d\n", |
| usb_pipedevice (urb->pipe), |
| usb_pipeendpoint (urb->pipe), |
| usb_pipein (urb->pipe) ? "in" : "out", |
| token, status); |
| } |
| |
| return status; |
| } |
| |
| static void |
| fusbh200_urb_done(struct fusbh200_hcd *fusbh200, struct urb *urb, int status) |
| __releases(fusbh200->lock) |
| __acquires(fusbh200->lock) |
| { |
| if (likely (urb->hcpriv != NULL)) { |
| struct fusbh200_qh *qh = (struct fusbh200_qh *) urb->hcpriv; |
| |
| /* S-mask in a QH means it's an interrupt urb */ |
| if ((qh->hw->hw_info2 & cpu_to_hc32(fusbh200, QH_SMASK)) != 0) { |
| |
| /* ... update hc-wide periodic stats (for usbfs) */ |
| fusbh200_to_hcd(fusbh200)->self.bandwidth_int_reqs--; |
| } |
| } |
| |
| if (unlikely(urb->unlinked)) { |
| COUNT(fusbh200->stats.unlink); |
| } else { |
| /* report non-error and short read status as zero */ |
| if (status == -EINPROGRESS || status == -EREMOTEIO) |
| status = 0; |
| COUNT(fusbh200->stats.complete); |
| } |
| |
| #ifdef FUSBH200_URB_TRACE |
| fusbh200_dbg (fusbh200, |
| "%s %s urb %p ep%d%s status %d len %d/%d\n", |
| __func__, urb->dev->devpath, urb, |
| usb_pipeendpoint (urb->pipe), |
| usb_pipein (urb->pipe) ? "in" : "out", |
| status, |
| urb->actual_length, urb->transfer_buffer_length); |
| #endif |
| |
| /* complete() can reenter this HCD */ |
| usb_hcd_unlink_urb_from_ep(fusbh200_to_hcd(fusbh200), urb); |
| spin_unlock (&fusbh200->lock); |
| usb_hcd_giveback_urb(fusbh200_to_hcd(fusbh200), urb, status); |
| spin_lock (&fusbh200->lock); |
| } |
| |
| static int qh_schedule (struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh); |
| |
| /* |
| * Process and free completed qtds for a qh, returning URBs to drivers. |
| * Chases up to qh->hw_current. Returns number of completions called, |
| * indicating how much "real" work we did. |
| */ |
| static unsigned |
| qh_completions (struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh) |
| { |
| struct fusbh200_qtd *last, *end = qh->dummy; |
| struct list_head *entry, *tmp; |
| int last_status; |
| int stopped; |
| unsigned count = 0; |
| u8 state; |
| struct fusbh200_qh_hw *hw = qh->hw; |
| |
| if (unlikely (list_empty (&qh->qtd_list))) |
| return count; |
| |
| /* completions (or tasks on other cpus) must never clobber HALT |
| * till we've gone through and cleaned everything up, even when |
| * they add urbs to this qh's queue or mark them for unlinking. |
| * |
| * NOTE: unlinking expects to be done in queue order. |
| * |
| * It's a bug for qh->qh_state to be anything other than |
| * QH_STATE_IDLE, unless our caller is scan_async() or |
| * scan_intr(). |
| */ |
| state = qh->qh_state; |
| qh->qh_state = QH_STATE_COMPLETING; |
| stopped = (state == QH_STATE_IDLE); |
| |
| rescan: |
| last = NULL; |
| last_status = -EINPROGRESS; |
| qh->needs_rescan = 0; |
| |
| /* remove de-activated QTDs from front of queue. |
| * after faults (including short reads), cleanup this urb |
| * then let the queue advance. |
| * if queue is stopped, handles unlinks. |
| */ |
| list_for_each_safe (entry, tmp, &qh->qtd_list) { |
| struct fusbh200_qtd *qtd; |
| struct urb *urb; |
| u32 token = 0; |
| |
| qtd = list_entry (entry, struct fusbh200_qtd, qtd_list); |
| urb = qtd->urb; |
| |
| /* clean up any state from previous QTD ...*/ |
| if (last) { |
| if (likely (last->urb != urb)) { |
| fusbh200_urb_done(fusbh200, last->urb, last_status); |
| count++; |
| last_status = -EINPROGRESS; |
| } |
| fusbh200_qtd_free (fusbh200, last); |
| last = NULL; |
| } |
| |
| /* ignore urbs submitted during completions we reported */ |
| if (qtd == end) |
| break; |
| |
| /* hardware copies qtd out of qh overlay */ |
| rmb (); |
| token = hc32_to_cpu(fusbh200, qtd->hw_token); |
| |
| /* always clean up qtds the hc de-activated */ |
| retry_xacterr: |
| if ((token & QTD_STS_ACTIVE) == 0) { |
| |
| /* Report Data Buffer Error: non-fatal but useful */ |
| if (token & QTD_STS_DBE) |
| fusbh200_dbg(fusbh200, |
| "detected DataBufferErr for urb %p ep%d%s len %d, qtd %p [qh %p]\n", |
| urb, |
| usb_endpoint_num(&urb->ep->desc), |
| usb_endpoint_dir_in(&urb->ep->desc) ? "in" : "out", |
| urb->transfer_buffer_length, |
| qtd, |
| qh); |
| |
| /* on STALL, error, and short reads this urb must |
| * complete and all its qtds must be recycled. |
| */ |
| if ((token & QTD_STS_HALT) != 0) { |
| |
| /* retry transaction errors until we |
| * reach the software xacterr limit |
| */ |
| if ((token & QTD_STS_XACT) && |
| QTD_CERR(token) == 0 && |
| ++qh->xacterrs < QH_XACTERR_MAX && |
| !urb->unlinked) { |
| fusbh200_dbg(fusbh200, |
| "detected XactErr len %zu/%zu retry %d\n", |
| qtd->length - QTD_LENGTH(token), qtd->length, qh->xacterrs); |
| |
| /* reset the token in the qtd and the |
| * qh overlay (which still contains |
| * the qtd) so that we pick up from |
| * where we left off |
| */ |
| token &= ~QTD_STS_HALT; |
| token |= QTD_STS_ACTIVE | |
| (FUSBH200_TUNE_CERR << 10); |
| qtd->hw_token = cpu_to_hc32(fusbh200, |
| token); |
| wmb(); |
| hw->hw_token = cpu_to_hc32(fusbh200, |
| token); |
| goto retry_xacterr; |
| } |
| stopped = 1; |
| |
| /* magic dummy for some short reads; qh won't advance. |
| * that silicon quirk can kick in with this dummy too. |
| * |
| * other short reads won't stop the queue, including |
| * control transfers (status stage handles that) or |
| * most other single-qtd reads ... the queue stops if |
| * URB_SHORT_NOT_OK was set so the driver submitting |
| * the urbs could clean it up. |
| */ |
| } else if (IS_SHORT_READ (token) |
| && !(qtd->hw_alt_next |
| & FUSBH200_LIST_END(fusbh200))) { |
| stopped = 1; |
| } |
| |
| /* stop scanning when we reach qtds the hc is using */ |
| } else if (likely (!stopped |
| && fusbh200->rh_state >= FUSBH200_RH_RUNNING)) { |
| break; |
| |
| /* scan the whole queue for unlinks whenever it stops */ |
| } else { |
| stopped = 1; |
| |
| /* cancel everything if we halt, suspend, etc */ |
| if (fusbh200->rh_state < FUSBH200_RH_RUNNING) |
| last_status = -ESHUTDOWN; |
| |
| /* this qtd is active; skip it unless a previous qtd |
| * for its urb faulted, or its urb was canceled. |
| */ |
| else if (last_status == -EINPROGRESS && !urb->unlinked) |
| continue; |
| |
| /* qh unlinked; token in overlay may be most current */ |
| if (state == QH_STATE_IDLE |
| && cpu_to_hc32(fusbh200, qtd->qtd_dma) |
| == hw->hw_current) { |
| token = hc32_to_cpu(fusbh200, hw->hw_token); |
| |
| /* An unlink may leave an incomplete |
| * async transaction in the TT buffer. |
| * We have to clear it. |
| */ |
| fusbh200_clear_tt_buffer(fusbh200, qh, urb, token); |
| } |
| } |
| |
| /* unless we already know the urb's status, collect qtd status |
| * and update count of bytes transferred. in common short read |
| * cases with only one data qtd (including control transfers), |
| * queue processing won't halt. but with two or more qtds (for |
| * example, with a 32 KB transfer), when the first qtd gets a |
| * short read the second must be removed by hand. |
| */ |
| if (last_status == -EINPROGRESS) { |
| last_status = qtd_copy_status(fusbh200, urb, |
| qtd->length, token); |
| if (last_status == -EREMOTEIO |
| && (qtd->hw_alt_next |
| & FUSBH200_LIST_END(fusbh200))) |
| last_status = -EINPROGRESS; |
| |
| /* As part of low/full-speed endpoint-halt processing |
| * we must clear the TT buffer (11.17.5). |
| */ |
| if (unlikely(last_status != -EINPROGRESS && |
| last_status != -EREMOTEIO)) { |
| /* The TT's in some hubs malfunction when they |
| * receive this request following a STALL (they |
| * stop sending isochronous packets). Since a |
| * STALL can't leave the TT buffer in a busy |
| * state (if you believe Figures 11-48 - 11-51 |
| * in the USB 2.0 spec), we won't clear the TT |
| * buffer in this case. Strictly speaking this |
| * is a violation of the spec. |
| */ |
| if (last_status != -EPIPE) |
| fusbh200_clear_tt_buffer(fusbh200, qh, urb, |
| token); |
| } |
| } |
| |
| /* if we're removing something not at the queue head, |
| * patch the hardware queue pointer. |
| */ |
| if (stopped && qtd->qtd_list.prev != &qh->qtd_list) { |
| last = list_entry (qtd->qtd_list.prev, |
| struct fusbh200_qtd, qtd_list); |
| last->hw_next = qtd->hw_next; |
| } |
| |
| /* remove qtd; it's recycled after possible urb completion */ |
| list_del (&qtd->qtd_list); |
| last = qtd; |
| |
| /* reinit the xacterr counter for the next qtd */ |
| qh->xacterrs = 0; |
| } |
| |
| /* last urb's completion might still need calling */ |
| if (likely (last != NULL)) { |
| fusbh200_urb_done(fusbh200, last->urb, last_status); |
| count++; |
| fusbh200_qtd_free (fusbh200, last); |
| } |
| |
| /* Do we need to rescan for URBs dequeued during a giveback? */ |
| if (unlikely(qh->needs_rescan)) { |
| /* If the QH is already unlinked, do the rescan now. */ |
| if (state == QH_STATE_IDLE) |
| goto rescan; |
| |
| /* Otherwise we have to wait until the QH is fully unlinked. |
| * Our caller will start an unlink if qh->needs_rescan is |
| * set. But if an unlink has already started, nothing needs |
| * to be done. |
| */ |
| if (state != QH_STATE_LINKED) |
| qh->needs_rescan = 0; |
| } |
| |
| /* restore original state; caller must unlink or relink */ |
| qh->qh_state = state; |
| |
| /* be sure the hardware's done with the qh before refreshing |
| * it after fault cleanup, or recovering from silicon wrongly |
| * overlaying the dummy qtd (which reduces DMA chatter). |
| */ |
| if (stopped != 0 || hw->hw_qtd_next == FUSBH200_LIST_END(fusbh200)) { |
| switch (state) { |
| case QH_STATE_IDLE: |
| qh_refresh(fusbh200, qh); |
| break; |
| case QH_STATE_LINKED: |
| /* We won't refresh a QH that's linked (after the HC |
| * stopped the queue). That avoids a race: |
| * - HC reads first part of QH; |
| * - CPU updates that first part and the token; |
| * - HC reads rest of that QH, including token |
| * Result: HC gets an inconsistent image, and then |
| * DMAs to/from the wrong memory (corrupting it). |
| * |
| * That should be rare for interrupt transfers, |
| * except maybe high bandwidth ... |
| */ |
| |
| /* Tell the caller to start an unlink */ |
| qh->needs_rescan = 1; |
| break; |
| /* otherwise, unlink already started */ |
| } |
| } |
| |
| return count; |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| // high bandwidth multiplier, as encoded in highspeed endpoint descriptors |
| #define hb_mult(wMaxPacketSize) (1 + (((wMaxPacketSize) >> 11) & 0x03)) |
| // ... and packet size, for any kind of endpoint descriptor |
| #define max_packet(wMaxPacketSize) ((wMaxPacketSize) & 0x07ff) |
| |
| /* |
| * reverse of qh_urb_transaction: free a list of TDs. |
| * used for cleanup after errors, before HC sees an URB's TDs. |
| */ |
| static void qtd_list_free ( |
| struct fusbh200_hcd *fusbh200, |
| struct urb *urb, |
| struct list_head *qtd_list |
| ) { |
| struct list_head *entry, *temp; |
| |
| list_for_each_safe (entry, temp, qtd_list) { |
| struct fusbh200_qtd *qtd; |
| |
| qtd = list_entry (entry, struct fusbh200_qtd, qtd_list); |
| list_del (&qtd->qtd_list); |
| fusbh200_qtd_free (fusbh200, qtd); |
| } |
| } |
| |
| /* |
| * create a list of filled qtds for this URB; won't link into qh. |
| */ |
| static struct list_head * |
| qh_urb_transaction ( |
| struct fusbh200_hcd *fusbh200, |
| struct urb *urb, |
| struct list_head *head, |
| gfp_t flags |
| ) { |
| struct fusbh200_qtd *qtd, *qtd_prev; |
| dma_addr_t buf; |
| int len, this_sg_len, maxpacket; |
| int is_input; |
| u32 token; |
| int i; |
| struct scatterlist *sg; |
| |
| /* |
| * URBs map to sequences of QTDs: one logical transaction |
| */ |
| qtd = fusbh200_qtd_alloc (fusbh200, flags); |
| if (unlikely (!qtd)) |
| return NULL; |
| list_add_tail (&qtd->qtd_list, head); |
| qtd->urb = urb; |
| |
| token = QTD_STS_ACTIVE; |
| token |= (FUSBH200_TUNE_CERR << 10); |
| /* for split transactions, SplitXState initialized to zero */ |
| |
| len = urb->transfer_buffer_length; |
| is_input = usb_pipein (urb->pipe); |
| if (usb_pipecontrol (urb->pipe)) { |
| /* SETUP pid */ |
| qtd_fill(fusbh200, qtd, urb->setup_dma, |
| sizeof (struct usb_ctrlrequest), |
| token | (2 /* "setup" */ << 8), 8); |
| |
| /* ... and always at least one more pid */ |
| token ^= QTD_TOGGLE; |
| qtd_prev = qtd; |
| qtd = fusbh200_qtd_alloc (fusbh200, flags); |
| if (unlikely (!qtd)) |
| goto cleanup; |
| qtd->urb = urb; |
| qtd_prev->hw_next = QTD_NEXT(fusbh200, qtd->qtd_dma); |
| list_add_tail (&qtd->qtd_list, head); |
| |
| /* for zero length DATA stages, STATUS is always IN */ |
| if (len == 0) |
| token |= (1 /* "in" */ << 8); |
| } |
| |
| /* |
| * data transfer stage: buffer setup |
| */ |
| i = urb->num_mapped_sgs; |
| if (len > 0 && i > 0) { |
| sg = urb->sg; |
| buf = sg_dma_address(sg); |
| |
| /* urb->transfer_buffer_length may be smaller than the |
| * size of the scatterlist (or vice versa) |
| */ |
| this_sg_len = min_t(int, sg_dma_len(sg), len); |
| } else { |
| sg = NULL; |
| buf = urb->transfer_dma; |
| this_sg_len = len; |
| } |
| |
| if (is_input) |
| token |= (1 /* "in" */ << 8); |
| /* else it's already initted to "out" pid (0 << 8) */ |
| |
| maxpacket = max_packet(usb_maxpacket(urb->dev, urb->pipe, !is_input)); |
| |
| /* |
| * buffer gets wrapped in one or more qtds; |
| * last one may be "short" (including zero len) |
| * and may serve as a control status ack |
| */ |
| for (;;) { |
| int this_qtd_len; |
| |
| this_qtd_len = qtd_fill(fusbh200, qtd, buf, this_sg_len, token, |
| maxpacket); |
| this_sg_len -= this_qtd_len; |
| len -= this_qtd_len; |
| buf += this_qtd_len; |
| |
| /* |
| * short reads advance to a "magic" dummy instead of the next |
| * qtd ... that forces the queue to stop, for manual cleanup. |
| * (this will usually be overridden later.) |
| */ |
| if (is_input) |
| qtd->hw_alt_next = fusbh200->async->hw->hw_alt_next; |
| |
| /* qh makes control packets use qtd toggle; maybe switch it */ |
| if ((maxpacket & (this_qtd_len + (maxpacket - 1))) == 0) |
| token ^= QTD_TOGGLE; |
| |
| if (likely(this_sg_len <= 0)) { |
| if (--i <= 0 || len <= 0) |
| break; |
| sg = sg_next(sg); |
| buf = sg_dma_address(sg); |
| this_sg_len = min_t(int, sg_dma_len(sg), len); |
| } |
| |
| qtd_prev = qtd; |
| qtd = fusbh200_qtd_alloc (fusbh200, flags); |
| if (unlikely (!qtd)) |
| goto cleanup; |
| qtd->urb = urb; |
| qtd_prev->hw_next = QTD_NEXT(fusbh200, qtd->qtd_dma); |
| list_add_tail (&qtd->qtd_list, head); |
| } |
| |
| /* |
| * unless the caller requires manual cleanup after short reads, |
| * have the alt_next mechanism keep the queue running after the |
| * last data qtd (the only one, for control and most other cases). |
| */ |
| if (likely ((urb->transfer_flags & URB_SHORT_NOT_OK) == 0 |
| || usb_pipecontrol (urb->pipe))) |
| qtd->hw_alt_next = FUSBH200_LIST_END(fusbh200); |
| |
| /* |
| * control requests may need a terminating data "status" ack; |
| * other OUT ones may need a terminating short packet |
| * (zero length). |
| */ |
| if (likely (urb->transfer_buffer_length != 0)) { |
| int one_more = 0; |
| |
| if (usb_pipecontrol (urb->pipe)) { |
| one_more = 1; |
| token ^= 0x0100; /* "in" <--> "out" */ |
| token |= QTD_TOGGLE; /* force DATA1 */ |
| } else if (usb_pipeout(urb->pipe) |
| && (urb->transfer_flags & URB_ZERO_PACKET) |
| && !(urb->transfer_buffer_length % maxpacket)) { |
| one_more = 1; |
| } |
| if (one_more) { |
| qtd_prev = qtd; |
| qtd = fusbh200_qtd_alloc (fusbh200, flags); |
| if (unlikely (!qtd)) |
| goto cleanup; |
| qtd->urb = urb; |
| qtd_prev->hw_next = QTD_NEXT(fusbh200, qtd->qtd_dma); |
| list_add_tail (&qtd->qtd_list, head); |
| |
| /* never any data in such packets */ |
| qtd_fill(fusbh200, qtd, 0, 0, token, 0); |
| } |
| } |
| |
| /* by default, enable interrupt on urb completion */ |
| if (likely (!(urb->transfer_flags & URB_NO_INTERRUPT))) |
| qtd->hw_token |= cpu_to_hc32(fusbh200, QTD_IOC); |
| return head; |
| |
| cleanup: |
| qtd_list_free (fusbh200, urb, head); |
| return NULL; |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| // Would be best to create all qh's from config descriptors, |
| // when each interface/altsetting is established. Unlink |
| // any previous qh and cancel its urbs first; endpoints are |
| // implicitly reset then (data toggle too). |
| // That'd mean updating how usbcore talks to HCDs. (2.7?) |
| |
| |
| /* |
| * Each QH holds a qtd list; a QH is used for everything except iso. |
| * |
| * For interrupt urbs, the scheduler must set the microframe scheduling |
| * mask(s) each time the QH gets scheduled. For highspeed, that's |
| * just one microframe in the s-mask. For split interrupt transactions |
| * there are additional complications: c-mask, maybe FSTNs. |
| */ |
| static struct fusbh200_qh * |
| qh_make ( |
| struct fusbh200_hcd *fusbh200, |
| struct urb *urb, |
| gfp_t flags |
| ) { |
| struct fusbh200_qh *qh = fusbh200_qh_alloc (fusbh200, flags); |
| u32 info1 = 0, info2 = 0; |
| int is_input, type; |
| int maxp = 0; |
| struct usb_tt *tt = urb->dev->tt; |
| struct fusbh200_qh_hw *hw; |
| |
| if (!qh) |
| return qh; |
| |
| /* |
| * init endpoint/device data for this QH |
| */ |
| info1 |= usb_pipeendpoint (urb->pipe) << 8; |
| info1 |= usb_pipedevice (urb->pipe) << 0; |
| |
| is_input = usb_pipein (urb->pipe); |
| type = usb_pipetype (urb->pipe); |
| maxp = usb_maxpacket (urb->dev, urb->pipe, !is_input); |
| |
| /* 1024 byte maxpacket is a hardware ceiling. High bandwidth |
| * acts like up to 3KB, but is built from smaller packets. |
| */ |
| if (max_packet(maxp) > 1024) { |
| fusbh200_dbg(fusbh200, "bogus qh maxpacket %d\n", max_packet(maxp)); |
| goto done; |
| } |
| |
| /* Compute interrupt scheduling parameters just once, and save. |
| * - allowing for high bandwidth, how many nsec/uframe are used? |
| * - split transactions need a second CSPLIT uframe; same question |
| * - splits also need a schedule gap (for full/low speed I/O) |
| * - qh has a polling interval |
| * |
| * For control/bulk requests, the HC or TT handles these. |
| */ |
| if (type == PIPE_INTERRUPT) { |
| qh->usecs = NS_TO_US(usb_calc_bus_time(USB_SPEED_HIGH, |
| is_input, 0, |
| hb_mult(maxp) * max_packet(maxp))); |
| qh->start = NO_FRAME; |
| |
| if (urb->dev->speed == USB_SPEED_HIGH) { |
| qh->c_usecs = 0; |
| qh->gap_uf = 0; |
| |
| qh->period = urb->interval >> 3; |
| if (qh->period == 0 && urb->interval != 1) { |
| /* NOTE interval 2 or 4 uframes could work. |
| * But interval 1 scheduling is simpler, and |
| * includes high bandwidth. |
| */ |
| urb->interval = 1; |
| } else if (qh->period > fusbh200->periodic_size) { |
| qh->period = fusbh200->periodic_size; |
| urb->interval = qh->period << 3; |
| } |
| } else { |
| int think_time; |
| |
| /* gap is f(FS/LS transfer times) */ |
| qh->gap_uf = 1 + usb_calc_bus_time (urb->dev->speed, |
| is_input, 0, maxp) / (125 * 1000); |
| |
| /* FIXME this just approximates SPLIT/CSPLIT times */ |
| if (is_input) { // SPLIT, gap, CSPLIT+DATA |
| qh->c_usecs = qh->usecs + HS_USECS (0); |
| qh->usecs = HS_USECS (1); |
| } else { // SPLIT+DATA, gap, CSPLIT |
| qh->usecs += HS_USECS (1); |
| qh->c_usecs = HS_USECS (0); |
| } |
| |
| think_time = tt ? tt->think_time : 0; |
| qh->tt_usecs = NS_TO_US (think_time + |
| usb_calc_bus_time (urb->dev->speed, |
| is_input, 0, max_packet (maxp))); |
| qh->period = urb->interval; |
| if (qh->period > fusbh200->periodic_size) { |
| qh->period = fusbh200->periodic_size; |
| urb->interval = qh->period; |
| } |
| } |
| } |
| |
| /* support for tt scheduling, and access to toggles */ |
| qh->dev = urb->dev; |
| |
| /* using TT? */ |
| switch (urb->dev->speed) { |
| case USB_SPEED_LOW: |
| info1 |= QH_LOW_SPEED; |
| /* FALL THROUGH */ |
| |
| case USB_SPEED_FULL: |
| /* EPS 0 means "full" */ |
| if (type != PIPE_INTERRUPT) |
| info1 |= (FUSBH200_TUNE_RL_TT << 28); |
| if (type == PIPE_CONTROL) { |
| info1 |= QH_CONTROL_EP; /* for TT */ |
| info1 |= QH_TOGGLE_CTL; /* toggle from qtd */ |
| } |
| info1 |= maxp << 16; |
| |
| info2 |= (FUSBH200_TUNE_MULT_TT << 30); |
| |
| /* Some Freescale processors have an erratum in which the |
| * port number in the queue head was 0..N-1 instead of 1..N. |
| */ |
| if (fusbh200_has_fsl_portno_bug(fusbh200)) |
| info2 |= (urb->dev->ttport-1) << 23; |
| else |
| info2 |= urb->dev->ttport << 23; |
| |
| /* set the address of the TT; for TDI's integrated |
| * root hub tt, leave it zeroed. |
| */ |
| if (tt && tt->hub != fusbh200_to_hcd(fusbh200)->self.root_hub) |
| info2 |= tt->hub->devnum << 16; |
| |
| /* NOTE: if (PIPE_INTERRUPT) { scheduler sets c-mask } */ |
| |
| break; |
| |
| case USB_SPEED_HIGH: /* no TT involved */ |
| info1 |= QH_HIGH_SPEED; |
| if (type == PIPE_CONTROL) { |
| info1 |= (FUSBH200_TUNE_RL_HS << 28); |
| info1 |= 64 << 16; /* usb2 fixed maxpacket */ |
| info1 |= QH_TOGGLE_CTL; /* toggle from qtd */ |
| info2 |= (FUSBH200_TUNE_MULT_HS << 30); |
| } else if (type == PIPE_BULK) { |
| info1 |= (FUSBH200_TUNE_RL_HS << 28); |
| /* The USB spec says that high speed bulk endpoints |
| * always use 512 byte maxpacket. But some device |
| * vendors decided to ignore that, and MSFT is happy |
| * to help them do so. So now people expect to use |
| * such nonconformant devices with Linux too; sigh. |
| */ |
| info1 |= max_packet(maxp) << 16; |
| info2 |= (FUSBH200_TUNE_MULT_HS << 30); |
| } else { /* PIPE_INTERRUPT */ |
| info1 |= max_packet (maxp) << 16; |
| info2 |= hb_mult (maxp) << 30; |
| } |
| break; |
| default: |
| fusbh200_dbg(fusbh200, "bogus dev %p speed %d\n", urb->dev, |
| urb->dev->speed); |
| done: |
| qh_destroy(fusbh200, qh); |
| return NULL; |
| } |
| |
| /* NOTE: if (PIPE_INTERRUPT) { scheduler sets s-mask } */ |
| |
| /* init as live, toggle clear, advance to dummy */ |
| qh->qh_state = QH_STATE_IDLE; |
| hw = qh->hw; |
| hw->hw_info1 = cpu_to_hc32(fusbh200, info1); |
| hw->hw_info2 = cpu_to_hc32(fusbh200, info2); |
| qh->is_out = !is_input; |
| usb_settoggle (urb->dev, usb_pipeendpoint (urb->pipe), !is_input, 1); |
| qh_refresh (fusbh200, qh); |
| return qh; |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| static void enable_async(struct fusbh200_hcd *fusbh200) |
| { |
| if (fusbh200->async_count++) |
| return; |
| |
| /* Stop waiting to turn off the async schedule */ |
| fusbh200->enabled_hrtimer_events &= ~BIT(FUSBH200_HRTIMER_DISABLE_ASYNC); |
| |
| /* Don't start the schedule until ASS is 0 */ |
| fusbh200_poll_ASS(fusbh200); |
| turn_on_io_watchdog(fusbh200); |
| } |
| |
| static void disable_async(struct fusbh200_hcd *fusbh200) |
| { |
| if (--fusbh200->async_count) |
| return; |
| |
| /* The async schedule and async_unlink list are supposed to be empty */ |
| WARN_ON(fusbh200->async->qh_next.qh || fusbh200->async_unlink); |
| |
| /* Don't turn off the schedule until ASS is 1 */ |
| fusbh200_poll_ASS(fusbh200); |
| } |
| |
| /* move qh (and its qtds) onto async queue; maybe enable queue. */ |
| |
| static void qh_link_async (struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh) |
| { |
| __hc32 dma = QH_NEXT(fusbh200, qh->qh_dma); |
| struct fusbh200_qh *head; |
| |
| /* Don't link a QH if there's a Clear-TT-Buffer pending */ |
| if (unlikely(qh->clearing_tt)) |
| return; |
| |
| WARN_ON(qh->qh_state != QH_STATE_IDLE); |
| |
| /* clear halt and/or toggle; and maybe recover from silicon quirk */ |
| qh_refresh(fusbh200, qh); |
| |
| /* splice right after start */ |
| head = fusbh200->async; |
| qh->qh_next = head->qh_next; |
| qh->hw->hw_next = head->hw->hw_next; |
| wmb (); |
| |
| head->qh_next.qh = qh; |
| head->hw->hw_next = dma; |
| |
| qh->xacterrs = 0; |
| qh->qh_state = QH_STATE_LINKED; |
| /* qtd completions reported later by interrupt */ |
| |
| enable_async(fusbh200); |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* |
| * For control/bulk/interrupt, return QH with these TDs appended. |
| * Allocates and initializes the QH if necessary. |
| * Returns null if it can't allocate a QH it needs to. |
| * If the QH has TDs (urbs) already, that's great. |
| */ |
| static struct fusbh200_qh *qh_append_tds ( |
| struct fusbh200_hcd *fusbh200, |
| struct urb *urb, |
| struct list_head *qtd_list, |
| int epnum, |
| void **ptr |
| ) |
| { |
| struct fusbh200_qh *qh = NULL; |
| __hc32 qh_addr_mask = cpu_to_hc32(fusbh200, 0x7f); |
<
|