kern_pmf.c revision 1.9.4.2
1 /* $NetBSD: kern_pmf.c,v 1.9.4.2 2007/12/26 19:17:22 ad Exp $ */ 2 3 /*- 4 * Copyright (c) 2007 Jared D. McNeill <jmcneill (at) invisible.ca> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Jared D. McNeill. 18 * 4. Neither the name of The NetBSD Foundation nor the names of its 19 * contributors may be used to endorse or promote products derived 20 * from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 32 * POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 #include <sys/cdefs.h> 36 __KERNEL_RCSID(0, "$NetBSD: kern_pmf.c,v 1.9.4.2 2007/12/26 19:17:22 ad Exp $"); 37 38 #include <sys/types.h> 39 #include <sys/param.h> 40 #include <sys/malloc.h> 41 #include <sys/buf.h> 42 #include <sys/callout.h> 43 #include <sys/kernel.h> 44 #include <sys/device.h> 45 #include <sys/pmf.h> 46 #include <sys/queue.h> 47 #include <sys/syscallargs.h> /* for sys_sync */ 48 #include <sys/workqueue.h> 49 #include <prop/proplib.h> 50 51 #ifdef PMF_DEBUG 52 int pmf_debug_event; 53 int pmf_debug_idle; 54 int pmf_debug_transition; 55 56 #define PMF_EVENT_PRINTF(x) if (pmf_debug_event) printf x 57 #define PMF_IDLE_PRINTF(x) if (pmf_debug_idle) printf x 58 #define PMF_TRANSITION_PRINTF(x) if (pmf_debug_transition) printf x 59 #define PMF_TRANSITION_PRINTF2(y,x) if (pmf_debug_transition>y) printf x 60 #else 61 #define PMF_EVENT_PRINTF(x) do { } while (0) 62 #define PMF_IDLE_PRINTF(x) do { } while (0) 63 #define PMF_TRANSITION_PRINTF(x) do { } while (0) 64 #define PMF_TRANSITION_PRINTF2(y,x) do { } while (0) 65 #endif 66 67 /* #define PMF_DEBUG */ 68 69 MALLOC_DEFINE(M_PMF, "pmf", "device pmf messaging memory"); 70 71 static prop_dictionary_t pmf_platform = NULL; 72 static struct workqueue *pmf_event_workqueue; 73 74 typedef struct pmf_event_handler { 75 TAILQ_ENTRY(pmf_event_handler) pmf_link; 76 pmf_generic_event_t pmf_event; 77 void (*pmf_handler)(device_t); 78 device_t pmf_device; 79 bool pmf_global; 80 } pmf_event_handler_t; 81 82 static TAILQ_HEAD(, pmf_event_handler) pmf_all_events = 83 TAILQ_HEAD_INITIALIZER(pmf_all_events); 84 85 typedef struct pmf_event_workitem { 86 struct work pew_work; 87 pmf_generic_event_t pew_event; 88 device_t pew_device; 89 } pmf_event_workitem_t; 90 91 static void 92 pmf_event_worker(struct work *wk, void *dummy) 93 { 94 pmf_event_workitem_t *pew; 95 pmf_event_handler_t *event; 96 97 pew = (void *)wk; 98 KASSERT(wk == &pew->pew_work); 99 KASSERT(pew != NULL); 100 101 TAILQ_FOREACH(event, &pmf_all_events, pmf_link) { 102 if (event->pmf_event != pew->pew_event) 103 continue; 104 if (event->pmf_device == pew->pew_device || event->pmf_global) 105 (*event->pmf_handler)(event->pmf_device); 106 } 107 108 free(pew, M_TEMP); 109 110 return; 111 } 112 113 static bool 114 pmf_check_system_drivers(void) 115 { 116 device_t curdev; 117 bool unsupported_devs; 118 119 unsupported_devs = false; 120 TAILQ_FOREACH(curdev, &alldevs, dv_list) { 121 if (device_pmf_is_registered(curdev)) 122 continue; 123 if (!unsupported_devs) 124 printf("Devices without power management support:"); 125 printf(" %s", device_xname(curdev)); 126 unsupported_devs = true; 127 } 128 if (unsupported_devs) { 129 printf("\n"); 130 return false; 131 } 132 return true; 133 } 134 135 bool 136 pmf_system_bus_resume(void) 137 { 138 int depth, maxdepth; 139 bool rv; 140 device_t curdev; 141 142 maxdepth = 0; 143 TAILQ_FOREACH(curdev, &alldevs, dv_list) { 144 if (curdev->dv_depth > maxdepth) 145 maxdepth = curdev->dv_depth; 146 } 147 ++maxdepth; 148 149 aprint_debug("Powering devices:"); 150 /* D0 handlers are run in order */ 151 depth = 0; 152 rv = true; 153 for (depth = 0; depth < maxdepth; ++depth) { 154 TAILQ_FOREACH(curdev, &alldevs, dv_list) { 155 if (!device_pmf_is_registered(curdev)) 156 continue; 157 if (device_is_active(curdev) || 158 !device_is_enabled(curdev)) 159 continue; 160 if (curdev->dv_depth != depth) 161 continue; 162 163 aprint_debug(" %s", device_xname(curdev)); 164 165 if (!device_pmf_bus_resume(curdev)) 166 aprint_debug("(failed)"); 167 } 168 } 169 aprint_debug("\n"); 170 171 return rv; 172 } 173 174 bool 175 pmf_system_resume(void) 176 { 177 int depth, maxdepth; 178 bool rv; 179 device_t curdev, parent; 180 181 if (!pmf_check_system_drivers()) 182 return false; 183 184 maxdepth = 0; 185 TAILQ_FOREACH(curdev, &alldevs, dv_list) { 186 if (curdev->dv_depth > maxdepth) 187 maxdepth = curdev->dv_depth; 188 } 189 ++maxdepth; 190 191 aprint_debug("Resuming devices:"); 192 /* D0 handlers are run in order */ 193 depth = 0; 194 rv = true; 195 for (depth = 0; depth < maxdepth; ++depth) { 196 TAILQ_FOREACH(curdev, &alldevs, dv_list) { 197 if (device_is_active(curdev) || 198 !device_is_enabled(curdev)) 199 continue; 200 if (curdev->dv_depth != depth) 201 continue; 202 parent = device_parent(curdev); 203 if (parent != NULL && 204 !device_is_active(parent)) 205 continue; 206 207 aprint_debug(" %s", device_xname(curdev)); 208 209 if (!pmf_device_resume(curdev)) { 210 rv = false; 211 aprint_debug("(failed)"); 212 } 213 } 214 } 215 aprint_debug(".\n"); 216 217 return rv; 218 } 219 220 bool 221 pmf_system_suspend(void) 222 { 223 int depth, maxdepth; 224 device_t curdev; 225 226 if (!pmf_check_system_drivers()) 227 return false; 228 229 /* 230 * Flush buffers only if the shutdown didn't do so 231 * already and if there was no panic. 232 */ 233 if (doing_shutdown == 0 && panicstr == NULL) { 234 printf("Flushing disk caches: "); 235 sys_sync(NULL, NULL, NULL); 236 if (buf_syncwait() != 0) 237 printf("giving up\n"); 238 else 239 printf("done\n"); 240 } 241 242 aprint_debug("Suspending devices:"); 243 244 maxdepth = 0; 245 TAILQ_FOREACH(curdev, &alldevs, dv_list) { 246 if (curdev->dv_depth > maxdepth) 247 maxdepth = curdev->dv_depth; 248 } 249 250 for (depth = maxdepth; depth >= 0; --depth) { 251 TAILQ_FOREACH_REVERSE(curdev, &alldevs, devicelist, dv_list) { 252 if (curdev->dv_depth != depth) 253 continue; 254 if (!device_is_active(curdev)) 255 continue; 256 257 aprint_debug(" %s", device_xname(curdev)); 258 259 /* XXX joerg check return value and abort suspend */ 260 if (!pmf_device_suspend(curdev)) 261 aprint_debug("(failed)"); 262 } 263 } 264 265 aprint_debug(".\n"); 266 267 return true; 268 } 269 270 void 271 pmf_system_shutdown(void) 272 { 273 int depth, maxdepth; 274 device_t curdev; 275 276 if (!pmf_check_system_drivers()) 277 delay(2000000); 278 279 aprint_debug("Shutting down devices:"); 280 281 maxdepth = 0; 282 TAILQ_FOREACH(curdev, &alldevs, dv_list) { 283 if (curdev->dv_depth > maxdepth) 284 maxdepth = curdev->dv_depth; 285 } 286 287 for (depth = maxdepth; depth >= 0; --depth) { 288 TAILQ_FOREACH_REVERSE(curdev, &alldevs, devicelist, dv_list) { 289 if (curdev->dv_depth != depth) 290 continue; 291 if (!device_is_active(curdev)) 292 continue; 293 294 aprint_debug(" %s", device_xname(curdev)); 295 296 if (!device_pmf_is_registered(curdev)) 297 continue; 298 if (!device_pmf_class_suspend(curdev)) { 299 aprint_debug("(failed)"); 300 continue; 301 } 302 if (!device_pmf_driver_suspend(curdev)) { 303 aprint_debug("(failed)"); 304 continue; 305 } 306 } 307 } 308 309 aprint_debug(".\n"); 310 } 311 312 bool 313 pmf_set_platform(const char *key, const char *value) 314 { 315 if (pmf_platform == NULL) 316 pmf_platform = prop_dictionary_create(); 317 if (pmf_platform == NULL) 318 return false; 319 320 return prop_dictionary_set_cstring(pmf_platform, key, value); 321 } 322 323 const char * 324 pmf_get_platform(const char *key) 325 { 326 const char *value; 327 328 if (pmf_platform == NULL) 329 return NULL; 330 331 if (!prop_dictionary_get_cstring_nocopy(pmf_platform, key, &value)) 332 return NULL; 333 334 return value; 335 } 336 337 bool 338 pmf_device_register(device_t dev, 339 bool (*suspend)(device_t), bool (*resume)(device_t)) 340 { 341 device_pmf_driver_register(dev, suspend, resume); 342 343 if (!device_pmf_driver_child_register(dev)) { 344 device_pmf_driver_deregister(dev); 345 return false; 346 } 347 348 return true; 349 } 350 351 void 352 pmf_device_deregister(device_t dev) 353 { 354 device_pmf_class_deregister(dev); 355 device_pmf_bus_deregister(dev); 356 device_pmf_driver_deregister(dev); 357 } 358 359 bool 360 pmf_device_suspend(device_t dev) 361 { 362 PMF_TRANSITION_PRINTF(("%s: suspend enter\n", device_xname(dev))); 363 if (!device_pmf_is_registered(dev)) 364 return false; 365 PMF_TRANSITION_PRINTF2(1, ("%s: class suspend\n", device_xname(dev))); 366 if (!device_pmf_class_suspend(dev)) 367 return false; 368 PMF_TRANSITION_PRINTF2(1, ("%s: driver suspend\n", device_xname(dev))); 369 if (!device_pmf_driver_suspend(dev)) 370 return false; 371 PMF_TRANSITION_PRINTF2(1, ("%s: bus suspend\n", device_xname(dev))); 372 if (!device_pmf_bus_suspend(dev)) 373 return false; 374 PMF_TRANSITION_PRINTF(("%s: suspend exit\n", device_xname(dev))); 375 return true; 376 } 377 378 bool 379 pmf_device_resume(device_t dev) 380 { 381 PMF_TRANSITION_PRINTF(("%s: resume enter\n", device_xname(dev))); 382 if (!device_pmf_is_registered(dev)) 383 return false; 384 PMF_TRANSITION_PRINTF2(1, ("%s: bus resume\n", device_xname(dev))); 385 if (!device_pmf_bus_resume(dev)) 386 return false; 387 PMF_TRANSITION_PRINTF2(1, ("%s: driver resume\n", device_xname(dev))); 388 if (!device_pmf_driver_resume(dev)) 389 return false; 390 PMF_TRANSITION_PRINTF2(1, ("%s: class resume\n", device_xname(dev))); 391 if (!device_pmf_class_resume(dev)) 392 return false; 393 PMF_TRANSITION_PRINTF(("%s: resume exit\n", device_xname(dev))); 394 return true; 395 } 396 397 bool 398 pmf_device_recursive_suspend(device_t dv) 399 { 400 device_t curdev; 401 402 if (!device_is_active(dv)) 403 return true; 404 405 TAILQ_FOREACH(curdev, &alldevs, dv_list) { 406 if (device_parent(curdev) != dv) 407 continue; 408 if (!pmf_device_recursive_suspend(curdev)) 409 return false; 410 } 411 412 return pmf_device_suspend(dv); 413 } 414 415 bool 416 pmf_device_recursive_resume(device_t dv) 417 { 418 device_t parent; 419 420 if (device_is_active(dv)) 421 return true; 422 423 parent = device_parent(dv); 424 if (parent != NULL) { 425 if (!pmf_device_recursive_resume(parent)) 426 return false; 427 } 428 429 return pmf_device_resume(dv); 430 } 431 432 bool 433 pmf_device_resume_subtree(device_t dv) 434 { 435 device_t curdev; 436 437 if (!pmf_device_recursive_resume(dv)) 438 return false; 439 440 TAILQ_FOREACH(curdev, &alldevs, dv_list) { 441 if (device_parent(curdev) != dv) 442 continue; 443 if (!pmf_device_resume_subtree(curdev)) 444 return false; 445 } 446 return true; 447 } 448 449 #include <net/if.h> 450 451 static bool 452 pmf_class_network_suspend(device_t dev) 453 { 454 struct ifnet *ifp = device_pmf_class_private(dev); 455 int s; 456 457 s = splnet(); 458 (*ifp->if_stop)(ifp, 1); 459 splx(s); 460 461 return true; 462 } 463 464 static bool 465 pmf_class_network_resume(device_t dev) 466 { 467 struct ifnet *ifp = device_pmf_class_private(dev); 468 int s; 469 470 s = splnet(); 471 if (ifp->if_flags & IFF_UP) { 472 ifp->if_flags &= ~IFF_RUNNING; 473 (*ifp->if_init)(ifp); 474 (*ifp->if_start)(ifp); 475 } 476 splx(s); 477 478 return true; 479 } 480 481 void 482 pmf_class_network_register(device_t dev, struct ifnet *ifp) 483 { 484 device_pmf_class_register(dev, ifp, pmf_class_network_suspend, 485 pmf_class_network_resume, NULL); 486 } 487 488 bool 489 pmf_event_inject(device_t dv, pmf_generic_event_t ev) 490 { 491 pmf_event_workitem_t *pew; 492 493 pew = malloc(sizeof(pmf_event_workitem_t), M_TEMP, M_NOWAIT); 494 if (pew == NULL) { 495 PMF_EVENT_PRINTF(("%s: PMF event %d dropped (no memory)\n", 496 dv ? device_xname(dv) : "<anonymous>", ev)); 497 return false; 498 } 499 500 pew->pew_event = ev; 501 pew->pew_device = dv; 502 503 workqueue_enqueue(pmf_event_workqueue, (void *)pew, NULL); 504 PMF_EVENT_PRINTF(("%s: PMF event %d injected\n", 505 dv ? device_xname(dv) : "<anonymous>", ev)); 506 507 return true; 508 } 509 510 bool 511 pmf_event_register(device_t dv, pmf_generic_event_t ev, 512 void (*handler)(device_t), bool global) 513 { 514 pmf_event_handler_t *event; 515 516 event = malloc(sizeof(*event), M_DEVBUF, M_WAITOK); 517 event->pmf_event = ev; 518 event->pmf_handler = handler; 519 event->pmf_device = dv; 520 event->pmf_global = global; 521 TAILQ_INSERT_TAIL(&pmf_all_events, event, pmf_link); 522 523 return true; 524 } 525 526 void 527 pmf_event_deregister(device_t dv, pmf_generic_event_t ev, 528 void (*handler)(device_t), bool global) 529 { 530 pmf_event_handler_t *event; 531 532 TAILQ_FOREACH(event, &pmf_all_events, pmf_link) { 533 if (event->pmf_event != ev) 534 continue; 535 if (event->pmf_device != dv) 536 continue; 537 if (event->pmf_global != global) 538 continue; 539 if (event->pmf_handler != handler) 540 continue; 541 TAILQ_REMOVE(&pmf_all_events, event, pmf_link); 542 free(event, M_WAITOK); 543 return; 544 } 545 } 546 547 struct display_class_softc { 548 TAILQ_ENTRY(display_class_softc) dc_link; 549 device_t dc_dev; 550 }; 551 552 static TAILQ_HEAD(, display_class_softc) all_displays; 553 static callout_t global_idle_counter; 554 static int idle_timeout = 30; 555 556 static void 557 input_idle(void *dummy) 558 { 559 PMF_IDLE_PRINTF(("Input idle handler called\n")); 560 pmf_event_inject(NULL, PMFE_DISPLAY_OFF); 561 } 562 563 static void 564 input_activity_handler(device_t dv, devactive_t type) 565 { 566 if (!TAILQ_EMPTY(&all_displays)) 567 callout_schedule(&global_idle_counter, idle_timeout * hz); 568 } 569 570 static void 571 pmf_class_input_deregister(device_t dv) 572 { 573 device_active_deregister(dv, input_activity_handler); 574 } 575 576 bool 577 pmf_class_input_register(device_t dv) 578 { 579 if (!device_active_register(dv, input_activity_handler)) 580 return false; 581 582 device_pmf_class_register(dv, NULL, NULL, NULL, 583 pmf_class_input_deregister); 584 585 return true; 586 } 587 588 static void 589 pmf_class_display_deregister(device_t dv) 590 { 591 struct display_class_softc *sc = device_pmf_class_private(dv); 592 int s; 593 594 s = splsoftclock(); 595 TAILQ_REMOVE(&all_displays, sc, dc_link); 596 if (TAILQ_EMPTY(&all_displays)) 597 callout_stop(&global_idle_counter); 598 splx(s); 599 600 free(sc, M_DEVBUF); 601 } 602 603 bool 604 pmf_class_display_register(device_t dv) 605 { 606 struct display_class_softc *sc; 607 int s; 608 609 sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK); 610 611 s = splsoftclock(); 612 if (TAILQ_EMPTY(&all_displays)) 613 callout_schedule(&global_idle_counter, idle_timeout * hz); 614 615 TAILQ_INSERT_HEAD(&all_displays, sc, dc_link); 616 splx(s); 617 618 device_pmf_class_register(dv, sc, NULL, NULL, 619 pmf_class_display_deregister); 620 621 return true; 622 } 623 624 void 625 pmf_init(void) 626 { 627 int err; 628 629 KASSERT(pmf_event_workqueue == NULL); 630 err = workqueue_create(&pmf_event_workqueue, "pmfevent", 631 pmf_event_worker, NULL, PRI_NONE, IPL_VM, 0); 632 if (err) 633 panic("couldn't create pmfevent workqueue"); 634 635 callout_init(&global_idle_counter, 0); 636 callout_setfunc(&global_idle_counter, input_idle, NULL); 637 } 638
Indexes created Tue Sep 30 20:09:53 GMT 2025