PageRenderTime 102ms CodeModel.GetById 19ms app.highlight 65ms RepoModel.GetById 0ms app.codeStats 1ms

/drivers/ps3/ps3av.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t
C | 1086 lines | 837 code | 167 blank | 82 comment | 112 complexity | 27c41f08e486f344877144ea0c044937 MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
   1/*
   2 *  PS3 AV backend support.
   3 *
   4 *  Copyright (C) 2007 Sony Computer Entertainment Inc.
   5 *  Copyright 2007 Sony Corp.
   6 *
   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.
  10 *
  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.
  15 *
  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
  19 */
  20
  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>
  26#include <linux/fb.h>
  27#include <linux/slab.h>
  28
  29#include <asm/firmware.h>
  30#include <asm/ps3av.h>
  31#include <asm/ps3.h>
  32
  33#include "vuart.h"
  34
  35#define BUFSIZE          4096	/* vuart buf size */
  36#define PS3AV_BUF_SIZE   512	/* max packet size */
  37
  38static int safe_mode;
  39
  40static int timeout = 5000;	/* in msec ( 5 sec ) */
  41module_param(timeout, int, 0644);
  42
  43static struct ps3av {
  44	struct mutex mutex;
  45	struct work_struct work;
  46	struct completion done;
  47	struct workqueue_struct *wq;
  48	int open_count;
  49	struct ps3_system_bus_device *dev;
  50
  51	int region;
  52	struct ps3av_pkt_av_get_hw_conf av_hw_conf;
  53	u32 av_port[PS3AV_AV_PORT_MAX + PS3AV_OPT_PORT_MAX];
  54	u32 opt_port[PS3AV_OPT_PORT_MAX];
  55	u32 head[PS3AV_HEAD_MAX];
  56	u32 audio_port;
  57	int ps3av_mode;
  58	int ps3av_mode_old;
  59	union {
  60		struct ps3av_reply_hdr reply_hdr;
  61		u8 raw[PS3AV_BUF_SIZE];
  62	} recv_buf;
  63} *ps3av;
  64
  65/* color space */
  66#define YUV444 PS3AV_CMD_VIDEO_CS_YUV444_8
  67#define RGB8   PS3AV_CMD_VIDEO_CS_RGB_8
  68/* format */
  69#define XRGB   PS3AV_CMD_VIDEO_FMT_X8R8G8B8
  70/* aspect */
  71#define A_N    PS3AV_CMD_AV_ASPECT_4_3
  72#define A_W    PS3AV_CMD_AV_ASPECT_16_9
  73static const struct avset_video_mode {
  74	u32 cs;
  75	u32 fmt;
  76	u32 vid;
  77	u32 aspect;
  78	u32 x;
  79	u32 y;
  80} video_mode_table[] = {
  81	{     0, }, /* auto */
  82	{YUV444, XRGB, PS3AV_CMD_VIDEO_VID_480I,       A_N,  720,  480},
  83	{YUV444, XRGB, PS3AV_CMD_VIDEO_VID_480P,       A_N,  720,  480},
  84	{YUV444, XRGB, PS3AV_CMD_VIDEO_VID_720P_60HZ,  A_W, 1280,  720},
  85	{YUV444, XRGB, PS3AV_CMD_VIDEO_VID_1080I_60HZ, A_W, 1920, 1080},
  86	{YUV444, XRGB, PS3AV_CMD_VIDEO_VID_1080P_60HZ, A_W, 1920, 1080},
  87	{YUV444, XRGB, PS3AV_CMD_VIDEO_VID_576I,       A_N,  720,  576},
  88	{YUV444, XRGB, PS3AV_CMD_VIDEO_VID_576P,       A_N,  720,  576},
  89	{YUV444, XRGB, PS3AV_CMD_VIDEO_VID_720P_50HZ,  A_W, 1280,  720},
  90	{YUV444, XRGB, PS3AV_CMD_VIDEO_VID_1080I_50HZ, A_W, 1920, 1080},
  91	{YUV444, XRGB, PS3AV_CMD_VIDEO_VID_1080P_50HZ, A_W, 1920, 1080},
  92	{  RGB8, XRGB, PS3AV_CMD_VIDEO_VID_WXGA,       A_W, 1280,  768},
  93	{  RGB8, XRGB, PS3AV_CMD_VIDEO_VID_SXGA,       A_N, 1280, 1024},
  94	{  RGB8, XRGB, PS3AV_CMD_VIDEO_VID_WUXGA,      A_W, 1920, 1200},
  95};
  96
  97/* supported CIDs */
  98static u32 cmd_table[] = {
  99	/* init */
 100	PS3AV_CID_AV_INIT,
 101	PS3AV_CID_AV_FIN,
 102	PS3AV_CID_VIDEO_INIT,
 103	PS3AV_CID_AUDIO_INIT,
 104
 105	/* set */
 106	PS3AV_CID_AV_ENABLE_EVENT,
 107	PS3AV_CID_AV_DISABLE_EVENT,
 108
 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,
 116
 117	PS3AV_CID_VIDEO_MODE,
 118	PS3AV_CID_VIDEO_FORMAT,
 119	PS3AV_CID_VIDEO_PITCH,
 120
 121	PS3AV_CID_AUDIO_MODE,
 122	PS3AV_CID_AUDIO_MUTE,
 123	PS3AV_CID_AUDIO_ACTIVE,
 124	PS3AV_CID_AUDIO_INACTIVE,
 125	PS3AV_CID_AVB_PARAM,
 126
 127	/* get */
 128	PS3AV_CID_AV_GET_HW_CONF,
 129	PS3AV_CID_AV_GET_MONITOR_INFO,
 130
 131	/* event */
 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,
 138
 139	0
 140};
 141
 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
 146
 147#define ps3av_event_get_port_id(cid)   ((cid >> 16) & 0xff)
 148
 149static u32 *ps3av_search_cmd_table(u32 cid, u32 mask)
 150{
 151	u32 *table;
 152	int i;
 153
 154	table = cmd_table;
 155	for (i = 0;; table++, i++) {
 156		if ((*table & mask) == (cid & mask))
 157			break;
 158		if (*table == 0)
 159			return NULL;
 160	}
 161	return table;
 162}
 163
 164static int ps3av_parse_event_packet(const struct ps3av_reply_hdr *hdr)
 165{
 166	u32 *table;
 167
 168	if (hdr->cid & PS3AV_EVENT_CMD_MASK) {
 169		table = ps3av_search_cmd_table(hdr->cid, PS3AV_EVENT_CMD_MASK);
 170		if (table)
 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),
 174				hdr->size);
 175		else
 176			printk(KERN_ERR
 177			       "%s: failed event packet, cid:%08x size:%d\n",
 178			       __func__, hdr->cid, hdr->size);
 179		return 1;	/* receive event packet */
 180	}
 181	return 0;
 182}
 183
 184
 185#define POLLING_INTERVAL  25	/* in msec */
 186
 187static int ps3av_vuart_write(struct ps3_system_bus_device *dev,
 188			     const void *buf, unsigned long size)
 189{
 190	int error;
 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;
 195}
 196
 197static int ps3av_vuart_read(struct ps3_system_bus_device *dev, void *buf,
 198			    unsigned long size, int timeout)
 199{
 200	int error;
 201	int loopcnt = 0;
 202
 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);
 207		if (!error)
 208			return size;
 209		if (error != -EAGAIN) {
 210			printk(KERN_ERR "%s: ps3_vuart_read failed %d\n",
 211			       __func__, error);
 212			return error;
 213		}
 214		msleep(POLLING_INTERVAL);
 215	}
 216	return -EWOULDBLOCK;
 217}
 218
 219static int ps3av_send_cmd_pkt(const struct ps3av_send_hdr *send_buf,
 220			      struct ps3av_reply_hdr *recv_buf, int write_len,
 221			      int read_len)
 222{
 223	int res;
 224	u32 cmd;
 225	int event;
 226
 227	if (!ps3av)
 228		return -ENODEV;
 229
 230	/* send pkt */
 231	res = ps3av_vuart_write(ps3av->dev, send_buf, write_len);
 232	if (res < 0) {
 233		dev_dbg(&ps3av->dev->core,
 234			"%s: ps3av_vuart_write() failed (result=%d)\n",
 235			__func__, res);
 236		return res;
 237	}
 238
 239	/* recv pkt */
 240	cmd = send_buf->cid;
 241	do {
 242		/* read header */
 243		res = ps3av_vuart_read(ps3av->dev, recv_buf, PS3AV_HDR_SIZE,
 244				       timeout);
 245		if (res != PS3AV_HDR_SIZE) {
 246			dev_dbg(&ps3av->dev->core,
 247				"%s: ps3av_vuart_read() failed (result=%d)\n",
 248				__func__, res);
 249			return res;
 250		}
 251
 252		/* read body */
 253		res = ps3av_vuart_read(ps3av->dev, &recv_buf->cid,
 254				       recv_buf->size, timeout);
 255		if (res < 0) {
 256			dev_dbg(&ps3av->dev->core,
 257				"%s: ps3av_vuart_read() failed (result=%d)\n",
 258				__func__, res);
 259			return res;
 260		}
 261		res += PS3AV_HDR_SIZE;	/* total len */
 262		event = ps3av_parse_event_packet(recv_buf);
 263		/* ret > 0 event packet */
 264	} while (event);
 265
 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);
 269		return -EINVAL;
 270	}
 271
 272	return 0;
 273}
 274
 275static int ps3av_process_reply_packet(struct ps3av_send_hdr *cmd_buf,
 276				      const struct ps3av_reply_hdr *recv_buf,
 277				      int user_buf_size)
 278{
 279	int return_len;
 280
 281	if (recv_buf->version != PS3AV_VERSION) {
 282		dev_dbg(&ps3av->dev->core, "reply_packet invalid version:%x\n",
 283			recv_buf->version);
 284		return -EFAULT;
 285	}
 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 */
 291}
 292
 293void ps3av_set_hdr(u32 cid, u16 size, struct ps3av_send_hdr *hdr)
 294{
 295	hdr->version = PS3AV_VERSION;
 296	hdr->size = size - PS3AV_HDR_SIZE;
 297	hdr->cid = cid;
 298}
 299
 300int ps3av_do_pkt(u32 cid, u16 send_len, size_t usr_buf_size,
 301		 struct ps3av_send_hdr *buf)
 302{
 303	int res = 0;
 304	u32 *table;
 305
 306	BUG_ON(!ps3av);
 307
 308	mutex_lock(&ps3av->mutex);
 309
 310	table = ps3av_search_cmd_table(cid, PS3AV_CID_MASK);
 311	BUG_ON(!table);
 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);
 315
 316	/* create header */
 317	ps3av_set_hdr(cid, send_len, buf);
 318
 319	/* send packet via vuart */
 320	res = ps3av_send_cmd_pkt(buf, &ps3av->recv_buf.reply_hdr, send_len,
 321				 usr_buf_size);
 322	if (res < 0) {
 323		printk(KERN_ERR
 324		       "%s: ps3av_send_cmd_pkt() failed (result=%d)\n",
 325		       __func__, res);
 326		goto err;
 327	}
 328
 329	/* process reply packet */
 330	res = ps3av_process_reply_packet(buf, &ps3av->recv_buf.reply_hdr,
 331					 usr_buf_size);
 332	if (res < 0) {
 333		printk(KERN_ERR "%s: put_return_status() failed (result=%d)\n",
 334		       __func__, res);
 335		goto err;
 336	}
 337
 338	mutex_unlock(&ps3av->mutex);
 339	return 0;
 340
 341      err:
 342	mutex_unlock(&ps3av->mutex);
 343	printk(KERN_ERR "%s: failed cid:%x res:%d\n", __func__, cid, res);
 344	return res;
 345}
 346
 347static int ps3av_set_av_video_mute(u32 mute)
 348{
 349	int i, num_of_av_port, res;
 350
 351	num_of_av_port = ps3av->av_hw_conf.num_of_hdmi +
 352			 ps3av->av_hw_conf.num_of_avmulti;
 353	/* video mute on */
 354	for (i = 0; i < num_of_av_port; i++) {
 355		res = ps3av_cmd_av_video_mute(1, &ps3av->av_port[i], mute);
 356		if (res < 0)
 357			return -1;
 358	}
 359
 360	return 0;
 361}
 362
 363static int ps3av_set_video_disable_sig(void)
 364{
 365	int i, num_of_hdmi_port, num_of_av_port, res;
 366
 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;
 370
 371	/* tv mute */
 372	for (i = 0; i < num_of_hdmi_port; i++) {
 373		res = ps3av_cmd_av_tv_mute(ps3av->av_port[i],
 374					   PS3AV_CMD_MUTE_ON);
 375		if (res < 0)
 376			return -1;
 377	}
 378	msleep(100);
 379
 380	/* video mute on */
 381	for (i = 0; i < num_of_av_port; i++) {
 382		res = ps3av_cmd_av_video_disable_sig(ps3av->av_port[i]);
 383		if (res < 0)
 384			return -1;
 385		if (i < num_of_hdmi_port) {
 386			res = ps3av_cmd_av_tv_mute(ps3av->av_port[i],
 387						   PS3AV_CMD_MUTE_OFF);
 388			if (res < 0)
 389				return -1;
 390		}
 391	}
 392	msleep(300);
 393
 394	return 0;
 395}
 396
 397static int ps3av_set_audio_mute(u32 mute)
 398{
 399	int i, num_of_av_port, num_of_opt_port, res;
 400
 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;
 404
 405	for (i = 0; i < num_of_av_port; i++) {
 406		res = ps3av_cmd_av_audio_mute(1, &ps3av->av_port[i], mute);
 407		if (res < 0)
 408			return -1;
 409	}
 410	for (i = 0; i < num_of_opt_port; i++) {
 411		res = ps3av_cmd_audio_mute(1, &ps3av->opt_port[i], mute);
 412		if (res < 0)
 413			return -1;
 414	}
 415
 416	return 0;
 417}
 418
 419int ps3av_set_audio_mode(u32 ch, u32 fs, u32 word_bits, u32 format, u32 source)
 420{
 421	struct ps3av_pkt_avb_param avb_param;
 422	int i, num_of_audio, vid, res;
 423	struct ps3av_pkt_audio_mode audio_mode;
 424	u32 len = 0;
 425
 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;
 429
 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;
 434
 435	vid = video_mode_table[ps3av->ps3av_mode].vid;
 436
 437	/* audio mute */
 438	ps3av_set_audio_mute(PS3AV_CMD_MUTE_ON);
 439
 440	/* audio inactive */
 441	res = ps3av_cmd_audio_active(0, ps3av->audio_port);
 442	if (res < 0)
 443		dev_dbg(&ps3av->dev->core,
 444			"ps3av_cmd_audio_active OFF failed\n");
 445
 446	/* audio_pkt */
 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) {
 451			/* hdmi only */
 452			len += ps3av_cmd_set_av_audio_param(&avb_param.buf[len],
 453							    ps3av->av_port[i],
 454							    &audio_mode, vid);
 455		}
 456		/* audio_mode pkt should be sent separately */
 457		res = ps3av_cmd_audio_mode(&audio_mode);
 458		if (res < 0)
 459			dev_dbg(&ps3av->dev->core,
 460				"ps3av_cmd_audio_mode failed, port:%x\n", i);
 461	}
 462
 463	/* send command using avb pkt */
 464	len += offsetof(struct ps3av_pkt_avb_param, buf);
 465	res = ps3av_cmd_avb_param(&avb_param, len);
 466	if (res < 0)
 467		dev_dbg(&ps3av->dev->core, "ps3av_cmd_avb_param failed\n");
 468
 469	/* audio mute */
 470	ps3av_set_audio_mute(PS3AV_CMD_MUTE_OFF);
 471
 472	/* audio active */
 473	res = ps3av_cmd_audio_active(1, ps3av->audio_port);
 474	if (res < 0)
 475		dev_dbg(&ps3av->dev->core,
 476			"ps3av_cmd_audio_active ON failed\n");
 477
 478	return 0;
 479}
 480
 481EXPORT_SYMBOL_GPL(ps3av_set_audio_mode);
 482
 483static int ps3av_set_videomode(void)
 484{
 485	/* av video mute */
 486	ps3av_set_av_video_mute(PS3AV_CMD_MUTE_ON);
 487
 488	/* wake up ps3avd to do the actual video mode setting */
 489	queue_work(ps3av->wq, &ps3av->work);
 490
 491	return 0;
 492}
 493
 494static void ps3av_set_videomode_packet(u32 id)
 495{
 496	struct ps3av_pkt_avb_param avb_param;
 497	unsigned int i;
 498	u32 len = 0, av_video_cs;
 499	const struct avset_video_mode *video_mode;
 500	int res;
 501
 502	video_mode = &video_mode_table[id & PS3AV_MODE_MASK];
 503
 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;
 509
 510	/* video_pkt */
 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);
 515	/* av_video_pkt */
 516	for (i = 0; i < avb_param.num_of_av_video_pkt; i++) {
 517		if (id & PS3AV_MODE_DVI || id & PS3AV_MODE_RGB)
 518			av_video_cs = RGB8;
 519		else
 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 */
 525#endif
 526		len += ps3av_cmd_set_av_video_cs(&avb_param.buf[len],
 527						 ps3av->av_port[i],
 528						 video_mode->vid, av_video_cs,
 529						 video_mode->aspect, id);
 530	}
 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)
 535		printk(KERN_WARNING
 536		       "%s: Command failed. Please try your request again.\n",
 537		       __func__);
 538	else if (res)
 539		dev_dbg(&ps3av->dev->core, "ps3av_cmd_avb_param failed\n");
 540}
 541
 542static void ps3av_set_videomode_cont(u32 id, u32 old_id)
 543{
 544	static int vesa;
 545	int res;
 546
 547	/* video signal off */
 548	ps3av_set_video_disable_sig();
 549
 550	/*
 551	 * AV backend needs non-VESA mode setting at least one time
 552	 * when VESA mode is used.
 553	 */
 554	if (vesa == 0 && (id & PS3AV_MODE_MASK) >= PS3AV_MODE_WXGA) {
 555		/* vesa mode */
 556		ps3av_set_videomode_packet(PS3AV_MODE_480P);
 557	}
 558	vesa = 1;
 559
 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");
 565		else if (res)
 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");
 573	}
 574
 575	ps3av_set_videomode_packet(id);
 576
 577	msleep(1500);
 578	/* av video mute */
 579	ps3av_set_av_video_mute(PS3AV_CMD_MUTE_OFF);
 580}
 581
 582static void ps3avd(struct work_struct *work)
 583{
 584	ps3av_set_videomode_cont(ps3av->ps3av_mode, ps3av->ps3av_mode_old);
 585	complete(&ps3av->done);
 586}
 587
 588#define SHIFT_50	0
 589#define SHIFT_60	4
 590#define SHIFT_VESA	8
 591
 592static const struct {
 593	unsigned mask : 19;
 594	unsigned id :  4;
 595} ps3av_preferred_modes[] = {
 596	{ PS3AV_RESBIT_WUXGA      << SHIFT_VESA, PS3AV_MODE_WUXGA   },
 597	{ PS3AV_RESBIT_1920x1080P << SHIFT_60,   PS3AV_MODE_1080P60 },
 598	{ PS3AV_RESBIT_1920x1080P << SHIFT_50,   PS3AV_MODE_1080P50 },
 599	{ PS3AV_RESBIT_1920x1080I << SHIFT_60,   PS3AV_MODE_1080I60 },
 600	{ PS3AV_RESBIT_1920x1080I << SHIFT_50,   PS3AV_MODE_1080I50 },
 601	{ PS3AV_RESBIT_SXGA       << SHIFT_VESA, PS3AV_MODE_SXGA    },
 602	{ PS3AV_RESBIT_WXGA       << SHIFT_VESA, PS3AV_MODE_WXGA    },
 603	{ PS3AV_RESBIT_1280x720P  << SHIFT_60,   PS3AV_MODE_720P60  },
 604	{ PS3AV_RESBIT_1280x720P  << SHIFT_50,   PS3AV_MODE_720P50  },
 605	{ PS3AV_RESBIT_720x480P   << SHIFT_60,   PS3AV_MODE_480P    },
 606	{ PS3AV_RESBIT_720x576P   << SHIFT_50,   PS3AV_MODE_576P    },
 607};
 608
 609static enum ps3av_mode_num ps3av_resbit2id(u32 res_50, u32 res_60,
 610					   u32 res_vesa)
 611{
 612	unsigned int i;
 613	u32 res_all;
 614
 615	/*
 616	 * We mask off the resolution bits we care about and combine the
 617	 * results in one bitfield, so make sure there's no overlap
 618	 */
 619	BUILD_BUG_ON(PS3AV_RES_MASK_50 << SHIFT_50 &
 620		     PS3AV_RES_MASK_60 << SHIFT_60);
 621	BUILD_BUG_ON(PS3AV_RES_MASK_50 << SHIFT_50 &
 622		     PS3AV_RES_MASK_VESA << SHIFT_VESA);
 623	BUILD_BUG_ON(PS3AV_RES_MASK_60 << SHIFT_60 &
 624		     PS3AV_RES_MASK_VESA << SHIFT_VESA);
 625	res_all = (res_50 & PS3AV_RES_MASK_50) << SHIFT_50 |
 626		  (res_60 & PS3AV_RES_MASK_60) << SHIFT_60 |
 627		  (res_vesa & PS3AV_RES_MASK_VESA) << SHIFT_VESA;
 628
 629	if (!res_all)
 630		return 0;
 631
 632	for (i = 0; i < ARRAY_SIZE(ps3av_preferred_modes); i++)
 633		if (res_all & ps3av_preferred_modes[i].mask)
 634			return ps3av_preferred_modes[i].id;
 635
 636	return 0;
 637}
 638
 639static enum ps3av_mode_num ps3av_hdmi_get_id(struct ps3av_info_monitor *info)
 640{
 641	enum ps3av_mode_num id;
 642
 643	if (safe_mode)
 644		return PS3AV_DEFAULT_HDMI_MODE_ID_REG_60;
 645
 646	/* check native resolution */
 647	id = ps3av_resbit2id(info->res_50.native, info->res_60.native,
 648			     info->res_vesa.native);
 649	if (id) {
 650		pr_debug("%s: Using native mode %d\n", __func__, id);
 651		return id;
 652	}
 653
 654	/* check supported resolutions */
 655	id = ps3av_resbit2id(info->res_50.res_bits, info->res_60.res_bits,
 656			     info->res_vesa.res_bits);
 657	if (id) {
 658		pr_debug("%s: Using supported mode %d\n", __func__, id);
 659		return id;
 660	}
 661
 662	if (ps3av->region & PS3AV_REGION_60)
 663		id = PS3AV_DEFAULT_HDMI_MODE_ID_REG_60;
 664	else
 665		id = PS3AV_DEFAULT_HDMI_MODE_ID_REG_50;
 666	pr_debug("%s: Using default mode %d\n", __func__, id);
 667	return id;
 668}
 669
 670static void ps3av_monitor_info_dump(const struct ps3av_pkt_av_get_monitor_info *monitor_info)
 671{
 672	const struct ps3av_info_monitor *info = &monitor_info->info;
 673	const struct ps3av_info_audio *audio = info->audio;
 674	char id[sizeof(info->monitor_id)*3+1];
 675	int i;
 676
 677	pr_debug("Monitor Info: size %u\n", monitor_info->send_hdr.size);
 678
 679	pr_debug("avport: %02x\n", info->avport);
 680	for (i = 0; i < sizeof(info->monitor_id); i++)
 681		sprintf(&id[i*3], " %02x", info->monitor_id[i]);
 682	pr_debug("monitor_id: %s\n", id);
 683	pr_debug("monitor_type: %02x\n", info->monitor_type);
 684	pr_debug("monitor_name: %.*s\n", (int)sizeof(info->monitor_name),
 685		 info->monitor_name);
 686
 687	/* resolution */
 688	pr_debug("resolution_60: bits: %08x native: %08x\n",
 689		 info->res_60.res_bits, info->res_60.native);
 690	pr_debug("resolution_50: bits: %08x native: %08x\n",
 691		 info->res_50.res_bits, info->res_50.native);
 692	pr_debug("resolution_other: bits: %08x native: %08x\n",
 693		 info->res_other.res_bits, info->res_other.native);
 694	pr_debug("resolution_vesa: bits: %08x native: %08x\n",
 695		 info->res_vesa.res_bits, info->res_vesa.native);
 696
 697	/* color space */
 698	pr_debug("color space    rgb: %02x\n", info->cs.rgb);
 699	pr_debug("color space yuv444: %02x\n", info->cs.yuv444);
 700	pr_debug("color space yuv422: %02x\n", info->cs.yuv422);
 701
 702	/* color info */
 703	pr_debug("color info   red: X %04x Y %04x\n", info->color.red_x,
 704		 info->color.red_y);
 705	pr_debug("color info green: X %04x Y %04x\n", info->color.green_x,
 706		 info->color.green_y);
 707	pr_debug("color info  blue: X %04x Y %04x\n", info->color.blue_x,
 708		 info->color.blue_y);
 709	pr_debug("color info white: X %04x Y %04x\n", info->color.white_x,
 710		 info->color.white_y);
 711	pr_debug("color info gamma:  %08x\n", info->color.gamma);
 712
 713	/* other info */
 714	pr_debug("supported_AI: %02x\n", info->supported_ai);
 715	pr_debug("speaker_info: %02x\n", info->speaker_info);
 716	pr_debug("num of audio: %02x\n", info->num_of_audio_block);
 717
 718	/* audio block */
 719	for (i = 0; i < info->num_of_audio_block; i++) {
 720		pr_debug("audio[%d] type: %02x max_ch: %02x fs: %02x sbit: "
 721			 "%02x\n",
 722			 i, audio->type, audio->max_num_of_ch, audio->fs,
 723			 audio->sbit);
 724		audio++;
 725	}
 726}
 727
 728static const struct ps3av_monitor_quirk {
 729	const char *monitor_name;
 730	u32 clear_60;
 731} ps3av_monitor_quirks[] = {
 732	{
 733		.monitor_name	= "DELL 2007WFP",
 734		.clear_60	= PS3AV_RESBIT_1920x1080I
 735	}, {
 736		.monitor_name	= "L226WTQ",
 737		.clear_60	= PS3AV_RESBIT_1920x1080I |
 738				  PS3AV_RESBIT_1920x1080P
 739	}, {
 740		.monitor_name	= "SyncMaster",
 741		.clear_60	= PS3AV_RESBIT_1920x1080I
 742	}
 743};
 744
 745static void ps3av_fixup_monitor_info(struct ps3av_info_monitor *info)
 746{
 747	unsigned int i;
 748	const struct ps3av_monitor_quirk *quirk;
 749
 750	for (i = 0; i < ARRAY_SIZE(ps3av_monitor_quirks); i++) {
 751		quirk = &ps3av_monitor_quirks[i];
 752		if (!strncmp(info->monitor_name, quirk->monitor_name,
 753			     sizeof(info->monitor_name))) {
 754			pr_info("%s: Applying quirk for %s\n", __func__,
 755				quirk->monitor_name);
 756			info->res_60.res_bits &= ~quirk->clear_60;
 757			info->res_60.native &= ~quirk->clear_60;
 758			break;
 759		}
 760	}
 761}
 762
 763static int ps3av_auto_videomode(struct ps3av_pkt_av_get_hw_conf *av_hw_conf)
 764{
 765	int i, res, id = 0, dvi = 0, rgb = 0;
 766	struct ps3av_pkt_av_get_monitor_info monitor_info;
 767	struct ps3av_info_monitor *info;
 768
 769	/* get mode id for hdmi */
 770	for (i = 0; i < av_hw_conf->num_of_hdmi && !id; i++) {
 771		res = ps3av_cmd_video_get_monitor_info(&monitor_info,
 772						       PS3AV_CMD_AVPORT_HDMI_0 +
 773						       i);
 774		if (res < 0)
 775			return -1;
 776
 777		ps3av_monitor_info_dump(&monitor_info);
 778
 779		info = &monitor_info.info;
 780		ps3av_fixup_monitor_info(info);
 781
 782		switch (info->monitor_type) {
 783		case PS3AV_MONITOR_TYPE_DVI:
 784			dvi = PS3AV_MODE_DVI;
 785			/* fall through */
 786		case PS3AV_MONITOR_TYPE_HDMI:
 787			id = ps3av_hdmi_get_id(info);
 788			break;
 789		}
 790	}
 791
 792	if (!id) {
 793		/* no HDMI interface or HDMI is off */
 794		if (ps3av->region & PS3AV_REGION_60)
 795			id = PS3AV_DEFAULT_AVMULTI_MODE_ID_REG_60;
 796		else
 797			id = PS3AV_DEFAULT_AVMULTI_MODE_ID_REG_50;
 798		if (ps3av->region & PS3AV_REGION_RGB)
 799			rgb = PS3AV_MODE_RGB;
 800		pr_debug("%s: Using avmulti mode %d\n", __func__, id);
 801	}
 802
 803	return id | dvi | rgb;
 804}
 805
 806static int ps3av_get_hw_conf(struct ps3av *ps3av)
 807{
 808	int i, j, k, res;
 809	const struct ps3av_pkt_av_get_hw_conf *hw_conf;
 810
 811	/* get av_hw_conf */
 812	res = ps3av_cmd_av_get_hw_conf(&ps3av->av_hw_conf);
 813	if (res < 0)
 814		return -1;
 815
 816	hw_conf = &ps3av->av_hw_conf;
 817	pr_debug("av_h_conf: num of hdmi: %u\n", hw_conf->num_of_hdmi);
 818	pr_debug("av_h_conf: num of avmulti: %u\n", hw_conf->num_of_avmulti);
 819	pr_debug("av_h_conf: num of spdif: %u\n", hw_conf->num_of_spdif);
 820
 821	for (i = 0; i < PS3AV_HEAD_MAX; i++)
 822		ps3av->head[i] = PS3AV_CMD_VIDEO_HEAD_A + i;
 823	for (i = 0; i < PS3AV_OPT_PORT_MAX; i++)
 824		ps3av->opt_port[i] = PS3AV_CMD_AVPORT_SPDIF_0 + i;
 825	for (i = 0; i < hw_conf->num_of_hdmi; i++)
 826		ps3av->av_port[i] = PS3AV_CMD_AVPORT_HDMI_0 + i;
 827	for (j = 0; j < hw_conf->num_of_avmulti; j++)
 828		ps3av->av_port[i + j] = PS3AV_CMD_AVPORT_AVMULTI_0 + j;
 829	for (k = 0; k < hw_conf->num_of_spdif; k++)
 830		ps3av->av_port[i + j + k] = PS3AV_CMD_AVPORT_SPDIF_0 + k;
 831
 832	/* set all audio port */
 833	ps3av->audio_port = PS3AV_CMD_AUDIO_PORT_HDMI_0
 834	    | PS3AV_CMD_AUDIO_PORT_HDMI_1
 835	    | PS3AV_CMD_AUDIO_PORT_AVMULTI_0
 836	    | PS3AV_CMD_AUDIO_PORT_SPDIF_0 | PS3AV_CMD_AUDIO_PORT_SPDIF_1;
 837
 838	return 0;
 839}
 840
 841/* set mode using id */
 842int ps3av_set_video_mode(int id)
 843{
 844	int size;
 845	u32 option;
 846
 847	size = ARRAY_SIZE(video_mode_table);
 848	if ((id & PS3AV_MODE_MASK) > size - 1 || id < 0) {
 849		dev_dbg(&ps3av->dev->core, "%s: error id :%d\n", __func__, id);
 850		return -EINVAL;
 851	}
 852
 853	/* auto mode */
 854	option = id & ~PS3AV_MODE_MASK;
 855	if ((id & PS3AV_MODE_MASK) == PS3AV_MODE_AUTO) {
 856		id = ps3av_auto_videomode(&ps3av->av_hw_conf);
 857		if (id < 1) {
 858			printk(KERN_ERR "%s: invalid id :%d\n", __func__, id);
 859			return -EINVAL;
 860		}
 861		id |= option;
 862	}
 863
 864	/* set videomode */
 865	wait_for_completion(&ps3av->done);
 866	ps3av->ps3av_mode_old = ps3av->ps3av_mode;
 867	ps3av->ps3av_mode = id;
 868	if (ps3av_set_videomode())
 869		ps3av->ps3av_mode = ps3av->ps3av_mode_old;
 870
 871	return 0;
 872}
 873
 874EXPORT_SYMBOL_GPL(ps3av_set_video_mode);
 875
 876int ps3av_get_auto_mode(void)
 877{
 878	return ps3av_auto_videomode(&ps3av->av_hw_conf);
 879}
 880
 881EXPORT_SYMBOL_GPL(ps3av_get_auto_mode);
 882
 883int ps3av_get_mode(void)
 884{
 885	return ps3av ? ps3av->ps3av_mode : 0;
 886}
 887
 888EXPORT_SYMBOL_GPL(ps3av_get_mode);
 889
 890/* get resolution by video_mode */
 891int ps3av_video_mode2res(u32 id, u32 *xres, u32 *yres)
 892{
 893	int size;
 894
 895	id = id & PS3AV_MODE_MASK;
 896	size = ARRAY_SIZE(video_mode_table);
 897	if (id > size - 1 || id < 0) {
 898		printk(KERN_ERR "%s: invalid mode %d\n", __func__, id);
 899		return -EINVAL;
 900	}
 901	*xres = video_mode_table[id].x;
 902	*yres = video_mode_table[id].y;
 903	return 0;
 904}
 905
 906EXPORT_SYMBOL_GPL(ps3av_video_mode2res);
 907
 908/* mute */
 909int ps3av_video_mute(int mute)
 910{
 911	return ps3av_set_av_video_mute(mute ? PS3AV_CMD_MUTE_ON
 912					    : PS3AV_CMD_MUTE_OFF);
 913}
 914
 915EXPORT_SYMBOL_GPL(ps3av_video_mute);
 916
 917/* mute analog output only */
 918int ps3av_audio_mute_analog(int mute)
 919{
 920	int i, res;
 921
 922	for (i = 0; i < ps3av->av_hw_conf.num_of_avmulti; i++) {
 923		res = ps3av_cmd_av_audio_mute(1,
 924			&ps3av->av_port[i + ps3av->av_hw_conf.num_of_hdmi],
 925			mute);
 926		if (res < 0)
 927			return -1;
 928	}
 929	return 0;
 930}
 931EXPORT_SYMBOL_GPL(ps3av_audio_mute_analog);
 932
 933int ps3av_audio_mute(int mute)
 934{
 935	return ps3av_set_audio_mute(mute ? PS3AV_CMD_MUTE_ON
 936					 : PS3AV_CMD_MUTE_OFF);
 937}
 938
 939EXPORT_SYMBOL_GPL(ps3av_audio_mute);
 940
 941static int __devinit ps3av_probe(struct ps3_system_bus_device *dev)
 942{
 943	int res;
 944	int id;
 945
 946	dev_dbg(&dev->core, " -> %s:%d\n", __func__, __LINE__);
 947	dev_dbg(&dev->core, "  timeout=%d\n", timeout);
 948
 949	if (ps3av) {
 950		dev_err(&dev->core, "Only one ps3av device is supported\n");
 951		return -EBUSY;
 952	}
 953
 954	ps3av = kzalloc(sizeof(*ps3av), GFP_KERNEL);
 955	if (!ps3av)
 956		return -ENOMEM;
 957
 958	mutex_init(&ps3av->mutex);
 959	ps3av->ps3av_mode = PS3AV_MODE_AUTO;
 960	ps3av->dev = dev;
 961
 962	INIT_WORK(&ps3av->work, ps3avd);
 963	init_completion(&ps3av->done);
 964	complete(&ps3av->done);
 965	ps3av->wq = create_singlethread_workqueue("ps3avd");
 966	if (!ps3av->wq) {
 967		res = -ENOMEM;
 968		goto fail;
 969	}
 970
 971	switch (ps3_os_area_get_av_multi_out()) {
 972	case PS3_PARAM_AV_MULTI_OUT_NTSC:
 973		ps3av->region = PS3AV_REGION_60;
 974		break;
 975	case PS3_PARAM_AV_MULTI_OUT_PAL_YCBCR:
 976	case PS3_PARAM_AV_MULTI_OUT_SECAM:
 977		ps3av->region = PS3AV_REGION_50;
 978		break;
 979	case PS3_PARAM_AV_MULTI_OUT_PAL_RGB:
 980		ps3av->region = PS3AV_REGION_50 | PS3AV_REGION_RGB;
 981		break;
 982	default:
 983		ps3av->region = PS3AV_REGION_60;
 984		break;
 985	}
 986
 987	/* init avsetting modules */
 988	res = ps3av_cmd_init();
 989	if (res < 0)
 990		printk(KERN_ERR "%s: ps3av_cmd_init failed %d\n", __func__,
 991		       res);
 992
 993	ps3av_get_hw_conf(ps3av);
 994
 995#ifdef CONFIG_FB
 996	if (fb_mode_option && !strcmp(fb_mode_option, "safe"))
 997		safe_mode = 1;
 998#endif /* CONFIG_FB */
 999	id = ps3av_auto_videomode(&ps3av->av_hw_conf);
1000	if (id < 0) {
1001		printk(KERN_ERR "%s: invalid id :%d\n", __func__, id);
1002		res = -EINVAL;
1003		goto fail;
1004	}
1005
1006	safe_mode = 0;
1007
1008	mutex_lock(&ps3av->mutex);
1009	ps3av->ps3av_mode = id;
1010	mutex_unlock(&ps3av->mutex);
1011
1012	dev_dbg(&dev->core, " <- %s:%d\n", __func__, __LINE__);
1013
1014	return 0;
1015
1016fail:
1017	kfree(ps3av);
1018	ps3av = NULL;
1019	return res;
1020}
1021
1022static int ps3av_remove(struct ps3_system_bus_device *dev)
1023{
1024	dev_dbg(&dev->core, " -> %s:%d\n", __func__, __LINE__);
1025	if (ps3av) {
1026		ps3av_cmd_fin();
1027		if (ps3av->wq)
1028			destroy_workqueue(ps3av->wq);
1029		kfree(ps3av);
1030		ps3av = NULL;
1031	}
1032
1033	dev_dbg(&dev->core, " <- %s:%d\n", __func__, __LINE__);
1034	return 0;
1035}
1036
1037static void ps3av_shutdown(struct ps3_system_bus_device *dev)
1038{
1039	dev_dbg(&dev->core, " -> %s:%d\n", __func__, __LINE__);
1040	ps3av_remove(dev);
1041	dev_dbg(&dev->core, " <- %s:%d\n", __func__, __LINE__);
1042}
1043
1044static struct ps3_vuart_port_driver ps3av_driver = {
1045	.core.match_id = PS3_MATCH_ID_AV_SETTINGS,
1046	.core.core.name = "ps3_av",
1047	.probe = ps3av_probe,
1048	.remove = ps3av_remove,
1049	.shutdown = ps3av_shutdown,
1050};
1051
1052static int __init ps3av_module_init(void)
1053{
1054	int error;
1055
1056	if (!firmware_has_feature(FW_FEATURE_PS3_LV1))
1057		return -ENODEV;
1058
1059	pr_debug(" -> %s:%d\n", __func__, __LINE__);
1060
1061	error = ps3_vuart_port_driver_register(&ps3av_driver);
1062	if (error) {
1063		printk(KERN_ERR
1064		       "%s: ps3_vuart_port_driver_register failed %d\n",
1065		       __func__, error);
1066		return error;
1067	}
1068
1069	pr_debug(" <- %s:%d\n", __func__, __LINE__);
1070	return error;
1071}
1072
1073static void __exit ps3av_module_exit(void)
1074{
1075	pr_debug(" -> %s:%d\n", __func__, __LINE__);
1076	ps3_vuart_port_driver_unregister(&ps3av_driver);
1077	pr_debug(" <- %s:%d\n", __func__, __LINE__);
1078}
1079
1080subsys_initcall(ps3av_module_init);
1081module_exit(ps3av_module_exit);
1082
1083MODULE_LICENSE("GPL v2");
1084MODULE_DESCRIPTION("PS3 AV Settings Driver");
1085MODULE_AUTHOR("Sony Computer Entertainment Inc.");
1086MODULE_ALIAS(PS3_MODULE_ALIAS_AV_SETTINGS);