1 /* $NetBSD: ibm561.c,v 1.1 2001/12/12 07:46:48 elric Exp $ */ 2 /* $OpenBSD: ibm561.c,v 1.3 2002/11/09 22:51:48 miod Exp $ */ 3 4 /*- 5 * Copyright (c) 2001 The NetBSD Foundation, Inc. 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to The NetBSD Foundation 9 * by Roland C. Dowdeswell of Ponte, Inc. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/device.h> 43 #include <sys/buf.h> 44 #include <sys/kernel.h> 45 #include <sys/malloc.h> 46 47 #include <uvm/uvm_extern.h> 48 49 #include <dev/pci/pcivar.h> 50 #include <dev/ic/ibm561reg.h> 51 #include <dev/ic/ibm561var.h> 52 #include <dev/ic/ramdac.h> 53 54 #include <dev/wscons/wsconsio.h> 55 56 /* 57 * Functions exported via the RAMDAC configuration table. 58 */ 59 void ibm561_init(struct ramdac_cookie *); 60 int ibm561_set_cmap(struct ramdac_cookie *, 61 struct wsdisplay_cmap *); 62 int ibm561_get_cmap(struct ramdac_cookie *, 63 struct wsdisplay_cmap *); 64 int ibm561_set_cursor(struct ramdac_cookie *, 65 struct wsdisplay_cursor *); 66 int ibm561_get_cursor(struct ramdac_cookie *, 67 struct wsdisplay_cursor *); 68 int ibm561_set_curpos(struct ramdac_cookie *, 69 struct wsdisplay_curpos *); 70 int ibm561_get_curpos(struct ramdac_cookie *, 71 struct wsdisplay_curpos *); 72 int ibm561_get_curmax(struct ramdac_cookie *, 73 struct wsdisplay_curpos *); 74 int ibm561_set_dotclock(struct ramdac_cookie *, 75 unsigned); 76 77 /* XXX const */ 78 struct ramdac_funcs ibm561_funcsstruct = { 79 "IBM561", 80 ibm561_register, 81 ibm561_init, 82 ibm561_set_cmap, 83 ibm561_get_cmap, 84 ibm561_set_cursor, 85 ibm561_get_cursor, 86 ibm561_set_curpos, 87 ibm561_get_curpos, 88 ibm561_get_curmax, 89 NULL, /* check_curcmap; not needed */ 90 NULL, /* set_curcmap; not needed */ 91 NULL, /* get_curcmap; not needed */ 92 ibm561_set_dotclock, 93 }; 94 95 /* 96 * Private data. 97 */ 98 struct ibm561data { 99 void *cookie; 100 101 int (*ramdac_sched_update)(void *, void (*)(void *)); 102 void (*ramdac_wr)(void *, u_int, u_int8_t); 103 u_int8_t (*ramdac_rd)(void *, u_int); 104 105 #define CHANGED_CURCMAP 0x0001 /* cursor cmap */ 106 #define CHANGED_CMAP 0x0002 /* color map */ 107 #define CHANGED_WTYPE 0x0004 /* window types */ 108 #define CHANGED_DOTCLOCK 0x0008 /* dot clock */ 109 #define CHANGED_ALL 0x000f /* or of all above */ 110 u_int8_t changed; 111 112 /* dotclock parameters */ 113 u_int8_t vco_div; 114 u_int8_t pll_ref; 115 u_int8_t div_dotclock; 116 117 /* colormaps et al. */ 118 u_int8_t curcmap_r[2]; 119 u_int8_t curcmap_g[2]; 120 u_int8_t curcmap_b[2]; 121 122 u_int8_t cmap_r[IBM561_NCMAP_ENTRIES]; 123 u_int8_t cmap_g[IBM561_NCMAP_ENTRIES]; 124 u_int8_t cmap_b[IBM561_NCMAP_ENTRIES]; 125 126 u_int16_t gamma_r[IBM561_NGAMMA_ENTRIES]; 127 u_int16_t gamma_g[IBM561_NGAMMA_ENTRIES]; 128 u_int16_t gamma_b[IBM561_NGAMMA_ENTRIES]; 129 130 u_int16_t wtype[IBM561_NWTYPES]; 131 }; 132 133 /* 134 * private functions 135 */ 136 void ibm561_update(void *); 137 static void ibm561_load_cmap(struct ibm561data *); 138 static void ibm561_load_dotclock(struct ibm561data *); 139 static void ibm561_regbegin(struct ibm561data *, u_int16_t); 140 static void ibm561_regcont(struct ibm561data *, u_int16_t, u_int8_t); 141 static void ibm561_regcont10bit(struct ibm561data *, u_int16_t, u_int16_t); 142 static void ibm561_regwr(struct ibm561data *, u_int16_t, u_int8_t); 143 144 struct ramdac_funcs * 145 ibm561_funcs(void) 146 { 147 return &ibm561_funcsstruct; 148 } 149 150 struct ramdac_cookie * 151 ibm561_register(v, sched_update, wr, rd) 152 void *v; 153 int (*sched_update)(void *, void (*)(void *)); 154 void (*wr)(void *, u_int, u_int8_t); 155 u_int8_t (*rd)(void *, u_int); 156 { 157 struct ibm561data *data; 158 159 data = malloc(sizeof *data, M_DEVBUF, M_WAITOK); // XXX |M_ZERO); 160 data->cookie = v; 161 data->ramdac_sched_update = sched_update; 162 data->ramdac_wr = wr; 163 data->ramdac_rd = rd; 164 return (struct ramdac_cookie *)data; 165 } 166 167 /* 168 * This function exists solely to provide a means to init 169 * the RAMDAC without first registering. It is useful for 170 * initializing the console early on. 171 */ 172 173 struct ibm561data *saved_console_data; 174 175 void 176 ibm561_cninit(v, sched_update, wr, rd, dotclock) 177 void *v; 178 int (*sched_update)(void *, void (*)(void *)); 179 void (*wr)(void *, u_int, u_int8_t); 180 u_int8_t (*rd)(void *, u_int); 181 u_int dotclock; 182 { 183 struct ibm561data tmp, *data = &tmp; 184 memset(data, 0x0, sizeof *data); 185 data->cookie = v; 186 data->ramdac_sched_update = sched_update; 187 data->ramdac_wr = wr; 188 data->ramdac_rd = rd; 189 ibm561_set_dotclock((struct ramdac_cookie *)data, dotclock); 190 saved_console_data = data; 191 ibm561_init((struct ramdac_cookie *)data); 192 saved_console_data = NULL; 193 } 194 195 void 196 ibm561_init(rc) 197 struct ramdac_cookie *rc; 198 { 199 struct ibm561data *data = (struct ibm561data *)rc; 200 int i; 201 202 /* XXX this is _essential_ */ 203 204 ibm561_load_dotclock(data); 205 206 /* XXXrcd: bunch of magic of which I have no current clue */ 207 ibm561_regwr(data, IBM561_CONFIG_REG1, 0x2a); 208 ibm561_regwr(data, IBM561_CONFIG_REG3, 0x41); 209 ibm561_regwr(data, IBM561_CONFIG_REG4, 0x20); 210 211 /* initialize the card a bit */ 212 ibm561_regwr(data, IBM561_SYNC_CNTL, 0x1); 213 ibm561_regwr(data, IBM561_CONFIG_REG2, 0x19); 214 215 ibm561_regwr(data, IBM561_CONFIG_REG1, 0x2a); 216 ibm561_regwr(data, IBM561_CONFIG_REG4, 0x20); 217 218 ibm561_regbegin(data, IBM561_WAT_SEG_REG); 219 ibm561_regcont(data, IBM561_CMD, 0x00); 220 ibm561_regcont(data, IBM561_CMD, 0x00); 221 ibm561_regcont(data, IBM561_CMD, 0x00); 222 ibm561_regcont(data, IBM561_CMD, 0x00); 223 ibm561_regbegin(data, IBM561_CHROMAKEY0); 224 ibm561_regcont(data, IBM561_CMD, 0x00); 225 ibm561_regcont(data, IBM561_CMD, 0x00); 226 ibm561_regcont(data, IBM561_CMD, 0x00); 227 ibm561_regcont(data, IBM561_CMD, 0x00); 228 229 ibm561_regwr(data, IBM561_CURS_CNTL_REG, 0x00); /* XXX off? */ 230 231 /* cursor `hot spot' registers */ 232 ibm561_regbegin(data, IBM561_HOTSPOT_REG); 233 ibm561_regcont(data, IBM561_CMD, 0x00); 234 ibm561_regcont(data, IBM561_CMD, 0x00); 235 ibm561_regcont(data, IBM561_CMD, 0xff); 236 ibm561_regcont(data, IBM561_CMD, 0x00); 237 ibm561_regcont(data, IBM561_CMD, 0xff); 238 ibm561_regcont(data, IBM561_CMD, 0x00); 239 240 /* VRAM Mask Registers (diagnostics) */ 241 ibm561_regbegin(data, IBM561_VRAM_MASK_REG); 242 ibm561_regcont(data, IBM561_CMD, 0xff); 243 ibm561_regcont(data, IBM561_CMD, 0xff); 244 ibm561_regcont(data, IBM561_CMD, 0xff); 245 ibm561_regcont(data, IBM561_CMD, 0xff); 246 ibm561_regcont(data, IBM561_CMD, 0xff); 247 ibm561_regcont(data, IBM561_CMD, 0xff); 248 ibm561_regcont(data, IBM561_CMD, 0xff); 249 250 /* let's set up some decent default colour maps and gammas */ 251 for (i=0; i < IBM561_NCMAP_ENTRIES; i++) 252 data->cmap_r[i] = data->cmap_g[i] = data->cmap_b[i] = 0xff; 253 data->cmap_r[0] = data->cmap_g[0] = data->cmap_b[0] = 0x00; 254 data->cmap_r[256] = data->cmap_g[256] = data->cmap_b[256] = 0x00; 255 data->cmap_r[512] = data->cmap_g[512] = data->cmap_b[512] = 0x00; 256 data->cmap_r[768] = data->cmap_g[768] = data->cmap_b[768] = 0x00; 257 258 data->gamma_r[0] = data->gamma_g[0] = data->gamma_b[0] = 0x00; 259 for (i=0; i < IBM561_NGAMMA_ENTRIES; i++) 260 data->gamma_r[i] = data->gamma_g[i] = data->gamma_b[i] = 0xff; 261 262 for (i=0; i < IBM561_NWTYPES; i++) 263 data->wtype[i] = 0x0036; 264 data->wtype[1] = 0x0028; 265 266 /* the last step: */ 267 data->changed = CHANGED_ALL; 268 data->ramdac_sched_update(data->cookie, ibm561_update); 269 } 270 271 int 272 ibm561_set_cmap(rc, cmapp) 273 struct ramdac_cookie *rc; 274 struct wsdisplay_cmap *cmapp; 275 { 276 struct ibm561data *data = (struct ibm561data *)rc; 277 u_int count, index; 278 int error; 279 int s; 280 281 index = cmapp->index; 282 count = cmapp->count; 283 284 if (index >= IBM561_NCMAP_ENTRIES || 285 count > IBM561_NCMAP_ENTRIES - index) 286 return (EINVAL); 287 288 s = spltty(); 289 if ((error = copyin(cmapp->red, &data->cmap_r[index], count)) != 0) { 290 splx(s); 291 return (error); 292 } 293 if ((error = copyin(cmapp->green, &data->cmap_g[index], count)) != 0) { 294 splx(s); 295 return (error); 296 } 297 if ((error = copyin(cmapp->blue, &data->cmap_b[index], count)) != 0) { 298 splx(s); 299 return (error); 300 } 301 data->changed |= CHANGED_CMAP; 302 data->ramdac_sched_update(data->cookie, ibm561_update); 303 splx(s); 304 return (0); 305 } 306 307 int 308 ibm561_get_cmap(rc, cmapp) 309 struct ramdac_cookie *rc; 310 struct wsdisplay_cmap *cmapp; 311 { 312 struct ibm561data *data = (struct ibm561data *)rc; 313 u_int count, index; 314 int error; 315 316 if (cmapp->index >= IBM561_NCMAP_ENTRIES || 317 cmapp->count > IBM561_NCMAP_ENTRIES - cmapp->index) 318 return (EINVAL); 319 count = cmapp->count; 320 index = cmapp->index; 321 error = copyout(&data->cmap_r[index], cmapp->red, count); 322 if (error) 323 return (error); 324 error = copyout(&data->cmap_g[index], cmapp->green, count); 325 if (error) 326 return (error); 327 error = copyout(&data->cmap_b[index], cmapp->blue, count); 328 return (error); 329 } 330 331 /* 332 * XXX: 333 * I am leaving these functions returning EINVAL, as they are 334 * not strictly necessary for the correct functioning of the 335 * card and in fact are not used on the other TGA variants, except 336 * they are exported via ioctl(2) to userland, which does not in 337 * fact use them. 338 */ 339 340 int 341 ibm561_set_cursor(rc, cursorp) 342 struct ramdac_cookie *rc; 343 struct wsdisplay_cursor *cursorp; 344 { 345 return EINVAL; 346 } 347 348 int 349 ibm561_get_cursor(rc, cursorp) 350 struct ramdac_cookie *rc; 351 struct wsdisplay_cursor *cursorp; 352 { 353 return EINVAL; 354 } 355 356 int 357 ibm561_set_curpos(rc, curposp) 358 struct ramdac_cookie *rc; 359 struct wsdisplay_curpos *curposp; 360 { 361 return EINVAL; 362 } 363 364 int 365 ibm561_get_curpos(rc, curposp) 366 struct ramdac_cookie *rc; 367 struct wsdisplay_curpos *curposp; 368 { 369 return EINVAL; 370 } 371 372 int 373 ibm561_get_curmax(rc, curposp) 374 struct ramdac_cookie *rc; 375 struct wsdisplay_curpos *curposp; 376 { 377 return EINVAL; 378 } 379 380 int 381 ibm561_set_dotclock(rc, dotclock) 382 struct ramdac_cookie *rc; 383 unsigned dotclock; 384 { 385 struct ibm561data *data = (struct ibm561data *)rc; 386 387 /* XXXrcd: a couple of these are a little hazy, vis a vis 388 * check 175MHz and 202MHz, which are wrong... 389 */ 390 switch (dotclock) { 391 case 25175000: data->vco_div = 0x3e; data->pll_ref = 0x09; break; 392 case 31500000: data->vco_div = 0x17; data->pll_ref = 0x05; break; 393 case 40000000: data->vco_div = 0x42; data->pll_ref = 0x06; break; 394 case 50000000: data->vco_div = 0x45; data->pll_ref = 0x05; break; 395 case 65000000: data->vco_div = 0xac; data->pll_ref = 0x0c; break; 396 case 69000000: data->vco_div = 0xa9; data->pll_ref = 0x0b; break; 397 case 74000000: data->vco_div = 0x9c; data->pll_ref = 0x09; break; 398 case 75000000: data->vco_div = 0x93; data->pll_ref = 0x08; break; 399 case 103994000: data->vco_div = 0x96; data->pll_ref = 0x06; break; 400 case 108180000: data->vco_div = 0xb8; data->pll_ref = 0x08; break; 401 case 110000000: data->vco_div = 0xba; data->pll_ref = 0x08; break; 402 case 119840000: data->vco_div = 0x82; data->pll_ref = 0x04; break; 403 case 130808000: data->vco_div = 0xc8; data->pll_ref = 0x08; break; 404 case 135000000: data->vco_div = 0xc1; data->pll_ref = 0x07; break; 405 case 175000000: data->vco_div = 0xe2; data->pll_ref = 0x07; break; 406 case 202500000: data->vco_div = 0xe2; data->pll_ref = 0x07; break; 407 default: 408 return EINVAL; 409 } 410 411 data->div_dotclock = 0xb0; 412 data->changed |= CHANGED_DOTCLOCK; 413 return 0; 414 } 415 416 /* 417 * Internal Functions 418 */ 419 420 void 421 ibm561_update(vp) 422 void *vp; 423 { 424 struct ibm561data *data = (struct ibm561data *)vp; 425 int i; 426 427 /* XXX see comment above ibm561_cninit() */ 428 if (!data) 429 data = saved_console_data; 430 431 if (data->changed & CHANGED_WTYPE) { 432 ibm561_regbegin(data, IBM561_FB_WINTYPE); 433 for (i=0; i < IBM561_NWTYPES; i++) 434 ibm561_regcont10bit(data, IBM561_CMD_FB_WAT, data->wtype[i]); 435 436 /* XXXrcd: quick hack here for AUX FB table */ 437 ibm561_regbegin(data, IBM561_AUXFB_WINTYPE); 438 for (i=0; i < IBM561_NWTYPES; i++) 439 ibm561_regcont(data, IBM561_CMD, 0x04); 440 441 /* XXXrcd: quick hack here for OL WAT table */ 442 ibm561_regbegin(data, IBM561_OL_WINTYPE); 443 for (i=0; i < IBM561_NWTYPES; i++) 444 ibm561_regcont10bit(data, IBM561_CMD_FB_WAT, 0x0231); 445 446 /* XXXrcd: quick hack here for AUX OL WAT table */ 447 ibm561_regbegin(data, IBM561_AUXOL_WINTYPE); 448 for (i=0; i < IBM561_NWTYPES; i++) 449 ibm561_regcont(data, IBM561_CMD, 0x0c); 450 } 451 452 if (data->changed & CHANGED_CMAP) 453 ibm561_load_cmap(data); 454 455 /* XXX: I am not sure in what situations it is safe to 456 * change the dotclock---hope this is good. 457 */ 458 if (data->changed & CHANGED_DOTCLOCK) 459 ibm561_load_dotclock(data); 460 } 461 462 static void 463 ibm561_load_cmap(struct ibm561data *data) 464 { 465 int i; 466 467 ibm561_regbegin(data, IBM561_CMAP_TABLE); 468 for (i=0; i < IBM561_NCMAP_ENTRIES; i++) { 469 ibm561_regcont(data, IBM561_CMD_CMAP, data->cmap_r[i]); 470 ibm561_regcont(data, IBM561_CMD_CMAP, data->cmap_g[i]); 471 ibm561_regcont(data, IBM561_CMD_CMAP, data->cmap_b[i]); 472 } 473 474 ibm561_regbegin(data, IBM561_RED_GAMMA_TABLE); 475 for (i=0; i < 256; i++) 476 ibm561_regcont10bit(data, IBM561_CMD_GAMMA, data->gamma_r[i]); 477 478 ibm561_regbegin(data, IBM561_GREEN_GAMMA_TABLE); 479 for (i=1; i < 256; i++) 480 ibm561_regcont10bit(data, IBM561_CMD_GAMMA, data->gamma_g[i]); 481 482 ibm561_regbegin(data, IBM561_BLUE_GAMMA_TABLE); 483 for (i=1; i < 256; i++) 484 ibm561_regcont10bit(data, IBM561_CMD_GAMMA, data->gamma_b[i]); 485 486 } 487 488 static void 489 ibm561_load_dotclock(struct ibm561data *data) 490 { 491 /* XXX 492 * we should probably be more pro-active here, but it shouldn't 493 * actually happen... 494 */ 495 if (!data->vco_div || !data->pll_ref || ! data->div_dotclock) { 496 panic("ibm561_load_dotclock: called uninitialized"); 497 } 498 499 ibm561_regwr(data, IBM561_PLL_VCO_DIV, data->vco_div); 500 ibm561_regwr(data, IBM561_PLL_REF_REG, data->pll_ref); 501 ibm561_regwr(data, IBM561_DIV_DOTCLCK, data->div_dotclock); 502 } 503 504 static void 505 ibm561_regcont10bit(struct ibm561data *data, u_int16_t reg, u_int16_t val) 506 { 507 data->ramdac_wr(data->cookie, IBM561_CMD_GAMMA, (val >> 2) & 0xff); 508 data->ramdac_wr(data->cookie, IBM561_CMD_GAMMA, (val & 0x3) << 6); 509 } 510 511 static void 512 ibm561_regbegin(struct ibm561data *data, u_int16_t reg) 513 { 514 data->ramdac_wr(data->cookie, IBM561_ADDR_LOW, reg & 0xff); 515 data->ramdac_wr(data->cookie, IBM561_ADDR_HIGH, (reg >> 8) & 0xff); 516 } 517 518 static void 519 ibm561_regcont(struct ibm561data *data, u_int16_t reg, u_int8_t val) 520 { 521 data->ramdac_wr(data->cookie, reg, val); 522 } 523 524 static void 525 ibm561_regwr(struct ibm561data *data, u_int16_t reg, u_int8_t val) 526 { 527 ibm561_regbegin(data, reg); 528 ibm561_regcont(data, IBM561_CMD, val); 529 } 530