/* * Early console support. Only used on hp300. */ int sti_cnattach(struct sti_rom *rom, struct sti_screen *scr, bus_space_tag_t memt, bus_addr_t *bases, u_int codebase) { bus_space_handle_t romh; u_int romend; int error; long defattr; if ((error = bus_space_map(memt, bases[0], PAGE_SIZE, 0, &romh)) != 0) return error; /* * Compute real PROM size */ romend = sti_rom_size(memt, romh); bus_space_unmap(memt, romh, PAGE_SIZE); if ((error = bus_space_map(memt, bases[0], romend, 0, &romh)) != 0) return error; bases[0] = romh; if (sti_rom_setup(rom, memt, memt, romh, bases, codebase) != 0) return -1; scr->scr_rom = rom; if (sti_screen_setup(scr, STI_CLEARSCR) != 0) return -1; sti_alloc_attr(scr, 0, 0, 0, &defattr); wsdisplay_cnattach(&scr->scr_wsd, scr, 0, 0, defattr); return 0; }
int nextdisplay_cnattach(void) { struct nextdisplay_config *dc = &nextdisplay_console_dc; long defattr; int iscolor; if (rom_machine_type == NeXT_WARP9C || rom_machine_type == NeXT_TURBO_COLOR) iscolor = 1; else iscolor = 0; /* set up the display */ nextdisplay_init(&nextdisplay_console_dc, iscolor); nextdisplay_consaddr = nextdisplay_console_dc.dc_vaddr; rcons_allocattr(&dc->dc_rcons, 0, 0, iscolor ? 0 : WSATTR_REVERSE, &defattr); wsdisplay_cnattach(iscolor ? &nextdisplay_color : &nextdisplay_mono, &dc->dc_rcons, 0, 0, defattr); dc->isconsole = 1; return (0); }
void sti_end_attach(struct sti_softc *sc) { struct sti_screen *scr = sc->sc_scr; if (scr == NULL) return; #if NWSDISPLAY > 0 else { struct wsemuldisplaydev_attach_args waa; scr->scr_wsmode = WSDISPLAYIO_MODE_EMUL; waa.console = sc->sc_flags & STI_CONSOLE ? 1 : 0; waa.scrdata = &scr->scr_screenlist; waa.accessops = &sti_accessops; waa.accesscookie = scr; /* attach as console if required */ if (waa.console && !ISSET(sc->sc_flags, STI_ATTACHED)) { long defattr; sti_alloc_attr(scr, 0, 0, 0, &defattr); wsdisplay_cnattach(&scr->scr_wsd, scr, 0, scr->scr_wsd.nrows - 1, defattr); sc->sc_flags |= STI_ATTACHED; } config_found(sc->sc_dev, &waa, wsemuldisplaydevprint); } #endif }
void sti_end_attach_screen(struct sti_softc *sc, struct sti_screen *scr, int console) { struct wsemuldisplaydev_attach_args waa; scr->scr_wsmode = WSDISPLAYIO_MODE_EMUL; waa.console = console; waa.scrdata = &scr->scr_screenlist; waa.accessops = &sti_accessops; waa.accesscookie = scr; waa.defaultscreens = 0; /* attach as console if required */ if (console && !ISSET(sc->sc_flags, STI_ATTACHED)) { long defattr; sti_alloc_attr(scr, 0, 0, 0, &defattr); wsdisplay_cnattach(&scr->scr_wsd, scr, 0, scr->scr_wsd.nrows - 1, defattr); sc->sc_flags |= STI_ATTACHED; } config_found(&sc->sc_dev, &waa, wsemuldisplaydevprint); }
/* * Attach.. plug pointer in and print some info. * Then try and attach a wsdisplay or ite to us. * Note: self is NULL durring console init. */ void grfattach(device_t parent, device_t self, void *aux) { #if NWSDISPLAY > 0 struct wsemuldisplaydev_attach_args wa; long defattr; #endif struct grf_softc *gp; int maj; gp = device_private(parent); gp->g_device = self; grfsp[gp->g_unit] = gp; /* * find our major device number */ maj = cdevsw_lookup_major(&grf_cdevsw); gp->g_grfdev = makedev(maj, gp->g_unit); if (self != NULL) { printf(": width %d height %d", gp->g_display.gd_dwidth, gp->g_display.gd_dheight); if (gp->g_display.gd_colors == 2) printf(" monochrome\n"); else printf(" colors %d\n", gp->g_display.gd_colors); #if NWSDISPLAY > 0 vcons_init(&gp->g_vd, gp, gp->g_screens[0], gp->g_accessops); gp->g_vd.init_screen = grf_init_screen; if (gp->g_flags & GF_CONSOLE) { console_vcons.scr_flags |= VCONS_SCREEN_IS_STATIC; vcons_init_screen(&gp->g_vd, &console_vcons, 1, &defattr); gp->g_screens[0]->textops = &console_vcons.scr_ri.ri_ops; wsdisplay_cnattach(gp->g_screens[0], &console_vcons.scr_ri, 0, 0, defattr); vcons_replay_msgbuf(&console_vcons); } /* attach wsdisplay */ wa.console = (gp->g_flags & GF_CONSOLE) != 0; wa.scrdata = &gp->g_screenlist; wa.accessops = gp->g_accessops; wa.accesscookie = &gp->g_vd; config_found(self, &wa, wsemuldisplaydevprint); #endif /* NWSDISPLAY > 0 */ } #if NWSDISPLAY == 0 /* * try and attach an ite */ amiga_config_found(cfdata, self, gp, grfprint); #endif }
void fbwscons_console_init(struct sunfb *sf, int row) { struct rasops_info *ri = &sf->sf_ro; long defattr; if (CPU_ISSUN4 || romgetcursoraddr(&sf->sf_crowp, &sf->sf_ccolp)) sf->sf_ccolp = sf->sf_crowp = NULL; if (sf->sf_ccolp != NULL) ri->ri_ccol = *sf->sf_ccolp; if (row < 0) { if (sf->sf_crowp != NULL) ri->ri_crow = *sf->sf_crowp; else /* assume last row */ ri->ri_crow = ri->ri_rows - 1; } else { /* * If we force the display row, this is because the screen * has been cleared or the font has been changed. * In this case, choose not to keep pointers to the PROM * cursor position, as the values are likely to be inaccurate * upon shutdown... */ sf->sf_crowp = sf->sf_ccolp = NULL; ri->ri_crow = row; } /* * Scale back rows and columns if the font would not otherwise * fit on this display. Without this we would panic later. */ if (ri->ri_crow >= ri->ri_rows) ri->ri_crow = ri->ri_rows - 1; if (ri->ri_ccol >= ri->ri_cols) ri->ri_ccol = ri->ri_cols - 1; /* * Take care of updating the PROM cursor position as well if we can. */ if (ri->ri_updatecursor == NULL && (sf->sf_ccolp != NULL || sf->sf_crowp != NULL)) ri->ri_updatecursor = fb_updatecursor; if (ISSET(ri->ri_caps, WSSCREEN_WSCOLORS)) ri->ri_ops.alloc_attr(ri, WSCOL_BLACK, WSCOL_WHITE, WSATTR_WSCOLORS, &defattr); else ri->ri_ops.alloc_attr(ri, 0, 0, 0, &defattr); fb_initwsd(sf); wsdisplay_cnattach(&sf->sf_wsd, ri, ri->ri_ccol, ri->ri_crow, defattr); }
int smfb_cnattach(bus_space_tag_t memt, bus_space_tag_t iot, pcitag_t tag, pcireg_t id) { long defattr; struct rasops_info *ri; bus_space_handle_t fbh, mmioh; pcireg_t bar; int rc, is5xx; /* filter out unrecognized devices */ switch (id) { default: return ENODEV; case PCI_ID_CODE(PCI_VENDOR_SMI, PCI_PRODUCT_SMI_SM712): is5xx = 0; break; case PCI_ID_CODE(PCI_VENDOR_SMI, PCI_PRODUCT_SMI_SM501): is5xx = 1; break; } smfbcn.is5xx = is5xx; bar = pci_conf_read_early(tag, PCI_MAPREG_START); if (PCI_MAPREG_TYPE(bar) != PCI_MAPREG_TYPE_MEM) return EINVAL; rc = bus_space_map(memt, PCI_MAPREG_MEM_ADDR(bar), 1 /* XXX */, BUS_SPACE_MAP_LINEAR, &fbh); if (rc != 0) return rc; if (smfbcn.is5xx) { bar = pci_conf_read_early(tag, PCI_MAPREG_START + 0x04); if (PCI_MAPREG_TYPE(bar) != PCI_MAPREG_TYPE_MEM) return EINVAL; rc = bus_space_map(memt, PCI_MAPREG_MEM_ADDR(bar), 1 /* XXX */, BUS_SPACE_MAP_LINEAR, &mmioh); if (rc != 0) return rc; } else { mmioh = fbh; } rc = smfb_setup(&smfbcn, memt, fbh, memt, mmioh); if (rc != 0) return rc; ri = &smfbcn.ri; ri->ri_ops.alloc_attr(ri, 0, 0, 0, &defattr); wsdisplay_cnattach(&smfbcn.wsd, ri, 0, 0, defattr); return 0; }
int light_cnattach(struct gio_attach_args *ga) { if (!light_match(NULL, NULL, ga)) return (ENXIO); light_attach_common(&light_console_dc, ga); wsdisplay_cnattach(&light_screen, &light_console_dc, 0, 0, LIGHT_ATTR_ENCODE(WSCOL_WHITE, WSCOL_BLACK)); light_is_console = 1; return (0); }
/* * This gets called if this device is used as the console. */ void amidisplaycc_cninit(struct consdev * cd) { void * cookie; long attr; int x; int y; /* Yeah, we got the console! */ /* * This will do the basic stuff we also need. */ config_console(); grfcc_probe(); #if NVIEW>0 viewprobe(); #endif /* * Set up wscons to handle the details. * It will then call us back when it needs something * display-specific. It will also set up cn_tab properly, * something which we failed to do at amidisplaycc_cnprobe(). */ /* * The alloc_screen knows to allocate the first screen statically. */ amidisplaycc_alloc_screen(NULL, &amidisplaycc_screentab[0].wsdescr, &cookie, &x, &y, &attr); wsdisplay_cnattach(&amidisplaycc_screentab[0].wsdescr, cookie, x, y, attr); #if NKBD>0 /* tell kbd device it is used as console keyboard */ kbd_cnattach(); #endif }
int pcdisplay_cnattach(bus_space_tag_t iot, bus_space_tag_t memt) { int mono; if (pcdisplay_probe_col(iot, memt)) mono = 0; else if (pcdisplay_probe_mono(iot, memt)) mono = 1; else return (ENXIO); pcdisplay_init(&pcdisplay_console_dc, iot, memt, mono); wsdisplay_cnattach(&pcdisplay_scr, &pcdisplay_console_dc, pcdisplay_console_dc.pcs.cursorcol, pcdisplay_console_dc.pcs.cursorrow, FG_LIGHTGREY | BG_BLACK); pcdisplayconsole = 1; return (0); }
int smfb_cnattach() { long defattr; struct rasops_info *ri; vaddr_t fbbase; int rc; extern paddr_t loongson_pci_base; /* XXX hardwired fbmem address */ fbbase = PHYS_TO_XKPHYS(loongson_pci_base + 0x14000000, CCA_NC); rc = smfb_setup(&smfbcn, fbbase); if (rc != 0) return rc; ri = &smfbcn.ri; ri->ri_ops.alloc_attr(ri, 0, 0, 0, &defattr); wsdisplay_cnattach(&smfbcn.wsd, ri, 0, 0, defattr); return 0; }
int newport_cnattach(struct gio_attach_args *ga) { struct rasops_info *ri = &newport_console_screen.scr_ri; long defattr = NEWPORT_ATTR_ENCODE(WSCOL_WHITE, WSCOL_BLACK); if (!newport_match(NULL, NULL, ga)) { return ENXIO; } newport_attach_common(&newport_console_dc, ga); newport_screen.ncols = newport_console_dc.dc_xres / 8; newport_screen.nrows = newport_console_dc.dc_yres / 16; ri->ri_hw = &newport_console_screen; ri->ri_depth = newport_console_dc.dc_depth; ri->ri_width = newport_console_dc.dc_xres; ri->ri_height = newport_console_dc.dc_yres; ri->ri_stride = newport_console_dc.dc_xres; /* XXX */ ri->ri_flg = RI_CENTER | RI_FULLCLEAR; ri->ri_ops.copyrows = newport_copyrows; ri->ri_ops.eraserows = newport_eraserows; ri->ri_ops.copycols = newport_copycols; ri->ri_ops.erasecols = newport_erasecols; ri->ri_ops.cursor = newport_cursor_dummy; ri->ri_ops.mapchar = newport_mapchar; ri->ri_ops.putchar = newport_putchar; ri->ri_ops.allocattr = newport_allocattr; ri->ri_font = newport_console_dc.dc_fontdata; newport_console_screen.scr_cookie = &newport_console_dc; wsdisplay_cnattach(&newport_screen, ri, 0, 0, defattr); newport_is_console = 1; return 0; }
int xafb_cnattach(void) { struct xafb_devconfig *dc = &xafb_console_dc; struct rasops_info *ri = &dc->dc_ri; long defattr; int crow = 0; if (!xafb_is_console()) return -1; dc->dc_fbpaddr = (paddr_t)0x10000000; dc->dc_fbbase = (void *)MIPS_PHYS_TO_KSEG1(dc->dc_fbpaddr); dc->dc_reg = (void *)0xb4903000; /* XXX */ xafb_common_init(dc); crow = 0; /* XXX current cursor pos */ (*ri->ri_ops.allocattr)(ri, 0, 0, 0, &defattr); wsdisplay_cnattach(&xafb_stdscreen, &dc->dc_ri, 0, crow, defattr); return 0; }
/* * Called very early to setup the glass tty as console. * Because it's called before the VM system is initialized, virtual memory * for the framebuffer can be stolen directly without disturbing anything. */ int legsscninit() { struct legss_screen *ss = &legss_consscr; extern vaddr_t virtual_avail; vaddr_t ova; long defattr; struct rasops_info *ri; ova = virtual_avail; ioaccess(virtual_avail, LEGSS_BASE + LEGSS_VRAM_OFFSET, 1); ss->ss_depth = legss_probe_depth(virtual_avail); iounaccess(virtual_avail, 1); if (ss->ss_depth == 0) return 1; ioaccess(virtual_avail, LEGSS_BASE + LEGSS_VRAM_OFFSET, (LEGSS_VISHEIGHT * LEGSS_WIDTH * 32 / NBBY) / VAX_NBPG); ss->ss_vram = virtual_avail; virtual_avail += (LEGSS_VISHEIGHT * LEGSS_WIDTH * 32 / NBBY); virtual_avail = round_page(virtual_avail); /* this had better not fail */ if (legss_setup_screen(ss) != 0) { iounaccess(ss->ss_vram, (LEGSS_VISHEIGHT * LEGSS_WIDTH * 32 / NBBY) / VAX_NBPG); virtual_avail = ova; return 1; } ri = &ss->ss_ri; ri->ri_ops.alloc_attr(ri, 0, 0, 0, &defattr); wsdisplay_cnattach(&legss_stdscreen, ri, 0, 0, defattr); return 0; }
int hpcfb_cnattach(struct hpcfb_fbconf *fbconf) { struct hpcfb_fbconf __fbconf __attribute__((__unused__)); long defattr; DPRINTF(("%s(%d): hpcfb_cnattach()\n", __FILE__, __LINE__)); #if NBIVIDEO > 0 if (fbconf == 0) { memset(&__fbconf, 0, sizeof(struct hpcfb_fbconf)); if (bivideo_getcnfb(&__fbconf) != 0) return (ENXIO); fbconf = &__fbconf; } #endif /* NBIVIDEO > 0 */ memset(&hpcfb_console_dc, 0, sizeof(struct hpcfb_devconfig)); if (hpcfb_init(fbconf, &hpcfb_console_dc) != 0) return (ENXIO); hpcfb_console_dc.dc_state |= HPCFB_DC_CURRENT; hpcfb_console_dc.dc_tvram = hpcfb_console_tvram; /* clear screen */ memset(hpcfb_console_tvram, 0, sizeof(hpcfb_console_tvram)); hpcfb_redraw(&hpcfb_console_dc, 0, hpcfb_console_dc.dc_rows, 1); hpcfb_console_wsscreen = hpcfb_stdscreen; hpcfb_console_wsscreen.nrows = hpcfb_console_dc.dc_rows; hpcfb_console_wsscreen.ncols = hpcfb_console_dc.dc_cols; hpcfb_console_wsscreen.capabilities = hpcfb_console_dc.dc_rinfo.ri_caps; hpcfb_alloc_attr(&hpcfb_console_dc, WSCOL_WHITE, WSCOL_BLACK, 0, &defattr); wsdisplay_cnattach(&hpcfb_console_wsscreen, &hpcfb_console_dc, 0, 0, defattr); hpcfbconsole = 1; return (0); }
/* EXPORT */ int vidcvideo_cnattach(vaddr_t addr) { struct fb_devconfig *dc = &vidcvideo_console_dc; struct rasops_info *ri; long defattr; vidcvideo_init(); /* fetch current framebuffer config */ vidcvideo_getdevconfig(videomemory.vidm_vbase, videomemory.vidm_size, dc); dc->dc_vd.active = NULL; vidcvideoinit_screen(dc, &dc->dc_console, 1, &defattr); ri = &(dc->dc_console.scr_ri); ri->ri_hw = &dc->dc_console; dc->dc_console.scr_cookie = dc; (*ri->ri_ops.allocattr)(ri, WS_DEFAULT_FG, /* fg */ WS_DEFAULT_BG, /* bg */ 0, /* wsattrs */ &defattr); wsdisplay_cnattach(&vidcvideo_stdscreen, ri, /* emulcookie */ 0, 0, /* cursor position */ defattr); vidcvideo_is_console = true; return 0; }
int newport_cnattach(struct gio_attach_args *ga) { long defattr = NEWPORT_ATTR_ENCODE(WSCOL_WHITE, WSCOL_BLACK); const struct wsscreen_descr *screen; if (!newport_match(NULL, NULL, ga)) { return ENXIO; } newport_attach_common(&newport_console_dc, ga); if (newport_console_dc.dc_xres >= 1280 && newport_console_dc.dc_yres >= 1024) screen = &newport_screen_1280x1024; else screen = &newport_screen_1024x768; wsdisplay_cnattach(screen, &newport_console_dc, 0, 0, defattr); newport_is_console = 1; return 0; }
void radeondrm_attachhook(void *xsc) { struct radeon_device *rdev = xsc; int r, acpi_status; /* radeon_device_init should report only fatal error * like memory allocation failure or iomapping failure, * or memory manager initialization failure, it must * properly initialize the GPU MC controller and permit * VRAM allocation */ r = radeon_device_init(rdev, rdev->ddev); if (r) { printf(": Fatal error during GPU init\n"); radeon_fatal_error = 1; radeondrm_forcedetach(rdev); return; } /* Again modeset_init should fail only on fatal error * otherwise it should provide enough functionalities * for shadowfb to run */ r = radeon_modeset_init(rdev); if (r) printf("Fatal error during modeset init\n"); /* Call ACPI methods: require modeset init * but failure is not fatal */ if (!r) { acpi_status = radeon_acpi_init(rdev); if (acpi_status) DRM_DEBUG("Error during ACPI methods call\n"); } { struct wsemuldisplaydev_attach_args aa; struct rasops_info *ri = &rdev->ro; if (ri->ri_bits == NULL) return; #ifdef __sparc64__ fbwscons_setcolormap(&rdev->sf, radeondrm_setcolor); #endif drm_fb_helper_restore(); #ifndef __sparc64__ ri->ri_flg = RI_CENTER | RI_VCONS | RI_WRONLY; rasops_init(ri, 160, 160); ri->ri_hw = rdev; #else ri = &rdev->sf.sf_ro; #endif radeondrm_stdscreen.capabilities = ri->ri_caps; radeondrm_stdscreen.nrows = ri->ri_rows; radeondrm_stdscreen.ncols = ri->ri_cols; radeondrm_stdscreen.textops = &ri->ri_ops; radeondrm_stdscreen.fontwidth = ri->ri_font->fontwidth; radeondrm_stdscreen.fontheight = ri->ri_font->fontheight; aa.console = rdev->console; aa.scrdata = &radeondrm_screenlist; aa.accessops = &radeondrm_accessops; aa.accesscookie = ri; aa.defaultscreens = 0; if (rdev->console) { long defattr; ri->ri_ops.alloc_attr(ri->ri_active, 0, 0, 0, &defattr); wsdisplay_cnattach(&radeondrm_stdscreen, ri->ri_active, ri->ri_ccol, ri->ri_crow, defattr); } /* * Now that we've taken over the console, disable decoding of * VGA legacy addresses, and opt out of arbitration. */ radeon_vga_set_state(rdev, false); pci_disable_legacy_vga(&rdev->dev); printf("%s: %dx%d\n", rdev->dev.dv_xname, ri->ri_width, ri->ri_height); config_found_sm(&rdev->dev, &aa, wsemuldisplaydevprint, wsemuldisplaydevsubmatch); } }
static void cg14_setup_wsdisplay(struct cgfourteen_softc *sc, int is_cons) { struct wsemuldisplaydev_attach_args aa; struct rasops_info *ri; long defattr; sc->sc_defaultscreen_descr = (struct wsscreen_descr){ "default", 0, 0, NULL, 8, 16, WSSCREEN_WSCOLORS | WSSCREEN_HILIT, NULL }; sc->sc_screens[0] = &sc->sc_defaultscreen_descr; sc->sc_screenlist = (struct wsscreen_list){1, sc->sc_screens}; sc->sc_mode = WSDISPLAYIO_MODE_EMUL; vcons_init(&sc->sc_vd, sc, &sc->sc_defaultscreen_descr, &cg14_accessops); sc->sc_vd.init_screen = cg14_init_screen; ri = &sc->sc_console_screen.scr_ri; if (is_cons) { vcons_init_screen(&sc->sc_vd, &sc->sc_console_screen, 1, &defattr); sc->sc_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC; sc->sc_defaultscreen_descr.textops = &ri->ri_ops; sc->sc_defaultscreen_descr.capabilities = ri->ri_caps; sc->sc_defaultscreen_descr.nrows = ri->ri_rows; sc->sc_defaultscreen_descr.ncols = ri->ri_cols; wsdisplay_cnattach(&sc->sc_defaultscreen_descr, ri, 0, 0, defattr); } else { /* * since we're not the console we can postpone the rest * until someone actually allocates a screen for us */ } cg14_init_cmap(sc); aa.console = is_cons; aa.scrdata = &sc->sc_screenlist; aa.accessops = &cg14_accessops; aa.accesscookie = &sc->sc_vd; config_found(sc->sc_dev, &aa, wsemuldisplaydevprint); } static void cg14_init_cmap(struct cgfourteen_softc *sc) { int i, j = 0; for (i = 0; i < 256; i++) { sc->sc_cmap.cm_map[i][3] = rasops_cmap[j]; sc->sc_cmap.cm_map[i][2] = rasops_cmap[j + 1]; sc->sc_cmap.cm_map[i][1] = rasops_cmap[j + 2]; j += 3; } cg14_load_hwcmap(sc, 0, 256); } static int cg14_putcmap(struct cgfourteen_softc *sc, struct wsdisplay_cmap *cm) { u_int index = cm->index; u_int count = cm->count; int i, error; u_char rbuf[256], gbuf[256], bbuf[256]; if (cm->index >= 256 || cm->count > 256 || (cm->index + cm->count) > 256) return EINVAL; error = copyin(cm->red, &rbuf[index], count); if (error) return error; error = copyin(cm->green, &gbuf[index], count); if (error) return error; error = copyin(cm->blue, &bbuf[index], count); if (error) return error; for (i = 0; i < count; i++) { sc->sc_cmap.cm_map[index][3] = rbuf[index]; sc->sc_cmap.cm_map[index][2] = gbuf[index]; sc->sc_cmap.cm_map[index][1] = bbuf[index]; index++; } cg14_load_hwcmap(sc, 0, 256); return 0; }
/* * Attach a display. We need to notice if it is the console, too. */ static void p9100_sbus_attach(struct device *parent, struct device *self, void *args) { struct p9100_softc *sc = device_private(self); struct sbus_attach_args *sa = args; struct fbdevice *fb = &sc->sc_fb; int isconsole; int node; int i, j; uint8_t ver; #if NWSDISPLAY > 0 struct wsemuldisplaydev_attach_args aa; struct rasops_info *ri; unsigned long defattr; #endif sc->sc_last_offset = 0xffffffff; /* Remember cookies for p9100_mmap() */ sc->sc_bustag = sa->sa_bustag; sc->sc_ctl_paddr = sbus_bus_addr(sa->sa_bustag, sa->sa_reg[0].oa_space, sa->sa_reg[0].oa_base); sc->sc_ctl_psize = 0x8000;/*(bus_size_t)sa->sa_reg[0].oa_size;*/ sc->sc_cmd_paddr = sbus_bus_addr(sa->sa_bustag, sa->sa_reg[1].oa_space, sa->sa_reg[1].oa_base); sc->sc_cmd_psize = (bus_size_t)sa->sa_reg[1].oa_size; sc->sc_fb_paddr = sbus_bus_addr(sa->sa_bustag, sa->sa_reg[2].oa_space, sa->sa_reg[2].oa_base); sc->sc_fb_psize = (bus_size_t)sa->sa_reg[2].oa_size; fb->fb_driver = &p9100fbdriver; fb->fb_device = &sc->sc_dev; fb->fb_flags = device_cfdata(&sc->sc_dev)->cf_flags & FB_USERMASK; #ifdef PNOZZ_EMUL_CG3 fb->fb_type.fb_type = FBTYPE_SUN3COLOR; #else fb->fb_type.fb_type = FBTYPE_P9100; #endif fb->fb_pixels = NULL; sc->sc_mode = WSDISPLAYIO_MODE_EMUL; node = sa->sa_node; isconsole = fb_is_console(node); if (!isconsole) { aprint_normal("\n"); aprint_error_dev(self, "fatal error: PROM didn't configure device\n"); return; } /* * When the ROM has mapped in a p9100 display, the address * maps only the video RAM, so in any case we have to map the * registers ourselves. We only need the video RAM if we are * going to print characters via rconsole. */ if (sbus_bus_map(sc->sc_bustag, sa->sa_reg[0].oa_space, sa->sa_reg[0].oa_base, /* * XXX for some reason the SBus resources don't cover * all registers, so we just map what we need */ /*sc->sc_ctl_psize*/ 0x8000, /*BUS_SPACE_MAP_LINEAR*/0, &sc->sc_ctl_memh) != 0) { aprint_error_dev(self, "cannot map control registers\n"); return; } if (sa->sa_npromvaddrs != 0) fb->fb_pixels = (void *)sa->sa_promvaddrs[0]; if (fb->fb_pixels == NULL) { if (sbus_bus_map(sc->sc_bustag, sa->sa_reg[2].oa_space, sa->sa_reg[2].oa_base, sc->sc_fb_psize, BUS_SPACE_MAP_LINEAR, &sc->sc_fb_memh) != 0) { aprint_error_dev(self, "cannot map framebuffer\n"); return; } fb->fb_pixels = (char *)sc->sc_fb_memh; } else { sc->sc_fb_memh = (bus_space_handle_t) fb->fb_pixels; } i = p9100_ctl_read_4(sc, 0x0004); switch ((i >> 26) & 7) { case 5: fb->fb_type.fb_depth = 32; break; case 7: fb->fb_type.fb_depth = 24; break; case 3: fb->fb_type.fb_depth = 16; break; case 2: fb->fb_type.fb_depth = 8; break; default: { panic("pnozz: can't determine screen depth (0x%02x)", i); } } sc->sc_depth = (fb->fb_type.fb_depth >> 3); /* XXX for some reason I get a kernel trap with this */ sc->sc_width = prom_getpropint(node, "width", 800); sc->sc_height = prom_getpropint(node, "height", 600); sc->sc_stride = prom_getpropint(node, "linebytes", sc->sc_width * (fb->fb_type.fb_depth >> 3)); /* check the RAMDAC */ ver = p9100_ramdac_read_ctl(sc, DAC_VERSION); p9100_init_engine(sc); fb_setsize_obp(fb, fb->fb_type.fb_depth, sc->sc_width, sc->sc_height, node); sbus_establish(&sc->sc_sd, &sc->sc_dev); bus_intr_establish(sc->sc_bustag, sa->sa_pri, IPL_BIO, p9100_intr, sc); fb->fb_type.fb_size = fb->fb_type.fb_height * fb->fb_linebytes; printf(": rev %d / %x, %dx%d, depth %d mem %x", (i & 7), ver, fb->fb_type.fb_width, fb->fb_type.fb_height, fb->fb_type.fb_depth, (unsigned int)sc->sc_fb_psize); fb->fb_type.fb_cmsize = prom_getpropint(node, "cmsize", 256); if ((1 << fb->fb_type.fb_depth) != fb->fb_type.fb_cmsize) printf(", %d entry colormap", fb->fb_type.fb_cmsize); /* Initialize the default color map. */ /*bt_initcmap(&sc->sc_cmap, 256);*/ j = 0; for (i = 0; i < 256; i++) { sc->sc_cmap.cm_map[i][0] = rasops_cmap[j]; j++; sc->sc_cmap.cm_map[i][1] = rasops_cmap[j]; j++; sc->sc_cmap.cm_map[i][2] = rasops_cmap[j]; j++; } p9100loadcmap(sc, 0, 256); /* make sure we are not blanked */ if (isconsole) p9100_set_video(sc, 1); if (shutdownhook_establish(p9100_shutdown, sc) == NULL) { panic("%s: could not establish shutdown hook", device_xname(&sc->sc_dev)); } if (isconsole) { printf(" (console)\n"); #ifdef RASTERCONSOLE /*p9100loadcmap(sc, 255, 1);*/ fbrcons_init(fb); #endif } else printf("\n"); #if NWSDISPLAY > 0 wsfont_init(); vcons_init(&sc->vd, sc, &p9100_defscreendesc, &p9100_accessops); sc->vd.init_screen = p9100_init_screen; vcons_init_screen(&sc->vd, &p9100_console_screen, 1, &defattr); p9100_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC; sc->sc_bg = (defattr >> 16) & 0xff; p9100_clearscreen(sc); ri = &p9100_console_screen.scr_ri; p9100_defscreendesc.nrows = ri->ri_rows; p9100_defscreendesc.ncols = ri->ri_cols; p9100_defscreendesc.textops = &ri->ri_ops; p9100_defscreendesc.capabilities = ri->ri_caps; if(isconsole) { wsdisplay_cnattach(&p9100_defscreendesc, ri, 0, 0, defattr); } aa.console = isconsole; aa.scrdata = &p9100_screenlist; aa.accessops = &p9100_accessops; aa.accesscookie = &sc->vd; config_found(self, &aa, wsemuldisplaydevprint); #endif /* cursor sprite handling */ p9100_init_cursor(sc); /* attach the fb */ fb_attach(fb, isconsole); /* register with power management */ sc->sc_video = 1; sc->sc_powerstate = PWR_RESUME; powerhook_establish(device_xname(&sc->sc_dev), p9100_power_hook, sc); #if NTCTRL > 0 /* register callback for external monitor status change */ tadpole_register_callback(p9100_set_extvga, sc); #endif }
static void igmafb_attach(device_t parent, device_t self, void *aux) { struct igmafb_softc *sc = device_private(self); struct igma_attach_args *iaa = (struct igma_attach_args *)aux; struct rasops_info *ri; prop_dictionary_t dict; bool is_console; unsigned long defattr; struct wsemuldisplaydev_attach_args waa; sc->sc_dev = self; aprint_normal("\n"); dict = device_properties(self); prop_dictionary_get_bool(dict, "is_console", &is_console); if (iaa->iaa_console) is_console = true; sc->sc_chip = iaa->iaa_chip; sc->sc_fbaddr = bus_space_vaddr(sc->sc_chip.gmt, sc->sc_chip.gmh); sc->sc_fbsize = 16 * 1024 * 1024; igmafb_guess_size(sc, &sc->sc_width, &sc->sc_height); sc->sc_depth = 32; sc->sc_stride = (sc->sc_width*4 + 511)/512*512; aprint_normal("%s: %d x %d, %d bit, stride %d\n", device_xname(self), sc->sc_width, sc->sc_height, sc->sc_depth, sc->sc_stride); aprint_normal("%s: %d MB video memory at 0x%p\n", device_xname(self), (int)sc->sc_fbsize >> 20, (void *)sc->sc_chip.gmb); sc->sc_vga_save = kmem_alloc(256*1024, KM_SLEEP); igmafb_get_brightness(sc, &sc->sc_brightness); igmafb_get_brightness_max(sc, &sc->sc_brightness_max); sc->sc_backlight = sc->sc_brightness != 0; sc->sc_defaultscreen_descr = (struct wsscreen_descr) { "default", 0, 0, NULL, 8, 16, WSSCREEN_WSCOLORS | WSSCREEN_HILIT, NULL }; sc->sc_screens[0] = &sc->sc_defaultscreen_descr; sc->sc_screenlist = (struct wsscreen_list) { 1, sc->sc_screens }; vcons_init(&sc->vd, sc, &sc->sc_defaultscreen_descr, &igmafb_accessops); sc->vd.init_screen = igmafb_init_screen; /* enable hardware display */ igmafb_set_mode(sc, true); ri = &sc->sc_console_screen.scr_ri; if (is_console) { vcons_init_screen(&sc->vd, &sc->sc_console_screen, 1, &defattr); sc->sc_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC | VCONS_NO_COPYROWS | VCONS_NO_COPYCOLS; vcons_redraw_screen(&sc->sc_console_screen); sc->sc_defaultscreen_descr.textops = &ri->ri_ops; sc->sc_defaultscreen_descr.capabilities = ri->ri_caps; sc->sc_defaultscreen_descr.nrows = ri->ri_rows; sc->sc_defaultscreen_descr.ncols = ri->ri_cols; wsdisplay_cnattach(&sc->sc_defaultscreen_descr, ri, 0, 0, defattr); vcons_replay_msgbuf(&sc->sc_console_screen); } else { if (sc->sc_console_screen.scr_ri.ri_rows == 0) { /* do some minimal setup to avoid weirdness later */ vcons_init_screen(&sc->vd, &sc->sc_console_screen, 1, &defattr); } else (*ri->ri_ops.allocattr)(ri, 0, 0, 0, &defattr); } waa.console = is_console; waa.scrdata = &sc->sc_screenlist; waa.accessops = &igmafb_accessops; waa.accesscookie = &sc->vd; config_found(sc->sc_dev, &waa, wsemuldisplaydevprint); } /* * wsdisplay accessops */ static int igmafb_ioctl(void *v, void *vs, u_long cmd, void *data, int flags, struct lwp *l) { struct vcons_data *vd = v; struct igmafb_softc *sc = vd->cookie; struct wsdisplay_fbinfo *wdf; struct vcons_screen *ms = vd->active; struct wsdisplayio_fbinfo *fbi; struct wsdisplay_param *param; int val; switch (cmd) { case WSDISPLAYIO_GTYPE: *(u_int *)data = WSDISPLAY_TYPE_PCIMISC; return 0; case WSDISPLAYIO_GINFO: if (ms == NULL) return ENODEV; wdf = data; wdf->width = ms->scr_ri.ri_width; wdf->height = ms->scr_ri.ri_height; wdf->depth = ms->scr_ri.ri_depth; wdf->cmsize = 256; /* XXX */ return 0; case WSDISPLAYIO_LINEBYTES: if (ms == NULL) return ENODEV; *(u_int *)data = ms->scr_ri.ri_stride; return 0; case WSDISPLAYIO_GET_FBINFO: fbi = data; return wsdisplayio_get_fbinfo(&ms->scr_ri, fbi); case WSDISPLAYIO_SVIDEO: val = (*(u_int *)data) != WSDISPLAYIO_VIDEO_OFF; sc->sc_backlight = val; if (val) igmafb_set_brightness(sc, sc->sc_brightness); else igmafb_set_brightness(sc, 0); return 0; case WSDISPLAYIO_GETPARAM: param = (struct wsdisplay_param *)data; switch (param->param) { case WSDISPLAYIO_PARAM_BRIGHTNESS: param->min = 0; param->max = 255; if (sc->sc_backlight) igmafb_get_brightness(sc, &val); else val = sc->sc_brightness; val = val * 255 / sc->sc_brightness_max; param->curval = val; return 0; case WSDISPLAYIO_PARAM_BACKLIGHT: param->min = 0; param->max = 1; param->curval = sc->sc_backlight; return 0; } return EPASSTHROUGH; case WSDISPLAYIO_SETPARAM: param = (struct wsdisplay_param *)data; switch (param->param) { case WSDISPLAYIO_PARAM_BRIGHTNESS: val = param->curval; if (val < 0) val = 0; if (val > 255) val = 255; val = val * sc->sc_brightness_max / 255; sc->sc_brightness = val; if (sc->sc_backlight) igmafb_set_brightness(sc, val); return 0; case WSDISPLAYIO_PARAM_BACKLIGHT: val = param->curval; sc->sc_backlight = val; if (val) igmafb_set_brightness(sc, sc->sc_brightness); else igmafb_set_brightness(sc, 0); return 0; } return EPASSTHROUGH; } return EPASSTHROUGH; } static paddr_t igmafb_mmap(void *v, void *vs, off_t offset, int prot) { struct vcons_data *vd = v; struct igmafb_softc *sc = vd->cookie; if ((offset & PAGE_MASK) != 0) return -1; if (offset < 0 || offset >= sc->sc_fbsize) return -1; return bus_space_mmap(sc->sc_chip.gmt, sc->sc_chip.gmb, offset, prot, BUS_SPACE_MAP_LINEAR); } static void igmafb_pollc(void *v, int on) { struct vcons_data *vd = v; struct igmafb_softc *sc = vd->cookie; if (sc == NULL) return; if (sc->sc_console_screen.scr_vd == NULL) return; if (on) vcons_enable_polling(&sc->vd); else vcons_disable_polling(&sc->vd); } static void igmafb_init_screen(void *cookie, struct vcons_screen *scr, int existing, long *defattr) { struct igmafb_softc *sc = cookie; struct rasops_info *ri = &scr->scr_ri; memset(ri, 0, sizeof(struct rasops_info)); ri->ri_depth = sc->sc_depth; ri->ri_width = sc->sc_width; ri->ri_height = sc->sc_height; ri->ri_stride = sc->sc_stride; ri->ri_flg = RI_CENTER | RI_FULLCLEAR; ri->ri_bits = (char *)sc->sc_fbaddr; if (existing) { ri->ri_flg |= RI_CLEAR; } switch (sc->sc_depth) { case 32: ri->ri_rnum = 8; ri->ri_gnum = 8; ri->ri_bnum = 8; ri->ri_rpos = 16; ri->ri_gpos = 8; ri->ri_bpos = 0; break; } rasops_init(ri, 0, 0); ri->ri_caps = WSSCREEN_WSCOLORS; rasops_reconfig(ri, sc->sc_height / ri->ri_font->fontheight, sc->sc_width / ri->ri_font->fontwidth); ri->ri_hw = scr; } static void igmafb_guess_size(struct igmafb_softc *sc, int *widthp, int *heightp) { const struct igma_chip *cd = &sc->sc_chip; const struct igma_chip_ops *co = cd->ops; int pipe = cd->use_pipe; u_int32_t r; r = co->read_reg(cd, PIPE_HTOTAL(pipe)); *widthp = PIPE_HTOTAL_GET_ACTIVE(r); r = co->read_reg(cd, PIPE_VTOTAL(pipe)); *heightp = PIPE_VTOTAL_GET_ACTIVE(r); aprint_normal("%s: vga active size %d x %d\n", device_xname(sc->sc_dev), *widthp, *heightp); if (*widthp < 640 || *heightp < 400) { r = co->read_reg(cd, PF_WINSZ(pipe)); *widthp = PF_WINSZ_GET_WIDTH(r); *heightp = PF_WINSZ_GET_HEIGHT(r); aprint_normal("%s: window size %d x %d\n", device_xname(sc->sc_dev), *widthp, *heightp); } if (*widthp < 640) *widthp = 640; if (*heightp < 400) *heightp = 400; } static void igmafb_set_mode(struct igmafb_softc *sc, bool enable) { const struct igma_chip *cd = &sc->sc_chip; const struct igma_chip_ops *co = cd->ops; int pipe = cd->use_pipe; u_int32_t r; u_int8_t b; int i; if (enable) { /* disable VGA machinery */ b = co->read_vga(cd, 0x01); co->write_vga(cd, 0x01, b | 0x20); /* disable VGA compatible display */ r = co->read_reg(cd, sc->sc_chip.vga_cntrl); co->write_reg(cd, sc->sc_chip.vga_cntrl, r | VGA_CNTRL_DISABLE); /* save VGA memory */ memcpy(sc->sc_vga_save, sc->sc_fbaddr, 256*1024); /* configure panel fitter */ co->write_reg(cd, PF_WINPOS(pipe), PF_WINPOS_VAL(0, 0)); co->write_reg(cd, PF_WINSZ(pipe), PF_WINSZ_VAL(sc->sc_width, sc->sc_height)); /* pipe size */ co->write_reg(cd, PIPE_SRCSZ(pipe), PIPE_SRCSZ_VAL(sc->sc_width, sc->sc_height)); /* enable pipe */ co->write_reg(cd, PIPE_CONF(pipe), PIPE_CONF_ENABLE | PIPE_CONF_8BPP); /* configure planes */ r = co->read_reg(cd, PRI_CTRL(pipe)); r &= ~(PRI_CTRL_PIXFMTMSK | PRI_CTRL_TILED); r |= PRI_CTRL_ENABLE | PRI_CTRL_BGR; co->write_reg(cd, PRI_CTRL(pipe), r | cd->pri_cntrl); co->write_reg(cd, PRI_LINOFF(pipe), 0); co->write_reg(cd, PRI_STRIDE(pipe), sc->sc_stride); co->write_reg(cd, PRI_SURF(pipe), 0); co->write_reg(cd, PRI_TILEOFF(pipe), 0); if (cd->quirks & IGMA_PLANESTART_QUIRK) igmafb_planestart_quirk(sc); if (cd->quirks & IGMA_PFITDISABLE_QUIRK) igmafb_pfitdisable_quirk(sc); } else { /* disable planes */ co->write_reg(cd, PRI_CTRL(pipe), 0 | cd->pri_cntrl); co->write_reg(cd, PRI_LINOFF(pipe), 0); co->write_reg(cd, PRI_STRIDE(pipe), 2560); co->write_reg(cd, PRI_SURF(pipe), 0); co->write_reg(cd, PRI_TILEOFF(pipe), 0); /* pipe size */ co->write_reg(cd, PIPE_SRCSZ(pipe), PIPE_SRCSZ_VAL(720,400)); /* disable pipe */ co->write_reg(cd, PIPE_CONF(pipe), 0); for (i=0; i<10; ++i) { delay(10); if ((co->read_reg(cd, PIPE_CONF(pipe)) & PIPE_CONF_STATE) == 0) break; } /* workaround before enabling VGA */ r = co->read_reg(cd, 0x42000); co->write_reg(cd, 0x42000, (r & 0x1fffffff) | 0xa0000000); r = co->read_reg(cd, 0x42004); co->write_reg(cd, 0x42004, (r & 0xfbffffff) | 0x00000000); /* configure panel fitter */ co->write_reg(cd, PF_WINPOS(pipe), PF_WINPOS_VAL(0, 0)); co->write_reg(cd, PF_WINSZ(pipe), PF_WINSZ_VAL(sc->sc_width, sc->sc_height)); /* enable VGA compatible display */ r = co->read_reg(cd, sc->sc_chip.vga_cntrl); co->write_reg(cd, sc->sc_chip.vga_cntrl, r & ~VGA_CNTRL_DISABLE); /* enable VGA machinery */ b = co->read_vga(cd, 0x01); co->write_vga(cd, 0x01, b & ~0x20); /* restore VGA memory */ memcpy(sc->sc_fbaddr, sc->sc_vga_save, 256*1024); /* enable pipe again */ co->write_reg(cd, PIPE_CONF(pipe), PIPE_CONF_ENABLE | PIPE_CONF_6BPP | PIPE_CONF_DITHER); } } static void igmafb_planestart_quirk(struct igmafb_softc *sc) { const struct igma_chip *cd = &sc->sc_chip; const struct igma_chip_ops *co = cd->ops; int pipe = cd->use_pipe; u_int32_t cntrl, fwbcl; /* disable self refresh */ fwbcl = co->read_reg(cd, FW_BLC_SELF); co->write_reg(cd, FW_BLC_SELF, fwbcl & ~FW_BLC_SELF_EN); cntrl = co->read_reg(cd, CUR_CNTR(pipe)); co->write_reg(cd, CUR_CNTR(pipe), 1<<5 | 0x07); /* "wait for vblank" */ delay(40000); co->write_reg(cd, CUR_CNTR(pipe), cntrl); co->write_reg(cd, CUR_BASE(pipe), co->read_reg(cd, CUR_BASE(pipe))); co->write_reg(cd, FW_BLC_SELF, fwbcl); } static void igmafb_pfitdisable_quirk(struct igmafb_softc *sc) { const struct igma_chip *cd = &sc->sc_chip; const struct igma_chip_ops *co = cd->ops; u_int32_t r; /* disable i965 panel fitter */ r = co->read_reg(cd, PF_CTRL_I965); co->write_reg(cd, PF_CTRL_I965, r & ~PF_ENABLE); } static void igmafb_get_brightness_max(struct igmafb_softc *sc, int *valp) { const struct igma_chip *cd = &sc->sc_chip; const struct igma_chip_ops *co = cd->ops; u_int32_t r, f; r = co->read_reg(cd, cd->backlight_cntrl); f = BACKLIGHT_GET_FREQ(r); if (f == 0) { r = co->read_reg(cd, RAWCLK_FREQ); f = r * 1000000 / (200 * 128); if (f == 0 || f > 32767) f = 125 * 100000 / (200 * 128); } *valp = f; } static void igmafb_get_brightness(struct igmafb_softc *sc, int *valp) { const struct igma_chip *cd = &sc->sc_chip; const struct igma_chip_ops *co = cd->ops; u_int32_t r, v; r = co->read_reg(cd, cd->backlight_cntrl); v = BACKLIGHT_GET_CYCLE(r); *valp = v; } static void igmafb_set_brightness(struct igmafb_softc *sc, int val) { const struct igma_chip *cd = &sc->sc_chip; const struct igma_chip_ops *co = cd->ops; u_int32_t r, f, l; r = co->read_reg(cd, cd->backlight_cntrl); f = BACKLIGHT_GET_FREQ(r); l = BACKLIGHT_GET_LEGACY(r); co->write_reg(cd, cd->backlight_cntrl, BACKLIGHT_VAL(f,l,val)); }
void bwtwoattach(struct bwtwo_softc *sc, const char *name, int isconsole) { struct fbdevice *fb = &sc->sc_fb; int isoverlay; #if NWSDISPLAY > 0 struct wsemuldisplaydev_attach_args aa; struct rasops_info *ri = &bw2_console_screen.scr_ri; unsigned long defattr = 0; #endif /* Fill in the remaining fbdevice values */ fb->fb_driver = &bwtwofbdriver; fb->fb_device = sc->sc_dev; fb->fb_type.fb_type = FBTYPE_SUN2BW; fb->fb_type.fb_cmsize = 0; fb->fb_type.fb_size = fb->fb_type.fb_height * fb->fb_linebytes; printf(": %s, %d x %d", name, fb->fb_type.fb_width, fb->fb_type.fb_height); /* Are we an overlay bw2? */ if ((fb->fb_flags & FB_PFOUR) == 0 || (sc->sc_ovtype == BWO_NONE)) isoverlay = 0; else isoverlay = 1; /* Insure video is enabled */ sc->sc_set_video(sc, 1); if (isconsole) { printf(" (console)\n"); #ifdef RASTERCONSOLE /* * XXX rcons doesn't seem to work properly on the overlay * XXX plane. This is a temporary kludge until someone * XXX fixes it. */ if (!isoverlay) fbrcons_init(fb); #endif } else printf("\n"); if (isoverlay) { const char *ovnam; switch (sc->sc_ovtype) { case BWO_CGFOUR: ovnam = "cgfour"; break; case BWO_CGEIGHT: ovnam = "cgeight"; break; default: ovnam = "unknown"; break; } printf("%s: %s overlay plane\n", device_xname(sc->sc_dev), ovnam); } /* * If we're on an overlay plane of a color framebuffer, * then we don't force the issue in fb_attach() because * we'd like the color framebuffer to actually be the * "console framebuffer". We're only around to speed * up rconsole. */ if (isoverlay) fb_attach(fb, 0); else fb_attach(fb, isconsole); #if NWSDISPLAY > 0 sc->sc_width = fb->fb_type.fb_width; sc->sc_stride = fb->fb_type.fb_width/8; sc->sc_height = fb->fb_type.fb_height; /* setup rasops and so on for wsdisplay */ sc->sc_mode = WSDISPLAYIO_MODE_EMUL; vcons_init(&sc->vd, sc, &bwtwo_defaultscreen, &bwtwo_accessops); sc->vd.init_screen = bwtwo_init_screen; if(isconsole && !isoverlay) { /* we mess with bw2_console_screen only once */ vcons_init_screen(&sc->vd, &bw2_console_screen, 1, &defattr); bw2_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC; bwtwo_defaultscreen.textops = &ri->ri_ops; bwtwo_defaultscreen.capabilities = ri->ri_caps; bwtwo_defaultscreen.nrows = ri->ri_rows; bwtwo_defaultscreen.ncols = ri->ri_cols; sc->vd.active = &bw2_console_screen; wsdisplay_cnattach(&bwtwo_defaultscreen, ri, 0, 0, defattr); } else { /* * we're not the console so we just clear the screen and don't * set up any sort of text display */ if (bwtwo_defaultscreen.textops == NULL) { /* * ugly, but... * we want the console settings to win, so we only * touch anything when we find an untouched screen * definition. In this case we fill it from fb to * avoid problems in case no bwtwo is the console */ bwtwo_defaultscreen.textops = &ri->ri_ops; bwtwo_defaultscreen.capabilities = ri->ri_caps; bwtwo_defaultscreen.nrows = ri->ri_rows; bwtwo_defaultscreen.ncols = ri->ri_cols; } } aa.scrdata = &bwtwo_screenlist; if (isoverlay) aa.console = 0; else aa.console = isconsole; aa.accessops = &bwtwo_accessops; aa.accesscookie = &sc->vd; config_found(sc->sc_dev, &aa, wsemuldisplaydevprint); #endif }
static void zx_attach(device_t parent, device_t self, void *args) { struct zx_softc *sc; struct sbus_attach_args *sa; bus_space_handle_t bh; bus_space_tag_t bt; struct fbdevice *fb; #if NWSDISPLAY > 0 struct wsemuldisplaydev_attach_args aa; struct rasops_info *ri = &zx_console_screen.scr_ri; unsigned long defattr; #endif int isconsole, width, height; sc = device_private(self); sc->sc_dv = self; sa = args; fb = &sc->sc_fb; bt = sa->sa_bustag; sc->sc_bt = bt; sc->sc_paddr = sbus_bus_addr(bt, sa->sa_slot, sa->sa_offset); if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_SS0, 0x800000, BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_LARGE, &bh) != 0) { aprint_error_dev(self, "can't map bits\n"); return; } fb->fb_pixels = (void *)bus_space_vaddr(bt, bh); sc->sc_pixels = (uint32_t *)fb->fb_pixels; if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LC_SS0_USR, PAGE_SIZE, BUS_SPACE_MAP_LINEAR, &bh) != 0) { aprint_error_dev(self, "can't map zc\n"); return; } sc->sc_bhzc = bh; if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LD_SS0, PAGE_SIZE, BUS_SPACE_MAP_LINEAR, &bh) != 0) { aprint_error_dev(self, "can't map ld/ss0\n"); return; } sc->sc_bhzdss0 = bh; if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LD_SS1, PAGE_SIZE, BUS_SPACE_MAP_LINEAR, &bh) != 0) { aprint_error_dev(self, "can't map ld/ss1\n"); return; } sc->sc_bhzdss1 = bh; if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LX_CROSS, PAGE_SIZE, BUS_SPACE_MAP_LINEAR, &bh) != 0) { aprint_error_dev(self, "can't map zx\n"); return; } sc->sc_bhzx = bh; if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LX_CURSOR, PAGE_SIZE, BUS_SPACE_MAP_LINEAR, &bh) != 0) { aprint_error_dev(self, "can't map zcu\n"); return; } sc->sc_bhzcu = bh; fb->fb_driver = &zx_fbdriver; fb->fb_device = sc->sc_dv; fb->fb_flags = device_cfdata(sc->sc_dv)->cf_flags & FB_USERMASK; fb->fb_pfour = NULL; fb->fb_linebytes = prom_getpropint(sa->sa_node, "linebytes", 8192); width = prom_getpropint(sa->sa_node, "width", 1280); height = prom_getpropint(sa->sa_node, "height", 1024); fb_setsize_obp(fb, 32, width, height, sa->sa_node); fb->fb_type.fb_cmsize = 256; fb->fb_type.fb_depth = 32; fb->fb_type.fb_size = fb->fb_type.fb_height * fb->fb_linebytes; fb->fb_type.fb_type = FBTYPE_SUNLEO; printf(": %d x %d", fb->fb_type.fb_width, fb->fb_type.fb_height); isconsole = fb_is_console(sa->sa_node); if (isconsole) printf(" (console)"); printf("\n"); if (sa->sa_nintr != 0) bus_intr_establish(bt, sa->sa_pri, IPL_NONE, zx_intr, sc); sc->sc_cmap = malloc(768, M_DEVBUF, M_NOWAIT); zx_reset(sc); #if NWSDISPLAY > 0 sc->sc_width = fb->fb_type.fb_width; sc->sc_stride = 8192; /* 32 bit */ sc->sc_height = fb->fb_type.fb_height; /* setup rasops and so on for wsdisplay */ wsfont_init(); sc->sc_mode = WSDISPLAYIO_MODE_EMUL; sc->sc_bg = WS_DEFAULT_BG; vcons_init(&sc->vd, sc, &zx_defaultscreen, &zx_accessops); sc->vd.init_screen = zx_init_screen; if (isconsole) { /* we mess with zx_console_screen only once */ vcons_init_screen(&sc->vd, &zx_console_screen, 1, &defattr); zx_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC; zx_defaultscreen.textops = &ri->ri_ops; zx_defaultscreen.capabilities = WSSCREEN_WSCOLORS; zx_defaultscreen.nrows = ri->ri_rows; zx_defaultscreen.ncols = ri->ri_cols; zx_fillrect(sc, 0, 0, width, height, ri->ri_devcmap[defattr >> 16], ZX_STD_ROP); wsdisplay_cnattach(&zx_defaultscreen, ri, 0, 0, defattr); vcons_replay_msgbuf(&zx_console_screen); } else { /* * we're not the console so we just clear the screen and don't * set up any sort of text display */ if (zx_defaultscreen.textops == NULL) {
void cgthreeattach(struct cgthree_softc *sc, const char *name, int isconsole) { int i; struct fbdevice *fb = &sc->sc_fb; struct wsemuldisplaydev_attach_args aa; struct rasops_info *ri = &cg3_console_screen.scr_ri; unsigned long defattr; volatile struct fbcontrol *fbc = sc->sc_fbc; volatile struct bt_regs *bt = &fbc->fbc_dac; fb->fb_driver = &cgthreefbdriver; fb->fb_type.fb_cmsize = 256; fb->fb_type.fb_size = fb->fb_type.fb_height * fb->fb_linebytes; printf(": %s, %d x %d", name, fb->fb_type.fb_width, fb->fb_type.fb_height); /* Transfer video magic to board, if it's not running */ if ((fbc->fbc_ctrl & FBC_TIMING) == 0) { int sense = (fbc->fbc_status & FBS_MSENSE); /* Search table for video timings fitting this monitor */ for (i = 0; i < sizeof(cg3_videoctrl)/sizeof(cg3_videoctrl[0]); i++) { int j; if (sense != cg3_videoctrl[i].sense) continue; printf(" setting video ctrl"); for (j = 0; j < 12; j++) fbc->fbc_vcontrol[j] = cg3_videoctrl[i].vctrl[j]; fbc->fbc_ctrl |= FBC_TIMING; break; } } /* make sure we are not blanked */ cgthree_set_video(sc, 1); BT_INIT(bt, 0); if (isconsole) { printf(" (console)\n"); } else printf("\n"); fb_attach(fb, isconsole); sc->sc_width = fb->fb_type.fb_width; sc->sc_stride = fb->fb_type.fb_width; sc->sc_height = fb->fb_type.fb_height; /* setup rasops and so on for wsdisplay */ sc->sc_mode = WSDISPLAYIO_MODE_EMUL; vcons_init(&sc->vd, sc, &cgthree_defaultscreen, &cgthree_accessops); sc->vd.init_screen = cgthree_init_screen; if(isconsole) { /* we mess with cg3_console_screen only once */ vcons_init_screen(&sc->vd, &cg3_console_screen, 1, &defattr); memset(sc->sc_fb.fb_pixels, (defattr >> 16) & 0xff, sc->sc_stride * sc->sc_height); cg3_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC; cgthree_defaultscreen.textops = &ri->ri_ops; cgthree_defaultscreen.capabilities = ri->ri_caps; cgthree_defaultscreen.nrows = ri->ri_rows; cgthree_defaultscreen.ncols = ri->ri_cols; sc->vd.active = &cg3_console_screen; wsdisplay_cnattach(&cgthree_defaultscreen, ri, 0, 0, defattr); vcons_replay_msgbuf(&cg3_console_screen); } else { /* * we're not the console so we just clear the screen and don't * set up any sort of text display */ }