ACPI: SBS: Split host controller (ACPI0001) from SBS driver (ACPI0002)

Replace poll-based host controller driver with the notify-based one.
Split it out of sbs.c.
Signed-off-by: Alexey Starikovskiy <astarikovskiy@suse.de>
Signed-off-by: Len Brown <len.brown@intel.com>

1 files changed, 75 insertions, 299 deletions

diff --git a/drivers/acpi/sbs.c b/drivers/acpi/sbs.c
index 33ba4bf551ef..7bb8c62fb92c 100644
--- a/drivers/acpi/sbs.c
+++ b/drivers/acpi/sbs.c
@@ -34,6 +34,8 @@
 #include <linux/jiffies.h>
 #include <linux/delay.h>
 
+#include "sbshc.h"
+
 #define ACPI_SBS_COMPONENT              0x00080000
 #define ACPI_SBS_CLASS                  "sbs"
 #define ACPI_AC_CLASS                   "ac_adapter"
@@ -59,28 +61,6 @@ MODULE_AUTHOR("Rich Townsend");
 MODULE_DESCRIPTION("Smart Battery System ACPI interface driver");
 MODULE_LICENSE("GPL");
 
-#define xmsleep(t)      msleep(t)
-
-#define ACPI_EC_SMB_PRTCL       0x00    /* protocol, PEC */
-
-#define ACPI_EC_SMB_STS         0x01    /* status */
-#define ACPI_EC_SMB_ADDR        0x02    /* address */
-#define ACPI_EC_SMB_CMD         0x03    /* command */
-#define ACPI_EC_SMB_DATA        0x04    /* 32 data registers */
-#define ACPI_EC_SMB_BCNT        0x24    /* number of data bytes */
-
-#define ACPI_EC_SMB_STS_DONE    0x80
-#define ACPI_EC_SMB_STS_STATUS  0x1f
-
-#define ACPI_EC_SMB_PRTCL_WRITE         0x00
-#define ACPI_EC_SMB_PRTCL_READ          0x01
-#define ACPI_EC_SMB_PRTCL_WORD_DATA     0x08
-#define ACPI_EC_SMB_PRTCL_BLOCK_DATA    0x0a
-
-#define ACPI_EC_SMB_TRANSACTION_SLEEP   1
-#define ACPI_EC_SMB_ACCESS_SLEEP1       1
-#define ACPI_EC_SMB_ACCESS_SLEEP2       10
-
 #define DEF_CAPACITY_UNIT       3
 #define MAH_CAPACITY_UNIT       1
 #define MWH_CAPACITY_UNIT       2
@@ -103,12 +83,6 @@ extern void acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
 #define MAX_SBS_BAT                     4
 #define ACPI_SBS_BLOCK_MAX              32
 
-#define ACPI_SBS_SMBUS_READ             1
-#define ACPI_SBS_SMBUS_WRITE            2
-
-#define ACPI_SBS_WORD_DATA              1
-#define ACPI_SBS_BLOCK_DATA             2
-
 #define UPDATE_DELAY    10
 
 /* 0 - every time, > 0 - by update_time */
@@ -124,8 +98,7 @@ static int acpi_sbs_remove(struct acpi_device *device, int type);
 static int acpi_sbs_resume(struct acpi_device *device);
 
 static const struct acpi_device_id sbs_device_ids[] = {
-        {"ACPI0001", 0},
-        {"ACPI0005", 0},
+        {"ACPI0002", 0},
         {"", 0},
 };
 MODULE_DEVICE_TABLE(acpi, sbs_device_ids);
