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-common.h>
38#include <media/v4l2-chip-ident.h>
39#include <media/v4l2-i2c-drv.h>
40#include <linux/init.h>
41#include <linux/crc32.h>
42
43#define MPEG_VIDEO_TARGET_BITRATE_MAX 27000
44#define MPEG_VIDEO_MAX_BITRATE_MAX 27000
45#define MPEG_TOTAL_TARGET_BITRATE_MAX 27000
46#define MPEG_PID_MAX ((1 << 14) - 1)
47
48
49MODULE_DESCRIPTION("device driver for saa6752hs MPEG2 encoder");
50MODULE_AUTHOR("Andrew de Quincey");
51MODULE_LICENSE("GPL");
52
53enum saa6752hs_videoformat {
54 SAA6752HS_VF_D1 = 0,
55 SAA6752HS_VF_2_3_D1 = 1,
56 SAA6752HS_VF_1_2_D1 = 2,
57 SAA6752HS_VF_SIF = 3,
58 SAA6752HS_VF_UNKNOWN,
59};
60
61struct saa6752hs_mpeg_params {
62
63 __u16 ts_pid_pmt;
64 __u16 ts_pid_audio;
65 __u16 ts_pid_video;
66 __u16 ts_pid_pcr;
67
68
69 enum v4l2_mpeg_audio_encoding au_encoding;
70 enum v4l2_mpeg_audio_l2_bitrate au_l2_bitrate;
71 enum v4l2_mpeg_audio_ac3_bitrate au_ac3_bitrate;
72
73
74 enum v4l2_mpeg_video_aspect vi_aspect;
75 enum v4l2_mpeg_video_bitrate_mode vi_bitrate_mode;
76 __u32 vi_bitrate;
77 __u32 vi_bitrate_peak;
78};
79
80static const struct v4l2_format v4l2_format_table[] =
81{
82 [SAA6752HS_VF_D1] =
83 { .fmt = { .pix = { .width = 720, .height = 576 }}},
84 [SAA6752HS_VF_2_3_D1] =
85 { .fmt = { .pix = { .width = 480, .height = 576 }}},
86 [SAA6752HS_VF_1_2_D1] =
87 { .fmt = { .pix = { .width = 352, .height = 576 }}},
88 [SAA6752HS_VF_SIF] =
89 { .fmt = { .pix = { .width = 352, .height = 288 }}},
90 [SAA6752HS_VF_UNKNOWN] =
91 { .fmt = { .pix = { .width = 0, .height = 0}}},
92};
93
94struct saa6752hs_state {
95 struct v4l2_subdev sd;
96 int chip;
97 u32 revision;
98 int has_ac3;
99 struct saa6752hs_mpeg_params params;
100 enum saa6752hs_videoformat video_format;
101 v4l2_std_id standard;
102};
103
104enum saa6752hs_command {
105 SAA6752HS_COMMAND_RESET = 0,
106 SAA6752HS_COMMAND_STOP = 1,
107 SAA6752HS_COMMAND_START = 2,
108 SAA6752HS_COMMAND_PAUSE = 3,
109 SAA6752HS_COMMAND_RECONFIGURE = 4,
110 SAA6752HS_COMMAND_SLEEP = 5,
111 SAA6752HS_COMMAND_RECONFIGURE_FORCE = 6,
112
113 SAA6752HS_COMMAND_MAX
114};
115
116static inline struct saa6752hs_state *to_state(struct v4l2_subdev *sd)
117{
118 return container_of(sd, struct saa6752hs_state, sd);
119}
120
121
122
123static u8 PAT[] = {
124 0xc2,
125 0x00,
126
127 0x47,
128 0x40, 0x00,
129 0x10,
130
131 0x00,
132
133 0x00,
134 0xb0, 0x0d,
135
136 0x00, 0x01,
137
138 0xc1,
139
140 0x00, 0x00,
141
142 0x00, 0x01,
143
144 0xe0, 0x00,
145
146 0x00, 0x00, 0x00, 0x00
147};
148
149static u8 PMT[] = {
150 0xc2,
151 0x01,
152
153 0x47,
154 0x40, 0x00,
155 0x10,
156
157 0x00,
158
159 0x02,
160 0xb0, 0x17,
161
162 0x00, 0x01,
163
164 0xc1,
165
166 0x00, 0x00,
167
168 0xe0, 0x00,
169
170 0xf0, 0x00,
171
172 0x02, 0xe0, 0x00, 0xf0, 0x00,
173 0x04, 0xe0, 0x00, 0xf0, 0x00,
174
175 0x00, 0x00, 0x00, 0x00
176};
177
178static u8 PMT_AC3[] = {
179 0xc2,
180 0x01,
181 0x47,
182
183 0x40,
184 0x10,
185 0x10,
186
187 0x00,
188
189 0x02,
190 0xb0, 0x1a,
191
192 0x00, 0x01,
193
194 0xc1,
195
196 0x00, 0x00,
197
198 0xe1, 0x04,
199
200 0xf0, 0x00,
201
202 0x02, 0xe1, 0x00, 0xf0, 0x00,
203 0x06, 0xe1, 0x03, 0xf0, 0x03,
204 0x6a,
205 0x01,
206 0x00,
207
208 0xED, 0xDE, 0x2D, 0xF3
209};
210
211static struct saa6752hs_mpeg_params param_defaults =
212{
213 .ts_pid_pmt = 16,
214 .ts_pid_video = 260,
215 .ts_pid_audio = 256,
216 .ts_pid_pcr = 259,
217
218 .vi_aspect = V4L2_MPEG_VIDEO_ASPECT_4x3,
219 .vi_bitrate = 4000,
220 .vi_bitrate_peak = 6000,
221 .vi_bitrate_mode = V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
222
223 .au_encoding = V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
224 .au_l2_bitrate = V4L2_MPEG_AUDIO_L2_BITRATE_256K,
225 .au_ac3_bitrate = V4L2_MPEG_AUDIO_AC3_BITRATE_256K,
226};
227
228
229
230static int saa6752hs_chip_command(struct i2c_client *client,
231 enum saa6752hs_command command)
232{
233 unsigned char buf[3];
234 unsigned long timeout;
235 int status = 0;
236
237
238 switch(command) {
239 case SAA6752HS_COMMAND_RESET:
240 buf[0] = 0x00;
241 break;
242
243 case SAA6752HS_COMMAND_STOP:
244 buf[0] = 0x03;
245 break;
246
247 case SAA6752HS_COMMAND_START:
248 buf[0] = 0x02;
249 break;
250
251 case SAA6752HS_COMMAND_PAUSE:
252 buf[0] = 0x04;
253 break;
254
255 case SAA6752HS_COMMAND_RECONFIGURE:
256 buf[0] = 0x05;
257 break;
258
259 case SAA6752HS_COMMAND_SLEEP:
260 buf[0] = 0x06;
261 break;
262
263 case SAA6752HS_COMMAND_RECONFIGURE_FORCE:
264 buf[0] = 0x07;
265 break;
266
267 default:
268 return -EINVAL;
269 }
270
271
272 i2c_master_send(client, buf, 1);
273 timeout = jiffies + HZ * 3;
274 for (;;) {
275
276 buf[0] = 0x10;
277 i2c_master_send(client, buf, 1);
278 i2c_master_recv(client, buf, 1);
279
280 if (!(buf[0] & 0x20))
281 break;
282 if (time_after(jiffies,timeout)) {
283 status = -ETIMEDOUT;
284 break;
285 }
286
287 msleep(10);
288 }
289
290
291 msleep(50);
292
293 return status;
294}
295
296
297static inline void set_reg8(struct i2c_client *client, uint8_t reg, uint8_t val)
298{
299 u8 buf[2];
300
301 buf[0] = reg;
302 buf[1] = val;
303 i2c_master_send(client, buf, 2);
304}
305
306static inline void set_reg16(struct i2c_client *client, uint8_t reg, uint16_t val)
307{
308 u8 buf[3];
309
310 buf[0] = reg;
311 buf[1] = val >> 8;
312 buf[2] = val & 0xff;
313 i2c_master_send(client, buf, 3);
314}
315
316static int saa6752hs_set_bitrate(struct i2c_client *client,
317 struct saa6752hs_state *h)
318{
319 struct saa6752hs_mpeg_params *params = &h->params;
320 int tot_bitrate;
321 int is_384k;
322
323
324 set_reg8(client, 0x71,
325 params->vi_bitrate_mode != V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
326
327
328 if (params->vi_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) {
329
330 set_reg16(client, 0x80, params->vi_bitrate);
331
332
333 set_reg16(client, 0x81, params->vi_bitrate_peak);
334 tot_bitrate = params->vi_bitrate_peak;
335 } else {
336
337 set_reg16(client, 0x81, params->vi_bitrate);
338 tot_bitrate = params->vi_bitrate;
339 }
340
341
342 set_reg8(client, 0x93,
343 params->au_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3);
344
345
346 if (params->au_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3)
347 is_384k = V4L2_MPEG_AUDIO_AC3_BITRATE_384K == params->au_ac3_bitrate;
348 else
349 is_384k = V4L2_MPEG_AUDIO_L2_BITRATE_384K == params->au_l2_bitrate;
350 set_reg8(client, 0x94, is_384k);
351 tot_bitrate += is_384k ? 384 : 256;
352
353
354
355
356
357 tot_bitrate += 768;
358 if (tot_bitrate > MPEG_TOTAL_TARGET_BITRATE_MAX)
359 tot_bitrate = MPEG_TOTAL_TARGET_BITRATE_MAX;
360
361
362 set_reg16(client, 0xb1, tot_bitrate);
363 return 0;
364}
365
366
367static int get_ctrl(int has_ac3, struct saa6752hs_mpeg_params *params,
368 struct v4l2_ext_control *ctrl)
369{
370 switch (ctrl->id) {
371 case V4L2_CID_MPEG_STREAM_TYPE:
372 ctrl->value = V4L2_MPEG_STREAM_TYPE_MPEG2_TS;
373 break;
374 case V4L2_CID_MPEG_STREAM_PID_PMT:
375 ctrl->value = params->ts_pid_pmt;
376 break;
377 case V4L2_CID_MPEG_STREAM_PID_AUDIO:
378 ctrl->value = params->ts_pid_audio;
379 break;
380 case V4L2_CID_MPEG_STREAM_PID_VIDEO:
381 ctrl->value = params->ts_pid_video;
382 break;
383 case V4L2_CID_MPEG_STREAM_PID_PCR:
384 ctrl->value = params->ts_pid_pcr;
385 break;
386 case V4L2_CID_MPEG_AUDIO_ENCODING:
387 ctrl->value = params->au_encoding;
388 break;
389 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
390 ctrl->value = params->au_l2_bitrate;
391 break;
392 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
393 if (!has_ac3)
394 return -EINVAL;
395 ctrl->value = params->au_ac3_bitrate;
396 break;
397 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
398 ctrl->value = V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000;
399 break;
400 case V4L2_CID_MPEG_VIDEO_ENCODING:
401 ctrl->value = V4L2_MPEG_VIDEO_ENCODING_MPEG_2;
402 break;
403 case V4L2_CID_MPEG_VIDEO_ASPECT:
404 ctrl->value = params->vi_aspect;
405 break;
406 case V4L2_CID_MPEG_VIDEO_BITRATE:
407 ctrl->value = params->vi_bitrate * 1000;
408 break;
409 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
410 ctrl->value = params->vi_bitrate_peak * 1000;
411 break;
412 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
413 ctrl->value = params->vi_bitrate_mode;
414 break;
415 default:
416 return -EINVAL;
417 }
418 return 0;
419}
420
421static int handle_ctrl(int has_ac3, struct saa6752hs_mpeg_params *params,
422 struct v4l2_ext_control *ctrl, int set)
423{
424 int old = 0, new;
425
426 new = ctrl->value;
427 switch (ctrl->id) {
428 case V4L2_CID_MPEG_STREAM_TYPE:
429 old = V4L2_MPEG_STREAM_TYPE_MPEG2_TS;
430 if (set && new != old)
431 return -ERANGE;
432 new = old;
433 break;
434 case V4L2_CID_MPEG_STREAM_PID_PMT:
435 old = params->ts_pid_pmt;
436 if (set && new > MPEG_PID_MAX)
437 return -ERANGE;
438 if (new > MPEG_PID_MAX)
439 new = MPEG_PID_MAX;
440 params->ts_pid_pmt = new;
441 break;
442 case V4L2_CID_MPEG_STREAM_PID_AUDIO:
443 old = params->ts_pid_audio;
444 if (set && new > MPEG_PID_MAX)
445 return -ERANGE;
446 if (new > MPEG_PID_MAX)
447 new = MPEG_PID_MAX;
448 params->ts_pid_audio = new;
449 break;
450 case V4L2_CID_MPEG_STREAM_PID_VIDEO:
451 old = params->ts_pid_video;
452 if (set && new > MPEG_PID_MAX)
453 return -ERANGE;
454 if (new > MPEG_PID_MAX)
455 new = MPEG_PID_MAX;
456 params->ts_pid_video = new;
457 break;
458 case V4L2_CID_MPEG_STREAM_PID_PCR:
459 old = params->ts_pid_pcr;
460 if (set && new > MPEG_PID_MAX)
461 return -ERANGE;
462 if (new > MPEG_PID_MAX)
463 new = MPEG_PID_MAX;
464 params->ts_pid_pcr = new;
465 break;
466 case V4L2_CID_MPEG_AUDIO_ENCODING:
467 old = params->au_encoding;
468 if (set && new != V4L2_MPEG_AUDIO_ENCODING_LAYER_2 &&
469 (!has_ac3 || new != V4L2_MPEG_AUDIO_ENCODING_AC3))
470 return -ERANGE;
471 params->au_encoding = new;
472 break;
473 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
474 old = params->au_l2_bitrate;
475 if (set && new != V4L2_MPEG_AUDIO_L2_BITRATE_256K &&
476 new != V4L2_MPEG_AUDIO_L2_BITRATE_384K)
477 return -ERANGE;
478 if (new <= V4L2_MPEG_AUDIO_L2_BITRATE_256K)
479 new = V4L2_MPEG_AUDIO_L2_BITRATE_256K;
480 else
481 new = V4L2_MPEG_AUDIO_L2_BITRATE_384K;
482 params->au_l2_bitrate = new;
483 break;
484 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
485 if (!has_ac3)
486 return -EINVAL;
487 old = params->au_ac3_bitrate;
488 if (set && new != V4L2_MPEG_AUDIO_AC3_BITRATE_256K &&
489 new != V4L2_MPEG_AUDIO_AC3_BITRATE_384K)
490 return -ERANGE;
491 if (new <= V4L2_MPEG_AUDIO_AC3_BITRATE_256K)
492 new = V4L2_MPEG_AUDIO_AC3_BITRATE_256K;
493 else
494 new = V4L2_MPEG_AUDIO_AC3_BITRATE_384K;
495 params->au_ac3_bitrate = new;
496 break;
497 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
498 old = V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000;
499 if (set && new != old)
500 return -ERANGE;
501 new = old;
502 break;
503 case V4L2_CID_MPEG_VIDEO_ENCODING:
504 old = V4L2_MPEG_VIDEO_ENCODING_MPEG_2;
505 if (set && new != old)
506 return -ERANGE;
507 new = old;
508 break;
509 case V4L2_CID_MPEG_VIDEO_ASPECT:
510 old = params->vi_aspect;
511 if (set && new != V4L2_MPEG_VIDEO_ASPECT_16x9 &&
512 new != V4L2_MPEG_VIDEO_ASPECT_4x3)
513 return -ERANGE;
514 if (new != V4L2_MPEG_VIDEO_ASPECT_16x9)
515 new = V4L2_MPEG_VIDEO_ASPECT_4x3;
516 params->vi_aspect = new;
517 break;
518 case V4L2_CID_MPEG_VIDEO_BITRATE:
519 old = params->vi_bitrate * 1000;
520 new = 1000 * (new / 1000);
521 if (set && new > MPEG_VIDEO_TARGET_BITRATE_MAX * 1000)
522 return -ERANGE;
523 if (new > MPEG_VIDEO_TARGET_BITRATE_MAX * 1000)
524 new = MPEG_VIDEO_TARGET_BITRATE_MAX * 1000;
525 params->vi_bitrate = new / 1000;
526 break;
527 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
528 old = params->vi_bitrate_peak * 1000;
529 new = 1000 * (new / 1000);
530 if (set && new > MPEG_VIDEO_TARGET_BITRATE_MAX * 1000)
531 return -ERANGE;
532 if (new > MPEG_VIDEO_TARGET_BITRATE_MAX * 1000)
533 new = MPEG_VIDEO_TARGET_BITRATE_MAX * 1000;
534 params->vi_bitrate_peak = new / 1000;
535 break;
536 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
537 old = params->vi_bitrate_mode;
538 params->vi_bitrate_mode = new;
539 break;
540 default:
541 return -EINVAL;
542 }
543 ctrl->value = new;
544 return 0;
545}
546
547
548static int saa6752hs_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qctrl)
549{
550 struct saa6752hs_state *h = to_state(sd);
551 struct saa6752hs_mpeg_params *params = &h->params;
552 int err;
553
554 switch (qctrl->id) {
555 case V4L2_CID_MPEG_AUDIO_ENCODING:
556 return v4l2_ctrl_query_fill(qctrl,
557 V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
558 h->has_ac3 ? V4L2_MPEG_AUDIO_ENCODING_AC3 :
559 V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
560 1, V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
561
562 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
563 return v4l2_ctrl_query_fill(qctrl,
564 V4L2_MPEG_AUDIO_L2_BITRATE_256K,
565 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
566 V4L2_MPEG_AUDIO_L2_BITRATE_256K);
567
568 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
569 if (!h->has_ac3)
570 return -EINVAL;
571 return v4l2_ctrl_query_fill(qctrl,
572 V4L2_MPEG_AUDIO_AC3_BITRATE_256K,
573 V4L2_MPEG_AUDIO_AC3_BITRATE_384K, 1,
574 V4L2_MPEG_AUDIO_AC3_BITRATE_256K);
575
576 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
577 return v4l2_ctrl_query_fill(qctrl,
578 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000,
579 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000, 1,
580 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
581
582 case V4L2_CID_MPEG_VIDEO_ENCODING:
583 return v4l2_ctrl_query_fill(qctrl,
584 V4L2_MPEG_VIDEO_ENCODING_MPEG_2,
585 V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1,
586 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
587
588 case V4L2_CID_MPEG_VIDEO_ASPECT:
589 return v4l2_ctrl_query_fill(qctrl,
590 V4L2_MPEG_VIDEO_ASPECT_4x3,
591 V4L2_MPEG_VIDEO_ASPECT_16x9, 1,
592 V4L2_MPEG_VIDEO_ASPECT_4x3);
593
594 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
595 err = v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
596 if (err == 0 &&
597 params->vi_bitrate_mode ==
598 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
599 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
600 return err;
601
602 case V4L2_CID_MPEG_STREAM_TYPE:
603 return v4l2_ctrl_query_fill(qctrl,
604 V4L2_MPEG_STREAM_TYPE_MPEG2_TS,
605 V4L2_MPEG_STREAM_TYPE_MPEG2_TS, 1,
606 V4L2_MPEG_STREAM_TYPE_MPEG2_TS);
607
608 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
609 return v4l2_ctrl_query_fill(qctrl,
610 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
611 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
612 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
613 case V4L2_CID_MPEG_VIDEO_BITRATE:
614 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
615 case V4L2_CID_MPEG_STREAM_PID_PMT:
616 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 16);
617 case V4L2_CID_MPEG_STREAM_PID_AUDIO:
618 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 260);
619 case V4L2_CID_MPEG_STREAM_PID_VIDEO:
620 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 256);
621 case V4L2_CID_MPEG_STREAM_PID_PCR:
622 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 259);
623
624 default:
625 break;
626 }
627 return -EINVAL;
628}
629
630static int saa6752hs_querymenu(struct v4l2_subdev *sd, struct v4l2_querymenu *qmenu)
631{
632 static const u32 mpeg_audio_encoding[] = {
633 V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
634 V4L2_CTRL_MENU_IDS_END
635 };
636 static const u32 mpeg_audio_ac3_encoding[] = {
637 V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
638 V4L2_MPEG_AUDIO_ENCODING_AC3,
639 V4L2_CTRL_MENU_IDS_END
640 };
641 static u32 mpeg_audio_l2_bitrate[] = {
642 V4L2_MPEG_AUDIO_L2_BITRATE_256K,
643 V4L2_MPEG_AUDIO_L2_BITRATE_384K,
644 V4L2_CTRL_MENU_IDS_END
645 };
646 static u32 mpeg_audio_ac3_bitrate[] = {
647 V4L2_MPEG_AUDIO_AC3_BITRATE_256K,
648 V4L2_MPEG_AUDIO_AC3_BITRATE_384K,
649 V4L2_CTRL_MENU_IDS_END
650 };
651 struct saa6752hs_state *h = to_state(sd);
652 struct v4l2_queryctrl qctrl;
653 int err;
654
655 qctrl.id = qmenu->id;
656 err = saa6752hs_queryctrl(sd, &qctrl);
657 if (err)
658 return err;
659 switch (qmenu->id) {
660 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
661 return v4l2_ctrl_query_menu_valid_items(qmenu,
662 mpeg_audio_l2_bitrate);
663 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
664 if (!h->has_ac3)
665 return -EINVAL;
666 return v4l2_ctrl_query_menu_valid_items(qmenu,
667 mpeg_audio_ac3_bitrate);
668 case V4L2_CID_MPEG_AUDIO_ENCODING:
669 return v4l2_ctrl_query_menu_valid_items(qmenu,
670 h->has_ac3 ? mpeg_audio_ac3_encoding :
671 mpeg_audio_encoding);
672 }
673 return v4l2_ctrl_query_menu(qmenu, &qctrl, NULL);
674}
675
676static int saa6752hs_init(struct v4l2_subdev *sd, u32 leading_null_bytes)
677{
678 unsigned char buf[9], buf2[4];
679 struct saa6752hs_state *h = to_state(sd);
680 struct i2c_client *client = v4l2_get_subdevdata(sd);
681 unsigned size;
682 u32 crc;
683 unsigned char localPAT[256];
684 unsigned char localPMT[256];
685
686
687 set_reg8(client, 0x41, h->video_format);
688
689
690 set_reg8(client, 0x40, (h->standard & V4L2_STD_525_60) ? 1 : 0);
691
692
693 saa6752hs_set_bitrate(client, h);
694
695
696 set_reg16(client, 0x72, 0x030d);
697
698
699 set_reg8(client, 0x82, 0x04);
700
701
702 set_reg8(client, 0x83, 0x0c);
703
704
705 set_reg8(client, 0xd0, 0x81);
706
707
708 set_reg8(client, 0xb0, 0x05);
709
710
711 set_reg16(client, 0xf6, leading_null_bytes);
712
713
714 memcpy(localPAT, PAT, sizeof(PAT));
715 localPAT[17] = 0xe0 | ((h->params.ts_pid_pmt >> 8) & 0x0f);
716 localPAT[18] = h->params.ts_pid_pmt & 0xff;
717 crc = crc32_be(~0, &localPAT[7], sizeof(PAT) - 7 - 4);
718 localPAT[sizeof(PAT) - 4] = (crc >> 24) & 0xFF;
719 localPAT[sizeof(PAT) - 3] = (crc >> 16) & 0xFF;
720 localPAT[sizeof(PAT) - 2] = (crc >> 8) & 0xFF;
721 localPAT[sizeof(PAT) - 1] = crc & 0xFF;
722
723
724 if (h->params.au_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3) {
725 size = sizeof(PMT_AC3);
726 memcpy(localPMT, PMT_AC3, size);
727 } else {
728 size = sizeof(PMT);
729 memcpy(localPMT, PMT, size);
730 }
731 localPMT[3] = 0x40 | ((h->params.ts_pid_pmt >> 8) & 0x0f);
732 localPMT[4] = h->params.ts_pid_pmt & 0xff;
733 localPMT[15] = 0xE0 | ((h->params.ts_pid_pcr >> 8) & 0x0F);
734 localPMT[16] = h->params.ts_pid_pcr & 0xFF;
735 localPMT[20] = 0xE0 | ((h->params.ts_pid_video >> 8) & 0x0F);
736 localPMT[21] = h->params.ts_pid_video & 0xFF;
737 localPMT[25] = 0xE0 | ((h->params.ts_pid_audio >> 8) & 0x0F);
738 localPMT[26] = h->params.ts_pid_audio & 0xFF;
739 crc = crc32_be(~0, &localPMT[7], size - 7 - 4);
740 localPMT[size - 4] = (crc >> 24) & 0xFF;
741 localPMT[size - 3] = (crc >> 16) & 0xFF;
742 localPMT[size - 2] = (crc >> 8) & 0xFF;
743 localPMT[size - 1] = crc & 0xFF;
744
745
746 set_reg16(client, 0xc1, h->params.ts_pid_audio);
747
748
749 set_reg16(client, 0xc0, h->params.ts_pid_video);
750
751
752 set_reg16(client, 0xc4, h->params.ts_pid_pcr);
753
754
755 i2c_master_send(client, localPAT, sizeof(PAT));
756 i2c_master_send(client, localPMT, size);
757
758
759 set_reg8(client, 0xa4, 1);
760 set_reg8(client, 0xa4, 0);
761
762
763 saa6752hs_chip_command(client, SAA6752HS_COMMAND_START);
764
765
766 buf[0] = 0xE1;
767 buf[1] = 0xA7;
768 buf[2] = 0xFE;
769 buf[3] = 0x82;
770 buf[4] = 0xB0;
771 i2c_master_send(client, buf, 5);
772 i2c_master_recv(client, buf2, 4);
773
774
775 buf[0] = 0xE0;
776 buf[1] = 0xA7;
777 buf[2] = 0xFE;
778 buf[3] = 0x82;
779 buf[4] = 0xB0;
780 buf[5] = buf2[0];
781 switch (h->params.vi_aspect) {
782 case V4L2_MPEG_VIDEO_ASPECT_16x9:
783 buf[6] = buf2[1] | 0x40;
784 break;
785 case V4L2_MPEG_VIDEO_ASPECT_4x3:
786 default:
787 buf[6] = buf2[1] & 0xBF;
788 break;
789 }
790 buf[7] = buf2[2];
791 buf[8] = buf2[3];
792 i2c_master_send(client, buf, 9);
793
794 return 0;
795}
796
797static int saa6752hs_do_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ctrls, int set)
798{
799 struct saa6752hs_state *h = to_state(sd);
800 struct saa6752hs_mpeg_params params;
801 int i;
802
803 if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG)
804 return -EINVAL;
805
806 params = h->params;
807 for (i = 0; i < ctrls->count; i++) {
808 int err = handle_ctrl(h->has_ac3, ¶ms, ctrls->controls + i, set);
809
810 if (err) {
811 ctrls->error_idx = i;
812 return err;
813 }
814 }
815 if (set)
816 h->params = params;
817 return 0;
818}
819
820static int saa6752hs_s_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ctrls)
821{
822 return saa6752hs_do_ext_ctrls(sd, ctrls, 1);
823}
824
825static int saa6752hs_try_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ctrls)
826{
827 return saa6752hs_do_ext_ctrls(sd, ctrls, 0);
828}
829
830static int saa6752hs_g_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ctrls)
831{
832 struct saa6752hs_state *h = to_state(sd);
833 int i;
834
835 if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG)
836 return -EINVAL;
837
838 for (i = 0; i < ctrls->count; i++) {
839 int err = get_ctrl(h->has_ac3, &h->params, ctrls->controls + i);
840
841 if (err) {
842 ctrls->error_idx = i;
843 return err;
844 }
845 }
846 return 0;
847}
848
849static int saa6752hs_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
850{
851 struct saa6752hs_state *h = to_state(sd);
852
853 if (h->video_format == SAA6752HS_VF_UNKNOWN)
854 h->video_format = SAA6752HS_VF_D1;
855 f->fmt.pix.width =
856 v4l2_format_table[h->video_format].fmt.pix.width;
857 f->fmt.pix.height =
858 v4l2_format_table[h->video_format].fmt.pix.height;
859 return 0;
860}
861
862static int saa6752hs_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
863{
864 struct saa6752hs_state *h = to_state(sd);
865 int dist_352, dist_480, dist_720;
866
867
868
869
870
871
872
873
874
875
876
877
878
879 dist_352 = abs(f->fmt.pix.width - 352);
880 dist_480 = abs(f->fmt.pix.width - 480);
881 dist_720 = abs(f->fmt.pix.width - 720);
882 if (dist_720 < dist_480) {
883 f->fmt.pix.width = 720;
884 f->fmt.pix.height = 576;
885 h->video_format = SAA6752HS_VF_D1;
886 } else if (dist_480 < dist_352) {
887 f->fmt.pix.width = 480;
888 f->fmt.pix.height = 576;
889 h->video_format = SAA6752HS_VF_2_3_D1;
890 } else {
891 f->fmt.pix.width = 352;
892 if (abs(f->fmt.pix.height - 576) <
893 abs(f->fmt.pix.height - 288)) {
894 f->fmt.pix.height = 576;
895 h->video_format = SAA6752HS_VF_1_2_D1;
896 } else {
897 f->fmt.pix.height = 288;
898 h->video_format = SAA6752HS_VF_SIF;
899 }
900 }
901 return 0;
902}
903
904static int saa6752hs_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
905{
906 struct saa6752hs_state *h = to_state(sd);
907
908 h->standard = std;
909 return 0;
910}
911
912static int saa6752hs_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
913{
914 struct i2c_client *client = v4l2_get_subdevdata(sd);
915 struct saa6752hs_state *h = to_state(sd);
916
917 return v4l2_chip_ident_i2c_client(client,
918 chip, h->chip, h->revision);
919}
920
921
922
923static const struct v4l2_subdev_core_ops saa6752hs_core_ops = {
924 .g_chip_ident = saa6752hs_g_chip_ident,
925 .init = saa6752hs_init,
926 .queryctrl = saa6752hs_queryctrl,
927 .querymenu = saa6752hs_querymenu,
928 .g_ext_ctrls = saa6752hs_g_ext_ctrls,
929 .s_ext_ctrls = saa6752hs_s_ext_ctrls,
930 .try_ext_ctrls = saa6752hs_try_ext_ctrls,
931 .s_std = saa6752hs_s_std,
932};
933
934static const struct v4l2_subdev_video_ops saa6752hs_video_ops = {
935 .s_fmt = saa6752hs_s_fmt,
936 .g_fmt = saa6752hs_g_fmt,
937};
938
939static const struct v4l2_subdev_ops saa6752hs_ops = {
940 .core = &saa6752hs_core_ops,
941 .video = &saa6752hs_video_ops,
942};
943
944static int saa6752hs_probe(struct i2c_client *client,
945 const struct i2c_device_id *id)
946{
947 struct saa6752hs_state *h = kzalloc(sizeof(*h), GFP_KERNEL);
948 struct v4l2_subdev *sd;
949 u8 addr = 0x13;
950 u8 data[12];
951
952 v4l_info(client, "chip found @ 0x%x (%s)\n",
953 client->addr << 1, client->adapter->name);
954 if (h == NULL)
955 return -ENOMEM;
956 sd = &h->sd;
957 v4l2_i2c_subdev_init(sd, client, &saa6752hs_ops);
958
959 i2c_master_send(client, &addr, 1);
960 i2c_master_recv(client, data, sizeof(data));
961 h->chip = V4L2_IDENT_SAA6752HS;
962 h->revision = (data[8] << 8) | data[9];
963 h->has_ac3 = 0;
964 if (h->revision == 0x0206) {
965 h->chip = V4L2_IDENT_SAA6752HS_AC3;
966 h->has_ac3 = 1;
967 v4l_info(client, "support AC-3\n");
968 }
969 h->params = param_defaults;
970 h->standard = 0;
971 return 0;
972}
973
974static int saa6752hs_remove(struct i2c_client *client)
975{
976 struct v4l2_subdev *sd = i2c_get_clientdata(client);
977
978 v4l2_device_unregister_subdev(sd);
979 kfree(to_state(sd));
980 return 0;
981}
982
983static const struct i2c_device_id saa6752hs_id[] = {
984 { "saa6752hs", 0 },
985 { }
986};
987MODULE_DEVICE_TABLE(i2c, saa6752hs_id);
988
989static struct v4l2_i2c_driver_data v4l2_i2c_data = {
990 .name = "saa6752hs",
991 .probe = saa6752hs_probe,
992 .remove = saa6752hs_remove,
993 .id_table = saa6752hs_id,
994};
995
996
997
998
999
1000
1001
1002
1003