Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
toshiba_acpi.c
Go to the documentation of this file.
1 /*
2  * toshiba_acpi.c - Toshiba Laptop ACPI Extras
3  *
4  *
5  * Copyright (C) 2002-2004 John Belmonte
6  * Copyright (C) 2008 Philip Langdale
7  * Copyright (C) 2010 Pierre Ducroquet
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22  *
23  *
24  * The devolpment page for this driver is located at
25  * http://memebeam.org/toys/ToshibaAcpiDriver.
26  *
27  * Credits:
28  * Jonathan A. Buzzard - Toshiba HCI info, and critical tips on reverse
29  * engineering the Windows drivers
30  * Yasushi Nagato - changes for linux kernel 2.4 -> 2.5
31  * Rob Miller - TV out and hotkeys help
32  *
33  *
34  * TODO
35  *
36  */
37 
38 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
39 
40 #define TOSHIBA_ACPI_VERSION "0.19"
41 #define PROC_INTERFACE_VERSION 1
42 
43 #include <linux/kernel.h>
44 #include <linux/module.h>
45 #include <linux/init.h>
46 #include <linux/types.h>
47 #include <linux/proc_fs.h>
48 #include <linux/seq_file.h>
49 #include <linux/backlight.h>
50 #include <linux/rfkill.h>
51 #include <linux/input.h>
53 #include <linux/leds.h>
54 #include <linux/slab.h>
55 #include <linux/workqueue.h>
56 #include <linux/i8042.h>
57 
58 #include <asm/uaccess.h>
59 
60 #include <acpi/acpi_drivers.h>
61 
62 MODULE_AUTHOR("John Belmonte");
63 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
64 MODULE_LICENSE("GPL");
65 
66 #define TOSHIBA_WMI_EVENT_GUID "59142400-C6A3-40FA-BADB-8A2652834100"
67 
68 /* Scan code for Fn key on TOS1900 models */
69 #define TOS1900_FN_SCAN 0x6e
70 
71 /* Toshiba ACPI method paths */
72 #define METHOD_VIDEO_OUT "\\_SB_.VALX.DSSX"
73 
74 /* Toshiba HCI interface definitions
75  *
76  * HCI is Toshiba's "Hardware Control Interface" which is supposed to
77  * be uniform across all their models. Ideally we would just call
78  * dedicated ACPI methods instead of using this primitive interface.
79  * However the ACPI methods seem to be incomplete in some areas (for
80  * example they allow setting, but not reading, the LCD brightness value),
81  * so this is still useful.
82  */
83 
84 #define HCI_WORDS 6
85 
86 /* operations */
87 #define HCI_SET 0xff00
88 #define HCI_GET 0xfe00
89 
90 /* return codes */
91 #define HCI_SUCCESS 0x0000
92 #define HCI_FAILURE 0x1000
93 #define HCI_NOT_SUPPORTED 0x8000
94 #define HCI_EMPTY 0x8c00
95 
96 /* registers */
97 #define HCI_FAN 0x0004
98 #define HCI_TR_BACKLIGHT 0x0005
99 #define HCI_SYSTEM_EVENT 0x0016
100 #define HCI_VIDEO_OUT 0x001c
101 #define HCI_HOTKEY_EVENT 0x001e
102 #define HCI_LCD_BRIGHTNESS 0x002a
103 #define HCI_WIRELESS 0x0056
104 
105 /* field definitions */
106 #define HCI_HOTKEY_DISABLE 0x0b
107 #define HCI_HOTKEY_ENABLE 0x09
108 #define HCI_LCD_BRIGHTNESS_BITS 3
109 #define HCI_LCD_BRIGHTNESS_SHIFT (16-HCI_LCD_BRIGHTNESS_BITS)
110 #define HCI_LCD_BRIGHTNESS_LEVELS (1 << HCI_LCD_BRIGHTNESS_BITS)
111 #define HCI_VIDEO_OUT_LCD 0x1
112 #define HCI_VIDEO_OUT_CRT 0x2
113 #define HCI_VIDEO_OUT_TV 0x4
114 #define HCI_WIRELESS_KILL_SWITCH 0x01
115 #define HCI_WIRELESS_BT_PRESENT 0x0f
116 #define HCI_WIRELESS_BT_ATTACH 0x40
117 #define HCI_WIRELESS_BT_POWER 0x80
118 
120  struct acpi_device *acpi_dev;
121  const char *method_hci;
122  struct rfkill *bt_rfk;
123  struct input_dev *hotkey_dev;
127 
131 
132  unsigned int illumination_supported:1;
133  unsigned int video_supported:1;
134  unsigned int fan_supported:1;
135  unsigned int system_event_supported:1;
136  unsigned int ntfy_supported:1;
137  unsigned int info_supported:1;
138  unsigned int tr_backlight_supported:1;
139 
140  struct mutex mutex;
141 };
142 
143 static struct toshiba_acpi_dev *toshiba_acpi;
144 
145 static const struct acpi_device_id toshiba_device_ids[] = {
146  {"TOS6200", 0},
147  {"TOS6208", 0},
148  {"TOS1900", 0},
149  {"", 0},
150 };
151 MODULE_DEVICE_TABLE(acpi, toshiba_device_ids);
152 
153 static const struct key_entry toshiba_acpi_keymap[] __devinitconst = {
154  { KE_KEY, 0x101, { KEY_MUTE } },
155  { KE_KEY, 0x102, { KEY_ZOOMOUT } },
156  { KE_KEY, 0x103, { KEY_ZOOMIN } },
157  { KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } },
158  { KE_KEY, 0x139, { KEY_ZOOMRESET } },
159  { KE_KEY, 0x13b, { KEY_COFFEE } },
160  { KE_KEY, 0x13c, { KEY_BATTERY } },
161  { KE_KEY, 0x13d, { KEY_SLEEP } },
162  { KE_KEY, 0x13e, { KEY_SUSPEND } },
163  { KE_KEY, 0x13f, { KEY_SWITCHVIDEOMODE } },
164  { KE_KEY, 0x140, { KEY_BRIGHTNESSDOWN } },
165  { KE_KEY, 0x141, { KEY_BRIGHTNESSUP } },
166  { KE_KEY, 0x142, { KEY_WLAN } },
167  { KE_KEY, 0x143, { KEY_TOUCHPAD_TOGGLE } },
168  { KE_KEY, 0x17f, { KEY_FN } },
169  { KE_KEY, 0xb05, { KEY_PROG2 } },
170  { KE_KEY, 0xb06, { KEY_WWW } },
171  { KE_KEY, 0xb07, { KEY_MAIL } },
172  { KE_KEY, 0xb30, { KEY_STOP } },
173  { KE_KEY, 0xb31, { KEY_PREVIOUSSONG } },
174  { KE_KEY, 0xb32, { KEY_NEXTSONG } },
175  { KE_KEY, 0xb33, { KEY_PLAYPAUSE } },
176  { KE_KEY, 0xb5a, { KEY_MEDIA } },
177  { KE_IGNORE, 0x1430, { KEY_RESERVED } },
178  { KE_END, 0 },
179 };
180 
181 /* utility
182  */
183 
184 static __inline__ void _set_bit(u32 * word, u32 mask, int value)
185 {
186  *word = (*word & ~mask) | (mask * value);
187 }
188 
189 /* acpi interface wrappers
190  */
191 
192 static int write_acpi_int(const char *methodName, int val)
193 {
194  struct acpi_object_list params;
195  union acpi_object in_objs[1];
197 
198  params.count = ARRAY_SIZE(in_objs);
199  params.pointer = in_objs;
200  in_objs[0].type = ACPI_TYPE_INTEGER;
201  in_objs[0].integer.value = val;
202 
203  status = acpi_evaluate_object(NULL, (char *)methodName, &params, NULL);
204  return (status == AE_OK) ? 0 : -EIO;
205 }
206 
207 /* Perform a raw HCI call. Here we don't care about input or output buffer
208  * format.
209  */
210 static acpi_status hci_raw(struct toshiba_acpi_dev *dev,
211  const u32 in[HCI_WORDS], u32 out[HCI_WORDS])
212 {
213  struct acpi_object_list params;
214  union acpi_object in_objs[HCI_WORDS];
215  struct acpi_buffer results;
216  union acpi_object out_objs[HCI_WORDS + 1];
218  int i;
219 
220  params.count = HCI_WORDS;
221  params.pointer = in_objs;
222  for (i = 0; i < HCI_WORDS; ++i) {
223  in_objs[i].type = ACPI_TYPE_INTEGER;
224  in_objs[i].integer.value = in[i];
225  }
226 
227  results.length = sizeof(out_objs);
228  results.pointer = out_objs;
229 
230  status = acpi_evaluate_object(dev->acpi_dev->handle,
231  (char *)dev->method_hci, &params,
232  &results);
233  if ((status == AE_OK) && (out_objs->package.count <= HCI_WORDS)) {
234  for (i = 0; i < out_objs->package.count; ++i) {
235  out[i] = out_objs->package.elements[i].integer.value;
236  }
237  }
238 
239  return status;
240 }
241 
242 /* common hci tasks (get or set one or two value)
243  *
244  * In addition to the ACPI status, the HCI system returns a result which
245  * may be useful (such as "not supported").
246  */
247 
248 static acpi_status hci_write1(struct toshiba_acpi_dev *dev, u32 reg,
249  u32 in1, u32 *result)
250 {
251  u32 in[HCI_WORDS] = { HCI_SET, reg, in1, 0, 0, 0 };
252  u32 out[HCI_WORDS];
253  acpi_status status = hci_raw(dev, in, out);
254  *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
255  return status;
256 }
257 
258 static acpi_status hci_read1(struct toshiba_acpi_dev *dev, u32 reg,
259  u32 *out1, u32 *result)
260 {
261  u32 in[HCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 };
262  u32 out[HCI_WORDS];
263  acpi_status status = hci_raw(dev, in, out);
264  *out1 = out[2];
265  *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
266  return status;
267 }
268 
269 static acpi_status hci_write2(struct toshiba_acpi_dev *dev, u32 reg,
270  u32 in1, u32 in2, u32 *result)
271 {
272  u32 in[HCI_WORDS] = { HCI_SET, reg, in1, in2, 0, 0 };
273  u32 out[HCI_WORDS];
274  acpi_status status = hci_raw(dev, in, out);
275  *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
276  return status;
277 }
278 
279 static acpi_status hci_read2(struct toshiba_acpi_dev *dev, u32 reg,
280  u32 *out1, u32 *out2, u32 *result)
281 {
282  u32 in[HCI_WORDS] = { HCI_GET, reg, *out1, *out2, 0, 0 };
283  u32 out[HCI_WORDS];
284  acpi_status status = hci_raw(dev, in, out);
285  *out1 = out[2];
286  *out2 = out[3];
287  *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
288  return status;
289 }
290 
291 /* Illumination support */
292 static int toshiba_illumination_available(struct toshiba_acpi_dev *dev)
293 {
294  u32 in[HCI_WORDS] = { 0, 0, 0, 0, 0, 0 };
295  u32 out[HCI_WORDS];
297 
298  in[0] = 0xf100;
299  status = hci_raw(dev, in, out);
300  if (ACPI_FAILURE(status)) {
301  pr_info("Illumination device not available\n");
302  return 0;
303  }
304  in[0] = 0xf400;
305  status = hci_raw(dev, in, out);
306  return 1;
307 }
308 
309 static void toshiba_illumination_set(struct led_classdev *cdev,
311 {
312  struct toshiba_acpi_dev *dev = container_of(cdev,
313  struct toshiba_acpi_dev, led_dev);
314  u32 in[HCI_WORDS] = { 0, 0, 0, 0, 0, 0 };
315  u32 out[HCI_WORDS];
317 
318  /* First request : initialize communication. */
319  in[0] = 0xf100;
320  status = hci_raw(dev, in, out);
321  if (ACPI_FAILURE(status)) {
322  pr_info("Illumination device not available\n");
323  return;
324  }
325 
326  if (brightness) {
327  /* Switch the illumination on */
328  in[0] = 0xf400;
329  in[1] = 0x14e;
330  in[2] = 1;
331  status = hci_raw(dev, in, out);
332  if (ACPI_FAILURE(status)) {
333  pr_info("ACPI call for illumination failed\n");
334  return;
335  }
336  } else {
337  /* Switch the illumination off */
338  in[0] = 0xf400;
339  in[1] = 0x14e;
340  in[2] = 0;
341  status = hci_raw(dev, in, out);
342  if (ACPI_FAILURE(status)) {
343  pr_info("ACPI call for illumination failed.\n");
344  return;
345  }
346  }
347 
348  /* Last request : close communication. */
349  in[0] = 0xf200;
350  in[1] = 0;
351  in[2] = 0;
352  hci_raw(dev, in, out);
353 }
354 
355 static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev)
356 {
357  struct toshiba_acpi_dev *dev = container_of(cdev,
358  struct toshiba_acpi_dev, led_dev);
359  u32 in[HCI_WORDS] = { 0, 0, 0, 0, 0, 0 };
360  u32 out[HCI_WORDS];
362  enum led_brightness result;
363 
364  /*¬†First request : initialize communication. */
365  in[0] = 0xf100;
366  status = hci_raw(dev, in, out);
367  if (ACPI_FAILURE(status)) {
368  pr_info("Illumination device not available\n");
369  return LED_OFF;
370  }
371 
372  /* Check the illumination */
373  in[0] = 0xf300;
374  in[1] = 0x14e;
375  status = hci_raw(dev, in, out);
376  if (ACPI_FAILURE(status)) {
377  pr_info("ACPI call for illumination failed.\n");
378  return LED_OFF;
379  }
380 
381  result = out[2] ? LED_FULL : LED_OFF;
382 
383  /* Last request : close communication. */
384  in[0] = 0xf200;
385  in[1] = 0;
386  in[2] = 0;
387  hci_raw(dev, in, out);
388 
389  return result;
390 }
391 
392 /* Bluetooth rfkill handlers */
393 
394 static u32 hci_get_bt_present(struct toshiba_acpi_dev *dev, bool *present)
395 {
396  u32 hci_result;
397  u32 value, value2;
398 
399  value = 0;
400  value2 = 0;
401  hci_read2(dev, HCI_WIRELESS, &value, &value2, &hci_result);
402  if (hci_result == HCI_SUCCESS)
403  *present = (value & HCI_WIRELESS_BT_PRESENT) ? true : false;
404 
405  return hci_result;
406 }
407 
408 static u32 hci_get_radio_state(struct toshiba_acpi_dev *dev, bool *radio_state)
409 {
410  u32 hci_result;
411  u32 value, value2;
412 
413  value = 0;
414  value2 = 0x0001;
415  hci_read2(dev, HCI_WIRELESS, &value, &value2, &hci_result);
416 
417  *radio_state = value & HCI_WIRELESS_KILL_SWITCH;
418  return hci_result;
419 }
420 
421 static int bt_rfkill_set_block(void *data, bool blocked)
422 {
423  struct toshiba_acpi_dev *dev = data;
424  u32 result1, result2;
425  u32 value;
426  int err;
427  bool radio_state;
428 
429  value = (blocked == false);
430 
431  mutex_lock(&dev->mutex);
432  if (hci_get_radio_state(dev, &radio_state) != HCI_SUCCESS) {
433  err = -EIO;
434  goto out;
435  }
436 
437  if (!radio_state) {
438  err = 0;
439  goto out;
440  }
441 
442  hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_POWER, &result1);
443  hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_ATTACH, &result2);
444 
445  if (result1 != HCI_SUCCESS || result2 != HCI_SUCCESS)
446  err = -EIO;
447  else
448  err = 0;
449  out:
450  mutex_unlock(&dev->mutex);
451  return err;
452 }
453 
454 static void bt_rfkill_poll(struct rfkill *rfkill, void *data)
455 {
456  bool new_rfk_state;
457  bool value;
458  u32 hci_result;
459  struct toshiba_acpi_dev *dev = data;
460 
461  mutex_lock(&dev->mutex);
462 
463  hci_result = hci_get_radio_state(dev, &value);
464  if (hci_result != HCI_SUCCESS) {
465  /* Can't do anything useful */
466  mutex_unlock(&dev->mutex);
467  return;
468  }
469 
470  new_rfk_state = value;
471 
472  mutex_unlock(&dev->mutex);
473 
474  if (rfkill_set_hw_state(rfkill, !new_rfk_state))
475  bt_rfkill_set_block(data, true);
476 }
477 
478 static const struct rfkill_ops toshiba_rfk_ops = {
479  .set_block = bt_rfkill_set_block,
480  .poll = bt_rfkill_poll,
481 };
482 
483 static int get_tr_backlight_status(struct toshiba_acpi_dev *dev, bool *enabled)
484 {
485  u32 hci_result;
486  u32 status;
487 
488  hci_read1(dev, HCI_TR_BACKLIGHT, &status, &hci_result);
489  *enabled = !status;
490  return hci_result == HCI_SUCCESS ? 0 : -EIO;
491 }
492 
493 static int set_tr_backlight_status(struct toshiba_acpi_dev *dev, bool enable)
494 {
495  u32 hci_result;
496  u32 value = !enable;
497 
498  hci_write1(dev, HCI_TR_BACKLIGHT, value, &hci_result);
499  return hci_result == HCI_SUCCESS ? 0 : -EIO;
500 }
501 
502 static struct proc_dir_entry *toshiba_proc_dir /*= 0*/ ;
503 
504 static int __get_lcd_brightness(struct toshiba_acpi_dev *dev)
505 {
506  u32 hci_result;
507  u32 value;
508  int brightness = 0;
509 
510  if (dev->tr_backlight_supported) {
511  bool enabled;
512  int ret = get_tr_backlight_status(dev, &enabled);
513  if (ret)
514  return ret;
515  if (enabled)
516  return 0;
517  brightness++;
518  }
519 
520  hci_read1(dev, HCI_LCD_BRIGHTNESS, &value, &hci_result);
521  if (hci_result == HCI_SUCCESS)
522  return brightness + (value >> HCI_LCD_BRIGHTNESS_SHIFT);
523 
524  return -EIO;
525 }
526 
527 static int get_lcd_brightness(struct backlight_device *bd)
528 {
529  struct toshiba_acpi_dev *dev = bl_get_data(bd);
530  return __get_lcd_brightness(dev);
531 }
532 
533 static int lcd_proc_show(struct seq_file *m, void *v)
534 {
535  struct toshiba_acpi_dev *dev = m->private;
536  int value;
537  int levels;
538 
539  if (!dev->backlight_dev)
540  return -ENODEV;
541 
542  levels = dev->backlight_dev->props.max_brightness + 1;
543  value = get_lcd_brightness(dev->backlight_dev);
544  if (value >= 0) {
545  seq_printf(m, "brightness: %d\n", value);
546  seq_printf(m, "brightness_levels: %d\n", levels);
547  return 0;
548  }
549 
550  pr_err("Error reading LCD brightness\n");
551  return -EIO;
552 }
553 
554 static int lcd_proc_open(struct inode *inode, struct file *file)
555 {
556  return single_open(file, lcd_proc_show, PDE(inode)->data);
557 }
558 
559 static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value)
560 {
561  u32 hci_result;
562 
563  if (dev->tr_backlight_supported) {
564  bool enable = !value;
565  int ret = set_tr_backlight_status(dev, enable);
566  if (ret)
567  return ret;
568  if (value)
569  value--;
570  }
571 
572  value = value << HCI_LCD_BRIGHTNESS_SHIFT;
573  hci_write1(dev, HCI_LCD_BRIGHTNESS, value, &hci_result);
574  return hci_result == HCI_SUCCESS ? 0 : -EIO;
575 }
576 
577 static int set_lcd_status(struct backlight_device *bd)
578 {
579  struct toshiba_acpi_dev *dev = bl_get_data(bd);
580  return set_lcd_brightness(dev, bd->props.brightness);
581 }
582 
583 static ssize_t lcd_proc_write(struct file *file, const char __user *buf,
584  size_t count, loff_t *pos)
585 {
586  struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
587  char cmd[42];
588  size_t len;
589  int value;
590  int ret;
591  int levels = dev->backlight_dev->props.max_brightness + 1;
592 
593  len = min(count, sizeof(cmd) - 1);
594  if (copy_from_user(cmd, buf, len))
595  return -EFAULT;
596  cmd[len] = '\0';
597 
598  if (sscanf(cmd, " brightness : %i", &value) == 1 &&
599  value >= 0 && value < levels) {
600  ret = set_lcd_brightness(dev, value);
601  if (ret == 0)
602  ret = count;
603  } else {
604  ret = -EINVAL;
605  }
606  return ret;
607 }
608 
609 static const struct file_operations lcd_proc_fops = {
610  .owner = THIS_MODULE,
611  .open = lcd_proc_open,
612  .read = seq_read,
613  .llseek = seq_lseek,
614  .release = single_release,
615  .write = lcd_proc_write,
616 };
617 
618 static int get_video_status(struct toshiba_acpi_dev *dev, u32 *status)
619 {
620  u32 hci_result;
621 
622  hci_read1(dev, HCI_VIDEO_OUT, status, &hci_result);
623  return hci_result == HCI_SUCCESS ? 0 : -EIO;
624 }
625 
626 static int video_proc_show(struct seq_file *m, void *v)
627 {
628  struct toshiba_acpi_dev *dev = m->private;
629  u32 value;
630  int ret;
631 
632  ret = get_video_status(dev, &value);
633  if (!ret) {
634  int is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0;
635  int is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0;
636  int is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0;
637  seq_printf(m, "lcd_out: %d\n", is_lcd);
638  seq_printf(m, "crt_out: %d\n", is_crt);
639  seq_printf(m, "tv_out: %d\n", is_tv);
640  }
641 
642  return ret;
643 }
644 
645 static int video_proc_open(struct inode *inode, struct file *file)
646 {
647  return single_open(file, video_proc_show, PDE(inode)->data);
648 }
649 
650 static ssize_t video_proc_write(struct file *file, const char __user *buf,
651  size_t count, loff_t *pos)
652 {
653  struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
654  char *cmd, *buffer;
655  int ret;
656  int value;
657  int remain = count;
658  int lcd_out = -1;
659  int crt_out = -1;
660  int tv_out = -1;
661  u32 video_out;
662 
663  cmd = kmalloc(count + 1, GFP_KERNEL);
664  if (!cmd)
665  return -ENOMEM;
666  if (copy_from_user(cmd, buf, count)) {
667  kfree(cmd);
668  return -EFAULT;
669  }
670  cmd[count] = '\0';
671 
672  buffer = cmd;
673 
674  /* scan expression. Multiple expressions may be delimited with ;
675  *
676  * NOTE: to keep scanning simple, invalid fields are ignored
677  */
678  while (remain) {
679  if (sscanf(buffer, " lcd_out : %i", &value) == 1)
680  lcd_out = value & 1;
681  else if (sscanf(buffer, " crt_out : %i", &value) == 1)
682  crt_out = value & 1;
683  else if (sscanf(buffer, " tv_out : %i", &value) == 1)
684  tv_out = value & 1;
685  /* advance to one character past the next ; */
686  do {
687  ++buffer;
688  --remain;
689  }
690  while (remain && *(buffer - 1) != ';');
691  }
692 
693  kfree(cmd);
694 
695  ret = get_video_status(dev, &video_out);
696  if (!ret) {
697  unsigned int new_video_out = video_out;
698  if (lcd_out != -1)
699  _set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out);
700  if (crt_out != -1)
701  _set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out);
702  if (tv_out != -1)
703  _set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out);
704  /* To avoid unnecessary video disruption, only write the new
705  * video setting if something changed. */
706  if (new_video_out != video_out)
707  ret = write_acpi_int(METHOD_VIDEO_OUT, new_video_out);
708  }
709 
710  return ret ? ret : count;
711 }
712 
713 static const struct file_operations video_proc_fops = {
714  .owner = THIS_MODULE,
715  .open = video_proc_open,
716  .read = seq_read,
717  .llseek = seq_lseek,
718  .release = single_release,
719  .write = video_proc_write,
720 };
721 
722 static int get_fan_status(struct toshiba_acpi_dev *dev, u32 *status)
723 {
724  u32 hci_result;
725 
726  hci_read1(dev, HCI_FAN, status, &hci_result);
727  return hci_result == HCI_SUCCESS ? 0 : -EIO;
728 }
729 
730 static int fan_proc_show(struct seq_file *m, void *v)
731 {
732  struct toshiba_acpi_dev *dev = m->private;
733  int ret;
734  u32 value;
735 
736  ret = get_fan_status(dev, &value);
737  if (!ret) {
738  seq_printf(m, "running: %d\n", (value > 0));
739  seq_printf(m, "force_on: %d\n", dev->force_fan);
740  }
741 
742  return ret;
743 }
744 
745 static int fan_proc_open(struct inode *inode, struct file *file)
746 {
747  return single_open(file, fan_proc_show, PDE(inode)->data);
748 }
749 
750 static ssize_t fan_proc_write(struct file *file, const char __user *buf,
751  size_t count, loff_t *pos)
752 {
753  struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
754  char cmd[42];
755  size_t len;
756  int value;
757  u32 hci_result;
758 
759  len = min(count, sizeof(cmd) - 1);
760  if (copy_from_user(cmd, buf, len))
761  return -EFAULT;
762  cmd[len] = '\0';
763 
764  if (sscanf(cmd, " force_on : %i", &value) == 1 &&
765  value >= 0 && value <= 1) {
766  hci_write1(dev, HCI_FAN, value, &hci_result);
767  if (hci_result != HCI_SUCCESS)
768  return -EIO;
769  else
770  dev->force_fan = value;
771  } else {
772  return -EINVAL;
773  }
774 
775  return count;
776 }
777 
778 static const struct file_operations fan_proc_fops = {
779  .owner = THIS_MODULE,
780  .open = fan_proc_open,
781  .read = seq_read,
782  .llseek = seq_lseek,
783  .release = single_release,
784  .write = fan_proc_write,
785 };
786 
787 static int keys_proc_show(struct seq_file *m, void *v)
788 {
789  struct toshiba_acpi_dev *dev = m->private;
790  u32 hci_result;
791  u32 value;
792 
793  if (!dev->key_event_valid && dev->system_event_supported) {
794  hci_read1(dev, HCI_SYSTEM_EVENT, &value, &hci_result);
795  if (hci_result == HCI_SUCCESS) {
796  dev->key_event_valid = 1;
797  dev->last_key_event = value;
798  } else if (hci_result == HCI_EMPTY) {
799  /* better luck next time */
800  } else if (hci_result == HCI_NOT_SUPPORTED) {
801  /* This is a workaround for an unresolved issue on
802  * some machines where system events sporadically
803  * become disabled. */
804  hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result);
805  pr_notice("Re-enabled hotkeys\n");
806  } else {
807  pr_err("Error reading hotkey status\n");
808  return -EIO;
809  }
810  }
811 
812  seq_printf(m, "hotkey_ready: %d\n", dev->key_event_valid);
813  seq_printf(m, "hotkey: 0x%04x\n", dev->last_key_event);
814  return 0;
815 }
816 
817 static int keys_proc_open(struct inode *inode, struct file *file)
818 {
819  return single_open(file, keys_proc_show, PDE(inode)->data);
820 }
821 
822 static ssize_t keys_proc_write(struct file *file, const char __user *buf,
823  size_t count, loff_t *pos)
824 {
825  struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
826  char cmd[42];
827  size_t len;
828  int value;
829 
830  len = min(count, sizeof(cmd) - 1);
831  if (copy_from_user(cmd, buf, len))
832  return -EFAULT;
833  cmd[len] = '\0';
834 
835  if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0) {
836  dev->key_event_valid = 0;
837  } else {
838  return -EINVAL;
839  }
840 
841  return count;
842 }
843 
844 static const struct file_operations keys_proc_fops = {
845  .owner = THIS_MODULE,
846  .open = keys_proc_open,
847  .read = seq_read,
848  .llseek = seq_lseek,
849  .release = single_release,
850  .write = keys_proc_write,
851 };
852 
853 static int version_proc_show(struct seq_file *m, void *v)
854 {
855  seq_printf(m, "driver: %s\n", TOSHIBA_ACPI_VERSION);
856  seq_printf(m, "proc_interface: %d\n", PROC_INTERFACE_VERSION);
857  return 0;
858 }
859 
860 static int version_proc_open(struct inode *inode, struct file *file)
861 {
862  return single_open(file, version_proc_show, PDE(inode)->data);
863 }
864 
865 static const struct file_operations version_proc_fops = {
866  .owner = THIS_MODULE,
867  .open = version_proc_open,
868  .read = seq_read,
869  .llseek = seq_lseek,
870  .release = single_release,
871 };
872 
873 /* proc and module init
874  */
875 
876 #define PROC_TOSHIBA "toshiba"
877 
878 static void __devinit
879 create_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
880 {
881  if (dev->backlight_dev)
882  proc_create_data("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir,
883  &lcd_proc_fops, dev);
884  if (dev->video_supported)
885  proc_create_data("video", S_IRUGO | S_IWUSR, toshiba_proc_dir,
886  &video_proc_fops, dev);
887  if (dev->fan_supported)
888  proc_create_data("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir,
889  &fan_proc_fops, dev);
890  if (dev->hotkey_dev)
891  proc_create_data("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir,
892  &keys_proc_fops, dev);
893  proc_create_data("version", S_IRUGO, toshiba_proc_dir,
894  &version_proc_fops, dev);
895 }
896 
897 static void remove_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
898 {
899  if (dev->backlight_dev)
900  remove_proc_entry("lcd", toshiba_proc_dir);
901  if (dev->video_supported)
902  remove_proc_entry("video", toshiba_proc_dir);
903  if (dev->fan_supported)
904  remove_proc_entry("fan", toshiba_proc_dir);
905  if (dev->hotkey_dev)
906  remove_proc_entry("keys", toshiba_proc_dir);
907  remove_proc_entry("version", toshiba_proc_dir);
908 }
909 
910 static const struct backlight_ops toshiba_backlight_data = {
911  .options = BL_CORE_SUSPENDRESUME,
912  .get_brightness = get_lcd_brightness,
913  .update_status = set_lcd_status,
914 };
915 
916 static bool toshiba_acpi_i8042_filter(unsigned char data, unsigned char str,
917  struct serio *port)
918 {
919  if (str & 0x20)
920  return false;
921 
922  if (unlikely(data == 0xe0))
923  return false;
924 
925  if ((data & 0x7f) == TOS1900_FN_SCAN) {
926  schedule_work(&toshiba_acpi->hotkey_work);
927  return true;
928  }
929 
930  return false;
931 }
932 
933 static void toshiba_acpi_hotkey_work(struct work_struct *work)
934 {
935  acpi_handle ec_handle = ec_get_handle();
937 
938  if (!ec_handle)
939  return;
940 
941  status = acpi_evaluate_object(ec_handle, "NTFY", NULL, NULL);
942  if (ACPI_FAILURE(status))
943  pr_err("ACPI NTFY method execution failed\n");
944 }
945 
946 /*
947  * Returns hotkey scancode, or < 0 on failure.
948  */
949 static int toshiba_acpi_query_hotkey(struct toshiba_acpi_dev *dev)
950 {
951  struct acpi_buffer buf;
952  union acpi_object out_obj;
954 
955  buf.pointer = &out_obj;
956  buf.length = sizeof(out_obj);
957 
958  status = acpi_evaluate_object(dev->acpi_dev->handle, "INFO",
959  NULL, &buf);
960  if (ACPI_FAILURE(status) || out_obj.type != ACPI_TYPE_INTEGER) {
961  pr_err("ACPI INFO method execution failed\n");
962  return -EIO;
963  }
964 
965  return out_obj.integer.value;
966 }
967 
968 static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev,
969  int scancode)
970 {
971  if (scancode == 0x100)
972  return;
973 
974  /* act on key press; ignore key release */
975  if (scancode & 0x80)
976  return;
977 
978  if (!sparse_keymap_report_event(dev->hotkey_dev, scancode, 1, true))
979  pr_info("Unknown key %x\n", scancode);
980 }
981 
982 static int __devinit toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev)
983 {
985  acpi_handle ec_handle, handle;
986  int error;
987  u32 hci_result;
988 
989  dev->hotkey_dev = input_allocate_device();
990  if (!dev->hotkey_dev) {
991  pr_info("Unable to register input device\n");
992  return -ENOMEM;
993  }
994 
995  dev->hotkey_dev->name = "Toshiba input device";
996  dev->hotkey_dev->phys = "toshiba_acpi/input0";
997  dev->hotkey_dev->id.bustype = BUS_HOST;
998 
999  error = sparse_keymap_setup(dev->hotkey_dev, toshiba_acpi_keymap, NULL);
1000  if (error)
1001  goto err_free_dev;
1002 
1003  /*
1004  * For some machines the SCI responsible for providing hotkey
1005  * notification doesn't fire. We can trigger the notification
1006  * whenever the Fn key is pressed using the NTFY method, if
1007  * supported, so if it's present set up an i8042 key filter
1008  * for this purpose.
1009  */
1010  status = AE_ERROR;
1011  ec_handle = ec_get_handle();
1012  if (ec_handle)
1013  status = acpi_get_handle(ec_handle, "NTFY", &handle);
1014 
1015  if (ACPI_SUCCESS(status)) {
1016  INIT_WORK(&dev->hotkey_work, toshiba_acpi_hotkey_work);
1017 
1018  error = i8042_install_filter(toshiba_acpi_i8042_filter);
1019  if (error) {
1020  pr_err("Error installing key filter\n");
1021  goto err_free_keymap;
1022  }
1023 
1024  dev->ntfy_supported = 1;
1025  }
1026 
1027  /*
1028  * Determine hotkey query interface. Prefer using the INFO
1029  * method when it is available.
1030  */
1031  status = acpi_get_handle(dev->acpi_dev->handle, "INFO", &handle);
1032  if (ACPI_SUCCESS(status)) {
1033  dev->info_supported = 1;
1034  } else {
1035  hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result);
1036  if (hci_result == HCI_SUCCESS)
1037  dev->system_event_supported = 1;
1038  }
1039 
1040  if (!dev->info_supported && !dev->system_event_supported) {
1041  pr_warn("No hotkey query interface found\n");
1042  goto err_remove_filter;
1043  }
1044 
1045  status = acpi_evaluate_object(dev->acpi_dev->handle, "ENAB", NULL, NULL);
1046  if (ACPI_FAILURE(status)) {
1047  pr_info("Unable to enable hotkeys\n");
1048  error = -ENODEV;
1049  goto err_remove_filter;
1050  }
1051 
1052  error = input_register_device(dev->hotkey_dev);
1053  if (error) {
1054  pr_info("Unable to register input device\n");
1055  goto err_remove_filter;
1056  }
1057 
1058  hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE, &hci_result);
1059  return 0;
1060 
1061  err_remove_filter:
1062  if (dev->ntfy_supported)
1063  i8042_remove_filter(toshiba_acpi_i8042_filter);
1064  err_free_keymap:
1065  sparse_keymap_free(dev->hotkey_dev);
1066  err_free_dev:
1067  input_free_device(dev->hotkey_dev);
1068  dev->hotkey_dev = NULL;
1069  return error;
1070 }
1071 
1072 static int __devinit toshiba_acpi_setup_backlight(struct toshiba_acpi_dev *dev)
1073 {
1074  struct backlight_properties props;
1075  int brightness;
1076  int ret;
1077  bool enabled;
1078 
1079  /*
1080  * Some machines don't support the backlight methods at all, and
1081  * others support it read-only. Either of these is pretty useless,
1082  * so only register the backlight device if the backlight method
1083  * supports both reads and writes.
1084  */
1085  brightness = __get_lcd_brightness(dev);
1086  if (brightness < 0)
1087  return 0;
1088  ret = set_lcd_brightness(dev, brightness);
1089  if (ret) {
1090  pr_debug("Backlight method is read-only, disabling backlight support\n");
1091  return 0;
1092  }
1093 
1094  /* Determine whether or not BIOS supports transflective backlight */
1095  ret = get_tr_backlight_status(dev, &enabled);
1096  dev->tr_backlight_supported = !ret;
1097 
1098  memset(&props, 0, sizeof(props));
1099  props.type = BACKLIGHT_PLATFORM;
1100  props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1;
1101 
1102  /* adding an extra level and having 0 change to transflective mode */
1103  if (dev->tr_backlight_supported)
1104  props.max_brightness++;
1105 
1106  dev->backlight_dev = backlight_device_register("toshiba",
1107  &dev->acpi_dev->dev,
1108  dev,
1109  &toshiba_backlight_data,
1110  &props);
1111  if (IS_ERR(dev->backlight_dev)) {
1112  ret = PTR_ERR(dev->backlight_dev);
1113  pr_err("Could not register toshiba backlight device\n");
1114  dev->backlight_dev = NULL;
1115  return ret;
1116  }
1117 
1118  dev->backlight_dev->props.brightness = brightness;
1119  return 0;
1120 }
1121 
1122 static int toshiba_acpi_remove(struct acpi_device *acpi_dev, int type)
1123 {
1124  struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
1125 
1126  remove_toshiba_proc_entries(dev);
1127 
1128  if (dev->ntfy_supported) {
1129  i8042_remove_filter(toshiba_acpi_i8042_filter);
1131  }
1132 
1133  if (dev->hotkey_dev) {
1134  input_unregister_device(dev->hotkey_dev);
1135  sparse_keymap_free(dev->hotkey_dev);
1136  }
1137 
1138  if (dev->bt_rfk) {
1139  rfkill_unregister(dev->bt_rfk);
1140  rfkill_destroy(dev->bt_rfk);
1141  }
1142 
1143  if (dev->backlight_dev)
1145 
1146  if (dev->illumination_supported)
1148 
1149  if (toshiba_acpi)
1150  toshiba_acpi = NULL;
1151 
1152  kfree(dev);
1153 
1154  return 0;
1155 }
1156 
1157 static const char * __devinit find_hci_method(acpi_handle handle)
1158 {
1161 
1162  status = acpi_get_handle(handle, "GHCI", &hci_handle);
1163  if (ACPI_SUCCESS(status))
1164  return "GHCI";
1165 
1166  status = acpi_get_handle(handle, "SPFC", &hci_handle);
1167  if (ACPI_SUCCESS(status))
1168  return "SPFC";
1169 
1170  return NULL;
1171 }
1172 
1173 static int __devinit toshiba_acpi_add(struct acpi_device *acpi_dev)
1174 {
1175  struct toshiba_acpi_dev *dev;
1176  const char *hci_method;
1177  u32 dummy;
1178  bool bt_present;
1179  int ret = 0;
1180 
1181  if (toshiba_acpi)
1182  return -EBUSY;
1183 
1184  pr_info("Toshiba Laptop ACPI Extras version %s\n",
1186 
1187  hci_method = find_hci_method(acpi_dev->handle);
1188  if (!hci_method) {
1189  pr_err("HCI interface not found\n");
1190  return -ENODEV;
1191  }
1192 
1193  dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1194  if (!dev)
1195  return -ENOMEM;
1196  dev->acpi_dev = acpi_dev;
1197  dev->method_hci = hci_method;
1198  acpi_dev->driver_data = dev;
1199 
1200  if (toshiba_acpi_setup_keyboard(dev))
1201  pr_info("Unable to activate hotkeys\n");
1202 
1203  mutex_init(&dev->mutex);
1204 
1205  ret = toshiba_acpi_setup_backlight(dev);
1206  if (ret)
1207  goto error;
1208 
1209  /* Register rfkill switch for Bluetooth */
1210  if (hci_get_bt_present(dev, &bt_present) == HCI_SUCCESS && bt_present) {
1211  dev->bt_rfk = rfkill_alloc("Toshiba Bluetooth",
1212  &acpi_dev->dev,
1214  &toshiba_rfk_ops,
1215  dev);
1216  if (!dev->bt_rfk) {
1217  pr_err("unable to allocate rfkill device\n");
1218  ret = -ENOMEM;
1219  goto error;
1220  }
1221 
1222  ret = rfkill_register(dev->bt_rfk);
1223  if (ret) {
1224  pr_err("unable to register rfkill device\n");
1225  rfkill_destroy(dev->bt_rfk);
1226  goto error;
1227  }
1228  }
1229 
1230  if (toshiba_illumination_available(dev)) {
1231  dev->led_dev.name = "toshiba::illumination";
1232  dev->led_dev.max_brightness = 1;
1233  dev->led_dev.brightness_set = toshiba_illumination_set;
1234  dev->led_dev.brightness_get = toshiba_illumination_get;
1235  if (!led_classdev_register(&acpi_dev->dev, &dev->led_dev))
1236  dev->illumination_supported = 1;
1237  }
1238 
1239  /* Determine whether or not BIOS supports fan and video interfaces */
1240 
1241  ret = get_video_status(dev, &dummy);
1242  dev->video_supported = !ret;
1243 
1244  ret = get_fan_status(dev, &dummy);
1245  dev->fan_supported = !ret;
1246 
1247  create_toshiba_proc_entries(dev);
1248 
1249  toshiba_acpi = dev;
1250 
1251  return 0;
1252 
1253 error:
1254  toshiba_acpi_remove(acpi_dev, 0);
1255  return ret;
1256 }
1257 
1258 static void toshiba_acpi_notify(struct acpi_device *acpi_dev, u32 event)
1259 {
1260  struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
1261  u32 hci_result, value;
1262  int retries = 3;
1263  int scancode;
1264 
1265  if (event != 0x80)
1266  return;
1267 
1268  if (dev->info_supported) {
1269  scancode = toshiba_acpi_query_hotkey(dev);
1270  if (scancode < 0)
1271  pr_err("Failed to query hotkey event\n");
1272  else if (scancode != 0)
1273  toshiba_acpi_report_hotkey(dev, scancode);
1274  } else if (dev->system_event_supported) {
1275  do {
1276  hci_read1(dev, HCI_SYSTEM_EVENT, &value, &hci_result);
1277  switch (hci_result) {
1278  case HCI_SUCCESS:
1279  toshiba_acpi_report_hotkey(dev, (int)value);
1280  break;
1281  case HCI_NOT_SUPPORTED:
1282  /*
1283  * This is a workaround for an unresolved
1284  * issue on some machines where system events
1285  * sporadically become disabled.
1286  */
1287  hci_write1(dev, HCI_SYSTEM_EVENT, 1,
1288  &hci_result);
1289  pr_notice("Re-enabled hotkeys\n");
1290  /* fall through */
1291  default:
1292  retries--;
1293  break;
1294  }
1295  } while (retries && hci_result != HCI_EMPTY);
1296  }
1297 }
1298 
1299 #ifdef CONFIG_PM_SLEEP
1300 static int toshiba_acpi_suspend(struct device *device)
1301 {
1302  struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));
1303  u32 result;
1304 
1305  if (dev->hotkey_dev)
1306  hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_DISABLE, &result);
1307 
1308  return 0;
1309 }
1310 
1311 static int toshiba_acpi_resume(struct device *device)
1312 {
1313  struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));
1314  u32 result;
1315 
1316  if (dev->hotkey_dev)
1317  hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE, &result);
1318 
1319  return 0;
1320 }
1321 #endif
1322 
1323 static SIMPLE_DEV_PM_OPS(toshiba_acpi_pm,
1324  toshiba_acpi_suspend, toshiba_acpi_resume);
1325 
1326 static struct acpi_driver toshiba_acpi_driver = {
1327  .name = "Toshiba ACPI driver",
1328  .owner = THIS_MODULE,
1329  .ids = toshiba_device_ids,
1330  .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1331  .ops = {
1332  .add = toshiba_acpi_add,
1333  .remove = toshiba_acpi_remove,
1334  .notify = toshiba_acpi_notify,
1335  },
1336  .drv.pm = &toshiba_acpi_pm,
1337 };
1338 
1339 static int __init toshiba_acpi_init(void)
1340 {
1341  int ret;
1342 
1343  /*
1344  * Machines with this WMI guid aren't supported due to bugs in
1345  * their AML. This check relies on wmi initializing before
1346  * toshiba_acpi to guarantee guids have been identified.
1347  */
1349  return -ENODEV;
1350 
1351  toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
1352  if (!toshiba_proc_dir) {
1353  pr_err("Unable to create proc dir " PROC_TOSHIBA "\n");
1354  return -ENODEV;
1355  }
1356 
1357  ret = acpi_bus_register_driver(&toshiba_acpi_driver);
1358  if (ret) {
1359  pr_err("Failed to register ACPI driver: %d\n", ret);
1361  }
1362 
1363  return ret;
1364 }
1365 
1366 static void __exit toshiba_acpi_exit(void)
1367 {
1368  acpi_bus_unregister_driver(&toshiba_acpi_driver);
1369  if (toshiba_proc_dir)
1371 }
1372 
1373 module_init(toshiba_acpi_init);
1374 module_exit(toshiba_acpi_exit);