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