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
  64 static struct timer_list hdaps_timer;
  65 static struct platform_device *pdev;
  66 static unsigned int hdaps_invert;
  67 static u8 km_activity;
  68 static int rest_x;
  69 static int rest_y;
  70
  71 static DECLARE_MUTEX(hdaps_sem);
  72
  73 /*
  74  * __get_latch - Get the value from a given port.  Callers must hold hdaps_sem.
  75  */
  76 static inline u8 __get_latch(u16 port)
  77 {
  78         return inb(port) & 0xff;
  79 }
  80
  81 /*
  82  * __check_latch - Check a port latch for a given value.  Returns zero if the
  83  * port contains the given value.  Callers must hold hdaps_sem.
  84  */
  85 static inline int __check_latch(u16 port, u8 val)
  86 {
  87         if (__get_latch(port) == val)
  88                 return 0;
  89         return -EINVAL;
  90 }
  91
  92 /*
  93  * __wait_latch - Wait up to 100us for a port latch to get a certain value,
  94  * returning zero if the value is obtained.  Callers must hold hdaps_sem.
  95  */
  96 static int __wait_latch(u16 port, u8 val)
  97 {
  98         unsigned int i;
  99
 100         for (i = 0; i < 20; i++) {
 101                 if (!__check_latch(port, val))
 102                         return 0;
 103                 udelay(5);
 104         }
 105
 106         return -EIO;
 107 }
 108
 109 /*
 110  * __device_refresh - request a refresh from the accelerometer.  Does not wait
 111  * for refresh to complete.  Callers must hold hdaps_sem.
 112  */
 113 static void __device_refresh(void)
 114 {
 115         udelay(200);
 116         if (inb(0x1604) != STATE_FRESH) {
 117                 outb(0x11, 0x1610);
 118                 outb(0x01, 0x161f);
 119         }
 120 }
 121
 122 /*
 123  * __device_refresh_sync - request a synchronous refresh from the
 124  * accelerometer.  We wait for the refresh to complete.  Returns zero if
 125  * successful and nonzero on error.  Callers must hold hdaps_sem.
 126  */
 127 static int __device_refresh_sync(void)
 128 {
 129         __device_refresh();
 130         return __wait_latch(0x1604, STATE_FRESH);
 131 }
 132
 133 /*
 134  * __device_complete - indicate to the accelerometer that we are done reading
 135  * data, and then initiate an async refresh.  Callers must hold hdaps_sem.
 136  */
 137 static inline void __device_complete(void)
 138 {
 139         inb(0x161f);
 140         inb(0x1604);
 141         __device_refresh();
 142 }
 143
 144 /*
 145  * hdaps_readb_one - reads a byte from a single I/O port, placing the value in
 146  * the given pointer.  Returns zero on success or a negative error on failure.
 147  * Can sleep.
 148  */
 149 static int hdaps_readb_one(unsigned int port, u8 *val)
 150 {
 151         int ret;
 152
 153         down(&hdaps_sem);
 154
 155         /* do a sync refresh -- we need to be sure that we read fresh data */
 156         ret = __device_refresh_sync();
 157         if (ret)
 158                 goto out;
 159
 160         *val = inb(port);
 161         __device_complete();
 162
 163 out:
 164         up(&hdaps_sem);
 165         return ret;
 166 }
 167
 168 /* __hdaps_read_pair - internal lockless helper for hdaps_read_pair(). */
 169 static int __hdaps_read_pair(unsigned int port1, unsigned int port2,
 170                              int *x, int *y)
 171 {
 172         /* do a sync refresh -- we need to be sure that we read fresh data */
 173         if (__device_refresh_sync())
 174                 return -EIO;
 175
 176         *y = inw(port2);
 177         *x = inw(port1);
 178         km_activity = inb(HDAPS_PORT_KMACT);
 179         __device_complete();
 180
 181         /* if hdaps_invert is set, negate the two values */
 182         if (hdaps_invert) {
 183                 *x = -*x;
 184                 *y = -*y;
 185         }
 186
 187         return 0;
 188 }
 189
 190 /*
 191  * hdaps_read_pair - reads the values from a pair of ports, placing the values
 192  * in the given pointers.  Returns zero on success.  Can sleep.
 193  */
 194 static int hdaps_read_pair(unsigned int port1, unsigned int port2,
 195                            int *val1, int *val2)
 196 {
 197         int ret;
 198
 199         down(&hdaps_sem);
 200         ret = __hdaps_read_pair(port1, port2, val1, val2);
 201         up(&hdaps_sem);
 202
 203         return ret;
 204 }
 205
 206 /*
 207  * hdaps_device_init - initialize the accelerometer.  Returns zero on success
 208  * and negative error code on failure.  Can sleep.
 209  */
 210 static int hdaps_device_init(void)
 211 {
 212         int total, ret = -ENXIO;
 213
 214         down(&hdaps_sem);
 215
 216         outb(0x13, 0x1610);
 217         outb(0x01, 0x161f);
 218         if (__wait_latch(0x161f, 0x00))
 219                 goto out;
 220
 221         /*
 222          * Most ThinkPads return 0x01.
 223          *
 224          * Others--namely the R50p, T41p, and T42p--return 0x03.  These laptops
 225          * have "inverted" axises.
 226          *
 227          * The 0x02 value occurs when the chip has been previously initialized.
 228          */
 229         if (__check_latch(0x1611, 0x03) &&
 230                      __check_latch(0x1611, 0x02) &&
 231                      __check_latch(0x1611, 0x01))
 232                 goto out;
 233
 234         printk(KERN_DEBUG "hdaps: initial latch check good (0x%02x).\n",
 235                __get_latch(0x1611));
 236
 237         outb(0x17, 0x1610);
 238         outb(0x81, 0x1611);
 239         outb(0x01, 0x161f);
 240         if (__wait_latch(0x161f, 0x00))
 241                 goto out;
 242         if (__wait_latch(0x1611, 0x00))
 243                 goto out;
 244         if (__wait_latch(0x1612, 0x60))
 245                 goto out;
 246         if (__wait_latch(0x1613, 0x00))
 247                 goto out;
 248         outb(0x14, 0x1610);
 249         outb(0x01, 0x1611);
 250         outb(0x01, 0x161f);
 251         if (__wait_latch(0x161f, 0x00))
 252                 goto out;
 253         outb(0x10, 0x1610);
 254         outb(0xc8, 0x1611);
 255         outb(0x00, 0x1612);
 256         outb(0x02, 0x1613);
 257         outb(0x01, 0x161f);
 258         if (__wait_latch(0x161f, 0x00))
 259                 goto out;
 260         if (__device_refresh_sync())
 261                 goto out;
 262         if (__wait_latch(0x1611, 0x00))
 263                 goto out;
 264
 265         /* we have done our dance, now let's wait for the applause */
 266         for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
 267                 int x, y;
 268
 269                 /* a read of the device helps push it into action */
 270                 __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
 271                 if (!__wait_latch(0x1611, 0x02)) {
 272                         ret = 0;
 273                         break;
 274                 }
 275
 276                 msleep(INIT_WAIT_MSECS);
 277         }
 278
 279 out:
 280         up(&hdaps_sem);
 281         return ret;
 282 }
 283
 284
 285 /* Device model stuff */
 286
 287 static int hdaps_probe(struct platform_device *dev)
 288 {
 289         int ret;
 290
 291         ret = hdaps_device_init();
 292         if (ret)
 293                 return ret;
 294
 295         printk(KERN_INFO "hdaps: device successfully initialized.\n");
 296         return 0;
 297 }
 298
 299 static int hdaps_resume(struct platform_device *dev)
 300 {
 301         return hdaps_device_init();
 302 }
 303
 304 static struct platform_driver hdaps_driver = {
 305         .probe = hdaps_probe,
 306         .resume = hdaps_resume,
 307         .driver = {
 308                 .name = "hdaps",
 309                 .owner = THIS_MODULE,
 310         },
 311 };
 312
 313 /* Input class stuff */
 314
 315 static struct input_dev hdaps_idev = {
 316         .name = "hdaps",
 317         .evbit = { BIT(EV_ABS) },
 318         .absbit = { BIT(ABS_X) | BIT(ABS_Y) },
 319         .absmin  = { [ABS_X] = -256, [ABS_Y] = -256 },
 320         .absmax  = { [ABS_X] = 256, [ABS_Y] = 256 },
 321         .absfuzz = { [ABS_X] = HDAPS_INPUT_FUZZ, [ABS_Y] = HDAPS_INPUT_FUZZ },
 322         .absflat = { [ABS_X] = HDAPS_INPUT_FUZZ, [ABS_Y] = HDAPS_INPUT_FUZZ },
 323 };
 324
 325 /*
 326  * hdaps_calibrate - Set our "resting" values.  Callers must hold hdaps_sem.
 327  */
 328 static void hdaps_calibrate(void)
 329 {
 330         __hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &rest_x, &rest_y);
 331 }
 332
 333 static void hdaps_mousedev_poll(unsigned long unused)
 334 {
 335         int x, y;
 336
 337         /* Cannot sleep.  Try nonblockingly.  If we fail, try again later. */
 338         if (down_trylock(&hdaps_sem)) {
 339                 mod_timer(&hdaps_timer,jiffies + HDAPS_POLL_PERIOD);
 340                 return;
 341         }
 342
 343         if (__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y))
 344                 goto out;
 345
 346         input_report_abs(&hdaps_idev, ABS_X, x - rest_x);
 347         input_report_abs(&hdaps_idev, ABS_Y, y - rest_y);
 348         input_sync(&hdaps_idev);
 349
 350         mod_timer(&hdaps_timer, jiffies + HDAPS_POLL_PERIOD);
 351
 352 out:
 353         up(&hdaps_sem);
 354 }
 355
 356
 357 /* Sysfs Files */
 358
 359 static ssize_t hdaps_position_show(struct device *dev,
 360                                    struct device_attribute *attr, char *buf)
 361 {
 362         int ret, x, y;
 363
 364         ret = hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
 365         if (ret)
 366                 return ret;
 367
 368         return sprintf(buf, "(%d,%d)\n", x, y);
 369 }
 370
 371 static ssize_t hdaps_variance_show(struct device *dev,
 372                                    struct device_attribute *attr, char *buf)
 373 {
 374         int ret, x, y;
 375
 376         ret = hdaps_read_pair(HDAPS_PORT_XVAR, HDAPS_PORT_YVAR, &x, &y);
 377         if (ret)
 378                 return ret;
 379
 380         return sprintf(buf, "(%d,%d)\n", x, y);
 381 }
 382
 383 static ssize_t hdaps_temp1_show(struct device *dev,
 384                                 struct device_attribute *attr, char *buf)
 385 {
 386         u8 temp;
 387         int ret;
 388
 389         ret = hdaps_readb_one(HDAPS_PORT_TEMP1, &temp);
 390         if (ret < 0)
 391                 return ret;
 392
 393         return sprintf(buf, "%u\n", temp);
 394 }
 395
 396 static ssize_t hdaps_temp2_show(struct device *dev,
 397                                 struct device_attribute *attr, char *buf)
 398 {
 399         u8 temp;
 400         int ret;
 401
 402         ret = hdaps_readb_one(HDAPS_PORT_TEMP2, &temp);
 403         if (ret < 0)
 404                 return ret;
 405
 406         return sprintf(buf, "%u\n", temp);
 407 }
 408
 409 static ssize_t hdaps_keyboard_activity_show(struct device *dev,
 410                                             struct device_attribute *attr,
 411                                             char *buf)
 412 {
 413         return sprintf(buf, "%u\n", KEYBD_ISSET(km_activity));
 414 }
 415
 416 static ssize_t hdaps_mouse_activity_show(struct device *dev,
 417                                          struct device_attribute *attr,
 418                                          char *buf)
 419 {
 420         return sprintf(buf, "%u\n", MOUSE_ISSET(km_activity));
 421 }
 422
 423 static ssize_t hdaps_calibrate_show(struct device *dev,
 424                                     struct device_attribute *attr, char *buf)
 425 {
 426         return sprintf(buf, "(%d,%d)\n", rest_x, rest_y);
 427 }
 428
 429 static ssize_t hdaps_calibrate_store(struct device *dev,
 430                                      struct device_attribute *attr,
 431                                      const char *buf, size_t count)
 432 {
 433         down(&hdaps_sem);
 434         hdaps_calibrate();
 435         up(&hdaps_sem);
 436
 437         return count;
 438 }
 439
 440 static ssize_t hdaps_invert_show(struct device *dev,
 441                                  struct device_attribute *attr, char *buf)
 442 {
 443         return sprintf(buf, "%u\n", hdaps_invert);
 444 }
 445
 446 static ssize_t hdaps_invert_store(struct device *dev,
 447                                   struct device_attribute *attr,
 448                                   const char *buf, size_t count)
 449 {
 450         int invert;
 451
 452         if (sscanf(buf, "%d", &invert) != 1 || (invert != 1 && invert != 0))
 453                 return -EINVAL;
 454
 455         hdaps_invert = invert;
 456         hdaps_calibrate();
 457
 458         return count;
 459 }
 460
 461 static DEVICE_ATTR(position, 0444, hdaps_position_show, NULL);
 462 static DEVICE_ATTR(variance, 0444, hdaps_variance_show, NULL);
 463 static DEVICE_ATTR(temp1, 0444, hdaps_temp1_show, NULL);
 464 static DEVICE_ATTR(temp2, 0444, hdaps_temp2_show, NULL);
 465 static DEVICE_ATTR(keyboard_activity, 0444, hdaps_keyboard_activity_show, NULL);
 466 static DEVICE_ATTR(mouse_activity, 0444, hdaps_mouse_activity_show, NULL);
 467 static DEVICE_ATTR(calibrate, 0644, hdaps_calibrate_show,hdaps_calibrate_store);
 468 static DEVICE_ATTR(invert, 0644, hdaps_invert_show, hdaps_invert_store);
 469
 470 static struct attribute *hdaps_attributes[] = {
 471         &dev_attr_position.attr,
 472         &dev_attr_variance.attr,
 473         &dev_attr_temp1.attr,
 474         &dev_attr_temp2.attr,
 475         &dev_attr_keyboard_activity.attr,
 476         &dev_attr_mouse_activity.attr,
 477         &dev_attr_calibrate.attr,
 478         &dev_attr_invert.attr,
 479         NULL,
 480 };
 481
 482 static struct attribute_group hdaps_attribute_group = {
 483         .attrs = hdaps_attributes,
 484 };
 485
 486
 487 /* Module stuff */
 488
 489 /* hdaps_dmi_match - found a match.  return one, short-circuiting the hunt. */
 490 static int hdaps_dmi_match(struct dmi_system_id *id)
 491 {
 492         printk(KERN_INFO "hdaps: %s detected.\n", id->ident);
 493         return 1;
 494 }
 495
 496 /* hdaps_dmi_match_invert - found an inverted match. */
 497 static int hdaps_dmi_match_invert(struct dmi_system_id *id)
 498 {
 499         hdaps_invert = 1;
 500         printk(KERN_INFO "hdaps: inverting axis readings.\n");
 501         return hdaps_dmi_match(id);
 502 }
 503
 504 #define HDAPS_DMI_MATCH_NORMAL(model)   {               \
 505         .ident = "IBM " model,                          \
 506         .callback = hdaps_dmi_match,                    \
 507         .matches = {                                    \
 508                 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"),     \
 509                 DMI_MATCH(DMI_PRODUCT_VERSION, model)   \
 510         }                                               \
 511 }
 512
 513 #define HDAPS_DMI_MATCH_INVERT(model)   {               \
 514         .ident = "IBM " model,                          \
 515         .callback = hdaps_dmi_match_invert,             \
 516         .matches = {                                    \
 517                 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"),     \
 518                 DMI_MATCH(DMI_PRODUCT_VERSION, model)   \
 519         }                                               \
 520 }
 521
 522 static int __init hdaps_init(void)
 523 {
 524         int ret;
 525
 526         /* Note that DMI_MATCH(...,"ThinkPad T42") will match "ThinkPad T42p" */
 527         struct dmi_system_id hdaps_whitelist[] = {
 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_NORMAL("ThinkPad X40"),
 538                 HDAPS_DMI_MATCH_NORMAL("ThinkPad X41 Tablet"),
 539                 HDAPS_DMI_MATCH_NORMAL("ThinkPad X41"),
 540                 { .ident = NULL }
 541         };
 542
 543         if (!dmi_check_system(hdaps_whitelist)) {
 544                 printk(KERN_WARNING "hdaps: supported laptop not found!\n");
 545                 ret = -ENXIO;
 546                 goto out;
 547         }
 548
 549         if (!request_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS, "hdaps")) {
 550                 ret = -ENXIO;
 551                 goto out;
 552         }
 553
 554         ret = platform_driver_register(&hdaps_driver);
 555         if (ret)
 556                 goto out_region;
 557
 558         pdev = platform_device_register_simple("hdaps", -1, NULL, 0);
 559         if (IS_ERR(pdev)) {
 560                 ret = PTR_ERR(pdev);
 561                 goto out_driver;
 562         }
 563
 564         ret = sysfs_create_group(&pdev->dev.kobj, &hdaps_attribute_group);
 565         if (ret)
 566                 goto out_device;
 567
 568         /* initial calibrate for the input device */
 569         hdaps_calibrate();
 570
 571         /* initialize the input class */
 572         hdaps_idev.dev = &pdev->dev;
 573         input_register_device(&hdaps_idev);
 574
 575         /* start up our timer for the input device */
 576         init_timer(&hdaps_timer);
 577         hdaps_timer.function = hdaps_mousedev_poll;
 578         hdaps_timer.expires = jiffies + HDAPS_POLL_PERIOD;
 579         add_timer(&hdaps_timer);
 580
 581         printk(KERN_INFO "hdaps: driver successfully loaded.\n");
 582         return 0;
 583
 584 out_device:
 585         platform_device_unregister(pdev);
 586 out_driver:
 587         platform_driver_unregister(&hdaps_driver);
 588 out_region:
 589         release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
 590 out:
 591         printk(KERN_WARNING "hdaps: driver init failed (ret=%d)!\n", ret);
 592         return ret;
 593 }
 594
 595 static void __exit hdaps_exit(void)
 596 {
 597         del_timer_sync(&hdaps_timer);
 598         input_unregister_device(&hdaps_idev);
 599         sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
 600         platform_device_unregister(pdev);
 601         platform_driver_unregister(&hdaps_driver);
 602         release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
 603
 604         printk(KERN_INFO "hdaps: driver unloaded.\n");
 605 }
 606
 607 module_init(hdaps_init);
 608 module_exit(hdaps_exit);
 609
 610 module_param_named(invert, hdaps_invert, bool, 0);
 611 MODULE_PARM_DESC(invert, "invert data along each axis");
 612
 613 MODULE_AUTHOR("Robert Love");
 614 MODULE_DESCRIPTION("IBM Hard Drive Active Protection System (HDAPS) driver");
 615 MODULE_LICENSE("GPL v2");