drivers/media/video/saa7191.c

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