applesmc.c 32.6 KB
Newer Older
1
2
3
4
5
6
/*
 * drivers/hwmon/applesmc.c - driver for Apple's SMC (accelerometer, temperature
 * sensors, fan control, keyboard backlight control) used in Intel-based Apple
 * computers.
 *
 * Copyright (C) 2007 Nicolas Boichat <nicolas@boichat.ch>
7
 * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>
8
9
10
 *
 * Based on hdaps.c driver:
 * Copyright (C) 2005 Robert Love <rml@novell.com>
11
 * Copyright (C) 2005 Jesper Juhl <jj@chaosbits.net>
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 *
 * Fan control based on smcFanControl:
 * Copyright (C) 2006 Hendrik Holtmann <holtmann@mac.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License v2 as published by the
 * Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */

30
31
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

32
33
#include <linux/delay.h>
#include <linux/platform_device.h>
34
#include <linux/input-polldev.h>
35
#include <linux/kernel.h>
36
#include <linux/slab.h>
37
38
39
40
41
#include <linux/module.h>
#include <linux/timer.h>
#include <linux/dmi.h>
#include <linux/mutex.h>
#include <linux/hwmon-sysfs.h>
42
#include <linux/io.h>
43
44
45
#include <linux/leds.h>
#include <linux/hwmon.h>
#include <linux/workqueue.h>
46
#include <linux/err.h>
47
48
49
50
51
52
53
54
55
56

/* data port used by Apple SMC */
#define APPLESMC_DATA_PORT	0x300
/* command/status port used by Apple SMC */
#define APPLESMC_CMD_PORT	0x304

#define APPLESMC_NR_PORTS	32 /* 0x300-0x31f */

#define APPLESMC_MAX_DATA_LENGTH 32

57
/* wait up to 128 ms for a status change. */
58
#define APPLESMC_MIN_WAIT	0x0010
59
#define APPLESMC_RETRY_WAIT	0x0100
60
#define APPLESMC_MAX_WAIT	0x20000
61

62
63
64
65
66
67
68
#define APPLESMC_READ_CMD	0x10
#define APPLESMC_WRITE_CMD	0x11
#define APPLESMC_GET_KEY_BY_INDEX_CMD	0x12
#define APPLESMC_GET_KEY_TYPE_CMD	0x13

#define KEY_COUNT_KEY		"#KEY" /* r-o ui32 */

69
70
#define LIGHT_SENSOR_LEFT_KEY	"ALV0" /* r-o {alv (6-10 bytes) */
#define LIGHT_SENSOR_RIGHT_KEY	"ALV1" /* r-o {alv (6-10 bytes) */
71
#define BACKLIGHT_KEY		"LKSB" /* w-o {lkb (2 bytes) */
72

73
#define CLAMSHELL_KEY		"MSLD" /* r-o ui8 (unused) */
74
75
76
77
78
79
80
81

#define MOTION_SENSOR_X_KEY	"MO_X" /* r-o sp78 (2 bytes) */
#define MOTION_SENSOR_Y_KEY	"MO_Y" /* r-o sp78 (2 bytes) */
#define MOTION_SENSOR_Z_KEY	"MO_Z" /* r-o sp78 (2 bytes) */
#define MOTION_SENSOR_KEY	"MOCN" /* r/w ui16 */

#define FANS_COUNT		"FNum" /* r-o ui8 */
#define FANS_MANUAL		"FS! " /* r-w ui16 */
82
#define FAN_ID_FMT		"F%dID" /* r-o char[16] */
83

84
85
#define TEMP_SENSOR_TYPE	"sp78"

86
/* List of keys used to read/write fan speeds */
87
88
89
90
91
92
static const char *const fan_speed_fmt[] = {
	"F%dAc",		/* actual speed */
	"F%dMn",		/* minimum speed (rw) */
	"F%dMx",		/* maximum speed */
	"F%dSf",		/* safe speed - not all models */
	"F%dTg",		/* target speed (manual: rw) */
93
94
95
96
97
};

#define INIT_TIMEOUT_MSECS	5000	/* wait up to 5s for device init ... */
#define INIT_WAIT_MSECS		50	/* ... in 50ms increments */

98
#define APPLESMC_POLL_INTERVAL	50	/* msecs */
99
100
101
#define APPLESMC_INPUT_FUZZ	4	/* input event threshold */
#define APPLESMC_INPUT_FLAT	4

102
103
#define to_index(attr) (to_sensor_dev_attr(attr)->index & 0xffff)
#define to_option(attr) (to_sensor_dev_attr(attr)->index >> 16)
104
105
106
107
108
109
110
111
112
113
114
115

/* Dynamic device node attributes */
struct applesmc_dev_attr {
	struct sensor_device_attribute sda;	/* hwmon attributes */
	char name[32];				/* room for node file name */
};

/* Dynamic device node group */
struct applesmc_node_group {
	char *format;				/* format string */
	void *show;				/* show function */
	void *store;				/* store function */
116
	int option;				/* function argument */
117
118
119
	struct applesmc_dev_attr *nodes;	/* dynamic node array */
};

120
121
122
123
124
125
126
127
128
129
130
131
132
/* AppleSMC entry - cached register information */
struct applesmc_entry {
	char key[5];		/* four-letter key code */
	u8 valid;		/* set when entry is successfully read once */
	u8 len;			/* bounded by APPLESMC_MAX_DATA_LENGTH */
	char type[5];		/* four-letter type code */
	u8 flags;		/* 0x10: func; 0x40: write; 0x80: read */
};

