0001
0002
0003
0004
0005
0006
0007
0008 #include <linux/kernel.h>
0009 #include <linux/module.h>
0010 #include <linux/mutex.h>
0011 #include <linux/notifier.h>
0012 #include <linux/of.h>
0013 #include <linux/platform_device.h>
0014 #include <linux/slab.h>
0015 #include <linux/types.h>
0016
0017 #include <linux/platform_data/cros_ec_commands.h>
0018 #include <linux/platform_data/cros_ec_proto.h>
0019
0020 #include <linux/iio/events.h>
0021 #include <linux/iio/iio.h>
0022 #include <linux/iio/sysfs.h>
0023
0024 #include <asm/unaligned.h>
0025
0026 struct cros_ec_mkbp_proximity_data {
0027 struct cros_ec_device *ec;
0028 struct iio_dev *indio_dev;
0029 struct mutex lock;
0030 struct notifier_block notifier;
0031 int last_proximity;
0032 bool enabled;
0033 };
0034
0035 static const struct iio_event_spec cros_ec_mkbp_proximity_events[] = {
0036 {
0037 .type = IIO_EV_TYPE_THRESH,
0038 .dir = IIO_EV_DIR_EITHER,
0039 .mask_separate = BIT(IIO_EV_INFO_ENABLE),
0040 },
0041 };
0042
0043 static const struct iio_chan_spec cros_ec_mkbp_proximity_chan_spec[] = {
0044 {
0045 .type = IIO_PROXIMITY,
0046 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
0047 .event_spec = cros_ec_mkbp_proximity_events,
0048 .num_event_specs = ARRAY_SIZE(cros_ec_mkbp_proximity_events),
0049 },
0050 };
0051
0052 static int cros_ec_mkbp_proximity_parse_state(const void *data)
0053 {
0054 u32 switches = get_unaligned_le32(data);
0055
0056 return !!(switches & BIT(EC_MKBP_FRONT_PROXIMITY));
0057 }
0058
0059 static int cros_ec_mkbp_proximity_query(struct cros_ec_device *ec_dev,
0060 int *state)
0061 {
0062 struct {
0063 struct cros_ec_command msg;
0064 union {
0065 struct ec_params_mkbp_info params;
0066 u32 switches;
0067 };
0068 } __packed buf = { };
0069 struct ec_params_mkbp_info *params = &buf.params;
0070 struct cros_ec_command *msg = &buf.msg;
0071 u32 *switches = &buf.switches;
0072 size_t insize = sizeof(*switches);
0073 int ret;
0074
0075 msg->command = EC_CMD_MKBP_INFO;
0076 msg->version = 1;
0077 msg->outsize = sizeof(*params);
0078 msg->insize = insize;
0079
0080 params->info_type = EC_MKBP_INFO_CURRENT;
0081 params->event_type = EC_MKBP_EVENT_SWITCH;
0082
0083 ret = cros_ec_cmd_xfer_status(ec_dev, msg);
0084 if (ret < 0)
0085 return ret;
0086
0087 if (ret != insize) {
0088 dev_warn(ec_dev->dev, "wrong result size: %d != %zu\n", ret,
0089 insize);
0090 return -EPROTO;
0091 }
0092
0093 *state = cros_ec_mkbp_proximity_parse_state(switches);
0094 return IIO_VAL_INT;
0095 }
0096
0097 static void cros_ec_mkbp_proximity_push_event(struct cros_ec_mkbp_proximity_data *data, int state)
0098 {
0099 s64 timestamp;
0100 u64 ev;
0101 int dir;
0102 struct iio_dev *indio_dev = data->indio_dev;
0103 struct cros_ec_device *ec = data->ec;
0104
0105 mutex_lock(&data->lock);
0106 if (state != data->last_proximity) {
0107 if (data->enabled) {
0108 timestamp = ktime_to_ns(ec->last_event_time);
0109 if (iio_device_get_clock(indio_dev) != CLOCK_BOOTTIME)
0110 timestamp = iio_get_time_ns(indio_dev);
0111
0112 dir = state ? IIO_EV_DIR_FALLING : IIO_EV_DIR_RISING;
0113 ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0,
0114 IIO_EV_TYPE_THRESH, dir);
0115 iio_push_event(indio_dev, ev, timestamp);
0116 }
0117 data->last_proximity = state;
0118 }
0119 mutex_unlock(&data->lock);
0120 }
0121
0122 static int cros_ec_mkbp_proximity_notify(struct notifier_block *nb,
0123 unsigned long queued_during_suspend,
0124 void *_ec)
0125 {
0126 struct cros_ec_mkbp_proximity_data *data;
0127 struct cros_ec_device *ec = _ec;
0128 u8 event_type = ec->event_data.event_type & EC_MKBP_EVENT_TYPE_MASK;
0129 void *switches;
0130 int state;
0131
0132 if (event_type == EC_MKBP_EVENT_SWITCH) {
0133 data = container_of(nb, struct cros_ec_mkbp_proximity_data,
0134 notifier);
0135
0136 switches = &ec->event_data.data.switches;
0137 state = cros_ec_mkbp_proximity_parse_state(switches);
0138 cros_ec_mkbp_proximity_push_event(data, state);
0139 }
0140
0141 return NOTIFY_OK;
0142 }
0143
0144 static int cros_ec_mkbp_proximity_read_raw(struct iio_dev *indio_dev,
0145 const struct iio_chan_spec *chan, int *val,
0146 int *val2, long mask)
0147 {
0148 struct cros_ec_mkbp_proximity_data *data = iio_priv(indio_dev);
0149 struct cros_ec_device *ec = data->ec;
0150
0151 if (chan->type == IIO_PROXIMITY && mask == IIO_CHAN_INFO_RAW)
0152 return cros_ec_mkbp_proximity_query(ec, val);
0153
0154 return -EINVAL;
0155 }
0156
0157 static int cros_ec_mkbp_proximity_read_event_config(struct iio_dev *indio_dev,
0158 const struct iio_chan_spec *chan,
0159 enum iio_event_type type,
0160 enum iio_event_direction dir)
0161 {
0162 struct cros_ec_mkbp_proximity_data *data = iio_priv(indio_dev);
0163
0164 return data->enabled;
0165 }
0166
0167 static int cros_ec_mkbp_proximity_write_event_config(struct iio_dev *indio_dev,
0168 const struct iio_chan_spec *chan,
0169 enum iio_event_type type,
0170 enum iio_event_direction dir, int state)
0171 {
0172 struct cros_ec_mkbp_proximity_data *data = iio_priv(indio_dev);
0173
0174 mutex_lock(&data->lock);
0175 data->enabled = state;
0176 mutex_unlock(&data->lock);
0177
0178 return 0;
0179 }
0180
0181 static const struct iio_info cros_ec_mkbp_proximity_info = {
0182 .read_raw = cros_ec_mkbp_proximity_read_raw,
0183 .read_event_config = cros_ec_mkbp_proximity_read_event_config,
0184 .write_event_config = cros_ec_mkbp_proximity_write_event_config,
0185 };
0186
0187 static int cros_ec_mkbp_proximity_resume(struct device *dev)
0188 {
0189 struct cros_ec_mkbp_proximity_data *data = dev_get_drvdata(dev);
0190 struct cros_ec_device *ec = data->ec;
0191 int ret, state;
0192
0193 ret = cros_ec_mkbp_proximity_query(ec, &state);
0194 if (ret < 0) {
0195 dev_warn(dev, "failed to fetch proximity state on resume: %d\n",
0196 ret);
0197 } else {
0198 cros_ec_mkbp_proximity_push_event(data, state);
0199 }
0200
0201 return 0;
0202 }
0203
0204 static DEFINE_SIMPLE_DEV_PM_OPS(cros_ec_mkbp_proximity_pm_ops, NULL,
0205 cros_ec_mkbp_proximity_resume);
0206
0207 static int cros_ec_mkbp_proximity_probe(struct platform_device *pdev)
0208 {
0209 struct device *dev = &pdev->dev;
0210 struct cros_ec_device *ec = dev_get_drvdata(dev->parent);
0211 struct iio_dev *indio_dev;
0212 struct cros_ec_mkbp_proximity_data *data;
0213 int ret;
0214
0215 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
0216 if (!indio_dev)
0217 return -ENOMEM;
0218
0219 data = iio_priv(indio_dev);
0220 data->ec = ec;
0221 data->indio_dev = indio_dev;
0222 data->last_proximity = -1;
0223 mutex_init(&data->lock);
0224 platform_set_drvdata(pdev, data);
0225
0226 indio_dev->name = dev->driver->name;
0227 indio_dev->info = &cros_ec_mkbp_proximity_info;
0228 indio_dev->modes = INDIO_DIRECT_MODE;
0229 indio_dev->channels = cros_ec_mkbp_proximity_chan_spec;
0230 indio_dev->num_channels = ARRAY_SIZE(cros_ec_mkbp_proximity_chan_spec);
0231
0232 ret = devm_iio_device_register(dev, indio_dev);
0233 if (ret)
0234 return ret;
0235
0236 data->notifier.notifier_call = cros_ec_mkbp_proximity_notify;
0237 blocking_notifier_chain_register(&ec->event_notifier, &data->notifier);
0238
0239 return 0;
0240 }
0241
0242 static int cros_ec_mkbp_proximity_remove(struct platform_device *pdev)
0243 {
0244 struct cros_ec_mkbp_proximity_data *data = platform_get_drvdata(pdev);
0245 struct cros_ec_device *ec = data->ec;
0246
0247 blocking_notifier_chain_unregister(&ec->event_notifier,
0248 &data->notifier);
0249
0250 return 0;
0251 }
0252
0253 static const struct of_device_id cros_ec_mkbp_proximity_of_match[] = {
0254 { .compatible = "google,cros-ec-mkbp-proximity" },
0255 {}
0256 };
0257 MODULE_DEVICE_TABLE(of, cros_ec_mkbp_proximity_of_match);
0258
0259 static struct platform_driver cros_ec_mkbp_proximity_driver = {
0260 .driver = {
0261 .name = "cros-ec-mkbp-proximity",
0262 .of_match_table = cros_ec_mkbp_proximity_of_match,
0263 .pm = pm_sleep_ptr(&cros_ec_mkbp_proximity_pm_ops),
0264 },
0265 .probe = cros_ec_mkbp_proximity_probe,
0266 .remove = cros_ec_mkbp_proximity_remove,
0267 };
0268 module_platform_driver(cros_ec_mkbp_proximity_driver);
0269
0270 MODULE_LICENSE("GPL v2");
0271 MODULE_DESCRIPTION("ChromeOS EC MKBP proximity sensor driver");
