Annotation of sys/dev/ic/sti.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: sti.c,v 1.55 2007/06/17 13:59:08 miod Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2000-2003 Michael Shalayeff
! 5: * All rights reserved.
! 6: *
! 7: * Redistribution and use in source and binary forms, with or without
! 8: * modification, are permitted provided that the following conditions
! 9: * are met:
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: *
! 16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 17: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 18: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 19: * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
! 20: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
! 21: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
! 22: * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
! 24: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
! 25: * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
! 26: * THE POSSIBILITY OF SUCH DAMAGE.
! 27: */
! 28: /*
! 29: * TODO:
! 30: * call sti procs asynchronously;
! 31: * implement console scroll-back;
! 32: * X11 support.
! 33: */
! 34:
! 35: #include <sys/param.h>
! 36: #include <sys/systm.h>
! 37: #include <sys/device.h>
! 38: #include <sys/malloc.h>
! 39:
! 40: #include <uvm/uvm.h>
! 41:
! 42: #include <machine/bus.h>
! 43:
! 44: #include <dev/wscons/wsdisplayvar.h>
! 45: #include <dev/wscons/wsconsio.h>
! 46:
! 47: #include <dev/ic/stireg.h>
! 48: #include <dev/ic/stivar.h>
! 49:
! 50: #include "sti.h"
! 51:
! 52: struct cfdriver sti_cd = {
! 53: NULL, "sti", DV_DULL
! 54: };
! 55:
! 56: void sti_cursor(void *v, int on, int row, int col);
! 57: int sti_mapchar(void *v, int uni, u_int *index);
! 58: void sti_putchar(void *v, int row, int col, u_int uc, long attr);
! 59: void sti_copycols(void *v, int row, int srccol, int dstcol, int ncols);
! 60: void sti_erasecols(void *v, int row, int startcol, int ncols, long attr);
! 61: void sti_copyrows(void *v, int srcrow, int dstrow, int nrows);
! 62: void sti_eraserows(void *v, int row, int nrows, long attr);
! 63: int sti_alloc_attr(void *v, int fg, int bg, int flags, long *pattr);
! 64: void sti_unpack_attr(void *v, long attr, int *fg, int *bg, int *ul);
! 65:
! 66: struct wsdisplay_emulops sti_emulops = {
! 67: sti_cursor,
! 68: sti_mapchar,
! 69: sti_putchar,
! 70: sti_copycols,
! 71: sti_erasecols,
! 72: sti_copyrows,
! 73: sti_eraserows,
! 74: sti_alloc_attr,
! 75: sti_unpack_attr
! 76: };
! 77:
! 78: int sti_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p);
! 79: paddr_t sti_mmap(void *v, off_t offset, int prot);
! 80: int sti_alloc_screen(void *v, const struct wsscreen_descr *type,
! 81: void **cookiep, int *cxp, int *cyp, long *defattr);
! 82: void sti_free_screen(void *v, void *cookie);
! 83: int sti_show_screen(void *v, void *cookie, int waitok,
! 84: void (*cb)(void *, int, int), void *cbarg);
! 85: int sti_load_font(void *v, void *cookie, struct wsdisplay_font *);
! 86:
! 87: const struct wsdisplay_accessops sti_accessops = {
! 88: sti_ioctl,
! 89: sti_mmap,
! 90: sti_alloc_screen,
! 91: sti_free_screen,
! 92: sti_show_screen,
! 93: sti_load_font
! 94: };
! 95:
! 96: enum sti_bmove_funcs {
! 97: bmf_clear, bmf_copy, bmf_invert, bmf_underline
! 98: };
! 99:
! 100: int sti_init(struct sti_screen *scr, int mode);
! 101: int sti_inqcfg(struct sti_screen *scr, struct sti_inqconfout *out);
! 102: void sti_bmove(struct sti_screen *scr, int, int, int, int, int, int,
! 103: enum sti_bmove_funcs);
! 104: int sti_setcment(struct sti_screen *scr, u_int i, u_char r, u_char g, u_char b);
! 105: int sti_fetchfonts(struct sti_screen *scr, struct sti_inqconfout *cfg,
! 106: u_int32_t addr);
! 107: int sti_screen_setup(struct sti_screen *scr, bus_space_tag_t iot,
! 108: bus_space_tag_t memt, bus_space_handle_t romh, bus_addr_t *bases,
! 109: u_int codebase);
! 110:
! 111: #if NSTI_PCI > 0
! 112: #define STI_ENABLE_ROM(sc) \
! 113: do { \
! 114: if ((sc) != NULL && (sc)->sc_enable_rom != NULL) \
! 115: (*(sc)->sc_enable_rom)(sc); \
! 116: } while (0)
! 117: #define STI_DISABLE_ROM(sc) \
! 118: do { \
! 119: if ((sc) != NULL && (sc)->sc_disable_rom != NULL) \
! 120: (*(sc)->sc_disable_rom)(sc); \
! 121: } while (0)
! 122: #else
! 123: #define STI_ENABLE_ROM(sc) do { /* nothing */ } while (0)
! 124: #define STI_DISABLE_ROM(sc) do { /* nothing */ } while (0)
! 125: #endif
! 126:
! 127: int
! 128: sti_attach_common(sc, codebase)
! 129: struct sti_softc *sc;
! 130: u_int codebase;
! 131: {
! 132: struct sti_screen *scr;
! 133: int rc;
! 134:
! 135: scr = malloc(sizeof(struct sti_screen), M_DEVBUF, M_NOWAIT);
! 136: if (scr == NULL) {
! 137: printf("cannot allocate screen data\n");
! 138: return (ENOMEM);
! 139: }
! 140:
! 141: bzero(scr, sizeof(struct sti_screen));
! 142: sc->sc_scr = scr;
! 143: scr->scr_main = sc;
! 144:
! 145: if ((rc = sti_screen_setup(scr, sc->iot, sc->memt, sc->romh, sc->bases,
! 146: codebase)) != 0) {
! 147: free(scr, M_DEVBUF);
! 148: sc->sc_scr = NULL;
! 149: return (rc);
! 150: }
! 151:
! 152: sti_describe(sc);
! 153: return (0);
! 154: }
! 155:
! 156: int
! 157: sti_screen_setup(struct sti_screen *scr, bus_space_tag_t iot,
! 158: bus_space_tag_t memt, bus_space_handle_t romh, bus_addr_t *bases,
! 159: u_int codebase)
! 160: {
! 161: struct sti_inqconfout cfg;
! 162: struct sti_einqconfout ecfg;
! 163: bus_space_handle_t fbh;
! 164: struct sti_dd *dd;
! 165: struct sti_cfg *cc;
! 166: int error, size, i;
! 167: int geometry_kluge = 0;
! 168:
! 169: STI_ENABLE_ROM(scr->scr_main);
! 170:
! 171: scr->iot = iot;
! 172: scr->memt = memt;
! 173: scr->romh = romh;
! 174: scr->bases = bases;
! 175: scr->scr_devtype = bus_space_read_1(memt, romh, 3);
! 176:
! 177: /* { extern int pmapdebug; pmapdebug = 0xfffff; } */
! 178: dd = &scr->scr_dd;
! 179: if (scr->scr_devtype == STI_DEVTYPE1) {
! 180: #define parseshort(o) \
! 181: ((bus_space_read_1(memt, romh, (o) + 3) << 8) | \
! 182: (bus_space_read_1(memt, romh, (o) + 7)))
! 183: #define parseword(o) \
! 184: ((bus_space_read_1(memt, romh, (o) + 3) << 24) | \
! 185: (bus_space_read_1(memt, romh, (o) + 7) << 16) | \
! 186: (bus_space_read_1(memt, romh, (o) + 11) << 8) | \
! 187: (bus_space_read_1(memt, romh, (o) + 15)))
! 188:
! 189: dd->dd_type = bus_space_read_1(memt, romh, 0x03);
! 190: dd->dd_nmon = bus_space_read_1(memt, romh, 0x07);
! 191: dd->dd_grrev = bus_space_read_1(memt, romh, 0x0b);
! 192: dd->dd_lrrev = bus_space_read_1(memt, romh, 0x0f);
! 193: dd->dd_grid[0] = parseword(0x10);
! 194: dd->dd_grid[1] = parseword(0x20);
! 195: dd->dd_fntaddr = parseword(0x30) & ~3;
! 196: dd->dd_maxst = parseword(0x40);
! 197: dd->dd_romend = parseword(0x50) & ~3;
! 198: dd->dd_reglst = parseword(0x60) & ~3;
! 199: dd->dd_maxreent= parseshort(0x70);
! 200: dd->dd_maxtimo = parseshort(0x78);
! 201: dd->dd_montbl = parseword(0x80) & ~3;
! 202: dd->dd_udaddr = parseword(0x90) & ~3;
! 203: dd->dd_stimemreq=parseword(0xa0);
! 204: dd->dd_udsize = parseword(0xb0);
! 205: dd->dd_pwruse = parseshort(0xc0);
! 206: dd->dd_bussup = bus_space_read_1(memt, romh, 0xcb);
! 207: dd->dd_ebussup = bus_space_read_1(memt, romh, 0xcf);
! 208: dd->dd_altcodet= bus_space_read_1(memt, romh, 0xd3);
! 209: dd->dd_eddst[0]= bus_space_read_1(memt, romh, 0xd7);
! 210: dd->dd_eddst[1]= bus_space_read_1(memt, romh, 0xdb);
! 211: dd->dd_eddst[2]= bus_space_read_1(memt, romh, 0xdf);
! 212: dd->dd_cfbaddr = parseword(0xe0) & ~3;
! 213:
! 214: codebase <<= 2;
! 215: dd->dd_pacode[0x0] = parseword(codebase + 0x000) & ~3;
! 216: dd->dd_pacode[0x1] = parseword(codebase + 0x010) & ~3;
! 217: dd->dd_pacode[0x2] = parseword(codebase + 0x020) & ~3;
! 218: dd->dd_pacode[0x3] = parseword(codebase + 0x030) & ~3;
! 219: dd->dd_pacode[0x4] = parseword(codebase + 0x040) & ~3;
! 220: dd->dd_pacode[0x5] = parseword(codebase + 0x050) & ~3;
! 221: dd->dd_pacode[0x6] = parseword(codebase + 0x060) & ~3;
! 222: dd->dd_pacode[0x7] = parseword(codebase + 0x070) & ~3;
! 223: dd->dd_pacode[0x8] = parseword(codebase + 0x080) & ~3;
! 224: dd->dd_pacode[0x9] = parseword(codebase + 0x090) & ~3;
! 225: dd->dd_pacode[0xa] = parseword(codebase + 0x0a0) & ~3;
! 226: dd->dd_pacode[0xb] = parseword(codebase + 0x0b0) & ~3;
! 227: dd->dd_pacode[0xc] = parseword(codebase + 0x0c0) & ~3;
! 228: dd->dd_pacode[0xd] = parseword(codebase + 0x0d0) & ~3;
! 229: dd->dd_pacode[0xe] = parseword(codebase + 0x0e0) & ~3;
! 230: dd->dd_pacode[0xf] = parseword(codebase + 0x0f0) & ~3;
! 231: } else { /* STI_DEVTYPE4 */
! 232: bus_space_read_raw_region_4(memt, romh, 0, (u_int8_t *)dd,
! 233: sizeof(*dd));
! 234: /* fix pacode... */
! 235: bus_space_read_raw_region_4(memt, romh, codebase,
! 236: (u_int8_t *)dd->dd_pacode, sizeof(dd->dd_pacode));
! 237: }
! 238:
! 239: STI_DISABLE_ROM(scr->scr_main);
! 240:
! 241: #ifdef STIDEBUG
! 242: printf("dd:\n"
! 243: "devtype=%x, rev=%x;%d, altt=%x, gid=%016llx, font=%x, mss=%x\n"
! 244: "end=%x, regions=%x, msto=%x, timo=%d, mont=%x, user=%x[%x]\n"
! 245: "memrq=%x, pwr=%d, bus=%x, ebus=%x, cfb=%x\n"
! 246: "code=",
! 247: dd->dd_type & 0xff, dd->dd_grrev, dd->dd_lrrev, dd->dd_altcodet,
! 248: *(u_int64_t *)dd->dd_grid, dd->dd_fntaddr, dd->dd_maxst,
! 249: dd->dd_romend, dd->dd_reglst, dd->dd_maxreent, dd->dd_maxtimo,
! 250: dd->dd_montbl, dd->dd_udaddr, dd->dd_udsize, dd->dd_stimemreq,
! 251: dd->dd_pwruse, dd->dd_bussup, dd->dd_ebussup, dd->dd_cfbaddr);
! 252: printf("%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x\n",
! 253: dd->dd_pacode[0x0], dd->dd_pacode[0x1], dd->dd_pacode[0x2],
! 254: dd->dd_pacode[0x3], dd->dd_pacode[0x4], dd->dd_pacode[0x5],
! 255: dd->dd_pacode[0x6], dd->dd_pacode[0x7], dd->dd_pacode[0x8],
! 256: dd->dd_pacode[0x9], dd->dd_pacode[0xa], dd->dd_pacode[0xb],
! 257: dd->dd_pacode[0xc], dd->dd_pacode[0xd], dd->dd_pacode[0xe],
! 258: dd->dd_pacode[0xf]);
! 259: #endif
! 260: /* divise code size, could be less than STI_END entries */
! 261: for (i = STI_END; !dd->dd_pacode[i]; i--);
! 262: size = dd->dd_pacode[i] - dd->dd_pacode[STI_BEGIN];
! 263: if (scr->scr_devtype == STI_DEVTYPE1)
! 264: size = (size + 3) / 4;
! 265: if (size == 0) {
! 266: printf(": no code for the requested platform\n");
! 267: return (EINVAL);
! 268: }
! 269: if (!(scr->scr_code = uvm_km_alloc(kernel_map, round_page(size)))) {
! 270: printf(": cannot allocate %u bytes for code\n", size);
! 271: return (ENOMEM);
! 272: }
! 273: #ifdef STIDEBUG
! 274: printf("code=0x%x[%x]\n", scr->scr_code, size);
! 275: #endif
! 276:
! 277: STI_ENABLE_ROM(scr->scr_main);
! 278:
! 279: /* copy code into memory */
! 280: if (scr->scr_devtype == STI_DEVTYPE1) {
! 281: u_int8_t *p = (u_int8_t *)scr->scr_code;
! 282: u_int32_t addr, eaddr;
! 283:
! 284: for (addr = dd->dd_pacode[STI_BEGIN], eaddr = addr + size * 4;
! 285: addr < eaddr; addr += 4 )
! 286: *p++ = bus_space_read_4(memt, romh, addr) & 0xff;
! 287:
! 288: } else /* STI_DEVTYPE4 */
! 289: bus_space_read_raw_region_4(memt, romh,
! 290: dd->dd_pacode[STI_BEGIN], (u_int8_t *)scr->scr_code,
! 291: size);
! 292:
! 293: STI_DISABLE_ROM(scr->scr_main);
! 294:
! 295: #define O(i) (dd->dd_pacode[(i)]? (scr->scr_code + \
! 296: (dd->dd_pacode[(i)] - dd->dd_pacode[0]) / \
! 297: (scr->scr_devtype == STI_DEVTYPE1? 4 : 1)) : NULL)
! 298:
! 299: scr->init = (sti_init_t) O(STI_INIT_GRAPH);
! 300: scr->mgmt = (sti_mgmt_t) O(STI_STATE_MGMT);
! 301: scr->unpmv = (sti_unpmv_t) O(STI_FONT_UNPMV);
! 302: scr->blkmv = (sti_blkmv_t) O(STI_BLOCK_MOVE);
! 303: scr->test = (sti_test_t) O(STI_SELF_TEST);
! 304: scr->exhdl = (sti_exhdl_t) O(STI_EXCEP_HDLR);
! 305: scr->inqconf = (sti_inqconf_t)O(STI_INQ_CONF);
! 306: scr->scment = (sti_scment_t)O(STI_SCM_ENT);
! 307: scr->dmac = (sti_dmac_t) O(STI_DMA_CTRL);
! 308: scr->flowc = (sti_flowc_t) O(STI_FLOW_CTRL);
! 309: scr->utiming = (sti_utiming_t)O(STI_UTIMING);
! 310: scr->pmgr = (sti_pmgr_t) O(STI_PROC_MGR);
! 311: scr->util = (sti_util_t) O(STI_UTIL);
! 312:
! 313: /*
! 314: * Set colormap entry is not implemented until 8.04, so force
! 315: * a NULL pointer here.
! 316: */
! 317: if (dd->dd_grrev < STI_REVISION(8,4)) {
! 318: scr->scment = NULL;
! 319: }
! 320:
! 321: if ((error = uvm_map_protect(kernel_map, scr->scr_code,
! 322: scr->scr_code + round_page(size), UVM_PROT_RX, FALSE))) {
! 323: printf(": uvm_map_protect failed (%d)\n", error);
! 324: uvm_km_free(kernel_map, scr->scr_code, round_page(size));
! 325: return (error);
! 326: }
! 327:
! 328: cc = &scr->scr_cfg;
! 329: bzero(cc, sizeof (*cc));
! 330: cc->ext_cfg = &scr->scr_ecfg;
! 331: bzero(cc->ext_cfg, sizeof(*cc->ext_cfg));
! 332: if (dd->dd_stimemreq) {
! 333: scr->scr_ecfg.addr =
! 334: malloc(dd->dd_stimemreq, M_DEVBUF, M_NOWAIT);
! 335: if (!scr->scr_ecfg.addr) {
! 336: printf("cannot allocate %d bytes for STI\n",
! 337: dd->dd_stimemreq);
! 338: uvm_km_free(kernel_map, scr->scr_code,
! 339: round_page(size));
! 340: return (ENOMEM);
! 341: }
! 342: }
! 343: {
! 344: int i = dd->dd_reglst;
! 345: u_int32_t *p;
! 346: struct sti_region r;
! 347:
! 348: #ifdef STIDEBUG
! 349: printf("stiregions @%p:\n", i);
! 350: #endif
! 351:
! 352: STI_ENABLE_ROM(scr->scr_main);
! 353:
! 354: r.last = 0;
! 355: for (p = cc->regions; !r.last &&
! 356: p < &cc->regions[STI_REGION_MAX]; p++) {
! 357:
! 358: if (scr->scr_devtype == STI_DEVTYPE1)
! 359: *(u_int *)&r = parseword(i), i+= 16;
! 360: else {
! 361: bus_space_read_raw_region_4(memt, romh, i,
! 362: (u_int8_t *)&r, 4);
! 363: i += 4;
! 364: }
! 365:
! 366: *p = bases[p - cc->regions] + (r.offset << PGSHIFT);
! 367: #ifdef STIDEBUG
! 368: STI_DISABLE_ROM(scr->scr_main);
! 369: printf("%08x @ 0x%08x%s%s%s%s\n",
! 370: r.length << PGSHIFT, *p, r.sys_only? " sys" : "",
! 371: r.cache? " cache" : "", r.btlb? " btlb" : "",
! 372: r.last? " last" : "");
! 373: STI_ENABLE_ROM(scr->scr_main);
! 374: #endif
! 375:
! 376: /* skip rom if it has already been mapped */
! 377: if (p == cc->regions && romh == bases[0])
! 378: continue;
! 379:
! 380: if (bus_space_map(memt, *p, r.length << PGSHIFT,
! 381: r.cache ? BUS_SPACE_MAP_CACHEABLE : 0, &fbh)) {
! 382: #ifdef STIDEBUG
! 383: STI_DISABLE_ROM(scr->scr_main);
! 384: printf("already mapped region\n");
! 385: STI_ENABLE_ROM(scr->scr_main);
! 386: #endif
! 387: } else {
! 388: if (p - cc->regions == 1) {
! 389: scr->fbaddr = *p;
! 390: scr->fblen = r.length << PGSHIFT;
! 391: }
! 392: *p = fbh;
! 393: }
! 394: }
! 395:
! 396: STI_DISABLE_ROM(scr->scr_main);
! 397: }
! 398:
! 399: if ((error = sti_init(scr, 0))) {
! 400: printf(": can not initialize (%d)\n", error);
! 401: /* XXX free resources */
! 402: return (ENXIO);
! 403: }
! 404:
! 405: bzero(&cfg, sizeof(cfg));
! 406: bzero(&ecfg, sizeof(ecfg));
! 407: cfg.ext = &ecfg;
! 408: if ((error = sti_inqcfg(scr, &cfg))) {
! 409: printf(": error %d inquiring config\n", error);
! 410: /* XXX free resources */
! 411: return (ENXIO);
! 412: }
! 413:
! 414: /*
! 415: * Older (rev 8.02) boards report wrong offset values,
! 416: * similar to the displayable area size, at least in m68k mode.
! 417: * Attempt to detect this and adjust here.
! 418: */
! 419: if (cfg.owidth == cfg.width &&
! 420: cfg.oheight == cfg.height)
! 421: geometry_kluge = 1;
! 422:
! 423: if (geometry_kluge) {
! 424: scr->scr_cfg.oscr_width = cfg.owidth =
! 425: cfg.fbwidth - cfg.width;
! 426: scr->scr_cfg.oscr_height = cfg.oheight =
! 427: cfg.fbheight - cfg.height;
! 428: }
! 429:
! 430: /*
! 431: * Save a few fields for sti_describe() later
! 432: */
! 433: scr->fbheight = cfg.fbheight;
! 434: scr->fbwidth = cfg.fbwidth;
! 435: scr->oheight = cfg.oheight;
! 436: scr->owidth = cfg.owidth;
! 437: bcopy(cfg.name, scr->name, sizeof(scr->name));
! 438:
! 439: if ((error = sti_init(scr, STI_TEXTMODE))) {
! 440: printf(": can not initialize (%d)\n", error);
! 441: /* XXX free resources */
! 442: return (ENXIO);
! 443: }
! 444:
! 445: #ifdef STIDEBUG
! 446: printf("conf: bpp=%d planes=%d attr=%b\n"
! 447: "crt=0x%x:0x%x:0x%x hw=0x%x:0x%x:0x%x\n", cfg.bpp,
! 448: cfg.planes, cfg.attributes, STI_INQCONF_BITS,
! 449: ecfg.crt_config[0], ecfg.crt_config[1], ecfg.crt_config[2],
! 450: ecfg.crt_hw[0], ecfg.crt_hw[1], ecfg.crt_hw[2]);
! 451: #endif
! 452: scr->scr_bpp = cfg.bppu;
! 453:
! 454: if ((error = sti_fetchfonts(scr, &cfg, dd->dd_fntaddr))) {
! 455: printf(": cannot fetch fonts (%d)\n", error);
! 456: /* XXX free resources */
! 457: return (ENXIO);
! 458: }
! 459:
! 460: /*
! 461: * setup screen descriptions:
! 462: * figure number of fonts supported;
! 463: * allocate wscons structures;
! 464: * calculate dimensions.
! 465: */
! 466:
! 467: strlcpy(scr->scr_wsd.name, "std", sizeof(scr->scr_wsd.name));
! 468: scr->scr_wsd.ncols = cfg.width / scr->scr_curfont.width;
! 469: scr->scr_wsd.nrows = cfg.height / scr->scr_curfont.height;
! 470: scr->scr_wsd.textops = &sti_emulops;
! 471: scr->scr_wsd.fontwidth = scr->scr_curfont.width;
! 472: scr->scr_wsd.fontheight = scr->scr_curfont.height;
! 473: scr->scr_wsd.capabilities = 0;
! 474:
! 475: scr->scr_scrlist[0] = &scr->scr_wsd;
! 476: scr->scr_screenlist.nscreens = 1;
! 477: scr->scr_screenlist.screens =
! 478: (const struct wsscreen_descr **)scr->scr_scrlist;
! 479:
! 480: /* { extern int pmapdebug; pmapdebug = 0; } */
! 481:
! 482: return (0);
! 483: }
! 484:
! 485: void
! 486: sti_describe(struct sti_softc *sc)
! 487: {
! 488: struct sti_screen *scr = sc->sc_scr;
! 489: struct sti_dd *dd = &scr->scr_dd;
! 490: struct sti_font *fp = &scr->scr_curfont;
! 491:
! 492: printf(": %s rev %d.%02d;%d, ID 0x%016llX\n",
! 493: scr->name, dd->dd_grrev >> 4, dd->dd_grrev & 0xf,
! 494: dd->dd_lrrev, *(u_int64_t *)dd->dd_grid);
! 495:
! 496: printf("%s: %dx%d frame buffer, %dx%dx%d display, offset %dx%d\n",
! 497: sc->sc_dev.dv_xname, scr->fbwidth, scr->fbheight,
! 498: scr->scr_cfg.scr_width, scr->scr_cfg.scr_height, scr->scr_bpp,
! 499: scr->owidth, scr->oheight);
! 500:
! 501: printf("%s: %dx%d font type %d, %d bpc, charset %d-%d\n",
! 502: sc->sc_dev.dv_xname, fp->width, fp->height,
! 503: fp->type, fp->bpc, fp->first, fp->last);
! 504: }
! 505:
! 506: void
! 507: sti_end_attach(void *v)
! 508: {
! 509: struct sti_softc *sc = v;
! 510: struct wsemuldisplaydev_attach_args waa;
! 511:
! 512: sc->sc_wsmode = WSDISPLAYIO_MODE_EMUL;
! 513:
! 514: waa.console = sc->sc_flags & STI_CONSOLE ? 1 : 0;
! 515: waa.scrdata = &sc->sc_scr->scr_screenlist;
! 516: waa.accessops = &sti_accessops;
! 517: waa.accesscookie = sc;
! 518: waa.defaultscreens = 0;
! 519:
! 520: /* attach as console if required */
! 521: if (waa.console && !ISSET(sc->sc_flags, STI_ATTACHED)) {
! 522: long defattr;
! 523:
! 524: sti_alloc_attr(sc, 0, 0, 0, &defattr);
! 525: wsdisplay_cnattach(&sc->sc_scr->scr_wsd, sc->sc_scr,
! 526: 0, sc->sc_scr->scr_wsd.nrows - 1, defattr);
! 527: sc->sc_flags |= STI_ATTACHED;
! 528: }
! 529:
! 530: config_found(&sc->sc_dev, &waa, wsemuldisplaydevprint);
! 531: }
! 532:
! 533: u_int
! 534: sti_rom_size(bus_space_tag_t iot, bus_space_handle_t ioh)
! 535: {
! 536: int devtype;
! 537: u_int romend;
! 538:
! 539: devtype = bus_space_read_1(iot, ioh, 3);
! 540: if (devtype == STI_DEVTYPE4) {
! 541: bus_space_read_raw_region_4(iot, ioh, 0x18,
! 542: (u_int8_t *)&romend, 4);
! 543: } else {
! 544: romend =
! 545: (bus_space_read_1(iot, ioh, 0x50 + 3) << 24) |
! 546: (bus_space_read_1(iot, ioh, 0x50 + 7) << 16) |
! 547: (bus_space_read_1(iot, ioh, 0x50 + 11) << 8) |
! 548: (bus_space_read_1(iot, ioh, 0x50 + 15));
! 549: }
! 550:
! 551: return (round_page(romend));
! 552: }
! 553:
! 554: int
! 555: sti_fetchfonts(struct sti_screen *scr, struct sti_inqconfout *cfg,
! 556: u_int32_t addr)
! 557: {
! 558: struct sti_font *fp = &scr->scr_curfont;
! 559: int size;
! 560: bus_space_tag_t memt;
! 561: bus_space_handle_t romh;
! 562: #ifdef notyet
! 563: int uc;
! 564: struct {
! 565: struct sti_unpmvflags flags;
! 566: struct sti_unpmvin in;
! 567: struct sti_unpmvout out;
! 568: } a;
! 569: #endif
! 570:
! 571: memt = scr->memt;
! 572: romh = scr->romh;
! 573:
! 574: /*
! 575: * Get the first PROM font in memory
! 576: */
! 577:
! 578: STI_ENABLE_ROM(scr->scr_main);
! 579:
! 580: do {
! 581: if (scr->scr_devtype == STI_DEVTYPE1) {
! 582: fp->first = parseshort(addr + 0x00);
! 583: fp->last = parseshort(addr + 0x08);
! 584: fp->width = bus_space_read_1(memt, romh,
! 585: addr + 0x13);
! 586: fp->height = bus_space_read_1(memt, romh,
! 587: addr + 0x17);
! 588: fp->type = bus_space_read_1(memt, romh,
! 589: addr + 0x1b);
! 590: fp->bpc = bus_space_read_1(memt, romh,
! 591: addr + 0x1f);
! 592: fp->next = parseword(addr + 0x23);
! 593: fp->uheight= bus_space_read_1(memt, romh,
! 594: addr + 0x33);
! 595: fp->uoffset= bus_space_read_1(memt, romh,
! 596: addr + 0x37);
! 597: } else /* STI_DEVTYPE4 */
! 598: bus_space_read_raw_region_4(memt, romh, addr,
! 599: (u_int8_t *)fp, sizeof(struct sti_font));
! 600:
! 601: size = sizeof(struct sti_font) +
! 602: (fp->last - fp->first + 1) * fp->bpc;
! 603: if (scr->scr_devtype == STI_DEVTYPE1)
! 604: size *= 4;
! 605: scr->scr_romfont = malloc(size, M_DEVBUF, M_NOWAIT);
! 606: if (scr->scr_romfont == NULL)
! 607: return (ENOMEM);
! 608:
! 609: bus_space_read_raw_region_4(memt, romh, addr,
! 610: (u_int8_t *)scr->scr_romfont, size);
! 611:
! 612: addr = NULL; /* fp->next */
! 613: } while (addr);
! 614:
! 615: STI_DISABLE_ROM(scr->scr_main);
! 616:
! 617: #ifdef notyet
! 618: /*
! 619: * If there is enough room in the off-screen framebuffer memory,
! 620: * display all the characters there in order to display them
! 621: * faster with blkmv operations rather than unpmv later on.
! 622: */
! 623: if (size <= cfg->fbheight *
! 624: (cfg->fbwidth - cfg->width - cfg->owidth)) {
! 625: bzero(&a, sizeof(a));
! 626: a.flags.flags = STI_UNPMVF_WAIT;
! 627: a.in.fg_colour = STI_COLOUR_WHITE;
! 628: a.in.bg_colour = STI_COLOUR_BLACK;
! 629: a.in.font_addr = scr->scr_romfont;
! 630:
! 631: scr->scr_fontmaxcol = cfg->fbheight / fp->height;
! 632: scr->scr_fontbase = cfg->width + cfg->owidth;
! 633: for (uc = fp->first; uc <= fp->last; uc++) {
! 634: a.in.x = ((uc - fp->first) / scr->scr_fontmaxcol) *
! 635: fp->width + scr->scr_fontbase;
! 636: a.in.y = ((uc - fp->first) % scr->scr_fontmaxcol) *
! 637: fp->height;
! 638: a.in.index = uc;
! 639:
! 640: (*scr->unpmv)(&a.flags, &a.in, &a.out, &scr->scr_cfg);
! 641: if (a.out.errno) {
! 642: #ifdef STIDEBUG
! 643: printf("sti_unpmv %d returned %d\n",
! 644: uc, a.out.errno);
! 645: #endif
! 646: return (0);
! 647: }
! 648: }
! 649:
! 650: free(scr->scr_romfont, M_DEVBUF);
! 651: scr->scr_romfont = NULL;
! 652: }
! 653: #endif
! 654:
! 655: return (0);
! 656: }
! 657:
! 658: int
! 659: sti_init(scr, mode)
! 660: struct sti_screen *scr;
! 661: int mode;
! 662: {
! 663: struct {
! 664: struct sti_initflags flags;
! 665: struct sti_initin in;
! 666: struct sti_einitin ein;
! 667: struct sti_initout out;
! 668: } a;
! 669:
! 670: bzero(&a, sizeof(a));
! 671:
! 672: a.flags.flags = STI_INITF_WAIT | STI_INITF_CMB | STI_INITF_EBET |
! 673: (mode & STI_TEXTMODE? STI_INITF_TEXT | STI_INITF_PBET |
! 674: STI_INITF_PBETI | STI_INITF_ICMT : 0);
! 675: a.in.text_planes = 1;
! 676: a.in.ext_in = &a.ein;
! 677: #ifdef STIDEBUG
! 678: printf("sti_init,%p(%x, %p, %p, %p)\n",
! 679: scr->init, a.flags.flags, &a.in, &a.out, &scr->scr_cfg);
! 680: #endif
! 681: (*scr->init)(&a.flags, &a.in, &a.out, &scr->scr_cfg);
! 682: if (a.out.text_planes != a.in.text_planes)
! 683: return (-1); /* not colliding with sti errno values */
! 684: return (a.out.errno);
! 685: }
! 686:
! 687: int
! 688: sti_inqcfg(struct sti_screen *scr, struct sti_inqconfout *out)
! 689: {
! 690: struct {
! 691: struct sti_inqconfflags flags;
! 692: struct sti_inqconfin in;
! 693: } a;
! 694:
! 695: bzero(&a, sizeof(a));
! 696:
! 697: a.flags.flags = STI_INQCONFF_WAIT;
! 698: (*scr->inqconf)(&a.flags, &a.in, out, &scr->scr_cfg);
! 699:
! 700: return out->errno;
! 701: }
! 702:
! 703: void
! 704: sti_bmove(scr, x1, y1, x2, y2, h, w, f)
! 705: struct sti_screen *scr;
! 706: int x1, y1, x2, y2, h, w;
! 707: enum sti_bmove_funcs f;
! 708: {
! 709: struct {
! 710: struct sti_blkmvflags flags;
! 711: struct sti_blkmvin in;
! 712: struct sti_blkmvout out;
! 713: } a;
! 714:
! 715: bzero(&a, sizeof(a));
! 716:
! 717: a.flags.flags = STI_BLKMVF_WAIT;
! 718: switch (f) {
! 719: case bmf_clear:
! 720: a.flags.flags |= STI_BLKMVF_CLR;
! 721: a.in.bg_colour = STI_COLOUR_BLACK;
! 722: break;
! 723: case bmf_underline:
! 724: case bmf_copy:
! 725: a.in.fg_colour = STI_COLOUR_WHITE;
! 726: a.in.bg_colour = STI_COLOUR_BLACK;
! 727: break;
! 728: case bmf_invert:
! 729: a.flags.flags |= STI_BLKMVF_COLR;
! 730: a.in.fg_colour = STI_COLOUR_BLACK;
! 731: a.in.bg_colour = STI_COLOUR_WHITE;
! 732: break;
! 733: }
! 734: a.in.srcx = x1;
! 735: a.in.srcy = y1;
! 736: a.in.dstx = x2;
! 737: a.in.dsty = y2;
! 738: a.in.height = h;
! 739: a.in.width = w;
! 740:
! 741: (*scr->blkmv)(&a.flags, &a.in, &a.out, &scr->scr_cfg);
! 742: #ifdef STIDEBUG
! 743: if (a.out.errno)
! 744: printf("sti_blkmv returned %d\n", a.out.errno);
! 745: #endif
! 746: }
! 747:
! 748: int
! 749: sti_setcment(struct sti_screen *scr, u_int i, u_char r, u_char g, u_char b)
! 750: {
! 751: struct {
! 752: struct sti_scmentflags flags;
! 753: struct sti_scmentin in;
! 754: struct sti_scmentout out;
! 755: } a;
! 756:
! 757: bzero(&a, sizeof(a));
! 758:
! 759: a.flags.flags = STI_SCMENTF_WAIT;
! 760: a.in.entry = i;
! 761: a.in.value = (r << 16) | (g << 8) | b;
! 762:
! 763: (*scr->scment)(&a.flags, &a.in, &a.out, &scr->scr_cfg);
! 764:
! 765: return a.out.errno;
! 766: }
! 767:
! 768: int
! 769: sti_ioctl(v, cmd, data, flag, p)
! 770: void *v;
! 771: u_long cmd;
! 772: caddr_t data;
! 773: int flag;
! 774: struct proc *p;
! 775: {
! 776: struct sti_softc *sc = v;
! 777: struct sti_screen *scr = sc->sc_scr;
! 778: struct wsdisplay_fbinfo *wdf;
! 779: struct wsdisplay_cmap *cmapp;
! 780: u_int mode, idx, count;
! 781: int i, ret;
! 782:
! 783: ret = 0;
! 784: switch (cmd) {
! 785: case WSDISPLAYIO_GMODE:
! 786: *(u_int *)data = sc->sc_wsmode;
! 787: break;
! 788:
! 789: case WSDISPLAYIO_SMODE:
! 790: mode = *(u_int *)data;
! 791: if (sc->sc_wsmode == WSDISPLAYIO_MODE_EMUL &&
! 792: mode == WSDISPLAYIO_MODE_DUMBFB)
! 793: ret = sti_init(scr, 0);
! 794: else if (sc->sc_wsmode == WSDISPLAYIO_MODE_DUMBFB &&
! 795: mode == WSDISPLAYIO_MODE_EMUL)
! 796: ret = sti_init(scr, STI_TEXTMODE);
! 797: sc->sc_wsmode = mode;
! 798: break;
! 799:
! 800: case WSDISPLAYIO_GTYPE:
! 801: *(u_int *)data = WSDISPLAY_TYPE_STI;
! 802: break;
! 803:
! 804: case WSDISPLAYIO_GINFO:
! 805: wdf = (struct wsdisplay_fbinfo *)data;
! 806: wdf->height = scr->scr_cfg.scr_height;
! 807: wdf->width = scr->scr_cfg.scr_width;
! 808: wdf->depth = scr->scr_bpp;
! 809: if (scr->scment == NULL)
! 810: wdf->cmsize = 0;
! 811: else
! 812: wdf->cmsize = STI_NCMAP;
! 813: break;
! 814:
! 815: case WSDISPLAYIO_LINEBYTES:
! 816: *(u_int *)data = scr->scr_cfg.fb_width;
! 817: break;
! 818:
! 819: case WSDISPLAYIO_GETCMAP:
! 820: if (scr->scment == NULL)
! 821: return ENODEV;
! 822: cmapp = (struct wsdisplay_cmap *)data;
! 823: idx = cmapp->index;
! 824: count = cmapp->count;
! 825: if (idx >= STI_NCMAP || idx + count > STI_NCMAP)
! 826: return EINVAL;
! 827: if ((ret = copyout(&scr->scr_rcmap[idx], cmapp->red, count)))
! 828: break;
! 829: if ((ret = copyout(&scr->scr_gcmap[idx], cmapp->green, count)))
! 830: break;
! 831: if ((ret = copyout(&scr->scr_bcmap[idx], cmapp->blue, count)))
! 832: break;
! 833: break;
! 834:
! 835: case WSDISPLAYIO_PUTCMAP:
! 836: if (scr->scment == NULL)
! 837: return ENODEV;
! 838: cmapp = (struct wsdisplay_cmap *)data;
! 839: idx = cmapp->index;
! 840: count = cmapp->count;
! 841: if (idx >= STI_NCMAP || idx + count > STI_NCMAP)
! 842: return EINVAL;
! 843: if ((ret = copyin(cmapp->red, &scr->scr_rcmap[idx], count)))
! 844: break;
! 845: if ((ret = copyin(cmapp->green, &scr->scr_gcmap[idx], count)))
! 846: break;
! 847: if ((ret = copyin(cmapp->blue, &scr->scr_bcmap[idx], count)))
! 848: break;
! 849: for (i = idx + count - 1; i >= idx; i--)
! 850: if ((ret = sti_setcment(scr, i, scr->scr_rcmap[i],
! 851: scr->scr_gcmap[i], scr->scr_bcmap[i]))) {
! 852: #ifdef STIDEBUG
! 853: printf("sti_ioctl: "
! 854: "sti_setcment(%d, %u, %u, %u): %d\n", i,
! 855: (u_int)scr->scr_rcmap[i],
! 856: (u_int)scr->scr_gcmap[i],
! 857: (u_int)scr->scr_bcmap[i]);
! 858: #endif
! 859: ret = EINVAL;
! 860: break;
! 861: }
! 862: break;
! 863:
! 864: case WSDISPLAYIO_SVIDEO:
! 865: case WSDISPLAYIO_GVIDEO:
! 866: break;
! 867:
! 868: case WSDISPLAYIO_GCURPOS:
! 869: case WSDISPLAYIO_SCURPOS:
! 870: case WSDISPLAYIO_GCURMAX:
! 871: case WSDISPLAYIO_GCURSOR:
! 872: case WSDISPLAYIO_SCURSOR:
! 873: default:
! 874: return (-1); /* not supported yet */
! 875: }
! 876:
! 877: return (ret);
! 878: }
! 879:
! 880: paddr_t
! 881: sti_mmap(v, offset, prot)
! 882: void *v;
! 883: off_t offset;
! 884: int prot;
! 885: {
! 886: /* XXX not finished */
! 887: return -1;
! 888: }
! 889:
! 890: int
! 891: sti_alloc_screen(v, type, cookiep, cxp, cyp, defattr)
! 892: void *v;
! 893: const struct wsscreen_descr *type;
! 894: void **cookiep;
! 895: int *cxp, *cyp;
! 896: long *defattr;
! 897: {
! 898: struct sti_softc *sc = v;
! 899:
! 900: if (sc->sc_nscreens > 0)
! 901: return ENOMEM;
! 902:
! 903: *cookiep = sc->sc_scr;
! 904: *cxp = 0;
! 905: *cyp = 0;
! 906: sti_alloc_attr(sc, 0, 0, 0, defattr);
! 907: sc->sc_nscreens++;
! 908: return 0;
! 909: }
! 910:
! 911: void
! 912: sti_free_screen(v, cookie)
! 913: void *v;
! 914: void *cookie;
! 915: {
! 916: struct sti_softc *sc = v;
! 917:
! 918: sc->sc_nscreens--;
! 919: }
! 920:
! 921: int
! 922: sti_show_screen(v, cookie, waitok, cb, cbarg)
! 923: void *v;
! 924: void *cookie;
! 925: int waitok;
! 926: void (*cb)(void *, int, int);
! 927: void *cbarg;
! 928: {
! 929: return 0;
! 930: }
! 931:
! 932: int
! 933: sti_load_font(v, cookie, font)
! 934: void *v;
! 935: void *cookie;
! 936: struct wsdisplay_font *font;
! 937: {
! 938: return -1;
! 939: }
! 940:
! 941: void
! 942: sti_cursor(v, on, row, col)
! 943: void *v;
! 944: int on, row, col;
! 945: {
! 946: struct sti_screen *scr = v;
! 947: struct sti_font *fp = &scr->scr_curfont;
! 948:
! 949: sti_bmove(scr,
! 950: col * fp->width, row * fp->height,
! 951: col * fp->width, row * fp->height,
! 952: fp->height, fp->width, bmf_invert);
! 953: }
! 954:
! 955: /*
! 956: * ISO 8859-1 part of Unicode to HP Roman font index conversion array.
! 957: */
! 958: static const u_int8_t
! 959: sti_unitoroman[0x100 - 0xa0] = {
! 960: 0xa0, 0xb8, 0xbf, 0xbb, 0xba, 0xbc, 0, 0xbd,
! 961: 0xab, 0, 0xf9, 0xfb, 0, 0xf6, 0, 0xb0,
! 962:
! 963: 0xb3, 0xfe, 0, 0, 0xa8, 0xf3, 0xf4, 0xf2,
! 964: 0, 0, 0xfa, 0xfd, 0xf7, 0xf8, 0, 0xb9,
! 965:
! 966: 0xa1, 0xe0, 0xa2, 0xe1, 0xd8, 0xd0, 0xd3, 0xb4,
! 967: 0xa3, 0xdc, 0xa4, 0xa5, 0xe6, 0xe5, 0xa6, 0xa7,
! 968:
! 969: 0xe3, 0xb6, 0xe8, 0xe7, 0xdf, 0xe9, 0xda, 0,
! 970: 0xd2, 0xad, 0xed, 0xae, 0xdb, 0xb1, 0xf0, 0xde,
! 971:
! 972: 0xc8, 0xc4, 0xc0, 0xe2, 0xcc, 0xd4, 0xd7, 0xb5,
! 973: 0xc9, 0xc5, 0xc1, 0xcd, 0xd9, 0xd5, 0xd1, 0xdd,
! 974:
! 975: 0xe4, 0xb7, 0xca, 0xc6, 0xc2, 0xea, 0xce, 0,
! 976: 0xd6, 0xcb, 0xc7, 0xc3, 0xcf, 0xb2, 0xf1, 0xef
! 977: };
! 978:
! 979: int
! 980: sti_mapchar(v, uni, index)
! 981: void *v;
! 982: int uni;
! 983: u_int *index;
! 984: {
! 985: struct sti_screen *scr = v;
! 986: struct sti_font *fp = &scr->scr_curfont;
! 987: int c;
! 988:
! 989: switch (fp->type) {
! 990: case STI_FONT_HPROMAN8:
! 991: if (uni >= 0x80 && uni < 0xa0)
! 992: c = -1;
! 993: else if (uni >= 0xa0 && uni < 0x100) {
! 994: c = (int)sti_unitoroman[uni - 0xa0];
! 995: if (c == 0)
! 996: c = -1;
! 997: } else
! 998: c = uni;
! 999: break;
! 1000: default:
! 1001: c = uni;
! 1002: break;
! 1003: }
! 1004:
! 1005: if (c == -1 || c < fp->first || c > fp->last) {
! 1006: *index = ' ';
! 1007: return (0);
! 1008: }
! 1009:
! 1010: *index = c;
! 1011: return (5);
! 1012: }
! 1013:
! 1014: void
! 1015: sti_putchar(v, row, col, uc, attr)
! 1016: void *v;
! 1017: int row, col;
! 1018: u_int uc;
! 1019: long attr;
! 1020: {
! 1021: struct sti_screen *scr = v;
! 1022: struct sti_font *fp = &scr->scr_curfont;
! 1023:
! 1024: if (scr->scr_romfont != NULL) {
! 1025: /*
! 1026: * Font is in memory, use unpmv
! 1027: */
! 1028: struct {
! 1029: struct sti_unpmvflags flags;
! 1030: struct sti_unpmvin in;
! 1031: struct sti_unpmvout out;
! 1032: } a;
! 1033:
! 1034: bzero(&a, sizeof(a));
! 1035:
! 1036: a.flags.flags = STI_UNPMVF_WAIT;
! 1037: /* XXX does not handle text attributes */
! 1038: a.in.fg_colour = STI_COLOUR_WHITE;
! 1039: a.in.bg_colour = STI_COLOUR_BLACK;
! 1040: a.in.x = col * fp->width;
! 1041: a.in.y = row * fp->height;
! 1042: a.in.font_addr = scr->scr_romfont;
! 1043: a.in.index = uc;
! 1044:
! 1045: (*scr->unpmv)(&a.flags, &a.in, &a.out, &scr->scr_cfg);
! 1046: } else {
! 1047: /*
! 1048: * Font is in frame buffer, use blkmv
! 1049: */
! 1050: struct {
! 1051: struct sti_blkmvflags flags;
! 1052: struct sti_blkmvin in;
! 1053: struct sti_blkmvout out;
! 1054: } a;
! 1055:
! 1056: bzero(&a, sizeof(a));
! 1057:
! 1058: a.flags.flags = STI_BLKMVF_WAIT;
! 1059: /* XXX does not handle text attributes */
! 1060: a.in.fg_colour = STI_COLOUR_WHITE;
! 1061: a.in.bg_colour = STI_COLOUR_BLACK;
! 1062:
! 1063: a.in.srcx = ((uc - fp->first) / scr->scr_fontmaxcol) *
! 1064: fp->width + scr->scr_fontbase;
! 1065: a.in.srcy = ((uc - fp->first) % scr->scr_fontmaxcol) *
! 1066: fp->height;
! 1067: a.in.dstx = col * fp->width;
! 1068: a.in.dsty = row * fp->height;
! 1069: a.in.height = fp->height;
! 1070: a.in.width = fp->width;
! 1071:
! 1072: (*scr->blkmv)(&a.flags, &a.in, &a.out, &scr->scr_cfg);
! 1073: }
! 1074: }
! 1075:
! 1076: void
! 1077: sti_copycols(v, row, srccol, dstcol, ncols)
! 1078: void *v;
! 1079: int row, srccol, dstcol, ncols;
! 1080: {
! 1081: struct sti_screen *scr = v;
! 1082: struct sti_font *fp = &scr->scr_curfont;
! 1083:
! 1084: sti_bmove(scr,
! 1085: srccol * fp->width, row * fp->height,
! 1086: dstcol * fp->width, row * fp->height,
! 1087: fp->height, ncols * fp->width, bmf_copy);
! 1088: }
! 1089:
! 1090: void
! 1091: sti_erasecols(v, row, startcol, ncols, attr)
! 1092: void *v;
! 1093: int row, startcol, ncols;
! 1094: long attr;
! 1095: {
! 1096: struct sti_screen *scr = v;
! 1097: struct sti_font *fp = &scr->scr_curfont;
! 1098:
! 1099: sti_bmove(scr,
! 1100: startcol * fp->width, row * fp->height,
! 1101: startcol * fp->width, row * fp->height,
! 1102: fp->height, ncols * fp->width, bmf_clear);
! 1103: }
! 1104:
! 1105: void
! 1106: sti_copyrows(v, srcrow, dstrow, nrows)
! 1107: void *v;
! 1108: int srcrow, dstrow, nrows;
! 1109: {
! 1110: struct sti_screen *scr = v;
! 1111: struct sti_font *fp = &scr->scr_curfont;
! 1112:
! 1113: sti_bmove(scr, 0, srcrow * fp->height, 0, dstrow * fp->height,
! 1114: nrows * fp->height, scr->scr_cfg.scr_width, bmf_copy);
! 1115: }
! 1116:
! 1117: void
! 1118: sti_eraserows(v, srcrow, nrows, attr)
! 1119: void *v;
! 1120: int srcrow, nrows;
! 1121: long attr;
! 1122: {
! 1123: struct sti_screen *scr = v;
! 1124: struct sti_font *fp = &scr->scr_curfont;
! 1125:
! 1126: sti_bmove(scr, 0, srcrow * fp->height, 0, srcrow * fp->height,
! 1127: nrows * fp->height, scr->scr_cfg.scr_width, bmf_clear);
! 1128: }
! 1129:
! 1130: int
! 1131: sti_alloc_attr(v, fg, bg, flags, pattr)
! 1132: void *v;
! 1133: int fg, bg, flags;
! 1134: long *pattr;
! 1135: {
! 1136: /* struct sti_screen *scr = v; */
! 1137:
! 1138: *pattr = 0;
! 1139:
! 1140: return 0;
! 1141: }
! 1142:
! 1143: void
! 1144: sti_unpack_attr(void *v, long attr, int *fg, int *bg, int *ul)
! 1145: {
! 1146: *fg = WSCOL_WHITE;
! 1147: *bg = WSCOL_BLACK;
! 1148: if (ul != NULL)
! 1149: *ul = 0;
! 1150: }
! 1151:
! 1152: #if NSTI_SGC > 0
! 1153:
! 1154: /*
! 1155: * Early console support
! 1156: */
! 1157:
! 1158: void
! 1159: sti_clear(struct sti_screen *scr)
! 1160: {
! 1161: sti_bmove(scr, 0, 0, 0, 0,
! 1162: scr->scr_cfg.scr_height, scr->scr_cfg.scr_width, bmf_clear);
! 1163: }
! 1164:
! 1165: int
! 1166: sti_cnattach(struct sti_screen *scr, bus_space_tag_t iot, bus_addr_t *bases,
! 1167: u_int codebase)
! 1168: {
! 1169: bus_space_handle_t ioh;
! 1170: u_int romend;
! 1171: int error;
! 1172: long defattr;
! 1173:
! 1174: if ((error = bus_space_map(iot, bases[0], PAGE_SIZE, 0, &ioh)) != 0)
! 1175: return (error);
! 1176:
! 1177: /*
! 1178: * Compute real PROM size
! 1179: */
! 1180: romend = sti_rom_size(iot, ioh);
! 1181:
! 1182: bus_space_unmap(iot, ioh, PAGE_SIZE);
! 1183:
! 1184: if ((error = bus_space_map(iot, bases[0], romend, 0, &ioh)) != 0)
! 1185: return (error);
! 1186:
! 1187: bases[0] = ioh;
! 1188: if (sti_screen_setup(scr, iot, iot, ioh, bases, codebase) != 0)
! 1189: panic(__func__);
! 1190:
! 1191: sti_alloc_attr(scr, 0, 0, 0, &defattr);
! 1192: wsdisplay_cnattach(&scr->scr_wsd, scr, 0, 0, defattr);
! 1193:
! 1194: return (0);
! 1195: }
! 1196:
! 1197: #endif /* NSTI_SGC > 0 */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to sti.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic