3 * Copyright (c) 2012, Intel Corporation.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
19 #include <linux/device.h>
20 #include <linux/platform_device.h>
21 #include <linux/module.h>
22 #include <linux/interrupt.h>
23 #include <linux/irq.h>
24 #include <linux/slab.h>
25 #include <linux/delay.h>
26 #include <linux/hid-sensor-hub.h>
27 #include <linux/iio/iio.h>
28 #include <linux/iio/trigger.h>
29 #include <linux/iio/buffer.h>
30 #include <linux/iio/sysfs.h>
31 #include "hid-sensor-trigger.h"
33 static ssize_t _hid_sensor_set_report_latency(struct device *dev,
34 struct device_attribute *attr,
35 const char *buf, size_t len)
37 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
38 struct hid_sensor_common *attrb = iio_device_get_drvdata(indio_dev);
39 int integer, fract, ret;
42 ret = iio_str_to_fixpoint(buf, 100000, &integer, &fract);
46 latency = integer * 1000 + fract / 1000;
47 ret = hid_sensor_set_report_latency(attrb, latency);
51 attrb->latency_ms = hid_sensor_get_report_latency(attrb);
56 static ssize_t _hid_sensor_get_report_latency(struct device *dev,
57 struct device_attribute *attr,
60 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
61 struct hid_sensor_common *attrb = iio_device_get_drvdata(indio_dev);
64 latency = hid_sensor_get_report_latency(attrb);
68 return sprintf(buf, "%d.%06u\n", latency / 1000, (latency % 1000) * 1000);
71 static ssize_t _hid_sensor_get_fifo_state(struct device *dev,
72 struct device_attribute *attr,
75 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
76 struct hid_sensor_common *attrb = iio_device_get_drvdata(indio_dev);
79 latency = hid_sensor_get_report_latency(attrb);
83 return sprintf(buf, "%d\n", !!latency);
86 static IIO_DEVICE_ATTR(hwfifo_timeout, 0644,
87 _hid_sensor_get_report_latency,
88 _hid_sensor_set_report_latency, 0);
89 static IIO_DEVICE_ATTR(hwfifo_enabled, 0444,
90 _hid_sensor_get_fifo_state, NULL, 0);
92 static const struct attribute *hid_sensor_fifo_attributes[] = {
93 &iio_dev_attr_hwfifo_timeout.dev_attr.attr,
94 &iio_dev_attr_hwfifo_enabled.dev_attr.attr,
98 static void hid_sensor_setup_batch_mode(struct iio_dev *indio_dev,
99 struct hid_sensor_common *st)
101 if (!hid_sensor_batch_mode_supported(st))
104 iio_buffer_set_attrs(indio_dev->buffer, hid_sensor_fifo_attributes);
107 static int _hid_sensor_power_state(struct hid_sensor_common *st, bool state)
114 if (!atomic_read(&st->user_requested_state))
116 if (sensor_hub_device_open(st->hsdev))
119 atomic_inc(&st->data_ready);
121 state_val = hid_sensor_get_usage_index(st->hsdev,
122 st->power_state.report_id,
123 st->power_state.index,
124 HID_USAGE_SENSOR_PROP_POWER_STATE_D0_FULL_POWER_ENUM);
125 report_val = hid_sensor_get_usage_index(st->hsdev,
126 st->report_state.report_id,
127 st->report_state.index,
128 HID_USAGE_SENSOR_PROP_REPORTING_STATE_ALL_EVENTS_ENUM);
130 poll_value = hid_sensor_read_poll_value(st);
134 val = atomic_dec_if_positive(&st->data_ready);
138 sensor_hub_device_close(st->hsdev);
139 state_val = hid_sensor_get_usage_index(st->hsdev,
140 st->power_state.report_id,
141 st->power_state.index,
142 HID_USAGE_SENSOR_PROP_POWER_STATE_D4_POWER_OFF_ENUM);
143 report_val = hid_sensor_get_usage_index(st->hsdev,
144 st->report_state.report_id,
145 st->report_state.index,
146 HID_USAGE_SENSOR_PROP_REPORTING_STATE_NO_EVENTS_ENUM);
149 if (state_val >= 0) {
150 state_val += st->power_state.logical_minimum;
151 sensor_hub_set_feature(st->hsdev, st->power_state.report_id,
152 st->power_state.index, sizeof(state_val),
156 if (report_val >= 0) {
157 report_val += st->report_state.logical_minimum;
158 sensor_hub_set_feature(st->hsdev, st->report_state.report_id,
159 st->report_state.index,
164 sensor_hub_get_feature(st->hsdev, st->power_state.report_id,
165 st->power_state.index,
166 sizeof(state_val), &state_val);
167 if (state && poll_value)
168 msleep_interruptible(poll_value * 2);
172 EXPORT_SYMBOL(hid_sensor_power_state);
174 int hid_sensor_power_state(struct hid_sensor_common *st, bool state)
180 atomic_set(&st->user_requested_state, state);
182 ret = pm_runtime_get_sync(&st->pdev->dev);
184 pm_runtime_mark_last_busy(&st->pdev->dev);
185 ret = pm_runtime_put_autosuspend(&st->pdev->dev);
189 pm_runtime_put_noidle(&st->pdev->dev);
195 atomic_set(&st->user_requested_state, state);
196 return _hid_sensor_power_state(st, state);
200 static void hid_sensor_set_power_work(struct work_struct *work)
202 struct hid_sensor_common *attrb = container_of(work,
203 struct hid_sensor_common,
206 if (attrb->poll_interval >= 0)
207 sensor_hub_set_feature(attrb->hsdev, attrb->poll.report_id,
209 sizeof(attrb->poll_interval),
210 &attrb->poll_interval);
212 if (attrb->raw_hystersis >= 0)
213 sensor_hub_set_feature(attrb->hsdev,
214 attrb->sensitivity.report_id,
215 attrb->sensitivity.index,
216 sizeof(attrb->raw_hystersis),
217 &attrb->raw_hystersis);
219 if (attrb->latency_ms > 0)
220 hid_sensor_set_report_latency(attrb, attrb->latency_ms);
222 _hid_sensor_power_state(attrb, true);
225 static int hid_sensor_data_rdy_trigger_set_state(struct iio_trigger *trig,
228 return hid_sensor_power_state(iio_trigger_get_drvdata(trig), state);
231 void hid_sensor_remove_trigger(struct hid_sensor_common *attrb)
233 pm_runtime_disable(&attrb->pdev->dev);
234 pm_runtime_set_suspended(&attrb->pdev->dev);
235 pm_runtime_put_noidle(&attrb->pdev->dev);
237 cancel_work_sync(&attrb->work);
238 iio_trigger_unregister(attrb->trigger);
239 iio_trigger_free(attrb->trigger);
241 EXPORT_SYMBOL(hid_sensor_remove_trigger);
243 static const struct iio_trigger_ops hid_sensor_trigger_ops = {
244 .owner = THIS_MODULE,
245 .set_trigger_state = &hid_sensor_data_rdy_trigger_set_state,
248 int hid_sensor_setup_trigger(struct iio_dev *indio_dev, const char *name,
249 struct hid_sensor_common *attrb)
252 struct iio_trigger *trig;
254 trig = iio_trigger_alloc("%s-dev%d", name, indio_dev->id);
256 dev_err(&indio_dev->dev, "Trigger Allocate Failed\n");
261 trig->dev.parent = indio_dev->dev.parent;
262 iio_trigger_set_drvdata(trig, attrb);
263 trig->ops = &hid_sensor_trigger_ops;
264 ret = iio_trigger_register(trig);
267 dev_err(&indio_dev->dev, "Trigger Register Failed\n");
268 goto error_free_trig;
270 attrb->trigger = trig;
271 indio_dev->trig = iio_trigger_get(trig);
273 hid_sensor_setup_batch_mode(indio_dev, attrb);
275 ret = pm_runtime_set_active(&indio_dev->dev);
277 goto error_unreg_trigger;
279 iio_device_set_drvdata(indio_dev, attrb);
281 INIT_WORK(&attrb->work, hid_sensor_set_power_work);
283 pm_suspend_ignore_children(&attrb->pdev->dev, true);
284 pm_runtime_enable(&attrb->pdev->dev);
285 /* Default to 3 seconds, but can be changed from sysfs */
286 pm_runtime_set_autosuspend_delay(&attrb->pdev->dev,
288 pm_runtime_use_autosuspend(&attrb->pdev->dev);
292 iio_trigger_unregister(trig);
294 iio_trigger_free(trig);
298 EXPORT_SYMBOL(hid_sensor_setup_trigger);
300 static int __maybe_unused hid_sensor_suspend(struct device *dev)
302 struct platform_device *pdev = to_platform_device(dev);
303 struct iio_dev *indio_dev = platform_get_drvdata(pdev);
304 struct hid_sensor_common *attrb = iio_device_get_drvdata(indio_dev);
306 return _hid_sensor_power_state(attrb, false);
309 static int __maybe_unused hid_sensor_resume(struct device *dev)
311 struct platform_device *pdev = to_platform_device(dev);
312 struct iio_dev *indio_dev = platform_get_drvdata(pdev);
313 struct hid_sensor_common *attrb = iio_device_get_drvdata(indio_dev);
314 schedule_work(&attrb->work);
318 static int __maybe_unused hid_sensor_runtime_resume(struct device *dev)
320 struct platform_device *pdev = to_platform_device(dev);
321 struct iio_dev *indio_dev = platform_get_drvdata(pdev);
322 struct hid_sensor_common *attrb = iio_device_get_drvdata(indio_dev);
323 return _hid_sensor_power_state(attrb, true);
326 const struct dev_pm_ops hid_sensor_pm_ops = {
327 SET_SYSTEM_SLEEP_PM_OPS(hid_sensor_suspend, hid_sensor_resume)
328 SET_RUNTIME_PM_OPS(hid_sensor_suspend,
329 hid_sensor_runtime_resume, NULL)
331 EXPORT_SYMBOL(hid_sensor_pm_ops);
333 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
334 MODULE_DESCRIPTION("HID Sensor trigger processing");
335 MODULE_LICENSE("GPL");