grfabs_cc.c revision 1.29
1 /* $NetBSD: grfabs_cc.c,v 1.29 2007/06/16 20:06:52 dsl Exp $ */ 2 3 /* 4 * Copyright (c) 1994 Christian E. Hopps 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 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Christian E. Hopps. 18 * 4. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /* 34 * abstract interface for custom chips to the amiga abstract graphics driver. 35 * 36 */ 37 38 #include "opt_amigaccgrf.h" 39 40 #include <sys/cdefs.h> 41 __KERNEL_RCSID(0, "$NetBSD: grfabs_cc.c,v 1.29 2007/06/16 20:06:52 dsl Exp $"); 42 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/errno.h> 46 #include <sys/queue.h> 47 48 #include <uvm/uvm_extern.h> 49 50 #include <amiga/amiga/custom.h> 51 #include <amiga/amiga/cc.h> 52 53 #include <amiga/dev/grfabs_reg.h> 54 #include <amiga/dev/grfabs_ccreg.h> 55 56 monitor_t *m_this; 57 mdata_t *m_this_data; 58 const char *monitor_name = "CCMONITOR"; 59 monitor_t monitor; 60 mdata_t monitor_data; 61 cop_t *null_mode_copper_list; 62 63 #if defined (GRF_PAL) 64 # if defined (GRF_A2024) 65 dmode_t pal_a2024_mode; 66 dmdata_t pal_a2024_mode_data; 67 cop_t *pal_a2024_frames[F_QD_TOTAL]; 68 u_char *hedley_init; /* init bitplane. */ 69 dmode_t *p24_this; 70 dmdata_t *p24_this_data; 71 72 dmode_t pal_hires_dlace_mode; 73 dmdata_t pal_hires_dlace_mode_data; 74 cop_t *pal_hires_dlace_frames[F_LACE_TOTAL]; 75 dmode_t *phdl_this; 76 dmdata_t *phdl_this_data; 77 # endif /* GRF_A2024 */ 78 79 # if defined (GRF_AGA) 80 dmode_t paga_mode; 81 dmdata_t paga_mode_data; 82 cop_t *paga_frames[F_TOTAL]; 83 dmode_t *paga_this; 84 dmdata_t *paga_this_data; 85 86 # endif /* GRF_AGA */ 87 88 dmode_t pal_hires_lace_mode; 89 dmdata_t pal_hires_lace_mode_data; 90 cop_t *pal_hires_lace_frames[F_LACE_TOTAL]; 91 dmode_t *phl_this; 92 dmdata_t *phl_this_data; 93 94 dmode_t pal_hires_mode; 95 dmdata_t pal_hires_mode_data; 96 cop_t *pal_hires_frames[F_TOTAL]; 97 dmode_t *ph_this; 98 dmdata_t *ph_this_data; 99 #endif /* PAL */ 100 101 #if defined (GRF_NTSC) 102 # if defined (GRF_A2024) 103 dmode_t a2024_mode; 104 dmdata_t a2024_mode_data; 105 cop_t *a2024_frames[F_QD_TOTAL]; 106 u_char *hedley_init; /* init bitplane. */ 107 dmode_t *a24_this; 108 dmdata_t *a24_this_data; 109 110 dmode_t hires_dlace_mode; 111 dmdata_t hires_dlace_mode_data; 112 cop_t *hires_dlace_frames[F_LACE_TOTAL]; 113 dmode_t *hdl_this; 114 dmdata_t *hdl_this_data; 115 # endif /* GRF_A2024 */ 116 117 # if defined (GRF_AGA) 118 dmode_t aga_mode; 119 dmdata_t aga_mode_data; 120 cop_t *aga_frames[F_TOTAL]; 121 dmode_t *aga_this; 122 dmdata_t *aga_this_data; 123 124 #if defined (GRF_SUPER72) 125 dmode_t super72_mode; 126 dmdata_t super72_mode_data; 127 cop_t *super72_frames[F_LACE_TOTAL]; 128 dmode_t *super72_this; 129 dmdata_t *super72_this_data; 130 #endif /* GRF_SUPER72 */ 131 132 # endif /* GRF_AGA */ 133 134 dmode_t hires_lace_mode; 135 dmdata_t hires_lace_mode_data; 136 cop_t *hires_lace_frames[F_LACE_TOTAL]; 137 dmode_t *hl_this; 138 dmdata_t *hl_this_data; 139 140 void display_hires_view(view_t * v); 141 dmode_t hires_mode; 142 dmdata_t hires_mode_data; 143 cop_t *hires_frames[F_TOTAL]; 144 dmode_t *h_this; 145 dmdata_t *h_this_data; 146 #endif /* GRF_NTSC */ 147 148 #ifdef GRF_AGA 149 #define AGA_ENABLE 0x0001 150 #define AGA_ENABLE2 0x0002 151 #define AGA_TRACE 0x0004 152 #define AGA_TRACE2 0x0008 153 #define AGA_VGAONLY 0x0010 154 #define AGA_VGA31KHZ 0x0020 155 156 int aga_enable = 0; /* set by start_c(), or can be patched */ 157 colormap_t *cc_alloc_aga_colormap(int); 158 int cc_use_aga_colormap(view_t *, colormap_t *); 159 #endif 160 161 /* monitor functions. */ 162 monitor_t * 163 cc_init_monitor(void) 164 { 165 cop_t *cp; 166 167 if (m_this) 168 return(m_this); 169 170 cc_monitor = m_this = &monitor; 171 /* turn sprite DMA off. we don't support them yet. */ 172 custom.dmacon = DMAF_SPRITE; 173 174 /* makre sure sprite data registers are clear as well */ 175 custom.spr[0].data = 0; 176 custom.spr[0].datb = 0; 177 178 m_this->name = monitor_name; 179 m_this_data = m_this->data = &monitor_data; 180 181 m_this->get_current_mode = get_current_mode; 182 m_this->vbl_handler = (vbl_handler_func *) monitor_vbl_handler; 183 m_this->get_next_mode = get_next_mode; 184 m_this->get_best_mode = get_best_mode; 185 186 m_this->alloc_bitmap = alloc_bitmap; 187 m_this->free_bitmap = free_bitmap; 188 189 m_this_data->current_mode = NULL; 190 LIST_INIT(&m_this_data->modes); 191 192 cp = null_mode_copper_list = alloc_chipmem(sizeof(cop_t) * 4); 193 if (!cp) 194 panic("no chipmem for grf."); 195 196 CMOVE(cp, R_COLOR00, 0x0000); /* background is black */ 197 CMOVE(cp, R_BPLCON0, 0x0000); /* no planes to fetch from */ 198 CWAIT(cp, 255, 255); /* COPEND */ 199 CWAIT(cp, 255, 255); /* COPEND really */ 200 201 /* install this list and turn DMA on */ 202 custom.cop1lc = PREP_DMA_MEM(null_mode_copper_list); 203 custom.copjmp1 = 0; 204 custom.dmacon = DMAF_SETCLR | DMAF_MASTER | DMAF_RASTER \ 205 |DMAF_COPPER; 206 207 cc_init_modes(); 208 LIST_INSERT_HEAD(monitors, m_this, link); 209 return (m_this); 210 } 211 212 void 213 monitor_vbl_handler(monitor_t *m) 214 { 215 dmdata_t *dmd; 216 217 if (m_this_data->current_mode == NULL) 218 return; 219 220 dmd = DMDATA(m_this_data->current_mode); 221 if (dmd) 222 dmd->vbl_handler(m_this_data->current_mode); 223 } 224 225 dmode_t * 226 get_current_mode(void) 227 { 228 if (m_this_data->current_mode) 229 return(m_this_data->current_mode); 230 else 231 return(NULL); 232 } 233 234 dmode_t * 235 get_next_mode(dmode_t *d) 236 { 237 if (d) 238 return(d->link.le_next); 239 return(m_this_data->modes.lh_first); 240 } 241 242 /* XXX needs to have more control attributes */ 243 dmode_t * 244 get_best_mode(dimen_t *size, u_char depth) 245 { 246 dmode_t *save; 247 dmode_t *dm; 248 long dt = 0, dx, dy, ct; 249 dmdata_t *dmd; 250 251 save = NULL; 252 dm = m_this_data->modes.lh_first; 253 while (dm != NULL) { 254 dmd = dm->data; 255 if (depth > dmd->max_depth || depth < dmd->min_depth) { 256 dm = dm->link.le_next; 257 continue; 258 } else if (size->width > dmd->max_size.width || 259 size->height > dmd->max_size.height) { 260 dm = dm->link.le_next; 261 continue; 262 } else if (size->width < dmd->min_size.width || 263 size->height < dmd->min_size.height) { 264 dm = dm->link.le_next; 265 continue; 266 } 267 dx = abs(dm->nominal_size.width - size->width); 268 dy = abs(dm->nominal_size.height - size->height); 269 ct = dx + dy; 270 271 if (ct < dt || save == NULL) { 272 save = dm; 273 dt = ct; 274 } 275 dm = dm->link.le_next; 276 } 277 return (save); 278 } 279 /* bitmap functions */ 280 bmap_t * 281 alloc_bitmap(u_short width, u_short height, u_short depth, u_short flags) 282 { 283 int i; 284 u_long total_size; 285 #ifdef GRF_AGA 286 u_short lwpr = (flags & BMF_ALIGN64) ? ((width + 63) / 64) * 2 : 287 (width + 31) / 32; /* AGA needs 64 bit align */ 288 #else 289 u_short lwpr = (width + 31) / 32; 290 #endif 291 u_short wpr = lwpr << 1; 292 u_short bpr = wpr << 1; 293 u_short array_size = sizeof(u_char *) * depth; 294 u_long plane_size = bpr * height; 295 u_short temp_size = bpr + sizeof(u_long); 296 bmap_t *bm; 297 298 /* note the next allocation will give everything, also note that all 299 * the stuff we want (including bitmaps) will be long short aligned. 300 * This is a function of the data being allocated and the fact that 301 * alloc_chipmem() returns long short aligned data. note also that 302 * each row of the bitmap is long word aligned and made of exactly n 303 * longwords. -ch */ 304 305 /* Sigh, it seems for mapping to work we need the bitplane data to 1: 306 * be aligned on a page boundry. 2: be n pages large. 307 * 308 * why? because the user gets a page aligned address, if this is before 309 * your allocation, too bad. Also it seems that the mapping routines 310 * do not watch to closely to the allowable length. so if you go over 311 * n pages by less than another page, the user gets to write all over 312 * the entire page. Since you did not allocate up to a page boundry 313 * (or more) the user writes into someone elses memory. -ch */ 314 #ifdef __powerpc__ 315 #define m68k_round_page(x) ((((unsigned)(x)) + PGOFSET) & ~PGOFSET) 316 #endif 317 total_size = m68k_round_page(plane_size * depth) + /* for length */ 318 (temp_size) + (array_size) + sizeof(bmap_t) + 319 PAGE_SIZE; /* for alignment */ 320 bm = alloc_chipmem(total_size); 321 if (bm) { 322 if (flags & BMF_CLEAR) { 323 bzero(bm, total_size); 324 } 325 bm->bytes_per_row = bpr; 326 bm->rows = height; 327 bm->depth = depth; 328 bm->flags = flags; 329 bm->plane = (u_char **) & bm[1]; 330 bm->blit_temp = ((u_char *) bm->plane) + array_size; 331 bm->plane[0] = (u_char *) m68k_round_page((u_long) 332 (bm->blit_temp + temp_size)); 333 if (flags & BMF_INTERLEAVED) { 334 bm->row_mod = bm->bytes_per_row * (depth - 1); 335 for (i = 1; i < depth; i++) { 336 bm->plane[i] = bm->plane[i - 1] + bpr; 337 } 338 } else { 339 bm->row_mod = 0; 340 for (i = 1; i < depth; i++) { 341 bm->plane[i] = bm->plane[i - 1] + plane_size; 342 } 343 } 344 bm->hardware_address = PREP_DMA_MEM(bm->plane[0]); 345 return (bm); 346 } 347 return (NULL); 348 } 349 350 351 void 352 free_bitmap(bmap_t *bm) 353 { 354 if (bm) 355 free_chipmem(bm); 356 } 357 /* load a new mode into the current display, if NULL shut display off. */ 358 void 359 cc_load_mode(dmode_t *d) 360 { 361 if (d) { 362 m_this_data->current_mode = d; 363 #ifdef __powerpc__ /* XXX ???? */ 364 custom.cop1lc = PREP_DMA_MEM(DMDATA(d)->frames[F_LONG]); 365 custom.copjmp1 = 0; 366 #endif 367 return; 368 } 369 /* turn off display */ 370 m_this_data->current_mode = NULL; 371 wait_tof(); 372 wait_tof(); 373 custom.cop1lc = PREP_DMA_MEM(null_mode_copper_list); 374 custom.copjmp1 = 0; 375 } 376 /* 377 * CC Mode Stuff. 378 */ 379 380 dmode_t *(*mode_init_funcs[]) (void) = { 381 #if defined (GRF_NTSC) 382 #if defined (GRF_A2024) 383 cc_init_ntsc_a2024, 384 cc_init_ntsc_hires_dlace, 385 #endif /* GRF_A2024 */ 386 cc_init_ntsc_hires_lace, 387 cc_init_ntsc_hires, 388 #if defined (GRF_AGA) 389 cc_init_ntsc_aga, 390 #if defined (GRF_SUPER72) 391 cc_init_super72, 392 #endif /* GRF_SUPER72 */ 393 #endif /* GRF_AGA */ 394 #endif /* GRF_NTSC */ 395 #if defined (GRF_PAL) 396 #if defined (GRF_A2024) 397 cc_init_pal_a2024, 398 cc_init_pal_hires_dlace, 399 #endif /* GRF_A2024 */ 400 cc_init_pal_hires_lace, 401 cc_init_pal_hires, 402 #if defined (GRF_AGA) 403 cc_init_pal_aga, 404 #endif /* GRF_AGA */ 405 #endif /* GRF_PAL */ 406 NULL 407 }; 408 409 int 410 cc_init_modes(void) 411 { 412 int i = 0; 413 int error = 0; 414 while (mode_init_funcs[i]) { 415 mode_init_funcs[i] (); 416 i++; 417 } 418 return (error); 419 } 420 421 monitor_t * 422 cc_get_monitor(dmode_t *d) 423 { 424 return (DMDATA(d)->monitor); 425 } 426 427 view_t * 428 cc_get_current_view(dmode_t *d) 429 { 430 return (DMDATA(d)->current_view); 431 } 432 433 434 view_t * 435 cc_alloc_view(dmode_t *mode, dimen_t *dim, u_char depth) 436 { 437 view_t *v = alloc_chipmem(sizeof(*v) + sizeof(vdata_t)); 438 if (v) { 439 bmap_t *bm = cc_monitor->alloc_bitmap(dim->width, dim->height, 440 depth, BMF_CLEAR | (DMDATA(mode)->max_depth == 8 ? BMF_ALIGN64 : 0)); 441 if (bm) { 442 box_t box; 443 444 v->data = &v[1]; /* at the end of view */ 445 VDATA(v)->colormap = DMDATA(mode)->alloc_colormap(depth); 446 if (VDATA(v)->colormap) { 447 INIT_BOX(&box, 0, 0, dim->width, dim->height); 448 cc_init_view(v, bm, mode, &box); 449 return (v); 450 } 451 cc_monitor->free_bitmap(bm); 452 } 453 free_chipmem(v); 454 } 455 return (NULL); 456 } 457 458 colormap_t * 459 cc_alloc_colormap(int depth) 460 { 461 u_long size = 1U << depth, i; 462 colormap_t *cm = alloc_chipmem(sizeof(u_long) * size + sizeof(*cm)); 463 464 if (cm) { 465 cm->type = CM_COLOR; 466 cm->red_mask = 0x0F; 467 cm->green_mask = 0x0F; 468 cm->blue_mask = 0x0F; 469 cm->first = 0; 470 cm->size = size; 471 cm->entry = (u_long *) & cm[1]; /* table directly after. */ 472 for (i = 0; i < size; i++) { 473 cm->entry[i] = CM_WTOL(cc_default_colors[i&31]); 474 } 475 return (cm); 476 } 477 return (NULL); 478 } 479 480 #ifdef GRF_AGA 481 colormap_t * 482 cc_alloc_aga_colormap(int depth) 483 { 484 u_long size = 1U << depth, i; 485 colormap_t *cm = alloc_chipmem(sizeof(u_long) * size + sizeof(*cm)); 486 487 if (cm) { 488 cm->type = CM_COLOR; 489 cm->red_mask = 0x0FF; 490 cm->green_mask = 0x0FF; 491 cm->blue_mask = 0x0FF; 492 cm->first = 0; 493 cm->size = size; 494 cm->entry = (u_long *) & cm[1]; /* table directly after. */ 495 for (i = 0; i < size; i++) { 496 cm->entry[i] = CM_WTOL(cc_default_colors[i&31]) | 497 (CM_WTOL(cc_default_colors[i&31]) << 4); 498 } 499 return (cm); 500 } 501 return (NULL); 502 } 503 #endif 504 505 int 506 cc_colormap_checkvals(colormap_t *vcm, colormap_t *cm, int use) 507 { 508 if (use) { 509 /* check to see if its the view's colormap, if so just do 510 * update. */ 511 if (vcm != cm) { 512 if (cm->first >= vcm->size || 513 (cm->first + cm->size) > (cm->first + vcm->size) || 514 cm->type != vcm->type) { 515 return (0); 516 } 517 switch (vcm->type) { 518 case CM_COLOR: 519 if (cm->red_mask != vcm->red_mask || 520 cm->green_mask != vcm->green_mask || 521 cm->blue_mask != vcm->blue_mask) { 522 return (0); 523 } 524 break; 525 case CM_GREYSCALE: 526 if (cm->grey_mask != vcm->grey_mask) { 527 return (0); 528 } 529 break; 530 } 531 } 532 } else { 533 if (cm->first >= vcm->size || 534 (cm->first + cm->size) > (cm->first + vcm->size)) { 535 return (0); 536 } 537 } 538 return (1); 539 } 540 541 /* does sanity check on values */ 542 int 543 cc_get_colormap(view_t *v, colormap_t *cm) 544 { 545 colormap_t *vcm = VDATA(v)->colormap; 546 int i; 547 548 if (!cc_colormap_checkvals(vcm, cm, 0)) { 549 return (EINVAL); 550 } 551 cm->type = vcm->type; 552 553 switch (vcm->type) { 554 case CM_COLOR: 555 cm->red_mask = vcm->red_mask; 556 cm->green_mask = vcm->green_mask; 557 cm->blue_mask = vcm->blue_mask; 558 break; 559 case CM_GREYSCALE: 560 cm->grey_mask = vcm->grey_mask; 561 break; 562 } 563 564 /* copy entries into colormap. */ 565 for (i = cm->first; i < (cm->first + cm->size); i++) { 566 cm->entry[i] = vcm->entry[i]; 567 } 568 return (0); 569 } 570 571 /* does sanity check on values */ 572 int 573 cc_use_colormap(view_t *v, colormap_t *cm) 574 { 575 colormap_t *vcm = VDATA(v)->colormap; 576 int s, i; 577 578 if (!cc_colormap_checkvals(vcm, cm, 1)) { 579 return (EINVAL); 580 } 581 /* check to see if its the view's colormap, if so just do update. */ 582 if (vcm != cm) { 583 /* copy entries into colormap. */ 584 for (i = cm->first; i < (cm->first + cm->size); i++) { 585 vcm->entry[i] = cm->entry[i]; 586 } 587 } 588 s = spltty(); 589 590 /* is view currently being displayed? */ 591 if (VDATA(v)->flags & VF_DISPLAY) { 592 /* yes, update the copper lists */ 593 cop_t *tmp, *cp; 594 int nframes = 1, j; 595 596 if (DMDATA(VDATA(v)->mode)->flags & DMF_INTERLACE) { 597 nframes = 2; 598 } 599 for (i = 0; i < nframes; i++) { 600 cp = DMDATA(VDATA(v)->mode)->frames[i]; 601 602 tmp = find_copper_inst(cp, CI_MOVE(R_COLOR07)); 603 tmp -= 7; 604 605 for (j = 0; j < 32; j++) { 606 CMOVE(tmp, (R_COLOR00 + (j << 1)), 607 CM_LTOW(vcm->entry[j])); 608 } 609 } 610 } 611 splx(s); 612 return (0); 613 } 614 615 #ifdef GRF_AGA 616 /* does sanity check on values */ 617 int 618 cc_use_aga_colormap(view_t *v, colormap_t *cm) 619 { 620 colormap_t *vcm = VDATA(v)->colormap; 621 int s, i; 622 623 if (!cc_colormap_checkvals(vcm, cm, 1)) { 624 return (EINVAL); 625 } 626 /* check to see if its the view's colormap, if so just do update. */ 627 if (vcm != cm) { 628 /* copy entries into colormap. */ 629 for (i = cm->first; i < (cm->first + cm->size); i++) { 630 vcm->entry[i] = cm->entry[i]; 631 } 632 } 633 s = spltty(); 634 635 /* is view currently being displayed? */ 636 if (VDATA(v)->flags & VF_DISPLAY) { 637 /* yes, update the copper lists */ 638 cop_t *tmp, *cp; 639 int nframes = 1, j; 640 641 if (DMDATA(VDATA(v)->mode)->flags & DMF_INTERLACE) { 642 nframes = 2; 643 } 644 for (i = 0; i < nframes; i++) { 645 cp = DMDATA(VDATA(v)->mode)->frames[i]; 646 647 tmp = find_copper_inst(cp, CI_MOVE(R_COLOR00)); 648 for (j = 0; j < vcm->size; j += 32) { 649 int k; 650 651 for (k = 0; k < 32; k++) { 652 int ce = vcm->entry[j + k] >> 4; 653 CMOVE(tmp, (R_COLOR00 + (k << 1)), 654 CM_LTOW(ce)); 655 } 656 tmp++; 657 for (k = 0; k < 32; k++) { 658 int ce =vcm->entry[j + k]; 659 CMOVE(tmp, (R_COLOR00 + (k << 1)), 660 CM_LTOW(ce)); 661 } 662 tmp++; 663 } 664 } 665 } 666 splx(s); 667 return (0); 668 } 669 #endif 670 671 #if defined (GRF_A2024) 672 colormap_t * 673 cc_a2024_alloc_colormap(int depth) 674 { 675 u_long size = 1U << depth, i; 676 colormap_t *cm = alloc_chipmem(sizeof(u_long) * size + sizeof(*cm)); 677 678 if (cm) { 679 cm->type = CM_GREYSCALE; 680 cm->grey_mask = 0x03; 681 cm->first = 0; 682 cm->size = size; 683 cm->entry = (u_long *) & cm[1]; /* table directly after. */ 684 for (i = 0; i < size; i++) { 685 cm->entry[i] = CM_WTOL(cc_a2024_default_colors[i]); 686 } 687 return (cm); 688 } 689 return (NULL); 690 } 691 692 int 693 cc_a2024_get_colormap(view_t *v, colormap_t *cm) 694 { 695 /* there are no differences (yet) in the way the cm's are stored */ 696 return (cc_get_colormap(v, cm)); 697 } 698 699 int 700 cc_a2024_use_colormap(view_t *v, colormap_t *cm) 701 { 702 colormap_t *vcm = VDATA(v)->colormap; 703 int s, i; 704 705 if (!cc_colormap_checkvals(vcm, cm, 1)) { 706 return (EINVAL); 707 } 708 /* check to see if its the view's colormap, if so just do update. */ 709 if (vcm != cm) { 710 /* copy entries into colormap. */ 711 for (i = cm->first; i < (cm->first + cm->size); i++) { 712 vcm->entry[i] = cm->entry[i]; 713 } 714 } 715 s = spltty(); 716 717 /* is view currently being displayed? */ 718 if (VDATA(v)->flags & VF_DISPLAY) { 719 /* yes, update the copper lists */ 720 cop_t *tmp, *cp; 721 int nframes = 2, nregs = cm->size == 4 ? 16 : 8, j; 722 723 if (DMDATA(VDATA(v)->mode)->flags & DMF_HEDLEY_EXP) { 724 nframes = 4; 725 } 726 for (i = 0; i < nframes; i++) { 727 cp = DMDATA(VDATA(v)->mode)->frames[i]; 728 729 tmp = find_copper_inst(cp, CI_MOVE(R_COLOR07)); 730 tmp -= 7; 731 732 for (j = 0; j < nregs; j++) { 733 CMOVE(tmp, (R_COLOR00 + (j << 1)), 734 A2024_CM_TO_CR(vcm, j)); 735 } 736 } 737 } 738 splx(s); 739 return (0); 740 } 741 #endif /* GRF_A2024 */ 742 743 744 /* 745 * CC View stuff. 746 */ 747 748 void 749 cc_init_view(view_t *v, bmap_t *bm, dmode_t *mode, box_t *dbox) 750 { 751 vdata_t *vd = VDATA(v); 752 v->bitmap = bm; 753 vd->mode = mode; 754 bcopy(dbox, &v->display, sizeof(box_t)); 755 756 v->display_view = DMDATA(vd->mode)->display_view; 757 v->use_colormap = DMDATA(vd->mode)->use_colormap; 758 v->get_colormap = DMDATA(vd->mode)->get_colormap; 759 v->free_view = cc_free_view; 760 v->get_display_mode = cc_get_display_mode; 761 v->remove_view = cc_remove_view; 762 } 763 764 void 765 cc_free_view(view_t *v) 766 { 767 if (v) { 768 v->remove_view(v); 769 free_chipmem(VDATA(v)->colormap); 770 cc_monitor->free_bitmap(v->bitmap); 771 free_chipmem(v); 772 } 773 } 774 775 void 776 cc_remove_view(view_t *v) 777 { 778 dmode_t *mode = VDATA(v)->mode; 779 780 if (MDATA(cc_monitor)->current_mode == mode) { 781 if (DMDATA(mode)->current_view == v) { 782 cc_load_mode(NULL); 783 } 784 } 785 if (DMDATA(mode)->current_view == v) { 786 DMDATA(mode)->current_view = NULL; 787 } 788 VDATA(v)->flags &= ~VF_DISPLAY; 789 } 790 791 dmode_t * 792 cc_get_display_mode(view_t *v) 793 { 794 return (VDATA(v)->mode); 795 } 796 797 void 798 cc_mode_vbl_handler(dmode_t *d) 799 { 800 u_short vp = ((custom.vposr & 0x0007) << 8) | ((custom.vhposr) >> 8); 801 802 if (vp < 12) { 803 custom.cop1lc = PREP_DMA_MEM(DMDATA(d)->frames[F_LONG]); 804 custom.copjmp1 = 0; 805 } 806 } 807 808 void 809 cc_lace_mode_vbl_handler(dmode_t *d) 810 { 811 u_short vp = ((custom.vposr & 0x0007) << 8) | ((custom.vhposr) >> 8); 812 813 if (vp < 12) { 814 if (custom.vposr & 0x8000) { 815 custom.cop1lc = PREP_DMA_MEM(DMDATA(d)->frames[F_LACE_LONG]); 816 } else { 817 custom.cop1lc = PREP_DMA_MEM(DMDATA(d)->frames[F_LACE_SHORT]); 818 } 819 custom.copjmp1 = 0; 820 } 821 } 822 823 /* 824 * Modes. (ick) 825 */ 826 827 /* 828 * NTSC Modes 829 */ 830 831 #if defined (GRF_NTSC) 832 833 dmode_t * 834 cc_init_ntsc_hires(void) 835 { 836 /* this function should only be called once. */ 837 if (!h_this) { 838 u_short len = std_copper_list_len; 839 840 h_this = &hires_mode; 841 h_this_data = &hires_mode_data; 842 bzero(h_this, sizeof(dmode_t)); 843 bzero(h_this_data, sizeof(dmdata_t)); 844 845 h_this->name = "ntsc: hires"; 846 h_this->nominal_size.width = 640; 847 h_this->nominal_size.height = 200; 848 h_this_data->max_size.width = 724; 849 h_this_data->max_size.height = 242; 850 h_this_data->min_size.width = 320; 851 h_this_data->min_size.height = 100; 852 h_this_data->min_depth = 1; 853 h_this_data->max_depth = 4; 854 h_this->data = h_this_data; 855 856 h_this->get_monitor = cc_get_monitor; 857 h_this->alloc_view = cc_alloc_view; 858 h_this->get_current_view = cc_get_current_view; 859 860 h_this_data->use_colormap = cc_use_colormap; 861 h_this_data->get_colormap = cc_get_colormap; 862 h_this_data->alloc_colormap = cc_alloc_colormap; 863 h_this_data->display_view = display_hires_view; 864 h_this_data->monitor = cc_monitor; 865 866 h_this_data->frames = hires_frames; 867 h_this_data->frames[F_LONG] = 868 alloc_chipmem(std_copper_list_size * F_TOTAL); 869 if (!h_this_data->frames[F_LONG]) { 870 panic("couldn't get chipmem for copper list"); 871 } 872 h_this_data->frames[F_STORE_LONG] = 873 &h_this_data->frames[F_LONG][len]; 874 875 bcopy(std_copper_list, h_this_data->frames[F_STORE_LONG], 876 std_copper_list_size); 877 bcopy(std_copper_list, h_this_data->frames[F_LONG], 878 std_copper_list_size); 879 880 h_this_data->bplcon0 = 0x8200 | USE_CON3; /* hires, color 881 * composite enable */ 882 h_this_data->std_start_x = STANDARD_VIEW_X; 883 h_this_data->std_start_y = STANDARD_VIEW_Y; 884 h_this_data->vbl_handler = 885 (vbl_handler_func *) cc_mode_vbl_handler; 886 #if defined (GRF_ECS) || defined (GRF_AGA) 887 h_this_data->beamcon0 = STANDARD_NTSC_BEAMCON; 888 #endif 889 890 LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, h_this, link); 891 } 892 return (h_this); 893 } 894 895 void 896 display_hires_view(view_t *v) 897 { 898 if (h_this_data->current_view != v) { 899 vdata_t *vd = VDATA(v); 900 cop_t *cp = h_this_data->frames[F_STORE_LONG], *tmp; 901 int depth = v->bitmap->depth, i; 902 int hstart, hstop, vstart, vstop, j; 903 int x, y, w = v->display.width, h = v->display.height; 904 u_short ddfstart, ddfwidth, con1; 905 906 /* round down to nearest even width */ 907 /* w &= 0xfffe; */ 908 /* calculate datafetch width. */ 909 910 ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 2) << 2; 911 912 /* This will center the any overscanned display */ 913 /* and allow user to modify. */ 914 x = v->display.x + h_this_data->std_start_x - ((w - 640) >> 2); 915 y = v->display.y + h_this_data->std_start_y - ((h - 200) >> 1); 916 917 if (y & 1) 918 y--; 919 920 if (!(x & 1)) 921 x--; 922 923 hstart = x; 924 hstop = x + (w >> 1); 925 vstart = y; 926 vstop = y + h; 927 ddfstart = (hstart - 9) >> 1; 928 929 /* check for hardware limits, AGA may allow more..? */ 930 /* anyone got a 4000 I can borrow :^) -ch */ 931 if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) { 932 int d = 0; 933 934 /* XXX anyone know the equality properties of 935 * intermixed logial AND's */ 936 /* XXX and arithmetic operators? */ 937 while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) { 938 d++; 939 } 940 941 ddfstart -= d; 942 hstart -= d << 1; 943 hstop -= d << 1; 944 } 945 /* correct the datafetch to proper limits. */ 946 /* delay the actual display of the data until we need it. */ 947 ddfstart &= 0xfffc; 948 con1 = ((hstart - 9) - (ddfstart << 1)) | 949 (((hstart - 9) - (ddfstart << 1)) << 4); 950 951 if (h_this_data->current_view) { 952 VDATA(h_this_data->current_view)->flags &= 953 ~VF_DISPLAY; /* mark as no longer displayed. */ 954 } 955 h_this_data->current_view = v; 956 957 cp = h_this_data->frames[F_STORE_LONG]; 958 #if defined (GRF_ECS) || defined (GRF_AGA) 959 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON3)); 960 tmp->cp.inst.operand = 0x0020; 961 #if defined (GRF_AGA) 962 tmp = find_copper_inst(cp, CI_MOVE(R_FMODE)); 963 tmp->cp.inst.operand = 0; 964 #endif 965 tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0)); 966 tmp->cp.inst.operand = h_this_data->beamcon0; 967 tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH)); 968 tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop); 969 #endif /* ECS */ 970 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0)); 971 tmp->cp.inst.operand = h_this_data->bplcon0 | ((depth & 0x7) << 12); 972 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1)); 973 tmp->cp.inst.operand = con1; 974 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART)); 975 tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff); 976 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP)); 977 tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff); 978 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART)); 979 tmp->cp.inst.operand = ddfstart; 980 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP)); 981 tmp->cp.inst.operand = ddfstart + ddfwidth; 982 983 tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH)); 984 for (i = 0, j = 0; i < depth; j += 2, i++) { 985 /* update the plane pointers */ 986 tmp[j].cp.inst.operand = 987 HIADDR(PREP_DMA_MEM(v->bitmap->plane[i])); 988 tmp[j + 1].cp.inst.operand = 989 LOADDR(PREP_DMA_MEM(v->bitmap->plane[i])); 990 } 991 992 /* set mods correctly. */ 993 tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD)); 994 tmp[0].cp.inst.operand = v->bitmap->row_mod; 995 tmp[1].cp.inst.operand = v->bitmap->row_mod; 996 997 /* set next pointers correctly */ 998 tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH)); 999 tmp[0].cp.inst.operand = 1000 HIADDR(PREP_DMA_MEM(h_this_data->frames[F_STORE_LONG])); 1001 tmp[1].cp.inst.operand = 1002 LOADDR(PREP_DMA_MEM(h_this_data->frames[F_STORE_LONG])); 1003 1004 cp = h_this_data->frames[F_LONG]; 1005 h_this_data->frames[F_LONG] = h_this_data->frames[F_STORE_LONG]; 1006 h_this_data->frames[F_STORE_LONG] = cp; 1007 1008 vd->flags |= VF_DISPLAY; 1009 1010 cc_use_colormap(v, vd->colormap); 1011 } 1012 cc_load_mode(h_this); 1013 } 1014 1015 dmode_t * 1016 cc_init_ntsc_hires_lace(void) 1017 { 1018 /* this function should only be called once. */ 1019 if (!hl_this) { 1020 u_short len = std_copper_list_len; 1021 1022 hl_this = &hires_lace_mode; 1023 hl_this_data = &hires_lace_mode_data; 1024 bzero(hl_this, sizeof(dmode_t)); 1025 bzero(hl_this_data, sizeof(dmdata_t)); 1026 1027 hl_this->name = "ntsc: hires interlace"; 1028 hl_this->nominal_size.width = 640; 1029 hl_this->nominal_size.height = 400; 1030 hl_this_data->max_size.width = 724; 1031 hl_this_data->max_size.height = 482; 1032 hl_this_data->min_size.width = 320; 1033 hl_this_data->min_size.height = 200; 1034 hl_this_data->min_depth = 1; 1035 hl_this_data->max_depth = 4; 1036 hl_this->data = hl_this_data; 1037 1038 hl_this->get_monitor = cc_get_monitor; 1039 hl_this->alloc_view = cc_alloc_view; 1040 hl_this->get_current_view = cc_get_current_view; 1041 1042 hl_this_data->use_colormap = cc_use_colormap; 1043 hl_this_data->get_colormap = cc_get_colormap; 1044 hl_this_data->alloc_colormap = cc_alloc_colormap; 1045 hl_this_data->display_view = display_hires_lace_view; 1046 hl_this_data->monitor = cc_monitor; 1047 1048 hl_this_data->flags |= DMF_INTERLACE; 1049 1050 hl_this_data->frames = hires_lace_frames; 1051 hl_this_data->frames[F_LACE_LONG] = 1052 alloc_chipmem(std_copper_list_size * F_LACE_TOTAL); 1053 if (!hl_this_data->frames[F_LACE_LONG]) { 1054 panic("couldn't get chipmem for copper list"); 1055 } 1056 hl_this_data->frames[F_LACE_SHORT] = 1057 &hl_this_data->frames[F_LACE_LONG][len]; 1058 hl_this_data->frames[F_LACE_STORE_LONG] = 1059 &hl_this_data->frames[F_LACE_SHORT][len]; 1060 hl_this_data->frames[F_LACE_STORE_SHORT] = 1061 &hl_this_data->frames[F_LACE_STORE_LONG][len]; 1062 1063 bcopy(std_copper_list, hl_this_data->frames[F_LACE_STORE_LONG], 1064 std_copper_list_size); 1065 bcopy(std_copper_list, hl_this_data->frames[F_LACE_STORE_SHORT], 1066 std_copper_list_size); 1067 bcopy(std_copper_list, hl_this_data->frames[F_LACE_LONG], 1068 std_copper_list_size); 1069 bcopy(std_copper_list, hl_this_data->frames[F_LACE_SHORT], 1070 std_copper_list_size); 1071 1072 hl_this_data->bplcon0 = 0x8204 | USE_CON3; /* hires, color 1073 * composite enable, 1074 * lace. */ 1075 hl_this_data->std_start_x = STANDARD_VIEW_X; 1076 hl_this_data->std_start_y = STANDARD_VIEW_Y; 1077 hl_this_data->vbl_handler = 1078 (vbl_handler_func *) cc_lace_mode_vbl_handler; 1079 #if defined (GRF_ECS) || defined (GRF_AGA) 1080 hl_this_data->beamcon0 = STANDARD_NTSC_BEAMCON; 1081 #endif 1082 1083 LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, hl_this, link); 1084 } 1085 return (hl_this); 1086 } 1087 1088 void 1089 display_hires_lace_view(view_t *v) 1090 { 1091 if (hl_this_data->current_view != v) { 1092 vdata_t *vd = VDATA(v); 1093 cop_t *cp = hl_this_data->frames[F_LACE_STORE_LONG], *tmp; 1094 int depth = v->bitmap->depth, i; 1095 int hstart, hstop, vstart, vstop, j; 1096 int x, y, w = v->display.width, h = v->display.height; 1097 u_short ddfstart, ddfwidth, con1; 1098 1099 /* round down to nearest even width */ 1100 /* w &= 0xfffe; */ 1101 1102 1103 /* calculate datafetch width. */ 1104 1105 ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 2) << 2; 1106 1107 /* This will center the any overscanned display */ 1108 /* and allow user to modify. */ 1109 x = v->display.x + hl_this_data->std_start_x - ((w - 640) >> 2); 1110 y = v->display.y + hl_this_data->std_start_y - ((h - 400) >> 2); 1111 1112 if (y & 1) 1113 y--; 1114 1115 if (!(x & 1)) 1116 x--; 1117 1118 hstart = x; 1119 hstop = x + (w >> 1); 1120 vstart = y; 1121 vstop = y + (h >> 1); 1122 ddfstart = (hstart - 9) >> 1; 1123 1124 /* check for hardware limits, AGA may allow more..? */ 1125 /* anyone got a 4000 I can borrow :^) -ch */ 1126 if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) { 1127 int d = 0; 1128 1129 /* XXX anyone know the equality properties of 1130 * intermixed logial AND's */ 1131 /* XXX and arithmetic operators? */ 1132 while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) { 1133 d++; 1134 } 1135 1136 ddfstart -= d; 1137 hstart -= d << 1; 1138 hstop -= d << 1; 1139 } 1140 /* correct the datafetch to proper limits. */ 1141 /* delay the actual display of the data until we need it. */ 1142 ddfstart &= 0xfffc; 1143 con1 = ((hstart - 9) - (ddfstart << 1)) | 1144 (((hstart - 9) - (ddfstart << 1)) << 4); 1145 1146 if (hl_this_data->current_view) { 1147 VDATA(hl_this_data->current_view)->flags &= 1148 ~VF_DISPLAY; /* mark as no longer displayed. */ 1149 } 1150 hl_this_data->current_view = v; 1151 1152 cp = hl_this_data->frames[F_LACE_STORE_LONG]; 1153 #if defined (GRF_ECS) || defined (GRF_AGA) 1154 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON3)); 1155 tmp->cp.inst.operand = 0x0020; 1156 #if defined (GRF_AGA) 1157 tmp = find_copper_inst(cp, CI_MOVE(R_FMODE)); 1158 tmp->cp.inst.operand = 0; 1159 #endif 1160 tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0)); 1161 tmp->cp.inst.operand = hl_this_data->beamcon0; 1162 tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH)); 1163 tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop); 1164 #endif /* ECS */ 1165 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0)); 1166 tmp->cp.inst.operand = hl_this_data->bplcon0 | ((depth & 0x7) << 12); 1167 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1)); 1168 tmp->cp.inst.operand = con1; 1169 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART)); 1170 tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff); 1171 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP)); 1172 tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff); 1173 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART)); 1174 tmp->cp.inst.operand = ddfstart; 1175 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP)); 1176 tmp->cp.inst.operand = ddfstart + ddfwidth; 1177 1178 tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH)); 1179 for (i = 0, j = 0; i < depth; j += 2, i++) { 1180 /* update the plane pointers */ 1181 tmp[j].cp.inst.operand = 1182 HIADDR(PREP_DMA_MEM(v->bitmap->plane[i])); 1183 tmp[j + 1].cp.inst.operand = 1184 LOADDR(PREP_DMA_MEM(v->bitmap->plane[i])); 1185 } 1186 1187 /* set mods correctly. */ 1188 tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD)); 1189 tmp[0].cp.inst.operand = v->bitmap->bytes_per_row + v->bitmap->row_mod; 1190 tmp[1].cp.inst.operand = v->bitmap->bytes_per_row + v->bitmap->row_mod; 1191 1192 /* set next pointers correctly */ 1193 tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH)); 1194 tmp[0].cp.inst.operand = 1195 HIADDR(PREP_DMA_MEM(hl_this_data->frames[F_LACE_STORE_SHORT])); 1196 tmp[1].cp.inst.operand = 1197 LOADDR(PREP_DMA_MEM(hl_this_data->frames[F_LACE_STORE_SHORT])); 1198 1199 1200 bcopy(hl_this_data->frames[F_LACE_STORE_LONG], 1201 hl_this_data->frames[F_LACE_STORE_SHORT], std_copper_list_size); 1202 1203 /* these are the only ones that are different from long frame. */ 1204 cp = hl_this_data->frames[F_LACE_STORE_SHORT]; 1205 tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH)); 1206 for (i = 0, j = 0; i < depth; j += 2, i++) { 1207 u_short mod = v->bitmap->bytes_per_row + v->bitmap->row_mod; 1208 /* update plane pointers. high and low. */ 1209 tmp[j].cp.inst.operand = 1210 HIADDR(PREP_DMA_MEM(&v->bitmap->plane[i][mod])); 1211 tmp[j + 1].cp.inst.operand = 1212 LOADDR(PREP_DMA_MEM(&v->bitmap->plane[i][mod])); 1213 } 1214 1215 /* set next pointers correctly */ 1216 tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH)); 1217 tmp[0].cp.inst.operand = 1218 HIADDR(PREP_DMA_MEM(hl_this_data->frames[F_LACE_STORE_LONG])); 1219 tmp[1].cp.inst.operand = 1220 LOADDR(PREP_DMA_MEM(hl_this_data->frames[F_LACE_STORE_LONG])); 1221 1222 1223 cp = hl_this_data->frames[F_LACE_LONG]; 1224 hl_this_data->frames[F_LACE_LONG] = 1225 hl_this_data->frames[F_LACE_STORE_LONG]; 1226 hl_this_data->frames[F_LACE_STORE_LONG] = cp; 1227 1228 cp = hl_this_data->frames[F_LACE_SHORT]; 1229 hl_this_data->frames[F_LACE_SHORT] = 1230 hl_this_data->frames[F_LACE_STORE_SHORT]; 1231 hl_this_data->frames[F_LACE_STORE_SHORT] = cp; 1232 1233 vd->flags |= VF_DISPLAY; 1234 1235 cc_use_colormap(v, vd->colormap); 1236 } 1237 cc_load_mode(hl_this); 1238 } 1239 #if defined (GRF_A2024) 1240 1241 dmode_t * 1242 cc_init_ntsc_hires_dlace(void) 1243 { 1244 /* this function should only be called once. */ 1245 if (!hdl_this) { 1246 u_short len = std_dlace_copper_list_len; 1247 1248 hdl_this = &hires_dlace_mode; 1249 hdl_this_data = &hires_dlace_mode_data; 1250 bzero(hdl_this, sizeof(dmode_t)); 1251 bzero(hdl_this_data, sizeof(dmdata_t)); 1252 1253 hdl_this->name = "ntsc: hires double interlace"; 1254 hdl_this->nominal_size.width = 640; 1255 hdl_this->nominal_size.height = 800; 1256 hdl_this_data->max_size.width = 724; 1257 hdl_this_data->max_size.height = 800; 1258 hdl_this_data->min_size.width = 320; 1259 hdl_this_data->min_size.height = 400; 1260 hdl_this_data->min_depth = 1; 1261 hdl_this_data->max_depth = 2; 1262 hdl_this->data = hdl_this_data; 1263 1264 hdl_this->get_monitor = cc_get_monitor; 1265 hdl_this->alloc_view = cc_alloc_view; 1266 hdl_this->get_current_view = cc_get_current_view; 1267 1268 hdl_this_data->use_colormap = cc_a2024_use_colormap; 1269 hdl_this_data->get_colormap = cc_a2024_get_colormap; 1270 hdl_this_data->alloc_colormap = cc_a2024_alloc_colormap; 1271 hdl_this_data->display_view = display_hires_dlace_view; 1272 hdl_this_data->monitor = cc_monitor; 1273 1274 hdl_this_data->flags |= DMF_INTERLACE; 1275 1276 hdl_this_data->frames = hires_dlace_frames; 1277 hdl_this_data->frames[F_LACE_LONG] = 1278 alloc_chipmem(std_dlace_copper_list_size * F_LACE_TOTAL); 1279 if (!hdl_this_data->frames[F_LACE_LONG]) { 1280 panic("couldn't get chipmem for copper list"); 1281 } 1282 hdl_this_data->frames[F_LACE_SHORT] = 1283 &hdl_this_data->frames[F_LACE_LONG][len]; 1284 hdl_this_data->frames[F_LACE_STORE_LONG] = 1285 &hdl_this_data->frames[F_LACE_SHORT][len]; 1286 hdl_this_data->frames[F_LACE_STORE_SHORT] = 1287 &hdl_this_data->frames[F_LACE_STORE_LONG][len]; 1288 1289 bcopy(std_dlace_copper_list, 1290 hdl_this_data->frames[F_LACE_STORE_LONG], 1291 std_dlace_copper_list_size); 1292 bcopy(std_dlace_copper_list, 1293 hdl_this_data->frames[F_LACE_STORE_SHORT], 1294 std_dlace_copper_list_size); 1295 bcopy(std_dlace_copper_list, 1296 hdl_this_data->frames[F_LACE_LONG], 1297 std_dlace_copper_list_size); 1298 bcopy(std_dlace_copper_list, 1299 hdl_this_data->frames[F_LACE_SHORT], 1300 std_dlace_copper_list_size); 1301 1302 hdl_this_data->bplcon0 = 0x8204 | USE_CON3; /* hires, color 1303 * composite enable, 1304 * dlace. */ 1305 hdl_this_data->std_start_x = STANDARD_VIEW_X; 1306 hdl_this_data->std_start_y = STANDARD_VIEW_Y; 1307 hdl_this_data->vbl_handler = 1308 (vbl_handler_func *) cc_lace_mode_vbl_handler; 1309 #if defined (GRF_ECS) || defined (GRF_AGA) 1310 hdl_this_data->beamcon0 = STANDARD_NTSC_BEAMCON; 1311 #endif 1312 LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, hdl_this, link); 1313 } 1314 return (hdl_this); 1315 } 1316 1317 void 1318 display_hires_dlace_view(view_t *v) 1319 { 1320 if (hdl_this_data->current_view != v) { 1321 vdata_t *vd = VDATA(v); 1322 cop_t *cp = hdl_this_data->frames[F_LACE_STORE_LONG], *tmp; 1323 int depth = v->bitmap->depth; 1324 int hstart, hstop, vstart, vstop; 1325 int x, y, w = v->display.width, h = v->display.height; 1326 u_short ddfstart, ddfwidth, con1; 1327 u_short mod1l, mod2l; 1328 1329 /* round down to nearest even width */ 1330 /* w &= 0xfffe; */ 1331 1332 /* calculate datafetch width. */ 1333 1334 ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 2) << 2; 1335 1336 /* This will center the any overscanned display */ 1337 /* and allow user to modify. */ 1338 x = v->display.x + hdl_this_data->std_start_x - ((w - 640) >> 2); 1339 y = v->display.y + hdl_this_data->std_start_y - ((h - 800) >> 3); 1340 1341 if (y & 1) 1342 y--; 1343 1344 if (!(x & 1)) 1345 x--; 1346 1347 hstart = x; 1348 hstop = x + (w >> 1); 1349 vstart = y; 1350 vstop = y + (h >> 2); 1351 1352 ddfstart = (hstart - 9) >> 1; 1353 1354 /* check for hardware limits, AGA may allow more..? */ 1355 /* anyone got a 4000 I can borrow :^) -ch */ 1356 if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) { 1357 int d = 0; 1358 1359 /* XXX anyone know the equality properties of 1360 * intermixed logial AND's */ 1361 /* XXX and arithmetic operators? */ 1362 while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) { 1363 d++; 1364 } 1365 1366 ddfstart -= d; 1367 hstart -= d << 1; 1368 hstop -= d << 1; 1369 } 1370 /* correct the datafetch to proper limits. */ 1371 /* delay the actual display of the data until we need it. */ 1372 ddfstart &= 0xfffc; 1373 con1 = ((hstart - 9) - (ddfstart << 1)) | 1374 (((hstart - 9) - (ddfstart << 1)) << 4); 1375 1376 if (hdl_this_data->current_view) { 1377 VDATA(hdl_this_data->current_view)->flags &= 1378 ~VF_DISPLAY; /* mark as no longer displayed. */ 1379 } 1380 hdl_this_data->current_view = v; 1381 1382 cp = hdl_this_data->frames[F_LACE_STORE_LONG]; 1383 #if defined (GRF_ECS) || defined (GRF_AGA) 1384 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON3)); 1385 tmp->cp.inst.operand = 0x0020; 1386 #if defined (GRF_AGA) 1387 tmp = find_copper_inst(cp, CI_MOVE(R_FMODE)); 1388 tmp->cp.inst.operand = 0; 1389 #endif 1390 tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0)); 1391 tmp->cp.inst.operand = hdl_this_data->beamcon0; 1392 tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH)); 1393 tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop); 1394 #endif /* ECS */ 1395 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0)); 1396 tmp->cp.inst.operand = 1397 hdl_this_data->bplcon0 | ((depth & 0x7) << 13); /* times two. */ 1398 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1)); 1399 tmp->cp.inst.operand = con1; 1400 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART)); 1401 tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff); 1402 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP)); 1403 tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff); 1404 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART)); 1405 tmp->cp.inst.operand = ddfstart; 1406 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP)); 1407 tmp->cp.inst.operand = ddfstart + ddfwidth; 1408 1409 mod1l = v->bitmap->bytes_per_row + v->bitmap->row_mod; 1410 mod2l = mod1l << 1; 1411 1412 /* update plane pointers. */ 1413 tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH)); 1414 tmp[0].cp.inst.operand = 1415 HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][0])); 1416 tmp[1].cp.inst.operand = 1417 LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][0])); 1418 tmp[2].cp.inst.operand = 1419 HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod1l])); 1420 tmp[3].cp.inst.operand = 1421 LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod1l])); 1422 if (depth == 2) { 1423 tmp[4].cp.inst.operand = 1424 HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][0])); 1425 tmp[5].cp.inst.operand = 1426 LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][0])); 1427 tmp[6].cp.inst.operand = 1428 HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod1l])); 1429 tmp[7].cp.inst.operand = 1430 LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod1l])); 1431 } 1432 /* set modulos. */ 1433 tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD)); 1434 tmp[0].cp.inst.operand = mod2l + mod1l; 1435 tmp[1].cp.inst.operand = mod2l + mod1l; 1436 1437 1438 /* set next coper list pointers */ 1439 tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH)); 1440 tmp[0].cp.inst.operand = 1441 HIADDR(PREP_DMA_MEM(hdl_this_data->frames[F_LACE_STORE_SHORT])); 1442 tmp[1].cp.inst.operand = 1443 LOADDR(PREP_DMA_MEM(hdl_this_data->frames[F_LACE_STORE_SHORT])); 1444 1445 bcopy(hdl_this_data->frames[F_LACE_STORE_LONG], 1446 hdl_this_data->frames[F_LACE_STORE_SHORT], 1447 std_dlace_copper_list_size); 1448 1449 /* these are the only ones that are different from long frame. */ 1450 cp = hdl_this_data->frames[F_LACE_STORE_SHORT]; 1451 /* update plane pointers. */ 1452 tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH)); 1453 tmp[0].cp.inst.operand = 1454 HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l])); 1455 tmp[1].cp.inst.operand = 1456 LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l])); 1457 tmp[2].cp.inst.operand = 1458 HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l + mod1l])); 1459 tmp[3].cp.inst.operand = 1460 LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l + mod1l])); 1461 if (depth == 2) { 1462 tmp[4].cp.inst.operand = 1463 HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l])); 1464 tmp[5].cp.inst.operand = 1465 LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l])); 1466 tmp[6].cp.inst.operand = 1467 HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l + mod1l])); 1468 tmp[7].cp.inst.operand = 1469 LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l + mod1l])); 1470 } 1471 /* set next copper list pointers */ 1472 tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH)); 1473 tmp[0].cp.inst.operand = 1474 HIADDR(PREP_DMA_MEM(hdl_this_data->frames[F_LACE_STORE_LONG])); 1475 tmp[1].cp.inst.operand = 1476 LOADDR(PREP_DMA_MEM(hdl_this_data->frames[F_LACE_STORE_LONG])); 1477 1478 cp = hdl_this_data->frames[F_LACE_LONG]; 1479 hdl_this_data->frames[F_LACE_LONG] = 1480 hdl_this_data->frames[F_LACE_STORE_LONG]; 1481 hdl_this_data->frames[F_LACE_STORE_LONG] = cp; 1482 1483 cp = hdl_this_data->frames[F_LACE_SHORT]; 1484 hdl_this_data->frames[F_LACE_SHORT] = 1485 hdl_this_data->frames[F_LACE_STORE_SHORT]; 1486 hdl_this_data->frames[F_LACE_STORE_SHORT] = cp; 1487 1488 vd->flags |= VF_DISPLAY; 1489 cc_a2024_use_colormap(v, vd->colormap); 1490 } 1491 cc_load_mode(hdl_this); 1492 } 1493 1494 1495 dmode_t * 1496 cc_init_ntsc_a2024(void) 1497 { 1498 /* this function should only be called once. */ 1499 if (!a24_this) { 1500 int i; 1501 u_short len = std_a2024_copper_list_len; 1502 cop_t *cp; 1503 1504 a24_this = &a2024_mode; 1505 a24_this_data = &a2024_mode_data; 1506 bzero(a24_this, sizeof(dmode_t)); 1507 bzero(a24_this_data, sizeof(dmdata_t)); 1508 1509 a24_this->name = "ntsc: A2024 15 kHz"; 1510 a24_this->nominal_size.width = 1024; 1511 a24_this->nominal_size.height = 800; 1512 a24_this_data->max_size.width = 1024; 1513 a24_this_data->max_size.height = 800; 1514 a24_this_data->min_size.width = 1024; 1515 a24_this_data->min_size.height = 800; 1516 a24_this_data->min_depth = 1; 1517 a24_this_data->max_depth = 2; 1518 a24_this->data = a24_this_data; 1519 1520 a24_this->get_monitor = cc_get_monitor; 1521 a24_this->alloc_view = cc_alloc_view; 1522 a24_this->get_current_view = cc_get_current_view; 1523 1524 a24_this_data->use_colormap = cc_a2024_use_colormap; 1525 a24_this_data->get_colormap = cc_a2024_get_colormap; 1526 a24_this_data->display_view = display_a2024_view; 1527 a24_this_data->alloc_colormap = cc_a2024_alloc_colormap; 1528 a24_this_data->monitor = cc_monitor; 1529 1530 a24_this_data->flags |= DMF_HEDLEY_EXP; 1531 1532 a24_this_data->frames = a2024_frames; 1533 a24_this_data->frames[F_QD_QUAD0] = 1534 alloc_chipmem(std_a2024_copper_list_size * F_QD_TOTAL); 1535 if (!a24_this_data->frames[F_QD_QUAD0]) { 1536 panic("couldn't get chipmem for copper list"); 1537 } 1538 /* setup the hedley init bitplane. */ 1539 hedley_init = alloc_chipmem(128); 1540 if (!hedley_init) { 1541 panic("couldn't get chipmem for hedley init bitplane"); 1542 } 1543 for (i = 1; i < 128; i++) 1544 hedley_init[i] = 0xff; 1545 hedley_init[0] = 0x03; 1546 1547 /* copy image of standard copper list. */ 1548 bcopy(std_a2024_copper_list, a24_this_data->frames[0], 1549 std_a2024_copper_list_size); 1550 1551 /* set the init plane pointer. */ 1552 cp = find_copper_inst(a24_this_data->frames[F_QD_QUAD0], 1553 CI_MOVE(R_BPL0PTH)); 1554 cp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(hedley_init)); 1555 cp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(hedley_init)); 1556 1557 for (i = 1; i < F_QD_TOTAL; i++) { 1558 a24_this_data->frames[i] = &a24_this_data->frames[i - 1][len]; 1559 bcopy(a24_this_data->frames[0], 1560 a24_this_data->frames[i], 1561 std_a2024_copper_list_size); 1562 } 1563 1564 a24_this_data->bplcon0 = 0x8200; /* hires */ 1565 a24_this_data->vbl_handler = 1566 (vbl_handler_func *) a2024_mode_vbl_handler; 1567 1568 1569 LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, a24_this, link); 1570 } 1571 return (a24_this); 1572 } 1573 1574 void 1575 display_a2024_view(view_t *v) 1576 { 1577 if (a24_this_data->current_view != v) { 1578 vdata_t *vd = VDATA(v); 1579 cop_t *cp, *tmp; 1580 u_char *inst_plane[2]; 1581 u_char **plane = inst_plane; 1582 u_long full_line = v->bitmap->bytes_per_row + v->bitmap->row_mod; 1583 u_long half_plane = full_line * v->bitmap->rows / 2; 1584 1585 int depth = v->bitmap->depth, i, j; 1586 1587 plane[0] = v->bitmap->plane[0]; 1588 if (depth == 2) { 1589 plane[1] = v->bitmap->plane[1]; 1590 } 1591 if (a24_this_data->current_view) { 1592 VDATA(a24_this_data->current_view)->flags &= 1593 ~VF_DISPLAY; /* mark as no longer displayed. */ 1594 } 1595 cp = a24_this_data->frames[F_QD_STORE_QUAD0]; 1596 tmp = find_copper_inst(cp, CI_MOVE(R_COLOR1F)); 1597 tmp = find_copper_inst(tmp, CI_MOVE(R_BPLCON0)); /* grab third one. */ 1598 tmp->cp.inst.operand = a24_this_data->bplcon0 | 1599 ((depth & 0x7) << 13); /* times 2 */ 1600 1601 bcopy(a24_this_data->frames[F_QD_STORE_QUAD0], 1602 a24_this_data->frames[F_QD_STORE_QUAD1], 1603 std_a2024_copper_list_size); 1604 bcopy(a24_this_data->frames[F_QD_STORE_QUAD0], 1605 a24_this_data->frames[F_QD_STORE_QUAD2], 1606 std_a2024_copper_list_size); 1607 bcopy(a24_this_data->frames[F_QD_STORE_QUAD0], 1608 a24_this_data->frames[F_QD_STORE_QUAD3], 1609 std_a2024_copper_list_size); 1610 1611 /* 1612 * Mark Id's 1613 */ 1614 tmp = find_copper_inst(a24_this_data->frames[F_QD_STORE_QUAD1], 1615 CI_WAIT(126, 21)); 1616 CBUMP(tmp); 1617 CMOVE(tmp, R_COLOR01, QUAD1_ID); 1618 tmp = find_copper_inst(a24_this_data->frames[F_QD_STORE_QUAD2], 1619 CI_WAIT(126, 21)); 1620 CBUMP(tmp); 1621 CMOVE(tmp, R_COLOR01, QUAD2_ID); 1622 tmp = find_copper_inst(a24_this_data->frames[F_QD_STORE_QUAD3], 1623 CI_WAIT(126, 21)); 1624 CBUMP(tmp); 1625 CMOVE(tmp, R_COLOR01, QUAD3_ID); 1626 1627 plane[0]--; 1628 plane[0]--; 1629 if (depth == 2) { 1630 plane[1]--; 1631 plane[1]--; 1632 } 1633 /* 1634 * Set bitplane pointers. 1635 */ 1636 tmp = find_copper_inst(a24_this_data->frames[F_QD_STORE_QUAD0], 1637 CI_MOVE(R_BPLMOD2)); 1638 CBUMP(tmp); 1639 CMOVE(tmp, R_BPL0PTH, HIADDR(PREP_DMA_MEM(&plane[0][0]))); 1640 CMOVE(tmp, R_BPL0PTL, LOADDR(PREP_DMA_MEM(&plane[0][0]))); 1641 CMOVE(tmp, R_BPL1PTH, HIADDR(PREP_DMA_MEM(&plane[0][full_line]))); 1642 CMOVE(tmp, R_BPL1PTL, LOADDR(PREP_DMA_MEM(&plane[0][full_line]))); 1643 if (depth == 2) { 1644 CMOVE(tmp, R_BPL2PTH, HIADDR(PREP_DMA_MEM(&plane[1][0]))); 1645 CMOVE(tmp, R_BPL2PTL, LOADDR(PREP_DMA_MEM(&plane[1][0]))); 1646 CMOVE(tmp, R_BPL3PTH, HIADDR(PREP_DMA_MEM(&plane[1][full_line]))); 1647 CMOVE(tmp, R_BPL3PTL, LOADDR(PREP_DMA_MEM(&plane[1][full_line]))); 1648 } 1649 #if defined (GRF_ECS) || defined (GRF_AGA) 1650 CMOVE(tmp, R_DIWHIGH, 0x2000); 1651 #endif 1652 CMOVE(tmp, R_COP1LCH, 1653 HIADDR(PREP_DMA_MEM(a24_this_data->frames[F_QD_STORE_QUAD1]))); 1654 CMOVE(tmp, R_COP1LCL, 1655 LOADDR(PREP_DMA_MEM(a24_this_data->frames[F_QD_STORE_QUAD1]))); 1656 CEND(tmp); 1657 CEND(tmp); 1658 1659 tmp = find_copper_inst(a24_this_data->frames[F_QD_STORE_QUAD1], 1660 CI_MOVE(R_BPLMOD2)); 1661 CBUMP(tmp); 1662 CMOVE(tmp, R_BPL0PTH, 1663 HIADDR(PREP_DMA_MEM(&plane[0][HALF_2024_LINE]))); 1664 CMOVE(tmp, R_BPL0PTL, 1665 LOADDR(PREP_DMA_MEM(&plane[0][HALF_2024_LINE]))); 1666 CMOVE(tmp, R_BPL1PTH, 1667 HIADDR(PREP_DMA_MEM(&plane[0][full_line + HALF_2024_LINE]))); 1668 CMOVE(tmp, R_BPL1PTL, 1669 LOADDR(PREP_DMA_MEM(&plane[0][full_line + HALF_2024_LINE]))); 1670 if (depth == 2) { 1671 CMOVE(tmp, R_BPL2PTH, 1672 HIADDR(PREP_DMA_MEM(&plane[1][HALF_2024_LINE]))); 1673 CMOVE(tmp, R_BPL2PTL, 1674 LOADDR(PREP_DMA_MEM(&plane[1][HALF_2024_LINE]))); 1675 CMOVE(tmp, R_BPL3PTH, 1676 HIADDR(PREP_DMA_MEM(&plane[1][full_line + HALF_2024_LINE]))); 1677 CMOVE(tmp, R_BPL3PTL, 1678 LOADDR(PREP_DMA_MEM(&plane[1][full_line + HALF_2024_LINE]))); 1679 } 1680 #if defined (GRF_ECS) || defined (GRF_AGA) 1681 CMOVE(tmp, R_DIWHIGH, 0x2000); 1682 #endif 1683 CMOVE(tmp, R_COP1LCH, 1684 HIADDR(PREP_DMA_MEM(a24_this_data->frames[F_QD_STORE_QUAD2]))); 1685 CMOVE(tmp, R_COP1LCL, 1686 LOADDR(PREP_DMA_MEM(a24_this_data->frames[F_QD_STORE_QUAD2]))); 1687 CEND(tmp); 1688 CEND(tmp); 1689 1690 tmp = find_copper_inst(a24_this_data->frames[F_QD_STORE_QUAD2], 1691 CI_MOVE(R_BPLMOD2)); 1692 CBUMP(tmp); 1693 CMOVE(tmp, R_BPL0PTH, 1694 HIADDR(PREP_DMA_MEM(&plane[0][half_plane]))); 1695 CMOVE(tmp, R_BPL0PTL, 1696 LOADDR(PREP_DMA_MEM(&plane[0][half_plane]))); 1697 CMOVE(tmp, R_BPL1PTH, 1698 HIADDR(PREP_DMA_MEM(&plane[0][half_plane + full_line]))); 1699 CMOVE(tmp, R_BPL1PTL, 1700 LOADDR(PREP_DMA_MEM(&plane[0][half_plane + full_line]))); 1701 if (depth == 2) { 1702 CMOVE(tmp, R_BPL2PTH, 1703 HIADDR(PREP_DMA_MEM(&plane[1][half_plane]))); 1704 CMOVE(tmp, R_BPL2PTL, 1705 LOADDR(PREP_DMA_MEM(&plane[1][half_plane]))); 1706 CMOVE(tmp, R_BPL3PTH, 1707 HIADDR(PREP_DMA_MEM(&plane[1][half_plane + full_line]))); 1708 CMOVE(tmp, R_BPL3PTL, 1709 LOADDR(PREP_DMA_MEM(&plane[1][half_plane + full_line]))); 1710 } 1711 #if defined (GRF_ECS) || defined (GRF_AGA) 1712 CMOVE(tmp, R_DIWHIGH, 0x2000); 1713 #endif 1714 CMOVE(tmp, R_COP1LCH, 1715 HIADDR(PREP_DMA_MEM(a24_this_data->frames[F_QD_STORE_QUAD3]))); 1716 CMOVE(tmp, R_COP1LCL, 1717 LOADDR(PREP_DMA_MEM(a24_this_data->frames[F_QD_STORE_QUAD3]))); 1718 CEND(tmp); 1719 CEND(tmp); 1720 1721 tmp = find_copper_inst(a24_this_data->frames[F_QD_STORE_QUAD3], 1722 CI_MOVE(R_BPLMOD2)); 1723 CBUMP(tmp); 1724 CMOVE(tmp, R_BPL0PTH, HIADDR(PREP_DMA_MEM( 1725 &plane[0][half_plane + HALF_2024_LINE]))); 1726 CMOVE(tmp, R_BPL0PTL, LOADDR(PREP_DMA_MEM( 1727 &plane[0][half_plane + HALF_2024_LINE]))); 1728 CMOVE(tmp, R_BPL1PTH, HIADDR(PREP_DMA_MEM( 1729 &plane[0][half_plane + full_line + HALF_2024_LINE]))); 1730 CMOVE(tmp, R_BPL1PTL, LOADDR(PREP_DMA_MEM( 1731 &plane[0][half_plane + full_line + HALF_2024_LINE]))); 1732 if (depth == 2) { 1733 CMOVE(tmp, R_BPL2PTH, HIADDR(PREP_DMA_MEM( 1734 &plane[1][half_plane + HALF_2024_LINE]))); 1735 CMOVE(tmp, R_BPL2PTL, LOADDR(PREP_DMA_MEM( 1736 &plane[1][half_plane + HALF_2024_LINE]))); 1737 CMOVE(tmp, R_BPL3PTH, HIADDR(PREP_DMA_MEM( 1738 &plane[1][half_plane + full_line + HALF_2024_LINE]))); 1739 CMOVE(tmp, R_BPL3PTL, LOADDR(PREP_DMA_MEM( 1740 &plane[1][half_plane + full_line + HALF_2024_LINE]))); 1741 } 1742 #if defined (GRF_ECS) || defined (GRF_AGA) 1743 CMOVE(tmp, R_DIWHIGH, 0x2000); 1744 #endif 1745 CMOVE(tmp, R_COP1LCH, HIADDR(PREP_DMA_MEM( 1746 a24_this_data->frames[F_QD_STORE_QUAD0]))); 1747 CMOVE(tmp, R_COP1LCL, LOADDR(PREP_DMA_MEM( 1748 a24_this_data->frames[F_QD_STORE_QUAD0]))); 1749 CEND(tmp); 1750 CEND(tmp); 1751 1752 /* swap new pointers in. */ 1753 for (i = F_QD_STORE_QUAD0, j = F_QD_QUAD0; 1754 i <= F_QD_STORE_QUAD3; i++, j++) { 1755 cp = a24_this_data->frames[j]; 1756 a24_this_data->frames[j] = a24_this_data->frames[i]; 1757 a24_this_data->frames[i] = cp; 1758 } 1759 1760 a24_this_data->current_view = v; 1761 vd->flags |= VF_DISPLAY; 1762 1763 cc_a2024_use_colormap(v, vd->colormap); 1764 } 1765 cc_load_mode(a24_this); 1766 } 1767 1768 void 1769 a2024_mode_vbl_handler(dmode_t *d) 1770 { 1771 u_short vp = ((custom.vposr & 0x0007) << 8) | ((custom.vhposr) >> 8); 1772 1773 if (vp < 12) { 1774 custom.cop1lc = 1775 PREP_DMA_MEM(a24_this_data->frames[a24_this_data->hedley_current]); 1776 custom.copjmp1 = 0; 1777 } 1778 a24_this_data->hedley_current++; 1779 a24_this_data->hedley_current &= 0x3; /* if 4 then 0. */ 1780 } 1781 #endif /* GRF_A2024 */ 1782 1783 #if defined (GRF_AGA) 1784 1785 dmode_t * 1786 cc_init_ntsc_aga(void) 1787 { 1788 /* this function should only be called once. */ 1789 if (!aga_this && (custom.deniseid & 0xff) == 0xf8 && 1790 aga_enable & AGA_ENABLE) { 1791 u_short len = aga_copper_list_len; 1792 1793 aga_this = &aga_mode; 1794 aga_this_data = &aga_mode_data; 1795 bzero(aga_this, sizeof(dmode_t)); 1796 bzero(aga_this_data, sizeof(dmdata_t)); 1797 1798 aga_this->name = "ntsc: AGA dbl"; 1799 aga_this->nominal_size.width = 640; 1800 aga_this->nominal_size.height = 400; 1801 aga_this_data->max_size.width = 724; 1802 aga_this_data->max_size.height = 482; 1803 aga_this_data->min_size.width = 320; 1804 aga_this_data->min_size.height = 200; 1805 aga_this_data->min_depth = 1; 1806 aga_this_data->max_depth = 8; 1807 aga_this->data = aga_this_data; 1808 1809 aga_this->get_monitor = cc_get_monitor; 1810 aga_this->alloc_view = cc_alloc_view; 1811 aga_this->get_current_view = cc_get_current_view; 1812 1813 aga_this_data->use_colormap = cc_use_aga_colormap; 1814 aga_this_data->get_colormap = cc_get_colormap; 1815 aga_this_data->alloc_colormap = cc_alloc_aga_colormap; 1816 aga_this_data->display_view = display_aga_view; 1817 aga_this_data->monitor = cc_monitor; 1818 1819 aga_this_data->frames = aga_frames; 1820 aga_this_data->frames[F_LONG] = alloc_chipmem(aga_copper_list_size * F_TOTAL); 1821 if (!aga_this_data->frames[F_LONG]) { 1822 panic("couldn't get chipmem for copper list"); 1823 } 1824 aga_this_data->frames[F_STORE_LONG] = &aga_this_data->frames[F_LONG][len]; 1825 1826 bcopy(aga_copper_list, aga_this_data->frames[F_STORE_LONG], aga_copper_list_size); 1827 bcopy(aga_copper_list, aga_this_data->frames[F_LONG], aga_copper_list_size); 1828 1829 aga_this_data->bplcon0 = 0x0240 | USE_CON3; /* color composite 1830 * enable, 1831 * shres. */ 1832 #ifdef GRF_AGA_VGA 1833 aga_this_data->std_start_x = 0x40 /*STANDARD_VIEW_X*/; 1834 #else 1835 aga_this_data->std_start_x = 0x4f /*STANDARD_VIEW_X*/; 1836 #endif 1837 aga_this_data->std_start_y = 0x2b /*STANDARD_VIEW_Y*/; 1838 aga_this_data->vbl_handler = (vbl_handler_func *) cc_mode_vbl_handler; 1839 aga_this_data->beamcon0 = SPECIAL_BEAMCON ^ VSYNCTRUE; 1840 1841 LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, 1842 aga_this, link); 1843 } 1844 return (aga_this); 1845 } 1846 1847 /* static, so I can patch and play */ 1848 1849 #ifdef GRF_AGA_VGA 1850 int AGA_htotal = 0x71; 1851 int AGA_hsstrt = 0xc; 1852 int AGA_hsstop = 0x16; 1853 int AGA_hbstrt = 0x5; 1854 int AGA_vtotal = 0x1c1; 1855 #else 1856 int AGA_htotal = 0x79; 1857 int AGA_hsstrt = 0xe; 1858 int AGA_hsstop = 0x1c; 1859 int AGA_hbstrt = 0x8; 1860 int AGA_vtotal = 0x1ec; 1861 #endif 1862 int AGA_hbstop = 0x1e; 1863 int AGA_vsstrt = 0x3; 1864 int AGA_vsstop = 0x6; 1865 int AGA_vbstrt = 0x0; 1866 int AGA_vbstop = 0x19; 1867 int AGA_hcenter = 0x4a; 1868 1869 void 1870 display_aga_view(view_t *v) 1871 { 1872 if (aga_this_data->current_view != v) { 1873 vdata_t *vd = VDATA(v); 1874 cop_t *cp = aga_this_data->frames[F_STORE_LONG], *tmp; 1875 int depth = v->bitmap->depth, i; 1876 int hstart, hstop, vstart, vstop, j; 1877 int x, y, w = v->display.width, h = v->display.height; 1878 u_short ddfstart, ddfwidth, con1; 1879 1880 #ifdef DEBUG 1881 if (aga_enable & AGA_TRACE) 1882 printf("display_aga_view(%dx%dx%d) %p\n", w, h, 1883 depth, v); 1884 #endif 1885 /* round down to nearest even width */ 1886 /* w &= 0xfffe; */ 1887 /* calculate datafetch width. */ 1888 1889 ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 4) << 1; 1890 1891 /* this will center the any overscanned display */ 1892 /* and allow user to modify. */ 1893 x = v->display.x + aga_this_data->std_start_x - ((w - 640) >> 3); 1894 y = v->display.y + aga_this_data->std_start_y - ((h - 400) >> 1); 1895 1896 if (y & 1) 1897 y--; 1898 1899 if (!(x & 1)) 1900 x--; 1901 1902 hstart = x; 1903 hstop = x + (w >> 2); 1904 vstart = y; 1905 vstop = y + (h >> 0); 1906 ddfstart = (hstart >> 1) - 8; 1907 1908 #ifdef DEBUG 1909 if (aga_enable & AGA_TRACE2) { 1910 printf (" ddfwidth %04x x %04x y %04x", ddfwidth, 1911 x, y); 1912 printf (" hstart %04x hstop %04x vstart %04x vstop %04x ddfstart %04x\n", 1913 hstart, hstop, vstart, vstop, ddfstart); 1914 } 1915 #endif 1916 /* check for hardware limits, AGA may allow more..? */ 1917 /* anyone got a 4000 I can borrow :^) -ch */ 1918 if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) { 1919 int d = 0; 1920 1921 /* XXX anyone know the equality properties of 1922 * intermixed logial AND's */ 1923 /* XXX and arithmetic operators? */ 1924 while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) { 1925 d++; 1926 } 1927 1928 ddfstart -= d; 1929 hstart -= d << 1; 1930 hstop -= d << 1; 1931 } 1932 /* correct the datafetch to proper limits. */ 1933 /* delay the actual display of the data until we need it. */ 1934 ddfstart &= 0xfffc; 1935 #ifdef DEBUG 1936 if (aga_enable & AGA_TRACE2) { 1937 printf (" ddfwidth %04x x %04x y %04x", ddfwidth, 1938 x, y); 1939 printf (" hstart %04x hstop %04x vstart %04x vstop %04x ddfstart %04x\n", 1940 hstart, hstop, vstart, vstop, ddfstart); 1941 } 1942 #endif 1943 con1 = ((hstart - 9) - (ddfstart << 1)) | (((hstart - 9) - (ddfstart << 1)) << 4); 1944 1945 if (aga_this_data->current_view) { 1946 VDATA(aga_this_data->current_view)->flags &= ~VF_DISPLAY; /* mark as no longer */ 1947 /* displayed. */ 1948 } 1949 aga_this_data->current_view = v; 1950 1951 cp = aga_this_data->frames[F_STORE_LONG]; 1952 tmp = cp; 1953 for (i = 0; i < 8; ++i) { 1954 if (tmp == NULL) 1955 break; 1956 tmp = find_copper_inst(tmp + 1, CI_MOVE(R_BPLCON3)); 1957 if (tmp == NULL) 1958 break; 1959 tmp->cp.inst.operand = 0x0ca1 | (i << 13); 1960 tmp = find_copper_inst(tmp + 1, CI_MOVE(R_BPLCON3)); 1961 if (tmp == NULL) 1962 break; 1963 tmp->cp.inst.operand = 0x0ea1 | (i << 13); 1964 } 1965 if (tmp) 1966 tmp = find_copper_inst(tmp + 1, CI_MOVE(R_BPLCON3)); 1967 if (tmp) 1968 tmp->cp.inst.operand = 0x0ca1; 1969 tmp = find_copper_inst(cp, CI_MOVE(R_FMODE)); 1970 tmp->cp.inst.operand = 0x8003; 1971 tmp = find_copper_inst(cp, CI_MOVE(R_HTOTAL)); 1972 tmp->cp.inst.operand = AGA_htotal; /* 81/71/73/79? */ 1973 tmp = find_copper_inst(cp, CI_MOVE(R_HBSTRT)); 1974 tmp->cp.inst.operand = AGA_hbstrt; /* 0x0008 */ 1975 tmp = find_copper_inst(cp, CI_MOVE(R_HSSTRT)); 1976 tmp->cp.inst.operand = AGA_hsstrt; /* 0x000e */ 1977 tmp = find_copper_inst(cp, CI_MOVE(R_HSSTOP)); 1978 tmp->cp.inst.operand = AGA_hsstop; /* 0x001c */ 1979 tmp = find_copper_inst(cp, CI_MOVE(R_HBSTOP)); 1980 tmp->cp.inst.operand = AGA_hsstop; /* 0x001e */ 1981 tmp = find_copper_inst(cp, CI_MOVE(R_HCENTER)); 1982 tmp->cp.inst.operand = AGA_hcenter; /*AGA_htotal / 2 + AGA_hsstrt */ 1983 tmp = find_copper_inst(cp, CI_MOVE(R_VBSTRT)); 1984 tmp->cp.inst.operand = AGA_vbstrt; /* 0x0000 */ 1985 tmp = find_copper_inst(cp, CI_MOVE(R_VSSTRT)); 1986 tmp->cp.inst.operand = AGA_vsstrt; /* 0x016b / AGA_htotal */ 1987 tmp = find_copper_inst(cp, CI_MOVE(R_VSSTOP)); 1988 tmp->cp.inst.operand = AGA_vsstop; /* 0x02d6 / AGA_htotal */ 1989 tmp = find_copper_inst(cp, CI_MOVE(R_VBSTOP)); 1990 tmp->cp.inst.operand = AGA_vbstop; /* 0x0bd1 / AGA_htotal */ 1991 tmp = find_copper_inst(cp, CI_MOVE(R_VTOTAL)); 1992 tmp->cp.inst.operand = AGA_vtotal; 1993 tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0)); 1994 tmp->cp.inst.operand = aga_this_data->beamcon0; 1995 #ifdef DEBUG 1996 if (aga_enable & AGA_TRACE2) 1997 printf(" beamcon0 %04x", tmp->cp.inst.operand); 1998 #endif 1999 tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH)); 2000 tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop); 2001 #ifdef DEBUG 2002 if (aga_enable & AGA_TRACE2) 2003 printf(" diwhigh %04x>", tmp->cp.inst.operand); 2004 #endif 2005 #if 0 2006 tmp->cp.inst.operand = (vstop & 0x0700) | ((hstop & 0x0100) << 5); 2007 #endif 2008 #ifdef DEBUG 2009 if (aga_enable & AGA_TRACE2) 2010 printf("%04x", tmp->cp.inst.operand); 2011 #endif 2012 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0)); 2013 tmp->cp.inst.operand = aga_this_data->bplcon0 | 2014 ((depth & 0x7) << 12) | ((depth & 0x8) << 1); 2015 #ifdef DEBUG 2016 if (aga_enable & AGA_TRACE2) 2017 printf(" bplcon0 %04x", tmp->cp.inst.operand); 2018 #endif 2019 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1)); 2020 tmp->cp.inst.operand = con1; 2021 #ifdef DEBUG 2022 if (aga_enable & AGA_TRACE2) 2023 printf(" bplcon1 %04x>0000\n", con1); 2024 #endif 2025 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART)); 2026 tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff); 2027 #ifdef DEBUG 2028 if (aga_enable & AGA_TRACE2) 2029 printf(" diwstart %04x", tmp->cp.inst.operand); 2030 #endif 2031 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP)); 2032 tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff); 2033 #ifdef DEBUG 2034 if (aga_enable & AGA_TRACE2) 2035 printf(" diwstop %04x", tmp->cp.inst.operand); 2036 #endif 2037 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART)); 2038 tmp->cp.inst.operand = ddfstart; 2039 #ifdef DEBUG 2040 if (aga_enable & AGA_TRACE2) 2041 printf(" ddfstart %04x", tmp->cp.inst.operand); 2042 #endif 2043 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP)); 2044 tmp->cp.inst.operand = ddfstart + ddfwidth; 2045 #ifdef DEBUG 2046 if (aga_enable & AGA_TRACE2) 2047 printf(" ddfstop %04x", tmp->cp.inst.operand); 2048 #endif 2049 2050 tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH)); 2051 for (i = 0, j = 0; i < depth; j += 2, i++) { 2052 /* update the plane pointers */ 2053 tmp[j].cp.inst.operand = HIADDR(PREP_DMA_MEM(v->bitmap->plane[i])); 2054 tmp[j + 1].cp.inst.operand = LOADDR(PREP_DMA_MEM(v->bitmap->plane[i])); 2055 #ifdef DEBUG 2056 if (aga_enable & AGA_TRACE2) 2057 printf (" bpl%dpth %p", i, v->bitmap->plane[i]); 2058 #endif 2059 } 2060 2061 /* set mods correctly. */ 2062 tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD)); 2063 tmp[0].cp.inst.operand = v->bitmap->row_mod; 2064 tmp[1].cp.inst.operand = v->bitmap->row_mod; 2065 #ifdef DEBUG 2066 if (aga_enable & AGA_TRACE2) 2067 printf(" bplxmod %04x\n", v->bitmap->row_mod); 2068 #endif 2069 2070 /* set next pointers correctly */ 2071 tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH)); 2072 tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(aga_this_data->frames[F_STORE_LONG])); 2073 tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(aga_this_data->frames[F_STORE_LONG])); 2074 2075 cp = aga_this_data->frames[F_LONG]; 2076 aga_this_data->frames[F_LONG] = aga_this_data->frames[F_STORE_LONG]; 2077 aga_this_data->frames[F_STORE_LONG] = cp; 2078 2079 vd->flags |= VF_DISPLAY; 2080 2081 cc_use_aga_colormap(v, vd->colormap); 2082 } 2083 cc_load_mode(aga_this); 2084 #ifdef DEBUG 2085 if (aga_enable & AGA_TRACE) 2086 aga_enable |= AGA_TRACE2; /* XXXX */ 2087 #endif 2088 } 2089 2090 /* 2091 * SUPER72 Mode 2092 */ 2093 2094 #if defined (GRF_SUPER72) 2095 dmode_t * 2096 cc_init_super72(void) 2097 { 2098 /* this function should only be called once. */ 2099 if (!super72_this && (custom.deniseid & 0xff) == 0xf8) { 2100 u_short len = aga_copper_list_len; 2101 2102 super72_this = &super72_mode; 2103 super72_this_data = &super72_mode_data; 2104 bzero(super72_this, sizeof(dmode_t)); 2105 bzero(super72_this_data, sizeof(dmdata_t)); 2106 2107 super72_this->name = "super72: superhires interlace"; 2108 super72_this->nominal_size.width = 800; 2109 super72_this->nominal_size.height = 600; 2110 super72_this_data->max_size.width = 848; 2111 super72_this_data->max_size.height = 614; 2112 super72_this_data->min_size.width = 320; 2113 super72_this_data->min_size.height = 484; 2114 super72_this_data->min_depth = 1; 2115 super72_this_data->max_depth = 8; 2116 super72_this->data = super72_this_data; 2117 2118 super72_this->get_monitor = cc_get_monitor; 2119 super72_this->alloc_view = cc_alloc_view; 2120 super72_this->get_current_view = cc_get_current_view; 2121 2122 super72_this_data->use_colormap = cc_use_aga_colormap; 2123 super72_this_data->get_colormap = cc_get_colormap; 2124 super72_this_data->alloc_colormap = cc_alloc_aga_colormap; 2125 super72_this_data->display_view = display_super72_view; 2126 super72_this_data->monitor = cc_monitor; 2127 2128 super72_this_data->flags |= DMF_INTERLACE; 2129 2130 super72_this_data->frames = super72_frames; /* MAY NEED TO CHANGE COPLIST */ 2131 super72_this_data->frames[F_LACE_LONG] = 2132 alloc_chipmem(aga_copper_list_size * F_LACE_TOTAL); 2133 if (!super72_this_data->frames[F_LACE_LONG]) { 2134 panic("couldn't get chipmem for copper list"); 2135 } 2136 super72_this_data->frames[F_LACE_SHORT] = 2137 &super72_this_data->frames[F_LACE_LONG][len]; 2138 super72_this_data->frames[F_LACE_STORE_LONG] = 2139 &super72_this_data->frames[F_LACE_SHORT][len]; 2140 super72_this_data->frames[F_LACE_STORE_SHORT] = 2141 &super72_this_data->frames[F_LACE_STORE_LONG][len]; 2142 2143 bcopy(aga_copper_list, 2144 super72_this_data->frames[F_LACE_STORE_LONG], 2145 aga_copper_list_size); 2146 bcopy(aga_copper_list, 2147 super72_this_data->frames[F_LACE_STORE_SHORT], 2148 aga_copper_list_size); 2149 bcopy(aga_copper_list, 2150 super72_this_data->frames[F_LACE_LONG], 2151 aga_copper_list_size); 2152 bcopy(aga_copper_list, 2153 super72_this_data->frames[F_LACE_SHORT], 2154 aga_copper_list_size); 2155 2156 super72_this_data->bplcon0 = 0x0244 | USE_CON3; /* color 2157 * composite enable, 2158 * shres 2159 * lace. */ 2160 #if 0 /* patchable variables for testing */ 2161 super72_this_data->std_start_x = 0x6c; 2162 super72_this_data->std_start_y = 0x1b; 2163 #endif 2164 super72_this_data->vbl_handler = 2165 (vbl_handler_func *) cc_lace_mode_vbl_handler; 2166 super72_this_data->beamcon0 = (SPECIAL_BEAMCON ^ VSYNCTRUE) | 2167 DISPLAYPAL | 0x4000; 2168 super72_this_data->beamcon0 = 0x5bb0; 2169 2170 LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, super72_this, link); 2171 } 2172 return (super72_this); 2173 } 2174 2175 /* Super72 83Hz hack monitor values */ 2176 /*int super72_htotal = 0x083; 2177 int super72_hsstrt = 0x00d; 2178 int super72_hsstop = 0x01b; 2179 int super72_hbstrt = 0x001; 2180 int super72_hbstop = 0x021; 2181 int super72_vtotal = 0x148; 2182 int super72_vsstrt = 0x2d5; 2183 int super72_vsstop = 0x3ca; 2184 int super72_vbstrt = 0x000; 2185 int super72_vbstop = 0xfdc; 2186 int super72_hcenter = 0x04e; 2187 */ 2188 2189 /* Super72 standard monitor values */ 2190 int super72_htotal = 154; /* 0x099*/ 2191 int super72_hsstrt = 17; /* 0x01c*/ 2192 int super72_hsstop = 27; /* 0x038*/ 2193 int super72_hbstrt = 154; /* 0x008*/ 2194 int super72_hbstop = 55; /* 0x01e*/ 2195 int super72_vtotal = 328; /* 0x147*/ 2196 int super72_vsstrt = 11; /* 0x030*/ 2197 int super72_vsstop = 18; /* 0x033*/ 2198 int super72_vbstrt = 327; /* 0x000*/ 2199 int super72_vbstop = 27; /* 0x019*/ 2200 int super72_hcenter = 94; /* 0x057*/ 2201 int super72_startx = 100; 2202 int super72_starty = 27; 2203 2204 void 2205 display_super72_view(view_t *v) 2206 { 2207 if (super72_this_data->current_view != v) { 2208 vdata_t *vd = VDATA(v); 2209 cop_t *cp = super72_this_data->frames[F_LACE_STORE_LONG], *tmp; 2210 int depth = v->bitmap->depth, i; 2211 int hstart, hstop, vstart, vstop, j; 2212 int x, y, w = v->display.width, h = v->display.height; 2213 u_short ddfstart, ddfwidth, con1; 2214 2215 /* round down to nearest even width */ 2216 /* w &= 0xfffe; */ 2217 2218 /* calculate datafetch width. */ 2219 ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 4) << 1; 2220 2221 /* This will center any overscanned display */ 2222 /* and allow user to modify. */ 2223 x = (v->display.x >> 1) + super72_startx - ((w - 800) >> 3); 2224 y = v->display.y + super72_starty - ((h - 600) >> 2); 2225 2226 hstart = x; 2227 hstop = x + (w >> 2); 2228 vstart = y; 2229 vstop = y + (h >> 1); 2230 ddfstart = (hstart >> 1) - 16; 2231 2232 ddfstart = (hstart << 2) - 4; 2233 con1 = ddfstart & 63; 2234 ddfstart = (ddfstart & -64) - 64; 2235 ddfwidth = ((w + 64 - 1) & -64) - 64; 2236 ddfwidth = ddfwidth >> 3; 2237 ddfstart = ddfstart >> 3; 2238 super72_hbstrt = ((x << 2) + w + 4) >> 3; 2239 super72_hbstop = (hstart + 1) >> 1; 2240 super72_vbstrt = vstop; 2241 super72_vbstop = vstart - 2; 2242 2243 if ((hstop >> 1) > super72_htotal) { 2244 int d; 2245 2246 d = (hstop >> 1) - super72_htotal; 2247 ddfstart -= d; 2248 hstart -= d << 1; 2249 hstop -= d << 1; 2250 } 2251 if (vstop >= super72_vtotal) { 2252 int d; 2253 d = (vstop - super72_vtotal + 1); 2254 vstart -= d; 2255 vstop -= d; 2256 } 2257 con1 = ((con1 >> 2) & 0x000f) | /* PF1H2-PF1H5 */ 2258 ((con1 << 8) & 0x0300) | /* PF1H0-PF1H2 */ 2259 ((con1 << 4) & 0x0c00); /* PF1H6-PF1H7 */ 2260 con1 |= con1 << 4; /* PF2H2-PF2H7 */ 2261 2262 if (super72_this_data->current_view) { 2263 VDATA(super72_this_data->current_view)->flags &= 2264 ~VF_DISPLAY; /* mark as no longer */ 2265 /* displayed. */ 2266 } 2267 super72_this_data->current_view = v; 2268 2269 cp = super72_this_data->frames[F_LACE_STORE_LONG]; 2270 tmp = find_copper_inst(cp, CI_MOVE(R_FMODE)); 2271 tmp->cp.inst.operand = 0x8003; 2272 tmp = find_copper_inst(cp, CI_MOVE(R_HTOTAL)); 2273 tmp->cp.inst.operand = super72_htotal; 2274 tmp = find_copper_inst(cp, CI_MOVE(R_HBSTRT)); 2275 tmp->cp.inst.operand = super72_hbstrt; 2276 tmp = find_copper_inst(cp, CI_MOVE(R_HSSTRT)); 2277 tmp->cp.inst.operand = super72_hsstrt; 2278 tmp = find_copper_inst(cp, CI_MOVE(R_HSSTOP)); 2279 tmp->cp.inst.operand = super72_hsstop; 2280 tmp = find_copper_inst(cp, CI_MOVE(R_HBSTOP)); 2281 tmp->cp.inst.operand = super72_hbstop; 2282 tmp = find_copper_inst(cp, CI_MOVE(R_HCENTER)); 2283 tmp->cp.inst.operand = super72_hcenter; 2284 tmp = find_copper_inst(cp, CI_MOVE(R_VBSTRT)); 2285 tmp->cp.inst.operand = super72_vbstrt; 2286 tmp = find_copper_inst(cp, CI_MOVE(R_VSSTRT)); 2287 tmp->cp.inst.operand = super72_vsstrt; 2288 tmp = find_copper_inst(cp, CI_MOVE(R_VSSTOP)); 2289 tmp->cp.inst.operand = super72_vsstop; 2290 tmp = find_copper_inst(cp, CI_MOVE(R_VBSTOP)); 2291 tmp->cp.inst.operand = super72_vbstop; 2292 tmp = find_copper_inst(cp, CI_MOVE(R_VTOTAL)); 2293 tmp->cp.inst.operand = super72_vtotal; 2294 2295 tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0)); 2296 tmp->cp.inst.operand = super72_this_data->beamcon0; 2297 tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH)); 2298 tmp->cp.inst.operand = 2299 CALC_DIWHIGH(hstart, vstart, hstop, vstop); 2300 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0)); 2301 tmp->cp.inst.operand = super72_this_data->bplcon0 | 2302 ((depth & 0x7) << 12) | ((depth & 0x8) << 1); 2303 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1)); 2304 tmp->cp.inst.operand = con1; 2305 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART)); 2306 tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff); 2307 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP)); 2308 tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff); 2309 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART)); 2310 tmp->cp.inst.operand = ddfstart; 2311 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP)); 2312 tmp->cp.inst.operand = ddfstart + ddfwidth; 2313 2314 tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH)); 2315 for (i = 0, j = 0; i < depth; j += 2, i++) { 2316 /* update the plane pointers */ 2317 tmp[j].cp.inst.operand = 2318 HIADDR(PREP_DMA_MEM(v->bitmap->plane[i])); 2319 tmp[j + 1].cp.inst.operand = 2320 LOADDR(PREP_DMA_MEM(v->bitmap->plane[i])); 2321 } 2322 2323 /* set mods correctly. */ 2324 tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD)); 2325 tmp[0].cp.inst.operand = v->bitmap->bytes_per_row + 2326 v->bitmap->row_mod; 2327 tmp[1].cp.inst.operand = v->bitmap->bytes_per_row + 2328 v->bitmap->row_mod; 2329 2330 /* set next pointers correctly */ 2331 tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH)); 2332 tmp[0].cp.inst.operand = 2333 HIADDR(PREP_DMA_MEM(super72_this_data->frames[F_LACE_STORE_SHORT])); 2334 tmp[1].cp.inst.operand = 2335 LOADDR(PREP_DMA_MEM(super72_this_data->frames[F_LACE_STORE_SHORT])); 2336 2337 bcopy(super72_this_data->frames[F_LACE_STORE_LONG], 2338 super72_this_data->frames[F_LACE_STORE_SHORT], 2339 aga_copper_list_size); 2340 2341 /* these are the only ones that are different from long frame. */ 2342 cp = super72_this_data->frames[F_LACE_STORE_SHORT]; 2343 tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH)); 2344 for (i = 0, j = 0; i < depth; j += 2, i++) { 2345 u_short mod = v->bitmap->bytes_per_row + 2346 v->bitmap->row_mod; 2347 /* update plane pointers. high and low. */ 2348 tmp[j].cp.inst.operand = 2349 HIADDR(PREP_DMA_MEM(&v->bitmap->plane[i][mod])); 2350 tmp[j + 1].cp.inst.operand = 2351 LOADDR(PREP_DMA_MEM(&v->bitmap->plane[i][mod])); 2352 } 2353 2354 /* set next pointers correctly */ 2355 tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH)); 2356 tmp[0].cp.inst.operand = 2357 HIADDR(PREP_DMA_MEM(super72_this_data->frames[F_LACE_STORE_LONG])); 2358 tmp[1].cp.inst.operand = 2359 LOADDR(PREP_DMA_MEM(super72_this_data->frames[F_LACE_STORE_LONG])); 2360 2361 cp = super72_this_data->frames[F_LACE_LONG]; 2362 super72_this_data->frames[F_LACE_LONG] = 2363 super72_this_data->frames[F_LACE_STORE_LONG]; 2364 super72_this_data->frames[F_LACE_STORE_LONG] = cp; 2365 2366 cp = super72_this_data->frames[F_LACE_SHORT]; 2367 super72_this_data->frames[F_LACE_SHORT] = 2368 super72_this_data->frames[F_LACE_STORE_SHORT]; 2369 super72_this_data->frames[F_LACE_STORE_SHORT] = cp; 2370 2371 vd->flags |= VF_DISPLAY; 2372 cc_use_aga_colormap(v, vd->colormap); 2373 } 2374 cc_load_mode(super72_this); 2375 } 2376 #endif /* GRF_SUPER72 */ 2377 2378 #endif /* GRF_AGA */ 2379 #endif /* GRF_NTSC */ 2380 2381 /* 2382 * PAL modes. 2383 */ 2384 2385 #if defined (GRF_PAL) 2386 2387 dmode_t * 2388 cc_init_pal_hires(void) 2389 { 2390 /* this function should only be called once. */ 2391 if (!ph_this) { 2392 u_short len = std_copper_list_len; 2393 2394 ph_this = &pal_hires_mode; 2395 ph_this_data = &pal_hires_mode_data; 2396 bzero(ph_this, sizeof(dmode_t)); 2397 bzero(ph_this_data, sizeof(dmdata_t)); 2398 2399 ph_this->name = "pal: hires"; 2400 ph_this->nominal_size.width = 640; 2401 ph_this->nominal_size.height = 256; 2402 ph_this_data->max_size.width = 724; 2403 ph_this_data->max_size.height = 289; 2404 ph_this_data->min_size.width = 320; 2405 ph_this_data->min_size.height = 244; 2406 ph_this_data->min_depth = 1; 2407 ph_this_data->max_depth = 4; 2408 ph_this->data = ph_this_data; 2409 2410 ph_this->get_monitor = cc_get_monitor; 2411 ph_this->alloc_view = cc_alloc_view; 2412 ph_this->get_current_view = cc_get_current_view; 2413 2414 ph_this_data->use_colormap = cc_use_colormap; 2415 ph_this_data->get_colormap = cc_get_colormap; 2416 ph_this_data->alloc_colormap = cc_alloc_colormap; 2417 ph_this_data->display_view = display_pal_hires_view; 2418 ph_this_data->monitor = cc_monitor; 2419 2420 ph_this_data->frames = pal_hires_frames; 2421 ph_this_data->frames[F_LONG] = alloc_chipmem(std_copper_list_size * F_TOTAL); 2422 if (!ph_this_data->frames[F_LONG]) { 2423 panic("couldn't get chipmem for copper list"); 2424 } 2425 ph_this_data->frames[F_STORE_LONG] = &ph_this_data->frames[F_LONG][len]; 2426 2427 bcopy(std_copper_list, ph_this_data->frames[F_STORE_LONG], std_copper_list_size); 2428 bcopy(std_copper_list, ph_this_data->frames[F_LONG], std_copper_list_size); 2429 2430 ph_this_data->bplcon0 = 0x8200 | USE_CON3; /* pal_hires, color 2431 * composite enable, 2432 * lace. */ 2433 ph_this_data->std_start_x = STANDARD_VIEW_X; 2434 ph_this_data->std_start_y = STANDARD_VIEW_Y; 2435 ph_this_data->vbl_handler = (vbl_handler_func *) cc_mode_vbl_handler; 2436 #if defined (GRF_ECS) || defined (GRF_AGA) 2437 ph_this_data->beamcon0 = STANDARD_PAL_BEAMCON; 2438 #endif 2439 2440 LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, ph_this, link); 2441 } 2442 return (ph_this); 2443 } 2444 2445 void 2446 display_pal_hires_view(view_t *v) 2447 { 2448 if (ph_this_data->current_view != v) { 2449 vdata_t *vd = VDATA(v); 2450 cop_t *cp = ph_this_data->frames[F_STORE_LONG], *tmp; 2451 int depth = v->bitmap->depth, i; 2452 int hstart, hstop, vstart, vstop, j; 2453 int x, y, w = v->display.width, h = v->display.height; 2454 u_short ddfstart, ddfwidth, con1; 2455 2456 /* round down to nearest even width */ 2457 /* w &= 0xfffe; */ 2458 2459 /* calculate datafetch width. */ 2460 ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 2) << 2; 2461 2462 /* This will center the any overscanned display */ 2463 /* and allow user to modify. */ 2464 x = v->display.x + ph_this_data->std_start_x - ((w - 640) >> 2); 2465 y = v->display.y + ph_this_data->std_start_y - ((h - 256) >> 1); 2466 2467 if (y & 1) 2468 y--; 2469 2470 if (!(x & 1)) 2471 x--; 2472 2473 hstart = x; 2474 hstop = x + (w >> 1); 2475 vstart = y; 2476 vstop = y + h; 2477 ddfstart = (hstart - 9) >> 1; 2478 /* check for hardware limits, AGA may allow more..? */ 2479 /* anyone got a 4000 I can borrow :^) -ch */ 2480 if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) { 2481 int d = 0; 2482 2483 /* XXX anyone know the equality properties of 2484 * intermixed logial AND's */ 2485 /* XXX and arithmetic operators? */ 2486 while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) { 2487 d++; 2488 } 2489 2490 ddfstart -= d; 2491 hstart -= d << 1; 2492 hstop -= d << 1; 2493 } 2494 /* correct the datafetch to proper limits. */ 2495 /* delay the actual display of the data until we need it. */ 2496 ddfstart &= 0xfffc; 2497 con1 = ((hstart - 9) - (ddfstart << 1)) | (((hstart - 9) - (ddfstart << 1)) << 4); 2498 2499 if (ph_this_data->current_view) { 2500 VDATA(ph_this_data->current_view)->flags &= ~VF_DISPLAY; /* mark as no longer */ 2501 /* displayed. */ 2502 } 2503 ph_this_data->current_view = v; 2504 2505 cp = ph_this_data->frames[F_STORE_LONG]; 2506 #if defined (GRF_ECS) || defined (GRF_AGA) 2507 #if defined (GRF_AGA) 2508 tmp = find_copper_inst(cp, CI_MOVE(R_FMODE)); 2509 tmp->cp.inst.operand = 0; 2510 #endif 2511 tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0)); 2512 tmp->cp.inst.operand = ph_this_data->beamcon0; 2513 tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH)); 2514 tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop); 2515 #endif /* ECS */ 2516 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0)); 2517 tmp->cp.inst.operand = ph_this_data->bplcon0 | ((depth & 0x7) << 12); 2518 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1)); 2519 tmp->cp.inst.operand = con1; 2520 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART)); 2521 tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff); 2522 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP)); 2523 tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff); 2524 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART)); 2525 tmp->cp.inst.operand = ddfstart; 2526 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP)); 2527 tmp->cp.inst.operand = ddfstart + ddfwidth; 2528 2529 tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH)); 2530 for (i = 0, j = 0; i < depth; j += 2, i++) { 2531 /* update the plane pointers */ 2532 tmp[j].cp.inst.operand = HIADDR(PREP_DMA_MEM(v->bitmap->plane[i])); 2533 tmp[j + 1].cp.inst.operand = LOADDR(PREP_DMA_MEM(v->bitmap->plane[i])); 2534 } 2535 2536 /* set mods correctly. */ 2537 tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD)); 2538 tmp[0].cp.inst.operand = v->bitmap->row_mod; 2539 tmp[1].cp.inst.operand = v->bitmap->row_mod; 2540 2541 /* set next pointers correctly */ 2542 tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH)); 2543 tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(ph_this_data->frames[F_STORE_LONG])); 2544 tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(ph_this_data->frames[F_STORE_LONG])); 2545 2546 cp = ph_this_data->frames[F_LONG]; 2547 ph_this_data->frames[F_LONG] = ph_this_data->frames[F_STORE_LONG]; 2548 ph_this_data->frames[F_STORE_LONG] = cp; 2549 2550 vd->flags |= VF_DISPLAY; 2551 cc_use_colormap(v, vd->colormap); 2552 } 2553 cc_load_mode(ph_this); 2554 } 2555 2556 dmode_t * 2557 cc_init_pal_hires_lace(void) 2558 { 2559 /* this function should only be called once. */ 2560 if (!phl_this) { 2561 u_short len = std_copper_list_len; 2562 2563 phl_this = &pal_hires_lace_mode; 2564 phl_this_data = &pal_hires_lace_mode_data; 2565 bzero(phl_this, sizeof(dmode_t)); 2566 bzero(phl_this_data, sizeof(dmdata_t)); 2567 2568 phl_this->name = "pal: hires interlace"; 2569 phl_this->nominal_size.width = 640; 2570 phl_this->nominal_size.height = 512; 2571 phl_this_data->max_size.width = 724; 2572 phl_this_data->max_size.height = 578; 2573 phl_this_data->min_size.width = 320; 2574 phl_this_data->min_size.height = 484; 2575 phl_this_data->min_depth = 1; 2576 phl_this_data->max_depth = 4; 2577 phl_this->data = phl_this_data; 2578 2579 phl_this->get_monitor = cc_get_monitor; 2580 phl_this->alloc_view = cc_alloc_view; 2581 phl_this->get_current_view = cc_get_current_view; 2582 2583 phl_this_data->use_colormap = cc_use_colormap; 2584 phl_this_data->get_colormap = cc_get_colormap; 2585 phl_this_data->alloc_colormap = cc_alloc_colormap; 2586 phl_this_data->display_view = display_pal_hires_lace_view; 2587 phl_this_data->monitor = cc_monitor; 2588 2589 phl_this_data->flags |= DMF_INTERLACE; 2590 2591 phl_this_data->frames = pal_hires_lace_frames; 2592 phl_this_data->frames[F_LACE_LONG] = alloc_chipmem(std_copper_list_size * F_LACE_TOTAL); 2593 if (!phl_this_data->frames[F_LACE_LONG]) { 2594 panic("couldn't get chipmem for copper list"); 2595 } 2596 phl_this_data->frames[F_LACE_SHORT] = &phl_this_data->frames[F_LACE_LONG][len]; 2597 phl_this_data->frames[F_LACE_STORE_LONG] = &phl_this_data->frames[F_LACE_SHORT][len]; 2598 phl_this_data->frames[F_LACE_STORE_SHORT] = &phl_this_data->frames[F_LACE_STORE_LONG][len]; 2599 2600 bcopy(std_copper_list, phl_this_data->frames[F_LACE_STORE_LONG], std_copper_list_size); 2601 bcopy(std_copper_list, phl_this_data->frames[F_LACE_STORE_SHORT], std_copper_list_size); 2602 bcopy(std_copper_list, phl_this_data->frames[F_LACE_LONG], std_copper_list_size); 2603 bcopy(std_copper_list, phl_this_data->frames[F_LACE_SHORT], std_copper_list_size); 2604 2605 phl_this_data->bplcon0 = 0x8204 | USE_CON3; /* hires, color 2606 * composite enable, 2607 * lace. */ 2608 phl_this_data->std_start_x = STANDARD_VIEW_X; 2609 phl_this_data->std_start_y = STANDARD_VIEW_Y; 2610 phl_this_data->vbl_handler = (vbl_handler_func *) cc_lace_mode_vbl_handler; 2611 #if defined (GRF_ECS) || defined (GRF_AGA) 2612 phl_this_data->beamcon0 = STANDARD_PAL_BEAMCON; 2613 #endif 2614 2615 LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, phl_this, link); 2616 } 2617 return (phl_this); 2618 } 2619 2620 void 2621 display_pal_hires_lace_view(view_t *v) 2622 { 2623 if (phl_this_data->current_view != v) { 2624 vdata_t *vd = VDATA(v); 2625 cop_t *cp = phl_this_data->frames[F_LACE_STORE_LONG], *tmp; 2626 int depth = v->bitmap->depth, i; 2627 int hstart, hstop, vstart, vstop, j; 2628 int x, y, w = v->display.width, h = v->display.height; 2629 u_short ddfstart, ddfwidth, con1; 2630 2631 /* round down to nearest even width */ 2632 /* w &= 0xfffe; */ 2633 2634 /* calculate datafetch width. */ 2635 ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 2) << 2; 2636 2637 /* This will center the any overscanned display */ 2638 /* and allow user to modify. */ 2639 x = v->display.x + phl_this_data->std_start_x - ((w - 640) >> 2); 2640 y = v->display.y + phl_this_data->std_start_y - ((h - 512) >> 2); 2641 2642 if (y & 1) 2643 y--; 2644 2645 if (!(x & 1)) 2646 x--; 2647 2648 hstart = x; 2649 hstop = x + (w >> 1); 2650 vstart = y; 2651 vstop = y + (h >> 1); 2652 ddfstart = (hstart - 9) >> 1; 2653 2654 /* check for hardware limits, AGA may allow more..? */ 2655 /* anyone got a 4000 I can borrow :^) -ch */ 2656 if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) { 2657 int d = 0; 2658 2659 /* XXX anyone know the equality properties of 2660 * intermixed logial AND's */ 2661 /* XXX and arithmetic operators? */ 2662 while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) { 2663 d++; 2664 } 2665 2666 ddfstart -= d; 2667 hstart -= d << 1; 2668 hstop -= d << 1; 2669 } 2670 /* correct the datafetch to proper limits. */ 2671 /* delay the actual display of the data until we need it. */ 2672 ddfstart &= 0xfffc; 2673 con1 = ((hstart - 9) - (ddfstart << 1)) | (((hstart - 9) - (ddfstart << 1)) << 4); 2674 2675 if (phl_this_data->current_view) { 2676 VDATA(phl_this_data->current_view)->flags &= ~VF_DISPLAY; /* mark as no longer */ 2677 /* displayed. */ 2678 } 2679 phl_this_data->current_view = v; 2680 2681 cp = phl_this_data->frames[F_LACE_STORE_LONG]; 2682 #if defined (GRF_ECS) || defined (GRF_AGA) 2683 #if defined (GRF_AGA) 2684 tmp = find_copper_inst(cp, CI_MOVE(R_FMODE)); 2685 tmp->cp.inst.operand = 0; 2686 #endif 2687 tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0)); 2688 tmp->cp.inst.operand = phl_this_data->beamcon0; 2689 tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH)); 2690 tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop); 2691 #endif /* ECS */ 2692 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0)); 2693 tmp->cp.inst.operand = phl_this_data->bplcon0 | ((depth & 0x7) << 12); 2694 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1)); 2695 tmp->cp.inst.operand = con1; 2696 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART)); 2697 tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff); 2698 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP)); 2699 tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff); 2700 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART)); 2701 tmp->cp.inst.operand = ddfstart; 2702 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP)); 2703 tmp->cp.inst.operand = ddfstart + ddfwidth; 2704 2705 tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH)); 2706 for (i = 0, j = 0; i < depth; j += 2, i++) { 2707 /* update the plane pointers */ 2708 tmp[j].cp.inst.operand = HIADDR(PREP_DMA_MEM(v->bitmap->plane[i])); 2709 tmp[j + 1].cp.inst.operand = LOADDR(PREP_DMA_MEM(v->bitmap->plane[i])); 2710 } 2711 2712 /* set mods correctly. */ 2713 tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD)); 2714 tmp[0].cp.inst.operand = v->bitmap->bytes_per_row + v->bitmap->row_mod; 2715 tmp[1].cp.inst.operand = v->bitmap->bytes_per_row + v->bitmap->row_mod; 2716 2717 /* set next pointers correctly */ 2718 tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH)); 2719 tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(phl_this_data->frames[F_LACE_STORE_SHORT])); 2720 tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(phl_this_data->frames[F_LACE_STORE_SHORT])); 2721 2722 2723 bcopy(phl_this_data->frames[F_LACE_STORE_LONG], phl_this_data->frames[F_LACE_STORE_SHORT], std_copper_list_size); 2724 2725 /* these are the only ones that are different from long frame. */ 2726 cp = phl_this_data->frames[F_LACE_STORE_SHORT]; 2727 tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH)); 2728 for (i = 0, j = 0; i < depth; j += 2, i++) { 2729 u_short mod = v->bitmap->bytes_per_row + v->bitmap->row_mod; 2730 /* update plane pointers. high and low. */ 2731 tmp[j].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[i][mod])); 2732 tmp[j + 1].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[i][mod])); 2733 } 2734 2735 /* set next pointers correctly */ 2736 tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH)); 2737 tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(phl_this_data->frames[F_LACE_STORE_LONG])); 2738 tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(phl_this_data->frames[F_LACE_STORE_LONG])); 2739 2740 2741 cp = phl_this_data->frames[F_LACE_LONG]; 2742 phl_this_data->frames[F_LACE_LONG] = phl_this_data->frames[F_LACE_STORE_LONG]; 2743 phl_this_data->frames[F_LACE_STORE_LONG] = cp; 2744 2745 cp = phl_this_data->frames[F_LACE_SHORT]; 2746 phl_this_data->frames[F_LACE_SHORT] = phl_this_data->frames[F_LACE_STORE_SHORT]; 2747 phl_this_data->frames[F_LACE_STORE_SHORT] = cp; 2748 2749 vd->flags |= VF_DISPLAY; 2750 cc_use_colormap(v, vd->colormap); 2751 } 2752 cc_load_mode(phl_this); 2753 } 2754 #if defined (GRF_A2024) 2755 2756 dmode_t * 2757 cc_init_pal_hires_dlace(void) 2758 { 2759 /* this function should only be called once. */ 2760 if (!phdl_this) { 2761 u_short len = std_dlace_copper_list_len; 2762 2763 phdl_this = &pal_hires_dlace_mode; 2764 phdl_this_data = &pal_hires_dlace_mode_data; 2765 bzero(phdl_this, sizeof(dmode_t)); 2766 bzero(phdl_this_data, sizeof(dmdata_t)); 2767 2768 phdl_this->name = "pal: hires double interlace"; 2769 phdl_this->nominal_size.width = 640; 2770 phdl_this->nominal_size.height = 1024; 2771 phdl_this_data->max_size.width = 724; 2772 phdl_this_data->max_size.height = 1024; 2773 phdl_this_data->min_size.width = 320; 2774 phdl_this_data->min_size.height = 512; 2775 phdl_this_data->min_depth = 1; 2776 phdl_this_data->max_depth = 2; 2777 phdl_this->data = phdl_this_data; 2778 2779 phdl_this->get_monitor = cc_get_monitor; 2780 phdl_this->alloc_view = cc_alloc_view; 2781 phdl_this->get_current_view = cc_get_current_view; 2782 2783 phdl_this_data->use_colormap = cc_a2024_use_colormap; 2784 phdl_this_data->get_colormap = cc_a2024_get_colormap; 2785 phdl_this_data->alloc_colormap = cc_a2024_alloc_colormap; 2786 phdl_this_data->display_view = display_pal_hires_dlace_view; 2787 phdl_this_data->monitor = cc_monitor; 2788 2789 phdl_this_data->flags |= DMF_INTERLACE; 2790 2791 phdl_this_data->frames = pal_hires_dlace_frames; 2792 phdl_this_data->frames[F_LACE_LONG] = alloc_chipmem(std_dlace_copper_list_size * F_LACE_TOTAL); 2793 if (!phdl_this_data->frames[F_LACE_LONG]) { 2794 panic("couldn't get chipmem for copper list"); 2795 } 2796 phdl_this_data->frames[F_LACE_SHORT] = &phdl_this_data->frames[F_LACE_LONG][len]; 2797 phdl_this_data->frames[F_LACE_STORE_LONG] = &phdl_this_data->frames[F_LACE_SHORT][len]; 2798 phdl_this_data->frames[F_LACE_STORE_SHORT] = &phdl_this_data->frames[F_LACE_STORE_LONG][len]; 2799 2800 bcopy(std_dlace_copper_list, phdl_this_data->frames[F_LACE_STORE_LONG], std_dlace_copper_list_size); 2801 bcopy(std_dlace_copper_list, phdl_this_data->frames[F_LACE_STORE_SHORT], std_dlace_copper_list_size); 2802 bcopy(std_dlace_copper_list, phdl_this_data->frames[F_LACE_LONG], std_dlace_copper_list_size); 2803 bcopy(std_dlace_copper_list, phdl_this_data->frames[F_LACE_SHORT], std_dlace_copper_list_size); 2804 2805 phdl_this_data->bplcon0 = 0x8204 | USE_CON3; /* hires, color 2806 * composite enable, 2807 * dlace. */ 2808 phdl_this_data->std_start_x = STANDARD_VIEW_X; 2809 phdl_this_data->std_start_y = STANDARD_VIEW_Y; 2810 phdl_this_data->vbl_handler = (vbl_handler_func *) cc_lace_mode_vbl_handler; 2811 #if defined (GRF_ECS) || defined (GRF_AGA) 2812 phdl_this_data->beamcon0 = STANDARD_PAL_BEAMCON; 2813 #endif 2814 2815 LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, phdl_this, link); 2816 } 2817 return (phdl_this); 2818 } 2819 2820 void 2821 display_pal_hires_dlace_view(view_t *v) 2822 { 2823 if (phdl_this_data->current_view != v) { 2824 vdata_t *vd = VDATA(v); 2825 cop_t *cp = phdl_this_data->frames[F_LACE_STORE_LONG], *tmp; 2826 int depth = v->bitmap->depth; 2827 int hstart, hstop, vstart, vstop; 2828 int x, y, w = v->display.width, h = v->display.height; 2829 u_short ddfstart, ddfwidth, con1; 2830 u_short mod1l, mod2l; 2831 2832 /* round down to nearest even width */ 2833 /* w &= 0xfffe; */ 2834 2835 /* calculate datafetch width. */ 2836 ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 2) << 2; 2837 2838 /* This will center the any overscanned display */ 2839 /* and allow user to modify. */ 2840 x = v->display.x + phdl_this_data->std_start_x - ((w - 640) >> 2); 2841 y = v->display.y + phdl_this_data->std_start_y - ((h - 1024) >> 3); 2842 2843 if (y & 1) 2844 y--; 2845 2846 if (!(x & 1)) 2847 x--; 2848 2849 hstart = x; 2850 hstop = x + (w >> 1); 2851 vstart = y; 2852 vstop = y + (h >> 2); 2853 ddfstart = (hstart - 9) >> 1; 2854 2855 /* check for hardware limits, AGA may allow more..? */ 2856 /* anyone got a 4000 I can borrow :^) -ch */ 2857 if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) { 2858 int d = 0; 2859 2860 /* XXX anyone know the equality properties of 2861 * intermixed logial AND's */ 2862 /* XXX and arithmetic operators? */ 2863 while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) { 2864 d++; 2865 } 2866 2867 ddfstart -= d; 2868 hstart -= d << 1; 2869 hstop -= d << 1; 2870 } 2871 /* correct the datafetch to proper limits. */ 2872 /* delay the actual display of the data until we need it. */ 2873 ddfstart &= 0xfffc; 2874 con1 = ((hstart - 9) - (ddfstart << 1)) | (((hstart - 9) - (ddfstart << 1)) << 4); 2875 2876 if (phdl_this_data->current_view) { 2877 VDATA(phdl_this_data->current_view)->flags &= ~VF_DISPLAY; /* mark as no longer */ 2878 /* displayed. */ 2879 } 2880 phdl_this_data->current_view = v; 2881 2882 cp = phdl_this_data->frames[F_LACE_STORE_LONG]; 2883 #if defined (GRF_ECS) || defined (GRF_AGA) 2884 #if defined (GRF_AGA) 2885 tmp = find_copper_inst(cp, CI_MOVE(R_FMODE)); 2886 tmp->cp.inst.operand = 0; 2887 #endif 2888 tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0)); 2889 tmp->cp.inst.operand = phdl_this_data->beamcon0; 2890 tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH)); 2891 tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop); 2892 #endif /* ECS */ 2893 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0)); 2894 tmp->cp.inst.operand = phdl_this_data->bplcon0 | ((depth & 0x7) << 13); /* times two. */ 2895 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1)); 2896 tmp->cp.inst.operand = con1; 2897 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART)); 2898 tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff); 2899 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP)); 2900 tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff); 2901 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART)); 2902 tmp->cp.inst.operand = ddfstart; 2903 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP)); 2904 tmp->cp.inst.operand = ddfstart + ddfwidth; 2905 2906 mod1l = v->bitmap->bytes_per_row + v->bitmap->row_mod; 2907 mod2l = mod1l << 1; 2908 2909 tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH)); 2910 tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][0])); /* update plane 2911 * pointers. */ 2912 tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][0])); /* high and low. */ 2913 tmp[2].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod1l])); /* update plane 2914 * pointers. */ 2915 tmp[3].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod1l])); /* high and low. */ 2916 if (depth == 2) { 2917 tmp[4].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][0])); /* update plane 2918 * pointers. */ 2919 tmp[5].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][0])); /* high and low. */ 2920 tmp[6].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod1l])); /* update plane 2921 * pointers. */ 2922 tmp[7].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod1l])); /* high and low. */ 2923 } 2924 /* set mods correctly. */ 2925 tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD)); 2926 tmp[0].cp.inst.operand = mod2l + mod1l; 2927 tmp[1].cp.inst.operand = mod2l + mod1l; 2928 2929 /* set next pointers correctly */ 2930 tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH)); 2931 tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(phdl_this_data->frames[F_LACE_STORE_SHORT])); 2932 tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(phdl_this_data->frames[F_LACE_STORE_SHORT])); 2933 2934 bcopy(phdl_this_data->frames[F_LACE_STORE_LONG], phdl_this_data->frames[F_LACE_STORE_SHORT], std_dlace_copper_list_size); 2935 2936 /* these are the only ones that are different from long frame. */ 2937 cp = phdl_this_data->frames[F_LACE_STORE_SHORT]; 2938 tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH)); 2939 tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l])); /* update plane 2940 * pointers. */ 2941 tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l])); /* high and low. */ 2942 tmp[2].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l + mod1l])); /* update plane 2943 * pointers. */ 2944 tmp[3].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[0][mod2l + mod1l])); /* high and low. */ 2945 if (depth == 2) { 2946 tmp[4].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l])); /* update plane 2947 * pointers. */ 2948 tmp[5].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l])); /* high and low. */ 2949 tmp[6].cp.inst.operand = HIADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l + mod1l])); /* update plane 2950 * pointers. */ 2951 tmp[7].cp.inst.operand = LOADDR(PREP_DMA_MEM(&v->bitmap->plane[1][mod2l + mod1l])); /* high and low. */ 2952 } 2953 /* set next pointers correctly */ 2954 tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH)); 2955 tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(phdl_this_data->frames[F_LACE_STORE_LONG])); 2956 tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(phdl_this_data->frames[F_LACE_STORE_LONG])); 2957 2958 cp = phdl_this_data->frames[F_LACE_LONG]; 2959 phdl_this_data->frames[F_LACE_LONG] = phdl_this_data->frames[F_LACE_STORE_LONG]; 2960 phdl_this_data->frames[F_LACE_STORE_LONG] = cp; 2961 2962 cp = phdl_this_data->frames[F_LACE_SHORT]; 2963 phdl_this_data->frames[F_LACE_SHORT] = phdl_this_data->frames[F_LACE_STORE_SHORT]; 2964 phdl_this_data->frames[F_LACE_STORE_SHORT] = cp; 2965 2966 vd->flags |= VF_DISPLAY; 2967 2968 cc_a2024_use_colormap(v, vd->colormap); 2969 } 2970 cc_load_mode(phdl_this); 2971 } 2972 2973 dmode_t * 2974 cc_init_pal_a2024(void) 2975 { 2976 /* this function should only be called once. */ 2977 if (!p24_this) { 2978 int i; 2979 u_short len = std_pal_a2024_copper_list_len; 2980 cop_t *cp; 2981 2982 p24_this = &pal_a2024_mode; 2983 p24_this_data = &pal_a2024_mode_data; 2984 bzero(p24_this, sizeof(dmode_t)); 2985 bzero(p24_this_data, sizeof(dmdata_t)); 2986 2987 p24_this->name = "pal: A2024 15 kHz"; 2988 p24_this->nominal_size.width = 1024; 2989 p24_this->nominal_size.height = 1024; 2990 p24_this_data->max_size.width = 1024; 2991 p24_this_data->max_size.height = 1024; 2992 p24_this_data->min_size.width = 1024; 2993 p24_this_data->min_size.height = 1024; 2994 p24_this_data->min_depth = 1; 2995 p24_this_data->max_depth = 2; 2996 p24_this->data = p24_this_data; 2997 2998 p24_this->get_monitor = cc_get_monitor; 2999 p24_this->alloc_view = cc_alloc_view; 3000 p24_this->get_current_view = cc_get_current_view; 3001 3002 p24_this_data->use_colormap = cc_a2024_use_colormap; 3003 p24_this_data->get_colormap = cc_a2024_get_colormap; 3004 p24_this_data->display_view = display_pal_a2024_view; 3005 p24_this_data->alloc_colormap = cc_a2024_alloc_colormap; 3006 p24_this_data->monitor = cc_monitor; 3007 3008 p24_this_data->flags |= DMF_HEDLEY_EXP; 3009 3010 p24_this_data->frames = pal_a2024_frames; 3011 p24_this_data->frames[F_QD_QUAD0] = alloc_chipmem(std_pal_a2024_copper_list_size * F_QD_TOTAL); 3012 if (!p24_this_data->frames[F_QD_QUAD0]) { 3013 panic("couldn't get chipmem for copper list"); 3014 } 3015 /* setup the hedley init bitplane. */ 3016 hedley_init = alloc_chipmem(128); 3017 if (!hedley_init) { 3018 panic("couldn't get chipmem for hedley init bitplane"); 3019 } 3020 for (i = 1; i < 128; i++) 3021 hedley_init[i] = 0xff; 3022 hedley_init[0] = 0x03; 3023 3024 /* copy image of standard copper list. */ 3025 bcopy(std_pal_a2024_copper_list, p24_this_data->frames[0], std_pal_a2024_copper_list_size); 3026 3027 /* set the init plane pointer. */ 3028 cp = find_copper_inst(p24_this_data->frames[F_QD_QUAD0], CI_MOVE(R_BPL0PTH)); 3029 cp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(hedley_init)); 3030 cp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(hedley_init)); 3031 3032 for (i = 1; i < F_QD_TOTAL; i++) { 3033 p24_this_data->frames[i] = &p24_this_data->frames[i - 1][len]; 3034 bcopy(p24_this_data->frames[0], p24_this_data->frames[i], std_pal_a2024_copper_list_size); 3035 } 3036 3037 p24_this_data->bplcon0 = 0x8200; /* hires */ 3038 p24_this_data->vbl_handler = (vbl_handler_func *) pal_a2024_mode_vbl_handler; 3039 3040 3041 LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, p24_this, link); 3042 } 3043 return (p24_this); 3044 } 3045 3046 void 3047 display_pal_a2024_view(view_t *v) 3048 { 3049 if (p24_this_data->current_view != v) { 3050 vdata_t *vd = VDATA(v); 3051 cop_t *cp, *tmp; 3052 u_char *inst_plane[2]; 3053 u_char **plane = inst_plane; 3054 u_long full_line = v->bitmap->bytes_per_row + v->bitmap->row_mod; 3055 u_long half_plane = full_line * v->bitmap->rows / 2; 3056 3057 int depth = v->bitmap->depth, i, j; 3058 3059 plane[0] = v->bitmap->plane[0]; 3060 if (depth == 2) { 3061 plane[1] = v->bitmap->plane[1]; 3062 } 3063 if (p24_this_data->current_view) { 3064 VDATA(p24_this_data->current_view)->flags &= ~VF_DISPLAY; /* mark as no longer 3065 * displayed. */ 3066 } 3067 cp = p24_this_data->frames[F_QD_STORE_QUAD0]; 3068 tmp = find_copper_inst(cp, CI_MOVE(R_COLOR1F)); 3069 tmp = find_copper_inst(tmp, CI_MOVE(R_BPLCON0)); /* grab third one. */ 3070 tmp->cp.inst.operand = p24_this_data->bplcon0 | ((depth & 0x7) << 13); /* times 2 */ 3071 3072 bcopy(p24_this_data->frames[F_QD_STORE_QUAD0], p24_this_data->frames[F_QD_STORE_QUAD1], std_pal_a2024_copper_list_size); 3073 bcopy(p24_this_data->frames[F_QD_STORE_QUAD0], p24_this_data->frames[F_QD_STORE_QUAD2], std_pal_a2024_copper_list_size); 3074 bcopy(p24_this_data->frames[F_QD_STORE_QUAD0], p24_this_data->frames[F_QD_STORE_QUAD3], std_pal_a2024_copper_list_size); 3075 3076 /* 3077 * Mark Id's 3078 */ 3079 tmp = find_copper_inst(p24_this_data->frames[F_QD_STORE_QUAD1], CI_WAIT(126, 29)); 3080 CBUMP(tmp); 3081 CMOVE(tmp, R_COLOR01, QUAD1_ID); 3082 tmp = find_copper_inst(p24_this_data->frames[F_QD_STORE_QUAD2], CI_WAIT(126, 29)); 3083 CBUMP(tmp); 3084 CMOVE(tmp, R_COLOR01, QUAD2_ID); 3085 tmp = find_copper_inst(p24_this_data->frames[F_QD_STORE_QUAD3], CI_WAIT(126, 29)); 3086 CBUMP(tmp); 3087 CMOVE(tmp, R_COLOR01, QUAD3_ID); 3088 3089 plane[0]--; 3090 plane[0]--; 3091 if (depth == 2) { 3092 plane[1]--; 3093 plane[1]--; 3094 } 3095 /* 3096 * Set bitplane pointers. 3097 */ 3098 tmp = find_copper_inst(p24_this_data->frames[F_QD_STORE_QUAD0], CI_MOVE(R_BPLMOD2)); 3099 CBUMP(tmp); 3100 CMOVE(tmp, R_BPL0PTH, HIADDR(PREP_DMA_MEM(&plane[0][0]))); 3101 CMOVE(tmp, R_BPL0PTL, LOADDR(PREP_DMA_MEM(&plane[0][0]))); 3102 CMOVE(tmp, R_BPL1PTH, HIADDR(PREP_DMA_MEM(&plane[0][full_line]))); 3103 CMOVE(tmp, R_BPL1PTL, LOADDR(PREP_DMA_MEM(&plane[0][full_line]))); 3104 if (depth == 2) { 3105 CMOVE(tmp, R_BPL2PTH, HIADDR(PREP_DMA_MEM(&plane[1][0]))); 3106 CMOVE(tmp, R_BPL2PTL, LOADDR(PREP_DMA_MEM(&plane[1][0]))); 3107 CMOVE(tmp, R_BPL3PTH, HIADDR(PREP_DMA_MEM(&plane[1][full_line]))); 3108 CMOVE(tmp, R_BPL3PTL, LOADDR(PREP_DMA_MEM(&plane[1][full_line]))); 3109 } 3110 #if defined (GRF_ECS) || defined (GRF_AGA) 3111 CMOVE(tmp, R_DIWHIGH, 0x2100); 3112 #endif 3113 CMOVE(tmp, R_COP1LCH, HIADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD1]))); 3114 CMOVE(tmp, R_COP1LCL, LOADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD1]))); 3115 CEND(tmp); 3116 CEND(tmp); 3117 3118 tmp = find_copper_inst(p24_this_data->frames[F_QD_STORE_QUAD1], CI_MOVE(R_BPLMOD2)); 3119 CBUMP(tmp); 3120 CMOVE(tmp, R_BPL0PTH, HIADDR(PREP_DMA_MEM(&plane[0][HALF_2024_LINE]))); 3121 CMOVE(tmp, R_BPL0PTL, LOADDR(PREP_DMA_MEM(&plane[0][HALF_2024_LINE]))); 3122 CMOVE(tmp, R_BPL1PTH, HIADDR(PREP_DMA_MEM(&plane[0][full_line + HALF_2024_LINE]))); 3123 CMOVE(tmp, R_BPL1PTL, LOADDR(PREP_DMA_MEM(&plane[0][full_line + HALF_2024_LINE]))); 3124 if (depth == 2) { 3125 CMOVE(tmp, R_BPL2PTH, HIADDR(PREP_DMA_MEM(&plane[1][HALF_2024_LINE]))); 3126 CMOVE(tmp, R_BPL2PTL, LOADDR(PREP_DMA_MEM(&plane[1][HALF_2024_LINE]))); 3127 CMOVE(tmp, R_BPL3PTH, HIADDR(PREP_DMA_MEM(&plane[1][full_line + HALF_2024_LINE]))); 3128 CMOVE(tmp, R_BPL3PTL, LOADDR(PREP_DMA_MEM(&plane[1][full_line + HALF_2024_LINE]))); 3129 } 3130 #if defined (GRF_ECS) || defined (GRF_AGA) 3131 CMOVE(tmp, R_DIWHIGH, 0x2100); 3132 #endif 3133 CMOVE(tmp, R_COP1LCH, HIADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD2]))); 3134 CMOVE(tmp, R_COP1LCL, LOADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD2]))); 3135 CEND(tmp); 3136 CEND(tmp); 3137 3138 tmp = find_copper_inst(p24_this_data->frames[F_QD_STORE_QUAD2], CI_MOVE(R_BPLMOD2)); 3139 CBUMP(tmp); 3140 CMOVE(tmp, R_BPL0PTH, HIADDR(PREP_DMA_MEM(&plane[0][half_plane]))); 3141 CMOVE(tmp, R_BPL0PTL, LOADDR(PREP_DMA_MEM(&plane[0][half_plane]))); 3142 CMOVE(tmp, R_BPL1PTH, HIADDR(PREP_DMA_MEM(&plane[0][half_plane + full_line]))); 3143 CMOVE(tmp, R_BPL1PTL, LOADDR(PREP_DMA_MEM(&plane[0][half_plane + full_line]))); 3144 if (depth == 2) { 3145 CMOVE(tmp, R_BPL2PTH, HIADDR(PREP_DMA_MEM(&plane[1][half_plane]))); 3146 CMOVE(tmp, R_BPL2PTL, LOADDR(PREP_DMA_MEM(&plane[1][half_plane]))); 3147 CMOVE(tmp, R_BPL3PTH, HIADDR(PREP_DMA_MEM(&plane[1][half_plane + full_line]))); 3148 CMOVE(tmp, R_BPL3PTL, LOADDR(PREP_DMA_MEM(&plane[1][half_plane + full_line]))); 3149 } 3150 #if defined (GRF_ECS) || defined (GRF_AGA) 3151 CMOVE(tmp, R_DIWHIGH, 0x2100); 3152 #endif 3153 CMOVE(tmp, R_COP1LCH, HIADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD3]))); 3154 CMOVE(tmp, R_COP1LCL, LOADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD3]))); 3155 CEND(tmp); 3156 CEND(tmp); 3157 3158 tmp = find_copper_inst(p24_this_data->frames[F_QD_STORE_QUAD3], CI_MOVE(R_BPLMOD2)); 3159 CBUMP(tmp); 3160 CMOVE(tmp, R_BPL0PTH, HIADDR(PREP_DMA_MEM(&plane[0][half_plane + HALF_2024_LINE]))); 3161 CMOVE(tmp, R_BPL0PTL, LOADDR(PREP_DMA_MEM(&plane[0][half_plane + HALF_2024_LINE]))); 3162 CMOVE(tmp, R_BPL1PTH, HIADDR(PREP_DMA_MEM(&plane[0][half_plane + full_line + HALF_2024_LINE]))); 3163 CMOVE(tmp, R_BPL1PTL, LOADDR(PREP_DMA_MEM(&plane[0][half_plane + full_line + HALF_2024_LINE]))); 3164 if (depth == 2) { 3165 CMOVE(tmp, R_BPL2PTH, HIADDR(PREP_DMA_MEM(&plane[1][half_plane + HALF_2024_LINE]))); 3166 CMOVE(tmp, R_BPL2PTL, LOADDR(PREP_DMA_MEM(&plane[1][half_plane + HALF_2024_LINE]))); 3167 CMOVE(tmp, R_BPL3PTH, HIADDR(PREP_DMA_MEM(&plane[1][half_plane + full_line + HALF_2024_LINE]))); 3168 CMOVE(tmp, R_BPL3PTL, LOADDR(PREP_DMA_MEM(&plane[1][half_plane + full_line + HALF_2024_LINE]))); 3169 } 3170 #if defined (GRF_ECS) || defined (GRF_AGA) 3171 CMOVE(tmp, R_DIWHIGH, 0x2100); 3172 #endif 3173 CMOVE(tmp, R_COP1LCH, HIADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD0]))); 3174 CMOVE(tmp, R_COP1LCL, LOADDR(PREP_DMA_MEM(p24_this_data->frames[F_QD_STORE_QUAD0]))); 3175 CEND(tmp); 3176 CEND(tmp); 3177 3178 /* swap new pointers in. */ 3179 for (i = F_QD_STORE_QUAD0, j = F_QD_QUAD0; 3180 i <= F_QD_STORE_QUAD3; i++, j++) { 3181 cp = p24_this_data->frames[j]; 3182 p24_this_data->frames[j] = p24_this_data->frames[i]; 3183 p24_this_data->frames[i] = cp; 3184 } 3185 3186 p24_this_data->current_view = v; 3187 vd->flags |= VF_DISPLAY; 3188 3189 cc_a2024_use_colormap(v, vd->colormap); 3190 } 3191 cc_load_mode(p24_this); 3192 } 3193 3194 void 3195 pal_a2024_mode_vbl_handler(dmode_t *d) 3196 { 3197 u_short vp = ((custom.vposr & 0x0007) << 8) | ((custom.vhposr) >> 8); 3198 3199 if (vp < 20) { 3200 custom.cop1lc = PREP_DMA_MEM(p24_this_data->frames[p24_this_data->hedley_current]); 3201 custom.copjmp1 = 0; 3202 } 3203 p24_this_data->hedley_current++; 3204 p24_this_data->hedley_current &= 0x3; /* if 4 then 0. */ 3205 } 3206 #endif /* GRF_A2024 */ 3207 3208 #if defined (GRF_AGA) 3209 3210 dmode_t * 3211 cc_init_pal_aga(void) 3212 { 3213 /* this function should only be called once. */ 3214 if (!paga_this && (custom.deniseid & 0xff) == 0xf8 && 3215 aga_enable & AGA_ENABLE) { 3216 u_short len = aga_copper_list_len; 3217 3218 paga_this = &paga_mode; 3219 paga_this_data = &paga_mode_data; 3220 bzero(paga_this, sizeof(dmode_t)); 3221 bzero(paga_this_data, sizeof(dmdata_t)); 3222 3223 paga_this->name = "pal: AGA dbl"; 3224 paga_this->nominal_size.width = 640; 3225 paga_this->nominal_size.height = 512; 3226 paga_this_data->max_size.width = 720; 3227 paga_this_data->max_size.height = 564; 3228 paga_this_data->min_size.width = 320; 3229 paga_this_data->min_size.height = 200; 3230 paga_this_data->min_depth = 1; 3231 paga_this_data->max_depth = 8; 3232 paga_this->data = paga_this_data; 3233 3234 paga_this->get_monitor = cc_get_monitor; 3235 paga_this->alloc_view = cc_alloc_view; 3236 paga_this->get_current_view = cc_get_current_view; 3237 3238 paga_this_data->use_colormap = cc_use_aga_colormap; 3239 paga_this_data->get_colormap = cc_get_colormap; 3240 paga_this_data->alloc_colormap = cc_alloc_aga_colormap; 3241 paga_this_data->display_view = display_pal_aga_view; 3242 paga_this_data->monitor = cc_monitor; 3243 3244 paga_this_data->frames = paga_frames; 3245 paga_this_data->frames[F_LONG] = alloc_chipmem(aga_copper_list_size * F_TOTAL); 3246 if (!paga_this_data->frames[F_LONG]) { 3247 panic("couldn't get chipmem for copper list"); 3248 } 3249 paga_this_data->frames[F_STORE_LONG] = &paga_this_data->frames[F_LONG][len]; 3250 3251 bcopy(aga_copper_list, paga_this_data->frames[F_STORE_LONG], aga_copper_list_size); 3252 bcopy(aga_copper_list, paga_this_data->frames[F_LONG], aga_copper_list_size); 3253 3254 paga_this_data->bplcon0 = 0x0240 | USE_CON3; /* color composite 3255 * enable, 3256 * shres. */ 3257 paga_this_data->std_start_x = 0x4f /*STANDARD_VIEW_X*/; 3258 paga_this_data->std_start_y = 0x2b /*STANDARD_VIEW_Y*/; 3259 paga_this_data->vbl_handler = (vbl_handler_func *) cc_mode_vbl_handler; 3260 paga_this_data->beamcon0 = STANDARD_PAL_BEAMCON | (SPECIAL_BEAMCON ^ VSYNCTRUE); 3261 3262 LIST_INSERT_HEAD(&MDATA(cc_monitor)->modes, 3263 paga_this, link); 3264 } 3265 return (paga_this); 3266 } 3267 3268 /* static, so I can patch and play */ 3269 3270 #ifdef GRF_AGA_VGA 3271 int pAGA_htotal = 0x079; 3272 int pAGA_vtotal = 0x24d; 3273 int pAGA_vbstop = 0x019; 3274 int pAGA_hcenter = 0x04b; 3275 #else 3276 int pAGA_htotal = 0x081; 3277 int pAGA_vtotal = 0x23d; 3278 int pAGA_vbstop = 0x017; 3279 int pAGA_hcenter = 0x04f; 3280 #endif 3281 int pAGA_hsstrt = 0x00f; 3282 int pAGA_hsstop = 0x019; 3283 int pAGA_hbstrt = 0x001; 3284 int pAGA_hbstop = 0x021; 3285 int pAGA_vsstrt = 0x001; 3286 int pAGA_vsstop = 0x008; 3287 int pAGA_vbstrt = 0x000; 3288 3289 void 3290 display_pal_aga_view(view_t *v) 3291 { 3292 if (paga_this_data->current_view != v) { 3293 vdata_t *vd = VDATA(v); 3294 cop_t *cp = paga_this_data->frames[F_STORE_LONG], *tmp; 3295 int depth = v->bitmap->depth, i; 3296 int hstart, hstop, vstart, vstop, j; 3297 int x, y, w = v->display.width, h = v->display.height; 3298 u_short ddfstart, ddfwidth, con1; 3299 3300 #ifdef DEBUG 3301 if (aga_enable & AGA_TRACE) 3302 printf("display_aga_view(%dx%dx%d) %p\n", w, h, 3303 depth, v); 3304 #endif 3305 /* round down to nearest even width */ 3306 /* w &= 0xfffe; */ 3307 /* calculate datafetch width. */ 3308 3309 ddfwidth = ((v->bitmap->bytes_per_row >> 1) - 4) << 1; 3310 3311 /* this will center the any overscanned display */ 3312 /* and allow user to modify. */ 3313 x = v->display.x + paga_this_data->std_start_x - ((w - 640) >> 3); 3314 y = v->display.y + paga_this_data->std_start_y - ((h - 512) >> 1); 3315 3316 if (y & 1) 3317 y--; 3318 3319 if (!(x & 1)) 3320 x--; 3321 3322 hstart = x; 3323 hstop = x + (w >> 2); 3324 vstart = y; 3325 vstop = y + (h >> 0); 3326 ddfstart = (hstart >> 1) - 8; 3327 3328 #ifdef DEBUG 3329 if (aga_enable & AGA_TRACE2) { 3330 printf (" ddfwidth %04x x %04x y %04x", ddfwidth, 3331 x, y); 3332 printf (" hstart %04x hstop %04x vstart %04x vstop %04x ddfstart %04x\n", 3333 hstart, hstop, vstart, vstop, ddfstart); 3334 } 3335 #endif 3336 /* check for hardware limits, AGA may allow more..? */ 3337 /* anyone got a 4000 I can borrow :^) -ch */ 3338 if ((ddfstart & 0xfffc) + ddfwidth > 0xd8) { 3339 int d = 0; 3340 3341 /* XXX anyone know the equality properties of 3342 * intermixed logial AND's */ 3343 /* XXX and arithmetic operators? */ 3344 while (((ddfstart & 0xfffc) + ddfwidth - d) > 0xd8) { 3345 d++; 3346 } 3347 3348 ddfstart -= d; 3349 hstart -= d << 1; 3350 hstop -= d << 1; 3351 } 3352 /* correct the datafetch to proper limits. */ 3353 /* delay the actual display of the data until we need it. */ 3354 ddfstart &= 0xfffc; 3355 #ifdef DEBUG 3356 if (aga_enable & AGA_TRACE2) { 3357 printf (" ddfwidth %04x x %04x y %04x", ddfwidth, 3358 x, y); 3359 printf (" hstart %04x hstop %04x vstart %04x vstop %04x ddfstart %04x\n", 3360 hstart, hstop, vstart, vstop, ddfstart); 3361 } 3362 #endif 3363 con1 = ((hstart - 9) - (ddfstart << 1)) | (((hstart - 9) - (ddfstart << 1)) << 4); 3364 3365 if (paga_this_data->current_view) { 3366 VDATA(paga_this_data->current_view)->flags &= ~VF_DISPLAY; /* mark as no longer */ 3367 /* displayed. */ 3368 } 3369 paga_this_data->current_view = v; 3370 3371 cp = paga_this_data->frames[F_STORE_LONG]; 3372 tmp = cp; 3373 for (i = 0; i < 8; ++i) { 3374 if (tmp == NULL) 3375 break; 3376 tmp = find_copper_inst(tmp + 1, CI_MOVE(R_BPLCON3)); 3377 if (tmp == NULL) 3378 break; 3379 tmp->cp.inst.operand = 0x0ca1 | (i << 13); 3380 tmp = find_copper_inst(tmp + 1, CI_MOVE(R_BPLCON3)); 3381 if (tmp == NULL) 3382 break; 3383 tmp->cp.inst.operand = 0x0ea1 | (i << 13); 3384 } 3385 if (tmp) 3386 tmp = find_copper_inst(tmp + 1, CI_MOVE(R_BPLCON3)); 3387 if (tmp) 3388 tmp->cp.inst.operand = 0x0ca1; 3389 tmp = find_copper_inst(cp, CI_MOVE(R_FMODE)); 3390 tmp->cp.inst.operand = 0x8003; 3391 tmp = find_copper_inst(cp, CI_MOVE(R_HTOTAL)); 3392 tmp->cp.inst.operand = pAGA_htotal; /* 81/71/73/79? */ 3393 tmp = find_copper_inst(cp, CI_MOVE(R_HBSTRT)); 3394 tmp->cp.inst.operand = pAGA_hbstrt; /* 0x0008 */ 3395 tmp = find_copper_inst(cp, CI_MOVE(R_HSSTRT)); 3396 tmp->cp.inst.operand = pAGA_hsstrt; /* 0x000e */ 3397 tmp = find_copper_inst(cp, CI_MOVE(R_HSSTOP)); 3398 tmp->cp.inst.operand = pAGA_hsstop; /* 0x001c */ 3399 tmp = find_copper_inst(cp, CI_MOVE(R_HBSTOP)); 3400 tmp->cp.inst.operand = pAGA_hsstop; /* 0x001e */ 3401 tmp = find_copper_inst(cp, CI_MOVE(R_HCENTER)); 3402 tmp->cp.inst.operand = pAGA_hcenter; /*AGA_htotal / 2 + AGA_hsstrt */ 3403 tmp = find_copper_inst(cp, CI_MOVE(R_VBSTRT)); 3404 tmp->cp.inst.operand = pAGA_vbstrt; /* 0x0000 */ 3405 tmp = find_copper_inst(cp, CI_MOVE(R_VSSTRT)); 3406 tmp->cp.inst.operand = pAGA_vsstrt; /* 0x016b / AGA_htotal */ 3407 tmp = find_copper_inst(cp, CI_MOVE(R_VSSTOP)); 3408 tmp->cp.inst.operand = pAGA_vsstop; /* 0x02d6 / AGA_htotal */ 3409 tmp = find_copper_inst(cp, CI_MOVE(R_VBSTOP)); 3410 tmp->cp.inst.operand = pAGA_vbstop; /* 0x0bd1 / AGA_htotal */ 3411 tmp = find_copper_inst(cp, CI_MOVE(R_VTOTAL)); 3412 tmp->cp.inst.operand = pAGA_vtotal; 3413 tmp = find_copper_inst(cp, CI_MOVE(R_BEAMCON0)); 3414 tmp->cp.inst.operand = paga_this_data->beamcon0; 3415 #ifdef DEBUG 3416 if (aga_enable & AGA_TRACE2) 3417 printf(" beamcon0 %04x", tmp->cp.inst.operand); 3418 #endif 3419 tmp = find_copper_inst(cp, CI_MOVE(R_DIWHIGH)); 3420 tmp->cp.inst.operand = CALC_DIWHIGH(hstart, vstart, hstop, vstop); 3421 #ifdef DEBUG 3422 if (aga_enable & AGA_TRACE2) 3423 printf(" diwhigh %04x>", tmp->cp.inst.operand); 3424 #endif 3425 #if 0 3426 tmp->cp.inst.operand = (vstop & 0x0700) | ((hstop & 0x0100) << 5); 3427 #endif 3428 #ifdef DEBUG 3429 if (aga_enable & AGA_TRACE2) 3430 printf("%04x", tmp->cp.inst.operand); 3431 #endif 3432 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON0)); 3433 tmp->cp.inst.operand = paga_this_data->bplcon0 | 3434 ((depth & 0x7) << 12) | ((depth & 0x8) << 1); 3435 #ifdef DEBUG 3436 if (aga_enable & AGA_TRACE2) 3437 printf(" bplcon0 %04x", tmp->cp.inst.operand); 3438 #endif 3439 tmp = find_copper_inst(cp, CI_MOVE(R_BPLCON1)); 3440 tmp->cp.inst.operand = con1; 3441 #ifdef DEBUG 3442 if (aga_enable & AGA_TRACE2) 3443 printf(" bplcon1 %04x>0000\n", con1); 3444 #endif 3445 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTART)); 3446 tmp->cp.inst.operand = ((vstart & 0xff) << 8) | (hstart & 0xff); 3447 #ifdef DEBUG 3448 if (aga_enable & AGA_TRACE2) 3449 printf(" diwstart %04x", tmp->cp.inst.operand); 3450 #endif 3451 tmp = find_copper_inst(cp, CI_MOVE(R_DIWSTOP)); 3452 tmp->cp.inst.operand = ((vstop & 0xff) << 8) | (hstop & 0xff); 3453 #ifdef DEBUG 3454 if (aga_enable & AGA_TRACE2) 3455 printf(" diwstop %04x", tmp->cp.inst.operand); 3456 #endif 3457 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTART)); 3458 tmp->cp.inst.operand = ddfstart; 3459 #ifdef DEBUG 3460 if (aga_enable & AGA_TRACE2) 3461 printf(" ddfstart %04x", tmp->cp.inst.operand); 3462 #endif 3463 tmp = find_copper_inst(cp, CI_MOVE(R_DDFSTOP)); 3464 tmp->cp.inst.operand = ddfstart + ddfwidth; 3465 #ifdef DEBUG 3466 if (aga_enable & AGA_TRACE2) 3467 printf(" ddfstop %04x", tmp->cp.inst.operand); 3468 #endif 3469 3470 tmp = find_copper_inst(cp, CI_MOVE(R_BPL0PTH)); 3471 for (i = 0, j = 0; i < depth; j += 2, i++) { 3472 /* update the plane pointers */ 3473 tmp[j].cp.inst.operand = HIADDR(PREP_DMA_MEM(v->bitmap->plane[i])); 3474 tmp[j + 1].cp.inst.operand = LOADDR(PREP_DMA_MEM(v->bitmap->plane[i])); 3475 #ifdef DEBUG 3476 if (aga_enable & AGA_TRACE2) 3477 printf (" bpl%dpth %p", i, v->bitmap->plane[i]); 3478 #endif 3479 } 3480 3481 /* set mods correctly. */ 3482 tmp = find_copper_inst(cp, CI_MOVE(R_BPL1MOD)); 3483 tmp[0].cp.inst.operand = v->bitmap->row_mod; 3484 tmp[1].cp.inst.operand = v->bitmap->row_mod; 3485 #ifdef DEBUG 3486 if (aga_enable & AGA_TRACE2) 3487 printf(" bplxmod %04x\n", v->bitmap->row_mod); 3488 #endif 3489 3490 /* set next pointers correctly */ 3491 tmp = find_copper_inst(cp, CI_MOVE(R_COP1LCH)); 3492 tmp[0].cp.inst.operand = HIADDR(PREP_DMA_MEM(paga_this_data->frames[F_STORE_LONG])); 3493 tmp[1].cp.inst.operand = LOADDR(PREP_DMA_MEM(paga_this_data->frames[F_STORE_LONG])); 3494 3495 cp = paga_this_data->frames[F_LONG]; 3496 paga_this_data->frames[F_LONG] = paga_this_data->frames[F_STORE_LONG]; 3497 paga_this_data->frames[F_STORE_LONG] = cp; 3498 3499 vd->flags |= VF_DISPLAY; 3500 3501 cc_use_aga_colormap(v, vd->colormap); 3502 } 3503 cc_load_mode(paga_this); 3504 #ifdef DEBUG 3505 if (aga_enable & AGA_TRACE) 3506 aga_enable |= AGA_TRACE2; /* XXXX */ 3507 #endif 3508 } 3509 3510 #endif /* GRF_AGA */ 3511 #endif /* GRF_PAL */ 3512
Indexes created Mon Sep 22 13:09:51 GMT 2025