drivers/input/touchscreen/wacom_i2c.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Wacom Penabled Driver for I2C
   4  *
   5  * Copyright (c) 2011 - 2013 Tatsunosuke Tobita, Wacom.
   6  * <[email protected]>
   7  */
   8
   9 #include <linux/bits.h>
  10 #include <linux/module.h>
  11 #include <linux/input.h>
  12 #include <linux/i2c.h>
  13 #include <linux/slab.h>
  14 #include <linux/irq.h>
  15 #include <linux/interrupt.h>
  16 #include <asm/unaligned.h>
  17
  18 /* Bitmasks (for data[3]) */
  19 #define WACOM_TIP_SWITCH        BIT(0)
  20 #define WACOM_BARREL_SWITCH     BIT(1)
  21 #define WACOM_ERASER            BIT(2)
  22 #define WACOM_INVERT            BIT(3)
  23 #define WACOM_BARREL_SWITCH_2   BIT(4)
  24 #define WACOM_IN_PROXIMITY      BIT(5)
  25
  26 /* Registers */
  27 #define WACOM_COMMAND_LSB       0x04
  28 #define WACOM_COMMAND_MSB       0x00
  29
  30 #define WACOM_DATA_LSB          0x05
  31 #define WACOM_DATA_MSB          0x00
  32
  33 /* Report types */
  34 #define REPORT_FEATURE          0x30
  35
  36 /* Requests / operations */
  37 #define OPCODE_GET_REPORT       0x02
  38
  39 #define WACOM_QUERY_REPORT      3
  40 #define WACOM_QUERY_SIZE        19
  41
  42 struct wacom_features {
  43         int x_max;
  44         int y_max;
  45         int pressure_max;
  46         char fw_version;
  47 };
  48
  49 struct wacom_i2c {
  50         struct i2c_client *client;
  51         struct input_dev *input;
  52         u8 data[WACOM_QUERY_SIZE];
  53         bool prox;
  54         int tool;
  55 };
  56
  57 static int wacom_query_device(struct i2c_client *client,
  58                               struct wacom_features *features)
  59 {
  60         u8 get_query_data_cmd[] = {
  61                 WACOM_COMMAND_LSB,
  62                 WACOM_COMMAND_MSB,
  63                 REPORT_FEATURE | WACOM_QUERY_REPORT,
  64                 OPCODE_GET_REPORT,
  65                 WACOM_DATA_LSB,
  66                 WACOM_DATA_MSB,
  67         };
  68         u8 data[WACOM_QUERY_SIZE];
  69         int ret;
  70
  71         struct i2c_msg msgs[] = {
  72                 /* Request reading of feature ReportID: 3 (Pen Query Data) */
  73                 {
  74                         .addr = client->addr,
  75                         .flags = 0,
  76                         .len = sizeof(get_query_data_cmd),
  77                         .buf = get_query_data_cmd,
  78                 },
  79                 {
  80                         .addr = client->addr,
  81                         .flags = I2C_M_RD,
  82                         .len = sizeof(data),
  83                         .buf = data,
  84                 },
  85         };
  86
  87         ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
  88         if (ret < 0)
  89                 return ret;
  90         if (ret != ARRAY_SIZE(msgs))
  91                 return -EIO;
  92
  93         features->x_max = get_unaligned_le16(&data[3]);
  94         features->y_max = get_unaligned_le16(&data[5]);
  95         features->pressure_max = get_unaligned_le16(&data[11]);
  96         features->fw_version = get_unaligned_le16(&data[13]);
  97
  98         dev_dbg(&client->dev,
  99                 "x_max:%d, y_max:%d, pressure:%d, fw:%d\n",
 100                 features->x_max, features->y_max,
 101                 features->pressure_max, features->fw_version);
 102
 103         return 0;
 104 }
 105
 106 static irqreturn_t wacom_i2c_irq(int irq, void *dev_id)
 107 {
 108         struct wacom_i2c *wac_i2c = dev_id;
 109         struct input_dev *input = wac_i2c->input;
 110         u8 *data = wac_i2c->data;
 111         unsigned int x, y, pressure;
 112         unsigned char tsw, f1, f2, ers;
 113         int error;
 114
 115         error = i2c_master_recv(wac_i2c->client,
 116                                 wac_i2c->data, sizeof(wac_i2c->data));
 117         if (error < 0)
 118                 goto out;
 119
 120         tsw = data[3] & WACOM_TIP_SWITCH;
 121         ers = data[3] & WACOM_ERASER;
 122         f1 = data[3] & WACOM_BARREL_SWITCH;
 123         f2 = data[3] & WACOM_BARREL_SWITCH_2;
 124         x = le16_to_cpup((__le16 *)&data[4]);
 125         y = le16_to_cpup((__le16 *)&data[6]);
 126         pressure = le16_to_cpup((__le16 *)&data[8]);
 127
 128         if (!wac_i2c->prox)
 129                 wac_i2c->tool = (data[3] & (WACOM_ERASER | WACOM_INVERT)) ?
 130                         BTN_TOOL_RUBBER : BTN_TOOL_PEN;
 131
 132         wac_i2c->prox = data[3] & WACOM_IN_PROXIMITY;
 133
 134         input_report_key(input, BTN_TOUCH, tsw || ers);
 135         input_report_key(input, wac_i2c->tool, wac_i2c->prox);
 136         input_report_key(input, BTN_STYLUS, f1);
 137         input_report_key(input, BTN_STYLUS2, f2);
 138         input_report_abs(input, ABS_X, x);
 139         input_report_abs(input, ABS_Y, y);
 140         input_report_abs(input, ABS_PRESSURE, pressure);
 141         input_sync(input);
 142
 143 out:
 144         return IRQ_HANDLED;
 145 }
 146
 147 static int wacom_i2c_open(struct input_dev *dev)
 148 {
 149         struct wacom_i2c *wac_i2c = input_get_drvdata(dev);
 150         struct i2c_client *client = wac_i2c->client;
 151
 152         enable_irq(client->irq);
 153
 154         return 0;
 155 }
 156
 157 static void wacom_i2c_close(struct input_dev *dev)
 158 {
 159         struct wacom_i2c *wac_i2c = input_get_drvdata(dev);
 160         struct i2c_client *client = wac_i2c->client;
 161
 162         disable_irq(client->irq);
 163 }
 164
 165 static int wacom_i2c_probe(struct i2c_client *client,
 166                            const struct i2c_device_id *id)
 167 {
 168         struct device *dev = &client->dev;
 169         struct wacom_i2c *wac_i2c;
 170         struct input_dev *input;
 171         struct wacom_features features = { 0 };
 172         int error;
 173
 174         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 175                 dev_err(dev, "i2c_check_functionality error\n");
 176                 return -EIO;
 177         }
 178
 179         error = wacom_query_device(client, &features);
 180         if (error)
 181                 return error;
 182
 183         wac_i2c = devm_kzalloc(dev, sizeof(*wac_i2c), GFP_KERNEL);
 184         if (!wac_i2c)
 185                 return -ENOMEM;
 186
 187         wac_i2c->client = client;
 188
 189         input = devm_input_allocate_device(dev);
 190         if (!input)
 191                 return -ENOMEM;
 192
 193         wac_i2c->input = input;
 194
 195         input->name = "Wacom I2C Digitizer";
 196         input->id.bustype = BUS_I2C;
 197         input->id.vendor = 0x56a;
 198         input->id.version = features.fw_version;
 199         input->open = wacom_i2c_open;
 200         input->close = wacom_i2c_close;
 201
 202         input->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 203
 204         __set_bit(BTN_TOOL_PEN, input->keybit);
 205         __set_bit(BTN_TOOL_RUBBER, input->keybit);
 206         __set_bit(BTN_STYLUS, input->keybit);
 207         __set_bit(BTN_STYLUS2, input->keybit);
 208         __set_bit(BTN_TOUCH, input->keybit);
 209
 210         input_set_abs_params(input, ABS_X, 0, features.x_max, 0, 0);
 211         input_set_abs_params(input, ABS_Y, 0, features.y_max, 0, 0);
 212         input_set_abs_params(input, ABS_PRESSURE,
 213                              0, features.pressure_max, 0, 0);
 214
 215         input_set_drvdata(input, wac_i2c);
 216
 217         error = devm_request_threaded_irq(dev, client->irq, NULL, wacom_i2c_irq,
 218                                           IRQF_ONESHOT, "wacom_i2c", wac_i2c);
 219         if (error) {
 220                 dev_err(dev, "Failed to request IRQ: %d\n", error);
 221                 return error;
 222         }
 223
 224         /* Disable the IRQ, we'll enable it in wac_i2c_open() */
 225         disable_irq(client->irq);
 226
 227         error = input_register_device(wac_i2c->input);
 228         if (error) {
 229                 dev_err(dev, "Failed to register input device: %d\n", error);
 230                 return error;
 231         }
 232
 233         return 0;
 234 }
 235
 236 static int __maybe_unused wacom_i2c_suspend(struct device *dev)
 237 {
 238         struct i2c_client *client = to_i2c_client(dev);
 239
 240         disable_irq(client->irq);
 241
 242         return 0;
 243 }
 244
 245 static int __maybe_unused wacom_i2c_resume(struct device *dev)
 246 {
 247         struct i2c_client *client = to_i2c_client(dev);
 248
 249         enable_irq(client->irq);
 250
 251         return 0;
 252 }
 253
 254 static SIMPLE_DEV_PM_OPS(wacom_i2c_pm, wacom_i2c_suspend, wacom_i2c_resume);
 255
 256 static const struct i2c_device_id wacom_i2c_id[] = {
 257         { "WAC_I2C_EMR", 0 },
 258         { },
 259 };
 260 MODULE_DEVICE_TABLE(i2c, wacom_i2c_id);
 261
 262 static struct i2c_driver wacom_i2c_driver = {
 263         .driver = {
 264                 .name   = "wacom_i2c",
 265                 .pm     = &wacom_i2c_pm,
 266         },
 267
 268         .probe          = wacom_i2c_probe,
 269         .id_table       = wacom_i2c_id,
 270 };
 271 module_i2c_driver(wacom_i2c_driver);
 272
 273 MODULE_AUTHOR("Tatsunosuke Tobita <[email protected]>");
 274 MODULE_DESCRIPTION("WACOM EMR I2C Driver");
 275 MODULE_LICENSE("GPL");