git.oblomov.eu Git - linux-2.6/blob - 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.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 #define HDAPS_INPUT_FLAT        4
  64
  65 static struct timer_list hdaps_timer;
  66 static struct platform_device *pdev;
  67 static struct input_dev *hdaps_idev;
  68 static unsigned int hdaps_invert;
  69 static u8 km_activity;
  70 static int rest_x;
  71 static int rest_y;
  72
  73 static DECLARE_MUTEX(hdaps_sem);
  74
  75 /*
  76  * __get_latch - Get the value from a given port.  Callers must hold hdaps_sem.
  77  */
  78 static inline u8 __get_latch(u16 port)
  79 {
  80         return inb(port) & 0xff;
  81 }
  82
  83 /*
  84  * __check_latch - Check a port latch for a given value.  Returns zero if the
  85  * port contains the given value.  Callers must hold hdaps_sem.
  86  */
  87 static inline int __check_latch(u16 port, u8 val)
  88 {
  89         if (__get_latch(port) == val)
  90                 return 0;
  91         return -EINVAL;
  92 }
  93
  94 /*
  95  * __wait_latch - Wait up to 100us for a port latch to get a certain value,
  96  * returning zero if the value is obtained.  Callers must hold hdaps_sem.
  97  */
  98 static int __wait_latch(u16 port, u8 val)
  99 {
 100         unsigned int i;
 101
 102         for (i = 0; i < 20; i++) {
 103                 if (!__check_latch(port, val))
 104                         return 0;
 105                 udelay(5);
 106         }
 107
 108         return -EIO;
 109 }
 110
 111 /*
 112  * __device_refresh - request a refresh from the accelerometer.  Does not wait
 113  * for refresh to complete.  Callers must hold hdaps_sem.
 114  */
 115 static void __device_refresh(void)
 116 {
 117         udelay(200);
 118         if (inb(0x1604) != STATE_FRESH) {
 119                 outb(0x11, 0x1610);
 120                 outb(0x01, 0x161f);
 121         }
 122 }
 123
 124 /*
 125  * __device_refresh_sync - request a synchronous refresh from the
 126  * accelerometer.  We wait for the refresh to complete.  Returns zero if
 127  * successful and nonzero on error.  Callers must hold hdaps_sem.
 128  */
 129 static int __device_refresh_sync(void)
 130 {
 131         __device_refresh();
 132         return __wait_latch(0x1604, STATE_FRESH);
 133 }
 134
 135 /*
 136  * __device_complete - indicate to the accelerometer that we are done reading
 137  * data, and then initiate an async refresh.  Callers must hold hdaps_sem.
 138  */
 139 static inline void __device_complete(void)
 140 {
 141         inb(0x161f);
 142         inb(0x1604);
 143         __device_refresh();
 144 }
 145
 146 /*
 147  * hdaps_readb_one - reads a byte from a single I/O port, placing the value in
 148  * the given pointer.  Returns zero on success or a negative error on failure.
 149  * Can sleep.
 150  */
 151 static int hdaps_readb_one(unsigned int port, u8 *val)
 152 {
 153         int ret;
 154
 155         down(&hdaps_sem);
 156
 157         /* do a sync refresh -- we need to be sure that we read fresh data */
 158         ret = __device_refresh_sync();
 159         if (ret)
 160                 goto out;
 161
 162         *val = inb(port);
 163         __device_complete();
 164
 165 out:
 166         up(&hdaps_sem);
 167         return ret;
 168 }
 169
 170 /* __hdaps_read_pair - internal lockless helper for hdaps_read_pair(). */
 171 static int __hdaps_read_pair(unsigned int port1, unsigned int port2,
 172                              int *x, int *y)
 173 {
 174         /* do a sync refresh -- we need to be sure that we read fresh data */
 175         if (__device_refresh_sync())
 176                 return -EIO;
 177
 178         *y = inw(port2);
 179         *x = inw(port1);
 180         km_activity = inb(HDAPS_PORT_KMACT);
 181         __device_complete();
 182
 183         /* if hdaps_invert is set, negate the two values */
 184         if (hdaps_invert) {
 185                 *x = -*x;
 186                 *y = -*y;
 187         }
 188
 189         return 0;
 190 }
 191
 192 /*
 193  * hdaps_read_pair - reads the values from a pair of ports, placing the values
 194  * in the given pointers.  Returns zero on success.  Can sleep.
 195  */
 196 static int hdaps_read_pair(unsigned int port1, unsigned int port2,
 197                            int *val1, int *val2)
 198 {
 199         int ret;
 200
 201         down(&hdaps_sem);
 202         ret = __hdaps_read_pair(port1, port2, val1, val2);
 203         up(&hdaps_sem);
 204
 205         return ret;
 206 }
 207
 208 /*
 209  * hdaps_device_init - initialize the accelerometer.  Returns zero on success
 210  * and negative error code on failure.  Can sleep.
 211  */
 212 static int hdaps_device_init(void)
 213 {
 214         int total, ret = -ENXIO;
 215
 216         down(&hdaps_sem);
 217
 218         outb(0x13, 0x1610);
 219         outb(0x01, 0x161f);
 220         if (__wait_latch(0x161f, 0x00))
 221                 goto out;
 222
 223         /*
 224          * Most ThinkPads return 0x01.
 225          *
 226          * Others--namely the R50p, T41p, and T42p--return 0x03.  These laptops
 227          * have "inverted" axises.
 228          *
 229          * The 0x02 value occurs when the chip has been previously initialized.
 230          */
 231         if (__check_latch(0x1611, 0x03) &&
 232                      __check_latch(0x1611, 0x02) &&
 233                      __check_latch(0x1611, 0x01))
 234                 goto out;
 235
 236         printk(KERN_DEBUG "hdaps: initial latch check good (0x%02x).\n",
 237                __get_latch(0x1611));
 238
 239         outb(0x17, 0x1610);
 240         outb(0x81, 0x1611);
 241         outb(0x01, 0x161f);
 242         if (__wait_latch(0x161f, 0x00))
 243                 goto out;
 244         if (__wait_latch(0x1611, 0x00))
 245                 goto out;
 246         if (__wait_latch(0x1612, 0x60))
 247                 goto out;
 248         if (__wait_latch(0x1613, 0x00))
 249                 goto out;
 250         outb(0x14, 0x1610);
 251         outb(0x01, 0x1611);
 252         outb(0x01, 0x161f);
 253         if (__wait_latch(0x161f, 0x00))
 254                 goto out;
 255         outb(0x10, 0x1610);
 256         outb(0xc8, 0x1611);
 257         outb(0x00, 0x1612);
 258         outb(0x02, 0x1613);
 259         outb(0x01, 0x161f);
 260         if (__wait_latch(0x161f, 0x00))
 261                 goto out;
 262         if (__device_refresh_sync())
 263                 goto out;
 264         if (__wait_latch(0x1611, 0x00))
 265                 goto out;
 266
 267         /* we have done our dance, now let's wait for the applause */
 268         for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
 269                 int x, y;
 270
 271                 /* a read of the device helps push it into action */
 272                 __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
 273                 if (!__wait_latch(0x1611, 0x02)) {
 274                         ret = 0;
 275                         break;
 276                 }
 277
 278                 msleep(INIT_WAIT_MSECS);
 279         }
 280
 281 out:
 282         up(&hdaps_sem);
 283         return ret;
 284 }
 285
 286
 287 /* Device model stuff */
 288
 289 static int hdaps_probe(struct platform_device *dev)
 290 {
 291         int ret;
 292
 293         ret = hdaps_device_init();
 294         if (ret)
 295                 return ret;
 296
 297         printk(KERN_INFO "hdaps: device successfully initialized.\n");
 298         return 0;
 299 }
 300
 301 static int hdaps_resume(struct platform_device *dev)
 302 {
 303         return hdaps_device_init();
 304 }
 305
 306 static struct platform_driver hdaps_driver = {
 307         .probe = hdaps_probe,
 308         .resume = hdaps_resume,
 309         .driver = {
 310                 .name = "hdaps",
 311                 .owner = THIS_MODULE,
 312         },
 313 };
 314
 315 /*
 316  * hdaps_calibrate - Set our "resting" values.  Callers must hold hdaps_sem.
 317  */
 318 static void hdaps_calibrate(void)
 319 {
 320         __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &rest_x, &rest_y);
 321 }
 322
 323 static void hdaps_mousedev_poll(unsigned long unused)
 324 {
 325         int x, y;
 326
 327         /* Cannot sleep.  Try nonblockingly.  If we fail, try again later. */
 328         if (down_trylock(&hdaps_sem)) {
 329                 mod_timer(&hdaps_timer,jiffies + HDAPS_POLL_PERIOD);
 330                 return;
 331         }
 332
 333         if (__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y))
 334                 goto out;
 335
 336         input_report_abs(hdaps_idev, ABS_X, x - rest_x);
 337         input_report_abs(hdaps_idev, ABS_Y, y - rest_y);
 338         input_sync(hdaps_idev);
 339
 340         mod_timer(&hdaps_timer, jiffies + HDAPS_POLL_PERIOD);
 341
 342 out:
 343         up(&hdaps_sem);
 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         down(&hdaps_sem);
 424         hdaps_calibrate();
 425         up(&hdaps_sem);
 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 || (invert != 1 && invert != 0))
 443                 return -EINVAL;
 444
 445         hdaps_invert = invert;
 446         hdaps_calibrate();
 447
 448         return count;
 449 }
 450
 451 static DEVICE_ATTR(position, 0444, hdaps_position_show, NULL);
 452 static DEVICE_ATTR(variance, 0444, hdaps_variance_show, NULL);
 453 static DEVICE_ATTR(temp1, 0444, hdaps_temp1_show, NULL);
 454 static DEVICE_ATTR(temp2, 0444, hdaps_temp2_show, NULL);
 455 static DEVICE_ATTR(keyboard_activity, 0444, hdaps_keyboard_activity_show, NULL);
 456 static DEVICE_ATTR(mouse_activity, 0444, hdaps_mouse_activity_show, NULL);
 457 static DEVICE_ATTR(calibrate, 0644, hdaps_calibrate_show,hdaps_calibrate_store);
 458 static DEVICE_ATTR(invert, 0644, hdaps_invert_show, hdaps_invert_store);
 459
 460 static struct attribute *hdaps_attributes[] = {
 461         &dev_attr_position.attr,
 462         &dev_attr_variance.attr,
 463         &dev_attr_temp1.attr,
 464         &dev_attr_temp2.attr,
 465         &dev_attr_keyboard_activity.attr,
 466         &dev_attr_mouse_activity.attr,
 467         &dev_attr_calibrate.attr,
 468         &dev_attr_invert.attr,
 469         NULL,
 470 };
 471
 472 static struct attribute_group hdaps_attribute_group = {
 473         .attrs = hdaps_attributes,
 474 };
 475
 476
 477 /* Module stuff */
 478
 479 /* hdaps_dmi_match - found a match.  return one, short-circuiting the hunt. */
 480 static int hdaps_dmi_match(struct dmi_system_id *id)
 481 {
 482         printk(KERN_INFO "hdaps: %s detected.\n", id->ident);
 483         return 1;
 484 }
 485
 486 /* hdaps_dmi_match_invert - found an inverted match. */
 487 static int hdaps_dmi_match_invert(struct dmi_system_id *id)
 488 {
 489         hdaps_invert = 1;
 490         printk(KERN_INFO "hdaps: inverting axis readings.\n");
 491         return hdaps_dmi_match(id);
 492 }
 493
 494 #define HDAPS_DMI_MATCH_NORMAL(model)   {               \
 495         .ident = "IBM " model,                          \
 496         .callback = hdaps_dmi_match,                    \
 497         .matches = {                                    \
 498                 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"),     \
 499                 DMI_MATCH(DMI_PRODUCT_VERSION, model)   \
 500         }                                               \
 501 }
 502
 503 #define HDAPS_DMI_MATCH_INVERT(model)   {               \
 504         .ident = "IBM " model,                          \
 505         .callback = hdaps_dmi_match_invert,             \
 506         .matches = {                                    \
 507                 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"),     \
 508                 DMI_MATCH(DMI_PRODUCT_VERSION, model)   \
 509         }                                               \
 510 }
 511
 512 #define HDAPS_DMI_MATCH_LENOVO(model)   {               \
 513         .ident = "Lenovo " model,                       \
 514         .callback = hdaps_dmi_match_invert,             \
 515         .matches = {                                    \
 516                 DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),  \
 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_NORMAL("ThinkPad H"),
 528                 HDAPS_DMI_MATCH_INVERT("ThinkPad R50p"),
 529                 HDAPS_DMI_MATCH_NORMAL("ThinkPad R50"),
 530                 HDAPS_DMI_MATCH_NORMAL("ThinkPad R51"),
 531                 HDAPS_DMI_MATCH_NORMAL("ThinkPad R52"),
 532                 HDAPS_DMI_MATCH_INVERT("ThinkPad T41p"),
 533                 HDAPS_DMI_MATCH_NORMAL("ThinkPad T41"),
 534                 HDAPS_DMI_MATCH_INVERT("ThinkPad T42p"),
 535                 HDAPS_DMI_MATCH_NORMAL("ThinkPad T42"),
 536                 HDAPS_DMI_MATCH_NORMAL("ThinkPad T43"),
 537                 HDAPS_DMI_MATCH_LENOVO("ThinkPad T60p"),
 538                 HDAPS_DMI_MATCH_NORMAL("ThinkPad X40"),
 539                 HDAPS_DMI_MATCH_NORMAL("ThinkPad X41 Tablet"),
 540                 HDAPS_DMI_MATCH_NORMAL("ThinkPad X41"),
 541                 HDAPS_DMI_MATCH_LENOVO("ThinkPad X60"),
 542                 { .ident = NULL }
 543         };
 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_device();
 571         if (!hdaps_idev) {
 572                 ret = -ENOMEM;
 573                 goto out_group;
 574         }
 575
 576         /* initial calibrate for the input device */
 577         hdaps_calibrate();
 578
 579         /* initialize the input class */
 580         hdaps_idev->name = "hdaps";
 581         hdaps_idev->cdev.dev = &pdev->dev;
 582         hdaps_idev->evbit[0] = BIT(EV_ABS);
 583         input_set_abs_params(hdaps_idev, ABS_X,
 584                         -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
 585         input_set_abs_params(hdaps_idev, ABS_Y,
 586                         -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
 587
 588         input_register_device(hdaps_idev);
 589
 590         /* start up our timer for the input device */
 591         init_timer(&hdaps_timer);
 592         hdaps_timer.function = hdaps_mousedev_poll;
 593         hdaps_timer.expires = jiffies + HDAPS_POLL_PERIOD;
 594         add_timer(&hdaps_timer);
 595
 596         printk(KERN_INFO "hdaps: driver successfully loaded.\n");
 597         return 0;
 598
 599 out_group:
 600         sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
 601 out_device:
 602         platform_device_unregister(pdev);
 603 out_driver:
 604         platform_driver_unregister(&hdaps_driver);
 605 out_region:
 606         release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
 607 out:
 608         printk(KERN_WARNING "hdaps: driver init failed (ret=%d)!\n", ret);
 609         return ret;
 610 }
 611
 612 static void __exit hdaps_exit(void)
 613 {
 614         del_timer_sync(&hdaps_timer);
 615         input_unregister_device(hdaps_idev);
 616         sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
 617         platform_device_unregister(pdev);
 618         platform_driver_unregister(&hdaps_driver);
 619         release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
 620
 621         printk(KERN_INFO "hdaps: driver unloaded.\n");
 622 }
 623
 624 module_init(hdaps_init);
 625 module_exit(hdaps_exit);
 626
 627 module_param_named(invert, hdaps_invert, bool, 0);
 628 MODULE_PARM_DESC(invert, "invert data along each axis");
 629
 630 MODULE_AUTHOR("Robert Love");
 631 MODULE_DESCRIPTION("IBM Hard Drive Active Protection System (HDAPS) driver");
 632 MODULE_LICENSE("GPL v2");