root/arch/i386/i386/apm.c

DEFINITIONS

1. apm_get_event
2. apm_err_translate
3. apm_perror
4. apm_power_print
5. apm_suspend
6. apm_standby
7. apm_resume
8. apm_record_event
9. apm_handle_event
10. apm_periodic_check
11. apm_powmgt_enable
12. apm_powmgt_engage
13. apm_devpowmgt_enable
14. apm_set_powstate
15. apm_cpu_busy
16. apm_cpu_idle
17. apm_set_ver
18. apm_disconnect
19. apmprobe
20. apmattach
21. apm_thread_create
22. apm_thread
23. apmopen
24. apmclose
25. apmioctl
26. filt_apmrdetach
27. filt_apmread
28. apmkqfilter

    1 /*      $OpenBSD: apm.c,v 1.76 2007/07/02 17:11:29 thib Exp $   */
    3 /*-
    4  * Copyright (c) 1998-2001 Michael Shalayeff. All rights reserved.
    5  * Copyright (c) 1995 John T. Kohl.  All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. All advertising materials mentioning features or use of this software
   16  *    must display the following acknowledgement:
   17  *      This product includes software developed by the University of
   18  *      California, Berkeley and its contributors.
   19  * 4. Neither the name of the University nor the names of its contributors
   20  *    may be used to endorse or promote products derived from this software
   21  *    without specific prior written permission.
   22  *
   23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   29  * OR SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   33  * SUCH DAMAGE.
   34  *
   35  */
   37 #include "apm.h"
   39 #if NAPM > 1
   40 #error only one APM device may be configured
   41 #endif
   43 #include <sys/param.h>
   44 #include <sys/systm.h>
   45 #include <sys/signalvar.h>
   46 #include <sys/kernel.h>
   47 #include <sys/kthread.h>
   48 #include <sys/rwlock.h>
   49 #include <sys/proc.h>
   50 #include <sys/user.h>
   51 #include <sys/malloc.h>
   52 #include <sys/device.h>
   53 #include <sys/fcntl.h>
   54 #include <sys/ioctl.h>
   55 #include <sys/event.h>
   56 #include <sys/mount.h>  /* for vfs_syncwait() proto */
   58 #include <machine/conf.h>
   59 #include <machine/cpu.h>
   60 #include <machine/cpufunc.h>
   61 #include <machine/gdt.h>
   62 #include <machine/psl.h>
   64 #include <dev/isa/isareg.h>
   65 #include <i386/isa/isa_machdep.h>
   66 #include <i386/isa/nvram.h>
   67 #include <dev/isa/isavar.h>
   69 #include <machine/biosvar.h>
   70 #include <machine/apmvar.h>
   72 #if defined(APMDEBUG)
   73 #define DPRINTF(x)      printf x
   74 #else
   75 #define DPRINTF(x)      /**/
   76 #endif
   78 struct cfdriver apm_cd = {
NULL, "apm", DV_DULL
   80 };
   82 struct apm_softc {
   83         struct device sc_dev;
   84         struct klist sc_note;
   85         int     sc_flags;
   86         int     batt_life;
   87         struct proc *sc_thread;
   88         struct rwlock sc_lock;
   89 };
   90 #define SCFLAG_OREAD    0x0000001
   91 #define SCFLAG_OWRITE   0x0000002
   92 #define SCFLAG_OPEN     (SCFLAG_OREAD|SCFLAG_OWRITE)
   94 int     apmprobe(struct device *, void *, void *);
   95 void    apmattach(struct device *, struct device *, void *);
   97 struct cfattach apm_ca = {
   98         sizeof(struct apm_softc), apmprobe, apmattach
   99 };
  101 void    filt_apmrdetach(struct knote *kn);
  102 int     filt_apmread(struct knote *kn, long hint);
  104 struct filterops apmread_filtops = {
  105         1, NULL, filt_apmrdetach, filt_apmread
  106 };
  108 /* battery percentage at where we get verbose in our warnings.  This
  109  * value can be changed using sysctl(8), value machdep.apmwarn.
  110  * Setting it to zero kills all warnings
  111  */
  112 int     cpu_apmwarn = 10;
  114 #define APM_RESUME_HOLDOFF      3
  116 /*
  117  * Flags to control kernel display
  118  *      SCFLAG_NOPRINT:         do not output APM power messages due to
  119  *                              a power change event.
  120  *
  121  *      SCFLAG_PCTPRINT:        do not output APM power messages due to
  122  *                              to a power change event unless the battery
  123  *                              percentage changes.
  124  */
  125 #define SCFLAG_NOPRINT  0x0008000
  126 #define SCFLAG_PCTPRINT 0x0004000
  127 #define SCFLAG_PRINT    (SCFLAG_NOPRINT|SCFLAG_PCTPRINT)
  129 #define APMUNIT(dev)    (minor(dev)&0xf0)
  130 #define APMDEV(dev)     (minor(dev)&0x0f)
  131 #define APMDEV_NORMAL   0
  132 #define APMDEV_CTL      8
  134 int     apm_standbys;
  135 int     apm_userstandbys;
  136 int     apm_suspends;
  137 int     apm_resumes;
  138 int     apm_battlow;
  139 int     apm_evindex;
  140 int     apm_error;
  141 int     apm_op_inprog;
