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