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/delay.h>
23 #include <linux/notifier.h>
24 #include <linux/reboot.h>
25 #include <linux/kernel.h>
26 #include <linux/ioctl.h>
27 #include <asm/lv1call.h>
28 #include <asm/ps3av.h>
33 #define BUFSIZE 4096 /* vuart buf size */
34 #define PS3AV_BUF_SIZE 512 /* max packet size */
36 static int timeout
= 5000; /* in msec ( 5 sec ) */
37 module_param(timeout
, int, 0644);
39 static struct ps3av ps3av
;
41 static struct ps3_vuart_port_device ps3av_dev
= {
42 .match_id
= PS3_MATCH_ID_AV_SETTINGS
46 #define YUV444 PS3AV_CMD_VIDEO_CS_YUV444_8
47 #define RGB8 PS3AV_CMD_VIDEO_CS_RGB_8
49 #define XRGB PS3AV_CMD_VIDEO_FMT_X8R8G8B8
51 #define A_N PS3AV_CMD_AV_ASPECT_4_3
52 #define A_W PS3AV_CMD_AV_ASPECT_16_9
53 static const struct avset_video_mode
{
62 } video_mode_table
[] = {
64 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_480I
, A_N
, 720, 480, 1, 60},
65 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_480P
, A_N
, 720, 480, 0, 60},
66 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_720P_60HZ
, A_N
, 1280, 720, 0, 60},
67 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_1080I_60HZ
, A_W
, 1920, 1080, 1, 60},
68 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_1080P_60HZ
, A_W
, 1920, 1080, 0, 60},
69 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_576I
, A_N
, 720, 576, 1, 50},
70 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_576P
, A_N
, 720, 576, 0, 50},
71 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_720P_50HZ
, A_N
, 1280, 720, 0, 50},
72 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_1080I_50HZ
, A_W
, 1920, 1080, 1, 50},
73 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_1080P_50HZ
, A_W
, 1920, 1080, 0, 50},
74 { RGB8
, XRGB
, PS3AV_CMD_VIDEO_VID_WXGA
, A_W
, 1280, 768, 0, 60},
75 { RGB8
, XRGB
, PS3AV_CMD_VIDEO_VID_SXGA
, A_N
, 1280, 1024, 0, 60},
76 { RGB8
, XRGB
, PS3AV_CMD_VIDEO_VID_WUXGA
, A_W
, 1920, 1200, 0, 60},
80 static u32 cmd_table
[] = {
88 PS3AV_CID_AV_ENABLE_EVENT
,
89 PS3AV_CID_AV_DISABLE_EVENT
,
91 PS3AV_CID_AV_VIDEO_CS
,
92 PS3AV_CID_AV_VIDEO_MUTE
,
93 PS3AV_CID_AV_VIDEO_DISABLE_SIG
,
94 PS3AV_CID_AV_AUDIO_PARAM
,
95 PS3AV_CID_AV_AUDIO_MUTE
,
96 PS3AV_CID_AV_HDMI_MODE
,
100 PS3AV_CID_VIDEO_FORMAT
,
101 PS3AV_CID_VIDEO_PITCH
,
103 PS3AV_CID_AUDIO_MODE
,
104 PS3AV_CID_AUDIO_MUTE
,
105 PS3AV_CID_AUDIO_ACTIVE
,
106 PS3AV_CID_AUDIO_INACTIVE
,
110 PS3AV_CID_AV_GET_HW_CONF
,
111 PS3AV_CID_AV_GET_MONITOR_INFO
,
114 PS3AV_CID_EVENT_UNPLUGGED
,
115 PS3AV_CID_EVENT_PLUGGED
,
116 PS3AV_CID_EVENT_HDCP_DONE
,
117 PS3AV_CID_EVENT_HDCP_FAIL
,
118 PS3AV_CID_EVENT_HDCP_AUTH
,
119 PS3AV_CID_EVENT_HDCP_ERROR
,
124 #define PS3AV_EVENT_CMD_MASK 0x10000000
125 #define PS3AV_EVENT_ID_MASK 0x0000ffff
126 #define PS3AV_CID_MASK 0xffffffff
127 #define PS3AV_REPLY_BIT 0x80000000
129 #define ps3av_event_get_port_id(cid) ((cid >> 16) & 0xff)
131 static u32
*ps3av_search_cmd_table(u32 cid
, u32 mask
)
137 for (i
= 0;; table
++, i
++) {
138 if ((*table
& mask
) == (cid
& mask
))
146 static int ps3av_parse_event_packet(const struct ps3av_reply_hdr
*hdr
)
150 if (hdr
->cid
& PS3AV_EVENT_CMD_MASK
) {
151 table
= ps3av_search_cmd_table(hdr
->cid
, PS3AV_EVENT_CMD_MASK
);
153 dev_dbg(&ps3av_dev
.core
,
154 "recv event packet cid:%08x port:0x%x size:%d\n",
155 hdr
->cid
, ps3av_event_get_port_id(hdr
->cid
),
159 "%s: failed event packet, cid:%08x size:%d\n",
160 __FUNCTION__
, hdr
->cid
, hdr
->size
);
161 return 1; /* receive event packet */
166 static int ps3av_send_cmd_pkt(const struct ps3av_send_hdr
*send_buf
,
167 struct ps3av_reply_hdr
*recv_buf
, int write_len
,
174 if (!ps3av
.available
)
178 res
= ps3av_vuart_write(ps3av
.dev
, send_buf
, write_len
);
180 dev_dbg(&ps3av_dev
.core
,
181 "%s: ps3av_vuart_write() failed (result=%d)\n",
190 res
= ps3av_vuart_read(ps3av
.dev
, recv_buf
, PS3AV_HDR_SIZE
,
192 if (res
!= PS3AV_HDR_SIZE
) {
193 dev_dbg(&ps3av_dev
.core
,
194 "%s: ps3av_vuart_read() failed (result=%d)\n",
200 res
= ps3av_vuart_read(ps3av
.dev
, &recv_buf
->cid
,
201 recv_buf
->size
, timeout
);
203 dev_dbg(&ps3av_dev
.core
,
204 "%s: ps3av_vuart_read() failed (result=%d)\n",
208 res
+= PS3AV_HDR_SIZE
; /* total len */
209 event
= ps3av_parse_event_packet(recv_buf
);
210 /* ret > 0 event packet */
213 if ((cmd
| PS3AV_REPLY_BIT
) != recv_buf
->cid
) {
214 dev_dbg(&ps3av_dev
.core
, "%s: reply err (result=%x)\n",
215 __FUNCTION__
, recv_buf
->cid
);
222 static int ps3av_process_reply_packet(struct ps3av_send_hdr
*cmd_buf
,
223 const struct ps3av_reply_hdr
*recv_buf
,
228 if (recv_buf
->version
!= PS3AV_VERSION
) {
229 dev_dbg(&ps3av_dev
.core
, "reply_packet invalid version:%x\n",
233 return_len
= recv_buf
->size
+ PS3AV_HDR_SIZE
;
234 if (return_len
> user_buf_size
)
235 return_len
= user_buf_size
;
236 memcpy(cmd_buf
, recv_buf
, return_len
);
237 return 0; /* success */
240 void ps3av_set_hdr(u32 cid
, u16 size
, struct ps3av_send_hdr
*hdr
)
242 hdr
->version
= PS3AV_VERSION
;
243 hdr
->size
= size
- PS3AV_HDR_SIZE
;
247 int ps3av_do_pkt(u32 cid
, u16 send_len
, size_t usr_buf_size
,
248 struct ps3av_send_hdr
*buf
)
252 struct ps3av_reply_hdr reply_hdr
;
253 u8 raw
[PS3AV_BUF_SIZE
];
258 BUG_ON(!ps3av
.available
);
260 if (down_interruptible(&ps3av
.sem
))
263 table
= ps3av_search_cmd_table(cid
, PS3AV_CID_MASK
);
265 BUG_ON(send_len
< PS3AV_HDR_SIZE
);
266 BUG_ON(usr_buf_size
< send_len
);
267 BUG_ON(usr_buf_size
> PS3AV_BUF_SIZE
);
270 ps3av_set_hdr(cid
, send_len
, buf
);
272 /* send packet via vuart */
273 res
= ps3av_send_cmd_pkt(buf
, &recv_buf
.reply_hdr
, send_len
,
277 "%s: ps3av_send_cmd_pkt() failed (result=%d)\n",
282 /* process reply packet */
283 res
= ps3av_process_reply_packet(buf
, &recv_buf
.reply_hdr
,
286 printk(KERN_ERR
"%s: put_return_status() failed (result=%d)\n",
296 printk(KERN_ERR
"%s: failed cid:%x res:%d\n", __FUNCTION__
, cid
, res
);
300 static int ps3av_set_av_video_mute(u32 mute
)
302 int i
, num_of_av_port
, res
;
304 num_of_av_port
= ps3av
.av_hw_conf
.num_of_hdmi
+
305 ps3av
.av_hw_conf
.num_of_avmulti
;
307 for (i
= 0; i
< num_of_av_port
; i
++) {
308 res
= ps3av_cmd_av_video_mute(1, &ps3av
.av_port
[i
], mute
);
316 static int ps3av_set_video_disable_sig(void)
318 int i
, num_of_hdmi_port
, num_of_av_port
, res
;
320 num_of_hdmi_port
= ps3av
.av_hw_conf
.num_of_hdmi
;
321 num_of_av_port
= ps3av
.av_hw_conf
.num_of_hdmi
+
322 ps3av
.av_hw_conf
.num_of_avmulti
;
325 for (i
= 0; i
< num_of_hdmi_port
; i
++) {
326 res
= ps3av_cmd_av_tv_mute(ps3av
.av_port
[i
],
334 for (i
= 0; i
< num_of_av_port
; i
++) {
335 res
= ps3av_cmd_av_video_disable_sig(ps3av
.av_port
[i
]);
338 if (i
< num_of_hdmi_port
) {
339 res
= ps3av_cmd_av_tv_mute(ps3av
.av_port
[i
],
350 static int ps3av_set_audio_mute(u32 mute
)
352 int i
, num_of_av_port
, num_of_opt_port
, res
;
354 num_of_av_port
= ps3av
.av_hw_conf
.num_of_hdmi
+
355 ps3av
.av_hw_conf
.num_of_avmulti
;
356 num_of_opt_port
= ps3av
.av_hw_conf
.num_of_spdif
;
358 for (i
= 0; i
< num_of_av_port
; i
++) {
359 res
= ps3av_cmd_av_audio_mute(1, &ps3av
.av_port
[i
], mute
);
363 for (i
= 0; i
< num_of_opt_port
; i
++) {
364 res
= ps3av_cmd_audio_mute(1, &ps3av
.opt_port
[i
], mute
);
372 int ps3av_set_audio_mode(u32 ch
, u32 fs
, u32 word_bits
, u32 format
, u32 source
)
374 struct ps3av_pkt_avb_param avb_param
;
375 int i
, num_of_audio
, vid
, res
;
376 struct ps3av_pkt_audio_mode audio_mode
;
379 num_of_audio
= ps3av
.av_hw_conf
.num_of_hdmi
+
380 ps3av
.av_hw_conf
.num_of_avmulti
+
381 ps3av
.av_hw_conf
.num_of_spdif
;
383 avb_param
.num_of_video_pkt
= 0;
384 avb_param
.num_of_audio_pkt
= PS3AV_AVB_NUM_AUDIO
; /* always 0 */
385 avb_param
.num_of_av_video_pkt
= 0;
386 avb_param
.num_of_av_audio_pkt
= ps3av
.av_hw_conf
.num_of_hdmi
;
388 vid
= video_mode_table
[ps3av
.ps3av_mode
].vid
;
391 ps3av_set_audio_mute(PS3AV_CMD_MUTE_ON
);
394 res
= ps3av_cmd_audio_active(0, ps3av
.audio_port
);
396 dev_dbg(&ps3av_dev
.core
,
397 "ps3av_cmd_audio_active OFF failed\n");
400 for (i
= 0; i
< num_of_audio
; i
++) {
401 ps3av_cmd_set_audio_mode(&audio_mode
, ps3av
.av_port
[i
], ch
, fs
,
402 word_bits
, format
, source
);
403 if (i
< ps3av
.av_hw_conf
.num_of_hdmi
) {
405 len
+= ps3av_cmd_set_av_audio_param(&avb_param
.buf
[len
],
409 /* audio_mode pkt should be sent separately */
410 res
= ps3av_cmd_audio_mode(&audio_mode
);
412 dev_dbg(&ps3av_dev
.core
,
413 "ps3av_cmd_audio_mode failed, port:%x\n", i
);
416 /* send command using avb pkt */
417 len
+= offsetof(struct ps3av_pkt_avb_param
, buf
);
418 res
= ps3av_cmd_avb_param(&avb_param
, len
);
420 dev_dbg(&ps3av_dev
.core
, "ps3av_cmd_avb_param failed\n");
423 ps3av_set_audio_mute(PS3AV_CMD_MUTE_OFF
);
426 res
= ps3av_cmd_audio_active(1, ps3av
.audio_port
);
428 dev_dbg(&ps3av_dev
.core
, "ps3av_cmd_audio_active ON failed\n");
433 EXPORT_SYMBOL_GPL(ps3av_set_audio_mode
);
435 static int ps3av_set_videomode(void)
438 ps3av_set_av_video_mute(PS3AV_CMD_MUTE_ON
);
440 /* wake up ps3avd to do the actual video mode setting */
446 static void ps3av_set_videomode_cont(u32 id
, u32 old_id
)
448 struct ps3av_pkt_avb_param avb_param
;
450 u32 len
= 0, av_video_cs
;
451 const struct avset_video_mode
*video_mode
;
454 video_mode
= &video_mode_table
[id
& PS3AV_MODE_MASK
];
456 avb_param
.num_of_video_pkt
= PS3AV_AVB_NUM_VIDEO
; /* num of head */
457 avb_param
.num_of_audio_pkt
= 0;
458 avb_param
.num_of_av_video_pkt
= ps3av
.av_hw_conf
.num_of_hdmi
+
459 ps3av
.av_hw_conf
.num_of_avmulti
;
460 avb_param
.num_of_av_audio_pkt
= 0;
462 /* video signal off */
463 ps3av_set_video_disable_sig();
465 /* Retail PS3 product doesn't support this */
466 if (id
& PS3AV_MODE_HDCP_OFF
) {
467 res
= ps3av_cmd_av_hdmi_mode(PS3AV_CMD_AV_HDMI_HDCP_OFF
);
468 if (res
== PS3AV_STATUS_UNSUPPORTED_HDMI_MODE
)
469 dev_dbg(&ps3av_dev
.core
, "Not supported\n");
471 dev_dbg(&ps3av_dev
.core
,
472 "ps3av_cmd_av_hdmi_mode failed\n");
473 } else if (old_id
& PS3AV_MODE_HDCP_OFF
) {
474 res
= ps3av_cmd_av_hdmi_mode(PS3AV_CMD_AV_HDMI_MODE_NORMAL
);
475 if (res
< 0 && res
!= PS3AV_STATUS_UNSUPPORTED_HDMI_MODE
)
476 dev_dbg(&ps3av_dev
.core
,
477 "ps3av_cmd_av_hdmi_mode failed\n");
481 for (i
= 0; i
< avb_param
.num_of_video_pkt
; i
++)
482 len
+= ps3av_cmd_set_video_mode(&avb_param
.buf
[len
],
483 ps3av
.head
[i
], video_mode
->vid
,
484 video_mode
->fmt
, id
);
486 for (i
= 0; i
< avb_param
.num_of_av_video_pkt
; i
++) {
487 if (id
& PS3AV_MODE_DVI
|| id
& PS3AV_MODE_RGB
)
490 av_video_cs
= video_mode
->cs
;
491 #ifndef PS3AV_HDMI_YUV
492 if (ps3av
.av_port
[i
] == PS3AV_CMD_AVPORT_HDMI_0
||
493 ps3av
.av_port
[i
] == PS3AV_CMD_AVPORT_HDMI_1
)
494 av_video_cs
= RGB8
; /* use RGB for HDMI */
496 len
+= ps3av_cmd_set_av_video_cs(&avb_param
.buf
[len
],
498 video_mode
->vid
, av_video_cs
,
499 video_mode
->aspect
, id
);
501 /* send command using avb pkt */
502 len
+= offsetof(struct ps3av_pkt_avb_param
, buf
);
503 res
= ps3av_cmd_avb_param(&avb_param
, len
);
504 if (res
== PS3AV_STATUS_NO_SYNC_HEAD
)
506 "%s: Command failed. Please try your request again. \n",
509 dev_dbg(&ps3av_dev
.core
, "ps3av_cmd_avb_param failed\n");
513 ps3av_set_av_video_mute(PS3AV_CMD_MUTE_OFF
);
516 static int ps3avd(void *p
)
518 struct ps3av
*info
= p
;
523 ps3av_set_videomode_cont(info
->ps3av_mode
,
524 info
->ps3av_mode_old
);
530 static int ps3av_vid2table_id(int vid
)
534 for (i
= 1; i
< ARRAY_SIZE(video_mode_table
); i
++)
535 if (video_mode_table
[i
].vid
== vid
)
540 static int ps3av_resbit2vid(u32 res_50
, u32 res_60
)
544 if (res_50
> res_60
) { /* if res_50 == res_60, res_60 will be used */
545 if (res_50
& PS3AV_RESBIT_1920x1080P
)
546 vid
= PS3AV_CMD_VIDEO_VID_1080P_50HZ
;
547 else if (res_50
& PS3AV_RESBIT_1920x1080I
)
548 vid
= PS3AV_CMD_VIDEO_VID_1080I_50HZ
;
549 else if (res_50
& PS3AV_RESBIT_1280x720P
)
550 vid
= PS3AV_CMD_VIDEO_VID_720P_50HZ
;
551 else if (res_50
& PS3AV_RESBIT_720x576P
)
552 vid
= PS3AV_CMD_VIDEO_VID_576P
;
556 if (res_60
& PS3AV_RESBIT_1920x1080P
)
557 vid
= PS3AV_CMD_VIDEO_VID_1080P_60HZ
;
558 else if (res_60
& PS3AV_RESBIT_1920x1080I
)
559 vid
= PS3AV_CMD_VIDEO_VID_1080I_60HZ
;
560 else if (res_60
& PS3AV_RESBIT_1280x720P
)
561 vid
= PS3AV_CMD_VIDEO_VID_720P_60HZ
;
562 else if (res_60
& PS3AV_RESBIT_720x480P
)
563 vid
= PS3AV_CMD_VIDEO_VID_480P
;
570 static int ps3av_hdmi_get_vid(struct ps3av_info_monitor
*info
)
575 if (info
->monitor_type
!= PS3AV_MONITOR_TYPE_HDMI
)
578 /* check native resolution */
579 res_50
= info
->res_50
.native
& PS3AV_RES_MASK_50
;
580 res_60
= info
->res_60
.native
& PS3AV_RES_MASK_60
;
581 if (res_50
|| res_60
) {
582 vid
= ps3av_resbit2vid(res_50
, res_60
);
586 /* check resolution */
587 res_50
= info
->res_50
.res_bits
& PS3AV_RES_MASK_50
;
588 res_60
= info
->res_60
.res_bits
& PS3AV_RES_MASK_60
;
589 if (res_50
|| res_60
) {
590 vid
= ps3av_resbit2vid(res_50
, res_60
);
594 if (ps3av
.region
& PS3AV_REGION_60
)
595 vid
= PS3AV_DEFAULT_HDMI_VID_REG_60
;
597 vid
= PS3AV_DEFAULT_HDMI_VID_REG_50
;
601 static int ps3av_auto_videomode(struct ps3av_pkt_av_get_hw_conf
*av_hw_conf
,
604 int i
, res
, vid
= -1, dvi
= 0, rgb
= 0;
605 struct ps3av_pkt_av_get_monitor_info monitor_info
;
606 struct ps3av_info_monitor
*info
;
608 /* get vid for hdmi */
609 for (i
= 0; i
< av_hw_conf
->num_of_hdmi
; i
++) {
610 res
= ps3av_cmd_video_get_monitor_info(&monitor_info
,
611 PS3AV_CMD_AVPORT_HDMI_0
+
616 ps3av_cmd_av_monitor_info_dump(&monitor_info
);
617 info
= &monitor_info
.info
;
619 if (info
->monitor_type
== PS3AV_MONITOR_TYPE_DVI
) {
620 dvi
= PS3AV_MODE_DVI
;
624 vid
= ps3av_hdmi_get_vid(info
);
633 vid
= PS3AV_DEFAULT_DVI_VID
;
634 } else if (vid
== -1) {
635 /* no HDMI interface or HDMI is off */
636 if (ps3av
.region
& PS3AV_REGION_60
)
637 vid
= PS3AV_DEFAULT_AVMULTI_VID_REG_60
;
639 vid
= PS3AV_DEFAULT_AVMULTI_VID_REG_50
;
640 if (ps3av
.region
& PS3AV_REGION_RGB
)
641 rgb
= PS3AV_MODE_RGB
;
643 /* HDMI: using DEFAULT HDMI_VID while booting up */
644 info
= &monitor_info
.info
;
645 if (ps3av
.region
& PS3AV_REGION_60
) {
646 if (info
->res_60
.res_bits
& PS3AV_RESBIT_720x480P
)
647 vid
= PS3AV_DEFAULT_HDMI_VID_REG_60
;
648 else if (info
->res_50
.res_bits
& PS3AV_RESBIT_720x576P
)
649 vid
= PS3AV_DEFAULT_HDMI_VID_REG_50
;
652 vid
= PS3AV_DEFAULT_HDMI_VID_REG_60
;
655 if (info
->res_50
.res_bits
& PS3AV_RESBIT_720x576P
)
656 vid
= PS3AV_DEFAULT_HDMI_VID_REG_50
;
657 else if (info
->res_60
.res_bits
& PS3AV_RESBIT_720x480P
)
658 vid
= PS3AV_DEFAULT_HDMI_VID_REG_60
;
661 vid
= PS3AV_DEFAULT_HDMI_VID_REG_50
;
666 return (ps3av_vid2table_id(vid
) | dvi
| rgb
);
669 static int ps3av_get_hw_conf(struct ps3av
*ps3av
)
674 res
= ps3av_cmd_av_get_hw_conf(&ps3av
->av_hw_conf
);
678 ps3av_cmd_av_hw_conf_dump(&ps3av
->av_hw_conf
);
680 for (i
= 0; i
< PS3AV_HEAD_MAX
; i
++)
681 ps3av
->head
[i
] = PS3AV_CMD_VIDEO_HEAD_A
+ i
;
682 for (i
= 0; i
< PS3AV_OPT_PORT_MAX
; i
++)
683 ps3av
->opt_port
[i
] = PS3AV_CMD_AVPORT_SPDIF_0
+ i
;
684 for (i
= 0; i
< ps3av
->av_hw_conf
.num_of_hdmi
; i
++)
685 ps3av
->av_port
[i
] = PS3AV_CMD_AVPORT_HDMI_0
+ i
;
686 for (j
= 0; j
< ps3av
->av_hw_conf
.num_of_avmulti
; j
++)
687 ps3av
->av_port
[i
+ j
] = PS3AV_CMD_AVPORT_AVMULTI_0
+ j
;
688 for (k
= 0; k
< ps3av
->av_hw_conf
.num_of_spdif
; k
++)
689 ps3av
->av_port
[i
+ j
+ k
] = PS3AV_CMD_AVPORT_SPDIF_0
+ k
;
691 /* set all audio port */
692 ps3av
->audio_port
= PS3AV_CMD_AUDIO_PORT_HDMI_0
693 | PS3AV_CMD_AUDIO_PORT_HDMI_1
694 | PS3AV_CMD_AUDIO_PORT_AVMULTI_0
695 | PS3AV_CMD_AUDIO_PORT_SPDIF_0
| PS3AV_CMD_AUDIO_PORT_SPDIF_1
;
700 /* set mode using id */
701 int ps3av_set_video_mode(u32 id
, int boot
)
706 size
= ARRAY_SIZE(video_mode_table
);
707 if ((id
& PS3AV_MODE_MASK
) > size
- 1 || id
< 0) {
708 dev_dbg(&ps3av_dev
.core
, "%s: error id :%d\n", __FUNCTION__
,
714 option
= id
& ~PS3AV_MODE_MASK
;
715 if ((id
& PS3AV_MODE_MASK
) == 0) {
716 id
= ps3av_auto_videomode(&ps3av
.av_hw_conf
, boot
);
718 printk(KERN_ERR
"%s: invalid id :%d\n", __FUNCTION__
,
727 ps3av
.ps3av_mode_old
= ps3av
.ps3av_mode
;
728 ps3av
.ps3av_mode
= id
;
729 if (ps3av_set_videomode())
730 ps3av
.ps3av_mode
= ps3av
.ps3av_mode_old
;
735 EXPORT_SYMBOL_GPL(ps3av_set_video_mode
);
737 int ps3av_set_mode(u32 id
, int boot
)
741 res
= ps3av_set_video_mode(id
, boot
);
745 res
= ps3av_set_audio_mode(PS3AV_CMD_AUDIO_NUM_OF_CH_2
,
746 PS3AV_CMD_AUDIO_FS_48K
,
747 PS3AV_CMD_AUDIO_WORD_BITS_16
,
748 PS3AV_CMD_AUDIO_FORMAT_PCM
,
749 PS3AV_CMD_AUDIO_SOURCE_SERIAL
);
756 EXPORT_SYMBOL_GPL(ps3av_set_mode
);
758 int ps3av_get_mode(void)
760 return ps3av
.ps3av_mode
;
763 EXPORT_SYMBOL_GPL(ps3av_get_mode
);
765 int ps3av_get_scanmode(int id
)
769 id
= id
& PS3AV_MODE_MASK
;
770 size
= ARRAY_SIZE(video_mode_table
);
771 if (id
> size
- 1 || id
< 0) {
772 printk(KERN_ERR
"%s: invalid mode %d\n", __FUNCTION__
, id
);
775 return video_mode_table
[id
].interlace
;
778 EXPORT_SYMBOL_GPL(ps3av_get_scanmode
);
780 int ps3av_get_refresh_rate(int id
)
784 id
= id
& PS3AV_MODE_MASK
;
785 size
= ARRAY_SIZE(video_mode_table
);
786 if (id
> size
- 1 || id
< 0) {
787 printk(KERN_ERR
"%s: invalid mode %d\n", __FUNCTION__
, id
);
790 return video_mode_table
[id
].freq
;
793 EXPORT_SYMBOL_GPL(ps3av_get_refresh_rate
);
795 /* get resolution by video_mode */
796 int ps3av_video_mode2res(u32 id
, u32
*xres
, u32
*yres
)
800 id
= id
& PS3AV_MODE_MASK
;
801 size
= ARRAY_SIZE(video_mode_table
);
802 if (id
> size
- 1 || id
< 0) {
803 printk(KERN_ERR
"%s: invalid mode %d\n", __FUNCTION__
, id
);
806 *xres
= video_mode_table
[id
].x
;
807 *yres
= video_mode_table
[id
].y
;
811 EXPORT_SYMBOL_GPL(ps3av_video_mode2res
);
814 int ps3av_video_mute(int mute
)
816 return ps3av_set_av_video_mute(mute
? PS3AV_CMD_MUTE_ON
817 : PS3AV_CMD_MUTE_OFF
);
820 EXPORT_SYMBOL_GPL(ps3av_video_mute
);
822 int ps3av_audio_mute(int mute
)
824 return ps3av_set_audio_mute(mute
? PS3AV_CMD_MUTE_ON
825 : PS3AV_CMD_MUTE_OFF
);
828 EXPORT_SYMBOL_GPL(ps3av_audio_mute
);
830 int ps3av_dev_open(void)
834 mutex_lock(&ps3av
.mutex
);
835 if (!ps3av
.open_count
++) {
836 status
= lv1_gpu_open(0);
838 printk(KERN_ERR
"%s: lv1_gpu_open failed %d\n",
839 __FUNCTION__
, status
);
843 mutex_unlock(&ps3av
.mutex
);
848 EXPORT_SYMBOL_GPL(ps3av_dev_open
);
850 int ps3av_dev_close(void)
854 mutex_lock(&ps3av
.mutex
);
855 if (ps3av
.open_count
<= 0) {
856 printk(KERN_ERR
"%s: GPU already closed\n", __FUNCTION__
);
858 } else if (!--ps3av
.open_count
) {
859 status
= lv1_gpu_close();
861 printk(KERN_WARNING
"%s: lv1_gpu_close failed %d\n",
862 __FUNCTION__
, status
);
864 mutex_unlock(&ps3av
.mutex
);
869 EXPORT_SYMBOL_GPL(ps3av_dev_close
);
871 static int ps3av_probe(struct ps3_vuart_port_device
*dev
)
876 dev_dbg(&ps3av_dev
.core
, "init ...\n");
877 dev_dbg(&ps3av_dev
.core
, " timeout=%d\n", timeout
);
879 memset(&ps3av
, 0, sizeof(ps3av
));
881 init_MUTEX(&ps3av
.sem
);
882 init_MUTEX_LOCKED(&ps3av
.ping
);
883 init_MUTEX(&ps3av
.pong
);
884 mutex_init(&ps3av
.mutex
);
885 ps3av
.ps3av_mode
= 0;
887 kernel_thread(ps3avd
, &ps3av
, CLONE_KERNEL
);
890 switch (ps3_os_area_get_av_multi_out()) {
891 case PS3_PARAM_AV_MULTI_OUT_NTSC
:
892 ps3av
.region
= PS3AV_REGION_60
;
894 case PS3_PARAM_AV_MULTI_OUT_PAL_YCBCR
:
895 case PS3_PARAM_AV_MULTI_OUT_SECAM
:
896 ps3av
.region
= PS3AV_REGION_50
;
898 case PS3_PARAM_AV_MULTI_OUT_PAL_RGB
:
899 ps3av
.region
= PS3AV_REGION_50
| PS3AV_REGION_RGB
;
902 ps3av
.region
= PS3AV_REGION_60
;
906 /* init avsetting modules */
907 res
= ps3av_cmd_init();
909 printk(KERN_ERR
"%s: ps3av_cmd_init failed %d\n", __FUNCTION__
,
912 ps3av_get_hw_conf(&ps3av
);
913 id
= ps3av_auto_videomode(&ps3av
.av_hw_conf
, 1);
914 mutex_lock(&ps3av
.mutex
);
915 ps3av
.ps3av_mode
= id
;
916 mutex_unlock(&ps3av
.mutex
);
918 dev_dbg(&ps3av_dev
.core
, "init...done\n");
923 static int ps3av_remove(struct ps3_vuart_port_device
*dev
)
925 if (ps3av
.available
) {
933 static void ps3av_shutdown(struct ps3_vuart_port_device
*dev
)
938 static struct ps3_vuart_port_driver ps3av_driver
= {
939 .match_id
= PS3_MATCH_ID_AV_SETTINGS
,
943 .probe
= ps3av_probe
,
944 .remove
= ps3av_remove
,
945 .shutdown
= ps3av_shutdown
,
948 static int ps3av_module_init(void)
950 int error
= ps3_vuart_port_driver_register(&ps3av_driver
);
953 "%s: ps3_vuart_port_driver_register failed %d\n",
954 __FUNCTION__
, error
);
958 error
= ps3_vuart_port_device_register(&ps3av_dev
);
961 "%s: ps3_vuart_port_device_register failed %d\n",
962 __FUNCTION__
, error
);
967 static void __exit
ps3av_module_exit(void)
969 device_unregister(&ps3av_dev
.core
);
970 ps3_vuart_port_driver_unregister(&ps3av_driver
);
973 subsys_initcall(ps3av_module_init
);
974 module_exit(ps3av_module_exit
);