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/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 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 device *dev)
 300 {
 301         return hdaps_device_init();
 302 }
 303
 304 static struct device_driver hdaps_driver = {
 305         .name = "hdaps",
 306         .bus = &platform_bus_type,
 307         .owner = THIS_MODULE,
 308         .probe = hdaps_probe,
 309         .resume = hdaps_resume
 310 };
 311
 312 /* Input class stuff */
 313
 314 static struct input_dev hdaps_idev = {
 315         .name = "hdaps",
 316         .evbit = { BIT(EV_ABS) },
 317         .absbit = { BIT(ABS_X) | BIT(ABS_Y) },
 318         .absmin  = { [ABS_X] = -256, [ABS_Y] = -256 },
 319         .absmax  = { [ABS_X] = 256, [ABS_Y] = 256 },
 320         .absfuzz = { [ABS_X] = HDAPS_INPUT_FUZZ, [ABS_Y] = HDAPS_INPUT_FUZZ },
 321         .absflat = { [ABS_X] = HDAPS_INPUT_FUZZ, [ABS_Y] = HDAPS_INPUT_FUZZ },
 322 };
 323
 324 /*
 325  * hdaps_calibrate - Set our "resting" values.  Callers must hold hdaps_sem.
 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(unsigned long unused)
 333 {
 334         int x, y;
 335
 336         /* Cannot sleep.  Try nonblockingly.  If we fail, try again later. */
 337         if (down_trylock(&hdaps_sem)) {
 338                 mod_timer(&hdaps_timer,jiffies + HDAPS_POLL_PERIOD);
 339                 return;
 340         }
 341
 342         if (__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y))
 343                 goto out;
 344
 345         input_report_abs(&hdaps_idev, ABS_X, x - rest_x);
 346         input_report_abs(&hdaps_idev, ABS_Y, y - rest_y);
 347         input_sync(&hdaps_idev);
 348
 349         mod_timer(&hdaps_timer, jiffies + HDAPS_POLL_PERIOD);
 350
 351 out:
 352         up(&hdaps_sem);
 353 }
 354
 355
 356 /* Sysfs Files */
 357
 358 static ssize_t hdaps_position_show(struct device *dev,
 359                                    struct device_attribute *attr, char *buf)
 360 {
 361         int ret, x, y;
 362
 363         ret = hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
 364         if (ret)
 365                 return ret;
 366
 367         return sprintf(buf, "(%d,%d)\n", x, y);
 368 }
 369
 370 static ssize_t hdaps_variance_show(struct device *dev,
 371                                    struct device_attribute *attr, char *buf)
 372 {
 373         int ret, x, y;
 374
 375         ret = hdaps_read_pair(HDAPS_PORT_XVAR, HDAPS_PORT_YVAR, &x, &y);
 376         if (ret)
 377                 return ret;
 378
 379         return sprintf(buf, "(%d,%d)\n", x, y);
 380 }
 381
 382 static ssize_t hdaps_temp1_show(struct device *dev,
 383                                 struct device_attribute *attr, char *buf)
 384 {
 385         u8 temp;
 386         int ret;
 387
 388         ret = hdaps_readb_one(HDAPS_PORT_TEMP1, &temp);
 389         if (ret < 0)
 390                 return ret;
 391
 392         return sprintf(buf, "%u\n", temp);
 393 }
 394
 395 static ssize_t hdaps_temp2_show(struct device *dev,
 396                                 struct device_attribute *attr, char *buf)
 397 {
 398         u8 temp;
 399         int ret;
 400
 401         ret = hdaps_readb_one(HDAPS_PORT_TEMP2, &temp);
 402         if (ret < 0)
 403                 return ret;
 404
 405         return sprintf(buf, "%u\n", temp);
 406 }
 407
 408 static ssize_t hdaps_keyboard_activity_show(struct device *dev,
 409                                             struct device_attribute *attr,
 410                                             char *buf)
 411 {
 412         return sprintf(buf, "%u\n", KEYBD_ISSET(km_activity));
 413 }
 414
 415 static ssize_t hdaps_mouse_activity_show(struct device *dev,
 416                                          struct device_attribute *attr,
 417                                          char *buf)
 418 {
 419         return sprintf(buf, "%u\n", MOUSE_ISSET(km_activity));
 420 }
 421
 422 static ssize_t hdaps_calibrate_show(struct device *dev,
 423                                     struct device_attribute *attr, char *buf)
 424 {
 425         return sprintf(buf, "(%d,%d)\n", rest_x, rest_y);
 426 }
 427
 428 static ssize_t hdaps_calibrate_store(struct device *dev,
 429                                      struct device_attribute *attr,
 430                                      const char *buf, size_t count)
 431 {
 432         down(&hdaps_sem);
 433         hdaps_calibrate();
 434         up(&hdaps_sem);
 435
 436         return count;
 437 }
 438
 439 static ssize_t hdaps_invert_show(struct device *dev,
 440                                  struct device_attribute *attr, char *buf)
 441 {
 442         return sprintf(buf, "%u\n", hdaps_invert);
 443 }
 444
 445 static ssize_t hdaps_invert_store(struct device *dev,
 446                                   struct device_attribute *attr,
 447                                   const char *buf, size_t count)
 448 {
 449         int invert;
 450
 451         if (sscanf(buf, "%d", &invert) != 1 || (invert != 1 && invert != 0))
 452                 return -EINVAL;
 453
 454         hdaps_invert = invert;
 455         hdaps_calibrate();
 456
 457         return count;
 458 }
 459
 460 static DEVICE_ATTR(position, 0444, hdaps_position_show, NULL);
 461 static DEVICE_ATTR(variance, 0444, hdaps_variance_show, NULL);
 462 static DEVICE_ATTR(temp1, 0444, hdaps_temp1_show, NULL);
 463 static DEVICE_ATTR(temp2, 0444, hdaps_temp2_show, NULL);
 464 static DEVICE_ATTR(keyboard_activity, 0444, hdaps_keyboard_activity_show, NULL);
 465 static DEVICE_ATTR(mouse_activity, 0444, hdaps_mouse_activity_show, NULL);
 466 static DEVICE_ATTR(calibrate, 0644, hdaps_calibrate_show,hdaps_calibrate_store);
 467 static DEVICE_ATTR(invert, 0644, hdaps_invert_show, hdaps_invert_store);
 468
 469 static struct attribute *hdaps_attributes[] = {
 470         &dev_attr_position.attr,
 471         &dev_attr_variance.attr,
 472         &dev_attr_temp1.attr,
 473         &dev_attr_temp2.attr,
 474         &dev_attr_keyboard_activity.attr,
 475         &dev_attr_mouse_activity.attr,
 476         &dev_attr_calibrate.attr,
 477         &dev_attr_invert.attr,
 478         NULL,
 479 };
 480
 481 static struct attribute_group hdaps_attribute_group = {
 482         .attrs = hdaps_attributes,
 483 };
 484
 485
 486 /* Module stuff */
 487
 488 /* hdaps_dmi_match - found a match.  return one, short-circuiting the hunt. */
 489 static int hdaps_dmi_match(struct dmi_system_id *id)
 490 {
 491         printk(KERN_INFO "hdaps: %s detected.\n", id->ident);
 492         return 1;
 493 }
 494
 495 /* hdaps_dmi_match_invert - found an inverted match. */
 496 static int hdaps_dmi_match_invert(struct dmi_system_id *id)
 497 {
 498         hdaps_invert = 1;
 499         printk(KERN_INFO "hdaps: inverting axis readings.\n");
 500         return hdaps_dmi_match(id);
 501 }
 502
 503 #define HDAPS_DMI_MATCH_NORMAL(model)   {               \
 504         .ident = "IBM " model,                          \
 505         .callback = hdaps_dmi_match,                    \
 506         .matches = {                                    \
 507                 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"),     \
 508                 DMI_MATCH(DMI_PRODUCT_VERSION, model)   \
 509         }                                               \
 510 }
 511
 512 #define HDAPS_DMI_MATCH_INVERT(model)   {               \
 513         .ident = "IBM " model,                          \
 514         .callback = hdaps_dmi_match_invert,             \
 515         .matches = {                                    \
 516                 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"),     \
 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_INVERT("ThinkPad R50p"),
 528                 HDAPS_DMI_MATCH_NORMAL("ThinkPad R50"),
 529                 HDAPS_DMI_MATCH_NORMAL("ThinkPad R51"),
 530                 HDAPS_DMI_MATCH_NORMAL("ThinkPad R52"),
 531                 HDAPS_DMI_MATCH_INVERT("ThinkPad T41p"),
 532                 HDAPS_DMI_MATCH_NORMAL("ThinkPad T41"),
 533                 HDAPS_DMI_MATCH_INVERT("ThinkPad T42p"),
 534                 HDAPS_DMI_MATCH_NORMAL("ThinkPad T42"),
 535                 HDAPS_DMI_MATCH_NORMAL("ThinkPad T43"),
 536                 HDAPS_DMI_MATCH_NORMAL("ThinkPad X40"),
 537                 HDAPS_DMI_MATCH_NORMAL("ThinkPad X41 Tablet"),
 538                 HDAPS_DMI_MATCH_NORMAL("ThinkPad X41"),
 539                 { .ident = NULL }
 540         };
 541
 542         if (!dmi_check_system(hdaps_whitelist)) {
 543                 printk(KERN_WARNING "hdaps: supported laptop not found!\n");
 544                 ret = -ENXIO;
 545                 goto out;
 546         }
 547
 548         if (!request_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS, "hdaps")) {
 549                 ret = -ENXIO;
 550                 goto out;
 551         }
 552
 553         ret = driver_register(&hdaps_driver);
 554         if (ret)
 555                 goto out_region;
 556
 557         pdev = platform_device_register_simple("hdaps", -1, NULL, 0);
 558         if (IS_ERR(pdev)) {
 559                 ret = PTR_ERR(pdev);
 560                 goto out_driver;
 561         }
 562
 563         ret = sysfs_create_group(&pdev->dev.kobj, &hdaps_attribute_group);
 564         if (ret)
 565                 goto out_device;
 566
 567         /* initial calibrate for the input device */
 568         hdaps_calibrate();
 569
 570         /* initialize the input class */
 571         hdaps_idev.dev = &pdev->dev;
 572         input_register_device(&hdaps_idev);
 573
 574         /* start up our timer for the input device */
 575         init_timer(&hdaps_timer);
 576         hdaps_timer.function = hdaps_mousedev_poll;
 577         hdaps_timer.expires = jiffies + HDAPS_POLL_PERIOD;
 578         add_timer(&hdaps_timer);
 579
 580         printk(KERN_INFO "hdaps: driver successfully loaded.\n");
 581         return 0;
 582
 583 out_device:
 584         platform_device_unregister(pdev);
 585 out_driver:
 586         driver_unregister(&hdaps_driver);
 587 out_region:
 588         release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
 589 out:
 590         printk(KERN_WARNING "hdaps: driver init failed (ret=%d)!\n", ret);
 591         return ret;
 592 }
 593
 594 static void __exit hdaps_exit(void)
 595 {
 596         del_timer_sync(&hdaps_timer);
 597         input_unregister_device(&hdaps_idev);
 598         sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
 599         platform_device_unregister(pdev);
 600         driver_unregister(&hdaps_driver);
 601         release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
 602
 603         printk(KERN_INFO "hdaps: driver unloaded.\n");
 604 }
 605
 606 module_init(hdaps_init);
 607 module_exit(hdaps_exit);
 608
 609 module_param_named(invert, hdaps_invert, bool, 0);
 610 MODULE_PARM_DESC(invert, "invert data along each axis");
 611
 612 MODULE_AUTHOR("Robert Love");
 613 MODULE_DESCRIPTION("IBM Hard Drive Active Protection System (HDAPS) driver");
 614 MODULE_LICENSE("GPL v2");