aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/host/ehci-tegra.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/usb/host/ehci-tegra.c')
-rw-r--r--drivers/usb/host/ehci-tegra.c379
1 files changed, 197 insertions, 182 deletions
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index 3de48a2d7955..f214a80cdee2 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -24,6 +24,7 @@
24#include <linux/gpio.h> 24#include <linux/gpio.h>
25#include <linux/of.h> 25#include <linux/of.h>
26#include <linux/of_gpio.h> 26#include <linux/of_gpio.h>
27#include <linux/pm_runtime.h>
27 28
28#include <mach/usb_phy.h> 29#include <mach/usb_phy.h>
29#include <mach/iomap.h> 30#include <mach/iomap.h>
@@ -37,9 +38,7 @@ struct tegra_ehci_hcd {
37 struct clk *emc_clk; 38 struct clk *emc_clk;
38 struct usb_phy *transceiver; 39 struct usb_phy *transceiver;
39 int host_resumed; 40 int host_resumed;
40 int bus_suspended;
41 int port_resuming; 41 int port_resuming;
42 int power_down_on_bus_suspend;
43 enum tegra_usb_phy_port_speed port_speed; 42 enum tegra_usb_phy_port_speed port_speed;
44}; 43};
45 44
@@ -224,6 +223,7 @@ static int tegra_ehci_hub_control(
224 temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS); 223 temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
225 /* start resume signalling */ 224 /* start resume signalling */
226 ehci_writel(ehci, temp | PORT_RESUME, status_reg); 225 ehci_writel(ehci, temp | PORT_RESUME, status_reg);
226 set_bit(wIndex-1, &ehci->resuming_ports);
227 227
228 spin_unlock_irqrestore(&ehci->lock, flags); 228 spin_unlock_irqrestore(&ehci->lock, flags);
229 msleep(20); 229 msleep(20);
@@ -236,6 +236,7 @@ static int tegra_ehci_hub_control(
236 pr_err("%s: timeout waiting for SUSPEND\n", __func__); 236 pr_err("%s: timeout waiting for SUSPEND\n", __func__);
237 237
238 ehci->reset_done[wIndex-1] = 0; 238 ehci->reset_done[wIndex-1] = 0;
239 clear_bit(wIndex-1, &ehci->resuming_ports);
239 240
240 tegra->port_resuming = 1; 241 tegra->port_resuming = 1;
241 goto done; 242 goto done;
@@ -271,120 +272,6 @@ static void tegra_ehci_restart(struct usb_hcd *hcd)
271 up_write(&ehci_cf_port_reset_rwsem); 272 up_write(&ehci_cf_port_reset_rwsem);
272} 273}
273 274
274static int tegra_usb_suspend(struct usb_hcd *hcd)
275{
276 struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
277 struct ehci_regs __iomem *hw = tegra->ehci->regs;
278 unsigned long flags;
279
280 spin_lock_irqsave(&tegra->ehci->lock, flags);
281
282 tegra->port_speed = (readl(&hw->port_status[0]) >> 26) & 0x3;
283 ehci_halt(tegra->ehci);
284 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
285
286 spin_unlock_irqrestore(&tegra->ehci->lock, flags);
287
288 tegra_ehci_power_down(hcd);
289 return 0;
290}
291
292static int tegra_usb_resume(struct usb_hcd *hcd)
293{
294 struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
295 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
296 struct ehci_regs __iomem *hw = ehci->regs;
297 unsigned long val;
298
299 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
300 tegra_ehci_power_up(hcd);
301
302 if (tegra->port_speed > TEGRA_USB_PHY_PORT_SPEED_HIGH) {
303 /* Wait for the phy to detect new devices
304 * before we restart the controller */
305 msleep(10);
306 goto restart;
307 }
308
309 /* Force the phy to keep data lines in suspend state */
310 tegra_ehci_phy_restore_start(tegra->phy, tegra->port_speed);
311
312 /* Enable host mode */
313 tdi_reset(ehci);
314
315 /* Enable Port Power */
316 val = readl(&hw->port_status[0]);
317 val |= PORT_POWER;
318 writel(val, &hw->port_status[0]);
319 udelay(10);
320
321 /* Check if the phy resume from LP0. When the phy resume from LP0
322 * USB register will be reset. */
323 if (!readl(&hw->async_next)) {
324 /* Program the field PTC based on the saved speed mode */
325 val = readl(&hw->port_status[0]);
326 val &= ~PORT_TEST(~0);
327 if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_HIGH)
328 val |= PORT_TEST_FORCE;
329 else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_FULL)
330 val |= PORT_TEST(6);
331 else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_LOW)
332 val |= PORT_TEST(7);
333 writel(val, &hw->port_status[0]);
334 udelay(10);
335
336 /* Disable test mode by setting PTC field to NORMAL_OP */
337 val = readl(&hw->port_status[0]);
338 val &= ~PORT_TEST(~0);
339 writel(val, &hw->port_status[0]);
340 udelay(10);
341 }
342
343 /* Poll until CCS is enabled */
344 if (handshake(ehci, &hw->port_status[0], PORT_CONNECT,
345 PORT_CONNECT, 2000)) {
346 pr_err("%s: timeout waiting for PORT_CONNECT\n", __func__);
347 goto restart;
348 }
349
350 /* Poll until PE is enabled */
351 if (handshake(ehci, &hw->port_status[0], PORT_PE,
352 PORT_PE, 2000)) {
353 pr_err("%s: timeout waiting for USB_PORTSC1_PE\n", __func__);
354 goto restart;
355 }
356
357 /* Clear the PCI status, to avoid an interrupt taken upon resume */
358 val = readl(&hw->status);
359 val |= STS_PCD;
360 writel(val, &hw->status);
361
362 /* Put controller in suspend mode by writing 1 to SUSP bit of PORTSC */
363 val = readl(&hw->port_status[0]);
364 if ((val & PORT_POWER) && (val & PORT_PE)) {
365 val |= PORT_SUSPEND;
366 writel(val, &hw->port_status[0]);
367
368 /* Wait until port suspend completes */
369 if (handshake(ehci, &hw->port_status[0], PORT_SUSPEND,
370 PORT_SUSPEND, 1000)) {
371 pr_err("%s: timeout waiting for PORT_SUSPEND\n",
372 __func__);
373 goto restart;
374 }
375 }
376
377 tegra_ehci_phy_restore_end(tegra->phy);
378 return 0;
379
380restart:
381 if (tegra->port_speed <= TEGRA_USB_PHY_PORT_SPEED_HIGH)
382 tegra_ehci_phy_restore_end(tegra->phy);
383
384 tegra_ehci_restart(hcd);
385 return 0;
386}
387
388static void tegra_ehci_shutdown(struct usb_hcd *hcd) 275static void tegra_ehci_shutdown(struct usb_hcd *hcd)
389{ 276{
390 struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller); 277 struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
@@ -432,36 +319,6 @@ static int tegra_ehci_setup(struct usb_hcd *hcd)
432 return retval; 319 return retval;
433} 320}
434 321
435#ifdef CONFIG_PM
436static int tegra_ehci_bus_suspend(struct usb_hcd *hcd)
437{
438 struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
439 int error_status = 0;
440
441 error_status = ehci_bus_suspend(hcd);
442 if (!error_status && tegra->power_down_on_bus_suspend) {
443 tegra_usb_suspend(hcd);
444 tegra->bus_suspended = 1;
445 }
446
447 return error_status;
448}
449
450static int tegra_ehci_bus_resume(struct usb_hcd *hcd)
451{
452 struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
453
454 if (tegra->bus_suspended && tegra->power_down_on_bus_suspend) {
455 tegra_usb_resume(hcd);
456 tegra->bus_suspended = 0;
457 }
458
459 tegra_usb_phy_preresume(tegra->phy);
460 tegra->port_resuming = 1;
461 return ehci_bus_resume(hcd);
462}
463#endif
464
465struct temp_buffer { 322struct temp_buffer {
466 void *kmalloc_ptr; 323 void *kmalloc_ptr;
467 void *old_xfer_buffer; 324 void *old_xfer_buffer;
@@ -572,8 +429,8 @@ static const struct hc_driver tegra_ehci_hc_driver = {
572 .hub_control = tegra_ehci_hub_control, 429 .hub_control = tegra_ehci_hub_control,
573 .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete, 430 .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
574#ifdef CONFIG_PM 431#ifdef CONFIG_PM
575 .bus_suspend = tegra_ehci_bus_suspend, 432 .bus_suspend = ehci_bus_suspend,
576 .bus_resume = tegra_ehci_bus_resume, 433 .bus_resume = ehci_bus_resume,
577#endif 434#endif
578 .relinquish_port = ehci_relinquish_port, 435 .relinquish_port = ehci_relinquish_port,
579 .port_handed_over = ehci_port_handed_over, 436 .port_handed_over = ehci_port_handed_over,
@@ -601,11 +458,187 @@ static int setup_vbus_gpio(struct platform_device *pdev)
601 dev_err(&pdev->dev, "can't enable vbus\n"); 458 dev_err(&pdev->dev, "can't enable vbus\n");
602 return err; 459 return err;
603 } 460 }
604 gpio_set_value(gpio, 1);
605 461
606 return err; 462 return err;
607} 463}
608 464
465#ifdef CONFIG_PM
466
467static int controller_suspend(struct device *dev)
468{
469 struct tegra_ehci_hcd *tegra =
470 platform_get_drvdata(to_platform_device(dev));
471 struct ehci_hcd *ehci = tegra->ehci;
472 struct usb_hcd *hcd = ehci_to_hcd(ehci);
473 struct ehci_regs __iomem *hw = ehci->regs;
474 unsigned long flags;
475
476 if (time_before(jiffies, ehci->next_statechange))
477 msleep(10);
478
479 spin_lock_irqsave(&ehci->lock, flags);
480
481 tegra->port_speed = (readl(&hw->port_status[0]) >> 26) & 0x3;
482 ehci_halt(ehci);
483 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
484
485 spin_unlock_irqrestore(&ehci->lock, flags);
486
487 tegra_ehci_power_down(hcd);
488 return 0;
489}
490
491static int controller_resume(struct device *dev)
492{
493 struct tegra_ehci_hcd *tegra =
494 platform_get_drvdata(to_platform_device(dev));
495 struct ehci_hcd *ehci = tegra->ehci;
496 struct usb_hcd *hcd = ehci_to_hcd(ehci);
497 struct ehci_regs __iomem *hw = ehci->regs;
498 unsigned long val;
499
500 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
501 tegra_ehci_power_up(hcd);
502
503 if (tegra->port_speed > TEGRA_USB_PHY_PORT_SPEED_HIGH) {
504 /* Wait for the phy to detect new devices
505 * before we restart the controller */
506 msleep(10);
507 goto restart;
508 }
509
510 /* Force the phy to keep data lines in suspend state */
511 tegra_ehci_phy_restore_start(tegra->phy, tegra->port_speed);
512
513 /* Enable host mode */
514 tdi_reset(ehci);
515
516 /* Enable Port Power */
517 val = readl(&hw->port_status[0]);
518 val |= PORT_POWER;
519 writel(val, &hw->port_status[0]);
520 udelay(10);
521
522 /* Check if the phy resume from LP0. When the phy resume from LP0
523 * USB register will be reset. */
524 if (!readl(&hw->async_next)) {
525 /* Program the field PTC based on the saved speed mode */
526 val = readl(&hw->port_status[0]);
527 val &= ~PORT_TEST(~0);
528 if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_HIGH)
529 val |= PORT_TEST_FORCE;
530 else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_FULL)
531 val |= PORT_TEST(6);
532 else if (tegra->port_speed == TEGRA_USB_PHY_PORT_SPEED_LOW)
533 val |= PORT_TEST(7);
534 writel(val, &hw->port_status[0]);
535 udelay(10);
536
537 /* Disable test mode by setting PTC field to NORMAL_OP */
538 val = readl(&hw->port_status[0]);
539 val &= ~PORT_TEST(~0);
540 writel(val, &hw->port_status[0]);
541 udelay(10);
542 }
543
544 /* Poll until CCS is enabled */
545 if (handshake(ehci, &hw->port_status[0], PORT_CONNECT,
546 PORT_CONNECT, 2000)) {
547 pr_err("%s: timeout waiting for PORT_CONNECT\n", __func__);
548 goto restart;
549 }
550
551 /* Poll until PE is enabled */
552 if (handshake(ehci, &hw->port_status[0], PORT_PE,
553 PORT_PE, 2000)) {
554 pr_err("%s: timeout waiting for USB_PORTSC1_PE\n", __func__);
555 goto restart;
556 }
557
558 /* Clear the PCI status, to avoid an interrupt taken upon resume */
559 val = readl(&hw->status);
560 val |= STS_PCD;
561 writel(val, &hw->status);
562
563 /* Put controller in suspend mode by writing 1 to SUSP bit of PORTSC */
564 val = readl(&hw->port_status[0]);
565 if ((val & PORT_POWER) && (val & PORT_PE)) {
566 val |= PORT_SUSPEND;
567 writel(val, &hw->port_status[0]);
568
569 /* Wait until port suspend completes */
570 if (handshake(ehci, &hw->port_status[0], PORT_SUSPEND,
571 PORT_SUSPEND, 1000)) {
572 pr_err("%s: timeout waiting for PORT_SUSPEND\n",
573 __func__);
574 goto restart;
575 }
576 }
577
578 tegra_ehci_phy_restore_end(tegra->phy);
579 goto done;
580
581 restart:
582 if (tegra->port_speed <= TEGRA_USB_PHY_PORT_SPEED_HIGH)
583 tegra_ehci_phy_restore_end(tegra->phy);
584
585 tegra_ehci_restart(hcd);
586
587 done:
588 tegra_usb_phy_preresume(tegra->phy);
589 tegra->port_resuming = 1;
590 return 0;
591}
592
593static int tegra_ehci_suspend(struct device *dev)
594{
595 struct tegra_ehci_hcd *tegra =
596 platform_get_drvdata(to_platform_device(dev));
597 struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci);
598 int rc = 0;
599
600 /*
601 * When system sleep is supported and USB controller wakeup is
602 * implemented: If the controller is runtime-suspended and the
603 * wakeup setting needs to be changed, call pm_runtime_resume().
604 */
605 if (HCD_HW_ACCESSIBLE(hcd))
606 rc = controller_suspend(dev);
607 return rc;
608}
609
610static int tegra_ehci_resume(struct device *dev)
611{
612 int rc;
613
614 rc = controller_resume(dev);
615 if (rc == 0) {
616 pm_runtime_disable(dev);
617 pm_runtime_set_active(dev);
618 pm_runtime_enable(dev);
619 }
620 return rc;
621}
622
623static int tegra_ehci_runtime_suspend(struct device *dev)
624{
625 return controller_suspend(dev);
626}
627
628static int tegra_ehci_runtime_resume(struct device *dev)
629{
630 return controller_resume(dev);
631}
632
633static const struct dev_pm_ops tegra_ehci_pm_ops = {
634 .suspend = tegra_ehci_suspend,
635 .resume = tegra_ehci_resume,
636 .runtime_suspend = tegra_ehci_runtime_suspend,
637 .runtime_resume = tegra_ehci_runtime_resume,
638};
639
640#endif
641
609static u64 tegra_ehci_dma_mask = DMA_BIT_MASK(32); 642static u64 tegra_ehci_dma_mask = DMA_BIT_MASK(32);
610 643
611static int tegra_ehci_probe(struct platform_device *pdev) 644static int tegra_ehci_probe(struct platform_device *pdev)
@@ -720,7 +753,6 @@ static int tegra_ehci_probe(struct platform_device *pdev)
720 } 753 }
721 754
722 tegra->host_resumed = 1; 755 tegra->host_resumed = 1;
723 tegra->power_down_on_bus_suspend = pdata->power_down_on_bus_suspend;
724 tegra->ehci = hcd_to_ehci(hcd); 756 tegra->ehci = hcd_to_ehci(hcd);
725 757
726 irq = platform_get_irq(pdev, 0); 758 irq = platform_get_irq(pdev, 0);
@@ -729,7 +761,6 @@ static int tegra_ehci_probe(struct platform_device *pdev)
729 err = -ENODEV; 761 err = -ENODEV;
730 goto fail; 762 goto fail;
731 } 763 }
732 set_irq_flags(irq, IRQF_VALID);
733 764
734#ifdef CONFIG_USB_OTG_UTILS 765#ifdef CONFIG_USB_OTG_UTILS
735 if (pdata->operating_mode == TEGRA_USB_OTG) { 766 if (pdata->operating_mode == TEGRA_USB_OTG) {
@@ -745,6 +776,14 @@ static int tegra_ehci_probe(struct platform_device *pdev)
745 goto fail; 776 goto fail;
746 } 777 }
747 778
779 pm_runtime_set_active(&pdev->dev);
780 pm_runtime_get_noresume(&pdev->dev);
781
782 /* Don't skip the pm_runtime_forbid call if wakeup isn't working */
783 /* if (!pdata->power_down_on_bus_suspend) */
784 pm_runtime_forbid(&pdev->dev);
785 pm_runtime_enable(&pdev->dev);
786 pm_runtime_put_sync(&pdev->dev);
748 return err; 787 return err;
749 788
750fail: 789fail:
@@ -771,33 +810,6 @@ fail_hcd:
771 return err; 810 return err;
772} 811}
773 812
774#ifdef CONFIG_PM
775static int tegra_ehci_resume(struct platform_device *pdev)
776{
777 struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);
778 struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci);
779
780 if (tegra->bus_suspended)
781 return 0;
782
783 return tegra_usb_resume(hcd);
784}
785
786static int tegra_ehci_suspend(struct platform_device *pdev, pm_message_t state)
787{
788 struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);
789 struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci);
790
791 if (tegra->bus_suspended)
792 return 0;
793
794 if (time_before(jiffies, tegra->ehci->next_statechange))
795 msleep(10);
796
797 return tegra_usb_suspend(hcd);
798}
799#endif
800
801static int tegra_ehci_remove(struct platform_device *pdev) 813static int tegra_ehci_remove(struct platform_device *pdev)
802{ 814{
803 struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev); 815 struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);
@@ -806,6 +818,10 @@ static int tegra_ehci_remove(struct platform_device *pdev)
806 if (tegra == NULL || hcd == NULL) 818 if (tegra == NULL || hcd == NULL)
807 return -EINVAL; 819 return -EINVAL;
808 820
821 pm_runtime_get_sync(&pdev->dev);
822 pm_runtime_disable(&pdev->dev);
823 pm_runtime_put_noidle(&pdev->dev);
824
809#ifdef CONFIG_USB_OTG_UTILS 825#ifdef CONFIG_USB_OTG_UTILS
810 if (tegra->transceiver) { 826 if (tegra->transceiver) {
811 otg_set_host(tegra->transceiver->otg, NULL); 827 otg_set_host(tegra->transceiver->otg, NULL);
@@ -846,13 +862,12 @@ static struct of_device_id tegra_ehci_of_match[] __devinitdata = {
846static struct platform_driver tegra_ehci_driver = { 862static struct platform_driver tegra_ehci_driver = {
847 .probe = tegra_ehci_probe, 863 .probe = tegra_ehci_probe,
848 .remove = tegra_ehci_remove, 864 .remove = tegra_ehci_remove,
849#ifdef CONFIG_PM
850 .suspend = tegra_ehci_suspend,
851 .resume = tegra_ehci_resume,
852#endif
853 .shutdown = tegra_ehci_hcd_shutdown, 865 .shutdown = tegra_ehci_hcd_shutdown,
854 .driver = { 866 .driver = {
855 .name = "tegra-ehci", 867 .name = "tegra-ehci",
856 .of_match_table = tegra_ehci_of_match, 868 .of_match_table = tegra_ehci_of_match,
869#ifdef CONFIG_PM
870 .pm = &tegra_ehci_pm_ops,
871#endif
857 } 872 }
858}; 873};
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-28 07:38:49 -0500