drivers/media/video/saa7134/saa6752hs.c

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