sys/platform/pc64/apm/apm.c

   1 /*
   2  * APM (Advanced Power Management) BIOS Device Driver
   3  *
   4  * Copyright (c) 1994 UKAI, Fumitoshi.
   5  * Copyright (c) 1994-1995 by HOSOKAWA, Tatsumi <hosokawa@jp.FreeBSD.org>
   6  * Copyright (c) 1996 Nate Williams <nate@FreeBSD.org>
   7  * Copyright (c) 1997 Poul-Henning Kamp <phk@FreeBSD.org>
   8  *
   9  * This software may be used, modified, copied, and distributed, in
  10  * both source and binary form provided that the above copyright and
  11  * these terms are retained. Under no circumstances is the author
  12  * responsible for the proper functioning of this software, nor does
  13  * the author assume any responsibility for damages incurred with its
  14  * use.
  15  *
  16  * Sep, 1994    Implemented on FreeBSD 1.1.5.1R (Toshiba AVS001WD)
  17  *
  18  * $FreeBSD: src/sys/i386/apm/apm.c,v 1.114.2.5 2002/11/02 04:41:50 iwasaki Exp $
  19  * $DragonFly: src/sys/platform/pc32/apm/apm.c,v 1.21 2006/12/23 00:27:03 swildner Exp $
  20  */
  21
  22 #include <sys/param.h>
  23 #include <sys/systm.h>
  24 #include <sys/eventhandler.h>
  25 #include <sys/conf.h>
  26 #include <sys/device.h>
  27 #include <sys/kernel.h>
  28 #include <sys/time.h>
  29 #include <sys/reboot.h>
  30 #include <sys/bus.h>
  31 #include <sys/event.h>
  32 #include <sys/fcntl.h>
  33 #include <sys/uio.h>
  34 #include <sys/signalvar.h>
  35 #include <sys/sysctl.h>
  36 #include <machine/apm_bios.h>
  37 #include <machine/segments.h>
  38 #include <machine/clock.h>
  39 #include <vm/vm.h>
  40 #include <vm/vm_param.h>
  41 #include <vm/pmap.h>
  42 #include <sys/syslog.h>
  43 #include <sys/thread2.h>
  44
  45 #include <machine/pc/bios.h>
  46 #include <machine/vm86.h>
  47
  48 #include <machine_base/apm/apm.h>
  49
  50 /* Used by the apm_saver screen saver module */
  51 int apm_display (int newstate);
  52 struct apm_softc apm_softc;
  53
  54 static void apm_resume (void);
  55 static int apm_bioscall(void);
  56 static int apm_check_function_supported (u_int version, u_int func);
  57
  58 static u_long   apm_version;
  59
  60 int     apm_evindex;
  61
  62 #define SCFLAG_ONORMAL  0x0000001
  63 #define SCFLAG_OCTL     0x0000002
  64 #define SCFLAG_OPEN     (SCFLAG_ONORMAL|SCFLAG_OCTL)
  65
  66 #define APMDEV(dev)     (minor(dev)&0x0f)
  67 #define APMDEV_NORMAL   0
  68 #define APMDEV_CTL      8
  69
  70 static struct apmhook   *hook[NAPM_HOOK];               /* XXX */
  71
  72 #define is_enabled(foo) ((foo) ? "enabled" : "disabled")
  73
  74 /* Map version number to integer (keeps ordering of version numbers) */
  75 #define INTVERSION(major, minor)        ((major)*100 + (minor))
  76
  77 static struct callout apm_timeout_ch;
  78
  79 static timeout_t apm_timeout;
  80 static d_open_t apmopen;
  81 static d_close_t apmclose;
  82 static d_write_t apmwrite;
  83 static d_ioctl_t apmioctl;
  84 static d_kqfilter_t apmkqfilter;
  85
  86 static void apmfilter_detach(struct knote *);
  87 static int apmfilter_read(struct knote *, long);
  88 static int apmfilter_write(struct knote *, long);
  89
  90 #define CDEV_MAJOR 39
  91 static struct dev_ops apm_ops = {
  92         { "apm", CDEV_MAJOR, 0 },
  93         .d_open =       apmopen,
  94         .d_close =      apmclose,
  95         .d_write =      apmwrite,
  96         .d_ioctl =      apmioctl,
  97         .d_kqfilter =   apmkqfilter
  98 };
  99
 100 static int apm_suspend_delay = 1;
 101 static int apm_standby_delay = 1;
 102 static int apm_debug = 0;
 103
 104 #define APM_DPRINT(args...) do  {                                       \
 105         if (apm_debug) {                                                \
 106                 kprintf(args);                                          \
 107         }                                                               \
 108 } while (0)
 109
 110 SYSCTL_INT(_machdep, OID_AUTO, apm_suspend_delay, CTLFLAG_RW, &apm_suspend_delay, 1, "");
 111 SYSCTL_INT(_machdep, OID_AUTO, apm_standby_delay, CTLFLAG_RW, &apm_standby_delay, 1, "");
 112 SYSCTL_INT(_debug, OID_AUTO, apm_debug, CTLFLAG_RW, &apm_debug, 0, "");
 113
 114 /*
 115  * return  0 if the function successfull,
 116  * return  1 if the function unsuccessfull,
 117  * return -1 if the function unsupported.
 118  */
 119 static int
 120 apm_bioscall(void)
 121 {
 122         struct apm_softc *sc = &apm_softc;
 123         int error = 0;
 124         u_int apm_func = sc->bios.r.eax & 0xff;
 125
 126         if (!apm_check_function_supported(sc->intversion, apm_func)) {
 127                 APM_DPRINT("apm_bioscall: function 0x%x is not supported in v%d.%d\n",
 128                     apm_func, sc->majorversion, sc->minorversion);
 129                 return (-1);
 130         }
 131
 132         sc->bios_busy = 1;
 133         if (sc->connectmode == APM_PROT32CONNECT) {
 134                 set_bios_selectors(&sc->bios.seg,
 135                                    BIOSCODE_FLAG | BIOSDATA_FLAG);
 136                 error = bios32(&sc->bios.r,
 137                                sc->bios.entry, GSEL(GBIOSCODE32_SEL, SEL_KPL));
 138         } else {
 139                 error = bios16(&sc->bios, NULL);
 140         }
 141         sc->bios_busy = 0;
 142         return (error);
 143 }
 144
 145 /* check whether APM function is supported (1)  or not (0). */
 146 static int
 147 apm_check_function_supported(u_int version, u_int func)
 148 {
 149         /* except driver version */
 150         if (func == APM_DRVVERSION) {
 151                 return (1);
 152         }
 153
 154         switch (version) {
 155         case INTVERSION(1, 0):
 156                 if (func > APM_GETPMEVENT) {
 157                         return (0); /* not supported */
 158                 }
 159                 break;
 160         case INTVERSION(1, 1):
 161                 if (func > APM_ENGAGEDISENGAGEPM &&
 162                     func < APM_OEMFUNC) {
 163                         return (0); /* not supported */
 164                 }
 165                 break;
 166         case INTVERSION(1, 2):
 167                 break;
 168         }
 169
 170         return (1); /* supported */
 171 }
 172
 173 /* enable/disable power management */
 174 static int
 175 apm_enable_disable_pm(int enable)
 176 {
 177         struct apm_softc *sc = &apm_softc;
 178
 179         sc->bios.r.eax = (APM_BIOS << 8) | APM_ENABLEDISABLEPM;
 180
 181         if (sc->intversion >= INTVERSION(1, 1))
 182                 sc->bios.r.ebx  = PMDV_ALLDEV;
 183         else
 184                 sc->bios.r.ebx  = 0xffff;       /* APM version 1.0 only */
 185         sc->bios.r.ecx  = enable;
 186         sc->bios.r.edx = 0;
 187         return (apm_bioscall());
 188 }
 189
 190 /* register driver version (APM 1.1 or later) */
 191 static int
 192 apm_driver_version(int version)
 193 {
 194         struct apm_softc *sc = &apm_softc;
 195
 196         sc->bios.r.eax = (APM_BIOS << 8) | APM_DRVVERSION;
 197         sc->bios.r.ebx  = 0x0;
 198         sc->bios.r.ecx  = version;
 199         sc->bios.r.edx = 0;
 200
 201         if (apm_bioscall() == 0 && sc->bios.r.eax == version)
 202                 return (0);
 203
 204         /* Some old BIOSes don't return the connection version in %ax. */
 205         if (sc->bios.r.eax == ((APM_BIOS << 8) | APM_DRVVERSION))
 206                 return (0);
 207
 208         return (1);
 209 }
 210
 211 /* engage/disengage power management (APM 1.1 or later) */
 212 static int
 213 apm_engage_disengage_pm(int engage)
 214 {
 215         struct apm_softc *sc = &apm_softc;
 216
 217         sc->bios.r.eax = (APM_BIOS << 8) | APM_ENGAGEDISENGAGEPM;
 218         sc->bios.r.ebx = PMDV_ALLDEV;
 219         sc->bios.r.ecx = engage;
 220         sc->bios.r.edx = 0;
 221         return (apm_bioscall());
 222 }
 223
 224 /* get PM event */
 225 static u_int
 226 apm_getevent(void)
 227 {
 228         struct apm_softc *sc = &apm_softc;
 229
 230         sc->bios.r.eax = (APM_BIOS << 8) | APM_GETPMEVENT;
 231
 232         sc->bios.r.ebx = 0;
 233         sc->bios.r.ecx = 0;
 234         sc->bios.r.edx = 0;
 235         if (apm_bioscall())
 236                 return (PMEV_NOEVENT);
 237         return (sc->bios.r.ebx & 0xffff);
 238 }
 239
 240 /* suspend entire system */
 241 static int
 242 apm_suspend_system(int state)
 243 {
 244         struct apm_softc *sc = &apm_softc;
 245
 246         sc->bios.r.eax = (APM_BIOS << 8) | APM_SETPWSTATE;
 247         sc->bios.r.ebx = PMDV_ALLDEV;
 248         sc->bios.r.ecx = state;
 249         sc->bios.r.edx = 0;
 250
 251         if (apm_bioscall()) {
 252                 kprintf("Entire system suspend failure: errcode = %d\n",
 253                         0xff & (sc->bios.r.eax >> 8));
 254                 return 1;
 255         }
 256         return 0;
 257 }
 258
 259 /* Display control */
 260 /*
 261  * Experimental implementation: My laptop machine can't handle this function
 262  * If your laptop can control the display via APM, please inform me.
 263  *                            HOSOKAWA, Tatsumi <hosokawa@jp.FreeBSD.org>
 264  */
 265 int
 266 apm_display(int newstate)
 267 {
 268         struct apm_softc *sc = &apm_softc;
 269
 270         sc->bios.r.eax = (APM_BIOS << 8) | APM_SETPWSTATE;
 271         sc->bios.r.ebx = PMDV_DISP0;
 272         sc->bios.r.ecx = newstate ? PMST_APMENABLED:PMST_SUSPEND;
 273         sc->bios.r.edx = 0;
 274         if (apm_bioscall() == 0) {
 275                 return 0;
 276         }
 277
 278         /* If failed, then try to blank all display devices instead. */
 279         sc->bios.r.eax = (APM_BIOS << 8) | APM_SETPWSTATE;
 280         sc->bios.r.ebx = PMDV_DISPALL;  /* all display devices */
 281         sc->bios.r.ecx = newstate ? PMST_APMENABLED:PMST_SUSPEND;
 282         sc->bios.r.edx = 0;
 283         if (apm_bioscall() == 0) {
 284                 return 0;
 285         }
 286         kprintf("Display off failure: errcode = %d\n",
 287                0xff & (sc->bios.r.eax >> 8));
 288         return 1;
 289 }
 290
 291 /*
 292  * Turn off the entire system.
 293  */
 294 static void
 295 apm_power_off(void *junk, int howto)
 296 {
 297         struct apm_softc *sc = &apm_softc;
 298
 299         /* Not halting powering off, or not active */
 300         if (!(howto & RB_POWEROFF) || !apm_softc.active)
 301                 return;
 302         sc->bios.r.eax = (APM_BIOS << 8) | APM_SETPWSTATE;
 303         sc->bios.r.ebx = PMDV_ALLDEV;
 304         sc->bios.r.ecx = PMST_OFF;
 305         sc->bios.r.edx = 0;
 306         apm_bioscall();
 307 }
 308
 309 /* APM Battery low handler */
 310 static void
 311 apm_battery_low(void)
 312 {
 313         kprintf("\007\007 * * * BATTERY IS LOW * * * \007\007");
 314 }
 315
 316 /* APM hook manager */
 317 static struct apmhook *
 318 apm_add_hook(struct apmhook **list, struct apmhook *ah)
 319 {
 320         struct apmhook *p, *prev;
 321
 322         APM_DPRINT("Add hook \"%s\"\n", ah->ah_name);
 323
 324         crit_enter();
 325         if (ah == NULL)
 326                 panic("illegal apm_hook!");
 327         prev = NULL;
 328         for (p = *list; p != NULL; prev = p, p = p->ah_next)
 329                 if (p->ah_order > ah->ah_order)
 330                         break;
 331
 332         if (prev == NULL) {
 333                 ah->ah_next = *list;
 334                 *list = ah;
 335         } else {
 336                 ah->ah_next = prev->ah_next;
 337                 prev->ah_next = ah;
 338         }
 339         crit_exit();
 340         return ah;
 341 }
 342
 343 static void
 344 apm_del_hook(struct apmhook **list, struct apmhook *ah)
 345 {
 346         struct apmhook *p, *prev;
 347
 348         crit_enter();
 349         prev = NULL;
 350         for (p = *list; p != NULL; prev = p, p = p->ah_next)
 351                 if (p == ah)
 352                         goto deleteit;
 353         panic("Tried to delete unregistered apm_hook.");
 354         goto nosuchnode;
 355 deleteit:
 356         if (prev != NULL)
 357                 prev->ah_next = p->ah_next;
 358         else
 359                 *list = p->ah_next;
 360 nosuchnode:
 361         crit_exit();
 362 }
 363
 364
 365 /* APM driver calls some functions automatically */
 366 static void
 367 apm_execute_hook(struct apmhook *list)
 368 {
 369         struct apmhook *p;
 370
 371         for (p = list; p != NULL; p = p->ah_next) {
 372                 APM_DPRINT("Execute APM hook \"%s.\"\n", p->ah_name);
 373                 if ((*(p->ah_fun))(p->ah_arg))
 374                         kprintf("Warning: APM hook \"%s\" failed", p->ah_name);
 375         }
 376 }
 377
 378
 379 /* establish an apm hook */
 380 struct apmhook *
 381 apm_hook_establish(int apmh, struct apmhook *ah)
 382 {
 383         if (apmh < 0 || apmh >= NAPM_HOOK)
 384                 return NULL;
 385
 386         return apm_add_hook(&hook[apmh], ah);
 387 }
 388
 389 /* disestablish an apm hook */
 390 void
 391 apm_hook_disestablish(int apmh, struct apmhook *ah)
 392 {
 393         if (apmh < 0 || apmh >= NAPM_HOOK)
 394                 return;
 395
 396         apm_del_hook(&hook[apmh], ah);
 397 }
 398
 399
 400 static struct timeval suspend_time;
 401 static struct timeval diff_time;
 402
 403 static int
 404 apm_default_resume(void *arg)
 405 {
 406         u_int second, minute, hour;
 407         struct timeval resume_time, tmp_time;
 408
 409         /* modified for adjkerntz */
 410         crit_enter();
 411         timer_restore();                /* restore the all timers */
 412         inittodr(0);                    /* adjust time to RTC */
 413         microtime(&resume_time);
 414         getmicrotime(&tmp_time);
 415         timevaladd(&tmp_time, &diff_time);
 416
 417 #ifdef FIXME
 418         /* XXX THIS DOESN'T WORK!!! */
 419         time = tmp_time;
 420 #endif
 421
 422 #ifdef APM_FIXUP_CALLTODO
 423         /* Calculate the delta time suspended */
 424         timevalsub(&resume_time, &suspend_time);
 425         /* Fixup the calltodo list with the delta time. */
 426         adjust_timeout_calltodo(&resume_time);
 427 #endif /* APM_FIXUP_CALLTODOK */
 428         crit_exit();
 429 #ifndef APM_FIXUP_CALLTODO
 430         second = resume_time.tv_sec - suspend_time.tv_sec;
 431 #else /* APM_FIXUP_CALLTODO */
 432         /*
 433          * We've already calculated resume_time to be the delta between
 434          * the suspend and the resume.
 435          */
 436         second = resume_time.tv_sec;
 437 #endif /* APM_FIXUP_CALLTODO */
 438         hour = second / 3600;
 439         second %= 3600;
 440         minute = second / 60;
 441         second %= 60;
 442         log(LOG_NOTICE, "resumed from suspended mode (slept %02d:%02d:%02d)\n",
 443                 hour, minute, second);
 444         return 0;
 445 }
 446
 447 static int
 448 apm_default_suspend(void *arg)
 449 {
 450         crit_enter();
 451         microtime(&diff_time);
 452         inittodr(0);
 453         microtime(&suspend_time);
 454         timevalsub(&diff_time, &suspend_time);
 455         crit_exit();
 456         return 0;
 457 }
 458
 459 static int apm_record_event (struct apm_softc *, u_int);
 460 static void apm_processevent(void);
 461
 462 static u_int apm_op_inprog = 0;
 463
 464 static void
 465 apm_do_suspend(void)
 466 {
 467         struct apm_softc *sc = &apm_softc;
 468         int error;
 469
 470         if (!sc)
 471                 return;
 472
 473         apm_op_inprog = 0;
 474         sc->suspends = sc->suspend_countdown = 0;
 475
 476         if (sc->initialized) {
 477                 error = DEVICE_SUSPEND(root_bus);
 478                 if (error) {
 479                         DEVICE_RESUME(root_bus);
 480                 } else {
 481                         apm_execute_hook(hook[APM_HOOK_SUSPEND]);
 482                         if (apm_suspend_system(PMST_SUSPEND) == 0) {
 483                                 apm_processevent();
 484                         } else {
 485                                 /* Failure, 'resume' the system again */
 486                                 apm_execute_hook(hook[APM_HOOK_RESUME]);
 487                                 DEVICE_RESUME(root_bus);
 488                         }
 489                 }
 490         }
 491 }
 492
 493 static void
 494 apm_do_standby(void)
 495 {
 496         struct apm_softc *sc = &apm_softc;
 497
 498         if (!sc)
 499                 return;
 500
 501         apm_op_inprog = 0;
 502         sc->standbys = sc->standby_countdown = 0;
 503
 504         if (sc->initialized) {
 505                 /*
 506                  * As far as standby, we don't need to execute
 507                  * all of suspend hooks.
 508                  */
 509                 apm_default_suspend(&apm_softc);
 510                 if (apm_suspend_system(PMST_STANDBY) == 0)
 511                         apm_processevent();
 512         }
 513 }
 514
 515 static void
 516 apm_lastreq_notify(void)
 517 {
 518         struct apm_softc *sc = &apm_softc;
 519
 520         sc->bios.r.eax = (APM_BIOS << 8) | APM_SETPWSTATE;
 521         sc->bios.r.ebx = PMDV_ALLDEV;
 522         sc->bios.r.ecx = PMST_LASTREQNOTIFY;
 523         sc->bios.r.edx = 0;
 524         apm_bioscall();
 525 }
 526
 527 static int
 528 apm_lastreq_rejected(void)
 529 {
 530         struct apm_softc *sc = &apm_softc;
 531
 532         if (apm_op_inprog == 0) {
 533                 return 1;       /* no operation in progress */
 534         }
 535
 536         sc->bios.r.eax = (APM_BIOS << 8) | APM_SETPWSTATE;
 537         sc->bios.r.ebx = PMDV_ALLDEV;
 538         sc->bios.r.ecx = PMST_LASTREQREJECT;
 539         sc->bios.r.edx = 0;
 540
 541         if (apm_bioscall()) {
 542                 APM_DPRINT("apm_lastreq_rejected: failed\n");
 543                 return 1;
 544         }
 545         apm_op_inprog = 0;
 546         return 0;
 547 }
 548
 549 /*
 550  * Public interface to the suspend/resume:
 551  *
 552  * Execute suspend and resume hook before and after sleep, respectively.
 553  *
 554  */
 555
 556 void
 557 apm_suspend(int state)
 558 {
 559         struct apm_softc *sc = &apm_softc;
 560
 561         if (!sc->initialized)
 562                 return;
 563
 564         switch (state) {
 565         case PMST_SUSPEND:
 566                 if (sc->suspends)
 567                         return;
 568                 sc->suspends++;
 569                 sc->suspend_countdown = apm_suspend_delay;
 570                 break;
 571         case PMST_STANDBY:
 572                 if (sc->standbys)
 573                         return;
 574                 sc->standbys++;
 575                 sc->standby_countdown = apm_standby_delay;
 576                 break;
 577         default:
 578                 kprintf("apm_suspend: Unknown Suspend state 0x%x\n", state);
 579                 return;
 580         }
 581
 582         apm_op_inprog++;
 583         apm_lastreq_notify();
 584 }
 585
 586 void
 587 apm_resume(void)
 588 {
 589         struct apm_softc *sc = &apm_softc;
 590
 591         if (!sc)
 592                 return;
 593
 594         if (sc->initialized) {
 595                 apm_execute_hook(hook[APM_HOOK_RESUME]);
 596                 DEVICE_RESUME(root_bus);
 597         }
 598 }
 599
 600
 601 /* get power status per battery */
 602 static int
 603 apm_get_pwstatus(apm_pwstatus_t app)
 604 {
 605         struct apm_softc *sc = &apm_softc;
 606
 607         if (app->ap_device != PMDV_ALLDEV &&
 608             (app->ap_device < PMDV_BATT0 || app->ap_device > PMDV_BATT_ALL))
 609                 return 1;
 610
 611         sc->bios.r.eax = (APM_BIOS << 8) | APM_GETPWSTATUS;
 612         sc->bios.r.ebx = app->ap_device;
 613         sc->bios.r.ecx = 0;
 614         sc->bios.r.edx = 0xffff;        /* default to unknown battery time */
 615
 616         if (apm_bioscall())
 617                 return 1;
 618
 619         app->ap_acline    = (sc->bios.r.ebx >> 8) & 0xff;
 620         app->ap_batt_stat = sc->bios.r.ebx & 0xff;
 621         app->ap_batt_flag = (sc->bios.r.ecx >> 8) & 0xff;
 622         app->ap_batt_life = sc->bios.r.ecx & 0xff;
 623         sc->bios.r.edx &= 0xffff;
 624         if (sc->bios.r.edx == 0xffff)   /* Time is unknown */
 625                 app->ap_batt_time = -1;
 626         else if (sc->bios.r.edx & 0x8000)       /* Time is in minutes */
 627                 app->ap_batt_time = (sc->bios.r.edx & 0x7fff) * 60;
 628         else                            /* Time is in seconds */
 629                 app->ap_batt_time = sc->bios.r.edx;
 630
 631         return 0;
 632 }
 633
 634
 635 /* get APM information */
 636 static int
 637 apm_get_info(apm_info_t aip)
 638 {
 639         struct apm_softc *sc = &apm_softc;
 640         struct apm_pwstatus aps;
 641
 642         bzero(&aps, sizeof(aps));
 643         aps.ap_device = PMDV_ALLDEV;
 644         if (apm_get_pwstatus(&aps))
 645                 return 1;
 646
 647         aip->ai_infoversion = 1;
 648         aip->ai_acline      = aps.ap_acline;
 649         aip->ai_batt_stat   = aps.ap_batt_stat;
 650         aip->ai_batt_life   = aps.ap_batt_life;
 651         aip->ai_batt_time   = aps.ap_batt_time;
 652         aip->ai_major       = (u_int)sc->majorversion;
 653         aip->ai_minor       = (u_int)sc->minorversion;
 654         aip->ai_status      = (u_int)sc->active;
 655
 656         sc->bios.r.eax = (APM_BIOS << 8) | APM_GETCAPABILITIES;
 657         sc->bios.r.ebx = 0;
 658         sc->bios.r.ecx = 0;
 659         sc->bios.r.edx = 0;
 660         if (apm_bioscall()) {
 661                 aip->ai_batteries = -1; /* Unknown */
 662                 aip->ai_capabilities = 0xff00; /* Unknown, with no bits set */
 663         } else {
 664                 aip->ai_batteries = sc->bios.r.ebx & 0xff;
 665                 aip->ai_capabilities = sc->bios.r.ecx & 0xf;
 666         }
 667
 668         bzero(aip->ai_spare, sizeof aip->ai_spare);
 669
 670         return 0;
 671 }
 672
 673
 674 /* inform APM BIOS that CPU is idle */
 675 void
 676 apm_cpu_idle(void)
 677 {
 678         struct apm_softc *sc = &apm_softc;
 679
 680         if (sc->active) {
 681
 682                 sc->bios.r.eax = (APM_BIOS <<8) | APM_CPUIDLE;
 683                 sc->bios.r.edx = sc->bios.r.ecx = sc->bios.r.ebx = 0;
 684                 apm_bioscall();
 685         }
 686         /*
 687          * Some APM implementation halts CPU in BIOS, whenever
 688          * "CPU-idle" function are invoked, but swtch() of
 689          * FreeBSD halts CPU, therefore, CPU is halted twice
 690          * in the sched loop. It makes the interrupt latency
 691          * terribly long and be able to cause a serious problem
 692          * in interrupt processing. We prevent it by removing
 693          * "hlt" operation from swtch() and managed it under
 694          * APM driver.
 695          */
 696         if (!sc->active || sc->always_halt_cpu)
 697                 __asm("hlt");   /* wait for interrupt */
 698 }
 699
 700 /* inform APM BIOS that CPU is busy */
 701 void
 702 apm_cpu_busy(void)
 703 {
 704         struct apm_softc *sc = &apm_softc;
 705
 706         /*
 707          * The APM specification says this is only necessary if your BIOS
 708          * slows down the processor in the idle task, otherwise it's not
 709          * necessary.
 710          */
 711         if (sc->slow_idle_cpu && sc->active) {
 712
 713                 sc->bios.r.eax = (APM_BIOS <<8) | APM_CPUBUSY;
 714                 sc->bios.r.edx = sc->bios.r.ecx = sc->bios.r.ebx = 0;
 715                 apm_bioscall();
 716         }
 717 }
 718
 719
 720 /*
 721  * APM timeout routine:
 722  *
 723  * This routine is automatically called by timer once per second.
 724  */
 725
 726 static void
 727 apm_timeout(void *dummy)
 728 {
 729         struct apm_softc *sc = &apm_softc;
 730
 731         if (apm_op_inprog)
 732                 apm_lastreq_notify();
 733
 734         if (sc->standbys && sc->standby_countdown-- <= 0)
 735                 apm_do_standby();
 736
 737         if (sc->suspends && sc->suspend_countdown-- <= 0)
 738                 apm_do_suspend();
 739
 740         if (!sc->bios_busy)
 741                 apm_processevent();
 742
 743         if (sc->active == 1) {
 744                 /* Run slightly more oftan than 1 Hz */
 745                 callout_reset(&apm_timeout_ch, hz - 1, apm_timeout, NULL);
 746         }
 747 }
 748
 749 /* enable APM BIOS */
 750 static void
 751 apm_event_enable(void)
 752 {
 753         struct apm_softc *sc = &apm_softc;
 754
 755         APM_DPRINT("called apm_event_enable()\n");
 756         if (sc->initialized) {
 757                 sc->active = 1;
 758                 callout_init(&apm_timeout_ch);
 759                 apm_timeout(sc);
 760         }
 761 }
 762
 763 /* disable APM BIOS */
 764 static void
 765 apm_event_disable(void)
 766 {
 767         struct apm_softc *sc = &apm_softc;
 768
 769         APM_DPRINT("called apm_event_disable()\n");
 770         if (sc->initialized) {
 771                 callout_stop(&apm_timeout_ch);
 772                 sc->active = 0;
 773         }
 774 }
 775
 776 /* halt CPU in scheduling loop */
 777 static void
 778 apm_halt_cpu(void)
 779 {
 780         struct apm_softc *sc = &apm_softc;
 781
 782         if (sc->initialized)
 783                 sc->always_halt_cpu = 1;
 784 }
 785
 786 /* don't halt CPU in scheduling loop */
 787 static void
 788 apm_not_halt_cpu(void)
 789 {
 790         struct apm_softc *sc = &apm_softc;
 791
 792         if (sc->initialized)
 793                 sc->always_halt_cpu = 0;
 794 }
 795
 796 /* device driver definitions */
 797
 798 /*
 799  * probe for APM BIOS
 800  */
 801 static int
 802 apm_probe(device_t dev)
 803 {
 804 #define APM_KERNBASE    KERNBASE
 805         struct vm86frame        vmf;
 806         struct apm_softc        *sc = &apm_softc;
 807         int                     disabled, flags;
 808
 809         if (resource_int_value("apm", 0, "disabled", &disabled) == 0
 810             && disabled != 0)
 811                 return ENXIO;
 812
 813         device_set_desc(dev, "APM BIOS");
 814
 815         if ( device_get_unit(dev) > 0 ) {
 816                 kprintf("apm: Only one APM driver supported.\n");
 817                 return ENXIO;
 818         }
 819
 820         if (resource_int_value("apm", 0, "flags", &flags) != 0)
 821                 flags = 0;
 822
 823         bzero(&vmf, sizeof(struct vm86frame));          /* safety */
 824         bzero(&apm_softc, sizeof(apm_softc));
 825         vmf.vmf_ah = APM_BIOS;
 826         vmf.vmf_al = APM_INSTCHECK;
 827         vmf.vmf_bx = 0;
 828         if (vm86_intcall(APM_INT, &vmf))
 829                 return ENXIO;                   /* APM not found */
 830         if (vmf.vmf_bx != 0x504d) {
 831                 kprintf("apm: incorrect signature (0x%x)\n", vmf.vmf_bx);
 832                 return ENXIO;
 833         }
 834         if ((vmf.vmf_cx & (APM_32BIT_SUPPORT | APM_16BIT_SUPPORT)) == 0) {
 835                 kprintf("apm: protected mode connections are not supported\n");
 836                 return ENXIO;
 837         }
 838
 839         apm_version = vmf.vmf_ax;
 840         sc->slow_idle_cpu = ((vmf.vmf_cx & APM_CPUIDLE_SLOW) != 0);
 841         sc->disabled = ((vmf.vmf_cx & APM_DISABLED) != 0);
 842         sc->disengaged = ((vmf.vmf_cx & APM_DISENGAGED) != 0);
 843
 844         vmf.vmf_ah = APM_BIOS;
 845         vmf.vmf_al = APM_DISCONNECT;
 846         vmf.vmf_bx = 0;
 847         vm86_intcall(APM_INT, &vmf);            /* disconnect, just in case */
 848
 849         if ((vmf.vmf_cx & APM_32BIT_SUPPORT) != 0) {
 850                 vmf.vmf_ah = APM_BIOS;
 851                 vmf.vmf_al = APM_PROT32CONNECT;
 852                 vmf.vmf_bx = 0;
 853                 if (vm86_intcall(APM_INT, &vmf)) {
 854                         kprintf("apm: 32-bit connection error.\n");
 855                         return (ENXIO);
 856                 }
 857                 sc->bios.seg.code32.base = (vmf.vmf_ax << 4) + APM_KERNBASE;
 858                 sc->bios.seg.code32.limit = 0xffff;
 859                 sc->bios.seg.code16.base = (vmf.vmf_cx << 4) + APM_KERNBASE;
 860                 sc->bios.seg.code16.limit = 0xffff;
 861                 sc->bios.seg.data.base = (vmf.vmf_dx << 4) + APM_KERNBASE;
 862                 sc->bios.seg.data.limit = 0xffff;
 863                 sc->bios.entry = vmf.vmf_ebx;
 864                 sc->connectmode = APM_PROT32CONNECT;
 865         } else {
 866                 /* use 16-bit connection */
 867                 vmf.vmf_ah = APM_BIOS;
 868                 vmf.vmf_al = APM_PROT16CONNECT;
 869                 vmf.vmf_bx = 0;
 870                 if (vm86_intcall(APM_INT, &vmf)) {
 871                         kprintf("apm: 16-bit connection error.\n");
 872                         return (ENXIO);
 873                 }
 874                 sc->bios.seg.code16.base = (vmf.vmf_ax << 4) + APM_KERNBASE;
 875                 sc->bios.seg.code16.limit = 0xffff;
 876                 sc->bios.seg.data.base = (vmf.vmf_cx << 4) + APM_KERNBASE;
 877                 sc->bios.seg.data.limit = 0xffff;
 878                 sc->bios.entry = vmf.vmf_bx;
 879                 sc->connectmode = APM_PROT16CONNECT;
 880         }
 881         return(0);
 882 }
 883
 884
 885 /*
 886  * return 0 if the user will notice and handle the event,
 887  * return 1 if the kernel driver should do so.
 888  */
 889 static int
 890 apm_record_event(struct apm_softc *sc, u_int event_type)
 891 {
 892         struct apm_event_info *evp;
 893
 894         if ((sc->sc_flags & SCFLAG_OPEN) == 0)
 895                 return 1;               /* no user waiting */
 896         if (sc->event_count == APM_NEVENTS)
 897                 return 1;                       /* overflow */
 898         if (sc->event_filter[event_type] == 0)
 899                 return 1;               /* not registered */
 900         evp = &sc->event_list[sc->event_ptr];
 901         sc->event_count++;
 902         sc->event_ptr++;
 903         sc->event_ptr %= APM_NEVENTS;
 904         evp->type = event_type;
 905         evp->index = ++apm_evindex;
 906         KNOTE(&sc->sc_rkq.ki_note, 0);
 907         return (sc->sc_flags & SCFLAG_OCTL) ? 0 : 1; /* user may handle */
 908 }
 909
 910 /* Process APM event */
 911 static void
 912 apm_processevent(void)
 913 {
 914         int apm_event;
 915         struct apm_softc *sc = &apm_softc;
 916
 917 #define OPMEV_DEBUGMESSAGE(symbol) case symbol:                         \
 918         APM_DPRINT("Received APM Event: " #symbol "\n");
 919
 920         do {
 921                 apm_event = apm_getevent();
 922                 switch (apm_event) {
 923                     OPMEV_DEBUGMESSAGE(PMEV_STANDBYREQ);
 924                         if (apm_op_inprog == 0) {
 925                             apm_op_inprog++;
 926                             if (apm_record_event(sc, apm_event)) {
 927                                 apm_suspend(PMST_STANDBY);
 928                             }
 929                         }
 930                         break;
 931                     OPMEV_DEBUGMESSAGE(PMEV_USERSTANDBYREQ);
 932                         if (apm_op_inprog == 0) {
 933                             apm_op_inprog++;
 934                             if (apm_record_event(sc, apm_event)) {
 935                                 apm_suspend(PMST_STANDBY);
 936                             }
 937                         }
 938                         break;
 939                     OPMEV_DEBUGMESSAGE(PMEV_SUSPENDREQ);
 940                         apm_lastreq_notify();
 941                         if (apm_op_inprog == 0) {
 942                             apm_op_inprog++;
 943                             if (apm_record_event(sc, apm_event)) {
 944                                 apm_do_suspend();
 945                             }
 946                         }
 947                         return; /* XXX skip the rest */
 948                     OPMEV_DEBUGMESSAGE(PMEV_USERSUSPENDREQ);
 949                         apm_lastreq_notify();
 950                         if (apm_op_inprog == 0) {
 951                             apm_op_inprog++;
 952                             if (apm_record_event(sc, apm_event)) {
 953                                 apm_do_suspend();
 954                             }
 955                         }
 956                         return; /* XXX skip the rest */
 957                     OPMEV_DEBUGMESSAGE(PMEV_CRITSUSPEND);
 958                         apm_do_suspend();
 959                         break;
 960                     OPMEV_DEBUGMESSAGE(PMEV_NORMRESUME);
 961                         apm_record_event(sc, apm_event);
 962                         apm_resume();
 963                         break;
 964                     OPMEV_DEBUGMESSAGE(PMEV_CRITRESUME);
 965                         apm_record_event(sc, apm_event);
 966                         apm_resume();
 967                         break;
 968                     OPMEV_DEBUGMESSAGE(PMEV_STANDBYRESUME);
 969                         apm_record_event(sc, apm_event);
 970                         apm_resume();
 971                         break;
 972                     OPMEV_DEBUGMESSAGE(PMEV_BATTERYLOW);
 973                         if (apm_record_event(sc, apm_event)) {
 974                             apm_battery_low();
 975                             apm_suspend(PMST_SUSPEND);
 976                         }
 977                         break;
 978                     OPMEV_DEBUGMESSAGE(PMEV_POWERSTATECHANGE);
 979                         apm_record_event(sc, apm_event);
 980                         break;
 981                     OPMEV_DEBUGMESSAGE(PMEV_UPDATETIME);
 982                         apm_record_event(sc, apm_event);
 983                         inittodr(0);    /* adjust time to RTC */
 984                         break;
 985                     OPMEV_DEBUGMESSAGE(PMEV_CAPABILITIESCHANGE);
 986                         apm_record_event(sc, apm_event);
 987                         break;
 988                     case PMEV_NOEVENT:
 989                         break;
 990                     default:
 991                         kprintf("Unknown Original APM Event 0x%x\n", apm_event);
 992                             break;
 993                 }
 994         } while (apm_event != PMEV_NOEVENT);
 995 }
 996
 997 /*
 998  * Attach APM:
 999  *
1000  * Initialize APM driver
1001  */
1002
1003 static int
1004 apm_attach(device_t dev)
1005 {
1006         struct apm_softc        *sc = &apm_softc;
1007         int                     flags;
1008         int                     drv_version;
1009
1010         if (resource_int_value("apm", 0, "flags", &flags) != 0)
1011                 flags = 0;
1012
1013         sc->initialized = 0;
1014
1015         /* Must be externally enabled */
1016         sc->active = 0;
1017
1018         /* Always call HLT in idle loop */
1019         sc->always_halt_cpu = 1;
1020
1021         kgetenv_int("debug.apm_debug", &apm_debug);
1022
1023         /* print bootstrap messages */
1024         APM_DPRINT("apm: APM BIOS version %04lx\n",  apm_version);
1025         APM_DPRINT("apm: Code16 0x%08x, Data 0x%08x\n",
1026             sc->bios.seg.code16.base, sc->bios.seg.data.base);
1027         APM_DPRINT("apm: Code entry 0x%08x, Idling CPU %s, Management %s\n",
1028             sc->bios.entry, is_enabled(sc->slow_idle_cpu),
1029             is_enabled(!sc->disabled));
1030         APM_DPRINT("apm: CS_limit=0x%x, DS_limit=0x%x\n",
1031             sc->bios.seg.code16.limit, sc->bios.seg.data.limit);
1032
1033         /*
1034          * In one test, apm bios version was 1.02; an attempt to register
1035          * a 1.04 driver resulted in a 1.00 connection!  Registering a
1036          * 1.02 driver resulted in a 1.02 connection.
1037          */
1038         drv_version = apm_version > 0x102 ? 0x102 : apm_version;
1039         for (; drv_version > 0x100; drv_version--)
1040                 if (apm_driver_version(drv_version) == 0)
1041                         break;
1042         sc->minorversion = ((drv_version & 0x00f0) >>  4) * 10 +
1043                 ((drv_version & 0x000f) >> 0);
1044         sc->majorversion = ((drv_version & 0xf000) >> 12) * 10 +
1045                 ((apm_version & 0x0f00) >> 8);
1046
1047         sc->intversion = INTVERSION(sc->majorversion, sc->minorversion);
1048
1049         if (sc->intversion >= INTVERSION(1, 1))
1050                 APM_DPRINT("apm: Engaged control %s\n", is_enabled(!sc->disengaged));
1051         device_printf(dev, "found APM BIOS v%ld.%ld, connected at v%d.%d\n",
1052                ((apm_version & 0xf000) >> 12) * 10 + ((apm_version & 0x0f00) >> 8),
1053                ((apm_version & 0x00f0) >> 4) * 10 + ((apm_version & 0x000f) >> 0),
1054                sc->majorversion, sc->minorversion);
1055
1056
1057         APM_DPRINT("apm: Slow Idling CPU %s\n", is_enabled(sc->slow_idle_cpu));
1058         /* enable power management */
1059         if (sc->disabled) {
1060                 if (apm_enable_disable_pm(1)) {
1061                         APM_DPRINT("apm: *Warning* enable function failed! [%x]\n",
1062                             (sc->bios.r.eax >> 8) & 0xff);
1063                 }
1064         }
1065
1066         /* engage power managment (APM 1.1 or later) */
1067         if (sc->intversion >= INTVERSION(1, 1) && sc->disengaged) {
1068                 if (apm_engage_disengage_pm(1)) {
1069                         APM_DPRINT("apm: *Warning* engage function failed err=[%x]",
1070                             (sc->bios.r.eax >> 8) & 0xff);
1071                         APM_DPRINT(" (Docked or using external power?).\n");
1072                 }
1073         }
1074
1075         /* default suspend hook */
1076         sc->sc_suspend.ah_fun = apm_default_suspend;
1077         sc->sc_suspend.ah_arg = sc;
1078         sc->sc_suspend.ah_name = "default suspend";
1079         sc->sc_suspend.ah_order = APM_MAX_ORDER;
1080
1081         /* default resume hook */
1082         sc->sc_resume.ah_fun = apm_default_resume;
1083         sc->sc_resume.ah_arg = sc;
1084         sc->sc_resume.ah_name = "default resume";
1085         sc->sc_resume.ah_order = APM_MIN_ORDER;
1086
1087         apm_hook_establish(APM_HOOK_SUSPEND, &sc->sc_suspend);
1088         apm_hook_establish(APM_HOOK_RESUME , &sc->sc_resume);
1089
1090         /* Power the system off using APM */
1091         EVENTHANDLER_REGISTER(shutdown_final, apm_power_off, NULL,
1092                               SHUTDOWN_PRI_LAST);
1093
1094         sc->initialized = 1;
1095
1096         make_dev(&apm_ops, 0, UID_ROOT, GID_OPERATOR, 0660, "apm");
1097         make_dev(&apm_ops, 8, UID_ROOT, GID_OPERATOR, 0660, "apmctl");
1098         return 0;
1099 }
1100
1101 static int
1102 apmopen(struct dev_open_args *ap)
1103 {
1104         cdev_t dev = ap->a_head.a_dev;
1105         struct apm_softc *sc = &apm_softc;
1106         int ctl = APMDEV(dev);
1107
1108         if (!sc->initialized)
1109                 return (ENXIO);
1110
1111         switch (ctl) {
1112         case APMDEV_CTL:
1113                 if (!(ap->a_oflags & FWRITE))
1114                         return EINVAL;
1115                 if (sc->sc_flags & SCFLAG_OCTL)
1116                         return EBUSY;
1117                 sc->sc_flags |= SCFLAG_OCTL;
1118                 bzero(sc->event_filter, sizeof sc->event_filter);
1119                 break;
1120         case APMDEV_NORMAL:
1121                 sc->sc_flags |= SCFLAG_ONORMAL;
1122                 break;
1123         default:
1124                 return ENXIO;
1125                 break;
1126         }
1127         return 0;
1128 }
1129
1130 static int
1131 apmclose(struct dev_close_args *ap)
1132 {
1133         cdev_t dev = ap->a_head.a_dev;
1134         struct apm_softc *sc = &apm_softc;
1135         int ctl = APMDEV(dev);
1136
1137         switch (ctl) {
1138         case APMDEV_CTL:
1139                 apm_lastreq_rejected();
1140                 sc->sc_flags &= ~SCFLAG_OCTL;
1141                 bzero(sc->event_filter, sizeof sc->event_filter);
1142                 break;
1143         case APMDEV_NORMAL:
1144                 sc->sc_flags &= ~SCFLAG_ONORMAL;
1145                 break;
1146         }
1147         if ((sc->sc_flags & SCFLAG_OPEN) == 0) {
1148                 sc->event_count = 0;
1149                 sc->event_ptr = 0;
1150         }
1151         return 0;
1152 }
1153
1154 static int
1155 apmioctl(struct dev_ioctl_args *ap)
1156 {
1157         cdev_t dev = ap->a_head.a_dev;
1158         struct apm_softc *sc = &apm_softc;
1159         struct apm_bios_arg *args;
1160         int error = 0;
1161         int ret;
1162         int newstate;
1163
1164         if (!sc->initialized)
1165                 return (ENXIO);
1166         APM_DPRINT("APM ioctl: cmd = 0x%lx\n", ap->a_cmd);
1167
1168         switch (ap->a_cmd) {
1169         case APMIO_SUSPEND:
1170                 if (!(ap->a_fflag & FWRITE))
1171                         return (EPERM);
1172                 if (sc->active)
1173                         apm_suspend(PMST_SUSPEND);
1174                 else
1175                         error = EINVAL;
1176                 break;
1177
1178         case APMIO_STANDBY:
1179                 if (!(ap->a_fflag & FWRITE))
1180                         return (EPERM);
1181                 if (sc->active)
1182                         apm_suspend(PMST_STANDBY);
1183                 else
1184                         error = EINVAL;
1185                 break;
1186
1187         case APMIO_GETINFO_OLD:
1188                 {
1189                         struct apm_info info;
1190                         apm_info_old_t aiop;
1191
1192                         if (apm_get_info(&info))
1193                                 error = ENXIO;
1194                         aiop = (apm_info_old_t)ap->a_data;
1195                         aiop->ai_major = info.ai_major;
1196                         aiop->ai_minor = info.ai_minor;
1197                         aiop->ai_acline = info.ai_acline;
1198                         aiop->ai_batt_stat = info.ai_batt_stat;
1199                         aiop->ai_batt_life = info.ai_batt_life;
1200                         aiop->ai_status = info.ai_status;
1201                 }
1202                 break;
1203         case APMIO_GETINFO:
1204                 if (apm_get_info((apm_info_t)ap->a_data))
1205                         error = ENXIO;
1206                 break;
1207         case APMIO_GETPWSTATUS:
1208                 if (apm_get_pwstatus((apm_pwstatus_t)ap->a_data))
1209                         error = ENXIO;
1210                 break;
1211         case APMIO_ENABLE:
1212                 if (!(ap->a_fflag & FWRITE))
1213                         return (EPERM);
1214                 apm_event_enable();
1215                 break;
1216         case APMIO_DISABLE:
1217                 if (!(ap->a_fflag & FWRITE))
1218                         return (EPERM);
1219                 apm_event_disable();
1220                 break;
1221         case APMIO_HALTCPU:
1222                 if (!(ap->a_fflag & FWRITE))
1223                         return (EPERM);
1224                 apm_halt_cpu();
1225                 break;
1226         case APMIO_NOTHALTCPU:
1227                 if (!(ap->a_fflag & FWRITE))
1228                         return (EPERM);
1229                 apm_not_halt_cpu();
1230                 break;
1231         case APMIO_DISPLAY:
1232                 if (!(ap->a_fflag & FWRITE))
1233                         return (EPERM);
1234                 newstate = *(int *)ap->a_data;
1235                 if (apm_display(newstate))
1236                         error = ENXIO;
1237                 break;
1238         case APMIO_BIOS:
1239                 if (!(ap->a_fflag & FWRITE))
1240                         return (EPERM);
1241                 /* XXX compatibility with the old interface */
1242                 args = (struct apm_bios_arg *)ap->a_data;
1243                 sc->bios.r.eax = args->eax;
1244                 sc->bios.r.ebx = args->ebx;
1245                 sc->bios.r.ecx = args->ecx;
1246                 sc->bios.r.edx = args->edx;
1247                 sc->bios.r.esi = args->esi;
1248                 sc->bios.r.edi = args->edi;
1249                 if ((ret = apm_bioscall())) {
1250                         /*
1251                          * Return code 1 means bios call was unsuccessful.
1252                          * Error code is stored in %ah.
1253                          * Return code -1 means bios call was unsupported
1254                          * in the APM BIOS version.
1255                          */
1256                         if (ret == -1) {
1257                                 error = EINVAL;
1258                         }
1259                 } else {
1260                         /*
1261                          * Return code 0 means bios call was successful.
1262                          * We need only %al and can discard %ah.
1263                          */
1264                         sc->bios.r.eax &= 0xff;
1265                 }
1266                 args->eax = sc->bios.r.eax;
1267                 args->ebx = sc->bios.r.ebx;
1268                 args->ecx = sc->bios.r.ecx;
1269                 args->edx = sc->bios.r.edx;
1270                 args->esi = sc->bios.r.esi;
1271                 args->edi = sc->bios.r.edi;
1272                 break;
1273         default:
1274                 error = EINVAL;
1275                 break;
1276         }
1277
1278         /* for /dev/apmctl */
1279         if (APMDEV(dev) == APMDEV_CTL) {
1280                 struct apm_event_info *evp;
1281                 int i;
1282
1283                 error = 0;
1284                 switch (ap->a_cmd) {
1285                 case APMIO_NEXTEVENT:
1286                         if (!sc->event_count) {
1287                                 error = EAGAIN;
1288                         } else {
1289                                 evp = (struct apm_event_info *)ap->a_data;
1290                                 i = sc->event_ptr + APM_NEVENTS - sc->event_count;
1291                                 i %= APM_NEVENTS;
1292                                 *evp = sc->event_list[i];
1293                                 sc->event_count--;
1294                         }
1295                         break;
1296                 case APMIO_REJECTLASTREQ:
1297                         if (apm_lastreq_rejected()) {
1298                                 error = EINVAL;
1299                         }
1300                         break;
1301                 default:
1302                         error = EINVAL;
1303                         break;
1304                 }
1305         }
1306
1307         return error;
1308 }
1309
1310 static int
1311 apmwrite(struct dev_write_args *ap)
1312 {
1313         cdev_t dev = ap->a_head.a_dev;
1314         struct uio *uio = ap->a_uio;
1315         struct apm_softc *sc = &apm_softc;
1316         u_int event_type;
1317         int error;
1318         u_char enabled;
1319
1320         if (APMDEV(dev) != APMDEV_CTL)
1321                 return(ENODEV);
1322         if (uio->uio_resid != sizeof(u_int))
1323                 return(E2BIG);
1324
1325         if ((error = uiomove((caddr_t)&event_type, sizeof(u_int), uio)))
1326                 return(error);
1327
1328         if (event_type < 0 || event_type >= APM_NPMEV)
1329                 return(EINVAL);
1330
1331         if (sc->event_filter[event_type] == 0) {
1332                 enabled = 1;
1333         } else {
1334                 enabled = 0;
1335         }
1336         sc->event_filter[event_type] = enabled;
1337         APM_DPRINT("apmwrite: event 0x%x %s\n", event_type, is_enabled(enabled));
1338
1339         return uio->uio_resid;
1340 }
1341
1342 static struct filterops apmfiltops_read =
1343         { FILTEROP_ISFD, NULL, apmfilter_detach, apmfilter_read };
1344 static struct filterops apmfiltops_write =
1345         { FILTEROP_ISFD, NULL, apmfilter_detach, apmfilter_write };
1346
1347 static int
1348 apmkqfilter(struct dev_kqfilter_args *ap)
1349 {
1350         struct apm_softc *sc = &apm_softc;
1351         struct knote *kn = ap->a_kn;
1352         struct klist *klist;
1353
1354         ap->a_result = 0;
1355
1356         switch (kn->kn_filter) {
1357         case EVFILT_READ:
1358                 kn->kn_fop = &apmfiltops_read;
1359                 kn->kn_hook = (caddr_t)sc;
1360                 break;
1361         case EVFILT_WRITE:
1362                 kn->kn_fop = &apmfiltops_write;
1363                 kn->kn_hook = (caddr_t)sc;
1364                 break;
1365         default:
1366                 ap->a_result = EOPNOTSUPP;
1367                 return (0);
1368         }
1369
1370         klist = &sc->sc_rkq.ki_note;
1371         knote_insert(klist, kn);
1372
1373         return (0);
1374 }
1375
1376 static void
1377 apmfilter_detach(struct knote *kn)
1378 {
1379         struct apm_softc *sc = (struct apm_softc *)kn->kn_hook;
1380         struct klist *klist;
1381
1382         klist = &sc->sc_rkq.ki_note;
1383         knote_remove(klist, kn);
1384 }
1385
1386 static int
1387 apmfilter_read(struct knote *kn, long hint)
1388 {
1389         struct apm_softc *sc = (struct apm_softc *)kn->kn_hook;
1390         int ready = 0;
1391
1392         if (sc->event_count)
1393                 ready = 1;
1394
1395         return (ready);
1396 }
1397
1398 static int
1399 apmfilter_write(struct knote *kn, long hint)
1400 {
1401         /* write()'s are always OK */
1402         return (1);
1403 }
1404
1405 /*
1406  * Because apm is a static device that always exists under any attached
1407  * isa device, and not scanned by the isa device, we need an identify
1408  * function to install the device so we can probe for it.
1409  */
1410 static device_method_t apm_methods[] = {
1411         /* Device interface */
1412         DEVMETHOD(device_identify,      bus_generic_identify),
1413         DEVMETHOD(device_probe,         apm_probe),
1414         DEVMETHOD(device_attach,        apm_attach),
1415
1416         { 0, 0 }
1417 };
1418
1419 static driver_t apm_driver = {
1420         "apm",
1421         apm_methods,
1422         1,                      /* no softc (XXX) */
1423 };
1424
1425 static devclass_t apm_devclass;
1426
1427 DRIVER_MODULE(apm, nexus, apm_driver, apm_devclass, 0, 0);