u_int   apm_flags;
u_char  apm_majver;
u_char  apm_minver;
  146 int     apm_dobusy = 0;
  147 int     apm_doidle = 0;
  148 int     apm_bebatt = 0;
  149 int     apm_idle_called = 0;
  150 int     apm_attached = 0;
  152 struct {
u_int32_t entry;
u_int16_t seg;
u_int16_t pad;
  156 } apm_ep;
  158 struct apmregs {
u_int32_t       ax;
u_int32_t       bx;
u_int32_t       cx;
u_int32_t       dx;
  163 };
  165 int  apmcall(u_int, u_int, struct apmregs *);
  166 void apm_power_print(struct apm_softc *, struct apmregs *);
  167 int  apm_handle_event(struct apm_softc *, struct apmregs *);
  168 void apm_set_ver(struct apm_softc *);
  169 int  apm_periodic_check(struct apm_softc *);
  170 void apm_thread_create(void *v);
  171 void apm_thread(void *);
  172 void apm_disconnect(struct apm_softc *);
  173 void apm_perror(const char *, struct apmregs *);
  174 void apm_powmgt_enable(int onoff);
  175 void apm_powmgt_engage(int onoff, u_int devid);
  176 /* void apm_devpowmgt_enable(int onoff, u_int devid); */
  177 int  apm_record_event(struct apm_softc *sc, u_int type);
  178 const char *apm_err_translate(int code);
  180 #define apm_get_powstat(r) apmcall(APM_POWER_STATUS, APM_DEV_ALLDEVS, r)
  181 void    apm_standby(void);
  182 void    apm_suspend(void);
  183 void    apm_resume(struct apm_softc *, struct apmregs *);
  185 static int __inline
apm_get_event(struct apmregs *r)
  187 {
  188         int rv;
bzero(r, sizeof(*r));
rv = apmcall(APM_GET_PM_EVENT, 0, r);
  192         return rv;
  193 }
  195 const char *
apm_err_translate(int code)
  197 {
  198         switch (code) {
  199         case APM_ERR_PM_DISABLED:
  200                 return "power management disabled";
  201         case APM_ERR_REALALREADY:
  202                 return "real mode interface already connected";
  203         case APM_ERR_NOTCONN:
  204                 return "interface not connected";
  205         case APM_ERR_16ALREADY:
  206                 return "16-bit interface already connected";
  207         case APM_ERR_16NOTSUPP:
  208                 return "16-bit interface not supported";
  209         case APM_ERR_32ALREADY:
  210                 return "32-bit interface already connected";
  211         case APM_ERR_32NOTSUPP:
  212                 return "32-bit interface not supported";
  213         case APM_ERR_UNRECOG_DEV:
  214                 return "unrecognized device ID";
  215         case APM_ERR_ERANGE:
  216                 return "parameter out of range";
  217         case APM_ERR_NOTENGAGED:
  218                 return "interface not engaged";
  219         case APM_ERR_UNABLE:
  220                 return "unable to enter requested state";
  221         case APM_ERR_NOEVENTS:
  222                 return "No pending events";
  223         case APM_ERR_NOT_PRESENT:
  224                 return "No APM present";
  225         default:
  226                 return "unknown error code?";
  227         }
  228 }
  230 int apmerrors = 0;
  232 void
apm_perror(const char *str, struct apmregs *regs)
  234 {
printf("apm0: APM %s: %s (%d)\n", str,
apm_err_translate(APM_ERR_CODE(regs)),
APM_ERR_CODE(regs));
delay(1000000);
apmerrors++;
  241 }
  243 void
apm_power_print (struct apm_softc *sc, struct apmregs *regs)
  245 {
  246 #if !defined(APM_NOPRINT)
sc->batt_life = BATT_LIFE(regs);
  248         if (BATT_LIFE(regs) != APM_BATT_LIFE_UNKNOWN) {
printf("%s: battery life expectancy %d%%\n",
sc->sc_dev.dv_xname,
BATT_LIFE(regs));
  252         }
printf("%s: AC ", sc->sc_dev.dv_xname);
  254         switch (AC_STATE(regs)) {
  255         case APM_AC_OFF:
printf("off,");
  257                 break;
  258         case APM_AC_ON:
printf("on,");
  260                 break;
  261         case APM_AC_BACKUP:
printf("backup power,");
  263                 break;
  264         default:
  265         case APM_AC_UNKNOWN:
printf("unknown,");
  267                 break;
  268         }
  269         if (apm_minver == 0) {
printf(" battery is ");
  271                 switch (BATT_STATE(regs)) {
  272                 case APM_BATT_HIGH:
printf("high");
  274                         break;
  275                 case APM_BATT_LOW:
printf("low");
  277                         break;
  278                 case APM_BATT_CRITICAL:
printf("CRITICAL");
  280                         break;
  281                 case APM_BATT_CHARGING:
printf("charging");
  283                         break;
  284                 case APM_BATT_UNKNOWN:
printf("unknown");
  286                         break;
  287                 default:
printf("undecoded (%x)", BATT_STATE(regs));
  289                         break;
  290                 }
  291         } else if (apm_minver >= 1) {
  292                 if (BATT_FLAGS(regs) & APM_BATT_FLAG_NOBATTERY)
printf(" no battery");
  294                 else {
printf(" battery charge ");
  296                         if (BATT_FLAGS(regs) & APM_BATT_FLAG_HIGH)
printf("high");
  298                         else if (BATT_FLAGS(regs) & APM_BATT_FLAG_LOW)
printf("low");
  300                         else if (BATT_FLAGS(regs) & APM_BATT_FLAG_CRITICAL)
printf("critical");
  302                         else
printf("unknown");
  304                         if (BATT_FLAGS(regs) & APM_BATT_FLAG_CHARGING)
printf(", charging");
  306                         if (BATT_REM_VALID(regs)) {
  307                                 int life = BATT_REMAINING(regs);
  308                                 if (apm_bebatt)
life = swap16(life);
printf(", estimated %d:%02d hours",
life / 60, life % 60);
  312                         }
  313                 }
  314         }
printf("\n");
  317 #endif
  318 }
  320 void
