vidc20config.c revision 1.14
1 /* $NetBSD: vidc20config.c,v 1.14 2002/09/27 15:35:46 provos Exp $ */ 2 3 /* 4 * Copyright (c) 2001 Reinoud Zandijk 5 * Copyright (c) 1996 Mark Brinicombe 6 * Copyright (c) 1996 Robert Black 7 * Copyright (c) 1994-1995 Melvyn Tang-Richardson 8 * Copyright (c) 1994-1995 RiscBSD kernel team 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the RiscBSD kernel team 22 * 4. The name of the company nor the name of the author may be used to 23 * endorse or promote products derived from this software without specific 24 * prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE RISCBSD TEAM ``AS IS'' AND ANY EXPRESS 27 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 28 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE 30 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 36 * THE POSSIBILITY OF SUCH DAMAGE. 37 * 38 * NetBSD kernel project 39 * 40 * vidcvideo.c 41 * 42 * This file is the lower basis of the wscons driver for VIDC based ARM machines. 43 * It features the initialisation and all VIDC writing and keeps in internal state 44 * copy. 45 * Its currenly set up as a library file and not as a device; it could be named 46 * vidcvideo0 eventually. 47 */ 48 49 #include <sys/cdefs.h> 50 51 __KERNEL_RCSID(0, "$NetBSD: vidc20config.c,v 1.14 2002/09/27 15:35:46 provos Exp $"); 52 53 #include <sys/types.h> 54 #include <sys/param.h> 55 #include <arm/iomd/vidc.h> 56 #include <arm/arm32/katelib.h> 57 #include <machine/bootconfig.h> 58 #include <machine/intr.h> 59 60 #include <sys/systm.h> 61 #include <sys/device.h> 62 #include <uvm/uvm_extern.h> 63 64 #include <arm/iomd/iomdreg.h> 65 #include <arm/iomd/iomdvar.h> 66 #include <arm/iomd/vidc20config.h> 67 68 69 /* 70 * A structure containing ALL the information required to restore 71 * the VIDC20 to any given state. ALL vidc transactions should 72 * go through these procedures, which record the vidc's state. 73 * it may be an idea to set the permissions of the vidc base address 74 * so we get a fault, so the fault routine can record the state but 75 * I guess that's not really necessary for the time being, since we 76 * can make the kernel more secure later on. Also, it is possible 77 * to write a routine to allow 'reading' of the vidc registers. 78 */ 79 80 static struct vidc_state vidc_lookup = { 81 { 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 82 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 83 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 84 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 85 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 86 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 87 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 88 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0 89 }, 90 91 VIDC_PALREG, 92 VIDC_BCOL, 93 VIDC_CP1 , 94 VIDC_CP2, 95 VIDC_CP3, 96 VIDC_HCR, 97 VIDC_HSWR, 98 VIDC_HBSR, 99 VIDC_HDSR, 100 VIDC_HDER, 101 VIDC_HBER, 102 VIDC_HCSR, 103 VIDC_HIR, 104 VIDC_VCR, 105 VIDC_VSWR, 106 VIDC_VBSR, 107 VIDC_VDSR, 108 VIDC_VDER, 109 VIDC_VBER, 110 VIDC_VCSR, 111 VIDC_VCER, 112 VIDC_EREG, 113 VIDC_FSYNREG, 114 VIDC_CONREG, 115 VIDC_DCTL 116 }; 117 118 struct vidc_state vidc_current[1]; 119 120 121 /* 122 * XXX global display variables XXX ... should be a structure 123 */ 124 static int cold_init = 0; /* flags initialisation */ 125 extern videomemory_t videomemory; 126 127 static struct vidc_mode vidc_initialmode; 128 static struct vidc_mode *vidc_currentmode; 129 130 unsigned int dispstart; 131 unsigned int dispsize; 132 unsigned int dispbase; 133 unsigned int dispend; 134 unsigned int ptov; 135 unsigned int vmem_base; 136 unsigned int phys_base; 137 unsigned int transfersize; 138 139 140 /* cursor stuff */ 141 char *cursor_normal; 142 char *cursor_transparent; 143 int p_cursor_normal; 144 int p_cursor_transparent; 145 int cursor_width; 146 int cursor_height; 147 148 149 /* 150 * VIDC mode definitions 151 * generated from RISC OS mode definition file by an `awk' script 152 */ 153 extern struct vidc_mode vidcmodes[]; 154 155 156 /* 157 * configuration printing 158 * 159 */ 160 161 void 162 vidcvideo_printdetails(void) 163 { 164 printf(": refclk=%dMHz %dKB %s ", (vidc_fref / 1000000), 165 videomemory.vidm_size / 1024, 166 (videomemory.vidm_type == VIDEOMEM_TYPE_VRAM) ? "VRAM" : "DRAM"); 167 } 168 169 170 /* 171 * Common functions to directly access VIDC registers 172 */ 173 int 174 vidcvideo_write(reg, value) 175 u_int reg; 176 int value; 177 { 178 int counter; 179 180 int *current; 181 int *tab; 182 183 tab = (int *)&vidc_lookup; 184 current = (int *)vidc_current; 185 186 187 /* 188 * OK, the VIDC_PALETTE register is handled differently 189 * to the others on the VIDC, so take that into account here 190 */ 191 if (reg==VIDC_PALREG) { 192 vidc_current->palreg = 0; 193 WriteWord(vidc_base, reg | value); 194 return 0; 195 } 196 197 if (reg==VIDC_PALETTE) { 198 WriteWord(vidc_base, reg | value); 199 vidc_current->palette[vidc_current->palreg] = value; 200 vidc_current->palreg++; 201 vidc_current->palreg = vidc_current->palreg & 0xff; 202 return 0; 203 } 204 205 /* 206 * Undefine SAFER if you wish to speed things up (a little) 207 * although this means the function will assume things abou 208 * the structure of vidc_state. i.e. the first 256 words are 209 * the palette array 210 */ 211 212 #define SAFER 213 214 #ifdef SAFER 215 #define INITVALUE 0 216 #else 217 #define INITVALUE 256 218 #endif 219 220 for ( counter=INITVALUE; counter<= sizeof(struct vidc_state); counter++ ) { 221 if ( reg==tab[counter] ) { 222 WriteWord ( vidc_base, reg | value ); 223 current[counter] = value; 224 return 0; 225 } 226 } 227 return -1; 228 } 229 230 231 void 232 vidcvideo_setpalette(vidc) 233 struct vidc_state *vidc; 234 { 235 int counter = 0; 236 237 vidcvideo_write(VIDC_PALREG, 0x00000000); 238 for (counter = 0; counter < 255; counter++) 239 vidcvideo_write(VIDC_PALETTE, vidc->palette[counter]); 240 } 241 242 243 void 244 vidcvideo_setstate(vidc) 245 struct vidc_state *vidc; 246 { 247 vidcvideo_write ( VIDC_PALREG, vidc->palreg ); 248 vidcvideo_write ( VIDC_BCOL, vidc->bcol ); 249 vidcvideo_write ( VIDC_CP1, vidc->cp1 ); 250 vidcvideo_write ( VIDC_CP2, vidc->cp2 ); 251 vidcvideo_write ( VIDC_CP3, vidc->cp3 ); 252 vidcvideo_write ( VIDC_HCR, vidc->hcr ); 253 vidcvideo_write ( VIDC_HSWR, vidc->hswr ); 254 vidcvideo_write ( VIDC_HBSR, vidc->hbsr ); 255 vidcvideo_write ( VIDC_HDSR, vidc->hdsr ); 256 vidcvideo_write ( VIDC_HDER, vidc->hder ); 257 vidcvideo_write ( VIDC_HBER, vidc->hber ); 258 vidcvideo_write ( VIDC_HCSR, vidc->hcsr ); 259 vidcvideo_write ( VIDC_HIR, vidc->hir ); 260 vidcvideo_write ( VIDC_VCR, vidc->vcr ); 261 vidcvideo_write ( VIDC_VSWR, vidc->vswr ); 262 vidcvideo_write ( VIDC_VBSR, vidc->vbsr ); 263 vidcvideo_write ( VIDC_VDSR, vidc->vdsr ); 264 vidcvideo_write ( VIDC_VDER, vidc->vder ); 265 vidcvideo_write ( VIDC_VBER, vidc->vber ); 266 vidcvideo_write ( VIDC_VCSR, vidc->vcsr ); 267 vidcvideo_write ( VIDC_VCER, vidc->vcer ); 268 /* 269 * Right, dunno what to set these to yet, but let's keep RiscOS's 270 * ones for now, until the time is right to finish this code 271 */ 272 273 /* vidcvideo_write ( VIDC_EREG, vidc->ereg ); */ 274 /* vidcvideo_write ( VIDC_FSYNREG, vidc->fsynreg ); */ 275 /* vidcvideo_write ( VIDC_CONREG, vidc->conreg ); */ 276 /* vidcvideo_write ( VIDC_DCTL, vidc->dctl ); */ 277 278 } 279 280 281 void 282 vidcvideo_getstate(vidc) 283 struct vidc_state *vidc; 284 { 285 *vidc = *vidc_current; 286 } 287 288 289 void 290 vidcvideo_getmode(mode) 291 struct vidc_mode *mode; 292 { 293 *mode = *vidc_currentmode; 294 } 295 296 297 static int 298 vidcvideo_coldinit(void) 299 { 300 int found; 301 int loop; 302 303 /* Blank out the cursor */ 304 305 vidcvideo_write(VIDC_CP1, 0x0); 306 vidcvideo_write(VIDC_CP2, 0x0); 307 vidcvideo_write(VIDC_CP3, 0x0); 308 309 /* Try to determine the current mode */ 310 vidc_initialmode.hder = bootconfig.width+1; 311 vidc_initialmode.vder = bootconfig.height+1; 312 vidc_initialmode.log2_bpp = bootconfig.log2_bpp; 313 314 dispbase = vmem_base = dispstart = videomemory.vidm_vbase; 315 phys_base = videomemory.vidm_pbase; 316 317 /* Nut - should be using videomemory.vidm_size - mark */ 318 if (videomemory.vidm_type == VIDEOMEM_TYPE_DRAM) { 319 dispsize = videomemory.vidm_size; 320 transfersize = 16; 321 } else { 322 dispsize = bootconfig.vram[0].pages * NBPG; 323 transfersize = dispsize >> 10; 324 }; 325 326 ptov = dispbase - phys_base; 327 328 dispend = dispstart+dispsize; 329 330 /* try to find the current mode from the bootloader in my table */ 331 vidc_currentmode = &vidcmodes[0]; 332 loop = 0; 333 found = 0; 334 while (vidcmodes[loop].pixel_rate != 0) { 335 if (vidcmodes[loop].hder == (bootconfig.width + 1) 336 && vidcmodes[loop].vder == (bootconfig.height + 1) 337 && vidcmodes[loop].frame_rate == bootconfig.framerate) { 338 vidc_currentmode = &vidcmodes[loop]; 339 found = 1; 340 } 341 ++loop; 342 } 343 344 /* if not found choose first mode but dont be picky on the framerate */ 345 if (!found) { 346 vidc_currentmode = &vidcmodes[0]; 347 loop = 0; 348 found = 0; 349 350 while (vidcmodes[loop].pixel_rate != 0) { 351 if (vidcmodes[loop].hder == (bootconfig.width + 1) 352 && vidcmodes[loop].vder == (bootconfig.height + 1)) { 353 vidc_currentmode = &vidcmodes[loop]; 354 found = 1; 355 } 356 ++loop; 357 } 358 } 359 360 vidc_currentmode->log2_bpp = bootconfig.log2_bpp; 361 362 dispstart = dispbase; 363 dispend = dispstart+dispsize; 364 365 IOMD_WRITE_WORD(IOMD_VIDINIT, dispstart-ptov); 366 IOMD_WRITE_WORD(IOMD_VIDSTART, dispstart-ptov); 367 IOMD_WRITE_WORD(IOMD_VIDEND, (dispend-transfersize)-ptov); 368 return 0; 369 } 370 371 372 /* simple function to abstract vidc variables ; returns virt start address of screen */ 373 /* XXX asumption that video memory is mapped in twice */ 374 void *vidcvideo_hwscroll(int bytes) { 375 dispstart += bytes; 376 if (dispstart >= dispbase + dispsize) dispstart -= dispsize; 377 if (dispstart < dispbase) dispstart += dispsize; 378 dispend = dispstart+dispsize; 379 380 /* return the start of the bit map of the screen (left top) */ 381 return (void *) dispstart; 382 } 383 384 385 /* reset the HW scroll to be at the start for the benefit of f.e. X */ 386 void *vidcvideo_hwscroll_reset(void) { 387 void *cookie = (void *) dispstart; 388 389 dispstart = dispbase; 390 dispend = dispstart + dispsize; 391 return cookie; 392 } 393 394 395 /* put HW scroll back to where it was */ 396 void *vidcvideo_hwscroll_back(void *cookie) { 397 dispstart = (int) cookie; 398 dispend = dispstart + dispsize; 399 return cookie; 400 } 401 402 403 /* this function is to be called perferably at vsync */ 404 void vidcvideo_progr_scroll(void) { 405 IOMD_WRITE_WORD(IOMD_VIDINIT, dispstart-ptov); 406 IOMD_WRITE_WORD(IOMD_VIDSTART, dispstart-ptov); 407 IOMD_WRITE_WORD(IOMD_VIDEND, (dispend-transfersize)-ptov); 408 } 409 410 411 /* 412 * Select a new mode by reprogramming the VIDC chip 413 * XXX this part is known not to work for 32bpp 414 */ 415 416 struct vidc_mode newmode; 417 418 static const int bpp_mask_table[] = { 419 0, /* 1bpp */ 420 1, /* 2bpp */ 421 2, /* 4bpp */ 422 3, /* 8bpp */ 423 4, /* 16bpp */ 424 6 /* 32bpp */ 425 }; 426 427 428 void 429 vidcvideo_setmode(struct vidc_mode *mode) 430 { 431 register int acc; 432 int bpp_mask; 433 int ereg; 434 int best_r, best_v; 435 int least_error; 436 int r, v, f; 437 438 /* 439 * Find out what bit mask we need to or with the vidc20 control register 440 * in order to generate the desired number of bits per pixel. 441 * log_bpp is log base 2 of the number of bits per pixel. 442 */ 443 444 bpp_mask = bpp_mask_table[mode->log2_bpp]; 445 446 newmode = *mode; 447 vidc_currentmode = &newmode; 448 449 least_error = INT_MAX; 450 best_r = 0; best_v = 0; 451 452 for (v = 63; v > 0; v--) { 453 for (r = 63; r > 0; r--) { 454 f = ((v * vidc_fref) /1000) / r; 455 if (least_error >= 456 abs(f - vidc_currentmode->pixel_rate)) { 457 least_error = 458 abs(f - vidc_currentmode->pixel_rate); 459 best_r = r; 460 best_v = v; 461 } 462 } 463 } 464 465 if (best_r > 63) best_r=63; 466 if (best_v > 63) best_v=63; 467 if (best_r < 1) best_r= 1; 468 if (best_v < 1) best_v= 1; 469 470 vidcvideo_write(VIDC_FSYNREG, (best_v-1)<<8 | (best_r-1)<<0); 471 472 acc=0; 473 acc+=vidc_currentmode->hswr; vidcvideo_write(VIDC_HSWR, (acc - 8 ) & (~1)); 474 acc+=vidc_currentmode->hbsr; vidcvideo_write(VIDC_HBSR, (acc - 12) & (~1)); 475 acc+=vidc_currentmode->hdsr; vidcvideo_write(VIDC_HDSR, (acc - 18) & (~1)); 476 acc+=vidc_currentmode->hder; vidcvideo_write(VIDC_HDER, (acc - 18) & (~1)); 477 acc+=vidc_currentmode->hber; vidcvideo_write(VIDC_HBER, (acc - 12) & (~1)); 478 acc+=vidc_currentmode->hcr; vidcvideo_write(VIDC_HCR, (acc - 8 ) & (~3)); 479 480 acc=0; 481 acc+=vidc_currentmode->vswr; vidcvideo_write(VIDC_VSWR, (acc - 1)); 482 acc+=vidc_currentmode->vbsr; vidcvideo_write(VIDC_VBSR, (acc - 1)); 483 acc+=vidc_currentmode->vdsr; vidcvideo_write(VIDC_VDSR, (acc - 1)); 484 acc+=vidc_currentmode->vder; vidcvideo_write(VIDC_VDER, (acc - 1)); 485 acc+=vidc_currentmode->vber; vidcvideo_write(VIDC_VBER, (acc - 1)); 486 acc+=vidc_currentmode->vcr; vidcvideo_write(VIDC_VCR, (acc - 1)); 487 488 IOMD_WRITE_WORD(IOMD_FSIZE, vidc_currentmode->vcr 489 + vidc_currentmode->vswr 490 + vidc_currentmode->vber 491 + vidc_currentmode->vbsr - 1); 492 493 if (dispsize <= 1024*1024) 494 vidcvideo_write(VIDC_DCTL, vidc_currentmode->hder>>2 | 1<<16 | 1<<12); 495 else 496 vidcvideo_write(VIDC_DCTL, vidc_currentmode->hder>>2 | 3<<16 | 1<<12); 497 498 ereg = 1<<12; 499 if (vidc_currentmode->sync_pol & 0x01) 500 ereg |= 1<<16; 501 if (vidc_currentmode->sync_pol & 0x02) 502 ereg |= 1<<18; 503 vidcvideo_write(VIDC_EREG, ereg); 504 if (dispsize > 1024*1024) { 505 if (vidc_currentmode->hder >= 800) 506 vidcvideo_write(VIDC_CONREG, 7<<8 | bpp_mask<<5); 507 else 508 vidcvideo_write(VIDC_CONREG, 6<<8 | bpp_mask<<5); 509 } else { 510 vidcvideo_write(VIDC_CONREG, 7<<8 | bpp_mask<<5); 511 } 512 } 513 514 515 #if 0 516 /* not used for now */ 517 void 518 vidcvideo_set_display_base(base) 519 u_int base; 520 { 521 dispstart = dispstart-dispbase + base; 522 dispbase = vmem_base = base; 523 dispend = base + dispsize; 524 ptov = dispbase - phys_base; 525 } 526 #endif 527 528 529 /* 530 * Main initialisation routine for now 531 */ 532 533 static int cursor_init = 0; 534 535 int 536 vidcvideo_init(void) 537 { 538 vidcvideo_coldinit(); 539 if (cold_init && (cursor_init == 0)) 540 /* vidcvideo_flash_go() */; 541 542 /* setting a mode goes wrong in 32 bpp ... 8 and 16 seem OK */ 543 vidcvideo_setmode(vidc_currentmode); 544 vidcvideo_blank(0); /* display on */ 545 546 vidcvideo_stdpalette(); 547 548 if (cold_init == 0) { 549 vidcvideo_write(VIDC_CP1, 0x0); 550 vidcvideo_write(VIDC_CP2, 0x0); 551 vidcvideo_write(VIDC_CP3, 0x0); 552 } else { 553 vidcvideo_cursor_init(CURSOR_MAX_WIDTH, CURSOR_MAX_HEIGHT); 554 }; 555 556 cold_init=1; 557 return 0; 558 } 559 560 561 /* reinitialise the vidcvideo */ 562 void 563 vidcvideo_reinit() 564 { 565 vidcvideo_coldinit(); 566 vidcvideo_setmode(vidc_currentmode); 567 } 568 569 570 int 571 vidcvideo_cursor_init(int width, int height) 572 { 573 static char *cursor_data = NULL; 574 int counter; 575 int line; 576 paddr_t pa; 577 578 cursor_width = width; 579 cursor_height = height; 580 581 if (!cursor_data) { 582 /* Allocate cursor memory first time round */ 583 cursor_data = (char *)uvm_km_zalloc(kernel_map, NBPG); 584 if (!cursor_data) 585 panic("Cannot allocate memory for hardware cursor"); 586 (void) pmap_extract(pmap_kernel(), (vaddr_t)cursor_data, &pa); 587 IOMD_WRITE_WORD(IOMD_CURSINIT, pa); 588 } 589 590 /* Blank the cursor while initialising it's sprite */ 591 592 vidcvideo_write ( VIDC_CP1, 0x0 ); 593 vidcvideo_write ( VIDC_CP2, 0x0 ); 594 vidcvideo_write ( VIDC_CP3, 0x0 ); 595 596 cursor_normal = cursor_data; 597 cursor_transparent = cursor_data + (height * width); 598 599 cursor_transparent += 32; /* ALIGN */ 600 cursor_transparent = (char *)((int)cursor_transparent & (~31) ); 601 602 for ( line = 0; line<height; ++ line ) 603 { 604 for ( counter=0; counter<width/4;counter++ ) 605 cursor_normal[line * width + counter]=0x55; /* why 0x55 ? */ 606 for ( ; counter<8; counter++ ) 607 cursor_normal[line * width + counter]=0; 608 } 609 610 for ( line = 0; line<height; ++ line ) 611 { 612 for ( counter=0; counter<width/4;counter++ ) 613 cursor_transparent[line * width + counter]=0x00; 614 for ( ; counter<8; counter++ ) 615 cursor_transparent[line * width + counter]=0; 616 } 617 618 619 (void) pmap_extract(pmap_kernel(), (vaddr_t)cursor_normal, 620 (paddr_t *)&p_cursor_normal); 621 (void) pmap_extract(pmap_kernel(), (vaddr_t)cursor_transparent, 622 (paddr_t *)&p_cursor_transparent); 623 624 memset ( cursor_normal, 0x55, width*height ); /* white? */ 625 memset ( cursor_transparent, 0x00, width*height ); /* to see the diffence */ 626 627 /* Ok, now program the cursor; should be blank */ 628 vidcvideo_enablecursor(0); 629 630 return 0; 631 } 632 633 634 void 635 vidcvideo_updatecursor(xcur, ycur) 636 int xcur, ycur; 637 { 638 int frontporch = vidc_currentmode->hswr + vidc_currentmode->hbsr + vidc_currentmode->hdsr; 639 int topporch = vidc_currentmode->vswr + vidc_currentmode->vbsr + vidc_currentmode->vdsr; 640 641 vidcvideo_write(VIDC_HCSR, frontporch -17 + xcur); 642 vidcvideo_write(VIDC_VCSR, topporch -2 + (ycur+1)-2 + 3 - cursor_height); 643 vidcvideo_write(VIDC_VCER, topporch -2 + (ycur+3)+2 + 3 ); 644 return; 645 } 646 647 648 void 649 vidcvideo_enablecursor(on) 650 int on; 651 { 652 if (on) { 653 IOMD_WRITE_WORD(IOMD_CURSINIT,p_cursor_normal); 654 } else { 655 IOMD_WRITE_WORD(IOMD_CURSINIT,p_cursor_transparent); 656 }; 657 vidcvideo_write ( VIDC_CP1, 0xffffff ); /* enable */ 658 659 return; 660 } 661 662 663 void 664 vidcvideo_stdpalette() 665 { 666 int i; 667 668 switch (vidc_currentmode->log2_bpp) { 669 case 0: /* 1 bpp */ 670 case 1: /* 2 bpp */ 671 case 2: /* 4 bpp */ 672 case 3: /* 8 bpp */ 673 vidcvideo_write(VIDC_PALREG, 0x00000000); 674 vidcvideo_write(VIDC_PALETTE, VIDC_COL( 0, 0, 0)); 675 vidcvideo_write(VIDC_PALETTE, VIDC_COL(255, 0, 0)); 676 vidcvideo_write(VIDC_PALETTE, VIDC_COL( 0, 255, 0)); 677 vidcvideo_write(VIDC_PALETTE, VIDC_COL(255, 255, 0)); 678 vidcvideo_write(VIDC_PALETTE, VIDC_COL( 0, 0, 255)); 679 vidcvideo_write(VIDC_PALETTE, VIDC_COL(255, 0, 255)); 680 vidcvideo_write(VIDC_PALETTE, VIDC_COL( 0, 255, 255)); 681 vidcvideo_write(VIDC_PALETTE, VIDC_COL(255, 255, 255)); 682 vidcvideo_write(VIDC_PALETTE, VIDC_COL(128, 128, 128)); 683 vidcvideo_write(VIDC_PALETTE, VIDC_COL(255, 128, 128)); 684 vidcvideo_write(VIDC_PALETTE, VIDC_COL(128, 255, 128)); 685 vidcvideo_write(VIDC_PALETTE, VIDC_COL(255, 255, 128)); 686 vidcvideo_write(VIDC_PALETTE, VIDC_COL(128, 128, 255)); 687 vidcvideo_write(VIDC_PALETTE, VIDC_COL(255, 128, 255)); 688 vidcvideo_write(VIDC_PALETTE, VIDC_COL(255, 255, 255)); 689 break; 690 case 4: /* 16 bpp */ 691 /* 692 * The use of the palette in 16-bit modes is quite 693 * fun. Comments in linux/drivers/video/acornfb.c 694 * imply that it goes something like this: 695 * 696 * red = LUT[pixel[7:0]].red 697 * green = LUT[pixel[11:4]].green 698 * blue = LUT[pixel[15:8]].blue 699 * 700 * We use 6:5:5 R:G:B cos that's what Xarm32VIDC wants. 701 */ 702 #define RBITS 6 703 #define GBITS 5 704 #define BBITS 5 705 vidcvideo_write(VIDC_PALREG, 0x00000000); 706 for (i = 0; i < 256; i++) { 707 int r, g, b; 708 709 r = i & ((1 << RBITS) - 1); 710 g = (i >> (RBITS - 4)) & ((1 << GBITS) - 1); 711 b = (i >> (RBITS + GBITS - 8)) & ((1 << BBITS) - 1); 712 vidcvideo_write(VIDC_PALETTE, 713 VIDC_COL(r << (8 - RBITS) | r >> (2 * RBITS - 8), 714 g << (8 - GBITS) | g >> (2 * GBITS - 8), 715 b << (8 - BBITS) | b >> (2 * BBITS - 8))); 716 } 717 break; 718 case 5: /* 32 bpp */ 719 vidcvideo_write(VIDC_PALREG, 0x00000000); 720 for (i = 0; i < 256; i++) 721 vidcvideo_write(VIDC_PALETTE, VIDC_COL(i, i, i)); 722 break; 723 } 724 725 } 726 727 int 728 vidcvideo_blank(video_off) 729 int video_off; 730 { 731 int ereg; 732 733 ereg = 1<<12; 734 if (vidc_currentmode->sync_pol & 0x01) 735 ereg |= 1<<16; 736 if (vidc_currentmode->sync_pol & 0x02) 737 ereg |= 1<<18; 738 739 if (!video_off) { 740 vidcvideo_write(VIDC_EREG, ereg); 741 } else { 742 vidcvideo_write(VIDC_EREG, 0); 743 }; 744 return 0; 745 } 746 747 /* end of vidc20config.c */ 748
Indexes created Fri Sep 26 08:10:20 GMT 2025