[mirror_ubuntu-bionic-kernel.git] / drivers / platform / x86 / compal-laptop.c

/*-*-linux-c-*-*/

/*
  Copyright (C) 2008 Cezary Jackiewicz <cezary.jackiewicz (at) gmail.com>

  based on MSI driver

  Copyright (C) 2006 Lennart Poettering <mzxreary (at) 0pointer (dot) de>

  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.
 */

/*
 * compal-laptop.c - Compal laptop support.
 *
 * This driver exports a few files in /sys/devices/platform/compal-laptop/:
 *   wake_up_XXX   Whether or not we listen to such wake up events (rw)
 *
 * In addition to these platform device attributes the driver
 * registers itself in the Linux backlight control, power_supply, rfkill
 * and hwmon subsystem and is available to userspace under:
 *
 *   /sys/class/backlight/compal-laptop/
 *   /sys/class/power_supply/compal-laptop/
 *   /sys/class/rfkill/rfkillX/
 *   /sys/class/hwmon/hwmonX/
 *
 * Notes on the power_supply battery interface:
 *   - the "minimum" design voltage is *the* design voltage
 *   - the ambient temperature is the average battery temperature
 *     and the value is an educated guess (see commented code below)
 *
 *
 * This driver might work on other laptops produced by Compal. If you
 * want to try it you can pass force=1 as argument to the module which
 * will force it to load even when the DMI data doesn't identify the
 * laptop as compatible.
 *
 * Lots of data available at:
 * http://service1.marasst.com/Compal/JHL90_91/Service%20Manual/
 * JHL90%20service%20manual-Final-0725.pdf
 *
 *
 *
 * Support for the Compal JHL90 added by Roald Frederickx
 * (roald.frederickx@gmail.com):
 * Driver got large revision. Added functionalities: backlight
 * power, wake_on_XXX, a hwmon and power_supply interface.
 *
 * In case this gets merged into the kernel source: I want to dedicate this
 * to Kasper Meerts, the awesome guy who showed me Linux and C!
 */

/* NOTE: currently the wake_on_XXX, hwmon and power_supply interfaces are
 * only enabled on a JHL90 board until it is verified that they work on the
 * other boards too.  See the extra_features variable. */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/acpi.h>
#include <linux/dmi.h>
#include <linux/backlight.h>
#include <linux/platform_device.h>
#include <linux/rfkill.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/power_supply.h>
#include <linux/fb.h>
#include <acpi/video.h>

/* ======= */
/* Defines */
/* ======= */
#define DRIVER_NAME "compal-laptop"
#define DRIVER_VERSION  "0.2.7"

#define BACKLIGHT_LEVEL_ADDR            0xB9
#define BACKLIGHT_LEVEL_MAX             7
#define BACKLIGHT_STATE_ADDR            0x59
#define BACKLIGHT_STATE_ON_DATA         0xE1
#define BACKLIGHT_STATE_OFF_DATA        0xE2

#define WAKE_UP_ADDR                    0xA4
#define WAKE_UP_PME                     (1 << 0)
#define WAKE_UP_MODEM                   (1 << 1)
#define WAKE_UP_LAN                     (1 << 2)
#define WAKE_UP_WLAN                    (1 << 4)
#define WAKE_UP_KEY                     (1 << 6)
#define WAKE_UP_MOUSE                   (1 << 7)

#define WIRELESS_ADDR                   0xBB
#define WIRELESS_WLAN                   (1 << 0)
#define WIRELESS_BT                     (1 << 1)
#define WIRELESS_WLAN_EXISTS            (1 << 2)
#define WIRELESS_BT_EXISTS              (1 << 3)
#define WIRELESS_KILLSWITCH             (1 << 4)

#define PWM_ADDRESS                     0x46
#define PWM_DISABLE_ADDR                0x59
#define PWM_DISABLE_DATA                0xA5
#define PWM_ENABLE_ADDR                 0x59
#define PWM_ENABLE_DATA                 0xA8

#define FAN_ADDRESS                     0x46
#define FAN_DATA                        0x81
#define FAN_FULL_ON_CMD                 0x59 /* Doesn't seem to work. Just */
#define FAN_FULL_ON_ENABLE              0x76 /* force the pwm signal to its */
#define FAN_FULL_ON_DISABLE             0x77 /* maximum value instead */

#define TEMP_CPU                        0xB0
#define TEMP_CPU_LOCAL                  0xB1
#define TEMP_CPU_DTS                    0xB5
#define TEMP_NORTHBRIDGE                0xB6
#define TEMP_VGA                        0xB4
#define TEMP_SKIN                       0xB2