/* Register lookup and registers common to all SMCs */
static struct applesmc_registers {
	struct mutex mutex;		/* register read/write mutex */
	unsigned int key_count;		/* number of SMC registers */
133
	unsigned int fan_count;		/* number of fans */
134
135
136
	unsigned int temp_count;	/* number of temperature registers */
	unsigned int temp_begin;	/* temperature lower index bound */
	unsigned int temp_end;		/* temperature upper index bound */
137
	unsigned int index_count;	/* size of temperature index array */
138
139
140
	int num_light_sensors;		/* number of light sensors */
	bool has_accelerometer;		/* has motion sensor */
	bool has_key_backlight;		/* has keyboard backlight */
141
142
	bool init_complete;		/* true when fully initialized */
	struct applesmc_entry *cache;	/* cached key entries */
143
	const char **index;		/* temperature key index */
144
145
146
147
} smcreg = {
	.mutex = __MUTEX_INITIALIZER(smcreg.mutex),
};

148
149
150
151
static const int debug;
static struct platform_device *pdev;
static s16 rest_x;
static s16 rest_y;
152
153
static u8 backlight_state[2];

154
static struct device *hwmon_dev;
155
static struct input_polled_dev *applesmc_idev;
156
157
158
159
160
161
162
163
164
165

/*
 * Last index written to key_at_index sysfs file, and value to use for all other
 * key_at_index_* sysfs files.
 */
static unsigned int key_at_index;

static struct workqueue_struct *applesmc_led_wq;

/*
166
 * wait_read - Wait for a byte to appear on SMC port. Callers must
167
168
 * hold applesmc_lock.
 */
169
static int wait_read(void)
170
{
171
	u8 status;
172
173
174
	int us;
	for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) {
		udelay(us);
175
176
177
		status = inb(APPLESMC_CMD_PORT);
		/* read: wait for smc to settle */
		if (status & 0x01)
178
179
180
			return 0;
	}

181
	pr_warn("wait_read() fail: 0x%02x\n", status);
182
183
184
	return -EIO;
}

185
/*
186
187
 * send_byte - Write to SMC port, retrying when necessary. Callers
 * must hold applesmc_lock.
188
 */
189
static int send_byte(u8 cmd, u16 port)
190
{
191
	u8 status;
192
	int us;
193
194

	outb(cmd, port);
195
196
	for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) {
		udelay(us);
197
198
199
200
201
202
		status = inb(APPLESMC_CMD_PORT);
		/* write: wait for smc to settle */
		if (status & 0x02)
			continue;
		/* ready: cmd accepted, return */
		if (status & 0x04)
203
			return 0;
204
205
206
207
208
209
		/* timeout: give up */
		if (us << 1 == APPLESMC_MAX_WAIT)
			break;
		/* busy: long wait and resend */
		udelay(APPLESMC_RETRY_WAIT);
		outb(cmd, port);
210
	}
211
212

	pr_warn("send_byte(0x%02x, 0x%04x) fail: 0x%02x\n", cmd, port, status);
213
214
215
	return -EIO;
}

216
217
218
219
220
static int send_command(u8 cmd)
{
	return send_byte(cmd, APPLESMC_CMD_PORT);
}

221
static int send_argument(const char *key)
222
223
224
{
	int i;

225
226
	for (i = 0; i < 4; i++)
		if (send_byte(key[i], APPLESMC_DATA_PORT))
227
			return -EIO;
228
229
230
231
232
	return 0;
}

static int read_smc(u8 cmd, const char *key, u8 *buffer, u8 len)
{
233
	u8 status, data = 0;
234
235
236
	int i;

	if (send_command(cmd) || send_argument(key)) {
237
		pr_warn("%.4s: read arg fail\n", key);
238
239
		return -EIO;
	}
240

241
	/* This has no effect on newer (2012) SMCs */
242
243
244
245
	if (send_byte(len, APPLESMC_DATA_PORT)) {
		pr_warn("%.4s: read len fail\n", key);
		return -EIO;
	}
246
247

	for (i = 0; i < len; i++) {
248
249
		if (wait_read()) {
			pr_warn("%.4s: read data[%d] fail\n", key, i);
250
			return -EIO;
251
		}
252
253
254
		buffer[i] = inb(APPLESMC_DATA_PORT);
	}

255
256
257
258
259
260
261
262
263
264
265
	/* Read the data port until bit0 is cleared */
	for (i = 0; i < 16; i++) {
		udelay(APPLESMC_MIN_WAIT);
		status = inb(APPLESMC_CMD_PORT);
		if (!(status & 0x01))
			break;
		data = inb(APPLESMC_DATA_PORT);
	}
	if (i)
		pr_warn("flushed %d bytes, last value is: %d\n", i, data);

266
267
268
	return 0;
}

269
static int write_smc(u8 cmd, const char *key, const u8 *buffer, u8 len)
270
271
272
{
	int i;

273
274
	if (send_command(cmd) || send_argument(key)) {
		pr_warn("%s: write arg fail\n", key);
275
276
277
		return -EIO;
	}

278
279
280
281
	if (send_byte(len, APPLESMC_DATA_PORT)) {
		pr_warn("%.4s: write len fail\n", key);
		return -EIO;
	}
282
283

	for (i = 0; i < len; i++) {
284
		if (send_byte(buffer[i], APPLESMC_DATA_PORT)) {
285
			pr_warn("%s: write data fail\n", key);
286
			return -EIO;
287
		}
288
289
290
291
292
	}

	return 0;
}

