blob: be2d131e405c669f405d0b963c5704feec4b014a [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>
H Hartley Sweeten6055fae2009-09-15 17:18:13 +020038#include <linux/io.h>
Robert Love860e1d62005-08-31 23:57:59 -040039
40#define HDAPS_LOW_PORT 0x1600 /* first port used by hdaps */
Robert Love393ad292005-09-16 19:28:07 -070041#define HDAPS_NR_PORTS 0x30 /* number of ports: 0x1600 - 0x162f */
Robert Love860e1d62005-08-31 23:57:59 -040042
43#define HDAPS_PORT_STATE 0x1611 /* device state */
44#define HDAPS_PORT_YPOS 0x1612 /* y-axis position */
45#define HDAPS_PORT_XPOS 0x1614 /* x-axis position */
Jean Delvare0a704682006-06-04 20:10:55 +020046#define HDAPS_PORT_TEMP1 0x1616 /* device temperature, in Celsius */
Robert Love860e1d62005-08-31 23:57:59 -040047#define HDAPS_PORT_YVAR 0x1617 /* y-axis variance (what is this?) */
48#define HDAPS_PORT_XVAR 0x1619 /* x-axis variance (what is this?) */
49#define HDAPS_PORT_TEMP2 0x161b /* device temperature (again?) */
50#define HDAPS_PORT_UNKNOWN 0x161c /* what is this? */
51#define HDAPS_PORT_KMACT 0x161d /* keyboard or mouse activity */
52
Robert Love393ad292005-09-16 19:28:07 -070053#define STATE_FRESH 0x50 /* accelerometer data is fresh */
Robert Love860e1d62005-08-31 23:57:59 -040054
55#define KEYBD_MASK 0x20 /* set if keyboard activity */
56#define MOUSE_MASK 0x40 /* set if mouse activity */
57#define KEYBD_ISSET(n) (!! (n & KEYBD_MASK)) /* keyboard used? */
58#define MOUSE_ISSET(n) (!! (n & MOUSE_MASK)) /* mouse used? */
59
60#define INIT_TIMEOUT_MSECS 4000 /* wait up to 4s for device init ... */
61#define INIT_WAIT_MSECS 200 /* ... in 200ms increments */
62
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -040063#define HDAPS_POLL_INTERVAL 50 /* poll for input every 1/20s (50 ms)*/
Robert Love393ad292005-09-16 19:28:07 -070064#define HDAPS_INPUT_FUZZ 4 /* input event threshold */
Dmitry Torokhovd12eb7e2005-11-10 22:10:55 -050065#define HDAPS_INPUT_FLAT 4
Robert Love393ad292005-09-16 19:28:07 -070066
Frank Seidel2b8cf3e2009-03-30 21:46:41 +020067#define HDAPS_X_AXIS (1 << 0)
68#define HDAPS_Y_AXIS (1 << 1)
69#define HDAPS_BOTH_AXES (HDAPS_X_AXIS | HDAPS_Y_AXIS)
70
Robert Love393ad292005-09-16 19:28:07 -070071static struct platform_device *pdev;
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -040072static struct input_polled_dev *hdaps_idev;
Robert Love860e1d62005-08-31 23:57:59 -040073static unsigned int hdaps_invert;
74static u8 km_activity;
75static int rest_x;
76static int rest_y;
77
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -070078static DEFINE_MUTEX(hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -040079
80/*
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -070081 * __get_latch - Get the value from a given port. Callers must hold hdaps_mtx.
Robert Love860e1d62005-08-31 23:57:59 -040082 */
83static inline u8 __get_latch(u16 port)
84{
Robert Love393ad292005-09-16 19:28:07 -070085 return inb(port) & 0xff;
Robert Love860e1d62005-08-31 23:57:59 -040086}
87
88/*
Robert Love393ad292005-09-16 19:28:07 -070089 * __check_latch - Check a port latch for a given value. Returns zero if the
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -070090 * port contains the given value. Callers must hold hdaps_mtx.
Robert Love860e1d62005-08-31 23:57:59 -040091 */
Robert Love393ad292005-09-16 19:28:07 -070092static inline int __check_latch(u16 port, u8 val)
Robert Love860e1d62005-08-31 23:57:59 -040093{
94 if (__get_latch(port) == val)
95 return 0;
96 return -EINVAL;
97}
98
99/*
100 * __wait_latch - Wait up to 100us for a port latch to get a certain value,
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700101 * returning zero if the value is obtained. Callers must hold hdaps_mtx.
Robert Love860e1d62005-08-31 23:57:59 -0400102 */
Robert Love393ad292005-09-16 19:28:07 -0700103static int __wait_latch(u16 port, u8 val)
Robert Love860e1d62005-08-31 23:57:59 -0400104{
105 unsigned int i;
106
107 for (i = 0; i < 20; i++) {
108 if (!__check_latch(port, val))
109 return 0;
110 udelay(5);
111 }
112
Robert Love393ad292005-09-16 19:28:07 -0700113 return -EIO;
Robert Love860e1d62005-08-31 23:57:59 -0400114}
115
116/*
Robert Love393ad292005-09-16 19:28:07 -0700117 * __device_refresh - request a refresh from the accelerometer. Does not wait
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700118 * for refresh to complete. Callers must hold hdaps_mtx.
Robert Love860e1d62005-08-31 23:57:59 -0400119 */
Robert Love393ad292005-09-16 19:28:07 -0700120static void __device_refresh(void)
Robert Love860e1d62005-08-31 23:57:59 -0400121{
Robert Love393ad292005-09-16 19:28:07 -0700122 udelay(200);
123 if (inb(0x1604) != STATE_FRESH) {
124 outb(0x11, 0x1610);
125 outb(0x01, 0x161f);
126 }
127}
Robert Love860e1d62005-08-31 23:57:59 -0400128
Robert Love393ad292005-09-16 19:28:07 -0700129/*
130 * __device_refresh_sync - request a synchronous refresh from the
131 * accelerometer. We wait for the refresh to complete. Returns zero if
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700132 * successful and nonzero on error. Callers must hold hdaps_mtx.
Robert Love393ad292005-09-16 19:28:07 -0700133 */
134static int __device_refresh_sync(void)
135{
136 __device_refresh();
Robert Love860e1d62005-08-31 23:57:59 -0400137 return __wait_latch(0x1604, STATE_FRESH);
138}
139
140/*
Robert Love393ad292005-09-16 19:28:07 -0700141 * __device_complete - indicate to the accelerometer that we are done reading
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700142 * data, and then initiate an async refresh. Callers must hold hdaps_mtx.
Robert Love860e1d62005-08-31 23:57:59 -0400143 */
144static inline void __device_complete(void)
145{
146 inb(0x161f);
147 inb(0x1604);
Robert Love393ad292005-09-16 19:28:07 -0700148 __device_refresh();
Robert Love860e1d62005-08-31 23:57:59 -0400149}
150
151/*
152 * hdaps_readb_one - reads a byte from a single I/O port, placing the value in
153 * the given pointer. Returns zero on success or a negative error on failure.
154 * Can sleep.
155 */
156static int hdaps_readb_one(unsigned int port, u8 *val)
157{
158 int ret;
159
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700160 mutex_lock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400161
Robert Love393ad292005-09-16 19:28:07 -0700162 /* do a sync refresh -- we need to be sure that we read fresh data */
163 ret = __device_refresh_sync();
164 if (ret)
165 goto out;
166
167 *val = inb(port);
168 __device_complete();
169
170out:
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700171 mutex_unlock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400172 return ret;
173}
174
Robert Love393ad292005-09-16 19:28:07 -0700175/* __hdaps_read_pair - internal lockless helper for hdaps_read_pair(). */
Robert Love860e1d62005-08-31 23:57:59 -0400176static int __hdaps_read_pair(unsigned int port1, unsigned int port2,
177 int *x, int *y)
178{
179 /* do a sync refresh -- we need to be sure that we read fresh data */
Robert Love393ad292005-09-16 19:28:07 -0700180 if (__device_refresh_sync())
Robert Love860e1d62005-08-31 23:57:59 -0400181 return -EIO;
182
183 *y = inw(port2);
184 *x = inw(port1);
185 km_activity = inb(HDAPS_PORT_KMACT);
186 __device_complete();
187
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200188 /* hdaps_invert is a bitvector to negate the axes */
189 if (hdaps_invert & HDAPS_X_AXIS)
Robert Love860e1d62005-08-31 23:57:59 -0400190 *x = -*x;
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200191 if (hdaps_invert & HDAPS_Y_AXIS)
Robert Love860e1d62005-08-31 23:57:59 -0400192 *y = -*y;
Robert Love860e1d62005-08-31 23:57:59 -0400193
194 return 0;
195}
196
197/*
198 * hdaps_read_pair - reads the values from a pair of ports, placing the values
199 * in the given pointers. Returns zero on success. Can sleep.
200 */
201static int hdaps_read_pair(unsigned int port1, unsigned int port2,
202 int *val1, int *val2)
203{
204 int ret;
205
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700206 mutex_lock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400207 ret = __hdaps_read_pair(port1, port2, val1, val2);
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700208 mutex_unlock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400209
210 return ret;
211}
212
Robert Love393ad292005-09-16 19:28:07 -0700213/*
214 * hdaps_device_init - initialize the accelerometer. Returns zero on success
215 * and negative error code on failure. Can sleep.
216 */
Robert Love860e1d62005-08-31 23:57:59 -0400217static int hdaps_device_init(void)
218{
Robert Love393ad292005-09-16 19:28:07 -0700219 int total, ret = -ENXIO;
Robert Love860e1d62005-08-31 23:57:59 -0400220
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700221 mutex_lock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400222
223 outb(0x13, 0x1610);
224 outb(0x01, 0x161f);
225 if (__wait_latch(0x161f, 0x00))
226 goto out;
227
228 /*
Robert Love393ad292005-09-16 19:28:07 -0700229 * Most ThinkPads return 0x01.
230 *
231 * Others--namely the R50p, T41p, and T42p--return 0x03. These laptops
232 * have "inverted" axises.
Robert Love860e1d62005-08-31 23:57:59 -0400233 *
234 * The 0x02 value occurs when the chip has been previously initialized.
235 */
236 if (__check_latch(0x1611, 0x03) &&
237 __check_latch(0x1611, 0x02) &&
238 __check_latch(0x1611, 0x01))
239 goto out;
240
241 printk(KERN_DEBUG "hdaps: initial latch check good (0x%02x).\n",
242 __get_latch(0x1611));
243
244 outb(0x17, 0x1610);
245 outb(0x81, 0x1611);
246 outb(0x01, 0x161f);
247 if (__wait_latch(0x161f, 0x00))
248 goto out;
249 if (__wait_latch(0x1611, 0x00))
250 goto out;
251 if (__wait_latch(0x1612, 0x60))
252 goto out;
253 if (__wait_latch(0x1613, 0x00))
254 goto out;
255 outb(0x14, 0x1610);
256 outb(0x01, 0x1611);
257 outb(0x01, 0x161f);
258 if (__wait_latch(0x161f, 0x00))
259 goto out;
260 outb(0x10, 0x1610);
261 outb(0xc8, 0x1611);
262 outb(0x00, 0x1612);
263 outb(0x02, 0x1613);
264 outb(0x01, 0x161f);
265 if (__wait_latch(0x161f, 0x00))
266 goto out;
Robert Love393ad292005-09-16 19:28:07 -0700267 if (__device_refresh_sync())
Robert Love860e1d62005-08-31 23:57:59 -0400268 goto out;
269 if (__wait_latch(0x1611, 0x00))
270 goto out;
271
272 /* we have done our dance, now let's wait for the applause */
Robert Love393ad292005-09-16 19:28:07 -0700273 for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
274 int x, y;
Robert Love860e1d62005-08-31 23:57:59 -0400275
276 /* a read of the device helps push it into action */
Robert Love393ad292005-09-16 19:28:07 -0700277 __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
Robert Love860e1d62005-08-31 23:57:59 -0400278 if (!__wait_latch(0x1611, 0x02)) {
279 ret = 0;
280 break;
281 }
282
283 msleep(INIT_WAIT_MSECS);
Robert Love860e1d62005-08-31 23:57:59 -0400284 }
285
286out:
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700287 mutex_unlock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400288 return ret;
289}
290
291
Robert Love860e1d62005-08-31 23:57:59 -0400292/* Device model stuff */
293
Russell King3ae5eae2005-11-09 22:32:44 +0000294static int hdaps_probe(struct platform_device *dev)
Robert Love860e1d62005-08-31 23:57:59 -0400295{
296 int ret;
297
298 ret = hdaps_device_init();
299 if (ret)
300 return ret;
301
302 printk(KERN_INFO "hdaps: device successfully initialized.\n");
303 return 0;
304}
305
Russell King3ae5eae2005-11-09 22:32:44 +0000306static int hdaps_resume(struct platform_device *dev)
Robert Love860e1d62005-08-31 23:57:59 -0400307{
Russell King9480e302005-10-28 09:52:56 -0700308 return hdaps_device_init();
Robert Love860e1d62005-08-31 23:57:59 -0400309}
310
Russell King3ae5eae2005-11-09 22:32:44 +0000311static struct platform_driver hdaps_driver = {
Robert Love860e1d62005-08-31 23:57:59 -0400312 .probe = hdaps_probe,
Russell King3ae5eae2005-11-09 22:32:44 +0000313 .resume = hdaps_resume,
314 .driver = {
315 .name = "hdaps",
316 .owner = THIS_MODULE,
317 },
Robert Love860e1d62005-08-31 23:57:59 -0400318};
319
Robert Love393ad292005-09-16 19:28:07 -0700320/*
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700321 * hdaps_calibrate - Set our "resting" values. Callers must hold hdaps_mtx.
Robert Love393ad292005-09-16 19:28:07 -0700322 */
323static void hdaps_calibrate(void)
324{
325 __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &rest_x, &rest_y);
326}
327
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400328static void hdaps_mousedev_poll(struct input_polled_dev *dev)
Robert Love393ad292005-09-16 19:28:07 -0700329{
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400330 struct input_dev *input_dev = dev->input;
Robert Love393ad292005-09-16 19:28:07 -0700331 int x, y;
332
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400333 mutex_lock(&hdaps_mtx);
Robert Love393ad292005-09-16 19:28:07 -0700334
335 if (__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y))
336 goto out;
337
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400338 input_report_abs(input_dev, ABS_X, x - rest_x);
339 input_report_abs(input_dev, ABS_Y, y - rest_y);
340 input_sync(input_dev);
Robert Love393ad292005-09-16 19:28:07 -0700341
342out:
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700343 mutex_unlock(&hdaps_mtx);
Robert Love393ad292005-09-16 19:28:07 -0700344}
345
Robert Love860e1d62005-08-31 23:57:59 -0400346
347/* Sysfs Files */
348
349static ssize_t hdaps_position_show(struct device *dev,
350 struct device_attribute *attr, char *buf)
351{
352 int ret, x, y;
353
354 ret = hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
355 if (ret)
356 return ret;
357
358 return sprintf(buf, "(%d,%d)\n", x, y);
359}
360
361static ssize_t hdaps_variance_show(struct device *dev,
362 struct device_attribute *attr, char *buf)
363{
364 int ret, x, y;
365
366 ret = hdaps_read_pair(HDAPS_PORT_XVAR, HDAPS_PORT_YVAR, &x, &y);
367 if (ret)
368 return ret;
369
370 return sprintf(buf, "(%d,%d)\n", x, y);
371}
372
373static ssize_t hdaps_temp1_show(struct device *dev,
374 struct device_attribute *attr, char *buf)
375{
376 u8 temp;
377 int ret;
378
379 ret = hdaps_readb_one(HDAPS_PORT_TEMP1, &temp);
380 if (ret < 0)
381 return ret;
382
383 return sprintf(buf, "%u\n", temp);
384}
385
386static ssize_t hdaps_temp2_show(struct device *dev,
387 struct device_attribute *attr, char *buf)
388{
389 u8 temp;
390 int ret;
391
392 ret = hdaps_readb_one(HDAPS_PORT_TEMP2, &temp);
393 if (ret < 0)
394 return ret;
395
396 return sprintf(buf, "%u\n", temp);
397}
398
399static ssize_t hdaps_keyboard_activity_show(struct device *dev,
400 struct device_attribute *attr,
401 char *buf)
402{
403 return sprintf(buf, "%u\n", KEYBD_ISSET(km_activity));
404}
405
406static ssize_t hdaps_mouse_activity_show(struct device *dev,
407 struct device_attribute *attr,
408 char *buf)
409{
410 return sprintf(buf, "%u\n", MOUSE_ISSET(km_activity));
411}
412
413static ssize_t hdaps_calibrate_show(struct device *dev,
414 struct device_attribute *attr, char *buf)
415{
416 return sprintf(buf, "(%d,%d)\n", rest_x, rest_y);
417}
418
419static ssize_t hdaps_calibrate_store(struct device *dev,
420 struct device_attribute *attr,
421 const char *buf, size_t count)
422{
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700423 mutex_lock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400424 hdaps_calibrate();
Matthias Kaehlcke6acc3692007-05-08 00:32:05 -0700425 mutex_unlock(&hdaps_mtx);
Robert Love860e1d62005-08-31 23:57:59 -0400426
427 return count;
428}
429
430static ssize_t hdaps_invert_show(struct device *dev,
431 struct device_attribute *attr, char *buf)
432{
433 return sprintf(buf, "%u\n", hdaps_invert);
434}
435
436static ssize_t hdaps_invert_store(struct device *dev,
437 struct device_attribute *attr,
438 const char *buf, size_t count)
439{
440 int invert;
441
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200442 if (sscanf(buf, "%d", &invert) != 1 ||
443 invert < 0 || invert > HDAPS_BOTH_AXES)
Robert Love860e1d62005-08-31 23:57:59 -0400444 return -EINVAL;
445
446 hdaps_invert = invert;
447 hdaps_calibrate();
448
449 return count;
450}
451
Robert Love860e1d62005-08-31 23:57:59 -0400452static DEVICE_ATTR(position, 0444, hdaps_position_show, NULL);
453static DEVICE_ATTR(variance, 0444, hdaps_variance_show, NULL);
454static DEVICE_ATTR(temp1, 0444, hdaps_temp1_show, NULL);
455static DEVICE_ATTR(temp2, 0444, hdaps_temp2_show, NULL);
456static DEVICE_ATTR(keyboard_activity, 0444, hdaps_keyboard_activity_show, NULL);
457static DEVICE_ATTR(mouse_activity, 0444, hdaps_mouse_activity_show, NULL);
458static DEVICE_ATTR(calibrate, 0644, hdaps_calibrate_show,hdaps_calibrate_store);
459static DEVICE_ATTR(invert, 0644, hdaps_invert_show, hdaps_invert_store);
Robert Love860e1d62005-08-31 23:57:59 -0400460
461static struct attribute *hdaps_attributes[] = {
462 &dev_attr_position.attr,
463 &dev_attr_variance.attr,
464 &dev_attr_temp1.attr,
465 &dev_attr_temp2.attr,
466 &dev_attr_keyboard_activity.attr,
467 &dev_attr_mouse_activity.attr,
468 &dev_attr_calibrate.attr,
Robert Love860e1d62005-08-31 23:57:59 -0400469 &dev_attr_invert.attr,
470 NULL,
471};
472
473static struct attribute_group hdaps_attribute_group = {
474 .attrs = hdaps_attributes,
475};
476
477
478/* Module stuff */
479
Robert Love4c87b742005-09-22 21:44:00 -0700480/* hdaps_dmi_match - found a match. return one, short-circuiting the hunt. */
Jeff Garzik18552562007-10-03 15:15:40 -0400481static int __init hdaps_dmi_match(const struct dmi_system_id *id)
Robert Love860e1d62005-08-31 23:57:59 -0400482{
483 printk(KERN_INFO "hdaps: %s detected.\n", id->ident);
Robert Love4c87b742005-09-22 21:44:00 -0700484 return 1;
Robert Love860e1d62005-08-31 23:57:59 -0400485}
486
Robert Love4c87b742005-09-22 21:44:00 -0700487/* hdaps_dmi_match_invert - found an inverted match. */
Jeff Garzik18552562007-10-03 15:15:40 -0400488static int __init hdaps_dmi_match_invert(const struct dmi_system_id *id)
Robert Love860e1d62005-08-31 23:57:59 -0400489{
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200490 hdaps_invert = (unsigned long)id->driver_data;
491 printk(KERN_INFO "hdaps: inverting axis (%u) readings.\n",
492 hdaps_invert);
Robert Love4c87b742005-09-22 21:44:00 -0700493 return hdaps_dmi_match(id);
Robert Love860e1d62005-08-31 23:57:59 -0400494}
495
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200496#define HDAPS_DMI_MATCH_INVERT(vendor, model, axes) { \
Jean Delvare509a5e82006-12-12 18:18:28 +0100497 .ident = vendor " " model, \
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200498 .callback = hdaps_dmi_match_invert, \
499 .driver_data = (void *)axes, \
Robert Love860e1d62005-08-31 23:57:59 -0400500 .matches = { \
Jean Delvare509a5e82006-12-12 18:18:28 +0100501 DMI_MATCH(DMI_BOARD_VENDOR, vendor), \
Robert Love860e1d62005-08-31 23:57:59 -0400502 DMI_MATCH(DMI_PRODUCT_VERSION, model) \
503 } \
504}
505
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200506#define HDAPS_DMI_MATCH_NORMAL(vendor, model) \
507 HDAPS_DMI_MATCH_INVERT(vendor, model, 0)
Robert Love860e1d62005-08-31 23:57:59 -0400508
Jean Delvare509a5e82006-12-12 18:18:28 +0100509/* Note that HDAPS_DMI_MATCH_NORMAL("ThinkPad T42") would match
Stephan Berberig0f23e502006-12-12 18:18:28 +0100510 "ThinkPad T42p", so the order of the entries matters.
511 If your ThinkPad is not recognized, please update to latest
512 BIOS. This is especially the case for some R52 ThinkPads. */
Jean Delvare509a5e82006-12-12 18:18:28 +0100513static struct dmi_system_id __initdata hdaps_whitelist[] = {
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200514 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad R50p", HDAPS_BOTH_AXES),
Jean Delvare509a5e82006-12-12 18:18:28 +0100515 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R50"),
516 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R51"),
517 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R52"),
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200518 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R61i", HDAPS_BOTH_AXES),
519 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R61", HDAPS_BOTH_AXES),
520 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T41p", HDAPS_BOTH_AXES),
Jean Delvare509a5e82006-12-12 18:18:28 +0100521 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T41"),
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200522 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T42p", HDAPS_BOTH_AXES),
Jean Delvare509a5e82006-12-12 18:18:28 +0100523 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T42"),
524 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T43"),
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200525 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T60", HDAPS_BOTH_AXES),
526 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61p", HDAPS_BOTH_AXES),
527 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61", HDAPS_BOTH_AXES),
Jean Delvare509a5e82006-12-12 18:18:28 +0100528 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad X40"),
Frank Seidelb6a33fe2009-03-30 21:46:42 +0200529 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad X41", HDAPS_Y_AXIS),
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200530 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X60", HDAPS_BOTH_AXES),
531 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61s", HDAPS_BOTH_AXES),
532 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61", HDAPS_BOTH_AXES),
Jean Delvare509a5e82006-12-12 18:18:28 +0100533 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad Z60m"),
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200534 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61m", HDAPS_BOTH_AXES),
535 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61p", HDAPS_BOTH_AXES),
Jean Delvare509a5e82006-12-12 18:18:28 +0100536 { .ident = NULL }
537};
Robert Love0f6c8402006-04-10 22:54:11 -0700538
Robert Love860e1d62005-08-31 23:57:59 -0400539static int __init hdaps_init(void)
540{
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400541 struct input_dev *idev;
Robert Love860e1d62005-08-31 23:57:59 -0400542 int ret;
543
Robert Love860e1d62005-08-31 23:57:59 -0400544 if (!dmi_check_system(hdaps_whitelist)) {
545 printk(KERN_WARNING "hdaps: supported laptop not found!\n");
Andrew Mortonb3f28a92006-04-10 22:54:32 -0700546 ret = -ENODEV;
Robert Love860e1d62005-08-31 23:57:59 -0400547 goto out;
548 }
549
550 if (!request_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS, "hdaps")) {
551 ret = -ENXIO;
552 goto out;
553 }
554
Russell King3ae5eae2005-11-09 22:32:44 +0000555 ret = platform_driver_register(&hdaps_driver);
Robert Love860e1d62005-08-31 23:57:59 -0400556 if (ret)
557 goto out_region;
558
559 pdev = platform_device_register_simple("hdaps", -1, NULL, 0);
560 if (IS_ERR(pdev)) {
561 ret = PTR_ERR(pdev);
562 goto out_driver;
563 }
564
565 ret = sysfs_create_group(&pdev->dev.kobj, &hdaps_attribute_group);
566 if (ret)
567 goto out_device;
568
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400569 hdaps_idev = input_allocate_polled_device();
Dmitry Torokhovd12eb7e2005-11-10 22:10:55 -0500570 if (!hdaps_idev) {
571 ret = -ENOMEM;
572 goto out_group;
573 }
574
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400575 hdaps_idev->poll = hdaps_mousedev_poll;
576 hdaps_idev->poll_interval = HDAPS_POLL_INTERVAL;
577
Robert Love393ad292005-09-16 19:28:07 -0700578 /* initial calibrate for the input device */
579 hdaps_calibrate();
580
581 /* initialize the input class */
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400582 idev = hdaps_idev->input;
583 idev->name = "hdaps";
Dmitry Torokhovd2fc60d2008-05-05 11:53:45 -0400584 idev->phys = "isa1600/input0";
585 idev->id.bustype = BUS_ISA;
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400586 idev->dev.parent = &pdev->dev;
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700587 idev->evbit[0] = BIT_MASK(EV_ABS);
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400588 input_set_abs_params(idev, ABS_X,
Dmitry Torokhovd12eb7e2005-11-10 22:10:55 -0500589 -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400590 input_set_abs_params(idev, ABS_Y,
Dmitry Torokhovd12eb7e2005-11-10 22:10:55 -0500591 -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
592
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400593 ret = input_register_polled_device(hdaps_idev);
Dmitry Torokhovb25a1062006-08-28 14:21:42 +0200594 if (ret)
595 goto out_idev;
Robert Love393ad292005-09-16 19:28:07 -0700596
Robert Love860e1d62005-08-31 23:57:59 -0400597 printk(KERN_INFO "hdaps: driver successfully loaded.\n");
598 return 0;
599
Dmitry Torokhovb25a1062006-08-28 14:21:42 +0200600out_idev:
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400601 input_free_polled_device(hdaps_idev);
Dmitry Torokhovd12eb7e2005-11-10 22:10:55 -0500602out_group:
603 sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
Robert Love860e1d62005-08-31 23:57:59 -0400604out_device:
605 platform_device_unregister(pdev);
606out_driver:
Russell King3ae5eae2005-11-09 22:32:44 +0000607 platform_driver_unregister(&hdaps_driver);
Robert Love860e1d62005-08-31 23:57:59 -0400608out_region:
609 release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
610out:
611 printk(KERN_WARNING "hdaps: driver init failed (ret=%d)!\n", ret);
612 return ret;
613}
614
615static void __exit hdaps_exit(void)
616{
Dmitry Torokhovaefca8b2007-10-12 21:30:36 -0400617 input_unregister_polled_device(hdaps_idev);
618 input_free_polled_device(hdaps_idev);
Robert Love860e1d62005-08-31 23:57:59 -0400619 sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
620 platform_device_unregister(pdev);
Russell King3ae5eae2005-11-09 22:32:44 +0000621 platform_driver_unregister(&hdaps_driver);
Robert Love860e1d62005-08-31 23:57:59 -0400622 release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
623
624 printk(KERN_INFO "hdaps: driver unloaded.\n");
625}
626
627module_init(hdaps_init);
628module_exit(hdaps_exit);
629
Frank Seidel2b8cf3e2009-03-30 21:46:41 +0200630module_param_named(invert, hdaps_invert, int, 0);
631MODULE_PARM_DESC(invert, "invert data along each axis. 1 invert x-axis, "
632 "2 invert y-axis, 3 invert both axes.");
Robert Love860e1d62005-08-31 23:57:59 -0400633
634MODULE_AUTHOR("Robert Love");
635MODULE_DESCRIPTION("IBM Hard Drive Active Protection System (HDAPS) driver");
636MODULE_LICENSE("GPL v2");