• Skip to content
• Skip to link menu

KDE 4.0 API Reference

• KDE API Reference
• kdeutils

• Sitemap
• Contact Us

 

klaptopdaemon

portable.cpp

Go to the documentation of this file.

 /*
 * portable.cpp
 *
 * $Id: portable.cpp 701121 2007-08-17 11:24:48Z amth $
 *
 * Copyright (c) 1999 Paul Campbell <paul@taniwha.com>
 *
 * Requires the Qt widget libraries, available at no cost at
 * http://www.troll.no/
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

//
//  this file contains the machine specific laptop power management stuff
//  to add support for your own OS this is should be the only place you need
//  to change - to add your own stuff insert above the line marked
//  'INSERT HERE' :
//
//      #ifdef MY_OS"
//          .. copy of linux code or whatever you want to use as a base
//      # else
//
//  then tag an extra '#endif' at the end
//
// There is support for the following OSsen right now:
//
//  Linux       (#if __linux__)
//  FreeBSD     (#elif __FreeBSD__)
//  NetBSD      (#elif __NetBSD_APM__)
//  generic nothing (#else)
//
//
// The code here is written in a C rather than C++ like to encourage
// people more used to kernel types to do stuff here
//
//  If you have any problems, questions, whatever please get in touch
//
//      Paul Campbell
//      paul@taniwha.com
//
//
//  Thanks to Cajus Pollmeier <C.Pollmeier@gmx.net>
//  and Robert Ellis Parrott <parrott@fas.harvard.edu>
//  who both provided ACPI support
//  and Volker Krause <volker.krause@rwth-aachen.de> who provided ACPI bug fixes
//

#include <config-klaptopdaemon.h>
#include <klocale.h>
#include <kdebug.h>
#include <stdio.h>
#include "portable.h"

#ifdef __linux__

/*
** This is the Linux-specific laptop code.
*/
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <time.h>
#include <stdlib.h>
#include <math.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <dirent.h>
#include <QPushButton>
#include <QDir>
#include <QFile>
#include <qfileinfo.h>
#include <qstringlist.h>

#include <QObject>
#include <QRegExp>
#include <qiodevice.h>
#include <QLayout>
#include <q3valuevector.h>
//Added by qt3to4:
#include <QLabel>
#include <QVBoxLayout>

#include <k3activelabel.h>
#include <kconfig.h>
#include <kstandarddirs.h>
#include <kprocess.h>
#include <krichtextlabel.h>

// ibm specific stuff
extern "C"{
#include "thinkpad_common.h"
#include "smapi.h"
#include "smapidev.h"
}

//
//  here's the Linux specific laptop control panel stuff
//

typedef struct apm_info {
   unsigned int apm_flags;
   unsigned int ac_line_status;
   int          battery_percentage;
   int          battery_time;
} apm_info;

static int
apm_read(apm_info *ap)
{
    FILE    *f = 0;
    char    tmp2[10];
    int tmp, s;
    unsigned int utmp;
    char    version[256];

    f = fopen("/proc/apm", "r");
    if (f == NULL)
        return(1);
    s = fscanf(f, "%255s %d.%d %x %x %x %x %d%% %d %s\n",
        version,
        &tmp,
        &tmp,
        &ap->apm_flags,
        &ap->ac_line_status,
        &utmp,
        &utmp,
        &ap->battery_percentage,
        &ap->battery_time,
        tmp2);
    if (s < 9) {
        fclose(f);
        return(1);
        }
    if (version[0] == 'B') {
        fclose(f);
        return(2);
    }
    if (ap->battery_percentage > 100)
        ap->battery_percentage = -1;
    if (strcmp(tmp2, "sec") == 0)
        ap->battery_time /= 60;
    fclose(f);
    return(0);
}


// 0 => unknown
// 1 => have it
// -1 => don't have it
static int pmustate = 0;

static bool
have_pmu(void)
{
    if (pmustate != 0)
        return (pmustate == 1);
    if (!access("/proc/pmu", R_OK|X_OK)) {
        kDebug() << "Found powermac PMU.  Using that." ;
        pmustate = 1;
        return true;
    }
    pmustate = -1;
    return false;
}

