zapm.c revision 1.3.44.1
1 /* $NetBSD: zapm.c,v 1.3.44.1 2009/03/03 18:29:49 skrll Exp $ */ 2 /* $OpenBSD: zaurus_apm.c,v 1.13 2006/12/12 23:14:28 dim Exp $ */ 3 4 /* 5 * Copyright (c) 2005 Uwe Stuehler <uwe (at) bsdx.de> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 #include <sys/cdefs.h> 21 __KERNEL_RCSID(0, "$NetBSD: zapm.c,v 1.3.44.1 2009/03/03 18:29:49 skrll Exp $"); 22 23 #include <sys/param.h> 24 #include <sys/systm.h> 25 #include <sys/kernel.h> 26 #include <sys/callout.h> 27 28 #include <dev/hpc/apm/apmvar.h> 29 30 #include <arm/xscale/pxa2x0reg.h> 31 #include <arm/xscale/pxa2x0var.h> 32 #include <arm/xscale/pxa2x0cpu.h> 33 #include <arm/xscale/pxa2x0_gpio.h> 34 35 #include <machine/config_hook.h> 36 37 #include <zaurus/dev/scoopvar.h> 38 #include <zaurus/dev/zsspvar.h> 39 #include <zaurus/zaurus/zaurus_reg.h> 40 #include <zaurus/zaurus/zaurus_var.h> 41 42 #ifdef APMDEBUG 43 #define DPRINTF(x) printf x 44 #else 45 #define DPRINTF(x) do { } while (/*CONSTCOND*/0) 46 #endif 47 48 struct zapm_softc { 49 device_t sc_dev; 50 void *sc_apmdev; 51 52 struct callout sc_cyclic_poll; 53 struct callout sc_discharge_poll; 54 struct timeval sc_lastbattchk; 55 volatile int suspended; 56 volatile int charging; 57 volatile int discharging; 58 int battery_volt; 59 int battery_full_cnt; 60 61 /* GPIO pin */ 62 int sc_ac_detect_pin; 63 int sc_batt_cover_pin; 64 int sc_charge_comp_pin; 65 66 /* machine-independent part */ 67 volatile u_int events; 68 volatile int power_state; 69 volatile int battery_state; 70 volatile int ac_state; 71 config_hook_tag sc_standby_hook; 72 config_hook_tag sc_suspend_hook; 73 config_hook_tag sc_battery_hook; 74 config_hook_tag sc_ac_hook; 75 int battery_life; 76 int minutes_left; 77 }; 78 79 static int zapm_match(device_t, cfdata_t, void *); 80 static void zapm_attach(device_t, device_t, void *); 81 82 CFATTACH_DECL_NEW(zapm, sizeof(struct zapm_softc), 83 zapm_match, zapm_attach, NULL, NULL); 84 85 static int zapm_hook(void *, int, long, void *); 86 static void zapm_disconnect(void *); 87 static void zapm_enable(void *, int); 88 static int zapm_set_powstate(void *, u_int, u_int); 89 static int zapm_get_powstat(void *, struct apm_power_info *); 90 static int zapm_get_event(void *, u_int *, u_int *); 91 static void zapm_cpu_busy(void *); 92 static void zapm_cpu_idle(void *); 93 static void zapm_get_capabilities(void *, u_int *, u_int *); 94 95 static struct apm_accessops zapm_accessops = { 96 zapm_disconnect, 97 zapm_enable, 98 zapm_set_powstate, 99 zapm_get_powstat, 100 zapm_get_event, 101 zapm_cpu_busy, 102 zapm_cpu_idle, 103 zapm_get_capabilities, 104 }; 105 106 static int zapm_acintr(void *); 107 static int zapm_bcintr(void *); 108 static void zapm_cyclic(void *); 109 static void zapm_poll(void *); 110 static void zapm_poll1(void *, int); 111 112 /* battery-related GPIO pins */ 113 #define GPIO_AC_IN_C3000 115 /* 0=AC connected */ 114 #define GPIO_CHRG_CO_C3000 101 /* 1=battery full */ 115 #define GPIO_BATT_COVER_C3000 90 /* 0=unlocked */ 116 117 /* Cyclic timer value */ 118 #define CYCLIC_TIME (60 * hz) /* 60s */ 119 120 static int 121 zapm_match(device_t parent, cfdata_t cf, void *aux) 122 { 123 124 if (!ZAURUS_ISC3000) 125 return 0; 126 return 1; 127 } 128 129 static void 130 zapm_attach(device_t parent, device_t self, void *aux) 131 { 132 struct zapm_softc *sc = device_private(self); 133 struct apmdev_attach_args aaa; 134 135 sc->sc_dev = self; 136 137 aprint_normal(": pseudo power management module\n"); 138 aprint_naive("\n"); 139 140 /* machine-depent part */ 141 callout_init(&sc->sc_cyclic_poll, 0); 142 callout_setfunc(&sc->sc_cyclic_poll, zapm_cyclic, sc); 143 callout_init(&sc->sc_discharge_poll, 0); 144 callout_setfunc(&sc->sc_discharge_poll, zapm_poll, sc); 145 146 if (ZAURUS_ISC3000) { 147 sc->sc_ac_detect_pin = GPIO_AC_IN_C3000; 148 sc->sc_batt_cover_pin = GPIO_BATT_COVER_C3000; 149 sc->sc_charge_comp_pin = GPIO_CHRG_CO_C3000; 150 } else { 151 /* XXX */ 152 return; 153 } 154 155 pxa2x0_gpio_set_function(sc->sc_ac_detect_pin, GPIO_IN); 156 pxa2x0_gpio_set_function(sc->sc_charge_comp_pin, GPIO_IN); 157 pxa2x0_gpio_set_function(sc->sc_batt_cover_pin, GPIO_IN); 158 159 (void)pxa2x0_gpio_intr_establish(sc->sc_ac_detect_pin, 160 IST_EDGE_BOTH, IPL_BIO, zapm_acintr, sc); 161 (void)pxa2x0_gpio_intr_establish(sc->sc_charge_comp_pin, 162 IST_EDGE_BOTH, IPL_BIO, zapm_bcintr, sc); 163 164 /* machine-independent part */ 165 sc->events = 0; 166 sc->power_state = APM_SYS_READY; 167 sc->battery_state = APM_BATT_FLAG_UNKNOWN; 168 sc->ac_state = APM_AC_UNKNOWN; 169 sc->battery_life = APM_BATT_LIFE_UNKNOWN; 170 sc->minutes_left = 0; 171 sc->sc_standby_hook = config_hook(CONFIG_HOOK_PMEVENT, 172 CONFIG_HOOK_PMEVENT_STANDBYREQ, 173 CONFIG_HOOK_EXCLUSIVE, 174 zapm_hook, sc); 175 sc->sc_suspend_hook = config_hook(CONFIG_HOOK_PMEVENT, 176 CONFIG_HOOK_PMEVENT_SUSPENDREQ, 177 CONFIG_HOOK_EXCLUSIVE, 178 zapm_hook, sc); 179 180 sc->sc_battery_hook = config_hook(CONFIG_HOOK_PMEVENT, 181 CONFIG_HOOK_PMEVENT_BATTERY, 182 CONFIG_HOOK_SHARE, 183 zapm_hook, sc); 184 185 sc->sc_ac_hook = config_hook(CONFIG_HOOK_PMEVENT, 186 CONFIG_HOOK_PMEVENT_AC, 187 CONFIG_HOOK_SHARE, 188 zapm_hook, sc); 189 190 aaa.accessops = &zapm_accessops; 191 aaa.accesscookie = sc; 192 aaa.apm_detail = 0x0102; 193 194 sc->sc_apmdev = config_found_ia(self, "apmdevif", &aaa, apmprint); 195 if (sc->sc_apmdev != NULL) { 196 zapm_poll1(sc, 0); 197 callout_schedule(&sc->sc_cyclic_poll, CYCLIC_TIME); 198 } 199 } 200 201 static int 202 zapm_hook(void *v, int type, long id, void *msg) 203 { 204 struct zapm_softc *sc = (struct zapm_softc *)v; 205 int charge; 206 int message; 207 int s; 208 209 if (type != CONFIG_HOOK_PMEVENT) 210 return 1; 211 212 if (CONFIG_HOOK_VALUEP(msg)) 213 message = (int)msg; 214 else 215 message = *(int *)msg; 216 217 s = splhigh(); 218 219 switch (id) { 220 case CONFIG_HOOK_PMEVENT_STANDBYREQ: 221 if (sc->power_state != APM_SYS_STANDBY) { 222 sc->events |= (1 << APM_USER_STANDBY_REQ); 223 } else { 224 sc->events |= (1 << APM_NORMAL_RESUME); 225 } 226 break; 227 case CONFIG_HOOK_PMEVENT_SUSPENDREQ: 228 if (sc->power_state != APM_SYS_SUSPEND) { 229 DPRINTF(("zapm: suspend request\n")); 230 sc->events |= (1 << APM_USER_SUSPEND_REQ); 231 } else { 232 sc->events |= (1 << APM_NORMAL_RESUME); 233 } 234 break; 235 case CONFIG_HOOK_PMEVENT_BATTERY: 236 switch (message) { 237 case CONFIG_HOOK_BATT_CRITICAL: 238 DPRINTF(("zapm: battery state critical\n")); 239 charge = sc->battery_state & APM_BATT_FLAG_CHARGING; 240 sc->battery_state = APM_BATT_FLAG_CRITICAL; 241 sc->battery_state |= charge; 242 sc->battery_life = 0; 243 break; 244 case CONFIG_HOOK_BATT_LOW: 245 DPRINTF(("zapm: battery state low\n")); 246 charge = sc->battery_state & APM_BATT_FLAG_CHARGING; 247 sc->battery_state = APM_BATT_FLAG_LOW; 248 sc->battery_state |= charge; 249 break; 250 case CONFIG_HOOK_BATT_HIGH: 251 DPRINTF(("zapm: battery state high\n")); 252 charge = sc->battery_state & APM_BATT_FLAG_CHARGING; 253 sc->battery_state = APM_BATT_FLAG_HIGH; 254 sc->battery_state |= charge; 255 break; 256 case CONFIG_HOOK_BATT_10P: 257 DPRINTF(("zapm: battery life 10%%\n")); 258 sc->battery_life = 10; 259 break; 260 case CONFIG_HOOK_BATT_20P: 261 DPRINTF(("zapm: battery life 20%%\n")); 262 sc->battery_life = 20; 263 break; 264 case CONFIG_HOOK_BATT_30P: 265 DPRINTF(("zapm: battery life 30%%\n")); 266 sc->battery_life = 30; 267 break; 268 case CONFIG_HOOK_BATT_40P: 269 DPRINTF(("zapm: battery life 40%%\n")); 270 sc->battery_life = 40; 271 break; 272 case CONFIG_HOOK_BATT_50P: 273 DPRINTF(("zapm: battery life 50%%\n")); 274 sc->battery_life = 50; 275 break; 276 case CONFIG_HOOK_BATT_60P: 277 DPRINTF(("zapm: battery life 60%%\n")); 278 sc->battery_life = 60; 279 break; 280 case CONFIG_HOOK_BATT_70P: 281 DPRINTF(("zapm: battery life 70%%\n")); 282 sc->battery_life = 70; 283 break; 284 case CONFIG_HOOK_BATT_80P: 285 DPRINTF(("zapm: battery life 80%%\n")); 286 sc->battery_life = 80; 287 break; 288 case CONFIG_HOOK_BATT_90P: 289 DPRINTF(("zapm: battery life 90%%\n")); 290 sc->battery_life = 90; 291 break; 292 case CONFIG_HOOK_BATT_100P: 293 DPRINTF(("zapm: battery life 100%%\n")); 294 sc->battery_life = 100; 295 break; 296 case CONFIG_HOOK_BATT_UNKNOWN: 297 DPRINTF(("zapm: battery state unknown\n")); 298 sc->battery_state = APM_BATT_FLAG_UNKNOWN; 299 sc->battery_life = APM_BATT_LIFE_UNKNOWN; 300 break; 301 case CONFIG_HOOK_BATT_NO_SYSTEM_BATTERY: 302 DPRINTF(("zapm: battery state no system battery?\n")); 303 sc->battery_state = APM_BATT_FLAG_NO_SYSTEM_BATTERY; 304 sc->battery_life = APM_BATT_LIFE_UNKNOWN; 305 break; 306 } 307 break; 308 case CONFIG_HOOK_PMEVENT_AC: 309 switch (message) { 310 case CONFIG_HOOK_AC_OFF: 311 DPRINTF(("zapm: ac not connected\n")); 312 sc->battery_state &= ~APM_BATT_FLAG_CHARGING; 313 sc->ac_state = APM_AC_OFF; 314 break; 315 case CONFIG_HOOK_AC_ON_CHARGE: 316 DPRINTF(("zapm: charging\n")); 317 sc->battery_state |= APM_BATT_FLAG_CHARGING; 318 sc->ac_state = APM_AC_ON; 319 break; 320 case CONFIG_HOOK_AC_ON_NOCHARGE: 321 DPRINTF(("zapm: ac connected\n")); 322 sc->battery_state &= ~APM_BATT_FLAG_CHARGING; 323 sc->ac_state = APM_AC_ON; 324 break; 325 case CONFIG_HOOK_AC_UNKNOWN: 326 sc->ac_state = APM_AC_UNKNOWN; 327 break; 328 } 329 break; 330 } 331 332 splx(s); 333 334 return 0; 335 } 336 337 static void 338 zapm_disconnect(void *v) 339 { 340 #if 0 341 struct zapm_softc *sc = (struct zapm_softc *)v; 342 #endif 343 } 344 345 static void 346 zapm_enable(void *v, int onoff) 347 { 348 #if 0 349 struct zapm_softc *sc = (struct zapm_softc *)v; 350 #endif 351 } 352 353 static int 354 zapm_set_powstate(void *v, u_int devid, u_int powstat) 355 { 356 struct zapm_softc *sc = (struct zapm_softc *)v; 357 358 if (devid != APM_DEV_ALLDEVS) 359 return APM_ERR_UNRECOG_DEV; 360 361 switch (powstat) { 362 case APM_SYS_READY: 363 DPRINTF(("zapm: set power state READY\n")); 364 sc->power_state = APM_SYS_READY; 365 break; 366 case APM_SYS_STANDBY: 367 DPRINTF(("zapm: set power state STANDBY\n")); 368 /* XXX */ 369 DPRINTF(("zapm: resume\n")); 370 break; 371 case APM_SYS_SUSPEND: 372 DPRINTF(("zapm: set power state SUSPEND...\n")); 373 /* XXX */ 374 DPRINTF(("zapm: resume\n")); 375 break; 376 case APM_SYS_OFF: 377 DPRINTF(("zapm: set power state OFF\n")); 378 sc->power_state = APM_SYS_OFF; 379 break; 380 case APM_LASTREQ_INPROG: 381 /*DPRINTF(("zapm: set power state INPROG\n"));*/ 382 break; 383 case APM_LASTREQ_REJECTED: 384 DPRINTF(("zapm: set power state REJECTED\n")); 385 break; 386 } 387 388 return 0; 389 } 390 391 static int 392 zapm_get_powstat(void *v, struct apm_power_info *pinfo) 393 { 394 struct zapm_softc *sc = (struct zapm_softc *)v; 395 int val; 396 397 if (config_hook_call(CONFIG_HOOK_GET, 398 CONFIG_HOOK_ACADAPTER, &val) != -1) 399 pinfo->ac_state = val; 400 else 401 pinfo->ac_state = sc->ac_state; 402 if (config_hook_call(CONFIG_HOOK_GET, 403 CONFIG_HOOK_CHARGE, &val) != -1) 404 pinfo->battery_state = val; 405 else 406 pinfo->battery_state = sc->battery_state; 407 if (config_hook_call(CONFIG_HOOK_GET, 408 CONFIG_HOOK_BATTERYVAL, &val) != -1) 409 pinfo->battery_life = val; 410 else 411 pinfo->battery_life = sc->battery_life; 412 413 return 0; 414 } 415 416 static int 417 zapm_get_event(void *v, u_int *event_type, u_int *event_info) 418 { 419 struct zapm_softc *sc = (struct zapm_softc *)v; 420 u_int ev; 421 int s; 422 423 s = splhigh(); 424 for (ev = APM_STANDBY_REQ; ev <= APM_CAP_CHANGE; ev++) { 425 if (sc->events & (1 << ev)) { 426 sc->events &= ~(1 << ev); 427 *event_type = ev; 428 if (*event_type == APM_NORMAL_RESUME || 429 *event_type == APM_CRIT_RESUME) { 430 /* pccard power off in the suspend state */ 431 *event_info = 1; 432 sc->power_state = APM_SYS_READY; 433 } else { 434 *event_info = 0; 435 } 436 splx(s); 437 438 return 0; 439 } 440 } 441 splx(s); 442 443 return APM_ERR_NOEVENTS; 444 } 445 446 static void 447 zapm_cpu_busy(void *v) 448 { 449 #if 0 450 struct zapm_softc *sc = (struct zapm_softc *)v; 451 #endif 452 } 453 454 static void 455 zapm_cpu_idle(void *v) 456 { 457 #if 0 458 struct zapm_softc *sc = (struct zapm_softc *)v; 459 #endif 460 } 461 462 static void 463 zapm_get_capabilities(void *v, u_int *numbatts, u_int *capflags) 464 { 465 #if 0 466 struct zapm_softc *sc = (struct zapm_softc *)v; 467 #endif 468 469 *numbatts = 1; 470 *capflags = 0 /* | APM_GLOBAL_STANDBY | APM_GLOBAL_SUSPEND */; 471 } 472 473 /*----------------------------------------------------------------------------- 474 * zaurus depent part 475 */ 476 /* MAX1111 command word */ 477 #define MAXCTRL_PD0 (1<<0) 478 #define MAXCTRL_PD1 (1<<1) 479 #define MAXCTRL_SGL (1<<2) 480 #define MAXCTRL_UNI (1<<3) 481 #define MAXCTRL_SEL_SHIFT 4 482 #define MAXCTRL_STR (1<<7) 483 484 /* MAX1111 ADC channels */ 485 #define BATT_THM 2 486 #define BATT_AD 4 487 #define JK_VAD 6 488 489 /* 490 * Battery-specific information 491 */ 492 struct battery_threshold { 493 int percent; 494 int value; 495 int state; 496 }; 497 498 struct battery_info { 499 const struct battery_threshold *bi_thres; 500 }; 501 502 static const struct battery_threshold zaurus_battery_life_c3000[] = { 503 { 100, 194, CONFIG_HOOK_BATT_HIGH }, 504 { 75, 188, CONFIG_HOOK_BATT_HIGH }, 505 { 50, 184, CONFIG_HOOK_BATT_HIGH }, 506 { 25, 180, CONFIG_HOOK_BATT_LOW }, 507 { 5, 178, CONFIG_HOOK_BATT_LOW }, 508 { 0, 0, CONFIG_HOOK_BATT_CRITICAL } 509 }; 510 511 static const struct battery_info zaurus_battery_c3000 = { 512 zaurus_battery_life_c3000 513 }; 514 515 static const struct battery_info *zaurus_main_battery = &zaurus_battery_c3000; 516 517 /* Restart charging this many times before accepting BATT_FULL. */ 518 #define MIN_BATT_FULL 2 519 520 /* Discharge 100 ms before reading the voltage if AC is connected. */ 521 #define DISCHARGE_TIMEOUT (hz / 10) 522 523 /* Check battery voltage and "kick charging" every minute. */ 524 static const struct timeval zapm_battchkrate = { 60, 0 }; 525 526 static int zapm_get_ac_state(struct zapm_softc *); 527 static int zapm_get_battery_compartment_state(struct zapm_softc *); 528 static int zapm_get_charge_complete_state(struct zapm_softc *); 529 static void zapm_set_charging(struct zapm_softc *, int); 530 static int zapm_charge_complete(struct zapm_softc *); 531 static int max1111_adc_value_avg(int, int); 532 static int zapm_get_battery_volt(void); 533 static int zapm_battery_state(int volt); 534 static int zapm_battery_life(int volt); 535 536 static int 537 zapm_acintr(void *v) 538 { 539 540 zapm_poll1(v, 1); 541 542 return 1; 543 } 544 545 static int 546 zapm_bcintr(void *v) 547 { 548 549 zapm_poll1(v, 1); 550 551 return 1; 552 } 553 554 static void 555 zapm_cyclic(void *v) 556 { 557 struct zapm_softc *sc = (struct zapm_softc *)v; 558 559 zapm_poll1(sc, 1); 560 561 callout_schedule(&sc->sc_cyclic_poll, CYCLIC_TIME); 562 } 563 564 static void 565 zapm_poll(void *v) 566 { 567 568 zapm_poll1(v, 1); 569 } 570 571 static int 572 zapm_get_ac_state(struct zapm_softc *sc) 573 { 574 575 if (!pxa2x0_gpio_get_bit(sc->sc_ac_detect_pin)) 576 return APM_AC_ON; 577 return APM_AC_OFF; 578 } 579 580 static int 581 zapm_get_battery_compartment_state(struct zapm_softc *sc) 582 { 583 584 return pxa2x0_gpio_get_bit(sc->sc_batt_cover_pin); 585 } 586 587 static int 588 zapm_get_charge_complete_state(struct zapm_softc *sc) 589 { 590 591 return pxa2x0_gpio_get_bit(sc->sc_charge_comp_pin); 592 } 593 594 static void 595 zapm_set_charging(struct zapm_softc *sc, int enable) 596 { 597 598 scoop_discharge_battery(0); 599 scoop_charge_battery(enable, 0); 600 scoop_led_set(SCOOP_LED_ORANGE, enable); 601 } 602 603 /* 604 * Return non-zero if the charge complete signal indicates that the 605 * battery is fully charged. Restart charging to clear this signal. 606 */ 607 static int 608 zapm_charge_complete(struct zapm_softc *sc) 609 { 610 611 if (sc->charging && sc->battery_full_cnt < MIN_BATT_FULL) { 612 if (zapm_get_charge_complete_state(sc)) { 613 sc->battery_full_cnt++; 614 if (sc->battery_full_cnt < MIN_BATT_FULL) { 615 DPRINTF(("battery almost full\n")); 616 zapm_set_charging(sc, 0); 617 delay(15000); 618 zapm_set_charging(sc, 1); 619 } 620 } else if (sc->battery_full_cnt > 0) { 621 /* false alarm */ 622 sc->battery_full_cnt = 0; 623 zapm_set_charging(sc, 0); 624 delay(15000); 625 zapm_set_charging(sc, 1); 626 } 627 } 628 629 return (sc->battery_full_cnt >= MIN_BATT_FULL); 630 } 631 632 static int 633 max1111_adc_value(int chan) 634 { 635 636 return ((int)zssp_ic_send(ZSSP_IC_MAX1111, MAXCTRL_PD0 | 637 MAXCTRL_PD1 | MAXCTRL_SGL | MAXCTRL_UNI | 638 (chan << MAXCTRL_SEL_SHIFT) | MAXCTRL_STR)); 639 } 640 641 /* XXX simplify */ 642 static int 643 max1111_adc_value_avg(int chan, int pause) 644 { 645 int val[5]; 646 int i, j, k, x; 647 int sum = 0; 648 649 DPRINTF(("max1111_adc_value_avg: chan = %d, pause = %d\n", 650 chan, pause)); 651 652 for (i = 0; i < 5; i++) { 653 val[i] = max1111_adc_value(chan); 654 if (i != 4) 655 delay(pause * 1000); 656 DPRINTF(("max1111_adc_value_avg: chan[%d] = %d\n", i, val[i])); 657 } 658 659 x = val[0]; 660 j = 0; 661 for (i = 1; i < 5; i++) { 662 if (x < val[i]) { 663 x = val[i]; 664 j = i; 665 } 666 } 667 668 x = val[4]; 669 k = 4; 670 for (i = 3; i >= 0; i--) { 671 if (x > val[i]) { 672 x = val[i]; 673 k = i; 674 } 675 } 676 677 DPRINTF(("max1111_adc_value_avg: j = %d, k = %d\n", j, k)); 678 for (i = 0; i < 5; i++) { 679 if (i == j || i == k) 680 continue; 681 sum += val[i]; 682 } 683 684 DPRINTF(("max1111_adc_value_avg: sum = %d, sum / 3 = %d\n", 685 sum, sum / 3)); 686 687 return sum / 3; 688 } 689 690 static int 691 zapm_get_battery_volt(void) 692 { 693 694 return max1111_adc_value_avg(BATT_AD, 10); 695 } 696 697 static int 698 zapm_battery_state(int volt) 699 { 700 const struct battery_threshold *bthr; 701 int i; 702 703 bthr = zaurus_main_battery->bi_thres; 704 705 for (i = 0; bthr[i].value > 0; i++) 706 if (bthr[i].value <= volt) 707 break; 708 709 return bthr[i].state; 710 } 711 712 static int 713 zapm_battery_life(int volt) 714 { 715 const struct battery_threshold *bthr; 716 int i; 717 718 bthr = zaurus_main_battery->bi_thres; 719 720 for (i = 0; bthr[i].value > 0; i++) 721 if (bthr[i].value <= volt) 722 break; 723 724 if (i == 0) 725 return bthr[0].percent; 726 727 return (bthr[i].percent + 728 ((volt - bthr[i].value) * 100) / 729 (bthr[i-1].value - bthr[i].value) * 730 (bthr[i-1].percent - bthr[i].percent) / 100); 731 } 732 733 /* 734 * Poll power-management related GPIO inputs, update battery life 735 * in softc, and/or control battery charging. 736 */ 737 static void 738 zapm_poll1(void *v, int do_suspend) 739 { 740 struct zapm_softc *sc = (struct zapm_softc *)v; 741 int ac_state; 742 int bc_lock; 743 int charging; 744 int volt; 745 int s; 746 747 s = splhigh(); 748 749 ac_state = zapm_get_ac_state(sc); 750 bc_lock = zapm_get_battery_compartment_state(sc); 751 752 /* Stop discharging. */ 753 if (sc->discharging) { 754 sc->discharging = 0; 755 charging = 0; 756 volt = zapm_get_battery_volt(); 757 DPRINTF(("zapm_poll: discharge off volt %d\n", volt)); 758 } else { 759 charging = sc->battery_state & APM_BATT_FLAG_CHARGING; 760 volt = sc->battery_volt; 761 } 762 763 /* Start or stop charging as necessary. */ 764 if (ac_state && bc_lock) { 765 int charge_completed = zapm_charge_complete(sc); 766 if (charging) { 767 if (charge_completed) { 768 DPRINTF(("zapm_poll: battery is full\n")); 769 charging = 0; 770 zapm_set_charging(sc, 0); 771 } 772 } else if (!charge_completed) { 773 charging = 1; 774 volt = zapm_get_battery_volt(); 775 zapm_set_charging(sc, 1); 776 DPRINTF(("zapm_poll: start charging volt %d\n", volt)); 777 } 778 } else { 779 if (charging) { 780 charging = 0; 781 zapm_set_charging(sc, 0); 782 timerclear(&sc->sc_lastbattchk); 783 DPRINTF(("zapm_poll: stop charging\n")); 784 } 785 sc->battery_full_cnt = 0; 786 } 787 788 /* 789 * Restart charging once in a while. Discharge a few milliseconds 790 * before updating the voltage in our softc if A/C is connected. 791 */ 792 if (bc_lock && ratecheck(&sc->sc_lastbattchk, &zapm_battchkrate)) { 793 if (do_suspend && sc->suspended) { 794 /* XXX */ 795 #if 0 796 DPRINTF(("zapm_poll: suspended %lu %lu\n", 797 sc->lastbattchk.tv_sec, 798 pxa2x0_rtc_getsecs())); 799 if (charging) { 800 zapm_set_charging(sc, 0); 801 delay(15000); 802 zapm_set_charging(sc, 1); 803 pxa2x0_rtc_setalarm(pxa2x0_rtc_getsecs() + 804 zapm_battchkrate.tv_sec + 1); 805 } 806 #endif 807 } else if (ac_state && sc->battery_full_cnt == 0) { 808 DPRINTF(("zapm_poll: discharge on\n")); 809 if (charging) 810 zapm_set_charging(sc, 0); 811 sc->discharging = 1; 812 scoop_discharge_battery(1); 813 callout_schedule(&sc->sc_discharge_poll, 814 DISCHARGE_TIMEOUT); 815 } else if (!ac_state) { 816 volt = zapm_get_battery_volt(); 817 DPRINTF(("zapm_poll: volt %d\n", volt)); 818 } 819 } 820 821 /* Update the cached power state in our softc. */ 822 if ((ac_state != sc->ac_state) 823 || (charging != (sc->battery_state & APM_BATT_FLAG_CHARGING))) { 824 config_hook_call(CONFIG_HOOK_PMEVENT, 825 CONFIG_HOOK_PMEVENT_AC, 826 (void *)((ac_state == APM_AC_OFF) 827 ? CONFIG_HOOK_AC_OFF 828 : (charging ? CONFIG_HOOK_AC_ON_CHARGE 829 : CONFIG_HOOK_AC_ON_NOCHARGE))); 830 } 831 if (volt != sc->battery_volt) { 832 sc->battery_volt = volt; 833 sc->battery_life = zapm_battery_life(volt); 834 config_hook_call(CONFIG_HOOK_PMEVENT, 835 CONFIG_HOOK_PMEVENT_BATTERY, 836 (void *)zapm_battery_state(volt)); 837 } 838 839 splx(s); 840 } 841
Indexes created Mon Oct 20 20:10:13 GMT 2025