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                 .owner = THIS_MODULE,
 714         },
 715         .probe  = compal_probe,
 716         .remove = compal_remove,
 717 };
 718
 719 static enum power_supply_property compal_bat_properties[] = {
 720         POWER_SUPPLY_PROP_STATUS,
 721         POWER_SUPPLY_PROP_HEALTH,
 722         POWER_SUPPLY_PROP_PRESENT,
 723         POWER_SUPPLY_PROP_TECHNOLOGY,
 724         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 725         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 726         POWER_SUPPLY_PROP_CURRENT_NOW,
 727         POWER_SUPPLY_PROP_CURRENT_AVG,
 728         POWER_SUPPLY_PROP_POWER_NOW,
 729         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
 730         POWER_SUPPLY_PROP_CHARGE_NOW,
 731         POWER_SUPPLY_PROP_CAPACITY,
 732         POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 733         POWER_SUPPLY_PROP_TEMP,
 734         POWER_SUPPLY_PROP_TEMP_AMBIENT,
 735         POWER_SUPPLY_PROP_MODEL_NAME,
 736         POWER_SUPPLY_PROP_MANUFACTURER,
 737         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 738 };
 739
 740 static struct backlight_device *compalbl_device;
 741
 742 static struct platform_device *compal_device;
 743
 744 static struct rfkill *wifi_rfkill;
 745 static struct rfkill *bt_rfkill;
 746
 747
 748
 749
 750
 751 /* =================================== */
 752 /* Initialization & clean-up functions */
 753 /* =================================== */
 754
 755 static int dmi_check_cb(const struct dmi_system_id *id)
 756 {
 757         pr_info("Identified laptop model '%s'\n", id->ident);
 758         extra_features = false;
 759         return 1;
 760 }
 761
 762 static int dmi_check_cb_extra(const struct dmi_system_id *id)
 763 {
 764         pr_info("Identified laptop model '%s', enabling extra features\n",
 765                 id->ident);
 766         extra_features = true;
 767         return 1;
 768 }
 769
 770 static struct dmi_system_id __initdata compal_dmi_table[] = {
 771         {
 772                 .ident = "FL90/IFL90",
 773                 .matches = {
 774                         DMI_MATCH(DMI_BOARD_NAME, "IFL90"),
 775                         DMI_MATCH(DMI_BOARD_VERSION, "IFT00"),
 776                 },
 777                 .callback = dmi_check_cb
 778         },
 779         {
 780                 .ident = "FL90/IFL90",
 781                 .matches = {
 782                         DMI_MATCH(DMI_BOARD_NAME, "IFL90"),
 783                         DMI_MATCH(DMI_BOARD_VERSION, "REFERENCE"),
 784                 },
 785                 .callback = dmi_check_cb
 786         },
 787         {
 788                 .ident = "FL91/IFL91",
 789                 .matches = {
 790                         DMI_MATCH(DMI_BOARD_NAME, "IFL91"),
 791                         DMI_MATCH(DMI_BOARD_VERSION, "IFT00"),
 792                 },
 793                 .callback = dmi_check_cb
 794         },
 795         {
 796                 .ident = "FL92/JFL92",
 797                 .matches = {
 798                         DMI_MATCH(DMI_BOARD_NAME, "JFL92"),
 799                         DMI_MATCH(DMI_BOARD_VERSION, "IFT00"),
 800                 },
 801                 .callback = dmi_check_cb
 802         },
 803         {
 804                 .ident = "FT00/IFT00",
 805                 .matches = {
 806                         DMI_MATCH(DMI_BOARD_NAME, "IFT00"),
 807                         DMI_MATCH(DMI_BOARD_VERSION, "IFT00"),
 808                 },
 809                 .callback = dmi_check_cb
 810         },
 811         {
 812                 .ident = "Dell Mini 9",
 813                 .matches = {
 814                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 815                         DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 910"),
 816                 },
 817                 .callback = dmi_check_cb
 818         },
 819         {
 820                 .ident = "Dell Mini 10",
 821                 .matches = {
 822                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 823                         DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1010"),
 824                 },
 825                 .callback = dmi_check_cb
 826         },
 827         {
 828                 .ident = "Dell Mini 10v",
 829                 .matches = {
 830                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 831                         DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1011"),
 832                 },
 833                 .callback = dmi_check_cb
 834         },
 835         {
 836                 .ident = "Dell Mini 1012",
 837                 .matches = {
 838                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 839                         DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1012"),
 840                 },
 841                 .callback = dmi_check_cb
 842         },
 843         {
 844                 .ident = "Dell Inspiron 11z",
 845                 .matches = {
 846                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 847                         DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1110"),
 848                 },
 849                 .callback = dmi_check_cb
 850         },
 851         {
 852                 .ident = "Dell Mini 12",
 853                 .matches = {
 854                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 855                         DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1210"),
 856                 },
 857                 .callback = dmi_check_cb
 858         },
 859         {
 860                 .ident = "JHL90",
 861                 .matches = {
 862                         DMI_MATCH(DMI_BOARD_NAME, "JHL90"),
 863                         DMI_MATCH(DMI_BOARD_VERSION, "REFERENCE"),
 864                 },
 865                 .callback = dmi_check_cb_extra
 866         },
 867         {
 868                 .ident = "KHLB2",
 869                 .matches = {
 870                         DMI_MATCH(DMI_BOARD_NAME, "KHLB2"),
 871                         DMI_MATCH(DMI_BOARD_VERSION, "REFERENCE"),
 872                 },
 873                 .callback = dmi_check_cb_extra
 874         },
 875         { }
 876 };
 877 MODULE_DEVICE_TABLE(dmi, compal_dmi_table);
 878
 879 static void initialize_power_supply_data(struct compal_data *data)
 880 {
 881         data->psy.name = DRIVER_NAME;
 882         data->psy.type = POWER_SUPPLY_TYPE_BATTERY;
 883         data->psy.properties = compal_bat_properties;
 884         data->psy.num_properties = ARRAY_SIZE(compal_bat_properties);
 885         data->psy.get_property = bat_get_property;
 886
 887         ec_read_sequence(BAT_MANUFACTURER_NAME_ADDR,
 888                                         data->bat_manufacturer_name,
 889                                         BAT_MANUFACTURER_NAME_LEN);
 890         data->bat_manufacturer_name[BAT_MANUFACTURER_NAME_LEN] = 0;
 891
 892         ec_read_sequence(BAT_MODEL_NAME_ADDR,
 893                                         data->bat_model_name,
 894                                         BAT_MODEL_NAME_LEN);
 895         data->bat_model_name[BAT_MODEL_NAME_LEN] = 0;
 896
 897         scnprintf(data->bat_serial_number, BAT_SERIAL_NUMBER_LEN + 1, "%d",
 898                                 ec_read_u16(BAT_SERIAL_NUMBER_ADDR));
 899 }
 900
 901 static void initialize_fan_control_data(struct compal_data *data)
 902 {
 903         data->pwm_enable = 2; /* Keep motherboard in control for now */
 904         data->curr_pwm = 255; /* Try not to cause a CPU_on_fire exception
 905                                  if we take over... */
 906 }
 907
 908 static int setup_rfkill(void)
 909 {
 910         int ret;
 911
 912         wifi_rfkill = rfkill_alloc("compal-wifi", &compal_device->dev,
 913                                 RFKILL_TYPE_WLAN, &compal_rfkill_ops,
 914                                 (void *) WIRELESS_WLAN);
 915         if (!wifi_rfkill)
 916                 return -ENOMEM;
 917
 918         ret = rfkill_register(wifi_rfkill);
 919         if (ret)
 920                 goto err_wifi;
 921
 922         bt_rfkill = rfkill_alloc("compal-bluetooth", &compal_device->dev,
 923                                 RFKILL_TYPE_BLUETOOTH, &compal_rfkill_ops,
 924                                 (void *) WIRELESS_BT);
 925         if (!bt_rfkill) {
 926                 ret = -ENOMEM;
 927                 goto err_allocate_bt;
 928         }
 929         ret = rfkill_register(bt_rfkill);
 930         if (ret)
 931                 goto err_register_bt;
 932
 933         return 0;
 934
 935 err_register_bt:
 936         rfkill_destroy(bt_rfkill);
 937
 938 err_allocate_bt:
 939         rfkill_unregister(wifi_rfkill);
 940
 941 err_wifi:
 942         rfkill_destroy(wifi_rfkill);
 943
 944         return ret;
 945 }
 946
 947 static int __init compal_init(void)
 948 {
 949         int ret;
 950
 951         if (acpi_disabled) {
 952                 pr_err("ACPI needs to be enabled for this driver to work!\n");
 953                 return -ENODEV;
 954         }
 955
 956         if (!force && !dmi_check_system(compal_dmi_table)) {
 957                 pr_err("Motherboard not recognized (You could try the module's force-parameter)\n");
 958                 return -ENODEV;
 959         }
 960
 961         if (!acpi_video_backlight_support()) {
 962                 struct backlight_properties props;
 963                 memset(&props, 0, sizeof(struct backlight_properties));
 964                 props.type = BACKLIGHT_PLATFORM;
 965                 props.max_brightness = BACKLIGHT_LEVEL_MAX;
 966                 compalbl_device = backlight_device_register(DRIVER_NAME,
 967                                                             NULL, NULL,
 968                                                             &compalbl_ops,
 969                                                             &props);
 970                 if (IS_ERR(compalbl_device))
 971                         return PTR_ERR(compalbl_device);
 972         }
 973
 974         ret = platform_driver_register(&compal_driver);
 975         if (ret)
 976                 goto err_backlight;
 977
 978         compal_device = platform_device_alloc(DRIVER_NAME, -1);
 979         if (!compal_device) {
 980                 ret = -ENOMEM;
 981                 goto err_platform_driver;
 982         }
 983
 984         ret = platform_device_add(compal_device); /* This calls compal_probe */
 985         if (ret)
 986                 goto err_platform_device;
 987
 988         ret = setup_rfkill();
 989         if (ret)
 990                 goto err_rfkill;
 991
 992         pr_info("Driver " DRIVER_VERSION " successfully loaded\n");
 993         return 0;
 994
 995 err_rfkill:
 996         platform_device_del(compal_device);
 997
 998 err_platform_device:
 999         platform_device_put(compal_device);
1000
1001 err_platform_driver:
1002         platform_driver_unregister(&compal_driver);
1003
1004 err_backlight:
1005         backlight_device_unregister(compalbl_device);
1006
1007         return ret;
1008 }
1009
1010 static int compal_probe(struct platform_device *pdev)
1011 {
1012         int err;
1013         struct compal_data *data;
1014         struct device *hwmon_dev;
1015
1016         if (!extra_features)
1017                 return 0;
1018
1019         /* Fan control */
1020         data = devm_kzalloc(&pdev->dev, sizeof(struct compal_data), GFP_KERNEL);
1021         if (!data)
1022                 return -ENOMEM;
1023
1024         initialize_fan_control_data(data);
1025
1026         err = sysfs_create_group(&pdev->dev.kobj, &compal_platform_attr_group);
1027         if (err)
1028                 return err;
1029
1030         hwmon_dev = hwmon_device_register_with_groups(&pdev->dev,
1031                                                       DRIVER_NAME, data,
1032                                                       compal_hwmon_groups);
1033         if (IS_ERR(hwmon_dev)) {
1034                 err = PTR_ERR(hwmon_dev);
1035                 goto remove;
1036         }
1037
1038         /* Power supply */
1039         initialize_power_supply_data(data);
1040         power_supply_register(&compal_device->dev, &data->psy);
1041
1042         platform_set_drvdata(pdev, data);
1043
1044         return 0;
1045
1046 remove:
1047         sysfs_remove_group(&pdev->dev.kobj, &compal_platform_attr_group);
1048         return err;
1049 }
1050
1051 static void __exit compal_cleanup(void)
1052 {
1053         platform_device_unregister(compal_device);
1054         platform_driver_unregister(&compal_driver);
1055         backlight_device_unregister(compalbl_device);
1056         rfkill_unregister(wifi_rfkill);
1057         rfkill_unregister(bt_rfkill);
1058         rfkill_destroy(wifi_rfkill);
1059         rfkill_destroy(bt_rfkill);
1060
1061         pr_info("Driver unloaded\n");
1062 }
1063
1064 static int compal_remove(struct platform_device *pdev)
1065 {
1066         struct compal_data *data;
1067
1068         if (!extra_features)
1069                 return 0;
1070
1071         pr_info("Unloading: resetting fan control to motherboard\n");
1072         pwm_disable_control();
1073
1074         data = platform_get_drvdata(pdev);
1075         power_supply_unregister(&data->psy);
1076
1077         sysfs_remove_group(&pdev->dev.kobj, &compal_platform_attr_group);
1078
1079         return 0;
1080 }
1081
1082
1083 module_init(compal_init);
1084 module_exit(compal_cleanup);
1085
1086 MODULE_AUTHOR("Cezary Jackiewicz");
1087 MODULE_AUTHOR("Roald Frederickx (roald.frederickx@gmail.com)");
1088 MODULE_DESCRIPTION("Compal Laptop Support");
1089 MODULE_VERSION(DRIVER_VERSION);
1090 MODULE_LICENSE("GPL");