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