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 (sensor_hub_device_open(st->hsdev))
117 atomic_inc(&st->data_ready);
119 state_val = hid_sensor_get_usage_index(st->hsdev,
120 st->power_state.report_id,
121 st->power_state.index,
122 HID_USAGE_SENSOR_PROP_POWER_STATE_D0_FULL_POWER_ENUM);
123 report_val = hid_sensor_get_usage_index(st->hsdev,
124 st->report_state.report_id,
125 st->report_state.index,
126 HID_USAGE_SENSOR_PROP_REPORTING_STATE_ALL_EVENTS_ENUM);
128 poll_value = hid_sensor_read_poll_value(st);
132 val = atomic_dec_if_positive(&st->data_ready);
136 sensor_hub_device_close(st->hsdev);
137 state_val = hid_sensor_get_usage_index(st->hsdev,
138 st->power_state.report_id,
139 st->power_state.index,
140 HID_USAGE_SENSOR_PROP_POWER_STATE_D4_POWER_OFF_ENUM);
141 report_val = hid_sensor_get_usage_index(st->hsdev,
142 st->report_state.report_id,
143 st->report_state.index,
144 HID_USAGE_SENSOR_PROP_REPORTING_STATE_NO_EVENTS_ENUM);
147 if (state_val >= 0) {
148 state_val += st->power_state.logical_minimum;
149 sensor_hub_set_feature(st->hsdev, st->power_state.report_id,
150 st->power_state.index, sizeof(state_val),
154 if (report_val >= 0) {
155 report_val += st->report_state.logical_minimum;
156 sensor_hub_set_feature(st->hsdev, st->report_state.report_id,
157 st->report_state.index,
162 pr_debug("HID_SENSOR %s set power_state %d report_state %d\n",
163 st->pdev->name, state_val, report_val);
165 sensor_hub_get_feature(st->hsdev, st->power_state.report_id,
166 st->power_state.index,
167 sizeof(state_val), &state_val);
168 if (state && poll_value)
169 msleep_interruptible(poll_value * 2);
173 EXPORT_SYMBOL(hid_sensor_power_state);
175 int hid_sensor_power_state(struct hid_sensor_common *st, bool state)
181 atomic_set(&st->user_requested_state, state);
183 ret = pm_runtime_get_sync(&st->pdev->dev);
185 pm_runtime_mark_last_busy(&st->pdev->dev);
186 pm_runtime_use_autosuspend(&st->pdev->dev);
187 ret = pm_runtime_put_autosuspend(&st->pdev->dev);
191 pm_runtime_put_noidle(&st->pdev->dev);
197 atomic_set(&st->user_requested_state, state);
198 return _hid_sensor_power_state(st, state);
202 static void hid_sensor_set_power_work(struct work_struct *work)
204 struct hid_sensor_common *attrb = container_of(work,
205 struct hid_sensor_common,
208 if (attrb->poll_interval >= 0)
209 sensor_hub_set_feature(attrb->hsdev, attrb->poll.report_id,
211 sizeof(attrb->poll_interval),
212 &attrb->poll_interval);
214 if (attrb->raw_hystersis >= 0)
215 sensor_hub_set_feature(attrb->hsdev,
216 attrb->sensitivity.report_id,
217 attrb->sensitivity.index,
218 sizeof(attrb->raw_hystersis),
219 &attrb->raw_hystersis);
221 if (attrb->latency_ms > 0)
222 hid_sensor_set_report_latency(attrb, attrb->latency_ms);
224 _hid_sensor_power_state(attrb, true);
227 static int hid_sensor_data_rdy_trigger_set_state(struct iio_trigger *trig,
230 return hid_sensor_power_state(iio_trigger_get_drvdata(trig), state);
233 void hid_sensor_remove_trigger(struct hid_sensor_common *attrb)
235 pm_runtime_disable(&attrb->pdev->dev);
236 pm_runtime_set_suspended(&attrb->pdev->dev);
237 pm_runtime_put_noidle(&attrb->pdev->dev);
239 cancel_work_sync(&attrb->work);
240 iio_trigger_unregister(attrb->trigger);
241 iio_trigger_free(attrb->trigger);
243 EXPORT_SYMBOL(hid_sensor_remove_trigger);
245 static const struct iio_trigger_ops hid_sensor_trigger_ops = {
246 .owner = THIS_MODULE,
247 .set_trigger_state = &hid_sensor_data_rdy_trigger_set_state,
250 int hid_sensor_setup_trigger(struct iio_dev *indio_dev, const char *name,
251 struct hid_sensor_common *attrb)
254 struct iio_trigger *trig;
256 trig = iio_trigger_alloc("%s-dev%d", name, indio_dev->id);
258 dev_err(&indio_dev->dev, "Trigger Allocate Failed\n");
263 trig->dev.parent = indio_dev->dev.parent;
264 iio_trigger_set_drvdata(trig, attrb);
265 trig->ops = &hid_sensor_trigger_ops;
266 ret = iio_trigger_register(trig);
269 dev_err(&indio_dev->dev, "Trigger Register Failed\n");
270 goto error_free_trig;
272 attrb->trigger = trig;
273 indio_dev->trig = iio_trigger_get(trig);
275 hid_sensor_setup_batch_mode(indio_dev, attrb);
277 ret = pm_runtime_set_active(&indio_dev->dev);
279 goto error_unreg_trigger;
281 iio_device_set_drvdata(indio_dev, attrb);
283 INIT_WORK(&attrb->work, hid_sensor_set_power_work);
285 pm_suspend_ignore_children(&attrb->pdev->dev, true);
286 pm_runtime_enable(&attrb->pdev->dev);
287 /* Default to 3 seconds, but can be changed from sysfs */
288 pm_runtime_set_autosuspend_delay(&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");