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