/*      $NetBSD: apm.c,v 1.32 2022/02/11 04:23:18 thorpej Exp $ */
/*      $OpenBSD: apm.c,v 1.5 2002/06/07 07:13:59 miod Exp $    */

/*-
* Copyright (c) 2001 Alexander Guy.  All rights reserved.
* Copyright (c) 1998-2001 Michael Shalayeff. All rights reserved.
* Copyright (c) 1995 John T. Kohl.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the names of the authors nor the names of contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: apm.c,v 1.32 2022/02/11 04:23:18 thorpej Exp $");

#include "apm.h"

#if NAPM > 1
#error only one APM emulation device may be configured
#endif

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/proc.h>
#include <sys/device.h>
#include <sys/fcntl.h>
#include <sys/ioctl.h>
#include <sys/mutex.h>
#include <sys/select.h>
#include <sys/poll.h>
#include <sys/conf.h>

#include <machine/cpu.h>
#include <machine/apmvar.h>

#include <macppc/dev/adbvar.h>
#include <macppc/dev/pm_direct.h>

#if defined(APMDEBUG)
#define DPRINTF(x)      printf x
#else
#define DPRINTF(x)      /**/
#endif

#define APM_NEVENTS 16

struct apm_softc {
       struct selinfo sc_rsel;
       int    sc_flags;
       int     event_count;
       int     event_ptr;
       kmutex_t sc_lock;
       struct  apm_event_info event_list[APM_NEVENTS];
};

/*
* A brief note on the locking protocol: it's very simple; we
* assert an exclusive lock any time thread context enters the
* APM module.  This is both the APM thread itself, as well as
* user context.
*/
#define APM_LOCK(apmsc)         mutex_enter(&(apmsc)->sc_lock)
#define APM_UNLOCK(apmsc)       mutex_exit(&(apmsc)->sc_lock)

int apmmatch(device_t, cfdata_t, void *);
void apmattach(device_t, device_t, void *);

#if 0
static int      apm_record_event(struct apm_softc *, u_int);
#endif

CFATTACH_DECL_NEW(apm, sizeof(struct apm_softc),
   apmmatch, apmattach, NULL, NULL);

extern struct cfdriver apm_cd;

dev_type_open(apmopen);
dev_type_close(apmclose);
dev_type_ioctl(apmioctl);
dev_type_poll(apmpoll);
dev_type_kqfilter(apmkqfilter);

const struct cdevsw apm_cdevsw = {
       .d_open = apmopen,
       .d_close = apmclose,
       .d_read = noread,
       .d_write = nowrite,
       .d_ioctl = apmioctl,
       .d_stop = nostop,
       .d_tty = notty,
       .d_poll = apmpoll,
       .d_mmap = nommap,
       .d_kqfilter = apmkqfilter,
       .d_discard = nodiscard,
       .d_flag = 0
};

int     apm_evindex;

#define APMUNIT(dev)    (minor(dev)&0xf0)
#define APMDEV(dev)     (minor(dev)&0x0f)
#define APMDEV_NORMAL   0
#define APMDEV_CTL      8

/*
* Flags to control kernel display
*      SCFLAG_NOPRINT:         do not output APM power messages due to
*                              a power change event.
*
*      SCFLAG_PCTPRINT:        do not output APM power messages due to
*                              to a power change event unless the battery
*                              percentage changes.
*/

#define SCFLAG_NOPRINT  0x0008000
#define SCFLAG_PCTPRINT 0x0004000
#define SCFLAG_PRINT    (SCFLAG_NOPRINT|SCFLAG_PCTPRINT)

#define SCFLAG_OREAD    (1 << 0)
#define SCFLAG_OWRITE   (1 << 1)
#define SCFLAG_OPEN     (SCFLAG_OREAD|SCFLAG_OWRITE)


int
apmmatch(device_t parent, cfdata_t match, void *aux)
{
       struct adb_attach_args *aa = (void *)aux;
       if (aa->origaddr != ADBADDR_APM ||
           aa->handler_id != ADBADDR_APM ||
           aa->adbaddr != ADBADDR_APM)
               return 0;

       if (adbHardware != ADB_HW_PMU)
               return 0;

       return 1;
}

