hak5
/
openwrt
mirror of https://github.com/hak5/openwrt.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

USB driver fixes 

SVN-Revision: 9513
lede-17.01
Gabor Juhos 2007-11-08 12:28:27 +00:00
parent 64e1a619c2
commit cda3dc3ae1
7 changed files with 477 additions and 556 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
target/linux/adm5120/files/drivers/usb/host/adm5120-drv.c
View File

@ -163,14 +163,14 @@ static const struct hc_driver adm5120_hc_driver = {
/* /*
* scheduling support * scheduling support
*/ */
.get_frame_number = admhc_get_frame, .get_frame_number = admhc_get_frame_number,
/* /*
* root hub support * root hub support
*/ */
.hub_status_data = admhc_hub_status_data, .hub_status_data = admhc_hub_status_data,
.hub_control = admhc_hub_control, .hub_control = admhc_hub_control,
.hub_irq_enable = admhc_rhsc_enable, .hub_irq_enable = admhc_hub_irq_enable,
#ifdef CONFIG_PM #ifdef CONFIG_PM
.bus_suspend = admhc_bus_suspend, .bus_suspend = admhc_bus_suspend,
.bus_resume = admhc_bus_resume, .bus_resume = admhc_bus_resume,
@ -201,8 +201,7 @@ static int usb_hcd_adm5120_remove(struct platform_device *pdev)
return 0; return 0;
} }
#if 0 #ifdef CONFIG_PM
/* TODO */
static int usb_hcd_adm5120_suspend(struct platform_device *dev) static int usb_hcd_adm5120_suspend(struct platform_device *dev)
{ {
struct usb_hcd *hcd = platform_get_drvdata(dev); struct usb_hcd *hcd = platform_get_drvdata(dev);
@ -216,17 +215,17 @@ static int usb_hcd_adm5120_resume(struct platform_device *dev)
return 0; return 0;
} }
#endif #else
#define usb_hcd_adm5120_suspend NULL
#define usb_hcd_adm5120_resume NULL
#endif /* CONFIG_PM */
static struct platform_driver usb_hcd_adm5120_driver = { static struct platform_driver usb_hcd_adm5120_driver = {
.probe = usb_hcd_adm5120_probe, .probe = usb_hcd_adm5120_probe,
.remove = usb_hcd_adm5120_remove, .remove = usb_hcd_adm5120_remove,
.shutdown = usb_hcd_platform_shutdown, .shutdown = usb_hcd_platform_shutdown,
#if 0
/* TODO */
.suspend = usb_hcd_adm5120_suspend, .suspend = usb_hcd_adm5120_suspend,
.resume = usb_hcd_adm5120_resume, .resume = usb_hcd_adm5120_resume,
#endif
.driver = { .driver = {
.name = "adm5120-hcd", .name = "adm5120-hcd",
.owner = THIS_MODULE, .owner = THIS_MODULE,

152
target/linux/adm5120/files/drivers/usb/host/adm5120-hcd.c
View File

@ -45,14 +45,14 @@
#include "../core/hcd.h" #include "../core/hcd.h"
#include "../core/hub.h" #include "../core/hub.h"
#define DRIVER_VERSION "v0.02" #define DRIVER_VERSION "v0.03"
#define DRIVER_AUTHOR "Gabor Juhos <juhosg at openwrt.org>" #define DRIVER_AUTHOR "Gabor Juhos <juhosg at openwrt.org>"
#define DRIVER_DESC "ADMtek USB 1.1 Host Controller Driver" #define DRIVER_DESC "ADMtek USB 1.1 Host Controller Driver"
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
#define ADMHC_VERBOSE_DEBUG /* not always helpful */ #define ADMHC_VERBOSE_DEBUG /* not always helpful */
#undef LATE_ED_SCHEDULE #undef ADMHC_LOCK_DMA
/* For initializing controller (mask in an HCFS mode too) */ /* For initializing controller (mask in an HCFS mode too) */
#define OHCI_CONTROL_INIT OHCI_CTRL_CBSR #define OHCI_CONTROL_INIT OHCI_CTRL_CBSR
@ -73,9 +73,10 @@ static void admhc_dump(struct admhcd *ahcd, int verbose);
static int admhc_init(struct admhcd *ahcd); static int admhc_init(struct admhcd *ahcd);
static void admhc_stop(struct usb_hcd *hcd); static void admhc_stop(struct usb_hcd *hcd);
#include "adm5120-hub.c"
#include "adm5120-dbg.c" #include "adm5120-dbg.c"
#include "adm5120-mem.c" #include "adm5120-mem.c"
#include "adm5120-pm.c"
#include "adm5120-hub.c"
#include "adm5120-q.c" #include "adm5120-q.c"
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
@ -92,7 +93,7 @@ static int admhc_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *ep,
unsigned int pipe = urb->pipe; unsigned int pipe = urb->pipe;
int td_cnt = 0; int td_cnt = 0;
unsigned long flags; unsigned long flags;
int retval = 0; int ret = 0;
#ifdef ADMHC_VERBOSE_DEBUG #ifdef ADMHC_VERBOSE_DEBUG
spin_lock_irqsave(&ahcd->lock, flags); spin_lock_irqsave(&ahcd->lock, flags);
@ -160,11 +161,11 @@ static int admhc_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *ep,
spin_lock_irqsave(&ahcd->lock, flags); spin_lock_irqsave(&ahcd->lock, flags);
/* don't submit to a dead HC */ /* don't submit to a dead HC */
if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) { if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
retval = -ENODEV; ret = -ENODEV;
goto fail; goto fail;
} }
if (!HC_IS_RUNNING(hcd->state)) { if (!HC_IS_RUNNING(hcd->state)) {
retval = -ENODEV; ret = -ENODEV;
goto fail; goto fail;
} }
@ -174,7 +175,7 @@ static int admhc_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *ep,
spin_unlock(&urb->lock); spin_unlock(&urb->lock);
urb->hcpriv = urb_priv; urb->hcpriv = urb_priv;
finish_urb(ahcd, urb); finish_urb(ahcd, urb);
retval = 0; ret = 0;
goto fail; goto fail;
} }
@ -202,18 +203,18 @@ static int admhc_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *ep,
list_add_tail(&urb_priv->pending, &ed->urb_pending); list_add_tail(&urb_priv->pending, &ed->urb_pending);
/* schedule the ED */ /* schedule the ED */
retval = ed_schedule(ahcd, ed); ret = ed_schedule(ahcd, ed);
fail0: fail0:
spin_unlock(&urb->lock); spin_unlock(&urb->lock);
fail: fail:
if (retval) { if (ret) {
urb_priv = urb->hcpriv; urb_priv = urb->hcpriv;
urb_priv_free(ahcd, urb_priv); urb_priv_free(ahcd, urb_priv);
} }
spin_unlock_irqrestore(&ahcd->lock, flags); spin_unlock_irqrestore(&ahcd->lock, flags);
return retval; return ret;
} }
/* /*
@ -338,7 +339,7 @@ sanitize:
return; return;
} }
static int admhc_get_frame(struct usb_hcd *hcd) static int admhc_get_frame_number(struct usb_hcd *hcd)
{ {
struct admhcd *ahcd = hcd_to_admhcd(hcd); struct admhcd *ahcd = hcd_to_admhcd(hcd);
@ -364,8 +365,6 @@ admhc_shutdown(struct usb_hcd *hcd)
admhc_intr_disable(ahcd, ADMHC_INTR_MIE); admhc_intr_disable(ahcd, ADMHC_INTR_MIE);
admhc_dma_disable(ahcd); admhc_dma_disable(ahcd);
admhc_usb_reset(ahcd); admhc_usb_reset(ahcd);
/* flush the writes */
admhc_writel_flush(ahcd);
} }
/*-------------------------------------------------------------------------* /*-------------------------------------------------------------------------*
@ -509,7 +508,7 @@ static int admhc_run(struct admhcd *ahcd)
admhc_dbg(ahcd, "fminterval delta %d\n", admhc_dbg(ahcd, "fminterval delta %d\n",
ahcd->fminterval - FI); ahcd->fminterval - FI);
ahcd->fminterval |= ahcd->fminterval |=
(FSLDP (ahcd->fminterval) << ADMHC_SFI_FSLDP_SHIFT); (FSLDP(ahcd->fminterval) << ADMHC_SFI_FSLDP_SHIFT);
/* also: power/overcurrent flags in rhdesc */ /* also: power/overcurrent flags in rhdesc */
} }
@ -531,9 +530,6 @@ static int admhc_run(struct admhcd *ahcd)
} }
admhc_writel(ahcd, ahcd->host_control, &ahcd->regs->host_control); admhc_writel(ahcd, ahcd->host_control, &ahcd->regs->host_control);
/* flush the writes */
admhc_writel_flush(ahcd);
msleep(temp); msleep(temp);
temp = admhc_get_rhdesc(ahcd); temp = admhc_get_rhdesc(ahcd);
if (!(temp & ADMHC_RH_NPS)) { if (!(temp & ADMHC_RH_NPS)) {
@ -542,8 +538,6 @@ static int admhc_run(struct admhcd *ahcd)
admhc_writel(ahcd, ADMHC_PS_CPP, admhc_writel(ahcd, ADMHC_PS_CPP,
&ahcd->regs->portstatus[temp]); &ahcd->regs->portstatus[temp]);
} }
/* flush those writes */
admhc_writel_flush(ahcd);
/* 2msec timelimit here means no irqs/preempt */ /* 2msec timelimit here means no irqs/preempt */
spin_lock_irq(&ahcd->lock); spin_lock_irq(&ahcd->lock);
@ -585,9 +579,6 @@ retry:
admhc_writel(ahcd, ADMHC_RH_NPS | ADMHC_RH_LPSC, &ahcd->regs->rhdesc); admhc_writel(ahcd, ADMHC_RH_NPS | ADMHC_RH_LPSC, &ahcd->regs->rhdesc);
/* flush those writes */
admhc_writel_flush(ahcd);
/* start controller operations */ /* start controller operations */
ahcd->host_control = ADMHC_BUSS_OPER; ahcd->host_control = ADMHC_BUSS_OPER;
admhc_writel(ahcd, ahcd->host_control, &ahcd->regs->host_control); admhc_writel(ahcd, ahcd->host_control, &ahcd->regs->host_control);
@ -604,27 +595,8 @@ retry:
} }
hcd->state = HC_STATE_RUNNING; hcd->state = HC_STATE_RUNNING;
ahcd->next_statechange = jiffies + STATECHANGE_DELAY; ahcd->next_statechange = jiffies + STATECHANGE_DELAY;
#if 0
/* FIXME: enabling DMA is always failed here for an unknown reason */
admhc_dma_enable(ahcd);
temp = 200;
while ((admhc_readl(ahcd, &ahcd->regs->host_control)
& ADMHC_HC_DMAE) != ADMHC_HC_DMAE) {
if (--temp == 0) {
spin_unlock_irq(&ahcd->lock);
admhc_err(ahcd, "unable to enable DMA!\n");
admhc_dump(ahcd, 1);
return -1;
}
mdelay(1);
}
#endif
spin_unlock_irq(&ahcd->lock); spin_unlock_irq(&ahcd->lock);
mdelay(ADMHC_POTPGT); mdelay(ADMHC_POTPGT);
@ -650,7 +622,6 @@ static irqreturn_t admhc_irq(struct usb_hcd *hcd)
ints &= admhc_readl(ahcd, &regs->int_enable); ints &= admhc_readl(ahcd, &regs->int_enable);
spin_lock(&ahcd->lock);
if (ints & ADMHC_INTR_FATI) { if (ints & ADMHC_INTR_FATI) {
/* e.g. due to PCI Master/Target Abort */ /* e.g. due to PCI Master/Target Abort */
admhc_disable(ahcd); admhc_disable(ahcd);
@ -700,7 +671,9 @@ static irqreturn_t admhc_irq(struct usb_hcd *hcd)
if (HC_IS_RUNNING(hcd->state)) if (HC_IS_RUNNING(hcd->state))
admhc_intr_disable(ahcd, ADMHC_INTR_TDC); admhc_intr_disable(ahcd, ADMHC_INTR_TDC);
admhc_vdbg(ahcd, "Transfer Descriptor Complete\n"); admhc_vdbg(ahcd, "Transfer Descriptor Complete\n");
spin_lock(&ahcd->lock);
admhc_td_complete(ahcd); admhc_td_complete(ahcd);
spin_unlock(&ahcd->lock);
if (HC_IS_RUNNING(hcd->state)) if (HC_IS_RUNNING(hcd->state))
admhc_intr_enable(ahcd, ADMHC_INTR_TDC); admhc_intr_enable(ahcd, ADMHC_INTR_TDC);
} }
@ -714,15 +687,15 @@ static irqreturn_t admhc_irq(struct usb_hcd *hcd)
admhc_intr_ack(ahcd, ADMHC_INTR_SOFI); admhc_intr_ack(ahcd, ADMHC_INTR_SOFI);
/* handle any pending ED removes */ /* handle any pending ED removes */
admhc_finish_unlinks(ahcd, admhc_frame_no(ahcd)); admhc_finish_unlinks(ahcd, admhc_frame_no(ahcd));
spin_lock(&ahcd->lock);
admhc_sof_refill(ahcd); admhc_sof_refill(ahcd);
spin_unlock(&ahcd->lock);
} }
if (HC_IS_RUNNING(hcd->state)) { if (HC_IS_RUNNING(hcd->state)) {
admhc_intr_ack(ahcd, ints); admhc_intr_ack(ahcd, ints);
admhc_intr_enable(ahcd, ADMHC_INTR_MIE); admhc_intr_enable(ahcd, ADMHC_INTR_MIE);
admhc_writel_flush(ahcd);
} }
spin_unlock(&ahcd->lock);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
@ -750,87 +723,6 @@ static void admhc_stop(struct usb_hcd *hcd)
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/* must not be called from interrupt context */
#ifdef CONFIG_PM
static int admhc_restart(struct admhcd *ahcd)
{
int temp;
int i;
struct urb_priv *priv;
/* mark any devices gone, so they do nothing till khubd disconnects.
* recycle any "live" eds/tds (and urbs) right away.
* later, khubd disconnect processing will recycle the other state,
* (either as disconnect/reconnect, or maybe someday as a reset).
*/
spin_lock_irq(&ahcd->lock);
admhc_disable(ahcd);
usb_root_hub_lost_power(admhcd_to_hcd(ahcd)->self.root_hub);
if (!list_empty(&ahcd->pending))
admhc_dbg(ahcd, "abort schedule...\n");
list_for_each_entry(priv, &ahcd->pending, pending) {
struct urb *urb = priv->td[0]->urb;
struct ed *ed = priv->ed;
switch (ed->state) {
case ED_OPER:
ed->state = ED_UNLINK;
ed->hwINFO |= cpu_to_hc32(ahcd, ED_DEQUEUE);
ed_deschedule (ahcd, ed);
ed->ed_next = ahcd->ed_rm_list;
ed->ed_prev = NULL;
ahcd->ed_rm_list = ed;
/* FALLTHROUGH */
case ED_UNLINK:
break;
default:
admhc_dbg(ahcd, "bogus ed %p state %d\n",
ed, ed->state);
}
spin_lock(&urb->lock);
urb->status = -ESHUTDOWN;
spin_unlock(&urb->lock);
}
finish_unlinks(ahcd, 0);
spin_unlock_irq(&ahcd->lock);
/* paranoia, in case that didn't work: */
/* empty the interrupt branches */
for (i = 0; i < NUM_INTS; i++) ahcd->load[i] = 0;
for (i = 0; i < NUM_INTS; i++) ahcd->hcca->int_table[i] = 0;
/* no EDs to remove */
ahcd->ed_rm_list = NULL;
/* empty control and bulk lists */
ahcd->ed_controltail = NULL;
ahcd->ed_bulktail = NULL;
if ((temp = admhc_run(ahcd)) < 0) {
admhc_err(ahcd, "can't restart, %d\n", temp);
return temp;
} else {
/* here we "know" root ports should always stay powered,
* and that if we try to turn them back on the root hub
* will respond to CSC processing.
*/
i = ahcd->num_ports;
while (i--)
admhc_writel(ahcd, RH_PS_PSS,
&ahcd->regs->portstatus[i]);
admhc_dbg(ahcd, "restart complete\n");
}
return 0;
}
#endif
/*-------------------------------------------------------------------------*/
#ifdef CONFIG_MIPS_ADM5120 #ifdef CONFIG_MIPS_ADM5120
#include "adm5120-drv.c" #include "adm5120-drv.c"
#define PLATFORM_DRIVER usb_hcd_adm5120_driver #define PLATFORM_DRIVER usb_hcd_adm5120_driver
@ -844,7 +736,7 @@ static int admhc_restart(struct admhcd *ahcd)
static int __init admhc_hcd_mod_init(void) static int __init admhc_hcd_mod_init(void)
{ {
int retval = 0; int ret = 0;
if (usb_disabled()) if (usb_disabled())
return -ENODEV; return -ENODEV;
@ -854,18 +746,18 @@ static int __init admhc_hcd_mod_init(void)
sizeof (struct ed), sizeof (struct td)); sizeof (struct ed), sizeof (struct td));
#ifdef PLATFORM_DRIVER #ifdef PLATFORM_DRIVER
retval = platform_driver_register(&PLATFORM_DRIVER); ret = platform_driver_register(&PLATFORM_DRIVER);
if (retval < 0) if (ret < 0)
goto error_platform; goto error_platform;
#endif #endif
return retval; return ret;
#ifdef PLATFORM_DRIVER #ifdef PLATFORM_DRIVER
platform_driver_unregister(&PLATFORM_DRIVER); platform_driver_unregister(&PLATFORM_DRIVER);
error_platform: error_platform:
#endif #endif
return retval; return ret;
} }
module_init(admhc_hcd_mod_init); module_init(admhc_hcd_mod_init);

