sys/bus/pci/vga_pci.c

   1 /*-
   2  * Copyright (c) 2005 John Baldwin <jhb@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, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the author nor the names of any co-contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $FreeBSD: src/sys/dev/pci/vga_pci.c,v 1.5.8.1 2009/04/15 03:14:26 kensmith Exp $
  30  */
  31
  32 /*
  33  * Simple driver for PCI VGA display devices.  Drivers such as agp(4) and
  34  * drm(4) should attach as children of this device.
  35  *
  36  * XXX: The vgapci name is a hack until we somehow merge the isa vga driver
  37  * in or rename it.
  38  */
  39
  40 #include <sys/param.h>
  41 #include <sys/bus.h>
  42 #include <sys/kernel.h>
  43 #include <sys/module.h>
  44 #include <sys/rman.h>
  45 #include <sys/sysctl.h>
  46 #include <sys/systm.h>
  47
  48 #include <machine/pmap.h>
  49
  50 #include <bus/pci/pcireg.h>
  51 #include <bus/pci/pcivar.h>
  52
  53 struct vga_resource {
  54         struct resource *vr_res;
  55         int     vr_refs;
  56 };
  57
  58 struct vga_pci_softc {
  59         device_t        vga_msi_child;  /* Child driver using MSI. */
  60         struct vga_resource vga_bars[PCIR_MAX_BAR_0 + 1];
  61         struct vga_resource vga_bios;
  62 };
  63
  64 SYSCTL_DECL(_hw_pci);
  65
  66 static struct vga_resource *lookup_res(struct vga_pci_softc *sc, int rid);
  67 static struct resource *vga_pci_alloc_resource(device_t dev, device_t child,
  68     int type, int *rid, u_long start, u_long end, u_long count, u_int flags,
  69     int cpuid);
  70 static int      vga_pci_release_resource(device_t dev, device_t child, int type,
  71     int rid, struct resource *r);
  72
  73 int vga_pci_default_unit = -1;
  74 TUNABLE_INT("hw.pci.default_vgapci_unit", &vga_pci_default_unit);
  75 SYSCTL_INT(_hw_pci, OID_AUTO, default_vgapci_unit, CTLFLAG_RD,
  76     &vga_pci_default_unit, -1, "Default VGA-compatible display");
  77
  78 int
  79 vga_pci_is_boot_display(device_t dev)
  80 {
  81         int unit;
  82         device_t pcib;
  83         uint16_t config;
  84
  85         /* Check that the given device is a video card */
  86         if ((pci_get_class(dev) != PCIC_DISPLAY &&
  87             (pci_get_class(dev) != PCIC_OLD ||
  88              pci_get_subclass(dev) != PCIS_OLD_VGA)))
  89                 return (0);
  90
  91         unit = device_get_unit(dev);
  92
  93         if (vga_pci_default_unit >= 0) {
  94                 /*
  95                  * The boot display device was determined by a previous
  96                  * call to this function, or the user forced it using
  97                  * the hw.pci.default_vgapci_unit tunable.
  98                  */
  99                 return (vga_pci_default_unit == unit);
 100         }
 101
 102         /*
 103          * The primary video card used as a boot display must have the
 104          * "I/O" and "Memory Address Space Decoding" bits set in its
 105          * Command register.
 106          *
 107          * Furthermore, if the card is attached to a bridge, instead of
 108          * the root PCI bus, the bridge must have the "VGA Enable" bit
 109          * set in its Control register.
 110          */
 111
 112         pcib = device_get_parent(device_get_parent(dev));
 113         if (device_get_devclass(device_get_parent(pcib)) ==
 114             devclass_find("pci")) {
 115                 /*
 116                  * The parent bridge is a PCI-to-PCI bridge: check the
 117                  * value of the "VGA Enable" bit.
 118                  */
 119                 config = pci_read_config(pcib, PCIR_BRIDGECTL_1, 2);
 120                 if ((config & PCIB_BCR_VGA_ENABLE) == 0)
 121                         return (0);
 122         }
 123
 124         config = pci_read_config(dev, PCIR_COMMAND, 2);
 125         if ((config & (PCIM_CMD_PORTEN | PCIM_CMD_MEMEN)) == 0)
 126                 return (0);
 127
 128         /* This video card is the boot display: record its unit number. */
 129         vga_pci_default_unit = unit;
 130         device_set_flags(dev, 1);
 131
 132         return (1);
 133 }
 134
 135 void *
 136 vga_pci_map_bios(device_t dev, size_t *size)
 137 {
 138         int rid;
 139         struct resource *res;
 140
 141         if (vga_pci_is_boot_display(dev)) {
 142                 /*
 143                  * On x86, the System BIOS copy the default display
 144                  * device's Video BIOS at a fixed location in system
 145                  * memory (0xC0000, 128 kBytes long) at boot time.
 146                  *
 147                  * We use this copy for the default boot device, because
 148                  * the original ROM may not be valid after boot.
 149                  */
 150
 151                 *size = VGA_PCI_BIOS_SHADOW_SIZE;
 152                 return (pmap_mapbios(VGA_PCI_BIOS_SHADOW_ADDR, *size));
 153         }
 154
 155         rid = PCIR_BIOS;
 156         res = vga_pci_alloc_resource(dev, NULL, SYS_RES_MEMORY, &rid, 0ul,
 157             ~0ul, 1, RF_ACTIVE, -1);
 158         if (res == NULL) {
 159                 return (NULL);
 160         }
 161
 162         *size = rman_get_size(res);
 163         return (rman_get_virtual(res));
 164 }
 165
 166 void
 167 vga_pci_unmap_bios(device_t dev, void *bios)
 168 {
 169         struct vga_resource *vr;
 170
 171         if (bios == NULL) {
 172                 return;
 173         }
 174
 175         if (vga_pci_is_boot_display(dev)) {
 176                 /* We mapped the BIOS shadow copy located at 0xC0000. */
 177                 pmap_unmapdev((vm_offset_t)bios, VGA_PCI_BIOS_SHADOW_SIZE);
 178
 179                 return;
 180         }
 181
 182         /*
 183          * Look up the PCIR_BIOS resource in our softc.  It should match
 184          * the address we returned previously.
 185          */
 186         vr = lookup_res(device_get_softc(dev), PCIR_BIOS);
 187         KASSERT(vr->vr_res != NULL, ("vga_pci_unmap_bios: bios not mapped"));
 188         KASSERT(rman_get_virtual(vr->vr_res) == bios,
 189             ("vga_pci_unmap_bios: mismatch"));
 190         vga_pci_release_resource(dev, NULL, SYS_RES_MEMORY, PCIR_BIOS,
 191             vr->vr_res);
 192 }
 193
 194 static int
 195 vga_pci_probe(device_t dev)
 196 {
 197
 198         switch (pci_get_class(dev)) {
 199         case PCIC_DISPLAY:
 200                 break;
 201         case PCIC_OLD:
 202                 if (pci_get_subclass(dev) != PCIS_OLD_VGA)
 203                         return (ENXIO);
 204                 break;
 205         default:
 206                 return (ENXIO);
 207         }
 208
 209         /* Probe default display. */
 210         vga_pci_is_boot_display(dev);
 211
 212         device_set_desc(dev, "VGA-compatible display");
 213         return (BUS_PROBE_GENERIC);
 214 }
 215
 216 static int
 217 vga_pci_attach(device_t dev)
 218 {
 219
 220         bus_generic_probe(dev);
 221
 222         /* Always create a drm child for now to make it easier on drm. */
 223         device_add_child(dev, "drm", -1);
 224         device_add_child(dev, "drmn", -1);
 225         bus_generic_attach(dev);
 226
 227         if (vga_pci_is_boot_display(dev))
 228                 device_printf(dev, "Boot video device\n");
 229
 230         return (0);
 231 }
 232
 233 static int
 234 vga_pci_suspend(device_t dev)
 235 {
 236
 237         return (bus_generic_suspend(dev));
 238 }
 239
 240 static int
 241 vga_pci_resume(device_t dev)
 242 {
 243
 244         return (bus_generic_resume(dev));
 245 }
 246
 247 /* Bus interface. */
 248
 249 static int
 250 vga_pci_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
 251 {
 252
 253         return (BUS_READ_IVAR(device_get_parent(dev), dev, which, result));
 254 }
 255
 256 static int
 257 vga_pci_write_ivar(device_t dev, device_t child, int which, uintptr_t value)
 258 {
 259
 260         return (EINVAL);
 261 }
 262
 263 static struct vga_resource *
 264 lookup_res(struct vga_pci_softc *sc, int rid)
 265 {
 266         int bar;
 267
 268         if (rid == PCIR_BIOS)
 269                 return (&sc->vga_bios);
 270         bar = PCI_RID2BAR(rid);
 271         if (bar >= 0 && bar <= PCIR_MAX_BAR_0)
 272                 return (&sc->vga_bars[bar]);
 273         return (NULL);
 274 }
 275
 276 static struct resource *
 277 vga_pci_alloc_resource(device_t dev, device_t child, int type, int *rid,
 278     u_long start, u_long end, u_long count, u_int flags, int cpuid __unused)
 279 {
 280         struct vga_resource *vr;
 281
 282         switch (type) {
 283         case SYS_RES_MEMORY:
 284         case SYS_RES_IOPORT:
 285                 /*
 286                  * For BARs, we cache the resource so that we only allocate it
 287                  * from the PCI bus once.
 288                  */
 289                 vr = lookup_res(device_get_softc(dev), *rid);
 290                 if (vr == NULL)
 291                         return (NULL);
 292                 if (vr->vr_res == NULL)
 293                         vr->vr_res = bus_alloc_resource(dev, type, rid, start,
 294                             end, count, flags);
 295                 if (vr->vr_res != NULL)
 296                         vr->vr_refs++;
 297                 return (vr->vr_res);
 298         }
 299         return (bus_alloc_resource(dev, type, rid, start, end, count, flags));
 300 }
 301
 302 static int
 303 vga_pci_release_resource(device_t dev, device_t child, int type, int rid,
 304     struct resource *r)
 305 {
 306         struct vga_resource *vr;
 307
 308         switch (type) {
 309         case SYS_RES_MEMORY:
 310         case SYS_RES_IOPORT:
 311                 /*
 312                  * Stop caching the resource when refs drops to 0
 313                  */
 314                 vr = lookup_res(device_get_softc(dev), rid);
 315                 if (vr && vr->vr_refs > 0) {
 316                         if (--vr->vr_refs > 0)
 317                                 return(0);
 318                         vr->vr_res = NULL;
 319                         /* fall through */
 320                 }
 321                 /* fall through */
 322                 break;
 323         }
 324         return (bus_release_resource(dev, type, rid, r));
 325 }
 326
 327 /* PCI interface. */
 328
 329 static uint32_t
 330 vga_pci_read_config(device_t dev, device_t child, int reg, int width)
 331 {
 332
 333         return (pci_read_config(dev, reg, width));
 334 }
 335
 336 static void
 337 vga_pci_write_config(device_t dev, device_t child, int reg,
 338     uint32_t val, int width)
 339 {
 340
 341         pci_write_config(dev, reg, val, width);
 342 }
 343
 344 static int
 345 vga_pci_enable_busmaster(device_t dev, device_t child)
 346 {
 347
 348         return (pci_enable_busmaster(dev));
 349 }
 350
 351 static int
 352 vga_pci_disable_busmaster(device_t dev, device_t child)
 353 {
 354
 355         return (pci_disable_busmaster(dev));
 356 }
 357
 358 static int
 359 vga_pci_enable_io(device_t dev, device_t child, int space)
 360 {
 361
 362         device_printf(dev, "child %s requested pci_enable_io\n",
 363             device_get_nameunit(child));
 364         return (pci_enable_io(dev, space));
 365 }
 366
 367 static int
 368 vga_pci_disable_io(device_t dev, device_t child, int space)
 369 {
 370
 371         device_printf(dev, "child %s requested pci_disable_io\n",
 372             device_get_nameunit(child));
 373         return (pci_disable_io(dev, space));
 374 }
 375
 376 static int
 377 vga_pci_set_powerstate(device_t dev, device_t child, int state)
 378 {
 379
 380         device_printf(dev, "child %s requested pci_set_powerstate\n",
 381             device_get_nameunit(child));
 382         return (pci_set_powerstate(dev, state));
 383 }
 384
 385 static int
 386 vga_pci_get_powerstate(device_t dev, device_t child)
 387 {
 388
 389         device_printf(dev, "child %s requested pci_get_powerstate\n",
 390             device_get_nameunit(child));
 391         return (pci_get_powerstate(dev));
 392 }
 393
 394 static int
 395 vga_pci_assign_interrupt(device_t dev, device_t child)
 396 {
 397
 398         device_printf(dev, "child %s requested pci_assign_interrupt\n",
 399             device_get_nameunit(child));
 400         return (PCI_ASSIGN_INTERRUPT(device_get_parent(dev), dev));
 401 }
 402
 403 static int
 404 vga_pci_find_extcap(device_t dev, device_t child, int capability,
 405     int *capreg)
 406 {
 407
 408         return (pci_find_extcap(dev, capability, capreg));
 409 }
 410
 411 static device_method_t vga_pci_methods[] = {
 412         /* Device interface */
 413         DEVMETHOD(device_probe,         vga_pci_probe),
 414         DEVMETHOD(device_attach,        vga_pci_attach),
 415         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
 416         DEVMETHOD(device_suspend,       vga_pci_suspend),
 417         DEVMETHOD(device_resume,        vga_pci_resume),
 418
 419         /* Bus interface */
 420         DEVMETHOD(bus_read_ivar,        vga_pci_read_ivar),
 421         DEVMETHOD(bus_write_ivar,       vga_pci_write_ivar),
 422         DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),
 423         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
 424
 425         DEVMETHOD(bus_alloc_resource,   vga_pci_alloc_resource),
 426         DEVMETHOD(bus_release_resource, vga_pci_release_resource),
 427         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
 428         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
 429
 430         /* PCI interface */
 431         DEVMETHOD(pci_read_config,      vga_pci_read_config),
 432         DEVMETHOD(pci_write_config,     vga_pci_write_config),
 433         DEVMETHOD(pci_enable_busmaster, vga_pci_enable_busmaster),
 434         DEVMETHOD(pci_disable_busmaster, vga_pci_disable_busmaster),
 435         DEVMETHOD(pci_enable_io,        vga_pci_enable_io),
 436         DEVMETHOD(pci_disable_io,       vga_pci_disable_io),
 437         DEVMETHOD(pci_get_powerstate,   vga_pci_get_powerstate),
 438         DEVMETHOD(pci_set_powerstate,   vga_pci_set_powerstate),
 439         DEVMETHOD(pci_assign_interrupt, vga_pci_assign_interrupt),
 440         DEVMETHOD(pci_find_extcap,      vga_pci_find_extcap),
 441
 442         DEVMETHOD_END
 443 };
 444
 445 static driver_t vga_pci_driver = {
 446         "vgapci",
 447         vga_pci_methods,
 448         sizeof(struct vga_pci_softc),
 449 };
 450
 451 static devclass_t vga_devclass;
 452
 453 DRIVER_MODULE(vgapci, pci, vga_pci_driver, vga_devclass, NULL, NULL);