/* $NetBSD: igsfb.c,v 1.2 2002/04/05 03:29:05 uwe Exp $ */ /* * Copyright (c) 2002 Valeriy E. Ushakov * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * Integraphics Systems IGA 1682 and (untested) CyberPro 2k. */ #include __KERNEL_RCSID(0, "$NetBSD: igsfb.c,v 1.2 2002/04/05 03:29:05 uwe Exp $"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* * wsscreen */ /* filled from rasops_info in igsfb_common_init */ static struct wsscreen_descr igsfb_stdscreen = { "std", /* name */ 0, 0, /* ncols, nrows */ NULL, /* textops */ 0, 0, /* fontwidth, fontheight */ 0 /* capabilities */ }; static const struct wsscreen_descr *_igsfb_scrlist[] = { &igsfb_stdscreen, }; static const struct wsscreen_list igsfb_screenlist = { sizeof(_igsfb_scrlist) / sizeof(struct wsscreen_descr *), _igsfb_scrlist }; /* * wsdisplay_accessops */ static int igsfb_ioctl(void *, u_long, caddr_t, int, struct proc *); static paddr_t igsfb_mmap(void *, off_t, int); static int igsfb_alloc_screen(void *, const struct wsscreen_descr *, void **, int *, int *, long *); static void igsfb_free_screen(void *, void *); static int igsfb_show_screen(void *, void *, int, void (*) (void *, int, int), void *); static const struct wsdisplay_accessops igsfb_accessops = { igsfb_ioctl, igsfb_mmap, igsfb_alloc_screen, igsfb_free_screen, igsfb_show_screen, NULL /* load_font */ }; /* * internal functions */ static void igsfb_common_init(struct igsfb_softc *); static void igsfb_init_bit_tables(struct igsfb_softc *); static void igsfb_blank_screen(struct igsfb_softc *, int); static int igsfb_get_cmap(struct igsfb_softc *, struct wsdisplay_cmap *); static int igsfb_set_cmap(struct igsfb_softc *, struct wsdisplay_cmap *); static void igsfb_update_cmap(struct igsfb_softc *sc, u_int, u_int); static void igsfb_set_curpos(struct igsfb_softc *, struct wsdisplay_curpos *); static void igsfb_update_curpos(struct igsfb_softc *); static int igsfb_get_cursor(struct igsfb_softc *, struct wsdisplay_cursor *); static int igsfb_set_cursor(struct igsfb_softc *, struct wsdisplay_cursor *); static void igsfb_update_cursor(struct igsfb_softc *, u_int); static void igsfb_convert_cursor_data(struct igsfb_softc *, u_int, u_int); /* * bit expanders */ static u_int16_t igsfb_spread_bits_8(u_int8_t); struct igs_bittab *igsfb_bittab = NULL; struct igs_bittab *igsfb_bittab_bswap = NULL; static __inline__ u_int16_t igsfb_spread_bits_8(b) u_int8_t b; { u_int16_t s = b; s = ((s & 0x00f0) << 4) | (s & 0x000f); s = ((s & 0x0c0c) << 2) | (s & 0x0303); s = ((s & 0x2222) << 1) | (s & 0x1111); return (s); } /* * Enable Video. This might go through either memory or i/o space and * requires access to registers that we don't need for normal * operation. So for greater flexibility this function takes bus tag * and base address, not the igsfb_softc. */ int igsfb_io_enable(bt, base) bus_space_tag_t bt; bus_addr_t base; { bus_space_handle_t vdoh; bus_space_handle_t vseh; int ret; ret = bus_space_map(bt, base + IGS_VDO, 1, 0, &vdoh); if (ret != 0) { printf("unable to map VDO register\n"); return (ret); } ret = bus_space_map(bt, base + IGS_VSE, 1, 0, &vseh); if (ret != 0) { bus_space_unmap(bt, vdoh, 1); printf("unable to map VSE register\n"); return (ret); } /* enable video: start decoding i/o space accesses */ bus_space_write_1(bt, vdoh, 0, IGS_VDO_ENABLE | IGS_VDO_SETUP); bus_space_write_1(bt, vseh, 0, IGS_VSE_ENABLE); bus_space_write_1(bt, vdoh, 0, IGS_VDO_ENABLE); bus_space_unmap(bt, vdoh, 1); bus_space_unmap(bt, vseh, 1); return (0); } /* * Enable linear: start decoding memory space accesses. * while here, enable coprocessor and set its addrress to 0xbf000. */ void igsfb_mem_enable(sc) struct igsfb_softc *sc; { igs_ext_write(sc->sc_iot, sc->sc_ioh, IGS_EXT_BIU_MISC_CTL, IGS_EXT_BIU_LINEAREN | IGS_EXT_BIU_COPREN | IGS_EXT_BIU_COPASELB); } /* * Finish off the attach. Bus specific attach method should have * enabled io and memory accesses and mapped io and cop registers. */ void igsfb_common_attach(sc, isconsole) struct igsfb_softc *sc; int isconsole; { bus_addr_t craddr; off_t croffset; struct rasops_info *ri; struct wsemuldisplaydev_attach_args waa; u_int8_t busctl, curctl; busctl = igs_ext_read(sc->sc_iot, sc->sc_ioh, IGS_EXT_BUS_CTL); if (busctl & 0x2) sc->sc_memsz = 4 * 1024 * 1024; else if (busctl & 0x1) sc->sc_memsz = 2 * 1024 * 1024; else sc->sc_memsz = 1 * 1024 * 1024; /* * Don't map in all N megs, just the amount we need for wsscreen */ sc->sc_fbsz = 1024 * 768; /* XXX: 8bpp specific */ if (bus_space_map(sc->sc_memt, sc->sc_memaddr, sc->sc_fbsz, sc->sc_memflags | BUS_SPACE_MAP_LINEAR, &sc->sc_fbh) != 0) { bus_space_unmap(sc->sc_iot, sc->sc_ioh, IGS_IO_SIZE); printf("unable to map framebuffer\n"); return; } /* * 1Kb for cursor sprite data at the very end of linear space */ croffset = sc->sc_memsz - IGS_CURSOR_DATA_SIZE; craddr = sc->sc_memaddr + croffset; if (bus_space_map(sc->sc_memt, craddr, IGS_CURSOR_DATA_SIZE, sc->sc_memflags | BUS_SPACE_MAP_LINEAR, &sc->sc_crh) != 0) { bus_space_unmap(sc->sc_iot, sc->sc_ioh, IGS_IO_SIZE); bus_space_unmap(sc->sc_memt, sc->sc_fbh, sc->sc_fbsz); printf("unable to map cursor sprite region\n"); return; } /* * Tell device where cursor sprite data are located in linear * space (it takes data offset in 1k units). */ croffset >>= 10; igs_ext_write(sc->sc_iot, sc->sc_ioh, IGS_EXT_SPRITE_DATA_LO, croffset & 0xff); igs_ext_write(sc->sc_iot, sc->sc_ioh, IGS_EXT_SPRITE_DATA_HI, (croffset >> 8) & 0xf); memset(&sc->sc_cursor, 0, sizeof(struct igs_hwcursor)); memset(bus_space_vaddr(sc->sc_memt, sc->sc_crh), 0xaa, IGS_CURSOR_DATA_SIZE); /* transparent */ curctl = igs_ext_read(sc->sc_iot, sc->sc_ioh, IGS_EXT_SPRITE_CTL); curctl |= IGS_EXT_SPRITE_64x64; curctl &= ~IGS_EXT_SPRITE_VISIBLE; igs_ext_write(sc->sc_iot, sc->sc_ioh, IGS_EXT_SPRITE_CTL, curctl); /* bit expanders for cursor sprite data */ igsfb_init_bit_tables(sc); /* alloc and cross-link raster ops */ ri = malloc(sizeof(struct rasops_info), M_DEVBUF, M_NOWAIT | M_ZERO); if (ri == NULL) panic("unable to allocate rasops"); ri->ri_hw = sc; sc->sc_ri = ri; igsfb_common_init(sc); /* * XXX: console attachment needs rethinking */ if (isconsole) { long defattr; (*ri->ri_ops.alloc_attr)(ri, 0, 0, 0, &defattr); wsdisplay_cnattach(&igsfb_stdscreen, ri, 0, 0, defattr); } printf("%s: %dx%d, %dbpp\n", sc->sc_dev.dv_xname, ri->ri_width, ri->ri_height, ri->ri_depth); /* attach wsdisplay */ waa.console = isconsole; waa.scrdata = &igsfb_screenlist; waa.accessops = &igsfb_accessops; waa.accesscookie = sc; config_found(&sc->sc_dev, &waa, wsemuldisplaydevprint); } /* * Cursor sprite data are in 2bpp. Incoming image/mask are in 1bpp. * Prebuild tables to expand 1bpp->2bpp with bswapping if neccessary. */ static void igsfb_init_bit_tables(sc) struct igsfb_softc *sc; { struct igs_bittab *tab; u_int i; if (sc->sc_hwflags & IGSFB_HW_BSWAP) { if (igsfb_bittab_bswap == NULL) { tab = malloc(sizeof(struct igs_bittab), M_DEVBUF, M_NOWAIT); for (i = 0; i < 256; ++i) { u_int16_t s = igsfb_spread_bits_8(i); tab->iexpand[i] = bswap16(s); tab->mexpand[i] = bswap16((s << 1) | s); } igsfb_bittab_bswap = tab; } sc->sc_bittab = igsfb_bittab_bswap; } else { if (igsfb_bittab == NULL) { tab = malloc(sizeof(struct igs_bittab), M_DEVBUF, M_NOWAIT); for (i = 0; i < 256; ++i) { u_int16_t s = igsfb_spread_bits_8(i); tab->iexpand[i] = s; tab->mexpand[i] = (s << 1) | s; } igsfb_bittab = tab; } sc->sc_bittab = igsfb_bittab; } } /* * I/O and memory are mapped, video enabled, structures allocated. */ static void igsfb_common_init(sc) struct igsfb_softc *sc; { bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; struct rasops_info *ri = sc->sc_ri; int wsfcookie; const u_int8_t *p; int i; sc->sc_blanked = 0; ri->ri_flg = RI_CENTER | RI_CLEAR; if (sc->sc_hwflags & IGSFB_HW_BSWAP) ri->ri_flg |= RI_BSWAP; ri->ri_depth = 8; ri->ri_width = 1024; ri->ri_height = 768; ri->ri_stride = 1024; ri->ri_bits = (u_char *)sc->sc_fbh; /* * Initialize wsfont related stuff. */ wsfont_init(); /* prefer gallant that is identical to the one the prom uses */ wsfcookie = wsfont_find("Gallant", 12, 22, 0, WSDISPLAY_FONTORDER_L2R, WSDISPLAY_FONTORDER_L2R); if (wsfcookie <= 0) { #ifdef DIAGNOSTIC printf("%s: unable to find font Gallant 12x22\n", sc->sc_dev.dv_xname); #endif /* any font at all? */ wsfcookie = wsfont_find(NULL, 0, 0, 0, WSDISPLAY_FONTORDER_L2R, WSDISPLAY_FONTORDER_L2R); } if (wsfcookie <= 0) { printf("%s: unable to find any fonts\n", sc->sc_dev.dv_xname); return; } if (wsfont_lock(wsfcookie, &ri->ri_font) != 0) { printf("%s: unable to lock font\n", sc->sc_dev.dv_xname); return; } ri->ri_wsfcookie = wsfcookie; /* * Initialize colormap related stuff. */ /* ANSI color map */ p = rasops_cmap; for (i = 0; i < IGS_CMAP_SIZE; ++i, p += 3) { /* software copy */ sc->sc_cmap.r[i] = p[0]; sc->sc_cmap.g[i] = p[1]; sc->sc_cmap.b[i] = p[2]; } igsfb_update_cmap(sc, 0, IGS_CMAP_SIZE); /* set overscan color r/g/b (XXX: use defattr's rgb?) */ igs_ext_write(iot, ioh, IGS_EXT_OVERSCAN_RED, 0); igs_ext_write(iot, ioh, IGS_EXT_OVERSCAN_GREEN, 0); igs_ext_write(iot, ioh, IGS_EXT_OVERSCAN_BLUE, 0); /* TODO: compute term size based on font dimensions? */ rasops_init(ri, 34, 80); igsfb_stdscreen.nrows = ri->ri_rows; igsfb_stdscreen.ncols = ri->ri_cols; igsfb_stdscreen.textops = &ri->ri_ops; igsfb_stdscreen.capabilities = ri->ri_caps; } /* * wsdisplay_accessops: mmap() */ static paddr_t igsfb_mmap(v, offset, prot) void *v; off_t offset; int prot; { struct igsfb_softc *sc = v; if (offset >= sc->sc_memsz || offset < 0) return (-1); return (bus_space_mmap(sc->sc_memt, sc->sc_memaddr, offset, prot, sc->sc_memflags | BUS_SPACE_MAP_LINEAR)); } /* * wsdisplay_accessops: ioctl() */ static int igsfb_ioctl(v, cmd, data, flag, p) void *v; u_long cmd; caddr_t data; int flag; struct proc *p; { struct igsfb_softc *sc = v; struct rasops_info *ri = sc->sc_ri; int turnoff; switch (cmd) { case WSDISPLAYIO_GTYPE: *(u_int *)data = WSDISPLAY_TYPE_PCIMISC; return (0); case WSDISPLAYIO_GINFO: #define wsd_fbip ((struct wsdisplay_fbinfo *)data) wsd_fbip->height = ri->ri_height; wsd_fbip->width = ri->ri_width; wsd_fbip->depth = ri->ri_depth; wsd_fbip->cmsize = IGS_CMAP_SIZE; #undef wsd_fbip return (0); case WSDISPLAYIO_GVIDEO: *(u_int *)data = sc->sc_blanked ? WSDISPLAYIO_VIDEO_OFF : WSDISPLAYIO_VIDEO_ON; return (0); case WSDISPLAYIO_SVIDEO: turnoff = (*(u_int *)data == WSDISPLAYIO_VIDEO_OFF); if (sc->sc_blanked != turnoff) { sc->sc_blanked = turnoff; igsfb_blank_screen(sc, sc->sc_blanked); } return (0); case WSDISPLAYIO_GETCMAP: return (igsfb_get_cmap(sc, (struct wsdisplay_cmap *)data)); case WSDISPLAYIO_PUTCMAP: return (igsfb_set_cmap(sc, (struct wsdisplay_cmap *)data)); case WSDISPLAYIO_GCURMAX: ((struct wsdisplay_curpos *)data)->x = IGS_CURSOR_MAX_SIZE; ((struct wsdisplay_curpos *)data)->y = IGS_CURSOR_MAX_SIZE; return (0); case WSDISPLAYIO_GCURPOS: *(struct wsdisplay_curpos *)data = sc->sc_cursor.cc_pos; return (0); case WSDISPLAYIO_SCURPOS: igsfb_set_curpos(sc, (struct wsdisplay_curpos *)data); return (0); case WSDISPLAYIO_GCURSOR: return (igsfb_get_cursor(sc, (struct wsdisplay_cursor *)data)); case WSDISPLAYIO_SCURSOR: return (igsfb_set_cursor(sc, (struct wsdisplay_cursor *)data)); } return (EPASSTHROUGH); } /* * wsdisplay_accessops: ioctl(WSDISPLAYIO_SVIDEO) */ static void igsfb_blank_screen(sc, blank) struct igsfb_softc *sc; int blank; { igs_ext_write(sc->sc_iot, sc->sc_ioh, IGS_EXT_SYNC_CTL, blank ? IGS_EXT_SYNC_H0 | IGS_EXT_SYNC_V0 : 0); } /* * wsdisplay_accessops: ioctl(WSDISPLAYIO_GETCMAP) * Served from software cmap copy. */ static int igsfb_get_cmap(sc, p) struct igsfb_softc *sc; struct wsdisplay_cmap *p; { u_int index = p->index, count = p->count; if (index >= IGS_CMAP_SIZE || (index + count) > IGS_CMAP_SIZE) return (EINVAL); if (!uvm_useracc(p->red, count, B_WRITE) || !uvm_useracc(p->green, count, B_WRITE) || !uvm_useracc(p->blue, count, B_WRITE)) return (EFAULT); copyout(&sc->sc_cmap.r[index], p->red, count); copyout(&sc->sc_cmap.g[index], p->green, count); copyout(&sc->sc_cmap.b[index], p->blue, count); return (0); } /* * wsdisplay_accessops: ioctl(WSDISPLAYIO_SETCMAP) * Set software cmap copy and propagate changed range to device. */ static int igsfb_set_cmap(sc, p) struct igsfb_softc *sc; struct wsdisplay_cmap *p; { u_int index = p->index, count = p->count; if (index >= IGS_CMAP_SIZE || (index + count) > IGS_CMAP_SIZE) return (EINVAL); if (!uvm_useracc(p->red, count, B_READ) || !uvm_useracc(p->green, count, B_READ) || !uvm_useracc(p->blue, count, B_READ)) return (EFAULT); copyin(p->red, &sc->sc_cmap.r[index], count); copyin(p->green, &sc->sc_cmap.g[index], count); copyin(p->blue, &sc->sc_cmap.b[index], count); igsfb_update_cmap(sc, p->index, p->count); return (0); } /* * Propagate specified part of the software cmap copy to device. */ static void igsfb_update_cmap(sc, index, count) struct igsfb_softc *sc; u_int index, count; { bus_space_tag_t t; bus_space_handle_t h; u_int last, i; if (index >= IGS_CMAP_SIZE) return; last = index + count; if (last > IGS_CMAP_SIZE) last = IGS_CMAP_SIZE; t = sc->sc_iot; h = sc->sc_ioh; /* start palette writing, index is autoincremented by hardware */ bus_space_write_1(t, h, IGS_DAC_PEL_WRITE_IDX, index); for (i = index; i < last; ++i) { bus_space_write_1(t, h, IGS_DAC_PEL_DATA, sc->sc_cmap.r[i]); bus_space_write_1(t, h, IGS_DAC_PEL_DATA, sc->sc_cmap.g[i]); bus_space_write_1(t, h, IGS_DAC_PEL_DATA, sc->sc_cmap.b[i]); } } /* * wsdisplay_accessops: ioctl(WSDISPLAYIO_SCURPOS) */ static void igsfb_set_curpos(sc, curpos) struct igsfb_softc *sc; struct wsdisplay_curpos *curpos; { struct rasops_info *ri = sc->sc_ri; int x = curpos->x, y = curpos->y; if (y < 0) y = 0; else if (y > ri->ri_height) y = ri->ri_height; if (x < 0) x = 0; else if (x > ri->ri_width) x = ri->ri_width; sc->sc_cursor.cc_pos.x = x; sc->sc_cursor.cc_pos.y = y; igsfb_update_curpos(sc); } static void igsfb_update_curpos(sc) struct igsfb_softc *sc; { bus_space_tag_t t; bus_space_handle_t h; int x, xoff, y, yoff; xoff = 0; x = sc->sc_cursor.cc_pos.x - sc->sc_cursor.cc_hot.x; if (x < 0) { x = 0; xoff = -x; } yoff = 0; y = sc->sc_cursor.cc_pos.y - sc->sc_cursor.cc_hot.y; if (y < 0) { y = 0; yoff = -y; } t = sc->sc_iot; h = sc->sc_ioh; igs_ext_write(t, h, IGS_EXT_SPRITE_HSTART_LO, x & 0xff); igs_ext_write(t, h, IGS_EXT_SPRITE_HSTART_HI, (x >> 8) & 0x07); igs_ext_write(t, h, IGS_EXT_SPRITE_HPRESET, xoff & 0x3f); igs_ext_write(t, h, IGS_EXT_SPRITE_VSTART_LO, y & 0xff); igs_ext_write(t, h, IGS_EXT_SPRITE_VSTART_HI, (y >> 8) & 0x07); igs_ext_write(t, h, IGS_EXT_SPRITE_VPRESET, yoff & 0x3f); } /* * wsdisplay_accessops: ioctl(WSDISPLAYIO_GCURSOR) */ static int igsfb_get_cursor(sc, p) struct igsfb_softc *sc; struct wsdisplay_cursor *p; { /* XXX: TODO */ return (0); } /* * wsdisplay_accessops: ioctl(WSDISPLAYIO_SCURSOR) */ static int igsfb_set_cursor(sc, p) struct igsfb_softc *sc; struct wsdisplay_cursor *p; { struct igs_hwcursor *cc; u_int v, index, count, icount, iwidth; cc = &sc->sc_cursor; v = p->which; if (v & WSDISPLAY_CURSOR_DOCMAP) { index = p->cmap.index; count = p->cmap.count; if (index >= 2 || (index + count) > 2) return (EINVAL); if (!uvm_useracc(p->cmap.red, count, B_READ) || !uvm_useracc(p->cmap.green, count, B_READ) || !uvm_useracc(p->cmap.blue, count, B_READ)) return (EFAULT); } if (v & WSDISPLAY_CURSOR_DOSHAPE) { if (p->size.x > IGS_CURSOR_MAX_SIZE || p->size.y > IGS_CURSOR_MAX_SIZE) return (EINVAL); iwidth = (p->size.x + 7) >> 3; /* bytes per scan line */ icount = iwidth * p->size.y; if (!uvm_useracc(p->image, icount, B_READ) || !uvm_useracc(p->mask, icount, B_READ)) return (EFAULT); } /* XXX: verify that hot is within size, pos within screen? */ /* arguments verified, do the processing */ if (v & WSDISPLAY_CURSOR_DOCUR) sc->sc_curenb = p->enable; if (v & WSDISPLAY_CURSOR_DOPOS) cc->cc_pos = p->pos; if (v & WSDISPLAY_CURSOR_DOHOT) cc->cc_hot = p->hot; if (v & WSDISPLAY_CURSOR_DOCMAP) { copyin(p->cmap.red, &cc->cc_color[index], count); copyin(p->cmap.green, &cc->cc_color[index + 2], count); copyin(p->cmap.blue, &cc->cc_color[index + 4], count); } if (v & WSDISPLAY_CURSOR_DOSHAPE) { u_int trailing_bits; copyin(p->image, cc->cc_image, icount); copyin(p->mask, cc->cc_mask, icount); cc->cc_size = p->size; /* clear trailing bits in the "partial" mask bytes */ trailing_bits = p->size.x & 0x07; if (trailing_bits != 0) { const u_int cutmask = ~((~0) << trailing_bits); u_char *mp; u_int i; mp = cc->cc_mask + iwidth - 1; for (i = 0; i < p->size.y; ++i) { *mp &= cutmask; mp += iwidth; } } igsfb_convert_cursor_data(sc, iwidth, p->size.y); } igsfb_update_cursor(sc, v); return (0); } /* * Convert incoming 1bpp cursor image/mask into native 2bpp format. */ static void igsfb_convert_cursor_data(sc, w, h) struct igsfb_softc *sc; u_int w, h; { struct igs_hwcursor *cc = &sc->sc_cursor; struct igs_bittab *btab = sc->sc_bittab; u_int8_t *ip, *mp; u_int16_t *dp; u_int line, i; /* init sprite to be all transparent */ memset(cc->cc_sprite, 0xaa, IGS_CURSOR_DATA_SIZE); /* first scanline */ ip = cc->cc_image; mp = cc->cc_mask; dp = cc->cc_sprite; for (line = 0; line < h; ++line) { for (i = 0; i < w; ++i) { u_int16_t is = btab->iexpand[ip[i]]; u_int16_t ms = btab->mexpand[mp[i]]; /* NB: tables are pre-bswapped if needed */ dp[i] = (0xaaaa & ~ms) | (is & ms); } /* next scanline */ ip += w; mp += w; dp += 8; /* 2bpp, 8 pixels per short = 8 shorts */ } } /* * Propagate cursor changes to device. * "which" is composed from WSDISPLAY_CURSOR_DO* bits. */ static void igsfb_update_cursor(sc, which) struct igsfb_softc *sc; u_int which; { bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; u_int8_t curctl; /* * We will need to tweak sprite control register for cursor * visibility and cursor color map manipualtion. */ if (which & (WSDISPLAY_CURSOR_DOCUR | WSDISPLAY_CURSOR_DOCMAP)) { curctl = igs_ext_read(iot, ioh, IGS_EXT_SPRITE_CTL); } if (which & WSDISPLAY_CURSOR_DOSHAPE) { u_int8_t *dst = bus_space_vaddr(sc->sc_memt, sc->sc_crh); /* * memcpy between spaces of different endianness would * be ... special. We cannot be sure if memset gonna * push data in 4-byte chunks, we can't pre-bswap it, * so do it byte-by-byte to preserve byte ordering. */ if (sc->sc_hwflags & IGSFB_HW_BSWAP) { u_int8_t *src = (u_int8_t *)sc->sc_cursor.cc_sprite; int i; for (i = 0; i < 1024; ++i) *dst++ = *src++; } else { memcpy(dst, sc->sc_cursor.cc_sprite, 1024); } } if (which & (WSDISPLAY_CURSOR_DOPOS | WSDISPLAY_CURSOR_DOHOT)) { /* code shared with WSDISPLAYIO_SCURPOS */ igsfb_update_curpos(sc); } if (which & WSDISPLAY_CURSOR_DOCMAP) { u_int8_t *p; /* tell DAC we want access to the cursor palette */ igs_ext_write(iot, ioh, IGS_EXT_SPRITE_CTL, curctl | IGS_EXT_SPRITE_SELECT); p = sc->sc_cursor.cc_color; bus_space_write_1(iot, ioh, IGS_DAC_PEL_WRITE_IDX, 0); bus_space_write_1(iot, ioh, IGS_DAC_PEL_DATA, p[0]); bus_space_write_1(iot, ioh, IGS_DAC_PEL_DATA, p[2]); bus_space_write_1(iot, ioh, IGS_DAC_PEL_DATA, p[4]); bus_space_write_1(iot, ioh, IGS_DAC_PEL_WRITE_IDX, 1); bus_space_write_1(iot, ioh, IGS_DAC_PEL_DATA, p[1]); bus_space_write_1(iot, ioh, IGS_DAC_PEL_DATA, p[3]); bus_space_write_1(iot, ioh, IGS_DAC_PEL_DATA, p[5]); /* restore access to normal palette */ igs_ext_write(iot, ioh, IGS_EXT_SPRITE_CTL, curctl); } if (which & WSDISPLAY_CURSOR_DOCUR) { if ((curctl & IGS_EXT_SPRITE_VISIBLE) == 0 && sc->sc_curenb) igs_ext_write(iot, ioh, IGS_EXT_SPRITE_CTL, curctl | IGS_EXT_SPRITE_VISIBLE); else if ((curctl & IGS_EXT_SPRITE_VISIBLE) != 0 && !sc->sc_curenb) igs_ext_write(iot, ioh, IGS_EXT_SPRITE_CTL, curctl & ~IGS_EXT_SPRITE_VISIBLE); } } /* * wsdisplay_accessops: alloc_screen() */ static int igsfb_alloc_screen(v, type, cookiep, curxp, curyp, attrp) void *v; const struct wsscreen_descr *type; void **cookiep; int *curxp, *curyp; long *attrp; { /* TODO */ return (ENOMEM); } /* * wsdisplay_accessops: free_screen() */ static void igsfb_free_screen(v, cookie) void *v; void *cookie; { /* TODO */ return; } /* * wsdisplay_accessops: show_screen() */ static int igsfb_show_screen(v, cookie, waitok, cb, cbarg) void *v; void *cookie; int waitok; void (*cb)(void *, int, int); void *cbarg; { return (0); }