Subsequent immutable branch between MFD and Input due for the v4.11 merge window
-----BEGIN PGP SIGNATURE----- iQIcBAABCAAGBQJYoXvBAAoJEFGvii+H/HdhPCMP/1KAxTGNt/6405t/5mTf1+Fz YtxyLTqZq9cpECYmbFiiyFaP4/VJTLVkesmNbji8RD8pR5UpGLS0f/HLKxs/M9dv bOwnk0kRhFiZ0ozE+bEmcNEqUZRPb1uNhaiD2z5qphBQgYGFRDl6TbajSnCi/UaE wfcJcDdI29Z/6BYQPSqKhcSQsZSowoVdHA1uIcTJ5Oq5pvnmwL8IVP9Rj++FUafI bElqpIZeFffbORKJUjRpp6vmhB2IDcmBxj5aayB6Q4ItbuQ17yzBI5Mgy+j+6/dc Q+k5JKLwskMk4uoDKka0RYODtmrEjxnIz+6EzDvQbk14EZ5duDfecNaCaE0RAcXC 0O5VAdBifygjI+QuV9Wu5FaOhwl+1cxcecRtq0YEutbPYl1UHERRG88Ys1xOIHpg jGQB06JVbwzQ1a2BkGZRBIGhv1cSEIcEM9mQ1Iq6ZKrsqdma60dqgsYb/dQ7Fn6E 4Tk+WZsaPjM2bwOKU4xjm/itO1tYdNA2mOy+K8EXgMq5XrwuinderJpdhx/Lg5Z8 h2Qv10LixZA61gotJ8TNKJF1KaHEGudfqfvt+iUn0LxtXJ3dDuiRxmVuGTZrdNN3 0RmmjF0A5GzZ2JBPV+p3lZksWNP7yvm2btANNuAquwlkupEVhc3YY8hcKkgKC6dM 0r9rh75NxpdQ9bl22QUP =wmTw -----END PGP SIGNATURE----- Merge tag 'ib-mfd-input-v4.11-1' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd into next Merge in cros-ec changes applied through MFD branch to resolve conflicts.
This commit is contained in:
Dmitry Torokhov
commit
b0c9d043d4
|
|
@ -34,6 +34,8 @@
|
|||
#include <linux/mfd/cros_ec.h>
|
||||
#include <linux/mfd/cros_ec_commands.h>
|
||||
|
||||
#include <asm/unaligned.h>
|
||||
|
||||
/*
|
||||
* @rows: Number of rows in the keypad
|
||||
* @cols: Number of columns in the keypad
|
||||
|
|
@ -43,8 +45,9 @@
|
|||
* @valid_keys: bitmap of existing keys for each matrix column
|
||||
* @old_kb_state: bitmap of keys pressed last scan
|
||||
* @dev: Device pointer
|
||||
* @idev: Input device
|
||||
* @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
|
||||
*/
|
||||
struct cros_ec_keyb {
|
||||
|
|
@ -57,12 +60,64 @@ struct cros_ec_keyb {
|
|||
uint8_t *old_kb_state;
|
||||
|
||||
struct device *dev;
|
||||
struct input_dev *idev;
|
||||
struct cros_ec_device *ec;
|
||||
|
||||
struct input_dev *idev;
|
||||
struct input_dev *bs_idev;
|
||||
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
|
||||
* results in ghosting.
|
||||
|
|
@ -149,20 +204,33 @@ static void cros_ec_keyb_process(struct cros_ec_keyb *ckdev,
|
|||
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,
|
||||
&ckdev->notifier);
|
||||
}
|
||||
for (i = 0; i < ARRAY_SIZE(cros_ec_keyb_bs); i++) {
|
||||
const struct cros_ec_bs_map *map = &cros_ec_keyb_bs[i];
|
||||
|
||||
static void cros_ec_keyb_close(struct input_dev *dev)
|
||||
{
|
||||
struct cros_ec_keyb *ckdev = input_get_drvdata(dev);
|
||||
if (map->ev_type != ev_type)
|
||||
continue;
|
||||
|
||||
blocking_notifier_chain_unregister(&ckdev->ec->event_notifier,
|
||||
&ckdev->notifier);
|
||||
input_event(idev, ev_type, map->code,
|
||||
!!(mask & BIT(map->bit)) ^ map->inverted);
|
||||
}
|
||||
input_sync(idev);
|
||||
}
|
||||
|
||||
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,
|
||||
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) {
|
||||
case EC_MKBP_EVENT_KEY_MATRIX:
|
||||
/*
|
||||
* If EC is not the wake source, discard key state changes
|
||||
* during suspend.
|
||||
*/
|
||||
if (queued_during_suspend)
|
||||
return NOTIFY_OK;
|
||||
|
||||
if (ckdev->ec->event_size != ckdev->cols) {
|
||||
dev_err(ckdev->dev,
|
||||
"Discarded incomplete key matrix event.\n");
|
||||
return NOTIFY_OK;
|
||||
}
|
||||
cros_ec_keyb_process(ckdev,
|
||||
ckdev->ec->event_data.data.key_matrix,
|
||||
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;
|
||||
/*
|
||||
* If EC is not the wake source, discard key state changes during
|
||||
* suspend.
|
||||
*/
|
||||
if (queued_during_suspend)
|
||||
return NOTIFY_OK;
|
||||
if (ckdev->ec->event_size != ckdev->cols) {
|
||||
dev_err(ckdev->dev,
|
||||
"Discarded incomplete key matrix event.\n");
|
||||
return NOTIFY_OK;
|
||||
}
|
||||
cros_ec_keyb_process(ckdev, ckdev->ec->event_data.data.key_matrix,
|
||||
ckdev->ec->event_size);
|
||||
|
||||
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 device *dev = &pdev->dev;
|
||||
struct cros_ec_keyb *ckdev;
|
||||
struct input_dev *idev;
|
||||
struct device_node *np;
|
||||
int err;
|
||||
struct ec_params_mkbp_info *params;
|
||||
struct cros_ec_command *msg;
|
||||
int ret;
|
||||
|
||||
np = dev->of_node;
|
||||
if (!np)
|
||||
return -ENODEV;
|
||||
|
||||
ckdev = devm_kzalloc(dev, sizeof(*ckdev), GFP_KERNEL);
|
||||
if (!ckdev)
|
||||
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;
|
||||
union ec_response_get_next_data event_data = {};
|
||||
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;
|
||||
|
||||
/*
|
||||
* We call the non-matrix buttons/switches 'input1', if present.
|
||||
* 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;
|
||||
|
||||
idev = devm_input_allocate_device(dev);
|
||||
if (!idev)
|
||||
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);
|
||||
if (err)
|
||||
return err;
|
||||
|
|
@ -242,26 +547,28 @@ static int cros_ec_keyb_probe(struct platform_device *pdev)
|
|||
if (!ckdev->old_kb_state)
|
||||
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);
|
||||
if (!idev)
|
||||
return -ENOMEM;
|
||||
|
||||
ckdev->ec = ec;
|
||||
ckdev->notifier.notifier_call = cros_ec_keyb_work;
|
||||
ckdev->dev = dev;
|
||||
|
||||
idev->name = CROS_EC_DEV_NAME;
|
||||
idev->phys = ec->phys_name;
|
||||
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;
|
||||
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");
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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
|
||||
static const struct of_device_id cros_ec_keyb_of_match[] = {
|
||||
{ .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);
|
||||
#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 = {
|
||||
.probe = cros_ec_keyb_probe,
|
||||
.remove = cros_ec_keyb_remove,
|
||||
.driver = {
|
||||
.name = "cros-ec-keyb",
|
||||
.of_match_table = of_match_ptr(cros_ec_keyb_of_match),
|
||||
.pm = &cros_ec_keyb_pm_ops,
|
||||
},
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -1839,18 +1839,69 @@ struct ec_response_tmp006_get_raw {
|
|||
*
|
||||
* Returns raw data for keyboard cols; see ec_response_mkbp_info.cols for
|
||||
* 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
|
||||
|
||||
/* 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
|
||||
|
||||
struct ec_response_mkbp_info {
|
||||
uint32_t rows;
|
||||
uint32_t cols;
|
||||
uint8_t switches;
|
||||
/* Formerly "switches", which was 0. */
|
||||
uint8_t reserved;
|
||||
} __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 */
|
||||
#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. */
|
||||
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 */
|
||||
EC_MKBP_EVENT_COUNT,
|
||||
};
|
||||
|
|
@ -1992,6 +2049,9 @@ union ec_response_get_next_data {
|
|||
|
||||
/* Unaligned */
|
||||
uint32_t host_event;
|
||||
|
||||
uint32_t buttons;
|
||||
uint32_t switches;
|
||||
} __packed;
|
||||
|
||||
struct ec_response_get_next_event {
|
||||
|
|
@ -2000,6 +2060,16 @@ struct ec_response_get_next_event {
|
|||
union ec_response_get_next_data data;
|
||||
} __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 */
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue