1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * HID Sensors Driver 4 * Copyright (c) 2012, Intel Corporation. 5 */ 6 #include <linux/device.h> 7 #include <linux/platform_device.h> 8 #include <linux/module.h> 9 #include <linux/delay.h> 10 #include <linux/hid-sensor-hub.h> 11 #include <linux/workqueue.h> 12 #include <linux/iio/iio.h> 13 #include <linux/iio/trigger.h> 14 #include <linux/iio/triggered_buffer.h> 15 #include <linux/iio/trigger_consumer.h> 16 #include <linux/iio/sysfs.h> 17 #include <linux/iio/kfifo_buf.h> 18 #include "hid-sensor-trigger.h" 19 20 static ssize_t _hid_sensor_set_report_latency(struct device *dev, 21 struct device_attribute *attr, 22 const char *buf, size_t len) 23 { 24 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 25 struct hid_sensor_common *attrb = iio_device_get_drvdata(indio_dev); 26 int integer, fract, ret; 27 int latency; 28 29 ret = iio_str_to_fixpoint(buf, 100000, &integer, &fract); 30 if (ret) 31 return ret; 32 33 latency = integer * 1000 + fract / 1000; 34 ret = hid_sensor_set_report_latency(attrb, latency); 35 if (ret < 0) 36 return ret; 37 38 attrb->latency_ms = hid_sensor_get_report_latency(attrb); 39 40 return len; 41 } 42 43 static ssize_t _hid_sensor_get_report_latency(struct device *dev, 44 struct device_attribute *attr, 45 char *buf) 46 { 47 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 48 struct hid_sensor_common *attrb = iio_device_get_drvdata(indio_dev); 49 int latency; 50 51 latency = hid_sensor_get_report_latency(attrb); 52 if (latency < 0) 53 return latency; 54 55 return sprintf(buf, "%d.%06u\n", latency / 1000, (latency % 1000) * 1000); 56 } 57 58 static ssize_t _hid_sensor_get_fifo_state(struct device *dev, 59 struct device_attribute *attr, 60 char *buf) 61 { 62 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 63 struct hid_sensor_common *attrb = iio_device_get_drvdata(indio_dev); 64 int latency; 65 66 latency = hid_sensor_get_report_latency(attrb); 67 if (latency < 0) 68 return latency; 69 70 return sprintf(buf, "%d\n", !!latency); 71 } 72 73 static IIO_DEVICE_ATTR(hwfifo_timeout, 0644, 74 _hid_sensor_get_report_latency, 75 _hid_sensor_set_report_latency, 0); 76 static IIO_DEVICE_ATTR(hwfifo_enabled, 0444, 77 _hid_sensor_get_fifo_state, NULL, 0); 78 79 static const struct iio_dev_attr *hid_sensor_fifo_attributes[] = { 80 &iio_dev_attr_hwfifo_timeout, 81 &iio_dev_attr_hwfifo_enabled, 82 NULL, 83 }; 84 85 static int _hid_sensor_power_state(struct hid_sensor_common *st, bool state) 86 { 87 int state_val; 88 int report_val; 89 s32 poll_value = 0; 90 91 if (state) { 92 if (sensor_hub_device_open(st->hsdev)) 93 return -EIO; 94 95 atomic_inc(&st->data_ready); 96 97 state_val = hid_sensor_get_usage_index(st->hsdev, 98 st->power_state.report_id, 99 st->power_state.index, 100 HID_USAGE_SENSOR_PROP_POWER_STATE_D0_FULL_POWER_ENUM); 101 report_val = hid_sensor_get_usage_index(st->hsdev, 102 st->report_state.report_id, 103 st->report_state.index, 104 HID_USAGE_SENSOR_PROP_REPORTING_STATE_ALL_EVENTS_ENUM); 105 106 poll_value = hid_sensor_read_poll_value(st); 107 } else { 108 int val; 109 110 val = atomic_dec_if_positive(&st->data_ready); 111 if (val < 0) 112 return 0; 113 114 sensor_hub_device_close(st->hsdev); 115 state_val = hid_sensor_get_usage_index(st->hsdev, 116 st->power_state.report_id, 117 st->power_state.index, 118 HID_USAGE_SENSOR_PROP_POWER_STATE_D4_POWER_OFF_ENUM); 119 report_val = hid_sensor_get_usage_index(st->hsdev, 120 st->report_state.report_id, 121 st->report_state.index, 122 HID_USAGE_SENSOR_PROP_REPORTING_STATE_NO_EVENTS_ENUM); 123 } 124 125 if (state_val >= 0) { 126 state_val += st->power_state.logical_minimum; 127 sensor_hub_set_feature(st->hsdev, st->power_state.report_id, 128 st->power_state.index, sizeof(state_val), 129 &state_val); 130 } 131 132 if (report_val >= 0) { 133 report_val += st->report_state.logical_minimum; 134 sensor_hub_set_feature(st->hsdev, st->report_state.report_id, 135 st->report_state.index, 136 sizeof(report_val), 137 &report_val); 138 } 139 140 pr_debug("HID_SENSOR %s set power_state %d report_state %d\n", 141 st->pdev->name, state_val, report_val); 142 143 sensor_hub_get_feature(st->hsdev, st->power_state.report_id, 144 st->power_state.index, 145 sizeof(state_val), &state_val); 146 if (state && poll_value) 147 msleep_interruptible(poll_value * 2); 148 149 return 0; 150 } 151 EXPORT_SYMBOL_NS(hid_sensor_power_state, "IIO_HID"); 152 153 int hid_sensor_power_state(struct hid_sensor_common *st, bool state) 154 { 155 156 #ifdef CONFIG_PM 157 int ret; 158 159 if (atomic_add_unless(&st->runtime_pm_enable, 1, 1)) 160 pm_runtime_enable(&st->pdev->dev); 161 162 if (state) { 163 atomic_inc(&st->user_requested_state); 164 ret = pm_runtime_resume_and_get(&st->pdev->dev); 165 } else { 166 atomic_dec(&st->user_requested_state); 167 pm_runtime_use_autosuspend(&st->pdev->dev); 168 ret = pm_runtime_put_autosuspend(&st->pdev->dev); 169 } 170 if (ret < 0) 171 return ret; 172 173 return 0; 174 #else 175 atomic_set(&st->user_requested_state, state); 176 return _hid_sensor_power_state(st, state); 177 #endif 178 } 179 180 static void hid_sensor_set_power_work(struct work_struct *work) 181 { 182 struct hid_sensor_common *attrb = container_of(work, 183 struct hid_sensor_common, 184 work); 185 186 if (attrb->poll_interval >= 0) 187 sensor_hub_set_feature(attrb->hsdev, attrb->poll.report_id, 188 attrb->poll.index, 189 sizeof(attrb->poll_interval), 190 &attrb->poll_interval); 191 192 if (attrb->raw_hystersis >= 0) 193 sensor_hub_set_feature(attrb->hsdev, 194 attrb->sensitivity.report_id, 195 attrb->sensitivity.index, 196 sizeof(attrb->raw_hystersis), 197 &attrb->raw_hystersis); 198 199 if (attrb->latency_ms > 0) 200 hid_sensor_set_report_latency(attrb, attrb->latency_ms); 201 202 if (atomic_read(&attrb->user_requested_state)) 203 _hid_sensor_power_state(attrb, true); 204 } 205 206 static int buffer_postenable(struct iio_dev *indio_dev) 207 { 208 return hid_sensor_power_state(iio_device_get_drvdata(indio_dev), 1); 209 } 210 211 static int buffer_predisable(struct iio_dev *indio_dev) 212 { 213 return hid_sensor_power_state(iio_device_get_drvdata(indio_dev), 0); 214 } 215 216 static const struct iio_buffer_setup_ops hid_sensor_buffer_ops = { 217 .postenable = buffer_postenable, 218 .predisable = buffer_predisable, 219 }; 220 221 void hid_sensor_remove_trigger(struct iio_dev *indio_dev, 222 struct hid_sensor_common *attrb) 223 { 224 if (atomic_read(&attrb->runtime_pm_enable)) 225 pm_runtime_disable(&attrb->pdev->dev); 226 227 pm_runtime_set_suspended(&attrb->pdev->dev); 228 229 cancel_work_sync(&attrb->work); 230 iio_trigger_unregister(attrb->trigger); 231 iio_trigger_free(attrb->trigger); 232 } 233 EXPORT_SYMBOL_NS(hid_sensor_remove_trigger, "IIO_HID"); 234 235 int hid_sensor_setup_trigger(struct iio_dev *indio_dev, const char *name, 236 struct hid_sensor_common *attrb) 237 { 238 const struct iio_dev_attr **fifo_attrs; 239 int ret; 240 struct iio_trigger *trig; 241 242 if (hid_sensor_batch_mode_supported(attrb)) 243 fifo_attrs = hid_sensor_fifo_attributes; 244 else 245 fifo_attrs = NULL; 246 247 indio_dev->modes = INDIO_DIRECT_MODE | INDIO_HARDWARE_TRIGGERED; 248 249 ret = devm_iio_kfifo_buffer_setup_ext(&indio_dev->dev, indio_dev, 250 &hid_sensor_buffer_ops, 251 fifo_attrs); 252 if (ret) { 253 dev_err(&indio_dev->dev, "Kfifo Buffer Setup Failed\n"); 254 return ret; 255 } 256 257 /* 258 * The current user space in distro "iio-sensor-proxy" is not working in 259 * trigerless mode and it expects 260 * /sys/bus/iio/devices/iio:device0/trigger/current_trigger. 261 * The change replacing iio_triggered_buffer_setup_ext() with 262 * devm_iio_kfifo_buffer_setup_ext() will not create attribute without 263 * registering a trigger with INDIO_HARDWARE_TRIGGERED. 264 * So the below code fragment is still required. 265 */ 266 267 trig = iio_trigger_alloc(indio_dev->dev.parent, 268 "%s-dev%d", name, iio_device_id(indio_dev)); 269 if (trig == NULL) { 270 dev_err(&indio_dev->dev, "Trigger Allocate Failed\n"); 271 return -ENOMEM; 272 } 273 274 iio_trigger_set_drvdata(trig, attrb); 275 ret = iio_trigger_register(trig); 276 277 if (ret) { 278 dev_err(&indio_dev->dev, "Trigger Register Failed\n"); 279 goto error_free_trig; 280 } 281 attrb->trigger = trig; 282 indio_dev->trig = iio_trigger_get(trig); 283 284 ret = pm_runtime_set_active(&indio_dev->dev); 285 if (ret) 286 goto error_unreg_trigger; 287 288 iio_device_set_drvdata(indio_dev, attrb); 289 290 INIT_WORK(&attrb->work, hid_sensor_set_power_work); 291 292 pm_suspend_ignore_children(&attrb->pdev->dev, true); 293 /* Default to 3 seconds, but can be changed from sysfs */ 294 pm_runtime_set_autosuspend_delay(&attrb->pdev->dev, 295 3000); 296 return ret; 297 error_unreg_trigger: 298 iio_trigger_unregister(trig); 299 error_free_trig: 300 iio_trigger_free(trig); 301 return ret; 302 } 303 EXPORT_SYMBOL_NS(hid_sensor_setup_trigger, "IIO_HID"); 304 305 static int __maybe_unused hid_sensor_suspend(struct device *dev) 306 { 307 struct iio_dev *indio_dev = dev_get_drvdata(dev); 308 struct hid_sensor_common *attrb = iio_device_get_drvdata(indio_dev); 309 310 return _hid_sensor_power_state(attrb, false); 311 } 312 313 static int __maybe_unused hid_sensor_resume(struct device *dev) 314 { 315 struct iio_dev *indio_dev = dev_get_drvdata(dev); 316 struct hid_sensor_common *attrb = iio_device_get_drvdata(indio_dev); 317 schedule_work(&attrb->work); 318 return 0; 319 } 320 321 static int __maybe_unused hid_sensor_runtime_resume(struct device *dev) 322 { 323 struct iio_dev *indio_dev = dev_get_drvdata(dev); 324 struct hid_sensor_common *attrb = iio_device_get_drvdata(indio_dev); 325 return _hid_sensor_power_state(attrb, true); 326 } 327 328 const struct dev_pm_ops hid_sensor_pm_ops = { 329 SET_SYSTEM_SLEEP_PM_OPS(hid_sensor_suspend, hid_sensor_resume) 330 SET_RUNTIME_PM_OPS(hid_sensor_suspend, 331 hid_sensor_runtime_resume, NULL) 332 }; 333 EXPORT_SYMBOL_NS(hid_sensor_pm_ops, "IIO_HID"); 334 335 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>"); 336 MODULE_DESCRIPTION("HID Sensor trigger processing"); 337 MODULE_LICENSE("GPL"); 338 MODULE_IMPORT_NS("IIO_HID_ATTRIBUTES"); 339