drivers/media/i2c/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
  26 #include "saa7191.h"
  27
  28 #define SAA7191_MODULE_VERSION  "0.0.5"
  29
  30 MODULE_DESCRIPTION("Philips SAA7191 video decoder driver");
  31 MODULE_VERSION(SAA7191_MODULE_VERSION);
  32 MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
  33 MODULE_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
  47 struct 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
  58 static inline struct saa7191 *to_saa7191(struct v4l2_subdev *sd)
  59 {
  60         return container_of(sd, struct saa7191, sd);
  61 }
  62
  63 static 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
 107 static u8 saa7191_read_reg(struct v4l2_subdev *sd, u8 reg)
 108 {
 109         return to_saa7191(sd)->reg[reg];
 110 }
 111
 112 static 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
 127 static 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) */
 136 static 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
 160 static 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
 196 static 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
 240 static 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
 263 static 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                 return -EAGAIN;
 328         }
 329
 330         if (status & SAA7191_STATUS_CODE) {
 331                 dprintk("PAL\n");
 332                 *norm = V4L2_STD_PAL;
 333                 return saa7191_s_std(sd, old_norm);
 334         }
 335
 336         dprintk("No color detected with PAL - Trying SECAM...\n");
 337
 338         /* no color detected ? -> try SECAM */
 339         err = saa7191_s_std(sd, V4L2_STD_SECAM);
 340         if (err)
 341                 goto out;
 342
 343         msleep(SAA7191_SYNC_DELAY);
 344
 345         err = saa7191_wait_for_signal(sd, &status);
 346         if (err)
 347                 goto out;
 348
 349         /* not 50Hz ? */
 350         if (status & SAA7191_STATUS_FIDT) {
 351                 dprintk("No 50Hz signal\n");
 352                 err = -EAGAIN;
 353                 goto out;
 354         }
 355
 356         if (status & SAA7191_STATUS_CODE) {
 357                 /* Color detected -> SECAM */
 358                 dprintk("SECAM\n");
 359                 *norm = V4L2_STD_SECAM;
 360                 return saa7191_s_std(sd, old_norm);
 361         }
 362
 363         dprintk("No color detected with SECAM - Going back to PAL.\n");
 364
 365 out:
 366         return saa7191_s_std(sd, old_norm);
 367 }
 368
 369 static int saa7191_autodetect_norm(struct v4l2_subdev *sd)
 370 {
 371         u8 status;
 372
 373         dprintk("SAA7191 signal auto-detection...\n");
 374
 375         dprintk("Reading status...\n");
 376
 377         if (saa7191_read_status(sd, &status))
 378                 return -EIO;
 379
 380         dprintk("Checking for signal...\n");
 381
 382         /* no signal ? */
 383         if (status & SAA7191_STATUS_HLCK) {
 384                 dprintk("No signal\n");
 385                 return -EBUSY;
 386         }
 387
 388         dprintk("Signal found\n");
 389
 390         if (status & SAA7191_STATUS_FIDT) {
 391                 /* 60hz signal -> NTSC */
 392                 dprintk("NTSC\n");
 393                 return saa7191_s_std(sd, V4L2_STD_NTSC);
 394         } else {
 395                 /* 50hz signal -> PAL */
 396                 dprintk("PAL\n");
 397                 return saa7191_s_std(sd, V4L2_STD_PAL);
 398         }
 399 }
 400
 401 static int saa7191_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 402 {
 403         u8 reg;
 404         int ret = 0;
 405
 406         switch (ctrl->id) {
 407         case SAA7191_CONTROL_BANDPASS:
 408         case SAA7191_CONTROL_BANDPASS_WEIGHT:
 409         case SAA7191_CONTROL_CORING:
 410                 reg = saa7191_read_reg(sd, SAA7191_REG_LUMA);
 411                 switch (ctrl->id) {
 412                 case SAA7191_CONTROL_BANDPASS:
 413                         ctrl->value = ((s32)reg & SAA7191_LUMA_BPSS_MASK)
 414                                 >> SAA7191_LUMA_BPSS_SHIFT;
 415                         break;
 416                 case SAA7191_CONTROL_BANDPASS_WEIGHT:
 417                         ctrl->value = ((s32)reg & SAA7191_LUMA_APER_MASK)
 418                                 >> SAA7191_LUMA_APER_SHIFT;
 419                         break;
 420                 case SAA7191_CONTROL_CORING:
 421                         ctrl->value = ((s32)reg & SAA7191_LUMA_CORI_MASK)
 422                                 >> SAA7191_LUMA_CORI_SHIFT;
 423                         break;
 424                 }
 425                 break;
 426         case SAA7191_CONTROL_FORCE_COLOUR:
 427         case SAA7191_CONTROL_CHROMA_GAIN:
 428                 reg = saa7191_read_reg(sd, SAA7191_REG_GAIN);
 429                 if (ctrl->id == SAA7191_CONTROL_FORCE_COLOUR)
 430                         ctrl->value = ((s32)reg & SAA7191_GAIN_COLO) ? 1 : 0;
 431                 else
 432                         ctrl->value = ((s32)reg & SAA7191_GAIN_LFIS_MASK)
 433                                 >> SAA7191_GAIN_LFIS_SHIFT;
 434                 break;
 435         case V4L2_CID_HUE:
 436                 reg = saa7191_read_reg(sd, SAA7191_REG_HUEC);
 437                 if (reg < 0x80)
 438                         reg += 0x80;
 439                 else
 440                         reg -= 0x80;
 441                 ctrl->value = (s32)reg;
 442                 break;
 443         case SAA7191_CONTROL_VTRC:
 444                 reg = saa7191_read_reg(sd, SAA7191_REG_STDC);
 445                 ctrl->value = ((s32)reg & SAA7191_STDC_VTRC) ? 1 : 0;
 446                 break;
 447         case SAA7191_CONTROL_LUMA_DELAY:
 448                 reg = saa7191_read_reg(sd, SAA7191_REG_CTL3);
 449                 ctrl->value = ((s32)reg & SAA7191_CTL3_YDEL_MASK)
 450                         >> SAA7191_CTL3_YDEL_SHIFT;
 451                 if (ctrl->value >= 4)
 452                         ctrl->value -= 8;
 453                 break;
 454         case SAA7191_CONTROL_VNR:
 455                 reg = saa7191_read_reg(sd, SAA7191_REG_CTL4);
 456                 ctrl->value = ((s32)reg & SAA7191_CTL4_VNOI_MASK)
 457                         >> SAA7191_CTL4_VNOI_SHIFT;
 458                 break;
 459         default:
 460                 ret = -EINVAL;
 461         }
 462
 463         return ret;
 464 }
 465
 466 static int saa7191_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 467 {
 468         u8 reg;
 469         int ret = 0;
 470
 471         switch (ctrl->id) {
 472         case SAA7191_CONTROL_BANDPASS:
 473         case SAA7191_CONTROL_BANDPASS_WEIGHT:
 474         case SAA7191_CONTROL_CORING:
 475                 reg = saa7191_read_reg(sd, SAA7191_REG_LUMA);
 476                 switch (ctrl->id) {
 477                 case SAA7191_CONTROL_BANDPASS:
 478                         reg &= ~SAA7191_LUMA_BPSS_MASK;
 479                         reg |= (ctrl->value << SAA7191_LUMA_BPSS_SHIFT)
 480                                 & SAA7191_LUMA_BPSS_MASK;
 481                         break;
 482                 case SAA7191_CONTROL_BANDPASS_WEIGHT:
 483                         reg &= ~SAA7191_LUMA_APER_MASK;
 484                         reg |= (ctrl->value << SAA7191_LUMA_APER_SHIFT)
 485                                 & SAA7191_LUMA_APER_MASK;
 486                         break;
 487                 case SAA7191_CONTROL_CORING:
 488                         reg &= ~SAA7191_LUMA_CORI_MASK;
 489                         reg |= (ctrl->value << SAA7191_LUMA_CORI_SHIFT)
 490                                 & SAA7191_LUMA_CORI_MASK;
 491                         break;
 492                 }
 493                 ret = saa7191_write_reg(sd, SAA7191_REG_LUMA, reg);
 494                 break;
 495         case SAA7191_CONTROL_FORCE_COLOUR:
 496         case SAA7191_CONTROL_CHROMA_GAIN:
 497                 reg = saa7191_read_reg(sd, SAA7191_REG_GAIN);
 498                 if (ctrl->id == SAA7191_CONTROL_FORCE_COLOUR) {
 499                         if (ctrl->value)
 500                                 reg |= SAA7191_GAIN_COLO;
 501                         else
 502                                 reg &= ~SAA7191_GAIN_COLO;
 503                 } else {
 504                         reg &= ~SAA7191_GAIN_LFIS_MASK;
 505                         reg |= (ctrl->value << SAA7191_GAIN_LFIS_SHIFT)
 506                                 & SAA7191_GAIN_LFIS_MASK;
 507                 }
 508                 ret = saa7191_write_reg(sd, SAA7191_REG_GAIN, reg);
 509                 break;
 510         case V4L2_CID_HUE:
 511                 reg = ctrl->value & 0xff;
 512                 if (reg < 0x80)
 513                         reg += 0x80;
 514                 else
 515                         reg -= 0x80;
 516                 ret = saa7191_write_reg(sd, SAA7191_REG_HUEC, reg);
 517                 break;
 518         case SAA7191_CONTROL_VTRC:
 519                 reg = saa7191_read_reg(sd, SAA7191_REG_STDC);
 520                 if (ctrl->value)
 521                         reg |= SAA7191_STDC_VTRC;
 522                 else
 523                         reg &= ~SAA7191_STDC_VTRC;
 524                 ret = saa7191_write_reg(sd, SAA7191_REG_STDC, reg);
 525                 break;
 526         case SAA7191_CONTROL_LUMA_DELAY: {
 527                 s32 value = ctrl->value;
 528                 if (value < 0)
 529                         value += 8;
 530                 reg = saa7191_read_reg(sd, SAA7191_REG_CTL3);
 531                 reg &= ~SAA7191_CTL3_YDEL_MASK;
 532                 reg |= (value << SAA7191_CTL3_YDEL_SHIFT)
 533                         & SAA7191_CTL3_YDEL_MASK;
 534                 ret = saa7191_write_reg(sd, SAA7191_REG_CTL3, reg);
 535                 break;
 536         }
 537         case SAA7191_CONTROL_VNR:
 538                 reg = saa7191_read_reg(sd, SAA7191_REG_CTL4);
 539                 reg &= ~SAA7191_CTL4_VNOI_MASK;
 540                 reg |= (ctrl->value << SAA7191_CTL4_VNOI_SHIFT)
 541                         & SAA7191_CTL4_VNOI_MASK;
 542                 ret = saa7191_write_reg(sd, SAA7191_REG_CTL4, reg);
 543                 break;
 544         default:
 545                 ret = -EINVAL;
 546         }
 547
 548         return ret;
 549 }
 550
 551 /* I2C-interface */
 552
 553 static int saa7191_g_input_status(struct v4l2_subdev *sd, u32 *status)
 554 {
 555         u8 status_reg;
 556         int res = V4L2_IN_ST_NO_SIGNAL;
 557
 558         if (saa7191_read_status(sd, &status_reg))
 559                 return -EIO;
 560         if ((status_reg & SAA7191_STATUS_HLCK) == 0)
 561                 res = 0;
 562         if (!(status_reg & SAA7191_STATUS_CODE))
 563                 res |= V4L2_IN_ST_NO_COLOR;
 564         *status = res;
 565         return 0;
 566 }
 567
 568
 569 /* ----------------------------------------------------------------------- */
 570
 571 static const struct v4l2_subdev_core_ops saa7191_core_ops = {
 572         .g_ctrl = saa7191_g_ctrl,
 573         .s_ctrl = saa7191_s_ctrl,
 574         .s_std = saa7191_s_std,
 575 };
 576
 577 static const struct v4l2_subdev_video_ops saa7191_video_ops = {
 578         .s_routing = saa7191_s_routing,
 579         .querystd = saa7191_querystd,
 580         .g_input_status = saa7191_g_input_status,
 581 };
 582
 583 static const struct v4l2_subdev_ops saa7191_ops = {
 584         .core = &saa7191_core_ops,
 585         .video = &saa7191_video_ops,
 586 };
 587
 588 static int saa7191_probe(struct i2c_client *client,
 589                           const struct i2c_device_id *id)
 590 {
 591         int err = 0;
 592         struct saa7191 *decoder;
 593         struct v4l2_subdev *sd;
 594
 595         v4l_info(client, "chip found @ 0x%x (%s)\n",
 596                         client->addr << 1, client->adapter->name);
 597
 598         decoder = devm_kzalloc(&client->dev, sizeof(*decoder), GFP_KERNEL);
 599         if (!decoder)
 600                 return -ENOMEM;
 601
 602         sd = &decoder->sd;
 603         v4l2_i2c_subdev_init(sd, client, &saa7191_ops);
 604
 605         err = saa7191_write_block(sd, sizeof(initseq), initseq);
 606         if (err) {
 607                 printk(KERN_ERR "SAA7191 initialization failed\n");
 608                 return err;
 609         }
 610
 611         printk(KERN_INFO "SAA7191 initialized\n");
 612
 613         decoder->input = SAA7191_INPUT_COMPOSITE;
 614         decoder->norm = V4L2_STD_PAL;
 615
 616         err = saa7191_autodetect_norm(sd);
 617         if (err && (err != -EBUSY))
 618                 printk(KERN_ERR "SAA7191: Signal auto-detection failed\n");
 619
 620         return 0;
 621 }
 622
 623 static int saa7191_remove(struct i2c_client *client)
 624 {
 625         struct v4l2_subdev *sd = i2c_get_clientdata(client);
 626
 627         v4l2_device_unregister_subdev(sd);
 628         return 0;
 629 }
 630
 631 static const struct i2c_device_id saa7191_id[] = {
 632         { "saa7191", 0 },
 633         { }
 634 };
 635 MODULE_DEVICE_TABLE(i2c, saa7191_id);
 636
 637 static struct i2c_driver saa7191_driver = {
 638         .driver = {
 639                 .owner  = THIS_MODULE,
 640                 .name   = "saa7191",
 641         },
 642         .probe          = saa7191_probe,
 643         .remove         = saa7191_remove,
 644         .id_table       = saa7191_id,
 645 };
 646
 647 module_i2c_driver(saa7191_driver);