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