/* Only supports 1 battery right now - all batteries are merged into one stat */
static int
pmu_read(apm_info *ap)
{
    int bcnt = 0;
    memset(ap, 0, sizeof(apm_info));
    QFile f("/proc/pmu/info");
    if (!f.open(QIODevice::ReadOnly))
        return 1;

    while (!f.atEnd()) {
        QString l;
            l = f.readLine();
        QStringList ll = QStringList::split(':', l, false);
        if (ll[0].trimmed() == "AC Power") {
            ap->ac_line_status = ll[1].trimmed().toInt();
            //kDebug() << "line status " << ap->ac_line_status ;
        } else if (ll[0].trimmed() == "Battery count") {
            bcnt = ll[1].trimmed().toInt();
            //kDebug() << "batteries: " << bcnt ;
        }
    }

    f.close();

    int charge = 0;
    int timerem = 0;
    int maxcharge = 0;
    for (int i = 0; i < bcnt; i++) {
        QFile bf(QString("/proc/pmu/battery_%1").arg(i));
        if (!bf.open(QIODevice::ReadOnly))
            continue;

        while(!bf.atEnd()) {
            QString l;
            l = bf.readLine();
            QStringList ll = QStringList::split(':', l, false);
            if (ll[0].trimmed() == "charge") {
                charge += ll[1].trimmed().toInt();
                //kDebug() << "charge: " << charge ;
            } else if (ll[0].trimmed() == "max_charge") {
                maxcharge += ll[1].trimmed().toInt();
                //kDebug() << "max charge: " << maxcharge ;
            } else if (ll[0].trimmed() == "time rem.") {
                timerem += ll[1].trimmed().toInt();
                //kDebug() << "time: " << timerem ;
            }
        }
        bf.close();
    }
    ap->battery_percentage = int(rint(100.0*float(float(charge)/float(maxcharge))));
    ap->battery_time = timerem;

    if (ap->ac_line_status > 0 || timerem == 0 ||
        (ap->ac_line_status == 0 && charge > 100 && timerem == 0))
        ap->battery_time = -1;

    return 0;
}


struct acpi_battery_info {
    int percentage;
    bool present;
    int cap;
    int cap_low;
    int remaining;
    int rate;
    QString name;
    QString state_file;
    QString info_file;
};

static Q3ValueVector<acpi_battery_info> acpi_batteries;
static int acpi_last_known=0;
static int last_seed=1; // increment this to force revaluation

static unsigned char acpi_ac_ok;

//
//  linux APCI doesn't return useful stuff like how much TIME is left yet
//      the 'rate' is not smoothed over time so it's faked out here
//      it's not pretty and it's a quick estimate
//
//      for the moment we prefer APM
//

static int
acpi_ac_status()
{
    DIR *dfd;
    struct dirent *dp;
    FILE *f = NULL;
    static char buff[NAME_MAX+50];
    static bool inited=0;
    static bool bad=0;

    if (inited) {
        if (bad)
            return(-1);
        f = fopen(buff, "r");
        goto readit;
    }
    inited = 1;

    dfd = opendir("/proc/acpi/ac_adapter/");
    if (dfd) {
        for (;;) {
            dp = readdir(dfd);
            if (dp == 0)
                break;
            if (strcmp(dp->d_name, ".") == 0 ||
                    strcmp(dp->d_name, "..") == 0)
                continue;
            strcpy(buff, "/proc/acpi/ac_adapter/");
            strcat(buff, dp->d_name);
            strcat(buff, "/status");
            f = fopen(buff, "r");
            if (!f) {
                strcpy(buff, "/proc/acpi/ac_adapter/");
                strcat(buff, dp->d_name);
                strcat(buff, "/state");
                f = fopen(buff, "r");
            }
            if (f)
                break;
        }
        closedir(dfd);
readit:
        if (f) {
            for (;;) {
                char buff2[1024];
                if (fgets(buff2, sizeof(buff), f) == NULL)
                    break;
                if (strstr(buff2, "Status:") != NULL ||
                        strstr(buff2, "state:") != NULL) {
                    if (strstr(buff2, "on-line") != NULL) {
                        fclose(f);
                        return(1);
                    }
                }
            }
            fclose(f);
            return(0);
        }
    }
    bad=1;
    return(-1);
}