364
target/linux/adm5120/files/drivers/usb/host/adm5120-hub.c
View File

@ -58,7 +58,7 @@
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/* hcd->hub_irq_enable() */ /* hcd->hub_irq_enable() */
static void admhc_rhsc_enable(struct usb_hcd *hcd) static void admhc_hub_irq_enable(struct usb_hcd *hcd)
{ {
struct admhcd *ahcd = hcd_to_admhcd(hcd); struct admhcd *ahcd = hcd_to_admhcd(hcd);
@ -69,360 +69,6 @@ static void admhc_rhsc_enable(struct usb_hcd *hcd)
spin_unlock_irq(&ahcd->lock); spin_unlock_irq(&ahcd->lock);
} }
#define OHCI_SCHED_ENABLES \
(OHCI_CTRL_CLE|OHCI_CTRL_BLE|OHCI_CTRL_PLE|OHCI_CTRL_IE)
#ifdef CONFIG_PM
static int admhc_restart(struct admhcd *ahcd);
static int admhc_rh_suspend(struct admhcd *ahcd, int autostop)
__releases(ahcd->lock)
__acquires(ahcd->lock)
{
int status = 0;
ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control);
switch (ahcd->hc_control & OHCI_CTRL_HCFS) {
case OHCI_USB_RESUME:
admhc_dbg(ahcd, "resume/suspend?\n");
ahcd->hc_control &= ~OHCI_CTRL_HCFS;
ahcd->hc_control |= OHCI_USB_RESET;
admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
(void) admhc_readl(ahcd, &ahcd->regs->control);
/* FALL THROUGH */
case OHCI_USB_RESET:
status = -EBUSY;
admhc_dbg(ahcd, "needs reinit!\n");
goto done;
case OHCI_USB_SUSPEND:
if (!ahcd->autostop) {
admhc_dbg(ahcd, "already suspended\n");
goto done;
}
}
admhc_dbg(ahcd, "%s root hub\n",
autostop ? "auto-stop" : "suspend");
/* First stop any processing */
if (!autostop && (ahcd->hc_control & OHCI_SCHED_ENABLES)) {
ahcd->hc_control &= ~OHCI_SCHED_ENABLES;
admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control);
admhc_writel(ahcd, OHCI_INTR_SF, &ahcd->regs->intrstatus);
/* sched disables take effect on the next frame,
* then the last WDH could take 6+ msec
*/
admhc_dbg(ahcd, "stopping schedules ...\n");
ahcd->autostop = 0;
spin_unlock_irq (&ahcd->lock);
msleep (8);
spin_lock_irq (&ahcd->lock);
}
dl_done_list (ahcd);
finish_unlinks (ahcd, admhc_frame_no(ahcd));
/* maybe resume can wake root hub */
if (device_may_wakeup(&admhcd_to_hcd(ahcd)->self.root_hub->dev) ||
autostop)
ahcd->hc_control |= OHCI_CTRL_RWE;
else {
admhc_writel(ahcd, OHCI_INTR_RHSC, &ahcd->regs->intrdisable);
ahcd->hc_control &= ~OHCI_CTRL_RWE;
}
/* Suspend hub ... this is the "global (to this bus) suspend" mode,
* which doesn't imply ports will first be individually suspended.
*/
ahcd->hc_control &= ~OHCI_CTRL_HCFS;
ahcd->hc_control |= OHCI_USB_SUSPEND;
admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
(void) admhc_readl(ahcd, &ahcd->regs->control);
/* no resumes until devices finish suspending */
if (!autostop) {
ahcd->next_statechange = jiffies + msecs_to_jiffies (5);
ahcd->autostop = 0;
}
done:
return status;
}
static inline struct ed *find_head(struct ed *ed)
{
/* for bulk and control lists */
while (ed->ed_prev)
ed = ed->ed_prev;
return ed;
}
/* caller has locked the root hub */
static int admhc_rh_resume(struct admhcd *ahcd)
__releases(ahcd->lock)
__acquires(ahcd->lock)
{
struct usb_hcd *hcd = admhcd_to_hcd (ahcd);
u32 temp, enables;
int status = -EINPROGRESS;
int autostopped = ahcd->autostop;
ahcd->autostop = 0;
ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control);
if (ahcd->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) {
/* this can happen after resuming a swsusp snapshot */
if (hcd->state == HC_STATE_RESUMING) {
admhc_dbg(ahcd, "BIOS/SMM active, control %03x\n",
ahcd->hc_control);
status = -EBUSY;
/* this happens when pmcore resumes HC then root */
} else {
admhc_dbg(ahcd, "duplicate resume\n");
status = 0;
}
} else switch (ahcd->hc_control & OHCI_CTRL_HCFS) {
case OHCI_USB_SUSPEND:
ahcd->hc_control &= ~(OHCI_CTRL_HCFS|OHCI_SCHED_ENABLES);
ahcd->hc_control |= OHCI_USB_RESUME;
admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
(void) admhc_readl(ahcd, &ahcd->regs->control);
admhc_dbg(ahcd, "%s root hub\n",
autostopped ? "auto-start" : "resume");
break;
case OHCI_USB_RESUME:
/* HCFS changes sometime after INTR_RD */
admhc_dbg(ahcd, "%swakeup root hub\n",
autostopped ? "auto-" : "");
break;
case OHCI_USB_OPER:
/* this can happen after resuming a swsusp snapshot */
admhc_dbg(ahcd, "snapshot resume? reinit\n");
status = -EBUSY;
break;
default: /* RESET, we lost power */
admhc_dbg(ahcd, "lost power\n");
status = -EBUSY;
}
if (status == -EBUSY) {
if (!autostopped) {
spin_unlock_irq (&ahcd->lock);
(void) ahcd_init (ahcd);
status = admhc_restart (ahcd);
spin_lock_irq (&ahcd->lock);
}
return status;
}
if (status != -EINPROGRESS)
return status;
if (autostopped)
goto skip_resume;
spin_unlock_irq (&ahcd->lock);
/* Some controllers (lucent erratum) need extra-long delays */
msleep (20 /* usb 11.5.1.10 */ + 12 /* 32 msec counter */ + 1);
temp = admhc_readl(ahcd, &ahcd->regs->control);
temp &= OHCI_CTRL_HCFS;
if (temp != OHCI_USB_RESUME) {
admhc_err (ahcd, "controller won't resume\n");
spin_lock_irq(&ahcd->lock);
return -EBUSY;
}
/* disable old schedule state, reinit from scratch */
admhc_writel(ahcd, 0, &ahcd->regs->ed_controlhead);
admhc_writel(ahcd, 0, &ahcd->regs->ed_controlcurrent);
admhc_writel(ahcd, 0, &ahcd->regs->ed_bulkhead);
admhc_writel(ahcd, 0, &ahcd->regs->ed_bulkcurrent);
admhc_writel(ahcd, 0, &ahcd->regs->ed_periodcurrent);
admhc_writel(ahcd, (u32) ahcd->hcca_dma, &ahcd->ahcd->regs->hcca);
/* Sometimes PCI D3 suspend trashes frame timings ... */
periodic_reinit(ahcd);
/* the following code is executed with ahcd->lock held and
* irqs disabled if and only if autostopped is true
*/
skip_resume:
/* interrupts might have been disabled */
admhc_writel(ahcd, OHCI_INTR_INIT, &ahcd->regs->int_enable);
if (ahcd->ed_rm_list)
admhc_writel(ahcd, OHCI_INTR_SF, &ahcd->regs->int_enable);
/* Then re-enable operations */
admhc_writel(ahcd, OHCI_USB_OPER, &ahcd->regs->control);
(void) admhc_readl(ahcd, &ahcd->regs->control);
if (!autostopped)
msleep (3);
temp = ahcd->hc_control;
temp &= OHCI_CTRL_RWC;
temp |= OHCI_CONTROL_INIT | OHCI_USB_OPER;
ahcd->hc_control = temp;
admhc_writel(ahcd, temp, &ahcd->regs->control);
(void) admhc_readl(ahcd, &ahcd->regs->control);
/* TRSMRCY */
if (!autostopped) {
msleep (10);
spin_lock_irq (&ahcd->lock);
}
/* now ahcd->lock is always held and irqs are always disabled */
/* keep it alive for more than ~5x suspend + resume costs */
ahcd->next_statechange = jiffies + STATECHANGE_DELAY;
/* maybe turn schedules back on */
enables = 0;
temp = 0;
if (!ahcd->ed_rm_list) {
if (ahcd->ed_controltail) {
admhc_writel(ahcd,
find_head (ahcd->ed_controltail)->dma,
&ahcd->regs->ed_controlhead);
enables |= OHCI_CTRL_CLE;
temp |= OHCI_CLF;
}
if (ahcd->ed_bulktail) {
admhc_writel(ahcd, find_head (ahcd->ed_bulktail)->dma,
&ahcd->regs->ed_bulkhead);
enables |= OHCI_CTRL_BLE;
temp |= OHCI_BLF;
}
}
if (hcd->self.bandwidth_isoc_reqs || hcd->self.bandwidth_int_reqs)
enables |= OHCI_CTRL_PLE|OHCI_CTRL_IE;
if (enables) {
admhc_dbg(ahcd, "restarting schedules ... %08x\n", enables);
ahcd->hc_control |= enables;
admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
if (temp)
admhc_writel(ahcd, temp, &ahcd->regs->cmdstatus);
(void) admhc_readl(ahcd, &ahcd->regs->control);
}
return 0;
}
static int admhc_bus_suspend(struct usb_hcd *hcd)
{
struct admhcd *ahcd = hcd_to_admhcd(hcd);
int rc;
spin_lock_irq(&ahcd->lock);
if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
rc = -ESHUTDOWN;
else
rc = admhc_rh_suspend (ahcd, 0);
spin_unlock_irq(&ahcd->lock);
return rc;
}
static int admhc_bus_resume(struct usb_hcd *hcd)
{
struct admhcd *ahcd = hcd_to_admhcd(hcd);
int rc;
if (time_before(jiffies, ahcd->next_statechange))
msleep(5);
spin_lock_irq (&ahcd->lock);
if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
rc = -ESHUTDOWN;
else
rc = admhc_rh_resume (ahcd);
spin_unlock_irq(&ahcd->lock);
/* poll until we know a device is connected or we autostop */
if (rc == 0)
usb_hcd_poll_rh_status(hcd);
return rc;
}
/* Carry out polling-, autostop-, and autoresume-related state changes */
static int admhc_root_hub_state_changes(struct admhcd *ahcd, int changed,
int any_connected)
{
int poll_rh = 1;
switch (ahcd->hc_control & OHCI_CTRL_HCFS) {
case OHCI_USB_OPER:
/* keep on polling until we know a device is connected
* and RHSC is enabled */
if (!ahcd->autostop) {
if (any_connected ||
!device_may_wakeup(&admhcd_to_hcd(ahcd)
->self.root_hub->dev)) {
if (admhc_readl(ahcd, &ahcd->regs->int_enable) &
OHCI_INTR_RHSC)
poll_rh = 0;
} else {
ahcd->autostop = 1;
ahcd->next_statechange = jiffies + HZ;
}
/* if no devices have been attached for one second, autostop */
} else {
if (changed || any_connected) {
ahcd->autostop = 0;
ahcd->next_statechange = jiffies +
STATECHANGE_DELAY;
} else if (time_after_eq(jiffies,
ahcd->next_statechange)
&& !ahcd->ed_rm_list
&& !(ahcd->hc_control &
OHCI_SCHED_ENABLES)) {
ahcd_rh_suspend(ahcd, 1);
}
}
break;
/* if there is a port change, autostart or ask to be resumed */
case OHCI_USB_SUSPEND:
case OHCI_USB_RESUME:
if (changed) {
if (ahcd->autostop)
admhc_rh_resume(ahcd);
else
usb_hcd_resume_root_hub(admhcd_to_hcd(ahcd));
} else {
/* everything is idle, no need for polling */
poll_rh = 0;
}
break;
}
return poll_rh;
}
#else /* CONFIG_PM */
static inline int admhc_rh_resume(struct admhcd *ahcd)
{
return 0;
}
/* Carry out polling-related state changes.
* autostop isn't used when CONFIG_PM is turned off.
*/
static int admhc_root_hub_state_changes(struct admhcd *ahcd, int changed,
int any_connected)
{
int poll_rh = 1;
/* keep on polling until RHSC is enabled */
if (admhc_readl(ahcd, &ahcd->regs->int_enable) & ADMHC_INTR_INSM)
poll_rh = 0;
return poll_rh;
}
#endif /* CONFIG_PM */
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/* build "status change" packet (one or two bytes) from HC registers */ /* build "status change" packet (one or two bytes) from HC registers */
@ -647,7 +293,7 @@ static int admhc_hub_control (
struct admhcd *ahcd = hcd_to_admhcd(hcd); struct admhcd *ahcd = hcd_to_admhcd(hcd);
int ports = hcd_to_bus (hcd)->root_hub->maxchild; int ports = hcd_to_bus (hcd)->root_hub->maxchild;
u32 temp; u32 temp;
int retval = 0; int ret = 0;
if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))) if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
return -ESHUTDOWN; return -ESHUTDOWN;
@ -753,7 +399,7 @@ static int admhc_hub_control (
&ahcd->regs->portstatus[wIndex]); &ahcd->regs->portstatus[wIndex]);
break; break;
case USB_PORT_FEAT_RESET: case USB_PORT_FEAT_RESET:
retval = root_port_reset(ahcd, wIndex); ret = root_port_reset(ahcd, wIndex);
break; break;
default: default:
goto error; goto error;
@ -763,8 +409,8 @@ static int admhc_hub_control (
default: default:
error: error:
/* "protocol stall" on error */ /* "protocol stall" on error */
retval = -EPIPE; ret = -EPIPE;
} }
return retval; return ret;
} }

