1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/module.h>
14#include <linux/kernel.h>
15#include <linux/string.h>
16#include <linux/timer.h>
17#include <linux/delay.h>
18#include <linux/errno.h>
19#include <linux/slab.h>
20#include <linux/poll.h>
21#include <linux/i2c.h>
22#include <linux/types.h>
23#include <linux/videodev2.h>
24#include <linux/init.h>
25#include <linux/crc32.h>
26#include <media/v4l2-device.h>
27#include <media/v4l2-ctrls.h>
28#include <media/v4l2-common.h>
29
30#define MPEG_VIDEO_TARGET_BITRATE_MAX 27000
31#define MPEG_VIDEO_MAX_BITRATE_MAX 27000
32#define MPEG_TOTAL_TARGET_BITRATE_MAX 27000
33#define MPEG_PID_MAX ((1 << 14) - 1)
34
35
36MODULE_DESCRIPTION("device driver for saa6752hs MPEG2 encoder");
37MODULE_AUTHOR("Andrew de Quincey");
38MODULE_LICENSE("GPL");
39
40enum saa6752hs_videoformat {
41 SAA6752HS_VF_D1 = 0,
42 SAA6752HS_VF_2_3_D1 = 1,
43 SAA6752HS_VF_1_2_D1 = 2,
44 SAA6752HS_VF_SIF = 3,
45 SAA6752HS_VF_UNKNOWN,
46};
47
48struct saa6752hs_mpeg_params {
49
50 __u16 ts_pid_pmt;
51 __u16 ts_pid_audio;
52 __u16 ts_pid_video;
53 __u16 ts_pid_pcr;
54
55
56 enum v4l2_mpeg_audio_encoding au_encoding;
57 enum v4l2_mpeg_audio_l2_bitrate au_l2_bitrate;
58 enum v4l2_mpeg_audio_ac3_bitrate au_ac3_bitrate;
59
60
61 enum v4l2_mpeg_video_aspect vi_aspect;
62 enum v4l2_mpeg_video_bitrate_mode vi_bitrate_mode;
63 __u32 vi_bitrate;
64 __u32 vi_bitrate_peak;
65};
66
67static const struct v4l2_format v4l2_format_table[] =
68{
69 [SAA6752HS_VF_D1] =
70 { .fmt = { .pix = { .width = 720, .height = 576 }}},
71 [SAA6752HS_VF_2_3_D1] =
72 { .fmt = { .pix = { .width = 480, .height = 576 }}},
73 [SAA6752HS_VF_1_2_D1] =
74 { .fmt = { .pix = { .width = 352, .height = 576 }}},
75 [SAA6752HS_VF_SIF] =
76 { .fmt = { .pix = { .width = 352, .height = 288 }}},
77 [SAA6752HS_VF_UNKNOWN] =
78 { .fmt = { .pix = { .width = 0, .height = 0}}},
79};
80
81struct saa6752hs_state {
82 struct v4l2_subdev sd;
83 struct v4l2_ctrl_handler hdl;
84 struct {
85 struct v4l2_ctrl *video_bitrate_mode;
86 struct v4l2_ctrl *video_bitrate;
87 struct v4l2_ctrl *video_bitrate_peak;
88 };
89 u32 revision;
90 int has_ac3;
91 struct saa6752hs_mpeg_params params;
92 enum saa6752hs_videoformat video_format;
93 v4l2_std_id standard;
94};
95
96enum saa6752hs_command {
97 SAA6752HS_COMMAND_RESET = 0,
98 SAA6752HS_COMMAND_STOP = 1,
99 SAA6752HS_COMMAND_START = 2,
100 SAA6752HS_COMMAND_PAUSE = 3,
101 SAA6752HS_COMMAND_RECONFIGURE = 4,
102 SAA6752HS_COMMAND_SLEEP = 5,
103 SAA6752HS_COMMAND_RECONFIGURE_FORCE = 6,
104
105 SAA6752HS_COMMAND_MAX
106};
107
108static inline struct saa6752hs_state *to_state(struct v4l2_subdev *sd)
109{
110 return container_of(sd, struct saa6752hs_state, sd);
111}
112
113
114
115static const u8 PAT[] = {
116 0xc2,
117 0x00,
118
119 0x47,
120 0x40, 0x00,
121 0x10,
122
123 0x00,
124
125 0x00,
126 0xb0, 0x0d,
127
128 0x00, 0x01,
129
130 0xc1,
131
132 0x00, 0x00,
133
134 0x00, 0x01,
135
136 0xe0, 0x00,
137
138 0x00, 0x00, 0x00, 0x00
139};
140
141static const u8 PMT[] = {
142 0xc2,
143 0x01,
144
145 0x47,
146 0x40, 0x00,
147 0x10,
148
149 0x00,
150
151 0x02,
152 0xb0, 0x17,
153
154 0x00, 0x01,
155
156 0xc1,
157
158 0x00, 0x00,
159
160 0xe0, 0x00,
161
162 0xf0, 0x00,
163
164 0x02, 0xe0, 0x00, 0xf0, 0x00,
165 0x04, 0xe0, 0x00, 0xf0, 0x00,
166
167 0x00, 0x00, 0x00, 0x00
168};
169
170static const u8 PMT_AC3[] = {
171 0xc2,
172 0x01,
173 0x47,
174
175 0x40,
176 0x10,
177 0x10,
178
179 0x00,
180
181 0x02,
182 0xb0, 0x1a,
183
184 0x00, 0x01,
185
186 0xc1,
187
188 0x00, 0x00,
189
190 0xe1, 0x04,
191
192 0xf0, 0x00,
193
194 0x02, 0xe1, 0x00, 0xf0, 0x00,
195 0x06, 0xe1, 0x03, 0xf0, 0x03,
196 0x6a,
197 0x01,
198 0x00,
199
200 0xED, 0xDE, 0x2D, 0xF3
201};
202
203static const struct saa6752hs_mpeg_params param_defaults =
204{
205 .ts_pid_pmt = 16,
206 .ts_pid_video = 260,
207 .ts_pid_audio = 256,
208 .ts_pid_pcr = 259,
209
210 .vi_aspect = V4L2_MPEG_VIDEO_ASPECT_4x3,
211 .vi_bitrate = 4000,
212 .vi_bitrate_peak = 6000,
213 .vi_bitrate_mode = V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
214
215 .au_encoding = V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
216 .au_l2_bitrate = V4L2_MPEG_AUDIO_L2_BITRATE_256K,
217 .au_ac3_bitrate = V4L2_MPEG_AUDIO_AC3_BITRATE_256K,
218};
219
220
221
222static int saa6752hs_chip_command(struct i2c_client *client,
223 enum saa6752hs_command command)
224{
225 unsigned char buf[3];
226 unsigned long timeout;
227 int status = 0;
228
229
230 switch(command) {
231 case SAA6752HS_COMMAND_RESET:
232 buf[0] = 0x00;
233 break;
234
235 case SAA6752HS_COMMAND_STOP:
236 buf[0] = 0x03;
237 break;
238
239 case SAA6752HS_COMMAND_START:
240 buf[0] = 0x02;
241 break;
242
243 case SAA6752HS_COMMAND_PAUSE:
244 buf[0] = 0x04;
245 break;
246
247 case SAA6752HS_COMMAND_RECONFIGURE:
248 buf[0] = 0x05;
249 break;
250
251 case SAA6752HS_COMMAND_SLEEP:
252 buf[0] = 0x06;
253 break;
254
255 case SAA6752HS_COMMAND_RECONFIGURE_FORCE:
256 buf[0] = 0x07;
257 break;
258
259 default:
260 return -EINVAL;
261 }
262
263
264 i2c_master_send(client, buf, 1);
265 timeout = jiffies + HZ * 3;
266 for (;;) {
267
268 buf[0] = 0x10;
269 i2c_master_send(client, buf, 1);
270 i2c_master_recv(client, buf, 1);
271
272 if (!(buf[0] & 0x20))
273 break;
274 if (time_after(jiffies,timeout)) {
275 status = -ETIMEDOUT;
276 break;
277 }
278
279 msleep(10);
280 }
281
282
283 msleep(50);
284
285 return status;
286}
287
288
289static inline void set_reg8(struct i2c_client *client, uint8_t reg, uint8_t val)
290{
291 u8 buf[2];
292
293 buf[0] = reg;
294 buf[1] = val;
295 i2c_master_send(client, buf, 2);
296}
297
298static inline void set_reg16(struct i2c_client *client, uint8_t reg, uint16_t val)
299{
300 u8 buf[3];
301
302 buf[0] = reg;
303 buf[1] = val >> 8;
304 buf[2] = val & 0xff;
305 i2c_master_send(client, buf, 3);
306}
307
308static int saa6752hs_set_bitrate(struct i2c_client *client,
309 struct saa6752hs_state *h)
310{
311 struct saa6752hs_mpeg_params *params = &h->params;
312 int tot_bitrate;
313 int is_384k;
314
315
316 set_reg8(client, 0x71,
317 params->vi_bitrate_mode != V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
318
319
320 if (params->vi_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) {
321
322 set_reg16(client, 0x80, params->vi_bitrate);
323
324
325 set_reg16(client, 0x81, params->vi_bitrate_peak);
326 tot_bitrate = params->vi_bitrate_peak;
327 } else {
328
329 set_reg16(client, 0x81, params->vi_bitrate);
330 tot_bitrate = params->vi_bitrate;
331 }
332
333
334 set_reg8(client, 0x93,
335 params->au_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3);
336
337
338 if (params->au_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3)
339 is_384k = V4L2_MPEG_AUDIO_AC3_BITRATE_384K == params->au_ac3_bitrate;
340 else
341 is_384k = V4L2_MPEG_AUDIO_L2_BITRATE_384K == params->au_l2_bitrate;
342 set_reg8(client, 0x94, is_384k);
343 tot_bitrate += is_384k ? 384 : 256;
344
345
346
347
348
349 tot_bitrate += 768;
350 if (tot_bitrate > MPEG_TOTAL_TARGET_BITRATE_MAX)
351 tot_bitrate = MPEG_TOTAL_TARGET_BITRATE_MAX;
352
353
354 set_reg16(client, 0xb1, tot_bitrate);
355 return 0;
356}
357
358static int saa6752hs_try_ctrl(struct v4l2_ctrl *ctrl)
359{
360 struct saa6752hs_state *h =
361 container_of(ctrl->handler, struct saa6752hs_state, hdl);
362
363 switch (ctrl->id) {
364 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
365
366 if (ctrl->val == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR &&
367 h->video_bitrate_peak->val < h->video_bitrate->val)
368 h->video_bitrate_peak->val = h->video_bitrate->val;
369 break;
370 }
371 return 0;
372}
373
374static int saa6752hs_s_ctrl(struct v4l2_ctrl *ctrl)
375{
376 struct saa6752hs_state *h =
377 container_of(ctrl->handler, struct saa6752hs_state, hdl);
378 struct saa6752hs_mpeg_params *params = &h->params;
379
380 switch (ctrl->id) {
381 case V4L2_CID_MPEG_STREAM_TYPE:
382 break;
383 case V4L2_CID_MPEG_STREAM_PID_PMT:
384 params->ts_pid_pmt = ctrl->val;
385 break;
386 case V4L2_CID_MPEG_STREAM_PID_AUDIO:
387 params->ts_pid_audio = ctrl->val;
388 break;
389 case V4L2_CID_MPEG_STREAM_PID_VIDEO:
390 params->ts_pid_video = ctrl->val;
391 break;
392 case V4L2_CID_MPEG_STREAM_PID_PCR:
393 params->ts_pid_pcr = ctrl->val;
394 break;
395 case V4L2_CID_MPEG_AUDIO_ENCODING:
396 params->au_encoding = ctrl->val;
397 break;
398 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
399 params->au_l2_bitrate = ctrl->val;
400 break;
401 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
402 params->au_ac3_bitrate = ctrl->val;
403 break;
404 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
405 break;
406 case V4L2_CID_MPEG_VIDEO_ENCODING:
407 break;
408 case V4L2_CID_MPEG_VIDEO_ASPECT:
409 params->vi_aspect = ctrl->val;
410 break;
411 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
412 params->vi_bitrate_mode = ctrl->val;
413 params->vi_bitrate = h->video_bitrate->val / 1000;
414 params->vi_bitrate_peak = h->video_bitrate_peak->val / 1000;
415 v4l2_ctrl_activate(h->video_bitrate_peak,
416 ctrl->val == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
417 break;
418 default:
419 return -EINVAL;
420 }
421 return 0;
422}
423
424static int saa6752hs_init(struct v4l2_subdev *sd, u32 leading_null_bytes)
425{
426 unsigned char buf[9], buf2[4];
427 struct saa6752hs_state *h = to_state(sd);
428 struct i2c_client *client = v4l2_get_subdevdata(sd);
429 unsigned size;
430 u32 crc;
431 unsigned char localPAT[256];
432 unsigned char localPMT[256];
433
434
435 set_reg8(client, 0x41, h->video_format);
436
437
438 set_reg8(client, 0x40, (h->standard & V4L2_STD_525_60) ? 1 : 0);
439
440
441 saa6752hs_set_bitrate(client, h);
442
443
444 set_reg16(client, 0x72, 0x030d);
445
446
447 set_reg8(client, 0x82, 0x04);
448
449
450 set_reg8(client, 0x83, 0x0c);
451
452
453 set_reg8(client, 0xd0, 0x81);
454
455
456 set_reg8(client, 0xb0, 0x05);
457
458
459 set_reg16(client, 0xf6, leading_null_bytes);
460
461
462 memcpy(localPAT, PAT, sizeof(PAT));
463 localPAT[17] = 0xe0 | ((h->params.ts_pid_pmt >> 8) & 0x0f);
464 localPAT[18] = h->params.ts_pid_pmt & 0xff;
465 crc = crc32_be(~0, &localPAT[7], sizeof(PAT) - 7 - 4);
466 localPAT[sizeof(PAT) - 4] = (crc >> 24) & 0xFF;
467 localPAT[sizeof(PAT) - 3] = (crc >> 16) & 0xFF;
468 localPAT[sizeof(PAT) - 2] = (crc >> 8) & 0xFF;
469 localPAT[sizeof(PAT) - 1] = crc & 0xFF;
470
471
472 if (h->params.au_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3) {
473 size = sizeof(PMT_AC3);
474 memcpy(localPMT, PMT_AC3, size);
475 } else {
476 size = sizeof(PMT);
477 memcpy(localPMT, PMT, size);
478 }
479 localPMT[3] = 0x40 | ((h->params.ts_pid_pmt >> 8) & 0x0f);
480 localPMT[4] = h->params.ts_pid_pmt & 0xff;
481 localPMT[15] = 0xE0 | ((h->params.ts_pid_pcr >> 8) & 0x0F);
482 localPMT[16] = h->params.ts_pid_pcr & 0xFF;
483 localPMT[20] = 0xE0 | ((h->params.ts_pid_video >> 8) & 0x0F);
484 localPMT[21] = h->params.ts_pid_video & 0xFF;
485 localPMT[25] = 0xE0 | ((h->params.ts_pid_audio >> 8) & 0x0F);
486 localPMT[26] = h->params.ts_pid_audio & 0xFF;
487 crc = crc32_be(~0, &localPMT[7], size - 7 - 4);
488 localPMT[size - 4] = (crc >> 24) & 0xFF;
489 localPMT[size - 3] = (crc >> 16) & 0xFF;
490 localPMT[size - 2] = (crc >> 8) & 0xFF;
491 localPMT[size - 1] = crc & 0xFF;
492
493
494 set_reg16(client, 0xc1, h->params.ts_pid_audio);
495
496
497 set_reg16(client, 0xc0, h->params.ts_pid_video);
498
499
500 set_reg16(client, 0xc4, h->params.ts_pid_pcr);
501
502
503 i2c_master_send(client, localPAT, sizeof(PAT));
504 i2c_master_send(client, localPMT, size);
505
506
507 set_reg8(client, 0xa4, 1);
508 set_reg8(client, 0xa4, 0);
509
510
511 saa6752hs_chip_command(client, SAA6752HS_COMMAND_START);
512
513
514 buf[0] = 0xE1;
515 buf[1] = 0xA7;
516 buf[2] = 0xFE;
517 buf[3] = 0x82;
518 buf[4] = 0xB0;
519 i2c_master_send(client, buf, 5);
520 i2c_master_recv(client, buf2, 4);
521
522
523 buf[0] = 0xE0;
524 buf[1] = 0xA7;
525 buf[2] = 0xFE;
526 buf[3] = 0x82;
527 buf[4] = 0xB0;
528 buf[5] = buf2[0];
529 switch (h->params.vi_aspect) {
530 case V4L2_MPEG_VIDEO_ASPECT_16x9:
531 buf[6] = buf2[1] | 0x40;
532 break;
533 case V4L2_MPEG_VIDEO_ASPECT_4x3:
534 default:
535 buf[6] = buf2[1] & 0xBF;
536 break;
537 }
538 buf[7] = buf2[2];
539 buf[8] = buf2[3];
540 i2c_master_send(client, buf, 9);
541
542 return 0;
543}
544
545static int saa6752hs_get_fmt(struct v4l2_subdev *sd,
546 struct v4l2_subdev_pad_config *cfg,
547 struct v4l2_subdev_format *format)
548{
549 struct v4l2_mbus_framefmt *f = &format->format;
550 struct saa6752hs_state *h = to_state(sd);
551
552 if (format->pad)
553 return -EINVAL;
554
555 if (h->video_format == SAA6752HS_VF_UNKNOWN)
556 h->video_format = SAA6752HS_VF_D1;
557 f->width = v4l2_format_table[h->video_format].fmt.pix.width;
558 f->height = v4l2_format_table[h->video_format].fmt.pix.height;
559 f->code = MEDIA_BUS_FMT_FIXED;
560 f->field = V4L2_FIELD_INTERLACED;
561 f->colorspace = V4L2_COLORSPACE_SMPTE170M;
562 return 0;
563}
564
565static int saa6752hs_set_fmt(struct v4l2_subdev *sd,
566 struct v4l2_subdev_pad_config *cfg,
567 struct v4l2_subdev_format *format)
568{
569 struct v4l2_mbus_framefmt *f = &format->format;
570 struct saa6752hs_state *h = to_state(sd);
571 int dist_352, dist_480, dist_720;
572
573 if (format->pad)
574 return -EINVAL;
575
576 f->code = MEDIA_BUS_FMT_FIXED;
577
578 dist_352 = abs(f->width - 352);
579 dist_480 = abs(f->width - 480);
580 dist_720 = abs(f->width - 720);
581 if (dist_720 < dist_480) {
582 f->width = 720;
583 f->height = 576;
584 } else if (dist_480 < dist_352) {
585 f->width = 480;
586 f->height = 576;
587 } else {
588 f->width = 352;
589 if (abs(f->height - 576) < abs(f->height - 288))
590 f->height = 576;
591 else
592 f->height = 288;
593 }
594 f->field = V4L2_FIELD_INTERLACED;
595 f->colorspace = V4L2_COLORSPACE_SMPTE170M;
596
597 if (format->which == V4L2_SUBDEV_FORMAT_TRY) {
598 cfg->try_fmt = *f;
599 return 0;
600 }
601
602
603
604
605
606
607
608
609
610
611
612
613
614 if (f->code != MEDIA_BUS_FMT_FIXED)
615 return -EINVAL;
616
617 if (f->width == 720)
618 h->video_format = SAA6752HS_VF_D1;
619 else if (f->width == 480)
620 h->video_format = SAA6752HS_VF_2_3_D1;
621 else if (f->height == 576)
622 h->video_format = SAA6752HS_VF_1_2_D1;
623 else
624 h->video_format = SAA6752HS_VF_SIF;
625 return 0;
626}
627
628static int saa6752hs_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
629{
630 struct saa6752hs_state *h = to_state(sd);
631
632 h->standard = std;
633 return 0;
634}
635
636
637
638static const struct v4l2_ctrl_ops saa6752hs_ctrl_ops = {
639 .try_ctrl = saa6752hs_try_ctrl,
640 .s_ctrl = saa6752hs_s_ctrl,
641};
642
643static const struct v4l2_subdev_core_ops saa6752hs_core_ops = {
644 .init = saa6752hs_init,
645};
646
647static const struct v4l2_subdev_video_ops saa6752hs_video_ops = {
648 .s_std = saa6752hs_s_std,
649};
650
651static const struct v4l2_subdev_pad_ops saa6752hs_pad_ops = {
652 .get_fmt = saa6752hs_get_fmt,
653 .set_fmt = saa6752hs_set_fmt,
654};
655
656static const struct v4l2_subdev_ops saa6752hs_ops = {
657 .core = &saa6752hs_core_ops,
658 .video = &saa6752hs_video_ops,
659 .pad = &saa6752hs_pad_ops,
660};
661
662static int saa6752hs_probe(struct i2c_client *client,
663 const struct i2c_device_id *id)
664{
665 struct saa6752hs_state *h;
666 struct v4l2_subdev *sd;
667 struct v4l2_ctrl_handler *hdl;
668 u8 addr = 0x13;
669 u8 data[12];
670
671 v4l_info(client, "chip found @ 0x%x (%s)\n",
672 client->addr << 1, client->adapter->name);
673
674 h = devm_kzalloc(&client->dev, sizeof(*h), GFP_KERNEL);
675 if (h == NULL)
676 return -ENOMEM;
677 sd = &h->sd;
678 v4l2_i2c_subdev_init(sd, client, &saa6752hs_ops);
679
680 i2c_master_send(client, &addr, 1);
681 i2c_master_recv(client, data, sizeof(data));
682 h->revision = (data[8] << 8) | data[9];
683 h->has_ac3 = 0;
684 if (h->revision == 0x0206) {
685 h->has_ac3 = 1;
686 v4l_info(client, "supports AC-3\n");
687 }
688 h->params = param_defaults;
689
690 hdl = &h->hdl;
691 v4l2_ctrl_handler_init(hdl, 14);
692 v4l2_ctrl_new_std_menu(hdl, &saa6752hs_ctrl_ops,
693 V4L2_CID_MPEG_AUDIO_ENCODING,
694 h->has_ac3 ? V4L2_MPEG_AUDIO_ENCODING_AC3 :
695 V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
696 0x0d, V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
697
698 v4l2_ctrl_new_std_menu(hdl, &saa6752hs_ctrl_ops,
699 V4L2_CID_MPEG_AUDIO_L2_BITRATE,
700 V4L2_MPEG_AUDIO_L2_BITRATE_384K,
701 ~((1 << V4L2_MPEG_AUDIO_L2_BITRATE_256K) |
702 (1 << V4L2_MPEG_AUDIO_L2_BITRATE_384K)),
703 V4L2_MPEG_AUDIO_L2_BITRATE_256K);
704
705 if (h->has_ac3)
706 v4l2_ctrl_new_std_menu(hdl, &saa6752hs_ctrl_ops,
707 V4L2_CID_MPEG_AUDIO_AC3_BITRATE,
708 V4L2_MPEG_AUDIO_AC3_BITRATE_384K,
709 ~((1 << V4L2_MPEG_AUDIO_AC3_BITRATE_256K) |
710 (1 << V4L2_MPEG_AUDIO_AC3_BITRATE_384K)),
711 V4L2_MPEG_AUDIO_AC3_BITRATE_256K);
712
713 v4l2_ctrl_new_std_menu(hdl, &saa6752hs_ctrl_ops,
714 V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
715 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000,
716 ~(1 << V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000),
717 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
718
719 v4l2_ctrl_new_std_menu(hdl, &saa6752hs_ctrl_ops,
720 V4L2_CID_MPEG_VIDEO_ENCODING,
721 V4L2_MPEG_VIDEO_ENCODING_MPEG_2,
722 ~(1 << V4L2_MPEG_VIDEO_ENCODING_MPEG_2),
723 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
724
725 v4l2_ctrl_new_std_menu(hdl, &saa6752hs_ctrl_ops,
726 V4L2_CID_MPEG_VIDEO_ASPECT,
727 V4L2_MPEG_VIDEO_ASPECT_16x9, 0x01,
728 V4L2_MPEG_VIDEO_ASPECT_4x3);
729
730 h->video_bitrate_peak = v4l2_ctrl_new_std(hdl, &saa6752hs_ctrl_ops,
731 V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
732 1000000, 27000000, 1000, 8000000);
733
734 v4l2_ctrl_new_std_menu(hdl, &saa6752hs_ctrl_ops,
735 V4L2_CID_MPEG_STREAM_TYPE,
736 V4L2_MPEG_STREAM_TYPE_MPEG2_TS,
737 ~(1 << V4L2_MPEG_STREAM_TYPE_MPEG2_TS),
738 V4L2_MPEG_STREAM_TYPE_MPEG2_TS);
739
740 h->video_bitrate_mode = v4l2_ctrl_new_std_menu(hdl, &saa6752hs_ctrl_ops,
741 V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
742 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 0,
743 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
744 h->video_bitrate = v4l2_ctrl_new_std(hdl, &saa6752hs_ctrl_ops,
745 V4L2_CID_MPEG_VIDEO_BITRATE, 1000000, 27000000, 1000, 6000000);
746 v4l2_ctrl_new_std(hdl, &saa6752hs_ctrl_ops,
747 V4L2_CID_MPEG_STREAM_PID_PMT, 0, (1 << 14) - 1, 1, 16);
748 v4l2_ctrl_new_std(hdl, &saa6752hs_ctrl_ops,
749 V4L2_CID_MPEG_STREAM_PID_AUDIO, 0, (1 << 14) - 1, 1, 260);
750 v4l2_ctrl_new_std(hdl, &saa6752hs_ctrl_ops,
751 V4L2_CID_MPEG_STREAM_PID_VIDEO, 0, (1 << 14) - 1, 1, 256);
752 v4l2_ctrl_new_std(hdl, &saa6752hs_ctrl_ops,
753 V4L2_CID_MPEG_STREAM_PID_PCR, 0, (1 << 14) - 1, 1, 259);
754 sd->ctrl_handler = hdl;
755 if (hdl->error) {
756 int err = hdl->error;
757
758 v4l2_ctrl_handler_free(hdl);
759 return err;
760 }
761 v4l2_ctrl_cluster(3, &h->video_bitrate_mode);
762 v4l2_ctrl_handler_setup(hdl);
763 h->standard = 0;
764 return 0;
765}
766
767static int saa6752hs_remove(struct i2c_client *client)
768{
769 struct v4l2_subdev *sd = i2c_get_clientdata(client);
770
771 v4l2_device_unregister_subdev(sd);
772 v4l2_ctrl_handler_free(&to_state(sd)->hdl);
773 return 0;
774}
775
776static const struct i2c_device_id saa6752hs_id[] = {
777 { "saa6752hs", 0 },
778 { }
779};
780MODULE_DEVICE_TABLE(i2c, saa6752hs_id);
781
782static struct i2c_driver saa6752hs_driver = {
783 .driver = {
784 .name = "saa6752hs",
785 },
786 .probe = saa6752hs_probe,
787 .remove = saa6752hs_remove,
788 .id_table = saa6752hs_id,
789};
790
791module_i2c_driver(saa6752hs_driver);
792