static void acpi_read_batteries() {
    QString buff;
    QFile *f;
    static int test_count = 0;
    bool skip = false;

    for(int i = 0; i < acpi_batteries.count(); ++i) {
        acpi_battery_info& bat = acpi_batteries[i];
        bool present = false;
        if ((test_count==0 || acpi_last_known != last_seed) && !bat.info_file.isNull()) {
            f = new QFile(bat.info_file);
            if (f && f->open(QIODevice::ReadOnly)) {
                while( !( buff=f->readLine() ).isNull() ) {
                    if (buff.contains("design capacity low:", Qt::CaseInsensitive)) {
                        QRegExp rx("(\\d*)\\D*$");
                        rx.search(buff);
                        bat.cap_low = rx.cap(1).toInt();
                        if (bat.cap_low < 0)
                            bat.cap_low = 0;
                        continue;
                    }
                    if (buff.contains("last full capacity:", Qt::CaseInsensitive)) {
                        QRegExp rx("(\\d*)\\D*$");
                        rx.search(buff);
                        bat.cap = rx.cap(1).toInt();
                        continue;
                    }
                }
                f->close();
                bat.cap -= bat.cap_low;
            }
            delete f;
        }
        if (bat.cap <= 0) {
            KConfig* config = new KConfig("kcmlaptoprc", true /*readonly*/, false /*useKDEGlobals*/);
            config->setGroup("AcpiBattery");
            bat.cap = config->readEntry(bat.name,0);
            delete config;
        }
        if (!bat.state_file.isNull()) {
            f = new QFile(bat.state_file);
            if (f && f->open(QIODevice::ReadOnly)) {
                while( !( buff= f->readLine() ).isNull()) {
                    if (buff.contains("present rate:", Qt::CaseInsensitive)) {
                        QRegExp rx("(\\d*)\\D*$");
                        rx.search(buff);
                        bat.rate = rx.cap(1).toInt();
                        if (bat.rate < 0)
                            bat.rate = 0;
                        present = true;
                        continue;
                    }
                    if (buff.contains("remaining capacity:", Qt::CaseInsensitive)) {
                        QRegExp rx("(\\d*)\\D*$");
                        rx.search(buff);
                        bat.remaining = rx.cap(1).toInt();
                        bat.remaining -= bat.cap_low;
                        if (bat.remaining < 0)
                            bat.remaining = 0;
                        present = true;
                        continue;
                    }
                }
                f->close();
            }
            delete f;
        }
        if(present && !bat.present) // recheck capacity if a battery was put in
            skip = true;
        bat.present = present;
        if (bat.present) {
            if (bat.remaining > bat.cap) {  // happens e.g. if the system doesn't provide a capacity value
                bat.cap = bat.remaining;
                KConfig* config = new KConfig("kcmlaptoprc", false /*readonly*/, false /*useKDEGlobals*/);
                config->setGroup("AcpiBattery");
                config->writeEntry(bat.name, bat.cap);
                config->sync();
                delete config;
                skip = true;
            }
            if (bat.cap == 0)
                bat.percentage = 0;
            else
                bat.percentage = bat.remaining*100/bat.cap;
        }
        else
            bat.percentage = 0;
    }

    if (!skip) {
        acpi_last_known = last_seed;
        test_count++;
    }
    else
        test_count = 0;
    if (test_count > 1000)      // every 1000 or so times recheck the battery capacity
        test_count = 0;

}

static int
acpi_read(apm_info *ap)
{
    int rate, part, total;
    int ret = 1;
    bool present = 0;

    part = 0;
    total = 0;
    rate = 0;

    acpi_read_batteries();

    for(int i = 0; i < acpi_batteries.count(); ++i) {
        acpi_battery_info& bat = acpi_batteries[i];
        present |= bat.present;
        if(bat.present) {
            total += bat.cap;
            part += bat.remaining;
            rate += bat.rate;
        }
        ret = 0;
    }

    // some broken ACPI implementations don't return a rate
    // compute a 'fake' rate by diffing remaining values
    if (rate == 0)
    {
        static int last_remaining = 0;
        static time_t last_time = 0;
        if (last_remaining != 0
        && last_time != 0)
        {
        int diff_time = time(0) - last_time;
        if (diff_time > 0)
            rate = (last_remaining - part) * 3600 / diff_time;
        }
        last_remaining = part;
        last_time = time(0);
        if (rate < 0)
        rate = 0;
    }

    static int nrates = 0;
    static int saved_rate[8];
    static unsigned char ignore_next = 2;   // ignore the first couple

    ap->ac_line_status = 0;
    //
    //  ACPI (unlike nice systems like some APM implementations) doesn't
    //  tell us how much battery TIME we have left - here we
    //  do a weighted average of the discharge rate (in mW) and
    //  figure out how long we have left by dividing it into the
    //  remaining capacity
    //
    //  because some ACPI implementations return bogus
    //  rates when charging we can't estimate the battery life
    //  so we only collect discharge rate data when we're actually
    //  discharging
    //
    if (acpi_ac_status() == 1) {
        ap->ac_line_status |= 1;
        ignore_next = 2;
    } else {
        // after switching from power to unpowered we often get
        // a bad reading from ACPI resulting in bizarre
        // readings
        if (ignore_next == 0) {
            if (nrates < 8)             // smooth the power flow
                nrates++;           // simple box filter
            for (int i = 8-1; i > 0; i--)
                saved_rate[i] = saved_rate[i-1];
            saved_rate[0] = rate;
        } else {
            ignore_next--;
        }
    }
    //
    //  if we haven't got any discharge rate data yet don't return a
    //  battery time - probably happens when you start up with the
    //  ac adaptor plugged in
    //
    if (nrates == 0) {
        ap->battery_time = -1;
    } else {
        rate = 0;
        for (int i = 0; i < nrates; i++)
            rate += saved_rate[i];
        rate = (rate+2*saved_rate[0])/(nrates+2);       // weight it slighly
        ap->battery_time = (rate==0 ? -1 : 60*part/rate);
    }
    ap->battery_percentage = (total==0?0:100*part/total);
    if (!present) {
        ap->battery_percentage = -1;
        ap->battery_time = -1;
    }
    ap->apm_flags = 0;
    return(ret);
}

