330 lines
8.3 KiB
C
330 lines
8.3 KiB
C
/* Copyright (c) 2014, The Linux Foundation. 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.
|
|
* * Neither the name of The Linux Foundation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* 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 <err.h>
|
|
#include <msm_panel.h>
|
|
#include <platform/iomap.h>
|
|
#include <platform/timer.h>
|
|
#include <reg.h>
|
|
#include <target.h>
|
|
|
|
#include "qpic.h"
|
|
#include "qpic_panel.h"
|
|
|
|
int mdss_qpic_panel_init(struct qpic_panel_io_desc *panel_io);
|
|
|
|
struct qpic_data_type qpic_data;
|
|
struct qpic_data_type *qpic_res = &qpic_data;
|
|
static int qpic_send_pkt_sw(uint32_t cmd, uint32_t len, uint8_t *param);
|
|
|
|
/* for debugging */
|
|
static uint32_t use_bam = false;
|
|
static uint32_t use_vsync;
|
|
|
|
/* For compilation */
|
|
void mdp_set_revision(int rev)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int qpic_on(void)
|
|
{
|
|
int ret;
|
|
ret = mdss_qpic_panel_on(&qpic_res->panel_io);
|
|
return ret;
|
|
}
|
|
|
|
int qpic_off(void)
|
|
{
|
|
int ret = NO_ERROR;
|
|
|
|
if (!target_cont_splash_screen()) {
|
|
ret = mdss_qpic_panel_off(&qpic_res->panel_io);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void qpic_update()
|
|
{
|
|
uint32_t fb_offset, size;
|
|
|
|
if (use_bam)
|
|
fb_offset = qpic_res->fb_phys + (uint32_t) qpic_res->base;
|
|
else
|
|
fb_offset = (uint32_t) qpic_res->fb_virt + (uint32_t) qpic_res->base;
|
|
|
|
size = qpic_res->fb_xres * qpic_res->fb_yres * qpic_res->fb_bpp;
|
|
|
|
qpic_send_frame(0, 0, qpic_res->fb_xres - 1, qpic_res->fb_yres - 1,
|
|
(uint32_t *)fb_offset, size);
|
|
}
|
|
|
|
int mdss_qpic_alloc_fb_mem(struct msm_panel_info *pinfo, int base)
|
|
{
|
|
qpic_res->fb_virt = 0;
|
|
qpic_res->fb_phys = 0;
|
|
qpic_res->fb_xres = pinfo->xres;
|
|
qpic_res->fb_yres = pinfo->yres;
|
|
qpic_res->fb_bpp = pinfo->bpp / 8;
|
|
qpic_res->base = base;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void qpic_init(struct msm_panel_info *pinfo, int base)
|
|
{
|
|
if (qpic_res->res_init)
|
|
return;
|
|
|
|
qpic_res->qpic_base = QPIC_BASE;
|
|
mdss_qpic_panel_init(&qpic_res->panel_io);
|
|
mdss_qpic_alloc_fb_mem(pinfo, base);
|
|
qpic_res->res_init = true;
|
|
}
|
|
|
|
int qpic_init_sps(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void mdss_qpic_reset(void)
|
|
{
|
|
uint32_t cnt = 0;
|
|
|
|
QPIC_OUTP(QPIC_REG_QPIC_LCDC_RESET, 1 << 0);
|
|
/* wait 100 us after reset as suggested by hw */
|
|
udelay(100);
|
|
while (((QPIC_INP(QPIC_REG_QPIC_LCDC_STTS) & (1 << 8)) == 0)) {
|
|
if (cnt > QPIC_MAX_WAIT_CNT) {
|
|
dprintf(CRITICAL, "%s reset not finished\n", __func__);
|
|
break;
|
|
}
|
|
/* yield 100 us for next polling by experiment*/
|
|
udelay(100);
|
|
cnt++;
|
|
}
|
|
}
|
|
|
|
static int qpic_send_pkt_bam(uint32_t cmd, uint32_t len, uint8_t *param)
|
|
{
|
|
return qpic_send_pkt_sw(cmd, len, param);
|
|
}
|
|
|
|
static void qpic_dump_reg(void)
|
|
{
|
|
dprintf(INFO, "%s\n", __func__);
|
|
dprintf(INFO, "QPIC_REG_QPIC_LCDC_CTRL = %x\n",
|
|
QPIC_INP(QPIC_REG_QPIC_LCDC_CTRL));
|
|
dprintf(INFO, "QPIC_REG_QPIC_LCDC_CMD_DATA_CYCLE_CNT = %x\n",
|
|
QPIC_INP(QPIC_REG_QPIC_LCDC_CMD_DATA_CYCLE_CNT));
|
|
dprintf(INFO, "QPIC_REG_QPIC_LCDC_CFG0 = %x\n",
|
|
QPIC_INP(QPIC_REG_QPIC_LCDC_CFG0));
|
|
dprintf(INFO, "QPIC_REG_QPIC_LCDC_CFG1 = %x\n",
|
|
QPIC_INP(QPIC_REG_QPIC_LCDC_CFG1));
|
|
dprintf(INFO, "QPIC_REG_QPIC_LCDC_CFG2 = %x\n",
|
|
QPIC_INP(QPIC_REG_QPIC_LCDC_CFG2));
|
|
dprintf(INFO, "QPIC_REG_QPIC_LCDC_IRQ_EN = %x\n",
|
|
QPIC_INP(QPIC_REG_QPIC_LCDC_IRQ_EN));
|
|
dprintf(INFO, "QPIC_REG_QPIC_LCDC_IRQ_STTS = %x\n",
|
|
QPIC_INP(QPIC_REG_QPIC_LCDC_IRQ_STTS));
|
|
dprintf(INFO, "QPIC_REG_QPIC_LCDC_STTS = %x\n",
|
|
QPIC_INP(QPIC_REG_QPIC_LCDC_STTS));
|
|
dprintf(INFO, "QPIC_REG_QPIC_LCDC_FIFO_SOF = %x\n",
|
|
QPIC_INP(QPIC_REG_QPIC_LCDC_FIFO_SOF));
|
|
}
|
|
|
|
static int qpic_wait_for_fifo(void)
|
|
{
|
|
uint32_t data, cnt = 0;
|
|
int ret = 0;
|
|
|
|
while (1) {
|
|
data = QPIC_INP(QPIC_REG_QPIC_LCDC_STTS);
|
|
data &= 0x3F;
|
|
if (data == 0)
|
|
break;
|
|
/* yield 10 us for next polling by experiment*/
|
|
udelay(10);
|
|
if (cnt > (QPIC_MAX_WAIT_CNT * 10)) {
|
|
dprintf(CRITICAL, "%s time out\n", __func__);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
cnt++;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int qpic_wait_for_eof(void)
|
|
{
|
|
uint32_t data, cnt = 0;
|
|
int ret = 0;
|
|
|
|
while (1) {
|
|
data = QPIC_INP(QPIC_REG_QPIC_LCDC_IRQ_STTS);
|
|
if (data & (1 << 2))
|
|
break;
|
|
/* yield 10 us for next polling by experiment*/
|
|
udelay(10);
|
|
if (cnt > (QPIC_MAX_WAIT_CNT * 10)) {
|
|
dprintf(CRITICAL, "%s wait for eof time out\n", __func__);
|
|
qpic_dump_reg();
|
|
ret = -1;
|
|
break;
|
|
}
|
|
cnt++;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int qpic_send_pkt_sw(uint32_t cmd, uint32_t len, uint8_t *param)
|
|
{
|
|
uint32_t bytes_left, space, data, cfg2;
|
|
int ret = 0;
|
|
uint32_t i;
|
|
|
|
if (len && !param) {
|
|
dprintf(CRITICAL, "Null Pointer!\n");
|
|
return 0;
|
|
}
|
|
if (len <= 4) {
|
|
len = (len + 3) / 4; /* len in dwords */
|
|
data = 0;
|
|
for (i = 0; i < len; i++)
|
|
data |= (uint32_t)param[i] << (8 * i);
|
|
QPIC_OUTP(QPIC_REG_QPIC_LCDC_CMD_DATA_CYCLE_CNT, len);
|
|
QPIC_OUTP(QPIC_REG_LCD_DEVICE_CMD0 + (4 * cmd), data);
|
|
return 0;
|
|
}
|
|
|
|
if ((len & 0x1) != 0) {
|
|
dprintf(INFO, "%s: number of bytes needs be even\n", __func__);
|
|
len = (len + 1) & (~0x1);
|
|
}
|
|
QPIC_OUTP(QPIC_REG_QPIC_LCDC_IRQ_CLR, 0xff);
|
|
QPIC_OUTP(QPIC_REG_QPIC_LCDC_CMD_DATA_CYCLE_CNT, 0);
|
|
cfg2 = QPIC_INP(QPIC_REG_QPIC_LCDC_CFG2);
|
|
if ((cmd != OP_WRITE_MEMORY_START) &&
|
|
(cmd != OP_WRITE_MEMORY_CONTINUE))
|
|
cfg2 |= (1 << 24); /* transparent mode */
|
|
else
|
|
cfg2 &= ~(1 << 24);
|
|
|
|
cfg2 &= ~0xFF;
|
|
cfg2 |= cmd;
|
|
QPIC_OUTP(QPIC_REG_QPIC_LCDC_CFG2, cfg2);
|
|
QPIC_OUTP(QPIC_REG_QPIC_LCDC_FIFO_SOF, 0x0);
|
|
bytes_left = len;
|
|
|
|
while (bytes_left > 0) {
|
|
ret = qpic_wait_for_fifo();
|
|
if (ret)
|
|
goto exit_send_cmd_sw;
|
|
|
|
space = 16;
|
|
|
|
while ((space > 0) && (bytes_left > 0)) {
|
|
/* write to fifo */
|
|
if (bytes_left >= 4) {
|
|
QPIC_OUTP(QPIC_REG_QPIC_LCDC_FIFO_DATA_PORT0,
|
|
*(uint32_t *)param);
|
|
param += 4;
|
|
bytes_left -= 4;
|
|
space--;
|
|
} else if (bytes_left == 2) {
|
|
QPIC_OUTPW(QPIC_REG_QPIC_LCDC_FIFO_DATA_PORT0,
|
|
*(uint16_t *)param);
|
|
bytes_left -= 2;
|
|
}
|
|
}
|
|
}
|
|
/* finished */
|
|
QPIC_OUTP(QPIC_REG_QPIC_LCDC_FIFO_EOF, 0x0);
|
|
ret = qpic_wait_for_eof();
|
|
exit_send_cmd_sw:
|
|
cfg2 &= ~(1 << 24);
|
|
QPIC_OUTP(QPIC_REG_QPIC_LCDC_CFG2, cfg2);
|
|
return ret;
|
|
}
|
|
|
|
int qpic_send_pkt(uint32_t cmd, uint8_t *param, uint32_t len)
|
|
{
|
|
if (!use_bam || ((cmd != OP_WRITE_MEMORY_CONTINUE) &&
|
|
(cmd != OP_WRITE_MEMORY_START)))
|
|
return qpic_send_pkt_sw(cmd, len, param);
|
|
else
|
|
return qpic_send_pkt_bam(cmd, len, param);
|
|
}
|
|
|
|
int mdss_qpic_init(void)
|
|
{
|
|
int ret = 0;
|
|
uint32_t data;
|
|
mdss_qpic_reset();
|
|
|
|
data = QPIC_INP(QPIC_REG_QPIC_LCDC_CTRL);
|
|
/* clear vsync wait , bam mode = 0 */
|
|
data &= ~(3 << 0);
|
|
data &= ~(0x1f << 3);
|
|
data |= (1 << 3); /* threshold */
|
|
data |= (1 << 8); /* lcd_en */
|
|
data &= ~(0x1f << 9);
|
|
data |= (1 << 9); /* threshold */
|
|
QPIC_OUTP(QPIC_REG_QPIC_LCDC_CTRL, data);
|
|
|
|
QPIC_OUTP(QPIC_REG_QPIC_LCDC_CFG0, 0x02108501);
|
|
data = QPIC_INP(QPIC_REG_QPIC_LCDC_CFG2);
|
|
data &= ~(0xFFF);
|
|
data |= 0x0; /* 565 */
|
|
data |= 0x2C;
|
|
QPIC_OUTP(QPIC_REG_QPIC_LCDC_CFG2, data);
|
|
|
|
/* TE enable */
|
|
if (use_vsync) {
|
|
data = QPIC_INP(QPIC_REG_QPIC_LCDC_CTRL);
|
|
data |= (1 << 0);
|
|
QPIC_OUTP(QPIC_REG_QPIC_LCDC_CTRL, data);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
uint32_t qpic_read_data(uint32_t cmd_index, uint32_t size)
|
|
{
|
|
uint32_t data = 0;
|
|
if (size <= 4) {
|
|
QPIC_OUTP(QPIC_REG_QPIC_LCDC_CMD_DATA_CYCLE_CNT, size);
|
|
data = QPIC_INP(QPIC_REG_LCD_DEVICE_CMD0 + (cmd_index * 4));
|
|
}
|
|
return data;
|
|
}
|
|
|