#define BAT_MANUFACTURER_NAME_ADDR      0x10
#define BAT_MANUFACTURER_NAME_LEN       9
#define BAT_MODEL_NAME_ADDR             0x19
#define BAT_MODEL_NAME_LEN              6
#define BAT_SERIAL_NUMBER_ADDR          0xC4
#define BAT_SERIAL_NUMBER_LEN           5
#define BAT_CHARGE_NOW                  0xC2
#define BAT_CHARGE_DESIGN               0xCA
#define BAT_VOLTAGE_NOW                 0xC6
#define BAT_VOLTAGE_DESIGN              0xC8
#define BAT_CURRENT_NOW                 0xD0
#define BAT_CURRENT_AVG                 0xD2
#define BAT_POWER                       0xD4
#define BAT_CAPACITY                    0xCE
#define BAT_TEMP                        0xD6
#define BAT_TEMP_AVG                    0xD7
#define BAT_STATUS0                     0xC1
#define BAT_STATUS1                     0xF0
#define BAT_STATUS2                     0xF1
#define BAT_STOP_CHARGE1                0xF2
#define BAT_STOP_CHARGE2                0xF3
#define BAT_CHARGE_LIMIT                0x03
#define BAT_CHARGE_LIMIT_MAX            100

#define BAT_S0_DISCHARGE                (1 << 0)
#define BAT_S0_DISCHRG_CRITICAL         (1 << 2)
#define BAT_S0_LOW                      (1 << 3)
#define BAT_S0_CHARGING                 (1 << 1)
#define BAT_S0_AC                       (1 << 7)
#define BAT_S1_EXISTS                   (1 << 0)
#define BAT_S1_FULL                     (1 << 1)
#define BAT_S1_EMPTY                    (1 << 2)
#define BAT_S1_LiION_OR_NiMH            (1 << 7)
#define BAT_S2_LOW_LOW                  (1 << 0)
#define BAT_STOP_CHRG1_BAD_CELL         (1 << 1)
#define BAT_STOP_CHRG1_COMM_FAIL        (1 << 2)
#define BAT_STOP_CHRG1_OVERVOLTAGE      (1 << 6)
#define BAT_STOP_CHRG1_OVERTEMPERATURE  (1 << 7)


/* ======= */
/* Structs */
/* ======= */
struct compal_data{
        /* Fan control */
        int pwm_enable; /* 0:full on, 1:set by pwm1, 2:control by motherboard */
        unsigned char curr_pwm;

        /* Power supply */
        struct power_supply *psy;
        struct power_supply_info psy_info;
        char bat_model_name[BAT_MODEL_NAME_LEN + 1];
        char bat_manufacturer_name[BAT_MANUFACTURER_NAME_LEN + 1];
        char bat_serial_number[BAT_SERIAL_NUMBER_LEN + 1];
};


/* =============== */
/* General globals */
/* =============== */
static bool force;
module_param(force, bool, 0);
MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");

/* Support for the wake_on_XXX, hwmon and power_supply interface. Currently
 * only gets enabled on a JHL90 board. Might work with the others too */
static bool extra_features;

/* Nasty stuff. For some reason the fan control is very un-linear.  I've
 * come up with these values by looping through the possible inputs and
 * watching the output of address 0x4F (do an ec_transaction writing 0x33
 * into 0x4F and read a few bytes from the output, like so:
 *      u8 writeData = 0x33;
 *      ec_transaction(0x4F, &writeData, 1, buffer, 32);
 * That address is labeled "fan1 table information" in the service manual.
 * It should be clear which value in 'buffer' changes). This seems to be
 * related to fan speed. It isn't a proper 'realtime' fan speed value
 * though, because physically stopping or speeding up the fan doesn't
 * change it. It might be the average voltage or current of the pwm output.
 * Nevertheless, it is more fine-grained than the actual RPM reading */
static const unsigned char pwm_lookup_table[256] = {
        0, 0, 0, 1, 1, 1, 2, 253, 254, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6,
        7, 7, 7, 8, 86, 86, 9, 9, 9, 10, 10, 10, 11, 92, 92, 12, 12, 95,
        13, 66, 66, 14, 14, 98, 15, 15, 15, 16, 16, 67, 17, 17, 72, 18, 70,
        75, 19, 90, 90, 73, 73, 73, 21, 21, 91, 91, 91, 96, 23, 94, 94, 94,
        94, 94, 94, 94, 94, 94, 94, 141, 141, 238, 223, 192, 139, 139, 139,
        139, 139, 142, 142, 142, 142, 142, 78, 78, 78, 78, 78, 76, 76, 76,
        76, 76, 79, 79, 79, 79, 79, 79, 79, 20, 20, 20, 20, 20, 22, 22, 22,
        22, 22, 24, 24, 24, 24, 24, 24, 219, 219, 219, 219, 219, 219, 219,
        219, 27, 27, 188, 188, 28, 28, 28, 29, 186, 186, 186, 186, 186,
        186, 186, 186, 186, 186, 31, 31, 31, 31, 31, 32, 32, 32, 41, 33,
        33, 33, 33, 33, 252, 252, 34, 34, 34, 43, 35, 35, 35, 36, 36, 38,
        206, 206, 206, 206, 206, 206, 206, 206, 206, 37, 37, 37, 46, 46,
        47, 47, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 48, 48,
        48, 48, 48, 40, 40, 40, 49, 42, 42, 42, 42, 42, 42, 42, 42, 44,
        189, 189, 189, 189, 54, 54, 45, 45, 45, 45, 45, 45, 45, 45, 251,
        191, 199, 199, 199, 199, 199, 215, 215, 215, 215, 187, 187, 187,
        187, 187, 193, 50
};