apm_suspend()
  322 {
dopowerhooks(PWR_SUSPEND);
  325         if (cold)
vfs_syncwait(0);
  328         (void)apm_set_powstate(APM_DEV_ALLDEVS, APM_SYS_SUSPEND);
  329 }
  331 void
apm_standby()
  333 {
dopowerhooks(PWR_STANDBY);
  336         if (cold)
vfs_syncwait(0);
  339         (void)apm_set_powstate(APM_DEV_ALLDEVS, APM_SYS_STANDBY);
  340 }
  342 void
apm_resume(struct apm_softc *sc, struct apmregs *regs)
  344 {
  345         extern int perflevel;
apm_resumes = APM_RESUME_HOLDOFF;
  349         /* they say that some machines may require reinitializing the clock */
initrtclock();
inittodr(time_second);
  353         /* lower bit in cx means pccard was powered down */
dopowerhooks(PWR_RESUME);
apm_record_event(sc, regs->bx);
  357         /* acknowledge any rtc interrupt we may have missed */
rtcdrain(NULL);
  360         /* restore hw.setperf */
  361         if (cpu_setperf != NULL)
cpu_setperf(perflevel);
  363 }
  365 int
apm_record_event(struct apm_softc *sc, u_int type)
  367 {
  368         if (!apm_error && (sc->sc_flags & SCFLAG_OPEN) == 0) {
DPRINTF(("apm_record_event: no user waiting\n"));
apm_error++;
  371                 return 1;
  372         }
apm_evindex++;
KNOTE(&sc->sc_note, APM_EVENT_COMPOSE(type, apm_evindex));
  376         return (0);
  377 }
  379 int
apm_handle_event(struct apm_softc *sc, struct apmregs *regs)
  381 {
  382         struct apmregs nregs;
  383         int ret = 0;
  385         switch (regs->bx) {
  386         case APM_NOEVENT:
ret++;
  388                 break;
  390         case APM_USER_STANDBY_REQ:
  391                 if (apm_resumes || apm_op_inprog)
  392                         break;
DPRINTF(("user wants STANDBY--fat chance\n"));
apm_op_inprog++;
  395                 if (apm_record_event(sc, regs->bx)) {
DPRINTF(("standby ourselves\n"));
apm_userstandbys++;
  398                 }
  399                 break;
  400         case APM_STANDBY_REQ:
  401                 if (apm_resumes || apm_op_inprog)
  402                         break;
DPRINTF(("standby requested\n"));
  404                 if (apm_standbys || apm_suspends) {
DPRINTF(("premature standby\n"));
apm_error++;
ret++;
  408                 }
apm_op_inprog++;
  410                 if (apm_record_event(sc, regs->bx)) {
DPRINTF(("standby ourselves\n"));
apm_standbys++;
  413                 }
  414                 break;
  415         case APM_USER_SUSPEND_REQ:
  416                 if (apm_resumes || apm_op_inprog)
  417                         break;
DPRINTF(("user wants suspend--fat chance!\n"));
apm_op_inprog++;
  420                 if (apm_record_event(sc, regs->bx)) {
DPRINTF(("suspend ourselves\n"));
apm_suspends++;
  423                 }
  424                 break;
  425         case APM_SUSPEND_REQ:
  426                 if (apm_resumes || apm_op_inprog)
  427                         break;
DPRINTF(("suspend requested\n"));
  429                 if (apm_standbys || apm_suspends) {
DPRINTF(("premature suspend\n"));
apm_error++;
ret++;
  433                 }
apm_op_inprog++;
  435                 if (apm_record_event(sc, regs->bx)) {
DPRINTF(("suspend ourselves\n"));
apm_suspends++;
  438                 }
  439                 break;
  440         case APM_POWER_CHANGE:
DPRINTF(("power status change\n"));
  442                 if (apm_get_powstat(&nregs) == 0 &&
BATT_LIFE(&nregs) != APM_BATT_LIFE_UNKNOWN &&
BATT_LIFE(&nregs) < cpu_apmwarn &&
  445                     (sc->sc_flags & SCFLAG_PRINT) != SCFLAG_NOPRINT &&
  446                     ((sc->sc_flags & SCFLAG_PRINT) != SCFLAG_PCTPRINT ||
sc->batt_life != BATT_LIFE(&nregs)))
apm_power_print(sc, &nregs);
apm_record_event(sc, regs->bx);
  450                 break;
  451         case APM_NORMAL_RESUME:
DPRINTF(("system resumed\n"));
apm_resume(sc, regs);
  454                 break;
  455         case APM_CRIT_RESUME:
DPRINTF(("system resumed without us!\n"));
apm_resume(sc, regs);
  458                 break;
  459         case APM_SYS_STANDBY_RESUME:
DPRINTF(("system standby resume\n"));
apm_resume(sc, regs);
  462                 break;
  463         case APM_UPDATE_TIME:
DPRINTF(("update time, please\n"));
inittodr(time_second);
apm_record_event(sc, regs->bx);
  467                 break;
  468         case APM_CRIT_SUSPEND_REQ:
DPRINTF(("suspend required immediately\n"));
apm_record_event(sc, regs->bx);
apm_suspend();
  472                 break;
  473         case APM_BATTERY_LOW:
DPRINTF(("Battery low!\n"));
apm_battlow++;
apm_record_event(sc, regs->bx);
  477                 break;
  478         case APM_CAPABILITY_CHANGE:
DPRINTF(("capability change\n"));
  480                 if (apm_minver < 2) {
DPRINTF(("adult event\n"));
  482                 } else {
  483                         if (apmcall(APM_GET_CAPABILITIES, APM_DEV_APM_BIOS,
  484                             &nregs) != 0) {
apm_perror("get capabilities", &nregs);
  486                         } else {
apm_get_powstat(&nregs);
  488                         }
  489                 }
  490                 break;
  491         default: {
  492 #ifdef APMDEBUG
  493                 char *p;
  494                 switch (regs->bx >> 8) {
  495                 case 0: p = "reserved system";  break;
  496                 case 1: p = "reserved device";  break;
  497                 case 2: p = "OEM defined";      break;
  498                 default:p = "reserved";         break;
  499                 }
  500 #endif
DPRINTF(("apm_handle_event: %s event, code %d\n", p, regs->bx));
  502             }
  503         }
  504         return ret;
  505 }
  507 int
