1 /* $NetBSD: grfabs.c,v 1.2 1995/03/28 06:35:40 leo Exp $ */ 2 3 /* 4 * Copyright (c) 1995 Leo Weppelman. 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 Leo Weppelman. 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 * atari abstract graphics driver. 35 */ 36 #include <sys/param.h> 37 #include <sys/queue.h> 38 #include <sys/malloc.h> 39 40 #include <machine/iomap.h> 41 #include <machine/video.h> 42 #include <machine/mfp.h> 43 #include <atari/dev/grfabs_reg.h> 44 45 /* 46 * Function decls 47 */ 48 static dmode_t *get_best_display_mode __P((int, int, int)); 49 static view_t *alloc_view __P((dmode_t *, dimen_t *, u_char)); 50 static void init_view __P((view_t *, bmap_t *, dmode_t *, box_t *)); 51 static bmap_t *alloc_bitmap __P((u_long, u_long, u_char, int)); 52 static void free_bitmap __P((bmap_t *)); 53 static colormap_t *alloc_colormap __P((dmode_t *)); 54 55 /* 56 * Ugh.. Stuff needed to allocate console structures before the VM-system 57 * is running. There is no malloc() available at that time. 58 */ 59 extern int atari_realconfig; /* 0 -> no malloc */ 60 static view_t con_view; 61 static colormap_t con_cmap; 62 static long con_colors[MAX_CENTRIES]; 63 64 /* 65 * List of available graphic modes 66 */ 67 static LIST_HEAD(modelist, display_mode) modes; 68 69 static dmode_t vid_modes[] = { 70 { { NULL, NULL }, "stlow", { 320, 200 }, 4, RES_STLOW }, 71 { { NULL, NULL }, "stmid", { 640, 200 }, 2, RES_STMID }, 72 { { NULL, NULL }, "sthigh", { 640, 400 }, 1, RES_STHIGH }, 73 { { NULL, NULL }, "ttlow", { 320, 480 }, 8, RES_TTLOW }, 74 { { NULL, NULL }, "ttmid", { 640, 480 }, 4, RES_TTMID }, 75 { { NULL, NULL }, "tthigh", { 1280, 960 }, 1, RES_TTHIGH }, 76 { { NULL, NULL }, NULL, } 77 }; 78 79 /* 80 * Default colors..... 81 * Currently the TT-low (256 colors) just uses 16 time the 16-color default. 82 * If you have a sensible 256 scale, feel free to add..... 83 * The first 2 colors in all maps are {black,white}, so ite (text) displays 84 * are initially readable. Also, this enables me to supply only 1 map. The 85 * 4 color mode uses the first four entries of the 16 color mode thus giving 86 * a gray scale display. (Maybe we can add an intensity bit to the ite...) 87 */ 88 static u_short def_color16[16] = { 89 0x000, /* black */ 90 0xfff, /* white */ 91 0xccc, /* light gray */ 92 0x888, /* gray */ 93 0x00c, /* blue */ 94 0x0c0, /* green */ 95 0x0cc, /* cyan */ 96 0xc00, /* red */ 97 0xc0c, /* magenta */ 98 0xcc0, /* brown */ 99 0x00f, /* light blue */ 100 0x0f0, /* light green */ 101 0x0ff, /* light cyan */ 102 0xf00, /* light red */ 103 0xf0f, /* light magenta */ 104 0xff0 /* light brown */ 105 }; 106 107 /* 108 * XXX: called from ite console init routine. 109 * Initialize list of posible video modes. 110 */ 111 int 112 grfabs_probe() 113 { 114 dmode_t *dm; 115 int i; 116 int has_mono; 117 static int inited = 0; 118 119 if(inited) 120 return; /* Has to be done only once */ 121 inited++; 122 123 /* 124 * First find out what kind of monitor is attached. Dma-sound 125 * should be off because the 'sound-done' and 'monochrome-detect' 126 * are xor-ed together. I think that shutting it down here is the 127 * wrong place. 128 */ 129 has_mono = (MFP->mf_gpip & IA_MONO) == 0; 130 131 LIST_INIT(&modes); 132 for(i = 0; (dm = &vid_modes[i])->name != NULL; i++) { 133 if(has_mono && (dm->vm_reg != RES_TTHIGH)) 134 continue; 135 if(!has_mono && (dm->vm_reg == RES_TTHIGH)) 136 continue; 137 LIST_INSERT_HEAD(&modes, dm, link); 138 } 139 140 /* 141 * This seems to prevent bordered screens. 142 */ 143 for(i=0; i < 16; i++) 144 VIDEO->vd_tt_rgb[i] = def_color16[i]; 145 146 return(1); 147 } 148 149 view_t * 150 grf_alloc_view(d, dim, depth) 151 dmode_t *d; 152 dimen_t *dim; 153 u_char depth; 154 { 155 if(!d) 156 d = get_best_display_mode(dim->width, dim->height, depth); 157 if(d) 158 return(alloc_view(d, dim, depth)); 159 return(NULL); 160 } 161 162 void grf_display_view(v) 163 view_t *v; 164 { 165 dmode_t *dm = v->mode; 166 bmap_t *bm = v->bitmap; 167 168 if(dm->current_view) { 169 /* 170 * Mark current view for this mode as no longer displayed 171 */ 172 dm->current_view->flags &= ~VF_DISPLAY; 173 } 174 dm->current_view = v; 175 v->flags |= VF_DISPLAY; 176 177 grf_use_colormap(v, v->colormap); 178 179 /* XXX: should use vbl for this */ 180 VIDEO->vd_tt_res = dm->vm_reg; 181 VIDEO->vd_raml = (u_long)bm->hw_address & 0xff; 182 VIDEO->vd_ramm = ((u_long)bm->hw_address >> 8) & 0xff; 183 VIDEO->vd_ramh = ((u_long)bm->hw_address >> 16) & 0xff; 184 } 185 186 void grf_remove_view(v) 187 view_t *v; 188 { 189 dmode_t *mode = v->mode; 190 191 if(mode->current_view == v) { 192 #if 0 193 if(v->flags & VF_DISPLAY) 194 panic("Cannot shutdown display\n"); /* XXX */ 195 #endif 196 mode->current_view = NULL; 197 } 198 v->flags &= ~VF_DISPLAY; 199 } 200 201 void grf_free_view(v) 202 view_t *v; 203 { 204 if(v) { 205 dmode_t *md = v->mode; 206 207 grf_remove_view(v); 208 if(v->colormap != &con_cmap) 209 free(v->colormap, M_DEVBUF); 210 free_bitmap(v->bitmap); 211 if(v != &con_view) 212 free(v, M_DEVBUF); 213 } 214 } 215 216 int 217 grf_get_colormap(v, cm) 218 view_t *v; 219 colormap_t *cm; 220 { 221 colormap_t *gcm; 222 int i, n; 223 224 bzero(cm->entry, cm->size * sizeof(long)); 225 226 gcm = v->colormap; 227 n = cm->size < gcm->size ? cm->size : gcm->size; 228 for(i = 0; i < n; i++) 229 cm->entry[i] = gcm->entry[i]; 230 return(0); 231 } 232 233 int 234 grf_use_colormap(v, cm) 235 view_t *v; 236 colormap_t *cm; 237 { 238 dmode_t *dm; 239 volatile u_short *creg; 240 long *src; 241 u_short ncreg; 242 int i; 243 244 dm = v->mode; 245 246 switch(dm->vm_reg) { 247 case RES_STLOW: 248 creg = &VIDEO->vd_tt_rgb[0]; 249 ncreg = 16; 250 break; 251 case RES_STMID: 252 creg = &VIDEO->vd_tt_rgb[0]; 253 ncreg = 4; 254 break; 255 case RES_STHIGH: 256 creg = &VIDEO->vd_tt_rgb[254]; 257 ncreg = 2; 258 break; 259 case RES_TTLOW: 260 creg = &VIDEO->vd_tt_rgb[0]; 261 ncreg = 256; 262 break; 263 case RES_TTMID: 264 creg = &VIDEO->vd_tt_rgb[0]; 265 ncreg = 16; 266 break; 267 case RES_TTHIGH: 268 return(0); /* No colors */ 269 default: 270 panic("grf_get_colormap: wrong mode!?"); 271 } 272 273 if(cm->first >= ncreg) 274 return(EINVAL); 275 creg = &creg[cm->first]; 276 ncreg -= cm->first; 277 278 if(cm->size > ncreg) 279 return(EINVAL); 280 ncreg = cm->size; 281 282 for(i = 0, src = cm->entry; i < ncreg; i++) { 283 register long val = *src++; 284 *creg++ = CM_LTOW(val); 285 } 286 return(0); 287 } 288 289 static dmode_t * 290 get_best_display_mode(width, height, depth) 291 int width, height, depth; 292 { 293 dmode_t *save; 294 dmode_t *dm; 295 long dt, dx, dy, ct; 296 297 save = NULL; 298 dm = modes.lh_first; 299 while(dm != NULL) { 300 if(depth > dm->depth) { 301 dm = dm->link.le_next; 302 continue; 303 } 304 else if(width > dm->size.width || height > dm->size.height) { 305 dm = dm->link.le_next; 306 continue; 307 } 308 else if (width < dm->size.width || height < dm->size.height) { 309 dm = dm->link.le_next; 310 continue; 311 } 312 dx = abs(dm->size.width - width); 313 dy = abs(dm->size.height - height); 314 ct = dx + dy; 315 316 if (ct < dt || save == NULL) { 317 save = dm; 318 dt = ct; 319 } 320 dm = dm->link.le_next; 321 } 322 return (save); 323 } 324 325 static view_t * 326 alloc_view(mode, dim, depth) 327 dmode_t *mode; 328 dimen_t *dim; 329 u_char depth; 330 { 331 view_t *v; 332 bmap_t *bm; 333 334 if(!atari_realconfig) 335 v = &con_view; 336 else v = malloc(sizeof(*v), M_DEVBUF, M_NOWAIT); 337 338 bm = alloc_bitmap(mode->size.width, mode->size.height, mode->depth, 1); 339 if(bm) { 340 int i; 341 box_t box; 342 343 v->colormap = alloc_colormap(mode); 344 if(v->colormap) { 345 INIT_BOX(&box,0,0,mode->size.width,mode->size.height); 346 init_view(v, bm, mode, &box); 347 return(v); 348 } 349 free_bitmap(bm); 350 } 351 if(v != &con_view) 352 free(v, M_DEVBUF); 353 return (NULL); 354 } 355 356 static void 357 init_view(v, bm, mode, dbox) 358 view_t *v; 359 bmap_t *bm; 360 dmode_t *mode; 361 box_t *dbox; 362 { 363 v->bitmap = bm; 364 v->mode = mode; 365 bcopy(dbox, &v->display, sizeof(box_t)); 366 } 367 368 /* bitmap functions */ 369 370 static bmap_t * 371 alloc_bitmap(width, height, depth, clear) 372 u_long width, height; 373 u_char depth; 374 int clear; 375 { 376 int i; 377 u_long total_size, bm_size; 378 void *hw_address; 379 bmap_t *bm; 380 381 /* 382 * Sigh, it seems for mapping to work we need the bitplane data to 383 * 1: be aligned on a page boundry. 384 * 2: be n pages large. 385 * 386 * why? because the user gets a page aligned address, if this is before 387 * your allocation, too bad. Also it seems that the mapping routines 388 * do not watch to closely to the allowable length. so if you go over 389 * n pages by less than another page, the user gets to write all over 390 * the entire page. Since you did not allocate up to a page boundry 391 * (or more) the user writes into someone elses memory. -ch 392 */ 393 bm_size = atari_round_page((width * height * depth) / NBBY); 394 total_size = bm_size + sizeof(bmap_t) + NBPG; 395 396 if((bm = (bmap_t*)alloc_stmem(total_size, &hw_address)) == NULL) 397 return(NULL); 398 399 bm->plane = (u_char*)bm + sizeof(bmap_t); 400 bm->plane = (u_char*)atari_round_page(bm->plane); 401 bm->hw_address = (u_char*)hw_address + sizeof(bmap_t); 402 bm->hw_address = (u_char*)atari_round_page(bm->hw_address); 403 bm->bytes_per_row = (width * depth) / NBBY; 404 bm->rows = height; 405 bm->depth = depth; 406 407 if(clear) 408 bzero(bm->plane, bm_size); 409 return(bm); 410 } 411 412 static void 413 free_bitmap(bm) 414 bmap_t *bm; 415 { 416 if(bm) 417 free_stmem(bm); 418 } 419 420 static colormap_t * 421 alloc_colormap(dm) 422 dmode_t *dm; 423 { 424 int nentries, i; 425 colormap_t *cm; 426 u_char type = CM_COLOR; 427 428 switch(dm->vm_reg) { 429 case RES_STLOW: 430 case RES_TTMID: 431 nentries = 16; 432 break; 433 case RES_STMID: 434 nentries = 4; 435 break; 436 case RES_STHIGH: 437 nentries = 2; 438 break; 439 case RES_TTLOW: 440 nentries = 256; 441 break; 442 case RES_TTHIGH: 443 type = CM_MONO; 444 nentries = 0; 445 default: 446 panic("grf:alloc_colormap: wrong mode!?"); 447 } 448 if(!atari_realconfig) { 449 cm = &con_cmap; 450 cm->entry = con_colors; 451 } 452 else { 453 int size; 454 455 size = sizeof(*cm) + (nentries * sizeof(cm->entry[0])); 456 cm = malloc(size, M_DEVBUF, M_NOWAIT); 457 if(cm == NULL) 458 return(NULL); 459 cm->entry = (long *)&cm[1]; 460 461 } 462 if((cm->type = type) == CM_COLOR) 463 cm->red_mask = cm->green_mask = cm->blue_mask = 0xf; 464 cm->first = 0; 465 cm->size = nentries; 466 467 for(i = 0; i < nentries; i++) { 468 register short val = def_color16[i % 16]; 469 cm->entry[i] = CM_WTOL(val); 470 } 471 return(cm); 472 } 473