void
apmattach(device_t parent, device_t self, void *aux)
{
       struct apm_softc *sc = device_private(self);
       struct pmu_battery_info info;

       pm_battery_info(0, &info);

       printf(": battery flags 0x%X, ", info.flags);
       printf("%d%% charged\n", ((info.cur_charge * 100) / info.max_charge));

       sc->sc_flags = 0;
       sc->event_ptr = 0;
       sc->event_count = 0;
       mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
       selinit(&sc->sc_rsel);
}

int
apmopen(dev_t dev, int flag, int mode, struct lwp *l)
{
       struct apm_softc *sc;
       int error = 0;

       /* apm0 only */
       sc = device_lookup_private(&apm_cd, APMUNIT(dev));
       if (sc == NULL)
               return ENXIO;

       DPRINTF(("apmopen: dev %d pid %d flag %x mode %x\n",
           APMDEV(dev), l->l_proc->p_pid, flag, mode));

       APM_LOCK(sc);
       switch (APMDEV(dev)) {
       case APMDEV_CTL:
               if (!(flag & FWRITE)) {
                       error = EINVAL;
                       break;
               }
               if (sc->sc_flags & SCFLAG_OWRITE) {
                       error = EBUSY;
                       break;
               }
               sc->sc_flags |= SCFLAG_OWRITE;
               break;
       case APMDEV_NORMAL:
               if (!(flag & FREAD) || (flag & FWRITE)) {
                       error = EINVAL;
                       break;
               }
               sc->sc_flags |= SCFLAG_OREAD;
               break;
       default:
               error = ENXIO;
               break;
       }
       APM_UNLOCK(sc);
       return error;
}

int
apmclose(dev_t dev, int flag, int mode, struct lwp *l)
{
       struct apm_softc *sc;

       /* apm0 only */
       sc = device_lookup_private(&apm_cd, APMUNIT(dev));
       if (sc == NULL)
               return ENXIO;

       DPRINTF(("apmclose: pid %d flag %x mode %x\n", l->l_proc->p_pid, flag, mode));

       APM_LOCK(sc);
       switch (APMDEV(dev)) {
       case APMDEV_CTL:
               sc->sc_flags &= ~SCFLAG_OWRITE;
               break;
       case APMDEV_NORMAL:
               sc->sc_flags &= ~SCFLAG_OREAD;
               break;
       }
       APM_UNLOCK(sc);
       return 0;
}

int
apmioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
       struct apm_softc *sc;
       struct pmu_battery_info batt;
       struct apm_power_info *power;
       int error = 0;

       /* apm0 only */
       sc = device_lookup_private(&apm_cd, APMUNIT(dev));
       if (sc == NULL)
               return ENXIO;

       APM_LOCK(sc);
       switch (cmd) {
               /* some ioctl names from linux */
       case APM_IOC_STANDBY:
               if ((flag & FWRITE) == 0)
                       error = EBADF;
       case APM_IOC_SUSPEND:
               if ((flag & FWRITE) == 0)
                       error = EBADF;
               break;
       case APM_IOC_PRN_CTL:
               if ((flag & FWRITE) == 0)
                       error = EBADF;
               else {
                       int op = *(int *)data;
                       DPRINTF(( "APM_IOC_PRN_CTL: %d\n", op ));
                       switch (op) {
                       case APM_PRINT_ON:      /* enable printing */
                               sc->sc_flags &= ~SCFLAG_PRINT;
                               break;
                       case APM_PRINT_OFF: /* disable printing */
                               sc->sc_flags &= ~SCFLAG_PRINT;
                               sc->sc_flags |= SCFLAG_NOPRINT;
                               break;
                       case APM_PRINT_PCT: /* disable some printing */
                               sc->sc_flags &= ~SCFLAG_PRINT;
                               sc->sc_flags |= SCFLAG_PCTPRINT;
                               break;
                       default:
                               error = EINVAL;
                               break;
                       }
               }
               break;
       case APM_IOC_DEV_CTL:
               if ((flag & FWRITE) == 0)
                       error = EBADF;
               break;
       case APM_IOC_GETPOWER:
               power = (struct apm_power_info *)data;

               pm_battery_info(0, &batt);

               power->ac_state = ((batt.flags & PMU_PWR_AC_PRESENT) ?
                   APM_AC_ON : APM_AC_OFF);
               power->battery_life =
                   ((batt.cur_charge * 100) / batt.max_charge);

               /*
                * If the battery is charging, return the minutes left until
                * charging is complete. apmd knows this.
                */

               if (!(batt.flags & PMU_PWR_BATT_PRESENT)) {
                       power->battery_state = APM_BATT_UNKNOWN;
                       power->minutes_left = 0;
                       power->battery_life = 0;
               } else if ((power->ac_state == APM_AC_ON) &&
                          (batt.draw > 0)) {
                       power->minutes_left = batt.secs_remaining / 60;
                       power->battery_state = APM_BATT_CHARGING;
               } else {
                       power->minutes_left = batt.secs_remaining / 60;

                       /* XXX - Arbitrary */
                       if (power->battery_life > 60) {
                               power->battery_state = APM_BATT_HIGH;
                       } else if (power->battery_life < 10) {
                               power->battery_state = APM_BATT_CRITICAL;
                       } else {
                               power->battery_state = APM_BATT_LOW;
                       }
               }

               break;

       default:
               error = ENOTTY;
       }
       APM_UNLOCK(sc);

       return error;
}