/* ========================= */
/* Hardware access functions */
/* ========================= */
/* General access */
static u8 ec_read_u8(u8 addr)
{
        u8 value;
        ec_read(addr, &value);
        return value;
}

static s8 ec_read_s8(u8 addr)
{
        return (s8)ec_read_u8(addr);
}

static u16 ec_read_u16(u8 addr)
{
        int hi, lo;
        lo = ec_read_u8(addr);
        hi = ec_read_u8(addr + 1);
        return (hi << 8) + lo;
}

static s16 ec_read_s16(u8 addr)
{
        return (s16) ec_read_u16(addr);
}

static void ec_read_sequence(u8 addr, u8 *buf, int len)
{
        int i;
        for (i = 0; i < len; i++)
                ec_read(addr + i, buf + i);
}


/* Backlight access */
static int set_backlight_level(int level)
{
        if (level < 0 || level > BACKLIGHT_LEVEL_MAX)
                return -EINVAL;

        ec_write(BACKLIGHT_LEVEL_ADDR, level);

        return 0;
}

static int get_backlight_level(void)
{
        return (int) ec_read_u8(BACKLIGHT_LEVEL_ADDR);
}

static void set_backlight_state(bool on)
{
        u8 data = on ? BACKLIGHT_STATE_ON_DATA : BACKLIGHT_STATE_OFF_DATA;
        ec_transaction(BACKLIGHT_STATE_ADDR, &data, 1, NULL, 0);
}


/* Fan control access */
static void pwm_enable_control(void)
{
        unsigned char writeData = PWM_ENABLE_DATA;
        ec_transaction(PWM_ENABLE_ADDR, &writeData, 1, NULL, 0);
}

static void pwm_disable_control(void)
{
        unsigned char writeData = PWM_DISABLE_DATA;
        ec_transaction(PWM_DISABLE_ADDR, &writeData, 1, NULL, 0);
}

static void set_pwm(int pwm)
{
        ec_transaction(PWM_ADDRESS, &pwm_lookup_table[pwm], 1, NULL, 0);
}

static int get_fan_rpm(void)
{
        u8 value, data = FAN_DATA;
        ec_transaction(FAN_ADDRESS, &data, 1, &value, 1);
        return 100 * (int)value;
}




/* =================== */
/* Interface functions */
/* =================== */

/* Backlight interface */
static int bl_get_brightness(struct backlight_device *b)
{
        return get_backlight_level();
}

static int bl_update_status(struct backlight_device *b)
{
        int ret = set_backlight_level(b->props.brightness);
        if (ret)
                return ret;

        set_backlight_state((b->props.power == FB_BLANK_UNBLANK)
                &&    !(b->props.state & BL_CORE_SUSPENDED)
                &&    !(b->props.state & BL_CORE_FBBLANK));
        return 0;
}

static const struct backlight_ops compalbl_ops = {
        .get_brightness = bl_get_brightness,
        .update_status  = bl_update_status,
};


/* Wireless interface */
static int compal_rfkill_set(void *data, bool blocked)
{
        unsigned long radio = (unsigned long) data;
        u8 result = ec_read_u8(WIRELESS_ADDR);
        u8 value;

        if (!blocked)
                value = (u8) (result | radio);
        else
                value = (u8) (result & ~radio);
        ec_write(WIRELESS_ADDR, value);

        return 0;
}

static void compal_rfkill_poll(struct rfkill *rfkill, void *data)
{
        u8 result = ec_read_u8(WIRELESS_ADDR);
        bool hw_blocked = !(result & WIRELESS_KILLSWITCH);
        rfkill_set_hw_state(rfkill, hw_blocked);
}

static const struct rfkill_ops compal_rfkill_ops = {
        .poll = compal_rfkill_poll,
        .set_block = compal_rfkill_set,
};


/* Wake_up interface */
#define SIMPLE_MASKED_STORE_SHOW(NAME, ADDR, MASK)                      \
static ssize_t NAME##_show(struct device *dev,                          \
        struct device_attribute *attr, char *buf)                       \
{                                                                       \
        return sprintf(buf, "%d\n", ((ec_read_u8(ADDR) & MASK) != 0));  \
}                                                                       \
static ssize_t NAME##_store(struct device *dev,                         \
        struct device_attribute *attr, const char *buf, size_t count)   \
{                                                                       \
        int state;                                                      \
        u8 old_val = ec_read_u8(ADDR);                                  \
        if (sscanf(buf, "%d", &state) != 1 || (state < 0 || state > 1)) \
                return -EINVAL;                                         \
        ec_write(ADDR, state ? (old_val | MASK) : (old_val & ~MASK));   \
        return count;                                                   \
}