1
target/linux/adm5120/files/drivers/usb/host/adm5120-mem.c
View File

@ -27,7 +27,6 @@ static void admhc_hcd_init(struct admhcd *ahcd)
{ {
ahcd->next_statechange = jiffies; ahcd->next_statechange = jiffies;
spin_lock_init(&ahcd->lock); spin_lock_init(&ahcd->lock);
spin_lock_init(&ahcd->dma_lock);
} }
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/

440
target/linux/adm5120/files/drivers/usb/host/adm5120-pm.c Normal file
View File

@ -0,0 +1,440 @@
/*
* OHCI HCD (Host Controller Driver) for USB.
*
* (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
* (C) Copyright 2000-2004 David Brownell <dbrownell@users.sourceforge.net>
*
* This file is licenced under GPL
*/
#define OHCI_SCHED_ENABLES \
(OHCI_CTRL_CLE|OHCI_CTRL_BLE|OHCI_CTRL_PLE|OHCI_CTRL_IE)
#ifdef CONFIG_PM
static int admhc_restart(struct admhcd *ahcd);
static int admhc_rh_suspend(struct admhcd *ahcd, int autostop)
__releases(ahcd->lock)
__acquires(ahcd->lock)
{
int status = 0;
ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control);
switch (ahcd->hc_control & OHCI_CTRL_HCFS) {
case OHCI_USB_RESUME:
admhc_dbg(ahcd, "resume/suspend?\n");
ahcd->hc_control &= ~OHCI_CTRL_HCFS;
ahcd->hc_control |= OHCI_USB_RESET;
admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
(void) admhc_readl(ahcd, &ahcd->regs->control);
/* FALL THROUGH */
case OHCI_USB_RESET:
status = -EBUSY;
admhc_dbg(ahcd, "needs reinit!\n");
goto done;
case OHCI_USB_SUSPEND:
if (!ahcd->autostop) {
admhc_dbg(ahcd, "already suspended\n");
goto done;
}
}
admhc_dbg(ahcd, "%s root hub\n",
autostop ? "auto-stop" : "suspend");
/* First stop any processing */
if (!autostop && (ahcd->hc_control & OHCI_SCHED_ENABLES)) {
ahcd->hc_control &= ~OHCI_SCHED_ENABLES;
admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control);
admhc_writel(ahcd, OHCI_INTR_SF, &ahcd->regs->intrstatus);
/* sched disables take effect on the next frame,
* then the last WDH could take 6+ msec
*/
admhc_dbg(ahcd, "stopping schedules ...\n");
ahcd->autostop = 0;
spin_unlock_irq (&ahcd->lock);
msleep (8);
spin_lock_irq(&ahcd->lock);
}
dl_done_list (ahcd);
finish_unlinks (ahcd, admhc_frame_no(ahcd));
/* maybe resume can wake root hub */
if (device_may_wakeup(&admhcd_to_hcd(ahcd)->self.root_hub->dev) ||
autostop)
ahcd->hc_control |= OHCI_CTRL_RWE;
else {
admhc_writel(ahcd, OHCI_INTR_RHSC, &ahcd->regs->intrdisable);
ahcd->hc_control &= ~OHCI_CTRL_RWE;
}
/* Suspend hub ... this is the "global (to this bus) suspend" mode,
* which doesn't imply ports will first be individually suspended.
*/
ahcd->hc_control &= ~OHCI_CTRL_HCFS;
ahcd->hc_control |= OHCI_USB_SUSPEND;
admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
(void) admhc_readl(ahcd, &ahcd->regs->control);
/* no resumes until devices finish suspending */
if (!autostop) {
ahcd->next_statechange = jiffies + msecs_to_jiffies (5);
ahcd->autostop = 0;
}
done:
return status;
}
static inline struct ed *find_head(struct ed *ed)
{
/* for bulk and control lists */
while (ed->ed_prev)
ed = ed->ed_prev;
return ed;
}
/* caller has locked the root hub */
static int admhc_rh_resume(struct admhcd *ahcd)
__releases(ahcd->lock)
__acquires(ahcd->lock)
{
struct usb_hcd *hcd = admhcd_to_hcd (ahcd);
u32 temp, enables;
int status = -EINPROGRESS;
int autostopped = ahcd->autostop;
ahcd->autostop = 0;
ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control);
if (ahcd->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) {
/* this can happen after resuming a swsusp snapshot */
if (hcd->state == HC_STATE_RESUMING) {
admhc_dbg(ahcd, "BIOS/SMM active, control %03x\n",
ahcd->hc_control);
status = -EBUSY;
/* this happens when pmcore resumes HC then root */
} else {
admhc_dbg(ahcd, "duplicate resume\n");
status = 0;
}
} else switch (ahcd->hc_control & OHCI_CTRL_HCFS) {
case OHCI_USB_SUSPEND:
ahcd->hc_control &= ~(OHCI_CTRL_HCFS|OHCI_SCHED_ENABLES);
ahcd->hc_control |= OHCI_USB_RESUME;
admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
(void) admhc_readl(ahcd, &ahcd->regs->control);
admhc_dbg(ahcd, "%s root hub\n",
autostopped ? "auto-start" : "resume");
break;
case OHCI_USB_RESUME:
/* HCFS changes sometime after INTR_RD */
admhc_dbg(ahcd, "%swakeup root hub\n",
autostopped ? "auto-" : "");
break;
case OHCI_USB_OPER:
/* this can happen after resuming a swsusp snapshot */
admhc_dbg(ahcd, "snapshot resume? reinit\n");
status = -EBUSY;
break;
default: /* RESET, we lost power */
admhc_dbg(ahcd, "lost power\n");
status = -EBUSY;
}
if (status == -EBUSY) {
if (!autostopped) {
spin_unlock_irq (&ahcd->lock);
(void) ahcd_init (ahcd);
status = admhc_restart (ahcd);
spin_lock_irq(&ahcd->lock);
}
return status;
}
if (status != -EINPROGRESS)
return status;
if (autostopped)
goto skip_resume;
spin_unlock_irq (&ahcd->lock);
/* Some controllers (lucent erratum) need extra-long delays */
msleep (20 /* usb 11.5.1.10 */ + 12 /* 32 msec counter */ + 1);
temp = admhc_readl(ahcd, &ahcd->regs->control);
temp &= OHCI_CTRL_HCFS;
if (temp != OHCI_USB_RESUME) {
admhc_err (ahcd, "controller won't resume\n");
spin_lock_irq(&ahcd->lock);
return -EBUSY;
}
/* disable old schedule state, reinit from scratch */
admhc_writel(ahcd, 0, &ahcd->regs->ed_controlhead);
admhc_writel(ahcd, 0, &ahcd->regs->ed_controlcurrent);
admhc_writel(ahcd, 0, &ahcd->regs->ed_bulkhead);
admhc_writel(ahcd, 0, &ahcd->regs->ed_bulkcurrent);
admhc_writel(ahcd, 0, &ahcd->regs->ed_periodcurrent);
admhc_writel(ahcd, (u32) ahcd->hcca_dma, &ahcd->ahcd->regs->hcca);
/* Sometimes PCI D3 suspend trashes frame timings ... */
periodic_reinit(ahcd);
/* the following code is executed with ahcd->lock held and
* irqs disabled if and only if autostopped is true
*/
skip_resume:
/* interrupts might have been disabled */
admhc_writel(ahcd, OHCI_INTR_INIT, &ahcd->regs->int_enable);
if (ahcd->ed_rm_list)
admhc_writel(ahcd, OHCI_INTR_SF, &ahcd->regs->int_enable);
/* Then re-enable operations */
admhc_writel(ahcd, OHCI_USB_OPER, &ahcd->regs->control);
(void) admhc_readl(ahcd, &ahcd->regs->control);
if (!autostopped)
msleep (3);
temp = ahcd->hc_control;
temp &= OHCI_CTRL_RWC;
temp |= OHCI_CONTROL_INIT | OHCI_USB_OPER;
ahcd->hc_control = temp;
admhc_writel(ahcd, temp, &ahcd->regs->control);
(void) admhc_readl(ahcd, &ahcd->regs->control);
/* TRSMRCY */
if (!autostopped) {
msleep (10);
spin_lock_irq(&ahcd->lock);
}
/* now ahcd->lock is always held and irqs are always disabled */
/* keep it alive for more than ~5x suspend + resume costs */
ahcd->next_statechange = jiffies + STATECHANGE_DELAY;
/* maybe turn schedules back on */
enables = 0;
temp = 0;
if (!ahcd->ed_rm_list) {
if (ahcd->ed_controltail) {
admhc_writel(ahcd,
find_head (ahcd->ed_controltail)->dma,
&ahcd->regs->ed_controlhead);
enables |= OHCI_CTRL_CLE;
temp |= OHCI_CLF;
}
if (ahcd->ed_bulktail) {
admhc_writel(ahcd, find_head (ahcd->ed_bulktail)->dma,
&ahcd->regs->ed_bulkhead);
enables |= OHCI_CTRL_BLE;
temp |= OHCI_BLF;
}
}
if (hcd->self.bandwidth_isoc_reqs || hcd->self.bandwidth_int_reqs)
enables |= OHCI_CTRL_PLE|OHCI_CTRL_IE;
if (enables) {
admhc_dbg(ahcd, "restarting schedules ... %08x\n", enables);
ahcd->hc_control |= enables;
admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
if (temp)
admhc_writel(ahcd, temp, &ahcd->regs->cmdstatus);
(void) admhc_readl(ahcd, &ahcd->regs->control);
}
return 0;
}
static int admhc_bus_suspend(struct usb_hcd *hcd)
{
struct admhcd *ahcd = hcd_to_admhcd(hcd);
int rc;
spin_lock_irq(&ahcd->lock);
if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
rc = -ESHUTDOWN;
else
rc = admhc_rh_suspend(ahcd, 0);
spin_unlock_irq(&ahcd->lock);
return rc;
}
static int admhc_bus_resume(struct usb_hcd *hcd)
{
struct admhcd *ahcd = hcd_to_admhcd(hcd);
int rc;
if (time_before(jiffies, ahcd->next_statechange))
msleep(5);
spin_lock_irq(&ahcd->lock);
if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
rc = -ESHUTDOWN;
else
rc = admhc_rh_resume(ahcd);
spin_unlock_irq(&ahcd->lock);
/* poll until we know a device is connected or we autostop */
if (rc == 0)
usb_hcd_poll_rh_status(hcd);
return rc;
}
/* Carry out polling-, autostop-, and autoresume-related state changes */
static int admhc_root_hub_state_changes(struct admhcd *ahcd, int changed,
int any_connected)
{
int poll_rh = 1;
switch (ahcd->hc_control & OHCI_CTRL_HCFS) {
case OHCI_USB_OPER:
/* keep on polling until we know a device is connected
* and RHSC is enabled */
if (!ahcd->autostop) {
if (any_connected ||
!device_may_wakeup(&admhcd_to_hcd(ahcd)
->self.root_hub->dev)) {
if (admhc_readl(ahcd, &ahcd->regs->int_enable) &
OHCI_INTR_RHSC)
poll_rh = 0;
} else {
ahcd->autostop = 1;
ahcd->next_statechange = jiffies + HZ;
}
/* if no devices have been attached for one second, autostop */
} else {
if (changed || any_connected) {
ahcd->autostop = 0;
ahcd->next_statechange = jiffies +
STATECHANGE_DELAY;
} else if (time_after_eq(jiffies,
ahcd->next_statechange)
&& !ahcd->ed_rm_list
&& !(ahcd->hc_control &
OHCI_SCHED_ENABLES)) {
ahcd_rh_suspend(ahcd, 1);
}
}
break;
/* if there is a port change, autostart or ask to be resumed */
case OHCI_USB_SUSPEND:
case OHCI_USB_RESUME:
if (changed) {
if (ahcd->autostop)
admhc_rh_resume(ahcd);
else
usb_hcd_resume_root_hub(admhcd_to_hcd(ahcd));
} else {
/* everything is idle, no need for polling */
poll_rh = 0;
}
break;
}
return poll_rh;
}
/*-------------------------------------------------------------------------*/
/* must not be called from interrupt context */
static int admhc_restart(struct admhcd *ahcd)
{
int temp;
int i;
struct urb_priv *priv;
/* mark any devices gone, so they do nothing till khubd disconnects.
* recycle any "live" eds/tds (and urbs) right away.
* later, khubd disconnect processing will recycle the other state,
* (either as disconnect/reconnect, or maybe someday as a reset).
*/
spin_lock_irq(&ahcd->lock);
admhc_disable(ahcd);
usb_root_hub_lost_power(admhcd_to_hcd(ahcd)->self.root_hub);
if (!list_empty(&ahcd->pending))
admhc_dbg(ahcd, "abort schedule...\n");
list_for_each_entry(priv, &ahcd->pending, pending) {
struct urb *urb = priv->td[0]->urb;
struct ed *ed = priv->ed;
switch (ed->state) {
case ED_OPER:
ed->state = ED_UNLINK;
ed->hwINFO |= cpu_to_hc32(ahcd, ED_DEQUEUE);
ed_deschedule (ahcd, ed);
ed->ed_next = ahcd->ed_rm_list;
ed->ed_prev = NULL;
ahcd->ed_rm_list = ed;
/* FALLTHROUGH */
case ED_UNLINK:
break;
default:
admhc_dbg(ahcd, "bogus ed %p state %d\n",
ed, ed->state);
}
spin_lock(&urb->lock);
urb->status = -ESHUTDOWN;
spin_unlock(&urb->lock);
}
finish_unlinks(ahcd, 0);
spin_unlock_irq(&ahcd->lock);
/* paranoia, in case that didn't work: */
/* empty the interrupt branches */
for (i = 0; i < NUM_INTS; i++) ahcd->load[i] = 0;
for (i = 0; i < NUM_INTS; i++) ahcd->hcca->int_table[i] = 0;
/* no EDs to remove */
ahcd->ed_rm_list = NULL;
/* empty control and bulk lists */
ahcd->ed_controltail = NULL;
ahcd->ed_bulktail = NULL;
if ((temp = admhc_run(ahcd)) < 0) {
admhc_err(ahcd, "can't restart, %d\n", temp);
return temp;
} else {
/* here we "know" root ports should always stay powered,
* and that if we try to turn them back on the root hub
* will respond to CSC processing.
*/
i = ahcd->num_ports;
while (i--)
admhc_writel(ahcd, RH_PS_PSS,
&ahcd->regs->portstatus[i]);
admhc_dbg(ahcd, "restart complete\n");
}
return 0;
}
#else /* CONFIG_PM */
static inline int admhc_rh_resume(struct admhcd *ahcd)
{
return 0;
}
/* Carry out polling-related state changes.
* autostop isn't used when CONFIG_PM is turned off.
*/
static int admhc_root_hub_state_changes(struct admhcd *ahcd, int changed,
int any_connected)
{
int poll_rh = 1;
/* keep on polling until RHSC is enabled */
if (admhc_readl(ahcd, &ahcd->regs->int_enable) & ADMHC_INTR_INSM)
poll_rh = 0;
return poll_rh;
}
#endif /* CONFIG_PM */

