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