1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Driver for cros-ec proximity sensor exposed through MKBP switch 4 * 5 * Copyright 2021 Google LLC. 6 */ 7 8 #include <linux/kernel.h> 9 #include <linux/module.h> 10 #include <linux/mutex.h> 11 #include <linux/notifier.h> 12 #include <linux/of.h> 13 #include <linux/platform_device.h> 14 #include <linux/slab.h> 15 #include <linux/types.h> 16 17 #include <linux/platform_data/cros_ec_commands.h> 18 #include <linux/platform_data/cros_ec_proto.h> 19 20 #include <linux/iio/events.h> 21 #include <linux/iio/iio.h> 22 #include <linux/iio/sysfs.h> 23 24 #include <asm/unaligned.h> 25 26 struct cros_ec_mkbp_proximity_data { 27 struct cros_ec_device *ec; 28 struct iio_dev *indio_dev; 29 struct mutex lock; 30 struct notifier_block notifier; 31 int last_proximity; 32 bool enabled; 33 }; 34 35 static const struct iio_event_spec cros_ec_mkbp_proximity_events[] = { 36 { 37 .type = IIO_EV_TYPE_THRESH, 38 .dir = IIO_EV_DIR_EITHER, 39 .mask_separate = BIT(IIO_EV_INFO_ENABLE), 40 }, 41 }; 42 43 static const struct iio_chan_spec cros_ec_mkbp_proximity_chan_spec[] = { 44 { 45 .type = IIO_PROXIMITY, 46 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 47 .event_spec = cros_ec_mkbp_proximity_events, 48 .num_event_specs = ARRAY_SIZE(cros_ec_mkbp_proximity_events), 49 }, 50 }; 51 52 static int cros_ec_mkbp_proximity_parse_state(const void *data) 53 { 54 u32 switches = get_unaligned_le32(data); 55 56 return !!(switches & BIT(EC_MKBP_FRONT_PROXIMITY)); 57 } 58 59 static int cros_ec_mkbp_proximity_query(struct cros_ec_device *ec_dev, 60 int *state) 61 { 62 struct { 63 struct cros_ec_command msg; 64 union { 65 struct ec_params_mkbp_info params; 66 u32 switches; 67 }; 68 } __packed buf = { }; 69 struct ec_params_mkbp_info *params = &buf.params; 70 struct cros_ec_command *msg = &buf.msg; 71 u32 *switches = &buf.switches; 72 size_t insize = sizeof(*switches); 73 int ret; 74 75 msg->command = EC_CMD_MKBP_INFO; 76 msg->version = 1; 77 msg->outsize = sizeof(*params); 78 msg->insize = insize; 79 80 params->info_type = EC_MKBP_INFO_CURRENT; 81 params->event_type = EC_MKBP_EVENT_SWITCH; 82 83 ret = cros_ec_cmd_xfer_status(ec_dev, msg); 84 if (ret < 0) 85 return ret; 86 87 if (ret != insize) { 88 dev_warn(ec_dev->dev, "wrong result size: %d != %zu\n", ret, 89 insize); 90 return -EPROTO; 91 } 92 93 *state = cros_ec_mkbp_proximity_parse_state(switches); 94 return IIO_VAL_INT; 95 } 96 97 static void cros_ec_mkbp_proximity_push_event(struct cros_ec_mkbp_proximity_data *data, int state) 98 { 99 s64 timestamp; 100 u64 ev; 101 int dir; 102 struct iio_dev *indio_dev = data->indio_dev; 103 struct cros_ec_device *ec = data->ec; 104 105 mutex_lock(&data->lock); 106 if (state != data->last_proximity) { 107 if (data->enabled) { 108 timestamp = ktime_to_ns(ec->last_event_time); 109 if (iio_device_get_clock(indio_dev) != CLOCK_BOOTTIME) 110 timestamp = iio_get_time_ns(indio_dev); 111 112 dir = state ? IIO_EV_DIR_FALLING : IIO_EV_DIR_RISING; 113 ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0, 114 IIO_EV_TYPE_THRESH, dir); 115 iio_push_event(indio_dev, ev, timestamp); 116 } 117 data->last_proximity = state; 118 } 119 mutex_unlock(&data->lock); 120 } 121 122 static int cros_ec_mkbp_proximity_notify(struct notifier_block *nb, 123 unsigned long queued_during_suspend, 124 void *_ec) 125 { 126 struct cros_ec_mkbp_proximity_data *data; 127 struct cros_ec_device *ec = _ec; 128 u8 event_type = ec->event_data.event_type & EC_MKBP_EVENT_TYPE_MASK; 129 void *switches; 130 int state; 131 132 if (event_type == EC_MKBP_EVENT_SWITCH) { 133 data = container_of(nb, struct cros_ec_mkbp_proximity_data, 134 notifier); 135 136 switches = &ec->event_data.data.switches; 137 state = cros_ec_mkbp_proximity_parse_state(switches); 138 cros_ec_mkbp_proximity_push_event(data, state); 139 } 140 141 return NOTIFY_OK; 142 } 143 144 static int cros_ec_mkbp_proximity_read_raw(struct iio_dev *indio_dev, 145 const struct iio_chan_spec *chan, int *val, 146 int *val2, long mask) 147 { 148 struct cros_ec_mkbp_proximity_data *data = iio_priv(indio_dev); 149 struct cros_ec_device *ec = data->ec; 150 151 if (chan->type == IIO_PROXIMITY && mask == IIO_CHAN_INFO_RAW) 152 return cros_ec_mkbp_proximity_query(ec, val); 153 154 return -EINVAL; 155 } 156 157 static int cros_ec_mkbp_proximity_read_event_config(struct iio_dev *indio_dev, 158 const struct iio_chan_spec *chan, 159 enum iio_event_type type, 160 enum iio_event_direction dir) 161 { 162 struct cros_ec_mkbp_proximity_data *data = iio_priv(indio_dev); 163 164 return data->enabled; 165 } 166 167 static int cros_ec_mkbp_proximity_write_event_config(struct iio_dev *indio_dev, 168 const struct iio_chan_spec *chan, 169 enum iio_event_type type, 170 enum iio_event_direction dir, int state) 171 { 172 struct cros_ec_mkbp_proximity_data *data = iio_priv(indio_dev); 173 174 mutex_lock(&data->lock); 175 data->enabled = state; 176 mutex_unlock(&data->lock); 177 178 return 0; 179 } 180 181 static const struct iio_info cros_ec_mkbp_proximity_info = { 182 .read_raw = cros_ec_mkbp_proximity_read_raw, 183 .read_event_config = cros_ec_mkbp_proximity_read_event_config, 184 .write_event_config = cros_ec_mkbp_proximity_write_event_config, 185 }; 186 187 static int cros_ec_mkbp_proximity_resume(struct device *dev) 188 { 189 struct cros_ec_mkbp_proximity_data *data = dev_get_drvdata(dev); 190 struct cros_ec_device *ec = data->ec; 191 int ret, state; 192 193 ret = cros_ec_mkbp_proximity_query(ec, &state); 194 if (ret < 0) { 195 dev_warn(dev, "failed to fetch proximity state on resume: %d\n", 196 ret); 197 } else { 198 cros_ec_mkbp_proximity_push_event(data, state); 199 } 200 201 return 0; 202 } 203 204 static DEFINE_SIMPLE_DEV_PM_OPS(cros_ec_mkbp_proximity_pm_ops, NULL, 205 cros_ec_mkbp_proximity_resume); 206 207 static int cros_ec_mkbp_proximity_probe(struct platform_device *pdev) 208 { 209 struct device *dev = &pdev->dev; 210 struct cros_ec_device *ec = dev_get_drvdata(dev->parent); 211 struct iio_dev *indio_dev; 212 struct cros_ec_mkbp_proximity_data *data; 213 int ret; 214 215 indio_dev = devm_iio_device_alloc(dev, sizeof(*data)); 216 if (!indio_dev) 217 return -ENOMEM; 218 219 data = iio_priv(indio_dev); 220 data->ec = ec; 221 data->indio_dev = indio_dev; 222 data->last_proximity = -1; /* Unknown to start */ 223 mutex_init(&data->lock); 224 platform_set_drvdata(pdev, data); 225 226 indio_dev->name = dev->driver->name; 227 indio_dev->info = &cros_ec_mkbp_proximity_info; 228 indio_dev->modes = INDIO_DIRECT_MODE; 229 indio_dev->channels = cros_ec_mkbp_proximity_chan_spec; 230 indio_dev->num_channels = ARRAY_SIZE(cros_ec_mkbp_proximity_chan_spec); 231 232 ret = devm_iio_device_register(dev, indio_dev); 233 if (ret) 234 return ret; 235 236 data->notifier.notifier_call = cros_ec_mkbp_proximity_notify; 237 blocking_notifier_chain_register(&ec->event_notifier, &data->notifier); 238 239 return 0; 240 } 241 242 static int cros_ec_mkbp_proximity_remove(struct platform_device *pdev) 243 { 244 struct cros_ec_mkbp_proximity_data *data = platform_get_drvdata(pdev); 245 struct cros_ec_device *ec = data->ec; 246 247 blocking_notifier_chain_unregister(&ec->event_notifier, 248 &data->notifier); 249 250 return 0; 251 } 252 253 static const struct of_device_id cros_ec_mkbp_proximity_of_match[] = { 254 { .compatible = "google,cros-ec-mkbp-proximity" }, 255 {} 256 }; 257 MODULE_DEVICE_TABLE(of, cros_ec_mkbp_proximity_of_match); 258 259 static struct platform_driver cros_ec_mkbp_proximity_driver = { 260 .driver = { 261 .name = "cros-ec-mkbp-proximity", 262 .of_match_table = cros_ec_mkbp_proximity_of_match, 263 .pm = pm_sleep_ptr(&cros_ec_mkbp_proximity_pm_ops), 264 }, 265 .probe = cros_ec_mkbp_proximity_probe, 266 .remove = cros_ec_mkbp_proximity_remove, 267 }; 268 module_platform_driver(cros_ec_mkbp_proximity_driver); 269 270 MODULE_LICENSE("GPL v2"); 271 MODULE_DESCRIPTION("ChromeOS EC MKBP proximity sensor driver"); 272