Merge branches 'acerhdf', 'acpi-pci-bind', 'bjorn-pci-root', 'bugzilla-12904', 'bugzi...
Len Brown [Wed, 24 Jun 2009 05:19:50 +0000 (01:19 -0400)]
20 files changed:
1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18 
Documentation/kernel-parameters.txt
Documentation/laptops/thinkpad-acpi.txt
MAINTAINERS
arch/x86/include/asm/pci_x86.h
arch/x86/kernel/acpi/boot.c
drivers/acpi/pci_irq.c
drivers/acpi/pci_root.c
drivers/acpi/processor_core.c
drivers/acpi/processor_idle.c
drivers/acpi/scan.c
drivers/acpi/video.c
drivers/platform/x86/Kconfig
drivers/platform/x86/hp-wmi.c
drivers/platform/x86/thinkpad_acpi.c
drivers/pnp/pnpacpi/rsparser.c
include/acpi/acpi_bus.h
include/acpi/acpi_drivers.h
include/linux/acpi.h
include/linux/pci_hotplug.h
init/main.c

Simple merge
diff --cc MAINTAINERS
                  F:    drivers/edac/edac_*
                  F:    include/linux/edac.h
                  
 +++++++++++++++++EDAC-AMD64
 +++++++++++++++++P:    Doug Thompson
 +++++++++++++++++M:    dougthompson@xmission.com
 +++++++++++++++++P:    Borislav Petkov
 +++++++++++++++++M:    borislav.petkov@amd.com
 +++++++++++++++++L:    bluesmoke-devel@lists.sourceforge.net (moderated for non-subscribers)
 +++++++++++++++++W:    bluesmoke.sourceforge.net
 +++++++++++++++++S:    Supported
 +++++++++++++++++F:    drivers/edac/amd64_edac*
 +++++++++++++++++
                  EDAC-E752X
                  P:    Mark Gross
         --  --   P:    Doug Thompson
                  M:    mark.gross@intel.com
         ++  ++   P:    Doug Thompson
                  M:    dougthompson@xmission.com
                  L:    bluesmoke-devel@lists.sourceforge.net (moderated for non-subscribers)
                  W:    bluesmoke.sourceforge.net
                  M:    leoli@freescale.com
                  P:    Zhang Wei
                  M:    zw@zh-kernel.org
         --  --   L:    linuxppc-embedded@ozlabs.org
         --  --   L:    linux-kernel@vger.kernel.org
         ++  ++   L:    linuxppc-dev@ozlabs.org
 --------  --  ---L:    linux-kernel@vger.kernel.org
                  S:    Maintained
                  F:    drivers/dma/fsldma.*
                  
