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> 4014ca7a47SHans de Goede #include <asm/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 #define ACPI_VIDEO_NOTIFY_SWITCH 0x80 4714ca7a47SHans de Goede #define ACPI_VIDEO_NOTIFY_PROBE 0x81 4814ca7a47SHans de Goede #define ACPI_VIDEO_NOTIFY_CYCLE 0x82 4914ca7a47SHans de Goede #define ACPI_VIDEO_NOTIFY_NEXT_OUTPUT 0x83 5014ca7a47SHans de Goede #define ACPI_VIDEO_NOTIFY_PREV_OUTPUT 0x84 5114ca7a47SHans de Goede 5214ca7a47SHans de Goede #define ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS 0x85 5314ca7a47SHans de Goede #define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS 0x86 5414ca7a47SHans de Goede #define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS 0x87 5514ca7a47SHans de Goede #define ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS 0x88 5614ca7a47SHans de Goede #define ACPI_VIDEO_NOTIFY_DISPLAY_OFF 0x89 5714ca7a47SHans de Goede 5814ca7a47SHans de Goede #define MAX_NAME_LEN 20 5914ca7a47SHans de Goede 6014ca7a47SHans de Goede #define _COMPONENT ACPI_VIDEO_COMPONENT 6114ca7a47SHans de Goede ACPI_MODULE_NAME("video"); 6214ca7a47SHans de Goede 6314ca7a47SHans de Goede MODULE_AUTHOR("Bruno Ducrot"); 6414ca7a47SHans de Goede MODULE_DESCRIPTION("ACPI Video Driver"); 6514ca7a47SHans de Goede MODULE_LICENSE("GPL"); 6614ca7a47SHans de Goede 6714ca7a47SHans de Goede static bool brightness_switch_enabled = 1; 6814ca7a47SHans de Goede module_param(brightness_switch_enabled, bool, 0644); 6914ca7a47SHans de Goede 7014ca7a47SHans de Goede /* 7114ca7a47SHans de Goede * By default, we don't allow duplicate ACPI video bus devices 7214ca7a47SHans de Goede * under the same VGA controller 7314ca7a47SHans de Goede */ 7414ca7a47SHans de Goede static bool allow_duplicates; 7514ca7a47SHans de Goede module_param(allow_duplicates, bool, 0644); 7614ca7a47SHans de Goede 7714ca7a47SHans de Goede static int disable_backlight_sysfs_if = -1; 7814ca7a47SHans de Goede module_param(disable_backlight_sysfs_if, int, 0444); 7914ca7a47SHans de Goede 8005bc59a0SHans de Goede #define REPORT_OUTPUT_KEY_EVENTS 0x01 8105bc59a0SHans de Goede #define REPORT_BRIGHTNESS_KEY_EVENTS 0x02 8205bc59a0SHans de Goede static int report_key_events = -1; 8305bc59a0SHans de Goede module_param(report_key_events, int, 0644); 8405bc59a0SHans de Goede MODULE_PARM_DESC(report_key_events, 8505bc59a0SHans de Goede "0: none, 1: output changes, 2: brightness changes, 3: all"); 8605bc59a0SHans de Goede 87e50b9be1SAaron Lu static bool device_id_scheme = false; 88e50b9be1SAaron Lu module_param(device_id_scheme, bool, 0444); 89e50b9be1SAaron Lu 90e50b9be1SAaron Lu static bool only_lcd = false; 91e50b9be1SAaron Lu module_param(only_lcd, bool, 0444); 92e50b9be1SAaron Lu 93aecbd9b1SAdrien Schildknecht static DECLARE_COMPLETION(register_done); 94aecbd9b1SAdrien Schildknecht static DEFINE_MUTEX(register_done_mutex); 9514ca7a47SHans de Goede static struct mutex video_list_lock; 9614ca7a47SHans de Goede static struct list_head video_bus_head; 9714ca7a47SHans de Goede static int acpi_video_bus_add(struct acpi_device *device); 9814ca7a47SHans de Goede static int acpi_video_bus_remove(struct acpi_device *device); 9914ca7a47SHans de Goede static void acpi_video_bus_notify(struct acpi_device *device, u32 event); 10093a291dfSHans de Goede void acpi_video_detect_exit(void); 10114ca7a47SHans de Goede 10214ca7a47SHans de Goede static const struct acpi_device_id video_device_ids[] = { 10314ca7a47SHans de Goede {ACPI_VIDEO_HID, 0}, 10414ca7a47SHans de Goede {"", 0}, 10514ca7a47SHans de Goede }; 10614ca7a47SHans de Goede MODULE_DEVICE_TABLE(acpi, video_device_ids); 10714ca7a47SHans de Goede 10814ca7a47SHans de Goede static struct acpi_driver acpi_video_bus = { 10914ca7a47SHans de Goede .name = "video", 11014ca7a47SHans de Goede .class = ACPI_VIDEO_CLASS, 11114ca7a47SHans de Goede .ids = video_device_ids, 11214ca7a47SHans de Goede .ops = { 11314ca7a47SHans de Goede .add = acpi_video_bus_add, 11414ca7a47SHans de Goede .remove = acpi_video_bus_remove, 11514ca7a47SHans de Goede .notify = acpi_video_bus_notify, 11614ca7a47SHans de Goede }, 11714ca7a47SHans de Goede }; 11814ca7a47SHans de Goede 11914ca7a47SHans de Goede struct acpi_video_bus_flags { 12014ca7a47SHans de Goede u8 multihead:1; /* can switch video heads */ 12114ca7a47SHans de Goede u8 rom:1; /* can retrieve a video rom */ 12214ca7a47SHans de Goede u8 post:1; /* can configure the head to */ 12314ca7a47SHans de Goede u8 reserved:5; 12414ca7a47SHans de Goede }; 12514ca7a47SHans de Goede 12614ca7a47SHans de Goede struct acpi_video_bus_cap { 12714ca7a47SHans de Goede u8 _DOS:1; /* Enable/Disable output switching */ 12814ca7a47SHans de Goede u8 _DOD:1; /* Enumerate all devices attached to display adapter */ 12914ca7a47SHans de Goede u8 _ROM:1; /* Get ROM Data */ 13014ca7a47SHans de Goede u8 _GPD:1; /* Get POST Device */ 13114ca7a47SHans de Goede u8 _SPD:1; /* Set POST Device */ 13214ca7a47SHans de Goede u8 _VPO:1; /* Video POST Options */ 13314ca7a47SHans de Goede u8 reserved:2; 13414ca7a47SHans de Goede }; 13514ca7a47SHans de Goede 13614ca7a47SHans de Goede struct acpi_video_device_attrib { 13714ca7a47SHans de Goede u32 display_index:4; /* A zero-based instance of the Display */ 13814ca7a47SHans de Goede u32 display_port_attachment:4; /* This field differentiates the display type */ 13914ca7a47SHans de Goede u32 display_type:4; /* Describe the specific type in use */ 14014ca7a47SHans de Goede u32 vendor_specific:4; /* Chipset Vendor Specific */ 14114ca7a47SHans de Goede u32 bios_can_detect:1; /* BIOS can detect the device */ 14214ca7a47SHans de Goede u32 depend_on_vga:1; /* Non-VGA output device whose power is related to 14314ca7a47SHans de Goede the VGA device. */ 14414ca7a47SHans de Goede u32 pipe_id:3; /* For VGA multiple-head devices. */ 14514ca7a47SHans de Goede u32 reserved:10; /* Must be 0 */ 14614ca7a47SHans de Goede u32 device_id_scheme:1; /* Device ID Scheme */ 14714ca7a47SHans de Goede }; 14814ca7a47SHans de Goede 14914ca7a47SHans de Goede struct acpi_video_enumerated_device { 15014ca7a47SHans de Goede union { 15114ca7a47SHans de Goede u32 int_val; 15214ca7a47SHans de Goede struct acpi_video_device_attrib attrib; 15314ca7a47SHans de Goede } value; 15414ca7a47SHans de Goede struct acpi_video_device *bind_info; 15514ca7a47SHans de Goede }; 15614ca7a47SHans de Goede 15714ca7a47SHans de Goede struct acpi_video_bus { 15814ca7a47SHans de Goede struct acpi_device *device; 15914ca7a47SHans de Goede bool backlight_registered; 16014ca7a47SHans de Goede u8 dos_setting; 16114ca7a47SHans de Goede struct acpi_video_enumerated_device *attached_array; 16214ca7a47SHans de Goede u8 attached_count; 16314ca7a47SHans de Goede u8 child_count; 16414ca7a47SHans de Goede struct acpi_video_bus_cap cap; 16514ca7a47SHans de Goede struct acpi_video_bus_flags flags; 16614ca7a47SHans de Goede struct list_head video_device_list; 16714ca7a47SHans de Goede struct mutex device_list_lock; /* protects video_device_list */ 16814ca7a47SHans de Goede struct list_head entry; 16914ca7a47SHans de Goede struct input_dev *input; 17014ca7a47SHans de Goede char phys[32]; /* for input device */ 17114ca7a47SHans de Goede struct notifier_block pm_nb; 17214ca7a47SHans de Goede }; 17314ca7a47SHans de Goede 17414ca7a47SHans de Goede struct acpi_video_device_flags { 17514ca7a47SHans de Goede u8 crt:1; 17614ca7a47SHans de Goede u8 lcd:1; 17714ca7a47SHans de Goede u8 tvout:1; 17814ca7a47SHans de Goede u8 dvi:1; 17914ca7a47SHans de Goede u8 bios:1; 18014ca7a47SHans de Goede u8 unknown:1; 18114ca7a47SHans de Goede u8 notify:1; 18214ca7a47SHans de Goede u8 reserved:1; 18314ca7a47SHans de Goede }; 18414ca7a47SHans de Goede 18514ca7a47SHans de Goede struct acpi_video_device_cap { 18614ca7a47SHans de Goede u8 _ADR:1; /* Return the unique ID */ 18714ca7a47SHans de Goede u8 _BCL:1; /* Query list of brightness control levels supported */ 18814ca7a47SHans de Goede u8 _BCM:1; /* Set the brightness level */ 18914ca7a47SHans de Goede u8 _BQC:1; /* Get current brightness level */ 19014ca7a47SHans de Goede u8 _BCQ:1; /* Some buggy BIOS uses _BCQ instead of _BQC */ 19114ca7a47SHans de Goede u8 _DDC:1; /* Return the EDID for this device */ 19214ca7a47SHans de Goede }; 19314ca7a47SHans de Goede 19414ca7a47SHans de Goede struct acpi_video_brightness_flags { 19514ca7a47SHans de Goede u8 _BCL_no_ac_battery_levels:1; /* no AC/Battery levels in _BCL */ 19614ca7a47SHans de Goede u8 _BCL_reversed:1; /* _BCL package is in a reversed order */ 19714ca7a47SHans de Goede u8 _BQC_use_index:1; /* _BQC returns an index value */ 19814ca7a47SHans de Goede }; 19914ca7a47SHans de Goede 20014ca7a47SHans de Goede struct acpi_video_device_brightness { 20114ca7a47SHans de Goede int curr; 20214ca7a47SHans de Goede int count; 20314ca7a47SHans de Goede int *levels; 20414ca7a47SHans de Goede struct acpi_video_brightness_flags flags; 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 const char device_decode[][30] = { 22214ca7a47SHans de Goede "motherboard VGA device", 22314ca7a47SHans de Goede "PCI VGA device", 22414ca7a47SHans de Goede "AGP VGA device", 22514ca7a47SHans de Goede "UNKNOWN", 22614ca7a47SHans de Goede }; 22714ca7a47SHans de Goede 22814ca7a47SHans de Goede static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data); 22914ca7a47SHans de Goede static void acpi_video_device_rebind(struct acpi_video_bus *video); 23014ca7a47SHans de Goede static void acpi_video_device_bind(struct acpi_video_bus *video, 23114ca7a47SHans de Goede struct acpi_video_device *device); 23214ca7a47SHans de Goede static int acpi_video_device_enumerate(struct acpi_video_bus *video); 23314ca7a47SHans de Goede static int acpi_video_device_lcd_set_level(struct acpi_video_device *device, 23414ca7a47SHans de Goede int level); 23514ca7a47SHans de Goede static int acpi_video_device_lcd_get_level_current( 23614ca7a47SHans de Goede struct acpi_video_device *device, 23714ca7a47SHans de Goede unsigned long long *level, bool raw); 23814ca7a47SHans de Goede static int acpi_video_get_next_level(struct acpi_video_device *device, 23914ca7a47SHans de Goede u32 level_current, u32 event); 24014ca7a47SHans de Goede static void acpi_video_switch_brightness(struct work_struct *work); 24114ca7a47SHans de Goede 24214ca7a47SHans de Goede /* backlight device sysfs support */ 24314ca7a47SHans de Goede static int acpi_video_get_brightness(struct backlight_device *bd) 24414ca7a47SHans de Goede { 24514ca7a47SHans de Goede unsigned long long cur_level; 24614ca7a47SHans de Goede int i; 24714ca7a47SHans de Goede struct acpi_video_device *vd = bl_get_data(bd); 24814ca7a47SHans de Goede 24914ca7a47SHans de Goede if (acpi_video_device_lcd_get_level_current(vd, &cur_level, false)) 25014ca7a47SHans de Goede return -EINVAL; 25114ca7a47SHans de Goede for (i = 2; i < vd->brightness->count; i++) { 25214ca7a47SHans de Goede if (vd->brightness->levels[i] == cur_level) 25314ca7a47SHans de Goede /* 25414ca7a47SHans de Goede * The first two entries are special - see page 575 25514ca7a47SHans de Goede * of the ACPI spec 3.0 25614ca7a47SHans de Goede */ 25714ca7a47SHans de Goede return i - 2; 25814ca7a47SHans de Goede } 25914ca7a47SHans de Goede return 0; 26014ca7a47SHans de Goede } 26114ca7a47SHans de Goede 26214ca7a47SHans de Goede static int acpi_video_set_brightness(struct backlight_device *bd) 26314ca7a47SHans de Goede { 26414ca7a47SHans de Goede int request_level = bd->props.brightness + 2; 26514ca7a47SHans de Goede struct acpi_video_device *vd = bl_get_data(bd); 26614ca7a47SHans de Goede 26714ca7a47SHans de Goede cancel_delayed_work(&vd->switch_brightness_work); 26814ca7a47SHans de Goede return acpi_video_device_lcd_set_level(vd, 26914ca7a47SHans de Goede vd->brightness->levels[request_level]); 27014ca7a47SHans de Goede } 27114ca7a47SHans de Goede 27214ca7a47SHans de Goede static const struct backlight_ops acpi_backlight_ops = { 27314ca7a47SHans de Goede .get_brightness = acpi_video_get_brightness, 27414ca7a47SHans de Goede .update_status = acpi_video_set_brightness, 27514ca7a47SHans de Goede }; 27614ca7a47SHans de Goede 27714ca7a47SHans de Goede /* thermal cooling device callbacks */ 27814ca7a47SHans de Goede static int video_get_max_state(struct thermal_cooling_device *cooling_dev, unsigned 27914ca7a47SHans de Goede long *state) 28014ca7a47SHans de Goede { 28114ca7a47SHans de Goede struct acpi_device *device = cooling_dev->devdata; 28214ca7a47SHans de Goede struct acpi_video_device *video = acpi_driver_data(device); 28314ca7a47SHans de Goede 28414ca7a47SHans de Goede *state = video->brightness->count - 3; 28514ca7a47SHans de Goede return 0; 28614ca7a47SHans de Goede } 28714ca7a47SHans de Goede 28814ca7a47SHans de Goede static int video_get_cur_state(struct thermal_cooling_device *cooling_dev, unsigned 28914ca7a47SHans de Goede long *state) 29014ca7a47SHans de Goede { 29114ca7a47SHans de Goede struct acpi_device *device = cooling_dev->devdata; 29214ca7a47SHans de Goede struct acpi_video_device *video = acpi_driver_data(device); 29314ca7a47SHans de Goede unsigned long long level; 29414ca7a47SHans de Goede int offset; 29514ca7a47SHans de Goede 29614ca7a47SHans de Goede if (acpi_video_device_lcd_get_level_current(video, &level, false)) 29714ca7a47SHans de Goede return -EINVAL; 29814ca7a47SHans de Goede for (offset = 2; offset < video->brightness->count; offset++) 29914ca7a47SHans de Goede if (level == video->brightness->levels[offset]) { 30014ca7a47SHans de Goede *state = video->brightness->count - offset - 1; 30114ca7a47SHans de Goede return 0; 30214ca7a47SHans de Goede } 30314ca7a47SHans de Goede 30414ca7a47SHans de Goede return -EINVAL; 30514ca7a47SHans de Goede } 30614ca7a47SHans de Goede 30714ca7a47SHans de Goede static int 30814ca7a47SHans de Goede video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long state) 30914ca7a47SHans de Goede { 31014ca7a47SHans de Goede struct acpi_device *device = cooling_dev->devdata; 31114ca7a47SHans de Goede struct acpi_video_device *video = acpi_driver_data(device); 31214ca7a47SHans de Goede int level; 31314ca7a47SHans de Goede 31414ca7a47SHans de Goede if (state >= video->brightness->count - 2) 31514ca7a47SHans de Goede return -EINVAL; 31614ca7a47SHans de Goede 31714ca7a47SHans de Goede state = video->brightness->count - state; 31814ca7a47SHans de Goede level = video->brightness->levels[state - 1]; 31914ca7a47SHans de Goede return acpi_video_device_lcd_set_level(video, level); 32014ca7a47SHans de Goede } 32114ca7a47SHans de Goede 32214ca7a47SHans de Goede static const struct thermal_cooling_device_ops video_cooling_ops = { 32314ca7a47SHans de Goede .get_max_state = video_get_max_state, 32414ca7a47SHans de Goede .get_cur_state = video_get_cur_state, 32514ca7a47SHans de Goede .set_cur_state = video_set_cur_state, 32614ca7a47SHans de Goede }; 32714ca7a47SHans de Goede 32814ca7a47SHans de Goede /* 32914ca7a47SHans de Goede * -------------------------------------------------------------------------- 33014ca7a47SHans de Goede * Video Management 33114ca7a47SHans de Goede * -------------------------------------------------------------------------- 33214ca7a47SHans de Goede */ 33314ca7a47SHans de Goede 33414ca7a47SHans de Goede static int 33514ca7a47SHans de Goede acpi_video_device_lcd_query_levels(struct acpi_video_device *device, 33614ca7a47SHans de Goede union acpi_object **levels) 33714ca7a47SHans de Goede { 33814ca7a47SHans de Goede int status; 33914ca7a47SHans de Goede struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 34014ca7a47SHans de Goede union acpi_object *obj; 34114ca7a47SHans de Goede 34214ca7a47SHans de Goede 34314ca7a47SHans de Goede *levels = NULL; 34414ca7a47SHans de Goede 34514ca7a47SHans de Goede status = acpi_evaluate_object(device->dev->handle, "_BCL", NULL, &buffer); 34614ca7a47SHans de Goede if (!ACPI_SUCCESS(status)) 34714ca7a47SHans de Goede return status; 34814ca7a47SHans de Goede obj = (union acpi_object *)buffer.pointer; 34914ca7a47SHans de Goede if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) { 35014ca7a47SHans de Goede printk(KERN_ERR PREFIX "Invalid _BCL data\n"); 35114ca7a47SHans de Goede status = -EFAULT; 35214ca7a47SHans de Goede goto err; 35314ca7a47SHans de Goede } 35414ca7a47SHans de Goede 35514ca7a47SHans de Goede *levels = obj; 35614ca7a47SHans de Goede 35714ca7a47SHans de Goede return 0; 35814ca7a47SHans de Goede 35914ca7a47SHans de Goede err: 36014ca7a47SHans de Goede kfree(buffer.pointer); 36114ca7a47SHans de Goede 36214ca7a47SHans de Goede return status; 36314ca7a47SHans de Goede } 36414ca7a47SHans de Goede 36514ca7a47SHans de Goede static int 36614ca7a47SHans de Goede acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level) 36714ca7a47SHans de Goede { 36814ca7a47SHans de Goede int status; 36914ca7a47SHans de Goede int state; 37014ca7a47SHans de Goede 37114ca7a47SHans de Goede status = acpi_execute_simple_method(device->dev->handle, 37214ca7a47SHans de Goede "_BCM", level); 37314ca7a47SHans de Goede if (ACPI_FAILURE(status)) { 37414ca7a47SHans de Goede ACPI_ERROR((AE_INFO, "Evaluating _BCM failed")); 37514ca7a47SHans de Goede return -EIO; 37614ca7a47SHans de Goede } 37714ca7a47SHans de Goede 37814ca7a47SHans de Goede device->brightness->curr = level; 37914ca7a47SHans de Goede for (state = 2; state < device->brightness->count; state++) 38014ca7a47SHans de Goede if (level == device->brightness->levels[state]) { 38114ca7a47SHans de Goede if (device->backlight) 38214ca7a47SHans de Goede device->backlight->props.brightness = state - 2; 38314ca7a47SHans de Goede return 0; 38414ca7a47SHans de Goede } 38514ca7a47SHans de Goede 38614ca7a47SHans de Goede ACPI_ERROR((AE_INFO, "Current brightness invalid")); 38714ca7a47SHans de Goede return -EINVAL; 38814ca7a47SHans de Goede } 38914ca7a47SHans de Goede 39014ca7a47SHans de Goede /* 39114ca7a47SHans de Goede * For some buggy _BQC methods, we need to add a constant value to 39214ca7a47SHans de Goede * the _BQC return value to get the actual current brightness level 39314ca7a47SHans de Goede */ 39414ca7a47SHans de Goede 39514ca7a47SHans de Goede static int bqc_offset_aml_bug_workaround; 3967ee33baaSHans de Goede static int video_set_bqc_offset(const struct dmi_system_id *d) 39714ca7a47SHans de Goede { 39814ca7a47SHans de Goede bqc_offset_aml_bug_workaround = 9; 39914ca7a47SHans de Goede return 0; 40014ca7a47SHans de Goede } 40114ca7a47SHans de Goede 4027ee33baaSHans de Goede static int video_disable_backlight_sysfs_if( 40314ca7a47SHans de Goede const struct dmi_system_id *d) 40414ca7a47SHans de Goede { 40514ca7a47SHans de Goede if (disable_backlight_sysfs_if == -1) 40614ca7a47SHans de Goede disable_backlight_sysfs_if = 1; 40714ca7a47SHans de Goede return 0; 40814ca7a47SHans de Goede } 40914ca7a47SHans de Goede 410e50b9be1SAaron Lu static int video_set_device_id_scheme(const struct dmi_system_id *d) 411e50b9be1SAaron Lu { 412e50b9be1SAaron Lu device_id_scheme = true; 413e50b9be1SAaron Lu return 0; 414e50b9be1SAaron Lu } 415e50b9be1SAaron Lu 416e50b9be1SAaron Lu static int video_enable_only_lcd(const struct dmi_system_id *d) 417e50b9be1SAaron Lu { 418e50b9be1SAaron Lu only_lcd = true; 419e50b9be1SAaron Lu return 0; 420e50b9be1SAaron Lu } 421e50b9be1SAaron Lu 4224b4b3b20SHans de Goede static int video_set_report_key_events(const struct dmi_system_id *id) 4234b4b3b20SHans de Goede { 4244b4b3b20SHans de Goede if (report_key_events == -1) 4254b4b3b20SHans de Goede report_key_events = (uintptr_t)id->driver_data; 4264b4b3b20SHans de Goede return 0; 4274b4b3b20SHans de Goede } 4284b4b3b20SHans de Goede 4297ee33baaSHans de Goede static struct dmi_system_id video_dmi_table[] = { 43014ca7a47SHans de Goede /* 43114ca7a47SHans de Goede * Broken _BQC workaround http://bugzilla.kernel.org/show_bug.cgi?id=13121 43214ca7a47SHans de Goede */ 43314ca7a47SHans de Goede { 43414ca7a47SHans de Goede .callback = video_set_bqc_offset, 43514ca7a47SHans de Goede .ident = "Acer Aspire 5720", 43614ca7a47SHans de Goede .matches = { 43714ca7a47SHans de Goede DMI_MATCH(DMI_BOARD_VENDOR, "Acer"), 43814ca7a47SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5720"), 43914ca7a47SHans de Goede }, 44014ca7a47SHans de Goede }, 44114ca7a47SHans de Goede { 44214ca7a47SHans de Goede .callback = video_set_bqc_offset, 44314ca7a47SHans de Goede .ident = "Acer Aspire 5710Z", 44414ca7a47SHans de Goede .matches = { 44514ca7a47SHans de Goede DMI_MATCH(DMI_BOARD_VENDOR, "Acer"), 44614ca7a47SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5710Z"), 44714ca7a47SHans de Goede }, 44814ca7a47SHans de Goede }, 44914ca7a47SHans de Goede { 45014ca7a47SHans de Goede .callback = video_set_bqc_offset, 45114ca7a47SHans de Goede .ident = "eMachines E510", 45214ca7a47SHans de Goede .matches = { 45314ca7a47SHans de Goede DMI_MATCH(DMI_BOARD_VENDOR, "EMACHINES"), 45414ca7a47SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "eMachines E510"), 45514ca7a47SHans de Goede }, 45614ca7a47SHans de Goede }, 45714ca7a47SHans de Goede { 45814ca7a47SHans de Goede .callback = video_set_bqc_offset, 45914ca7a47SHans de Goede .ident = "Acer Aspire 5315", 46014ca7a47SHans de Goede .matches = { 46114ca7a47SHans de Goede DMI_MATCH(DMI_BOARD_VENDOR, "Acer"), 46214ca7a47SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5315"), 46314ca7a47SHans de Goede }, 46414ca7a47SHans de Goede }, 46514ca7a47SHans de Goede { 46614ca7a47SHans de Goede .callback = video_set_bqc_offset, 46714ca7a47SHans de Goede .ident = "Acer Aspire 7720", 46814ca7a47SHans de Goede .matches = { 46914ca7a47SHans de Goede DMI_MATCH(DMI_BOARD_VENDOR, "Acer"), 47014ca7a47SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 7720"), 47114ca7a47SHans de Goede }, 47214ca7a47SHans de Goede }, 47314ca7a47SHans de Goede 47414ca7a47SHans de Goede /* 47514ca7a47SHans de Goede * Some machines have a broken acpi-video interface for brightness 47614ca7a47SHans de Goede * control, but still need an acpi_video_device_lcd_set_level() call 47714ca7a47SHans de Goede * on resume to turn the backlight power on. We Enable backlight 47814ca7a47SHans de Goede * control on these systems, but do not register a backlight sysfs 47914ca7a47SHans de Goede * as brightness control does not work. 48014ca7a47SHans de Goede */ 48114ca7a47SHans de Goede { 482*de588b8fSHans de Goede /* https://bugzilla.kernel.org/show_bug.cgi?id=21012 */ 483*de588b8fSHans de Goede .callback = video_disable_backlight_sysfs_if, 484*de588b8fSHans de Goede .ident = "Toshiba Portege R700", 485*de588b8fSHans de Goede .matches = { 486*de588b8fSHans de Goede DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), 487*de588b8fSHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE R700"), 488*de588b8fSHans de Goede }, 489*de588b8fSHans de Goede }, 490*de588b8fSHans de Goede { 49114ca7a47SHans de Goede /* https://bugs.freedesktop.org/show_bug.cgi?id=82634 */ 49214ca7a47SHans de Goede .callback = video_disable_backlight_sysfs_if, 49314ca7a47SHans de Goede .ident = "Toshiba Portege R830", 49414ca7a47SHans de Goede .matches = { 49514ca7a47SHans de Goede DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), 49614ca7a47SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE R830"), 49714ca7a47SHans de Goede }, 49814ca7a47SHans de Goede }, 499e50b9be1SAaron Lu /* 500e50b9be1SAaron Lu * Some machine's _DOD IDs don't have bit 31(Device ID Scheme) set 501e50b9be1SAaron Lu * but the IDs actually follow the Device ID Scheme. 502e50b9be1SAaron Lu */ 503e50b9be1SAaron Lu { 504e50b9be1SAaron Lu /* https://bugzilla.kernel.org/show_bug.cgi?id=104121 */ 505e50b9be1SAaron Lu .callback = video_set_device_id_scheme, 506e50b9be1SAaron Lu .ident = "ESPRIMO Mobile M9410", 507e50b9be1SAaron Lu .matches = { 508e50b9be1SAaron Lu DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 509e50b9be1SAaron Lu DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO Mobile M9410"), 510e50b9be1SAaron Lu }, 511e50b9be1SAaron Lu }, 512e50b9be1SAaron Lu /* 513e50b9be1SAaron Lu * Some machines have multiple video output devices, but only the one 514e50b9be1SAaron Lu * that is the type of LCD can do the backlight control so we should not 515e50b9be1SAaron Lu * register backlight interface for other video output devices. 516e50b9be1SAaron Lu */ 517e50b9be1SAaron Lu { 518e50b9be1SAaron Lu /* https://bugzilla.kernel.org/show_bug.cgi?id=104121 */ 519e50b9be1SAaron Lu .callback = video_enable_only_lcd, 520e50b9be1SAaron Lu .ident = "ESPRIMO Mobile M9410", 521e50b9be1SAaron Lu .matches = { 522e50b9be1SAaron Lu DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 523e50b9be1SAaron Lu DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO Mobile M9410"), 524e50b9be1SAaron Lu }, 525e50b9be1SAaron Lu }, 5264b4b3b20SHans de Goede /* 5274b4b3b20SHans de Goede * Some machines report wrong key events on the acpi-bus, suppress 5284b4b3b20SHans de Goede * key event reporting on these. Note this is only intended to work 5294b4b3b20SHans de Goede * around events which are plain wrong. In some cases we get double 5304b4b3b20SHans de Goede * events, in this case acpi-video is considered the canonical source 5314b4b3b20SHans de Goede * and the events from the other source should be filtered. E.g. 5324b4b3b20SHans de Goede * by calling acpi_video_handles_brightness_key_presses() from the 5334b4b3b20SHans de Goede * vendor acpi/wmi driver or by using /lib/udev/hwdb.d/60-keyboard.hwdb 5344b4b3b20SHans de Goede */ 5354b4b3b20SHans de Goede { 5364b4b3b20SHans de Goede .callback = video_set_report_key_events, 5374b4b3b20SHans de Goede .driver_data = (void *)((uintptr_t)REPORT_OUTPUT_KEY_EVENTS), 5384b4b3b20SHans de Goede .ident = "Dell Vostro V131", 5394b4b3b20SHans de Goede .matches = { 5404b4b3b20SHans de Goede DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 5414b4b3b20SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "Vostro V131"), 5424b4b3b20SHans de Goede }, 5434b4b3b20SHans de Goede }, 54414ca7a47SHans de Goede {} 54514ca7a47SHans de Goede }; 54614ca7a47SHans de Goede 54714ca7a47SHans de Goede static unsigned long long 54814ca7a47SHans de Goede acpi_video_bqc_value_to_level(struct acpi_video_device *device, 54914ca7a47SHans de Goede unsigned long long bqc_value) 55014ca7a47SHans de Goede { 55114ca7a47SHans de Goede unsigned long long level; 55214ca7a47SHans de Goede 55314ca7a47SHans de Goede if (device->brightness->flags._BQC_use_index) { 55414ca7a47SHans de Goede /* 55514ca7a47SHans de Goede * _BQC returns an index that doesn't account for 55614ca7a47SHans de Goede * the first 2 items with special meaning, so we need 55714ca7a47SHans de Goede * to compensate for that by offsetting ourselves 55814ca7a47SHans de Goede */ 55914ca7a47SHans de Goede if (device->brightness->flags._BCL_reversed) 56014ca7a47SHans de Goede bqc_value = device->brightness->count - 3 - bqc_value; 56114ca7a47SHans de Goede 56214ca7a47SHans de Goede level = device->brightness->levels[bqc_value + 2]; 56314ca7a47SHans de Goede } else { 56414ca7a47SHans de Goede level = bqc_value; 56514ca7a47SHans de Goede } 56614ca7a47SHans de Goede 56714ca7a47SHans de Goede level += bqc_offset_aml_bug_workaround; 56814ca7a47SHans de Goede 56914ca7a47SHans de Goede return level; 57014ca7a47SHans de Goede } 57114ca7a47SHans de Goede 57214ca7a47SHans de Goede static int 57314ca7a47SHans de Goede acpi_video_device_lcd_get_level_current(struct acpi_video_device *device, 57414ca7a47SHans de Goede unsigned long long *level, bool raw) 57514ca7a47SHans de Goede { 57614ca7a47SHans de Goede acpi_status status = AE_OK; 57714ca7a47SHans de Goede int i; 57814ca7a47SHans de Goede 57914ca7a47SHans de Goede if (device->cap._BQC || device->cap._BCQ) { 58014ca7a47SHans de Goede char *buf = device->cap._BQC ? "_BQC" : "_BCQ"; 58114ca7a47SHans de Goede 58214ca7a47SHans de Goede status = acpi_evaluate_integer(device->dev->handle, buf, 58314ca7a47SHans de Goede NULL, level); 58414ca7a47SHans de Goede if (ACPI_SUCCESS(status)) { 58514ca7a47SHans de Goede if (raw) { 58614ca7a47SHans de Goede /* 58714ca7a47SHans de Goede * Caller has indicated he wants the raw 58814ca7a47SHans de Goede * value returned by _BQC, so don't furtherly 58914ca7a47SHans de Goede * mess with the value. 59014ca7a47SHans de Goede */ 59114ca7a47SHans de Goede return 0; 59214ca7a47SHans de Goede } 59314ca7a47SHans de Goede 59414ca7a47SHans de Goede *level = acpi_video_bqc_value_to_level(device, *level); 59514ca7a47SHans de Goede 59614ca7a47SHans de Goede for (i = 2; i < device->brightness->count; i++) 59714ca7a47SHans de Goede if (device->brightness->levels[i] == *level) { 59814ca7a47SHans de Goede device->brightness->curr = *level; 59914ca7a47SHans de Goede return 0; 60014ca7a47SHans de Goede } 60114ca7a47SHans de Goede /* 60214ca7a47SHans de Goede * BQC returned an invalid level. 60314ca7a47SHans de Goede * Stop using it. 60414ca7a47SHans de Goede */ 60514ca7a47SHans de Goede ACPI_WARNING((AE_INFO, 60614ca7a47SHans de Goede "%s returned an invalid level", 60714ca7a47SHans de Goede buf)); 60814ca7a47SHans de Goede device->cap._BQC = device->cap._BCQ = 0; 60914ca7a47SHans de Goede } else { 61014ca7a47SHans de Goede /* 61114ca7a47SHans de Goede * Fixme: 61214ca7a47SHans de Goede * should we return an error or ignore this failure? 61314ca7a47SHans de Goede * dev->brightness->curr is a cached value which stores 61414ca7a47SHans de Goede * the correct current backlight level in most cases. 61514ca7a47SHans de Goede * ACPI video backlight still works w/ buggy _BQC. 61614ca7a47SHans de Goede * http://bugzilla.kernel.org/show_bug.cgi?id=12233 61714ca7a47SHans de Goede */ 61814ca7a47SHans de Goede ACPI_WARNING((AE_INFO, "Evaluating %s failed", buf)); 61914ca7a47SHans de Goede device->cap._BQC = device->cap._BCQ = 0; 62014ca7a47SHans de Goede } 62114ca7a47SHans de Goede } 62214ca7a47SHans de Goede 62314ca7a47SHans de Goede *level = device->brightness->curr; 62414ca7a47SHans de Goede return 0; 62514ca7a47SHans de Goede } 62614ca7a47SHans de Goede 62714ca7a47SHans de Goede static int 62814ca7a47SHans de Goede acpi_video_device_EDID(struct acpi_video_device *device, 62914ca7a47SHans de Goede union acpi_object **edid, ssize_t length) 63014ca7a47SHans de Goede { 63114ca7a47SHans de Goede int status; 63214ca7a47SHans de Goede struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 63314ca7a47SHans de Goede union acpi_object *obj; 63414ca7a47SHans de Goede union acpi_object arg0 = { ACPI_TYPE_INTEGER }; 63514ca7a47SHans de Goede struct acpi_object_list args = { 1, &arg0 }; 63614ca7a47SHans de Goede 63714ca7a47SHans de Goede 63814ca7a47SHans de Goede *edid = NULL; 63914ca7a47SHans de Goede 64014ca7a47SHans de Goede if (!device) 64114ca7a47SHans de Goede return -ENODEV; 64214ca7a47SHans de Goede if (length == 128) 64314ca7a47SHans de Goede arg0.integer.value = 1; 64414ca7a47SHans de Goede else if (length == 256) 64514ca7a47SHans de Goede arg0.integer.value = 2; 64614ca7a47SHans de Goede else 64714ca7a47SHans de Goede return -EINVAL; 64814ca7a47SHans de Goede 64914ca7a47SHans de Goede status = acpi_evaluate_object(device->dev->handle, "_DDC", &args, &buffer); 65014ca7a47SHans de Goede if (ACPI_FAILURE(status)) 65114ca7a47SHans de Goede return -ENODEV; 65214ca7a47SHans de Goede 65314ca7a47SHans de Goede obj = buffer.pointer; 65414ca7a47SHans de Goede 65514ca7a47SHans de Goede if (obj && obj->type == ACPI_TYPE_BUFFER) 65614ca7a47SHans de Goede *edid = obj; 65714ca7a47SHans de Goede else { 65814ca7a47SHans de Goede printk(KERN_ERR PREFIX "Invalid _DDC data\n"); 65914ca7a47SHans de Goede status = -EFAULT; 66014ca7a47SHans de Goede kfree(obj); 66114ca7a47SHans de Goede } 66214ca7a47SHans de Goede 66314ca7a47SHans de Goede return status; 66414ca7a47SHans de Goede } 66514ca7a47SHans de Goede 66614ca7a47SHans de Goede /* bus */ 66714ca7a47SHans de Goede 66814ca7a47SHans de Goede /* 66914ca7a47SHans de Goede * Arg: 67014ca7a47SHans de Goede * video : video bus device pointer 67114ca7a47SHans de Goede * bios_flag : 67214ca7a47SHans de Goede * 0. The system BIOS should NOT automatically switch(toggle) 67314ca7a47SHans de Goede * the active display output. 67414ca7a47SHans de Goede * 1. The system BIOS should automatically switch (toggle) the 67514ca7a47SHans de Goede * active display output. No switch event. 67614ca7a47SHans de Goede * 2. The _DGS value should be locked. 67714ca7a47SHans de Goede * 3. The system BIOS should not automatically switch (toggle) the 67814ca7a47SHans de Goede * active display output, but instead generate the display switch 67914ca7a47SHans de Goede * event notify code. 68014ca7a47SHans de Goede * lcd_flag : 68114ca7a47SHans de Goede * 0. The system BIOS should automatically control the brightness level 68214ca7a47SHans de Goede * of the LCD when the power changes from AC to DC 68314ca7a47SHans de Goede * 1. The system BIOS should NOT automatically control the brightness 68414ca7a47SHans de Goede * level of the LCD when the power changes from AC to DC. 68514ca7a47SHans de Goede * Return Value: 68614ca7a47SHans de Goede * -EINVAL wrong arg. 68714ca7a47SHans de Goede */ 68814ca7a47SHans de Goede 68914ca7a47SHans de Goede static int 69014ca7a47SHans de Goede acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag) 69114ca7a47SHans de Goede { 69214ca7a47SHans de Goede acpi_status status; 69314ca7a47SHans de Goede 69414ca7a47SHans de Goede if (!video->cap._DOS) 69514ca7a47SHans de Goede return 0; 69614ca7a47SHans de Goede 69714ca7a47SHans de Goede if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1) 69814ca7a47SHans de Goede return -EINVAL; 69914ca7a47SHans de Goede video->dos_setting = (lcd_flag << 2) | bios_flag; 70014ca7a47SHans de Goede status = acpi_execute_simple_method(video->device->handle, "_DOS", 70114ca7a47SHans de Goede (lcd_flag << 2) | bios_flag); 70214ca7a47SHans de Goede if (ACPI_FAILURE(status)) 70314ca7a47SHans de Goede return -EIO; 70414ca7a47SHans de Goede 70514ca7a47SHans de Goede return 0; 70614ca7a47SHans de Goede } 70714ca7a47SHans de Goede 70814ca7a47SHans de Goede /* 70914ca7a47SHans de Goede * Simple comparison function used to sort backlight levels. 71014ca7a47SHans de Goede */ 71114ca7a47SHans de Goede 71214ca7a47SHans de Goede static int 71314ca7a47SHans de Goede acpi_video_cmp_level(const void *a, const void *b) 71414ca7a47SHans de Goede { 71514ca7a47SHans de Goede return *(int *)a - *(int *)b; 71614ca7a47SHans de Goede } 71714ca7a47SHans de Goede 71814ca7a47SHans de Goede /* 71914ca7a47SHans de Goede * Decides if _BQC/_BCQ for this system is usable 72014ca7a47SHans de Goede * 72114ca7a47SHans de Goede * We do this by changing the level first and then read out the current 72214ca7a47SHans de Goede * brightness level, if the value does not match, find out if it is using 72314ca7a47SHans de Goede * index. If not, clear the _BQC/_BCQ capability. 72414ca7a47SHans de Goede */ 72514ca7a47SHans de Goede static int acpi_video_bqc_quirk(struct acpi_video_device *device, 72614ca7a47SHans de Goede int max_level, int current_level) 72714ca7a47SHans de Goede { 72814ca7a47SHans de Goede struct acpi_video_device_brightness *br = device->brightness; 72914ca7a47SHans de Goede int result; 73014ca7a47SHans de Goede unsigned long long level; 73114ca7a47SHans de Goede int test_level; 73214ca7a47SHans de Goede 73314ca7a47SHans de Goede /* don't mess with existing known broken systems */ 73414ca7a47SHans de Goede if (bqc_offset_aml_bug_workaround) 73514ca7a47SHans de Goede return 0; 73614ca7a47SHans de Goede 73714ca7a47SHans de Goede /* 73814ca7a47SHans de Goede * Some systems always report current brightness level as maximum 73914ca7a47SHans de Goede * through _BQC, we need to test another value for them. 74014ca7a47SHans de Goede */ 74114ca7a47SHans de Goede test_level = current_level == max_level ? br->levels[3] : max_level; 74214ca7a47SHans de Goede 74314ca7a47SHans de Goede result = acpi_video_device_lcd_set_level(device, test_level); 74414ca7a47SHans de Goede if (result) 74514ca7a47SHans de Goede return result; 74614ca7a47SHans de Goede 74714ca7a47SHans de Goede result = acpi_video_device_lcd_get_level_current(device, &level, true); 74814ca7a47SHans de Goede if (result) 74914ca7a47SHans de Goede return result; 75014ca7a47SHans de Goede 75114ca7a47SHans de Goede if (level != test_level) { 75214ca7a47SHans de Goede /* buggy _BQC found, need to find out if it uses index */ 75314ca7a47SHans de Goede if (level < br->count) { 75414ca7a47SHans de Goede if (br->flags._BCL_reversed) 75514ca7a47SHans de Goede level = br->count - 3 - level; 75614ca7a47SHans de Goede if (br->levels[level + 2] == test_level) 75714ca7a47SHans de Goede br->flags._BQC_use_index = 1; 75814ca7a47SHans de Goede } 75914ca7a47SHans de Goede 76014ca7a47SHans de Goede if (!br->flags._BQC_use_index) 76114ca7a47SHans de Goede device->cap._BQC = device->cap._BCQ = 0; 76214ca7a47SHans de Goede } 76314ca7a47SHans de Goede 76414ca7a47SHans de Goede return 0; 76514ca7a47SHans de Goede } 76614ca7a47SHans de Goede 76714ca7a47SHans de Goede 76814ca7a47SHans de Goede /* 76914ca7a47SHans de Goede * Arg: 77014ca7a47SHans de Goede * device : video output device (LCD, CRT, ..) 77114ca7a47SHans de Goede * 77214ca7a47SHans de Goede * Return Value: 77314ca7a47SHans de Goede * Maximum brightness level 77414ca7a47SHans de Goede * 77514ca7a47SHans de Goede * Allocate and initialize device->brightness. 77614ca7a47SHans de Goede */ 77714ca7a47SHans de Goede 77814ca7a47SHans de Goede static int 77914ca7a47SHans de Goede acpi_video_init_brightness(struct acpi_video_device *device) 78014ca7a47SHans de Goede { 78114ca7a47SHans de Goede union acpi_object *obj = NULL; 78214ca7a47SHans de Goede int i, max_level = 0, count = 0, level_ac_battery = 0; 78314ca7a47SHans de Goede unsigned long long level, level_old; 78414ca7a47SHans de Goede union acpi_object *o; 78514ca7a47SHans de Goede struct acpi_video_device_brightness *br = NULL; 78614ca7a47SHans de Goede int result = -EINVAL; 78714ca7a47SHans de Goede u32 value; 78814ca7a47SHans de Goede 78914ca7a47SHans de Goede if (!ACPI_SUCCESS(acpi_video_device_lcd_query_levels(device, &obj))) { 79014ca7a47SHans de Goede ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Could not query available " 79114ca7a47SHans de Goede "LCD brightness level\n")); 79214ca7a47SHans de Goede goto out; 79314ca7a47SHans de Goede } 79414ca7a47SHans de Goede 79514ca7a47SHans de Goede if (obj->package.count < 2) 79614ca7a47SHans de Goede goto out; 79714ca7a47SHans de Goede 79814ca7a47SHans de Goede br = kzalloc(sizeof(*br), GFP_KERNEL); 79914ca7a47SHans de Goede if (!br) { 80014ca7a47SHans de Goede printk(KERN_ERR "can't allocate memory\n"); 80114ca7a47SHans de Goede result = -ENOMEM; 80214ca7a47SHans de Goede goto out; 80314ca7a47SHans de Goede } 80414ca7a47SHans de Goede 80514ca7a47SHans de Goede br->levels = kmalloc((obj->package.count + 2) * sizeof *(br->levels), 80614ca7a47SHans de Goede GFP_KERNEL); 80714ca7a47SHans de Goede if (!br->levels) { 80814ca7a47SHans de Goede result = -ENOMEM; 80914ca7a47SHans de Goede goto out_free; 81014ca7a47SHans de Goede } 81114ca7a47SHans de Goede 81214ca7a47SHans de Goede for (i = 0; i < obj->package.count; i++) { 81314ca7a47SHans de Goede o = (union acpi_object *)&obj->package.elements[i]; 81414ca7a47SHans de Goede if (o->type != ACPI_TYPE_INTEGER) { 81514ca7a47SHans de Goede printk(KERN_ERR PREFIX "Invalid data\n"); 81614ca7a47SHans de Goede continue; 81714ca7a47SHans de Goede } 81814ca7a47SHans de Goede value = (u32) o->integer.value; 81914ca7a47SHans de Goede /* Skip duplicate entries */ 82014ca7a47SHans de Goede if (count > 2 && br->levels[count - 1] == value) 82114ca7a47SHans de Goede continue; 82214ca7a47SHans de Goede 82314ca7a47SHans de Goede br->levels[count] = value; 82414ca7a47SHans de Goede 82514ca7a47SHans de Goede if (br->levels[count] > max_level) 82614ca7a47SHans de Goede max_level = br->levels[count]; 82714ca7a47SHans de Goede count++; 82814ca7a47SHans de Goede } 82914ca7a47SHans de Goede 83014ca7a47SHans de Goede /* 83114ca7a47SHans de Goede * some buggy BIOS don't export the levels 83214ca7a47SHans de Goede * when machine is on AC/Battery in _BCL package. 83314ca7a47SHans de Goede * In this case, the first two elements in _BCL packages 83414ca7a47SHans de Goede * are also supported brightness levels that OS should take care of. 83514ca7a47SHans de Goede */ 83614ca7a47SHans de Goede for (i = 2; i < count; i++) { 83714ca7a47SHans de Goede if (br->levels[i] == br->levels[0]) 83814ca7a47SHans de Goede level_ac_battery++; 83914ca7a47SHans de Goede if (br->levels[i] == br->levels[1]) 84014ca7a47SHans de Goede level_ac_battery++; 84114ca7a47SHans de Goede } 84214ca7a47SHans de Goede 84314ca7a47SHans de Goede if (level_ac_battery < 2) { 84414ca7a47SHans de Goede level_ac_battery = 2 - level_ac_battery; 84514ca7a47SHans de Goede br->flags._BCL_no_ac_battery_levels = 1; 84614ca7a47SHans de Goede for (i = (count - 1 + level_ac_battery); i >= 2; i--) 84714ca7a47SHans de Goede br->levels[i] = br->levels[i - level_ac_battery]; 84814ca7a47SHans de Goede count += level_ac_battery; 84914ca7a47SHans de Goede } else if (level_ac_battery > 2) 85014ca7a47SHans de Goede ACPI_ERROR((AE_INFO, "Too many duplicates in _BCL package")); 85114ca7a47SHans de Goede 85214ca7a47SHans de Goede /* Check if the _BCL package is in a reversed order */ 85314ca7a47SHans de Goede if (max_level == br->levels[2]) { 85414ca7a47SHans de Goede br->flags._BCL_reversed = 1; 85514ca7a47SHans de Goede sort(&br->levels[2], count - 2, sizeof(br->levels[2]), 85614ca7a47SHans de Goede acpi_video_cmp_level, NULL); 85714ca7a47SHans de Goede } else if (max_level != br->levels[count - 1]) 85814ca7a47SHans de Goede ACPI_ERROR((AE_INFO, 85914ca7a47SHans de Goede "Found unordered _BCL package")); 86014ca7a47SHans de Goede 86114ca7a47SHans de Goede br->count = count; 86214ca7a47SHans de Goede device->brightness = br; 86314ca7a47SHans de Goede 86414ca7a47SHans de Goede /* _BQC uses INDEX while _BCL uses VALUE in some laptops */ 86514ca7a47SHans de Goede br->curr = level = max_level; 86614ca7a47SHans de Goede 86714ca7a47SHans de Goede if (!device->cap._BQC) 86814ca7a47SHans de Goede goto set_level; 86914ca7a47SHans de Goede 87014ca7a47SHans de Goede result = acpi_video_device_lcd_get_level_current(device, 87114ca7a47SHans de Goede &level_old, true); 87214ca7a47SHans de Goede if (result) 87314ca7a47SHans de Goede goto out_free_levels; 87414ca7a47SHans de Goede 87514ca7a47SHans de Goede result = acpi_video_bqc_quirk(device, max_level, level_old); 87614ca7a47SHans de Goede if (result) 87714ca7a47SHans de Goede goto out_free_levels; 87814ca7a47SHans de Goede /* 87914ca7a47SHans de Goede * cap._BQC may get cleared due to _BQC is found to be broken 88014ca7a47SHans de Goede * in acpi_video_bqc_quirk, so check again here. 88114ca7a47SHans de Goede */ 88214ca7a47SHans de Goede if (!device->cap._BQC) 88314ca7a47SHans de Goede goto set_level; 88414ca7a47SHans de Goede 88514ca7a47SHans de Goede level = acpi_video_bqc_value_to_level(device, level_old); 88614ca7a47SHans de Goede /* 88714ca7a47SHans de Goede * On some buggy laptops, _BQC returns an uninitialized 88814ca7a47SHans de Goede * value when invoked for the first time, i.e. 88914ca7a47SHans de Goede * level_old is invalid (no matter whether it's a level 89014ca7a47SHans de Goede * or an index). Set the backlight to max_level in this case. 89114ca7a47SHans de Goede */ 89214ca7a47SHans de Goede for (i = 2; i < br->count; i++) 89314ca7a47SHans de Goede if (level == br->levels[i]) 89414ca7a47SHans de Goede break; 89514ca7a47SHans de Goede if (i == br->count || !level) 89614ca7a47SHans de Goede level = max_level; 89714ca7a47SHans de Goede 89814ca7a47SHans de Goede set_level: 89914ca7a47SHans de Goede result = acpi_video_device_lcd_set_level(device, level); 90014ca7a47SHans de Goede if (result) 90114ca7a47SHans de Goede goto out_free_levels; 90214ca7a47SHans de Goede 90314ca7a47SHans de Goede ACPI_DEBUG_PRINT((ACPI_DB_INFO, 90414ca7a47SHans de Goede "found %d brightness levels\n", count - 2)); 90514ca7a47SHans de Goede kfree(obj); 90614ca7a47SHans de Goede return result; 90714ca7a47SHans de Goede 90814ca7a47SHans de Goede out_free_levels: 90914ca7a47SHans de Goede kfree(br->levels); 91014ca7a47SHans de Goede out_free: 91114ca7a47SHans de Goede kfree(br); 91214ca7a47SHans de Goede out: 91314ca7a47SHans de Goede device->brightness = NULL; 91414ca7a47SHans de Goede kfree(obj); 91514ca7a47SHans de Goede return result; 91614ca7a47SHans de Goede } 91714ca7a47SHans de Goede 91814ca7a47SHans de Goede /* 91914ca7a47SHans de Goede * Arg: 92014ca7a47SHans de Goede * device : video output device (LCD, CRT, ..) 92114ca7a47SHans de Goede * 92214ca7a47SHans de Goede * Return Value: 92314ca7a47SHans de Goede * None 92414ca7a47SHans de Goede * 92514ca7a47SHans de Goede * Find out all required AML methods defined under the output 92614ca7a47SHans de Goede * device. 92714ca7a47SHans de Goede */ 92814ca7a47SHans de Goede 92914ca7a47SHans de Goede static void acpi_video_device_find_cap(struct acpi_video_device *device) 93014ca7a47SHans de Goede { 93114ca7a47SHans de Goede if (acpi_has_method(device->dev->handle, "_ADR")) 93214ca7a47SHans de Goede device->cap._ADR = 1; 93314ca7a47SHans de Goede if (acpi_has_method(device->dev->handle, "_BCL")) 93414ca7a47SHans de Goede device->cap._BCL = 1; 93514ca7a47SHans de Goede if (acpi_has_method(device->dev->handle, "_BCM")) 93614ca7a47SHans de Goede device->cap._BCM = 1; 93714ca7a47SHans de Goede if (acpi_has_method(device->dev->handle, "_BQC")) { 93814ca7a47SHans de Goede device->cap._BQC = 1; 93914ca7a47SHans de Goede } else if (acpi_has_method(device->dev->handle, "_BCQ")) { 94014ca7a47SHans de Goede printk(KERN_WARNING FW_BUG "_BCQ is used instead of _BQC\n"); 94114ca7a47SHans de Goede device->cap._BCQ = 1; 94214ca7a47SHans de Goede } 94314ca7a47SHans de Goede 94414ca7a47SHans de Goede if (acpi_has_method(device->dev->handle, "_DDC")) 94514ca7a47SHans de Goede device->cap._DDC = 1; 94614ca7a47SHans de Goede } 94714ca7a47SHans de Goede 94814ca7a47SHans de Goede /* 94914ca7a47SHans de Goede * Arg: 95014ca7a47SHans de Goede * device : video output device (VGA) 95114ca7a47SHans de Goede * 95214ca7a47SHans de Goede * Return Value: 95314ca7a47SHans de Goede * None 95414ca7a47SHans de Goede * 95514ca7a47SHans de Goede * Find out all required AML methods defined under the video bus device. 95614ca7a47SHans de Goede */ 95714ca7a47SHans de Goede 95814ca7a47SHans de Goede static void acpi_video_bus_find_cap(struct acpi_video_bus *video) 95914ca7a47SHans de Goede { 96014ca7a47SHans de Goede if (acpi_has_method(video->device->handle, "_DOS")) 96114ca7a47SHans de Goede video->cap._DOS = 1; 96214ca7a47SHans de Goede if (acpi_has_method(video->device->handle, "_DOD")) 96314ca7a47SHans de Goede video->cap._DOD = 1; 96414ca7a47SHans de Goede if (acpi_has_method(video->device->handle, "_ROM")) 96514ca7a47SHans de Goede video->cap._ROM = 1; 96614ca7a47SHans de Goede if (acpi_has_method(video->device->handle, "_GPD")) 96714ca7a47SHans de Goede video->cap._GPD = 1; 96814ca7a47SHans de Goede if (acpi_has_method(video->device->handle, "_SPD")) 96914ca7a47SHans de Goede video->cap._SPD = 1; 97014ca7a47SHans de Goede if (acpi_has_method(video->device->handle, "_VPO")) 97114ca7a47SHans de Goede video->cap._VPO = 1; 97214ca7a47SHans de Goede } 97314ca7a47SHans de Goede 97414ca7a47SHans de Goede /* 97514ca7a47SHans de Goede * Check whether the video bus device has required AML method to 97614ca7a47SHans de Goede * support the desired features 97714ca7a47SHans de Goede */ 97814ca7a47SHans de Goede 97914ca7a47SHans de Goede static int acpi_video_bus_check(struct acpi_video_bus *video) 98014ca7a47SHans de Goede { 98114ca7a47SHans de Goede acpi_status status = -ENOENT; 98214ca7a47SHans de Goede struct pci_dev *dev; 98314ca7a47SHans de Goede 98414ca7a47SHans de Goede if (!video) 98514ca7a47SHans de Goede return -EINVAL; 98614ca7a47SHans de Goede 98714ca7a47SHans de Goede dev = acpi_get_pci_dev(video->device->handle); 98814ca7a47SHans de Goede if (!dev) 98914ca7a47SHans de Goede return -ENODEV; 99014ca7a47SHans de Goede pci_dev_put(dev); 99114ca7a47SHans de Goede 99214ca7a47SHans de Goede /* 99314ca7a47SHans de Goede * Since there is no HID, CID and so on for VGA driver, we have 99414ca7a47SHans de Goede * to check well known required nodes. 99514ca7a47SHans de Goede */ 99614ca7a47SHans de Goede 99714ca7a47SHans de Goede /* Does this device support video switching? */ 99814ca7a47SHans de Goede if (video->cap._DOS || video->cap._DOD) { 99914ca7a47SHans de Goede if (!video->cap._DOS) { 100014ca7a47SHans de Goede printk(KERN_WARNING FW_BUG 100114ca7a47SHans de Goede "ACPI(%s) defines _DOD but not _DOS\n", 100214ca7a47SHans de Goede acpi_device_bid(video->device)); 100314ca7a47SHans de Goede } 100414ca7a47SHans de Goede video->flags.multihead = 1; 100514ca7a47SHans de Goede status = 0; 100614ca7a47SHans de Goede } 100714ca7a47SHans de Goede 100814ca7a47SHans de Goede /* Does this device support retrieving a video ROM? */ 100914ca7a47SHans de Goede if (video->cap._ROM) { 101014ca7a47SHans de Goede video->flags.rom = 1; 101114ca7a47SHans de Goede status = 0; 101214ca7a47SHans de Goede } 101314ca7a47SHans de Goede 101414ca7a47SHans de Goede /* Does this device support configuring which video device to POST? */ 101514ca7a47SHans de Goede if (video->cap._GPD && video->cap._SPD && video->cap._VPO) { 101614ca7a47SHans de Goede video->flags.post = 1; 101714ca7a47SHans de Goede status = 0; 101814ca7a47SHans de Goede } 101914ca7a47SHans de Goede 102014ca7a47SHans de Goede return status; 102114ca7a47SHans de Goede } 102214ca7a47SHans de Goede 102314ca7a47SHans de Goede /* 102414ca7a47SHans de Goede * -------------------------------------------------------------------------- 102514ca7a47SHans de Goede * Driver Interface 102614ca7a47SHans de Goede * -------------------------------------------------------------------------- 102714ca7a47SHans de Goede */ 102814ca7a47SHans de Goede 102914ca7a47SHans de Goede /* device interface */ 103014ca7a47SHans de Goede static struct acpi_video_device_attrib * 103114ca7a47SHans de Goede acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id) 103214ca7a47SHans de Goede { 103314ca7a47SHans de Goede struct acpi_video_enumerated_device *ids; 103414ca7a47SHans de Goede int i; 103514ca7a47SHans de Goede 103614ca7a47SHans de Goede for (i = 0; i < video->attached_count; i++) { 103714ca7a47SHans de Goede ids = &video->attached_array[i]; 103814ca7a47SHans de Goede if ((ids->value.int_val & 0xffff) == device_id) 103914ca7a47SHans de Goede return &ids->value.attrib; 104014ca7a47SHans de Goede } 104114ca7a47SHans de Goede 104214ca7a47SHans de Goede return NULL; 104314ca7a47SHans de Goede } 104414ca7a47SHans de Goede 104514ca7a47SHans de Goede static int 104614ca7a47SHans de Goede acpi_video_get_device_type(struct acpi_video_bus *video, 104714ca7a47SHans de Goede unsigned long device_id) 104814ca7a47SHans de Goede { 104914ca7a47SHans de Goede struct acpi_video_enumerated_device *ids; 105014ca7a47SHans de Goede int i; 105114ca7a47SHans de Goede 105214ca7a47SHans de Goede for (i = 0; i < video->attached_count; i++) { 105314ca7a47SHans de Goede ids = &video->attached_array[i]; 105414ca7a47SHans de Goede if ((ids->value.int_val & 0xffff) == device_id) 105514ca7a47SHans de Goede return ids->value.int_val; 105614ca7a47SHans de Goede } 105714ca7a47SHans de Goede 105814ca7a47SHans de Goede return 0; 105914ca7a47SHans de Goede } 106014ca7a47SHans de Goede 106114ca7a47SHans de Goede static int 106214ca7a47SHans de Goede acpi_video_bus_get_one_device(struct acpi_device *device, 106314ca7a47SHans de Goede struct acpi_video_bus *video) 106414ca7a47SHans de Goede { 106514ca7a47SHans de Goede unsigned long long device_id; 106614ca7a47SHans de Goede int status, device_type; 106714ca7a47SHans de Goede struct acpi_video_device *data; 106814ca7a47SHans de Goede struct acpi_video_device_attrib *attribute; 106914ca7a47SHans de Goede 107014ca7a47SHans de Goede status = 107114ca7a47SHans de Goede acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id); 107214ca7a47SHans de Goede /* Some device omits _ADR, we skip them instead of fail */ 107314ca7a47SHans de Goede if (ACPI_FAILURE(status)) 107414ca7a47SHans de Goede return 0; 107514ca7a47SHans de Goede 107614ca7a47SHans de Goede data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL); 107714ca7a47SHans de Goede if (!data) 107814ca7a47SHans de Goede return -ENOMEM; 107914ca7a47SHans de Goede 108014ca7a47SHans de Goede strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME); 108114ca7a47SHans de Goede strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS); 108214ca7a47SHans de Goede device->driver_data = data; 108314ca7a47SHans de Goede 108414ca7a47SHans de Goede data->device_id = device_id; 108514ca7a47SHans de Goede data->video = video; 108614ca7a47SHans de Goede data->dev = device; 108714ca7a47SHans de Goede INIT_DELAYED_WORK(&data->switch_brightness_work, 108814ca7a47SHans de Goede acpi_video_switch_brightness); 108914ca7a47SHans de Goede 109014ca7a47SHans de Goede attribute = acpi_video_get_device_attr(video, device_id); 109114ca7a47SHans de Goede 1092e50b9be1SAaron Lu if (attribute && (attribute->device_id_scheme || device_id_scheme)) { 109314ca7a47SHans de Goede switch (attribute->display_type) { 109414ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_CRT: 109514ca7a47SHans de Goede data->flags.crt = 1; 109614ca7a47SHans de Goede break; 109714ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_TV: 109814ca7a47SHans de Goede data->flags.tvout = 1; 109914ca7a47SHans de Goede break; 110014ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_DVI: 110114ca7a47SHans de Goede data->flags.dvi = 1; 110214ca7a47SHans de Goede break; 110314ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_LCD: 110414ca7a47SHans de Goede data->flags.lcd = 1; 110514ca7a47SHans de Goede break; 110614ca7a47SHans de Goede default: 110714ca7a47SHans de Goede data->flags.unknown = 1; 110814ca7a47SHans de Goede break; 110914ca7a47SHans de Goede } 111014ca7a47SHans de Goede if (attribute->bios_can_detect) 111114ca7a47SHans de Goede data->flags.bios = 1; 111214ca7a47SHans de Goede } else { 111314ca7a47SHans de Goede /* Check for legacy IDs */ 111414ca7a47SHans de Goede device_type = acpi_video_get_device_type(video, device_id); 111514ca7a47SHans de Goede /* Ignore bits 16 and 18-20 */ 111614ca7a47SHans de Goede switch (device_type & 0xffe2ffff) { 111714ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_LEGACY_MONITOR: 111814ca7a47SHans de Goede data->flags.crt = 1; 111914ca7a47SHans de Goede break; 112014ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_LEGACY_PANEL: 112114ca7a47SHans de Goede data->flags.lcd = 1; 112214ca7a47SHans de Goede break; 112314ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_LEGACY_TV: 112414ca7a47SHans de Goede data->flags.tvout = 1; 112514ca7a47SHans de Goede break; 112614ca7a47SHans de Goede default: 112714ca7a47SHans de Goede data->flags.unknown = 1; 112814ca7a47SHans de Goede } 112914ca7a47SHans de Goede } 113014ca7a47SHans de Goede 113114ca7a47SHans de Goede acpi_video_device_bind(video, data); 113214ca7a47SHans de Goede acpi_video_device_find_cap(data); 113314ca7a47SHans de Goede 113414ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 113514ca7a47SHans de Goede list_add_tail(&data->entry, &video->video_device_list); 113614ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 113714ca7a47SHans de Goede 113814ca7a47SHans de Goede return status; 113914ca7a47SHans de Goede } 114014ca7a47SHans de Goede 114114ca7a47SHans de Goede /* 114214ca7a47SHans de Goede * Arg: 114314ca7a47SHans de Goede * video : video bus device 114414ca7a47SHans de Goede * 114514ca7a47SHans de Goede * Return: 114614ca7a47SHans de Goede * none 114714ca7a47SHans de Goede * 114814ca7a47SHans de Goede * Enumerate the video device list of the video bus, 114914ca7a47SHans de Goede * bind the ids with the corresponding video devices 115014ca7a47SHans de Goede * under the video bus. 115114ca7a47SHans de Goede */ 115214ca7a47SHans de Goede 115314ca7a47SHans de Goede static void acpi_video_device_rebind(struct acpi_video_bus *video) 115414ca7a47SHans de Goede { 115514ca7a47SHans de Goede struct acpi_video_device *dev; 115614ca7a47SHans de Goede 115714ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 115814ca7a47SHans de Goede 115914ca7a47SHans de Goede list_for_each_entry(dev, &video->video_device_list, entry) 116014ca7a47SHans de Goede acpi_video_device_bind(video, dev); 116114ca7a47SHans de Goede 116214ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 116314ca7a47SHans de Goede } 116414ca7a47SHans de Goede 116514ca7a47SHans de Goede /* 116614ca7a47SHans de Goede * Arg: 116714ca7a47SHans de Goede * video : video bus device 116814ca7a47SHans de Goede * device : video output device under the video 116914ca7a47SHans de Goede * bus 117014ca7a47SHans de Goede * 117114ca7a47SHans de Goede * Return: 117214ca7a47SHans de Goede * none 117314ca7a47SHans de Goede * 117414ca7a47SHans de Goede * Bind the ids with the corresponding video devices 117514ca7a47SHans de Goede * under the video bus. 117614ca7a47SHans de Goede */ 117714ca7a47SHans de Goede 117814ca7a47SHans de Goede static void 117914ca7a47SHans de Goede acpi_video_device_bind(struct acpi_video_bus *video, 118014ca7a47SHans de Goede struct acpi_video_device *device) 118114ca7a47SHans de Goede { 118214ca7a47SHans de Goede struct acpi_video_enumerated_device *ids; 118314ca7a47SHans de Goede int i; 118414ca7a47SHans de Goede 118514ca7a47SHans de Goede for (i = 0; i < video->attached_count; i++) { 118614ca7a47SHans de Goede ids = &video->attached_array[i]; 118714ca7a47SHans de Goede if (device->device_id == (ids->value.int_val & 0xffff)) { 118814ca7a47SHans de Goede ids->bind_info = device; 118914ca7a47SHans de Goede ACPI_DEBUG_PRINT((ACPI_DB_INFO, "device_bind %d\n", i)); 119014ca7a47SHans de Goede } 119114ca7a47SHans de Goede } 119214ca7a47SHans de Goede } 119314ca7a47SHans de Goede 119414ca7a47SHans de Goede static bool acpi_video_device_in_dod(struct acpi_video_device *device) 119514ca7a47SHans de Goede { 119614ca7a47SHans de Goede struct acpi_video_bus *video = device->video; 119714ca7a47SHans de Goede int i; 119814ca7a47SHans de Goede 119914ca7a47SHans de Goede /* 120014ca7a47SHans de Goede * If we have a broken _DOD or we have more than 8 output devices 120114ca7a47SHans de Goede * under the graphics controller node that we can't proper deal with 120214ca7a47SHans de Goede * in the operation region code currently, no need to test. 120314ca7a47SHans de Goede */ 120414ca7a47SHans de Goede if (!video->attached_count || video->child_count > 8) 120514ca7a47SHans de Goede return true; 120614ca7a47SHans de Goede 120714ca7a47SHans de Goede for (i = 0; i < video->attached_count; i++) { 120814ca7a47SHans de Goede if ((video->attached_array[i].value.int_val & 0xfff) == 120914ca7a47SHans de Goede (device->device_id & 0xfff)) 121014ca7a47SHans de Goede return true; 121114ca7a47SHans de Goede } 121214ca7a47SHans de Goede 121314ca7a47SHans de Goede return false; 121414ca7a47SHans de Goede } 121514ca7a47SHans de Goede 121614ca7a47SHans de Goede /* 121714ca7a47SHans de Goede * Arg: 121814ca7a47SHans de Goede * video : video bus device 121914ca7a47SHans de Goede * 122014ca7a47SHans de Goede * Return: 122114ca7a47SHans de Goede * < 0 : error 122214ca7a47SHans de Goede * 122314ca7a47SHans de Goede * Call _DOD to enumerate all devices attached to display adapter 122414ca7a47SHans de Goede * 122514ca7a47SHans de Goede */ 122614ca7a47SHans de Goede 122714ca7a47SHans de Goede static int acpi_video_device_enumerate(struct acpi_video_bus *video) 122814ca7a47SHans de Goede { 122914ca7a47SHans de Goede int status; 123014ca7a47SHans de Goede int count; 123114ca7a47SHans de Goede int i; 123214ca7a47SHans de Goede struct acpi_video_enumerated_device *active_list; 123314ca7a47SHans de Goede struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 123414ca7a47SHans de Goede union acpi_object *dod = NULL; 123514ca7a47SHans de Goede union acpi_object *obj; 123614ca7a47SHans de Goede 123714ca7a47SHans de Goede status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer); 123814ca7a47SHans de Goede if (!ACPI_SUCCESS(status)) { 123914ca7a47SHans de Goede ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD")); 124014ca7a47SHans de Goede return status; 124114ca7a47SHans de Goede } 124214ca7a47SHans de Goede 124314ca7a47SHans de Goede dod = buffer.pointer; 124414ca7a47SHans de Goede if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) { 124514ca7a47SHans de Goede ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data")); 124614ca7a47SHans de Goede status = -EFAULT; 124714ca7a47SHans de Goede goto out; 124814ca7a47SHans de Goede } 124914ca7a47SHans de Goede 125014ca7a47SHans de Goede ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d video heads in _DOD\n", 125114ca7a47SHans de Goede dod->package.count)); 125214ca7a47SHans de Goede 125314ca7a47SHans de Goede active_list = kcalloc(1 + dod->package.count, 125414ca7a47SHans de Goede sizeof(struct acpi_video_enumerated_device), 125514ca7a47SHans de Goede GFP_KERNEL); 125614ca7a47SHans de Goede if (!active_list) { 125714ca7a47SHans de Goede status = -ENOMEM; 125814ca7a47SHans de Goede goto out; 125914ca7a47SHans de Goede } 126014ca7a47SHans de Goede 126114ca7a47SHans de Goede count = 0; 126214ca7a47SHans de Goede for (i = 0; i < dod->package.count; i++) { 126314ca7a47SHans de Goede obj = &dod->package.elements[i]; 126414ca7a47SHans de Goede 126514ca7a47SHans de Goede if (obj->type != ACPI_TYPE_INTEGER) { 126614ca7a47SHans de Goede printk(KERN_ERR PREFIX 126714ca7a47SHans de Goede "Invalid _DOD data in element %d\n", i); 126814ca7a47SHans de Goede continue; 126914ca7a47SHans de Goede } 127014ca7a47SHans de Goede 127114ca7a47SHans de Goede active_list[count].value.int_val = obj->integer.value; 127214ca7a47SHans de Goede active_list[count].bind_info = NULL; 127314ca7a47SHans de Goede ACPI_DEBUG_PRINT((ACPI_DB_INFO, "dod element[%d] = %d\n", i, 127414ca7a47SHans de Goede (int)obj->integer.value)); 127514ca7a47SHans de Goede count++; 127614ca7a47SHans de Goede } 127714ca7a47SHans de Goede 127814ca7a47SHans de Goede kfree(video->attached_array); 127914ca7a47SHans de Goede 128014ca7a47SHans de Goede video->attached_array = active_list; 128114ca7a47SHans de Goede video->attached_count = count; 128214ca7a47SHans de Goede 128314ca7a47SHans de Goede out: 128414ca7a47SHans de Goede kfree(buffer.pointer); 128514ca7a47SHans de Goede return status; 128614ca7a47SHans de Goede } 128714ca7a47SHans de Goede 128814ca7a47SHans de Goede static int 128914ca7a47SHans de Goede acpi_video_get_next_level(struct acpi_video_device *device, 129014ca7a47SHans de Goede u32 level_current, u32 event) 129114ca7a47SHans de Goede { 129214ca7a47SHans de Goede int min, max, min_above, max_below, i, l, delta = 255; 129314ca7a47SHans de Goede max = max_below = 0; 129414ca7a47SHans de Goede min = min_above = 255; 129514ca7a47SHans de Goede /* Find closest level to level_current */ 129614ca7a47SHans de Goede for (i = 2; i < device->brightness->count; i++) { 129714ca7a47SHans de Goede l = device->brightness->levels[i]; 129814ca7a47SHans de Goede if (abs(l - level_current) < abs(delta)) { 129914ca7a47SHans de Goede delta = l - level_current; 130014ca7a47SHans de Goede if (!delta) 130114ca7a47SHans de Goede break; 130214ca7a47SHans de Goede } 130314ca7a47SHans de Goede } 130414ca7a47SHans de Goede /* Ajust level_current to closest available level */ 130514ca7a47SHans de Goede level_current += delta; 130614ca7a47SHans de Goede for (i = 2; i < device->brightness->count; i++) { 130714ca7a47SHans de Goede l = device->brightness->levels[i]; 130814ca7a47SHans de Goede if (l < min) 130914ca7a47SHans de Goede min = l; 131014ca7a47SHans de Goede if (l > max) 131114ca7a47SHans de Goede max = l; 131214ca7a47SHans de Goede if (l < min_above && l > level_current) 131314ca7a47SHans de Goede min_above = l; 131414ca7a47SHans de Goede if (l > max_below && l < level_current) 131514ca7a47SHans de Goede max_below = l; 131614ca7a47SHans de Goede } 131714ca7a47SHans de Goede 131814ca7a47SHans de Goede switch (event) { 131914ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS: 132014ca7a47SHans de Goede return (level_current < max) ? min_above : min; 132114ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS: 132214ca7a47SHans de Goede return (level_current < max) ? min_above : max; 132314ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS: 132414ca7a47SHans de Goede return (level_current > min) ? max_below : min; 132514ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: 132614ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: 132714ca7a47SHans de Goede return 0; 132814ca7a47SHans de Goede default: 132914ca7a47SHans de Goede return level_current; 133014ca7a47SHans de Goede } 133114ca7a47SHans de Goede } 133214ca7a47SHans de Goede 133314ca7a47SHans de Goede static void 133414ca7a47SHans de Goede acpi_video_switch_brightness(struct work_struct *work) 133514ca7a47SHans de Goede { 133614ca7a47SHans de Goede struct acpi_video_device *device = container_of(to_delayed_work(work), 133714ca7a47SHans de Goede struct acpi_video_device, switch_brightness_work); 133814ca7a47SHans de Goede unsigned long long level_current, level_next; 133914ca7a47SHans de Goede int event = device->switch_brightness_event; 134014ca7a47SHans de Goede int result = -EINVAL; 134114ca7a47SHans de Goede 134214ca7a47SHans de Goede /* no warning message if acpi_backlight=vendor or a quirk is used */ 134314ca7a47SHans de Goede if (!device->backlight) 134414ca7a47SHans de Goede return; 134514ca7a47SHans de Goede 134614ca7a47SHans de Goede if (!device->brightness) 134714ca7a47SHans de Goede goto out; 134814ca7a47SHans de Goede 134914ca7a47SHans de Goede result = acpi_video_device_lcd_get_level_current(device, 135014ca7a47SHans de Goede &level_current, 135114ca7a47SHans de Goede false); 135214ca7a47SHans de Goede if (result) 135314ca7a47SHans de Goede goto out; 135414ca7a47SHans de Goede 135514ca7a47SHans de Goede level_next = acpi_video_get_next_level(device, level_current, event); 135614ca7a47SHans de Goede 135714ca7a47SHans de Goede result = acpi_video_device_lcd_set_level(device, level_next); 135814ca7a47SHans de Goede 135914ca7a47SHans de Goede if (!result) 136014ca7a47SHans de Goede backlight_force_update(device->backlight, 136114ca7a47SHans de Goede BACKLIGHT_UPDATE_HOTKEY); 136214ca7a47SHans de Goede 136314ca7a47SHans de Goede out: 136414ca7a47SHans de Goede if (result) 136514ca7a47SHans de Goede printk(KERN_ERR PREFIX "Failed to switch the brightness\n"); 136614ca7a47SHans de Goede } 136714ca7a47SHans de Goede 136814ca7a47SHans de Goede int acpi_video_get_edid(struct acpi_device *device, int type, int device_id, 136914ca7a47SHans de Goede void **edid) 137014ca7a47SHans de Goede { 137114ca7a47SHans de Goede struct acpi_video_bus *video; 137214ca7a47SHans de Goede struct acpi_video_device *video_device; 137314ca7a47SHans de Goede union acpi_object *buffer = NULL; 137414ca7a47SHans de Goede acpi_status status; 137514ca7a47SHans de Goede int i, length; 137614ca7a47SHans de Goede 137714ca7a47SHans de Goede if (!device || !acpi_driver_data(device)) 137814ca7a47SHans de Goede return -EINVAL; 137914ca7a47SHans de Goede 138014ca7a47SHans de Goede video = acpi_driver_data(device); 138114ca7a47SHans de Goede 138214ca7a47SHans de Goede for (i = 0; i < video->attached_count; i++) { 138314ca7a47SHans de Goede video_device = video->attached_array[i].bind_info; 138414ca7a47SHans de Goede length = 256; 138514ca7a47SHans de Goede 138614ca7a47SHans de Goede if (!video_device) 138714ca7a47SHans de Goede continue; 138814ca7a47SHans de Goede 138914ca7a47SHans de Goede if (!video_device->cap._DDC) 139014ca7a47SHans de Goede continue; 139114ca7a47SHans de Goede 139214ca7a47SHans de Goede if (type) { 139314ca7a47SHans de Goede switch (type) { 139414ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_CRT: 139514ca7a47SHans de Goede if (!video_device->flags.crt) 139614ca7a47SHans de Goede continue; 139714ca7a47SHans de Goede break; 139814ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_TV: 139914ca7a47SHans de Goede if (!video_device->flags.tvout) 140014ca7a47SHans de Goede continue; 140114ca7a47SHans de Goede break; 140214ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_DVI: 140314ca7a47SHans de Goede if (!video_device->flags.dvi) 140414ca7a47SHans de Goede continue; 140514ca7a47SHans de Goede break; 140614ca7a47SHans de Goede case ACPI_VIDEO_DISPLAY_LCD: 140714ca7a47SHans de Goede if (!video_device->flags.lcd) 140814ca7a47SHans de Goede continue; 140914ca7a47SHans de Goede break; 141014ca7a47SHans de Goede } 141114ca7a47SHans de Goede } else if (video_device->device_id != device_id) { 141214ca7a47SHans de Goede continue; 141314ca7a47SHans de Goede } 141414ca7a47SHans de Goede 141514ca7a47SHans de Goede status = acpi_video_device_EDID(video_device, &buffer, length); 141614ca7a47SHans de Goede 141714ca7a47SHans de Goede if (ACPI_FAILURE(status) || !buffer || 141814ca7a47SHans de Goede buffer->type != ACPI_TYPE_BUFFER) { 141914ca7a47SHans de Goede length = 128; 142014ca7a47SHans de Goede status = acpi_video_device_EDID(video_device, &buffer, 142114ca7a47SHans de Goede length); 142214ca7a47SHans de Goede if (ACPI_FAILURE(status) || !buffer || 142314ca7a47SHans de Goede buffer->type != ACPI_TYPE_BUFFER) { 142414ca7a47SHans de Goede continue; 142514ca7a47SHans de Goede } 142614ca7a47SHans de Goede } 142714ca7a47SHans de Goede 142814ca7a47SHans de Goede *edid = buffer->buffer.pointer; 142914ca7a47SHans de Goede return length; 143014ca7a47SHans de Goede } 143114ca7a47SHans de Goede 143214ca7a47SHans de Goede return -ENODEV; 143314ca7a47SHans de Goede } 143414ca7a47SHans de Goede EXPORT_SYMBOL(acpi_video_get_edid); 143514ca7a47SHans de Goede 143614ca7a47SHans de Goede static int 143714ca7a47SHans de Goede acpi_video_bus_get_devices(struct acpi_video_bus *video, 143814ca7a47SHans de Goede struct acpi_device *device) 143914ca7a47SHans de Goede { 144014ca7a47SHans de Goede int status = 0; 144114ca7a47SHans de Goede struct acpi_device *dev; 144214ca7a47SHans de Goede 144314ca7a47SHans de Goede /* 144414ca7a47SHans de Goede * There are systems where video module known to work fine regardless 144514ca7a47SHans de Goede * of broken _DOD and ignoring returned value here doesn't cause 144614ca7a47SHans de Goede * any issues later. 144714ca7a47SHans de Goede */ 144814ca7a47SHans de Goede acpi_video_device_enumerate(video); 144914ca7a47SHans de Goede 145014ca7a47SHans de Goede list_for_each_entry(dev, &device->children, node) { 145114ca7a47SHans de Goede 145214ca7a47SHans de Goede status = acpi_video_bus_get_one_device(dev, video); 145314ca7a47SHans de Goede if (status) { 145414ca7a47SHans de Goede dev_err(&dev->dev, "Can't attach device\n"); 145514ca7a47SHans de Goede break; 145614ca7a47SHans de Goede } 145714ca7a47SHans de Goede video->child_count++; 145814ca7a47SHans de Goede } 145914ca7a47SHans de Goede return status; 146014ca7a47SHans de Goede } 146114ca7a47SHans de Goede 146214ca7a47SHans de Goede /* acpi_video interface */ 146314ca7a47SHans de Goede 146414ca7a47SHans de Goede /* 146514ca7a47SHans de Goede * Win8 requires setting bit2 of _DOS to let firmware know it shouldn't 146614ca7a47SHans de Goede * preform any automatic brightness change on receiving a notification. 146714ca7a47SHans de Goede */ 146814ca7a47SHans de Goede static int acpi_video_bus_start_devices(struct acpi_video_bus *video) 146914ca7a47SHans de Goede { 147014ca7a47SHans de Goede return acpi_video_bus_DOS(video, 0, 147114ca7a47SHans de Goede acpi_osi_is_win8() ? 1 : 0); 147214ca7a47SHans de Goede } 147314ca7a47SHans de Goede 147414ca7a47SHans de Goede static int acpi_video_bus_stop_devices(struct acpi_video_bus *video) 147514ca7a47SHans de Goede { 147614ca7a47SHans de Goede return acpi_video_bus_DOS(video, 0, 147714ca7a47SHans de Goede acpi_osi_is_win8() ? 0 : 1); 147814ca7a47SHans de Goede } 147914ca7a47SHans de Goede 148014ca7a47SHans de Goede static void acpi_video_bus_notify(struct acpi_device *device, u32 event) 148114ca7a47SHans de Goede { 148214ca7a47SHans de Goede struct acpi_video_bus *video = acpi_driver_data(device); 148314ca7a47SHans de Goede struct input_dev *input; 148414ca7a47SHans de Goede int keycode = 0; 148514ca7a47SHans de Goede 148614ca7a47SHans de Goede if (!video || !video->input) 148714ca7a47SHans de Goede return; 148814ca7a47SHans de Goede 148914ca7a47SHans de Goede input = video->input; 149014ca7a47SHans de Goede 149114ca7a47SHans de Goede switch (event) { 149214ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_SWITCH: /* User requested a switch, 149314ca7a47SHans de Goede * most likely via hotkey. */ 149414ca7a47SHans de Goede keycode = KEY_SWITCHVIDEOMODE; 149514ca7a47SHans de Goede break; 149614ca7a47SHans de Goede 149714ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_PROBE: /* User plugged in or removed a video 149814ca7a47SHans de Goede * connector. */ 149914ca7a47SHans de Goede acpi_video_device_enumerate(video); 150014ca7a47SHans de Goede acpi_video_device_rebind(video); 150114ca7a47SHans de Goede keycode = KEY_SWITCHVIDEOMODE; 150214ca7a47SHans de Goede break; 150314ca7a47SHans de Goede 150414ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_CYCLE: /* Cycle Display output hotkey pressed. */ 150514ca7a47SHans de Goede keycode = KEY_SWITCHVIDEOMODE; 150614ca7a47SHans de Goede break; 150714ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT: /* Next Display output hotkey pressed. */ 150814ca7a47SHans de Goede keycode = KEY_VIDEO_NEXT; 150914ca7a47SHans de Goede break; 151014ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_PREV_OUTPUT: /* previous Display output hotkey pressed. */ 151114ca7a47SHans de Goede keycode = KEY_VIDEO_PREV; 151214ca7a47SHans de Goede break; 151314ca7a47SHans de Goede 151414ca7a47SHans de Goede default: 151514ca7a47SHans de Goede ACPI_DEBUG_PRINT((ACPI_DB_INFO, 151614ca7a47SHans de Goede "Unsupported event [0x%x]\n", event)); 151714ca7a47SHans de Goede break; 151814ca7a47SHans de Goede } 151914ca7a47SHans de Goede 152014ca7a47SHans de Goede if (acpi_notifier_call_chain(device, event, 0)) 152114ca7a47SHans de Goede /* Something vetoed the keypress. */ 152214ca7a47SHans de Goede keycode = 0; 152314ca7a47SHans de Goede 152405bc59a0SHans de Goede if (keycode && (report_key_events & REPORT_OUTPUT_KEY_EVENTS)) { 152514ca7a47SHans de Goede input_report_key(input, keycode, 1); 152614ca7a47SHans de Goede input_sync(input); 152714ca7a47SHans de Goede input_report_key(input, keycode, 0); 152814ca7a47SHans de Goede input_sync(input); 152914ca7a47SHans de Goede } 153014ca7a47SHans de Goede 153114ca7a47SHans de Goede return; 153214ca7a47SHans de Goede } 153314ca7a47SHans de Goede 153414ca7a47SHans de Goede static void brightness_switch_event(struct acpi_video_device *video_device, 153514ca7a47SHans de Goede u32 event) 153614ca7a47SHans de Goede { 153714ca7a47SHans de Goede if (!brightness_switch_enabled) 153814ca7a47SHans de Goede return; 153914ca7a47SHans de Goede 154014ca7a47SHans de Goede video_device->switch_brightness_event = event; 154114ca7a47SHans de Goede schedule_delayed_work(&video_device->switch_brightness_work, HZ / 10); 154214ca7a47SHans de Goede } 154314ca7a47SHans de Goede 154414ca7a47SHans de Goede static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data) 154514ca7a47SHans de Goede { 154614ca7a47SHans de Goede struct acpi_video_device *video_device = data; 154714ca7a47SHans de Goede struct acpi_device *device = NULL; 154814ca7a47SHans de Goede struct acpi_video_bus *bus; 154914ca7a47SHans de Goede struct input_dev *input; 155014ca7a47SHans de Goede int keycode = 0; 155114ca7a47SHans de Goede 155214ca7a47SHans de Goede if (!video_device) 155314ca7a47SHans de Goede return; 155414ca7a47SHans de Goede 155514ca7a47SHans de Goede device = video_device->dev; 155614ca7a47SHans de Goede bus = video_device->video; 155714ca7a47SHans de Goede input = bus->input; 155814ca7a47SHans de Goede 155914ca7a47SHans de Goede switch (event) { 156014ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS: /* Cycle brightness */ 156114ca7a47SHans de Goede brightness_switch_event(video_device, event); 156214ca7a47SHans de Goede keycode = KEY_BRIGHTNESS_CYCLE; 156314ca7a47SHans de Goede break; 156414ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS: /* Increase brightness */ 156514ca7a47SHans de Goede brightness_switch_event(video_device, event); 156614ca7a47SHans de Goede keycode = KEY_BRIGHTNESSUP; 156714ca7a47SHans de Goede break; 156814ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS: /* Decrease brightness */ 156914ca7a47SHans de Goede brightness_switch_event(video_device, event); 157014ca7a47SHans de Goede keycode = KEY_BRIGHTNESSDOWN; 157114ca7a47SHans de Goede break; 157214ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: /* zero brightness */ 157314ca7a47SHans de Goede brightness_switch_event(video_device, event); 157414ca7a47SHans de Goede keycode = KEY_BRIGHTNESS_ZERO; 157514ca7a47SHans de Goede break; 157614ca7a47SHans de Goede case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: /* display device off */ 157714ca7a47SHans de Goede brightness_switch_event(video_device, event); 157814ca7a47SHans de Goede keycode = KEY_DISPLAY_OFF; 157914ca7a47SHans de Goede break; 158014ca7a47SHans de Goede default: 158114ca7a47SHans de Goede ACPI_DEBUG_PRINT((ACPI_DB_INFO, 158214ca7a47SHans de Goede "Unsupported event [0x%x]\n", event)); 158314ca7a47SHans de Goede break; 158414ca7a47SHans de Goede } 158514ca7a47SHans de Goede 158614ca7a47SHans de Goede acpi_notifier_call_chain(device, event, 0); 158714ca7a47SHans de Goede 158805bc59a0SHans de Goede if (keycode && (report_key_events & REPORT_BRIGHTNESS_KEY_EVENTS)) { 158914ca7a47SHans de Goede input_report_key(input, keycode, 1); 159014ca7a47SHans de Goede input_sync(input); 159114ca7a47SHans de Goede input_report_key(input, keycode, 0); 159214ca7a47SHans de Goede input_sync(input); 159314ca7a47SHans de Goede } 159414ca7a47SHans de Goede 159514ca7a47SHans de Goede return; 159614ca7a47SHans de Goede } 159714ca7a47SHans de Goede 159814ca7a47SHans de Goede static int acpi_video_resume(struct notifier_block *nb, 159914ca7a47SHans de Goede unsigned long val, void *ign) 160014ca7a47SHans de Goede { 160114ca7a47SHans de Goede struct acpi_video_bus *video; 160214ca7a47SHans de Goede struct acpi_video_device *video_device; 160314ca7a47SHans de Goede int i; 160414ca7a47SHans de Goede 160514ca7a47SHans de Goede switch (val) { 160614ca7a47SHans de Goede case PM_HIBERNATION_PREPARE: 160714ca7a47SHans de Goede case PM_SUSPEND_PREPARE: 160814ca7a47SHans de Goede case PM_RESTORE_PREPARE: 160914ca7a47SHans de Goede return NOTIFY_DONE; 161014ca7a47SHans de Goede } 161114ca7a47SHans de Goede 161214ca7a47SHans de Goede video = container_of(nb, struct acpi_video_bus, pm_nb); 161314ca7a47SHans de Goede 161414ca7a47SHans de Goede dev_info(&video->device->dev, "Restoring backlight state\n"); 161514ca7a47SHans de Goede 161614ca7a47SHans de Goede for (i = 0; i < video->attached_count; i++) { 161714ca7a47SHans de Goede video_device = video->attached_array[i].bind_info; 161814ca7a47SHans de Goede if (video_device && video_device->brightness) 161914ca7a47SHans de Goede acpi_video_device_lcd_set_level(video_device, 162014ca7a47SHans de Goede video_device->brightness->curr); 162114ca7a47SHans de Goede } 162214ca7a47SHans de Goede 162314ca7a47SHans de Goede return NOTIFY_OK; 162414ca7a47SHans de Goede } 162514ca7a47SHans de Goede 162614ca7a47SHans de Goede static acpi_status 162714ca7a47SHans de Goede acpi_video_bus_match(acpi_handle handle, u32 level, void *context, 162814ca7a47SHans de Goede void **return_value) 162914ca7a47SHans de Goede { 163014ca7a47SHans de Goede struct acpi_device *device = context; 163114ca7a47SHans de Goede struct acpi_device *sibling; 163214ca7a47SHans de Goede int result; 163314ca7a47SHans de Goede 163414ca7a47SHans de Goede if (handle == device->handle) 163514ca7a47SHans de Goede return AE_CTRL_TERMINATE; 163614ca7a47SHans de Goede 163714ca7a47SHans de Goede result = acpi_bus_get_device(handle, &sibling); 163814ca7a47SHans de Goede if (result) 163914ca7a47SHans de Goede return AE_OK; 164014ca7a47SHans de Goede 164114ca7a47SHans de Goede if (!strcmp(acpi_device_name(sibling), ACPI_VIDEO_BUS_NAME)) 164214ca7a47SHans de Goede return AE_ALREADY_EXISTS; 164314ca7a47SHans de Goede 164414ca7a47SHans de Goede return AE_OK; 164514ca7a47SHans de Goede } 164614ca7a47SHans de Goede 164714ca7a47SHans de Goede static void acpi_video_dev_register_backlight(struct acpi_video_device *device) 164814ca7a47SHans de Goede { 164914ca7a47SHans de Goede struct backlight_properties props; 165014ca7a47SHans de Goede struct pci_dev *pdev; 165114ca7a47SHans de Goede acpi_handle acpi_parent; 165214ca7a47SHans de Goede struct device *parent = NULL; 165314ca7a47SHans de Goede int result; 165414ca7a47SHans de Goede static int count; 165514ca7a47SHans de Goede char *name; 165614ca7a47SHans de Goede 165714ca7a47SHans de Goede result = acpi_video_init_brightness(device); 165814ca7a47SHans de Goede if (result) 165914ca7a47SHans de Goede return; 166014ca7a47SHans de Goede 166114ca7a47SHans de Goede if (disable_backlight_sysfs_if > 0) 166214ca7a47SHans de Goede return; 166314ca7a47SHans de Goede 166414ca7a47SHans de Goede name = kasprintf(GFP_KERNEL, "acpi_video%d", count); 166514ca7a47SHans de Goede if (!name) 166614ca7a47SHans de Goede return; 166714ca7a47SHans de Goede count++; 166814ca7a47SHans de Goede 166914ca7a47SHans de Goede acpi_get_parent(device->dev->handle, &acpi_parent); 167014ca7a47SHans de Goede 167114ca7a47SHans de Goede pdev = acpi_get_pci_dev(acpi_parent); 167214ca7a47SHans de Goede if (pdev) { 167314ca7a47SHans de Goede parent = &pdev->dev; 167414ca7a47SHans de Goede pci_dev_put(pdev); 167514ca7a47SHans de Goede } 167614ca7a47SHans de Goede 167714ca7a47SHans de Goede memset(&props, 0, sizeof(struct backlight_properties)); 167814ca7a47SHans de Goede props.type = BACKLIGHT_FIRMWARE; 167914ca7a47SHans de Goede props.max_brightness = device->brightness->count - 3; 168014ca7a47SHans de Goede device->backlight = backlight_device_register(name, 168114ca7a47SHans de Goede parent, 168214ca7a47SHans de Goede device, 168314ca7a47SHans de Goede &acpi_backlight_ops, 168414ca7a47SHans de Goede &props); 168514ca7a47SHans de Goede kfree(name); 168614ca7a47SHans de Goede if (IS_ERR(device->backlight)) { 168714ca7a47SHans de Goede device->backlight = NULL; 168814ca7a47SHans de Goede return; 168914ca7a47SHans de Goede } 169014ca7a47SHans de Goede 169114ca7a47SHans de Goede /* 169214ca7a47SHans de Goede * Save current brightness level in case we have to restore it 169314ca7a47SHans de Goede * before acpi_video_device_lcd_set_level() is called next time. 169414ca7a47SHans de Goede */ 169514ca7a47SHans de Goede device->backlight->props.brightness = 169614ca7a47SHans de Goede acpi_video_get_brightness(device->backlight); 169714ca7a47SHans de Goede 169814ca7a47SHans de Goede device->cooling_dev = thermal_cooling_device_register("LCD", 169914ca7a47SHans de Goede device->dev, &video_cooling_ops); 170014ca7a47SHans de Goede if (IS_ERR(device->cooling_dev)) { 170114ca7a47SHans de Goede /* 170214ca7a47SHans de Goede * Set cooling_dev to NULL so we don't crash trying to free it. 170314ca7a47SHans de Goede * Also, why the hell we are returning early and not attempt to 170414ca7a47SHans de Goede * register video output if cooling device registration failed? 170514ca7a47SHans de Goede * -- dtor 170614ca7a47SHans de Goede */ 170714ca7a47SHans de Goede device->cooling_dev = NULL; 170814ca7a47SHans de Goede return; 170914ca7a47SHans de Goede } 171014ca7a47SHans de Goede 171114ca7a47SHans de Goede dev_info(&device->dev->dev, "registered as cooling_device%d\n", 171214ca7a47SHans de Goede device->cooling_dev->id); 171314ca7a47SHans de Goede result = sysfs_create_link(&device->dev->dev.kobj, 171414ca7a47SHans de Goede &device->cooling_dev->device.kobj, 171514ca7a47SHans de Goede "thermal_cooling"); 171614ca7a47SHans de Goede if (result) 171714ca7a47SHans de Goede printk(KERN_ERR PREFIX "Create sysfs link\n"); 171814ca7a47SHans de Goede result = sysfs_create_link(&device->cooling_dev->device.kobj, 171914ca7a47SHans de Goede &device->dev->dev.kobj, "device"); 172014ca7a47SHans de Goede if (result) 172114ca7a47SHans de Goede printk(KERN_ERR PREFIX "Create sysfs link\n"); 172214ca7a47SHans de Goede } 172314ca7a47SHans de Goede 172414ca7a47SHans de Goede static void acpi_video_run_bcl_for_osi(struct acpi_video_bus *video) 172514ca7a47SHans de Goede { 172614ca7a47SHans de Goede struct acpi_video_device *dev; 172714ca7a47SHans de Goede union acpi_object *levels; 172814ca7a47SHans de Goede 172914ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 173014ca7a47SHans de Goede list_for_each_entry(dev, &video->video_device_list, entry) { 173114ca7a47SHans de Goede if (!acpi_video_device_lcd_query_levels(dev, &levels)) 173214ca7a47SHans de Goede kfree(levels); 173314ca7a47SHans de Goede } 173414ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 173514ca7a47SHans de Goede } 173614ca7a47SHans de Goede 1737e50b9be1SAaron Lu static bool acpi_video_should_register_backlight(struct acpi_video_device *dev) 1738e50b9be1SAaron Lu { 1739e50b9be1SAaron Lu /* 1740e50b9be1SAaron Lu * Do not create backlight device for video output 1741e50b9be1SAaron Lu * device that is not in the enumerated list. 1742e50b9be1SAaron Lu */ 1743e50b9be1SAaron Lu if (!acpi_video_device_in_dod(dev)) { 1744e50b9be1SAaron Lu dev_dbg(&dev->dev->dev, "not in _DOD list, ignore\n"); 1745e50b9be1SAaron Lu return false; 1746e50b9be1SAaron Lu } 1747e50b9be1SAaron Lu 1748e50b9be1SAaron Lu if (only_lcd) 1749e50b9be1SAaron Lu return dev->flags.lcd; 1750e50b9be1SAaron Lu return true; 1751e50b9be1SAaron Lu } 1752e50b9be1SAaron Lu 175314ca7a47SHans de Goede static int acpi_video_bus_register_backlight(struct acpi_video_bus *video) 175414ca7a47SHans de Goede { 175514ca7a47SHans de Goede struct acpi_video_device *dev; 175614ca7a47SHans de Goede 175714ca7a47SHans de Goede if (video->backlight_registered) 175814ca7a47SHans de Goede return 0; 175914ca7a47SHans de Goede 176014ca7a47SHans de Goede acpi_video_run_bcl_for_osi(video); 176114ca7a47SHans de Goede 17623bd6bce3SHans de Goede if (acpi_video_get_backlight_type() != acpi_backlight_video) 176314ca7a47SHans de Goede return 0; 176414ca7a47SHans de Goede 176514ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 1766e50b9be1SAaron Lu list_for_each_entry(dev, &video->video_device_list, entry) { 1767e50b9be1SAaron Lu if (acpi_video_should_register_backlight(dev)) 176814ca7a47SHans de Goede acpi_video_dev_register_backlight(dev); 1769e50b9be1SAaron Lu } 177014ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 177114ca7a47SHans de Goede 177214ca7a47SHans de Goede video->backlight_registered = true; 177314ca7a47SHans de Goede 177414ca7a47SHans de Goede video->pm_nb.notifier_call = acpi_video_resume; 177514ca7a47SHans de Goede video->pm_nb.priority = 0; 177614ca7a47SHans de Goede return register_pm_notifier(&video->pm_nb); 177714ca7a47SHans de Goede } 177814ca7a47SHans de Goede 177914ca7a47SHans de Goede static void acpi_video_dev_unregister_backlight(struct acpi_video_device *device) 178014ca7a47SHans de Goede { 178114ca7a47SHans de Goede if (device->backlight) { 178214ca7a47SHans de Goede backlight_device_unregister(device->backlight); 178314ca7a47SHans de Goede device->backlight = NULL; 178414ca7a47SHans de Goede } 178514ca7a47SHans de Goede if (device->brightness) { 178614ca7a47SHans de Goede kfree(device->brightness->levels); 178714ca7a47SHans de Goede kfree(device->brightness); 178814ca7a47SHans de Goede device->brightness = NULL; 178914ca7a47SHans de Goede } 179014ca7a47SHans de Goede if (device->cooling_dev) { 179114ca7a47SHans de Goede sysfs_remove_link(&device->dev->dev.kobj, "thermal_cooling"); 179214ca7a47SHans de Goede sysfs_remove_link(&device->cooling_dev->device.kobj, "device"); 179314ca7a47SHans de Goede thermal_cooling_device_unregister(device->cooling_dev); 179414ca7a47SHans de Goede device->cooling_dev = NULL; 179514ca7a47SHans de Goede } 179614ca7a47SHans de Goede } 179714ca7a47SHans de Goede 179814ca7a47SHans de Goede static int acpi_video_bus_unregister_backlight(struct acpi_video_bus *video) 179914ca7a47SHans de Goede { 180014ca7a47SHans de Goede struct acpi_video_device *dev; 180114ca7a47SHans de Goede int error; 180214ca7a47SHans de Goede 180314ca7a47SHans de Goede if (!video->backlight_registered) 180414ca7a47SHans de Goede return 0; 180514ca7a47SHans de Goede 180614ca7a47SHans de Goede error = unregister_pm_notifier(&video->pm_nb); 180714ca7a47SHans de Goede 180814ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 180914ca7a47SHans de Goede list_for_each_entry(dev, &video->video_device_list, entry) 181014ca7a47SHans de Goede acpi_video_dev_unregister_backlight(dev); 181114ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 181214ca7a47SHans de Goede 181314ca7a47SHans de Goede video->backlight_registered = false; 181414ca7a47SHans de Goede 181514ca7a47SHans de Goede return error; 181614ca7a47SHans de Goede } 181714ca7a47SHans de Goede 181814ca7a47SHans de Goede static void acpi_video_dev_add_notify_handler(struct acpi_video_device *device) 181914ca7a47SHans de Goede { 182014ca7a47SHans de Goede acpi_status status; 182114ca7a47SHans de Goede struct acpi_device *adev = device->dev; 182214ca7a47SHans de Goede 182314ca7a47SHans de Goede status = acpi_install_notify_handler(adev->handle, ACPI_DEVICE_NOTIFY, 182414ca7a47SHans de Goede acpi_video_device_notify, device); 182514ca7a47SHans de Goede if (ACPI_FAILURE(status)) 182614ca7a47SHans de Goede dev_err(&adev->dev, "Error installing notify handler\n"); 182714ca7a47SHans de Goede else 182814ca7a47SHans de Goede device->flags.notify = 1; 182914ca7a47SHans de Goede } 183014ca7a47SHans de Goede 183114ca7a47SHans de Goede static int acpi_video_bus_add_notify_handler(struct acpi_video_bus *video) 183214ca7a47SHans de Goede { 183314ca7a47SHans de Goede struct input_dev *input; 183414ca7a47SHans de Goede struct acpi_video_device *dev; 183514ca7a47SHans de Goede int error; 183614ca7a47SHans de Goede 183714ca7a47SHans de Goede video->input = input = input_allocate_device(); 183814ca7a47SHans de Goede if (!input) { 183914ca7a47SHans de Goede error = -ENOMEM; 184014ca7a47SHans de Goede goto out; 184114ca7a47SHans de Goede } 184214ca7a47SHans de Goede 184314ca7a47SHans de Goede error = acpi_video_bus_start_devices(video); 184414ca7a47SHans de Goede if (error) 184514ca7a47SHans de Goede goto err_free_input; 184614ca7a47SHans de Goede 184714ca7a47SHans de Goede snprintf(video->phys, sizeof(video->phys), 184814ca7a47SHans de Goede "%s/video/input0", acpi_device_hid(video->device)); 184914ca7a47SHans de Goede 185014ca7a47SHans de Goede input->name = acpi_device_name(video->device); 185114ca7a47SHans de Goede input->phys = video->phys; 185214ca7a47SHans de Goede input->id.bustype = BUS_HOST; 185314ca7a47SHans de Goede input->id.product = 0x06; 185414ca7a47SHans de Goede input->dev.parent = &video->device->dev; 185514ca7a47SHans de Goede input->evbit[0] = BIT(EV_KEY); 185614ca7a47SHans de Goede set_bit(KEY_SWITCHVIDEOMODE, input->keybit); 185714ca7a47SHans de Goede set_bit(KEY_VIDEO_NEXT, input->keybit); 185814ca7a47SHans de Goede set_bit(KEY_VIDEO_PREV, input->keybit); 185914ca7a47SHans de Goede set_bit(KEY_BRIGHTNESS_CYCLE, input->keybit); 186014ca7a47SHans de Goede set_bit(KEY_BRIGHTNESSUP, input->keybit); 186114ca7a47SHans de Goede set_bit(KEY_BRIGHTNESSDOWN, input->keybit); 186214ca7a47SHans de Goede set_bit(KEY_BRIGHTNESS_ZERO, input->keybit); 186314ca7a47SHans de Goede set_bit(KEY_DISPLAY_OFF, input->keybit); 186414ca7a47SHans de Goede 186514ca7a47SHans de Goede error = input_register_device(input); 186614ca7a47SHans de Goede if (error) 186714ca7a47SHans de Goede goto err_stop_dev; 186814ca7a47SHans de Goede 186914ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 187014ca7a47SHans de Goede list_for_each_entry(dev, &video->video_device_list, entry) 187114ca7a47SHans de Goede acpi_video_dev_add_notify_handler(dev); 187214ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 187314ca7a47SHans de Goede 187414ca7a47SHans de Goede return 0; 187514ca7a47SHans de Goede 187614ca7a47SHans de Goede err_stop_dev: 187714ca7a47SHans de Goede acpi_video_bus_stop_devices(video); 187814ca7a47SHans de Goede err_free_input: 187914ca7a47SHans de Goede input_free_device(input); 188014ca7a47SHans de Goede video->input = NULL; 188114ca7a47SHans de Goede out: 188214ca7a47SHans de Goede return error; 188314ca7a47SHans de Goede } 188414ca7a47SHans de Goede 188514ca7a47SHans de Goede static void acpi_video_dev_remove_notify_handler(struct acpi_video_device *dev) 188614ca7a47SHans de Goede { 188714ca7a47SHans de Goede if (dev->flags.notify) { 188814ca7a47SHans de Goede acpi_remove_notify_handler(dev->dev->handle, ACPI_DEVICE_NOTIFY, 188914ca7a47SHans de Goede acpi_video_device_notify); 189014ca7a47SHans de Goede dev->flags.notify = 0; 189114ca7a47SHans de Goede } 189214ca7a47SHans de Goede } 189314ca7a47SHans de Goede 189414ca7a47SHans de Goede static void acpi_video_bus_remove_notify_handler(struct acpi_video_bus *video) 189514ca7a47SHans de Goede { 189614ca7a47SHans de Goede struct acpi_video_device *dev; 189714ca7a47SHans de Goede 189814ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 189914ca7a47SHans de Goede list_for_each_entry(dev, &video->video_device_list, entry) 190014ca7a47SHans de Goede acpi_video_dev_remove_notify_handler(dev); 190114ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 190214ca7a47SHans de Goede 190314ca7a47SHans de Goede acpi_video_bus_stop_devices(video); 190414ca7a47SHans de Goede input_unregister_device(video->input); 190514ca7a47SHans de Goede video->input = NULL; 190614ca7a47SHans de Goede } 190714ca7a47SHans de Goede 190814ca7a47SHans de Goede static int acpi_video_bus_put_devices(struct acpi_video_bus *video) 190914ca7a47SHans de Goede { 191014ca7a47SHans de Goede struct acpi_video_device *dev, *next; 191114ca7a47SHans de Goede 191214ca7a47SHans de Goede mutex_lock(&video->device_list_lock); 191314ca7a47SHans de Goede list_for_each_entry_safe(dev, next, &video->video_device_list, entry) { 191414ca7a47SHans de Goede list_del(&dev->entry); 191514ca7a47SHans de Goede kfree(dev); 191614ca7a47SHans de Goede } 191714ca7a47SHans de Goede mutex_unlock(&video->device_list_lock); 191814ca7a47SHans de Goede 191914ca7a47SHans de Goede return 0; 192014ca7a47SHans de Goede } 192114ca7a47SHans de Goede 192214ca7a47SHans de Goede static int instance; 192314ca7a47SHans de Goede 192414ca7a47SHans de Goede static int acpi_video_bus_add(struct acpi_device *device) 192514ca7a47SHans de Goede { 192614ca7a47SHans de Goede struct acpi_video_bus *video; 192714ca7a47SHans de Goede int error; 192814ca7a47SHans de Goede acpi_status status; 192914ca7a47SHans de Goede 193014ca7a47SHans de Goede status = acpi_walk_namespace(ACPI_TYPE_DEVICE, 193114ca7a47SHans de Goede device->parent->handle, 1, 193214ca7a47SHans de Goede acpi_video_bus_match, NULL, 193314ca7a47SHans de Goede device, NULL); 193414ca7a47SHans de Goede if (status == AE_ALREADY_EXISTS) { 193514ca7a47SHans de Goede printk(KERN_WARNING FW_BUG 193614ca7a47SHans de Goede "Duplicate ACPI video bus devices for the" 193714ca7a47SHans de Goede " same VGA controller, please try module " 193814ca7a47SHans de Goede "parameter \"video.allow_duplicates=1\"" 193914ca7a47SHans de Goede "if the current driver doesn't work.\n"); 194014ca7a47SHans de Goede if (!allow_duplicates) 194114ca7a47SHans de Goede return -ENODEV; 194214ca7a47SHans de Goede } 194314ca7a47SHans de Goede 194414ca7a47SHans de Goede video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL); 194514ca7a47SHans de Goede if (!video) 194614ca7a47SHans de Goede return -ENOMEM; 194714ca7a47SHans de Goede 194814ca7a47SHans de Goede /* a hack to fix the duplicate name "VID" problem on T61 */ 194914ca7a47SHans de Goede if (!strcmp(device->pnp.bus_id, "VID")) { 195014ca7a47SHans de Goede if (instance) 195114ca7a47SHans de Goede device->pnp.bus_id[3] = '0' + instance; 195214ca7a47SHans de Goede instance++; 195314ca7a47SHans de Goede } 195414ca7a47SHans de Goede /* a hack to fix the duplicate name "VGA" problem on Pa 3553 */ 195514ca7a47SHans de Goede if (!strcmp(device->pnp.bus_id, "VGA")) { 195614ca7a47SHans de Goede if (instance) 195714ca7a47SHans de Goede device->pnp.bus_id[3] = '0' + instance; 195814ca7a47SHans de Goede instance++; 195914ca7a47SHans de Goede } 196014ca7a47SHans de Goede 196114ca7a47SHans de Goede video->device = device; 196214ca7a47SHans de Goede strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME); 196314ca7a47SHans de Goede strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS); 196414ca7a47SHans de Goede device->driver_data = video; 196514ca7a47SHans de Goede 196614ca7a47SHans de Goede acpi_video_bus_find_cap(video); 196714ca7a47SHans de Goede error = acpi_video_bus_check(video); 196814ca7a47SHans de Goede if (error) 196914ca7a47SHans de Goede goto err_free_video; 197014ca7a47SHans de Goede 197114ca7a47SHans de Goede mutex_init(&video->device_list_lock); 197214ca7a47SHans de Goede INIT_LIST_HEAD(&video->video_device_list); 197314ca7a47SHans de Goede 197414ca7a47SHans de Goede error = acpi_video_bus_get_devices(video, device); 197514ca7a47SHans de Goede if (error) 197614ca7a47SHans de Goede goto err_put_video; 197714ca7a47SHans de Goede 197814ca7a47SHans de Goede printk(KERN_INFO PREFIX "%s [%s] (multi-head: %s rom: %s post: %s)\n", 197914ca7a47SHans de Goede ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device), 198014ca7a47SHans de Goede video->flags.multihead ? "yes" : "no", 198114ca7a47SHans de Goede video->flags.rom ? "yes" : "no", 198214ca7a47SHans de Goede video->flags.post ? "yes" : "no"); 198314ca7a47SHans de Goede mutex_lock(&video_list_lock); 198414ca7a47SHans de Goede list_add_tail(&video->entry, &video_bus_head); 198514ca7a47SHans de Goede mutex_unlock(&video_list_lock); 198614ca7a47SHans de Goede 198714ca7a47SHans de Goede acpi_video_bus_register_backlight(video); 198814ca7a47SHans de Goede acpi_video_bus_add_notify_handler(video); 198914ca7a47SHans de Goede 199014ca7a47SHans de Goede return 0; 199114ca7a47SHans de Goede 199214ca7a47SHans de Goede err_put_video: 199314ca7a47SHans de Goede acpi_video_bus_put_devices(video); 199414ca7a47SHans de Goede kfree(video->attached_array); 199514ca7a47SHans de Goede err_free_video: 199614ca7a47SHans de Goede kfree(video); 199714ca7a47SHans de Goede device->driver_data = NULL; 199814ca7a47SHans de Goede 199914ca7a47SHans de Goede return error; 200014ca7a47SHans de Goede } 200114ca7a47SHans de Goede 200214ca7a47SHans de Goede static int acpi_video_bus_remove(struct acpi_device *device) 200314ca7a47SHans de Goede { 200414ca7a47SHans de Goede struct acpi_video_bus *video = NULL; 200514ca7a47SHans de Goede 200614ca7a47SHans de Goede 200714ca7a47SHans de Goede if (!device || !acpi_driver_data(device)) 200814ca7a47SHans de Goede return -EINVAL; 200914ca7a47SHans de Goede 201014ca7a47SHans de Goede video = acpi_driver_data(device); 201114ca7a47SHans de Goede 201214ca7a47SHans de Goede acpi_video_bus_remove_notify_handler(video); 201314ca7a47SHans de Goede acpi_video_bus_unregister_backlight(video); 201414ca7a47SHans de Goede acpi_video_bus_put_devices(video); 201514ca7a47SHans de Goede 201614ca7a47SHans de Goede mutex_lock(&video_list_lock); 201714ca7a47SHans de Goede list_del(&video->entry); 201814ca7a47SHans de Goede mutex_unlock(&video_list_lock); 201914ca7a47SHans de Goede 202014ca7a47SHans de Goede kfree(video->attached_array); 202114ca7a47SHans de Goede kfree(video); 202214ca7a47SHans de Goede 202314ca7a47SHans de Goede return 0; 202414ca7a47SHans de Goede } 202514ca7a47SHans de Goede 202614ca7a47SHans de Goede static int __init is_i740(struct pci_dev *dev) 202714ca7a47SHans de Goede { 202814ca7a47SHans de Goede if (dev->device == 0x00D1) 202914ca7a47SHans de Goede return 1; 203014ca7a47SHans de Goede if (dev->device == 0x7000) 203114ca7a47SHans de Goede return 1; 203214ca7a47SHans de Goede return 0; 203314ca7a47SHans de Goede } 203414ca7a47SHans de Goede 203514ca7a47SHans de Goede static int __init intel_opregion_present(void) 203614ca7a47SHans de Goede { 203714ca7a47SHans de Goede int opregion = 0; 203814ca7a47SHans de Goede struct pci_dev *dev = NULL; 203914ca7a47SHans de Goede u32 address; 204014ca7a47SHans de Goede 204114ca7a47SHans de Goede for_each_pci_dev(dev) { 204214ca7a47SHans de Goede if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA) 204314ca7a47SHans de Goede continue; 204414ca7a47SHans de Goede if (dev->vendor != PCI_VENDOR_ID_INTEL) 204514ca7a47SHans de Goede continue; 204614ca7a47SHans de Goede /* We don't want to poke around undefined i740 registers */ 204714ca7a47SHans de Goede if (is_i740(dev)) 204814ca7a47SHans de Goede continue; 204914ca7a47SHans de Goede pci_read_config_dword(dev, 0xfc, &address); 205014ca7a47SHans de Goede if (!address) 205114ca7a47SHans de Goede continue; 205214ca7a47SHans de Goede opregion = 1; 205314ca7a47SHans de Goede } 205414ca7a47SHans de Goede return opregion; 205514ca7a47SHans de Goede } 205614ca7a47SHans de Goede 205714ca7a47SHans de Goede int acpi_video_register(void) 205814ca7a47SHans de Goede { 20592a8b18e9SHans de Goede int ret = 0; 206014ca7a47SHans de Goede 2061aecbd9b1SAdrien Schildknecht mutex_lock(®ister_done_mutex); 2062aecbd9b1SAdrien Schildknecht if (completion_done(®ister_done)) { 206314ca7a47SHans de Goede /* 206414ca7a47SHans de Goede * if the function of acpi_video_register is already called, 206514ca7a47SHans de Goede * don't register the acpi_vide_bus again and return no error. 206614ca7a47SHans de Goede */ 20672a8b18e9SHans de Goede goto leave; 206814ca7a47SHans de Goede } 206914ca7a47SHans de Goede 207014ca7a47SHans de Goede mutex_init(&video_list_lock); 207114ca7a47SHans de Goede INIT_LIST_HEAD(&video_bus_head); 207214ca7a47SHans de Goede 20737ee33baaSHans de Goede dmi_check_system(video_dmi_table); 20747ee33baaSHans de Goede 207514ca7a47SHans de Goede ret = acpi_bus_register_driver(&acpi_video_bus); 207614ca7a47SHans de Goede if (ret) 20772a8b18e9SHans de Goede goto leave; 207814ca7a47SHans de Goede 207914ca7a47SHans de Goede /* 208014ca7a47SHans de Goede * When the acpi_video_bus is loaded successfully, increase 208114ca7a47SHans de Goede * the counter reference. 208214ca7a47SHans de Goede */ 2083aecbd9b1SAdrien Schildknecht complete(®ister_done); 208414ca7a47SHans de Goede 20852a8b18e9SHans de Goede leave: 2086aecbd9b1SAdrien Schildknecht mutex_unlock(®ister_done_mutex); 20872a8b18e9SHans de Goede return ret; 208814ca7a47SHans de Goede } 208914ca7a47SHans de Goede EXPORT_SYMBOL(acpi_video_register); 209014ca7a47SHans de Goede 209114ca7a47SHans de Goede void acpi_video_unregister(void) 209214ca7a47SHans de Goede { 2093aecbd9b1SAdrien Schildknecht mutex_lock(®ister_done_mutex); 2094aecbd9b1SAdrien Schildknecht if (completion_done(®ister_done)) { 209514ca7a47SHans de Goede acpi_bus_unregister_driver(&acpi_video_bus); 2096aecbd9b1SAdrien Schildknecht reinit_completion(®ister_done); 20972a8b18e9SHans de Goede } 2098aecbd9b1SAdrien Schildknecht mutex_unlock(®ister_done_mutex); 209914ca7a47SHans de Goede } 210014ca7a47SHans de Goede EXPORT_SYMBOL(acpi_video_unregister); 210114ca7a47SHans de Goede 210214ca7a47SHans de Goede void acpi_video_unregister_backlight(void) 210314ca7a47SHans de Goede { 210414ca7a47SHans de Goede struct acpi_video_bus *video; 210514ca7a47SHans de Goede 2106aecbd9b1SAdrien Schildknecht mutex_lock(®ister_done_mutex); 2107aecbd9b1SAdrien Schildknecht if (completion_done(®ister_done)) { 210814ca7a47SHans de Goede mutex_lock(&video_list_lock); 210914ca7a47SHans de Goede list_for_each_entry(video, &video_bus_head, entry) 211014ca7a47SHans de Goede acpi_video_bus_unregister_backlight(video); 211114ca7a47SHans de Goede mutex_unlock(&video_list_lock); 211214ca7a47SHans de Goede } 2113aecbd9b1SAdrien Schildknecht mutex_unlock(®ister_done_mutex); 21142a8b18e9SHans de Goede } 211514ca7a47SHans de Goede 211690b066b1SHans de Goede bool acpi_video_handles_brightness_key_presses(void) 211790b066b1SHans de Goede { 211890b066b1SHans de Goede bool have_video_busses; 211990b066b1SHans de Goede 2120aecbd9b1SAdrien Schildknecht wait_for_completion(®ister_done); 212190b066b1SHans de Goede mutex_lock(&video_list_lock); 212290b066b1SHans de Goede have_video_busses = !list_empty(&video_bus_head); 212390b066b1SHans de Goede mutex_unlock(&video_list_lock); 212490b066b1SHans de Goede 212505bc59a0SHans de Goede return have_video_busses && 212605bc59a0SHans de Goede (report_key_events & REPORT_BRIGHTNESS_KEY_EVENTS); 212790b066b1SHans de Goede } 212890b066b1SHans de Goede EXPORT_SYMBOL(acpi_video_handles_brightness_key_presses); 212990b066b1SHans de Goede 213014ca7a47SHans de Goede /* 213114ca7a47SHans de Goede * This is kind of nasty. Hardware using Intel chipsets may require 213214ca7a47SHans de Goede * the video opregion code to be run first in order to initialise 213314ca7a47SHans de Goede * state before any ACPI video calls are made. To handle this we defer 213414ca7a47SHans de Goede * registration of the video class until the opregion code has run. 213514ca7a47SHans de Goede */ 213614ca7a47SHans de Goede 213714ca7a47SHans de Goede static int __init acpi_video_init(void) 213814ca7a47SHans de Goede { 213914ca7a47SHans de Goede /* 214014ca7a47SHans de Goede * Let the module load even if ACPI is disabled (e.g. due to 214114ca7a47SHans de Goede * a broken BIOS) so that i915.ko can still be loaded on such 214214ca7a47SHans de Goede * old systems without an AcpiOpRegion. 214314ca7a47SHans de Goede * 214414ca7a47SHans de Goede * acpi_video_register() will report -ENODEV later as well due 214514ca7a47SHans de Goede * to acpi_disabled when i915.ko tries to register itself afterwards. 214614ca7a47SHans de Goede */ 214714ca7a47SHans de Goede if (acpi_disabled) 214814ca7a47SHans de Goede return 0; 214914ca7a47SHans de Goede 215014ca7a47SHans de Goede if (intel_opregion_present()) 215114ca7a47SHans de Goede return 0; 215214ca7a47SHans de Goede 215314ca7a47SHans de Goede return acpi_video_register(); 215414ca7a47SHans de Goede } 215514ca7a47SHans de Goede 215614ca7a47SHans de Goede static void __exit acpi_video_exit(void) 215714ca7a47SHans de Goede { 215893a291dfSHans de Goede acpi_video_detect_exit(); 215914ca7a47SHans de Goede acpi_video_unregister(); 216014ca7a47SHans de Goede 216114ca7a47SHans de Goede return; 216214ca7a47SHans de Goede } 216314ca7a47SHans de Goede 216414ca7a47SHans de Goede module_init(acpi_video_init); 216514ca7a47SHans de Goede module_exit(acpi_video_exit); 2166