#if 0
/*
* return 0 if the user will notice and handle the event,
* return 1 if the kernel driver should do so.
*/
static int
apm_record_event(struct apm_softc *sc, u_int event_type)
{
       struct apm_event_info *evp;

       if ((sc->sc_flags & SCFLAG_OPEN) == 0)
               return 1;               /* no user waiting */
       if (sc->event_count == APM_NEVENTS) {
               DPRINTF(("apm_record_event: queue full!\n"));
               return 1;                       /* overflow */
       }
       evp = &sc->event_list[sc->event_ptr];
       sc->event_count++;
       sc->event_ptr++;
       sc->event_ptr %= APM_NEVENTS;
       evp->type = event_type;
       evp->index = ++apm_evindex;
       selnotify(&sc->sc_rsel, 0, 0);
       return (sc->sc_flags & SCFLAG_OWRITE) ? 0 : 1; /* user may handle */
}
#endif

int
apmpoll(dev_t dev, int events, struct lwp *l)
{
       struct apm_softc *sc = device_lookup_private(&apm_cd,APMUNIT(dev));
       int revents = 0;

       APM_LOCK(sc);
       if (events & (POLLIN | POLLRDNORM)) {
               if (sc->event_count)
                       revents |= events & (POLLIN | POLLRDNORM);
               else
                       selrecord(l, &sc->sc_rsel);
       }
       APM_UNLOCK(sc);

       return (revents);
}

static void
filt_apmrdetach(struct knote *kn)
{
       struct apm_softc *sc = (struct apm_softc *)kn->kn_hook;

       APM_LOCK(sc);
       selremove_knote(&sc->sc_rsel, kn);
       APM_UNLOCK(sc);
}

static int
filt_apmread(struct knote *kn, long hint)
{
       struct apm_softc *sc = kn->kn_hook;

       kn->kn_data = sc->event_count;
       return (kn->kn_data > 0);
}

static struct filterops apmread_filtops = {
       .f_flags = FILTEROP_ISFD,
       .f_attach = NULL,
       .f_detach = filt_apmrdetach,
       .f_event = filt_apmread,
};

int
apmkqfilter(dev_t dev, struct knote *kn)
{
       struct apm_softc *sc = device_lookup_private(&apm_cd,APMUNIT(dev));

       switch (kn->kn_filter) {
       case EVFILT_READ:
               kn->kn_fop = &apmread_filtops;
               break;
       default:
               return (EINVAL);
       }

       kn->kn_hook = sc;

       APM_LOCK(sc);
       selrecord_knote(&sc->sc_rsel, kn);
       APM_UNLOCK(sc);

       return (0);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.