// SPDX-License-Identifier: GPL-2.0+/* * Supports for the power IC on the Surface 3 tablet. * * (C) Copyright 2016-2018 Red Hat, Inc * (C) Copyright 2016-2018 Benjamin Tissoires <benjamin.tissoires@gmail.com> * (C) Copyright 2016 Stephen Just <stephenjust@gmail.com> * * This driver has been reverse-engineered by parsing the DSDT of the Surface 3 * and looking at the registers of the chips. * * The DSDT allowed to find out that: * - the driver is required for the ACPI BAT0 device to communicate to the chip * through an operation region. * - the various defines for the operation region functions to communicate with * this driver * - the DSM 3f99e367-6220-4955-8b0f-06ef2ae79412 allows to trigger ACPI * events to BAT0 (the code is all available in the DSDT). * * Further findings regarding the 2 chips declared in the MSHW0011 are: * - there are 2 chips declared: * . 0x22 seems to control the ADP1 line status (and probably the charger) * . 0x55 controls the battery directly * - the battery chip uses a SMBus protocol (using plain SMBus allows non * destructive commands): * . the commands/registers used are in the range 0x00..0x7F * . if bit 8 (0x80) is set in the SMBus command, the returned value is the * same as when it is not set. There is a high chance this bit is the * read/write * . the various registers semantic as been deduced by observing the register * dumps. */ #include <linux/acpi.h>#include <linux/bits.h>#include <linux/freezer.h>#include <linux/i2c.h>#include <linux/kernel.h>#include <linux/kthread.h>#include <linux/slab.h>#include <linux/types.h>#include <linux/uuid.h>#include <linux/unaligned.h> #define SURFACE_3_POLL_INTERVAL (2 * HZ)#define SURFACE_3_STRLEN 10 struct mshw0011_data { struct i2c_client *adp1; struct i2c_client *bat0; unsigned short notify_mask; struct task_struct *poll_task; bool kthread_running; bool charging; bool bat_charging; u8 trip_point; s32 full_capacity;}; struct mshw0011_handler_data { struct acpi_connection_info info; struct i2c_client *client;}; struct bix { u32 revision; u32 power_unit; u32 design_capacity; u32 last_full_charg_capacity; u32 battery_technology; u32 design_voltage; u32 design_capacity_of_warning; u32 design_capacity_of_low; u32 cycle_count; u32 measurement_accuracy; u32 max_sampling_time; u32 min_sampling_time; u32 max_average_interval; u32 min_average_interval; u32 battery_capacity_granularity_1; u32 battery_capacity_granularity_2; char model[SURFACE_3_STRLEN]; char serial[SURFACE_3_STRLEN]; char type[SURFACE_3_STRLEN]; char OEM[SURFACE_3_STRLEN];} __packed; struct bst { u32 battery_state; s32 battery_present_rate; u32 battery_remaining_capacity; u32 battery_present_voltage;} __packed; struct gsb_command { u8 arg0; u8 arg1; u8 arg2;} __packed; struct gsb_buffer { u8 status; u8 len; u8 ret; union { struct gsb_command cmd; struct bst bst; struct bix bix; } __packed;} __packed; #define ACPI_BATTERY_STATE_DISCHARGING BIT(0)#define ACPI_BATTERY_STATE_CHARGING BIT(1)#define ACPI_BATTERY_STATE_CRITICAL BIT(2) #define MSHW0011_CMD_DEST_BAT0 0x01#define MSHW0011_CMD_DEST_ADP1 0x03 #define MSHW0011_CMD_BAT0_STA 0x01#define MSHW0011_CMD_BAT0_BIX 0x02#define MSHW0011_CMD_BAT0_BCT 0x03#define MSHW0011_CMD_BAT0_BTM 0x04#define MSHW0011_CMD_BAT0_BST 0x05#define MSHW0011_CMD_BAT0_BTP 0x06#define MSHW0011_CMD_ADP1_PSR 0x07#define MSHW0011_CMD_BAT0_PSOC 0x09#define MSHW0011_CMD_BAT0_PMAX 0x0a#define MSHW0011_CMD_BAT0_PSRC 0x0b#define MSHW0011_CMD_BAT0_CHGI 0x0c#define MSHW0011_CMD_BAT0_ARTG 0x0d #define MSHW0011_NOTIFY_GET_VERSION 0x00#define MSHW0011_NOTIFY_ADP1 0x01#define MSHW0011_NOTIFY_BAT0_BST 0x02#define MSHW0011_NOTIFY_BAT0_BIX 0x05 #define MSHW0011_ADP1_REG_PSR 0x04 #define MSHW0011_BAT0_REG_CAPACITY 0x0c#define MSHW0011_BAT0_REG_FULL_CHG_CAPACITY 0x0e#define MSHW0011_BAT0_REG_DESIGN_CAPACITY 0x40#define MSHW0011_BAT0_REG_VOLTAGE 0x08#define MSHW0011_BAT0_REG_RATE 0x14#define MSHW0011_BAT0_REG_OEM 0x45#define MSHW0011_BAT0_REG_TYPE 0x4e#define MSHW0011_BAT0_REG_SERIAL_NO 0x56#define MSHW0011_BAT0_REG_CYCLE_CNT 0x6e #define MSHW0011_EV_2_5_MASK GENMASK(8, 0) /* 3f99e367-6220-4955-8b0f-06ef2ae79412 */static const guid_t mshw0011_guid = GUID_INIT(0x3F99E367, 0x6220, 0x4955, 0x8B, 0x0F, 0x06, 0xEF, 0x2A, 0xE7, 0x94, 0x12); static intmshw0011_notify(struct mshw0011_data *cdata, u8 arg1, u8 arg2, unsigned int *ret_value){ union acpi_object *obj; acpi_handle handle; unsigned int i; handle = ACPI_HANDLE(&cdata->adp1->dev); if (!handle) return -ENODEV; obj = acpi_evaluate_dsm_typed(handle, &mshw0011_guid, arg1, arg2, NULL, ACPI_TYPE_BUFFER); if (!obj) { dev_err(&cdata->adp1->dev, "device _DSM execution failed\n"); return -ENODEV; } *ret_value = 0; for (i = 0; i < obj->buffer.length; i++) *ret_value |= obj->buffer.pointer[i] << (i * 8); ACPI_FREE(obj); return 0;} static const struct bix default_bix = { .revision = 0x00, .power_unit = 0x01, .design_capacity = 0x1dca, .last_full_charg_capacity = 0x1dca, .battery_technology = 0x01, .design_voltage = 0x10df, .design_capacity_of_warning = 0x8f, .design_capacity_of_low = 0x47, .cycle_count = 0xffffffff, .measurement_accuracy = 0x00015f90, .max_sampling_time = 0x03e8, .min_sampling_time = 0x03e8, .max_average_interval = 0x03e8, .min_average_interval = 0x03e8, .battery_capacity_granularity_1 = 0x45, .battery_capacity_granularity_2 = 0x11, .model = "P11G8M", .serial = "", .type = "LION", .OEM = "",}; static int mshw0011_bix(struct mshw0011_data *cdata, struct bix *bix){ struct i2c_client *client = cdata->bat0; char buf[SURFACE_3_STRLEN]; int ret; *bix = default_bix; /* get design capacity */ ret = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_DESIGN_CAPACITY); if (ret < 0) { dev_err(&client->dev, "Error reading design capacity: %d\n", ret); return ret; } bix->design_capacity = ret; /* get last full charge capacity */ ret = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_FULL_CHG_CAPACITY); if (ret < 0) { dev_err(&client->dev, "Error reading last full charge capacity: %d\n", ret); return ret; } bix->last_full_charg_capacity = ret; /* * Get serial number, on some devices (with unofficial replacement * battery?) reading any of the serial number range addresses gets * nacked in this case just leave the serial number empty. */ ret = i2c_smbus_read_i2c_block_data(client, MSHW0011_BAT0_REG_SERIAL_NO, sizeof(buf), buf); if (ret == -EREMOTEIO) { /* no serial number available */ } else if (ret != sizeof(buf)) { dev_err(&client->dev, "Error reading serial no: %d\n", ret); return ret; } else { snprintf(bix->serial, ARRAY_SIZE(bix->serial), "%3pE%6pE", buf + 7, buf); } /* get cycle count */ ret = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_CYCLE_CNT); if (ret < 0) { dev_err(&client->dev, "Error reading cycle count: %d\n", ret); return ret; } bix->cycle_count = ret; /* get OEM name */ ret = i2c_smbus_read_i2c_block_data(client, MSHW0011_BAT0_REG_OEM, 4, buf); if (ret != 4) { dev_err(&client->dev, "Error reading cycle count: %d\n", ret); return ret; } snprintf(bix->OEM, ARRAY_SIZE(bix->OEM), "%3pE", buf); return 0;} static int mshw0011_bst(struct mshw0011_data *cdata, struct bst *bst){ struct i2c_client *client = cdata->bat0; int rate, capacity, voltage, state; s16 tmp; rate = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_RATE); if (rate < 0) return rate; capacity = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_CAPACITY); if (capacity < 0) return capacity; voltage = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_VOLTAGE); if (voltage < 0) return voltage; tmp = rate; bst->battery_present_rate = abs((s32)tmp); state = 0; if ((s32) tmp > 0) state |= ACPI_BATTERY_STATE_CHARGING; else if ((s32) tmp < 0) state |= ACPI_BATTERY_STATE_DISCHARGING; bst->battery_state = state; bst->battery_remaining_capacity = capacity; bst->battery_present_voltage = voltage; return 0;} static int mshw0011_adp_psr(struct mshw0011_data *cdata){ return i2c_smbus_read_byte_data(cdata->adp1, MSHW0011_ADP1_REG_PSR);} static int mshw0011_isr(struct mshw0011_data *cdata){ struct bst bst; struct bix bix; int ret; bool status, bat_status; ret = mshw0011_adp_psr(cdata); if (ret < 0) return ret; status = ret; if (status != cdata->charging) mshw0011_notify(cdata, cdata->notify_mask, MSHW0011_NOTIFY_ADP1, &ret); cdata->charging = status; ret = mshw0011_bst(cdata, &bst); if (ret < 0) return ret; bat_status = bst.battery_state; if (bat_status != cdata->bat_charging) mshw0011_notify(cdata, cdata->notify_mask, MSHW0011_NOTIFY_BAT0_BST, &ret); cdata->bat_charging = bat_status; ret = mshw0011_bix(cdata, &bix); if (ret < 0) return ret; if (bix.last_full_charg_capacity != cdata->full_capacity) mshw0011_notify(cdata, cdata->notify_mask, MSHW0011_NOTIFY_BAT0_BIX, &ret); cdata->full_capacity = bix.last_full_charg_capacity; return 0;} static int mshw0011_poll_task(void *data){ struct mshw0011_data *cdata = data; int ret = 0; cdata->kthread_running = true; set_freezable(); while (!kthread_should_stop()) { schedule_timeout_interruptible(SURFACE_3_POLL_INTERVAL); try_to_freeze(); ret = mshw0011_isr(data); if (ret) break; } cdata->kthread_running = false; return ret;} static acpi_statusmshw0011_space_handler(u32 function, acpi_physical_address command, u32 bits, u64 *value64, void *handler_context, void *region_context){ struct gsb_buffer *gsb = (struct gsb_buffer *)value64; struct mshw0011_handler_data *data = handler_context; struct acpi_connection_info *info = &data->info; struct acpi_resource_i2c_serialbus *sb; struct i2c_client *client = data->client; struct mshw0011_data *cdata = i2c_get_clientdata(client); struct acpi_resource *ares; u32 accessor_type = function >> 16; acpi_status ret; int status = 1; ret = acpi_buffer_to_resource(info->connection, info->length, &ares); if (ACPI_FAILURE(ret)) return ret; if (!value64 || !i2c_acpi_get_i2c_resource(ares, &sb)) { ret = AE_BAD_PARAMETER; goto err; } if (accessor_type != ACPI_GSB_ACCESS_ATTRIB_RAW_PROCESS) { ret = AE_BAD_PARAMETER; goto err; } if (gsb->cmd.arg0 == MSHW0011_CMD_DEST_ADP1 && gsb->cmd.arg1 == MSHW0011_CMD_ADP1_PSR) { status = mshw0011_adp_psr(cdata); if (status >= 0) { ret = AE_OK; goto out; } else { ret = AE_ERROR; goto err; } } if (gsb->cmd.arg0 != MSHW0011_CMD_DEST_BAT0) { ret = AE_BAD_PARAMETER; goto err; } switch (gsb->cmd.arg1) { case MSHW0011_CMD_BAT0_STA: break; case MSHW0011_CMD_BAT0_BIX: ret = mshw0011_bix(cdata, &gsb->bix); break; case MSHW0011_CMD_BAT0_BTP: cdata->trip_point = gsb->cmd.arg2; break; case MSHW0011_CMD_BAT0_BST: ret = mshw0011_bst(cdata, &gsb->bst); break; default: dev_info(&cdata->bat0->dev, "command(0x%02x) is not supported.\n", gsb->cmd.arg1); ret = AE_BAD_PARAMETER; goto err; } out: gsb->ret = status; gsb->status = 0; err: ACPI_FREE(ares); return ret;} static int mshw0011_install_space_handler(struct i2c_client *client){ struct acpi_device *adev; struct mshw0011_handler_data *data; acpi_status status; adev = ACPI_COMPANION(&client->dev); if (!adev) return -ENODEV; data = kzalloc_obj(struct mshw0011_handler_data); if (!data) return -ENOMEM; data->client = client; status = acpi_bus_attach_private_data(adev->handle, (void *)data); if (ACPI_FAILURE(status)) { kfree(data); return -ENOMEM; } status = acpi_install_address_space_handler(adev->handle, ACPI_ADR_SPACE_GSBUS, &mshw0011_space_handler, NULL, data); if (ACPI_FAILURE(status)) { dev_err(&client->dev, "Error installing i2c space handler\n"); acpi_bus_detach_private_data(adev->handle); kfree(data); return -ENOMEM; } acpi_dev_clear_dependencies(adev); return 0;} static void mshw0011_remove_space_handler(struct i2c_client *client){ struct mshw0011_handler_data *data; acpi_handle handle; acpi_status status; handle = ACPI_HANDLE(&client->dev); if (!handle) return; acpi_remove_address_space_handler(handle, ACPI_ADR_SPACE_GSBUS, &mshw0011_space_handler); status = acpi_bus_get_private_data(handle, (void **)&data); if (ACPI_SUCCESS(status)) kfree(data);Lines 1–500 of 586. Load more
// SPDX-License-Identifier: GPL-2.0+ /* * Supports for the power IC on the Surface 3 tablet. * * (C) Copyright 2016-2018 Red Hat, Inc * (C) Copyright 2016-2018 Benjamin Tissoires <benjamin.tissoires@gmail.com> * (C) Copyright 2016 Stephen Just <stephenjust@gmail.com> * * This driver has been reverse-engineered by parsing the DSDT of the Surface 3 * and looking at the registers of the chips. * * The DSDT allowed to find out that: * - the driver is required for the ACPI BAT0 device to communicate to the chip * through an operation region. * - the various defines for the operation region functions to communicate with * this driver * - the DSM 3f99e367-6220-4955-8b0f-06ef2ae79412 allows to trigger ACPI * events to BAT0 (the code is all available in the DSDT). * * Further findings regarding the 2 chips declared in the MSHW0011 are: * - there are 2 chips declared: * . 0x22 seems to control the ADP1 line status (and probably the charger) * . 0x55 controls the battery directly * - the battery chip uses a SMBus protocol (using plain SMBus allows non * destructive commands): * . the commands/registers used are in the range 0x00..0x7F * . if bit 8 (0x80) is set in the SMBus command, the returned value is the * same as when it is not set. There is a high chance this bit is the * read/write * . the various registers semantic as been deduced by observing the register * dumps. */ #include <linux/acpi.h> #include <linux/bits.h> #include <linux/freezer.h> #include <linux/i2c.h> #include <linux/kernel.h> #include <linux/kthread.h> #include <linux/slab.h> #include <linux/types.h> #include <linux/uuid.h> #include <linux/unaligned.h> #define SURFACE_3_POLL_INTERVAL (2 * HZ) #define SURFACE_3_STRLEN 10 struct mshw0011_data { struct i2c_client *adp1; struct i2c_client *bat0; unsigned short notify_mask; struct task_struct *poll_task; bool kthread_running; bool charging; bool bat_charging; u8 trip_point; s32 full_capacity; }; struct mshw0011_handler_data { struct acpi_connection_info info; struct i2c_client *client; }; struct bix { u32 revision; u32 power_unit; u32 design_capacity; u32 last_full_charg_capacity; u32 battery_technology; u32 design_voltage; u32 design_capacity_of_warning; u32 design_capacity_of_low; u32 cycle_count; u32 measurement_accuracy; u32 max_sampling_time; u32 min_sampling_time; u32 max_average_interval; u32 min_average_interval; u32 battery_capacity_granularity_1; u32 battery_capacity_granularity_2; char model[SURFACE_3_STRLEN]; char serial[SURFACE_3_STRLEN]; char type[SURFACE_3_STRLEN]; char OEM[SURFACE_3_STRLEN]; } __packed; struct bst { u32 battery_state; s32 battery_present_rate; u32 battery_remaining_capacity; u32 battery_present_voltage; } __packed; struct gsb_command { u8 arg0; u8 arg1; u8 arg2; } __packed; struct gsb_buffer { u8 status; u8 len; u8 ret; union { struct gsb_command cmd; struct bst bst; struct bix bix; } __packed; } __packed; #define ACPI_BATTERY_STATE_DISCHARGING BIT(0) #define ACPI_BATTERY_STATE_CHARGING BIT(1) #define ACPI_BATTERY_STATE_CRITICAL BIT(2) #define MSHW0011_CMD_DEST_BAT0 0x01 #define MSHW0011_CMD_DEST_ADP1 0x03 #define MSHW0011_CMD_BAT0_STA 0x01 #define MSHW0011_CMD_BAT0_BIX 0x02 #define MSHW0011_CMD_BAT0_BCT 0x03 #define MSHW0011_CMD_BAT0_BTM 0x04 #define MSHW0011_CMD_BAT0_BST 0x05 #define MSHW0011_CMD_BAT0_BTP 0x06 #define MSHW0011_CMD_ADP1_PSR 0x07 #define MSHW0011_CMD_BAT0_PSOC 0x09 #define MSHW0011_CMD_BAT0_PMAX 0x0a #define MSHW0011_CMD_BAT0_PSRC 0x0b #define MSHW0011_CMD_BAT0_CHGI 0x0c #define MSHW0011_CMD_BAT0_ARTG 0x0d #define MSHW0011_NOTIFY_GET_VERSION 0x00 #define MSHW0011_NOTIFY_ADP1 0x01 #define MSHW0011_NOTIFY_BAT0_BST 0x02 #define MSHW0011_NOTIFY_BAT0_BIX 0x05 #define MSHW0011_ADP1_REG_PSR 0x04 #define MSHW0011_BAT0_REG_CAPACITY 0x0c #define MSHW0011_BAT0_REG_FULL_CHG_CAPACITY 0x0e #define MSHW0011_BAT0_REG_DESIGN_CAPACITY 0x40 #define MSHW0011_BAT0_REG_VOLTAGE 0x08 #define MSHW0011_BAT0_REG_RATE 0x14 #define MSHW0011_BAT0_REG_OEM 0x45 #define MSHW0011_BAT0_REG_TYPE 0x4e #define MSHW0011_BAT0_REG_SERIAL_NO 0x56 #define MSHW0011_BAT0_REG_CYCLE_CNT 0x6e #define MSHW0011_EV_2_5_MASK GENMASK(8, 0) /* 3f99e367-6220-4955-8b0f-06ef2ae79412 */ static const guid_t mshw0011_guid = GUID_INIT(0x3F99E367, 0x6220, 0x4955, 0x8B, 0x0F, 0x06, 0xEF, 0x2A, 0xE7, 0x94, 0x12); static int mshw0011_notify(struct mshw0011_data *cdata, u8 arg1, u8 arg2, unsigned int *ret_value) { union acpi_object *obj; acpi_handle handle; unsigned int i; handle = ACPI_HANDLE(&cdata->adp1->dev); if (!handle) return -ENODEV; obj = acpi_evaluate_dsm_typed(handle, &mshw0011_guid, arg1, arg2, NULL, ACPI_TYPE_BUFFER); if (!obj) { dev_err(&cdata->adp1->dev, "device _DSM execution failed\n"); return -ENODEV; } *ret_value = 0; for (i = 0; i < obj->buffer.length; i++) *ret_value |= obj->buffer.pointer[i] << (i * 8); ACPI_FREE(obj); return 0; } static const struct bix default_bix = { .revision = 0x00, .power_unit = 0x01, .design_capacity = 0x1dca, .last_full_charg_capacity = 0x1dca, .battery_technology = 0x01, .design_voltage = 0x10df, .design_capacity_of_warning = 0x8f, .design_capacity_of_low = 0x47, .cycle_count = 0xffffffff, .measurement_accuracy = 0x00015f90, .max_sampling_time = 0x03e8, .min_sampling_time = 0x03e8, .max_average_interval = 0x03e8, .min_average_interval = 0x03e8, .battery_capacity_granularity_1 = 0x45, .battery_capacity_granularity_2 = 0x11, .model = "P11G8M", .serial = "", .type = "LION", .OEM = "", }; static int mshw0011_bix(struct mshw0011_data *cdata, struct bix *bix) { struct i2c_client *client = cdata->bat0; char buf[SURFACE_3_STRLEN]; int ret; *bix = default_bix; /* get design capacity */ ret = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_DESIGN_CAPACITY); if (ret < 0) { dev_err(&client->dev, "Error reading design capacity: %d\n", ret); return ret; } bix->design_capacity = ret; /* get last full charge capacity */ ret = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_FULL_CHG_CAPACITY); if (ret < 0) { dev_err(&client->dev, "Error reading last full charge capacity: %d\n", ret); return ret; } bix->last_full_charg_capacity = ret; /* * Get serial number, on some devices (with unofficial replacement * battery?) reading any of the serial number range addresses gets * nacked in this case just leave the serial number empty. */ ret = i2c_smbus_read_i2c_block_data(client, MSHW0011_BAT0_REG_SERIAL_NO, sizeof(buf), buf); if (ret == -EREMOTEIO) { /* no serial number available */ } else if (ret != sizeof(buf)) { dev_err(&client->dev, "Error reading serial no: %d\n", ret); return ret; } else { snprintf(bix->serial, ARRAY_SIZE(bix->serial), "%3pE%6pE", buf + 7, buf); } /* get cycle count */ ret = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_CYCLE_CNT); if (ret < 0) { dev_err(&client->dev, "Error reading cycle count: %d\n", ret); return ret; } bix->cycle_count = ret; /* get OEM name */ ret = i2c_smbus_read_i2c_block_data(client, MSHW0011_BAT0_REG_OEM, 4, buf); if (ret != 4) { dev_err(&client->dev, "Error reading cycle count: %d\n", ret); return ret; } snprintf(bix->OEM, ARRAY_SIZE(bix->OEM), "%3pE", buf); return 0; } static int mshw0011_bst(struct mshw0011_data *cdata, struct bst *bst) { struct i2c_client *client = cdata->bat0; int rate, capacity, voltage, state; s16 tmp; rate = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_RATE); if (rate < 0) return rate; capacity = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_CAPACITY); if (capacity < 0) return capacity; voltage = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_VOLTAGE); if (voltage < 0) return voltage; tmp = rate; bst->battery_present_rate = abs((s32)tmp); state = 0; if ((s32) tmp > 0) state |= ACPI_BATTERY_STATE_CHARGING; else if ((s32) tmp < 0) state |= ACPI_BATTERY_STATE_DISCHARGING; bst->battery_state = state; bst->battery_remaining_capacity = capacity; bst->battery_present_voltage = voltage; return 0; } static int mshw0011_adp_psr(struct mshw0011_data *cdata) { return i2c_smbus_read_byte_data(cdata->adp1, MSHW0011_ADP1_REG_PSR); } static int mshw0011_isr(struct mshw0011_data *cdata) { struct bst bst; struct bix bix; int ret; bool status, bat_status; ret = mshw0011_adp_psr(cdata); if (ret < 0) return ret; status = ret; if (status != cdata->charging) mshw0011_notify(cdata, cdata->notify_mask, MSHW0011_NOTIFY_ADP1, &ret); cdata->charging = status; ret = mshw0011_bst(cdata, &bst); if (ret < 0) return ret; bat_status = bst.battery_state; if (bat_status != cdata->bat_charging) mshw0011_notify(cdata, cdata->notify_mask, MSHW0011_NOTIFY_BAT0_BST, &ret); cdata->bat_charging = bat_status; ret = mshw0011_bix(cdata, &bix); if (ret < 0) return ret; if (bix.last_full_charg_capacity != cdata->full_capacity) mshw0011_notify(cdata, cdata->notify_mask, MSHW0011_NOTIFY_BAT0_BIX, &ret); cdata->full_capacity = bix.last_full_charg_capacity; return 0; } static int mshw0011_poll_task(void *data) { struct mshw0011_data *cdata = data; int ret = 0; cdata->kthread_running = true; set_freezable(); while (!kthread_should_stop()) { schedule_timeout_interruptible(SURFACE_3_POLL_INTERVAL); try_to_freeze(); ret = mshw0011_isr(data); if (ret) break; } cdata->kthread_running = false; return ret; } static acpi_status mshw0011_space_handler(u32 function, acpi_physical_address command, u32 bits, u64 *value64, void *handler_context, void *region_context) { struct gsb_buffer *gsb = (struct gsb_buffer *)value64; struct mshw0011_handler_data *data = handler_context; struct acpi_connection_info *info = &data->info; struct acpi_resource_i2c_serialbus *sb; struct i2c_client *client = data->client; struct mshw0011_data *cdata = i2c_get_clientdata(client); struct acpi_resource *ares; u32 accessor_type = function >> 16; acpi_status ret; int status = 1; ret = acpi_buffer_to_resource(info->connection, info->length, &ares); if (ACPI_FAILURE(ret)) return ret; if (!value64 || !i2c_acpi_get_i2c_resource(ares, &sb)) { ret = AE_BAD_PARAMETER; goto err; } if (accessor_type != ACPI_GSB_ACCESS_ATTRIB_RAW_PROCESS) { ret = AE_BAD_PARAMETER; goto err; } if (gsb->cmd.arg0 == MSHW0011_CMD_DEST_ADP1 && gsb->cmd.arg1 == MSHW0011_CMD_ADP1_PSR) { status = mshw0011_adp_psr(cdata); if (status >= 0) { ret = AE_OK; goto out; } else { ret = AE_ERROR; goto err; } } if (gsb->cmd.arg0 != MSHW0011_CMD_DEST_BAT0) { ret = AE_BAD_PARAMETER; goto err; } switch (gsb->cmd.arg1) { case MSHW0011_CMD_BAT0_STA: break; case MSHW0011_CMD_BAT0_BIX: ret = mshw0011_bix(cdata, &gsb->bix); break; case MSHW0011_CMD_BAT0_BTP: cdata->trip_point = gsb->cmd.arg2; break; case MSHW0011_CMD_BAT0_BST: ret = mshw0011_bst(cdata, &gsb->bst); break; default: dev_info(&cdata->bat0->dev, "command(0x%02x) is not supported.\n", gsb->cmd.arg1); ret = AE_BAD_PARAMETER; goto err; } out: gsb->ret = status; gsb->status = 0; err: ACPI_FREE(ares); return ret; } static int mshw0011_install_space_handler(struct i2c_client *client) { struct acpi_device *adev; struct mshw0011_handler_data *data; acpi_status status; adev = ACPI_COMPANION(&client->dev); if (!adev) return -ENODEV; data = kzalloc_obj(struct mshw0011_handler_data); if (!data) return -ENOMEM; data->client = client; status = acpi_bus_attach_private_data(adev->handle, (void *)data); if (ACPI_FAILURE(status)) { kfree(data); return -ENOMEM; } status = acpi_install_address_space_handler(adev->handle, ACPI_ADR_SPACE_GSBUS, &mshw0011_space_handler, NULL, data); if (ACPI_FAILURE(status)) { dev_err(&client->dev, "Error installing i2c space handler\n"); acpi_bus_detach_private_data(adev->handle); kfree(data); return -ENOMEM; } acpi_dev_clear_dependencies(adev); return 0; } static void mshw0011_remove_space_handler(struct i2c_client *client) { struct mshw0011_handler_data *data; acpi_handle handle; acpi_status status; handle = ACPI_HANDLE(&client->dev); if (!handle) return; acpi_remove_address_space_handler(handle, ACPI_ADR_SPACE_GSBUS, &mshw0011_space_handler); status = acpi_bus_get_private_data(handle, (void **)&data); if (ACPI_SUCCESS(status)) kfree(data);