2 * PS3 AV backend support.
4 * Copyright (C) 2007 Sony Computer Entertainment Inc.
5 * Copyright 2007 Sony Corp.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; version 2 of the License.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/delay.h>
24 #include <linux/notifier.h>
25 #include <linux/ioctl.h>
27 #include <asm/firmware.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);
41 struct work_struct work
;
42 struct completion done
;
43 struct workqueue_struct
*wq
;
45 struct ps3_system_bus_device
*dev
;
48 struct ps3av_pkt_av_get_hw_conf av_hw_conf
;
49 u32 av_port
[PS3AV_AV_PORT_MAX
+ PS3AV_OPT_PORT_MAX
];
50 u32 opt_port
[PS3AV_OPT_PORT_MAX
];
51 u32 head
[PS3AV_HEAD_MAX
];
56 struct ps3av_reply_hdr reply_hdr
;
57 u8 raw
[PS3AV_BUF_SIZE
];
59 void (*flip_ctl
)(int on
, void *data
);
64 #define YUV444 PS3AV_CMD_VIDEO_CS_YUV444_8
65 #define RGB8 PS3AV_CMD_VIDEO_CS_RGB_8
67 #define XRGB PS3AV_CMD_VIDEO_FMT_X8R8G8B8
69 #define A_N PS3AV_CMD_AV_ASPECT_4_3
70 #define A_W PS3AV_CMD_AV_ASPECT_16_9
71 static const struct avset_video_mode
{
80 } video_mode_table
[] = {
82 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_480I
, A_N
, 720, 480, 1, 60},
83 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_480P
, A_N
, 720, 480, 0, 60},
84 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_720P_60HZ
, A_N
, 1280, 720, 0, 60},
85 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_1080I_60HZ
, A_W
, 1920, 1080, 1, 60},
86 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_1080P_60HZ
, A_W
, 1920, 1080, 0, 60},
87 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_576I
, A_N
, 720, 576, 1, 50},
88 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_576P
, A_N
, 720, 576, 0, 50},
89 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_720P_50HZ
, A_N
, 1280, 720, 0, 50},
90 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_1080I_50HZ
, A_W
, 1920, 1080, 1, 50},
91 {YUV444
, XRGB
, PS3AV_CMD_VIDEO_VID_1080P_50HZ
, A_W
, 1920, 1080, 0, 50},
92 { RGB8
, XRGB
, PS3AV_CMD_VIDEO_VID_WXGA
, A_W
, 1280, 768, 0, 60},
93 { RGB8
, XRGB
, PS3AV_CMD_VIDEO_VID_SXGA
, A_N
, 1280, 1024, 0, 60},
94 { RGB8
, XRGB
, PS3AV_CMD_VIDEO_VID_WUXGA
, A_W
, 1920, 1200, 0, 60},
98 static u32 cmd_table
[] = {
102 PS3AV_CID_VIDEO_INIT
,
103 PS3AV_CID_AUDIO_INIT
,
106 PS3AV_CID_AV_ENABLE_EVENT
,
107 PS3AV_CID_AV_DISABLE_EVENT
,
109 PS3AV_CID_AV_VIDEO_CS
,
110 PS3AV_CID_AV_VIDEO_MUTE
,
111 PS3AV_CID_AV_VIDEO_DISABLE_SIG
,
112 PS3AV_CID_AV_AUDIO_PARAM
,
113 PS3AV_CID_AV_AUDIO_MUTE
,
114 PS3AV_CID_AV_HDMI_MODE
,
115 PS3AV_CID_AV_TV_MUTE
,
117 PS3AV_CID_VIDEO_MODE
,
118 PS3AV_CID_VIDEO_FORMAT
,
119 PS3AV_CID_VIDEO_PITCH
,
121 PS3AV_CID_AUDIO_MODE
,
122 PS3AV_CID_AUDIO_MUTE
,
123 PS3AV_CID_AUDIO_ACTIVE
,
124 PS3AV_CID_AUDIO_INACTIVE
,
128 PS3AV_CID_AV_GET_HW_CONF
,
129 PS3AV_CID_AV_GET_MONITOR_INFO
,
132 PS3AV_CID_EVENT_UNPLUGGED
,
133 PS3AV_CID_EVENT_PLUGGED
,
134 PS3AV_CID_EVENT_HDCP_DONE
,
135 PS3AV_CID_EVENT_HDCP_FAIL
,
136 PS3AV_CID_EVENT_HDCP_AUTH
,
137 PS3AV_CID_EVENT_HDCP_ERROR
,
142 #define PS3AV_EVENT_CMD_MASK 0x10000000
143 #define PS3AV_EVENT_ID_MASK 0x0000ffff
144 #define PS3AV_CID_MASK 0xffffffff
145 #define PS3AV_REPLY_BIT 0x80000000
147 #define ps3av_event_get_port_id(cid) ((cid >> 16) & 0xff)
149 static u32
*ps3av_search_cmd_table(u32 cid
, u32 mask
)
155 for (i
= 0;; table
++, i
++) {
156 if ((*table
& mask
) == (cid
& mask
))
164 static int ps3av_parse_event_packet(const struct ps3av_reply_hdr
*hdr
)
168 if (hdr
->cid
& PS3AV_EVENT_CMD_MASK
) {
169 table
= ps3av_search_cmd_table(hdr
->cid
, PS3AV_EVENT_CMD_MASK
);
171 dev_dbg(&ps3av
->dev
->core
,
172 "recv event packet cid:%08x port:0x%x size:%d\n",
173 hdr
->cid
, ps3av_event_get_port_id(hdr
->cid
),
177 "%s: failed event packet, cid:%08x size:%d\n",
178 __func__
, hdr
->cid
, hdr
->size
);
179 return 1; /* receive event packet */
185 #define POLLING_INTERVAL 25 /* in msec */
187 static int ps3av_vuart_write(struct ps3_system_bus_device
*dev
,
188 const void *buf
, unsigned long size
)
191 dev_dbg(&dev
->core
, " -> %s:%d\n", __func__
, __LINE__
);
192 error
= ps3_vuart_write(dev
, buf
, size
);
193 dev_dbg(&dev
->core
, " <- %s:%d\n", __func__
, __LINE__
);
194 return error
? error
: size
;
197 static int ps3av_vuart_read(struct ps3_system_bus_device
*dev
, void *buf
,
198 unsigned long size
, int timeout
)
203 dev_dbg(&dev
->core
, " -> %s:%d\n", __func__
, __LINE__
);
204 timeout
= (timeout
+ POLLING_INTERVAL
- 1) / POLLING_INTERVAL
;
205 while (loopcnt
++ <= timeout
) {
206 error
= ps3_vuart_read(dev
, buf
, size
);
209 if (error
!= -EAGAIN
) {
210 printk(KERN_ERR
"%s: ps3_vuart_read failed %d\n",
214 msleep(POLLING_INTERVAL
);
219 static int ps3av_send_cmd_pkt(const struct ps3av_send_hdr
*send_buf
,
220 struct ps3av_reply_hdr
*recv_buf
, int write_len
,
231 res
= ps3av_vuart_write(ps3av
->dev
, send_buf
, write_len
);
233 dev_dbg(&ps3av
->dev
->core
,
234 "%s: ps3av_vuart_write() failed (result=%d)\n",
243 res
= ps3av_vuart_read(ps3av
->dev
, recv_buf
, PS3AV_HDR_SIZE
,
245 if (res
!= PS3AV_HDR_SIZE
) {
246 dev_dbg(&ps3av
->dev
->core
,
247 "%s: ps3av_vuart_read() failed (result=%d)\n",
253 res
= ps3av_vuart_read(ps3av
->dev
, &recv_buf
->cid
,
254 recv_buf
->size
, timeout
);
256 dev_dbg(&ps3av
->dev
->core
,
257 "%s: ps3av_vuart_read() failed (result=%d)\n",
261 res
+= PS3AV_HDR_SIZE
; /* total len */
262 event
= ps3av_parse_event_packet(recv_buf
);
263 /* ret > 0 event packet */
266 if ((cmd
| PS3AV_REPLY_BIT
) != recv_buf
->cid
) {
267 dev_dbg(&ps3av
->dev
->core
, "%s: reply err (result=%x)\n",
268 __func__
, recv_buf
->cid
);
275 static int ps3av_process_reply_packet(struct ps3av_send_hdr
*cmd_buf
,
276 const struct ps3av_reply_hdr
*recv_buf
,
281 if (recv_buf
->version
!= PS3AV_VERSION
) {
282 dev_dbg(&ps3av
->dev
->core
, "reply_packet invalid version:%x\n",
286 return_len
= recv_buf
->size
+ PS3AV_HDR_SIZE
;
287 if (return_len
> user_buf_size
)
288 return_len
= user_buf_size
;
289 memcpy(cmd_buf
, recv_buf
, return_len
);
290 return 0; /* success */
293 void ps3av_set_hdr(u32 cid
, u16 size
, struct ps3av_send_hdr
*hdr
)
295 hdr
->version
= PS3AV_VERSION
;
296 hdr
->size
= size
- PS3AV_HDR_SIZE
;
300 int ps3av_do_pkt(u32 cid
, u16 send_len
, size_t usr_buf_size
,
301 struct ps3av_send_hdr
*buf
)
308 mutex_lock(&ps3av
->mutex
);
310 table
= ps3av_search_cmd_table(cid
, PS3AV_CID_MASK
);
312 BUG_ON(send_len
< PS3AV_HDR_SIZE
);
313 BUG_ON(usr_buf_size
< send_len
);
314 BUG_ON(usr_buf_size
> PS3AV_BUF_SIZE
);
317 ps3av_set_hdr(cid
, send_len
, buf
);
319 /* send packet via vuart */
320 res
= ps3av_send_cmd_pkt(buf
, &ps3av
->recv_buf
.reply_hdr
, send_len
,
324 "%s: ps3av_send_cmd_pkt() failed (result=%d)\n",
329 /* process reply packet */
330 res
= ps3av_process_reply_packet(buf
, &ps3av
->recv_buf
.reply_hdr
,
333 printk(KERN_ERR
"%s: put_return_status() failed (result=%d)\n",
338 mutex_unlock(&ps3av
->mutex
);
342 mutex_unlock(&ps3av
->mutex
);
343 printk(KERN_ERR
"%s: failed cid:%x res:%d\n", __func__
, cid
, res
);
347 static int ps3av_set_av_video_mute(u32 mute
)
349 int i
, num_of_av_port
, res
;
351 num_of_av_port
= ps3av
->av_hw_conf
.num_of_hdmi
+
352 ps3av
->av_hw_conf
.num_of_avmulti
;
354 for (i
= 0; i
< num_of_av_port
; i
++) {
355 res
= ps3av_cmd_av_video_mute(1, &ps3av
->av_port
[i
], mute
);
363 static int ps3av_set_video_disable_sig(void)
365 int i
, num_of_hdmi_port
, num_of_av_port
, res
;
367 num_of_hdmi_port
= ps3av
->av_hw_conf
.num_of_hdmi
;
368 num_of_av_port
= ps3av
->av_hw_conf
.num_of_hdmi
+
369 ps3av
->av_hw_conf
.num_of_avmulti
;
372 for (i
= 0; i
< num_of_hdmi_port
; i
++) {
373 res
= ps3av_cmd_av_tv_mute(ps3av
->av_port
[i
],
381 for (i
= 0; i
< num_of_av_port
; i
++) {
382 res
= ps3av_cmd_av_video_disable_sig(ps3av
->av_port
[i
]);
385 if (i
< num_of_hdmi_port
) {
386 res
= ps3av_cmd_av_tv_mute(ps3av
->av_port
[i
],
397 static int ps3av_set_audio_mute(u32 mute
)
399 int i
, num_of_av_port
, num_of_opt_port
, res
;
401 num_of_av_port
= ps3av
->av_hw_conf
.num_of_hdmi
+
402 ps3av
->av_hw_conf
.num_of_avmulti
;
403 num_of_opt_port
= ps3av
->av_hw_conf
.num_of_spdif
;
405 for (i
= 0; i
< num_of_av_port
; i
++) {
406 res
= ps3av_cmd_av_audio_mute(1, &ps3av
->av_port
[i
], mute
);
410 for (i
= 0; i
< num_of_opt_port
; i
++) {
411 res
= ps3av_cmd_audio_mute(1, &ps3av
->opt_port
[i
], mute
);
419 int ps3av_set_audio_mode(u32 ch
, u32 fs
, u32 word_bits
, u32 format
, u32 source
)
421 struct ps3av_pkt_avb_param avb_param
;
422 int i
, num_of_audio
, vid
, res
;
423 struct ps3av_pkt_audio_mode audio_mode
;
426 num_of_audio
= ps3av
->av_hw_conf
.num_of_hdmi
+
427 ps3av
->av_hw_conf
.num_of_avmulti
+
428 ps3av
->av_hw_conf
.num_of_spdif
;
430 avb_param
.num_of_video_pkt
= 0;
431 avb_param
.num_of_audio_pkt
= PS3AV_AVB_NUM_AUDIO
; /* always 0 */
432 avb_param
.num_of_av_video_pkt
= 0;
433 avb_param
.num_of_av_audio_pkt
= ps3av
->av_hw_conf
.num_of_hdmi
;
435 vid
= video_mode_table
[ps3av
->ps3av_mode
].vid
;
438 ps3av_set_audio_mute(PS3AV_CMD_MUTE_ON
);
441 res
= ps3av_cmd_audio_active(0, ps3av
->audio_port
);
443 dev_dbg(&ps3av
->dev
->core
,
444 "ps3av_cmd_audio_active OFF failed\n");
447 for (i
= 0; i
< num_of_audio
; i
++) {
448 ps3av_cmd_set_audio_mode(&audio_mode
, ps3av
->av_port
[i
], ch
,
449 fs
, word_bits
, format
, source
);
450 if (i
< ps3av
->av_hw_conf
.num_of_hdmi
) {
452 len
+= ps3av_cmd_set_av_audio_param(&avb_param
.buf
[len
],
456 /* audio_mode pkt should be sent separately */
457 res
= ps3av_cmd_audio_mode(&audio_mode
);
459 dev_dbg(&ps3av
->dev
->core
,
460 "ps3av_cmd_audio_mode failed, port:%x\n", i
);
463 /* send command using avb pkt */
464 len
+= offsetof(struct ps3av_pkt_avb_param
, buf
);
465 res
= ps3av_cmd_avb_param(&avb_param
, len
);
467 dev_dbg(&ps3av
->dev
->core
, "ps3av_cmd_avb_param failed\n");
470 ps3av_set_audio_mute(PS3AV_CMD_MUTE_OFF
);
473 res
= ps3av_cmd_audio_active(1, ps3av
->audio_port
);
475 dev_dbg(&ps3av
->dev
->core
,
476 "ps3av_cmd_audio_active ON failed\n");
481 EXPORT_SYMBOL_GPL(ps3av_set_audio_mode
);
483 static int ps3av_set_videomode(void)
486 ps3av_set_av_video_mute(PS3AV_CMD_MUTE_ON
);
488 /* wake up ps3avd to do the actual video mode setting */
489 queue_work(ps3av
->wq
, &ps3av
->work
);
494 static void ps3av_set_videomode_packet(u32 id
)
496 struct ps3av_pkt_avb_param avb_param
;
498 u32 len
= 0, av_video_cs
;
499 const struct avset_video_mode
*video_mode
;
502 video_mode
= &video_mode_table
[id
& PS3AV_MODE_MASK
];
504 avb_param
.num_of_video_pkt
= PS3AV_AVB_NUM_VIDEO
; /* num of head */
505 avb_param
.num_of_audio_pkt
= 0;
506 avb_param
.num_of_av_video_pkt
= ps3av
->av_hw_conf
.num_of_hdmi
+
507 ps3av
->av_hw_conf
.num_of_avmulti
;
508 avb_param
.num_of_av_audio_pkt
= 0;
511 for (i
= 0; i
< avb_param
.num_of_video_pkt
; i
++)
512 len
+= ps3av_cmd_set_video_mode(&avb_param
.buf
[len
],
513 ps3av
->head
[i
], video_mode
->vid
,
514 video_mode
->fmt
, id
);
516 for (i
= 0; i
< avb_param
.num_of_av_video_pkt
; i
++) {
517 if (id
& PS3AV_MODE_DVI
|| id
& PS3AV_MODE_RGB
)
520 av_video_cs
= video_mode
->cs
;
521 #ifndef PS3AV_HDMI_YUV
522 if (ps3av
->av_port
[i
] == PS3AV_CMD_AVPORT_HDMI_0
||
523 ps3av
->av_port
[i
] == PS3AV_CMD_AVPORT_HDMI_1
)
524 av_video_cs
= RGB8
; /* use RGB for HDMI */
526 len
+= ps3av_cmd_set_av_video_cs(&avb_param
.buf
[len
],
528 video_mode
->vid
, av_video_cs
,
529 video_mode
->aspect
, id
);
531 /* send command using avb pkt */
532 len
+= offsetof(struct ps3av_pkt_avb_param
, buf
);
533 res
= ps3av_cmd_avb_param(&avb_param
, len
);
534 if (res
== PS3AV_STATUS_NO_SYNC_HEAD
)
536 "%s: Command failed. Please try your request again. \n",
539 dev_dbg(&ps3av
->dev
->core
, "ps3av_cmd_avb_param failed\n");
542 static void ps3av_set_videomode_cont(u32 id
, u32 old_id
)
547 /* video signal off */
548 ps3av_set_video_disable_sig();
551 * AV backend needs non-VESA mode setting at least one time
552 * when VESA mode is used.
554 if (vesa
== 0 && (id
& PS3AV_MODE_MASK
) >= 11) {
556 ps3av_set_videomode_packet(2); /* 480P */
560 /* Retail PS3 product doesn't support this */
561 if (id
& PS3AV_MODE_HDCP_OFF
) {
562 res
= ps3av_cmd_av_hdmi_mode(PS3AV_CMD_AV_HDMI_HDCP_OFF
);
563 if (res
== PS3AV_STATUS_UNSUPPORTED_HDMI_MODE
)
564 dev_dbg(&ps3av
->dev
->core
, "Not supported\n");
566 dev_dbg(&ps3av
->dev
->core
,
567 "ps3av_cmd_av_hdmi_mode failed\n");
568 } else if (old_id
& PS3AV_MODE_HDCP_OFF
) {
569 res
= ps3av_cmd_av_hdmi_mode(PS3AV_CMD_AV_HDMI_MODE_NORMAL
);
570 if (res
< 0 && res
!= PS3AV_STATUS_UNSUPPORTED_HDMI_MODE
)
571 dev_dbg(&ps3av
->dev
->core
,
572 "ps3av_cmd_av_hdmi_mode failed\n");
575 ps3av_set_videomode_packet(id
);
579 ps3av_set_av_video_mute(PS3AV_CMD_MUTE_OFF
);
582 static void ps3avd(struct work_struct
*work
)
584 ps3av_set_videomode_cont(ps3av
->ps3av_mode
, ps3av
->ps3av_mode_old
);
585 complete(&ps3av
->done
);
588 static int ps3av_vid2table_id(int vid
)
592 for (i
= 1; i
< ARRAY_SIZE(video_mode_table
); i
++)
593 if (video_mode_table
[i
].vid
== vid
)
598 static int ps3av_resbit2vid(u32 res_50
, u32 res_60
)
602 if (res_50
> res_60
) { /* if res_50 == res_60, res_60 will be used */
603 if (res_50
& PS3AV_RESBIT_1920x1080P
)
604 vid
= PS3AV_CMD_VIDEO_VID_1080P_50HZ
;
605 else if (res_50
& PS3AV_RESBIT_1920x1080I
)
606 vid
= PS3AV_CMD_VIDEO_VID_1080I_50HZ
;
607 else if (res_50
& PS3AV_RESBIT_1280x720P
)
608 vid
= PS3AV_CMD_VIDEO_VID_720P_50HZ
;
609 else if (res_50
& PS3AV_RESBIT_720x576P
)
610 vid
= PS3AV_CMD_VIDEO_VID_576P
;
614 if (res_60
& PS3AV_RESBIT_1920x1080P
)
615 vid
= PS3AV_CMD_VIDEO_VID_1080P_60HZ
;
616 else if (res_60
& PS3AV_RESBIT_1920x1080I
)
617 vid
= PS3AV_CMD_VIDEO_VID_1080I_60HZ
;
618 else if (res_60
& PS3AV_RESBIT_1280x720P
)
619 vid
= PS3AV_CMD_VIDEO_VID_720P_60HZ
;
620 else if (res_60
& PS3AV_RESBIT_720x480P
)
621 vid
= PS3AV_CMD_VIDEO_VID_480P
;
628 static int ps3av_hdmi_get_vid(struct ps3av_info_monitor
*info
)
633 if (info
->monitor_type
!= PS3AV_MONITOR_TYPE_HDMI
)
636 /* check native resolution */
637 res_50
= info
->res_50
.native
& PS3AV_RES_MASK_50
;
638 res_60
= info
->res_60
.native
& PS3AV_RES_MASK_60
;
639 if (res_50
|| res_60
) {
640 vid
= ps3av_resbit2vid(res_50
, res_60
);
644 /* check resolution */
645 res_50
= info
->res_50
.res_bits
& PS3AV_RES_MASK_50
;
646 res_60
= info
->res_60
.res_bits
& PS3AV_RES_MASK_60
;
647 if (res_50
|| res_60
) {
648 vid
= ps3av_resbit2vid(res_50
, res_60
);
652 if (ps3av
->region
& PS3AV_REGION_60
)
653 vid
= PS3AV_DEFAULT_HDMI_VID_REG_60
;
655 vid
= PS3AV_DEFAULT_HDMI_VID_REG_50
;
659 static void ps3av_monitor_info_dump(const struct ps3av_pkt_av_get_monitor_info
*monitor_info
)
661 const struct ps3av_info_monitor
*info
= &monitor_info
->info
;
662 const struct ps3av_info_audio
*audio
= info
->audio
;
663 char id
[sizeof(info
->monitor_id
)*3+1];
666 pr_debug("Monitor Info: size %u\n", monitor_info
->send_hdr
.size
);
668 pr_debug("avport: %02x\n", info
->avport
);
669 for (i
= 0; i
< sizeof(info
->monitor_id
); i
++)
670 sprintf(&id
[i
*3], " %02x", info
->monitor_id
[i
]);
671 pr_debug("monitor_id: %s\n", id
);
672 pr_debug("monitor_type: %02x\n", info
->monitor_type
);
673 pr_debug("monitor_name: %.*s\n", (int)sizeof(info
->monitor_name
),
677 pr_debug("resolution_60: bits: %08x native: %08x\n",
678 info
->res_60
.res_bits
, info
->res_60
.native
);
679 pr_debug("resolution_50: bits: %08x native: %08x\n",
680 info
->res_50
.res_bits
, info
->res_50
.native
);
681 pr_debug("resolution_other: bits: %08x native: %08x\n",
682 info
->res_other
.res_bits
, info
->res_other
.native
);
683 pr_debug("resolution_vesa: bits: %08x native: %08x\n",
684 info
->res_vesa
.res_bits
, info
->res_vesa
.native
);
687 pr_debug("color space rgb: %02x\n", info
->cs
.rgb
);
688 pr_debug("color space yuv444: %02x\n", info
->cs
.yuv444
);
689 pr_debug("color space yuv422: %02x\n", info
->cs
.yuv422
);
692 pr_debug("color info red: X %04x Y %04x\n", info
->color
.red_x
,
694 pr_debug("color info green: X %04x Y %04x\n", info
->color
.green_x
,
695 info
->color
.green_y
);
696 pr_debug("color info blue: X %04x Y %04x\n", info
->color
.blue_x
,
698 pr_debug("color info white: X %04x Y %04x\n", info
->color
.white_x
,
699 info
->color
.white_y
);
700 pr_debug("color info gamma: %08x\n", info
->color
.gamma
);
703 pr_debug("supported_AI: %02x\n", info
->supported_ai
);
704 pr_debug("speaker_info: %02x\n", info
->speaker_info
);
705 pr_debug("num of audio: %02x\n", info
->num_of_audio_block
);
708 for (i
= 0; i
< info
->num_of_audio_block
; i
++) {
709 pr_debug("audio[%d] type: %02x max_ch: %02x fs: %02x sbit: "
711 i
, audio
->type
, audio
->max_num_of_ch
, audio
->fs
,
717 static int ps3av_auto_videomode(struct ps3av_pkt_av_get_hw_conf
*av_hw_conf
,
720 int i
, res
, vid
= -1, dvi
= 0, rgb
= 0;
721 struct ps3av_pkt_av_get_monitor_info monitor_info
;
722 struct ps3av_info_monitor
*info
;
724 /* get vid for hdmi */
725 for (i
= 0; i
< av_hw_conf
->num_of_hdmi
; i
++) {
726 res
= ps3av_cmd_video_get_monitor_info(&monitor_info
,
727 PS3AV_CMD_AVPORT_HDMI_0
+
732 ps3av_monitor_info_dump(&monitor_info
);
733 info
= &monitor_info
.info
;
735 if (info
->monitor_type
== PS3AV_MONITOR_TYPE_DVI
) {
736 dvi
= PS3AV_MODE_DVI
;
740 vid
= ps3av_hdmi_get_vid(info
);
749 vid
= PS3AV_DEFAULT_DVI_VID
;
750 } else if (vid
== -1) {
751 /* no HDMI interface or HDMI is off */
752 if (ps3av
->region
& PS3AV_REGION_60
)
753 vid
= PS3AV_DEFAULT_AVMULTI_VID_REG_60
;
755 vid
= PS3AV_DEFAULT_AVMULTI_VID_REG_50
;
756 if (ps3av
->region
& PS3AV_REGION_RGB
)
757 rgb
= PS3AV_MODE_RGB
;
759 /* HDMI: using DEFAULT HDMI_VID while booting up */
760 info
= &monitor_info
.info
;
761 if (ps3av
->region
& PS3AV_REGION_60
) {
762 if (info
->res_60
.res_bits
& PS3AV_RESBIT_720x480P
)
763 vid
= PS3AV_DEFAULT_HDMI_VID_REG_60
;
764 else if (info
->res_50
.res_bits
& PS3AV_RESBIT_720x576P
)
765 vid
= PS3AV_DEFAULT_HDMI_VID_REG_50
;
768 vid
= PS3AV_DEFAULT_HDMI_VID_REG_60
;
771 if (info
->res_50
.res_bits
& PS3AV_RESBIT_720x576P
)
772 vid
= PS3AV_DEFAULT_HDMI_VID_REG_50
;
773 else if (info
->res_60
.res_bits
& PS3AV_RESBIT_720x480P
)
774 vid
= PS3AV_DEFAULT_HDMI_VID_REG_60
;
777 vid
= PS3AV_DEFAULT_HDMI_VID_REG_50
;
782 return (ps3av_vid2table_id(vid
) | dvi
| rgb
);
785 static int ps3av_get_hw_conf(struct ps3av
*ps3av
)
788 const struct ps3av_pkt_av_get_hw_conf
*hw_conf
;
791 res
= ps3av_cmd_av_get_hw_conf(&ps3av
->av_hw_conf
);
795 hw_conf
= &ps3av
->av_hw_conf
;
796 pr_debug("av_h_conf: num of hdmi: %u\n", hw_conf
->num_of_hdmi
);
797 pr_debug("av_h_conf: num of avmulti: %u\n", hw_conf
->num_of_avmulti
);
798 pr_debug("av_h_conf: num of spdif: %u\n", hw_conf
->num_of_spdif
);
800 for (i
= 0; i
< PS3AV_HEAD_MAX
; i
++)
801 ps3av
->head
[i
] = PS3AV_CMD_VIDEO_HEAD_A
+ i
;
802 for (i
= 0; i
< PS3AV_OPT_PORT_MAX
; i
++)
803 ps3av
->opt_port
[i
] = PS3AV_CMD_AVPORT_SPDIF_0
+ i
;
804 for (i
= 0; i
< hw_conf
->num_of_hdmi
; i
++)
805 ps3av
->av_port
[i
] = PS3AV_CMD_AVPORT_HDMI_0
+ i
;
806 for (j
= 0; j
< hw_conf
->num_of_avmulti
; j
++)
807 ps3av
->av_port
[i
+ j
] = PS3AV_CMD_AVPORT_AVMULTI_0
+ j
;
808 for (k
= 0; k
< hw_conf
->num_of_spdif
; k
++)
809 ps3av
->av_port
[i
+ j
+ k
] = PS3AV_CMD_AVPORT_SPDIF_0
+ k
;
811 /* set all audio port */
812 ps3av
->audio_port
= PS3AV_CMD_AUDIO_PORT_HDMI_0
813 | PS3AV_CMD_AUDIO_PORT_HDMI_1
814 | PS3AV_CMD_AUDIO_PORT_AVMULTI_0
815 | PS3AV_CMD_AUDIO_PORT_SPDIF_0
| PS3AV_CMD_AUDIO_PORT_SPDIF_1
;
820 /* set mode using id */
821 int ps3av_set_video_mode(u32 id
, int boot
)
826 size
= ARRAY_SIZE(video_mode_table
);
827 if ((id
& PS3AV_MODE_MASK
) > size
- 1 || id
< 0) {
828 dev_dbg(&ps3av
->dev
->core
, "%s: error id :%d\n", __func__
, id
);
833 option
= id
& ~PS3AV_MODE_MASK
;
834 if ((id
& PS3AV_MODE_MASK
) == 0) {
835 id
= ps3av_auto_videomode(&ps3av
->av_hw_conf
, boot
);
837 printk(KERN_ERR
"%s: invalid id :%d\n", __func__
, id
);
844 wait_for_completion(&ps3av
->done
);
845 ps3av
->ps3av_mode_old
= ps3av
->ps3av_mode
;
846 ps3av
->ps3av_mode
= id
;
847 if (ps3av_set_videomode())
848 ps3av
->ps3av_mode
= ps3av
->ps3av_mode_old
;
853 EXPORT_SYMBOL_GPL(ps3av_set_video_mode
);
855 int ps3av_get_auto_mode(int boot
)
857 return ps3av_auto_videomode(&ps3av
->av_hw_conf
, boot
);
860 EXPORT_SYMBOL_GPL(ps3av_get_auto_mode
);
862 int ps3av_set_mode(u32 id
, int boot
)
866 res
= ps3av_set_video_mode(id
, boot
);
870 res
= ps3av_set_audio_mode(PS3AV_CMD_AUDIO_NUM_OF_CH_2
,
871 PS3AV_CMD_AUDIO_FS_48K
,
872 PS3AV_CMD_AUDIO_WORD_BITS_16
,
873 PS3AV_CMD_AUDIO_FORMAT_PCM
,
874 PS3AV_CMD_AUDIO_SOURCE_SERIAL
);
881 EXPORT_SYMBOL_GPL(ps3av_set_mode
);
883 int ps3av_get_mode(void)
885 return ps3av
? ps3av
->ps3av_mode
: 0;
888 EXPORT_SYMBOL_GPL(ps3av_get_mode
);
890 int ps3av_get_scanmode(int id
)
894 id
= id
& PS3AV_MODE_MASK
;
895 size
= ARRAY_SIZE(video_mode_table
);
896 if (id
> size
- 1 || id
< 0) {
897 printk(KERN_ERR
"%s: invalid mode %d\n", __func__
, id
);
900 return video_mode_table
[id
].interlace
;
903 EXPORT_SYMBOL_GPL(ps3av_get_scanmode
);
905 int ps3av_get_refresh_rate(int id
)
909 id
= id
& PS3AV_MODE_MASK
;
910 size
= ARRAY_SIZE(video_mode_table
);
911 if (id
> size
- 1 || id
< 0) {
912 printk(KERN_ERR
"%s: invalid mode %d\n", __func__
, id
);
915 return video_mode_table
[id
].freq
;
918 EXPORT_SYMBOL_GPL(ps3av_get_refresh_rate
);
920 /* get resolution by video_mode */
921 int ps3av_video_mode2res(u32 id
, u32
*xres
, u32
*yres
)
925 id
= id
& PS3AV_MODE_MASK
;
926 size
= ARRAY_SIZE(video_mode_table
);
927 if (id
> size
- 1 || id
< 0) {
928 printk(KERN_ERR
"%s: invalid mode %d\n", __func__
, id
);
931 *xres
= video_mode_table
[id
].x
;
932 *yres
= video_mode_table
[id
].y
;
936 EXPORT_SYMBOL_GPL(ps3av_video_mode2res
);
939 int ps3av_video_mute(int mute
)
941 return ps3av_set_av_video_mute(mute
? PS3AV_CMD_MUTE_ON
942 : PS3AV_CMD_MUTE_OFF
);
945 EXPORT_SYMBOL_GPL(ps3av_video_mute
);
947 int ps3av_audio_mute(int mute
)
949 return ps3av_set_audio_mute(mute
? PS3AV_CMD_MUTE_ON
950 : PS3AV_CMD_MUTE_OFF
);
953 EXPORT_SYMBOL_GPL(ps3av_audio_mute
);
955 void ps3av_register_flip_ctl(void (*flip_ctl
)(int on
, void *data
),
958 mutex_lock(&ps3av
->mutex
);
959 ps3av
->flip_ctl
= flip_ctl
;
960 ps3av
->flip_data
= flip_data
;
961 mutex_unlock(&ps3av
->mutex
);
963 EXPORT_SYMBOL_GPL(ps3av_register_flip_ctl
);
965 void ps3av_flip_ctl(int on
)
967 mutex_lock(&ps3av
->mutex
);
969 ps3av
->flip_ctl(on
, ps3av
->flip_data
);
970 mutex_unlock(&ps3av
->mutex
);
973 static int ps3av_probe(struct ps3_system_bus_device
*dev
)
978 dev_dbg(&dev
->core
, " -> %s:%d\n", __func__
, __LINE__
);
979 dev_dbg(&dev
->core
, " timeout=%d\n", timeout
);
982 dev_err(&dev
->core
, "Only one ps3av device is supported\n");
986 ps3av
= kzalloc(sizeof(*ps3av
), GFP_KERNEL
);
990 mutex_init(&ps3av
->mutex
);
991 ps3av
->ps3av_mode
= 0;
994 INIT_WORK(&ps3av
->work
, ps3avd
);
995 init_completion(&ps3av
->done
);
996 complete(&ps3av
->done
);
997 ps3av
->wq
= create_singlethread_workqueue("ps3avd");
1001 switch (ps3_os_area_get_av_multi_out()) {
1002 case PS3_PARAM_AV_MULTI_OUT_NTSC
:
1003 ps3av
->region
= PS3AV_REGION_60
;
1005 case PS3_PARAM_AV_MULTI_OUT_PAL_YCBCR
:
1006 case PS3_PARAM_AV_MULTI_OUT_SECAM
:
1007 ps3av
->region
= PS3AV_REGION_50
;
1009 case PS3_PARAM_AV_MULTI_OUT_PAL_RGB
:
1010 ps3av
->region
= PS3AV_REGION_50
| PS3AV_REGION_RGB
;
1013 ps3av
->region
= PS3AV_REGION_60
;
1017 /* init avsetting modules */
1018 res
= ps3av_cmd_init();
1020 printk(KERN_ERR
"%s: ps3av_cmd_init failed %d\n", __func__
,
1023 ps3av_get_hw_conf(ps3av
);
1024 id
= ps3av_auto_videomode(&ps3av
->av_hw_conf
, 1);
1025 mutex_lock(&ps3av
->mutex
);
1026 ps3av
->ps3av_mode
= id
;
1027 mutex_unlock(&ps3av
->mutex
);
1029 dev_dbg(&dev
->core
, " <- %s:%d\n", __func__
, __LINE__
);
1039 static int ps3av_remove(struct ps3_system_bus_device
*dev
)
1041 dev_dbg(&dev
->core
, " -> %s:%d\n", __func__
, __LINE__
);
1045 destroy_workqueue(ps3av
->wq
);
1050 dev_dbg(&dev
->core
, " <- %s:%d\n", __func__
, __LINE__
);
1054 static void ps3av_shutdown(struct ps3_system_bus_device
*dev
)
1056 dev_dbg(&dev
->core
, " -> %s:%d\n", __func__
, __LINE__
);
1058 dev_dbg(&dev
->core
, " <- %s:%d\n", __func__
, __LINE__
);
1061 static struct ps3_vuart_port_driver ps3av_driver
= {
1062 .core
.match_id
= PS3_MATCH_ID_AV_SETTINGS
,
1063 .core
.core
.name
= "ps3_av",
1064 .probe
= ps3av_probe
,
1065 .remove
= ps3av_remove
,
1066 .shutdown
= ps3av_shutdown
,
1069 static int ps3av_module_init(void)
1073 if (!firmware_has_feature(FW_FEATURE_PS3_LV1
))
1076 pr_debug(" -> %s:%d\n", __func__
, __LINE__
);
1078 error
= ps3_vuart_port_driver_register(&ps3av_driver
);
1081 "%s: ps3_vuart_port_driver_register failed %d\n",
1086 pr_debug(" <- %s:%d\n", __func__
, __LINE__
);
1090 static void __exit
ps3av_module_exit(void)
1092 pr_debug(" -> %s:%d\n", __func__
, __LINE__
);
1093 ps3_vuart_port_driver_unregister(&ps3av_driver
);
1094 pr_debug(" <- %s:%d\n", __func__
, __LINE__
);
1097 subsys_initcall(ps3av_module_init
);
1098 module_exit(ps3av_module_exit
);
1100 MODULE_LICENSE("GPL v2");
1101 MODULE_DESCRIPTION("PS3 AV Settings Driver");
1102 MODULE_AUTHOR("Sony Computer Entertainment Inc.");
1103 MODULE_ALIAS(PS3_MODULE_ALIAS_AV_SETTINGS
);