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