SIMPLE_MASKED_STORE_SHOW(wake_up_pme,   WAKE_UP_ADDR, WAKE_UP_PME)
SIMPLE_MASKED_STORE_SHOW(wake_up_modem, WAKE_UP_ADDR, WAKE_UP_MODEM)
SIMPLE_MASKED_STORE_SHOW(wake_up_lan,   WAKE_UP_ADDR, WAKE_UP_LAN)
SIMPLE_MASKED_STORE_SHOW(wake_up_wlan,  WAKE_UP_ADDR, WAKE_UP_WLAN)
SIMPLE_MASKED_STORE_SHOW(wake_up_key,   WAKE_UP_ADDR, WAKE_UP_KEY)
SIMPLE_MASKED_STORE_SHOW(wake_up_mouse, WAKE_UP_ADDR, WAKE_UP_MOUSE)

/* Fan control interface */
static ssize_t pwm_enable_show(struct device *dev,
                struct device_attribute *attr, char *buf)
{
        struct compal_data *data = dev_get_drvdata(dev);
        return sprintf(buf, "%d\n", data->pwm_enable);
}

static ssize_t pwm_enable_store(struct device *dev,
                struct device_attribute *attr, const char *buf, size_t count)
{
        struct compal_data *data = dev_get_drvdata(dev);
        long val;
        int err;

        err = kstrtol(buf, 10, &val);
        if (err)
                return err;
        if (val < 0)
                return -EINVAL;

        data->pwm_enable = val;

        switch (val) {
        case 0:  /* Full speed */
                pwm_enable_control();
                set_pwm(255);
                break;
        case 1:  /* As set by pwm1 */
                pwm_enable_control();
                set_pwm(data->curr_pwm);
                break;
        default: /* Control by motherboard */
                pwm_disable_control();
                break;
        }

        return count;
}

static ssize_t pwm_show(struct device *dev, struct device_attribute *attr,
                char *buf)
{
        struct compal_data *data = dev_get_drvdata(dev);
        return sprintf(buf, "%hhu\n", data->curr_pwm);
}

static ssize_t pwm_store(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t count)
{
        struct compal_data *data = dev_get_drvdata(dev);
        long val;
        int err;

        err = kstrtol(buf, 10, &val);
        if (err)
                return err;
        if (val < 0 || val > 255)
                return -EINVAL;

        data->curr_pwm = val;

        if (data->pwm_enable != 1)
                return count;
        set_pwm(val);

        return count;
}

static ssize_t fan_show(struct device *dev, struct device_attribute *attr,
                char *buf)
{
        return sprintf(buf, "%d\n", get_fan_rpm());
}


/* Temperature interface */
#define TEMPERATURE_SHOW_TEMP_AND_LABEL(POSTFIX, ADDRESS, LABEL)        \
static ssize_t temp_##POSTFIX(struct device *dev,                       \
                struct device_attribute *attr, char *buf)               \
{                                                                       \
        return sprintf(buf, "%d\n", 1000 * (int)ec_read_s8(ADDRESS));   \
}                                                                       \
static ssize_t label_##POSTFIX(struct device *dev,                      \
                struct device_attribute *attr, char *buf)               \
{                                                                       \
        return sprintf(buf, "%s\n", LABEL);                             \
}

/* Labels as in service guide */
TEMPERATURE_SHOW_TEMP_AND_LABEL(cpu,        TEMP_CPU,        "CPU_TEMP");
TEMPERATURE_SHOW_TEMP_AND_LABEL(cpu_local,  TEMP_CPU_LOCAL,  "CPU_TEMP_LOCAL");
TEMPERATURE_SHOW_TEMP_AND_LABEL(cpu_DTS,    TEMP_CPU_DTS,    "CPU_DTS");
TEMPERATURE_SHOW_TEMP_AND_LABEL(northbridge,TEMP_NORTHBRIDGE,"NorthBridge");
TEMPERATURE_SHOW_TEMP_AND_LABEL(vga,        TEMP_VGA,        "VGA_TEMP");
TEMPERATURE_SHOW_TEMP_AND_LABEL(SKIN,       TEMP_SKIN,       "SKIN_TEMP90");


/* Power supply interface */
static int bat_status(void)
{
        u8 status0 = ec_read_u8(BAT_STATUS0);
        u8 status1 = ec_read_u8(BAT_STATUS1);

        if (status0 & BAT_S0_CHARGING)
                return POWER_SUPPLY_STATUS_CHARGING;
        if (status0 & BAT_S0_DISCHARGE)
                return POWER_SUPPLY_STATUS_DISCHARGING;
        if (status1 & BAT_S1_FULL)
                return POWER_SUPPLY_STATUS_FULL;
        return POWER_SUPPLY_STATUS_NOT_CHARGING;
}

static int bat_health(void)
{
        u8 status = ec_read_u8(BAT_STOP_CHARGE1);

        if (status & BAT_STOP_CHRG1_OVERTEMPERATURE)
                return POWER_SUPPLY_HEALTH_OVERHEAT;
        if (status & BAT_STOP_CHRG1_OVERVOLTAGE)
                return POWER_SUPPLY_HEALTH_OVERVOLTAGE;
        if (status & BAT_STOP_CHRG1_BAD_CELL)
                return POWER_SUPPLY_HEALTH_DEAD;
        if (status & BAT_STOP_CHRG1_COMM_FAIL)
                return POWER_SUPPLY_HEALTH_UNKNOWN;
        return POWER_SUPPLY_HEALTH_GOOD;
}