apm_periodic_check(struct apm_softc *sc)
  509 {
  510         struct apmregs regs;
  511         int ret = 0;
  513         if (apm_op_inprog)
apm_set_powstate(APM_DEV_ALLDEVS, APM_LASTREQ_INPROG);
  516         while (1) {
  517                 if (apm_get_event(&regs) != 0) {
  518                         /* i think some bioses combine the error codes */
  519                         if (!(APM_ERR_CODE(&regs) & APM_ERR_NOEVENTS))
apm_perror("get event", &regs);
  521                         break;
  522                 }
  524                 if (apm_handle_event(sc, &regs))
  525                         break;
  526         }
  528         if (apm_error || APM_ERR_CODE(&regs) == APM_ERR_NOTCONN)
ret = -1;
  531         if (apm_suspends /*|| (apm_battlow && apm_userstandbys)*/) {
apm_op_inprog = 0;
apm_suspend();
  534         } else if (apm_standbys || apm_userstandbys) {
apm_op_inprog = 0;
apm_standby();
  537         }
apm_suspends = apm_standbys = apm_battlow = apm_userstandbys = 0;
apm_error = 0;
  541         if (apm_resumes)
apm_resumes--;
  543         return (ret);
  544 }
  546 void
apm_powmgt_enable(int onoff)
  548 {
  549         struct apmregs regs;
bzero(&regs, sizeof(regs));
regs.cx = onoff ? APM_MGT_ENABLE : APM_MGT_DISABLE;
  553         if (apmcall(APM_PWR_MGT_ENABLE,
  554             (apm_minver? APM_DEV_APM_BIOS : APM_MGT_ALL), &regs) != 0)
apm_perror("power management enable", &regs);
  556 }
  558 void
apm_powmgt_engage(int onoff, u_int dev)
  560 {
  561         struct apmregs regs;
  563         if (apm_minver == 0)
  564                 return;
bzero(&regs, sizeof(regs));
regs.cx = onoff ? APM_MGT_ENGAGE : APM_MGT_DISENGAGE;
  567         if (apmcall(APM_PWR_MGT_ENGAGE, dev, &regs) != 0)
printf("apm0: APM engage (device %x): %s (%d)\n",
dev, apm_err_translate(APM_ERR_CODE(&regs)),
APM_ERR_CODE(&regs));
  571 }
  573 #ifdef notused
  574 void
  575 apm_devpowmgt_enable(int onoff, u_int dev)
  576 {
  577         struct apmregs regs;
  579         if (apm_minver == 0)
  580                 return;
  581         /* enable is auto BIOS management.
  582          * disable is program control.
  583          */
bzero(&regs, sizeof(regs));
regs.cx = onoff ? APM_MGT_ENABLE : APM_MGT_DISABLE;
  586         if (apmcall(APM_DEVICE_MGMT_ENABLE, dev, &regs) != 0)
printf("APM device engage (device %x): %s (%d)\n",
dev, apm_err_translate(APM_ERR_CODE(&regs)),
APM_ERR_CODE(&regs));
  590 }
  591 #endif
  593 int
apm_set_powstate(u_int dev, u_int state)
  595 {
  596         struct apmregs regs;
  598         if (!apm_cd.cd_ndevs || (apm_minver == 0 && state > APM_SYS_OFF))
  599                 return EINVAL;
bzero(&regs, sizeof(regs));
regs.cx = state;
  602         if (apmcall(APM_SET_PWR_STATE, dev, &regs) != 0) {
apm_perror("set power state", &regs);
  604                 if (APM_ERR_CODE(&regs) == APM_ERR_UNRECOG_DEV)
  605                         return ENXIO;
  606                 else
  607                         return EIO;
  608         }
  609         return 0;
  610 }
  612 void
apm_cpu_busy(void)
  614 {
  615         struct apmregs regs;
  617         if (!apm_cd.cd_ndevs)   /* No APM device, punt */
  618                 return;
  619         if (!apm_dobusy)
  620                 return;
  621         if (!apm_idle_called)
  622                 return;
  624         if (apm_flags & APM_IDLE_SLOWS) {
bzero(&regs, sizeof(regs));
  626                 if (apmcall(APM_CPU_BUSY, 0, &regs) != 0) {
  627 #ifdef DIAGNOSTIC
apm_perror("set CPU busy", &regs);
  629 #endif
  630                 }
apm_idle_called = 0;
  632         }
  633 }
  635 void
