video/rk_eink/rk_eink_display.c

/*
 * (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",
};