@@ -182,8 +155,8 @@ struct acpi_battery {
 };
 
 struct acpi_sbs {
-        int base;
         struct acpi_device *device;
+        struct acpi_smb_hc *hc;
         struct mutex mutex;
         int sbsm_present;
         int sbsm_batteries_supported;
@@ -199,190 +172,6 @@ struct acpi_sbs {
 static int acpi_sbs_update_run(struct acpi_sbs *sbs, int id, int data_type);
 static void acpi_sbs_update_time(void *data);
 
-union sbs_rw_data {
-        u16 word;
-        u8 block[ACPI_SBS_BLOCK_MAX + 2];
-};
-
-static int acpi_ec_sbs_access(struct acpi_sbs *sbs, u16 addr,
-                              char read_write, u8 command, int size,
-                              union sbs_rw_data *data);
-
-/* --------------------------------------------------------------------------
-                               SMBus Communication
-   -------------------------------------------------------------------------- */
-
-static int acpi_ec_sbs_read(struct acpi_sbs *sbs, u8 address, u8 * data)
-{
-        u8 val;
-        int err;
-
-        err = ec_read(sbs->base + address, &val);
-        if (!err) {
-                *data = val;
-        }
-        xmsleep(ACPI_EC_SMB_TRANSACTION_SLEEP);
-        return (err);
-}
-
-static int acpi_ec_sbs_write(struct acpi_sbs *sbs, u8 address, u8 data)
-{
-        int err;
-
-        err = ec_write(sbs->base + address, data);
-        return (err);
-}
-
-static int
-acpi_ec_sbs_access(struct acpi_sbs *sbs, u16 addr,
-                   char read_write, u8 command, int size,
-                   union sbs_rw_data *data)
-{
-        unsigned char protocol, len = 0, temp[2] = { 0, 0 };
-        int i;
-
-        if (read_write == ACPI_SBS_SMBUS_READ) {
-                protocol = ACPI_EC_SMB_PRTCL_READ;
-        } else {
-                protocol = ACPI_EC_SMB_PRTCL_WRITE;
-        }
-
-        switch (size) {
-
-        case ACPI_SBS_WORD_DATA:
-                acpi_ec_sbs_write(sbs, ACPI_EC_SMB_CMD, command);
-                if (read_write == ACPI_SBS_SMBUS_WRITE) {
-                        acpi_ec_sbs_write(sbs, ACPI_EC_SMB_DATA, data->word);
-                        acpi_ec_sbs_write(sbs, ACPI_EC_SMB_DATA + 1,
-                                          data->word >> 8);
-                }
-                protocol |= ACPI_EC_SMB_PRTCL_WORD_DATA;
-                break;
-        case ACPI_SBS_BLOCK_DATA:
-                acpi_ec_sbs_write(sbs, ACPI_EC_SMB_CMD, command);
-                if (read_write == ACPI_SBS_SMBUS_WRITE) {
-                        len = min_t(u8, data->block[0], 32);
-                        acpi_ec_sbs_write(sbs, ACPI_EC_SMB_BCNT, len);
-                        for (i = 0; i < len; i++)
-                                acpi_ec_sbs_write(sbs, ACPI_EC_SMB_DATA + i,
-                                                  data->block[i + 1]);
-                }
-                protocol |= ACPI_EC_SMB_PRTCL_BLOCK_DATA;
-                break;
-        default:
-                ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "unsupported transaction %d", size));
-                return (-1);
-        }
-
-        acpi_ec_sbs_write(sbs, ACPI_EC_SMB_ADDR, addr << 1);
-        acpi_ec_sbs_write(sbs, ACPI_EC_SMB_PRTCL, protocol);
-
-        acpi_ec_sbs_read(sbs, ACPI_EC_SMB_STS, temp);
-
-        if (~temp[0] & ACPI_EC_SMB_STS_DONE) {
-                xmsleep(ACPI_EC_SMB_ACCESS_SLEEP1);
-                acpi_ec_sbs_read(sbs, ACPI_EC_SMB_STS, temp);
-        }
-        if (~temp[0] & ACPI_EC_SMB_STS_DONE) {
-                xmsleep(ACPI_EC_SMB_ACCESS_SLEEP2);
-                acpi_ec_sbs_read(sbs, ACPI_EC_SMB_STS, temp);
-        }
-        if ((~temp[0] & ACPI_EC_SMB_STS_DONE)
-            || (temp[0] & ACPI_EC_SMB_STS_STATUS)) {
-                ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "transaction %d error", size));
-                return (-1);
-        }
-
-        if (read_write == ACPI_SBS_SMBUS_WRITE) {
-                return (0);
-        }
-
-        switch (size) {
-
-        case ACPI_SBS_WORD_DATA:
-                acpi_ec_sbs_read(sbs, ACPI_EC_SMB_DATA, temp);
-                acpi_ec_sbs_read(sbs, ACPI_EC_SMB_DATA + 1, temp + 1);
-                data->word = (temp[1] << 8) | temp[0];
-                break;
-
-        case ACPI_SBS_BLOCK_DATA:
-                len = 0;
-                acpi_ec_sbs_read(sbs, ACPI_EC_SMB_BCNT, &len);
-                len = min_t(u8, len, 32);
-                for (i = 0; i < len; i++)
-                        acpi_ec_sbs_read(sbs, ACPI_EC_SMB_DATA + i,
-                                         data->block + i + 1);
-                data->block[0] = len;
-                break;
-        default:
-                ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "unsupported transaction %d", size));
-                return (-1);
-        }
-
-        return (0);
-}
-
-static int
-acpi_sbs_read_word(struct acpi_sbs *sbs, int addr, int func, u16 * word)
-{
-        union sbs_rw_data data;
-        int result = 0;
-
-        result = acpi_ec_sbs_access(sbs, addr,
-                                    ACPI_SBS_SMBUS_READ, func,
-                                    ACPI_SBS_WORD_DATA, &data);
-        if (result) {
-                ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_ec_sbs_access() failed"));
-        } else {
-                *word = data.word;
-        }
-
-        return result;
-}
-
-static int
-acpi_sbs_read_str(struct acpi_sbs *sbs, int addr, int func, char *str)
-{
-        union sbs_rw_data data;
-        int result = 0;
-
-        result = acpi_ec_sbs_access(sbs, addr,
-                                    ACPI_SBS_SMBUS_READ, func,
-                                    ACPI_SBS_BLOCK_DATA, &data);
-        if (result) {
-                ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_ec_sbs_access() failed"));
-        } else {
-                strncpy(str, (const char *)data.block + 1, data.block[0]);
-                str[data.block[0]] = 0;
-        }
-
-        return result;
-}
-
-static int
-acpi_sbs_write_word(struct acpi_sbs *sbs, int addr, int func, int word)
-{
-        union sbs_rw_data data;
-        int result = 0;
-
-        data.word = word;
-
-        result = acpi_ec_sbs_access(sbs, addr,
-                                    ACPI_SBS_SMBUS_WRITE, func,
-                                    ACPI_SBS_WORD_DATA, &data);
-        if (result) {
-                ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_ec_sbs_access() failed"));
-        }
-
-        return result;
-}
-
 static int sbs_zombie(struct acpi_sbs *sbs)
 {
         return (sbs->zombie);
@@ -433,11 +222,11 @@ static int acpi_battery_get_present(struct acpi_battery *battery)
         int result = 0;
         int is_present = 0;
 
-        result = acpi_sbs_read_word(battery->sbs,
-                                    ACPI_SBSM_SMBUS_ADDR, 0x01, &state);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD,
+                                    ACPI_SBSM_SMBUS_ADDR, 0x01, (u8 *)&state);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
         }
         if (!result) {
                 is_present = (state & 0x000f) & (1 << battery->id);
@@ -461,19 +250,19 @@ static int acpi_battery_select(struct acpi_battery *battery)
                  * it causes charging to halt on SBSELs */
 
                 result =
-                    acpi_sbs_read_word(sbs, ACPI_SBSM_SMBUS_ADDR, 0x01, &state);
+                    acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SBSM_SMBUS_ADDR, 0x01, (u8 *)&state);
                 if (result) {
                         ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                        "acpi_sbs_read_word() failed"));
