?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / drivers / media / video / saa7114.c
blob122229e7b463154430cc07e37956c74b26d20b93
1 /*
2 * saa7114 - Philips SAA7114H video decoder driver version 0.0.1
3 *
4 * Copyright (C) 2002 Maxim Yevtyushkin <max@linuxmedialabs.com>
5 *
6 * Based on saa7111 driver by Dave Perks
7 *
8 * Copyright (C) 1998 Dave Perks <dperks@ibm.net>
9 *
10 * Slight changes for video timing and attachment output by
11 * Wolfgang Scherr <scherr@net4you.net>
12 *
13 * Changes by Ronald Bultje <rbultje@ronald.bitfreak.net>
14 * - moved over to linux>=2.4.x i2c protocol (1/1/2003)
15 *
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
20 *
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
25 *
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 */
30
31 #include <linux/module.h>
32 #include <linux/init.h>
33 #include <linux/delay.h>
34 #include <linux/errno.h>
35 #include <linux/fs.h>
36 #include <linux/kernel.h>
37 #include <linux/major.h>
38
39 #include <linux/slab.h>
40
41 #include <linux/mm.h>
42 #include <linux/pci.h>
43 #include <linux/signal.h>
44 #include <asm/io.h>
45 #include <asm/pgtable.h>
46 #include <asm/page.h>
47 #include <linux/sched.h>
48 #include <asm/segment.h>
49 #include <linux/types.h>
50
51 #include <linux/videodev.h>
52 #include <asm/uaccess.h>
53
54 MODULE_DESCRIPTION("Philips SAA7114H video decoder driver");
55 MODULE_AUTHOR("Maxim Yevtyushkin");
56 MODULE_LICENSE("GPL");
57
58 #include <linux/i2c.h>
59 #include <linux/i2c-dev.h>
60
61 #define I2C_NAME(x) (x)->name
62
63 #include <linux/video_decoder.h>
64
65 static int debug = 0;
66 MODULE_PARM(debug, "i");
67 MODULE_PARM_DESC(debug, "Debug level (0-1)");
68
69 #define dprintk(num, format, args...) \
70 do { \
71 if (debug >= num) \
72 printk(format, ##args); \
73 } while (0)
74
75 /* ----------------------------------------------------------------------- */
76
77 struct saa7114 {
78 unsigned char reg[0xf0 * 2];
79
80 int norm;
81 int input;
82 int enable;
83 int bright;
84 int contrast;
85 int hue;
86 int sat;
87 int playback;
88 };
89
90 #define I2C_SAA7114 0x42
91 #define I2C_SAA7114A 0x40
92
93 #define I2C_DELAY 10
94
95
96 //#define SAA_7114_NTSC_HSYNC_START (-3)
97 //#define SAA_7114_NTSC_HSYNC_STOP (-18)
98
99 #define SAA_7114_NTSC_HSYNC_START (-17)
100 #define SAA_7114_NTSC_HSYNC_STOP (-32)
101
102 //#define SAA_7114_NTSC_HOFFSET (5)
103 #define SAA_7114_NTSC_HOFFSET (6)
104 #define SAA_7114_NTSC_VOFFSET (10)
105 #define SAA_7114_NTSC_WIDTH (720)
106 #define SAA_7114_NTSC_HEIGHT (250)
107
108 #define SAA_7114_SECAM_HSYNC_START (-17)
109 #define SAA_7114_SECAM_HSYNC_STOP (-32)
110
111 #define SAA_7114_SECAM_HOFFSET (2)
112 #define SAA_7114_SECAM_VOFFSET (10)
113 #define SAA_7114_SECAM_WIDTH (720)
114 #define SAA_7114_SECAM_HEIGHT (300)
115
116 #define SAA_7114_PAL_HSYNC_START (-17)
117 #define SAA_7114_PAL_HSYNC_STOP (-32)
118
119 #define SAA_7114_PAL_HOFFSET (2)
120 #define SAA_7114_PAL_VOFFSET (10)
121 #define SAA_7114_PAL_WIDTH (720)
122 #define SAA_7114_PAL_HEIGHT (300)
123
124
125
126 #define SAA_7114_VERTICAL_CHROMA_OFFSET 0 //0x50504040
127 #define SAA_7114_VERTICAL_LUMA_OFFSET 0
128
129 #define REG_ADDR(x) (((x) << 1) + 1)
130 #define LOBYTE(x) ((unsigned char)((x) & 0xff))
131 #define HIBYTE(x) ((unsigned char)(((x) >> 8) & 0xff))
132 #define LOWORD(x) ((unsigned short int)((x) & 0xffff))
133 #define HIWORD(x) ((unsigned short int)(((x) >> 16) & 0xffff))
134
135
136 /* ----------------------------------------------------------------------- */
137
138 static inline int
139 saa7114_write (struct i2c_client *client,
140 u8 reg,
141 u8 value)
142 {
143 /*struct saa7114 *decoder = i2c_get_clientdata(client);*/
144
145 /*decoder->reg[reg] = value;*/
146 return i2c_smbus_write_byte_data(client, reg, value);
147 }
148
149 static int
150 saa7114_write_block (struct i2c_client *client,
151 const u8 *data,
152 unsigned int len)
153 {
154 int ret = -1;
155 u8 reg;
156
157 /* the saa7114 has an autoincrement function, use it if
158 * the adapter understands raw I2C */
159 if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
160 /* do raw I2C, not smbus compatible */
161 /*struct saa7114 *decoder = i2c_get_clientdata(client);*/
162 struct i2c_msg msg;
163 u8 block_data[32];
164
165 msg.addr = client->addr;
166 msg.flags = client->flags;
167 while (len >= 2) {
168 msg.buf = (char *) block_data;
169 msg.len = 0;
170 block_data[msg.len++] = reg = data[0];
171 do {
172 block_data[msg.len++] =
173 /*decoder->reg[reg++] =*/ data[1];
174 len -= 2;
175 data += 2;
176 } while (len >= 2 && data[0] == reg &&
177 msg.len < 32);
178 if ((ret = i2c_transfer(client->adapter,
179 &msg, 1)) < 0)
180 break;
181 }
182 } else {
183 /* do some slow I2C emulation kind of thing */
184 while (len >= 2) {
185 reg = *data++;
186 if ((ret = saa7114_write(client, reg,
187 *data++)) < 0)
188 break;
189 len -= 2;
190 }
191 }
192
193 return ret;
194 }
195
196 static inline int
197 saa7114_read (struct i2c_client *client,
198 u8 reg)
199 {
200 return i2c_smbus_read_byte_data(client, reg);
201 }
202
203 /* ----------------------------------------------------------------------- */
204
205 // initially set NTSC, composite
206
207
208 static const unsigned char init[] = {
209 0x00, 0x00, /* 00 - ID byte , chip version,
210 * read only */
211 0x01, 0x08, /* 01 - X,X,X,X, IDEL3 to IDEL0 -
212 * horizontal increment delay,
213 * recommended position */
214 0x02, 0x00, /* 02 - FUSE=3, GUDL=2, MODE=0 ;
215 * input control */
216 0x03, 0x10, /* 03 - HLNRS=0, VBSL=1, WPOFF=0,
217 * HOLDG=0, GAFIX=0, GAI1=256, GAI2=256 */
218 0x04, 0x90, /* 04 - GAI1=256 */
219 0x05, 0x90, /* 05 - GAI2=256 */
220 0x06, SAA_7114_NTSC_HSYNC_START, /* 06 - HSB: hsync start,
221 * depends on the video standard */
222 0x07, SAA_7114_NTSC_HSYNC_STOP, /* 07 - HSS: hsync stop, depends
223 *on the video standard */
224 0x08, 0xb8, /* 08 - AUFD=1, FSEL=1, EXFIL=0, VTRC=1,
225 * HPLL: free running in playback, locked
226 * in capture, VNOI=0 */
227 0x09, 0x80, /* 09 - BYPS=0, PREF=0, BPSS=0, VBLB=0,
228 * UPTCV=0, APER=1; depends from input */
229 0x0a, 0x80, /* 0a - BRIG=128 */
230 0x0b, 0x44, /* 0b - CONT=1.109 */
231 0x0c, 0x40, /* 0c - SATN=1.0 */
232 0x0d, 0x00, /* 0d - HUE=0 */
233 0x0e, 0x84, /* 0e - CDTO, CSTD2 to 0, DCVF, FCTC,
234 * CCOMB; depends from video standard */
235 0x0f, 0x24, /* 0f - ACGC,CGAIN6 to CGAIN0; depends
236 * from video standard */
237 0x10, 0x03, /* 10 - OFFU1 to 0, OFFV1 to 0, CHBW,
238 * LCBW2 to 0 */
239 0x11, 0x59, /* 11 - COLO, RTP1, HEDL1 to 0, RTP0,
240 * YDEL2 to 0 */
241 0x12, 0xc9, /* 12 - RT signal control RTSE13 to 10
242 * and 03 to 00 */
243 0x13, 0x80, /* 13 - RT/X port output control */
244 0x14, 0x00, /* 14 - analog, ADC, compatibility control */
245 0x15, 0x00, /* 15 - VGATE start FID change */
246 0x16, 0xfe, /* 16 - VGATE stop */
247 0x17, 0x00, /* 17 - Misc., VGATE MSBs */
248 0x18, 0x40, /* RAWG */
249 0x19, 0x80, /* RAWO */
250 0x1a, 0x00,
251 0x1b, 0x00,
252 0x1c, 0x00,
253 0x1d, 0x00,
254 0x1e, 0x00,
255 0x1f, 0x00, /* status byte, read only */
256 0x20, 0x00, /* video decoder reserved part */
257 0x21, 0x00,
258 0x22, 0x00,
259 0x23, 0x00,
260 0x24, 0x00,
261 0x25, 0x00,
262 0x26, 0x00,
263 0x27, 0x00,
264 0x28, 0x00,
265 0x29, 0x00,
266 0x2a, 0x00,
267 0x2b, 0x00,
268 0x2c, 0x00,
269 0x2d, 0x00,
270 0x2e, 0x00,
271 0x2f, 0x00,
272 0x30, 0xbc, /* audio clock generator */
273 0x31, 0xdf,
274 0x32, 0x02,
275 0x33, 0x00,
276 0x34, 0xcd,
277 0x35, 0xcc,
278 0x36, 0x3a,
279 0x37, 0x00,
280 0x38, 0x03,
281 0x39, 0x10,
282 0x3a, 0x00,
283 0x3b, 0x00,
284 0x3c, 0x00,
285 0x3d, 0x00,
286 0x3e, 0x00,
287 0x3f, 0x00,
288 0x40, 0x00, /* VBI data slicer */
289 0x41, 0xff,
290 0x42, 0xff,
291 0x43, 0xff,
292 0x44, 0xff,
293 0x45, 0xff,
294 0x46, 0xff,
295 0x47, 0xff,
296 0x48, 0xff,
297 0x49, 0xff,
298 0x4a, 0xff,
299 0x4b, 0xff,
300 0x4c, 0xff,
301 0x4d, 0xff,
302 0x4e, 0xff,
303 0x4f, 0xff,
304 0x50, 0xff,
305 0x51, 0xff,
306 0x52, 0xff,
307 0x53, 0xff,
308 0x54, 0xff,
309 0x55, 0xff,
310 0x56, 0xff,
311 0x57, 0xff,
312 0x58, 0x40, // framing code
313 0x59, 0x47, // horizontal offset
314 0x5a, 0x06, // vertical offset
315 0x5b, 0x83, // field offset
316 0x5c, 0x00, // reserved
317 0x5d, 0x3e, // header and data
318 0x5e, 0x00, // sliced data
319 0x5f, 0x00, // reserved
320 0x60, 0x00, /* video decoder reserved part */
321 0x61, 0x00,
322 0x62, 0x00,
323 0x63, 0x00,
324 0x64, 0x00,
325 0x65, 0x00,
326 0x66, 0x00,
327 0x67, 0x00,
328 0x68, 0x00,
329 0x69, 0x00,
330 0x6a, 0x00,
331 0x6b, 0x00,
332 0x6c, 0x00,
333 0x6d, 0x00,
334 0x6e, 0x00,
335 0x6f, 0x00,
336 0x70, 0x00, /* video decoder reserved part */
337 0x71, 0x00,
338 0x72, 0x00,
339 0x73, 0x00,
340 0x74, 0x00,
341 0x75, 0x00,
342 0x76, 0x00,
343 0x77, 0x00,
344 0x78, 0x00,
345 0x79, 0x00,
346 0x7a, 0x00,
347 0x7b, 0x00,
348 0x7c, 0x00,
349 0x7d, 0x00,
350 0x7e, 0x00,
351 0x7f, 0x00,
352 0x80, 0x00, /* X-port, I-port and scaler */
353 0x81, 0x00,
354 0x82, 0x00,
355 0x83, 0x00,
356 0x84, 0xc5,
357 0x85, 0x0d, // hsync and vsync ?
358 0x86, 0x40,
359 0x87, 0x01,
360 0x88, 0x00,
361 0x89, 0x00,
362 0x8a, 0x00,
363 0x8b, 0x00,
364 0x8c, 0x00,
365 0x8d, 0x00,
366 0x8e, 0x00,
367 0x8f, 0x00,
368 0x90, 0x03, /* Task A definition */
369 0x91, 0x08,
370 0x92, 0x00,
371 0x93, 0x40,
372 0x94, 0x00, // window settings
373 0x95, 0x00,
374 0x96, 0x00,
375 0x97, 0x00,
376 0x98, 0x00,
377 0x99, 0x00,
378 0x9a, 0x00,
379 0x9b, 0x00,
380 0x9c, 0x00,
381 0x9d, 0x00,
382 0x9e, 0x00,
383 0x9f, 0x00,
384 0xa0, 0x01, /* horizontal integer prescaling ratio */
385 0xa1, 0x00, /* horizontal prescaler accumulation
386 * sequence length */
387 0xa2, 0x00, /* UV FIR filter, Y FIR filter, prescaler
388 * DC gain */
389 0xa3, 0x00,
390 0xa4, 0x80, // luminance brightness
391 0xa5, 0x40, // luminance gain
392 0xa6, 0x40, // chrominance saturation
393 0xa7, 0x00,
394 0xa8, 0x00, // horizontal luminance scaling increment
395 0xa9, 0x04,
396 0xaa, 0x00, // horizontal luminance phase offset
397 0xab, 0x00,
398 0xac, 0x00, // horizontal chrominance scaling increment
399 0xad, 0x02,
400 0xae, 0x00, // horizontal chrominance phase offset
401 0xaf, 0x00,
402 0xb0, 0x00, // vertical luminance scaling increment
403 0xb1, 0x04,
404 0xb2, 0x00, // vertical chrominance scaling increment
405 0xb3, 0x04,
406 0xb4, 0x00,
407 0xb5, 0x00,
408 0xb6, 0x00,
409 0xb7, 0x00,
410 0xb8, 0x00,
411 0xb9, 0x00,
412 0xba, 0x00,
413 0xbb, 0x00,
414 0xbc, 0x00,
415 0xbd, 0x00,
416 0xbe, 0x00,
417 0xbf, 0x00,
418 0xc0, 0x02, // Task B definition
419 0xc1, 0x08,
420 0xc2, 0x00,
421 0xc3, 0x40,
422 0xc4, 0x00, // window settings
423 0xc5, 0x00,
424 0xc6, 0x00,
425 0xc7, 0x00,
426 0xc8, 0x00,
427 0xc9, 0x00,
428 0xca, 0x00,
429 0xcb, 0x00,
430 0xcc, 0x00,
431 0xcd, 0x00,
432 0xce, 0x00,
433 0xcf, 0x00,
434 0xd0, 0x01, // horizontal integer prescaling ratio
435 0xd1, 0x00, // horizontal prescaler accumulation sequence length
436 0xd2, 0x00, // UV FIR filter, Y FIR filter, prescaler DC gain
437 0xd3, 0x00,
438 0xd4, 0x80, // luminance brightness
439 0xd5, 0x40, // luminance gain
440 0xd6, 0x40, // chrominance saturation
441 0xd7, 0x00,
442 0xd8, 0x00, // horizontal luminance scaling increment
443 0xd9, 0x04,
444 0xda, 0x00, // horizontal luminance phase offset
445 0xdb, 0x00,
446 0xdc, 0x00, // horizontal chrominance scaling increment
447 0xdd, 0x02,
448 0xde, 0x00, // horizontal chrominance phase offset
449 0xdf, 0x00,
450 0xe0, 0x00, // vertical luminance scaling increment
451 0xe1, 0x04,
452 0xe2, 0x00, // vertical chrominance scaling increment
453 0xe3, 0x04,
454 0xe4, 0x00,
455 0xe5, 0x00,
456 0xe6, 0x00,
457 0xe7, 0x00,
458 0xe8, 0x00,
459 0xe9, 0x00,
460 0xea, 0x00,
461 0xeb, 0x00,
462 0xec, 0x00,
463 0xed, 0x00,
464 0xee, 0x00,
465 0xef, 0x00
466 };
467
468 static int
469 saa7114_command (struct i2c_client *client,
470 unsigned int cmd,
471 void *arg)
472 {
473 struct saa7114 *decoder = i2c_get_clientdata(client);
474
475 switch (cmd) {
476
477 case 0:
478 //dprintk(1, KERN_INFO "%s: writing init\n", I2C_NAME(client));
479 //saa7114_write_block(client, init, sizeof(init));
480 break;
481
482 case DECODER_DUMP:
483 {
484 int i;
485
486 dprintk(1, KERN_INFO "%s: decoder dump\n", I2C_NAME(client));
487
488 for (i = 0; i < 32; i += 16) {
489 int j;
490
491 printk(KERN_DEBUG "%s: %03x", I2C_NAME(client), i);
492 for (j = 0; j < 16; ++j) {
493 printk(" %02x",
494 saa7114_read(client, i + j));
495 }
496 printk("\n");
497 }
498 }
499 break;
500
501 case DECODER_GET_CAPABILITIES:
502 {
503 struct video_decoder_capability *cap = arg;
504
505 dprintk(1, KERN_DEBUG "%s: decoder get capabilities\n",
506 I2C_NAME(client));
507
508 cap->flags = VIDEO_DECODER_PAL |
509 VIDEO_DECODER_NTSC |
510 VIDEO_DECODER_AUTO |
511 VIDEO_DECODER_CCIR;
512 cap->inputs = 8;
513 cap->outputs = 1;
514 }
515 break;
516
517 case DECODER_GET_STATUS:
518 {
519 int *iarg = arg;
520 int status;
521 int res;
522
523 status = saa7114_read(client, 0x1f);
524
525 dprintk(1, KERN_DEBUG "%s status: 0x%02x\n", I2C_NAME(client),
526 status);
527 res = 0;
528 if ((status & (1 << 6)) == 0) {
529 res |= DECODER_STATUS_GOOD;
530 }
531 switch (decoder->norm) {
532 case VIDEO_MODE_NTSC:
533 res |= DECODER_STATUS_NTSC;
534 break;
535 case VIDEO_MODE_PAL:
536 res |= DECODER_STATUS_PAL;
537 break;
538 case VIDEO_MODE_SECAM:
539 res |= DECODER_STATUS_SECAM;
540 break;
541 default:
542 case VIDEO_MODE_AUTO:
543 if ((status & (1 << 5)) != 0) {
544 res |= DECODER_STATUS_NTSC;
545 } else {
546 res |= DECODER_STATUS_PAL;
547 }
548 break;
549 }
550 if ((status & (1 << 0)) != 0) {
551 res |= DECODER_STATUS_COLOR;
552 }
553 *iarg = res;
554 }
555 break;
556
557 case DECODER_SET_NORM:
558 {
559 int *iarg = arg;
560
561 short int hoff = 0, voff = 0, w = 0, h = 0;
562
563 dprintk(1, KERN_DEBUG "%s: decoder set norm ",
564 I2C_NAME(client));
565 switch (*iarg) {
566
567 case VIDEO_MODE_NTSC:
568 dprintk(1, "NTSC\n");
569 decoder->reg[REG_ADDR(0x06)] =
570 SAA_7114_NTSC_HSYNC_START;
571 decoder->reg[REG_ADDR(0x07)] =
572 SAA_7114_NTSC_HSYNC_STOP;
573
574 decoder->reg[REG_ADDR(0x08)] = decoder->playback ? 0x7c : 0xb8; // PLL free when playback, PLL close when capture
575
576 decoder->reg[REG_ADDR(0x0e)] = 0x85;
577 decoder->reg[REG_ADDR(0x0f)] = 0x24;
578
579 hoff = SAA_7114_NTSC_HOFFSET;
580 voff = SAA_7114_NTSC_VOFFSET;
581 w = SAA_7114_NTSC_WIDTH;
582 h = SAA_7114_NTSC_HEIGHT;
583
584 break;
585
586 case VIDEO_MODE_PAL:
587 dprintk(1, "PAL\n");
588 decoder->reg[REG_ADDR(0x06)] =
589 SAA_7114_PAL_HSYNC_START;
590 decoder->reg[REG_ADDR(0x07)] =
591 SAA_7114_PAL_HSYNC_STOP;
592
593 decoder->reg[REG_ADDR(0x08)] = decoder->playback ? 0x7c : 0xb8; // PLL free when playback, PLL close when capture
594
595 decoder->reg[REG_ADDR(0x0e)] = 0x81;
596 decoder->reg[REG_ADDR(0x0f)] = 0x24;
597
598 hoff = SAA_7114_PAL_HOFFSET;
599 voff = SAA_7114_PAL_VOFFSET;
600 w = SAA_7114_PAL_WIDTH;
601 h = SAA_7114_PAL_HEIGHT;
602
603 break;
604
605 default:
606 dprintk(1, " Unknown video mode!!!\n");
607 return -EINVAL;
608
609 }
610
611
612 decoder->reg[REG_ADDR(0x94)] = LOBYTE(hoff); // hoffset low
613 decoder->reg[REG_ADDR(0x95)] = HIBYTE(hoff) & 0x0f; // hoffset high
614 decoder->reg[REG_ADDR(0x96)] = LOBYTE(w); // width low
615 decoder->reg[REG_ADDR(0x97)] = HIBYTE(w) & 0x0f; // width high
616 decoder->reg[REG_ADDR(0x98)] = LOBYTE(voff); // voffset low
617 decoder->reg[REG_ADDR(0x99)] = HIBYTE(voff) & 0x0f; // voffset high
618 decoder->reg[REG_ADDR(0x9a)] = LOBYTE(h + 2); // height low
619 decoder->reg[REG_ADDR(0x9b)] = HIBYTE(h + 2) & 0x0f; // height high
620 decoder->reg[REG_ADDR(0x9c)] = LOBYTE(w); // out width low
621 decoder->reg[REG_ADDR(0x9d)] = HIBYTE(w) & 0x0f; // out width high
622 decoder->reg[REG_ADDR(0x9e)] = LOBYTE(h); // out height low
623 decoder->reg[REG_ADDR(0x9f)] = HIBYTE(h) & 0x0f; // out height high
624
625 decoder->reg[REG_ADDR(0xc4)] = LOBYTE(hoff); // hoffset low
626 decoder->reg[REG_ADDR(0xc5)] = HIBYTE(hoff) & 0x0f; // hoffset high
627 decoder->reg[REG_ADDR(0xc6)] = LOBYTE(w); // width low
628 decoder->reg[REG_ADDR(0xc7)] = HIBYTE(w) & 0x0f; // width high
629 decoder->reg[REG_ADDR(0xc8)] = LOBYTE(voff); // voffset low
630 decoder->reg[REG_ADDR(0xc9)] = HIBYTE(voff) & 0x0f; // voffset high
631 decoder->reg[REG_ADDR(0xca)] = LOBYTE(h + 2); // height low
632 decoder->reg[REG_ADDR(0xcb)] = HIBYTE(h + 2) & 0x0f; // height high
633 decoder->reg[REG_ADDR(0xcc)] = LOBYTE(w); // out width low
634 decoder->reg[REG_ADDR(0xcd)] = HIBYTE(w) & 0x0f; // out width high
635 decoder->reg[REG_ADDR(0xce)] = LOBYTE(h); // out height low
636 decoder->reg[REG_ADDR(0xcf)] = HIBYTE(h) & 0x0f; // out height high
637
638
639 saa7114_write(client, 0x80, 0x06); // i-port and scaler back end clock selection, task A&B off
640 saa7114_write(client, 0x88, 0xd8); // sw reset scaler
641 saa7114_write(client, 0x88, 0xf8); // sw reset scaler release
642
643 saa7114_write_block(client, decoder->reg + (0x06 << 1),
644 3 << 1);
645 saa7114_write_block(client, decoder->reg + (0x0e << 1),
646 2 << 1);
647 saa7114_write_block(client, decoder->reg + (0x5a << 1),
648 2 << 1);
649
650 saa7114_write_block(client, decoder->reg + (0x94 << 1),
651 (0x9f + 1 - 0x94) << 1);
652 saa7114_write_block(client, decoder->reg + (0xc4 << 1),
653 (0xcf + 1 - 0xc4) << 1);
654
655 saa7114_write(client, 0x88, 0xd8); // sw reset scaler
656 saa7114_write(client, 0x88, 0xf8); // sw reset scaler release
657 saa7114_write(client, 0x80, 0x36); // i-port and scaler back end clock selection
658
659 decoder->norm = *iarg;
660 }
661 break;
662
663 case DECODER_SET_INPUT:
664 {
665 int *iarg = arg;
666
667 dprintk(1, KERN_DEBUG "%s: decoder set input (%d)\n",
668 I2C_NAME(client), *iarg);
669 if (*iarg < 0 || *iarg > 7) {
670 return -EINVAL;
671 }
672
673 if (decoder->input != *iarg) {
674 dprintk(1, KERN_DEBUG "%s: now setting %s input\n",
675 I2C_NAME(client),
676 *iarg >= 6 ? "S-Video" : "Composite");
677 decoder->input = *iarg;
678
679 /* select mode */
680 decoder->reg[REG_ADDR(0x02)] =
681 (decoder->
682 reg[REG_ADDR(0x02)] & 0xf0) | (decoder->
683 input <
684 6 ? 0x0 : 0x9);
685 saa7114_write(client, 0x02,
686 decoder->reg[REG_ADDR(0x02)]);
687
688 /* bypass chrominance trap for modes 6..9 */
689 decoder->reg[REG_ADDR(0x09)] =
690 (decoder->
691 reg[REG_ADDR(0x09)] & 0x7f) | (decoder->
692 input <
693 6 ? 0x0 :
694 0x80);
695 saa7114_write(client, 0x09,
696 decoder->reg[REG_ADDR(0x09)]);
697
698 decoder->reg[REG_ADDR(0x0e)] =
699 decoder->input <
700 6 ? decoder->
701 reg[REG_ADDR(0x0e)] | 1 : decoder->
702 reg[REG_ADDR(0x0e)] & ~1;
703 saa7114_write(client, 0x0e,
704 decoder->reg[REG_ADDR(0x0e)]);
705 }
706 }
707 break;
708
709 case DECODER_SET_OUTPUT:
710 {
711 int *iarg = arg;
712
713 dprintk(1, KERN_DEBUG "%s: decoder set output\n",
714 I2C_NAME(client));
715
716 /* not much choice of outputs */
717 if (*iarg != 0) {
718 return -EINVAL;
719 }
720 }
721 break;
722
723 case DECODER_ENABLE_OUTPUT:
724 {
725 int *iarg = arg;
726 int enable = (*iarg != 0);
727
728 dprintk(1, KERN_DEBUG "%s: decoder %s output\n",
729 I2C_NAME(client), enable ? "enable" : "disable");
730
731 decoder->playback = !enable;
732
733 if (decoder->enable != enable) {
734 decoder->enable = enable;
735
736 /* RJ: If output should be disabled (for
737 * playing videos), we also need a open PLL.
738 * The input is set to 0 (where no input
739 * source is connected), although this
740 * is not necessary.
741 *
742 * If output should be enabled, we have to
743 * reverse the above.
744 */
745
746 if (decoder->enable) {
747 decoder->reg[REG_ADDR(0x08)] = 0xb8;
748 decoder->reg[REG_ADDR(0x12)] = 0xc9;
749 decoder->reg[REG_ADDR(0x13)] = 0x80;
750 decoder->reg[REG_ADDR(0x87)] = 0x01;
751 } else {
752 decoder->reg[REG_ADDR(0x08)] = 0x7c;
753 decoder->reg[REG_ADDR(0x12)] = 0x00;
754 decoder->reg[REG_ADDR(0x13)] = 0x00;
755 decoder->reg[REG_ADDR(0x87)] = 0x00;
756 }
757
758 saa7114_write_block(client,
759 decoder->reg + (0x12 << 1),
760 2 << 1);
761 saa7114_write(client, 0x08,
762 decoder->reg[REG_ADDR(0x08)]);
763 saa7114_write(client, 0x87,
764 decoder->reg[REG_ADDR(0x87)]);
765 saa7114_write(client, 0x88, 0xd8); // sw reset scaler
766 saa7114_write(client, 0x88, 0xf8); // sw reset scaler release
767 saa7114_write(client, 0x80, 0x36);
768
769 }
770 }
771 break;
772
773 case DECODER_SET_PICTURE:
774 {
775 struct video_picture *pic = arg;
776
777 dprintk(1,
778 KERN_DEBUG
779 "%s: decoder set picture bright=%d contrast=%d saturation=%d hue=%d\n",
780 I2C_NAME(client), pic->brightness, pic->contrast,
781 pic->colour, pic->hue);
782
783 if (decoder->bright != pic->brightness) {
784 /* We want 0 to 255 we get 0-65535 */
785 decoder->bright = pic->brightness;
786 saa7114_write(client, 0x0a, decoder->bright >> 8);
787 }
788 if (decoder->contrast != pic->contrast) {
789 /* We want 0 to 127 we get 0-65535 */
790 decoder->contrast = pic->contrast;
791 saa7114_write(client, 0x0b,
792 decoder->contrast >> 9);
793 }
794 if (decoder->sat != pic->colour) {
795 /* We want 0 to 127 we get 0-65535 */
796 decoder->sat = pic->colour;
797 saa7114_write(client, 0x0c, decoder->sat >> 9);
798 }
799 if (decoder->hue != pic->hue) {
800 /* We want -128 to 127 we get 0-65535 */
801 decoder->hue = pic->hue;
802 saa7114_write(client, 0x0d,
803 (decoder->hue - 32768) >> 8);
804 }
805 }
806 break;
807
808 default:
809 return -EINVAL;
810 }
811
812 return 0;
813 }
814
815 /* ----------------------------------------------------------------------- */
816
817 /*
818 * Generic i2c probe
819 * concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
820 */
821 static unsigned short normal_i2c[] =
822 { I2C_SAA7114 >> 1, I2C_SAA7114A >> 1, I2C_CLIENT_END };
823 static unsigned short normal_i2c_range[] = { I2C_CLIENT_END };
824
825 static unsigned short probe[2] = { I2C_CLIENT_END, I2C_CLIENT_END };
826 static unsigned short probe_range[2] = { I2C_CLIENT_END, I2C_CLIENT_END };
827 static unsigned short ignore[2] = { I2C_CLIENT_END, I2C_CLIENT_END };
828 static unsigned short ignore_range[2] = { I2C_CLIENT_END, I2C_CLIENT_END };
829 static unsigned short force[2] = { I2C_CLIENT_END , I2C_CLIENT_END };
830
831 static struct i2c_client_address_data addr_data = {
832 .normal_i2c = normal_i2c,
833 .normal_i2c_range = normal_i2c_range,
834 .probe = probe,
835 .probe_range = probe_range,
836 .ignore = ignore,
837 .ignore_range = ignore_range,
838 .force = force
839 };
840
841 static int saa7114_i2c_id = 0;
842 static struct i2c_driver i2c_driver_saa7114;
843
844 static int
845 saa7114_detect_client (struct i2c_adapter *adapter,
846 int address,
847 int kind)
848 {
849 int i, err[30];
850 short int hoff = SAA_7114_NTSC_HOFFSET;
851 short int voff = SAA_7114_NTSC_VOFFSET;
852 short int w = SAA_7114_NTSC_WIDTH;
853 short int h = SAA_7114_NTSC_HEIGHT;
854 struct i2c_client *client;
855 struct saa7114 *decoder;
856
857 dprintk(1,
858 KERN_INFO
859 "saa7114.c: detecting saa7114 client on address 0x%x\n",
860 address << 1);
861
862 /* Check if the adapter supports the needed features */
863 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
864 return 0;
865
866 client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
867 if (client == 0)
868 return -ENOMEM;
869 memset(client, 0, sizeof(struct i2c_client));
870 client->addr = address;
871 client->adapter = adapter;
872 client->driver = &i2c_driver_saa7114;
873 client->flags = I2C_CLIENT_ALLOW_USE;
874 client->id = saa7114_i2c_id++;
875 snprintf(I2C_NAME(client), sizeof(I2C_NAME(client)) - 1,
876 "saa7114[%d]", client->id);
877
878 decoder = kmalloc(sizeof(struct saa7114), GFP_KERNEL);
879 if (decoder == NULL) {
880 kfree(client);
881 return -ENOMEM;
882 }
883 memset(decoder, 0, sizeof(struct saa7114));
884 decoder->norm = VIDEO_MODE_NTSC;
885 decoder->input = -1;
886 decoder->enable = 1;
887 decoder->bright = 32768;
888 decoder->contrast = 32768;
889 decoder->hue = 32768;
890 decoder->sat = 32768;
891 decoder->playback = 0; // initially capture mode useda
892 i2c_set_clientdata(client, decoder);
893
894 memcpy(decoder->reg, init, sizeof(init));
895
896 decoder->reg[REG_ADDR(0x94)] = LOBYTE(hoff); // hoffset low
897 decoder->reg[REG_ADDR(0x95)] = HIBYTE(hoff) & 0x0f; // hoffset high
898 decoder->reg[REG_ADDR(0x96)] = LOBYTE(w); // width low
899 decoder->reg[REG_ADDR(0x97)] = HIBYTE(w) & 0x0f; // width high
900 decoder->reg[REG_ADDR(0x98)] = LOBYTE(voff); // voffset low
901 decoder->reg[REG_ADDR(0x99)] = HIBYTE(voff) & 0x0f; // voffset high
902 decoder->reg[REG_ADDR(0x9a)] = LOBYTE(h + 2); // height low
903 decoder->reg[REG_ADDR(0x9b)] = HIBYTE(h + 2) & 0x0f; // height high
904 decoder->reg[REG_ADDR(0x9c)] = LOBYTE(w); // out width low
905 decoder->reg[REG_ADDR(0x9d)] = HIBYTE(w) & 0x0f; // out width high
906 decoder->reg[REG_ADDR(0x9e)] = LOBYTE(h); // out height low
907 decoder->reg[REG_ADDR(0x9f)] = HIBYTE(h) & 0x0f; // out height high
908
909 decoder->reg[REG_ADDR(0xc4)] = LOBYTE(hoff); // hoffset low
910 decoder->reg[REG_ADDR(0xc5)] = HIBYTE(hoff) & 0x0f; // hoffset high
911 decoder->reg[REG_ADDR(0xc6)] = LOBYTE(w); // width low
912 decoder->reg[REG_ADDR(0xc7)] = HIBYTE(w) & 0x0f; // width high
913 decoder->reg[REG_ADDR(0xc8)] = LOBYTE(voff); // voffset low
914 decoder->reg[REG_ADDR(0xc9)] = HIBYTE(voff) & 0x0f; // voffset high
915 decoder->reg[REG_ADDR(0xca)] = LOBYTE(h + 2); // height low
916 decoder->reg[REG_ADDR(0xcb)] = HIBYTE(h + 2) & 0x0f; // height high
917 decoder->reg[REG_ADDR(0xcc)] = LOBYTE(w); // out width low
918 decoder->reg[REG_ADDR(0xcd)] = HIBYTE(w) & 0x0f; // out width high
919 decoder->reg[REG_ADDR(0xce)] = LOBYTE(h); // out height low
920 decoder->reg[REG_ADDR(0xcf)] = HIBYTE(h) & 0x0f; // out height high
921
922 decoder->reg[REG_ADDR(0xb8)] =
923 LOBYTE(LOWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
924 decoder->reg[REG_ADDR(0xb9)] =
925 HIBYTE(LOWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
926 decoder->reg[REG_ADDR(0xba)] =
927 LOBYTE(HIWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
928 decoder->reg[REG_ADDR(0xbb)] =
929 HIBYTE(HIWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
930
931 decoder->reg[REG_ADDR(0xbc)] =
932 LOBYTE(LOWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
933 decoder->reg[REG_ADDR(0xbd)] =
934 HIBYTE(LOWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
935 decoder->reg[REG_ADDR(0xbe)] =
936 LOBYTE(HIWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
937 decoder->reg[REG_ADDR(0xbf)] =
938 HIBYTE(HIWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
939
940 decoder->reg[REG_ADDR(0xe8)] =
941 LOBYTE(LOWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
942 decoder->reg[REG_ADDR(0xe9)] =
943 HIBYTE(LOWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
944 decoder->reg[REG_ADDR(0xea)] =
945 LOBYTE(HIWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
946 decoder->reg[REG_ADDR(0xeb)] =
947 HIBYTE(HIWORD(SAA_7114_VERTICAL_CHROMA_OFFSET));
948
949 decoder->reg[REG_ADDR(0xec)] =
950 LOBYTE(LOWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
951 decoder->reg[REG_ADDR(0xed)] =
952 HIBYTE(LOWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
953 decoder->reg[REG_ADDR(0xee)] =
954 LOBYTE(HIWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
955 decoder->reg[REG_ADDR(0xef)] =
956 HIBYTE(HIWORD(SAA_7114_VERTICAL_LUMA_OFFSET));
957
958
959 decoder->reg[REG_ADDR(0x13)] = 0x80; // RTC0 on
960 decoder->reg[REG_ADDR(0x87)] = 0x01; // I-Port
961 decoder->reg[REG_ADDR(0x12)] = 0xc9; // RTS0
962
963 decoder->reg[REG_ADDR(0x02)] = 0xc0; // set composite1 input, aveasy
964 decoder->reg[REG_ADDR(0x09)] = 0x00; // chrominance trap
965 decoder->reg[REG_ADDR(0x0e)] |= 1; // combfilter on
966
967
968 dprintk(1, KERN_DEBUG "%s_attach: starting decoder init\n",
969 I2C_NAME(client));
970
971 err[0] =
972 saa7114_write_block(client, decoder->reg + (0x20 << 1),
973 0x10 << 1);
974 err[1] =
975 saa7114_write_block(client, decoder->reg + (0x30 << 1),
976 0x10 << 1);
977 err[2] =
978 saa7114_write_block(client, decoder->reg + (0x63 << 1),
979 (0x7f + 1 - 0x63) << 1);
980 err[3] =
981 saa7114_write_block(client, decoder->reg + (0x89 << 1),
982 6 << 1);
983 err[4] =
984 saa7114_write_block(client, decoder->reg + (0xb8 << 1),
985 8 << 1);
986 err[5] =
987 saa7114_write_block(client, decoder->reg + (0xe8 << 1),
988 8 << 1);
989
990
991 for (i = 0; i <= 5; i++) {
992 if (err[i] < 0) {
993 dprintk(1,
994 KERN_ERR
995 "%s_attach: init error %d at stage %d, leaving attach.\n",
996 I2C_NAME(client), i, err[i]);
997 kfree(decoder);
998 kfree(client);
999 return 0;
1000 }
1001 }
1002
1003 for (i = 6; i < 8; i++) {
1004 dprintk(1,
1005 KERN_DEBUG
1006 "%s_attach: reg[0x%02x] = 0x%02x (0x%02x)\n",
1007 I2C_NAME(client), i, saa7114_read(client, i),
1008 decoder->reg[REG_ADDR(i)]);
1009 }
1010
1011 dprintk(1,
1012 KERN_DEBUG
1013 "%s_attach: performing decoder reset sequence\n",
1014 I2C_NAME(client));
1015
1016 err[6] = saa7114_write(client, 0x80, 0x06); // i-port and scaler backend clock selection, task A&B off
1017 err[7] = saa7114_write(client, 0x88, 0xd8); // sw reset scaler
1018 err[8] = saa7114_write(client, 0x88, 0xf8); // sw reset scaler release
1019
1020 for (i = 6; i <= 8; i++) {
1021 if (err[i] < 0) {
1022 dprintk(1,
1023 KERN_ERR
1024 "%s_attach: init error %d at stage %d, leaving attach.\n",
1025 I2C_NAME(client), i, err[i]);
1026 kfree(decoder);
1027 kfree(client);
1028 return 0;
1029 }
1030 }
1031
1032 dprintk(1, KERN_INFO "%s_attach: performing the rest of init\n",
1033 I2C_NAME(client));
1034
1035
1036 err[9] = saa7114_write(client, 0x01, decoder->reg[REG_ADDR(0x01)]);
1037 err[10] = saa7114_write_block(client, decoder->reg + (0x03 << 1), (0x1e + 1 - 0x03) << 1); // big seq
1038 err[11] = saa7114_write_block(client, decoder->reg + (0x40 << 1), (0x5f + 1 - 0x40) << 1); // slicer
1039 err[12] = saa7114_write_block(client, decoder->reg + (0x81 << 1), 2 << 1); // ?
1040 err[13] = saa7114_write_block(client, decoder->reg + (0x83 << 1), 5 << 1); // ?
1041 err[14] = saa7114_write_block(client, decoder->reg + (0x90 << 1), 4 << 1); // Task A
1042 err[15] =
1043 saa7114_write_block(client, decoder->reg + (0x94 << 1),
1044 12 << 1);
1045 err[16] =
1046 saa7114_write_block(client, decoder->reg + (0xa0 << 1),
1047 8 << 1);
1048 err[17] =
1049 saa7114_write_block(client, decoder->reg + (0xa8 << 1),
1050 8 << 1);
1051 err[18] =
1052 saa7114_write_block(client, decoder->reg + (0xb0 << 1),
1053 8 << 1);
1054 err[19] = saa7114_write_block(client, decoder->reg + (0xc0 << 1), 4 << 1); // Task B
1055 err[15] =
1056 saa7114_write_block(client, decoder->reg + (0xc4 << 1),
1057 12 << 1);
1058 err[16] =
1059 saa7114_write_block(client, decoder->reg + (0xd0 << 1),
1060 8 << 1);
1061 err[17] =
1062 saa7114_write_block(client, decoder->reg + (0xd8 << 1),
1063 8 << 1);
1064 err[18] =
1065 saa7114_write_block(client, decoder->reg + (0xe0 << 1),
1066 8 << 1);
1067
1068 for (i = 9; i <= 18; i++) {
1069 if (err[i] < 0) {
1070 dprintk(1,
1071 KERN_ERR
1072 "%s_attach: init error %d at stage %d, leaving attach.\n",
1073 I2C_NAME(client), i, err[i]);
1074 kfree(decoder);
1075 kfree(client);
1076 return 0;
1077 }
1078 }
1079
1080
1081 for (i = 6; i < 8; i++) {
1082 dprintk(1,
1083 KERN_DEBUG
1084 "%s_attach: reg[0x%02x] = 0x%02x (0x%02x)\n",
1085 I2C_NAME(client), i, saa7114_read(client, i),
1086 decoder->reg[REG_ADDR(i)]);
1087 }
1088
1089
1090 for (i = 0x11; i <= 0x13; i++) {
1091 dprintk(1,
1092 KERN_DEBUG
1093 "%s_attach: reg[0x%02x] = 0x%02x (0x%02x)\n",
1094 I2C_NAME(client), i, saa7114_read(client, i),
1095 decoder->reg[REG_ADDR(i)]);
1096 }
1097
1098
1099 dprintk(1, KERN_DEBUG "%s_attach: setting video input\n",
1100 I2C_NAME(client));
1101
1102 err[19] =
1103 saa7114_write(client, 0x02, decoder->reg[REG_ADDR(0x02)]);
1104 err[20] =
1105 saa7114_write(client, 0x09, decoder->reg[REG_ADDR(0x09)]);
1106 err[21] =
1107 saa7114_write(client, 0x0e, decoder->reg[REG_ADDR(0x0e)]);
1108
1109 for (i = 19; i <= 21; i++) {
1110 if (err[i] < 0) {
1111 dprintk(1,
1112 KERN_ERR
1113 "%s_attach: init error %d at stage %d, leaving attach.\n",
1114 I2C_NAME(client), i, err[i]);
1115 kfree(decoder);
1116 kfree(client);
1117 return 0;
1118 }
1119 }
1120
1121 dprintk(1,
1122 KERN_DEBUG
1123 "%s_attach: performing decoder reset sequence\n",
1124 I2C_NAME(client));
1125
1126 err[22] = saa7114_write(client, 0x88, 0xd8); // sw reset scaler
1127 err[23] = saa7114_write(client, 0x88, 0xf8); // sw reset scaler release
1128 err[24] = saa7114_write(client, 0x80, 0x36); // i-port and scaler backend clock selection, task A&B off
1129
1130
1131 for (i = 22; i <= 24; i++) {
1132 if (err[i] < 0) {
1133 dprintk(1,
1134 KERN_ERR
1135 "%s_attach: init error %d at stage %d, leaving attach.\n",
1136 I2C_NAME(client), i, err[i]);
1137 kfree(decoder);
1138 kfree(client);
1139 return 0;
1140 }
1141 }
1142
1143 err[25] = saa7114_write(client, 0x06, init[REG_ADDR(0x06)]);
1144 err[26] = saa7114_write(client, 0x07, init[REG_ADDR(0x07)]);
1145 err[27] = saa7114_write(client, 0x10, init[REG_ADDR(0x10)]);
1146
1147 dprintk(1,
1148 KERN_INFO
1149 "%s_attach: chip version %x, decoder status 0x%02x\n",
1150 I2C_NAME(client), saa7114_read(client, 0x00) >> 4,
1151 saa7114_read(client, 0x1f));
1152 dprintk(1,
1153 KERN_DEBUG
1154 "%s_attach: power save control: 0x%02x, scaler status: 0x%02x\n",
1155 I2C_NAME(client), saa7114_read(client, 0x88),
1156 saa7114_read(client, 0x8f));
1157
1158
1159 for (i = 0x94; i < 0x96; i++) {
1160 dprintk(1,
1161 KERN_DEBUG
1162 "%s_attach: reg[0x%02x] = 0x%02x (0x%02x)\n",
1163 I2C_NAME(client), i, saa7114_read(client, i),
1164 decoder->reg[REG_ADDR(i)]);
1165 }
1166
1167 i = i2c_attach_client(client);
1168 if (i) {
1169 kfree(client);
1170 kfree(decoder);
1171 return i;
1172 }
1173
1174 //i = saa7114_write_block(client, init, sizeof(init));
1175 i = 0;
1176 if (i < 0) {
1177 dprintk(1, KERN_ERR "%s_attach error: init status %d\n",
1178 I2C_NAME(client), i);
1179 } else {
1180 dprintk(1,
1181 KERN_INFO
1182 "%s_attach: chip version %x at address 0x%x\n",
1183 I2C_NAME(client), saa7114_read(client, 0x00) >> 4,
1184 client->addr << 1);
1185 }
1186
1187 return 0;
1188 }
1189
1190 static int
1191 saa7114_attach_adapter (struct i2c_adapter *adapter)
1192 {
1193 dprintk(1,
1194 KERN_INFO
1195 "saa7114.c: starting probe for adapter %s (0x%x)\n",
1196 I2C_NAME(adapter), adapter->id);
1197 return i2c_probe(adapter, &addr_data, &saa7114_detect_client);
1198 }
1199
1200 static int
1201 saa7114_detach_client (struct i2c_client *client)
1202 {
1203 struct saa7114 *decoder = i2c_get_clientdata(client);
1204 int err;
1205
1206 err = i2c_detach_client(client);
1207 if (err) {
1208 return err;
1209 }
1210
1211 kfree(decoder);
1212 kfree(client);
1213
1214 return 0;
1215 }
1216
1217 /* ----------------------------------------------------------------------- */
1218
1219 static struct i2c_driver i2c_driver_saa7114 = {
1220 .owner = THIS_MODULE,
1221 .name = "saa7114",
1222
1223 .id = I2C_DRIVERID_SAA7114,
1224 .flags = I2C_DF_NOTIFY,
1225
1226 .attach_adapter = saa7114_attach_adapter,
1227 .detach_client = saa7114_detach_client,
1228 .command = saa7114_command,
1229 };
1230
1231 static int __init
1232 saa7114_init (void)
1233 {
1234 return i2c_add_driver(&i2c_driver_saa7114);
1235 }
1236
1237 static void __exit
1238 saa7114_exit (void)
1239 {
1240 i2c_del_driver(&i2c_driver_saa7114);
1241 }
1242
1243 module_init(saa7114_init);
1244 module_exit(saa7114_exit);
MOXA 2.6.9 from sdlinux-moxaart.tgz