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/videodev.h>
  23 #include <linux/video_decoder.h>
  24 #include <linux/i2c.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 // #define SAA7191_DEBUG
  36
  37 #ifdef SAA7191_DEBUG
  38 #define dprintk(x...) printk("SAA7191: " x);
  39 #else
  40 #define dprintk(x...)
  41 #endif
  42
  43 #define SAA7191_SYNC_COUNT      30
  44 #define SAA7191_SYNC_DELAY      100     /* milliseconds */
  45
  46 struct saa7191 {
  47         struct i2c_client *client;
  48
  49         /* the register values are stored here as the actual
  50          * I2C-registers are write-only */
  51         u8 reg[25];
  52
  53         int input;
  54         int norm;
  55 };
  56
  57 static struct i2c_driver i2c_driver_saa7191;
  58
  59 static const u8 initseq[] = {
  60         0,      /* Subaddress */
  61
  62         0x50,   /* (0x50) SAA7191_REG_IDEL */
  63
  64         /* 50 Hz signal timing */
  65         0x30,   /* (0x30) SAA7191_REG_HSYB */
  66         0x00,   /* (0x00) SAA7191_REG_HSYS */
  67         0xe8,   /* (0xe8) SAA7191_REG_HCLB */
  68         0xb6,   /* (0xb6) SAA7191_REG_HCLS */
  69         0xf4,   /* (0xf4) SAA7191_REG_HPHI */
  70
  71         /* control */
  72         SAA7191_LUMA_APER_1,    /* (0x01) SAA7191_REG_LUMA - CVBS mode */
  73         0x00,   /* (0x00) SAA7191_REG_HUEC */
  74         0xf8,   /* (0xf8) SAA7191_REG_CKTQ */
  75         0xf8,   /* (0xf8) SAA7191_REG_CKTS */
  76         0x90,   /* (0x90) SAA7191_REG_PLSE */
  77         0x90,   /* (0x90) SAA7191_REG_SESE */
  78         0x00,   /* (0x00) SAA7191_REG_GAIN */
  79         SAA7191_STDC_NFEN | SAA7191_STDC_HRMV,  /* (0x0c) SAA7191_REG_STDC
  80                                                  * - not SECAM,
  81                                                  * slow time constant */
  82         SAA7191_IOCK_OEDC | SAA7191_IOCK_OEHS | SAA7191_IOCK_OEVS
  83         | SAA7191_IOCK_OEDY,    /* (0x78) SAA7191_REG_IOCK
  84                                  * - chroma from CVBS, GPSW1 & 2 off */
  85         SAA7191_CTL3_AUFD | SAA7191_CTL3_SCEN | SAA7191_CTL3_OFTS
  86         | SAA7191_CTL3_YDEL0,   /* (0x99) SAA7191_REG_CTL3
  87                                  * - automatic field detection */
  88         0x00,   /* (0x00) SAA7191_REG_CTL4 */
  89         0x2c,   /* (0x2c) SAA7191_REG_CHCV - PAL nominal value */
  90         0x00,   /* unused */
  91         0x00,   /* unused */
  92
  93         /* 60 Hz signal timing */
  94         0x34,   /* (0x34) SAA7191_REG_HS6B */
  95         0x0a,   /* (0x0a) SAA7191_REG_HS6S */
  96         0xf4,   /* (0xf4) SAA7191_REG_HC6B */
  97         0xce,   /* (0xce) SAA7191_REG_HC6S */
  98         0xf4,   /* (0xf4) SAA7191_REG_HP6I */
  99 };
 100
 101 /* SAA7191 register handling */
 102
 103 static u8 saa7191_read_reg(struct i2c_client *client,
 104                            u8 reg)
 105 {
 106         return ((struct saa7191 *)i2c_get_clientdata(client))->reg[reg];
 107 }
 108
 109 static int saa7191_read_status(struct i2c_client *client,
 110                                u8 *value)
 111 {
 112         int ret;
 113
 114         ret = i2c_master_recv(client, value, 1);
 115         if (ret < 0) {
 116                 printk(KERN_ERR "SAA7191: saa7191_read_status(): read failed\n");
 117                 return ret;
 118         }
 119
 120         return 0;
 121 }
 122
 123
 124 static int saa7191_write_reg(struct i2c_client *client, u8 reg,
 125                              u8 value)
 126 {
 127         ((struct saa7191 *)i2c_get_clientdata(client))->reg[reg] = value;
 128         return i2c_smbus_write_byte_data(client, reg, value);
 129 }
 130
 131 /* the first byte of data must be the first subaddress number (register) */
 132 static int saa7191_write_block(struct i2c_client *client,
 133                                u8 length, const u8 *data)
 134 {
 135         int i;
 136         int ret;
 137
 138         struct saa7191 *decoder = (struct saa7191 *)i2c_get_clientdata(client);
 139         for (i = 0; i < (length - 1); i++) {
 140                 decoder->reg[data[0] + i] = data[i + 1];
 141         }
 142
 143         ret = i2c_master_send(client, data, length);
 144         if (ret < 0) {
 145                 printk(KERN_ERR "SAA7191: saa7191_write_block(): "
 146                        "write failed\n");
 147                 return ret;
 148         }
 149
 150         return 0;
 151 }
 152
 153 /* Helper functions */
 154
 155 static int saa7191_set_input(struct i2c_client *client, int input)
 156 {
 157         struct saa7191 *decoder = i2c_get_clientdata(client);
 158         u8 luma = saa7191_read_reg(client, SAA7191_REG_LUMA);
 159         u8 iock = saa7191_read_reg(client, SAA7191_REG_IOCK);
 160         int err;
 161
 162         switch (input) {
 163         case SAA7191_INPUT_COMPOSITE: /* Set Composite input */
 164                 iock &= ~(SAA7191_IOCK_CHRS | SAA7191_IOCK_GPSW1
 165                           | SAA7191_IOCK_GPSW2);
 166                 /* Chrominance trap active */
 167                 luma &= ~SAA7191_LUMA_BYPS;
 168                 break;
 169         case SAA7191_INPUT_SVIDEO: /* Set S-Video input */
 170                 iock |= SAA7191_IOCK_CHRS | SAA7191_IOCK_GPSW2;
 171                 /* Chrominance trap bypassed */
 172                 luma |= SAA7191_LUMA_BYPS;
 173                 break;
 174         default:
 175                 return -EINVAL;
 176         }
 177
 178         err = saa7191_write_reg(client, SAA7191_REG_LUMA, luma);
 179         if (err)
 180                 return -EIO;
 181         err = saa7191_write_reg(client, SAA7191_REG_IOCK, iock);
 182         if (err)
 183                 return -EIO;
 184
 185         decoder->input = input;
 186
 187         return 0;
 188 }
 189
 190 static int saa7191_set_norm(struct i2c_client *client, int norm)
 191 {
 192         struct saa7191 *decoder = i2c_get_clientdata(client);
 193         u8 stdc = saa7191_read_reg(client, SAA7191_REG_STDC);
 194         u8 ctl3 = saa7191_read_reg(client, SAA7191_REG_CTL3);
 195         u8 chcv = saa7191_read_reg(client, SAA7191_REG_CHCV);
 196         int err;
 197
 198         switch(norm) {
 199         case SAA7191_NORM_PAL:
 200                 stdc &= ~SAA7191_STDC_SECS;
 201                 ctl3 &= ~(SAA7191_CTL3_AUFD | SAA7191_CTL3_FSEL);
 202                 chcv = SAA7191_CHCV_PAL;
 203                 break;
 204         case SAA7191_NORM_NTSC:
 205                 stdc &= ~SAA7191_STDC_SECS;
 206                 ctl3 &= ~SAA7191_CTL3_AUFD;
 207                 ctl3 |= SAA7191_CTL3_FSEL;
 208                 chcv = SAA7191_CHCV_NTSC;
 209                 break;
 210         case SAA7191_NORM_SECAM:
 211                 stdc |= SAA7191_STDC_SECS;
 212                 ctl3 &= ~(SAA7191_CTL3_AUFD | SAA7191_CTL3_FSEL);
 213                 chcv = SAA7191_CHCV_PAL;
 214                 break;
 215         default:
 216                 return -EINVAL;
 217         }
 218
 219         err = saa7191_write_reg(client, SAA7191_REG_CTL3, ctl3);
 220         if (err)
 221                 return -EIO;
 222         err = saa7191_write_reg(client, SAA7191_REG_STDC, stdc);
 223         if (err)
 224                 return -EIO;
 225         err = saa7191_write_reg(client, SAA7191_REG_CHCV, chcv);
 226         if (err)
 227                 return -EIO;
 228
 229         decoder->norm = norm;
 230
 231         dprintk("ctl3: %02x stdc: %02x chcv: %02x\n", ctl3,
 232                 stdc, chcv);
 233         dprintk("norm: %d\n", norm);
 234
 235         return 0;
 236 }
 237
 238 static int saa7191_wait_for_signal(struct i2c_client *client, u8 *status)
 239 {
 240         int i = 0;
 241
 242         dprintk("Checking for signal...\n");
 243
 244         for (i = 0; i < SAA7191_SYNC_COUNT; i++) {
 245                 if (saa7191_read_status(client, status))
 246                         return -EIO;
 247
 248                 if (((*status) & SAA7191_STATUS_HLCK) == 0) {
 249                         dprintk("Signal found\n");
 250                         return 0;
 251                 }
 252
 253                 msleep(SAA7191_SYNC_DELAY);
 254         }
 255
 256         dprintk("No signal\n");
 257
 258         return -EBUSY;
 259 }
 260
 261 static int saa7191_autodetect_norm_extended(struct i2c_client *client)
 262 {
 263         u8 stdc = saa7191_read_reg(client, SAA7191_REG_STDC);
 264         u8 ctl3 = saa7191_read_reg(client, SAA7191_REG_CTL3);
 265         u8 status;
 266         int err = 0;
 267
 268         dprintk("SAA7191 extended signal auto-detection...\n");
 269
 270         stdc &= ~SAA7191_STDC_SECS;
 271         ctl3 &= ~(SAA7191_CTL3_FSEL);
 272
 273         err = saa7191_write_reg(client, SAA7191_REG_STDC, stdc);
 274         if (err) {
 275                 err = -EIO;
 276                 goto out;
 277         }
 278         err = saa7191_write_reg(client, SAA7191_REG_CTL3, ctl3);
 279         if (err) {
 280                 err = -EIO;
 281                 goto out;
 282         }
 283
 284         ctl3 |= SAA7191_CTL3_AUFD;
 285         err = saa7191_write_reg(client, SAA7191_REG_CTL3, ctl3);
 286         if (err) {
 287                 err = -EIO;
 288                 goto out;
 289         }
 290
 291         msleep(SAA7191_SYNC_DELAY);
 292
 293         err = saa7191_wait_for_signal(client, &status);
 294         if (err)
 295                 goto out;
 296
 297         if (status & SAA7191_STATUS_FIDT) {
 298                 /* 60Hz signal -> NTSC */
 299                 dprintk("60Hz signal: NTSC\n");
 300                 return saa7191_set_norm(client, SAA7191_NORM_NTSC);
 301         }
 302
 303         /* 50Hz signal */
 304         dprintk("50Hz signal: Trying PAL...\n");
 305
 306         /* try PAL first */
 307         err = saa7191_set_norm(client, SAA7191_NORM_PAL);
 308         if (err)
 309                 goto out;
 310
 311         msleep(SAA7191_SYNC_DELAY);
 312
 313         err = saa7191_wait_for_signal(client, &status);
 314         if (err)
 315                 goto out;
 316
 317         /* not 50Hz ? */
 318         if (status & SAA7191_STATUS_FIDT) {
 319                 dprintk("No 50Hz signal\n");
 320                 err = -EAGAIN;
 321                 goto out;
 322         }
 323
 324         if (status & SAA7191_STATUS_CODE) {
 325                 dprintk("PAL\n");
 326                 return 0;
 327         }
 328
 329         dprintk("No color detected with PAL - Trying SECAM...\n");
 330
 331         /* no color detected ? -> try SECAM */
 332         err = saa7191_set_norm(client,
 333                                SAA7191_NORM_SECAM);
 334         if (err)
 335                 goto out;
 336
 337         msleep(SAA7191_SYNC_DELAY);
 338
 339         err = saa7191_wait_for_signal(client, &status);
 340         if (err)
 341                 goto out;
 342
 343         /* not 50Hz ? */
 344         if (status & SAA7191_STATUS_FIDT) {
 345                 dprintk("No 50Hz signal\n");
 346                 err = -EAGAIN;
 347                 goto out;
 348         }
 349
 350         if (status & SAA7191_STATUS_CODE) {
 351                 /* Color detected -> SECAM */
 352                 dprintk("SECAM\n");
 353                 return 0;
 354         }
 355
 356         dprintk("No color detected with SECAM - Going back to PAL.\n");
 357
 358         /* still no color detected ?
 359          * -> set norm back to PAL */
 360         err = saa7191_set_norm(client,
 361                                SAA7191_NORM_PAL);
 362         if (err)
 363                 goto out;
 364
 365 out:
 366         ctl3 = saa7191_read_reg(client, SAA7191_REG_CTL3);
 367         if (ctl3 & SAA7191_CTL3_AUFD) {
 368                 ctl3 &= ~(SAA7191_CTL3_AUFD);
 369                 err = saa7191_write_reg(client, SAA7191_REG_CTL3, ctl3);
 370                 if (err) {
 371                         err = -EIO;
 372                 }
 373         }
 374
 375         return err;
 376 }
 377
 378 static int saa7191_autodetect_norm(struct i2c_client *client)
 379 {
 380         u8 status;
 381
 382         dprintk("SAA7191 signal auto-detection...\n");
 383
 384         dprintk("Reading status...\n");
 385
 386         if (saa7191_read_status(client, &status))
 387                 return -EIO;
 388
 389         dprintk("Checking for signal...\n");
 390
 391         /* no signal ? */
 392         if (status & SAA7191_STATUS_HLCK) {
 393                 dprintk("No signal\n");
 394                 return -EBUSY;
 395         }
 396
 397         dprintk("Signal found\n");
 398
 399         if (status & SAA7191_STATUS_FIDT) {
 400                 /* 60hz signal -> NTSC */
 401                 dprintk("NTSC\n");
 402                 return saa7191_set_norm(client, SAA7191_NORM_NTSC);
 403         } else {
 404                 /* 50hz signal -> PAL */
 405                 dprintk("PAL\n");
 406                 return saa7191_set_norm(client, SAA7191_NORM_PAL);
 407         }
 408 }
 409
 410 static int saa7191_get_control(struct i2c_client *client,
 411                                struct saa7191_control *ctrl)
 412 {
 413         u8 reg;
 414         int ret = 0;
 415
 416         switch (ctrl->type) {
 417         case SAA7191_CONTROL_BANDPASS:
 418         case SAA7191_CONTROL_BANDPASS_WEIGHT:
 419         case SAA7191_CONTROL_CORING:
 420                 reg = saa7191_read_reg(client, SAA7191_REG_LUMA);
 421                 switch (ctrl->type) {
 422                 case SAA7191_CONTROL_BANDPASS:
 423                         ctrl->value = ((s32)reg & SAA7191_LUMA_BPSS_MASK)
 424                                 >> SAA7191_LUMA_BPSS_SHIFT;
 425                         break;
 426                 case SAA7191_CONTROL_BANDPASS_WEIGHT:
 427                         ctrl->value = ((s32)reg & SAA7191_LUMA_APER_MASK)
 428                                 >> SAA7191_LUMA_APER_SHIFT;
 429                         break;
 430                 case SAA7191_CONTROL_CORING:
 431                         ctrl->value = ((s32)reg & SAA7191_LUMA_CORI_MASK)
 432                                 >> SAA7191_LUMA_CORI_SHIFT;
 433                         break;
 434                 }
 435                 break;
 436         case SAA7191_CONTROL_FORCE_COLOUR:
 437         case SAA7191_CONTROL_CHROMA_GAIN:
 438                 reg = saa7191_read_reg(client, SAA7191_REG_GAIN);
 439                 if (ctrl->type == SAA7191_CONTROL_FORCE_COLOUR)
 440                         ctrl->value = ((s32)reg & SAA7191_GAIN_COLO) ? 1 : 0;
 441                 else
 442                         ctrl->value = ((s32)reg & SAA7191_GAIN_LFIS_MASK)
 443                                 >> SAA7191_GAIN_LFIS_SHIFT;
 444                 break;
 445         case SAA7191_CONTROL_HUE:
 446                 reg = saa7191_read_reg(client, SAA7191_REG_HUEC);
 447                 if (reg < 0x80)
 448                         reg += 0x80;
 449                 else
 450                         reg -= 0x80;
 451                 ctrl->value = (s32)reg;
 452                 break;
 453         case SAA7191_CONTROL_VTRC:
 454                 reg = saa7191_read_reg(client, SAA7191_REG_STDC);
 455                 ctrl->value = ((s32)reg & SAA7191_STDC_VTRC) ? 1 : 0;
 456                 break;
 457         case SAA7191_CONTROL_LUMA_DELAY:
 458                 reg = saa7191_read_reg(client, SAA7191_REG_CTL3);
 459                 ctrl->value = ((s32)reg & SAA7191_CTL3_YDEL_MASK)
 460                         >> SAA7191_CTL3_YDEL_SHIFT;
 461                 if (ctrl->value >= 4)
 462                         ctrl->value -= 8;
 463                 break;
 464         case SAA7191_CONTROL_VNR:
 465                 reg = saa7191_read_reg(client, SAA7191_REG_CTL4);
 466                 ctrl->value = ((s32)reg & SAA7191_CTL4_VNOI_MASK)
 467                         >> SAA7191_CTL4_VNOI_SHIFT;
 468                 break;
 469         default:
 470                 ret = -EINVAL;
 471         }
 472
 473         return ret;
 474 }
 475
 476 static int saa7191_set_control(struct i2c_client *client,
 477                                struct saa7191_control *ctrl)
 478 {
 479         u8 reg;
 480         int ret = 0;
 481
 482         switch (ctrl->type) {
 483         case SAA7191_CONTROL_BANDPASS:
 484         case SAA7191_CONTROL_BANDPASS_WEIGHT:
 485         case SAA7191_CONTROL_CORING:
 486                 reg = saa7191_read_reg(client, SAA7191_REG_LUMA);
 487                 switch (ctrl->type) {
 488                 case SAA7191_CONTROL_BANDPASS:
 489                         reg &= ~SAA7191_LUMA_BPSS_MASK;
 490                         reg |= (ctrl->value << SAA7191_LUMA_BPSS_SHIFT)
 491                                 & SAA7191_LUMA_BPSS_MASK;
 492                         break;
 493                 case SAA7191_CONTROL_BANDPASS_WEIGHT:
 494                         reg &= ~SAA7191_LUMA_APER_MASK;
 495                         reg |= (ctrl->value << SAA7191_LUMA_APER_SHIFT)
 496                                 & SAA7191_LUMA_APER_MASK;
 497                         break;
 498                 case SAA7191_CONTROL_CORING:
 499                         reg &= ~SAA7191_LUMA_CORI_MASK;
 500                         reg |= (ctrl->value << SAA7191_LUMA_CORI_SHIFT)
 501                                 & SAA7191_LUMA_CORI_MASK;
 502                         break;
 503                 }
 504                 ret = saa7191_write_reg(client, SAA7191_REG_LUMA, reg);
 505                 break;
 506         case SAA7191_CONTROL_FORCE_COLOUR:
 507         case SAA7191_CONTROL_CHROMA_GAIN:
 508                 reg = saa7191_read_reg(client, SAA7191_REG_GAIN);
 509                 if (ctrl->type == SAA7191_CONTROL_FORCE_COLOUR) {
 510                         if (ctrl->value)
 511                                 reg |= SAA7191_GAIN_COLO;
 512                         else
 513                                 reg &= ~SAA7191_GAIN_COLO;
 514                 } else {
 515                         reg &= ~SAA7191_GAIN_LFIS_MASK;
 516                         reg |= (ctrl->value << SAA7191_GAIN_LFIS_SHIFT)
 517                                 & SAA7191_GAIN_LFIS_MASK;
 518                 }
 519                 ret = saa7191_write_reg(client, SAA7191_REG_GAIN, reg);
 520                 break;
 521         case SAA7191_CONTROL_HUE:
 522                 reg = ctrl->value & 0xff;
 523                 if (reg < 0x80)
 524                         reg += 0x80;
 525                 else
 526                         reg -= 0x80;
 527                 ret = saa7191_write_reg(client, SAA7191_REG_HUEC, reg);
 528                 break;
 529         case SAA7191_CONTROL_VTRC:
 530                 reg = saa7191_read_reg(client, SAA7191_REG_STDC);
 531                 if (ctrl->value)
 532                         reg |= SAA7191_STDC_VTRC;
 533                 else
 534                         reg &= ~SAA7191_STDC_VTRC;
 535                 ret = saa7191_write_reg(client, SAA7191_REG_STDC, reg);
 536                 break;
 537         case SAA7191_CONTROL_LUMA_DELAY: {
 538                 s32 value = ctrl->value;
 539                 if (value < 0)
 540                         value += 8;
 541                 reg = saa7191_read_reg(client, SAA7191_REG_CTL3);
 542                 reg &= ~SAA7191_CTL3_YDEL_MASK;
 543                 reg |= (value << SAA7191_CTL3_YDEL_SHIFT)
 544                         & SAA7191_CTL3_YDEL_MASK;
 545                 ret = saa7191_write_reg(client, SAA7191_REG_CTL3, reg);
 546                 break;
 547         }
 548         case SAA7191_CONTROL_VNR:
 549                 reg = saa7191_read_reg(client, SAA7191_REG_CTL4);
 550                 reg &= ~SAA7191_CTL4_VNOI_MASK;
 551                 reg |= (ctrl->value << SAA7191_CTL4_VNOI_SHIFT)
 552                         & SAA7191_CTL4_VNOI_MASK;
 553                 ret = saa7191_write_reg(client, SAA7191_REG_CTL4, reg);
 554                 break;
 555         default:
 556                 ret = -EINVAL;
 557         }
 558
 559         return ret;
 560 }
 561
 562 /* I2C-interface */
 563
 564 static int saa7191_attach(struct i2c_adapter *adap, int addr, int kind)
 565 {
 566         int err = 0;
 567         struct saa7191 *decoder;
 568         struct i2c_client *client;
 569
 570         printk(KERN_INFO "Philips SAA7191 driver version %s\n",
 571                SAA7191_MODULE_VERSION);
 572
 573         client = kzalloc(sizeof(*client), GFP_KERNEL);
 574         if (!client)
 575                 return -ENOMEM;
 576         decoder = kzalloc(sizeof(*decoder), GFP_KERNEL);
 577         if (!decoder) {
 578                 err = -ENOMEM;
 579                 goto out_free_client;
 580         }
 581
 582         client->addr = addr;
 583         client->adapter = adap;
 584         client->driver = &i2c_driver_saa7191;
 585         client->flags = 0;
 586         strcpy(client->name, "saa7191 client");
 587         i2c_set_clientdata(client, decoder);
 588
 589         decoder->client = client;
 590
 591         err = i2c_attach_client(client);
 592         if (err)
 593                 goto out_free_decoder;
 594
 595         err = saa7191_write_block(client, sizeof(initseq), initseq);
 596         if (err) {
 597                 printk(KERN_ERR "SAA7191 initialization failed\n");
 598                 goto out_detach_client;
 599         }
 600
 601         printk(KERN_INFO "SAA7191 initialized\n");
 602
 603         decoder->input = SAA7191_INPUT_COMPOSITE;
 604         decoder->norm = SAA7191_NORM_PAL;
 605
 606         err = saa7191_autodetect_norm(client);
 607         if (err && (err != -EBUSY)) {
 608                 printk(KERN_ERR "SAA7191: Signal auto-detection failed\n");
 609         }
 610
 611         return 0;
 612
 613 out_detach_client:
 614         i2c_detach_client(client);
 615 out_free_decoder:
 616         kfree(decoder);
 617 out_free_client:
 618         kfree(client);
 619         return err;
 620 }
 621
 622 static int saa7191_probe(struct i2c_adapter *adap)
 623 {
 624         /* Always connected to VINO */
 625         if (adap->id == I2C_HW_SGI_VINO)
 626                 return saa7191_attach(adap, SAA7191_ADDR, 0);
 627         /* Feel free to add probe here :-) */
 628         return -ENODEV;
 629 }
 630
 631 static int saa7191_detach(struct i2c_client *client)
 632 {
 633         struct saa7191 *decoder = i2c_get_clientdata(client);
 634
 635         i2c_detach_client(client);
 636         kfree(decoder);
 637         kfree(client);
 638         return 0;
 639 }
 640
 641 static int saa7191_command(struct i2c_client *client, unsigned int cmd,
 642                            void *arg)
 643 {
 644         struct saa7191 *decoder = i2c_get_clientdata(client);
 645
 646         switch (cmd) {
 647         case DECODER_GET_CAPABILITIES: {
 648                 struct video_decoder_capability *cap = arg;
 649
 650                 cap->flags  = VIDEO_DECODER_PAL | VIDEO_DECODER_NTSC |
 651                               VIDEO_DECODER_SECAM | VIDEO_DECODER_AUTO;
 652                 cap->inputs = (client->adapter->id == I2C_HW_SGI_VINO) ? 2 : 1;
 653                 cap->outputs = 1;
 654                 break;
 655         }
 656         case DECODER_GET_STATUS: {
 657                 int *iarg = arg;
 658                 u8 status;
 659                 int res = 0;
 660
 661                 if (saa7191_read_status(client, &status)) {
 662                         return -EIO;
 663                 }
 664                 if ((status & SAA7191_STATUS_HLCK) == 0)
 665                         res |= DECODER_STATUS_GOOD;
 666                 if (status & SAA7191_STATUS_CODE)
 667                         res |= DECODER_STATUS_COLOR;
 668                 switch (decoder->norm) {
 669                 case SAA7191_NORM_NTSC:
 670                         res |= DECODER_STATUS_NTSC;
 671                         break;
 672                 case SAA7191_NORM_PAL:
 673                         res |= DECODER_STATUS_PAL;
 674                         break;
 675                 case SAA7191_NORM_SECAM:
 676                         res |= DECODER_STATUS_SECAM;
 677                         break;
 678                 case SAA7191_NORM_AUTO:
 679                 default:
 680                         if (status & SAA7191_STATUS_FIDT)
 681                                 res |= DECODER_STATUS_NTSC;
 682                         else
 683                                 res |= DECODER_STATUS_PAL;
 684                         break;
 685                 }
 686                 *iarg = res;
 687                 break;
 688         }
 689         case DECODER_SET_NORM: {
 690                 int *iarg = arg;
 691
 692                 switch (*iarg) {
 693                 case VIDEO_MODE_AUTO:
 694                         return saa7191_autodetect_norm(client);
 695                 case VIDEO_MODE_PAL:
 696                         return saa7191_set_norm(client, SAA7191_NORM_PAL);
 697                 case VIDEO_MODE_NTSC:
 698                         return saa7191_set_norm(client, SAA7191_NORM_NTSC);
 699                 case VIDEO_MODE_SECAM:
 700                         return saa7191_set_norm(client, SAA7191_NORM_SECAM);
 701                 default:
 702                         return -EINVAL;
 703                 }
 704                 break;
 705         }
 706         case DECODER_SET_INPUT: {
 707                 int *iarg = arg;
 708
 709                 switch (client->adapter->id) {
 710                 case I2C_HW_SGI_VINO:
 711                         return saa7191_set_input(client, *iarg);
 712                 default:
 713                         if (*iarg != 0)
 714                                 return -EINVAL;
 715                 }
 716                 break;
 717         }
 718         case DECODER_SET_OUTPUT: {
 719                 int *iarg = arg;
 720
 721                 /* not much choice of outputs */
 722                 if (*iarg != 0)
 723                         return -EINVAL;
 724                 break;
 725         }
 726         case DECODER_ENABLE_OUTPUT: {
 727                 /* Always enabled */
 728                 break;
 729         }
 730         case DECODER_SET_PICTURE: {
 731                 struct video_picture *pic = arg;
 732                 unsigned val;
 733                 int err;
 734
 735                 val = (pic->hue >> 8) - 0x80;
 736
 737                 err = saa7191_write_reg(client, SAA7191_REG_HUEC, val);
 738                 if (err)
 739                         return -EIO;
 740
 741                 break;
 742         }
 743         case DECODER_SAA7191_GET_STATUS: {
 744                 struct saa7191_status *status = arg;
 745                 u8 status_reg;
 746
 747                 if (saa7191_read_status(client, &status_reg))
 748                         return -EIO;
 749
 750                 status->signal = ((status_reg & SAA7191_STATUS_HLCK) == 0)
 751                         ? 1 : 0;
 752                 status->signal_60hz = (status_reg & SAA7191_STATUS_FIDT)
 753                         ? 1 : 0;
 754                 status->color = (status_reg & SAA7191_STATUS_CODE) ? 1 : 0;
 755
 756                 status->input = decoder->input;
 757                 status->norm = decoder->norm;
 758
 759                 break;
 760         }
 761         case DECODER_SAA7191_SET_NORM: {
 762                 int *norm = arg;
 763
 764                 switch (*norm) {
 765                 case SAA7191_NORM_AUTO:
 766                         return saa7191_autodetect_norm(client);
 767                 case SAA7191_NORM_AUTO_EXT:
 768                         return saa7191_autodetect_norm_extended(client);
 769                 default:
 770                         return saa7191_set_norm(client, *norm);
 771                 }
 772         }
 773         case DECODER_SAA7191_GET_CONTROL: {
 774                 return saa7191_get_control(client, arg);
 775         }
 776         case DECODER_SAA7191_SET_CONTROL: {
 777                 return saa7191_set_control(client, arg);
 778         }
 779         default:
 780                 return -EINVAL;
 781         }
 782
 783         return 0;
 784 }
 785
 786 static struct i2c_driver i2c_driver_saa7191 = {
 787         .driver = {
 788                 .name   = "saa7191",
 789         },
 790         .id             = I2C_DRIVERID_SAA7191,
 791         .attach_adapter = saa7191_probe,
 792         .detach_client  = saa7191_detach,
 793         .command        = saa7191_command
 794 };
 795
 796 static int saa7191_init(void)
 797 {
 798         return i2c_add_driver(&i2c_driver_saa7191);
 799 }
 800
 801 static void saa7191_exit(void)
 802 {
 803         i2c_del_driver(&i2c_driver_saa7191);
 804 }
 805
 806 module_init(saa7191_init);
 807 module_exit(saa7191_exit);