Subversion Repositories shark

Rev

Rev 489 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
489 giacomo 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 <linuxcomp.h>
16
 
17
#include "matroxfb_maven.h"
18
#include "matroxfb_misc.h"
19
#include "matroxfb_DAC1064.h"
20
#include <linux/i2c.h>
21
#include <linux/matroxfb.h>
22
#include <asm/div64.h>
23
#include <asm/uaccess.h>
24
 
25
#define MAVEN_I2CID     (0x1B)
26
 
27
#define MGATVO_B        1
28
#define MGATVO_C        2
29
 
30
static const struct maven_gamma {
31
  unsigned char reg83;
32
  unsigned char reg84;
33
  unsigned char reg85;
34
  unsigned char reg86;
35
  unsigned char reg87;
36
  unsigned char reg88;
37
  unsigned char reg89;
38
  unsigned char reg8a;
39
  unsigned char reg8b;
40
} maven_gamma[] = {
41
  { 131, 57, 223, 15, 117, 212, 251, 91, 156},
42
  { 133, 61, 128, 63, 180, 147, 195, 100, 180},
43
  { 131, 19, 63, 31, 50, 66, 171, 64, 176},
44
  { 0, 0, 0, 31, 16, 16, 16, 100, 200},
45
  { 8, 23, 47, 73, 147, 244, 220, 80, 195},
46
  { 22, 43, 64, 80, 147, 115, 58, 85, 168},
47
  { 34, 60, 80, 214, 147, 212, 188, 85, 167},
48
  { 45, 77, 96, 216, 147, 99, 91, 85, 159},
49
  { 56, 76, 112, 107, 147, 212, 148, 64, 144},
50
  { 65, 91, 128, 137, 147, 196, 17, 69, 148},
51
  { 72, 104, 136, 138, 147, 180, 245, 73, 147},
52
  { 87, 116, 143, 126, 16, 83, 229, 77, 144},
53
  { 95, 119, 152, 254, 244, 83, 221, 77, 151},
54
  { 100, 129, 159, 156, 244, 148, 197, 77, 160},
55
  { 105, 141, 167, 247, 244, 132, 181, 84, 166},
56
  { 105, 147, 168, 247, 244, 245, 181, 90, 170},
57
  { 120, 153, 175, 248, 212, 229, 165, 90, 180},
58
  { 119, 156, 176, 248, 244, 229, 84, 74, 160},
59
  { 119, 158, 183, 248, 244, 229, 149, 78, 165}
60
};
61
 
62
/* Definition of the various controls */
63
struct mctl {
64
        struct v4l2_queryctrl desc;
65
        size_t control;
66
};
67
 
68
#define BLMIN   0x0FF
69
#define WLMAX   0x3FF
70
 
71
static const struct mctl maven_controls[] =
72
{       { { V4L2_CID_BRIGHTNESS, V4L2_CTRL_TYPE_INTEGER,
73
          "brightness",
74
          0, WLMAX - BLMIN, 1, 379 - BLMIN,
75
          0,
76
        }, offsetof(struct matrox_fb_info, altout.tvo_params.brightness) },
77
        { { V4L2_CID_CONTRAST, V4L2_CTRL_TYPE_INTEGER,
78
          "contrast",
79
          0, 1023, 1, 127,
80
          0,
81
        }, offsetof(struct matrox_fb_info, altout.tvo_params.contrast) },
82
        { { V4L2_CID_SATURATION, V4L2_CTRL_TYPE_INTEGER,
83
          "saturation",
84
          0, 255, 1, 155,
85
          0,
86
        }, offsetof(struct matrox_fb_info, altout.tvo_params.saturation) },
87
        { { V4L2_CID_HUE, V4L2_CTRL_TYPE_INTEGER,
88
          "hue",
89
          0, 255, 1, 0,
90
          0,
91
        }, offsetof(struct matrox_fb_info, altout.tvo_params.hue) },
92
        { { V4L2_CID_GAMMA, V4L2_CTRL_TYPE_INTEGER,
93
          "gamma",
94
          0, sizeof(maven_gamma)/sizeof(maven_gamma[0])-1, 1, 3,
95
          0,
96
        }, offsetof(struct matrox_fb_info, altout.tvo_params.gamma) },
97
        { { MATROXFB_CID_TESTOUT, V4L2_CTRL_TYPE_BOOLEAN,
98
          "test output",
99
          0, 1, 1, 0,
100
          0,
101
        }, offsetof(struct matrox_fb_info, altout.tvo_params.testout) },
102
        { { MATROXFB_CID_DEFLICKER, V4L2_CTRL_TYPE_INTEGER,
103
          "deflicker mode",
104
          0, 2, 1, 0,
105
          0,
106
        }, offsetof(struct matrox_fb_info, altout.tvo_params.deflicker) },
107
 
108
};
109
 
