void
bwtwo_init_screen(void *cookie, struct vcons_screen *scr,
int existing, long *defattr)
{
struct bwtwo_softc *sc = cookie;
struct rasops_info *ri = &scr->scr_ri;
char *bits;
ri->ri_depth = 1;
ri->ri_width = sc->sc_width;
ri->ri_height = sc->sc_height;
ri->ri_stride = sc->sc_stride;
ri->ri_flg = RI_CENTER;
ri->ri_bits = sc->sc_fb.fb_pixels;
/*
* Make sure that we set a maximum of 32 bits at a time,
* otherwise we'll see VME write errors if this is a P4 BW2.
*/
for (bits = (char *) ri->ri_bits;
bits < (char *) ri->ri_bits + ri->ri_stride * ri->ri_height;
bits += 4)
memset(bits, (*defattr >> 16) & 0xff, 4);
rasops_init(ri, 0, 0);
ri->ri_caps = 0;
rasops_reconfig(ri, sc->sc_height / ri->ri_font->fontheight,
sc->sc_width / ri->ri_font->fontwidth);
ri->ri_hw = scr;
}
static void
cg14_init_screen(void *cookie, struct vcons_screen *scr,
int existing, long *defattr)
{
struct cgfourteen_softc *sc = cookie;
struct rasops_info *ri = &scr->scr_ri;
ri->ri_depth = 8;
ri->ri_width = sc->sc_fb.fb_type.fb_width;
ri->ri_height = sc->sc_fb.fb_type.fb_height;
ri->ri_stride = ri->ri_width;
ri->ri_flg = RI_CENTER | RI_FULLCLEAR;
ri->ri_bits = (char *)sc->sc_fb.fb_pixels;
if (existing) {
ri->ri_flg |= RI_CLEAR;
}
rasops_init(ri, sc->sc_fb.fb_type.fb_height / 8,
sc->sc_fb.fb_type.fb_width / 8);
ri->ri_caps = WSSCREEN_WSCOLORS;
rasops_reconfig(ri,
sc->sc_fb.fb_type.fb_height / ri->ri_font->fontheight,
sc->sc_fb.fb_type.fb_width / ri->ri_font->fontwidth);
ri->ri_hw = scr;
}
int
xafb_common_init(struct xafb_devconfig *dc)
{
struct rasops_info *ri = &dc->dc_ri;
int i;
for (i = 0; i < 256; i++)
xafb_setcolor(dc, i, i, i, i);
/* initialize rasops */
ri->ri_width = 1280;
ri->ri_height = 1024;
ri->ri_depth = 8;
ri->ri_stride = 2048;
ri->ri_bits = (void *)dc->dc_fbbase;
ri->ri_flg = RI_FORCEMONO | RI_FULLCLEAR;
if (dc == &xafb_console_dc)
ri->ri_flg |= RI_NO_AUTO;
rasops_init(ri, 44, 100);
/* mono */
ri->ri_devcmap[0] = 0; /* bg */
ri->ri_devcmap[1] = 0xffffffff; /* fg */
xafb_stdscreen.nrows = ri->ri_rows;
xafb_stdscreen.ncols = ri->ri_cols;
xafb_stdscreen.textops = &ri->ri_ops;
xafb_stdscreen.capabilities = ri->ri_caps;
return 0;
}
static void
newport_init_screen(void *cookie, struct vcons_screen *scr,
int existing, long *defattr)
{
struct newport_devconfig *dc = cookie;
struct rasops_info *ri = &scr->scr_ri;
ri->ri_depth = dc->dc_depth;
ri->ri_width = dc->dc_xres;
ri->ri_height = dc->dc_yres;
ri->ri_stride = dc->dc_xres; /* XXX */
ri->ri_flg = RI_CENTER;
/*&ri->ri_bits = (char *)sc->sc_fb.fb_pixels;*/
rasops_init(ri, 0, 0);
ri->ri_caps = WSSCREEN_WSCOLORS;
rasops_reconfig(ri, dc->dc_yres / ri->ri_font->fontheight,
dc->dc_xres / ri->ri_font->fontwidth);
ri->ri_hw = scr;
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;
ri->ri_ops.mapchar = newport_mapchar;
ri->ri_ops.putchar = newport_putchar;
ri->ri_ops.allocattr = newport_allocattr;
}
void
fbwscons_init(struct sunfb *sf, int flags)
{
struct rasops_info *ri = &sf->sf_ro;
int cols, rows;
/* ri_hw and ri_bits must have already been setup by caller */
ri->ri_flg = RI_CENTER | RI_FULLCLEAR | flags;
ri->ri_depth = sf->sf_depth;
ri->ri_stride = sf->sf_linebytes;
ri->ri_width = sf->sf_width;
ri->ri_height = sf->sf_height;
rows = a2int(getpropstring(optionsnode, "screen-#rows"), 34);
cols = a2int(getpropstring(optionsnode, "screen-#columns"), 80);
rasops_init(ri, rows, cols);
if (sf->sf_depth == 8) {
/*
* If we are running with an indexed palette, compensate
* the swap of black and white through ri_devcmap.
*/
ri->ri_devcmap[WSCOL_SUN_BLACK] = 0;
ri->ri_devcmap[WSCOL_SUN_WHITE] = 0xffffffff;
} else if (sf->sf_depth > 8) {
/*
* If we are running on a direct color frame buffer,
* make the ``normal'' white the same as the highlighted
* white.
*/
ri->ri_devcmap[WSCOL_WHITE] = ri->ri_devcmap[WSCOL_WHITE + 8];
}
}
void
fbwscons_init(struct sunfb *sf, int flags)
{
struct rasops_info *ri = &sf->sf_ro;
int cols, rows;
/* ri_hw and ri_bits must have already been setup by caller */
ri->ri_flg = RI_CENTER | RI_FULLCLEAR | flags;
ri->ri_depth = sf->sf_depth;
ri->ri_stride = sf->sf_linebytes;
ri->ri_width = sf->sf_width;
ri->ri_height = sf->sf_height;
#if defined(SUN4C) || defined(SUN4M)
if (CPU_ISSUN4COR4M) {
rows = a2int(getpropstring(optionsnode, "screen-#rows"), 34);
cols = a2int(getpropstring(optionsnode, "screen-#columns"), 80);
}
#endif
#if defined(SUN4)
if (CPU_ISSUN4) {
struct eeprom *ep = (struct eeprom *)eeprom_va;
if (ep != NULL) {
rows = (u_short)ep->eeTtyRows;
cols = (u_short)ep->eeTtyCols;
/* deal with broken nvram contents... */
if (rows <= 0)
rows = 34;
if (cols <= 0)
cols = 80;
} else {
rows = 34;
cols = 80;
}
}
#endif
rasops_init(ri, rows, cols);
if (sf->sf_depth == 8) {
/*
* If we are running with an indexed palette, compensate
* the swap of black and white through ri_devcmap.
*/
ri->ri_devcmap[WSCOL_SUN_BLACK] = 0;
ri->ri_devcmap[WSCOL_SUN_WHITE] = 0xffffffff;
} else if (sf->sf_depth > 8) {
/*
* If we are running on a direct color frame buffer,
* make the ``normal'' white the same as the hilighted
* white.
*/
ri->ri_devcmap[WSCOL_WHITE] = ri->ri_devcmap[WSCOL_WHITE + 8];
}
}
int
gdium_cnattach(bus_space_tag_t memt, bus_space_tag_t iot,
pci_chipset_tag_t pc, pcitag_t tag, pcireg_t id)
{
struct rasops_info * const ri = &gdium_console_screen.scr_ri;
long defattr;
pcireg_t reg;
/* filter out unrecognized devices */
switch (id) {
default:
return ENODEV;
case PCI_ID_CODE(PCI_VENDOR_SILMOTION, PCI_PRODUCT_SILMOTION_SM502):
break;
}
wsfont_init();
/* set up rasops */
ri->ri_width = 1024;
ri->ri_height = 600;
ri->ri_depth = 16;
ri->ri_stride = 0x800;
/* read the mapping register for the frame buffer */
reg = pci_conf_read(pc, tag, PCI_MAPREG_START);
fb_addr = reg;
ri->ri_bits = (char *)MIPS_PHYS_TO_KSEG1(BONITO_PCILO_BASE + reg);
ri->ri_flg = RI_CENTER | RI_NO_AUTO;
memset(ri->ri_bits, 0, 0x200000);
/* use as much of the screen as the font permits */
rasops_init(ri, 30, 80);
rasops_reconfig(ri, ri->ri_height / ri->ri_font->fontheight,
ri->ri_width / ri->ri_font->fontwidth);
gdium_stdscreen.nrows = ri->ri_rows;
gdium_stdscreen.ncols = ri->ri_cols;
gdium_stdscreen.textops = &ri->ri_ops;
gdium_stdscreen.capabilities = ri->ri_caps;
ri->ri_ops.allocattr(ri, 0, ri->ri_rows - 1, 0, &defattr);
wsdisplay_preattach(&gdium_stdscreen, ri, 0, 0, defattr);
return 0;
}
int
impact_init_screen(struct impact_screen *scr)
{
struct rasops_info *ri = &scr->ri;
size_t bssize;
bzero(ri, sizeof(struct rasops_info));
ri->ri_flg = RI_CENTER | RI_FULLCLEAR;
ri->ri_depth = IMPACT_DEPTH;
ri->ri_width = IMPACT_WIDTH;
ri->ri_height = IMPACT_HEIGHT;
ri->ri_stride = IMPACT_WIDTH * IMPACT_DEPTH / 8;
rasops_init(ri, 160, 160);
/*
* Allocate backing store to remember character cells, to
* be able to fulfill scrolling requests.
*/
if (scr->bs == NULL) {
bssize = ri->ri_rows * ri->ri_cols *
sizeof(struct wsdisplay_charcell);
scr->bs = malloc(bssize, M_DEVBUF, M_NOWAIT | M_ZERO);
if (scr->bs == NULL)
return ENOMEM;
}
ri->ri_hw = scr;
ri->ri_ops.putchar = impact_putchar;
ri->ri_do_cursor = impact_do_cursor;
ri->ri_ops.copyrows = impact_copyrows;
ri->ri_ops.copycols = impact_copycols;
ri->ri_ops.eraserows = impact_eraserows;
ri->ri_ops.erasecols = impact_erasecols;
/* clear display */
impact_fillrect(scr, 0, 0, ri->ri_width, ri->ri_height,
ri->ri_devcmap[WSCOL_BLACK]);
strlcpy(scr->wsd.name, "std", sizeof(scr->wsd.name));
scr->wsd.ncols = ri->ri_cols;
scr->wsd.nrows = ri->ri_rows;
scr->wsd.textops = &ri->ri_ops;
scr->wsd.fontwidth = ri->ri_font->fontwidth;
scr->wsd.fontheight = ri->ri_font->fontheight;
scr->wsd.capabilities = ri->ri_caps;
return 0;
}
static void
mfb_common_init(struct rasops_info *ri)
{
char *base;
int cookie;
base = (void *)ri->ri_hw;
/* initialize colormap and cursor hardware */
mfbhwinit(base);
ri->ri_flg = RI_CENTER | RI_FORCEMONO;
if (ri == &mfb_console_ri)
ri->ri_flg |= RI_NO_AUTO;
ri->ri_depth = 8; /* !! watch out !! */
ri->ri_width = 1280;
ri->ri_height = 1024;
ri->ri_stride = 2048;
ri->ri_bits = base + MX_FB_OFFSET;
/* clear the screen */
memset(ri->ri_bits, 0, ri->ri_stride * ri->ri_height);
wsfont_init();
/* prefer 12 pixel wide font */
cookie = wsfont_find(NULL, 12, 0, 0, WSDISPLAY_FONTORDER_L2R,
WSDISPLAY_FONTORDER_L2R, WSFONT_FIND_BITMAP);
if (cookie <= 0)
cookie = wsfont_find(NULL, 0, 0, 0, WSDISPLAY_FONTORDER_L2R,
WSDISPLAY_FONTORDER_L2R, WSFONT_FIND_BITMAP);
if (cookie <= 0) {
printf("mfb: font table is empty\n");
return;
}
if (wsfont_lock(cookie, &ri->ri_font)) {
printf("mfb: couldn't lock font\n");
return;
}
ri->ri_wsfcookie = cookie;
rasops_init(ri, 34, 80);
/* XXX shouldn't be global */
mfb_stdscreen.nrows = ri->ri_rows;
mfb_stdscreen.ncols = ri->ri_cols;
mfb_stdscreen.textops = &ri->ri_ops;
mfb_stdscreen.capabilities = ri->ri_caps;
}
static void
vidcvideoinit_screen(void *cookie, struct vcons_screen *scr,
int existing, long *defattr)
{
struct rasops_info *ri = &scr->scr_ri;
struct fb_devconfig *dc = cookie;
if ((scr == &dc->dc_console) && (dc->dc_vd.active != NULL))
return;
ri->ri_flg = RI_NO_AUTO; /* RI_CENTER | RI_FULLCLEAR; */
ri->ri_depth = dc->dc_depth;
ri->ri_bits = (void *) dc->dc_videobase;
ri->ri_width = dc->dc_width;
ri->ri_height = dc->dc_height;
ri->ri_stride = dc->dc_rowbytes;
ri->ri_hw = &dc->dc_console; /* link back */
rasops_init(ri,
ri->ri_height / 8,
ri->ri_width / 8);
ri->ri_caps = WSSCREEN_WSCOLORS;
rasops_reconfig(ri,
ri->ri_height / ri->ri_font->fontheight,
ri->ri_width / ri->ri_font->fontwidth);
/*
* Provide a hook for the acceleration functions and make a copy of the
* original rasops functions for passing on calls
*/
memcpy(&(dc->orig_ri_ops), &(ri->ri_ops),
sizeof(struct wsdisplay_emulops));
/* add our accelerated functions */
ri->ri_ops.eraserows = vv_eraserows;
ri->ri_ops.copyrows = vv_copyrows;
/* add the extra activity measuring functions; they just delegate on */
ri->ri_ops.putchar = vv_putchar;
vidcvideo_stdscreen.nrows = ri->ri_rows;
vidcvideo_stdscreen.ncols = ri->ri_cols;
vidcvideo_stdscreen.textops = &ri->ri_ops;
vidcvideo_stdscreen.capabilities = ri->ri_caps;
}
int
legss_setup_screen(struct legss_screen *ss)
{
struct rasops_info *ri = &ss->ss_ri;
bzero(ri, sizeof(*ri));
ri->ri_depth = 32; /* masquerade as a 32 bit device for rasops */
ri->ri_width = LEGSS_VISWIDTH;
ri->ri_height = LEGSS_VISHEIGHT;
ri->ri_stride = LEGSS_WIDTH * 32 / NBBY;
ri->ri_flg = RI_FORCEMONO | RI_CENTER; /* no RI_CLEAR ! */
ri->ri_hw = ss;
ri->ri_bits = (u_char *)ss->ss_vram;
/*
* Ask for an unholy big display, rasops will trim this to more
* reasonable values.
*/
if (rasops_init(ri, 160, 160) != 0)
return -1;
/*
* Override the rasops emulops.
*/
ri->ri_ops.copyrows = legss_copyrows;
ri->ri_ops.copycols = legss_copycols;
ri->ri_ops.eraserows = legss_eraserows;
ri->ri_ops.erasecols = legss_erasecols;
ri->ri_ops.putchar = legss_putchar;
ri->ri_do_cursor = legss_do_cursor;
legss_stdscreen.ncols = ri->ri_cols;
legss_stdscreen.nrows = ri->ri_rows;
legss_stdscreen.textops = &ri->ri_ops;
legss_stdscreen.fontwidth = ri->ri_font->fontwidth;
legss_stdscreen.fontheight = ri->ri_font->fontheight;
legss_stdscreen.capabilities = ri->ri_caps;
/*
* Clear display.
*/
legss_clear_screen(ss);
return 0;
}
int
smfb_setup(struct smfb *fb, bus_space_tag_t memt, bus_space_handle_t memh,
bus_space_tag_t mmiot, bus_space_handle_t mmioh)
{
struct rasops_info *ri;
int accel = 0;
int rc;
ri = &fb->ri;
ri->ri_width = 1024;
ri->ri_height = 600;
ri->ri_depth = 16;
ri->ri_stride = (ri->ri_width * ri->ri_depth) / 8;
ri->ri_flg = RI_CENTER | RI_CLEAR | RI_FULLCLEAR;
ri->ri_bits = (void *)bus_space_vaddr(memt, memh);
ri->ri_hw = fb;
#ifdef __MIPSEL__
/* swap B and R */
ri->ri_rnum = 5;
ri->ri_rpos = 11;
ri->ri_gnum = 6;
ri->ri_gpos = 5;
ri->ri_bnum = 5;
ri->ri_bpos = 0;
#endif
rasops_init(ri, 160, 160);
strlcpy(fb->wsd.name, "std", sizeof(fb->wsd.name));
fb->wsd.ncols = ri->ri_cols;
fb->wsd.nrows = ri->ri_rows;
fb->wsd.textops = &ri->ri_ops;
fb->wsd.fontwidth = ri->ri_font->fontwidth;
fb->wsd.fontheight = ri->ri_font->fontheight;
fb->wsd.capabilities = ri->ri_caps;
if (fb->is5xx) {
fb->dcrt = mmiot;
if ((rc = bus_space_subregion(mmiot, mmioh, SM5XX_DCR_BASE,
SM5XX_DCR_SIZE, &fb->dcrh)) != 0)
return rc;
fb->dprt = mmiot;
if ((rc = bus_space_subregion(mmiot, mmioh, SM5XX_DPR_BASE,
SMXXX_DPR_SIZE, &fb->dprh)) != 0)
return rc;
fb->mmiot = mmiot;
if ((rc = bus_space_subregion(mmiot, mmioh, SM5XX_MMIO_BASE,
SM5XX_MMIO_SIZE, &fb->mmioh)) != 0)
return rc;
accel = 1;
} else {
fb->dprt = memt;
if ((rc = bus_space_subregion(memt, memh, SM7XX_DPR_BASE,
SMXXX_DPR_SIZE, &fb->dprh)) != 0)
return rc;
fb->mmiot = memt;
if ((rc = bus_space_subregion(memt, memh, SM7XX_MMIO_BASE,
SM7XX_MMIO_SIZE, &fb->mmioh)) != 0)
return rc;
accel = 1;
}
/*
* Setup 2D acceleration whenever possible
*/
if (accel) {
if (smfb_wait(fb) != 0)
accel = 0;
}
if (accel) {
DPR_WRITE(fb, DPR_CROP_TOPLEFT_COORDS, DPR_COORDS(0, 0));
/* use of width both times is intentional */
DPR_WRITE(fb, DPR_PITCH,
DPR_COORDS(ri->ri_width, ri->ri_width));
DPR_WRITE(fb, DPR_SRC_WINDOW,
DPR_COORDS(ri->ri_width, ri->ri_width));
DPR_WRITE(fb, DPR_BYTE_BIT_MASK, 0xffffffff);
DPR_WRITE(fb, DPR_COLOR_COMPARE_MASK, 0);
DPR_WRITE(fb, DPR_COLOR_COMPARE, 0);
DPR_WRITE(fb, DPR_SRC_BASE, 0);
DPR_WRITE(fb, DPR_DST_BASE, 0);
DPR_READ(fb, DPR_DST_BASE);
ri->ri_ops.copycols = smfb_copycols;
ri->ri_ops.copyrows = smfb_copyrows;
ri->ri_ops.erasecols = smfb_erasecols;
ri->ri_ops.eraserows = smfb_eraserows;
}
return 0;
}
int
hpcfb_init(struct hpcfb_fbconf *fbconf, struct hpcfb_devconfig *dc)
{
struct rasops_info *ri;
vaddr_t fbaddr;
fbaddr = (vaddr_t)fbconf->hf_baseaddr;
dc->dc_fbaddr = (u_char *)fbaddr;
/* init rasops */
ri = &dc->dc_rinfo;
memset(ri, 0, sizeof(struct rasops_info));
ri->ri_depth = fbconf->hf_pixel_width;
ri->ri_bits = (caddr_t)fbaddr;
ri->ri_width = fbconf->hf_width;
ri->ri_height = fbconf->hf_height;
ri->ri_stride = fbconf->hf_bytes_per_line;
#if 0
ri->ri_flg = RI_FORCEMONO | RI_CURSOR;
#else
ri->ri_flg = RI_CURSOR;
#endif
switch (ri->ri_depth) {
case 8:
if (32 <= fbconf->hf_pack_width &&
(fbconf->hf_order_flags & HPCFB_REVORDER_BYTE) &&
(fbconf->hf_order_flags & HPCFB_REVORDER_WORD)) {
ri->ri_flg |= RI_BSWAP;
}
break;
default:
if (fbconf->hf_order_flags & HPCFB_REVORDER_BYTE) {
#if BYTE_ORDER == BIG_ENDIAN
ri->ri_flg |= RI_BSWAP;
#endif
} else {
#if BYTE_ORDER == LITTLE_ENDIAN
ri->ri_flg |= RI_BSWAP;
#endif
}
break;
}
if (rasops_init(ri, HPCFB_MAX_ROW, HPCFB_MAX_COLUMN)) {
panic("%s(%d): rasops_init() failed!", __FILE__, __LINE__);
}
/* over write color map of rasops */
hpcfb_cmap_reorder (fbconf, dc);
dc->dc_curx = -1;
dc->dc_cury = -1;
dc->dc_rows = dc->dc_rinfo.ri_rows;
dc->dc_cols = dc->dc_rinfo.ri_cols;
#ifdef HPCFB_JUMP
dc->dc_max_row = 0;
dc->dc_min_row = dc->dc_rows;
dc->dc_scroll = 0;
callout_init(&dc->dc_scroll_ch);
#endif /* HPCFB_JUMP */
dc->dc_memsize = ri->ri_stride * ri->ri_height;
/* hook rasops in hpcfb_ops */
rasops_emul = ri->ri_ops; /* struct copy */
ri->ri_ops = hpcfb_emulops; /* struct copy */
return (0);
}
int
cfxga_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep,
int *curxp, int *curyp, long *attrp)
{
struct cfxga_softc *sc = v;
struct cfxga_screen *scr;
struct rasops_info *ri;
u_int mode, width, height, depth, scrsize;
scr = malloc(sizeof *scr, M_DEVBUF, cold ? M_NOWAIT : M_WAITOK);
if (scr == NULL)
return (ENOMEM);
bzero(scr, sizeof *scr);
mode = type - sc->sc_wsd;
#ifdef DIAGNOSTIC
if (mode >= CFXGA_NMODES)
mode = CFXGA_MODE_640x480x16;
#endif
switch (mode) {
default:
case CFXGA_MODE_640x480x16:
width = 640;
height = 480;
depth = 16;
break;
case CFXGA_MODE_800x600x16:
width = 800;
height = 600;
depth = 16;
break;
#ifdef ENABLE_8BIT_MODES
case CFXGA_MODE_640x480x8:
width = 640;
height = 480;
depth = 8;
break;
case CFXGA_MODE_800x600x8:
width = 800;
height = 600;
depth = 8;
break;
#endif
}
ri = &scr->scr_ri;
ri->ri_hw = (void *)scr;
ri->ri_bits = NULL;
ri->ri_depth = depth;
ri->ri_width = width;
ri->ri_height = height;
ri->ri_stride = width * depth / 8;
ri->ri_flg = 0;
/* swap B and R at 16 bpp */
if (depth == 16) {
ri->ri_rnum = 5;
ri->ri_rpos = 11;
ri->ri_gnum = 6;
ri->ri_gpos = 5;
ri->ri_bnum = 5;
ri->ri_bpos = 0;
}
if (type->nrows == 0) /* first screen creation */
rasops_init(ri, 100, 100);
else
rasops_init(ri, type->nrows, type->ncols);
/*
* Allocate backing store to remember non-visible screen contents in
* emulation mode.
*/
scrsize = ri->ri_rows * ri->ri_cols * sizeof(struct wsdisplay_charcell);
scr->scr_mem = malloc(scrsize, M_DEVBUF, cold ? M_NOWAIT : M_WAITOK);
if (scr->scr_mem == NULL) {
free(scr, M_DEVBUF);
return (ENOMEM);
}
bzero(scr->scr_mem, scrsize);
ri->ri_ops.copycols = cfxga_copycols;
ri->ri_ops.copyrows = cfxga_copyrows;
ri->ri_ops.erasecols = cfxga_erasecols;
ri->ri_ops.eraserows = cfxga_eraserows;
ri->ri_ops.putchar = cfxga_putchar;
ri->ri_do_cursor = cfxga_do_cursor;
/*
* Finish initializing our screen descriptions, now that we know
* the actual console emulation parameters.
*/
if (type->nrows == 0) {
struct wsscreen_descr *wsd = (struct wsscreen_descr *)type;
wsd->nrows = ri->ri_rows;
wsd->ncols = ri->ri_cols;
bcopy(&ri->ri_ops, &sc->sc_ops, sizeof(sc->sc_ops));
wsd->fontwidth = ri->ri_font->fontwidth;
wsd->fontheight = ri->ri_font->fontheight;
wsd->capabilities = ri->ri_caps;
}
scr->scr_sc = sc;
LIST_INSERT_HEAD(&sc->sc_scr, scr, scr_link);
sc->sc_nscreens++;
ri->ri_ops.alloc_attr(ri, 0, 0, 0, attrp);
*cookiep = ri;
*curxp = *curyp = 0;
return (0);
}
int
smfb_setup(struct smfb *fb, vaddr_t fbbase)
{
struct rasops_info *ri;
ri = &fb->ri;
ri->ri_width = 1024;
ri->ri_height = 600;
ri->ri_depth = 16;
ri->ri_stride = (ri->ri_width * ri->ri_depth) / 8;
ri->ri_flg = RI_CENTER | RI_CLEAR | RI_FULLCLEAR;
ri->ri_bits = (void *)fbbase;
ri->ri_hw = fb;
#ifdef __MIPSEL__
/* swap B and R */
ri->ri_rnum = 5;
ri->ri_rpos = 11;
ri->ri_gnum = 6;
ri->ri_gpos = 5;
ri->ri_bnum = 5;
ri->ri_bpos = 0;
#endif
rasops_init(ri, 160, 160);
strlcpy(fb->wsd.name, "std", sizeof(fb->wsd.name));
fb->wsd.ncols = ri->ri_cols;
fb->wsd.nrows = ri->ri_rows;
fb->wsd.textops = &ri->ri_ops;
fb->wsd.fontwidth = ri->ri_font->fontwidth;
fb->wsd.fontheight = ri->ri_font->fontheight;
fb->wsd.capabilities = ri->ri_caps;
fb->dpr = (volatile uint32_t *)(fbbase + DPR_BASE);
fb->mmio = (volatile uint8_t *)(fbbase + MMIO_BASE);
/*
* Setup 2D acceleration
*/
smfb_wait(fb);
DPR_WRITE(fb, DPR_CROP_TOPLEFT_COORDS, DPR_COORDS(0, 0));
/* use of width both times is intentional */
DPR_WRITE(fb, DPR_PITCH, DPR_COORDS(ri->ri_width, ri->ri_width));
DPR_WRITE(fb, DPR_SRC_WINDOW, DPR_COORDS(ri->ri_width, ri->ri_width));
DPR_WRITE(fb, DPR_BYTE_BIT_MASK, 0xffffffff);
DPR_WRITE(fb, DPR_COLOR_COMPARE_MASK, 0);
DPR_WRITE(fb, DPR_COLOR_COMPARE, 0);
DPR_WRITE(fb, DPR_SRC_BASE, 0);
DPR_WRITE(fb, DPR_DST_BASE, 0);
DPR_READ(fb, DPR_DST_BASE);
ri->ri_ops.copycols = smfb_copycols;
ri->ri_ops.copyrows = smfb_copyrows;
ri->ri_ops.erasecols = smfb_erasecols;
ri->ri_ops.eraserows = smfb_eraserows;
return 0;
}
int
rascons_init_rasops(int node, struct rasops_info *ri)
{
int32_t width, height, linebytes, depth;
/* XXX /chaos/control doesn't have "width", "height", ... */
width = height = -1;
if (OF_getprop(node, "width", &width, 4) != 4)
OF_interpret("screen-width", 0, 1, &width);
if (OF_getprop(node, "height", &height, 4) != 4)
OF_interpret("screen-height", 0, 1, &height);
if (OF_getprop(node, "linebytes", &linebytes, 4) != 4)
linebytes = width; /* XXX */
if (OF_getprop(node, "depth", &depth, 4) != 4)
depth = 8; /* XXX */
if (OF_getprop(node, "address", &fbaddr, 4) != 4)
OF_interpret("frame-buffer-adr", 0, 1, &fbaddr);
if (width == -1 || height == -1 || fbaddr == 0 || fbaddr == -1)
return false;
/* Enable write-through cache. */
#if defined (PPC_OEA) && !defined (PPC_OEA64) && !defined (PPC_OEA64_BRIDGE)
if (rascons_enable_cache) {
vaddr_t va;
/*
* Let's try to find an empty BAT to use
*/
for (va = SEGMENT_LENGTH; va < (USER_SR << ADDR_SR_SHFT);
va += SEGMENT_LENGTH) {
if (battable[va >> ADDR_SR_SHFT].batu == 0) {
battable[va >> ADDR_SR_SHFT].batl =
BATL(fbaddr & 0xf0000000,
BAT_G | BAT_W | BAT_M, BAT_PP_RW);
battable[va >> ADDR_SR_SHFT].batu =
BATL(va, BAT_BL_256M, BAT_Vs);
fbaddr &= 0x0fffffff;
fbaddr |= va;
break;
}
}
}
#endif /* PPC_OEA64 */
/* initialize rasops */
ri->ri_width = width;
ri->ri_height = height;
ri->ri_depth = depth;
ri->ri_stride = linebytes;
ri->ri_bits = (char *)fbaddr;
ri->ri_flg = RI_CENTER | RI_FULLCLEAR;
/* mimic firmware output if we can find the ROM font */
if (romfont_loaded) {
int cols, rows;
/*
* XXX this assumes we're the console which may or may not
* be the case
*/
OF_interpret("#lines", 0, 1, &rows);
OF_interpret("#columns", 0, 1, &cols);
ri->ri_font = &openfirm6x11;
ri->ri_wsfcookie = -1; /* not using wsfont */
rasops_init(ri, rows, cols);
ri->ri_xorigin = (width - cols * ri->ri_font->fontwidth) >> 1;
ri->ri_yorigin = (height - rows * ri->ri_font->fontheight)
>> 1;
ri->ri_bits = (char *)fbaddr + ri->ri_xorigin +
ri->ri_stride * ri->ri_yorigin;
} else {
int
s3c24x0_lcd_alloc_screen(void *v, const struct wsscreen_descr *_type,
void **cookiep, int *curxp, int *curyp, long *attrp)
{
struct s3c24x0_lcd_softc *sc = v;
struct s3c24x0_lcd_screen *scr;
const struct s3c24x0_wsscreen_descr *type =
(const struct s3c24x0_wsscreen_descr *)_type;
int width, height;
width = type->c.ncols * type->c.fontwidth;
height = type->c.nrows * type->c.fontwidth;
if (width < sc->panel_info->panel_width)
width = sc->panel_info->panel_width;
if (height < sc->panel_info->panel_height)
height = sc->panel_info->panel_height;
scr = s3c24x0_lcd_new_screen(sc, width, height, type->depth);
if (scr == NULL)
return -1;
/*
* initialize raster operation for this screen.
*/
scr->rinfo.ri_flg = 0;
scr->rinfo.ri_depth = type->depth;
scr->rinfo.ri_bits = scr->buf_va;
scr->rinfo.ri_width = width;
scr->rinfo.ri_height = height;
scr->rinfo.ri_stride = scr->stride;
if (type->c.fontwidth || type->c.fontheight) {
/*
* find a font with specified size
*/
int cookie;
wsfont_init();
cookie = wsfont_find(NULL, type->c.fontwidth,
type->c.fontheight, 0, WSDISPLAY_FONTORDER_L2R,
WSDISPLAY_FONTORDER_L2R);
if (cookie > 0) {
if (wsfont_lock(cookie, &scr->rinfo.ri_font))
scr->rinfo.ri_wsfcookie = cookie;
}
}
rasops_init(&scr->rinfo, type->c.nrows, type->c.ncols);
(* scr->rinfo.ri_ops.allocattr)(&scr->rinfo, 0, 0, 0, attrp);
if (type->c.nrows != scr->rinfo.ri_rows ||
type->c.ncols != scr->rinfo.ri_cols) {
aprint_error("%s: can't allocate a screen with requested size:"
"%d x %d -> %d x %d\n",
sc->dev.dv_xname,
type->c.ncols, type->c.nrows,
scr->rinfo.ri_cols, scr->rinfo.ri_rows);
}
*cookiep = scr;
*curxp = 0;
*curyp = 0;
return 0;
}
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
fbwscons_init(struct sunfb *sf, int flags, int isconsole)
{
struct rasops_info *ri = &sf->sf_ro;
int cols, rows, fw, fh, wt, wl;
/* ri_hw and ri_bits must have already been setup by caller */
ri->ri_flg = RI_FULLCLEAR | flags;
ri->ri_depth = sf->sf_depth;
ri->ri_stride = sf->sf_linebytes;
ri->ri_width = sf->sf_width;
ri->ri_height = sf->sf_height;
rows = a2int(getpropstring(optionsnode, "screen-#rows"), 34);
cols = a2int(getpropstring(optionsnode, "screen-#columns"), 80);
/*
* If the framebuffer width is under 960 pixels, rasops will
* switch from the 12x22 font to the more adequate 8x16 font
* here.
* If we are the console device, we need to adjust two things:
* - the display row should be overrided from the current PROM
* metrics, since it will not match the PROM reality anymore.
* - the screen needs to be cleared.
*
* However, to accommodate laptops with specific small fonts,
* it is necessary to compare the resolution with the actual
* font metrics.
*/
if (isconsole) {
if (fb_get_console_metrics(&fw, &fh, &wt, &wl) != 0) {
/*
* Assume a 12x22 prom font and a centered
* 80x34 console window.
*/
fw = 12; fh = 22;
wt = wl = 0;
} else {
/*
* Make sure window-top and window-left
* values are consistent with the font metrics.
*/
if (wt <= 0 || wt > sf->sf_height - rows * fh ||
wl <= 0 || wl > sf->sf_width - cols * fw)
wt = wl = 0;
}
if (wt == 0 /* || wl == 0 */) {
ri->ri_flg |= RI_CENTER;
/*
* Since the console window might not be
* centered (e.g. on a 1280x1024 vigra
* VS-12 frame buffer), have rasops
* clear the margins even if the screen is
* not cleared.
*/
ri->ri_flg |= RI_CLEARMARGINS;
}
if (ri->ri_wsfcookie != 0) {
/* driver handles font issues. do nothing. */
} else {
/*
* If the PROM uses a different font than the
* one we are expecting it to use, or if the
* display is shorter than 960 pixels wide,
* we'll force a screen clear.
*/
if (fw != 12 || sf->sf_width < 12 * 80)
ri->ri_flg |= RI_CLEAR | RI_CENTER;
}
} else {
ri->ri_flg |= RI_CLEAR | RI_CENTER;
}
/* ifb(4) doesn't set ri_bits at the moment */
if (ri->ri_bits == NULL)
ri->ri_flg &= ~(RI_CLEAR | RI_CLEARMARGINS);
rasops_init(ri, rows, cols);
/*
* If this is the console display and there is no font change,
* adjust our terminal window to the position of the PROM
* window - in case it is not exactly centered.
*/
if ((ri->ri_flg & RI_CENTER) == 0) {
/* code above made sure wt and wl are initialized */
ri->ri_bits += wt * ri->ri_stride;
if (ri->ri_depth >= 8) /* for 15bpp to compute ok */
ri->ri_bits += wl * ri->ri_pelbytes;
else
ri->ri_bits += (wl * ri->ri_depth) >> 3;
ri->ri_xorigin = wl;
ri->ri_yorigin = wt;
}
void
odyssey_init_screen(struct odyssey_screen *screen)
{
u_char *colour;
int i;
/*
* Initialise screen.
*/
/* Initialise rasops. */
memset(&screen->ri, 0, sizeof(struct rasops_info));
screen->ri.ri_flg = RI_CENTER;
screen->ri.ri_depth = screen->depth;
screen->ri.ri_width = screen->width;
screen->ri.ri_height = screen->height;
screen->ri.ri_stride = screen->linebytes;
if (screen->depth == 32) {
screen->ri.ri_bpos = 16;
screen->ri.ri_bnum = 8;
screen->ri.ri_gpos = 8;
screen->ri.ri_gnum = 8;
screen->ri.ri_rpos = 0;
screen->ri.ri_rnum = 8;
} else if (screen->depth == 16) {
screen->ri.ri_rpos = 10;
screen->ri.ri_rnum = 5;
screen->ri.ri_gpos = 5;
screen->ri.ri_gnum = 5;
screen->ri.ri_bpos = 0;
screen->ri.ri_bnum = 5;
}
rasops_init(&screen->ri, screen->height / 8, screen->width / 8);
/*
* Initialise colourmap, if required.
*/
if (screen->depth == 8) {
for (i = 0; i < 16; i++) {
colour = (u_char *)&rasops_cmap[i * 3];
screen->cmap.cm_red[i] = colour[0];
screen->cmap.cm_green[i] = colour[1];
screen->cmap.cm_blue[i] = colour[2];
}
for (i = 240; i < 256; i++) {
colour = (u_char *)&rasops_cmap[i * 3];
screen->cmap.cm_red[i] = colour[0];
screen->cmap.cm_green[i] = colour[1];
screen->cmap.cm_blue[i] = colour[2];
}
}
screen->ri.ri_hw = screen->sc;
screen->ri.ri_ops.putchar = odyssey_putchar;
screen->ri.ri_do_cursor = odyssey_do_cursor;
screen->ri.ri_ops.copyrows = odyssey_copyrows;
screen->ri.ri_ops.copycols = odyssey_copycols;
screen->ri.ri_ops.eraserows = odyssey_eraserows;
screen->ri.ri_ops.erasecols = odyssey_erasecols;
odyssey_stdscreen.ncols = screen->ri.ri_cols;
odyssey_stdscreen.nrows = screen->ri.ri_rows;
odyssey_stdscreen.textops = &screen->ri.ri_ops;
odyssey_stdscreen.fontwidth = screen->ri.ri_font->fontwidth;
odyssey_stdscreen.fontheight = screen->ri.ri_font->fontheight;
odyssey_stdscreen.capabilities = screen->ri.ri_caps;
}
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);
}
}