drivers/usb/host/ehci-pci.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*-
   3  * Copyright (c) 2007-2008, Juniper Networks, Inc.
   4  * All rights reserved.
   5  */
   6
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <errno.h>
  10 #include <pci.h>
  11 #include <usb.h>
  12 #include <asm/io.h>
  13
  14 #include "ehci.h"
  15
  16 /* Information about a USB port */
  17 struct ehci_pci_priv {
  18         struct ehci_ctrl ehci;
  19         struct phy phy;
  20 };
  21
  22 #if CONFIG_IS_ENABLED(DM_USB)
  23 static int ehci_pci_init(struct udevice *dev, struct ehci_hccr **ret_hccr,
  24                           struct ehci_hcor **ret_hcor)
  25 {
  26         struct ehci_pci_priv *priv = dev_get_priv(dev);
  27         struct ehci_hccr *hccr;
  28         struct ehci_hcor *hcor;
  29         int ret;
  30         u32 cmd;
  31
  32         ret = ehci_setup_phy(dev, &priv->phy, 0);
  33         if (ret)
  34                 return ret;
  35
  36         hccr = (struct ehci_hccr *)dm_pci_map_bar(dev,
  37                         PCI_BASE_ADDRESS_0, PCI_REGION_MEM);
  38         hcor = (struct ehci_hcor *)((uintptr_t) hccr +
  39                         HC_LENGTH(ehci_readl(&hccr->cr_capbase)));
  40
  41         debug("EHCI-PCI init hccr %#lx and hcor %#lx hc_length %d\n",
  42               (ulong)hccr, (ulong)hcor,
  43               (u32)HC_LENGTH(ehci_readl(&hccr->cr_capbase)));
  44
  45         *ret_hccr = hccr;
  46         *ret_hcor = hcor;
  47
  48         /* enable busmaster */
  49         dm_pci_read_config32(dev, PCI_COMMAND, &cmd);
  50         cmd |= PCI_COMMAND_MASTER;
  51         dm_pci_write_config32(dev, PCI_COMMAND, cmd);
  52
  53         return 0;
  54 }
  55
  56 #else
  57
  58 #ifdef CONFIG_PCI_EHCI_DEVICE
  59 static struct pci_device_id ehci_pci_ids[] = {
  60         /* Please add supported PCI EHCI controller ids here */
  61         {0x1033, 0x00E0},       /* NEC */
  62         {0x10B9, 0x5239},       /* ULI1575 PCI EHCI module ids */
  63         {0x12D8, 0x400F},       /* Pericom */
  64         {0, 0}
  65 };
  66 #endif
  67
  68 static void ehci_pci_legacy_init(pci_dev_t pdev, struct ehci_hccr **ret_hccr,
  69                                  struct ehci_hcor **ret_hcor)
  70 {
  71         struct ehci_hccr *hccr;
  72         struct ehci_hcor *hcor;
  73         u32 cmd;
  74
  75         hccr = (struct ehci_hccr *)pci_map_bar(pdev,
  76                         PCI_BASE_ADDRESS_0, PCI_REGION_MEM);
  77         hcor = (struct ehci_hcor *)((uintptr_t) hccr +
  78                         HC_LENGTH(ehci_readl(&hccr->cr_capbase)));
  79
  80         debug("EHCI-PCI init hccr 0x%x and hcor 0x%x hc_length %d\n",
  81               (u32)hccr, (u32)hcor,
  82               (u32)HC_LENGTH(ehci_readl(&hccr->cr_capbase)));
  83
  84         *ret_hccr = hccr;
  85         *ret_hcor = hcor;
  86
  87         /* enable busmaster */
  88         pci_read_config_dword(pdev, PCI_COMMAND, &cmd);
  89         cmd |= PCI_COMMAND_MASTER;
  90         pci_write_config_dword(pdev, PCI_COMMAND, cmd);
  91 }
  92
  93 /*
  94  * Create the appropriate control structures to manage
  95  * a new EHCI host controller.
  96  */
  97 int ehci_hcd_init(int index, enum usb_init_type init,
  98                 struct ehci_hccr **ret_hccr, struct ehci_hcor **ret_hcor)
  99 {
 100         pci_dev_t pdev;
 101
 102 #ifdef CONFIG_PCI_EHCI_DEVICE
 103         pdev = pci_find_devices(ehci_pci_ids, CONFIG_PCI_EHCI_DEVICE);
 104 #else
 105         pdev = pci_find_class(PCI_CLASS_SERIAL_USB_EHCI, index);
 106 #endif
 107         if (pdev < 0) {
 108                 printf("EHCI host controller not found\n");
 109                 return -1;
 110         }
 111         ehci_pci_legacy_init(pdev, ret_hccr, ret_hcor);
 112
 113         return 0;
 114 }
 115
 116 /*
 117  * Destroy the appropriate control structures corresponding
 118  * the the EHCI host controller.
 119  */
 120 int ehci_hcd_stop(int index)
 121 {
 122         return 0;
 123 }
 124 #endif /* !CONFIG_IS_ENABLED(DM_USB) */
 125
 126 #if CONFIG_IS_ENABLED(DM_USB)
 127 static int ehci_pci_probe(struct udevice *dev)
 128 {
 129         struct ehci_hccr *hccr;
 130         struct ehci_hcor *hcor;
 131         int ret;
 132
 133         ret = ehci_pci_init(dev, &hccr, &hcor);
 134         if (ret)
 135                 return ret;
 136
 137         return ehci_register(dev, hccr, hcor, NULL, 0, USB_INIT_HOST);
 138 }
 139
 140 static int ehci_pci_remove(struct udevice *dev)
 141 {
 142         struct ehci_pci_priv *priv = dev_get_priv(dev);
 143         int ret;
 144
 145         ret = ehci_deregister(dev);
 146         if (ret)
 147                 return ret;
 148
 149         return ehci_shutdown_phy(dev, &priv->phy);
 150 }
 151
 152 static const struct udevice_id ehci_pci_ids[] = {
 153         { .compatible = "ehci-pci" },
 154         { }
 155 };
 156
 157 U_BOOT_DRIVER(ehci_pci) = {
 158         .name   = "ehci_pci",
 159         .id     = UCLASS_USB,
 160         .probe = ehci_pci_probe,
 161         .remove = ehci_pci_remove,
 162         .of_match = ehci_pci_ids,
 163         .ops    = &ehci_usb_ops,
 164         .platdata_auto_alloc_size = sizeof(struct usb_platdata),
 165         .priv_auto_alloc_size = sizeof(struct ehci_pci_priv),
 166         .flags  = DM_FLAG_ALLOC_PRIV_DMA,
 167 };
 168
 169 static struct pci_device_id ehci_pci_supported[] = {
 170         { PCI_DEVICE_CLASS(PCI_CLASS_SERIAL_USB_EHCI, ~0) },
 171         {},
 172 };
 173
 174 U_BOOT_PCI_DEVICE(ehci_pci, ehci_pci_supported);
 175
 176 #endif /* CONFIG_IS_ENABLED(DM_USB) */