static int apm_no_time;
static apm_info apmx = {0,0,0,0};
static int
has_apm()
{
        static int init = 0;
        static int val;
        if (init)
                return(val);
        init = 1;
        val = 1;
        apm_no_time=0;
        if (apm_read(&apmx) || (apmx.apm_flags&0x20)) {
                val = 0;
                apm_no_time = 1;
        } else {
                apm_no_time = apmx.battery_time < 0;
        }

    if (val == 0) {
        val = have_pmu();
        if (val && pmu_read(&apmx)) {
            val = 0;
        }
    }
        return(val);
}

// Power to the powermacs!!
static int
has_pmu()
{
    static int init = 0;
    static int val;
    if (init)
        return val;
    init = 1;
    val = 1;
    if (!QDir("/proc/pmu").exists()) {
        val = 0;
    }
    return val;
}

static bool software_suspend_is_preferred = false;  // user prefers to use SS for hibernate
static bool acpi_helper_ok(bool type);
static bool
has_software_suspend(int type)
{
    static int known=0;
    static bool present=0;      // functionality seems to be here
    static bool available=0;    // helper can work
    if (known != last_seed) {
        known = last_seed;
        available = 0;
        present = (((::access("/proc/sys/kernel/swsusp", F_OK) == 0) ||
                            (::access("/proc/software_suspend", F_OK) == 0)) ||
                            (::access("/proc/suspend2", F_OK) == 0)) &&
                            (::access("/usr/sbin/hibernate", F_OK) == 0);
        if (present) {
            if (::getuid() == 0) {  // running as root
                available = ::access("/usr/sbin/hibernate", X_OK) == 0 && acpi_helper_ok(1);
            } else {
                available = acpi_helper_ok(0);
            }
        }
    }
    switch (type) {
    case 0: return(present);
    case 1: return(present&available&software_suspend_is_preferred);
    case 2: return(present&available);
    default:return(0);
    }
}

bool
laptop_portable::has_software_suspend(int type)
{
    return(::has_software_suspend(type));
}

void
laptop_portable::software_suspend_set_mask(bool hibernate)
{
    software_suspend_is_preferred = hibernate;
}


static int x_acpi_init = 0;
static bool
has_acpi()
{
    static bool val;
    static bool checked = 0;

    if (!checked) {
        val = ::access("/proc/acpi", F_OK) == 0;
        checked = 1;
    }
    return(val);
}

static int
has_acpi_power()
{
    static int val;

    if (x_acpi_init)
        return(val);
    x_acpi_init = 1;
    val = 0;

    acpi_batteries.clear();

    if (acpi_ac_status() >= 0)
        acpi_ac_ok = 1;

    QDir battdir("/proc/acpi/battery");
    battdir.setFilter(QDir::Dirs);
    if(!battdir.isReadable())
        return(val = 0);
    for(uint i = 0; !battdir[i].isNull(); ++i) {
        if(battdir[i] == "." || battdir[i] == "..")
            continue;
        bool ok = 0;
        acpi_battery_info bat = {0,0,0,0,0,0,0,0,0};
        QString base = battdir.path() + "/" + battdir[i] + "/";
        QString name(base + "state");
        QFileInfo f(name);
        if(f.isReadable()) {
            bat.state_file = name;
            ok = true;
        } else {
            name = base + "status";
            f.setFile(name);
            if(f.isReadable()) {
                bat.state_file = name;
                ok = true;
            }
        }
        name = base + "info";
        f.setFile(name);
        if(f.isReadable()) {
            bat.info_file = name;
            ok = true;
        }
        if (ok) {
            bat.name = battdir[i];
            acpi_batteries.append(bat);
            val = 1;
        }
    }
    if (!acpi_ac_ok)
        val = 0;
    return(val);
}

static unsigned long acpi_sleep_enabled = 0x00; // acpi sleep functions enabled mask


