tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * saa7191.c - Philips SAA7191 video decoder driver
3 *
4 * Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
5 * Copyright (C) 2004,2005 Mikael Nousiainen <tmnousia@cc.hut.fi>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12#include <linux/delay.h>
13#include <linux/errno.h>
14#include <linux/fs.h>
15#include <linux/init.h>
16#include <linux/kernel.h>
17#include <linux/major.h>
18#include <linux/module.h>
19#include <linux/mm.h>
20#include <linux/slab.h>
21
22#include <linux/videodev2.h>
23#include <linux/i2c.h>
24#include <media/v4l2-device.h>
25
26#include "saa7191.h"
27
28#define SAA7191_MODULE_VERSION "0.0.5"
29
30MODULE_DESCRIPTION("Philips SAA7191 video decoder driver");
31MODULE_VERSION(SAA7191_MODULE_VERSION);
32MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
33MODULE_LICENSE("GPL");
34
35
36// #define SAA7191_DEBUG
37
38#ifdef SAA7191_DEBUG
39#define dprintk(x...) printk("SAA7191: " x);
40#else
41#define dprintk(x...)
42#endif
43
44#define SAA7191_SYNC_COUNT 30
45#define SAA7191_SYNC_DELAY 100 /* milliseconds */
46
47struct saa7191 {
48 struct v4l2_subdev sd;
49
50 /* the register values are stored here as the actual
51 * I2C-registers are write-only */
52 u8 reg[25];
53
54 int input;
55 v4l2_std_id norm;
56};
57
58static inline struct saa7191 *to_saa7191(struct v4l2_subdev *sd)
59{
60 return container_of(sd, struct saa7191, sd);
61}
62
63static const u8 initseq[] = {
64 0, /* Subaddress */
65
66 0x50, /* (0x50) SAA7191_REG_IDEL */
67
68 /* 50 Hz signal timing */
69 0x30, /* (0x30) SAA7191_REG_HSYB */
70 0x00, /* (0x00) SAA7191_REG_HSYS */
71 0xe8, /* (0xe8) SAA7191_REG_HCLB */
72 0xb6, /* (0xb6) SAA7191_REG_HCLS */
73 0xf4, /* (0xf4) SAA7191_REG_HPHI */
74
75 /* control */
76 SAA7191_LUMA_APER_1, /* (0x01) SAA7191_REG_LUMA - CVBS mode */
77 0x00, /* (0x00) SAA7191_REG_HUEC */
78 0xf8, /* (0xf8) SAA7191_REG_CKTQ */
79 0xf8, /* (0xf8) SAA7191_REG_CKTS */
80 0x90, /* (0x90) SAA7191_REG_PLSE */
81 0x90, /* (0x90) SAA7191_REG_SESE */
82 0x00, /* (0x00) SAA7191_REG_GAIN */
83 SAA7191_STDC_NFEN | SAA7191_STDC_HRMV, /* (0x0c) SAA7191_REG_STDC
84 * - not SECAM,
85 * slow time constant */
86 SAA7191_IOCK_OEDC | SAA7191_IOCK_OEHS | SAA7191_IOCK_OEVS
87 | SAA7191_IOCK_OEDY, /* (0x78) SAA7191_REG_IOCK
88 * - chroma from CVBS, GPSW1 & 2 off */
89 SAA7191_CTL3_AUFD | SAA7191_CTL3_SCEN | SAA7191_CTL3_OFTS
90 | SAA7191_CTL3_YDEL0, /* (0x99) SAA7191_REG_CTL3
91 * - automatic field detection */
92 0x00, /* (0x00) SAA7191_REG_CTL4 */
93 0x2c, /* (0x2c) SAA7191_REG_CHCV - PAL nominal value */
94 0x00, /* unused */
95 0x00, /* unused */
96
97 /* 60 Hz signal timing */
98 0x34, /* (0x34) SAA7191_REG_HS6B */
99 0x0a, /* (0x0a) SAA7191_REG_HS6S */
100 0xf4, /* (0xf4) SAA7191_REG_HC6B */
101 0xce, /* (0xce) SAA7191_REG_HC6S */
102 0xf4, /* (0xf4) SAA7191_REG_HP6I */
103};
104
105/* SAA7191 register handling */
106
107static u8 saa7191_read_reg(struct v4l2_subdev *sd, u8 reg)
108{
109 return to_saa7191(sd)->reg[reg];
110}
111
112static int saa7191_read_status(struct v4l2_subdev *sd, u8 *value)
113{
114 struct i2c_client *client = v4l2_get_subdevdata(sd);
115 int ret;
116
117 ret = i2c_master_recv(client, value, 1);
118 if (ret < 0) {
119 printk(KERN_ERR "SAA7191: saa7191_read_status(): read failed\n");
120 return ret;
121 }
122
123 return 0;
124}
125
126
127static int saa7191_write_reg(struct v4l2_subdev *sd, u8 reg, u8 value)
128{
129 struct i2c_client *client = v4l2_get_subdevdata(sd);
130
131 to_saa7191(sd)->reg[reg] = value;
132 return i2c_smbus_write_byte_data(client, reg, value);
133}
134
135/* the first byte of data must be the first subaddress number (register) */
136static int saa7191_write_block(struct v4l2_subdev *sd,
137 u8 length, const u8 *data)
138{
139 struct i2c_client *client = v4l2_get_subdevdata(sd);
140 struct saa7191 *decoder = to_saa7191(sd);
141 int i;
142 int ret;
143
144 for (i = 0; i < (length - 1); i++) {
145 decoder->reg[data[0] + i] = data[i + 1];
146 }
147
148 ret = i2c_master_send(client, data, length);
149 if (ret < 0) {
150 printk(KERN_ERR "SAA7191: saa7191_write_block(): "
151 "write failed\n");
152 return ret;
153 }
154
155 return 0;
156}
157
158/* Helper functions */
159
160static int saa7191_s_routing(struct v4l2_subdev *sd,
161 u32 input, u32 output, u32 config)
162{
163 struct saa7191 *decoder = to_saa7191(sd);
164 u8 luma = saa7191_read_reg(sd, SAA7191_REG_LUMA);
165 u8 iock = saa7191_read_reg(sd, SAA7191_REG_IOCK);
166 int err;
167
168 switch (input) {
169 case SAA7191_INPUT_COMPOSITE: /* Set Composite input */
170 iock &= ~(SAA7191_IOCK_CHRS | SAA7191_IOCK_GPSW1
171 | SAA7191_IOCK_GPSW2);
172 /* Chrominance trap active */
173 luma &= ~SAA7191_LUMA_BYPS;
174 break;
175 case SAA7191_INPUT_SVIDEO: /* Set S-Video input */
176 iock |= SAA7191_IOCK_CHRS | SAA7191_IOCK_GPSW2;
177 /* Chrominance trap bypassed */
178 luma |= SAA7191_LUMA_BYPS;
179 break;
180 default:
181 return -EINVAL;
182 }
183
184 err = saa7191_write_reg(sd, SAA7191_REG_LUMA, luma);
185 if (err)
186 return -EIO;
187 err = saa7191_write_reg(sd, SAA7191_REG_IOCK, iock);
188 if (err)
189 return -EIO;
190
191 decoder->input = input;
192
193 return 0;
194}
195
196static int saa7191_s_std(struct v4l2_subdev *sd, v4l2_std_id norm)
197{
198 struct saa7191 *decoder = to_saa7191(sd);
199 u8 stdc = saa7191_read_reg(sd, SAA7191_REG_STDC);
200 u8 ctl3 = saa7191_read_reg(sd, SAA7191_REG_CTL3);
201 u8 chcv = saa7191_read_reg(sd, SAA7191_REG_CHCV);
202 int err;
203
204 if (norm & V4L2_STD_PAL) {
205 stdc &= ~SAA7191_STDC_SECS;
206 ctl3 &= ~(SAA7191_CTL3_AUFD | SAA7191_CTL3_FSEL);
207 chcv = SAA7191_CHCV_PAL;
208 } else if (norm & V4L2_STD_NTSC) {
209 stdc &= ~SAA7191_STDC_SECS;
210 ctl3 &= ~SAA7191_CTL3_AUFD;
211 ctl3 |= SAA7191_CTL3_FSEL;
212 chcv = SAA7191_CHCV_NTSC;
213 } else if (norm & V4L2_STD_SECAM) {
214 stdc |= SAA7191_STDC_SECS;
215 ctl3 &= ~(SAA7191_CTL3_AUFD | SAA7191_CTL3_FSEL);
216 chcv = SAA7191_CHCV_PAL;
217 } else {
218 return -EINVAL;
219 }
220
221 err = saa7191_write_reg(sd, SAA7191_REG_CTL3, ctl3);
222 if (err)
223 return -EIO;
224 err = saa7191_write_reg(sd, SAA7191_REG_STDC, stdc);
225 if (err)
226 return -EIO;
227 err = saa7191_write_reg(sd, SAA7191_REG_CHCV, chcv);
228 if (err)
229 return -EIO;
230
231 decoder->norm = norm;
232
233 dprintk("ctl3: %02x stdc: %02x chcv: %02x\n", ctl3,
234 stdc, chcv);
235 dprintk("norm: %llx\n", norm);
236
237 return 0;
238}
239
240static int saa7191_wait_for_signal(struct v4l2_subdev *sd, u8 *status)
241{
242 int i = 0;
243
244 dprintk("Checking for signal...\n");
245
246 for (i = 0; i < SAA7191_SYNC_COUNT; i++) {
247 if (saa7191_read_status(sd, status))
248 return -EIO;
249
250 if (((*status) & SAA7191_STATUS_HLCK) == 0) {
251 dprintk("Signal found\n");
252 return 0;
253 }
254
255 msleep(SAA7191_SYNC_DELAY);
256 }
257
258 dprintk("No signal\n");
259
260 return -EBUSY;
261}
262
263static int saa7191_querystd(struct v4l2_subdev *sd, v4l2_std_id *norm)
264{
265 struct saa7191 *decoder = to_saa7191(sd);
266 u8 stdc = saa7191_read_reg(sd, SAA7191_REG_STDC);
267 u8 ctl3 = saa7191_read_reg(sd, SAA7191_REG_CTL3);
268 u8 status;
269 v4l2_std_id old_norm = decoder->norm;
270 int err = 0;
271
272 dprintk("SAA7191 extended signal auto-detection...\n");
273
274 *norm &= V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM;
275 stdc &= ~SAA7191_STDC_SECS;
276 ctl3 &= ~(SAA7191_CTL3_FSEL);
277
278 err = saa7191_write_reg(sd, SAA7191_REG_STDC, stdc);
279 if (err) {
280 err = -EIO;
281 goto out;
282 }
283 err = saa7191_write_reg(sd, SAA7191_REG_CTL3, ctl3);
284 if (err) {
285 err = -EIO;
286 goto out;
287 }
288
289 ctl3 |= SAA7191_CTL3_AUFD;
290 err = saa7191_write_reg(sd, SAA7191_REG_CTL3, ctl3);
291 if (err) {
292 err = -EIO;
293 goto out;
294 }
295
296 msleep(SAA7191_SYNC_DELAY);
297
298 err = saa7191_wait_for_signal(sd, &status);
299 if (err)
300 goto out;
301
302 if (status & SAA7191_STATUS_FIDT) {
303 /* 60Hz signal -> NTSC */
304 dprintk("60Hz signal: NTSC\n");
305 *norm &= V4L2_STD_NTSC;
306 return 0;
307 }
308
309 /* 50Hz signal */
310 dprintk("50Hz signal: Trying PAL...\n");
311
312 /* try PAL first */
313 err = saa7191_s_std(sd, V4L2_STD_PAL);
314 if (err)
315 goto out;
316
317 msleep(SAA7191_SYNC_DELAY);
318
319 err = saa7191_wait_for_signal(sd, &status);
320 if (err)
321 goto out;
322
323 /* not 50Hz ? */
324 if (status & SAA7191_STATUS_FIDT) {
325 dprintk("No 50Hz signal\n");
326 saa7191_s_std(sd, old_norm);
327 *norm = V4L2_STD_UNKNOWN;
328 return 0;
329 }
330
331 if (status & SAA7191_STATUS_CODE) {
332 dprintk("PAL\n");
333 *norm &= V4L2_STD_PAL;
334 return saa7191_s_std(sd, old_norm);
335 }
336
337 dprintk("No color detected with PAL - Trying SECAM...\n");
338
339 /* no color detected ? -> try SECAM */
340 err = saa7191_s_std(sd, V4L2_STD_SECAM);
341 if (err)
342 goto out;
343
344 msleep(SAA7191_SYNC_DELAY);
345
346 err = saa7191_wait_for_signal(sd, &status);
347 if (err)
348 goto out;
349
350 /* not 50Hz ? */
351 if (status & SAA7191_STATUS_FIDT) {
352 dprintk("No 50Hz signal\n");
353 *norm = V4L2_STD_UNKNOWN;
354 goto out;
355 }
356
357 if (status & SAA7191_STATUS_CODE) {
358 /* Color detected -> SECAM */
359 dprintk("SECAM\n");
360 *norm &= V4L2_STD_SECAM;
361 return saa7191_s_std(sd, old_norm);
362 }
363
364 dprintk("No color detected with SECAM - Going back to PAL.\n");
365 *norm = V4L2_STD_UNKNOWN;
366
367out:
368 return saa7191_s_std(sd, old_norm);
369}
370
371static int saa7191_autodetect_norm(struct v4l2_subdev *sd)
372{
373 u8 status;
374
375 dprintk("SAA7191 signal auto-detection...\n");
376
377 dprintk("Reading status...\n");
378
379 if (saa7191_read_status(sd, &status))
380 return -EIO;
381
382 dprintk("Checking for signal...\n");
383
384 /* no signal ? */
385 if (status & SAA7191_STATUS_HLCK) {
386 dprintk("No signal\n");
387 return -EBUSY;
388 }
389
390 dprintk("Signal found\n");
391
392 if (status & SAA7191_STATUS_FIDT) {
393 /* 60hz signal -> NTSC */
394 dprintk("NTSC\n");
395 return saa7191_s_std(sd, V4L2_STD_NTSC);
396 } else {
397 /* 50hz signal -> PAL */
398 dprintk("PAL\n");
399 return saa7191_s_std(sd, V4L2_STD_PAL);
400 }
401}
402
403static int saa7191_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
404{
405 u8 reg;
406 int ret = 0;
407
408 switch (ctrl->id) {
409 case SAA7191_CONTROL_BANDPASS:
410 case SAA7191_CONTROL_BANDPASS_WEIGHT:
411 case SAA7191_CONTROL_CORING:
412 reg = saa7191_read_reg(sd, SAA7191_REG_LUMA);
413 switch (ctrl->id) {
414 case SAA7191_CONTROL_BANDPASS:
415 ctrl->value = ((s32)reg & SAA7191_LUMA_BPSS_MASK)
416 >> SAA7191_LUMA_BPSS_SHIFT;
417 break;
418 case SAA7191_CONTROL_BANDPASS_WEIGHT:
419 ctrl->value = ((s32)reg & SAA7191_LUMA_APER_MASK)
420 >> SAA7191_LUMA_APER_SHIFT;
421 break;
422 case SAA7191_CONTROL_CORING:
423 ctrl->value = ((s32)reg & SAA7191_LUMA_CORI_MASK)
424 >> SAA7191_LUMA_CORI_SHIFT;
425 break;
426 }
427 break;
428 case SAA7191_CONTROL_FORCE_COLOUR:
429 case SAA7191_CONTROL_CHROMA_GAIN:
430 reg = saa7191_read_reg(sd, SAA7191_REG_GAIN);
431 if (ctrl->id == SAA7191_CONTROL_FORCE_COLOUR)
432 ctrl->value = ((s32)reg & SAA7191_GAIN_COLO) ? 1 : 0;
433 else
434 ctrl->value = ((s32)reg & SAA7191_GAIN_LFIS_MASK)
435 >> SAA7191_GAIN_LFIS_SHIFT;
436 break;
437 case V4L2_CID_HUE:
438 reg = saa7191_read_reg(sd, SAA7191_REG_HUEC);
439 if (reg < 0x80)
440 reg += 0x80;
441 else
442 reg -= 0x80;
443 ctrl->value = (s32)reg;
444 break;
445 case SAA7191_CONTROL_VTRC:
446 reg = saa7191_read_reg(sd, SAA7191_REG_STDC);
447 ctrl->value = ((s32)reg & SAA7191_STDC_VTRC) ? 1 : 0;
448 break;
449 case SAA7191_CONTROL_LUMA_DELAY:
450 reg = saa7191_read_reg(sd, SAA7191_REG_CTL3);
451 ctrl->value = ((s32)reg & SAA7191_CTL3_YDEL_MASK)
452 >> SAA7191_CTL3_YDEL_SHIFT;
453 if (ctrl->value >= 4)
454 ctrl->value -= 8;
455 break;
456 case SAA7191_CONTROL_VNR:
457 reg = saa7191_read_reg(sd, SAA7191_REG_CTL4);
458 ctrl->value = ((s32)reg & SAA7191_CTL4_VNOI_MASK)
459 >> SAA7191_CTL4_VNOI_SHIFT;
460 break;
461 default:
462 ret = -EINVAL;
463 }
464
465 return ret;
466}
467
468static int saa7191_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
469{
470 u8 reg;
471 int ret = 0;
472
473 switch (ctrl->id) {
474 case SAA7191_CONTROL_BANDPASS:
475 case SAA7191_CONTROL_BANDPASS_WEIGHT:
476 case SAA7191_CONTROL_CORING:
477 reg = saa7191_read_reg(sd, SAA7191_REG_LUMA);
478 switch (ctrl->id) {
479 case SAA7191_CONTROL_BANDPASS:
480 reg &= ~SAA7191_LUMA_BPSS_MASK;
481 reg |= (ctrl->value << SAA7191_LUMA_BPSS_SHIFT)
482 & SAA7191_LUMA_BPSS_MASK;
483 break;
484 case SAA7191_CONTROL_BANDPASS_WEIGHT:
485 reg &= ~SAA7191_LUMA_APER_MASK;
486 reg |= (ctrl->value << SAA7191_LUMA_APER_SHIFT)
487 & SAA7191_LUMA_APER_MASK;
488 break;
489 case SAA7191_CONTROL_CORING:
490 reg &= ~SAA7191_LUMA_CORI_MASK;
491 reg |= (ctrl->value << SAA7191_LUMA_CORI_SHIFT)
492 & SAA7191_LUMA_CORI_MASK;
493 break;
494 }
495 ret = saa7191_write_reg(sd, SAA7191_REG_LUMA, reg);
496 break;
497 case SAA7191_CONTROL_FORCE_COLOUR:
498 case SAA7191_CONTROL_CHROMA_GAIN:
499 reg = saa7191_read_reg(sd, SAA7191_REG_GAIN);
500 if (ctrl->id == SAA7191_CONTROL_FORCE_COLOUR) {
501 if (ctrl->value)
502 reg |= SAA7191_GAIN_COLO;
503 else
504 reg &= ~SAA7191_GAIN_COLO;
505 } else {
506 reg &= ~SAA7191_GAIN_LFIS_MASK;
507 reg |= (ctrl->value << SAA7191_GAIN_LFIS_SHIFT)
508 & SAA7191_GAIN_LFIS_MASK;
509 }
510 ret = saa7191_write_reg(sd, SAA7191_REG_GAIN, reg);
511 break;
512 case V4L2_CID_HUE:
513 reg = ctrl->value & 0xff;
514 if (reg < 0x80)
515 reg += 0x80;
516 else
517 reg -= 0x80;
518 ret = saa7191_write_reg(sd, SAA7191_REG_HUEC, reg);
519 break;
520 case SAA7191_CONTROL_VTRC:
521 reg = saa7191_read_reg(sd, SAA7191_REG_STDC);
522 if (ctrl->value)
523 reg |= SAA7191_STDC_VTRC;
524 else
525 reg &= ~SAA7191_STDC_VTRC;
526 ret = saa7191_write_reg(sd, SAA7191_REG_STDC, reg);
527 break;
528 case SAA7191_CONTROL_LUMA_DELAY: {
529 s32 value = ctrl->value;
530 if (value < 0)
531 value += 8;
532 reg = saa7191_read_reg(sd, SAA7191_REG_CTL3);
533 reg &= ~SAA7191_CTL3_YDEL_MASK;
534 reg |= (value << SAA7191_CTL3_YDEL_SHIFT)
535 & SAA7191_CTL3_YDEL_MASK;
536 ret = saa7191_write_reg(sd, SAA7191_REG_CTL3, reg);
537 break;
538 }
539 case SAA7191_CONTROL_VNR:
540 reg = saa7191_read_reg(sd, SAA7191_REG_CTL4);
541 reg &= ~SAA7191_CTL4_VNOI_MASK;
542 reg |= (ctrl->value << SAA7191_CTL4_VNOI_SHIFT)
543 & SAA7191_CTL4_VNOI_MASK;
544 ret = saa7191_write_reg(sd, SAA7191_REG_CTL4, reg);
545 break;
546 default:
547 ret = -EINVAL;
548 }
549
550 return ret;
551}
552
553/* I2C-interface */
554
555static int saa7191_g_input_status(struct v4l2_subdev *sd, u32 *status)
556{
557 u8 status_reg;
558 int res = V4L2_IN_ST_NO_SIGNAL;
559
560 if (saa7191_read_status(sd, &status_reg))
561 return -EIO;
562 if ((status_reg & SAA7191_STATUS_HLCK) == 0)
563 res = 0;
564 if (!(status_reg & SAA7191_STATUS_CODE))
565 res |= V4L2_IN_ST_NO_COLOR;
566 *status = res;
567 return 0;
568}
569
570
571/* ----------------------------------------------------------------------- */
572
573static const struct v4l2_subdev_core_ops saa7191_core_ops = {
574 .g_ctrl = saa7191_g_ctrl,
575 .s_ctrl = saa7191_s_ctrl,
576 .s_std = saa7191_s_std,
577};
578
579static const struct v4l2_subdev_video_ops saa7191_video_ops = {
580 .s_routing = saa7191_s_routing,
581 .querystd = saa7191_querystd,
582 .g_input_status = saa7191_g_input_status,
583};
584
585static const struct v4l2_subdev_ops saa7191_ops = {
586 .core = &saa7191_core_ops,
587 .video = &saa7191_video_ops,
588};
589
590static int saa7191_probe(struct i2c_client *client,
591 const struct i2c_device_id *id)
592{
593 int err = 0;
594 struct saa7191 *decoder;
595 struct v4l2_subdev *sd;
596
597 v4l_info(client, "chip found @ 0x%x (%s)\n",
598 client->addr << 1, client->adapter->name);
599
600 decoder = devm_kzalloc(&client->dev, sizeof(*decoder), GFP_KERNEL);
601 if (!decoder)
602 return -ENOMEM;
603
604 sd = &decoder->sd;
605 v4l2_i2c_subdev_init(sd, client, &saa7191_ops);
606
607 err = saa7191_write_block(sd, sizeof(initseq), initseq);
608 if (err) {
609 printk(KERN_ERR "SAA7191 initialization failed\n");
610 return err;
611 }
612
613 printk(KERN_INFO "SAA7191 initialized\n");
614
615 decoder->input = SAA7191_INPUT_COMPOSITE;
616 decoder->norm = V4L2_STD_PAL;
617
618 err = saa7191_autodetect_norm(sd);
619 if (err && (err != -EBUSY))
620 printk(KERN_ERR "SAA7191: Signal auto-detection failed\n");
621
622 return 0;
623}
624
625static int saa7191_remove(struct i2c_client *client)
626{
627 struct v4l2_subdev *sd = i2c_get_clientdata(client);
628
629 v4l2_device_unregister_subdev(sd);
630 return 0;
631}
632
633static const struct i2c_device_id saa7191_id[] = {
634 { "saa7191", 0 },
635 { }
636};
637MODULE_DEVICE_TABLE(i2c, saa7191_id);
638
639static struct i2c_driver saa7191_driver = {
640 .driver = {
641 .owner = THIS_MODULE,
642 .name = "saa7191",
643 },
644 .probe = saa7191_probe,
645 .remove = saa7191_remove,
646 .id_table = saa7191_id,
647};
648
649module_i2c_driver(saa7191_driver);