1 /* 2 * (C) Copyright 2017 Rockchip Electronics Co., Ltd 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 #include <asm/io.h> 8 #include <common.h> 9 #include <boot_rkimg.h> 10 #include <console.h> 11 #include <dm.h> 12 #include <errno.h> 13 #include <key.h> 14 #include <led.h> 15 #include <rtc.h> 16 #include <pwm.h> 17 #include <asm/arch/rockchip_smccc.h> 18 #include <asm/suspend.h> 19 #include <linux/input.h> 20 #include <power/charge_display.h> 21 #include <power/charge_animation.h> 22 #include <power/rockchip_pm.h> 23 #include <power/fuel_gauge.h> 24 #include <power/pmic.h> 25 #include <power/rk8xx_pmic.h> 26 #include <power/regulator.h> 27 #include <video_rockchip.h> 28 #ifdef CONFIG_IRQ 29 #include <irq-generic.h> 30 #include <rk_timer_irq.h> 31 #endif 32 #ifdef CONFIG_ROCKCHIP_EINK_DISPLAY 33 #include <rk_eink.h> 34 #endif 35 DECLARE_GLOBAL_DATA_PTR; 36 37 #define IMAGE_RESET_IDX -1 38 #define IMAGE_SOC_100_IDX(n) ((n) - 2) 39 #define IMAGE_LOWPOWER_IDX(n) ((n) - 1) 40 #define SYSTEM_SUSPEND_DELAY_MS 5000 41 #define FUEL_GAUGE_POLL_MS 1000 42 43 #define LED_CHARGING_NAME "battery_charging" 44 #define LED_CHARGING_FULL_NAME "battery_full" 45 46 struct charge_image { 47 const char *name; 48 int soc; 49 int period; /* ms */ 50 }; 51 52 struct charge_animation_priv { 53 struct udevice *pmic; 54 struct udevice *fg; 55 struct udevice *charger; 56 struct udevice *rtc; 57 #ifdef CONFIG_LED 58 struct udevice *led_charging; 59 struct udevice *led_full; 60 #endif 61 const struct charge_image *image; 62 int image_num; 63 64 int auto_wakeup_key_state; 65 ulong auto_screen_off_timeout; /* ms */ 66 ulong suspend_delay_timeout; /* ms */ 67 }; 68 69 /* 70 * IF you want to use your own charge images, please: 71 * 72 * 1. Update the following 'image[]' to point to your own images; 73 * 2. You must set the failed image as last one and soc = -1 !!! 74 */ 75 static const struct charge_image image[] = { 76 { .name = "battery_0.bmp", .soc = 5, .period = 600 }, 77 { .name = "battery_1.bmp", .soc = 20, .period = 600 }, 78 { .name = "battery_2.bmp", .soc = 40, .period = 600 }, 79 { .name = "battery_3.bmp", .soc = 60, .period = 600 }, 80 { .name = "battery_4.bmp", .soc = 80, .period = 600 }, 81 { .name = "battery_5.bmp", .soc = 100, .period = 600 }, 82 { .name = "battery_fail.bmp", .soc = -1, .period = 1000 }, 83 }; 84 85 static int charge_animation_ofdata_to_platdata(struct udevice *dev) 86 { 87 struct charge_animation_pdata *pdata = dev_get_platdata(dev); 88 89 /* charge mode */ 90 pdata->uboot_charge = 91 dev_read_u32_default(dev, "rockchip,uboot-charge-on", 0); 92 pdata->android_charge = 93 dev_read_u32_default(dev, "rockchip,android-charge-on", 0); 94 95 pdata->auto_exit_charge = 96 dev_read_u32_default(dev, "rockchip,uboot-exit-charge-auto", 0); 97 pdata->exit_charge_level = 98 dev_read_u32_default(dev, "rockchip,uboot-exit-charge-level", 0); 99 pdata->exit_charge_voltage = 100 dev_read_u32_default(dev, "rockchip,uboot-exit-charge-voltage", 0); 101 102 pdata->low_power_voltage = 103 dev_read_u32_default(dev, "rockchip,uboot-low-power-voltage", 0); 104 105 pdata->screen_on_voltage = 106 dev_read_u32_default(dev, "rockchip,screen-on-voltage", 0); 107 pdata->system_suspend = 108 dev_read_u32_default(dev, "rockchip,system-suspend", 0); 109 110 pdata->auto_wakeup_interval = 111 dev_read_u32_default(dev, "rockchip,auto-wakeup-interval", 0); 112 pdata->auto_wakeup_screen_invert = 113 dev_read_u32_default(dev, "rockchip,auto-wakeup-screen-invert", 0); 114 115 pdata->auto_off_screen_interval = 116 dev_read_u32_default(dev, "rockchip,auto-off-screen-interval", 15); 117 118 if (pdata->screen_on_voltage > pdata->exit_charge_voltage) 119 pdata->screen_on_voltage = pdata->exit_charge_voltage; 120 121 if (pdata->auto_exit_charge && !pdata->auto_wakeup_interval) 122 pdata->auto_wakeup_interval = 10; 123 124 debug("mode: uboot=%d, android=%d; exit: soc=%d%%, voltage=%dmv;\n" 125 "lp_voltage=%d%%, screen_on=%dmv\n", 126 pdata->uboot_charge, pdata->android_charge, 127 pdata->exit_charge_level, pdata->exit_charge_voltage, 128 pdata->low_power_voltage, pdata->screen_on_voltage); 129 130 return 0; 131 } 132 133 static int check_key_press(struct udevice *dev) 134 { 135 struct charge_animation_pdata *pdata = dev_get_platdata(dev); 136 struct charge_animation_priv *priv = dev_get_priv(dev); 137 u32 state, rtc_state = 0; 138 139 #ifdef CONFIG_DM_RTC 140 if (priv->rtc) 141 rtc_state = rtc_alarm_trigger(priv->rtc); 142 #endif 143 if (rtc_state) { 144 printf("rtc alarm trigger...\n"); 145 return KEY_PRESS_LONG_DOWN; 146 } 147 148 state = key_read(KEY_POWER); 149 if (state < 0) 150 printf("read power key failed: %d\n", state); 151 else if (state == KEY_PRESS_DOWN) 152 printf("power key pressed...\n"); 153 else if (state == KEY_PRESS_LONG_DOWN) 154 printf("power key long pressed...\n"); 155 156 /* Fixup key state for following cases */ 157 if (pdata->auto_wakeup_interval) { 158 if (pdata->auto_wakeup_screen_invert) { 159 if (priv->auto_wakeup_key_state == KEY_PRESS_DOWN) { 160 /* Value is updated in timer interrupt */ 161 priv->auto_wakeup_key_state = KEY_PRESS_NONE; 162 state = KEY_PRESS_DOWN; 163 } 164 } 165 } 166 if (!pdata->auto_wakeup_screen_invert && 167 pdata->auto_off_screen_interval) { 168 if (priv->auto_screen_off_timeout && 169 get_timer(priv->auto_screen_off_timeout) > 170 pdata->auto_off_screen_interval * 1000) { /* 1000ms */ 171 state = KEY_PRESS_DOWN; 172 printf("Auto screen off\n"); 173 } 174 } 175 176 return state; 177 } 178 179 /* 180 * If not enable CONFIG_IRQ, cpu can't suspend to ATF or wfi, so that wakeup 181 * period timer is useless. 182 */ 183 #if !defined(CONFIG_IRQ) || !defined(CONFIG_ARM_CPU_SUSPEND) 184 static int system_suspend_enter(struct udevice *dev) 185 { 186 return 0; 187 } 188 189 static void autowakeup_timer_init(struct udevice *dev, uint32_t seconds) {} 190 static void autowakeup_timer_uninit(void) {} 191 192 #else 193 static int system_suspend_enter(struct udevice *dev) 194 { 195 struct charge_animation_pdata *pdata = dev_get_platdata(dev); 196 struct charge_animation_priv *priv = dev_get_priv(dev); 197 198 /* 199 * When cpu is in wfi and we try to give a long key press event without 200 * key release, cpu would wakeup and enter wfi again immediately. So 201 * here is the problem: cpu can only wakeup when long key released. 202 * 203 * Actually, we want cpu can detect long key event without key release, 204 * so we give a suspend delay timeout for cpu to detect this. 205 */ 206 if (priv->suspend_delay_timeout && 207 get_timer(priv->suspend_delay_timeout) <= SYSTEM_SUSPEND_DELAY_MS) 208 return 0; 209 210 if (pdata->system_suspend && IS_ENABLED(CONFIG_ARM_SMCCC)) { 211 printf("\nSystem suspend: "); 212 putc('0'); 213 regulators_enable_state_mem(false); 214 putc('1'); 215 local_irq_disable(); 216 putc('2'); 217 irqs_suspend(); 218 putc('3'); 219 device_suspend(); 220 putc('4'); 221 putc('\n'); 222 223 /* Trap into ATF for low power mode */ 224 cpu_suspend(0, psci_system_suspend); 225 226 putc('\n'); 227 putc('4'); 228 device_resume(); 229 putc('3'); 230 irqs_resume(); 231 putc('2'); 232 local_irq_enable(); 233 putc('1'); 234 putc('\n'); 235 } else { 236 irqs_suspend(); 237 printf("\nWfi\n"); 238 wfi(); 239 putc('1'); 240 irqs_resume(); 241 } 242 243 priv->suspend_delay_timeout = get_timer(0); 244 245 /* 246 * We must wait for key release event finish, otherwise 247 * we may read key state too early. 248 */ 249 mdelay(300); 250 251 return 0; 252 } 253 254 static void timer_irq_handler(int irq, void *data) 255 { 256 struct udevice *dev = data; 257 struct charge_animation_priv *priv = dev_get_priv(dev); 258 static long long count; 259 260 writel(TIMER_CLR_INT, TIMER_BASE + TIMER_INTSTATUS); 261 262 priv->auto_wakeup_key_state = KEY_PRESS_DOWN; 263 printf("auto wakeup count: %lld\n", ++count); 264 } 265 266 static void autowakeup_timer_init(struct udevice *dev, uint32_t seconds) 267 { 268 uint64_t period = 24000000ULL * seconds; 269 270 /* Disable before conifg */ 271 writel(0, TIMER_BASE + TIMER_CTRL); 272 273 /* Config */ 274 writel((uint32_t)period, TIMER_BASE + TIMER_LOAD_COUNT0); 275 writel((uint32_t)(period >> 32), TIMER_BASE + TIMER_LOAD_COUNT1); 276 writel(TIMER_CLR_INT, TIMER_BASE + TIMER_INTSTATUS); 277 writel(TIMER_EN | TIMER_INT_EN, TIMER_BASE + TIMER_CTRL); 278 279 /* IRQ */ 280 irq_install_handler(TIMER_IRQ, timer_irq_handler, dev); 281 irq_handler_enable(TIMER_IRQ); 282 } 283 284 static void autowakeup_timer_uninit(void) 285 { 286 irq_free_handler(TIMER_IRQ); 287 } 288 #endif 289 290 #ifdef CONFIG_DRM_ROCKCHIP 291 static void charge_show_bmp(const char *name) 292 { 293 rockchip_show_bmp(name); 294 } 295 296 static void charge_show_logo(void) 297 { 298 rockchip_show_logo(); 299 } 300 #else 301 static void charge_show_bmp(const char *name) {} 302 static void charge_show_logo(void) {} 303 #endif 304 305 #ifdef CONFIG_LED 306 static int leds_update(struct udevice *dev, int soc) 307 { 308 struct charge_animation_priv *priv = dev_get_priv(dev); 309 static int old_soc = -1; 310 int ret, ledst; 311 312 if (old_soc == soc) 313 return 0; 314 315 old_soc = soc; 316 if (priv->led_charging) { 317 ledst = (soc < 100) ? LEDST_ON : LEDST_OFF; 318 ret = led_set_state(priv->led_charging, ledst); 319 if (ret) { 320 printf("set charging led %s failed, ret=%d\n", 321 (ledst == LEDST_ON) ? "ON" : "OFF", ret); 322 return ret; 323 } 324 } 325 326 if (priv->led_full) { 327 ledst = (soc == 100) ? LEDST_ON : LEDST_OFF; 328 ret = led_set_state(priv->led_full, ledst); 329 if (ret) { 330 printf("set charging full led %s failed, ret=%d\n", 331 ledst == LEDST_ON ? "ON" : "OFF", ret); 332 return ret; 333 } 334 } 335 336 return 0; 337 } 338 #else 339 static int leds_update(struct udevice *dev, int soc) { return 0; } 340 #endif 341 342 static int fg_charger_get_chrg_online(struct udevice *dev) 343 { 344 struct charge_animation_priv *priv = dev_get_priv(dev); 345 struct udevice *charger; 346 347 charger = priv->charger ? : priv->fg; 348 349 return fuel_gauge_get_chrg_online(charger); 350 } 351 352 static int charge_extrem_low_power(struct udevice *dev) 353 { 354 struct charge_animation_pdata *pdata = dev_get_platdata(dev); 355 struct charge_animation_priv *priv = dev_get_priv(dev); 356 struct udevice *pmic = priv->pmic; 357 struct udevice *fg = priv->fg; 358 int voltage, soc, charging = 1; 359 static int timer_initialized; 360 int ret; 361 362 voltage = fuel_gauge_get_voltage(fg); 363 if (voltage < 0) 364 return -EINVAL; 365 366 while (voltage < pdata->low_power_voltage + 50) { 367 /* Check charger online */ 368 charging = fg_charger_get_chrg_online(dev); 369 if (charging <= 0) { 370 printf("%s: Not charging, online=%d. Shutdown...\n", 371 __func__, charging); 372 /* wait uart flush before shutdown */ 373 mdelay(5); 374 /* PMIC shutdown */ 375 pmic_shutdown(pmic); 376 377 printf("Cpu should never reach here, shutdown failed !\n"); 378 continue; 379 } 380 381 /* Enable auto wakeup */ 382 if (!timer_initialized) { 383 timer_initialized = 1; 384 autowakeup_timer_init(dev, 5); 385 } 386 387 /* 388 * Just for fuel gauge to update something important, 389 * including charge current, coulometer or other. 390 */ 391 soc = fuel_gauge_update_get_soc(fg); 392 if (soc < 0 || soc > 100) { 393 printf("get soc failed: %d\n", soc); 394 continue; 395 } 396 397 /* Update led */ 398 ret = leds_update(dev, soc); 399 if (ret) 400 printf("update led failed: %d\n", ret); 401 402 printf("Extrem low power, force charging... threshold=%dmv, now=%dmv\n", 403 pdata->low_power_voltage, voltage); 404 405 /* System suspend */ 406 system_suspend_enter(dev); 407 408 /* Update voltage */ 409 voltage = fuel_gauge_get_voltage(fg); 410 if (voltage < 0) { 411 printf("get voltage failed: %d\n", voltage); 412 continue; 413 } 414 415 if (ctrlc()) { 416 printf("Extrem low charge: exit by ctrl+c\n"); 417 break; 418 } 419 } 420 421 autowakeup_timer_uninit(); 422 423 return 0; 424 } 425 426 static int charge_animation_show(struct udevice *dev) 427 { 428 struct charge_animation_pdata *pdata = dev_get_platdata(dev); 429 struct charge_animation_priv *priv = dev_get_priv(dev); 430 const struct charge_image *image = priv->image; 431 struct udevice *pmic = priv->pmic; 432 struct udevice *fg = priv->fg; 433 const char *preboot = env_get("preboot"); 434 int image_num = priv->image_num; 435 bool ever_lowpower_screen_off = false; 436 bool screen_on = true; 437 ulong show_start = 0, charge_start = 0, debug_start = 0; 438 ulong delta; 439 ulong ms = 0, sec = 0; 440 int start_idx = 0, show_idx = -1, old_show_idx = IMAGE_RESET_IDX; 441 int soc, voltage, current, key_state; 442 int i, charging = 1, ret; 443 int boot_mode; 444 int first_poll_fg = 1; 445 bool exit_charge = false; 446 447 /* 448 * Check sequence: 449 * 450 * 1. Extrem low power charge? 451 * 2. Preboot cmd? 452 * 3. Valid boot mode? 453 * 4. U-Boot charge enabled by dts config? 454 * 5. Screen off before charge? 455 * 6. Enter charge ! 456 * 457 */ 458 if (!fuel_gauge_bat_is_exist(fg)) { 459 printf("Exit charge: battery is not exist\n"); 460 return 0; 461 } 462 463 /* Extrem low power charge */ 464 ret = charge_extrem_low_power(dev); 465 if (ret < 0) { 466 printf("extrem low power charge failed, ret=%d\n", ret); 467 return ret; 468 } 469 470 /* If there is preboot command, exit */ 471 if (preboot && !strstr(preboot, "dvfs")) { 472 printf("Exit charge: due to preboot cmd '%s'\n", preboot); 473 return 0; 474 } 475 476 /* Not valid charge mode, exit */ 477 #ifdef CONFIG_RKIMG_BOOTLOADER 478 boot_mode = rockchip_get_boot_mode(); 479 if ((boot_mode != BOOT_MODE_CHARGING) && 480 (boot_mode != BOOT_MODE_UNDEFINE)) { 481 printf("Exit charge: due to boot mode\n"); 482 return 0; 483 } 484 #endif 485 charging = fg_charger_get_chrg_online(dev); 486 /* Not charger online and low power, shutdown */ 487 if (charging <= 0 && pdata->auto_exit_charge) { 488 soc = fuel_gauge_update_get_soc(fg); 489 voltage = fuel_gauge_get_voltage(fg); 490 if (soc < pdata->exit_charge_level) { 491 printf("soc(%d%%) < exit_charge_level(%d%%)\n", 492 soc, pdata->exit_charge_level); 493 exit_charge = true; 494 } 495 if (voltage < pdata->exit_charge_voltage) { 496 printf("voltage(%d) < exit_charge_voltage(%d)\n", 497 voltage, pdata->exit_charge_voltage); 498 exit_charge = true; 499 } 500 if (exit_charge) { 501 printf("Not charging and low power, Shutdown...\n"); 502 show_idx = IMAGE_LOWPOWER_IDX(image_num); 503 charge_show_bmp(image[show_idx].name); 504 mdelay(1000); 505 pmic_shutdown(pmic); 506 } 507 } 508 509 /* Not charger online, exit */ 510 if (charging <= 0) { 511 printf("Exit charge: due to charger offline\n"); 512 return 0; 513 } 514 515 /* Enter android charge, set property for kernel */ 516 if (pdata->android_charge) { 517 env_update("bootargs", "androidboot.mode=charger"); 518 printf("Android charge mode\n"); 519 } 520 521 /* Not enable U-Boot charge, exit */ 522 if (!pdata->uboot_charge) { 523 printf("Exit charge: due to not enable uboot charge\n"); 524 return 0; 525 } 526 527 voltage = fuel_gauge_get_voltage(fg); 528 if (voltage < 0) { 529 printf("get voltage failed: %d\n", voltage); 530 return -EINVAL; 531 } 532 533 /* If low power, turn off screen */ 534 if (voltage <= pdata->screen_on_voltage + 50) { 535 screen_on = false; 536 ever_lowpower_screen_off = true; 537 charge_show_bmp(NULL); 538 } 539 540 /* Auto wakeup */ 541 if (pdata->auto_wakeup_interval) { 542 printf("Auto wakeup: %dS\n", pdata->auto_wakeup_interval); 543 autowakeup_timer_init(dev, pdata->auto_wakeup_interval); 544 } 545 546 /* Give a message warning when CONFIG_IRQ is not enabled */ 547 #ifdef CONFIG_IRQ 548 printf("Enter U-Boot charging mode\n"); 549 #else 550 printf("Enter U-Boot charging mode(without IRQ)\n"); 551 #endif 552 553 charge_start = get_timer(0); 554 delta = get_timer(0); 555 556 /* Charging ! */ 557 while (1) { 558 /* 559 * At the most time, fuel gauge is usually a i2c device, we 560 * should avoid read/write all the time. We had better set 561 * poll seconds to update fuel gauge info. 562 */ 563 if (!first_poll_fg && get_timer(delta) < FUEL_GAUGE_POLL_MS) 564 goto show_images; 565 566 delta = get_timer(0); 567 568 debug("step1 (%d)... \n", screen_on); 569 570 /* 571 * Most fuel gauge is I2C interface, it shouldn't be interrupted 572 * during transfer. The power key event depends on interrupt, so 573 * we should disable local irq when update fuel gauge. 574 */ 575 local_irq_disable(); 576 577 /* Step1: Is charging now ? */ 578 charging = fg_charger_get_chrg_online(dev); 579 if (charging <= 0) { 580 printf("Not charging, online=%d. Shutdown...\n", 581 charging); 582 #ifdef CONFIG_ROCKCHIP_EINK_DISPLAY 583 /* 584 * If charger is plug out during charging, display white 585 * screen before device power off. 586 * Irq must be enable if CONFIG_IRQ is defined, because 587 * ebc need to wait irq to indicate frame is complete. 588 */ 589 #ifdef CONFIG_IRQ 590 local_irq_enable(); 591 #endif 592 ret = rockchip_eink_show_charge_logo(EINK_LOGO_RESET); 593 if (ret != 0) 594 printf("Eink display reset logo failed\n"); 595 #ifdef CONFIG_IRQ 596 local_irq_disable(); 597 #endif 598 #endif 599 /* wait uart flush before shutdown */ 600 mdelay(5); 601 602 /* PMIC shutdown */ 603 pmic_shutdown(pmic); 604 605 printf("Cpu should never reach here, shutdown failed !\n"); 606 continue; 607 } 608 609 debug("step2 (%d)... show_idx=%d\n", screen_on, show_idx); 610 611 /* Step2: get soc and voltage */ 612 soc = fuel_gauge_update_get_soc(fg); 613 if (soc < 0 || soc > 100) { 614 printf("get soc failed: %d\n", soc); 615 continue; 616 } 617 618 voltage = fuel_gauge_get_voltage(fg); 619 if (voltage < 0) { 620 printf("get voltage failed: %d\n", voltage); 621 continue; 622 } 623 624 current = fuel_gauge_get_current(fg); 625 if (current == -ENOSYS) { 626 printf("get current failed: %d\n", current); 627 continue; 628 } 629 630 first_poll_fg = 0; 631 local_irq_enable(); 632 633 if (pdata->auto_exit_charge) { 634 /* Is able to boot now ? */ 635 if (pdata->exit_charge_level && 636 soc >= pdata->exit_charge_level) { 637 printf("soc(%d%%) exit charge animation...\n", 638 soc); 639 break; 640 } 641 if (pdata->exit_charge_voltage && 642 voltage >= pdata->exit_charge_voltage) { 643 printf("vol(%d) exit charge animation...\n", 644 voltage); 645 break; 646 } 647 } 648 649 show_images: 650 /* 651 * Just for debug, otherwise there will be nothing output which 652 * is not good to know what happen. 653 */ 654 if (!debug_start) 655 debug_start = get_timer(0); 656 if (get_timer(debug_start) > 20000) { 657 debug_start = get_timer(0); 658 printf("[%8ld]: soc=%d%%, vol=%dmv, c=%dma, " 659 "online=%d, screen_on=%d\n", 660 get_timer(0)/1000, soc, voltage, 661 current, charging, screen_on); 662 } 663 664 /* Update leds */ 665 ret = leds_update(dev, soc); 666 if (ret) 667 printf("update led failed: %d\n", ret); 668 669 /* 670 * If ever lowpower screen off, force screen_on=false, which 671 * means key event can't modify screen_on, only voltage higher 672 * then threshold can update screen_on=true; 673 */ 674 if (ever_lowpower_screen_off) 675 screen_on = false; 676 677 /* 678 * Auto turn on screen when voltage higher than Vol screen on. 679 * 'ever_lowpower_screen_off' means enter the while(1) loop with 680 * screen off. 681 */ 682 if ((ever_lowpower_screen_off) && 683 (voltage > pdata->screen_on_voltage)) { 684 ever_lowpower_screen_off = false; 685 screen_on = true; 686 show_idx = IMAGE_RESET_IDX; 687 } 688 689 /* 690 * IMAGE_RESET_IDX means show_idx show be update by start_idx. 691 * When short key pressed event trigged, we will set show_idx 692 * as IMAGE_RESET_IDX which updates images index from start_idx 693 * that calculate by current soc. 694 */ 695 if (show_idx == IMAGE_RESET_IDX) { 696 for (i = 0; i < IMAGE_SOC_100_IDX(image_num); i++) { 697 /* Find out which image we start to show */ 698 if ((soc >= image[i].soc) && 699 (soc < image[i + 1].soc)) { 700 start_idx = i; 701 break; 702 } 703 704 if (soc >= 100) { 705 start_idx = IMAGE_SOC_100_IDX(image_num); 706 break; 707 } 708 } 709 710 debug("%s: show_idx=%d, screen_on=%d\n", 711 __func__, show_idx, screen_on); 712 713 /* Mark start index and start time */ 714 show_idx = start_idx; 715 show_start = get_timer(0); 716 } 717 718 debug("step3 (%d)... show_idx=%d\n", screen_on, show_idx); 719 720 #ifdef CONFIG_ROCKCHIP_EINK_DISPLAY 721 /* 722 * Device is auto wakeup from suspend, if it's eink display, 723 * screen will display the last image after suspend, so 724 * we should update the image to show the approximate 725 * battery power if battery is charging to next level. 726 */ 727 if (pdata->auto_wakeup_interval && 728 priv->auto_wakeup_key_state == KEY_PRESS_DOWN && 729 !screen_on) { 730 if (soc >= image[old_show_idx + 1].soc && 731 soc < 100) { 732 int ret; 733 int logo_type = EINK_LOGO_CHARGING_0; 734 735 logo_type = logo_type << (old_show_idx + 1); 736 ret = rockchip_eink_show_charge_logo(logo_type); 737 /* 738 * only change the logic if eink is 739 * actually exist 740 */ 741 if (ret == 0) { 742 printf("Update image id[%d] for eink\n", 743 old_show_idx + 1); 744 old_show_idx++; 745 } 746 } 747 } 748 /* 749 * If battery capacity is charged to 100%, exit charging 750 * animation and boot android system. 751 */ 752 if (soc >= 100) { 753 int ret; 754 int logo_type = EINK_LOGO_CHARGING_5; 755 756 ret = rockchip_eink_show_charge_logo(logo_type); 757 /* Only change the logic if eink is acutally exist */ 758 if (ret == 0) { 759 printf("battery FULL,exit charge animation\n"); 760 mdelay(20); 761 break; 762 } 763 } 764 #endif 765 /* Step3: show images */ 766 if (screen_on) { 767 /* Don't call 'charge_show_bmp' unless image changed */ 768 if (old_show_idx != show_idx) { 769 #ifdef CONFIG_ROCKCHIP_EINK_DISPLAY 770 int logo_type = EINK_LOGO_CHARGING_0; 771 772 rockchip_eink_show_charge_logo(logo_type << 773 show_idx); 774 #endif 775 old_show_idx = show_idx; 776 debug("SHOW: %s\n", image[show_idx].name); 777 charge_show_bmp(image[show_idx].name); 778 } 779 /* Re-calculate timeout to off screen */ 780 if (priv->auto_screen_off_timeout == 0) 781 priv->auto_screen_off_timeout = get_timer(0); 782 } else { 783 priv->auto_screen_off_timeout = 0; 784 system_suspend_enter(dev); 785 } 786 787 mdelay(5); 788 789 /* Every image shows period */ 790 if (get_timer(show_start) > image[show_idx].period) { 791 show_start = get_timer(0); 792 /* Update to next image */ 793 show_idx++; 794 if (show_idx > IMAGE_SOC_100_IDX(image_num)) 795 show_idx = IMAGE_RESET_IDX; 796 } 797 798 debug("step4 (%d)... \n", screen_on); 799 800 /* 801 * Step4: check key event. 802 * 803 * Short key event: turn on/off screen; 804 * Long key event: show logo and boot system or still charging. 805 */ 806 key_state = check_key_press(dev); 807 if (key_state == KEY_PRESS_DOWN) { 808 /* 809 * Clear current image index, and show image 810 * from start_idx 811 */ 812 old_show_idx = IMAGE_RESET_IDX; 813 show_idx = IMAGE_RESET_IDX; 814 815 /* 816 * Reverse the screen state 817 * 818 * If screen_on=false, means this short key pressed 819 * event turn on the screen and we need show images. 820 * 821 * If screen_on=true, means this short key pressed 822 * event turn off the screen and we never show images. 823 */ 824 if (screen_on) { 825 #ifdef CONFIG_ROCKCHIP_EINK_DISPLAY 826 int type = EINK_LOGO_CHARGING_0 << start_idx; 827 /* 828 * Show current battery capacity before suspend 829 * if it's eink display, because eink screen 830 * will continue to display the last image 831 * after suspend, so user can get the 832 * approximate capacity by image displayed. 833 */ 834 ret = rockchip_eink_show_charge_logo(type); 835 /* only change the logic if eink display ok */ 836 if (ret == 0) 837 old_show_idx = start_idx; 838 #endif 839 charge_show_bmp(NULL); /* Turn off screen */ 840 screen_on = false; 841 priv->suspend_delay_timeout = get_timer(0); 842 } else { 843 screen_on = true; 844 } 845 846 printf("screen %s\n", screen_on ? "on" : "off"); 847 } else if (key_state == KEY_PRESS_LONG_DOWN) { 848 /* Set screen_on=true anyway when key long pressed */ 849 if (!screen_on) 850 screen_on = true; 851 852 printf("screen %s\n", screen_on ? "on" : "off"); 853 854 /* Is able to boot now ? */ 855 if (soc < pdata->exit_charge_level) { 856 printf("soc=%d%%, threshold soc=%d%%\n", 857 soc, pdata->exit_charge_level); 858 printf("Low power, unable to boot, charging...\n"); 859 show_idx = IMAGE_LOWPOWER_IDX(image_num); 860 continue; 861 } 862 863 if (voltage < pdata->exit_charge_voltage) { 864 printf("voltage=%dmv, threshold voltage=%dmv\n", 865 voltage, pdata->exit_charge_voltage); 866 printf("Low power, unable to boot, charging...\n"); 867 show_idx = IMAGE_LOWPOWER_IDX(image_num); 868 continue; 869 } 870 871 /* Success exit charging */ 872 printf("Exit charge animation...\n"); 873 charge_show_logo(); 874 break; 875 } else { 876 /* Do nothing */ 877 } 878 879 debug("step5 (%d)... \n", screen_on); 880 881 /* Step5: Exit by ctrl+c */ 882 if (ctrlc()) { 883 if (voltage >= pdata->screen_on_voltage) 884 charge_show_logo(); 885 printf("Exit charge, due to ctrl+c\n"); 886 break; 887 } 888 } 889 890 if (pdata->auto_wakeup_interval) 891 autowakeup_timer_uninit(); 892 893 ms = get_timer(charge_start); 894 if (ms >= 1000) { 895 sec = ms / 1000; 896 ms = ms % 1000; 897 } 898 899 printf("charging time total: %lu.%lus, soc=%d%%, vol=%dmv\n", 900 sec, ms, soc, voltage); 901 902 return 0; 903 } 904 905 static int fg_charger_get_device(struct udevice **fuel_gauge, 906 struct udevice **charger) 907 { 908 struct udevice *dev; 909 struct uclass *uc; 910 int ret, cap; 911 912 *fuel_gauge = NULL, 913 *charger = NULL; 914 915 ret = uclass_get(UCLASS_FG, &uc); 916 if (ret) 917 return ret; 918 919 for (uclass_first_device(UCLASS_FG, &dev); 920 dev; 921 uclass_next_device(&dev)) { 922 cap = fuel_gauge_capability(dev); 923 if (cap == (FG_CAP_CHARGER | FG_CAP_FUEL_GAUGE)) { 924 *fuel_gauge = dev; 925 *charger = NULL; 926 } else if (cap == FG_CAP_FUEL_GAUGE) { 927 *fuel_gauge = dev; 928 } else if (cap == FG_CAP_CHARGER) { 929 *charger = dev; 930 } 931 } 932 933 return (*fuel_gauge) ? 0 : -ENODEV; 934 } 935 936 static const struct dm_charge_display_ops charge_animation_ops = { 937 .show = charge_animation_show, 938 }; 939 940 static int charge_animation_probe(struct udevice *dev) 941 { 942 struct charge_animation_priv *priv = dev_get_priv(dev); 943 int ret, soc; 944 945 /* Get PMIC: used for power off system */ 946 ret = uclass_get_device(UCLASS_PMIC, 0, &priv->pmic); 947 if (ret) { 948 if (ret == -ENODEV) 949 printf("Can't find PMIC\n"); 950 else 951 printf("Get UCLASS PMIC failed: %d\n", ret); 952 return ret; 953 } 954 955 /* Get fuel gauge and charger(If need) */ 956 ret = fg_charger_get_device(&priv->fg, &priv->charger); 957 if (ret) { 958 if (ret == -ENODEV) 959 debug("Can't find FG\n"); 960 else 961 debug("Get UCLASS FG failed: %d\n", ret); 962 return ret; 963 } 964 965 /* Get rtc: used for power on */ 966 ret = uclass_get_device(UCLASS_RTC, 0, &priv->rtc); 967 if (ret) { 968 if (ret == -ENODEV) 969 debug("Can't find RTC\n"); 970 else 971 debug("Get UCLASS RTC failed: %d\n", ret); 972 } 973 974 /* Get PWRKEY: used for wakeup and turn off/on LCD */ 975 if (key_read(KEY_POWER) == KEY_NOT_EXIST) { 976 debug("Can't find power key\n"); 977 return -EINVAL; 978 } 979 980 /* Initialize charge current */ 981 soc = fuel_gauge_update_get_soc(priv->fg); 982 if (soc < 0 || soc > 100) { 983 debug("get soc failed: %d\n", soc); 984 return -EINVAL; 985 } 986 987 /* Get leds */ 988 #ifdef CONFIG_LED 989 ret = led_get_by_label(LED_CHARGING_NAME, &priv->led_charging); 990 if (!ret) 991 printf("Found Charging LED\n"); 992 ret = led_get_by_label(LED_CHARGING_FULL_NAME, &priv->led_full); 993 if (!ret) 994 printf("Found Charging-Full LED\n"); 995 #endif 996 997 /* Get charge images */ 998 priv->image = image; 999 priv->image_num = ARRAY_SIZE(image); 1000 1001 printf("Enable charge animation display\n"); 1002 1003 return 0; 1004 } 1005 1006 static const struct udevice_id charge_animation_ids[] = { 1007 { .compatible = "rockchip,uboot-charge" }, 1008 { }, 1009 }; 1010 1011 U_BOOT_DRIVER(charge_animation) = { 1012 .name = "charge-animation", 1013 .id = UCLASS_CHARGE_DISPLAY, 1014 .probe = charge_animation_probe, 1015 .of_match = charge_animation_ids, 1016 .ops = &charge_animation_ops, 1017 .ofdata_to_platdata = charge_animation_ofdata_to_platdata, 1018 .platdata_auto_alloc_size = sizeof(struct charge_animation_pdata), 1019 .priv_auto_alloc_size = sizeof(struct charge_animation_priv), 1020 }; 1021