drivers/platform/x86/hdaps.c

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