source: trunk/target/linux/adm5120/files/drivers/usb/host/adm5120-pm.c @ 31511

Last change on this file since 31511 was 31511, checked in by juhosg, 4 years ago

adm5120: merge 3.3 patches

  • Property svn:eol-style set to native
File size: 12.0 KB
Line 
1/*
2 * ADM5120 HCD (Host Controller Driver) for USB
3 *
4 * Copyright (C) 2007-2008 Gabor Juhos <juhosg@openwrt.org>
5 *
6 * This file was derived from fragments of the OHCI driver.
7 *   (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
8 *   (C) Copyright 2000-2004 David Brownell <dbrownell@users.sourceforge.net>
9 *
10 *  This program is free software; you can redistribute it and/or modify it
11 *  under the terms of the GNU General Public License version 2 as published
12 *  by the Free Software Foundation.
13 *
14 */
15
16#define OHCI_SCHED_ENABLES \
17        (OHCI_CTRL_CLE|OHCI_CTRL_BLE|OHCI_CTRL_PLE|OHCI_CTRL_IE)
18
19#ifdef  CONFIG_PM
20static int admhc_restart(struct admhcd *ahcd);
21
22static int admhc_rh_suspend(struct admhcd *ahcd, int autostop)
23__releases(ahcd->lock)
24__acquires(ahcd->lock)
25{
26        int                     status = 0;
27
28        ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control);
29        switch (ahcd->hc_control & OHCI_CTRL_HCFS) {
30        case OHCI_USB_RESUME:
31                admhc_dbg(ahcd, "resume/suspend?\n");
32                ahcd->hc_control &= ~OHCI_CTRL_HCFS;
33                ahcd->hc_control |= OHCI_USB_RESET;
34                admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
35                (void) admhc_readl(ahcd, &ahcd->regs->control);
36                /* FALL THROUGH */
37        case OHCI_USB_RESET:
38                status = -EBUSY;
39                admhc_dbg(ahcd, "needs reinit!\n");
40                goto done;
41        case OHCI_USB_SUSPEND:
42                if (!ahcd->autostop) {
43                        admhc_dbg(ahcd, "already suspended\n");
44                        goto done;
45                }
46        }
47        admhc_dbg(ahcd, "%s root hub\n",
48                        autostop ? "auto-stop" : "suspend");
49
50        /* First stop any processing */
51        if (!autostop && (ahcd->hc_control & OHCI_SCHED_ENABLES)) {
52                ahcd->hc_control &= ~OHCI_SCHED_ENABLES;
53                admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
54                ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control);
55                admhc_writel(ahcd, OHCI_INTR_SF, &ahcd->regs->intrstatus);
56
57                /* sched disables take effect on the next frame,
58                 * then the last WDH could take 6+ msec
59                 */
60                admhc_dbg(ahcd, "stopping schedules ...\n");
61                ahcd->autostop = 0;
62                spin_unlock_irq (&ahcd->lock);
63                msleep (8);
64                spin_lock_irq(&ahcd->lock);
65        }
66        dl_done_list (ahcd);
67        finish_unlinks (ahcd, admhc_frame_no(ahcd));
68
69        /* maybe resume can wake root hub */
70        if (device_may_wakeup(&admhcd_to_hcd(ahcd)->self.root_hub->dev) ||
71                        autostop)
72                ahcd->hc_control |= OHCI_CTRL_RWE;
73        else {
74                admhc_writel(ahcd, OHCI_INTR_RHSC, &ahcd->regs->intrdisable);
75                ahcd->hc_control &= ~OHCI_CTRL_RWE;
76        }
77
78        /* Suspend hub ... this is the "global (to this bus) suspend" mode,
79         * which doesn't imply ports will first be individually suspended.
80         */
81        ahcd->hc_control &= ~OHCI_CTRL_HCFS;
82        ahcd->hc_control |= OHCI_USB_SUSPEND;
83        admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
84        (void) admhc_readl(ahcd, &ahcd->regs->control);
85
86        /* no resumes until devices finish suspending */
87        if (!autostop) {
88                ahcd->next_statechange = jiffies + msecs_to_jiffies (5);
89                ahcd->autostop = 0;
90        }
91
92done:
93        return status;
94}
95
96static inline struct ed *find_head(struct ed *ed)
97{
98        /* for bulk and control lists */
99        while (ed->ed_prev)
100                ed = ed->ed_prev;
101        return ed;
102}
103
104/* caller has locked the root hub */
105static int admhc_rh_resume(struct admhcd *ahcd)
106__releases(ahcd->lock)
107__acquires(ahcd->lock)
108{
109        struct usb_hcd          *hcd = admhcd_to_hcd (ahcd);
110        u32                     temp, enables;
111        int                     status = -EINPROGRESS;
112        int                     autostopped = ahcd->autostop;
113
114        ahcd->autostop = 0;
115        ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control);
116
117        if (ahcd->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) {
118                /* this can happen after resuming a swsusp snapshot */
119                if (hcd->state == HC_STATE_RESUMING) {
120                        admhc_dbg(ahcd, "BIOS/SMM active, control %03x\n",
121                                        ahcd->hc_control);
122                        status = -EBUSY;
123                /* this happens when pmcore resumes HC then root */
124                } else {
125                        admhc_dbg(ahcd, "duplicate resume\n");
126                        status = 0;
127                }
128        } else switch (ahcd->hc_control & OHCI_CTRL_HCFS) {
129        case OHCI_USB_SUSPEND:
130                ahcd->hc_control &= ~(OHCI_CTRL_HCFS|OHCI_SCHED_ENABLES);
131                ahcd->hc_control |= OHCI_USB_RESUME;
132                admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
133                (void) admhc_readl(ahcd, &ahcd->regs->control);
134                admhc_dbg(ahcd, "%s root hub\n",
135                                autostopped ? "auto-start" : "resume");
136                break;
137        case OHCI_USB_RESUME:
138                /* HCFS changes sometime after INTR_RD */
139                admhc_dbg(ahcd, "%swakeup root hub\n",
140                                autostopped ? "auto-" : "");
141                break;
142        case OHCI_USB_OPER:
143                /* this can happen after resuming a swsusp snapshot */
144                admhc_dbg(ahcd, "snapshot resume? reinit\n");
145                status = -EBUSY;
146                break;
147        default:                /* RESET, we lost power */
148                admhc_dbg(ahcd, "lost power\n");
149                status = -EBUSY;
150        }
151        if (status == -EBUSY) {
152                if (!autostopped) {
153                        spin_unlock_irq (&ahcd->lock);
154                        (void) ahcd_init (ahcd);
155                        status = admhc_restart (ahcd);
156                        spin_lock_irq(&ahcd->lock);
157                }
158                return status;
159        }
160        if (status != -EINPROGRESS)
161                return status;
162        if (autostopped)
163                goto skip_resume;
164        spin_unlock_irq (&ahcd->lock);
165
166        /* Some controllers (lucent erratum) need extra-long delays */
167        msleep (20 /* usb 11.5.1.10 */ + 12 /* 32 msec counter */ + 1);
168
169        temp = admhc_readl(ahcd, &ahcd->regs->control);
170        temp &= OHCI_CTRL_HCFS;
171        if (temp != OHCI_USB_RESUME) {
172                admhc_err (ahcd, "controller won't resume\n");
173                spin_lock_irq(&ahcd->lock);
174                return -EBUSY;
175        }
176
177        /* disable old schedule state, reinit from scratch */
178        admhc_writel(ahcd, 0, &ahcd->regs->ed_controlhead);
179        admhc_writel(ahcd, 0, &ahcd->regs->ed_controlcurrent);
180        admhc_writel(ahcd, 0, &ahcd->regs->ed_bulkhead);
181        admhc_writel(ahcd, 0, &ahcd->regs->ed_bulkcurrent);
182        admhc_writel(ahcd, 0, &ahcd->regs->ed_periodcurrent);
183        admhc_writel(ahcd, (u32) ahcd->hcca_dma, &ahcd->ahcd->regs->hcca);
184
185        /* Sometimes PCI D3 suspend trashes frame timings ... */
186        periodic_reinit(ahcd);
187
188        /* the following code is executed with ahcd->lock held and
189         * irqs disabled if and only if autostopped is true
190         */
191
192skip_resume:
193        /* interrupts might have been disabled */
194        admhc_writel(ahcd, OHCI_INTR_INIT, &ahcd->regs->int_enable);
195        if (ahcd->ed_rm_list)
196                admhc_writel(ahcd, OHCI_INTR_SF, &ahcd->regs->int_enable);
197
198        /* Then re-enable operations */
199        admhc_writel(ahcd, OHCI_USB_OPER, &ahcd->regs->control);
200        (void) admhc_readl(ahcd, &ahcd->regs->control);
201        if (!autostopped)
202                msleep (3);
203
204        temp = ahcd->hc_control;
205        temp &= OHCI_CTRL_RWC;
206        temp |= OHCI_CONTROL_INIT | OHCI_USB_OPER;
207        ahcd->hc_control = temp;
208        admhc_writel(ahcd, temp, &ahcd->regs->control);
209        (void) admhc_readl(ahcd, &ahcd->regs->control);
210
211        /* TRSMRCY */
212        if (!autostopped) {
213                msleep (10);
214                spin_lock_irq(&ahcd->lock);
215        }
216        /* now ahcd->lock is always held and irqs are always disabled */
217
218        /* keep it alive for more than ~5x suspend + resume costs */
219        ahcd->next_statechange = jiffies + STATECHANGE_DELAY;
220
221        /* maybe turn schedules back on */
222        enables = 0;
223        temp = 0;
224        if (!ahcd->ed_rm_list) {
225                if (ahcd->ed_controltail) {
226                        admhc_writel(ahcd,
227                                        find_head (ahcd->ed_controltail)->dma,
228                                        &ahcd->regs->ed_controlhead);
229                        enables |= OHCI_CTRL_CLE;
230                        temp |= OHCI_CLF;
231                }
232                if (ahcd->ed_bulktail) {
233                        admhc_writel(ahcd, find_head (ahcd->ed_bulktail)->dma,
234                                &ahcd->regs->ed_bulkhead);
235                        enables |= OHCI_CTRL_BLE;
236                        temp |= OHCI_BLF;
237                }
238        }
239        if (hcd->self.bandwidth_isoc_reqs || hcd->self.bandwidth_int_reqs)
240                enables |= OHCI_CTRL_PLE|OHCI_CTRL_IE;
241        if (enables) {
242                admhc_dbg(ahcd, "restarting schedules ... %08x\n", enables);
243                ahcd->hc_control |= enables;
244                admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
245                if (temp)
246                        admhc_writel(ahcd, temp, &ahcd->regs->cmdstatus);
247                (void) admhc_readl(ahcd, &ahcd->regs->control);
248        }
249
250        return 0;
251}
252
253static int admhc_bus_suspend(struct usb_hcd *hcd)
254{
255        struct admhcd   *ahcd = hcd_to_admhcd(hcd);
256        int             rc;
257
258        spin_lock_irq(&ahcd->lock);
259
260        if (unlikely(!HCD_HW_ACCESSIBLE(hcd)))
261                rc = -ESHUTDOWN;
262        else
263                rc = admhc_rh_suspend(ahcd, 0);
264        spin_unlock_irq(&ahcd->lock);
265        return rc;
266}
267
268static int admhc_bus_resume(struct usb_hcd *hcd)
269{
270        struct admhcd           *ahcd = hcd_to_admhcd(hcd);
271        int                     rc;
272
273        if (time_before(jiffies, ahcd->next_statechange))
274                msleep(5);
275
276        spin_lock_irq(&ahcd->lock);
277
278        if (unlikely(!HCD_HW_ACCESSIBLE(hcd)))
279                rc = -ESHUTDOWN;
280        else
281                rc = admhc_rh_resume(ahcd);
282        spin_unlock_irq(&ahcd->lock);
283
284        /* poll until we know a device is connected or we autostop */
285        if (rc == 0)
286                usb_hcd_poll_rh_status(hcd);
287        return rc;
288}
289
290/* Carry out polling-, autostop-, and autoresume-related state changes */
291static int admhc_root_hub_state_changes(struct admhcd *ahcd, int changed,
292                int any_connected)
293{
294        int     poll_rh = 1;
295
296        switch (ahcd->hc_control & OHCI_CTRL_HCFS) {
297
298        case OHCI_USB_OPER:
299                /* keep on polling until we know a device is connected
300                 * and RHSC is enabled */
301                if (!ahcd->autostop) {
302                        if (any_connected ||
303                                        !device_may_wakeup(&admhcd_to_hcd(ahcd)
304                                                ->self.root_hub->dev)) {
305                                if (admhc_readl(ahcd, &ahcd->regs->int_enable) &
306                                                OHCI_INTR_RHSC)
307                                        poll_rh = 0;
308                        } else {
309                                ahcd->autostop = 1;
310                                ahcd->next_statechange = jiffies + HZ;
311                        }
312
313                /* if no devices have been attached for one second, autostop */
314                } else {
315                        if (changed || any_connected) {
316                                ahcd->autostop = 0;
317                                ahcd->next_statechange = jiffies +
318                                                STATECHANGE_DELAY;
319                        } else if (time_after_eq(jiffies,
320                                                ahcd->next_statechange)
321                                        && !ahcd->ed_rm_list
322                                        && !(ahcd->hc_control &
323                                                OHCI_SCHED_ENABLES)) {
324                                ahcd_rh_suspend(ahcd, 1);
325                        }
326                }
327                break;
328
329        /* if there is a port change, autostart or ask to be resumed */
330        case OHCI_USB_SUSPEND:
331        case OHCI_USB_RESUME:
332                if (changed) {
333                        if (ahcd->autostop)
334                                admhc_rh_resume(ahcd);
335                        else
336                                usb_hcd_resume_root_hub(admhcd_to_hcd(ahcd));
337                } else {
338                        /* everything is idle, no need for polling */
339                        poll_rh = 0;
340                }
341                break;
342        }
343        return poll_rh;
344}
345
346/*-------------------------------------------------------------------------*/
347
348/* must not be called from interrupt context */
349static int admhc_restart(struct admhcd *ahcd)
350{
351        int temp;
352        int i;
353        struct urb_priv *priv;
354
355        /* mark any devices gone, so they do nothing till khubd disconnects.
356         * recycle any "live" eds/tds (and urbs) right away.
357         * later, khubd disconnect processing will recycle the other state,
358         * (either as disconnect/reconnect, or maybe someday as a reset).
359         */
360        spin_lock_irq(&ahcd->lock);
361        admhc_disable(ahcd);
362        usb_root_hub_lost_power(admhcd_to_hcd(ahcd)->self.root_hub);
363        if (!list_empty(&ahcd->pending))
364                admhc_dbg(ahcd, "abort schedule...\n");
365                list_for_each_entry(priv, &ahcd->pending, pending) {
366                struct urb      *urb = priv->td[0]->urb;
367                struct ed       *ed = priv->ed;
368
369                switch (ed->state) {
370                case ED_OPER:
371                        ed->state = ED_UNLINK;
372                        ed->hwINFO |= cpu_to_hc32(ahcd, ED_DEQUEUE);
373                        ed_deschedule (ahcd, ed);
374
375                        ed->ed_next = ahcd->ed_rm_list;
376                        ed->ed_prev = NULL;
377                        ahcd->ed_rm_list = ed;
378                        /* FALLTHROUGH */
379                case ED_UNLINK:
380                        break;
381                default:
382                        admhc_dbg(ahcd, "bogus ed %p state %d\n",
383                                        ed, ed->state);
384                }
385
386                if (!urb->unlinked)
387                        urb->unlinked = -ESHUTDOWN;
388        }
389        finish_unlinks(ahcd, 0);
390        spin_unlock_irq(&ahcd->lock);
391
392        /* paranoia, in case that didn't work: */
393
394        /* empty the interrupt branches */
395        for (i = 0; i < NUM_INTS; i++) ahcd->load[i] = 0;
396        for (i = 0; i < NUM_INTS; i++) ahcd->hcca->int_table[i] = 0;
397
398        /* no EDs to remove */
399        ahcd->ed_rm_list = NULL;
400
401        /* empty control and bulk lists */
402        ahcd->ed_controltail = NULL;
403        ahcd->ed_bulktail    = NULL;
404
405        if ((temp = admhc_run(ahcd)) < 0) {
406                admhc_err(ahcd, "can't restart, %d\n", temp);
407                return temp;
408        } else {
409                /* here we "know" root ports should always stay powered,
410                 * and that if we try to turn them back on the root hub
411                 * will respond to CSC processing.
412                 */
413                i = ahcd->num_ports;
414                while (i--)
415                        admhc_writel(ahcd, RH_PS_PSS,
416                                &ahcd->regs->portstatus[i]);
417                admhc_dbg(ahcd, "restart complete\n");
418        }
419        return 0;
420}
421
422#else   /* CONFIG_PM */
423
424static inline int admhc_rh_resume(struct admhcd *ahcd)
425{
426        return 0;
427}
428
429/* Carry out polling-related state changes.
430 * autostop isn't used when CONFIG_PM is turned off.
431 */
432static int admhc_root_hub_state_changes(struct admhcd *ahcd, int changed,
433                int any_connected)
434{
435        /* If INSM is enabled, don't poll */
436        if (admhc_readl(ahcd, &ahcd->regs->int_enable) & ADMHC_INTR_INSM)
437                return 0;
438
439        /* If no status changes are pending, enable status-change interrupts */
440        if (!changed) {
441                admhc_intr_enable(ahcd, ADMHC_INTR_INSM);
442                return 0;
443        }
444
445        return 1;
446}
447
448#endif  /* CONFIG_PM */
449
Note: See TracBrowser for help on using the repository browser.