ACPI_VIDEO_FIRST_LEVEL - 1 - bqc_value;
 
                level = device->brightness->levels[bqc_value +
-                                                  ACPI_VIDEO_FIRST_LEVEL];
+                                                  ACPI_VIDEO_FIRST_LEVEL];
        } else {
                level = bqc_value;
        }
                goto out_free_levels;
 
        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                         "found %d brightness levels\n",
-                         br->count - ACPI_VIDEO_FIRST_LEVEL));
+                         "found %d brightness levels\n",
+                         br->count - ACPI_VIDEO_FIRST_LEVEL));
        return 0;
 
 out_free_levels:
 
         */
        if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
            (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
-            (battery->capacity_now <= battery->alarm)))
+            (battery->capacity_now <= battery->alarm)))
                acpi_pm_wakeup_event(&battery->device->dev);
 
        return result;
 
        event.type = type;
        event.data = data;
        return (blocking_notifier_call_chain(&acpi_chain_head, 0, (void *)&event)
-                        == NOTIFY_BAD) ? -EINVAL : 0;
+                       == NOTIFY_BAD) ? -EINVAL : 0;
 }
 EXPORT_SYMBOL(acpi_notifier_call_chain);
 
 
 void acpi_power_add_remove_device(struct acpi_device *adev, bool add);
 int acpi_power_wakeup_list_init(struct list_head *list, int *system_level);
 int acpi_device_sleep_wake(struct acpi_device *dev,
-                           int enable, int sleep_state, int dev_state);
+                          int enable, int sleep_state, int dev_state);
 int acpi_power_get_inferred_state(struct acpi_device *device, int *state);
 int acpi_power_on_resources(struct acpi_device *device, int state);
 int acpi_power_transition(struct acpi_device *device, int state);
 
  * these commands.
  */
 enum nfit_aux_cmds {
-        NFIT_CMD_TRANSLATE_SPA = 5,
-        NFIT_CMD_ARS_INJECT_SET = 7,
-        NFIT_CMD_ARS_INJECT_CLEAR = 8,
-        NFIT_CMD_ARS_INJECT_GET = 9,
+       NFIT_CMD_TRANSLATE_SPA = 5,
+       NFIT_CMD_ARS_INJECT_SET = 7,
+       NFIT_CMD_ARS_INJECT_CLEAR = 8,
+       NFIT_CMD_ARS_INJECT_GET = 9,
 };
 
 static void acpi_nfit_init_dsms(struct acpi_nfit_desc *acpi_desc)
        nfit_blk->bdw_offset = nfit_mem->bdw->offset;
        mmio = &nfit_blk->mmio[BDW];
        mmio->addr.base = devm_nvdimm_memremap(dev, nfit_mem->spa_bdw->address,
-                        nfit_mem->spa_bdw->length, nd_blk_memremap_flags(ndbr));
+                       nfit_mem->spa_bdw->length, nd_blk_memremap_flags(ndbr));
        if (!mmio->addr.base) {
                dev_dbg(dev, "%s failed to map bdw\n",
                                nvdimm_name(nvdimm));
 
         * configure the IRQ assigned to this slot|dev|pin.  The 'source_index'
         * indicates which resource descriptor in the resource template (of
         * the link device) this interrupt is allocated from.
-        * 
+        *
         * NOTE: Don't query the Link Device for IRQ information at this time
         *       because Link Device enumeration may not have occurred yet
         *       (e.g. exists somewhere 'below' this _PRT entry in the ACPI
 
  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
  *  Copyright (C) 2002       Dominik Brodowski <devel@brodo.de>
  *
- * TBD: 
- *      1. Support more than one IRQ resource entry per link device (index).
+ * TBD:
+ *     1. Support more than one IRQ resource entry per link device (index).
  *     2. Implement start/stop mechanism and use ACPI Bus Driver facilities
  *        for IRQ management (e.g. start()->_SRS).
  */
                }
        }
 
