1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2012 Huang Wen Hui 5 * Copyright (c) 2021 Vladimir Kondratyev <wulf@FreeBSD.org> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 33 #include <sys/param.h> 34 #include <sys/bus.h> 35 #include <sys/endian.h> 36 #include <sys/kernel.h> 37 #include <sys/malloc.h> 38 #include <sys/module.h> 39 #include <sys/sysctl.h> 40 #include <sys/systm.h> 41 42 #include <dev/evdev/input.h> 43 #include <dev/evdev/evdev.h> 44 45 #define HID_DEBUG_VAR bcm5974_debug 46 #include <dev/hid/hid.h> 47 #include <dev/hid/hidbus.h> 48 #include <dev/hid/hidquirk.h> 49 50 #include <dev/usb/usb.h> 51 #include <dev/usb/usbdi.h> 52 #include <dev/usb/usbhid.h> 53 #include <dev/usb/usb_ioctl.h> 54 55 #include "usbdevs.h" 56 57 #define BCM5974_BUFFER_MAX (248 * 4) /* 4 Type4 SPI frames */ 58 #define BCM5974_TLC_PAGE HUP_GENERIC_DESKTOP 59 #define BCM5974_TLC_USAGE HUG_MOUSE 60 61 /* magic to switch device from HID (default) mode into raw */ 62 /* Type1 & Type2 trackpads */ 63 #define BCM5974_USB_IFACE_INDEX 0 64 #define BCM5974_USB_REPORT_LEN 8 65 #define BCM5974_USB_REPORT_ID 0 66 #define BCM5974_USB_MODE_RAW 0x01 67 #define BCM5974_USB_MODE_HID 0x08 68 /* Type4 trackpads */ 69 #define BCM5974_HID_REPORT_LEN 2 70 #define BCM5974_HID_REPORT_ID 2 71 #define BCM5974_HID_MODE_RAW 0x01 72 #define BCM5974_HID_MODE_HID 0x00 73 74 /* Tunables */ 75 static SYSCTL_NODE(_hw_hid, OID_AUTO, bcm5974, CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 76 "HID wellspring touchpad"); 77 78 #ifdef HID_DEBUG 79 enum wsp_log_level { 80 BCM5974_LLEVEL_DISABLED = 0, 81 BCM5974_LLEVEL_ERROR, 82 BCM5974_LLEVEL_DEBUG, /* for troubleshooting */ 83 BCM5974_LLEVEL_INFO, /* for diagnostics */ 84 }; 85 /* the default is to only log errors */ 86 static int bcm5974_debug = BCM5974_LLEVEL_ERROR; 87 88 SYSCTL_INT(_hw_hid_bcm5974, OID_AUTO, debug, CTLFLAG_RWTUN, 89 &bcm5974_debug, BCM5974_LLEVEL_ERROR, "BCM5974 debug level"); 90 #endif /* HID_DEBUG */ 91 92 /* 93 * Some tables, structures, definitions and constant values for the 94 * touchpad protocol has been copied from Linux's 95 * "drivers/input/mouse/bcm5974.c" which has the following copyright 96 * holders under GPLv2. All device specific code in this driver has 97 * been written from scratch. The decoding algorithm is based on 98 * output from FreeBSD's usbdump. 99 * 100 * Copyright (C) 2008 Henrik Rydberg (rydberg@euromail.se) 101 * Copyright (C) 2008 Scott Shawcroft (scott.shawcroft@gmail.com) 102 * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com) 103 * Copyright (C) 2005 Johannes Berg (johannes@sipsolutions.net) 104 * Copyright (C) 2005 Stelian Pop (stelian@popies.net) 105 * Copyright (C) 2005 Frank Arnold (frank@scirocco-5v-turbo.de) 106 * Copyright (C) 2005 Peter Osterlund (petero2@telia.com) 107 * Copyright (C) 2005 Michael Hanselmann (linux-kernel@hansmi.ch) 108 * Copyright (C) 2006 Nicolas Boichat (nicolas@boichat.ch) 109 */ 110 111 /* trackpad header types */ 112 enum tp_type { 113 TYPE1, /* plain trackpad */ 114 TYPE2, /* button integrated in trackpad */ 115 TYPE3, /* additional header fields since June 2013 */ 116 TYPE4, /* additional header field for pressure data */ 117 TYPE_MT2U, /* Magic Trackpad 2 USB */ 118 TYPE_CNT 119 }; 120 121 /* list of device capability bits */ 122 #define HAS_INTEGRATED_BUTTON 1 123 #define USES_COMPACT_REPORT 2 124 125 struct tp_type_params { 126 uint8_t caps; /* device capability bitmask */ 127 uint8_t button; /* offset to button data */ 128 uint8_t offset; /* offset to trackpad finger data */ 129 uint8_t delta; /* offset from header to finger struct */ 130 } const static tp[TYPE_CNT] = { 131 [TYPE1] = { 132 .caps = 0, 133 .button = 0, 134 .offset = 13 * 2, 135 .delta = 0, 136 }, 137 [TYPE2] = { 138 .caps = HAS_INTEGRATED_BUTTON, 139 .button = 15, 140 .offset = 15 * 2, 141 .delta = 0, 142 }, 143 [TYPE3] = { 144 .caps = HAS_INTEGRATED_BUTTON, 145 .button = 23, 146 .offset = 19 * 2, 147 .delta = 0, 148 }, 149 [TYPE4] = { 150 .caps = HAS_INTEGRATED_BUTTON, 151 .button = 31, 152 .offset = 23 * 2, 153 .delta = 2, 154 }, 155 [TYPE_MT2U] = { 156 .caps = HAS_INTEGRATED_BUTTON | USES_COMPACT_REPORT, 157 .button = 1, 158 .offset = 12, 159 .delta = 0, 160 }, 161 }; 162 163 /* trackpad finger structure - compact version for external "Magic" devices */ 164 struct tp_finger_compact { 165 uint32_t coords; /* not struct directly due to endian conversion */ 166 uint8_t touch_major; 167 uint8_t touch_minor; 168 uint8_t size; 169 uint8_t pressure; 170 uint8_t id_ori; 171 } __packed; 172 173 _Static_assert((sizeof(struct tp_finger_compact) == 9), "tp_finger struct size must be 9"); 174 175 /* trackpad finger structure - little endian */ 176 struct tp_finger { 177 uint16_t origin; /* zero when switching track finger */ 178 uint16_t abs_x; /* absolute x coodinate */ 179 uint16_t abs_y; /* absolute y coodinate */ 180 uint16_t rel_x; /* relative x coodinate */ 181 uint16_t rel_y; /* relative y coodinate */ 182 uint16_t tool_major; /* tool area, major axis */ 183 uint16_t tool_minor; /* tool area, minor axis */ 184 uint16_t orientation; /* 16384 when point, else 15 bit angle */ 185 uint16_t touch_major; /* touch area, major axis */ 186 uint16_t touch_minor; /* touch area, minor axis */ 187 uint16_t unused[2]; /* zeros */ 188 uint16_t pressure; /* pressure on forcetouch touchpad */ 189 uint16_t multi; /* one finger: varies, more fingers: 190 * constant */ 191 } __packed; 192 193 #define BCM5974_LE2H(x) ((int32_t)(int16_t)le16toh(x)) 194 195 /* trackpad finger data size, empirically at least ten fingers */ 196 #define MAX_FINGERS MAX_MT_SLOTS 197 198 #define MAX_FINGER_ORIENTATION 16384 199 200 enum { 201 BCM5974_FLAG_WELLSPRING1, 202 BCM5974_FLAG_WELLSPRING2, 203 BCM5974_FLAG_WELLSPRING3, 204 BCM5974_FLAG_WELLSPRING4, 205 BCM5974_FLAG_WELLSPRING4A, 206 BCM5974_FLAG_WELLSPRING5, 207 BCM5974_FLAG_WELLSPRING6A, 208 BCM5974_FLAG_WELLSPRING6, 209 BCM5974_FLAG_WELLSPRING5A, 210 BCM5974_FLAG_WELLSPRING7, 211 BCM5974_FLAG_WELLSPRING7A, 212 BCM5974_FLAG_WELLSPRING8, 213 BCM5974_FLAG_WELLSPRING9, 214 BCM5974_FLAG_MAGIC_TRACKPAD2_USB, 215 BCM5974_FLAG_MAX, 216 }; 217 218 /* device-specific parameters */ 219 struct bcm5974_axis { 220 int snratio; /* signal-to-noise ratio */ 221 int min; /* device minimum reading */ 222 int max; /* device maximum reading */ 223 int size; /* physical size, mm */ 224 }; 225 226 /* device-specific configuration */ 227 struct bcm5974_dev_params { 228 const struct tp_type_params* tp; 229 struct bcm5974_axis p; /* finger pressure limits */ 230 struct bcm5974_axis w; /* finger width limits */ 231 struct bcm5974_axis x; /* horizontal limits */ 232 struct bcm5974_axis y; /* vertical limits */ 233 struct bcm5974_axis o; /* orientation limits */ 234 }; 235 236 /* logical signal quality */ 237 #define SN_PRESSURE 45 /* pressure signal-to-noise ratio */ 238 #define SN_WIDTH 25 /* width signal-to-noise ratio */ 239 #define SN_COORD 250 /* coordinate signal-to-noise ratio */ 240 #define SN_ORIENT 10 /* orientation signal-to-noise ratio */ 241 242 static const struct bcm5974_dev_params bcm5974_dev_params[BCM5974_FLAG_MAX] = { 243 [BCM5974_FLAG_WELLSPRING1] = { 244 .tp = tp + TYPE1, 245 .p = { SN_PRESSURE, 0, 256, 0 }, 246 .w = { SN_WIDTH, 0, 2048, 0 }, 247 .x = { SN_COORD, -4824, 5342, 105 }, 248 .y = { SN_COORD, -172, 5820, 75 }, 249 .o = { SN_ORIENT, 250 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 }, 251 }, 252 [BCM5974_FLAG_WELLSPRING2] = { 253 .tp = tp + TYPE1, 254 .p = { SN_PRESSURE, 0, 256, 0 }, 255 .w = { SN_WIDTH, 0, 2048, 0 }, 256 .x = { SN_COORD, -4824, 4824, 105 }, 257 .y = { SN_COORD, -172, 4290, 75 }, 258 .o = { SN_ORIENT, 259 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 }, 260 }, 261 [BCM5974_FLAG_WELLSPRING3] = { 262 .tp = tp + TYPE2, 263 .p = { SN_PRESSURE, 0, 300, 0 }, 264 .w = { SN_WIDTH, 0, 2048, 0 }, 265 .x = { SN_COORD, -4460, 5166, 105 }, 266 .y = { SN_COORD, -75, 6700, 75 }, 267 .o = { SN_ORIENT, 268 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 }, 269 }, 270 [BCM5974_FLAG_WELLSPRING4] = { 271 .tp = tp + TYPE2, 272 .p = { SN_PRESSURE, 0, 300, 0 }, 273 .w = { SN_WIDTH, 0, 2048, 0 }, 274 .x = { SN_COORD, -4620, 5140, 105 }, 275 .y = { SN_COORD, -150, 6600, 75 }, 276 .o = { SN_ORIENT, 277 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 }, 278 }, 279 [BCM5974_FLAG_WELLSPRING4A] = { 280 .tp = tp + TYPE2, 281 .p = { SN_PRESSURE, 0, 300, 0 }, 282 .w = { SN_WIDTH, 0, 2048, 0 }, 283 .x = { SN_COORD, -4616, 5112, 105 }, 284 .y = { SN_COORD, -142, 5234, 75 }, 285 .o = { SN_ORIENT, 286 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 }, 287 }, 288 [BCM5974_FLAG_WELLSPRING5] = { 289 .tp = tp + TYPE2, 290 .p = { SN_PRESSURE, 0, 300, 0 }, 291 .w = { SN_WIDTH, 0, 2048, 0 }, 292 .x = { SN_COORD, -4415, 5050, 105 }, 293 .y = { SN_COORD, -55, 6680, 75 }, 294 .o = { SN_ORIENT, 295 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 }, 296 }, 297 [BCM5974_FLAG_WELLSPRING6] = { 298 .tp = tp + TYPE2, 299 .p = { SN_PRESSURE, 0, 300, 0 }, 300 .w = { SN_WIDTH, 0, 2048, 0 }, 301 .x = { SN_COORD, -4620, 5140, 105 }, 302 .y = { SN_COORD, -150, 6600, 75 }, 303 .o = { SN_ORIENT, 304 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 }, 305 }, 306 [BCM5974_FLAG_WELLSPRING5A] = { 307 .tp = tp + TYPE2, 308 .p = { SN_PRESSURE, 0, 300, 0 }, 309 .w = { SN_WIDTH, 0, 2048, 0 }, 310 .x = { SN_COORD, -4750, 5280, 105 }, 311 .y = { SN_COORD, -150, 6730, 75 }, 312 .o = { SN_ORIENT, 313 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 }, 314 }, 315 [BCM5974_FLAG_WELLSPRING6A] = { 316 .tp = tp + TYPE2, 317 .p = { SN_PRESSURE, 0, 300, 0 }, 318 .w = { SN_WIDTH, 0, 2048, 0 }, 319 .x = { SN_COORD, -4620, 5140, 105 }, 320 .y = { SN_COORD, -150, 6600, 75 }, 321 .o = { SN_ORIENT, 322 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 }, 323 }, 324 [BCM5974_FLAG_WELLSPRING7] = { 325 .tp = tp + TYPE2, 326 .p = { SN_PRESSURE, 0, 300, 0 }, 327 .w = { SN_WIDTH, 0, 2048, 0 }, 328 .x = { SN_COORD, -4750, 5280, 105 }, 329 .y = { SN_COORD, -150, 6730, 75 }, 330 .o = { SN_ORIENT, 331 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 }, 332 }, 333 [BCM5974_FLAG_WELLSPRING7A] = { 334 .tp = tp + TYPE2, 335 .p = { SN_PRESSURE, 0, 300, 0 }, 336 .w = { SN_WIDTH, 0, 2048, 0 }, 337 .x = { SN_COORD, -4750, 5280, 105 }, 338 .y = { SN_COORD, -150, 6730, 75 }, 339 .o = { SN_ORIENT, 340 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 }, 341 }, 342 [BCM5974_FLAG_WELLSPRING8] = { 343 .tp = tp + TYPE3, 344 .p = { SN_PRESSURE, 0, 300, 0 }, 345 .w = { SN_WIDTH, 0, 2048, 0 }, 346 .x = { SN_COORD, -4620, 5140, 105 }, 347 .y = { SN_COORD, -150, 6600, 75 }, 348 .o = { SN_ORIENT, 349 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 }, 350 }, 351 /* 352 * NOTE: Actually force-sensitive. Pressure has a "size" equal to the max 353 * so that the "resolution" is 1 (i.e. values will be interpreted as grams). 354 * No scientific measurements have been done :) but a really hard press 355 * results in a value around 3500 on model 4. 356 */ 357 [BCM5974_FLAG_WELLSPRING9] = { 358 .tp = tp + TYPE4, 359 .p = { SN_PRESSURE, 0, 4096, 4096 }, 360 .w = { SN_WIDTH, 0, 2048, 0 }, 361 .x = { SN_COORD, -4828, 5345, 105 }, 362 .y = { SN_COORD, -203, 6803, 75 }, 363 .o = { SN_ORIENT, 364 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 }, 365 }, 366 [BCM5974_FLAG_MAGIC_TRACKPAD2_USB] = { 367 .tp = tp + TYPE_MT2U, 368 .p = { SN_PRESSURE, 0, 256, 256 }, 369 .w = { SN_WIDTH, 0, 2048, 0 }, 370 .x = { SN_COORD, -3678, 3934, 48 }, 371 .y = { SN_COORD, -2478, 2587, 44 }, 372 .o = { SN_ORIENT, -3, 4, 0 }, 373 }, 374 }; 375 376 #define BCM5974_DEV(v,p,i) { \ 377 HID_BVPI(BUS_USB, USB_VENDOR_##v, USB_PRODUCT_##v##_##p, i), \ 378 HID_TLC(BCM5974_TLC_PAGE, BCM5974_TLC_USAGE), \ 379 } 380 381 static const struct hid_device_id bcm5974_devs[] = { 382 /* MacbookAir1.1 */ 383 BCM5974_DEV(APPLE, WELLSPRING_ANSI, BCM5974_FLAG_WELLSPRING1), 384 BCM5974_DEV(APPLE, WELLSPRING_ISO, BCM5974_FLAG_WELLSPRING1), 385 BCM5974_DEV(APPLE, WELLSPRING_JIS, BCM5974_FLAG_WELLSPRING1), 386 387 /* MacbookProPenryn, aka wellspring2 */ 388 BCM5974_DEV(APPLE, WELLSPRING2_ANSI, BCM5974_FLAG_WELLSPRING2), 389 BCM5974_DEV(APPLE, WELLSPRING2_ISO, BCM5974_FLAG_WELLSPRING2), 390 BCM5974_DEV(APPLE, WELLSPRING2_JIS, BCM5974_FLAG_WELLSPRING2), 391 392 /* Macbook5,1 (unibody), aka wellspring3 */ 393 BCM5974_DEV(APPLE, WELLSPRING3_ANSI, BCM5974_FLAG_WELLSPRING3), 394 BCM5974_DEV(APPLE, WELLSPRING3_ISO, BCM5974_FLAG_WELLSPRING3), 395 BCM5974_DEV(APPLE, WELLSPRING3_JIS, BCM5974_FLAG_WELLSPRING3), 396 397 /* MacbookAir3,2 (unibody), aka wellspring4 */ 398 BCM5974_DEV(APPLE, WELLSPRING4_ANSI, BCM5974_FLAG_WELLSPRING4), 399 BCM5974_DEV(APPLE, WELLSPRING4_ISO, BCM5974_FLAG_WELLSPRING4), 400 BCM5974_DEV(APPLE, WELLSPRING4_JIS, BCM5974_FLAG_WELLSPRING4), 401 402 /* MacbookAir3,1 (unibody), aka wellspring4 */ 403 BCM5974_DEV(APPLE, WELLSPRING4A_ANSI, BCM5974_FLAG_WELLSPRING4A), 404 BCM5974_DEV(APPLE, WELLSPRING4A_ISO, BCM5974_FLAG_WELLSPRING4A), 405 BCM5974_DEV(APPLE, WELLSPRING4A_JIS, BCM5974_FLAG_WELLSPRING4A), 406 407 /* Macbook8 (unibody, March 2011) */ 408 BCM5974_DEV(APPLE, WELLSPRING5_ANSI, BCM5974_FLAG_WELLSPRING5), 409 BCM5974_DEV(APPLE, WELLSPRING5_ISO, BCM5974_FLAG_WELLSPRING5), 410 BCM5974_DEV(APPLE, WELLSPRING5_JIS, BCM5974_FLAG_WELLSPRING5), 411 412 /* MacbookAir4,1 (unibody, July 2011) */ 413 BCM5974_DEV(APPLE, WELLSPRING6A_ANSI, BCM5974_FLAG_WELLSPRING6A), 414 BCM5974_DEV(APPLE, WELLSPRING6A_ISO, BCM5974_FLAG_WELLSPRING6A), 415 BCM5974_DEV(APPLE, WELLSPRING6A_JIS, BCM5974_FLAG_WELLSPRING6A), 416 417 /* MacbookAir4,2 (unibody, July 2011) */ 418 BCM5974_DEV(APPLE, WELLSPRING6_ANSI, BCM5974_FLAG_WELLSPRING6), 419 BCM5974_DEV(APPLE, WELLSPRING6_ISO, BCM5974_FLAG_WELLSPRING6), 420 BCM5974_DEV(APPLE, WELLSPRING6_JIS, BCM5974_FLAG_WELLSPRING6), 421 422 /* Macbook8,2 (unibody) */ 423 BCM5974_DEV(APPLE, WELLSPRING5A_ANSI, BCM5974_FLAG_WELLSPRING5A), 424 BCM5974_DEV(APPLE, WELLSPRING5A_ISO, BCM5974_FLAG_WELLSPRING5A), 425 BCM5974_DEV(APPLE, WELLSPRING5A_JIS, BCM5974_FLAG_WELLSPRING5A), 426 427 /* MacbookPro10,1 (unibody, June 2012) */ 428 /* MacbookPro11,1-3 (unibody, June 2013) */ 429 BCM5974_DEV(APPLE, WELLSPRING7_ANSI, BCM5974_FLAG_WELLSPRING7), 430 BCM5974_DEV(APPLE, WELLSPRING7_ISO, BCM5974_FLAG_WELLSPRING7), 431 BCM5974_DEV(APPLE, WELLSPRING7_JIS, BCM5974_FLAG_WELLSPRING7), 432 433 /* MacbookPro10,2 (unibody, October 2012) */ 434 BCM5974_DEV(APPLE, WELLSPRING7A_ANSI, BCM5974_FLAG_WELLSPRING7A), 435 BCM5974_DEV(APPLE, WELLSPRING7A_ISO, BCM5974_FLAG_WELLSPRING7A), 436 BCM5974_DEV(APPLE, WELLSPRING7A_JIS, BCM5974_FLAG_WELLSPRING7A), 437 438 /* MacbookAir6,2 (unibody, June 2013) */ 439 BCM5974_DEV(APPLE, WELLSPRING8_ANSI, BCM5974_FLAG_WELLSPRING8), 440 BCM5974_DEV(APPLE, WELLSPRING8_ISO, BCM5974_FLAG_WELLSPRING8), 441 BCM5974_DEV(APPLE, WELLSPRING8_JIS, BCM5974_FLAG_WELLSPRING8), 442 443 /* MacbookPro12,1 MacbookPro11,4 */ 444 BCM5974_DEV(APPLE, WELLSPRING9_ANSI, BCM5974_FLAG_WELLSPRING9), 445 BCM5974_DEV(APPLE, WELLSPRING9_ISO, BCM5974_FLAG_WELLSPRING9), 446 BCM5974_DEV(APPLE, WELLSPRING9_JIS, BCM5974_FLAG_WELLSPRING9), 447 448 /* External "Magic" devices */ 449 BCM5974_DEV(APPLE, MAGIC_TRACKPAD2, BCM5974_FLAG_MAGIC_TRACKPAD2_USB), 450 }; 451 452 struct bcm5974_softc { 453 device_t sc_dev; 454 struct evdev_dev *sc_evdev; 455 /* device configuration */ 456 const struct bcm5974_dev_params *sc_params; 457 bool sc_saved_mode; 458 }; 459 460 static const uint8_t bcm5974_rdesc[] = { 461 0x05, BCM5974_TLC_PAGE, /* Usage Page (BCM5974_TLC_PAGE) */ 462 0x09, BCM5974_TLC_USAGE,/* Usage (BCM5974_TLC_USAGE) */ 463 0xA1, 0x01, /* Collection (Application) */ 464 0x06, 0x00, 0xFF, /* Usage Page (Vendor Defined 0xFF00) */ 465 0x09, 0x01, /* Usage (0x01) */ 466 0x15, 0x00, /* Logical Minimum (0) */ 467 0x26, 0xFF, 0x00, /* Logical Maximum (255) */ 468 0x75, 0x08, /* Report Size (8) */ 469 0x96, /* Report Count (BCM5974_BUFFER_MAX) */ 470 BCM5974_BUFFER_MAX & 0xFF, 471 BCM5974_BUFFER_MAX >> 8 & 0xFF, 472 0x81, 0x02, /* Input (Data,Var,Abs) */ 473 0xC0, /* End Collection */ 474 }; 475 476 /* 477 * function prototypes 478 */ 479 static evdev_open_t bcm5974_ev_open; 480 static evdev_close_t bcm5974_ev_close; 481 static const struct evdev_methods bcm5974_evdev_methods = { 482 .ev_open = &bcm5974_ev_open, 483 .ev_close = &bcm5974_ev_close, 484 }; 485 static hid_intr_t bcm5974_intr; 486 487 /* Device methods. */ 488 static device_identify_t bcm5974_identify; 489 static device_probe_t bcm5974_probe; 490 static device_attach_t bcm5974_attach; 491 static device_detach_t bcm5974_detach; 492 493 /* 494 * Type1 and Type2 touchpads use keyboard USB interface to switch from HID to 495 * RAW mode. Although it is possible to extend hkbd driver to support such a 496 * mode change requests, it's not wanted due to cross device tree dependencies. 497 * So, find lowest common denominator (struct usb_device of grandparent usbhid 498 * driver) of touchpad and keyboard drivers and issue direct USB requests. 499 */ 500 static int 501 bcm5974_set_device_mode_usb(struct bcm5974_softc *sc, bool on) 502 { 503 uint8_t mode_bytes[BCM5974_USB_REPORT_LEN]; 504 struct usb_ctl_request ucr; 505 int err; 506 507 ucr.ucr_request.bmRequestType = UT_READ_CLASS_INTERFACE; 508 ucr.ucr_request.bRequest = UR_GET_REPORT; 509 USETW2(ucr.ucr_request.wValue, 510 UHID_FEATURE_REPORT, BCM5974_USB_REPORT_ID); 511 ucr.ucr_request.wIndex[0] = BCM5974_USB_IFACE_INDEX; 512 ucr.ucr_request.wIndex[1] = 0; 513 USETW(ucr.ucr_request.wLength, BCM5974_USB_REPORT_LEN); 514 ucr.ucr_data = mode_bytes; 515 516 err = hid_ioctl(sc->sc_dev, USB_REQUEST, (uintptr_t)&ucr); 517 if (err != 0) { 518 DPRINTF("Failed to read device mode (%d)\n", err); 519 return (EIO); 520 } 521 #if 0 522 /* 523 * XXX Need to wait at least 250ms for hardware to get 524 * ready. The device mode handling appears to be handled 525 * asynchronously and we should not issue these commands too 526 * quickly. 527 */ 528 pause("WHW", hz / 4); 529 #endif 530 mode_bytes[0] = on ? BCM5974_USB_MODE_RAW : BCM5974_USB_MODE_HID; 531 ucr.ucr_request.bmRequestType = UT_WRITE_CLASS_INTERFACE; 532 ucr.ucr_request.bRequest = UR_SET_REPORT; 533 534 err = hid_ioctl(sc->sc_dev, USB_REQUEST, (uintptr_t)&ucr); 535 if (err != 0) { 536 DPRINTF("Failed to write device mode (%d)\n", err); 537 return (EIO); 538 } 539 540 return (0); 541 } 542 543 static int 544 bcm5974_set_device_mode_hid(struct bcm5974_softc *sc, bool on) 545 { 546 uint8_t mode_bytes[BCM5974_HID_REPORT_LEN] = { 547 BCM5974_HID_REPORT_ID, 548 on ? BCM5974_HID_MODE_RAW : BCM5974_HID_MODE_HID, 549 }; 550 #if 0 551 int err; 552 553 err = hid_get_report(sc->sc_dev, mode_bytes, BCM5974_HID_REPORT_LEN, 554 NULL, HID_FEATURE_REPORT, BCM5974_HID_REPORT_ID); 555 if (err != 0) { 556 DPRINTF("Failed to read device mode (%d)\n", err); 557 return (err); 558 } 559 /* 560 * XXX Need to wait at least 250ms for hardware to get 561 * ready. The device mode handling appears to be handled 562 * asynchronously and we should not issue these commands too 563 * quickly. 564 */ 565 pause("WHW", hz / 4); 566 mode_bytes[1] = on ? BCM5974_HID_MODE_RAW : BCM5974_HID_MODE_HID; 567 #endif 568 return (hid_set_report(sc->sc_dev, mode_bytes, BCM5974_HID_REPORT_LEN, 569 HID_FEATURE_REPORT, BCM5974_HID_REPORT_ID)); 570 } 571 572 static int 573 bcm5974_set_device_mode(struct bcm5974_softc *sc, bool on) 574 { 575 int err = 0; 576 577 switch (sc->sc_params->tp - tp) { 578 case TYPE1: 579 case TYPE2: 580 err = bcm5974_set_device_mode_usb(sc, on); 581 break; 582 case TYPE3: /* Type 3 does not require a mode switch */ 583 break; 584 case TYPE4: 585 case TYPE_MT2U: 586 err = bcm5974_set_device_mode_hid(sc, on); 587 break; 588 default: 589 KASSERT(0 == 1, ("Unknown trackpad type")); 590 } 591 592 if (!err) 593 sc->sc_saved_mode = on; 594 595 return (err); 596 } 597 598 static void 599 bcm5974_identify(driver_t *driver, device_t parent) 600 { 601 void *d_ptr; 602 hid_size_t d_len; 603 604 /* 605 * The bcm5974 touchpad has no stable RAW mode TLC in its report 606 * descriptor. So replace existing HID mode mouse TLC with dummy one 607 * to set proper transport layer buffer sizes, make driver probe 608 * simpler and prevent unwanted hms driver attachment. 609 */ 610 if (HIDBUS_LOOKUP_ID(parent, bcm5974_devs) != NULL && 611 hid_get_report_descr(parent, &d_ptr, &d_len) == 0 && 612 hid_is_mouse(d_ptr, d_len)) 613 hid_set_report_descr(parent, bcm5974_rdesc, 614 sizeof(bcm5974_rdesc)); 615 } 616 617 static int 618 bcm5974_probe(device_t dev) 619 { 620 int err; 621 622 err = HIDBUS_LOOKUP_DRIVER_INFO(dev, bcm5974_devs); 623 if (err != 0) 624 return (err); 625 626 hidbus_set_desc(dev, "Touchpad"); 627 628 return (BUS_PROBE_DEFAULT); 629 } 630 631 static int 632 bcm5974_attach(device_t dev) 633 { 634 struct bcm5974_softc *sc = device_get_softc(dev); 635 const struct hid_device_info *hw = hid_get_device_info(dev); 636 int err; 637 638 DPRINTFN(BCM5974_LLEVEL_INFO, "sc=%p\n", sc); 639 640 sc->sc_dev = dev; 641 642 /* get device specific configuration */ 643 sc->sc_params = bcm5974_dev_params + hidbus_get_driver_info(dev); 644 645 sc->sc_evdev = evdev_alloc(); 646 evdev_set_name(sc->sc_evdev, device_get_desc(dev)); 647 evdev_set_phys(sc->sc_evdev, device_get_nameunit(dev)); 648 evdev_set_id(sc->sc_evdev, hw->idBus, hw->idVendor, hw->idProduct, 649 hw->idVersion); 650 evdev_set_serial(sc->sc_evdev, hw->serial); 651 evdev_set_methods(sc->sc_evdev, sc, &bcm5974_evdev_methods); 652 evdev_support_prop(sc->sc_evdev, INPUT_PROP_POINTER); 653 evdev_support_event(sc->sc_evdev, EV_SYN); 654 evdev_support_event(sc->sc_evdev, EV_ABS); 655 evdev_support_event(sc->sc_evdev, EV_KEY); 656 evdev_set_flag(sc->sc_evdev, EVDEV_FLAG_EXT_EPOCH); /* hidbus child */ 657 658 #define BCM5974_ABS(evdev, code, param) \ 659 evdev_support_abs((evdev), (code), (param).min, (param).max, \ 660 ((param).max - (param).min) / (param).snratio, 0, \ 661 (param).size != 0 ? ((param).max - (param).min) / (param).size : 0); 662 663 /* finger position */ 664 BCM5974_ABS(sc->sc_evdev, ABS_MT_POSITION_X, sc->sc_params->x); 665 BCM5974_ABS(sc->sc_evdev, ABS_MT_POSITION_Y, sc->sc_params->y); 666 /* finger pressure */ 667 BCM5974_ABS(sc->sc_evdev, ABS_MT_PRESSURE, sc->sc_params->p); 668 /* finger touch area */ 669 BCM5974_ABS(sc->sc_evdev, ABS_MT_TOUCH_MAJOR, sc->sc_params->w); 670 BCM5974_ABS(sc->sc_evdev, ABS_MT_TOUCH_MINOR, sc->sc_params->w); 671 /* finger approach area */ 672 if ((sc->sc_params->tp->caps & USES_COMPACT_REPORT) == 0) { 673 BCM5974_ABS(sc->sc_evdev, ABS_MT_WIDTH_MAJOR, sc->sc_params->w); 674 BCM5974_ABS(sc->sc_evdev, ABS_MT_WIDTH_MINOR, sc->sc_params->w); 675 } 676 /* finger orientation */ 677 BCM5974_ABS(sc->sc_evdev, ABS_MT_ORIENTATION, sc->sc_params->o); 678 /* button properties */ 679 evdev_support_key(sc->sc_evdev, BTN_LEFT); 680 if ((sc->sc_params->tp->caps & HAS_INTEGRATED_BUTTON) != 0) 681 evdev_support_prop(sc->sc_evdev, INPUT_PROP_BUTTONPAD); 682 /* Enable automatic touch assignment for type B MT protocol */ 683 evdev_support_abs(sc->sc_evdev, ABS_MT_SLOT, 684 0, MAX_FINGERS - 1, 0, 0, 0); 685 evdev_support_abs(sc->sc_evdev, ABS_MT_TRACKING_ID, 686 -1, MAX_FINGERS - 1, 0, 0, 0); 687 if ((sc->sc_params->tp->caps & USES_COMPACT_REPORT) == 0) 688 evdev_set_flag(sc->sc_evdev, EVDEV_FLAG_MT_TRACK); 689 evdev_set_flag(sc->sc_evdev, EVDEV_FLAG_MT_AUTOREL); 690 /* Synaptics compatibility events */ 691 evdev_set_flag(sc->sc_evdev, EVDEV_FLAG_MT_STCOMPAT); 692 693 err = evdev_register(sc->sc_evdev); 694 if (err) 695 goto detach; 696 697 hidbus_set_intr(dev, bcm5974_intr, sc); 698 699 return (0); 700 701 detach: 702 bcm5974_detach(dev); 703 return (ENOMEM); 704 } 705 706 static int 707 bcm5974_detach(device_t dev) 708 { 709 struct bcm5974_softc *sc = device_get_softc(dev); 710 711 evdev_free(sc->sc_evdev); 712 713 return (0); 714 } 715 716 static int 717 bcm5974_resume(device_t dev) 718 { 719 struct bcm5974_softc *sc = device_get_softc(dev); 720 721 bcm5974_set_device_mode(sc, sc->sc_saved_mode); 722 723 return (0); 724 } 725 726 static void 727 bcm5974_intr(void *context, void *data, hid_size_t len) 728 { 729 struct bcm5974_softc *sc = context; 730 const struct bcm5974_dev_params *params = sc->sc_params; 731 union evdev_mt_slot slot_data; 732 struct tp_finger *f; 733 struct tp_finger_compact *fc; 734 int coords; 735 int ntouch; /* the finger number in touch */ 736 int ibt; /* button status */ 737 int i; 738 int slot; 739 uint8_t fsize = sizeof(struct tp_finger) + params->tp->delta; 740 741 if ((params->tp->caps & USES_COMPACT_REPORT) != 0) 742 fsize = sizeof(struct tp_finger_compact) + params->tp->delta; 743 744 if ((len < params->tp->offset + fsize) || 745 ((len - params->tp->offset) % fsize) != 0) { 746 DPRINTFN(BCM5974_LLEVEL_INFO, "Invalid length: %d, %x, %x\n", 747 len, sc->tp_data[0], sc->tp_data[1]); 748 return; 749 } 750 751 ibt = ((uint8_t *)data)[params->tp->button]; 752 ntouch = (len - params->tp->offset) / fsize; 753 754 for (i = 0, slot = 0; i != ntouch; i++) { 755 if ((params->tp->caps & USES_COMPACT_REPORT) != 0) { 756 fc = (struct tp_finger_compact *)(((uint8_t *)data) + 757 params->tp->offset + params->tp->delta + i * fsize); 758 coords = (int)le32toh(fc->coords); 759 DPRINTFN(BCM5974_LLEVEL_INFO, 760 "[%d]ibt=%d, taps=%d, x=%5d, y=%5d, state=%4d, " 761 "tchmaj=%4d, tchmin=%4d, size=%4d, pressure=%4d, " 762 "ot=%4x, id=%4x\n", 763 i, ibt, ntouch, coords << 19 >> 19, 764 coords << 6 >> 19, (u_int)coords >> 30, 765 fc->touch_major, fc->touch_minor, fc->size, 766 fc->pressure, fc->id_ori >> 5, fc->id_ori & 0x0f); 767 if (fc->touch_major == 0) 768 continue; 769 slot_data = (union evdev_mt_slot) { 770 .id = fc->id_ori & 0x0f, 771 .x = coords << 19 >> 19, 772 .y = params->y.min + params->y.max - 773 ((coords << 6) >> 19), 774 .p = fc->pressure, 775 .maj = fc->touch_major << 2, 776 .min = fc->touch_minor << 2, 777 .ori = (int)(fc->id_ori >> 5) - 4, 778 }; 779 evdev_mt_push_slot(sc->sc_evdev, slot, &slot_data); 780 slot++; 781 continue; 782 } 783 f = (struct tp_finger *)(((uint8_t *)data) + 784 params->tp->offset + params->tp->delta + i * fsize); 785 DPRINTFN(BCM5974_LLEVEL_INFO, 786 "[%d]ibt=%d, taps=%d, o=%4d, ax=%5d, ay=%5d, " 787 "rx=%5d, ry=%5d, tlmaj=%4d, tlmin=%4d, ot=%4x, " 788 "tchmaj=%4d, tchmin=%4d, pressure=%4d, m=%4x\n", 789 i, ibt, ntouch, BCM5974_LE2H(f->origin), 790 BCM5974_LE2H(f->abs_x), BCM5974_LE2H(f->abs_y), 791 BCM5974_LE2H(f->rel_x), BCM5974_LE2H(f->rel_y), 792 BCM5974_LE2H(f->tool_major), BCM5974_LE2H(f->tool_minor), 793 BCM5974_LE2H(f->orientation), BCM5974_LE2H(f->touch_major), 794 BCM5974_LE2H(f->touch_minor), BCM5974_LE2H(f->pressure), 795 BCM5974_LE2H(f->multi)); 796 797 if (BCM5974_LE2H(f->touch_major) == 0) 798 continue; 799 slot_data = (union evdev_mt_slot) { 800 .id = slot, 801 .x = BCM5974_LE2H(f->abs_x), 802 .y = params->y.min + params->y.max - 803 BCM5974_LE2H(f->abs_y), 804 .p = BCM5974_LE2H(f->pressure), 805 .maj = BCM5974_LE2H(f->touch_major) << 1, 806 .min = BCM5974_LE2H(f->touch_minor) << 1, 807 .w_maj = BCM5974_LE2H(f->tool_major) << 1, 808 .w_min = BCM5974_LE2H(f->tool_minor) << 1, 809 .ori = params->o.max - BCM5974_LE2H(f->orientation), 810 }; 811 evdev_mt_push_slot(sc->sc_evdev, slot, &slot_data); 812 slot++; 813 } 814 815 evdev_push_key(sc->sc_evdev, BTN_LEFT, ibt); 816 evdev_sync(sc->sc_evdev); 817 } 818 819 static int 820 bcm5974_ev_open(struct evdev_dev *evdev) 821 { 822 struct bcm5974_softc *sc = evdev_get_softc(evdev); 823 int err; 824 825 /* 826 * By default the touchpad behaves like a HID device, sending 827 * packets with reportID = 8. Such reports contain only 828 * limited information. They encode movement deltas and button 829 * events, but do not include data from the pressure 830 * sensors. The device input mode can be switched from HID 831 * reports to raw sensor data using vendor-specific USB 832 * control commands: 833 */ 834 err = bcm5974_set_device_mode(sc, true); 835 if (err != 0) { 836 DPRINTF("failed to set mode to RAW MODE (%d)\n", err); 837 return (err); 838 } 839 840 return (hidbus_intr_start(sc->sc_dev)); 841 } 842 843 static int 844 bcm5974_ev_close(struct evdev_dev *evdev) 845 { 846 struct bcm5974_softc *sc = evdev_get_softc(evdev); 847 int err; 848 849 err = hidbus_intr_stop(sc->sc_dev); 850 if (err != 0) 851 return (err); 852 853 /* 854 * During re-enumeration of the device we need to force the 855 * device back into HID mode before switching it to RAW 856 * mode. Else the device does not work like expected. 857 */ 858 err = bcm5974_set_device_mode(sc, false); 859 if (err != 0) 860 DPRINTF("Failed to set mode to HID MODE (%d)\n", err); 861 862 return (err); 863 } 864 865 static device_method_t bcm5974_methods[] = { 866 /* Device interface */ 867 DEVMETHOD(device_identify, bcm5974_identify), 868 DEVMETHOD(device_probe, bcm5974_probe), 869 DEVMETHOD(device_attach, bcm5974_attach), 870 DEVMETHOD(device_detach, bcm5974_detach), 871 DEVMETHOD(device_resume, bcm5974_resume), 872 DEVMETHOD_END 873 }; 874 875 static driver_t bcm5974_driver = { 876 .name = "bcm5974", 877 .methods = bcm5974_methods, 878 .size = sizeof(struct bcm5974_softc) 879 }; 880 881 DRIVER_MODULE(bcm5974, hidbus, bcm5974_driver, NULL, NULL); 882 MODULE_DEPEND(bcm5974, hidbus, 1, 1, 1); 883 MODULE_DEPEND(bcm5974, hid, 1, 1, 1); 884 MODULE_DEPEND(bcm5974, evdev, 1, 1, 1); 885 MODULE_VERSION(bcm5974, 1); 886 HID_PNP_INFO(bcm5974_devs); 887