Loading...
1/*
2 * hdaps.c - driver for IBM's Hard Drive Active Protection System
3 *
4 * Copyright (C) 2005 Robert Love <rml@novell.com>
5 * Copyright (C) 2005 Jesper Juhl <jesper.juhl@gmail.com>
6 *
7 * The HardDisk Active Protection System (hdaps) is present in IBM ThinkPads
8 * starting with the R40, T41, and X40. It provides a basic two-axis
9 * accelerometer and other data, such as the device's temperature.
10 *
11 * This driver is based on the document by Mark A. Smith available at
12 * http://www.almaden.ibm.com/cs/people/marksmith/tpaps.html and a lot of trial
13 * and error.
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#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
30
31#include <linux/delay.h>
32#include <linux/platform_device.h>
33#include <linux/input-polldev.h>
34#include <linux/kernel.h>
35#include <linux/mutex.h>
36#include <linux/module.h>
37#include <linux/timer.h>
38#include <linux/dmi.h>
39#include <linux/jiffies.h>
40#include <linux/io.h>
41
42#define HDAPS_LOW_PORT 0x1600 /* first port used by hdaps */
43#define HDAPS_NR_PORTS 0x30 /* number of ports: 0x1600 - 0x162f */
44
45#define HDAPS_PORT_STATE 0x1611 /* device state */
46#define HDAPS_PORT_YPOS 0x1612 /* y-axis position */
47#define HDAPS_PORT_XPOS 0x1614 /* x-axis position */
48#define HDAPS_PORT_TEMP1 0x1616 /* device temperature, in Celsius */
49#define HDAPS_PORT_YVAR 0x1617 /* y-axis variance (what is this?) */
50#define HDAPS_PORT_XVAR 0x1619 /* x-axis variance (what is this?) */
51#define HDAPS_PORT_TEMP2 0x161b /* device temperature (again?) */
52#define HDAPS_PORT_UNKNOWN 0x161c /* what is this? */
53#define HDAPS_PORT_KMACT 0x161d /* keyboard or mouse activity */
54
55#define STATE_FRESH 0x50 /* accelerometer data is fresh */
56
57#define KEYBD_MASK 0x20 /* set if keyboard activity */
58#define MOUSE_MASK 0x40 /* set if mouse activity */
59#define KEYBD_ISSET(n) (!! (n & KEYBD_MASK)) /* keyboard used? */
60#define MOUSE_ISSET(n) (!! (n & MOUSE_MASK)) /* mouse used? */
61
62#define INIT_TIMEOUT_MSECS 4000 /* wait up to 4s for device init ... */
63#define INIT_WAIT_MSECS 200 /* ... in 200ms increments */
64
65#define HDAPS_POLL_INTERVAL 50 /* poll for input every 1/20s (50 ms)*/
66#define HDAPS_INPUT_FUZZ 4 /* input event threshold */
67#define HDAPS_INPUT_FLAT 4
68
69#define HDAPS_X_AXIS (1 << 0)
70#define HDAPS_Y_AXIS (1 << 1)
71#define HDAPS_BOTH_AXES (HDAPS_X_AXIS | HDAPS_Y_AXIS)
72
73static struct platform_device *pdev;
74static struct input_polled_dev *hdaps_idev;
75static unsigned int hdaps_invert;
76static u8 km_activity;
77static int rest_x;
78static int rest_y;
79
80static DEFINE_MUTEX(hdaps_mtx);
81
82/*
83 * __get_latch - Get the value from a given port. Callers must hold hdaps_mtx.
84 */
85static inline u8 __get_latch(u16 port)
86{
87 return inb(port) & 0xff;
88}
89
90/*
91 * __check_latch - Check a port latch for a given value. Returns zero if the
92 * port contains the given value. Callers must hold hdaps_mtx.
93 */
94static inline int __check_latch(u16 port, u8 val)
95{
96 if (__get_latch(port) == val)
97 return 0;
98 return -EINVAL;
99}
100
101/*
102 * __wait_latch - Wait up to 100us for a port latch to get a certain value,
103 * returning zero if the value is obtained. Callers must hold hdaps_mtx.
104 */
105static int __wait_latch(u16 port, u8 val)
106{
107 unsigned int i;
108
109 for (i = 0; i < 20; i++) {
110 if (!__check_latch(port, val))
111 return 0;
112 udelay(5);
113 }
114
115 return -EIO;
116}
117
118/*
119 * __device_refresh - request a refresh from the accelerometer. Does not wait
120 * for refresh to complete. Callers must hold hdaps_mtx.
121 */
122static void __device_refresh(void)
123{
124 udelay(200);
125 if (inb(0x1604) != STATE_FRESH) {
126 outb(0x11, 0x1610);
127 outb(0x01, 0x161f);
128 }
129}
130
131/*
132 * __device_refresh_sync - request a synchronous refresh from the
133 * accelerometer. We wait for the refresh to complete. Returns zero if
134 * successful and nonzero on error. Callers must hold hdaps_mtx.
135 */
136static int __device_refresh_sync(void)
137{
138 __device_refresh();
139 return __wait_latch(0x1604, STATE_FRESH);
140}
141
142/*
143 * __device_complete - indicate to the accelerometer that we are done reading
144 * data, and then initiate an async refresh. Callers must hold hdaps_mtx.
145 */
146static inline void __device_complete(void)
147{
148 inb(0x161f);
149 inb(0x1604);
150 __device_refresh();
151}
152
153/*
154 * hdaps_readb_one - reads a byte from a single I/O port, placing the value in
155 * the given pointer. Returns zero on success or a negative error on failure.
156 * Can sleep.
157 */
158static int hdaps_readb_one(unsigned int port, u8 *val)
159{
160 int ret;
161
162 mutex_lock(&hdaps_mtx);
163
164 /* do a sync refresh -- we need to be sure that we read fresh data */
165 ret = __device_refresh_sync();
166 if (ret)
167 goto out;
168
169 *val = inb(port);
170 __device_complete();
171
172out:
173 mutex_unlock(&hdaps_mtx);
174 return ret;
175}
176
177/* __hdaps_read_pair - internal lockless helper for hdaps_read_pair(). */
178static int __hdaps_read_pair(unsigned int port1, unsigned int port2,
179 int *x, int *y)
180{
181 /* do a sync refresh -- we need to be sure that we read fresh data */
182 if (__device_refresh_sync())
183 return -EIO;
184
185 *y = inw(port2);
186 *x = inw(port1);
187 km_activity = inb(HDAPS_PORT_KMACT);
188 __device_complete();
189
190 /* hdaps_invert is a bitvector to negate the axes */
191 if (hdaps_invert & HDAPS_X_AXIS)
192 *x = -*x;
193 if (hdaps_invert & HDAPS_Y_AXIS)
194 *y = -*y;
195
196 return 0;
197}
198
199/*
200 * hdaps_read_pair - reads the values from a pair of ports, placing the values
201 * in the given pointers. Returns zero on success. Can sleep.
202 */
203static int hdaps_read_pair(unsigned int port1, unsigned int port2,
204 int *val1, int *val2)
205{
206 int ret;
207
208 mutex_lock(&hdaps_mtx);
209 ret = __hdaps_read_pair(port1, port2, val1, val2);
210 mutex_unlock(&hdaps_mtx);
211
212 return ret;
213}
214
215/*
216 * hdaps_device_init - initialize the accelerometer. Returns zero on success
217 * and negative error code on failure. Can sleep.
218 */
219static int hdaps_device_init(void)
220{
221 int total, ret = -ENXIO;
222
223 mutex_lock(&hdaps_mtx);
224
225 outb(0x13, 0x1610);
226 outb(0x01, 0x161f);
227 if (__wait_latch(0x161f, 0x00))
228 goto out;
229
230 /*
231 * Most ThinkPads return 0x01.
232 *
233 * Others--namely the R50p, T41p, and T42p--return 0x03. These laptops
234 * have "inverted" axises.
235 *
236 * The 0x02 value occurs when the chip has been previously initialized.
237 */
238 if (__check_latch(0x1611, 0x03) &&
239 __check_latch(0x1611, 0x02) &&
240 __check_latch(0x1611, 0x01))
241 goto out;
242
243 printk(KERN_DEBUG "hdaps: initial latch check good (0x%02x)\n",
244 __get_latch(0x1611));
245
246 outb(0x17, 0x1610);
247 outb(0x81, 0x1611);
248 outb(0x01, 0x161f);
249 if (__wait_latch(0x161f, 0x00))
250 goto out;
251 if (__wait_latch(0x1611, 0x00))
252 goto out;
253 if (__wait_latch(0x1612, 0x60))
254 goto out;
255 if (__wait_latch(0x1613, 0x00))
256 goto out;
257 outb(0x14, 0x1610);
258 outb(0x01, 0x1611);
259 outb(0x01, 0x161f);
260 if (__wait_latch(0x161f, 0x00))
261 goto out;
262 outb(0x10, 0x1610);
263 outb(0xc8, 0x1611);
264 outb(0x00, 0x1612);
265 outb(0x02, 0x1613);
266 outb(0x01, 0x161f);
267 if (__wait_latch(0x161f, 0x00))
268 goto out;
269 if (__device_refresh_sync())
270 goto out;
271 if (__wait_latch(0x1611, 0x00))
272 goto out;
273
274 /* we have done our dance, now let's wait for the applause */
275 for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
276 int x, y;
277
278 /* a read of the device helps push it into action */
279 __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
280 if (!__wait_latch(0x1611, 0x02)) {
281 ret = 0;
282 break;
283 }
284
285 msleep(INIT_WAIT_MSECS);
286 }
287
288out:
289 mutex_unlock(&hdaps_mtx);
290 return ret;
291}
292
293
294/* Device model stuff */
295
296static int hdaps_probe(struct platform_device *dev)
297{
298 int ret;
299
300 ret = hdaps_device_init();
301 if (ret)
302 return ret;
303
304 pr_info("device successfully initialized\n");
305 return 0;
306}
307
308static int hdaps_resume(struct platform_device *dev)
309{
310 return hdaps_device_init();
311}
312
313static struct platform_driver hdaps_driver = {
314 .probe = hdaps_probe,
315 .resume = hdaps_resume,
316 .driver = {
317 .name = "hdaps",
318 .owner = THIS_MODULE,
319 },
320};
321
322/*
323 * hdaps_calibrate - Set our "resting" values. Callers must hold hdaps_mtx.
324 */
325static void hdaps_calibrate(void)
326{
327 __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &rest_x, &rest_y);
328}
329
330static void hdaps_mousedev_poll(struct input_polled_dev *dev)
331{
332 struct input_dev *input_dev = dev->input;
333 int x, y;
334
335 mutex_lock(&hdaps_mtx);
336
337 if (__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y))
338 goto out;
339
340 input_report_abs(input_dev, ABS_X, x - rest_x);
341 input_report_abs(input_dev, ABS_Y, y - rest_y);
342 input_sync(input_dev);
343
344out:
345 mutex_unlock(&hdaps_mtx);
346}
347
348
349/* Sysfs Files */
350
351static ssize_t hdaps_position_show(struct device *dev,
352 struct device_attribute *attr, char *buf)
353{
354 int ret, x, y;
355
356 ret = hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
357 if (ret)
358 return ret;
359
360 return sprintf(buf, "(%d,%d)\n", x, y);
361}
362
363static ssize_t hdaps_variance_show(struct device *dev,
364 struct device_attribute *attr, char *buf)
365{
366 int ret, x, y;
367
368 ret = hdaps_read_pair(HDAPS_PORT_XVAR, HDAPS_PORT_YVAR, &x, &y);
369 if (ret)
370 return ret;
371
372 return sprintf(buf, "(%d,%d)\n", x, y);
373}
374
375static ssize_t hdaps_temp1_show(struct device *dev,
376 struct device_attribute *attr, char *buf)
377{
378 u8 temp;
379 int ret;
380
381 ret = hdaps_readb_one(HDAPS_PORT_TEMP1, &temp);
382 if (ret < 0)
383 return ret;
384
385 return sprintf(buf, "%u\n", temp);
386}
387
388static ssize_t hdaps_temp2_show(struct device *dev,
389 struct device_attribute *attr, char *buf)
390{
391 u8 temp;
392 int ret;
393
394 ret = hdaps_readb_one(HDAPS_PORT_TEMP2, &temp);
395 if (ret < 0)
396 return ret;
397
398 return sprintf(buf, "%u\n", temp);
399}
400
401static ssize_t hdaps_keyboard_activity_show(struct device *dev,
402 struct device_attribute *attr,
403 char *buf)
404{
405 return sprintf(buf, "%u\n", KEYBD_ISSET(km_activity));
406}
407
408static ssize_t hdaps_mouse_activity_show(struct device *dev,
409 struct device_attribute *attr,
410 char *buf)
411{
412 return sprintf(buf, "%u\n", MOUSE_ISSET(km_activity));
413}
414
415static ssize_t hdaps_calibrate_show(struct device *dev,
416 struct device_attribute *attr, char *buf)
417{
418 return sprintf(buf, "(%d,%d)\n", rest_x, rest_y);
419}
420
421static ssize_t hdaps_calibrate_store(struct device *dev,
422 struct device_attribute *attr,
423 const char *buf, size_t count)
424{
425 mutex_lock(&hdaps_mtx);
426 hdaps_calibrate();
427 mutex_unlock(&hdaps_mtx);
428
429 return count;
430}
431
432static ssize_t hdaps_invert_show(struct device *dev,
433 struct device_attribute *attr, char *buf)
434{
435 return sprintf(buf, "%u\n", hdaps_invert);
436}
437
438static ssize_t hdaps_invert_store(struct device *dev,
439 struct device_attribute *attr,
440 const char *buf, size_t count)
441{
442 int invert;
443
444 if (sscanf(buf, "%d", &invert) != 1 ||
445 invert < 0 || invert > HDAPS_BOTH_AXES)
446 return -EINVAL;
447
448 hdaps_invert = invert;
449 hdaps_calibrate();
450
451 return count;
452}
453
454static DEVICE_ATTR(position, 0444, hdaps_position_show, NULL);
455static DEVICE_ATTR(variance, 0444, hdaps_variance_show, NULL);
456static DEVICE_ATTR(temp1, 0444, hdaps_temp1_show, NULL);
457static DEVICE_ATTR(temp2, 0444, hdaps_temp2_show, NULL);
458static DEVICE_ATTR(keyboard_activity, 0444, hdaps_keyboard_activity_show, NULL);
459static DEVICE_ATTR(mouse_activity, 0444, hdaps_mouse_activity_show, NULL);
460static DEVICE_ATTR(calibrate, 0644, hdaps_calibrate_show,hdaps_calibrate_store);
461static DEVICE_ATTR(invert, 0644, hdaps_invert_show, hdaps_invert_store);
462
463static struct attribute *hdaps_attributes[] = {
464 &dev_attr_position.attr,
465 &dev_attr_variance.attr,
466 &dev_attr_temp1.attr,
467 &dev_attr_temp2.attr,
468 &dev_attr_keyboard_activity.attr,
469 &dev_attr_mouse_activity.attr,
470 &dev_attr_calibrate.attr,
471 &dev_attr_invert.attr,
472 NULL,
473};
474
475static struct attribute_group hdaps_attribute_group = {
476 .attrs = hdaps_attributes,
477};
478
479
480/* Module stuff */
481
482/* hdaps_dmi_match - found a match. return one, short-circuiting the hunt. */
483static int __init hdaps_dmi_match(const struct dmi_system_id *id)
484{
485 pr_info("%s detected\n", id->ident);
486 return 1;
487}
488
489/* hdaps_dmi_match_invert - found an inverted match. */
490static int __init hdaps_dmi_match_invert(const struct dmi_system_id *id)
491{
492 hdaps_invert = (unsigned long)id->driver_data;
493 pr_info("inverting axis (%u) readings\n", hdaps_invert);
494 return hdaps_dmi_match(id);
495}
496
497#define HDAPS_DMI_MATCH_INVERT(vendor, model, axes) { \
498 .ident = vendor " " model, \
499 .callback = hdaps_dmi_match_invert, \
500 .driver_data = (void *)axes, \
501 .matches = { \
502 DMI_MATCH(DMI_BOARD_VENDOR, vendor), \
503 DMI_MATCH(DMI_PRODUCT_VERSION, model) \
504 } \
505}
506
507#define HDAPS_DMI_MATCH_NORMAL(vendor, model) \
508 HDAPS_DMI_MATCH_INVERT(vendor, model, 0)
509
510/* Note that HDAPS_DMI_MATCH_NORMAL("ThinkPad T42") would match
511 "ThinkPad T42p", so the order of the entries matters.
512 If your ThinkPad is not recognized, please update to latest
513 BIOS. This is especially the case for some R52 ThinkPads. */
514static struct dmi_system_id __initdata hdaps_whitelist[] = {
515 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad R50p", HDAPS_BOTH_AXES),
516 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R50"),
517 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R51"),
518 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R52"),
519 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R61i", HDAPS_BOTH_AXES),
520 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R61", HDAPS_BOTH_AXES),
521 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T41p", HDAPS_BOTH_AXES),
522 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T41"),
523 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T42p", HDAPS_BOTH_AXES),
524 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T42"),
525 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T43"),
526 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T400", HDAPS_BOTH_AXES),
527 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T60", HDAPS_BOTH_AXES),
528 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61p", HDAPS_BOTH_AXES),
529 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61", HDAPS_BOTH_AXES),
530 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad X40"),
531 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad X41", HDAPS_Y_AXIS),
532 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X60", HDAPS_BOTH_AXES),
533 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61s", HDAPS_BOTH_AXES),
534 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61", HDAPS_BOTH_AXES),
535 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad Z60m"),
536 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61m", HDAPS_BOTH_AXES),
537 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61p", HDAPS_BOTH_AXES),
538 { .ident = NULL }
539};
540
541static int __init hdaps_init(void)
542{
543 struct input_dev *idev;
544 int ret;
545
546 if (!dmi_check_system(hdaps_whitelist)) {
547 pr_warn("supported laptop not found!\n");
548 ret = -ENODEV;
549 goto out;
550 }
551
552 if (!request_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS, "hdaps")) {
553 ret = -ENXIO;
554 goto out;
555 }
556
557 ret = platform_driver_register(&hdaps_driver);
558 if (ret)
559 goto out_region;
560
561 pdev = platform_device_register_simple("hdaps", -1, NULL, 0);
562 if (IS_ERR(pdev)) {
563 ret = PTR_ERR(pdev);
564 goto out_driver;
565 }
566
567 ret = sysfs_create_group(&pdev->dev.kobj, &hdaps_attribute_group);
568 if (ret)
569 goto out_device;
570
571 hdaps_idev = input_allocate_polled_device();
572 if (!hdaps_idev) {
573 ret = -ENOMEM;
574 goto out_group;
575 }
576
577 hdaps_idev->poll = hdaps_mousedev_poll;
578 hdaps_idev->poll_interval = HDAPS_POLL_INTERVAL;
579
580 /* initial calibrate for the input device */
581 hdaps_calibrate();
582
583 /* initialize the input class */
584 idev = hdaps_idev->input;
585 idev->name = "hdaps";
586 idev->phys = "isa1600/input0";
587 idev->id.bustype = BUS_ISA;
588 idev->dev.parent = &pdev->dev;
589 idev->evbit[0] = BIT_MASK(EV_ABS);
590 input_set_abs_params(idev, ABS_X,
591 -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
592 input_set_abs_params(idev, ABS_Y,
593 -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
594
595 ret = input_register_polled_device(hdaps_idev);
596 if (ret)
597 goto out_idev;
598
599 pr_info("driver successfully loaded\n");
600 return 0;
601
602out_idev:
603 input_free_polled_device(hdaps_idev);
604out_group:
605 sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
606out_device:
607 platform_device_unregister(pdev);
608out_driver:
609 platform_driver_unregister(&hdaps_driver);
610out_region:
611 release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
612out:
613 pr_warn("driver init failed (ret=%d)!\n", ret);
614 return ret;
615}
616
617static void __exit hdaps_exit(void)
618{
619 input_unregister_polled_device(hdaps_idev);
620 input_free_polled_device(hdaps_idev);
621 sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
622 platform_device_unregister(pdev);
623 platform_driver_unregister(&hdaps_driver);
624 release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
625
626 pr_info("driver unloaded\n");
627}
628
629module_init(hdaps_init);
630module_exit(hdaps_exit);
631
632module_param_named(invert, hdaps_invert, int, 0);
633MODULE_PARM_DESC(invert, "invert data along each axis. 1 invert x-axis, "
634 "2 invert y-axis, 3 invert both axes.");
635
636MODULE_AUTHOR("Robert Love");
637MODULE_DESCRIPTION("IBM Hard Drive Active Protection System (HDAPS) driver");
638MODULE_LICENSE("GPL v2");
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * hdaps.c - driver for IBM's Hard Drive Active Protection System
4 *
5 * Copyright (C) 2005 Robert Love <rml@novell.com>
6 * Copyright (C) 2005 Jesper Juhl <jj@chaosbits.net>
7 *
8 * The HardDisk Active Protection System (hdaps) is present in IBM ThinkPads
9 * starting with the R40, T41, and X40. It provides a basic two-axis
10 * accelerometer and other data, such as the device's temperature.
11 *
12 * This driver is based on the document by Mark A. Smith available at
13 * http://www.almaden.ibm.com/cs/people/marksmith/tpaps.html and a lot of trial
14 * and error.
15 */
16
17#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
18
19#include <linux/delay.h>
20#include <linux/platform_device.h>
21#include <linux/input-polldev.h>
22#include <linux/kernel.h>
23#include <linux/mutex.h>
24#include <linux/module.h>
25#include <linux/timer.h>
26#include <linux/dmi.h>
27#include <linux/jiffies.h>
28#include <linux/io.h>
29
30#define HDAPS_LOW_PORT 0x1600 /* first port used by hdaps */
31#define HDAPS_NR_PORTS 0x30 /* number of ports: 0x1600 - 0x162f */
32
33#define HDAPS_PORT_STATE 0x1611 /* device state */
34#define HDAPS_PORT_YPOS 0x1612 /* y-axis position */
35#define HDAPS_PORT_XPOS 0x1614 /* x-axis position */
36#define HDAPS_PORT_TEMP1 0x1616 /* device temperature, in Celsius */
37#define HDAPS_PORT_YVAR 0x1617 /* y-axis variance (what is this?) */
38#define HDAPS_PORT_XVAR 0x1619 /* x-axis variance (what is this?) */
39#define HDAPS_PORT_TEMP2 0x161b /* device temperature (again?) */
40#define HDAPS_PORT_UNKNOWN 0x161c /* what is this? */
41#define HDAPS_PORT_KMACT 0x161d /* keyboard or mouse activity */
42
43#define STATE_FRESH 0x50 /* accelerometer data is fresh */
44
45#define KEYBD_MASK 0x20 /* set if keyboard activity */
46#define MOUSE_MASK 0x40 /* set if mouse activity */
47#define KEYBD_ISSET(n) (!! (n & KEYBD_MASK)) /* keyboard used? */
48#define MOUSE_ISSET(n) (!! (n & MOUSE_MASK)) /* mouse used? */
49
50#define INIT_TIMEOUT_MSECS 4000 /* wait up to 4s for device init ... */
51#define INIT_WAIT_MSECS 200 /* ... in 200ms increments */
52
53#define HDAPS_POLL_INTERVAL 50 /* poll for input every 1/20s (50 ms)*/
54#define HDAPS_INPUT_FUZZ 4 /* input event threshold */
55#define HDAPS_INPUT_FLAT 4
56
57#define HDAPS_X_AXIS (1 << 0)
58#define HDAPS_Y_AXIS (1 << 1)
59#define HDAPS_BOTH_AXES (HDAPS_X_AXIS | HDAPS_Y_AXIS)
60
61static struct platform_device *pdev;
62static struct input_polled_dev *hdaps_idev;
63static unsigned int hdaps_invert;
64static u8 km_activity;
65static int rest_x;
66static int rest_y;
67
68static DEFINE_MUTEX(hdaps_mtx);
69
70/*
71 * __get_latch - Get the value from a given port. Callers must hold hdaps_mtx.
72 */
73static inline u8 __get_latch(u16 port)
74{
75 return inb(port) & 0xff;
76}
77
78/*
79 * __check_latch - Check a port latch for a given value. Returns zero if the
80 * port contains the given value. Callers must hold hdaps_mtx.
81 */
82static inline int __check_latch(u16 port, u8 val)
83{
84 if (__get_latch(port) == val)
85 return 0;
86 return -EINVAL;
87}
88
89/*
90 * __wait_latch - Wait up to 100us for a port latch to get a certain value,
91 * returning zero if the value is obtained. Callers must hold hdaps_mtx.
92 */
93static int __wait_latch(u16 port, u8 val)
94{
95 unsigned int i;
96
97 for (i = 0; i < 20; i++) {
98 if (!__check_latch(port, val))
99 return 0;
100 udelay(5);
101 }
102
103 return -EIO;
104}
105
106/*
107 * __device_refresh - request a refresh from the accelerometer. Does not wait
108 * for refresh to complete. Callers must hold hdaps_mtx.
109 */
110static void __device_refresh(void)
111{
112 udelay(200);
113 if (inb(0x1604) != STATE_FRESH) {
114 outb(0x11, 0x1610);
115 outb(0x01, 0x161f);
116 }
117}
118
119/*
120 * __device_refresh_sync - request a synchronous refresh from the
121 * accelerometer. We wait for the refresh to complete. Returns zero if
122 * successful and nonzero on error. Callers must hold hdaps_mtx.
123 */
124static int __device_refresh_sync(void)
125{
126 __device_refresh();
127 return __wait_latch(0x1604, STATE_FRESH);
128}
129
130/*
131 * __device_complete - indicate to the accelerometer that we are done reading
132 * data, and then initiate an async refresh. Callers must hold hdaps_mtx.
133 */
134static inline void __device_complete(void)
135{
136 inb(0x161f);
137 inb(0x1604);
138 __device_refresh();
139}
140
141/*
142 * hdaps_readb_one - reads a byte from a single I/O port, placing the value in
143 * the given pointer. Returns zero on success or a negative error on failure.
144 * Can sleep.
145 */
146static int hdaps_readb_one(unsigned int port, u8 *val)
147{
148 int ret;
149
150 mutex_lock(&hdaps_mtx);
151
152 /* do a sync refresh -- we need to be sure that we read fresh data */
153 ret = __device_refresh_sync();
154 if (ret)
155 goto out;
156
157 *val = inb(port);
158 __device_complete();
159
160out:
161 mutex_unlock(&hdaps_mtx);
162 return ret;
163}
164
165/* __hdaps_read_pair - internal lockless helper for hdaps_read_pair(). */
166static int __hdaps_read_pair(unsigned int port1, unsigned int port2,
167 int *x, int *y)
168{
169 /* do a sync refresh -- we need to be sure that we read fresh data */
170 if (__device_refresh_sync())
171 return -EIO;
172
173 *y = inw(port2);
174 *x = inw(port1);
175 km_activity = inb(HDAPS_PORT_KMACT);
176 __device_complete();
177
178 /* hdaps_invert is a bitvector to negate the axes */
179 if (hdaps_invert & HDAPS_X_AXIS)
180 *x = -*x;
181 if (hdaps_invert & HDAPS_Y_AXIS)
182 *y = -*y;
183
184 return 0;
185}
186
187/*
188 * hdaps_read_pair - reads the values from a pair of ports, placing the values
189 * in the given pointers. Returns zero on success. Can sleep.
190 */
191static int hdaps_read_pair(unsigned int port1, unsigned int port2,
192 int *val1, int *val2)
193{
194 int ret;
195
196 mutex_lock(&hdaps_mtx);
197 ret = __hdaps_read_pair(port1, port2, val1, val2);
198 mutex_unlock(&hdaps_mtx);
199
200 return ret;
201}
202
203/*
204 * hdaps_device_init - initialize the accelerometer. Returns zero on success
205 * and negative error code on failure. Can sleep.
206 */
207static int hdaps_device_init(void)
208{
209 int total, ret = -ENXIO;
210
211 mutex_lock(&hdaps_mtx);
212
213 outb(0x13, 0x1610);
214 outb(0x01, 0x161f);
215 if (__wait_latch(0x161f, 0x00))
216 goto out;
217
218 /*
219 * Most ThinkPads return 0x01.
220 *
221 * Others--namely the R50p, T41p, and T42p--return 0x03. These laptops
222 * have "inverted" axises.
223 *
224 * The 0x02 value occurs when the chip has been previously initialized.
225 */
226 if (__check_latch(0x1611, 0x03) &&
227 __check_latch(0x1611, 0x02) &&
228 __check_latch(0x1611, 0x01))
229 goto out;
230
231 printk(KERN_DEBUG "hdaps: initial latch check good (0x%02x)\n",
232 __get_latch(0x1611));
233
234 outb(0x17, 0x1610);
235 outb(0x81, 0x1611);
236 outb(0x01, 0x161f);
237 if (__wait_latch(0x161f, 0x00))
238 goto out;
239 if (__wait_latch(0x1611, 0x00))
240 goto out;
241 if (__wait_latch(0x1612, 0x60))
242 goto out;
243 if (__wait_latch(0x1613, 0x00))
244 goto out;
245 outb(0x14, 0x1610);
246 outb(0x01, 0x1611);
247 outb(0x01, 0x161f);
248 if (__wait_latch(0x161f, 0x00))
249 goto out;
250 outb(0x10, 0x1610);
251 outb(0xc8, 0x1611);
252 outb(0x00, 0x1612);
253 outb(0x02, 0x1613);
254 outb(0x01, 0x161f);
255 if (__wait_latch(0x161f, 0x00))
256 goto out;
257 if (__device_refresh_sync())
258 goto out;
259 if (__wait_latch(0x1611, 0x00))
260 goto out;
261
262 /* we have done our dance, now let's wait for the applause */
263 for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
264 int x, y;
265
266 /* a read of the device helps push it into action */
267 __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
268 if (!__wait_latch(0x1611, 0x02)) {
269 ret = 0;
270 break;
271 }
272
273 msleep(INIT_WAIT_MSECS);
274 }
275
276out:
277 mutex_unlock(&hdaps_mtx);
278 return ret;
279}
280
281
282/* Device model stuff */
283
284static int hdaps_probe(struct platform_device *dev)
285{
286 int ret;
287
288 ret = hdaps_device_init();
289 if (ret)
290 return ret;
291
292 pr_info("device successfully initialized\n");
293 return 0;
294}
295
296#ifdef CONFIG_PM_SLEEP
297static int hdaps_resume(struct device *dev)
298{
299 return hdaps_device_init();
300}
301#endif
302
303static SIMPLE_DEV_PM_OPS(hdaps_pm, NULL, hdaps_resume);
304
305static struct platform_driver hdaps_driver = {
306 .probe = hdaps_probe,
307 .driver = {
308 .name = "hdaps",
309 .pm = &hdaps_pm,
310 },
311};
312
313/*
314 * hdaps_calibrate - Set our "resting" values. Callers must hold hdaps_mtx.
315 */
316static void hdaps_calibrate(void)
317{
318 __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &rest_x, &rest_y);
319}
320
321static void hdaps_mousedev_poll(struct input_polled_dev *dev)
322{
323 struct input_dev *input_dev = dev->input;
324 int x, y;
325
326 mutex_lock(&hdaps_mtx);
327
328 if (__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y))
329 goto out;
330
331 input_report_abs(input_dev, ABS_X, x - rest_x);
332 input_report_abs(input_dev, ABS_Y, y - rest_y);
333 input_sync(input_dev);
334
335out:
336 mutex_unlock(&hdaps_mtx);
337}
338
339
340/* Sysfs Files */
341
342static ssize_t hdaps_position_show(struct device *dev,
343 struct device_attribute *attr, char *buf)
344{
345 int ret, x, y;
346
347 ret = hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
348 if (ret)
349 return ret;
350
351 return sprintf(buf, "(%d,%d)\n", x, y);
352}
353
354static ssize_t hdaps_variance_show(struct device *dev,
355 struct device_attribute *attr, char *buf)
356{
357 int ret, x, y;
358
359 ret = hdaps_read_pair(HDAPS_PORT_XVAR, HDAPS_PORT_YVAR, &x, &y);
360 if (ret)
361 return ret;
362
363 return sprintf(buf, "(%d,%d)\n", x, y);
364}
365
366static ssize_t hdaps_temp1_show(struct device *dev,
367 struct device_attribute *attr, char *buf)
368{
369 u8 uninitialized_var(temp);
370 int ret;
371
372 ret = hdaps_readb_one(HDAPS_PORT_TEMP1, &temp);
373 if (ret)
374 return ret;
375
376 return sprintf(buf, "%u\n", temp);
377}
378
379static ssize_t hdaps_temp2_show(struct device *dev,
380 struct device_attribute *attr, char *buf)
381{
382 u8 uninitialized_var(temp);
383 int ret;
384
385 ret = hdaps_readb_one(HDAPS_PORT_TEMP2, &temp);
386 if (ret)
387 return ret;
388
389 return sprintf(buf, "%u\n", temp);
390}
391
392static ssize_t hdaps_keyboard_activity_show(struct device *dev,
393 struct device_attribute *attr,
394 char *buf)
395{
396 return sprintf(buf, "%u\n", KEYBD_ISSET(km_activity));
397}
398
399static ssize_t hdaps_mouse_activity_show(struct device *dev,
400 struct device_attribute *attr,
401 char *buf)
402{
403 return sprintf(buf, "%u\n", MOUSE_ISSET(km_activity));
404}
405
406static ssize_t hdaps_calibrate_show(struct device *dev,
407 struct device_attribute *attr, char *buf)
408{
409 return sprintf(buf, "(%d,%d)\n", rest_x, rest_y);
410}
411
412static ssize_t hdaps_calibrate_store(struct device *dev,
413 struct device_attribute *attr,
414 const char *buf, size_t count)
415{
416 mutex_lock(&hdaps_mtx);
417 hdaps_calibrate();
418 mutex_unlock(&hdaps_mtx);
419
420 return count;
421}
422
423static ssize_t hdaps_invert_show(struct device *dev,
424 struct device_attribute *attr, char *buf)
425{
426 return sprintf(buf, "%u\n", hdaps_invert);
427}
428
429static ssize_t hdaps_invert_store(struct device *dev,
430 struct device_attribute *attr,
431 const char *buf, size_t count)
432{
433 int invert;
434
435 if (sscanf(buf, "%d", &invert) != 1 ||
436 invert < 0 || invert > HDAPS_BOTH_AXES)
437 return -EINVAL;
438
439 hdaps_invert = invert;
440 hdaps_calibrate();
441
442 return count;
443}
444
445static DEVICE_ATTR(position, 0444, hdaps_position_show, NULL);
446static DEVICE_ATTR(variance, 0444, hdaps_variance_show, NULL);
447static DEVICE_ATTR(temp1, 0444, hdaps_temp1_show, NULL);
448static DEVICE_ATTR(temp2, 0444, hdaps_temp2_show, NULL);
449static DEVICE_ATTR(keyboard_activity, 0444, hdaps_keyboard_activity_show, NULL);
450static DEVICE_ATTR(mouse_activity, 0444, hdaps_mouse_activity_show, NULL);
451static DEVICE_ATTR(calibrate, 0644, hdaps_calibrate_show,hdaps_calibrate_store);
452static DEVICE_ATTR(invert, 0644, hdaps_invert_show, hdaps_invert_store);
453
454static struct attribute *hdaps_attributes[] = {
455 &dev_attr_position.attr,
456 &dev_attr_variance.attr,
457 &dev_attr_temp1.attr,
458 &dev_attr_temp2.attr,
459 &dev_attr_keyboard_activity.attr,
460 &dev_attr_mouse_activity.attr,
461 &dev_attr_calibrate.attr,
462 &dev_attr_invert.attr,
463 NULL,
464};
465
466static struct attribute_group hdaps_attribute_group = {
467 .attrs = hdaps_attributes,
468};
469
470
471/* Module stuff */
472
473/* hdaps_dmi_match - found a match. return one, short-circuiting the hunt. */
474static int __init hdaps_dmi_match(const struct dmi_system_id *id)
475{
476 pr_info("%s detected\n", id->ident);
477 return 1;
478}
479
480/* hdaps_dmi_match_invert - found an inverted match. */
481static int __init hdaps_dmi_match_invert(const struct dmi_system_id *id)
482{
483 hdaps_invert = (unsigned long)id->driver_data;
484 pr_info("inverting axis (%u) readings\n", hdaps_invert);
485 return hdaps_dmi_match(id);
486}
487
488#define HDAPS_DMI_MATCH_INVERT(vendor, model, axes) { \
489 .ident = vendor " " model, \
490 .callback = hdaps_dmi_match_invert, \
491 .driver_data = (void *)axes, \
492 .matches = { \
493 DMI_MATCH(DMI_BOARD_VENDOR, vendor), \
494 DMI_MATCH(DMI_PRODUCT_VERSION, model) \
495 } \
496}
497
498#define HDAPS_DMI_MATCH_NORMAL(vendor, model) \
499 HDAPS_DMI_MATCH_INVERT(vendor, model, 0)
500
501/* Note that HDAPS_DMI_MATCH_NORMAL("ThinkPad T42") would match
502 "ThinkPad T42p", so the order of the entries matters.
503 If your ThinkPad is not recognized, please update to latest
504 BIOS. This is especially the case for some R52 ThinkPads. */
505static const struct dmi_system_id hdaps_whitelist[] __initconst = {
506 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad R50p", HDAPS_BOTH_AXES),
507 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R50"),
508 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R51"),
509 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R52"),
510 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R61i", HDAPS_BOTH_AXES),
511 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R61", HDAPS_BOTH_AXES),
512 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T41p", HDAPS_BOTH_AXES),
513 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T41"),
514 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T42p", HDAPS_BOTH_AXES),
515 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T42"),
516 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T43"),
517 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T400", HDAPS_BOTH_AXES),
518 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T60", HDAPS_BOTH_AXES),
519 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61p", HDAPS_BOTH_AXES),
520 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61", HDAPS_BOTH_AXES),
521 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad X40"),
522 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad X41", HDAPS_Y_AXIS),
523 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X60", HDAPS_BOTH_AXES),
524 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61s", HDAPS_BOTH_AXES),
525 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61", HDAPS_BOTH_AXES),
526 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad Z60m"),
527 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61m", HDAPS_BOTH_AXES),
528 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61p", HDAPS_BOTH_AXES),
529 { .ident = NULL }
530};
531
532static int __init hdaps_init(void)
533{
534 struct input_dev *idev;
535 int ret;
536
537 if (!dmi_check_system(hdaps_whitelist)) {
538 pr_warn("supported laptop not found!\n");
539 ret = -ENODEV;
540 goto out;
541 }
542
543 if (!request_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS, "hdaps")) {
544 ret = -ENXIO;
545 goto out;
546 }
547
548 ret = platform_driver_register(&hdaps_driver);
549 if (ret)
550 goto out_region;
551
552 pdev = platform_device_register_simple("hdaps", -1, NULL, 0);
553 if (IS_ERR(pdev)) {
554 ret = PTR_ERR(pdev);
555 goto out_driver;
556 }
557
558 ret = sysfs_create_group(&pdev->dev.kobj, &hdaps_attribute_group);
559 if (ret)
560 goto out_device;
561
562 hdaps_idev = input_allocate_polled_device();
563 if (!hdaps_idev) {
564 ret = -ENOMEM;
565 goto out_group;
566 }
567
568 hdaps_idev->poll = hdaps_mousedev_poll;
569 hdaps_idev->poll_interval = HDAPS_POLL_INTERVAL;
570
571 /* initial calibrate for the input device */
572 hdaps_calibrate();
573
574 /* initialize the input class */
575 idev = hdaps_idev->input;
576 idev->name = "hdaps";
577 idev->phys = "isa1600/input0";
578 idev->id.bustype = BUS_ISA;
579 idev->dev.parent = &pdev->dev;
580 idev->evbit[0] = BIT_MASK(EV_ABS);
581 input_set_abs_params(idev, ABS_X,
582 -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
583 input_set_abs_params(idev, ABS_Y,
584 -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
585
586 ret = input_register_polled_device(hdaps_idev);
587 if (ret)
588 goto out_idev;
589
590 pr_info("driver successfully loaded\n");
591 return 0;
592
593out_idev:
594 input_free_polled_device(hdaps_idev);
595out_group:
596 sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
597out_device:
598 platform_device_unregister(pdev);
599out_driver:
600 platform_driver_unregister(&hdaps_driver);
601out_region:
602 release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
603out:
604 pr_warn("driver init failed (ret=%d)!\n", ret);
605 return ret;
606}
607
608static void __exit hdaps_exit(void)
609{
610 input_unregister_polled_device(hdaps_idev);
611 input_free_polled_device(hdaps_idev);
612 sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
613 platform_device_unregister(pdev);
614 platform_driver_unregister(&hdaps_driver);
615 release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
616
617 pr_info("driver unloaded\n");
618}
619
620module_init(hdaps_init);
621module_exit(hdaps_exit);
622
623module_param_named(invert, hdaps_invert, int, 0);
624MODULE_PARM_DESC(invert, "invert data along each axis. 1 invert x-axis, "
625 "2 invert y-axis, 3 invert both axes.");
626
627MODULE_AUTHOR("Robert Love");
628MODULE_DESCRIPTION("IBM Hard Drive Active Protection System (HDAPS) driver");
629MODULE_LICENSE("GPL v2");