tp_smapi/hdaps.c

   1 /*
   2  * drivers/platform/x86/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 <linux/jiffies.h>
  37 #include "thinkpad_ec.h"
  38 #include <linux/pci_ids.h>
  39 #include <linux/version.h>
  40
  41 /* Embedded controller accelerometer read command and its result: */
  42 static const struct thinkpad_ec_row ec_accel_args =
  43         { .mask = 0x0001, .val = {0x11} };
  44 #define EC_ACCEL_IDX_READOUTS   0x1     /* readouts included in this read */
  45                                         /* First readout, if READOUTS>=1: */
  46 #define EC_ACCEL_IDX_YPOS1      0x2     /*   y-axis position word */
  47 #define EC_ACCEL_IDX_XPOS1      0x4     /*   x-axis position word */
  48 #define EC_ACCEL_IDX_TEMP1      0x6     /*   device temperature in Celsius */
  49                                         /* Second readout, if READOUTS>=2: */
  50 #define EC_ACCEL_IDX_XPOS2      0x7     /*   y-axis position word */
  51 #define EC_ACCEL_IDX_YPOS2      0x9     /*   x-axis position word */
  52 #define EC_ACCEL_IDX_TEMP2      0xb     /*   device temperature in Celsius */
  53 #define EC_ACCEL_IDX_QUEUED     0xc     /* Number of queued readouts left */
  54 #define EC_ACCEL_IDX_KMACT      0xd     /* keyboard or mouse activity */
  55 #define EC_ACCEL_IDX_RETVAL     0xf     /* command return value, good=0x00 */
  56
  57 #define KEYBD_MASK              0x20    /* set if keyboard activity */
  58 #define MOUSE_MASK              0x40    /* set if mouse activity */
  59
  60 #define READ_TIMEOUT_MSECS      100     /* wait this long for device read */
  61 #define RETRY_MSECS             3       /* retry delay */
  62
  63 #define HDAPS_INPUT_FUZZ        4       /* input event threshold */
  64 #define HDAPS_INPUT_FLAT        4
  65 #define KMACT_REMEMBER_PERIOD   (HZ/10) /* keyboard/mouse persistance */
  66
  67 /* Input IDs */
  68 #define HDAPS_INPUT_VENDOR      PCI_VENDOR_ID_IBM
  69 #define HDAPS_INPUT_PRODUCT     0x5054 /* "TP", shared with thinkpad_acpi */
  70 #define HDAPS_INPUT_JS_VERSION  0x6801 /* Joystick emulation input device */
  71 #define HDAPS_INPUT_RAW_VERSION 0x4801 /* Raw accelerometer input device */
  72
  73 /* Axis orientation. */
  74 /* The unnatural bit-representation of inversions is for backward
  75  * compatibility with the"invert=1" module parameter.             */
  76 #define HDAPS_ORIENT_INVERT_XY  0x01   /* Invert both X and Y axes.       */
  77 #define HDAPS_ORIENT_INVERT_X   0x02   /* Invert the X axis (uninvert if
  78                                         * already inverted by INVERT_XY). */
  79 #define HDAPS_ORIENT_SWAP       0x04   /* Swap the axes. The swap occurs
  80                                         * before inverting X or Y.        */
  81 #define HDAPS_ORIENT_MAX        0x07
  82 #define HDAPS_ORIENT_UNDEFINED  0xFF   /* Placeholder during initialization */
  83 #define HDAPS_ORIENT_INVERT_Y   (HDAPS_ORIENT_INVERT_XY | HDAPS_ORIENT_INVERT_X)
  84
  85 static struct timer_list hdaps_timer;
  86 static struct platform_device *pdev;
  87 static struct input_dev *hdaps_idev;     /* joystick-like device with fuzz */
  88 static struct input_dev *hdaps_idev_raw; /* raw hdaps sensor readouts */
  89 static unsigned int hdaps_invert = HDAPS_ORIENT_UNDEFINED;
  90 static int needs_calibration;
  91
  92 /* Configuration: */
  93 static int sampling_rate = 50;       /* Sampling rate  */
  94 static int oversampling_ratio = 5;   /* Ratio between our sampling rate and
  95                                       * EC accelerometer sampling rate      */
  96 static int running_avg_filter_order = 2; /* EC running average filter order */
  97
  98 /* Latest state readout: */
  99 static int pos_x, pos_y;      /* position */
 100 static int temperature;       /* temperature */
 101 static int stale_readout = 1; /* last read invalid */
 102 static int rest_x, rest_y;    /* calibrated rest position */
 103
 104 /* Last time we saw keyboard and mouse activity: */
 105 static u64 last_keyboard_jiffies = INITIAL_JIFFIES;
 106 static u64 last_mouse_jiffies = INITIAL_JIFFIES;
 107 static u64 last_update_jiffies = INITIAL_JIFFIES;
 108
 109 /* input device use count */
 110 static int hdaps_users;
 111 static DEFINE_MUTEX(hdaps_users_mtx);
 112
 113 /* Some models require an axis transformation to the standard representation */
 114 static void transform_axes(int *x, int *y)
 115 {
 116         if (hdaps_invert & HDAPS_ORIENT_SWAP) {
 117                 int z;
 118                 z = *x;
 119                 *x = *y;
 120                 *y = z;
 121         }
 122         if (hdaps_invert & HDAPS_ORIENT_INVERT_XY) {
 123                 *x = -*x;
 124                 *y = -*y;
 125         }
 126         if (hdaps_invert & HDAPS_ORIENT_INVERT_X)
 127                 *x = -*x;
 128 }
 129
 130 /**
 131  * __hdaps_update - query current state, with locks already acquired
 132  * @fast: if nonzero, do one quick attempt without retries.
 133  *
 134  * Query current accelerometer state and update global state variables.
 135  * Also prefetches the next query. Caller must hold controller lock.
 136  */
 137 static int __hdaps_update(int fast)
 138 {
 139         /* Read data: */
 140         struct thinkpad_ec_row data;
 141         int ret;
 142
 143         data.mask = (1 << EC_ACCEL_IDX_READOUTS) | (1 << EC_ACCEL_IDX_KMACT) |
 144                     (3 << EC_ACCEL_IDX_YPOS1)    | (3 << EC_ACCEL_IDX_XPOS1) |
 145                     (1 << EC_ACCEL_IDX_TEMP1)    | (1 << EC_ACCEL_IDX_RETVAL);
 146         if (fast)
 147                 ret = thinkpad_ec_try_read_row(&ec_accel_args, &data);
 148         else
 149                 ret = thinkpad_ec_read_row(&ec_accel_args, &data);
 150         thinkpad_ec_prefetch_row(&ec_accel_args); /* Prefetch even if error */
 151         if (ret)
 152                 return ret;
 153
 154         /* Check status: */
 155         if (data.val[EC_ACCEL_IDX_RETVAL] != 0x00) {
 156                 printk(KERN_WARNING "hdaps: read RETVAL=0x%02x\n",
 157                        data.val[EC_ACCEL_IDX_RETVAL]);
 158                 return -EIO;
 159         }
 160
 161         if (data.val[EC_ACCEL_IDX_READOUTS] < 1)
 162                 return -EBUSY; /* no pending readout, try again later */
 163
 164         /* Parse position data: */
 165         pos_x = *(s16 *)(data.val+EC_ACCEL_IDX_XPOS1);
 166         pos_y = *(s16 *)(data.val+EC_ACCEL_IDX_YPOS1);
 167         transform_axes(&pos_x, &pos_y);
 168
 169         /* Keyboard and mouse activity status is cleared as soon as it's read,
 170          * so applications will eat each other's events. Thus we remember any
 171          * event for KMACT_REMEMBER_PERIOD jiffies.
 172          */
 173         if (data.val[EC_ACCEL_IDX_KMACT] & KEYBD_MASK)
 174                 last_keyboard_jiffies = get_jiffies_64();
 175         if (data.val[EC_ACCEL_IDX_KMACT] & MOUSE_MASK)
 176                 last_mouse_jiffies = get_jiffies_64();
 177
 178         temperature = data.val[EC_ACCEL_IDX_TEMP1];
 179
 180         last_update_jiffies = get_jiffies_64();
 181         stale_readout = 0;
 182         if (needs_calibration) {
 183                 rest_x = pos_x;
 184                 rest_y = pos_y;
 185                 needs_calibration = 0;
 186         }
 187
 188         return 0;
 189 }
 190
 191 /**
 192  * hdaps_update - acquire locks and query current state
 193  *
 194  * Query current accelerometer state and update global state variables.
 195  * Also prefetches the next query.
 196  * Retries until timeout if the accelerometer is not in ready status (common).
 197  * Does its own locking.
 198  */
 199 static int hdaps_update(void)
 200 {
 201         u64 age = get_jiffies_64() - last_update_jiffies;
 202         int total, ret;
 203
 204         if (!stale_readout && age < (9*HZ)/(10*sampling_rate))
 205                 return 0; /* already updated recently */
 206         for (total = 0; total < READ_TIMEOUT_MSECS; total += RETRY_MSECS) {
 207                 ret = thinkpad_ec_lock();
 208                 if (ret)
 209                         return ret;
 210                 ret = __hdaps_update(0);
 211                 thinkpad_ec_unlock();
 212
 213                 if (!ret)
 214                         return 0;
 215                 if (ret != -EBUSY)
 216                         break;
 217                 msleep(RETRY_MSECS);
 218         }
 219         return ret;
 220 }
 221
 222 /**
 223  * hdaps_set_power - enable or disable power to the accelerometer.
 224  * Returns zero on success and negative error code on failure.  Can sleep.
 225  */
 226 static int hdaps_set_power(int on)
 227 {
 228         struct thinkpad_ec_row args =
 229                 { .mask = 0x0003, .val = {0x14, on?0x01:0x00} };
 230         struct thinkpad_ec_row data = { .mask = 0x8000 };
 231         int ret = thinkpad_ec_read_row(&args, &data);
 232         if (ret)
 233                 return ret;
 234         if (data.val[0xF] != 0x00)
 235                 return -EIO;
 236         return 0;
 237 }
 238
 239 /**
 240  * hdaps_set_ec_config - set accelerometer parameters.
 241  * @ec_rate: embedded controller sampling rate
 242  * @order: embedded controller running average filter order
 243  * (Normally we have @ec_rate = sampling_rate * oversampling_ratio.)
 244  * Returns zero on success and negative error code on failure.  Can sleep.
 245  */
 246 static int hdaps_set_ec_config(int ec_rate, int order)
 247 {
 248         struct thinkpad_ec_row args = { .mask = 0x000F,
 249                 .val = {0x10, (u8)ec_rate, (u8)(ec_rate>>8), order} };
 250         struct thinkpad_ec_row data = { .mask = 0x8000 };
 251         int ret = thinkpad_ec_read_row(&args, &data);
 252         printk(KERN_DEBUG "hdaps: setting ec_rate=%d, filter_order=%d\n",
 253                ec_rate, order);
 254         if (ret)
 255                 return ret;
 256         if (data.val[0xF] == 0x03) {
 257                 printk(KERN_WARNING "hdaps: config param out of range\n");
 258                 return -EINVAL;
 259         }
 260         if (data.val[0xF] == 0x06) {
 261                 printk(KERN_WARNING "hdaps: config change already pending\n");
 262                 return -EBUSY;
 263         }
 264         if (data.val[0xF] != 0x00) {
 265                 printk(KERN_WARNING "hdaps: config change error, ret=%d\n",
 266                       data.val[0xF]);
 267                 return -EIO;
 268         }
 269         return 0;
 270 }
 271
 272 /**
 273  * hdaps_get_ec_config - get accelerometer parameters.
 274  * @ec_rate: embedded controller sampling rate
 275  * @order: embedded controller running average filter order
 276  * Returns zero on success and negative error code on failure.  Can sleep.
 277  */
 278 static int hdaps_get_ec_config(int *ec_rate, int *order)
 279 {
 280         const struct thinkpad_ec_row args =
 281                 { .mask = 0x0003, .val = {0x17, 0x82} };
 282         struct thinkpad_ec_row data = { .mask = 0x801F };
 283         int ret = thinkpad_ec_read_row(&args, &data);
 284         if (ret)
 285                 return ret;
 286         if (data.val[0xF] != 0x00)
 287                 return -EIO;
 288         if (!(data.val[0x1] & 0x01))
 289                 return -ENXIO; /* accelerometer polling not enabled */
 290         if (data.val[0x1] & 0x02)
 291                 return -EBUSY; /* config change in progress, retry later */
 292         *ec_rate = data.val[0x2] | ((int)(data.val[0x3]) << 8);
 293         *order = data.val[0x4];
 294         return 0;
 295 }
 296
 297 /**
 298  * hdaps_get_ec_mode - get EC accelerometer mode
 299  * Returns zero on success and negative error code on failure.  Can sleep.
 300  */
 301 static int hdaps_get_ec_mode(u8 *mode)
 302 {
 303         const struct thinkpad_ec_row args =
 304                 { .mask = 0x0001, .val = {0x13} };
 305         struct thinkpad_ec_row data = { .mask = 0x8002 };
 306         int ret = thinkpad_ec_read_row(&args, &data);
 307         if (ret)
 308                 return ret;
 309         if (data.val[0xF] != 0x00) {
 310                 printk(KERN_WARNING
 311                        "accelerometer not implemented (0x%02x)\n",
 312                        data.val[0xF]);
 313                 return -EIO;
 314         }
 315         *mode = data.val[0x1];
 316         return 0;
 317 }
 318
 319 /**
 320  * hdaps_check_ec - checks something about the EC.
 321  * Follows the clean-room spec for HDAPS; we don't know what it means.
 322  * Returns zero on success and negative error code on failure.  Can sleep.
 323  */
 324 static int hdaps_check_ec(void)
 325 {
 326         const struct thinkpad_ec_row args =
 327                 { .mask = 0x0003, .val = {0x17, 0x81} };
 328         struct thinkpad_ec_row data = { .mask = 0x800E };
 329         int ret = thinkpad_ec_read_row(&args, &data);
 330         if (ret)
 331                 return  ret;
 332         if (!((data.val[0x1] == 0x00 && data.val[0x2] == 0x60) || /* cleanroom spec */
 333               (data.val[0x1] == 0x01 && data.val[0x2] == 0x00)) || /* seen on T61 */
 334             data.val[0x3] != 0x00 || data.val[0xF] != 0x00) {
 335                 printk(KERN_WARNING
 336                        "hdaps_check_ec: bad response (0x%x,0x%x,0x%x,0x%x)\n",
 337                        data.val[0x1], data.val[0x2],
 338                        data.val[0x3], data.val[0xF]);
 339                 return -EIO;
 340         }
 341         return 0;
 342 }
 343
 344 /**
 345  * hdaps_device_init - initialize the accelerometer.
 346  *
 347  * Call several embedded controller functions to test and initialize the
 348  * accelerometer.
 349  * Returns zero on success and negative error code on failure. Can sleep.
 350  */
 351 #define FAILED_INIT(msg) printk(KERN_ERR "hdaps init failed at: %s\n", msg)
 352 static int hdaps_device_init(void)
 353 {
 354         int ret;
 355         u8 mode;
 356
 357         ret = thinkpad_ec_lock();
 358         if (ret)
 359                 return ret;
 360
 361         if (hdaps_get_ec_mode(&mode))
 362                 { FAILED_INIT("hdaps_get_ec_mode failed"); goto bad; }
 363
 364         printk(KERN_DEBUG "hdaps: initial mode latch is 0x%02x\n", mode);
 365         if (mode == 0x00)
 366                 { FAILED_INIT("accelerometer not available"); goto bad; }
 367
 368         if (hdaps_check_ec())
 369                 { FAILED_INIT("hdaps_check_ec failed"); goto bad; }
 370
 371         if (hdaps_set_power(1))
 372                 { FAILED_INIT("hdaps_set_power failed"); goto bad; }
 373
 374         if (hdaps_set_ec_config(sampling_rate*oversampling_ratio,
 375                                 running_avg_filter_order))
 376                 { FAILED_INIT("hdaps_set_ec_config failed"); goto bad; }
 377
 378         thinkpad_ec_invalidate();
 379         udelay(200);
 380
 381         /* Just prefetch instead of reading, to avoid ~1sec delay on load */
 382         ret = thinkpad_ec_prefetch_row(&ec_accel_args);
 383         if (ret)
 384                 { FAILED_INIT("initial prefetch failed"); goto bad; }
 385         goto good;
 386 bad:
 387         thinkpad_ec_invalidate();
 388         ret = -ENXIO;
 389 good:
 390         stale_readout = 1;
 391         thinkpad_ec_unlock();
 392         return ret;
 393 }
 394
 395 /**
 396  * hdaps_device_shutdown - power off the accelerometer
 397  * Returns nonzero on failure. Can sleep.
 398  */
 399 static int hdaps_device_shutdown(void)
 400 {
 401         int ret;
 402         ret = hdaps_set_power(0);
 403         if (ret) {
 404                 printk(KERN_WARNING "hdaps: cannot power off\n");
 405                 return ret;
 406         }
 407         ret = hdaps_set_ec_config(0, 1);
 408         if (ret)
 409                 printk(KERN_WARNING "hdaps: cannot stop EC sampling\n");
 410         return ret;
 411 }
 412
 413 /* Device model stuff */
 414
 415 static int hdaps_probe(struct platform_device *dev)
 416 {
 417         int ret;
 418
 419         ret = hdaps_device_init();
 420         if (ret)
 421                 return ret;
 422
 423         printk(KERN_INFO "hdaps: device successfully initialized.\n");
 424         return 0;
 425 }
 426
 427 static int hdaps_suspend(struct platform_device *dev, pm_message_t state)
 428 {
 429         /* Don't do hdaps polls until resume re-initializes the sensor. */
 430         del_timer_sync(&hdaps_timer);
 431         hdaps_device_shutdown(); /* ignore errors, effect is negligible */
 432         return 0;
 433 }
 434
 435 static int hdaps_resume(struct platform_device *dev)
 436 {
 437         int ret = hdaps_device_init();
 438         if (ret)
 439                 return ret;
 440
 441         mutex_lock(&hdaps_users_mtx);
 442         if (hdaps_users)
 443                 mod_timer(&hdaps_timer, jiffies + HZ/sampling_rate);
 444         mutex_unlock(&hdaps_users_mtx);
 445         return 0;
 446 }
 447
 448 static struct platform_driver hdaps_driver = {
 449         .probe = hdaps_probe,
 450         .suspend = hdaps_suspend,
 451         .resume = hdaps_resume,
 452         .driver = {
 453                 .name = "hdaps",
 454                 .owner = THIS_MODULE,
 455         },
 456 };
 457
 458 /**
 459  * hdaps_calibrate - set our "resting" values.
 460  * Does its own locking.
 461  */
 462 static void hdaps_calibrate(void)
 463 {
 464         needs_calibration = 1;
 465         hdaps_update();
 466         /* If that fails, the mousedev poll will take care of things later. */
 467 }
 468
 469 /* Timer handler for updating the input device. Runs in softirq context,
 470  * so avoid lenghty or blocking operations.
 471  */
 472 static void hdaps_mousedev_poll(unsigned long unused)
 473 {
 474         int ret;
 475
 476         stale_readout = 1;
 477
 478         /* Cannot sleep.  Try nonblockingly.  If we fail, try again later. */
 479         if (thinkpad_ec_try_lock())
 480                 goto keep_active;
 481
 482         ret = __hdaps_update(1); /* fast update, we're in softirq context */
 483         thinkpad_ec_unlock();
 484         /* Any of "successful", "not yet ready" and "not prefetched"? */
 485         if (ret != 0 && ret != -EBUSY && ret != -ENODATA) {
 486                 printk(KERN_ERR
 487                        "hdaps: poll failed, disabling updates\n");
 488                 return;
 489         }
 490
 491 keep_active:
 492         /* Even if we failed now, pos_x,y may have been updated earlier: */
 493         input_report_abs(hdaps_idev, ABS_X, pos_x - rest_x);
 494         input_report_abs(hdaps_idev, ABS_Y, pos_y - rest_y);
 495         input_sync(hdaps_idev);
 496         input_report_abs(hdaps_idev_raw, ABS_X, pos_x);
 497         input_report_abs(hdaps_idev_raw, ABS_Y, pos_y);
 498         input_sync(hdaps_idev_raw);
 499         mod_timer(&hdaps_timer, jiffies + HZ/sampling_rate);
 500 }
 501
 502
 503 /* Sysfs Files */
 504
 505 static ssize_t hdaps_position_show(struct device *dev,
 506                                    struct device_attribute *attr, char *buf)
 507 {
 508         int ret = hdaps_update();
 509         if (ret)
 510                 return ret;
 511         return sprintf(buf, "(%d,%d)\n", pos_x, pos_y);
 512 }
 513
 514 static ssize_t hdaps_temp1_show(struct device *dev,
 515                                 struct device_attribute *attr, char *buf)
 516 {
 517         int ret = hdaps_update();
 518         if (ret)
 519                 return ret;
 520         return sprintf(buf, "%d\n", temperature);
 521 }
 522
 523 static ssize_t hdaps_keyboard_activity_show(struct device *dev,
 524                                             struct device_attribute *attr,
 525                                             char *buf)
 526 {
 527         int ret = hdaps_update();
 528         if (ret)
 529                 return ret;
 530         return sprintf(buf, "%u\n",
 531            get_jiffies_64() < last_keyboard_jiffies + KMACT_REMEMBER_PERIOD);
 532 }
 533
 534 static ssize_t hdaps_mouse_activity_show(struct device *dev,
 535                                          struct device_attribute *attr,
 536                                          char *buf)
 537 {
 538         int ret = hdaps_update();
 539         if (ret)
 540                 return ret;
 541         return sprintf(buf, "%u\n",
 542            get_jiffies_64() < last_mouse_jiffies + KMACT_REMEMBER_PERIOD);
 543 }
 544
 545 static ssize_t hdaps_calibrate_show(struct device *dev,
 546                                     struct device_attribute *attr, char *buf)
 547 {
 548         return sprintf(buf, "(%d,%d)\n", rest_x, rest_y);
 549 }
 550
 551 static ssize_t hdaps_calibrate_store(struct device *dev,
 552                                      struct device_attribute *attr,
 553                                      const char *buf, size_t count)
 554 {
 555         hdaps_calibrate();
 556         return count;
 557 }
 558
 559 static ssize_t hdaps_invert_show(struct device *dev,
 560                                  struct device_attribute *attr, char *buf)
 561 {
 562         return sprintf(buf, "%u\n", hdaps_invert);
 563 }
 564
 565 static ssize_t hdaps_invert_store(struct device *dev,
 566                                   struct device_attribute *attr,
 567                                   const char *buf, size_t count)
 568 {
 569         int invert;
 570
 571         if (sscanf(buf, "%d", &invert) != 1 ||
 572             invert < 0 || invert > HDAPS_ORIENT_MAX)
 573                 return -EINVAL;
 574
 575         hdaps_invert = invert;
 576         hdaps_calibrate();
 577
 578         return count;
 579 }
 580
 581 static ssize_t hdaps_sampling_rate_show(
 582         struct device *dev, struct device_attribute *attr, char *buf)
 583 {
 584         return sprintf(buf, "%d\n", sampling_rate);
 585 }
 586
 587 static ssize_t hdaps_sampling_rate_store(
 588         struct device *dev, struct device_attribute *attr,
 589         const char *buf, size_t count)
 590 {
 591         int rate, ret;
 592         if (sscanf(buf, "%d", &rate) != 1 || rate > HZ || rate <= 0) {
 593                 printk(KERN_WARNING
 594                        "must have 0<input_sampling_rate<=HZ=%d\n", HZ);
 595                 return -EINVAL;
 596         }
 597         ret = hdaps_set_ec_config(rate*oversampling_ratio,
 598                                   running_avg_filter_order);
 599         if (ret)
 600                 return ret;
 601         sampling_rate = rate;
 602         return count;
 603 }
 604
 605 static ssize_t hdaps_oversampling_ratio_show(
 606         struct device *dev, struct device_attribute *attr, char *buf)
 607 {
 608         int ec_rate, order;
 609         int ret = hdaps_get_ec_config(&ec_rate, &order);
 610         if (ret)
 611                 return ret;
 612         return sprintf(buf, "%u\n", ec_rate / sampling_rate);
 613 }
 614
 615 static ssize_t hdaps_oversampling_ratio_store(
 616         struct device *dev, struct device_attribute *attr,
 617         const char *buf, size_t count)
 618 {
 619         int ratio, ret;
 620         if (sscanf(buf, "%d", &ratio) != 1 || ratio < 1)
 621                 return -EINVAL;
 622         ret = hdaps_set_ec_config(sampling_rate*ratio,
 623                                   running_avg_filter_order);
 624         if (ret)
 625                 return ret;
 626         oversampling_ratio = ratio;
 627         return count;
 628 }
 629
 630 static ssize_t hdaps_running_avg_filter_order_show(
 631         struct device *dev, struct device_attribute *attr, char *buf)
 632 {
 633         int rate, order;
 634         int ret = hdaps_get_ec_config(&rate, &order);
 635         if (ret)
 636                 return ret;
 637         return sprintf(buf, "%u\n", order);
 638 }
 639
 640 static ssize_t hdaps_running_avg_filter_order_store(
 641         struct device *dev, struct device_attribute *attr,
 642         const char *buf, size_t count)
 643 {
 644         int order, ret;
 645         if (sscanf(buf, "%d", &order) != 1)
 646                 return -EINVAL;
 647         ret = hdaps_set_ec_config(sampling_rate*oversampling_ratio, order);
 648         if (ret)
 649                 return ret;
 650         running_avg_filter_order = order;
 651         return count;
 652 }
 653
 654 static int hdaps_mousedev_open(struct input_dev *dev)
 655 {
 656         if (!try_module_get(THIS_MODULE))
 657                 return -ENODEV;
 658
 659         mutex_lock(&hdaps_users_mtx);
 660         if (hdaps_users++ == 0) /* first input user */
 661                 mod_timer(&hdaps_timer, jiffies + HZ/sampling_rate);
 662         mutex_unlock(&hdaps_users_mtx);
 663         return 0;
 664 }
 665
 666 static void hdaps_mousedev_close(struct input_dev *dev)
 667 {
 668         mutex_lock(&hdaps_users_mtx);
 669         if (--hdaps_users == 0) /* no input users left */
 670                 del_timer_sync(&hdaps_timer);
 671         mutex_unlock(&hdaps_users_mtx);
 672
 673         module_put(THIS_MODULE);
 674 }
 675
 676 static DEVICE_ATTR(position, 0444, hdaps_position_show, NULL);
 677 static DEVICE_ATTR(temp1, 0444, hdaps_temp1_show, NULL);
 678   /* "temp1" instead of "temperature" is hwmon convention */
 679 static DEVICE_ATTR(keyboard_activity, 0444,
 680                    hdaps_keyboard_activity_show, NULL);
 681 static DEVICE_ATTR(mouse_activity, 0444, hdaps_mouse_activity_show, NULL);
 682 static DEVICE_ATTR(calibrate, 0644,
 683                    hdaps_calibrate_show, hdaps_calibrate_store);
 684 static DEVICE_ATTR(invert, 0644, hdaps_invert_show, hdaps_invert_store);
 685 static DEVICE_ATTR(sampling_rate, 0644,
 686                    hdaps_sampling_rate_show, hdaps_sampling_rate_store);
 687 static DEVICE_ATTR(oversampling_ratio, 0644,
 688                    hdaps_oversampling_ratio_show,
 689                    hdaps_oversampling_ratio_store);
 690 static DEVICE_ATTR(running_avg_filter_order, 0644,
 691                    hdaps_running_avg_filter_order_show,
 692                    hdaps_running_avg_filter_order_store);
 693
 694 static struct attribute *hdaps_attributes[] = {
 695         &dev_attr_position.attr,
 696         &dev_attr_temp1.attr,
 697         &dev_attr_keyboard_activity.attr,
 698         &dev_attr_mouse_activity.attr,
 699         &dev_attr_calibrate.attr,
 700         &dev_attr_invert.attr,
 701         &dev_attr_sampling_rate.attr,
 702         &dev_attr_oversampling_ratio.attr,
 703         &dev_attr_running_avg_filter_order.attr,
 704         NULL,
 705 };
 706
 707 static struct attribute_group hdaps_attribute_group = {
 708         .attrs = hdaps_attributes,
 709 };
 710
 711
 712 /* Module stuff */
 713
 714 /* hdaps_dmi_match_invert - found an inverted match. */
 715 static int __init hdaps_dmi_match_invert(const struct dmi_system_id *id)
 716 {
 717         unsigned int orient = (kernel_ulong_t) id->driver_data;
 718         hdaps_invert = orient;
 719         printk(KERN_INFO "hdaps: %s detected, setting orientation %u\n",
 720                id->ident, orient);
 721         return 1; /* stop enumeration */
 722 }
 723
 724 #define HDAPS_DMI_MATCH_INVERT(vendor, model, orient) { \
 725         .ident = vendor " " model,                      \
 726         .callback = hdaps_dmi_match_invert,             \
 727         .driver_data = (void *)(orient),                \
 728         .matches = {                                    \
 729                 DMI_MATCH(DMI_BOARD_VENDOR, vendor),    \
 730                 DMI_MATCH(DMI_PRODUCT_VERSION, model)   \
 731         }                                               \
 732 }
 733
 734 /* List of models with abnormal axis configuration.
 735    Note that HDAPS_DMI_MATCH_NORMAL("ThinkPad T42") would match
 736    "ThinkPad T42p", and enumeration stops after first match,
 737    so the order of the entries matters. */
 738 struct dmi_system_id __initdata hdaps_whitelist[] = {
 739         HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad R50p", HDAPS_ORIENT_INVERT_XY),
 740         HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad R60", HDAPS_ORIENT_INVERT_XY),
 741         HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T41p", HDAPS_ORIENT_INVERT_XY),
 742         HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T42p", HDAPS_ORIENT_INVERT_XY),
 743         HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad X40", HDAPS_ORIENT_INVERT_Y),
 744         HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad X41", HDAPS_ORIENT_INVERT_Y),
 745         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R60", HDAPS_ORIENT_INVERT_XY),
 746         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R61", HDAPS_ORIENT_INVERT_XY),
 747         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T60", HDAPS_ORIENT_INVERT_XY),
 748         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61", HDAPS_ORIENT_INVERT_XY),
 749         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X60 Tablet", HDAPS_ORIENT_INVERT_Y),
 750         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X60s", HDAPS_ORIENT_INVERT_Y),
 751         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X60", HDAPS_ORIENT_SWAP | HDAPS_ORIENT_INVERT_X),
 752         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61", HDAPS_ORIENT_SWAP | HDAPS_ORIENT_INVERT_X),
 753         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T400s", HDAPS_ORIENT_INVERT_X),
 754         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T400", HDAPS_ORIENT_INVERT_XY),
 755         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T410s", HDAPS_ORIENT_SWAP),
 756         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T410", HDAPS_ORIENT_INVERT_XY),
 757         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T500", HDAPS_ORIENT_INVERT_XY),
 758         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad W51O", HDAPS_ORIENT_MAX),
 759         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X200", HDAPS_ORIENT_SWAP | HDAPS_ORIENT_INVERT_X | HDAPS_ORIENT_INVERT_Y),
 760         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X201 Tablet", HDAPS_ORIENT_SWAP | HDAPS_ORIENT_INVERT_XY),
 761         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X201s", HDAPS_ORIENT_SWAP | HDAPS_ORIENT_INVERT_XY),
 762         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X201", HDAPS_ORIENT_SWAP | HDAPS_ORIENT_INVERT_X),
 763         HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X220", HDAPS_ORIENT_SWAP),
 764         { .ident = NULL }
 765 };
 766
 767 static int __init hdaps_init(void)
 768 {
 769         int ret;
 770
 771         /* Determine axis orientation orientation */
 772         if (hdaps_invert == HDAPS_ORIENT_UNDEFINED) /* set by module param? */
 773                 if (dmi_check_system(hdaps_whitelist) < 1) /* in whitelist? */
 774                         hdaps_invert = 0; /* default */
 775
 776         /* Init timer before platform_driver_register, in case of suspend */
 777         init_timer(&hdaps_timer);
 778         hdaps_timer.function = hdaps_mousedev_poll;
 779         ret = platform_driver_register(&hdaps_driver);
 780         if (ret)
 781                 goto out;
 782
 783         pdev = platform_device_register_simple("hdaps", -1, NULL, 0);
 784         if (IS_ERR(pdev)) {
 785                 ret = PTR_ERR(pdev);
 786                 goto out_driver;
 787         }
 788
 789         ret = sysfs_create_group(&pdev->dev.kobj, &hdaps_attribute_group);
 790         if (ret)
 791                 goto out_device;
 792
 793         hdaps_idev = input_allocate_device();
 794         if (!hdaps_idev) {
 795                 ret = -ENOMEM;
 796                 goto out_group;
 797         }
 798
 799         hdaps_idev_raw = input_allocate_device();
 800         if (!hdaps_idev_raw) {
 801                 ret = -ENOMEM;
 802                 goto out_idev_first;
 803         }
 804
 805         /* calibration for the input device (deferred to avoid delay) */
 806         needs_calibration = 1;
 807
 808         /* initialize the joystick-like fuzzed input device */
 809         hdaps_idev->name = "hdaps";
 810         hdaps_idev->phys = "hdaps/input0";
 811         hdaps_idev->id.bustype = BUS_HOST;
 812         hdaps_idev->id.vendor  = HDAPS_INPUT_VENDOR;
 813         hdaps_idev->id.product = HDAPS_INPUT_PRODUCT;
 814         hdaps_idev->id.version = HDAPS_INPUT_JS_VERSION;
 815 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
 816         hdaps_idev->cdev.dev = &pdev->dev;
 817 #endif
 818         hdaps_idev->evbit[0] = BIT(EV_ABS);
 819         hdaps_idev->open = hdaps_mousedev_open;
 820         hdaps_idev->close = hdaps_mousedev_close;
 821         input_set_abs_params(hdaps_idev, ABS_X,
 822                         -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
 823         input_set_abs_params(hdaps_idev, ABS_Y,
 824                         -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
 825
 826         ret = input_register_device(hdaps_idev);
 827         if (ret)
 828                 goto out_idev;
 829
 830         /* initialize the raw data input device */
 831         hdaps_idev_raw->name = "raw_hdaps_data";
 832         hdaps_idev_raw->phys = "hdaps/input1";
 833         hdaps_idev_raw->id.bustype = BUS_HOST;
 834         hdaps_idev_raw->id.vendor  = HDAPS_INPUT_VENDOR;
 835         hdaps_idev_raw->id.product = HDAPS_INPUT_PRODUCT;
 836         hdaps_idev_raw->id.version = HDAPS_INPUT_RAW_VERSION;
 837 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
 838         hdaps_idev_raw->cdev.dev = &pdev->dev;
 839 #endif
 840         hdaps_idev_raw->evbit[0] = BIT(EV_ABS);
 841         hdaps_idev_raw->open = hdaps_mousedev_open;
 842         hdaps_idev_raw->close = hdaps_mousedev_close;
 843         input_set_abs_params(hdaps_idev_raw, ABS_X, -32768, 32767, 0, 0);
 844         input_set_abs_params(hdaps_idev_raw, ABS_Y, -32768, 32767, 0, 0);
 845
 846         ret = input_register_device(hdaps_idev_raw);
 847         if (ret)
 848                 goto out_idev_reg_first;
 849
 850         printk(KERN_INFO "hdaps: driver successfully loaded.\n");
 851         return 0;
 852
 853 out_idev_reg_first:
 854         input_unregister_device(hdaps_idev);
 855 out_idev:
 856         input_free_device(hdaps_idev_raw);
 857 out_idev_first:
 858         input_free_device(hdaps_idev);
 859 out_group:
 860         sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
 861 out_device:
 862         platform_device_unregister(pdev);
 863 out_driver:
 864         platform_driver_unregister(&hdaps_driver);
 865         hdaps_device_shutdown();
 866 out:
 867         printk(KERN_WARNING "hdaps: driver init failed (ret=%d)!\n", ret);
 868         return ret;
 869 }
 870
 871 static void __exit hdaps_exit(void)
 872 {
 873         input_unregister_device(hdaps_idev_raw);
 874         input_unregister_device(hdaps_idev);
 875         hdaps_device_shutdown(); /* ignore errors, effect is negligible */
 876         sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
 877         platform_device_unregister(pdev);
 878         platform_driver_unregister(&hdaps_driver);
 879
 880         printk(KERN_INFO "hdaps: driver unloaded.\n");
 881 }
 882
 883 module_init(hdaps_init);
 884 module_exit(hdaps_exit);
 885
 886 module_param_named(invert, hdaps_invert, uint, 0);
 887 MODULE_PARM_DESC(invert, "axis orientation code");
 888
 889 MODULE_AUTHOR("Robert Love");
 890 MODULE_DESCRIPTION("IBM Hard Drive Active Protection System (HDAPS) driver");
 891 MODULE_LICENSE("GPL v2");