8
target/linux/adm5120/files/drivers/usb/host/adm5120-q.c
View File

@ -153,7 +153,6 @@ static int ed_schedule(struct admhcd *ahcd, struct ed *ed)
ed->state = ED_IDLE; ed->state = ED_IDLE;
admhc_dma_lock(ahcd);
ed->hwINFO &= ~cpu_to_hc32(ahcd, ED_SKIP); ed->hwINFO &= ~cpu_to_hc32(ahcd, ED_SKIP);
old_tail = ahcd->ed_tails[ed->type]; old_tail = ahcd->ed_tails[ed->type];
@ -169,7 +168,6 @@ static int ed_schedule(struct admhcd *ahcd, struct ed *ed)
old_tail->hwNextED = cpu_to_hc32(ahcd, ed->dma); old_tail->hwNextED = cpu_to_hc32(ahcd, ed->dma);
ahcd->ed_tails[ed->type] = ed; ahcd->ed_tails[ed->type] = ed;
admhc_dma_unlock(ahcd);
admhc_intr_enable(ahcd, ADMHC_INTR_SOFI); admhc_intr_enable(ahcd, ADMHC_INTR_SOFI);
@ -181,9 +179,7 @@ static void ed_deschedule(struct admhcd *ahcd, struct ed *ed)
admhc_dump_ed(ahcd, "ED-DESCHED", ed, 0); admhc_dump_ed(ahcd, "ED-DESCHED", ed, 0);
/* remove this ED from the HC list */ /* remove this ED from the HC list */
admhc_dma_lock(ahcd);
ed->ed_prev->hwNextED = ed->hwNextED; ed->ed_prev->hwNextED = ed->hwNextED;
admhc_dma_unlock(ahcd);
/* and remove it from our list */ /* and remove it from our list */
ed->ed_prev->ed_next = ed->ed_next; ed->ed_prev->ed_next = ed->ed_next;
@ -203,9 +199,7 @@ static void ed_start_deschedule(struct admhcd *ahcd, struct ed *ed)
{ {
admhc_dump_ed(ahcd, "ED-UNLINK", ed, 0); admhc_dump_ed(ahcd, "ED-UNLINK", ed, 0);
admhc_dma_lock(ahcd);
ed->hwINFO |= cpu_to_hc32(ahcd, ED_SKIP); ed->hwINFO |= cpu_to_hc32(ahcd, ED_SKIP);
admhc_dma_unlock(ahcd);
ed->state = ED_UNLINK; ed->state = ED_UNLINK;
@ -573,11 +567,9 @@ static int ed_next_urb(struct admhcd *ahcd, struct ed *ed)
up->td[up->td_cnt-1]->hwNextTD = cpu_to_hc32(ahcd, ed->dummy->td_dma); up->td[up->td_cnt-1]->hwNextTD = cpu_to_hc32(ahcd, ed->dummy->td_dma);
admhc_dma_lock(ahcd);
carry = hc32_to_cpup(ahcd, &ed->hwHeadP) & ED_C; carry = hc32_to_cpup(ahcd, &ed->hwHeadP) & ED_C;
ed->hwHeadP = cpu_to_hc32(ahcd, up->td[0]->td_dma | carry); ed->hwHeadP = cpu_to_hc32(ahcd, up->td[0]->td_dma | carry);
ed->hwINFO &= ~cpu_to_hc32(ahcd, ED_SKIP); ed->hwINFO &= ~cpu_to_hc32(ahcd, ED_SKIP);
admhc_dma_unlock(ahcd);
return 1; return 1;
} }

