1 /*
2 * (C) Copyright 2020 Rockchip Electronics Co., Ltd
3 *
4 * SPDX-License-Identifier: GPL-2.0+
5 * Author: Wenping Zhang <wenping.zhang@rock-chips.com>
6 */
7 #include <common.h>
8 #include <dm.h>
9 #include <stdio.h>
10 #include <errno.h>
11 #include <mapmem.h>
12 #include <stdlib.h>
13 #include <asm/arch/vendor.h>
14 #include <dm/device-internal.h>
15 #include <dm/of_access.h>
16 #include <dm/uclass.h>
17 #include <dm/uclass-id.h>
18 #include <boot_rkimg.h>
19 #include <rk_eink.h>
20 #include <backlight.h>
21 #include <power/regulator.h>
22 #include <thermal.h>
23 #include "rk_ebc.h"
24 #include "epdlut/epd_lut.h"
25
26 #if !CONFIG_IS_ENABLED(DM_THERMAL)
thermal_get_temp(struct udevice * dev,int * temp)27 inline int thermal_get_temp(struct udevice *dev, int *temp)
28 {
29 return 0;
30 }
31 #endif
32
33 #define PART_WAVEFORM "waveform"
34 #define EINK_LOGO_PART_MAGIC "RKEL"
35 #define EINK_LOGO_IMAGE_MAGIC "GR04"
36 /*
37 * grayscale logo partition format:
38 * block0:
39 * struct logo_part_header part_header;
40 * struct grayscale_header logo1_header;
41 * struct grayscale_header logo2_header;
42 * struct grayscale_header logo3_header;
43 * struct grayscale_header logo4_header;
44 * ....
45 *
46 * block 1:
47 * logo1_image
48 *
49 * .....
50 * block m:
51 * logo2_image
52 *
53 * ........
54 * block n:
55 * logo3_image
56 *
57 * ........
58 * block i:
59 * logoi_image
60 */
61
62 //logo partition Header, 64byte
63 struct logo_part_header {
64 char magic[4]; /* must be "RKEL" */
65 u32 totoal_size;
66 u32 screen_width;
67 u32 screen_height;
68 u32 logo_count;
69 u8 version[4];
70 u32 rsv[10];
71 } __packed;
72
73 // logo image header,32 byte
74 struct grayscale_header {
75 char magic[4]; /* must be "GR04" */
76 u16 x;
77 u16 y;
78 u16 w;
79 u16 h;
80 u32 logo_type;
81 u32 data_offset; /* image offset in byte */
82 u32 data_size; /* image size in byte */
83 u32 rsv[2];
84 } __packed;
85
86 /*
87 * The start address of logo image in logo.img must be aligned in 512 bytes,
88 * so the header size must be times of 512 bytes. Here we fix the size to 512
89 * bytes, so the count of logo image can only support up to 14.
90 */
91 struct logo_info {
92 struct logo_part_header part_hdr;
93 struct grayscale_header img_hdr[14];
94 } __packed;
95
96 struct rockchip_eink_display_priv {
97 struct udevice *dev;
98 struct udevice *ebc_tcon_dev;
99 struct udevice *ebc_pwr_dev;
100 struct udevice *regulator_dev;
101 struct udevice *thermal_dev;
102 int vcom;
103 struct udevice *backlight;
104 };
105
106 enum {
107 EBC_PWR_DOWN = 0,
108 EBC_PWR_ON = 1,
109 };
110
111 #define EINK_VCOM_ID 17
112 #define EINK_VCOM_MAX 64
113 #define VCOM_DEFAULT_VALUE 1650
114
115 static struct logo_info eink_logo_info;
116 static struct udevice *eink_dev;
117 static volatile int last_logo_type = -1;
read_vcom_from_vendor(void)118 static int read_vcom_from_vendor(void)
119 {
120 int ret = 0;
121 char vcom_str[EINK_VCOM_MAX] = {0};
122 char vcom_args[EINK_VCOM_MAX] = {0};
123
124 /* Read vcom value from vendor storage part */
125 ret = vendor_storage_read(EINK_VCOM_ID, vcom_str, (EINK_VCOM_MAX - 1));
126 if (ret > 0) {
127 snprintf(vcom_args, strlen(vcom_str) + 15, "ebc_pmic.vcom=%s", vcom_str);
128 printf("eink update bootargs: %s\n", vcom_args);
129 env_update("bootargs", vcom_args);
130 } else {
131 return ret;
132 }
133
134 return atoi(vcom_str);
135 }
136
read_waveform(struct udevice * dev)137 static int read_waveform(struct udevice *dev)
138 {
139 int cnt, start, ret;
140 disk_partition_t part;
141 struct blk_desc *dev_desc;
142 struct ebc_panel *plat = dev_get_platdata(dev);
143
144 dev_desc = rockchip_get_bootdev();
145 if (!dev_desc) {
146 printf("%s: Could not find device\n", __func__);
147 return -EIO;
148 }
149 if (part_get_info_by_name(dev_desc, PART_WAVEFORM, &part) < 0) {
150 printf("Get waveform partition failed\n");
151 return -ENODEV;
152 }
153 cnt = plat->lut_pbuf_size / RK_BLK_SIZE;
154 start = part.start;
155 ret = blk_dread(dev_desc, start, cnt, (void *)plat->lut_pbuf);
156 if (ret != cnt)
157 printf("Try to read %d blocks failed, only read %d\n",
158 cnt, ret);
159
160 flush_dcache_range((ulong)plat->lut_pbuf,
161 ALIGN((ulong)plat->lut_pbuf + cnt,
162 CONFIG_SYS_CACHELINE_SIZE));
163 ret = epd_lut_from_mem_init(plat->lut_pbuf);
164 if (ret < 0) {
165 printf("lut init failed\n");
166 return -EINVAL;
167 }
168
169 return 0;
170 }
171
aligned_image_size_4k(struct udevice * dev)172 static u32 aligned_image_size_4k(struct udevice *dev)
173 {
174 struct ebc_panel *plat = dev_get_platdata(dev);
175 u32 w = plat->width;
176 u32 h = plat->height;
177
178 return ALIGN((w * h) >> 1, 4096);
179 }
180
181 /*
182 * This driver load the grayscale image from flash,
183 * and put it in the reserve memory which define in dts:
184 * display_reserved: framebuffer@10000000 {
185 * reg = <0x0 0x10000000 0x0 0x2000000>;
186 * no-map;
187 * };
188 * Every image logo size must be aligned in 4K, make sure
189 * kernel can use it rightly, the buffer of LOGO image is
190 * put in order of below map:
191 * |---reset logo ---|
192 * |---uboot logo ---|
193 * |---kernel logo ---|
194 * |---charge_0 logo ---|
195 * |---charge_1 logo ---|
196 * |---charge_2 logo ---|
197 * |---charge_3 logo ---|
198 * |---charge_4 logo ---|
199 * |---charge_5 logo ---|
200 * |---battery low logo---|
201 * |---temp un-mirror buffer--|
202 */
get_addr_by_type(struct udevice * dev,u32 logo_type)203 static int get_addr_by_type(struct udevice *dev, u32 logo_type)
204 {
205 u32 offset, indx, img_size;
206 struct ebc_panel *plat = dev_get_platdata(dev);
207
208 if (plat->disp_pbuf_size == 0 || !plat->disp_pbuf) {
209 printf("invalid display buffer, please check dts\n");
210 return -EINVAL;
211 }
212 indx = ffs(logo_type);
213 img_size = aligned_image_size_4k(dev);
214 offset = img_size * indx;
215 if (offset + img_size > plat->disp_pbuf_size) {
216 printf("reserve display memory size is not enough\n");
217 return -EINVAL;
218 }
219
220 switch (logo_type) {
221 case EINK_LOGO_RESET:
222 case EINK_LOGO_UBOOT:
223 case EINK_LOGO_KERNEL:
224 case EINK_LOGO_CHARGING_0:
225 case EINK_LOGO_CHARGING_1:
226 case EINK_LOGO_CHARGING_2:
227 case EINK_LOGO_CHARGING_3:
228 case EINK_LOGO_CHARGING_4:
229 case EINK_LOGO_CHARGING_5:
230 case EINK_LOGO_CHARGING_LOWPOWER:
231 case EINK_LOGO_POWEROFF:
232 /*
233 * The MIRROR_TEMP_BUF is used to save the
234 * non-mirror image data.
235 */
236 case EINK_LOGO_UNMIRROR_TEMP_BUF:
237 return (plat->disp_pbuf + offset);
238 default:
239 printf("invalid logo type[%d]\n", logo_type);
240 }
241
242 return -EINVAL;
243 }
244
read_header(struct blk_desc * dev_desc,disk_partition_t * part,struct logo_info * header)245 static int read_header(struct blk_desc *dev_desc,
246 disk_partition_t *part,
247 struct logo_info *header)
248 {
249 int i;
250 struct logo_part_header *part_hdr = &header->part_hdr;
251
252 if (blk_dread(dev_desc, part->start, 1, header) != 1)
253 return -EIO;
254
255 if (memcmp(part_hdr->magic, EINK_LOGO_PART_MAGIC, 4)) {
256 printf("partition header is invalid\n");
257 return -EINVAL;
258 }
259 if (part_hdr->logo_count == 0) {
260 printf("the count of logo image is 0\n");
261 return -EINVAL;
262 }
263 for (i = 0; i < part_hdr->logo_count; i++) {
264 struct grayscale_header *img_hdr = &header->img_hdr[i];
265
266 if (memcmp(img_hdr->magic, EINK_LOGO_IMAGE_MAGIC, 4)) {
267 printf("image[%d] header '%s' is invalid\n", i,
268 img_hdr->magic);
269 return -EINVAL;
270 }
271 }
272
273 return 0;
274 }
275
read_grayscale(struct blk_desc * dev_desc,disk_partition_t * part,u32 offset,u32 size,void * buf)276 static int read_grayscale(struct blk_desc *dev_desc,
277 disk_partition_t *part, u32 offset,
278 u32 size, void *buf)
279 {
280 u32 blk_start, blk_offset, blk_count;
281
282 blk_offset = DIV_ROUND_UP(offset, dev_desc->blksz);
283 blk_start = part->start + blk_offset;
284 blk_count = DIV_ROUND_UP(size, dev_desc->blksz);
285
286 debug("blk_offset=%d, blk_start=%d,blk_count=%d,out buf=%p\n",
287 blk_offset, blk_start, blk_count, buf);
288 if (blk_dread(dev_desc, blk_start, blk_count, buf) != blk_count) {
289 printf("read grayscale data failed\n");
290 return -EIO;
291 }
292
293 return 0;
294 }
295
image_rearrange(u8 * in_buf,u8 * out_buf,u16 w,u16 h)296 static int image_rearrange(u8 *in_buf, u8 *out_buf, u16 w, u16 h)
297 {
298 int i, j;
299 u8 in_data;
300 u8 *out_buf_tmp;
301
302 if (!in_buf || !out_buf) {
303 printf("rearrange in buffer or out buffer is NULL\n");
304 return -EINVAL;
305 }
306
307 for (i = 0; i < h; i += 2) {
308 out_buf_tmp = out_buf + (i * w / 2);
309 for (j = 0; j < w / 2; j++) {
310 in_data = *in_buf++;
311 *(out_buf_tmp + j * 2) = in_data & 0x0f;
312 *(out_buf_tmp + j * 2 + 1) = (in_data >> 4) & 0x0f;
313 }
314 for (j = 0; j < w / 2; j++) {
315 in_data = *in_buf++;
316 *(out_buf_tmp + j * 2) |= (in_data << 4) & 0xf0;
317 *(out_buf_tmp + j * 2 + 1) |= in_data & 0xf0;
318 }
319 }
320
321 return 0;
322 }
323
image_mirror(u8 * in_buf,u8 * out_buf,u16 w,u16 h)324 static int image_mirror(u8 *in_buf, u8 *out_buf, u16 w, u16 h)
325 {
326 int i;
327
328 if (!in_buf || !out_buf) {
329 printf("mirror in buffer or out buffer is NULL\n");
330 return -EINVAL;
331 }
332
333 for (i = 0; i < h; i++) {
334 u16 column_len = w / 2;
335 u8 *column_in = in_buf + i * column_len;
336 u8 *column_out = out_buf + (h - i - 1) * column_len;
337
338 memcpy(column_out, column_in, column_len);
339 }
340
341 return 0;
342 }
343
344 /*
345 * The eink kernel driver need last frame to do part refresh,
346 * so we need to transfer two images to kernel, which is kernel
347 * logo and the logo displayed in uboot.
348 *
349 * this function use logo type bitmap to indicate several logo.
350 * u32 needed_logo: we only load needed logo image into ram, such as
351 * uboot logo + kernel logo or charger logo + kernel
352 * logo
353 * u32 *loaded_logo: because the needed logo may not exist in logo.img,
354 * store the really loaded logo in para loaded_logo.
355 */
read_needed_logo_from_partition(struct udevice * dev,u32 needed_logo,u32 * loaded_logo)356 static int read_needed_logo_from_partition(struct udevice *dev,
357 u32 needed_logo,
358 u32 *loaded_logo)
359 {
360 int ret, i;
361 disk_partition_t part;
362 struct blk_desc *dev_desc;
363 struct logo_info *hdr = &eink_logo_info;
364 struct logo_part_header *part_hdr = &hdr->part_hdr;
365 struct ebc_panel *panel = dev_get_platdata(dev);
366 u32 logo = needed_logo & (~(*loaded_logo));
367
368 if (!logo) {
369 printf("logo[0x%x] is already loaded, just return!\n",
370 needed_logo);
371 return 0;
372 }
373 dev_desc = rockchip_get_bootdev();
374 if (!dev_desc) {
375 printf("%s: Could not find device\n", __func__);
376 return -EIO;
377 }
378
379 if (part_get_info_by_name(dev_desc, PART_LOGO, &part) < 0)
380 return -ENODEV;
381
382 ret = read_header(dev_desc, &part, hdr);
383 if (ret < 0) {
384 printf("eink logo read header failed,ret = %d\n", ret);
385 return -EINVAL;
386 }
387 if (part_hdr->screen_width != panel->width ||
388 part_hdr->screen_height != panel->height){
389 printf("logo size(%dx%d) is not same as screen size(%dx%d)\n",
390 part_hdr->screen_width, part_hdr->screen_height,
391 panel->width, panel->height);
392 return -EINVAL;
393 }
394
395 for (i = 0; i < part_hdr->logo_count; i++) {
396 struct grayscale_header *img_hdr = &hdr->img_hdr[i];
397 int pic_buf;
398 u32 offset = img_hdr->data_offset;
399 u32 size = img_hdr->data_size;
400 u32 logo_type = img_hdr->logo_type;
401
402 debug("offset=0x%x, size=%d,logo_type=%d,w=%d,h=%d\n",
403 offset, size, logo_type, img_hdr->w, img_hdr->h);
404
405 if (logo & logo_type) {
406 pic_buf = get_addr_by_type(dev, logo_type);
407
408 if (pic_buf <= 0) {
409 printf("Get buffer failed for image %d\n",
410 img_hdr->logo_type);
411 return -EIO;
412 }
413 if (!IS_ALIGNED((ulong)pic_buf,
414 ARCH_DMA_MINALIGN)) {
415 printf("disp buffer is not dma aligned\n");
416 return -EINVAL;
417 }
418 /*
419 * kernel logo is transmitted to kernel to display, and
420 * kernel will do the mirror operation, so skip kernel
421 * logo here.
422 */
423 if (panel->mirror && logo_type != EINK_LOGO_KERNEL) {
424 u32 w = panel->width;
425 u32 h = panel->height;
426 u32 mirror_buf = 0;
427
428 mirror_buf = get_addr_by_type(dev,
429 EINK_LOGO_UNMIRROR_TEMP_BUF);
430 if (mirror_buf <= 0) {
431 printf("get mirror buffer failed\n");
432 return -EIO;
433 }
434 read_grayscale(dev_desc, &part, offset, size,
435 (void *)((ulong)mirror_buf));
436 image_mirror((u8 *)((ulong)mirror_buf),
437 (u8 *)((ulong)pic_buf), w, h);
438 } else if (panel->rearrange && logo_type != EINK_LOGO_KERNEL) {
439 u32 w = panel->width;
440 u32 h = panel->height;
441 u32 rearrange_buf = 0;
442
443 rearrange_buf = get_addr_by_type(dev,
444 EINK_LOGO_UNMIRROR_TEMP_BUF);
445 if (rearrange_buf <= 0) {
446 printf("get mirror buffer failed\n");
447 return -EIO;
448 }
449 read_grayscale(dev_desc, &part, offset, size,
450 (void *)((ulong)rearrange_buf));
451 image_rearrange((u8 *)((ulong)rearrange_buf),
452 (u8 *)((ulong)pic_buf), w, h);
453 } else {
454 read_grayscale(dev_desc, &part, offset, size,
455 (void *)((ulong)pic_buf));
456 }
457 flush_dcache_range((ulong)pic_buf,
458 ALIGN((ulong)pic_buf + size,
459 CONFIG_SYS_CACHELINE_SIZE));
460 *loaded_logo |= logo_type;
461
462 logo &= ~logo_type;
463 if (!logo)
464 break;
465 }
466 }
467
468 return 0;
469 }
470
ebc_power_set(struct udevice * dev,int is_on)471 static int ebc_power_set(struct udevice *dev, int is_on)
472 {
473 int ret;
474 struct rockchip_eink_display_priv *priv = dev_get_priv(dev);
475 struct ebc_panel *panel = dev_get_platdata(dev);
476 struct udevice *ebc_tcon_dev = priv->ebc_tcon_dev;
477 struct rk_ebc_tcon_ops *ebc_tcon_ops = ebc_tcon_get_ops(ebc_tcon_dev);
478 struct udevice *ebc_pwr_dev = priv->ebc_pwr_dev;
479 struct rk_ebc_pwr_ops *pwr_ops = NULL;
480
481 if (ebc_pwr_dev)
482 pwr_ops = ebc_pwr_get_ops(ebc_pwr_dev);
483
484 if (is_on) {
485 if (pwr_ops)
486 ret = pwr_ops->power_on(ebc_pwr_dev);
487 else
488 ret = regulator_set_enable(priv->regulator_dev, true);
489 if (ret) {
490 printf("%s, power on failed\n", __func__);
491 return -1;
492 }
493 ret = ebc_tcon_ops->enable(ebc_tcon_dev, panel);
494 if (ret) {
495 printf("%s, ebc tcon enabled failed\n", __func__);
496 return -1;
497 }
498 } else {
499 ret = ebc_tcon_ops->disable(ebc_tcon_dev);
500 if (ret) {
501 printf("%s, ebc tcon disable failed\n", __func__);
502 return -1;
503 }
504
505 if (pwr_ops)
506 ret = pwr_ops->power_down(ebc_pwr_dev);
507 else
508 ret = regulator_set_enable(priv->regulator_dev, false);
509 if (ret) {
510 printf("%s, power_down failed\n", __func__);
511 return -1;
512 }
513 }
514 return 0;
515 }
516
eink_display(struct udevice * dev,u32 pre_img_buf,u32 cur_img_buf,u32 lut_type,int update_mode)517 static int eink_display(struct udevice *dev, u32 pre_img_buf,
518 u32 cur_img_buf, u32 lut_type, int update_mode)
519 {
520 int temperature;
521 u32 frame_num;
522 struct rockchip_eink_display_priv *priv = dev_get_priv(dev);
523 struct ebc_panel *plat = dev_get_platdata(dev);
524 struct udevice *ebc_pwr_dev = priv->ebc_pwr_dev;
525 struct rk_ebc_pwr_ops *pwr_ops = NULL;
526 struct udevice *ebc_tcon_dev = priv->ebc_tcon_dev;
527 struct rk_ebc_tcon_ops *ebc_tcon_ops = ebc_tcon_get_ops(ebc_tcon_dev);
528
529 if (ebc_pwr_dev)
530 pwr_ops = ebc_pwr_get_ops(ebc_pwr_dev);
531
532 if (pwr_ops)
533 pwr_ops->temp_get(ebc_pwr_dev, (u32 *)(&temperature));
534 else
535 thermal_get_temp(priv->thermal_dev, &temperature);
536 if (temperature <= 0 || temperature > 50) {
537 printf("temperature = %d, out of range0~50 ,use 25\n",
538 temperature);
539 temperature = 25;
540 }
541
542 if(!plat->lut_data.wf_table[0])
543 plat->lut_data.wf_table[0] = kzalloc(MAXFRAME * 32 * 32, GFP_KERNEL);
544 epd_lut_get(&plat->lut_data, lut_type, temperature, WF_4BIT, 0);
545 kfree(plat->lut_data.wf_table[0]);
546 plat->lut_data.wf_table[0] = NULL;
547
548 frame_num = plat->lut_data.frame_num & 0xff;
549 printk("lut_type=%d, frame num=%d, temp=%d\n", lut_type,
550 frame_num, temperature);
551
552 ebc_tcon_ops->wait_for_last_frame_complete(ebc_tcon_dev);
553 ebc_tcon_ops->lut_data_set(ebc_tcon_dev, plat->lut_data.data,
554 frame_num, 0);
555 ebc_tcon_ops->dsp_mode_set(ebc_tcon_dev, update_mode,
556 LUT_MODE, !THREE_WIN_MODE, !EINK_MODE);
557 ebc_tcon_ops->image_addr_set(ebc_tcon_dev, pre_img_buf, cur_img_buf);
558 ebc_tcon_ops->frame_start(ebc_tcon_dev, frame_num);
559 return 0;
560 }
561
rk_eink_display_init(void)562 static int rk_eink_display_init(void)
563 {
564 int ret;
565 struct uclass *uc;
566 struct udevice *dev;
567
568 if (eink_dev) {
569 printf("ebc-dev is already initialized!\n");
570 return 0;
571 }
572
573 ret = uclass_get(UCLASS_EINK_DISPLAY, &uc);
574 if (ret) {
575 printf("can't find uclass eink\n");
576 return -ENODEV;
577 }
578 for (uclass_first_device(UCLASS_EINK_DISPLAY, &dev);
579 dev; uclass_next_device(&dev))
580 ;
581
582 if (eink_dev) {
583 printf("ebc-dev is probed success!\n");
584 return 0;
585 }
586 printf("Can't find ebc-dev\n");
587 return -ENODEV;
588 }
589
590 /*
591 * Eink display need current and previous image buffer, We assume
592 * every type of logo has only one image, so just tell this function
593 * last logo type and current logo type, it will find the right images.
594 * last_logo_type: -1 means it's first displaying.
595 */
rockchip_eink_show_logo(int cur_logo_type,int update_mode)596 static int rockchip_eink_show_logo(int cur_logo_type, int update_mode)
597 {
598 int ret = 0;
599 u32 logo_addr;
600 u32 last_logo_addr;
601 struct ebc_panel *plat;
602 struct udevice *dev;
603 static u32 loaded_logo = 0;
604 struct rockchip_eink_display_priv *priv;
605
606 if (!eink_dev) {
607 static bool first_init = true;
608
609 if (first_init) {
610 first_init = false;
611 ret = rk_eink_display_init();
612 if (ret) {
613 printf("Get ebc dev failed, check dts\n");
614 return -ENODEV;
615 }
616 } else {
617 return -ENODEV;
618 }
619 }
620 dev = eink_dev;
621
622 /*Don't need to update display*/
623 if (last_logo_type == cur_logo_type) {
624 debug("Same as last picture, Don't need to display\n");
625 return 0;
626 }
627
628 plat = dev_get_platdata(dev);
629 priv = dev_get_priv(dev);
630
631 /*
632 * The last_logo_type is -1 means it's first displaying
633 */
634 if (last_logo_type == -1) {
635 ret = ebc_power_set(dev, EBC_PWR_ON);
636 if (ret) {
637 printf("Eink power on failed\n");
638 return -1;
639 }
640
641 int size = (plat->width * plat->height) >> 1;
642
643 logo_addr = get_addr_by_type(dev, EINK_LOGO_RESET);
644 memset((u32 *)(u64)logo_addr, 0xff, size);
645 flush_dcache_range((ulong)logo_addr,
646 ALIGN((ulong)logo_addr + size,
647 CONFIG_SYS_CACHELINE_SIZE));
648 eink_display(dev, logo_addr, logo_addr,
649 WF_TYPE_RESET, EINK_LOGO_RESET);
650 last_logo_type = 0;
651 last_logo_addr = logo_addr;
652 } else {
653 last_logo_addr = get_addr_by_type(dev, last_logo_type);
654 if (last_logo_addr < 0) {
655 printf("Invalid last logo addr, exit!\n");
656 goto out;
657 }
658 }
659 ret = read_needed_logo_from_partition(dev, cur_logo_type,
660 &loaded_logo);
661 if (ret || !(loaded_logo & cur_logo_type)) {
662 printf("read logo[0x%x] failed, loaded_logo=0x%x\n",
663 cur_logo_type, loaded_logo);
664 ret = -EIO;
665 goto out;
666 }
667 logo_addr = get_addr_by_type(dev, cur_logo_type);
668 debug("logo_addr=%x, logo_type=%d\n", logo_addr, cur_logo_type);
669 if (logo_addr <= 0) {
670 printf("get logo buffer failed\n");
671 ret = -EIO;
672 goto out;
673 }
674
675 eink_display(dev, last_logo_addr, logo_addr, WF_TYPE_GC16, update_mode);
676
677 if (priv->backlight)
678 backlight_enable(priv->backlight);
679
680 last_logo_type = cur_logo_type;
681
682 if (cur_logo_type == EINK_LOGO_POWEROFF) {
683 struct udevice *ebc_tcon_dev = priv->ebc_tcon_dev;
684 struct rk_ebc_tcon_ops *ebc_tcon_ops;
685
686 last_logo_type = -1;
687 /*
688 * For normal logo display, waiting for the last frame
689 * completion before start a new frame, except one
690 * situation which charging logo display finished,
691 * because device will rebooting or shutdown after
692 * charging logo is competed.
693 *
694 * We should take care of the power sequence,
695 * because ebc can't power off if last frame
696 * data is still sending, so keep the ebc power
697 * during u-boot phase and shutdown the
698 * power only if uboot charging is finished.
699 */
700 ebc_tcon_ops = ebc_tcon_get_ops(ebc_tcon_dev);
701 ebc_tcon_ops->wait_for_last_frame_complete(ebc_tcon_dev);
702 debug("charging logo displaying is complete\n");
703 /*
704 *shutdown ebc after charging logo display is complete
705 */
706 ret = ebc_power_set(dev, EBC_PWR_DOWN);
707 if (ret)
708 printf("Eink power down failed\n");
709 goto out;
710 }
711
712 /*
713 * System will boot up to kernel only when the
714 * logo is uboot logo
715 */
716 if (cur_logo_type == EINK_LOGO_UBOOT) {
717 char logo_args[64] = {0};
718 u32 uboot_logo_buf;
719
720 if (plat->mirror || plat->rearrange)
721 uboot_logo_buf = get_addr_by_type(dev,
722 EINK_LOGO_UNMIRROR_TEMP_BUF);
723 else
724 uboot_logo_buf = logo_addr;
725 printf("Transmit uboot logo addr(0x%x) to kernel\n",
726 uboot_logo_buf);
727 sprintf(logo_args, "ulogo_addr=0x%x", uboot_logo_buf);
728 env_update("bootargs", logo_args);
729 ret = read_needed_logo_from_partition(dev, EINK_LOGO_KERNEL,
730 &loaded_logo);
731 if (ret || !(loaded_logo & EINK_LOGO_KERNEL)) {
732 printf("No invalid kernel logo in logo.img\n");
733 } else {
734 int klogo_addr = get_addr_by_type(dev,
735 EINK_LOGO_KERNEL);
736
737 if (klogo_addr <= 0) {
738 printf("get kernel logo buffer failed\n");
739 ret = -EIO;
740 goto out;
741 }
742 printf("Transmit kernel logo addr(0x%x) to kernel\n",
743 klogo_addr);
744 sprintf(logo_args, "klogo_addr=0x%x", klogo_addr);
745 env_update("bootargs", logo_args);
746 }
747 }
748
749 out:
750 return ret;
751 }
752
rockchip_eink_show_uboot_logo(void)753 int rockchip_eink_show_uboot_logo(void)
754 {
755 return rockchip_eink_show_logo(EINK_LOGO_UBOOT, EINK_UPDATE_DIFF);
756 }
757
rockchip_eink_show_charge_logo(int logo_type)758 int rockchip_eink_show_charge_logo(int logo_type)
759 {
760 return rockchip_eink_show_logo(logo_type, EINK_UPDATE_DIFF);
761 }
762
rockchip_eink_display_probe(struct udevice * dev)763 static int rockchip_eink_display_probe(struct udevice *dev)
764 {
765 struct rockchip_eink_display_priv *priv = dev_get_priv(dev);
766 struct dm_regulator_uclass_platdata *uc_pdata;
767 struct rk_ebc_pwr_ops *pwr_ops = NULL;
768 struct udevice *child, *pmic_dev;
769 int ret, vcom, size, i, uclass_id;
770 bool find_pmic = false;
771 const fdt32_t *list;
772 uint32_t phandle;
773
774 /* Before relocation we don't need to do anything */
775 if (!(gd->flags & GD_FLG_RELOC))
776 return 0;
777
778 ret = uclass_get_device_by_phandle(UCLASS_EBC, dev,
779 "ebc_tcon",
780 &priv->ebc_tcon_dev);
781 if (ret) {
782 dev_err(dev, "Cannot get ebc_tcon: %d\n", ret);
783 return ret;
784 }
785
786 list = dev_read_prop(dev, "pmic", &size);
787 if (!list) {
788 dev_err(dev, "Cannot get pmic prop\n");
789 return -EINVAL;
790 }
791
792 size /= sizeof(*list);
793 for (i = 0; i < size; i++) {
794 phandle = fdt32_to_cpu(*list++);
795 /* TODO: migrate to pmic */
796 ret = uclass_get_device_by_phandle_id(UCLASS_I2C_GENERIC,
797 phandle,
798 &priv->ebc_pwr_dev);
799 if (!ret) {
800 find_pmic = true;
801 break;
802 }
803
804 ret = uclass_get_device_by_phandle_id(UCLASS_PMIC, phandle, &pmic_dev);
805 if (!ret) {
806 for (device_find_first_child(pmic_dev, &child); child;
807 device_find_next_child(&child)) {
808 uclass_id = device_get_uclass_id(child);
809 ret = device_probe(child);
810 if (ret) {
811 dev_warn(dev, "Failed to probe pmic %s\n", child->name);
812 continue;
813 }
814
815 if (uclass_id == UCLASS_REGULATOR) {
816 uc_pdata = dev_get_uclass_platdata(child);
817 if (!strcmp(uc_pdata->name, "vcom"))
818 priv->regulator_dev = child;
819 } else if (uclass_id == UCLASS_THERMAL) {
820 priv->thermal_dev = child;
821 }
822 }
823
824 find_pmic = true;
825 break;
826 }
827 }
828
829 if (!find_pmic) {
830 dev_err(dev, "Cannot get pmic: %d\n", ret);
831 return ret;
832 }
833
834 ret = uclass_get_device_by_phandle(UCLASS_PANEL_BACKLIGHT, dev,
835 "backlight", &priv->backlight);
836 if (ret && ret != -ENOENT) {
837 printf("%s: Cannot get backlight: %d\n", __func__, ret);
838 }
839
840 vcom = read_vcom_from_vendor();
841 if (vcom <= 0) {
842 printf("read vcom from vendor failed, use default vcom\n");
843 priv->vcom = VCOM_DEFAULT_VALUE;
844 } else {
845 priv->vcom = vcom;
846 }
847
848 if (priv->ebc_pwr_dev)
849 pwr_ops = ebc_pwr_get_ops(priv->ebc_pwr_dev);
850
851 if (priv->ebc_pwr_dev)
852 ret = pwr_ops->vcom_set(priv->ebc_pwr_dev, priv->vcom);
853 else
854 ret = regulator_set_value(priv->regulator_dev, priv->vcom * 1000);
855 if (ret) {
856 printf("%s, vcom_set failed\n", __func__);
857 return -EIO;
858 }
859
860 // read lut to ram, and get lut ops
861 ret = read_waveform(dev);
862 if (ret < 0) {
863 printf("read wavform failed\n");
864 return -EIO;
865 }
866
867 eink_dev = dev;
868
869 return 0;
870 }
871
rockchip_eink_display_ofdata_to_platdata(struct udevice * dev)872 static int rockchip_eink_display_ofdata_to_platdata(struct udevice *dev)
873 {
874 fdt_size_t size;
875 fdt_addr_t tmp_addr;
876 struct device_node *disp_mem;
877 struct device_node *waveform_mem;
878 struct ebc_panel *plat = dev_get_platdata(dev);
879 void * data;
880 int len;
881
882 data = (void *)dev_read_prop(dev, "wf,mode_table", &len);
883 if (len > 0 && pvi_wf_add_custom_mode_table(data, len))
884 return -ENODEV;
885
886 plat->width = dev_read_u32_default(dev, "panel,width", 0);
887 plat->height = dev_read_u32_default(dev, "panel,height", 0);
888 plat->vir_width = dev_read_u32_default(dev, "panel,vir_width", plat->width);
889 plat->vir_height = dev_read_u32_default(dev, "panel,vir_height", plat->height);
890 plat->sdck = dev_read_u32_default(dev, "panel,sdck", 0);
891 plat->lsl = dev_read_u32_default(dev, "panel,lsl", 0);
892 plat->lbl = dev_read_u32_default(dev, "panel,lbl", 0);
893 plat->ldl = dev_read_u32_default(dev, "panel,ldl", 0);
894 plat->lel = dev_read_u32_default(dev, "panel,lel", 0);
895 plat->gdck_sta = dev_read_u32_default(dev, "panel,gdck-sta", 0);
896 plat->lgonl = dev_read_u32_default(dev, "panel,lgonl", 0);
897 plat->fsl = dev_read_u32_default(dev, "panel,fsl", 0);
898 plat->fbl = dev_read_u32_default(dev, "panel,fbl", 0);
899 plat->fdl = dev_read_u32_default(dev, "panel,fdl", 0);
900 plat->fel = dev_read_u32_default(dev, "panel,fel", 0);
901 plat->panel_16bit = dev_read_u32_default(dev, "panel,panel_16bit", 0);
902 plat->panel_color = dev_read_u32_default(dev, "panel,panel_color", 0);
903 plat->mirror = dev_read_u32_default(dev, "panel,mirror", 0);
904 plat->rearrange = dev_read_u32_default(dev, "panel,rearrange", 0);
905 plat->width_mm = dev_read_u32_default(dev, "panel,width-mm", 0);
906 plat->height_mm = dev_read_u32_default(dev, "panel,height-mm", 0);
907 plat->sdce_width = dev_read_u32_default(dev, "panel,sdce_width", 0);
908 plat->sdoe_mode = dev_read_u32_default(dev, "panel,sdoe_mode", 0);
909
910 disp_mem = of_parse_phandle(ofnode_to_np(dev_ofnode(dev)),
911 "memory-region", 0);
912 if (!disp_mem) {
913 dev_err(dev, "Cannot get memory-region from dts\n");
914 return -ENODEV;
915 }
916 tmp_addr = ofnode_get_addr_size(np_to_ofnode(disp_mem), "reg", &size);
917 if (tmp_addr == FDT_ADDR_T_NONE) {
918 printf("get display memory address failed\n");
919 return -ENODEV;
920 }
921
922 plat->disp_pbuf = (u64)map_sysmem(tmp_addr, 0);
923 plat->disp_pbuf_size = size;
924 debug("display mem=0x%x, size=%x\n", plat->disp_pbuf,
925 plat->disp_pbuf_size);
926 waveform_mem = of_parse_phandle(ofnode_to_np(dev_ofnode(dev)),
927 "waveform-region", 0);
928 if (!waveform_mem) {
929 printf("Cannot get waveform-region from dts\n");
930 return -ENODEV;
931 }
932 tmp_addr = ofnode_get_addr_size(np_to_ofnode(waveform_mem),
933 "reg", &size);
934 if (tmp_addr == FDT_ADDR_T_NONE) {
935 printf("get waveform memory address failed\n");
936 return -ENODEV;
937 }
938
939 plat->lut_pbuf = map_sysmem(tmp_addr, 0);
940 plat->lut_pbuf_size = size;
941 debug("lut mem=0x%p, size=%x\n", plat->lut_pbuf, plat->lut_pbuf_size);
942 return 0;
943 }
944
945 static const struct udevice_id rockchip_eink_display_ids[] = {
946 { .compatible = "rockchip,ebc-dev", },
947 {}
948 };
949
950 U_BOOT_DRIVER(rk_eink_display) = {
951 .name = "rockchip_eink_display",
952 .id = UCLASS_EINK_DISPLAY,
953 .of_match = rockchip_eink_display_ids,
954 .ofdata_to_platdata = rockchip_eink_display_ofdata_to_platdata,
955 .probe = rockchip_eink_display_probe,
956 .priv_auto_alloc_size = sizeof(struct rockchip_eink_display_priv),
957 .platdata_auto_alloc_size = sizeof(struct ebc_panel),
958 };
959
960 UCLASS_DRIVER(rk_eink) = {
961 .id = UCLASS_EINK_DISPLAY,
962 .name = "rk_eink",
963 };
964
965