114ca7a47SHans de Goede /* 214ca7a47SHans de Goede * video.c - ACPI Video Driver 314ca7a47SHans de Goede * 414ca7a47SHans de Goede * Copyright (C) 2004 Luming Yu <luming.yu@intel.com> 514ca7a47SHans de Goede * Copyright (C) 2004 Bruno Ducrot <ducrot@poupinou.org> 614ca7a47SHans de Goede * Copyright (C) 2006 Thomas Tuttle <linux-kernel@ttuttle.net> 714ca7a47SHans de Goede * 814ca7a47SHans de Goede * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 914ca7a47SHans de Goede * 1014ca7a47SHans de Goede * This program is free software; you can redistribute it and/or modify 1114ca7a47SHans de Goede * it under the terms of the GNU General Public License as published by 1214ca7a47SHans de Goede * the Free Software Foundation; either version 2 of the License, or (at 1314ca7a47SHans de Goede * your option) any later version. 1414ca7a47SHans de Goede * 1514ca7a47SHans de Goede * This program is distributed in the hope that it will be useful, but 1614ca7a47SHans de Goede * WITHOUT ANY WARRANTY; without even the implied warranty of 1714ca7a47SHans de Goede * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 1814ca7a47SHans de Goede * General Public License for more details. 1914ca7a47SHans de Goede * 2014ca7a47SHans de Goede * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 2114ca7a47SHans de Goede */ 2214ca7a47SHans de Goede 2314ca7a47SHans de Goede #include <linux/kernel.h> 2414ca7a47SHans de Goede #include <linux/module.h> 2514ca7a47SHans de Goede #include <linux/init.h> 2614ca7a47SHans de Goede #include <linux/types.h> 2714ca7a47SHans de Goede #include <linux/list.h> 2814ca7a47SHans de Goede #include <linux/mutex.h> 2914ca7a47SHans de Goede #include <linux/input.h> 3014ca7a47SHans de Goede #include <linux/backlight.h> 3114ca7a47SHans de Goede #include <linux/thermal.h> 3214ca7a47SHans de Goede #include <linux/sort.h> 3314ca7a47SHans de Goede #include <linux/pci.h> 3414ca7a47SHans de Goede #include <linux/pci_ids.h> 3514ca7a47SHans de Goede #include <linux/slab.h> 3614ca7a47SHans de Goede #include <linux/dmi.h> 3714ca7a47SHans de Goede #include <linux/suspend.h> 3814ca7a47SHans de Goede #include <linux/acpi.h> 3914ca7a47SHans de Goede #include <acpi/video.h> 407c0f6ba6SLinus Torvalds #include <linux/uaccess.h> 4114ca7a47SHans de Goede 4214ca7a47SHans de Goede #define PREFIX "ACPI: " 4314ca7a47SHans de Goede 4414ca7a47SHans de Goede #define ACPI_VIDEO_BUS_NAME "Video Bus" 4514ca7a47SHans de Goede #define ACPI_VIDEO_DEVICE_NAME "Video Device" 4614ca7a47SHans de Goede 4714ca7a47SHans de Goede #define MAX_NAME_LEN 20 4814ca7a47SHans de Goede 4914ca7a47SHans de Goede #define _COMPONENT ACPI_VIDEO_COMPONENT 5014ca7a47SHans de Goede ACPI_MODULE_NAME("video"); 5114ca7a47SHans de Goede 5214ca7a47SHans de Goede MODULE_AUTHOR("Bruno Ducrot"); 5314ca7a47SHans de Goede MODULE_DESCRIPTION("ACPI Video Driver"); 5414ca7a47SHans de Goede MODULE_LICENSE("GPL"); 5514ca7a47SHans de Goede 5697e45dd6SGustavo A. R. Silva static bool brightness_switch_enabled = true; 5714ca7a47SHans de Goede module_param(brightness_switch_enabled, bool, 0644); 5814ca7a47SHans de Goede 5914ca7a47SHans de Goede /* 6014ca7a47SHans de Goede * By default, we don't allow duplicate ACPI video bus devices 6114ca7a47SHans de Goede * under the same VGA controller 6214ca7a47SHans de Goede */ 6314ca7a47SHans de Goede static bool allow_duplicates; 6414ca7a47SHans de Goede module_param(allow_duplicates, bool, 0644); 6514ca7a47SHans de Goede 6614ca7a47SHans de Goede static int disable_backlight_sysfs_if = -1; 6714ca7a47SHans de Goede module_param(disable_backlight_sysfs_if, int, 0444); 6814ca7a47SHans de Goede 6905bc59a0SHans de Goede #define REPORT_OUTPUT_KEY_EVENTS 0x01 7005bc59a0SHans de Goede #define REPORT_BRIGHTNESS_KEY_EVENTS 0x02 7105bc59a0SHans de Goede static int report_key_events = -1; 7205bc59a0SHans de Goede module_param(report_key_events, int, 0644); 7305bc59a0SHans de Goede MODULE_PARM_DESC(report_key_events, 7405bc59a0SHans de Goede "0: none, 1: output changes, 2: brightness changes, 3: all"); 7505bc59a0SHans de Goede 76592c8095SDmitry Frank /* 77592c8095SDmitry Frank * Whether the struct acpi_video_device_attrib::device_id_scheme bit should be 78592c8095SDmitry Frank * assumed even if not actually set. 79592c8095SDmitry Frank */ 80e50b9be1SAaron Lu static bool device_id_scheme = false; 81e50b9be1SAaron Lu module_param(device_id_scheme, bool, 0444); 82e50b9be1SAaron Lu 835928c281SHans de Goede static int only_lcd = -1; 845928c281SHans de Goede module_param(only_lcd, int, 0444); 85e50b9be1SAaron Lu 86970530cdSHans de Goede static int register_count; 87970530cdSHans de Goede static DEFINE_MUTEX(register_count_mutex); 8814e93553SHans de Goede static DEFINE_MUTEX(video_list_lock); 8914e93553SHans de Goede static LIST_HEAD(video_bus_head); 9014ca7a47SHans de Goede static int acpi_video_bus_add(struct acpi_device *device); 9114ca7a47SHans de Goede static int acpi_video_bus_remove(struct acpi_device *device); 9214ca7a47SHans de Goede static void acpi_video_bus_notify(struct acpi_device *device, u32 event); 9393a291dfSHans de Goede void acpi_video_detect_exit(void); 9414ca7a47SHans de Goede 95d485ef43SDmitry Frank /* 96d485ef43SDmitry Frank * Indices in the _BCL method response: the first two items are special, 97d485ef43SDmitry Frank * the rest are all supported levels. 98d485ef43SDmitry Frank * 99d485ef43SDmitry Frank * See page 575 of the ACPI spec 3.0 100d485ef43SDmitry Frank */ 101d485ef43SDmitry Frank enum acpi_video_level_idx { 102d485ef43SDmitry Frank ACPI_VIDEO_AC_LEVEL, /* level when machine has full power */ 103d485ef43SDmitry Frank ACPI_VIDEO_BATTERY_LEVEL, /* level when machine is on batteries */ 104d485ef43SDmitry Frank ACPI_VIDEO_FIRST_LEVEL, /* actual supported levels begin here */ 105d485ef43SDmitry Frank }; 106d485ef43SDmitry Frank 10714ca7a47SHans de Goede static const struct acpi_device_id video_device_ids[] = { 10814ca7a47SHans de Goede {ACPI_VIDEO_HID, 0}, 10914ca7a47SHans de Goede {"", 0}, 11014ca7a47SHans de Goede }; 11114ca7a47SHans de Goede MODULE_DEVICE_TABLE(acpi, video_device_ids); 11214ca7a47SHans de Goede 11314ca7a47SHans de Goede static struct acpi_driver acpi_video_bus = { 11414ca7a47SHans de Goede .name = "video", 11514ca7a47SHans de Goede .class = ACPI_VIDEO_CLASS, 11614ca7a47SHans de Goede .ids = video_device_ids, 11714ca7a47SHans de Goede .ops = { 11814ca7a47SHans de Goede .add = acpi_video_bus_add, 11914ca7a47SHans de Goede .remove = acpi_video_bus_remove, 12014ca7a47SHans de Goede .notify = acpi_video_bus_notify, 12114ca7a47SHans de Goede }, 12214ca7a47SHans de Goede }; 12314ca7a47SHans de Goede 12414ca7a47SHans de Goede struct acpi_video_bus_flags { 12514ca7a47SHans de Goede u8 multihead:1; /* can switch video heads */ 12614ca7a47SHans de Goede u8 rom:1; /* can retrieve a video rom */ 12714ca7a47SHans de Goede u8 post:1; /* can configure the head to */ 12814ca7a47SHans de Goede u8 reserved:5; 12914ca7a47SHans de Goede }; 13014ca7a47SHans de Goede 13114ca7a47SHans de Goede struct acpi_video_bus_cap { 13214ca7a47SHans de Goede u8 _DOS:1; /* Enable/Disable output switching */ 13314ca7a47SHans de Goede u8 _DOD:1; /* Enumerate all devices attached to display adapter */ 13414ca7a47SHans de Goede u8 _ROM:1; /* Get ROM Data */ 13514ca7a47SHans de Goede u8 _GPD:1; /* Get POST Device */ 13614ca7a47SHans de Goede u8 _SPD:1; /* Set POST Device */ 13714ca7a47SHans de Goede u8 _VPO:1; /* Video POST Options */ 13814ca7a47SHans de Goede u8 reserved:2; 13914ca7a47SHans de Goede }; 14014ca7a47SHans de Goede 14114ca7a47SHans de Goede struct acpi_video_device_attrib { 14214ca7a47SHans de Goede u32 display_index:4; /* A zero-based instance of the Display */ 14314ca7a47SHans de Goede u32 display_port_attachment:4; /* This field differentiates the display type */ 14414ca7a47SHans de Goede u32 display_type:4; /* Describe the specific type in use */ 14514ca7a47SHans de Goede u32 vendor_specific:4; /* Chipset Vendor Specific */ 14614ca7a47SHans de Goede u32 bios_can_detect:1; /* BIOS can detect the device */ 14714ca7a47SHans de Goede u32 depend_on_vga:1; /* Non-VGA output device whose power is related to 14814ca7a47SHans de Goede the VGA device. */ 14914ca7a47SHans de Goede u32 pipe_id:3; /* For VGA multiple-head devices. */ 15014ca7a47SHans de Goede u32 reserved:10; /* Must be 0 */ 151592c8095SDmitry Frank 152592c8095SDmitry Frank /* 153592c8095SDmitry Frank * The device ID might not actually follow the scheme described by this 154592c8095SDmitry Frank * struct acpi_video_device_attrib. If it does, then this bit 155592c8095SDmitry Frank * device_id_scheme is set; otherwise, other fields should be ignored. 156592c8095SDmitry Frank * 157592c8095SDmitry Frank * (but also see the global flag device_id_scheme) 158592c8095SDmitry Frank */ 159592c8095SDmitry Frank u32 device_id_scheme:1; 16014ca7a47SHans de Goede }; 16114ca7a47SHans de Goede 16214ca7a47SHans de Goede struct acpi_video_enumerated_device { 16314ca7a47SHans de Goede union { 16414ca7a47SHans de Goede u32 int_val; 16514ca7a47SHans de Goede struct acpi_video_device_attrib attrib; 16614ca7a47SHans de Goede } value; 16714ca7a47SHans de Goede struct acpi_video_device *bind_info; 16814ca7a47SHans de Goede }; 16914ca7a47SHans de Goede 17014ca7a47SHans de Goede struct acpi_video_bus { 17114ca7a47SHans de Goede struct acpi_device *device; 17214ca7a47SHans de Goede bool backlight_registered; 17314ca7a47SHans de Goede u8 dos_setting; 17414ca7a47SHans de Goede struct acpi_video_enumerated_device *attached_array; 17514ca7a47SHans de Goede u8 attached_count; 17614ca7a47SHans de Goede u8 child_count; 17714ca7a47SHans de Goede struct acpi_video_bus_cap cap; 17814ca7a47SHans de Goede struct acpi_video_bus_flags flags; 17914ca7a47SHans de Goede struct list_head video_device_list; 18014ca7a47SHans de Goede struct mutex device_list_lock; /* protects video_device_list */ 18114ca7a47SHans de Goede struct list_head entry; 18214ca7a47SHans de Goede struct input_dev *input; 18314ca7a47SHans de Goede char phys[32]; /* for input device */ 18414ca7a47SHans de Goede struct notifier_block pm_nb; 18514ca7a47SHans de Goede }; 18614ca7a47SHans de Goede 18714ca7a47SHans de Goede struct acpi_video_device_flags { 18814ca7a47SHans de Goede u8 crt:1; 18914ca7a47SHans de Goede u8 lcd:1; 19014ca7a47SHans de Goede u8 tvout:1; 19114ca7a47SHans de Goede u8 dvi:1; 19214ca7a47SHans de Goede u8 bios:1; 19314ca7a47SHans de Goede u8 unknown:1; 19414ca7a47SHans de Goede u8 notify:1; 19514ca7a47SHans de Goede u8 reserved:1; 19614ca7a47SHans de Goede }; 19714ca7a47SHans de Goede 19814ca7a47SHans de Goede struct acpi_video_device_cap { 19914ca7a47SHans de Goede u8 _ADR:1; /* Return the unique ID */ 20014ca7a47SHans de Goede u8 _BCL:1; /* Query list of brightness control levels supported */ 20114ca7a47SHans de Goede u8 _BCM:1; /* Set the brightness level */ 20214ca7a47SHans de Goede u8 _BQC:1; /* Get current brightness level */ 20314ca7a47SHans de Goede u8 _BCQ:1; /* Some buggy BIOS uses _BCQ instead of _BQC */ 20414ca7a47SHans de Goede u8 _DDC:1; /* Return the EDID for this device */ 20514ca7a47SHans de Goede }; 20614ca7a47SHans de Goede 20714ca7a47SHans de Goede struct acpi_video_device { 20814ca7a47SHans de Goede unsigned long device_id; 20914ca7a47SHans de Goede struct acpi_video_device_flags flags; 21014ca7a47SHans de Goede struct acpi_video_device_cap cap; 21114ca7a47SHans de Goede struct list_head entry; 21214ca7a47SHans de Goede struct delayed_work switch_brightness_work; 21314ca7a47SHans de Goede int switch_brightness_event; 21414ca7a47SHans de Goede struct acpi_video_bus *video; 21514ca7a47SHans de Goede struct acpi_device *dev; 21614ca7a47SHans de Goede struct acpi_video_device_brightness *brightness; 21714ca7a47SHans de Goede struct backlight_device *backlight; 21814ca7a47SHans de Goede struct thermal_cooling_device *cooling_dev; 21914ca7a47SHans de Goede }; 22014ca7a47SHans de Goede 22114ca7a47SHans de Goede static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data); 22214ca7a47SHans de Goede static void acpi_video_device_rebind(struct acpi_video_bus *video); 22314ca7a47SHans de Goede static void acpi_video_device_bind(struct acpi_video_bus *video, 22414ca7a47SHans de Goede struct acpi_video_device *device); 22514ca7a47SHans de Goede static int acpi_video_device_enumerate(struct acpi_video_bus *video); 22614ca7a47SHans de Goede static int acpi_video_device_lcd_set_level(struct acpi_video_device *device, 22714ca7a47SHans de Goede int level); 22814ca7a47SHans de Goede static int acpi_video_device_lcd_get_level_current( 22914ca7a47SHans de Goede struct acpi_video_device *device, 23014ca7a47SHans de Goede unsigned long long *level, bool raw); 23114ca7a47SHans de Goede static int acpi_video_get_next_level(struct acpi_video_device *device, 23214ca7a47SHans de Goede u32 level_current, u32 event); 23314ca7a47SHans de Goede static void acpi_video_switch_brightness(struct work_struct *work); 23414ca7a47SHans de Goede 23514ca7a47SHans de Goede /* backlight device sysfs support */ 23614ca7a47SHans de Goede static int acpi_video_get_brightness(struct backlight_device *bd) 23714ca7a47SHans de Goede { 23814ca7a47SHans de Goede unsigned long long cur_level; 23914ca7a47SHans de Goede int i; 24014ca7a47SHans de Goede struct acpi_video_device *vd = bl_get_data(bd); 24114ca7a47SHans de Goede 24214ca7a47SHans de Goede if (acpi_video_device_lcd_get_level_current(vd, &cur_level, false)) 24314ca7a47SHans de Goede return -EINVAL; 244d485ef43SDmitry Frank for (i = ACPI_VIDEO_FIRST_LEVEL; i < vd->brightness->count; i++) { 24514ca7a47SHans de Goede if (vd->brightness->levels[i] == cur_level) 246d485ef43SDmitry Frank return i - ACPI_VIDEO_FIRST_LEVEL; 24714ca7a47SHans de Goede } 24814ca7a47SHans de Goede return 0; 24914ca7a47SHans de Goede } 25014ca7a47SHans de Goede 25114ca7a47SHans de Goede static int acpi_video_set_brightness(struct backlight_device *bd) 25214ca7a47SHans de Goede { 253d485ef43SDmitry Frank int request_level = bd->props.brightness + ACPI_VIDEO_FIRST_LEVEL; 25414ca7a47SHans de Goede struct acpi_video_device *vd = bl_get_data(bd); 25514ca7a47SHans de Goede 25614ca7a47SHans de Goede cancel_delayed_work(&vd->switch_brightness_work); 25714ca7a47SHans de Goede return acpi_video_device_lcd_set_level(vd, 25814ca7a47SHans de Goede vd->brightness->levels[request_level]); 25914ca7a47SHans de Goede } 26014ca7a47SHans de Goede 26114ca7a47SHans de Goede static const struct backlight_ops acpi_backlight_ops = { 26214ca7a47SHans de Goede .get_brightness = acpi_video_get_brightness, 26314ca7a47SHans de Goede .update_status = acpi_video_set_brightness, 26414ca7a47SHans de Goede }; 26514ca7a47SHans de Goede 26614ca7a47SHans de Goede /* thermal cooling device callbacks */ 267d485ef43SDmitry Frank static int video_get_max_state(struct thermal_cooling_device *cooling_dev, 268d485ef43SDmitry Frank unsigned long *state) 26914ca7a47SHans de Goede { 27014ca7a47SHans de Goede struct acpi_device *device = cooling_dev->devdata; 27114ca7a47SHans de Goede struct acpi_video_device *video = acpi_driver_data(device); 27214ca7a47SHans de Goede 273d485ef43SDmitry Frank *state = video->brightness->count - ACPI_VIDEO_FIRST_LEVEL - 1; 27414ca7a47SHans de Goede return 0; 27514ca7a47SHans de Goede } 27614ca7a47SHans de Goede 277d485ef43SDmitry Frank static int video_get_cur_state(struct thermal_cooling_device *cooling_dev, 278d485ef43SDmitry Frank unsigned long *state) 27914ca7a47SHans de Goede { 28014ca7a47SHans de Goede struct acpi_device *device = cooling_dev->devdata; 28114ca7a47SHans de Goede struct acpi_video_device *video = acpi_driver_data(device); 28214ca7a47SHans de Goede unsigned long long level; 28314ca7a47SHans de Goede int offset; 28414ca7a47SHans de Goede 28514ca7a47SHans de Goede if (acpi_video_device_lcd_get_level_current(video, &level, false)) 28614ca7a47SHans de Goede return -EINVAL; 287d485ef43SDmitry Frank for (offset = ACPI_VIDEO_FIRST_LEVEL; offset < video->brightness->count; 288d485ef43SDmitry Frank offset++) 28914ca7a47SHans de Goede if (level == video->brightness->levels[offset]) { 29014ca7a47SHans de Goede *state = video->brightness->count - offset - 1; 29114ca7a47SHans de Goede return 0; 29214ca7a47SHans de Goede } 29314ca7a47SHans de Goede 29414ca7a47SHans de Goede return -EINVAL; 29514ca7a47SHans de Goede } 29614ca7a47SHans de Goede 29714ca7a47SHans de Goede static int 29814ca7a47SHans de Goede video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long state) 29914ca7a47SHans de Goede { 30014ca7a47SHans de Goede struct acpi_device *device = cooling_dev->devdata; 30114ca7a47SHans de Goede struct acpi_video_device *video = acpi_driver_data(device); 30214ca7a47SHans de Goede int level; 30314ca7a47SHans de Goede 304d485ef43SDmitry Frank if (state >= video->brightness->count - ACPI_VIDEO_FIRST_LEVEL) 30514ca7a47SHans de Goede return -EINVAL; 30614ca7a47SHans de Goede 30714ca7a47SHans de Goede state = video->brightness->count - state; 30814ca7a47SHans de Goede level = video->brightness->levels[state - 1]; 30914ca7a47SHans de Goede return acpi_video_device_lcd_set_level(video, level); 31014ca7a47SHans de Goede } 31114ca7a47SHans de Goede 31214ca7a47SHans de Goede static const struct thermal_cooling_device_ops video_cooling_ops = { 31314ca7a47SHans de Goede .get_max_state = video_get_max_state, 31414ca7a47SHans de Goede .get_cur_state = video_get_cur_state, 31514ca7a47SHans de Goede .set_cur_state = video_set_cur_state, 31614ca7a47SHans de Goede }; 31714ca7a47SHans de Goede 31814ca7a47SHans de Goede /* 31914ca7a47SHans de Goede * -------------------------------------------------------------------------- 32014ca7a47SHans de Goede * Video Management 32114ca7a47SHans de Goede * -------------------------------------------------------------------------- 32214ca7a47SHans de Goede */ 32314ca7a47SHans de Goede 32414ca7a47SHans de Goede static int 32505950094SAaron Lu acpi_video_device_lcd_query_levels(acpi_handle handle, 32614ca7a47SHans de Goede union acpi_object **levels) 32714ca7a47SHans de Goede { 32814ca7a47SHans de Goede int status; 32914ca7a47SHans de Goede struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 33014ca7a47SHans de Goede union acpi_object *obj; 33114ca7a47SHans de Goede 33214ca7a47SHans de Goede 33314ca7a47SHans de Goede *levels = NULL; 33414ca7a47SHans de Goede 33505950094SAaron Lu status = acpi_evaluate_object(handle, "_BCL", NULL, &buffer); 33614ca7a47SHans de Goede if (!ACPI_SUCCESS(status)) 33714ca7a47SHans de Goede return status; 33814ca7a47SHans de Goede obj = (union acpi_object *)buffer.pointer; 33914ca7a47SHans de Goede if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) { 34014ca7a47SHans de Goede printk(KERN_ERR PREFIX "Invalid _BCL data\n"); 34114ca7a47SHans de Goede status = -EFAULT; 34214ca7a47SHans de Goede goto err; 34314ca7a47SHans de Goede } 34414ca7a47SHans de Goede 34514ca7a47SHans de Goede *levels = obj; 34614ca7a47SHans de Goede 34714ca7a47SHans de Goede return 0; 34814ca7a47SHans de Goede 34914ca7a47SHans de Goede err: 35014ca7a47SHans de Goede kfree(buffer.pointer); 35114ca7a47SHans de Goede 35214ca7a47SHans de Goede return status; 35314ca7a47SHans de Goede } 35414ca7a47SHans de Goede 35514ca7a47SHans de Goede static int 35614ca7a47SHans de Goede acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level) 35714ca7a47SHans de Goede { 35814ca7a47SHans de Goede int status; 35914ca7a47SHans de Goede int state; 36014ca7a47SHans de Goede 36114ca7a47SHans de Goede status = acpi_execute_simple_method(device->dev->handle, 36214ca7a47SHans de Goede "_BCM", level); 36314ca7a47SHans de Goede if (ACPI_FAILURE(status)) { 36414ca7a47SHans de Goede ACPI_ERROR((AE_INFO, "Evaluating _BCM failed")); 36514ca7a47SHans de Goede return -EIO; 36614ca7a47SHans de Goede } 36714ca7a47SHans de Goede 36814ca7a47SHans de Goede device->brightness->curr = level; 369d485ef43SDmitry Frank for (state = ACPI_VIDEO_FIRST_LEVEL; state < device->brightness->count; 370d485ef43SDmitry Frank state++) 37114ca7a47SHans de Goede if (level == device->brightness->levels[state]) { 37214ca7a47SHans de Goede if (device->backlight) 373d485ef43SDmitry Frank device->backlight->props.brightness = 374d485ef43SDmitry Frank state - ACPI_VIDEO_FIRST_LEVEL; 37514ca7a47SHans de Goede return 0; 37614ca7a47SHans de Goede } 37714ca7a47SHans de Goede 37814ca7a47SHans de Goede ACPI_ERROR((AE_INFO, "Current brightness invalid")); 37914ca7a47SHans de Goede return -EINVAL; 38014ca7a47SHans de Goede } 38114ca7a47SHans de Goede 38214ca7a47SHans de Goede /* 38314ca7a47SHans de Goede * For some buggy _BQC methods, we need to add a constant value to 38414ca7a47SHans de Goede * the _BQC return value to get the actual current brightness level 38514ca7a47SHans de Goede */ 38614ca7a47SHans de Goede 38714ca7a47SHans de Goede static int bqc_offset_aml_bug_workaround; 3887ee33baaSHans de Goede static int video_set_bqc_offset(const struct dmi_system_id *d) 38914ca7a47SHans de Goede { 39014ca7a47SHans de Goede bqc_offset_aml_bug_workaround = 9; 39114ca7a47SHans de Goede return 0; 39214ca7a47SHans de Goede } 39314ca7a47SHans de Goede 3947ee33baaSHans de Goede static int video_disable_backlight_sysfs_if( 39514ca7a47SHans de Goede const struct dmi_system_id *d) 39614ca7a47SHans de Goede { 39714ca7a47SHans de Goede if (disable_backlight_sysfs_if == -1) 39814ca7a47SHans de Goede disable_backlight_sysfs_if = 1; 39914ca7a47SHans de Goede return 0; 40014ca7a47SHans de Goede } 40114ca7a47SHans de Goede 402e50b9be1SAaron Lu static int video_set_device_id_scheme(const struct dmi_system_id *d) 403e50b9be1SAaron Lu { 404e50b9be1SAaron Lu device_id_scheme = true; 405e50b9be1SAaron Lu return 0; 406e50b9be1SAaron Lu } 407e50b9be1SAaron Lu 408e50b9be1SAaron Lu static int video_enable_only_lcd(const struct dmi_system_id *d) 409e50b9be1SAaron Lu { 410e50b9be1SAaron Lu only_lcd = true; 411e50b9be1SAaron Lu return 0; 412e50b9be1SAaron Lu } 413e50b9be1SAaron Lu 4144b4b3b20SHans de Goede static int video_set_report_key_events(const struct dmi_system_id *id) 4154b4b3b20SHans de Goede { 4164b4b3b20SHans de Goede if (report_key_events == -1) 4174b4b3b20SHans de Goede report_key_events = (uintptr_t)id->driver_data; 4184b4b3b20SHans de Goede return 0; 4194b4b3b20SHans de Goede } 4204b4b3b20SHans de Goede 4216faadbbbSChristoph Hellwig static const struct dmi_system_id video_dmi_table[] = { 42214ca7a47SHans de Goede /* 42314ca7a47SHans de Goede * Broken _BQC workaround http://bugzilla.kernel.org/show_bug.cgi?id=13121 42414ca7a47SHans de Goede */ 42514ca7a47SHans de Goede { 42614ca7a47SHans de Goede .callback = video_set_bqc_offset, 42714ca7a47SHans de Goede .ident = "Acer Aspire 5720", 42814ca7a47SHans de Goede .matches = { 42914ca7a47SHans de Goede DMI_MATCH(DMI_BOARD_VENDOR, "Acer"), 43014ca7a47SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5720"), 43114ca7a47SHans de Goede }, 43214ca7a47SHans de Goede }, 43314ca7a47SHans de Goede { 43414ca7a47SHans de Goede .callback = video_set_bqc_offset, 43514ca7a47SHans de Goede .ident = "Acer Aspire 5710Z", 43614ca7a47SHans de Goede .matches = { 43714ca7a47SHans de Goede DMI_MATCH(DMI_BOARD_VENDOR, "Acer"), 43814ca7a47SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5710Z"), 43914ca7a47SHans de Goede }, 44014ca7a47SHans de Goede }, 44114ca7a47SHans de Goede { 44214ca7a47SHans de Goede .callback = video_set_bqc_offset, 44314ca7a47SHans de Goede .ident = "eMachines E510", 44414ca7a47SHans de Goede .matches = { 44514ca7a47SHans de Goede DMI_MATCH(DMI_BOARD_VENDOR, "EMACHINES"), 44614ca7a47SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "eMachines E510"), 44714ca7a47SHans de Goede }, 44814ca7a47SHans de Goede }, 44914ca7a47SHans de Goede { 45014ca7a47SHans de Goede .callback = video_set_bqc_offset, 45114ca7a47SHans de Goede .ident = "Acer Aspire 5315", 45214ca7a47SHans de Goede .matches = { 45314ca7a47SHans de Goede DMI_MATCH(DMI_BOARD_VENDOR, "Acer"), 45414ca7a47SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5315"), 45514ca7a47SHans de Goede }, 45614ca7a47SHans de Goede }, 45714ca7a47SHans de Goede { 45814ca7a47SHans de Goede .callback = video_set_bqc_offset, 45914ca7a47SHans de Goede .ident = "Acer Aspire 7720", 46014ca7a47SHans de Goede .matches = { 46114ca7a47SHans de Goede DMI_MATCH(DMI_BOARD_VENDOR, "Acer"), 46214ca7a47SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 7720"), 46314ca7a47SHans de Goede }, 46414ca7a47SHans de Goede }, 46514ca7a47SHans de Goede 46614ca7a47SHans de Goede /* 46714ca7a47SHans de Goede * Some machines have a broken acpi-video interface for brightness 46814ca7a47SHans de Goede * control, but still need an acpi_video_device_lcd_set_level() call 46914ca7a47SHans de Goede * on resume to turn the backlight power on. We Enable backlight 47014ca7a47SHans de Goede * control on these systems, but do not register a backlight sysfs 47114ca7a47SHans de Goede * as brightness control does not work. 47214ca7a47SHans de Goede */ 47314ca7a47SHans de Goede { 474de588b8fSHans de Goede /* https://bugzilla.kernel.org/show_bug.cgi?id=21012 */ 475de588b8fSHans de Goede .callback = video_disable_backlight_sysfs_if, 476de588b8fSHans de Goede .ident = "Toshiba Portege R700", 477de588b8fSHans de Goede .matches = { 478de588b8fSHans de Goede DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), 479de588b8fSHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE R700"), 480de588b8fSHans de Goede }, 481de588b8fSHans de Goede }, 482de588b8fSHans de Goede { 48314ca7a47SHans de Goede /* https://bugs.freedesktop.org/show_bug.cgi?id=82634 */ 48414ca7a47SHans de Goede .callback = video_disable_backlight_sysfs_if, 48514ca7a47SHans de Goede .ident = "Toshiba Portege R830", 48614ca7a47SHans de Goede .matches = { 48714ca7a47SHans de Goede DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), 48814ca7a47SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE R830"), 48914ca7a47SHans de Goede }, 49014ca7a47SHans de Goede }, 491b21f2e81SHans de Goede { 492b21f2e81SHans de Goede /* https://bugzilla.kernel.org/show_bug.cgi?id=21012 */ 493b21f2e81SHans de Goede .callback = video_disable_backlight_sysfs_if, 494b21f2e81SHans de Goede .ident = "Toshiba Satellite R830", 495b21f2e81SHans de Goede .matches = { 496b21f2e81SHans de Goede DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), 497b21f2e81SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "SATELLITE R830"), 498b21f2e81SHans de Goede }, 499b21f2e81SHans de Goede }, 500e50b9be1SAaron Lu /* 501e50b9be1SAaron Lu * Some machine's _DOD IDs don't have bit 31(Device ID Scheme) set 502e50b9be1SAaron Lu * but the IDs actually follow the Device ID Scheme. 503e50b9be1SAaron Lu */ 504e50b9be1SAaron Lu { 505e50b9be1SAaron Lu /* https://bugzilla.kernel.org/show_bug.cgi?id=104121 */ 506e50b9be1SAaron Lu .callback = video_set_device_id_scheme, 507e50b9be1SAaron Lu .ident = "ESPRIMO Mobile M9410", 508e50b9be1SAaron Lu .matches = { 509e50b9be1SAaron Lu DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 510e50b9be1SAaron Lu DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO Mobile M9410"), 511e50b9be1SAaron Lu }, 512e50b9be1SAaron Lu }, 513e50b9be1SAaron Lu /* 514e50b9be1SAaron Lu * Some machines have multiple video output devices, but only the one 515e50b9be1SAaron Lu * that is the type of LCD can do the backlight control so we should not 516e50b9be1SAaron Lu * register backlight interface for other video output devices. 517e50b9be1SAaron Lu */ 518e50b9be1SAaron Lu { 519e50b9be1SAaron Lu /* https://bugzilla.kernel.org/show_bug.cgi?id=104121 */ 520e50b9be1SAaron Lu .callback = video_enable_only_lcd, 521e50b9be1SAaron Lu .ident = "ESPRIMO Mobile M9410", 522e50b9be1SAaron Lu .matches = { 523e50b9be1SAaron Lu DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 524e50b9be1SAaron Lu DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO Mobile M9410"), 525e50b9be1SAaron Lu }, 526e50b9be1SAaron Lu }, 5274b4b3b20SHans de Goede /* 5284b4b3b20SHans de Goede * Some machines report wrong key events on the acpi-bus, suppress 5294b4b3b20SHans de Goede * key event reporting on these. Note this is only intended to work 5304b4b3b20SHans de Goede * around events which are plain wrong. In some cases we get double 5314b4b3b20SHans de Goede * events, in this case acpi-video is considered the canonical source 5324b4b3b20SHans de Goede * and the events from the other source should be filtered. E.g. 5334b4b3b20SHans de Goede * by calling acpi_video_handles_brightness_key_presses() from the 5344b4b3b20SHans de Goede * vendor acpi/wmi driver or by using /lib/udev/hwdb.d/60-keyboard.hwdb 5354b4b3b20SHans de Goede */ 5364b4b3b20SHans de Goede { 5374b4b3b20SHans de Goede .callback = video_set_report_key_events, 5384b4b3b20SHans de Goede .driver_data = (void *)((uintptr_t)REPORT_OUTPUT_KEY_EVENTS), 5394b4b3b20SHans de Goede .ident = "Dell Vostro V131", 5404b4b3b20SHans de Goede .matches = { 5414b4b3b20SHans de Goede DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 5424b4b3b20SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "Vostro V131"), 5434b4b3b20SHans de Goede }, 5444b4b3b20SHans de Goede }, 54514ca7a47SHans de Goede {} 54614ca7a47SHans de Goede }; 54714ca7a47SHans de Goede 54814ca7a47SHans de Goede static unsigned long long 54914ca7a47SHans de Goede acpi_video_bqc_value_to_level(struct acpi_video_device *device, 55014ca7a47SHans de Goede unsigned long long bqc_value) 55114ca7a47SHans de Goede { 55214ca7a47SHans de Goede unsigned long long level; 55314ca7a47SHans de Goede 55414ca7a47SHans de Goede if (device->brightness->flags._BQC_use_index) { 55514ca7a47SHans de Goede /* 556d485ef43SDmitry Frank * _BQC returns an index that doesn't account for the first 2 557d485ef43SDmitry Frank * items with special meaning (see enum acpi_video_level_idx), 558d485ef43SDmitry Frank * so we need to compensate for that by offsetting ourselves 55914ca7a47SHans de Goede */ 56014ca7a47SHans de Goede if (device->brightness->flags._BCL_reversed) 561d485ef43SDmitry Frank bqc_value = device->brightness->count - 562d485ef43SDmitry Frank ACPI_VIDEO_FIRST_LEVEL - 1 - bqc_value; 56314ca7a47SHans de Goede 564d485ef43SDmitry Frank level = device->brightness->levels[bqc_value + 565d485ef43SDmitry Frank ACPI_VIDEO_FIRST_LEVEL]; 56614ca7a47SHans de Goede } else { 56714ca7a47SHans de Goede level = bqc_value; 56814ca7a47SHans de Goede } 56914ca7a47SHans de Goede 57014ca7a47SHans de Goede level += bqc_offset_aml_bug_workaround; 57114ca7a47SHans de Goede 57214ca7a47SHans de Goede return level; 57314ca7a47SHans de Goede } 57414ca7a47SHans de Goede 57514ca7a47SHans de Goede static int 57614ca7a47SHans de Goede acpi_video_device_lcd_get_level_current(struct acpi_video_device *device, 57714ca7a47SHans de Goede unsigned long long *level, bool raw) 57814ca7a47SHans de Goede { 57914ca7a47SHans de Goede acpi_status status = AE_OK; 58014ca7a47SHans de Goede int i; 58114ca7a47SHans de Goede 58214ca7a47SHans de Goede if (device->cap._BQC || device->cap._BCQ) { 58314ca7a47SHans de Goede char *buf = device->cap._BQC ? "_BQC" : "_BCQ"; 58414ca7a47SHans de Goede 58514ca7a47SHans de Goede status = acpi_evaluate_integer(device->dev->handle, buf, 58614ca7a47SHans de Goede NULL, level); 58714ca7a47SHans de Goede if (ACPI_SUCCESS(status)) { 58814ca7a47SHans de Goede if (raw) { 58914ca7a47SHans de Goede /* 59014ca7a47SHans de Goede * Caller has indicated he wants the raw 59114ca7a47SHans de Goede * value returned by _BQC, so don't furtherly 59214ca7a47SHans de Goede * mess with the value. 59314ca7a47SHans de Goede */ 59414ca7a47SHans de Goede return 0; 59514ca7a47SHans de Goede } 59614ca7a47SHans de Goede 59714ca7a47SHans de Goede *level = acpi_video_bqc_value_to_level(device, *level); 59814ca7a47SHans de Goede 599d485ef43SDmitry Frank for (i = ACPI_VIDEO_FIRST_LEVEL; 600d485ef43SDmitry Frank i < device->brightness->count; i++) 60114ca7a47SHans de Goede if (device->brightness->levels[i] == *level) { 60214ca7a47SHans de Goede device->brightness->curr = *level; 60314ca7a47SHans de Goede return 0; 60414ca7a47SHans de Goede } 60514ca7a47SHans de Goede /* 60614ca7a47SHans de Goede * BQC returned an invalid level. 60714ca7a47SHans de Goede * Stop using it. 60814ca7a47SHans de Goede */ 60914ca7a47SHans de Goede ACPI_WARNING((AE_INFO, 61014ca7a47SHans de Goede "%s returned an invalid level", 61114ca7a47SHans de Goede buf)); 61214ca7a47SHans de Goede device->cap._BQC = device->cap._BCQ = 0; 61314ca7a47SHans de Goede } else { 61414ca7a47SHans de Goede /* 61514ca7a47SHans de Goede * Fixme: 61614ca7a47SHans de Goede * should we return an error or ignore this failure? 61714ca7a47SHans de Goede * dev->brightness->curr is a cached value which stores 61814ca7a47SHans de Goede * the correct current backlight level in most cases. 61914ca7a47SHans de Goede * ACPI video backlight still works w/ buggy _BQC. 62014ca7a47SHans de Goede * http://bugzilla.kernel.org/show_bug.cgi?id=12233 62114ca7a47SHans de Goede */ 62214ca7a47SHans de Goede ACPI_WARNING((AE_INFO, "Evaluating %s failed", buf)); 62314ca7a47SHans de Goede device->cap._BQC = device->cap._BCQ = 0; 62414ca7a47SHans de Goede } 62514ca7a47SHans de Goede } 62614ca7a47SHans de Goede 62714ca7a47SHans de Goede *level = device->brightness->curr; 62814ca7a47SHans de Goede return 0; 62914ca7a47SHans de Goede } 63014ca7a47SHans de Goede 63114ca7a47SHans de Goede static int 63214ca7a47SHans de Goede acpi_video_device_EDID(struct acpi_video_device *device, 63314ca7a47SHans de Goede union acpi_object **edid, ssize_t length) 63414ca7a47SHans de Goede { 63514ca7a47SHans de Goede int status; 63614ca7a47SHans de Goede struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 63714ca7a47SHans de Goede union acpi_object *obj; 63814ca7a47SHans de Goede union acpi_object arg0 = { ACPI_TYPE_INTEGER }; 63914ca7a47SHans de Goede struct acpi_object_list args = { 1, &arg0 }; 64014ca7a47SHans de Goede 64114ca7a47SHans de Goede 64214ca7a47SHans de Goede *edid = NULL; 64314ca7a47SHans de Goede 64414ca7a47SHans de Goede if (!device) 64514ca7a47SHans de Goede return -ENODEV; 64614ca7a47SHans de Goede if (length == 128) 64714ca7a47SHans de Goede arg0.integer.value = 1; 64814ca7a47SHans de Goede else if (length == 256) 64914ca7a47SHans de Goede arg0.integer.value = 2; 65014ca7a47SHans de Goede else 65114ca7a47SHans de Goede return -EINVAL; 65214ca7a47SHans de Goede 65314ca7a47SHans de Goede status = acpi_evaluate_object(device->dev->handle, "_DDC", &args, &buffer); 65414ca7a47SHans de Goede if (ACPI_FAILURE(status)) 65514ca7a47SHans de Goede return -ENODEV; 65614ca7a47SHans de Goede 65714ca7a47SHans de Goede obj = buffer.pointer; 65814ca7a47SHans de Goede 65914ca7a47SHans de Goede if (obj && obj->type == ACPI_TYPE_BUFFER) 66014ca7a47SHans de Goede *edid = obj; 66114ca7a47SHans de Goede else { 66214ca7a47SHans de Goede printk(KERN_ERR PREFIX "Invalid _DDC data\n"); 66314ca7a47SHans de Goede status = -EFAULT; 66414ca7a47SHans de Goede kfree(obj); 66514ca7a47SHans de Goede } 66614ca7a47SHans de Goede 66714ca7a47SHans de Goede return status; 66814ca7a47SHans de Goede } 66914ca7a47SHans de Goede 67014ca7a47SHans de Goede /* bus */ 67114ca7a47SHans de Goede 67214ca7a47SHans de Goede /* 67314ca7a47SHans de Goede * Arg: 67414ca7a47SHans de Goede * video : video bus device pointer 67514ca7a47SHans de Goede * bios_flag : 67614ca7a47SHans de Goede * 0. The system BIOS should NOT automatically switch(toggle) 67714ca7a47SHans de Goede * the active display output. 67814ca7a47SHans de Goede * 1. The system BIOS should automatically switch (toggle) the 67914ca7a47SHans de Goede * active display output. No switch event. 68014ca7a47SHans de Goede * 2. The _DGS value should be locked. 68114ca7a47SHans de Goede * 3. The system BIOS should not automatically switch (toggle) the 68214ca7a47SHans de Goede * active display output, but instead generate the display switch 68314ca7a47SHans de Goede * event notify code. 68414ca7a47SHans de Goede * lcd_flag : 68514ca7a47SHans de Goede * 0. The system BIOS should automatically control the brightness level 68614ca7a47SHans de Goede * of the LCD when the power changes from AC to DC 68714ca7a47SHans de Goede * 1. The system BIOS should NOT automatically control the brightness 68814ca7a47SHans de Goede * level of the LCD when the power changes from AC to DC. 68914ca7a47SHans de Goede * Return Value: 69014ca7a47SHans de Goede * -EINVAL wrong arg. 69114ca7a47SHans de Goede */ 69214ca7a47SHans de Goede 69314ca7a47SHans de Goede static int 69414ca7a47SHans de Goede acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag) 69514ca7a47SHans de Goede { 69614ca7a47SHans de Goede acpi_status status; 69714ca7a47SHans de Goede 69814ca7a47SHans de Goede if (!video->cap._DOS) 69914ca7a47SHans de Goede return 0; 70014ca7a47SHans de Goede 70114ca7a47SHans de Goede if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1) 70214ca7a47SHans de Goede return -EINVAL; 70314ca7a47SHans de Goede video->dos_setting = (lcd_flag << 2) | bios_flag; 70414ca7a47SHans de Goede status = acpi_execute_simple_method(video->device->handle, "_DOS", 70514ca7a47SHans de Goede (lcd_flag << 2) | bios_flag); 70614ca7a47SHans de Goede if (ACPI_FAILURE(status)) 70714ca7a47SHans de Goede return -EIO; 70814ca7a47SHans de Goede 70914ca7a47SHans de Goede return 0; 71014ca7a47SHans de Goede } 71114ca7a47SHans de Goede 71214ca7a47SHans de Goede /* 71314ca7a47SHans de Goede * Simple comparison function used to sort backlight levels. 71414ca7a47SHans de Goede */ 71514ca7a47SHans de Goede 71614ca7a47SHans de Goede static int 71714ca7a47SHans de Goede acpi_video_cmp_level(const void *a, const void *b) 71814ca7a47SHans de Goede { 71914ca7a47SHans de Goede return *(int *)a - *(int *)b; 72014ca7a47SHans de Goede } 72114ca7a47SHans de Goede 72214ca7a47SHans de Goede /* 72314ca7a47SHans de Goede * Decides if _BQC/_BCQ for this system is usable 72414ca7a47SHans de Goede * 72514ca7a47SHans de Goede * We do this by changing the level first and then read out the current 72614ca7a47SHans de Goede * brightness level, if the value does not match, find out if it is using 72714ca7a47SHans de Goede * index. If not, clear the _BQC/_BCQ capability. 72814ca7a47SHans de Goede */ 72914ca7a47SHans de Goede static int acpi_video_bqc_quirk(struct acpi_video_device *device, 73014ca7a47SHans de Goede int max_level, int current_level) 73114ca7a47SHans de Goede { 73214ca7a47SHans de Goede struct acpi_video_device_brightness *br = device->brightness; 73314ca7a47SHans de Goede int result; 73414ca7a47SHans de Goede unsigned long long level; 73514ca7a47SHans de Goede int test_level; 73614ca7a47SHans de Goede 73714ca7a47SHans de Goede /* don't mess with existing known broken systems */ 73814ca7a47SHans de Goede if (bqc_offset_aml_bug_workaround) 73914ca7a47SHans de Goede return 0; 74014ca7a47SHans de Goede 74114ca7a47SHans de Goede /* 74214ca7a47SHans de Goede * Some systems always report current brightness level as maximum 743592c8095SDmitry Frank * through _BQC, we need to test another value for them. However, 744592c8095SDmitry Frank * there is a subtlety: 745592c8095SDmitry Frank * 746592c8095SDmitry Frank * If the _BCL package ordering is descending, the first level 747592c8095SDmitry Frank * (br->levels[2]) is likely to be 0, and if the number of levels 748592c8095SDmitry Frank * matches the number of steps, we might confuse a returned level to 749592c8095SDmitry Frank * mean the index. 750592c8095SDmitry Frank * 751592c8095SDmitry Frank * For example: 752592c8095SDmitry Frank * 753592c8095SDmitry Frank * current_level = max_level = 100 754592c8095SDmitry Frank * test_level = 0 755592c8095SDmitry Frank * returned level = 100 756592c8095SDmitry Frank * 757592c8095SDmitry Frank * In this case 100 means the level, not the index, and _BCM failed. 758592c8095SDmitry Frank * Still, if the _BCL package ordering is descending, the index of 759592c8095SDmitry Frank * level 0 is also 100, so we assume _BQC is indexed, when it's not. 760592c8095SDmitry Frank * 761592c8095SDmitry Frank * This causes all _BQC calls to return bogus values causing weird 762592c8095SDmitry Frank * behavior from the user's perspective. For example: 763592c8095SDmitry Frank * 764592c8095SDmitry Frank * xbacklight -set 10; xbacklight -set 20; 765592c8095SDmitry Frank * 766592c8095SDmitry Frank * would flash to 90% and then slowly down to the desired level (20). 767592c8095SDmitry Frank * 768592c8095SDmitry Frank * The solution is simple; test anything other than the first level 769592c8095SDmitry Frank * (e.g. 1). 77014ca7a47SHans de Goede */ 771d485ef43SDmitry Frank test_level = current_level == max_level 772d485ef43SDmitry Frank ? br->levels[ACPI_VIDEO_FIRST_LEVEL + 1] 773d485ef43SDmitry Frank : max_level; 77414ca7a47SHans de Goede 77514ca7a47SHans de Goede result = acpi_video_device_lcd_set_level(device, test_level); 77614ca7a47SHans de Goede if (result) 77714ca7a47SHans de Goede return result; 77814ca7a47SHans de Goede 77914ca7a47SHans de Goede result = acpi_video_device_lcd_get_level_current(device, &level, true); 78014ca7a47SHans de Goede if (result) 78114ca7a47SHans de Goede return result; 78214ca7a47SHans de Goede 78314ca7a47SHans de Goede if (level != test_level) { 78414ca7a47SHans de Goede /* buggy _BQC found, need to find out if it uses index */ 78514ca7a47SHans de Goede if (level < br->count) { 78614ca7a47SHans de Goede if (br->flags._BCL_reversed) 787d485ef43SDmitry Frank level = br->count - ACPI_VIDEO_FIRST_LEVEL - 1 - level; 788d485ef43SDmitry Frank if (br->levels[level + ACPI_VIDEO_FIRST_LEVEL] == test_level) 78914ca7a47SHans de Goede br->flags._BQC_use_index = 1; 79014ca7a47SHans de Goede } 79114ca7a47SHans de Goede 79214ca7a47SHans de Goede if (!br->flags._BQC_use_index) 79314ca7a47SHans de Goede device->cap._BQC = device->cap._BCQ = 0; 79414ca7a47SHans de Goede } 79514ca7a47SHans de Goede 79614ca7a47SHans de Goede return 0; 79714ca7a47SHans de Goede } 79814ca7a47SHans de Goede 79905950094SAaron Lu int acpi_video_get_levels(struct acpi_device *device, 8009f9cd7eeSAaron Lu struct acpi_video_device_brightness **dev_br, 8019f9cd7eeSAaron Lu int *pmax_level) 80214ca7a47SHans de Goede { 80314ca7a47SHans de Goede union acpi_object *obj = NULL; 80414ca7a47SHans de Goede int i, max_level = 0, count = 0, level_ac_battery = 0; 80514ca7a47SHans de Goede union acpi_object *o; 80614ca7a47SHans de Goede struct acpi_video_device_brightness *br = NULL; 80705950094SAaron Lu int result = 0; 80814ca7a47SHans de Goede u32 value; 80914ca7a47SHans de Goede 81005950094SAaron Lu if (!ACPI_SUCCESS(acpi_video_device_lcd_query_levels(device->handle, 81105950094SAaron Lu &obj))) { 81214ca7a47SHans de Goede ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Could not query available " 81314ca7a47SHans de Goede "LCD brightness level\n")); 81405950094SAaron Lu result = -ENODEV; 81514ca7a47SHans de Goede goto out; 81614ca7a47SHans de Goede } 81714ca7a47SHans de Goede 818d485ef43SDmitry Frank if (obj->package.count < ACPI_VIDEO_FIRST_LEVEL) { 81905950094SAaron Lu result = -EINVAL; 82014ca7a47SHans de Goede goto out; 82105950094SAaron Lu } 82214ca7a47SHans de Goede 82314ca7a47SHans de Goede br = kzalloc(sizeof(*br), GFP_KERNEL); 82414ca7a47SHans de Goede if (!br) { 82514ca7a47SHans de Goede printk(KERN_ERR "can't allocate memory\n"); 82614ca7a47SHans de Goede result = -ENOMEM; 82714ca7a47SHans de Goede goto out; 82814ca7a47SHans de Goede } 82914ca7a47SHans de Goede 830592c8095SDmitry Frank /* 831592c8095SDmitry Frank * Note that we have to reserve 2 extra items (ACPI_VIDEO_FIRST_LEVEL), 832592c8095SDmitry Frank * in order to account for buggy BIOS which don't export the first two 833592c8095SDmitry Frank * special levels (see below) 834592c8095SDmitry Frank */ 8356da2ec56SKees Cook br->levels = kmalloc_array(obj->package.count + ACPI_VIDEO_FIRST_LEVEL, 8366da2ec56SKees Cook sizeof(*br->levels), 8376da2ec56SKees Cook GFP_KERNEL); 83814ca7a47SHans de Goede if (!br->levels) { 83914ca7a47SHans de Goede result = -ENOMEM; 84014ca7a47SHans de Goede goto out_free; 84114ca7a47SHans de Goede } 84214ca7a47SHans de Goede 84314ca7a47SHans de Goede for (i = 0; i < obj->package.count; i++) { 84414ca7a47SHans de Goede o = (union acpi_object *)&obj->package.elements[i]; 84514ca7a47SHans de Goede if (o->type != ACPI_TYPE_INTEGER) { 84614ca7a47SHans de Goede printk(KERN_ERR PREFIX "Invalid data\n"); 84714ca7a47SHans de Goede continue; 84814ca7a47SHans de Goede } 84914ca7a47SHans de Goede value = (u32) o->integer.value; 85014ca7a47SHans de Goede /* Skip duplicate entries */ 851d485ef43SDmitry Frank if (count > ACPI_VIDEO_FIRST_LEVEL 852d485ef43SDmitry Frank && br->levels[count - 1] == value) 85314ca7a47SHans de Goede continue; 85414ca7a47SHans de Goede 85514ca7a47SHans de Goede br->levels[count] = value; 85614ca7a47SHans de Goede 85714ca7a47SHans de Goede if (br->levels[count] > max_level) 85814ca7a47SHans de Goede max_level = br->levels[count]; 85914ca7a47SHans de Goede count++; 86014ca7a47SHans de Goede } 86114ca7a47SHans de Goede 86214ca7a47SHans de Goede /* 86314ca7a47SHans de Goede * some buggy BIOS don't export the levels 86414ca7a47SHans de Goede * when machine is on AC/Battery in _BCL package. 86514ca7a47SHans de Goede * In this case, the first two elements in _BCL packages 86614ca7a47SHans de Goede * are also supported brightness levels that OS should take care of. 86714ca7a47SHans de Goede */ 868d485ef43SDmitry Frank for (i = ACPI_VIDEO_FIRST_LEVEL; i < count; i++) { 869d485ef43SDmitry Frank if (br->levels[i] == br->levels[ACPI_VIDEO_AC_LEVEL]) 87014ca7a47SHans de Goede level_ac_battery++; 871d485ef43SDmitry Frank if (br->levels[i] == br->levels[ACPI_VIDEO_BATTERY_LEVEL]) 87214ca7a47SHans de Goede level_ac_battery++; 87314ca7a47SHans de Goede } 87414ca7a47SHans de Goede 875d485ef43SDmitry Frank if (level_ac_battery < ACPI_VIDEO_FIRST_LEVEL) { 876d485ef43SDmitry Frank level_ac_battery = ACPI_VIDEO_FIRST_LEVEL - level_ac_battery; 87714ca7a47SHans de Goede br->flags._BCL_no_ac_battery_levels = 1; 878d485ef43SDmitry Frank for (i = (count - 1 + level_ac_battery); 879d485ef43SDmitry Frank i >= ACPI_VIDEO_FIRST_LEVEL; i--) 88014ca7a47SHans de Goede br->levels[i] = br->levels[i - level_ac_battery]; 88114ca7a47SHans de Goede count += level_ac_battery; 882d485ef43SDmitry Frank } else if (level_ac_battery > ACPI_VIDEO_FIRST_LEVEL) 88314ca7a47SHans de Goede ACPI_ERROR((AE_INFO, "Too many duplicates in _BCL package")); 88414ca7a47SHans de Goede 88514ca7a47SHans de Goede /* Check if the _BCL package is in a reversed order */ 886d485ef43SDmitry Frank if (max_level == br->levels[ACPI_VIDEO_FIRST_LEVEL]) { 88714ca7a47SHans de Goede br->flags._BCL_reversed = 1; 888d485ef43SDmitry Frank sort(&br->levels[ACPI_VIDEO_FIRST_LEVEL], 889d485ef43SDmitry Frank count - ACPI_VIDEO_FIRST_LEVEL, 890d485ef43SDmitry Frank sizeof(br->levels[ACPI_VIDEO_FIRST_LEVEL]), 89114ca7a47SHans de Goede acpi_video_cmp_level, NULL); 89214ca7a47SHans de Goede } else if (max_level != br->levels[count - 1]) 89314ca7a47SHans de Goede ACPI_ERROR((AE_INFO, 89414ca7a47SHans de Goede "Found unordered _BCL package")); 89514ca7a47SHans de Goede 89614ca7a47SHans de Goede br->count = count; 89705950094SAaron Lu *dev_br = br; 8989f9cd7eeSAaron Lu if (pmax_level) 8999f9cd7eeSAaron Lu *pmax_level = max_level; 90005950094SAaron Lu 90105950094SAaron Lu out: 90205950094SAaron Lu kfree(obj); 90305950094SAaron Lu return result; 90405950094SAaron Lu out_free: 90505950094SAaron Lu kfree(br); 90605950094SAaron Lu goto out; 90705950094SAaron Lu } 90805950094SAaron Lu EXPORT_SYMBOL(acpi_video_get_levels); 90905950094SAaron Lu 91005950094SAaron Lu /* 91105950094SAaron Lu * Arg: 91205950094SAaron Lu * device : video output device (LCD, CRT, ..) 91305950094SAaron Lu * 91405950094SAaron Lu * Return Value: 91505950094SAaron Lu * Maximum brightness level 91605950094SAaron Lu * 91705950094SAaron Lu * Allocate and initialize device->brightness. 91805950094SAaron Lu */ 91905950094SAaron Lu 92005950094SAaron Lu static int 92105950094SAaron Lu acpi_video_init_brightness(struct acpi_video_device *device) 92205950094SAaron Lu { 92305950094SAaron Lu int i, max_level = 0; 92405950094SAaron Lu unsigned long long level, level_old; 92505950094SAaron Lu struct acpi_video_device_brightness *br = NULL; 92605950094SAaron Lu int result = -EINVAL; 92705950094SAaron Lu 9289f9cd7eeSAaron Lu result = acpi_video_get_levels(device->dev, &br, &max_level); 92905950094SAaron Lu if (result) 93005950094SAaron Lu return result; 93114ca7a47SHans de Goede device->brightness = br; 93214ca7a47SHans de Goede 93314ca7a47SHans de Goede /* _BQC uses INDEX while _BCL uses VALUE in some laptops */ 93414ca7a47SHans de Goede br->curr = level = max_level; 93514ca7a47SHans de Goede 93614ca7a47SHans de Goede if (!device->cap._BQC) 93714ca7a47SHans de Goede goto set_level; 93814ca7a47SHans de Goede 93914ca7a47SHans de Goede result = acpi_video_device_lcd_get_level_current(device, 94014ca7a47SHans de Goede &level_old, true); 94114ca7a47SHans de Goede if (result) 94214ca7a47SHans de Goede goto out_free_levels; 94314ca7a47SHans de Goede 94414ca7a47SHans de Goede result = acpi_video_bqc_quirk(device, max_level, level_old); 94514ca7a47SHans de Goede if (result) 94614ca7a47SHans de Goede goto out_free_levels; 94714ca7a47SHans de Goede /* 94814ca7a47SHans de Goede * cap._BQC may get cleared due to _BQC is found to be broken 94914ca7a47SHans de Goede * in acpi_video_bqc_quirk, so check again here. 95014ca7a47SHans de Goede */ 95114ca7a47SHans de Goede if (!device->cap._BQC) 95214ca7a47SHans de Goede goto set_level; 95314ca7a47SHans de Goede 95414ca7a47SHans de Goede level = acpi_video_bqc_value_to_level(device, level_old); 95514ca7a47SHans de Goede /* 95614ca7a47SHans de Goede * On some buggy laptops, _BQC returns an uninitialized 95714ca7a47SHans de Goede * value when invoked for the first time, i.e. 95814ca7a47SHans de Goede * level_old is invalid (no matter whether it's a level 95914ca7a47SHans de Goede * or an index). Set the backlight to max_level in this case. 96014ca7a47SHans de Goede */ 961d485ef43SDmitry Frank for (i = ACPI_VIDEO_FIRST_LEVEL; i < br->count; i++) 96214ca7a47SHans de Goede if (level == br->levels[i]) 96314ca7a47SHans de Goede break; 96414ca7a47SHans de Goede if (i == br->count || !level) 96514ca7a47SHans de Goede level = max_level; 96614ca7a47SHans de Goede 96714ca7a47SHans de Goede set_level: 96814ca7a47SHans de Goede result = acpi_video_device_lcd_set_level(device, level); 96914ca7a47SHans de Goede if (result) 97014ca7a47SHans de Goede goto out_free_levels; 97114ca7a47SHans de Goede 97214ca7a47SHans de Goede ACPI_DEBUG_PRINT((ACPI_DB_INFO, 973d485ef43SDmitry Frank "found %d brightness levels\n", 974d485ef43SDmitry Frank br->count - ACPI_VIDEO_FIRST_LEVEL)); 97505950094SAaron Lu return 0; 97614ca7a47SHans de Goede 97714ca7a47SHans de Goede out_free_levels: 97814ca7a47SHans de Goede kfree(br->levels); 97914ca7a47SHans de Goede kfree(br); 98014ca7a47SHans de Goede device->brightness = NULL; 98114ca7a47SHans de Goede return result; 98214ca7a47SHans de Goede } 98314ca7a47SHans de Goede 98414ca7a47SHans de Goede /* 98514ca7a47SHans de Goede * Arg: 98614ca7a47SHans de Goede * device : video output device (LCD, CRT, ..) 98714ca7a47SHans de Goede * 98814ca7a47SHans de Goede * Return Value: 98914ca7a47SHans de Goede * None 99014ca7a47SHans de Goede * 99114ca7a47SHans de Goede * Find out all required AML methods defined under the output 99214ca7a47SHans de Goede * device. 99314ca7a47SHans de Goede */ 99414ca7a47SHans de Goede 99514ca7a47SHans de Goede static void acpi_video_device_find_cap(struct acpi_video_device *device) 99614ca7a47SHans de Goede { 99714ca7a47SHans de Goede if (acpi_has_method(device->dev->handle, "_ADR")) 99814ca7a47SHans de Goede device->cap._ADR = 1; 99914ca7a47SHans de Goede if (acpi_has_method(device->dev->handle, "_BCL")) 100014ca7a47SHans de Goede device->cap._BCL = 1; 100114ca7a47SHans de Goede if (acpi_has_method(device->dev->handle, "_BCM")) 100214ca7a47SHans de Goede device->cap._BCM = 1; 100314ca7a47SHans de Goede if (acpi_has_method(device->dev->handle, "_BQC")) { 100414ca7a47SHans de Goede device->cap._BQC = 1; 100514ca7a47SHans de Goede } else if (acpi_has_method(device->dev->handle, "_BCQ")) { 100614ca7a47SHans de Goede printk(KERN_WARNING FW_BUG "_BCQ is used instead of _BQC\n"); 100714ca7a47SHans de Goede device->cap._BCQ = 1; 100814ca7a47SHans de Goede } 100914ca7a47SHans de Goede 101014ca7a47SHans de Goede if (acpi_has_method(device->dev->handle, "_DDC")) 101114ca7a47SHans de Goede device->cap._DDC = 1; 101214ca7a47SHans de Goede } 101314ca7a47SHans de Goede 101414ca7a47SHans de Goede /* 101514ca7a47SHans de Goede * Arg: 101614ca7a47SHans de Goede * device : video output device (VGA) 101714ca7a47SHans de Goede * 101814ca7a47SHans de Goede * Return Value: 101914ca7a47SHans de Goede * None 102014ca7a47SHans de Goede * 102114ca7a47SHans de Goede * Find out all required AML methods defined under the video bus device. 102214ca7a47SHans de Goede */ 102314ca7a47SHans de Goede 102414ca7a47SHans de Goede static void acpi_video_bus_find_cap(struct acpi_video_bus *video) 102514ca7a47SHans de Goede { 102614ca7a47SHans de Goede if (acpi_has_method(video->device->handle, "_DOS")) 102714ca7a47SHans de Goede video->cap._DOS = 1; 102814ca7a47SHans de Goede if (acpi_has_method(video->device->handle, "_DOD")) 102914ca7a47SHans de Goede video->cap._DOD = 1; 103014ca7a47SHans de Goede if (acpi_has_method(video->device->handle, "_ROM")) 103114ca7a47SHans de Goede video->cap._ROM = 1; 103214ca7a47SHans de Goede if (acpi_has_method(video->device->handle, "_GPD")) 103314ca7a47SHans de Goede video->cap._GPD = 1; 103414ca7a47SHans de Goede if (acpi_has_method(video->device->handle, "_SPD")) 103514ca7a47SHans de Goede video->cap._SPD = 1; 103614ca7a47SHans de Goede if (acpi_has_method(video->device->handle, "_VPO")) 103714ca7a47SHans de Goede video->cap._VPO = 1; 103814ca7a47SHans de Goede } 103914ca7a47SHans de Goede 104014ca7a47SHans de Goede /* 104114ca7a47SHans de Goede * Check whether the video bus device has required AML method to 104214ca7a47SHans de Goede * support the desired features 104314ca7a47SHans de Goede */ 104414ca7a47SHans de Goede 104514ca7a47SHans de Goede static int acpi_video_bus_check(struct acpi_video_bus *video) 104614ca7a47SHans de Goede { 104714ca7a47SHans de Goede acpi_status status = -ENOENT; 104814ca7a47SHans de Goede struct pci_dev *dev; 104914ca7a47SHans de Goede 105014ca7a47SHans de Goede if (!video) 105114ca7a47SHans de Goede return -EINVAL; 105214ca7a47SHans de Goede 105314ca7a47SHans de Goede dev = acpi_get_pci_dev(video->device->handle); 105414ca7a47SHans de Goede if (!dev) 105514ca7a47SHans de Goede return -ENODEV; 105614ca7a47SHans de Goede pci_dev_put(dev); 105714ca7a47SHans de Goede 105814ca7a47SHans de Goede /* 105914ca7a47SHans de Goede * Since there is no HID, CID and so on for VGA driver, we have 106014ca7a47SHans de Goede * to check well known required nodes. 106114ca7a47SHans de Goede */ 106214ca7a47SHans de Goede 106314ca7a47SHans de Goede /* Does this device support video switching? */ 106414ca7a47SHans de Goede if (video->cap._DOS || video->cap._DOD) { 106514ca7a47SHans de Goede if (!video->cap._DOS) { 106614ca7a47SHans de Goede printk(KERN_WARNING FW_BUG 106714ca7a47SHans de Goede "ACPI(%s) defines _DOD but not _DOS\n", 106814ca7a47SHans de Goede acpi_device_bid(video->device)); 106914ca7a47SHans de Goede } 107014ca7a47SHans de Goede video->flags.multihead = 1; 107114ca7a47SHans de Goede status = 0; 107214ca7a47SHans de Goede } 107314ca7a47SHans de Goede 107414ca7a47SHans de Goede /* Does this device support retrieving a video ROM? */ 107514ca7a47SHans de Goede if (video->cap._ROM) { 107614ca7a47SHans de Goede video->flags.rom = 1; 107714ca7a47SHans de Goede status = 0; 107814ca7a47SHans de Goede } 107914ca7a47SHans de Goede 108014ca7a47SHans de Goede /* Does this device support configuring which video device to POST? */ 108114ca7a47SHans de Goede if (video->cap._GPD && video->cap._SPD && video->cap._VPO) { 108214ca7a47SHans de Goede video->flags.post = 1; 108314ca7a47SHans de Goede status = 0; 108414ca7a47SHans de Goede } 108514ca7a47SHans de Goede 108614ca7a47SHans de Goede return status; 108714ca7a47SHans de Goede } 108814ca7a47SHans de Goede 108914ca7a47SHans de Goede /* 109014ca7a47SHans de Goede * -------------------------------------------------------------------------- 109114ca7a47SHans de Goede * Driver Interface 109214ca7a47SHans de Goede * -------------------------------------------------------------------------- 109314ca7a47SHans de Goede */ 109414ca7a47SHans de Goede 109514ca7a47SHans de Goede /* device interface */ 109614ca7a47SHans de Goede static struct acpi_video_device_attrib * 109714ca7a47SHans de Goede acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id) 109814ca7a47SHans de Goede { 109914ca7a47SHans de Goede struct acpi_video_enumerated_device *ids; 110014ca7a47SHans de Goede int i; 110114ca7a47SHans de Goede 110214ca7a47SHans de Goede for (i = 0; i < video->attached_count; i++) { 110314ca7a47SHans de Goede ids = &video->attached_array[i]; 110414ca7a47SHans de Goede if ((ids->value.int_val & 0xffff) == device_id) 110514ca7a47SHans de Goede return &ids->value.attrib; 110614ca7a47SHans de Goede } 110714ca7a47SHans de Goede 110814ca7a47SHans de Goede return NULL; 110914ca7a47SHans de Goede } 111014ca7a47SHans de Goede 111114ca7a47SHans de Goede static int 111214ca7a47SHans de Goede acpi_video_get_device_type(struct acpi_video_bus *video, 111314ca7a47SHans de Goede unsigned long device_id) 111414ca7a47SHans de Goede { 111514ca7a47SHans de Goede struct acpi_video_enumerated_device *ids; 111614ca7a47SHans de Goede int i; 111714ca7a47SHans de Goede 111814ca7a47SHans de Goede for (i = 0; i < video->attached_count; i++) { 111914ca7a47SHans de Goede ids = &video->attached_array[i]; 112014ca7a47SHans de Goede if ((ids->value.int_val & 0xffff) == device_id) 112114ca7a47SHans de Goede return ids->value.int_val; 112214ca7a47SHans de Goede } 112314ca7a47SHans de Goede 112414ca7a47SHans de Goede return 0; 112514ca7a47SHans de Goede } 112614ca7a47SHans de Goede 112714ca7a47SHans de Goede static int 112814ca7a47SHans de Goede acpi_video_bus_get_one_device(struct acpi_device *device, 112914ca7a47SHans de Goede struct acpi_video_bus *video) 113014ca7a47SHans de Goede { 113114ca7a47SHans de Goede unsigned long long device_id; 113214ca7a47SHans de Goede int status, device_type; 113314ca7a47SHans de Goede struct acpi_video_device *data; 113414ca7a47SHans de Goede struct acpi_video_device_attrib *attribute; 113514ca7a47SHans de Goede 113614ca7a47SHans de Goede status = 113714ca7a47SHans de Goede acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id); 113814ca7a47SHans de Goede /* Some device omits _ADR, we skip them instead of fail */ 113914ca7a47SHans de Goede if (ACPI_FAILURE(status)) 114014ca7a47SHans de Goede return 0; 114114ca7a47SHans de Goede 114214ca7a47SHans de Goede data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL); 114314ca7a47SHans de Goede if (!data) 114414ca7a47SHans de Goede return -ENOMEM; 114514ca7a47SHans de Goede 114614ca7a47SHans de Goede strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME); 114714ca7a47SHans de Goede strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS); 114814ca7a47SHans de Goede device->driver_data = data; 114914ca7a47SHans de Goede 115014ca7a47SHans de Goede data->device_id = device_id; 115114ca7a47SHans de Goede data->video = video; 115214ca7a47SHans de Goede data->dev = device; 115314ca7a47SHans de Goede INIT_DELAYED_WORK(&data->switch_brightness_work, 115414ca7a47SHans de Goede acpi_video_switch_brightness); 115514ca7a47SHans de Goede 115614ca7a47SHans de Goede attribute = acpi_video_get_device_attr(video, device_id); 115714ca7a47SHans de Goede 1158e50b9be1SAaron Lu if (attribute && (attribute->device_id_scheme || device_id_scheme)) { 115914ca7a47SHans de Goede switch (attribute->display_type) { 116014ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_CRT: 116114ca7a47SHans de Goede data->flags.crt = 1; 116214ca7a47SHans de Goede break; 116314ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_TV: 116414ca7a47SHans de Goede data->flags.tvout = 1; 116514ca7a47SHans de Goede break; 116614ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_DVI: 116714ca7a47SHans de Goede data->flags.dvi = 1; 116814ca7a47SHans de Goede break; 116914ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_LCD: 117014ca7a47SHans de Goede data->flags.lcd = 1; 117114ca7a47SHans de Goede break; 117214ca7a47SHans de Goede default: 117314ca7a47SHans de Goede data->flags.unknown = 1; 117414ca7a47SHans de Goede break; 117514ca7a47SHans de Goede } 117614ca7a47SHans de Goede if (attribute->bios_can_detect) 117714ca7a47SHans de Goede data->flags.bios = 1; 117814ca7a47SHans de Goede } else { 117914ca7a47SHans de Goede /* Check for legacy IDs */ 118014ca7a47SHans de Goede device_type = acpi_video_get_device_type(video, device_id); 118114ca7a47SHans de Goede /* Ignore bits 16 and 18-20 */ 118214ca7a47SHans de Goede switch (device_type & 0xffe2ffff) { 118314ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_LEGACY_MONITOR: 118414ca7a47SHans de Goede data->flags.crt = 1; 118514ca7a47SHans de Goede break; 118614ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_LEGACY_PANEL: 118714ca7a47SHans de Goede data->flags.lcd = 1; 118814ca7a47SHans de Goede break; 118914ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_LEGACY_TV: 119014ca7a47SHans de Goede data->flags.tvout = 1; 119114ca7a47SHans de Goede break; 119214ca7a47SHans de Goede default: 119314ca7a47SHans de Goede data->flags.unknown = 1; 119414ca7a47SHans de Goede } 119514ca7a47SHans de Goede } 119614ca7a47SHans de Goede 119714ca7a47SHans de Goede acpi_video_device_bind(video, data); 119814ca7a47SHans de Goede acpi_video_device_find_cap(data); 119914ca7a47SHans de Goede 120014ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 120114ca7a47SHans de Goede list_add_tail(&data->entry, &video->video_device_list); 120214ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 120314ca7a47SHans de Goede 120414ca7a47SHans de Goede return status; 120514ca7a47SHans de Goede } 120614ca7a47SHans de Goede 120714ca7a47SHans de Goede /* 120814ca7a47SHans de Goede * Arg: 120914ca7a47SHans de Goede * video : video bus device 121014ca7a47SHans de Goede * 121114ca7a47SHans de Goede * Return: 121214ca7a47SHans de Goede * none 121314ca7a47SHans de Goede * 121414ca7a47SHans de Goede * Enumerate the video device list of the video bus, 121514ca7a47SHans de Goede * bind the ids with the corresponding video devices 121614ca7a47SHans de Goede * under the video bus. 121714ca7a47SHans de Goede */ 121814ca7a47SHans de Goede 121914ca7a47SHans de Goede static void acpi_video_device_rebind(struct acpi_video_bus *video) 122014ca7a47SHans de Goede { 122114ca7a47SHans de Goede struct acpi_video_device *dev; 122214ca7a47SHans de Goede 122314ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 122414ca7a47SHans de Goede 122514ca7a47SHans de Goede list_for_each_entry(dev, &video->video_device_list, entry) 122614ca7a47SHans de Goede acpi_video_device_bind(video, dev); 122714ca7a47SHans de Goede 122814ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 122914ca7a47SHans de Goede } 123014ca7a47SHans de Goede 123114ca7a47SHans de Goede /* 123214ca7a47SHans de Goede * Arg: 123314ca7a47SHans de Goede * video : video bus device 123414ca7a47SHans de Goede * device : video output device under the video 123514ca7a47SHans de Goede * bus 123614ca7a47SHans de Goede * 123714ca7a47SHans de Goede * Return: 123814ca7a47SHans de Goede * none 123914ca7a47SHans de Goede * 124014ca7a47SHans de Goede * Bind the ids with the corresponding video devices 124114ca7a47SHans de Goede * under the video bus. 124214ca7a47SHans de Goede */ 124314ca7a47SHans de Goede 124414ca7a47SHans de Goede static void 124514ca7a47SHans de Goede acpi_video_device_bind(struct acpi_video_bus *video, 124614ca7a47SHans de Goede struct acpi_video_device *device) 124714ca7a47SHans de Goede { 124814ca7a47SHans de Goede struct acpi_video_enumerated_device *ids; 124914ca7a47SHans de Goede int i; 125014ca7a47SHans de Goede 125114ca7a47SHans de Goede for (i = 0; i < video->attached_count; i++) { 125214ca7a47SHans de Goede ids = &video->attached_array[i]; 125314ca7a47SHans de Goede if (device->device_id == (ids->value.int_val & 0xffff)) { 125414ca7a47SHans de Goede ids->bind_info = device; 125514ca7a47SHans de Goede ACPI_DEBUG_PRINT((ACPI_DB_INFO, "device_bind %d\n", i)); 125614ca7a47SHans de Goede } 125714ca7a47SHans de Goede } 125814ca7a47SHans de Goede } 125914ca7a47SHans de Goede 126014ca7a47SHans de Goede static bool acpi_video_device_in_dod(struct acpi_video_device *device) 126114ca7a47SHans de Goede { 126214ca7a47SHans de Goede struct acpi_video_bus *video = device->video; 126314ca7a47SHans de Goede int i; 126414ca7a47SHans de Goede 126514ca7a47SHans de Goede /* 126614ca7a47SHans de Goede * If we have a broken _DOD or we have more than 8 output devices 126714ca7a47SHans de Goede * under the graphics controller node that we can't proper deal with 126814ca7a47SHans de Goede * in the operation region code currently, no need to test. 126914ca7a47SHans de Goede */ 127014ca7a47SHans de Goede if (!video->attached_count || video->child_count > 8) 127114ca7a47SHans de Goede return true; 127214ca7a47SHans de Goede 127314ca7a47SHans de Goede for (i = 0; i < video->attached_count; i++) { 127414ca7a47SHans de Goede if ((video->attached_array[i].value.int_val & 0xfff) == 127514ca7a47SHans de Goede (device->device_id & 0xfff)) 127614ca7a47SHans de Goede return true; 127714ca7a47SHans de Goede } 127814ca7a47SHans de Goede 127914ca7a47SHans de Goede return false; 128014ca7a47SHans de Goede } 128114ca7a47SHans de Goede 128214ca7a47SHans de Goede /* 128314ca7a47SHans de Goede * Arg: 128414ca7a47SHans de Goede * video : video bus device 128514ca7a47SHans de Goede * 128614ca7a47SHans de Goede * Return: 128714ca7a47SHans de Goede * < 0 : error 128814ca7a47SHans de Goede * 128914ca7a47SHans de Goede * Call _DOD to enumerate all devices attached to display adapter 129014ca7a47SHans de Goede * 129114ca7a47SHans de Goede */ 129214ca7a47SHans de Goede 129314ca7a47SHans de Goede static int acpi_video_device_enumerate(struct acpi_video_bus *video) 129414ca7a47SHans de Goede { 129514ca7a47SHans de Goede int status; 129614ca7a47SHans de Goede int count; 129714ca7a47SHans de Goede int i; 129814ca7a47SHans de Goede struct acpi_video_enumerated_device *active_list; 129914ca7a47SHans de Goede struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 130014ca7a47SHans de Goede union acpi_object *dod = NULL; 130114ca7a47SHans de Goede union acpi_object *obj; 130214ca7a47SHans de Goede 1303e34fbbacSAlex Hung if (!video->cap._DOD) 1304e34fbbacSAlex Hung return AE_NOT_EXIST; 1305e34fbbacSAlex Hung 130614ca7a47SHans de Goede status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer); 130714ca7a47SHans de Goede if (!ACPI_SUCCESS(status)) { 130814ca7a47SHans de Goede ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD")); 130914ca7a47SHans de Goede return status; 131014ca7a47SHans de Goede } 131114ca7a47SHans de Goede 131214ca7a47SHans de Goede dod = buffer.pointer; 131314ca7a47SHans de Goede if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) { 131414ca7a47SHans de Goede ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data")); 131514ca7a47SHans de Goede status = -EFAULT; 131614ca7a47SHans de Goede goto out; 131714ca7a47SHans de Goede } 131814ca7a47SHans de Goede 131914ca7a47SHans de Goede ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d video heads in _DOD\n", 132014ca7a47SHans de Goede dod->package.count)); 132114ca7a47SHans de Goede 132214ca7a47SHans de Goede active_list = kcalloc(1 + dod->package.count, 132314ca7a47SHans de Goede sizeof(struct acpi_video_enumerated_device), 132414ca7a47SHans de Goede GFP_KERNEL); 132514ca7a47SHans de Goede if (!active_list) { 132614ca7a47SHans de Goede status = -ENOMEM; 132714ca7a47SHans de Goede goto out; 132814ca7a47SHans de Goede } 132914ca7a47SHans de Goede 133014ca7a47SHans de Goede count = 0; 133114ca7a47SHans de Goede for (i = 0; i < dod->package.count; i++) { 133214ca7a47SHans de Goede obj = &dod->package.elements[i]; 133314ca7a47SHans de Goede 133414ca7a47SHans de Goede if (obj->type != ACPI_TYPE_INTEGER) { 133514ca7a47SHans de Goede printk(KERN_ERR PREFIX 133614ca7a47SHans de Goede "Invalid _DOD data in element %d\n", i); 133714ca7a47SHans de Goede continue; 133814ca7a47SHans de Goede } 133914ca7a47SHans de Goede 134014ca7a47SHans de Goede active_list[count].value.int_val = obj->integer.value; 134114ca7a47SHans de Goede active_list[count].bind_info = NULL; 134214ca7a47SHans de Goede ACPI_DEBUG_PRINT((ACPI_DB_INFO, "dod element[%d] = %d\n", i, 134314ca7a47SHans de Goede (int)obj->integer.value)); 134414ca7a47SHans de Goede count++; 134514ca7a47SHans de Goede } 134614ca7a47SHans de Goede 134714ca7a47SHans de Goede kfree(video->attached_array); 134814ca7a47SHans de Goede 134914ca7a47SHans de Goede video->attached_array = active_list; 135014ca7a47SHans de Goede video->attached_count = count; 135114ca7a47SHans de Goede 135214ca7a47SHans de Goede out: 135314ca7a47SHans de Goede kfree(buffer.pointer); 135414ca7a47SHans de Goede return status; 135514ca7a47SHans de Goede } 135614ca7a47SHans de Goede 135714ca7a47SHans de Goede static int 135814ca7a47SHans de Goede acpi_video_get_next_level(struct acpi_video_device *device, 135914ca7a47SHans de Goede u32 level_current, u32 event) 136014ca7a47SHans de Goede { 136114ca7a47SHans de Goede int min, max, min_above, max_below, i, l, delta = 255; 136214ca7a47SHans de Goede max = max_below = 0; 136314ca7a47SHans de Goede min = min_above = 255; 136414ca7a47SHans de Goede /* Find closest level to level_current */ 1365d485ef43SDmitry Frank for (i = ACPI_VIDEO_FIRST_LEVEL; i < device->brightness->count; i++) { 136614ca7a47SHans de Goede l = device->brightness->levels[i]; 136714ca7a47SHans de Goede if (abs(l - level_current) < abs(delta)) { 136814ca7a47SHans de Goede delta = l - level_current; 136914ca7a47SHans de Goede if (!delta) 137014ca7a47SHans de Goede break; 137114ca7a47SHans de Goede } 137214ca7a47SHans de Goede } 137314ca7a47SHans de Goede /* Ajust level_current to closest available level */ 137414ca7a47SHans de Goede level_current += delta; 1375d485ef43SDmitry Frank for (i = ACPI_VIDEO_FIRST_LEVEL; i < device->brightness->count; i++) { 137614ca7a47SHans de Goede l = device->brightness->levels[i]; 137714ca7a47SHans de Goede if (l < min) 137814ca7a47SHans de Goede min = l; 137914ca7a47SHans de Goede if (l > max) 138014ca7a47SHans de Goede max = l; 138114ca7a47SHans de Goede if (l < min_above && l > level_current) 138214ca7a47SHans de Goede min_above = l; 138314ca7a47SHans de Goede if (l > max_below && l < level_current) 138414ca7a47SHans de Goede max_below = l; 138514ca7a47SHans de Goede } 138614ca7a47SHans de Goede 138714ca7a47SHans de Goede switch (event) { 138814ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS: 138914ca7a47SHans de Goede return (level_current < max) ? min_above : min; 139014ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS: 139114ca7a47SHans de Goede return (level_current < max) ? min_above : max; 139214ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS: 139314ca7a47SHans de Goede return (level_current > min) ? max_below : min; 139414ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: 139514ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: 139614ca7a47SHans de Goede return 0; 139714ca7a47SHans de Goede default: 139814ca7a47SHans de Goede return level_current; 139914ca7a47SHans de Goede } 140014ca7a47SHans de Goede } 140114ca7a47SHans de Goede 140214ca7a47SHans de Goede static void 140314ca7a47SHans de Goede acpi_video_switch_brightness(struct work_struct *work) 140414ca7a47SHans de Goede { 140514ca7a47SHans de Goede struct acpi_video_device *device = container_of(to_delayed_work(work), 140614ca7a47SHans de Goede struct acpi_video_device, switch_brightness_work); 140714ca7a47SHans de Goede unsigned long long level_current, level_next; 140814ca7a47SHans de Goede int event = device->switch_brightness_event; 140914ca7a47SHans de Goede int result = -EINVAL; 141014ca7a47SHans de Goede 141114ca7a47SHans de Goede /* no warning message if acpi_backlight=vendor or a quirk is used */ 141214ca7a47SHans de Goede if (!device->backlight) 141314ca7a47SHans de Goede return; 141414ca7a47SHans de Goede 141514ca7a47SHans de Goede if (!device->brightness) 141614ca7a47SHans de Goede goto out; 141714ca7a47SHans de Goede 141814ca7a47SHans de Goede result = acpi_video_device_lcd_get_level_current(device, 141914ca7a47SHans de Goede &level_current, 142014ca7a47SHans de Goede false); 142114ca7a47SHans de Goede if (result) 142214ca7a47SHans de Goede goto out; 142314ca7a47SHans de Goede 142414ca7a47SHans de Goede level_next = acpi_video_get_next_level(device, level_current, event); 142514ca7a47SHans de Goede 142614ca7a47SHans de Goede result = acpi_video_device_lcd_set_level(device, level_next); 142714ca7a47SHans de Goede 142814ca7a47SHans de Goede if (!result) 142914ca7a47SHans de Goede backlight_force_update(device->backlight, 143014ca7a47SHans de Goede BACKLIGHT_UPDATE_HOTKEY); 143114ca7a47SHans de Goede 143214ca7a47SHans de Goede out: 143314ca7a47SHans de Goede if (result) 143414ca7a47SHans de Goede printk(KERN_ERR PREFIX "Failed to switch the brightness\n"); 143514ca7a47SHans de Goede } 143614ca7a47SHans de Goede 143714ca7a47SHans de Goede int acpi_video_get_edid(struct acpi_device *device, int type, int device_id, 143814ca7a47SHans de Goede void **edid) 143914ca7a47SHans de Goede { 144014ca7a47SHans de Goede struct acpi_video_bus *video; 144114ca7a47SHans de Goede struct acpi_video_device *video_device; 144214ca7a47SHans de Goede union acpi_object *buffer = NULL; 144314ca7a47SHans de Goede acpi_status status; 144414ca7a47SHans de Goede int i, length; 144514ca7a47SHans de Goede 144614ca7a47SHans de Goede if (!device || !acpi_driver_data(device)) 144714ca7a47SHans de Goede return -EINVAL; 144814ca7a47SHans de Goede 144914ca7a47SHans de Goede video = acpi_driver_data(device); 145014ca7a47SHans de Goede 145114ca7a47SHans de Goede for (i = 0; i < video->attached_count; i++) { 145214ca7a47SHans de Goede video_device = video->attached_array[i].bind_info; 145314ca7a47SHans de Goede length = 256; 145414ca7a47SHans de Goede 145514ca7a47SHans de Goede if (!video_device) 145614ca7a47SHans de Goede continue; 145714ca7a47SHans de Goede 145814ca7a47SHans de Goede if (!video_device->cap._DDC) 145914ca7a47SHans de Goede continue; 146014ca7a47SHans de Goede 146114ca7a47SHans de Goede if (type) { 146214ca7a47SHans de Goede switch (type) { 146314ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_CRT: 146414ca7a47SHans de Goede if (!video_device->flags.crt) 146514ca7a47SHans de Goede continue; 146614ca7a47SHans de Goede break; 146714ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_TV: 146814ca7a47SHans de Goede if (!video_device->flags.tvout) 146914ca7a47SHans de Goede continue; 147014ca7a47SHans de Goede break; 147114ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_DVI: 147214ca7a47SHans de Goede if (!video_device->flags.dvi) 147314ca7a47SHans de Goede continue; 147414ca7a47SHans de Goede break; 147514ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_LCD: 147614ca7a47SHans de Goede if (!video_device->flags.lcd) 147714ca7a47SHans de Goede continue; 147814ca7a47SHans de Goede break; 147914ca7a47SHans de Goede } 148014ca7a47SHans de Goede } else if (video_device->device_id != device_id) { 148114ca7a47SHans de Goede continue; 148214ca7a47SHans de Goede } 148314ca7a47SHans de Goede 148414ca7a47SHans de Goede status = acpi_video_device_EDID(video_device, &buffer, length); 148514ca7a47SHans de Goede 148614ca7a47SHans de Goede if (ACPI_FAILURE(status) || !buffer || 148714ca7a47SHans de Goede buffer->type != ACPI_TYPE_BUFFER) { 148814ca7a47SHans de Goede length = 128; 148914ca7a47SHans de Goede status = acpi_video_device_EDID(video_device, &buffer, 149014ca7a47SHans de Goede length); 149114ca7a47SHans de Goede if (ACPI_FAILURE(status) || !buffer || 149214ca7a47SHans de Goede buffer->type != ACPI_TYPE_BUFFER) { 149314ca7a47SHans de Goede continue; 149414ca7a47SHans de Goede } 149514ca7a47SHans de Goede } 149614ca7a47SHans de Goede 149714ca7a47SHans de Goede *edid = buffer->buffer.pointer; 149814ca7a47SHans de Goede return length; 149914ca7a47SHans de Goede } 150014ca7a47SHans de Goede 150114ca7a47SHans de Goede return -ENODEV; 150214ca7a47SHans de Goede } 150314ca7a47SHans de Goede EXPORT_SYMBOL(acpi_video_get_edid); 150414ca7a47SHans de Goede 150514ca7a47SHans de Goede static int 150614ca7a47SHans de Goede acpi_video_bus_get_devices(struct acpi_video_bus *video, 150714ca7a47SHans de Goede struct acpi_device *device) 150814ca7a47SHans de Goede { 150914ca7a47SHans de Goede int status = 0; 151014ca7a47SHans de Goede struct acpi_device *dev; 151114ca7a47SHans de Goede 151214ca7a47SHans de Goede /* 151314ca7a47SHans de Goede * There are systems where video module known to work fine regardless 151414ca7a47SHans de Goede * of broken _DOD and ignoring returned value here doesn't cause 151514ca7a47SHans de Goede * any issues later. 151614ca7a47SHans de Goede */ 151714ca7a47SHans de Goede acpi_video_device_enumerate(video); 151814ca7a47SHans de Goede 151914ca7a47SHans de Goede list_for_each_entry(dev, &device->children, node) { 152014ca7a47SHans de Goede 152114ca7a47SHans de Goede status = acpi_video_bus_get_one_device(dev, video); 152214ca7a47SHans de Goede if (status) { 152314ca7a47SHans de Goede dev_err(&dev->dev, "Can't attach device\n"); 152414ca7a47SHans de Goede break; 152514ca7a47SHans de Goede } 152614ca7a47SHans de Goede video->child_count++; 152714ca7a47SHans de Goede } 152814ca7a47SHans de Goede return status; 152914ca7a47SHans de Goede } 153014ca7a47SHans de Goede 153114ca7a47SHans de Goede /* acpi_video interface */ 153214ca7a47SHans de Goede 153314ca7a47SHans de Goede /* 153414ca7a47SHans de Goede * Win8 requires setting bit2 of _DOS to let firmware know it shouldn't 153514ca7a47SHans de Goede * preform any automatic brightness change on receiving a notification. 153614ca7a47SHans de Goede */ 153714ca7a47SHans de Goede static int acpi_video_bus_start_devices(struct acpi_video_bus *video) 153814ca7a47SHans de Goede { 153914ca7a47SHans de Goede return acpi_video_bus_DOS(video, 0, 154014ca7a47SHans de Goede acpi_osi_is_win8() ? 1 : 0); 154114ca7a47SHans de Goede } 154214ca7a47SHans de Goede 154314ca7a47SHans de Goede static int acpi_video_bus_stop_devices(struct acpi_video_bus *video) 154414ca7a47SHans de Goede { 154514ca7a47SHans de Goede return acpi_video_bus_DOS(video, 0, 154614ca7a47SHans de Goede acpi_osi_is_win8() ? 0 : 1); 154714ca7a47SHans de Goede } 154814ca7a47SHans de Goede 154914ca7a47SHans de Goede static void acpi_video_bus_notify(struct acpi_device *device, u32 event) 155014ca7a47SHans de Goede { 155114ca7a47SHans de Goede struct acpi_video_bus *video = acpi_driver_data(device); 155214ca7a47SHans de Goede struct input_dev *input; 155314ca7a47SHans de Goede int keycode = 0; 155414ca7a47SHans de Goede 155514ca7a47SHans de Goede if (!video || !video->input) 155614ca7a47SHans de Goede return; 155714ca7a47SHans de Goede 155814ca7a47SHans de Goede input = video->input; 155914ca7a47SHans de Goede 156014ca7a47SHans de Goede switch (event) { 156114ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_SWITCH: /* User requested a switch, 156214ca7a47SHans de Goede * most likely via hotkey. */ 156314ca7a47SHans de Goede keycode = KEY_SWITCHVIDEOMODE; 156414ca7a47SHans de Goede break; 156514ca7a47SHans de Goede 156614ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_PROBE: /* User plugged in or removed a video 156714ca7a47SHans de Goede * connector. */ 156814ca7a47SHans de Goede acpi_video_device_enumerate(video); 156914ca7a47SHans de Goede acpi_video_device_rebind(video); 157014ca7a47SHans de Goede keycode = KEY_SWITCHVIDEOMODE; 157114ca7a47SHans de Goede break; 157214ca7a47SHans de Goede 157314ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_CYCLE: /* Cycle Display output hotkey pressed. */ 157414ca7a47SHans de Goede keycode = KEY_SWITCHVIDEOMODE; 157514ca7a47SHans de Goede break; 157614ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT: /* Next Display output hotkey pressed. */ 157714ca7a47SHans de Goede keycode = KEY_VIDEO_NEXT; 157814ca7a47SHans de Goede break; 157914ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_PREV_OUTPUT: /* previous Display output hotkey pressed. */ 158014ca7a47SHans de Goede keycode = KEY_VIDEO_PREV; 158114ca7a47SHans de Goede break; 158214ca7a47SHans de Goede 158314ca7a47SHans de Goede default: 158414ca7a47SHans de Goede ACPI_DEBUG_PRINT((ACPI_DB_INFO, 158514ca7a47SHans de Goede "Unsupported event [0x%x]\n", event)); 158614ca7a47SHans de Goede break; 158714ca7a47SHans de Goede } 158814ca7a47SHans de Goede 158914ca7a47SHans de Goede if (acpi_notifier_call_chain(device, event, 0)) 159014ca7a47SHans de Goede /* Something vetoed the keypress. */ 159114ca7a47SHans de Goede keycode = 0; 159214ca7a47SHans de Goede 159305bc59a0SHans de Goede if (keycode && (report_key_events & REPORT_OUTPUT_KEY_EVENTS)) { 159414ca7a47SHans de Goede input_report_key(input, keycode, 1); 159514ca7a47SHans de Goede input_sync(input); 159614ca7a47SHans de Goede input_report_key(input, keycode, 0); 159714ca7a47SHans de Goede input_sync(input); 159814ca7a47SHans de Goede } 159914ca7a47SHans de Goede 160014ca7a47SHans de Goede return; 160114ca7a47SHans de Goede } 160214ca7a47SHans de Goede 160314ca7a47SHans de Goede static void brightness_switch_event(struct acpi_video_device *video_device, 160414ca7a47SHans de Goede u32 event) 160514ca7a47SHans de Goede { 160614ca7a47SHans de Goede if (!brightness_switch_enabled) 160714ca7a47SHans de Goede return; 160814ca7a47SHans de Goede 160914ca7a47SHans de Goede video_device->switch_brightness_event = event; 161014ca7a47SHans de Goede schedule_delayed_work(&video_device->switch_brightness_work, HZ / 10); 161114ca7a47SHans de Goede } 161214ca7a47SHans de Goede 161314ca7a47SHans de Goede static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data) 161414ca7a47SHans de Goede { 161514ca7a47SHans de Goede struct acpi_video_device *video_device = data; 161614ca7a47SHans de Goede struct acpi_device *device = NULL; 161714ca7a47SHans de Goede struct acpi_video_bus *bus; 161814ca7a47SHans de Goede struct input_dev *input; 161914ca7a47SHans de Goede int keycode = 0; 162014ca7a47SHans de Goede 162114ca7a47SHans de Goede if (!video_device) 162214ca7a47SHans de Goede return; 162314ca7a47SHans de Goede 162414ca7a47SHans de Goede device = video_device->dev; 162514ca7a47SHans de Goede bus = video_device->video; 162614ca7a47SHans de Goede input = bus->input; 162714ca7a47SHans de Goede 162814ca7a47SHans de Goede switch (event) { 162914ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS: /* Cycle brightness */ 163014ca7a47SHans de Goede brightness_switch_event(video_device, event); 163114ca7a47SHans de Goede keycode = KEY_BRIGHTNESS_CYCLE; 163214ca7a47SHans de Goede break; 163314ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS: /* Increase brightness */ 163414ca7a47SHans de Goede brightness_switch_event(video_device, event); 163514ca7a47SHans de Goede keycode = KEY_BRIGHTNESSUP; 163614ca7a47SHans de Goede break; 163714ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS: /* Decrease brightness */ 163814ca7a47SHans de Goede brightness_switch_event(video_device, event); 163914ca7a47SHans de Goede keycode = KEY_BRIGHTNESSDOWN; 164014ca7a47SHans de Goede break; 164114ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: /* zero brightness */ 164214ca7a47SHans de Goede brightness_switch_event(video_device, event); 164314ca7a47SHans de Goede keycode = KEY_BRIGHTNESS_ZERO; 164414ca7a47SHans de Goede break; 164514ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: /* display device off */ 164614ca7a47SHans de Goede brightness_switch_event(video_device, event); 164714ca7a47SHans de Goede keycode = KEY_DISPLAY_OFF; 164814ca7a47SHans de Goede break; 164914ca7a47SHans de Goede default: 165014ca7a47SHans de Goede ACPI_DEBUG_PRINT((ACPI_DB_INFO, 165114ca7a47SHans de Goede "Unsupported event [0x%x]\n", event)); 165214ca7a47SHans de Goede break; 165314ca7a47SHans de Goede } 165414ca7a47SHans de Goede 165514ca7a47SHans de Goede acpi_notifier_call_chain(device, event, 0); 165614ca7a47SHans de Goede 165705bc59a0SHans de Goede if (keycode && (report_key_events & REPORT_BRIGHTNESS_KEY_EVENTS)) { 165814ca7a47SHans de Goede input_report_key(input, keycode, 1); 165914ca7a47SHans de Goede input_sync(input); 166014ca7a47SHans de Goede input_report_key(input, keycode, 0); 166114ca7a47SHans de Goede input_sync(input); 166214ca7a47SHans de Goede } 166314ca7a47SHans de Goede 166414ca7a47SHans de Goede return; 166514ca7a47SHans de Goede } 166614ca7a47SHans de Goede 166714ca7a47SHans de Goede static int acpi_video_resume(struct notifier_block *nb, 166814ca7a47SHans de Goede unsigned long val, void *ign) 166914ca7a47SHans de Goede { 167014ca7a47SHans de Goede struct acpi_video_bus *video; 167114ca7a47SHans de Goede struct acpi_video_device *video_device; 167214ca7a47SHans de Goede int i; 167314ca7a47SHans de Goede 167414ca7a47SHans de Goede switch (val) { 167514ca7a47SHans de Goede case PM_HIBERNATION_PREPARE: 167614ca7a47SHans de Goede case PM_SUSPEND_PREPARE: 167714ca7a47SHans de Goede case PM_RESTORE_PREPARE: 167814ca7a47SHans de Goede return NOTIFY_DONE; 167914ca7a47SHans de Goede } 168014ca7a47SHans de Goede 168114ca7a47SHans de Goede video = container_of(nb, struct acpi_video_bus, pm_nb); 168214ca7a47SHans de Goede 168314ca7a47SHans de Goede dev_info(&video->device->dev, "Restoring backlight state\n"); 168414ca7a47SHans de Goede 168514ca7a47SHans de Goede for (i = 0; i < video->attached_count; i++) { 168614ca7a47SHans de Goede video_device = video->attached_array[i].bind_info; 168714ca7a47SHans de Goede if (video_device && video_device->brightness) 168814ca7a47SHans de Goede acpi_video_device_lcd_set_level(video_device, 168914ca7a47SHans de Goede video_device->brightness->curr); 169014ca7a47SHans de Goede } 169114ca7a47SHans de Goede 169214ca7a47SHans de Goede return NOTIFY_OK; 169314ca7a47SHans de Goede } 169414ca7a47SHans de Goede 169514ca7a47SHans de Goede static acpi_status 169614ca7a47SHans de Goede acpi_video_bus_match(acpi_handle handle, u32 level, void *context, 169714ca7a47SHans de Goede void **return_value) 169814ca7a47SHans de Goede { 169914ca7a47SHans de Goede struct acpi_device *device = context; 170014ca7a47SHans de Goede struct acpi_device *sibling; 170114ca7a47SHans de Goede int result; 170214ca7a47SHans de Goede 170314ca7a47SHans de Goede if (handle == device->handle) 170414ca7a47SHans de Goede return AE_CTRL_TERMINATE; 170514ca7a47SHans de Goede 170614ca7a47SHans de Goede result = acpi_bus_get_device(handle, &sibling); 170714ca7a47SHans de Goede if (result) 170814ca7a47SHans de Goede return AE_OK; 170914ca7a47SHans de Goede 171014ca7a47SHans de Goede if (!strcmp(acpi_device_name(sibling), ACPI_VIDEO_BUS_NAME)) 171114ca7a47SHans de Goede return AE_ALREADY_EXISTS; 171214ca7a47SHans de Goede 171314ca7a47SHans de Goede return AE_OK; 171414ca7a47SHans de Goede } 171514ca7a47SHans de Goede 171614ca7a47SHans de Goede static void acpi_video_dev_register_backlight(struct acpi_video_device *device) 171714ca7a47SHans de Goede { 171814ca7a47SHans de Goede struct backlight_properties props; 171914ca7a47SHans de Goede struct pci_dev *pdev; 172014ca7a47SHans de Goede acpi_handle acpi_parent; 172114ca7a47SHans de Goede struct device *parent = NULL; 172214ca7a47SHans de Goede int result; 172314ca7a47SHans de Goede static int count; 172414ca7a47SHans de Goede char *name; 172514ca7a47SHans de Goede 172614ca7a47SHans de Goede result = acpi_video_init_brightness(device); 172714ca7a47SHans de Goede if (result) 172814ca7a47SHans de Goede return; 172914ca7a47SHans de Goede 173014ca7a47SHans de Goede if (disable_backlight_sysfs_if > 0) 173114ca7a47SHans de Goede return; 173214ca7a47SHans de Goede 173314ca7a47SHans de Goede name = kasprintf(GFP_KERNEL, "acpi_video%d", count); 173414ca7a47SHans de Goede if (!name) 173514ca7a47SHans de Goede return; 173614ca7a47SHans de Goede count++; 173714ca7a47SHans de Goede 173814ca7a47SHans de Goede acpi_get_parent(device->dev->handle, &acpi_parent); 173914ca7a47SHans de Goede 174014ca7a47SHans de Goede pdev = acpi_get_pci_dev(acpi_parent); 174114ca7a47SHans de Goede if (pdev) { 174214ca7a47SHans de Goede parent = &pdev->dev; 174314ca7a47SHans de Goede pci_dev_put(pdev); 174414ca7a47SHans de Goede } 174514ca7a47SHans de Goede 174614ca7a47SHans de Goede memset(&props, 0, sizeof(struct backlight_properties)); 174714ca7a47SHans de Goede props.type = BACKLIGHT_FIRMWARE; 1748d485ef43SDmitry Frank props.max_brightness = 1749d485ef43SDmitry Frank device->brightness->count - ACPI_VIDEO_FIRST_LEVEL - 1; 175014ca7a47SHans de Goede device->backlight = backlight_device_register(name, 175114ca7a47SHans de Goede parent, 175214ca7a47SHans de Goede device, 175314ca7a47SHans de Goede &acpi_backlight_ops, 175414ca7a47SHans de Goede &props); 175514ca7a47SHans de Goede kfree(name); 175614ca7a47SHans de Goede if (IS_ERR(device->backlight)) { 175714ca7a47SHans de Goede device->backlight = NULL; 175814ca7a47SHans de Goede return; 175914ca7a47SHans de Goede } 176014ca7a47SHans de Goede 176114ca7a47SHans de Goede /* 176214ca7a47SHans de Goede * Save current brightness level in case we have to restore it 176314ca7a47SHans de Goede * before acpi_video_device_lcd_set_level() is called next time. 176414ca7a47SHans de Goede */ 176514ca7a47SHans de Goede device->backlight->props.brightness = 176614ca7a47SHans de Goede acpi_video_get_brightness(device->backlight); 176714ca7a47SHans de Goede 176814ca7a47SHans de Goede device->cooling_dev = thermal_cooling_device_register("LCD", 176914ca7a47SHans de Goede device->dev, &video_cooling_ops); 177014ca7a47SHans de Goede if (IS_ERR(device->cooling_dev)) { 177114ca7a47SHans de Goede /* 177214ca7a47SHans de Goede * Set cooling_dev to NULL so we don't crash trying to free it. 177314ca7a47SHans de Goede * Also, why the hell we are returning early and not attempt to 177414ca7a47SHans de Goede * register video output if cooling device registration failed? 177514ca7a47SHans de Goede * -- dtor 177614ca7a47SHans de Goede */ 177714ca7a47SHans de Goede device->cooling_dev = NULL; 177814ca7a47SHans de Goede return; 177914ca7a47SHans de Goede } 178014ca7a47SHans de Goede 178114ca7a47SHans de Goede dev_info(&device->dev->dev, "registered as cooling_device%d\n", 178214ca7a47SHans de Goede device->cooling_dev->id); 178314ca7a47SHans de Goede result = sysfs_create_link(&device->dev->dev.kobj, 178414ca7a47SHans de Goede &device->cooling_dev->device.kobj, 178514ca7a47SHans de Goede "thermal_cooling"); 178614ca7a47SHans de Goede if (result) 178714ca7a47SHans de Goede printk(KERN_ERR PREFIX "Create sysfs link\n"); 178814ca7a47SHans de Goede result = sysfs_create_link(&device->cooling_dev->device.kobj, 178914ca7a47SHans de Goede &device->dev->dev.kobj, "device"); 179014ca7a47SHans de Goede if (result) 179114ca7a47SHans de Goede printk(KERN_ERR PREFIX "Create sysfs link\n"); 179214ca7a47SHans de Goede } 179314ca7a47SHans de Goede 179414ca7a47SHans de Goede static void acpi_video_run_bcl_for_osi(struct acpi_video_bus *video) 179514ca7a47SHans de Goede { 179614ca7a47SHans de Goede struct acpi_video_device *dev; 179714ca7a47SHans de Goede union acpi_object *levels; 179814ca7a47SHans de Goede 179914ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 180014ca7a47SHans de Goede list_for_each_entry(dev, &video->video_device_list, entry) { 18019f9cd7eeSAaron Lu if (!acpi_video_device_lcd_query_levels(dev->dev->handle, &levels)) 180214ca7a47SHans de Goede kfree(levels); 180314ca7a47SHans de Goede } 180414ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 180514ca7a47SHans de Goede } 180614ca7a47SHans de Goede 1807e50b9be1SAaron Lu static bool acpi_video_should_register_backlight(struct acpi_video_device *dev) 1808e50b9be1SAaron Lu { 1809e50b9be1SAaron Lu /* 1810e50b9be1SAaron Lu * Do not create backlight device for video output 1811e50b9be1SAaron Lu * device that is not in the enumerated list. 1812e50b9be1SAaron Lu */ 1813e50b9be1SAaron Lu if (!acpi_video_device_in_dod(dev)) { 1814e50b9be1SAaron Lu dev_dbg(&dev->dev->dev, "not in _DOD list, ignore\n"); 1815e50b9be1SAaron Lu return false; 1816e50b9be1SAaron Lu } 1817e50b9be1SAaron Lu 1818e50b9be1SAaron Lu if (only_lcd) 1819e50b9be1SAaron Lu return dev->flags.lcd; 1820e50b9be1SAaron Lu return true; 1821e50b9be1SAaron Lu } 1822e50b9be1SAaron Lu 182314ca7a47SHans de Goede static int acpi_video_bus_register_backlight(struct acpi_video_bus *video) 182414ca7a47SHans de Goede { 182514ca7a47SHans de Goede struct acpi_video_device *dev; 182614ca7a47SHans de Goede 182714ca7a47SHans de Goede if (video->backlight_registered) 182814ca7a47SHans de Goede return 0; 182914ca7a47SHans de Goede 183014ca7a47SHans de Goede acpi_video_run_bcl_for_osi(video); 183114ca7a47SHans de Goede 18323bd6bce3SHans de Goede if (acpi_video_get_backlight_type() != acpi_backlight_video) 183314ca7a47SHans de Goede return 0; 183414ca7a47SHans de Goede 183514ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 1836e50b9be1SAaron Lu list_for_each_entry(dev, &video->video_device_list, entry) { 1837e50b9be1SAaron Lu if (acpi_video_should_register_backlight(dev)) 183814ca7a47SHans de Goede acpi_video_dev_register_backlight(dev); 1839e50b9be1SAaron Lu } 184014ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 184114ca7a47SHans de Goede 184214ca7a47SHans de Goede video->backlight_registered = true; 184314ca7a47SHans de Goede 184414ca7a47SHans de Goede video->pm_nb.notifier_call = acpi_video_resume; 184514ca7a47SHans de Goede video->pm_nb.priority = 0; 184614ca7a47SHans de Goede return register_pm_notifier(&video->pm_nb); 184714ca7a47SHans de Goede } 184814ca7a47SHans de Goede 184914ca7a47SHans de Goede static void acpi_video_dev_unregister_backlight(struct acpi_video_device *device) 185014ca7a47SHans de Goede { 185114ca7a47SHans de Goede if (device->backlight) { 185214ca7a47SHans de Goede backlight_device_unregister(device->backlight); 185314ca7a47SHans de Goede device->backlight = NULL; 185414ca7a47SHans de Goede } 185514ca7a47SHans de Goede if (device->brightness) { 185614ca7a47SHans de Goede kfree(device->brightness->levels); 185714ca7a47SHans de Goede kfree(device->brightness); 185814ca7a47SHans de Goede device->brightness = NULL; 185914ca7a47SHans de Goede } 186014ca7a47SHans de Goede if (device->cooling_dev) { 186114ca7a47SHans de Goede sysfs_remove_link(&device->dev->dev.kobj, "thermal_cooling"); 186214ca7a47SHans de Goede sysfs_remove_link(&device->cooling_dev->device.kobj, "device"); 186314ca7a47SHans de Goede thermal_cooling_device_unregister(device->cooling_dev); 186414ca7a47SHans de Goede device->cooling_dev = NULL; 186514ca7a47SHans de Goede } 186614ca7a47SHans de Goede } 186714ca7a47SHans de Goede 186814ca7a47SHans de Goede static int acpi_video_bus_unregister_backlight(struct acpi_video_bus *video) 186914ca7a47SHans de Goede { 187014ca7a47SHans de Goede struct acpi_video_device *dev; 187114ca7a47SHans de Goede int error; 187214ca7a47SHans de Goede 187314ca7a47SHans de Goede if (!video->backlight_registered) 187414ca7a47SHans de Goede return 0; 187514ca7a47SHans de Goede 187614ca7a47SHans de Goede error = unregister_pm_notifier(&video->pm_nb); 187714ca7a47SHans de Goede 187814ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 187914ca7a47SHans de Goede list_for_each_entry(dev, &video->video_device_list, entry) 188014ca7a47SHans de Goede acpi_video_dev_unregister_backlight(dev); 188114ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 188214ca7a47SHans de Goede 188314ca7a47SHans de Goede video->backlight_registered = false; 188414ca7a47SHans de Goede 188514ca7a47SHans de Goede return error; 188614ca7a47SHans de Goede } 188714ca7a47SHans de Goede 188814ca7a47SHans de Goede static void acpi_video_dev_add_notify_handler(struct acpi_video_device *device) 188914ca7a47SHans de Goede { 189014ca7a47SHans de Goede acpi_status status; 189114ca7a47SHans de Goede struct acpi_device *adev = device->dev; 189214ca7a47SHans de Goede 189314ca7a47SHans de Goede status = acpi_install_notify_handler(adev->handle, ACPI_DEVICE_NOTIFY, 189414ca7a47SHans de Goede acpi_video_device_notify, device); 189514ca7a47SHans de Goede if (ACPI_FAILURE(status)) 189614ca7a47SHans de Goede dev_err(&adev->dev, "Error installing notify handler\n"); 189714ca7a47SHans de Goede else 189814ca7a47SHans de Goede device->flags.notify = 1; 189914ca7a47SHans de Goede } 190014ca7a47SHans de Goede 190114ca7a47SHans de Goede static int acpi_video_bus_add_notify_handler(struct acpi_video_bus *video) 190214ca7a47SHans de Goede { 190314ca7a47SHans de Goede struct input_dev *input; 190414ca7a47SHans de Goede struct acpi_video_device *dev; 190514ca7a47SHans de Goede int error; 190614ca7a47SHans de Goede 190714ca7a47SHans de Goede video->input = input = input_allocate_device(); 190814ca7a47SHans de Goede if (!input) { 190914ca7a47SHans de Goede error = -ENOMEM; 191014ca7a47SHans de Goede goto out; 191114ca7a47SHans de Goede } 191214ca7a47SHans de Goede 191314ca7a47SHans de Goede error = acpi_video_bus_start_devices(video); 191414ca7a47SHans de Goede if (error) 191514ca7a47SHans de Goede goto err_free_input; 191614ca7a47SHans de Goede 191714ca7a47SHans de Goede snprintf(video->phys, sizeof(video->phys), 191814ca7a47SHans de Goede "%s/video/input0", acpi_device_hid(video->device)); 191914ca7a47SHans de Goede 192014ca7a47SHans de Goede input->name = acpi_device_name(video->device); 192114ca7a47SHans de Goede input->phys = video->phys; 192214ca7a47SHans de Goede input->id.bustype = BUS_HOST; 192314ca7a47SHans de Goede input->id.product = 0x06; 192414ca7a47SHans de Goede input->dev.parent = &video->device->dev; 192514ca7a47SHans de Goede input->evbit[0] = BIT(EV_KEY); 192614ca7a47SHans de Goede set_bit(KEY_SWITCHVIDEOMODE, input->keybit); 192714ca7a47SHans de Goede set_bit(KEY_VIDEO_NEXT, input->keybit); 192814ca7a47SHans de Goede set_bit(KEY_VIDEO_PREV, input->keybit); 192914ca7a47SHans de Goede set_bit(KEY_BRIGHTNESS_CYCLE, input->keybit); 193014ca7a47SHans de Goede set_bit(KEY_BRIGHTNESSUP, input->keybit); 193114ca7a47SHans de Goede set_bit(KEY_BRIGHTNESSDOWN, input->keybit); 193214ca7a47SHans de Goede set_bit(KEY_BRIGHTNESS_ZERO, input->keybit); 193314ca7a47SHans de Goede set_bit(KEY_DISPLAY_OFF, input->keybit); 193414ca7a47SHans de Goede 193514ca7a47SHans de Goede error = input_register_device(input); 193614ca7a47SHans de Goede if (error) 193714ca7a47SHans de Goede goto err_stop_dev; 193814ca7a47SHans de Goede 193914ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 194014ca7a47SHans de Goede list_for_each_entry(dev, &video->video_device_list, entry) 194114ca7a47SHans de Goede acpi_video_dev_add_notify_handler(dev); 194214ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 194314ca7a47SHans de Goede 194414ca7a47SHans de Goede return 0; 194514ca7a47SHans de Goede 194614ca7a47SHans de Goede err_stop_dev: 194714ca7a47SHans de Goede acpi_video_bus_stop_devices(video); 194814ca7a47SHans de Goede err_free_input: 194914ca7a47SHans de Goede input_free_device(input); 195014ca7a47SHans de Goede video->input = NULL; 195114ca7a47SHans de Goede out: 195214ca7a47SHans de Goede return error; 195314ca7a47SHans de Goede } 195414ca7a47SHans de Goede 195514ca7a47SHans de Goede static void acpi_video_dev_remove_notify_handler(struct acpi_video_device *dev) 195614ca7a47SHans de Goede { 195714ca7a47SHans de Goede if (dev->flags.notify) { 195814ca7a47SHans de Goede acpi_remove_notify_handler(dev->dev->handle, ACPI_DEVICE_NOTIFY, 195914ca7a47SHans de Goede acpi_video_device_notify); 196014ca7a47SHans de Goede dev->flags.notify = 0; 196114ca7a47SHans de Goede } 196214ca7a47SHans de Goede } 196314ca7a47SHans de Goede 196414ca7a47SHans de Goede static void acpi_video_bus_remove_notify_handler(struct acpi_video_bus *video) 196514ca7a47SHans de Goede { 196614ca7a47SHans de Goede struct acpi_video_device *dev; 196714ca7a47SHans de Goede 196814ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 196914ca7a47SHans de Goede list_for_each_entry(dev, &video->video_device_list, entry) 197014ca7a47SHans de Goede acpi_video_dev_remove_notify_handler(dev); 197114ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 197214ca7a47SHans de Goede 197314ca7a47SHans de Goede acpi_video_bus_stop_devices(video); 197414ca7a47SHans de Goede input_unregister_device(video->input); 197514ca7a47SHans de Goede video->input = NULL; 197614ca7a47SHans de Goede } 197714ca7a47SHans de Goede 197814ca7a47SHans de Goede static int acpi_video_bus_put_devices(struct acpi_video_bus *video) 197914ca7a47SHans de Goede { 198014ca7a47SHans de Goede struct acpi_video_device *dev, *next; 198114ca7a47SHans de Goede 198214ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 198314ca7a47SHans de Goede list_for_each_entry_safe(dev, next, &video->video_device_list, entry) { 198414ca7a47SHans de Goede list_del(&dev->entry); 198514ca7a47SHans de Goede kfree(dev); 198614ca7a47SHans de Goede } 198714ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 198814ca7a47SHans de Goede 198914ca7a47SHans de Goede return 0; 199014ca7a47SHans de Goede } 199114ca7a47SHans de Goede 199214ca7a47SHans de Goede static int instance; 199314ca7a47SHans de Goede 199414ca7a47SHans de Goede static int acpi_video_bus_add(struct acpi_device *device) 199514ca7a47SHans de Goede { 199614ca7a47SHans de Goede struct acpi_video_bus *video; 199714ca7a47SHans de Goede int error; 199814ca7a47SHans de Goede acpi_status status; 199914ca7a47SHans de Goede 200014ca7a47SHans de Goede status = acpi_walk_namespace(ACPI_TYPE_DEVICE, 200114ca7a47SHans de Goede device->parent->handle, 1, 200214ca7a47SHans de Goede acpi_video_bus_match, NULL, 200314ca7a47SHans de Goede device, NULL); 200414ca7a47SHans de Goede if (status == AE_ALREADY_EXISTS) { 200514ca7a47SHans de Goede printk(KERN_WARNING FW_BUG 200614ca7a47SHans de Goede "Duplicate ACPI video bus devices for the" 200714ca7a47SHans de Goede " same VGA controller, please try module " 200814ca7a47SHans de Goede "parameter \"video.allow_duplicates=1\"" 200914ca7a47SHans de Goede "if the current driver doesn't work.\n"); 201014ca7a47SHans de Goede if (!allow_duplicates) 201114ca7a47SHans de Goede return -ENODEV; 201214ca7a47SHans de Goede } 201314ca7a47SHans de Goede 201414ca7a47SHans de Goede video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL); 201514ca7a47SHans de Goede if (!video) 201614ca7a47SHans de Goede return -ENOMEM; 201714ca7a47SHans de Goede 201814ca7a47SHans de Goede /* a hack to fix the duplicate name "VID" problem on T61 */ 201914ca7a47SHans de Goede if (!strcmp(device->pnp.bus_id, "VID")) { 202014ca7a47SHans de Goede if (instance) 202114ca7a47SHans de Goede device->pnp.bus_id[3] = '0' + instance; 202214ca7a47SHans de Goede instance++; 202314ca7a47SHans de Goede } 202414ca7a47SHans de Goede /* a hack to fix the duplicate name "VGA" problem on Pa 3553 */ 202514ca7a47SHans de Goede if (!strcmp(device->pnp.bus_id, "VGA")) { 202614ca7a47SHans de Goede if (instance) 202714ca7a47SHans de Goede device->pnp.bus_id[3] = '0' + instance; 202814ca7a47SHans de Goede instance++; 202914ca7a47SHans de Goede } 203014ca7a47SHans de Goede 203114ca7a47SHans de Goede video->device = device; 203214ca7a47SHans de Goede strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME); 203314ca7a47SHans de Goede strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS); 203414ca7a47SHans de Goede device->driver_data = video; 203514ca7a47SHans de Goede 203614ca7a47SHans de Goede acpi_video_bus_find_cap(video); 203714ca7a47SHans de Goede error = acpi_video_bus_check(video); 203814ca7a47SHans de Goede if (error) 203914ca7a47SHans de Goede goto err_free_video; 204014ca7a47SHans de Goede 204114ca7a47SHans de Goede mutex_init(&video->device_list_lock); 204214ca7a47SHans de Goede INIT_LIST_HEAD(&video->video_device_list); 204314ca7a47SHans de Goede 204414ca7a47SHans de Goede error = acpi_video_bus_get_devices(video, device); 204514ca7a47SHans de Goede if (error) 204614ca7a47SHans de Goede goto err_put_video; 204714ca7a47SHans de Goede 204814ca7a47SHans de Goede printk(KERN_INFO PREFIX "%s [%s] (multi-head: %s rom: %s post: %s)\n", 204914ca7a47SHans de Goede ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device), 205014ca7a47SHans de Goede video->flags.multihead ? "yes" : "no", 205114ca7a47SHans de Goede video->flags.rom ? "yes" : "no", 205214ca7a47SHans de Goede video->flags.post ? "yes" : "no"); 205314ca7a47SHans de Goede mutex_lock(&video_list_lock); 205414ca7a47SHans de Goede list_add_tail(&video->entry, &video_bus_head); 205514ca7a47SHans de Goede mutex_unlock(&video_list_lock); 205614ca7a47SHans de Goede 205714ca7a47SHans de Goede acpi_video_bus_register_backlight(video); 205814ca7a47SHans de Goede acpi_video_bus_add_notify_handler(video); 205914ca7a47SHans de Goede 206014ca7a47SHans de Goede return 0; 206114ca7a47SHans de Goede 206214ca7a47SHans de Goede err_put_video: 206314ca7a47SHans de Goede acpi_video_bus_put_devices(video); 206414ca7a47SHans de Goede kfree(video->attached_array); 206514ca7a47SHans de Goede err_free_video: 206614ca7a47SHans de Goede kfree(video); 206714ca7a47SHans de Goede device->driver_data = NULL; 206814ca7a47SHans de Goede 206914ca7a47SHans de Goede return error; 207014ca7a47SHans de Goede } 207114ca7a47SHans de Goede 207214ca7a47SHans de Goede static int acpi_video_bus_remove(struct acpi_device *device) 207314ca7a47SHans de Goede { 207414ca7a47SHans de Goede struct acpi_video_bus *video = NULL; 207514ca7a47SHans de Goede 207614ca7a47SHans de Goede 207714ca7a47SHans de Goede if (!device || !acpi_driver_data(device)) 207814ca7a47SHans de Goede return -EINVAL; 207914ca7a47SHans de Goede 208014ca7a47SHans de Goede video = acpi_driver_data(device); 208114ca7a47SHans de Goede 208214ca7a47SHans de Goede acpi_video_bus_remove_notify_handler(video); 208314ca7a47SHans de Goede acpi_video_bus_unregister_backlight(video); 208414ca7a47SHans de Goede acpi_video_bus_put_devices(video); 208514ca7a47SHans de Goede 208614ca7a47SHans de Goede mutex_lock(&video_list_lock); 208714ca7a47SHans de Goede list_del(&video->entry); 208814ca7a47SHans de Goede mutex_unlock(&video_list_lock); 208914ca7a47SHans de Goede 209014ca7a47SHans de Goede kfree(video->attached_array); 209114ca7a47SHans de Goede kfree(video); 209214ca7a47SHans de Goede 209314ca7a47SHans de Goede return 0; 209414ca7a47SHans de Goede } 209514ca7a47SHans de Goede 209614ca7a47SHans de Goede static int __init is_i740(struct pci_dev *dev) 209714ca7a47SHans de Goede { 209814ca7a47SHans de Goede if (dev->device == 0x00D1) 209914ca7a47SHans de Goede return 1; 210014ca7a47SHans de Goede if (dev->device == 0x7000) 210114ca7a47SHans de Goede return 1; 210214ca7a47SHans de Goede return 0; 210314ca7a47SHans de Goede } 210414ca7a47SHans de Goede 210514ca7a47SHans de Goede static int __init intel_opregion_present(void) 210614ca7a47SHans de Goede { 210714ca7a47SHans de Goede int opregion = 0; 210814ca7a47SHans de Goede struct pci_dev *dev = NULL; 210914ca7a47SHans de Goede u32 address; 211014ca7a47SHans de Goede 211114ca7a47SHans de Goede for_each_pci_dev(dev) { 211214ca7a47SHans de Goede if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA) 211314ca7a47SHans de Goede continue; 211414ca7a47SHans de Goede if (dev->vendor != PCI_VENDOR_ID_INTEL) 211514ca7a47SHans de Goede continue; 211614ca7a47SHans de Goede /* We don't want to poke around undefined i740 registers */ 211714ca7a47SHans de Goede if (is_i740(dev)) 211814ca7a47SHans de Goede continue; 211914ca7a47SHans de Goede pci_read_config_dword(dev, 0xfc, &address); 212014ca7a47SHans de Goede if (!address) 212114ca7a47SHans de Goede continue; 212214ca7a47SHans de Goede opregion = 1; 212314ca7a47SHans de Goede } 212414ca7a47SHans de Goede return opregion; 212514ca7a47SHans de Goede } 212614ca7a47SHans de Goede 2127*cecf3e3eSHans de Goede /* Check if the chassis-type indicates there is no builtin LCD panel */ 212853fa1f6eSHans de Goede static bool dmi_is_desktop(void) 212953fa1f6eSHans de Goede { 213053fa1f6eSHans de Goede const char *chassis_type; 2131*cecf3e3eSHans de Goede unsigned long type; 213253fa1f6eSHans de Goede 213353fa1f6eSHans de Goede chassis_type = dmi_get_system_info(DMI_CHASSIS_TYPE); 213453fa1f6eSHans de Goede if (!chassis_type) 213553fa1f6eSHans de Goede return false; 213653fa1f6eSHans de Goede 2137*cecf3e3eSHans de Goede if (kstrtoul(chassis_type, 10, &type) != 0) 2138*cecf3e3eSHans de Goede return false; 2139*cecf3e3eSHans de Goede 2140*cecf3e3eSHans de Goede switch (type) { 2141*cecf3e3eSHans de Goede case 0x03: /* Desktop */ 2142*cecf3e3eSHans de Goede case 0x04: /* Low Profile Desktop */ 2143*cecf3e3eSHans de Goede case 0x05: /* Pizza Box */ 2144*cecf3e3eSHans de Goede case 0x06: /* Mini Tower */ 2145*cecf3e3eSHans de Goede case 0x07: /* Tower */ 2146*cecf3e3eSHans de Goede case 0x11: /* Main Server Chassis */ 214753fa1f6eSHans de Goede return true; 2148*cecf3e3eSHans de Goede } 214953fa1f6eSHans de Goede 215053fa1f6eSHans de Goede return false; 215153fa1f6eSHans de Goede } 215253fa1f6eSHans de Goede 215314ca7a47SHans de Goede int acpi_video_register(void) 215414ca7a47SHans de Goede { 21552a8b18e9SHans de Goede int ret = 0; 215614ca7a47SHans de Goede 2157970530cdSHans de Goede mutex_lock(®ister_count_mutex); 2158970530cdSHans de Goede if (register_count) { 215914ca7a47SHans de Goede /* 216014ca7a47SHans de Goede * if the function of acpi_video_register is already called, 216114ca7a47SHans de Goede * don't register the acpi_vide_bus again and return no error. 216214ca7a47SHans de Goede */ 21632a8b18e9SHans de Goede goto leave; 216414ca7a47SHans de Goede } 216514ca7a47SHans de Goede 21665928c281SHans de Goede /* 21675928c281SHans de Goede * We're seeing a lot of bogus backlight interfaces on newer machines 21685928c281SHans de Goede * without a LCD such as desktops, servers and HDMI sticks. Checking 21695928c281SHans de Goede * the lcd flag fixes this, so enable this on any machines which are 21705928c281SHans de Goede * win8 ready (where we also prefer the native backlight driver, so 21715928c281SHans de Goede * normally the acpi_video code should not register there anyways). 21725928c281SHans de Goede */ 217353fa1f6eSHans de Goede if (only_lcd == -1) { 217453fa1f6eSHans de Goede if (dmi_is_desktop() && acpi_osi_is_win8()) 217553fa1f6eSHans de Goede only_lcd = true; 217653fa1f6eSHans de Goede else 217753fa1f6eSHans de Goede only_lcd = false; 217853fa1f6eSHans de Goede } 21795928c281SHans de Goede 21807ee33baaSHans de Goede dmi_check_system(video_dmi_table); 21817ee33baaSHans de Goede 218214ca7a47SHans de Goede ret = acpi_bus_register_driver(&acpi_video_bus); 218314ca7a47SHans de Goede if (ret) 21842a8b18e9SHans de Goede goto leave; 218514ca7a47SHans de Goede 218614ca7a47SHans de Goede /* 218714ca7a47SHans de Goede * When the acpi_video_bus is loaded successfully, increase 218814ca7a47SHans de Goede * the counter reference. 218914ca7a47SHans de Goede */ 2190970530cdSHans de Goede register_count = 1; 219114ca7a47SHans de Goede 21922a8b18e9SHans de Goede leave: 2193970530cdSHans de Goede mutex_unlock(®ister_count_mutex); 21942a8b18e9SHans de Goede return ret; 219514ca7a47SHans de Goede } 219614ca7a47SHans de Goede EXPORT_SYMBOL(acpi_video_register); 219714ca7a47SHans de Goede 219814ca7a47SHans de Goede void acpi_video_unregister(void) 219914ca7a47SHans de Goede { 2200970530cdSHans de Goede mutex_lock(®ister_count_mutex); 2201970530cdSHans de Goede if (register_count) { 220214ca7a47SHans de Goede acpi_bus_unregister_driver(&acpi_video_bus); 2203970530cdSHans de Goede register_count = 0; 22042a8b18e9SHans de Goede } 2205970530cdSHans de Goede mutex_unlock(®ister_count_mutex); 220614ca7a47SHans de Goede } 220714ca7a47SHans de Goede EXPORT_SYMBOL(acpi_video_unregister); 220814ca7a47SHans de Goede 220914ca7a47SHans de Goede void acpi_video_unregister_backlight(void) 221014ca7a47SHans de Goede { 221114ca7a47SHans de Goede struct acpi_video_bus *video; 221214ca7a47SHans de Goede 2213970530cdSHans de Goede mutex_lock(®ister_count_mutex); 2214970530cdSHans de Goede if (register_count) { 221514ca7a47SHans de Goede mutex_lock(&video_list_lock); 221614ca7a47SHans de Goede list_for_each_entry(video, &video_bus_head, entry) 221714ca7a47SHans de Goede acpi_video_bus_unregister_backlight(video); 221814ca7a47SHans de Goede mutex_unlock(&video_list_lock); 221914ca7a47SHans de Goede } 2220970530cdSHans de Goede mutex_unlock(®ister_count_mutex); 22212a8b18e9SHans de Goede } 222214ca7a47SHans de Goede 222390b066b1SHans de Goede bool acpi_video_handles_brightness_key_presses(void) 222490b066b1SHans de Goede { 222590b066b1SHans de Goede bool have_video_busses; 222690b066b1SHans de Goede 222790b066b1SHans de Goede mutex_lock(&video_list_lock); 222890b066b1SHans de Goede have_video_busses = !list_empty(&video_bus_head); 222990b066b1SHans de Goede mutex_unlock(&video_list_lock); 223090b066b1SHans de Goede 223105bc59a0SHans de Goede return have_video_busses && 223205bc59a0SHans de Goede (report_key_events & REPORT_BRIGHTNESS_KEY_EVENTS); 223390b066b1SHans de Goede } 223490b066b1SHans de Goede EXPORT_SYMBOL(acpi_video_handles_brightness_key_presses); 223590b066b1SHans de Goede 223614ca7a47SHans de Goede /* 223714ca7a47SHans de Goede * This is kind of nasty. Hardware using Intel chipsets may require 223814ca7a47SHans de Goede * the video opregion code to be run first in order to initialise 223914ca7a47SHans de Goede * state before any ACPI video calls are made. To handle this we defer 224014ca7a47SHans de Goede * registration of the video class until the opregion code has run. 224114ca7a47SHans de Goede */ 224214ca7a47SHans de Goede 224314ca7a47SHans de Goede static int __init acpi_video_init(void) 224414ca7a47SHans de Goede { 224514ca7a47SHans de Goede /* 224614ca7a47SHans de Goede * Let the module load even if ACPI is disabled (e.g. due to 224714ca7a47SHans de Goede * a broken BIOS) so that i915.ko can still be loaded on such 224814ca7a47SHans de Goede * old systems without an AcpiOpRegion. 224914ca7a47SHans de Goede * 225014ca7a47SHans de Goede * acpi_video_register() will report -ENODEV later as well due 225114ca7a47SHans de Goede * to acpi_disabled when i915.ko tries to register itself afterwards. 225214ca7a47SHans de Goede */ 225314ca7a47SHans de Goede if (acpi_disabled) 225414ca7a47SHans de Goede return 0; 225514ca7a47SHans de Goede 225614ca7a47SHans de Goede if (intel_opregion_present()) 225714ca7a47SHans de Goede return 0; 225814ca7a47SHans de Goede 225914ca7a47SHans de Goede return acpi_video_register(); 226014ca7a47SHans de Goede } 226114ca7a47SHans de Goede 226214ca7a47SHans de Goede static void __exit acpi_video_exit(void) 226314ca7a47SHans de Goede { 226493a291dfSHans de Goede acpi_video_detect_exit(); 226514ca7a47SHans de Goede acpi_video_unregister(); 226614ca7a47SHans de Goede 226714ca7a47SHans de Goede return; 226814ca7a47SHans de Goede } 226914ca7a47SHans de Goede 227014ca7a47SHans de Goede module_init(acpi_video_init); 227114ca7a47SHans de Goede module_exit(acpi_video_exit); 2272