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