Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/drivers/usb/dwc3/dwc3-pci.c

  1 /**
  2  * dwc3-pci.c - PCI Specific glue layer
  3  *
  4  * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com
  5  *
  6  * Authors: Felipe Balbi <balbi@ti.com>,
  7  *          Sebastian Andrzej Siewior <bigeasy@linutronix.de>
  8  *
  9  * This program is free software: you can redistribute it and/or modify
 10  * it under the terms of the GNU General Public License version 2  of
 11  * the License as published by the Free Software Foundation.
 12  *
 13  * This program is distributed in the hope that it will be useful,
 14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16  * GNU General Public License for more details.
 17  */
 18 
 19 #include <linux/kernel.h>
 20 #include <linux/module.h>
 21 #include <linux/slab.h>
 22 #include <linux/pci.h>
 23 #include <linux/pm_runtime.h>
 24 #include <linux/platform_device.h>
 25 #include <linux/gpio/consumer.h>
 26 #include <linux/acpi.h>
 27 #include <linux/delay.h>
 28 
 29 #define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3         0xabcd
 30 #define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3_AXI     0xabce
 31 #define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB31        0xabcf
 32 #define PCI_DEVICE_ID_INTEL_BYT                 0x0f37
 33 #define PCI_DEVICE_ID_INTEL_MRFLD               0x119e
 34 #define PCI_DEVICE_ID_INTEL_BSW                 0x22b7
 35 #define PCI_DEVICE_ID_INTEL_SPTLP               0x9d30
 36 #define PCI_DEVICE_ID_INTEL_SPTH                0xa130
 37 #define PCI_DEVICE_ID_INTEL_BXT                 0x0aaa
 38 #define PCI_DEVICE_ID_INTEL_BXT_M               0x1aaa
 39 #define PCI_DEVICE_ID_INTEL_APL                 0x5aaa
 40 #define PCI_DEVICE_ID_INTEL_KBP                 0xa2b0
 41 
 42 static const struct acpi_gpio_params reset_gpios = { 0, 0, false };
 43 static const struct acpi_gpio_params cs_gpios = { 1, 0, false };
 44 
 45 static const struct acpi_gpio_mapping acpi_dwc3_byt_gpios[] = {
 46         { "reset-gpios", &reset_gpios, 1 },
 47         { "cs-gpios", &cs_gpios, 1 },
 48         { },
 49 };
 50 
 51 static int dwc3_pci_quirks(struct pci_dev *pdev, struct platform_device *dwc3)
 52 {
 53         if (pdev->vendor == PCI_VENDOR_ID_AMD &&
 54             pdev->device == PCI_DEVICE_ID_AMD_NL_USB) {
 55                 struct property_entry properties[] = {
 56                         PROPERTY_ENTRY_BOOL("snps,has-lpm-erratum"),
 57                         PROPERTY_ENTRY_U8("snps,lpm-nyet-threshold", 0xf),
 58                         PROPERTY_ENTRY_BOOL("snps,u2exit_lfps_quirk"),
 59                         PROPERTY_ENTRY_BOOL("snps,u2ss_inp3_quirk"),
 60                         PROPERTY_ENTRY_BOOL("snps,req_p1p2p3_quirk"),
 61                         PROPERTY_ENTRY_BOOL("snps,del_p1p2p3_quirk"),
 62                         PROPERTY_ENTRY_BOOL("snps,del_phy_power_chg_quirk"),
 63                         PROPERTY_ENTRY_BOOL("snps,lfps_filter_quirk"),
 64                         PROPERTY_ENTRY_BOOL("snps,rx_detect_poll_quirk"),
 65                         PROPERTY_ENTRY_BOOL("snps,tx_de_emphasis_quirk"),
 66                         PROPERTY_ENTRY_U8("snps,tx_de_emphasis", 1),
 67                         /*
 68                          * FIXME these quirks should be removed when AMD NL
 69                          * tapes out
 70                          */
 71                         PROPERTY_ENTRY_BOOL("snps,disable_scramble_quirk"),
 72                         PROPERTY_ENTRY_BOOL("snps,dis_u3_susphy_quirk"),
 73                         PROPERTY_ENTRY_BOOL("snps,dis_u2_susphy_quirk"),
 74                         { },
 75                 };
 76 
 77                 return platform_device_add_properties(dwc3, properties);
 78         }
 79 
 80         if (pdev->vendor == PCI_VENDOR_ID_INTEL) {
 81                 int ret;
 82 
 83                 struct property_entry properties[] = {
 84                         PROPERTY_ENTRY_STRING("dr-mode", "peripheral"),
 85                         { }
 86                 };
 87 
 88                 ret = platform_device_add_properties(dwc3, properties);
 89                 if (ret < 0)
 90                         return ret;
 91 
 92                 if (pdev->device == PCI_DEVICE_ID_INTEL_BYT) {
 93                         struct gpio_desc *gpio;
 94 
 95                         acpi_dev_add_driver_gpios(ACPI_COMPANION(&pdev->dev),
 96                                         acpi_dwc3_byt_gpios);
 97 
 98                         /*
 99                          * These GPIOs will turn on the USB2 PHY. Note that we have to
100                          * put the gpio descriptors again here because the phy driver
101                          * might want to grab them, too.
102                          */
103                         gpio = gpiod_get_optional(&pdev->dev, "cs", GPIOD_OUT_LOW);
104                         if (IS_ERR(gpio))
105                                 return PTR_ERR(gpio);
106 
107                         gpiod_set_value_cansleep(gpio, 1);
108                         gpiod_put(gpio);
109 
110                         gpio = gpiod_get_optional(&pdev->dev, "reset", GPIOD_OUT_LOW);
111                         if (IS_ERR(gpio))
112                                 return PTR_ERR(gpio);
113 
114                         if (gpio) {
115                                 gpiod_set_value_cansleep(gpio, 1);
116                                 gpiod_put(gpio);
117                                 usleep_range(10000, 11000);
118                         }
119                 }
120         }
121 
122         if (pdev->vendor == PCI_VENDOR_ID_SYNOPSYS &&
123             (pdev->device == PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3 ||
124              pdev->device == PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3_AXI ||
125              pdev->device == PCI_DEVICE_ID_SYNOPSYS_HAPSUSB31)) {
126                 struct property_entry properties[] = {
127                         PROPERTY_ENTRY_BOOL("snps,usb3_lpm_capable"),
128                         PROPERTY_ENTRY_BOOL("snps,has-lpm-erratum"),
129                         PROPERTY_ENTRY_BOOL("snps,dis_enblslpm_quirk"),
130                         { },
131                 };
132 
133                 return platform_device_add_properties(dwc3, properties);
134         }
135 
136         return 0;
137 }
138 
139 static int dwc3_pci_probe(struct pci_dev *pci,
140                 const struct pci_device_id *id)
141 {
142         struct resource         res[2];
143         struct platform_device  *dwc3;
144         int                     ret;
145         struct device           *dev = &pci->dev;
146 
147         ret = pcim_enable_device(pci);
148         if (ret) {
149                 dev_err(dev, "failed to enable pci device\n");
150                 return -ENODEV;
151         }
152 
153         pci_set_master(pci);
154 
155         dwc3 = platform_device_alloc("dwc3", PLATFORM_DEVID_AUTO);
156         if (!dwc3) {
157                 dev_err(dev, "couldn't allocate dwc3 device\n");
158                 return -ENOMEM;
159         }
160 
161         memset(res, 0x00, sizeof(struct resource) * ARRAY_SIZE(res));
162 
163         res[0].start    = pci_resource_start(pci, 0);
164         res[0].end      = pci_resource_end(pci, 0);
165         res[0].name     = "dwc_usb3";
166         res[0].flags    = IORESOURCE_MEM;
167 
168         res[1].start    = pci->irq;
169         res[1].name     = "dwc_usb3";
170         res[1].flags    = IORESOURCE_IRQ;
171 
172         ret = platform_device_add_resources(dwc3, res, ARRAY_SIZE(res));
173         if (ret) {
174                 dev_err(dev, "couldn't add resources to dwc3 device\n");
175                 return ret;
176         }
177 
178         dwc3->dev.parent = dev;
179         ACPI_COMPANION_SET(&dwc3->dev, ACPI_COMPANION(dev));
180 
181         ret = dwc3_pci_quirks(pci, dwc3);
182         if (ret)
183                 goto err;
184 
185         ret = platform_device_add(dwc3);
186         if (ret) {
187                 dev_err(dev, "failed to register dwc3 device\n");
188                 goto err;
189         }
190 
191         device_init_wakeup(dev, true);
192         device_set_run_wake(dev, true);
193         pci_set_drvdata(pci, dwc3);
194         pm_runtime_put(dev);
195 
196         return 0;
197 err:
198         platform_device_put(dwc3);
199         return ret;
200 }
201 
202 static void dwc3_pci_remove(struct pci_dev *pci)
203 {
204         device_init_wakeup(&pci->dev, false);
205         pm_runtime_get(&pci->dev);
206         acpi_dev_remove_driver_gpios(ACPI_COMPANION(&pci->dev));
207         platform_device_unregister(pci_get_drvdata(pci));
208 }
209 
210 static const struct pci_device_id dwc3_pci_id_table[] = {
211         {
212                 PCI_DEVICE(PCI_VENDOR_ID_SYNOPSYS,
213                                 PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3),
214         },
215         {
216                 PCI_DEVICE(PCI_VENDOR_ID_SYNOPSYS,
217                                 PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3_AXI),
218         },
219         {
220                 PCI_DEVICE(PCI_VENDOR_ID_SYNOPSYS,
221                                 PCI_DEVICE_ID_SYNOPSYS_HAPSUSB31),
222         },
223         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BSW), },
224         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BYT), },
225         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_MRFLD), },
226         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SPTLP), },
227         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SPTH), },
228         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BXT), },
229         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BXT_M), },
230         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_APL), },
231         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_KBP), },
232         { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_NL_USB), },
233         {  }    /* Terminating Entry */
234 };
235 MODULE_DEVICE_TABLE(pci, dwc3_pci_id_table);
236 
237 #ifdef CONFIG_PM
238 static int dwc3_pci_runtime_suspend(struct device *dev)
239 {
240         if (device_run_wake(dev))
241                 return 0;
242 
243         return -EBUSY;
244 }
245 
246 static int dwc3_pci_runtime_resume(struct device *dev)
247 {
248         struct platform_device *dwc3 = dev_get_drvdata(dev);
249 
250         return pm_runtime_get(&dwc3->dev);
251 }
252 #endif /* CONFIG_PM */
253 
254 #ifdef CONFIG_PM_SLEEP
255 static int dwc3_pci_pm_dummy(struct device *dev)
256 {
257         /*
258          * There's nothing to do here. No, seriously. Everything is either taken
259          * care either by PCI subsystem or dwc3/core.c, so we have nothing
260          * missing here.
261          *
262          * So you'd think we didn't need this at all, but PCI subsystem will
263          * bail out if we don't have a valid callback :-s
264          */
265         return 0;
266 }
267 #endif /* CONFIG_PM_SLEEP */
268 
269 static struct dev_pm_ops dwc3_pci_dev_pm_ops = {
270         SET_SYSTEM_SLEEP_PM_OPS(dwc3_pci_pm_dummy, dwc3_pci_pm_dummy)
271         SET_RUNTIME_PM_OPS(dwc3_pci_runtime_suspend, dwc3_pci_runtime_resume,
272                 NULL)
273 };
274 
275 static struct pci_driver dwc3_pci_driver = {
276         .name           = "dwc3-pci",
277         .id_table       = dwc3_pci_id_table,
278         .probe          = dwc3_pci_probe,
279         .remove         = dwc3_pci_remove,
280         .driver         = {
281                 .pm     = &dwc3_pci_dev_pm_ops,
282         }
283 };
284 
285 MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
286 MODULE_LICENSE("GPL v2");
287 MODULE_DESCRIPTION("DesignWare USB3 PCI Glue Layer");
288 
289 module_pci_driver(dwc3_pci_driver);
290 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us