1 /* 2 * Wacom W8001 penabled serial touchscreen driver 3 * 4 * Copyright (c) 2008 Jaya Kumar 5 * Copyright (c) 2010 Red Hat, Inc. 6 * 7 * This file is subject to the terms and conditions of the GNU General Public 8 * License. See the file COPYING in the main directory of this archive for 9 * more details. 10 * 11 * Layout based on Elo serial touchscreen driver by Vojtech Pavlik 12 */ 13 14 #include <linux/errno.h> 15 #include <linux/kernel.h> 16 #include <linux/module.h> 17 #include <linux/slab.h> 18 #include <linux/input.h> 19 #include <linux/serio.h> 20 #include <linux/init.h> 21 #include <linux/ctype.h> 22 23 #define DRIVER_DESC "Wacom W8001 serial touchscreen driver" 24 25 MODULE_AUTHOR("Jaya Kumar <jayakumar.lkml@gmail.com>"); 26 MODULE_DESCRIPTION(DRIVER_DESC); 27 MODULE_LICENSE("GPL"); 28 29 #define W8001_MAX_LENGTH 11 30 #define W8001_LEAD_MASK 0x80 31 #define W8001_LEAD_BYTE 0x80 32 #define W8001_TAB_MASK 0x40 33 #define W8001_TAB_BYTE 0x40 34 /* set in first byte of touch data packets */ 35 #define W8001_TOUCH_MASK (0x10 | W8001_LEAD_MASK) 36 #define W8001_TOUCH_BYTE (0x10 | W8001_LEAD_BYTE) 37 38 #define W8001_QUERY_PACKET 0x20 39 40 #define W8001_CMD_START '1' 41 #define W8001_CMD_QUERY '*' 42 #define W8001_CMD_TOUCHQUERY '%' 43 44 /* length of data packets in bytes, depends on device. */ 45 #define W8001_PKTLEN_TOUCH93 5 46 #define W8001_PKTLEN_TOUCH9A 7 47 #define W8001_PKTLEN_TPCPEN 9 48 #define W8001_PKTLEN_TPCCTL 11 /* control packet */ 49 #define W8001_PKTLEN_TOUCH2FG 13 50 51 #define MAX_TRACKING_ID 0xFF /* arbitrarily chosen */ 52 53 struct w8001_coord { 54 u8 rdy; 55 u8 tsw; 56 u8 f1; 57 u8 f2; 58 u16 x; 59 u16 y; 60 u16 pen_pressure; 61 u8 tilt_x; 62 u8 tilt_y; 63 }; 64 65 /* touch query reply packet */ 66 struct w8001_touch_query { 67 u8 panel_res; 68 u8 capacity_res; 69 u8 sensor_id; 70 u16 x; 71 u16 y; 72 }; 73 74 /* 75 * Per-touchscreen data. 76 */ 77 78 struct w8001 { 79 struct input_dev *dev; 80 struct serio *serio; 81 struct completion cmd_done; 82 int id; 83 int idx; 84 unsigned char response_type; 85 unsigned char response[W8001_MAX_LENGTH]; 86 unsigned char data[W8001_MAX_LENGTH]; 87 char phys[32]; 88 int type; 89 unsigned int pktlen; 90 int trkid[2]; 91 }; 92 93 static void parse_data(u8 *data, struct w8001_coord *coord) 94 { 95 memset(coord, 0, sizeof(*coord)); 96 97 coord->rdy = data[0] & 0x20; 98 coord->tsw = data[0] & 0x01; 99 coord->f1 = data[0] & 0x02; 100 coord->f2 = data[0] & 0x04; 101 102 coord->x = (data[1] & 0x7F) << 9; 103 coord->x |= (data[2] & 0x7F) << 2; 104 coord->x |= (data[6] & 0x60) >> 5; 105 106 coord->y = (data[3] & 0x7F) << 9; 107 coord->y |= (data[4] & 0x7F) << 2; 108 coord->y |= (data[6] & 0x18) >> 3; 109 110 coord->pen_pressure = data[5] & 0x7F; 111 coord->pen_pressure |= (data[6] & 0x07) << 7 ; 112 113 coord->tilt_x = data[7] & 0x7F; 114 coord->tilt_y = data[8] & 0x7F; 115 } 116 117 static void parse_touch(struct w8001 *w8001) 118 { 119 static int trkid; 120 struct input_dev *dev = w8001->dev; 121 unsigned char *data = w8001->data; 122 int i; 123 124 for (i = 0; i < 2; i++) { 125 input_mt_slot(dev, i); 126 127 if (data[0] & (1 << i)) { 128 int x = (data[6 * i + 1] << 7) | (data[6 * i + 2]); 129 int y = (data[6 * i + 3] << 7) | (data[6 * i + 4]); 130 /* data[5,6] and [11,12] is finger capacity */ 131 132 input_report_abs(dev, ABS_MT_POSITION_X, x); 133 input_report_abs(dev, ABS_MT_POSITION_Y, y); 134 input_report_abs(dev, ABS_MT_TOOL_TYPE, MT_TOOL_FINGER); 135 if (w8001->trkid[i] < 0) 136 w8001->trkid[i] = trkid++ & MAX_TRACKING_ID; 137 } else { 138 w8001->trkid[i] = -1; 139 } 140 input_report_abs(dev, ABS_MT_TRACKING_ID, w8001->trkid[i]); 141 } 142 143 input_sync(dev); 144 } 145 146 static void parse_touchquery(u8 *data, struct w8001_touch_query *query) 147 { 148 memset(query, 0, sizeof(*query)); 149 150 query->panel_res = data[1]; 151 query->sensor_id = data[2] & 0x7; 152 query->capacity_res = data[7]; 153 154 query->x = data[3] << 9; 155 query->x |= data[4] << 2; 156 query->x |= (data[2] >> 5) & 0x3; 157 158 query->y = data[5] << 9; 159 query->y |= data[6] << 2; 160 query->y |= (data[2] >> 3) & 0x3; 161 } 162 163 static void report_pen_events(struct w8001 *w8001, struct w8001_coord *coord) 164 { 165 struct input_dev *dev = w8001->dev; 166 167 /* 168 * We have 1 bit for proximity (rdy) and 3 bits for tip, side, 169 * side2/eraser. If rdy && f2 are set, this can be either pen + side2, 170 * or eraser. assume 171 * - if dev is already in proximity and f2 is toggled → pen + side2 172 * - if dev comes into proximity with f2 set → eraser 173 * If f2 disappears after assuming eraser, fake proximity out for 174 * eraser and in for pen. 175 */ 176 177 if (!w8001->type) { 178 w8001->type = coord->f2 ? BTN_TOOL_RUBBER : BTN_TOOL_PEN; 179 } else if (w8001->type == BTN_TOOL_RUBBER) { 180 if (!coord->f2) { 181 input_report_abs(dev, ABS_PRESSURE, 0); 182 input_report_key(dev, BTN_TOUCH, 0); 183 input_report_key(dev, BTN_STYLUS, 0); 184 input_report_key(dev, BTN_STYLUS2, 0); 185 input_report_key(dev, BTN_TOOL_RUBBER, 0); 186 input_sync(dev); 187 w8001->type = BTN_TOOL_PEN; 188 } 189 } else { 190 input_report_key(dev, BTN_STYLUS2, coord->f2); 191 } 192 193 input_report_abs(dev, ABS_X, coord->x); 194 input_report_abs(dev, ABS_Y, coord->y); 195 input_report_abs(dev, ABS_PRESSURE, coord->pen_pressure); 196 input_report_key(dev, BTN_TOUCH, coord->tsw); 197 input_report_key(dev, BTN_STYLUS, coord->f1); 198 input_report_key(dev, w8001->type, coord->rdy); 199 input_sync(dev); 200 201 if (!coord->rdy) 202 w8001->type = 0; 203 } 204 205 static irqreturn_t w8001_interrupt(struct serio *serio, 206 unsigned char data, unsigned int flags) 207 { 208 struct w8001 *w8001 = serio_get_drvdata(serio); 209 struct w8001_coord coord; 210 unsigned char tmp; 211 212 w8001->data[w8001->idx] = data; 213 switch (w8001->idx++) { 214 case 0: 215 if ((data & W8001_LEAD_MASK) != W8001_LEAD_BYTE) { 216 pr_debug("w8001: unsynchronized data: 0x%02x\n", data); 217 w8001->idx = 0; 218 } 219 break; 220 221 case W8001_PKTLEN_TOUCH93 - 1: 222 case W8001_PKTLEN_TOUCH9A - 1: 223 /* ignore one-finger touch packet. */ 224 if (w8001->pktlen == w8001->idx) 225 w8001->idx = 0; 226 break; 227 228 /* Pen coordinates packet */ 229 case W8001_PKTLEN_TPCPEN - 1: 230 tmp = w8001->data[0] & W8001_TAB_MASK; 231 if (unlikely(tmp == W8001_TAB_BYTE)) 232 break; 233 234 tmp = (w8001->data[0] & W8001_TOUCH_BYTE); 235 if (tmp == W8001_TOUCH_BYTE) 236 break; 237 238 w8001->idx = 0; 239 parse_data(w8001->data, &coord); 240 report_pen_events(w8001, &coord); 241 break; 242 243 /* control packet */ 244 case W8001_PKTLEN_TPCCTL - 1: 245 tmp = (w8001->data[0] & W8001_TOUCH_MASK); 246 if (tmp == W8001_TOUCH_BYTE) 247 break; 248 249 w8001->idx = 0; 250 memcpy(w8001->response, w8001->data, W8001_MAX_LENGTH); 251 w8001->response_type = W8001_QUERY_PACKET; 252 complete(&w8001->cmd_done); 253 break; 254 255 /* 2 finger touch packet */ 256 case W8001_PKTLEN_TOUCH2FG - 1: 257 w8001->idx = 0; 258 parse_touch(w8001); 259 break; 260 } 261 262 return IRQ_HANDLED; 263 } 264 265 static int w8001_command(struct w8001 *w8001, unsigned char command, 266 bool wait_response) 267 { 268 int rc; 269 270 w8001->response_type = 0; 271 init_completion(&w8001->cmd_done); 272 273 rc = serio_write(w8001->serio, command); 274 if (rc == 0 && wait_response) { 275 276 wait_for_completion_timeout(&w8001->cmd_done, HZ); 277 if (w8001->response_type != W8001_QUERY_PACKET) 278 rc = -EIO; 279 } 280 281 return rc; 282 } 283 284 static int w8001_setup(struct w8001 *w8001) 285 { 286 struct input_dev *dev = w8001->dev; 287 struct w8001_coord coord; 288 int error; 289 290 error = w8001_command(w8001, W8001_CMD_QUERY, true); 291 if (error) 292 return error; 293 294 parse_data(w8001->response, &coord); 295 296 input_set_abs_params(dev, ABS_X, 0, coord.x, 0, 0); 297 input_set_abs_params(dev, ABS_Y, 0, coord.y, 0, 0); 298 input_set_abs_params(dev, ABS_PRESSURE, 0, coord.pen_pressure, 0, 0); 299 input_set_abs_params(dev, ABS_TILT_X, 0, coord.tilt_x, 0, 0); 300 input_set_abs_params(dev, ABS_TILT_Y, 0, coord.tilt_y, 0, 0); 301 302 error = w8001_command(w8001, W8001_CMD_TOUCHQUERY, true); 303 if (!error) { 304 struct w8001_touch_query touch; 305 306 parse_touchquery(w8001->response, &touch); 307 308 switch (touch.sensor_id) { 309 case 0: 310 case 2: 311 w8001->pktlen = W8001_PKTLEN_TOUCH93; 312 break; 313 case 1: 314 case 3: 315 case 4: 316 w8001->pktlen = W8001_PKTLEN_TOUCH9A; 317 break; 318 case 5: 319 w8001->pktlen = W8001_PKTLEN_TOUCH2FG; 320 321 input_mt_create_slots(dev, 2); 322 input_set_abs_params(dev, ABS_MT_TRACKING_ID, 323 0, MAX_TRACKING_ID, 0, 0); 324 input_set_abs_params(dev, ABS_MT_POSITION_X, 325 0, touch.x, 0, 0); 326 input_set_abs_params(dev, ABS_MT_POSITION_Y, 327 0, touch.y, 0, 0); 328 input_set_abs_params(dev, ABS_MT_TOOL_TYPE, 329 0, 0, 0, 0); 330 break; 331 } 332 } 333 334 return w8001_command(w8001, W8001_CMD_START, false); 335 } 336 337 /* 338 * w8001_disconnect() is the opposite of w8001_connect() 339 */ 340 341 static void w8001_disconnect(struct serio *serio) 342 { 343 struct w8001 *w8001 = serio_get_drvdata(serio); 344 345 input_get_device(w8001->dev); 346 input_unregister_device(w8001->dev); 347 serio_close(serio); 348 serio_set_drvdata(serio, NULL); 349 input_put_device(w8001->dev); 350 kfree(w8001); 351 } 352 353 /* 354 * w8001_connect() is the routine that is called when someone adds a 355 * new serio device that supports the w8001 protocol and registers it as 356 * an input device. 357 */ 358 359 static int w8001_connect(struct serio *serio, struct serio_driver *drv) 360 { 361 struct w8001 *w8001; 362 struct input_dev *input_dev; 363 int err; 364 365 w8001 = kzalloc(sizeof(struct w8001), GFP_KERNEL); 366 input_dev = input_allocate_device(); 367 if (!w8001 || !input_dev) { 368 err = -ENOMEM; 369 goto fail1; 370 } 371 372 w8001->serio = serio; 373 w8001->id = serio->id.id; 374 w8001->dev = input_dev; 375 w8001->trkid[0] = w8001->trkid[1] = -1; 376 init_completion(&w8001->cmd_done); 377 snprintf(w8001->phys, sizeof(w8001->phys), "%s/input0", serio->phys); 378 379 input_dev->name = "Wacom W8001 Penabled Serial TouchScreen"; 380 input_dev->phys = w8001->phys; 381 input_dev->id.bustype = BUS_RS232; 382 input_dev->id.vendor = SERIO_W8001; 383 input_dev->id.product = w8001->id; 384 input_dev->id.version = 0x0100; 385 input_dev->dev.parent = &serio->dev; 386 387 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 388 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 389 input_dev->keybit[BIT_WORD(BTN_TOOL_PEN)] |= BIT_MASK(BTN_TOOL_PEN); 390 input_dev->keybit[BIT_WORD(BTN_TOOL_RUBBER)] |= BIT_MASK(BTN_TOOL_RUBBER); 391 input_dev->keybit[BIT_WORD(BTN_STYLUS)] |= BIT_MASK(BTN_STYLUS); 392 input_dev->keybit[BIT_WORD(BTN_STYLUS2)] |= BIT_MASK(BTN_STYLUS2); 393 394 serio_set_drvdata(serio, w8001); 395 err = serio_open(serio, drv); 396 if (err) 397 goto fail2; 398 399 err = w8001_setup(w8001); 400 if (err) 401 goto fail3; 402 403 err = input_register_device(w8001->dev); 404 if (err) 405 goto fail3; 406 407 return 0; 408 409 fail3: 410 serio_close(serio); 411 fail2: 412 serio_set_drvdata(serio, NULL); 413 fail1: 414 input_free_device(input_dev); 415 kfree(w8001); 416 return err; 417 } 418 419 static struct serio_device_id w8001_serio_ids[] = { 420 { 421 .type = SERIO_RS232, 422 .proto = SERIO_W8001, 423 .id = SERIO_ANY, 424 .extra = SERIO_ANY, 425 }, 426 { 0 } 427 }; 428 429 MODULE_DEVICE_TABLE(serio, w8001_serio_ids); 430 431 static struct serio_driver w8001_drv = { 432 .driver = { 433 .name = "w8001", 434 }, 435 .description = DRIVER_DESC, 436 .id_table = w8001_serio_ids, 437 .interrupt = w8001_interrupt, 438 .connect = w8001_connect, 439 .disconnect = w8001_disconnect, 440 }; 441 442 static int __init w8001_init(void) 443 { 444 return serio_register_driver(&w8001_drv); 445 } 446 447 static void __exit w8001_exit(void) 448 { 449 serio_unregister_driver(&w8001_drv); 450 } 451 452 module_init(w8001_init); 453 module_exit(w8001_exit); 454