blizzard.c (30026B)
1 /* 2 * Epson S1D13744/S1D13745 (Blizzard/Hailstorm/Tornado) LCD/TV controller. 3 * 4 * Copyright (C) 2008 Nokia Corporation 5 * Written by Andrzej Zaborowski <andrew@openedhand.com> 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License as 9 * published by the Free Software Foundation; either version 2 or 10 * (at your option) version 3 of the License. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License along 18 * with this program; if not, see <http://www.gnu.org/licenses/>. 19 */ 20 21 #include "qemu/osdep.h" 22 #include "qemu/bitops.h" 23 #include "ui/console.h" 24 #include "hw/display/blizzard.h" 25 #include "ui/pixel_ops.h" 26 27 typedef void (*blizzard_fn_t)(uint8_t *, const uint8_t *, unsigned int); 28 29 typedef struct { 30 uint8_t reg; 31 uint32_t addr; 32 int swallow; 33 34 int pll; 35 int pll_range; 36 int pll_ctrl; 37 uint8_t pll_mode; 38 uint8_t clksel; 39 int memenable; 40 int memrefresh; 41 uint8_t timing[3]; 42 int priority; 43 44 uint8_t lcd_config; 45 int x; 46 int y; 47 int skipx; 48 int skipy; 49 uint8_t hndp; 50 uint8_t vndp; 51 uint8_t hsync; 52 uint8_t vsync; 53 uint8_t pclk; 54 uint8_t u; 55 uint8_t v; 56 uint8_t yrc[2]; 57 int ix[2]; 58 int iy[2]; 59 int ox[2]; 60 int oy[2]; 61 62 int enable; 63 int blank; 64 int bpp; 65 int invalidate; 66 int mx[2]; 67 int my[2]; 68 uint8_t mode; 69 uint8_t effect; 70 uint8_t iformat; 71 uint8_t source; 72 QemuConsole *con; 73 blizzard_fn_t *line_fn_tab[2]; 74 void *fb; 75 76 uint8_t hssi_config[3]; 77 uint8_t tv_config; 78 uint8_t tv_timing[4]; 79 uint8_t vbi; 80 uint8_t tv_x; 81 uint8_t tv_y; 82 uint8_t tv_test; 83 uint8_t tv_filter_config; 84 uint8_t tv_filter_idx; 85 uint8_t tv_filter_coeff[0x20]; 86 uint8_t border_r; 87 uint8_t border_g; 88 uint8_t border_b; 89 uint8_t gamma_config; 90 uint8_t gamma_idx; 91 uint8_t gamma_lut[0x100]; 92 uint8_t matrix_ena; 93 uint8_t matrix_coeff[0x12]; 94 uint8_t matrix_r; 95 uint8_t matrix_g; 96 uint8_t matrix_b; 97 uint8_t pm; 98 uint8_t status; 99 uint8_t rgbgpio_dir; 100 uint8_t rgbgpio; 101 uint8_t gpio_dir; 102 uint8_t gpio; 103 uint8_t gpio_edge[2]; 104 uint8_t gpio_irq; 105 uint8_t gpio_pdown; 106 107 struct { 108 int x; 109 int y; 110 int dx; 111 int dy; 112 int len; 113 int buflen; 114 void *buf; 115 void *data; 116 uint16_t *ptr; 117 int angle; 118 int pitch; 119 blizzard_fn_t line_fn; 120 } data; 121 } BlizzardState; 122 123 /* Bytes(!) per pixel */ 124 static const int blizzard_iformat_bpp[0x10] = { 125 0, 126 2, /* RGB 5:6:5*/ 127 3, /* RGB 6:6:6 mode 1 */ 128 3, /* RGB 8:8:8 mode 1 */ 129 0, 0, 130 4, /* RGB 6:6:6 mode 2 */ 131 4, /* RGB 8:8:8 mode 2 */ 132 0, /* YUV 4:2:2 */ 133 0, /* YUV 4:2:0 */ 134 0, 0, 0, 0, 0, 0, 135 }; 136 137 static void blizzard_window(BlizzardState *s) 138 { 139 DisplaySurface *surface = qemu_console_surface(s->con); 140 uint8_t *src, *dst; 141 int bypp[2]; 142 int bypl[3]; 143 int y; 144 blizzard_fn_t fn = s->data.line_fn; 145 146 if (!fn) 147 return; 148 if (s->mx[0] > s->data.x) 149 s->mx[0] = s->data.x; 150 if (s->my[0] > s->data.y) 151 s->my[0] = s->data.y; 152 if (s->mx[1] < s->data.x + s->data.dx) 153 s->mx[1] = s->data.x + s->data.dx; 154 if (s->my[1] < s->data.y + s->data.dy) 155 s->my[1] = s->data.y + s->data.dy; 156 157 bypp[0] = s->bpp; 158 bypp[1] = surface_bytes_per_pixel(surface); 159 bypl[0] = bypp[0] * s->data.pitch; 160 bypl[1] = bypp[1] * s->x; 161 bypl[2] = bypp[0] * s->data.dx; 162 163 src = s->data.data; 164 dst = s->fb + bypl[1] * s->data.y + bypp[1] * s->data.x; 165 for (y = s->data.dy; y > 0; y --, src += bypl[0], dst += bypl[1]) 166 fn(dst, src, bypl[2]); 167 } 168 169 static int blizzard_transfer_setup(BlizzardState *s) 170 { 171 if (s->source > 3 || !s->bpp || 172 s->ix[1] < s->ix[0] || s->iy[1] < s->iy[0]) 173 return 0; 174 175 s->data.angle = s->effect & 3; 176 s->data.line_fn = s->line_fn_tab[!!s->data.angle][s->iformat]; 177 s->data.x = s->ix[0]; 178 s->data.y = s->iy[0]; 179 s->data.dx = s->ix[1] - s->ix[0] + 1; 180 s->data.dy = s->iy[1] - s->iy[0] + 1; 181 s->data.len = s->bpp * s->data.dx * s->data.dy; 182 s->data.pitch = s->data.dx; 183 if (s->data.len > s->data.buflen) { 184 s->data.buf = g_realloc(s->data.buf, s->data.len); 185 s->data.buflen = s->data.len; 186 } 187 s->data.ptr = s->data.buf; 188 s->data.data = s->data.buf; 189 s->data.len /= 2; 190 return 1; 191 } 192 193 static void blizzard_reset(BlizzardState *s) 194 { 195 s->reg = 0; 196 s->swallow = 0; 197 198 s->pll = 9; 199 s->pll_range = 1; 200 s->pll_ctrl = 0x14; 201 s->pll_mode = 0x32; 202 s->clksel = 0x00; 203 s->memenable = 0; 204 s->memrefresh = 0x25c; 205 s->timing[0] = 0x3f; 206 s->timing[1] = 0x13; 207 s->timing[2] = 0x21; 208 s->priority = 0; 209 210 s->lcd_config = 0x74; 211 s->x = 8; 212 s->y = 1; 213 s->skipx = 0; 214 s->skipy = 0; 215 s->hndp = 3; 216 s->vndp = 2; 217 s->hsync = 1; 218 s->vsync = 1; 219 s->pclk = 0x80; 220 221 s->ix[0] = 0; 222 s->ix[1] = 0; 223 s->iy[0] = 0; 224 s->iy[1] = 0; 225 s->ox[0] = 0; 226 s->ox[1] = 0; 227 s->oy[0] = 0; 228 s->oy[1] = 0; 229 230 s->yrc[0] = 0x00; 231 s->yrc[1] = 0x30; 232 s->u = 0; 233 s->v = 0; 234 235 s->iformat = 3; 236 s->source = 0; 237 s->bpp = blizzard_iformat_bpp[s->iformat]; 238 239 s->hssi_config[0] = 0x00; 240 s->hssi_config[1] = 0x00; 241 s->hssi_config[2] = 0x01; 242 s->tv_config = 0x00; 243 s->tv_timing[0] = 0x00; 244 s->tv_timing[1] = 0x00; 245 s->tv_timing[2] = 0x00; 246 s->tv_timing[3] = 0x00; 247 s->vbi = 0x10; 248 s->tv_x = 0x14; 249 s->tv_y = 0x03; 250 s->tv_test = 0x00; 251 s->tv_filter_config = 0x80; 252 s->tv_filter_idx = 0x00; 253 s->border_r = 0x10; 254 s->border_g = 0x80; 255 s->border_b = 0x80; 256 s->gamma_config = 0x00; 257 s->gamma_idx = 0x00; 258 s->matrix_ena = 0x00; 259 memset(&s->matrix_coeff, 0, sizeof(s->matrix_coeff)); 260 s->matrix_r = 0x00; 261 s->matrix_g = 0x00; 262 s->matrix_b = 0x00; 263 s->pm = 0x02; 264 s->status = 0x00; 265 s->rgbgpio_dir = 0x00; 266 s->gpio_dir = 0x00; 267 s->gpio_edge[0] = 0x00; 268 s->gpio_edge[1] = 0x00; 269 s->gpio_irq = 0x00; 270 s->gpio_pdown = 0xff; 271 } 272 273 static inline void blizzard_invalidate_display(void *opaque) { 274 BlizzardState *s = (BlizzardState *) opaque; 275 276 s->invalidate = 1; 277 } 278 279 static uint16_t blizzard_reg_read(void *opaque, uint8_t reg) 280 { 281 BlizzardState *s = (BlizzardState *) opaque; 282 283 switch (reg) { 284 case 0x00: /* Revision Code */ 285 return 0xa5; 286 287 case 0x02: /* Configuration Readback */ 288 return 0x83; /* Macrovision OK, CNF[2:0] = 3 */ 289 290 case 0x04: /* PLL M-Divider */ 291 return (s->pll - 1) | (1 << 7); 292 case 0x06: /* PLL Lock Range Control */ 293 return s->pll_range; 294 case 0x08: /* PLL Lock Synthesis Control 0 */ 295 return s->pll_ctrl & 0xff; 296 case 0x0a: /* PLL Lock Synthesis Control 1 */ 297 return s->pll_ctrl >> 8; 298 case 0x0c: /* PLL Mode Control 0 */ 299 return s->pll_mode; 300 301 case 0x0e: /* Clock-Source Select */ 302 return s->clksel; 303 304 case 0x10: /* Memory Controller Activate */ 305 case 0x14: /* Memory Controller Bank 0 Status Flag */ 306 return s->memenable; 307 308 case 0x18: /* Auto-Refresh Interval Setting 0 */ 309 return s->memrefresh & 0xff; 310 case 0x1a: /* Auto-Refresh Interval Setting 1 */ 311 return s->memrefresh >> 8; 312 313 case 0x1c: /* Power-On Sequence Timing Control */ 314 return s->timing[0]; 315 case 0x1e: /* Timing Control 0 */ 316 return s->timing[1]; 317 case 0x20: /* Timing Control 1 */ 318 return s->timing[2]; 319 320 case 0x24: /* Arbitration Priority Control */ 321 return s->priority; 322 323 case 0x28: /* LCD Panel Configuration */ 324 return s->lcd_config; 325 326 case 0x2a: /* LCD Horizontal Display Width */ 327 return s->x >> 3; 328 case 0x2c: /* LCD Horizontal Non-display Period */ 329 return s->hndp; 330 case 0x2e: /* LCD Vertical Display Height 0 */ 331 return s->y & 0xff; 332 case 0x30: /* LCD Vertical Display Height 1 */ 333 return s->y >> 8; 334 case 0x32: /* LCD Vertical Non-display Period */ 335 return s->vndp; 336 case 0x34: /* LCD HS Pulse-width */ 337 return s->hsync; 338 case 0x36: /* LCd HS Pulse Start Position */ 339 return s->skipx >> 3; 340 case 0x38: /* LCD VS Pulse-width */ 341 return s->vsync; 342 case 0x3a: /* LCD VS Pulse Start Position */ 343 return s->skipy; 344 345 case 0x3c: /* PCLK Polarity */ 346 return s->pclk; 347 348 case 0x3e: /* High-speed Serial Interface Tx Configuration Port 0 */ 349 return s->hssi_config[0]; 350 case 0x40: /* High-speed Serial Interface Tx Configuration Port 1 */ 351 return s->hssi_config[1]; 352 case 0x42: /* High-speed Serial Interface Tx Mode */ 353 return s->hssi_config[2]; 354 case 0x44: /* TV Display Configuration */ 355 return s->tv_config; 356 case 0x46 ... 0x4c: /* TV Vertical Blanking Interval Data bits */ 357 return s->tv_timing[(reg - 0x46) >> 1]; 358 case 0x4e: /* VBI: Closed Caption / XDS Control / Status */ 359 return s->vbi; 360 case 0x50: /* TV Horizontal Start Position */ 361 return s->tv_x; 362 case 0x52: /* TV Vertical Start Position */ 363 return s->tv_y; 364 case 0x54: /* TV Test Pattern Setting */ 365 return s->tv_test; 366 case 0x56: /* TV Filter Setting */ 367 return s->tv_filter_config; 368 case 0x58: /* TV Filter Coefficient Index */ 369 return s->tv_filter_idx; 370 case 0x5a: /* TV Filter Coefficient Data */ 371 if (s->tv_filter_idx < 0x20) 372 return s->tv_filter_coeff[s->tv_filter_idx ++]; 373 return 0; 374 375 case 0x60: /* Input YUV/RGB Translate Mode 0 */ 376 return s->yrc[0]; 377 case 0x62: /* Input YUV/RGB Translate Mode 1 */ 378 return s->yrc[1]; 379 case 0x64: /* U Data Fix */ 380 return s->u; 381 case 0x66: /* V Data Fix */ 382 return s->v; 383 384 case 0x68: /* Display Mode */ 385 return s->mode; 386 387 case 0x6a: /* Special Effects */ 388 return s->effect; 389 390 case 0x6c: /* Input Window X Start Position 0 */ 391 return s->ix[0] & 0xff; 392 case 0x6e: /* Input Window X Start Position 1 */ 393 return s->ix[0] >> 3; 394 case 0x70: /* Input Window Y Start Position 0 */ 395 return s->ix[0] & 0xff; 396 case 0x72: /* Input Window Y Start Position 1 */ 397 return s->ix[0] >> 3; 398 case 0x74: /* Input Window X End Position 0 */ 399 return s->ix[1] & 0xff; 400 case 0x76: /* Input Window X End Position 1 */ 401 return s->ix[1] >> 3; 402 case 0x78: /* Input Window Y End Position 0 */ 403 return s->ix[1] & 0xff; 404 case 0x7a: /* Input Window Y End Position 1 */ 405 return s->ix[1] >> 3; 406 case 0x7c: /* Output Window X Start Position 0 */ 407 return s->ox[0] & 0xff; 408 case 0x7e: /* Output Window X Start Position 1 */ 409 return s->ox[0] >> 3; 410 case 0x80: /* Output Window Y Start Position 0 */ 411 return s->oy[0] & 0xff; 412 case 0x82: /* Output Window Y Start Position 1 */ 413 return s->oy[0] >> 3; 414 case 0x84: /* Output Window X End Position 0 */ 415 return s->ox[1] & 0xff; 416 case 0x86: /* Output Window X End Position 1 */ 417 return s->ox[1] >> 3; 418 case 0x88: /* Output Window Y End Position 0 */ 419 return s->oy[1] & 0xff; 420 case 0x8a: /* Output Window Y End Position 1 */ 421 return s->oy[1] >> 3; 422 423 case 0x8c: /* Input Data Format */ 424 return s->iformat; 425 case 0x8e: /* Data Source Select */ 426 return s->source; 427 case 0x90: /* Display Memory Data Port */ 428 return 0; 429 430 case 0xa8: /* Border Color 0 */ 431 return s->border_r; 432 case 0xaa: /* Border Color 1 */ 433 return s->border_g; 434 case 0xac: /* Border Color 2 */ 435 return s->border_b; 436 437 case 0xb4: /* Gamma Correction Enable */ 438 return s->gamma_config; 439 case 0xb6: /* Gamma Correction Table Index */ 440 return s->gamma_idx; 441 case 0xb8: /* Gamma Correction Table Data */ 442 return s->gamma_lut[s->gamma_idx ++]; 443 444 case 0xba: /* 3x3 Matrix Enable */ 445 return s->matrix_ena; 446 case 0xbc ... 0xde: /* Coefficient Registers */ 447 return s->matrix_coeff[(reg - 0xbc) >> 1]; 448 case 0xe0: /* 3x3 Matrix Red Offset */ 449 return s->matrix_r; 450 case 0xe2: /* 3x3 Matrix Green Offset */ 451 return s->matrix_g; 452 case 0xe4: /* 3x3 Matrix Blue Offset */ 453 return s->matrix_b; 454 455 case 0xe6: /* Power-save */ 456 return s->pm; 457 case 0xe8: /* Non-display Period Control / Status */ 458 return s->status | (1 << 5); 459 case 0xea: /* RGB Interface Control */ 460 return s->rgbgpio_dir; 461 case 0xec: /* RGB Interface Status */ 462 return s->rgbgpio; 463 case 0xee: /* General-purpose IO Pins Configuration */ 464 return s->gpio_dir; 465 case 0xf0: /* General-purpose IO Pins Status / Control */ 466 return s->gpio; 467 case 0xf2: /* GPIO Positive Edge Interrupt Trigger */ 468 return s->gpio_edge[0]; 469 case 0xf4: /* GPIO Negative Edge Interrupt Trigger */ 470 return s->gpio_edge[1]; 471 case 0xf6: /* GPIO Interrupt Status */ 472 return s->gpio_irq; 473 case 0xf8: /* GPIO Pull-down Control */ 474 return s->gpio_pdown; 475 476 default: 477 fprintf(stderr, "%s: unknown register %02x\n", __func__, reg); 478 return 0; 479 } 480 } 481 482 static void blizzard_reg_write(void *opaque, uint8_t reg, uint16_t value) 483 { 484 BlizzardState *s = (BlizzardState *) opaque; 485 486 switch (reg) { 487 case 0x04: /* PLL M-Divider */ 488 s->pll = (value & 0x3f) + 1; 489 break; 490 case 0x06: /* PLL Lock Range Control */ 491 s->pll_range = value & 3; 492 break; 493 case 0x08: /* PLL Lock Synthesis Control 0 */ 494 s->pll_ctrl &= 0xf00; 495 s->pll_ctrl |= (value << 0) & 0x0ff; 496 break; 497 case 0x0a: /* PLL Lock Synthesis Control 1 */ 498 s->pll_ctrl &= 0x0ff; 499 s->pll_ctrl |= (value << 8) & 0xf00; 500 break; 501 case 0x0c: /* PLL Mode Control 0 */ 502 s->pll_mode = value & 0x77; 503 if ((value & 3) == 0 || (value & 3) == 3) 504 fprintf(stderr, "%s: wrong PLL Control bits (%i)\n", 505 __func__, value & 3); 506 break; 507 508 case 0x0e: /* Clock-Source Select */ 509 s->clksel = value & 0xff; 510 break; 511 512 case 0x10: /* Memory Controller Activate */ 513 s->memenable = value & 1; 514 break; 515 case 0x14: /* Memory Controller Bank 0 Status Flag */ 516 break; 517 518 case 0x18: /* Auto-Refresh Interval Setting 0 */ 519 s->memrefresh &= 0xf00; 520 s->memrefresh |= (value << 0) & 0x0ff; 521 break; 522 case 0x1a: /* Auto-Refresh Interval Setting 1 */ 523 s->memrefresh &= 0x0ff; 524 s->memrefresh |= (value << 8) & 0xf00; 525 break; 526 527 case 0x1c: /* Power-On Sequence Timing Control */ 528 s->timing[0] = value & 0x7f; 529 break; 530 case 0x1e: /* Timing Control 0 */ 531 s->timing[1] = value & 0x17; 532 break; 533 case 0x20: /* Timing Control 1 */ 534 s->timing[2] = value & 0x35; 535 break; 536 537 case 0x24: /* Arbitration Priority Control */ 538 s->priority = value & 1; 539 break; 540 541 case 0x28: /* LCD Panel Configuration */ 542 s->lcd_config = value & 0xff; 543 if (value & (1 << 7)) 544 fprintf(stderr, "%s: data swap not supported!\n", __func__); 545 break; 546 547 case 0x2a: /* LCD Horizontal Display Width */ 548 s->x = value << 3; 549 break; 550 case 0x2c: /* LCD Horizontal Non-display Period */ 551 s->hndp = value & 0xff; 552 break; 553 case 0x2e: /* LCD Vertical Display Height 0 */ 554 s->y &= 0x300; 555 s->y |= (value << 0) & 0x0ff; 556 break; 557 case 0x30: /* LCD Vertical Display Height 1 */ 558 s->y &= 0x0ff; 559 s->y |= (value << 8) & 0x300; 560 break; 561 case 0x32: /* LCD Vertical Non-display Period */ 562 s->vndp = value & 0xff; 563 break; 564 case 0x34: /* LCD HS Pulse-width */ 565 s->hsync = value & 0xff; 566 break; 567 case 0x36: /* LCD HS Pulse Start Position */ 568 s->skipx = value & 0xff; 569 break; 570 case 0x38: /* LCD VS Pulse-width */ 571 s->vsync = value & 0xbf; 572 break; 573 case 0x3a: /* LCD VS Pulse Start Position */ 574 s->skipy = value & 0xff; 575 break; 576 577 case 0x3c: /* PCLK Polarity */ 578 s->pclk = value & 0x82; 579 /* Affects calculation of s->hndp, s->hsync and s->skipx. */ 580 break; 581 582 case 0x3e: /* High-speed Serial Interface Tx Configuration Port 0 */ 583 s->hssi_config[0] = value; 584 break; 585 case 0x40: /* High-speed Serial Interface Tx Configuration Port 1 */ 586 s->hssi_config[1] = value; 587 if (((value >> 4) & 3) == 3) 588 fprintf(stderr, "%s: Illegal active-data-links value\n", 589 __func__); 590 break; 591 case 0x42: /* High-speed Serial Interface Tx Mode */ 592 s->hssi_config[2] = value & 0xbd; 593 break; 594 595 case 0x44: /* TV Display Configuration */ 596 s->tv_config = value & 0xfe; 597 break; 598 case 0x46 ... 0x4c: /* TV Vertical Blanking Interval Data bits 0 */ 599 s->tv_timing[(reg - 0x46) >> 1] = value; 600 break; 601 case 0x4e: /* VBI: Closed Caption / XDS Control / Status */ 602 s->vbi = value; 603 break; 604 case 0x50: /* TV Horizontal Start Position */ 605 s->tv_x = value; 606 break; 607 case 0x52: /* TV Vertical Start Position */ 608 s->tv_y = value & 0x7f; 609 break; 610 case 0x54: /* TV Test Pattern Setting */ 611 s->tv_test = value; 612 break; 613 case 0x56: /* TV Filter Setting */ 614 s->tv_filter_config = value & 0xbf; 615 break; 616 case 0x58: /* TV Filter Coefficient Index */ 617 s->tv_filter_idx = value & 0x1f; 618 break; 619 case 0x5a: /* TV Filter Coefficient Data */ 620 if (s->tv_filter_idx < 0x20) 621 s->tv_filter_coeff[s->tv_filter_idx ++] = value; 622 break; 623 624 case 0x60: /* Input YUV/RGB Translate Mode 0 */ 625 s->yrc[0] = value & 0xb0; 626 break; 627 case 0x62: /* Input YUV/RGB Translate Mode 1 */ 628 s->yrc[1] = value & 0x30; 629 break; 630 case 0x64: /* U Data Fix */ 631 s->u = value & 0xff; 632 break; 633 case 0x66: /* V Data Fix */ 634 s->v = value & 0xff; 635 break; 636 637 case 0x68: /* Display Mode */ 638 if ((s->mode ^ value) & 3) 639 s->invalidate = 1; 640 s->mode = value & 0xb7; 641 s->enable = value & 1; 642 s->blank = (value >> 1) & 1; 643 if (value & (1 << 4)) 644 fprintf(stderr, "%s: Macrovision enable attempt!\n", __func__); 645 break; 646 647 case 0x6a: /* Special Effects */ 648 s->effect = value & 0xfb; 649 break; 650 651 case 0x6c: /* Input Window X Start Position 0 */ 652 s->ix[0] &= 0x300; 653 s->ix[0] |= (value << 0) & 0x0ff; 654 break; 655 case 0x6e: /* Input Window X Start Position 1 */ 656 s->ix[0] &= 0x0ff; 657 s->ix[0] |= (value << 8) & 0x300; 658 break; 659 case 0x70: /* Input Window Y Start Position 0 */ 660 s->iy[0] &= 0x300; 661 s->iy[0] |= (value << 0) & 0x0ff; 662 break; 663 case 0x72: /* Input Window Y Start Position 1 */ 664 s->iy[0] &= 0x0ff; 665 s->iy[0] |= (value << 8) & 0x300; 666 break; 667 case 0x74: /* Input Window X End Position 0 */ 668 s->ix[1] &= 0x300; 669 s->ix[1] |= (value << 0) & 0x0ff; 670 break; 671 case 0x76: /* Input Window X End Position 1 */ 672 s->ix[1] &= 0x0ff; 673 s->ix[1] |= (value << 8) & 0x300; 674 break; 675 case 0x78: /* Input Window Y End Position 0 */ 676 s->iy[1] &= 0x300; 677 s->iy[1] |= (value << 0) & 0x0ff; 678 break; 679 case 0x7a: /* Input Window Y End Position 1 */ 680 s->iy[1] &= 0x0ff; 681 s->iy[1] |= (value << 8) & 0x300; 682 break; 683 case 0x7c: /* Output Window X Start Position 0 */ 684 s->ox[0] &= 0x300; 685 s->ox[0] |= (value << 0) & 0x0ff; 686 break; 687 case 0x7e: /* Output Window X Start Position 1 */ 688 s->ox[0] &= 0x0ff; 689 s->ox[0] |= (value << 8) & 0x300; 690 break; 691 case 0x80: /* Output Window Y Start Position 0 */ 692 s->oy[0] &= 0x300; 693 s->oy[0] |= (value << 0) & 0x0ff; 694 break; 695 case 0x82: /* Output Window Y Start Position 1 */ 696 s->oy[0] &= 0x0ff; 697 s->oy[0] |= (value << 8) & 0x300; 698 break; 699 case 0x84: /* Output Window X End Position 0 */ 700 s->ox[1] &= 0x300; 701 s->ox[1] |= (value << 0) & 0x0ff; 702 break; 703 case 0x86: /* Output Window X End Position 1 */ 704 s->ox[1] &= 0x0ff; 705 s->ox[1] |= (value << 8) & 0x300; 706 break; 707 case 0x88: /* Output Window Y End Position 0 */ 708 s->oy[1] &= 0x300; 709 s->oy[1] |= (value << 0) & 0x0ff; 710 break; 711 case 0x8a: /* Output Window Y End Position 1 */ 712 s->oy[1] &= 0x0ff; 713 s->oy[1] |= (value << 8) & 0x300; 714 break; 715 716 case 0x8c: /* Input Data Format */ 717 s->iformat = value & 0xf; 718 s->bpp = blizzard_iformat_bpp[s->iformat]; 719 if (!s->bpp) 720 fprintf(stderr, "%s: Illegal or unsupported input format %x\n", 721 __func__, s->iformat); 722 break; 723 case 0x8e: /* Data Source Select */ 724 s->source = value & 7; 725 /* Currently all windows will be "destructive overlays". */ 726 if ((!(s->effect & (1 << 3)) && (s->ix[0] != s->ox[0] || 727 s->iy[0] != s->oy[0] || 728 s->ix[1] != s->ox[1] || 729 s->iy[1] != s->oy[1])) || 730 !((s->ix[1] - s->ix[0]) & (s->iy[1] - s->iy[0]) & 731 (s->ox[1] - s->ox[0]) & (s->oy[1] - s->oy[0]) & 1)) 732 fprintf(stderr, "%s: Illegal input/output window positions\n", 733 __func__); 734 735 blizzard_transfer_setup(s); 736 break; 737 738 case 0x90: /* Display Memory Data Port */ 739 if (!s->data.len && !blizzard_transfer_setup(s)) 740 break; 741 742 *s->data.ptr ++ = value; 743 if (-- s->data.len == 0) 744 blizzard_window(s); 745 break; 746 747 case 0xa8: /* Border Color 0 */ 748 s->border_r = value; 749 break; 750 case 0xaa: /* Border Color 1 */ 751 s->border_g = value; 752 break; 753 case 0xac: /* Border Color 2 */ 754 s->border_b = value; 755 break; 756 757 case 0xb4: /* Gamma Correction Enable */ 758 s->gamma_config = value & 0x87; 759 break; 760 case 0xb6: /* Gamma Correction Table Index */ 761 s->gamma_idx = value; 762 break; 763 case 0xb8: /* Gamma Correction Table Data */ 764 s->gamma_lut[s->gamma_idx ++] = value; 765 break; 766 767 case 0xba: /* 3x3 Matrix Enable */ 768 s->matrix_ena = value & 1; 769 break; 770 case 0xbc ... 0xde: /* Coefficient Registers */ 771 s->matrix_coeff[(reg - 0xbc) >> 1] = value & ((reg & 2) ? 0x80 : 0xff); 772 break; 773 case 0xe0: /* 3x3 Matrix Red Offset */ 774 s->matrix_r = value; 775 break; 776 case 0xe2: /* 3x3 Matrix Green Offset */ 777 s->matrix_g = value; 778 break; 779 case 0xe4: /* 3x3 Matrix Blue Offset */ 780 s->matrix_b = value; 781 break; 782 783 case 0xe6: /* Power-save */ 784 s->pm = value & 0x83; 785 if (value & s->mode & 1) 786 fprintf(stderr, "%s: The display must be disabled before entering " 787 "Standby Mode\n", __func__); 788 break; 789 case 0xe8: /* Non-display Period Control / Status */ 790 s->status = value & 0x1b; 791 break; 792 case 0xea: /* RGB Interface Control */ 793 s->rgbgpio_dir = value & 0x8f; 794 break; 795 case 0xec: /* RGB Interface Status */ 796 s->rgbgpio = value & 0xcf; 797 break; 798 case 0xee: /* General-purpose IO Pins Configuration */ 799 s->gpio_dir = value; 800 break; 801 case 0xf0: /* General-purpose IO Pins Status / Control */ 802 s->gpio = value; 803 break; 804 case 0xf2: /* GPIO Positive Edge Interrupt Trigger */ 805 s->gpio_edge[0] = value; 806 break; 807 case 0xf4: /* GPIO Negative Edge Interrupt Trigger */ 808 s->gpio_edge[1] = value; 809 break; 810 case 0xf6: /* GPIO Interrupt Status */ 811 s->gpio_irq &= value; 812 break; 813 case 0xf8: /* GPIO Pull-down Control */ 814 s->gpio_pdown = value; 815 break; 816 817 default: 818 fprintf(stderr, "%s: unknown register %02x\n", __func__, reg); 819 break; 820 } 821 } 822 823 uint16_t s1d13745_read(void *opaque, int dc) 824 { 825 BlizzardState *s = (BlizzardState *) opaque; 826 uint16_t value = blizzard_reg_read(s, s->reg); 827 828 if (s->swallow -- > 0) 829 return 0; 830 if (dc) 831 s->reg ++; 832 833 return value; 834 } 835 836 void s1d13745_write(void *opaque, int dc, uint16_t value) 837 { 838 BlizzardState *s = (BlizzardState *) opaque; 839 840 if (s->swallow -- > 0) 841 return; 842 if (dc) { 843 blizzard_reg_write(s, s->reg, value); 844 845 if (s->reg != 0x90 && s->reg != 0x5a && s->reg != 0xb8) 846 s->reg += 2; 847 } else 848 s->reg = value & 0xff; 849 } 850 851 void s1d13745_write_block(void *opaque, int dc, 852 void *buf, size_t len, int pitch) 853 { 854 BlizzardState *s = (BlizzardState *) opaque; 855 856 while (len > 0) { 857 if (s->reg == 0x90 && dc && 858 (s->data.len || blizzard_transfer_setup(s)) && 859 len >= (s->data.len << 1)) { 860 len -= s->data.len << 1; 861 s->data.len = 0; 862 s->data.data = buf; 863 if (pitch) 864 s->data.pitch = pitch; 865 blizzard_window(s); 866 s->data.data = s->data.buf; 867 continue; 868 } 869 870 s1d13745_write(opaque, dc, *(uint16_t *) buf); 871 len -= 2; 872 buf += 2; 873 } 874 } 875 876 static void blizzard_update_display(void *opaque) 877 { 878 BlizzardState *s = (BlizzardState *) opaque; 879 DisplaySurface *surface = qemu_console_surface(s->con); 880 int y, bypp, bypl, bwidth; 881 uint8_t *src, *dst; 882 883 if (!s->enable) 884 return; 885 886 if (s->x != surface_width(surface) || s->y != surface_height(surface)) { 887 s->invalidate = 1; 888 qemu_console_resize(s->con, s->x, s->y); 889 surface = qemu_console_surface(s->con); 890 } 891 892 if (s->invalidate) { 893 s->invalidate = 0; 894 895 if (s->blank) { 896 bypp = surface_bytes_per_pixel(surface); 897 memset(surface_data(surface), 0, bypp * s->x * s->y); 898 return; 899 } 900 901 s->mx[0] = 0; 902 s->mx[1] = s->x; 903 s->my[0] = 0; 904 s->my[1] = s->y; 905 } 906 907 if (s->mx[1] <= s->mx[0]) 908 return; 909 910 bypp = surface_bytes_per_pixel(surface); 911 bypl = bypp * s->x; 912 bwidth = bypp * (s->mx[1] - s->mx[0]); 913 y = s->my[0]; 914 src = s->fb + bypl * y + bypp * s->mx[0]; 915 dst = surface_data(surface) + bypl * y + bypp * s->mx[0]; 916 for (; y < s->my[1]; y ++, src += bypl, dst += bypl) 917 memcpy(dst, src, bwidth); 918 919 dpy_gfx_update(s->con, s->mx[0], s->my[0], 920 s->mx[1] - s->mx[0], y - s->my[0]); 921 922 s->mx[0] = s->x; 923 s->mx[1] = 0; 924 s->my[0] = s->y; 925 s->my[1] = 0; 926 } 927 928 static void blizzard_draw_line16_32(uint32_t *dest, 929 const uint16_t *src, unsigned int width) 930 { 931 uint16_t data; 932 unsigned int r, g, b; 933 const uint16_t *end = (const void *) src + width; 934 while (src < end) { 935 data = *src ++; 936 b = extract16(data, 0, 5) << 3; 937 g = extract16(data, 5, 6) << 2; 938 r = extract16(data, 11, 5) << 3; 939 *dest++ = rgb_to_pixel32(r, g, b); 940 } 941 } 942 943 static void blizzard_draw_line24mode1_32(uint32_t *dest, 944 const uint8_t *src, unsigned int width) 945 { 946 /* TODO: check if SDL 24-bit planes are not in the same format and 947 * if so, use memcpy */ 948 unsigned int r[2], g[2], b[2]; 949 const uint8_t *end = src + width; 950 while (src < end) { 951 g[0] = *src ++; 952 r[0] = *src ++; 953 r[1] = *src ++; 954 b[0] = *src ++; 955 *dest++ = rgb_to_pixel32(r[0], g[0], b[0]); 956 b[1] = *src ++; 957 g[1] = *src ++; 958 *dest++ = rgb_to_pixel32(r[1], g[1], b[1]); 959 } 960 } 961 962 static void blizzard_draw_line24mode2_32(uint32_t *dest, 963 const uint8_t *src, unsigned int width) 964 { 965 unsigned int r, g, b; 966 const uint8_t *end = src + width; 967 while (src < end) { 968 r = *src ++; 969 src ++; 970 b = *src ++; 971 g = *src ++; 972 *dest++ = rgb_to_pixel32(r, g, b); 973 } 974 } 975 976 /* No rotation */ 977 static blizzard_fn_t blizzard_draw_fn_32[0x10] = { 978 NULL, 979 /* RGB 5:6:5*/ 980 (blizzard_fn_t) blizzard_draw_line16_32, 981 /* RGB 6:6:6 mode 1 */ 982 (blizzard_fn_t) blizzard_draw_line24mode1_32, 983 /* RGB 8:8:8 mode 1 */ 984 (blizzard_fn_t) blizzard_draw_line24mode1_32, 985 NULL, NULL, 986 /* RGB 6:6:6 mode 2 */ 987 (blizzard_fn_t) blizzard_draw_line24mode2_32, 988 /* RGB 8:8:8 mode 2 */ 989 (blizzard_fn_t) blizzard_draw_line24mode2_32, 990 /* YUV 4:2:2 */ 991 NULL, 992 /* YUV 4:2:0 */ 993 NULL, 994 NULL, NULL, NULL, NULL, NULL, NULL, 995 }; 996 997 /* 90deg, 180deg and 270deg rotation */ 998 static blizzard_fn_t blizzard_draw_fn_r_32[0x10] = { 999 /* TODO */ 1000 [0 ... 0xf] = NULL, 1001 }; 1002 1003 static const GraphicHwOps blizzard_ops = { 1004 .invalidate = blizzard_invalidate_display, 1005 .gfx_update = blizzard_update_display, 1006 }; 1007 1008 void *s1d13745_init(qemu_irq gpio_int) 1009 { 1010 BlizzardState *s = g_malloc0(sizeof(*s)); 1011 DisplaySurface *surface; 1012 1013 s->fb = g_malloc(0x180000); 1014 1015 s->con = graphic_console_init(NULL, 0, &blizzard_ops, s); 1016 surface = qemu_console_surface(s->con); 1017 1018 assert(surface_bits_per_pixel(surface) == 32); 1019 1020 s->line_fn_tab[0] = blizzard_draw_fn_32; 1021 s->line_fn_tab[1] = blizzard_draw_fn_r_32; 1022 1023 blizzard_reset(s); 1024 1025 return s; 1026 }