1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Apple USB BCM5974 (Macbook Air and Penryn Macbook Pro) multitouch driver 4 * 5 * Copyright (C) 2008 Henrik Rydberg (rydberg@euromail.se) 6 * Copyright (C) 2015 John Horan (knasher@gmail.com) 7 * 8 * The USB initialization and package decoding was made by 9 * Scott Shawcroft as part of the touchd user-space driver project: 10 * Copyright (C) 2008 Scott Shawcroft (scott.shawcroft@gmail.com) 11 * 12 * The BCM5974 driver is based on the appletouch driver: 13 * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com) 14 * Copyright (C) 2005 Johannes Berg (johannes@sipsolutions.net) 15 * Copyright (C) 2005 Stelian Pop (stelian@popies.net) 16 * Copyright (C) 2005 Frank Arnold (frank@scirocco-5v-turbo.de) 17 * Copyright (C) 2005 Peter Osterlund (petero2@telia.com) 18 * Copyright (C) 2005 Michael Hanselmann (linux-kernel@hansmi.ch) 19 * Copyright (C) 2006 Nicolas Boichat (nicolas@boichat.ch) 20 */ 21 22 #include <linux/kernel.h> 23 #include <linux/errno.h> 24 #include <linux/slab.h> 25 #include <linux/module.h> 26 #include <linux/usb/input.h> 27 #include <linux/hid.h> 28 #include <linux/mutex.h> 29 #include <linux/input/mt.h> 30 31 #define USB_VENDOR_ID_APPLE 0x05ac 32 33 /* MacbookAir, aka wellspring */ 34 #define USB_DEVICE_ID_APPLE_WELLSPRING_ANSI 0x0223 35 #define USB_DEVICE_ID_APPLE_WELLSPRING_ISO 0x0224 36 #define USB_DEVICE_ID_APPLE_WELLSPRING_JIS 0x0225 37 /* MacbookProPenryn, aka wellspring2 */ 38 #define USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI 0x0230 39 #define USB_DEVICE_ID_APPLE_WELLSPRING2_ISO 0x0231 40 #define USB_DEVICE_ID_APPLE_WELLSPRING2_JIS 0x0232 41 /* Macbook5,1 (unibody), aka wellspring3 */ 42 #define USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI 0x0236 43 #define USB_DEVICE_ID_APPLE_WELLSPRING3_ISO 0x0237 44 #define USB_DEVICE_ID_APPLE_WELLSPRING3_JIS 0x0238 45 /* MacbookAir3,2 (unibody), aka wellspring5 */ 46 #define USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI 0x023f 47 #define USB_DEVICE_ID_APPLE_WELLSPRING4_ISO 0x0240 48 #define USB_DEVICE_ID_APPLE_WELLSPRING4_JIS 0x0241 49 /* MacbookAir3,1 (unibody), aka wellspring4 */ 50 #define USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI 0x0242 51 #define USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO 0x0243 52 #define USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS 0x0244 53 /* Macbook8 (unibody, March 2011) */ 54 #define USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI 0x0245 55 #define USB_DEVICE_ID_APPLE_WELLSPRING5_ISO 0x0246 56 #define USB_DEVICE_ID_APPLE_WELLSPRING5_JIS 0x0247 57 /* MacbookAir4,1 (unibody, July 2011) */ 58 #define USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI 0x0249 59 #define USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO 0x024a 60 #define USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS 0x024b 61 /* MacbookAir4,2 (unibody, July 2011) */ 62 #define USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI 0x024c 63 #define USB_DEVICE_ID_APPLE_WELLSPRING6_ISO 0x024d 64 #define USB_DEVICE_ID_APPLE_WELLSPRING6_JIS 0x024e 65 /* Macbook8,2 (unibody) */ 66 #define USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI 0x0252 67 #define USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO 0x0253 68 #define USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS 0x0254 69 /* MacbookPro10,1 (unibody, June 2012) */ 70 #define USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI 0x0262 71 #define USB_DEVICE_ID_APPLE_WELLSPRING7_ISO 0x0263 72 #define USB_DEVICE_ID_APPLE_WELLSPRING7_JIS 0x0264 73 /* MacbookPro10,2 (unibody, October 2012) */ 74 #define USB_DEVICE_ID_APPLE_WELLSPRING7A_ANSI 0x0259 75 #define USB_DEVICE_ID_APPLE_WELLSPRING7A_ISO 0x025a 76 #define USB_DEVICE_ID_APPLE_WELLSPRING7A_JIS 0x025b 77 /* MacbookAir6,2 (unibody, June 2013) */ 78 #define USB_DEVICE_ID_APPLE_WELLSPRING8_ANSI 0x0290 79 #define USB_DEVICE_ID_APPLE_WELLSPRING8_ISO 0x0291 80 #define USB_DEVICE_ID_APPLE_WELLSPRING8_JIS 0x0292 81 /* MacbookPro12,1 (2015) */ 82 #define USB_DEVICE_ID_APPLE_WELLSPRING9_ANSI 0x0272 83 #define USB_DEVICE_ID_APPLE_WELLSPRING9_ISO 0x0273 84 #define USB_DEVICE_ID_APPLE_WELLSPRING9_JIS 0x0274 85 86 #define BCM5974_DEVICE(prod) { \ 87 .match_flags = (USB_DEVICE_ID_MATCH_DEVICE | \ 88 USB_DEVICE_ID_MATCH_INT_CLASS | \ 89 USB_DEVICE_ID_MATCH_INT_PROTOCOL), \ 90 .idVendor = USB_VENDOR_ID_APPLE, \ 91 .idProduct = (prod), \ 92 .bInterfaceClass = USB_INTERFACE_CLASS_HID, \ 93 .bInterfaceProtocol = USB_INTERFACE_PROTOCOL_MOUSE \ 94 } 95 96 /* table of devices that work with this driver */ 97 static const struct usb_device_id bcm5974_table[] = { 98 /* MacbookAir1.1 */ 99 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING_ANSI), 100 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING_ISO), 101 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING_JIS), 102 /* MacbookProPenryn */ 103 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI), 104 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING2_ISO), 105 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING2_JIS), 106 /* Macbook5,1 */ 107 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI), 108 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING3_ISO), 109 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING3_JIS), 110 /* MacbookAir3,2 */ 111 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI), 112 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4_ISO), 113 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4_JIS), 114 /* MacbookAir3,1 */ 115 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI), 116 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO), 117 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS), 118 /* MacbookPro8 */ 119 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI), 120 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5_ISO), 121 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5_JIS), 122 /* MacbookAir4,1 */ 123 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI), 124 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO), 125 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS), 126 /* MacbookAir4,2 */ 127 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI), 128 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING6_ISO), 129 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING6_JIS), 130 /* MacbookPro8,2 */ 131 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI), 132 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO), 133 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS), 134 /* MacbookPro10,1 */ 135 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI), 136 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING7_ISO), 137 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING7_JIS), 138 /* MacbookPro10,2 */ 139 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING7A_ANSI), 140 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING7A_ISO), 141 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING7A_JIS), 142 /* MacbookAir6,2 */ 143 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING8_ANSI), 144 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING8_ISO), 145 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING8_JIS), 146 /* MacbookPro12,1 */ 147 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING9_ANSI), 148 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING9_ISO), 149 BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING9_JIS), 150 /* Terminating entry */ 151 {} 152 }; 153 MODULE_DEVICE_TABLE(usb, bcm5974_table); 154 155 MODULE_AUTHOR("Henrik Rydberg"); 156 MODULE_DESCRIPTION("Apple USB BCM5974 multitouch driver"); 157 MODULE_LICENSE("GPL"); 158 159 #define dprintk(level, format, a...)\ 160 { if (debug >= level) printk(KERN_DEBUG format, ##a); } 161 162 static int debug = 1; 163 module_param(debug, int, 0644); 164 MODULE_PARM_DESC(debug, "Activate debugging output"); 165 166 /* button data structure */ 167 struct bt_data { 168 u8 unknown1; /* constant */ 169 u8 button; /* left button */ 170 u8 rel_x; /* relative x coordinate */ 171 u8 rel_y; /* relative y coordinate */ 172 }; 173 174 /* trackpad header types */ 175 enum tp_type { 176 TYPE1, /* plain trackpad */ 177 TYPE2, /* button integrated in trackpad */ 178 TYPE3, /* additional header fields since June 2013 */ 179 TYPE4 /* additional header field for pressure data */ 180 }; 181 182 /* trackpad finger data offsets, le16-aligned */ 183 #define HEADER_TYPE1 (13 * sizeof(__le16)) 184 #define HEADER_TYPE2 (15 * sizeof(__le16)) 185 #define HEADER_TYPE3 (19 * sizeof(__le16)) 186 #define HEADER_TYPE4 (23 * sizeof(__le16)) 187 188 /* trackpad button data offsets */ 189 #define BUTTON_TYPE1 0 190 #define BUTTON_TYPE2 15 191 #define BUTTON_TYPE3 23 192 #define BUTTON_TYPE4 31 193 194 /* list of device capability bits */ 195 #define HAS_INTEGRATED_BUTTON 1 196 197 /* trackpad finger data block size */ 198 #define FSIZE_TYPE1 (14 * sizeof(__le16)) 199 #define FSIZE_TYPE2 (14 * sizeof(__le16)) 200 #define FSIZE_TYPE3 (14 * sizeof(__le16)) 201 #define FSIZE_TYPE4 (15 * sizeof(__le16)) 202 203 /* offset from header to finger struct */ 204 #define DELTA_TYPE1 (0 * sizeof(__le16)) 205 #define DELTA_TYPE2 (0 * sizeof(__le16)) 206 #define DELTA_TYPE3 (0 * sizeof(__le16)) 207 #define DELTA_TYPE4 (1 * sizeof(__le16)) 208 209 /* usb control message mode switch data */ 210 #define USBMSG_TYPE1 8, 0x300, 0, 0, 0x1, 0x8 211 #define USBMSG_TYPE2 8, 0x300, 0, 0, 0x1, 0x8 212 #define USBMSG_TYPE3 8, 0x300, 0, 0, 0x1, 0x8 213 #define USBMSG_TYPE4 2, 0x302, 2, 1, 0x1, 0x0 214 215 /* Wellspring initialization constants */ 216 #define BCM5974_WELLSPRING_MODE_READ_REQUEST_ID 1 217 #define BCM5974_WELLSPRING_MODE_WRITE_REQUEST_ID 9 218 219 /* trackpad finger structure, le16-aligned */ 220 struct tp_finger { 221 __le16 origin; /* zero when switching track finger */ 222 __le16 abs_x; /* absolute x coodinate */ 223 __le16 abs_y; /* absolute y coodinate */ 224 __le16 rel_x; /* relative x coodinate */ 225 __le16 rel_y; /* relative y coodinate */ 226 __le16 tool_major; /* tool area, major axis */ 227 __le16 tool_minor; /* tool area, minor axis */ 228 __le16 orientation; /* 16384 when point, else 15 bit angle */ 229 __le16 touch_major; /* touch area, major axis */ 230 __le16 touch_minor; /* touch area, minor axis */ 231 __le16 unused[2]; /* zeros */ 232 __le16 pressure; /* pressure on forcetouch touchpad */ 233 __le16 multi; /* one finger: varies, more fingers: constant */ 234 } __attribute__((packed,aligned(2))); 235 236 /* trackpad finger data size, empirically at least ten fingers */ 237 #define MAX_FINGERS 16 238 #define MAX_FINGER_ORIENTATION 16384 239 240 /* device-specific parameters */ 241 struct bcm5974_param { 242 int snratio; /* signal-to-noise ratio */ 243 int min; /* device minimum reading */ 244 int max; /* device maximum reading */ 245 }; 246 247 /* device-specific configuration */ 248 struct bcm5974_config { 249 int ansi, iso, jis; /* the product id of this device */ 250 int caps; /* device capability bitmask */ 251 int bt_ep; /* the endpoint of the button interface */ 252 int bt_datalen; /* data length of the button interface */ 253 int tp_ep; /* the endpoint of the trackpad interface */ 254 enum tp_type tp_type; /* type of trackpad interface */ 255 int tp_header; /* bytes in header block */ 256 int tp_datalen; /* data length of the trackpad interface */ 257 int tp_button; /* offset to button data */ 258 int tp_fsize; /* bytes in single finger block */ 259 int tp_delta; /* offset from header to finger struct */ 260 int um_size; /* usb control message length */ 261 int um_req_val; /* usb control message value */ 262 int um_req_idx; /* usb control message index */ 263 int um_switch_idx; /* usb control message mode switch index */ 264 int um_switch_on; /* usb control message mode switch on */ 265 int um_switch_off; /* usb control message mode switch off */ 266 struct bcm5974_param p; /* finger pressure limits */ 267 struct bcm5974_param w; /* finger width limits */ 268 struct bcm5974_param x; /* horizontal limits */ 269 struct bcm5974_param y; /* vertical limits */ 270 struct bcm5974_param o; /* orientation limits */ 271 }; 272 273 /* logical device structure */ 274 struct bcm5974 { 275 char phys[64]; 276 struct usb_device *udev; /* usb device */ 277 struct usb_interface *intf; /* our interface */ 278 struct input_dev *input; /* input dev */ 279 struct bcm5974_config cfg; /* device configuration */ 280 struct mutex pm_mutex; /* serialize access to open/suspend */ 281 int opened; /* 1: opened, 0: closed */ 282 struct urb *bt_urb; /* button usb request block */ 283 struct bt_data *bt_data; /* button transferred data */ 284 struct urb *tp_urb; /* trackpad usb request block */ 285 u8 *tp_data; /* trackpad transferred data */ 286 const struct tp_finger *index[MAX_FINGERS]; /* finger index data */ 287 struct input_mt_pos pos[MAX_FINGERS]; /* position array */ 288 int slots[MAX_FINGERS]; /* slot assignments */ 289 }; 290 291 /* trackpad finger block data, le16-aligned */ 292 static const struct tp_finger *get_tp_finger(const struct bcm5974 *dev, int i) 293 { 294 const struct bcm5974_config *c = &dev->cfg; 295 u8 *f_base = dev->tp_data + c->tp_header + c->tp_delta; 296 297 return (const struct tp_finger *)(f_base + i * c->tp_fsize); 298 } 299 300 #define DATAFORMAT(type) \ 301 type, \ 302 HEADER_##type, \ 303 HEADER_##type + (MAX_FINGERS) * (FSIZE_##type), \ 304 BUTTON_##type, \ 305 FSIZE_##type, \ 306 DELTA_##type, \ 307 USBMSG_##type 308 309 /* logical signal quality */ 310 #define SN_PRESSURE 45 /* pressure signal-to-noise ratio */ 311 #define SN_WIDTH 25 /* width signal-to-noise ratio */ 312 #define SN_COORD 250 /* coordinate signal-to-noise ratio */ 313 #define SN_ORIENT 10 /* orientation signal-to-noise ratio */ 314 315 /* device constants */ 316 static const struct bcm5974_config bcm5974_config_table[] = { 317 { 318 USB_DEVICE_ID_APPLE_WELLSPRING_ANSI, 319 USB_DEVICE_ID_APPLE_WELLSPRING_ISO, 320 USB_DEVICE_ID_APPLE_WELLSPRING_JIS, 321 0, 322 0x84, sizeof(struct bt_data), 323 0x81, DATAFORMAT(TYPE1), 324 { SN_PRESSURE, 0, 256 }, 325 { SN_WIDTH, 0, 2048 }, 326 { SN_COORD, -4824, 5342 }, 327 { SN_COORD, -172, 5820 }, 328 { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION } 329 }, 330 { 331 USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI, 332 USB_DEVICE_ID_APPLE_WELLSPRING2_ISO, 333 USB_DEVICE_ID_APPLE_WELLSPRING2_JIS, 334 0, 335 0x84, sizeof(struct bt_data), 336 0x81, DATAFORMAT(TYPE1), 337 { SN_PRESSURE, 0, 256 }, 338 { SN_WIDTH, 0, 2048 }, 339 { SN_COORD, -4824, 4824 }, 340 { SN_COORD, -172, 4290 }, 341 { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION } 342 }, 343 { 344 USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI, 345 USB_DEVICE_ID_APPLE_WELLSPRING3_ISO, 346 USB_DEVICE_ID_APPLE_WELLSPRING3_JIS, 347 HAS_INTEGRATED_BUTTON, 348 0x84, sizeof(struct bt_data), 349 0x81, DATAFORMAT(TYPE2), 350 { SN_PRESSURE, 0, 300 }, 351 { SN_WIDTH, 0, 2048 }, 352 { SN_COORD, -4460, 5166 }, 353 { SN_COORD, -75, 6700 }, 354 { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION } 355 }, 356 { 357 USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI, 358 USB_DEVICE_ID_APPLE_WELLSPRING4_ISO, 359 USB_DEVICE_ID_APPLE_WELLSPRING4_JIS, 360 HAS_INTEGRATED_BUTTON, 361 0x84, sizeof(struct bt_data), 362 0x81, DATAFORMAT(TYPE2), 363 { SN_PRESSURE, 0, 300 }, 364 { SN_WIDTH, 0, 2048 }, 365 { SN_COORD, -4620, 5140 }, 366 { SN_COORD, -150, 6600 }, 367 { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION } 368 }, 369 { 370 USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI, 371 USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO, 372 USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS, 373 HAS_INTEGRATED_BUTTON, 374 0x84, sizeof(struct bt_data), 375 0x81, DATAFORMAT(TYPE2), 376 { SN_PRESSURE, 0, 300 }, 377 { SN_WIDTH, 0, 2048 }, 378 { SN_COORD, -4616, 5112 }, 379 { SN_COORD, -142, 5234 }, 380 { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION } 381 }, 382 { 383 USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI, 384 USB_DEVICE_ID_APPLE_WELLSPRING5_ISO, 385 USB_DEVICE_ID_APPLE_WELLSPRING5_JIS, 386 HAS_INTEGRATED_BUTTON, 387 0x84, sizeof(struct bt_data), 388 0x81, DATAFORMAT(TYPE2), 389 { SN_PRESSURE, 0, 300 }, 390 { SN_WIDTH, 0, 2048 }, 391 { SN_COORD, -4415, 5050 }, 392 { SN_COORD, -55, 6680 }, 393 { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION } 394 }, 395 { 396 USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI, 397 USB_DEVICE_ID_APPLE_WELLSPRING6_ISO, 398 USB_DEVICE_ID_APPLE_WELLSPRING6_JIS, 399 HAS_INTEGRATED_BUTTON, 400 0x84, sizeof(struct bt_data), 401 0x81, DATAFORMAT(TYPE2), 402 { SN_PRESSURE, 0, 300 }, 403 { SN_WIDTH, 0, 2048 }, 404 { SN_COORD, -4620, 5140 }, 405 { SN_COORD, -150, 6600 }, 406 { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION } 407 }, 408 { 409 USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI, 410 USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO, 411 USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS, 412 HAS_INTEGRATED_BUTTON, 413 0x84, sizeof(struct bt_data), 414 0x81, DATAFORMAT(TYPE2), 415 { SN_PRESSURE, 0, 300 }, 416 { SN_WIDTH, 0, 2048 }, 417 { SN_COORD, -4750, 5280 }, 418 { SN_COORD, -150, 6730 }, 419 { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION } 420 }, 421 { 422 USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI, 423 USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO, 424 USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS, 425 HAS_INTEGRATED_BUTTON, 426 0x84, sizeof(struct bt_data), 427 0x81, DATAFORMAT(TYPE2), 428 { SN_PRESSURE, 0, 300 }, 429 { SN_WIDTH, 0, 2048 }, 430 { SN_COORD, -4620, 5140 }, 431 { SN_COORD, -150, 6600 }, 432 { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION } 433 }, 434 { 435 USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI, 436 USB_DEVICE_ID_APPLE_WELLSPRING7_ISO, 437 USB_DEVICE_ID_APPLE_WELLSPRING7_JIS, 438 HAS_INTEGRATED_BUTTON, 439 0x84, sizeof(struct bt_data), 440 0x81, DATAFORMAT(TYPE2), 441 { SN_PRESSURE, 0, 300 }, 442 { SN_WIDTH, 0, 2048 }, 443 { SN_COORD, -4750, 5280 }, 444 { SN_COORD, -150, 6730 }, 445 { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION } 446 }, 447 { 448 USB_DEVICE_ID_APPLE_WELLSPRING7A_ANSI, 449 USB_DEVICE_ID_APPLE_WELLSPRING7A_ISO, 450 USB_DEVICE_ID_APPLE_WELLSPRING7A_JIS, 451 HAS_INTEGRATED_BUTTON, 452 0x84, sizeof(struct bt_data), 453 0x81, DATAFORMAT(TYPE2), 454 { SN_PRESSURE, 0, 300 }, 455 { SN_WIDTH, 0, 2048 }, 456 { SN_COORD, -4750, 5280 }, 457 { SN_COORD, -150, 6730 }, 458 { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION } 459 }, 460 { 461 USB_DEVICE_ID_APPLE_WELLSPRING8_ANSI, 462 USB_DEVICE_ID_APPLE_WELLSPRING8_ISO, 463 USB_DEVICE_ID_APPLE_WELLSPRING8_JIS, 464 HAS_INTEGRATED_BUTTON, 465 0, sizeof(struct bt_data), 466 0x83, DATAFORMAT(TYPE3), 467 { SN_PRESSURE, 0, 300 }, 468 { SN_WIDTH, 0, 2048 }, 469 { SN_COORD, -4620, 5140 }, 470 { SN_COORD, -150, 6600 }, 471 { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION } 472 }, 473 { 474 USB_DEVICE_ID_APPLE_WELLSPRING9_ANSI, 475 USB_DEVICE_ID_APPLE_WELLSPRING9_ISO, 476 USB_DEVICE_ID_APPLE_WELLSPRING9_JIS, 477 HAS_INTEGRATED_BUTTON, 478 0, sizeof(struct bt_data), 479 0x83, DATAFORMAT(TYPE4), 480 { SN_PRESSURE, 0, 300 }, 481 { SN_WIDTH, 0, 2048 }, 482 { SN_COORD, -4828, 5345 }, 483 { SN_COORD, -203, 6803 }, 484 { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION } 485 }, 486 {} 487 }; 488 489 /* return the device-specific configuration by device */ 490 static const struct bcm5974_config *bcm5974_get_config(struct usb_device *udev) 491 { 492 u16 id = le16_to_cpu(udev->descriptor.idProduct); 493 const struct bcm5974_config *cfg; 494 495 for (cfg = bcm5974_config_table; cfg->ansi; ++cfg) 496 if (cfg->ansi == id || cfg->iso == id || cfg->jis == id) 497 return cfg; 498 499 return bcm5974_config_table; 500 } 501 502 /* convert 16-bit little endian to signed integer */ 503 static inline int raw2int(__le16 x) 504 { 505 return (signed short)le16_to_cpu(x); 506 } 507 508 static void set_abs(struct input_dev *input, unsigned int code, 509 const struct bcm5974_param *p) 510 { 511 int fuzz = p->snratio ? (p->max - p->min) / p->snratio : 0; 512 input_set_abs_params(input, code, p->min, p->max, fuzz, 0); 513 } 514 515 /* setup which logical events to report */ 516 static void setup_events_to_report(struct input_dev *input_dev, 517 const struct bcm5974_config *cfg) 518 { 519 __set_bit(EV_ABS, input_dev->evbit); 520 521 /* for synaptics only */ 522 input_set_abs_params(input_dev, ABS_PRESSURE, 0, 256, 5, 0); 523 input_set_abs_params(input_dev, ABS_TOOL_WIDTH, 0, 16, 0, 0); 524 525 /* finger touch area */ 526 set_abs(input_dev, ABS_MT_TOUCH_MAJOR, &cfg->w); 527 set_abs(input_dev, ABS_MT_TOUCH_MINOR, &cfg->w); 528 /* finger approach area */ 529 set_abs(input_dev, ABS_MT_WIDTH_MAJOR, &cfg->w); 530 set_abs(input_dev, ABS_MT_WIDTH_MINOR, &cfg->w); 531 /* finger orientation */ 532 set_abs(input_dev, ABS_MT_ORIENTATION, &cfg->o); 533 /* finger position */ 534 set_abs(input_dev, ABS_MT_POSITION_X, &cfg->x); 535 set_abs(input_dev, ABS_MT_POSITION_Y, &cfg->y); 536 537 __set_bit(EV_KEY, input_dev->evbit); 538 __set_bit(BTN_LEFT, input_dev->keybit); 539 540 if (cfg->caps & HAS_INTEGRATED_BUTTON) 541 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit); 542 543 input_mt_init_slots(input_dev, MAX_FINGERS, 544 INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED | INPUT_MT_TRACK); 545 } 546 547 /* report button data as logical button state */ 548 static int report_bt_state(struct bcm5974 *dev, int size) 549 { 550 if (size != sizeof(struct bt_data)) 551 return -EIO; 552 553 dprintk(7, 554 "bcm5974: button data: %x %x %x %x\n", 555 dev->bt_data->unknown1, dev->bt_data->button, 556 dev->bt_data->rel_x, dev->bt_data->rel_y); 557 558 input_report_key(dev->input, BTN_LEFT, dev->bt_data->button); 559 input_sync(dev->input); 560 561 return 0; 562 } 563 564 static void report_finger_data(struct input_dev *input, int slot, 565 const struct input_mt_pos *pos, 566 const struct tp_finger *f) 567 { 568 input_mt_slot(input, slot); 569 input_mt_report_slot_state(input, MT_TOOL_FINGER, true); 570 571 input_report_abs(input, ABS_MT_TOUCH_MAJOR, 572 raw2int(f->touch_major) << 1); 573 input_report_abs(input, ABS_MT_TOUCH_MINOR, 574 raw2int(f->touch_minor) << 1); 575 input_report_abs(input, ABS_MT_WIDTH_MAJOR, 576 raw2int(f->tool_major) << 1); 577 input_report_abs(input, ABS_MT_WIDTH_MINOR, 578 raw2int(f->tool_minor) << 1); 579 input_report_abs(input, ABS_MT_ORIENTATION, 580 MAX_FINGER_ORIENTATION - raw2int(f->orientation)); 581 input_report_abs(input, ABS_MT_POSITION_X, pos->x); 582 input_report_abs(input, ABS_MT_POSITION_Y, pos->y); 583 } 584 585 static void report_synaptics_data(struct input_dev *input, 586 const struct bcm5974_config *cfg, 587 const struct tp_finger *f, int raw_n) 588 { 589 int abs_p = 0, abs_w = 0; 590 591 if (raw_n) { 592 int p = raw2int(f->touch_major); 593 int w = raw2int(f->tool_major); 594 if (p > 0 && raw2int(f->origin)) { 595 abs_p = clamp_val(256 * p / cfg->p.max, 0, 255); 596 abs_w = clamp_val(16 * w / cfg->w.max, 0, 15); 597 } 598 } 599 600 input_report_abs(input, ABS_PRESSURE, abs_p); 601 input_report_abs(input, ABS_TOOL_WIDTH, abs_w); 602 } 603 604 /* report trackpad data as logical trackpad state */ 605 static int report_tp_state(struct bcm5974 *dev, int size) 606 { 607 const struct bcm5974_config *c = &dev->cfg; 608 const struct tp_finger *f; 609 struct input_dev *input = dev->input; 610 int raw_n, i, n = 0; 611 612 if (size < c->tp_header || (size - c->tp_header) % c->tp_fsize != 0) 613 return -EIO; 614 615 raw_n = (size - c->tp_header) / c->tp_fsize; 616 617 for (i = 0; i < raw_n; i++) { 618 f = get_tp_finger(dev, i); 619 if (raw2int(f->touch_major) == 0) 620 continue; 621 dev->pos[n].x = raw2int(f->abs_x); 622 dev->pos[n].y = c->y.min + c->y.max - raw2int(f->abs_y); 623 dev->index[n++] = f; 624 } 625 626 input_mt_assign_slots(input, dev->slots, dev->pos, n, 0); 627 628 for (i = 0; i < n; i++) 629 report_finger_data(input, dev->slots[i], 630 &dev->pos[i], dev->index[i]); 631 632 input_mt_sync_frame(input); 633 634 report_synaptics_data(input, c, get_tp_finger(dev, 0), raw_n); 635 636 /* later types report button events via integrated button only */ 637 if (c->caps & HAS_INTEGRATED_BUTTON) { 638 int ibt = raw2int(dev->tp_data[c->tp_button]); 639 input_report_key(input, BTN_LEFT, ibt); 640 } 641 642 input_sync(input); 643 644 return 0; 645 } 646 647 static int bcm5974_wellspring_mode(struct bcm5974 *dev, bool on) 648 { 649 const struct bcm5974_config *c = &dev->cfg; 650 int retval = 0, size; 651 char *data; 652 653 /* Type 3 does not require a mode switch */ 654 if (c->tp_type == TYPE3) 655 return 0; 656 657 data = kmalloc(c->um_size, GFP_KERNEL); 658 if (!data) { 659 dev_err(&dev->intf->dev, "out of memory\n"); 660 retval = -ENOMEM; 661 goto out; 662 } 663 664 /* read configuration */ 665 size = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), 666 BCM5974_WELLSPRING_MODE_READ_REQUEST_ID, 667 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 668 c->um_req_val, c->um_req_idx, data, c->um_size, 5000); 669 670 if (size != c->um_size) { 671 dev_err(&dev->intf->dev, "could not read from device\n"); 672 retval = -EIO; 673 goto out; 674 } 675 676 /* apply the mode switch */ 677 data[c->um_switch_idx] = on ? c->um_switch_on : c->um_switch_off; 678 679 /* write configuration */ 680 size = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), 681 BCM5974_WELLSPRING_MODE_WRITE_REQUEST_ID, 682 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 683 c->um_req_val, c->um_req_idx, data, c->um_size, 5000); 684 685 if (size != c->um_size) { 686 dev_err(&dev->intf->dev, "could not write to device\n"); 687 retval = -EIO; 688 goto out; 689 } 690 691 dprintk(2, "bcm5974: switched to %s mode.\n", 692 on ? "wellspring" : "normal"); 693 694 out: 695 kfree(data); 696 return retval; 697 } 698 699 static void bcm5974_irq_button(struct urb *urb) 700 { 701 struct bcm5974 *dev = urb->context; 702 struct usb_interface *intf = dev->intf; 703 int error; 704 705 switch (urb->status) { 706 case 0: 707 break; 708 case -EOVERFLOW: 709 case -ECONNRESET: 710 case -ENOENT: 711 case -ESHUTDOWN: 712 dev_dbg(&intf->dev, "button urb shutting down: %d\n", 713 urb->status); 714 return; 715 default: 716 dev_dbg(&intf->dev, "button urb status: %d\n", urb->status); 717 goto exit; 718 } 719 720 if (report_bt_state(dev, dev->bt_urb->actual_length)) 721 dprintk(1, "bcm5974: bad button package, length: %d\n", 722 dev->bt_urb->actual_length); 723 724 exit: 725 error = usb_submit_urb(dev->bt_urb, GFP_ATOMIC); 726 if (error) 727 dev_err(&intf->dev, "button urb failed: %d\n", error); 728 } 729 730 static void bcm5974_irq_trackpad(struct urb *urb) 731 { 732 struct bcm5974 *dev = urb->context; 733 struct usb_interface *intf = dev->intf; 734 int error; 735 736 switch (urb->status) { 737 case 0: 738 break; 739 case -EOVERFLOW: 740 case -ECONNRESET: 741 case -ENOENT: 742 case -ESHUTDOWN: 743 dev_dbg(&intf->dev, "trackpad urb shutting down: %d\n", 744 urb->status); 745 return; 746 default: 747 dev_dbg(&intf->dev, "trackpad urb status: %d\n", urb->status); 748 goto exit; 749 } 750 751 /* control response ignored */ 752 if (dev->tp_urb->actual_length == 2) 753 goto exit; 754 755 if (report_tp_state(dev, dev->tp_urb->actual_length)) 756 dprintk(1, "bcm5974: bad trackpad package, length: %d\n", 757 dev->tp_urb->actual_length); 758 759 exit: 760 error = usb_submit_urb(dev->tp_urb, GFP_ATOMIC); 761 if (error) 762 dev_err(&intf->dev, "trackpad urb failed: %d\n", error); 763 } 764 765 /* 766 * The Wellspring trackpad, like many recent Apple trackpads, share 767 * the usb device with the keyboard. Since keyboards are usually 768 * handled by the HID system, the device ends up being handled by two 769 * modules. Setting up the device therefore becomes slightly 770 * complicated. To enable multitouch features, a mode switch is 771 * required, which is usually applied via the control interface of the 772 * device. It can be argued where this switch should take place. In 773 * some drivers, like appletouch, the switch is made during 774 * probe. However, the hid module may also alter the state of the 775 * device, resulting in trackpad malfunction under certain 776 * circumstances. To get around this problem, there is at least one 777 * example that utilizes the USB_QUIRK_RESET_RESUME quirk in order to 778 * receive a reset_resume request rather than the normal resume. 779 * Since the implementation of reset_resume is equal to mode switch 780 * plus start_traffic, it seems easier to always do the switch when 781 * starting traffic on the device. 782 */ 783 static int bcm5974_start_traffic(struct bcm5974 *dev) 784 { 785 int error; 786 787 error = bcm5974_wellspring_mode(dev, true); 788 if (error) { 789 dprintk(1, "bcm5974: mode switch failed\n"); 790 goto err_out; 791 } 792 793 if (dev->bt_urb) { 794 error = usb_submit_urb(dev->bt_urb, GFP_KERNEL); 795 if (error) 796 goto err_reset_mode; 797 } 798 799 error = usb_submit_urb(dev->tp_urb, GFP_KERNEL); 800 if (error) 801 goto err_kill_bt; 802 803 return 0; 804 805 err_kill_bt: 806 usb_kill_urb(dev->bt_urb); 807 err_reset_mode: 808 bcm5974_wellspring_mode(dev, false); 809 err_out: 810 return error; 811 } 812 813 static void bcm5974_pause_traffic(struct bcm5974 *dev) 814 { 815 usb_kill_urb(dev->tp_urb); 816 usb_kill_urb(dev->bt_urb); 817 bcm5974_wellspring_mode(dev, false); 818 } 819 820 /* 821 * The code below implements open/close and manual suspend/resume. 822 * All functions may be called in random order. 823 * 824 * Opening a suspended device fails with EACCES - permission denied. 825 * 826 * Failing a resume leaves the device resumed but closed. 827 */ 828 static int bcm5974_open(struct input_dev *input) 829 { 830 struct bcm5974 *dev = input_get_drvdata(input); 831 int error; 832 833 error = usb_autopm_get_interface(dev->intf); 834 if (error) 835 return error; 836 837 mutex_lock(&dev->pm_mutex); 838 839 error = bcm5974_start_traffic(dev); 840 if (!error) 841 dev->opened = 1; 842 843 mutex_unlock(&dev->pm_mutex); 844 845 if (error) 846 usb_autopm_put_interface(dev->intf); 847 848 return error; 849 } 850 851 static void bcm5974_close(struct input_dev *input) 852 { 853 struct bcm5974 *dev = input_get_drvdata(input); 854 855 mutex_lock(&dev->pm_mutex); 856 857 bcm5974_pause_traffic(dev); 858 dev->opened = 0; 859 860 mutex_unlock(&dev->pm_mutex); 861 862 usb_autopm_put_interface(dev->intf); 863 } 864 865 static int bcm5974_suspend(struct usb_interface *iface, pm_message_t message) 866 { 867 struct bcm5974 *dev = usb_get_intfdata(iface); 868 869 mutex_lock(&dev->pm_mutex); 870 871 if (dev->opened) 872 bcm5974_pause_traffic(dev); 873 874 mutex_unlock(&dev->pm_mutex); 875 876 return 0; 877 } 878 879 static int bcm5974_resume(struct usb_interface *iface) 880 { 881 struct bcm5974 *dev = usb_get_intfdata(iface); 882 int error = 0; 883 884 mutex_lock(&dev->pm_mutex); 885 886 if (dev->opened) 887 error = bcm5974_start_traffic(dev); 888 889 mutex_unlock(&dev->pm_mutex); 890 891 return error; 892 } 893 894 static int bcm5974_probe(struct usb_interface *iface, 895 const struct usb_device_id *id) 896 { 897 struct usb_device *udev = interface_to_usbdev(iface); 898 const struct bcm5974_config *cfg; 899 struct bcm5974 *dev; 900 struct input_dev *input_dev; 901 int error = -ENOMEM; 902 903 /* find the product index */ 904 cfg = bcm5974_get_config(udev); 905 906 /* allocate memory for our device state and initialize it */ 907 dev = kzalloc(sizeof(struct bcm5974), GFP_KERNEL); 908 input_dev = input_allocate_device(); 909 if (!dev || !input_dev) { 910 dev_err(&iface->dev, "out of memory\n"); 911 goto err_free_devs; 912 } 913 914 dev->udev = udev; 915 dev->intf = iface; 916 dev->input = input_dev; 917 dev->cfg = *cfg; 918 mutex_init(&dev->pm_mutex); 919 920 /* setup urbs */ 921 if (cfg->tp_type == TYPE1) { 922 dev->bt_urb = usb_alloc_urb(0, GFP_KERNEL); 923 if (!dev->bt_urb) 924 goto err_free_devs; 925 } 926 927 dev->tp_urb = usb_alloc_urb(0, GFP_KERNEL); 928 if (!dev->tp_urb) 929 goto err_free_bt_urb; 930 931 if (dev->bt_urb) { 932 dev->bt_data = usb_alloc_coherent(dev->udev, 933 dev->cfg.bt_datalen, GFP_KERNEL, 934 &dev->bt_urb->transfer_dma); 935 if (!dev->bt_data) 936 goto err_free_urb; 937 } 938 939 dev->tp_data = usb_alloc_coherent(dev->udev, 940 dev->cfg.tp_datalen, GFP_KERNEL, 941 &dev->tp_urb->transfer_dma); 942 if (!dev->tp_data) 943 goto err_free_bt_buffer; 944 945 if (dev->bt_urb) 946 usb_fill_int_urb(dev->bt_urb, udev, 947 usb_rcvintpipe(udev, cfg->bt_ep), 948 dev->bt_data, dev->cfg.bt_datalen, 949 bcm5974_irq_button, dev, 1); 950 951 usb_fill_int_urb(dev->tp_urb, udev, 952 usb_rcvintpipe(udev, cfg->tp_ep), 953 dev->tp_data, dev->cfg.tp_datalen, 954 bcm5974_irq_trackpad, dev, 1); 955 956 /* create bcm5974 device */ 957 usb_make_path(udev, dev->phys, sizeof(dev->phys)); 958 strlcat(dev->phys, "/input0", sizeof(dev->phys)); 959 960 input_dev->name = "bcm5974"; 961 input_dev->phys = dev->phys; 962 usb_to_input_id(dev->udev, &input_dev->id); 963 /* report driver capabilities via the version field */ 964 input_dev->id.version = cfg->caps; 965 input_dev->dev.parent = &iface->dev; 966 967 input_set_drvdata(input_dev, dev); 968 969 input_dev->open = bcm5974_open; 970 input_dev->close = bcm5974_close; 971 972 setup_events_to_report(input_dev, cfg); 973 974 error = input_register_device(dev->input); 975 if (error) 976 goto err_free_buffer; 977 978 /* save our data pointer in this interface device */ 979 usb_set_intfdata(iface, dev); 980 981 return 0; 982 983 err_free_buffer: 984 usb_free_coherent(dev->udev, dev->cfg.tp_datalen, 985 dev->tp_data, dev->tp_urb->transfer_dma); 986 err_free_bt_buffer: 987 if (dev->bt_urb) 988 usb_free_coherent(dev->udev, dev->cfg.bt_datalen, 989 dev->bt_data, dev->bt_urb->transfer_dma); 990 err_free_urb: 991 usb_free_urb(dev->tp_urb); 992 err_free_bt_urb: 993 usb_free_urb(dev->bt_urb); 994 err_free_devs: 995 usb_set_intfdata(iface, NULL); 996 input_free_device(input_dev); 997 kfree(dev); 998 return error; 999 } 1000 1001 static void bcm5974_disconnect(struct usb_interface *iface) 1002 { 1003 struct bcm5974 *dev = usb_get_intfdata(iface); 1004 1005 usb_set_intfdata(iface, NULL); 1006 1007 input_unregister_device(dev->input); 1008 usb_free_coherent(dev->udev, dev->cfg.tp_datalen, 1009 dev->tp_data, dev->tp_urb->transfer_dma); 1010 if (dev->bt_urb) 1011 usb_free_coherent(dev->udev, dev->cfg.bt_datalen, 1012 dev->bt_data, dev->bt_urb->transfer_dma); 1013 usb_free_urb(dev->tp_urb); 1014 usb_free_urb(dev->bt_urb); 1015 kfree(dev); 1016 } 1017 1018 static struct usb_driver bcm5974_driver = { 1019 .name = "bcm5974", 1020 .probe = bcm5974_probe, 1021 .disconnect = bcm5974_disconnect, 1022 .suspend = bcm5974_suspend, 1023 .resume = bcm5974_resume, 1024 .id_table = bcm5974_table, 1025 .supports_autosuspend = 1, 1026 }; 1027 1028 module_usb_driver(bcm5974_driver); 1029