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 writel(0, TIMER_BASE + TIMER_CTRL); 287 288 irq_handler_disable(TIMER_IRQ); 289 irq_free_handler(TIMER_IRQ); 290 } 291 #endif 292 293 #ifdef CONFIG_DRM_ROCKCHIP 294 static void charge_show_bmp(const char *name) 295 { 296 rockchip_show_bmp(name); 297 } 298 299 static void charge_show_logo(void) 300 { 301 rockchip_show_logo(); 302 } 303 #else 304 static void charge_show_bmp(const char *name) {} 305 static void charge_show_logo(void) {} 306 #endif 307 308 #ifdef CONFIG_LED 309 static int leds_update(struct udevice *dev, int soc) 310 { 311 struct charge_animation_priv *priv = dev_get_priv(dev); 312 static int old_soc = -1; 313 int ret, ledst; 314 315 if (old_soc == soc) 316 return 0; 317 318 old_soc = soc; 319 if (priv->led_charging) { 320 ledst = (soc < 100) ? LEDST_ON : LEDST_OFF; 321 ret = led_set_state(priv->led_charging, ledst); 322 if (ret) { 323 printf("set charging led %s failed, ret=%d\n", 324 (ledst == LEDST_ON) ? "ON" : "OFF", ret); 325 return ret; 326 } 327 } 328 329 if (priv->led_full) { 330 ledst = (soc == 100) ? LEDST_ON : LEDST_OFF; 331 ret = led_set_state(priv->led_full, ledst); 332 if (ret) { 333 printf("set charging full led %s failed, ret=%d\n", 334 ledst == LEDST_ON ? "ON" : "OFF", ret); 335 return ret; 336 } 337 } 338 339 return 0; 340 } 341 #else 342 static int leds_update(struct udevice *dev, int soc) { return 0; } 343 #endif 344 345 static int fg_charger_get_chrg_online(struct udevice *dev) 346 { 347 struct charge_animation_priv *priv = dev_get_priv(dev); 348 struct udevice *charger; 349 350 charger = priv->charger ? : priv->fg; 351 352 return fuel_gauge_get_chrg_online(charger); 353 } 354 355 static int charge_extrem_low_power(struct udevice *dev) 356 { 357 struct charge_animation_pdata *pdata = dev_get_platdata(dev); 358 struct charge_animation_priv *priv = dev_get_priv(dev); 359 struct udevice *pmic = priv->pmic; 360 struct udevice *fg = priv->fg; 361 int voltage, soc, charging = 1; 362 static int timer_initialized; 363 int ret; 364 365 voltage = fuel_gauge_get_voltage(fg); 366 if (voltage < 0) 367 return -EINVAL; 368 369 while (voltage < pdata->low_power_voltage + 50) { 370 /* Check charger online */ 371 charging = fg_charger_get_chrg_online(dev); 372 if (charging <= 0) { 373 printf("%s: Not charging, online=%d. Shutdown...\n", 374 __func__, charging); 375 /* wait uart flush before shutdown */ 376 mdelay(5); 377 /* PMIC shutdown */ 378 pmic_shutdown(pmic); 379 380 printf("Cpu should never reach here, shutdown failed !\n"); 381 continue; 382 } 383 384 /* Enable auto wakeup */ 385 if (!timer_initialized) { 386 timer_initialized = 1; 387 autowakeup_timer_init(dev, 5); 388 } 389 390 /* 391 * Just for fuel gauge to update something important, 392 * including charge current, coulometer or other. 393 */ 394 soc = fuel_gauge_update_get_soc(fg); 395 if (soc < 0 || soc > 100) { 396 printf("get soc failed: %d\n", soc); 397 continue; 398 } 399 400 /* Update led */ 401 ret = leds_update(dev, soc); 402 if (ret) 403 printf("update led failed: %d\n", ret); 404 405 printf("Extrem low power, force charging... threshold=%dmv, now=%dmv\n", 406 pdata->low_power_voltage, voltage); 407 408 /* System suspend */ 409 system_suspend_enter(dev); 410 411 /* Update voltage */ 412 voltage = fuel_gauge_get_voltage(fg); 413 if (voltage < 0) { 414 printf("get voltage failed: %d\n", voltage); 415 continue; 416 } 417 418 if (ctrlc()) { 419 printf("Extrem low charge: exit by ctrl+c\n"); 420 break; 421 } 422 } 423 424 autowakeup_timer_uninit(); 425 426 return 0; 427 } 428 429 static int charge_animation_show(struct udevice *dev) 430 { 431 struct charge_animation_pdata *pdata = dev_get_platdata(dev); 432 struct charge_animation_priv *priv = dev_get_priv(dev); 433 const struct charge_image *image = priv->image; 434 struct udevice *pmic = priv->pmic; 435 struct udevice *fg = priv->fg; 436 const char *preboot = env_get("preboot"); 437 int image_num = priv->image_num; 438 bool ever_lowpower_screen_off = false; 439 bool screen_on = true; 440 ulong show_start = 0, charge_start = 0, debug_start = 0; 441 ulong delta; 442 ulong ms = 0, sec = 0; 443 int start_idx = 0, show_idx = -1, old_show_idx = IMAGE_RESET_IDX; 444 int soc, voltage, current, key_state; 445 int i, charging = 1, ret; 446 int boot_mode; 447 int first_poll_fg = 1; 448 bool exit_charge = false; 449 450 /* 451 * Check sequence: 452 * 453 * 1. Extrem low power charge? 454 * 2. Preboot cmd? 455 * 3. Valid boot mode? 456 * 4. U-Boot charge enabled by dts config? 457 * 5. Screen off before charge? 458 * 6. Enter charge ! 459 * 460 */ 461 if (!fuel_gauge_bat_is_exist(fg)) { 462 printf("Exit charge: battery is not exist\n"); 463 return 0; 464 } 465 466 /* Extrem low power charge */ 467 ret = charge_extrem_low_power(dev); 468 if (ret < 0) { 469 printf("extrem low power charge failed, ret=%d\n", ret); 470 return ret; 471 } 472 473 /* If there is preboot command, exit */ 474 if (preboot && !strstr(preboot, "dvfs")) { 475 printf("Exit charge: due to preboot cmd '%s'\n", preboot); 476 return 0; 477 } 478 479 /* Not valid charge mode, exit */ 480 #ifdef CONFIG_RKIMG_BOOTLOADER 481 boot_mode = rockchip_get_boot_mode(); 482 if ((boot_mode != BOOT_MODE_CHARGING) && 483 (boot_mode != BOOT_MODE_UNDEFINE)) { 484 printf("Exit charge: due to boot mode\n"); 485 return 0; 486 } 487 #endif 488 charging = fg_charger_get_chrg_online(dev); 489 /* Not charger online and low power, shutdown */ 490 if (charging <= 0 && pdata->auto_exit_charge) { 491 soc = fuel_gauge_update_get_soc(fg); 492 voltage = fuel_gauge_get_voltage(fg); 493 if (soc < pdata->exit_charge_level) { 494 printf("soc(%d%%) < exit_charge_level(%d%%)\n", 495 soc, pdata->exit_charge_level); 496 exit_charge = true; 497 } 498 if (voltage < pdata->exit_charge_voltage) { 499 printf("voltage(%d) < exit_charge_voltage(%d)\n", 500 voltage, pdata->exit_charge_voltage); 501 exit_charge = true; 502 } 503 if (exit_charge) { 504 printf("Not charging and low power, Shutdown...\n"); 505 show_idx = IMAGE_LOWPOWER_IDX(image_num); 506 charge_show_bmp(image[show_idx].name); 507 mdelay(1000); 508 pmic_shutdown(pmic); 509 } 510 } 511 512 /* Not charger online, exit */ 513 if (charging <= 0) { 514 printf("Exit charge: due to charger offline\n"); 515 return 0; 516 } 517 518 /* Enter android charge, set property for kernel */ 519 if (pdata->android_charge) { 520 env_update("bootargs", "androidboot.mode=charger"); 521 printf("Android charge mode\n"); 522 } 523 524 /* Not enable U-Boot charge, exit */ 525 if (!pdata->uboot_charge) { 526 printf("Exit charge: due to not enable uboot charge\n"); 527 return 0; 528 } 529 530 voltage = fuel_gauge_get_voltage(fg); 531 if (voltage < 0) { 532 printf("get voltage failed: %d\n", voltage); 533 return -EINVAL; 534 } 535 536 /* If low power, turn off screen */ 537 if (voltage <= pdata->screen_on_voltage + 50) { 538 screen_on = false; 539 ever_lowpower_screen_off = true; 540 charge_show_bmp(NULL); 541 } 542 543 /* Auto wakeup */ 544 if (pdata->auto_wakeup_interval) { 545 printf("Auto wakeup: %dS\n", pdata->auto_wakeup_interval); 546 autowakeup_timer_init(dev, pdata->auto_wakeup_interval); 547 } 548 549 /* Give a message warning when CONFIG_IRQ is not enabled */ 550 #ifdef CONFIG_IRQ 551 printf("Enter U-Boot charging mode\n"); 552 #else 553 printf("Enter U-Boot charging mode(without IRQ)\n"); 554 #endif 555 556 charge_start = get_timer(0); 557 delta = get_timer(0); 558 559 /* Charging ! */ 560 while (1) { 561 /* 562 * At the most time, fuel gauge is usually a i2c device, we 563 * should avoid read/write all the time. We had better set 564 * poll seconds to update fuel gauge info. 565 */ 566 if (!first_poll_fg && get_timer(delta) < FUEL_GAUGE_POLL_MS) 567 goto show_images; 568 569 delta = get_timer(0); 570 571 debug("step1 (%d)... \n", screen_on); 572 573 /* 574 * Most fuel gauge is I2C interface, it shouldn't be interrupted 575 * during transfer. The power key event depends on interrupt, so 576 * we should disable local irq when update fuel gauge. 577 */ 578 local_irq_disable(); 579 580 /* Step1: Is charging now ? */ 581 charging = fg_charger_get_chrg_online(dev); 582 if (charging <= 0) { 583 printf("Not charging, online=%d. Shutdown...\n", 584 charging); 585 #ifdef CONFIG_ROCKCHIP_EINK_DISPLAY 586 /* 587 * If charger is plug out during charging, display white 588 * screen before device power off. 589 * Irq must be enable if CONFIG_IRQ is defined, because 590 * ebc need to wait irq to indicate frame is complete. 591 */ 592 #ifdef CONFIG_IRQ 593 local_irq_enable(); 594 #endif 595 ret = rockchip_eink_show_charge_logo(EINK_LOGO_RESET); 596 if (ret != 0) 597 printf("Eink display reset logo failed\n"); 598 #ifdef CONFIG_IRQ 599 local_irq_disable(); 600 #endif 601 #endif 602 /* wait uart flush before shutdown */ 603 mdelay(5); 604 605 /* PMIC shutdown */ 606 pmic_shutdown(pmic); 607 608 printf("Cpu should never reach here, shutdown failed !\n"); 609 continue; 610 } 611 612 debug("step2 (%d)... show_idx=%d\n", screen_on, show_idx); 613 614 /* Step2: get soc and voltage */ 615 soc = fuel_gauge_update_get_soc(fg); 616 if (soc < 0 || soc > 100) { 617 printf("get soc failed: %d\n", soc); 618 continue; 619 } 620 621 voltage = fuel_gauge_get_voltage(fg); 622 if (voltage < 0) { 623 printf("get voltage failed: %d\n", voltage); 624 continue; 625 } 626 627 current = fuel_gauge_get_current(fg); 628 if (current == -ENOSYS) { 629 printf("get current failed: %d\n", current); 630 continue; 631 } 632 633 first_poll_fg = 0; 634 local_irq_enable(); 635 636 if (pdata->auto_exit_charge) { 637 /* Is able to boot now ? */ 638 if (pdata->exit_charge_level && 639 soc >= pdata->exit_charge_level) { 640 printf("soc(%d%%) exit charge animation...\n", 641 soc); 642 break; 643 } 644 if (pdata->exit_charge_voltage && 645 voltage >= pdata->exit_charge_voltage) { 646 printf("vol(%d) exit charge animation...\n", 647 voltage); 648 break; 649 } 650 } 651 652 show_images: 653 /* 654 * Just for debug, otherwise there will be nothing output which 655 * is not good to know what happen. 656 */ 657 if (!debug_start) 658 debug_start = get_timer(0); 659 if (get_timer(debug_start) > 20000) { 660 debug_start = get_timer(0); 661 printf("[%8ld]: soc=%d%%, vol=%dmv, c=%dma, " 662 "online=%d, screen_on=%d\n", 663 get_timer(0)/1000, soc, voltage, 664 current, charging, screen_on); 665 } 666 667 /* Update leds */ 668 ret = leds_update(dev, soc); 669 if (ret) 670 printf("update led failed: %d\n", ret); 671 672 /* 673 * If ever lowpower screen off, force screen_on=false, which 674 * means key event can't modify screen_on, only voltage higher 675 * then threshold can update screen_on=true; 676 */ 677 if (ever_lowpower_screen_off) 678 screen_on = false; 679 680 /* 681 * Auto turn on screen when voltage higher than Vol screen on. 682 * 'ever_lowpower_screen_off' means enter the while(1) loop with 683 * screen off. 684 */ 685 if ((ever_lowpower_screen_off) && 686 (voltage > pdata->screen_on_voltage)) { 687 ever_lowpower_screen_off = false; 688 screen_on = true; 689 show_idx = IMAGE_RESET_IDX; 690 } 691 692 /* 693 * IMAGE_RESET_IDX means show_idx show be update by start_idx. 694 * When short key pressed event trigged, we will set show_idx 695 * as IMAGE_RESET_IDX which updates images index from start_idx 696 * that calculate by current soc. 697 */ 698 if (show_idx == IMAGE_RESET_IDX) { 699 for (i = 0; i < IMAGE_SOC_100_IDX(image_num); i++) { 700 /* Find out which image we start to show */ 701 if ((soc >= image[i].soc) && 702 (soc < image[i + 1].soc)) { 703 start_idx = i; 704 break; 705 } 706 707 if (soc >= 100) { 708 start_idx = IMAGE_SOC_100_IDX(image_num); 709 break; 710 } 711 } 712 713 debug("%s: show_idx=%d, screen_on=%d\n", 714 __func__, show_idx, screen_on); 715 716 /* Mark start index and start time */ 717 show_idx = start_idx; 718 show_start = get_timer(0); 719 } 720 721 debug("step3 (%d)... show_idx=%d\n", screen_on, show_idx); 722 723 #ifdef CONFIG_ROCKCHIP_EINK_DISPLAY 724 /* 725 * Device is auto wakeup from suspend, if it's eink display, 726 * screen will display the last image after suspend, so 727 * we should update the image to show the approximate 728 * battery power if battery is charging to next level. 729 */ 730 if (pdata->auto_wakeup_interval && 731 priv->auto_wakeup_key_state == KEY_PRESS_DOWN && 732 !screen_on) { 733 if (soc >= image[old_show_idx + 1].soc && 734 soc < 100) { 735 int ret; 736 int logo_type = EINK_LOGO_CHARGING_0; 737 738 logo_type = logo_type << (old_show_idx + 1); 739 ret = rockchip_eink_show_charge_logo(logo_type); 740 /* 741 * only change the logic if eink is 742 * actually exist 743 */ 744 if (ret == 0) { 745 printf("Update image id[%d] for eink\n", 746 old_show_idx + 1); 747 old_show_idx++; 748 } 749 } 750 } 751 /* 752 * If battery capacity is charged to 100%, exit charging 753 * animation and boot android system. 754 */ 755 if (soc >= 100) { 756 int ret; 757 int logo_type = EINK_LOGO_CHARGING_5; 758 759 ret = rockchip_eink_show_charge_logo(logo_type); 760 /* Only change the logic if eink is acutally exist */ 761 if (ret == 0) { 762 printf("battery FULL,exit charge animation\n"); 763 mdelay(20); 764 break; 765 } 766 } 767 #endif 768 /* Step3: show images */ 769 if (screen_on) { 770 /* Don't call 'charge_show_bmp' unless image changed */ 771 if (old_show_idx != show_idx) { 772 #ifdef CONFIG_ROCKCHIP_EINK_DISPLAY 773 int logo_type = EINK_LOGO_CHARGING_0; 774 775 rockchip_eink_show_charge_logo(logo_type << 776 show_idx); 777 #endif 778 old_show_idx = show_idx; 779 debug("SHOW: %s\n", image[show_idx].name); 780 charge_show_bmp(image[show_idx].name); 781 } 782 /* Re-calculate timeout to off screen */ 783 if (priv->auto_screen_off_timeout == 0) 784 priv->auto_screen_off_timeout = get_timer(0); 785 } else { 786 priv->auto_screen_off_timeout = 0; 787 system_suspend_enter(dev); 788 } 789 790 mdelay(5); 791 792 /* Every image shows period */ 793 if (get_timer(show_start) > image[show_idx].period) { 794 show_start = get_timer(0); 795 /* Update to next image */ 796 show_idx++; 797 if (show_idx > IMAGE_SOC_100_IDX(image_num)) 798 show_idx = IMAGE_RESET_IDX; 799 } 800 801 debug("step4 (%d)... \n", screen_on); 802 803 /* 804 * Step4: check key event. 805 * 806 * Short key event: turn on/off screen; 807 * Long key event: show logo and boot system or still charging. 808 */ 809 key_state = check_key_press(dev); 810 if (key_state == KEY_PRESS_DOWN) { 811 /* 812 * Clear current image index, and show image 813 * from start_idx 814 */ 815 old_show_idx = IMAGE_RESET_IDX; 816 show_idx = IMAGE_RESET_IDX; 817 818 /* 819 * Reverse the screen state 820 * 821 * If screen_on=false, means this short key pressed 822 * event turn on the screen and we need show images. 823 * 824 * If screen_on=true, means this short key pressed 825 * event turn off the screen and we never show images. 826 */ 827 if (screen_on) { 828 #ifdef CONFIG_ROCKCHIP_EINK_DISPLAY 829 int type = EINK_LOGO_CHARGING_0 << start_idx; 830 /* 831 * Show current battery capacity before suspend 832 * if it's eink display, because eink screen 833 * will continue to display the last image 834 * after suspend, so user can get the 835 * approximate capacity by image displayed. 836 */ 837 ret = rockchip_eink_show_charge_logo(type); 838 /* only change the logic if eink display ok */ 839 if (ret == 0) 840 old_show_idx = start_idx; 841 #endif 842 charge_show_bmp(NULL); /* Turn off screen */ 843 screen_on = false; 844 priv->suspend_delay_timeout = get_timer(0); 845 } else { 846 screen_on = true; 847 } 848 849 printf("screen %s\n", screen_on ? "on" : "off"); 850 } else if (key_state == KEY_PRESS_LONG_DOWN) { 851 /* Set screen_on=true anyway when key long pressed */ 852 if (!screen_on) 853 screen_on = true; 854 855 printf("screen %s\n", screen_on ? "on" : "off"); 856 857 /* Is able to boot now ? */ 858 if (soc < pdata->exit_charge_level) { 859 printf("soc=%d%%, threshold soc=%d%%\n", 860 soc, pdata->exit_charge_level); 861 printf("Low power, unable to boot, charging...\n"); 862 show_idx = IMAGE_LOWPOWER_IDX(image_num); 863 continue; 864 } 865 866 if (voltage < pdata->exit_charge_voltage) { 867 printf("voltage=%dmv, threshold voltage=%dmv\n", 868 voltage, pdata->exit_charge_voltage); 869 printf("Low power, unable to boot, charging...\n"); 870 show_idx = IMAGE_LOWPOWER_IDX(image_num); 871 continue; 872 } 873 874 /* Success exit charging */ 875 printf("Exit charge animation...\n"); 876 charge_show_logo(); 877 break; 878 } else { 879 /* Do nothing */ 880 } 881 882 debug("step5 (%d)... \n", screen_on); 883 884 /* Step5: Exit by ctrl+c */ 885 if (ctrlc()) { 886 if (voltage >= pdata->screen_on_voltage) 887 charge_show_logo(); 888 printf("Exit charge, due to ctrl+c\n"); 889 break; 890 } 891 } 892 893 if (pdata->auto_wakeup_interval) 894 autowakeup_timer_uninit(); 895 896 ms = get_timer(charge_start); 897 if (ms >= 1000) { 898 sec = ms / 1000; 899 ms = ms % 1000; 900 } 901 902 printf("charging time total: %lu.%lus, soc=%d%%, vol=%dmv\n", 903 sec, ms, soc, voltage); 904 905 return 0; 906 } 907 908 static int fg_charger_get_device(struct udevice **fuel_gauge, 909 struct udevice **charger) 910 { 911 struct udevice *dev; 912 struct uclass *uc; 913 int ret, cap; 914 915 *fuel_gauge = NULL, 916 *charger = NULL; 917 918 ret = uclass_get(UCLASS_FG, &uc); 919 if (ret) 920 return ret; 921 922 for (uclass_first_device(UCLASS_FG, &dev); 923 dev; 924 uclass_next_device(&dev)) { 925 cap = fuel_gauge_capability(dev); 926 if (cap == (FG_CAP_CHARGER | FG_CAP_FUEL_GAUGE)) { 927 *fuel_gauge = dev; 928 *charger = NULL; 929 } else if (cap == FG_CAP_FUEL_GAUGE) { 930 *fuel_gauge = dev; 931 } else if (cap == FG_CAP_CHARGER) { 932 *charger = dev; 933 } 934 } 935 936 return (*fuel_gauge) ? 0 : -ENODEV; 937 } 938 939 static const struct dm_charge_display_ops charge_animation_ops = { 940 .show = charge_animation_show, 941 }; 942 943 static int charge_animation_probe(struct udevice *dev) 944 { 945 struct charge_animation_priv *priv = dev_get_priv(dev); 946 int ret, soc; 947 948 /* Get PMIC: used for power off system */ 949 ret = uclass_get_device(UCLASS_PMIC, 0, &priv->pmic); 950 if (ret) { 951 if (ret == -ENODEV) 952 printf("Can't find PMIC\n"); 953 else 954 printf("Get UCLASS PMIC failed: %d\n", ret); 955 return ret; 956 } 957 958 /* Get fuel gauge and charger(If need) */ 959 ret = fg_charger_get_device(&priv->fg, &priv->charger); 960 if (ret) { 961 if (ret == -ENODEV) 962 debug("Can't find FG\n"); 963 else 964 debug("Get UCLASS FG failed: %d\n", ret); 965 return ret; 966 } 967 968 /* Get rtc: used for power on */ 969 ret = uclass_get_device(UCLASS_RTC, 0, &priv->rtc); 970 if (ret) { 971 if (ret == -ENODEV) 972 debug("Can't find RTC\n"); 973 else 974 debug("Get UCLASS RTC failed: %d\n", ret); 975 } 976 977 /* Get PWRKEY: used for wakeup and turn off/on LCD */ 978 if (key_read(KEY_POWER) == KEY_NOT_EXIST) { 979 debug("Can't find power key\n"); 980 return -EINVAL; 981 } 982 983 /* Initialize charge current */ 984 soc = fuel_gauge_update_get_soc(priv->fg); 985 if (soc < 0 || soc > 100) { 986 debug("get soc failed: %d\n", soc); 987 return -EINVAL; 988 } 989 990 /* Get leds */ 991 #ifdef CONFIG_LED 992 ret = led_get_by_label(LED_CHARGING_NAME, &priv->led_charging); 993 if (!ret) 994 printf("Found Charging LED\n"); 995 ret = led_get_by_label(LED_CHARGING_FULL_NAME, &priv->led_full); 996 if (!ret) 997 printf("Found Charging-Full LED\n"); 998 #endif 999 1000 /* Get charge images */ 1001 priv->image = image; 1002 priv->image_num = ARRAY_SIZE(image); 1003 1004 printf("Enable charge animation display\n"); 1005 1006 return 0; 1007 } 1008 1009 static const struct udevice_id charge_animation_ids[] = { 1010 { .compatible = "rockchip,uboot-charge" }, 1011 { }, 1012 }; 1013 1014 U_BOOT_DRIVER(charge_animation) = { 1015 .name = "charge-animation", 1016 .id = UCLASS_CHARGE_DISPLAY, 1017 .probe = charge_animation_probe, 1018 .of_match = charge_animation_ids, 1019 .ops = &charge_animation_ops, 1020 .ofdata_to_platdata = charge_animation_ofdata_to_platdata, 1021 .platdata_auto_alloc_size = sizeof(struct charge_animation_pdata), 1022 .priv_auto_alloc_size = sizeof(struct charge_animation_priv), 1023 }; 1024