M7350/bootable/bootloader/lk/platform/msm_shared/mddi.c
2024-09-09 08:52:07 +00:00

378 lines
9.1 KiB
C

/*
* Copyright (c) 2008, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <debug.h>
#include <reg.h>
#include <stdlib.h>
#include <string.h>
#include <dev/fbcon.h>
#include <kernel/thread.h>
#include <mddi.h>
#include <target/display.h>
#include <platform/timer.h>
#include "mddi_hw.h"
static mddi_llentry *mlist = NULL;
static mddi_llentry *mlist_remote_write = NULL;
#define MDDI_MAX_REV_PKT_SIZE 0x60
#define MDDI_REV_PKT_BUF_SIZE 256
static void *rev_pkt_buf;
/* functions provided by the target specific panel code */
void panel_init(struct mddi_client_caps *client_caps);
void panel_poweron(void);
void panel_backlight(int on);
/* forward decls */
static void mddi_start_update(void);
static int mddi_update_done(void);
static struct fbcon_config fb_cfg = {
.format = FB_FORMAT_RGB565,
.bpp = 16,
.update_start = mddi_start_update,
.update_done = mddi_update_done,
};
static void printcaps(struct mddi_client_caps *c)
{
if ((c->length != 0x4a) || (c->type != 0x42)) {
dprintf(INFO, "bad caps header\n");
memset(c, 0, sizeof(*c));
return;
}
dprintf(INFO, "mddi: bm: %d,%d win %d,%d rgb %x\n",
c->bitmap_width, c->bitmap_height,
c->display_window_width, c->display_window_height, c->rgb_cap);
dprintf(INFO, "mddi: vend %x prod %x\n",
c->manufacturer_name, c->product_code);
}
/* TODO: add timeout */
static int mddi_wait_status(unsigned statmask)
{
while ((readl(MDDI_STAT) & statmask) == 0) ;
return 0;
}
/* TODO: add timeout */
static int mddi_wait_interrupt(unsigned intmask)
{
while ((readl(MDDI_INT) & intmask) == 0) ;
return 0;
}
void mddi_remote_write(unsigned val, unsigned reg)
{
mddi_llentry *ll;
mddi_register_access *ra;
ll = mlist_remote_write;
ra = &(ll->u.r);
ra->length = 14 + 4;
ra->type = TYPE_REGISTER_ACCESS;
ra->client_id = 0;
ra->rw_info = MDDI_WRITE | 1;
ra->crc = 0;
ra->reg_addr = reg;
ra->reg_data[0] = val;
ll->flags = 1;
ll->header_count = 14;
ll->data_count = 4;
ll->data = &ra->reg_data[0];
ll->next = (void *)0;
ll->reserved = 0;
writel((unsigned)ll, MDDI_PRI_PTR);
mddi_wait_status(MDDI_STAT_PRI_LINK_LIST_DONE);
}
#ifdef MDDI_MULTI_WRITE
void
mddi_remote_multiwrite(unsigned *val_list, unsigned reg, unsigned val_count)
{
mddi_llentry *ll;
mddi_register_access *ra;
ll = mlist_remote_write;
ra = &(ll->u.r);
ra->length = 14 + (val_count * 4);
ra->type = TYPE_REGISTER_ACCESS;
ra->client_id = 0;
ra->rw_info = MDDI_WRITE | val_count;
ra->crc = 0;
ra->reg_addr = reg;
memcpy((void *)&ra->reg_data[0], val_list, val_count);
ll->flags = 1;
ll->header_count = 14;
ll->data_count = val_count * 4;
ll->data = &ra->reg_data;
ll->next = (void *)0;
ll->reserved = 0;
writel((unsigned)ll, MDDI_PRI_PTR);
mddi_wait_status(MDDI_STAT_PRI_LINK_LIST_DONE);
}
#endif
static void mddi_start_update(void)
{
writel((unsigned)mlist, MDDI_PRI_PTR);
}
static int mddi_update_done(void)
{
return !!(readl(MDDI_STAT) & MDDI_STAT_PRI_LINK_LIST_DONE);
}
static void mddi_do_cmd(unsigned cmd)
{
writel(cmd, MDDI_CMD);
mddi_wait_interrupt(MDDI_INT_NO_REQ_PKTS_PENDING);
}
static void mddi_init_rev_encap(void)
{
memset(rev_pkt_buf, 0xee, MDDI_REV_PKT_BUF_SIZE);
writel((unsigned)rev_pkt_buf, MDDI_REV_PTR);
writel((unsigned)rev_pkt_buf, MDDI_REV_PTR);
writel(MDDI_REV_PKT_BUF_SIZE, MDDI_REV_SIZE);
writel(MDDI_REV_PKT_BUF_SIZE, MDDI_REV_ENCAP_SZ);
mddi_do_cmd(CMD_FORCE_NEW_REV_PTR);
}
static void mddi_set_auto_hibernate(unsigned on)
{
writel(CMD_POWER_DOWN, MDDI_CMD);
mddi_wait_interrupt(MDDI_INT_IN_HIBERNATION);
mddi_do_cmd(CMD_HIBERNATE | !!on);
}
void mddi_set_caps(mddi_client_caps * c)
{
/* Hardcoding the capability values */
c->length = 74;
c->type = 66;
c->client_id = 0;
c->protocol_ver = 1;
c->min_protocol_ver = 1;
c->data_rate_cap = 400;
c->interface_type_cap = 0;
c->num_alt_displays = 1;
c->postcal_data_rate = 400;
c->bitmap_width = TARGET_XRES;
c->bitmap_height = TARGET_YRES;
c->display_window_width = TARGET_XRES;
c->display_window_height = TARGET_YRES;
c->cmap_size = 0;
c->cmap_rgb_width = 0;
c->rgb_cap = 34592;
c->mono_cap = 0;
c->reserved1 = 0;
c->ycbcr_cap = 0;
c->bayer_cap = 0;
c->alpha_cursor_planes = 0;
c->client_feature_cap = 4489216;
c->max_video_frame_rate_cap = 60;
c->min_video_frame_rate_cap = 0;
c->min_sub_frame_rate = 0;
c->audio_buf_depth = 0;
c->audio_channel_cap = 0;
c->audio_sampe_rate_rap = 0;
c->audio_sample_res = 0;
c->mic_audio_sample_res = 0;
c->mic_sample_rate_cap = 0;
c->keyboard_data_fmt = 0;
c->pointing_device_data_fmt = 0;
c->content_protection_type = 0;
c->manufacturer_name = 53859;
c->product_code = 34594;
c->reserved3 = 0;
c->serial_no = 1;
c->week_of_manufacture = 0;
c->year_of_manufacture = 0;
c->crc = 53536;
}
static void mddi_get_caps(struct mddi_client_caps *caps)
{
unsigned timeout = 100000;
unsigned n;
writel(0xffffffff, MDDI_INT);
mddi_do_cmd(CMD_LINK_ACTIVE);
/* sometimes this will fail -- do it three times for luck... */
mddi_do_cmd(CMD_RTD_MEASURE);
thread_sleep(1); //mdelay(1);
mddi_do_cmd(CMD_RTD_MEASURE);
thread_sleep(1); //mdelay(1);
mddi_do_cmd(CMD_RTD_MEASURE);
thread_sleep(1); //mdelay(1);
mddi_do_cmd(CMD_GET_CLIENT_CAP);
do {
n = readl(MDDI_INT);
}
while (!(n & MDDI_INT_REV_DATA_AVAIL) && (--timeout));
if (timeout == 0)
dprintf(INFO, "timeout\n");
memcpy(caps, rev_pkt_buf, sizeof(struct mddi_client_caps));
}
static unsigned mddi_init_regs(void)
{
mddi_do_cmd(CMD_RESET);
mddi_do_cmd(CMD_PERIODIC_REV_ENC);
writel(0x0001, MDDI_VERSION);
writel(0x3C00, MDDI_BPS);
writel(0x0003, MDDI_SPM);
writel(0x0005, MDDI_TA1_LEN);
writel(0x001A, MDDI_TA2_LEN);
writel(0x0096, MDDI_DRIVE_HI);
writel(0x0050, MDDI_DRIVE_LO);
writel(0x003C, MDDI_DISP_WAKE);
writel(0x0004, MDDI_REV_RATE_DIV);
/* needs to settle for 5uS */
if (readl(MDDI_PAD_CTL) == 0) {
writel(0x08000, MDDI_PAD_CTL);
udelay(5);
}
writel(0xA850F, MDDI_PAD_CTL);
writel(0x60006, MDDI_DRIVER_START_CNT);
mddi_init_rev_encap();
/* disable hibernate */
mddi_do_cmd(CMD_HIBERNATE | 0);
return readl(MDDI_CORE_VER) & 0xffff;
}
struct fbcon_config *mddi_init(void)
{
unsigned n;
struct mddi_client_caps client_caps;
dprintf(INFO, "mddi_init()\n");
rev_pkt_buf = memalign(32, MDDI_REV_PKT_BUF_SIZE);
mlist_remote_write = memalign(32, sizeof(struct mddi_llentry));
n = mddi_init_regs();
dprintf(INFO, "mddi version: 0x%08x\n", n);
//mddi_get_caps(&client_caps);
//if(!(client_caps.length == 0x4a && client_caps.type == 0x42))
{
mddi_set_caps(&client_caps);
}
fb_cfg.width = client_caps.bitmap_width;
fb_cfg.stride = fb_cfg.width;
fb_cfg.height = client_caps.bitmap_height;
panel_init(&client_caps);
panel_backlight(0);
panel_poweron();
/* v > 8? v > 8 && < 0x19 ? */
writel(2, MDDI_TEST);
dprintf(INFO, "panel is %d x %d\n", fb_cfg.width, fb_cfg.height);
fb_cfg.base =
memalign(4096, fb_cfg.width * fb_cfg.height * (fb_cfg.bpp / 8));
mlist = memalign(32, sizeof(mddi_llentry) * (fb_cfg.height / 8));
dprintf(INFO, "FB @ %p mlist @ %x\n", fb_cfg.base, (unsigned)mlist);
for (n = 0; n < (fb_cfg.height / 8); n++) {
unsigned y = n * 8;
unsigned pixels = fb_cfg.width * 8;
mddi_video_stream *vs = &(mlist[n].u.v);
vs->length = sizeof(mddi_video_stream) - 2 + (pixels * 2);
vs->type = TYPE_VIDEO_STREAM;
vs->client_id = 0;
vs->format = 0x5565; // FORMAT_16BPP;
vs->pixattr = PIXATTR_BOTH_EYES | PIXATTR_TO_ALL;
vs->left = 0;
vs->right = fb_cfg.width - 1;
vs->top = y;
vs->bottom = y + 7;
vs->start_x = 0;
vs->start_y = y;
vs->pixels = pixels;
vs->crc = 0;
vs->reserved = 0;
mlist[n].header_count = sizeof(mddi_video_stream) - 2;
mlist[n].data_count = pixels * 2;
mlist[n].reserved = 0;
mlist[n].data = fb_cfg.base + (y * fb_cfg.width * 2);
mlist[n].next = &mlist[n + 1];
mlist[n].flags = 0;
}
mlist[n - 1].flags = 1;
mlist[n - 1].next = 0;
mddi_set_auto_hibernate(1);
mddi_do_cmd(CMD_LINK_ACTIVE);
panel_backlight(1);
return &fb_cfg;
}