linux/drivers/hid/hid-ntrig.c
<<
>>
Prefs
   1/*
   2 *  HID driver for N-Trig touchscreens
   3 *
   4 *  Copyright (c) 2008-2010 Rafi Rubin
   5 *  Copyright (c) 2009-2010 Stephane Chatty
   6 *
   7 */
   8
   9/*
  10 * This program is free software; you can redistribute it and/or modify it
  11 * under the terms of the GNU General Public License as published by the Free
  12 * Software Foundation; either version 2 of the License, or (at your option)
  13 * any later version.
  14 */
  15
  16#include <linux/device.h>
  17#include <linux/hid.h>
  18#include <linux/usb.h>
  19#include "usbhid/usbhid.h"
  20#include <linux/module.h>
  21#include <linux/slab.h>
  22
  23#include "hid-ids.h"
  24
  25#define NTRIG_DUPLICATE_USAGES  0x001
  26
  27static unsigned int min_width;
  28module_param(min_width, uint, 0644);
  29MODULE_PARM_DESC(min_width, "Minimum touch contact width to accept.");
  30
  31static unsigned int min_height;
  32module_param(min_height, uint, 0644);
  33MODULE_PARM_DESC(min_height, "Minimum touch contact height to accept.");
  34
  35static unsigned int activate_slack = 1;
  36module_param(activate_slack, uint, 0644);
  37MODULE_PARM_DESC(activate_slack, "Number of touch frames to ignore at "
  38                 "the start of touch input.");
  39
  40static unsigned int deactivate_slack = 4;
  41module_param(deactivate_slack, uint, 0644);
  42MODULE_PARM_DESC(deactivate_slack, "Number of empty frames to ignore before "
  43                 "deactivating touch.");
  44
  45static unsigned int activation_width = 64;
  46module_param(activation_width, uint, 0644);
  47MODULE_PARM_DESC(activation_width, "Width threshold to immediately start "
  48                 "processing touch events.");
  49
  50static unsigned int activation_height = 32;
  51module_param(activation_height, uint, 0644);
  52MODULE_PARM_DESC(activation_height, "Height threshold to immediately start "
  53                 "processing touch events.");
  54
  55struct ntrig_data {
  56        /* Incoming raw values for a single contact */
  57        __u16 x, y, w, h;
  58        __u16 id;
  59
  60        bool tipswitch;
  61        bool confidence;
  62        bool first_contact_touch;
  63
  64        bool reading_mt;
  65
  66        __u8 mt_footer[4];
  67        __u8 mt_foot_count;
  68
  69        /* The current activation state. */
  70        __s8 act_state;
  71
  72        /* Empty frames to ignore before recognizing the end of activity */
  73        __s8 deactivate_slack;
  74
  75        /* Frames to ignore before acknowledging the start of activity */
  76        __s8 activate_slack;
  77
  78        /* Minimum size contact to accept */
  79        __u16 min_width;
  80        __u16 min_height;
  81
  82        /* Threshold to override activation slack */
  83        __u16 activation_width;
  84        __u16 activation_height;
  85
  86        __u16 sensor_logical_width;
  87        __u16 sensor_logical_height;
  88        __u16 sensor_physical_width;
  89        __u16 sensor_physical_height;
  90};
  91
  92
  93/*
  94 * This function converts the 4 byte raw firmware code into
  95 * a string containing 5 comma separated numbers.
  96 */
  97static int ntrig_version_string(unsigned char *raw, char *buf)
  98{
  99        __u8 a =  (raw[1] & 0x0e) >> 1;
 100        __u8 b =  (raw[0] & 0x3c) >> 2;
 101        __u8 c = ((raw[0] & 0x03) << 3) | ((raw[3] & 0xe0) >> 5);
 102        __u8 d = ((raw[3] & 0x07) << 3) | ((raw[2] & 0xe0) >> 5);
 103        __u8 e =   raw[2] & 0x07;
 104
 105        /*
 106         * As yet unmapped bits:
 107         * 0b11000000 0b11110001 0b00011000 0b00011000
 108         */
 109
 110        return sprintf(buf, "%u.%u.%u.%u.%u", a, b, c, d, e);
 111}
 112
 113static inline int ntrig_get_mode(struct hid_device *hdev)
 114{
 115        struct hid_report *report = hdev->report_enum[HID_FEATURE_REPORT].
 116                                    report_id_hash[0x0d];
 117
 118        if (!report)
 119                return -EINVAL;
 120
 121        usbhid_submit_report(hdev, report, USB_DIR_IN);
 122        usbhid_wait_io(hdev);
 123        return (int)report->field[0]->value[0];
 124}
 125
 126static inline void ntrig_set_mode(struct hid_device *hdev, const int mode)
 127{
 128        struct hid_report *report;
 129        __u8 mode_commands[4] = { 0xe, 0xf, 0x1b, 0x10 };
 130
 131        if (mode < 0 || mode > 3)
 132                return;
 133
 134        report = hdev->report_enum[HID_FEATURE_REPORT].
 135                 report_id_hash[mode_commands[mode]];
 136
 137        if (!report)
 138                return;
 139
 140        usbhid_submit_report(hdev, report, USB_DIR_IN);
 141}
 142
 143static void ntrig_report_version(struct hid_device *hdev)
 144{
 145        int ret;
 146        char buf[20];
 147        struct usb_device *usb_dev = hid_to_usb_dev(hdev);
 148        unsigned char *data = kmalloc(8, GFP_KERNEL);
 149
 150        if (!data)
 151                goto err_free;
 152
 153        ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
 154                              USB_REQ_CLEAR_FEATURE,
 155                              USB_TYPE_CLASS | USB_RECIP_INTERFACE |
 156                              USB_DIR_IN,
 157                              0x30c, 1, data, 8,
 158                              USB_CTRL_SET_TIMEOUT);
 159
 160        if (ret == 8) {
 161                ret = ntrig_version_string(&data[2], buf);
 162
 163                hid_info(hdev, "Firmware version: %s (%02x%02x %02x%02x)\n",
 164                         buf, data[2], data[3], data[4], data[5]);
 165        }
 166
 167err_free:
 168        kfree(data);
 169}
 170
 171static ssize_t show_phys_width(struct device *dev,
 172                               struct device_attribute *attr,
 173                               char *buf)
 174{
 175        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 176        struct ntrig_data *nd = hid_get_drvdata(hdev);
 177
 178        return sprintf(buf, "%d\n", nd->sensor_physical_width);
 179}
 180
 181static DEVICE_ATTR(sensor_physical_width, S_IRUGO, show_phys_width, NULL);
 182
 183static ssize_t show_phys_height(struct device *dev,
 184                                struct device_attribute *attr,
 185                                char *buf)
 186{
 187        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 188        struct ntrig_data *nd = hid_get_drvdata(hdev);
 189
 190        return sprintf(buf, "%d\n", nd->sensor_physical_height);
 191}
 192
 193static DEVICE_ATTR(sensor_physical_height, S_IRUGO, show_phys_height, NULL);
 194
 195static ssize_t show_log_width(struct device *dev,
 196                              struct device_attribute *attr,
 197                              char *buf)
 198{
 199        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 200        struct ntrig_data *nd = hid_get_drvdata(hdev);
 201
 202        return sprintf(buf, "%d\n", nd->sensor_logical_width);
 203}
 204
 205static DEVICE_ATTR(sensor_logical_width, S_IRUGO, show_log_width, NULL);
 206
 207static ssize_t show_log_height(struct device *dev,
 208                               struct device_attribute *attr,
 209                               char *buf)
 210{
 211        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 212        struct ntrig_data *nd = hid_get_drvdata(hdev);
 213
 214        return sprintf(buf, "%d\n", nd->sensor_logical_height);
 215}
 216
 217static DEVICE_ATTR(sensor_logical_height, S_IRUGO, show_log_height, NULL);
 218
 219static ssize_t show_min_width(struct device *dev,
 220                              struct device_attribute *attr,
 221                              char *buf)
 222{
 223        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 224        struct ntrig_data *nd = hid_get_drvdata(hdev);
 225
 226        return sprintf(buf, "%d\n", nd->min_width *
 227                                    nd->sensor_physical_width /
 228                                    nd->sensor_logical_width);
 229}
 230
 231static ssize_t set_min_width(struct device *dev,
 232                             struct device_attribute *attr,
 233                             const char *buf, size_t count)
 234{
 235        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 236        struct ntrig_data *nd = hid_get_drvdata(hdev);
 237
 238        unsigned long val;
 239
 240        if (strict_strtoul(buf, 0, &val))
 241                return -EINVAL;
 242
 243        if (val > nd->sensor_physical_width)
 244                return -EINVAL;
 245
 246        nd->min_width = val * nd->sensor_logical_width /
 247                              nd->sensor_physical_width;
 248
 249        return count;
 250}
 251
 252static DEVICE_ATTR(min_width, S_IWUSR | S_IRUGO, show_min_width, set_min_width);
 253
 254static ssize_t show_min_height(struct device *dev,
 255                               struct device_attribute *attr,
 256                               char *buf)
 257{
 258        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 259        struct ntrig_data *nd = hid_get_drvdata(hdev);
 260
 261        return sprintf(buf, "%d\n", nd->min_height *
 262                                    nd->sensor_physical_height /
 263                                    nd->sensor_logical_height);
 264}
 265
 266static ssize_t set_min_height(struct device *dev,
 267                              struct device_attribute *attr,
 268                              const char *buf, size_t count)
 269{
 270        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 271        struct ntrig_data *nd = hid_get_drvdata(hdev);
 272
 273        unsigned long val;
 274
 275        if (strict_strtoul(buf, 0, &val))
 276                return -EINVAL;
 277
 278        if (val > nd->sensor_physical_height)
 279                return -EINVAL;
 280
 281        nd->min_height = val * nd->sensor_logical_height /
 282                               nd->sensor_physical_height;
 283
 284        return count;
 285}
 286
 287static DEVICE_ATTR(min_height, S_IWUSR | S_IRUGO, show_min_height,
 288                   set_min_height);
 289
 290static ssize_t show_activate_slack(struct device *dev,
 291                                   struct device_attribute *attr,
 292                                   char *buf)
 293{
 294        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 295        struct ntrig_data *nd = hid_get_drvdata(hdev);
 296
 297        return sprintf(buf, "%d\n", nd->activate_slack);
 298}
 299
 300static ssize_t set_activate_slack(struct device *dev,
 301                                  struct device_attribute *attr,
 302                                  const char *buf, size_t count)
 303{
 304        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 305        struct ntrig_data *nd = hid_get_drvdata(hdev);
 306
 307        unsigned long val;
 308
 309        if (strict_strtoul(buf, 0, &val))
 310                return -EINVAL;
 311
 312        if (val > 0x7f)
 313                return -EINVAL;
 314
 315        nd->activate_slack = val;
 316
 317        return count;
 318}
 319
 320static DEVICE_ATTR(activate_slack, S_IWUSR | S_IRUGO, show_activate_slack,
 321                   set_activate_slack);
 322
 323static ssize_t show_activation_width(struct device *dev,
 324                                     struct device_attribute *attr,
 325                                     char *buf)
 326{
 327        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 328        struct ntrig_data *nd = hid_get_drvdata(hdev);
 329
 330        return sprintf(buf, "%d\n", nd->activation_width *
 331                                    nd->sensor_physical_width /
 332                                    nd->sensor_logical_width);
 333}
 334
 335static ssize_t set_activation_width(struct device *dev,
 336                                    struct device_attribute *attr,
 337                                    const char *buf, size_t count)
 338{
 339        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 340        struct ntrig_data *nd = hid_get_drvdata(hdev);
 341
 342        unsigned long val;
 343
 344        if (strict_strtoul(buf, 0, &val))
 345                return -EINVAL;
 346
 347        if (val > nd->sensor_physical_width)
 348                return -EINVAL;
 349
 350        nd->activation_width = val * nd->sensor_logical_width /
 351                                     nd->sensor_physical_width;
 352
 353        return count;
 354}
 355
 356static DEVICE_ATTR(activation_width, S_IWUSR | S_IRUGO, show_activation_width,
 357                   set_activation_width);
 358
 359static ssize_t show_activation_height(struct device *dev,
 360                                      struct device_attribute *attr,
 361                                      char *buf)
 362{
 363        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 364        struct ntrig_data *nd = hid_get_drvdata(hdev);
 365
 366        return sprintf(buf, "%d\n", nd->activation_height *
 367                                    nd->sensor_physical_height /
 368                                    nd->sensor_logical_height);
 369}
 370
 371static ssize_t set_activation_height(struct device *dev,
 372                                     struct device_attribute *attr,
 373                                     const char *buf, size_t count)
 374{
 375        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 376        struct ntrig_data *nd = hid_get_drvdata(hdev);
 377
 378        unsigned long val;
 379
 380        if (strict_strtoul(buf, 0, &val))
 381                return -EINVAL;
 382
 383        if (val > nd->sensor_physical_height)
 384                return -EINVAL;
 385
 386        nd->activation_height = val * nd->sensor_logical_height /
 387                                      nd->sensor_physical_height;
 388
 389        return count;
 390}
 391
 392static DEVICE_ATTR(activation_height, S_IWUSR | S_IRUGO,
 393                   show_activation_height, set_activation_height);
 394
 395static ssize_t show_deactivate_slack(struct device *dev,
 396                                     struct device_attribute *attr,
 397                                     char *buf)
 398{
 399        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 400        struct ntrig_data *nd = hid_get_drvdata(hdev);
 401
 402        return sprintf(buf, "%d\n", -nd->deactivate_slack);
 403}
 404
 405static ssize_t set_deactivate_slack(struct device *dev,
 406                                    struct device_attribute *attr,
 407                                    const char *buf, size_t count)
 408{
 409        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 410        struct ntrig_data *nd = hid_get_drvdata(hdev);
 411
 412        unsigned long val;
 413
 414        if (strict_strtoul(buf, 0, &val))
 415                return -EINVAL;
 416
 417        /*
 418         * No more than 8 terminal frames have been observed so far
 419         * and higher slack is highly likely to leave the single
 420         * touch emulation stuck down.
 421         */
 422        if (val > 7)
 423                return -EINVAL;
 424
 425        nd->deactivate_slack = -val;
 426
 427        return count;
 428}
 429
 430static DEVICE_ATTR(deactivate_slack, S_IWUSR | S_IRUGO, show_deactivate_slack,
 431                   set_deactivate_slack);
 432
 433static struct attribute *sysfs_attrs[] = {
 434        &dev_attr_sensor_physical_width.attr,
 435        &dev_attr_sensor_physical_height.attr,
 436        &dev_attr_sensor_logical_width.attr,
 437        &dev_attr_sensor_logical_height.attr,
 438        &dev_attr_min_height.attr,
 439        &dev_attr_min_width.attr,
 440        &dev_attr_activate_slack.attr,
 441        &dev_attr_activation_width.attr,
 442        &dev_attr_activation_height.attr,
 443        &dev_attr_deactivate_slack.attr,
 444        NULL
 445};
 446
 447static struct attribute_group ntrig_attribute_group = {
 448        .attrs = sysfs_attrs
 449};
 450
 451/*
 452 * this driver is aimed at two firmware versions in circulation:
 453 *  - dual pen/finger single touch
 454 *  - finger multitouch, pen not working
 455 */
 456
 457static int ntrig_input_mapping(struct hid_device *hdev, struct hid_input *hi,
 458                               struct hid_field *field, struct hid_usage *usage,
 459                               unsigned long **bit, int *max)
 460{
 461        struct ntrig_data *nd = hid_get_drvdata(hdev);
 462
 463        /* No special mappings needed for the pen and single touch */
 464        if (field->physical)
 465                return 0;
 466
 467        switch (usage->hid & HID_USAGE_PAGE) {
 468        case HID_UP_GENDESK:
 469                switch (usage->hid) {
 470                case HID_GD_X:
 471                        hid_map_usage(hi, usage, bit, max,
 472                                        EV_ABS, ABS_MT_POSITION_X);
 473                        input_set_abs_params(hi->input, ABS_X,
 474                                        field->logical_minimum,
 475                                        field->logical_maximum, 0, 0);
 476
 477                        if (!nd->sensor_logical_width) {
 478                                nd->sensor_logical_width =
 479                                        field->logical_maximum -
 480                                        field->logical_minimum;
 481                                nd->sensor_physical_width =
 482                                        field->physical_maximum -
 483                                        field->physical_minimum;
 484                                nd->activation_width = activation_width *
 485                                        nd->sensor_logical_width /
 486                                        nd->sensor_physical_width;
 487                                nd->min_width = min_width *
 488                                        nd->sensor_logical_width /
 489                                        nd->sensor_physical_width;
 490                        }
 491                        return 1;
 492                case HID_GD_Y:
 493                        hid_map_usage(hi, usage, bit, max,
 494                                        EV_ABS, ABS_MT_POSITION_Y);
 495                        input_set_abs_params(hi->input, ABS_Y,
 496                                        field->logical_minimum,
 497                                        field->logical_maximum, 0, 0);
 498
 499                        if (!nd->sensor_logical_height) {
 500                                nd->sensor_logical_height =
 501                                        field->logical_maximum -
 502                                        field->logical_minimum;
 503                                nd->sensor_physical_height =
 504                                        field->physical_maximum -
 505                                        field->physical_minimum;
 506                                nd->activation_height = activation_height *
 507                                        nd->sensor_logical_height /
 508                                        nd->sensor_physical_height;
 509                                nd->min_height = min_height *
 510                                        nd->sensor_logical_height /
 511                                        nd->sensor_physical_height;
 512                        }
 513                        return 1;
 514                }
 515                return 0;
 516
 517        case HID_UP_DIGITIZER:
 518                switch (usage->hid) {
 519                /* we do not want to map these for now */
 520                case HID_DG_CONTACTID: /* Not trustworthy, squelch for now */
 521                case HID_DG_INPUTMODE:
 522                case HID_DG_DEVICEINDEX:
 523                case HID_DG_CONTACTMAX:
 524                        return -1;
 525
 526                /* width/height mapped on TouchMajor/TouchMinor/Orientation */
 527                case HID_DG_WIDTH:
 528                        hid_map_usage(hi, usage, bit, max,
 529                                      EV_ABS, ABS_MT_TOUCH_MAJOR);
 530                        return 1;
 531                case HID_DG_HEIGHT:
 532                        hid_map_usage(hi, usage, bit, max,
 533                                      EV_ABS, ABS_MT_TOUCH_MINOR);
 534                        input_set_abs_params(hi->input, ABS_MT_ORIENTATION,
 535                                             0, 1, 0, 0);
 536                        return 1;
 537                }
 538                return 0;
 539
 540        case 0xff000000:
 541                /* we do not want to map these: no input-oriented meaning */
 542                return -1;
 543        }
 544
 545        return 0;
 546}
 547
 548static int ntrig_input_mapped(struct hid_device *hdev, struct hid_input *hi,
 549                              struct hid_field *field, struct hid_usage *usage,
 550                              unsigned long **bit, int *max)
 551{
 552        /* No special mappings needed for the pen and single touch */
 553        if (field->physical)
 554                return 0;
 555
 556        if (usage->type == EV_KEY || usage->type == EV_REL
 557                        || usage->type == EV_ABS)
 558                clear_bit(usage->code, *bit);
 559
 560        return 0;
 561}
 562
 563/*
 564 * this function is called upon all reports
 565 * so that we can filter contact point information,
 566 * decide whether we are in multi or single touch mode
 567 * and call input_mt_sync after each point if necessary
 568 */
 569static int ntrig_event (struct hid_device *hid, struct hid_field *field,
 570                        struct hid_usage *usage, __s32 value)
 571{
 572        struct ntrig_data *nd = hid_get_drvdata(hid);
 573        struct input_dev *input;
 574
 575        /* Skip processing if not a claimed input */
 576        if (!(hid->claimed & HID_CLAIMED_INPUT))
 577                goto not_claimed_input;
 578
 579        /* This function is being called before the structures are fully
 580         * initialized */
 581        if(!(field->hidinput && field->hidinput->input))
 582                return -EINVAL;
 583
 584        input = field->hidinput->input;
 585
 586        /* No special handling needed for the pen */
 587        if (field->application == HID_DG_PEN)
 588                return 0;
 589
 590        switch (usage->hid) {
 591        case 0xff000001:
 592                /* Tag indicating the start of a multitouch group */
 593                nd->reading_mt = 1;
 594                nd->first_contact_touch = 0;
 595                break;
 596        case HID_DG_TIPSWITCH:
 597                nd->tipswitch = value;
 598                /* Prevent emission of touch until validated */
 599                return 1;
 600        case HID_DG_CONFIDENCE:
 601                nd->confidence = value;
 602                break;
 603        case HID_GD_X:
 604                nd->x = value;
 605                /* Clear the contact footer */
 606                nd->mt_foot_count = 0;
 607                break;
 608        case HID_GD_Y:
 609                nd->y = value;
 610                break;
 611        case HID_DG_CONTACTID:
 612                nd->id = value;
 613                break;
 614        case HID_DG_WIDTH:
 615                nd->w = value;
 616                break;
 617        case HID_DG_HEIGHT:
 618                nd->h = value;
 619                /*
 620                 * when in single touch mode, this is the last
 621                 * report received in a finger event. We want
 622                 * to emit a normal (X, Y) position
 623                 */
 624                if (!nd->reading_mt) {
 625                        /*
 626                         * TipSwitch indicates the presence of a
 627                         * finger in single touch mode.
 628                         */
 629                        input_report_key(input, BTN_TOUCH,
 630                                         nd->tipswitch);
 631                        input_report_key(input, BTN_TOOL_DOUBLETAP,
 632                                         nd->tipswitch);
 633                        input_event(input, EV_ABS, ABS_X, nd->x);
 634                        input_event(input, EV_ABS, ABS_Y, nd->y);
 635                }
 636                break;
 637        case 0xff000002:
 638                /*
 639                 * we receive this when the device is in multitouch
 640                 * mode. The first of the three values tagged with
 641                 * this usage tells if the contact point is real
 642                 * or a placeholder
 643                 */
 644
 645                /* Shouldn't get more than 4 footer packets, so skip */
 646                if (nd->mt_foot_count >= 4)
 647                        break;
 648
 649                nd->mt_footer[nd->mt_foot_count++] = value;
 650
 651                /* if the footer isn't complete break */
 652                if (nd->mt_foot_count != 4)
 653                        break;
 654
 655                /* Pen activity signal. */
 656                if (nd->mt_footer[2]) {
 657                        /*
 658                         * When the pen deactivates touch, we see a
 659                         * bogus frame with ContactCount > 0.
 660                         * We can
 661                         * save a bit of work by ensuring act_state < 0
 662                         * even if deactivation slack is turned off.
 663                         */
 664                        nd->act_state = deactivate_slack - 1;
 665                        nd->confidence = 0;
 666                        break;
 667                }
 668
 669                /*
 670                 * The first footer value indicates the presence of a
 671                 * finger.
 672                 */
 673                if (nd->mt_footer[0]) {
 674                        /*
 675                         * We do not want to process contacts under
 676                         * the size threshold, but do not want to
 677                         * ignore them for activation state
 678                         */
 679                        if (nd->w < nd->min_width ||
 680                            nd->h < nd->min_height)
 681                                nd->confidence = 0;
 682                } else
 683                        break;
 684
 685                if (nd->act_state > 0) {
 686                        /*
 687                         * Contact meets the activation size threshold
 688                         */
 689                        if (nd->w >= nd->activation_width &&
 690                            nd->h >= nd->activation_height) {
 691                                if (nd->id)
 692                                        /*
 693                                         * first contact, activate now
 694                                         */
 695                                        nd->act_state = 0;
 696                                else {
 697                                        /*
 698                                         * avoid corrupting this frame
 699                                         * but ensure next frame will
 700                                         * be active
 701                                         */
 702                                        nd->act_state = 1;
 703                                        break;
 704                                }
 705                        } else
 706                                /*
 707                                 * Defer adjusting the activation state
 708                                 * until the end of the frame.
 709                                 */
 710                                break;
 711                }
 712
 713                /* Discarding this contact */
 714                if (!nd->confidence)
 715                        break;
 716
 717                /* emit a normal (X, Y) for the first point only */
 718                if (nd->id == 0) {
 719                        /*
 720                         * TipSwitch is superfluous in multitouch
 721                         * mode.  The footer events tell us
 722                         * if there is a finger on the screen or
 723                         * not.
 724                         */
 725                        nd->first_contact_touch = nd->confidence;
 726                        input_event(input, EV_ABS, ABS_X, nd->x);
 727                        input_event(input, EV_ABS, ABS_Y, nd->y);
 728                }
 729
 730                /* Emit MT events */
 731                input_event(input, EV_ABS, ABS_MT_POSITION_X, nd->x);
 732                input_event(input, EV_ABS, ABS_MT_POSITION_Y, nd->y);
 733
 734                /*
 735                 * Translate from height and width to size
 736                 * and orientation.
 737                 */
 738                if (nd->w > nd->h) {
 739                        input_event(input, EV_ABS,
 740                                        ABS_MT_ORIENTATION, 1);
 741                        input_event(input, EV_ABS,
 742                                        ABS_MT_TOUCH_MAJOR, nd->w);
 743                        input_event(input, EV_ABS,
 744                                        ABS_MT_TOUCH_MINOR, nd->h);
 745                } else {
 746                        input_event(input, EV_ABS,
 747                                        ABS_MT_ORIENTATION, 0);
 748                        input_event(input, EV_ABS,
 749                                        ABS_MT_TOUCH_MAJOR, nd->h);
 750                        input_event(input, EV_ABS,
 751                                        ABS_MT_TOUCH_MINOR, nd->w);
 752                }
 753                input_mt_sync(field->hidinput->input);
 754                break;
 755
 756        case HID_DG_CONTACTCOUNT: /* End of a multitouch group */
 757                if (!nd->reading_mt) /* Just to be sure */
 758                        break;
 759
 760                nd->reading_mt = 0;
 761
 762
 763                /*
 764                 * Activation state machine logic:
 765                 *
 766                 * Fundamental states:
 767                 *      state >  0: Inactive
 768                 *      state <= 0: Active
 769                 *      state <  -deactivate_slack:
 770                 *               Pen termination of touch
 771                 *
 772                 * Specific values of interest
 773                 *      state == activate_slack
 774                 *               no valid input since the last reset
 775                 *
 776                 *      state == 0
 777                 *               general operational state
 778                 *
 779                 *      state == -deactivate_slack
 780                 *               read sufficient empty frames to accept
 781                 *               the end of input and reset
 782                 */
 783
 784                if (nd->act_state > 0) { /* Currently inactive */
 785                        if (value)
 786                                /*
 787                                 * Consider each live contact as
 788                                 * evidence of intentional activity.
 789                                 */
 790                                nd->act_state = (nd->act_state > value)
 791                                                ? nd->act_state - value
 792                                                : 0;
 793                        else
 794                                /*
 795                                 * Empty frame before we hit the
 796                                 * activity threshold, reset.
 797                                 */
 798                                nd->act_state = nd->activate_slack;
 799
 800                        /*
 801                         * Entered this block inactive and no
 802                         * coordinates sent this frame, so hold off
 803                         * on button state.
 804                         */
 805                        break;
 806                } else { /* Currently active */
 807                        if (value && nd->act_state >=
 808                                     nd->deactivate_slack)
 809                                /*
 810                                 * Live point: clear accumulated
 811                                 * deactivation count.
 812                                 */
 813                                nd->act_state = 0;
 814                        else if (nd->act_state <= nd->deactivate_slack)
 815                                /*
 816                                 * We've consumed the deactivation
 817                                 * slack, time to deactivate and reset.
 818                                 */
 819                                nd->act_state =
 820                                        nd->activate_slack;
 821                        else { /* Move towards deactivation */
 822                                nd->act_state--;
 823                                break;
 824                        }
 825                }
 826
 827                if (nd->first_contact_touch && nd->act_state <= 0) {
 828                        /*
 829                         * Check to see if we're ready to start
 830                         * emitting touch events.
 831                         *
 832                         * Note: activation slack will decrease over
 833                         * the course of the frame, and it will be
 834                         * inconsistent from the start to the end of
 835                         * the frame.  However if the frame starts
 836                         * with slack, first_contact_touch will still
 837                         * be 0 and we will not get to this point.
 838                         */
 839                        input_report_key(input, BTN_TOOL_DOUBLETAP, 1);
 840                        input_report_key(input, BTN_TOUCH, 1);
 841                } else {
 842                        input_report_key(input, BTN_TOOL_DOUBLETAP, 0);
 843                        input_report_key(input, BTN_TOUCH, 0);
 844                }
 845                break;
 846
 847        default:
 848                /* fall-back to the generic hidinput handling */
 849                return 0;
 850        }
 851
 852not_claimed_input:
 853
 854        /* we have handled the hidinput part, now remains hiddev */
 855        if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_hid_event)
 856                hid->hiddev_hid_event(hid, field, usage, value);
 857
 858        return 1;
 859}
 860
 861static int ntrig_probe(struct hid_device *hdev, const struct hid_device_id *id)
 862{
 863        int ret;
 864        struct ntrig_data *nd;
 865        struct hid_input *hidinput;
 866        struct input_dev *input;
 867        struct hid_report *report;
 868
 869        if (id->driver_data)
 870                hdev->quirks |= HID_QUIRK_MULTI_INPUT
 871                                | HID_QUIRK_NO_INIT_REPORTS;
 872
 873        nd = kmalloc(sizeof(struct ntrig_data), GFP_KERNEL);
 874        if (!nd) {
 875                hid_err(hdev, "cannot allocate N-Trig data\n");
 876                return -ENOMEM;
 877        }
 878
 879        nd->reading_mt = 0;
 880        nd->min_width = 0;
 881        nd->min_height = 0;
 882        nd->activate_slack = activate_slack;
 883        nd->act_state = activate_slack;
 884        nd->deactivate_slack = -deactivate_slack;
 885        nd->sensor_logical_width = 1;
 886        nd->sensor_logical_height = 1;
 887        nd->sensor_physical_width = 1;
 888        nd->sensor_physical_height = 1;
 889
 890        hid_set_drvdata(hdev, nd);
 891
 892        ret = hid_parse(hdev);
 893        if (ret) {
 894                hid_err(hdev, "parse failed\n");
 895                goto err_free;
 896        }
 897
 898        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
 899        if (ret) {
 900                hid_err(hdev, "hw start failed\n");
 901                goto err_free;
 902        }
 903
 904
 905        list_for_each_entry(hidinput, &hdev->inputs, list) {
 906                if (hidinput->report->maxfield < 1)
 907                        continue;
 908
 909                input = hidinput->input;
 910                switch (hidinput->report->field[0]->application) {
 911                case HID_DG_PEN:
 912                        input->name = "N-Trig Pen";
 913                        break;
 914                case HID_DG_TOUCHSCREEN:
 915                        /* These keys are redundant for fingers, clear them
 916                         * to prevent incorrect identification */
 917                        __clear_bit(BTN_TOOL_PEN, input->keybit);
 918                        __clear_bit(BTN_TOOL_FINGER, input->keybit);
 919                        __clear_bit(BTN_0, input->keybit);
 920                        __set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
 921                        /*
 922                         * The physical touchscreen (single touch)
 923                         * input has a value for physical, whereas
 924                         * the multitouch only has logical input
 925                         * fields.
 926                         */
 927                        input->name =
 928                                (hidinput->report->field[0]
 929                                 ->physical) ?
 930                                "N-Trig Touchscreen" :
 931                                "N-Trig MultiTouch";
 932                        break;
 933                }
 934        }
 935
 936        /* This is needed for devices with more recent firmware versions */
 937        report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0x0a];
 938        if (report) {
 939                /* Let the device settle to ensure the wakeup message gets
 940                 * through */
 941                usbhid_wait_io(hdev);
 942                usbhid_submit_report(hdev, report, USB_DIR_IN);
 943
 944                /*
 945                 * Sanity check: if the current mode is invalid reset it to
 946                 * something reasonable.
 947                 */
 948                if (ntrig_get_mode(hdev) >= 4)
 949                        ntrig_set_mode(hdev, 3);
 950        }
 951
 952        ntrig_report_version(hdev);
 953
 954        ret = sysfs_create_group(&hdev->dev.kobj,
 955                        &ntrig_attribute_group);
 956
 957        return 0;
 958err_free:
 959        kfree(nd);
 960        return ret;
 961}
 962
 963static void ntrig_remove(struct hid_device *hdev)
 964{
 965        sysfs_remove_group(&hdev->dev.kobj,
 966                           &ntrig_attribute_group);
 967        hid_hw_stop(hdev);
 968        kfree(hid_get_drvdata(hdev));
 969}
 970
 971static const struct hid_device_id ntrig_devices[] = {
 972        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN),
 973                .driver_data = NTRIG_DUPLICATE_USAGES },
 974        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1),
 975                .driver_data = NTRIG_DUPLICATE_USAGES },
 976        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2),
 977                .driver_data = NTRIG_DUPLICATE_USAGES },
 978        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3),
 979                .driver_data = NTRIG_DUPLICATE_USAGES },
 980        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4),
 981                .driver_data = NTRIG_DUPLICATE_USAGES },
 982        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5),
 983                .driver_data = NTRIG_DUPLICATE_USAGES },
 984        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6),
 985                .driver_data = NTRIG_DUPLICATE_USAGES },
 986        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7),
 987                .driver_data = NTRIG_DUPLICATE_USAGES },
 988        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8),
 989                .driver_data = NTRIG_DUPLICATE_USAGES },
 990        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9),
 991                .driver_data = NTRIG_DUPLICATE_USAGES },
 992        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10),
 993                .driver_data = NTRIG_DUPLICATE_USAGES },
 994        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11),
 995                .driver_data = NTRIG_DUPLICATE_USAGES },
 996        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12),
 997                .driver_data = NTRIG_DUPLICATE_USAGES },
 998        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13),
 999                .driver_data = NTRIG_DUPLICATE_USAGES },
