sys/dev/pci/vga_pci.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2005 John Baldwin <jhb@FreeBSD.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  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 #if defined(__amd64__) || defined(__i386__)
  49 #include <vm/vm.h>
  50 #include <vm/pmap.h>
  51 #endif
  52
  53 #include <dev/pci/pcireg.h>
  54 #include <dev/pci/pcivar.h>
  55
  56 #include <compat/x86bios/x86bios.h> /* To re-POST the card. */
  57
  58 struct vga_resource {
  59         struct resource *vr_res;
  60         int     vr_refs;
  61 };
  62
  63 struct vga_pci_softc {
  64         device_t        vga_msi_child;  /* Child driver using MSI. */
  65         struct vga_resource vga_bars[PCIR_MAX_BAR_0 + 1];
  66         struct vga_resource vga_bios;
  67 };
  68
  69 SYSCTL_DECL(_hw_pci);
  70
  71 static struct vga_resource *lookup_res(struct vga_pci_softc *sc, int rid);
  72 static struct resource *vga_pci_alloc_resource(device_t dev, device_t child,
  73     int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count,
  74     u_int flags);
  75 static int      vga_pci_release_resource(device_t dev, device_t child, int type,
  76     int rid, struct resource *r);
  77
  78 int vga_pci_default_unit = -1;
  79 SYSCTL_INT(_hw_pci, OID_AUTO, default_vgapci_unit, CTLFLAG_RDTUN,
  80     &vga_pci_default_unit, -1, "Default VGA-compatible display");
  81
  82 int
  83 vga_pci_is_boot_display(device_t dev)
  84 {
  85         int unit;
  86         device_t pcib;
  87         uint16_t config;
  88
  89         /* Check that the given device is a video card */
  90         if ((pci_get_class(dev) != PCIC_DISPLAY &&
  91             (pci_get_class(dev) != PCIC_OLD ||
  92              pci_get_subclass(dev) != PCIS_OLD_VGA)))
  93                 return (0);
  94
  95         unit = device_get_unit(dev);
  96
  97         if (vga_pci_default_unit >= 0) {
  98                 /*
  99                  * The boot display device was determined by a previous
 100                  * call to this function, or the user forced it using
 101                  * the hw.pci.default_vgapci_unit tunable.
 102                  */
 103                 return (vga_pci_default_unit == unit);
 104         }
 105
 106         /*
 107          * The primary video card used as a boot display must have the
 108          * "I/O" and "Memory Address Space Decoding" bits set in its
 109          * Command register.
 110          *
 111          * Furthermore, if the card is attached to a bridge, instead of
 112          * the root PCI bus, the bridge must have the "VGA Enable" bit
 113          * set in its Control register.
 114          */
 115
 116         pcib = device_get_parent(device_get_parent(dev));
 117         if (device_get_devclass(device_get_parent(pcib)) ==
 118             devclass_find("pci")) {
 119                 /*
 120                  * The parent bridge is a PCI-to-PCI bridge: check the
 121                  * value of the "VGA Enable" bit.
 122                  */
 123                 config = pci_read_config(pcib, PCIR_BRIDGECTL_1, 2);
 124                 if ((config & PCIB_BCR_VGA_ENABLE) == 0)
 125                         return (0);
 126         }
 127
 128         config = pci_read_config(dev, PCIR_COMMAND, 2);
 129         if ((config & (PCIM_CMD_PORTEN | PCIM_CMD_MEMEN)) == 0)
 130                 return (0);
 131
 132         /*
 133          * Disable interrupts until a chipset driver is loaded for
 134          * this PCI device. Else unhandled display adapter interrupts
 135          * might freeze the CPU.
 136          */
 137         pci_write_config(dev, PCIR_COMMAND, config | PCIM_CMD_INTxDIS, 2);
 138
 139         /* This video card is the boot display: record its unit number. */
 140         vga_pci_default_unit = unit;
 141         device_set_flags(dev, 1);
 142
 143         return (1);
 144 }
 145
 146 void *
 147 vga_pci_map_bios(device_t dev, size_t *size)
 148 {
 149         int rid;
 150         struct resource *res;
 151
 152 #if defined(__amd64__) || defined(__i386__)
 153         if (vga_pci_is_boot_display(dev)) {
 154                 /*
 155                  * On x86, the System BIOS copy the default display
 156                  * device's Video BIOS at a fixed location in system
 157                  * memory (0xC0000, 128 kBytes long) at boot time.
 158                  *
 159                  * We use this copy for the default boot device, because
 160                  * the original ROM may not be valid after boot.
 161                  */
 162
 163                 *size = VGA_PCI_BIOS_SHADOW_SIZE;
 164                 return (pmap_mapbios(VGA_PCI_BIOS_SHADOW_ADDR, *size));
 165         }
 166 #endif
 167
 168         rid = PCIR_BIOS;
 169         res = vga_pci_alloc_resource(dev, NULL, SYS_RES_MEMORY, &rid, 0,
 170             ~0, 1, RF_ACTIVE);
 171         if (res == NULL) {
 172                 return (NULL);
 173         }
 174
 175         *size = rman_get_size(res);
 176         return (rman_get_virtual(res));
 177 }
 178
 179 void
 180 vga_pci_unmap_bios(device_t dev, void *bios)
 181 {
 182         struct vga_resource *vr;
 183
 184         if (bios == NULL) {
 185                 return;
 186         }
 187
 188 #if defined(__amd64__) || defined(__i386__)
 189         if (vga_pci_is_boot_display(dev)) {
 190                 /* We mapped the BIOS shadow copy located at 0xC0000. */
 191                 pmap_unmapdev((vm_offset_t)bios, VGA_PCI_BIOS_SHADOW_SIZE);
 192
 193                 return;
 194         }
 195 #endif
 196
 197         /*
 198          * Look up the PCIR_BIOS resource in our softc.  It should match
 199          * the address we returned previously.
 200          */
 201         vr = lookup_res(device_get_softc(dev), PCIR_BIOS);
 202         KASSERT(vr->vr_res != NULL, ("vga_pci_unmap_bios: bios not mapped"));
 203         KASSERT(rman_get_virtual(vr->vr_res) == bios,
 204             ("vga_pci_unmap_bios: mismatch"));
 205         vga_pci_release_resource(dev, NULL, SYS_RES_MEMORY, PCIR_BIOS,
 206             vr->vr_res);
 207 }
 208
 209 int
 210 vga_pci_repost(device_t dev)
 211 {
 212 #if defined(__amd64__) || defined(__i386__)
 213         x86regs_t regs;
 214
 215         if (!vga_pci_is_boot_display(dev))
 216                 return (EINVAL);
 217
 218         if (x86bios_get_orm(VGA_PCI_BIOS_SHADOW_ADDR) == NULL)
 219                 return (ENOTSUP);
 220
 221         x86bios_init_regs(&regs);
 222
 223         regs.R_AH = pci_get_bus(dev);
 224         regs.R_AL = (pci_get_slot(dev) << 3) | (pci_get_function(dev) & 0x07);
 225         regs.R_DL = 0x80;
 226
 227         device_printf(dev, "REPOSTing\n");
 228         x86bios_call(&regs, X86BIOS_PHYSTOSEG(VGA_PCI_BIOS_SHADOW_ADDR + 3),
 229             X86BIOS_PHYSTOOFF(VGA_PCI_BIOS_SHADOW_ADDR + 3));
 230
 231         x86bios_get_intr(0x10);
 232
 233         return (0);
 234 #else
 235         return (ENOTSUP);
 236 #endif
 237 }
 238
 239 static int
 240 vga_pci_probe(device_t dev)
 241 {
 242
 243         switch (pci_get_class(dev)) {
 244         case PCIC_DISPLAY:
 245                 break;
 246         case PCIC_OLD:
 247                 if (pci_get_subclass(dev) != PCIS_OLD_VGA)
 248                         return (ENXIO);
 249                 break;
 250         default:
 251                 return (ENXIO);
 252         }
 253
 254         /* Probe default display. */
 255         vga_pci_is_boot_display(dev);
 256
 257         device_set_desc(dev, "VGA-compatible display");
 258         return (BUS_PROBE_GENERIC);
 259 }
 260
 261 static int
 262 vga_pci_attach(device_t dev)
 263 {
 264
 265         bus_generic_probe(dev);
 266
 267         /* Always create a drm child for now to make it easier on drm. */
 268         device_add_child(dev, "drm", -1);
 269         device_add_child(dev, "drmn", -1);
 270         bus_generic_attach(dev);
 271
 272         if (vga_pci_is_boot_display(dev))
 273                 device_printf(dev, "Boot video device\n");
 274
 275         return (0);
 276 }
 277
 278 static int
 279 vga_pci_suspend(device_t dev)
 280 {
 281
 282         return (bus_generic_suspend(dev));
 283 }
 284
 285 static int
 286 vga_pci_resume(device_t dev)
 287 {
 288
 289         return (bus_generic_resume(dev));
 290 }
 291
 292 /* Bus interface. */
 293
 294 static int
 295 vga_pci_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
 296 {
 297
 298         return (BUS_READ_IVAR(device_get_parent(dev), dev, which, result));
 299 }
 300
 301 static int
 302 vga_pci_write_ivar(device_t dev, device_t child, int which, uintptr_t value)
 303 {
 304
 305         return (EINVAL);
 306 }
 307
 308 static int
 309 vga_pci_setup_intr(device_t dev, device_t child, struct resource *irq,
 310     int flags, driver_filter_t *filter, driver_intr_t *intr, void *arg,
 311     void **cookiep)
 312 {
 313         return (BUS_SETUP_INTR(device_get_parent(dev), dev, irq, flags,
 314             filter, intr, arg, cookiep));
 315 }
 316
 317 static int
 318 vga_pci_teardown_intr(device_t dev, device_t child, struct resource *irq,
 319     void *cookie)
 320 {
 321         return (BUS_TEARDOWN_INTR(device_get_parent(dev), dev, irq, cookie));
 322 }
 323
 324 static struct vga_resource *
 325 lookup_res(struct vga_pci_softc *sc, int rid)
 326 {
 327         int bar;
 328
 329         if (rid == PCIR_BIOS)
 330                 return (&sc->vga_bios);
 331         bar = PCI_RID2BAR(rid);
 332         if (bar >= 0 && bar <= PCIR_MAX_BAR_0)
 333                 return (&sc->vga_bars[bar]);
 334         return (NULL);
 335 }
 336
 337 static struct resource *
 338 vga_pci_alloc_resource(device_t dev, device_t child, int type, int *rid,
 339     rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
 340 {
 341         struct vga_resource *vr;
 342
 343         switch (type) {
 344         case SYS_RES_MEMORY:
 345         case SYS_RES_IOPORT:
 346                 /*
 347                  * For BARs, we cache the resource so that we only allocate it
 348                  * from the PCI bus once.
 349                  */
 350                 vr = lookup_res(device_get_softc(dev), *rid);
 351                 if (vr == NULL)
 352                         return (NULL);
 353                 if (vr->vr_res == NULL)
 354                         vr->vr_res = bus_alloc_resource(dev, type, rid, start,
 355                             end, count, flags);
 356                 if (vr->vr_res != NULL)
 357                         vr->vr_refs++;
 358                 return (vr->vr_res);
 359         }
 360         return (bus_alloc_resource(dev, type, rid, start, end, count, flags));
 361 }
 362
 363 static int
 364 vga_pci_release_resource(device_t dev, device_t child, int type, int rid,
 365     struct resource *r)
 366 {
 367         struct vga_resource *vr;
 368         int error;
 369
 370         switch (type) {
 371         case SYS_RES_MEMORY:
 372         case SYS_RES_IOPORT:
 373                 /*
 374                  * For BARs, we release the resource from the PCI bus
 375                  * when the last child reference goes away.
 376                  */
 377                 vr = lookup_res(device_get_softc(dev), rid);
 378                 if (vr == NULL)
 379                         return (EINVAL);
 380                 if (vr->vr_res == NULL)
 381                         return (EINVAL);
 382                 KASSERT(vr->vr_res == r, ("vga_pci resource mismatch"));
 383                 if (vr->vr_refs > 1) {
 384                         vr->vr_refs--;
 385                         return (0);
 386                 }
 387                 KASSERT(vr->vr_refs > 0,
 388                     ("vga_pci resource reference count underflow"));
 389                 error = bus_release_resource(dev, type, rid, r);
 390                 if (error == 0) {
 391                         vr->vr_res = NULL;
 392                         vr->vr_refs = 0;
 393                 }
 394                 return (error);
 395         }
 396
 397         return (bus_release_resource(dev, type, rid, r));
 398 }
 399
 400 /* PCI interface. */
 401
 402 static uint32_t
 403 vga_pci_read_config(device_t dev, device_t child, int reg, int width)
 404 {
 405
 406         return (pci_read_config(dev, reg, width));
 407 }
 408
 409 static void
 410 vga_pci_write_config(device_t dev, device_t child, int reg,
 411     uint32_t val, int width)
 412 {
 413
 414         pci_write_config(dev, reg, val, width);
 415 }
 416
 417 static int
 418 vga_pci_enable_busmaster(device_t dev, device_t child)
 419 {
 420
 421         return (pci_enable_busmaster(dev));
 422 }
 423
 424 static int
 425 vga_pci_disable_busmaster(device_t dev, device_t child)
 426 {
 427
 428         return (pci_disable_busmaster(dev));
 429 }
 430
 431 static int
 432 vga_pci_enable_io(device_t dev, device_t child, int space)
 433 {
 434
 435         device_printf(dev, "child %s requested pci_enable_io\n",
 436             device_get_nameunit(child));
 437         return (pci_enable_io(dev, space));
 438 }
 439
 440 static int
 441 vga_pci_disable_io(device_t dev, device_t child, int space)
 442 {
 443
 444         device_printf(dev, "child %s requested pci_disable_io\n",
 445             device_get_nameunit(child));
 446         return (pci_disable_io(dev, space));
 447 }
 448
 449 static int
 450 vga_pci_get_vpd_ident(device_t dev, device_t child, const char **identptr)
 451 {
 452
 453         return (pci_get_vpd_ident(dev, identptr));
 454 }
 455
 456 static int
 457 vga_pci_get_vpd_readonly(device_t dev, device_t child, const char *kw,
 458     const char **vptr)
 459 {
 460
 461         return (pci_get_vpd_readonly(dev, kw, vptr));
 462 }
 463
 464 static int
 465 vga_pci_set_powerstate(device_t dev, device_t child, int state)
 466 {
 467
 468         device_printf(dev, "child %s requested pci_set_powerstate\n",
 469             device_get_nameunit(child));
 470         return (pci_set_powerstate(dev, state));
 471 }
 472
 473 static int
 474 vga_pci_get_powerstate(device_t dev, device_t child)
 475 {
 476
 477         device_printf(dev, "child %s requested pci_get_powerstate\n",
 478             device_get_nameunit(child));
 479         return (pci_get_powerstate(dev));
 480 }
 481
 482 static int
 483 vga_pci_assign_interrupt(device_t dev, device_t child)
 484 {
 485
 486         device_printf(dev, "child %s requested pci_assign_interrupt\n",
 487             device_get_nameunit(child));
 488         return (PCI_ASSIGN_INTERRUPT(device_get_parent(dev), dev));
 489 }
 490
 491 static int
 492 vga_pci_find_cap(device_t dev, device_t child, int capability,
 493     int *capreg)
 494 {
 495
 496         return (pci_find_cap(dev, capability, capreg));
 497 }
 498
 499 static int
 500 vga_pci_find_extcap(device_t dev, device_t child, int capability,
 501     int *capreg)
 502 {
 503
 504         return (pci_find_extcap(dev, capability, capreg));
 505 }
 506
 507 static int
 508 vga_pci_find_htcap(device_t dev, device_t child, int capability,
 509     int *capreg)
 510 {
 511
 512         return (pci_find_htcap(dev, capability, capreg));
 513 }
 514
 515 static int
 516 vga_pci_alloc_msi(device_t dev, device_t child, int *count)
 517 {
 518         struct vga_pci_softc *sc;
 519         int error;
 520
 521         sc = device_get_softc(dev);
 522         if (sc->vga_msi_child != NULL)
 523                 return (EBUSY);
 524         error = pci_alloc_msi(dev, count);
 525         if (error == 0)
 526                 sc->vga_msi_child = child;
 527         return (error);
 528 }
 529
 530 static int
 531 vga_pci_alloc_msix(device_t dev, device_t child, int *count)
 532 {
 533         struct vga_pci_softc *sc;
 534         int error;
 535
 536         sc = device_get_softc(dev);
 537         if (sc->vga_msi_child != NULL)
 538                 return (EBUSY);
 539         error = pci_alloc_msix(dev, count);
 540         if (error == 0)
 541                 sc->vga_msi_child = child;
 542         return (error);
 543 }
 544
 545 static int
 546 vga_pci_remap_msix(device_t dev, device_t child, int count,
 547     const u_int *vectors)
 548 {
 549         struct vga_pci_softc *sc;
 550
 551         sc = device_get_softc(dev);
 552         if (sc->vga_msi_child != child)
 553                 return (ENXIO);
 554         return (pci_remap_msix(dev, count, vectors));
 555 }
 556
 557 static int
 558 vga_pci_release_msi(device_t dev, device_t child)
 559 {
 560         struct vga_pci_softc *sc;
 561         int error;
 562
 563         sc = device_get_softc(dev);
 564         if (sc->vga_msi_child != child)
 565                 return (ENXIO);
 566         error = pci_release_msi(dev);
 567         if (error == 0)
 568                 sc->vga_msi_child = NULL;
 569         return (error);
 570 }
 571
 572 static int
 573 vga_pci_msi_count(device_t dev, device_t child)
 574 {
 575
 576         return (pci_msi_count(dev));
 577 }
 578
 579 static int
 580 vga_pci_msix_count(device_t dev, device_t child)
 581 {
 582
 583         return (pci_msix_count(dev));
 584 }
 585
 586 static bus_dma_tag_t
 587 vga_pci_get_dma_tag(device_t bus, device_t child)
 588 {
 589
 590         return (bus_get_dma_tag(bus));
 591 }
 592
 593 static device_method_t vga_pci_methods[] = {
 594         /* Device interface */
 595         DEVMETHOD(device_probe,         vga_pci_probe),
 596         DEVMETHOD(device_attach,        vga_pci_attach),
 597         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
 598         DEVMETHOD(device_suspend,       vga_pci_suspend),
 599         DEVMETHOD(device_resume,        vga_pci_resume),
 600
 601         /* Bus interface */
 602         DEVMETHOD(bus_read_ivar,        vga_pci_read_ivar),
 603         DEVMETHOD(bus_write_ivar,       vga_pci_write_ivar),
 604         DEVMETHOD(bus_setup_intr,       vga_pci_setup_intr),
 605         DEVMETHOD(bus_teardown_intr,    vga_pci_teardown_intr),
 606         DEVMETHOD(bus_alloc_resource,   vga_pci_alloc_resource),
 607         DEVMETHOD(bus_release_resource, vga_pci_release_resource),
 608         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
 609         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
 610         DEVMETHOD(bus_get_dma_tag,      vga_pci_get_dma_tag),
 611
 612         /* PCI interface */
 613         DEVMETHOD(pci_read_config,      vga_pci_read_config),
 614         DEVMETHOD(pci_write_config,     vga_pci_write_config),
 615         DEVMETHOD(pci_enable_busmaster, vga_pci_enable_busmaster),
 616         DEVMETHOD(pci_disable_busmaster, vga_pci_disable_busmaster),
 617         DEVMETHOD(pci_enable_io,        vga_pci_enable_io),
 618         DEVMETHOD(pci_disable_io,       vga_pci_disable_io),
 619         DEVMETHOD(pci_get_vpd_ident,    vga_pci_get_vpd_ident),
 620         DEVMETHOD(pci_get_vpd_readonly, vga_pci_get_vpd_readonly),
 621         DEVMETHOD(pci_get_powerstate,   vga_pci_get_powerstate),
 622         DEVMETHOD(pci_set_powerstate,   vga_pci_set_powerstate),
 623         DEVMETHOD(pci_assign_interrupt, vga_pci_assign_interrupt),
 624         DEVMETHOD(pci_find_cap,         vga_pci_find_cap),
 625         DEVMETHOD(pci_find_extcap,      vga_pci_find_extcap),
 626         DEVMETHOD(pci_find_htcap,       vga_pci_find_htcap),
 627         DEVMETHOD(pci_alloc_msi,        vga_pci_alloc_msi),
 628         DEVMETHOD(pci_alloc_msix,       vga_pci_alloc_msix),
 629         DEVMETHOD(pci_remap_msix,       vga_pci_remap_msix),
 630         DEVMETHOD(pci_release_msi,      vga_pci_release_msi),
 631         DEVMETHOD(pci_msi_count,        vga_pci_msi_count),
 632         DEVMETHOD(pci_msix_count,       vga_pci_msix_count),
 633
 634         { 0, 0 }
 635 };
 636
 637 static driver_t vga_pci_driver = {
 638         "vgapci",
 639         vga_pci_methods,
 640         sizeof(struct vga_pci_softc),
 641 };
 642
 643 static devclass_t vga_devclass;
 644
 645 DRIVER_MODULE(vgapci, pci, vga_pci_driver, vga_devclass, 0, 0);
 646 MODULE_DEPEND(vgapci, x86bios, 1, 1, 1);