1 /* 2 * 3 * Hardware accelerated Matrox Millennium I, II, Mystique, G100, G200, G400 and G450. 4 * 5 * (c) 1998-2002 Petr Vandrovec <vandrove@vc.cvut.cz> 6 * 7 * Portions Copyright (c) 2001 Matrox Graphics Inc. 8 * 9 * Version: 1.65 2002/08/14 10 * 11 * See matroxfb_base.c for contributors. 12 * 13 */ 14 15 #include "matroxfb_maven.h" 16 #include "matroxfb_misc.h" 17 #include "matroxfb_DAC1064.h" 18 #include <linux/i2c.h> 19 #include <linux/matroxfb.h> 20 #include <linux/slab.h> 21 #include <asm/div64.h> 22 23 #define MGATVO_B 1 24 #define MGATVO_C 2 25 26 static const struct maven_gamma { 27 unsigned char reg83; 28 unsigned char reg84; 29 unsigned char reg85; 30 unsigned char reg86; 31 unsigned char reg87; 32 unsigned char reg88; 33 unsigned char reg89; 34 unsigned char reg8a; 35 unsigned char reg8b; 36 } maven_gamma[] = { 37 { 131, 57, 223, 15, 117, 212, 251, 91, 156}, 38 { 133, 61, 128, 63, 180, 147, 195, 100, 180}, 39 { 131, 19, 63, 31, 50, 66, 171, 64, 176}, 40 { 0, 0, 0, 31, 16, 16, 16, 100, 200}, 41 { 8, 23, 47, 73, 147, 244, 220, 80, 195}, 42 { 22, 43, 64, 80, 147, 115, 58, 85, 168}, 43 { 34, 60, 80, 214, 147, 212, 188, 85, 167}, 44 { 45, 77, 96, 216, 147, 99, 91, 85, 159}, 45 { 56, 76, 112, 107, 147, 212, 148, 64, 144}, 46 { 65, 91, 128, 137, 147, 196, 17, 69, 148}, 47 { 72, 104, 136, 138, 147, 180, 245, 73, 147}, 48 { 87, 116, 143, 126, 16, 83, 229, 77, 144}, 49 { 95, 119, 152, 254, 244, 83, 221, 77, 151}, 50 { 100, 129, 159, 156, 244, 148, 197, 77, 160}, 51 { 105, 141, 167, 247, 244, 132, 181, 84, 166}, 52 { 105, 147, 168, 247, 244, 245, 181, 90, 170}, 53 { 120, 153, 175, 248, 212, 229, 165, 90, 180}, 54 { 119, 156, 176, 248, 244, 229, 84, 74, 160}, 55 { 119, 158, 183, 248, 244, 229, 149, 78, 165} 56 }; 57 58 /* Definition of the various controls */ 59 struct mctl { 60 struct v4l2_queryctrl desc; 61 size_t control; 62 }; 63 64 #define BLMIN 0x0FF 65 #define WLMAX 0x3FF 66 67 static const struct mctl maven_controls[] = 68 { { { V4L2_CID_BRIGHTNESS, V4L2_CTRL_TYPE_INTEGER, 69 "brightness", 70 0, WLMAX - BLMIN, 1, 379 - BLMIN, 71 0, 72 }, offsetof(struct matrox_fb_info, altout.tvo_params.brightness) }, 73 { { V4L2_CID_CONTRAST, V4L2_CTRL_TYPE_INTEGER, 74 "contrast", 75 0, 1023, 1, 127, 76 0, 77 }, offsetof(struct matrox_fb_info, altout.tvo_params.contrast) }, 78 { { V4L2_CID_SATURATION, V4L2_CTRL_TYPE_INTEGER, 79 "saturation", 80 0, 255, 1, 155, 81 0, 82 }, offsetof(struct matrox_fb_info, altout.tvo_params.saturation) }, 83 { { V4L2_CID_HUE, V4L2_CTRL_TYPE_INTEGER, 84 "hue", 85 0, 255, 1, 0, 86 0, 87 }, offsetof(struct matrox_fb_info, altout.tvo_params.hue) }, 88 { { V4L2_CID_GAMMA, V4L2_CTRL_TYPE_INTEGER, 89 "gamma", 90 0, ARRAY_SIZE(maven_gamma) - 1, 1, 3, 91 0, 92 }, offsetof(struct matrox_fb_info, altout.tvo_params.gamma) }, 93 { { MATROXFB_CID_TESTOUT, V4L2_CTRL_TYPE_BOOLEAN, 94 "test output", 95 0, 1, 1, 0, 96 0, 97 }, offsetof(struct matrox_fb_info, altout.tvo_params.testout) }, 98 { { MATROXFB_CID_DEFLICKER, V4L2_CTRL_TYPE_INTEGER, 99 "deflicker mode", 100 0, 2, 1, 0, 101 0, 102 }, offsetof(struct matrox_fb_info, altout.tvo_params.deflicker) }, 103 104 }; 105 106 #define MAVCTRLS ARRAY_SIZE(maven_controls) 107 108 /* Return: positive number: id found 109 -EINVAL: id not found, return failure 110 -ENOENT: id not found, create fake disabled control */ 111 static int get_ctrl_id(__u32 v4l2_id) { 112 int i; 113 114 for (i = 0; i < MAVCTRLS; i++) { 115 if (v4l2_id < maven_controls[i].desc.id) { 116 if (maven_controls[i].desc.id == 0x08000000) { 117 return -EINVAL; 118 } 119 return -ENOENT; 120 } 121 if (v4l2_id == maven_controls[i].desc.id) { 122 return i; 123 } 124 } 125 return -EINVAL; 126 } 127 128 struct maven_data { 129 struct matrox_fb_info* primary_head; 130 struct i2c_client *client; 131 int version; 132 }; 133 134 static int* get_ctrl_ptr(struct maven_data* md, int idx) { 135 return (int*)((char*)(md->primary_head) + maven_controls[idx].control); 136 } 137 138 static int maven_get_reg(struct i2c_client* c, char reg) { 139 char dst; 140 struct i2c_msg msgs[] = { 141 { 142 .addr = c->addr, 143 .flags = I2C_M_REV_DIR_ADDR, 144 .len = sizeof(reg), 145 .buf = ® 146 }, 147 { 148 .addr = c->addr, 149 .flags = I2C_M_RD | I2C_M_NOSTART, 150 .len = sizeof(dst), 151 .buf = &dst 152 } 153 }; 154 s32 err; 155 156 err = i2c_transfer(c->adapter, msgs, 2); 157 if (err < 0) 158 printk(KERN_INFO "ReadReg(%d) failed\n", reg); 159 return dst & 0xFF; 160 } 161 162 static int maven_set_reg(struct i2c_client* c, int reg, int val) { 163 s32 err; 164 165 err = i2c_smbus_write_byte_data(c, reg, val); 166 if (err) 167 printk(KERN_INFO "WriteReg(%d) failed\n", reg); 168 return err; 169 } 170 171 static int maven_set_reg_pair(struct i2c_client* c, int reg, int val) { 172 s32 err; 173 174 err = i2c_smbus_write_word_data(c, reg, val); 175 if (err) 176 printk(KERN_INFO "WriteRegPair(%d) failed\n", reg); 177 return err; 178 } 179 180 static const struct matrox_pll_features maven_pll = { 181 50000, 182 27000, 183 4, 127, 184 2, 31, 185 3 186 }; 187 188 struct matrox_pll_features2 { 189 unsigned int vco_freq_min; 190 unsigned int vco_freq_max; 191 unsigned int feed_div_min; 192 unsigned int feed_div_max; 193 unsigned int in_div_min; 194 unsigned int in_div_max; 195 unsigned int post_shift_max; 196 }; 197 198 struct matrox_pll_ctl { 199 unsigned int ref_freq; 200 unsigned int den; 201 }; 202 203 static const struct matrox_pll_features2 maven1000_pll = { 204 .vco_freq_min = 50000000, 205 .vco_freq_max = 300000000, 206 .feed_div_min = 5, 207 .feed_div_max = 128, 208 .in_div_min = 3, 209 .in_div_max = 32, 210 .post_shift_max = 3 211 }; 212 213 static const struct matrox_pll_ctl maven_PAL = { 214 .ref_freq = 540000, 215 .den = 50 216 }; 217 218 static const struct matrox_pll_ctl maven_NTSC = { 219 .ref_freq = 450450, /* 27027000/60 == 27000000/59.94005994 */ 220 .den = 60 221 }; 222 223 static int matroxfb_PLL_mavenclock(const struct matrox_pll_features2* pll, 224 const struct matrox_pll_ctl* ctl, 225 unsigned int htotal, unsigned int vtotal, 226 unsigned int* in, unsigned int* feed, unsigned int* post, 227 unsigned int* h2) { 228 unsigned int besth2 = 0; 229 unsigned int fxtal = ctl->ref_freq; 230 unsigned int fmin = pll->vco_freq_min / ctl->den; 231 unsigned int fwant; 232 unsigned int p; 233 unsigned int scrlen; 234 unsigned int fmax; 235 236 DBG(__func__) 237 238 scrlen = htotal * (vtotal - 1); 239 fwant = htotal * vtotal; 240 fmax = pll->vco_freq_max / ctl->den; 241 242 dprintk(KERN_DEBUG "want: %u, xtal: %u, h: %u, v: %u, fmax: %u\n", 243 fwant, fxtal, htotal, vtotal, fmax); 244 for (p = 1; p <= pll->post_shift_max; p++) { 245 if (fwant * 2 > fmax) 246 break; 247 fwant *= 2; 248 } 249 if (fwant > fmax) 250 return 0; 251 for (; p-- > 0; fwant >>= 1) { 252 unsigned int m; 253 254 if (fwant < fmin) break; 255 for (m = pll->in_div_min; m <= pll->in_div_max; m++) { 256 unsigned int n; 257 unsigned int dvd; 258 unsigned int ln; 259 260 n = (fwant * m) / fxtal; 261 if (n < pll->feed_div_min) 262 continue; 263 if (n > pll->feed_div_max) 264 break; 265 266 ln = fxtal * n; 267 dvd = m << p; 268 269 if (ln % dvd) 270 continue; 271 ln = ln / dvd; 272 273 if (ln < scrlen + 2) 274 continue; 275 ln = ln - scrlen; 276 if (ln > htotal) 277 continue; 278 dprintk(KERN_DEBUG "Match: %u / %u / %u / %u\n", n, m, p, ln); 279 if (ln > besth2) { 280 dprintk(KERN_DEBUG "Better...\n"); 281 *h2 = besth2 = ln; 282 *post = p; 283 *in = m; 284 *feed = n; 285 } 286 } 287 } 288 289 /* if h2/post/in/feed have not been assigned, return zero (error) */ 290 if (besth2 < 2) 291 return 0; 292 293 dprintk(KERN_ERR "clk: %02X %02X %02X %d %d\n", *in, *feed, *post, fxtal, fwant); 294 return fxtal * (*feed) / (*in) * ctl->den; 295 } 296 297 static int matroxfb_mavenclock(const struct matrox_pll_ctl *ctl, 298 unsigned int htotal, unsigned int vtotal, 299 unsigned int* in, unsigned int* feed, unsigned int* post, 300 unsigned int* htotal2) { 301 unsigned int fvco; 302 unsigned int uninitialized_var(p); 303 304 fvco = matroxfb_PLL_mavenclock(&maven1000_pll, ctl, htotal, vtotal, in, feed, &p, htotal2); 305 if (!fvco) 306 return -EINVAL; 307 p = (1 << p) - 1; 308 if (fvco <= 100000000) 309 ; 310 else if (fvco <= 140000000) 311 p |= 0x08; 312 else if (fvco <= 180000000) 313 p |= 0x10; 314 else 315 p |= 0x18; 316 *post = p; 317 return 0; 318 } 319 320 static void DAC1064_calcclock(unsigned int freq, unsigned int fmax, 321 unsigned int* in, unsigned int* feed, unsigned int* post) { 322 unsigned int fvco; 323 unsigned int p; 324 325 fvco = matroxfb_PLL_calcclock(&maven_pll, freq, fmax, in, feed, &p); 326 p = (1 << p) - 1; 327 if (fvco <= 100000) 328 ; 329 else if (fvco <= 140000) 330 p |= 0x08; 331 else if (fvco <= 180000) 332 p |= 0x10; 333 else 334 p |= 0x18; 335 *post = p; 336 return; 337 } 338 339 static unsigned char maven_compute_deflicker (const struct maven_data* md) { 340 unsigned char df; 341 342 df = (md->version == MGATVO_B?0x40:0x00); 343 switch (md->primary_head->altout.tvo_params.deflicker) { 344 case 0: 345 /* df |= 0x00; */ 346 break; 347 case 1: 348 df |= 0xB1; 349 break; 350 case 2: 351 df |= 0xA2; 352 break; 353 } 354 return df; 355 } 356 357 static void maven_compute_bwlevel (const struct maven_data* md, 358 int *bl, int *wl) { 359 const int b = md->primary_head->altout.tvo_params.brightness + BLMIN; 360 const int c = md->primary_head->altout.tvo_params.contrast; 361 362 *bl = max(b - c, BLMIN); 363 *wl = min(b + c, WLMAX); 364 } 365 366 static const struct maven_gamma* maven_compute_gamma (const struct maven_data* md) { 367 return maven_gamma + md->primary_head->altout.tvo_params.gamma; 368 } 369 370 371 static void maven_init_TVdata(const struct maven_data* md, struct mavenregs* data) { 372 static struct mavenregs palregs = { { 373 0x2A, 0x09, 0x8A, 0xCB, /* 00: chroma subcarrier */ 374 0x00, 375 0x00, /* ? not written */ 376 0x00, /* modified by code (F9 written...) */ 377 0x00, /* ? not written */ 378 0x7E, /* 08 */ 379 0x44, /* 09 */ 380 0x9C, /* 0A */ 381 0x2E, /* 0B */ 382 0x21, /* 0C */ 383 0x00, /* ? not written */ 384 0x3F, 0x03, /* 0E-0F */ 385 0x3F, 0x03, /* 10-11 */ 386 0x1A, /* 12 */ 387 0x2A, /* 13 */ 388 0x1C, 0x3D, 0x14, /* 14-16 */ 389 0x9C, 0x01, /* 17-18 */ 390 0x00, /* 19 */ 391 0xFE, /* 1A */ 392 0x7E, /* 1B */ 393 0x60, /* 1C */ 394 0x05, /* 1D */ 395 0x89, 0x03, /* 1E-1F */ 396 0x72, /* 20 */ 397 0x07, /* 21 */ 398 0x72, /* 22 */ 399 0x00, /* 23 */ 400 0x00, /* 24 */ 401 0x00, /* 25 */ 402 0x08, /* 26 */ 403 0x04, /* 27 */ 404 0x00, /* 28 */ 405 0x1A, /* 29 */ 406 0x55, 0x01, /* 2A-2B */ 407 0x26, /* 2C */ 408 0x07, 0x7E, /* 2D-2E */ 409 0x02, 0x54, /* 2F-30 */ 410 0xB0, 0x00, /* 31-32 */ 411 0x14, /* 33 */ 412 0x49, /* 34 */ 413 0x00, /* 35 written multiple times */ 414 0x00, /* 36 not written */ 415 0xA3, /* 37 */ 416 0xC8, /* 38 */ 417 0x22, /* 39 */ 418 0x02, /* 3A */ 419 0x22, /* 3B */ 420 0x3F, 0x03, /* 3C-3D */ 421 0x00, /* 3E written multiple times */ 422 0x00, /* 3F not written */ 423 }, MATROXFB_OUTPUT_MODE_PAL, 625, 50 }; 424 static struct mavenregs ntscregs = { { 425 0x21, 0xF0, 0x7C, 0x1F, /* 00: chroma subcarrier */ 426 0x00, 427 0x00, /* ? not written */ 428 0x00, /* modified by code (F9 written...) */ 429 0x00, /* ? not written */ 430 0x7E, /* 08 */ 431 0x43, /* 09 */ 432 0x7E, /* 0A */ 433 0x3D, /* 0B */ 434 0x00, /* 0C */ 435 0x00, /* ? not written */ 436 0x41, 0x00, /* 0E-0F */ 437 0x3C, 0x00, /* 10-11 */ 438 0x17, /* 12 */ 439 0x21, /* 13 */ 440 0x1B, 0x1B, 0x24, /* 14-16 */ 441 0x83, 0x01, /* 17-18 */ 442 0x00, /* 19 */ 443 0x0F, /* 1A */ 444 0x0F, /* 1B */ 445 0x60, /* 1C */ 446 0x05, /* 1D */ 447 0x89, 0x02, /* 1E-1F */ 448 0x5F, /* 20 */ 449 0x04, /* 21 */ 450 0x5F, /* 22 */ 451 0x01, /* 23 */ 452 0x02, /* 24 */ 453 0x00, /* 25 */ 454 0x0A, /* 26 */ 455 0x05, /* 27 */ 456 0x00, /* 28 */ 457 0x10, /* 29 */ 458 0xFF, 0x03, /* 2A-2B */ 459 0x24, /* 2C */ 460 0x0F, 0x78, /* 2D-2E */ 461 0x00, 0x00, /* 2F-30 */ 462 0xB2, 0x04, /* 31-32 */ 463 0x14, /* 33 */ 464 0x02, /* 34 */ 465 0x00, /* 35 written multiple times */ 466 0x00, /* 36 not written */ 467 0xA3, /* 37 */ 468 0xC8, /* 38 */ 469 0x15, /* 39 */ 470 0x05, /* 3A */ 471 0x3B, /* 3B */ 472 0x3C, 0x00, /* 3C-3D */ 473 0x00, /* 3E written multiple times */ 474 0x00, /* never written */ 475 }, MATROXFB_OUTPUT_MODE_NTSC, 525, 60 }; 476 struct matrox_fb_info *minfo = md->primary_head; 477 478 if (minfo->outputs[1].mode == MATROXFB_OUTPUT_MODE_PAL) 479 *data = palregs; 480 else 481 *data = ntscregs; 482 483 /* Set deflicker */ 484 data->regs[0x93] = maven_compute_deflicker(md); 485 486 /* set gamma */ 487 { 488 const struct maven_gamma* g; 489 g = maven_compute_gamma(md); 490 data->regs[0x83] = g->reg83; 491 data->regs[0x84] = g->reg84; 492 data->regs[0x85] = g->reg85; 493 data->regs[0x86] = g->reg86; 494 data->regs[0x87] = g->reg87; 495 data->regs[0x88] = g->reg88; 496 data->regs[0x89] = g->reg89; 497 data->regs[0x8A] = g->reg8a; 498 data->regs[0x8B] = g->reg8b; 499 } 500 501 /* Set contrast / brightness */ 502 { 503 int bl, wl; 504 maven_compute_bwlevel (md, &bl, &wl); 505 data->regs[0x0e] = bl >> 2; 506 data->regs[0x0f] = bl & 3; 507 data->regs[0x1e] = wl >> 2; 508 data->regs[0x1f] = wl & 3; 509 } 510 511 /* Set saturation */ 512 { 513 data->regs[0x20] = 514 data->regs[0x22] = minfo->altout.tvo_params.saturation; 515 } 516 517 /* Set HUE */ 518 data->regs[0x25] = minfo->altout.tvo_params.hue; 519 return; 520 } 521 522 #define LR(x) maven_set_reg(c, (x), m->regs[(x)]) 523 #define LRP(x) maven_set_reg_pair(c, (x), m->regs[(x)] | (m->regs[(x)+1] << 8)) 524 static void maven_init_TV(struct i2c_client* c, const struct mavenregs* m) { 525 int val; 526 527 528 maven_set_reg(c, 0x3E, 0x01); 529 maven_get_reg(c, 0x82); /* fetch oscillator state? */ 530 maven_set_reg(c, 0x8C, 0x00); 531 maven_get_reg(c, 0x94); /* get 0x82 */ 532 maven_set_reg(c, 0x94, 0xA2); 533 /* xmiscctrl */ 534 535 maven_set_reg_pair(c, 0x8E, 0x1EFF); 536 maven_set_reg(c, 0xC6, 0x01); 537 538 /* removed code... */ 539 540 maven_get_reg(c, 0x06); 541 maven_set_reg(c, 0x06, 0xF9); /* or read |= 0xF0 ? */ 542 543 /* removed code here... */ 544 545 /* real code begins here? */ 546 /* chroma subcarrier */ 547 LR(0x00); LR(0x01); LR(0x02); LR(0x03); 548 549 LR(0x04); 550 551 LR(0x2C); 552 LR(0x08); 553 LR(0x0A); 554 LR(0x09); 555 LR(0x29); 556 LRP(0x31); 557 LRP(0x17); 558 LR(0x0B); 559 LR(0x0C); 560 if (m->mode == MATROXFB_OUTPUT_MODE_PAL) { 561 maven_set_reg(c, 0x35, 0x10); /* ... */ 562 } else { 563 maven_set_reg(c, 0x35, 0x0F); /* ... */ 564 } 565 566 LRP(0x10); 567 568 LRP(0x0E); 569 LRP(0x1E); 570 571 LR(0x20); /* saturation #1 */ 572 LR(0x22); /* saturation #2 */ 573 LR(0x25); /* hue */ 574 LR(0x34); 575 LR(0x33); 576 LR(0x19); 577 LR(0x12); 578 LR(0x3B); 579 LR(0x13); 580 LR(0x39); 581 LR(0x1D); 582 LR(0x3A); 583 LR(0x24); 584 LR(0x14); 585 LR(0x15); 586 LR(0x16); 587 LRP(0x2D); 588 LRP(0x2F); 589 LR(0x1A); 590 LR(0x1B); 591 LR(0x1C); 592 LR(0x23); 593 LR(0x26); 594 LR(0x28); 595 LR(0x27); 596 LR(0x21); 597 LRP(0x2A); 598 if (m->mode == MATROXFB_OUTPUT_MODE_PAL) 599 maven_set_reg(c, 0x35, 0x1D); /* ... */ 600 else 601 maven_set_reg(c, 0x35, 0x1C); 602 603 LRP(0x3C); 604 LR(0x37); 605 LR(0x38); 606 maven_set_reg(c, 0xB3, 0x01); 607 608 maven_get_reg(c, 0xB0); /* read 0x80 */ 609 maven_set_reg(c, 0xB0, 0x08); /* ugh... */ 610 maven_get_reg(c, 0xB9); /* read 0x7C */ 611 maven_set_reg(c, 0xB9, 0x78); 612 maven_get_reg(c, 0xBF); /* read 0x00 */ 613 maven_set_reg(c, 0xBF, 0x02); 614 maven_get_reg(c, 0x94); /* read 0x82 */ 615 maven_set_reg(c, 0x94, 0xB3); 616 617 LR(0x80); /* 04 1A 91 or 05 21 91 */ 618 LR(0x81); 619 LR(0x82); 620 621 maven_set_reg(c, 0x8C, 0x20); 622 maven_get_reg(c, 0x8D); 623 maven_set_reg(c, 0x8D, 0x10); 624 625 LR(0x90); /* 4D 50 52 or 4E 05 45 */ 626 LR(0x91); 627 LR(0x92); 628 629 LRP(0x9A); /* 0049 or 004F */ 630 LRP(0x9C); /* 0004 or 0004 */ 631 LRP(0x9E); /* 0458 or 045E */ 632 LRP(0xA0); /* 05DA or 051B */ 633 LRP(0xA2); /* 00CC or 00CF */ 634 LRP(0xA4); /* 007D or 007F */ 635 LRP(0xA6); /* 007C or 007E */ 636 LRP(0xA8); /* 03CB or 03CE */ 637 LRP(0x98); /* 0000 or 0000 */ 638 LRP(0xAE); /* 0044 or 003A */ 639 LRP(0x96); /* 05DA or 051B */ 640 LRP(0xAA); /* 04BC or 046A */ 641 LRP(0xAC); /* 004D or 004E */ 642 643 LR(0xBE); 644 LR(0xC2); 645 646 maven_get_reg(c, 0x8D); 647 maven_set_reg(c, 0x8D, 0x04); 648 649 LR(0x20); /* saturation #1 */ 650 LR(0x22); /* saturation #2 */ 651 LR(0x93); /* whoops */ 652 LR(0x20); /* oh, saturation #1 again */ 653 LR(0x22); /* oh, saturation #2 again */ 654 LR(0x25); /* hue */ 655 LRP(0x0E); 656 LRP(0x1E); 657 LRP(0x0E); /* problems with memory? */ 658 LRP(0x1E); /* yes, matrox must have problems in memory area... */ 659 660 /* load gamma correction stuff */ 661 LR(0x83); 662 LR(0x84); 663 LR(0x85); 664 LR(0x86); 665 LR(0x87); 666 LR(0x88); 667 LR(0x89); 668 LR(0x8A); 669 LR(0x8B); 670 671 val = maven_get_reg(c, 0x8D); 672 val &= 0x14; /* 0x10 or anything ored with it */ 673 maven_set_reg(c, 0x8D, val); 674 675 LR(0x33); 676 LR(0x19); 677 LR(0x12); 678 LR(0x3B); 679 LR(0x13); 680 LR(0x39); 681 LR(0x1D); 682 LR(0x3A); 683 LR(0x24); 684 LR(0x14); 685 LR(0x15); 686 LR(0x16); 687 LRP(0x2D); 688 LRP(0x2F); 689 LR(0x1A); 690 LR(0x1B); 691 LR(0x1C); 692 LR(0x23); 693 LR(0x26); 694 LR(0x28); 695 LR(0x27); 696 LR(0x21); 697 LRP(0x2A); 698 if (m->mode == MATROXFB_OUTPUT_MODE_PAL) 699 maven_set_reg(c, 0x35, 0x1D); 700 else 701 maven_set_reg(c, 0x35, 0x1C); 702 LRP(0x3C); 703 LR(0x37); 704 LR(0x38); 705 706 maven_get_reg(c, 0xB0); 707 LR(0xB0); /* output mode */ 708 LR(0x90); 709 LR(0xBE); 710 LR(0xC2); 711 712 LRP(0x9A); 713 LRP(0xA2); 714 LRP(0x9E); 715 LRP(0xA6); 716 LRP(0xAA); 717 LRP(0xAC); 718 maven_set_reg(c, 0x3E, 0x00); 719 maven_set_reg(c, 0x95, 0x20); 720 } 721 722 static int maven_find_exact_clocks(unsigned int ht, unsigned int vt, 723 struct mavenregs* m) { 724 unsigned int x; 725 unsigned int err = ~0; 726 727 /* 1:1 */ 728 m->regs[0x80] = 0x0F; 729 m->regs[0x81] = 0x07; 730 m->regs[0x82] = 0x81; 731 732 for (x = 0; x < 8; x++) { 733 unsigned int c; 734 unsigned int uninitialized_var(a), uninitialized_var(b), 735 uninitialized_var(h2); 736 unsigned int h = ht + 2 + x; 737 738 if (!matroxfb_mavenclock((m->mode == MATROXFB_OUTPUT_MODE_PAL) ? &maven_PAL : &maven_NTSC, h, vt, &a, &b, &c, &h2)) { 739 unsigned int diff = h - h2; 740 741 if (diff < err) { 742 err = diff; 743 m->regs[0x80] = a - 1; 744 m->regs[0x81] = b - 1; 745 m->regs[0x82] = c | 0x80; 746 m->hcorr = h2 - 2; 747 m->htotal = h - 2; 748 } 749 } 750 } 751 return err != ~0U; 752 } 753 754 static inline int maven_compute_timming(struct maven_data* md, 755 struct my_timming* mt, 756 struct mavenregs* m) { 757 unsigned int tmpi; 758 unsigned int a, bv, c; 759 struct matrox_fb_info *minfo = md->primary_head; 760 761 m->mode = minfo->outputs[1].mode; 762 if (m->mode != MATROXFB_OUTPUT_MODE_MONITOR) { 763 unsigned int lmargin; 764 unsigned int umargin; 765 unsigned int vslen; 766 unsigned int hcrt; 767 unsigned int slen; 768 769 maven_init_TVdata(md, m); 770 771 if (maven_find_exact_clocks(mt->HTotal, mt->VTotal, m) == 0) 772 return -EINVAL; 773 774 lmargin = mt->HTotal - mt->HSyncEnd; 775 slen = mt->HSyncEnd - mt->HSyncStart; 776 hcrt = mt->HTotal - slen - mt->delay; 777 umargin = mt->VTotal - mt->VSyncEnd; 778 vslen = mt->VSyncEnd - mt->VSyncStart; 779 780 if (m->hcorr < mt->HTotal) 781 hcrt += m->hcorr; 782 if (hcrt > mt->HTotal) 783 hcrt -= mt->HTotal; 784 if (hcrt + 2 > mt->HTotal) 785 hcrt = 0; /* or issue warning? */ 786 787 /* last (first? middle?) line in picture can have different length */ 788 /* hlen - 2 */ 789 m->regs[0x96] = m->hcorr; 790 m->regs[0x97] = m->hcorr >> 8; 791 /* ... */ 792 m->regs[0x98] = 0x00; m->regs[0x99] = 0x00; 793 /* hblanking end */ 794 m->regs[0x9A] = lmargin; /* 100% */ 795 m->regs[0x9B] = lmargin >> 8; /* 100% */ 796 /* who knows */ 797 m->regs[0x9C] = 0x04; 798 m->regs[0x9D] = 0x00; 799 /* htotal - 2 */ 800 m->regs[0xA0] = m->htotal; 801 m->regs[0xA1] = m->htotal >> 8; 802 /* vblanking end */ 803 m->regs[0xA2] = mt->VTotal - mt->VSyncStart - 1; /* stop vblanking */ 804 m->regs[0xA3] = (mt->VTotal - mt->VSyncStart - 1) >> 8; 805 /* something end... [A6]+1..[A8] */ 806 if (md->version == MGATVO_B) { 807 m->regs[0xA4] = 0x04; 808 m->regs[0xA5] = 0x00; 809 } else { 810 m->regs[0xA4] = 0x01; 811 m->regs[0xA5] = 0x00; 812 } 813 /* something start... 0..[A4]-1 */ 814 m->regs[0xA6] = 0x00; 815 m->regs[0xA7] = 0x00; 816 /* vertical line count - 1 */ 817 m->regs[0xA8] = mt->VTotal - 1; 818 m->regs[0xA9] = (mt->VTotal - 1) >> 8; 819 /* horizontal vidrst pos */ 820 m->regs[0xAA] = hcrt; /* 0 <= hcrt <= htotal - 2 */ 821 m->regs[0xAB] = hcrt >> 8; 822 /* vertical vidrst pos */ 823 m->regs[0xAC] = mt->VTotal - 2; 824 m->regs[0xAD] = (mt->VTotal - 2) >> 8; 825 /* moves picture up/down and so on... */ 826 m->regs[0xAE] = 0x01; /* Fix this... 0..VTotal */ 827 m->regs[0xAF] = 0x00; 828 { 829 int hdec; 830 int hlen; 831 unsigned int ibmin = 4 + lmargin + mt->HDisplay; 832 unsigned int ib; 833 int i; 834 835 /* Verify! */ 836 /* Where 94208 came from? */ 837 if (mt->HTotal) 838 hdec = 94208 / (mt->HTotal); 839 else 840 hdec = 0x81; 841 if (hdec > 0x81) 842 hdec = 0x81; 843 if (hdec < 0x41) 844 hdec = 0x41; 845 hdec--; 846 hlen = 98304 - 128 - ((lmargin + mt->HDisplay - 8) * hdec); 847 if (hlen < 0) 848 hlen = 0; 849 hlen = hlen >> 8; 850 if (hlen > 0xFF) 851 hlen = 0xFF; 852 /* Now we have to compute input buffer length. 853 If you want any picture, it must be between 854 4 + lmargin + xres 855 and 856 94208 / hdec 857 If you want perfect picture even on the top 858 of screen, it must be also 859 0x3C0000 * i / hdec + Q - R / hdec 860 where 861 R Qmin Qmax 862 0x07000 0x5AE 0x5BF 863 0x08000 0x5CF 0x5FF 864 0x0C000 0x653 0x67F 865 0x10000 0x6F8 0x6FF 866 */ 867 i = 1; 868 do { 869 ib = ((0x3C0000 * i - 0x8000)/ hdec + 0x05E7) >> 8; 870 i++; 871 } while (ib < ibmin); 872 if (ib >= m->htotal + 2) { 873 ib = ibmin; 874 } 875 876 m->regs[0x90] = hdec; /* < 0x40 || > 0x80 is bad... 0x80 is questionable */ 877 m->regs[0xC2] = hlen; 878 /* 'valid' input line length */ 879 m->regs[0x9E] = ib; 880 m->regs[0x9F] = ib >> 8; 881 } 882 { 883 int vdec; 884 int vlen; 885 886 #define MATROX_USE64BIT_DIVIDE 887 if (mt->VTotal) { 888 #ifdef MATROX_USE64BIT_DIVIDE 889 u64 f1; 890 u32 a; 891 u32 b; 892 893 a = m->vlines * (m->htotal + 2); 894 b = (mt->VTotal - 1) * (m->htotal + 2) + m->hcorr + 2; 895 896 f1 = ((u64)a) << 15; /* *32768 */ 897 do_div(f1, b); 898 vdec = f1; 899 #else 900 vdec = m->vlines * 32768 / mt->VTotal; 901 #endif 902 } else 903 vdec = 0x8000; 904 if (vdec > 0x8000) 905 vdec = 0x8000; 906 vlen = (vslen + umargin + mt->VDisplay) * vdec; 907 vlen = (vlen >> 16) - 146; /* FIXME: 146?! */ 908 if (vlen < 0) 909 vlen = 0; 910 if (vlen > 0xFF) 911 vlen = 0xFF; 912 vdec--; 913 m->regs[0x91] = vdec; 914 m->regs[0x92] = vdec >> 8; 915 m->regs[0xBE] = vlen; 916 } 917 m->regs[0xB0] = 0x08; /* output: SVideo/Composite */ 918 return 0; 919 } 920 921 DAC1064_calcclock(mt->pixclock, 450000, &a, &bv, &c); 922 m->regs[0x80] = a; 923 m->regs[0x81] = bv; 924 m->regs[0x82] = c | 0x80; 925 926 m->regs[0xB3] = 0x01; 927 m->regs[0x94] = 0xB2; 928 929 /* htotal... */ 930 m->regs[0x96] = mt->HTotal; 931 m->regs[0x97] = mt->HTotal >> 8; 932 /* ?? */ 933 m->regs[0x98] = 0x00; 934 m->regs[0x99] = 0x00; 935 /* hsync len */ 936 tmpi = mt->HSyncEnd - mt->HSyncStart; 937 m->regs[0x9A] = tmpi; 938 m->regs[0x9B] = tmpi >> 8; 939 /* hblank end */ 940 tmpi = mt->HTotal - mt->HSyncStart; 941 m->regs[0x9C] = tmpi; 942 m->regs[0x9D] = tmpi >> 8; 943 /* hblank start */ 944 tmpi += mt->HDisplay; 945 m->regs[0x9E] = tmpi; 946 m->regs[0x9F] = tmpi >> 8; 947 /* htotal + 1 */ 948 tmpi = mt->HTotal + 1; 949 m->regs[0xA0] = tmpi; 950 m->regs[0xA1] = tmpi >> 8; 951 /* vsync?! */ 952 tmpi = mt->VSyncEnd - mt->VSyncStart - 1; 953 m->regs[0xA2] = tmpi; 954 m->regs[0xA3] = tmpi >> 8; 955 /* ignored? */ 956 tmpi = mt->VTotal - mt->VSyncStart; 957 m->regs[0xA4] = tmpi; 958 m->regs[0xA5] = tmpi >> 8; 959 /* ignored? */ 960 tmpi = mt->VTotal - 1; 961 m->regs[0xA6] = tmpi; 962 m->regs[0xA7] = tmpi >> 8; 963 /* vtotal - 1 */ 964 m->regs[0xA8] = tmpi; 965 m->regs[0xA9] = tmpi >> 8; 966 /* hor vidrst */ 967 tmpi = mt->HTotal - mt->delay; 968 m->regs[0xAA] = tmpi; 969 m->regs[0xAB] = tmpi >> 8; 970 /* vert vidrst */ 971 tmpi = mt->VTotal - 2; 972 m->regs[0xAC] = tmpi; 973 m->regs[0xAD] = tmpi >> 8; 974 /* ignored? */ 975 m->regs[0xAE] = 0x00; 976 m->regs[0xAF] = 0x00; 977 978 m->regs[0xB0] = 0x03; /* output: monitor */ 979 m->regs[0xB1] = 0xA0; /* ??? */ 980 m->regs[0x8C] = 0x20; /* must be set... */ 981 m->regs[0x8D] = 0x04; /* defaults to 0x10: test signal */ 982 m->regs[0xB9] = 0x1A; /* defaults to 0x2C: too bright */ 983 m->regs[0xBF] = 0x22; /* makes picture stable */ 984 985 return 0; 986 } 987 988 static int maven_program_timming(struct maven_data* md, 989 const struct mavenregs* m) { 990 struct i2c_client *c = md->client; 991 992 if (m->mode == MATROXFB_OUTPUT_MODE_MONITOR) { 993 LR(0x80); 994 LR(0x81); 995 LR(0x82); 996 997 LR(0xB3); 998 LR(0x94); 999 1000 LRP(0x96); 1001 LRP(0x98); 1002 LRP(0x9A); 1003 LRP(0x9C); 1004 LRP(0x9E); 1005 LRP(0xA0); 1006 LRP(0xA2); 1007 LRP(0xA4); 1008 LRP(0xA6); 1009 LRP(0xA8); 1010 LRP(0xAA); 1011 LRP(0xAC); 1012 LRP(0xAE); 1013 1014 LR(0xB0); /* output: monitor */ 1015 LR(0xB1); /* ??? */ 1016 LR(0x8C); /* must be set... */ 1017 LR(0x8D); /* defaults to 0x10: test signal */ 1018 LR(0xB9); /* defaults to 0x2C: too bright */ 1019 LR(0xBF); /* makes picture stable */ 1020 } else { 1021 maven_init_TV(c, m); 1022 } 1023 return 0; 1024 } 1025 1026 static inline int maven_resync(struct maven_data* md) { 1027 struct i2c_client *c = md->client; 1028 maven_set_reg(c, 0x95, 0x20); /* start whole thing */ 1029 return 0; 1030 } 1031 1032 static int maven_get_queryctrl (struct maven_data* md, 1033 struct v4l2_queryctrl *p) { 1034 int i; 1035 1036 i = get_ctrl_id(p->id); 1037 if (i >= 0) { 1038 *p = maven_controls[i].desc; 1039 return 0; 1040 } 1041 if (i == -ENOENT) { 1042 static const struct v4l2_queryctrl disctrl = 1043 { .flags = V4L2_CTRL_FLAG_DISABLED }; 1044 1045 i = p->id; 1046 *p = disctrl; 1047 p->id = i; 1048 sprintf(p->name, "Ctrl #%08X", i); 1049 return 0; 1050 } 1051 return -EINVAL; 1052 } 1053 1054 static int maven_set_control (struct maven_data* md, 1055 struct v4l2_control *p) { 1056 int i; 1057 1058 i = get_ctrl_id(p->id); 1059 if (i < 0) return -EINVAL; 1060 1061 /* 1062 * Check if changed. 1063 */ 1064 if (p->value == *get_ctrl_ptr(md, i)) return 0; 1065 1066 /* 1067 * Check limits. 1068 */ 1069 if (p->value > maven_controls[i].desc.maximum) return -EINVAL; 1070 if (p->value < maven_controls[i].desc.minimum) return -EINVAL; 1071 1072 /* 1073 * Store new value. 1074 */ 1075 *get_ctrl_ptr(md, i) = p->value; 1076 1077 switch (p->id) { 1078 case V4L2_CID_BRIGHTNESS: 1079 case V4L2_CID_CONTRAST: 1080 { 1081 int blacklevel, whitelevel; 1082 maven_compute_bwlevel(md, &blacklevel, &whitelevel); 1083 blacklevel = (blacklevel >> 2) | ((blacklevel & 3) << 8); 1084 whitelevel = (whitelevel >> 2) | ((whitelevel & 3) << 8); 1085 maven_set_reg_pair(md->client, 0x0e, blacklevel); 1086 maven_set_reg_pair(md->client, 0x1e, whitelevel); 1087 } 1088 break; 1089 case V4L2_CID_SATURATION: 1090 { 1091 maven_set_reg(md->client, 0x20, p->value); 1092 maven_set_reg(md->client, 0x22, p->value); 1093 } 1094 break; 1095 case V4L2_CID_HUE: 1096 { 1097 maven_set_reg(md->client, 0x25, p->value); 1098 } 1099 break; 1100 case V4L2_CID_GAMMA: 1101 { 1102 const struct maven_gamma* g; 1103 g = maven_compute_gamma(md); 1104 maven_set_reg(md->client, 0x83, g->reg83); 1105 maven_set_reg(md->client, 0x84, g->reg84); 1106 maven_set_reg(md->client, 0x85, g->reg85); 1107 maven_set_reg(md->client, 0x86, g->reg86); 1108 maven_set_reg(md->client, 0x87, g->reg87); 1109 maven_set_reg(md->client, 0x88, g->reg88); 1110 maven_set_reg(md->client, 0x89, g->reg89); 1111 maven_set_reg(md->client, 0x8a, g->reg8a); 1112 maven_set_reg(md->client, 0x8b, g->reg8b); 1113 } 1114 break; 1115 case MATROXFB_CID_TESTOUT: 1116 { 1117 unsigned char val 1118 = maven_get_reg(md->client, 0x8d); 1119 if (p->value) val |= 0x10; 1120 else val &= ~0x10; 1121 maven_set_reg(md->client, 0x8d, val); 1122 } 1123 break; 1124 case MATROXFB_CID_DEFLICKER: 1125 { 1126 maven_set_reg(md->client, 0x93, maven_compute_deflicker(md)); 1127 } 1128 break; 1129 } 1130 1131 1132 return 0; 1133 } 1134 1135 static int maven_get_control (struct maven_data* md, 1136 struct v4l2_control *p) { 1137 int i; 1138 1139 i = get_ctrl_id(p->id); 1140 if (i < 0) return -EINVAL; 1141 p->value = *get_ctrl_ptr(md, i); 1142 return 0; 1143 } 1144 1145 /******************************************************/ 1146 1147 static int maven_out_compute(void* md, struct my_timming* mt) { 1148 #define mdinfo ((struct maven_data*)md) 1149 #define minfo (mdinfo->primary_head) 1150 return maven_compute_timming(md, mt, &minfo->hw.maven); 1151 #undef minfo 1152 #undef mdinfo 1153 } 1154 1155 static int maven_out_program(void* md) { 1156 #define mdinfo ((struct maven_data*)md) 1157 #define minfo (mdinfo->primary_head) 1158 return maven_program_timming(md, &minfo->hw.maven); 1159 #undef minfo 1160 #undef mdinfo 1161 } 1162 1163 static int maven_out_start(void* md) { 1164 return maven_resync(md); 1165 } 1166 1167 static int maven_out_verify_mode(void* md, u_int32_t arg) { 1168 switch (arg) { 1169 case MATROXFB_OUTPUT_MODE_PAL: 1170 case MATROXFB_OUTPUT_MODE_NTSC: 1171 case MATROXFB_OUTPUT_MODE_MONITOR: 1172 return 0; 1173 } 1174 return -EINVAL; 1175 } 1176 1177 static int maven_out_get_queryctrl(void* md, struct v4l2_queryctrl* p) { 1178 return maven_get_queryctrl(md, p); 1179 } 1180 1181 static int maven_out_get_ctrl(void* md, struct v4l2_control* p) { 1182 return maven_get_control(md, p); 1183 } 1184 1185 static int maven_out_set_ctrl(void* md, struct v4l2_control* p) { 1186 return maven_set_control(md, p); 1187 } 1188 1189 static struct matrox_altout maven_altout = { 1190 .name = "Secondary output", 1191 .compute = maven_out_compute, 1192 .program = maven_out_program, 1193 .start = maven_out_start, 1194 .verifymode = maven_out_verify_mode, 1195 .getqueryctrl = maven_out_get_queryctrl, 1196 .getctrl = maven_out_get_ctrl, 1197 .setctrl = maven_out_set_ctrl, 1198 }; 1199 1200 static int maven_init_client(struct i2c_client* clnt) { 1201 struct maven_data* md = i2c_get_clientdata(clnt); 1202 struct matrox_fb_info *minfo = container_of(clnt->adapter, 1203 struct i2c_bit_adapter, 1204 adapter)->minfo; 1205 1206 md->primary_head = minfo; 1207 md->client = clnt; 1208 down_write(&minfo->altout.lock); 1209 minfo->outputs[1].output = &maven_altout; 1210 minfo->outputs[1].src = minfo->outputs[1].default_src; 1211 minfo->outputs[1].data = md; 1212 minfo->outputs[1].mode = MATROXFB_OUTPUT_MODE_MONITOR; 1213 up_write(&minfo->altout.lock); 1214 if (maven_get_reg(clnt, 0xB2) < 0x14) { 1215 md->version = MGATVO_B; 1216 /* Tweak some things for this old chip */ 1217 } else { 1218 md->version = MGATVO_C; 1219 } 1220 /* 1221 * Set all parameters to its initial values. 1222 */ 1223 { 1224 unsigned int i; 1225 1226 for (i = 0; i < MAVCTRLS; ++i) { 1227 *get_ctrl_ptr(md, i) = maven_controls[i].desc.default_value; 1228 } 1229 } 1230 1231 return 0; 1232 } 1233 1234 static int maven_shutdown_client(struct i2c_client* clnt) { 1235 struct maven_data* md = i2c_get_clientdata(clnt); 1236 1237 if (md->primary_head) { 1238 struct matrox_fb_info *minfo = md->primary_head; 1239 1240 down_write(&minfo->altout.lock); 1241 minfo->outputs[1].src = MATROXFB_SRC_NONE; 1242 minfo->outputs[1].output = NULL; 1243 minfo->outputs[1].data = NULL; 1244 minfo->outputs[1].mode = MATROXFB_OUTPUT_MODE_MONITOR; 1245 up_write(&minfo->altout.lock); 1246 md->primary_head = NULL; 1247 } 1248 return 0; 1249 } 1250 1251 static int maven_probe(struct i2c_client *client, 1252 const struct i2c_device_id *id) 1253 { 1254 struct i2c_adapter *adapter = client->adapter; 1255 int err = -ENODEV; 1256 struct maven_data* data; 1257 1258 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_WORD_DATA | 1259 I2C_FUNC_SMBUS_BYTE_DATA | 1260 I2C_FUNC_NOSTART | 1261 I2C_FUNC_PROTOCOL_MANGLING)) 1262 goto ERROR0; 1263 if (!(data = kzalloc(sizeof(*data), GFP_KERNEL))) { 1264 err = -ENOMEM; 1265 goto ERROR0; 1266 } 1267 i2c_set_clientdata(client, data); 1268 err = maven_init_client(client); 1269 if (err) 1270 goto ERROR4; 1271 return 0; 1272 ERROR4:; 1273 kfree(data); 1274 ERROR0:; 1275 return err; 1276 } 1277 1278 static int maven_remove(struct i2c_client *client) 1279 { 1280 maven_shutdown_client(client); 1281 kfree(i2c_get_clientdata(client)); 1282 return 0; 1283 } 1284 1285 static const struct i2c_device_id maven_id[] = { 1286 { "maven", 0 }, 1287 { } 1288 }; 1289 MODULE_DEVICE_TABLE(i2c, maven_id); 1290 1291 static struct i2c_driver maven_driver={ 1292 .driver = { 1293 .name = "maven", 1294 }, 1295 .probe = maven_probe, 1296 .remove = maven_remove, 1297 .id_table = maven_id, 1298 }; 1299 1300 module_i2c_driver(maven_driver); 1301 MODULE_AUTHOR("(c) 1999-2002 Petr Vandrovec <vandrove@vc.cvut.cz>"); 1302 MODULE_DESCRIPTION("Matrox G200/G400 Matrox MGA-TVO driver"); 1303 MODULE_LICENSE("GPL"); 1304