293
294
295
296
297
298
299
300
301
302
303
304
305
static int read_register_count(unsigned int *count)
{
	__be32 be;
	int ret;

	ret = read_smc(APPLESMC_READ_CMD, KEY_COUNT_KEY, (u8 *)&be, 4);
	if (ret)
		return ret;

	*count = be32_to_cpu(be);
	return 0;
}

306
/*
307
308
309
310
 * Serialized I/O
 *
 * Returns zero on success or a negative error on failure.
 * All functions below are concurrency safe - callers should NOT hold lock.
311
 */
312
313
314

static int applesmc_read_entry(const struct applesmc_entry *entry,
			       u8 *buf, u8 len)
315
{
316
	int ret;
317

318
319
320
321
322
	if (entry->len != len)
		return -EINVAL;
	mutex_lock(&smcreg.mutex);
	ret = read_smc(APPLESMC_READ_CMD, entry->key, buf, len);
	mutex_unlock(&smcreg.mutex);
323

324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
	return ret;
}

static int applesmc_write_entry(const struct applesmc_entry *entry,
				const u8 *buf, u8 len)
{
	int ret;

	if (entry->len != len)
		return -EINVAL;
	mutex_lock(&smcreg.mutex);
	ret = write_smc(APPLESMC_WRITE_CMD, entry->key, buf, len);
	mutex_unlock(&smcreg.mutex);
	return ret;
}

static const struct applesmc_entry *applesmc_get_entry_by_index(int index)
{
	struct applesmc_entry *cache = &smcreg.cache[index];
	u8 key[4], info[6];
	__be32 be;
	int ret = 0;

	if (cache->valid)
		return cache;

	mutex_lock(&smcreg.mutex);

	if (cache->valid)
		goto out;
	be = cpu_to_be32(index);
	ret = read_smc(APPLESMC_GET_KEY_BY_INDEX_CMD, (u8 *)&be, key, 4);
	if (ret)
		goto out;
	ret = read_smc(APPLESMC_GET_KEY_TYPE_CMD, key, info, 6);
	if (ret)
		goto out;

	memcpy(cache->key, key, 4);
	cache->len = info[0];
	memcpy(cache->type, &info[1], 4);
	cache->flags = info[5];
	cache->valid = 1;

out:
	mutex_unlock(&smcreg.mutex);
	if (ret)
		return ERR_PTR(ret);
	return cache;
}

static int applesmc_get_lower_bound(unsigned int *lo, const char *key)
{
	int begin = 0, end = smcreg.key_count;
	const struct applesmc_entry *entry;

	while (begin != end) {
		int middle = begin + (end - begin) / 2;
		entry = applesmc_get_entry_by_index(middle);
383
384
		if (IS_ERR(entry)) {
			*lo = 0;
385
			return PTR_ERR(entry);
386
		}
387
388
389
390
		if (strcmp(entry->key, key) < 0)
			begin = middle + 1;
		else
			end = middle;
391
392
	}

393
394
395
	*lo = begin;
	return 0;
}
396

397
398
399
400
401
402
403
404
static int applesmc_get_upper_bound(unsigned int *hi, const char *key)
{
	int begin = 0, end = smcreg.key_count;
	const struct applesmc_entry *entry;

	while (begin != end) {
		int middle = begin + (end - begin) / 2;
		entry = applesmc_get_entry_by_index(middle);
405
406
		if (IS_ERR(entry)) {
			*hi = smcreg.key_count;
407
			return PTR_ERR(entry);
408
		}
409
410
411
412
		if (strcmp(key, entry->key) < 0)
			end = middle;
		else
			begin = middle + 1;
413
414
	}

415
	*hi = begin;
416
417
418
	return 0;
}

419
static const struct applesmc_entry *applesmc_get_entry_by_key(const char *key)
420
{
421
422
	int begin, end;
	int ret;
423

424
425
426
427
428
429
430
431
	ret = applesmc_get_lower_bound(&begin, key);
	if (ret)
		return ERR_PTR(ret);
	ret = applesmc_get_upper_bound(&end, key);
	if (ret)
		return ERR_PTR(ret);
	if (end - begin != 1)
		return ERR_PTR(-EINVAL);
432

433
434
	return applesmc_get_entry_by_index(begin);
}
435

436
437
438
static int applesmc_read_key(const char *key, u8 *buffer, u8 len)
{
	const struct applesmc_entry *entry;
439

440
441
442
	entry = applesmc_get_entry_by_key(key);
	if (IS_ERR(entry))
		return PTR_ERR(entry);
443

444
445
446
447
448
449
450
451
452
453
454
455
	return applesmc_read_entry(entry, buffer, len);
}

static int applesmc_write_key(const char *key, const u8 *buffer, u8 len)
{
	const struct applesmc_entry *entry;

	entry = applesmc_get_entry_by_key(key);
	if (IS_ERR(entry))
		return PTR_ERR(entry);

	return applesmc_write_entry(entry, buffer, len);
456
457
}

458
459
460
461
462
463
464
465
466
467
468
469
static int applesmc_has_key(const char *key, bool *value)
{
	const struct applesmc_entry *entry;

	entry = applesmc_get_entry_by_key(key);
	if (IS_ERR(entry) && PTR_ERR(entry) != -EINVAL)
		return PTR_ERR(entry);

	*value = !IS_ERR(entry);
	return 0;
}

