blob: d3612a1f198135d1a719428fc5f77e417674e671 [file] [log] [blame]
Robert Love860e1d62005-08-31 23:57:59 -04001/*
2 * drivers/hwmon/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 *
Robert Love4c87b742005-09-22 21:44:00 -07007 * 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.
Robert Love860e1d62005-08-31 23:57:59 -040010 *
Robert Love393ad292005-09-16 19:28:07 -070011 * This driver is based on the document by Mark A. Smith available at
Robert Love860e1d62005-08-31 23:57:59 -040012 * 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#include <linux/delay.h>
Russell Kingd052d1b2005-10-29 19:07:23 +010030#include <linux/platform_device.h>
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -040031#include <linux/input-polldev.h>
Robert Love860e1d62005-08-31 23:57:59 -040032#include <linux/kernel.h>
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -070033#include <linux/mutex.h>
Robert Love860e1d62005-08-31 23:57:59 -040034#include <linux/module.h>
35#include <linux/timer.h>
36#include <linux/dmi.h>
Al Viro914e2632006-10-18 13:55:46 -040037#include <linux/jiffies.h>
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -070038
Robert Love860e1d62005-08-31 23:57:59 -040039#include <asm/io.h>
40
41#define HDAPS_LOW_PORT 0x1600 /* first port used by hdaps */
Robert Love393ad292005-09-16 19:28:07 -070042#define HDAPS_NR_PORTS 0x30 /* number of ports: 0x1600 - 0x162f */
Robert Love860e1d62005-08-31 23:57:59 -040043
44#define HDAPS_PORT_STATE 0x1611 /* device state */
45#define HDAPS_PORT_YPOS 0x1612 /* y-axis position */
46#define HDAPS_PORT_XPOS 0x1614 /* x-axis position */
Jean Delvare0a704682006-06-04 20:10:55 +020047#define HDAPS_PORT_TEMP1 0x1616 /* device temperature, in Celsius */
Robert Love860e1d62005-08-31 23:57:59 -040048#define HDAPS_PORT_YVAR 0x1617 /* y-axis variance (what is this?) */
49#define HDAPS_PORT_XVAR 0x1619 /* x-axis variance (what is this?) */
50#define HDAPS_PORT_TEMP2 0x161b /* device temperature (again?) */
51#define HDAPS_PORT_UNKNOWN 0x161c /* what is this? */
52#define HDAPS_PORT_KMACT 0x161d /* keyboard or mouse activity */
53
Robert Love393ad292005-09-16 19:28:07 -070054#define STATE_FRESH 0x50 /* accelerometer data is fresh */
Robert Love860e1d62005-08-31 23:57:59 -040055
56#define KEYBD_MASK 0x20 /* set if keyboard activity */
57#define MOUSE_MASK 0x40 /* set if mouse activity */
58#define KEYBD_ISSET(n) (!! (n & KEYBD_MASK)) /* keyboard used? */
59#define MOUSE_ISSET(n) (!! (n & MOUSE_MASK)) /* mouse used? */
60
61#define INIT_TIMEOUT_MSECS 4000 /* wait up to 4s for device init ... */
62#define INIT_WAIT_MSECS 200 /* ... in 200ms increments */
63
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -040064#define HDAPS_POLL_INTERVAL 50 /* poll for input every 1/20s (50 ms)*/
Robert Love393ad292005-09-16 19:28:07 -070065#define HDAPS_INPUT_FUZZ 4 /* input event threshold */
Dmitry Torokhovd12eb7e2005-11-10 22:10:55 -050066#define HDAPS_INPUT_FLAT 4
Robert Love393ad292005-09-16 19:28:07 -070067
Frank Seidel2b8cf3e2009-03-30 21:46:41 +020068#define HDAPS_X_AXIS (1 << 0)
69#define HDAPS_Y_AXIS (1 << 1)
70#define HDAPS_BOTH_AXES (HDAPS_X_AXIS | HDAPS_Y_AXIS)
71
Robert Love393ad292005-09-16 19:28:07 -070072static struct platform_device *pdev;
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -040073static struct input_polled_dev *hdaps_idev;
Robert Love860e1d62005-08-31 23:57:59 -040074static unsigned int hdaps_invert;
75static u8 km_activity;
76static int rest_x;
77static int rest_y;
78
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -070079static DEFINE_MUTEX(hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -040080
81/*
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -070082 * __get_latch - Get the value from a given port. Callers must hold hdaps_mtx.
Robert Love860e1d62005-08-31 23:57:59 -040083 */
84static inline u8 __get_latch(u16 port)
85{
Robert Love393ad292005-09-16 19:28:07 -070086 return inb(port) & 0xff;
Robert Love860e1d62005-08-31 23:57:59 -040087}
88
89/*
Robert Love393ad292005-09-16 19:28:07 -070090 * __check_latch - Check a port latch for a given value. Returns zero if the
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -070091 * port contains the given value. Callers must hold hdaps_mtx.
Robert Love860e1d62005-08-31 23:57:59 -040092 */
Robert Love393ad292005-09-16 19:28:07 -070093static inline int __check_latch(u16 port, u8 val)
Robert Love860e1d62005-08-31 23:57:59 -040094{
95 if (__get_latch(port) == val)
96 return 0;
97 return -EINVAL;
98}
99
100/*
101 * __wait_latch - Wait up to 100us for a port latch to get a certain value,
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700102 * returning zero if the value is obtained. Callers must hold hdaps_mtx.
Robert Love860e1d62005-08-31 23:57:59 -0400103 */
Robert Love393ad292005-09-16 19:28:07 -0700104static int __wait_latch(u16 port, u8 val)
Robert Love860e1d62005-08-31 23:57:59 -0400105{
106 unsigned int i;
107
108 for (i = 0; i < 20; i++) {
109 if (!__check_latch(port, val))
110 return 0;
111 udelay(5);
112 }
113
Robert Love393ad292005-09-16 19:28:07 -0700114 return -EIO;
Robert Love860e1d62005-08-31 23:57:59 -0400115}
116
117/*
Robert Love393ad292005-09-16 19:28:07 -0700118 * __device_refresh - request a refresh from the accelerometer. Does not wait
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700119 * for refresh to complete. Callers must hold hdaps_mtx.
Robert Love860e1d62005-08-31 23:57:59 -0400120 */
Robert Love393ad292005-09-16 19:28:07 -0700121static void __device_refresh(void)
Robert Love860e1d62005-08-31 23:57:59 -0400122{
Robert Love393ad292005-09-16 19:28:07 -0700123 udelay(200);
124 if (inb(0x1604) != STATE_FRESH) {
125 outb(0x11, 0x1610);
126 outb(0x01, 0x161f);
127 }
128}
Robert Love860e1d62005-08-31 23:57:59 -0400129
Robert Love393ad292005-09-16 19:28:07 -0700130/*
131 * __device_refresh_sync - request a synchronous refresh from the
132 * accelerometer. We wait for the refresh to complete. Returns zero if
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700133 * successful and nonzero on error. Callers must hold hdaps_mtx.
Robert Love393ad292005-09-16 19:28:07 -0700134 */
135static int __device_refresh_sync(void)
136{
137 __device_refresh();
Robert Love860e1d62005-08-31 23:57:59 -0400138 return __wait_latch(0x1604, STATE_FRESH);
139}
140
141/*
Robert Love393ad292005-09-16 19:28:07 -0700142 * __device_complete - indicate to the accelerometer that we are done reading
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700143 * data, and then initiate an async refresh. Callers must hold hdaps_mtx.
Robert Love860e1d62005-08-31 23:57:59 -0400144 */
145static inline void __device_complete(void)
146{
147 inb(0x161f);
148 inb(0x1604);
Robert Love393ad292005-09-16 19:28:07 -0700149 __device_refresh();
Robert Love860e1d62005-08-31 23:57:59 -0400150}
151
152/*
153 * hdaps_readb_one - reads a byte from a single I/O port, placing the value in
154 * the given pointer. Returns zero on success or a negative error on failure.
155 * Can sleep.
156 */
157static int hdaps_readb_one(unsigned int port, u8 *val)
158{
159 int ret;
160
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700161 mutex_lock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400162
Robert Love393ad292005-09-16 19:28:07 -0700163 /* do a sync refresh -- we need to be sure that we read fresh data */
164 ret = __device_refresh_sync();
165 if (ret)
166 goto out;
167
168 *val = inb(port);
169 __device_complete();
170
171out:
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700172 mutex_unlock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400173 return ret;
174}
175
Robert Love393ad292005-09-16 19:28:07 -0700176/* __hdaps_read_pair - internal lockless helper for hdaps_read_pair(). */
Robert Love860e1d62005-08-31 23:57:59 -0400177static int __hdaps_read_pair(unsigned int port1, unsigned int port2,
178 int *x, int *y)
179{
180 /* do a sync refresh -- we need to be sure that we read fresh data */
Robert Love393ad292005-09-16 19:28:07 -0700181 if (__device_refresh_sync())
Robert Love860e1d62005-08-31 23:57:59 -0400182 return -EIO;
183
184 *y = inw(port2);
185 *x = inw(port1);
186 km_activity = inb(HDAPS_PORT_KMACT);
187 __device_complete();
188
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200189 /* hdaps_invert is a bitvector to negate the axes */
190 if (hdaps_invert & HDAPS_X_AXIS)
Robert Love860e1d62005-08-31 23:57:59 -0400191 *x = -*x;
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200192 if (hdaps_invert & HDAPS_Y_AXIS)
Robert Love860e1d62005-08-31 23:57:59 -0400193 *y = -*y;
Robert Love860e1d62005-08-31 23:57:59 -0400194
195 return 0;
196}
197
198/*
199 * hdaps_read_pair - reads the values from a pair of ports, placing the values
200 * in the given pointers. Returns zero on success. Can sleep.
201 */
202static int hdaps_read_pair(unsigned int port1, unsigned int port2,
203 int *val1, int *val2)
204{
205 int ret;
206
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700207 mutex_lock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400208 ret = __hdaps_read_pair(port1, port2, val1, val2);
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700209 mutex_unlock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400210
211 return ret;
212}
213
Robert Love393ad292005-09-16 19:28:07 -0700214/*
215 * hdaps_device_init - initialize the accelerometer. Returns zero on success
216 * and negative error code on failure. Can sleep.
217 */
Robert Love860e1d62005-08-31 23:57:59 -0400218static int hdaps_device_init(void)
219{
Robert Love393ad292005-09-16 19:28:07 -0700220 int total, ret = -ENXIO;
Robert Love860e1d62005-08-31 23:57:59 -0400221
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700222 mutex_lock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400223
224 outb(0x13, 0x1610);
225 outb(0x01, 0x161f);
226 if (__wait_latch(0x161f, 0x00))
227 goto out;
228
229 /*
Robert Love393ad292005-09-16 19:28:07 -0700230 * Most ThinkPads return 0x01.
231 *
232 * Others--namely the R50p, T41p, and T42p--return 0x03. These laptops
233 * have "inverted" axises.
Robert Love860e1d62005-08-31 23:57:59 -0400234 *
235 * The 0x02 value occurs when the chip has been previously initialized.
236 */
237 if (__check_latch(0x1611, 0x03) &&
238 __check_latch(0x1611, 0x02) &&
239 __check_latch(0x1611, 0x01))
240 goto out;
241
242 printk(KERN_DEBUG "hdaps: initial latch check good (0x%02x).\n",
243 __get_latch(0x1611));
244
245 outb(0x17, 0x1610);
246 outb(0x81, 0x1611);
247 outb(0x01, 0x161f);
248 if (__wait_latch(0x161f, 0x00))
249 goto out;
250 if (__wait_latch(0x1611, 0x00))
251 goto out;
252 if (__wait_latch(0x1612, 0x60))
253 goto out;
254 if (__wait_latch(0x1613, 0x00))
255 goto out;
256 outb(0x14, 0x1610);
257 outb(0x01, 0x1611);
258 outb(0x01, 0x161f);
259 if (__wait_latch(0x161f, 0x00))
260 goto out;
261 outb(0x10, 0x1610);
262 outb(0xc8, 0x1611);
263 outb(0x00, 0x1612);
264 outb(0x02, 0x1613);
265 outb(0x01, 0x161f);
266 if (__wait_latch(0x161f, 0x00))
267 goto out;
Robert Love393ad292005-09-16 19:28:07 -0700268 if (__device_refresh_sync())
Robert Love860e1d62005-08-31 23:57:59 -0400269 goto out;
270 if (__wait_latch(0x1611, 0x00))
271 goto out;
272
273 /* we have done our dance, now let's wait for the applause */
Robert Love393ad292005-09-16 19:28:07 -0700274 for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
275 int x, y;
Robert Love860e1d62005-08-31 23:57:59 -0400276
277 /* a read of the device helps push it into action */
Robert Love393ad292005-09-16 19:28:07 -0700278 __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
Robert Love860e1d62005-08-31 23:57:59 -0400279 if (!__wait_latch(0x1611, 0x02)) {
280 ret = 0;
281 break;
282 }
283
284 msleep(INIT_WAIT_MSECS);
Robert Love860e1d62005-08-31 23:57:59 -0400285 }
286
287out:
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700288 mutex_unlock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400289 return ret;
290}
291
292
Robert Love860e1d62005-08-31 23:57:59 -0400293/* Device model stuff */
294
Russell King3ae5eae2005-11-09 22:32:44 +0000295static int hdaps_probe(struct platform_device *dev)
Robert Love860e1d62005-08-31 23:57:59 -0400296{
297 int ret;
298
299 ret = hdaps_device_init();
300 if (ret)
301 return ret;
302
303 printk(KERN_INFO "hdaps: device successfully initialized.\n");
304 return 0;
305}
306
Russell King3ae5eae2005-11-09 22:32:44 +0000307static int hdaps_resume(struct platform_device *dev)
Robert Love860e1d62005-08-31 23:57:59 -0400308{
Russell King9480e302005-10-28 09:52:56 -0700309 return hdaps_device_init();
Robert Love860e1d62005-08-31 23:57:59 -0400310}
311
Russell King3ae5eae2005-11-09 22:32:44 +0000312static struct platform_driver hdaps_driver = {
Robert Love860e1d62005-08-31 23:57:59 -0400313 .probe = hdaps_probe,
Russell King3ae5eae2005-11-09 22:32:44 +0000314 .resume = hdaps_resume,
315 .driver = {
316 .name = "hdaps",
317 .owner = THIS_MODULE,
318 },
Robert Love860e1d62005-08-31 23:57:59 -0400319};
320
Robert Love393ad292005-09-16 19:28:07 -0700321/*
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700322 * hdaps_calibrate - Set our "resting" values. Callers must hold hdaps_mtx.
Robert Love393ad292005-09-16 19:28:07 -0700323 */
324static void hdaps_calibrate(void)
325{
326 __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &rest_x, &rest_y);
327}
328
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400329static void hdaps_mousedev_poll(struct input_polled_dev *dev)
Robert Love393ad292005-09-16 19:28:07 -0700330{
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400331 struct input_dev *input_dev = dev->input;
Robert Love393ad292005-09-16 19:28:07 -0700332 int x, y;
333
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400334 mutex_lock(&hdaps_mtx);
Robert Love393ad292005-09-16 19:28:07 -0700335
336 if (__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y))
337 goto out;
338
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400339 input_report_abs(input_dev, ABS_X, x - rest_x);
340 input_report_abs(input_dev, ABS_Y, y - rest_y);
341 input_sync(input_dev);
Robert Love393ad292005-09-16 19:28:07 -0700342
343out:
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700344 mutex_unlock(&hdaps_mtx);
Robert Love393ad292005-09-16 19:28:07 -0700345}
346
Robert Love860e1d62005-08-31 23:57:59 -0400347
348/* Sysfs Files */
349
350static ssize_t hdaps_position_show(struct device *dev,
351 struct device_attribute *attr, char *buf)
352{
353 int ret, x, y;
354
355 ret = hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
356 if (ret)
357 return ret;
358
359 return sprintf(buf, "(%d,%d)\n", x, y);
360}
361
362static ssize_t hdaps_variance_show(struct device *dev,
363 struct device_attribute *attr, char *buf)
364{
365 int ret, x, y;
366
367 ret = hdaps_read_pair(HDAPS_PORT_XVAR, HDAPS_PORT_YVAR, &x, &y);
368 if (ret)
369 return ret;
370
371 return sprintf(buf, "(%d,%d)\n", x, y);
372}
373
374static ssize_t hdaps_temp1_show(struct device *dev,
375 struct device_attribute *attr, char *buf)
376{
377 u8 temp;
378 int ret;
379
380 ret = hdaps_readb_one(HDAPS_PORT_TEMP1, &temp);
381 if (ret < 0)
382 return ret;
383
384 return sprintf(buf, "%u\n", temp);
385}
386
387static ssize_t hdaps_temp2_show(struct device *dev,
388 struct device_attribute *attr, char *buf)
389{
390 u8 temp;
391 int ret;
392
393 ret = hdaps_readb_one(HDAPS_PORT_TEMP2, &temp);
394 if (ret < 0)
395 return ret;
396
397 return sprintf(buf, "%u\n", temp);
398}
399
400static ssize_t hdaps_keyboard_activity_show(struct device *dev,
401 struct device_attribute *attr,
402 char *buf)
403{
404 return sprintf(buf, "%u\n", KEYBD_ISSET(km_activity));
405}
406
407static ssize_t hdaps_mouse_activity_show(struct device *dev,
408 struct device_attribute *attr,
409 char *buf)
410{
411 return sprintf(buf, "%u\n", MOUSE_ISSET(km_activity));
412}
413
414static ssize_t hdaps_calibrate_show(struct device *dev,
415 struct device_attribute *attr, char *buf)
416{
417 return sprintf(buf, "(%d,%d)\n", rest_x, rest_y);
418}
419
420static ssize_t hdaps_calibrate_store(struct device *dev,
421 struct device_attribute *attr,
422 const char *buf, size_t count)
423{
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700424 mutex_lock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400425 hdaps_calibrate();
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700426 mutex_unlock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400427
428 return count;
429}
430
431static ssize_t hdaps_invert_show(struct device *dev,
432 struct device_attribute *attr, char *buf)
433{
434 return sprintf(buf, "%u\n", hdaps_invert);
435}
436
437static ssize_t hdaps_invert_store(struct device *dev,
438 struct device_attribute *attr,
439 const char *buf, size_t count)
440{
441 int invert;
442
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200443 if (sscanf(buf, "%d", &invert) != 1 ||
444 invert < 0 || invert > HDAPS_BOTH_AXES)
Robert Love860e1d62005-08-31 23:57:59 -0400445 return -EINVAL;
446
447 hdaps_invert = invert;
448 hdaps_calibrate();
449
450 return count;
451}
452
Robert Love860e1d62005-08-31 23:57:59 -0400453static DEVICE_ATTR(position, 0444, hdaps_position_show, NULL);
454static DEVICE_ATTR(variance, 0444, hdaps_variance_show, NULL);
455static DEVICE_ATTR(temp1, 0444, hdaps_temp1_show, NULL);
456static DEVICE_ATTR(temp2, 0444, hdaps_temp2_show, NULL);
457static DEVICE_ATTR(keyboard_activity, 0444, hdaps_keyboard_activity_show, NULL);
458static DEVICE_ATTR(mouse_activity, 0444, hdaps_mouse_activity_show, NULL);
459static DEVICE_ATTR(calibrate, 0644, hdaps_calibrate_show,hdaps_calibrate_store);
460static DEVICE_ATTR(invert, 0644, hdaps_invert_show, hdaps_invert_store);
Robert Love860e1d62005-08-31 23:57:59 -0400461
462static struct attribute *hdaps_attributes[] = {
463 &dev_attr_position.attr,
464 &dev_attr_variance.attr,
465 &dev_attr_temp1.attr,
466 &dev_attr_temp2.attr,
467 &dev_attr_keyboard_activity.attr,
468 &dev_attr_mouse_activity.attr,
469 &dev_attr_calibrate.attr,
Robert Love860e1d62005-08-31 23:57:59 -0400470 &dev_attr_invert.attr,
471 NULL,
472};
473
474static struct attribute_group hdaps_attribute_group = {
475 .attrs = hdaps_attributes,
476};
477
478
479/* Module stuff */
480
Robert Love4c87b742005-09-22 21:44:00 -0700481/* hdaps_dmi_match - found a match. return one, short-circuiting the hunt. */
Jeff Garzik18552562007-10-03 15:15:40 -0400482static int __init hdaps_dmi_match(const struct dmi_system_id *id)
Robert Love860e1d62005-08-31 23:57:59 -0400483{
484 printk(KERN_INFO "hdaps: %s detected.\n", id->ident);
Robert Love4c87b742005-09-22 21:44:00 -0700485 return 1;
Robert Love860e1d62005-08-31 23:57:59 -0400486}
487
Robert Love4c87b742005-09-22 21:44:00 -0700488/* hdaps_dmi_match_invert - found an inverted match. */
Jeff Garzik18552562007-10-03 15:15:40 -0400489static int __init hdaps_dmi_match_invert(const struct dmi_system_id *id)
Robert Love860e1d62005-08-31 23:57:59 -0400490{
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200491 hdaps_invert = (unsigned long)id->driver_data;
492 printk(KERN_INFO "hdaps: inverting axis (%u) readings.\n",
493 hdaps_invert);
Robert Love4c87b742005-09-22 21:44:00 -0700494 return hdaps_dmi_match(id);
Robert Love860e1d62005-08-31 23:57:59 -0400495}
496
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200497#define HDAPS_DMI_MATCH_INVERT(vendor, model, axes) { \
Jean Delvare509a5e82006-12-12 18:18:28 +0100498 .ident = vendor " " model, \
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200499 .callback = hdaps_dmi_match_invert, \
500 .driver_data = (void *)axes, \
Robert Love860e1d62005-08-31 23:57:59 -0400501 .matches = { \
Jean Delvare509a5e82006-12-12 18:18:28 +0100502 DMI_MATCH(DMI_BOARD_VENDOR, vendor), \
Robert Love860e1d62005-08-31 23:57:59 -0400503 DMI_MATCH(DMI_PRODUCT_VERSION, model) \
504 } \
505}
506
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200507#define HDAPS_DMI_MATCH_NORMAL(vendor, model) \
508 HDAPS_DMI_MATCH_INVERT(vendor, model, 0)
Robert Love860e1d62005-08-31 23:57:59 -0400509
Jean Delvare509a5e82006-12-12 18:18:28 +0100510/* Note that HDAPS_DMI_MATCH_NORMAL("ThinkPad T42") would match
Stephan Berberig0f23e502006-12-12 18:18:28 +0100511 "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. */
Jean Delvare509a5e82006-12-12 18:18:28 +0100514static struct dmi_system_id __initdata hdaps_whitelist[] = {
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200515 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad R50p", HDAPS_BOTH_AXES),
Jean Delvare509a5e82006-12-12 18:18:28 +0100516 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R50"),
517 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R51"),
518 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R52"),
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200519 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),
Jean Delvare509a5e82006-12-12 18:18:28 +0100522 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T41"),
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200523 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T42p", HDAPS_BOTH_AXES),
Jean Delvare509a5e82006-12-12 18:18:28 +0100524 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T42"),
525 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T43"),
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200526 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T60", HDAPS_BOTH_AXES),
527 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61p", HDAPS_BOTH_AXES),
528 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61", HDAPS_BOTH_AXES),
Jean Delvare509a5e82006-12-12 18:18:28 +0100529 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad X40"),
Frank Seidelb6a33fe2009-03-30 21:46:42 +0200530 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad X41", HDAPS_Y_AXIS),
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200531 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X60", HDAPS_BOTH_AXES),
532 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61s", HDAPS_BOTH_AXES),
533 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61", HDAPS_BOTH_AXES),
Jean Delvare509a5e82006-12-12 18:18:28 +0100534 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad Z60m"),
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200535 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61m", HDAPS_BOTH_AXES),
536 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61p", HDAPS_BOTH_AXES),
Jean Delvare509a5e82006-12-12 18:18:28 +0100537 { .ident = NULL }
538};
Robert Love0f6c8402006-04-10 22:54:11 -0700539
Robert Love860e1d62005-08-31 23:57:59 -0400540static int __init hdaps_init(void)
541{
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400542 struct input_dev *idev;
Robert Love860e1d62005-08-31 23:57:59 -0400543 int ret;
544
Robert Love860e1d62005-08-31 23:57:59 -0400545 if (!dmi_check_system(hdaps_whitelist)) {
546 printk(KERN_WARNING "hdaps: supported laptop not found!\n");
Andrew Mortonb3f28a92006-04-10 22:54:32 -0700547 ret = -ENODEV;
Robert Love860e1d62005-08-31 23:57:59 -0400548 goto out;
549 }
550
551 if (!request_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS, "hdaps")) {
552 ret = -ENXIO;
553 goto out;
554 }
555
Russell King3ae5eae2005-11-09 22:32:44 +0000556 ret = platform_driver_register(&hdaps_driver);
Robert Love860e1d62005-08-31 23:57:59 -0400557 if (ret)
558 goto out_region;
559
560 pdev = platform_device_register_simple("hdaps", -1, NULL, 0);
561 if (IS_ERR(pdev)) {
562 ret = PTR_ERR(pdev);
563 goto out_driver;
564 }
565
566 ret = sysfs_create_group(&pdev->dev.kobj, &hdaps_attribute_group);
567 if (ret)
568 goto out_device;
569
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400570 hdaps_idev = input_allocate_polled_device();
Dmitry Torokhovd12eb7e2005-11-10 22:10:55 -0500571 if (!hdaps_idev) {
572 ret = -ENOMEM;
573 goto out_group;
574 }
575
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400576 hdaps_idev->poll = hdaps_mousedev_poll;
577 hdaps_idev->poll_interval = HDAPS_POLL_INTERVAL;
578
Robert Love393ad292005-09-16 19:28:07 -0700579 /* initial calibrate for the input device */
580 hdaps_calibrate();
581
582 /* initialize the input class */
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400583 idev = hdaps_idev->input;
584 idev->name = "hdaps";
Dmitry Torokhovd2fc60d2008-05-05 11:53:45 -0400585 idev->phys = "isa1600/input0";
586 idev->id.bustype = BUS_ISA;
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400587 idev->dev.parent = &pdev->dev;
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700588 idev->evbit[0] = BIT_MASK(EV_ABS);
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400589 input_set_abs_params(idev, ABS_X,
Dmitry Torokhovd12eb7e2005-11-10 22:10:55 -0500590 -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400591 input_set_abs_params(idev, ABS_Y,
Dmitry Torokhovd12eb7e2005-11-10 22:10:55 -0500592 -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
593
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400594 ret = input_register_polled_device(hdaps_idev);
Dmitry Torokhovb25a1062006-08-28 14:21:42 +0200595 if (ret)
596 goto out_idev;
Robert Love393ad292005-09-16 19:28:07 -0700597
Robert Love860e1d62005-08-31 23:57:59 -0400598 printk(KERN_INFO "hdaps: driver successfully loaded.\n");
599 return 0;
600
Dmitry Torokhovb25a1062006-08-28 14:21:42 +0200601out_idev:
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400602 input_free_polled_device(hdaps_idev);
Dmitry Torokhovd12eb7e2005-11-10 22:10:55 -0500603out_group:
604 sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
Robert Love860e1d62005-08-31 23:57:59 -0400605out_device:
606 platform_device_unregister(pdev);
607out_driver:
Russell King3ae5eae2005-11-09 22:32:44 +0000608 platform_driver_unregister(&hdaps_driver);
Robert Love860e1d62005-08-31 23:57:59 -0400609out_region:
610 release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
611out:
612 printk(KERN_WARNING "hdaps: driver init failed (ret=%d)!\n", ret);
613 return ret;
614}
615
616static void __exit hdaps_exit(void)
617{
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400618 input_unregister_polled_device(hdaps_idev);
619 input_free_polled_device(hdaps_idev);
Robert Love860e1d62005-08-31 23:57:59 -0400620 sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
621 platform_device_unregister(pdev);
Russell King3ae5eae2005-11-09 22:32:44 +0000622 platform_driver_unregister(&hdaps_driver);
Robert Love860e1d62005-08-31 23:57:59 -0400623 release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
624
625 printk(KERN_INFO "hdaps: driver unloaded.\n");
626}
627
628module_init(hdaps_init);
629module_exit(hdaps_exit);
630
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200631module_param_named(invert, hdaps_invert, int, 0);
632MODULE_PARM_DESC(invert, "invert data along each axis. 1 invert x-axis, "
633 "2 invert y-axis, 3 invert both axes.");
Robert Love860e1d62005-08-31 23:57:59 -0400634
635MODULE_AUTHOR("Robert Love");
636MODULE_DESCRIPTION("IBM Hard Drive Active Protection System (HDAPS) driver");
637MODULE_LICENSE("GPL v2");