drivers/usb/cdns3/cdnsp-pci.c

   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
  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
  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
 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                 kfree(cdnsp);
 197                 goto pci_put;
 198         }
 199
 200         cdns_remove(cdnsp);
 201
 202 pci_put:
 203         pci_dev_put(func);
 204 }
 205
 206 static int __maybe_unused cdnsp_pci_suspend(struct device *dev)
 207 {
 208         struct cdns *cdns = dev_get_drvdata(dev);
 209
 210         return cdns_suspend(cdns);
 211 }
 212
 213 static int __maybe_unused cdnsp_pci_resume(struct device *dev)
 214 {
 215         struct cdns *cdns = dev_get_drvdata(dev);
 216         unsigned long flags;
 217         int ret;
 218
 219         spin_lock_irqsave(&cdns->lock, flags);
 220         ret = cdns_resume(cdns, 1);
 221         spin_unlock_irqrestore(&cdns->lock, flags);
 222
 223         return ret;
 224 }
 225
 226 static const struct dev_pm_ops cdnsp_pci_pm_ops = {
 227         SET_SYSTEM_SLEEP_PM_OPS(cdnsp_pci_suspend, cdnsp_pci_resume)
 228 };
 229
 230 static const struct pci_device_id cdnsp_pci_ids[] = {
 231         { PCI_VENDOR_ID_CDNS, CDNS_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,
 232           PCI_CLASS_SERIAL_USB_DEVICE, PCI_ANY_ID },
 233         { PCI_VENDOR_ID_CDNS, CDNS_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,
 234           CDNS_DRD_IF, PCI_ANY_ID },
 235         { 0, }
 236 };
 237
 238 static struct pci_driver cdnsp_pci_driver = {
 239         .name = "cdnsp-pci",
 240         .id_table = &cdnsp_pci_ids[0],
 241         .probe = cdnsp_pci_probe,
 242         .remove = cdnsp_pci_remove,
 243         .driver = {
 244                 .pm = &cdnsp_pci_pm_ops,
 245         }
 246 };
 247
 248 module_pci_driver(cdnsp_pci_driver);
 249 MODULE_DEVICE_TABLE(pci, cdnsp_pci_ids);
 250
 251 MODULE_ALIAS("pci:cdnsp");
 252 MODULE_AUTHOR("Pawel Laszczak <pawell@cadence.com>");
 253 MODULE_LICENSE("GPL v2");
 254 MODULE_DESCRIPTION("Cadence CDNSP PCI driver");