-       /* 
-        * Query and parse _CRS to get the current IRQ assignment. 
+       /*
+        * Query and parse _CRS to get the current IRQ assignment.
         */
 
        status = acpi_walk_resources(link->device->handle, METHOD_NAME__CRS,
 /*
  * "acpi_irq_balance" (default in APIC mode) enables ACPI to use PIC Interrupt
  * Link Devices to move the PIRQs around to minimize sharing.
- * 
+ *
  * "acpi_irq_nobalance" (default in PIC mode) tells ACPI not to move any PIC IRQs
  * that the BIOS has already set to active.  This is necessary because
  * ACPI has no automatic means of knowing what ISA IRQs are used.  Note that
  *
  * Note that PCI IRQ routers have a list of possible IRQs,
  * which may not include the IRQs this table says are available.
- * 
+ *
  * Since this heuristic can't tell the difference between a link
  * that no device will attach to, vs. a link which may be shared
  * by multiple active devices -- it is not optimal.
 
 {
        if (!memcmp(f->oem_id, mcfg_oem_id, ACPI_OEM_ID_SIZE) &&
            !memcmp(f->oem_table_id, mcfg_oem_table_id,
-                   ACPI_OEM_TABLE_ID_SIZE) &&
+                   ACPI_OEM_TABLE_ID_SIZE) &&
            f->oem_revision == mcfg_oem_revision &&
            f->segment == segment &&
            resource_contains(&f->bus_range, bus_range))
 
  * 1. via "Device Specific (D-State) Control"
  * 2. via "Power Resource Control".
  * The code below deals with ACPI Power Resources control.
- * 
+ *
  * An ACPI "power resource object" represents a software controllable power
  * plane, clock plane, or other resource depended on by a device.
  *
  * -ENODEV if the execution of either _DSW or _PSW has failed
  */
 int acpi_device_sleep_wake(struct acpi_device *dev,
-                           int enable, int sleep_state, int dev_state)
+                          int enable, int sleep_state, int dev_state)
 {
        union acpi_object in_arg[3];
        struct acpi_object_list arg_list = { 3, in_arg };
 
 /*
  * Prepare a wakeup device, two steps (Ref ACPI 2.0:P229):
- * 1. Power on the power resources required for the wakeup device 
+ * 1. Power on the power resources required for the wakeup device
  * 2. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
  *    State Wake) for the device, if present
  */
 
                                  (u32) px->control, (u32) px->status));
 
                /*
-                * Check that ACPI's u64 MHz will be valid as u32 KHz in cpufreq
+                * Check that ACPI's u64 MHz will be valid as u32 KHz in cpufreq
                 */
                if (!px->core_frequency ||
                    ((u32)(px->core_frequency * 1000) !=
                goto err_ret;
 
        /*
-        * Now that we have _PSD data from all CPUs, lets setup P-state 
+        * Now that we have _PSD data from all CPUs, lets setup P-state
         * domain info.
         */
        for_each_possible_cpu(i) {
                        if (match_pdomain->domain != pdomain->domain)
                                continue;
 
-                       match_pr->performance->shared_type = 
+                       match_pr->performance->shared_type =
                                        pr->performance->shared_type;
                        cpumask_copy(match_pr->performance->shared_cpu_map,
                                     pr->performance->shared_cpu_map);
 
                                         state_readers[i].mode,
                                         ACPI_SBS_BATTERY,
                                         state_readers[i].command,
-                                        (u8 *)battery +
+                                        (u8 *)battery +
                                                state_readers[i].offset);
                if (result)
                        goto end;
 
 EXPORT_SYMBOL_GPL(acpi_smbus_write);
 
 int acpi_smbus_register_callback(struct acpi_smb_hc *hc,
-                                smbus_alarm_callback callback, void *context)
+                                smbus_alarm_callback callback, void *context)
 {
        mutex_lock(&hc->lock);
        hc->callback = callback;
 
 typedef void (*smbus_alarm_callback)(void *context);
 
 extern int acpi_smbus_read(struct acpi_smb_hc *hc, u8 protocol, u8 address,
-              u8 command, u8 * data);
+               u8 command, u8 *data);
 extern int acpi_smbus_write(struct acpi_smb_hc *hc, u8 protocol, u8 slave_address,
-               u8 command, u8 * data, u8 length);
+               u8 command, u8 *data, u8 length);
 extern int acpi_smbus_register_callback(struct acpi_smb_hc *hc,
-                                smbus_alarm_callback callback, void *context);
+               smbus_alarm_callback callback, void *context);
 extern int acpi_smbus_unregister_callback(struct acpi_smb_hc *hc);
 
                DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad X201s"),
                },
        },
-        {
-         .callback = video_detect_force_video,
-         .ident = "ThinkPad X201T",
-         .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
-                DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad X201T"),
-                },
-        },
+       {
+        .callback = video_detect_force_video,
+        .ident = "ThinkPad X201T",
+        .matches = {
+               DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
+               DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad X201T"),
+               },
+       },
 
        /* The native backlight controls do not work on some older machines */
        {
 
                if (!dev->wakeup.flags.valid
                    || sleep_state > (u32) dev->wakeup.sleep_state
                    || !(device_may_wakeup(&dev->dev)
-                       || dev->wakeup.prepare_count))
+                        || dev->wakeup.prepare_count))
                        continue;
 
                if (device_may_wakeup(&dev->dev))
                if (!dev->wakeup.flags.valid
                    || sleep_state > (u32) dev->wakeup.sleep_state
                    || !(device_may_wakeup(&dev->dev)
-                       || dev->wakeup.prepare_count))
+                        || dev->wakeup.prepare_count))
                        continue;
 
                acpi_set_gpe_wake_mask(dev->wakeup.gpe_device, dev->wakeup.gpe_number,