apm_cpu_idle(void)
  637 {
  638         struct apmregs regs;
  639         static u_int64_t call_apm = 0;
  641         if (!apm_cd.cd_ndevs) { /* No APM device, wait for next interrupt */
  642                 __asm __volatile("sti;hlt");
  643                 return;
  644         }
  646         if (!apm_doidle) {
  647                 __asm __volatile("sti;hlt");
  648                 return;
  649         }
  651         /*
  652          * We call the bios APM_IDLE routine here only when we
  653          * have been idle for some time - otherwise we just hlt.
  654          */
  656         if  (call_apm != curcpu()->ci_schedstate.spc_cp_time[CP_IDLE]) {
  657                 /* Always call BIOS halt/idle stuff */
bzero(&regs, sizeof(regs));
  659                 if (apmcall(APM_CPU_IDLE, 0, &regs) != 0) {
  660 #ifdef APMDEBUG
apm_perror("set CPU idle", &regs);
  662 #endif
  663                 }
apm_idle_called = 1;
  665                 /* If BIOS did halt, don't do it again! */
  666                 if (apm_flags & APM_IDLE_SLOWS) {
  667                         __asm __volatile("sti;hlt");
  668                 }
call_apm = curcpu()->ci_schedstate.spc_cp_time[CP_IDLE];
  670         } else {
  671                 __asm __volatile("sti;hlt");
  672         }
  673 }
  675 void
apm_set_ver(struct apm_softc *self)
  677 {
  678         struct apmregs regs;
  679         int rv = 0;
bzero(&regs, sizeof(regs));
regs.cx = APM_VERSION;
  684         if (APM_MAJOR(apm_flags) == 1 && APM_MINOR(apm_flags) == 2 &&
  685             (rv = apmcall(APM_DRIVER_VERSION, APM_DEV_APM_BIOS, &regs)) == 0) {
apm_majver = APM_CONN_MAJOR(&regs);
apm_minver = APM_CONN_MINOR(&regs);
  688         } else {
  689 #ifdef APMDEBUG
  690                 if (rv)
apm_perror("set version 1.2", &regs);
  692 #endif
  693                 /* try downgrading to 1.1 */
bzero(&regs, sizeof(regs));
regs.cx = 0x0101;
  697                 if (apmcall(APM_DRIVER_VERSION, APM_DEV_APM_BIOS, &regs) == 0) {
apm_majver = 1;
apm_minver = 1;
  700                 } else {
  701 #ifdef APMDEBUG
apm_perror("set version 1.1", &regs);
  703 #endif
  704                         /* stay w/ flags then */
apm_majver = APM_MAJOR(apm_flags);
apm_minver = APM_MINOR(apm_flags);
  708                         /* fix version for some endianess-challenged compaqs */
  709                         if (!apm_majver) {
apm_majver = 1;
apm_minver = 0;
  712                         }
  713                 }
  714         }
printf(": Power Management spec V%d.%d", apm_majver, apm_minver);
  716         if (apm_flags & APM_IDLE_SLOWS) {
DPRINTF((" (slowidle)"));
apm_dobusy = 1;
apm_doidle = 1;
  720         } else {
apm_dobusy = 0;
apm_doidle = 1;
  723         }
  724 #ifdef DIAGNOSTIC
  725         if (apm_flags & APM_BIOS_PM_DISABLED)
printf(" (BIOS mgmt disabled)");
  727         if (apm_flags & APM_BIOS_PM_DISENGAGED)
printf(" (BIOS managing devices)");
  729 #endif
printf("\n");
  731 }
  733 void
apm_disconnect(struct apm_softc *sc)
  735 {
  736         struct apmregs regs;
bzero(&regs, sizeof(regs));
  739         if (apmcall(APM_SYSTEM_DEFAULTS,
  740             (apm_minver == 1 ? APM_DEV_ALLDEVS : APM_DEFAULTS_ALL), &regs))
apm_perror("system defaults failed", &regs);
  743         if (apmcall(APM_DISCONNECT, APM_DEV_APM_BIOS, &regs))
apm_perror("disconnect failed", &regs);
  745         else
printf("%s: disconnected\n", sc->sc_dev.dv_xname);
apm_flags |= APM_BIOS_PM_DISABLED;
  748 }
  750 int
