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