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