apmprobe(struct device *parent, void *match, void *aux)
  752 {
  753         struct bios_attach_args *ba = aux;
bios_apminfo_t *ap = ba->bios_apmp;
bus_space_handle_t ch, dh;
  757         if (apm_cd.cd_ndevs || strcmp(ba->bios_dev, "apm") ||
  758             !(ba->bios_apmp->apm_detail & APM_32BIT_SUPPORTED)) {
DPRINTF(("%s: %x\n", ba->bios_dev, ba->bios_apmp->apm_detail));
  760                 return 0;
  761         }
  763         /* addresses check
  764            since pc* console and vga* probes much later
  765            we cannot check for video memory being mapped
  766            for apm stuff w/ bus_space_map() */
  767         if (ap->apm_code_len == 0 ||
  768             (ap->apm_code32_base < IOM_BEGIN &&
ap->apm_code32_base + ap->apm_code_len > IOM_BEGIN) ||
  770             (ap->apm_code16_base < IOM_BEGIN &&
ap->apm_code16_base + ap->apm_code16_len > IOM_BEGIN) ||
  772             (ap->apm_data_base < IOM_BEGIN &&
ap->apm_data_base + ap->apm_data_len > IOM_BEGIN))
  774                 return 0;
  776         if (bus_space_map(ba->bios_memt, ap->apm_code32_base,
ap->apm_code_len, 1, &ch) != 0) {
DPRINTF(("apm0: can't map code\n"));
  779                 return 0;
  780         }
bus_space_unmap(ba->bios_memt, ch, ap->apm_code_len);
  783         if (bus_space_map(ba->bios_memt, ap->apm_data_base,
ap->apm_data_len, 1, &dh) != 0) {
DPRINTF(("apm0: can't map data\n"));
  786                 return 0;
  787         }
bus_space_unmap(ba->bios_memt, dh, ap->apm_data_len);
  789         return 1;
  790 }
  792 void
apmattach(struct device *parent, struct device *self, void *aux)
  794 {
  795         struct bios_attach_args *ba = aux;
bios_apminfo_t *ap = ba->bios_apmp;
  797         struct apm_softc *sc = (void *)self;
  798         struct apmregs regs;
u_int cbase, clen, l;
bus_space_handle_t ch16, ch32, dh;
apm_flags = ap->apm_detail;
  803         /*
  804          * set up GDT descriptors for APM
  805          */
  806         if (apm_flags & APM_32BIT_SUPPORTED) {
  808                 /* truncate segments' limits to a page */
ap->apm_code_len -= (ap->apm_code32_base +
ap->apm_code_len + 1) & 0xfff;
ap->apm_code16_len -= (ap->apm_code16_base +
ap->apm_code16_len + 1) & 0xfff;
ap->apm_data_len -= (ap->apm_data_base +
ap->apm_data_len + 1) & 0xfff;
  816                 /* adjust version */
  817                 if ((sc->sc_dev.dv_cfdata->cf_flags & APM_VERMASK) &&
  818                     (apm_flags & APM_VERMASK) !=
  819                     (sc->sc_dev.dv_cfdata->cf_flags & APM_VERMASK))
apm_flags = (apm_flags & ~APM_VERMASK) |
  821                             (sc->sc_dev.dv_cfdata->cf_flags & APM_VERMASK);
  822                 if (sc->sc_dev.dv_cfdata->cf_flags & APM_NOCLI) {
  823                         extern int apm_cli; /* from apmcall.S */
apm_cli = 0;
  825                 }
  826                 if (sc->sc_dev.dv_cfdata->cf_flags & APM_BEBATT)
apm_bebatt = 1;
apm_ep.seg = GSEL(GAPM32CODE_SEL,SEL_KPL);
apm_ep.entry = ap->apm_entry;
cbase = min(ap->apm_code32_base, ap->apm_code16_base);
clen = max(ap->apm_code32_base + ap->apm_code_len,
ap->apm_code16_base + ap->apm_code16_len) - cbase;
  833                 if ((cbase <= ap->apm_data_base &&
cbase + clen >= ap->apm_data_base) ||
  835                     (ap->apm_data_base <= cbase &&
ap->apm_data_base + ap->apm_data_len >= cbase)) {
l = max(ap->apm_data_base + ap->apm_data_len + 1,
cbase + clen + 1) -
min(ap->apm_data_base, cbase);
bus_space_map(ba->bios_memt,
min(ap->apm_data_base, cbase),
l, 1, &dh);
ch16 = dh;
  844                         if (ap->apm_data_base < cbase)
ch16 += cbase - ap->apm_data_base;
  846                         else
dh += ap->apm_data_base - cbase;
  848                 } else {
bus_space_map(ba->bios_memt, cbase, clen + 1, 1, &ch16);
bus_space_map(ba->bios_memt, ap->apm_data_base,
ap->apm_data_len + 1, 1, &dh);
  853                 }
ch32 = ch16;
  855                 if (ap->apm_code16_base == cbase)
ch32 += ap->apm_code32_base - cbase;
  857                 else
ch16 += ap->apm_code16_base - cbase;
setgdt(GAPM32CODE_SEL, (void *)ch32, ap->apm_code_len,
SDT_MEMERA, SEL_KPL, 1, 0);
setgdt(GAPM16CODE_SEL, (void *)ch16, ap->apm_code16_len,
SDT_MEMERA, SEL_KPL, 0, 0);
setgdt(GAPMDATA_SEL, (void *)dh, ap->apm_data_len, SDT_MEMRWA,
SEL_KPL, 1, 0);
DPRINTF((": flags %x code 32:%x/%x[%x] 16:%x/%x[%x] "
  867                     "data %x/%x/%x ep %x (%x:%x)\n%s", apm_flags,
ap->apm_code32_base, ch32, ap->apm_code_len,
ap->apm_code16_base, ch16, ap->apm_code16_len,
ap->apm_data_base, dh, ap->apm_data_len,
ap->apm_entry, apm_ep.seg, ap->apm_entry+ch32,
sc->sc_dev.dv_xname));
apm_set_ver(sc);
  876                 if (apm_flags & APM_BIOS_PM_DISABLED)
apm_powmgt_enable(1);
  878                 /*
  879                  * Engage cooperative power mgt (we get to do it)
  880                  * on all devices (v1.1).
  881                  */
apm_powmgt_engage(1, APM_DEV_ALLDEVS);
bzero(&regs, sizeof(regs));
  885                 if (apm_get_powstat(&regs) == 0)
apm_power_print(sc, &regs);
  887                 else
apm_perror("get power status", &regs);
apm_cpu_busy();
rw_init(&sc->sc_lock, "apmlk");
  893                 /*
  894                  * Do a check once, ignoring any errors. This avoids
  895                  * gratuitous APM disconnects on laptops where the first
  896                  * event in the queue (after a boot) is non-recognizable.
  897                  * The IBM ThinkPad 770Z is one of those.
  898                  */
apm_periodic_check(sc);
  901                 if (apm_periodic_check(sc) == -1) {
apm_disconnect(sc);
apm_dobusy = apm_doidle = 0;
  904                 } else {
kthread_create_deferred(apm_thread_create, sc);
apm_attached = 1;
  907                 }
  908         } else {
setgdt(GAPM32CODE_SEL, NULL, 0, 0, 0, 0, 0);
setgdt(GAPM16CODE_SEL, NULL, 0, 0, 0, 0, 0);
setgdt(GAPMDATA_SEL, NULL, 0, 0, 0, 0, 0);
  912         }
  913         /* XXX - To go away */
printf("apm0: flags %x dobusy %d doidle %d\n",
apm_flags, apm_dobusy, apm_doidle);
  916 }
  918 void
