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