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