Simple merge
                                       ioapic_pin);
                                return gsi;
                        }
 -----------------      if (test_bit(ioapic_pin, mp_ioapic_routing[ioapic].pin_programmed)) {
 -----------------              pr_debug("Pin %d-%d already programmed\n",
 -----------------                       mp_ioapic_routing[ioapic].apic_id, ioapic_pin);
 -----------------#ifdef CONFIG_X86_32
 -----------------              return (gsi < IRQ_COMPRESSION_START ? gsi : gsi_to_irq[gsi]);
 -----------------#else
 -----------------              return gsi;
 -----------------#endif
 -----------------      }
                  
 -----------------      set_bit(ioapic_pin, mp_ioapic_routing[ioapic].pin_programmed);
 -----------------#ifdef CONFIG_X86_32
 -----------------      /*
 -----------------       * For GSI >= 64, use IRQ compression
 -----------------       */
 -----------------      if ((gsi >= IRQ_COMPRESSION_START)
 -----------------          && (triggering == ACPI_LEVEL_SENSITIVE)) {
 -----------------              /*
 -----------------               * For PCI devices assign IRQs in order, avoiding gaps
 -----------------               * due to unused I/O APIC pins.
 -----------------               */
 -----------------              int irq = gsi;
 -----------------              if (gsi < MAX_GSI_NUM) {
 -----------------                      /*
 -----------------                       * Retain the VIA chipset work-around (gsi > 15), but
 -----------------                       * avoid a problem where the 8254 timer (IRQ0) is setup
 -----------------                       * via an override (so it's not on pin 0 of the ioapic),
 -----------------                       * and at the same time, the pin 0 interrupt is a PCI
 -----------------                       * type.  The gsi > 15 test could cause these two pins
 -----------------                       * to be shared as IRQ0, and they are not shareable.
 -----------------                       * So test for this condition, and if necessary, avoid
 -----------------                       * the pin collision.
 -----------------                       */
 -----------------                      gsi = pci_irq++;
 -----------------                      /*
 -----------------                       * Don't assign IRQ used by ACPI SCI
 -----------------                       */
 -----------------                      if (gsi == acpi_gbl_FADT.sci_interrupt)
 -----------------                              gsi = pci_irq++;
 -----------------                      gsi_to_irq[irq] = gsi;
 -----------------              } else {
 -----------------                      printk(KERN_ERR "GSI %u is too high\n", gsi);
 -----------------                      return gsi;
 -----------------              }
 -----------------      }
 -----------------#endif
 -----------------      io_apic_set_pci_routing(ioapic, ioapic_pin, gsi,
 -----------------                              triggering == ACPI_EDGE_SENSITIVE ? 0 : 1,
 -----------------                              polarity == ACPI_ACTIVE_HIGH ? 0 : 1);
 -----------------      return gsi;
 -----------------}
 +++++++++++++++++      if (enable_update_mptable)
 +++++++++++++++++              mp_config_acpi_gsi(dev, gsi, trigger, polarity);
                  
 -----------------int mp_config_acpi_gsi(unsigned char number, unsigned int devfn, u8 pin,
 -----------------                      u32 gsi, int triggering, int polarity)
 -----------------{
 -----------------#ifdef CONFIG_X86_MPPARSE
 -----------------      struct mpc_intsrc mp_irq;
 -----------------      int ioapic;
 ---------- ------
 ---------- ------      if (!acpi_ioapic)
 ---------- ------              return 0;
 +++++++++++++++++      set_io_apic_irq_attr(&irq_attr, ioapic, ioapic_pin,
 +++++++++++++++++                           trigger == ACPI_EDGE_SENSITIVE ? 0 : 1,
 +++++++++++++++++                           polarity == ACPI_ACTIVE_HIGH ? 0 : 1);
 +++++++++++++++++      io_apic_set_pci_routing(dev, gsi, &irq_attr);
                  
 ---------- ------      /* print the entry should happen on mptable identically */
 ---------- ------      mp_irq.type = MP_INTSRC;
 ---------- ------      mp_irq.irqtype = mp_INT;
 ---------- ------      mp_irq.irqflag = (triggering == ACPI_EDGE_SENSITIVE ? 4 : 0x0c) |
 ---------- ------                              (polarity == ACPI_ACTIVE_HIGH ? 1 : 3);
 ---------- ------      mp_irq.srcbus = number;
 ---------- ------      mp_irq.srcbusirq = (((devfn >> 3) & 0x1f) << 2) | ((pin - 1) & 3);
 ---------- ------      ioapic = mp_find_ioapic(gsi);
 ---------- ------      mp_irq.dstapic = mp_ioapic_routing[ioapic].apic_id;
 ---------- ------      mp_irq.dstirq = mp_find_ioapic_pin(ioapic, gsi);
 ---------- ------
 ---------- ------      save_mp_irq(&mp_irq);
 ---------- ------#endif
 ---------- ------      return 0;
           -            if (!acpi_ioapic)
           -                    return 0;
           -      
           -            /* print the entry should happen on mptable identically */
           -            mp_irq.type = MP_INTSRC;
           -            mp_irq.irqtype = mp_INT;
           -            mp_irq.irqflag = (triggering == ACPI_EDGE_SENSITIVE ? 4 : 0x0c) |
           -                                    (polarity == ACPI_ACTIVE_HIGH ? 1 : 3);
           -            mp_irq.srcbus = number;
           -            mp_irq.srcbusirq = (((devfn >> 3) & 0x1f) << 2) | ((pin - 1) & 3);
           -            ioapic = mp_find_ioapic(gsi);
           -            mp_irq.dstapic = mp_ioapic_routing[ioapic].apic_id;
           -            mp_irq.dstirq = mp_find_ioapic_pin(ioapic, gsi);
           -      
           -            save_mp_irq(&mp_irq);
           -      #endif
           -            return 0;
 +++++++++++++++++      return gsi;
                  }
                  
                  /*
Simple merge
Simple merge
Simple merge
@@@@@@@@@@@@@@@@@@@ -839,7 -839,7 -839,7 -839,7 -839,7 -839,7 -839,7 -839,7 -839,7 -838,6 -835,6 -835,7 -839,7 -835,6 -835,6 -839,7 -839,7 -839,7 +838,7 @@@@@@@@@@@@@@@@@@@ static int acpi_idle_enter_c1(struct cp
                                return 0;
                        }
                  
---------   -  ---      acpi_state_timer_broadcast(pr, cx, 1);
+++++++++++ ++++++      lapic_timer_state_broadcast(pr, cx, 1);
                        kt1 = ktime_get_real();
                        acpi_idle_do_entry(cx);
                        kt2 = ktime_get_real();
                  
                        local_irq_enable();
                        cx->usage++;
---------   -  ---      acpi_state_timer_broadcast(pr, cx, 0);
+++++++++++ ++++++      lapic_timer_state_broadcast(pr, cx, 0);
                  
                        return idle_time;
                  }
Simple merge
@@@@@@@@@@@@@@@@@@@ -570,22 -570,22 -570,22 -570,22 -570,22 -570,30 -571,22 -570,22 -570,22 -570,6 -570,6 -570,22 -570,22 -570,6 -570,6 -570,22 -570,22 -570,22 +571,30 @@@@@@@@@@@@@@@@@@@ static struct dmi_system_id video_dmi_t
                                DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5710Z"),
                                },
                        },
         ++  ++         {
         ++  ++          .callback = video_set_bqc_offset,
         ++  ++          .ident = "eMachines E510",
         ++  ++          .matches = {
         ++  ++                 DMI_MATCH(DMI_BOARD_VENDOR, "EMACHINES"),
         ++  ++                 DMI_MATCH(DMI_PRODUCT_NAME, "eMachines E510"),
         ++  ++                 },
         ++  ++         },
         ++  ++         {
         ++  ++          .callback = video_set_bqc_offset,
         ++  ++          .ident = "Acer Aspire 5315",
         ++  ++          .matches = {
         ++  ++                 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
         ++  ++                 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5315"),
         ++  ++                 },
         ++  ++         },
+++++ ++++++++++++      {
+++++ ++++++++++++       .callback = video_set_bqc_offset,
+++++ ++++++++++++       .ident = "Acer Aspire 7720",
+++++ ++++++++++++       .matches = {
+++++ ++++++++++++              DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
+++++ ++++++++++++              DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 7720"),
+++++ ++++++++++++              },
+++++ ++++++++++++      },
                        {}
                  };
                  
@@@@@@@@@@@@@@@@@@@ -2350,12 -2350,12 -2350,12 -2350,12 -2350,12 -2358,12 -2383,9 -2350,12 -2350,12 -2334,12 -2334,12 -2350,12 -2350,12 -2334,12 -2334,12 -2350,12 -2356,12 -2350,12 +2397,9 @@@@@@@@@@@@@@@@@@@ static int __init acpi_video_init(void
                        return acpi_video_register();
                  }
                  
------ --  --  ---void acpi_video_exit(void)
         --  --   void __exit acpi_video_exit(void)
++++++ +++++++++++static void __exit acpi_video_exit(void)
                  {
------ -----------
------ -----------      acpi_bus_unregister_driver(&acpi_video_bus);
------ -----------
------ -----------      remove_proc_entry(ACPI_VIDEO_CLASS, acpi_root_dir);
++++++ +++++++++++      acpi_video_unregister();
                  
                        return;
                  }
Simple merge
@@@@@@@@@@@@@@@@@@@ -151,22 -151,34 -151,34 -151,34 -151,34 -151,34 -151,34 -151,34 -151,34 -151,34 -151,34 -151,34 -151,34 -151,34 -151,34 -151,34 -151,34 -150,49 +150,37 @@@@@@@@@@@@@@@@@@@ static int hp_wmi_als_state(void
                  
                  static int hp_wmi_dock_state(void)
                  {
-----------------       return hp_wmi_perform_query(HPWMI_DOCK_QUERY, 0, 0);
 ---------------- }
+++++++++++++++++       int ret = hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, 0, 0);
+                 
 ---------------- static int hp_wmi_wifi_set(void *data, enum rfkill_state state)
 ---------------- {
 ----------------       if (state)
 ----------------               return hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1, 0x101);
 ----------------       else
 ----------------               return hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1, 0x100);
+++++++++++++++++       if (ret < 0)
+++++++++++++++++               return ret;
+++++++++++++++++ 
+++++++++++++++++       return ret & 0x1;
+                 }
+                 
 ---------------- static int hp_wmi_bluetooth_set(void *data, enum rfkill_state state)
+++++++++++++++++ static int hp_wmi_tablet_state(void)
+                 {
 ----------------       if (state)
 ----------------               return hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1, 0x202);
 ----------------       else
 ----------------               return hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1, 0x200);
+++++++++++++++++       int ret = hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, 0, 0);
+++++++++++++++++ 
+++++++++++++++++       if (ret < 0)
+++++++++++++++++               return ret;
+++++++++++++++++ 
+++++++++++++++++       return (ret & 0x4) ? 1 : 0;
                  }
                  
 ---------------- static int hp_wmi_wwan_set(void *data, enum rfkill_state state)
                 -static int hp_wmi_wifi_set(void *data, enum rfkill_state state)
 +++++++++++++++++static int hp_wmi_set_block(void *data, bool blocked)
                  {
 -----------------      if (state)
 ----------------               return hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1, 0x404);
 ----------------       else
 ----------------               return hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1, 0x400);
                 -              return hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1, 0x101);
                 -      else
                 -              return hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1, 0x100);
                 -}
 +++++++++++++++++      unsigned long b = (unsigned long) data;
 +++++++++++++++++      int query = BIT(b + 8) | ((!!blocked) << b);
 ++++++++++++++++ 
                 -static int hp_wmi_bluetooth_set(void *data, enum rfkill_state state)
                 -{
                 -      if (state)
                 -              return hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1, 0x202);
                 -      else
                 -              return hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1, 0x200);
 +++++++++++++++++      return hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1, query);
                  }
                  
 ---------------- static int hp_wmi_wifi_state(void)
                 -static int hp_wmi_wwan_set(void *data, enum rfkill_state state)
                 -{
                 -      if (state)
                 -              return hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1, 0x404);
                 -      else
                 -              return hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1, 0x400);
                 -}
 +++++++++++++++++static const struct rfkill_ops hp_wmi_rfkill_ops = {
 +++++++++++++++++      .set_block = hp_wmi_set_block,
 +++++++++++++++++};
 ++++++++++++++++ 
                 -static int hp_wmi_wifi_state(void)
 +++++++++++++++++static bool hp_wmi_wifi_state(void)
                  {
                        int wireless = hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0, 0);
                  
@@@@@@@@@@@@@@@@@@@ -326,23 -338,23 -338,23 -338,23 -338,23 -338,23 -338,23 -338,23 -338,23 -338,23 -338,23 -338,23 -338,23 -338,23 -338,23 -338,23 -338,23 -362,23 +350,23 @@@@@@@@@@@@@@@@@@@ static void hp_wmi_notify(u32 value, vo
                                                                 key->keycode, 0);
                                                input_sync(hp_wmi_input_dev);
                                                break;
-----------------                       case KE_SW:
-----------------                               input_report_switch(hp_wmi_input_dev,
-----------------                                                   key->keycode,
-----------------                                                   hp_wmi_dock_state());
-----------------                               input_sync(hp_wmi_input_dev);
-----------------                               break;
                                        }
+++++++++++++++++               } else if (eventcode == 0x1) {
+++++++++++++++++                       input_report_switch(hp_wmi_input_dev, SW_DOCK,
+++++++++++++++++                                           hp_wmi_dock_state());
+++++++++++++++++                       input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE,
+++++++++++++++++                                           hp_wmi_tablet_state());
+++++++++++++++++                       input_sync(hp_wmi_input_dev);
                                } else if (eventcode == 0x5) {
                                        if (wifi_rfkill)
 -----------------                              rfkill_force_state(wifi_rfkill,
 -----------------                                                 hp_wmi_wifi_state());
 +++++++++++++++++                              rfkill_set_sw_state(wifi_rfkill,
 +++++++++++++++++                                                  hp_wmi_wifi_state());
                                        if (bluetooth_rfkill)
 -----------------                              rfkill_force_state(bluetooth_rfkill,
 -----------------                                                 hp_wmi_bluetooth_state());
 +++++++++++++++++                              rfkill_set_sw_state(bluetooth_rfkill,
 +++++++++++++++++                                                  hp_wmi_bluetooth_state());
                                        if (wwan_rfkill)
 -----------------                              rfkill_force_state(wwan_rfkill,
 -----------------                                                 hp_wmi_wwan_state());
 +++++++++++++++++                              rfkill_set_sw_state(wwan_rfkill,
 +++++++++++++++++                                                  hp_wmi_wwan_state());
                                } else
                                        printk(KERN_INFO "HP WMI: Unknown key pressed - %x\n",
                                               eventcode);
@@@@@@@@@@@@@@@@@@@ -416,15 -428,16 -428,16 -428,16 -428,16 -428,16 -428,16 -428,16 -428,16 -428,16 -428,16 -428,16 -428,16 -428,16 -428,16 -428,16 -428,16 -454,19 +442,18 @@@@@@@@@@@@@@@@@@@ static int __init hp_wmi_bios_setup(str
                        err = device_create_file(&device->dev, &dev_attr_dock);
                        if (err)
                                goto add_sysfs_error;
+++++++++++++++++       err = device_create_file(&device->dev, &dev_attr_tablet);
+++++++++++++++++       if (err)
+++++++++++++++++               goto add_sysfs_error;
                  
                        if (wireless & 0x1) {
 -----------------              wifi_rfkill = rfkill_allocate(&device->dev, RFKILL_TYPE_WLAN);
 -----------------              wifi_rfkill->name = "hp-wifi";
 -----------------              wifi_rfkill->state = hp_wmi_wifi_state();
 -----------------              wifi_rfkill->toggle_radio = hp_wmi_wifi_set;
 -----------------              wifi_rfkill->user_claim_unsupported = 1;
 +++++++++++++++++              wifi_rfkill = rfkill_alloc("hp-wifi", &device->dev,
 +++++++++++++++++                                         RFKILL_TYPE_WLAN,
 +++++++++++++++++                                         &hp_wmi_rfkill_ops,
 +++++++++++++++++                                         (void *) 0);
                                err = rfkill_register(wifi_rfkill);
                                if (err)
 -----------------                      goto add_sysfs_error;
 +++++++++++++++++                      goto register_wifi_error;
                        }
                  
                        if (wireless & 0x2) {
                  {
                        int wlsw;
                  
 -----------------      /* Sync these BEFORE sending any rfkill events */
 -----------------      if (tp_features.bluetooth)
 -----------------              bluetooth_update_rfk();
 -----------------      if (tp_features.wan)
 -----------------              wan_update_rfk();
 -----------------      if (tp_features.uwb)
 -----------------              uwb_update_rfk();
 +++++++++++++++++      /*
 +++++++++++++++++       * We must sync all rfkill controllers *before* issuing any
 +++++++++++++++++       * rfkill input events, or we will race the rfkill core input
 +++++++++++++++++       * handler.
 +++++++++++++++++       *
 +++++++++++++++++       * tpacpi_inputdev_send_mutex works as a syncronization point
 +++++++++++++++++       * for the above.
 +++++++++++++++++       *
 +++++++++++++++++       * We optimize to avoid numerous calls to hotkey_get_wlsw.
 +++++++++++++++++       */
 +++++++++++++++++
 +++++++++++++++++      wlsw = hotkey_get_wlsw();
 ++++++++++++++ ++
               -        if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&wlsw)) {
 +++++++++++++++++      /* Sync hw blocking state first if it is hw-blocked */
 +++++++++++++++++      if (wlsw == TPACPI_RFK_RADIO_OFF)
 +++++++++++++++++              tpacpi_rfk_update_hwblock_state(true);
 +++++++++++++++++
 +++++++++++++++++      /* Sync sw blocking state */
 +++++++++++++++++      tpacpi_rfk_update_swstate_all();
 +++++++++++++++++
 +++++++++++++++++      /* Sync hw blocking state last if it is hw-unblocked */
 +++++++++++++++++      if (wlsw == TPACPI_RFK_RADIO_ON)
 +++++++++++++++++              tpacpi_rfk_update_hwblock_state(false);
               +  
 -------------- --      if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&wlsw)) {
 +++++++++++++++++      /* Issue rfkill input event for WLSW switch */
 +++++++++++++++++      if (!(wlsw < 0)) {
                                mutex_lock(&tpacpi_inputdev_send_mutex);
                  
                                input_report_switch(tpacpi_inputdev,
                                return -EIO;
                  
                        return ((status & TP_ACPI_BLUETOOTH_RADIOSSW) != 0) ?
 -----------------              RFKILL_STATE_UNBLOCKED : RFKILL_STATE_SOFT_BLOCKED;
               -  }
               -  
               -  static void bluetooth_update_rfk(void)
               -  {
               -        int status;
               -  
               -        if (!tpacpi_bluetooth_rfkill)
               -                return;
               -  
               -        status = bluetooth_get_radiosw();
               -        if (status < 0)
               -                return;
               -        rfkill_force_state(tpacpi_bluetooth_rfkill, status);
               -  
               -        vdbg_printk(TPACPI_DBG_RFKILL,
               -                "forced rfkill state to %d\n",
               -                status);
 +++++++++++++++++                      TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
                  }
                  
 -------------- --static void bluetooth_update_rfk(void)
               -  static int bluetooth_set_radiosw(int radio_on, int update_rfk)
 +++++++++++++++++static int bluetooth_set_status(enum tpacpi_rfkill_state state)
                  {
                        int status;
                  
 -------------- --      if (!tpacpi_bluetooth_rfkill)
 -------------- --              return;
 -------------- --
 -------------- --      status = bluetooth_get_radiosw();
 -------------- --      if (status < 0)
 -------------- --              return;
 -------------- --      rfkill_force_state(tpacpi_bluetooth_rfkill, status);
 -------------- --
               -        if (!tp_features.bluetooth)
               -                return -ENODEV;
               -  
               -        /* WLSW overrides bluetooth in firmware/hardware, but there is no
               -         * reason to risk weird behaviour. */
               -        if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&status) && !status
               -            && radio_on)
               -                return -EPERM;
               -  
                        vdbg_printk(TPACPI_DBG_RFKILL,
 -------------- --              "forced rfkill state to %d\n",
 -------------- --              status);
 -------------- --}
 -------------- --
 -------------- --static int bluetooth_set_radiosw(int radio_on, int update_rfk)
 -------------- --{
 -------------- --      int status;
 -------------- --
 -------------- --      if (!tp_features.bluetooth)
 -------------- --              return -ENODEV;
 -------------- --
 -------------- --      /* WLSW overrides bluetooth in firmware/hardware, but there is no
 -------------- --       * reason to risk weird behaviour. */
 -------------- --      if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&status) && !status
 -------------- --          && radio_on)
 -------------- --              return -EPERM;
 -------------- --
 -------------- --      vdbg_printk(TPACPI_DBG_RFKILL,
 -----------------              "will %s bluetooth\n", radio_on ? "enable" : "disable");
 +++++++++++++++++              "will attempt to %s bluetooth\n",
 +++++++++++++++++              (state == TPACPI_RFK_RADIO_ON) ? "enable" : "disable");
                  
                  #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
                        if (dbg_bluetoothemul) {
                                return -EIO;
                  
                        return ((status & TP_ACPI_UWB_RADIOSSW) != 0) ?
 -----------------              RFKILL_STATE_UNBLOCKED : RFKILL_STATE_SOFT_BLOCKED;
               -  }
               -  
               -  static void uwb_update_rfk(void)
               -  {
               -        int status;
               -  
               -        if (!tpacpi_uwb_rfkill)
               -                return;
               -  
               -        status = uwb_get_radiosw();
               -        if (status < 0)
               -                return;
               -        rfkill_force_state(tpacpi_uwb_rfkill, status);
               -  
               -        vdbg_printk(TPACPI_DBG_RFKILL,
               -                "forced rfkill state to %d\n",
               -                status);
 +++++++++++++++++                      TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
                  }
                  
 -------------- --static void uwb_update_rfk(void)
               -  static int uwb_set_radiosw(int radio_on, int update_rfk)
 +++++++++++++++++static int uwb_set_status(enum tpacpi_rfkill_state state)
                  {
                        int status;
                  
 -------------- --      if (!tpacpi_uwb_rfkill)
 -------------- --              return;
 -------------- --
 -------------- --      status = uwb_get_radiosw();
 -------------- --      if (status < 0)
 -------------- --              return;
 -------------- --      rfkill_force_state(tpacpi_uwb_rfkill, status);
 -------------- --
 -------------- --      vdbg_printk(TPACPI_DBG_RFKILL,
 -------------- --              "forced rfkill state to %d\n",
 -------------- --              status);
 -------------- --}
 -------------- --
 -------------- --static int uwb_set_radiosw(int radio_on, int update_rfk)
 -------------- --{
 -------------- --      int status;
 -------------- --
 -----------------      if (!tp_features.uwb)
 -----------------              return -ENODEV;
 -----------------
 -----------------      /* WLSW overrides UWB in firmware/hardware, but there is no
 -----------------       * reason to risk weird behaviour. */
 -----------------      if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&status) && !status
 -----------------          && radio_on)
 -----------------              return -EPERM;
 -----------------
                        vdbg_printk(TPACPI_DBG_RFKILL,
 -----------------                      "will %s UWB\n", radio_on ? "enable" : "disable");
 +++++++++++++++++              "will attempt to %s UWB\n",
 +++++++++++++++++              (state == TPACPI_RFK_RADIO_ON) ? "enable" : "disable");
                  
                  #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
                        if (dbg_uwbemul) {
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
diff --cc init/main.c
Simple merge