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