drivers/platform/x86/compal-laptop.c

   1 /*-*-linux-c-*-*/
   2
   3 /*
   4   Copyright (C) 2008 Cezary Jackiewicz <cezary.jackiewicz (at) gmail.com>
   5
   6   based on MSI driver
   7
   8   Copyright (C) 2006 Lennart Poettering <mzxreary (at) 0pointer (dot) de>
   9
  10   This program is free software; you can redistribute it and/or modify
  11   it under the terms of the GNU General Public License as published by
  12   the Free Software Foundation; either version 2 of the License, or
  13   (at your option) any later version.
  14
  15   This program is distributed in the hope that it will be useful, but
  16   WITHOUT ANY WARRANTY; without even the implied warranty of
  17   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18   General Public License for more details.
  19
  20   You should have received a copy of the GNU General Public License
  21   along with this program; if not, write to the Free Software
  22   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  23   02110-1301, USA.
  24  */
  25
  26 /*
  27  * compal-laptop.c - Compal laptop support.
  28  *
  29  * This driver exports a few files in /sys/devices/platform/compal-laptop/:
  30  *   wake_up_XXX   Whether or not we listen to such wake up events (rw)
  31  *
  32  * In addition to these platform device attributes the driver
  33  * registers itself in the Linux backlight control, power_supply, rfkill
  34  * and hwmon subsystem and is available to userspace under:
  35  *
  36  *   /sys/class/backlight/compal-laptop/
  37  *   /sys/class/power_supply/compal-laptop/
  38  *   /sys/class/rfkill/rfkillX/
  39  *   /sys/class/hwmon/hwmonX/
  40  *
  41  * Notes on the power_supply battery interface:
  42  *   - the "minimum" design voltage is *the* design voltage
  43  *   - the ambient temperature is the average battery temperature
  44  *     and the value is an educated guess (see commented code below)
  45  *
  46  *
  47  * This driver might work on other laptops produced by Compal. If you
  48  * want to try it you can pass force=1 as argument to the module which
  49  * will force it to load even when the DMI data doesn't identify the
  50  * laptop as compatible.
  51  *
  52  * Lots of data available at:
  53  * http://service1.marasst.com/Compal/JHL90_91/Service%20Manual/
  54  * JHL90%20service%20manual-Final-0725.pdf
  55  *
  56  *
  57  *
  58  * Support for the Compal JHL90 added by Roald Frederickx
  59  * (roald.frederickx@gmail.com):
  60  * Driver got large revision. Added functionalities: backlight
  61  * power, wake_on_XXX, a hwmon and power_supply interface.
  62  *
  63  * In case this gets merged into the kernel source: I want to dedicate this
  64  * to Kasper Meerts, the awesome guy who showed me Linux and C!
  65  */
  66
  67 /* NOTE: currently the wake_on_XXX, hwmon and power_supply interfaces are
  68  * only enabled on a JHL90 board until it is verified that they work on the
  69  * other boards too.  See the extra_features variable. */
  70
  71 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  72
  73 #include <linux/module.h>
  74 #include <linux/kernel.h>
  75 #include <linux/init.h>
  76 #include <linux/acpi.h>
  77 #include <linux/dmi.h>
  78 #include <linux/backlight.h>
  79 #include <linux/platform_device.h>
  80 #include <linux/rfkill.h>
  81 #include <linux/hwmon.h>
  82 #include <linux/hwmon-sysfs.h>
  83 #include <linux/power_supply.h>
  84 #include <linux/fb.h>
  85
  86
  87 /* ======= */
  88 /* Defines */
  89 /* ======= */
  90 #define DRIVER_NAME "compal-laptop"
  91 #define DRIVER_VERSION  "0.2.7"
  92
  93 #define BACKLIGHT_LEVEL_ADDR            0xB9
  94 #define BACKLIGHT_LEVEL_MAX             7
  95 #define BACKLIGHT_STATE_ADDR            0x59
  96 #define BACKLIGHT_STATE_ON_DATA         0xE1
  97 #define BACKLIGHT_STATE_OFF_DATA        0xE2
  98
  99 #define WAKE_UP_ADDR                    0xA4
 100 #define WAKE_UP_PME                     (1 << 0)
 101 #define WAKE_UP_MODEM                   (1 << 1)
 102 #define WAKE_UP_LAN                     (1 << 2)
 103 #define WAKE_UP_WLAN                    (1 << 4)
 104 #define WAKE_UP_KEY                     (1 << 6)
 105 #define WAKE_UP_MOUSE                   (1 << 7)
 106
 107 #define WIRELESS_ADDR                   0xBB
 108 #define WIRELESS_WLAN                   (1 << 0)
 109 #define WIRELESS_BT                     (1 << 1)
 110 #define WIRELESS_WLAN_EXISTS            (1 << 2)
 111 #define WIRELESS_BT_EXISTS              (1 << 3)
 112 #define WIRELESS_KILLSWITCH             (1 << 4)
 113
 114 #define PWM_ADDRESS                     0x46
 115 #define PWM_DISABLE_ADDR                0x59
 116 #define PWM_DISABLE_DATA                0xA5
 117 #define PWM_ENABLE_ADDR                 0x59
 118 #define PWM_ENABLE_DATA                 0xA8
 119
 120 #define FAN_ADDRESS                     0x46
 121 #define FAN_DATA                        0x81
 122 #define FAN_FULL_ON_CMD                 0x59 /* Doesn't seem to work. Just */
 123 #define FAN_FULL_ON_ENABLE              0x76 /* force the pwm signal to its */
 124 #define FAN_FULL_ON_DISABLE             0x77 /* maximum value instead */
 125
 126 #define TEMP_CPU                        0xB0
 127 #define TEMP_CPU_LOCAL                  0xB1
 128 #define TEMP_CPU_DTS                    0xB5
 129 #define TEMP_NORTHBRIDGE                0xB6
 130 #define TEMP_VGA                        0xB4
 131 #define TEMP_SKIN                       0xB2
 132
 133 #define BAT_MANUFACTURER_NAME_ADDR      0x10
 134 #define BAT_MANUFACTURER_NAME_LEN       9
 135 #define BAT_MODEL_NAME_ADDR             0x19
 136 #define BAT_MODEL_NAME_LEN              6
 137 #define BAT_SERIAL_NUMBER_ADDR          0xC4
 138 #define BAT_SERIAL_NUMBER_LEN           5
 139 #define BAT_CHARGE_NOW                  0xC2
 140 #define BAT_CHARGE_DESIGN               0xCA
 141 #define BAT_VOLTAGE_NOW                 0xC6
 142 #define BAT_VOLTAGE_DESIGN              0xC8
 143 #define BAT_CURRENT_NOW                 0xD0
 144 #define BAT_CURRENT_AVG                 0xD2
 145 #define BAT_POWER                       0xD4
 146 #define BAT_CAPACITY                    0xCE
 147 #define BAT_TEMP                        0xD6
 148 #define BAT_TEMP_AVG                    0xD7
 149 #define BAT_STATUS0                     0xC1
 150 #define BAT_STATUS1                     0xF0
 151 #define BAT_STATUS2                     0xF1
 152 #define BAT_STOP_CHARGE1                0xF2
 153 #define BAT_STOP_CHARGE2                0xF3
 154
 155 #define BAT_S0_DISCHARGE                (1 << 0)
 156 #define BAT_S0_DISCHRG_CRITICAL         (1 << 2)
 157 #define BAT_S0_LOW                      (1 << 3)
 158 #define BAT_S0_CHARGING                 (1 << 1)
 159 #define BAT_S0_AC                       (1 << 7)
 160 #define BAT_S1_EXISTS                   (1 << 0)
 161 #define BAT_S1_FULL                     (1 << 1)
 162 #define BAT_S1_EMPTY                    (1 << 2)
 163 #define BAT_S1_LiION_OR_NiMH            (1 << 7)
 164 #define BAT_S2_LOW_LOW                  (1 << 0)
 165 #define BAT_STOP_CHRG1_BAD_CELL         (1 << 1)
 166 #define BAT_STOP_CHRG1_COMM_FAIL        (1 << 2)
 167 #define BAT_STOP_CHRG1_OVERVOLTAGE      (1 << 6)
 168 #define BAT_STOP_CHRG1_OVERTEMPERATURE  (1 << 7)
 169
 170
 171 /* ======= */
 172 /* Structs */
 173 /* ======= */
 174 struct compal_data{
 175         /* Fan control */
 176         int pwm_enable; /* 0:full on, 1:set by pwm1, 2:control by motherboard */
 177         unsigned char curr_pwm;
 178
 179         /* Power supply */
 180         struct power_supply psy;
 181         struct power_supply_info psy_info;
 182         char bat_model_name[BAT_MODEL_NAME_LEN + 1];
 183         char bat_manufacturer_name[BAT_MANUFACTURER_NAME_LEN + 1];
 184         char bat_serial_number[BAT_SERIAL_NUMBER_LEN + 1];
 185 };
 186
 187
 188 /* =============== */
 189 /* General globals */
 190 /* =============== */
 191 static bool force;
 192 module_param(force, bool, 0);
 193 MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");
 194
 195 /* Support for the wake_on_XXX, hwmon and power_supply interface. Currently
 196  * only gets enabled on a JHL90 board. Might work with the others too */
 197 static bool extra_features;
 198
 199 /* Nasty stuff. For some reason the fan control is very un-linear.  I've
 200  * come up with these values by looping through the possible inputs and
 201  * watching the output of address 0x4F (do an ec_transaction writing 0x33
 202  * into 0x4F and read a few bytes from the output, like so:
 203  *      u8 writeData = 0x33;
 204  *      ec_transaction(0x4F, &writeData, 1, buffer, 32);
 205  * That address is labeled "fan1 table information" in the service manual.
 206  * It should be clear which value in 'buffer' changes). This seems to be
 207  * related to fan speed. It isn't a proper 'realtime' fan speed value
 208  * though, because physically stopping or speeding up the fan doesn't
 209  * change it. It might be the average voltage or current of the pwm output.
 210  * Nevertheless, it is more fine-grained than the actual RPM reading */
 211 static const unsigned char pwm_lookup_table[256] = {
 212         0, 0, 0, 1, 1, 1, 2, 253, 254, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6,
 213         7, 7, 7, 8, 86, 86, 9, 9, 9, 10, 10, 10, 11, 92, 92, 12, 12, 95,
 214         13, 66, 66, 14, 14, 98, 15, 15, 15, 16, 16, 67, 17, 17, 72, 18, 70,
 215         75, 19, 90, 90, 73, 73, 73, 21, 21, 91, 91, 91, 96, 23, 94, 94, 94,
 216         94, 94, 94, 94, 94, 94, 94, 141, 141, 238, 223, 192, 139, 139, 139,
 217         139, 139, 142, 142, 142, 142, 142, 78, 78, 78, 78, 78, 76, 76, 76,
 218         76, 76, 79, 79, 79, 79, 79, 79, 79, 20, 20, 20, 20, 20, 22, 22, 22,
 219         22, 22, 24, 24, 24, 24, 24, 24, 219, 219, 219, 219, 219, 219, 219,
 220         219, 27, 27, 188, 188, 28, 28, 28, 29, 186, 186, 186, 186, 186,
 221         186, 186, 186, 186, 186, 31, 31, 31, 31, 31, 32, 32, 32, 41, 33,
 222         33, 33, 33, 33, 252, 252, 34, 34, 34, 43, 35, 35, 35, 36, 36, 38,
 223         206, 206, 206, 206, 206, 206, 206, 206, 206, 37, 37, 37, 46, 46,
 224         47, 47, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 48, 48,
 225         48, 48, 48, 40, 40, 40, 49, 42, 42, 42, 42, 42, 42, 42, 42, 44,
 226         189, 189, 189, 189, 54, 54, 45, 45, 45, 45, 45, 45, 45, 45, 251,
 227         191, 199, 199, 199, 199, 199, 215, 215, 215, 215, 187, 187, 187,
 228         187, 187, 193, 50
 229 };
 230
 231
 232
 233
 234 /* ========================= */
 235 /* Hardware access functions */
 236 /* ========================= */
 237 /* General access */
 238 static u8 ec_read_u8(u8 addr)
 239 {
 240         u8 value;
 241         ec_read(addr, &value);
 242         return value;
 243 }
 244
 245 static s8 ec_read_s8(u8 addr)
 246 {
 247         return (s8)ec_read_u8(addr);
 248 }
 249
 250 static u16 ec_read_u16(u8 addr)
 251 {
 252         int hi, lo;
 253         lo = ec_read_u8(addr);
 254         hi = ec_read_u8(addr + 1);
 255         return (hi << 8) + lo;
 256 }
 257
 258 static s16 ec_read_s16(u8 addr)
 259 {
 260         return (s16) ec_read_u16(addr);
 261 }
 262
 263 static void ec_read_sequence(u8 addr, u8 *buf, int len)
 264 {
 265         int i;
 266         for (i = 0; i < len; i++)
 267                 ec_read(addr + i, buf + i);
 268 }
 269
 270
 271 /* Backlight access */
 272 static int set_backlight_level(int level)
 273 {
 274         if (level < 0 || level > BACKLIGHT_LEVEL_MAX)
 275                 return -EINVAL;
 276
 277         ec_write(BACKLIGHT_LEVEL_ADDR, level);
 278
 279         return 0;
 280 }
 281
 282 static int get_backlight_level(void)
 283 {
 284         return (int) ec_read_u8(BACKLIGHT_LEVEL_ADDR);
 285 }
 286
 287 static void set_backlight_state(bool on)
 288 {
 289         u8 data = on ? BACKLIGHT_STATE_ON_DATA : BACKLIGHT_STATE_OFF_DATA;
 290         ec_transaction(BACKLIGHT_STATE_ADDR, &data, 1, NULL, 0);
 291 }
 292
 293
 294 /* Fan control access */
 295 static void pwm_enable_control(void)
 296 {
 297         unsigned char writeData = PWM_ENABLE_DATA;
 298         ec_transaction(PWM_ENABLE_ADDR, &writeData, 1, NULL, 0);
 299 }
 300
 301 static void pwm_disable_control(void)
 302 {
 303         unsigned char writeData = PWM_DISABLE_DATA;
 304         ec_transaction(PWM_DISABLE_ADDR, &writeData, 1, NULL, 0);
 305 }
 306
 307 static void set_pwm(int pwm)
 308 {
 309         ec_transaction(PWM_ADDRESS, &pwm_lookup_table[pwm], 1, NULL, 0);
 310 }
 311
 312 static int get_fan_rpm(void)
 313 {
 314         u8 value, data = FAN_DATA;
 315         ec_transaction(FAN_ADDRESS, &data, 1, &value, 1);
 316         return 100 * (int)value;
 317 }
 318
 319
 320
 321
 322 /* =================== */
 323 /* Interface functions */
 324 /* =================== */
 325
 326 /* Backlight interface */
 327 static int bl_get_brightness(struct backlight_device *b)
 328 {
 329         return get_backlight_level();
 330 }
 331
 332 static int bl_update_status(struct backlight_device *b)
 333 {
 334         int ret = set_backlight_level(b->props.brightness);
 335         if (ret)
 336                 return ret;
 337
 338         set_backlight_state((b->props.power == FB_BLANK_UNBLANK)
 339                 &&    !(b->props.state & BL_CORE_SUSPENDED)
 340                 &&    !(b->props.state & BL_CORE_FBBLANK));
 341         return 0;
 342 }
 343
 344 static const struct backlight_ops compalbl_ops = {
 345         .get_brightness = bl_get_brightness,
 346         .update_status  = bl_update_status,
 347 };
 348
 349
 350 /* Wireless interface */
 351 static int compal_rfkill_set(void *data, bool blocked)
 352 {
 353         unsigned long radio = (unsigned long) data;
 354         u8 result = ec_read_u8(WIRELESS_ADDR);
 355         u8 value;
 356
 357         if (!blocked)
 358                 value = (u8) (result | radio);
 359         else
 360                 value = (u8) (result & ~radio);
 361         ec_write(WIRELESS_ADDR, value);
 362
 363         return 0;
 364 }
 365
 366 static void compal_rfkill_poll(struct rfkill *rfkill, void *data)
 367 {
 368         u8 result = ec_read_u8(WIRELESS_ADDR);
 369         bool hw_blocked = !(result & WIRELESS_KILLSWITCH);
 370         rfkill_set_hw_state(rfkill, hw_blocked);
 371 }
 372
 373 static const struct rfkill_ops compal_rfkill_ops = {
 374         .poll = compal_rfkill_poll,
 375         .set_block = compal_rfkill_set,
 376 };
 377
 378
 379 /* Wake_up interface */
 380 #define SIMPLE_MASKED_STORE_SHOW(NAME, ADDR, MASK)                      \
 381 static ssize_t NAME##_show(struct device *dev,                          \
 382         struct device_attribute *attr, char *buf)                       \
 383 {                                                                       \
 384         return sprintf(buf, "%d\n", ((ec_read_u8(ADDR) & MASK) != 0));  \
 385 }                                                                       \
 386 static ssize_t NAME##_store(struct device *dev,                         \
 387         struct device_attribute *attr, const char *buf, size_t count)   \
 388 {                                                                       \
 389         int state;                                                      \
 390         u8 old_val = ec_read_u8(ADDR);                                  \
 391         if (sscanf(buf, "%d", &state) != 1 || (state < 0 || state > 1)) \
 392                 return -EINVAL;                                         \
 393         ec_write(ADDR, state ? (old_val | MASK) : (old_val & ~MASK));   \
 394         return count;                                                   \
 395 }
 396
 397 SIMPLE_MASKED_STORE_SHOW(wake_up_pme,   WAKE_UP_ADDR, WAKE_UP_PME)
 398 SIMPLE_MASKED_STORE_SHOW(wake_up_modem, WAKE_UP_ADDR, WAKE_UP_MODEM)
 399 SIMPLE_MASKED_STORE_SHOW(wake_up_lan,   WAKE_UP_ADDR, WAKE_UP_LAN)
 400 SIMPLE_MASKED_STORE_SHOW(wake_up_wlan,  WAKE_UP_ADDR, WAKE_UP_WLAN)
 401 SIMPLE_MASKED_STORE_SHOW(wake_up_key,   WAKE_UP_ADDR, WAKE_UP_KEY)
 402 SIMPLE_MASKED_STORE_SHOW(wake_up_mouse, WAKE_UP_ADDR, WAKE_UP_MOUSE)
 403
 404 /* Fan control interface */
 405 static ssize_t pwm_enable_show(struct device *dev,
 406                 struct device_attribute *attr, char *buf)
 407 {
 408         struct compal_data *data = dev_get_drvdata(dev);
 409         return sprintf(buf, "%d\n", data->pwm_enable);
 410 }
 411
 412 static ssize_t pwm_enable_store(struct device *dev,
 413                 struct device_attribute *attr, const char *buf, size_t count)
 414 {
 415         struct compal_data *data = dev_get_drvdata(dev);
 416         long val;
 417         int err;
 418
 419         err = kstrtol(buf, 10, &val);
 420         if (err)
 421                 return err;
 422         if (val < 0)
 423                 return -EINVAL;
 424
 425         data->pwm_enable = val;
 426
 427         switch (val) {
 428         case 0:  /* Full speed */
 429                 pwm_enable_control();
 430                 set_pwm(255);
 431                 break;
 432         case 1:  /* As set by pwm1 */
 433                 pwm_enable_control();
 434                 set_pwm(data->curr_pwm);
 435                 break;
 436         default: /* Control by motherboard */
 437                 pwm_disable_control();
 438                 break;
 439         }
 440
 441         return count;
 442 }
 443
 444 static ssize_t pwm_show(struct device *dev, struct device_attribute *attr,
 445                 char *buf)
 446 {
 447         struct compal_data *data = dev_get_drvdata(dev);
 448         return sprintf(buf, "%hhu\n", data->curr_pwm);
 449 }
 450
 451 static ssize_t pwm_store(struct device *dev, struct device_attribute *attr,
 452                 const char *buf, size_t count)
 453 {
 454         struct compal_data *data = dev_get_drvdata(dev);
 455         long val;
 456         int err;
 457
 458         err = kstrtol(buf, 10, &val);
 459         if (err)
 460                 return err;
 461         if (val < 0 || val > 255)
 462                 return -EINVAL;
 463
 464         data->curr_pwm = val;
 465
 466         if (data->pwm_enable != 1)
 467                 return count;
 468         set_pwm(val);
 469
 470         return count;
 471 }
 472
 473 static ssize_t fan_show(struct device *dev, struct device_attribute *attr,
 474                 char *buf)
 475 {
 476         return sprintf(buf, "%d\n", get_fan_rpm());
 477 }
 478
 479
 480 /* Temperature interface */
 481 #define TEMPERATURE_SHOW_TEMP_AND_LABEL(POSTFIX, ADDRESS, LABEL)        \
 482 static ssize_t temp_##POSTFIX(struct device *dev,                       \
 483                 struct device_attribute *attr, char *buf)               \
 484 {                                                                       \
 485         return sprintf(buf, "%d\n", 1000 * (int)ec_read_s8(ADDRESS));   \
 486 }                                                                       \
 487 static ssize_t label_##POSTFIX(struct device *dev,                      \
 488                 struct device_attribute *attr, char *buf)               \
 489 {                                                                       \
 490         return sprintf(buf, "%s\n", LABEL);                             \
 491 }
 492
 493 /* Labels as in service guide */
 494 TEMPERATURE_SHOW_TEMP_AND_LABEL(cpu,        TEMP_CPU,        "CPU_TEMP");
 495 TEMPERATURE_SHOW_TEMP_AND_LABEL(cpu_local,  TEMP_CPU_LOCAL,  "CPU_TEMP_LOCAL");
 496 TEMPERATURE_SHOW_TEMP_AND_LABEL(cpu_DTS,    TEMP_CPU_DTS,    "CPU_DTS");
 497 TEMPERATURE_SHOW_TEMP_AND_LABEL(northbridge,TEMP_NORTHBRIDGE,"NorthBridge");
 498 TEMPERATURE_SHOW_TEMP_AND_LABEL(vga,        TEMP_VGA,        "VGA_TEMP");
 499 TEMPERATURE_SHOW_TEMP_AND_LABEL(SKIN,       TEMP_SKIN,       "SKIN_TEMP90");
 500
 501
 502 /* Power supply interface */
 503 static int bat_status(void)
 504 {
 505         u8 status0 = ec_read_u8(BAT_STATUS0);
 506         u8 status1 = ec_read_u8(BAT_STATUS1);
 507
 508         if (status0 & BAT_S0_CHARGING)
 509                 return POWER_SUPPLY_STATUS_CHARGING;
 510         if (status0 & BAT_S0_DISCHARGE)
 511                 return POWER_SUPPLY_STATUS_DISCHARGING;
 512         if (status1 & BAT_S1_FULL)
 513                 return POWER_SUPPLY_STATUS_FULL;
 514         return POWER_SUPPLY_STATUS_NOT_CHARGING;
 515 }
 516
 517 static int bat_health(void)
 518 {
 519         u8 status = ec_read_u8(BAT_STOP_CHARGE1);
 520
 521         if (status & BAT_STOP_CHRG1_OVERTEMPERATURE)
 522                 return POWER_SUPPLY_HEALTH_OVERHEAT;
 523         if (status & BAT_STOP_CHRG1_OVERVOLTAGE)
 524                 return POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 525         if (status & BAT_STOP_CHRG1_BAD_CELL)
 526                 return POWER_SUPPLY_HEALTH_DEAD;
 527         if (status & BAT_STOP_CHRG1_COMM_FAIL)
 528                 return POWER_SUPPLY_HEALTH_UNKNOWN;
 529         return POWER_SUPPLY_HEALTH_GOOD;
 530 }
 531
 532 static int bat_is_present(void)
 533 {
 534         u8 status = ec_read_u8(BAT_STATUS2);
 535         return ((status & BAT_S1_EXISTS) != 0);
 536 }
 537
 538 static int bat_technology(void)
 539 {
 540         u8 status = ec_read_u8(BAT_STATUS1);
 541
 542         if (status & BAT_S1_LiION_OR_NiMH)
 543                 return POWER_SUPPLY_TECHNOLOGY_LION;
 544         return POWER_SUPPLY_TECHNOLOGY_NiMH;
 545 }
 546
 547 static int bat_capacity_level(void)
 548 {
 549         u8 status0 = ec_read_u8(BAT_STATUS0);
 550         u8 status1 = ec_read_u8(BAT_STATUS1);
 551         u8 status2 = ec_read_u8(BAT_STATUS2);
 552
 553         if (status0 & BAT_S0_DISCHRG_CRITICAL
 554                         || status1 & BAT_S1_EMPTY
 555                         || status2 & BAT_S2_LOW_LOW)
 556                 return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
 557         if (status0 & BAT_S0_LOW)
 558                 return POWER_SUPPLY_CAPACITY_LEVEL_LOW;
 559         if (status1 & BAT_S1_FULL)
 560                 return POWER_SUPPLY_CAPACITY_LEVEL_FULL;
 561         return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
 562 }
 563
 564 static int bat_get_property(struct power_supply *psy,
 565                                 enum power_supply_property psp,
 566                                 union power_supply_propval *val)
 567 {
 568         struct compal_data *data;
 569         data = container_of(psy, struct compal_data, psy);
 570
 571         switch (psp) {
 572         case POWER_SUPPLY_PROP_STATUS:
 573                 val->intval = bat_status();
 574                 break;
 575         case POWER_SUPPLY_PROP_HEALTH:
 576                 val->intval = bat_health();
 577                 break;
 578         case POWER_SUPPLY_PROP_PRESENT:
 579                 val->intval = bat_is_present();
 580                 break;
 581         case POWER_SUPPLY_PROP_TECHNOLOGY:
 582                 val->intval = bat_technology();
 583                 break;
 584         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: /* THE design voltage... */
 585                 val->intval = ec_read_u16(BAT_VOLTAGE_DESIGN) * 1000;
 586                 break;
 587         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 588                 val->intval = ec_read_u16(BAT_VOLTAGE_NOW) * 1000;
 589                 break;
 590         case POWER_SUPPLY_PROP_CURRENT_NOW:
 591                 val->intval = ec_read_s16(BAT_CURRENT_NOW) * 1000;
 592                 break;
 593         case POWER_SUPPLY_PROP_CURRENT_AVG:
 594                 val->intval = ec_read_s16(BAT_CURRENT_AVG) * 1000;
 595                 break;
 596         case POWER_SUPPLY_PROP_POWER_NOW:
 597                 val->intval = ec_read_u8(BAT_POWER) * 1000000;
 598                 break;
 599         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 600                 val->intval = ec_read_u16(BAT_CHARGE_DESIGN) * 1000;
 601                 break;
 602         case POWER_SUPPLY_PROP_CHARGE_NOW:
 603                 val->intval = ec_read_u16(BAT_CHARGE_NOW) * 1000;
 604                 break;
 605         case POWER_SUPPLY_PROP_CAPACITY:
 606                 val->intval = ec_read_u8(BAT_CAPACITY);
 607                 break;
 608         case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
 609                 val->intval = bat_capacity_level();
 610                 break;
 611         /* It smees that BAT_TEMP_AVG is a (2's complement?) value showing
 612          * the number of degrees, whereas BAT_TEMP is somewhat more
 613          * complicated. It looks like this is a negative nember with a
 614          * 100/256 divider and an offset of 222. Both were determined
 615          * experimentally by comparing BAT_TEMP and BAT_TEMP_AVG. */
 616         case POWER_SUPPLY_PROP_TEMP:
 617                 val->intval = ((222 - (int)ec_read_u8(BAT_TEMP)) * 1000) >> 8;
 618                 break;
 619         case POWER_SUPPLY_PROP_TEMP_AMBIENT: /* Ambient, Avg, ... same thing */
 620                 val->intval = ec_read_s8(BAT_TEMP_AVG) * 10;
 621                 break;
 622         /* Neither the model name nor manufacturer name work for me. */
 623         case POWER_SUPPLY_PROP_MODEL_NAME:
 624                 val->strval = data->bat_model_name;
 625                 break;
 626         case POWER_SUPPLY_PROP_MANUFACTURER:
 627                 val->strval = data->bat_manufacturer_name;
 628                 break;
 629         case POWER_SUPPLY_PROP_SERIAL_NUMBER:
 630                 val->strval = data->bat_serial_number;
 631                 break;
 632         default:
 633                 break;
 634         }
 635         return 0;
 636 }
 637
 638
 639
 640
 641
 642 /* ============== */
 643 /* Driver Globals */
 644 /* ============== */
 645 static DEVICE_ATTR(wake_up_pme,
 646                 0644, wake_up_pme_show,         wake_up_pme_store);
 647 static DEVICE_ATTR(wake_up_modem,
 648                 0644, wake_up_modem_show,       wake_up_modem_store);
 649 static DEVICE_ATTR(wake_up_lan,
 650                 0644, wake_up_lan_show, wake_up_lan_store);
 651 static DEVICE_ATTR(wake_up_wlan,
 652                 0644, wake_up_wlan_show,        wake_up_wlan_store);
 653 static DEVICE_ATTR(wake_up_key,
 654                 0644, wake_up_key_show, wake_up_key_store);
 655 static DEVICE_ATTR(wake_up_mouse,
 656                 0644, wake_up_mouse_show,       wake_up_mouse_store);
 657
 658 static DEVICE_ATTR(fan1_input,  S_IRUGO, fan_show,          NULL);
 659 static DEVICE_ATTR(temp1_input, S_IRUGO, temp_cpu,          NULL);
 660 static DEVICE_ATTR(temp2_input, S_IRUGO, temp_cpu_local,    NULL);
 661 static DEVICE_ATTR(temp3_input, S_IRUGO, temp_cpu_DTS,      NULL);
 662 static DEVICE_ATTR(temp4_input, S_IRUGO, temp_northbridge,  NULL);
 663 static DEVICE_ATTR(temp5_input, S_IRUGO, temp_vga,          NULL);
 664 static DEVICE_ATTR(temp6_input, S_IRUGO, temp_SKIN,         NULL);
 665 static DEVICE_ATTR(temp1_label, S_IRUGO, label_cpu,         NULL);
 666 static DEVICE_ATTR(temp2_label, S_IRUGO, label_cpu_local,   NULL);
 667 static DEVICE_ATTR(temp3_label, S_IRUGO, label_cpu_DTS,     NULL);
 668 static DEVICE_ATTR(temp4_label, S_IRUGO, label_northbridge, NULL);
 669 static DEVICE_ATTR(temp5_label, S_IRUGO, label_vga,         NULL);
 670 static DEVICE_ATTR(temp6_label, S_IRUGO, label_SKIN,        NULL);
 671 static DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, pwm_show, pwm_store);
 672 static DEVICE_ATTR(pwm1_enable,
 673                    S_IRUGO | S_IWUSR, pwm_enable_show, pwm_enable_store);
 674
 675 static struct attribute *compal_platform_attrs[] = {
 676         &dev_attr_wake_up_pme.attr,
 677         &dev_attr_wake_up_modem.attr,
 678         &dev_attr_wake_up_lan.attr,
 679         &dev_attr_wake_up_wlan.attr,
 680         &dev_attr_wake_up_key.attr,
 681         &dev_attr_wake_up_mouse.attr,
 682         NULL
 683 };
 684 static struct attribute_group compal_platform_attr_group = {
 685         .attrs = compal_platform_attrs
 686 };
 687
 688 static struct attribute *compal_hwmon_attrs[] = {
 689         &dev_attr_pwm1_enable.attr,
 690         &dev_attr_pwm1.attr,
 691         &dev_attr_fan1_input.attr,
 692         &dev_attr_temp1_input.attr,
 693         &dev_attr_temp2_input.attr,
 694         &dev_attr_temp3_input.attr,
 695         &dev_attr_temp4_input.attr,
 696         &dev_attr_temp5_input.attr,
 697         &dev_attr_temp6_input.attr,
 698         &dev_attr_temp1_label.attr,
 699         &dev_attr_temp2_label.attr,
 700         &dev_attr_temp3_label.attr,
 701         &dev_attr_temp4_label.attr,
 702         &dev_attr_temp5_label.attr,
 703         &dev_attr_temp6_label.attr,
 704         NULL
 705 };
 706 ATTRIBUTE_GROUPS(compal_hwmon);
 707
 708 static int compal_probe(struct platform_device *);
 709 static int compal_remove(struct platform_device *);
 710 static struct platform_driver compal_driver = {
 711         .driver = {
 712                 .name = DRIVER_NAME,
 713         },
 714         .probe  = compal_probe,
 715         .remove = compal_remove,
 716 };
 717
 718 static enum power_supply_property compal_bat_properties[] = {
 719         POWER_SUPPLY_PROP_STATUS,
 720         POWER_SUPPLY_PROP_HEALTH,
 721         POWER_SUPPLY_PROP_PRESENT,
 722         POWER_SUPPLY_PROP_TECHNOLOGY,
 723         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 724         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 725         POWER_SUPPLY_PROP_CURRENT_NOW,
 726         POWER_SUPPLY_PROP_CURRENT_AVG,
 727         POWER_SUPPLY_PROP_POWER_NOW,
 728         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
 729         POWER_SUPPLY_PROP_CHARGE_NOW,
 730         POWER_SUPPLY_PROP_CAPACITY,
 731         POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 732         POWER_SUPPLY_PROP_TEMP,
 733         POWER_SUPPLY_PROP_TEMP_AMBIENT,
 734         POWER_SUPPLY_PROP_MODEL_NAME,
 735         POWER_SUPPLY_PROP_MANUFACTURER,
 736         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 737 };
 738
 739 static struct backlight_device *compalbl_device;
 740
 741 static struct platform_device *compal_device;
 742
 743 static struct rfkill *wifi_rfkill;
 744 static struct rfkill *bt_rfkill;
 745
 746
 747
 748
 749
 750 /* =================================== */
 751 /* Initialization & clean-up functions */
 752 /* =================================== */
 753
 754 static int dmi_check_cb(const struct dmi_system_id *id)
 755 {
 756         pr_info("Identified laptop model '%s'\n", id->ident);
 757         extra_features = false;
 758         return 1;
 759 }
 760
 761 static int dmi_check_cb_extra(const struct dmi_system_id *id)
 762 {
 763         pr_info("Identified laptop model '%s', enabling extra features\n",
 764                 id->ident);
 765         extra_features = true;
 766         return 1;
 767 }
 768
 769 static struct dmi_system_id __initdata compal_dmi_table[] = {
 770         {
 771                 .ident = "FL90/IFL90",
 772                 .matches = {
 773                         DMI_MATCH(DMI_BOARD_NAME, "IFL90"),
 774                         DMI_MATCH(DMI_BOARD_VERSION, "IFT00"),
 775                 },
 776                 .callback = dmi_check_cb
 777         },
 778         {
 779                 .ident = "FL90/IFL90",
 780                 .matches = {
 781                         DMI_MATCH(DMI_BOARD_NAME, "IFL90"),
 782                         DMI_MATCH(DMI_BOARD_VERSION, "REFERENCE"),
 783                 },
 784                 .callback = dmi_check_cb
 785         },
 786         {
 787                 .ident = "FL91/IFL91",
 788                 .matches = {
 789                         DMI_MATCH(DMI_BOARD_NAME, "IFL91"),
 790                         DMI_MATCH(DMI_BOARD_VERSION, "IFT00"),
 791                 },
 792                 .callback = dmi_check_cb
 793         },
 794         {
 795                 .ident = "FL92/JFL92",
 796                 .matches = {
 797                         DMI_MATCH(DMI_BOARD_NAME, "JFL92"),
 798                         DMI_MATCH(DMI_BOARD_VERSION, "IFT00"),
 799                 },
 800                 .callback = dmi_check_cb
 801         },
 802         {
 803                 .ident = "FT00/IFT00",
 804                 .matches = {
 805                         DMI_MATCH(DMI_BOARD_NAME, "IFT00"),
 806                         DMI_MATCH(DMI_BOARD_VERSION, "IFT00"),
 807                 },
 808                 .callback = dmi_check_cb
 809         },
 810         {
 811                 .ident = "Dell Mini 9",
 812                 .matches = {
 813                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 814                         DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 910"),
 815                 },
 816                 .callback = dmi_check_cb
 817         },
 818         {
 819                 .ident = "Dell Mini 10",
 820                 .matches = {
 821                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 822                         DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1010"),
 823                 },
 824                 .callback = dmi_check_cb
 825         },
 826         {
 827                 .ident = "Dell Mini 10v",
 828                 .matches = {
 829                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 830                         DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1011"),
 831                 },
 832                 .callback = dmi_check_cb
 833         },
 834         {
 835                 .ident = "Dell Mini 1012",
 836                 .matches = {
 837                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 838                         DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1012"),
 839                 },
 840                 .callback = dmi_check_cb
 841         },
 842         {
 843                 .ident = "Dell Inspiron 11z",
 844                 .matches = {
 845                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 846                         DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1110"),
 847                 },
 848                 .callback = dmi_check_cb
 849         },
 850         {
 851                 .ident = "Dell Mini 12",
 852                 .matches = {
 853                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 854                         DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1210"),
 855                 },
 856                 .callback = dmi_check_cb
 857         },
 858         {
 859                 .ident = "JHL90",
 860                 .matches = {
 861                         DMI_MATCH(DMI_BOARD_NAME, "JHL90"),
 862                         DMI_MATCH(DMI_BOARD_VERSION, "REFERENCE"),
 863                 },
 864                 .callback = dmi_check_cb_extra
 865         },
 866         {
 867                 .ident = "KHLB2",
 868                 .matches = {
 869                         DMI_MATCH(DMI_BOARD_NAME, "KHLB2"),
 870                         DMI_MATCH(DMI_BOARD_VERSION, "REFERENCE"),
 871                 },
 872                 .callback = dmi_check_cb_extra
 873         },
 874         { }
 875 };
 876 MODULE_DEVICE_TABLE(dmi, compal_dmi_table);
 877
 878 static void initialize_power_supply_data(struct compal_data *data)
 879 {
 880         data->psy.name = DRIVER_NAME;
 881         data->psy.type = POWER_SUPPLY_TYPE_BATTERY;
 882         data->psy.properties = compal_bat_properties;
 883         data->psy.num_properties = ARRAY_SIZE(compal_bat_properties);
 884         data->psy.get_property = bat_get_property;
 885
 886         ec_read_sequence(BAT_MANUFACTURER_NAME_ADDR,
 887                                         data->bat_manufacturer_name,
 888                                         BAT_MANUFACTURER_NAME_LEN);
 889         data->bat_manufacturer_name[BAT_MANUFACTURER_NAME_LEN] = 0;
 890
 891         ec_read_sequence(BAT_MODEL_NAME_ADDR,
 892                                         data->bat_model_name,
 893                                         BAT_MODEL_NAME_LEN);
 894         data->bat_model_name[BAT_MODEL_NAME_LEN] = 0;
 895
 896         scnprintf(data->bat_serial_number, BAT_SERIAL_NUMBER_LEN + 1, "%d",
 897                                 ec_read_u16(BAT_SERIAL_NUMBER_ADDR));
 898 }
 899
 900 static void initialize_fan_control_data(struct compal_data *data)
 901 {
 902         data->pwm_enable = 2; /* Keep motherboard in control for now */
 903         data->curr_pwm = 255; /* Try not to cause a CPU_on_fire exception
 904                                  if we take over... */
 905 }
 906
 907 static int setup_rfkill(void)
 908 {
 909         int ret;
 910
 911         wifi_rfkill = rfkill_alloc("compal-wifi", &compal_device->dev,
 912                                 RFKILL_TYPE_WLAN, &compal_rfkill_ops,
 913                                 (void *) WIRELESS_WLAN);
 914         if (!wifi_rfkill)
 915                 return -ENOMEM;
 916
 917         ret = rfkill_register(wifi_rfkill);
 918         if (ret)
 919                 goto err_wifi;
 920
 921         bt_rfkill = rfkill_alloc("compal-bluetooth", &compal_device->dev,
 922                                 RFKILL_TYPE_BLUETOOTH, &compal_rfkill_ops,
 923                                 (void *) WIRELESS_BT);
 924         if (!bt_rfkill) {
 925                 ret = -ENOMEM;
 926                 goto err_allocate_bt;
 927         }
 928         ret = rfkill_register(bt_rfkill);
 929         if (ret)
 930                 goto err_register_bt;
 931
 932         return 0;
 933
 934 err_register_bt:
 935         rfkill_destroy(bt_rfkill);
 936
 937 err_allocate_bt:
 938         rfkill_unregister(wifi_rfkill);
 939
 940 err_wifi:
 941         rfkill_destroy(wifi_rfkill);
 942
 943         return ret;
 944 }
 945
 946 static int __init compal_init(void)
 947 {
 948         int ret;
 949
 950         if (acpi_disabled) {
 951                 pr_err("ACPI needs to be enabled for this driver to work!\n");
 952                 return -ENODEV;
 953         }
 954
 955         if (!force && !dmi_check_system(compal_dmi_table)) {
 956                 pr_err("Motherboard not recognized (You could try the module's force-parameter)\n");
 957                 return -ENODEV;
 958         }
 959
 960         if (!acpi_video_backlight_support()) {
 961                 struct backlight_properties props;
 962                 memset(&props, 0, sizeof(struct backlight_properties));
 963                 props.type = BACKLIGHT_PLATFORM;
 964                 props.max_brightness = BACKLIGHT_LEVEL_MAX;
 965                 compalbl_device = backlight_device_register(DRIVER_NAME,
 966                                                             NULL, NULL,
 967                                                             &compalbl_ops,
 968                                                             &props);
 969                 if (IS_ERR(compalbl_device))
 970                         return PTR_ERR(compalbl_device);
 971         }
 972
 973         ret = platform_driver_register(&compal_driver);
 974         if (ret)
 975                 goto err_backlight;
 976
 977         compal_device = platform_device_alloc(DRIVER_NAME, -1);
 978         if (!compal_device) {
 979                 ret = -ENOMEM;
 980                 goto err_platform_driver;
 981         }
 982
 983         ret = platform_device_add(compal_device); /* This calls compal_probe */
 984         if (ret)
 985                 goto err_platform_device;
 986
 987         ret = setup_rfkill();
 988         if (ret)
 989                 goto err_rfkill;
 990
 991         pr_info("Driver " DRIVER_VERSION " successfully loaded\n");
 992         return 0;
 993
 994 err_rfkill:
 995         platform_device_del(compal_device);
 996
 997 err_platform_device:
 998         platform_device_put(compal_device);
 999
1000 err_platform_driver:
1001         platform_driver_unregister(&compal_driver);
1002
1003 err_backlight:
1004         backlight_device_unregister(compalbl_device);
1005
1006         return ret;
1007 }
1008
1009 static int compal_probe(struct platform_device *pdev)
1010 {
1011         int err;
1012         struct compal_data *data;
1013         struct device *hwmon_dev;
1014
1015         if (!extra_features)
1016                 return 0;
1017
1018         /* Fan control */
1019         data = devm_kzalloc(&pdev->dev, sizeof(struct compal_data), GFP_KERNEL);
1020         if (!data)
1021                 return -ENOMEM;
1022
1023         initialize_fan_control_data(data);
1024
1025         err = sysfs_create_group(&pdev->dev.kobj, &compal_platform_attr_group);
1026         if (err)
1027                 return err;
1028
1029         hwmon_dev = hwmon_device_register_with_groups(&pdev->dev,
1030                                                       "compal", data,
1031                                                       compal_hwmon_groups);
1032         if (IS_ERR(hwmon_dev)) {
1033                 err = PTR_ERR(hwmon_dev);
1034                 goto remove;
1035         }
1036
1037         /* Power supply */
1038         initialize_power_supply_data(data);
1039         power_supply_register(&compal_device->dev, &data->psy);
1040
1041         platform_set_drvdata(pdev, data);
1042
1043         return 0;
1044
1045 remove:
1046         sysfs_remove_group(&pdev->dev.kobj, &compal_platform_attr_group);
1047         return err;
1048 }
1049
1050 static void __exit compal_cleanup(void)
1051 {
1052         platform_device_unregister(compal_device);
1053         platform_driver_unregister(&compal_driver);
1054         backlight_device_unregister(compalbl_device);
1055         rfkill_unregister(wifi_rfkill);
1056         rfkill_unregister(bt_rfkill);
1057         rfkill_destroy(wifi_rfkill);
1058         rfkill_destroy(bt_rfkill);
1059
1060         pr_info("Driver unloaded\n");
1061 }
1062
1063 static int compal_remove(struct platform_device *pdev)
1064 {
1065         struct compal_data *data;
1066
1067         if (!extra_features)
1068                 return 0;
1069
1070         pr_info("Unloading: resetting fan control to motherboard\n");
1071         pwm_disable_control();
1072
1073         data = platform_get_drvdata(pdev);
1074         power_supply_unregister(&data->psy);
1075
1076         sysfs_remove_group(&pdev->dev.kobj, &compal_platform_attr_group);
1077
1078         return 0;
1079 }
1080
1081
1082 module_init(compal_init);
1083 module_exit(compal_cleanup);
1084
1085 MODULE_AUTHOR("Cezary Jackiewicz");
1086 MODULE_AUTHOR("Roald Frederickx (roald.frederickx@gmail.com)");
1087 MODULE_DESCRIPTION("Compal Laptop Support");
1088 MODULE_VERSION(DRIVER_VERSION);
1089 MODULE_LICENSE("GPL");