1 /* 2 * 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 #include <linux/io.h> 39 40 #define HDAPS_LOW_PORT 0x1600 /* first port used by hdaps */ 41 #define HDAPS_NR_PORTS 0x30 /* number of ports: 0x1600 - 0x162f */ 42 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 */ 46 #define HDAPS_PORT_TEMP1 0x1616 /* device temperature, in Celsius */ 47 #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 53 #define STATE_FRESH 0x50 /* accelerometer data is fresh */ 54 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 63 #define HDAPS_POLL_INTERVAL 50 /* poll for input every 1/20s (50 ms)*/ 64 #define HDAPS_INPUT_FUZZ 4 /* input event threshold */ 65 #define HDAPS_INPUT_FLAT 4 66 67 #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 71 static struct platform_device *pdev; 72 static struct input_polled_dev *hdaps_idev; 73 static unsigned int hdaps_invert; 74 static u8 km_activity; 75 static int rest_x; 76 static int rest_y; 77 78 static DEFINE_MUTEX(hdaps_mtx); 79 80 /* 81 * __get_latch - Get the value from a given port. Callers must hold hdaps_mtx. 82 */ 83 static inline u8 __get_latch(u16 port) 84 { 85 return inb(port) & 0xff; 86 } 87 88 /* 89 * __check_latch - Check a port latch for a given value. Returns zero if the 90 * port contains the given value. Callers must hold hdaps_mtx. 91 */ 92 static inline int __check_latch(u16 port, u8 val) 93 { 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, 101 * returning zero if the value is obtained. Callers must hold hdaps_mtx. 102 */ 103 static int __wait_latch(u16 port, u8 val) 104 { 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 113 return -EIO; 114 } 115 116 /* 117 * __device_refresh - request a refresh from the accelerometer. Does not wait 118 * for refresh to complete. Callers must hold hdaps_mtx. 119 */ 120 static void __device_refresh(void) 121 { 122 udelay(200); 123 if (inb(0x1604) != STATE_FRESH) { 124 outb(0x11, 0x1610); 125 outb(0x01, 0x161f); 126 } 127 } 128 129 /* 130 * __device_refresh_sync - request a synchronous refresh from the 131 * accelerometer. We wait for the refresh to complete. Returns zero if 132 * successful and nonzero on error. Callers must hold hdaps_mtx. 133 */ 134 static int __device_refresh_sync(void) 135 { 136 __device_refresh(); 137 return __wait_latch(0x1604, STATE_FRESH); 138 } 139 140 /* 141 * __device_complete - indicate to the accelerometer that we are done reading 142 * data, and then initiate an async refresh. Callers must hold hdaps_mtx. 143 */ 144 static inline void __device_complete(void) 145 { 146 inb(0x161f); 147 inb(0x1604); 148 __device_refresh(); 149 } 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 */ 156 static int hdaps_readb_one(unsigned int port, u8 *val) 157 { 158 int ret; 159 160 mutex_lock(&hdaps_mtx); 161 162 /* 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 170 out: 171 mutex_unlock(&hdaps_mtx); 172 return ret; 173 } 174 175 /* __hdaps_read_pair - internal lockless helper for hdaps_read_pair(). */ 176 static 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 */ 180 if (__device_refresh_sync()) 181 return -EIO; 182 183 *y = inw(port2); 184 *x = inw(port1); 185 km_activity = inb(HDAPS_PORT_KMACT); 186 __device_complete(); 187 188 /* hdaps_invert is a bitvector to negate the axes */ 189 if (hdaps_invert & HDAPS_X_AXIS) 190 *x = -*x; 191 if (hdaps_invert & HDAPS_Y_AXIS) 192 *y = -*y; 193 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 */ 201 static int hdaps_read_pair(unsigned int port1, unsigned int port2, 202 int *val1, int *val2) 203 { 204 int ret; 205 206 mutex_lock(&hdaps_mtx); 207 ret = __hdaps_read_pair(port1, port2, val1, val2); 208 mutex_unlock(&hdaps_mtx); 209 210 return ret; 211 } 212 213 /* 214 * hdaps_device_init - initialize the accelerometer. Returns zero on success 215 * and negative error code on failure. Can sleep. 216 */ 217 static int hdaps_device_init(void) 218 { 219 int total, ret = -ENXIO; 220 221 mutex_lock(&hdaps_mtx); 222 223 outb(0x13, 0x1610); 224 outb(0x01, 0x161f); 225 if (__wait_latch(0x161f, 0x00)) 226 goto out; 227 228 /* 229 * Most ThinkPads return 0x01. 230 * 231 * Others--namely the R50p, T41p, and T42p--return 0x03. These laptops 232 * have "inverted" axises. 233 * 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; 267 if (__device_refresh_sync()) 268 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 */ 273 for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) { 274 int x, y; 275 276 /* a read of the device helps push it into action */ 277 __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y); 278 if (!__wait_latch(0x1611, 0x02)) { 279 ret = 0; 280 break; 281 } 282 283 msleep(INIT_WAIT_MSECS); 284 } 285 286 out: 287 mutex_unlock(&hdaps_mtx); 288 return ret; 289 } 290 291 292 /* Device model stuff */ 293 294 static int hdaps_probe(struct platform_device *dev) 295 { 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 306 static int hdaps_resume(struct platform_device *dev) 307 { 308 return hdaps_device_init(); 309 } 310 311 static struct platform_driver hdaps_driver = { 312 .probe = hdaps_probe, 313 .resume = hdaps_resume, 314 .driver = { 315 .name = "hdaps", 316 .owner = THIS_MODULE, 317 }, 318 }; 319 320 /* 321 * hdaps_calibrate - Set our "resting" values. Callers must hold hdaps_mtx. 322 */ 323 static void hdaps_calibrate(void) 324 { 325 __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &rest_x, &rest_y); 326 } 327 328 static void hdaps_mousedev_poll(struct input_polled_dev *dev) 329 { 330 struct input_dev *input_dev = dev->input; 331 int x, y; 332 333 mutex_lock(&hdaps_mtx); 334 335 if (__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y)) 336 goto out; 337 338 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); 341 342 out: 343 mutex_unlock(&hdaps_mtx); 344 } 345 346 347 /* Sysfs Files */ 348 349 static 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 361 static 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 373 static 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 386 static 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 399 static 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 406 static 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 413 static 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 419 static ssize_t hdaps_calibrate_store(struct device *dev, 420 struct device_attribute *attr, 421 const char *buf, size_t count) 422 { 423 mutex_lock(&hdaps_mtx); 424 hdaps_calibrate(); 425 mutex_unlock(&hdaps_mtx); 426 427 return count; 428 } 429 430 static 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 436 static 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 442 if (sscanf(buf, "%d", &invert) != 1 || 443 invert < 0 || invert > HDAPS_BOTH_AXES) 444 return -EINVAL; 445 446 hdaps_invert = invert; 447 hdaps_calibrate(); 448 449 return count; 450 } 451 452 static DEVICE_ATTR(position, 0444, hdaps_position_show, NULL); 453 static DEVICE_ATTR(variance, 0444, hdaps_variance_show, NULL); 454 static DEVICE_ATTR(temp1, 0444, hdaps_temp1_show, NULL); 455 static DEVICE_ATTR(temp2, 0444, hdaps_temp2_show, NULL); 456 static DEVICE_ATTR(keyboard_activity, 0444, hdaps_keyboard_activity_show, NULL); 457 static DEVICE_ATTR(mouse_activity, 0444, hdaps_mouse_activity_show, NULL); 458 static DEVICE_ATTR(calibrate, 0644, hdaps_calibrate_show,hdaps_calibrate_store); 459 static DEVICE_ATTR(invert, 0644, hdaps_invert_show, hdaps_invert_store); 460 461 static 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, 469 &dev_attr_invert.attr, 470 NULL, 471 }; 472 473 static struct attribute_group hdaps_attribute_group = { 474 .attrs = hdaps_attributes, 475 }; 476 477 478 /* Module stuff */ 479 480 /* hdaps_dmi_match - found a match. return one, short-circuiting the hunt. */ 481 static int __init hdaps_dmi_match(const struct dmi_system_id *id) 482 { 483 printk(KERN_INFO "hdaps: %s detected.\n", id->ident); 484 return 1; 485 } 486 487 /* hdaps_dmi_match_invert - found an inverted match. */ 488 static int __init hdaps_dmi_match_invert(const struct dmi_system_id *id) 489 { 490 hdaps_invert = (unsigned long)id->driver_data; 491 printk(KERN_INFO "hdaps: inverting axis (%u) readings.\n", 492 hdaps_invert); 493 return hdaps_dmi_match(id); 494 } 495 496 #define HDAPS_DMI_MATCH_INVERT(vendor, model, axes) { \ 497 .ident = vendor " " model, \ 498 .callback = hdaps_dmi_match_invert, \ 499 .driver_data = (void *)axes, \ 500 .matches = { \ 501 DMI_MATCH(DMI_BOARD_VENDOR, vendor), \ 502 DMI_MATCH(DMI_PRODUCT_VERSION, model) \ 503 } \ 504 } 505 506 #define HDAPS_DMI_MATCH_NORMAL(vendor, model) \ 507 HDAPS_DMI_MATCH_INVERT(vendor, model, 0) 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", HDAPS_BOTH_AXES), 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", 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), 521 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T41"), 522 HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T42p", HDAPS_BOTH_AXES), 523 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T42"), 524 HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T43"), 525 HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T400", HDAPS_BOTH_AXES), 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"); 638