linux/drivers/ps3/ps3av.c
<<
>>
Prefs
   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
 341err:
 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}
 480EXPORT_SYMBOL_GPL(ps3av_set_audio_mode);
 481
 482static int ps3av_set_videomode(void)
 483{
 484        /* av video mute */
 485        ps3av_set_av_video_mute(PS3AV_CMD_MUTE_ON);
 486
 487        /* wake up ps3avd to do the actual video mode setting */
 488        queue_work(ps3av->wq, &ps3av->work);
 489
 490        return 0;
 491}
 492
 493static void ps3av_set_videomode_packet(u32 id)
 494{
 495        struct ps3av_pkt_avb_param avb_param;
 496        unsigned int i;
 497        u32 len = 0, av_video_cs;
 498        const struct avset_video_mode *video_mode;
 499        int res;
 500
 501        video_mode = &video_mode_table[id & PS3AV_MODE_MASK];
 502
 503        avb_param.num_of_video_pkt = PS3AV_AVB_NUM_VIDEO; /* num of head */
 504        avb_param.num_of_audio_pkt = 0;
 505        avb_param.num_of_av_video_pkt = ps3av->av_hw_conf.num_of_hdmi +
 506                                        ps3av->av_hw_conf.num_of_avmulti;
 507        avb_param.num_of_av_audio_pkt = 0;
 508
 509        /* video_pkt */
 510        for (i = 0; i < avb_param.num_of_video_pkt; i++)
 511                len += ps3av_cmd_set_video_mode(&avb_param.buf[len],
 512                                                ps3av->head[i], video_mode->vid,
 513                                                video_mode->fmt, id);
 514        /* av_video_pkt */
 515        for (i = 0; i < avb_param.num_of_av_video_pkt; i++) {
 516                if (id & PS3AV_MODE_DVI || id & PS3AV_MODE_RGB)
 517                        av_video_cs = RGB8;
 518                else
 519                        av_video_cs = video_mode->cs;
 520#ifndef PS3AV_HDMI_YUV
 521                if (ps3av->av_port[i] == PS3AV_CMD_AVPORT_HDMI_0 ||
 522                    ps3av->av_port[i] == PS3AV_CMD_AVPORT_HDMI_1)
 523                        av_video_cs = RGB8; /* use RGB for HDMI */
 524#endif
 525                len += ps3av_cmd_set_av_video_cs(&avb_param.buf[len],
 526                                                 ps3av->av_port[i],
 527                                                 video_mode->vid, av_video_cs,
 528                                                 video_mode->aspect, id);
 529        }
 530        /* send command using avb pkt */
 531        len += offsetof(struct ps3av_pkt_avb_param, buf);
 532        res = ps3av_cmd_avb_param(&avb_param, len);
 533        if (res == PS3AV_STATUS_NO_SYNC_HEAD)
 534                printk(KERN_WARNING
 535                       "%s: Command failed. Please try your request again.\n",
 536                       __func__);
 537        else if (res)
 538                dev_dbg(&ps3av->dev->core, "ps3av_cmd_avb_param failed\n");
 539}
 540
 541static void ps3av_set_videomode_cont(u32 id, u32 old_id)
 542{
 543        static int vesa;
 544        int res;
 545
 546        /* video signal off */
 547        ps3av_set_video_disable_sig();
 548
 549        /*
 550         * AV backend needs non-VESA mode setting at least one time
 551         * when VESA mode is used.
 552         */
 553        if (vesa == 0 && (id & PS3AV_MODE_MASK) >= PS3AV_MODE_WXGA) {
 554                /* vesa mode */
 555                ps3av_set_videomode_packet(PS3AV_MODE_480P);
 556        }
 557        vesa = 1;
 558
 559        /* Retail PS3 product doesn't support this */
 560        if (id & PS3AV_MODE_HDCP_OFF) {
 561                res = ps3av_cmd_av_hdmi_mode(PS3AV_CMD_AV_HDMI_HDCP_OFF);
 562                if (res == PS3AV_STATUS_UNSUPPORTED_HDMI_MODE)
 563                        dev_dbg(&ps3av->dev->core, "Not supported\n");
 564                else if (res)
 565                        dev_dbg(&ps3av->dev->core,
 566                                "ps3av_cmd_av_hdmi_mode failed\n");
 567        } else if (old_id & PS3AV_MODE_HDCP_OFF) {
 568                res = ps3av_cmd_av_hdmi_mode(PS3AV_CMD_AV_HDMI_MODE_NORMAL);
 569                if (res < 0 && res != PS3AV_STATUS_UNSUPPORTED_HDMI_MODE)
 570                        dev_dbg(&ps3av->dev->core,
 571                                "ps3av_cmd_av_hdmi_mode failed\n");
 572        }
 573
 574        ps3av_set_videomode_packet(id);
 575
 576        msleep(1500);
 577        /* av video mute */
 578        ps3av_set_av_video_mute(PS3AV_CMD_MUTE_OFF);
 579}
 580
 581static void ps3avd(struct work_struct *work)
 582{
 583        ps3av_set_videomode_cont(ps3av->ps3av_mode, ps3av->ps3av_mode_old);
 584        complete(&ps3av->done);
 585}
 586
 587#define SHIFT_50        0
 588#define SHIFT_60        4
 589#define SHIFT_VESA      8
 590
 591static const struct {
 592        unsigned mask:19;
 593        unsigned id:4;
 594} ps3av_preferred_modes[] = {
 595        { PS3AV_RESBIT_WUXGA      << SHIFT_VESA, PS3AV_MODE_WUXGA   },
 596        { PS3AV_RESBIT_1920x1080P << SHIFT_60,   PS3AV_MODE_1080P60 },
 597        { PS3AV_RESBIT_1920x1080P << SHIFT_50,   PS3AV_MODE_1080P50 },
 598        { PS3AV_RESBIT_1920x1080I << SHIFT_60,   PS3AV_MODE_1080I60 },
 599        { PS3AV_RESBIT_1920x1080I << SHIFT_50,   PS3AV_MODE_1080I50 },
 600        { PS3AV_RESBIT_SXGA       << SHIFT_VESA, PS3AV_MODE_SXGA    },
 601        { PS3AV_RESBIT_WXGA       << SHIFT_VESA, PS3AV_MODE_WXGA    },
 602        { PS3AV_RESBIT_1280x720P  << SHIFT_60,   PS3AV_MODE_720P60  },
 603        { PS3AV_RESBIT_1280x720P  << SHIFT_50,   PS3AV_MODE_720P50  },
 604        { PS3AV_RESBIT_720x480P   << SHIFT_60,   PS3AV_MODE_480P    },
 605        { PS3AV_RESBIT_720x576P   << SHIFT_50,   PS3AV_MODE_576P    },
 606};
 607
 608static enum ps3av_mode_num ps3av_resbit2id(u32 res_50, u32 res_60,
 609                                           u32 res_vesa)
 610{
 611        unsigned int i;
 612        u32 res_all;
 613
 614        /*
 615         * We mask off the resolution bits we care about and combine the
 616         * results in one bitfield, so make sure there's no overlap
 617         */
 618        BUILD_BUG_ON(PS3AV_RES_MASK_50 << SHIFT_50 &
 619                     PS3AV_RES_MASK_60 << SHIFT_60);
 620        BUILD_BUG_ON(PS3AV_RES_MASK_50 << SHIFT_50 &
 621                     PS3AV_RES_MASK_VESA << SHIFT_VESA);
 622        BUILD_BUG_ON(PS3AV_RES_MASK_60 << SHIFT_60 &
 623                     PS3AV_RES_MASK_VESA << SHIFT_VESA);
 624        res_all = (res_50 & PS3AV_RES_MASK_50) << SHIFT_50 |
 625                  (res_60 & PS3AV_RES_MASK_60) << SHIFT_60 |
 626                  (res_vesa & PS3AV_RES_MASK_VESA) << SHIFT_VESA;
 627
 628        if (!res_all)
 629                return 0;
 630
 631        for (i = 0; i < ARRAY_SIZE(ps3av_preferred_modes); i++)
 632                if (res_all & ps3av_preferred_modes[i].mask)
 633                        return ps3av_preferred_modes[i].id;
 634
 635        return 0;
 636}
 637
 638static enum ps3av_mode_num ps3av_hdmi_get_id(struct ps3av_info_monitor *info)
 639{
 640        enum ps3av_mode_num id;
 641
 642        if (safe_mode)
 643                return PS3AV_DEFAULT_HDMI_MODE_ID_REG_60;
 644
 645        /* check native resolution */
 646        id = ps3av_resbit2id(info->res_50.native, info->res_60.native,
 647                             info->res_vesa.native);
 648        if (id) {
 649                pr_debug("%s: Using native mode %d\n", __func__, id);
 650                return id;
 651        }
 652
 653        /* check supported resolutions */
 654        id = ps3av_resbit2id(info->res_50.res_bits, info->res_60.res_bits,
 655                             info->res_vesa.res_bits);
 656        if (id) {
 657                pr_debug("%s: Using supported mode %d\n", __func__, id);
 658                return id;
 659        }
 660
 661        if (ps3av->region & PS3AV_REGION_60)
 662                id = PS3AV_DEFAULT_HDMI_MODE_ID_REG_60;
 663        else
 664                id = PS3AV_DEFAULT_HDMI_MODE_ID_REG_50;
 665        pr_debug("%s: Using default mode %d\n", __func__, id);
 666        return id;
 667}
 668
 669static void ps3av_monitor_info_dump(
 670        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(
 721                        "audio[%d] type: %02x max_ch: %02x fs: %02x sbit: %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}
 873EXPORT_SYMBOL_GPL(ps3av_set_video_mode);
 874
 875int ps3av_get_auto_mode(void)
 876{
 877        return ps3av_auto_videomode(&ps3av->av_hw_conf);
 878}
 879EXPORT_SYMBOL_GPL(ps3av_get_auto_mode);
 880
 881int ps3av_get_mode(void)
 882{
 883        return ps3av ? ps3av->ps3av_mode : 0;
 884}
 885EXPORT_SYMBOL_GPL(ps3av_get_mode);
 886
 887/* get resolution by video_mode */
 888int ps3av_video_mode2res(u32 id, u32 *xres, u32 *yres)
 889{
 890        int size;
 891
 892        id = id & PS3AV_MODE_MASK;
 893        size = ARRAY_SIZE(video_mode_table);
 894        if (id > size - 1 || id < 0) {
 895                printk(KERN_ERR "%s: invalid mode %d\n", __func__, id);
 896                return -EINVAL;
 897        }
 898        *xres = video_mode_table[id].x;
 899        *yres = video_mode_table[id].y;
 900        return 0;
 901}
 902EXPORT_SYMBOL_GPL(ps3av_video_mode2res);
 903
 904/* mute */
 905int ps3av_video_mute(int mute)
 906{
 907        return ps3av_set_av_video_mute(mute ? PS3AV_CMD_MUTE_ON
 908                                            : PS3AV_CMD_MUTE_OFF);
 909}
 910EXPORT_SYMBOL_GPL(ps3av_video_mute);
 911
 912/* mute analog output only */
 913int ps3av_audio_mute_analog(int mute)
 914{
 915        int i, res;
 916
 917        for (i = 0; i < ps3av->av_hw_conf.num_of_avmulti; i++) {
 918                res = ps3av_cmd_av_audio_mute(1,
 919                        &ps3av->av_port[i + ps3av->av_hw_conf.num_of_hdmi],
 920                        mute);
 921                if (res < 0)
 922                        return -1;
 923        }
 924        return 0;
 925}
 926EXPORT_SYMBOL_GPL(ps3av_audio_mute_analog);
 927
 928int ps3av_audio_mute(int mute)
 929{
 930        return ps3av_set_audio_mute(mute ? PS3AV_CMD_MUTE_ON
 931                                         : PS3AV_CMD_MUTE_OFF);
 932}
 933EXPORT_SYMBOL_GPL(ps3av_audio_mute);
 934
 935static int __devinit ps3av_probe(struct ps3_system_bus_device *dev)
 936{
 937        int res;
 938        int id;
 939
 940        dev_dbg(&dev->core, " -> %s:%d\n", __func__, __LINE__);
 941        dev_dbg(&dev->core, "  timeout=%d\n", timeout);
 942
 943        if (ps3av) {
 944                dev_err(&dev->core, "Only one ps3av device is supported\n");
 945                return -EBUSY;
 946        }
 947
 948        ps3av = kzalloc(sizeof(*ps3av), GFP_KERNEL);
 949        if (!ps3av)
 950                return -ENOMEM;
 951
 952        mutex_init(&ps3av->mutex);
 953        ps3av->ps3av_mode = PS3AV_MODE_AUTO;
 954        ps3av->dev = dev;
 955
 956        INIT_WORK(&ps3av->work, ps3avd);
 957        init_completion(&ps3av->done);
 958        complete(&ps3av->done);
 959        ps3av->wq = create_singlethread_workqueue("ps3avd");
 960        if (!ps3av->wq) {
 961                res = -ENOMEM;
 962                goto fail;
 963        }
 964
 965        switch (ps3_os_area_get_av_multi_out()) {
 966        case PS3_PARAM_AV_MULTI_OUT_NTSC:
 967                ps3av->region = PS3AV_REGION_60;
 968                break;
 969        case PS3_PARAM_AV_MULTI_OUT_PAL_YCBCR:
 970        case PS3_PARAM_AV_MULTI_OUT_SECAM:
 971                ps3av->region = PS3AV_REGION_50;
 972                break;
 973        case PS3_PARAM_AV_MULTI_OUT_PAL_RGB:
 974                ps3av->region = PS3AV_REGION_50 | PS3AV_REGION_RGB;
 975                break;
 976        default:
 977                ps3av->region = PS3AV_REGION_60;
 978                break;
 979        }
 980
 981        /* init avsetting modules */
 982        res = ps3av_cmd_init();
 983        if (res < 0)
 984                printk(KERN_ERR "%s: ps3av_cmd_init failed %d\n", __func__,
 985                       res);
 986
 987        ps3av_get_hw_conf(ps3av);
 988
 989#ifdef CONFIG_FB
 990        if (fb_mode_option && !strcmp(fb_mode_option, "safe"))
 991                safe_mode = 1;
 992#endif /* CONFIG_FB */
 993        id = ps3av_auto_videomode(&ps3av->av_hw_conf);
 994        if (id < 0) {
 995                printk(KERN_ERR "%s: invalid id :%d\n", __func__, id);
 996                res = -EINVAL;
 997                goto fail;
 998        }
 999
1000        safe_mode = 0;
1001
1002        mutex_lock(&ps3av->mutex);
1003        ps3av->ps3av_mode = id;
1004        mutex_unlock(&ps3av->mutex);
1005
1006        dev_dbg(&dev->core, " <- %s:%d\n", __func__, __LINE__);
1007
1008        return 0;
1009
1010fail:
1011        kfree(ps3av);
1012        ps3av = NULL;
1013        return res;
1014}
1015
1016static int ps3av_remove(struct ps3_system_bus_device *dev)
1017{
1018        dev_dbg(&dev->core, " -> %s:%d\n", __func__, __LINE__);
1019        if (ps3av) {
1020                ps3av_cmd_fin();
1021                if (ps3av->wq)
1022                        destroy_workqueue(ps3av->wq);
1023                kfree(ps3av);
1024                ps3av = NULL;
1025        }
1026
1027        dev_dbg(&dev->core, " <- %s:%d\n", __func__, __LINE__);
1028        return 0;
1029}
1030
1031static void ps3av_shutdown(struct ps3_system_bus_device *dev)
1032{
1033        dev_dbg(&dev->core, " -> %s:%d\n", __func__, __LINE__);
1034        ps3av_remove(dev);
1035        dev_dbg(&dev->core, " <- %s:%d\n", __func__, __LINE__);
1036}
1037
1038static struct ps3_vuart_port_driver ps3av_driver = {
1039        .core.match_id = PS3_MATCH_ID_AV_SETTINGS,
1040        .core.core.name = "ps3_av",
1041        .probe = ps3av_probe,
1042        .remove = ps3av_remove,
1043        .shutdown = ps3av_shutdown,
1044};
1045
1046static int __init ps3av_module_init(void)
1047{
1048        int error;
1049
1050        if (!firmware_has_feature(FW_FEATURE_PS3_LV1))
1051                return -ENODEV;
1052
1053        pr_debug(" -> %s:%d\n", __func__, __LINE__);
1054
1055        error = ps3_vuart_port_driver_register(&ps3av_driver);
1056        if (error) {
1057                printk(KERN_ERR
1058                       "%s: ps3_vuart_port_driver_register failed %d\n",
1059                       __func__, error);
1060                return error;
1061        }
1062
1063        pr_debug(" <- %s:%d\n", __func__, __LINE__);
1064        return error;
1065}
1066
1067static void __exit ps3av_module_exit(void)
1068{
1069        pr_debug(" -> %s:%d\n", __func__, __LINE__);
1070        ps3_vuart_port_driver_unregister(&ps3av_driver);
1071        pr_debug(" <- %s:%d\n", __func__, __LINE__);
1072}
1073
1074subsys_initcall(ps3av_module_init);
1075module_exit(ps3av_module_exit);
1076
1077MODULE_LICENSE("GPL v2");
1078MODULE_DESCRIPTION("PS3 AV Settings Driver");
1079MODULE_AUTHOR("Sony Computer Entertainment Inc.");
1080MODULE_ALIAS(PS3_MODULE_ALIAS_AV_SETTINGS);
1081
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.