static int bat_is_present(void)
{
        u8 status = ec_read_u8(BAT_STATUS2);
        return ((status & BAT_S1_EXISTS) != 0);
}

static int bat_technology(void)
{
        u8 status = ec_read_u8(BAT_STATUS1);

        if (status & BAT_S1_LiION_OR_NiMH)
                return POWER_SUPPLY_TECHNOLOGY_LION;
        return POWER_SUPPLY_TECHNOLOGY_NiMH;
}

static int bat_capacity_level(void)
{
        u8 status0 = ec_read_u8(BAT_STATUS0);
        u8 status1 = ec_read_u8(BAT_STATUS1);
        u8 status2 = ec_read_u8(BAT_STATUS2);

        if (status0 & BAT_S0_DISCHRG_CRITICAL
                        || status1 & BAT_S1_EMPTY
                        || status2 & BAT_S2_LOW_LOW)
                return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
        if (status0 & BAT_S0_LOW)
                return POWER_SUPPLY_CAPACITY_LEVEL_LOW;
        if (status1 & BAT_S1_FULL)
                return POWER_SUPPLY_CAPACITY_LEVEL_FULL;
        return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
}

static int bat_get_property(struct power_supply *psy,
                                enum power_supply_property psp,
                                union power_supply_propval *val)
{
        struct compal_data *data = power_supply_get_drvdata(psy);

        switch (psp) {
        case POWER_SUPPLY_PROP_STATUS:
                val->intval = bat_status();
                break;
        case POWER_SUPPLY_PROP_HEALTH:
                val->intval = bat_health();
                break;
        case POWER_SUPPLY_PROP_PRESENT:
                val->intval = bat_is_present();
                break;
        case POWER_SUPPLY_PROP_TECHNOLOGY:
                val->intval = bat_technology();
                break;
        case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: /* THE design voltage... */
                val->intval = ec_read_u16(BAT_VOLTAGE_DESIGN) * 1000;
                break;
        case POWER_SUPPLY_PROP_VOLTAGE_NOW:
                val->intval = ec_read_u16(BAT_VOLTAGE_NOW) * 1000;
                break;
        case POWER_SUPPLY_PROP_CURRENT_NOW:
                val->intval = ec_read_s16(BAT_CURRENT_NOW) * 1000;
                break;
        case POWER_SUPPLY_PROP_CURRENT_AVG:
                val->intval = ec_read_s16(BAT_CURRENT_AVG) * 1000;
                break;
        case POWER_SUPPLY_PROP_POWER_NOW:
                val->intval = ec_read_u8(BAT_POWER) * 1000000;
                break;
        case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
                val->intval = ec_read_u16(BAT_CHARGE_DESIGN) * 1000;
                break;
        case POWER_SUPPLY_PROP_CHARGE_NOW:
                val->intval = ec_read_u16(BAT_CHARGE_NOW) * 1000;
                break;
        case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
                val->intval = ec_read_u8(BAT_CHARGE_LIMIT);
                break;
        case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX:
                val->intval = BAT_CHARGE_LIMIT_MAX;
                break;
        case POWER_SUPPLY_PROP_CAPACITY:
                val->intval = ec_read_u8(BAT_CAPACITY);
                break;
        case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
                val->intval = bat_capacity_level();
                break;
        /* It smees that BAT_TEMP_AVG is a (2's complement?) value showing
         * the number of degrees, whereas BAT_TEMP is somewhat more
         * complicated. It looks like this is a negative nember with a
         * 100/256 divider and an offset of 222. Both were determined
         * experimentally by comparing BAT_TEMP and BAT_TEMP_AVG. */
        case POWER_SUPPLY_PROP_TEMP:
                val->intval = ((222 - (int)ec_read_u8(BAT_TEMP)) * 1000) >> 8;
                break;
        case POWER_SUPPLY_PROP_TEMP_AMBIENT: /* Ambient, Avg, ... same thing */
                val->intval = ec_read_s8(BAT_TEMP_AVG) * 10;
                break;
        /* Neither the model name nor manufacturer name work for me. */
        case POWER_SUPPLY_PROP_MODEL_NAME:
                val->strval = data->bat_model_name;
                break;
        case POWER_SUPPLY_PROP_MANUFACTURER:
                val->strval = data->bat_manufacturer_name;
                break;
        case POWER_SUPPLY_PROP_SERIAL_NUMBER:
                val->strval = data->bat_serial_number;
                break;
        default:
                break;
        }
        return 0;
}

static int bat_set_property(struct power_supply *psy,
                                enum power_supply_property psp,
                                const union power_supply_propval *val)
{
        int level;

        switch (psp) {
        case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
                level = val->intval;
                if (level < 0 || level > BAT_CHARGE_LIMIT_MAX)
                        return -EINVAL;
                if (ec_write(BAT_CHARGE_LIMIT, level) < 0)
                        return -EIO;
                break;
        default:
                break;
        }
        return 0;
}