110
#define MAVCTRLS (sizeof(maven_controls)/sizeof(maven_controls[0]))
111
 
112
/* Return: positive number: id found
113
           -EINVAL:         id not found, return failure
114
           -ENOENT:         id not found, create fake disabled control */
115
static int get_ctrl_id(__u32 v4l2_id) {
116
        int i;
117
 
118
        for (i = 0; i < MAVCTRLS; i++) {
119
                if (v4l2_id < maven_controls[i].desc.id) {
120
                        if (maven_controls[i].desc.id == 0x08000000) {
121
                                return -EINVAL;
122
                        }
123
                        return -ENOENT;
124
                }
125
                if (v4l2_id == maven_controls[i].desc.id) {
126
                        return i;
127
                }
128
        }
129
        return -EINVAL;
130
}
131
 
132
struct maven_data {
133
        struct matrox_fb_info*          primary_head;
134
        struct i2c_client*              client;
135
        int                             version;
136
};
137
 
138
static int* get_ctrl_ptr(struct maven_data* md, int idx) {
139
        return (int*)((char*)(md->primary_head) + maven_controls[idx].control);
140
}
141
 
142
static int maven_get_reg(struct i2c_client* c, char reg) {
143
        char dst;
144
        struct i2c_msg msgs[] = {{ c->addr, I2C_M_REV_DIR_ADDR, sizeof(reg), &reg },
145
                                 { c->addr, I2C_M_RD | I2C_M_NOSTART, sizeof(dst), &dst }};
146
        s32 err;
147
 
148
        err = i2c_transfer(c->adapter, msgs, 2);
149
        if (err < 0)
150
                printk(KERN_INFO "ReadReg(%d) failed\n", reg);
151
        return dst & 0xFF;
152
}
153
 
154
static int maven_set_reg(struct i2c_client* c, int reg, int val) {
155
        s32 err;
156
 
157
        err = i2c_smbus_write_byte_data(c, reg, val);
158
        if (err)
159
                printk(KERN_INFO "WriteReg(%d) failed\n", reg);
160
        return err;
161
}
162
 
163
static int maven_set_reg_pair(struct i2c_client* c, int reg, int val) {
164
        s32 err;
165
 
166
        err = i2c_smbus_write_word_data(c, reg, val);
167
        if (err)
168
                printk(KERN_INFO "WriteRegPair(%d) failed\n", reg);
169
        return err;
170
}
171
 
172
static const struct matrox_pll_features maven_pll = {
173
        50000,
174
        27000,
175
        4, 127,
176
        2, 31,
177
        3
178
};
179
 
180
struct matrox_pll_features2 {
181
        unsigned int    vco_freq_min;
182
        unsigned int    vco_freq_max;
183
        unsigned int    feed_div_min;
184
        unsigned int    feed_div_max;
185
        unsigned int    in_div_min;
186
        unsigned int    in_div_max;
187
        unsigned int    post_shift_max;
188
};
189
 
190
struct matrox_pll_ctl {
191
        unsigned int    ref_freq;
192
        unsigned int    den;
193
};
194
 
195
static const struct matrox_pll_features2 maven1000_pll = {
196
         50000000,
197
        300000000,
198
         5, 128,
199
         3,  32,
200
         3
201
};
202
 
203
static const struct matrox_pll_ctl maven_PAL = {
204
        540000,
205
            50
206
};
207
 
