drivers/usb/dwc3/dwc3-pci.c

   1 /**
   2  * dwc3-pci.c - PCI Specific glue layer
   3  *
   4  * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com
   5  * All rights reserved.
   6  *
   7  * Authors: Felipe Balbi <balbi@ti.com>,
   8  *          Sebastian Andrzej Siewior <bigeasy@linutronix.de>
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions, and the following disclaimer,
  15  *    without modification.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. The names of the above-listed copyright holders may not be used
  20  *    to endorse or promote products derived from this software without
  21  *    specific prior written permission.
  22  *
  23  * ALTERNATIVELY, this software may be distributed under the terms of the
  24  * GNU General Public License ("GPL") version 2, as published by the Free
  25  * Software Foundation.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  28  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  29  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  30  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  31  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  32  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  33  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  34  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  35  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  36  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  37  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  38  */
  39
  40 #include <linux/kernel.h>
  41 #include <linux/module.h>
  42 #include <linux/slab.h>
  43 #include <linux/pci.h>
  44 #include <linux/platform_device.h>
  45
  46 /* FIXME define these in <linux/pci_ids.h> */
  47 #define PCI_VENDOR_ID_SYNOPSYS          0x16c3
  48 #define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3 0xabcd
  49
  50 #define DWC3_PCI_DEVS_POSSIBLE  32
  51
  52 struct dwc3_pci {
  53         struct device           *dev;
  54         struct platform_device  *dwc3;
  55 };
  56
  57 static DECLARE_BITMAP(dwc3_pci_devs, DWC3_PCI_DEVS_POSSIBLE);
  58
  59 static int dwc3_pci_get_device_id(struct dwc3_pci *glue)
  60 {
  61         int             id;
  62
  63 again:
  64         id = find_first_zero_bit(dwc3_pci_devs, DWC3_PCI_DEVS_POSSIBLE);
  65         if (id < DWC3_PCI_DEVS_POSSIBLE) {
  66                 int old;
  67
  68                 old = test_and_set_bit(id, dwc3_pci_devs);
  69                 if (old)
  70                         goto again;
  71         } else {
  72                 dev_err(glue->dev, "no space for new device\n");
  73                 id = -ENOMEM;
  74         }
  75
  76         return 0;
  77 }
  78
  79 static void dwc3_pci_put_device_id(struct dwc3_pci *glue, int id)
  80 {
  81         int                     ret;
  82
  83         if (id < 0)
  84                 return;
  85
  86         ret = test_bit(id, dwc3_pci_devs);
  87         WARN(!ret, "Device: %s\nID %d not in use\n",
  88                         dev_driver_string(glue->dev), id);
  89         clear_bit(id, dwc3_pci_devs);
  90 }
  91
  92 static int __devinit dwc3_pci_probe(struct pci_dev *pci,
  93                 const struct pci_device_id *id)
  94 {
  95         struct resource         res[2];
  96         struct platform_device  *dwc3;
  97         struct dwc3_pci         *glue;
  98         int                     ret = -ENOMEM;
  99         int                     devid;
 100
 101         glue = kzalloc(sizeof(*glue), GFP_KERNEL);
 102         if (!glue) {
 103                 dev_err(&pci->dev, "not enough memory\n");
 104                 goto err0;
 105         }
 106
 107         glue->dev       = &pci->dev;
 108
 109         ret = pci_enable_device(pci);
 110         if (ret) {
 111                 dev_err(&pci->dev, "failed to enable pci device\n");
 112                 goto err1;
 113         }
 114
 115         pci_set_power_state(pci, PCI_D0);
 116         pci_set_master(pci);
 117
 118         devid = dwc3_pci_get_device_id(glue);
 119         if (devid < 0)
 120                 goto err2;
 121
 122         dwc3 = platform_device_alloc("dwc3-pci", devid);
 123         if (!dwc3) {
 124                 dev_err(&pci->dev, "couldn't allocate dwc3 device\n");
 125                 goto err3;
 126         }
 127
 128         memset(res, 0x00, sizeof(struct resource) * ARRAY_SIZE(res));
 129
 130         res[0].start    = pci_resource_start(pci, 0);
 131         res[0].end      = pci_resource_end(pci, 0);
 132         res[0].name     = "dwc_usb3";
 133         res[0].flags    = IORESOURCE_MEM;
 134
 135         res[1].start    = pci->irq;
 136         res[1].name     = "dwc_usb3";
 137         res[1].flags    = IORESOURCE_IRQ;
 138
 139         ret = platform_device_add_resources(dwc3, res, ARRAY_SIZE(res));
 140         if (ret) {
 141                 dev_err(&pci->dev, "couldn't add resources to dwc3 device\n");
 142                 goto err4;
 143         }
 144
 145         pci_set_drvdata(pci, glue);
 146
 147         dma_set_coherent_mask(&dwc3->dev, pci->dev.coherent_dma_mask);
 148
 149         dwc3->dev.dma_mask = pci->dev.dma_mask;
 150         dwc3->dev.dma_parms = pci->dev.dma_parms;
 151         dwc3->dev.parent = &pci->dev;
 152         glue->dwc3      = dwc3;
 153
 154         ret = platform_device_add(dwc3);
 155         if (ret) {
 156                 dev_err(&pci->dev, "failed to register dwc3 device\n");
 157                 goto err4;
 158         }
 159
 160         return 0;
 161
 162 err4:
 163         pci_set_drvdata(pci, NULL);
 164         platform_device_put(dwc3);
 165
 166 err3:
 167         dwc3_pci_put_device_id(glue, devid);
 168
 169 err2:
 170         pci_disable_device(pci);
 171
 172 err1:
 173         kfree(pci);
 174
 175 err0:
 176         return ret;
 177 }
 178
 179 static void __devexit dwc3_pci_remove(struct pci_dev *pci)
 180 {
 181         struct dwc3_pci *glue = pci_get_drvdata(pci);
 182
 183         dwc3_pci_put_device_id(glue, glue->dwc3->id);
 184         platform_device_unregister(glue->dwc3);
 185         pci_set_drvdata(pci, NULL);
 186         pci_disable_device(pci);
 187         kfree(glue);
 188 }
 189
 190 static DEFINE_PCI_DEVICE_TABLE(dwc3_pci_id_table) = {
 191         {
 192                 PCI_DEVICE(PCI_VENDOR_ID_SYNOPSYS,
 193                                 PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3),
 194         },
 195         {  }    /* Terminating Entry */
 196 };
 197 MODULE_DEVICE_TABLE(pci, dwc3_pci_id_table);
 198
 199 static struct pci_driver dwc3_pci_driver = {
 200         .name           = "pci-dwc3",
 201         .id_table       = dwc3_pci_id_table,
 202         .probe          = dwc3_pci_probe,
 203         .remove         = __devexit_p(dwc3_pci_remove),
 204 };
 205
 206 MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
 207 MODULE_LICENSE("Dual BSD/GPL");
 208 MODULE_DESCRIPTION("DesignWare USB3 PCI Glue Layer");
 209
 210 static int __devinit dwc3_pci_init(void)
 211 {
 212         return pci_register_driver(&dwc3_pci_driver);
 213 }
 214 module_init(dwc3_pci_init);
 215
 216 static void __exit dwc3_pci_exit(void)
 217 {
 218         pci_unregister_driver(&dwc3_pci_driver);
 219 }
 220 module_exit(dwc3_pci_exit);