Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  video.c - ACPI Video Driver
0004  *
0005  *  Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
0006  *  Copyright (C) 2004 Bruno Ducrot <ducrot@poupinou.org>
0007  *  Copyright (C) 2006 Thomas Tuttle <linux-kernel@ttuttle.net>
0008  */
0009 
0010 #define pr_fmt(fmt) "ACPI: video: " fmt
0011 
0012 #include <linux/kernel.h>
0013 #include <linux/module.h>
0014 #include <linux/init.h>
0015 #include <linux/types.h>
0016 #include <linux/list.h>
0017 #include <linux/mutex.h>
0018 #include <linux/input.h>
0019 #include <linux/backlight.h>
0020 #include <linux/thermal.h>
0021 #include <linux/sort.h>
0022 #include <linux/pci.h>
0023 #include <linux/pci_ids.h>
0024 #include <linux/slab.h>
0025 #include <linux/dmi.h>
0026 #include <linux/suspend.h>
0027 #include <linux/acpi.h>
0028 #include <acpi/video.h>
0029 #include <linux/uaccess.h>
0030 
0031 #define ACPI_VIDEO_BUS_NAME     "Video Bus"
0032 #define ACPI_VIDEO_DEVICE_NAME      "Video Device"
0033 
0034 #define MAX_NAME_LEN    20
0035 
0036 MODULE_AUTHOR("Bruno Ducrot");
0037 MODULE_DESCRIPTION("ACPI Video Driver");
0038 MODULE_LICENSE("GPL");
0039 
0040 static bool brightness_switch_enabled = true;
0041 module_param(brightness_switch_enabled, bool, 0644);
0042 
0043 /*
0044  * By default, we don't allow duplicate ACPI video bus devices
0045  * under the same VGA controller
0046  */
0047 static bool allow_duplicates;
0048 module_param(allow_duplicates, bool, 0644);
0049 
0050 static int disable_backlight_sysfs_if = -1;
0051 module_param(disable_backlight_sysfs_if, int, 0444);
0052 
0053 #define REPORT_OUTPUT_KEY_EVENTS        0x01
0054 #define REPORT_BRIGHTNESS_KEY_EVENTS        0x02
0055 static int report_key_events = -1;
0056 module_param(report_key_events, int, 0644);
0057 MODULE_PARM_DESC(report_key_events,
0058     "0: none, 1: output changes, 2: brightness changes, 3: all");
0059 
0060 static int hw_changes_brightness = -1;
0061 module_param(hw_changes_brightness, int, 0644);
0062 MODULE_PARM_DESC(hw_changes_brightness,
0063     "Set this to 1 on buggy hw which changes the brightness itself when "
0064     "a hotkey is pressed: -1: auto, 0: normal 1: hw-changes-brightness");
0065 
0066 /*
0067  * Whether the struct acpi_video_device_attrib::device_id_scheme bit should be
0068  * assumed even if not actually set.
0069  */
0070 static bool device_id_scheme = false;
0071 module_param(device_id_scheme, bool, 0444);
0072 
0073 static int only_lcd = -1;
0074 module_param(only_lcd, int, 0444);
0075 
0076 static bool may_report_brightness_keys;
0077 static int register_count;
0078 static DEFINE_MUTEX(register_count_mutex);
0079 static DEFINE_MUTEX(video_list_lock);
0080 static LIST_HEAD(video_bus_head);
0081 static int acpi_video_bus_add(struct acpi_device *device);
0082 static int acpi_video_bus_remove(struct acpi_device *device);
0083 static void acpi_video_bus_notify(struct acpi_device *device, u32 event);
0084 void acpi_video_detect_exit(void);
0085 
0086 /*
0087  * Indices in the _BCL method response: the first two items are special,
0088  * the rest are all supported levels.
0089  *
0090  * See page 575 of the ACPI spec 3.0
0091  */
0092 enum acpi_video_level_idx {
0093     ACPI_VIDEO_AC_LEVEL,        /* level when machine has full power */
0094     ACPI_VIDEO_BATTERY_LEVEL,   /* level when machine is on batteries */
0095     ACPI_VIDEO_FIRST_LEVEL,     /* actual supported levels begin here */
0096 };
0097 
0098 static const struct acpi_device_id video_device_ids[] = {
0099     {ACPI_VIDEO_HID, 0},
0100     {"", 0},
0101 };
0102 MODULE_DEVICE_TABLE(acpi, video_device_ids);
0103 
0104 static struct acpi_driver acpi_video_bus = {
0105     .name = "video",
0106     .class = ACPI_VIDEO_CLASS,
0107     .ids = video_device_ids,
0108     .ops = {
0109         .add = acpi_video_bus_add,
0110         .remove = acpi_video_bus_remove,
0111         .notify = acpi_video_bus_notify,
0112         },
0113 };
0114 
0115 struct acpi_video_bus_flags {
0116     u8 multihead:1;     /* can switch video heads */
0117     u8 rom:1;       /* can retrieve a video rom */
0118     u8 post:1;      /* can configure the head to */
0119     u8 reserved:5;
0120 };
0121 
0122 struct acpi_video_bus_cap {
0123     u8 _DOS:1;      /* Enable/Disable output switching */
0124     u8 _DOD:1;      /* Enumerate all devices attached to display adapter */
0125     u8 _ROM:1;      /* Get ROM Data */
0126     u8 _GPD:1;      /* Get POST Device */
0127     u8 _SPD:1;      /* Set POST Device */
0128     u8 _VPO:1;      /* Video POST Options */
0129     u8 reserved:2;
0130 };
0131 
0132 struct acpi_video_device_attrib {
0133     u32 display_index:4;    /* A zero-based instance of the Display */
0134     u32 display_port_attachment:4;  /* This field differentiates the display type */
0135     u32 display_type:4; /* Describe the specific type in use */
0136     u32 vendor_specific:4;  /* Chipset Vendor Specific */
0137     u32 bios_can_detect:1;  /* BIOS can detect the device */
0138     u32 depend_on_vga:1;    /* Non-VGA output device whose power is related to
0139                    the VGA device. */
0140     u32 pipe_id:3;      /* For VGA multiple-head devices. */
0141     u32 reserved:10;    /* Must be 0 */
0142 
0143     /*
0144      * The device ID might not actually follow the scheme described by this
0145      * struct acpi_video_device_attrib. If it does, then this bit
0146      * device_id_scheme is set; otherwise, other fields should be ignored.
0147      *
0148      * (but also see the global flag device_id_scheme)
0149      */
0150     u32 device_id_scheme:1;
0151 };
0152 
0153 struct acpi_video_enumerated_device {
0154     union {
0155         u32 int_val;
0156         struct acpi_video_device_attrib attrib;
0157     } value;
0158     struct acpi_video_device *bind_info;
0159 };
0160 
0161 struct acpi_video_bus {
0162     struct acpi_device *device;
0163     bool backlight_registered;
0164     u8 dos_setting;
0165     struct acpi_video_enumerated_device *attached_array;
0166     u8 attached_count;
0167     u8 child_count;
0168     struct acpi_video_bus_cap cap;
0169     struct acpi_video_bus_flags flags;
0170     struct list_head video_device_list;
0171     struct mutex device_list_lock;  /* protects video_device_list */
0172     struct list_head entry;
0173     struct input_dev *input;
0174     char phys[32];  /* for input device */
0175     struct notifier_block pm_nb;
0176 };
0177 
0178 struct acpi_video_device_flags {
0179     u8 crt:1;
0180     u8 lcd:1;
0181     u8 tvout:1;
0182     u8 dvi:1;
0183     u8 bios:1;
0184     u8 unknown:1;
0185     u8 notify:1;
0186     u8 reserved:1;
0187 };
0188 
0189 struct acpi_video_device_cap {
0190     u8 _ADR:1;      /* Return the unique ID */
0191     u8 _BCL:1;      /* Query list of brightness control levels supported */
0192     u8 _BCM:1;      /* Set the brightness level */
0193     u8 _BQC:1;      /* Get current brightness level */
0194     u8 _BCQ:1;      /* Some buggy BIOS uses _BCQ instead of _BQC */
0195     u8 _DDC:1;      /* Return the EDID for this device */
0196 };
0197 
0198 struct acpi_video_device {
0199     unsigned long device_id;
0200     struct acpi_video_device_flags flags;
0201     struct acpi_video_device_cap cap;
0202     struct list_head entry;
0203     struct delayed_work switch_brightness_work;
0204     int switch_brightness_event;
0205     struct acpi_video_bus *video;
0206     struct acpi_device *dev;
0207     struct acpi_video_device_brightness *brightness;
0208     struct backlight_device *backlight;
0209     struct thermal_cooling_device *cooling_dev;
0210 };
0211 
0212 static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data);
0213 static void acpi_video_device_rebind(struct acpi_video_bus *video);
0214 static void acpi_video_device_bind(struct acpi_video_bus *video,
0215                    struct acpi_video_device *device);
0216 static int acpi_video_device_enumerate(struct acpi_video_bus *video);
0217 static int acpi_video_device_lcd_set_level(struct acpi_video_device *device,
0218             int level);
0219 static int acpi_video_device_lcd_get_level_current(
0220             struct acpi_video_device *device,
0221             unsigned long long *level, bool raw);
0222 static int acpi_video_get_next_level(struct acpi_video_device *device,
0223                      u32 level_current, u32 event);
0224 static void acpi_video_switch_brightness(struct work_struct *work);
0225 
0226 /* backlight device sysfs support */
0227 static int acpi_video_get_brightness(struct backlight_device *bd)
0228 {
0229     unsigned long long cur_level;
0230     int i;
0231     struct acpi_video_device *vd = bl_get_data(bd);
0232 
0233     if (acpi_video_device_lcd_get_level_current(vd, &cur_level, false))
0234         return -EINVAL;
0235     for (i = ACPI_VIDEO_FIRST_LEVEL; i < vd->brightness->count; i++) {
0236         if (vd->brightness->levels[i] == cur_level)
0237             return i - ACPI_VIDEO_FIRST_LEVEL;
0238     }
0239     return 0;
0240 }
0241 
0242 static int acpi_video_set_brightness(struct backlight_device *bd)
0243 {
0244     int request_level = bd->props.brightness + ACPI_VIDEO_FIRST_LEVEL;
0245     struct acpi_video_device *vd = bl_get_data(bd);
0246 
0247     cancel_delayed_work(&vd->switch_brightness_work);
0248     return acpi_video_device_lcd_set_level(vd,
0249                 vd->brightness->levels[request_level]);
0250 }
0251 
0252 static const struct backlight_ops acpi_backlight_ops = {
0253     .get_brightness = acpi_video_get_brightness,
0254     .update_status  = acpi_video_set_brightness,
0255 };
0256 
0257 /* thermal cooling device callbacks */
0258 static int video_get_max_state(struct thermal_cooling_device *cooling_dev,
0259                    unsigned long *state)
0260 {
0261     struct acpi_device *device = cooling_dev->devdata;
0262     struct acpi_video_device *video = acpi_driver_data(device);
0263 
0264     *state = video->brightness->count - ACPI_VIDEO_FIRST_LEVEL - 1;
0265     return 0;
0266 }
0267 
0268 static int video_get_cur_state(struct thermal_cooling_device *cooling_dev,
0269                    unsigned long *state)
0270 {
0271     struct acpi_device *device = cooling_dev->devdata;
0272     struct acpi_video_device *video = acpi_driver_data(device);
0273     unsigned long long level;
0274     int offset;
0275 
0276     if (acpi_video_device_lcd_get_level_current(video, &level, false))
0277         return -EINVAL;
0278     for (offset = ACPI_VIDEO_FIRST_LEVEL; offset < video->brightness->count;
0279          offset++)
0280         if (level == video->brightness->levels[offset]) {
0281             *state = video->brightness->count - offset - 1;
0282             return 0;
0283         }
0284 
0285     return -EINVAL;
0286 }
0287 
0288 static int
0289 video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long state)
0290 {
0291     struct acpi_device *device = cooling_dev->devdata;
0292     struct acpi_video_device *video = acpi_driver_data(device);
0293     int level;
0294 
0295     if (state >= video->brightness->count - ACPI_VIDEO_FIRST_LEVEL)
0296         return -EINVAL;
0297 
0298     state = video->brightness->count - state;
0299     level = video->brightness->levels[state - 1];
0300     return acpi_video_device_lcd_set_level(video, level);
0301 }
0302 
0303 static const struct thermal_cooling_device_ops video_cooling_ops = {
0304     .get_max_state = video_get_max_state,
0305     .get_cur_state = video_get_cur_state,
0306     .set_cur_state = video_set_cur_state,
0307 };
0308 
0309 /*
0310  * --------------------------------------------------------------------------
0311  *                             Video Management
0312  * --------------------------------------------------------------------------
0313  */
0314 
0315 static int
0316 acpi_video_device_lcd_query_levels(acpi_handle handle,
0317                    union acpi_object **levels)
0318 {
0319     int status;
0320     struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
0321     union acpi_object *obj;
0322 
0323 
0324     *levels = NULL;
0325 
0326     status = acpi_evaluate_object(handle, "_BCL", NULL, &buffer);
0327     if (ACPI_FAILURE(status))
0328         return status;
0329     obj = (union acpi_object *)buffer.pointer;
0330     if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
0331         acpi_handle_info(handle, "Invalid _BCL data\n");
0332         status = -EFAULT;
0333         goto err;
0334     }
0335 
0336     *levels = obj;
0337 
0338     return 0;
0339 
0340 err:
0341     kfree(buffer.pointer);
0342 
0343     return status;
0344 }
0345 
0346 static int
0347 acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level)
0348 {
0349     int status;
0350     int state;
0351 
0352     status = acpi_execute_simple_method(device->dev->handle,
0353                         "_BCM", level);
0354     if (ACPI_FAILURE(status)) {
0355         acpi_handle_info(device->dev->handle, "_BCM evaluation failed\n");
0356         return -EIO;
0357     }
0358 
0359     device->brightness->curr = level;
0360     for (state = ACPI_VIDEO_FIRST_LEVEL; state < device->brightness->count;
0361          state++)
0362         if (level == device->brightness->levels[state]) {
0363             if (device->backlight)
0364                 device->backlight->props.brightness =
0365                     state - ACPI_VIDEO_FIRST_LEVEL;
0366             return 0;
0367         }
0368 
0369     acpi_handle_info(device->dev->handle, "Current brightness invalid\n");
0370     return -EINVAL;
0371 }
0372 
0373 /*
0374  * For some buggy _BQC methods, we need to add a constant value to
0375  * the _BQC return value to get the actual current brightness level
0376  */
0377 
0378 static int bqc_offset_aml_bug_workaround;
0379 static int video_set_bqc_offset(const struct dmi_system_id *d)
0380 {
0381     bqc_offset_aml_bug_workaround = 9;
0382     return 0;
0383 }
0384 
0385 static int video_disable_backlight_sysfs_if(
0386     const struct dmi_system_id *d)
0387 {
0388     if (disable_backlight_sysfs_if == -1)
0389         disable_backlight_sysfs_if = 1;
0390     return 0;
0391 }
0392 
0393 static int video_set_device_id_scheme(const struct dmi_system_id *d)
0394 {
0395     device_id_scheme = true;
0396     return 0;
0397 }
0398 
0399 static int video_enable_only_lcd(const struct dmi_system_id *d)
0400 {
0401     only_lcd = true;
0402     return 0;
0403 }
0404 
0405 static int video_set_report_key_events(const struct dmi_system_id *id)
0406 {
0407     if (report_key_events == -1)
0408         report_key_events = (uintptr_t)id->driver_data;
0409     return 0;
0410 }
0411 
0412 static int video_hw_changes_brightness(
0413     const struct dmi_system_id *d)
0414 {
0415     if (hw_changes_brightness == -1)
0416         hw_changes_brightness = 1;
0417     return 0;
0418 }
0419 
0420 static const struct dmi_system_id video_dmi_table[] = {
0421     /*
0422      * Broken _BQC workaround http://bugzilla.kernel.org/show_bug.cgi?id=13121
0423      */
0424     {
0425      .callback = video_set_bqc_offset,
0426      .ident = "Acer Aspire 5720",
0427      .matches = {
0428         DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
0429         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5720"),
0430         },
0431     },
0432     {
0433      .callback = video_set_bqc_offset,
0434      .ident = "Acer Aspire 5710Z",
0435      .matches = {
0436         DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
0437         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5710Z"),
0438         },
0439     },
0440     {
0441      .callback = video_set_bqc_offset,
0442      .ident = "eMachines E510",
0443      .matches = {
0444         DMI_MATCH(DMI_BOARD_VENDOR, "EMACHINES"),
0445         DMI_MATCH(DMI_PRODUCT_NAME, "eMachines E510"),
0446         },
0447     },
0448     {
0449      .callback = video_set_bqc_offset,
0450      .ident = "Acer Aspire 5315",
0451      .matches = {
0452         DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
0453         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5315"),
0454         },
0455     },
0456     {
0457      .callback = video_set_bqc_offset,
0458      .ident = "Acer Aspire 7720",
0459      .matches = {
0460         DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
0461         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 7720"),
0462         },
0463     },
0464 
0465     /*
0466      * Some machines have a broken acpi-video interface for brightness
0467      * control, but still need an acpi_video_device_lcd_set_level() call
0468      * on resume to turn the backlight power on.  We Enable backlight
0469      * control on these systems, but do not register a backlight sysfs
0470      * as brightness control does not work.
0471      */
0472     {
0473      /* https://bugzilla.kernel.org/show_bug.cgi?id=21012 */
0474      .callback = video_disable_backlight_sysfs_if,
0475      .ident = "Toshiba Portege R700",
0476      .matches = {
0477         DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
0478         DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE R700"),
0479         },
0480     },
0481     {
0482      /* https://bugs.freedesktop.org/show_bug.cgi?id=82634 */
0483      .callback = video_disable_backlight_sysfs_if,
0484      .ident = "Toshiba Portege R830",
0485      .matches = {
0486         DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
0487         DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE R830"),
0488         },
0489     },
0490     {
0491      /* https://bugzilla.kernel.org/show_bug.cgi?id=21012 */
0492      .callback = video_disable_backlight_sysfs_if,
0493      .ident = "Toshiba Satellite R830",
0494      .matches = {
0495         DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
0496         DMI_MATCH(DMI_PRODUCT_NAME, "SATELLITE R830"),
0497         },
0498     },
0499     /*
0500      * Some machine's _DOD IDs don't have bit 31(Device ID Scheme) set
0501      * but the IDs actually follow the Device ID Scheme.
0502      */
0503     {
0504      /* https://bugzilla.kernel.org/show_bug.cgi?id=104121 */
0505      .callback = video_set_device_id_scheme,
0506      .ident = "ESPRIMO Mobile M9410",
0507      .matches = {
0508         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
0509         DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO Mobile M9410"),
0510         },
0511     },
0512     /*
0513      * Some machines have multiple video output devices, but only the one
0514      * that is the type of LCD can do the backlight control so we should not
0515      * register backlight interface for other video output devices.
0516      */
0517     {
0518      /* https://bugzilla.kernel.org/show_bug.cgi?id=104121 */
0519      .callback = video_enable_only_lcd,
0520      .ident = "ESPRIMO Mobile M9410",
0521      .matches = {
0522         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
0523         DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO Mobile M9410"),
0524         },
0525     },
0526     /*
0527      * Some machines report wrong key events on the acpi-bus, suppress
0528      * key event reporting on these.  Note this is only intended to work
0529      * around events which are plain wrong. In some cases we get double
0530      * events, in this case acpi-video is considered the canonical source
0531      * and the events from the other source should be filtered. E.g.
0532      * by calling acpi_video_handles_brightness_key_presses() from the
0533      * vendor acpi/wmi driver or by using /lib/udev/hwdb.d/60-keyboard.hwdb
0534      */
0535     {
0536      .callback = video_set_report_key_events,
0537      .driver_data = (void *)((uintptr_t)REPORT_OUTPUT_KEY_EVENTS),
0538      .ident = "Dell Vostro V131",
0539      .matches = {
0540         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
0541         DMI_MATCH(DMI_PRODUCT_NAME, "Vostro V131"),
0542         },
0543     },
0544     {
0545      .callback = video_set_report_key_events,
0546      .driver_data = (void *)((uintptr_t)REPORT_BRIGHTNESS_KEY_EVENTS),
0547      .ident = "Dell Vostro 3350",
0548      .matches = {
0549         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
0550         DMI_MATCH(DMI_PRODUCT_NAME, "Vostro 3350"),
0551         },
0552     },
0553     /*
0554      * Some machines change the brightness themselves when a brightness
0555      * hotkey gets pressed, despite us telling them not to. In this case
0556      * acpi_video_device_notify() should only call backlight_force_update(
0557      * BACKLIGHT_UPDATE_HOTKEY) and not do anything else.
0558      */
0559     {
0560      /* https://bugzilla.kernel.org/show_bug.cgi?id=204077 */
0561      .callback = video_hw_changes_brightness,
0562      .ident = "Packard Bell EasyNote MZ35",
0563      .matches = {
0564         DMI_MATCH(DMI_SYS_VENDOR, "Packard Bell"),
0565         DMI_MATCH(DMI_PRODUCT_NAME, "EasyNote MZ35"),
0566         },
0567     },
0568     {}
0569 };
0570 
0571 static unsigned long long
0572 acpi_video_bqc_value_to_level(struct acpi_video_device *device,
0573                   unsigned long long bqc_value)
0574 {
0575     unsigned long long level;
0576 
0577     if (device->brightness->flags._BQC_use_index) {
0578         /*
0579          * _BQC returns an index that doesn't account for the first 2
0580          * items with special meaning (see enum acpi_video_level_idx),
0581          * so we need to compensate for that by offsetting ourselves
0582          */
0583         if (device->brightness->flags._BCL_reversed)
0584             bqc_value = device->brightness->count -
0585                 ACPI_VIDEO_FIRST_LEVEL - 1 - bqc_value;
0586 
0587         level = device->brightness->levels[bqc_value +
0588                            ACPI_VIDEO_FIRST_LEVEL];
0589     } else {
0590         level = bqc_value;
0591     }
0592 
0593     level += bqc_offset_aml_bug_workaround;
0594 
0595     return level;
0596 }
0597 
0598 static int
0599 acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
0600                     unsigned long long *level, bool raw)
0601 {
0602     acpi_status status = AE_OK;
0603     int i;
0604 
0605     if (device->cap._BQC || device->cap._BCQ) {
0606         char *buf = device->cap._BQC ? "_BQC" : "_BCQ";
0607 
0608         status = acpi_evaluate_integer(device->dev->handle, buf,
0609                         NULL, level);
0610         if (ACPI_SUCCESS(status)) {
0611             if (raw) {
0612                 /*
0613                  * Caller has indicated he wants the raw
0614                  * value returned by _BQC, so don't furtherly
0615                  * mess with the value.
0616                  */
0617                 return 0;
0618             }
0619 
0620             *level = acpi_video_bqc_value_to_level(device, *level);
0621 
0622             for (i = ACPI_VIDEO_FIRST_LEVEL;
0623                  i < device->brightness->count; i++)
0624                 if (device->brightness->levels[i] == *level) {
0625                     device->brightness->curr = *level;
0626                     return 0;
0627                 }
0628             /*
0629              * BQC returned an invalid level.
0630              * Stop using it.
0631              */
0632             acpi_handle_info(device->dev->handle,
0633                      "%s returned an invalid level", buf);
0634             device->cap._BQC = device->cap._BCQ = 0;
0635         } else {
0636             /*
0637              * Fixme:
0638              * should we return an error or ignore this failure?
0639              * dev->brightness->curr is a cached value which stores
0640              * the correct current backlight level in most cases.
0641              * ACPI video backlight still works w/ buggy _BQC.
0642              * http://bugzilla.kernel.org/show_bug.cgi?id=12233
0643              */
0644             acpi_handle_info(device->dev->handle,
0645                      "%s evaluation failed", buf);
0646             device->cap._BQC = device->cap._BCQ = 0;
0647         }
0648     }
0649 
0650     *level = device->brightness->curr;
0651     return 0;
0652 }
0653 
0654 static int
0655 acpi_video_device_EDID(struct acpi_video_device *device,
0656                union acpi_object **edid, ssize_t length)
0657 {
0658     int status;
0659     struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
0660     union acpi_object *obj;
0661     union acpi_object arg0 = { ACPI_TYPE_INTEGER };
0662     struct acpi_object_list args = { 1, &arg0 };
0663 
0664 
0665     *edid = NULL;
0666 
0667     if (!device)
0668         return -ENODEV;
0669     if (length == 128)
0670         arg0.integer.value = 1;
0671     else if (length == 256)
0672         arg0.integer.value = 2;
0673     else
0674         return -EINVAL;
0675 
0676     status = acpi_evaluate_object(device->dev->handle, "_DDC", &args, &buffer);
0677     if (ACPI_FAILURE(status))
0678         return -ENODEV;
0679 
0680     obj = buffer.pointer;
0681 
0682     if (obj && obj->type == ACPI_TYPE_BUFFER)
0683         *edid = obj;
0684     else {
0685         acpi_handle_info(device->dev->handle, "Invalid _DDC data\n");
0686         status = -EFAULT;
0687         kfree(obj);
0688     }
0689 
0690     return status;
0691 }
0692 
0693 /* bus */
0694 
0695 /*
0696  *  Arg:
0697  *  video       : video bus device pointer
0698  *  bios_flag   :
0699  *      0.  The system BIOS should NOT automatically switch(toggle)
0700  *          the active display output.
0701  *      1.  The system BIOS should automatically switch (toggle) the
0702  *          active display output. No switch event.
0703  *      2.  The _DGS value should be locked.
0704  *      3.  The system BIOS should not automatically switch (toggle) the
0705  *          active display output, but instead generate the display switch
0706  *          event notify code.
0707  *  lcd_flag    :
0708  *      0.  The system BIOS should automatically control the brightness level
0709  *          of the LCD when:
0710  *          - the power changes from AC to DC (ACPI appendix B)
0711  *          - a brightness hotkey gets pressed (implied by Win7/8 backlight docs)
0712  *      1.  The system BIOS should NOT automatically control the brightness
0713  *          level of the LCD when:
0714  *          - the power changes from AC to DC (ACPI appendix B)
0715  *          - a brightness hotkey gets pressed (implied by Win7/8 backlight docs)
0716  *  Return Value:
0717  *      -EINVAL wrong arg.
0718  */
0719 
0720 static int
0721 acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
0722 {
0723     acpi_status status;
0724 
0725     if (!video->cap._DOS)
0726         return 0;
0727 
0728     if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1)
0729         return -EINVAL;
0730     video->dos_setting = (lcd_flag << 2) | bios_flag;
0731     status = acpi_execute_simple_method(video->device->handle, "_DOS",
0732                         (lcd_flag << 2) | bios_flag);
0733     if (ACPI_FAILURE(status))
0734         return -EIO;
0735 
0736     return 0;
0737 }
0738 
0739 /*
0740  * Simple comparison function used to sort backlight levels.
0741  */
0742 
0743 static int
0744 acpi_video_cmp_level(const void *a, const void *b)
0745 {
0746     return *(int *)a - *(int *)b;
0747 }
0748 
0749 /*
0750  * Decides if _BQC/_BCQ for this system is usable
0751  *
0752  * We do this by changing the level first and then read out the current
0753  * brightness level, if the value does not match, find out if it is using
0754  * index. If not, clear the _BQC/_BCQ capability.
0755  */
0756 static int acpi_video_bqc_quirk(struct acpi_video_device *device,
0757                 int max_level, int current_level)
0758 {
0759     struct acpi_video_device_brightness *br = device->brightness;
0760     int result;
0761     unsigned long long level;
0762     int test_level;
0763 
0764     /* don't mess with existing known broken systems */
0765     if (bqc_offset_aml_bug_workaround)
0766         return 0;
0767 
0768     /*
0769      * Some systems always report current brightness level as maximum
0770      * through _BQC, we need to test another value for them. However,
0771      * there is a subtlety:
0772      *
0773      * If the _BCL package ordering is descending, the first level
0774      * (br->levels[2]) is likely to be 0, and if the number of levels
0775      * matches the number of steps, we might confuse a returned level to
0776      * mean the index.
0777      *
0778      * For example:
0779      *
0780      *     current_level = max_level = 100
0781      *     test_level = 0
0782      *     returned level = 100
0783      *
0784      * In this case 100 means the level, not the index, and _BCM failed.
0785      * Still, if the _BCL package ordering is descending, the index of
0786      * level 0 is also 100, so we assume _BQC is indexed, when it's not.
0787      *
0788      * This causes all _BQC calls to return bogus values causing weird
0789      * behavior from the user's perspective.  For example:
0790      *
0791      * xbacklight -set 10; xbacklight -set 20;
0792      *
0793      * would flash to 90% and then slowly down to the desired level (20).
0794      *
0795      * The solution is simple; test anything other than the first level
0796      * (e.g. 1).
0797      */
0798     test_level = current_level == max_level
0799         ? br->levels[ACPI_VIDEO_FIRST_LEVEL + 1]
0800         : max_level;
0801 
0802     result = acpi_video_device_lcd_set_level(device, test_level);
0803     if (result)
0804         return result;
0805 
0806     result = acpi_video_device_lcd_get_level_current(device, &level, true);
0807     if (result)
0808         return result;
0809 
0810     if (level != test_level) {
0811         /* buggy _BQC found, need to find out if it uses index */
0812         if (level < br->count) {
0813             if (br->flags._BCL_reversed)
0814                 level = br->count - ACPI_VIDEO_FIRST_LEVEL - 1 - level;
0815             if (br->levels[level + ACPI_VIDEO_FIRST_LEVEL] == test_level)
0816                 br->flags._BQC_use_index = 1;
0817         }
0818 
0819         if (!br->flags._BQC_use_index)
0820             device->cap._BQC = device->cap._BCQ = 0;
0821     }
0822 
0823     return 0;
0824 }
0825 
0826 int acpi_video_get_levels(struct acpi_device *device,
0827               struct acpi_video_device_brightness **dev_br,
0828               int *pmax_level)
0829 {
0830     union acpi_object *obj = NULL;
0831     int i, max_level = 0, count = 0, level_ac_battery = 0;
0832     union acpi_object *o;
0833     struct acpi_video_device_brightness *br = NULL;
0834     int result = 0;
0835     u32 value;
0836 
0837     if (ACPI_FAILURE(acpi_video_device_lcd_query_levels(device->handle, &obj))) {
0838         acpi_handle_debug(device->handle,
0839                   "Could not query available LCD brightness level\n");
0840         result = -ENODEV;
0841         goto out;
0842     }
0843 
0844     if (obj->package.count < ACPI_VIDEO_FIRST_LEVEL) {
0845         result = -EINVAL;
0846         goto out;
0847     }
0848 
0849     br = kzalloc(sizeof(*br), GFP_KERNEL);
0850     if (!br) {
0851         result = -ENOMEM;
0852         goto out;
0853     }
0854 
0855     /*
0856      * Note that we have to reserve 2 extra items (ACPI_VIDEO_FIRST_LEVEL),
0857      * in order to account for buggy BIOS which don't export the first two
0858      * special levels (see below)
0859      */
0860     br->levels = kmalloc_array(obj->package.count + ACPI_VIDEO_FIRST_LEVEL,
0861                    sizeof(*br->levels),
0862                    GFP_KERNEL);
0863     if (!br->levels) {
0864         result = -ENOMEM;
0865         goto out_free;
0866     }
0867 
0868     for (i = 0; i < obj->package.count; i++) {
0869         o = (union acpi_object *)&obj->package.elements[i];
0870         if (o->type != ACPI_TYPE_INTEGER) {
0871             acpi_handle_info(device->handle, "Invalid data\n");
0872             continue;
0873         }
0874         value = (u32) o->integer.value;
0875         /* Skip duplicate entries */
0876         if (count > ACPI_VIDEO_FIRST_LEVEL
0877             && br->levels[count - 1] == value)
0878             continue;
0879 
0880         br->levels[count] = value;
0881 
0882         if (br->levels[count] > max_level)
0883             max_level = br->levels[count];
0884         count++;
0885     }
0886 
0887     /*
0888      * some buggy BIOS don't export the levels
0889      * when machine is on AC/Battery in _BCL package.
0890      * In this case, the first two elements in _BCL packages
0891      * are also supported brightness levels that OS should take care of.
0892      */
0893     for (i = ACPI_VIDEO_FIRST_LEVEL; i < count; i++) {
0894         if (br->levels[i] == br->levels[ACPI_VIDEO_AC_LEVEL])
0895             level_ac_battery++;
0896         if (br->levels[i] == br->levels[ACPI_VIDEO_BATTERY_LEVEL])
0897             level_ac_battery++;
0898     }
0899 
0900     if (level_ac_battery < ACPI_VIDEO_FIRST_LEVEL) {
0901         level_ac_battery = ACPI_VIDEO_FIRST_LEVEL - level_ac_battery;
0902         br->flags._BCL_no_ac_battery_levels = 1;
0903         for (i = (count - 1 + level_ac_battery);
0904              i >= ACPI_VIDEO_FIRST_LEVEL; i--)
0905             br->levels[i] = br->levels[i - level_ac_battery];
0906         count += level_ac_battery;
0907     } else if (level_ac_battery > ACPI_VIDEO_FIRST_LEVEL)
0908         acpi_handle_info(device->handle,
0909                  "Too many duplicates in _BCL package");
0910 
0911     /* Check if the _BCL package is in a reversed order */
0912     if (max_level == br->levels[ACPI_VIDEO_FIRST_LEVEL]) {
0913         br->flags._BCL_reversed = 1;
0914         sort(&br->levels[ACPI_VIDEO_FIRST_LEVEL],
0915              count - ACPI_VIDEO_FIRST_LEVEL,
0916              sizeof(br->levels[ACPI_VIDEO_FIRST_LEVEL]),
0917              acpi_video_cmp_level, NULL);
0918     } else if (max_level != br->levels[count - 1])
0919         acpi_handle_info(device->handle,
0920                  "Found unordered _BCL package");
0921 
0922     br->count = count;
0923     *dev_br = br;
0924     if (pmax_level)
0925         *pmax_level = max_level;
0926 
0927 out:
0928     kfree(obj);
0929     return result;
0930 out_free:
0931     kfree(br);
0932     goto out;
0933 }
0934 EXPORT_SYMBOL(acpi_video_get_levels);
0935 
0936 /*
0937  *  Arg:
0938  *  device  : video output device (LCD, CRT, ..)
0939  *
0940  *  Return Value:
0941  *  Maximum brightness level
0942  *
0943  *  Allocate and initialize device->brightness.
0944  */
0945 
0946 static int
0947 acpi_video_init_brightness(struct acpi_video_device *device)
0948 {
0949     int i, max_level = 0;
0950     unsigned long long level, level_old;
0951     struct acpi_video_device_brightness *br = NULL;
0952     int result;
0953 
0954     result = acpi_video_get_levels(device->dev, &br, &max_level);
0955     if (result)
0956         return result;
0957     device->brightness = br;
0958 
0959     /* _BQC uses INDEX while _BCL uses VALUE in some laptops */
0960     br->curr = level = max_level;
0961 
0962     if (!device->cap._BQC)
0963         goto set_level;
0964 
0965     result = acpi_video_device_lcd_get_level_current(device,
0966                              &level_old, true);
0967     if (result)
0968         goto out_free_levels;
0969 
0970     result = acpi_video_bqc_quirk(device, max_level, level_old);
0971     if (result)
0972         goto out_free_levels;
0973     /*
0974      * cap._BQC may get cleared due to _BQC is found to be broken
0975      * in acpi_video_bqc_quirk, so check again here.
0976      */
0977     if (!device->cap._BQC)
0978         goto set_level;
0979 
0980     level = acpi_video_bqc_value_to_level(device, level_old);
0981     /*
0982      * On some buggy laptops, _BQC returns an uninitialized
0983      * value when invoked for the first time, i.e.
0984      * level_old is invalid (no matter whether it's a level
0985      * or an index). Set the backlight to max_level in this case.
0986      */
0987     for (i = ACPI_VIDEO_FIRST_LEVEL; i < br->count; i++)
0988         if (level == br->levels[i])
0989             break;
0990     if (i == br->count || !level)
0991         level = max_level;
0992 
0993 set_level:
0994     result = acpi_video_device_lcd_set_level(device, level);
0995     if (result)
0996         goto out_free_levels;
0997 
0998     acpi_handle_debug(device->dev->handle, "found %d brightness levels\n",
0999               br->count - ACPI_VIDEO_FIRST_LEVEL);
1000 
1001     return 0;
1002 
1003 out_free_levels:
1004     kfree(br->levels);
1005     kfree(br);
1006     device->brightness = NULL;
1007     return result;
1008 }
1009 
1010 /*
1011  *  Arg:
1012  *  device  : video output device (LCD, CRT, ..)
1013  *
1014  *  Return Value:
1015  *  None
1016  *
1017  *  Find out all required AML methods defined under the output
1018  *  device.
1019  */
1020 
1021 static void acpi_video_device_find_cap(struct acpi_video_device *device)
1022 {
1023     if (acpi_has_method(device->dev->handle, "_ADR"))
1024         device->cap._ADR = 1;
1025     if (acpi_has_method(device->dev->handle, "_BCL"))
1026         device->cap._BCL = 1;
1027     if (acpi_has_method(device->dev->handle, "_BCM"))
1028         device->cap._BCM = 1;
1029     if (acpi_has_method(device->dev->handle, "_BQC")) {
1030         device->cap._BQC = 1;
1031     } else if (acpi_has_method(device->dev->handle, "_BCQ")) {
1032         acpi_handle_info(device->dev->handle,
1033                  "_BCQ is used instead of _BQC\n");
1034         device->cap._BCQ = 1;
1035     }
1036 
1037     if (acpi_has_method(device->dev->handle, "_DDC"))
1038         device->cap._DDC = 1;
1039 }
1040 
1041 /*
1042  *  Arg:
1043  *  device  : video output device (VGA)
1044  *
1045  *  Return Value:
1046  *  None
1047  *
1048  *  Find out all required AML methods defined under the video bus device.
1049  */
1050 
1051 static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
1052 {
1053     if (acpi_has_method(video->device->handle, "_DOS"))
1054         video->cap._DOS = 1;
1055     if (acpi_has_method(video->device->handle, "_DOD"))
1056         video->cap._DOD = 1;
1057     if (acpi_has_method(video->device->handle, "_ROM"))
1058         video->cap._ROM = 1;
1059     if (acpi_has_method(video->device->handle, "_GPD"))
1060         video->cap._GPD = 1;
1061     if (acpi_has_method(video->device->handle, "_SPD"))
1062         video->cap._SPD = 1;
1063     if (acpi_has_method(video->device->handle, "_VPO"))
1064         video->cap._VPO = 1;
1065 }
1066 
1067 /*
1068  * Check whether the video bus device has required AML method to
1069  * support the desired features
1070  */
1071 
1072 static int acpi_video_bus_check(struct acpi_video_bus *video)
1073 {
1074     acpi_status status = -ENOENT;
1075     struct pci_dev *dev;
1076 
1077     if (!video)
1078         return -EINVAL;
1079 
1080     dev = acpi_get_pci_dev(video->device->handle);
1081     if (!dev)
1082         return -ENODEV;
1083     pci_dev_put(dev);
1084 
1085     /*
1086      * Since there is no HID, CID and so on for VGA driver, we have
1087      * to check well known required nodes.
1088      */
1089 
1090     /* Does this device support video switching? */
1091     if (video->cap._DOS || video->cap._DOD) {
1092         if (!video->cap._DOS) {
1093             pr_info(FW_BUG "ACPI(%s) defines _DOD but not _DOS\n",
1094                 acpi_device_bid(video->device));
1095         }
1096         video->flags.multihead = 1;
1097         status = 0;
1098     }
1099 
1100     /* Does this device support retrieving a video ROM? */
1101     if (video->cap._ROM) {
1102         video->flags.rom = 1;
1103         status = 0;
1104     }
1105 
1106     /* Does this device support configuring which video device to POST? */
1107     if (video->cap._GPD && video->cap._SPD && video->cap._VPO) {
1108         video->flags.post = 1;
1109         status = 0;
1110     }
1111 
1112     return status;
1113 }
1114 
1115 /*
1116  * --------------------------------------------------------------------------
1117  *                               Driver Interface
1118  * --------------------------------------------------------------------------
1119  */
1120 
1121 /* device interface */
1122 static struct acpi_video_device_attrib *
1123 acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id)
1124 {
1125     struct acpi_video_enumerated_device *ids;
1126     int i;
1127 
1128     for (i = 0; i < video->attached_count; i++) {
1129         ids = &video->attached_array[i];
1130         if ((ids->value.int_val & 0xffff) == device_id)
1131             return &ids->value.attrib;
1132     }
1133 
1134     return NULL;
1135 }
1136 
1137 static int
1138 acpi_video_get_device_type(struct acpi_video_bus *video,
1139                unsigned long device_id)
1140 {
1141     struct acpi_video_enumerated_device *ids;
1142     int i;
1143 
1144     for (i = 0; i < video->attached_count; i++) {
1145         ids = &video->attached_array[i];
1146         if ((ids->value.int_val & 0xffff) == device_id)
1147             return ids->value.int_val;
1148     }
1149 
1150     return 0;
1151 }
1152 
1153 static int acpi_video_bus_get_one_device(struct acpi_device *device, void *arg)
1154 {
1155     struct acpi_video_bus *video = arg;
1156     struct acpi_video_device_attrib *attribute;
1157     struct acpi_video_device *data;
1158     unsigned long long device_id;
1159     acpi_status status;
1160     int device_type;
1161 
1162     status = acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
1163     /* Skip devices without _ADR instead of failing. */
1164     if (ACPI_FAILURE(status))
1165         goto exit;
1166 
1167     data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
1168     if (!data) {
1169         dev_dbg(&device->dev, "Cannot attach\n");
1170         return -ENOMEM;
1171     }
1172 
1173     strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
1174     strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
1175     device->driver_data = data;
1176 
1177     data->device_id = device_id;
1178     data->video = video;
1179     data->dev = device;
1180     INIT_DELAYED_WORK(&data->switch_brightness_work,
1181               acpi_video_switch_brightness);
1182 
1183     attribute = acpi_video_get_device_attr(video, device_id);
1184 
1185     if (attribute && (attribute->device_id_scheme || device_id_scheme)) {
1186         switch (attribute->display_type) {
1187         case ACPI_VIDEO_DISPLAY_CRT:
1188             data->flags.crt = 1;
1189             break;
1190         case ACPI_VIDEO_DISPLAY_TV:
1191             data->flags.tvout = 1;
1192             break;
1193         case ACPI_VIDEO_DISPLAY_DVI:
1194             data->flags.dvi = 1;
1195             break;
1196         case ACPI_VIDEO_DISPLAY_LCD:
1197             data->flags.lcd = 1;
1198             break;
1199         default:
1200             data->flags.unknown = 1;
1201             break;
1202         }
1203         if (attribute->bios_can_detect)
1204             data->flags.bios = 1;
1205     } else {
1206         /* Check for legacy IDs */
1207         device_type = acpi_video_get_device_type(video, device_id);
1208         /* Ignore bits 16 and 18-20 */
1209         switch (device_type & 0xffe2ffff) {
1210         case ACPI_VIDEO_DISPLAY_LEGACY_MONITOR:
1211             data->flags.crt = 1;
1212             break;
1213         case ACPI_VIDEO_DISPLAY_LEGACY_PANEL:
1214             data->flags.lcd = 1;
1215             break;
1216         case ACPI_VIDEO_DISPLAY_LEGACY_TV:
1217             data->flags.tvout = 1;
1218             break;
1219         default:
1220             data->flags.unknown = 1;
1221         }
1222     }
1223 
1224     acpi_video_device_bind(video, data);
1225     acpi_video_device_find_cap(data);
1226 
1227     if (data->cap._BCM && data->cap._BCL)
1228         may_report_brightness_keys = true;
1229 
1230     mutex_lock(&video->device_list_lock);
1231     list_add_tail(&data->entry, &video->video_device_list);
1232     mutex_unlock(&video->device_list_lock);
1233 
1234 exit:
1235     video->child_count++;
1236     return 0;
1237 }
1238 
1239 /*
1240  *  Arg:
1241  *  video   : video bus device
1242  *
1243  *  Return:
1244  *  none
1245  *
1246  *  Enumerate the video device list of the video bus,
1247  *  bind the ids with the corresponding video devices
1248  *  under the video bus.
1249  */
1250 
1251 static void acpi_video_device_rebind(struct acpi_video_bus *video)
1252 {
1253     struct acpi_video_device *dev;
1254 
1255     mutex_lock(&video->device_list_lock);
1256 
1257     list_for_each_entry(dev, &video->video_device_list, entry)
1258         acpi_video_device_bind(video, dev);
1259 
1260     mutex_unlock(&video->device_list_lock);
1261 }
1262 
1263 /*
1264  *  Arg:
1265  *  video   : video bus device
1266  *  device  : video output device under the video
1267  *      bus
1268  *
1269  *  Return:
1270  *  none
1271  *
1272  *  Bind the ids with the corresponding video devices
1273  *  under the video bus.
1274  */
1275 
1276 static void
1277 acpi_video_device_bind(struct acpi_video_bus *video,
1278                struct acpi_video_device *device)
1279 {
1280     struct acpi_video_enumerated_device *ids;
1281     int i;
1282 
1283     for (i = 0; i < video->attached_count; i++) {
1284         ids = &video->attached_array[i];
1285         if (device->device_id == (ids->value.int_val & 0xffff)) {
1286             ids->bind_info = device;
1287             acpi_handle_debug(video->device->handle, "%s: %d\n",
1288                       __func__, i);
1289         }
1290     }
1291 }
1292 
1293 static bool acpi_video_device_in_dod(struct acpi_video_device *device)
1294 {
1295     struct acpi_video_bus *video = device->video;
1296     int i;
1297 
1298     /*
1299      * If we have a broken _DOD or we have more than 8 output devices
1300      * under the graphics controller node that we can't proper deal with
1301      * in the operation region code currently, no need to test.
1302      */
1303     if (!video->attached_count || video->child_count > 8)
1304         return true;
1305 
1306     for (i = 0; i < video->attached_count; i++) {
1307         if ((video->attached_array[i].value.int_val & 0xfff) ==
1308             (device->device_id & 0xfff))
1309             return true;
1310     }
1311 
1312     return false;
1313 }
1314 
1315 /*
1316  *  Arg:
1317  *  video   : video bus device
1318  *
1319  *  Return:
1320  *  < 0 : error
1321  *
1322  *  Call _DOD to enumerate all devices attached to display adapter
1323  *
1324  */
1325 
1326 static int acpi_video_device_enumerate(struct acpi_video_bus *video)
1327 {
1328     int status;
1329     int count;
1330     int i;
1331     struct acpi_video_enumerated_device *active_list;
1332     struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1333     union acpi_object *dod = NULL;
1334     union acpi_object *obj;
1335 
1336     if (!video->cap._DOD)
1337         return AE_NOT_EXIST;
1338 
1339     status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer);
1340     if (ACPI_FAILURE(status)) {
1341         acpi_handle_info(video->device->handle,
1342                  "_DOD evaluation failed: %s\n",
1343                  acpi_format_exception(status));
1344         return status;
1345     }
1346 
1347     dod = buffer.pointer;
1348     if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
1349         acpi_handle_info(video->device->handle, "Invalid _DOD data\n");
1350         status = -EFAULT;
1351         goto out;
1352     }
1353 
1354     acpi_handle_debug(video->device->handle, "Found %d video heads in _DOD\n",
1355               dod->package.count);
1356 
1357     active_list = kcalloc(1 + dod->package.count,
1358                   sizeof(struct acpi_video_enumerated_device),
1359                   GFP_KERNEL);
1360     if (!active_list) {
1361         status = -ENOMEM;
1362         goto out;
1363     }
1364 
1365     count = 0;
1366     for (i = 0; i < dod->package.count; i++) {
1367         obj = &dod->package.elements[i];
1368 
1369         if (obj->type != ACPI_TYPE_INTEGER) {
1370             acpi_handle_info(video->device->handle,
1371                      "Invalid _DOD data in element %d\n", i);
1372             continue;
1373         }
1374 
1375         active_list[count].value.int_val = obj->integer.value;
1376         active_list[count].bind_info = NULL;
1377 
1378         acpi_handle_debug(video->device->handle,
1379                   "_DOD element[%d] = %d\n", i,
1380                   (int)obj->integer.value);
1381 
1382         count++;
1383     }
1384 
1385     kfree(video->attached_array);
1386 
1387     video->attached_array = active_list;
1388     video->attached_count = count;
1389 
1390 out:
1391     kfree(buffer.pointer);
1392     return status;
1393 }
1394 
1395 static int
1396 acpi_video_get_next_level(struct acpi_video_device *device,
1397               u32 level_current, u32 event)
1398 {
1399     int min, max, min_above, max_below, i, l, delta = 255;
1400     max = max_below = 0;
1401     min = min_above = 255;
1402     /* Find closest level to level_current */
1403     for (i = ACPI_VIDEO_FIRST_LEVEL; i < device->brightness->count; i++) {
1404         l = device->brightness->levels[i];
1405         if (abs(l - level_current) < abs(delta)) {
1406             delta = l - level_current;
1407             if (!delta)
1408                 break;
1409         }
1410     }
1411     /* Adjust level_current to closest available level */
1412     level_current += delta;
1413     for (i = ACPI_VIDEO_FIRST_LEVEL; i < device->brightness->count; i++) {
1414         l = device->brightness->levels[i];
1415         if (l < min)
1416             min = l;
1417         if (l > max)
1418             max = l;
1419         if (l < min_above && l > level_current)
1420             min_above = l;
1421         if (l > max_below && l < level_current)
1422             max_below = l;
1423     }
1424 
1425     switch (event) {
1426     case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:
1427         return (level_current < max) ? min_above : min;
1428     case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:
1429         return (level_current < max) ? min_above : max;
1430     case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:
1431         return (level_current > min) ? max_below : min;
1432     case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS:
1433     case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:
1434         return 0;
1435     default:
1436         return level_current;
1437     }
1438 }
1439 
1440 static void
1441 acpi_video_switch_brightness(struct work_struct *work)
1442 {
1443     struct acpi_video_device *device = container_of(to_delayed_work(work),
1444                  struct acpi_video_device, switch_brightness_work);
1445     unsigned long long level_current, level_next;
1446     int event = device->switch_brightness_event;
1447     int result = -EINVAL;
1448 
1449     /* no warning message if acpi_backlight=vendor or a quirk is used */
1450     if (!device->backlight)
1451         return;
1452 
1453     if (!device->brightness)
1454         goto out;
1455 
1456     result = acpi_video_device_lcd_get_level_current(device,
1457                              &level_current,
1458                              false);
1459     if (result)
1460         goto out;
1461 
1462     level_next = acpi_video_get_next_level(device, level_current, event);
1463 
1464     result = acpi_video_device_lcd_set_level(device, level_next);
1465 
1466     if (!result)
1467         backlight_force_update(device->backlight,
1468                        BACKLIGHT_UPDATE_HOTKEY);
1469 
1470 out:
1471     if (result)
1472         acpi_handle_info(device->dev->handle,
1473                  "Failed to switch brightness\n");
1474 }
1475 
1476 int acpi_video_get_edid(struct acpi_device *device, int type, int device_id,
1477             void **edid)
1478 {
1479     struct acpi_video_bus *video;
1480     struct acpi_video_device *video_device;
1481     union acpi_object *buffer = NULL;
1482     acpi_status status;
1483     int i, length;
1484 
1485     if (!device || !acpi_driver_data(device))
1486         return -EINVAL;
1487 
1488     video = acpi_driver_data(device);
1489 
1490     for (i = 0; i < video->attached_count; i++) {
1491         video_device = video->attached_array[i].bind_info;
1492         length = 256;
1493 
1494         if (!video_device)
1495             continue;
1496 
1497         if (!video_device->cap._DDC)
1498             continue;
1499 
1500         if (type) {
1501             switch (type) {
1502             case ACPI_VIDEO_DISPLAY_CRT:
1503                 if (!video_device->flags.crt)
1504                     continue;
1505                 break;
1506             case ACPI_VIDEO_DISPLAY_TV:
1507                 if (!video_device->flags.tvout)
1508                     continue;
1509                 break;
1510             case ACPI_VIDEO_DISPLAY_DVI:
1511                 if (!video_device->flags.dvi)
1512                     continue;
1513                 break;
1514             case ACPI_VIDEO_DISPLAY_LCD:
1515                 if (!video_device->flags.lcd)
1516                     continue;
1517                 break;
1518             }
1519         } else if (video_device->device_id != device_id) {
1520             continue;
1521         }
1522 
1523         status = acpi_video_device_EDID(video_device, &buffer, length);
1524 
1525         if (ACPI_FAILURE(status) || !buffer ||
1526             buffer->type != ACPI_TYPE_BUFFER) {
1527             length = 128;
1528             status = acpi_video_device_EDID(video_device, &buffer,
1529                             length);
1530             if (ACPI_FAILURE(status) || !buffer ||
1531                 buffer->type != ACPI_TYPE_BUFFER) {
1532                 continue;
1533             }
1534         }
1535 
1536         *edid = buffer->buffer.pointer;
1537         return length;
1538     }
1539 
1540     return -ENODEV;
1541 }
1542 EXPORT_SYMBOL(acpi_video_get_edid);
1543 
1544 static int
1545 acpi_video_bus_get_devices(struct acpi_video_bus *video,
1546                struct acpi_device *device)
1547 {
1548     /*
1549      * There are systems where video module known to work fine regardless
1550      * of broken _DOD and ignoring returned value here doesn't cause
1551      * any issues later.
1552      */
1553     acpi_video_device_enumerate(video);
1554 
1555     return acpi_dev_for_each_child(device, acpi_video_bus_get_one_device, video);
1556 }
1557 
1558 /* acpi_video interface */
1559 
1560 /*
1561  * Win8 requires setting bit2 of _DOS to let firmware know it shouldn't
1562  * perform any automatic brightness change on receiving a notification.
1563  */
1564 static int acpi_video_bus_start_devices(struct acpi_video_bus *video)
1565 {
1566     return acpi_video_bus_DOS(video, 0,
1567                   acpi_osi_is_win8() ? 1 : 0);
1568 }
1569 
1570 static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
1571 {
1572     return acpi_video_bus_DOS(video, 0,
1573                   acpi_osi_is_win8() ? 0 : 1);
1574 }
1575 
1576 static void acpi_video_bus_notify(struct acpi_device *device, u32 event)
1577 {
1578     struct acpi_video_bus *video = acpi_driver_data(device);
1579     struct input_dev *input;
1580     int keycode = 0;
1581 
1582     if (!video || !video->input)
1583         return;
1584 
1585     input = video->input;
1586 
1587     switch (event) {
1588     case ACPI_VIDEO_NOTIFY_SWITCH:  /* User requested a switch,
1589                      * most likely via hotkey. */
1590         keycode = KEY_SWITCHVIDEOMODE;
1591         break;
1592 
1593     case ACPI_VIDEO_NOTIFY_PROBE:   /* User plugged in or removed a video
1594                      * connector. */
1595         acpi_video_device_enumerate(video);
1596         acpi_video_device_rebind(video);
1597         keycode = KEY_SWITCHVIDEOMODE;
1598         break;
1599 
1600     case ACPI_VIDEO_NOTIFY_CYCLE:   /* Cycle Display output hotkey pressed. */
1601         keycode = KEY_SWITCHVIDEOMODE;
1602         break;
1603     case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT: /* Next Display output hotkey pressed. */
1604         keycode = KEY_VIDEO_NEXT;
1605         break;
1606     case ACPI_VIDEO_NOTIFY_PREV_OUTPUT: /* previous Display output hotkey pressed. */
1607         keycode = KEY_VIDEO_PREV;
1608         break;
1609 
1610     default:
1611         acpi_handle_debug(device->handle, "Unsupported event [0x%x]\n",
1612                   event);
1613         break;
1614     }
1615 
1616     if (acpi_notifier_call_chain(device, event, 0))
1617         /* Something vetoed the keypress. */
1618         keycode = 0;
1619 
1620     if (keycode && (report_key_events & REPORT_OUTPUT_KEY_EVENTS)) {
1621         input_report_key(input, keycode, 1);
1622         input_sync(input);
1623         input_report_key(input, keycode, 0);
1624         input_sync(input);
1625     }
1626 }
1627 
1628 static void brightness_switch_event(struct acpi_video_device *video_device,
1629                     u32 event)
1630 {
1631     if (!brightness_switch_enabled)
1632         return;
1633 
1634     video_device->switch_brightness_event = event;
1635     schedule_delayed_work(&video_device->switch_brightness_work, HZ / 10);
1636 }
1637 
1638 static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
1639 {
1640     struct acpi_video_device *video_device = data;
1641     struct acpi_device *device = NULL;
1642     struct acpi_video_bus *bus;
1643     struct input_dev *input;
1644     int keycode = 0;
1645 
1646     if (!video_device)
1647         return;
1648 
1649     device = video_device->dev;
1650     bus = video_device->video;
1651     input = bus->input;
1652 
1653     if (hw_changes_brightness > 0) {
1654         if (video_device->backlight)
1655             backlight_force_update(video_device->backlight,
1656                            BACKLIGHT_UPDATE_HOTKEY);
1657         acpi_notifier_call_chain(device, event, 0);
1658         return;
1659     }
1660 
1661     switch (event) {
1662     case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:    /* Cycle brightness */
1663         brightness_switch_event(video_device, event);
1664         keycode = KEY_BRIGHTNESS_CYCLE;
1665         break;
1666     case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:  /* Increase brightness */
1667         brightness_switch_event(video_device, event);
1668         keycode = KEY_BRIGHTNESSUP;
1669         break;
1670     case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:  /* Decrease brightness */
1671         brightness_switch_event(video_device, event);
1672         keycode = KEY_BRIGHTNESSDOWN;
1673         break;
1674     case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: /* zero brightness */
1675         brightness_switch_event(video_device, event);
1676         keycode = KEY_BRIGHTNESS_ZERO;
1677         break;
1678     case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: /* display device off */
1679         brightness_switch_event(video_device, event);
1680         keycode = KEY_DISPLAY_OFF;
1681         break;
1682     default:
1683         acpi_handle_debug(handle, "Unsupported event [0x%x]\n", event);
1684         break;
1685     }
1686 
1687     if (keycode)
1688         may_report_brightness_keys = true;
1689 
1690     acpi_notifier_call_chain(device, event, 0);
1691 
1692     if (keycode && (report_key_events & REPORT_BRIGHTNESS_KEY_EVENTS)) {
1693         input_report_key(input, keycode, 1);
1694         input_sync(input);
1695         input_report_key(input, keycode, 0);
1696         input_sync(input);
1697     }
1698 }
1699 
1700 static int acpi_video_resume(struct notifier_block *nb,
1701                 unsigned long val, void *ign)
1702 {
1703     struct acpi_video_bus *video;
1704     struct acpi_video_device *video_device;
1705     int i;
1706 
1707     switch (val) {
1708     case PM_POST_HIBERNATION:
1709     case PM_POST_SUSPEND:
1710     case PM_POST_RESTORE:
1711         video = container_of(nb, struct acpi_video_bus, pm_nb);
1712 
1713         dev_info(&video->device->dev, "Restoring backlight state\n");
1714 
1715         for (i = 0; i < video->attached_count; i++) {
1716             video_device = video->attached_array[i].bind_info;
1717             if (video_device && video_device->brightness)
1718                 acpi_video_device_lcd_set_level(video_device,
1719                         video_device->brightness->curr);
1720         }
1721 
1722         return NOTIFY_OK;
1723     }
1724     return NOTIFY_DONE;
1725 }
1726 
1727 static acpi_status
1728 acpi_video_bus_match(acpi_handle handle, u32 level, void *context,
1729             void **return_value)
1730 {
1731     struct acpi_device *device = context;
1732     struct acpi_device *sibling;
1733 
1734     if (handle == device->handle)
1735         return AE_CTRL_TERMINATE;
1736 
1737     sibling = acpi_fetch_acpi_dev(handle);
1738     if (!sibling)
1739         return AE_OK;
1740 
1741     if (!strcmp(acpi_device_name(sibling), ACPI_VIDEO_BUS_NAME))
1742             return AE_ALREADY_EXISTS;
1743 
1744     return AE_OK;
1745 }
1746 
1747 static void acpi_video_dev_register_backlight(struct acpi_video_device *device)
1748 {
1749     struct backlight_properties props;
1750     struct pci_dev *pdev;
1751     acpi_handle acpi_parent;
1752     struct device *parent = NULL;
1753     int result;
1754     static int count;
1755     char *name;
1756 
1757     result = acpi_video_init_brightness(device);
1758     if (result)
1759         return;
1760 
1761     if (disable_backlight_sysfs_if > 0)
1762         return;
1763 
1764     name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
1765     if (!name)
1766         return;
1767     count++;
1768 
1769     acpi_get_parent(device->dev->handle, &acpi_parent);
1770 
1771     pdev = acpi_get_pci_dev(acpi_parent);
1772     if (pdev) {
1773         parent = &pdev->dev;
1774         pci_dev_put(pdev);
1775     }
1776 
1777     memset(&props, 0, sizeof(struct backlight_properties));
1778     props.type = BACKLIGHT_FIRMWARE;
1779     props.max_brightness =
1780         device->brightness->count - ACPI_VIDEO_FIRST_LEVEL - 1;
1781     device->backlight = backlight_device_register(name,
1782                               parent,
1783                               device,
1784                               &acpi_backlight_ops,
1785                               &props);
1786     kfree(name);
1787     if (IS_ERR(device->backlight)) {
1788         device->backlight = NULL;
1789         return;
1790     }
1791 
1792     /*
1793      * Save current brightness level in case we have to restore it
1794      * before acpi_video_device_lcd_set_level() is called next time.
1795      */
1796     device->backlight->props.brightness =
1797             acpi_video_get_brightness(device->backlight);
1798 
1799     device->cooling_dev = thermal_cooling_device_register("LCD",
1800                 device->dev, &video_cooling_ops);
1801     if (IS_ERR(device->cooling_dev)) {
1802         /*
1803          * Set cooling_dev to NULL so we don't crash trying to free it.
1804          * Also, why the hell we are returning early and not attempt to
1805          * register video output if cooling device registration failed?
1806          * -- dtor
1807          */
1808         device->cooling_dev = NULL;
1809         return;
1810     }
1811 
1812     dev_info(&device->dev->dev, "registered as cooling_device%d\n",
1813          device->cooling_dev->id);
1814     result = sysfs_create_link(&device->dev->dev.kobj,
1815             &device->cooling_dev->device.kobj,
1816             "thermal_cooling");
1817     if (result)
1818         pr_info("sysfs link creation failed\n");
1819 
1820     result = sysfs_create_link(&device->cooling_dev->device.kobj,
1821             &device->dev->dev.kobj, "device");
1822     if (result)
1823         pr_info("Reverse sysfs link creation failed\n");
1824 }
1825 
1826 static void acpi_video_run_bcl_for_osi(struct acpi_video_bus *video)
1827 {
1828     struct acpi_video_device *dev;
1829     union acpi_object *levels;
1830 
1831     mutex_lock(&video->device_list_lock);
1832     list_for_each_entry(dev, &video->video_device_list, entry) {
1833         if (!acpi_video_device_lcd_query_levels(dev->dev->handle, &levels))
1834             kfree(levels);
1835     }
1836     mutex_unlock(&video->device_list_lock);
1837 }
1838 
1839 static bool acpi_video_should_register_backlight(struct acpi_video_device *dev)
1840 {
1841     /*
1842      * Do not create backlight device for video output
1843      * device that is not in the enumerated list.
1844      */
1845     if (!acpi_video_device_in_dod(dev)) {
1846         dev_dbg(&dev->dev->dev, "not in _DOD list, ignore\n");
1847         return false;
1848     }
1849 
1850     if (only_lcd)
1851         return dev->flags.lcd;
1852     return true;
1853 }
1854 
1855 static int acpi_video_bus_register_backlight(struct acpi_video_bus *video)
1856 {
1857     struct acpi_video_device *dev;
1858 
1859     if (video->backlight_registered)
1860         return 0;
1861 
1862     acpi_video_run_bcl_for_osi(video);
1863 
1864     if (acpi_video_get_backlight_type() != acpi_backlight_video)
1865         return 0;
1866 
1867     mutex_lock(&video->device_list_lock);
1868     list_for_each_entry(dev, &video->video_device_list, entry) {
1869         if (acpi_video_should_register_backlight(dev))
1870             acpi_video_dev_register_backlight(dev);
1871     }
1872     mutex_unlock(&video->device_list_lock);
1873 
1874     video->backlight_registered = true;
1875 
1876     video->pm_nb.notifier_call = acpi_video_resume;
1877     video->pm_nb.priority = 0;
1878     return register_pm_notifier(&video->pm_nb);
1879 }
1880 
1881 static void acpi_video_dev_unregister_backlight(struct acpi_video_device *device)
1882 {
1883     if (device->backlight) {
1884         backlight_device_unregister(device->backlight);
1885         device->backlight = NULL;
1886     }
1887     if (device->brightness) {
1888         kfree(device->brightness->levels);
1889         kfree(device->brightness);
1890         device->brightness = NULL;
1891     }
1892     if (device->cooling_dev) {
1893         sysfs_remove_link(&device->dev->dev.kobj, "thermal_cooling");
1894         sysfs_remove_link(&device->cooling_dev->device.kobj, "device");
1895         thermal_cooling_device_unregister(device->cooling_dev);
1896         device->cooling_dev = NULL;
1897     }
1898 }
1899 
1900 static int acpi_video_bus_unregister_backlight(struct acpi_video_bus *video)
1901 {
1902     struct acpi_video_device *dev;
1903     int error;
1904 
1905     if (!video->backlight_registered)
1906         return 0;
1907 
1908     error = unregister_pm_notifier(&video->pm_nb);
1909 
1910     mutex_lock(&video->device_list_lock);
1911     list_for_each_entry(dev, &video->video_device_list, entry)
1912         acpi_video_dev_unregister_backlight(dev);
1913     mutex_unlock(&video->device_list_lock);
1914 
1915     video->backlight_registered = false;
1916 
1917     return error;
1918 }
1919 
1920 static void acpi_video_dev_add_notify_handler(struct acpi_video_device *device)
1921 {
1922     acpi_status status;
1923     struct acpi_device *adev = device->dev;
1924 
1925     status = acpi_install_notify_handler(adev->handle, ACPI_DEVICE_NOTIFY,
1926                          acpi_video_device_notify, device);
1927     if (ACPI_FAILURE(status))
1928         dev_err(&adev->dev, "Error installing notify handler\n");
1929     else
1930         device->flags.notify = 1;
1931 }
1932 
1933 static int acpi_video_bus_add_notify_handler(struct acpi_video_bus *video)
1934 {
1935     struct input_dev *input;
1936     struct acpi_video_device *dev;
1937     int error;
1938 
1939     video->input = input = input_allocate_device();
1940     if (!input) {
1941         error = -ENOMEM;
1942         goto out;
1943     }
1944 
1945     error = acpi_video_bus_start_devices(video);
1946     if (error)
1947         goto err_free_input;
1948 
1949     snprintf(video->phys, sizeof(video->phys),
1950             "%s/video/input0", acpi_device_hid(video->device));
1951 
1952     input->name = acpi_device_name(video->device);
1953     input->phys = video->phys;
1954     input->id.bustype = BUS_HOST;
1955     input->id.product = 0x06;
1956     input->dev.parent = &video->device->dev;
1957     input->evbit[0] = BIT(EV_KEY);
1958     set_bit(KEY_SWITCHVIDEOMODE, input->keybit);
1959     set_bit(KEY_VIDEO_NEXT, input->keybit);
1960     set_bit(KEY_VIDEO_PREV, input->keybit);
1961     set_bit(KEY_BRIGHTNESS_CYCLE, input->keybit);
1962     set_bit(KEY_BRIGHTNESSUP, input->keybit);
1963     set_bit(KEY_BRIGHTNESSDOWN, input->keybit);
1964     set_bit(KEY_BRIGHTNESS_ZERO, input->keybit);
1965     set_bit(KEY_DISPLAY_OFF, input->keybit);
1966 
1967     error = input_register_device(input);
1968     if (error)
1969         goto err_stop_dev;
1970 
1971     mutex_lock(&video->device_list_lock);
1972     list_for_each_entry(dev, &video->video_device_list, entry)
1973         acpi_video_dev_add_notify_handler(dev);
1974     mutex_unlock(&video->device_list_lock);
1975 
1976     return 0;
1977 
1978 err_stop_dev:
1979     acpi_video_bus_stop_devices(video);
1980 err_free_input:
1981     input_free_device(input);
1982     video->input = NULL;
1983 out:
1984     return error;
1985 }
1986 
1987 static void acpi_video_dev_remove_notify_handler(struct acpi_video_device *dev)
1988 {
1989     if (dev->flags.notify) {
1990         acpi_remove_notify_handler(dev->dev->handle, ACPI_DEVICE_NOTIFY,
1991                        acpi_video_device_notify);
1992         dev->flags.notify = 0;
1993     }
1994 }
1995 
1996 static void acpi_video_bus_remove_notify_handler(struct acpi_video_bus *video)
1997 {
1998     struct acpi_video_device *dev;
1999 
2000     mutex_lock(&video->device_list_lock);
2001     list_for_each_entry(dev, &video->video_device_list, entry)
2002         acpi_video_dev_remove_notify_handler(dev);
2003     mutex_unlock(&video->device_list_lock);
2004 
2005     acpi_video_bus_stop_devices(video);
2006     input_unregister_device(video->input);
2007     video->input = NULL;
2008 }
2009 
2010 static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
2011 {
2012     struct acpi_video_device *dev, *next;
2013 
2014     mutex_lock(&video->device_list_lock);
2015     list_for_each_entry_safe(dev, next, &video->video_device_list, entry) {
2016         list_del(&dev->entry);
2017         kfree(dev);
2018     }
2019     mutex_unlock(&video->device_list_lock);
2020 
2021     return 0;
2022 }
2023 
2024 static int instance;
2025 
2026 static int acpi_video_bus_add(struct acpi_device *device)
2027 {
2028     struct acpi_video_bus *video;
2029     int error;
2030     acpi_status status;
2031 
2032     status = acpi_walk_namespace(ACPI_TYPE_DEVICE,
2033                 device->parent->handle, 1,
2034                 acpi_video_bus_match, NULL,
2035                 device, NULL);
2036     if (status == AE_ALREADY_EXISTS) {
2037         pr_info(FW_BUG
2038             "Duplicate ACPI video bus devices for the"
2039             " same VGA controller, please try module "
2040             "parameter \"video.allow_duplicates=1\""
2041             "if the current driver doesn't work.\n");
2042         if (!allow_duplicates)
2043             return -ENODEV;
2044     }
2045 
2046     video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
2047     if (!video)
2048         return -ENOMEM;
2049 
2050     /* a hack to fix the duplicate name "VID" problem on T61 */
2051     if (!strcmp(device->pnp.bus_id, "VID")) {
2052         if (instance)
2053             device->pnp.bus_id[3] = '0' + instance;
2054         instance++;
2055     }
2056     /* a hack to fix the duplicate name "VGA" problem on Pa 3553 */
2057     if (!strcmp(device->pnp.bus_id, "VGA")) {
2058         if (instance)
2059             device->pnp.bus_id[3] = '0' + instance;
2060         instance++;
2061     }
2062 
2063     video->device = device;
2064     strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
2065     strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
2066     device->driver_data = video;
2067 
2068     acpi_video_bus_find_cap(video);
2069     error = acpi_video_bus_check(video);
2070     if (error)
2071         goto err_free_video;
2072 
2073     mutex_init(&video->device_list_lock);
2074     INIT_LIST_HEAD(&video->video_device_list);
2075 
2076     error = acpi_video_bus_get_devices(video, device);
2077     if (error)
2078         goto err_put_video;
2079 
2080     pr_info("%s [%s] (multi-head: %s  rom: %s  post: %s)\n",
2081            ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device),
2082            video->flags.multihead ? "yes" : "no",
2083            video->flags.rom ? "yes" : "no",
2084            video->flags.post ? "yes" : "no");
2085     mutex_lock(&video_list_lock);
2086     list_add_tail(&video->entry, &video_bus_head);
2087     mutex_unlock(&video_list_lock);
2088 
2089     acpi_video_bus_register_backlight(video);
2090     acpi_video_bus_add_notify_handler(video);
2091 
2092     return 0;
2093 
2094 err_put_video:
2095     acpi_video_bus_put_devices(video);
2096     kfree(video->attached_array);
2097 err_free_video:
2098     kfree(video);
2099     device->driver_data = NULL;
2100 
2101     return error;
2102 }
2103 
2104 static int acpi_video_bus_remove(struct acpi_device *device)
2105 {
2106     struct acpi_video_bus *video = NULL;
2107 
2108 
2109     if (!device || !acpi_driver_data(device))
2110         return -EINVAL;
2111 
2112     video = acpi_driver_data(device);
2113 
2114     acpi_video_bus_remove_notify_handler(video);
2115     acpi_video_bus_unregister_backlight(video);
2116     acpi_video_bus_put_devices(video);
2117 
2118     mutex_lock(&video_list_lock);
2119     list_del(&video->entry);
2120     mutex_unlock(&video_list_lock);
2121 
2122     kfree(video->attached_array);
2123     kfree(video);
2124 
2125     return 0;
2126 }
2127 
2128 static int __init is_i740(struct pci_dev *dev)
2129 {
2130     if (dev->device == 0x00D1)
2131         return 1;
2132     if (dev->device == 0x7000)
2133         return 1;
2134     return 0;
2135 }
2136 
2137 static int __init intel_opregion_present(void)
2138 {
2139     int opregion = 0;
2140     struct pci_dev *dev = NULL;
2141     u32 address;
2142 
2143     for_each_pci_dev(dev) {
2144         if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
2145             continue;
2146         if (dev->vendor != PCI_VENDOR_ID_INTEL)
2147             continue;
2148         /* We don't want to poke around undefined i740 registers */
2149         if (is_i740(dev))
2150             continue;
2151         pci_read_config_dword(dev, 0xfc, &address);
2152         if (!address)
2153             continue;
2154         opregion = 1;
2155     }
2156     return opregion;
2157 }
2158 
2159 /* Check if the chassis-type indicates there is no builtin LCD panel */
2160 static bool dmi_is_desktop(void)
2161 {
2162     const char *chassis_type;
2163     unsigned long type;
2164 
2165     chassis_type = dmi_get_system_info(DMI_CHASSIS_TYPE);
2166     if (!chassis_type)
2167         return false;
2168 
2169     if (kstrtoul(chassis_type, 10, &type) != 0)
2170         return false;
2171 
2172     switch (type) {
2173     case 0x03: /* Desktop */
2174     case 0x04: /* Low Profile Desktop */
2175     case 0x05: /* Pizza Box */
2176     case 0x06: /* Mini Tower */
2177     case 0x07: /* Tower */
2178     case 0x10: /* Lunch Box */
2179     case 0x11: /* Main Server Chassis */
2180         return true;
2181     }
2182 
2183     return false;
2184 }
2185 
2186 /*
2187  * We're seeing a lot of bogus backlight interfaces on newer machines
2188  * without a LCD such as desktops, servers and HDMI sticks. Checking the
2189  * lcd flag fixes this, enable this by default on any machines which are:
2190  * 1.  Win8 ready (where we also prefer the native backlight driver, so
2191  *     normally the acpi_video code should not register there anyways); *and*
2192  * 2.1 Report a desktop/server DMI chassis-type, or
2193  * 2.2 Are an ACPI-reduced-hardware platform (and thus won't use the EC for
2194        backlight control)
2195  */
2196 static bool should_check_lcd_flag(void)
2197 {
2198     if (!acpi_osi_is_win8())
2199         return false;
2200 
2201     if (dmi_is_desktop())
2202         return true;
2203 
2204     if (acpi_reduced_hardware())
2205         return true;
2206 
2207     return false;
2208 }
2209 
2210 int acpi_video_register(void)
2211 {
2212     int ret = 0;
2213 
2214     mutex_lock(&register_count_mutex);
2215     if (register_count) {
2216         /*
2217          * if the function of acpi_video_register is already called,
2218          * don't register the acpi_video_bus again and return no error.
2219          */
2220         goto leave;
2221     }
2222 
2223     if (only_lcd == -1)
2224         only_lcd = should_check_lcd_flag();
2225 
2226     dmi_check_system(video_dmi_table);
2227 
2228     ret = acpi_bus_register_driver(&acpi_video_bus);
2229     if (ret)
2230         goto leave;
2231 
2232     /*
2233      * When the acpi_video_bus is loaded successfully, increase
2234      * the counter reference.
2235      */
2236     register_count = 1;
2237 
2238 leave:
2239     mutex_unlock(&register_count_mutex);
2240     return ret;
2241 }
2242 EXPORT_SYMBOL(acpi_video_register);
2243 
2244 void acpi_video_unregister(void)
2245 {
2246     mutex_lock(&register_count_mutex);
2247     if (register_count) {
2248         acpi_bus_unregister_driver(&acpi_video_bus);
2249         register_count = 0;
2250         may_report_brightness_keys = false;
2251     }
2252     mutex_unlock(&register_count_mutex);
2253 }
2254 EXPORT_SYMBOL(acpi_video_unregister);
2255 
2256 void acpi_video_unregister_backlight(void)
2257 {
2258     struct acpi_video_bus *video;
2259 
2260     mutex_lock(&register_count_mutex);
2261     if (register_count) {
2262         mutex_lock(&video_list_lock);
2263         list_for_each_entry(video, &video_bus_head, entry)
2264             acpi_video_bus_unregister_backlight(video);
2265         mutex_unlock(&video_list_lock);
2266     }
2267     mutex_unlock(&register_count_mutex);
2268 }
2269 
2270 bool acpi_video_handles_brightness_key_presses(void)
2271 {
2272     return may_report_brightness_keys &&
2273            (report_key_events & REPORT_BRIGHTNESS_KEY_EVENTS);
2274 }
2275 EXPORT_SYMBOL(acpi_video_handles_brightness_key_presses);
2276 
2277 /*
2278  * This is kind of nasty. Hardware using Intel chipsets may require
2279  * the video opregion code to be run first in order to initialise
2280  * state before any ACPI video calls are made. To handle this we defer
2281  * registration of the video class until the opregion code has run.
2282  */
2283 
2284 static int __init acpi_video_init(void)
2285 {
2286     /*
2287      * Let the module load even if ACPI is disabled (e.g. due to
2288      * a broken BIOS) so that i915.ko can still be loaded on such
2289      * old systems without an AcpiOpRegion.
2290      *
2291      * acpi_video_register() will report -ENODEV later as well due
2292      * to acpi_disabled when i915.ko tries to register itself afterwards.
2293      */
2294     if (acpi_disabled)
2295         return 0;
2296 
2297     if (intel_opregion_present())
2298         return 0;
2299 
2300     return acpi_video_register();
2301 }
2302 
2303 static void __exit acpi_video_exit(void)
2304 {
2305     acpi_video_detect_exit();
2306     acpi_video_unregister();
2307 }
2308 
2309 module_init(acpi_video_init);
2310 module_exit(acpi_video_exit);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!