208
static const struct matrox_pll_ctl maven_NTSC = {
209
        450450, /* 27027000/60 == 27000000/59.94005994 */
210
            60
211
};
212
 
213
static int matroxfb_PLL_mavenclock(const struct matrox_pll_features2* pll,
214
                const struct matrox_pll_ctl* ctl,
215
                unsigned int htotal, unsigned int vtotal,
216
                unsigned int* in, unsigned int* feed, unsigned int* post,
217
                unsigned int* h2) {
218
        unsigned int besth2 = 0;
219
        unsigned int fxtal = ctl->ref_freq;
220
        unsigned int fmin = pll->vco_freq_min / ctl->den;
221
        unsigned int fwant;
222
        unsigned int p;
223
        unsigned int scrlen;
224
        unsigned int fmax;
225
 
226
        DBG(__FUNCTION__)
227
 
228
        scrlen = htotal * (vtotal - 1);
229
        fwant = htotal * vtotal;
230
        fmax = pll->vco_freq_max / ctl->den;
231
 
232
        dprintk(KERN_DEBUG "want: %u, xtal: %u, h: %u, v: %u, fmax: %u\n",
233
                fwant, fxtal, htotal, vtotal, fmax);
234
        for (p = 1; p <= pll->post_shift_max; p++) {
235
                if (fwant * 2 > fmax)
236
                        break;
237
                fwant *= 2;
238
        }
239
        if (fwant > fmax)
240
                return 0;
241
        for (; p-- > 0; fwant >>= 1) {
242
                unsigned int m;
243
 
244
                if (fwant < fmin) break;
245
                for (m = pll->in_div_min; m <= pll->in_div_max; m++) {
246
                        unsigned int n;
247
                        unsigned int dvd;
248
                        unsigned int ln;
249
 
250
                        n = (fwant * m) / fxtal;
251
                        if (n < pll->feed_div_min)
252
                                continue;
253
                        if (n > pll->feed_div_max)
254
                                break;
255
 
256
                        ln = fxtal * n;
257
                        dvd = m << p;
258
 
259
                        if (ln % dvd)
260
                                continue;
261
                        ln = ln / dvd;
262
 
263
                        if (ln < scrlen + 2)
264
                                continue;
265
                        ln = ln - scrlen;
266
                        if (ln > htotal)
267
                                continue;
268
                        dprintk(KERN_DEBUG "Match: %u / %u / %u / %u\n", n, m, p, ln);
269
                        if (ln > besth2) {
270
                                dprintk(KERN_DEBUG "Better...\n");
271
                                *h2 = besth2 = ln;
272
                                *post = p;
273
                                *in = m;
274
                                *feed = n;
275
                        }
276
                }
277
        }
278
        if (besth2 < 2)
279
                return 0;
280
        dprintk(KERN_ERR "clk: %02X %02X %02X %d %d\n", *in, *feed, *post, fxtal, fwant);
281
        return fxtal * (*feed) / (*in) * ctl->den;
282
}
283
 
284
static unsigned int matroxfb_mavenclock(const struct matrox_pll_ctl* ctl,
285
                unsigned int htotal, unsigned int vtotal,
286
                unsigned int* in, unsigned int* feed, unsigned int* post,
287
                unsigned int* htotal2) {
288
        unsigned int fvco;
289
        unsigned int p;
290
 
291
        fvco = matroxfb_PLL_mavenclock(&maven1000_pll, ctl, htotal, vtotal, in, feed, &p, htotal2);
292
        if (!fvco)
293
                return -EINVAL;
294
        p = (1 << p) - 1;
295
        if (fvco <= 100000000)
296
                ;
297
        else if (fvco <= 140000000)
298
                p |= 0x08;
299
        else if (fvco <= 180000000)
300
                p |= 0x10;
301
        else
302
                p |= 0x18;
303
        *post = p;
304
        return 0;
305
}
306
 
