1 /* $NetBSD: grfabs_fal.c,v 1.31 2024/09/08 09:36:48 rillig Exp $ */ 2 3 /* 4 * Copyright (c) 1995 Thomas Gerner. 5 * Copyright (c) 1995 Leo Weppelman. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: grfabs_fal.c,v 1.31 2024/09/08 09:36:48 rillig Exp $"); 31 32 #ifdef FALCON_VIDEO 33 /* 34 * atari abstract graphics driver: Falcon-interface 35 */ 36 #include <sys/param.h> 37 #include <sys/queue.h> 38 #include <sys/malloc.h> 39 #include <sys/device.h> 40 #include <sys/systm.h> 41 42 #include <uvm/uvm_extern.h> 43 44 #include <machine/iomap.h> 45 #include <machine/video.h> 46 #include <machine/mfp.h> 47 #include <atari/atari/device.h> 48 #include <atari/atari/stalloc.h> 49 #include <atari/dev/grfabs_reg.h> 50 #include <atari/dev/grfabs_fal.h> 51 52 /* 53 * Function decls 54 */ 55 static void init_view(view_t *, bmap_t *, dmode_t *, box_t *); 56 static bmap_t *alloc_bitmap(u_long, u_long, u_char); 57 static colormap_t *alloc_colormap(dmode_t *); 58 static void free_bitmap(bmap_t *); 59 static void falcon_display_view(view_t *); 60 static view_t *falcon_alloc_view(dmode_t *, dimen_t *, u_char); 61 static void falcon_free_view(view_t *); 62 static void falcon_remove_view(view_t *); 63 static void falcon_save_view(view_t *); 64 static int falcon_use_colormap(view_t *, colormap_t *); 65 static void falcon_detect(dmode_t *); 66 static struct videl *falcon_getreg(u_short); 67 68 /* 69 * Our function switch table 70 */ 71 struct grfabs_sw fal_vid_sw = { 72 falcon_display_view, 73 falcon_alloc_view, 74 falcon_free_view, 75 falcon_remove_view, 76 falcon_save_view, 77 falcon_use_colormap 78 }; 79 80 struct falcon_hwregs { 81 u_short fal_mode; /* falcon mode */ 82 struct videl *fal_regs; /* videl register values */ 83 }; 84 #define vm_mode(dm) (((struct falcon_hwregs*)(dm->data))->fal_mode) 85 #define vm_regs(dm) (((struct falcon_hwregs*)(dm->data))->fal_regs) 86 87 /* 88 * Note that the order of this table *must* match the order of 89 * the table below! 90 */ 91 static struct falcon_hwregs fal_hwregs[] = { 92 { RES_FALAUTO }, 93 { RES_FAL_STHIGH }, 94 { RES_FAL_STMID }, 95 { RES_FAL_STLOW }, 96 { RES_FAL_TTLOW }, 97 { RES_VGA2 }, 98 { RES_VGA4 }, 99 { RES_VGA16 }, 100 { RES_VGA256 }, 101 { RES_DIRECT } 102 }; 103 104 static dmode_t vid_modes[] = { 105 { {NULL,NULL}, "falauto", { 0, 0 }, 0, NULL, &fal_vid_sw}, 106 { {NULL,NULL}, "sthigh", { 640,400 }, 1, NULL, &fal_vid_sw}, 107 { {NULL,NULL}, "stmid", { 640,200 }, 2, NULL, &fal_vid_sw}, 108 { {NULL,NULL}, "stlow", { 320,200 }, 4, NULL, &fal_vid_sw}, 109 { {NULL,NULL}, "ttlow", { 320,480 }, 8, NULL, &fal_vid_sw}, 110 { {NULL,NULL}, "vga2", { 640,480 }, 1, NULL, &fal_vid_sw}, 111 { {NULL,NULL}, "vga4", { 640,480 }, 2, NULL, &fal_vid_sw}, 112 { {NULL,NULL}, "vga16", { 640,480 }, 4, NULL, &fal_vid_sw}, 113 { {NULL,NULL}, "vga256", { 640,480 }, 8, NULL, &fal_vid_sw}, 114 { {NULL,NULL}, "highcol", { 320,200 }, 16, NULL, &fal_vid_sw}, 115 { {NULL,NULL}, NULL, } 116 }; 117 118 /* 119 * The following table contains timing values for the various video modes. 120 * I have only a multisync display, therefore I can not say if this values 121 * are useful at other displays. 122 * Use other video modes at YOUR OWN RISK. 123 * THERE IS NO WARRENTY ABOUT THIS VALUES TO WORK WITH A PARTICULAR 124 * DISPLAY. -- Thomas 125 */ 126 static struct videl videlinit[] = { 127 { RES_FALAUTO, /* autodedect */ 128 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 129 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }, 130 131 { FAL_VGA | RES_FAL_STHIGH, /* sthigh, 640x400, 2 colors */ 132 0x2, 0x0, 0x28, 0x0, 0x400, 0xc6, 0x8d, 0x15, 0x273, 0x50, 0x96, 0x0, 133 0x0, 0x419, 0x3af, 0x8f, 0x8f, 0x3af, 0x415, 0x186, 0x8 }, 134 135 #if 0 /* not yet */ 136 { FAL_SM | RES_FAL_STHIGH, /* sthigh, 640x400, 2 colors */ 137 0x0, 0x0, 0x28, 0x2, 0x0, 0x1a, 0x0, 0x0, 0x20f, 0xc, 0x14, 0x0, 138 0x0, 0x3e9, 0x0, 0x0, 0x43, 0x363, 0x3e7, 0x80, 0x8 }, 139 #endif 140 141 { FAL_VGA | RES_FAL_STMID, /* stmid, 640x200, 4 colors */ 142 0x2, 0x0, 0x50, 0x1, 0x0, 0x17, 0x12, 0x1, 0x20e, 0xd, 0x11, 0x0, 143 0x0, 0x419, 0x3af, 0x8f, 0x8f, 0x3af, 0x415, 0x186, 0x9 }, 144 145 { FAL_VGA | RES_FAL_STLOW, /* stlow, 320x200, 16 colors */ 146 0x2, 0x0, 0x50, 0x0, 0x0, 0x17, 0x12, 0x1, 0x20e, 0xd, 0x11, 0x0, 147 0x0, 0x419, 0x3af, 0x8f, 0x8f, 0x3af, 0x415, 0x186, 0x5 }, 148 149 { FAL_VGA | RES_FAL_TTLOW, /* ttlow, 320x480, 256 colors */ 150 0x2, 0x0, 0xa0, 0x0, 0x10, 0xc6, 0x8d, 0x15, 0x29a, 0x7b, 0x96, 0x0, 151 0x0, 0x419, 0x3ff, 0x3f, 0x3f, 0x3ff, 0x415, 0x186, 0x4 }, 152 153 { FAL_VGA | RES_VGA2, /* vga, 640x480, 2 colors */ 154 0x2, 0x0, 0x28, 0x0, 0x400, 0xc6, 0x8d, 0x15, 0x273, 0x50, 0x96, 0x0, 155 0x0, 0x419, 0x3ff, 0x3f, 0x3f, 0x3ff, 0x415, 0x186, 0x8 }, 156 157 { FAL_VGA | RES_VGA4, /* vga, 640x480, 4 colors */ 158 0x2, 0x0, 0x50, 0x1, 0x0, 0x17, 0x12, 0x1, 0x20e, 0xd, 0x11, 0x0, 159 0x0, 0x419, 0x3ff, 0x3f, 0x3f, 0x3ff, 0x415, 0x186, 0x8 }, 160 161 { FAL_VGA | RES_VGA16, /* vga, 640x480, 16 colors */ 162 0x2, 0x0, 0xa0, 0x1, 0x0, 0xc6, 0x8d, 0x15, 0x2a3, 0x7c, 0x96, 0x0, 163 0x0, 0x419, 0x3ff, 0x3f, 0x3f, 0x3ff, 0x415, 0x186, 0x8 }, 164 165 { FAL_VGA | RES_VGA256, /* vga, 640x480, 256 colors */ 166 0x2, 0x0, 0x140, 0x1, 0x10, 0xc6, 0x8d, 0x15, 0x2ab, 0x84, 0x96, 0x0, 167 0x0, 0x419, 0x3ff, 0x3f, 0x3f, 0x3ff, 0x415, 0x186, 0x8 }, 168 169 { FAL_VGA | RES_DIRECT, /* direct video, 320x200, 65536 colors */ 170 0x2, 0x0, 0x140, 0x0, 0x100, 0xc6, 0x8d, 0x15, 0x2ac, 0x91, 0x96, 0x0, 171 0x0, 0x419, 0x3ff, 0x3f, 0x3f, 0x3ff, 0x415, 0x186, 0x4 }, 172 173 { 0xffff } /* end of list */ 174 }; 175 176 static u_short mon_type; 177 /* 178 * XXX: called from ite console init routine. 179 * Initialize list of possible video modes. 180 */ 181 void 182 falcon_probe_video(MODES *modelp) 183 { 184 dmode_t *dm; 185 struct videl *vregs; 186 int i; 187 188 mon_type = *(volatile unsigned char *)(AD_FAL_MON_TYPE); 189 mon_type = (mon_type & 0xc0) << 2; 190 191 /* 192 * get all possible modes 193 */ 194 195 for (i = 0; (dm = &vid_modes[i])->name != NULL; i++) { 196 dm->data = (void *)&fal_hwregs[i]; 197 if (vm_mode(dm) == RES_FALAUTO) { 198 vm_regs(dm) = falcon_getreg(RES_FALAUTO); 199 falcon_detect(dm); 200 LIST_INSERT_HEAD(modelp, dm, link); 201 } else { 202 vregs = falcon_getreg(vm_mode(dm) | mon_type); 203 if (vregs) { 204 vm_regs(dm) = vregs; 205 LIST_INSERT_HEAD(modelp, dm, link); 206 } 207 } 208 } 209 210 /* 211 * This seems to prevent bordered screens. 212 */ 213 for (i=0; i < 16; i++) 214 VIDEO->vd_fal_rgb[i] = CM_L2FAL(gra_def_color16[i]); 215 } 216 217 static struct videl * 218 falcon_getreg(u_short mode) 219 { 220 int i; 221 struct videl *vregs; 222 223 for (i = 0; (vregs = &videlinit[i])->video_mode != 0xffff; i++) 224 if ((vregs->video_mode) == mode) 225 return vregs; 226 227 return NULL; /* mode not found */ 228 } 229 230 static void 231 falcon_detect(dmode_t *dm) 232 { 233 u_short falshift, stshift; 234 struct videl *vregs = vm_regs(dm); 235 236 /* 237 * First get the videl register values 238 */ 239 240 vregs->vd_syncmode = VIDEO->vd_sync; 241 vregs->vd_line_wide = VIDEO->vd_line_wide; 242 vregs->vd_vert_wrap = VIDEO->vd_vert_wrap; 243 vregs->vd_st_res = VIDEO->vd_st_res; 244 vregs->vd_fal_res = VIDEO->vd_fal_res; 245 vregs->vd_h_hold_tim = VIDEO->vd_h_hold_tim; 246 vregs->vd_h_bord_beg = VIDEO->vd_h_bord_beg; 247 vregs->vd_h_bord_end = VIDEO->vd_h_bord_end; 248 vregs->vd_h_dis_beg = VIDEO->vd_h_dis_beg; 249 vregs->vd_h_dis_end = VIDEO->vd_h_dis_end; 250 vregs->vd_h_ss = VIDEO->vd_h_ss; 251 vregs->vd_h_fs = VIDEO->vd_h_fs; 252 vregs->vd_h_hh = VIDEO->vd_h_hh; 253 vregs->vd_v_freq_tim = VIDEO->vd_v_freq_tim; 254 vregs->vd_v_bord_beg = VIDEO->vd_v_bord_beg; 255 vregs->vd_v_bord_end = VIDEO->vd_v_bord_end; 256 vregs->vd_v_dis_beg = VIDEO->vd_v_dis_beg; 257 vregs->vd_v_dis_end = VIDEO->vd_v_dis_end; 258 vregs->vd_v_ss = VIDEO->vd_v_ss; 259 vregs->vd_fal_ctrl = VIDEO->vd_fal_ctrl; 260 vregs->vd_fal_mode = VIDEO->vd_fal_mode; 261 262 /* 263 * Calculate the depth of the screen 264 */ 265 266 falshift = vregs->vd_fal_res; 267 stshift = vregs->vd_st_res; 268 269 if (falshift & 0x400) /* 2 color */ 270 dm->depth = 1; 271 else if (falshift & 0x100) /* high color, direct */ 272 dm->depth = 16; 273 else if (falshift & 0x10) /* 256 color */ 274 dm->depth = 8; 275 else if (stshift == 0) /* 16 color */ 276 dm->depth = 4; 277 else if (stshift == 1) /* 4 color */ 278 dm->depth = 2; 279 else 280 dm->depth = 1; /* 2 color */ 281 282 /* 283 * Now calculate the screen height 284 */ 285 286 dm->size.height = vregs->vd_v_dis_end - vregs->vd_v_dis_beg; 287 if (!((vregs->vd_fal_mode & 0x2) >> 1)) /* if not interlaced */ 288 dm->size.height >>=1; 289 if (vregs->vd_fal_mode & 0x1) /* if doublescan */ 290 dm->size.height >>=1; 291 292 /* 293 * And the width 294 */ 295 296 dm->size.width = vregs->vd_vert_wrap * 16 / dm->depth; 297 298 } 299 300 u_long falcon_needs_vbl; 301 void falcon_display_switch(void); 302 303 static void 304 falcon_display_view(view_t *v) 305 { 306 dmode_t *dm = v->mode; 307 bmap_t *bm; 308 struct videl *vregs; 309 static u_short last_mode = 0xffff; 310 311 if (dm->current_view) { 312 /* 313 * Mark current view for this mode as no longer displayed 314 */ 315 dm->current_view->flags &= ~VF_DISPLAY; 316 } 317 dm->current_view = v; 318 v->flags |= VF_DISPLAY; 319 vregs = vm_regs(v->mode); 320 321 falcon_use_colormap(v, v->colormap); 322 323 bm = v->bitmap; 324 VIDEO->vd_ramh = ((u_long)bm->hw_address >> 16) & 0xff; 325 VIDEO->vd_ramm = ((u_long)bm->hw_address >> 8) & 0xff; 326 VIDEO->vd_raml = (u_long)bm->hw_address & 0xff; 327 328 if (last_mode != vregs->video_mode) { 329 last_mode = vregs->video_mode; 330 331 if (dm->depth == 1) { 332 /* 333 * Set the resolution registers to a mode, which guarantee 334 * no shifting when the register are written during vbl. 335 */ 336 VIDEO->vd_fal_res = 0; 337 VIDEO->vd_st_res = 0; 338 } 339 340 /* 341 * Arrange for them to be activated 342 * at the second vbl interrupt. 343 */ 344 falcon_needs_vbl = (u_long)v; 345 } 346 } 347 348 void 349 falcon_display_switch(void) 350 { 351 view_t *v; 352 struct videl *vregs; 353 static int vbl_count = 1; 354 355 if (vbl_count--) 356 return; 357 358 v = (view_t*)falcon_needs_vbl; 359 360 vbl_count = 1; 361 falcon_needs_vbl = 0; 362 363 /* 364 * Write to videl registers only on VGA displays 365 * This is only a hack. Must be fixed soon. XXX -- Thomas 366 */ 367 if (mon_type != FAL_VGA) 368 return; 369 370 vregs = vm_regs(v->mode); 371 372 VIDEO->vd_v_freq_tim = vregs->vd_v_freq_tim; 373 VIDEO->vd_v_ss = vregs->vd_v_ss; 374 VIDEO->vd_v_bord_beg = vregs->vd_v_bord_beg; 375 VIDEO->vd_v_bord_end = vregs->vd_v_bord_end; 376 VIDEO->vd_v_dis_beg = vregs->vd_v_dis_beg; 377 VIDEO->vd_v_dis_end = vregs->vd_v_dis_end; 378 VIDEO->vd_h_hold_tim = vregs->vd_h_hold_tim; 379 VIDEO->vd_h_ss = vregs->vd_h_ss; 380 VIDEO->vd_h_bord_beg = vregs->vd_h_bord_beg; 381 VIDEO->vd_h_bord_end = vregs->vd_h_bord_end; 382 VIDEO->vd_h_dis_beg = vregs->vd_h_dis_beg; 383 VIDEO->vd_h_dis_end = vregs->vd_h_dis_end; 384 #if 0 /* This seems not to be necessary -- Thomas */ 385 VIDEO->vd_h_fs = vregs->vd_h_fs; 386 VIDEO->vd_h_hh = vregs->vd_h_hh; 387 #endif 388 VIDEO->vd_sync = vregs->vd_syncmode; 389 VIDEO->vd_fal_res = 0; 390 if (v->mode->depth == 2) 391 VIDEO->vd_st_res = vregs->vd_st_res; 392 else { 393 VIDEO->vd_st_res = 0; 394 VIDEO->vd_fal_res = vregs->vd_fal_res; 395 } 396 VIDEO->vd_vert_wrap = vregs->vd_vert_wrap; 397 VIDEO->vd_line_wide = vregs->vd_line_wide; 398 VIDEO->vd_fal_ctrl = vregs->vd_fal_ctrl; 399 VIDEO->vd_fal_mode = vregs->vd_fal_mode; 400 } 401 402 static void 403 falcon_remove_view(view_t *v) 404 { 405 dmode_t *mode = v->mode; 406 407 if (mode->current_view == v) { 408 #if 0 409 if (v->flags & VF_DISPLAY) 410 panic("Cannot shutdown display"); /* XXX */ 411 #endif 412 mode->current_view = NULL; 413 } 414 v->flags &= ~VF_DISPLAY; 415 } 416 417 void 418 falcon_save_view(view_t *v) 419 { 420 } 421 422 static void 423 falcon_free_view(view_t *v) 424 { 425 if (v) { 426 falcon_remove_view(v); 427 if (v->colormap != &gra_con_cmap) 428 free(v->colormap, M_DEVBUF); 429 free_bitmap(v->bitmap); 430 if (v != &gra_con_view) 431 free(v, M_DEVBUF); 432 } 433 } 434 435 static int 436 falcon_use_colormap(view_t *v, colormap_t *cm) 437 { 438 dmode_t *dm; 439 volatile u_short *creg; 440 volatile u_long *fcreg; 441 u_long *src; 442 colormap_t *vcm; 443 u_long *vcreg; 444 u_short ncreg; 445 int last_streg; 446 int i; 447 448 dm = v->mode; 449 vcm = v->colormap; 450 451 /* 452 * I guess it seems reasonable to require the maps to be 453 * of the same type... 454 */ 455 if (cm->type != vcm->type) 456 return (EINVAL); 457 458 /* 459 * First get the colormap addresses and calculate 460 * how many colors are in it. 461 */ 462 if (dm->depth == 16) /* direct color, no colormap; 463 but also not (yet) supported */ 464 return(0); 465 fcreg = &VIDEO->vd_fal_rgb[0]; 466 creg = &VIDEO->vd_st_rgb[0]; 467 ncreg = 1 << dm->depth; 468 469 /* If first entry specified beyond capabilities -> error */ 470 if (cm->first >= ncreg) 471 return (EINVAL); 472 473 /* 474 * A little tricky, the actual colormap pointer will be NULL 475 * when view is not displaying, valid otherwise. 476 */ 477 if (v->flags & VF_DISPLAY) { 478 creg = &creg[cm->first]; 479 fcreg = &fcreg[cm->first]; 480 } else { 481 creg = NULL; 482 fcreg = NULL; 483 } 484 485 vcreg = &vcm->entry[cm->first]; 486 ncreg -= cm->first; 487 last_streg = 16 - cm->first; 488 if (cm->size > ncreg) 489 return (EINVAL); 490 ncreg = cm->size; 491 492 for (i = 0, src = cm->entry; i < ncreg; i++, vcreg++) { 493 *vcreg = *src++; 494 495 /* 496 * If displaying, also update actual color register. 497 */ 498 if (fcreg != NULL) { 499 *fcreg++ = CM_L2FAL(*vcreg); 500 if (i < last_streg) 501 *creg++ = CM_L2ST(*vcreg); 502 } 503 } 504 return (0); 505 } 506 507 static view_t * 508 falcon_alloc_view(dmode_t *mode, dimen_t *dim, u_char depth) 509 { 510 view_t *v; 511 bmap_t *bm; 512 513 if (!atari_realconfig) 514 v = &gra_con_view; 515 else 516 v = malloc(sizeof(*v), M_DEVBUF, M_NOWAIT); 517 if (v == NULL) 518 return(NULL); 519 520 bm = alloc_bitmap(mode->size.width, mode->size.height, mode->depth); 521 if (bm) { 522 box_t box; 523 524 v->colormap = alloc_colormap(mode); 525 if (v->colormap) { 526 INIT_BOX(&box,0,0,mode->size.width,mode->size.height); 527 init_view(v, bm, mode, &box); 528 return(v); 529 } 530 free_bitmap(bm); 531 } 532 if (v != &gra_con_view) 533 free(v, M_DEVBUF); 534 return (NULL); 535 } 536 537 static void 538 init_view(view_t *v, bmap_t *bm, dmode_t *mode, box_t *dbox) 539 { 540 v->bitmap = bm; 541 v->mode = mode; 542 v->flags = 0; 543 memcpy(&v->display, dbox, sizeof(box_t)); 544 } 545 546 /* bitmap functions */ 547 548 static bmap_t * 549 alloc_bitmap(u_long width, u_long height, u_char depth) 550 { 551 u_long total_size, bm_size; 552 void *hw_address; 553 bmap_t *bm; 554 555 /* 556 * Sigh, it seems for mapping to work we need the bitplane data to 557 * 1: be aligned on a page boundary. 558 * 2: be n pages large. 559 * 560 * why? because the user gets a page aligned address, if this is before 561 * your allocation, too bad. Also it seems that the mapping routines 562 * do not watch to closely to the allowable length. so if you go over 563 * n pages by less than another page, the user gets to write all over 564 * the entire page. Since you did not allocate up to a page boundary 565 * (or more) the user writes into someone elses memory. -ch 566 */ 567 bm_size = m68k_round_page((width * height * depth) / NBBY); 568 total_size = bm_size + sizeof(bmap_t) + PAGE_SIZE; 569 570 if ((bm = (bmap_t*)alloc_stmem(total_size, &hw_address)) == NULL) 571 return(NULL); 572 573 bm->plane = (u_char*)bm + sizeof(bmap_t); 574 bm->plane = (u_char*)m68k_round_page(bm->plane); 575 bm->hw_address = (u_char*)hw_address + sizeof(bmap_t); 576 bm->hw_address = (u_char*)m68k_round_page(bm->hw_address); 577 bm->bytes_per_row = (width * depth) / NBBY; 578 bm->rows = height; 579 bm->depth = depth; 580 bm->phys_mappable = (depth * width * height) / NBBY; 581 bm->regs = NULL; 582 bm->hw_regs = NULL; 583 bm->reg_size = 0; 584 bm->vga_address = NULL; 585 bm->vga_mappable = 0; 586 bm->lin_base = 0; 587 bm->vga_base = 0; 588 589 memset(bm->plane, 0, bm_size); 590 return (bm); 591 } 592 593 static void 594 free_bitmap(bmap_t *bm) 595 { 596 if (bm) 597 free_stmem(bm); 598 } 599 600 static colormap_t * 601 alloc_colormap(dmode_t *dm) 602 { 603 int nentries, i; 604 colormap_t *cm; 605 u_char type = CM_COLOR; 606 607 if (dm->depth == 16) /* direct color, no colormap; 608 not (yet) supported */ 609 nentries = 0; 610 else 611 nentries = 1 << dm->depth; 612 613 if (!atari_realconfig) { 614 cm = &gra_con_cmap; 615 cm->entry = gra_con_colors; 616 } else { 617 int size; 618 619 size = sizeof(*cm) + (nentries * sizeof(cm->entry[0])); 620 cm = malloc(size, M_DEVBUF, M_NOWAIT); 621 if (cm == NULL) 622 return(NULL); 623 cm->entry = (long *)&cm[1]; 624 625 } 626 627 if ((cm->type = type) == CM_COLOR) 628 cm->red_mask = cm->green_mask = cm->blue_mask = 0x3f; 629 630 cm->first = 0; 631 cm->size = nentries; 632 633 for (i = 0; i < nentries; i++) 634 cm->entry[i] = gra_def_color16[i % 16]; 635 return (cm); 636 } 637 #endif /* FALCON_VIDEO */ 638