SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/saa7127.c

   1 /*
   2  * saa7127 - Philips SAA7127/SAA7129 video encoder driver
   3  *
   4  * Copyright (C) 2003 Roy Bulter <rbulter@hetnet.nl>
   5  *
   6  * Based on SAA7126 video encoder driver by Gillem & Andreas Oberritter
   7  *
   8  * Copyright (C) 2000-2001 Gillem <htoa@gmx.net>
   9  * Copyright (C) 2002 Andreas Oberritter <obi@saftware.de>
  10  *
  11  * Based on Stadis 4:2:2 MPEG-2 Decoder Driver by Nathan Laredo
  12  *
  13  * Copyright (C) 1999 Nathan Laredo <laredo@gnu.org>
  14  *
  15  * This driver is designed for the Hauppauge 250/350 Linux driver
  16  * from the ivtv Project
  17  *
  18  * Copyright (C) 2003 Kevin Thayer <nufan_wfk@yahoo.com>
  19  *
  20  * Dual output support:
  21  * Copyright (C) 2004 Eric Varsanyi
  22  *
  23  * NTSC Tuning and 7.5 IRE Setup
  24  * Copyright (C) 2004  Chris Kennedy <c@groovy.org>
  25  *
  26  * VBI additions & cleanup:
  27  * Copyright (C) 2004, 2005 Hans Verkuil <hverkuil@xs4all.nl>
  28  *
  29  * Note: the saa7126 is identical to the saa7127, and the saa7128 is
  30  * identical to the saa7129, except that the saa7126 and saa7128 have
  31  * macrovision anti-taping support. This driver will almost certainly
  32  * work find for those chips, except of course for the missing anti-taping
  33  * support.
  34  *
  35  * This program is free software; you can redistribute it and/or modify
  36  * it under the terms of the GNU General Public License as published by
  37  * the Free Software Foundation; either version 2 of the License, or
  38  * (at your option) any later version.
  39  *
  40  * This program is distributed in the hope that it will be useful,
  41  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  42  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  43  * GNU General Public License for more details.
  44  *
  45  * You should have received a copy of the GNU General Public License
  46  * along with this program; if not, write to the Free Software
  47  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  48  */
  49
  50
  51 #include <linux/kernel.h>
  52 #include <linux/module.h>
  53 #include <linux/slab.h>
  54 #include <linux/i2c.h>
  55 #include <linux/videodev2.h>
  56 #include <media/v4l2-common.h>
  57
  58 static int debug = 0;
  59 static int test_image = 0;
  60
  61 MODULE_DESCRIPTION("Philips SAA7127/9 video encoder driver");
  62 MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");
  63 MODULE_LICENSE("GPL");
  64 module_param(debug, int, 0644);
  65 module_param(test_image, int, 0644);
  66 MODULE_PARM_DESC(debug, "debug level (0-2)");
  67 MODULE_PARM_DESC(test_image, "test_image (0-1)");
  68
  69 #define saa7127_dbg(fmt, arg...) \
  70         do { \
  71                 if (debug >= 1) \
  72                         printk(KERN_INFO "%s debug %d-%04x: " fmt, \
  73                                client->driver->driver.name, \
  74                                i2c_adapter_id(client->adapter), client->addr , ## arg); \
  75         } while (0)
  76
  77 /* High volume debug. Use with care. */
  78 #define saa7127_dbg_highvol(fmt, arg...) \
  79         do { \
  80                 if (debug == 2) \
  81                         printk(KERN_INFO "%s debug %d-%04x: " fmt, \
  82                                client->driver->driver.name, \
  83                                i2c_adapter_id(client->adapter), client->addr , ## arg); \
  84         } while (0)
  85
  86 #define saa7127_err(fmt, arg...) do { \
  87         printk(KERN_ERR "%s %d-%04x: " fmt, client->driver->driver.name, \
  88                i2c_adapter_id(client->adapter), client->addr , ## arg); } while (0)
  89 #define saa7127_info(fmt, arg...) do { \
  90         printk(KERN_INFO "%s %d-%04x: " fmt, client->driver->driver.name, \
  91                i2c_adapter_id(client->adapter), client->addr , ## arg); } while (0)
  92
  93 static unsigned short normal_i2c[] = { 0x88 >> 1, I2C_CLIENT_END };
  94
  95
  96 I2C_CLIENT_INSMOD;
  97
  98 /*
  99  * SAA7127 registers
 100  */
 101
 102 #define SAA7127_REG_STATUS                           0x00
 103 #define SAA7127_REG_WIDESCREEN_CONFIG                0x26
 104 #define SAA7127_REG_WIDESCREEN_ENABLE                0x27
 105 #define SAA7127_REG_BURST_START                      0x28
 106 #define SAA7127_REG_BURST_END                        0x29
 107 #define SAA7127_REG_COPYGEN_0                        0x2a
 108 #define SAA7127_REG_COPYGEN_1                        0x2b
 109 #define SAA7127_REG_COPYGEN_2                        0x2c
 110 #define SAA7127_REG_OUTPUT_PORT_CONTROL              0x2d
 111 #define SAA7127_REG_GAIN_LUMINANCE_RGB               0x38
 112 #define SAA7127_REG_GAIN_COLORDIFF_RGB               0x39
 113 #define SAA7127_REG_INPUT_PORT_CONTROL_1             0x3a
 114 #define SAA7129_REG_FADE_KEY_COL2                    0x4f
 115 #define SAA7127_REG_CHROMA_PHASE                     0x5a
 116 #define SAA7127_REG_GAINU                            0x5b
 117 #define SAA7127_REG_GAINV                            0x5c
 118 #define SAA7127_REG_BLACK_LEVEL                      0x5d
 119 #define SAA7127_REG_BLANKING_LEVEL                   0x5e
 120 #define SAA7127_REG_VBI_BLANKING                     0x5f
 121 #define SAA7127_REG_DAC_CONTROL                      0x61
 122 #define SAA7127_REG_BURST_AMP                        0x62
 123 #define SAA7127_REG_SUBC3                            0x63
 124 #define SAA7127_REG_SUBC2                            0x64
 125 #define SAA7127_REG_SUBC1                            0x65
 126 #define SAA7127_REG_SUBC0                            0x66
 127 #define SAA7127_REG_LINE_21_ODD_0                    0x67
 128 #define SAA7127_REG_LINE_21_ODD_1                    0x68
 129 #define SAA7127_REG_LINE_21_EVEN_0                   0x69
 130 #define SAA7127_REG_LINE_21_EVEN_1                   0x6a
 131 #define SAA7127_REG_RCV_PORT_CONTROL                 0x6b
 132 #define SAA7127_REG_VTRIG                            0x6c
 133 #define SAA7127_REG_HTRIG_HI                         0x6d
 134 #define SAA7127_REG_MULTI                            0x6e
 135 #define SAA7127_REG_CLOSED_CAPTION                   0x6f
 136 #define SAA7127_REG_RCV2_OUTPUT_START                0x70
 137 #define SAA7127_REG_RCV2_OUTPUT_END                  0x71
 138 #define SAA7127_REG_RCV2_OUTPUT_MSBS                 0x72
 139 #define SAA7127_REG_TTX_REQUEST_H_START              0x73
 140 #define SAA7127_REG_TTX_REQUEST_H_DELAY_LENGTH       0x74
 141 #define SAA7127_REG_CSYNC_ADVANCE_VSYNC_SHIFT        0x75
 142 #define SAA7127_REG_TTX_ODD_REQ_VERT_START           0x76
 143 #define SAA7127_REG_TTX_ODD_REQ_VERT_END             0x77
 144 #define SAA7127_REG_TTX_EVEN_REQ_VERT_START          0x78
 145 #define SAA7127_REG_TTX_EVEN_REQ_VERT_END            0x79
 146 #define SAA7127_REG_FIRST_ACTIVE                     0x7a
 147 #define SAA7127_REG_LAST_ACTIVE                      0x7b
 148 #define SAA7127_REG_MSB_VERTICAL                     0x7c
 149 #define SAA7127_REG_DISABLE_TTX_LINE_LO_0            0x7e
 150 #define SAA7127_REG_DISABLE_TTX_LINE_LO_1            0x7f
 151
 152 /*
 153  **********************************************************************
 154  *
 155  *  Arrays with configuration parameters for the SAA7127
 156  *
 157  **********************************************************************
 158  */
 159
 160 struct i2c_reg_value {
 161         unsigned char reg;
 162         unsigned char value;
 163 };
 164
 165 static const struct i2c_reg_value saa7129_init_config_extra[] = {
 166         { SAA7127_REG_OUTPUT_PORT_CONTROL,              0x38 },
 167         { SAA7127_REG_VTRIG,                            0xfa },
 168 };
 169
 170 static const struct i2c_reg_value saa7127_init_config_common[] = {
 171         { SAA7127_REG_WIDESCREEN_CONFIG,                0x0d },
 172         { SAA7127_REG_WIDESCREEN_ENABLE,                0x00 },
 173         { SAA7127_REG_COPYGEN_0,                        0x77 },
 174         { SAA7127_REG_COPYGEN_1,                        0x41 },
 175         { SAA7127_REG_COPYGEN_2,                        0x00 }, /* Macrovision enable/disable */
 176         { SAA7127_REG_OUTPUT_PORT_CONTROL,              0x9e },
 177         { SAA7127_REG_GAIN_LUMINANCE_RGB,               0x00 },
 178         { SAA7127_REG_GAIN_COLORDIFF_RGB,               0x00 },
 179         { SAA7127_REG_INPUT_PORT_CONTROL_1,             0x80 }, /* for color bars */
 180         { SAA7127_REG_LINE_21_ODD_0,                    0x77 },
 181         { SAA7127_REG_LINE_21_ODD_1,                    0x41 },
 182         { SAA7127_REG_LINE_21_EVEN_0,                   0x88 },
 183         { SAA7127_REG_LINE_21_EVEN_1,                   0x41 },
 184         { SAA7127_REG_RCV_PORT_CONTROL,                 0x12 },
 185         { SAA7127_REG_VTRIG,                            0xf9 },
 186         { SAA7127_REG_HTRIG_HI,                         0x00 },
 187         { SAA7127_REG_RCV2_OUTPUT_START,                0x41 },
 188         { SAA7127_REG_RCV2_OUTPUT_END,                  0xc3 },
 189         { SAA7127_REG_RCV2_OUTPUT_MSBS,                 0x00 },
 190         { SAA7127_REG_TTX_REQUEST_H_START,              0x3e },
 191         { SAA7127_REG_TTX_REQUEST_H_DELAY_LENGTH,       0xb8 },
 192         { SAA7127_REG_CSYNC_ADVANCE_VSYNC_SHIFT,        0x03 },
 193         { SAA7127_REG_TTX_ODD_REQ_VERT_START,           0x15 },
 194         { SAA7127_REG_TTX_ODD_REQ_VERT_END,             0x16 },
 195         { SAA7127_REG_TTX_EVEN_REQ_VERT_START,          0x15 },
 196         { SAA7127_REG_TTX_EVEN_REQ_VERT_END,            0x16 },
 197         { SAA7127_REG_FIRST_ACTIVE,                     0x1a },
 198         { SAA7127_REG_LAST_ACTIVE,                      0x01 },
 199         { SAA7127_REG_MSB_VERTICAL,                     0xc0 },
 200         { SAA7127_REG_DISABLE_TTX_LINE_LO_0,            0x00 },
 201         { SAA7127_REG_DISABLE_TTX_LINE_LO_1,            0x00 },
 202         { 0, 0 }
 203 };
 204
 205 #define SAA7127_60HZ_DAC_CONTROL 0x15
 206 static const struct i2c_reg_value saa7127_init_config_60hz[] = {
 207         { SAA7127_REG_BURST_START,                      0x19 },
 208         /* BURST_END is also used as a chip ID in saa7127_detect_client */
 209         { SAA7127_REG_BURST_END,                        0x1d },
 210         { SAA7127_REG_CHROMA_PHASE,                     0xa3 },
 211         { SAA7127_REG_GAINU,                            0x98 },
 212         { SAA7127_REG_GAINV,                            0xd3 },
 213         { SAA7127_REG_BLACK_LEVEL,                      0x39 },
 214         { SAA7127_REG_BLANKING_LEVEL,                   0x2e },
 215         { SAA7127_REG_VBI_BLANKING,                     0x2e },
 216         { SAA7127_REG_DAC_CONTROL,                      0x15 },
 217         { SAA7127_REG_BURST_AMP,                        0x4d },
 218         { SAA7127_REG_SUBC3,                            0x1f },
 219         { SAA7127_REG_SUBC2,                            0x7c },
 220         { SAA7127_REG_SUBC1,                            0xf0 },
 221         { SAA7127_REG_SUBC0,                            0x21 },
 222         { SAA7127_REG_MULTI,                            0x90 },
 223         { SAA7127_REG_CLOSED_CAPTION,                   0x11 },
 224         { 0, 0 }
 225 };
 226
 227 #define SAA7127_50HZ_DAC_CONTROL 0x02
 228 static struct i2c_reg_value saa7127_init_config_50hz[] = {
 229         { SAA7127_REG_BURST_START,                      0x21 },
 230         /* BURST_END is also used as a chip ID in saa7127_detect_client */
 231         { SAA7127_REG_BURST_END,                        0x1d },
 232         { SAA7127_REG_CHROMA_PHASE,                     0x3f },
 233         { SAA7127_REG_GAINU,                            0x7d },
 234         { SAA7127_REG_GAINV,                            0xaf },
 235         { SAA7127_REG_BLACK_LEVEL,                      0x33 },
 236         { SAA7127_REG_BLANKING_LEVEL,                   0x35 },
 237         { SAA7127_REG_VBI_BLANKING,                     0x35 },
 238         { SAA7127_REG_DAC_CONTROL,                      0x02 },
 239         { SAA7127_REG_BURST_AMP,                        0x2f },
 240         { SAA7127_REG_SUBC3,                            0xcb },
 241         { SAA7127_REG_SUBC2,                            0x8a },
 242         { SAA7127_REG_SUBC1,                            0x09 },
 243         { SAA7127_REG_SUBC0,                            0x2a },
 244         { SAA7127_REG_MULTI,                            0xa0 },
 245         { SAA7127_REG_CLOSED_CAPTION,                   0x00 },
 246         { 0, 0 }
 247 };
 248
 249 /* Enumeration for the Supported input types */
 250 enum saa7127_input_type {
 251         SAA7127_INPUT_TYPE_NORMAL,
 252         SAA7127_INPUT_TYPE_TEST_IMAGE
 253 };
 254
 255 /* Enumeration for the Supported Output signal types */
 256 enum saa7127_output_type {
 257         SAA7127_OUTPUT_TYPE_BOTH,
 258         SAA7127_OUTPUT_TYPE_COMPOSITE,
 259         SAA7127_OUTPUT_TYPE_SVIDEO,
 260         SAA7127_OUTPUT_TYPE_RGB,
 261         SAA7127_OUTPUT_TYPE_YUV_C,
 262         SAA7127_OUTPUT_TYPE_YUV_V
 263 };
 264
 265 /*
 266  **********************************************************************
 267  *
 268  *  Encoder Struct, holds the configuration state of the encoder
 269  *
 270  **********************************************************************
 271  */
 272
 273 struct saa7127_state {
 274         v4l2_std_id std;
 275         enum v4l2_chip_ident ident;
 276         enum saa7127_input_type input_type;
 277         enum saa7127_output_type output_type;
 278         int video_enable;
 279         int wss_enable;
 280         u16 wss_mode;
 281         int cc_enable;
 282         u16 cc_data;
 283         int xds_enable;
 284         u16 xds_data;
 285         int vps_enable;
 286         u8 vps_data[5];
 287         u8 reg_2d;
 288         u8 reg_3a;
 289         u8 reg_3a_cb;   /* colorbar bit */
 290         u8 reg_61;
 291 };
 292
 293 static const char * const output_strs[] =
 294 {
 295         "S-Video + Composite",
 296         "Composite",
 297         "S-Video",
 298         "RGB",
 299         "YUV C",
 300         "YUV V"
 301 };
 302
 303 static const char * const wss_strs[] = {
 304         "invalid",
 305         "letterbox 14:9 center",
 306         "letterbox 14:9 top",
 307         "invalid",
 308         "letterbox 16:9 top",
 309         "invalid",
 310         "invalid",
 311         "16:9 full format anamorphic"
 312         "4:3 full format",
 313         "invalid",
 314         "invalid",
 315         "letterbox 16:9 center",
 316         "invalid",
 317         "letterbox >16:9 center",
 318         "14:9 full format center",
 319         "invalid",
 320 };
 321
 322 /* ----------------------------------------------------------------------- */
 323
 324 static int saa7127_read(struct i2c_client *client, u8 reg)
 325 {
 326         return i2c_smbus_read_byte_data(client, reg);
 327 }
 328
 329 /* ----------------------------------------------------------------------- */
 330
 331 static int saa7127_write(struct i2c_client *client, u8 reg, u8 val)
 332 {
 333         int i;
 334
 335         for (i = 0; i < 3; i++) {
 336                 if (i2c_smbus_write_byte_data(client, reg, val) == 0)
 337                         return 0;
 338         }
 339         saa7127_err("I2C Write Problem\n");
 340         return -1;
 341 }
 342
 343 /* ----------------------------------------------------------------------- */
 344
 345 static int saa7127_write_inittab(struct i2c_client *client,
 346                                  const struct i2c_reg_value *regs)
 347 {
 348         while (regs->reg != 0) {
 349                 saa7127_write(client, regs->reg, regs->value);
 350                 regs++;
 351         }
 352         return 0;
 353 }
 354
 355 /* ----------------------------------------------------------------------- */
 356
 357 static int saa7127_set_vps(struct i2c_client *client, struct v4l2_sliced_vbi_data *data)
 358 {
 359         struct saa7127_state *state = i2c_get_clientdata(client);
 360         int enable = (data->line != 0);
 361
 362         if (enable && (data->field != 0 || data->line != 16))
 363                 return -EINVAL;
 364         if (state->vps_enable != enable) {
 365                 saa7127_dbg("Turn VPS Signal %s\n", enable ? "on" : "off");
 366                 saa7127_write(client, 0x54, enable << 7);
 367                 state->vps_enable = enable;
 368         }
 369         if (!enable)
 370                 return 0;
 371
 372         state->vps_data[0] = data->data[4];
 373         state->vps_data[1] = data->data[10];
 374         state->vps_data[2] = data->data[11];
 375         state->vps_data[3] = data->data[12];
 376         state->vps_data[4] = data->data[13];
 377         saa7127_dbg("Set VPS data %02x %02x %02x %02x %02x\n",
 378                 state->vps_data[0], state->vps_data[1],
 379                 state->vps_data[2], state->vps_data[3],
 380                 state->vps_data[4]);
 381         saa7127_write(client, 0x55, state->vps_data[0]);
 382         saa7127_write(client, 0x56, state->vps_data[1]);
 383         saa7127_write(client, 0x57, state->vps_data[2]);
 384         saa7127_write(client, 0x58, state->vps_data[3]);
 385         saa7127_write(client, 0x59, state->vps_data[4]);
 386         return 0;
 387 }
 388
 389 /* ----------------------------------------------------------------------- */
 390
 391 static int saa7127_set_cc(struct i2c_client *client, struct v4l2_sliced_vbi_data *data)
 392 {
 393         struct saa7127_state *state = i2c_get_clientdata(client);
 394         u16 cc = data->data[1] << 8 | data->data[0];
 395         int enable = (data->line != 0);
 396
 397         if (enable && (data->field != 0 || data->line != 21))
 398                 return -EINVAL;
 399         if (state->cc_enable != enable) {
 400                 saa7127_dbg("Turn CC %s\n", enable ? "on" : "off");
 401                 saa7127_write(client, SAA7127_REG_CLOSED_CAPTION,
 402                                 (state->xds_enable << 7) | (enable << 6) | 0x11);
 403                 state->cc_enable = enable;
 404         }
 405         if (!enable)
 406                 return 0;
 407
 408         saa7127_dbg_highvol("CC data: %04x\n", cc);
 409         saa7127_write(client, SAA7127_REG_LINE_21_ODD_0, cc & 0xff);
 410         saa7127_write(client, SAA7127_REG_LINE_21_ODD_1, cc >> 8);
 411         state->cc_data = cc;
 412         return 0;
 413 }
 414
 415 /* ----------------------------------------------------------------------- */
 416
 417 static int saa7127_set_xds(struct i2c_client *client, struct v4l2_sliced_vbi_data *data)
 418 {
 419         struct saa7127_state *state = i2c_get_clientdata(client);
 420         u16 xds = data->data[1] << 8 | data->data[0];
 421         int enable = (data->line != 0);
 422
 423         if (enable && (data->field != 1 || data->line != 21))
 424                 return -EINVAL;
 425         if (state->xds_enable != enable) {
 426                 saa7127_dbg("Turn XDS %s\n", enable ? "on" : "off");
 427                 saa7127_write(client, SAA7127_REG_CLOSED_CAPTION,
 428                                 (enable << 7) | (state->cc_enable << 6) | 0x11);
 429                 state->xds_enable = enable;
 430         }
 431         if (!enable)
 432                 return 0;
 433
 434         saa7127_dbg_highvol("XDS data: %04x\n", xds);
 435         saa7127_write(client, SAA7127_REG_LINE_21_EVEN_0, xds & 0xff);
 436         saa7127_write(client, SAA7127_REG_LINE_21_EVEN_1, xds >> 8);
 437         state->xds_data = xds;
 438         return 0;
 439 }
 440
 441 /* ----------------------------------------------------------------------- */
 442
 443 static int saa7127_set_wss(struct i2c_client *client, struct v4l2_sliced_vbi_data *data)
 444 {
 445         struct saa7127_state *state = i2c_get_clientdata(client);
 446         int enable = (data->line != 0);
 447
 448         if (enable && (data->field != 0 || data->line != 23))
 449                 return -EINVAL;
 450         if (state->wss_enable != enable) {
 451                 saa7127_dbg("Turn WSS %s\n", enable ? "on" : "off");
 452                 saa7127_write(client, 0x27, enable << 7);
 453                 state->wss_enable = enable;
 454         }
 455         if (!enable)
 456                 return 0;
 457
 458         saa7127_write(client, 0x26, data->data[0]);
 459         saa7127_write(client, 0x27, 0x80 | (data->data[1] & 0x3f));
 460         saa7127_dbg("WSS mode: %s\n", wss_strs[data->data[0] & 0xf]);
 461         state->wss_mode = (data->data[1] & 0x3f) << 8 | data->data[0];
 462         return 0;
 463 }
 464
 465 /* ----------------------------------------------------------------------- */
 466
 467 static int saa7127_set_video_enable(struct i2c_client *client, int enable)
 468 {
 469         struct saa7127_state *state = i2c_get_clientdata(client);
 470
 471         if (enable) {
 472                 saa7127_dbg("Enable Video Output\n");
 473                 saa7127_write(client, 0x2d, state->reg_2d);
 474                 saa7127_write(client, 0x61, state->reg_61);
 475         } else {
 476                 saa7127_dbg("Disable Video Output\n");
 477                 saa7127_write(client, 0x2d, (state->reg_2d & 0xf0));
 478                 saa7127_write(client, 0x61, (state->reg_61 | 0xc0));
 479         }
 480         state->video_enable = enable;
 481         return 0;
 482 }
 483
 484 /* ----------------------------------------------------------------------- */
 485
 486 static int saa7127_set_std(struct i2c_client *client, v4l2_std_id std)
 487 {
 488         struct saa7127_state *state = i2c_get_clientdata(client);
 489         const struct i2c_reg_value *inittab;
 490
 491         if (std & V4L2_STD_525_60) {
 492                 saa7127_dbg("Selecting 60 Hz video Standard\n");
 493                 inittab = saa7127_init_config_60hz;
 494                 state->reg_61 = SAA7127_60HZ_DAC_CONTROL;
 495         } else {
 496                 saa7127_dbg("Selecting 50 Hz video Standard\n");
 497                 inittab = saa7127_init_config_50hz;
 498                 state->reg_61 = SAA7127_50HZ_DAC_CONTROL;
 499         }
 500
 501         /* Write Table */
 502         saa7127_write_inittab(client, inittab);
 503         state->std = std;
 504         return 0;
 505 }
 506
 507 /* ----------------------------------------------------------------------- */
 508
 509 static int saa7127_set_output_type(struct i2c_client *client, int output)
 510 {
 511         struct saa7127_state *state = i2c_get_clientdata(client);
 512
 513         switch (output) {
 514         case SAA7127_OUTPUT_TYPE_RGB:
 515                 state->reg_2d = 0x0f;   /* RGB + CVBS (for sync) */
 516                 state->reg_3a = 0x13;   /* by default switch YUV to RGB-matrix on */
 517                 break;
 518
 519         case SAA7127_OUTPUT_TYPE_COMPOSITE:
 520                 state->reg_2d = 0x08;   /* 00001000 CVBS only, RGB DAC's off (high impedance mode) */
 521                 state->reg_3a = 0x13;   /* by default switch YUV to RGB-matrix on */
 522                 break;
 523
 524         case SAA7127_OUTPUT_TYPE_SVIDEO:
 525                 state->reg_2d = 0xff;   /* 11111111  croma -> R, luma -> CVBS + G + B */
 526                 state->reg_3a = 0x13;   /* by default switch YUV to RGB-matrix on */
 527                 break;
 528
 529         case SAA7127_OUTPUT_TYPE_YUV_V:
 530                 state->reg_2d = 0x4f;   /* reg 2D = 01001111, all DAC's on, RGB + VBS */
 531                 state->reg_3a = 0x0b;   /* reg 3A = 00001011, bypass RGB-matrix */
 532                 break;
 533
 534         case SAA7127_OUTPUT_TYPE_YUV_C:
 535                 state->reg_2d = 0x0f;   /* reg 2D = 00001111, all DAC's on, RGB + CVBS */
 536                 state->reg_3a = 0x0b;   /* reg 3A = 00001011, bypass RGB-matrix */
 537                 break;
 538
 539         case SAA7127_OUTPUT_TYPE_BOTH:
 540                 state->reg_2d = 0xbf;
 541                 state->reg_3a = 0x13;   /* by default switch YUV to RGB-matrix on */
 542                 break;
 543
 544         default:
 545                 return -EINVAL;
 546         }
 547         saa7127_dbg("Selecting %s output type\n", output_strs[output]);
 548
 549         /* Configure Encoder */
 550         saa7127_write(client, 0x2d, state->reg_2d);
 551         saa7127_write(client, 0x3a, state->reg_3a | state->reg_3a_cb);
 552         state->output_type = output;
 553         return 0;
 554 }
 555
 556 /* ----------------------------------------------------------------------- */
 557
 558 static int saa7127_set_input_type(struct i2c_client *client, int input)
 559 {
 560         struct saa7127_state *state = i2c_get_clientdata(client);
 561
 562         switch (input) {
 563         case SAA7127_INPUT_TYPE_NORMAL: /* avia */
 564                 saa7127_dbg("Selecting Normal Encoder Input\n");
 565                 state->reg_3a_cb = 0;
 566                 break;
 567
 568         case SAA7127_INPUT_TYPE_TEST_IMAGE:     /* color bar */
 569                 saa7127_dbg("Selecting Color Bar generator\n");
 570                 state->reg_3a_cb = 0x80;
 571                 break;
 572
 573         default:
 574                 return -EINVAL;
 575         }
 576         saa7127_write(client, 0x3a, state->reg_3a | state->reg_3a_cb);
 577         state->input_type = input;
 578         return 0;
 579 }
 580
 581 /* ----------------------------------------------------------------------- */
 582
 583 static int saa7127_command(struct i2c_client *client,
 584                            unsigned int cmd, void *arg)
 585 {
 586         struct saa7127_state *state = i2c_get_clientdata(client);
 587         struct v4l2_format *fmt = arg;
 588         int *iarg = arg;
 589
 590         switch (cmd) {
 591         case VIDIOC_S_STD:
 592                 if (state->std == *(v4l2_std_id *)arg)
 593                         break;
 594                 return saa7127_set_std(client, *(v4l2_std_id *)arg);
 595
 596         case VIDIOC_G_STD:
 597                 *(v4l2_std_id *)arg = state->std;
 598                 break;
 599
 600         case VIDIOC_S_INPUT:
 601                 if (state->input_type == *iarg)
 602                         break;
 603                 return saa7127_set_input_type(client, *iarg);
 604
 605         case VIDIOC_S_OUTPUT:
 606                 if (state->output_type == *iarg)
 607                         break;
 608                 return saa7127_set_output_type(client, *iarg);
 609
 610         case VIDIOC_STREAMON:
 611         case VIDIOC_STREAMOFF:
 612                 if (state->video_enable == (cmd == VIDIOC_STREAMON))
 613                         break;
 614                 return saa7127_set_video_enable(client, cmd == VIDIOC_STREAMON);
 615
 616         case VIDIOC_G_FMT:
 617                 if (fmt->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
 618                         return -EINVAL;
 619
 620                 memset(&fmt->fmt.sliced, 0, sizeof(fmt->fmt.sliced));
 621                 if (state->vps_enable)
 622                         fmt->fmt.sliced.service_lines[0][16] = V4L2_SLICED_VPS;
 623                 if (state->wss_enable)
 624                         fmt->fmt.sliced.service_lines[0][23] = V4L2_SLICED_WSS_625;
 625                 if (state->cc_enable) {
 626                         fmt->fmt.sliced.service_lines[0][21] = V4L2_SLICED_CAPTION_525;
 627                         fmt->fmt.sliced.service_lines[1][21] = V4L2_SLICED_CAPTION_525;
 628                 }
 629                 fmt->fmt.sliced.service_set =
 630                         (state->vps_enable ? V4L2_SLICED_VPS : 0) |
 631                         (state->wss_enable ? V4L2_SLICED_WSS_625 : 0) |
 632                         (state->cc_enable ? V4L2_SLICED_CAPTION_525 : 0);
 633                 break;
 634
 635         case VIDIOC_LOG_STATUS:
 636                 saa7127_info("Standard: %s\n", (state->std & V4L2_STD_525_60) ? "60 Hz" : "50 Hz");
 637                 saa7127_info("Input:    %s\n", state->input_type ?  "color bars" : "normal");
 638                 saa7127_info("Output:   %s\n", state->video_enable ?
 639                         output_strs[state->output_type] : "disabled");
 640                 saa7127_info("WSS:      %s\n", state->wss_enable ?
 641                         wss_strs[state->wss_mode] : "disabled");
 642                 saa7127_info("VPS:      %s\n", state->vps_enable ? "enabled" : "disabled");
 643                 saa7127_info("CC:       %s\n", state->cc_enable ? "enabled" : "disabled");
 644                 break;
 645
 646 #ifdef CONFIG_VIDEO_ADV_DEBUG
 647         case VIDIOC_INT_G_REGISTER:
 648         {
 649                 struct v4l2_register *reg = arg;
 650
 651                 if (reg->i2c_id != I2C_DRIVERID_SAA7127)
 652                         return -EINVAL;
 653                 reg->val = saa7127_read(client, reg->reg & 0xff);
 654                 break;
 655         }
 656
 657         case VIDIOC_INT_S_REGISTER:
 658         {
 659                 struct v4l2_register *reg = arg;
 660
 661                 if (reg->i2c_id != I2C_DRIVERID_SAA7127)
 662                         return -EINVAL;
 663                 if (!capable(CAP_SYS_ADMIN))
 664                         return -EPERM;
 665                 saa7127_write(client, reg->reg & 0xff, reg->val & 0xff);
 666                 break;
 667         }
 668 #endif
 669
 670         case VIDIOC_INT_S_VBI_DATA:
 671         {
 672                 struct v4l2_sliced_vbi_data *data = arg;
 673
 674                 switch (data->id) {
 675                         case V4L2_SLICED_WSS_625:
 676                                 return saa7127_set_wss(client, data);
 677                         case V4L2_SLICED_VPS:
 678                                 return saa7127_set_vps(client, data);
 679                         case V4L2_SLICED_CAPTION_525:
 680                                 if (data->field == 0)
 681                                         return saa7127_set_cc(client, data);
 682                                 return saa7127_set_xds(client, data);
 683                         default:
 684                                 return -EINVAL;
 685                 }
 686                 break;
 687         }
 688
 689         case VIDIOC_INT_G_CHIP_IDENT:
 690                 *(enum v4l2_chip_ident *)arg = state->ident;
 691                 break;
 692
 693         default:
 694                 return -EINVAL;
 695         }
 696         return 0;
 697 }
 698
 699 /* ----------------------------------------------------------------------- */
 700
 701 static struct i2c_driver i2c_driver_saa7127;
 702
 703 /* ----------------------------------------------------------------------- */
 704
 705 static int saa7127_attach(struct i2c_adapter *adapter, int address, int kind)
 706 {
 707         struct i2c_client *client;
 708         struct saa7127_state *state;
 709         struct v4l2_sliced_vbi_data vbi = { 0, 0, 0, 0 };  /* set to disabled */
 710         int read_result = 0;
 711
 712         /* Check if the adapter supports the needed features */
 713         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 714                 return 0;
 715
 716         client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
 717         if (client == 0)
 718                 return -ENOMEM;
 719
 720         memset(client, 0, sizeof(struct i2c_client));
 721         client->addr = address;
 722         client->adapter = adapter;
 723         client->driver = &i2c_driver_saa7127;
 724         snprintf(client->name, sizeof(client->name) - 1, "saa7127");
 725
 726         saa7127_dbg("detecting saa7127 client on address 0x%x\n", address << 1);
 727
 728         /* First test register 0: Bits 5-7 are a version ID (should be 0),
 729            and bit 2 should also be 0.
 730            This is rather general, so the second test is more specific and
 731            looks at the 'ending point of burst in clock cycles' which is
 732            0x1d after a reset and not expected to ever change. */
 733         if ((saa7127_read(client, 0) & 0xe4) != 0 ||
 734                         (saa7127_read(client, 0x29) & 0x3f) != 0x1d) {
 735                 saa7127_dbg("saa7127 not found\n");
 736                 kfree(client);
 737                 return 0;
 738         }
 739         state = kmalloc(sizeof(struct saa7127_state), GFP_KERNEL);
 740
 741         if (state == NULL) {
 742                 kfree(client);
 743                 return (-ENOMEM);
 744         }
 745
 746         i2c_set_clientdata(client, state);
 747         memset(state, 0, sizeof(struct saa7127_state));
 748
 749         /* Configure Encoder */
 750
 751         saa7127_dbg("Configuring encoder\n");
 752         saa7127_write_inittab(client, saa7127_init_config_common);
 753         saa7127_set_std(client, V4L2_STD_NTSC);
 754         saa7127_set_output_type(client, SAA7127_OUTPUT_TYPE_BOTH);
 755         saa7127_set_vps(client, &vbi);
 756         saa7127_set_wss(client, &vbi);
 757         saa7127_set_cc(client, &vbi);
 758         saa7127_set_xds(client, &vbi);
 759         if (test_image == 1) {
 760                 /* The Encoder has an internal Colorbar generator */
 761                 /* This can be used for debugging */
 762                 saa7127_set_input_type(client, SAA7127_INPUT_TYPE_TEST_IMAGE);
 763         } else {
 764                 saa7127_set_input_type(client, SAA7127_INPUT_TYPE_NORMAL);
 765         }
 766         saa7127_set_video_enable(client, 1);
 767
 768         /* Detect if it's an saa7129 */
 769         read_result = saa7127_read(client, SAA7129_REG_FADE_KEY_COL2);
 770         saa7127_write(client, SAA7129_REG_FADE_KEY_COL2, 0xaa);
 771         if (saa7127_read(client, SAA7129_REG_FADE_KEY_COL2) == 0xaa) {
 772                 saa7127_info("saa7129 found @ 0x%x (%s)\n", address << 1, adapter->name);
 773                 saa7127_write(client, SAA7129_REG_FADE_KEY_COL2, read_result);
 774                 saa7127_write_inittab(client, saa7129_init_config_extra);
 775                 state->ident = V4L2_IDENT_SAA7129;
 776         } else {
 777                 saa7127_info("saa7127 found @ 0x%x (%s)\n", address << 1, adapter->name);
 778                 state->ident = V4L2_IDENT_SAA7127;
 779         }
 780
 781         i2c_attach_client(client);
 782
 783         return 0;
 784 }
 785
 786 /* ----------------------------------------------------------------------- */
 787
 788 static int saa7127_probe(struct i2c_adapter *adapter)
 789 {
 790         if (adapter->class & I2C_CLASS_TV_ANALOG)
 791                 return i2c_probe(adapter, &addr_data, saa7127_attach);
 792         return 0;
 793 }
 794
 795 /* ----------------------------------------------------------------------- */
 796
 797 static int saa7127_detach(struct i2c_client *client)
 798 {
 799         struct saa7127_state *state = i2c_get_clientdata(client);
 800         int err;
 801
 802         /* Turn off TV output */
 803         saa7127_set_video_enable(client, 0);
 804
 805         err = i2c_detach_client(client);
 806
 807         if (err) {
 808                 return err;
 809         }
 810
 811         kfree(state);
 812         kfree(client);
 813         return 0;
 814 }
 815
 816 /* ----------------------------------------------------------------------- */
 817
 818 static struct i2c_driver i2c_driver_saa7127 = {
 819         .driver = {
 820                 .name = "saa7127",
 821         },
 822         .id = I2C_DRIVERID_SAA7127,
 823         .attach_adapter = saa7127_probe,
 824         .detach_client = saa7127_detach,
 825         .command = saa7127_command,
 826 };
 827
 828
 829 /* ----------------------------------------------------------------------- */
 830
 831 static int __init saa7127_init_module(void)
 832 {
 833         return i2c_add_driver(&i2c_driver_saa7127);
 834 }
 835
 836 /* ----------------------------------------------------------------------- */
 837
 838 static void __exit saa7127_cleanup_module(void)
 839 {
 840         i2c_del_driver(&i2c_driver_saa7127);
 841 }
 842
 843 /* ----------------------------------------------------------------------- */
 844
 845 module_init(saa7127_init_module);
 846 module_exit(saa7127_cleanup_module);