1 /* $NetBSD: genfb_pci.c,v 1.45 2022/10/02 02:37:27 rin Exp $ */ 2 3 /*- 4 * Copyright (c) 2007 Michael Lorenz 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 NETBSD FOUNDATION, INC. AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: genfb_pci.c,v 1.45 2022/10/02 02:37:27 rin Exp $"); 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/kernel.h> 35 #include <sys/device.h> 36 #include <sys/proc.h> 37 #include <sys/mutex.h> 38 #include <sys/ioctl.h> 39 #include <sys/kernel.h> 40 #include <sys/systm.h> 41 #include <sys/kauth.h> 42 43 #include <dev/pci/pcidevs.h> 44 #include <dev/pci/pcireg.h> 45 #include <dev/pci/pcivar.h> 46 #include <dev/pci/pciio.h> 47 48 #include <dev/wsfb/genfbvar.h> 49 #include <dev/pci/wsdisplay_pci.h> 50 51 #include <dev/pci/genfb_pcivar.h> 52 53 #include "opt_wsfb.h" 54 #include "opt_genfb.h" 55 56 #ifdef GENFB_PCI_DEBUG 57 # define DPRINTF printf 58 #else 59 # define DPRINTF while (0) printf 60 #endif 61 62 static int pci_genfb_match(device_t, cfdata_t, void *); 63 static void pci_genfb_attach(device_t, device_t, void *); 64 static int pci_genfb_ioctl(void *, void *, u_long, void *, int, 65 struct lwp *); 66 static paddr_t pci_genfb_mmap(void *, void *, off_t, int); 67 static int pci_genfb_borrow(void *, bus_addr_t, bus_space_handle_t *); 68 static int pci_genfb_drm_print(void *, const char *); 69 static bool pci_genfb_shutdown(device_t, int); 70 71 CFATTACH_DECL_NEW(genfb_pci, sizeof(struct pci_genfb_softc), 72 pci_genfb_match, pci_genfb_attach, NULL, NULL); 73 74 static int 75 pci_genfb_match(device_t parent, cfdata_t match, void *aux) 76 { 77 struct pci_attach_args *pa = aux; 78 int matchlvl = 1; 79 80 if (!genfb_is_enabled()) 81 return 0; /* explicitly disabled by MD code */ 82 83 if (genfb_is_console()) 84 matchlvl = 5; /* beat VGA */ 85 86 if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_APPLE && 87 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_APPLE_CONTROL) 88 return matchlvl; 89 90 if (PCI_CLASS(pa->pa_class) == PCI_CLASS_DISPLAY) 91 return matchlvl; 92 93 return 0; 94 } 95 96 static void 97 pci_genfb_attach(device_t parent, device_t self, void *aux) 98 { 99 struct pci_genfb_softc *sc = device_private(self); 100 struct pci_attach_args *pa = aux; 101 static const struct genfb_ops zero_ops; 102 struct genfb_ops ops = zero_ops; 103 pcireg_t rom; 104 int idx, bar, type; 105 bool skip; 106 107 pci_aprint_devinfo(pa, NULL); 108 109 sc->sc_gen.sc_dev = self; 110 sc->sc_memt = pa->pa_memt; 111 sc->sc_iot = pa->pa_iot; 112 sc->sc_pc = pa->pa_pc; 113 sc->sc_pcitag = pa->pa_tag; 114 sc->sc_want_wsfb = 0; 115 116 genfb_init(&sc->sc_gen); 117 118 /* firmware / MD code responsible for restoring the display */ 119 if (sc->sc_gen.sc_pmfcb == NULL) 120 pmf_device_register1(self, NULL, NULL, 121 pci_genfb_shutdown); 122 else 123 pmf_device_register1(self, 124 sc->sc_gen.sc_pmfcb->gpc_suspend, 125 sc->sc_gen.sc_pmfcb->gpc_resume, 126 pci_genfb_shutdown); 127 128 if ((sc->sc_gen.sc_width == 0) || (sc->sc_gen.sc_fbsize == 0)) { 129 aprint_debug_dev(self, "not configured by firmware\n"); 130 return; 131 } 132 133 /* 134 * if some MD code handed us a framebuffer VA we use that instead of 135 * mapping our own 136 */ 137 if (sc->sc_gen.sc_fbaddr == NULL) { 138 if (bus_space_map(sc->sc_memt, sc->sc_gen.sc_fboffset, 139 sc->sc_gen.sc_fbsize, 140 BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_PREFETCHABLE, 141 &sc->sc_memh) != 0) { 142 aprint_error_dev(self, 143 "unable to map the framebuffer\n"); 144 return; 145 } 146 sc->sc_gen.sc_fbaddr = bus_space_vaddr(sc->sc_memt, 147 sc->sc_memh); 148 } else 149 aprint_debug("%s: recycling existing fb mapping at %lx\n", 150 device_xname(sc->sc_gen.sc_dev), 151 (unsigned long)sc->sc_gen.sc_fbaddr); 152 153 /* mmap()able bus ranges */ 154 idx = 0; 155 skip = false; 156 for (bar = PCI_MAPREG_START; bar <= PCI_MAPREG_ROM; bar += 4) { 157 158 rom = pci_conf_read(sc->sc_pc, sc->sc_pcitag, bar); 159 if ((bar == PCI_MAPREG_ROM) && (rom != 0)) { 160 rom |= PCI_MAPREG_ROM_ENABLE; 161 pci_conf_write(sc->sc_pc, sc->sc_pcitag, bar, rom); 162 } 163 sc->sc_bars[(bar - PCI_MAPREG_START) >> 2] = rom; 164 if (skip || (bar >= PCI_MAPREG_END && bar < PCI_MAPREG_ROM) || 165 pci_mapreg_probe(sc->sc_pc, sc->sc_pcitag, bar, &type) 166 == 0) { 167 /* 168 * skip unimplemented, non-BAR registers, or 169 * higher words of 64-bit BARs. 170 */ 171 skip = false; 172 continue; 173 } 174 if (PCI_MAPREG_TYPE(type) == PCI_MAPREG_TYPE_MEM || 175 PCI_MAPREG_TYPE(type) == PCI_MAPREG_TYPE_ROM) { 176 pci_mapreg_info(sc->sc_pc, sc->sc_pcitag, bar, type, 177 &sc->sc_ranges[idx].offset, 178 &sc->sc_ranges[idx].size, 179 &sc->sc_ranges[idx].flags); 180 idx++; 181 } 182 if (PCI_MAPREG_TYPE(type) == PCI_MAPREG_TYPE_MEM && 183 PCI_MAPREG_MEM_TYPE(type) == PCI_MAPREG_MEM_TYPE_64BIT) 184 skip = true; 185 } 186 187 sc->sc_ranges_used = idx; 188 189 ops.genfb_ioctl = pci_genfb_ioctl; 190 ops.genfb_mmap = pci_genfb_mmap; 191 ops.genfb_borrow = pci_genfb_borrow; 192 193 if (genfb_attach(&sc->sc_gen, &ops) == 0) { 194 195 /* now try to attach a DRM */ 196 config_found(self, aux, pci_genfb_drm_print, 197 CFARGS(.iattr = "drm")); 198 } 199 } 200 201 static int 202 pci_genfb_drm_print(void *aux, const char *pnp) 203 { 204 if (pnp) 205 aprint_normal("drm at %s", pnp); 206 return (UNCONF); 207 } 208 209 210 static int 211 pci_genfb_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, 212 struct lwp *l) 213 { 214 struct pci_genfb_softc *sc = v; 215 size_t i; 216 int new_mode; 217 218 switch (cmd) { 219 case WSDISPLAYIO_GTYPE: 220 *(u_int *)data = WSDISPLAY_TYPE_PCIMISC; 221 return 0; 222 223 /* PCI config read/write passthrough. */ 224 case PCI_IOC_CFGREAD: 225 case PCI_IOC_CFGWRITE: 226 return pci_devioctl(sc->sc_pc, sc->sc_pcitag, 227 cmd, data, flag, l); 228 229 case WSDISPLAYIO_GET_BUSID: 230 return wsdisplayio_busid_pci(sc->sc_gen.sc_dev, sc->sc_pc, 231 sc->sc_pcitag, data); 232 233 case WSDISPLAYIO_SMODE: 234 new_mode = *(int *)data; 235 if (new_mode == WSDISPLAYIO_MODE_EMUL) { 236 for (i = 0; i < __arraycount(sc->sc_bars); i++) 237 pci_conf_write(sc->sc_pc, sc->sc_pcitag, 238 PCI_BAR(i), sc->sc_bars[i]); 239 } 240 return 0; 241 } 242 243 return EPASSTHROUGH; 244 } 245 246 static paddr_t 247 pci_genfb_mmap(void *v, void *vs, off_t offset, int prot) 248 { 249 struct pci_genfb_softc *sc = v; 250 struct range *r; 251 int i; 252 253 if (offset == 0) 254 sc->sc_want_wsfb = 1; 255 256 /* 257 * regular fb mapping at 0 258 * since some Sun firmware likes to put PCI resources low enough 259 * to collide with the wsfb mapping we only allow it after asking 260 * for offset 0 261 */ 262 DPRINTF("%s: %08x limit %08x\n", __func__, (uint32_t)offset, 263 (uint32_t)sc->sc_gen.sc_fbsize); 264 if ((offset >= 0) && (offset < sc->sc_gen.sc_fbsize) && 265 (sc->sc_want_wsfb == 1)) { 266 267 return bus_space_mmap(sc->sc_memt, sc->sc_gen.sc_fboffset, 268 offset, prot, 269 BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_PREFETCHABLE); 270 } 271 272 /* 273 * restrict all other mappings to processes with superuser privileges 274 * or the kernel itself 275 */ 276 if (kauth_authorize_machdep(kauth_cred_get(), KAUTH_MACHDEP_UNMANAGEDMEM, 277 NULL, NULL, NULL, NULL) != 0) { 278 aprint_normal_dev(sc->sc_gen.sc_dev, "mmap() rejected.\n"); 279 return -1; 280 } 281 282 #ifdef WSFB_FAKE_VGA_FB 283 if ((offset >= 0xa0000) && (offset < 0xbffff)) { 284 285 return bus_space_mmap(sc->sc_memt, sc->sc_gen.sc_fboffset, 286 offset - 0xa0000, prot, BUS_SPACE_MAP_LINEAR); 287 } 288 #endif 289 290 /* 291 * XXX this should be generalized, let's just 292 * #define PCI_IOAREA_PADDR 293 * #define PCI_IOAREA_OFFSET 294 * #define PCI_IOAREA_SIZE 295 * somewhere in a MD header and compile this code only if all are 296 * present 297 */ 298 /* 299 * no. 300 * PCI_IOAREA_PADDR would be completely, utterly wrong and completely 301 * useless for the following reasons: 302 * - it's a bus address, not a physical address 303 * - there's no guarantee it's the same for each host bridge 304 * - it's already taken care of by the IO tag 305 * PCI_IOAREA_OFFSET is the same as PCI_MAGIC_IO_RANGE 306 * PCI_IOAREA_SIZE is also useless: 307 * - many cards don't decode more than 16 bit IO anyway 308 * - even machines with more than 64kB IO space try to keep everything 309 * within 64kB for the reason above 310 * - IO ranges tend to be small so in most cases you can't cram enough 311 * cards into a single machine to exhaust 64kB IO space 312 * - machines which need this tend to prefer memory space anyway 313 * - the only use for this right now is to allow the Xserver to map 314 * VGA registers on macppc and a few other powerpc ports, shark uses 315 * a similar mechanism, and what they need is always within 64kB 316 */ 317 #ifdef PCI_MAGIC_IO_RANGE 318 /* allow to map our IO space */ 319 if ((offset >= PCI_MAGIC_IO_RANGE) && 320 (offset < PCI_MAGIC_IO_RANGE + 0x10000)) { 321 return bus_space_mmap(sc->sc_iot, offset - PCI_MAGIC_IO_RANGE, 322 0, prot, BUS_SPACE_MAP_LINEAR); 323 } 324 #endif 325 326 /* allow to mmap() our BARs */ 327 /* maybe the ROM BAR too? */ 328 for (i = 0; i < sc->sc_ranges_used; i++) { 329 330 r = &sc->sc_ranges[i]; 331 if ((offset >= r->offset) && (offset < (r->offset + r->size))) { 332 return bus_space_mmap(sc->sc_memt, offset, 0, prot, 333 r->flags); 334 } 335 } 336 337 return -1; 338 } 339 340 int 341 pci_genfb_borrow(void *opaque, bus_addr_t addr, bus_space_handle_t *hdlp) 342 { 343 struct pci_genfb_softc *sc = opaque; 344 345 if (sc == NULL) 346 return 0; 347 if (!sc->sc_gen.sc_fboffset) 348 return 0; 349 if (sc->sc_gen.sc_fboffset != addr) 350 return 0; 351 *hdlp = sc->sc_memh; 352 return 1; 353 } 354 355 static bool 356 pci_genfb_shutdown(device_t self, int flags) 357 { 358 genfb_enable_polling(self); 359 return true; 360 } 361
Indexes created Wed Sep 24 05:09:52 GMT 2025