static bool
has_acpi_sleep(int state)
{
    static int known=0;
    static unsigned long mask=0;
    if (known != last_seed) {
        known = last_seed;
        mask = 0;
        QFile f("/proc/acpi/sleep");
        if (f.open(QIODevice::ReadOnly)) {
            QString l;
                l= f.readLine();
            QStringList ll = QStringList::split(' ',l,false);
            for (QStringList::const_iterator i = ll.constBegin(); i!=ll.constEnd(); ++i) {
                QString s = *i;
                if (s[0] == 'S') {
                    int c = s[1].digitValue();
                    if (c >= 0 && c <= 9)
                        mask |= 1<<c;
                }
            }
            f.close();
        }
    }
    return((mask&acpi_sleep_enabled&(1<<state)) != 0);
}

static bool acpi_performance_enabled = 0;
static bool acpi_throttle_enabled = 0;
void
laptop_portable::acpi_set_mask(bool standby, bool suspend, bool hibernate, bool perf, bool throttle)
{
    acpi_sleep_enabled =
            (standby ? (1<<1)|(1<<2) : 0) |
            (suspend ? 1<<3 : 0) |
            (hibernate ? 1<<4 : 0);
    acpi_performance_enabled = perf;
    acpi_throttle_enabled = throttle;
    last_seed++;
}

static void
invoke_acpi_helper(const char *param, const char *param2, const char *param3)
{
    KProcess proc;
    proc << KStandardDirs::findExe("klaptop_acpi_helper");
    proc << param;
    if (param2)
        proc << param2;
    if (param3)
        proc << param3;
    proc.execute(); // helper runs fast and we want to see the result
}

static unsigned long apm_sleep_enabled = 0x0c;  // apm sleep functions enabled mask
static bool
has_apm_sleep(int state)
{
    return((apm_sleep_enabled&(1<<state)) != 0);
}

void
laptop_portable::apm_set_mask(bool standby, bool suspend)
{
    apm_sleep_enabled =
            (standby ? 1<<2 : 0) |
            (suspend ? 1<<3 : 0);
    last_seed++;
}

static bool apm_sleep_access_ok();
static bool acpi_sleep_access_ok();

static int
apm_has_time()
{
        return(!apm_no_time);
}

//
//  something changed maybe we need to check out environment again
//
void
laptop_portable::power_management_restart()
{
    last_seed++;
    x_acpi_init = 0;
}

int laptop_portable::has_apm(int type)
{
    switch (type) {
    case 0:
        return(::has_apm());
    case 1:
        return(::has_apm() && ::apm_sleep_access_ok());
    default:
        return(0);
    }
}

//
//  returns 1 if we support acpi
//
int laptop_portable::has_acpi(int type)
{
    switch (type) {
    case 0:
        return(::has_acpi_power());
    case 1:
        return(::has_acpi() && ::acpi_sleep_access_ok());
    case 3:
        return(::has_acpi() &&::acpi_sleep_access_ok() && (::has_acpi_sleep(1)||::has_acpi_sleep(2)));
    case 4:
        return(::has_acpi() &&::acpi_sleep_access_ok() && ::has_acpi_sleep(3));
    case 5:
        return(::has_acpi() &&::acpi_sleep_access_ok() && ::has_acpi_sleep(4));
    default:
        return(0);
    }
}

//
// The following code was derived from tpctl for IBM thinkpad support
//      (Thomas Hood, Bill Mair - tpctl.sourceforge.net)
//
//  we check for the existence of /dev/thinkpad/thinkpad or /dev/thinkpad
//
static const char *ibm_device;
static int ibm_fd = -1;

static bool has_ibm()
{
    static int known=0;
    static bool result;
    if (known == last_seed)
        return(result);
    known = last_seed;
    result = 0;
    if (ibm_fd >= 0) {
        result = 1;
        return(1);
    }
    ibm_device = "/dev/thinkpad/thinkpad";
    if ((ibm_fd = open(ibm_device, O_RDWR)) < 0) {
        ibm_device = "/dev/thinkpad";
        if ((ibm_fd = open(ibm_device, O_RDWR)) < 0)
            return(0);
    }
    result = 1;
    return(1);
}
//
//  returns 1 if we support power management
//
int laptop_portable::has_power_management()
{
    if (::has_apm())
        return 1;
    if (::has_pmu())
        return 1;
    if (::has_acpi_power())
        return 1;
    if (::has_ibm())
        return 1;
    // INSERT HERE
    return 0;
}
//
//  returns 1 if the BIOS returns the time left in the battery rather than a % of full
//
int laptop_portable::has_battery_time()
{
    if (::has_acpi_power())
        return 1;
    if (::apm_has_time())
        return 1;
    // INSERT HERE
    return 0;
}
//
//  returns 1 if we can perform a change-to-suspend-mode operation for the user
//  (has_power_management() has already returned 1)
//
int laptop_portable::has_suspend()
{
    if (::has_acpi())
        return ::acpi_sleep_access_ok() && ::has_acpi_sleep(3);
    if (::has_pmu())
        return 1;
    if (::has_ibm())
        return 1;
    if (::has_apm())
        return ::apm_sleep_access_ok() && ::has_apm_sleep(3);
    // INSERT HERE
    return 0;
}
//
//  returns 1 if we can perform a change-to-standby-mode operation for the user
//  (has_power_management() has already returned 1)
//
int laptop_portable::has_standby()
{
    if (::has_pmu())
        return 0;
    if (::has_acpi())
        return ::acpi_sleep_access_ok() && (::has_acpi_sleep(1)||::has_acpi_sleep(2));
    if (::has_ibm())
        return 1;
    if (::has_apm())
        return ::apm_sleep_access_ok() && ::has_apm_sleep(2);
    // INSERT HERE
    return 0;
}
//
//  returns 1 if we can perform a change-to-hibernate-mode for a user
//      (has_power_management() has already returned 1)  [hibernate is the save-to-disk mode
//  not supported by linux APM]
//
int laptop_portable::has_hibernation()
{
    if (::has_pmu())
        return 0;
    if (::has_software_suspend(1))  // must be before acpi
        return 1;
    if (::has_acpi())
        return ::acpi_sleep_access_ok() && ::has_acpi_sleep(4);
    if (::has_ibm())
        return 1;
    // INSERT HERE
    return 0;
}