307
static void DAC1064_calcclock(unsigned int freq, unsigned int fmax,
308
                unsigned int* in, unsigned int* feed, unsigned int* post) {
309
        unsigned int fvco;
310
        unsigned int p;
311
 
312
        fvco = matroxfb_PLL_calcclock(&maven_pll, freq, fmax, in, feed, &p);
313
        p = (1 << p) - 1;
314
        if (fvco <= 100000)
315
                ;
316
        else if (fvco <= 140000)
317
                p |= 0x08;
318
        else if (fvco <= 180000)
319
                p |= 0x10;
320
        else
321
                p |= 0x18;
322
        *post = p;
323
        return;
324
}
325
 
326
static unsigned char maven_compute_deflicker (const struct maven_data* md) {
327
        unsigned char df;
328
 
329
        df = (md->version == MGATVO_B?0x40:0x00);
330
        switch (md->primary_head->altout.tvo_params.deflicker) {
331
                case 0:
332
/*                      df |= 0x00; */
333
                        break;
334
                case 1:
335
                        df |= 0xB1;
336
                        break;
337
                case 2:
338
                        df |= 0xA2;
339
                        break;
340
        }
341
        return df;
342
}
343
 
344
static void maven_compute_bwlevel (const struct maven_data* md,
345
                                   int *bl, int *wl) {
346
        int b = md->primary_head->altout.tvo_params.brightness + BLMIN;
347
        int c = md->primary_head->altout.tvo_params.contrast;
348
 
349
        *bl = max(b - c, BLMIN);
350
        *wl = min(b + c, WLMAX);
351
}
352
 
353
static const struct maven_gamma* maven_compute_gamma (const struct maven_data* md) {
354
        return maven_gamma + md->primary_head->altout.tvo_params.gamma;
355
}
356
 
357
 
