linux-surface/patches/4.18/acpi.patch

diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index ac4d48830415..2025f56446a0 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -1158,6 +1158,15 @@ config SURFACE_3_BUTTON
 	---help---
 	  This driver handles the power/home/volume buttons on the Microsoft Surface 3 tablet.
 
+config ACPI_SURFACE
+	tristate "Microsoft Surface Extras"
+	depends on ACPI
+	depends on ACPI_WMI
+	depends on INPUT
+	---help---
+	  This driver adds support for access to certain system events
+	  on Microsoft Surface devices.
+
 config INTEL_PUNIT_IPC
 	tristate "Intel P-Unit IPC Driver"
 	---help---
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index 2ba6cb795338..8fd5b93bb20d 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -81,6 +81,9 @@ obj-$(CONFIG_INTEL_PMC_IPC)	+= intel_pmc_ipc.o
 obj-$(CONFIG_SILEAD_DMI)	+= silead_dmi.o
 obj-$(CONFIG_SURFACE_PRO3_BUTTON)	+= surfacepro3_button.o
 obj-$(CONFIG_SURFACE_3_BUTTON)	+= surface3_button.o
+obj-$(CONFIG_ACPI_SURFACE)	+= surface_acpi.o
+obj-$(CONFIG_ACPI_SURFACE)	+= surface_i2c.o
+obj-$(CONFIG_ACPI_SURFACE)	+= surface_platform.o
 obj-$(CONFIG_INTEL_PUNIT_IPC)  += intel_punit_ipc.o
 obj-$(CONFIG_INTEL_BXTWC_PMIC_TMU)	+= intel_bxtwc_tmu.o
 obj-$(CONFIG_INTEL_TELEMETRY)	+= intel_telemetry_core.o \