static int bat_writeable_property(struct power_supply *psy,
                                enum power_supply_property psp)
{
        switch (psp) {
        case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
                return 1;
        default:
                return 0;
        }
}




/* ============== */
/* Driver Globals */
/* ============== */
static DEVICE_ATTR(wake_up_pme,
                0644, wake_up_pme_show,         wake_up_pme_store);
static DEVICE_ATTR(wake_up_modem,
                0644, wake_up_modem_show,       wake_up_modem_store);
static DEVICE_ATTR(wake_up_lan,
                0644, wake_up_lan_show, wake_up_lan_store);
static DEVICE_ATTR(wake_up_wlan,
                0644, wake_up_wlan_show,        wake_up_wlan_store);
static DEVICE_ATTR(wake_up_key,
                0644, wake_up_key_show, wake_up_key_store);
static DEVICE_ATTR(wake_up_mouse,
                0644, wake_up_mouse_show,       wake_up_mouse_store);

static DEVICE_ATTR(fan1_input,  S_IRUGO, fan_show,          NULL);
static DEVICE_ATTR(temp1_input, S_IRUGO, temp_cpu,          NULL);
static DEVICE_ATTR(temp2_input, S_IRUGO, temp_cpu_local,    NULL);
static DEVICE_ATTR(temp3_input, S_IRUGO, temp_cpu_DTS,      NULL);
static DEVICE_ATTR(temp4_input, S_IRUGO, temp_northbridge,  NULL);
static DEVICE_ATTR(temp5_input, S_IRUGO, temp_vga,          NULL);
static DEVICE_ATTR(temp6_input, S_IRUGO, temp_SKIN,         NULL);
static DEVICE_ATTR(temp1_label, S_IRUGO, label_cpu,         NULL);
static DEVICE_ATTR(temp2_label, S_IRUGO, label_cpu_local,   NULL);
static DEVICE_ATTR(temp3_label, S_IRUGO, label_cpu_DTS,     NULL);
static DEVICE_ATTR(temp4_label, S_IRUGO, label_northbridge, NULL);
static DEVICE_ATTR(temp5_label, S_IRUGO, label_vga,         NULL);
static DEVICE_ATTR(temp6_label, S_IRUGO, label_SKIN,        NULL);
static DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, pwm_show, pwm_store);
static DEVICE_ATTR(pwm1_enable,
                   S_IRUGO | S_IWUSR, pwm_enable_show, pwm_enable_store);

static struct attribute *compal_platform_attrs[] = {
        &dev_attr_wake_up_pme.attr,
        &dev_attr_wake_up_modem.attr,
        &dev_attr_wake_up_lan.attr,
        &dev_attr_wake_up_wlan.attr,
        &dev_attr_wake_up_key.attr,
        &dev_attr_wake_up_mouse.attr,
        NULL
};
static const struct attribute_group compal_platform_attr_group = {
        .attrs = compal_platform_attrs
};

static struct attribute *compal_hwmon_attrs[] = {
        &dev_attr_pwm1_enable.attr,
        &dev_attr_pwm1.attr,
        &dev_attr_fan1_input.attr,
        &dev_attr_temp1_input.attr,
        &dev_attr_temp2_input.attr,
        &dev_attr_temp3_input.attr,
        &dev_attr_temp4_input.attr,
        &dev_attr_temp5_input.attr,
        &dev_attr_temp6_input.attr,
        &dev_attr_temp1_label.attr,
        &dev_attr_temp2_label.attr,
        &dev_attr_temp3_label.attr,
        &dev_attr_temp4_label.attr,
        &dev_attr_temp5_label.attr,
        &dev_attr_temp6_label.attr,
        NULL
};
ATTRIBUTE_GROUPS(compal_hwmon);

static int compal_probe(struct platform_device *);
static int compal_remove(struct platform_device *);
static struct platform_driver compal_driver = {
        .driver = {
                .name = DRIVER_NAME,
        },
        .probe  = compal_probe,
        .remove = compal_remove,
};

static enum power_supply_property compal_bat_properties[] = {
        POWER_SUPPLY_PROP_STATUS,
        POWER_SUPPLY_PROP_HEALTH,
        POWER_SUPPLY_PROP_PRESENT,
        POWER_SUPPLY_PROP_TECHNOLOGY,
        POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
        POWER_SUPPLY_PROP_VOLTAGE_NOW,
        POWER_SUPPLY_PROP_CURRENT_NOW,
        POWER_SUPPLY_PROP_CURRENT_AVG,
        POWER_SUPPLY_PROP_POWER_NOW,
        POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
        POWER_SUPPLY_PROP_CHARGE_NOW,
        POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT,
        POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX,
        POWER_SUPPLY_PROP_CAPACITY,
        POWER_SUPPLY_PROP_CAPACITY_LEVEL,
        POWER_SUPPLY_PROP_TEMP,
        POWER_SUPPLY_PROP_TEMP_AMBIENT,
        POWER_SUPPLY_PROP_MODEL_NAME,
        POWER_SUPPLY_PROP_MANUFACTURER,
        POWER_SUPPLY_PROP_SERIAL_NUMBER,
};

