diff -pruN linux/drivers/hwmon.vanilla/Kconfig linux/drivers/hwmon/Kconfig --- linux/drivers/hwmon.vanilla/Kconfig 2006-07-07 14:50:32.000000000 +0200 +++ linux/drivers/hwmon/Kconfig 2006-07-11 11:34:20.000000000 +0200 @@ -450,6 +450,26 @@ config SENSORS_HDAPS Say Y here if you have an applicable laptop and want to experience the awesome power of hdaps. +config SENSORS_APPLESMC + tristate "Apple SMC (Motion sensor, light sensor, keyboard backlight)" + depends on HWMON && INPUT && X86 + default n + help + This driver provides support for the Apple System Management + Controller, which provides an accelerometer (Apple Sudden Motion + Sensor), light sensors, and keyboard backlight control. + + Only Intel-based Apple's laptops are supported (MacBook Pro, MacBook). + + The accelerometer and light sensors data is readable via sysfs, and + the keyboard backlight is writable. + + This driver also provides an absolute input class device, allowing + the laptop to act as a pinball machine-esque joystick. + + Say Y here if you have an applicable laptop and want to experience + the awesome power of applesmc. + config HWMON_DEBUG_CHIP bool "Hardware Monitoring Chip debugging messages" depends on HWMON diff -pruN linux/drivers/hwmon.vanilla/Makefile linux/drivers/hwmon/Makefile --- linux/drivers/hwmon.vanilla/Makefile 2006-07-07 14:50:32.000000000 +0200 +++ linux/drivers/hwmon/Makefile 2006-07-10 17:37:16.000000000 +0200 @@ -16,6 +16,7 @@ obj-$(CONFIG_SENSORS_ADM1025) += adm1025 obj-$(CONFIG_SENSORS_ADM1026) += adm1026.o obj-$(CONFIG_SENSORS_ADM1031) += adm1031.o obj-$(CONFIG_SENSORS_ADM9240) += adm9240.o +obj-$(CONFIG_SENSORS_APPLESMC) += applesmc.o obj-$(CONFIG_SENSORS_ATXP1) += atxp1.o obj-$(CONFIG_SENSORS_DS1621) += ds1621.o obj-$(CONFIG_SENSORS_F71805F) += f71805f.o diff -pruN linux/drivers/hwmon.vanilla/applesmc.c linux/drivers/hwmon/applesmc.c --- linux/drivers/hwmon.vanilla/applesmc.c 1970-01-01 01:00:00.000000000 +0100 +++ linux/drivers/hwmon/applesmc.c 2006-07-11 11:26:12.000000000 +0200 @@ -0,0 +1,572 @@ +/* + * drivers/hwmon/applesmc.c - driver for Apple's SMC (various sensors) + * + * Copyright (C) 2006 Nicolas Boichat + * + * Based on hdaps.c driver : + * Copyright (C) 2005 Robert Love + * Copyright (C) 2005 Jesper Juhl + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License v2 as published by the + * Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +/* data port used by apple SMC */ +#define APPLESMC_DATA_PORT 0x300 +/* command/status port used by apple SMC */ +#define APPLESMC_CMD_PORT 0x304 + +#define APPLESMC_NR_PORTS 5 /* 0x300-0x304 */ + +#define APPLESMC_STATUS_MASK 0x0f +#define APPLESMC_READ_CMD 0x10 +#define APPLESMC_WRITE_CMD 0x11 + +#define LIGHT_SENSOR_LEFT_KEY "ALV0" //0x414c5630, r-o length 6 +#define LIGHT_SENSOR_RIGHT_KEY "ALV1" //0x414c5631, r-o length 6 +#define BACKLIGHT_KEY "LKSB" //0x4c4b5342, w-o +#define CLAMSHELL_KEY "MSLD" //0x4d534c44, r-o length 1 (unused) +#define MOTION_SENSOR_X_KEY "MO_X" //0x4d4f5f58, r-o length 2 +#define MOTION_SENSOR_Y_KEY "MO_Y" //0x4d4f5f58, r-o length 2 +#define MOTION_SENSOR_Z_KEY "MO_Z" //0x4d4f5f58, r-o length 2 +#define MOTION_SENSOR_KEY "MOCN" //0x4d4f434e, r/w length 2 + +#define INIT_TIMEOUT_MSECS 5000 /* wait up to 5s for device init ... */ +#define INIT_WAIT_MSECS 50 /* ... in 50ms increments */ + +#define APPLESMC_POLL_PERIOD (HZ/20) /* poll for input every 1/20s */ +#define APPLESMC_INPUT_FUZZ 4 /* input event threshold */ +#define APPLESMC_INPUT_FLAT 4 + +#define SENSOR_X 0 +#define SENSOR_Y 1 +#define SENSOR_Z 2 + +static int debug = 0; +static struct platform_device *pdev; +static s16 rest_x; +static s16 rest_y; +static struct timer_list applesmc_timer; +static struct input_dev *applesmc_idev; + +/* Indicate whether this computer has light sensors and keyboard backlight. */ +static unsigned int applesmc_light = 0; + +#if 0 +static unsigned int hdaps_invert; +static u8 km_activity; +#endif + +static DECLARE_MUTEX(applesmc_sem); + +/* + * __wait_status - Wait up to 1000us for the status port to get a certain value + * (masked with 0x0f), returning zero if the value is obtained. Callers must + * hold applesmc_sem. + */ +static int __wait_status(u8 val) +{ + unsigned int i; + + val = val & APPLESMC_STATUS_MASK; + + for (i = 0; i < 100; i++) { + if ((inb(APPLESMC_CMD_PORT) & APPLESMC_STATUS_MASK) == val) + return 0; + udelay(10); + } + + printk(KERN_WARNING "applesmc: wait status failed: %x != %x\n", + val, inb(APPLESMC_CMD_PORT)); + + return -EIO; +} + +/* + * applesmc_read_key - reads len bytes from a given key, and put them in buffer. + * Returns zero on success or a negative error on failure. Callers must + * hold applesmc_sem. + */ +static int applesmc_read_key(char* key, u8* buffer, u8 len) +{ + int ret = -EIO; + int i; + + outb(APPLESMC_READ_CMD, APPLESMC_CMD_PORT); + if (__wait_status(0x0c)) + goto out; + + for (i = 0; i < 4; i++) { + outb(key[i], APPLESMC_DATA_PORT); + if (__wait_status(0x04)) + goto out; + } + if (debug) printk(KERN_DEBUG "<%s", key); + + outb(len, APPLESMC_DATA_PORT); + if (debug) printk(KERN_DEBUG ">%x", len); + + for (i = 0; i < len; i++) { + if (__wait_status(0x05)) + goto out; + buffer[i] = inb(APPLESMC_DATA_PORT); + if (debug) printk(KERN_DEBUG "<%x", buffer[i]); + } + if (debug) printk(KERN_DEBUG "\n"); + ret = 0; + +out: + return ret; +} + +/* + * applesmc_write_key - writes len bytes from buffer to a given key. + * Returns zero on success or a negative error on failure. Callers must + * hold applesmc_sem. + */ +static int applesmc_write_key(char* key, u8* buffer, u8 len) +{ + int ret = -EIO; + int i; + + outb(APPLESMC_WRITE_CMD, APPLESMC_CMD_PORT); + if (__wait_status(0x0c)) + goto out; + + for (i = 0; i < 4; i++) { + outb(key[i], APPLESMC_DATA_PORT); + if (__wait_status(0x04)) + goto out; + } + + outb(len, APPLESMC_DATA_PORT); + + for (i = 0; i < len; i++) { + if (__wait_status(0x04)) + goto out; + outb(buffer[i], APPLESMC_DATA_PORT); + } + + ret = 0; +out: + return ret; +} + +/* + * applesmc_read_motion_sensor - Read motion sensor (X, Y or Z). Callers must + * hold applesmc_sem. + */ +static int applesmc_read_motion_sensor(int index, s16* value) { + u8 buffer[2]; + int ret; + + switch (index) { + case SENSOR_X: + ret = applesmc_read_key(MOTION_SENSOR_X_KEY, buffer, 2); + break; + case SENSOR_Y: + ret = applesmc_read_key(MOTION_SENSOR_Y_KEY, buffer, 2); + break; + case SENSOR_Z: + ret = applesmc_read_key(MOTION_SENSOR_Z_KEY, buffer, 2); + break; + default: + ret = -EINVAL; + } + + *value = ((s16)buffer[0] << 8) | buffer[1]; + + return ret; +} + +/* + * applesmc_device_init - initialize the accelerometer. Returns zero on success + * and negative error code on failure. Can sleep. + */ +static int applesmc_device_init(void) +{ + int total, ret = -ENXIO; + u8 buffer[2]; + + down(&applesmc_sem); + + for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) { + if (debug) printk(KERN_DEBUG "applesmc try %d\n", total); + if (!applesmc_read_key(MOTION_SENSOR_KEY, buffer, 2) && + (buffer[0] != 0x00 || buffer[1] != 0x00)) { + if (total == INIT_TIMEOUT_MSECS) { + printk(KERN_DEBUG "applesmc: device has" + " already been initialized" + " (0x%02x, 0x%02x).\n", + buffer[0], buffer[1]); + } + else { + printk(KERN_DEBUG "applesmc: device" + " successfully initialized" + " (0x%02x, 0x%02x).\n", + buffer[0], buffer[1]); + } + ret = 0; + goto out; + } + buffer[0] = 0xe0; + buffer[1] = 0x00; + applesmc_write_key(MOTION_SENSOR_KEY, buffer, 2); + msleep(INIT_WAIT_MSECS); + } + + printk(KERN_WARNING "applesmc: failed to init the device\n"); + +out: + up(&applesmc_sem); + return ret; +} + + +/* Device model stuff */ +static int applesmc_probe(struct platform_device *dev) +{ + int ret; + + ret = applesmc_device_init(); + if (ret) + return ret; + + printk(KERN_INFO "applesmc: device successfully initialized.\n"); + return 0; +} + +static int applesmc_resume(struct platform_device *dev) +{ + return applesmc_device_init(); +} + +static struct platform_driver applesmc_driver = { + .probe = applesmc_probe, + .resume = applesmc_resume, + .driver = { + .name = "applesmc", + .owner = THIS_MODULE, + }, +}; + +/* + * applesmc_calibrate - Set our "resting" values. Callers must hold applesmc_sem. + */ +static void applesmc_calibrate(void) +{ + applesmc_read_motion_sensor(SENSOR_X, &rest_x); + applesmc_read_motion_sensor(SENSOR_Y, &rest_y); +} + +static void applesmc_mousedev_poll(unsigned long unused) +{ + s16 x, y; + + /* Cannot sleep. Try nonblockingly. If we fail, try again later. */ + if (down_trylock(&applesmc_sem)) { + mod_timer(&applesmc_timer,jiffies + APPLESMC_POLL_PERIOD); + return; + } + + if (applesmc_read_motion_sensor(SENSOR_X, &x)) + goto out; + if (applesmc_read_motion_sensor(SENSOR_Y, &y)) + goto out; + + + input_report_abs(applesmc_idev, ABS_X, x - rest_x); + input_report_abs(applesmc_idev, ABS_Y, y - rest_y); + input_sync(applesmc_idev); + +out: + mod_timer(&applesmc_timer, jiffies + APPLESMC_POLL_PERIOD); + + up(&applesmc_sem); +} + +/* Sysfs Files */ + +static ssize_t applesmc_position_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int ret; + s16 x, y, z; + + down(&applesmc_sem); + + ret = applesmc_read_motion_sensor(SENSOR_X, &x); + if (ret) + goto out; + ret = applesmc_read_motion_sensor(SENSOR_Y, &y); + if (ret) + goto out; + ret = applesmc_read_motion_sensor(SENSOR_Z, &z); + if (ret) + goto out; + +out: + up(&applesmc_sem); + if (ret) + return ret; + else + return sprintf(buf, "(%d,%d,%d)\n", x, y, z); +} + +static ssize_t applesmc_light_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int ret; + u8 left = 0, right = 0; + u8 buffer[6]; + + down(&applesmc_sem); + + ret = applesmc_read_key(LIGHT_SENSOR_LEFT_KEY, buffer, 6); + left = buffer[2]; + if (ret) + goto out; + ret = applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY, buffer, 6); + right = buffer[2]; + if (ret) + goto out; + +out: + up(&applesmc_sem); + if (ret) + return ret; + else + return sprintf(buf, "(%d,%d)\n", left, right); +} + +static ssize_t applesmc_keyboard_backlight_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + int ret; + u8 buffer[2]; + long val = simple_strtol(buf, NULL, 10); + + if (val < 0 || val > 255) + return EINVAL; + + down(&applesmc_sem); + buffer[0] = val; + buffer[1] = 0x00; + ret = applesmc_write_key(BACKLIGHT_KEY, buffer, 2); + up(&applesmc_sem); + + if (ret) + return ret; + + return count; +} + +static ssize_t applesmc_calibrate_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + return sprintf(buf, "(%d,%d)\n", rest_x, rest_y); +} + +static ssize_t applesmc_calibrate_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + down(&applesmc_sem); + applesmc_calibrate(); + up(&applesmc_sem); + + return count; +} + +static DEVICE_ATTR(position, 0444, applesmc_position_show, NULL); +static DEVICE_ATTR(light, 0444, applesmc_light_show, NULL); +static DEVICE_ATTR(keyboard_backlight, 0220, NULL, applesmc_keyboard_backlight_store); +static DEVICE_ATTR(calibrate, 0644, applesmc_calibrate_show,applesmc_calibrate_store); + +static struct attribute *applesmc_light_attributes[] = { + &dev_attr_position.attr, + &dev_attr_light.attr, + &dev_attr_keyboard_backlight.attr, + &dev_attr_calibrate.attr, + NULL, +}; + +static struct attribute_group applesmc_light_attribute_group = { + .attrs = applesmc_light_attributes, +}; + +static struct attribute *applesmc_attributes[] = { + &dev_attr_position.attr, + &dev_attr_calibrate.attr, + NULL, +}; + +static struct attribute_group applesmc_attribute_group = { + .attrs = applesmc_attributes, +}; + + +/* Module stuff */ + +/* applesmc_light_dmi_match - found a match. return one, short-circuiting the hunt. */ +static int applesmc_light_dmi_match(struct dmi_system_id *id) +{ + applesmc_light = 1; + printk(KERN_INFO "applesmc: %s detected (model with light" + " sensors and backlight).\n", id->ident); + return 1; +} + +/* applesmc_dmi_match - found a match. return one, short-circuiting the hunt. */ +static int applesmc_dmi_match(struct dmi_system_id *id) +{ + printk(KERN_INFO "applesmc: %s detected (model without light" + " sensors and backlight).\n", id->ident); + return 1; +} + +#define APPLESMC_DMI_MATCH(model) { \ + .ident = "Apple " model, \ + .callback = applesmc_dmi_match, \ + .matches = { \ + DMI_MATCH(DMI_BOARD_VENDOR, "Apple"), \ + DMI_MATCH(DMI_PRODUCT_NAME, model) \ + } \ +} + +#define APPLESMC_LIGHT_DMI_MATCH(model) { \ + .ident = "Apple " model, \ + .callback = applesmc_light_dmi_match, \ + .matches = { \ + DMI_MATCH(DMI_BOARD_VENDOR, "Apple"), \ + DMI_MATCH(DMI_PRODUCT_NAME, model) \ + } \ +} + +static int __init applesmc_init(void) +{ + int ret; + + /* Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1". + * So we need to put MacBookPro before MacBook... */ + struct dmi_system_id applesmc_whitelist[] = { + APPLESMC_LIGHT_DMI_MATCH("MacBookPro"), + APPLESMC_DMI_MATCH("MacBook"), + { .ident = NULL } + }; + + if (!dmi_check_system(applesmc_whitelist)) { + printk(KERN_WARNING "applesmc: supported laptop not found!\n"); + ret = -ENODEV; + goto out; + } + + if (!request_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS, + "applesmc")) { + ret = -ENXIO; + goto out; + } + + ret = platform_driver_register(&applesmc_driver); + if (ret) + goto out_region; + + pdev = platform_device_register_simple("applesmc", -1, NULL, 0); + if (IS_ERR(pdev)) { + ret = PTR_ERR(pdev); + goto out_driver; + } + + if (applesmc_light) + ret = sysfs_create_group(&pdev->dev.kobj, + &applesmc_light_attribute_group); + else + ret = sysfs_create_group(&pdev->dev.kobj, + &applesmc_attribute_group); + if (ret) + goto out_device; + + applesmc_idev = input_allocate_device(); + if (!applesmc_idev) { + ret = -ENOMEM; + goto out_group; + } + + /* initial calibrate for the input device */ + applesmc_calibrate(); + + /* initialize the input class */ + applesmc_idev->name = "applesmc"; + applesmc_idev->cdev.dev = &pdev->dev; + applesmc_idev->evbit[0] = BIT(EV_ABS); + input_set_abs_params(applesmc_idev, ABS_X, + -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT); + input_set_abs_params(applesmc_idev, ABS_Y, + -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT); + + input_register_device(applesmc_idev); + + /* start up our timer for the input device */ + init_timer(&applesmc_timer); + applesmc_timer.function = applesmc_mousedev_poll; + applesmc_timer.expires = jiffies + APPLESMC_POLL_PERIOD; + add_timer(&applesmc_timer); + + printk(KERN_INFO "applesmc: driver successfully loaded.\n"); + return 0; + +out_group: + sysfs_remove_group(&pdev->dev.kobj, &applesmc_attribute_group); +out_device: + platform_device_unregister(pdev); +out_driver: + platform_driver_unregister(&applesmc_driver); +out_region: + release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS); +out: + printk(KERN_WARNING "applesmc: driver init failed (ret=%d)!\n", ret); + return ret; +} + +static void __exit applesmc_exit(void) +{ + del_timer_sync(&applesmc_timer); + input_unregister_device(applesmc_idev); + if (applesmc_light) + sysfs_remove_group(&pdev->dev.kobj, + &applesmc_light_attribute_group); + else + sysfs_remove_group(&pdev->dev.kobj, &applesmc_attribute_group); + platform_device_unregister(pdev); + platform_driver_unregister(&applesmc_driver); + release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS); + + printk(KERN_INFO "applesmc: driver unloaded.\n"); +} + +module_init(applesmc_init); +module_exit(applesmc_exit); + +MODULE_AUTHOR("Nicolas Boichat"); +MODULE_DESCRIPTION("Apple SMC"); +MODULE_LICENSE("GPL v2");