+                                        "acpi_smbus_read() failed"));
                         goto end;
                 }
 
                 foo = (state & 0x0fff) | (1 << (battery->id + 12));
                 result =
-                    acpi_sbs_write_word(sbs, ACPI_SBSM_SMBUS_ADDR, 0x01, foo);
+                    acpi_smbus_write(battery->sbs->hc, SMBUS_WRITE_WORD, ACPI_SBSM_SMBUS_ADDR, 0x01, (u8 *)&foo, 2);
                 if (result) {
                         ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                        "acpi_sbs_write_word() failed"));
+                                        "acpi_smbus_write() failed"));
                         goto end;
                 }
         }
@@ -487,11 +276,11 @@ static int acpi_sbsm_get_info(struct acpi_sbs *sbs)
         int result = 0;
         s16 battery_system_info;
 
-        result = acpi_sbs_read_word(sbs, ACPI_SBSM_SMBUS_ADDR, 0x04,
-                                    &battery_system_info);
+        result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBSM_SMBUS_ADDR, 0x04,
+                                    (u8 *)&battery_system_info);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
                 goto end;
         }
         sbs->sbsm_present = 1;
@@ -504,50 +293,49 @@ static int acpi_sbsm_get_info(struct acpi_sbs *sbs)
 
 static int acpi_battery_get_info(struct acpi_battery *battery)
 {
-        struct acpi_sbs *sbs = battery->sbs;
         int result = 0;
         s16 battery_mode;
         s16 specification_info;
 
-        result = acpi_sbs_read_word(sbs, ACPI_SB_SMBUS_ADDR, 0x03,
-                                    &battery_mode);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x03,
+                                    (u8 *)&battery_mode);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
                 goto end;
         }
         battery->info.capacity_mode = (battery_mode & 0x8000) >> 15;
 
-        result = acpi_sbs_read_word(sbs, ACPI_SB_SMBUS_ADDR, 0x10,
-                                    &battery->info.full_charge_capacity);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x10,
+                                    (u8 *)&battery->info.full_charge_capacity);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
                 goto end;
         }
 
