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