470
/*
471
 * applesmc_read_s16 - Read 16-bit signed big endian register
472
 */
473
static int applesmc_read_s16(const char *key, s16 *value)
474
475
476
477
{
	u8 buffer[2];
	int ret;

478
479
480
	ret = applesmc_read_key(key, buffer, 2);
	if (ret)
		return ret;
481
482

	*value = ((s16)buffer[0] << 8) | buffer[1];
483
	return 0;
484
485
486
}

/*
487
 * applesmc_device_init - initialize the accelerometer.  Can sleep.
488
 */
489
static void applesmc_device_init(void)
490
{
491
	int total;
492
493
	u8 buffer[2];

494
	if (!smcreg.has_accelerometer)
495
		return;
496
497
498

	for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
		if (!applesmc_read_key(MOTION_SENSOR_KEY, buffer, 2) &&
499
				(buffer[0] != 0x00 || buffer[1] != 0x00))
500
			return;
501
502
503
504
505
506
		buffer[0] = 0xe0;
		buffer[1] = 0x00;
		applesmc_write_key(MOTION_SENSOR_KEY, buffer, 2);
		msleep(INIT_WAIT_MSECS);
	}

507
	pr_warn("failed to init the device\n");
508
509
}

510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
static int applesmc_init_index(struct applesmc_registers *s)
{
	const struct applesmc_entry *entry;
	unsigned int i;

	if (s->index)
		return 0;

	s->index = kcalloc(s->temp_count, sizeof(s->index[0]), GFP_KERNEL);
	if (!s->index)
		return -ENOMEM;

	for (i = s->temp_begin; i < s->temp_end; i++) {
		entry = applesmc_get_entry_by_index(i);
		if (IS_ERR(entry))
			continue;
		if (strcmp(entry->type, TEMP_SENSOR_TYPE))
			continue;
		s->index[s->index_count++] = entry->key;
	}

	return 0;
}

534
535
536
537
538
539
/*
 * applesmc_init_smcreg_try - Try to initialize register cache. Idempotent.
 */
static int applesmc_init_smcreg_try(void)
{
	struct applesmc_registers *s = &smcreg;
540
	bool left_light_sensor = 0, right_light_sensor = 0;
541
	unsigned int count;
542
	u8 tmp[1];
543
544
545
546
547
	int ret;

	if (s->init_complete)
		return 0;

548
	ret = read_register_count(&count);
549
550
551
	if (ret)
		return ret;

552
553
554
555
556
557
558
559
	if (s->cache && s->key_count != count) {
		pr_warn("key count changed from %d to %d\n",
			s->key_count, count);
		kfree(s->cache);
		s->cache = NULL;
	}
	s->key_count = count;

560
561
562
563
564
	if (!s->cache)
		s->cache = kcalloc(s->key_count, sizeof(*s->cache), GFP_KERNEL);
	if (!s->cache)
		return -ENOMEM;

565
566
567
568
	ret = applesmc_read_key(FANS_COUNT, tmp, 1);
	if (ret)
		return ret;
	s->fan_count = tmp[0];
569
570
	if (s->fan_count > 10)
		s->fan_count = 10;
571

572
573
574
575
576
577
578
579
	ret = applesmc_get_lower_bound(&s->temp_begin, "T");
	if (ret)
		return ret;
	ret = applesmc_get_lower_bound(&s->temp_end, "U");
	if (ret)
		return ret;
	s->temp_count = s->temp_end - s->temp_begin;

580
581
582
583
	ret = applesmc_init_index(s);
	if (ret)
		return ret;

584
585
586
587
588
589
590
591
592
593
594
595
596
597
	ret = applesmc_has_key(LIGHT_SENSOR_LEFT_KEY, &left_light_sensor);
	if (ret)
		return ret;
	ret = applesmc_has_key(LIGHT_SENSOR_RIGHT_KEY, &right_light_sensor);
	if (ret)
		return ret;
	ret = applesmc_has_key(MOTION_SENSOR_KEY, &s->has_accelerometer);
	if (ret)
		return ret;
	ret = applesmc_has_key(BACKLIGHT_KEY, &s->has_key_backlight);
	if (ret)
		return ret;

	s->num_light_sensors = left_light_sensor + right_light_sensor;
598
599
	s->init_complete = true;

600
601
	pr_info("key=%d fan=%d temp=%d index=%d acc=%d lux=%d kbd=%d\n",
	       s->key_count, s->fan_count, s->temp_count, s->index_count,
602
603
604
	       s->has_accelerometer,
	       s->num_light_sensors,
	       s->has_key_backlight);
605
606
607
608

	return 0;
}

609
610
611
612
613
614
615
616
617
static void applesmc_destroy_smcreg(void)
{
	kfree(smcreg.index);
	smcreg.index = NULL;
	kfree(smcreg.cache);
	smcreg.cache = NULL;
	smcreg.init_complete = false;
}

618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
/*
 * applesmc_init_smcreg - Initialize register cache.
 *
 * Retries until initialization is successful, or the operation times out.
 *
 */
