sys/compat/linuxkpi/common/src/linux_pci.c

   1 /*-
   2  * Copyright (c) 2015 Mellanox Technologies, Ltd.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice unmodified, this list of conditions, and the following
  10  *    disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/systm.h>
  32 #include <sys/malloc.h>
  33 #include <sys/kernel.h>
  34 #include <sys/sysctl.h>
  35 #include <sys/lock.h>
  36 #include <sys/mutex.h>
  37 #include <sys/bus.h>
  38 #include <sys/fcntl.h>
  39 #include <sys/file.h>
  40 #include <sys/filio.h>
  41 #include <sys/rwlock.h>
  42
  43 #include <vm/vm.h>
  44 #include <vm/pmap.h>
  45
  46 #include <machine/stdarg.h>
  47 #include <machine/pmap.h>
  48
  49 #include <linux/kobject.h>
  50 #include <linux/device.h>
  51 #include <linux/slab.h>
  52 #include <linux/module.h>
  53 #include <linux/cdev.h>
  54 #include <linux/file.h>
  55 #include <linux/sysfs.h>
  56 #include <linux/mm.h>
  57 #include <linux/io.h>
  58 #include <linux/vmalloc.h>
  59 #include <linux/pci.h>
  60
  61 static device_probe_t linux_pci_probe;
  62 static device_attach_t linux_pci_attach;
  63 static device_detach_t linux_pci_detach;
  64 static device_suspend_t linux_pci_suspend;
  65 static device_resume_t linux_pci_resume;
  66 static device_shutdown_t linux_pci_shutdown;
  67
  68 static device_method_t pci_methods[] = {
  69         DEVMETHOD(device_probe, linux_pci_probe),
  70         DEVMETHOD(device_attach, linux_pci_attach),
  71         DEVMETHOD(device_detach, linux_pci_detach),
  72         DEVMETHOD(device_suspend, linux_pci_suspend),
  73         DEVMETHOD(device_resume, linux_pci_resume),
  74         DEVMETHOD(device_shutdown, linux_pci_shutdown),
  75         DEVMETHOD_END
  76 };
  77
  78 static struct pci_driver *
  79 linux_pci_find(device_t dev, const struct pci_device_id **idp)
  80 {
  81         const struct pci_device_id *id;
  82         struct pci_driver *pdrv;
  83         uint16_t vendor;
  84         uint16_t device;
  85
  86         vendor = pci_get_vendor(dev);
  87         device = pci_get_device(dev);
  88
  89         spin_lock(&pci_lock);
  90         list_for_each_entry(pdrv, &pci_drivers, links) {
  91                 for (id = pdrv->id_table; id->vendor != 0; id++) {
  92                         if (vendor == id->vendor && device == id->device) {
  93                                 *idp = id;
  94                                 spin_unlock(&pci_lock);
  95                                 return (pdrv);
  96                         }
  97                 }
  98         }
  99         spin_unlock(&pci_lock);
 100         return (NULL);
 101 }
 102
 103 static int
 104 linux_pci_probe(device_t dev)
 105 {
 106         const struct pci_device_id *id;
 107         struct pci_driver *pdrv;
 108
 109         if ((pdrv = linux_pci_find(dev, &id)) == NULL)
 110                 return (ENXIO);
 111         if (device_get_driver(dev) != &pdrv->driver)
 112                 return (ENXIO);
 113         device_set_desc(dev, pdrv->name);
 114         return (0);
 115 }
 116
 117 static int
 118 linux_pci_attach(device_t dev)
 119 {
 120         struct resource_list_entry *rle;
 121         struct pci_dev *pdev;
 122         struct pci_driver *pdrv;
 123         const struct pci_device_id *id;
 124         int error;
 125
 126         pdrv = linux_pci_find(dev, &id);
 127         pdev = device_get_softc(dev);
 128         pdev->dev.parent = &linux_root_device;
 129         pdev->dev.bsddev = dev;
 130         INIT_LIST_HEAD(&pdev->dev.irqents);
 131         pdev->device = id->device;
 132         pdev->vendor = id->vendor;
 133         pdev->dev.dma_mask = &pdev->dma_mask;
 134         pdev->pdrv = pdrv;
 135         kobject_init(&pdev->dev.kobj, &linux_dev_ktype);
 136         kobject_set_name(&pdev->dev.kobj, device_get_nameunit(dev));
 137         kobject_add(&pdev->dev.kobj, &linux_root_device.kobj,
 138             kobject_name(&pdev->dev.kobj));
 139         rle = _pci_get_rle(pdev, SYS_RES_IRQ, 0);
 140         if (rle)
 141                 pdev->dev.irq = rle->start;
 142         else
 143                 pdev->dev.irq = 0;
 144         pdev->irq = pdev->dev.irq;
 145         mtx_unlock(&Giant);
 146         spin_lock(&pci_lock);
 147         list_add(&pdev->links, &pci_devices);
 148         spin_unlock(&pci_lock);
 149         error = pdrv->probe(pdev, id);
 150         mtx_lock(&Giant);
 151         if (error) {
 152                 spin_lock(&pci_lock);
 153                 list_del(&pdev->links);
 154                 spin_unlock(&pci_lock);
 155                 put_device(&pdev->dev);
 156                 return (-error);
 157         }
 158         return (0);
 159 }
 160
 161 static int
 162 linux_pci_detach(device_t dev)
 163 {
 164         struct pci_dev *pdev;
 165
 166         pdev = device_get_softc(dev);
 167         mtx_unlock(&Giant);
 168         pdev->pdrv->remove(pdev);
 169         mtx_lock(&Giant);
 170         spin_lock(&pci_lock);
 171         list_del(&pdev->links);
 172         spin_unlock(&pci_lock);
 173         put_device(&pdev->dev);
 174
 175         return (0);
 176 }
 177
 178 static int
 179 linux_pci_suspend(device_t dev)
 180 {
 181         struct pm_message pm = { };
 182         struct pci_dev *pdev;
 183         int err;
 184
 185         pdev = device_get_softc(dev);
 186         if (pdev->pdrv->suspend != NULL)
 187                 err = -pdev->pdrv->suspend(pdev, pm);
 188         else
 189                 err = 0;
 190         return (err);
 191 }
 192
 193 static int
 194 linux_pci_resume(device_t dev)
 195 {
 196         struct pci_dev *pdev;
 197         int err;
 198
 199         pdev = device_get_softc(dev);
 200         if (pdev->pdrv->resume != NULL)
 201                 err = -pdev->pdrv->resume(pdev);
 202         else
 203                 err = 0;
 204         return (err);
 205 }
 206
 207 static int
 208 linux_pci_shutdown(device_t dev)
 209 {
 210         struct pci_dev *pdev;
 211
 212         pdev = device_get_softc(dev);
 213         if (pdev->pdrv->shutdown != NULL)
 214                 pdev->pdrv->shutdown(pdev);
 215         return (0);
 216 }
 217
 218 int
 219 pci_register_driver(struct pci_driver *pdrv)
 220 {
 221         devclass_t bus;
 222         int error = 0;
 223
 224         bus = devclass_find("pci");
 225
 226         spin_lock(&pci_lock);
 227         list_add(&pdrv->links, &pci_drivers);
 228         spin_unlock(&pci_lock);
 229         pdrv->driver.name = pdrv->name;
 230         pdrv->driver.methods = pci_methods;
 231         pdrv->driver.size = sizeof(struct pci_dev);
 232         mtx_lock(&Giant);
 233         if (bus != NULL) {
 234                 error = devclass_add_driver(bus, &pdrv->driver, BUS_PASS_DEFAULT,
 235                     &pdrv->bsdclass);
 236         }
 237         mtx_unlock(&Giant);
 238         return (-error);
 239 }
 240
 241 void
 242 pci_unregister_driver(struct pci_driver *pdrv)
 243 {
 244         devclass_t bus;
 245
 246         bus = devclass_find("pci");
 247
 248         list_del(&pdrv->links);
 249         mtx_lock(&Giant);
 250         if (bus != NULL)
 251                 devclass_delete_driver(bus, &pdrv->driver);
 252         mtx_unlock(&Giant);
 253 }
 254