14-05-2021

Compal Fl92 Drivers

Compal Fl92 Drivers

This is a driver for laptops built by Compal: Compal FL90/IFL90 Compal FL90/IFL90 Compal FL91/IFL91 Compal FL92/JFL92 Compal FT00/IFT00 Compal JHL90 Compal JHL91 Dell Mini 9 Dell Mini 10 Dell Mini 10v Dell Inspiron 11z Dell Mini 12 It adds support for: - bluetooth, WLAN and lcd brightness control (via backlight control/rfkill) - change battery.

Permalink

Join GitHub today

GitHub is home to over 40 million developers working together to host and review code, manage projects, and build software together.

Sign up

Compal Fl92 Drivers Test

Compal Fl92 Drivers
Find file Copy path
Cannot retrieve contributors at this time
// SPDX-License-Identifier: GPL-2.0-or-later
/*-*-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>
*/
/*
* 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. */
#definepr_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 */
/* */
#defineDRIVER_NAME'compal-laptop'
#defineDRIVER_VERSION'0.2.7'
#defineBACKLIGHT_LEVEL_ADDR0xB9
#defineBACKLIGHT_LEVEL_MAX7
#defineBACKLIGHT_STATE_ADDR0x59
#defineBACKLIGHT_STATE_ON_DATA0xE1
#defineBACKLIGHT_STATE_OFF_DATA0xE2
#defineWAKE_UP_ADDR0xA4
#defineWAKE_UP_PME (1 << 0)
#defineWAKE_UP_MODEM (1 << 1)
#defineWAKE_UP_LAN (1 << 2)
#defineWAKE_UP_WLAN (1 << 4)
#defineWAKE_UP_KEY (1 << 6)
#defineWAKE_UP_MOUSE (1 << 7)
#defineWIRELESS_ADDR0xBB
#defineWIRELESS_WLAN (1 << 0)
#defineWIRELESS_BT (1 << 1)
#defineWIRELESS_WLAN_EXISTS (1 << 2)
#defineWIRELESS_BT_EXISTS (1 << 3)
#defineWIRELESS_KILLSWITCH (1 << 4)
#definePWM_ADDRESS0x46
#definePWM_DISABLE_ADDR0x59
#definePWM_DISABLE_DATA0xA5
#definePWM_ENABLE_ADDR0x59
#definePWM_ENABLE_DATA0xA8
#defineFAN_ADDRESS0x46
#defineFAN_DATA0x81
#defineFAN_FULL_ON_CMD0x59/* Doesn't seem to work. Just */
#defineFAN_FULL_ON_ENABLE0x76/* force the pwm signal to its */
#defineFAN_FULL_ON_DISABLE0x77/* maximum value instead */
#defineTEMP_CPU0xB0
#defineTEMP_CPU_LOCAL0xB1
#defineTEMP_CPU_DTS0xB5
#defineTEMP_NORTHBRIDGE0xB6
#defineTEMP_VGA0xB4
#defineTEMP_SKIN0xB2
#defineBAT_MANUFACTURER_NAME_ADDR0x10
#defineBAT_MANUFACTURER_NAME_LEN9
#defineBAT_MODEL_NAME_ADDR0x19
#defineBAT_MODEL_NAME_LEN6
#defineBAT_SERIAL_NUMBER_ADDR0xC4
#defineBAT_SERIAL_NUMBER_LEN5
#defineBAT_CHARGE_NOW0xC2
#defineBAT_CHARGE_DESIGN0xCA
#defineBAT_VOLTAGE_NOW0xC6
#defineBAT_VOLTAGE_DESIGN0xC8
#defineBAT_CURRENT_NOW0xD0
#defineBAT_CURRENT_AVG0xD2
#defineBAT_POWER0xD4
#defineBAT_CAPACITY0xCE
#defineBAT_TEMP0xD6
#defineBAT_TEMP_AVG0xD7
#defineBAT_STATUS00xC1
#defineBAT_STATUS10xF0
#defineBAT_STATUS20xF1
#defineBAT_STOP_CHARGE10xF2
#defineBAT_STOP_CHARGE20xF3
#defineBAT_CHARGE_LIMIT0x03
#defineBAT_CHARGE_LIMIT_MAX100
#defineBAT_S0_DISCHARGE (1 << 0)
#defineBAT_S0_DISCHRG_CRITICAL (1 << 2)
#defineBAT_S0_LOW (1 << 3)
#defineBAT_S0_CHARGING (1 << 1)
#defineBAT_S0_AC (1 << 7)
#defineBAT_S1_EXISTS (1 << 0)
#defineBAT_S1_FULL (1 << 1)
#defineBAT_S1_EMPTY (1 << 2)
#defineBAT_S1_LiION_OR_NiMH (1 << 7)
#defineBAT_S2_LOW_LOW (1 << 0)
#defineBAT_STOP_CHRG1_BAD_CELL (1 << 1)
#defineBAT_STOP_CHRG1_COMM_FAIL (1 << 2)
#defineBAT_STOP_CHRG1_OVERVOLTAGE (1 << 6)
#defineBAT_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 */
unsignedchar 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 */
/* */
staticbool 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 */
staticbool 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 */
staticconstunsignedchar 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 = 0;
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);
}
staticvoidec_read_sequence(u8 addr, u8 *buf, int len)
{
int i;
for (i = 0; i < len; i++)
ec_read(addr + i, buf + i);
}
/* Backlight access */
staticintset_backlight_level(int level)
{
if (level < 0 || level > BACKLIGHT_LEVEL_MAX)
return -EINVAL;
ec_write(BACKLIGHT_LEVEL_ADDR, level);
return0;
}
staticintget_backlight_level(void)
{
return (int) ec_read_u8(BACKLIGHT_LEVEL_ADDR);
}
staticvoidset_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 */
staticvoidpwm_enable_control(void)
{
unsignedchar writeData = PWM_ENABLE_DATA;
ec_transaction(PWM_ENABLE_ADDR, &writeData, 1, NULL, 0);
}
staticvoidpwm_disable_control(void)
{
unsignedchar writeData = PWM_DISABLE_DATA;
ec_transaction(PWM_DISABLE_ADDR, &writeData, 1, NULL, 0);
}
staticvoidset_pwm(int pwm)
{
ec_transaction(PWM_ADDRESS, &pwm_lookup_table[pwm], 1, NULL, 0);
}
staticintget_fan_rpm(void)
{
u8 value, data = FAN_DATA;
ec_transaction(FAN_ADDRESS, &data, 1, &value, 1);
return100 * (int)value;
}
/* */
/* Interface functions */
/* */
/* Backlight interface */
staticintbl_get_brightness(struct backlight_device *b)
{
returnget_backlight_level();
}
staticintbl_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));
return0;
}
staticconststruct backlight_ops compalbl_ops = {
.get_brightness = bl_get_brightness,
.update_status = bl_update_status,
};
/* Wireless interface */
staticintcompal_rfkill_set(void *data, bool blocked)
{
unsignedlong radio = (unsignedlong) 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);
return0;
}
staticvoidcompal_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);
}
staticconststruct rfkill_ops compal_rfkill_ops = {
.poll = compal_rfkill_poll,
.set_block = compal_rfkill_set,
};
/* Wake_up interface */
#defineSIMPLE_MASKED_STORE_SHOW(NAME, ADDR, MASK)
staticssize_t NAME##_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
returnsprintf(buf, '%dn', ((ec_read_u8(ADDR) & MASK) != 0));
}
staticssize_t NAME##_store(struct device *dev,
struct device_attribute *attr, constchar *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);
returnsprintf(buf, '%dn', data->pwm_enable);
}
staticssize_tpwm_enable_store(struct device *dev,
struct device_attribute *attr, constchar *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) {
case0: /* Full speed */
pwm_enable_control();
set_pwm(255);
break;
case1: /* As set by pwm1 */
pwm_enable_control();
set_pwm(data->curr_pwm);
break;
default: /* Control by motherboard */
pwm_disable_control();
break;
}
return count;
}
staticssize_tpwm_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct compal_data *data = dev_get_drvdata(dev);
returnsprintf(buf, '%hhun', data->curr_pwm);
}
staticssize_tpwm_store(struct device *dev, struct device_attribute *attr,
constchar *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;
}
staticssize_tfan_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
returnsprintf(buf, '%dn', get_fan_rpm());
}
/* Temperature interface */
#defineTEMPERATURE_SHOW_TEMP_AND_LABEL(POSTFIX, ADDRESS, LABEL)
staticssize_t temp_##POSTFIX(struct device *dev,
struct device_attribute *attr, char *buf)
{
returnsprintf(buf, '%dn', 1000 * (int)ec_read_s8(ADDRESS));
}
staticssize_t label_##POSTFIX(struct device *dev,
struct device_attribute *attr, char *buf)
{
returnsprintf(buf, '%sn', 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 */
staticintbat_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;
}
staticintbat_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;
}
staticintbat_is_present(void)
{
u8 status = ec_read_u8(BAT_STATUS2);
return ((status & BAT_S1_EXISTS) != 0);
}
staticintbat_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;
}
staticintbat_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;
}
staticintbat_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;
}
return0;
}
staticintbat_set_property(struct power_supply *psy,
enum power_supply_property psp,
constunion 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;
}
return0;
}
staticintbat_writeable_property(struct power_supply *psy,
enum power_supply_property psp)
{
switch (psp) {
case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
return1;
default:
return0;
}
}
/* */
/* Driver Globals */
/* */
staticDEVICE_ATTR_RW(wake_up_pme);
staticDEVICE_ATTR_RW(wake_up_modem);
staticDEVICE_ATTR_RW(wake_up_lan);
staticDEVICE_ATTR_RW(wake_up_wlan);
staticDEVICE_ATTR_RW(wake_up_key);
staticDEVICE_ATTR_RW(wake_up_mouse);
staticDEVICE_ATTR(fan1_input, S_IRUGO, fan_show, NULL);
staticDEVICE_ATTR(temp1_input, S_IRUGO, temp_cpu, NULL);
staticDEVICE_ATTR(temp2_input, S_IRUGO, temp_cpu_local, NULL);
staticDEVICE_ATTR(temp3_input, S_IRUGO, temp_cpu_DTS, NULL);
staticDEVICE_ATTR(temp4_input, S_IRUGO, temp_northbridge, NULL);
staticDEVICE_ATTR(temp5_input, S_IRUGO, temp_vga, NULL);
staticDEVICE_ATTR(temp6_input, S_IRUGO, temp_SKIN, NULL);
staticDEVICE_ATTR(temp1_label, S_IRUGO, label_cpu, NULL);
staticDEVICE_ATTR(temp2_label, S_IRUGO, label_cpu_local, NULL);
staticDEVICE_ATTR(temp3_label, S_IRUGO, label_cpu_DTS, NULL);
staticDEVICE_ATTR(temp4_label, S_IRUGO, label_northbridge, NULL);
staticDEVICE_ATTR(temp5_label, S_IRUGO, label_vga, NULL);
staticDEVICE_ATTR(temp6_label, S_IRUGO, label_SKIN, NULL);
staticDEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, pwm_show, pwm_store);
staticDEVICE_ATTR(pwm1_enable,
S_IRUGO | S_IWUSR, pwm_enable_show, pwm_enable_store);
staticstruct 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
};
staticconststruct attribute_group compal_platform_attr_group = {
.attrs = compal_platform_attrs
};
staticstruct 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);
staticintcompal_probe(struct platform_device *);
staticintcompal_remove(struct platform_device *);
staticstruct platform_driver compal_driver = {
.driver = {
.name = DRIVER_NAME,
},
.probe = compal_probe,
.remove = compal_remove,
};
staticenum 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,
};
staticstruct backlight_device *compalbl_device;
staticstruct platform_device *compal_device;
staticstruct rfkill *wifi_rfkill;
staticstruct rfkill *bt_rfkill;
/* */
/* Initialization & clean-up functions */
/* */
staticintdmi_check_cb(conststruct dmi_system_id *id)
{
pr_info('Identified laptop model '%s'n', id->ident);
extra_features = false;
return1;
}
staticintdmi_check_cb_extra(conststruct dmi_system_id *id)
{
pr_info('Identified laptop model '%s', enabling extra featuresn',
id->ident);
extra_features = true;
return1;
}
staticconststruct 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);
staticconststruct 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,
};
staticvoidinitialize_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));
}
staticvoidinitialize_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... */
}
staticintsetup_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;
return0;
err_register_bt:
rfkill_destroy(bt_rfkill);
err_allocate_bt:
rfkill_unregister(wifi_rfkill);
err_wifi:
rfkill_destroy(wifi_rfkill);
return ret;
}
staticint __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))
returnPTR_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 loadedn');
return0;
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;
}
staticintcompal_probe(struct platform_device *pdev)
{
int err;
struct compal_data *data;
struct device *hwmon_dev;
struct power_supply_config psy_cfg = {};
if (!extra_features)
return0;
/* 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);
gotoremove;
}
/* 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);
gotoremove;
}
platform_set_drvdata(pdev, data);
return0;
remove:
sysfs_remove_group(&pdev->dev.kobj, &compal_platform_attr_group);
return err;
}
staticvoid __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 unloadedn');
}
staticintcompal_remove(struct platform_device *pdev)
{
struct compal_data *data;
if (!extra_features)
return0;
pr_info('Unloading: resetting fan control to motherboardn');
pwm_disable_control();
data = platform_get_drvdata(pdev);
power_supply_unregister(data->psy);
sysfs_remove_group(&pdev->dev.kobj, &compal_platform_attr_group);
return0;
}
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');
  • Copy lines
  • Copy permalink

Compal Fl92 Drivers Download

Scan performed on 4/26/2017, Computer: HP S5680es - Windows 7 64 bit

Compal Fl91 Drivers

Outdated or Corrupted drivers:7/19

Compal

Device/DriverStatusStatus DescriptionUpdated By Scanner
Motherboards
Intel(R) ICH8-Familie USB universeller Hostcontroller - 2832Up To Date and Functioning
Mice And Touchpads
Microsoft Microsoft USB Compact Optical Mouse (IntelliPoint)Up To Date and Functioning
Synaptics Mouse compatible PS/2Up To Date and Functioning
Synaptics Synaptics PS/2 Port Pointing DeviceCorrupted By Compal Jfl92
Usb Devices
Logitech Logitech Webcam C210Up To Date and Functioning
USB Compliance USB Storage DeviceUp To Date and Functioning
Hewlett-Packard HP Deskjet 3050A J611 series (REST)Up To Date and Functioning
Sound Cards And Media Devices
Intel(R) Intel(R) Display AudioCorrupted By Compal Jfl92
Network Cards
Intel NetzwerkcontrollerUp To Date and Functioning
Keyboards
Microsoft Keyboard Device FilterCorrupted By Compal Jfl92
Hard Disk Controller
ATI ATI PCI IDE Bus Master ControllerCorrupted By Compal Jfl92
Others
Broadcom HP integrated module with Bluetooth wireless technologyCorrupted By Compal Jfl92
Intel Intel(r) AIM External Flat Panel Driver 3Up To Date and Functioning
Cameras, Webcams And Scanners
Importek USB Composite DeviceOutdated
Video Cards
Intel(R) 82945G Express Chipset Family (Microsoft Corporation - WDDM 1.0)Up To Date and Functioning
Input Devices
Sony Sony Programmable I/O Control DeviceOutdated
Port Devices
PROLiNK PROLiNK Diagnostics Device (COM8)Up To Date and Functioning
Monitors
Sony Digital Flat Panel (1024x768)Up To Date and Functioning
Mobile Phones And Portable Devices
Acer NOKIAUp To Date and Functioning