rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/u-boot/drivers/video/rk_eink/rk_eink_display.c

897 lines
24 KiB
C
Raw Blame History

/*
* (C) Copyright 2020 Rockchip Electronics Co., Ltd
*
* SPDX-License-Identifier: GPL-2.0+
* Author: Wenping Zhang <wenping.zhang@rock-chips.com>
*/
#include <common.h>
#include <dm.h>
#include <stdio.h>
#include <errno.h>
#include <mapmem.h>
#include <stdlib.h>
#include <asm/arch/vendor.h>
#include <dm/of_access.h>
#include <dm/uclass.h>
#include <dm/uclass-id.h>
#include <boot_rkimg.h>
#include <rk_eink.h>
#include <backlight.h>
#include "rk_ebc.h"
#include "epdlut/epd_lut.h"
#define PART_WAVEFORM "waveform"
#define EINK_LOGO_PART_MAGIC "RKEL"
#define EINK_LOGO_IMAGE_MAGIC "GR04"
/*
* grayscale logo partition format:
* block0:
* struct logo_part_header part_header;
* struct grayscale_header logo1_header;
* struct grayscale_header logo2_header;
* struct grayscale_header logo3_header;
* struct grayscale_header logo4_header;
* ....
*
* block 1:
* logo1_image
*
* .....
* block m:
* logo2_image
*
* ........
* block n:
* logo3_image
*
* ........
* block i:
* logoi_image
*/
//logo partition Header, 64byte
struct logo_part_header {
char magic[4]; /* must be "RKEL" */
u32 totoal_size;
u32 screen_width;
u32 screen_height;
u32 logo_count;
u8 version[4];
u32 rsv[10];
} __packed;
// logo image header,32 byte
struct grayscale_header {
char magic[4]; /* must be "GR04" */
u16 x;
u16 y;
u16 w;
u16 h;
u32 logo_type;
u32 data_offset; /* image offset in byte */
u32 data_size; /* image size in byte */
u32 rsv[2];
} __packed;
/*
* The start address of logo image in logo.img must be aligned in 512 bytes,
* so the header size must be times of 512 bytes. Here we fix the size to 512
* bytes, so the count of logo image can only support up to 14.
*/
struct logo_info {
struct logo_part_header part_hdr;
struct grayscale_header img_hdr[14];
} __packed;
struct rockchip_eink_display_priv {
struct udevice *dev;
struct udevice *ebc_tcon_dev;
struct udevice *ebc_pwr_dev;
int vcom;
struct udevice *backlight;
};
enum {
EBC_PWR_DOWN = 0,
EBC_PWR_ON = 1,
};
#define EINK_VCOM_ID 17
#define EINK_VCOM_MAX 64
#define VCOM_DEFAULT_VALUE 1650
static struct logo_info eink_logo_info;
static struct udevice *eink_dev;
static volatile int last_logo_type = -1;
static int read_vcom_from_vendor(void)
{
int ret = 0;
char vcom_str[EINK_VCOM_MAX] = {0};
char vcom_args[EINK_VCOM_MAX] = {0};
/* Read vcom value from vendor storage part */
ret = vendor_storage_read(EINK_VCOM_ID, vcom_str, (EINK_VCOM_MAX - 1));
if (ret > 0) {
snprintf(vcom_args, strlen(vcom_str) + 15, "ebc_pmic.vcom=%s", vcom_str);
printf("eink update bootargs: %s\n", vcom_args);
env_update("bootargs", vcom_args);
} else {
return ret;
}
return atoi(vcom_str);
}
static int read_waveform(struct udevice *dev)
{
int cnt, start, ret;
disk_partition_t part;
struct blk_desc *dev_desc;
struct ebc_panel *plat = dev_get_platdata(dev);
dev_desc = rockchip_get_bootdev();
if (!dev_desc) {
printf("%s: Could not find device\n", __func__);
return -EIO;
}
if (part_get_info_by_name(dev_desc, PART_WAVEFORM, &part) < 0) {
printf("Get waveform partition failed\n");
return -ENODEV;
}
cnt = plat->lut_pbuf_size / RK_BLK_SIZE;
start = part.start;
ret = blk_dread(dev_desc, start, cnt, (void *)plat->lut_pbuf);
if (ret != cnt)
printf("Try to read %d blocks failed, only read %d\n",
cnt, ret);
flush_dcache_range((ulong)plat->lut_pbuf,
ALIGN((ulong)plat->lut_pbuf + cnt,
CONFIG_SYS_CACHELINE_SIZE));
ret = epd_lut_from_mem_init(plat->lut_pbuf, &plat->lut_ops);
if (ret < 0) {
printf("lut init failed\n");
return -EINVAL;
}
return 0;
}
static u32 aligned_image_size_4k(struct udevice *dev)
{
struct ebc_panel *plat = dev_get_platdata(dev);
u32 w = plat->vir_width;
u32 h = plat->vir_height;
return ALIGN((w * h) >> 1, 4096);
}
/*
* This driver load the grayscale image from flash,
* and put it in the reserve memory which define in dts:
* display_reserved: framebuffer@10000000 {
* reg = <0x0 0x10000000 0x0 0x2000000>;
* no-map;
* };
* Every image logo size must be aligned in 4K, make sure
* kernel can use it rightly, the buffer of LOGO image is
* put in order of below map:
* |---reset logo ---|
* |---uboot logo ---|
* |---kernel logo ---|
* |---charge_0 logo ---|
* |---charge_1 logo ---|
* |---charge_2 logo ---|
* |---charge_3 logo ---|
* |---charge_4 logo ---|
* |---charge_5 logo ---|
* |---battery low logo---|
* |---temp un-mirror buffer--|
*/
static int get_addr_by_type(struct udevice *dev, u32 logo_type)
{
u32 offset, indx, img_size;
struct ebc_panel *plat = dev_get_platdata(dev);
if (plat->disp_pbuf_size == 0 || !plat->disp_pbuf) {
printf("invalid display buffer, please check dts\n");
return -EINVAL;
}
indx = ffs(logo_type);
img_size = aligned_image_size_4k(dev);
offset = img_size * indx;
if (offset + img_size > plat->disp_pbuf_size) {
printf("reserve display memory size is not enough\n");
return -EINVAL;
}
switch (logo_type) {
case EINK_LOGO_RESET:
case EINK_LOGO_UBOOT:
case EINK_LOGO_KERNEL:
case EINK_LOGO_CHARGING_0:
case EINK_LOGO_CHARGING_1:
case EINK_LOGO_CHARGING_2:
case EINK_LOGO_CHARGING_3:
case EINK_LOGO_CHARGING_4:
case EINK_LOGO_CHARGING_5:
case EINK_LOGO_CHARGING_LOWPOWER:
case EINK_LOGO_POWEROFF:
/*
* The MIRROR_TEMP_BUF is used to save the
* non-mirror image data.
*/
case EINK_LOGO_UNMIRROR_TEMP_BUF:
return (plat->disp_pbuf + offset);
default:
printf("invalid logo type[%d]\n", logo_type);
}
return -EINVAL;
}
static int read_header(struct blk_desc *dev_desc,
disk_partition_t *part,
struct logo_info *header)
{
int i;
struct logo_part_header *part_hdr = &header->part_hdr;
if (blk_dread(dev_desc, part->start, 1, header) != 1)
return -EIO;
if (memcmp(part_hdr->magic, EINK_LOGO_PART_MAGIC, 4)) {
printf("partition header is invalid\n");
return -EINVAL;
}
if (part_hdr->logo_count == 0) {
printf("the count of logo image is 0\n");
return -EINVAL;
}
for (i = 0; i < part_hdr->logo_count; i++) {
struct grayscale_header *img_hdr = &header->img_hdr[i];
if (memcmp(img_hdr->magic, EINK_LOGO_IMAGE_MAGIC, 4)) {
printf("image[%d] header '%s' is invalid\n", i,
img_hdr->magic);
return -EINVAL;
}
}
return 0;
}
static int read_grayscale(struct blk_desc *dev_desc,
disk_partition_t *part, u32 offset,
u32 size, void *buf)
{
u32 blk_start, blk_offset, blk_count;
blk_offset = DIV_ROUND_UP(offset, dev_desc->blksz);
blk_start = part->start + blk_offset;
blk_count = DIV_ROUND_UP(size, dev_desc->blksz);
debug("blk_offset=%d, blk_start=%d,blk_count=%d,out buf=%p\n",
blk_offset, blk_start, blk_count, buf);
if (blk_dread(dev_desc, blk_start, blk_count, buf) != blk_count) {
printf("read grayscale data failed\n");
return -EIO;
}
return 0;
}
static int image_rearrange(u8 *in_buf, u8 *out_buf, u16 w, u16 h)
{
int i, j;
u8 in_data;
u8 *out_buf_tmp;
if (!in_buf || !out_buf) {
printf("rearrange in buffer or out buffer is NULL\n");
return -EINVAL;
}
for (i = 0; i < h; i += 2) {
out_buf_tmp = out_buf + (i * w / 2);
for (j = 0; j < w / 2; j++) {
in_data = *in_buf++;
*(out_buf_tmp + j * 2) = in_data & 0x0f;
*(out_buf_tmp + j * 2 + 1) = (in_data >> 4) & 0x0f;
}
for (j = 0; j < w / 2; j++) {
in_data = *in_buf++;
*(out_buf_tmp + j * 2) |= (in_data << 4) & 0xf0;
*(out_buf_tmp + j * 2 + 1) |= in_data & 0xf0;
}
}
return 0;
}
static int image_mirror(u8 *in_buf, u8 *out_buf, u16 w, u16 h)
{
int i;
if (!in_buf || !out_buf) {
printf("mirror in buffer or out buffer is NULL\n");
return -EINVAL;
}
for (i = 0; i < h; i++) {
u16 column_len = w / 2;
u8 *column_in = in_buf + i * column_len;
u8 *column_out = out_buf + (h - i - 1) * column_len;
memcpy(column_out, column_in, column_len);
}
return 0;
}
/*
* The eink kernel driver need last frame to do part refresh,
* so we need to transfer two images to kernel, which is kernel
* logo and the logo displayed in uboot.
*
* this function use logo type bitmap to indicate several logo.
* u32 needed_logo: we only load needed logo image into ram, such as
* uboot logo + kernel logo or charger logo + kernel
* logo
* u32 *loaded_logo: because the needed logo may not exist in logo.img,
* store the really loaded logo in para loaded_logo.
*/
static int read_needed_logo_from_partition(struct udevice *dev,
u32 needed_logo,
u32 *loaded_logo)
{
int ret, i;
disk_partition_t part;
struct blk_desc *dev_desc;
struct logo_info *hdr = &eink_logo_info;
struct logo_part_header *part_hdr = &hdr->part_hdr;
struct ebc_panel *panel = dev_get_platdata(dev);
u32 logo = needed_logo & (~(*loaded_logo));
if (!logo) {
printf("logo[0x%x] is already loaded, just return!\n",
needed_logo);
return 0;
}
dev_desc = rockchip_get_bootdev();
if (!dev_desc) {
printf("%s: Could not find device\n", __func__);
return -EIO;
}
if (part_get_info_by_name(dev_desc, PART_LOGO, &part) < 0)
return -ENODEV;
ret = read_header(dev_desc, &part, hdr);
if (ret < 0) {
printf("eink logo read header failed,ret = %d\n", ret);
return -EINVAL;
}
if (part_hdr->screen_width != panel->vir_width ||
part_hdr->screen_height != panel->vir_height){
printf("logo size(%dx%d) is not same as screen size(%dx%d)\n",
part_hdr->screen_width, part_hdr->screen_height,
panel->vir_width, panel->vir_height);
return -EINVAL;
}
for (i = 0; i < part_hdr->logo_count; i++) {
struct grayscale_header *img_hdr = &hdr->img_hdr[i];
int pic_buf;
u32 offset = img_hdr->data_offset;
u32 size = img_hdr->data_size;
u32 logo_type = img_hdr->logo_type;
debug("offset=0x%x, size=%d,logo_type=%d,w=%d,h=%d\n",
offset, size, logo_type, img_hdr->w, img_hdr->h);
if (logo & logo_type) {
pic_buf = get_addr_by_type(dev, logo_type);
if (pic_buf <= 0) {
printf("Get buffer failed for image %d\n",
img_hdr->logo_type);
return -EIO;
}
if (!IS_ALIGNED((ulong)pic_buf,
ARCH_DMA_MINALIGN)) {
printf("disp buffer is not dma aligned\n");
return -EINVAL;
}
/*
* kernel logo is transmitted to kernel to display, and
* kernel will do the mirror operation, so skip kernel
* logo here.
*/
if (panel->mirror && logo_type != EINK_LOGO_KERNEL) {
u32 w = panel->vir_width;
u32 h = panel->vir_height;
u32 mirror_buf = 0;
mirror_buf = get_addr_by_type(dev,
EINK_LOGO_UNMIRROR_TEMP_BUF);
if (mirror_buf <= 0) {
printf("get mirror buffer failed\n");
return -EIO;
}
read_grayscale(dev_desc, &part, offset, size,
(void *)((ulong)mirror_buf));
image_mirror((u8 *)((ulong)mirror_buf),
(u8 *)((ulong)pic_buf), w, h);
} else if (panel->rearrange && logo_type != EINK_LOGO_KERNEL) {
u32 w = panel->vir_width;
u32 h = panel->vir_height;
u32 rearrange_buf = 0;
rearrange_buf = get_addr_by_type(dev,
EINK_LOGO_UNMIRROR_TEMP_BUF);
if (rearrange_buf <= 0) {
printf("get mirror buffer failed\n");
return -EIO;
}
read_grayscale(dev_desc, &part, offset, size,
(void *)((ulong)rearrange_buf));
image_rearrange((u8 *)((ulong)rearrange_buf),
(u8 *)((ulong)pic_buf), w, h);
} else {
read_grayscale(dev_desc, &part, offset, size,
(void *)((ulong)pic_buf));
}
flush_dcache_range((ulong)pic_buf,
ALIGN((ulong)pic_buf + size,
CONFIG_SYS_CACHELINE_SIZE));
*loaded_logo |= logo_type;
logo &= ~logo_type;
if (!logo)
break;
}
}
return 0;
}
static int ebc_power_set(struct udevice *dev, int is_on)
{
int ret;
struct rockchip_eink_display_priv *priv = dev_get_priv(dev);
struct ebc_panel *panel = dev_get_platdata(dev);
struct udevice *ebc_tcon_dev = priv->ebc_tcon_dev;
struct rk_ebc_tcon_ops *ebc_tcon_ops = ebc_tcon_get_ops(ebc_tcon_dev);
struct udevice *ebc_pwr_dev = priv->ebc_pwr_dev;
struct rk_ebc_pwr_ops *pwr_ops = ebc_pwr_get_ops(ebc_pwr_dev);
if (is_on) {
ret = pwr_ops->power_on(ebc_pwr_dev);
if (ret) {
printf("%s, power on failed\n", __func__);
return -1;
}
ret = ebc_tcon_ops->enable(ebc_tcon_dev, panel);
if (ret) {
printf("%s, ebc tcon enabled failed\n", __func__);
return -1;
}
} else {
ret = ebc_tcon_ops->disable(ebc_tcon_dev);
if (ret) {
printf("%s, ebc tcon disable failed\n", __func__);
return -1;
}
ret = pwr_ops->power_down(ebc_pwr_dev);
if (ret) {
printf("%s, power_down failed\n", __func__);
return -1;
}
}
return 0;
}
static int eink_display(struct udevice *dev, u32 pre_img_buf,
u32 cur_img_buf, u32 lut_type, int update_mode)
{
u32 temperature, frame_num;
struct rockchip_eink_display_priv *priv = dev_get_priv(dev);
struct ebc_panel *plat = dev_get_platdata(dev);
struct epd_lut_ops *lut_ops = &plat->lut_ops;
struct udevice *ebc_pwr_dev = priv->ebc_pwr_dev;
struct rk_ebc_pwr_ops *pwr_ops = ebc_pwr_get_ops(ebc_pwr_dev);
struct udevice *ebc_tcon_dev = priv->ebc_tcon_dev;
struct rk_ebc_tcon_ops *ebc_tcon_ops = ebc_tcon_get_ops(ebc_tcon_dev);
pwr_ops->temp_get(ebc_pwr_dev, &temperature);
if (temperature <= 0 || temperature > 50) {
printf("temperature = %d, out of range0~50 ,use 25\n",
temperature);
temperature = 25;
}
if (!lut_ops->lut_get) {
printf("get lut ops failed\n");
return -EIO;
}
lut_ops->lut_get(&plat->lut_data, lut_type, temperature);
frame_num = plat->lut_data.frame_num;
debug("lut_type=%d, frame num=%d, temp=%d\n", lut_type,
frame_num, temperature);
ebc_tcon_ops->wait_for_last_frame_complete(ebc_tcon_dev);
ebc_tcon_ops->lut_data_set(ebc_tcon_dev, plat->lut_data.data,
frame_num, 0);
ebc_tcon_ops->dsp_mode_set(ebc_tcon_dev, update_mode,
LUT_MODE, !THREE_WIN_MODE, !EINK_MODE);
ebc_tcon_ops->image_addr_set(ebc_tcon_dev, pre_img_buf, cur_img_buf);
ebc_tcon_ops->frame_start(ebc_tcon_dev, frame_num);
return 0;
}
static int rk_eink_display_init(void)
{
int ret;
struct uclass *uc;
struct udevice *dev;
if (eink_dev) {
printf("ebc-dev is already initialized!\n");
return 0;
}
ret = uclass_get(UCLASS_EINK_DISPLAY, &uc);
if (ret) {
printf("can't find uclass eink\n");
return -ENODEV;
}
for (uclass_first_device(UCLASS_EINK_DISPLAY, &dev);
dev; uclass_next_device(&dev))
;
if (eink_dev) {
printf("ebc-dev is probed success!\n");
return 0;
}
printf("Can't find ebc-dev\n");
return -ENODEV;
}
/*
* Eink display need current and previous image buffer, We assume
* every type of logo has only one image, so just tell this function
* last logo type and current logo type, it will find the right images.
* last_logo_type: -1 means it's first displaying.
*/
static int rockchip_eink_show_logo(int cur_logo_type, int update_mode)
{
int ret = 0;
u32 logo_addr;
u32 last_logo_addr;
struct ebc_panel *plat;
struct udevice *dev;
static u32 loaded_logo = 0;
struct rockchip_eink_display_priv *priv;
if (!eink_dev) {
static bool first_init = true;
if (first_init) {
first_init = false;
ret = rk_eink_display_init();
if (ret) {
printf("Get ebc dev failed, check dts\n");
return -ENODEV;
}
} else {
return -ENODEV;
}
}
dev = eink_dev;
/*Don't need to update display*/
if (last_logo_type == cur_logo_type) {
debug("Same as last picture, Don't need to display\n");
return 0;
}
plat = dev_get_platdata(dev);
priv = dev_get_priv(dev);
/*
* The last_logo_type is -1 means it's first displaying
*/
if (last_logo_type == -1) {
ret = ebc_power_set(dev, EBC_PWR_ON);
if (ret) {
printf("Eink power on failed\n");
return -1;
}
int size = (plat->vir_width * plat->vir_height) >> 1;
logo_addr = get_addr_by_type(dev, EINK_LOGO_RESET);
memset((u32 *)(u64)logo_addr, 0xff, size);
flush_dcache_range((ulong)logo_addr,
ALIGN((ulong)logo_addr + size,
CONFIG_SYS_CACHELINE_SIZE));
eink_display(dev, logo_addr, logo_addr,
WF_TYPE_RESET, EINK_LOGO_RESET);
last_logo_type = 0;
last_logo_addr = logo_addr;
} else {
last_logo_addr = get_addr_by_type(dev, last_logo_type);
if (last_logo_addr < 0) {
printf("Invalid last logo addr, exit!\n");
goto out;
}
}
ret = read_needed_logo_from_partition(dev, cur_logo_type,
&loaded_logo);
if (ret || !(loaded_logo & cur_logo_type)) {
printf("read logo[0x%x] failed, loaded_logo=0x%x\n",
cur_logo_type, loaded_logo);
ret = -EIO;
goto out;
}
logo_addr = get_addr_by_type(dev, cur_logo_type);
debug("logo_addr=%x, logo_type=%d\n", logo_addr, cur_logo_type);
if (logo_addr <= 0) {
printf("get logo buffer failed\n");
ret = -EIO;
goto out;
}
eink_display(dev, last_logo_addr, logo_addr, WF_TYPE_GC16, update_mode);
if (priv->backlight)
backlight_enable(priv->backlight);
last_logo_type = cur_logo_type;
if (cur_logo_type == EINK_LOGO_POWEROFF) {
struct udevice *ebc_tcon_dev = priv->ebc_tcon_dev;
struct rk_ebc_tcon_ops *ebc_tcon_ops;
last_logo_type = -1;
/*
* For normal logo display, waiting for the last frame
* completion before start a new frame, except one
* situation which charging logo display finished,
* because device will rebooting or shutdown after
* charging logo is competed.
*
* We should take care of the power sequence,
* because ebc can't power off if last frame
* data is still sending, so keep the ebc power
* during u-boot phase and shutdown the
* power only if uboot charging is finished.
*/
ebc_tcon_ops = ebc_tcon_get_ops(ebc_tcon_dev);
ebc_tcon_ops->wait_for_last_frame_complete(ebc_tcon_dev);
debug("charging logo displaying is complete\n");
/*
*shutdown ebc after charging logo display is complete
*/
ret = ebc_power_set(dev, EBC_PWR_DOWN);
if (ret)
printf("Eink power down failed\n");
goto out;
}
/*
* System will boot up to kernel only when the
* logo is uboot logo
*/
if (cur_logo_type == EINK_LOGO_UBOOT) {
char logo_args[64] = {0};
u32 uboot_logo_buf;
if (plat->mirror || plat->rearrange)
uboot_logo_buf = get_addr_by_type(dev,
EINK_LOGO_UNMIRROR_TEMP_BUF);
else
uboot_logo_buf = logo_addr;
printf("Transmit uboot logo addr(0x%x) to kernel\n",
uboot_logo_buf);
sprintf(logo_args, "ulogo_addr=0x%x", uboot_logo_buf);
env_update("bootargs", logo_args);
ret = read_needed_logo_from_partition(dev, EINK_LOGO_KERNEL,
&loaded_logo);
if (ret || !(loaded_logo & EINK_LOGO_KERNEL)) {
printf("No invalid kernel logo in logo.img\n");
} else {
int klogo_addr = get_addr_by_type(dev,
EINK_LOGO_KERNEL);
if (klogo_addr <= 0) {
printf("get kernel logo buffer failed\n");
ret = -EIO;
goto out;
}
printf("Transmit kernel logo addr(0x%x) to kernel\n",
klogo_addr);
sprintf(logo_args, "klogo_addr=0x%x", klogo_addr);
env_update("bootargs", logo_args);
}
}
out:
return ret;
}
int rockchip_eink_show_uboot_logo(void)
{
return rockchip_eink_show_logo(EINK_LOGO_UBOOT, EINK_UPDATE_DIFF);
}
int rockchip_eink_show_charge_logo(int logo_type)
{
return rockchip_eink_show_logo(logo_type, EINK_UPDATE_DIFF);
}
static int rockchip_eink_display_probe(struct udevice *dev)
{
int ret, vcom, size, i;
const fdt32_t *list;
uint32_t phandle;
struct rockchip_eink_display_priv *priv = dev_get_priv(dev);
/* Before relocation we don't need to do anything */
if (!(gd->flags & GD_FLG_RELOC))
return 0;
ret = uclass_get_device_by_phandle(UCLASS_EBC, dev,
"ebc_tcon",
&priv->ebc_tcon_dev);
if (ret) {
dev_err(dev, "Cannot get ebc_tcon: %d\n", ret);
return ret;
}
list = dev_read_prop(dev, "pmic", &size);
if (!list) {
dev_err(dev, "Cannot get pmic prop\n");
return -EINVAL;
}
size /= sizeof(*list);
for (i = 0; i < size; i++) {
phandle = fdt32_to_cpu(*list++);
ret = uclass_get_device_by_phandle_id(UCLASS_I2C_GENERIC,
phandle,
&priv->ebc_pwr_dev);
if (!ret) {
printf("Eink: use pmic %s\n", priv->ebc_pwr_dev->name);
break;
}
}
if (ret) {
dev_err(dev, "Cannot get pmic: %d\n", ret);
return ret;
}
ret = uclass_get_device_by_phandle(UCLASS_PANEL_BACKLIGHT, dev,
"backlight", &priv->backlight);
if (ret && ret != -ENOENT) {
printf("%s: Cannot get backlight: %d\n", __func__, ret);
}
vcom = read_vcom_from_vendor();
if (vcom <= 0) {
printf("read vcom from vendor failed, use default vcom\n");
priv->vcom = VCOM_DEFAULT_VALUE;
} else {
priv->vcom = vcom;
}
if (priv->ebc_pwr_dev) {
struct rk_ebc_pwr_ops *pwr_ops;
pwr_ops = ebc_pwr_get_ops(priv->ebc_pwr_dev);
ret = pwr_ops->vcom_set(priv->ebc_pwr_dev, priv->vcom);
if (ret) {
printf("%s, vcom_set failed\n", __func__);
return -EIO;
}
}
// read lut to ram, and get lut ops
ret = read_waveform(dev);
if (ret < 0) {
printf("read wavform failed\n");
return -EIO;
}
eink_dev = dev;
return 0;
}
static int rockchip_eink_display_ofdata_to_platdata(struct udevice *dev)
{
fdt_size_t size;
fdt_addr_t tmp_addr;
struct device_node *disp_mem;
struct device_node *waveform_mem;
struct ebc_panel *plat = dev_get_platdata(dev);
plat->width = dev_read_u32_default(dev, "panel,width", 0);
plat->height = dev_read_u32_default(dev, "panel,height", 0);
plat->vir_width = dev_read_u32_default(dev, "panel,vir_width", plat->width);
plat->vir_height = dev_read_u32_default(dev, "panel,vir_height", plat->height);
plat->sdck = dev_read_u32_default(dev, "panel,sdck", 0);
plat->lsl = dev_read_u32_default(dev, "panel,lsl", 0);
plat->lbl = dev_read_u32_default(dev, "panel,lbl", 0);
plat->ldl = dev_read_u32_default(dev, "panel,ldl", 0);
plat->lel = dev_read_u32_default(dev, "panel,lel", 0);
plat->gdck_sta = dev_read_u32_default(dev, "panel,gdck-sta", 0);
plat->lgonl = dev_read_u32_default(dev, "panel,lgonl", 0);
plat->fsl = dev_read_u32_default(dev, "panel,fsl", 0);
plat->fbl = dev_read_u32_default(dev, "panel,fbl", 0);
plat->fdl = dev_read_u32_default(dev, "panel,fdl", 0);
plat->fel = dev_read_u32_default(dev, "panel,fel", 0);
plat->panel_16bit = dev_read_u32_default(dev, "panel,panel_16bit", 0);
plat->panel_color = dev_read_u32_default(dev, "panel,panel_color", 0);
plat->mirror = dev_read_u32_default(dev, "panel,mirror", 0);
plat->rearrange = dev_read_u32_default(dev, "panel,rearrange", 0);
plat->width_mm = dev_read_u32_default(dev, "panel,width-mm", 0);
plat->height_mm = dev_read_u32_default(dev, "panel,height-mm", 0);
disp_mem = of_parse_phandle(ofnode_to_np(dev_ofnode(dev)),
"memory-region", 0);
if (!disp_mem) {
dev_err(dev, "Cannot get memory-region from dts\n");
return -ENODEV;
}
tmp_addr = ofnode_get_addr_size(np_to_ofnode(disp_mem), "reg", &size);
if (tmp_addr == FDT_ADDR_T_NONE) {
printf("get display memory address failed\n");
return -ENODEV;
}
plat->disp_pbuf = (u64)map_sysmem(tmp_addr, 0);
plat->disp_pbuf_size = size;
debug("display mem=0x%x, size=%x\n", plat->disp_pbuf,
plat->disp_pbuf_size);
waveform_mem = of_parse_phandle(ofnode_to_np(dev_ofnode(dev)),
"waveform-region", 0);
if (!waveform_mem) {
printf("Cannot get waveform-region from dts\n");
return -ENODEV;
}
tmp_addr = ofnode_get_addr_size(np_to_ofnode(waveform_mem),
"reg", &size);
if (tmp_addr == FDT_ADDR_T_NONE) {
printf("get waveform memory address failed\n");
return -ENODEV;
}
plat->lut_pbuf = map_sysmem(tmp_addr, 0);
plat->lut_pbuf_size = size;
debug("lut mem=0x%p, size=%x\n", plat->lut_pbuf, plat->lut_pbuf_size);
return 0;
}
static const struct udevice_id rockchip_eink_display_ids[] = {
{ .compatible = "rockchip,ebc-dev", },
{}
};
U_BOOT_DRIVER(rk_eink_display) = {
.name = "rockchip_eink_display",
.id = UCLASS_EINK_DISPLAY,
.of_match = rockchip_eink_display_ids,
.ofdata_to_platdata = rockchip_eink_display_ofdata_to_platdata,
.probe = rockchip_eink_display_probe,
.priv_auto_alloc_size = sizeof(struct rockchip_eink_display_priv),
.platdata_auto_alloc_size = sizeof(struct ebc_panel),
};
UCLASS_DRIVER(rk_eink) = {
.id = UCLASS_EINK_DISPLAY,
.name = "rk_eink",
};
Reference in New Issue View Git Blame Copy Permalink