358
static void maven_init_TVdata(const struct maven_data* md, struct mavenregs* data) {
359
        static struct mavenregs palregs = { {
360
                0x2A, 0x09, 0x8A, 0xCB, /* 00: chroma subcarrier */
361
                0x00,
362
                0x00,   /* ? not written */
363
                0x00,   /* modified by code (F9 written...) */
364
                0x00,   /* ? not written */
365
                0x7E,   /* 08 */
366
                0x44,   /* 09 */
367
                0x9C,   /* 0A */
368
                0x2E,   /* 0B */
369
                0x21,   /* 0C */
370
                0x00,   /* ? not written */
371
                0x3F, 0x03, /* 0E-0F */
372
                0x3F, 0x03, /* 10-11 */
373
                0x1A,   /* 12 */
374
                0x2A,   /* 13 */
375
                0x1C, 0x3D, 0x14, /* 14-16 */
376
                0x9C, 0x01, /* 17-18 */
377
                0x00,   /* 19 */
378
                0xFE,   /* 1A */
379
                0x7E,   /* 1B */
380
                0x60,   /* 1C */
381
                0x05,   /* 1D */
382
                0x89, 0x03, /* 1E-1F */
383
                0x72,   /* 20 */
384
                0x07,   /* 21 */
385
                0x72,   /* 22 */
386
                0x00,   /* 23 */
387
                0x00,   /* 24 */
388
                0x00,   /* 25 */
389
                0x08,   /* 26 */
390
                0x04,   /* 27 */
391
                0x00,   /* 28 */
392
                0x1A,   /* 29 */
393
                0x55, 0x01, /* 2A-2B */
394
                0x26,   /* 2C */
395
                0x07, 0x7E, /* 2D-2E */
396
                0x02, 0x54, /* 2F-30 */
397
                0xB0, 0x00, /* 31-32 */
398
                0x14,   /* 33 */
399
                0x49,   /* 34 */
400
                0x00,   /* 35 written multiple times */
401
                0x00,   /* 36 not written */
402
                0xA3,   /* 37 */
403
                0xC8,   /* 38 */
404
                0x22,   /* 39 */
405
                0x02,   /* 3A */
406
                0x22,   /* 3B */
407
                0x3F, 0x03, /* 3C-3D */
408
                0x00,   /* 3E written multiple times */
409
                0x00,   /* 3F not written */
410
        }, MATROXFB_OUTPUT_MODE_PAL, 625, 50 };
411
        static struct mavenregs ntscregs = { {
412
                0x21, 0xF0, 0x7C, 0x1F, /* 00: chroma subcarrier */
413
                0x00,
414
                0x00,   /* ? not written */
415
                0x00,   /* modified by code (F9 written...) */
416
                0x00,   /* ? not written */
417
                0x7E,   /* 08 */
418
                0x43,   /* 09 */
419
                0x7E,   /* 0A */
420
                0x3D,   /* 0B */
421
                0x00,   /* 0C */
422
                0x00,   /* ? not written */
423
                0x41, 0x00, /* 0E-0F */
424
                0x3C, 0x00, /* 10-11 */
425
                0x17,   /* 12 */
426
                0x21,   /* 13 */
427
                0x1B, 0x1B, 0x24, /* 14-16 */
428
                0x83, 0x01, /* 17-18 */
429
                0x00,   /* 19 */
430
                0x0F,   /* 1A */
431
                0x0F,   /* 1B */
432
                0x60,   /* 1C */
433
                0x05,   /* 1D */
434
                0x89, 0x02, /* 1E-1F */
435
                0x5F,   /* 20 */
436
                0x04,   /* 21 */
437
                0x5F,   /* 22 */
438
                0x01,   /* 23 */
439
                0x02,   /* 24 */
440
                0x00,   /* 25 */
441
                0x0A,   /* 26 */
442
                0x05,   /* 27 */
443
                0x00,   /* 28 */
444
                0x10,   /* 29 */
445
                0xFF, 0x03, /* 2A-2B */
446
                0x24,   /* 2C */
447
                0x0F, 0x78, /* 2D-2E */
448
                0x00, 0x00, /* 2F-30 */
449
                0xB2, 0x04, /* 31-32 */
450
                0x14,   /* 33 */
451
                0x02,   /* 34 */
452
                0x00,   /* 35 written multiple times */
453
                0x00,   /* 36 not written */
454
                0xA3,   /* 37 */
455
                0xC8,   /* 38 */
456
                0x15,   /* 39 */
457
                0x05,   /* 3A */
458
                0x3B,   /* 3B */
459
                0x3C, 0x00, /* 3C-3D */
460
                0x00,   /* 3E written multiple times */
461
                0x00,   /* never written */
462
        }, MATROXFB_OUTPUT_MODE_NTSC, 525, 60 };
463
        MINFO_FROM(md->primary_head);
464
 
465
        if (ACCESS_FBINFO(outputs[1]).mode == MATROXFB_OUTPUT_MODE_PAL)
466
                *data = palregs;
467
        else
468
                *data = ntscregs;
469
 
470
        /* Set deflicker */
471
        data->regs[0x93] = maven_compute_deflicker(md);
472
 
473
        /* set gamma */
474
        {
475
                const struct maven_gamma* g;
476
                g = maven_compute_gamma(md);
477
                data->regs[0x83] = g->reg83;
478
                data->regs[0x84] = g->reg84;
479
                data->regs[0x85] = g->reg85;
480
                data->regs[0x86] = g->reg86;
481
                data->regs[0x87] = g->reg87;
482
                data->regs[0x88] = g->reg88;
483
                data->regs[0x89] = g->reg89;
484
                data->regs[0x8A] = g->reg8a;
485
                data->regs[0x8B] = g->reg8b;
486
        }
487
 
488
        /* Set contrast / brightness */
489
        {
490
                int bl, wl;
491
                maven_compute_bwlevel (md, &bl, &wl);
492
                data->regs[0x0e] = bl >> 2;
493
                data->regs[0x0f] = bl & 3;
494
                data->regs[0x1e] = wl >> 2;
495
                data->regs[0x1f] = wl & 3;
496
        }
497
 
498
        /* Set saturation */
499
        {
500
                data->regs[0x20] =
501
                data->regs[0x22] = ACCESS_FBINFO(altout.tvo_params.saturation);
502
        }
503
 
504
        /* Set HUE */
505
        data->regs[0x25] = ACCESS_FBINFO(altout.tvo_params.hue);
506
        return;
507
}
508
 