//
//  explain to the user what they need to do if has_power_management() returned 0
//  to get any software they lack
//

K3ActiveLabel *laptop_portable::no_power_management_explanation(QWidget *parent)
{
    if (access("/proc/acpi", F_OK) == 0) {  // probably has default kernel ACPI installed
        K3ActiveLabel* explain = new K3ActiveLabel(i18n("Your computer seems to have a partial ACPI installation. ACPI was probably enabled, but some of the sub-options were not - you need to enable at least 'AC Adaptor' and 'Control Method Battery' and then rebuild your kernel."), parent);
        return(explain);
    }

    K3ActiveLabel* explain = new K3ActiveLabel(i18n("Your computer doesn't have the Linux APM (Advanced Power Management) or ACPI software installed, or doesn't have the APM kernel drivers installed - check out the <a href=\"http://www.linuxdoc.org/HOWTO/Laptop-HOWTO.html\">Linux Laptop-HOWTO</a> document for information on how to install APM."), parent);

    return(explain);
}

//
//  explain to the user what they need to do to get suspend/resume to work from user mode
//
QLabel *laptop_portable::how_to_do_suspend_resume(QWidget *parent)
{
    if (::has_apm()) {
                // TODO: remove linefeed from string, can't do it right now coz we have a string freeze
        QLabel* note = new KRichTextLabel(i18n("\nIf you make /usr/bin/apm setuid then you will also "
                        "be able to choose 'suspend' and 'standby' in the above "
                        "dialog - check out the help button below to find out "
                        "how to do this").replace("\n", QString()), parent);
        return(note);
    }
    if (::has_acpi()) {
                // TODO: remove linefeed from string, can't do it right now coz we have a string freeze
        QLabel* note = new KRichTextLabel(i18n("\nYou may need to enable ACPI suspend/resume in the ACPI panel").replace("\n", QString()), parent);
        return(note);
    }
        // TODO: remove linefeed from string, can't do it right now coz we have a string freeze
    QLabel* note = new KRichTextLabel(i18n("\nYour system does not support suspend/standby").replace("\n", QString()), parent);
    return(note);
}

static char tmp0[256], tmp1[256];
static int present=0;
static
void get_pcmcia_info()
{
      FILE *f = fopen("/var/lib/pcmcia/stab", "r");
      if (!f) f = fopen("/var/run/stab", "r");
      if (f) {
    int c;
    char *cp;

    present = 1;
    cp = tmp0;
    for (;;) {
        c = fgetc(f);
        if (c == EOF || c == '\n')
            break;
        if (c == ':') {
            while ((c = fgetc(f)) == ' ')
                ;
            if (c == EOF)
                break;
            for (;;) {
                *cp++ = c;
                c = fgetc(f);
                if (c == EOF || c == '\n')
                    break;
            }
            break;
        }
    }
    *cp = 0;

    if (c != EOF) {
        cp = tmp1;
        for (;;) {
            c = fgetc(f);
            if (c == EOF)
                break;
            if (c == ':') {
                while ((c = fgetc(f)) == ' ')
                    ;
                if (c == EOF)
                    break;
                for (;;) {
                    *cp++ = c;
                    c = fgetc(f);
                    if (c == EOF || c == '\n')
                        break;
                }
                break;
            }
        }
    *cp = 0;
    }

    fclose(f);
      } else {
    present = 0;
      }
}

