The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/i386/bios/apm.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    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 
   19 #include <sys/cdefs.h>
   20 __FBSDID("$FreeBSD: releng/9.2/sys/i386/bios/apm.c 220844 2011-04-19 16:30:17Z jkim $");
   21 
   22 #include <sys/param.h>
   23 #include <sys/systm.h>
   24 #include <sys/bus.h>
   25 #include <sys/conf.h>
   26 #include <sys/condvar.h>
   27 #include <sys/eventhandler.h>
   28 #include <sys/fcntl.h>
   29 #include <sys/kernel.h>
   30 #include <sys/kthread.h>
   31 #include <sys/lock.h>
   32 #include <sys/module.h>
   33 #include <sys/mutex.h>
   34 #include <sys/poll.h>
   35 #include <sys/power.h>
   36 #include <sys/reboot.h>
   37 #include <sys/selinfo.h>
   38 #include <sys/signalvar.h>
   39 #include <sys/sysctl.h>
   40 #include <sys/syslog.h>
   41 #include <sys/time.h>
   42 #include <sys/uio.h>
   43 
   44 #include <machine/apm_bios.h>
   45 #include <machine/clock.h>
   46 #include <machine/endian.h>
   47 #include <machine/pc/bios.h>
   48 #include <machine/cpufunc.h>
   49 #include <machine/segments.h>
   50 #include <machine/stdarg.h>
   51 #include <machine/vm86.h>
   52 
   53 #include <machine/bus.h>
   54 #include <machine/resource.h>
   55 #include <sys/rman.h>
   56 
   57 #include <vm/vm.h>
   58 #include <vm/pmap.h>
   59 #include <vm/vm_param.h>
   60 
   61 #include <i386/bios/apm.h>
   62 #include <isa/rtc.h>
   63 
   64 /* Used by the apm_saver screen saver module */
   65 int apm_display(int newstate);
   66 struct apm_softc apm_softc;
   67 
   68 static void apm_resume(void);
   69 static int apm_bioscall(void);
   70 static int apm_check_function_supported(u_int version, u_int func);
   71 
   72 static int apm_pm_func(u_long, void*, ...);
   73 
   74 static u_long   apm_version;
   75 
   76 int     apm_evindex;
   77 
   78 #define SCFLAG_ONORMAL  0x0000001
   79 #define SCFLAG_OCTL     0x0000002
   80 #define SCFLAG_OPEN     (SCFLAG_ONORMAL|SCFLAG_OCTL)
   81 
   82 #define APMDEV_NORMAL   0
   83 #define APMDEV_CTL      1
   84 
   85 #ifdef PC98
   86 extern int bios32_apm98(struct bios_regs *, u_int, u_short);
   87 
   88 /* PC98's SMM definition */
   89 #define APM_NECSMM_PORT         0x6b8e
   90 #define APM_NECSMM_PORTSZ       1
   91 #define APM_NECSMM_EN           0x10
   92 static __inline void apm_enable_smm(struct apm_softc *);
   93 static __inline void apm_disable_smm(struct apm_softc *);
   94 int apm_necsmm_addr;
   95 u_int32_t apm_necsmm_mask;
   96 #endif
   97 
   98 static struct apmhook   *hook[NAPM_HOOK];               /* XXX */
   99 
  100 #define is_enabled(foo) ((foo) ? "enabled" : "disabled")
  101 
  102 /* Map version number to integer (keeps ordering of version numbers) */
  103 #define INTVERSION(major, minor)        ((major)*100 + (minor))
  104 
  105 static d_open_t apmopen;
  106 static d_close_t apmclose;
  107 static d_write_t apmwrite;
  108 static d_ioctl_t apmioctl;
  109 static d_poll_t apmpoll;
  110 
  111 static struct cdevsw apm_cdevsw = {
  112         .d_version =    D_VERSION,
  113         .d_flags =      D_NEEDGIANT,
  114         .d_open =       apmopen,
  115         .d_close =      apmclose,
  116         .d_write =      apmwrite,
  117         .d_ioctl =      apmioctl,
  118         .d_poll =       apmpoll,
  119         .d_name =       "apm",
  120 };
  121 
  122 static int apm_suspend_delay = 1;
  123 static int apm_standby_delay = 1;
  124 static int apm_swab_batt_minutes = 0;
  125 static int apm_debug = 0;
  126 
  127 #define APM_DPRINT(args...) do  {                                       \
  128         if (apm_debug) {                                                \
  129                 printf(args);                                           \
  130         }                                                               \
  131 } while (0)
  132 
  133 SYSCTL_INT(_machdep, OID_AUTO, apm_suspend_delay, CTLFLAG_RW, &apm_suspend_delay, 1, "");
  134 SYSCTL_INT(_machdep, OID_AUTO, apm_standby_delay, CTLFLAG_RW, &apm_standby_delay, 1, "");
  135 SYSCTL_INT(_debug, OID_AUTO, apm_debug, CTLFLAG_RW, &apm_debug, 0, "");
  136 
  137 TUNABLE_INT("machdep.apm_swab_batt_minutes", &apm_swab_batt_minutes);
  138 SYSCTL_INT(_machdep, OID_AUTO, apm_swab_batt_minutes, CTLFLAG_RW,
  139            &apm_swab_batt_minutes, 0, "Byte swap battery time value.");
  140 
  141 #ifdef PC98
  142 static __inline void
  143 apm_enable_smm(sc)
  144         struct apm_softc *sc;
  145 {
  146         bus_space_tag_t iot = sc->sc_iot;
  147         bus_space_handle_t ioh = sc->sc_ioh;
  148         if (apm_necsmm_addr != 0)
  149                 bus_space_write_1(iot, ioh, 0,
  150                           (bus_space_read_1(iot, ioh, 0) | ~apm_necsmm_mask));
  151 }
  152 
  153 static __inline void
  154 apm_disable_smm(sc)
  155         struct apm_softc *sc;
  156 {
  157         bus_space_tag_t iot = sc->sc_iot;
  158         bus_space_handle_t ioh = sc->sc_ioh;
  159         if (apm_necsmm_addr != 0)
  160                 bus_space_write_1(iot, ioh, 0,
  161                           (bus_space_read_1(iot, ioh, 0) & apm_necsmm_mask));
  162 }
  163 #endif
  164 
  165 /*
  166  * return  0 if the function successfull,
  167  * return  1 if the function unsuccessfull,
  168  * return -1 if the function unsupported.
  169  */
  170 static int
  171 apm_bioscall(void)
  172 {
  173         struct apm_softc *sc = &apm_softc;
  174         int errno = 0;
  175         u_int apm_func = sc->bios.r.eax & 0xff;
  176 
  177         if (!apm_check_function_supported(sc->intversion, apm_func)) {
  178                 APM_DPRINT("apm_bioscall: function 0x%x is not supported in v%d.%d\n",
  179                     apm_func, sc->majorversion, sc->minorversion);
  180                 return (-1);
  181         }
  182 
  183         sc->bios_busy = 1;
  184 #ifdef  PC98
  185         set_bios_selectors(&sc->bios.seg, BIOSCODE_FLAG | BIOSDATA_FLAG);
  186         if (bios32_apm98(&sc->bios.r, sc->bios.entry,
  187             GSEL(GBIOSCODE32_SEL, SEL_KPL)) != 0)
  188                 return 1;
  189 #else
  190         if (sc->connectmode == APM_PROT32CONNECT) {
  191                 set_bios_selectors(&sc->bios.seg,
  192                                    BIOSCODE_FLAG | BIOSDATA_FLAG);
  193                 errno = bios32(&sc->bios.r,
  194                                sc->bios.entry, GSEL(GBIOSCODE32_SEL, SEL_KPL));
  195         } else {
  196                 errno = bios16(&sc->bios, NULL);
  197         }
  198 #endif
  199         sc->bios_busy = 0;
  200         return (errno);
  201 }
  202 
  203 /* check whether APM function is supported (1)  or not (0). */
  204 static int
  205 apm_check_function_supported(u_int version, u_int func)
  206 {
  207         /* except driver version */
  208         if (func == APM_DRVVERSION) {
  209                 return (1);
  210         }
  211 #ifdef PC98
  212         if (func == APM_GETPWSTATUS) {
  213                 return (1);
  214         }
  215 #endif
  216 
  217         switch (version) {
  218         case INTVERSION(1, 0):
  219                 if (func > APM_GETPMEVENT) {
  220                         return (0); /* not supported */
  221                 }
  222                 break;
  223         case INTVERSION(1, 1):
  224                 if (func > APM_ENGAGEDISENGAGEPM &&
  225                     func < APM_OEMFUNC) {
  226                         return (0); /* not supported */
  227                 }
  228                 break;
  229         case INTVERSION(1, 2):
  230                 break;
  231         }
  232 
  233         return (1); /* supported */
  234 }
  235 
  236 /* enable/disable power management */
  237 static int
  238 apm_enable_disable_pm(int enable)
  239 {
  240         struct apm_softc *sc = &apm_softc;
  241 
  242         sc->bios.r.eax = (APM_BIOS << 8) | APM_ENABLEDISABLEPM;
  243 
  244         if (sc->intversion >= INTVERSION(1, 1))
  245                 sc->bios.r.ebx  = PMDV_ALLDEV;
  246         else
  247                 sc->bios.r.ebx  = 0xffff;       /* APM version 1.0 only */
  248         sc->bios.r.ecx  = enable;
  249         sc->bios.r.edx = 0;
  250         return (apm_bioscall());
  251 }
  252 
  253 /* register driver version (APM 1.1 or later) */
  254 static int
  255 apm_driver_version(int version)
  256 {
  257         struct apm_softc *sc = &apm_softc;
  258  
  259         sc->bios.r.eax = (APM_BIOS << 8) | APM_DRVVERSION;
  260         sc->bios.r.ebx  = 0x0;
  261         sc->bios.r.ecx  = version;
  262         sc->bios.r.edx = 0;
  263 
  264         if (apm_bioscall() == 0 && sc->bios.r.eax == version)
  265                 return (0);
  266 
  267         /* Some old BIOSes don't return the connection version in %ax. */
  268         if (sc->bios.r.eax == ((APM_BIOS << 8) | APM_DRVVERSION))
  269                 return (0);
  270 
  271         return (1);
  272 }
  273  
  274 /* engage/disengage power management (APM 1.1 or later) */
  275 static int
  276 apm_engage_disengage_pm(int engage)
  277 {
  278         struct apm_softc *sc = &apm_softc;
  279  
  280         sc->bios.r.eax = (APM_BIOS << 8) | APM_ENGAGEDISENGAGEPM;
  281         sc->bios.r.ebx = PMDV_ALLDEV;
  282         sc->bios.r.ecx = engage;
  283         sc->bios.r.edx = 0;
  284         return (apm_bioscall());
  285 }
  286  
  287 /* get PM event */
  288 static u_int
  289 apm_getevent(void)
  290 {
  291         struct apm_softc *sc = &apm_softc;
  292  
  293         sc->bios.r.eax = (APM_BIOS << 8) | APM_GETPMEVENT;
  294  
  295         sc->bios.r.ebx = 0;
  296         sc->bios.r.ecx = 0;
  297         sc->bios.r.edx = 0;
  298         if (apm_bioscall())
  299                 return (PMEV_NOEVENT);
  300         return (sc->bios.r.ebx & 0xffff);
  301 }
  302  
  303 /* suspend entire system */
  304 static int
  305 apm_suspend_system(int state)
  306 {
  307         struct apm_softc *sc = &apm_softc;
  308  
  309         sc->bios.r.eax = (APM_BIOS << 8) | APM_SETPWSTATE;
  310         sc->bios.r.ebx = PMDV_ALLDEV;
  311         sc->bios.r.ecx = state;
  312         sc->bios.r.edx = 0;
  313  
  314 #ifdef PC98
  315         apm_disable_smm(sc);
  316 #endif
  317         if (apm_bioscall()) {
  318                 printf("Entire system suspend failure: errcode = %d\n",
  319                        0xff & (sc->bios.r.eax >> 8));
  320                 return 1;
  321         }
  322 #ifdef PC98
  323         apm_enable_smm(sc);
  324 #endif
  325         return 0;
  326 }
  327 
  328 /* Display control */
  329 /*
  330  * Experimental implementation: My laptop machine can't handle this function
  331  * If your laptop can control the display via APM, please inform me.
  332  *                            HOSOKAWA, Tatsumi <hosokawa@jp.FreeBSD.org>
  333  */
  334 int
  335 apm_display(int newstate)
  336 {
  337         struct apm_softc *sc = &apm_softc;
  338  
  339         sc->bios.r.eax = (APM_BIOS << 8) | APM_SETPWSTATE;
  340         sc->bios.r.ebx = PMDV_DISP0;
  341         sc->bios.r.ecx = newstate ? PMST_APMENABLED:PMST_SUSPEND;
  342         sc->bios.r.edx = 0;
  343         if (apm_bioscall() == 0) {
  344                 return 0;
  345         }
  346 
  347         /* If failed, then try to blank all display devices instead. */
  348         sc->bios.r.eax = (APM_BIOS << 8) | APM_SETPWSTATE;
  349         sc->bios.r.ebx = PMDV_DISPALL;  /* all display devices */
  350         sc->bios.r.ecx = newstate ? PMST_APMENABLED:PMST_SUSPEND;
  351         sc->bios.r.edx = 0;
  352         if (apm_bioscall() == 0) {
  353                 return 0;
  354         }
  355         printf("Display off failure: errcode = %d\n",
  356                0xff & (sc->bios.r.eax >> 8));
  357         return 1;
  358 }
  359 
  360 /*
  361  * Turn off the entire system.
  362  */
  363 static void
  364 apm_power_off(void *junk, int howto)
  365 {
  366         struct apm_softc *sc = &apm_softc;
  367 
  368         /* Not halting powering off, or not active */
  369         if (!(howto & RB_POWEROFF) || !apm_softc.active)
  370                 return;
  371         sc->bios.r.eax = (APM_BIOS << 8) | APM_SETPWSTATE;
  372         sc->bios.r.ebx = PMDV_ALLDEV;
  373         sc->bios.r.ecx = PMST_OFF;
  374         sc->bios.r.edx = 0;
  375         (void) apm_bioscall();
  376 }
  377 
  378 /* APM Battery low handler */
  379 static void
  380 apm_battery_low(void)
  381 {
  382         printf("\007\007 * * * BATTERY IS LOW * * * \007\007");
  383 }
  384 
  385 /* APM hook manager */
  386 static struct apmhook *
  387 apm_add_hook(struct apmhook **list, struct apmhook *ah)
  388 {
  389         int s;
  390         struct apmhook *p, *prev;
  391 
  392         APM_DPRINT("Add hook \"%s\"\n", ah->ah_name);
  393 
  394         s = splhigh();
  395         if (ah == NULL)
  396                 panic("illegal apm_hook!");
  397         prev = NULL;
  398         for (p = *list; p != NULL; prev = p, p = p->ah_next)
  399                 if (p->ah_order > ah->ah_order)
  400                         break;
  401 
  402         if (prev == NULL) {
  403                 ah->ah_next = *list;
  404                 *list = ah;
  405         } else {
  406                 ah->ah_next = prev->ah_next;
  407                 prev->ah_next = ah;
  408         }
  409         splx(s);
  410         return ah;
  411 }
  412 
  413 static void
  414 apm_del_hook(struct apmhook **list, struct apmhook *ah)
  415 {
  416         int s;
  417         struct apmhook *p, *prev;
  418 
  419         s = splhigh();
  420         prev = NULL;
  421         for (p = *list; p != NULL; prev = p, p = p->ah_next)
  422                 if (p == ah)
  423                         goto deleteit;
  424         panic("Tried to delete unregistered apm_hook.");
  425         goto nosuchnode;
  426 deleteit:
  427         if (prev != NULL)
  428                 prev->ah_next = p->ah_next;
  429         else
  430                 *list = p->ah_next;
  431 nosuchnode:
  432         splx(s);
  433 }
  434 
  435 
  436 /* APM driver calls some functions automatically */
  437 static void
  438 apm_execute_hook(struct apmhook *list)
  439 {
  440         struct apmhook *p;
  441 
  442         for (p = list; p != NULL; p = p->ah_next) {
  443                 APM_DPRINT("Execute APM hook \"%s.\"\n", p->ah_name);
  444                 if ((*(p->ah_fun))(p->ah_arg))
  445                         printf("Warning: APM hook \"%s\" failed", p->ah_name);
  446         }
  447 }
  448 
  449 
  450 /* establish an apm hook */
  451 struct apmhook *
  452 apm_hook_establish(int apmh, struct apmhook *ah)
  453 {
  454         if (apmh < 0 || apmh >= NAPM_HOOK)
  455                 return NULL;
  456 
  457         return apm_add_hook(&hook[apmh], ah);
  458 }
  459 
  460 /* disestablish an apm hook */
  461 void
  462 apm_hook_disestablish(int apmh, struct apmhook *ah)
  463 {
  464         if (apmh < 0 || apmh >= NAPM_HOOK)
  465                 return;
  466 
  467         apm_del_hook(&hook[apmh], ah);
  468 }
  469 
  470 static int apm_record_event(struct apm_softc *, u_int);
  471 static void apm_processevent(void);
  472 
  473 static u_int apm_op_inprog = 0;
  474 
  475 static void
  476 apm_do_suspend(void)
  477 {
  478         struct apm_softc *sc = &apm_softc;
  479         int error;
  480 
  481         if (sc == NULL || sc->initialized == 0)
  482                 return;
  483 
  484         apm_op_inprog = 0;
  485         sc->suspends = sc->suspend_countdown = 0;
  486 
  487         EVENTHANDLER_INVOKE(power_suspend);
  488 
  489         /*
  490          * Be sure to hold Giant across DEVICE_SUSPEND/RESUME since
  491          * non-MPSAFE drivers need this.
  492          */
  493         mtx_lock(&Giant);
  494         error = DEVICE_SUSPEND(root_bus);
  495         if (error)
  496                 goto backout;
  497 
  498         apm_execute_hook(hook[APM_HOOK_SUSPEND]);
  499         if (apm_suspend_system(PMST_SUSPEND) == 0) {
  500                 sc->suspending = 1;
  501                 apm_processevent();
  502                 mtx_unlock(&Giant);
  503                 return;
  504         }
  505 
  506         /* Failure, 'resume' the system again */
  507         apm_execute_hook(hook[APM_HOOK_RESUME]);
  508         DEVICE_RESUME(root_bus);
  509 backout:
  510         mtx_unlock(&Giant);
  511         EVENTHANDLER_INVOKE(power_resume);
  512 }
  513 
  514 static void
  515 apm_do_standby(void)
  516 {
  517         struct apm_softc *sc = &apm_softc;
  518 
  519         if (sc == NULL || sc->initialized == 0)
  520                 return;
  521 
  522         apm_op_inprog = 0;
  523         sc->standbys = sc->standby_countdown = 0;
  524 
  525         /*
  526          * As far as standby, we don't need to execute 
  527          * all of suspend hooks.
  528          */
  529         if (apm_suspend_system(PMST_STANDBY) == 0)
  530                 apm_processevent();
  531         return;
  532 }
  533 
  534 static void
  535 apm_lastreq_notify(void)
  536 {
  537         struct apm_softc *sc = &apm_softc;
  538 
  539         sc->bios.r.eax = (APM_BIOS << 8) | APM_SETPWSTATE;
  540         sc->bios.r.ebx = PMDV_ALLDEV;
  541         sc->bios.r.ecx = PMST_LASTREQNOTIFY;
  542         sc->bios.r.edx = 0;
  543         apm_bioscall();
  544 }
  545 
  546 static int
  547 apm_lastreq_rejected(void)
  548 {
  549         struct apm_softc *sc = &apm_softc;
  550 
  551         if (apm_op_inprog == 0) {
  552                 return 1;       /* no operation in progress */
  553         }
  554 
  555         sc->bios.r.eax = (APM_BIOS << 8) | APM_SETPWSTATE;
  556         sc->bios.r.ebx = PMDV_ALLDEV;
  557         sc->bios.r.ecx = PMST_LASTREQREJECT;
  558         sc->bios.r.edx = 0;
  559 
  560         if (apm_bioscall()) {
  561                 APM_DPRINT("apm_lastreq_rejected: failed\n");
  562                 return 1;
  563         }
  564         apm_op_inprog = 0;
  565         return 0;
  566 }
  567 
  568 /*
  569  * Public interface to the suspend/resume:
  570  *
  571  * Execute suspend and resume hook before and after sleep, respectively.
  572  *
  573  */
  574 
  575 void
  576 apm_suspend(int state)
  577 {
  578         struct apm_softc *sc = &apm_softc;
  579 
  580         if (sc == NULL || sc->initialized == 0)
  581                 return;
  582 
  583         switch (state) {
  584         case PMST_SUSPEND:
  585                 if (sc->suspends)
  586                         return;
  587                 sc->suspends++;
  588                 sc->suspend_countdown = apm_suspend_delay;
  589                 break;
  590         case PMST_STANDBY:
  591                 if (sc->standbys)
  592                         return;
  593                 sc->standbys++;
  594                 sc->standby_countdown = apm_standby_delay;
  595                 break;
  596         default:
  597                 printf("apm_suspend: Unknown Suspend state 0x%x\n", state);
  598                 return;
  599         }
  600 
  601         apm_op_inprog++;
  602         apm_lastreq_notify();
  603 }
  604 
  605 static void
  606 apm_resume(void)
  607 {
  608         struct apm_softc *sc = &apm_softc;
  609 
  610         if (sc == NULL || sc->initialized == 0 || sc->suspending == 0)
  611                 return;
  612 
  613         sc->suspending = 0;
  614         apm_execute_hook(hook[APM_HOOK_RESUME]);
  615         mtx_lock(&Giant);
  616         DEVICE_RESUME(root_bus);
  617         mtx_unlock(&Giant);
  618         EVENTHANDLER_INVOKE(power_resume);
  619 }
  620 
  621 
  622 /* get power status per battery */
  623 static int
  624 apm_get_pwstatus(apm_pwstatus_t app)
  625 {
  626         struct apm_softc *sc = &apm_softc;
  627 
  628         if (app->ap_device != PMDV_ALLDEV &&
  629             (app->ap_device < PMDV_BATT0 || app->ap_device > PMDV_BATT_ALL))
  630                 return 1;
  631 
  632         sc->bios.r.eax = (APM_BIOS << 8) | APM_GETPWSTATUS;
  633         sc->bios.r.ebx = app->ap_device;
  634         sc->bios.r.ecx = 0;
  635         sc->bios.r.edx = 0xffff;        /* default to unknown battery time */
  636 
  637         if (apm_bioscall())
  638                 return 1;
  639 
  640         app->ap_acline    = (sc->bios.r.ebx >> 8) & 0xff;
  641         app->ap_batt_stat = sc->bios.r.ebx & 0xff;
  642         app->ap_batt_flag = (sc->bios.r.ecx >> 8) & 0xff;
  643         app->ap_batt_life = sc->bios.r.ecx & 0xff;
  644         sc->bios.r.edx &= 0xffff;
  645         if (apm_swab_batt_minutes)
  646                 sc->bios.r.edx = __bswap16(sc->bios.r.edx) | 0x8000;
  647         if (sc->bios.r.edx == 0xffff)   /* Time is unknown */
  648                 app->ap_batt_time = -1;
  649         else if (sc->bios.r.edx & 0x8000)       /* Time is in minutes */
  650                 app->ap_batt_time = (sc->bios.r.edx & 0x7fff) * 60;
  651         else                            /* Time is in seconds */
  652                 app->ap_batt_time = sc->bios.r.edx;
  653 
  654         return 0;
  655 }
  656 
  657 
  658 /* get APM information */
  659 static int
  660 apm_get_info(apm_info_t aip)
  661 {
  662         struct apm_softc *sc = &apm_softc;
  663         struct apm_pwstatus aps;
  664 
  665         bzero(&aps, sizeof(aps));
  666         aps.ap_device = PMDV_ALLDEV;
  667         if (apm_get_pwstatus(&aps))
  668                 return 1;
  669 
  670         aip->ai_infoversion = 1;
  671         aip->ai_acline      = aps.ap_acline;
  672         aip->ai_batt_stat   = aps.ap_batt_stat;
  673         aip->ai_batt_life   = aps.ap_batt_life;
  674         aip->ai_batt_time   = aps.ap_batt_time;
  675         aip->ai_major       = (u_int)sc->majorversion;
  676         aip->ai_minor       = (u_int)sc->minorversion;
  677         aip->ai_status      = (u_int)sc->active;
  678 
  679         sc->bios.r.eax = (APM_BIOS << 8) | APM_GETCAPABILITIES;
  680         sc->bios.r.ebx = 0;
  681         sc->bios.r.ecx = 0;
  682         sc->bios.r.edx = 0;
  683         if (apm_bioscall()) {
  684                 aip->ai_batteries = 0xffffffff; /* Unknown */
  685                 aip->ai_capabilities = 0xff00; /* Unknown, with no bits set */
  686         } else {
  687                 aip->ai_batteries = sc->bios.r.ebx & 0xff;
  688                 aip->ai_capabilities = sc->bios.r.ecx & 0xff;
  689         }
  690 
  691         bzero(aip->ai_spare, sizeof aip->ai_spare);
  692 
  693         return 0;
  694 }
  695 
  696 
  697 /* inform APM BIOS that CPU is idle */
  698 void
  699 apm_cpu_idle(void)
  700 {
  701         struct apm_softc *sc = &apm_softc;
  702 
  703         if (sc->active) {
  704 
  705                 sc->bios.r.eax = (APM_BIOS <<8) | APM_CPUIDLE;
  706                 sc->bios.r.edx = sc->bios.r.ecx = sc->bios.r.ebx = 0;
  707                 (void) apm_bioscall();
  708         }
  709         /*
  710          * Some APM implementation halts CPU in BIOS, whenever
  711          * "CPU-idle" function are invoked, but swtch() of
  712          * FreeBSD halts CPU, therefore, CPU is halted twice
  713          * in the sched loop. It makes the interrupt latency
  714          * terribly long and be able to cause a serious problem
  715          * in interrupt processing. We prevent it by removing
  716          * "hlt" operation from swtch() and managed it under
  717          * APM driver.
  718          */
  719         if (!sc->active || sc->always_halt_cpu)
  720                 halt(); /* wait for interrupt */
  721 }
  722 
  723 /* inform APM BIOS that CPU is busy */
  724 void
  725 apm_cpu_busy(void)
  726 {
  727         struct apm_softc *sc = &apm_softc;
  728 
  729         /*
  730          * The APM specification says this is only necessary if your BIOS
  731          * slows down the processor in the idle task, otherwise it's not
  732          * necessary.
  733          */
  734         if (sc->slow_idle_cpu && sc->active) {
  735 
  736                 sc->bios.r.eax = (APM_BIOS <<8) | APM_CPUBUSY;
  737                 sc->bios.r.edx = sc->bios.r.ecx = sc->bios.r.ebx = 0;
  738                 apm_bioscall();
  739         }
  740 }
  741 
  742 
  743 /*
  744  * APM thread loop.
  745  *
  746  * This routine wakes up from time to time to deal with delaying the
  747  * suspend of the system, or other events.
  748  */
  749 static void
  750 apm_event_thread(void *arg)
  751 {
  752         struct apm_softc *sc = &apm_softc;
  753 
  754         sc->running = 1;
  755         while (sc->active) {
  756                 if (apm_op_inprog)
  757                         apm_lastreq_notify();
  758                 if (sc->standbys && sc->standby_countdown-- <= 0)
  759                         apm_do_standby();
  760                 if (sc->suspends && sc->suspend_countdown-- <= 0)
  761                         apm_do_suspend();
  762                 if (!sc->bios_busy)
  763                         apm_processevent();
  764                 mtx_lock(&sc->mtx);
  765                 cv_timedwait(&sc->cv, &sc->mtx, 10 * hz / 9);
  766                 mtx_unlock(&sc->mtx);
  767         }
  768         sc->running = 0;
  769         kproc_exit(0);
  770 }
  771 
  772 /* enable APM BIOS */
  773 static void
  774 apm_event_enable(void)
  775 {
  776         struct apm_softc *sc = &apm_softc;
  777 
  778         APM_DPRINT("called apm_event_enable()\n");
  779 
  780         if (sc == NULL || sc->initialized == 0)
  781                 return;
  782 
  783         /* Start the thread */
  784         sc->active = 1;
  785         if (kproc_create(apm_event_thread, sc, &sc->event_thread, 0, 0,
  786             "apm worker"))
  787                 panic("Cannot create apm worker thread");
  788 
  789         return;
  790 }
  791 
  792 /* disable APM BIOS */
  793 static void
  794 apm_event_disable(void)
  795 {
  796         struct apm_softc *sc = &apm_softc;
  797 
  798         APM_DPRINT("called apm_event_disable()\n");
  799 
  800         if (sc == NULL || sc->initialized == 0)
  801                 return;
  802 
  803         mtx_lock(&sc->mtx);
  804         sc->active = 0;
  805         while (sc->running) {
  806                 cv_broadcast(&sc->cv);
  807                 msleep(sc->event_thread, &sc->mtx, PWAIT, "apmdie", 0);
  808         }
  809         mtx_unlock(&sc->mtx);
  810         sc->event_thread = NULL;
  811         return;
  812 }
  813 
  814 /* halt CPU in scheduling loop */
  815 static void
  816 apm_halt_cpu(void)
  817 {
  818         struct apm_softc *sc = &apm_softc;
  819 
  820         if (sc == NULL || sc->initialized == 0)
  821                 return;
  822 
  823         sc->always_halt_cpu = 1;
  824 
  825         return;
  826 }
  827 
  828 /* don't halt CPU in scheduling loop */
  829 static void
  830 apm_not_halt_cpu(void)
  831 {
  832         struct apm_softc *sc = &apm_softc;
  833 
  834         if (sc == NULL || sc->initialized == 0)
  835                 return;
  836 
  837         sc->always_halt_cpu = 0;
  838 
  839         return;
  840 }
  841 
  842 /* device driver definitions */
  843 
  844 /*
  845  * Module event
  846  */
  847 
  848 static int
  849 apm_modevent(struct module *mod, int event, void *junk)
  850 {
  851 
  852         switch (event) {
  853         case MOD_LOAD:
  854                 if (!cold)
  855                         return (EPERM);
  856                 break;
  857         case MOD_UNLOAD:
  858                 if (!cold && power_pm_get_type() == POWER_PM_TYPE_APM)
  859                         return (EBUSY);
  860                 break;
  861         default:
  862                 break;
  863         }
  864 
  865         return (0);
  866 }
  867 
  868 /*
  869  * Create "connection point"
  870  */
  871 static void
  872 apm_identify(driver_t *driver, device_t parent)
  873 {
  874         device_t child;
  875 
  876         if (!cold) {
  877                 printf("Don't load this driver from userland!!\n");
  878                 return;
  879         }
  880 
  881         if (resource_disabled("apm", 0))
  882                 return;
  883 
  884         child = BUS_ADD_CHILD(parent, 0, "apm", 0);
  885         if (child == NULL)
  886                 panic("apm_identify");
  887 }
  888 
  889 /*
  890  * probe for APM BIOS
  891  */
  892 static int
  893 apm_probe(device_t dev)
  894 {
  895 #define APM_KERNBASE    KERNBASE
  896         struct vm86frame        vmf;
  897         struct apm_softc        *sc = &apm_softc;
  898 #ifdef PC98
  899         int                     rid;
  900 #endif
  901 
  902         device_set_desc(dev, "APM BIOS");
  903         if (device_get_unit(dev) > 0) {
  904                 printf("apm: Only one APM driver supported.\n");
  905                 return ENXIO;
  906         }
  907 
  908         if (power_pm_get_type() != POWER_PM_TYPE_NONE &&
  909             power_pm_get_type() != POWER_PM_TYPE_APM) {
  910                 printf("apm: Other PM system enabled.\n");
  911                 return ENXIO;
  912         }
  913 
  914         bzero(&vmf, sizeof(struct vm86frame));          /* safety */
  915         bzero(&apm_softc, sizeof(apm_softc));
  916         vmf.vmf_ah = APM_BIOS;
  917         vmf.vmf_al = APM_INSTCHECK;
  918         vmf.vmf_bx = 0;
  919         if (vm86_intcall(APM_INT, &vmf))
  920                 return ENXIO;                   /* APM not found */
  921         if (vmf.vmf_bx != 0x504d) {
  922                 printf("apm: incorrect signature (0x%x)\n", vmf.vmf_bx);
  923                 return ENXIO;
  924         }
  925         if ((vmf.vmf_cx & (APM_32BIT_SUPPORT | APM_16BIT_SUPPORT)) == 0) {
  926                 printf("apm: protected mode connections are not supported\n");
  927                 return ENXIO;
  928         }
  929 
  930         apm_version = vmf.vmf_ax;
  931         sc->slow_idle_cpu = ((vmf.vmf_cx & APM_CPUIDLE_SLOW) != 0);
  932         sc->disabled = ((vmf.vmf_cx & APM_DISABLED) != 0);
  933         sc->disengaged = ((vmf.vmf_cx & APM_DISENGAGED) != 0);
  934 
  935         vmf.vmf_ah = APM_BIOS;
  936         vmf.vmf_al = APM_DISCONNECT;
  937         vmf.vmf_bx = 0;
  938         vm86_intcall(APM_INT, &vmf);            /* disconnect, just in case */
  939 
  940 #ifdef PC98
  941         /* PC98 have bogos APM 32bit BIOS */
  942         if ((vmf.vmf_cx & APM_32BIT_SUPPORT) == 0)
  943                 return ENXIO;
  944         rid = 0;
  945         bus_set_resource(dev, SYS_RES_IOPORT, rid,
  946                          APM_NECSMM_PORT, APM_NECSMM_PORTSZ);
  947         sc->sc_res = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
  948                          APM_NECSMM_PORT, ~0, APM_NECSMM_PORTSZ, RF_ACTIVE);
  949         if (sc->sc_res == NULL) {
  950                 printf("apm: cannot open NEC smm device\n");
  951                 return ENXIO;
  952         }
  953         bus_release_resource(dev, SYS_RES_IOPORT, rid, sc->sc_res);
  954 
  955         vmf.vmf_ah = APM_BIOS;
  956         vmf.vmf_al = APM_PROT32CONNECT;
  957         vmf.vmf_bx = 0;
  958         if (vm86_intcall(APM_INT, &vmf)) {
  959                 printf("apm: 32-bit connection error.\n");
  960                 return (ENXIO);
  961         }
  962 
  963         sc->bios.seg.code32.base = (vmf.vmf_ax << 4) + APM_KERNBASE;
  964         sc->bios.seg.code32.limit = 0xffff;
  965         sc->bios.seg.code16.base = (vmf.vmf_cx << 4) + APM_KERNBASE;
  966         sc->bios.seg.code16.limit = 0xffff;
  967         sc->bios.seg.data.base = (vmf.vmf_dx << 4) + APM_KERNBASE;
  968         sc->bios.seg.data.limit = 0xffff;
  969         sc->bios.entry = vmf.vmf_ebx;
  970         sc->connectmode = APM_PROT32CONNECT;
  971 #else
  972         if ((vmf.vmf_cx & APM_32BIT_SUPPORT) != 0) {
  973                 vmf.vmf_ah = APM_BIOS;
  974                 vmf.vmf_al = APM_PROT32CONNECT;
  975                 vmf.vmf_bx = 0;
  976                 if (vm86_intcall(APM_INT, &vmf)) {
  977                         printf("apm: 32-bit connection error.\n");
  978                         return (ENXIO);
  979                 }
  980                 sc->bios.seg.code32.base = (vmf.vmf_ax << 4) + APM_KERNBASE;
  981                 sc->bios.seg.code32.limit = 0xffff;
  982                 sc->bios.seg.code16.base = (vmf.vmf_cx << 4) + APM_KERNBASE;
  983                 sc->bios.seg.code16.limit = 0xffff;
  984                 sc->bios.seg.data.base = (vmf.vmf_dx << 4) + APM_KERNBASE;
  985                 sc->bios.seg.data.limit = 0xffff;
  986                 sc->bios.entry = vmf.vmf_ebx;
  987                 sc->connectmode = APM_PROT32CONNECT;
  988         } else {
  989                 /* use 16-bit connection */
  990                 vmf.vmf_ah = APM_BIOS;
  991                 vmf.vmf_al = APM_PROT16CONNECT;
  992                 vmf.vmf_bx = 0;
  993                 if (vm86_intcall(APM_INT, &vmf)) {
  994                         printf("apm: 16-bit connection error.\n");
  995                         return (ENXIO);
  996                 }
  997                 sc->bios.seg.code16.base = (vmf.vmf_ax << 4) + APM_KERNBASE;
  998                 sc->bios.seg.code16.limit = 0xffff;
  999                 sc->bios.seg.data.base = (vmf.vmf_cx << 4) + APM_KERNBASE;
 1000                 sc->bios.seg.data.limit = 0xffff;
 1001                 sc->bios.entry = vmf.vmf_bx;
 1002                 sc->connectmode = APM_PROT16CONNECT;
 1003         }
 1004 #endif
 1005         return(0);
 1006 }
 1007 
 1008 
 1009 /*
 1010  * return 0 if the user will notice and handle the event,
 1011  * return 1 if the kernel driver should do so.
 1012  */
 1013 static int
 1014 apm_record_event(struct apm_softc *sc, u_int event_type)
 1015 {
 1016         struct apm_event_info *evp;
 1017 
 1018         if ((sc->sc_flags & SCFLAG_OPEN) == 0)
 1019                 return 1;               /* no user waiting */
 1020         if (sc->event_count == APM_NEVENTS)
 1021                 return 1;                       /* overflow */
 1022         if (sc->event_filter[event_type] == 0)
 1023                 return 1;               /* not registered */
 1024         evp = &sc->event_list[sc->event_ptr];
 1025         sc->event_count++;
 1026         sc->event_ptr++;
 1027         sc->event_ptr %= APM_NEVENTS;
 1028         evp->type = event_type;
 1029         evp->index = ++apm_evindex;
 1030         selwakeuppri(&sc->sc_rsel, PZERO);
 1031         return (sc->sc_flags & SCFLAG_OCTL) ? 0 : 1; /* user may handle */
 1032 }
 1033 
 1034 /* Power profile */
 1035 static void
 1036 apm_power_profile(struct apm_softc *sc)
 1037 {
 1038         int state;
 1039         struct apm_info info;
 1040         static int apm_acline = 0;
 1041 
 1042         if (apm_get_info(&info))
 1043                 return;
 1044 
 1045         if (apm_acline != info.ai_acline) {
 1046                 apm_acline = info.ai_acline;
 1047                 state = apm_acline ? POWER_PROFILE_PERFORMANCE : POWER_PROFILE_ECONOMY;
 1048                 power_profile_set_state(state);
 1049         }
 1050 }
 1051 
 1052 /* Process APM event */
 1053 static void
 1054 apm_processevent(void)
 1055 {
 1056         int apm_event;
 1057         struct apm_softc *sc = &apm_softc;
 1058 
 1059 #define OPMEV_DEBUGMESSAGE(symbol) case symbol:                         \
 1060         APM_DPRINT("Received APM Event: " #symbol "\n");
 1061 
 1062         do {
 1063                 apm_event = apm_getevent();
 1064                 switch (apm_event) {
 1065                     OPMEV_DEBUGMESSAGE(PMEV_STANDBYREQ);
 1066                         if (apm_op_inprog == 0) {
 1067                             apm_op_inprog++;
 1068                             if (apm_record_event(sc, apm_event)) {
 1069                                 apm_suspend(PMST_STANDBY);
 1070                             }
 1071                         }
 1072                         break;
 1073                     OPMEV_DEBUGMESSAGE(PMEV_USERSTANDBYREQ);
 1074                         if (apm_op_inprog == 0) {
 1075                             apm_op_inprog++;
 1076                             if (apm_record_event(sc, apm_event)) {
 1077                                 apm_suspend(PMST_STANDBY);
 1078                             }
 1079                         }
 1080                         break;
 1081                     OPMEV_DEBUGMESSAGE(PMEV_SUSPENDREQ);
 1082                         apm_lastreq_notify();
 1083                         if (apm_op_inprog == 0) {
 1084                             apm_op_inprog++;
 1085                             if (apm_record_event(sc, apm_event)) {
 1086                                 apm_do_suspend();
 1087                             }
 1088                         }
 1089                         return; /* XXX skip the rest */
 1090                     OPMEV_DEBUGMESSAGE(PMEV_USERSUSPENDREQ);
 1091                         apm_lastreq_notify();
 1092                         if (apm_op_inprog == 0) {
 1093                             apm_op_inprog++;
 1094                             if (apm_record_event(sc, apm_event)) {
 1095                                 apm_do_suspend();
 1096                             }
 1097                         }
 1098                         return; /* XXX skip the rest */
 1099                     OPMEV_DEBUGMESSAGE(PMEV_CRITSUSPEND);
 1100                         apm_do_suspend();
 1101                         break;
 1102                     OPMEV_DEBUGMESSAGE(PMEV_NORMRESUME);
 1103                         apm_record_event(sc, apm_event);
 1104                         apm_resume();
 1105                         break;
 1106                     OPMEV_DEBUGMESSAGE(PMEV_CRITRESUME);
 1107                         apm_record_event(sc, apm_event);
 1108                         apm_resume();
 1109                         break;
 1110                     OPMEV_DEBUGMESSAGE(PMEV_STANDBYRESUME);
 1111                         apm_record_event(sc, apm_event);
 1112                         break;
 1113                     OPMEV_DEBUGMESSAGE(PMEV_BATTERYLOW);
 1114                         if (apm_record_event(sc, apm_event)) {
 1115                             apm_battery_low();
 1116                             apm_suspend(PMST_SUSPEND);
 1117                         }
 1118                         break;
 1119                     OPMEV_DEBUGMESSAGE(PMEV_POWERSTATECHANGE);
 1120                         apm_record_event(sc, apm_event);
 1121                         apm_power_profile(sc);
 1122                         break;
 1123                     OPMEV_DEBUGMESSAGE(PMEV_UPDATETIME);
 1124                         apm_record_event(sc, apm_event);
 1125                         inittodr(0);    /* adjust time to RTC */
 1126                         break;
 1127                     OPMEV_DEBUGMESSAGE(PMEV_CAPABILITIESCHANGE);
 1128                         apm_record_event(sc, apm_event);
 1129                         apm_power_profile(sc);
 1130                         break;
 1131                     case PMEV_NOEVENT:
 1132                         break;
 1133                     default:
 1134                         printf("Unknown Original APM Event 0x%x\n", apm_event);
 1135                             break;
 1136                 }
 1137         } while (apm_event != PMEV_NOEVENT);
 1138 #ifdef PC98
 1139         apm_disable_smm(sc);
 1140 #endif
 1141 }
 1142 
 1143 /*
 1144  * Attach APM:
 1145  *
 1146  * Initialize APM driver
 1147  */
 1148 
 1149 static int
 1150 apm_attach(device_t dev)
 1151 {
 1152         struct apm_softc        *sc = &apm_softc;
 1153         int                     drv_version;
 1154 #ifdef PC98
 1155         int                     rid;
 1156 #endif
 1157         mtx_init(&sc->mtx, device_get_nameunit(dev), "apm", MTX_DEF);
 1158         cv_init(&sc->cv, "cbb cv");
 1159 
 1160 #ifndef PC98
 1161         if (device_get_flags(dev) & 0x20)
 1162                 atrtcclock_disable = 1;
 1163 #endif
 1164 
 1165         sc->initialized = 0;
 1166 
 1167         /* Must be externally enabled */
 1168         sc->active = 0;
 1169 
 1170         /* Always call HLT in idle loop */
 1171         sc->always_halt_cpu = 1;
 1172 
 1173         getenv_int("debug.apm_debug", &apm_debug);
 1174 
 1175         /* print bootstrap messages */
 1176         APM_DPRINT("apm: APM BIOS version %04lx\n",  apm_version);
 1177         APM_DPRINT("apm: Code16 0x%08x, Data 0x%08x\n",
 1178             sc->bios.seg.code16.base, sc->bios.seg.data.base);
 1179         APM_DPRINT("apm: Code entry 0x%08x, Idling CPU %s, Management %s\n",
 1180             sc->bios.entry, is_enabled(sc->slow_idle_cpu),
 1181             is_enabled(!sc->disabled));
 1182         APM_DPRINT("apm: CS_limit=0x%x, DS_limit=0x%x\n",
 1183             sc->bios.seg.code16.limit, sc->bios.seg.data.limit);
 1184 
 1185 #ifdef PC98
 1186         rid = 0;
 1187         sc->sc_res = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
 1188                          APM_NECSMM_PORT, ~0, APM_NECSMM_PORTSZ, RF_ACTIVE);
 1189         if (sc->sc_res == NULL)
 1190                 panic("%s: counldn't map I/O ports", device_get_name(dev));
 1191         sc->sc_iot = rman_get_bustag(sc->sc_res);
 1192         sc->sc_ioh = rman_get_bushandle(sc->sc_res);
 1193 
 1194         if (apm_version==0x112 || apm_version==0x111 || apm_version==0x110)
 1195                 apm_necsmm_addr = APM_NECSMM_PORT;
 1196         else
 1197                 apm_necsmm_addr = 0;
 1198         apm_necsmm_mask = ~APM_NECSMM_EN;
 1199 #endif /* PC98 */
 1200 
 1201         /*
 1202          * In one test, apm bios version was 1.02; an attempt to register
 1203          * a 1.04 driver resulted in a 1.00 connection!  Registering a
 1204          * 1.02 driver resulted in a 1.02 connection.
 1205          */
 1206         drv_version = apm_version > 0x102 ? 0x102 : apm_version;
 1207         for (; drv_version > 0x100; drv_version--)
 1208                 if (apm_driver_version(drv_version) == 0)
 1209                         break;
 1210         sc->minorversion = ((drv_version & 0x00f0) >>  4) * 10 +
 1211                 ((drv_version & 0x000f) >> 0);
 1212         sc->majorversion = ((drv_version & 0xf000) >> 12) * 10 +
 1213                 ((apm_version & 0x0f00) >> 8);
 1214 
 1215         sc->intversion = INTVERSION(sc->majorversion, sc->minorversion);
 1216 
 1217         if (sc->intversion >= INTVERSION(1, 1))
 1218                 APM_DPRINT("apm: Engaged control %s\n", is_enabled(!sc->disengaged));
 1219         device_printf(dev, "found APM BIOS v%ld.%ld, connected at v%d.%d\n",
 1220                ((apm_version & 0xf000) >> 12) * 10 + ((apm_version & 0x0f00) >> 8),
 1221                ((apm_version & 0x00f0) >> 4) * 10 + ((apm_version & 0x000f) >> 0),
 1222                sc->majorversion, sc->minorversion);
 1223 
 1224 
 1225         APM_DPRINT("apm: Slow Idling CPU %s\n", is_enabled(sc->slow_idle_cpu));
 1226         /* enable power management */
 1227         if (sc->disabled) {
 1228                 if (apm_enable_disable_pm(1)) {
 1229                         APM_DPRINT("apm: *Warning* enable function failed! [%x]\n",
 1230                             (sc->bios.r.eax >> 8) & 0xff);
 1231                 }
 1232         }
 1233 
 1234         /* engage power managment (APM 1.1 or later) */
 1235         if (sc->intversion >= INTVERSION(1, 1) && sc->disengaged) {
 1236                 if (apm_engage_disengage_pm(1)) {
 1237                         APM_DPRINT("apm: *Warning* engage function failed err=[%x]",
 1238                             (sc->bios.r.eax >> 8) & 0xff);
 1239                         APM_DPRINT(" (Docked or using external power?).\n");
 1240                 }
 1241         }
 1242 
 1243         /* Power the system off using APM */
 1244         EVENTHANDLER_REGISTER(shutdown_final, apm_power_off, NULL, 
 1245                               SHUTDOWN_PRI_LAST);
 1246 
 1247         /* Register APM again to pass the correct argument of pm_func. */
 1248         power_pm_register(POWER_PM_TYPE_APM, apm_pm_func, sc);
 1249 
 1250         sc->initialized = 1;
 1251         sc->suspending = 0;
 1252         sc->running = 0;
 1253 
 1254         make_dev(&apm_cdevsw, APMDEV_NORMAL,
 1255             UID_ROOT, GID_OPERATOR, 0664, "apm");
 1256         make_dev(&apm_cdevsw, APMDEV_CTL,
 1257             UID_ROOT, GID_OPERATOR, 0660, "apmctl");
 1258         return 0;
 1259 }
 1260 
 1261 static int
 1262 apmopen(struct cdev *dev, int flag, int fmt, struct thread *td)
 1263 {
 1264         struct apm_softc *sc = &apm_softc;
 1265 
 1266         if (sc == NULL || sc->initialized == 0)
 1267                 return (ENXIO);
 1268 
 1269         switch (dev2unit(dev)) {
 1270         case APMDEV_CTL:
 1271                 if (!(flag & FWRITE))
 1272                         return EINVAL;
 1273                 if (sc->sc_flags & SCFLAG_OCTL)
 1274                         return EBUSY;
 1275                 sc->sc_flags |= SCFLAG_OCTL;
 1276                 bzero(sc->event_filter, sizeof sc->event_filter);
 1277                 break;
 1278         case APMDEV_NORMAL:
 1279                 sc->sc_flags |= SCFLAG_ONORMAL;
 1280                 break;
 1281         }
 1282         return 0;
 1283 }
 1284 
 1285 static int
 1286 apmclose(struct cdev *dev, int flag, int fmt, struct thread *td)
 1287 {
 1288         struct apm_softc *sc = &apm_softc;
 1289 
 1290         switch (dev2unit(dev)) {
 1291         case APMDEV_CTL:
 1292                 apm_lastreq_rejected();
 1293                 sc->sc_flags &= ~SCFLAG_OCTL;
 1294                 bzero(sc->event_filter, sizeof sc->event_filter);
 1295                 break;
 1296         case APMDEV_NORMAL:
 1297                 sc->sc_flags &= ~SCFLAG_ONORMAL;
 1298                 break;
 1299         }
 1300         if ((sc->sc_flags & SCFLAG_OPEN) == 0) {
 1301                 sc->event_count = 0;
 1302                 sc->event_ptr = 0;
 1303         }
 1304         return 0;
 1305 }
 1306 
 1307 static int
 1308 apmioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td)
 1309 {
 1310         struct apm_softc *sc = &apm_softc;
 1311         struct apm_bios_arg *args;
 1312         int error = 0;
 1313         int ret;
 1314         int newstate;
 1315 
 1316         if (sc == NULL || sc->initialized == 0)
 1317                 return (ENXIO);
 1318 
 1319         APM_DPRINT("APM ioctl: cmd = 0x%lx\n", cmd);
 1320         switch (cmd) {
 1321         case APMIO_SUSPEND:
 1322                 if (!(flag & FWRITE))
 1323                         return (EPERM);
 1324                 if (sc->active)
 1325                         apm_suspend(PMST_SUSPEND);
 1326                 else
 1327                         error = EINVAL;
 1328                 break;
 1329 
 1330         case APMIO_STANDBY:
 1331                 if (!(flag & FWRITE))
 1332                         return (EPERM);
 1333                 if (sc->active)
 1334                         apm_suspend(PMST_STANDBY);
 1335                 else
 1336                         error = EINVAL;
 1337                 break;
 1338 
 1339         case APMIO_GETINFO_OLD:
 1340                 {
 1341                         struct apm_info info;
 1342                         apm_info_old_t aiop;
 1343 
 1344                         if (apm_get_info(&info))
 1345                                 error = ENXIO;
 1346                         aiop = (apm_info_old_t)addr;
 1347                         aiop->ai_major = info.ai_major;
 1348                         aiop->ai_minor = info.ai_minor;
 1349                         aiop->ai_acline = info.ai_acline;
 1350                         aiop->ai_batt_stat = info.ai_batt_stat;
 1351                         aiop->ai_batt_life = info.ai_batt_life;
 1352                         aiop->ai_status = info.ai_status;
 1353                 }
 1354                 break;
 1355         case APMIO_GETINFO:
 1356                 if (apm_get_info((apm_info_t)addr))
 1357                         error = ENXIO;
 1358                 break;
 1359         case APMIO_GETPWSTATUS:
 1360                 if (apm_get_pwstatus((apm_pwstatus_t)addr))
 1361                         error = ENXIO;
 1362                 break;
 1363         case APMIO_ENABLE:
 1364                 if (!(flag & FWRITE))
 1365                         return (EPERM);
 1366                 apm_event_enable();
 1367                 break;
 1368         case APMIO_DISABLE:
 1369                 if (!(flag & FWRITE))
 1370                         return (EPERM);
 1371                 apm_event_disable();
 1372                 break;
 1373         case APMIO_HALTCPU:
 1374                 if (!(flag & FWRITE))
 1375                         return (EPERM);
 1376                 apm_halt_cpu();
 1377                 break;
 1378         case APMIO_NOTHALTCPU:
 1379                 if (!(flag & FWRITE))
 1380                         return (EPERM);
 1381                 apm_not_halt_cpu();
 1382                 break;
 1383         case APMIO_DISPLAY:
 1384                 if (!(flag & FWRITE))
 1385                         return (EPERM);
 1386                 newstate = *(int *)addr;
 1387                 if (apm_display(newstate))
 1388                         error = ENXIO;
 1389                 break;
 1390         case APMIO_BIOS:
 1391                 if (!(flag & FWRITE))
 1392                         return (EPERM);
 1393                 /* XXX compatibility with the old interface */
 1394                 args = (struct apm_bios_arg *)addr;
 1395 #ifdef PC98
 1396                 if (((args->eax >> 8) & 0xff) == 0x53) {
 1397                         sc->bios.r.eax = args->eax & ~0xffff;
 1398                         sc->bios.r.eax |= APM_BIOS << 8;
 1399                         switch (args->eax & 0xff) {
 1400                         case 0x0a:
 1401                                 sc->bios.r.eax |= APM_GETPWSTATUS;
 1402                                 break;
 1403                         case 0x0e:
 1404                                 sc->bios.r.eax |= APM_DRVVERSION;
 1405                                 break;
 1406                         default:
 1407                                 sc->bios.r.eax |= args->eax & 0xff;
 1408                                 break;
 1409                         }
 1410                 } else
 1411 #endif
 1412                 sc->bios.r.eax = args->eax;
 1413                 sc->bios.r.ebx = args->ebx;
 1414                 sc->bios.r.ecx = args->ecx;
 1415                 sc->bios.r.edx = args->edx;
 1416                 sc->bios.r.esi = args->esi;
 1417                 sc->bios.r.edi = args->edi;
 1418                 if ((ret = apm_bioscall())) {
 1419                         /*
 1420                          * Return code 1 means bios call was unsuccessful.
 1421                          * Error code is stored in %ah.
 1422                          * Return code -1 means bios call was unsupported
 1423                          * in the APM BIOS version.
 1424                          */
 1425                         if (ret == -1) {
 1426                                 error = EINVAL;
 1427                         }
 1428                 } else {
 1429                         /*
 1430                          * Return code 0 means bios call was successful.
 1431                          * We need only %al and can discard %ah.
 1432                          */
 1433                         sc->bios.r.eax &= 0xff;
 1434                 }
 1435                 args->eax = sc->bios.r.eax;
 1436                 args->ebx = sc->bios.r.ebx;
 1437                 args->ecx = sc->bios.r.ecx;
 1438                 args->edx = sc->bios.r.edx;
 1439                 args->esi = sc->bios.r.esi;
 1440                 args->edi = sc->bios.r.edi;
 1441                 break;
 1442         default:
 1443                 error = EINVAL;
 1444                 break;
 1445         }
 1446 
 1447         /* for /dev/apmctl */
 1448         if (dev2unit(dev) == APMDEV_CTL) {
 1449                 struct apm_event_info *evp;
 1450                 int i;
 1451 
 1452                 error = 0;
 1453                 switch (cmd) {
 1454                 case APMIO_NEXTEVENT:
 1455                         if (!sc->event_count) {
 1456                                 error = EAGAIN;
 1457                         } else {
 1458                                 evp = (struct apm_event_info *)addr;
 1459                                 i = sc->event_ptr + APM_NEVENTS - sc->event_count;
 1460                                 i %= APM_NEVENTS;
 1461                                 *evp = sc->event_list[i];
 1462                                 sc->event_count--;
 1463                         }
 1464                         break;
 1465                 case APMIO_REJECTLASTREQ:
 1466                         if (apm_lastreq_rejected()) {
 1467                                 error = EINVAL;
 1468                         }
 1469                         break;
 1470                 default:
 1471                         error = EINVAL;
 1472                         break;
 1473                 }
 1474         }
 1475 
 1476         return error;
 1477 }
 1478 
 1479 static int
 1480 apmwrite(struct cdev *dev, struct uio *uio, int ioflag)
 1481 {
 1482         struct apm_softc *sc = &apm_softc;
 1483         u_int event_type;
 1484         int error;
 1485         u_char enabled;
 1486 
 1487         if (dev2unit(dev) != APMDEV_CTL)
 1488                 return(ENODEV);
 1489         if (uio->uio_resid != sizeof(u_int))
 1490                 return(E2BIG);
 1491 
 1492         if ((error = uiomove((caddr_t)&event_type, sizeof(u_int), uio)))
 1493                 return(error);
 1494 
 1495         if (event_type < 0 || event_type >= APM_NPMEV)
 1496                 return(EINVAL);
 1497 
 1498         if (sc->event_filter[event_type] == 0) {
 1499                 enabled = 1;
 1500         } else {
 1501                 enabled = 0;
 1502         }
 1503         sc->event_filter[event_type] = enabled;
 1504         APM_DPRINT("apmwrite: event 0x%x %s\n", event_type, is_enabled(enabled));
 1505 
 1506         return uio->uio_resid;
 1507 }
 1508 
 1509 static int
 1510 apmpoll(struct cdev *dev, int events, struct thread *td)
 1511 {
 1512         struct apm_softc *sc = &apm_softc;
 1513         int revents = 0;
 1514 
 1515         if (events & (POLLIN | POLLRDNORM)) {
 1516                 if (sc->event_count) {
 1517                         revents |= events & (POLLIN | POLLRDNORM);
 1518                 } else {
 1519                         selrecord(td, &sc->sc_rsel);
 1520                 }
 1521         }
 1522 
 1523         return (revents);
 1524 }
 1525 
 1526 static device_method_t apm_methods[] = {
 1527         /* Device interface */
 1528         DEVMETHOD(device_identify,      apm_identify),
 1529         DEVMETHOD(device_probe,         apm_probe),
 1530         DEVMETHOD(device_attach,        apm_attach),
 1531 
 1532         { 0, 0 }
 1533 };
 1534 
 1535 static driver_t apm_driver = {
 1536         "apm",
 1537         apm_methods,
 1538         1,                      /* no softc (XXX) */
 1539 };
 1540 
 1541 static devclass_t apm_devclass;
 1542 
 1543 DRIVER_MODULE(apm, legacy, apm_driver, apm_devclass, apm_modevent, 0);
 1544 MODULE_VERSION(apm, 1);
 1545 
 1546 static int
 1547 apm_pm_func(u_long cmd, void *arg, ...)
 1548 {
 1549         int     state, apm_state;
 1550         int     error;
 1551         va_list ap;
 1552 
 1553         error = 0;
 1554         switch (cmd) {
 1555         case POWER_CMD_SUSPEND:
 1556                 va_start(ap, arg);
 1557                 state = va_arg(ap, int);
 1558                 va_end(ap);     
 1559 
 1560                 switch (state) {
 1561                 case POWER_SLEEP_STATE_STANDBY:
 1562                         apm_state = PMST_STANDBY;
 1563                         break;
 1564                 case POWER_SLEEP_STATE_SUSPEND:
 1565                 case POWER_SLEEP_STATE_HIBERNATE:
 1566                         apm_state = PMST_SUSPEND;
 1567                         break;
 1568                 default:
 1569                         error = EINVAL;
 1570                         goto out;
 1571                 }
 1572 
 1573                 apm_suspend(apm_state);
 1574                 break;
 1575 
 1576         default:
 1577                 error = EINVAL;
 1578                 goto out;
 1579         }
 1580 
 1581 out:
 1582         return (error);
 1583 }
 1584 
 1585 static void
 1586 apm_pm_register(void *arg)
 1587 {
 1588 
 1589         if (!resource_disabled("apm", 0))
 1590                 power_pm_register(POWER_PM_TYPE_APM, apm_pm_func, NULL);
 1591 }
 1592 
 1593 SYSINIT(power, SI_SUB_KLD, SI_ORDER_ANY, apm_pm_register, 0);

Cache object: 738f2e25fc1ef9da28e9d2b54951bf4e


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.