Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/drivers/platform/x86/fujitsu-tablet.c

  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_DIRECTION,
 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_DIRECTION,
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_DIRECTION,
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 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us