509
#define LR(x) maven_set_reg(c, (x), m->regs[(x)])
510
#define LRP(x) maven_set_reg_pair(c, (x), m->regs[(x)] | (m->regs[(x)+1] << 8))
511
static void maven_init_TV(struct i2c_client* c, const struct mavenregs* m) {
512
        int val;
513
 
514
 
515
        maven_set_reg(c, 0x3E, 0x01);
516
        maven_get_reg(c, 0x82); /* fetch oscillator state? */
517
        maven_set_reg(c, 0x8C, 0x00);
518
        maven_get_reg(c, 0x94); /* get 0x82 */
519
        maven_set_reg(c, 0x94, 0xA2);
520
        /* xmiscctrl */
521
 
522
        maven_set_reg_pair(c, 0x8E, 0x1EFF);
523
        maven_set_reg(c, 0xC6, 0x01);
524
 
525
        /* removed code... */
526
 
527
        maven_get_reg(c, 0x06);
528
        maven_set_reg(c, 0x06, 0xF9);   /* or read |= 0xF0 ? */
529
 
530
        /* removed code here... */
531
 
532
        /* real code begins here? */
533
        /* chroma subcarrier */
534
        LR(0x00); LR(0x01); LR(0x02); LR(0x03);
535
 
536
        LR(0x04);
537
 
538
        LR(0x2C);
539
        LR(0x08);
540
        LR(0x0A);
541
        LR(0x09);
542
        LR(0x29);
543
        LRP(0x31);
544
        LRP(0x17);
545
        LR(0x0B);
546
        LR(0x0C);
547
        if (m->mode == MATROXFB_OUTPUT_MODE_PAL) {
548
                maven_set_reg(c, 0x35, 0x10); /* ... */
549
        } else {
550
                maven_set_reg(c, 0x35, 0x0F); /* ... */
551
        }
552
 
553
        LRP(0x10);
554
 
555
        LRP(0x0E);
556
        LRP(0x1E);
557
 
558
        LR(0x20);       /* saturation #1 */
559
        LR(0x22);       /* saturation #2 */
560
        LR(0x25);       /* hue */
561
        LR(0x34);
562
        LR(0x33);
563
        LR(0x19);
564
        LR(0x12);
565
        LR(0x3B);
566
        LR(0x13);
567
        LR(0x39);
568
        LR(0x1D);
569
        LR(0x3A);
570
        LR(0x24);
571
        LR(0x14);
572
        LR(0x15);
573
        LR(0x16);
574
        LRP(0x2D);
575
        LRP(0x2F);
576
        LR(0x1A);
577
        LR(0x1B);
578
        LR(0x1C);
579
        LR(0x23);
580
        LR(0x26);
581
        LR(0x28);
582
        LR(0x27);
583
        LR(0x21);
584
        LRP(0x2A);
585
        if (m->mode == MATROXFB_OUTPUT_MODE_PAL)
586
                maven_set_reg(c, 0x35, 0x1D);   /* ... */
587
        else
588
                maven_set_reg(c, 0x35, 0x1C);
589
 
590
        LRP(0x3C);
591
        LR(0x37);
592
        LR(0x38);
593
        maven_set_reg(c, 0xB3, 0x01);
594
 
595
        maven_get_reg(c, 0xB0); /* read 0x80 */
596
        maven_set_reg(c, 0xB0, 0x08);   /* ugh... */
597
        maven_get_reg(c, 0xB9); /* read 0x7C */
598
        maven_set_reg(c, 0xB9, 0x78);
599
        maven_get_reg(c, 0xBF); /* read 0x00 */
600
        maven_set_reg(c, 0xBF, 0x02);
601
        maven_get_reg(c, 0x94); /* read 0x82 */
602
        maven_set_reg(c, 0x94, 0xB3);
603
 
604
        LR(0x80); /* 04 1A 91 or 05 21 91 */
605
        LR(0x81);
606
        LR(0x82);
607
 
608
        maven_set_reg(c, 0x8C, 0x20);
609
        maven_get_reg(c, 0x8D);
610
        maven_set_reg(c, 0x8D, 0x10);
611
 
612
        LR(0x90); /* 4D 50 52 or 4E 05 45 */
613
        LR(0x91);
614
        LR(0x92);
615
 
616
        LRP(0x9A); /* 0049 or 004F */
617
        LRP(0x9C); /* 0004 or 0004 */
618
        LRP(0x9E); /* 0458 or 045E */
619
        LRP(0xA0); /* 05DA or 051B */
620
        LRP(0xA2); /* 00CC or 00CF */
621
        LRP(0xA4); /* 007D or 007F */
622
        LRP(0xA6); /* 007C or 007E */
623
        LRP(0xA8); /* 03CB or 03CE */
624
        LRP(0x98); /* 0000 or 0000 */
625
        LRP(0xAE); /* 0044 or 003A */
626
        LRP(0x96); /* 05DA or 051B */
627
        LRP(0xAA); /* 04BC or 046A */
628
        LRP(0xAC); /* 004D or 004E */
629
 
630
        LR(0xBE);
631
        LR(0xC2);
632
 
633
        maven_get_reg(c, 0x8D);
634
        maven_set_reg(c, 0x8D, 0x04);
635
 
636
        LR(0x20);       /* saturation #1 */
637
        LR(0x22);       /* saturation #2 */
638
        LR(0x93);       /* whoops */
639
        LR(0x20);       /* oh, saturation #1 again */
640
        LR(0x22);       /* oh, saturation #2 again */
641
        LR(0x25);       /* hue */
642
        LRP(0x0E);
643
        LRP(0x1E);
644
        LRP(0x0E);      /* problems with memory? */
645
        LRP(0x1E);      /* yes, matrox must have problems in memory area... */
646
 
647
        /* load gamma correction stuff */
648
        LR(0x83);
649
        LR(0x84);
650
        LR(0x85);
651
        LR(0x86);
652
        LR(0x87);
653
        LR(0x88);
654
        LR(0x89);
655
        LR(0x8A);
656
        LR(0x8B);
657
 
658
        val = maven_get_reg(c, 0x8D);
659
        val &= 0x14;                    /* 0x10 or anything ored with it */
660
        maven_set_reg(c, 0x8D, val);
661
 
662
        LR(0x33);
663
        LR(0x19);
664
        LR(0x12);
665
        LR(0x3B);
666
        LR(0x13);
667
        LR(0x39);
668
        LR(0x1D);
669
        LR(0x3A);
670
        LR(0x24);
671
        LR(0x14);
672
        LR(0x15);
673
        LR(0x16);
674
        LRP(0x2D);
675
        LRP(0x2F);
676
        LR(0x1A);
677
        LR(0x1B);
678
        LR(0x1C);
679
        LR(0x23);
680
        LR(0x26);
681
        LR(0x28);
682
        LR(0x27);
683
        LR(0x21);
684
        LRP(0x2A);
685
        if (m->mode == MATROXFB_OUTPUT_MODE_PAL)
686
                maven_set_reg(c, 0x35, 0x1D);
687
        else
688
                maven_set_reg(c, 0x35, 0x1C);
689
        LRP(0x3C);
690
        LR(0x37);
691
        LR(0x38);
692
 
693
        maven_get_reg(c, 0xB0);
694
        LR(0xB0);       /* output mode */
695
        LR(0x90);
696
        LR(0xBE);
697
        LR(0xC2);
698
 
699
        LRP(0x9A);
700
        LRP(0xA2);
701
        LRP(0x9E);
702
        LRP(0xA6);
703
        LRP(0xAA);
704
        LRP(0xAC);
705
        maven_set_reg(c, 0x3E, 0x00);
706
        maven_set_reg(c, 0x95, 0x20);
707
}
708
 
