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