-        result = acpi_sbs_read_word(sbs, ACPI_SB_SMBUS_ADDR, 0x18,
-                                    &battery->info.design_capacity);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x18,
+                                    (u8 *)&battery->info.design_capacity);
 
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
                 goto end;
         }
 
-        result = acpi_sbs_read_word(sbs, ACPI_SB_SMBUS_ADDR, 0x19,
-                                    &battery->info.design_voltage);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x19,
+                                    (u8 *)&battery->info.design_voltage);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
                 goto end;
         }
 
-        result = acpi_sbs_read_word(sbs, ACPI_SB_SMBUS_ADDR, 0x1a,
-                                    &specification_info);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x1a,
+                                    (u8 *)&specification_info);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
                 goto end;
         }
 
@@ -579,32 +367,32 @@ static int acpi_battery_get_info(struct acpi_battery *battery)
                 battery->info.ipscale = 1;
         }
 
-        result = acpi_sbs_read_word(sbs, ACPI_SB_SMBUS_ADDR, 0x1c,
-                                    &battery->info.serial_number);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x1c,
+                                    (u8 *)&battery->info.serial_number);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
                 goto end;
         }
 
-        result = acpi_sbs_read_str(sbs, ACPI_SB_SMBUS_ADDR, 0x20,
-                                   battery->info.manufacturer_name);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_BLOCK, ACPI_SB_SMBUS_ADDR, 0x20,
+                                   (u8 *)battery->info.manufacturer_name);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
                                 "acpi_sbs_read_str() failed"));
                 goto end;
         }
 
-        result = acpi_sbs_read_str(sbs, ACPI_SB_SMBUS_ADDR, 0x21,
-                                   battery->info.device_name);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_BLOCK, ACPI_SB_SMBUS_ADDR, 0x21,
+                                   (u8 *)battery->info.device_name);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
                                 "acpi_sbs_read_str() failed"));
                 goto end;
         }
 
-        result = acpi_sbs_read_str(sbs, ACPI_SB_SMBUS_ADDR, 0x22,
-                                   battery->info.device_chemistry);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_BLOCK, ACPI_SB_SMBUS_ADDR, 0x22,
+                                   (u8 *)battery->info.device_chemistry);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
                                 "acpi_sbs_read_str() failed"));
@@ -617,38 +405,37 @@ static int acpi_battery_get_info(struct acpi_battery *battery)
 
 static int acpi_battery_get_state(struct acpi_battery *battery)
 {
-        struct acpi_sbs *sbs = battery->sbs;
         int result = 0;
 
-        result = acpi_sbs_read_word(sbs, ACPI_SB_SMBUS_ADDR, 0x09,
-                                    &battery->state.voltage);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x09,
+                                    (u8 *)&battery->state.voltage);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
                 goto end;
         }
 
-        result = acpi_sbs_read_word(sbs, ACPI_SB_SMBUS_ADDR, 0x0a,
-                                    &battery->state.amperage);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x0a,
+                                    (u8 *)&battery->state.amperage);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
                 goto end;
         }
 
-        result = acpi_sbs_read_word(sbs, ACPI_SB_SMBUS_ADDR, 0x0f,
-                                    &battery->state.remaining_capacity);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x0f,
+                                    (u8 *)&battery->state.remaining_capacity);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
                 goto end;
         }
 
-        result = acpi_sbs_read_word(sbs, ACPI_SB_SMBUS_ADDR, 0x16,
-                                    &battery->state.battery_state);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x16,
+                                    (u8 *)&battery->state.battery_state);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
                 goto end;
         }
 
@@ -658,14 +445,13 @@ static int acpi_battery_get_state(struct acpi_battery *battery)
 
 static int acpi_battery_get_alarm(struct acpi_battery *battery)
 {
-        struct acpi_sbs *sbs = battery->sbs;
         int result = 0;
 
-        result = acpi_sbs_read_word(sbs, ACPI_SB_SMBUS_ADDR, 0x01,
-                                    &battery->alarm.remaining_capacity);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x01,
+                                    (u8 *)&battery->alarm.remaining_capacity);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
                 goto end;
         }
 
