drivers/platform/x86/hdaps.c

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