apm_thread_create(void *v)
  920 {
  921         struct apm_softc *sc = v;
  923 #ifdef MULTIPROCESSOR
  924         if (ncpus > 1) {
apm_disconnect(sc);
apm_dobusy = apm_doidle = 0;
  927                 return;
  928         }
  929 #endif
  931         if (kthread_create(apm_thread, sc, &sc->sc_thread, "%s",
sc->sc_dev.dv_xname)) {
apm_disconnect(sc);
printf("%s: failed to create kernel thread, disabled",
sc->sc_dev.dv_xname);
apm_dobusy = apm_doidle = 0;
  937         }
  938 }
  940 void
apm_thread(void *v)
  942 {
  943         struct apm_softc *sc = v;
  945         for (;;) {
rw_enter_write(&sc->sc_lock);
  947                 (void) apm_periodic_check(sc);
rw_exit_write(&sc->sc_lock);
tsleep(&lbolt, PWAIT, "apmev", 0);
  950         }
  951 }
  953 int
  954 apmopen(dev_t dev, int flag, int mode, struct proc *p)
  955 {
  956         struct apm_softc *sc;
  957         int error = 0;
  959         /* apm0 only */
  960         if (!apm_cd.cd_ndevs || APMUNIT(dev) != 0 ||
  961             !(sc = apm_cd.cd_devs[APMUNIT(dev)]))
  962                 return ENXIO;
  964         if (apm_flags & APM_BIOS_PM_DISABLED)
  965                 return ENXIO;
DPRINTF(("apmopen: dev %d pid %d flag %x mode %x\n",
APMDEV(dev), p->p_pid, flag, mode));
rw_enter_write(&sc->sc_lock);
  971         switch (APMDEV(dev)) {
  972         case APMDEV_CTL:
  973                 if (!(flag & FWRITE)) {
error = EINVAL;
  975                         break;
  976                 }
  977                 if (sc->sc_flags & SCFLAG_OWRITE) {
error = EBUSY;
  979                         break;
  980                 }
sc->sc_flags |= SCFLAG_OWRITE;
  982                 break;
  983         case APMDEV_NORMAL:
  984                 if (!(flag & FREAD) || (flag & FWRITE)) {
error = EINVAL;
  986                         break;
  987                 }
sc->sc_flags |= SCFLAG_OREAD;
  989                 break;
  990         default:
error = ENXIO;
  992                 break;
  993         }
rw_exit_write(&sc->sc_lock);
  995         return error;
  996 }
  998 int
  999 apmclose(dev_t dev, int flag, int mode, struct proc *p)
 1000 {
 1001         struct apm_softc *sc;
 1003         /* apm0 only */
 1004         if (!apm_cd.cd_ndevs || APMUNIT(dev) != 0 ||
 1005             !(sc = apm_cd.cd_devs[APMUNIT(dev)]))
 1006                 return ENXIO;
DPRINTF(("apmclose: pid %d flag %x mode %x\n", p->p_pid, flag, mode));
rw_enter_write(&sc->sc_lock);
 1011         switch (APMDEV(dev)) {
 1012         case APMDEV_CTL:
sc->sc_flags &= ~SCFLAG_OWRITE;
 1014                 break;
 1015         case APMDEV_NORMAL:
sc->sc_flags &= ~SCFLAG_OREAD;
 1017                 break;
 1018         }
rw_exit_write(&sc->sc_lock);
 1020         return 0;
 1021 }
 1023 int
 1024 apmioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
 1025 {
 1026         struct apm_softc *sc;
 1027         struct apmregs regs;
 1028         int error = 0;
 1030         /* apm0 only */
 1031         if (!apm_cd.cd_ndevs || APMUNIT(dev) != 0 ||
 1032             !(sc = apm_cd.cd_devs[APMUNIT(dev)]))
 1033                 return ENXIO;
rw_enter_write(&sc->sc_lock);
 1036         switch (cmd) {
 1037                 /* some ioctl names from linux */
 1038         case APM_IOC_STANDBY:
 1039                 if ((flag & FWRITE) == 0)
error = EBADF;
 1041                 else
apm_userstandbys++;
 1043                 break;
 1044         case APM_IOC_SUSPEND:
 1045                 if ((flag & FWRITE) == 0)
error = EBADF;
 1047                 else
apm_suspends++;
 1049                 break;
 1050         case APM_IOC_PRN_CTL:
 1051                 if ((flag & FWRITE) == 0)
error = EBADF;
 1053                 else {
 1054                         int flag = *(int *)data;
DPRINTF(( "APM_IOC_PRN_CTL: %d\n", flag ));
 1056                         switch (flag) {
 1057                         case APM_PRINT_ON:      /* enable printing */
sc->sc_flags &= ~SCFLAG_PRINT;
 1059                                 break;
 1060                         case APM_PRINT_OFF: /* disable printing */
sc->sc_flags &= ~SCFLAG_PRINT;
sc->sc_flags |= SCFLAG_NOPRINT;
 1063                                 break;
 1064                         case APM_PRINT_PCT: /* disable some printing */
sc->sc_flags &= ~SCFLAG_PRINT;
sc->sc_flags |= SCFLAG_PCTPRINT;
 1067                                 break;
 1068                         default:
error = EINVAL;
 1070                                 break;
 1071                         }
 1072                 }
 1073                 break;
 1074         case APM_IOC_DEV_CTL:
 1075                 if ((flag & FWRITE) == 0)
error = EBADF;
 1077                 else {
 1078                         struct apm_ctl *actl = (struct apm_ctl *)data;
bzero(&regs, sizeof(regs));
 1081                         if (!apmcall(APM_GET_POWER_STATE, actl->dev, &regs))
printf("%s: dev %04x state %04x\n",
sc->sc_dev.dv_xname, dev, regs.cx);
error = apm_set_powstate(actl->dev, actl->mode);
 1086                 }
 1087                 break;
 1088         case APM_IOC_GETPOWER:
 1089                 if (apm_get_powstat(&regs) == 0) {
 1090                         struct apm_power_info *powerp =
 1091                             (struct apm_power_info *)data;
bzero(powerp, sizeof(*powerp));
 1094                         if (BATT_LIFE(&regs) != APM_BATT_LIFE_UNKNOWN)
powerp->battery_life = BATT_LIFE(&regs);
powerp->ac_state = AC_STATE(&regs);
 1097                         switch (apm_minver) {
 1098                         case 0:
 1099                                 if (!(BATT_FLAGS(&regs) & APM_BATT_FLAG_NOBATTERY))
powerp->battery_state = BATT_STATE(&regs);
 1101                                 break;
 1102                         case 1:
 1103                         default:
 1104                                 if (BATT_FLAGS(&regs) & APM_BATT_FLAG_HIGH)
powerp->battery_state = APM_BATT_HIGH;
 1106                                 else if (BATT_FLAGS(&regs) & APM_BATT_FLAG_LOW)
powerp->battery_state = APM_BATT_LOW;
 1108                                 else if (BATT_FLAGS(&regs) & APM_BATT_FLAG_CRITICAL)
powerp->battery_state = APM_BATT_CRITICAL;
 1110                                 else if (BATT_FLAGS(&regs) & APM_BATT_FLAG_CHARGING)
powerp->battery_state = APM_BATT_CHARGING;
 1112                                 else if (BATT_FLAGS(&regs) & APM_BATT_FLAG_NOBATTERY)
powerp->battery_state = APM_BATTERY_ABSENT;
 1114                                 else
powerp->battery_state = APM_BATT_UNKNOWN;
 1116                                 if (BATT_REM_VALID(&regs)) {
powerp->minutes_left = BATT_REMAINING(&regs);
 1118                                         if (apm_bebatt)
powerp->minutes_left =
swap16(powerp->minutes_left);
 1121                                 }
 1122                         }
 1123                 } else {
apm_perror("ioctl get power status", &regs);
error = EIO;
 1126                 }
 1127                 break;
 1129         default:
error = ENOTTY;
 1131         }
rw_exit_write(&sc->sc_lock);
 1134         return error;
 1135 }
 1137 void