@@ -677,7 +463,6 @@ static int acpi_battery_get_alarm(struct acpi_battery *battery)
 static int acpi_battery_set_alarm(struct acpi_battery *battery,
                                   unsigned long alarm)
 {
-        struct acpi_sbs *sbs = battery->sbs;
         int result = 0;
         s16 battery_mode;
         int foo;
@@ -693,29 +478,30 @@ static int acpi_battery_set_alarm(struct acpi_battery *battery,
 
         if (alarm > 0) {
                 result =
-                    acpi_sbs_read_word(sbs, ACPI_SB_SMBUS_ADDR, 0x03,
-                                       &battery_mode);
+                    acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x03,
+                                       (u8 *)&battery_mode);
                 if (result) {
                         ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                        "acpi_sbs_read_word() failed"));
+                                        "acpi_smbus_read() failed"));
                         goto end;
                 }
 
+                battery_mode &= 0xbfff;
                 result =
-                    acpi_sbs_write_word(sbs, ACPI_SB_SMBUS_ADDR, 0x01,
-                                        battery_mode & 0xbfff);
+                    acpi_smbus_write(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x01,
+                                        (u8 *)&battery_mode, 2);
                 if (result) {
                         ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                        "acpi_sbs_write_word() failed"));
+                                        "acpi_smbus_write() failed"));
                         goto end;
                 }
         }
 
         foo = alarm / (battery->info.capacity_mode ? 10 : 1);
-        result = acpi_sbs_write_word(sbs, ACPI_SB_SMBUS_ADDR, 0x01, foo);
+        result = acpi_smbus_write(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x01, (u8 *)&foo, 2);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_write_word() failed"));
+                                "acpi_smbus_write() failed"));
                 goto end;
         }
 
@@ -726,7 +512,6 @@ static int acpi_battery_set_alarm(struct acpi_battery *battery,
 
 static int acpi_battery_set_mode(struct acpi_battery *battery)
 {
-        struct acpi_sbs *sbs = battery->sbs;
         int result = 0;
         s16 battery_mode;
 
@@ -734,11 +519,11 @@ static int acpi_battery_set_mode(struct acpi_battery *battery)
                 goto end;
         }
 
-        result = acpi_sbs_read_word(sbs,
-                                    ACPI_SB_SMBUS_ADDR, 0x03, &battery_mode);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD,
+                                    ACPI_SB_SMBUS_ADDR, 0x03, (u8 *)&battery_mode);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
                 goto end;
         }
 
@@ -747,19 +532,19 @@ static int acpi_battery_set_mode(struct acpi_battery *battery)
         } else {
                 battery_mode |= 0x8000;
         }
-        result = acpi_sbs_write_word(sbs,
-                                     ACPI_SB_SMBUS_ADDR, 0x03, battery_mode);
+        result = acpi_smbus_write(battery->sbs->hc, SMBUS_READ_WORD,
+                                     ACPI_SB_SMBUS_ADDR, 0x03, (u8 *)&battery_mode, 2);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_write_word() failed"));
+                                "acpi_smbus_write() failed"));
                 goto end;
         }
 
-        result = acpi_sbs_read_word(sbs,
-                                    ACPI_SB_SMBUS_ADDR, 0x03, &battery_mode);
+        result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD,
+                                    ACPI_SB_SMBUS_ADDR, 0x03, (u8 *)&battery_mode);
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
                 goto end;
         }
 
@@ -815,12 +600,12 @@ static int acpi_ac_get_present(struct acpi_sbs *sbs)
         int result = 0;
         s16 charger_status;
 
-        result = acpi_sbs_read_word(sbs, ACPI_SBC_SMBUS_ADDR, 0x13,
-                                    &charger_status);
+        result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBC_SMBUS_ADDR, 0x13,
+                                    (u8 *)&charger_status);
 
         if (result) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                "acpi_sbs_read_word() failed"));
+                                "acpi_smbus_read() failed"));
                 goto end;
         }
 
@@ -1614,15 +1399,6 @@ static int acpi_sbs_add(struct acpi_device *device)
         struct acpi_sbs *sbs = NULL;
         int result = 0, remove_result = 0;
         int id;
-        acpi_status status = AE_OK;
-        unsigned long val;
-
-        status =
-            acpi_evaluate_integer(device->handle, "_EC", NULL, &val);
-        if (ACPI_FAILURE(status)) {
-                ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Error obtaining _EC"));
-                return -EIO;
-        }
 
         sbs = kzalloc(sizeof(struct acpi_sbs), GFP_KERNEL);
         if (!sbs) {
@@ -1635,8 +1411,8 @@ static int acpi_sbs_add(struct acpi_device *device)
 
         sbs_mutex_lock(sbs);
 
-        sbs->base = 0xff & (val >> 8);
         sbs->device = device;
+        sbs->hc = acpi_driver_data(device->parent);
 
         strcpy(acpi_device_name(device), ACPI_SBS_DEVICE_NAME);
         strcpy(acpi_device_class(device), ACPI_SBS_CLASS);