//
//  pcmcia support - this will be replaced by better - pcmcia support being worked on by
//  others
//
QLabel *laptop_portable::pcmcia_info(int x, QWidget *parent)
{
    if (x == 0)
        get_pcmcia_info();
    if (!present) {
        if (x == 1)
                return(new QLabel(i18n("No PCMCIA controller detected"), parent));
            return(new QLabel(parent));
    } else {
        switch (x) {
            case 0: return(new QLabel(i18n("Card 0:"), parent));
            case 1: return(new QLabel(tmp0, parent));
        case 2: return(new QLabel(i18n("Card 1:"), parent));
            default:return(new QLabel(tmp1, parent));
        }
    }
}

//
//  puts us into standby mode
//
void laptop_portable::invoke_standby()
{
    last_seed++;    // make it look for battery removal/return
    if (::has_acpi()) {
        if (::has_acpi_sleep(1)) {  // people seem to argue as to which is 'standby' the S1 people are winning
            ::invoke_acpi_helper("--standby", 0, 0);
        } else {
            ::invoke_acpi_helper("--standby2", 0, 0);
        }
        return;
    }
    if (::has_ibm()) {
        smapi_ioparm_t ioparmMy;
        sync();
        ioparmMy.in.bFunc = (byte) 0x70;
        ioparmMy.in.bSubFunc = (byte) 0;
        ioparmMy.in.wParm1 = (word) 0;
        ioparmMy.in.wParm2 = (word) 0;
        ioparmMy.in.wParm3 = (word) 0;
        ioparmMy.in.dwParm4 = (dword) 0;
        ioparmMy.in.dwParm5 = (dword) 0;
        (void)ioctl_smapi( ibm_fd, &ioparmMy );
        return;
    }
    // add other machine specific standbys here
    KProcess proc;
    proc << "/usr/bin/apm";
    proc << "--standby";
    proc.execute(); // helper runs fast and we want to see the result
}

//
//  puts us into suspend mode
//
void laptop_portable::invoke_suspend()
{
    last_seed++;    // make it look for battery removal/return

    if (::has_pmu()) {
        KProcess proc;
        proc << "/usr/bin/apm";
        proc << "-f";
        proc.execute(); // helper runs fast and we want to see the result
        return;
    }

    if (::has_acpi()) {
        ::invoke_acpi_helper("--suspend", 0, 0);
        return;
    }
    if (::has_ibm()) {
        smapi_ioparm_t ioparmMy;
        sync();
        ioparmMy.in.bFunc = (byte) 0x70;
        ioparmMy.in.bSubFunc = (byte) 1;
        ioparmMy.in.wParm1 = (word) 0;
        ioparmMy.in.wParm2 = (word) 0;
        ioparmMy.in.wParm3 = (word) 0;
        ioparmMy.in.dwParm4 = (dword) 0;
        ioparmMy.in.dwParm5 = (dword) 0;
        (void)ioctl_smapi( ibm_fd, &ioparmMy );
        return;
    }
    // add other machine specific suspends here
    KProcess proc;
    proc << "/usr/bin/apm";
    proc << "--suspend";
    proc.execute(); // helper runs fast and we want to see the result
}

//
//  puts us into hibernate mode
//
void laptop_portable::invoke_hibernation()
{
    last_seed++;    // make it look for battery removal/return
    if (::has_software_suspend(1)) {    // must be before acpi
        ::invoke_acpi_helper("--software-suspend", 0, 0);
        return;
    }
    if (::has_acpi()) {
        ::invoke_acpi_helper("--hibernate", 0, 0);
        return;
    }
    if (::has_ibm()) {
        smapi_ioparm_t ioparmMy;
        sync();
        ioparmMy.in.bFunc = (byte) 0x70;
        ioparmMy.in.bSubFunc = (byte) 2;
        ioparmMy.in.wParm1 = (word) 0;
        ioparmMy.in.wParm2 = (word) 0;
        ioparmMy.in.wParm3 = (word) 0;
        ioparmMy.in.dwParm4 = (dword) 0;
        ioparmMy.in.dwParm5 = (dword) 0;
        (void)ioctl_smapi( ibm_fd, &ioparmMy );
        return;
    }
    // add other machine specific hibernates here
}

void
laptop_portable::extra_config(QWidget *wp, KConfig *, QVBoxLayout *top_layout)
{
    if (laptop_portable::has_apm(1) || laptop_portable::has_acpi(1))
        return;
    if (laptop_portable::has_apm(0)) {
            QLabel* explain = new KRichTextLabel( i18n("Your system has APM installed but may not be able to use all "
                               "of its features without further setup - look in the 'APM Config' "
                           "tab for information about setting up APM for suspend and resume"), wp);
        top_layout->addWidget(explain, 0);
    }
    if (laptop_portable::has_acpi(0)) {
            QLabel* explain = new KRichTextLabel( i18n("Your system has ACPI installed but may not be able to use all "
                               "of its features without further setup - look in the 'ACPI Config' "
                           "tab for information about setting up ACPI for suspend and resume"), wp);
            top_layout->addWidget(explain, 0);
    }
}

