sys/bus/pci/pci_compat.c

   1 /*
   2  * Copyright (c) 1997, Stefan Esser <se@freebsd.org>
   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  * $FreeBSD: src/sys/pci/pci_compat.c,v 1.35.2.1 2001/10/14 21:14:14 luigi Exp $
  27  * $DragonFly: src/sys/bus/pci/pci_compat.c,v 1.14 2007/05/13 18:33:56 swildner Exp $
  28  *
  29  */
  30
  31 #include "opt_bus.h"
  32
  33 /* for compatibility to FreeBSD-2.2 and 3.x versions of PCI code */
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/malloc.h>
  38 #include <sys/module.h>
  39
  40 #include <vm/vm.h>
  41 #include <vm/pmap.h>
  42
  43 #include <sys/bus.h>
  44 #include <sys/rman.h>
  45 #include <machine/smp.h>
  46 #include <sys/interrupt.h>
  47
  48 #include <sys/pciio.h>
  49 #include "pcireg.h"
  50 #include "pcivar.h"
  51 #include <bus/pci/pci_cfgreg.h>
  52
  53 struct pci_compat_driver {
  54         driver_t driver;
  55         struct pci_device *dvp;
  56 };
  57
  58 /* ------------------------------------------------------------------------- */
  59
  60 u_long
  61 pci_conf_read(pcici_t cfg, u_long reg)
  62 {
  63         return (pci_read_config(cfg->dev, reg, 4));
  64 }
  65
  66 void
  67 pci_conf_write(pcici_t cfg, u_long reg, u_long data)
  68 {
  69         pci_write_config(cfg->dev, reg, data, 4);
  70 }
  71
  72 void
  73 pci_cfgwrite(pcicfgregs *cfg, int reg, int data, int bytes)
  74 {
  75         pci_cfgregwrite(cfg->bus, cfg->slot, cfg->func, reg, data, bytes);
  76 }
  77
  78 int
  79 pci_map_port(pcici_t cfg, u_long reg, pci_port_t* pa)
  80 {
  81         int rid;
  82         struct resource *res;
  83
  84         rid = reg;
  85         res = bus_alloc_resource(cfg->dev, SYS_RES_IOPORT, &rid,
  86                                  0, ~0, 1, RF_ACTIVE);
  87         if (res) {
  88                 *pa = rman_get_start(res);
  89                 return (1);
  90         }
  91         return (0);
  92 }
  93
  94 int
  95 pci_map_mem(pcici_t cfg, u_long reg, vm_offset_t* va, vm_offset_t* pa)
  96 {
  97         int rid;
  98         struct resource *res;
  99
 100         rid = reg;
 101         res = bus_alloc_resource(cfg->dev, SYS_RES_MEMORY, &rid,
 102                                  0, ~0, 1, RF_ACTIVE);
 103         if (res) {
 104                 *pa = rman_get_start(res);
 105                 *va = (vm_offset_t) rman_get_virtual(res);
 106                 return (1);
 107         }
 108         return (0);
 109 }
 110
 111 int
 112 pci_map_int(pcici_t cfg, pci_inthand_t *handler, void *arg)
 113 {
 114         return (pci_map_int_right(cfg, handler, arg, 0));
 115 }
 116
 117 int
 118 pci_map_int_right(pcici_t cfg, pci_inthand_t *handler, void *arg, u_int intflags)
 119 {
 120         int error;
 121
 122         if (cfg->intpin != 0) {
 123                 int irq = cfg->intline;
 124                 int rid = 0;
 125                 struct resource *res;
 126                 int flags = 0;
 127                 int resflags = RF_SHAREABLE|RF_ACTIVE;
 128                 void *ih;
 129
 130                 if (intflags & INTR_CLOCK)
 131                         flags |= INTR_CLOCK;
 132                 if (intflags & INTR_EXCL)
 133                         resflags &= ~RF_SHAREABLE;
 134
 135                 res = bus_alloc_resource(cfg->dev, SYS_RES_IRQ, &rid,
 136                                          irq, irq, 1, resflags);
 137                 if (!res) {
 138                         kprintf("pci_map_int: can't allocate interrupt\n");
 139                         return 0;
 140                 }
 141
 142                 /*
 143                  * This is ugly. Translate the mask into an interrupt type.
 144                  */
 145
 146                 error = BUS_SETUP_INTR(device_get_parent(cfg->dev), cfg->dev,
 147                                        res, flags, handler, arg, &ih, NULL);
 148                 if (error != 0)
 149                         return 0;
 150
 151 #ifdef NEW_BUS_PCI
 152                 /*
 153                  * XXX this apic stuff looks totally busted.  It should
 154                  * move to the nexus code which actually registers the
 155                  * interrupt.
 156                  */
 157 #endif
 158         }
 159         return (1);
 160 }
 161
 162 int
 163 pci_unmap_int(pcici_t cfg)
 164 {
 165         return (0); /* not supported, yet, since cfg doesn't know about idesc */
 166 }
 167
 168 pcici_t
 169 pci_get_parent_from_tag(pcici_t tag)
 170 {
 171         return (pcici_t)pci_devlist_get_parent(tag);
 172 }
 173
 174 int
 175 pci_get_bus_from_tag(pcici_t tag)
 176 {
 177         return tag->bus;
 178 }
 179
 180 /*
 181  * A simple driver to wrap the old pci driver mechanism for back-compat.
 182  */
 183
 184 static int
 185 pci_compat_probe(device_t dev)
 186 {
 187         struct pci_device *dvp;
 188         struct pci_devinfo *dinfo;
 189         pcicfgregs *cfg;
 190         const char *name;
 191         int error;
 192
 193         dinfo = device_get_ivars(dev);
 194         cfg = &dinfo->cfg;
 195         dvp = ((struct pci_compat_driver *)device_get_driver(dev))->dvp;
 196
 197         /*
 198          * Do the wrapped probe.
 199          */
 200         error = ENXIO;
 201         if (dvp && dvp->pd_probe) {
 202                 name = dvp->pd_probe(cfg, (cfg->device << 16) + cfg->vendor);
 203                 if (name) {
 204                         device_set_desc_copy(dev, name);
 205                         /* Allow newbus drivers to match "better" */
 206                         error = -200;
 207                 }
 208         }
 209
 210         return error;
 211 }
 212
 213 static int
 214 pci_compat_attach(device_t dev)
 215 {
 216         struct pci_device *dvp;
 217         struct pci_devinfo *dinfo;
 218         pcicfgregs *cfg;
 219         int unit;
 220
 221         dinfo = device_get_ivars(dev);
 222         cfg = &dinfo->cfg;
 223         dvp = ((struct pci_compat_driver *)device_get_driver(dev))->dvp;
 224
 225         unit = device_get_unit(dev);
 226         if (unit > *dvp->pd_count)
 227                 *dvp->pd_count = unit;
 228         if (dvp->pd_attach)
 229                 dvp->pd_attach(cfg, unit);
 230         device_printf(dev, "driver is using old-style compatibility shims\n");
 231         return 0;
 232 }
 233
 234 static device_method_t pci_compat_methods[] = {
 235         /* Device interface */
 236         DEVMETHOD(device_probe,         pci_compat_probe),
 237         DEVMETHOD(device_attach,        pci_compat_attach),
 238
 239         { 0, 0 }
 240 };
 241
 242 /*
 243  * Create a new style driver around each old pci driver.
 244  */
 245 int
 246 compat_pci_handler(module_t mod, int type, void *data)
 247 {
 248         struct pci_device *dvp = (struct pci_device *)data;
 249         struct pci_compat_driver *driver;
 250         devclass_t pci_devclass = devclass_find("pci");
 251
 252         switch (type) {
 253         case MOD_LOAD:
 254                 driver = kmalloc(sizeof(struct pci_compat_driver), M_DEVBUF, M_WAITOK | M_ZERO);
 255                 driver->driver.name = dvp->pd_name;
 256                 driver->driver.methods = pci_compat_methods;
 257                 driver->driver.size = sizeof(struct pci_devinfo *);
 258                 driver->dvp = dvp;
 259                 devclass_add_driver(pci_devclass, (driver_t *)driver);
 260                 break;
 261         case MOD_UNLOAD:
 262                 kprintf("%s: module unload not supported!\n", dvp->pd_name);
 263                 return EOPNOTSUPP;
 264         default:
 265                 break;
 266         }
 267         return 0;
 268 }