API tools faq
paste
Advertisement
Guest User

wacom_wac.c

a guest
Nov 7th, 2015
336
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 101.04 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  * drivers/input/tablet/wacom_wac.c
  3.  *
  4.  *  USB Wacom tablet support - Wacom specific code
  5.  *
  6.  */
  7.  
  8. /*
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  */
  14.  
  15. #include "wacom_wac.h"
  16. #include "wacom.h"
  17. #include <linux/input/mt.h>
  18. #include <linux/hid.h>
  19.  
  20. /* resolution for penabled devices */
  21. #define WACOM_PL_RES        20
  22. #define WACOM_PENPRTN_RES   40
  23. #define WACOM_VOLITO_RES    50
  24. #define WACOM_GRAPHIRE_RES  80
  25. #define WACOM_INTUOS_RES    100
  26. #define WACOM_INTUOS3_RES   200
  27.  
  28. /*
  29.  * Scale factor relating reported contact size to logical contact area.
  30.  * 2^14/pi is a good approximation on Intuos5 and 3rd-gen Bamboo
  31.  */
  32. #define WACOM_CONTACT_AREA_SCALE 2607
  33.  
  34. /*
  35.  * Percent of battery capacity for Graphire.
  36.  * 8th value means AC online and show 100% capacity.
  37.  */
  38. static unsigned short batcap_gr[8] = { 1, 15, 25, 35, 50, 70, 100, 100 };
  39.  
  40. /*
  41.  * Percent of battery capacity for Intuos4 WL, AC has a separate bit.
  42.  */
  43. static unsigned short batcap_i4[8] = { 1, 15, 30, 45, 60, 70, 85, 100 };
  44.  
  45. static int wacom_penpartner_irq(struct wacom_wac *wacom)
  46. {
  47.     unsigned char *data = wacom->data;
  48.     struct input_dev *input = wacom->input;
  49.  
  50.     switch (data[0]) {
  51.     case 1:
  52.         if (data[5] & 0x80) {
  53.             wacom->tool[0] = (data[5] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
  54.             wacom->id[0] = (data[5] & 0x20) ? ERASER_DEVICE_ID : STYLUS_DEVICE_ID;
  55.             input_report_key(input, wacom->tool[0], 1);
  56.             input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
  57.             input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
  58.             input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
  59.             input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
  60.             input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -127));
  61.             input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
  62.         } else {
  63.             input_report_key(input, wacom->tool[0], 0);
  64.             input_report_abs(input, ABS_MISC, 0); /* report tool id */
  65.             input_report_abs(input, ABS_PRESSURE, -1);
  66.             input_report_key(input, BTN_TOUCH, 0);
  67.         }
  68.         break;
  69.  
  70.     case 2:
  71.         input_report_key(input, BTN_TOOL_PEN, 1);
  72.         input_report_abs(input, ABS_MISC, STYLUS_DEVICE_ID); /* report tool id */
  73.         input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
  74.         input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
  75.         input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
  76.         input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -80) && !(data[5] & 0x20));
  77.         input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
  78.         break;
  79.  
  80.     default:
  81.         dev_dbg(input->dev.parent,
  82.             "%s: received unknown report #%d\n", __func__, data[0]);
  83.         return 0;
  84.         }
  85.  
  86.     return 1;
  87. }
  88.  
  89. static int wacom_pl_irq(struct wacom_wac *wacom)
  90. {
  91.     struct wacom_features *features = &wacom->features;
  92.     unsigned char *data = wacom->data;
  93.     struct input_dev *input = wacom->input;
  94.     int prox, pressure;
  95.  
  96.     if (data[0] != WACOM_REPORT_PENABLED) {
  97.         dev_dbg(input->dev.parent,
  98.             "%s: received unknown report #%d\n", __func__, data[0]);
  99.         return 0;
  100.     }
  101.  
  102.     prox = data[1] & 0x40;
  103.  
  104.     if (prox) {
  105.         wacom->id[0] = ERASER_DEVICE_ID;
  106.         pressure = (signed char)((data[7] << 1) | ((data[4] >> 2) & 1));
  107.         if (features->pressure_max > 255)
  108.             pressure = (pressure << 1) | ((data[4] >> 6) & 1);
  109.         pressure += (features->pressure_max + 1) / 2;
  110.  
  111.         /*
  112.          * if going from out of proximity into proximity select between the eraser
  113.          * and the pen based on the state of the stylus2 button, choose eraser if
  114.          * pressed else choose pen. if not a proximity change from out to in, send
  115.          * an out of proximity for previous tool then a in for new tool.
  116.          */
  117.         if (!wacom->tool[0]) {
  118.             /* Eraser bit set for DTF */
  119.             if (data[1] & 0x10)
  120.                 wacom->tool[1] = BTN_TOOL_RUBBER;
  121.             else
  122.                 /* Going into proximity select tool */
  123.                 wacom->tool[1] = (data[4] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
  124.         } else {
  125.             /* was entered with stylus2 pressed */
  126.             if (wacom->tool[1] == BTN_TOOL_RUBBER && !(data[4] & 0x20)) {
  127.                 /* report out proximity for previous tool */
  128.                 input_report_key(input, wacom->tool[1], 0);
  129.                 input_sync(input);
  130.                 wacom->tool[1] = BTN_TOOL_PEN;
  131.                 return 0;
  132.             }
  133.         }
  134.         if (wacom->tool[1] != BTN_TOOL_RUBBER) {
  135.             /* Unknown tool selected default to pen tool */
  136.             wacom->tool[1] = BTN_TOOL_PEN;
  137.             wacom->id[0] = STYLUS_DEVICE_ID;
  138.         }
  139.         input_report_key(input, wacom->tool[1], prox); /* report in proximity for tool */
  140.         input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
  141.         input_report_abs(input, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
  142.         input_report_abs(input, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
  143.         input_report_abs(input, ABS_PRESSURE, pressure);
  144.  
  145.         input_report_key(input, BTN_TOUCH, data[4] & 0x08);
  146.         input_report_key(input, BTN_STYLUS, data[4] & 0x10);
  147.         /* Only allow the stylus2 button to be reported for the pen tool. */
  148.         input_report_key(input, BTN_STYLUS2, (wacom->tool[1] == BTN_TOOL_PEN) && (data[4] & 0x20));
  149.     } else {
  150.         /* report proximity-out of a (valid) tool */
  151.         if (wacom->tool[1] != BTN_TOOL_RUBBER) {
  152.             /* Unknown tool selected default to pen tool */
  153.             wacom->tool[1] = BTN_TOOL_PEN;
  154.         }
  155.         input_report_key(input, wacom->tool[1], prox);
  156.     }
  157.  
  158.     wacom->tool[0] = prox; /* Save proximity state */
  159.     return 1;
  160. }
  161.  
  162. static int wacom_ptu_irq(struct wacom_wac *wacom)
  163. {
  164.     unsigned char *data = wacom->data;
  165.     struct input_dev *input = wacom->input;
  166.  
  167.     if (data[0] != WACOM_REPORT_PENABLED) {
  168.         dev_dbg(input->dev.parent,
  169.             "%s: received unknown report #%d\n", __func__, data[0]);
  170.         return 0;
  171.     }
  172.  
  173.     if (data[1] & 0x04) {
  174.         input_report_key(input, BTN_TOOL_RUBBER, data[1] & 0x20);
  175.         input_report_key(input, BTN_TOUCH, data[1] & 0x08);
  176.         wacom->id[0] = ERASER_DEVICE_ID;
  177.     } else {
  178.         input_report_key(input, BTN_TOOL_PEN, data[1] & 0x20);
  179.         input_report_key(input, BTN_TOUCH, data[1] & 0x01);
  180.         wacom->id[0] = STYLUS_DEVICE_ID;
  181.     }
  182.     input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
  183.     input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
  184.     input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
  185.     input_report_abs(input, ABS_PRESSURE, le16_to_cpup((__le16 *)&data[6]));
  186.     input_report_key(input, BTN_STYLUS, data[1] & 0x02);
  187.     input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
  188.     return 1;
  189. }
  190.  
  191. static int wacom_dtu_irq(struct wacom_wac *wacom)
  192. {
  193.     unsigned char *data = wacom->data;
  194.     struct input_dev *input = wacom->input;
  195.     int prox = data[1] & 0x20;
  196.  
  197.     dev_dbg(input->dev.parent,
  198.         "%s: received report #%d", __func__, data[0]);
  199.  
  200.     if (prox) {
  201.         /* Going into proximity select tool */
  202.         wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
  203.         if (wacom->tool[0] == BTN_TOOL_PEN)
  204.             wacom->id[0] = STYLUS_DEVICE_ID;
  205.         else
  206.             wacom->id[0] = ERASER_DEVICE_ID;
  207.     }
  208.     input_report_key(input, BTN_STYLUS, data[1] & 0x02);
  209.     input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
  210.     input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
  211.     input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
  212.     input_report_abs(input, ABS_PRESSURE, ((data[7] & 0x01) << 8) | data[6]);
  213.     input_report_key(input, BTN_TOUCH, data[1] & 0x05);
  214.     if (!prox) /* out-prox */
  215.         wacom->id[0] = 0;
  216.     input_report_key(input, wacom->tool[0], prox);
  217.     input_report_abs(input, ABS_MISC, wacom->id[0]);
  218.     return 1;
  219. }
  220.  
  221. static int wacom_dtus_irq(struct wacom_wac *wacom)
  222. {
  223.     char *data = wacom->data;
  224.     struct input_dev *input = wacom->input;
  225.     unsigned short prox, pressure = 0;
  226.  
  227.     if (data[0] != WACOM_REPORT_DTUS && data[0] != WACOM_REPORT_DTUSPAD) {
  228.         dev_dbg(input->dev.parent,
  229.             "%s: received unknown report #%d", __func__, data[0]);
  230.         return 0;
  231.     } else if (data[0] == WACOM_REPORT_DTUSPAD) {
  232.         input = wacom->pad_input;
  233.         input_report_key(input, BTN_0, (data[1] & 0x01));
  234.         input_report_key(input, BTN_1, (data[1] & 0x02));
  235.         input_report_key(input, BTN_2, (data[1] & 0x04));
  236.         input_report_key(input, BTN_3, (data[1] & 0x08));
  237.         input_report_abs(input, ABS_MISC,
  238.                  data[1] & 0x0f ? PAD_DEVICE_ID : 0);
  239.         return 1;
  240.     } else {
  241.         prox = data[1] & 0x80;
  242.         if (prox) {
  243.             switch ((data[1] >> 3) & 3) {
  244.             case 1: /* Rubber */
  245.                 wacom->tool[0] = BTN_TOOL_RUBBER;
  246.                 wacom->id[0] = ERASER_DEVICE_ID;
  247.                 break;
  248.  
  249.             case 2: /* Pen */
  250.                 wacom->tool[0] = BTN_TOOL_PEN;
  251.                 wacom->id[0] = STYLUS_DEVICE_ID;
  252.                 break;
  253.             }
  254.         }
  255.  
  256.         input_report_key(input, BTN_STYLUS, data[1] & 0x20);
  257.         input_report_key(input, BTN_STYLUS2, data[1] & 0x40);
  258.         input_report_abs(input, ABS_X, get_unaligned_be16(&data[3]));
  259.         input_report_abs(input, ABS_Y, get_unaligned_be16(&data[5]));
  260.         pressure = ((data[1] & 0x03) << 8) | (data[2] & 0xff);
  261.         input_report_abs(input, ABS_PRESSURE, pressure);
  262.         input_report_key(input, BTN_TOUCH, pressure > 10);
  263.  
  264.         if (!prox) /* out-prox */
  265.             wacom->id[0] = 0;
  266.         input_report_key(input, wacom->tool[0], prox);
  267.         input_report_abs(input, ABS_MISC, wacom->id[0]);
  268.         return 1;
  269.     }
  270. }
  271.  
  272. static int wacom_graphire_irq(struct wacom_wac *wacom)
  273. {
  274.     struct wacom_features *features = &wacom->features;
  275.     unsigned char *data = wacom->data;
  276.     struct input_dev *input = wacom->input;
  277.     struct input_dev *pad_input = wacom->pad_input;
  278.     int battery_capacity, ps_connected;
  279.     int prox;
  280.     int rw = 0;
  281.     int retval = 0;
  282.  
  283.     if (features->type == GRAPHIRE_BT) {
  284.         if (data[0] != WACOM_REPORT_PENABLED_BT) {
  285.             dev_dbg(input->dev.parent,
  286.                 "%s: received unknown report #%d\n", __func__,
  287.                 data[0]);
  288.             goto exit;
  289.         }
  290.     } else if (data[0] != WACOM_REPORT_PENABLED) {
  291.         dev_dbg(input->dev.parent,
  292.             "%s: received unknown report #%d\n", __func__, data[0]);
  293.         goto exit;
  294.     }
  295.  
  296.     prox = data[1] & 0x80;
  297.     if (prox || wacom->id[0]) {
  298.         if (prox) {
  299.             switch ((data[1] >> 5) & 3) {
  300.  
  301.             case 0: /* Pen */
  302.                 wacom->tool[0] = BTN_TOOL_PEN;
  303.                 wacom->id[0] = STYLUS_DEVICE_ID;
  304.                 break;
  305.  
  306.             case 1: /* Rubber */
  307.                 wacom->tool[0] = BTN_TOOL_RUBBER;
  308.                 wacom->id[0] = ERASER_DEVICE_ID;
  309.                 break;
  310.  
  311.             case 2: /* Mouse with wheel */
  312.                 input_report_key(input, BTN_MIDDLE, data[1] & 0x04);
  313.                 /* fall through */
  314.  
  315.             case 3: /* Mouse without wheel */
  316.                 wacom->tool[0] = BTN_TOOL_MOUSE;
  317.                 wacom->id[0] = CURSOR_DEVICE_ID;
  318.                 break;
  319.             }
  320.         }
  321.         input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
  322.         input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
  323.         if (wacom->tool[0] != BTN_TOOL_MOUSE) {
  324.             if (features->type == GRAPHIRE_BT)
  325.                 input_report_abs(input, ABS_PRESSURE, data[6] |
  326.                     (((__u16) (data[1] & 0x08)) << 5));
  327.             else
  328.                 input_report_abs(input, ABS_PRESSURE, data[6] |
  329.                     ((data[7] & 0x03) << 8));
  330.             input_report_key(input, BTN_TOUCH, data[1] & 0x01);
  331.             input_report_key(input, BTN_STYLUS, data[1] & 0x02);
  332.             input_report_key(input, BTN_STYLUS2, data[1] & 0x04);
  333.         } else {
  334.             input_report_key(input, BTN_LEFT, data[1] & 0x01);
  335.             input_report_key(input, BTN_RIGHT, data[1] & 0x02);
  336.             if (features->type == WACOM_G4 ||
  337.                     features->type == WACOM_MO) {
  338.                 input_report_abs(input, ABS_DISTANCE, data[6] & 0x3f);
  339.                 rw = (data[7] & 0x04) - (data[7] & 0x03);
  340.             } else if (features->type == GRAPHIRE_BT) {
  341.                 /* Compute distance between mouse and tablet */
  342.                 rw = 44 - (data[6] >> 2);
  343.                 rw = clamp_val(rw, 0, 31);
  344.                 input_report_abs(input, ABS_DISTANCE, rw);
  345.                 if (((data[1] >> 5) & 3) == 2) {
  346.                     /* Mouse with wheel */
  347.                     input_report_key(input, BTN_MIDDLE,
  348.                             data[1] & 0x04);
  349.                     rw = (data[6] & 0x01) ? -1 :
  350.                         (data[6] & 0x02) ? 1 : 0;
  351.                 } else {
  352.                     rw = 0;
  353.                 }
  354.             } else {
  355.                 input_report_abs(input, ABS_DISTANCE, data[7] & 0x3f);
  356.                 rw = -(signed char)data[6];
  357.             }
  358.             input_report_rel(input, REL_WHEEL, rw);
  359.         }
  360.  
  361.         if (!prox)
  362.             wacom->id[0] = 0;
  363.         input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
  364.         input_report_key(input, wacom->tool[0], prox);
  365.         input_sync(input); /* sync last event */
  366.     }
  367.  
  368.     /* send pad data */
  369.     switch (features->type) {
  370.     case WACOM_G4:
  371.         prox = data[7] & 0xf8;
  372.         if (prox || wacom->id[1]) {
  373.             wacom->id[1] = PAD_DEVICE_ID;
  374.             input_report_key(pad_input, BTN_BACK, (data[7] & 0x40));
  375.             input_report_key(pad_input, BTN_FORWARD, (data[7] & 0x80));
  376.             rw = ((data[7] & 0x18) >> 3) - ((data[7] & 0x20) >> 3);
  377.             input_report_rel(pad_input, REL_WHEEL, rw);
  378.             if (!prox)
  379.                 wacom->id[1] = 0;
  380.             input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
  381.             retval = 1;
  382.         }
  383.         break;
  384.  
  385.     case WACOM_MO:
  386.         prox = (data[7] & 0xf8) || data[8];
  387.         if (prox || wacom->id[1]) {
  388.             wacom->id[1] = PAD_DEVICE_ID;
  389.             input_report_key(pad_input, BTN_BACK, (data[7] & 0x08));
  390.             input_report_key(pad_input, BTN_LEFT, (data[7] & 0x20));
  391.             input_report_key(pad_input, BTN_FORWARD, (data[7] & 0x10));
  392.             input_report_key(pad_input, BTN_RIGHT, (data[7] & 0x40));
  393.             input_report_abs(pad_input, ABS_WHEEL, (data[8] & 0x7f));
  394.             if (!prox)
  395.                 wacom->id[1] = 0;
  396.             input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
  397.             retval = 1;
  398.         }
  399.         break;
  400.     case GRAPHIRE_BT:
  401.         prox = data[7] & 0x03;
  402.         if (prox || wacom->id[1]) {
  403.             wacom->id[1] = PAD_DEVICE_ID;
  404.             input_report_key(pad_input, BTN_0, (data[7] & 0x02));
  405.             input_report_key(pad_input, BTN_1, (data[7] & 0x01));
  406.             if (!prox)
  407.                 wacom->id[1] = 0;
  408.             input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
  409.             retval = 1;
  410.         }
  411.         break;
  412.     }
  413.  
  414.     /* Store current battery capacity and power supply state */
  415.     if (features->type == GRAPHIRE_BT) {
  416.         rw = (data[7] >> 2 & 0x07);
  417.         battery_capacity = batcap_gr[rw];
  418.         ps_connected = rw == 7;
  419.         if ((wacom->battery_capacity != battery_capacity) ||
  420.             (wacom->ps_connected != ps_connected)) {
  421.             wacom->battery_capacity = battery_capacity;
  422.             wacom->ps_connected = ps_connected;
  423.             wacom_notify_battery(wacom);
  424.         }
  425.     }
  426. exit:
  427.     return retval;
  428. }
  429.  
  430. static int wacom_intuos_inout(struct wacom_wac *wacom)
  431. {
  432.     struct wacom_features *features = &wacom->features;
  433.     unsigned char *data = wacom->data;
  434.     struct input_dev *input = wacom->input;
  435.     int idx = 0;
  436.  
  437.     /* tool number */
  438.     if (features->type == INTUOS)
  439.         idx = data[1] & 0x01;
  440.  
  441.     /* Enter report */
  442.     if ((data[1] & 0xfc) == 0xc0) {
  443.         if (features->quirks & WACOM_QUIRK_MULTI_INPUT)
  444.             wacom->shared->stylus_in_proximity = true;
  445.  
  446.         /* serial number of the tool */
  447.         wacom->serial[idx] = ((data[3] & 0x0f) << 28) +
  448.             (data[4] << 20) + (data[5] << 12) +
  449.             (data[6] << 4) + (data[7] >> 4);
  450.  
  451.         wacom->id[idx] = (data[2] << 4) | (data[3] >> 4) |
  452.             ((data[7] & 0x0f) << 20) | ((data[8] & 0xf0) << 12);
  453.  
  454.         switch (wacom->id[idx]) {
  455.         case 0x812: /* Inking pen */
  456.         case 0x801: /* Intuos3 Inking pen */
  457.         case 0x120802: /* Intuos4/5 Inking Pen */
  458.         case 0x012:
  459.             wacom->tool[idx] = BTN_TOOL_PENCIL;
  460.             break;
  461.  
  462.         case 0x822: /* Pen */
  463.         case 0x842:
  464.         case 0x852:
  465.         case 0x823: /* Intuos3 Grip Pen */
  466.         case 0x813: /* Intuos3 Classic Pen */
  467.         case 0x885: /* Intuos3 Marker Pen */
  468.         case 0x802: /* Intuos4/5 13HD/24HD General Pen */
  469.         case 0x804: /* Intuos4/5 13HD/24HD Marker Pen */
  470.         case 0x022:
  471.         case 0x100804: /* Intuos4/5 13HD/24HD Art Pen */
  472.         case 0x140802: /* Intuos4/5 13HD/24HD Classic Pen */
  473.         case 0x160802: /* Cintiq 13HD Pro Pen */
  474.         case 0x180802: /* DTH2242 Pen */
  475.         case 0x100802: /* Intuos4/5 13HD/24HD General Pen */
  476.             wacom->tool[idx] = BTN_TOOL_PEN;
  477.             break;
  478.  
  479.         case 0x832: /* Stroke pen */
  480.         case 0x032:
  481.             wacom->tool[idx] = BTN_TOOL_BRUSH;
  482.             break;
  483.  
  484.         case 0x007: /* Mouse 4D and 2D */
  485.         case 0x09c:
  486.         case 0x094:
  487.         case 0x017: /* Intuos3 2D Mouse */
  488.         case 0x806: /* Intuos4 Mouse */
  489.             wacom->tool[idx] = BTN_TOOL_MOUSE;
  490.             break;
  491.  
  492.         case 0x096: /* Lens cursor */
  493.         case 0x097: /* Intuos3 Lens cursor */
  494.         case 0x006: /* Intuos4 Lens cursor */
  495.             wacom->tool[idx] = BTN_TOOL_LENS;
  496.             break;
  497.  
  498.         case 0x82a: /* Eraser */
  499.         case 0x85a:
  500.         case 0x91a:
  501.         case 0xd1a:
  502.         case 0x0fa:
  503.         case 0x82b: /* Intuos3 Grip Pen Eraser */
  504.         case 0x81b: /* Intuos3 Classic Pen Eraser */
  505.         case 0x91b: /* Intuos3 Airbrush Eraser */
  506.         case 0x80c: /* Intuos4/5 13HD/24HD Marker Pen Eraser */
  507.         case 0x80a: /* Intuos4/5 13HD/24HD General Pen Eraser */
  508.         case 0x90a: /* Intuos4/5 13HD/24HD Airbrush Eraser */
  509.         case 0x14080a: /* Intuos4/5 13HD/24HD Classic Pen Eraser */
  510.         case 0x10090a: /* Intuos4/5 13HD/24HD Airbrush Eraser */
  511.         case 0x10080c: /* Intuos4/5 13HD/24HD Art Pen Eraser */
  512.         case 0x16080a: /* Cintiq 13HD Pro Pen Eraser */
  513.         case 0x18080a: /* DTH2242 Eraser */
  514.         case 0x10080a: /* Intuos4/5 13HD/24HD General Pen Eraser */
  515.             wacom->tool[idx] = BTN_TOOL_RUBBER;
  516.             break;
  517.  
  518.         case 0xd12:
  519.         case 0x912:
  520.         case 0x112:
  521.         case 0x913: /* Intuos3 Airbrush */
  522.         case 0x902: /* Intuos4/5 13HD/24HD Airbrush */
  523.         case 0x100902: /* Intuos4/5 13HD/24HD Airbrush */
  524.             wacom->tool[idx] = BTN_TOOL_AIRBRUSH;
  525.             break;
  526.  
  527.         default: /* Unknown tool */
  528.             wacom->tool[idx] = BTN_TOOL_PEN;
  529.             break;
  530.         }
  531.         return 1;
  532.     }
  533.  
  534.     /* older I4 styli don't work with new Cintiqs */
  535.     if (!((wacom->id[idx] >> 20) & 0x01) &&
  536.             (features->type == WACOM_21UX2))
  537.         return 1;
  538.  
  539.     /* Range Report */
  540.     if ((data[1] & 0xfe) == 0x20) {
  541.         input_report_key(input, BTN_TOUCH, 0);
  542.         input_report_abs(input, ABS_PRESSURE, 0);
  543.         input_report_abs(input, ABS_DISTANCE, wacom->features.distance_max);
  544.         if (features->quirks & WACOM_QUIRK_MULTI_INPUT)
  545.             wacom->shared->stylus_in_proximity = true;
  546.     }
  547.  
  548.     /* Exit report */
  549.     if ((data[1] & 0xfe) == 0x80) {
  550.         if (features->quirks & WACOM_QUIRK_MULTI_INPUT)
  551.             wacom->shared->stylus_in_proximity = false;
  552.  
  553.         /*
  554.          * Reset all states otherwise we lose the initial states
  555.          * when in-prox next time
  556.          */
  557.         input_report_abs(input, ABS_X, 0);
  558.         input_report_abs(input, ABS_Y, 0);
  559.         input_report_abs(input, ABS_DISTANCE, 0);
  560.         input_report_abs(input, ABS_TILT_X, 0);
  561.         input_report_abs(input, ABS_TILT_Y, 0);
  562.         if (wacom->tool[idx] >= BTN_TOOL_MOUSE) {
  563.             input_report_key(input, BTN_LEFT, 0);
  564.             input_report_key(input, BTN_MIDDLE, 0);
  565.             input_report_key(input, BTN_RIGHT, 0);
  566.             input_report_key(input, BTN_SIDE, 0);
  567.             input_report_key(input, BTN_EXTRA, 0);
  568.             input_report_abs(input, ABS_THROTTLE, 0);
  569.             input_report_abs(input, ABS_RZ, 0);
  570.         } else {
  571.             input_report_abs(input, ABS_PRESSURE, 0);
  572.             input_report_key(input, BTN_STYLUS, 0);
  573.             input_report_key(input, BTN_STYLUS2, 0);
  574.             input_report_key(input, BTN_TOUCH, 0);
  575.             input_report_abs(input, ABS_WHEEL, 0);
  576.             if (features->type >= INTUOS3S)
  577.                 input_report_abs(input, ABS_Z, 0);
  578.         }
  579.         input_report_key(input, wacom->tool[idx], 0);
  580.         input_report_abs(input, ABS_MISC, 0); /* reset tool id */
  581.         input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
  582.         wacom->id[idx] = 0;
  583.         return 2;
  584.     }
  585.     return 0;
  586. }
  587.  
  588. static void wacom_intuos_general(struct wacom_wac *wacom)
  589. {
  590.     struct wacom_features *features = &wacom->features;
  591.     unsigned char *data = wacom->data;
  592.     struct input_dev *input = wacom->input;
  593.     unsigned int t;
  594.  
  595.     /* general pen packet */
  596.     if ((data[1] & 0xb8) == 0xa0) {
  597.         t = (data[6] << 2) | ((data[7] >> 6) & 3);
  598.         if (features->type >= INTUOS4S && features->type <= CINTIQ_HYBRID) {
  599.             t = (t << 1) | (data[1] & 1);
  600.         }
  601.         input_report_abs(input, ABS_PRESSURE, t);
  602.         input_report_abs(input, ABS_TILT_X,
  603.                 ((data[7] << 1) & 0x7e) | (data[8] >> 7));
  604.         input_report_abs(input, ABS_TILT_Y, data[8] & 0x7f);
  605.         input_report_key(input, BTN_STYLUS, data[1] & 2);
  606.         input_report_key(input, BTN_STYLUS2, data[1] & 4);
  607.         input_report_key(input, BTN_TOUCH, t > 10);
  608.     }
  609.  
  610.     /* airbrush second packet */
  611.     if ((data[1] & 0xbc) == 0xb4) {
  612.         input_report_abs(input, ABS_WHEEL,
  613.                 (data[6] << 2) | ((data[7] >> 6) & 3));
  614.         input_report_abs(input, ABS_TILT_X,
  615.                 ((data[7] << 1) & 0x7e) | (data[8] >> 7));
  616.         input_report_abs(input, ABS_TILT_Y, data[8] & 0x7f);
  617.     }
  618. }
  619.  
  620. static int wacom_intuos_irq(struct wacom_wac *wacom)
  621. {
  622.     struct wacom_features *features = &wacom->features;
  623.     unsigned char *data = wacom->data;
  624.     struct input_dev *input = wacom->input;
  625.     unsigned int t;
  626.     int idx = 0, result;
  627.  
  628.     if (data[0] != WACOM_REPORT_PENABLED &&
  629.         data[0] != WACOM_REPORT_INTUOSREAD &&
  630.         data[0] != WACOM_REPORT_INTUOSWRITE &&
  631.         data[0] != WACOM_REPORT_INTUOSPAD &&
  632.         data[0] != WACOM_REPORT_INTUOS5PAD) {
  633.         dev_dbg(input->dev.parent,
  634.             "%s: received unknown report #%d\n", __func__, data[0]);
  635.                 return 0;
  636.     }
  637.  
  638.     /* tool number */
  639.     if (features->type == INTUOS)
  640.         idx = data[1] & 0x01;
  641.  
  642.     /* pad packets. Works as a second tool and is always in prox */
  643.     if (data[0] == WACOM_REPORT_INTUOSPAD || data[0] == WACOM_REPORT_INTUOS5PAD) {
  644.         input = wacom->pad_input;
  645.         if (features->type >= INTUOS4S && features->type <= INTUOS4L) {
  646.             input_report_key(input, BTN_0, (data[2] & 0x01));
  647.             input_report_key(input, BTN_1, (data[3] & 0x01));
  648.             input_report_key(input, BTN_2, (data[3] & 0x02));
  649.             input_report_key(input, BTN_3, (data[3] & 0x04));
  650.             input_report_key(input, BTN_4, (data[3] & 0x08));
  651.             input_report_key(input, BTN_5, (data[3] & 0x10));
  652.             input_report_key(input, BTN_6, (data[3] & 0x20));
  653.             if (data[1] & 0x80) {
  654.                 input_report_abs(input, ABS_WHEEL, (data[1] & 0x7f));
  655.             } else {
  656.                 /* Out of proximity, clear wheel value. */
  657.                 input_report_abs(input, ABS_WHEEL, 0);
  658.             }
  659.             if (features->type != INTUOS4S) {
  660.                 input_report_key(input, BTN_7, (data[3] & 0x40));
  661.                 input_report_key(input, BTN_8, (data[3] & 0x80));
  662.             }
  663.             if (data[1] | (data[2] & 0x01) | data[3]) {
  664.                 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
  665.             } else {
  666.                 input_report_abs(input, ABS_MISC, 0);
  667.             }
  668.         } else if (features->type == DTK) {
  669.             input_report_key(input, BTN_0, (data[6] & 0x01));
  670.             input_report_key(input, BTN_1, (data[6] & 0x02));
  671.             input_report_key(input, BTN_2, (data[6] & 0x04));
  672.             input_report_key(input, BTN_3, (data[6] & 0x08));
  673.             input_report_key(input, BTN_4, (data[6] & 0x10));
  674.             input_report_key(input, BTN_5, (data[6] & 0x20));
  675.             if (data[6] & 0x3f) {
  676.                 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
  677.             } else {
  678.                 input_report_abs(input, ABS_MISC, 0);
  679.             }
  680.         } else if (features->type == WACOM_13HD) {
  681.             input_report_key(input, BTN_0, (data[3] & 0x01));
  682.             input_report_key(input, BTN_1, (data[4] & 0x01));
  683.             input_report_key(input, BTN_2, (data[4] & 0x02));
  684.             input_report_key(input, BTN_3, (data[4] & 0x04));
  685.             input_report_key(input, BTN_4, (data[4] & 0x08));
  686.             input_report_key(input, BTN_5, (data[4] & 0x10));
  687.             input_report_key(input, BTN_6, (data[4] & 0x20));
  688.             input_report_key(input, BTN_7, (data[4] & 0x40));
  689.             input_report_key(input, BTN_8, (data[4] & 0x80));
  690.             if ((data[3] & 0x01) | data[4]) {
  691.                 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
  692.             } else {
  693.                 input_report_abs(input, ABS_MISC, 0);
  694.             }
  695.         } else if (features->type == WACOM_24HD) {
  696.             input_report_key(input, BTN_0, (data[6] & 0x01));
  697.             input_report_key(input, BTN_1, (data[6] & 0x02));
  698.             input_report_key(input, BTN_2, (data[6] & 0x04));
  699.             input_report_key(input, BTN_3, (data[6] & 0x08));
  700.             input_report_key(input, BTN_4, (data[6] & 0x10));
  701.             input_report_key(input, BTN_5, (data[6] & 0x20));
  702.             input_report_key(input, BTN_6, (data[6] & 0x40));
  703.             input_report_key(input, BTN_7, (data[6] & 0x80));
  704.             input_report_key(input, BTN_8, (data[8] & 0x01));
  705.             input_report_key(input, BTN_9, (data[8] & 0x02));
  706.             input_report_key(input, BTN_A, (data[8] & 0x04));
  707.             input_report_key(input, BTN_B, (data[8] & 0x08));
  708.             input_report_key(input, BTN_C, (data[8] & 0x10));
  709.             input_report_key(input, BTN_X, (data[8] & 0x20));
  710.             input_report_key(input, BTN_Y, (data[8] & 0x40));
  711.             input_report_key(input, BTN_Z, (data[8] & 0x80));
  712.  
  713.             /*
  714.              * Three "buttons" are available on the 24HD which are
  715.              * physically implemented as a touchstrip. Each button
  716.              * is approximately 3 bits wide with a 2 bit spacing.
  717.              * The raw touchstrip bits are stored at:
  718.              *    ((data[3] & 0x1f) << 8) | data[4])
  719.              */
  720.             input_report_key(input, KEY_PROG1, data[4] & 0x07);
  721.             input_report_key(input, KEY_PROG2, data[4] & 0xE0);
  722.             input_report_key(input, KEY_PROG3, data[3] & 0x1C);
  723.  
  724.             if (data[1] & 0x80) {
  725.                 input_report_abs(input, ABS_WHEEL, (data[1] & 0x7f));
  726.             } else {
  727.                 /* Out of proximity, clear wheel value. */
  728.                 input_report_abs(input, ABS_WHEEL, 0);
  729.             }
  730.  
  731.             if (data[2] & 0x80) {
  732.                 input_report_abs(input, ABS_THROTTLE, (data[2] & 0x7f));
  733.             } else {
  734.                 /* Out of proximity, clear second wheel value. */
  735.                 input_report_abs(input, ABS_THROTTLE, 0);
  736.             }
  737.  
  738.             if (data[1] | data[2] | (data[3] & 0x1f) | data[4] | data[6] | data[8]) {
  739.                 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
  740.             } else {
  741.                 input_report_abs(input, ABS_MISC, 0);
  742.             }
  743.         } else if (features->type == CINTIQ_HYBRID) {
  744.             /*
  745.              * Do not send hardware buttons under Android. They
  746.              * are already sent to the system through GPIO (and
  747.              * have different meaning).
  748.              */
  749.             input_report_key(input, BTN_1, (data[4] & 0x01));
  750.             input_report_key(input, BTN_2, (data[4] & 0x02));
  751.             input_report_key(input, BTN_3, (data[4] & 0x04));
  752.             input_report_key(input, BTN_4, (data[4] & 0x08));
  753.  
  754.             input_report_key(input, BTN_5, (data[4] & 0x10));  /* Right  */
  755.             input_report_key(input, BTN_6, (data[4] & 0x20));  /* Up     */
  756.             input_report_key(input, BTN_7, (data[4] & 0x40));  /* Left   */
  757.             input_report_key(input, BTN_8, (data[4] & 0x80));  /* Down   */
  758.             input_report_key(input, BTN_0, (data[3] & 0x01));  /* Center */
  759.  
  760.             if (data[4] | (data[3] & 0x01)) {
  761.                 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
  762.             } else {
  763.                 input_report_abs(input, ABS_MISC, 0);
  764.             }
  765.         } else if (features->type >= INTUOS5S && features->type <= INTUOSPL) {
  766.             int i;
  767.  
  768.             /* Touch ring mode switch has no capacitive sensor */
  769.             input_report_key(input, BTN_0, (data[3] & 0x01));
  770.  
  771.             /*
  772.              * ExpressKeys on Intuos5/Intuos Pro have a capacitive sensor in
  773.              * addition to the mechanical switch. Switch data is
  774.              * stored in data[4], capacitive data in data[5].
  775.              */
  776.             for (i = 0; i < 8; i++)
  777.                 input_report_key(input, BTN_1 + i, data[4] & (1 << i));
  778.  
  779.             if (data[2] & 0x80) {
  780.                 input_report_abs(input, ABS_WHEEL, (data[2] & 0x7f));
  781.             } else {
  782.                 /* Out of proximity, clear wheel value. */
  783.                 input_report_abs(input, ABS_WHEEL, 0);
  784.             }
  785.  
  786.             if (data[2] | (data[3] & 0x01) | data[4] | data[5]) {
  787.                 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
  788.             } else {
  789.                 input_report_abs(input, ABS_MISC, 0);
  790.             }
  791.         } else {
  792.             if (features->type == WACOM_21UX2 || features->type == WACOM_22HD) {
  793.                 input_report_key(input, BTN_0, (data[5] & 0x01));
  794.                 input_report_key(input, BTN_1, (data[6] & 0x01));
  795.                 input_report_key(input, BTN_2, (data[6] & 0x02));
  796.                 input_report_key(input, BTN_3, (data[6] & 0x04));
  797.                 input_report_key(input, BTN_4, (data[6] & 0x08));
  798.                 input_report_key(input, BTN_5, (data[6] & 0x10));
  799.                 input_report_key(input, BTN_6, (data[6] & 0x20));
  800.                 input_report_key(input, BTN_7, (data[6] & 0x40));
  801.                 input_report_key(input, BTN_8, (data[6] & 0x80));
  802.                 input_report_key(input, BTN_9, (data[7] & 0x01));
  803.                 input_report_key(input, BTN_A, (data[8] & 0x01));
  804.                 input_report_key(input, BTN_B, (data[8] & 0x02));
  805.                 input_report_key(input, BTN_C, (data[8] & 0x04));
  806.                 input_report_key(input, BTN_X, (data[8] & 0x08));
  807.                 input_report_key(input, BTN_Y, (data[8] & 0x10));
  808.                 input_report_key(input, BTN_Z, (data[8] & 0x20));
  809.                 input_report_key(input, BTN_BASE, (data[8] & 0x40));
  810.                 input_report_key(input, BTN_BASE2, (data[8] & 0x80));
  811.  
  812.                 if (features->type == WACOM_22HD) {
  813.                     input_report_key(input, KEY_PROG1, data[9] & 0x01);
  814.                     input_report_key(input, KEY_PROG2, data[9] & 0x02);
  815.                     input_report_key(input, KEY_PROG3, data[9] & 0x04);
  816.                 }
  817.             } else {
  818.                 input_report_key(input, BTN_0, (data[5] & 0x01));
  819.                 input_report_key(input, BTN_1, (data[5] & 0x02));
  820.                 input_report_key(input, BTN_2, (data[5] & 0x04));
  821.                 input_report_key(input, BTN_3, (data[5] & 0x08));
  822.                 input_report_key(input, BTN_4, (data[6] & 0x01));
  823.                 input_report_key(input, BTN_5, (data[6] & 0x02));
  824.                 input_report_key(input, BTN_6, (data[6] & 0x04));
  825.                 input_report_key(input, BTN_7, (data[6] & 0x08));
  826.                 input_report_key(input, BTN_8, (data[5] & 0x10));
  827.                 input_report_key(input, BTN_9, (data[6] & 0x10));
  828.             }
  829.             input_report_abs(input, ABS_RX, ((data[1] & 0x1f) << 8) | data[2]);
  830.             input_report_abs(input, ABS_RY, ((data[3] & 0x1f) << 8) | data[4]);
  831.  
  832.             if ((data[5] & 0x1f) | data[6] | (data[1] & 0x1f) |
  833.                 data[2] | (data[3] & 0x1f) | data[4] | data[8] |
  834.                 (data[7] & 0x01)) {
  835.                 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
  836.             } else {
  837.                 input_report_abs(input, ABS_MISC, 0);
  838.             }
  839.         }
  840.                 return 1;
  841.     }
  842.  
  843.     /* process in/out prox events */
  844.     result = wacom_intuos_inout(wacom);
  845.     if (result)
  846.                 return result - 1;
  847.  
  848.     /* don't proceed if we don't know the ID */
  849.     if (!wacom->id[idx])
  850.         return 0;
  851.  
  852.     /* Only large Intuos support Lense Cursor */
  853.     if (wacom->tool[idx] == BTN_TOOL_LENS &&
  854.         (features->type == INTUOS3 ||
  855.          features->type == INTUOS3S ||
  856.          features->type == INTUOS4 ||
  857.          features->type == INTUOS4S ||
  858.          features->type == INTUOS5 ||
  859.          features->type == INTUOS5S ||
  860.          features->type == INTUOSPM ||
  861.          features->type == INTUOSPS)) {
  862.  
  863.         return 0;
  864.     }
  865.  
  866.     /* Cintiq doesn't send data when RDY bit isn't set */
  867.     if (features->type == CINTIQ && !(data[1] & 0x40))
  868.                  return 0;
  869.  
  870.     if (features->type >= INTUOS3S) {
  871.         input_report_abs(input, ABS_X, (data[2] << 9) | (data[3] << 1) | ((data[9] >> 1) & 1));
  872.         input_report_abs(input, ABS_Y, (data[4] << 9) | (data[5] << 1) | (data[9] & 1));
  873.         input_report_abs(input, ABS_DISTANCE, ((data[9] >> 2) & 0x3f));
  874.     } else {
  875.         input_report_abs(input, ABS_X, be16_to_cpup((__be16 *)&data[2]));
  876.         input_report_abs(input, ABS_Y, be16_to_cpup((__be16 *)&data[4]));
  877.         input_report_abs(input, ABS_DISTANCE, ((data[9] >> 3) & 0x1f));
  878.     }
  879.  
  880.     /* process general packets */
  881.     wacom_intuos_general(wacom);
  882.  
  883.     /* 4D mouse, 2D mouse, marker pen rotation, tilt mouse, or Lens cursor packets */
  884.     if ((data[1] & 0xbc) == 0xa8 || (data[1] & 0xbe) == 0xb0 || (data[1] & 0xbc) == 0xac) {
  885.  
  886.         if (data[1] & 0x02) {
  887.             /* Rotation packet */
  888.             if (features->type >= INTUOS3S) {
  889.                 /* I3 marker pen rotation */
  890.                 t = (data[6] << 3) | ((data[7] >> 5) & 7);
  891.                 t = (data[7] & 0x20) ? ((t > 900) ? ((t-1) / 2 - 1350) :
  892.                     ((t-1) / 2 + 450)) : (450 - t / 2) ;
  893.                 input_report_abs(input, ABS_Z, t);
  894.             } else {
  895.                 /* 4D mouse rotation packet */
  896.                 t = (data[6] << 3) | ((data[7] >> 5) & 7);
  897.                 input_report_abs(input, ABS_RZ, (data[7] & 0x20) ?
  898.                     ((t - 1) / 2) : -t / 2);
  899.             }
  900.  
  901.         } else if (!(data[1] & 0x10) && features->type < INTUOS3S) {
  902.             /* 4D mouse packet */
  903.             input_report_key(input, BTN_LEFT,   data[8] & 0x01);
  904.             input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
  905.             input_report_key(input, BTN_RIGHT,  data[8] & 0x04);
  906.  
  907.             input_report_key(input, BTN_SIDE,   data[8] & 0x20);
  908.             input_report_key(input, BTN_EXTRA,  data[8] & 0x10);
  909.             t = (data[6] << 2) | ((data[7] >> 6) & 3);
  910.             input_report_abs(input, ABS_THROTTLE, (data[8] & 0x08) ? -t : t);
  911.  
  912.         } else if (wacom->tool[idx] == BTN_TOOL_MOUSE) {
  913.             /* I4 mouse */
  914.             if (features->type >= INTUOS4S && features->type <= INTUOSPL) {
  915.                 input_report_key(input, BTN_LEFT,   data[6] & 0x01);
  916.                 input_report_key(input, BTN_MIDDLE, data[6] & 0x02);
  917.                 input_report_key(input, BTN_RIGHT,  data[6] & 0x04);
  918.                 input_report_rel(input, REL_WHEEL, ((data[7] & 0x80) >> 7)
  919.                          - ((data[7] & 0x40) >> 6));
  920.                 input_report_key(input, BTN_SIDE,   data[6] & 0x08);
  921.                 input_report_key(input, BTN_EXTRA,  data[6] & 0x10);
  922.  
  923.                 input_report_abs(input, ABS_TILT_X,
  924.                     ((data[7] << 1) & 0x7e) | (data[8] >> 7));
  925.                 input_report_abs(input, ABS_TILT_Y, data[8] & 0x7f);
  926.             } else {
  927.                 /* 2D mouse packet */
  928.                 input_report_key(input, BTN_LEFT,   data[8] & 0x04);
  929.                 input_report_key(input, BTN_MIDDLE, data[8] & 0x08);
  930.                 input_report_key(input, BTN_RIGHT,  data[8] & 0x10);
  931.                 input_report_rel(input, REL_WHEEL, (data[8] & 0x01)
  932.                          - ((data[8] & 0x02) >> 1));
  933.  
  934.                 /* I3 2D mouse side buttons */
  935.                 if (features->type >= INTUOS3S && features->type <= INTUOS3L) {
  936.                     input_report_key(input, BTN_SIDE,   data[8] & 0x40);
  937.                     input_report_key(input, BTN_EXTRA,  data[8] & 0x20);
  938.                 }
  939.             }
  940.         } else if ((features->type < INTUOS3S || features->type == INTUOS3L ||
  941.                 features->type == INTUOS4L || features->type == INTUOS5L ||
  942.                 features->type == INTUOSPL) &&
  943.                wacom->tool[idx] == BTN_TOOL_LENS) {
  944.             /* Lens cursor packets */
  945.             input_report_key(input, BTN_LEFT,   data[8] & 0x01);
  946.             input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
  947.             input_report_key(input, BTN_RIGHT,  data[8] & 0x04);
  948.             input_report_key(input, BTN_SIDE,   data[8] & 0x10);
  949.             input_report_key(input, BTN_EXTRA,  data[8] & 0x08);
  950.         }
  951.     }
  952.  
  953.     input_report_abs(input, ABS_MISC, wacom->id[idx]); /* report tool id */
  954.     input_report_key(input, wacom->tool[idx], 1);
  955.     input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
  956.     return 1;
  957. }
  958.  
  959. static int int_dist(int x1, int y1, int x2, int y2)
  960. {
  961.     int x = x2 - x1;
  962.     int y = y2 - y1;
  963.  
  964.     return int_sqrt(x*x + y*y);
  965. }
  966.  
  967. static void wacom_intuos_bt_process_data(struct wacom_wac *wacom,
  968.         unsigned char *data)
  969. {
  970.     memcpy(wacom->data, data, 10);
  971.     wacom_intuos_irq(wacom);
  972.  
  973.     input_sync(wacom->input);
  974.     if (wacom->pad_input)
  975.         input_sync(wacom->pad_input);
  976. }
  977.  
  978. static int wacom_intuos_bt_irq(struct wacom_wac *wacom, size_t len)
  979. {
  980.     unsigned char data[WACOM_PKGLEN_MAX];
  981.     int i = 1;
  982.     unsigned power_raw, battery_capacity, bat_charging, ps_connected;
  983.  
  984.     memcpy(data, wacom->data, len);
  985.  
  986.     switch (data[0]) {
  987.     case 0x04:
  988.         wacom_intuos_bt_process_data(wacom, data + i);
  989.         i += 10;
  990.         /* fall through */
  991.     case 0x03:
  992.         wacom_intuos_bt_process_data(wacom, data + i);
  993.         i += 10;
  994.         wacom_intuos_bt_process_data(wacom, data + i);
  995.         i += 10;
  996.         power_raw = data[i];
  997.         bat_charging = (power_raw & 0x08) ? 1 : 0;
  998.         ps_connected = (power_raw & 0x10) ? 1 : 0;
  999.         battery_capacity = batcap_i4[power_raw & 0x07];
  1000.         if ((wacom->battery_capacity != battery_capacity) ||
  1001.             (wacom->bat_charging != bat_charging) ||
  1002.             (wacom->ps_connected != ps_connected)) {
  1003.             wacom->battery_capacity = battery_capacity;
  1004.             wacom->bat_charging = bat_charging;
  1005.             wacom->ps_connected = ps_connected;
  1006.             wacom_notify_battery(wacom);
  1007.         }
  1008.  
  1009.         break;
  1010.     default:
  1011.         dev_dbg(wacom->input->dev.parent,
  1012.                 "Unknown report: %d,%d size:%zu\n",
  1013.                 data[0], data[1], len);
  1014.         return 0;
  1015.     }
  1016.     return 0;
  1017. }
  1018.  
  1019. static int wacom_24hdt_irq(struct wacom_wac *wacom)
  1020. {
  1021.     struct input_dev *input = wacom->input;
  1022.     unsigned char *data = wacom->data;
  1023.     int i;
  1024.     int current_num_contacts = data[61];
  1025.     int contacts_to_send = 0;
  1026.  
  1027.     /*
  1028.      * First packet resets the counter since only the first
  1029.      * packet in series will have non-zero current_num_contacts.
  1030.      */
  1031.     if (current_num_contacts)
  1032.         wacom->num_contacts_left = current_num_contacts;
  1033.  
  1034.     /* There are at most 4 contacts per packet */
  1035.     contacts_to_send = min(4, wacom->num_contacts_left);
  1036.  
  1037.     for (i = 0; i < contacts_to_send; i++) {
  1038.         int offset = (WACOM_BYTES_PER_24HDT_PACKET * i) + 1;
  1039.         bool touch = data[offset] & 0x1 && !wacom->shared->stylus_in_proximity;
  1040.         int slot = input_mt_get_slot_by_key(input, data[offset + 1]);
  1041.  
  1042.         if (slot < 0)
  1043.             continue;
  1044.         input_mt_slot(input, slot);
  1045.         input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
  1046.  
  1047.         if (touch) {
  1048.             int t_x = get_unaligned_le16(&data[offset + 2]);
  1049.             int c_x = get_unaligned_le16(&data[offset + 4]);
  1050.             int t_y = get_unaligned_le16(&data[offset + 6]);
  1051.             int c_y = get_unaligned_le16(&data[offset + 8]);
  1052.             int w = get_unaligned_le16(&data[offset + 10]);
  1053.             int h = get_unaligned_le16(&data[offset + 12]);
  1054.  
  1055.             input_report_abs(input, ABS_MT_POSITION_X, t_x);
  1056.             input_report_abs(input, ABS_MT_POSITION_Y, t_y);
  1057.             input_report_abs(input, ABS_MT_TOUCH_MAJOR, min(w,h));
  1058.             input_report_abs(input, ABS_MT_WIDTH_MAJOR, min(w, h) + int_dist(t_x, t_y, c_x, c_y));
  1059.             input_report_abs(input, ABS_MT_WIDTH_MINOR, min(w, h));
  1060.             input_report_abs(input, ABS_MT_ORIENTATION, w > h);
  1061.         }
  1062.     }
  1063.     input_mt_report_pointer_emulation(input, true);
  1064.  
  1065.     wacom->num_contacts_left -= contacts_to_send;
  1066.     if (wacom->num_contacts_left <= 0)
  1067.         wacom->num_contacts_left = 0;
  1068.  
  1069.     return 1;
  1070. }
  1071.  
  1072. static int wacom_mt_touch(struct wacom_wac *wacom)
  1073. {
  1074.     struct input_dev *input = wacom->input;
  1075.     unsigned char *data = wacom->data;
  1076.     int i;
  1077.     int current_num_contacts = data[2];
  1078.     int contacts_to_send = 0;
  1079.     int x_offset = 0;
  1080.  
  1081.     /* MTTPC does not support Height and Width */
  1082.     if (wacom->features.type == MTTPC || wacom->features.type == MTTPC_B)
  1083.         x_offset = -4;
  1084.  
  1085.     /*
  1086.      * First packet resets the counter since only the first
  1087.      * packet in series will have non-zero current_num_contacts.
  1088.      */
  1089.     if (current_num_contacts)
  1090.         wacom->num_contacts_left = current_num_contacts;
  1091.  
  1092.     /* There are at most 5 contacts per packet */
  1093.     contacts_to_send = min(5, wacom->num_contacts_left);
  1094.  
  1095.     for (i = 0; i < contacts_to_send; i++) {
  1096.         int offset = (WACOM_BYTES_PER_MT_PACKET + x_offset) * i + 3;
  1097.         bool touch = data[offset] & 0x1;
  1098.         int id = get_unaligned_le16(&data[offset + 1]);
  1099.         int slot = input_mt_get_slot_by_key(input, id);
  1100.  
  1101.         if (slot < 0)
  1102.             continue;
  1103.  
  1104.         input_mt_slot(input, slot);
  1105.         input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
  1106.         if (touch) {
  1107.             int x = get_unaligned_le16(&data[offset + x_offset + 7]);
  1108.             int y = get_unaligned_le16(&data[offset + x_offset + 9]);
  1109.             input_report_abs(input, ABS_MT_POSITION_X, x);
  1110.             input_report_abs(input, ABS_MT_POSITION_Y, y);
  1111.         }
  1112.     }
  1113.     input_mt_report_pointer_emulation(input, true);
  1114.  
  1115.     wacom->num_contacts_left -= contacts_to_send;
  1116.     if (wacom->num_contacts_left < 0)
  1117.         wacom->num_contacts_left = 0;
  1118.  
  1119.     return 1;
  1120. }
  1121.  
  1122. static int wacom_tpc_mt_touch(struct wacom_wac *wacom)
  1123. {
  1124.     struct input_dev *input = wacom->input;
  1125.     unsigned char *data = wacom->data;
  1126.     int contact_with_no_pen_down_count = 0;
  1127.     int i;
  1128.  
  1129.     for (i = 0; i < 2; i++) {
  1130.         int p = data[1] & (1 << i);
  1131.         bool touch = p && !wacom->shared->stylus_in_proximity;
  1132.  
  1133.         input_mt_slot(input, i);
  1134.         input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
  1135.         if (touch) {
  1136.             int x = le16_to_cpup((__le16 *)&data[i * 2 + 2]) & 0x7fff;
  1137.             int y = le16_to_cpup((__le16 *)&data[i * 2 + 6]) & 0x7fff;
  1138.  
  1139.             input_report_abs(input, ABS_MT_POSITION_X, x);
  1140.             input_report_abs(input, ABS_MT_POSITION_Y, y);
  1141.             contact_with_no_pen_down_count++;
  1142.         }
  1143.     }
  1144.     input_mt_report_pointer_emulation(input, true);
  1145.  
  1146.     /* keep touch state for pen event */
  1147.     wacom->shared->touch_down = (contact_with_no_pen_down_count > 0);
  1148.  
  1149.     return 1;
  1150. }
  1151.  
  1152. static int wacom_tpc_single_touch(struct wacom_wac *wacom, size_t len)
  1153. {
  1154.     unsigned char *data = wacom->data;
  1155.     struct input_dev *input = wacom->input;
  1156.     bool prox;
  1157.     int x = 0, y = 0;
  1158.  
  1159.     if (wacom->features.touch_max > 1 || len > WACOM_PKGLEN_TPC2FG)
  1160.         return 0;
  1161.  
  1162.     if (!wacom->shared->stylus_in_proximity) {
  1163.         if (len == WACOM_PKGLEN_TPC1FG) {
  1164.             prox = data[0] & 0x01;
  1165.             x = get_unaligned_le16(&data[1]);
  1166.             y = get_unaligned_le16(&data[3]);
  1167.         } else if (len == WACOM_PKGLEN_TPC1FG_B) {
  1168.             prox = data[2] & 0x01;
  1169.             x = get_unaligned_le16(&data[3]);
  1170.             y = get_unaligned_le16(&data[5]);
  1171.         } else {
  1172.             prox = data[1] & 0x01;
  1173.             x = le16_to_cpup((__le16 *)&data[2]);
  1174.             y = le16_to_cpup((__le16 *)&data[4]);
  1175.         }
  1176.     } else
  1177.         /* force touch out when pen is in prox */
  1178.         prox = 0;
  1179.  
  1180.     if (prox) {
  1181.         input_report_abs(input, ABS_X, x);
  1182.         input_report_abs(input, ABS_Y, y);
  1183.     }
  1184.     input_report_key(input, BTN_TOUCH, prox);
  1185.  
  1186.     /* keep touch state for pen events */
  1187.     wacom->shared->touch_down = prox;
  1188.  
  1189.     return 1;
  1190. }
  1191.  
  1192. static int wacom_tpc_pen(struct wacom_wac *wacom)
  1193. {
  1194.     unsigned char *data = wacom->data;
  1195.     struct input_dev *input = wacom->input;
  1196.     bool prox = data[1] & 0x20;
  1197.  
  1198.     if (!wacom->shared->stylus_in_proximity) /* first in prox */
  1199.         /* Going into proximity select tool */
  1200.         wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
  1201.  
  1202.     /* keep pen state for touch events */
  1203.     wacom->shared->stylus_in_proximity = prox;
  1204.  
  1205.     /* send pen events only when touch is up or forced out */
  1206.     if (!wacom->shared->touch_down) {
  1207.         input_report_key(input, BTN_STYLUS, data[1] & 0x02);
  1208.         input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
  1209.         input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
  1210.         input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
  1211.         input_report_abs(input, ABS_PRESSURE, ((data[7] & 0x07) << 8) | data[6]);
  1212.         input_report_key(input, BTN_TOUCH, data[1] & 0x05);
  1213.         input_report_key(input, wacom->tool[0], prox);
  1214.         return 1;
  1215.     }
  1216.  
  1217.     return 0;
  1218. }
  1219.  
  1220. static int wacom_tpc_irq(struct wacom_wac *wacom, size_t len)
  1221. {
  1222.     unsigned char *data = wacom->data;
  1223.  
  1224.     dev_dbg(wacom->input->dev.parent,
  1225.         "%s: received report #%d\n", __func__, data[0]);
  1226.  
  1227.     switch (len) {
  1228.     case WACOM_PKGLEN_TPC1FG:
  1229.         return wacom_tpc_single_touch(wacom, len);
  1230.  
  1231.     case WACOM_PKGLEN_TPC2FG:
  1232.         return wacom_tpc_mt_touch(wacom);
  1233.  
  1234.     case WACOM_PKGLEN_PENABLED:
  1235.         return wacom_tpc_pen(wacom);
  1236.  
  1237.     default:
  1238.         switch (data[0]) {
  1239.         case WACOM_REPORT_TPC1FG:
  1240.         case WACOM_REPORT_TPCHID:
  1241.         case WACOM_REPORT_TPCST:
  1242.         case WACOM_REPORT_TPC1FGE:
  1243.             return wacom_tpc_single_touch(wacom, len);
  1244.  
  1245.         case WACOM_REPORT_TPCMT:
  1246.         case WACOM_REPORT_TPCMT2:
  1247.             return wacom_mt_touch(wacom);
  1248.  
  1249.         case WACOM_REPORT_PENABLED:
  1250.             return wacom_tpc_pen(wacom);
  1251.         }
  1252.     }
  1253.  
  1254.     return 0;
  1255. }
  1256.  
  1257. static void wacom_map_usage(struct wacom *wacom, struct hid_usage *usage,
  1258.         struct hid_field *field, __u8 type, __u16 code, int fuzz)
  1259. {
  1260.     struct wacom_wac *wacom_wac = &wacom->wacom_wac;
  1261.     struct input_dev *input = wacom_wac->input;
  1262.     int fmin = field->logical_minimum;
  1263.     int fmax = field->logical_maximum;
  1264.  
  1265.     usage->type = type;
  1266.     usage->code = code;
  1267.  
  1268.     set_bit(type, input->evbit);
  1269.  
  1270.     switch (type) {
  1271.     case EV_ABS:
  1272.         input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
  1273.         input_abs_set_res(input, code,
  1274.                   hidinput_calc_abs_res(field, code));
  1275.         break;
  1276.     case EV_KEY:
  1277.         input_set_capability(input, EV_KEY, code);
  1278.         break;
  1279.     case EV_MSC:
  1280.         input_set_capability(input, EV_MSC, code);
  1281.         break;
  1282.     }
  1283. }
  1284.  
  1285. static void wacom_wac_pen_usage_mapping(struct hid_device *hdev,
  1286.         struct hid_field *field, struct hid_usage *usage)
  1287. {
  1288.     struct wacom *wacom = hid_get_drvdata(hdev);
  1289.  
  1290.     switch (usage->hid) {
  1291.     case HID_GD_X:
  1292.         wacom_map_usage(wacom, usage, field, EV_ABS, ABS_X, 4);
  1293.         break;
  1294.     case HID_GD_Y:
  1295.         wacom_map_usage(wacom, usage, field, EV_ABS, ABS_Y, 4);
  1296.         break;
  1297.     case HID_DG_TIPPRESSURE:
  1298.         wacom_map_usage(wacom, usage, field, EV_ABS, ABS_PRESSURE, 0);
  1299.         break;
  1300.     case HID_DG_INRANGE:
  1301.         wacom_map_usage(wacom, usage, field, EV_KEY, BTN_TOOL_PEN, 0);
  1302.         break;
  1303.     case HID_DG_INVERT:
  1304.         wacom_map_usage(wacom, usage, field, EV_KEY,
  1305.                 BTN_TOOL_RUBBER, 0);
  1306.         break;
  1307.     case HID_DG_ERASER:
  1308.     case HID_DG_TIPSWITCH:
  1309.         wacom_map_usage(wacom, usage, field, EV_KEY, BTN_TOUCH, 0);
  1310.         break;
  1311.     case HID_DG_BARRELSWITCH:
  1312.         wacom_map_usage(wacom, usage, field, EV_KEY, BTN_STYLUS, 0);
  1313.         break;
  1314.     case HID_DG_BARRELSWITCH2:
  1315.         wacom_map_usage(wacom, usage, field, EV_KEY, BTN_STYLUS2, 0);
  1316.         break;
  1317.     case HID_DG_TOOLSERIALNUMBER:
  1318.         wacom_map_usage(wacom, usage, field, EV_MSC, MSC_SERIAL, 0);
  1319.         break;
  1320.     }
  1321. }
  1322.  
  1323. static int wacom_wac_pen_event(struct hid_device *hdev, struct hid_field *field,
  1324.         struct hid_usage *usage, __s32 value)
  1325. {
  1326.     struct wacom *wacom = hid_get_drvdata(hdev);
  1327.     struct wacom_wac *wacom_wac = &wacom->wacom_wac;
  1328.     struct input_dev *input = wacom_wac->input;
  1329.  
  1330.     /* checking which Tool / tip switch to send */
  1331.     switch (usage->hid) {
  1332.     case HID_DG_INRANGE:
  1333.         wacom_wac->hid_data.inrange_state = value;
  1334.         return 0;
  1335.     case HID_DG_INVERT:
  1336.         wacom_wac->hid_data.invert_state = value;
  1337.         return 0;
  1338.     case HID_DG_ERASER:
  1339.     case HID_DG_TIPSWITCH:
  1340.         wacom_wac->hid_data.tipswitch |= value;
  1341.         return 0;
  1342.     }
  1343.  
  1344.     /* send pen events only when touch is up or forced out */
  1345.     if (!usage->type || wacom_wac->shared->touch_down)
  1346.         return 0;
  1347.  
  1348.     input_event(input, usage->type, usage->code, value);
  1349.  
  1350.     return 0;
  1351. }
  1352.  
  1353. static void wacom_wac_pen_report(struct hid_device *hdev,
  1354.         struct hid_report *report)
  1355. {
  1356.     struct wacom *wacom = hid_get_drvdata(hdev);
  1357.     struct wacom_wac *wacom_wac = &wacom->wacom_wac;
  1358.     struct input_dev *input = wacom_wac->input;
  1359.     bool prox = wacom_wac->hid_data.inrange_state;
  1360.  
  1361.     if (!wacom_wac->shared->stylus_in_proximity) /* first in prox */
  1362.         /* Going into proximity select tool */
  1363.         wacom_wac->tool[0] = wacom_wac->hid_data.invert_state ?
  1364.                         BTN_TOOL_RUBBER : BTN_TOOL_PEN;
  1365.  
  1366.     /* keep pen state for touch events */
  1367.     wacom_wac->shared->stylus_in_proximity = prox;
  1368.  
  1369.     /* send pen events only when touch is up or forced out */
  1370.     if (!wacom_wac->shared->touch_down) {
  1371.         input_report_key(input, BTN_TOUCH,
  1372.                 wacom_wac->hid_data.tipswitch);
  1373.         input_report_key(input, wacom_wac->tool[0], prox);
  1374.  
  1375.         wacom_wac->hid_data.tipswitch = false;
  1376.  
  1377.         input_sync(input);
  1378.     }
  1379. }
  1380.  
  1381. static void wacom_wac_finger_usage_mapping(struct hid_device *hdev,
  1382.         struct hid_field *field, struct hid_usage *usage)
  1383. {
  1384.     struct wacom *wacom = hid_get_drvdata(hdev);
  1385.     struct wacom_wac *wacom_wac = &wacom->wacom_wac;
  1386.     struct input_dev *input = wacom_wac->input;
  1387.     unsigned touch_max = wacom_wac->features.touch_max;
  1388.  
  1389.     switch (usage->hid) {
  1390.     case HID_GD_X:
  1391.         if (touch_max == 1)
  1392.             wacom_map_usage(wacom, usage, field, EV_ABS, ABS_X, 4);
  1393.         else
  1394.             wacom_map_usage(wacom, usage, field, EV_ABS,
  1395.                     ABS_MT_POSITION_X, 4);
  1396.         break;
  1397.     case HID_GD_Y:
  1398.         if (touch_max == 1)
  1399.             wacom_map_usage(wacom, usage, field, EV_ABS, ABS_Y, 4);
  1400.         else
  1401.             wacom_map_usage(wacom, usage, field, EV_ABS,
  1402.                     ABS_MT_POSITION_Y, 4);
  1403.         break;
  1404.     case HID_DG_CONTACTID:
  1405.         input_mt_init_slots(input, wacom_wac->features.touch_max,
  1406.             INPUT_MT_DIRECT);
  1407.         break;
  1408.     case HID_DG_INRANGE:
  1409.         break;
  1410.     case HID_DG_INVERT:
  1411.         break;
  1412.     case HID_DG_TIPSWITCH:
  1413.         wacom_map_usage(wacom, usage, field, EV_KEY, BTN_TOUCH, 0);
  1414.         break;
  1415.     }
  1416. }
  1417.  
  1418. static int wacom_wac_finger_event(struct hid_device *hdev,
  1419.         struct hid_field *field, struct hid_usage *usage, __s32 value)
  1420. {
  1421.     struct wacom *wacom = hid_get_drvdata(hdev);
  1422.     struct wacom_wac *wacom_wac = &wacom->wacom_wac;
  1423.  
  1424.     switch (usage->hid) {
  1425.     case HID_GD_X:
  1426.         wacom_wac->hid_data.x = value;
  1427.         break;
  1428.     case HID_GD_Y:
  1429.         wacom_wac->hid_data.y = value;
  1430.         break;
  1431.     case HID_DG_CONTACTID:
  1432.         wacom_wac->hid_data.id = value;
  1433.         break;
  1434.     case HID_DG_TIPSWITCH:
  1435.         wacom_wac->hid_data.tipswitch = value;
  1436.         break;
  1437.     }
  1438.  
  1439.  
  1440.     return 0;
  1441. }
  1442.  
  1443. static void wacom_wac_finger_mt_report(struct wacom_wac *wacom_wac,
  1444.         struct input_dev *input, bool touch)
  1445. {
  1446.     int slot;
  1447.     struct hid_data *hid_data = &wacom_wac->hid_data;
  1448.  
  1449.     slot = input_mt_get_slot_by_key(input, hid_data->id);
  1450.  
  1451.     input_mt_slot(input, slot);
  1452.     input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
  1453.     if (touch) {
  1454.         input_report_abs(input, ABS_MT_POSITION_X, hid_data->x);
  1455.         input_report_abs(input, ABS_MT_POSITION_Y, hid_data->y);
  1456.     }
  1457.     input_mt_sync_frame(input);
  1458. }
  1459.  
  1460. static void wacom_wac_finger_single_touch_report(struct wacom_wac *wacom_wac,
  1461.         struct input_dev *input, bool touch)
  1462. {
  1463.     struct hid_data *hid_data = &wacom_wac->hid_data;
  1464.  
  1465.     if (touch) {
  1466.         input_report_abs(input, ABS_X, hid_data->x);
  1467.         input_report_abs(input, ABS_Y, hid_data->y);
  1468.     }
  1469.     input_report_key(input, BTN_TOUCH, touch);
  1470. }
  1471.  
  1472. static void wacom_wac_finger_report(struct hid_device *hdev,
  1473.         struct hid_report *report)
  1474. {
  1475.     struct wacom *wacom = hid_get_drvdata(hdev);
  1476.     struct wacom_wac *wacom_wac = &wacom->wacom_wac;
  1477.     struct input_dev *input = wacom_wac->input;
  1478.     bool touch = wacom_wac->hid_data.tipswitch &&
  1479.              !wacom_wac->shared->stylus_in_proximity;
  1480.     unsigned touch_max = wacom_wac->features.touch_max;
  1481.  
  1482.     if (touch_max > 1)
  1483.         wacom_wac_finger_mt_report(wacom_wac, input, touch);
  1484.     else
  1485.         wacom_wac_finger_single_touch_report(wacom_wac, input, touch);
  1486.     input_sync(input);
  1487.  
  1488.     /* keep touch state for pen event */
  1489.     wacom_wac->shared->touch_down = touch;
  1490. }
  1491.  
  1492. #define WACOM_PEN_FIELD(f)  (((f)->logical == HID_DG_STYLUS) || \
  1493.                  ((f)->physical == HID_DG_STYLUS))
  1494. #define WACOM_FINGER_FIELD(f)   (((f)->logical == HID_DG_FINGER) || \
  1495.                  ((f)->physical == HID_DG_FINGER))
  1496.  
  1497. void wacom_wac_usage_mapping(struct hid_device *hdev,
  1498.         struct hid_field *field, struct hid_usage *usage)
  1499. {
  1500.     struct wacom *wacom = hid_get_drvdata(hdev);
  1501.     struct wacom_wac *wacom_wac = &wacom->wacom_wac;
  1502.     struct input_dev *input = wacom_wac->input;
  1503.  
  1504.     /* currently, only direct devices have proper hid report descriptors */
  1505.     __set_bit(INPUT_PROP_DIRECT, input->propbit);
  1506.  
  1507.     if (WACOM_PEN_FIELD(field))
  1508.         return wacom_wac_pen_usage_mapping(hdev, field, usage);
  1509.  
  1510.     if (WACOM_FINGER_FIELD(field))
  1511.         return wacom_wac_finger_usage_mapping(hdev, field, usage);
  1512. }
  1513.  
  1514. int wacom_wac_event(struct hid_device *hdev, struct hid_field *field,
  1515.         struct hid_usage *usage, __s32 value)
  1516. {
  1517.     struct wacom *wacom = hid_get_drvdata(hdev);
  1518.  
  1519.     if (wacom->wacom_wac.features.type != HID_GENERIC)
  1520.         return 0;
  1521.  
  1522.     if (WACOM_PEN_FIELD(field))
  1523.         return wacom_wac_pen_event(hdev, field, usage, value);
  1524.  
  1525.     if (WACOM_FINGER_FIELD(field))
  1526.         return wacom_wac_finger_event(hdev, field, usage, value);
  1527.  
  1528.     return 0;
  1529. }
  1530.  
  1531. void wacom_wac_report(struct hid_device *hdev, struct hid_report *report)
  1532. {
  1533.     struct wacom *wacom = hid_get_drvdata(hdev);
  1534.     struct wacom_wac *wacom_wac = &wacom->wacom_wac;
  1535.     struct hid_field *field = report->field[0];
  1536.  
  1537.     if (wacom_wac->features.type != HID_GENERIC)
  1538.         return;
  1539.  
  1540.     if (WACOM_PEN_FIELD(field))
  1541.         return wacom_wac_pen_report(hdev, report);
  1542.  
  1543.     if (WACOM_FINGER_FIELD(field))
  1544.         return wacom_wac_finger_report(hdev, report);
  1545. }
  1546.  
  1547. static int wacom_bpt_touch(struct wacom_wac *wacom)
  1548. {
  1549.     struct wacom_features *features = &wacom->features;
  1550.     struct input_dev *input = wacom->input;
  1551.     struct input_dev *pad_input = wacom->pad_input;
  1552.     unsigned char *data = wacom->data;
  1553.     int i;
  1554.  
  1555.     if (data[0] != 0x02)
  1556.         return 0;
  1557.  
  1558.     for (i = 0; i < 2; i++) {
  1559.         int offset = (data[1] & 0x80) ? (8 * i) : (9 * i);
  1560.         bool touch = data[offset + 3] & 0x80;
  1561.  
  1562.         /*
  1563.          * Touch events need to be disabled while stylus is
  1564.          * in proximity because user's hand is resting on touchpad
  1565.          * and sending unwanted events.  User expects tablet buttons
  1566.          * to continue working though.
  1567.          */
  1568.         touch = touch && !wacom->shared->stylus_in_proximity;
  1569.  
  1570.         input_mt_slot(input, i);
  1571.         input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
  1572.         if (touch) {
  1573.             int x = get_unaligned_be16(&data[offset + 3]) & 0x7ff;
  1574.             int y = get_unaligned_be16(&data[offset + 5]) & 0x7ff;
  1575.             if (features->quirks & WACOM_QUIRK_BBTOUCH_LOWRES) {
  1576.                 x <<= 5;
  1577.                 y <<= 5;
  1578.             }
  1579.             input_report_abs(input, ABS_MT_POSITION_X, x);
  1580.             input_report_abs(input, ABS_MT_POSITION_Y, y);
  1581.         }
  1582.     }
  1583.  
  1584.     input_mt_report_pointer_emulation(input, true);
  1585.  
  1586.     input_report_key(pad_input, BTN_LEFT, (data[1] & 0x08) != 0);
  1587.     input_report_key(pad_input, BTN_FORWARD, (data[1] & 0x04) != 0);
  1588.     input_report_key(pad_input, BTN_BACK, (data[1] & 0x02) != 0);
  1589.     input_report_key(pad_input, BTN_RIGHT, (data[1] & 0x01) != 0);
  1590.  
  1591.     return 1;
  1592. }
  1593.  
  1594. static void wacom_bpt3_touch_msg(struct wacom_wac *wacom, unsigned char *data)
  1595. {
  1596.     struct wacom_features *features = &wacom->features;
  1597.     struct input_dev *input = wacom->input;
  1598.     bool touch = data[1] & 0x80;
  1599.     int slot = input_mt_get_slot_by_key(input, data[0]);
  1600.  
  1601.     if (slot < 0)
  1602.         return;
  1603.  
  1604.     touch = touch && !wacom->shared->stylus_in_proximity;
  1605.  
  1606.     input_mt_slot(input, slot);
  1607.     input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
  1608.  
  1609.     if (touch) {
  1610.         int x = (data[2] << 4) | (data[4] >> 4);
  1611.         int y = (data[3] << 4) | (data[4] & 0x0f);
  1612.         int width, height;
  1613.  
  1614.         if (features->type >= INTUOSPS && features->type <= INTUOSPL) {
  1615.             width  = data[5] * 100;
  1616.             height = data[6] * 100;
  1617.         } else {
  1618.             /*
  1619.              * "a" is a scaled-down area which we assume is
  1620.              * roughly circular and which can be described as:
  1621.              * a=(pi*r^2)/C.
  1622.              */
  1623.             int a = data[5];
  1624.             int x_res = input_abs_get_res(input, ABS_MT_POSITION_X);
  1625.             int y_res = input_abs_get_res(input, ABS_MT_POSITION_Y);
  1626.             width = 2 * int_sqrt(a * WACOM_CONTACT_AREA_SCALE);
  1627.             height = width * y_res / x_res;
  1628.         }
  1629.  
  1630.         input_report_abs(input, ABS_MT_POSITION_X, x);
  1631.         input_report_abs(input, ABS_MT_POSITION_Y, y);
  1632.         input_report_abs(input, ABS_MT_TOUCH_MAJOR, width);
  1633.         input_report_abs(input, ABS_MT_TOUCH_MINOR, height);
  1634.     }
  1635. }
  1636.  
  1637. static void wacom_bpt3_button_msg(struct wacom_wac *wacom, unsigned char *data)
  1638. {
  1639.     struct input_dev *input = wacom->pad_input;
  1640.     struct wacom_features *features = &wacom->features;
  1641.  
  1642.     if (features->type == INTUOSHT) {
  1643.         input_report_key(input, BTN_LEFT, (data[1] & 0x02) != 0);
  1644.         input_report_key(input, BTN_BACK, (data[1] & 0x08) != 0);
  1645.     } else {
  1646.         input_report_key(input, BTN_BACK, (data[1] & 0x02) != 0);
  1647.         input_report_key(input, BTN_LEFT, (data[1] & 0x08) != 0);
  1648.     }
  1649.     input_report_key(input, BTN_FORWARD, (data[1] & 0x04) != 0);
  1650.     input_report_key(input, BTN_RIGHT, (data[1] & 0x01) != 0);
  1651. }
  1652.  
  1653. static int wacom_bpt3_touch(struct wacom_wac *wacom)
  1654. {
  1655.     struct input_dev *input = wacom->input;
  1656.     unsigned char *data = wacom->data;
  1657.     int count = data[1] & 0x07;
  1658.     int i;
  1659.  
  1660.     if (data[0] != 0x02)
  1661.         return 0;
  1662.  
  1663.     /* data has up to 7 fixed sized 8-byte messages starting at data[2] */
  1664.     for (i = 0; i < count; i++) {
  1665.         int offset = (8 * i) + 2;
  1666.         int msg_id = data[offset];
  1667.  
  1668.         if (msg_id >= 2 && msg_id <= 17)
  1669.             wacom_bpt3_touch_msg(wacom, data + offset);
  1670.         else if (msg_id == 128)
  1671.             wacom_bpt3_button_msg(wacom, data + offset);
  1672.  
  1673.     }
  1674.     input_mt_report_pointer_emulation(input, true);
  1675.  
  1676.     return 1;
  1677. }
  1678.  
  1679. static int wacom_bpt_pen(struct wacom_wac *wacom)
  1680. {
  1681.     struct wacom_features *features = &wacom->features;
  1682.     struct input_dev *input = wacom->input;
  1683.     unsigned char *data = wacom->data;
  1684.     int prox = 0, x = 0, y = 0, p = 0, d = 0, pen = 0, btn1 = 0, btn2 = 0;
  1685.  
  1686.     if (data[0] != WACOM_REPORT_PENABLED && data[0] != WACOM_REPORT_USB)
  1687.         return 0;
  1688.  
  1689.     if (data[0] == WACOM_REPORT_USB) {
  1690.         if (features->type == INTUOSHT && features->touch_max) {
  1691.             input_report_switch(wacom->shared->touch_input,
  1692.                         SW_MUTE_DEVICE, data[8] & 0x40);
  1693.             input_sync(wacom->shared->touch_input);
  1694.         }
  1695.         return 0;
  1696.     }
  1697.  
  1698.     prox = (data[1] & 0x20) == 0x20;
  1699.  
  1700.     /*
  1701.      * All reports shared between PEN and RUBBER tool must be
  1702.      * forced to a known starting value (zero) when transitioning to
  1703.      * out-of-prox.
  1704.      *
  1705.      * If not reset then, to userspace, it will look like lost events
  1706.      * if new tool comes in-prox with same values as previous tool sent.
  1707.      *
  1708.      * Hardware does report zero in most out-of-prox cases but not all.
  1709.      */
  1710.     if (prox) {
  1711.         if (!wacom->shared->stylus_in_proximity) {
  1712.             if (data[1] & 0x08) {
  1713.                 wacom->tool[0] = BTN_TOOL_RUBBER;
  1714.                 wacom->id[0] = ERASER_DEVICE_ID;
  1715.             } else {
  1716.                 wacom->tool[0] = BTN_TOOL_PEN;
  1717.                 wacom->id[0] = STYLUS_DEVICE_ID;
  1718.             }
  1719.             wacom->shared->stylus_in_proximity = true;
  1720.         }
  1721.         x = le16_to_cpup((__le16 *)&data[2]);
  1722.         y = le16_to_cpup((__le16 *)&data[4]);
  1723.         p = le16_to_cpup((__le16 *)&data[6]);
  1724.         /*
  1725.          * Convert distance from out prox to distance from tablet.
  1726.          * distance will be greater than distance_max once
  1727.          * touching and applying pressure; do not report negative
  1728.          * distance.
  1729.          */
  1730.         if (data[8] <= features->distance_max)
  1731.             d = features->distance_max - data[8];
  1732.  
  1733.         pen = data[1] & 0x01;
  1734.         btn1 = data[1] & 0x02;
  1735.         btn2 = data[1] & 0x04;
  1736.     }
  1737.  
  1738.     input_report_key(input, BTN_TOUCH, pen);
  1739.     input_report_key(input, BTN_STYLUS, btn1);
  1740.     input_report_key(input, BTN_STYLUS2, btn2);
  1741.  
  1742.     input_report_abs(input, ABS_X, x);
  1743.     input_report_abs(input, ABS_Y, y);
  1744.     input_report_abs(input, ABS_PRESSURE, p);
  1745.     input_report_abs(input, ABS_DISTANCE, d);
  1746.  
  1747.     if (!prox) {
  1748.         wacom->id[0] = 0;
  1749.         wacom->shared->stylus_in_proximity = false;
  1750.     }
  1751.  
  1752.     input_report_key(input, wacom->tool[0], prox); /* PEN or RUBBER */
  1753.     input_report_abs(input, ABS_MISC, wacom->id[0]); /* TOOL ID */
  1754.  
  1755.     return 1;
  1756. }
  1757.  
  1758. static int wacom_bpt_irq(struct wacom_wac *wacom, size_t len)
  1759. {
  1760.     if (len == WACOM_PKGLEN_BBTOUCH)
  1761.         return wacom_bpt_touch(wacom);
  1762.     else if (len == WACOM_PKGLEN_BBTOUCH3)
  1763.         return wacom_bpt3_touch(wacom);
  1764.     else if (len == WACOM_PKGLEN_BBFUN || len == WACOM_PKGLEN_BBPEN)
  1765.         return wacom_bpt_pen(wacom);
  1766.  
  1767.     return 0;
  1768. }
  1769.  
  1770. static int wacom_wireless_irq(struct wacom_wac *wacom, size_t len)
  1771. {
  1772.     unsigned char *data = wacom->data;
  1773.     int connected;
  1774.  
  1775.     if (len != WACOM_PKGLEN_WIRELESS || data[0] != WACOM_REPORT_WL)
  1776.         return 0;
  1777.  
  1778.     connected = data[1] & 0x01;
  1779.     if (connected) {
  1780.         int pid, battery, ps_connected;
  1781.  
  1782.         if ((wacom->shared->type == INTUOSHT) &&
  1783.                 wacom->shared->touch_max) {
  1784.             input_report_switch(wacom->shared->touch_input,
  1785.                     SW_MUTE_DEVICE, data[5] & 0x40);
  1786.             input_sync(wacom->shared->touch_input);
  1787.         }
  1788.  
  1789.         pid = get_unaligned_be16(&data[6]);
  1790.         battery = (data[5] & 0x3f) * 100 / 31;
  1791.         ps_connected = !!(data[5] & 0x80);
  1792.         if (wacom->pid != pid) {
  1793.             wacom->pid = pid;
  1794.             wacom_schedule_work(wacom);
  1795.         }
  1796.  
  1797.         if (wacom->shared->type &&
  1798.             (battery != wacom->battery_capacity ||
  1799.              ps_connected != wacom->ps_connected)) {
  1800.             wacom->battery_capacity = battery;
  1801.             wacom->ps_connected = ps_connected;
  1802.             wacom->bat_charging = ps_connected &&
  1803.                         wacom->battery_capacity < 100;
  1804.             wacom_notify_battery(wacom);
  1805.         }
  1806.     } else if (wacom->pid != 0) {
  1807.         /* disconnected while previously connected */
  1808.         wacom->pid = 0;
  1809.         wacom_schedule_work(wacom);
  1810.         wacom->battery_capacity = 0;
  1811.         wacom->bat_charging = 0;
  1812.         wacom->ps_connected = 0;
  1813.     }
  1814.  
  1815.     return 0;
  1816. }
  1817.  
  1818. void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
  1819. {
  1820.     bool sync;
  1821.  
  1822.     switch (wacom_wac->features.type) {
  1823.     case PENPARTNER:
  1824.         sync = wacom_penpartner_irq(wacom_wac);
  1825.         break;
  1826.  
  1827.     case PL:
  1828.         sync = wacom_pl_irq(wacom_wac);
  1829.         break;
  1830.  
  1831.     case WACOM_G4:
  1832.     case GRAPHIRE:
  1833.     case GRAPHIRE_BT:
  1834.     case WACOM_MO:
  1835.         sync = wacom_graphire_irq(wacom_wac);
  1836.         break;
  1837.  
  1838.     case PTU:
  1839.         sync = wacom_ptu_irq(wacom_wac);
  1840.         break;
  1841.  
  1842.     case DTU:
  1843.         sync = wacom_dtu_irq(wacom_wac);
  1844.         break;
  1845.  
  1846.     case DTUS:
  1847.         sync = wacom_dtus_irq(wacom_wac);
  1848.         break;
  1849.  
  1850.     case INTUOS:
  1851.     case INTUOS3S:
  1852.     case INTUOS3:
  1853.     case INTUOS3L:
  1854.     case INTUOS4S:
  1855.     case INTUOS4:
  1856.     case INTUOS4L:
  1857.     case CINTIQ:
  1858.     case WACOM_BEE:
  1859.     case WACOM_13HD:
  1860.     case WACOM_21UX2:
  1861.     case WACOM_22HD:
  1862.     case WACOM_24HD:
  1863.     case DTK:
  1864.     case CINTIQ_HYBRID:
  1865.         sync = wacom_intuos_irq(wacom_wac);
  1866.         break;
  1867.  
  1868.     case INTUOS4WL:
  1869.         sync = wacom_intuos_bt_irq(wacom_wac, len);
  1870.         break;
  1871.  
  1872.     case WACOM_24HDT:
  1873.         sync = wacom_24hdt_irq(wacom_wac);
  1874.         break;
  1875.  
  1876.     case INTUOS5S:
  1877.     case INTUOS5:
  1878.     case INTUOS5L:
  1879.     case INTUOSPS:
  1880.     case INTUOSPM:
  1881.     case INTUOSPL:
  1882.         if (len == WACOM_PKGLEN_BBTOUCH3)
  1883.             sync = wacom_bpt3_touch(wacom_wac);
  1884.         else
  1885.             sync = wacom_intuos_irq(wacom_wac);
  1886.         break;
  1887.  
  1888.     case TABLETPC:
  1889.     case TABLETPCE:
  1890.     case TABLETPC2FG:
  1891.     case MTSCREEN:
  1892.     case MTTPC:
  1893.     case MTTPC_B:
  1894.         sync = wacom_tpc_irq(wacom_wac, len);
  1895.         break;
  1896.  
  1897.     case BAMBOO_PT:
  1898.     case INTUOSHT:
  1899.         sync = wacom_bpt_irq(wacom_wac, len);
  1900.         break;
  1901.  
  1902.     case WIRELESS:
  1903.         sync = wacom_wireless_irq(wacom_wac, len);
  1904.         break;
  1905.  
  1906.     default:
  1907.         sync = false;
  1908.         break;
  1909.     }
  1910.  
  1911.     if (sync) {
  1912.         input_sync(wacom_wac->input);
  1913.         if (wacom_wac->pad_input)
  1914.             input_sync(wacom_wac->pad_input);
  1915.     }
  1916. }
  1917.  
  1918. static void wacom_setup_cintiq(struct wacom_wac *wacom_wac)
  1919. {
  1920.     struct input_dev *input_dev = wacom_wac->input;
  1921.  
  1922.     input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
  1923.  
  1924.     __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
  1925.     __set_bit(BTN_TOOL_PEN, input_dev->keybit);
  1926.     __set_bit(BTN_TOOL_BRUSH, input_dev->keybit);
  1927.     __set_bit(BTN_TOOL_PENCIL, input_dev->keybit);
  1928.     __set_bit(BTN_TOOL_AIRBRUSH, input_dev->keybit);
  1929.     __set_bit(BTN_STYLUS, input_dev->keybit);
  1930.     __set_bit(BTN_STYLUS2, input_dev->keybit);
  1931.  
  1932.     input_set_abs_params(input_dev, ABS_DISTANCE,
  1933.                  0, wacom_wac->features.distance_max, 0, 0);
  1934.     input_set_abs_params(input_dev, ABS_WHEEL, 0, 1023, 0, 0);
  1935.     input_set_abs_params(input_dev, ABS_TILT_X, 0, 127, 0, 0);
  1936.     input_set_abs_params(input_dev, ABS_TILT_Y, 0, 127, 0, 0);
  1937. }
  1938.  
  1939. static void wacom_setup_intuos(struct wacom_wac *wacom_wac)
  1940. {
  1941.     struct input_dev *input_dev = wacom_wac->input;
  1942.  
  1943.     input_set_capability(input_dev, EV_REL, REL_WHEEL);
  1944.  
  1945.     wacom_setup_cintiq(wacom_wac);
  1946.  
  1947.     __set_bit(BTN_LEFT, input_dev->keybit);
  1948.     __set_bit(BTN_RIGHT, input_dev->keybit);
  1949.     __set_bit(BTN_MIDDLE, input_dev->keybit);
  1950.     __set_bit(BTN_SIDE, input_dev->keybit);
  1951.     __set_bit(BTN_EXTRA, input_dev->keybit);
  1952.     __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
  1953.     __set_bit(BTN_TOOL_LENS, input_dev->keybit);
  1954.  
  1955.     input_set_abs_params(input_dev, ABS_RZ, -900, 899, 0, 0);
  1956.     input_set_abs_params(input_dev, ABS_THROTTLE, -1023, 1023, 0, 0);
  1957. }
  1958.  
  1959. void wacom_setup_device_quirks(struct wacom_features *features)
  1960. {
  1961.  
  1962.     /* touch device found but size is not defined. use default */
  1963.     if (features->device_type == BTN_TOOL_FINGER && !features->x_max) {
  1964.         features->x_max = 1023;
  1965.         features->y_max = 1023;
  1966.     }
  1967.  
  1968.     /* these device have multiple inputs */
  1969.     if (features->type >= WIRELESS ||
  1970.         (features->type >= INTUOS5S && features->type <= INTUOSHT) ||
  1971.         (features->oVid && features->oPid))
  1972.         features->quirks |= WACOM_QUIRK_MULTI_INPUT;
  1973.  
  1974.     /* quirk for bamboo touch with 2 low res touches */
  1975.     if (features->type == BAMBOO_PT &&
  1976.         features->pktlen == WACOM_PKGLEN_BBTOUCH) {
  1977.         features->x_max <<= 5;
  1978.         features->y_max <<= 5;
  1979.         features->x_fuzz <<= 5;
  1980.         features->y_fuzz <<= 5;
  1981.         features->quirks |= WACOM_QUIRK_BBTOUCH_LOWRES;
  1982.     }
  1983.  
  1984.     if (features->type == WIRELESS) {
  1985.  
  1986.         /* monitor never has input and pen/touch have delayed create */
  1987.         features->quirks |= WACOM_QUIRK_NO_INPUT;
  1988.  
  1989.         /* must be monitor interface if no device_type set */
  1990.         if (!features->device_type) {
  1991.             features->quirks |= WACOM_QUIRK_MONITOR;
  1992.             features->quirks |= WACOM_QUIRK_BATTERY;
  1993.         }
  1994.     }
  1995. }
  1996.  
  1997. static void wacom_abs_set_axis(struct input_dev *input_dev,
  1998.                    struct wacom_wac *wacom_wac)
  1999. {
  2000.     struct wacom_features *features = &wacom_wac->features;
  2001.  
  2002.     if (features->device_type == BTN_TOOL_PEN) {
  2003.         input_set_abs_params(input_dev, ABS_X, features->x_min,
  2004.                      features->x_max, features->x_fuzz, 0);
  2005.         input_set_abs_params(input_dev, ABS_Y, features->y_min,
  2006.                      features->y_max, features->y_fuzz, 0);
  2007.         input_set_abs_params(input_dev, ABS_PRESSURE, 0,
  2008.             features->pressure_max, features->pressure_fuzz, 0);
  2009.  
  2010.         /* penabled devices have fixed resolution for each model */
  2011.         input_abs_set_res(input_dev, ABS_X, features->x_resolution);
  2012.         input_abs_set_res(input_dev, ABS_Y, features->y_resolution);
  2013.     } else {
  2014.         if (features->touch_max == 1) {
  2015.             input_set_abs_params(input_dev, ABS_X, 0,
  2016.                 features->x_max, features->x_fuzz, 0);
  2017.             input_set_abs_params(input_dev, ABS_Y, 0,
  2018.                 features->y_max, features->y_fuzz, 0);
  2019.             input_abs_set_res(input_dev, ABS_X,
  2020.                       features->x_resolution);
  2021.             input_abs_set_res(input_dev, ABS_Y,
  2022.                       features->y_resolution);
  2023.         }
  2024.  
  2025.         if (features->touch_max > 1) {
  2026.             input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
  2027.                 features->x_max, features->x_fuzz, 0);
  2028.             input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
  2029.                 features->y_max, features->y_fuzz, 0);
  2030.             input_abs_set_res(input_dev, ABS_MT_POSITION_X,
  2031.                       features->x_resolution);
  2032.             input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
  2033.                       features->y_resolution);
  2034.         }
  2035.     }
  2036. }
  2037.  
  2038. int wacom_setup_input_capabilities(struct input_dev *input_dev,
  2039.                    struct wacom_wac *wacom_wac)
  2040. {
  2041.     struct wacom_features *features = &wacom_wac->features;
  2042.  
  2043.     input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
  2044.  
  2045.     if (features->type == HID_GENERIC)
  2046.         /* setup has already been done */
  2047.         return 0;
  2048.  
  2049.     __set_bit(BTN_TOUCH, input_dev->keybit);
  2050.     __set_bit(ABS_MISC, input_dev->absbit);
  2051.  
  2052.     wacom_abs_set_axis(input_dev, wacom_wac);
  2053.  
  2054.     switch (features->type) {
  2055.     case WACOM_MO:
  2056.         input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
  2057.         /* fall through */
  2058.  
  2059.     case WACOM_G4:
  2060.         /* fall through */
  2061.  
  2062.     case GRAPHIRE:
  2063.         input_set_capability(input_dev, EV_REL, REL_WHEEL);
  2064.  
  2065.         __set_bit(BTN_LEFT, input_dev->keybit);
  2066.         __set_bit(BTN_RIGHT, input_dev->keybit);
  2067.         __set_bit(BTN_MIDDLE, input_dev->keybit);
  2068.  
  2069.         __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
  2070.         __set_bit(BTN_TOOL_PEN, input_dev->keybit);
  2071.         __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
  2072.         __set_bit(BTN_STYLUS, input_dev->keybit);
  2073.         __set_bit(BTN_STYLUS2, input_dev->keybit);
  2074.  
  2075.         __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
  2076.         break;
  2077.  
  2078.     case GRAPHIRE_BT:
  2079.         __clear_bit(ABS_MISC, input_dev->absbit);
  2080.         input_set_abs_params(input_dev, ABS_DISTANCE, 0,
  2081.                           features->distance_max,
  2082.                           0, 0);
  2083.  
  2084.         input_set_capability(input_dev, EV_REL, REL_WHEEL);
  2085.  
  2086.         __set_bit(BTN_LEFT, input_dev->keybit);
  2087.         __set_bit(BTN_RIGHT, input_dev->keybit);
  2088.         __set_bit(BTN_MIDDLE, input_dev->keybit);
  2089.  
  2090.         __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
  2091.         __set_bit(BTN_TOOL_PEN, input_dev->keybit);
  2092.         __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
  2093.         __set_bit(BTN_STYLUS, input_dev->keybit);
  2094.         __set_bit(BTN_STYLUS2, input_dev->keybit);
  2095.  
  2096.         __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
  2097.         break;
  2098.  
  2099.     case WACOM_24HD:
  2100.         input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
  2101.         input_set_abs_params(input_dev, ABS_THROTTLE, 0, 71, 0, 0);
  2102.         /* fall through */
  2103.  
  2104.     case DTK:
  2105.         __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
  2106.  
  2107.         wacom_setup_cintiq(wacom_wac);
  2108.         break;
  2109.  
  2110.     case WACOM_22HD:
  2111.     case WACOM_21UX2:
  2112.     case WACOM_BEE:
  2113.     case CINTIQ:
  2114.         input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
  2115.  
  2116.         __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
  2117.  
  2118.         wacom_setup_cintiq(wacom_wac);
  2119.         break;
  2120.  
  2121.     case WACOM_13HD:
  2122.         input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
  2123.         __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
  2124.         wacom_setup_cintiq(wacom_wac);
  2125.         break;
  2126.  
  2127.     case INTUOS3:
  2128.     case INTUOS3L:
  2129.     case INTUOS3S:
  2130.         input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
  2131.         /* fall through */
  2132.  
  2133.     case INTUOS:
  2134.         __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
  2135.  
  2136.         wacom_setup_intuos(wacom_wac);
  2137.         break;
  2138.  
  2139.     case INTUOS5:
  2140.     case INTUOS5L:
  2141.     case INTUOSPM:
  2142.     case INTUOSPL:
  2143.     case INTUOS5S:
  2144.     case INTUOSPS:
  2145.         __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
  2146.  
  2147.         if (features->device_type == BTN_TOOL_PEN) {
  2148.             input_set_abs_params(input_dev, ABS_DISTANCE, 0,
  2149.                           features->distance_max,
  2150.                           0, 0);
  2151.  
  2152.             input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
  2153.  
  2154.             wacom_setup_intuos(wacom_wac);
  2155.         } else if (features->device_type == BTN_TOOL_FINGER) {
  2156.             __clear_bit(ABS_MISC, input_dev->absbit);
  2157.  
  2158.             input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
  2159.                                  0, features->x_max, 0, 0);
  2160.             input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR,
  2161.                                  0, features->y_max, 0, 0);
  2162.             input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_POINTER);
  2163.         }
  2164.         break;
  2165.  
  2166.     case INTUOS4:
  2167.     case INTUOS4WL:
  2168.     case INTUOS4L:
  2169.     case INTUOS4S:
  2170.         input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
  2171.         wacom_setup_intuos(wacom_wac);
  2172.  
  2173.         __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
  2174.         break;
  2175.  
  2176.     case WACOM_24HDT:
  2177.         if (features->device_type == BTN_TOOL_FINGER) {
  2178.             input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, features->x_max, 0, 0);
  2179.             input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, features->x_max, 0, 0);
  2180.             input_set_abs_params(input_dev, ABS_MT_WIDTH_MINOR, 0, features->y_max, 0, 0);
  2181.             input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
  2182.         }
  2183.         /* fall through */
  2184.  
  2185.     case MTSCREEN:
  2186.     case MTTPC:
  2187.     case MTTPC_B:
  2188.     case TABLETPC2FG:
  2189.         if (features->device_type == BTN_TOOL_FINGER && features->touch_max > 1)
  2190.             input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_DIRECT);
  2191.         /* fall through */
  2192.  
  2193.     case TABLETPC:
  2194.     case TABLETPCE:
  2195.         __clear_bit(ABS_MISC, input_dev->absbit);
  2196.  
  2197.         __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
  2198.  
  2199.         if (features->device_type != BTN_TOOL_PEN)
  2200.             break;  /* no need to process stylus stuff */
  2201.  
  2202.         /* fall through */
  2203.  
  2204.     case DTUS:
  2205.     case PL:
  2206.     case DTU:
  2207.         __set_bit(BTN_TOOL_PEN, input_dev->keybit);
  2208.         __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
  2209.         __set_bit(BTN_STYLUS, input_dev->keybit);
  2210.         __set_bit(BTN_STYLUS2, input_dev->keybit);
  2211.  
  2212.         __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
  2213.         break;
  2214.  
  2215.     case PTU:
  2216.         __set_bit(BTN_STYLUS2, input_dev->keybit);
  2217.         /* fall through */
  2218.  
  2219.     case PENPARTNER:
  2220.         __set_bit(BTN_TOOL_PEN, input_dev->keybit);
  2221.         __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
  2222.         __set_bit(BTN_STYLUS, input_dev->keybit);
  2223.  
  2224.         __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
  2225.         break;
  2226.  
  2227.     case INTUOSHT:
  2228.         if (features->touch_max &&
  2229.             features->device_type == BTN_TOOL_FINGER) {
  2230.             input_dev->evbit[0] |= BIT_MASK(EV_SW);
  2231.             __set_bit(SW_MUTE_DEVICE, input_dev->swbit);
  2232.         }
  2233.         /* fall through */
  2234.  
  2235.     case BAMBOO_PT:
  2236.         __clear_bit(ABS_MISC, input_dev->absbit);
  2237.  
  2238.         if (features->device_type == BTN_TOOL_FINGER) {
  2239.  
  2240.             if (features->touch_max) {
  2241.                 if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
  2242.                     input_set_abs_params(input_dev,
  2243.                              ABS_MT_TOUCH_MAJOR,
  2244.                              0, features->x_max, 0, 0);
  2245.                     input_set_abs_params(input_dev,
  2246.                              ABS_MT_TOUCH_MINOR,
  2247.                              0, features->y_max, 0, 0);
  2248.                 }
  2249.                 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_POINTER);
  2250.             } else {
  2251.                 /* buttons/keys only interface */
  2252.                 __clear_bit(ABS_X, input_dev->absbit);
  2253.                 __clear_bit(ABS_Y, input_dev->absbit);
  2254.                 __clear_bit(BTN_TOUCH, input_dev->keybit);
  2255.             }
  2256.         } else if (features->device_type == BTN_TOOL_PEN) {
  2257.             __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
  2258.             __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
  2259.             __set_bit(BTN_TOOL_PEN, input_dev->keybit);
  2260.             __set_bit(BTN_STYLUS, input_dev->keybit);
  2261.             __set_bit(BTN_STYLUS2, input_dev->keybit);
  2262.             input_set_abs_params(input_dev, ABS_DISTANCE, 0,
  2263.                           features->distance_max,
  2264.                           0, 0);
  2265.         }
  2266.         break;
  2267.  
  2268.     case CINTIQ_HYBRID:
  2269.         input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
  2270.         __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
  2271.  
  2272.         wacom_setup_cintiq(wacom_wac);
  2273.         break;
  2274.     }
  2275.     return 0;
  2276. }
  2277.  
  2278. int wacom_setup_pad_input_capabilities(struct input_dev *input_dev,
  2279.                    struct wacom_wac *wacom_wac)
  2280. {
  2281.     struct wacom_features *features = &wacom_wac->features;
  2282.     int i;
  2283.  
  2284.     input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
  2285.  
  2286.     /* kept for making legacy xf86-input-wacom working with the wheels */
  2287.     __set_bit(ABS_MISC, input_dev->absbit);
  2288.  
  2289.     /* kept for making legacy xf86-input-wacom accepting the pad */
  2290.     input_set_abs_params(input_dev, ABS_X, 0, 1, 0, 0);
  2291.     input_set_abs_params(input_dev, ABS_Y, 0, 1, 0, 0);
  2292.  
  2293.     /* kept for making udev and libwacom accepting the pad */
  2294.     __set_bit(BTN_STYLUS, input_dev->keybit);
  2295.  
  2296.     switch (features->type) {
  2297.     case GRAPHIRE_BT:
  2298.         __set_bit(BTN_0, input_dev->keybit);
  2299.         __set_bit(BTN_1, input_dev->keybit);
  2300.         break;
  2301.  
  2302.     case WACOM_MO:
  2303.         __set_bit(BTN_BACK, input_dev->keybit);
  2304.         __set_bit(BTN_LEFT, input_dev->keybit);
  2305.         __set_bit(BTN_FORWARD, input_dev->keybit);
  2306.         __set_bit(BTN_RIGHT, input_dev->keybit);
  2307.         input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
  2308.         break;
  2309.  
  2310.     case WACOM_G4:
  2311.         __set_bit(BTN_BACK, input_dev->keybit);
  2312.         __set_bit(BTN_LEFT, input_dev->keybit);
  2313.         __set_bit(BTN_FORWARD, input_dev->keybit);
  2314.         __set_bit(BTN_RIGHT, input_dev->keybit);
  2315.         input_set_capability(input_dev, EV_REL, REL_WHEEL);
  2316.         break;
  2317.  
  2318.     case WACOM_24HD:
  2319.         __set_bit(BTN_A, input_dev->keybit);
  2320.         __set_bit(BTN_B, input_dev->keybit);
  2321.         __set_bit(BTN_C, input_dev->keybit);
  2322.         __set_bit(BTN_X, input_dev->keybit);
  2323.         __set_bit(BTN_Y, input_dev->keybit);
  2324.         __set_bit(BTN_Z, input_dev->keybit);
  2325.  
  2326.         for (i = 0; i < 10; i++)
  2327.             __set_bit(BTN_0 + i, input_dev->keybit);
  2328.  
  2329.         __set_bit(KEY_PROG1, input_dev->keybit);
  2330.         __set_bit(KEY_PROG2, input_dev->keybit);
  2331.         __set_bit(KEY_PROG3, input_dev->keybit);
  2332.  
  2333.         input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
  2334.         input_set_abs_params(input_dev, ABS_THROTTLE, 0, 71, 0, 0);
  2335.         break;
  2336.  
  2337.     case DTK:
  2338.         for (i = 0; i < 6; i++)
  2339.             __set_bit(BTN_0 + i, input_dev->keybit);
  2340.  
  2341.         break;
  2342.  
  2343.     case WACOM_22HD:
  2344.         __set_bit(KEY_PROG1, input_dev->keybit);
  2345.         __set_bit(KEY_PROG2, input_dev->keybit);
  2346.         __set_bit(KEY_PROG3, input_dev->keybit);
  2347.         /* fall through */
  2348.  
  2349.     case WACOM_21UX2:
  2350.         __set_bit(BTN_A, input_dev->keybit);
  2351.         __set_bit(BTN_B, input_dev->keybit);
  2352.         __set_bit(BTN_C, input_dev->keybit);
  2353.         __set_bit(BTN_X, input_dev->keybit);
  2354.         __set_bit(BTN_Y, input_dev->keybit);
  2355.         __set_bit(BTN_Z, input_dev->keybit);
  2356.         __set_bit(BTN_BASE, input_dev->keybit);
  2357.         __set_bit(BTN_BASE2, input_dev->keybit);
  2358.         /* fall through */
  2359.  
  2360.     case WACOM_BEE:
  2361.         __set_bit(BTN_8, input_dev->keybit);
  2362.         __set_bit(BTN_9, input_dev->keybit);
  2363.         /* fall through */
  2364.  
  2365.     case CINTIQ:
  2366.         for (i = 0; i < 8; i++)
  2367.             __set_bit(BTN_0 + i, input_dev->keybit);
  2368.  
  2369.         input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
  2370.         input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
  2371.         break;
  2372.  
  2373.     case WACOM_13HD:
  2374.         for (i = 0; i < 9; i++)
  2375.             __set_bit(BTN_0 + i, input_dev->keybit);
  2376.  
  2377.         input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
  2378.         break;
  2379.  
  2380.     case INTUOS3:
  2381.     case INTUOS3L:
  2382.         __set_bit(BTN_4, input_dev->keybit);
  2383.         __set_bit(BTN_5, input_dev->keybit);
  2384.         __set_bit(BTN_6, input_dev->keybit);
  2385.         __set_bit(BTN_7, input_dev->keybit);
  2386.  
  2387.         input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
  2388.         /* fall through */
  2389.  
  2390.     case INTUOS3S:
  2391.         __set_bit(BTN_0, input_dev->keybit);
  2392.         __set_bit(BTN_1, input_dev->keybit);
  2393.         __set_bit(BTN_2, input_dev->keybit);
  2394.         __set_bit(BTN_3, input_dev->keybit);
  2395.  
  2396.         input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
  2397.         break;
  2398.  
  2399.     case INTUOS5:
  2400.     case INTUOS5L:
  2401.     case INTUOSPM:
  2402.     case INTUOSPL:
  2403.         __set_bit(BTN_7, input_dev->keybit);
  2404.         __set_bit(BTN_8, input_dev->keybit);
  2405.         /* fall through */
  2406.  
  2407.     case INTUOS5S:
  2408.     case INTUOSPS:
  2409.         /* touch interface does not have the pad device */
  2410.         if (features->device_type != BTN_TOOL_PEN)
  2411.             return 1;
  2412.  
  2413.         for (i = 0; i < 7; i++)
  2414.             __set_bit(BTN_0 + i, input_dev->keybit);
  2415.  
  2416.         input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
  2417.         break;
  2418.  
  2419.     case INTUOS4WL:
  2420.         /*
  2421.          * For Bluetooth devices, the udev rule does not work correctly
  2422.          * for pads unless we add a stylus capability, which forces
  2423.          * ID_INPUT_TABLET to be set.
  2424.          */
  2425.         __set_bit(BTN_STYLUS, input_dev->keybit);
  2426.         /* fall through */
  2427.  
  2428.     case INTUOS4:
  2429.     case INTUOS4L:
  2430.         __set_bit(BTN_7, input_dev->keybit);
  2431.         __set_bit(BTN_8, input_dev->keybit);
  2432.         /* fall through */
  2433.  
  2434.     case INTUOS4S:
  2435.         for (i = 0; i < 7; i++)
  2436.             __set_bit(BTN_0 + i, input_dev->keybit);
  2437.  
  2438.         input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
  2439.         break;
  2440.  
  2441.     case CINTIQ_HYBRID:
  2442.         for (i = 0; i < 9; i++)
  2443.             __set_bit(BTN_0 + i, input_dev->keybit);
  2444.  
  2445.         break;
  2446.  
  2447.     case DTUS:
  2448.         for (i = 0; i < 4; i++)
  2449.             __set_bit(BTN_0 + i, input_dev->keybit);
  2450.         break;
  2451.  
  2452.     case INTUOSHT:
  2453.     case BAMBOO_PT:
  2454.         /* pad device is on the touch interface */
  2455.         if (features->device_type != BTN_TOOL_FINGER)
  2456.             return 1;
  2457.  
  2458.         __clear_bit(ABS_MISC, input_dev->absbit);
  2459.  
  2460.         __set_bit(BTN_LEFT, input_dev->keybit);
  2461.         __set_bit(BTN_FORWARD, input_dev->keybit);
  2462.         __set_bit(BTN_BACK, input_dev->keybit);
  2463.         __set_bit(BTN_RIGHT, input_dev->keybit);
  2464.  
  2465.         break;
  2466.  
  2467.     default:
  2468.         /* no pad supported */
  2469.         return 1;
  2470.     }
  2471.     return 0;
  2472. }
  2473.  
  2474. static const struct wacom_features wacom_features_0x00 =
  2475.     { "Wacom Penpartner", 5040, 3780, 255, 0,
  2476.       PENPARTNER, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
  2477. static const struct wacom_features wacom_features_0x10 =
  2478.     { "Wacom Graphire", 10206, 7422, 511, 63,
  2479.       GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
  2480. static const struct wacom_features wacom_features_0x81 =
  2481.     { "Wacom Graphire BT", 16704, 12064, 511, 32,
  2482.       GRAPHIRE_BT, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
  2483. static const struct wacom_features wacom_features_0x11 =
  2484.     { "Wacom Graphire2 4x5", 10206, 7422, 511, 63,
  2485.       GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
  2486. static const struct wacom_features wacom_features_0x12 =
  2487.     { "Wacom Graphire2 5x7", 13918, 10206, 511, 63,
  2488.       GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
  2489. static const struct wacom_features wacom_features_0x13 =
  2490.     { "Wacom Graphire3", 10208, 7424, 511, 63,
  2491.       GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
  2492. static const struct wacom_features wacom_features_0x14 =
  2493.     { "Wacom Graphire3 6x8", 16704, 12064, 511, 63,
  2494.       GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
  2495. static const struct wacom_features wacom_features_0x15 =
  2496.     { "Wacom Graphire4 4x5", 10208, 7424, 511, 63,
  2497.       WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
  2498. static const struct wacom_features wacom_features_0x16 =
  2499.     { "Wacom Graphire4 6x8", 16704, 12064, 511, 63,
  2500.       WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
  2501. static const struct wacom_features wacom_features_0x17 =
  2502.     { "Wacom BambooFun 4x5", 14760, 9225, 511, 63,
  2503.       WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2504. static const struct wacom_features wacom_features_0x18 =
  2505.     { "Wacom BambooFun 6x8", 21648, 13530, 511, 63,
  2506.       WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2507. static const struct wacom_features wacom_features_0x19 =
  2508.     { "Wacom Bamboo1 Medium", 16704, 12064, 511, 63,
  2509.       GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
  2510. static const struct wacom_features wacom_features_0x60 =
  2511.     { "Wacom Volito", 5104, 3712, 511, 63,
  2512.       GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
  2513. static const struct wacom_features wacom_features_0x61 =
  2514.     { "Wacom PenStation2", 3250, 2320, 255, 63,
  2515.       GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
  2516. static const struct wacom_features wacom_features_0x62 =
  2517.     { "Wacom Volito2 4x5", 5104, 3712, 511, 63,
  2518.       GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
  2519. static const struct wacom_features wacom_features_0x63 =
  2520.     { "Wacom Volito2 2x3", 3248, 2320, 511, 63,
  2521.       GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
  2522. static const struct wacom_features wacom_features_0x64 =
  2523.     { "Wacom PenPartner2", 3250, 2320, 511, 63,
  2524.       GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
  2525. static const struct wacom_features wacom_features_0x65 =
  2526.     { "Wacom Bamboo", 14760, 9225, 511, 63,
  2527.       WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2528. static const struct wacom_features wacom_features_0x69 =
  2529.     { "Wacom Bamboo1", 5104, 3712, 511, 63,
  2530.       GRAPHIRE, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
  2531. static const struct wacom_features wacom_features_0x6A =
  2532.     { "Wacom Bamboo1 4x6", 14760, 9225, 1023, 63,
  2533.       GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2534. static const struct wacom_features wacom_features_0x6B =
  2535.     { "Wacom Bamboo1 5x8", 21648, 13530, 1023, 63,
  2536.       GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2537. static const struct wacom_features wacom_features_0x20 =
  2538.     { "Wacom Intuos 4x5", 12700, 10600, 1023, 31,
  2539.       INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2540. static const struct wacom_features wacom_features_0x21 =
  2541.     { "Wacom Intuos 6x8", 20320, 16240, 1023, 31,
  2542.       INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2543. static const struct wacom_features wacom_features_0x22 =
  2544.     { "Wacom Intuos 9x12", 30480, 24060, 1023, 31,
  2545.       INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2546. static const struct wacom_features wacom_features_0x23 =
  2547.     { "Wacom Intuos 12x12", 30480, 31680, 1023, 31,
  2548.       INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2549. static const struct wacom_features wacom_features_0x24 =
  2550.     { "Wacom Intuos 12x18", 45720, 31680, 1023, 31,
  2551.       INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2552. static const struct wacom_features wacom_features_0x30 =
  2553.     { "Wacom PL400", 5408, 4056, 255, 0,
  2554.       PL, WACOM_PL_RES, WACOM_PL_RES };
  2555. static const struct wacom_features wacom_features_0x31 =
  2556.     { "Wacom PL500", 6144, 4608, 255, 0,
  2557.       PL, WACOM_PL_RES, WACOM_PL_RES };
  2558. static const struct wacom_features wacom_features_0x32 =
  2559.     { "Wacom PL600", 6126, 4604, 255, 0,
  2560.       PL, WACOM_PL_RES, WACOM_PL_RES };
  2561. static const struct wacom_features wacom_features_0x33 =
  2562.     { "Wacom PL600SX", 6260, 5016, 255, 0,
  2563.       PL, WACOM_PL_RES, WACOM_PL_RES };
  2564. static const struct wacom_features wacom_features_0x34 =
  2565.     { "Wacom PL550", 6144, 4608, 511, 0,
  2566.       PL, WACOM_PL_RES, WACOM_PL_RES };
  2567. static const struct wacom_features wacom_features_0x35 =
  2568.     { "Wacom PL800", 7220, 5780, 511, 0,
  2569.       PL, WACOM_PL_RES, WACOM_PL_RES };
  2570. static const struct wacom_features wacom_features_0x37 =
  2571.     { "Wacom PL700", 6758, 5406, 511, 0,
  2572.       PL, WACOM_PL_RES, WACOM_PL_RES };
  2573. static const struct wacom_features wacom_features_0x38 =
  2574.     { "Wacom PL510", 6282, 4762, 511, 0,
  2575.       PL, WACOM_PL_RES, WACOM_PL_RES };
  2576. static const struct wacom_features wacom_features_0x39 =
  2577.     { "Wacom DTU710", 34080, 27660, 511, 0,
  2578.       PL, WACOM_PL_RES, WACOM_PL_RES };
  2579. static const struct wacom_features wacom_features_0xC4 =
  2580.     { "Wacom DTF521", 6282, 4762, 511, 0,
  2581.       PL, WACOM_PL_RES, WACOM_PL_RES };
  2582. static const struct wacom_features wacom_features_0xC0 =
  2583.     { "Wacom DTF720", 6858, 5506, 511, 0,
  2584.       PL, WACOM_PL_RES, WACOM_PL_RES };
  2585. static const struct wacom_features wacom_features_0xC2 =
  2586.     { "Wacom DTF720a", 6858, 5506, 511, 0,
  2587.       PL, WACOM_PL_RES, WACOM_PL_RES };
  2588. static const struct wacom_features wacom_features_0x03 =
  2589.     { "Wacom Cintiq Partner", 20480, 15360, 511, 0,
  2590.       PTU, WACOM_PL_RES, WACOM_PL_RES };
  2591. static const struct wacom_features wacom_features_0x41 =
  2592.     { "Wacom Intuos2 4x5", 12700, 10600, 1023, 31,
  2593.       INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2594. static const struct wacom_features wacom_features_0x42 =
  2595.     { "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
  2596.       INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2597. static const struct wacom_features wacom_features_0x43 =
  2598.     { "Wacom Intuos2 9x12", 30480, 24060, 1023, 31,
  2599.       INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2600. static const struct wacom_features wacom_features_0x44 =
  2601.     { "Wacom Intuos2 12x12", 30480, 31680, 1023, 31,
  2602.       INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2603. static const struct wacom_features wacom_features_0x45 =
  2604.     { "Wacom Intuos2 12x18", 45720, 31680, 1023, 31,
  2605.       INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2606. static const struct wacom_features wacom_features_0xB0 =
  2607.     { "Wacom Intuos3 4x5", 25400, 20320, 1023, 63,
  2608.       INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2609. static const struct wacom_features wacom_features_0xB1 =
  2610.     { "Wacom Intuos3 6x8", 40640, 30480, 1023, 63,
  2611.       INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2612. static const struct wacom_features wacom_features_0xB2 =
  2613.     { "Wacom Intuos3 9x12", 60960, 45720, 1023, 63,
  2614.       INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2615. static const struct wacom_features wacom_features_0xB3 =
  2616.     { "Wacom Intuos3 12x12", 60960, 60960, 1023, 63,
  2617.       INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2618. static const struct wacom_features wacom_features_0xB4 =
  2619.     { "Wacom Intuos3 12x19", 97536, 60960, 1023, 63,
  2620.       INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2621. static const struct wacom_features wacom_features_0xB5 =
  2622.     { "Wacom Intuos3 6x11", 54204, 31750, 1023, 63,
  2623.       INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2624. static const struct wacom_features wacom_features_0xB7 =
  2625.     { "Wacom Intuos3 4x6", 31496, 19685, 1023, 63,
  2626.       INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2627. static const struct wacom_features wacom_features_0xB8 =
  2628.     { "Wacom Intuos4 4x6", 31496, 19685, 2047, 63,
  2629.       INTUOS4S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2630. static const struct wacom_features wacom_features_0xB9 =
  2631.     { "Wacom Intuos4 6x9", 44704, 27940, 2047, 63,
  2632.       INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2633. static const struct wacom_features wacom_features_0xBA =
  2634.     { "Wacom Intuos4 8x13", 65024, 40640, 2047, 63,
  2635.       INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2636. static const struct wacom_features wacom_features_0xBB =
  2637.     { "Wacom Intuos4 12x19", 97536, 60960, 2047, 63,
  2638.       INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2639. static const struct wacom_features wacom_features_0xBC =
  2640.     { "Wacom Intuos4 WL", 40640, 25400, 2047, 63,
  2641.       INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2642. static const struct wacom_features wacom_features_0xBD =
  2643.     { "Wacom Intuos4 WL", 40640, 25400, 2047, 63,
  2644.       INTUOS4WL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2645. static const struct wacom_features wacom_features_0x26 =
  2646.     { "Wacom Intuos5 touch S", 31496, 19685, 2047, 63,
  2647.       INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16 };
  2648. static const struct wacom_features wacom_features_0x27 =
  2649.     { "Wacom Intuos5 touch M", 44704, 27940, 2047, 63,
  2650.       INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16 };
  2651. static const struct wacom_features wacom_features_0x28 =
  2652.     { "Wacom Intuos5 touch L", 65024, 40640, 2047, 63,
  2653.       INTUOS5L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16 };
  2654. static const struct wacom_features wacom_features_0x29 =
  2655.     { "Wacom Intuos5 S", 31496, 19685, 2047, 63,
  2656.       INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2657. static const struct wacom_features wacom_features_0x2A =
  2658.     { "Wacom Intuos5 M", 44704, 27940, 2047, 63,
  2659.       INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2660. static const struct wacom_features wacom_features_0x314 =
  2661.     { "Wacom Intuos Pro S", 31496, 19685, 2047, 63,
  2662.       INTUOSPS, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16,
  2663.       .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
  2664. static const struct wacom_features wacom_features_0x315 =
  2665.     { "Wacom Intuos Pro M", 44704, 27940, 2047, 63,
  2666.       INTUOSPM, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16,
  2667.       .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
  2668. static const struct wacom_features wacom_features_0x317 =
  2669.     { "Wacom Intuos Pro L", 65024, 40640, 2047, 63,
  2670.       INTUOSPL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16,
  2671.       .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
  2672. static const struct wacom_features wacom_features_0xF4 =
  2673.     { "Wacom Cintiq 24HD", 104280, 65400, 2047, 63,
  2674.       WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 };
  2675. static const struct wacom_features wacom_features_0xF8 =
  2676.     { "Wacom Cintiq 24HD touch", 104280, 65400, 2047, 63, /* Pen */
  2677.       WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200,
  2678.       .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf6 };
  2679. static const struct wacom_features wacom_features_0xF6 =
  2680.     { "Wacom Cintiq 24HD touch", .type = WACOM_24HDT, /* Touch */
  2681.       .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf8, .touch_max = 10,
  2682.       .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
  2683. static const struct wacom_features wacom_features_0x3F =
  2684.     { "Wacom Cintiq 21UX", 87200, 65600, 1023, 63,
  2685.       CINTIQ, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2686. static const struct wacom_features wacom_features_0xC5 =
  2687.     { "Wacom Cintiq 20WSX", 86680, 54180, 1023, 63,
  2688.       WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2689. static const struct wacom_features wacom_features_0xC6 =
  2690.     { "Wacom Cintiq 12WX", 53020, 33440, 1023, 63,
  2691.       WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
  2692. static const struct wacom_features wacom_features_0x304 =
  2693.     { "Wacom Cintiq 13HD", 59352, 33648, 1023, 63,
  2694.       WACOM_13HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 };
  2695. static const struct wacom_features wacom_features_0xC7 =
  2696.     { "Wacom DTU1931", 37832, 30305, 511, 0,
  2697.       PL, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2698. static const struct wacom_features wacom_features_0xCE =
  2699.     { "Wacom DTU2231", 47864, 27011, 511, 0,
  2700.       DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
  2701.       .check_for_hid_type = true, .hid_type = HID_TYPE_USBMOUSE };
  2702. static const struct wacom_features wacom_features_0xF0 =
  2703.     { "Wacom DTU1631", 34623, 19553, 511, 0,
  2704.       DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2705. static const struct wacom_features wacom_features_0xFB =
  2706.     { "Wacom DTU1031", 22096, 13960, 511, 0,
  2707.       DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2708. static const struct wacom_features wacom_features_0x57 =
  2709.     { "Wacom DTK2241", 95640, 54060, 2047, 63,
  2710.       DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 };
  2711. static const struct wacom_features wacom_features_0x59 = /* Pen */
  2712.     { "Wacom DTH2242", 95640, 54060, 2047, 63,
  2713.       DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200,
  2714.       .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5D };
  2715. static const struct wacom_features wacom_features_0x5D = /* Touch */
  2716.     { "Wacom DTH2242",       .type = WACOM_24HDT,
  2717.       .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x59, .touch_max = 10,
  2718.       .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
  2719. static const struct wacom_features wacom_features_0xCC =
  2720.     { "Wacom Cintiq 21UX2", 87000, 65400, 2047, 63,
  2721.       WACOM_21UX2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 };
  2722. static const struct wacom_features wacom_features_0xFA =
  2723.     { "Wacom Cintiq 22HD", 95640, 54060, 2047, 63,
  2724.       WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 };
  2725. static const struct wacom_features wacom_features_0x5B =
  2726.     { "Wacom Cintiq 22HDT", 95640, 54060, 2047, 63,
  2727.       WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200,
  2728.       .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5e };
  2729. static const struct wacom_features wacom_features_0x5E =
  2730.     { "Wacom Cintiq 22HDT", .type = WACOM_24HDT,
  2731.       .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5b, .touch_max = 10,
  2732.       .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
  2733. static const struct wacom_features wacom_features_0x90 =
  2734.     { "Wacom ISDv4 90", 26202, 16325, 255, 0,
  2735.       TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2736. static const struct wacom_features wacom_features_0x93 =
  2737.     { "Wacom ISDv4 93", 26202, 16325, 255, 0,
  2738.       TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2739. static const struct wacom_features wacom_features_0x97 =
  2740.     { "Wacom ISDv4 97", 26202, 16325, 511, 0,
  2741.       TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2742. static const struct wacom_features wacom_features_0x9A =
  2743.     { "Wacom ISDv4 9A", 26202, 16325, 255, 0,
  2744.       TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2745. static const struct wacom_features wacom_features_0x9F =
  2746.     { "Wacom ISDv4 9F", 26202, 16325, 255, 0,
  2747.       TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2748. static const struct wacom_features wacom_features_0xE2 =
  2749.     { "Wacom ISDv4 E2", 26202, 16325, 255, 0,
  2750.       TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
  2751. static const struct wacom_features wacom_features_0xE3 =
  2752.     { "Wacom ISDv4 E3", 26202, 16325, 255, 0,
  2753.       TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
  2754. static const struct wacom_features wacom_features_0xE5 =
  2755.     { "Wacom ISDv4 E5", 26202, 16325, 255, 0,
  2756.       MTSCREEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2757. static const struct wacom_features wacom_features_0xE6 =
  2758.     { "Wacom ISDv4 E6", 27760, 15694, 255, 0,
  2759.       TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
  2760. static const struct wacom_features wacom_features_0xEC =
  2761.     { "Wacom ISDv4 EC", 25710, 14500, 255, 0,
  2762.       TABLETPC,    WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2763. static const struct wacom_features wacom_features_0xED =
  2764.     { "Wacom ISDv4 ED", 26202, 16325, 255, 0,
  2765.       TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2766. static const struct wacom_features wacom_features_0xEF =
  2767.     { "Wacom ISDv4 EF", 26202, 16325, 255, 0,
  2768.       TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2769. static const struct wacom_features wacom_features_0x100 =
  2770.     { "Wacom ISDv4 100", 26202, 16325, 255, 0,
  2771.       MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2772. static const struct wacom_features wacom_features_0x101 =
  2773.     { "Wacom ISDv4 101", 26202, 16325, 255, 0,
  2774.       MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2775. static const struct wacom_features wacom_features_0x10D =
  2776.     { "Wacom ISDv4 10D", 26202, 16325, 255, 0,
  2777.       MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2778. static const struct wacom_features wacom_features_0x10E =
  2779.     { "Wacom ISDv4 10E", 27760, 15694, 255, 0,
  2780.       MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2781. static const struct wacom_features wacom_features_0x10F =
  2782.     { "Wacom ISDv4 10F", 27760, 15694, 255, 0,
  2783.       MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2784. static const struct wacom_features wacom_features_0x116 =
  2785.     { "Wacom ISDv4 116", 26202, 16325, 255, 0,
  2786.       TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2787. static const struct wacom_features wacom_features_0x12C =
  2788.     { "Wacom ISDv4 12C", 27848, 15752, 2047, 0,
  2789.       TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2790. static const struct wacom_features wacom_features_0x4001 =
  2791.     { "Wacom ISDv4 4001", 26202, 16325, 255, 0,
  2792.       MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2793. static const struct wacom_features wacom_features_0x4004 =
  2794.     { "Wacom ISDv4 4004", 11060, 6220, 255, 0,
  2795.       MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2796. static const struct wacom_features wacom_features_0x5000 =
  2797.     { "Wacom ISDv4 5000", 27848, 15752, 1023, 0,
  2798.       MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2799. static const struct wacom_features wacom_features_0x5002 =
  2800.     { "Wacom ISDv4 5002", 29576, 16724, 1023, 0,
  2801.       MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2802. static const struct wacom_features wacom_features_0x47 =
  2803.     { "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
  2804.       INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2805. static const struct wacom_features wacom_features_0x84 =
  2806.     { "Wacom Wireless Receiver", 0, 0, 0, 0,
  2807.       WIRELESS, 0, 0, .touch_max = 16 };
  2808. static const struct wacom_features wacom_features_0xD0 =
  2809.     { "Wacom Bamboo 2FG", 14720, 9200, 1023, 31,
  2810.       BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
  2811. static const struct wacom_features wacom_features_0xD1 =
  2812.     { "Wacom Bamboo 2FG 4x5", 14720, 9200, 1023, 31,
  2813.       BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
  2814. static const struct wacom_features wacom_features_0xD2 =
  2815.     { "Wacom Bamboo Craft", 14720, 9200, 1023, 31,
  2816.       BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
  2817. static const struct wacom_features wacom_features_0xD3 =
  2818.     { "Wacom Bamboo 2FG 6x8", 21648, 13700, 1023, 31,
  2819.       BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
  2820. static const struct wacom_features wacom_features_0xD4 =
  2821.     { "Wacom Bamboo Pen", 14720, 9200, 1023, 31,
  2822.       BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2823. static const struct wacom_features wacom_features_0xD5 =
  2824.     { "Wacom Bamboo Pen 6x8", 21648, 13700, 1023, 31,
  2825.       BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2826. static const struct wacom_features wacom_features_0xD6 =
  2827.     { "Wacom BambooPT 2FG 4x5", 14720, 9200, 1023, 31,
  2828.       BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
  2829. static const struct wacom_features wacom_features_0xD7 =
  2830.     { "Wacom BambooPT 2FG Small", 14720, 9200, 1023, 31,
  2831.       BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
  2832. static const struct wacom_features wacom_features_0xD8 =
  2833.     { "Wacom Bamboo Comic 2FG", 21648, 13700, 1023, 31,
  2834.       BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
  2835. static const struct wacom_features wacom_features_0xDA =
  2836.     { "Wacom Bamboo 2FG 4x5 SE", 14720, 9200, 1023, 31,
  2837.       BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
  2838. static const struct wacom_features wacom_features_0xDB =
  2839.     { "Wacom Bamboo 2FG 6x8 SE", 21648, 13700, 1023, 31,
  2840.       BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
  2841. static const struct wacom_features wacom_features_0xDD =
  2842.         { "Wacom Bamboo Connect", 14720, 9200, 1023, 31,
  2843.           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2844. static const struct wacom_features wacom_features_0xDE =
  2845.         { "Wacom Bamboo 16FG 4x5", 14720, 9200, 1023, 31,
  2846.       BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
  2847. static const struct wacom_features wacom_features_0xDF =
  2848.         { "Wacom Bamboo 16FG 6x8", 21648, 13700, 1023, 31,
  2849.       BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
  2850. static const struct wacom_features wacom_features_0x300 =
  2851.     { "Wacom Bamboo One S", 14720, 9225, 1023, 31,
  2852.       BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2853. static const struct wacom_features wacom_features_0x301 =
  2854.     { "Wacom Bamboo One M", 21648, 13530, 1023, 31,
  2855.       BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2856. static const struct wacom_features wacom_features_0x302 =
  2857.     { "Wacom Intuos PT S", 15200, 9500, 1023, 31,
  2858.       INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
  2859.       .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
  2860. static const struct wacom_features wacom_features_0x303 =
  2861.     { "Wacom Intuos PT M", 21600, 13500, 1023, 31,
  2862.       INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
  2863.       .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
  2864. static const struct wacom_features wacom_features_0x30E =
  2865.     { "Wacom Intuos S", 15200, 9500, 1023, 31,
  2866.       INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
  2867.       .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
  2868. static const struct wacom_features wacom_features_0x6004 =
  2869.     { "ISD-V4", 12800, 8000, 255, 0,
  2870.       TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
  2871. static const struct wacom_features wacom_features_0x307 =
  2872.     { "Wacom ISDv5 307", 59352, 33648, 2047, 63,
  2873.       CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200,
  2874.       .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x309 };
  2875. static const struct wacom_features wacom_features_0x309 =
  2876.     { "Wacom ISDv5 309", .type = WACOM_24HDT, /* Touch */
  2877.       .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x0307, .touch_max = 10,
  2878.       .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
  2879. static const struct wacom_features wacom_features_0x30A =
  2880.     { "Wacom ISDv5 30A", 59352, 33648, 2047, 63,
  2881.       CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200,
  2882.       .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x30C };
  2883. static const struct wacom_features wacom_features_0x30C =
  2884.     { "Wacom ISDv5 30C", .type = WACOM_24HDT, /* Touch */
  2885.       .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x30A, .touch_max = 10,
  2886.       .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
  2887.  
  2888. static const struct wacom_features wacom_features_HID_ANY_ID =
  2889.     { "Wacom HID", .type = HID_GENERIC };
  2890.  
  2891. #define USB_DEVICE_WACOM(prod)                      \
  2892.     HID_DEVICE(BUS_USB, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
  2893.     .driver_data = (kernel_ulong_t)&wacom_features_##prod
  2894.  
  2895. #define BT_DEVICE_WACOM(prod)                       \
  2896.     HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
  2897.     .driver_data = (kernel_ulong_t)&wacom_features_##prod
  2898.  
  2899. #define USB_DEVICE_LENOVO(prod)                 \
  2900.     HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, prod),         \
  2901.     .driver_data = (kernel_ulong_t)&wacom_features_##prod
  2902.  
  2903. const struct hid_device_id wacom_ids[] = {
  2904.     { USB_DEVICE_WACOM(0x00) },
  2905.     { USB_DEVICE_WACOM(0x03) },
  2906.     { USB_DEVICE_WACOM(0x10) },
  2907.     { USB_DEVICE_WACOM(0x11) },
  2908.     { USB_DEVICE_WACOM(0x12) },
  2909.     { USB_DEVICE_WACOM(0x13) },
  2910.     { USB_DEVICE_WACOM(0x14) },
  2911.     { USB_DEVICE_WACOM(0x15) },
  2912.     { USB_DEVICE_WACOM(0x16) },
  2913.     { USB_DEVICE_WACOM(0x17) },
  2914.     { USB_DEVICE_WACOM(0x18) },
  2915.     { USB_DEVICE_WACOM(0x19) },
  2916.     { USB_DEVICE_WACOM(0x20) },
  2917.     { USB_DEVICE_WACOM(0x21) },
  2918.     { USB_DEVICE_WACOM(0x22) },
  2919.     { USB_DEVICE_WACOM(0x23) },
  2920.     { USB_DEVICE_WACOM(0x24) },
  2921.     { USB_DEVICE_WACOM(0x26) },
  2922.     { USB_DEVICE_WACOM(0x27) },
  2923.     { USB_DEVICE_WACOM(0x28) },
  2924.     { USB_DEVICE_WACOM(0x29) },
  2925.     { USB_DEVICE_WACOM(0x2A) },
  2926.     { USB_DEVICE_WACOM(0x30) },
  2927.     { USB_DEVICE_WACOM(0x31) },
  2928.     { USB_DEVICE_WACOM(0x32) },
  2929.     { USB_DEVICE_WACOM(0x33) },
  2930.     { USB_DEVICE_WACOM(0x34) },
  2931.     { USB_DEVICE_WACOM(0x35) },
  2932.     { USB_DEVICE_WACOM(0x37) },
  2933.     { USB_DEVICE_WACOM(0x38) },
  2934.     { USB_DEVICE_WACOM(0x39) },
  2935.     { USB_DEVICE_WACOM(0x3F) },
  2936.     { USB_DEVICE_WACOM(0x41) },
  2937.     { USB_DEVICE_WACOM(0x42) },
  2938.     { USB_DEVICE_WACOM(0x43) },
  2939.     { USB_DEVICE_WACOM(0x44) },
  2940.     { USB_DEVICE_WACOM(0x45) },
  2941.     { USB_DEVICE_WACOM(0x47) },
  2942.     { USB_DEVICE_WACOM(0x57) },
  2943.     { USB_DEVICE_WACOM(0x59) },
  2944.     { USB_DEVICE_WACOM(0x5B) },
  2945.     { USB_DEVICE_WACOM(0x5D) },
  2946.     { USB_DEVICE_WACOM(0x5E) },
  2947.     { USB_DEVICE_WACOM(0x60) },
  2948.     { USB_DEVICE_WACOM(0x61) },
  2949.     { USB_DEVICE_WACOM(0x62) },
  2950.     { USB_DEVICE_WACOM(0x63) },
  2951.     { USB_DEVICE_WACOM(0x64) },
  2952.     { USB_DEVICE_WACOM(0x65) },
  2953.     { USB_DEVICE_WACOM(0x69) },
  2954.     { USB_DEVICE_WACOM(0x6A) },
  2955.     { USB_DEVICE_WACOM(0x6B) },
  2956.     { BT_DEVICE_WACOM(0x81) },
  2957.     { USB_DEVICE_WACOM(0x84) },
  2958.     { USB_DEVICE_WACOM(0x90) },
  2959.     { USB_DEVICE_WACOM(0x93) },
  2960.     { USB_DEVICE_WACOM(0x97) },
  2961.     { USB_DEVICE_WACOM(0x9A) },
  2962.     { USB_DEVICE_WACOM(0x9F) },
  2963.     { USB_DEVICE_WACOM(0xB0) },
  2964.     { USB_DEVICE_WACOM(0xB1) },
  2965.     { USB_DEVICE_WACOM(0xB2) },
  2966.     { USB_DEVICE_WACOM(0xB3) },
  2967.     { USB_DEVICE_WACOM(0xB4) },
  2968.     { USB_DEVICE_WACOM(0xB5) },
  2969.     { USB_DEVICE_WACOM(0xB7) },
  2970.     { USB_DEVICE_WACOM(0xB8) },
  2971.     { USB_DEVICE_WACOM(0xB9) },
  2972.     { USB_DEVICE_WACOM(0xBA) },
  2973.     { USB_DEVICE_WACOM(0xBB) },
  2974.     { USB_DEVICE_WACOM(0xBC) },
  2975.     { BT_DEVICE_WACOM(0xBD) },
  2976.     { USB_DEVICE_WACOM(0xC0) },
  2977.     { USB_DEVICE_WACOM(0xC2) },
  2978.     { USB_DEVICE_WACOM(0xC4) },
  2979.     { USB_DEVICE_WACOM(0xC5) },
  2980.     { USB_DEVICE_WACOM(0xC6) },
  2981.     { USB_DEVICE_WACOM(0xC7) },
  2982.     { USB_DEVICE_WACOM(0xCC) },
  2983.     { USB_DEVICE_WACOM(0xCE) },
  2984.     { USB_DEVICE_WACOM(0xD0) },
  2985.     { USB_DEVICE_WACOM(0xD1) },
  2986.     { USB_DEVICE_WACOM(0xD2) },
  2987.     { USB_DEVICE_WACOM(0xD3) },
  2988.     { USB_DEVICE_WACOM(0xD4) },
  2989.     { USB_DEVICE_WACOM(0xD5) },
  2990.     { USB_DEVICE_WACOM(0xD6) },
  2991.     { USB_DEVICE_WACOM(0xD7) },
  2992.     { USB_DEVICE_WACOM(0xD8) },
  2993.     { USB_DEVICE_WACOM(0xDA) },
  2994.     { USB_DEVICE_WACOM(0xDB) },
  2995.     { USB_DEVICE_WACOM(0xDD) },
  2996.     { USB_DEVICE_WACOM(0xDE) },
  2997.     { USB_DEVICE_WACOM(0xDF) },
  2998.     { USB_DEVICE_WACOM(0xE2) },
  2999.     { USB_DEVICE_WACOM(0xE3) },
  3000.     { USB_DEVICE_WACOM(0xE5) },
  3001.     { USB_DEVICE_WACOM(0xE6) },
  3002.     { USB_DEVICE_WACOM(0xEC) },
  3003.     { USB_DEVICE_WACOM(0xED) },
  3004.     { USB_DEVICE_WACOM(0xEF) },
  3005.     { USB_DEVICE_WACOM(0xF0) },
  3006.     { USB_DEVICE_WACOM(0xF4) },
  3007.     { USB_DEVICE_WACOM(0xF6) },
  3008.     { USB_DEVICE_WACOM(0xF8) },
  3009.     { USB_DEVICE_WACOM(0xFA) },
  3010.     { USB_DEVICE_WACOM(0xFB) },
  3011.     { USB_DEVICE_WACOM(0x100) },
  3012.     { USB_DEVICE_WACOM(0x101) },
  3013.     { USB_DEVICE_WACOM(0x10D) },
  3014.     { USB_DEVICE_WACOM(0x10E) },
  3015.     { USB_DEVICE_WACOM(0x10F) },
  3016.     { USB_DEVICE_WACOM(0x116) },
  3017.     { USB_DEVICE_WACOM(0x12C) },
  3018.     { USB_DEVICE_WACOM(0x300) },
  3019.     { USB_DEVICE_WACOM(0x301) },
  3020.     { USB_DEVICE_WACOM(0x302) },
  3021.     { USB_DEVICE_WACOM(0x303) },
  3022.     { USB_DEVICE_WACOM(0x304) },
  3023.     { USB_DEVICE_WACOM(0x307) },
  3024.     { USB_DEVICE_WACOM(0x309) },
  3025.     { USB_DEVICE_WACOM(0x30A) },
  3026.     { USB_DEVICE_WACOM(0x30C) },
  3027.     { USB_DEVICE_WACOM(0x30E) },
  3028.     { USB_DEVICE_WACOM(0x314) },
  3029.     { USB_DEVICE_WACOM(0x315) },
  3030.     { USB_DEVICE_WACOM(0x317) },
  3031.     { USB_DEVICE_WACOM(0x4001) },
  3032.     { USB_DEVICE_WACOM(0x4004) },
  3033.     { USB_DEVICE_WACOM(0x5000) },
  3034.     { USB_DEVICE_WACOM(0x5002) },
  3035.     { USB_DEVICE_LENOVO(0x6004) },
  3036.  
  3037.     { USB_DEVICE_WACOM(HID_ANY_ID) },
  3038.     { }
  3039. };
  3040. MODULE_DEVICE_TABLE(hid, wacom_ids);
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!