Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 1 | /** |
| 2 | * dwc3-pci.c - PCI Specific glue layer |
| 3 | * |
| 4 | * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 5 | * |
| 6 | * Authors: Felipe Balbi <balbi@ti.com>, |
| 7 | * Sebastian Andrzej Siewior <bigeasy@linutronix.de> |
| 8 | * |
Felipe Balbi | 5945f78 | 2013-06-30 14:15:11 +0300 | [diff] [blame] | 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. |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 12 | * |
Felipe Balbi | 5945f78 | 2013-06-30 14:15:11 +0300 | [diff] [blame] | 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. |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 17 | */ |
| 18 | |
| 19 | #include <linux/kernel.h> |
Stephen Rothwell | 46a5728 | 2011-08-23 15:08:54 +1000 | [diff] [blame] | 20 | #include <linux/module.h> |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 21 | #include <linux/slab.h> |
| 22 | #include <linux/pci.h> |
Felipe Balbi | e9af922 | 2016-05-17 10:15:02 +0300 | [diff] [blame] | 23 | #include <linux/pm_runtime.h> |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 24 | #include <linux/platform_device.h> |
Heikki Krogerus | a89d977 | 2015-05-13 15:26:50 +0300 | [diff] [blame] | 25 | #include <linux/gpio/consumer.h> |
| 26 | #include <linux/acpi.h> |
Heikki Krogerus | cf48305 | 2016-04-22 11:17:39 +0300 | [diff] [blame] | 27 | #include <linux/delay.h> |
Huang Rui | 8f317b4 | 2014-10-28 19:54:24 +0800 | [diff] [blame] | 28 | |
John Youn | 9a5a078 | 2015-09-25 23:47:53 -0700 | [diff] [blame] | 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 |
Heikki Krogerus | b4c580a | 2015-10-21 14:37:04 +0300 | [diff] [blame] | 37 | #define PCI_DEVICE_ID_INTEL_BXT 0x0aaa |
Heikki Krogerus | 1ffb4d5 | 2016-04-01 17:13:10 +0300 | [diff] [blame] | 38 | #define PCI_DEVICE_ID_INTEL_BXT_M 0x1aaa |
Heikki Krogerus | b4c580a | 2015-10-21 14:37:04 +0300 | [diff] [blame] | 39 | #define PCI_DEVICE_ID_INTEL_APL 0x5aaa |
Heikki Krogerus | 4491ed5 | 2016-04-01 17:13:11 +0300 | [diff] [blame] | 40 | #define PCI_DEVICE_ID_INTEL_KBP 0xa2b0 |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 41 | |
Heikki Krogerus | a89d977 | 2015-05-13 15:26:50 +0300 | [diff] [blame] | 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 | |
Heikki Krogerus | ce046d3 | 2016-04-22 11:17:38 +0300 | [diff] [blame] | 51 | static int dwc3_pci_quirks(struct pci_dev *pdev, struct platform_device *dwc3) |
Heikki Krogerus | 2cd9ddf | 2015-01-12 14:20:14 +0200 | [diff] [blame] | 52 | { |
| 53 | if (pdev->vendor == PCI_VENDOR_ID_AMD && |
| 54 | pdev->device == PCI_DEVICE_ID_AMD_NL_USB) { |
Heikki Krogerus | cf48305 | 2016-04-22 11:17:39 +0300 | [diff] [blame] | 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 | }; |
Heikki Krogerus | 2cd9ddf | 2015-01-12 14:20:14 +0200 | [diff] [blame] | 76 | |
Heikki Krogerus | cf48305 | 2016-04-22 11:17:39 +0300 | [diff] [blame] | 77 | return platform_device_add_properties(dwc3, properties); |
Heikki Krogerus | 2cd9ddf | 2015-01-12 14:20:14 +0200 | [diff] [blame] | 78 | } |
| 79 | |
Felipe Balbi | e6fe66f | 2016-06-07 12:49:52 +0300 | [diff] [blame] | 80 | if (pdev->vendor == PCI_VENDOR_ID_INTEL) { |
| 81 | int ret; |
Heikki Krogerus | a89d977 | 2015-05-13 15:26:50 +0300 | [diff] [blame] | 82 | |
Felipe Balbi | e6fe66f | 2016-06-07 12:49:52 +0300 | [diff] [blame] | 83 | struct property_entry properties[] = { |
| 84 | PROPERTY_ENTRY_STRING("dr-mode", "peripheral"), |
| 85 | { } |
| 86 | }; |
Heikki Krogerus | a89d977 | 2015-05-13 15:26:50 +0300 | [diff] [blame] | 87 | |
Felipe Balbi | e6fe66f | 2016-06-07 12:49:52 +0300 | [diff] [blame] | 88 | ret = platform_device_add_properties(dwc3, properties); |
| 89 | if (ret < 0) |
| 90 | return ret; |
Heikki Krogerus | a89d977 | 2015-05-13 15:26:50 +0300 | [diff] [blame] | 91 | |
Felipe Balbi | e6fe66f | 2016-06-07 12:49:52 +0300 | [diff] [blame] | 92 | if (pdev->device == PCI_DEVICE_ID_INTEL_BYT) { |
| 93 | struct gpio_desc *gpio; |
Uwe Kleine-König | 2df033c | 2015-07-06 11:09:48 +0200 | [diff] [blame] | 94 | |
Felipe Balbi | e6fe66f | 2016-06-07 12:49:52 +0300 | [diff] [blame] | 95 | acpi_dev_add_driver_gpios(ACPI_COMPANION(&pdev->dev), |
| 96 | acpi_dwc3_byt_gpios); |
Uwe Kleine-König | 2df033c | 2015-07-06 11:09:48 +0200 | [diff] [blame] | 97 | |
Felipe Balbi | e6fe66f | 2016-06-07 12:49:52 +0300 | [diff] [blame] | 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 | |
Heikki Krogerus | a89d977 | 2015-05-13 15:26:50 +0300 | [diff] [blame] | 107 | gpiod_set_value_cansleep(gpio, 1); |
| 108 | gpiod_put(gpio); |
Felipe Balbi | e6fe66f | 2016-06-07 12:49:52 +0300 | [diff] [blame] | 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 | } |
Heikki Krogerus | a89d977 | 2015-05-13 15:26:50 +0300 | [diff] [blame] | 119 | } |
| 120 | } |
| 121 | |
John Youn | bb7f3d6 | 2015-09-26 00:11:15 -0700 | [diff] [blame] | 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)) { |
Heikki Krogerus | cf48305 | 2016-04-22 11:17:39 +0300 | [diff] [blame] | 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 | }; |
John Youn | bb7f3d6 | 2015-09-26 00:11:15 -0700 | [diff] [blame] | 132 | |
Heikki Krogerus | cf48305 | 2016-04-22 11:17:39 +0300 | [diff] [blame] | 133 | return platform_device_add_properties(dwc3, properties); |
John Youn | bb7f3d6 | 2015-09-26 00:11:15 -0700 | [diff] [blame] | 134 | } |
| 135 | |
Heikki Krogerus | 2cd9ddf | 2015-01-12 14:20:14 +0200 | [diff] [blame] | 136 | return 0; |
| 137 | } |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 138 | |
Bill Pemberton | 41ac7b3 | 2012-11-19 13:21:48 -0500 | [diff] [blame] | 139 | static int dwc3_pci_probe(struct pci_dev *pci, |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 140 | const struct pci_device_id *id) |
| 141 | { |
| 142 | struct resource res[2]; |
| 143 | struct platform_device *dwc3; |
Andy Shevchenko | b09e99e | 2014-05-15 15:53:32 +0300 | [diff] [blame] | 144 | int ret; |
Chanho Park | 802ca85 | 2012-02-15 18:27:55 +0900 | [diff] [blame] | 145 | struct device *dev = &pci->dev; |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 146 | |
Andy Shevchenko | f1c7e71 | 2014-05-15 15:53:33 +0300 | [diff] [blame] | 147 | ret = pcim_enable_device(pci); |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 148 | if (ret) { |
Chanho Park | 802ca85 | 2012-02-15 18:27:55 +0900 | [diff] [blame] | 149 | dev_err(dev, "failed to enable pci device\n"); |
| 150 | return -ENODEV; |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 151 | } |
| 152 | |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 153 | pci_set_master(pci); |
| 154 | |
Sebastian Andrzej Siewior | 124dafd | 2012-10-29 18:09:53 +0100 | [diff] [blame] | 155 | dwc3 = platform_device_alloc("dwc3", PLATFORM_DEVID_AUTO); |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 156 | if (!dwc3) { |
Chanho Park | 802ca85 | 2012-02-15 18:27:55 +0900 | [diff] [blame] | 157 | dev_err(dev, "couldn't allocate dwc3 device\n"); |
Andy Shevchenko | f1c7e71 | 2014-05-15 15:53:33 +0300 | [diff] [blame] | 158 | return -ENOMEM; |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 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) { |
Chanho Park | 802ca85 | 2012-02-15 18:27:55 +0900 | [diff] [blame] | 174 | dev_err(dev, "couldn't add resources to dwc3 device\n"); |
Andy Shevchenko | f1c7e71 | 2014-05-15 15:53:33 +0300 | [diff] [blame] | 175 | return ret; |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 176 | } |
| 177 | |
Chanho Park | 802ca85 | 2012-02-15 18:27:55 +0900 | [diff] [blame] | 178 | dwc3->dev.parent = dev; |
Heikki Krogerus | 9caeb06 | 2015-09-21 11:14:36 +0300 | [diff] [blame] | 179 | ACPI_COMPANION_SET(&dwc3->dev, ACPI_COMPANION(dev)); |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 180 | |
Heikki Krogerus | ce046d3 | 2016-04-22 11:17:38 +0300 | [diff] [blame] | 181 | ret = dwc3_pci_quirks(pci, dwc3); |
Heikki Krogerus | 474799f | 2016-04-22 11:17:37 +0300 | [diff] [blame] | 182 | if (ret) |
| 183 | goto err; |
| 184 | |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 185 | ret = platform_device_add(dwc3); |
| 186 | if (ret) { |
Chanho Park | 802ca85 | 2012-02-15 18:27:55 +0900 | [diff] [blame] | 187 | dev_err(dev, "failed to register dwc3 device\n"); |
Heikki Krogerus | 2cd9ddf | 2015-01-12 14:20:14 +0200 | [diff] [blame] | 188 | goto err; |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 189 | } |
| 190 | |
Felipe Balbi | e9af922 | 2016-05-17 10:15:02 +0300 | [diff] [blame] | 191 | device_init_wakeup(dev, true); |
| 192 | device_set_run_wake(dev, true); |
Heikki Krogerus | ce046d3 | 2016-04-22 11:17:38 +0300 | [diff] [blame] | 193 | pci_set_drvdata(pci, dwc3); |
Felipe Balbi | e9af922 | 2016-05-17 10:15:02 +0300 | [diff] [blame] | 194 | pm_runtime_put(dev); |
| 195 | |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 196 | return 0; |
Heikki Krogerus | 2cd9ddf | 2015-01-12 14:20:14 +0200 | [diff] [blame] | 197 | err: |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 198 | platform_device_put(dwc3); |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 199 | return ret; |
| 200 | } |
| 201 | |
Bill Pemberton | fb4e98a | 2012-11-19 13:26:20 -0500 | [diff] [blame] | 202 | static void dwc3_pci_remove(struct pci_dev *pci) |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 203 | { |
Felipe Balbi | e9af922 | 2016-05-17 10:15:02 +0300 | [diff] [blame] | 204 | device_init_wakeup(&pci->dev, false); |
| 205 | pm_runtime_get(&pci->dev); |
Heikki Krogerus | a89d977 | 2015-05-13 15:26:50 +0300 | [diff] [blame] | 206 | acpi_dev_remove_driver_gpios(ACPI_COMPANION(&pci->dev)); |
Heikki Krogerus | 2cd9ddf | 2015-01-12 14:20:14 +0200 | [diff] [blame] | 207 | platform_device_unregister(pci_get_drvdata(pci)); |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 208 | } |
| 209 | |
Jingoo Han | 782df20 | 2013-11-28 14:15:46 +0900 | [diff] [blame] | 210 | static const struct pci_device_id dwc3_pci_id_table[] = { |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 211 | { |
| 212 | PCI_DEVICE(PCI_VENDOR_ID_SYNOPSYS, |
| 213 | PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3), |
| 214 | }, |
John Youn | 41adc59 | 2015-08-07 11:04:14 -0700 | [diff] [blame] | 215 | { |
| 216 | PCI_DEVICE(PCI_VENDOR_ID_SYNOPSYS, |
| 217 | PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3_AXI), |
| 218 | }, |
John Youn | e8095a2 | 2015-08-07 11:47:25 -0700 | [diff] [blame] | 219 | { |
| 220 | PCI_DEVICE(PCI_VENDOR_ID_SYNOPSYS, |
| 221 | PCI_DEVICE_ID_SYNOPSYS_HAPSUSB31), |
| 222 | }, |
Alan Cox | 7d64366 | 2014-09-24 10:40:25 +0300 | [diff] [blame] | 223 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BSW), }, |
Heikki Krogerus | b62cd96 | 2013-09-17 10:38:13 +0300 | [diff] [blame] | 224 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BYT), }, |
David Cohen | 85601f8 | 2013-09-26 13:01:44 -0700 | [diff] [blame] | 225 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_MRFLD), }, |
Heikki Krogerus | 84a2b61 | 2014-12-18 16:39:14 +0200 | [diff] [blame] | 226 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SPTLP), }, |
| 227 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SPTH), }, |
Heikki Krogerus | b4c580a | 2015-10-21 14:37:04 +0300 | [diff] [blame] | 228 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BXT), }, |
Heikki Krogerus | 1ffb4d5 | 2016-04-01 17:13:10 +0300 | [diff] [blame] | 229 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BXT_M), }, |
Heikki Krogerus | b4c580a | 2015-10-21 14:37:04 +0300 | [diff] [blame] | 230 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_APL), }, |
Heikki Krogerus | 4491ed5 | 2016-04-01 17:13:11 +0300 | [diff] [blame] | 231 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_KBP), }, |
Huang Rui | 9755449 | 2014-10-31 11:11:17 +0800 | [diff] [blame] | 232 | { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_NL_USB), }, |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 233 | { } /* Terminating Entry */ |
| 234 | }; |
| 235 | MODULE_DEVICE_TABLE(pci, dwc3_pci_id_table); |
| 236 | |
Felipe Balbi | e9af922 | 2016-05-17 10:15:02 +0300 | [diff] [blame] | 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 | |
Felipe Balbi | f6c274e | 2016-07-28 10:16:12 +0300 | [diff] [blame] | 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 | } |
Felipe Balbi | 696118c | 2016-09-07 13:39:37 +0300 | [diff] [blame] | 252 | #endif /* CONFIG_PM */ |
Felipe Balbi | f6c274e | 2016-07-28 10:16:12 +0300 | [diff] [blame] | 253 | |
Felipe Balbi | 696118c | 2016-09-07 13:39:37 +0300 | [diff] [blame] | 254 | #ifdef CONFIG_PM_SLEEP |
Felipe Balbi | e9af922 | 2016-05-17 10:15:02 +0300 | [diff] [blame] | 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 | } |
Felipe Balbi | 696118c | 2016-09-07 13:39:37 +0300 | [diff] [blame] | 267 | #endif /* CONFIG_PM_SLEEP */ |
Felipe Balbi | e9af922 | 2016-05-17 10:15:02 +0300 | [diff] [blame] | 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) |
Felipe Balbi | f6c274e | 2016-07-28 10:16:12 +0300 | [diff] [blame] | 271 | SET_RUNTIME_PM_OPS(dwc3_pci_runtime_suspend, dwc3_pci_runtime_resume, |
Felipe Balbi | e9af922 | 2016-05-17 10:15:02 +0300 | [diff] [blame] | 272 | NULL) |
| 273 | }; |
| 274 | |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 275 | static struct pci_driver dwc3_pci_driver = { |
Felipe Balbi | 0949e99 | 2011-10-12 10:44:56 +0300 | [diff] [blame] | 276 | .name = "dwc3-pci", |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 277 | .id_table = dwc3_pci_id_table, |
| 278 | .probe = dwc3_pci_probe, |
Bill Pemberton | 7690417 | 2012-11-19 13:21:08 -0500 | [diff] [blame] | 279 | .remove = dwc3_pci_remove, |
Felipe Balbi | e9af922 | 2016-05-17 10:15:02 +0300 | [diff] [blame] | 280 | .driver = { |
| 281 | .pm = &dwc3_pci_dev_pm_ops, |
| 282 | } |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 283 | }; |
| 284 | |
| 285 | MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>"); |
Felipe Balbi | 5945f78 | 2013-06-30 14:15:11 +0300 | [diff] [blame] | 286 | MODULE_LICENSE("GPL v2"); |
Felipe Balbi | 72246da | 2011-08-19 18:10:58 +0300 | [diff] [blame] | 287 | MODULE_DESCRIPTION("DesignWare USB3 PCI Glue Layer"); |
| 288 | |
Greg Kroah-Hartman | 9565633 | 2011-11-18 10:14:24 -0800 | [diff] [blame] | 289 | module_pci_driver(dwc3_pci_driver); |