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");