static struct backlight_device *compalbl_device;

static struct platform_device *compal_device;

static struct rfkill *wifi_rfkill;
static struct rfkill *bt_rfkill;





/* =================================== */
/* Initialization & clean-up functions */
/* =================================== */

static int dmi_check_cb(const struct dmi_system_id *id)
{
        pr_info("Identified laptop model '%s'\n", id->ident);
        extra_features = false;
        return 1;
}

static int dmi_check_cb_extra(const struct dmi_system_id *id)
{
        pr_info("Identified laptop model '%s', enabling extra features\n",
                id->ident);
        extra_features = true;
        return 1;
}

static const struct dmi_system_id compal_dmi_table[] __initconst = {
        {
                .ident = "FL90/IFL90",
                .matches = {
                        DMI_MATCH(DMI_BOARD_NAME, "IFL90"),
                        DMI_MATCH(DMI_BOARD_VERSION, "IFT00"),
                },
                .callback = dmi_check_cb
        },
        {
                .ident = "FL90/IFL90",
                .matches = {
                        DMI_MATCH(DMI_BOARD_NAME, "IFL90"),
                        DMI_MATCH(DMI_BOARD_VERSION, "REFERENCE"),
                },
                .callback = dmi_check_cb
        },
        {
                .ident = "FL91/IFL91",
                .matches = {
                        DMI_MATCH(DMI_BOARD_NAME, "IFL91"),
                        DMI_MATCH(DMI_BOARD_VERSION, "IFT00"),
                },
                .callback = dmi_check_cb
        },
        {
                .ident = "FL92/JFL92",
                .matches = {
                        DMI_MATCH(DMI_BOARD_NAME, "JFL92"),
                        DMI_MATCH(DMI_BOARD_VERSION, "IFT00"),
                },
                .callback = dmi_check_cb
        },
        {
                .ident = "FT00/IFT00",
                .matches = {
                        DMI_MATCH(DMI_BOARD_NAME, "IFT00"),
                        DMI_MATCH(DMI_BOARD_VERSION, "IFT00"),
                },
                .callback = dmi_check_cb
        },
        {
                .ident = "Dell Mini 9",
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 910"),
                },
                .callback = dmi_check_cb
        },
        {
                .ident = "Dell Mini 10",
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1010"),
                },
                .callback = dmi_check_cb
        },
        {
                .ident = "Dell Mini 10v",
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1011"),
                },
                .callback = dmi_check_cb
        },
        {
                .ident = "Dell Mini 1012",
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1012"),
                },
                .callback = dmi_check_cb
        },
        {
                .ident = "Dell Inspiron 11z",
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1110"),
                },
                .callback = dmi_check_cb
        },
        {
                .ident = "Dell Mini 12",
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1210"),
                },
                .callback = dmi_check_cb
        },
        {
                .ident = "JHL90",
                .matches = {
                        DMI_MATCH(DMI_BOARD_NAME, "JHL90"),
                        DMI_MATCH(DMI_BOARD_VERSION, "REFERENCE"),
                },
                .callback = dmi_check_cb_extra
        },
        {
                .ident = "KHLB2",
                .matches = {
                        DMI_MATCH(DMI_BOARD_NAME, "KHLB2"),
                        DMI_MATCH(DMI_BOARD_VERSION, "REFERENCE"),
                },
                .callback = dmi_check_cb_extra
        },
        { }
};
MODULE_DEVICE_TABLE(dmi, compal_dmi_table);

static const struct power_supply_desc psy_bat_desc = {
        .name           = DRIVER_NAME,
        .type           = POWER_SUPPLY_TYPE_BATTERY,
        .properties     = compal_bat_properties,
        .num_properties = ARRAY_SIZE(compal_bat_properties),
        .get_property   = bat_get_property,
        .set_property   = bat_set_property,
        .property_is_writeable = bat_writeable_property,
};

static void initialize_power_supply_data(struct compal_data *data)
{
        ec_read_sequence(BAT_MANUFACTURER_NAME_ADDR,
                                        data->bat_manufacturer_name,
                                        BAT_MANUFACTURER_NAME_LEN);
        data->bat_manufacturer_name[BAT_MANUFACTURER_NAME_LEN] = 0;

        ec_read_sequence(BAT_MODEL_NAME_ADDR,
                                        data->bat_model_name,
                                        BAT_MODEL_NAME_LEN);
        data->bat_model_name[BAT_MODEL_NAME_LEN] = 0;

        scnprintf(data->bat_serial_number, BAT_SERIAL_NUMBER_LEN + 1, "%d",
                                ec_read_u16(BAT_SERIAL_NUMBER_ADDR));
}

static void initialize_fan_control_data(struct compal_data *data)
{
        data->pwm_enable = 2; /* Keep motherboard in control for now */
        data->curr_pwm = 255; /* Try not to cause a CPU_on_fire exception
                                 if we take over... */
}

