1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2006-2012 Robert Gerlach <khnz@gmx.de> 4 * Copyright (C) 2005-2006 Jan Rychter <jan@rychter.com> 5 */ 6 7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 8 9 #include <linux/kernel.h> 10 #include <linux/module.h> 11 #include <linux/init.h> 12 #include <linux/bitops.h> 13 #include <linux/io.h> 14 #include <linux/ioport.h> 15 #include <linux/acpi.h> 16 #include <linux/device.h> 17 #include <linux/interrupt.h> 18 #include <linux/input.h> 19 #include <linux/delay.h> 20 #include <linux/dmi.h> 21 #include <linux/platform_device.h> 22 23 #define MODULENAME "fujitsu-tablet" 24 25 #define INVERT_TABLET_MODE_BIT 0x01 26 #define INVERT_DOCK_STATE_BIT 0x02 27 #define FORCE_TABLET_MODE_IF_UNDOCK 0x04 28 29 #define KEYMAP_LEN 16 30 31 static const struct acpi_device_id fujitsu_ids[] = { 32 { .id = "FUJ02BD" }, 33 { .id = "FUJ02BF" }, 34 { .id = "" } 35 }; 36 37 struct fujitsu_config { 38 unsigned short keymap[KEYMAP_LEN]; 39 unsigned int quirks; 40 }; 41 42 static unsigned short keymap_Lifebook_Tseries[KEYMAP_LEN] __initdata = { 43 KEY_RESERVED, 44 KEY_RESERVED, 45 KEY_RESERVED, 46 KEY_RESERVED, 47 KEY_SCROLLDOWN, 48 KEY_SCROLLUP, 49 KEY_ROTATE_DISPLAY, 50 KEY_LEFTCTRL, 51 KEY_BRIGHTNESSUP, 52 KEY_BRIGHTNESSDOWN, 53 KEY_BRIGHTNESS_ZERO, 54 KEY_RESERVED, 55 KEY_RESERVED, 56 KEY_RESERVED, 57 KEY_RESERVED, 58 KEY_LEFTALT 59 }; 60 61 static unsigned short keymap_Lifebook_T901[KEYMAP_LEN] __initdata = { 62 KEY_RESERVED, 63 KEY_RESERVED, 64 KEY_RESERVED, 65 KEY_RESERVED, 66 KEY_SCROLLDOWN, 67 KEY_SCROLLUP, 68 KEY_CYCLEWINDOWS, 69 KEY_LEFTCTRL, 70 KEY_RESERVED, 71 KEY_RESERVED, 72 KEY_RESERVED, 73 KEY_RESERVED, 74 KEY_RESERVED, 75 KEY_RESERVED, 76 KEY_RESERVED, 77 KEY_LEFTMETA 78 }; 79 80 static unsigned short keymap_Lifebook_T902[KEYMAP_LEN] __initdata = { 81 KEY_RESERVED, 82 KEY_VOLUMEDOWN, 83 KEY_VOLUMEUP, 84 KEY_CYCLEWINDOWS, 85 KEY_PROG1, 86 KEY_PROG2, 87 KEY_LEFTMETA, 88 KEY_RESERVED, 89 KEY_RESERVED, 90 KEY_RESERVED, 91 KEY_RESERVED, 92 KEY_RESERVED, 93 KEY_RESERVED, 94 KEY_RESERVED, 95 KEY_RESERVED, 96 KEY_RESERVED, 97 }; 98 99 static unsigned short keymap_Lifebook_U810[KEYMAP_LEN] __initdata = { 100 KEY_RESERVED, 101 KEY_RESERVED, 102 KEY_RESERVED, 103 KEY_RESERVED, 104 KEY_PROG1, 105 KEY_PROG2, 106 KEY_ROTATE_DISPLAY, 107 KEY_RESERVED, 108 KEY_RESERVED, 109 KEY_RESERVED, 110 KEY_UP, 111 KEY_DOWN, 112 KEY_RESERVED, 113 KEY_RESERVED, 114 KEY_LEFTCTRL, 115 KEY_LEFTALT 116 }; 117 118 static unsigned short keymap_Stylistic_Tseries[KEYMAP_LEN] __initdata = { 119 KEY_RESERVED, 120 KEY_RESERVED, 121 KEY_RESERVED, 122 KEY_RESERVED, 123 KEY_PRINT, 124 KEY_BACKSPACE, 125 KEY_SPACE, 126 KEY_ENTER, 127 KEY_BRIGHTNESSUP, 128 KEY_BRIGHTNESSDOWN, 129 KEY_DOWN, 130 KEY_UP, 131 KEY_SCROLLUP, 132 KEY_SCROLLDOWN, 133 KEY_LEFTCTRL, 134 KEY_LEFTALT 135 }; 136 137 static unsigned short keymap_Stylistic_ST5xxx[KEYMAP_LEN] __initdata = { 138 KEY_RESERVED, 139 KEY_RESERVED, 140 KEY_RESERVED, 141 KEY_RESERVED, 142 KEY_MAIL, 143 KEY_ROTATE_DISPLAY, 144 KEY_ESC, 145 KEY_ENTER, 146 KEY_BRIGHTNESSUP, 147 KEY_BRIGHTNESSDOWN, 148 KEY_DOWN, 149 KEY_UP, 150 KEY_SCROLLUP, 151 KEY_SCROLLDOWN, 152 KEY_LEFTCTRL, 153 KEY_LEFTALT 154 }; 155 156 static struct { 157 struct input_dev *idev; 158 struct fujitsu_config config; 159 unsigned long prev_keymask; 160 161 char name[17]; 162 char phys[21]; 163 164 int irq; 165 int io_base; 166 int io_length; 167 } fujitsu; 168 169 static u8 fujitsu_ack(void) 170 { 171 return inb(fujitsu.io_base + 2); 172 } 173 174 static u8 fujitsu_status(void) 175 { 176 return inb(fujitsu.io_base + 6); 177 } 178 179 static u8 fujitsu_read_register(const u8 addr) 180 { 181 outb(addr, fujitsu.io_base); 182 return inb(fujitsu.io_base + 4); 183 } 184 185 static void fujitsu_send_state(void) 186 { 187 int state; 188 int dock, tablet_mode; 189 190 state = fujitsu_read_register(0xdd); 191 192 dock = state & 0x02; 193 if (fujitsu.config.quirks & INVERT_DOCK_STATE_BIT) 194 dock = !dock; 195 196 if ((fujitsu.config.quirks & FORCE_TABLET_MODE_IF_UNDOCK) && (!dock)) { 197 tablet_mode = 1; 198 } else{ 199 tablet_mode = state & 0x01; 200 if (fujitsu.config.quirks & INVERT_TABLET_MODE_BIT) 201 tablet_mode = !tablet_mode; 202 } 203 204 input_report_switch(fujitsu.idev, SW_DOCK, dock); 205 input_report_switch(fujitsu.idev, SW_TABLET_MODE, tablet_mode); 206 input_sync(fujitsu.idev); 207 } 208 209 static void fujitsu_reset(void) 210 { 211 int timeout = 50; 212 213 fujitsu_ack(); 214 215 while ((fujitsu_status() & 0x02) && (--timeout)) 216 msleep(20); 217 218 fujitsu_send_state(); 219 } 220 221 static int input_fujitsu_setup(struct device *parent, const char *name, 222 const char *phys) 223 { 224 struct input_dev *idev; 225 int error; 226 int i; 227 228 idev = input_allocate_device(); 229 if (!idev) 230 return -ENOMEM; 231 232 idev->dev.parent = parent; 233 idev->phys = phys; 234 idev->name = name; 235 idev->id.bustype = BUS_HOST; 236 idev->id.vendor = 0x1734; /* Fujitsu Siemens Computer GmbH */ 237 idev->id.product = 0x0001; 238 idev->id.version = 0x0101; 239 240 idev->keycode = fujitsu.config.keymap; 241 idev->keycodesize = sizeof(fujitsu.config.keymap[0]); 242 idev->keycodemax = ARRAY_SIZE(fujitsu.config.keymap); 243 244 __set_bit(EV_REP, idev->evbit); 245 246 for (i = 0; i < ARRAY_SIZE(fujitsu.config.keymap); i++) 247 if (fujitsu.config.keymap[i]) 248 input_set_capability(idev, EV_KEY, fujitsu.config.keymap[i]); 249 250 input_set_capability(idev, EV_MSC, MSC_SCAN); 251 252 input_set_capability(idev, EV_SW, SW_DOCK); 253 input_set_capability(idev, EV_SW, SW_TABLET_MODE); 254 255 error = input_register_device(idev); 256 if (error) { 257 input_free_device(idev); 258 return error; 259 } 260 261 fujitsu.idev = idev; 262 return 0; 263 } 264 265 static void input_fujitsu_remove(void) 266 { 267 input_unregister_device(fujitsu.idev); 268 } 269 270 static irqreturn_t fujitsu_interrupt(int irq, void *dev_id) 271 { 272 unsigned long keymask, changed; 273 unsigned int keycode; 274 int pressed; 275 int i; 276 277 if (unlikely(!(fujitsu_status() & 0x01))) 278 return IRQ_NONE; 279 280 fujitsu_send_state(); 281 282 keymask = fujitsu_read_register(0xde); 283 keymask |= fujitsu_read_register(0xdf) << 8; 284 keymask ^= 0xffff; 285 286 changed = keymask ^ fujitsu.prev_keymask; 287 if (changed) { 288 fujitsu.prev_keymask = keymask; 289 290 for_each_set_bit(i, &changed, KEYMAP_LEN) { 291 keycode = fujitsu.config.keymap[i]; 292 pressed = keymask & changed & BIT(i); 293 294 if (pressed) 295 input_event(fujitsu.idev, EV_MSC, MSC_SCAN, i); 296 297 input_report_key(fujitsu.idev, keycode, pressed); 298 input_sync(fujitsu.idev); 299 } 300 } 301 302 fujitsu_ack(); 303 return IRQ_HANDLED; 304 } 305 306 static void __init fujitsu_dmi_common(const struct dmi_system_id *dmi) 307 { 308 pr_info("%s\n", dmi->ident); 309 memcpy(fujitsu.config.keymap, dmi->driver_data, 310 sizeof(fujitsu.config.keymap)); 311 } 312 313 static int __init fujitsu_dmi_lifebook(const struct dmi_system_id *dmi) 314 { 315 fujitsu_dmi_common(dmi); 316 fujitsu.config.quirks |= INVERT_TABLET_MODE_BIT; 317 return 1; 318 } 319 320 static int __init fujitsu_dmi_stylistic(const struct dmi_system_id *dmi) 321 { 322 fujitsu_dmi_common(dmi); 323 fujitsu.config.quirks |= FORCE_TABLET_MODE_IF_UNDOCK; 324 fujitsu.config.quirks |= INVERT_DOCK_STATE_BIT; 325 return 1; 326 } 327 328 static const struct dmi_system_id dmi_ids[] __initconst = { 329 { 330 .callback = fujitsu_dmi_lifebook, 331 .ident = "Fujitsu Lifebook T901", 332 .matches = { 333 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 334 DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook T901") 335 }, 336 .driver_data = keymap_Lifebook_T901 337 }, 338 { 339 .callback = fujitsu_dmi_lifebook, 340 .ident = "Fujitsu Lifebook T901", 341 .matches = { 342 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 343 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK T901") 344 }, 345 .driver_data = keymap_Lifebook_T901 346 }, 347 { 348 .callback = fujitsu_dmi_lifebook, 349 .ident = "Fujitsu Lifebook T902", 350 .matches = { 351 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 352 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK T902") 353 }, 354 .driver_data = keymap_Lifebook_T902 355 }, 356 { 357 .callback = fujitsu_dmi_lifebook, 358 .ident = "Fujitsu Siemens P/T Series", 359 .matches = { 360 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 361 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK") 362 }, 363 .driver_data = keymap_Lifebook_Tseries 364 }, 365 { 366 .callback = fujitsu_dmi_lifebook, 367 .ident = "Fujitsu Lifebook T Series", 368 .matches = { 369 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 370 DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook T") 371 }, 372 .driver_data = keymap_Lifebook_Tseries 373 }, 374 { 375 .callback = fujitsu_dmi_stylistic, 376 .ident = "Fujitsu Siemens Stylistic T Series", 377 .matches = { 378 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 379 DMI_MATCH(DMI_PRODUCT_NAME, "Stylistic T") 380 }, 381 .driver_data = keymap_Stylistic_Tseries 382 }, 383 { 384 .callback = fujitsu_dmi_lifebook, 385 .ident = "Fujitsu LifeBook U810", 386 .matches = { 387 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 388 DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook U810") 389 }, 390 .driver_data = keymap_Lifebook_U810 391 }, 392 { 393 .callback = fujitsu_dmi_stylistic, 394 .ident = "Fujitsu Siemens Stylistic ST5xxx Series", 395 .matches = { 396 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 397 DMI_MATCH(DMI_PRODUCT_NAME, "STYLISTIC ST5") 398 }, 399 .driver_data = keymap_Stylistic_ST5xxx 400 }, 401 { 402 .callback = fujitsu_dmi_stylistic, 403 .ident = "Fujitsu Siemens Stylistic ST5xxx Series", 404 .matches = { 405 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 406 DMI_MATCH(DMI_PRODUCT_NAME, "Stylistic ST5") 407 }, 408 .driver_data = keymap_Stylistic_ST5xxx 409 }, 410 { 411 .callback = fujitsu_dmi_lifebook, 412 .ident = "Unknown (using defaults)", 413 .matches = { 414 DMI_MATCH(DMI_SYS_VENDOR, ""), 415 DMI_MATCH(DMI_PRODUCT_NAME, "") 416 }, 417 .driver_data = keymap_Lifebook_Tseries 418 }, 419 { NULL } 420 }; 421 422 static acpi_status fujitsu_walk_resources(struct acpi_resource *res, void *data) 423 { 424 switch (res->type) { 425 case ACPI_RESOURCE_TYPE_IRQ: 426 fujitsu.irq = res->data.irq.interrupts[0]; 427 return AE_OK; 428 429 case ACPI_RESOURCE_TYPE_IO: 430 fujitsu.io_base = res->data.io.minimum; 431 fujitsu.io_length = res->data.io.address_length; 432 return AE_OK; 433 434 case ACPI_RESOURCE_TYPE_END_TAG: 435 if (fujitsu.irq && fujitsu.io_base) 436 return AE_OK; 437 else 438 return AE_NOT_FOUND; 439 440 default: 441 return AE_ERROR; 442 } 443 } 444 445 static int acpi_fujitsu_probe(struct platform_device *pdev) 446 { 447 struct acpi_device *adev; 448 acpi_status status; 449 int error; 450 451 adev = ACPI_COMPANION(&pdev->dev); 452 if (!adev) 453 return -ENODEV; 454 455 status = acpi_walk_resources(adev->handle, METHOD_NAME__CRS, 456 fujitsu_walk_resources, NULL); 457 if (ACPI_FAILURE(status) || !fujitsu.irq || !fujitsu.io_base) 458 return -ENODEV; 459 460 scnprintf(fujitsu.name, sizeof(fujitsu.name), "Fujitsu %s", acpi_device_hid(adev)); 461 scnprintf(fujitsu.phys, sizeof(fujitsu.phys), "%s/input0", acpi_device_hid(adev)); 462 463 error = input_fujitsu_setup(&pdev->dev, fujitsu.name, fujitsu.phys); 464 if (error) 465 return error; 466 467 if (!request_region(fujitsu.io_base, fujitsu.io_length, MODULENAME)) { 468 input_fujitsu_remove(); 469 return -EBUSY; 470 } 471 472 fujitsu_reset(); 473 474 error = request_irq(fujitsu.irq, fujitsu_interrupt, 475 IRQF_SHARED, MODULENAME, fujitsu_interrupt); 476 if (error) { 477 release_region(fujitsu.io_base, fujitsu.io_length); 478 input_fujitsu_remove(); 479 return error; 480 } 481 482 return 0; 483 } 484 485 static void acpi_fujitsu_remove(struct platform_device *pdev) 486 { 487 free_irq(fujitsu.irq, fujitsu_interrupt); 488 release_region(fujitsu.io_base, fujitsu.io_length); 489 input_fujitsu_remove(); 490 } 491 492 #ifdef CONFIG_PM_SLEEP 493 static int acpi_fujitsu_resume(struct device *dev) 494 { 495 fujitsu_reset(); 496 return 0; 497 } 498 #endif 499 500 static SIMPLE_DEV_PM_OPS(acpi_fujitsu_pm, NULL, acpi_fujitsu_resume); 501 502 static struct platform_driver acpi_fujitsu_driver = { 503 .probe = acpi_fujitsu_probe, 504 .remove = acpi_fujitsu_remove, 505 .driver = { 506 .name = MODULENAME, 507 .acpi_match_table = fujitsu_ids, 508 .pm = &acpi_fujitsu_pm, 509 }, 510 }; 511 512 static int __init fujitsu_module_init(void) 513 { 514 int error; 515 516 dmi_check_system(dmi_ids); 517 518 error = platform_driver_register(&acpi_fujitsu_driver); 519 if (error) 520 return error; 521 522 return 0; 523 } 524 525 static void __exit fujitsu_module_exit(void) 526 { 527 platform_driver_unregister(&acpi_fujitsu_driver); 528 } 529 530 module_init(fujitsu_module_init); 531 module_exit(fujitsu_module_exit); 532 533 MODULE_AUTHOR("Robert Gerlach <khnz@gmx.de>"); 534 MODULE_DESCRIPTION("Fujitsu tablet pc extras driver"); 535 MODULE_LICENSE("GPL"); 536 MODULE_VERSION("2.5"); 537 538 MODULE_DEVICE_TABLE(acpi, fujitsu_ids); 539