static int applesmc_init_smcreg(void)
{
	int ms, ret;

	for (ms = 0; ms < INIT_TIMEOUT_MSECS; ms += INIT_WAIT_MSECS) {
		ret = applesmc_init_smcreg_try();
		if (!ret) {
			if (ms)
				pr_info("init_smcreg() took %d ms\n", ms);
			return 0;
		}
		msleep(INIT_WAIT_MSECS);
	}

638
	applesmc_destroy_smcreg();
639
640
641
642

	return ret;
}

643
644
645
/* Device model stuff */
static int applesmc_probe(struct platform_device *dev)
{
646
647
648
649
650
651
	int ret;

	ret = applesmc_init_smcreg();
	if (ret)
		return ret;

652
	applesmc_device_init();
653
654
655
656

	return 0;
}

657
658
659
/* Synchronize device with memorized backlight state */
static int applesmc_pm_resume(struct device *dev)
{
660
	if (smcreg.has_key_backlight)
661
662
663
664
665
666
		applesmc_write_key(BACKLIGHT_KEY, backlight_state, 2);
	return 0;
}

/* Reinitialize device on resume from hibernation */
static int applesmc_pm_restore(struct device *dev)
667
{
668
	applesmc_device_init();
669
	return applesmc_pm_resume(dev);
670
671
}

672
static const struct dev_pm_ops applesmc_pm_ops = {
673
674
675
676
	.resume = applesmc_pm_resume,
	.restore = applesmc_pm_restore,
};

677
678
679
680
static struct platform_driver applesmc_driver = {
	.probe = applesmc_probe,
	.driver	= {
		.name = "applesmc",
681
		.pm = &applesmc_pm_ops,
682
683
684
685
686
687
688
689
690
	},
};

/*
 * applesmc_calibrate - Set our "resting" values.  Callers must
 * hold applesmc_lock.
 */
static void applesmc_calibrate(void)
{
691
692
	applesmc_read_s16(MOTION_SENSOR_X_KEY, &rest_x);
	applesmc_read_s16(MOTION_SENSOR_Y_KEY, &rest_y);
693
694
695
	rest_x = -rest_x;
}

696
static void applesmc_idev_poll(struct input_polled_dev *dev)
697
{
698
	struct input_dev *idev = dev->input;
699
700
	s16 x, y;

701
	if (applesmc_read_s16(MOTION_SENSOR_X_KEY, &x))
702
		return;
703
	if (applesmc_read_s16(MOTION_SENSOR_Y_KEY, &y))
704
		return;
705
706

	x = -x;
707
708
709
	input_report_abs(idev, ABS_X, x - rest_x);
	input_report_abs(idev, ABS_Y, y - rest_y);
	input_sync(idev);
710
711
712
713
}

/* Sysfs Files */

714
715
716
717
718
719
static ssize_t applesmc_name_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "applesmc\n");
}

720
721
722
723
724
725
static ssize_t applesmc_position_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	int ret;
	s16 x, y, z;

726
	ret = applesmc_read_s16(MOTION_SENSOR_X_KEY, &x);
727
728
	if (ret)
		goto out;
729
	ret = applesmc_read_s16(MOTION_SENSOR_Y_KEY, &y);
730
731
	if (ret)
		goto out;
732
	ret = applesmc_read_s16(MOTION_SENSOR_Z_KEY, &z);
733
734
735
736
737
738
739
740
741
742
743
744
745
	if (ret)
		goto out;

out:
	if (ret)
		return ret;
	else
		return snprintf(buf, PAGE_SIZE, "(%d,%d,%d)\n", x, y, z);
}

static ssize_t applesmc_light_show(struct device *dev,
				struct device_attribute *attr, char *sysfsbuf)
{
746
	const struct applesmc_entry *entry;
747
	static int data_length;
748
749
	int ret;
	u8 left = 0, right = 0;
750
	u8 buffer[10];
751

752
	if (!data_length) {
753
754
755
756
757
758
		entry = applesmc_get_entry_by_key(LIGHT_SENSOR_LEFT_KEY);
		if (IS_ERR(entry))
			return PTR_ERR(entry);
		if (entry->len > 10)
			return -ENXIO;
		data_length = entry->len;
759
		pr_info("light sensor data length set to %d\n", data_length);
760
761
762
	}

	ret = applesmc_read_key(LIGHT_SENSOR_LEFT_KEY, buffer, data_length);
763
764
765
766
767
	/* newer macbooks report a single 10-bit bigendian value */
	if (data_length == 10) {
		left = be16_to_cpu(*(__be16 *)(buffer + 6)) >> 2;
		goto out;
	}
768
769
770
	left = buffer[2];
	if (ret)
		goto out;
771
	ret = applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY, buffer, data_length);
772
773
774
775
776
777
778
779
780
	right = buffer[2];

out:
	if (ret)
		return ret;
	else
		return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", left, right);
}

781
782
783
784
/* Displays sensor key as label */
static ssize_t applesmc_show_sensor_label(struct device *dev,
			struct device_attribute *devattr, char *sysfsbuf)
{
785
	const char *key = smcreg.index[to_index(devattr)];
786

787
	return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", key);
788
789
}

790
791
792
793
/* Displays degree Celsius * 1000 */
static ssize_t applesmc_show_temperature(struct device *dev,
			struct device_attribute *devattr, char *sysfsbuf)
{
794
	const char *key = smcreg.index[to_index(devattr)];
795
	int ret;
796
797
	s16 value;
	int temp;
798

799
	ret = applesmc_read_s16(key, &value);
800
801
	if (ret)
		return ret;
802

803
	temp = 250 * (value >> 6);
804

805
	return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", temp);
806
807
808
809
810
811
812
813
814
815
}

