1420 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * drivers/hwmon/applesmc.c - driver for Apple's SMC (accelerometer, temperature4 * sensors, fan control, keyboard backlight control) used in Intel-based Apple5 * computers.6 *7 * Copyright (C) 2007 Nicolas Boichat <nicolas@boichat.ch>8 * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>9 *10 * Based on hdaps.c driver:11 * Copyright (C) 2005 Robert Love <rml@novell.com>12 * Copyright (C) 2005 Jesper Juhl <jj@chaosbits.net>13 *14 * Fan control based on smcFanControl:15 * Copyright (C) 2006 Hendrik Holtmann <holtmann@mac.com>16 */17 18#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt19 20#include <linux/delay.h>21#include <linux/platform_device.h>22#include <linux/input.h>23#include <linux/kernel.h>24#include <linux/slab.h>25#include <linux/module.h>26#include <linux/timer.h>27#include <linux/dmi.h>28#include <linux/mutex.h>29#include <linux/hwmon-sysfs.h>30#include <linux/io.h>31#include <linux/leds.h>32#include <linux/hwmon.h>33#include <linux/workqueue.h>34#include <linux/err.h>35#include <linux/bits.h>36 37/* data port used by Apple SMC */38#define APPLESMC_DATA_PORT 0x30039/* command/status port used by Apple SMC */40#define APPLESMC_CMD_PORT 0x30441 42#define APPLESMC_NR_PORTS 32 /* 0x300-0x31f */43 44#define APPLESMC_MAX_DATA_LENGTH 3245 46/* Apple SMC status bits */47#define SMC_STATUS_AWAITING_DATA BIT(0) /* SMC has data waiting to be read */48#define SMC_STATUS_IB_CLOSED BIT(1) /* Will ignore any input */49#define SMC_STATUS_BUSY BIT(2) /* Command in progress */50 51/* Initial wait is 8us */52#define APPLESMC_MIN_WAIT 0x000853 54#define APPLESMC_READ_CMD 0x1055#define APPLESMC_WRITE_CMD 0x1156#define APPLESMC_GET_KEY_BY_INDEX_CMD 0x1257#define APPLESMC_GET_KEY_TYPE_CMD 0x1358 59#define KEY_COUNT_KEY "#KEY" /* r-o ui32 */60 61#define LIGHT_SENSOR_LEFT_KEY "ALV0" /* r-o {alv (6-10 bytes) */62#define LIGHT_SENSOR_RIGHT_KEY "ALV1" /* r-o {alv (6-10 bytes) */63#define BACKLIGHT_KEY "LKSB" /* w-o {lkb (2 bytes) */64 65#define CLAMSHELL_KEY "MSLD" /* r-o ui8 (unused) */66 67#define MOTION_SENSOR_X_KEY "MO_X" /* r-o sp78 (2 bytes) */68#define MOTION_SENSOR_Y_KEY "MO_Y" /* r-o sp78 (2 bytes) */69#define MOTION_SENSOR_Z_KEY "MO_Z" /* r-o sp78 (2 bytes) */70#define MOTION_SENSOR_KEY "MOCN" /* r/w ui16 */71 72#define FANS_COUNT "FNum" /* r-o ui8 */73#define FANS_MANUAL "FS! " /* r-w ui16 */74#define FAN_ID_FMT "F%dID" /* r-o char[16] */75 76#define TEMP_SENSOR_TYPE "sp78"77 78/* List of keys used to read/write fan speeds */79static const char *const fan_speed_fmt[] = {80 "F%dAc", /* actual speed */81 "F%dMn", /* minimum speed (rw) */82 "F%dMx", /* maximum speed */83 "F%dSf", /* safe speed - not all models */84 "F%dTg", /* target speed (manual: rw) */85};86 87#define INIT_TIMEOUT_MSECS 5000 /* wait up to 5s for device init ... */88#define INIT_WAIT_MSECS 50 /* ... in 50ms increments */89 90#define APPLESMC_POLL_INTERVAL 50 /* msecs */91#define APPLESMC_INPUT_FUZZ 4 /* input event threshold */92#define APPLESMC_INPUT_FLAT 493 94#define to_index(attr) (to_sensor_dev_attr(attr)->index & 0xffff)95#define to_option(attr) (to_sensor_dev_attr(attr)->index >> 16)96 97/* Dynamic device node attributes */98struct applesmc_dev_attr {99 struct sensor_device_attribute sda; /* hwmon attributes */100 char name[32]; /* room for node file name */101};102 103/* Dynamic device node group */104struct applesmc_node_group {105 char *format; /* format string */106 void *show; /* show function */107 void *store; /* store function */108 int option; /* function argument */109 struct applesmc_dev_attr *nodes; /* dynamic node array */110};111 112/* AppleSMC entry - cached register information */113struct applesmc_entry {114 char key[5]; /* four-letter key code */115 u8 valid; /* set when entry is successfully read once */116 u8 len; /* bounded by APPLESMC_MAX_DATA_LENGTH */117 char type[5]; /* four-letter type code */118 u8 flags; /* 0x10: func; 0x40: write; 0x80: read */119};120 121/* Register lookup and registers common to all SMCs */122static struct applesmc_registers {123 struct mutex mutex; /* register read/write mutex */124 unsigned int key_count; /* number of SMC registers */125 unsigned int fan_count; /* number of fans */126 unsigned int temp_count; /* number of temperature registers */127 unsigned int temp_begin; /* temperature lower index bound */128 unsigned int temp_end; /* temperature upper index bound */129 unsigned int index_count; /* size of temperature index array */130 int num_light_sensors; /* number of light sensors */131 bool has_accelerometer; /* has motion sensor */132 bool has_key_backlight; /* has keyboard backlight */133 bool init_complete; /* true when fully initialized */134 struct applesmc_entry *cache; /* cached key entries */135 const char **index; /* temperature key index */136} smcreg = {137 .mutex = __MUTEX_INITIALIZER(smcreg.mutex),138};139 140static const int debug;141static struct platform_device *pdev;142static s16 rest_x;143static s16 rest_y;144static u8 backlight_state[2];145 146static struct device *hwmon_dev;147static struct input_dev *applesmc_idev;148 149/*150 * Last index written to key_at_index sysfs file, and value to use for all other151 * key_at_index_* sysfs files.152 */153static unsigned int key_at_index;154 155static struct workqueue_struct *applesmc_led_wq;156 157/*158 * Wait for specific status bits with a mask on the SMC.159 * Used before all transactions.160 * This does 10 fast loops of 8us then exponentially backs off for a161 * minimum total wait of 262ms. Depending on usleep_range this could162 * run out past 500ms.163 */164 165static int wait_status(u8 val, u8 mask)166{167 u8 status;168 int us;169 int i;170 171 us = APPLESMC_MIN_WAIT;172 for (i = 0; i < 24 ; i++) {173 status = inb(APPLESMC_CMD_PORT);174 if ((status & mask) == val)175 return 0;176 usleep_range(us, us * 2);177 if (i > 9)178 us <<= 1;179 }180 return -EIO;181}182 183/* send_byte - Write to SMC data port. Callers must hold applesmc_lock. */184 185static int send_byte(u8 cmd, u16 port)186{187 int status;188 189 status = wait_status(0, SMC_STATUS_IB_CLOSED);190 if (status)191 return status;192 /*193 * This needs to be a separate read looking for bit 0x04194 * after bit 0x02 falls. If consolidated with the wait above195 * this extra read may not happen if status returns both196 * simultaneously and this would appear to be required.197 */198 status = wait_status(SMC_STATUS_BUSY, SMC_STATUS_BUSY);199 if (status)200 return status;201 202 outb(cmd, port);203 return 0;204}205 206/* send_command - Write a command to the SMC. Callers must hold applesmc_lock. */207 208static int send_command(u8 cmd)209{210 int ret;211 212 ret = wait_status(0, SMC_STATUS_IB_CLOSED);213 if (ret)214 return ret;215 outb(cmd, APPLESMC_CMD_PORT);216 return 0;217}218 219/*220 * Based on logic from the Apple driver. This is issued before any interaction221 * If busy is stuck high, issue a read command to reset the SMC state machine.222 * If busy is stuck high after the command then the SMC is jammed.223 */224 225static int smc_sane(void)226{227 int ret;228 229 ret = wait_status(0, SMC_STATUS_BUSY);230 if (!ret)231 return ret;232 ret = send_command(APPLESMC_READ_CMD);233 if (ret)234 return ret;235 return wait_status(0, SMC_STATUS_BUSY);236}237 238static int send_argument(const char *key)239{240 int i;241 242 for (i = 0; i < 4; i++)243 if (send_byte(key[i], APPLESMC_DATA_PORT))244 return -EIO;245 return 0;246}247 248static int read_smc(u8 cmd, const char *key, u8 *buffer, u8 len)249{250 u8 status, data = 0;251 int i;252 int ret;253 254 ret = smc_sane();255 if (ret)256 return ret;257 258 if (send_command(cmd) || send_argument(key)) {259 pr_warn("%.4s: read arg fail\n", key);260 return -EIO;261 }262 263 /* This has no effect on newer (2012) SMCs */264 if (send_byte(len, APPLESMC_DATA_PORT)) {265 pr_warn("%.4s: read len fail\n", key);266 return -EIO;267 }268 269 for (i = 0; i < len; i++) {270 if (wait_status(SMC_STATUS_AWAITING_DATA | SMC_STATUS_BUSY,271 SMC_STATUS_AWAITING_DATA | SMC_STATUS_BUSY)) {272 pr_warn("%.4s: read data[%d] fail\n", key, i);273 return -EIO;274 }275 buffer[i] = inb(APPLESMC_DATA_PORT);276 }277 278 /* Read the data port until bit0 is cleared */279 for (i = 0; i < 16; i++) {280 udelay(APPLESMC_MIN_WAIT);281 status = inb(APPLESMC_CMD_PORT);282 if (!(status & SMC_STATUS_AWAITING_DATA))283 break;284 data = inb(APPLESMC_DATA_PORT);285 }286 if (i)287 pr_warn("flushed %d bytes, last value is: %d\n", i, data);288 289 return wait_status(0, SMC_STATUS_BUSY);290}291 292static int write_smc(u8 cmd, const char *key, const u8 *buffer, u8 len)293{294 int i;295 int ret;296 297 ret = smc_sane();298 if (ret)299 return ret;300 301 if (send_command(cmd) || send_argument(key)) {302 pr_warn("%s: write arg fail\n", key);303 return -EIO;304 }305 306 if (send_byte(len, APPLESMC_DATA_PORT)) {307 pr_warn("%.4s: write len fail\n", key);308 return -EIO;309 }310 311 for (i = 0; i < len; i++) {312 if (send_byte(buffer[i], APPLESMC_DATA_PORT)) {313 pr_warn("%s: write data fail\n", key);314 return -EIO;315 }316 }317 318 return wait_status(0, SMC_STATUS_BUSY);319}320 321static int read_register_count(unsigned int *count)322{323 __be32 be;324 int ret;325 326 ret = read_smc(APPLESMC_READ_CMD, KEY_COUNT_KEY, (u8 *)&be, 4);327 if (ret)328 return ret;329 330 *count = be32_to_cpu(be);331 return 0;332}333 334/*335 * Serialized I/O336 *337 * Returns zero on success or a negative error on failure.338 * All functions below are concurrency safe - callers should NOT hold lock.339 */340 341static int applesmc_read_entry(const struct applesmc_entry *entry,342 u8 *buf, u8 len)343{344 int ret;345 346 if (entry->len != len)347 return -EINVAL;348 mutex_lock(&smcreg.mutex);349 ret = read_smc(APPLESMC_READ_CMD, entry->key, buf, len);350 mutex_unlock(&smcreg.mutex);351 352 return ret;353}354 355static int applesmc_write_entry(const struct applesmc_entry *entry,356 const u8 *buf, u8 len)357{358 int ret;359 360 if (entry->len != len)361 return -EINVAL;362 mutex_lock(&smcreg.mutex);363 ret = write_smc(APPLESMC_WRITE_CMD, entry->key, buf, len);364 mutex_unlock(&smcreg.mutex);365 return ret;366}367 368static const struct applesmc_entry *applesmc_get_entry_by_index(int index)369{370 struct applesmc_entry *cache = &smcreg.cache[index];371 u8 key[4], info[6];372 __be32 be;373 int ret = 0;374 375 if (cache->valid)376 return cache;377 378 mutex_lock(&smcreg.mutex);379 380 if (cache->valid)381 goto out;382 be = cpu_to_be32(index);383 ret = read_smc(APPLESMC_GET_KEY_BY_INDEX_CMD, (u8 *)&be, key, 4);384 if (ret)385 goto out;386 ret = read_smc(APPLESMC_GET_KEY_TYPE_CMD, key, info, 6);387 if (ret)388 goto out;389 390 memcpy(cache->key, key, 4);391 cache->len = info[0];392 memcpy(cache->type, &info[1], 4);393 cache->flags = info[5];394 cache->valid = true;395 396out:397 mutex_unlock(&smcreg.mutex);398 if (ret)399 return ERR_PTR(ret);400 return cache;401}402 403static int applesmc_get_lower_bound(unsigned int *lo, const char *key)404{405 int begin = 0, end = smcreg.key_count;406 const struct applesmc_entry *entry;407 408 while (begin != end) {409 int middle = begin + (end - begin) / 2;410 entry = applesmc_get_entry_by_index(middle);411 if (IS_ERR(entry)) {412 *lo = 0;413 return PTR_ERR(entry);414 }415 if (strcmp(entry->key, key) < 0)416 begin = middle + 1;417 else418 end = middle;419 }420 421 *lo = begin;422 return 0;423}424 425static int applesmc_get_upper_bound(unsigned int *hi, const char *key)426{427 int begin = 0, end = smcreg.key_count;428 const struct applesmc_entry *entry;429 430 while (begin != end) {431 int middle = begin + (end - begin) / 2;432 entry = applesmc_get_entry_by_index(middle);433 if (IS_ERR(entry)) {434 *hi = smcreg.key_count;435 return PTR_ERR(entry);436 }437 if (strcmp(key, entry->key) < 0)438 end = middle;439 else440 begin = middle + 1;441 }442 443 *hi = begin;444 return 0;445}446 447static const struct applesmc_entry *applesmc_get_entry_by_key(const char *key)448{449 int begin, end;450 int ret;451 452 ret = applesmc_get_lower_bound(&begin, key);453 if (ret)454 return ERR_PTR(ret);455 ret = applesmc_get_upper_bound(&end, key);456 if (ret)457 return ERR_PTR(ret);458 if (end - begin != 1)459 return ERR_PTR(-EINVAL);460 461 return applesmc_get_entry_by_index(begin);462}463 464static int applesmc_read_key(const char *key, u8 *buffer, u8 len)465{466 const struct applesmc_entry *entry;467 468 entry = applesmc_get_entry_by_key(key);469 if (IS_ERR(entry))470 return PTR_ERR(entry);471 472 return applesmc_read_entry(entry, buffer, len);473}474 475static int applesmc_write_key(const char *key, const u8 *buffer, u8 len)476{477 const struct applesmc_entry *entry;478 479 entry = applesmc_get_entry_by_key(key);480 if (IS_ERR(entry))481 return PTR_ERR(entry);482 483 return applesmc_write_entry(entry, buffer, len);484}485 486static int applesmc_has_key(const char *key, bool *value)487{488 const struct applesmc_entry *entry;489 490 entry = applesmc_get_entry_by_key(key);491 if (IS_ERR(entry) && PTR_ERR(entry) != -EINVAL)492 return PTR_ERR(entry);493 494 *value = !IS_ERR(entry);495 return 0;496}497 498/*499 * applesmc_read_s16 - Read 16-bit signed big endian register500 */501static int applesmc_read_s16(const char *key, s16 *value)502{503 u8 buffer[2];504 int ret;505 506 ret = applesmc_read_key(key, buffer, 2);507 if (ret)508 return ret;509 510 *value = ((s16)buffer[0] << 8) | buffer[1];511 return 0;512}513 514/*515 * applesmc_device_init - initialize the accelerometer. Can sleep.516 */517static void applesmc_device_init(void)518{519 int total;520 u8 buffer[2];521 522 if (!smcreg.has_accelerometer)523 return;524 525 for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {526 if (!applesmc_read_key(MOTION_SENSOR_KEY, buffer, 2) &&527 (buffer[0] != 0x00 || buffer[1] != 0x00))528 return;529 buffer[0] = 0xe0;530 buffer[1] = 0x00;531 applesmc_write_key(MOTION_SENSOR_KEY, buffer, 2);532 msleep(INIT_WAIT_MSECS);533 }534 535 pr_warn("failed to init the device\n");536}537 538static int applesmc_init_index(struct applesmc_registers *s)539{540 const struct applesmc_entry *entry;541 unsigned int i;542 543 if (s->index)544 return 0;545 546 s->index = kcalloc(s->temp_count, sizeof(s->index[0]), GFP_KERNEL);547 if (!s->index)548 return -ENOMEM;549 550 for (i = s->temp_begin; i < s->temp_end; i++) {551 entry = applesmc_get_entry_by_index(i);552 if (IS_ERR(entry))553 continue;554 if (strcmp(entry->type, TEMP_SENSOR_TYPE))555 continue;556 s->index[s->index_count++] = entry->key;557 }558 559 return 0;560}561 562/*563 * applesmc_init_smcreg_try - Try to initialize register cache. Idempotent.564 */565static int applesmc_init_smcreg_try(void)566{567 struct applesmc_registers *s = &smcreg;568 bool left_light_sensor = false, right_light_sensor = false;569 unsigned int count;570 u8 tmp[1];571 int ret;572 573 if (s->init_complete)574 return 0;575 576 ret = read_register_count(&count);577 if (ret)578 return ret;579 580 if (s->cache && s->key_count != count) {581 pr_warn("key count changed from %d to %d\n",582 s->key_count, count);583 kfree(s->cache);584 s->cache = NULL;585 }586 s->key_count = count;587 588 if (!s->cache)589 s->cache = kcalloc(s->key_count, sizeof(*s->cache), GFP_KERNEL);590 if (!s->cache)591 return -ENOMEM;592 593 ret = applesmc_read_key(FANS_COUNT, tmp, 1);594 if (ret)595 return ret;596 s->fan_count = tmp[0];597 if (s->fan_count > 10)598 s->fan_count = 10;599 600 ret = applesmc_get_lower_bound(&s->temp_begin, "T");601 if (ret)602 return ret;603 ret = applesmc_get_lower_bound(&s->temp_end, "U");604 if (ret)605 return ret;606 s->temp_count = s->temp_end - s->temp_begin;607 608 ret = applesmc_init_index(s);609 if (ret)610 return ret;611 612 ret = applesmc_has_key(LIGHT_SENSOR_LEFT_KEY, &left_light_sensor);613 if (ret)614 return ret;615 ret = applesmc_has_key(LIGHT_SENSOR_RIGHT_KEY, &right_light_sensor);616 if (ret)617 return ret;618 ret = applesmc_has_key(MOTION_SENSOR_KEY, &s->has_accelerometer);619 if (ret)620 return ret;621 ret = applesmc_has_key(BACKLIGHT_KEY, &s->has_key_backlight);622 if (ret)623 return ret;624 625 s->num_light_sensors = left_light_sensor + right_light_sensor;626 s->init_complete = true;627 628 pr_info("key=%d fan=%d temp=%d index=%d acc=%d lux=%d kbd=%d\n",629 s->key_count, s->fan_count, s->temp_count, s->index_count,630 s->has_accelerometer,631 s->num_light_sensors,632 s->has_key_backlight);633 634 return 0;635}636 637static void applesmc_destroy_smcreg(void)638{639 kfree(smcreg.index);640 smcreg.index = NULL;641 kfree(smcreg.cache);642 smcreg.cache = NULL;643 smcreg.init_complete = false;644}645 646/*647 * applesmc_init_smcreg - Initialize register cache.648 *649 * Retries until initialization is successful, or the operation times out.650 *651 */652static int applesmc_init_smcreg(void)653{654 int ms, ret;655 656 for (ms = 0; ms < INIT_TIMEOUT_MSECS; ms += INIT_WAIT_MSECS) {657 ret = applesmc_init_smcreg_try();658 if (!ret) {659 if (ms)660 pr_info("init_smcreg() took %d ms\n", ms);661 return 0;662 }663 msleep(INIT_WAIT_MSECS);664 }665 666 applesmc_destroy_smcreg();667 668 return ret;669}670 671/* Device model stuff */672static int applesmc_probe(struct platform_device *dev)673{674 int ret;675 676 ret = applesmc_init_smcreg();677 if (ret)678 return ret;679 680 applesmc_device_init();681 682 return 0;683}684 685/* Synchronize device with memorized backlight state */686static int applesmc_pm_resume(struct device *dev)687{688 if (smcreg.has_key_backlight)689 applesmc_write_key(BACKLIGHT_KEY, backlight_state, 2);690 return 0;691}692 693/* Reinitialize device on resume from hibernation */694static int applesmc_pm_restore(struct device *dev)695{696 applesmc_device_init();697 return applesmc_pm_resume(dev);698}699 700static const struct dev_pm_ops applesmc_pm_ops = {701 .resume = applesmc_pm_resume,702 .restore = applesmc_pm_restore,703};704 705static struct platform_driver applesmc_driver = {706 .probe = applesmc_probe,707 .driver = {708 .name = "applesmc",709 .pm = &applesmc_pm_ops,710 },711};712 713/*714 * applesmc_calibrate - Set our "resting" values. Callers must715 * hold applesmc_lock.716 */717static void applesmc_calibrate(void)718{719 applesmc_read_s16(MOTION_SENSOR_X_KEY, &rest_x);720 applesmc_read_s16(MOTION_SENSOR_Y_KEY, &rest_y);721 rest_x = -rest_x;722}723 724static void applesmc_idev_poll(struct input_dev *idev)725{726 s16 x, y;727 728 if (applesmc_read_s16(MOTION_SENSOR_X_KEY, &x))729 return;730 if (applesmc_read_s16(MOTION_SENSOR_Y_KEY, &y))731 return;732 733 x = -x;734 input_report_abs(idev, ABS_X, x - rest_x);735 input_report_abs(idev, ABS_Y, y - rest_y);736 input_sync(idev);737}738 739/* Sysfs Files */740 741static ssize_t applesmc_name_show(struct device *dev,742 struct device_attribute *attr, char *buf)743{744 return sysfs_emit(buf, "applesmc\n");745}746 747static ssize_t applesmc_position_show(struct device *dev,748 struct device_attribute *attr, char *buf)749{750 int ret;751 s16 x, y, z;752 753 ret = applesmc_read_s16(MOTION_SENSOR_X_KEY, &x);754 if (ret)755 goto out;756 ret = applesmc_read_s16(MOTION_SENSOR_Y_KEY, &y);757 if (ret)758 goto out;759 ret = applesmc_read_s16(MOTION_SENSOR_Z_KEY, &z);760 if (ret)761 goto out;762 763out:764 if (ret)765 return ret;766 767 return sysfs_emit(buf, "(%d,%d,%d)\n", x, y, z);768}769 770static ssize_t applesmc_light_show(struct device *dev,771 struct device_attribute *attr, char *sysfsbuf)772{773 const struct applesmc_entry *entry;774 static int data_length;775 int ret;776 u8 left = 0, right = 0;777 u8 buffer[10];778 779 if (!data_length) {780 entry = applesmc_get_entry_by_key(LIGHT_SENSOR_LEFT_KEY);781 if (IS_ERR(entry))782 return PTR_ERR(entry);783 if (entry->len > 10)784 return -ENXIO;785 data_length = entry->len;786 pr_info("light sensor data length set to %d\n", data_length);787 }788 789 ret = applesmc_read_key(LIGHT_SENSOR_LEFT_KEY, buffer, data_length);790 if (ret)791 goto out;792 /* newer macbooks report a single 10-bit bigendian value */793 if (data_length == 10) {794 left = be16_to_cpu(*(__be16 *)(buffer + 6)) >> 2;795 goto out;796 }797 left = buffer[2];798 799 ret = applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY, buffer, data_length);800 if (ret)801 goto out;802 right = buffer[2];803 804out:805 if (ret)806 return ret;807 808 return sysfs_emit(sysfsbuf, "(%d,%d)\n", left, right);809}810 811/* Displays sensor key as label */812static ssize_t applesmc_show_sensor_label(struct device *dev,813 struct device_attribute *devattr, char *sysfsbuf)814{815 const char *key = smcreg.index[to_index(devattr)];816 817 return sysfs_emit(sysfsbuf, "%s\n", key);818}819 820/* Displays degree Celsius * 1000 */821static ssize_t applesmc_show_temperature(struct device *dev,822 struct device_attribute *devattr, char *sysfsbuf)823{824 const char *key = smcreg.index[to_index(devattr)];825 int ret;826 s16 value;827 int temp;828 829 ret = applesmc_read_s16(key, &value);830 if (ret)831 return ret;832 833 temp = 250 * (value >> 6);834 835 return sysfs_emit(sysfsbuf, "%d\n", temp);836}837 838static ssize_t applesmc_show_fan_speed(struct device *dev,839 struct device_attribute *attr, char *sysfsbuf)840{841 int ret;842 unsigned int speed = 0;843 char newkey[5];844 u8 buffer[2];845 846 scnprintf(newkey, sizeof(newkey), fan_speed_fmt[to_option(attr)],847 to_index(attr));848 849 ret = applesmc_read_key(newkey, buffer, 2);850 if (ret)851 return ret;852 853 speed = ((buffer[0] << 8 | buffer[1]) >> 2);854 return sysfs_emit(sysfsbuf, "%u\n", speed);855}856 857static ssize_t applesmc_store_fan_speed(struct device *dev,858 struct device_attribute *attr,859 const char *sysfsbuf, size_t count)860{861 int ret;862 unsigned long speed;863 char newkey[5];864 u8 buffer[2];865 866 if (kstrtoul(sysfsbuf, 10, &speed) < 0 || speed >= 0x4000)867 return -EINVAL; /* Bigger than a 14-bit value */868 869 scnprintf(newkey, sizeof(newkey), fan_speed_fmt[to_option(attr)],870 to_index(attr));871 872 buffer[0] = (speed >> 6) & 0xff;873 buffer[1] = (speed << 2) & 0xff;874 ret = applesmc_write_key(newkey, buffer, 2);875 876 if (ret)877 return ret;878 else879 return count;880}881 882static ssize_t applesmc_show_fan_manual(struct device *dev,883 struct device_attribute *attr, char *sysfsbuf)884{885 int ret;886 u16 manual = 0;887 u8 buffer[2];888 889 ret = applesmc_read_key(FANS_MANUAL, buffer, 2);890 if (ret)891 return ret;892 893 manual = ((buffer[0] << 8 | buffer[1]) >> to_index(attr)) & 0x01;894 return sysfs_emit(sysfsbuf, "%d\n", manual);895}896 897static ssize_t applesmc_store_fan_manual(struct device *dev,898 struct device_attribute *attr,899 const char *sysfsbuf, size_t count)900{901 int ret;902 u8 buffer[2];903 unsigned long input;904 u16 val;905 906 if (kstrtoul(sysfsbuf, 10, &input) < 0)907 return -EINVAL;908 909 ret = applesmc_read_key(FANS_MANUAL, buffer, 2);910 if (ret)911 goto out;912 913 val = (buffer[0] << 8 | buffer[1]);914 915 if (input)916 val = val | (0x01 << to_index(attr));917 else918 val = val & ~(0x01 << to_index(attr));919 920 buffer[0] = (val >> 8) & 0xFF;921 buffer[1] = val & 0xFF;922 923 ret = applesmc_write_key(FANS_MANUAL, buffer, 2);924 925out:926 if (ret)927 return ret;928 else929 return count;930}931 932static ssize_t applesmc_show_fan_position(struct device *dev,933 struct device_attribute *attr, char *sysfsbuf)934{935 int ret;936 char newkey[5];937 u8 buffer[17];938 939 scnprintf(newkey, sizeof(newkey), FAN_ID_FMT, to_index(attr));940 941 ret = applesmc_read_key(newkey, buffer, 16);942 buffer[16] = 0;943 944 if (ret)945 return ret;946 947 return sysfs_emit(sysfsbuf, "%s\n", buffer + 4);948}949 950static ssize_t applesmc_calibrate_show(struct device *dev,951 struct device_attribute *attr, char *sysfsbuf)952{953 return sysfs_emit(sysfsbuf, "(%d,%d)\n", rest_x, rest_y);954}955 956static ssize_t applesmc_calibrate_store(struct device *dev,957 struct device_attribute *attr, const char *sysfsbuf, size_t count)958{959 applesmc_calibrate();960 961 return count;962}963 964static void applesmc_backlight_set(struct work_struct *work)965{966 applesmc_write_key(BACKLIGHT_KEY, backlight_state, 2);967}968static DECLARE_WORK(backlight_work, &applesmc_backlight_set);969 970static void applesmc_brightness_set(struct led_classdev *led_cdev,971 enum led_brightness value)972{973 int ret;974 975 backlight_state[0] = value;976 ret = queue_work(applesmc_led_wq, &backlight_work);977 978 if (debug && (!ret))979 dev_dbg(led_cdev->dev, "work was already on the queue.\n");980}981 982static ssize_t applesmc_key_count_show(struct device *dev,983 struct device_attribute *attr, char *sysfsbuf)984{985 int ret;986 u8 buffer[4];987 u32 count;988 989 ret = applesmc_read_key(KEY_COUNT_KEY, buffer, 4);990 if (ret)991 return ret;992 993 count = ((u32)buffer[0]<<24) + ((u32)buffer[1]<<16) +994 ((u32)buffer[2]<<8) + buffer[3];995 return sysfs_emit(sysfsbuf, "%d\n", count);996}997 998static ssize_t applesmc_key_at_index_read_show(struct device *dev,999 struct device_attribute *attr, char *sysfsbuf)1000{1001 const struct applesmc_entry *entry;1002 int ret;1003 1004 entry = applesmc_get_entry_by_index(key_at_index);1005 if (IS_ERR(entry))1006 return PTR_ERR(entry);1007 ret = applesmc_read_entry(entry, sysfsbuf, entry->len);1008 if (ret)1009 return ret;1010 1011 return entry->len;1012}1013 1014static ssize_t applesmc_key_at_index_data_length_show(struct device *dev,1015 struct device_attribute *attr, char *sysfsbuf)1016{1017 const struct applesmc_entry *entry;1018 1019 entry = applesmc_get_entry_by_index(key_at_index);1020 if (IS_ERR(entry))1021 return PTR_ERR(entry);1022 1023 return sysfs_emit(sysfsbuf, "%d\n", entry->len);1024}1025 1026static ssize_t applesmc_key_at_index_type_show(struct device *dev,1027 struct device_attribute *attr, char *sysfsbuf)1028{1029 const struct applesmc_entry *entry;1030 1031 entry = applesmc_get_entry_by_index(key_at_index);1032 if (IS_ERR(entry))1033 return PTR_ERR(entry);1034 1035 return sysfs_emit(sysfsbuf, "%s\n", entry->type);1036}1037 1038static ssize_t applesmc_key_at_index_name_show(struct device *dev,1039 struct device_attribute *attr, char *sysfsbuf)1040{1041 const struct applesmc_entry *entry;1042 1043 entry = applesmc_get_entry_by_index(key_at_index);1044 if (IS_ERR(entry))1045 return PTR_ERR(entry);1046 1047 return sysfs_emit(sysfsbuf, "%s\n", entry->key);1048}1049 1050static ssize_t applesmc_key_at_index_show(struct device *dev,1051 struct device_attribute *attr, char *sysfsbuf)1052{1053 return sysfs_emit(sysfsbuf, "%d\n", key_at_index);1054}1055 1056static ssize_t applesmc_key_at_index_store(struct device *dev,1057 struct device_attribute *attr, const char *sysfsbuf, size_t count)1058{1059 unsigned long newkey;1060 1061 if (kstrtoul(sysfsbuf, 10, &newkey) < 01062 || newkey >= smcreg.key_count)1063 return -EINVAL;1064 1065 key_at_index = newkey;1066 return count;1067}1068 1069static struct led_classdev applesmc_backlight = {1070 .name = "smc::kbd_backlight",1071 .default_trigger = "nand-disk",1072 .brightness_set = applesmc_brightness_set,1073};1074 1075static struct applesmc_node_group info_group[] = {1076 { "name", applesmc_name_show },1077 { "key_count", applesmc_key_count_show },1078 { "key_at_index", applesmc_key_at_index_show, applesmc_key_at_index_store },1079 { "key_at_index_name", applesmc_key_at_index_name_show },1080 { "key_at_index_type", applesmc_key_at_index_type_show },1081 { "key_at_index_data_length", applesmc_key_at_index_data_length_show },1082 { "key_at_index_data", applesmc_key_at_index_read_show },1083 { }1084};1085 1086static struct applesmc_node_group accelerometer_group[] = {1087 { "position", applesmc_position_show },1088 { "calibrate", applesmc_calibrate_show, applesmc_calibrate_store },1089 { }1090};1091 1092static struct applesmc_node_group light_sensor_group[] = {1093 { "light", applesmc_light_show },1094 { }1095};1096 1097static struct applesmc_node_group fan_group[] = {1098 { "fan%d_label", applesmc_show_fan_position },1099 { "fan%d_input", applesmc_show_fan_speed, NULL, 0 },1100 { "fan%d_min", applesmc_show_fan_speed, applesmc_store_fan_speed, 1 },1101 { "fan%d_max", applesmc_show_fan_speed, NULL, 2 },1102 { "fan%d_safe", applesmc_show_fan_speed, NULL, 3 },1103 { "fan%d_output", applesmc_show_fan_speed, applesmc_store_fan_speed, 4 },1104 { "fan%d_manual", applesmc_show_fan_manual, applesmc_store_fan_manual },1105 { }1106};1107 1108static struct applesmc_node_group temp_group[] = {1109 { "temp%d_label", applesmc_show_sensor_label },1110 { "temp%d_input", applesmc_show_temperature },1111 { }1112};1113 1114/* Module stuff */1115 1116/*1117 * applesmc_destroy_nodes - remove files and free associated memory1118 */1119static void applesmc_destroy_nodes(struct applesmc_node_group *groups)1120{1121 struct applesmc_node_group *grp;1122 struct applesmc_dev_attr *node;1123 1124 for (grp = groups; grp->nodes; grp++) {1125 for (node = grp->nodes; node->sda.dev_attr.attr.name; node++)1126 sysfs_remove_file(&pdev->dev.kobj,1127 &node->sda.dev_attr.attr);1128 kfree(grp->nodes);1129 grp->nodes = NULL;1130 }1131}1132 1133/*1134 * applesmc_create_nodes - create a two-dimensional group of sysfs files1135 */1136static int applesmc_create_nodes(struct applesmc_node_group *groups, int num)1137{1138 struct applesmc_node_group *grp;1139 struct applesmc_dev_attr *node;1140 struct attribute *attr;1141 int ret, i;1142 1143 for (grp = groups; grp->format; grp++) {1144 grp->nodes = kcalloc(num + 1, sizeof(*node), GFP_KERNEL);1145 if (!grp->nodes) {1146 ret = -ENOMEM;1147 goto out;1148 }1149 for (i = 0; i < num; i++) {1150 node = &grp->nodes[i];1151 scnprintf(node->name, sizeof(node->name), grp->format,1152 i + 1);1153 node->sda.index = (grp->option << 16) | (i & 0xffff);1154 node->sda.dev_attr.show = grp->show;1155 node->sda.dev_attr.store = grp->store;1156 attr = &node->sda.dev_attr.attr;1157 sysfs_attr_init(attr);1158 attr->name = node->name;1159 attr->mode = 0444 | (grp->store ? 0200 : 0);1160 ret = sysfs_create_file(&pdev->dev.kobj, attr);1161 if (ret) {1162 attr->name = NULL;1163 goto out;1164 }1165 }1166 }1167 1168 return 0;1169out:1170 applesmc_destroy_nodes(groups);1171 return ret;1172}1173 1174/* Create accelerometer resources */1175static int applesmc_create_accelerometer(void)1176{1177 int ret;1178 1179 if (!smcreg.has_accelerometer)1180 return 0;1181 1182 ret = applesmc_create_nodes(accelerometer_group, 1);1183 if (ret)1184 goto out;1185 1186 applesmc_idev = input_allocate_device();1187 if (!applesmc_idev) {1188 ret = -ENOMEM;1189 goto out_sysfs;1190 }1191 1192 /* initial calibrate for the input device */1193 applesmc_calibrate();1194 1195 /* initialize the input device */1196 applesmc_idev->name = "applesmc";1197 applesmc_idev->id.bustype = BUS_HOST;1198 applesmc_idev->dev.parent = &pdev->dev;1199 input_set_abs_params(applesmc_idev, ABS_X,1200 -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);1201 input_set_abs_params(applesmc_idev, ABS_Y,1202 -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);1203 1204 ret = input_setup_polling(applesmc_idev, applesmc_idev_poll);1205 if (ret)1206 goto out_idev;1207 1208 input_set_poll_interval(applesmc_idev, APPLESMC_POLL_INTERVAL);1209 1210 ret = input_register_device(applesmc_idev);1211 if (ret)1212 goto out_idev;1213 1214 return 0;1215 1216out_idev:1217 input_free_device(applesmc_idev);1218 1219out_sysfs:1220 applesmc_destroy_nodes(accelerometer_group);1221 1222out:1223 pr_warn("driver init failed (ret=%d)!\n", ret);1224 return ret;1225}1226 1227/* Release all resources used by the accelerometer */1228static void applesmc_release_accelerometer(void)1229{1230 if (!smcreg.has_accelerometer)1231 return;1232 input_unregister_device(applesmc_idev);1233 applesmc_destroy_nodes(accelerometer_group);1234}1235 1236static int applesmc_create_light_sensor(void)1237{1238 if (!smcreg.num_light_sensors)1239 return 0;1240 return applesmc_create_nodes(light_sensor_group, 1);1241}1242 1243static void applesmc_release_light_sensor(void)1244{1245 if (!smcreg.num_light_sensors)1246 return;1247 applesmc_destroy_nodes(light_sensor_group);1248}1249 1250static int applesmc_create_key_backlight(void)1251{1252 if (!smcreg.has_key_backlight)1253 return 0;1254 applesmc_led_wq = create_singlethread_workqueue("applesmc-led");1255 if (!applesmc_led_wq)1256 return -ENOMEM;1257 return led_classdev_register(&pdev->dev, &applesmc_backlight);1258}1259 1260static void applesmc_release_key_backlight(void)1261{1262 if (!smcreg.has_key_backlight)1263 return;1264 led_classdev_unregister(&applesmc_backlight);1265 destroy_workqueue(applesmc_led_wq);1266}1267 1268static int applesmc_dmi_match(const struct dmi_system_id *id)1269{1270 return 1;1271}1272 1273/*1274 * Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".1275 * So we need to put "Apple MacBook Pro" before "Apple MacBook".1276 */1277static const struct dmi_system_id applesmc_whitelist[] __initconst = {1278 { applesmc_dmi_match, "Apple MacBook Air", {1279 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),1280 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir") },1281 },1282 { applesmc_dmi_match, "Apple MacBook Pro", {1283 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),1284 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro") },1285 },1286 { applesmc_dmi_match, "Apple MacBook", {1287 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),1288 DMI_MATCH(DMI_PRODUCT_NAME, "MacBook") },1289 },1290 { applesmc_dmi_match, "Apple Macmini", {1291 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),1292 DMI_MATCH(DMI_PRODUCT_NAME, "Macmini") },1293 },1294 { applesmc_dmi_match, "Apple MacPro", {1295 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),1296 DMI_MATCH(DMI_PRODUCT_NAME, "MacPro") },1297 },1298 { applesmc_dmi_match, "Apple iMac", {1299 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),1300 DMI_MATCH(DMI_PRODUCT_NAME, "iMac") },1301 },1302 { applesmc_dmi_match, "Apple Xserve", {1303 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),1304 DMI_MATCH(DMI_PRODUCT_NAME, "Xserve") },1305 },1306 { .ident = NULL }1307};1308 1309static int __init applesmc_init(void)1310{1311 int ret;1312 1313 if (!dmi_check_system(applesmc_whitelist)) {1314 pr_warn("supported laptop not found!\n");1315 ret = -ENODEV;1316 goto out;1317 }1318 1319 if (!request_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS,1320 "applesmc")) {1321 ret = -ENXIO;1322 goto out;1323 }1324 1325 ret = platform_driver_register(&applesmc_driver);1326 if (ret)1327 goto out_region;1328 1329 pdev = platform_device_register_simple("applesmc", APPLESMC_DATA_PORT,1330 NULL, 0);1331 if (IS_ERR(pdev)) {1332 ret = PTR_ERR(pdev);1333 goto out_driver;1334 }1335 1336 /* create register cache */1337 ret = applesmc_init_smcreg();1338 if (ret)1339 goto out_device;1340 1341 ret = applesmc_create_nodes(info_group, 1);1342 if (ret)1343 goto out_smcreg;1344 1345 ret = applesmc_create_nodes(fan_group, smcreg.fan_count);1346 if (ret)1347 goto out_info;1348 1349 ret = applesmc_create_nodes(temp_group, smcreg.index_count);1350 if (ret)1351 goto out_fans;1352 1353 ret = applesmc_create_accelerometer();1354 if (ret)1355 goto out_temperature;1356 1357 ret = applesmc_create_light_sensor();1358 if (ret)1359 goto out_accelerometer;1360 1361 ret = applesmc_create_key_backlight();1362 if (ret)1363 goto out_light_sysfs;1364 1365 hwmon_dev = hwmon_device_register(&pdev->dev);1366 if (IS_ERR(hwmon_dev)) {1367 ret = PTR_ERR(hwmon_dev);1368 goto out_light_ledclass;1369 }1370 1371 return 0;1372 1373out_light_ledclass:1374 applesmc_release_key_backlight();1375out_light_sysfs:1376 applesmc_release_light_sensor();1377out_accelerometer:1378 applesmc_release_accelerometer();1379out_temperature:1380 applesmc_destroy_nodes(temp_group);1381out_fans:1382 applesmc_destroy_nodes(fan_group);1383out_info:1384 applesmc_destroy_nodes(info_group);1385out_smcreg:1386 applesmc_destroy_smcreg();1387out_device:1388 platform_device_unregister(pdev);1389out_driver:1390 platform_driver_unregister(&applesmc_driver);1391out_region:1392 release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);1393out:1394 pr_warn("driver init failed (ret=%d)!\n", ret);1395 return ret;1396}1397 1398static void __exit applesmc_exit(void)1399{1400 hwmon_device_unregister(hwmon_dev);1401 applesmc_release_key_backlight();1402 applesmc_release_light_sensor();1403 applesmc_release_accelerometer();1404 applesmc_destroy_nodes(temp_group);1405 applesmc_destroy_nodes(fan_group);1406 applesmc_destroy_nodes(info_group);1407 applesmc_destroy_smcreg();1408 platform_device_unregister(pdev);1409 platform_driver_unregister(&applesmc_driver);1410 release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);1411}1412 1413module_init(applesmc_init);1414module_exit(applesmc_exit);1415 1416MODULE_AUTHOR("Nicolas Boichat");1417MODULE_DESCRIPTION("Apple SMC");1418MODULE_LICENSE("GPL v2");1419MODULE_DEVICE_TABLE(dmi, applesmc_whitelist);1420