diff --git a/drivers/platform/x86/surface_acpi.c b/drivers/platform/x86/surface_acpi.c
new file mode 100644
index 000000000000..c969bda99464
--- /dev/null
+++ b/drivers/platform/x86/surface_acpi.c
@@ -0,0 +1,485 @@
+/*
+ *  surface_acpi.c - Microsoft Surface ACPI Driver
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  The full GNU General Public License is included in this distribution in
+ *  the file called "COPYING".
+ */
+
+#define SURFACE_ACPI_VERSION	"0.1"
+#define SURFACE_GEN_VERSION		0x08
+#define PROC_SURFACE			"surface"
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/acpi.h>
+#include <linux/power_supply.h>
+#include <linux/thermal.h>
+#include <linux/dmi.h>
+#include <linux/seq_file.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+#include "surface_acpi.h"
+
+#define SUR_METHOD_DSM			"_DSM"
+#define SUR_METHOD_REG			"_REG"
+#define SUR_METHOD_STA			"_STA"
+#define SUR_METHOD_INI			"_INI"
+#define SUR_METHOD_CRS			"_CRS"
+
+#define SUR_QUERY_DEVICE		0x00
+#define SUR_SET_DVER			0x01
+#define SUR_GET_BOARD_REVID		0x02
+#define SUR_BAT1_STATE_CHANGE	0x03
+#define SUR_BAT1_INFO_CHANGE	0x04
+#define SUR_PSU_STATE_CHANGE	0x05
+#define SUR_PSU_INFO_CHANGE		0x06
+#define SUR_BAT2_STATE_CHANGE	0x07
+#define SUR_BAT2_INFO_CHANGE	0x08
+#define SUR_SENSOR_TRIP_POINT	0x09
+
+#define REG_AVAILABLE			0x01
+#define REG_INIT				0x09
+
+static char SURFACE_EVENT_GUID[] = "93b666c5-70c6-469f-a215-3d487c91ab3c";
+static char SUR_SAN_RQST[] = "\\_SB._SAN.RQST";
+static char SUR_SAN_RQSX[] = "\\_SB._SAN.RQSX";
+
+struct surface_acpi_dev {
+	acpi_handle handle;
+	acpi_handle rqst_handle;
+	acpi_handle rqsx_handle;
+
+	struct acpi_device *san_dev;
+	struct acpi_device *ssh_dev;
+	struct acpi_device *bat1_dev;
+	struct acpi_device *bat2_dev;
+	struct acpi_device *psu_dev;
+
+	unsigned int bat1_attached:1;
+	unsigned int bat2_attached:1;
+	unsigned int psu_registered:1;
+};
+
+static struct surface_acpi_dev *surface_acpi;
+
+static struct proc_dir_entry *surface_proc_dir;
+
+static acpi_status surface_acpi_check_status(struct acpi_device *dev)
+{
+	unsigned long long value;
+	acpi_status status;
+
+	if (acpi_has_method(dev->handle, SUR_METHOD_STA)) {
+		status = acpi_evaluate_integer(dev->handle,
+				SUR_METHOD_STA, NULL, &value);
+
+		if (ACPI_FAILURE(status)) {
+			pr_err("surface_acpi: ACPI event failure status %s\n",
+					acpi_format_exception(status));
+			return AE_ERROR;
+		}
+	}
+	else
+		return AE_NOT_FOUND;
+
+	return AE_OK;
+}
+
+static acpi_status surface_acpi_san_reg(void)
+{
+	union acpi_object in_objs[2], out_objs[1];
+	struct acpi_object_list params;
+	struct acpi_buffer results;
+	acpi_status status;
+
+	params.count = ARRAY_SIZE(in_objs);
+	params.pointer = in_objs;
+	in_objs[0].type = ACPI_TYPE_INTEGER;
+	in_objs[0].integer.value = REG_INIT;
+	in_objs[1].type = ACPI_TYPE_INTEGER;
+	in_objs[1].integer.value = REG_AVAILABLE;
+	results.length = sizeof(out_objs);
+	results.pointer = out_objs;
+
+	if (acpi_has_method(surface_acpi->handle, SUR_METHOD_REG)) {
+		status = acpi_evaluate_object(surface_acpi->handle,
+				SUR_METHOD_REG, &params, &results);
+
+		if (ACPI_FAILURE(status)) {
+			pr_err("surface_acpi: ACPI event failure status %s\n",
+					acpi_format_exception(status));
+			return AE_ERROR;
+		}
+	}
+	else
+		return AE_NOT_FOUND;
+
+	return AE_OK;
+}
+
+acpi_status surface_acpi_event_handler(u32 event)
+{
+	union acpi_object in_objs[4], out_objs[5];
+	struct acpi_object_list params;
+	struct acpi_buffer results;
+	acpi_status status;
+
+	params.count = ARRAY_SIZE(in_objs);
+	params.pointer = in_objs;
+	in_objs[0].type = ACPI_TYPE_BUFFER;
+	in_objs[0].buffer.length = sizeof(SURFACE_EVENT_GUID);
+	in_objs[0].buffer.pointer = SURFACE_EVENT_GUID;
+	in_objs[1].type = ACPI_TYPE_INTEGER;
+	in_objs[1].integer.value = SUR_QUERY_DEVICE;
+	in_objs[2].type = ACPI_TYPE_INTEGER;
+	in_objs[2].integer.value = event;
+	in_objs[3].type = ACPI_TYPE_PACKAGE;
+	in_objs[3].package.count = 0;
+	in_objs[3].package.elements = SURFACE_GEN_VERSION;
+	results.length = sizeof(out_objs);
+	results.pointer = out_objs;
+
+	if (acpi_has_method(surface_acpi->handle, SUR_METHOD_DSM)) {
+		status = acpi_evaluate_object(surface_acpi->handle,
+				SUR_METHOD_DSM, &params, &results);
+
+		if (ACPI_FAILURE(status)) {
+			pr_err("surface_acpi: ACPI event failure status %s\n",
+					acpi_format_exception(status));
+			return AE_ERROR;
+		}
+	}
+	else
+		return AE_NOT_FOUND;
+
+	return AE_OK;
+}
+EXPORT_SYMBOL(surface_acpi_event_handler);
+
+static void surface_acpi_san_load(void)
+{
+	acpi_status ret;
+
+	ret = surface_acpi_event_handler(SUR_SET_DVER);
+	if (ACPI_FAILURE(ret))
+		pr_err("surface_acpi: Error setting Driver Version\n");
+
+	ret = surface_acpi_event_handler(SUR_SENSOR_TRIP_POINT);
+	if (ACPI_FAILURE(ret))
+		pr_err("surface_acpi: Error setting Sensor Trip Point\n");
+
+	ret = surface_acpi_event_handler(SUR_BAT1_INFO_CHANGE);
+	if (ACPI_FAILURE(ret))
+		pr_err("surface_acpi: Error attaching BAT1\n");
+	else
+		surface_acpi->bat1_attached = 1;
+
+	ret = surface_acpi_event_handler(SUR_BAT2_INFO_CHANGE);
+	if (ACPI_FAILURE(ret))
+		pr_err("surface_acpi: Error attaching BAT2\n");
+	else
+		surface_acpi->bat2_attached = 1;
+
+	ret = surface_acpi_event_handler(SUR_PSU_INFO_CHANGE);
+	if (ACPI_FAILURE(ret))
+		pr_err("surface_acpi: Error registering PSU\n");
+	else
+		surface_acpi->psu_registered = 1;
+}
+
+static acpi_status surface_acpi_ssh_initialize(void)
+{
+	acpi_status status;
+
+	if (acpi_has_method(surface_acpi->ssh_dev->handle, SUR_METHOD_INI)) {
+		status = acpi_evaluate_object(surface_acpi->ssh_dev->handle,
+				SUR_METHOD_INI, NULL, NULL);
+
+		if (ACPI_FAILURE(status)) {
+			pr_err("surface_acpi: ACPI event failure status %s\n",
+					acpi_format_exception(status));
+			return AE_ERROR;
+		}
+	}
+	else
+		return AE_NOT_FOUND;
+
+	return AE_OK;
+}
+
+static int bat1_proc_show(struct seq_file *m, void *v)
+{
+	seq_printf(m, "attached: %d\n", surface_acpi->bat1_attached);
+	return 0;
+}
+
+static int bat1_proc_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, bat1_proc_show, PDE_DATA(inode));
+}
+
+static const struct file_operations bat1_proc_fops = {
+	.owner		= THIS_MODULE,
+	.open		= bat1_proc_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= single_release,
+};
+
+static int bat2_proc_show(struct seq_file *m, void *v)
+{
+	seq_printf(m, "attached: %d\n", surface_acpi->bat2_attached);
+	return 0;
+}
+
+static int bat2_proc_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, bat2_proc_show, PDE_DATA(inode));
+}
+
+static const struct file_operations bat2_proc_fops = {
+	.owner		= THIS_MODULE,
+	.open		= bat2_proc_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= single_release,
+};
+
+static int psu_proc_show(struct seq_file *m, void *v)
+{
+	seq_printf(m, "registered: %d\n", surface_acpi->psu_registered);
+	return 0;
+}
+
+static int psu_proc_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, psu_proc_show, PDE_DATA(inode));
+}
+
+static const struct file_operations psu_proc_fops = {
+	.owner		= THIS_MODULE,
+	.open		= psu_proc_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= single_release,
+};
+
+static int version_proc_show(struct seq_file *m, void *v)
+{
+	seq_printf(m, "driver: %s\n", SURFACE_ACPI_VERSION);
+	return 0;
+}
+
+static int version_proc_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, version_proc_show, PDE_DATA(inode));
+}
+
+static const struct file_operations version_proc_fops = {
+	.owner		= THIS_MODULE,
+	.open		= version_proc_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= single_release,
+};
+
+static void create_surface_proc_entries(void)
+{
+	proc_create_data("BAT1", 0, surface_proc_dir,
+			 &bat1_proc_fops, surface_acpi->bat1_attached);
+	proc_create_data("BAT2", 0, surface_proc_dir,
+			 &bat2_proc_fops, surface_acpi->bat2_attached);
+	proc_create_data("ADP1", 0, surface_proc_dir,
+			 &psu_proc_fops, surface_acpi->psu_registered);
+	proc_create_data("version", 0, surface_proc_dir,
+			 &version_proc_fops, SURFACE_ACPI_VERSION);
+}
+
+static void remove_surface_proc_entries(void)
+{
+	remove_proc_entry("BAT1", surface_proc_dir);
+	remove_proc_entry("BAT2", surface_proc_dir);
+	remove_proc_entry("ADP1", surface_proc_dir);
+	remove_proc_entry("version", surface_proc_dir);
+}
+
+static void surface_acpi_notify(struct acpi_device *dev, u32 event)
+{
+	pr_info("surface_acpi: Event received %x\n", event);
+}
+
+static void surface_acpi_register_rqst_handler(void)
+{
+	acpi_status status;
+
+	status = acpi_get_handle(NULL, SUR_SAN_RQST, &surface_acpi->rqst_handle);
+	if (ACPI_FAILURE(status)) {
+		pr_err("surface_acpi: ACPI event failure status %s\n",
+					acpi_format_exception(status));
+	}
+}
+
+static void surface_acpi_register_rqsx_handler(void)
+{
+	acpi_status status;
+
+	status = acpi_get_handle(NULL, SUR_SAN_RQSX, &surface_acpi->rqsx_handle);
+	if (ACPI_FAILURE(status)) {
+		pr_err("surface_acpi: ACPI event failure status %s\n",
+					acpi_format_exception(status));
+	}
+}
+
+static acpi_status surface_acpi_walk_callback(acpi_handle handle, u32 level,
+						void *context, void **return_value)
+{
+	struct acpi_device_info *info;
+
+	if (ACPI_SUCCESS(acpi_get_object_info(handle, &info))) {
+		pr_warn("method: name: %4.4s, args %X\n",
+			(char *)&info->name, info->param_count);
+
+		kfree(info);
+	}
+
+	return AE_OK;
+}
+
+static void surface_acpi_walk_namespace(struct acpi_device *dev)
+{
+	acpi_status status;
+
+	status = acpi_walk_namespace(ACPI_TYPE_METHOD,
+			dev->handle, 1, surface_acpi_walk_callback,
+			NULL, NULL, NULL);
+	if (ACPI_FAILURE(status))
+		pr_warn("surface_acpi: Unable to walk acpi resources\n");
+}
+
+static int surface_acpi_add(struct acpi_device *dev)
+{
+	if (!surface_acpi)
+	{
+		surface_acpi = kzalloc(sizeof(*surface_acpi), GFP_KERNEL);
+		if (!surface_acpi)
+			return AE_NO_MEMORY;
+	}
+
+	if (acpi_has_method(dev->handle, SUR_METHOD_DSM))
+	{
+		pr_info("surface_acpi: Attaching device MSHW0091\n");
+
+		surface_acpi->san_dev = dev;
+		surface_acpi->handle = dev->handle;
+
+		surface_acpi_walk_namespace(surface_acpi->san_dev);
+		surface_acpi_check_status(surface_acpi->san_dev);
+
+		surface_acpi_register_rqst_handler();
+		surface_acpi_register_rqsx_handler();
+
+		surface_acpi_san_reg();
+		surface_acpi_san_load();
+
+		create_surface_proc_entries();
+	}
+	else if (acpi_has_method(dev->handle, SUR_METHOD_CRS))
+	{
+		pr_info("surface_acpi: Attaching device MSHW0084\n");
+
+		surface_acpi->ssh_dev = dev;
+
+		surface_acpi_walk_namespace(surface_acpi->ssh_dev);
+		surface_acpi_check_status(surface_acpi->ssh_dev);
+
+		surface_acpi_ssh_initialize();
+		//surface_acpi_ssh_load();
+	}
+	else
+	{
+		pr_info("surface_acpi: Attaching device\n");
+	}
+
+	device_init_wakeup(&dev->dev, true);
+
+	return AE_OK;
+}
+
+static int surface_acpi_remove(struct acpi_device *dev)
+{
+	remove_surface_proc_entries();
+
+	return AE_OK;
+}
+
+static const struct acpi_device_id surface_device_ids[] = {
+	{"MSHW0084", 0},
+	{"MSHW0091", 0},
+	{"MSHW0124", 0},
+	{"INT3403", 0},
+	{"LNXTHERM", 0},
+	{"PNP0C0A", 0},
+	{"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, surface_device_ids);
+
+static struct acpi_driver surface_acpi_driver = {
+	.name	= "surface_acpi",
+	.owner	= THIS_MODULE,
+	.ids	= surface_device_ids,
+	.flags	= ACPI_DRIVER_ALL_NOTIFY_EVENTS,
+	.ops	= {
+		.add	= surface_acpi_add,
+		.remove = surface_acpi_remove,
+		.notify = surface_acpi_notify,
+	},
+};
+
+static int __init surface_acpi_init(void)
+{
+	int ret;
+
+	pr_info("surface_acpi: Microsoft Surface ACPI Driver version %s\n",
+	       SURFACE_ACPI_VERSION);
+
+	surface_proc_dir = proc_mkdir(PROC_SURFACE, acpi_root_dir);
+	if (!surface_proc_dir) {
+		pr_err("surface_acpi: Unable to create proc dir " PROC_SURFACE "\n");
+		return -ENODEV;
+	}
+
+	ret = acpi_bus_register_driver(&surface_acpi_driver);
+	if (ret) {
+		pr_err("surface_acpi: Failed to register ACPI driver: %d\n", ret);
+		remove_proc_entry(PROC_SURFACE, acpi_root_dir);
+	}
+
+	return ret;
+}
+
+static void __exit surface_acpi_exit(void)
+{
+	acpi_bus_unregister_driver(&surface_acpi_driver);
+	if (surface_proc_dir)
+		remove_proc_entry(PROC_SURFACE, acpi_root_dir);
+}
+
+module_init(surface_acpi_init);
+module_exit(surface_acpi_exit);
+
+MODULE_AUTHOR("Jake Day");
+MODULE_DESCRIPTION("Microsoft Surface ACPI Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/platform/x86/surface_acpi.h b/drivers/platform/x86/surface_acpi.h
new file mode 100644
index 000000000000..5b6627c4d6f1
--- /dev/null
+++ b/drivers/platform/x86/surface_acpi.h
@@ -0,0 +1,18 @@
+/*
+ *  surface_acpi.h - Microsoft Surface ACPI Driver
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  The full GNU General Public License is included in this distribution in
+ *  the file called "COPYING".
+ */
+
+acpi_status surface_acpi_event_handler(u32 event);
diff --git a/drivers/platform/x86/surface_i2c.c b/drivers/platform/x86/surface_i2c.c
new file mode 100644
index 000000000000..fb2cf0cae72f
--- /dev/null
+++ b/drivers/platform/x86/surface_i2c.c
@@ -0,0 +1,696 @@
+/*
+ *  surface_i2c.c - Microsoft Surface I2C Driver
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  The full GNU General Public License is included in this distribution in
+ *  the file called "COPYING".
+ */
+
+#include <linux/kernel.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/acpi.h>
+#include <linux/module.h>
+#include <linux/uuid.h>
+#include <linux/kthread.h>
+#include <linux/freezer.h>
+#include <asm/unaligned.h>
+
+#include "surface_acpi.h"
+
+#define POLL_INTERVAL		(HZ * 2)
+
+struct surface_i2c_data {
+	struct i2c_client *adp1;
+	struct i2c_client *bat0;
+	unsigned short notify_version;
+	struct task_struct *poll_task;
+	bool kthread_running;
+	bool charging;
+	bool bat_charging;
+	u8 trip_point;
+	s32 full_capacity;
+};
+
+struct surface_i2c_lookup {
+	struct surface_i2c_data	*cdata;
+	unsigned int n;
+	unsigned int index;
+	int addr;
+};
+
+struct surface_i2c_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[10];
+	char serial[10];
+	char type[10];
+	char OEM[10];
+} __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	0x1
+#define ACPI_BATTERY_STATE_CHARGING		0x2
+#define ACPI_BATTERY_STATE_CRITICAL		0x4
+
+#define surface_i2c_CMD_DEST_BAT0		0x01
+#define surface_i2c_CMD_DEST_ADP1		0x03
+
+#define surface_i2c_CMD_BAT0_STA		0x01
+#define surface_i2c_CMD_BAT0_BIX		0x02
+#define surface_i2c_CMD_BAT0_BCT		0x03
+#define surface_i2c_CMD_BAT0_BTM		0x04
+#define surface_i2c_CMD_BAT0_BST		0x05
+#define surface_i2c_CMD_BAT0_BTP		0x06
+#define surface_i2c_CMD_ADP1_PSR		0x07
+#define surface_i2c_CMD_BAT0_PSOC		0x09
+#define surface_i2c_CMD_BAT0_PMAX		0x0A
+#define surface_i2c_CMD_BAT0_PSRC		0x0B
+#define surface_i2c_CMD_BAT0_CHGI		0x0C
+#define surface_i2c_CMD_BAT0_ARTG		0x0D
+
+#define surface_i2c_NOTIFY_GET_VERSION	0x00
+#define surface_i2c_NOTIFY_ADP1			0x01
+#define surface_i2c_NOTIFY_BAT0_BST		0x02
+#define surface_i2c_NOTIFY_BAT0_BIX		0x05
+
+#define surface_i2c_ADP1_REG_PSR		0x03
+
+#define surface_i2c_BAT0_REG_CAPACITY			0x0c
+#define surface_i2c_BAT0_REG_FULL_CHG_CAPACITY	0x0e
+#define surface_i2c_BAT0_REG_DESIGN_CAPACITY	0x40
+#define surface_i2c_BAT0_REG_VOLTAGE			0x08
+#define surface_i2c_BAT0_REG_RATE				0x14
+#define surface_i2c_BAT0_REG_OEM				0x45
+#define surface_i2c_BAT0_REG_TYPE				0x4e
+#define surface_i2c_BAT0_REG_SERIAL_NO			0x56
+#define surface_i2c_BAT0_REG_CYCLE_CNT			0x6e
+
+#define surface_i2c_EV_2_5				0x1ff
+
+static int surface_i2c_read_block(struct i2c_client *client, u8 reg, u8 *buf,
+				   int len)
+{
+	int status, i;
+
+	for (i = 0; i < len; i++) {
+		status = i2c_smbus_read_byte_data(client, reg + i);
+		if (status < 0) {
+			buf[i] = 0xff;
+			continue;
+		}
+
+		buf[i] = (u8)status;
+	}
+
+	return 0;
+}
+
+static int
+surface_i2c_notify(struct surface_i2c_data *cdata, u8 arg1, u8 arg2,
+		unsigned int *ret_value)
+{
+	/*static const guid_t surface_i2c_guid =
+	GUID_INIT(0x93b666c5, 0x70c6, 0x469f,
+		  0xa2, 0x15, 0x3d, 0x48, 0x7c, 0x91, 0xab, 0x3c);*/
+
+	struct acpi_device *adev;
+	acpi_handle handle;
+	acpi_status status;
+
+	handle = ACPI_HANDLE(&cdata->adp1->dev);
+	if (!handle || acpi_bus_get_device(handle, &adev))
+		return -ENODEV;
+
+	*ret_value = 0;
+
+	status = surface_acpi_event_handler(arg2);
+	if (ACPI_FAILURE(status)) {
+		pr_err("surface_i2c: ACPI event failure status %s\n",
+					acpi_format_exception(status));
+	}
+
+	return 0;
+}
+
+static const struct bix default_bix = {
+	.revision = 0x00,
+	.power_unit = 0x00,
+	.design_capacity = 0x1734,
+	.last_full_charg_capacity = 0x1734,
+	.battery_technology = 0x01,
+	.design_voltage = 0x1d92,
+	.design_capacity_of_warning = 0xc8,
+	.design_capacity_of_low = 0xc8,
+	.battery_capacity_granularity_1 = 0x45,
+	.battery_capacity_granularity_2 = 0x11,
+	.cycle_count = 0x01,
+	.measurement_accuracy = 0x00015F90,
+	.max_sampling_time = 0x03E8,
+	.min_sampling_time = 0x03E8,
+	.max_average_interval = 0x03E8,
+	.min_average_interval = 0x03E8,
+	.model = "PNP0C0A",
+	.serial = "1234567890",
+	.type = "SDS-BAT",
+	.OEM = "MICROSOFT",
+};
+
+static int surface_i2c_bix(struct surface_i2c_data *cdata, struct bix *bix)
+{
+	struct i2c_client *client = cdata->bat0;
+	int ret;
+	char buf[10];
+
+	*bix = default_bix;
+
+	/* get design capacity */
+	ret = i2c_smbus_read_word_data(client, surface_i2c_BAT0_REG_DESIGN_CAPACITY);
+	if (ret < 0) {
+		dev_err(&client->dev, "Error reading design capacity: %d\n", ret);
+		return ret;
+	}
+	bix->design_capacity = le16_to_cpu(ret);
+
+	/* get last full charge capacity */
+	ret = i2c_smbus_read_word_data(client, surface_i2c_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 = le16_to_cpu(ret);
+
+	/* get serial number */
+	ret = surface_i2c_read_block(client, surface_i2c_BAT0_REG_SERIAL_NO,
+				      buf, 10);
+	if (ret) {
+		dev_err(&client->dev, "Error reading serial no: %d\n", ret);
+		return ret;
+	}
+	memcpy(bix->serial, buf + 7, 3);
+	memcpy(bix->serial + 3, buf, 6);
+	bix->serial[9] = '\0';
+
+	/* get cycle count */
+	ret = i2c_smbus_read_word_data(client, surface_i2c_BAT0_REG_CYCLE_CNT);
+	if (ret < 0) {
+		dev_err(&client->dev, "Error reading cycle count: %d\n", ret);
+		return ret;
+	}
+	bix->cycle_count = le16_to_cpu(ret);
+
+	/* get OEM name */
+	ret = surface_i2c_read_block(client, surface_i2c_BAT0_REG_OEM, buf, 4);
+	if (ret) {
+		dev_err(&client->dev, "Error reading cycle count: %d\n", ret);
+		return ret;
+	}
+	memcpy(bix->OEM, buf, 3);
+	bix->OEM[4] = '\0';
+
+	return 0;
+}
+
+static int surface_i2c_bst(struct surface_i2c_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, surface_i2c_BAT0_REG_RATE);
+	if (rate < 0)
+		return rate;
+
+	capacity = i2c_smbus_read_word_data(client, surface_i2c_BAT0_REG_CAPACITY);
+	if (capacity < 0)
+		return capacity;
+
+	voltage = i2c_smbus_read_word_data(client, surface_i2c_BAT0_REG_VOLTAGE);
+	if (voltage < 0)
+		return voltage;
+
+	tmp = le16_to_cpu(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 = le16_to_cpu(capacity);
+	bst->battery_present_voltage = le16_to_cpu(voltage);
+
+	return 0;
+}
+
+static int surface_i2c_adp_psr(struct surface_i2c_data *cdata)
+{
+	struct i2c_client *client = cdata->adp1;
+	int ret;
+
+	ret = i2c_smbus_read_byte_data(client, surface_i2c_ADP1_REG_PSR);
+	if (ret < 0)
+		return ret;
+
+	return ret;
+}
+
+static int surface_i2c_isr(struct surface_i2c_data *cdata)
+{
+	struct bst bst;
+	struct bix bix;
+	int ret;
+	bool status, bat_status;
+
+	ret = surface_i2c_adp_psr(cdata);
+	if (ret < 0)
+		return ret;
+
+	status = ret;
+
+	if (status != cdata->charging)
+		surface_i2c_notify(cdata, cdata->notify_version,
+				surface_i2c_NOTIFY_ADP1, &ret);
+
+	cdata->charging = status;
+
+	ret = surface_i2c_bst(cdata, &bst);
+	if (ret < 0)
+		return ret;
+
+	bat_status = bst.battery_state;
+
+	if (bat_status != cdata->bat_charging)
+		surface_i2c_notify(cdata, cdata->notify_version,
+				surface_i2c_NOTIFY_BAT0_BST, &ret);
+
+	cdata->bat_charging = bat_status;
+
+	ret = surface_i2c_bix(cdata, &bix);
+	if (ret < 0)
+		return ret;
+	if (bix.last_full_charg_capacity != cdata->full_capacity)
+		surface_i2c_notify(cdata, cdata->notify_version,
+				surface_i2c_NOTIFY_BAT0_BIX, &ret);
+
+	cdata->full_capacity = bix.last_full_charg_capacity;
+
+	return 0;
+}
+
+static int surface_i2c_poll_task(void *data)
+{
+	struct surface_i2c_data *cdata = data;
+	int ret = 0;
+
+	cdata->kthread_running = true;
+
+	set_freezable();
+
+	while (!kthread_should_stop()) {
+		schedule_timeout_interruptible(POLL_INTERVAL);
+		try_to_freeze();
+		ret = surface_i2c_isr(data);
+		if (ret)
+			goto out;
+	}
+
+out:
+	cdata->kthread_running = false;
+	return ret;
+}
+
+static acpi_status
+surface_i2c_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 surface_i2c_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 surface_i2c_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 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
+		ret = AE_BAD_PARAMETER;
+		goto err;
+	}
+
+	sb = &ares->data.i2c_serial_bus;
+	if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
+		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 == surface_i2c_CMD_DEST_ADP1 &&
+	    gsb->cmd.arg1 == surface_i2c_CMD_ADP1_PSR) {
+		ret = surface_i2c_adp_psr(cdata);
+		if (ret >= 0) {
+			status = ret;
+			ret = 0;
+		}
+		goto out;
+	}
+
+	if (gsb->cmd.arg0 != surface_i2c_CMD_DEST_BAT0) {
+		ret = AE_BAD_PARAMETER;
+		goto err;
+	}
+
+	switch (gsb->cmd.arg1) {
+	case surface_i2c_CMD_BAT0_STA:
+		status = 1;
+		ret = 0;
+		break;
+	case surface_i2c_CMD_BAT0_BIX:
+		status = 1;
+		ret = surface_i2c_bix(cdata, &gsb->bix);
+		break;
+	case surface_i2c_CMD_BAT0_BTP:
+		status = 1;
+		ret = 0;
+		cdata->trip_point = gsb->cmd.arg2;
+		break;
+	case surface_i2c_CMD_BAT0_BST:
+		status = 1;
+		ret = surface_i2c_bst(cdata, &gsb->bst);
+		break;
+	default:
+		pr_info("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 surface_i2c_install_space_handler(struct i2c_client *client)
+{
+	acpi_handle handle;
+	struct surface_i2c_handler_data *data;
+	acpi_status status;
+
+	handle = ACPI_HANDLE(&client->dev);
+
+	if (!handle)
+		return -ENODEV;
+
+	data = kzalloc(sizeof(struct surface_i2c_handler_data),
+			    GFP_KERNEL);
+	if (!data)
+		return -ENOMEM;
+
+	data->client = client;
+	status = acpi_bus_attach_private_data(handle, (void *)data);
+	if (ACPI_FAILURE(status)) {
+		kfree(data);
+		return -ENOMEM;
+	}
+
+	status = acpi_install_address_space_handler(handle,
+				ACPI_ADR_SPACE_GSBUS,
+				&surface_i2c_space_handler,
+				NULL,
+				data);
+	if (ACPI_FAILURE(status)) {
+		dev_err(&client->dev, "Error installing i2c space handler\n");
+		acpi_bus_detach_private_data(handle);
+		kfree(data);
+		return -ENOMEM;
+	}
+
+	acpi_walk_dep_device_list(handle);
+	return 0;
+}
+
+static void surface_i2c_remove_space_handler(struct i2c_client *client)
+{
+	acpi_handle handle;
+	struct surface_i2c_handler_data *data;
+	acpi_status status;
+
+	handle = ACPI_HANDLE(&client->dev);
+
+	if (!handle)
+		return;
+
+	acpi_remove_address_space_handler(handle,
+				ACPI_ADR_SPACE_GSBUS,
+				&surface_i2c_space_handler);
+
+	status = acpi_bus_get_private_data(handle, (void **)&data);
+	if (ACPI_SUCCESS(status))
+		kfree(data);
+
+	acpi_bus_detach_private_data(handle);
+}
+
+static int acpi_find_i2c(struct acpi_resource *ares, void *data)
+{
+	struct surface_i2c_lookup *lookup = data;
+
+	if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
+		return 1;
+
+	if (lookup->n++ == lookup->index && !lookup->addr)
+		lookup->addr = ares->data.i2c_serial_bus.slave_address;
+
+	return 1;
+}
+
+static int surface_i2c_resource_lookup(struct surface_i2c_data *cdata,
+					unsigned int index)
+{
+	struct i2c_client *client = cdata->adp1;
+	struct acpi_device *adev = ACPI_COMPANION(&client->dev);
+	struct surface_i2c_lookup lookup = {
+		.cdata = cdata,
+		.index = index,
+	};
+	struct list_head res_list;
+	int ret;
+
+	INIT_LIST_HEAD(&res_list);
+
+	ret = acpi_dev_get_resources(adev, &res_list, acpi_find_i2c, &lookup);
+	if (ret < 0)
+		return ret;
+
+	acpi_dev_free_resource_list(&res_list);
+
+	if (!lookup.addr)
+		return -ENOENT;
+
+	return lookup.addr;
+}
+
+static void surface_i2c_dump_registers(struct i2c_client *client,
+				    struct i2c_client *bat0)
+{
+	char rd_buf[60];
+	int error, i, c;
+	char buff[17 * 3 * 2] = {0};
+
+	dev_info(&client->dev, "dumping registers 0x00 to 0x7F:\n");
+
+	for (i = 0; i < 0x80; i += 0x20) {
+		memset(rd_buf, 0, sizeof(rd_buf));
+		error = surface_i2c_read_block(bat0, i, rd_buf, 0x20);
+		dev_info(&client->dev, " read 0x%02x: %*ph|%*ph\n",
+			 i,
+			 0x10, rd_buf,
+			 0x10, rd_buf + 0x10);
+		for (c = 0; c < 0x20; c++) {
+			if (rd_buf[c] >= 0x20 && rd_buf[c] <= 0x7e) {
+				buff[c * 3 + 0] = ' ';
+				buff[c * 3 + 1] = rd_buf[c];
+			} else {
+				buff[c * 3 + 0] = '-';
+				buff[c * 3 + 1] = '-';
+			}
+			buff[c * 3 + 2] = (c + 1) % 0x10 ? ' ' : '|';
+		}
+		buff[0x1f * 3 + 2] = '\0';
+		dev_info(&client->dev, "ascii 0x%02x: %s\n", i, buff);
+	}
+}
+
+static int surface_i2c_probe(struct i2c_client *client)
+{
+	struct device *dev = &client->dev;
+	struct i2c_client *bat0;
+	struct surface_i2c_data *data;
+	int error, version, addr;
+
+	pr_info("surface_i2c: Probing for surface i2c device...\n");
+
+	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
+	if (!data)
+		return -ENOMEM;
+
+	data->adp1 = client;
+	i2c_set_clientdata(client, data);
+
+	addr = surface_i2c_resource_lookup(data, 1);
+	if (addr < 0)
+		return addr;
+
+	bat0 = i2c_new_dummy(client->adapter, addr);
+	if (!bat0)
+		return -ENOMEM;
+
+	data->bat0 = bat0;
+	i2c_set_clientdata(bat0, data);
+
+	// debugging
+	surface_i2c_dump_registers(client, bat0);
+
+	pr_info("surface_i2c: Attaching device MSHW0124...");
+
+	error = surface_i2c_notify(data, 1, surface_i2c_NOTIFY_GET_VERSION, &version);
+	if (error)
+		goto out_err;
+
+	data->notify_version = version == surface_i2c_EV_2_5;
+
+	data->poll_task = kthread_run(surface_i2c_poll_task, data, "surface_i2c_adp");
+	if (IS_ERR(data->poll_task)) {
+		error = PTR_ERR(data->poll_task);
+		dev_err(&client->dev, "Unable to run kthread err %d\n", error);
+		goto out_err;
+	}
+
+	//error = surface_i2c_install_space_handler(client);
+	//if (error)
+	//	goto out_err;
+
+	return 0;
+
+out_err:
+	if (data->kthread_running)
+		kthread_stop(data->poll_task);
+	i2c_unregister_device(data->bat0);
+	return error;
+}
+
+static int surface_i2c_remove(struct i2c_client *client)
+{
+	struct surface_i2c_data *cdata = i2c_get_clientdata(client);
+
+	surface_i2c_remove_space_handler(client);
+
+	if (cdata->kthread_running)
+		kthread_stop(cdata->poll_task);
+
+	i2c_unregister_device(cdata->bat0);
+
+	return 0;
+}
+
+int surface_i2c_detect(struct i2c_client* client, struct i2c_board_info* board_info)
+{
+    pr_info("surface_i2c: Detecting surface_i2c device...");
+    return 0;
+}
+
+static const struct acpi_device_id surface_i2c_acpi_match[] = {
+	{ "MSHW0124", 0 },
+	{ "", 0 }
+};
+MODULE_DEVICE_TABLE(acpi, surface_i2c_acpi_match);
+
+static const struct i2c_device_id surface_i2c_id[] = {
+	{ "MSHW0124:00", 0 },
+	{ "MSHW0124:01", 0 },
+	{ "", 0 }
+};
+MODULE_DEVICE_TABLE(i2c, surface_i2c_id);
+
+static struct i2c_driver surface_i2c_driver = {
+	.probe_new = surface_i2c_probe,
+	.remove = surface_i2c_remove,
+	.detect = surface_i2c_detect,
+	.id_table = surface_i2c_id,
+	.driver = {
+		.name = "surface_i2c",
+		.acpi_match_table = ACPI_PTR(surface_i2c_acpi_match),
+	},
+};
+module_i2c_driver(surface_i2c_driver);
+
+MODULE_AUTHOR("Jake Day");
+MODULE_DESCRIPTION("Microsoft Surface I2C Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/platform/x86/surface_platform.c b/drivers/platform/x86/surface_platform.c
new file mode 100644
index 000000000000..7a84340b04bb
--- /dev/null
+++ b/drivers/platform/x86/surface_platform.c
@@ -0,0 +1,67 @@
+/*
+ *  surface_platform.c - Microsoft Surface Platform Driver
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  The full GNU General Public License is included in this distribution in
+ *  the file called "COPYING".
+ */
+
+#include <linux/acpi.h>
+#include <linux/gpio/consumer.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/platform_device.h>
+#include <linux/power_supply.h>
+#include <linux/thermal.h>
+#include <linux/uuid.h>
+#include <linux/workqueue.h>
+
+#include <asm/unaligned.h>
+
+struct surface_platform_data {
+	struct device *dev;
+};
+
+static int surface_platform_probe(struct platform_device *pdev)
+{
+	struct surface_platform_data *pdata;
+
+	platform_set_drvdata(pdev, pdata);
+	return 0;
+}
+
+static int surface_platform_remove(struct platform_device *pdev)
+{
+	struct surface_platform_data *pdata = platform_get_drvdata(pdev);
+}
+
+static const struct acpi_device_id surface_platform_acpi_match[] = {
+	{ "MSHW0091", 0 },
+	{ "INT3403", 0 },
+	{ "", 0 }
+};
+MODULE_DEVICE_TABLE(acpi, surface_platform_acpi_match);
+
+static struct platform_driver surface_platform_driver = {
+	.probe = surface_platform_probe,
+	.remove = surface_platform_remove,
+	.driver = {
+		.name = "surface_platform",
+		.acpi_match_table = ACPI_PTR(surface_platform_acpi_match),
+	},
+};
+module_platform_driver(surface_platform_driver);
+
+MODULE_AUTHOR("Jake Day");
+MODULE_DESCRIPTION("Microsoft Surface Platform Driver");
+MODULE_LICENSE("GPL");
diff --git a/kernel/power/suspend.c b/kernel/power/suspend.c
index 87331565e505..d55f949ee25a 100644
--- a/kernel/power/suspend.c
+++ b/kernel/power/suspend.c
@@ -520,6 +520,8 @@ int suspend_devices_and_enter(suspend_state_t state)
 	goto Resume_devices;
 }
 
+unsigned int resume_delay = 3000;
+
 /**
  * suspend_finish - Clean up before finishing the suspend sequence.
  *
@@ -528,6 +530,15 @@ int suspend_devices_and_enter(suspend_state_t state)
  */
 static void suspend_finish(void)
 {
+	if (resume_delay) {
+		/* Give kernel threads a head start, such that usb-storage
+		 * can detect devices before syslog attempts to write log
+		 * messages from the suspend code.
+		 */
+		thaw_kernel_threads();
+		pr_debug("PM: Sleeping for %d milliseconds.\n", resume_delay);
+		msleep(resume_delay);
+	}
 	suspend_thaw_processes();
 	pm_notifier_call_chain(PM_POST_SUSPEND);
 	pm_restore_console();
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 2d9837c0aff4..ac704bf71f45 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -308,7 +308,16 @@ static int min_extfrag_threshold;
 static int max_extfrag_threshold = 1000;
 #endif
 
+extern unsigned int resume_delay;
+
 static struct ctl_table kern_table[] = {
+	{
+		.procname	= "resume_delay",
+		.data		= &resume_delay,
+		.maxlen		= sizeof(unsigned int),
+		.mode		= 0644,
+		.proc_handler	= proc_dointvec,
+	},
 	{
 		.procname	= "sched_child_runs_first",
 		.data		= &sysctl_sched_child_runs_first,