static int setup_rfkill(void)
{
        int ret;

        wifi_rfkill = rfkill_alloc("compal-wifi", &compal_device->dev,
                                RFKILL_TYPE_WLAN, &compal_rfkill_ops,
                                (void *) WIRELESS_WLAN);
        if (!wifi_rfkill)
                return -ENOMEM;

        ret = rfkill_register(wifi_rfkill);
        if (ret)
                goto err_wifi;

        bt_rfkill = rfkill_alloc("compal-bluetooth", &compal_device->dev,
                                RFKILL_TYPE_BLUETOOTH, &compal_rfkill_ops,
                                (void *) WIRELESS_BT);
        if (!bt_rfkill) {
                ret = -ENOMEM;
                goto err_allocate_bt;
        }
        ret = rfkill_register(bt_rfkill);
        if (ret)
                goto err_register_bt;

        return 0;

err_register_bt:
        rfkill_destroy(bt_rfkill);

err_allocate_bt:
        rfkill_unregister(wifi_rfkill);

err_wifi:
        rfkill_destroy(wifi_rfkill);

        return ret;
}

static int __init compal_init(void)
{
        int ret;

        if (acpi_disabled) {
                pr_err("ACPI needs to be enabled for this driver to work!\n");
                return -ENODEV;
        }

        if (!force && !dmi_check_system(compal_dmi_table)) {
                pr_err("Motherboard not recognized (You could try the module's force-parameter)\n");
                return -ENODEV;
        }

        if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
                struct backlight_properties props;
                memset(&props, 0, sizeof(struct backlight_properties));
                props.type = BACKLIGHT_PLATFORM;
                props.max_brightness = BACKLIGHT_LEVEL_MAX;
                compalbl_device = backlight_device_register(DRIVER_NAME,
                                                            NULL, NULL,
                                                            &compalbl_ops,
                                                            &props);
                if (IS_ERR(compalbl_device))
                        return PTR_ERR(compalbl_device);
        }

        ret = platform_driver_register(&compal_driver);
        if (ret)
                goto err_backlight;

        compal_device = platform_device_alloc(DRIVER_NAME, -1);
        if (!compal_device) {
                ret = -ENOMEM;
                goto err_platform_driver;
        }

        ret = platform_device_add(compal_device); /* This calls compal_probe */
        if (ret)
                goto err_platform_device;

        ret = setup_rfkill();
        if (ret)
                goto err_rfkill;

        pr_info("Driver " DRIVER_VERSION " successfully loaded\n");
        return 0;

err_rfkill:
        platform_device_del(compal_device);

err_platform_device:
        platform_device_put(compal_device);

err_platform_driver:
        platform_driver_unregister(&compal_driver);

err_backlight:
        backlight_device_unregister(compalbl_device);

        return ret;
}

static int compal_probe(struct platform_device *pdev)
{
        int err;
        struct compal_data *data;
        struct device *hwmon_dev;
        struct power_supply_config psy_cfg = {};

        if (!extra_features)
                return 0;

        /* Fan control */
        data = devm_kzalloc(&pdev->dev, sizeof(struct compal_data), GFP_KERNEL);
        if (!data)
                return -ENOMEM;

        initialize_fan_control_data(data);

        err = sysfs_create_group(&pdev->dev.kobj, &compal_platform_attr_group);
        if (err)
                return err;

        hwmon_dev = devm_hwmon_device_register_with_groups(&pdev->dev,
                                                           "compal", data,
                                                           compal_hwmon_groups);
        if (IS_ERR(hwmon_dev)) {
                err = PTR_ERR(hwmon_dev);
                goto remove;
        }

        /* Power supply */
        initialize_power_supply_data(data);
        psy_cfg.drv_data = data;
        data->psy = power_supply_register(&compal_device->dev, &psy_bat_desc,
                                          &psy_cfg);
        if (IS_ERR(data->psy)) {
                err = PTR_ERR(data->psy);
                goto remove;
        }

        platform_set_drvdata(pdev, data);

        return 0;

remove:
        sysfs_remove_group(&pdev->dev.kobj, &compal_platform_attr_group);
        return err;
}

static void __exit compal_cleanup(void)
{
        platform_device_unregister(compal_device);
        platform_driver_unregister(&compal_driver);
        backlight_device_unregister(compalbl_device);
        rfkill_unregister(wifi_rfkill);
        rfkill_unregister(bt_rfkill);
        rfkill_destroy(wifi_rfkill);
        rfkill_destroy(bt_rfkill);

        pr_info("Driver unloaded\n");
}

static int compal_remove(struct platform_device *pdev)
{
        struct compal_data *data;

        if (!extra_features)
                return 0;

        pr_info("Unloading: resetting fan control to motherboard\n");
        pwm_disable_control();

        data = platform_get_drvdata(pdev);
        power_supply_unregister(data->psy);

        sysfs_remove_group(&pdev->dev.kobj, &compal_platform_attr_group);

        return 0;
}


module_init(compal_init);
module_exit(compal_cleanup);

MODULE_AUTHOR("Cezary Jackiewicz");
MODULE_AUTHOR("Roald Frederickx (roald.frederickx@gmail.com)");
MODULE_DESCRIPTION("Compal Laptop Support");
MODULE_VERSION(DRIVER_VERSION);
MODULE_LICENSE("GPL");