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