git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/saa7134/saa6752hs.c

   1  /*
   2     saa6752hs - i2c-driver for the saa6752hs by Philips
   3
   4     Copyright (C) 2004 Andrew de Quincey
   5
   6     AC-3 support:
   7
   8     Copyright (C) 2008 Hans Verkuil <hverkuil@xs4all.nl>
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License vs published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18     GNU General Public License for more details.
  19
  20     You should have received a copy of the GNU General Public License
  21     along with this program; if not, write to the Free Software
  22     Foundation, Inc., 675 Mvss Ave, Cambridge, MA 02139, USA.
  23   */
  24
  25 #include <linux/module.h>
  26 #include <linux/kernel.h>
  27 #include <linux/string.h>
  28 #include <linux/timer.h>
  29 #include <linux/delay.h>
  30 #include <linux/errno.h>
  31 #include <linux/slab.h>
  32 #include <linux/poll.h>
  33 #include <linux/i2c.h>
  34 #include <linux/types.h>
  35 #include <linux/videodev2.h>
  36 #include <media/v4l2-common.h>
  37 #include <media/v4l2-chip-ident.h>
  38 #include <media/v4l2-i2c-drv-legacy.h>
  39 #include <linux/init.h>
  40 #include <linux/crc32.h>
  41
  42 #define MPEG_VIDEO_TARGET_BITRATE_MAX  27000
  43 #define MPEG_VIDEO_MAX_BITRATE_MAX     27000
  44 #define MPEG_TOTAL_TARGET_BITRATE_MAX  27000
  45 #define MPEG_PID_MAX ((1 << 14) - 1)
  46
  47 /* Addresses to scan */
  48 static unsigned short normal_i2c[] = {0x20, I2C_CLIENT_END};
  49
  50 I2C_CLIENT_INSMOD;
  51
  52 MODULE_DESCRIPTION("device driver for saa6752hs MPEG2 encoder");
  53 MODULE_AUTHOR("Andrew de Quincey");
  54 MODULE_LICENSE("GPL");
  55
  56 enum saa6752hs_videoformat {
  57         SAA6752HS_VF_D1 = 0,    /* standard D1 video format: 720x576 */
  58         SAA6752HS_VF_2_3_D1 = 1,/* 2/3D1 video format: 480x576 */
  59         SAA6752HS_VF_1_2_D1 = 2,/* 1/2D1 video format: 352x576 */
  60         SAA6752HS_VF_SIF = 3,   /* SIF video format: 352x288 */
  61         SAA6752HS_VF_UNKNOWN,
  62 };
  63
  64 struct saa6752hs_mpeg_params {
  65         /* transport streams */
  66         __u16                           ts_pid_pmt;
  67         __u16                           ts_pid_audio;
  68         __u16                           ts_pid_video;
  69         __u16                           ts_pid_pcr;
  70
  71         /* audio */
  72         enum v4l2_mpeg_audio_encoding    au_encoding;
  73         enum v4l2_mpeg_audio_l2_bitrate  au_l2_bitrate;
  74         enum v4l2_mpeg_audio_ac3_bitrate au_ac3_bitrate;
  75
  76         /* video */
  77         enum v4l2_mpeg_video_aspect     vi_aspect;
  78         enum v4l2_mpeg_video_bitrate_mode vi_bitrate_mode;
  79         __u32                           vi_bitrate;
  80         __u32                           vi_bitrate_peak;
  81 };
  82
  83 static const struct v4l2_format v4l2_format_table[] =
  84 {
  85         [SAA6752HS_VF_D1] =
  86                 { .fmt = { .pix = { .width = 720, .height = 576 }}},
  87         [SAA6752HS_VF_2_3_D1] =
  88                 { .fmt = { .pix = { .width = 480, .height = 576 }}},
  89         [SAA6752HS_VF_1_2_D1] =
  90                 { .fmt = { .pix = { .width = 352, .height = 576 }}},
  91         [SAA6752HS_VF_SIF] =
  92                 { .fmt = { .pix = { .width = 352, .height = 288 }}},
  93         [SAA6752HS_VF_UNKNOWN] =
  94                 { .fmt = { .pix = { .width = 0, .height = 0}}},
  95 };
  96
  97 struct saa6752hs_state {
  98         int                           chip;
  99         u32                           revision;
 100         int                           has_ac3;
 101         struct saa6752hs_mpeg_params  params;
 102         enum saa6752hs_videoformat    video_format;
 103         v4l2_std_id                   standard;
 104 };
 105
 106 enum saa6752hs_command {
 107         SAA6752HS_COMMAND_RESET = 0,
 108         SAA6752HS_COMMAND_STOP = 1,
 109         SAA6752HS_COMMAND_START = 2,
 110         SAA6752HS_COMMAND_PAUSE = 3,
 111         SAA6752HS_COMMAND_RECONFIGURE = 4,
 112         SAA6752HS_COMMAND_SLEEP = 5,
 113         SAA6752HS_COMMAND_RECONFIGURE_FORCE = 6,
 114
 115         SAA6752HS_COMMAND_MAX
 116 };
 117
 118 /* ---------------------------------------------------------------------- */
 119
 120 static u8 PAT[] = {
 121         0xc2, /* i2c register */
 122         0x00, /* table number for encoder */
 123
 124         0x47, /* sync */
 125         0x40, 0x00, /* transport_error_indicator(0), payload_unit_start(1), transport_priority(0), pid(0) */
 126         0x10, /* transport_scrambling_control(00), adaptation_field_control(01), continuity_counter(0) */
 127
 128         0x00, /* PSI pointer to start of table */
 129
 130         0x00, /* tid(0) */
 131         0xb0, 0x0d, /* section_syntax_indicator(1), section_length(13) */
 132
 133         0x00, 0x01, /* transport_stream_id(1) */
 134
 135         0xc1, /* version_number(0), current_next_indicator(1) */
 136
 137         0x00, 0x00, /* section_number(0), last_section_number(0) */
 138
 139         0x00, 0x01, /* program_number(1) */
 140
 141         0xe0, 0x00, /* PMT PID */
 142
 143         0x00, 0x00, 0x00, 0x00 /* CRC32 */
 144 };
 145
 146 static u8 PMT[] = {
 147         0xc2, /* i2c register */
 148         0x01, /* table number for encoder */
 149
 150         0x47, /* sync */
 151         0x40, 0x00, /* transport_error_indicator(0), payload_unit_start(1), transport_priority(0), pid */
 152         0x10, /* transport_scrambling_control(00), adaptation_field_control(01), continuity_counter(0) */
 153
 154         0x00, /* PSI pointer to start of table */
 155
 156         0x02, /* tid(2) */
 157         0xb0, 0x17, /* section_syntax_indicator(1), section_length(23) */
 158
 159         0x00, 0x01, /* program_number(1) */
 160
 161         0xc1, /* version_number(0), current_next_indicator(1) */
 162
 163         0x00, 0x00, /* section_number(0), last_section_number(0) */
 164
 165         0xe0, 0x00, /* PCR_PID */
 166
 167         0xf0, 0x00, /* program_info_length(0) */
 168
 169         0x02, 0xe0, 0x00, 0xf0, 0x00, /* video stream type(2), pid */
 170         0x04, 0xe0, 0x00, 0xf0, 0x00, /* audio stream type(4), pid */
 171
 172         0x00, 0x00, 0x00, 0x00 /* CRC32 */
 173 };
 174
 175 static u8 PMT_AC3[] = {
 176         0xc2, /* i2c register */
 177         0x01, /* table number for encoder(1) */
 178         0x47, /* sync */
 179
 180         0x40, /* transport_error_indicator(0), payload_unit_start(1), transport_priority(0) */
 181         0x10, /* PMT PID (0x0010) */
 182         0x10, /* transport_scrambling_control(00), adaptation_field_control(01), continuity_counter(0) */
 183
 184         0x00, /* PSI pointer to start of table */
 185
 186         0x02, /* TID (2) */
 187         0xb0, 0x1a, /* section_syntax_indicator(1), section_length(26) */
 188
 189         0x00, 0x01, /* program_number(1) */
 190
 191         0xc1, /* version_number(0), current_next_indicator(1) */
 192
 193         0x00, 0x00, /* section_number(0), last_section_number(0) */
 194
 195         0xe1, 0x04, /* PCR_PID (0x0104) */
 196
 197         0xf0, 0x00, /* program_info_length(0) */
 198
 199         0x02, 0xe1, 0x00, 0xf0, 0x00, /* video stream type(2), pid */
 200         0x06, 0xe1, 0x03, 0xf0, 0x03, /* audio stream type(6), pid */
 201         0x6a, /* AC3 */
 202         0x01, /* Descriptor_length(1) */
 203         0x00, /* component_type_flag(0), bsid_flag(0), mainid_flag(0), asvc_flag(0), reserved flags(0) */
 204
 205         0xED, 0xDE, 0x2D, 0xF3 /* CRC32 BE */
 206 };
 207
 208 static struct saa6752hs_mpeg_params param_defaults =
 209 {
 210         .ts_pid_pmt      = 16,
 211         .ts_pid_video    = 260,
 212         .ts_pid_audio    = 256,
 213         .ts_pid_pcr      = 259,
 214
 215         .vi_aspect       = V4L2_MPEG_VIDEO_ASPECT_4x3,
 216         .vi_bitrate      = 4000,
 217         .vi_bitrate_peak = 6000,
 218         .vi_bitrate_mode = V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
 219
 220         .au_encoding     = V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
 221         .au_l2_bitrate   = V4L2_MPEG_AUDIO_L2_BITRATE_256K,
 222         .au_ac3_bitrate  = V4L2_MPEG_AUDIO_AC3_BITRATE_256K,
 223 };
 224
 225 /* ---------------------------------------------------------------------- */
 226
 227 static int saa6752hs_chip_command(struct i2c_client *client,
 228                                   enum saa6752hs_command command)
 229 {
 230         unsigned char buf[3];
 231         unsigned long timeout;
 232         int status = 0;
 233
 234         /* execute the command */
 235         switch(command) {
 236         case SAA6752HS_COMMAND_RESET:
 237                 buf[0] = 0x00;
 238                 break;
 239
 240         case SAA6752HS_COMMAND_STOP:
 241                 buf[0] = 0x03;
 242                 break;
 243
 244         case SAA6752HS_COMMAND_START:
 245                 buf[0] = 0x02;
 246                 break;
 247
 248         case SAA6752HS_COMMAND_PAUSE:
 249                 buf[0] = 0x04;
 250                 break;
 251
 252         case SAA6752HS_COMMAND_RECONFIGURE:
 253                 buf[0] = 0x05;
 254                 break;
 255
 256         case SAA6752HS_COMMAND_SLEEP:
 257                 buf[0] = 0x06;
 258                 break;
 259
 260         case SAA6752HS_COMMAND_RECONFIGURE_FORCE:
 261                 buf[0] = 0x07;
 262                 break;
 263
 264         default:
 265                 return -EINVAL;
 266         }
 267
 268         /* set it and wait for it to be so */
 269         i2c_master_send(client, buf, 1);
 270         timeout = jiffies + HZ * 3;
 271         for (;;) {
 272                 /* get the current status */
 273                 buf[0] = 0x10;
 274                 i2c_master_send(client, buf, 1);
 275                 i2c_master_recv(client, buf, 1);
 276
 277                 if (!(buf[0] & 0x20))
 278                         break;
 279                 if (time_after(jiffies,timeout)) {
 280                         status = -ETIMEDOUT;
 281                         break;
 282                 }
 283
 284                 msleep(10);
 285         }
 286
 287         /* delay a bit to let encoder settle */
 288         msleep(50);
 289
 290         return status;
 291 }
 292
 293
 294 static inline void set_reg8(struct i2c_client *client, uint8_t reg, uint8_t val)
 295 {
 296         u8 buf[2];
 297
 298         buf[0] = reg;
 299         buf[1] = val;
 300         i2c_master_send(client, buf, 2);
 301 }
 302
 303 static inline void set_reg16(struct i2c_client *client, uint8_t reg, uint16_t val)
 304 {
 305         u8 buf[3];
 306
 307         buf[0] = reg;
 308         buf[1] = val >> 8;
 309         buf[2] = val & 0xff;
 310         i2c_master_send(client, buf, 3);
 311 }
 312
 313 static int saa6752hs_set_bitrate(struct i2c_client *client,
 314                                  struct saa6752hs_state *h)
 315 {
 316         struct saa6752hs_mpeg_params *params = &h->params;
 317         int tot_bitrate;
 318         int is_384k;
 319
 320         /* set the bitrate mode */
 321         set_reg8(client, 0x71,
 322                 params->vi_bitrate_mode != V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
 323
 324         /* set the video bitrate */
 325         if (params->vi_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) {
 326                 /* set the target bitrate */
 327                 set_reg16(client, 0x80, params->vi_bitrate);
 328
 329                 /* set the max bitrate */
 330                 set_reg16(client, 0x81, params->vi_bitrate_peak);
 331                 tot_bitrate = params->vi_bitrate_peak;
 332         } else {
 333                 /* set the target bitrate (no max bitrate for CBR) */
 334                 set_reg16(client, 0x81, params->vi_bitrate);
 335                 tot_bitrate = params->vi_bitrate;
 336         }
 337
 338         /* set the audio encoding */
 339         set_reg8(client, 0x93,
 340                         params->au_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3);
 341
 342         /* set the audio bitrate */
 343         if (params->au_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3)
 344                 is_384k = V4L2_MPEG_AUDIO_AC3_BITRATE_384K == params->au_ac3_bitrate;
 345         else
 346                 is_384k = V4L2_MPEG_AUDIO_L2_BITRATE_384K == params->au_l2_bitrate;
 347         set_reg8(client, 0x94, is_384k);
 348         tot_bitrate += is_384k ? 384 : 256;
 349
 350         /* Note: the total max bitrate is determined by adding the video and audio
 351            bitrates together and also adding an extra 768kbit/s to stay on the
 352            safe side. If more control should be required, then an extra MPEG control
 353            should be added. */
 354         tot_bitrate += 768;
 355         if (tot_bitrate > MPEG_TOTAL_TARGET_BITRATE_MAX)
 356                 tot_bitrate = MPEG_TOTAL_TARGET_BITRATE_MAX;
 357
 358         /* set the total bitrate */
 359         set_reg16(client, 0xb1, tot_bitrate);
 360         return 0;
 361 }
 362
 363 static void saa6752hs_set_subsampling(struct i2c_client *client,
 364                                       struct v4l2_format *f)
 365 {
 366         struct saa6752hs_state *h = i2c_get_clientdata(client);
 367         int dist_352, dist_480, dist_720;
 368
 369         /*
 370           FIXME: translate and round width/height into EMPRESS
 371           subsample type:
 372
 373           type   |   PAL   |  NTSC
 374           ---------------------------
 375           SIF    | 352x288 | 352x240
 376           1/2 D1 | 352x576 | 352x480
 377           2/3 D1 | 480x576 | 480x480
 378           D1     | 720x576 | 720x480
 379         */
 380
 381         dist_352 = abs(f->fmt.pix.width - 352);
 382         dist_480 = abs(f->fmt.pix.width - 480);
 383         dist_720 = abs(f->fmt.pix.width - 720);
 384         if (dist_720 < dist_480) {
 385                 f->fmt.pix.width = 720;
 386                 f->fmt.pix.height = 576;
 387                 h->video_format = SAA6752HS_VF_D1;
 388         }
 389         else if (dist_480 < dist_352) {
 390                 f->fmt.pix.width = 480;
 391                 f->fmt.pix.height = 576;
 392                 h->video_format = SAA6752HS_VF_2_3_D1;
 393         }
 394         else {
 395                 f->fmt.pix.width = 352;
 396                 if (abs(f->fmt.pix.height - 576) <
 397                     abs(f->fmt.pix.height - 288)) {
 398                         f->fmt.pix.height = 576;
 399                         h->video_format = SAA6752HS_VF_1_2_D1;
 400                 }
 401                 else {
 402                         f->fmt.pix.height = 288;
 403                         h->video_format = SAA6752HS_VF_SIF;
 404                 }
 405         }
 406 }
 407
 408
 409 static int handle_ctrl(int has_ac3, struct saa6752hs_mpeg_params *params,
 410                 struct v4l2_ext_control *ctrl, unsigned int cmd)
 411 {
 412         int old = 0, new;
 413         int set = (cmd == VIDIOC_S_EXT_CTRLS);
 414
 415         new = ctrl->value;
 416         switch (ctrl->id) {
 417                 case V4L2_CID_MPEG_STREAM_TYPE:
 418                         old = V4L2_MPEG_STREAM_TYPE_MPEG2_TS;
 419                         if (set && new != old)
 420                                 return -ERANGE;
 421                         new = old;
 422                         break;
 423                 case V4L2_CID_MPEG_STREAM_PID_PMT:
 424                         old = params->ts_pid_pmt;
 425                         if (set && new > MPEG_PID_MAX)
 426                                 return -ERANGE;
 427                         if (new > MPEG_PID_MAX)
 428                                 new = MPEG_PID_MAX;
 429                         params->ts_pid_pmt = new;
 430                         break;
 431                 case V4L2_CID_MPEG_STREAM_PID_AUDIO:
 432                         old = params->ts_pid_audio;
 433                         if (set && new > MPEG_PID_MAX)
 434                                 return -ERANGE;
 435                         if (new > MPEG_PID_MAX)
 436                                 new = MPEG_PID_MAX;
 437                         params->ts_pid_audio = new;
 438                         break;
 439                 case V4L2_CID_MPEG_STREAM_PID_VIDEO:
 440                         old = params->ts_pid_video;
 441                         if (set && new > MPEG_PID_MAX)
 442                                 return -ERANGE;
 443                         if (new > MPEG_PID_MAX)
 444                                 new = MPEG_PID_MAX;
 445                         params->ts_pid_video = new;
 446                         break;
 447                 case V4L2_CID_MPEG_STREAM_PID_PCR:
 448                         old = params->ts_pid_pcr;
 449                         if (set && new > MPEG_PID_MAX)
 450                                 return -ERANGE;
 451                         if (new > MPEG_PID_MAX)
 452                                 new = MPEG_PID_MAX;
 453                         params->ts_pid_pcr = new;
 454                         break;
 455                 case V4L2_CID_MPEG_AUDIO_ENCODING:
 456                         old = params->au_encoding;
 457                         if (set && new != V4L2_MPEG_AUDIO_ENCODING_LAYER_2 &&
 458                             (!has_ac3 || new != V4L2_MPEG_AUDIO_ENCODING_AC3))
 459                                 return -ERANGE;
 460                         new = old;
 461                         break;
 462                 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 463                         old = params->au_l2_bitrate;
 464                         if (set && new != V4L2_MPEG_AUDIO_L2_BITRATE_256K &&
 465                                    new != V4L2_MPEG_AUDIO_L2_BITRATE_384K)
 466                                 return -ERANGE;
 467                         if (new <= V4L2_MPEG_AUDIO_L2_BITRATE_256K)
 468                                 new = V4L2_MPEG_AUDIO_L2_BITRATE_256K;
 469                         else
 470                                 new = V4L2_MPEG_AUDIO_L2_BITRATE_384K;
 471                         params->au_l2_bitrate = new;
 472                         break;
 473                 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
 474                         if (!has_ac3)
 475                                 return -EINVAL;
 476                         old = params->au_ac3_bitrate;
 477                         if (set && new != V4L2_MPEG_AUDIO_AC3_BITRATE_256K &&
 478                                    new != V4L2_MPEG_AUDIO_AC3_BITRATE_384K)
 479                                 return -ERANGE;
 480                         if (new <= V4L2_MPEG_AUDIO_AC3_BITRATE_256K)
 481                                 new = V4L2_MPEG_AUDIO_AC3_BITRATE_256K;
 482                         else
 483                                 new = V4L2_MPEG_AUDIO_AC3_BITRATE_384K;
 484                         params->au_ac3_bitrate = new;
 485                         break;
 486                 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 487                         old = V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000;
 488                         if (set && new != old)
 489                                 return -ERANGE;
 490                         new = old;
 491                         break;
 492                 case V4L2_CID_MPEG_VIDEO_ENCODING:
 493                         old = V4L2_MPEG_VIDEO_ENCODING_MPEG_2;
 494                         if (set && new != old)
 495                                 return -ERANGE;
 496                         new = old;
 497                         break;
 498                 case V4L2_CID_MPEG_VIDEO_ASPECT:
 499                         old = params->vi_aspect;
 500                         if (set && new != V4L2_MPEG_VIDEO_ASPECT_16x9 &&
 501                                    new != V4L2_MPEG_VIDEO_ASPECT_4x3)
 502                                 return -ERANGE;
 503                         if (new != V4L2_MPEG_VIDEO_ASPECT_16x9)
 504                                 new = V4L2_MPEG_VIDEO_ASPECT_4x3;
 505                         params->vi_aspect = new;
 506                         break;
 507                 case V4L2_CID_MPEG_VIDEO_BITRATE:
 508                         old = params->vi_bitrate * 1000;
 509                         new = 1000 * (new / 1000);
 510                         if (set && new > MPEG_VIDEO_TARGET_BITRATE_MAX * 1000)
 511                                 return -ERANGE;
 512                         if (new > MPEG_VIDEO_TARGET_BITRATE_MAX * 1000)
 513                                 new = MPEG_VIDEO_TARGET_BITRATE_MAX * 1000;
 514                         params->vi_bitrate = new / 1000;
 515                         break;
 516                 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
 517                         old = params->vi_bitrate_peak * 1000;
 518                         new = 1000 * (new / 1000);
 519                         if (set && new > MPEG_VIDEO_TARGET_BITRATE_MAX * 1000)
 520                                 return -ERANGE;
 521                         if (new > MPEG_VIDEO_TARGET_BITRATE_MAX * 1000)
 522                                 new = MPEG_VIDEO_TARGET_BITRATE_MAX * 1000;
 523                         params->vi_bitrate_peak = new / 1000;
 524                         break;
 525                 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 526                         old = params->vi_bitrate_mode;
 527                         params->vi_bitrate_mode = new;
 528                         break;
 529                 default:
 530                         return -EINVAL;
 531         }
 532         if (cmd == VIDIOC_G_EXT_CTRLS)
 533                 ctrl->value = old;
 534         else
 535                 ctrl->value = new;
 536         return 0;
 537 }
 538
 539 static int saa6752hs_qctrl(struct saa6752hs_state *h,
 540                 struct v4l2_queryctrl *qctrl)
 541 {
 542         struct saa6752hs_mpeg_params *params = &h->params;
 543         int err;
 544
 545         switch (qctrl->id) {
 546         case V4L2_CID_MPEG_AUDIO_ENCODING:
 547                 return v4l2_ctrl_query_fill(qctrl,
 548                                 V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
 549                                 h->has_ac3 ? V4L2_MPEG_AUDIO_ENCODING_AC3 :
 550                                         V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
 551                                 1, V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
 552
 553         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 554                 return v4l2_ctrl_query_fill(qctrl,
 555                                 V4L2_MPEG_AUDIO_L2_BITRATE_256K,
 556                                 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
 557                                 V4L2_MPEG_AUDIO_L2_BITRATE_256K);
 558
 559         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
 560                 if (!h->has_ac3)
 561                         return -EINVAL;
 562                 return v4l2_ctrl_query_fill(qctrl,
 563                                 V4L2_MPEG_AUDIO_AC3_BITRATE_256K,
 564                                 V4L2_MPEG_AUDIO_AC3_BITRATE_384K, 1,
 565                                 V4L2_MPEG_AUDIO_AC3_BITRATE_256K);
 566
 567         case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
 568                 return v4l2_ctrl_query_fill(qctrl,
 569                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000,
 570                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000, 1,
 571                                 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
 572
 573         case V4L2_CID_MPEG_VIDEO_ENCODING:
 574                 return v4l2_ctrl_query_fill(qctrl,
 575                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_2,
 576                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1,
 577                                 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
 578
 579         case V4L2_CID_MPEG_VIDEO_ASPECT:
 580                 return v4l2_ctrl_query_fill(qctrl,
 581                                 V4L2_MPEG_VIDEO_ASPECT_4x3,
 582                                 V4L2_MPEG_VIDEO_ASPECT_16x9, 1,
 583                                 V4L2_MPEG_VIDEO_ASPECT_4x3);
 584
 585         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
 586                 err = v4l2_ctrl_query_fill_std(qctrl);
 587                 if (err == 0 &&
 588                     params->vi_bitrate_mode ==
 589                                 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
 590                         qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
 591                 return err;
 592
 593         case V4L2_CID_MPEG_STREAM_TYPE:
 594                 return v4l2_ctrl_query_fill(qctrl,
 595                                 V4L2_MPEG_STREAM_TYPE_MPEG2_TS,
 596                                 V4L2_MPEG_STREAM_TYPE_MPEG2_TS, 1,
 597                                 V4L2_MPEG_STREAM_TYPE_MPEG2_TS);
 598
 599         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 600         case V4L2_CID_MPEG_VIDEO_BITRATE:
 601         case V4L2_CID_MPEG_STREAM_PID_PMT:
 602         case V4L2_CID_MPEG_STREAM_PID_AUDIO:
 603         case V4L2_CID_MPEG_STREAM_PID_VIDEO:
 604         case V4L2_CID_MPEG_STREAM_PID_PCR:
 605                 return v4l2_ctrl_query_fill_std(qctrl);
 606
 607         default:
 608                 break;
 609         }
 610         return -EINVAL;
 611 }
 612
 613 static int saa6752hs_qmenu(struct saa6752hs_state *h,
 614                 struct v4l2_querymenu *qmenu)
 615 {
 616         static const u32 mpeg_audio_encoding[] = {
 617                 V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
 618                 V4L2_CTRL_MENU_IDS_END
 619         };
 620         static const u32 mpeg_audio_ac3_encoding[] = {
 621                 V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
 622                 V4L2_MPEG_AUDIO_ENCODING_AC3,
 623                 V4L2_CTRL_MENU_IDS_END
 624         };
 625         static u32 mpeg_audio_l2_bitrate[] = {
 626                 V4L2_MPEG_AUDIO_L2_BITRATE_256K,
 627                 V4L2_MPEG_AUDIO_L2_BITRATE_384K,
 628                 V4L2_CTRL_MENU_IDS_END
 629         };
 630         static u32 mpeg_audio_ac3_bitrate[] = {
 631                 V4L2_MPEG_AUDIO_AC3_BITRATE_256K,
 632                 V4L2_MPEG_AUDIO_AC3_BITRATE_384K,
 633                 V4L2_CTRL_MENU_IDS_END
 634         };
 635         struct v4l2_queryctrl qctrl;
 636         int err;
 637
 638         qctrl.id = qmenu->id;
 639         err = saa6752hs_qctrl(h, &qctrl);
 640         if (err)
 641                 return err;
 642         switch (qmenu->id) {
 643         case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
 644                 return v4l2_ctrl_query_menu_valid_items(qmenu,
 645                                 mpeg_audio_l2_bitrate);
 646         case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
 647                 if (!h->has_ac3)
 648                         return -EINVAL;
 649                 return v4l2_ctrl_query_menu_valid_items(qmenu,
 650                                 mpeg_audio_ac3_bitrate);
 651         case V4L2_CID_MPEG_AUDIO_ENCODING:
 652                 return v4l2_ctrl_query_menu_valid_items(qmenu,
 653                         h->has_ac3 ? mpeg_audio_ac3_encoding :
 654                                 mpeg_audio_encoding);
 655         }
 656         return v4l2_ctrl_query_menu(qmenu, &qctrl, NULL);
 657 }
 658
 659 static int saa6752hs_init(struct i2c_client *client, u32 leading_null_bytes)
 660 {
 661         unsigned char buf[9], buf2[4];
 662         struct saa6752hs_state *h;
 663         unsigned size;
 664         u32 crc;
 665         unsigned char localPAT[256];
 666         unsigned char localPMT[256];
 667
 668         h = i2c_get_clientdata(client);
 669
 670         /* Set video format - must be done first as it resets other settings */
 671         set_reg8(client, 0x41, h->video_format);
 672
 673         /* Set number of lines in input signal */
 674         set_reg8(client, 0x40, (h->standard & V4L2_STD_525_60) ? 1 : 0);
 675
 676         /* set bitrate */
 677         saa6752hs_set_bitrate(client, h);
 678
 679         /* Set GOP structure {3, 13} */
 680         set_reg16(client, 0x72, 0x030d);
 681
 682         /* Set minimum Q-scale {4} */
 683         set_reg8(client, 0x82, 0x04);
 684
 685         /* Set maximum Q-scale {12} */
 686         set_reg8(client, 0x83, 0x0c);
 687
 688         /* Set Output Protocol */
 689         set_reg8(client, 0xd0, 0x81);
 690
 691         /* Set video output stream format {TS} */
 692         set_reg8(client, 0xb0, 0x05);
 693
 694         /* Set leading null byte for TS */
 695         set_reg16(client, 0xf6, leading_null_bytes);
 696
 697         /* compute PAT */
 698         memcpy(localPAT, PAT, sizeof(PAT));
 699         localPAT[17] = 0xe0 | ((h->params.ts_pid_pmt >> 8) & 0x0f);
 700         localPAT[18] = h->params.ts_pid_pmt & 0xff;
 701         crc = crc32_be(~0, &localPAT[7], sizeof(PAT) - 7 - 4);
 702         localPAT[sizeof(PAT) - 4] = (crc >> 24) & 0xFF;
 703         localPAT[sizeof(PAT) - 3] = (crc >> 16) & 0xFF;
 704         localPAT[sizeof(PAT) - 2] = (crc >> 8) & 0xFF;
 705         localPAT[sizeof(PAT) - 1] = crc & 0xFF;
 706
 707         /* compute PMT */
 708         if (h->params.au_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3) {
 709                 size = sizeof(PMT_AC3);
 710                 memcpy(localPMT, PMT_AC3, size);
 711         } else {
 712                 size = sizeof(PMT);
 713                 memcpy(localPMT, PMT, size);
 714         }
 715         localPMT[3] = 0x40 | ((h->params.ts_pid_pmt >> 8) & 0x0f);
 716         localPMT[4] = h->params.ts_pid_pmt & 0xff;
 717         localPMT[15] = 0xE0 | ((h->params.ts_pid_pcr >> 8) & 0x0F);
 718         localPMT[16] = h->params.ts_pid_pcr & 0xFF;
 719         localPMT[20] = 0xE0 | ((h->params.ts_pid_video >> 8) & 0x0F);
 720         localPMT[21] = h->params.ts_pid_video & 0xFF;
 721         localPMT[25] = 0xE0 | ((h->params.ts_pid_audio >> 8) & 0x0F);
 722         localPMT[26] = h->params.ts_pid_audio & 0xFF;
 723         crc = crc32_be(~0, &localPMT[7], size - 7 - 4);
 724         localPMT[size - 4] = (crc >> 24) & 0xFF;
 725         localPMT[size - 3] = (crc >> 16) & 0xFF;
 726         localPMT[size - 2] = (crc >> 8) & 0xFF;
 727         localPMT[size - 1] = crc & 0xFF;
 728
 729         /* Set Audio PID */
 730         set_reg16(client, 0xc1, h->params.ts_pid_audio);
 731
 732         /* Set Video PID */
 733         set_reg16(client, 0xc0, h->params.ts_pid_video);
 734
 735         /* Set PCR PID */
 736         set_reg16(client, 0xc4, h->params.ts_pid_pcr);
 737
 738         /* Send SI tables */
 739         i2c_master_send(client, localPAT, sizeof(PAT));
 740         i2c_master_send(client, localPMT, size);
 741
 742         /* mute then unmute audio. This removes buzzing artefacts */
 743         set_reg8(client, 0xa4, 1);
 744         set_reg8(client, 0xa4, 0);
 745
 746         /* start it going */
 747         saa6752hs_chip_command(client, SAA6752HS_COMMAND_START);
 748
 749         /* readout current state */
 750         buf[0] = 0xE1;
 751         buf[1] = 0xA7;
 752         buf[2] = 0xFE;
 753         buf[3] = 0x82;
 754         buf[4] = 0xB0;
 755         i2c_master_send(client, buf, 5);
 756         i2c_master_recv(client, buf2, 4);
 757
 758         /* change aspect ratio */
 759         buf[0] = 0xE0;
 760         buf[1] = 0xA7;
 761         buf[2] = 0xFE;
 762         buf[3] = 0x82;
 763         buf[4] = 0xB0;
 764         buf[5] = buf2[0];
 765         switch(h->params.vi_aspect) {
 766         case V4L2_MPEG_VIDEO_ASPECT_16x9:
 767                 buf[6] = buf2[1] | 0x40;
 768                 break;
 769         case V4L2_MPEG_VIDEO_ASPECT_4x3:
 770         default:
 771                 buf[6] = buf2[1] & 0xBF;
 772                 break;
 773                 break;
 774         }
 775         buf[7] = buf2[2];
 776         buf[8] = buf2[3];
 777         i2c_master_send(client, buf, 9);
 778
 779         return 0;
 780 }
 781
 782 static int
 783 saa6752hs_command(struct i2c_client *client, unsigned int cmd, void *arg)
 784 {
 785         struct saa6752hs_state *h = i2c_get_clientdata(client);
 786         struct v4l2_ext_controls *ctrls = arg;
 787         struct saa6752hs_mpeg_params params;
 788         int err = 0;
 789         int i;
 790
 791         switch (cmd) {
 792         case VIDIOC_INT_INIT:
 793                 /* apply settings and start encoder */
 794                 saa6752hs_init(client, *(u32 *)arg);
 795                 break;
 796         case VIDIOC_S_EXT_CTRLS:
 797                 if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG)
 798                         return -EINVAL;
 799                 /* fall through */
 800         case VIDIOC_TRY_EXT_CTRLS:
 801         case VIDIOC_G_EXT_CTRLS:
 802                 if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG)
 803                         return -EINVAL;
 804                 params = h->params;
 805                 for (i = 0; i < ctrls->count; i++) {
 806                         err = handle_ctrl(h->has_ac3, &params, ctrls->controls + i, cmd);
 807                         if (err) {
 808                                 ctrls->error_idx = i;
 809                                 return err;
 810                         }
 811                 }
 812                 h->params = params;
 813                 break;
 814         case VIDIOC_QUERYCTRL:
 815                 return saa6752hs_qctrl(h, arg);
 816         case VIDIOC_QUERYMENU:
 817                 return saa6752hs_qmenu(h, arg);
 818         case VIDIOC_G_FMT:
 819         {
 820            struct v4l2_format *f = arg;
 821
 822            if (h->video_format == SAA6752HS_VF_UNKNOWN)
 823                    h->video_format = SAA6752HS_VF_D1;
 824            f->fmt.pix.width =
 825                    v4l2_format_table[h->video_format].fmt.pix.width;
 826            f->fmt.pix.height =
 827                    v4l2_format_table[h->video_format].fmt.pix.height;
 828            break ;
 829         }
 830         case VIDIOC_S_FMT:
 831         {
 832                 struct v4l2_format *f = arg;
 833
 834                 saa6752hs_set_subsampling(client, f);
 835                 break;
 836         }
 837         case VIDIOC_S_STD:
 838                 h->standard = *((v4l2_std_id *) arg);
 839                 break;
 840
 841         case VIDIOC_DBG_G_CHIP_IDENT:
 842                 return v4l2_chip_ident_i2c_client(client,
 843                                 arg, h->chip, h->revision);
 844
 845         default:
 846                 /* nothing */
 847                 break;
 848         }
 849
 850         return err;
 851 }
 852
 853 static int saa6752hs_probe(struct i2c_client *client,
 854                         const struct i2c_device_id *id)
 855 {
 856         struct saa6752hs_state *h = kzalloc(sizeof(*h), GFP_KERNEL);
 857         u8 addr = 0x13;
 858         u8 data[12];
 859
 860         v4l_info(client, "chip found @ 0x%x (%s)\n",
 861                         client->addr << 1, client->adapter->name);
 862         if (h == NULL)
 863                 return -ENOMEM;
 864
 865         i2c_master_send(client, &addr, 1);
 866         i2c_master_recv(client, data, sizeof(data));
 867         h->chip = V4L2_IDENT_SAA6752HS;
 868         h->revision = (data[8] << 8) | data[9];
 869         h->has_ac3 = 0;
 870         if (h->revision == 0x0206) {
 871                 h->chip = V4L2_IDENT_SAA6752HS_AC3;
 872                 h->has_ac3 = 1;
 873                 v4l_info(client, "support AC-3\n");
 874         }
 875         h->params = param_defaults;
 876         h->standard = 0; /* Assume 625 input lines */
 877
 878         i2c_set_clientdata(client, h);
 879         return 0;
 880 }
 881
 882 static int saa6752hs_remove(struct i2c_client *client)
 883 {
 884         kfree(i2c_get_clientdata(client));
 885         return 0;
 886 }
 887
 888 static const struct i2c_device_id saa6752hs_id[] = {
 889         { "saa6752hs", 0 },
 890         { }
 891 };
 892 MODULE_DEVICE_TABLE(i2c, saa6752hs_id);
 893
 894 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
 895         .name = "saa6752hs",
 896         .driverid = I2C_DRIVERID_SAA6752HS,
 897         .command = saa6752hs_command,
 898         .probe = saa6752hs_probe,
 899         .remove = saa6752hs_remove,
 900         .id_table = saa6752hs_id,
 901 };
 902
 903 /*
 904  * Overrides for Emacs so that we follow Linus's tabbing style.
 905  * ---------------------------------------------------------------------------
 906  * Local variables:
 907  * c-basic-offset: 8
 908  * End:
 909  */