709
static int maven_find_exact_clocks(unsigned int ht, unsigned int vt,
710
                struct mavenregs* m) {
711
        unsigned int x;
712
        unsigned int err = ~0;
713
 
714
        /* 1:1 */
715
        m->regs[0x80] = 0x0F;
716
        m->regs[0x81] = 0x07;
717
        m->regs[0x82] = 0x81;
718
 
719
        for (x = 0; x < 8; x++) {
720
                unsigned int a, b, c, 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 inline 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
                sprintf26(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 = MATROXFB_SRC_NONE;
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 unsigned short normal_i2c[] = { MAVEN_I2CID, I2C_CLIENT_END };
1235
static unsigned short normal_i2c_range[] = { MAVEN_I2CID, MAVEN_I2CID, I2C_CLIENT_END };
1236
I2C_CLIENT_INSMOD;
1237
 
1238
static struct i2c_driver maven_driver;
1239
 
1240
static int maven_detect_client(struct i2c_adapter* adapter, int address, int kind) {
1241
        int err = 0;
1242
        struct i2c_client* new_client;
1243
        struct maven_data* data;
1244
 
1245
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_WORD_DATA |
1246
                                              I2C_FUNC_SMBUS_BYTE_DATA |
1247
                                              I2C_FUNC_PROTOCOL_MANGLING))
1248
                goto ERROR0;
1249
        if (!(new_client = (struct i2c_client*)kmalloc(sizeof(*new_client) + sizeof(*data),
1250
                        GFP_KERNEL))) {
1251
                err = -ENOMEM;
1252
                goto ERROR0;
1253
        }
1254
        data = (struct maven_data*)(new_client + 1);
1255
        i2c_set_clientdata(new_client, data);
1256
        new_client->addr = address;
1257
        new_client->adapter = adapter;
1258
        new_client->driver = &maven_driver;
1259
        new_client->flags = 0;
1260
        strcpy(new_client->name, "maven client");
1261
        if ((err = i2c_attach_client(new_client)))
1262
                goto ERROR3;
1263
        err = maven_init_client(new_client);
1264
        if (err)
1265
                goto ERROR4;
1266
        return 0;
1267
ERROR4:;
1268
        i2c_detach_client(new_client);
1269
ERROR3:;
1270
        kfree(new_client);
1271
ERROR0:;
1272
        return err;
1273
}
1274
 
1275
static int maven_attach_adapter(struct i2c_adapter* adapter) {
1276
        if (adapter->id == (I2C_ALGO_BIT | I2C_HW_B_G400))
1277
                return i2c_probe(adapter, &addr_data, &maven_detect_client);
1278
        return 0;
1279
}
1280
 
1281
static int maven_detach_client(struct i2c_client* client) {
1282
        int err;
1283
 
1284
        if ((err = i2c_detach_client(client))) {
1285
                printk(KERN_ERR "maven: Cannot deregister client\n");
1286
                return err;
1287
        }
1288
        maven_shutdown_client(client);
1289
        kfree(client);
1290
        return 0;
1291
}
1292
 
1293
static int maven_command(struct i2c_client* client, unsigned int cmd, void* arg) {
1294
        return -ENOIOCTLCMD;    /* or -EINVAL, depends on who will call this */
1295
}
1296
 
1297
static struct i2c_driver maven_driver={
1298
        .owner          = THIS_MODULE,
1299
        .name           = "maven",
1300
        .id             = I2C_DRIVERID_MGATVO,
1301
        .flags          = I2C_DF_NOTIFY,
1302
        .attach_adapter = maven_attach_adapter,
1303
        .detach_client  = maven_detach_client,
1304
        .command        = maven_command,
1305
};
1306
 
1307
/* ************************** */
1308
 
1309
static int matroxfb_maven_init(void) {
1310
        int err;
1311
 
1312
        err = i2c_add_driver(&maven_driver);
1313
        if (err) {
1314
                printk(KERN_ERR "maven: Maven driver failed to register (%d).\n", err);
1315
                return err;
1316
        }
1317
        return 0;
1318
}
1319
 
1320
static void matroxfb_maven_exit(void) {
1321
        i2c_del_driver(&maven_driver);
1322
}
1323
 
1324
MODULE_AUTHOR("(c) 1999-2002 Petr Vandrovec <vandrove@vc.cvut.cz>");
1325
MODULE_DESCRIPTION("Matrox G200/G400 Matrox MGA-TVO driver");
1326
MODULE_LICENSE("GPL");
1327
module_init(matroxfb_maven_init);
1328
module_exit(matroxfb_maven_exit);
1329
/* we do not have __setup() yet */