?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / video / fbdev / matrox / matroxfb_maven.c
blob9a98c4a6ba3313e64f38ea385de774610b94b438
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 */
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
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
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 = &reg
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
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
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
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
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
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
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
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
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
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))
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
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
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
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
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
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
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
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
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
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
1164 static int maven_out_start(void* md) {
1165 return maven_resync(md);
1166 }
1167
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
1178 static int maven_out_get_queryctrl(void* md, struct v4l2_queryctrl* p) {
1179 return maven_get_queryctrl(md, p);
1180 }
1181
1182 static int maven_out_get_ctrl(void* md, struct v4l2_control* p) {
1183 return maven_get_control(md, p);
1184 }
1185
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
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
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
1252 static int maven_probe(struct i2c_client *client,
1253 const struct i2c_device_id *id)
1254 {
1255 struct i2c_adapter *adapter = client->adapter;
1256 int err = -ENODEV;
1257 struct maven_data* data;
1258
1259 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_WORD_DATA |
1260 I2C_FUNC_SMBUS_BYTE_DATA |
1261 I2C_FUNC_NOSTART |
1262 I2C_FUNC_PROTOCOL_MANGLING))
1263 goto ERROR0;
1264 if (!(data = kzalloc(sizeof(*data), GFP_KERNEL))) {
1265 err = -ENOMEM;
1266 goto ERROR0;
1267 }
1268 i2c_set_clientdata(client, data);
1269 err = maven_init_client(client);
1270 if (err)
1271 goto ERROR4;
1272 return 0;
1273 ERROR4:;
1274 kfree(data);
1275 ERROR0:;
1276 return err;
1277 }
1278
1279 static int maven_remove(struct i2c_client *client)
1280 {
1281 maven_shutdown_client(client);
1282 kfree(i2c_get_clientdata(client));
1283 return 0;
1284 }
1285
1286 static const struct i2c_device_id maven_id[] = {
1287 { "maven", 0 },
1288 { }
1289 };
1290 MODULE_DEVICE_TABLE(i2c, maven_id);
1291
1292 static struct i2c_driver maven_driver={
1293 .driver = {
1294 .name = "maven",
1295 },
1296 .probe = maven_probe,
1297 .remove = maven_remove,
1298 .id_table = maven_id,
1299 };
1300
1301 module_i2c_driver(maven_driver);
1302 MODULE_AUTHOR("(c) 1999-2002 Petr Vandrovec <vandrove@vc.cvut.cz>");
1303 MODULE_DESCRIPTION("Matrox G200/G400 Matrox MGA-TVO driver");
1304 MODULE_LICENSE("GPL");
Linux with added FPC-III support