static ssize_t applesmc_show_fan_speed(struct device *dev,
				struct device_attribute *attr, char *sysfsbuf)
{
	int ret;
	unsigned int speed = 0;
	char newkey[5];
	u8 buffer[2];

816
817
	scnprintf(newkey, sizeof(newkey), fan_speed_fmt[to_option(attr)],
		  to_index(attr));
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832

	ret = applesmc_read_key(newkey, buffer, 2);
	speed = ((buffer[0] << 8 | buffer[1]) >> 2);

	if (ret)
		return ret;
	else
		return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", speed);
}

static ssize_t applesmc_store_fan_speed(struct device *dev,
					struct device_attribute *attr,
					const char *sysfsbuf, size_t count)
{
	int ret;
833
	unsigned long speed;
834
835
836
	char newkey[5];
	u8 buffer[2];

837
	if (kstrtoul(sysfsbuf, 10, &speed) < 0 || speed >= 0x4000)
838
		return -EINVAL;		/* Bigger than a 14-bit value */
839

840
841
	scnprintf(newkey, sizeof(newkey), fan_speed_fmt[to_option(attr)],
		  to_index(attr));
842
843
844
845
846
847
848
849
850
851
852
853

	buffer[0] = (speed >> 6) & 0xff;
	buffer[1] = (speed << 2) & 0xff;
	ret = applesmc_write_key(newkey, buffer, 2);

	if (ret)
		return ret;
	else
		return count;
}

static ssize_t applesmc_show_fan_manual(struct device *dev,
854
			struct device_attribute *attr, char *sysfsbuf)
855
856
857
858
859
860
{
	int ret;
	u16 manual = 0;
	u8 buffer[2];

	ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
861
	manual = ((buffer[0] << 8 | buffer[1]) >> to_index(attr)) & 0x01;
862
863
864
865
866
867
868
869

	if (ret)
		return ret;
	else
		return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", manual);
}

static ssize_t applesmc_store_fan_manual(struct device *dev,
870
					 struct device_attribute *attr,
871
872
873
874
					 const char *sysfsbuf, size_t count)
{
	int ret;
	u8 buffer[2];
875
	unsigned long input;
876
877
	u16 val;

878
	if (kstrtoul(sysfsbuf, 10, &input) < 0)
879
		return -EINVAL;
880
881
882
883
884
885
886

	ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
	val = (buffer[0] << 8 | buffer[1]);
	if (ret)
		goto out;

	if (input)
887
		val = val | (0x01 << to_index(attr));
888
	else
889
		val = val & ~(0x01 << to_index(attr));
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909

	buffer[0] = (val >> 8) & 0xFF;
	buffer[1] = val & 0xFF;

	ret = applesmc_write_key(FANS_MANUAL, buffer, 2);

out:
	if (ret)
		return ret;
	else
		return count;
}

static ssize_t applesmc_show_fan_position(struct device *dev,
				struct device_attribute *attr, char *sysfsbuf)
{
	int ret;
	char newkey[5];
	u8 buffer[17];

910
	scnprintf(newkey, sizeof(newkey), FAN_ID_FMT, to_index(attr));
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936

	ret = applesmc_read_key(newkey, buffer, 16);
	buffer[16] = 0;

	if (ret)
		return ret;
	else
		return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", buffer+4);
}

static ssize_t applesmc_calibrate_show(struct device *dev,
				struct device_attribute *attr, char *sysfsbuf)
{
	return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", rest_x, rest_y);
}

static ssize_t applesmc_calibrate_store(struct device *dev,
	struct device_attribute *attr, const char *sysfsbuf, size_t count)
{
	applesmc_calibrate();

	return count;
}

static void applesmc_backlight_set(struct work_struct *work)
{
937
	applesmc_write_key(BACKLIGHT_KEY, backlight_state, 2);
938
939
940
941
942
943
944
945
}
static DECLARE_WORK(backlight_work, &applesmc_backlight_set);

static void applesmc_brightness_set(struct led_classdev *led_cdev,
						enum led_brightness value)
{
	int ret;

946
	backlight_state[0] = value;
947
948
949
	ret = queue_work(applesmc_led_wq, &backlight_work);

	if (debug && (!ret))
950
		dev_dbg(led_cdev->dev, "work was already on the queue.\n");
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
}

static ssize_t applesmc_key_count_show(struct device *dev,
				struct device_attribute *attr, char *sysfsbuf)
{
	int ret;
	u8 buffer[4];
	u32 count;

	ret = applesmc_read_key(KEY_COUNT_KEY, buffer, 4);
	count = ((u32)buffer[0]<<24) + ((u32)buffer[1]<<16) +
						((u32)buffer[2]<<8) + buffer[3];

	if (ret)
		return ret;
	else
		return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", count);
}

static ssize_t applesmc_key_at_index_read_show(struct device *dev,
				struct device_attribute *attr, char *sysfsbuf)
{
973
	const struct applesmc_entry *entry;
974
975
	int ret;

976
977
978
979
980
	entry = applesmc_get_entry_by_index(key_at_index);
	if (IS_ERR(entry))
		return PTR_ERR(entry);
	ret = applesmc_read_entry(entry, sysfsbuf, entry->len);
	if (ret)
981
982
		return ret;

983
	return entry->len;
984
985
986
987
988
}