//
//  return current battery state
//
struct power_result laptop_portable::poll_battery_state()
{
    struct power_result p;

    apm_info x = {0,0,0,-1};
    if (have_pmu()) {
        pmu_read(&x);
    } else
    if ((::has_acpi_power() ? ::acpi_read(&x) : ::apm_read(&x)) || (x.apm_flags&0x20)) {
        // INSERT HERE
                p.powered = 0;
                p.percentage=0;
                p.time = -1;
        return p;
        }
    p.powered = x.ac_line_status&1;
    p.percentage = x.battery_percentage;
    p.time = x.battery_time;
    return(p);
}

void
laptop_portable::get_battery_status(int &num_batteries, QStringList &names, QStringList &state, QStringList &values)
{
    struct power_result r;

    if (!has_power_management()) {
        num_batteries = 0;
        names.clear();
        state.clear();
        values.clear();
        return;
    }

    if (::has_acpi_power()) {
        names.clear();
        state.clear();
        values.clear();
        acpi_read_batteries();
        num_batteries = acpi_batteries.count();
        for(int i = 0; i < acpi_batteries.count(); ++i) {
            acpi_battery_info& bat = acpi_batteries[i];
            names.append(bat.name);
            values.append(QString("%1").arg(bat.percentage));
            state.append(bat.present ? "yes" : "no");
        }
        return;
    }

    // INSERT HERE

    num_batteries = 1;
    r = poll_battery_state();
    names.append("BAT1");
    state.append("yes");
    QString s;
    s.setNum(r.percentage);
    values.append(s);
}


//
//  returns the current system load average, -1 if none
//
static QFile lav_file;
static bool lav_inited=0;
static bool lav_openok=0;

static bool has_lav()
{
    if (!lav_inited) {
        lav_inited =1;
        lav_file.setName("/proc/loadavg");
        lav_openok = lav_file.open( QIODevice::ReadOnly );
        if (lav_openok)
            lav_file.close();
    }
    return(lav_openok);
}

bool laptop_portable::has_lav()
{
    return ::has_lav();
}

float laptop_portable::get_load_average()
{
    if (!::has_lav())
        return(-1);
    lav_file.open( QIODevice::ReadOnly );
    QString l;
        l=lav_file.readLine();
    lav_file.close();
    QStringList ll = QStringList::split(' ', l, false);
    l = ll[0];
    bool ok;
    float f = l.toFloat(&ok);
    if (!ok)
        f = -1;
    return(f);
}


int laptop_portable::has_cpufreq() {
    struct stat sb;
    int rc;
    rc = stat("/proc/cpufreq", &sb);
    if (rc == 0) {
        rc = stat("/proc/cpuinfo", &sb);
        if (rc == 0)
            return 1;
    }
    // INSERT HERE
    return 0;
}


QString laptop_portable::cpu_frequency() {
    QString rc;
    QFile cf("/proc/cpufreq");
    bool haveProfile = false;

    if (cf.open(QIODevice::ReadOnly)) {
        while (!cf.atEnd()) {
            QString l;
                l = cf.readLine();
            if (l.left(3) == "CPU") {
                QStringList ll = QStringList::split(' ', l, false);
                rc = ll.last();
                haveProfile = true;
                break;
            }
        }

    }
    if (haveProfile) {
        QFile ci("/proc/cpuinfo");
        if (ci.open(QIODevice::ReadOnly)) {
            while (!ci.atEnd()) {
                QString l;
                    l=ci.readLine();
                QStringList ll =
                    QStringList::split(':',l,false);
                if (ll.count() != 2)
                    continue;
                if (ll.first().trimmed()
                        == "cpu MHz") {
                    rc = i18n("%1 MHz (%2)", ll.last().trimmed(), rc);
                    break;
                } else if (ll.first().trimmed()
                        == "clock") {
                    rc = QString("%1 (%2)").arg(ll.last().trimmed()).arg(rc);
                    break;
                }
            }
        }
    }

    return rc;
}

static int sonyFd = -1;
static int has_toshiba_brightness = 0;

static bool
acpi_helper_ok(bool type)
{
    static int known[2]={0,0};
    static bool known_res[2];

    if (known[type] == last_seed)
        return(known_res[type]);
    known[type] = last_seed;
    known_res[type] = 0;
    struct stat sb;