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.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_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_dev *input_dev)
 322 {
 323         int x, y;
 324
 325         mutex_lock(&hdaps_mtx);
 326
 327         if (__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y))
 328                 goto out;
 329
 330         input_report_abs(input_dev, ABS_X, x - rest_x);
 331         input_report_abs(input_dev, ABS_Y, y - rest_y);
 332         input_sync(input_dev);
 333
 334 out:
 335         mutex_unlock(&hdaps_mtx);
 336 }
 337
 338
 339 /* Sysfs Files */
 340
 341 static ssize_t hdaps_position_show(struct device *dev,
 342                                    struct device_attribute *attr, char *buf)
 343 {
 344         int ret, x, y;
 345
 346         ret = hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
 347         if (ret)
 348                 return ret;
 349
 350         return sprintf(buf, "(%d,%d)\n", x, y);
 351 }
 352
 353 static ssize_t hdaps_variance_show(struct device *dev,
 354                                    struct device_attribute *attr, char *buf)
 355 {
 356         int ret, x, y;
 357
 358         ret = hdaps_read_pair(HDAPS_PORT_XVAR, HDAPS_PORT_YVAR, &x, &y);
 359         if (ret)
 360                 return ret;
 361
 362         return sprintf(buf, "(%d,%d)\n", x, y);
 363 }
 364
 365 static ssize_t hdaps_temp1_show(struct device *dev,
 366                                 struct device_attribute *attr, char *buf)
 367 {
 368         u8 uninitialized_var(temp);
 369         int ret;
 370
 371         ret = hdaps_readb_one(HDAPS_PORT_TEMP1, &temp);
 372         if (ret)
 373                 return ret;
 374
 375         return sprintf(buf, "%u\n", temp);
 376 }
 377
 378 static ssize_t hdaps_temp2_show(struct device *dev,
 379                                 struct device_attribute *attr, char *buf)
 380 {
 381         u8 uninitialized_var(temp);
 382         int ret;
 383
 384         ret = hdaps_readb_one(HDAPS_PORT_TEMP2, &temp);
 385         if (ret)
 386                 return ret;
 387
 388         return sprintf(buf, "%u\n", temp);
 389 }
 390
 391 static ssize_t hdaps_keyboard_activity_show(struct device *dev,
 392                                             struct device_attribute *attr,
 393                                             char *buf)
 394 {
 395         return sprintf(buf, "%u\n", KEYBD_ISSET(km_activity));
 396 }
 397
 398 static ssize_t hdaps_mouse_activity_show(struct device *dev,
 399                                          struct device_attribute *attr,
 400                                          char *buf)
 401 {
 402         return sprintf(buf, "%u\n", MOUSE_ISSET(km_activity));
 403 }
 404
 405 static ssize_t hdaps_calibrate_show(struct device *dev,
 406                                     struct device_attribute *attr, char *buf)
 407 {
 408         return sprintf(buf, "(%d,%d)\n", rest_x, rest_y);
 409 }
 410
 411 static ssize_t hdaps_calibrate_store(struct device *dev,
 412                                      struct device_attribute *attr,
 413                                      const char *buf, size_t count)
 414 {
 415         mutex_lock(&hdaps_mtx);
 416         hdaps_calibrate();
 417         mutex_unlock(&hdaps_mtx);
 418
 419         return count;
 420 }
 421
 422 static ssize_t hdaps_invert_show(struct device *dev,
 423                                  struct device_attribute *attr, char *buf)
 424 {
 425         return sprintf(buf, "%u\n", hdaps_invert);
 426 }
 427
 428 static ssize_t hdaps_invert_store(struct device *dev,
 429                                   struct device_attribute *attr,
 430                                   const char *buf, size_t count)
 431 {
 432         int invert;
 433
 434         if (sscanf(buf, "%d", &invert) != 1 ||
 435             invert < 0 || invert > HDAPS_BOTH_AXES)
 436                 return -EINVAL;
 437
 438         hdaps_invert = invert;
 439         hdaps_calibrate();
 440
 441         return count;
 442 }
 443
 444 static DEVICE_ATTR(position, 0444, hdaps_position_show, NULL);
 445 static DEVICE_ATTR(variance, 0444, hdaps_variance_show, NULL);
 446 static DEVICE_ATTR(temp1, 0444, hdaps_temp1_show, NULL);
 447 static DEVICE_ATTR(temp2, 0444, hdaps_temp2_show, NULL);
 448 static DEVICE_ATTR(keyboard_activity, 0444, hdaps_keyboard_activity_show, NULL);
 449 static DEVICE_ATTR(mouse_activity, 0444, hdaps_mouse_activity_show, NULL);
 450 static DEVICE_ATTR(calibrate, 0644, hdaps_calibrate_show,hdaps_calibrate_store);
 451 static DEVICE_ATTR(invert, 0644, hdaps_invert_show, hdaps_invert_store);
 452
 453 static struct attribute *hdaps_attributes[] = {
 454         &dev_attr_position.attr,
 455         &dev_attr_variance.attr,
 456         &dev_attr_temp1.attr,
 457         &dev_attr_temp2.attr,
 458         &dev_attr_keyboard_activity.attr,
 459         &dev_attr_mouse_activity.attr,
 460         &dev_attr_calibrate.attr,
 461         &dev_attr_invert.attr,
 462         NULL,
 463 };
 464
 465 static struct attribute_group hdaps_attribute_group = {
 466         .attrs = hdaps_attributes,
 467 };
 468
 469
 470 /* Module stuff */
 471
 472 /* hdaps_dmi_match - found a match.  return one, short-circuiting the hunt. */
 473 static int __init hdaps_dmi_match(const struct dmi_system_id *id)
 474 {
 475         pr_info("%s detected\n", id->ident);
 476         return 1;
 477 }
 478
 479 /* hdaps_dmi_match_invert - found an inverted match. */
 480 static int __init hdaps_dmi_match_invert(const struct dmi_system_id *id)
 481 {
 482         hdaps_invert = (unsigned long)id->driver_data;
 483         pr_info("inverting axis (%u) readings\n", hdaps_invert);
 484         return hdaps_dmi_match(id);
 485 }
 486
 487 #define HDAPS_DMI_MATCH_INVERT(vendor, model, axes) {   \
 488         .ident = vendor " " model,                      \
 489         .callback = hdaps_dmi_match_invert,             \
 490         .driver_data = (void *)axes,                    \
 491         .matches = {                                    \
 492                 DMI_MATCH(DMI_BOARD_VENDOR, vendor),    \
 493                 DMI_MATCH(DMI_PRODUCT_VERSION, model)   \
 494         }                                               \
 495 }
 496
 497 #define HDAPS_DMI_MATCH_NORMAL(vendor, model)           \
 498         HDAPS_DMI_MATCH_INVERT(vendor, model, 0)
 499
 500 /* Note that HDAPS_DMI_MATCH_NORMAL("ThinkPad T42") would match
 501    "ThinkPad T42p", so the order of the entries matters.
 502    If your ThinkPad is not recognized, please update to latest
 503    BIOS. This is especially the case for some R52 ThinkPads. */
 504 static const struct dmi_system_id hdaps_whitelist[] __initconst = {
 505         HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad R50p", HDAPS_BOTH_AXES),
 506         HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R50"),
 507         HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R51"),
 508         HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R52"),
 509         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R61i", HDAPS_BOTH_AXES),
 510         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R61", HDAPS_BOTH_AXES),
 511         HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T41p", HDAPS_BOTH_AXES),
 512         HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T41"),
 513         HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T42p", HDAPS_BOTH_AXES),
 514         HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T42"),
 515         HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T43"),
 516         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T400", HDAPS_BOTH_AXES),
 517         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T60", HDAPS_BOTH_AXES),
 518         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61p", HDAPS_BOTH_AXES),
 519         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61", HDAPS_BOTH_AXES),
 520         HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad X40"),
 521         HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad X41", HDAPS_Y_AXIS),
 522         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X60", HDAPS_BOTH_AXES),
 523         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61s", HDAPS_BOTH_AXES),
 524         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61", HDAPS_BOTH_AXES),
 525         HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad Z60m"),
 526         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61m", HDAPS_BOTH_AXES),
 527         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61p", HDAPS_BOTH_AXES),
 528         { .ident = NULL }
 529 };
 530
 531 static int __init hdaps_init(void)
 532 {
 533         int ret;
 534
 535         if (!dmi_check_system(hdaps_whitelist)) {
 536                 pr_warn("supported laptop not found!\n");
 537                 ret = -ENODEV;
 538                 goto out;
 539         }
 540
 541         if (!request_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS, "hdaps")) {
 542                 ret = -ENXIO;
 543                 goto out;
 544         }
 545
 546         ret = platform_driver_register(&hdaps_driver);
 547         if (ret)
 548                 goto out_region;
 549
 550         pdev = platform_device_register_simple("hdaps", -1, NULL, 0);
 551         if (IS_ERR(pdev)) {
 552                 ret = PTR_ERR(pdev);
 553                 goto out_driver;
 554         }
 555
 556         ret = sysfs_create_group(&pdev->dev.kobj, &hdaps_attribute_group);
 557         if (ret)
 558                 goto out_device;
 559
 560         hdaps_idev = input_allocate_device();
 561         if (!hdaps_idev) {
 562                 ret = -ENOMEM;
 563                 goto out_group;
 564         }
 565
 566         /* initial calibrate for the input device */
 567         hdaps_calibrate();
 568
 569         /* initialize the input class */
 570         hdaps_idev->name = "hdaps";
 571         hdaps_idev->phys = "isa1600/input0";
 572         hdaps_idev->id.bustype = BUS_ISA;
 573         hdaps_idev->dev.parent = &pdev->dev;
 574         input_set_abs_params(hdaps_idev, ABS_X,
 575                         -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
 576         input_set_abs_params(hdaps_idev, ABS_Y,
 577                         -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
 578
 579         ret = input_setup_polling(hdaps_idev, hdaps_mousedev_poll);
 580         if (ret)
 581                 goto out_idev;
 582
 583         input_set_poll_interval(hdaps_idev, HDAPS_POLL_INTERVAL);
 584
 585         ret = input_register_device(hdaps_idev);
 586         if (ret)
 587                 goto out_idev;
 588
 589         pr_info("driver successfully loaded\n");
 590         return 0;
 591
 592 out_idev:
 593         input_free_device(hdaps_idev);
 594 out_group:
 595         sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
 596 out_device:
 597         platform_device_unregister(pdev);
 598 out_driver:
 599         platform_driver_unregister(&hdaps_driver);
 600 out_region:
 601         release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
 602 out:
 603         pr_warn("driver init failed (ret=%d)!\n", ret);
 604         return ret;
 605 }
 606
 607 static void __exit hdaps_exit(void)
 608 {
 609         input_unregister_device(hdaps_idev);
 610         sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
 611         platform_device_unregister(pdev);
 612         platform_driver_unregister(&hdaps_driver);
 613         release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
 614
 615         pr_info("driver unloaded\n");
 616 }
 617
 618 module_init(hdaps_init);
 619 module_exit(hdaps_exit);
 620
 621 module_param_named(invert, hdaps_invert, int, 0);
 622 MODULE_PARM_DESC(invert, "invert data along each axis. 1 invert x-axis, "
 623                  "2 invert y-axis, 3 invert both axes.");
 624
 625 MODULE_AUTHOR("Robert Love");
 626 MODULE_DESCRIPTION("IBM Hard Drive Active Protection System (HDAPS) driver");
 627 MODULE_LICENSE("GPL v2");