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