1000        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14),
1001                .driver_data = NTRIG_DUPLICATE_USAGES },
1002        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15),
1003                .driver_data = NTRIG_DUPLICATE_USAGES },
1004        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16),
1005                .driver_data = NTRIG_DUPLICATE_USAGES },
1006        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17),
1007                .driver_data = NTRIG_DUPLICATE_USAGES },
1008        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18),
1009                .driver_data = NTRIG_DUPLICATE_USAGES },
1010        { }
1011};
1012MODULE_DEVICE_TABLE(hid, ntrig_devices);
1013
1014static const struct hid_usage_id ntrig_grabbed_usages[] = {
1015        { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
1016        { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1 }
1017};
1018
1019static struct hid_driver ntrig_driver = {
1020        .name = "ntrig",
1021        .id_table = ntrig_devices,
1022        .probe = ntrig_probe,
1023        .remove = ntrig_remove,
1024        .input_mapping = ntrig_input_mapping,
1025        .input_mapped = ntrig_input_mapped,
1026        .usage_table = ntrig_grabbed_usages,
1027        .event = ntrig_event,
1028};
1029
1030static int __init ntrig_init(void)
1031{
1032        return hid_register_driver(&ntrig_driver);
1033}
1034
1035static void __exit ntrig_exit(void)
1036{
1037        hid_unregister_driver(&ntrig_driver);
1038}
1039
1040module_init(ntrig_init);
1041module_exit(ntrig_exit);
1042MODULE_LICENSE("GPL");
1043
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.