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