Merge tag 'ib-mfd-input-v4.11-1' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd into next (b0c9d043) · Commits · e / devices / android_kernel_teracube_mt6765

drivers/input/keyboard/cros_ec_keyb.c

+406 −44

Original line number	Original line	Diff line number	Diff line
	@@ -34,6 +34,8 @@
	#include <linux/mfd/cros_ec.h>		#include <linux/mfd/cros_ec.h>
	#include <linux/mfd/cros_ec_commands.h>		#include <linux/mfd/cros_ec_commands.h>

			#include <asm/unaligned.h>

	/*		/*
	* @rows: Number of rows in the keypad		* @rows: Number of rows in the keypad
	* @cols: Number of columns in the keypad		* @cols: Number of columns in the keypad
	@@ -43,8 +45,9 @@
	* @valid_keys: bitmap of existing keys for each matrix column		* @valid_keys: bitmap of existing keys for each matrix column
	* @old_kb_state: bitmap of keys pressed last scan		* @old_kb_state: bitmap of keys pressed last scan
	* @dev: Device pointer		* @dev: Device pointer
	* @idev: Input device
	* @ec: Top level ChromeOS device to use to talk to EC		* @ec: Top level ChromeOS device to use to talk to EC
			* @idev: The input device for the matrix keys.
			* @bs_idev: The input device for non-matrix buttons and switches (or NULL).
	* @notifier: interrupt event notifier for transport devices		* @notifier: interrupt event notifier for transport devices
	*/		*/
	struct cros_ec_keyb {		struct cros_ec_keyb {
	@@ -57,12 +60,64 @@ struct cros_ec_keyb {
	uint8_t *old_kb_state;		uint8_t *old_kb_state;

	struct device *dev;		struct device *dev;
	struct input_dev *idev;
	struct cros_ec_device *ec;		struct cros_ec_device *ec;

			struct input_dev *idev;
			struct input_dev *bs_idev;
	struct notifier_block notifier;		struct notifier_block notifier;
	};		};


			/**
			* cros_ec_bs_map - Struct mapping Linux keycodes to EC button/switch bitmap
			* #defines
			*
			* @ev_type: The type of the input event to generate (e.g., EV_KEY).
			* @code: A linux keycode
			* @bit: A #define like EC_MKBP_POWER_BUTTON or EC_MKBP_LID_OPEN
			* @inverted: If the #define and EV_SW have opposite meanings, this is true.
			* Only applicable to switches.
			*/
			struct cros_ec_bs_map {
			unsigned int ev_type;
			unsigned int code;
			u8 bit;
			bool inverted;
			};

			/* cros_ec_keyb_bs - Map EC button/switch #defines into kernel ones */
			static const struct cros_ec_bs_map cros_ec_keyb_bs[] = {
			/* Buttons */
			{
			.ev_type = EV_KEY,
			.code = KEY_POWER,
			.bit = EC_MKBP_POWER_BUTTON,
			},
			{
			.ev_type = EV_KEY,
			.code = KEY_VOLUMEUP,
			.bit = EC_MKBP_VOL_UP,
			},
			{
			.ev_type = EV_KEY,
			.code = KEY_VOLUMEDOWN,
			.bit = EC_MKBP_VOL_DOWN,
			},

			/* Switches */
			{
			.ev_type = EV_SW,
			.code = SW_LID,
			.bit = EC_MKBP_LID_OPEN,
			.inverted = true,
			},
			{
			.ev_type = EV_SW,
			.code = SW_TABLET_MODE,
			.bit = EC_MKBP_TABLET_MODE,
			},
			};

	/*		/*
	* Returns true when there is at least one combination of pressed keys that		* Returns true when there is at least one combination of pressed keys that
	* results in ghosting.		* results in ghosting.
	@@ -149,20 +204,33 @@ static void cros_ec_keyb_process(struct cros_ec_keyb *ckdev,
	input_sync(ckdev->idev);		input_sync(ckdev->idev);
	}		}

	static int cros_ec_keyb_open(struct input_dev *dev)		/**
			* cros_ec_keyb_report_bs - Report non-matrixed buttons or switches
			*
			* This takes a bitmap of buttons or switches from the EC and reports events,
			* syncing at the end.
			*
			* @ckdev: The keyboard device.
			* @ev_type: The input event type (e.g., EV_KEY).
			* @mask: A bitmap of buttons from the EC.
			*/
			static void cros_ec_keyb_report_bs(struct cros_ec_keyb *ckdev,
			unsigned int ev_type, u32 mask)

	{		{
	struct cros_ec_keyb *ckdev = input_get_drvdata(dev);		struct input_dev *idev = ckdev->bs_idev;
			int i;

	return blocking_notifier_chain_register(&ckdev->ec->event_notifier,		for (i = 0; i < ARRAY_SIZE(cros_ec_keyb_bs); i++) {
	&ckdev->notifier);		const struct cros_ec_bs_map *map = &cros_ec_keyb_bs[i];
	}

	static void cros_ec_keyb_close(struct input_dev *dev)		if (map->ev_type != ev_type)
	{		continue;
	struct cros_ec_keyb *ckdev = input_get_drvdata(dev);

	blocking_notifier_chain_unregister(&ckdev->ec->event_notifier,		input_event(idev, ev_type, map->code,
	&ckdev->notifier);		!!(mask & BIT(map->bit)) ^ map->inverted);
			}
			input_sync(idev);
	}		}

	static int cros_ec_keyb_work(struct notifier_block *nb,		static int cros_ec_keyb_work(struct notifier_block *nb,
	@@ -170,22 +238,54 @@ static int cros_ec_keyb_work(struct notifier_block *nb,
	{		{
	struct cros_ec_keyb *ckdev = container_of(nb, struct cros_ec_keyb,		struct cros_ec_keyb *ckdev = container_of(nb, struct cros_ec_keyb,
	notifier);		notifier);
			u32 val;
			unsigned int ev_type;

	if (ckdev->ec->event_data.event_type != EC_MKBP_EVENT_KEY_MATRIX)		switch (ckdev->ec->event_data.event_type) {
	return NOTIFY_DONE;		case EC_MKBP_EVENT_KEY_MATRIX:
	/*		/*
	* If EC is not the wake source, discard key state changes during		* If EC is not the wake source, discard key state changes
	* suspend.		* during suspend.
	*/		*/
	if (queued_during_suspend)		if (queued_during_suspend)
	return NOTIFY_OK;		return NOTIFY_OK;

	if (ckdev->ec->event_size != ckdev->cols) {		if (ckdev->ec->event_size != ckdev->cols) {
	dev_err(ckdev->dev,		dev_err(ckdev->dev,
	"Discarded incomplete key matrix event.\n");		"Discarded incomplete key matrix event.\n");
	return NOTIFY_OK;		return NOTIFY_OK;
	}		}
	cros_ec_keyb_process(ckdev, ckdev->ec->event_data.data.key_matrix,		cros_ec_keyb_process(ckdev,
			ckdev->ec->event_data.data.key_matrix,
	ckdev->ec->event_size);		ckdev->ec->event_size);
			break;

			case EC_MKBP_EVENT_BUTTON:
			case EC_MKBP_EVENT_SWITCH:
			/*
			* If EC is not the wake source, discard key state
			* changes during suspend. Switches will be re-checked in
			* cros_ec_keyb_resume() to be sure nothing is lost.
			*/
			if (queued_during_suspend)
			return NOTIFY_OK;

			if (ckdev->ec->event_data.event_type == EC_MKBP_EVENT_BUTTON) {
			val = get_unaligned_le32(
			&ckdev->ec->event_data.data.buttons);
			ev_type = EV_KEY;
			} else {
			val = get_unaligned_le32(
			&ckdev->ec->event_data.data.switches);
			ev_type = EV_SW;
			}
			cros_ec_keyb_report_bs(ckdev, ev_type, val);
			break;

			default:
			return NOTIFY_DONE;
			}

	return NOTIFY_OK;		return NOTIFY_OK;
	}		}

	@@ -213,23 +313,228 @@ static void cros_ec_keyb_compute_valid_keys(struct cros_ec_keyb *ckdev)
	}		}
	}		}

	static int cros_ec_keyb_probe(struct platform_device *pdev)		/**
			* cros_ec_keyb_info - Wrap the EC command EC_CMD_MKBP_INFO
			*
			* This wraps the EC_CMD_MKBP_INFO, abstracting out all of the marshalling and
			* unmarshalling and different version nonsense into something simple.
			*
			* @ec_dev: The EC device
			* @info_type: Either EC_MKBP_INFO_SUPPORTED or EC_MKBP_INFO_CURRENT.
			* @event_type: Either EC_MKBP_EVENT_BUTTON or EC_MKBP_EVENT_SWITCH. Actually
			* in some cases this could be EC_MKBP_EVENT_KEY_MATRIX or
			* EC_MKBP_EVENT_HOST_EVENT too but we don't use in this driver.
			* @result: Where we'll store the result; a union
			* @result_size: The size of the result. Expected to be the size of one of
			* the elements in the union.
			*
			* Returns 0 if no error or -error upon error.
			*/
			static int cros_ec_keyb_info(struct cros_ec_device *ec_dev,
			enum ec_mkbp_info_type info_type,
			enum ec_mkbp_event event_type,
			union ec_response_get_next_data *result,
			size_t result_size)
	{		{
	struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent);		struct ec_params_mkbp_info *params;
	struct device *dev = &pdev->dev;		struct cros_ec_command *msg;
	struct cros_ec_keyb *ckdev;		int ret;

			msg = kzalloc(sizeof(*msg) + max_t(size_t, result_size,
			sizeof(*params)), GFP_KERNEL);
			if (!msg)
			return -ENOMEM;

			msg->command = EC_CMD_MKBP_INFO;
			msg->version = 1;
			msg->outsize = sizeof(*params);
			msg->insize = result_size;
			params = (struct ec_params_mkbp_info *)msg->data;
			params->info_type = info_type;
			params->event_type = event_type;

			ret = cros_ec_cmd_xfer(ec_dev, msg);
			if (ret < 0) {
			dev_warn(ec_dev->dev, "Transfer error %d/%d: %d\n",
			(int)info_type, (int)event_type, ret);
			} else if (msg->result == EC_RES_INVALID_VERSION) {
			/* With older ECs we just return 0 for everything */
			memset(result, 0, result_size);
			ret = 0;
			} else if (msg->result != EC_RES_SUCCESS) {
			dev_warn(ec_dev->dev, "Error getting info %d/%d: %d\n",
			(int)info_type, (int)event_type, msg->result);
			ret = -EPROTO;
			} else if (ret != result_size) {
			dev_warn(ec_dev->dev, "Wrong size %d/%d: %d != %zu\n",
			(int)info_type, (int)event_type,
			ret, result_size);
			ret = -EPROTO;
			} else {
			memcpy(result, msg->data, result_size);
			ret = 0;
			}

			kfree(msg);

			return ret;
			}

			/**
			* cros_ec_keyb_query_switches - Query the state of switches and report
			*
			* This will ask the EC about the current state of switches and report to the
			* kernel. Note that we don't query for buttons because they are more
			* transitory and we'll get an update on the next release / press.
			*
			* @ckdev: The keyboard device
			*
			* Returns 0 if no error or -error upon error.
			*/
			static int cros_ec_keyb_query_switches(struct cros_ec_keyb *ckdev)
			{
			struct cros_ec_device *ec_dev = ckdev->ec;
			union ec_response_get_next_data event_data = {};
			int ret;

			ret = cros_ec_keyb_info(ec_dev, EC_MKBP_INFO_CURRENT,
			EC_MKBP_EVENT_SWITCH, &event_data,
			sizeof(event_data.switches));
			if (ret)
			return ret;

			cros_ec_keyb_report_bs(ckdev, EV_SW,
			get_unaligned_le32(&event_data.switches));

			return 0;
			}

			/**
			* cros_ec_keyb_resume - Resume the keyboard
			*
			* We use the resume notification as a chance to query the EC for switches.
			*
			* @dev: The keyboard device
			*
			* Returns 0 if no error or -error upon error.
			*/
			static __maybe_unused int cros_ec_keyb_resume(struct device *dev)
			{
			struct cros_ec_keyb *ckdev = dev_get_drvdata(dev);

			if (ckdev->bs_idev)
			return cros_ec_keyb_query_switches(ckdev);

			return 0;
			}

			/**
			* cros_ec_keyb_register_bs - Register non-matrix buttons/switches
			*
			* Handles all the bits of the keyboard driver related to non-matrix buttons
			* and switches, including asking the EC about which are present and telling
			* the kernel to expect them.
			*
			* If this device has no support for buttons and switches we'll return no error
			* but the ckdev->bs_idev will remain NULL when this function exits.
			*
			* @ckdev: The keyboard device
			*
			* Returns 0 if no error or -error upon error.
			*/
			static int cros_ec_keyb_register_bs(struct cros_ec_keyb *ckdev)
			{
			struct cros_ec_device *ec_dev = ckdev->ec;
			struct device *dev = ckdev->dev;
	struct input_dev *idev;		struct input_dev *idev;
	struct device_node *np;		union ec_response_get_next_data event_data = {};
	int err;		const char *phys;
			u32 buttons;
			u32 switches;
			int ret;
			int i;

			ret = cros_ec_keyb_info(ec_dev, EC_MKBP_INFO_SUPPORTED,
			EC_MKBP_EVENT_BUTTON, &event_data,
			sizeof(event_data.buttons));
			if (ret)
			return ret;
			buttons = get_unaligned_le32(&event_data.buttons);

			ret = cros_ec_keyb_info(ec_dev, EC_MKBP_INFO_SUPPORTED,
			EC_MKBP_EVENT_SWITCH, &event_data,
			sizeof(event_data.switches));
			if (ret)
			return ret;
			switches = get_unaligned_le32(&event_data.switches);

			if (!buttons && !switches)
			return 0;

	np = dev->of_node;		/*
	if (!np)		* We call the non-matrix buttons/switches 'input1', if present.
	return -ENODEV;		* Allocate phys before input dev, to ensure correct tear-down
			* ordering.
			*/
			phys = devm_kasprintf(dev, GFP_KERNEL, "%s/input1", ec_dev->phys_name);
			if (!phys)
			return -ENOMEM;

	ckdev = devm_kzalloc(dev, sizeof(*ckdev), GFP_KERNEL);		idev = devm_input_allocate_device(dev);
	if (!ckdev)		if (!idev)
	return -ENOMEM;		return -ENOMEM;

			idev->name = "cros_ec_buttons";
			idev->phys = phys;
			__set_bit(EV_REP, idev->evbit);

			idev->id.bustype = BUS_VIRTUAL;
			idev->id.version = 1;
			idev->id.product = 0;
			idev->dev.parent = dev;

			input_set_drvdata(idev, ckdev);
			ckdev->bs_idev = idev;

			for (i = 0; i < ARRAY_SIZE(cros_ec_keyb_bs); i++) {
			const struct cros_ec_bs_map *map = &cros_ec_keyb_bs[i];

			if (buttons & BIT(map->bit))
			input_set_capability(idev, map->ev_type, map->code);
			}

			ret = cros_ec_keyb_query_switches(ckdev);
			if (ret) {
			dev_err(dev, "cannot query switches\n");
			return ret;
			}

			ret = input_register_device(ckdev->bs_idev);
			if (ret) {
			dev_err(dev, "cannot register input device\n");
			return ret;
			}

			return 0;
			}

			/**
			* cros_ec_keyb_register_bs - Register matrix keys
			*
			* Handles all the bits of the keyboard driver related to matrix keys.
			*
			* @ckdev: The keyboard device
			*
			* Returns 0 if no error or -error upon error.
			*/
			static int cros_ec_keyb_register_matrix(struct cros_ec_keyb *ckdev)
			{
			struct cros_ec_device *ec_dev = ckdev->ec;
			struct device *dev = ckdev->dev;
			struct input_dev *idev;
			const char *phys;
			int err;

	err = matrix_keypad_parse_properties(dev, &ckdev->rows, &ckdev->cols);		err = matrix_keypad_parse_properties(dev, &ckdev->rows, &ckdev->cols);
	if (err)		if (err)
	return err;		return err;
	@@ -242,26 +547,28 @@ static int cros_ec_keyb_probe(struct platform_device *pdev)
	if (!ckdev->old_kb_state)		if (!ckdev->old_kb_state)
	return -ENOMEM;		return -ENOMEM;

			/*
			* We call the keyboard matrix 'input0'. Allocate phys before input
			* dev, to ensure correct tear-down ordering.
			*/
			phys = devm_kasprintf(dev, GFP_KERNEL, "%s/input0", ec_dev->phys_name);
			if (!phys)
			return -ENOMEM;

	idev = devm_input_allocate_device(dev);		idev = devm_input_allocate_device(dev);
	if (!idev)		if (!idev)
	return -ENOMEM;		return -ENOMEM;

	ckdev->ec = ec;
	ckdev->notifier.notifier_call = cros_ec_keyb_work;
	ckdev->dev = dev;

	idev->name = CROS_EC_DEV_NAME;		idev->name = CROS_EC_DEV_NAME;
	idev->phys = ec->phys_name;		idev->phys = phys;
	__set_bit(EV_REP, idev->evbit);		__set_bit(EV_REP, idev->evbit);

	idev->id.bustype = BUS_VIRTUAL;		idev->id.bustype = BUS_VIRTUAL;
	idev->id.version = 1;		idev->id.version = 1;
	idev->id.product = 0;		idev->id.product = 0;
	idev->dev.parent = dev;		idev->dev.parent = dev;
	idev->open = cros_ec_keyb_open;
	idev->close = cros_ec_keyb_close;

	ckdev->ghost_filter = of_property_read_bool(np,		ckdev->ghost_filter = of_property_read_bool(dev->of_node,
	"google,needs-ghost-filter");		"google,needs-ghost-filter");

	err = matrix_keypad_build_keymap(NULL, NULL, ckdev->rows, ckdev->cols,		err = matrix_keypad_build_keymap(NULL, NULL, ckdev->rows, ckdev->cols,
	@@ -287,6 +594,57 @@ static int cros_ec_keyb_probe(struct platform_device *pdev)
	return 0;		return 0;
	}		}

			static int cros_ec_keyb_probe(struct platform_device *pdev)
			{
			struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent);
			struct device *dev = &pdev->dev;
			struct cros_ec_keyb *ckdev;
			int err;

			if (!dev->of_node)
			return -ENODEV;

			ckdev = devm_kzalloc(dev, sizeof(*ckdev), GFP_KERNEL);
			if (!ckdev)
			return -ENOMEM;

			ckdev->ec = ec;
			ckdev->dev = dev;
			dev_set_drvdata(dev, ckdev);

			err = cros_ec_keyb_register_matrix(ckdev);
			if (err) {
			dev_err(dev, "cannot register matrix inputs: %d\n", err);
			return err;
			}

			err = cros_ec_keyb_register_bs(ckdev);
			if (err) {
			dev_err(dev, "cannot register non-matrix inputs: %d\n", err);
			return err;
			}

			ckdev->notifier.notifier_call = cros_ec_keyb_work;
			err = blocking_notifier_chain_register(&ckdev->ec->event_notifier,
			&ckdev->notifier);
			if (err) {
			dev_err(dev, "cannot register notifier: %d\n", err);
			return err;
			}

			return 0;
			}

			static int cros_ec_keyb_remove(struct platform_device *pdev)
			{
			struct cros_ec_keyb *ckdev = dev_get_drvdata(&pdev->dev);

			blocking_notifier_chain_unregister(&ckdev->ec->event_notifier,
			&ckdev->notifier);

			return 0;
			}

	#ifdef CONFIG_OF		#ifdef CONFIG_OF
	static const struct of_device_id cros_ec_keyb_of_match[] = {		static const struct of_device_id cros_ec_keyb_of_match[] = {
	{ .compatible = "google,cros-ec-keyb" },		{ .compatible = "google,cros-ec-keyb" },
	@@ -295,11 +653,15 @@ static const struct of_device_id cros_ec_keyb_of_match[] = {
	MODULE_DEVICE_TABLE(of, cros_ec_keyb_of_match);		MODULE_DEVICE_TABLE(of, cros_ec_keyb_of_match);
	#endif		#endif

			static const SIMPLE_DEV_PM_OPS(cros_ec_keyb_pm_ops, NULL, cros_ec_keyb_resume);

	static struct platform_driver cros_ec_keyb_driver = {		static struct platform_driver cros_ec_keyb_driver = {
	.probe = cros_ec_keyb_probe,		.probe = cros_ec_keyb_probe,
			.remove = cros_ec_keyb_remove,
	.driver = {		.driver = {
	.name = "cros-ec-keyb",		.name = "cros-ec-keyb",
	.of_match_table = of_match_ptr(cros_ec_keyb_of_match),		.of_match_table = of_match_ptr(cros_ec_keyb_of_match),
			.pm = &cros_ec_keyb_pm_ops,
	},		},
	};		};

include/linux/mfd/cros_ec_commands.h

+72 −2

Original line number	Original line	Diff line number	Diff line
	@@ -1839,18 +1839,69 @@ struct ec_response_tmp006_get_raw {
	*		*
	* Returns raw data for keyboard cols; see ec_response_mkbp_info.cols for		* Returns raw data for keyboard cols; see ec_response_mkbp_info.cols for
	* expected response size.		* expected response size.
			*
			* NOTE: This has been superseded by EC_CMD_MKBP_GET_NEXT_EVENT. If you wish
			* to obtain the instantaneous state, use EC_CMD_MKBP_INFO with the type
			* EC_MKBP_INFO_CURRENT and event EC_MKBP_EVENT_KEY_MATRIX.
	*/		*/
	#define EC_CMD_MKBP_STATE 0x60		#define EC_CMD_MKBP_STATE 0x60

	/* Provide information about the matrix : number of rows and columns */		/*
			* Provide information about various MKBP things. See enum ec_mkbp_info_type.
			*/
	#define EC_CMD_MKBP_INFO 0x61		#define EC_CMD_MKBP_INFO 0x61

	struct ec_response_mkbp_info {		struct ec_response_mkbp_info {
	uint32_t rows;		uint32_t rows;
	uint32_t cols;		uint32_t cols;
	uint8_t switches;		/* Formerly "switches", which was 0. */
			uint8_t reserved;
	} __packed;		} __packed;

			struct ec_params_mkbp_info {
			uint8_t info_type;
			uint8_t event_type;
			} __packed;

			enum ec_mkbp_info_type {
			/*
			* Info about the keyboard matrix: number of rows and columns.
			*
			* Returns struct ec_response_mkbp_info.
			*/
			EC_MKBP_INFO_KBD = 0,

			/*
			* For buttons and switches, info about which specifically are
			* supported. event_type must be set to one of the values in enum
			* ec_mkbp_event.
			*
			* For EC_MKBP_EVENT_BUTTON and EC_MKBP_EVENT_SWITCH, returns a 4 byte
			* bitmask indicating which buttons or switches are present. See the
			* bit inidices below.
			*/
			EC_MKBP_INFO_SUPPORTED = 1,

			/*
			* Instantaneous state of buttons and switches.
			*
			* event_type must be set to one of the values in enum ec_mkbp_event.
			*
			* For EC_MKBP_EVENT_KEY_MATRIX, returns uint8_t key_matrix[13]
			* indicating the current state of the keyboard matrix.
			*
			* For EC_MKBP_EVENT_HOST_EVENT, return uint32_t host_event, the raw
			* event state.
			*
			* For EC_MKBP_EVENT_BUTTON, returns uint32_t buttons, indicating the
			* state of supported buttons.
			*
			* For EC_MKBP_EVENT_SWITCH, returns uint32_t switches, indicating the
			* state of supported switches.
			*/
			EC_MKBP_INFO_CURRENT = 2,
			};

	/* Simulate key press */		/* Simulate key press */
	#define EC_CMD_MKBP_SIMULATE_KEY 0x62		#define EC_CMD_MKBP_SIMULATE_KEY 0x62

	@@ -1983,6 +2034,12 @@ enum ec_mkbp_event {
	/* New Sensor FIFO data. The event data is fifo_info structure. */		/* New Sensor FIFO data. The event data is fifo_info structure. */
	EC_MKBP_EVENT_SENSOR_FIFO = 2,		EC_MKBP_EVENT_SENSOR_FIFO = 2,

			/* The state of the non-matrixed buttons have changed. */
			EC_MKBP_EVENT_BUTTON = 3,

			/* The state of the switches have changed. */
			EC_MKBP_EVENT_SWITCH = 4,

	/* Number of MKBP events */		/* Number of MKBP events */
	EC_MKBP_EVENT_COUNT,		EC_MKBP_EVENT_COUNT,
	};		};
	@@ -1992,6 +2049,9 @@ union ec_response_get_next_data {

	/* Unaligned */		/* Unaligned */
	uint32_t host_event;		uint32_t host_event;

			uint32_t buttons;
			uint32_t switches;
	} __packed;		} __packed;

	struct ec_response_get_next_event {		struct ec_response_get_next_event {
	@@ -2000,6 +2060,16 @@ struct ec_response_get_next_event {
	union ec_response_get_next_data data;		union ec_response_get_next_data data;
	} __packed;		} __packed;

			/* Bit indices for buttons and switches.*/
			/* Buttons */
			#define EC_MKBP_POWER_BUTTON 0
			#define EC_MKBP_VOL_UP 1
			#define EC_MKBP_VOL_DOWN 2

			/* Switches */
			#define EC_MKBP_LID_OPEN 0
			#define EC_MKBP_TABLET_MODE 1

	/*****************************************************************************/		/*****************************************************************************/
	/* Temperature sensor commands */		/* Temperature sensor commands */