53
target/linux/adm5120/files/drivers/usb/host/adm5120.h
View File

@ -369,8 +369,6 @@ struct urb_priv {
struct admhcd { struct admhcd {
spinlock_t lock; spinlock_t lock;
spinlock_t dma_lock;
u32 dma_state;
/* /*
* I/O memory used to communicate with the HC (dma-consistent) * I/O memory used to communicate with the HC (dma-consistent)
@ -438,22 +436,6 @@ static inline struct usb_hcd *admhcd_to_hcd(const struct admhcd *ahcd)
#define STUB_DEBUG_FILES #define STUB_DEBUG_FILES
#endif /* DEBUG */ #endif /* DEBUG */
#if 0
#define admhc_dbg(ahcd, fmt, args...) \
dev_dbg(admhcd_to_hcd(ahcd)->self.controller , fmt , ## args )
#define admhc_err(ahcd, fmt, args...) \
dev_err(admhcd_to_hcd(ahcd)->self.controller , fmt , ## args )
#define ahcd_info(ahcd, fmt, args...) \
dev_info(admhcd_to_hcd(ahcd)->self.controller , fmt , ## args )
#define admhc_warn(ahcd, fmt, args...) \
dev_warn(admhcd_to_hcd(ahcd)->self.controller , fmt , ## args )
#ifdef ADMHC_VERBOSE_DEBUG
# define admhc_vdbg admhc_dbg
#else
# define admhc_vdbg(ahcd, fmt, args...) do { } while (0)
#endif
#else
#define admhc_dbg(ahcd, fmt, args...) \ #define admhc_dbg(ahcd, fmt, args...) \
printk(KERN_DEBUG "adm5120-hcd: " fmt , ## args ) printk(KERN_DEBUG "adm5120-hcd: " fmt , ## args )
#define admhc_err(ahcd, fmt, args...) \ #define admhc_err(ahcd, fmt, args...) \
@ -468,7 +450,6 @@ static inline struct usb_hcd *admhcd_to_hcd(const struct admhcd *ahcd)
#else #else
# define admhc_vdbg(ahcd, fmt, args...) do { } while (0) # define admhc_vdbg(ahcd, fmt, args...) do { } while (0)
#endif #endif
#endif
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
@ -564,14 +545,6 @@ static inline void admhc_writel(const struct admhcd *ahcd,
#endif #endif
} }
static inline void admhc_writel_flush(const struct admhcd *ahcd)
{
#if 0 /* TODO: needed? */
(void) admhc_readl(ahcd, &ahcd->regs->control);
#endif
}
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/* cpu to ahcd */ /* cpu to ahcd */
@ -659,13 +632,12 @@ static inline void admhc_disable(struct admhcd *ahcd)
} }
#define FI 0x2edf /* 12000 bits per frame (-1) */ #define FI 0x2edf /* 12000 bits per frame (-1) */
#define FSLDP(fi) (0x7fff & ((6 * ((fi) - 210)) / 7)) #define FSLDP(fi) (0x7fff & ((6 * ((fi) - 1200)) / 7))
#define FIT ADMHC_SFI_FIT #define FIT ADMHC_SFI_FIT
#define LSTHRESH 0x628 /* lowspeed bit threshold */ #define LSTHRESH 0x628 /* lowspeed bit threshold */
static inline void periodic_reinit(struct admhcd *ahcd) static inline void periodic_reinit(struct admhcd *ahcd)
{ {
u32 fi = ahcd->fminterval & ADMHC_SFI_FI_MASK;
u32 fit = admhc_readl(ahcd, &ahcd->regs->fminterval) & FIT; u32 fit = admhc_readl(ahcd, &ahcd->regs->fminterval) & FIT;
/* TODO: adjust FSLargestDataPacket value too? */ /* TODO: adjust FSLargestDataPacket value too? */
@ -724,7 +696,7 @@ static inline void admhc_dma_enable(struct admhcd *ahcd)
t |= ADMHC_HC_DMAE; t |= ADMHC_HC_DMAE;
admhc_writel(ahcd, t, &ahcd->regs->host_control); admhc_writel(ahcd, t, &ahcd->regs->host_control);
admhc_dbg(ahcd,"DMA enabled\n"); admhc_vdbg(ahcd,"DMA enabled\n");
} }
static inline void admhc_dma_disable(struct admhcd *ahcd) static inline void admhc_dma_disable(struct admhcd *ahcd)
@ -737,24 +709,5 @@ static inline void admhc_dma_disable(struct admhcd *ahcd)
t &= ~ADMHC_HC_DMAE; t &= ~ADMHC_HC_DMAE;
admhc_writel(ahcd, t, &ahcd->regs->host_control); admhc_writel(ahcd, t, &ahcd->regs->host_control);
admhc_dbg(ahcd,"DMA disabled\n"); admhc_vdbg(ahcd,"DMA disabled\n");
}
static inline void admhc_dma_lock(struct admhcd *ahcd)
{
spin_lock(ahcd->dma_lock);
ahcd->dma_state = admhc_readl(ahcd, &ahcd->regs->host_control);
admhc_writel(ahcd, 0, &ahcd->regs->hosthead);
admhc_writel(ahcd, ahcd->dma_state & ~ADMHC_HC_DMAE,
&ahcd->regs->host_control);
admhc_dbg(ahcd,"DMA locked\n");
}
static inline void admhc_dma_unlock(struct admhcd *ahcd)
{
admhc_writel(ahcd, (u32)ahcd->ed_head->dma, &ahcd->regs->hosthead);
admhc_writel(ahcd, ahcd->dma_state, &ahcd->regs->host_control);
admhc_dbg(ahcd,"DMA unlocked\n");
spin_unlock(ahcd->dma_lock);
} }