| 1 | /* $NetBSD: genfb_pci.c,v 1.38 2016/07/07 06:55:41 msaitoh 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.38 2016/07/07 06:55:41 msaitoh 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 | |
| 106 | pci_aprint_devinfo(pa, NULL); |
| 107 | |
| 108 | sc->sc_gen.sc_dev = self; |
| 109 | sc->sc_memt = pa->pa_memt; |
| 110 | sc->sc_iot = pa->pa_iot; |
| 111 | sc->sc_pc = pa->pa_pc; |
| 112 | sc->sc_pcitag = pa->pa_tag; |
| 113 | sc->sc_want_wsfb = 0; |
| 114 | |
| 115 | genfb_init(&sc->sc_gen); |
| 116 | |
| 117 | /* firmware / MD code responsible for restoring the display */ |
| 118 | if (sc->sc_gen.sc_pmfcb == NULL) |
| 119 | pmf_device_register1(self, NULL, NULL, |
| 120 | pci_genfb_shutdown); |
| 121 | else |
| 122 | pmf_device_register1(self, |
| 123 | sc->sc_gen.sc_pmfcb->gpc_suspend, |
| 124 | sc->sc_gen.sc_pmfcb->gpc_resume, |
| 125 | pci_genfb_shutdown); |
| 126 | |
| 127 | if ((sc->sc_gen.sc_width == 0) || (sc->sc_gen.sc_fbsize == 0)) { |
| 128 | aprint_debug_dev(self, "not configured by firmware\n" ); |
| 129 | return; |
| 130 | } |
| 131 | |
| 132 | /* |
| 133 | * if some MD code handed us a framebuffer VA we use that instead of |
| 134 | * mapping our own |
| 135 | */ |
| 136 | if (sc->sc_gen.sc_fbaddr == NULL) { |
| 137 | if (bus_space_map(sc->sc_memt, sc->sc_gen.sc_fboffset, |
| 138 | sc->sc_gen.sc_fbsize, |
| 139 | BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_PREFETCHABLE, |
| 140 | &sc->sc_memh) != 0) { |
| 141 | aprint_error_dev(self, |
| 142 | "unable to map the framebuffer\n" ); |
| 143 | return; |
| 144 | } |
| 145 | sc->sc_gen.sc_fbaddr = bus_space_vaddr(sc->sc_memt, |
| 146 | sc->sc_memh); |
| 147 | } else |
| 148 | aprint_debug("%s: recycling existing fb mapping at %lx\n" , |
| 149 | device_xname(sc->sc_gen.sc_dev), |
| 150 | (unsigned long)sc->sc_gen.sc_fbaddr); |
| 151 | |
| 152 | /* mmap()able bus ranges */ |
| 153 | idx = 0; |
| 154 | bar = PCI_MAPREG_START; |
| 155 | while (bar <= PCI_MAPREG_ROM) { |
| 156 | |
| 157 | sc->sc_bars[(bar - PCI_MAPREG_START) >> 2] = rom = |
| 158 | pci_conf_read(sc->sc_pc, sc->sc_pcitag, bar); |
| 159 | |
| 160 | if ((bar >= PCI_MAPREG_END && bar < PCI_MAPREG_ROM) || |
| 161 | pci_mapreg_probe(sc->sc_pc, sc->sc_pcitag, bar, &type) |
| 162 | == 0) { |
| 163 | /* skip unimplemented and non-BAR registers */ |
| 164 | bar += 4; |
| 165 | continue; |
| 166 | } |
| 167 | if (PCI_MAPREG_TYPE(type) == PCI_MAPREG_TYPE_MEM || |
| 168 | PCI_MAPREG_TYPE(type) == PCI_MAPREG_TYPE_ROM) { |
| 169 | pci_mapreg_info(sc->sc_pc, sc->sc_pcitag, bar, type, |
| 170 | &sc->sc_ranges[idx].offset, |
| 171 | &sc->sc_ranges[idx].size, |
| 172 | &sc->sc_ranges[idx].flags); |
| 173 | idx++; |
| 174 | } |
| 175 | if ((bar == PCI_MAPREG_ROM) && (rom != 0)) { |
| 176 | pci_conf_write(sc->sc_pc, sc->sc_pcitag, bar, rom | |
| 177 | PCI_MAPREG_ROM_ENABLE); |
| 178 | } |
| 179 | if (PCI_MAPREG_TYPE(type) == PCI_MAPREG_TYPE_MEM && |
| 180 | PCI_MAPREG_MEM_TYPE(type) == PCI_MAPREG_MEM_TYPE_64BIT) |
| 181 | bar += 8; |
| 182 | else |
| 183 | bar += 4; |
| 184 | } |
| 185 | |
| 186 | sc->sc_ranges_used = idx; |
| 187 | |
| 188 | ops.genfb_ioctl = pci_genfb_ioctl; |
| 189 | ops.genfb_mmap = pci_genfb_mmap; |
| 190 | ops.genfb_borrow = pci_genfb_borrow; |
| 191 | |
| 192 | if (genfb_attach(&sc->sc_gen, &ops) == 0) { |
| 193 | |
| 194 | /* now try to attach a DRM */ |
| 195 | config_found_ia(self, "drm" , aux, pci_genfb_drm_print); |
| 196 | } |
| 197 | } |
| 198 | |
| 199 | static int |
| 200 | pci_genfb_drm_print(void *aux, const char *pnp) |
| 201 | { |
| 202 | if (pnp) |
| 203 | aprint_normal("drm at %s" , pnp); |
| 204 | return (UNCONF); |
| 205 | } |
| 206 | |
| 207 | |
| 208 | static int |
| 209 | pci_genfb_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, |
| 210 | struct lwp *l) |
| 211 | { |
| 212 | struct pci_genfb_softc *sc = v; |
| 213 | |
| 214 | switch (cmd) { |
| 215 | case WSDISPLAYIO_GTYPE: |
| 216 | *(u_int *)data = WSDISPLAY_TYPE_PCIMISC; |
| 217 | return 0; |
| 218 | |
| 219 | /* PCI config read/write passthrough. */ |
| 220 | case PCI_IOC_CFGREAD: |
| 221 | case PCI_IOC_CFGWRITE: |
| 222 | return pci_devioctl(sc->sc_pc, sc->sc_pcitag, |
| 223 | cmd, data, flag, l); |
| 224 | |
| 225 | case WSDISPLAYIO_GET_BUSID: |
| 226 | return wsdisplayio_busid_pci(sc->sc_gen.sc_dev, sc->sc_pc, |
| 227 | sc->sc_pcitag, data); |
| 228 | |
| 229 | case WSDISPLAYIO_SMODE: { |
| 230 | int new_mode = *(int*)data, i; |
| 231 | if (new_mode == WSDISPLAYIO_MODE_EMUL) { |
| 232 | for (i = 0; i < 9; i++) |
| 233 | pci_conf_write(sc->sc_pc, |
| 234 | sc->sc_pcitag, |
| 235 | 0x10 + (i << 2), |
| 236 | sc->sc_bars[i]); |
| 237 | } |
| 238 | } |
| 239 | return 0; |
| 240 | } |
| 241 | |
| 242 | return EPASSTHROUGH; |
| 243 | } |
| 244 | |
| 245 | static paddr_t |
| 246 | pci_genfb_mmap(void *v, void *vs, off_t offset, int prot) |
| 247 | { |
| 248 | struct pci_genfb_softc *sc = v; |
| 249 | struct range *r; |
| 250 | int i; |
| 251 | |
| 252 | if (offset == 0) |
| 253 | sc->sc_want_wsfb = 1; |
| 254 | |
| 255 | /* |
| 256 | * regular fb mapping at 0 |
| 257 | * since some Sun firmware likes to put PCI resources low enough |
| 258 | * to collide with the wsfb mapping we only allow it after asking |
| 259 | * for offset 0 |
| 260 | */ |
| 261 | DPRINTF("%s: %08x limit %08x\n" , __func__, (uint32_t)offset, |
| 262 | (uint32_t)sc->sc_gen.sc_fbsize); |
| 263 | if ((offset >= 0) && (offset < sc->sc_gen.sc_fbsize) && |
| 264 | (sc->sc_want_wsfb == 1)) { |
| 265 | |
| 266 | return bus_space_mmap(sc->sc_memt, sc->sc_gen.sc_fboffset, |
| 267 | offset, prot, |
| 268 | BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_PREFETCHABLE); |
| 269 | } |
| 270 | |
| 271 | /* |
| 272 | * restrict all other mappings to processes with superuser privileges |
| 273 | * or the kernel itself |
| 274 | */ |
| 275 | if (kauth_authorize_machdep(kauth_cred_get(), KAUTH_MACHDEP_UNMANAGEDMEM, |
| 276 | NULL, NULL, NULL, NULL) != 0) { |
| 277 | aprint_normal_dev(sc->sc_gen.sc_dev, "mmap() rejected.\n" ); |
| 278 | return -1; |
| 279 | } |
| 280 | |
| 281 | #ifdef WSFB_FAKE_VGA_FB |
| 282 | if ((offset >= 0xa0000) && (offset < 0xbffff)) { |
| 283 | |
| 284 | return bus_space_mmap(sc->sc_memt, sc->sc_gen.sc_fboffset, |
| 285 | offset - 0xa0000, prot, BUS_SPACE_MAP_LINEAR); |
| 286 | } |
| 287 | #endif |
| 288 | |
| 289 | /* |
| 290 | * XXX this should be generalized, let's just |
| 291 | * #define PCI_IOAREA_PADDR |
| 292 | * #define PCI_IOAREA_OFFSET |
| 293 | * #define PCI_IOAREA_SIZE |
| 294 | * somewhere in a MD header and compile this code only if all are |
| 295 | * present |
| 296 | */ |
| 297 | /* |
| 298 | * no. |
| 299 | * PCI_IOAREA_PADDR would be completely, utterly wrong and completely |
| 300 | * useless for the following reasons: |
| 301 | * - it's a bus address, not a physical address |
| 302 | * - there's no guarantee it's the same for each host bridge |
| 303 | * - it's already taken care of by the IO tag |
| 304 | * PCI_IOAREA_OFFSET is the same as PCI_MAGIC_IO_RANGE |
| 305 | * PCI_IOAREA_SIZE is also useless: |
| 306 | * - many cards don't decode more than 16 bit IO anyway |
| 307 | * - even machines with more than 64kB IO space try to keep everything |
| 308 | * within 64kB for the reason above |
| 309 | * - IO ranges tend to be small so in most cases you can't cram enough |
| 310 | * cards into a single machine to exhaust 64kB IO space |
| 311 | * - machines which need this tend to prefer memory space anyway |
| 312 | * - the only use for this right now is to allow the Xserver to map |
| 313 | * VGA registers on macppc and a few other powerpc ports, shark uses |
| 314 | * a similar mechanism, and what they need is always within 64kB |
| 315 | */ |
| 316 | #ifdef PCI_MAGIC_IO_RANGE |
| 317 | /* allow to map our IO space */ |
| 318 | if ((offset >= PCI_MAGIC_IO_RANGE) && |
| 319 | (offset < PCI_MAGIC_IO_RANGE + 0x10000)) { |
| 320 | return bus_space_mmap(sc->sc_iot, offset - PCI_MAGIC_IO_RANGE, |
| 321 | 0, prot, BUS_SPACE_MAP_LINEAR); |
| 322 | } |
| 323 | #endif |
| 324 | |
| 325 | /* allow to mmap() our BARs */ |
| 326 | /* maybe the ROM BAR too? */ |
| 327 | for (i = 0; i < sc->sc_ranges_used; i++) { |
| 328 | |
| 329 | r = &sc->sc_ranges[i]; |
| 330 | if ((offset >= r->offset) && (offset < (r->offset + r->size))) { |
| 331 | return bus_space_mmap(sc->sc_memt, offset, 0, prot, |
| 332 | r->flags); |
| 333 | } |
| 334 | } |
| 335 | |
| 336 | return -1; |
| 337 | } |
| 338 | |
| 339 | int |
| 340 | pci_genfb_borrow(void *opaque, bus_addr_t addr, bus_space_handle_t *hdlp) |
| 341 | { |
| 342 | struct pci_genfb_softc *sc = opaque; |
| 343 | |
| 344 | if (sc == NULL) |
| 345 | return 0; |
| 346 | if (!sc->sc_gen.sc_fboffset) |
| 347 | return 0; |
| 348 | if (sc->sc_gen.sc_fboffset != addr) |
| 349 | return 0; |
| 350 | *hdlp = sc->sc_memh; |
| 351 | return 1; |
| 352 | } |
| 353 | |
| 354 | static bool |
| 355 | pci_genfb_shutdown(device_t self, int flags) |
| 356 | { |
| 357 | genfb_enable_polling(self); |
| 358 | return true; |
| 359 | } |
| 360 | |