1 /* 2 * Copyright (c) 1992 The Regents of the University of California. 3 * All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Sony Corp. and Kazumasa Utashiro of Software Research Associates, Inc. 7 * 8 * %sccs.include.redist.c% 9 * 10 * from: $Hdr: bitmapif.c,v 4.300 91/06/09 06:14:40 root Rel41 $ SONY 11 * 12 * @(#)bitmapif.c 7.1 (Berkeley) 06/04/92 13 */ 14 15 #include "../include/fix_machine_type.h" 16 17 #ifdef IPC_MRX 18 #include "../../h/param.h" 19 #include "../../h/types.h" 20 #include "../../iop/framebuf.h" 21 #include "../../iop/fbreg.h" 22 #else 23 #include "param.h" 24 #include "types.h" 25 #include "../iop/framebuf.h" 26 #include "../iop/fbreg.h" 27 #endif 28 29 #include "../fb/fbdefs.h" 30 31 #include "../bm/vt100.h" 32 #include "../bm/bitmapif.h" 33 34 extern int bm_todo; 35 extern int tmode; 36 37 #ifdef CPU_SINGLE 38 extern char *ext_fnt_addr[]; 39 extern char *ext_fnt24_addr[]; 40 #else /* CPU_SINGLE */ 41 #ifdef IPC_MRX 42 extern char **ext_fnt_addr; 43 extern char **ext_fnt24_addr; 44 #else 45 char **ext_fnt_addr = 0; 46 char **ext_fnt24_addr = 0; 47 #endif 48 #define lock_bitmap() 49 #define unlock_bitmap() 50 #endif /* CPU_SINGLE */ 51 52 extern SCREEN screen; 53 54 #ifdef IPC_MRX 55 extern int bitmap_use; 56 #endif 57 58 #ifdef CPU_SINGLE 59 #include "../include/cpu.h" 60 #define PRE_EMPT need_resched() 61 #else 62 #define PRE_EMPT 63 #endif 64 65 short zero[32 * 2]; 66 struct csr_buf local_csr_buf; 67 68 #ifdef CPU_SINGLE 69 struct fb_map rommap; 70 #endif 71 72 bitmapinit() 73 { 74 fbbm_rop_reset(consfb); 75 if (!consfb->Mono) { 76 lock_bitmap(); 77 fbbm_init_palette(consfb); 78 unlock_bitmap(); 79 } 80 } 81 82 bm_pallet_read(entry) 83 int entry; 84 { 85 lPalette lp; 86 sPalette palette; 87 #ifdef CPU_SINGLE 88 struct fb_map rommap; 89 #endif 90 91 lock_bitmap(); 92 93 lp.count = 1; 94 #ifdef CPU_SINGLE 95 lp.palette = (sPalette *)&rommap; 96 rommap.fm_vaddr = (caddr_t)&palette; 97 rommap.fm_offset = 0; 98 #else 99 lp.palette = &palette; 100 #endif 101 palette.index = entry; 102 103 fbbm_get_palette(consfb, &lp); 104 105 unlock_bitmap(); 106 107 return((palette.rgb.r << 16) | (palette.rgb.g << 8) | palette.rgb.b); 108 } 109 110 bm_pallet_write(entry, val) 111 int entry; 112 int val; 113 { 114 lPalette lp; 115 sPalette palette; 116 #ifdef CPU_SINGLE 117 struct fb_map rommap; 118 #endif 119 120 lock_bitmap(); 121 122 lp.count = 1; 123 #ifdef CPU_SINGLE 124 lp.palette = (sPalette *)&rommap; 125 rommap.fm_vaddr = (caddr_t)&palette; 126 rommap.fm_offset = 0; 127 #else 128 lp.palette = &palette; 129 #endif 130 palette.index = entry; 131 palette.rgb.r = ((val >> 16) & 0xff); 132 palette.rgb.g = ((val >> 8) & 0xff); 133 palette.rgb.b = (val & 0xff); 134 fbbm_set_palette(consfb, &lp); 135 136 unlock_bitmap(); 137 138 return(val); 139 } 140 141 unsigned 142 sftjis_to_jis(h, l) 143 register unsigned int h, l; 144 { 145 if ((h >= JVR1S) && (h <= JVR1E)) 146 h -= JVR1S; 147 else if ((h >= JVR2S) && (h <= JVR2E)) 148 h = h - JVR2S + 0x1f; 149 else 150 return (0); 151 152 h <<= 1; 153 154 if ((l >= JHR1S) && (l <= JHR1E)) 155 l -= JHR1S; 156 else if ((l >= JHR2S) && (l <= JHR2E)) 157 l = l - JHR2S + 0x3f; 158 else if ((l >= JHR3S) && (l <= JHR3E)) { 159 l -= JHR3S; 160 h++; 161 } else 162 return (0); 163 164 return(((h + 0x21) << 8) + l + 0x21); 165 } 166 167 setropfunc(func, transp, fore, aux) 168 int func, fore, aux; 169 { 170 char tmp[4]; 171 register int i = consfb->fbNplane; 172 register char *funcp = consfb->funcvec; 173 174 consfb->func = func; 175 consfb->fore = fore; 176 consfb->aux = aux; 177 consfb->trans = transp; 178 179 tmp[0] = TRANS(transp, (func & 0x0c) | (func>>2)); 180 tmp[1] = TRANS(transp, (func>>2) | ((func<<2) & 0x0c)); 181 tmp[2] = TRANS(transp, func); 182 tmp[3] = TRANS(transp, (func<<2) & 0x0c | func & 3); 183 184 while (--i >= 0) { 185 *funcp++ = tmp[((fore & 1) << 1) | (aux & 1)]; 186 fore >>= 1; aux >>= 1; 187 } 188 } 189 190 move_rect(src_x, src_y, width, height, dst_x, dst_y, rop) 191 int src_x, src_y; 192 int width, height; 193 int dst_x, dst_y; 194 int rop; 195 { 196 lRectangle sr; 197 lPoint dp; 198 199 sr.origin.x = src_x; 200 sr.origin.y = src_y; 201 sr.extent.x = width; 202 sr.extent.y = height; 203 204 dp.x = dst_x; 205 dp.y = dst_y; 206 207 lock_bitmap(); 208 setropfunc(rop, 0, consfb->planemask, 0); 209 fbbm_rop_init(consfb, consfb->funcvec); 210 fbbm_rop_copy(consfb, &sr, &dp, 0, consfb->planemask); 211 unlock_bitmap(); 212 } 213 214 clear_rect(x, y, width, height, rop, fore, aux) 215 int x, y; 216 int width, height; 217 int rop; 218 int fore; 219 int aux; 220 { 221 lRectangle dr; 222 223 dr.origin.x = x; 224 dr.origin.y = y; 225 dr.extent.x = width; 226 dr.extent.y = height; 227 228 lock_bitmap(); 229 setropfunc(rop, 0, fore, aux); 230 fbbm_rop_cinit(consfb, consfb->planemask, 1); 231 fbbm_rop_clear(consfb, &dr); 232 unlock_bitmap(); 233 } 234 235 line(param) 236 short *param; 237 { 238 lPoint p[2]; 239 lRectangle clip; 240 241 p[0].x = param[0]; 242 p[0].y = param[1]; 243 p[1].x = param[2]; 244 p[1].y = param[3]; 245 clip = consfb->VisRect; 246 247 lock_bitmap(); 248 fbbm_rop_vect(consfb, &clip, param[4] & 0xf, 249 fbbm_get_pixel(consfb, param[5]), 0, 1, 250 consfb->planemask, 2, p, LINE_SLD, 1, 0); 251 unlock_bitmap(); 252 } 253 254 /* 255 * cursor on 256 * cursor_on(x, y, plane) puts cursor at position (x, y) with color = plane, 257 * if cursor sw is off. 258 * At the same time the image of cursor position is saved. 259 */ 260 cursor_on(p) 261 lPoint *p; 262 { 263 register struct csr_buf *csr_bp = &local_csr_buf; 264 register lRectangle *dr; 265 266 if (screen.s_term_mode & DECCSR_ACTV && 267 bm_todo <= 0 && csr_bp->csr_sw == C_OFF) { 268 269 if (csr_bp->csr_number == 2 && p->x != rit_m) 270 dr = &char_r2; 271 else 272 dr = &char_r1; 273 274 dr->origin = *p; 275 276 lock_bitmap(); 277 setropfunc(BF_DI, 0, consfb->planemask, 0); 278 fbbm_rop_init(consfb, consfb->funcvec); 279 fbbm_rop_copy(consfb, dr, dr, 0, (fcolor^bcolor) & consfb->planemask); 280 unlock_bitmap(); 281 282 csr_bp->csr_sw = C_ON; 283 csr_bp->csr_p = *p; 284 } 285 } 286 287 /* 288 * cursor off 289 * cursor_off() turns off cursor. 290 * The image of cursor position which has previously saved by cursor_on 291 * is restored. 292 */ 293 cursor_off() 294 { 295 register struct csr_buf *csr_bp = &local_csr_buf; 296 register lRectangle *dr; 297 298 if (screen.s_term_mode & DECCSR_ACTV && csr_bp->csr_sw == C_ON) { 299 if (csr_bp->csr_number == 2 && csr_bp->csr_x != rit_m) 300 dr = &char_r2; 301 else 302 dr = &char_r1; 303 304 dr->origin = csr_bp->csr_p; 305 306 lock_bitmap(); 307 setropfunc(BF_DI, 0, consfb->planemask, 0); 308 fbbm_rop_init(consfb, consfb->funcvec); 309 fbbm_rop_copy(consfb, dr, dr, 0, (fcolor^bcolor) & consfb->planemask); 310 unlock_bitmap(); 311 312 csr_bp->csr_sw = C_OFF; 313 } 314 } 315 316 /* 317 * move lines 318 * move_lines(sl, nl, dl) moves nl lines starting at line sl to line dl. 319 */ 320 move_lines(sl, nl, dl) 321 int sl, nl, dl; 322 { 323 move_rect(x_ofst, char_h*(sl - 1) + y_ofst, char_w*(rit_m - LFT_M + 1), 324 char_h*nl, x_ofst, char_h*(dl - 1) + y_ofst, BF_S); 325 PRE_EMPT; 326 } 327 328 /* 329 * move chars 330 * move_chars(sx, sy, nchar, dx) moves nchar characters at position (sx, sy) 331 * to (dx, sy). 332 */ 333 move_chars(sx, sy, nchar, dx) 334 int sx, sy; 335 int nchar; 336 int dx; 337 { 338 move_rect(char_w*(sx - 1) + x_ofst, char_h*(sy - 1) + y_ofst, 339 char_w * nchar, char_h, 340 char_w*(dx - 1) + x_ofst, char_h*(sy - 1) + y_ofst, BF_S); 341 } 342 343 /* 344 * clear lines 345 * clear_lines(sl, nl, rev) clears nl lines starting at line sl with rev 346 * mode. If rev = 0 then normal clear else reverse clear. 347 */ 348 clear_lines(sl, nl, rev, fcol, bcol) 349 int sl, nl; 350 int rev; 351 int fcol, bcol; 352 { 353 if (nl == btm_m) { 354 clear_rect(0, 0, scr_w, scr_h, BF_S, rev?fcol:bcol, bcol); 355 } else if (nl > 0) { 356 clear_rect(x_ofst, char_h*(sl - 1) + y_ofst, 357 char_w*(rit_m - LFT_M + 1), char_h*nl, 358 BF_S, rev?fcol:bcol, bcol); 359 } 360 } 361 362 /* 363 * Clear chars 364 * clear_chars(x, y, nchar, rev) clears nchar characters following the 365 * position (x, y) with rev mode. If rev = 0 then normal clear else 366 * reverse clear. 367 */ 368 clear_chars(x, y, nchar, rev, fcol, bcol) 369 int x, y; 370 int nchar; 371 int rev; 372 int fcol, bcol; 373 { 374 if (nchar > 0) { 375 clear_rect(char_w*(x - 1) + x_ofst, char_h*(y - 1) + y_ofst, 376 char_w*nchar, char_h, BF_S, rev?fcol:bcol, bcol); 377 } 378 } 379 380 reverse_rec(fcol, bcol) 381 int fcol, bcol; 382 { 383 clear_rect(0, 0, scr_w, scr_h, BF_SDX, fcol^bcol, 0); 384 } 385 386 copy_char(sp, c, kanji) 387 register SCREEN *sp; 388 register unsigned int c; 389 int kanji; 390 { 391 register char *f_addr; 392 register int len; 393 register lRectangle *sr, *dr; 394 lRectangle udr; 395 register char **fnt_addr; 396 extern struct fb_map rommap; 397 398 lock_bitmap(); 399 400 if (consfb->font_h == 24) 401 fnt_addr = ext_fnt24_addr; 402 else 403 fnt_addr = ext_fnt_addr; 404 405 if (kanji) { 406 dr = &char_r2; 407 sr = &font_r2; 408 len = font_len2; 409 } else { 410 dr = &char_r1; 411 sr = &font_r1; 412 len = font_len1; 413 } 414 415 dr->origin = sp->s_csr.csr_p; 416 417 setropfunc(BF_S, 0, fcolor, bcolor); 418 fbbm_rop_cinit(consfb, consfb->planemask, 0); 419 fbbm_rop_clear(consfb, dr); 420 421 if (kanji) { 422 /* 423 * KANJI code... kanji char 424 */ 425 f_addr = (char *)fbbm_Krom_addr(consfb, c, sr); 426 #ifdef CPU_DOUBLE 427 } else if (fnt_addr == 0) { 428 /* 429 * no external fonts... try to use ROM fonts 430 */ 431 len = font_len2; 432 f_addr = (char *)fbbm_Krom_addr(consfb, c, sr); 433 #endif 434 #ifdef KM_ASCII 435 } else if (tmode == KM_ASCII) { 436 /* 437 * terminal mode is ASCII... ASCII (ISO) char 438 */ 439 if ((c >= 0x20) && (c <= 0x7e)) { 440 /* 441 * ASCII char 442 */ 443 f_addr = fnt_addr[c]; 444 } else if ((c >= 0xa0) && (c <= 0xff)) { 445 /* 446 * ISO char 447 */ 448 f_addr = fnt_addr[c - 32]; 449 } else { 450 /* 451 * UNKNOWN char 452 */ 453 f_addr = (caddr_t)zero; 454 } 455 #endif /* KM_ASCII */ 456 } else { 457 /* 458 * terminal mode is not ASCII... JIS, SJIS, EUC, ... 459 */ 460 if ((c >= 0x20) && (c <= 0x7e)) { 461 /* 462 * ASCII char 463 */ 464 f_addr = fnt_addr[c]; 465 } else if ((c >= 0xa1) && (c <= 0xdf)) { 466 /* 467 * KANA char 468 */ 469 f_addr = fnt_addr[c + 32]; 470 } else { 471 /* 472 * UNKNOWN char 473 */ 474 f_addr = (caddr_t)zero; 475 } 476 } 477 478 dr->origin.y += ch_pos; 479 480 setropfunc(BF_S, 1, fcolor, bcolor); 481 482 if (f_addr != 0) { 483 fbbm_rop_winit(consfb); 484 rommap.fm_vaddr = f_addr; 485 rommap.fm_offset = 0; 486 fbbm_rop_write(consfb, &rommap, rommap.fm_offset, len, 487 sr, &dr->origin, consfb->planemask); 488 if (sp->s_csr.csr_attributes & BOLD) { 489 dr->origin.x += 1; 490 fbbm_rop_write(consfb, &rommap, rommap.fm_offset, len, 491 sr, &dr->origin, consfb->planemask); 492 } 493 } else { 494 fbbm_rop_init(consfb, consfb->funcvec); 495 fbbm_rop_copy(consfb, sr, &dr->origin, 1, consfb->planemask); 496 if (sp->s_csr.csr_attributes & BOLD) { 497 dr->origin.x += 1; 498 fbbm_rop_copy(consfb, sr, &dr->origin, 1, consfb->planemask); 499 } 500 } 501 502 if (sp->s_csr.csr_attributes & USCORE) { 503 504 udr.origin.x = sp->s_csr.csr_p.x; 505 udr.origin.y = sp->s_csr.csr_p.y + ul_pos; 506 udr.extent.x = char_w; 507 udr.extent.y = 1; 508 509 setropfunc(BF_S, 1, fcolor, bcolor); 510 fbbm_rop_cinit(consfb, consfb->planemask, 1); 511 fbbm_rop_clear(consfb, &udr); 512 } 513 unlock_bitmap(); 514 } 515 516 vt_flush(spc) 517 struct cursor *spc; 518 { 519 register char *f_addr; 520 register int len; 521 register lRectangle *sr, *dr; 522 lRectangle fr, cr; 523 register int i; 524 register unsigned int c; 525 lRectangle udr; 526 register char **fnt_addr; 527 char *oldf_addr = (char *)-1; 528 extern struct fb_map rommap; 529 530 if (fp == 0) 531 return; 532 533 cursor_off(); 534 535 lock_bitmap(); 536 537 if (consfb->font_h == 24) 538 fnt_addr = ext_fnt24_addr; 539 else 540 fnt_addr = ext_fnt_addr; 541 542 udr.origin = fpp; 543 udr.extent.x = fpn * char_w; 544 udr.extent.y = char_h; 545 546 setropfunc(BF_S, 0, fcolor, bcolor); 547 fbbm_rop_cinit(consfb, consfb->planemask, 0); 548 fbbm_rop_clear(consfb, &udr); 549 550 if (fpa & BOLD) 551 setropfunc(BF_S, 1, fcolor, bcolor); 552 else 553 setropfunc(BF_S, 0, fcolor, bcolor); 554 555 fbbm_rop_winit(consfb); 556 557 sr = &fr; 558 dr = &cr; 559 sr->origin.x = 0; 560 sr->origin.y = 0; 561 sr->extent.y = font_h; 562 dr->origin.x = fpp.x; 563 dr->origin.y = fpp.y + ch_pos; 564 565 for (i = 0; i < fp; i++) { 566 c = fbuf[i]; 567 568 sr->extent.x = font_w; 569 dr->extent.x = char_w; 570 571 if (c & 0xff00) { 572 /* 573 * KANJI code... kanji char 574 */ 575 sr->extent.x = font_r2.extent.x; 576 dr->extent.x = char_r2.extent.x; 577 len = font_len2; 578 f_addr = (char *)fbbm_Krom_addr(consfb, c, sr); 579 #ifdef CPU_DOUBLE 580 } else if (fnt_addr == 0) { 581 /* 582 * no external fonts... try to use ROM fonts 583 */ 584 sr->extent.x = font_r1.extent.x; /*XXX*/ 585 dr->extent.x = char_r1.extent.x; /*XXX*/ 586 len = font_len2; 587 f_addr = (char *)fbbm_Krom_addr(consfb, c, sr); 588 #endif 589 #ifdef KM_ASCII 590 } else if (tmode == KM_ASCII) { 591 /* 592 * terminal mode is ASCII... ASCII (ISO) char 593 */ 594 len = font_len1; 595 if ((c >= 0x20) && (c <= 0x7e)) { 596 /* 597 * ASCII char 598 */ 599 f_addr = fnt_addr[c]; 600 } else if ((c >= 0xa0) && (c <= 0xff)) { 601 /* 602 * ISO char 603 */ 604 f_addr = fnt_addr[c - 32]; 605 } else { 606 /* 607 * UNKNOWN char 608 */ 609 f_addr = (caddr_t)zero; 610 } 611 #endif /* KM_ASCII */ 612 } else { 613 /* 614 * terminal mode is not ASCII... JIS, SJIS, EUC, ... 615 */ 616 len = font_len1; 617 if ((c >= 0x20) && (c <= 0x7e)) { 618 /* 619 * ASCII char 620 */ 621 f_addr = fnt_addr[c]; 622 } else if ((c >= 0xa1) && (c <= 0xdf)) { 623 /* 624 * KANA char 625 */ 626 f_addr = fnt_addr[c + 64]; 627 } else { 628 /* 629 * UNKNOWN char 630 */ 631 f_addr = (caddr_t)zero; 632 } 633 } 634 635 if (f_addr != 0) { 636 if (oldf_addr == 0) 637 fbbm_rop_winit(consfb); 638 639 rommap.fm_vaddr = f_addr; 640 rommap.fm_offset = 0; 641 fbbm_rop_write(consfb, &rommap, rommap.fm_offset, len, 642 sr, &dr->origin, consfb->planemask); 643 if (fpa & BOLD) { 644 /* 645 * Bold char 646 */ 647 dr->origin.x += 1; 648 fbbm_rop_write(consfb, &rommap, 649 rommap.fm_offset, len, 650 sr, &dr->origin, consfb->planemask); 651 dr->origin.x -= 1; 652 } 653 } else { 654 if (oldf_addr != 0) 655 fbbm_rop_init(consfb, consfb->funcvec); 656 657 fbbm_rop_copy(consfb, sr, &dr->origin, 1, consfb->planemask); 658 if (fpa & BOLD) { 659 /* 660 * Bold char 661 */ 662 dr->origin.x += 1; 663 fbbm_rop_copy(consfb, sr, &dr->origin, 664 1, consfb->planemask); 665 dr->origin.x -= 1; 666 } 667 668 } 669 dr->origin.x += dr->extent.x; 670 oldf_addr = f_addr; 671 672 /* 673 * sr->origin.x and sr->origin.y were changed by 674 * fbpop_Krom_addr(), fb254_Krom_addr(). 675 */ 676 sr->origin.x = 0; 677 sr->origin.y = 0; 678 } 679 680 if (fpa & USCORE) { 681 udr.origin.y += ul_pos; 682 udr.extent.y = 1; 683 684 setropfunc(BF_S, 1, fcolor, bcolor); 685 fbbm_rop_cinit(consfb, consfb->planemask, 1); 686 fbbm_rop_clear(consfb, &udr); 687 } 688 fp = 0; 689 690 unlock_bitmap(); 691 692 dr->origin.y -= ch_pos; 693 cursor_on(&(spc->csr_p)); 694 } 695