drivers/usb/cdns3/cdns3-pci-wrap.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Cadence USBSS PCI Glue driver
   4  *
   5  * Copyright (C) 2018-2019 Cadence.
   6  *
   7  * Author: Pawel Laszczak <pawell@cadence.com>
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/pci.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/dma-mapping.h>
  15 #include <linux/slab.h>
  16
  17 struct cdns3_wrap {
  18         struct platform_device *plat_dev;
  19         struct resource dev_res[6];
  20         int devfn;
  21 };
  22
  23 #define RES_IRQ_HOST_ID         0
  24 #define RES_IRQ_PERIPHERAL_ID   1
  25 #define RES_IRQ_OTG_ID          2
  26 #define RES_HOST_ID             3
  27 #define RES_DEV_ID              4
  28 #define RES_DRD_ID              5
  29
  30 #define PCI_BAR_HOST            0
  31 #define PCI_BAR_DEV             2
  32 #define PCI_BAR_OTG             0
  33
  34 #define PCI_DEV_FN_HOST_DEVICE  0
  35 #define PCI_DEV_FN_OTG          1
  36
  37 #define PCI_DRIVER_NAME         "cdns3-pci-usbss"
  38 #define PLAT_DRIVER_NAME        "cdns-usb3"
  39
  40 #define PCI_DEVICE_ID_CDNS_USB3 0x0100
  41
  42 static struct pci_dev *cdns3_get_second_fun(struct pci_dev *pdev)
  43 {
  44         struct pci_dev *func;
  45
  46         /*
  47          * Gets the second function.
  48          * It's little tricky, but this platform has two function.
  49          * The fist keeps resources for Host/Device while the second
  50          * keeps resources for DRD/OTG.
  51          */
  52         func = pci_get_device(pdev->vendor, pdev->device, NULL);
  53         if (unlikely(!func))
  54                 return NULL;
  55
  56         if (func->devfn == pdev->devfn) {
  57                 func = pci_get_device(pdev->vendor, pdev->device, func);
  58                 if (unlikely(!func))
  59                         return NULL;
  60         }
  61
  62         if (func->devfn != PCI_DEV_FN_HOST_DEVICE &&
  63             func->devfn != PCI_DEV_FN_OTG) {
  64                 return NULL;
  65         }
  66
  67         return func;
  68 }
  69
  70 static int cdns3_pci_probe(struct pci_dev *pdev,
  71                            const struct pci_device_id *id)
  72 {
  73         struct platform_device_info plat_info;
  74         struct cdns3_wrap *wrap;
  75         struct resource *res;
  76         struct pci_dev *func;
  77         int err;
  78
  79         /*
  80          * for GADGET/HOST PCI (devfn) function number is 0,
  81          * for OTG PCI (devfn) function number is 1
  82          */
  83         if (!id || (pdev->devfn != PCI_DEV_FN_HOST_DEVICE &&
  84                     pdev->devfn != PCI_DEV_FN_OTG))
  85                 return -EINVAL;
  86
  87         func = cdns3_get_second_fun(pdev);
  88         if (unlikely(!func))
  89                 return -EINVAL;
  90
  91         err = pcim_enable_device(pdev);
  92         if (err) {
  93                 dev_err(&pdev->dev, "Enabling PCI device has failed %d\n", err);
  94                 return err;
  95         }
  96
  97         pci_set_master(pdev);
  98
  99         if (pci_is_enabled(func)) {
 100                 wrap = pci_get_drvdata(func);
 101         } else {
 102                 wrap = kzalloc(sizeof(*wrap), GFP_KERNEL);
 103                 if (!wrap) {
 104                         pci_disable_device(pdev);
 105                         return -ENOMEM;
 106                 }
 107         }
 108
 109         res = wrap->dev_res;
 110
 111         if (pdev->devfn == PCI_DEV_FN_HOST_DEVICE) {
 112                 /* function 0: host(BAR_0) + device(BAR_1).*/
 113                 dev_dbg(&pdev->dev, "Initialize Device resources\n");
 114                 res[RES_DEV_ID].start = pci_resource_start(pdev, PCI_BAR_DEV);
 115                 res[RES_DEV_ID].end =   pci_resource_end(pdev, PCI_BAR_DEV);
 116                 res[RES_DEV_ID].name = "dev";
 117                 res[RES_DEV_ID].flags = IORESOURCE_MEM;
 118                 dev_dbg(&pdev->dev, "USBSS-DEV physical base addr: %pa\n",
 119                         &res[RES_DEV_ID].start);
 120
 121                 res[RES_HOST_ID].start = pci_resource_start(pdev, PCI_BAR_HOST);
 122                 res[RES_HOST_ID].end = pci_resource_end(pdev, PCI_BAR_HOST);
 123                 res[RES_HOST_ID].name = "xhci";
 124                 res[RES_HOST_ID].flags = IORESOURCE_MEM;
 125                 dev_dbg(&pdev->dev, "USBSS-XHCI physical base addr: %pa\n",
 126                         &res[RES_HOST_ID].start);
 127
 128                 /* Interrupt for XHCI */
 129                 wrap->dev_res[RES_IRQ_HOST_ID].start = pdev->irq;
 130                 wrap->dev_res[RES_IRQ_HOST_ID].name = "host";
 131                 wrap->dev_res[RES_IRQ_HOST_ID].flags = IORESOURCE_IRQ;
 132
 133                 /* Interrupt device. It's the same as for HOST. */
 134                 wrap->dev_res[RES_IRQ_PERIPHERAL_ID].start = pdev->irq;
 135                 wrap->dev_res[RES_IRQ_PERIPHERAL_ID].name = "peripheral";
 136                 wrap->dev_res[RES_IRQ_PERIPHERAL_ID].flags = IORESOURCE_IRQ;
 137         } else {
 138                 res[RES_DRD_ID].start = pci_resource_start(pdev, PCI_BAR_OTG);
 139                 res[RES_DRD_ID].end =   pci_resource_end(pdev, PCI_BAR_OTG);
 140                 res[RES_DRD_ID].name = "otg";
 141                 res[RES_DRD_ID].flags = IORESOURCE_MEM;
 142                 dev_dbg(&pdev->dev, "USBSS-DRD physical base addr: %pa\n",
 143                         &res[RES_DRD_ID].start);
 144
 145                 /* Interrupt for OTG/DRD. */
 146                 wrap->dev_res[RES_IRQ_OTG_ID].start = pdev->irq;
 147                 wrap->dev_res[RES_IRQ_OTG_ID].name = "otg";
 148                 wrap->dev_res[RES_IRQ_OTG_ID].flags = IORESOURCE_IRQ;
 149         }
 150
 151         if (pci_is_enabled(func)) {
 152                 /* set up platform device info */
 153                 memset(&plat_info, 0, sizeof(plat_info));
 154                 plat_info.parent = &pdev->dev;
 155                 plat_info.fwnode = pdev->dev.fwnode;
 156                 plat_info.name = PLAT_DRIVER_NAME;
 157                 plat_info.id = pdev->devfn;
 158                 wrap->devfn  = pdev->devfn;
 159                 plat_info.res = wrap->dev_res;
 160                 plat_info.num_res = ARRAY_SIZE(wrap->dev_res);
 161                 plat_info.dma_mask = pdev->dma_mask;
 162                 /* register platform device */
 163                 wrap->plat_dev = platform_device_register_full(&plat_info);
 164                 if (IS_ERR(wrap->plat_dev)) {
 165                         pci_disable_device(pdev);
 166                         err = PTR_ERR(wrap->plat_dev);
 167                         kfree(wrap);
 168                         return err;
 169                 }
 170         }
 171
 172         pci_set_drvdata(pdev, wrap);
 173         return err;
 174 }
 175
 176 static void cdns3_pci_remove(struct pci_dev *pdev)
 177 {
 178         struct cdns3_wrap *wrap;
 179         struct pci_dev *func;
 180
 181         func = cdns3_get_second_fun(pdev);
 182
 183         wrap = (struct cdns3_wrap *)pci_get_drvdata(pdev);
 184         if (wrap->devfn == pdev->devfn)
 185                 platform_device_unregister(wrap->plat_dev);
 186
 187         if (!pci_is_enabled(func))
 188                 kfree(wrap);
 189 }
 190
 191 static const struct pci_device_id cdns3_pci_ids[] = {
 192         { PCI_VDEVICE(CDNS, PCI_DEVICE_ID_CDNS_USB3) },
 193         { 0, }
 194 };
 195
 196 static struct pci_driver cdns3_pci_driver = {
 197         .name = PCI_DRIVER_NAME,
 198         .id_table = cdns3_pci_ids,
 199         .probe = cdns3_pci_probe,
 200         .remove = cdns3_pci_remove,
 201 };
 202
 203 module_pci_driver(cdns3_pci_driver);
 204 MODULE_DEVICE_TABLE(pci, cdns3_pci_ids);
 205
 206 MODULE_AUTHOR("Pawel Laszczak <pawell@cadence.com>");
 207 MODULE_LICENSE("GPL v2");
 208 MODULE_DESCRIPTION("Cadence USBSS PCI wrapper");