static ssize_t applesmc_key_at_index_data_length_show(struct device *dev,
				struct device_attribute *attr, char *sysfsbuf)
{
989
	const struct applesmc_entry *entry;
990

991
992
993
	entry = applesmc_get_entry_by_index(key_at_index);
	if (IS_ERR(entry))
		return PTR_ERR(entry);
994

995
	return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", entry->len);
996
997
998
999
1000
}

static ssize_t applesmc_key_at_index_type_show(struct device *dev,
				struct device_attribute *attr, char *sysfsbuf)
{
1001
	const struct applesmc_entry *entry;
1002

1003
1004
1005
	entry = applesmc_get_entry_by_index(key_at_index);
	if (IS_ERR(entry))
		return PTR_ERR(entry);
1006

1007
	return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", entry->type);
1008
1009
1010
1011
1012
}

static ssize_t applesmc_key_at_index_name_show(struct device *dev,
				struct device_attribute *attr, char *sysfsbuf)
{
1013
	const struct applesmc_entry *entry;
1014

1015
1016
1017
	entry = applesmc_get_entry_by_index(key_at_index);
	if (IS_ERR(entry))
		return PTR_ERR(entry);
1018

1019
	return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", entry->key);
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
}

static ssize_t applesmc_key_at_index_show(struct device *dev,
				struct device_attribute *attr, char *sysfsbuf)
{
	return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", key_at_index);
}

static ssize_t applesmc_key_at_index_store(struct device *dev,
	struct device_attribute *attr, const char *sysfsbuf, size_t count)
{
1031
	unsigned long newkey;
1032

1033
	if (kstrtoul(sysfsbuf, 10, &newkey) < 0
1034
1035
	    || newkey >= smcreg.key_count)
		return -EINVAL;
1036

1037
	key_at_index = newkey;
1038
1039
1040
1041
	return count;
}

static struct led_classdev applesmc_backlight = {
1042
	.name			= "smc::kbd_backlight",
1043
1044
1045
1046
	.default_trigger	= "nand-disk",
	.brightness_set		= applesmc_brightness_set,
};

1047
1048
1049
1050
1051
1052
1053
1054
1055
static struct applesmc_node_group info_group[] = {
	{ "name", applesmc_name_show },
	{ "key_count", applesmc_key_count_show },
	{ "key_at_index", applesmc_key_at_index_show, applesmc_key_at_index_store },
	{ "key_at_index_name", applesmc_key_at_index_name_show },
	{ "key_at_index_type", applesmc_key_at_index_type_show },
	{ "key_at_index_data_length", applesmc_key_at_index_data_length_show },
	{ "key_at_index_data", applesmc_key_at_index_read_show },
	{ }
1056
1057
};

1058
1059
1060
1061
static struct applesmc_node_group accelerometer_group[] = {
	{ "position", applesmc_position_show },
	{ "calibrate", applesmc_calibrate_show, applesmc_calibrate_store },
	{ }
1062
1063
};

1064
1065
1066
1067
static struct applesmc_node_group light_sensor_group[] = {
	{ "light", applesmc_light_show },
	{ }
};
1068

1069
1070
1071
1072
1073
1074
1075
1076
1077
static struct applesmc_node_group fan_group[] = {
	{ "fan%d_label", applesmc_show_fan_position },
	{ "fan%d_input", applesmc_show_fan_speed, NULL, 0 },
	{ "fan%d_min", applesmc_show_fan_speed, applesmc_store_fan_speed, 1 },
	{ "fan%d_max", applesmc_show_fan_speed, NULL, 2 },
	{ "fan%d_safe", applesmc_show_fan_speed, NULL, 3 },
	{ "fan%d_output", applesmc_show_fan_speed, applesmc_store_fan_speed, 4 },
	{ "fan%d_manual", applesmc_show_fan_manual, applesmc_store_fan_manual },
	{ }
1078
1079
};

1080
1081
1082
1083
static struct applesmc_node_group temp_group[] = {
	{ "temp%d_label", applesmc_show_sensor_label },
	{ "temp%d_input", applesmc_show_temperature },
	{ }
1084
1085
};

1086
1087
/* Module stuff */

1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
/*
 * applesmc_destroy_nodes - remove files and free associated memory
 */
static void applesmc_destroy_nodes(struct applesmc_node_group *groups)
{
	struct applesmc_node_group *grp;
	struct applesmc_dev_attr *node;

	for (grp = groups; grp->nodes; grp++) {
		for (node = grp->nodes; node->sda.dev_attr.attr.name; node++)
			sysfs_remove_file(&pdev->dev.kobj,
					  &node->sda.dev_attr.attr);
		kfree(grp->nodes);
		grp->nodes = NULL;
	}
}

/*
 * applesmc_create_nodes - create a two-dimensional group of sysfs files
 */
static int applesmc_create_nodes(struct applesmc_node_group *groups, int num)
{
	struct applesmc_node_group *grp;
	struct applesmc_dev_attr *node;
	struct attribute *attr;
	int ret, i;

	for (grp = groups; grp->format; grp++) {
		grp->nodes = kcalloc(num + 1, sizeof(*node), GFP_KERNEL);
		if (!grp->nodes) {
			ret = -ENOMEM;
			goto out;
		}
		for (i = 0; i < num; i++) {
			node = &grp->nodes[i];
1123
1124
			scnprintf(node->name, sizeof(node->name), grp->format,
				  i + 1);
1125
			node->sda.index = (grp->option << 16) | (i & 0xffff);
1126
1127
1128
			node->sda.dev_attr.show = grp->show;
			node->sda.dev_attr.store = grp->store;
			attr = &node->sda.dev_attr.attr;
1129
			sysfs_attr_init(attr);
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
			attr->name = node->name;
			attr->mode = S_IRUGO | (grp->store ? S_IWUSR : 0);
			ret = sysfs_create_file(&pdev->dev.kobj, attr);
			if (ret) {
				attr->name = NULL;
				goto out;
			}
		}
	}

	return 0;
out:
	applesmc_destroy_nodes(groups);
	return ret;
}

