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