Revert "fb: Initialize fb_info mutexes in framebuffer_alloc()"
[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/platform_device.h>
31 #include <linux/input-polldev.h>
32 #include <linux/kernel.h>
33 #include <linux/mutex.h>
34 #include <linux/module.h>
35 #include <linux/timer.h>
36 #include <linux/dmi.h>
37 #include <linux/jiffies.h>
38
39 #include <asm/io.h>
40
41 #define HDAPS_LOW_PORT          0x1600  /* first port used by hdaps */
42 #define HDAPS_NR_PORTS          0x30    /* number of ports: 0x1600 - 0x162f */
43
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 */
47 #define HDAPS_PORT_TEMP1        0x1616  /* device temperature, in Celsius */
48 #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
54 #define STATE_FRESH             0x50    /* accelerometer data is fresh */
55
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
64 #define HDAPS_POLL_INTERVAL     50      /* poll for input every 1/20s (50 ms)*/
65 #define HDAPS_INPUT_FUZZ        4       /* input event threshold */
66 #define HDAPS_INPUT_FLAT        4
67
68 #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
72 static struct platform_device *pdev;
73 static struct input_polled_dev *hdaps_idev;
74 static unsigned int hdaps_invert;
75 static u8 km_activity;
76 static int rest_x;
77 static int rest_y;
78
79 static DEFINE_MUTEX(hdaps_mtx);
80
81 /*
82  * __get_latch - Get the value from a given port.  Callers must hold hdaps_mtx.
83  */
84 static inline u8 __get_latch(u16 port)
85 {
86         return inb(port) & 0xff;
87 }
88
89 /*
90  * __check_latch - Check a port latch for a given value.  Returns zero if the
91  * port contains the given value.  Callers must hold hdaps_mtx.
92  */
93 static inline int __check_latch(u16 port, u8 val)
94 {
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,
102  * returning zero if the value is obtained.  Callers must hold hdaps_mtx.
103  */
104 static int __wait_latch(u16 port, u8 val)
105 {
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
114         return -EIO;
115 }
116
117 /*
118  * __device_refresh - request a refresh from the accelerometer.  Does not wait
119  * for refresh to complete.  Callers must hold hdaps_mtx.
120  */
121 static void __device_refresh(void)
122 {
123         udelay(200);
124         if (inb(0x1604) != STATE_FRESH) {
125                 outb(0x11, 0x1610);
126                 outb(0x01, 0x161f);
127         }
128 }
129
130 /*
131  * __device_refresh_sync - request a synchronous refresh from the
132  * accelerometer.  We wait for the refresh to complete.  Returns zero if
133  * successful and nonzero on error.  Callers must hold hdaps_mtx.
134  */
135 static int __device_refresh_sync(void)
136 {
137         __device_refresh();
138         return __wait_latch(0x1604, STATE_FRESH);
139 }
140
141 /*
142  * __device_complete - indicate to the accelerometer that we are done reading
143  * data, and then initiate an async refresh.  Callers must hold hdaps_mtx.
144  */
145 static inline void __device_complete(void)
146 {
147         inb(0x161f);
148         inb(0x1604);
149         __device_refresh();
150 }
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  */
157 static int hdaps_readb_one(unsigned int port, u8 *val)
158 {
159         int ret;
160
161         mutex_lock(&hdaps_mtx);
162
163         /* 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
171 out:
172         mutex_unlock(&hdaps_mtx);
173         return ret;
174 }
175
176 /* __hdaps_read_pair - internal lockless helper for hdaps_read_pair(). */
177 static 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 */
181         if (__device_refresh_sync())
182                 return -EIO;
183
184         *y = inw(port2);
185         *x = inw(port1);
186         km_activity = inb(HDAPS_PORT_KMACT);
187         __device_complete();
188
189         /* hdaps_invert is a bitvector to negate the axes */
190         if (hdaps_invert & HDAPS_X_AXIS)
191                 *x = -*x;
192         if (hdaps_invert & HDAPS_Y_AXIS)
193                 *y = -*y;
194
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  */
202 static int hdaps_read_pair(unsigned int port1, unsigned int port2,
203                            int *val1, int *val2)
204 {
205         int ret;
206
207         mutex_lock(&hdaps_mtx);
208         ret = __hdaps_read_pair(port1, port2, val1, val2);
209         mutex_unlock(&hdaps_mtx);
210
211         return ret;
212 }
213
214 /*
215  * hdaps_device_init - initialize the accelerometer.  Returns zero on success
216  * and negative error code on failure.  Can sleep.
217  */
218 static int hdaps_device_init(void)
219 {
220         int total, ret = -ENXIO;
221
222         mutex_lock(&hdaps_mtx);
223
224         outb(0x13, 0x1610);
225         outb(0x01, 0x161f);
226         if (__wait_latch(0x161f, 0x00))
227                 goto out;
228
229         /*
230          * Most ThinkPads return 0x01.
231          *
232          * Others--namely the R50p, T41p, and T42p--return 0x03.  These laptops
233          * have "inverted" axises.
234          *
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;
268         if (__device_refresh_sync())
269                 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 */
274         for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
275                 int x, y;
276
277                 /* a read of the device helps push it into action */
278                 __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
279                 if (!__wait_latch(0x1611, 0x02)) {
280                         ret = 0;
281                         break;
282                 }
283
284                 msleep(INIT_WAIT_MSECS);
285         }
286
287 out:
288         mutex_unlock(&hdaps_mtx);
289         return ret;
290 }
291
292
293 /* Device model stuff */
294
295 static int hdaps_probe(struct platform_device *dev)
296 {
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
307 static int hdaps_resume(struct platform_device *dev)
308 {
309         return hdaps_device_init();
310 }
311
312 static struct platform_driver hdaps_driver = {
313         .probe = hdaps_probe,
314         .resume = hdaps_resume,
315         .driver = {
316                 .name = "hdaps",
317                 .owner = THIS_MODULE,
318         },
319 };
320
321 /*
322  * hdaps_calibrate - Set our "resting" values.  Callers must hold hdaps_mtx.
323  */
324 static void hdaps_calibrate(void)
325 {
326         __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &rest_x, &rest_y);
327 }
328
329 static void hdaps_mousedev_poll(struct input_polled_dev *dev)
330 {
331         struct input_dev *input_dev = dev->input;
332         int x, y;
333
334         mutex_lock(&hdaps_mtx);
335
336         if (__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y))
337                 goto out;
338
339         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);
342
343 out:
344         mutex_unlock(&hdaps_mtx);
345 }
346
347
348 /* Sysfs Files */
349
350 static 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
362 static 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
374 static 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
387 static 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
400 static 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
407 static 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
414 static 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
420 static ssize_t hdaps_calibrate_store(struct device *dev,
421                                      struct device_attribute *attr,
422                                      const char *buf, size_t count)
423 {
424         mutex_lock(&hdaps_mtx);
425         hdaps_calibrate();
426         mutex_unlock(&hdaps_mtx);
427
428         return count;
429 }
430
431 static 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
437 static 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
443         if (sscanf(buf, "%d", &invert) != 1 ||
444             invert < 0 || invert > HDAPS_BOTH_AXES)
445                 return -EINVAL;
446
447         hdaps_invert = invert;
448         hdaps_calibrate();
449
450         return count;
451 }
452
453 static DEVICE_ATTR(position, 0444, hdaps_position_show, NULL);
454 static DEVICE_ATTR(variance, 0444, hdaps_variance_show, NULL);
455 static DEVICE_ATTR(temp1, 0444, hdaps_temp1_show, NULL);
456 static DEVICE_ATTR(temp2, 0444, hdaps_temp2_show, NULL);
457 static DEVICE_ATTR(keyboard_activity, 0444, hdaps_keyboard_activity_show, NULL);
458 static DEVICE_ATTR(mouse_activity, 0444, hdaps_mouse_activity_show, NULL);
459 static DEVICE_ATTR(calibrate, 0644, hdaps_calibrate_show,hdaps_calibrate_store);
460 static DEVICE_ATTR(invert, 0644, hdaps_invert_show, hdaps_invert_store);
461
462 static 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,
470         &dev_attr_invert.attr,
471         NULL,
472 };
473
474 static struct attribute_group hdaps_attribute_group = {
475         .attrs = hdaps_attributes,
476 };
477
478
479 /* Module stuff */
480
481 /* hdaps_dmi_match - found a match.  return one, short-circuiting the hunt. */
482 static int __init hdaps_dmi_match(const struct dmi_system_id *id)
483 {
484         printk(KERN_INFO "hdaps: %s detected.\n", id->ident);
485         return 1;
486 }
487
488 /* hdaps_dmi_match_invert - found an inverted match. */
489 static int __init hdaps_dmi_match_invert(const struct dmi_system_id *id)
490 {
491         hdaps_invert = (unsigned long)id->driver_data;
492         printk(KERN_INFO "hdaps: inverting axis (%u) readings.\n",
493                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. */
514 static 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 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),
529         HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad X40"),
530         HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad X41", HDAPS_Y_AXIS),
531         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),
534         HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad Z60m"),
535         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61m", HDAPS_BOTH_AXES),
536         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61p", HDAPS_BOTH_AXES),
537         { .ident = NULL }
538 };
539
540 static int __init hdaps_init(void)
541 {
542         struct input_dev *idev;
543         int ret;
544
545         if (!dmi_check_system(hdaps_whitelist)) {
546                 printk(KERN_WARNING "hdaps: supported laptop not found!\n");
547                 ret = -ENODEV;
548                 goto out;
549         }
550
551         if (!request_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS, "hdaps")) {
552                 ret = -ENXIO;
553                 goto out;
554         }
555
556         ret = platform_driver_register(&hdaps_driver);
557         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
570         hdaps_idev = input_allocate_polled_device();
571         if (!hdaps_idev) {
572                 ret = -ENOMEM;
573                 goto out_group;
574         }
575
576         hdaps_idev->poll = hdaps_mousedev_poll;
577         hdaps_idev->poll_interval = HDAPS_POLL_INTERVAL;
578
579         /* initial calibrate for the input device */
580         hdaps_calibrate();
581
582         /* initialize the input class */
583         idev = hdaps_idev->input;
584         idev->name = "hdaps";
585         idev->phys = "isa1600/input0";
586         idev->id.bustype = BUS_ISA;
587         idev->dev.parent = &pdev->dev;
588         idev->evbit[0] = BIT_MASK(EV_ABS);
589         input_set_abs_params(idev, ABS_X,
590                         -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
591         input_set_abs_params(idev, ABS_Y,
592                         -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
593
594         ret = input_register_polled_device(hdaps_idev);
595         if (ret)
596                 goto out_idev;
597
598         printk(KERN_INFO "hdaps: driver successfully loaded.\n");
599         return 0;
600
601 out_idev:
602         input_free_polled_device(hdaps_idev);
603 out_group:
604         sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
605 out_device:
606         platform_device_unregister(pdev);
607 out_driver:
608         platform_driver_unregister(&hdaps_driver);
609 out_region:
610         release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
611 out:
612         printk(KERN_WARNING "hdaps: driver init failed (ret=%d)!\n", ret);
613         return ret;
614 }
615
616 static void __exit hdaps_exit(void)
617 {
618         input_unregister_polled_device(hdaps_idev);
619         input_free_polled_device(hdaps_idev);
620         sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
621         platform_device_unregister(pdev);
622         platform_driver_unregister(&hdaps_driver);
623         release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
624
625         printk(KERN_INFO "hdaps: driver unloaded.\n");
626 }
627
628 module_init(hdaps_init);
629 module_exit(hdaps_exit);
630
631 module_param_named(invert, hdaps_invert, int, 0);
632 MODULE_PARM_DESC(invert, "invert data along each axis. 1 invert x-axis, "
633                  "2 invert y-axis, 3 invert both axes.");
634
635 MODULE_AUTHOR("Robert Love");
636 MODULE_DESCRIPTION("IBM Hard Drive Active Protection System (HDAPS) driver");
637 MODULE_LICENSE("GPL v2");