?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
smsc911x: Add spinlocks around registers access
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / hwmon / applesmc.c
blobf085c18d2905a602d465ef01a8d08b2a29467c28
1 /*
2 * drivers/hwmon/applesmc.c - driver for Apple's SMC (accelerometer, temperature
3 * sensors, fan control, keyboard backlight control) used in Intel-based Apple
4 * computers.
5 *
6 * Copyright (C) 2007 Nicolas Boichat <nicolas@boichat.ch>
7 *
8 * Based on hdaps.c driver:
9 * Copyright (C) 2005 Robert Love <rml@novell.com>
10 * Copyright (C) 2005 Jesper Juhl <jesper.juhl@gmail.com>
11 *
12 * Fan control based on smcFanControl:
13 * Copyright (C) 2006 Hendrik Holtmann <holtmann@mac.com>
14 *
15 * This program is free software; you can redistribute it and/or modify it
16 * under the terms of the GNU General Public License v2 as published by the
17 * Free Software Foundation.
18 *
19 * This program is distributed in the hope that it will be useful, but WITHOUT
20 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
21 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
22 * more details.
23 *
24 * You should have received a copy of the GNU General Public License along with
25 * this program; if not, write to the Free Software Foundation, Inc.,
26 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
27 */
28
29 #include <linux/delay.h>
30 #include <linux/platform_device.h>
31 #include <linux/input-polldev.h>
32 #include <linux/kernel.h>
33 #include <linux/module.h>
34 #include <linux/timer.h>
35 #include <linux/dmi.h>
36 #include <linux/mutex.h>
37 #include <linux/hwmon-sysfs.h>
38 #include <linux/io.h>
39 #include <linux/leds.h>
40 #include <linux/hwmon.h>
41 #include <linux/workqueue.h>
42
43 /* data port used by Apple SMC */
44 #define APPLESMC_DATA_PORT 0x300
45 /* command/status port used by Apple SMC */
46 #define APPLESMC_CMD_PORT 0x304
47
48 #define APPLESMC_NR_PORTS 32 /* 0x300-0x31f */
49
50 #define APPLESMC_MAX_DATA_LENGTH 32
51
52 #define APPLESMC_MIN_WAIT 0x0040
53 #define APPLESMC_MAX_WAIT 0x8000
54
55 #define APPLESMC_STATUS_MASK 0x0f
56 #define APPLESMC_READ_CMD 0x10
57 #define APPLESMC_WRITE_CMD 0x11
58 #define APPLESMC_GET_KEY_BY_INDEX_CMD 0x12
59 #define APPLESMC_GET_KEY_TYPE_CMD 0x13
60
61 #define KEY_COUNT_KEY "#KEY" /* r-o ui32 */
62
63 #define LIGHT_SENSOR_LEFT_KEY "ALV0" /* r-o {alv (6-10 bytes) */
64 #define LIGHT_SENSOR_RIGHT_KEY "ALV1" /* r-o {alv (6-10 bytes) */
65 #define BACKLIGHT_KEY "LKSB" /* w-o {lkb (2 bytes) */
66
67 #define CLAMSHELL_KEY "MSLD" /* r-o ui8 (unused) */
68
69 #define MOTION_SENSOR_X_KEY "MO_X" /* r-o sp78 (2 bytes) */
70 #define MOTION_SENSOR_Y_KEY "MO_Y" /* r-o sp78 (2 bytes) */
71 #define MOTION_SENSOR_Z_KEY "MO_Z" /* r-o sp78 (2 bytes) */
72 #define MOTION_SENSOR_KEY "MOCN" /* r/w ui16 */
73
74 #define FANS_COUNT "FNum" /* r-o ui8 */
75 #define FANS_MANUAL "FS! " /* r-w ui16 */
76 #define FAN_ACTUAL_SPEED "F0Ac" /* r-o fpe2 (2 bytes) */
77 #define FAN_MIN_SPEED "F0Mn" /* r-o fpe2 (2 bytes) */
78 #define FAN_MAX_SPEED "F0Mx" /* r-o fpe2 (2 bytes) */
79 #define FAN_SAFE_SPEED "F0Sf" /* r-o fpe2 (2 bytes) */
80 #define FAN_TARGET_SPEED "F0Tg" /* r-w fpe2 (2 bytes) */
81 #define FAN_POSITION "F0ID" /* r-o char[16] */
82
83 /*
84 * Temperature sensors keys (sp78 - 2 bytes).
85 */
86 static const char *temperature_sensors_sets[][41] = {
87 /* Set 0: Macbook Pro */
88 { "TA0P", "TB0T", "TC0D", "TC0P", "TG0H", "TG0P", "TG0T", "Th0H",
89 "Th1H", "Tm0P", "Ts0P", "Ts1P", NULL },
90 /* Set 1: Macbook2 set */
91 { "TB0T", "TC0D", "TC0P", "TM0P", "TN0P", "TN1P", "TTF0", "Th0H",
92 "Th0S", "Th1H", NULL },
93 /* Set 2: Macbook set */
94 { "TB0T", "TC0D", "TC0P", "TM0P", "TN0P", "TN1P", "Th0H", "Th0S",
95 "Th1H", "Ts0P", NULL },
96 /* Set 3: Macmini set */
97 { "TC0D", "TC0P", NULL },
98 /* Set 4: Mac Pro (2 x Quad-Core) */
99 { "TA0P", "TCAG", "TCAH", "TCBG", "TCBH", "TC0C", "TC0D", "TC0P",
100 "TC1C", "TC1D", "TC2C", "TC2D", "TC3C", "TC3D", "THTG", "TH0P",
101 "TH1P", "TH2P", "TH3P", "TMAP", "TMAS", "TMBS", "TM0P", "TM0S",
102 "TM1P", "TM1S", "TM2P", "TM2S", "TM3S", "TM8P", "TM8S", "TM9P",
103 "TM9S", "TN0H", "TS0C", NULL },
104 /* Set 5: iMac */
105 { "TC0D", "TA0P", "TG0P", "TG0D", "TG0H", "TH0P", "Tm0P", "TO0P",
106 "Tp0C", NULL },
107 /* Set 6: Macbook3 set */
108 { "TB0T", "TC0D", "TC0P", "TM0P", "TN0P", "TTF0", "TW0P", "Th0H",
109 "Th0S", "Th1H", NULL },
110 /* Set 7: Macbook Air */
111 { "TB0T", "TB1S", "TB1T", "TB2S", "TB2T", "TC0D", "TC0P", "TCFP",
112 "TTF0", "TW0P", "Th0H", "Tp0P", "TpFP", "Ts0P", "Ts0S", NULL },
113 /* Set 8: Macbook Pro 4,1 (Penryn) */
114 { "TB0T", "TC0D", "TC0P", "TG0D", "TG0H", "TTF0", "TW0P", "Th0H",
115 "Th1H", "Th2H", "Tm0P", "Ts0P", NULL },
116 /* Set 9: Macbook Pro 3,1 (Santa Rosa) */
117 { "TALP", "TB0T", "TC0D", "TC0P", "TG0D", "TG0H", "TTF0", "TW0P",
118 "Th0H", "Th1H", "Th2H", "Tm0P", "Ts0P", NULL },
119 /* Set 10: iMac 5,1 */
120 { "TA0P", "TC0D", "TC0P", "TG0D", "TH0P", "TO0P", "Tm0P", NULL },
121 /* Set 11: Macbook 5,1 */
122 { "TB0T", "TB1T", "TB2T", "TB3T", "TC0D", "TC0P", "TN0D", "TN0P",
123 "TTF0", "Th0H", "Th1H", "ThFH", "Ts0P", "Ts0S", NULL },
124 /* Set 12: Macbook Pro 5,1 */
125 { "TB0T", "TB1T", "TB2T", "TB3T", "TC0D", "TC0F", "TC0P", "TG0D",
126 "TG0F", "TG0H", "TG0P", "TG0T", "TG1H", "TN0D", "TN0P", "TTF0",
127 "Th2H", "Tm0P", "Ts0P", "Ts0S", NULL },
128 /* Set 13: iMac 8,1 */
129 { "TA0P", "TC0D", "TC0H", "TC0P", "TG0D", "TG0H", "TG0P", "TH0P",
130 "TL0P", "TO0P", "TW0P", "Tm0P", "Tp0P", NULL },
131 /* Set 14: iMac 6,1 */
132 { "TA0P", "TC0D", "TC0H", "TC0P", "TG0D", "TG0H", "TG0P", "TH0P",
133 "TO0P", "Tp0P", NULL },
134 /* Set 15: MacBook Air 2,1 */
135 { "TB0T", "TB1S", "TB1T", "TB2S", "TB2T", "TC0D", "TN0D", "TTF0",
136 "TV0P", "TVFP", "TW0P", "Th0P", "Tp0P", "Tp1P", "TpFP", "Ts0P",
137 "Ts0S", NULL },
138 /* Set 16: Mac Pro 3,1 (2 x Quad-Core) */
139 { "TA0P", "TCAG", "TCAH", "TCBG", "TCBH", "TC0C", "TC0D", "TC0P",
140 "TC1C", "TC1D", "TC2C", "TC2D", "TC3C", "TC3D", "TH0P", "TH1P",
141 "TH2P", "TH3P", "TMAP", "TMAS", "TMBS", "TM0P", "TM0S", "TM1P",
142 "TM1S", "TM2P", "TM2S", "TM3S", "TM8P", "TM8S", "TM9P", "TM9S",
143 "TN0C", "TN0D", "TN0H", "TS0C", "Tp0C", "Tp1C", "Tv0S", "Tv1S",
144 NULL },
145 /* Set 17: iMac 9,1 */
146 { "TA0P", "TC0D", "TC0H", "TC0P", "TG0D", "TG0H", "TH0P", "TL0P",
147 "TN0D", "TN0H", "TN0P", "TO0P", "Tm0P", "Tp0P", NULL },
148 /* Set 18: MacBook Pro 2,2 */
149 { "TB0T", "TC0D", "TC0P", "TG0H", "TG0P", "TG0T", "TM0P", "TTF0",
150 "Th0H", "Th1H", "Tm0P", "Ts0P", NULL },
151 };
152
153 /* List of keys used to read/write fan speeds */
154 static const char* fan_speed_keys[] = {
155 FAN_ACTUAL_SPEED,
156 FAN_MIN_SPEED,
157 FAN_MAX_SPEED,
158 FAN_SAFE_SPEED,
159 FAN_TARGET_SPEED
160 };
161
162 #define INIT_TIMEOUT_MSECS 5000 /* wait up to 5s for device init ... */
163 #define INIT_WAIT_MSECS 50 /* ... in 50ms increments */
164
165 #define APPLESMC_POLL_INTERVAL 50 /* msecs */
166 #define APPLESMC_INPUT_FUZZ 4 /* input event threshold */
167 #define APPLESMC_INPUT_FLAT 4
168
169 #define SENSOR_X 0
170 #define SENSOR_Y 1
171 #define SENSOR_Z 2
172
173 /* Structure to be passed to DMI_MATCH function */
174 struct dmi_match_data {
175 /* Indicates whether this computer has an accelerometer. */
176 int accelerometer;
177 /* Indicates whether this computer has light sensors and keyboard backlight. */
178 int light;
179 /* Indicates which temperature sensors set to use. */
180 int temperature_set;
181 };
182
183 static const int debug;
184 static struct platform_device *pdev;
185 static s16 rest_x;
186 static s16 rest_y;
187 static u8 backlight_state[2];
188
189 static struct device *hwmon_dev;
190 static struct input_polled_dev *applesmc_idev;
191
192 /* Indicates whether this computer has an accelerometer. */
193 static unsigned int applesmc_accelerometer;
194
195 /* Indicates whether this computer has light sensors and keyboard backlight. */
196 static unsigned int applesmc_light;
197
198 /* The number of fans handled by the driver */
199 static unsigned int fans_handled;
200
201 /* Indicates which temperature sensors set to use. */
202 static unsigned int applesmc_temperature_set;
203
204 static DEFINE_MUTEX(applesmc_lock);
205
206 /*
207 * Last index written to key_at_index sysfs file, and value to use for all other
208 * key_at_index_* sysfs files.
209 */
210 static unsigned int key_at_index;
211
212 static struct workqueue_struct *applesmc_led_wq;
213
214 /*
215 * __wait_status - Wait up to 32ms for the status port to get a certain value
216 * (masked with 0x0f), returning zero if the value is obtained. Callers must
217 * hold applesmc_lock.
218 */
219 static int __wait_status(u8 val)
220 {
221 int us;
222
223 val = val & APPLESMC_STATUS_MASK;
224
225 for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) {
226 udelay(us);
227 if ((inb(APPLESMC_CMD_PORT) & APPLESMC_STATUS_MASK) == val) {
228 if (debug)
229 printk(KERN_DEBUG
230 "Waited %d us for status %x\n",
231 2 * us - APPLESMC_MIN_WAIT, val);
232 return 0;
233 }
234 }
235
236 printk(KERN_WARNING "applesmc: wait status failed: %x != %x\n",
237 val, inb(APPLESMC_CMD_PORT));
238
239 return -EIO;
240 }
241
242 /*
243 * special treatment of command port - on newer macbooks, it seems necessary
244 * to resend the command byte before polling the status again. Callers must
245 * hold applesmc_lock.
246 */
247 static int send_command(u8 cmd)
248 {
249 int us;
250 for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) {
251 outb(cmd, APPLESMC_CMD_PORT);
252 udelay(us);
253 if ((inb(APPLESMC_CMD_PORT) & APPLESMC_STATUS_MASK) == 0x0c)
254 return 0;
255 }
256 printk(KERN_WARNING "applesmc: command failed: %x -> %x\n",
257 cmd, inb(APPLESMC_CMD_PORT));
258 return -EIO;
259 }
260
261 /*
262 * applesmc_read_key - reads len bytes from a given key, and put them in buffer.
263 * Returns zero on success or a negative error on failure. Callers must
264 * hold applesmc_lock.
265 */
266 static int applesmc_read_key(const char* key, u8* buffer, u8 len)
267 {
268 int i;
269
270 if (len > APPLESMC_MAX_DATA_LENGTH) {
271 printk(KERN_ERR "applesmc_read_key: cannot read more than "
272 "%d bytes\n", APPLESMC_MAX_DATA_LENGTH);
273 return -EINVAL;
274 }
275
276 if (send_command(APPLESMC_READ_CMD))
277 return -EIO;
278
279 for (i = 0; i < 4; i++) {
280 outb(key[i], APPLESMC_DATA_PORT);
281 if (__wait_status(0x04))
282 return -EIO;
283 }
284 if (debug)
285 printk(KERN_DEBUG "<%s", key);
286
287 outb(len, APPLESMC_DATA_PORT);
288 if (debug)
289 printk(KERN_DEBUG ">%x", len);
290
291 for (i = 0; i < len; i++) {
292 if (__wait_status(0x05))
293 return -EIO;
294 buffer[i] = inb(APPLESMC_DATA_PORT);
295 if (debug)
296 printk(KERN_DEBUG "<%x", buffer[i]);
297 }
298 if (debug)
299 printk(KERN_DEBUG "\n");
300
301 return 0;
302 }
303
304 /*
305 * applesmc_write_key - writes len bytes from buffer to a given key.
306 * Returns zero on success or a negative error on failure. Callers must
307 * hold applesmc_lock.
308 */
309 static int applesmc_write_key(const char* key, u8* buffer, u8 len)
310 {
311 int i;
312
313 if (len > APPLESMC_MAX_DATA_LENGTH) {
314 printk(KERN_ERR "applesmc_write_key: cannot write more than "
315 "%d bytes\n", APPLESMC_MAX_DATA_LENGTH);
316 return -EINVAL;
317 }
318
319 if (send_command(APPLESMC_WRITE_CMD))
320 return -EIO;
321
322 for (i = 0; i < 4; i++) {
323 outb(key[i], APPLESMC_DATA_PORT);
324 if (__wait_status(0x04))
325 return -EIO;
326 }
327
328 outb(len, APPLESMC_DATA_PORT);
329
330 for (i = 0; i < len; i++) {
331 if (__wait_status(0x04))
332 return -EIO;
333 outb(buffer[i], APPLESMC_DATA_PORT);
334 }
335
336 return 0;
337 }
338
339 /*
340 * applesmc_get_key_at_index - get key at index, and put the result in key
341 * (char[6]). Returns zero on success or a negative error on failure. Callers
342 * must hold applesmc_lock.
343 */
344 static int applesmc_get_key_at_index(int index, char* key)
345 {
346 int i;
347 u8 readkey[4];
348 readkey[0] = index >> 24;
349 readkey[1] = index >> 16;
350 readkey[2] = index >> 8;
351 readkey[3] = index;
352
353 if (send_command(APPLESMC_GET_KEY_BY_INDEX_CMD))
354 return -EIO;
355
356 for (i = 0; i < 4; i++) {
357 outb(readkey[i], APPLESMC_DATA_PORT);
358 if (__wait_status(0x04))
359 return -EIO;
360 }
361
362 outb(4, APPLESMC_DATA_PORT);
363
364 for (i = 0; i < 4; i++) {
365 if (__wait_status(0x05))
366 return -EIO;
367 key[i] = inb(APPLESMC_DATA_PORT);
368 }
369 key[4] = 0;
370
371 return 0;
372 }
373
374 /*
375 * applesmc_get_key_type - get key type, and put the result in type (char[6]).
376 * Returns zero on success or a negative error on failure. Callers must
377 * hold applesmc_lock.
378 */
379 static int applesmc_get_key_type(char* key, char* type)
380 {
381 int i;
382
383 if (send_command(APPLESMC_GET_KEY_TYPE_CMD))
384 return -EIO;
385
386 for (i = 0; i < 4; i++) {
387 outb(key[i], APPLESMC_DATA_PORT);
388 if (__wait_status(0x04))
389 return -EIO;
390 }
391
392 outb(6, APPLESMC_DATA_PORT);
393
394 for (i = 0; i < 6; i++) {
395 if (__wait_status(0x05))
396 return -EIO;
397 type[i] = inb(APPLESMC_DATA_PORT);
398 }
399 type[5] = 0;
400
401 return 0;
402 }
403
404 /*
405 * applesmc_read_motion_sensor - Read motion sensor (X, Y or Z). Callers must
406 * hold applesmc_lock.
407 */
408 static int applesmc_read_motion_sensor(int index, s16* value)
409 {
410 u8 buffer[2];
411 int ret;
412
413 switch (index) {
414 case SENSOR_X:
415 ret = applesmc_read_key(MOTION_SENSOR_X_KEY, buffer, 2);
416 break;
417 case SENSOR_Y:
418 ret = applesmc_read_key(MOTION_SENSOR_Y_KEY, buffer, 2);
419 break;
420 case SENSOR_Z:
421 ret = applesmc_read_key(MOTION_SENSOR_Z_KEY, buffer, 2);
422 break;
423 default:
424 ret = -EINVAL;
425 }
426
427 *value = ((s16)buffer[0] << 8) | buffer[1];
428
429 return ret;
430 }
431
432 /*
433 * applesmc_device_init - initialize the accelerometer. Returns zero on success
434 * and negative error code on failure. Can sleep.
435 */
436 static int applesmc_device_init(void)
437 {
438 int total, ret = -ENXIO;
439 u8 buffer[2];
440
441 if (!applesmc_accelerometer)
442 return 0;
443
444 mutex_lock(&applesmc_lock);
445
446 for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
447 if (debug)
448 printk(KERN_DEBUG "applesmc try %d\n", total);
449 if (!applesmc_read_key(MOTION_SENSOR_KEY, buffer, 2) &&
450 (buffer[0] != 0x00 || buffer[1] != 0x00)) {
451 if (total == INIT_TIMEOUT_MSECS) {
452 printk(KERN_DEBUG "applesmc: device has"
453 " already been initialized"
454 " (0x%02x, 0x%02x).\n",
455 buffer[0], buffer[1]);
456 } else {
457 printk(KERN_DEBUG "applesmc: device"
458 " successfully initialized"
459 " (0x%02x, 0x%02x).\n",
460 buffer[0], buffer[1]);
461 }
462 ret = 0;
463 goto out;
464 }
465 buffer[0] = 0xe0;
466 buffer[1] = 0x00;
467 applesmc_write_key(MOTION_SENSOR_KEY, buffer, 2);
468 msleep(INIT_WAIT_MSECS);
469 }
470
471 printk(KERN_WARNING "applesmc: failed to init the device\n");
472
473 out:
474 mutex_unlock(&applesmc_lock);
475 return ret;
476 }
477
478 /*
479 * applesmc_get_fan_count - get the number of fans. Callers must NOT hold
480 * applesmc_lock.
481 */
482 static int applesmc_get_fan_count(void)
483 {
484 int ret;
485 u8 buffer[1];
486
487 mutex_lock(&applesmc_lock);
488
489 ret = applesmc_read_key(FANS_COUNT, buffer, 1);
490
491 mutex_unlock(&applesmc_lock);
492 if (ret)
493 return ret;
494 else
495 return buffer[0];
496 }
497
498 /* Device model stuff */
499 static int applesmc_probe(struct platform_device *dev)
500 {
501 int ret;
502
503 ret = applesmc_device_init();
504 if (ret)
505 return ret;
506
507 printk(KERN_INFO "applesmc: device successfully initialized.\n");
508 return 0;
509 }
510
511 /* Synchronize device with memorized backlight state */
512 static int applesmc_pm_resume(struct device *dev)
513 {
514 mutex_lock(&applesmc_lock);
515 if (applesmc_light)
516 applesmc_write_key(BACKLIGHT_KEY, backlight_state, 2);
517 mutex_unlock(&applesmc_lock);
518 return 0;
519 }
520
521 /* Reinitialize device on resume from hibernation */
522 static int applesmc_pm_restore(struct device *dev)
523 {
524 int ret = applesmc_device_init();
525 if (ret)
526 return ret;
527 return applesmc_pm_resume(dev);
528 }
529
530 static const struct dev_pm_ops applesmc_pm_ops = {
531 .resume = applesmc_pm_resume,
532 .restore = applesmc_pm_restore,
533 };
534
535 static struct platform_driver applesmc_driver = {
536 .probe = applesmc_probe,
537 .driver = {
538 .name = "applesmc",
539 .owner = THIS_MODULE,
540 .pm = &applesmc_pm_ops,
541 },
542 };
543
544 /*
545 * applesmc_calibrate - Set our "resting" values. Callers must
546 * hold applesmc_lock.
547 */
548 static void applesmc_calibrate(void)
549 {
550 applesmc_read_motion_sensor(SENSOR_X, &rest_x);
551 applesmc_read_motion_sensor(SENSOR_Y, &rest_y);
552 rest_x = -rest_x;
553 }
554
555 static void applesmc_idev_poll(struct input_polled_dev *dev)
556 {
557 struct input_dev *idev = dev->input;
558 s16 x, y;
559
560 mutex_lock(&applesmc_lock);
561
562 if (applesmc_read_motion_sensor(SENSOR_X, &x))
563 goto out;
564 if (applesmc_read_motion_sensor(SENSOR_Y, &y))
565 goto out;
566
567 x = -x;
568 input_report_abs(idev, ABS_X, x - rest_x);
569 input_report_abs(idev, ABS_Y, y - rest_y);
570 input_sync(idev);
571
572 out:
573 mutex_unlock(&applesmc_lock);
574 }
575
576 /* Sysfs Files */
577
578 static ssize_t applesmc_name_show(struct device *dev,
579 struct device_attribute *attr, char *buf)
580 {
581 return snprintf(buf, PAGE_SIZE, "applesmc\n");
582 }
583
584 static ssize_t applesmc_position_show(struct device *dev,
585 struct device_attribute *attr, char *buf)
586 {
587 int ret;
588 s16 x, y, z;
589
590 mutex_lock(&applesmc_lock);
591
592 ret = applesmc_read_motion_sensor(SENSOR_X, &x);
593 if (ret)
594 goto out;
595 ret = applesmc_read_motion_sensor(SENSOR_Y, &y);
596 if (ret)
597 goto out;
598 ret = applesmc_read_motion_sensor(SENSOR_Z, &z);
599 if (ret)
600 goto out;
601
602 out:
603 mutex_unlock(&applesmc_lock);
604 if (ret)
605 return ret;
606 else
607 return snprintf(buf, PAGE_SIZE, "(%d,%d,%d)\n", x, y, z);
608 }
609
610 static ssize_t applesmc_light_show(struct device *dev,
611 struct device_attribute *attr, char *sysfsbuf)
612 {
613 static int data_length;
614 int ret;
615 u8 left = 0, right = 0;
616 u8 buffer[10], query[6];
617
618 mutex_lock(&applesmc_lock);
619
620 if (!data_length) {
621 ret = applesmc_get_key_type(LIGHT_SENSOR_LEFT_KEY, query);
622 if (ret)
623 goto out;
624 data_length = clamp_val(query[0], 0, 10);
625 printk(KERN_INFO "applesmc: light sensor data length set to "
626 "%d\n", data_length);
627 }
628
629 ret = applesmc_read_key(LIGHT_SENSOR_LEFT_KEY, buffer, data_length);
630 /* newer macbooks report a single 10-bit bigendian value */
631 if (data_length == 10) {
632 left = be16_to_cpu(*(__be16 *)(buffer + 6)) >> 2;
633 goto out;
634 }
635 left = buffer[2];
636 if (ret)
637 goto out;
638 ret = applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY, buffer, data_length);
639 right = buffer[2];
640
641 out:
642 mutex_unlock(&applesmc_lock);
643 if (ret)
644 return ret;
645 else
646 return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", left, right);
647 }
648
649 /* Displays degree Celsius * 1000 */
650 static ssize_t applesmc_show_temperature(struct device *dev,
651 struct device_attribute *devattr, char *sysfsbuf)
652 {
653 int ret;
654 u8 buffer[2];
655 unsigned int temp;
656 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
657 const char* key =
658 temperature_sensors_sets[applesmc_temperature_set][attr->index];
659
660 mutex_lock(&applesmc_lock);
661
662 ret = applesmc_read_key(key, buffer, 2);
663 temp = buffer[0]*1000;
664 temp += (buffer[1] >> 6) * 250;
665
666 mutex_unlock(&applesmc_lock);
667
668 if (ret)
669 return ret;
670 else
671 return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", temp);
672 }
673
674 static ssize_t applesmc_show_fan_speed(struct device *dev,
675 struct device_attribute *attr, char *sysfsbuf)
676 {
677 int ret;
678 unsigned int speed = 0;
679 char newkey[5];
680 u8 buffer[2];
681 struct sensor_device_attribute_2 *sensor_attr =
682 to_sensor_dev_attr_2(attr);
683
684 newkey[0] = fan_speed_keys[sensor_attr->nr][0];
685 newkey[1] = '0' + sensor_attr->index;
686 newkey[2] = fan_speed_keys[sensor_attr->nr][2];
687 newkey[3] = fan_speed_keys[sensor_attr->nr][3];
688 newkey[4] = 0;
689
690 mutex_lock(&applesmc_lock);
691
692 ret = applesmc_read_key(newkey, buffer, 2);
693 speed = ((buffer[0] << 8 | buffer[1]) >> 2);
694
695 mutex_unlock(&applesmc_lock);
696 if (ret)
697 return ret;
698 else
699 return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", speed);
700 }
701
702 static ssize_t applesmc_store_fan_speed(struct device *dev,
703 struct device_attribute *attr,
704 const char *sysfsbuf, size_t count)
705 {
706 int ret;
707 u32 speed;
708 char newkey[5];
709 u8 buffer[2];
710 struct sensor_device_attribute_2 *sensor_attr =
711 to_sensor_dev_attr_2(attr);
712
713 speed = simple_strtoul(sysfsbuf, NULL, 10);
714
715 if (speed > 0x4000) /* Bigger than a 14-bit value */
716 return -EINVAL;
717
718 newkey[0] = fan_speed_keys[sensor_attr->nr][0];
719 newkey[1] = '0' + sensor_attr->index;
720 newkey[2] = fan_speed_keys[sensor_attr->nr][2];
721 newkey[3] = fan_speed_keys[sensor_attr->nr][3];
722 newkey[4] = 0;
723
724 mutex_lock(&applesmc_lock);
725
726 buffer[0] = (speed >> 6) & 0xff;
727 buffer[1] = (speed << 2) & 0xff;
728 ret = applesmc_write_key(newkey, buffer, 2);
729
730 mutex_unlock(&applesmc_lock);
731 if (ret)
732 return ret;
733 else
734 return count;
735 }
736
737 static ssize_t applesmc_show_fan_manual(struct device *dev,
738 struct device_attribute *devattr, char *sysfsbuf)
739 {
740 int ret;
741 u16 manual = 0;
742 u8 buffer[2];
743 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
744
745 mutex_lock(&applesmc_lock);
746
747 ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
748 manual = ((buffer[0] << 8 | buffer[1]) >> attr->index) & 0x01;
749
750 mutex_unlock(&applesmc_lock);
751 if (ret)
752 return ret;
753 else
754 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", manual);
755 }
756
757 static ssize_t applesmc_store_fan_manual(struct device *dev,
758 struct device_attribute *devattr,
759 const char *sysfsbuf, size_t count)
760 {
761 int ret;
762 u8 buffer[2];
763 u32 input;
764 u16 val;
765 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
766
767 input = simple_strtoul(sysfsbuf, NULL, 10);
768
769 mutex_lock(&applesmc_lock);
770
771 ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
772 val = (buffer[0] << 8 | buffer[1]);
773 if (ret)
774 goto out;
775
776 if (input)
777 val = val | (0x01 << attr->index);
778 else
779 val = val & ~(0x01 << attr->index);
780
781 buffer[0] = (val >> 8) & 0xFF;
782 buffer[1] = val & 0xFF;
783
784 ret = applesmc_write_key(FANS_MANUAL, buffer, 2);
785
786 out:
787 mutex_unlock(&applesmc_lock);
788 if (ret)
789 return ret;
790 else
791 return count;
792 }
793
794 static ssize_t applesmc_show_fan_position(struct device *dev,
795 struct device_attribute *attr, char *sysfsbuf)
796 {
797 int ret;
798 char newkey[5];
799 u8 buffer[17];
800 struct sensor_device_attribute_2 *sensor_attr =
801 to_sensor_dev_attr_2(attr);
802
803 newkey[0] = FAN_POSITION[0];
804 newkey[1] = '0' + sensor_attr->index;
805 newkey[2] = FAN_POSITION[2];
806 newkey[3] = FAN_POSITION[3];
807 newkey[4] = 0;
808
809 mutex_lock(&applesmc_lock);
810
811 ret = applesmc_read_key(newkey, buffer, 16);
812 buffer[16] = 0;
813
814 mutex_unlock(&applesmc_lock);
815 if (ret)
816 return ret;
817 else
818 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", buffer+4);
819 }
820
821 static ssize_t applesmc_calibrate_show(struct device *dev,
822 struct device_attribute *attr, char *sysfsbuf)
823 {
824 return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", rest_x, rest_y);
825 }
826
827 static ssize_t applesmc_calibrate_store(struct device *dev,
828 struct device_attribute *attr, const char *sysfsbuf, size_t count)
829 {
830 mutex_lock(&applesmc_lock);
831 applesmc_calibrate();
832 mutex_unlock(&applesmc_lock);
833
834 return count;
835 }
836
837 static void applesmc_backlight_set(struct work_struct *work)
838 {
839 mutex_lock(&applesmc_lock);
840 applesmc_write_key(BACKLIGHT_KEY, backlight_state, 2);
841 mutex_unlock(&applesmc_lock);
842 }
843 static DECLARE_WORK(backlight_work, &applesmc_backlight_set);
844
845 static void applesmc_brightness_set(struct led_classdev *led_cdev,
846 enum led_brightness value)
847 {
848 int ret;
849
850 backlight_state[0] = value;
851 ret = queue_work(applesmc_led_wq, &backlight_work);
852
853 if (debug && (!ret))
854 printk(KERN_DEBUG "applesmc: work was already on the queue.\n");
855 }
856
857 static ssize_t applesmc_key_count_show(struct device *dev,
858 struct device_attribute *attr, char *sysfsbuf)
859 {
860 int ret;
861 u8 buffer[4];
862 u32 count;
863
864 mutex_lock(&applesmc_lock);
865
866 ret = applesmc_read_key(KEY_COUNT_KEY, buffer, 4);
867 count = ((u32)buffer[0]<<24) + ((u32)buffer[1]<<16) +
868 ((u32)buffer[2]<<8) + buffer[3];
869
870 mutex_unlock(&applesmc_lock);
871 if (ret)
872 return ret;
873 else
874 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", count);
875 }
876
877 static ssize_t applesmc_key_at_index_read_show(struct device *dev,
878 struct device_attribute *attr, char *sysfsbuf)
879 {
880 char key[5];
881 char info[6];
882 int ret;
883
884 mutex_lock(&applesmc_lock);
885
886 ret = applesmc_get_key_at_index(key_at_index, key);
887
888 if (ret || !key[0]) {
889 mutex_unlock(&applesmc_lock);
890
891 return -EINVAL;
892 }
893
894 ret = applesmc_get_key_type(key, info);
895
896 if (ret) {
897 mutex_unlock(&applesmc_lock);
898
899 return ret;
900 }
901
902 /*
903 * info[0] maximum value (APPLESMC_MAX_DATA_LENGTH) is much lower than
904 * PAGE_SIZE, so we don't need any checks before writing to sysfsbuf.
905 */
906 ret = applesmc_read_key(key, sysfsbuf, info[0]);
907
908 mutex_unlock(&applesmc_lock);
909
910 if (!ret) {
911 return info[0];
912 } else {
913 return ret;
914 }
915 }
916
917 static ssize_t applesmc_key_at_index_data_length_show(struct device *dev,
918 struct device_attribute *attr, char *sysfsbuf)
919 {
920 char key[5];
921 char info[6];
922 int ret;
923
924 mutex_lock(&applesmc_lock);
925
926 ret = applesmc_get_key_at_index(key_at_index, key);
927
928 if (ret || !key[0]) {
929 mutex_unlock(&applesmc_lock);
930
931 return -EINVAL;
932 }
933
934 ret = applesmc_get_key_type(key, info);
935
936 mutex_unlock(&applesmc_lock);
937
938 if (!ret)
939 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", info[0]);
940 else
941 return ret;
942 }
943
944 static ssize_t applesmc_key_at_index_type_show(struct device *dev,
945 struct device_attribute *attr, char *sysfsbuf)
946 {
947 char key[5];
948 char info[6];
949 int ret;
950
951 mutex_lock(&applesmc_lock);
952
953 ret = applesmc_get_key_at_index(key_at_index, key);
954
955 if (ret || !key[0]) {
956 mutex_unlock(&applesmc_lock);
957
958 return -EINVAL;
959 }
960
961 ret = applesmc_get_key_type(key, info);
962
963 mutex_unlock(&applesmc_lock);
964
965 if (!ret)
966 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", info+1);
967 else
968 return ret;
969 }
970
971 static ssize_t applesmc_key_at_index_name_show(struct device *dev,
972 struct device_attribute *attr, char *sysfsbuf)
973 {
974 char key[5];
975 int ret;
976
977 mutex_lock(&applesmc_lock);
978
979 ret = applesmc_get_key_at_index(key_at_index, key);
980
981 mutex_unlock(&applesmc_lock);
982
983 if (!ret && key[0])
984 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", key);
985 else
986 return -EINVAL;
987 }
988
989 static ssize_t applesmc_key_at_index_show(struct device *dev,
990 struct device_attribute *attr, char *sysfsbuf)
991 {
992 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", key_at_index);
993 }
994
995 static ssize_t applesmc_key_at_index_store(struct device *dev,
996 struct device_attribute *attr, const char *sysfsbuf, size_t count)
997 {
998 mutex_lock(&applesmc_lock);
999
1000 key_at_index = simple_strtoul(sysfsbuf, NULL, 10);
1001
1002 mutex_unlock(&applesmc_lock);
1003
1004 return count;
1005 }
1006
1007 static struct led_classdev applesmc_backlight = {
1008 .name = "smc::kbd_backlight",
1009 .default_trigger = "nand-disk",
1010 .brightness_set = applesmc_brightness_set,
1011 };
1012
1013 static DEVICE_ATTR(name, 0444, applesmc_name_show, NULL);
1014
1015 static DEVICE_ATTR(position, 0444, applesmc_position_show, NULL);
1016 static DEVICE_ATTR(calibrate, 0644,
1017 applesmc_calibrate_show, applesmc_calibrate_store);
1018
1019 static struct attribute *accelerometer_attributes[] = {
1020 &dev_attr_position.attr,
1021 &dev_attr_calibrate.attr,
1022 NULL
1023 };
1024
1025 static const struct attribute_group accelerometer_attributes_group =
1026 { .attrs = accelerometer_attributes };
1027
1028 static DEVICE_ATTR(light, 0444, applesmc_light_show, NULL);
1029
1030 static DEVICE_ATTR(key_count, 0444, applesmc_key_count_show, NULL);
1031 static DEVICE_ATTR(key_at_index, 0644,
1032 applesmc_key_at_index_show, applesmc_key_at_index_store);
1033 static DEVICE_ATTR(key_at_index_name, 0444,
1034 applesmc_key_at_index_name_show, NULL);
1035 static DEVICE_ATTR(key_at_index_type, 0444,
1036 applesmc_key_at_index_type_show, NULL);
1037 static DEVICE_ATTR(key_at_index_data_length, 0444,
1038 applesmc_key_at_index_data_length_show, NULL);
1039 static DEVICE_ATTR(key_at_index_data, 0444,
1040 applesmc_key_at_index_read_show, NULL);
1041
1042 static struct attribute *key_enumeration_attributes[] = {
1043 &dev_attr_key_count.attr,
1044 &dev_attr_key_at_index.attr,
1045 &dev_attr_key_at_index_name.attr,
1046 &dev_attr_key_at_index_type.attr,
1047 &dev_attr_key_at_index_data_length.attr,
1048 &dev_attr_key_at_index_data.attr,
1049 NULL
1050 };
1051
1052 static const struct attribute_group key_enumeration_group =
1053 { .attrs = key_enumeration_attributes };
1054
1055 /*
1056 * Macro defining SENSOR_DEVICE_ATTR for a fan sysfs entries.
1057 * - show actual speed
1058 * - show/store minimum speed
1059 * - show maximum speed
1060 * - show safe speed
1061 * - show/store target speed
1062 * - show/store manual mode
1063 */
1064 #define sysfs_fan_speeds_offset(offset) \
1065 static SENSOR_DEVICE_ATTR_2(fan##offset##_input, S_IRUGO, \
1066 applesmc_show_fan_speed, NULL, 0, offset-1); \
1067 \
1068 static SENSOR_DEVICE_ATTR_2(fan##offset##_min, S_IRUGO | S_IWUSR, \
1069 applesmc_show_fan_speed, applesmc_store_fan_speed, 1, offset-1); \
1070 \
1071 static SENSOR_DEVICE_ATTR_2(fan##offset##_max, S_IRUGO, \
1072 applesmc_show_fan_speed, NULL, 2, offset-1); \
1073 \
1074 static SENSOR_DEVICE_ATTR_2(fan##offset##_safe, S_IRUGO, \
1075 applesmc_show_fan_speed, NULL, 3, offset-1); \
1076 \
1077 static SENSOR_DEVICE_ATTR_2(fan##offset##_output, S_IRUGO | S_IWUSR, \
1078 applesmc_show_fan_speed, applesmc_store_fan_speed, 4, offset-1); \
1079 \
1080 static SENSOR_DEVICE_ATTR(fan##offset##_manual, S_IRUGO | S_IWUSR, \
1081 applesmc_show_fan_manual, applesmc_store_fan_manual, offset-1); \
1082 \
1083 static SENSOR_DEVICE_ATTR(fan##offset##_label, S_IRUGO, \
1084 applesmc_show_fan_position, NULL, offset-1); \
1085 \
1086 static struct attribute *fan##offset##_attributes[] = { \
1087 &sensor_dev_attr_fan##offset##_input.dev_attr.attr, \
1088 &sensor_dev_attr_fan##offset##_min.dev_attr.attr, \
1089 &sensor_dev_attr_fan##offset##_max.dev_attr.attr, \
1090 &sensor_dev_attr_fan##offset##_safe.dev_attr.attr, \
1091 &sensor_dev_attr_fan##offset##_output.dev_attr.attr, \
1092 &sensor_dev_attr_fan##offset##_manual.dev_attr.attr, \
1093 &sensor_dev_attr_fan##offset##_label.dev_attr.attr, \
1094 NULL \
1095 };
1096
1097 /*
1098 * Create the needed functions for each fan using the macro defined above
1099 * (4 fans are supported)
1100 */
1101 sysfs_fan_speeds_offset(1);
1102 sysfs_fan_speeds_offset(2);
1103 sysfs_fan_speeds_offset(3);
1104 sysfs_fan_speeds_offset(4);
1105
1106 static const struct attribute_group fan_attribute_groups[] = {
1107 { .attrs = fan1_attributes },
1108 { .attrs = fan2_attributes },
1109 { .attrs = fan3_attributes },
1110 { .attrs = fan4_attributes },
1111 };
1112
1113 /*
1114 * Temperature sensors sysfs entries.
1115 */
1116 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
1117 applesmc_show_temperature, NULL, 0);
1118 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO,
1119 applesmc_show_temperature, NULL, 1);
1120 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO,
1121 applesmc_show_temperature, NULL, 2);
1122 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO,
1123 applesmc_show_temperature, NULL, 3);
1124 static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO,
1125 applesmc_show_temperature, NULL, 4);
1126 static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO,
1127 applesmc_show_temperature, NULL, 5);
1128 static SENSOR_DEVICE_ATTR(temp7_input, S_IRUGO,
1129 applesmc_show_temperature, NULL, 6);
1130 static SENSOR_DEVICE_ATTR(temp8_input, S_IRUGO,
1131 applesmc_show_temperature, NULL, 7);
1132 static SENSOR_DEVICE_ATTR(temp9_input, S_IRUGO,
1133 applesmc_show_temperature, NULL, 8);
1134 static SENSOR_DEVICE_ATTR(temp10_input, S_IRUGO,
1135 applesmc_show_temperature, NULL, 9);
1136 static SENSOR_DEVICE_ATTR(temp11_input, S_IRUGO,
1137 applesmc_show_temperature, NULL, 10);
1138 static SENSOR_DEVICE_ATTR(temp12_input, S_IRUGO,
1139 applesmc_show_temperature, NULL, 11);
1140 static SENSOR_DEVICE_ATTR(temp13_input, S_IRUGO,
1141 applesmc_show_temperature, NULL, 12);
1142 static SENSOR_DEVICE_ATTR(temp14_input, S_IRUGO,
1143 applesmc_show_temperature, NULL, 13);
1144 static SENSOR_DEVICE_ATTR(temp15_input, S_IRUGO,
1145 applesmc_show_temperature, NULL, 14);
1146 static SENSOR_DEVICE_ATTR(temp16_input, S_IRUGO,
1147 applesmc_show_temperature, NULL, 15);
1148 static SENSOR_DEVICE_ATTR(temp17_input, S_IRUGO,
1149 applesmc_show_temperature, NULL, 16);
1150 static SENSOR_DEVICE_ATTR(temp18_input, S_IRUGO,
1151 applesmc_show_temperature, NULL, 17);
1152 static SENSOR_DEVICE_ATTR(temp19_input, S_IRUGO,
1153 applesmc_show_temperature, NULL, 18);
1154 static SENSOR_DEVICE_ATTR(temp20_input, S_IRUGO,
1155 applesmc_show_temperature, NULL, 19);
1156 static SENSOR_DEVICE_ATTR(temp21_input, S_IRUGO,
1157 applesmc_show_temperature, NULL, 20);
1158 static SENSOR_DEVICE_ATTR(temp22_input, S_IRUGO,
1159 applesmc_show_temperature, NULL, 21);
1160 static SENSOR_DEVICE_ATTR(temp23_input, S_IRUGO,
1161 applesmc_show_temperature, NULL, 22);
1162 static SENSOR_DEVICE_ATTR(temp24_input, S_IRUGO,
1163 applesmc_show_temperature, NULL, 23);
1164 static SENSOR_DEVICE_ATTR(temp25_input, S_IRUGO,
1165 applesmc_show_temperature, NULL, 24);
1166 static SENSOR_DEVICE_ATTR(temp26_input, S_IRUGO,
1167 applesmc_show_temperature, NULL, 25);
1168 static SENSOR_DEVICE_ATTR(temp27_input, S_IRUGO,
1169 applesmc_show_temperature, NULL, 26);
1170 static SENSOR_DEVICE_ATTR(temp28_input, S_IRUGO,
1171 applesmc_show_temperature, NULL, 27);
1172 static SENSOR_DEVICE_ATTR(temp29_input, S_IRUGO,
1173 applesmc_show_temperature, NULL, 28);
1174 static SENSOR_DEVICE_ATTR(temp30_input, S_IRUGO,
1175 applesmc_show_temperature, NULL, 29);
1176 static SENSOR_DEVICE_ATTR(temp31_input, S_IRUGO,
1177 applesmc_show_temperature, NULL, 30);
1178 static SENSOR_DEVICE_ATTR(temp32_input, S_IRUGO,
1179 applesmc_show_temperature, NULL, 31);
1180 static SENSOR_DEVICE_ATTR(temp33_input, S_IRUGO,
1181 applesmc_show_temperature, NULL, 32);
1182 static SENSOR_DEVICE_ATTR(temp34_input, S_IRUGO,
1183 applesmc_show_temperature, NULL, 33);
1184 static SENSOR_DEVICE_ATTR(temp35_input, S_IRUGO,
1185 applesmc_show_temperature, NULL, 34);
1186 static SENSOR_DEVICE_ATTR(temp36_input, S_IRUGO,
1187 applesmc_show_temperature, NULL, 35);
1188 static SENSOR_DEVICE_ATTR(temp37_input, S_IRUGO,
1189 applesmc_show_temperature, NULL, 36);
1190 static SENSOR_DEVICE_ATTR(temp38_input, S_IRUGO,
1191 applesmc_show_temperature, NULL, 37);
1192 static SENSOR_DEVICE_ATTR(temp39_input, S_IRUGO,
1193 applesmc_show_temperature, NULL, 38);
1194 static SENSOR_DEVICE_ATTR(temp40_input, S_IRUGO,
1195 applesmc_show_temperature, NULL, 39);
1196
1197 static struct attribute *temperature_attributes[] = {
1198 &sensor_dev_attr_temp1_input.dev_attr.attr,
1199 &sensor_dev_attr_temp2_input.dev_attr.attr,
1200 &sensor_dev_attr_temp3_input.dev_attr.attr,
1201 &sensor_dev_attr_temp4_input.dev_attr.attr,
1202 &sensor_dev_attr_temp5_input.dev_attr.attr,
1203 &sensor_dev_attr_temp6_input.dev_attr.attr,
1204 &sensor_dev_attr_temp7_input.dev_attr.attr,
1205 &sensor_dev_attr_temp8_input.dev_attr.attr,
1206 &sensor_dev_attr_temp9_input.dev_attr.attr,
1207 &sensor_dev_attr_temp10_input.dev_attr.attr,
1208 &sensor_dev_attr_temp11_input.dev_attr.attr,
1209 &sensor_dev_attr_temp12_input.dev_attr.attr,
1210 &sensor_dev_attr_temp13_input.dev_attr.attr,
1211 &sensor_dev_attr_temp14_input.dev_attr.attr,
1212 &sensor_dev_attr_temp15_input.dev_attr.attr,
1213 &sensor_dev_attr_temp16_input.dev_attr.attr,
1214 &sensor_dev_attr_temp17_input.dev_attr.attr,
1215 &sensor_dev_attr_temp18_input.dev_attr.attr,
1216 &sensor_dev_attr_temp19_input.dev_attr.attr,
1217 &sensor_dev_attr_temp20_input.dev_attr.attr,
1218 &sensor_dev_attr_temp21_input.dev_attr.attr,
1219 &sensor_dev_attr_temp22_input.dev_attr.attr,
1220 &sensor_dev_attr_temp23_input.dev_attr.attr,
1221 &sensor_dev_attr_temp24_input.dev_attr.attr,
1222 &sensor_dev_attr_temp25_input.dev_attr.attr,
1223 &sensor_dev_attr_temp26_input.dev_attr.attr,
1224 &sensor_dev_attr_temp27_input.dev_attr.attr,
1225 &sensor_dev_attr_temp28_input.dev_attr.attr,
1226 &sensor_dev_attr_temp29_input.dev_attr.attr,
1227 &sensor_dev_attr_temp30_input.dev_attr.attr,
1228 &sensor_dev_attr_temp31_input.dev_attr.attr,
1229 &sensor_dev_attr_temp32_input.dev_attr.attr,
1230 &sensor_dev_attr_temp33_input.dev_attr.attr,
1231 &sensor_dev_attr_temp34_input.dev_attr.attr,
1232 &sensor_dev_attr_temp35_input.dev_attr.attr,
1233 &sensor_dev_attr_temp36_input.dev_attr.attr,
1234 &sensor_dev_attr_temp37_input.dev_attr.attr,
1235 &sensor_dev_attr_temp38_input.dev_attr.attr,
1236 &sensor_dev_attr_temp39_input.dev_attr.attr,
1237 &sensor_dev_attr_temp40_input.dev_attr.attr,
1238 NULL
1239 };
1240
1241 static const struct attribute_group temperature_attributes_group =
1242 { .attrs = temperature_attributes };
1243
1244 /* Module stuff */
1245
1246 /*
1247 * applesmc_dmi_match - found a match. return one, short-circuiting the hunt.
1248 */
1249 static int applesmc_dmi_match(const struct dmi_system_id *id)
1250 {
1251 int i = 0;
1252 struct dmi_match_data* dmi_data = id->driver_data;
1253 printk(KERN_INFO "applesmc: %s detected:\n", id->ident);
1254 applesmc_accelerometer = dmi_data->accelerometer;
1255 printk(KERN_INFO "applesmc: - Model %s accelerometer\n",
1256 applesmc_accelerometer ? "with" : "without");
1257 applesmc_light = dmi_data->light;
1258 printk(KERN_INFO "applesmc: - Model %s light sensors and backlight\n",
1259 applesmc_light ? "with" : "without");
1260
1261 applesmc_temperature_set = dmi_data->temperature_set;
1262 while (temperature_sensors_sets[applesmc_temperature_set][i] != NULL)
1263 i++;
1264 printk(KERN_INFO "applesmc: - Model with %d temperature sensors\n", i);
1265 return 1;
1266 }
1267
1268 /* Create accelerometer ressources */
1269 static int applesmc_create_accelerometer(void)
1270 {
1271 struct input_dev *idev;
1272 int ret;
1273
1274 ret = sysfs_create_group(&pdev->dev.kobj,
1275 &accelerometer_attributes_group);
1276 if (ret)
1277 goto out;
1278
1279 applesmc_idev = input_allocate_polled_device();
1280 if (!applesmc_idev) {
1281 ret = -ENOMEM;
1282 goto out_sysfs;
1283 }
1284
1285 applesmc_idev->poll = applesmc_idev_poll;
1286 applesmc_idev->poll_interval = APPLESMC_POLL_INTERVAL;
1287
1288 /* initial calibrate for the input device */
1289 applesmc_calibrate();
1290
1291 /* initialize the input device */
1292 idev = applesmc_idev->input;
1293 idev->name = "applesmc";
1294 idev->id.bustype = BUS_HOST;
1295 idev->dev.parent = &pdev->dev;
1296 idev->evbit[0] = BIT_MASK(EV_ABS);
1297 input_set_abs_params(idev, ABS_X,
1298 -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);
1299 input_set_abs_params(idev, ABS_Y,
1300 -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);
1301
1302 ret = input_register_polled_device(applesmc_idev);
1303 if (ret)
1304 goto out_idev;
1305
1306 return 0;
1307
1308 out_idev:
1309 input_free_polled_device(applesmc_idev);
1310
1311 out_sysfs:
1312 sysfs_remove_group(&pdev->dev.kobj, &accelerometer_attributes_group);
1313
1314 out:
1315 printk(KERN_WARNING "applesmc: driver init failed (ret=%d)!\n", ret);
1316 return ret;
1317 }
1318
1319 /* Release all ressources used by the accelerometer */
1320 static void applesmc_release_accelerometer(void)
1321 {
1322 input_unregister_polled_device(applesmc_idev);
1323 input_free_polled_device(applesmc_idev);
1324 sysfs_remove_group(&pdev->dev.kobj, &accelerometer_attributes_group);
1325 }
1326
1327 static __initdata struct dmi_match_data applesmc_dmi_data[] = {
1328 /* MacBook Pro: accelerometer, backlight and temperature set 0 */
1329 { .accelerometer = 1, .light = 1, .temperature_set = 0 },
1330 /* MacBook2: accelerometer and temperature set 1 */
1331 { .accelerometer = 1, .light = 0, .temperature_set = 1 },
1332 /* MacBook: accelerometer and temperature set 2 */
1333 { .accelerometer = 1, .light = 0, .temperature_set = 2 },
1334 /* MacMini: temperature set 3 */
1335 { .accelerometer = 0, .light = 0, .temperature_set = 3 },
1336 /* MacPro: temperature set 4 */
1337 { .accelerometer = 0, .light = 0, .temperature_set = 4 },
1338 /* iMac: temperature set 5 */
1339 { .accelerometer = 0, .light = 0, .temperature_set = 5 },
1340 /* MacBook3, MacBook4: accelerometer and temperature set 6 */
1341 { .accelerometer = 1, .light = 0, .temperature_set = 6 },
1342 /* MacBook Air: accelerometer, backlight and temperature set 7 */
1343 { .accelerometer = 1, .light = 1, .temperature_set = 7 },
1344 /* MacBook Pro 4: accelerometer, backlight and temperature set 8 */
1345 { .accelerometer = 1, .light = 1, .temperature_set = 8 },
1346 /* MacBook Pro 3: accelerometer, backlight and temperature set 9 */
1347 { .accelerometer = 1, .light = 1, .temperature_set = 9 },
1348 /* iMac 5: light sensor only, temperature set 10 */
1349 { .accelerometer = 0, .light = 0, .temperature_set = 10 },
1350 /* MacBook 5: accelerometer, backlight and temperature set 11 */
1351 { .accelerometer = 1, .light = 1, .temperature_set = 11 },
1352 /* MacBook Pro 5: accelerometer, backlight and temperature set 12 */
1353 { .accelerometer = 1, .light = 1, .temperature_set = 12 },
1354 /* iMac 8: light sensor only, temperature set 13 */
1355 { .accelerometer = 0, .light = 0, .temperature_set = 13 },
1356 /* iMac 6: light sensor only, temperature set 14 */
1357 { .accelerometer = 0, .light = 0, .temperature_set = 14 },
1358 /* MacBook Air 2,1: accelerometer, backlight and temperature set 15 */
1359 { .accelerometer = 1, .light = 1, .temperature_set = 15 },
1360 /* MacPro3,1: temperature set 16 */
1361 { .accelerometer = 0, .light = 0, .temperature_set = 16 },
1362 /* iMac 9,1: light sensor only, temperature set 17 */
1363 { .accelerometer = 0, .light = 0, .temperature_set = 17 },
1364 /* MacBook Pro 2,2: accelerometer, backlight and temperature set 18 */
1365 { .accelerometer = 1, .light = 1, .temperature_set = 18 },
1366 };
1367
1368 /* Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
1369 * So we need to put "Apple MacBook Pro" before "Apple MacBook". */
1370 static __initdata struct dmi_system_id applesmc_whitelist[] = {
1371 { applesmc_dmi_match, "Apple MacBook Air 2", {
1372 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1373 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir2") },
1374 &applesmc_dmi_data[15]},
1375 { applesmc_dmi_match, "Apple MacBook Air", {
1376 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1377 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir") },
1378 &applesmc_dmi_data[7]},
1379 { applesmc_dmi_match, "Apple MacBook Pro 5", {
1380 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1381 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5") },
1382 &applesmc_dmi_data[12]},
1383 { applesmc_dmi_match, "Apple MacBook Pro 4", {
1384 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1385 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro4") },
1386 &applesmc_dmi_data[8]},
1387 { applesmc_dmi_match, "Apple MacBook Pro 3", {
1388 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1389 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro3") },
1390 &applesmc_dmi_data[9]},
1391 { applesmc_dmi_match, "Apple MacBook Pro 2,2", {
1392 DMI_MATCH(DMI_BOARD_VENDOR, "Apple Computer, Inc."),
1393 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro2,2") },
1394 &applesmc_dmi_data[18]},
1395 { applesmc_dmi_match, "Apple MacBook Pro", {
1396 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1397 DMI_MATCH(DMI_PRODUCT_NAME,"MacBookPro") },
1398 &applesmc_dmi_data[0]},
1399 { applesmc_dmi_match, "Apple MacBook (v2)", {
1400 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1401 DMI_MATCH(DMI_PRODUCT_NAME,"MacBook2") },
1402 &applesmc_dmi_data[1]},
1403 { applesmc_dmi_match, "Apple MacBook (v3)", {
1404 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1405 DMI_MATCH(DMI_PRODUCT_NAME,"MacBook3") },
1406 &applesmc_dmi_data[6]},
1407 { applesmc_dmi_match, "Apple MacBook 4", {
1408 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1409 DMI_MATCH(DMI_PRODUCT_NAME, "MacBook4") },
1410 &applesmc_dmi_data[6]},
1411 { applesmc_dmi_match, "Apple MacBook 5", {
1412 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1413 DMI_MATCH(DMI_PRODUCT_NAME, "MacBook5") },
1414 &applesmc_dmi_data[11]},
1415 { applesmc_dmi_match, "Apple MacBook", {
1416 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1417 DMI_MATCH(DMI_PRODUCT_NAME,"MacBook") },
1418 &applesmc_dmi_data[2]},
1419 { applesmc_dmi_match, "Apple Macmini", {
1420 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1421 DMI_MATCH(DMI_PRODUCT_NAME,"Macmini") },
1422 &applesmc_dmi_data[3]},
1423 { applesmc_dmi_match, "Apple MacPro2", {
1424 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1425 DMI_MATCH(DMI_PRODUCT_NAME,"MacPro2") },
1426 &applesmc_dmi_data[4]},
1427 { applesmc_dmi_match, "Apple MacPro3", {
1428 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1429 DMI_MATCH(DMI_PRODUCT_NAME, "MacPro3") },
1430 &applesmc_dmi_data[16]},
1431 { applesmc_dmi_match, "Apple MacPro", {
1432 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1433 DMI_MATCH(DMI_PRODUCT_NAME, "MacPro") },
1434 &applesmc_dmi_data[4]},
1435 { applesmc_dmi_match, "Apple iMac 9,1", {
1436 DMI_MATCH(DMI_BOARD_VENDOR, "Apple Inc."),
1437 DMI_MATCH(DMI_PRODUCT_NAME, "iMac9,1") },
1438 &applesmc_dmi_data[17]},
1439 { applesmc_dmi_match, "Apple iMac 8", {
1440 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1441 DMI_MATCH(DMI_PRODUCT_NAME, "iMac8") },
1442 &applesmc_dmi_data[13]},
1443 { applesmc_dmi_match, "Apple iMac 6", {
1444 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1445 DMI_MATCH(DMI_PRODUCT_NAME, "iMac6") },
1446 &applesmc_dmi_data[14]},
1447 { applesmc_dmi_match, "Apple iMac 5", {
1448 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1449 DMI_MATCH(DMI_PRODUCT_NAME, "iMac5") },
1450 &applesmc_dmi_data[10]},
1451 { applesmc_dmi_match, "Apple iMac", {
1452 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1453 DMI_MATCH(DMI_PRODUCT_NAME,"iMac") },
1454 &applesmc_dmi_data[5]},
1455 { .ident = NULL }
1456 };
1457
1458 static int __init applesmc_init(void)
1459 {
1460 int ret;
1461 int count;
1462 int i;
1463
1464 if (!dmi_check_system(applesmc_whitelist)) {
1465 printk(KERN_WARNING "applesmc: supported laptop not found!\n");
1466 ret = -ENODEV;
1467 goto out;
1468 }
1469
1470 if (!request_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS,
1471 "applesmc")) {
1472 ret = -ENXIO;
1473 goto out;
1474 }
1475
1476 ret = platform_driver_register(&applesmc_driver);
1477 if (ret)
1478 goto out_region;
1479
1480 pdev = platform_device_register_simple("applesmc", APPLESMC_DATA_PORT,
1481 NULL, 0);
1482 if (IS_ERR(pdev)) {
1483 ret = PTR_ERR(pdev);
1484 goto out_driver;
1485 }
1486
1487 ret = sysfs_create_file(&pdev->dev.kobj, &dev_attr_name.attr);
1488 if (ret)
1489 goto out_device;
1490
1491 /* Create key enumeration sysfs files */
1492 ret = sysfs_create_group(&pdev->dev.kobj, &key_enumeration_group);
1493 if (ret)
1494 goto out_name;
1495
1496 /* create fan files */
1497 count = applesmc_get_fan_count();
1498 if (count < 0)
1499 printk(KERN_ERR "applesmc: Cannot get the number of fans.\n");
1500 else
1501 printk(KERN_INFO "applesmc: %d fans found.\n", count);
1502
1503 if (count > 4) {
1504 count = 4;
1505 printk(KERN_WARNING "applesmc: More than 4 fans found,"
1506 " but at most 4 fans are supported"
1507 " by the driver.\n");
1508 }
1509
1510 while (fans_handled < count) {
1511 ret = sysfs_create_group(&pdev->dev.kobj,
1512 &fan_attribute_groups[fans_handled]);
1513 if (ret)
1514 goto out_fans;
1515 fans_handled++;
1516 }
1517
1518 for (i = 0;
1519 temperature_sensors_sets[applesmc_temperature_set][i] != NULL;
1520 i++) {
1521 if (temperature_attributes[i] == NULL) {
1522 printk(KERN_ERR "applesmc: More temperature sensors "
1523 "in temperature_sensors_sets (at least %i)"
1524 "than available sysfs files in "
1525 "temperature_attributes (%i), please report "
1526 "this bug.\n", i, i-1);
1527 goto out_temperature;
1528 }
1529 ret = sysfs_create_file(&pdev->dev.kobj,
1530 temperature_attributes[i]);
1531 if (ret)
1532 goto out_temperature;
1533 }
1534
1535 if (applesmc_accelerometer) {
1536 ret = applesmc_create_accelerometer();
1537 if (ret)
1538 goto out_temperature;
1539 }
1540
1541 if (applesmc_light) {
1542 /* Add light sensor file */
1543 ret = sysfs_create_file(&pdev->dev.kobj, &dev_attr_light.attr);
1544 if (ret)
1545 goto out_accelerometer;
1546
1547 /* Create the workqueue */
1548 applesmc_led_wq = create_singlethread_workqueue("applesmc-led");
1549 if (!applesmc_led_wq) {
1550 ret = -ENOMEM;
1551 goto out_light_sysfs;
1552 }
1553
1554 /* register as a led device */
1555 ret = led_classdev_register(&pdev->dev, &applesmc_backlight);
1556 if (ret < 0)
1557 goto out_light_wq;
1558 }
1559
1560 hwmon_dev = hwmon_device_register(&pdev->dev);
1561 if (IS_ERR(hwmon_dev)) {
1562 ret = PTR_ERR(hwmon_dev);
1563 goto out_light_ledclass;
1564 }
1565
1566 printk(KERN_INFO "applesmc: driver successfully loaded.\n");
1567
1568 return 0;
1569
1570 out_light_ledclass:
1571 if (applesmc_light)
1572 led_classdev_unregister(&applesmc_backlight);
1573 out_light_wq:
1574 if (applesmc_light)
1575 destroy_workqueue(applesmc_led_wq);
1576 out_light_sysfs:
1577 if (applesmc_light)
1578 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_light.attr);
1579 out_accelerometer:
1580 if (applesmc_accelerometer)
1581 applesmc_release_accelerometer();
1582 out_temperature:
1583 sysfs_remove_group(&pdev->dev.kobj, &temperature_attributes_group);
1584 out_fans:
1585 while (fans_handled)
1586 sysfs_remove_group(&pdev->dev.kobj,
1587 &fan_attribute_groups[--fans_handled]);
1588 sysfs_remove_group(&pdev->dev.kobj, &key_enumeration_group);
1589 out_name:
1590 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_name.attr);
1591 out_device:
1592 platform_device_unregister(pdev);
1593 out_driver:
1594 platform_driver_unregister(&applesmc_driver);
1595 out_region:
1596 release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);
1597 out:
1598 printk(KERN_WARNING "applesmc: driver init failed (ret=%d)!\n", ret);
1599 return ret;
1600 }
1601
1602 static void __exit applesmc_exit(void)
1603 {
1604 hwmon_device_unregister(hwmon_dev);
1605 if (applesmc_light) {
1606 led_classdev_unregister(&applesmc_backlight);
1607 destroy_workqueue(applesmc_led_wq);
1608 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_light.attr);
1609 }
1610 if (applesmc_accelerometer)
1611 applesmc_release_accelerometer();
1612 sysfs_remove_group(&pdev->dev.kobj, &temperature_attributes_group);
1613 while (fans_handled)
1614 sysfs_remove_group(&pdev->dev.kobj,
1615 &fan_attribute_groups[--fans_handled]);
1616 sysfs_remove_group(&pdev->dev.kobj, &key_enumeration_group);
1617 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_name.attr);
1618 platform_device_unregister(pdev);
1619 platform_driver_unregister(&applesmc_driver);
1620 release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);
1621
1622 printk(KERN_INFO "applesmc: driver unloaded.\n");
1623 }
1624
1625 module_init(applesmc_init);
1626 module_exit(applesmc_exit);
1627
1628 MODULE_AUTHOR("Nicolas Boichat");
1629 MODULE_DESCRIPTION("Apple SMC");
1630 MODULE_LICENSE("GPL v2");
1631 MODULE_DEVICE_TABLE(dmi, applesmc_whitelist);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree