2 * Copyright (C) 2006 Sony Computer Entertainment Inc.
3 * Copyright 2006, 2007 Sony Corporation
5 * AV backend support for PS3
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published
9 * by the Free Software Foundation; version 2 of the License.
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 #include <linux/module.h>
22 #include <linux/kernel.h>
23 #include <linux/delay.h>
24 #include <asm/ps3av.h>
25 #include <asm/ps3fb.h>
30 static const struct video_fmt
{
33 } ps3av_video_fmt_table
[] = {
34 { PS3AV_CMD_VIDEO_FORMAT_ARGB_8BIT
, PS3AV_CMD_VIDEO_ORDER_RGB
},
35 { PS3AV_CMD_VIDEO_FORMAT_ARGB_8BIT
, PS3AV_CMD_VIDEO_ORDER_BGR
},
42 } ps3av_cs_video2av_table
[] = {
44 .cs
= PS3AV_CMD_VIDEO_CS_RGB_8
,
45 .av
= PS3AV_CMD_AV_CS_RGB_8
,
46 .bl
= PS3AV_CMD_AV_CS_8
48 .cs
= PS3AV_CMD_VIDEO_CS_RGB_10
,
49 .av
= PS3AV_CMD_AV_CS_RGB_8
,
50 .bl
= PS3AV_CMD_AV_CS_8
52 .cs
= PS3AV_CMD_VIDEO_CS_RGB_12
,
53 .av
= PS3AV_CMD_AV_CS_RGB_8
,
54 .bl
= PS3AV_CMD_AV_CS_8
56 .cs
= PS3AV_CMD_VIDEO_CS_YUV444_8
,
57 .av
= PS3AV_CMD_AV_CS_YUV444_8
,
58 .bl
= PS3AV_CMD_AV_CS_8
60 .cs
= PS3AV_CMD_VIDEO_CS_YUV444_10
,
61 .av
= PS3AV_CMD_AV_CS_YUV444_8
,
62 .bl
= PS3AV_CMD_AV_CS_10
64 .cs
= PS3AV_CMD_VIDEO_CS_YUV444_12
,
65 .av
= PS3AV_CMD_AV_CS_YUV444_8
,
66 .bl
= PS3AV_CMD_AV_CS_10
68 .cs
= PS3AV_CMD_VIDEO_CS_YUV422_8
,
69 .av
= PS3AV_CMD_AV_CS_YUV422_8
,
70 .bl
= PS3AV_CMD_AV_CS_10
72 .cs
= PS3AV_CMD_VIDEO_CS_YUV422_10
,
73 .av
= PS3AV_CMD_AV_CS_YUV422_8
,
74 .bl
= PS3AV_CMD_AV_CS_10
76 .cs
= PS3AV_CMD_VIDEO_CS_YUV422_12
,
77 .av
= PS3AV_CMD_AV_CS_YUV422_8
,
78 .bl
= PS3AV_CMD_AV_CS_12
80 .cs
= PS3AV_CMD_VIDEO_CS_XVYCC_8
,
81 .av
= PS3AV_CMD_AV_CS_XVYCC_8
,
82 .bl
= PS3AV_CMD_AV_CS_12
84 .cs
= PS3AV_CMD_VIDEO_CS_XVYCC_10
,
85 .av
= PS3AV_CMD_AV_CS_XVYCC_8
,
86 .bl
= PS3AV_CMD_AV_CS_12
88 .cs
= PS3AV_CMD_VIDEO_CS_XVYCC_12
,
89 .av
= PS3AV_CMD_AV_CS_XVYCC_8
,
90 .bl
= PS3AV_CMD_AV_CS_12
94 static u32
ps3av_cs_video2av(int cs
)
98 for (i
= 0; i
< ARRAY_SIZE(ps3av_cs_video2av_table
); i
++)
99 if (ps3av_cs_video2av_table
[i
].cs
== cs
)
100 return ps3av_cs_video2av_table
[i
].av
;
102 return PS3AV_CMD_AV_CS_RGB_8
;
105 static u32
ps3av_cs_video2av_bitlen(int cs
)
109 for (i
= 0; i
< ARRAY_SIZE(ps3av_cs_video2av_table
); i
++)
110 if (ps3av_cs_video2av_table
[i
].cs
== cs
)
111 return ps3av_cs_video2av_table
[i
].bl
;
113 return PS3AV_CMD_AV_CS_8
;
116 static const struct {
119 } ps3av_vid_video2av_table
[] = {
120 { PS3AV_CMD_VIDEO_VID_480I
, PS3AV_CMD_AV_VID_480I
},
121 { PS3AV_CMD_VIDEO_VID_480P
, PS3AV_CMD_AV_VID_480P
},
122 { PS3AV_CMD_VIDEO_VID_576I
, PS3AV_CMD_AV_VID_576I
},
123 { PS3AV_CMD_VIDEO_VID_576P
, PS3AV_CMD_AV_VID_576P
},
124 { PS3AV_CMD_VIDEO_VID_1080I_60HZ
, PS3AV_CMD_AV_VID_1080I_60HZ
},
125 { PS3AV_CMD_VIDEO_VID_720P_60HZ
, PS3AV_CMD_AV_VID_720P_60HZ
},
126 { PS3AV_CMD_VIDEO_VID_1080P_60HZ
, PS3AV_CMD_AV_VID_1080P_60HZ
},
127 { PS3AV_CMD_VIDEO_VID_1080I_50HZ
, PS3AV_CMD_AV_VID_1080I_50HZ
},
128 { PS3AV_CMD_VIDEO_VID_720P_50HZ
, PS3AV_CMD_AV_VID_720P_50HZ
},
129 { PS3AV_CMD_VIDEO_VID_1080P_50HZ
, PS3AV_CMD_AV_VID_1080P_50HZ
},
130 { PS3AV_CMD_VIDEO_VID_WXGA
, PS3AV_CMD_AV_VID_WXGA
},
131 { PS3AV_CMD_VIDEO_VID_SXGA
, PS3AV_CMD_AV_VID_SXGA
},
132 { PS3AV_CMD_VIDEO_VID_WUXGA
, PS3AV_CMD_AV_VID_WUXGA
}
135 static u32
ps3av_vid_video2av(int vid
)
139 for (i
= 0; i
< ARRAY_SIZE(ps3av_vid_video2av_table
); i
++)
140 if (ps3av_vid_video2av_table
[i
].vid
== vid
)
141 return ps3av_vid_video2av_table
[i
].av
;
143 return PS3AV_CMD_AV_VID_480P
;
146 int ps3av_cmd_init(void)
149 struct ps3av_pkt_av_init av_init
;
150 struct ps3av_pkt_video_init video_init
;
151 struct ps3av_pkt_audio_init audio_init
;
154 memset(&video_init
, 0, sizeof(video_init
));
156 res
= ps3av_do_pkt(PS3AV_CID_VIDEO_INIT
, sizeof(video_init
.send_hdr
),
157 sizeof(video_init
), &video_init
.send_hdr
);
161 res
= get_status(&video_init
);
163 printk(KERN_ERR
"PS3AV_CID_VIDEO_INIT: failed %x\n", res
);
168 memset(&audio_init
, 0, sizeof(audio_init
));
170 res
= ps3av_do_pkt(PS3AV_CID_AUDIO_INIT
, sizeof(audio_init
.send_hdr
),
171 sizeof(audio_init
), &audio_init
.send_hdr
);
175 res
= get_status(&audio_init
);
177 printk(KERN_ERR
"PS3AV_CID_AUDIO_INIT: failed %x\n", res
);
182 memset(&av_init
, 0, sizeof(av_init
));
183 av_init
.event_bit
= 0;
185 res
= ps3av_do_pkt(PS3AV_CID_AV_INIT
, sizeof(av_init
), sizeof(av_init
),
190 res
= get_status(&av_init
);
192 printk(KERN_ERR
"PS3AV_CID_AV_INIT: failed %x\n", res
);
197 int ps3av_cmd_fin(void)
200 struct ps3av_pkt_av_fin av_fin
;
202 memset(&av_fin
, 0, sizeof(av_fin
));
204 res
= ps3av_do_pkt(PS3AV_CID_AV_FIN
, sizeof(av_fin
.send_hdr
),
205 sizeof(av_fin
), &av_fin
.send_hdr
);
209 res
= get_status(&av_fin
);
211 printk(KERN_ERR
"PS3AV_CID_AV_FIN: failed %x\n", res
);
216 int ps3av_cmd_av_video_mute(int num_of_port
, u32
*port
, u32 mute
)
218 int i
, send_len
, res
;
219 struct ps3av_pkt_av_video_mute av_video_mute
;
221 if (num_of_port
> PS3AV_MUTE_PORT_MAX
)
224 memset(&av_video_mute
, 0, sizeof(av_video_mute
));
225 for (i
= 0; i
< num_of_port
; i
++) {
226 av_video_mute
.mute
[i
].avport
= port
[i
];
227 av_video_mute
.mute
[i
].mute
= mute
;
230 send_len
= sizeof(av_video_mute
.send_hdr
) +
231 sizeof(struct ps3av_av_mute
) * num_of_port
;
232 res
= ps3av_do_pkt(PS3AV_CID_AV_VIDEO_MUTE
, send_len
,
233 sizeof(av_video_mute
), &av_video_mute
.send_hdr
);
237 res
= get_status(&av_video_mute
);
239 printk(KERN_ERR
"PS3AV_CID_AV_VIDEO_MUTE: failed %x\n", res
);
244 int ps3av_cmd_av_video_disable_sig(u32 port
)
247 struct ps3av_pkt_av_video_disable_sig av_video_sig
;
249 memset(&av_video_sig
, 0, sizeof(av_video_sig
));
250 av_video_sig
.avport
= port
;
252 res
= ps3av_do_pkt(PS3AV_CID_AV_VIDEO_DISABLE_SIG
,
253 sizeof(av_video_sig
), sizeof(av_video_sig
),
254 &av_video_sig
.send_hdr
);
258 res
= get_status(&av_video_sig
);
261 "PS3AV_CID_AV_VIDEO_DISABLE_SIG: failed %x port:%x\n",
267 int ps3av_cmd_av_tv_mute(u32 avport
, u32 mute
)
270 struct ps3av_pkt_av_tv_mute tv_mute
;
272 memset(&tv_mute
, 0, sizeof(tv_mute
));
273 tv_mute
.avport
= avport
;
276 res
= ps3av_do_pkt(PS3AV_CID_AV_TV_MUTE
, sizeof(tv_mute
),
277 sizeof(tv_mute
), &tv_mute
.send_hdr
);
281 res
= get_status(&tv_mute
);
283 printk(KERN_ERR
"PS3AV_CID_AV_TV_MUTE: failed %x port:%x\n",
289 int ps3av_cmd_enable_event(void)
292 struct ps3av_pkt_av_event av_event
;
294 memset(&av_event
, 0, sizeof(av_event
));
295 av_event
.event_bit
= PS3AV_CMD_EVENT_BIT_UNPLUGGED
|
296 PS3AV_CMD_EVENT_BIT_PLUGGED
| PS3AV_CMD_EVENT_BIT_HDCP_DONE
;
298 res
= ps3av_do_pkt(PS3AV_CID_AV_ENABLE_EVENT
, sizeof(av_event
),
299 sizeof(av_event
), &av_event
.send_hdr
);
303 res
= get_status(&av_event
);
305 printk(KERN_ERR
"PS3AV_CID_AV_ENABLE_EVENT: failed %x\n", res
);
310 int ps3av_cmd_av_hdmi_mode(u8 mode
)
313 struct ps3av_pkt_av_hdmi_mode hdmi_mode
;
315 memset(&hdmi_mode
, 0, sizeof(hdmi_mode
));
316 hdmi_mode
.mode
= mode
;
318 res
= ps3av_do_pkt(PS3AV_CID_AV_HDMI_MODE
, sizeof(hdmi_mode
),
319 sizeof(hdmi_mode
), &hdmi_mode
.send_hdr
);
323 res
= get_status(&hdmi_mode
);
324 if (res
&& res
!= PS3AV_STATUS_UNSUPPORTED_HDMI_MODE
)
325 printk(KERN_ERR
"PS3AV_CID_AV_HDMI_MODE: failed %x\n", res
);
330 u32
ps3av_cmd_set_av_video_cs(void *p
, u32 avport
, int video_vid
, int cs_out
,
333 struct ps3av_pkt_av_video_cs
*av_video_cs
;
335 av_video_cs
= (struct ps3av_pkt_av_video_cs
*)p
;
337 video_vid
= PS3AV_CMD_VIDEO_VID_720P_60HZ
;
339 cs_out
= PS3AV_CMD_VIDEO_CS_YUV444_8
;
343 memset(av_video_cs
, 0, sizeof(*av_video_cs
));
344 ps3av_set_hdr(PS3AV_CID_AV_VIDEO_CS
, sizeof(*av_video_cs
),
345 &av_video_cs
->send_hdr
);
346 av_video_cs
->avport
= avport
;
347 /* should be same as video_mode.resolution */
348 av_video_cs
->av_vid
= ps3av_vid_video2av(video_vid
);
349 av_video_cs
->av_cs_out
= ps3av_cs_video2av(cs_out
);
350 /* should be same as video_mode.video_cs_out */
351 av_video_cs
->av_cs_in
= ps3av_cs_video2av(PS3AV_CMD_VIDEO_CS_RGB_8
);
352 av_video_cs
->bitlen_out
= ps3av_cs_video2av_bitlen(cs_out
);
353 av_video_cs
->aspect
= aspect
;
354 if (id
& PS3AV_MODE_DITHER
) {
355 av_video_cs
->dither
= PS3AV_CMD_AV_DITHER_ON
356 | PS3AV_CMD_AV_DITHER_8BIT
;
359 av_video_cs
->dither
= PS3AV_CMD_AV_DITHER_OFF
;
362 return sizeof(*av_video_cs
);
365 u32
ps3av_cmd_set_video_mode(void *p
, u32 head
, int video_vid
, int video_fmt
,
368 struct ps3av_pkt_video_mode
*video_mode
;
371 video_mode
= (struct ps3av_pkt_video_mode
*)p
;
373 video_vid
= PS3AV_CMD_VIDEO_VID_720P_60HZ
;
375 video_fmt
= PS3AV_CMD_VIDEO_FMT_X8R8G8B8
;
377 if (ps3av_video_mode2res(id
, &x
, &y
))
381 memset(video_mode
, 0, sizeof(*video_mode
));
382 ps3av_set_hdr(PS3AV_CID_VIDEO_MODE
, sizeof(*video_mode
),
383 &video_mode
->send_hdr
);
384 video_mode
->video_head
= head
;
385 if (video_vid
== PS3AV_CMD_VIDEO_VID_480I
386 && head
== PS3AV_CMD_VIDEO_HEAD_B
)
387 video_mode
->video_vid
= PS3AV_CMD_VIDEO_VID_480I_A
;
389 video_mode
->video_vid
= video_vid
;
390 video_mode
->width
= (u16
) x
;
391 video_mode
->height
= (u16
) y
;
392 video_mode
->pitch
= video_mode
->width
* 4; /* line_length */
393 video_mode
->video_out_format
= PS3AV_CMD_VIDEO_OUT_FORMAT_RGB_12BIT
;
394 video_mode
->video_format
= ps3av_video_fmt_table
[video_fmt
].format
;
395 video_mode
->video_order
= ps3av_video_fmt_table
[video_fmt
].order
;
397 pr_debug("%s: video_mode:vid:%x width:%d height:%d pitch:%d out_format:%d format:%x order:%x\n",
398 __FUNCTION__
, video_vid
, video_mode
->width
, video_mode
->height
,
399 video_mode
->pitch
, video_mode
->video_out_format
,
400 video_mode
->video_format
, video_mode
->video_order
);
401 return sizeof(*video_mode
);
404 int ps3av_cmd_video_format_black(u32 head
, u32 video_fmt
, u32 mute
)
407 struct ps3av_pkt_video_format video_format
;
409 memset(&video_format
, 0, sizeof(video_format
));
410 video_format
.video_head
= head
;
411 if (mute
!= PS3AV_CMD_MUTE_OFF
)
412 video_format
.video_format
= PS3AV_CMD_VIDEO_FORMAT_BLACK
;
414 video_format
.video_format
=
415 ps3av_video_fmt_table
[video_fmt
].format
;
416 video_format
.video_order
= ps3av_video_fmt_table
[video_fmt
].order
;
418 res
= ps3av_do_pkt(PS3AV_CID_VIDEO_FORMAT
, sizeof(video_format
),
419 sizeof(video_format
), &video_format
.send_hdr
);
423 res
= get_status(&video_format
);
425 printk(KERN_ERR
"PS3AV_CID_VIDEO_FORMAT: failed %x\n", res
);
431 int ps3av_cmd_av_audio_mute(int num_of_port
, u32
*port
, u32 mute
)
434 struct ps3av_pkt_av_audio_mute av_audio_mute
;
436 if (num_of_port
> PS3AV_MUTE_PORT_MAX
)
440 memset(&av_audio_mute
, 0, sizeof(av_audio_mute
));
441 for (i
= 0; i
< num_of_port
; i
++) {
442 av_audio_mute
.mute
[i
].avport
= port
[i
];
443 av_audio_mute
.mute
[i
].mute
= mute
;
446 res
= ps3av_do_pkt(PS3AV_CID_AV_AUDIO_MUTE
,
447 sizeof(av_audio_mute
.send_hdr
) +
448 sizeof(struct ps3av_av_mute
) * num_of_port
,
449 sizeof(av_audio_mute
), &av_audio_mute
.send_hdr
);
453 res
= get_status(&av_audio_mute
);
455 printk(KERN_ERR
"PS3AV_CID_AV_AUDIO_MUTE: failed %x\n", res
);
460 static const struct {
463 } ps3av_cnv_mclk_table
[] = {
464 { PS3AV_CMD_AUDIO_FS_44K
, PS3AV_CMD_AV_MCLK_512
},
465 { PS3AV_CMD_AUDIO_FS_48K
, PS3AV_CMD_AV_MCLK_512
},
466 { PS3AV_CMD_AUDIO_FS_88K
, PS3AV_CMD_AV_MCLK_256
},
467 { PS3AV_CMD_AUDIO_FS_96K
, PS3AV_CMD_AV_MCLK_256
},
468 { PS3AV_CMD_AUDIO_FS_176K
, PS3AV_CMD_AV_MCLK_128
},
469 { PS3AV_CMD_AUDIO_FS_192K
, PS3AV_CMD_AV_MCLK_128
}
472 static u8
ps3av_cnv_mclk(u32 fs
)
476 for (i
= 0; i
< ARRAY_SIZE(ps3av_cnv_mclk_table
); i
++)
477 if (ps3av_cnv_mclk_table
[i
].fs
== fs
)
478 return ps3av_cnv_mclk_table
[i
].mclk
;
480 printk(KERN_ERR
"%s failed, fs:%x\n", __FUNCTION__
, fs
);
484 #define BASE PS3AV_CMD_AUDIO_FS_44K
486 static const u32 ps3av_ns_table
[][5] = {
487 /* D1, D2, D3, D4, D5 */
488 [PS3AV_CMD_AUDIO_FS_44K
-BASE
] = { 6272, 6272, 17836, 17836, 8918 },
489 [PS3AV_CMD_AUDIO_FS_48K
-BASE
] = { 6144, 6144, 11648, 11648, 5824 },
490 [PS3AV_CMD_AUDIO_FS_88K
-BASE
] = { 12544, 12544, 35672, 35672, 17836 },
491 [PS3AV_CMD_AUDIO_FS_96K
-BASE
] = { 12288, 12288, 23296, 23296, 11648 },
492 [PS3AV_CMD_AUDIO_FS_176K
-BASE
] = { 25088, 25088, 71344, 71344, 35672 },
493 [PS3AV_CMD_AUDIO_FS_192K
-BASE
] = { 24576, 24576, 46592, 46592, 23296 }
496 static void ps3av_cnv_ns(u8
*ns
, u32 fs
, u32 video_vid
)
503 av_vid
= ps3av_vid_video2av(video_vid
);
505 case PS3AV_CMD_AV_VID_480I
:
506 case PS3AV_CMD_AV_VID_576I
:
509 case PS3AV_CMD_AV_VID_480P
:
510 case PS3AV_CMD_AV_VID_576P
:
513 case PS3AV_CMD_AV_VID_1080I_60HZ
:
514 case PS3AV_CMD_AV_VID_1080I_50HZ
:
517 case PS3AV_CMD_AV_VID_720P_60HZ
:
518 case PS3AV_CMD_AV_VID_720P_50HZ
:
521 case PS3AV_CMD_AV_VID_1080P_60HZ
:
522 case PS3AV_CMD_AV_VID_1080P_50HZ
:
523 case PS3AV_CMD_AV_VID_WXGA
:
524 case PS3AV_CMD_AV_VID_SXGA
:
525 case PS3AV_CMD_AV_VID_WUXGA
:
529 printk(KERN_ERR
"%s failed, vid:%x\n", __FUNCTION__
,
534 if (fs
< PS3AV_CMD_AUDIO_FS_44K
|| fs
> PS3AV_CMD_AUDIO_FS_192K
)
535 printk(KERN_ERR
"%s failed, fs:%x\n", __FUNCTION__
, fs
);
537 ns_val
= ps3av_ns_table
[PS3AV_CMD_AUDIO_FS_44K
-BASE
][d
];
539 *p
++ = ns_val
& 0x000000FF;
540 *p
++ = (ns_val
& 0x0000FF00) >> 8;
541 *p
= (ns_val
& 0x00FF0000) >> 16;
546 static u8
ps3av_cnv_enable(u32 source
, const u8
*enable
)
551 if (source
== PS3AV_CMD_AUDIO_SOURCE_SPDIF
) {
553 } else if (source
== PS3AV_CMD_AUDIO_SOURCE_SERIAL
) {
555 ret
= ((p
[0] << 4) + (p
[1] << 5) + (p
[2] << 6) + (p
[3] << 7)) |
558 printk(KERN_ERR
"%s failed, source:%x\n", __FUNCTION__
,
563 static u8
ps3av_cnv_fifomap(const u8
*map
)
569 ret
= p
[0] + (p
[1] << 2) + (p
[2] << 4) + (p
[3] << 6);
573 static u8
ps3av_cnv_inputlen(u32 word_bits
)
578 case PS3AV_CMD_AUDIO_WORD_BITS_16
:
579 ret
= PS3AV_CMD_AV_INPUTLEN_16
;
581 case PS3AV_CMD_AUDIO_WORD_BITS_20
:
582 ret
= PS3AV_CMD_AV_INPUTLEN_20
;
584 case PS3AV_CMD_AUDIO_WORD_BITS_24
:
585 ret
= PS3AV_CMD_AV_INPUTLEN_24
;
588 printk(KERN_ERR
"%s failed, word_bits:%x\n", __FUNCTION__
,
595 static u8
ps3av_cnv_layout(u32 num_of_ch
)
597 if (num_of_ch
> PS3AV_CMD_AUDIO_NUM_OF_CH_8
) {
598 printk(KERN_ERR
"%s failed, num_of_ch:%x\n", __FUNCTION__
,
603 return num_of_ch
== PS3AV_CMD_AUDIO_NUM_OF_CH_2
? 0x0 : 0x1;
606 static void ps3av_cnv_info(struct ps3av_audio_info_frame
*info
,
607 const struct ps3av_pkt_audio_mode
*mode
)
609 info
->pb1
.cc
= mode
->audio_num_of_ch
+ 1; /* CH2:0x01 --- CH8:0x07 */
614 info
->pb3
= 0; /* check mode->audio_format ?? */
615 info
->pb4
= mode
->audio_layout
;
616 info
->pb5
.dm
= mode
->audio_downmix
;
617 info
->pb5
.lsv
= mode
->audio_downmix_level
;
620 static void ps3av_cnv_chstat(u8
*chstat
, const u8
*cs_info
)
622 memcpy(chstat
, cs_info
, 5);
625 u32
ps3av_cmd_set_av_audio_param(void *p
, u32 port
,
626 const struct ps3av_pkt_audio_mode
*audio_mode
,
629 struct ps3av_pkt_av_audio_param
*param
;
631 param
= (struct ps3av_pkt_av_audio_param
*)p
;
633 memset(param
, 0, sizeof(*param
));
634 ps3av_set_hdr(PS3AV_CID_AV_AUDIO_PARAM
, sizeof(*param
),
637 param
->avport
= port
;
638 param
->mclk
= ps3av_cnv_mclk(audio_mode
->audio_fs
) | 0x80;
639 ps3av_cnv_ns(param
->ns
, audio_mode
->audio_fs
, video_vid
);
640 param
->enable
= ps3av_cnv_enable(audio_mode
->audio_source
,
641 audio_mode
->audio_enable
);
642 param
->swaplr
= 0x09;
643 param
->fifomap
= ps3av_cnv_fifomap(audio_mode
->audio_map
);
644 param
->inputctrl
= 0x49;
645 param
->inputlen
= ps3av_cnv_inputlen(audio_mode
->audio_word_bits
);
646 param
->layout
= ps3av_cnv_layout(audio_mode
->audio_num_of_ch
);
647 ps3av_cnv_info(¶m
->info
, audio_mode
);
648 ps3av_cnv_chstat(param
->chstat
, audio_mode
->audio_cs_info
);
650 return sizeof(*param
);
654 static const u8 ps3av_mode_cs_info
[] = {
655 0x00, 0x09, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00
667 void ps3av_cmd_set_audio_mode(struct ps3av_pkt_audio_mode
*audio
, u32 avport
,
668 u32 ch
, u32 fs
, u32 word_bits
, u32 format
,
671 int spdif_through
, spdif_bitstream
;
674 if (!(ch
| fs
| format
| word_bits
| source
)) {
675 ch
= PS3AV_CMD_AUDIO_NUM_OF_CH_2
;
676 fs
= PS3AV_CMD_AUDIO_FS_48K
;
677 word_bits
= PS3AV_CMD_AUDIO_WORD_BITS_16
;
678 format
= PS3AV_CMD_AUDIO_FORMAT_PCM
;
679 source
= PS3AV_CMD_AUDIO_SOURCE_SERIAL
;
681 spdif_through
= spdif_bitstream
= 0; /* XXX not supported */
684 memset(audio
, 0, sizeof(*audio
));
685 ps3av_set_hdr(PS3AV_CID_AUDIO_MODE
, sizeof(*audio
), &audio
->send_hdr
);
687 audio
->avport
= (u8
) avport
;
688 audio
->mask
= 0x0FFF; /* XXX set all */
689 audio
->audio_num_of_ch
= ch
;
690 audio
->audio_fs
= fs
;
691 audio
->audio_word_bits
= word_bits
;
692 audio
->audio_format
= format
;
693 audio
->audio_source
= source
;
696 case PS3AV_CMD_AUDIO_NUM_OF_CH_8
:
697 audio
->audio_enable
[3] = 1;
699 case PS3AV_CMD_AUDIO_NUM_OF_CH_6
:
700 audio
->audio_enable
[2] = 1;
701 audio
->audio_enable
[1] = 1;
703 case PS3AV_CMD_AUDIO_NUM_OF_CH_2
:
705 audio
->audio_enable
[0] = 1;
709 for (i
= 0; i
< 4; i
++)
710 audio
->audio_swap
[i
] = PS3AV_CMD_AUDIO_SWAP_0
; /* no swap */
712 /* audio serial input mapping */
713 audio
->audio_map
[0] = PS3AV_CMD_AUDIO_MAP_OUTPUT_0
;
714 audio
->audio_map
[1] = PS3AV_CMD_AUDIO_MAP_OUTPUT_1
;
715 audio
->audio_map
[2] = PS3AV_CMD_AUDIO_MAP_OUTPUT_2
;
716 audio
->audio_map
[3] = PS3AV_CMD_AUDIO_MAP_OUTPUT_3
;
718 /* audio speaker layout */
719 if (avport
== PS3AV_CMD_AVPORT_HDMI_0
||
720 avport
== PS3AV_CMD_AVPORT_HDMI_1
) {
722 case PS3AV_CMD_AUDIO_NUM_OF_CH_8
:
723 audio
->audio_layout
= PS3AV_CMD_AUDIO_LAYOUT_8CH
;
725 case PS3AV_CMD_AUDIO_NUM_OF_CH_6
:
726 audio
->audio_layout
= PS3AV_CMD_AUDIO_LAYOUT_6CH
;
728 case PS3AV_CMD_AUDIO_NUM_OF_CH_2
:
730 audio
->audio_layout
= PS3AV_CMD_AUDIO_LAYOUT_2CH
;
734 audio
->audio_layout
= PS3AV_CMD_AUDIO_LAYOUT_2CH
;
737 /* audio downmix permission */
738 audio
->audio_downmix
= PS3AV_CMD_AUDIO_DOWNMIX_PERMITTED
;
739 /* audio downmix level shift (0:0dB to 15:15dB) */
740 audio
->audio_downmix_level
= 0; /* 0dB */
743 for (i
= 0; i
< 8; i
++)
744 audio
->audio_cs_info
[i
] = ps3av_mode_cs_info
[i
];
747 case PS3AV_CMD_AUDIO_FS_44K
:
748 audio
->audio_cs_info
[3] &= ~CS_MASK
;
749 audio
->audio_cs_info
[3] |= CS_44
;
751 case PS3AV_CMD_AUDIO_FS_88K
:
752 audio
->audio_cs_info
[3] &= ~CS_MASK
;
753 audio
->audio_cs_info
[3] |= CS_88
;
755 case PS3AV_CMD_AUDIO_FS_96K
:
756 audio
->audio_cs_info
[3] &= ~CS_MASK
;
757 audio
->audio_cs_info
[3] |= CS_96
;
759 case PS3AV_CMD_AUDIO_FS_176K
:
760 audio
->audio_cs_info
[3] &= ~CS_MASK
;
761 audio
->audio_cs_info
[3] |= CS_176
;
763 case PS3AV_CMD_AUDIO_FS_192K
:
764 audio
->audio_cs_info
[3] &= ~CS_MASK
;
765 audio
->audio_cs_info
[3] |= CS_192
;
771 /* pass through setting */
773 (avport
== PS3AV_CMD_AVPORT_SPDIF_0
||
774 avport
== PS3AV_CMD_AVPORT_SPDIF_1
)) {
775 audio
->audio_word_bits
= PS3AV_CMD_AUDIO_WORD_BITS_16
;
776 audio
->audio_source
= PS3AV_CMD_AUDIO_SOURCE_SPDIF
;
777 if (spdif_bitstream
) {
778 audio
->audio_format
= PS3AV_CMD_AUDIO_FORMAT_BITSTREAM
;
779 audio
->audio_cs_info
[0] |= CS_BIT
;
784 int ps3av_cmd_audio_mode(struct ps3av_pkt_audio_mode
*audio_mode
)
788 res
= ps3av_do_pkt(PS3AV_CID_AUDIO_MODE
, sizeof(*audio_mode
),
789 sizeof(*audio_mode
), &audio_mode
->send_hdr
);
793 res
= get_status(audio_mode
);
795 printk(KERN_ERR
"PS3AV_CID_AUDIO_MODE: failed %x\n", res
);
800 int ps3av_cmd_audio_mute(int num_of_port
, u32
*port
, u32 mute
)
803 struct ps3av_pkt_audio_mute audio_mute
;
805 if (num_of_port
> PS3AV_OPT_PORT_MAX
)
809 memset(&audio_mute
, 0, sizeof(audio_mute
));
810 for (i
= 0; i
< num_of_port
; i
++) {
811 audio_mute
.mute
[i
].avport
= port
[i
];
812 audio_mute
.mute
[i
].mute
= mute
;
815 res
= ps3av_do_pkt(PS3AV_CID_AUDIO_MUTE
,
816 sizeof(audio_mute
.send_hdr
) +
817 sizeof(struct ps3av_audio_mute
) * num_of_port
,
818 sizeof(audio_mute
), &audio_mute
.send_hdr
);
822 res
= get_status(&audio_mute
);
824 printk(KERN_ERR
"PS3AV_CID_AUDIO_MUTE: failed %x\n", res
);
829 int ps3av_cmd_audio_active(int active
, u32 port
)
832 struct ps3av_pkt_audio_active audio_active
;
836 memset(&audio_active
, 0, sizeof(audio_active
));
837 audio_active
.audio_port
= port
;
838 cid
= active
? PS3AV_CID_AUDIO_ACTIVE
: PS3AV_CID_AUDIO_INACTIVE
;
840 res
= ps3av_do_pkt(cid
, sizeof(audio_active
), sizeof(audio_active
),
841 &audio_active
.send_hdr
);
845 res
= get_status(&audio_active
);
847 printk(KERN_ERR
"PS3AV_CID_AUDIO_ACTIVE:%x failed %x\n", cid
,
853 int ps3av_cmd_avb_param(struct ps3av_pkt_avb_param
*avb
, u32 send_len
)
857 ps3fb_flip_ctl(0); /* flip off */
860 res
= ps3av_do_pkt(PS3AV_CID_AVB_PARAM
, send_len
, sizeof(*avb
),
865 res
= get_status(avb
);
867 pr_debug("%s: PS3AV_CID_AVB_PARAM: failed %x\n", __FUNCTION__
,
871 ps3fb_flip_ctl(1); /* flip on */
875 int ps3av_cmd_av_get_hw_conf(struct ps3av_pkt_av_get_hw_conf
*hw_conf
)
879 memset(hw_conf
, 0, sizeof(*hw_conf
));
881 res
= ps3av_do_pkt(PS3AV_CID_AV_GET_HW_CONF
, sizeof(hw_conf
->send_hdr
),
882 sizeof(*hw_conf
), &hw_conf
->send_hdr
);
886 res
= get_status(hw_conf
);
888 printk(KERN_ERR
"PS3AV_CID_AV_GET_HW_CONF: failed %x\n", res
);
893 int ps3av_cmd_video_get_monitor_info(struct ps3av_pkt_av_get_monitor_info
*info
,
898 memset(info
, 0, sizeof(*info
));
899 info
->avport
= avport
;
901 res
= ps3av_do_pkt(PS3AV_CID_AV_GET_MONITOR_INFO
,
902 sizeof(info
->send_hdr
) + sizeof(info
->avport
) +
903 sizeof(info
->reserved
),
904 sizeof(*info
), &info
->send_hdr
);
908 res
= get_status(info
);
910 printk(KERN_ERR
"PS3AV_CID_AV_GET_MONITOR_INFO: failed %x\n",
917 void ps3av_cmd_av_hw_conf_dump(const struct ps3av_pkt_av_get_hw_conf
*hw_conf
)
919 printk("av_h_conf:num of hdmi:%d\n", hw_conf
->num_of_hdmi
);
920 printk("av_h_conf:num of avmulti:%d\n", hw_conf
->num_of_avmulti
);
921 printk("av_h_conf:num of spdif:%d\n", hw_conf
->num_of_spdif
);
924 void ps3av_cmd_av_monitor_info_dump(const struct ps3av_pkt_av_get_monitor_info
*monitor_info
)
926 const struct ps3av_info_monitor
*info
= &monitor_info
->info
;
927 const struct ps3av_info_audio
*audio
= info
->audio
;
930 printk("Monitor Info: size%d\n", monitor_info
->send_hdr
.size
);
932 printk("avport:%02x\n", info
->avport
);
933 printk("monitor_id:");
934 for (i
= 0; i
< 10; i
++)
935 printk("%02x ", info
->monitor_id
[i
]);
936 printk("\nmonitor_type:%02x\n", info
->monitor_type
);
937 printk("monitor_name:");
938 for (i
= 0; i
< 16; i
++)
939 printk("%c", info
->monitor_name
[i
]);
942 printk("\nresolution_60: bits:%08x native:%08x\n",
943 info
->res_60
.res_bits
, info
->res_60
.native
);
944 printk("resolution_50: bits:%08x native:%08x\n",
945 info
->res_50
.res_bits
, info
->res_50
.native
);
946 printk("resolution_other: bits:%08x native:%08x\n",
947 info
->res_other
.res_bits
, info
->res_other
.native
);
948 printk("resolution_vesa: bits:%08x native:%08x\n",
949 info
->res_vesa
.res_bits
, info
->res_vesa
.native
);
952 printk("color space rgb:%02x\n", info
->cs
.rgb
);
953 printk("color space yuv444:%02x\n", info
->cs
.yuv444
);
954 printk("color space yuv422:%02x\n", info
->cs
.yuv422
);
957 printk("color info red:X %04x Y %04x\n",
958 info
->color
.red_x
, info
->color
.red_y
);
959 printk("color info green:X %04x Y %04x\n",
960 info
->color
.green_x
, info
->color
.green_y
);
961 printk("color info blue:X %04x Y %04x\n",
962 info
->color
.blue_x
, info
->color
.blue_y
);
963 printk("color info white:X %04x Y %04x\n",
964 info
->color
.white_x
, info
->color
.white_y
);
965 printk("color info gamma: %08x\n", info
->color
.gamma
);
968 printk("supported_AI:%02x\n", info
->supported_ai
);
969 printk("speaker_info:%02x\n", info
->speaker_info
);
970 printk("num of audio:%02x\n", info
->num_of_audio_block
);
973 for (i
= 0; i
< info
->num_of_audio_block
; i
++) {
974 printk("audio[%d] type:%02x max_ch:%02x fs:%02x sbit:%02x\n",
975 i
, audio
->type
, audio
->max_num_of_ch
, audio
->fs
,
980 #endif /* PS3AV_DEBUG */
982 #define PS3AV_AV_LAYOUT_0 (PS3AV_CMD_AV_LAYOUT_32 \
983 | PS3AV_CMD_AV_LAYOUT_44 \
984 | PS3AV_CMD_AV_LAYOUT_48)
986 #define PS3AV_AV_LAYOUT_1 (PS3AV_AV_LAYOUT_0 \
987 | PS3AV_CMD_AV_LAYOUT_88 \
988 | PS3AV_CMD_AV_LAYOUT_96 \
989 | PS3AV_CMD_AV_LAYOUT_176 \
990 | PS3AV_CMD_AV_LAYOUT_192)
992 /************************* vuart ***************************/
994 #define POLLING_INTERVAL 25 /* in msec */
996 int ps3av_vuart_write(struct ps3_vuart_port_device
*dev
, const void *buf
,
999 int error
= ps3_vuart_write(dev
, buf
, size
);
1000 return error
? error
: size
;
1003 int ps3av_vuart_read(struct ps3_vuart_port_device
*dev
, void *buf
,
1004 unsigned long size
, int timeout
)
1009 timeout
= (timeout
+ POLLING_INTERVAL
- 1) / POLLING_INTERVAL
;
1010 while (loopcnt
++ <= timeout
) {
1011 error
= ps3_vuart_read(dev
, buf
, size
);
1014 if (error
!= -EAGAIN
) {
1015 printk(KERN_ERR
"%s: ps3_vuart_read failed %d\n",
1016 __FUNCTION__
, error
);
1019 msleep(POLLING_INTERVAL
);
1021 return -EWOULDBLOCK
;