1146
/* Create accelerometer resources */
1147
1148
static int applesmc_create_accelerometer(void)
{
1149
	struct input_dev *idev;
1150
1151
	int ret;

1152
1153
1154
1155
	if (!smcreg.has_accelerometer)
		return 0;

	ret = applesmc_create_nodes(accelerometer_group, 1);
1156
1157
1158
	if (ret)
		goto out;

1159
	applesmc_idev = input_allocate_polled_device();
1160
1161
1162
1163
1164
	if (!applesmc_idev) {
		ret = -ENOMEM;
		goto out_sysfs;
	}

1165
1166
1167
	applesmc_idev->poll = applesmc_idev_poll;
	applesmc_idev->poll_interval = APPLESMC_POLL_INTERVAL;

1168
1169
1170
	/* initial calibrate for the input device */
	applesmc_calibrate();

1171
1172
1173
1174
1175
	/* initialize the input device */
	idev = applesmc_idev->input;
	idev->name = "applesmc";
	idev->id.bustype = BUS_HOST;
	idev->dev.parent = &pdev->dev;
1176
	idev->evbit[0] = BIT_MASK(EV_ABS);
1177
	input_set_abs_params(idev, ABS_X,
1178
			-256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);
1179
	input_set_abs_params(idev, ABS_Y,
1180
1181
			-256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);

1182
	ret = input_register_polled_device(applesmc_idev);
1183
1184
1185
1186
1187
1188
	if (ret)
		goto out_idev;

	return 0;

out_idev:
1189
	input_free_polled_device(applesmc_idev);
1190
1191

out_sysfs:
1192
	applesmc_destroy_nodes(accelerometer_group);
1193
1194

out:
1195
	pr_warn("driver init failed (ret=%d)!\n", ret);
1196
1197
1198
	return ret;
}

1199
/* Release all resources used by the accelerometer */
1200
1201
static void applesmc_release_accelerometer(void)
{
1202
1203
	if (!smcreg.has_accelerometer)
		return;
1204
1205
	input_unregister_polled_device(applesmc_idev);
	input_free_polled_device(applesmc_idev);
1206
	applesmc_destroy_nodes(accelerometer_group);
1207
}
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240

static int applesmc_create_light_sensor(void)
{
	if (!smcreg.num_light_sensors)
		return 0;
	return applesmc_create_nodes(light_sensor_group, 1);
}

static void applesmc_release_light_sensor(void)
{
	if (!smcreg.num_light_sensors)
		return;
	applesmc_destroy_nodes(light_sensor_group);
}

static int applesmc_create_key_backlight(void)
{
	if (!smcreg.has_key_backlight)
		return 0;
	applesmc_led_wq = create_singlethread_workqueue("applesmc-led");
	if (!applesmc_led_wq)
		return -ENOMEM;
	return led_classdev_register(&pdev->dev, &applesmc_backlight);
}

static void applesmc_release_key_backlight(void)
{
	if (!smcreg.has_key_backlight)
		return;
	led_classdev_unregister(&applesmc_backlight);
	destroy_workqueue(applesmc_led_wq);
}

1241
1242
1243
1244
static int applesmc_dmi_match(const struct dmi_system_id *id)
{
	return 1;
}
1245

1246
1247
1248
1249
/*
 * Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
 * So we need to put "Apple MacBook Pro" before "Apple MacBook".
 */
1250
static __initdata struct dmi_system_id applesmc_whitelist[] = {
1251
1252
1253
	{ applesmc_dmi_match, "Apple MacBook Air", {
	  DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
	  DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir") },
1254
	},
1255
	{ applesmc_dmi_match, "Apple MacBook Pro", {
1256
1257
	  DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
	  DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro") },
1258
	},
1259
	{ applesmc_dmi_match, "Apple MacBook", {
1260
1261
	  DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
	  DMI_MATCH(DMI_PRODUCT_NAME, "MacBook") },
1262
	},
1263
	{ applesmc_dmi_match, "Apple Macmini", {
1264
1265
	  DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
	  DMI_MATCH(DMI_PRODUCT_NAME, "Macmini") },
1266
	},
1267
1268
1269
	{ applesmc_dmi_match, "Apple MacPro", {
	  DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
	  DMI_MATCH(DMI_PRODUCT_NAME, "MacPro") },
1270
	},
1271
	{ applesmc_dmi_match, "Apple iMac", {
1272
1273
	  DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
	  DMI_MATCH(DMI_PRODUCT_NAME, "iMac") },
1274
	},
1275
1276
1277
1278
1279
1280
1281
1282
	{ .ident = NULL }
};

static int __init applesmc_init(void)
{
	int ret;

	if (!dmi_check_system(applesmc_whitelist)) {
1283
		pr_warn("supported laptop not found!\n");
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
		ret = -ENODEV;
		goto out;
	}