filt_apmrdetach(struct knote *kn)
 1139 {
 1140         struct apm_softc *sc = (struct apm_softc *)kn->kn_hook;
rw_enter_write(&sc->sc_lock);
SLIST_REMOVE(&sc->sc_note, kn, knote, kn_selnext);
rw_exit_write(&sc->sc_lock);
 1145 }
 1147 int
filt_apmread(struct knote *kn, long hint)
 1149 {
 1150         /* XXX weird kqueue_scan() semantics */
 1151         if (hint && !kn->kn_data)
kn->kn_data = (int)hint;
 1153         return (1);
 1154 }
 1156 int
 1157 apmkqfilter(dev_t dev, struct knote *kn)
 1158 {
 1159         struct apm_softc *sc;
 1161         /* apm0 only */
 1162         if (!apm_cd.cd_ndevs || APMUNIT(dev) != 0 ||
 1163             !(sc = apm_cd.cd_devs[APMUNIT(dev)]))
 1164                 return ENXIO;
 1166         switch (kn->kn_filter) {
 1167         case EVFILT_READ:
kn->kn_fop = &apmread_filtops;
 1169                 break;
 1170         default:
 1171                 return (1);
 1172         }
kn->kn_hook = (caddr_t)sc;
rw_enter_write(&sc->sc_lock);
SLIST_INSERT_HEAD(&sc->sc_note, kn, kn_selnext);
rw_exit_write(&sc->sc_lock);
 1179         return (0);
 1180 }