1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Cadence PCI Glue driver.
4 *
5 * Copyright (C) 2019 Cadence.
6 *
7 * Author: Pawel Laszczak <pawell@cadence.com>
8 *
9 */
10
11 #include <linux/platform_device.h>
12 #include <linux/dma-mapping.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 #include <linux/pci.h>
17
18 #include "core.h"
19 #include "gadget-export.h"
20
21 #define PCI_BAR_HOST 0
22 #define PCI_BAR_OTG 0
23 #define PCI_BAR_DEV 2
24
25 #define PCI_DEV_FN_HOST_DEVICE 0
26 #define PCI_DEV_FN_OTG 1
27
28 #define PCI_DRIVER_NAME "cdns-pci-usbssp"
29 #define PLAT_DRIVER_NAME "cdns-usbssp"
30
31 #define CHICKEN_APB_TIMEOUT_VALUE 0x1C20
32
cdnsp_get_second_fun(struct pci_dev * pdev)33 static struct pci_dev *cdnsp_get_second_fun(struct pci_dev *pdev)
34 {
35 /*
36 * Gets the second function.
37 * Platform has two function. The fist keeps resources for
38 * Host/Device while the secon keeps resources for DRD/OTG.
39 */
40 if (pdev->device == PCI_DEVICE_ID_CDNS_USBSSP)
41 return pci_get_device(pdev->vendor, PCI_DEVICE_ID_CDNS_USBSS, NULL);
42 if (pdev->device == PCI_DEVICE_ID_CDNS_USBSS)
43 return pci_get_device(pdev->vendor, PCI_DEVICE_ID_CDNS_USBSSP, NULL);
44
45 return NULL;
46 }
47
cdnsp_pci_probe(struct pci_dev * pdev,const struct pci_device_id * id)48 static int cdnsp_pci_probe(struct pci_dev *pdev,
49 const struct pci_device_id *id)
50 {
51 struct device *dev = &pdev->dev;
52 struct pci_dev *func;
53 struct resource *res;
54 struct cdns *cdnsp;
55 int ret;
56
57 /*
58 * For GADGET/HOST PCI (devfn) function number is 0,
59 * for OTG PCI (devfn) function number is 1.
60 */
61 if (!id || (pdev->devfn != PCI_DEV_FN_HOST_DEVICE &&
62 pdev->devfn != PCI_DEV_FN_OTG))
63 return -EINVAL;
64
65 func = cdnsp_get_second_fun(pdev);
66 if (!func)
67 return -EINVAL;
68
69 if (func->class == PCI_CLASS_SERIAL_USB_XHCI ||
70 pdev->class == PCI_CLASS_SERIAL_USB_XHCI) {
71 ret = -EINVAL;
72 goto put_pci;
73 }
74
75 ret = pcim_enable_device(pdev);
76 if (ret) {
77 dev_err(&pdev->dev, "Enabling PCI device has failed %d\n", ret);
78 goto put_pci;
79 }
80
81 pci_set_master(pdev);
82 if (pci_is_enabled(func)) {
83 cdnsp = pci_get_drvdata(func);
84 } else {
85 cdnsp = kzalloc(sizeof(*cdnsp), GFP_KERNEL);
86 if (!cdnsp) {
87 ret = -ENOMEM;
88 goto disable_pci;
89 }
90 }
91
92 /* For GADGET device function number is 0. */
93 if (pdev->devfn == 0) {
94 resource_size_t rsrc_start, rsrc_len;
95
96 /* Function 0: host(BAR_0) + device(BAR_1).*/
97 dev_dbg(dev, "Initialize resources\n");
98 rsrc_start = pci_resource_start(pdev, PCI_BAR_DEV);
99 rsrc_len = pci_resource_len(pdev, PCI_BAR_DEV);
100 res = devm_request_mem_region(dev, rsrc_start, rsrc_len, "dev");
101 if (!res) {
102 dev_dbg(dev, "controller already in use\n");
103 ret = -EBUSY;
104 goto free_cdnsp;
105 }
106
107 cdnsp->dev_regs = devm_ioremap(dev, rsrc_start, rsrc_len);
108 if (!cdnsp->dev_regs) {
109 dev_dbg(dev, "error mapping memory\n");
110 ret = -EFAULT;
111 goto free_cdnsp;
112 }
113
114 cdnsp->dev_irq = pdev->irq;
115 dev_dbg(dev, "USBSS-DEV physical base addr: %pa\n",
116 &rsrc_start);
117
118 res = &cdnsp->xhci_res[0];
119 res->start = pci_resource_start(pdev, PCI_BAR_HOST);
120 res->end = pci_resource_end(pdev, PCI_BAR_HOST);
121 res->name = "xhci";
122 res->flags = IORESOURCE_MEM;
123 dev_dbg(dev, "USBSS-XHCI physical base addr: %pa\n",
124 &res->start);
125
126 /* Interrupt for XHCI, */
127 res = &cdnsp->xhci_res[1];
128 res->start = pdev->irq;
129 res->name = "host";
130 res->flags = IORESOURCE_IRQ;
131 } else {
132 res = &cdnsp->otg_res;
133 res->start = pci_resource_start(pdev, PCI_BAR_OTG);
134 res->end = pci_resource_end(pdev, PCI_BAR_OTG);
135 res->name = "otg";
136 res->flags = IORESOURCE_MEM;
137 dev_dbg(dev, "CDNSP-DRD physical base addr: %pa\n",
138 &res->start);
139
140 /* Interrupt for OTG/DRD. */
141 cdnsp->otg_irq = pdev->irq;
142 }
143
144 /*
145 * Cadence PCI based platform require some longer timeout for APB
146 * to fixes domain clock synchronization issue after resuming
147 * controller from L1 state.
148 */
149 cdnsp->override_apb_timeout = CHICKEN_APB_TIMEOUT_VALUE;
150 pci_set_drvdata(pdev, cdnsp);
151
152 if (pci_is_enabled(func)) {
153 cdnsp->dev = dev;
154 cdnsp->gadget_init = cdnsp_gadget_init;
155
156 ret = cdns_init(cdnsp);
157 if (ret)
158 goto free_cdnsp;
159 }
160
161 device_wakeup_enable(&pdev->dev);
162 if (pci_dev_run_wake(pdev))
163 pm_runtime_put_noidle(&pdev->dev);
164
165 return 0;
166
167 free_cdnsp:
168 if (!pci_is_enabled(func))
169 kfree(cdnsp);
170
171 disable_pci:
172 pci_disable_device(pdev);
173
174 put_pci:
175 pci_dev_put(func);
176
177 return ret;
178 }
179
cdnsp_pci_remove(struct pci_dev * pdev)180 static void cdnsp_pci_remove(struct pci_dev *pdev)
181 {
182 struct cdns *cdnsp;
183 struct pci_dev *func;
184
185 func = cdnsp_get_second_fun(pdev);
186 cdnsp = (struct cdns *)pci_get_drvdata(pdev);
187
188 if (pci_dev_run_wake(pdev))
189 pm_runtime_get_noresume(&pdev->dev);
190
191 if (pci_is_enabled(func)) {
192 cdns_remove(cdnsp);
193 } else {
194 kfree(cdnsp);
195 }
196
197 pci_dev_put(func);
198 }
199
cdnsp_pci_suspend(struct device * dev)200 static int __maybe_unused cdnsp_pci_suspend(struct device *dev)
201 {
202 struct cdns *cdns = dev_get_drvdata(dev);
203
204 return cdns_suspend(cdns);
205 }
206
cdnsp_pci_resume(struct device * dev)207 static int __maybe_unused cdnsp_pci_resume(struct device *dev)
208 {
209 struct cdns *cdns = dev_get_drvdata(dev);
210 unsigned long flags;
211 int ret;
212
213 spin_lock_irqsave(&cdns->lock, flags);
214 ret = cdns_resume(cdns);
215 spin_unlock_irqrestore(&cdns->lock, flags);
216 cdns_set_active(cdns, 1);
217
218 return ret;
219 }
220
221 static const struct dev_pm_ops cdnsp_pci_pm_ops = {
222 SET_SYSTEM_SLEEP_PM_OPS(cdnsp_pci_suspend, cdnsp_pci_resume)
223 };
224
225 static const struct pci_device_id cdnsp_pci_ids[] = {
226 { PCI_DEVICE(PCI_VENDOR_ID_CDNS, PCI_DEVICE_ID_CDNS_USBSSP),
227 .class = PCI_CLASS_SERIAL_USB_DEVICE },
228 { PCI_DEVICE(PCI_VENDOR_ID_CDNS, PCI_DEVICE_ID_CDNS_USBSSP),
229 .class = PCI_CLASS_SERIAL_USB_CDNS },
230 { PCI_DEVICE(PCI_VENDOR_ID_CDNS, PCI_DEVICE_ID_CDNS_USBSS),
231 .class = PCI_CLASS_SERIAL_USB_CDNS },
232 { 0, }
233 };
234
235 static struct pci_driver cdnsp_pci_driver = {
236 .name = "cdnsp-pci",
237 .id_table = cdnsp_pci_ids,
238 .probe = cdnsp_pci_probe,
239 .remove = cdnsp_pci_remove,
240 .driver = {
241 .pm = &cdnsp_pci_pm_ops,
242 }
243 };
244
245 module_pci_driver(cdnsp_pci_driver);
246 MODULE_DEVICE_TABLE(pci, cdnsp_pci_ids);
247
248 MODULE_ALIAS("pci:cdnsp");
249 MODULE_AUTHOR("Pawel Laszczak <pawell@cadence.com>");
250 MODULE_LICENSE("GPL v2");
251 MODULE_DESCRIPTION("Cadence CDNSP PCI driver");
252