1 /* 2 * HID Sensors Driver 3 * Copyright (c) 2012, Intel Corporation. 4 * 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. 8 * 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 12 * more details. 13 * 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. 17 * 18 */ 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/hid-sensor-hub.h> 26 #include <linux/iio/iio.h> 27 #include <linux/iio/sysfs.h> 28 29 static struct { 30 u32 usage_id; 31 int unit; /* 0 for default others from HID sensor spec */ 32 int scale_val0; /* scale, whole number */ 33 int scale_val1; /* scale, fraction in nanos */ 34 } unit_conversion[] = { 35 {HID_USAGE_SENSOR_ACCEL_3D, 0, 9, 806650000}, 36 {HID_USAGE_SENSOR_ACCEL_3D, 37 HID_USAGE_SENSOR_UNITS_METERS_PER_SEC_SQRD, 1, 0}, 38 {HID_USAGE_SENSOR_ACCEL_3D, 39 HID_USAGE_SENSOR_UNITS_G, 9, 806650000}, 40 41 {HID_USAGE_SENSOR_GYRO_3D, 0, 0, 17453293}, 42 {HID_USAGE_SENSOR_GYRO_3D, 43 HID_USAGE_SENSOR_UNITS_RADIANS_PER_SECOND, 1, 0}, 44 {HID_USAGE_SENSOR_GYRO_3D, 45 HID_USAGE_SENSOR_UNITS_DEGREES_PER_SECOND, 0, 17453293}, 46 47 {HID_USAGE_SENSOR_COMPASS_3D, 0, 0, 1000000}, 48 {HID_USAGE_SENSOR_COMPASS_3D, HID_USAGE_SENSOR_UNITS_GAUSS, 1, 0}, 49 50 {HID_USAGE_SENSOR_INCLINOMETER_3D, 0, 0, 17453293}, 51 {HID_USAGE_SENSOR_INCLINOMETER_3D, 52 HID_USAGE_SENSOR_UNITS_DEGREES, 0, 17453293}, 53 {HID_USAGE_SENSOR_INCLINOMETER_3D, 54 HID_USAGE_SENSOR_UNITS_RADIANS, 1, 0}, 55 56 {HID_USAGE_SENSOR_ALS, 0, 1, 0}, 57 {HID_USAGE_SENSOR_ALS, HID_USAGE_SENSOR_UNITS_LUX, 1, 0}, 58 59 {HID_USAGE_SENSOR_PRESSURE, 0, 100, 0}, 60 {HID_USAGE_SENSOR_PRESSURE, HID_USAGE_SENSOR_UNITS_PASCAL, 0, 1000000}, 61 }; 62 63 static int pow_10(unsigned power) 64 { 65 int i; 66 int ret = 1; 67 for (i = 0; i < power; ++i) 68 ret = ret * 10; 69 70 return ret; 71 } 72 73 static void simple_div(int dividend, int divisor, int *whole, 74 int *micro_frac) 75 { 76 int rem; 77 int exp = 0; 78 79 *micro_frac = 0; 80 if (divisor == 0) { 81 *whole = 0; 82 return; 83 } 84 *whole = dividend/divisor; 85 rem = dividend % divisor; 86 if (rem) { 87 while (rem <= divisor) { 88 rem *= 10; 89 exp++; 90 } 91 *micro_frac = (rem / divisor) * pow_10(6-exp); 92 } 93 } 94 95 static void split_micro_fraction(unsigned int no, int exp, int *val1, int *val2) 96 { 97 *val1 = no/pow_10(exp); 98 *val2 = no%pow_10(exp) * pow_10(6-exp); 99 } 100 101 /* 102 VTF format uses exponent and variable size format. 103 For example if the size is 2 bytes 104 0x0067 with VTF16E14 format -> +1.03 105 To convert just change to 0x67 to decimal and use two decimal as E14 stands 106 for 10^-2. 107 Negative numbers are 2's complement 108 */ 109 static void convert_from_vtf_format(u32 value, int size, int exp, 110 int *val1, int *val2) 111 { 112 int sign = 1; 113 114 if (value & BIT(size*8 - 1)) { 115 value = ((1LL << (size * 8)) - value); 116 sign = -1; 117 } 118 exp = hid_sensor_convert_exponent(exp); 119 if (exp >= 0) { 120 *val1 = sign * value * pow_10(exp); 121 *val2 = 0; 122 } else { 123 split_micro_fraction(value, -exp, val1, val2); 124 if (*val1) 125 *val1 = sign * (*val1); 126 else 127 *val2 = sign * (*val2); 128 } 129 } 130 131 static u32 convert_to_vtf_format(int size, int exp, int val1, int val2) 132 { 133 u32 value; 134 int sign = 1; 135 136 if (val1 < 0 || val2 < 0) 137 sign = -1; 138 exp = hid_sensor_convert_exponent(exp); 139 if (exp < 0) { 140 value = abs(val1) * pow_10(-exp); 141 value += abs(val2) / pow_10(6+exp); 142 } else 143 value = abs(val1) / pow_10(exp); 144 if (sign < 0) 145 value = ((1LL << (size * 8)) - value); 146 147 return value; 148 } 149 150 s32 hid_sensor_read_poll_value(struct hid_sensor_common *st) 151 { 152 s32 value = 0; 153 int ret; 154 155 ret = sensor_hub_get_feature(st->hsdev, 156 st->poll.report_id, 157 st->poll.index, sizeof(value), &value); 158 159 if (ret < 0 || value < 0) { 160 return -EINVAL; 161 } else { 162 if (st->poll.units == HID_USAGE_SENSOR_UNITS_SECOND) 163 value = value * 1000; 164 } 165 166 return value; 167 } 168 EXPORT_SYMBOL(hid_sensor_read_poll_value); 169 170 int hid_sensor_read_samp_freq_value(struct hid_sensor_common *st, 171 int *val1, int *val2) 172 { 173 s32 value; 174 int ret; 175 176 ret = sensor_hub_get_feature(st->hsdev, 177 st->poll.report_id, 178 st->poll.index, sizeof(value), &value); 179 if (ret < 0 || value < 0) { 180 *val1 = *val2 = 0; 181 return -EINVAL; 182 } else { 183 if (st->poll.units == HID_USAGE_SENSOR_UNITS_MILLISECOND) 184 simple_div(1000, value, val1, val2); 185 else if (st->poll.units == HID_USAGE_SENSOR_UNITS_SECOND) 186 simple_div(1, value, val1, val2); 187 else { 188 *val1 = *val2 = 0; 189 return -EINVAL; 190 } 191 } 192 193 return IIO_VAL_INT_PLUS_MICRO; 194 } 195 EXPORT_SYMBOL(hid_sensor_read_samp_freq_value); 196 197 int hid_sensor_write_samp_freq_value(struct hid_sensor_common *st, 198 int val1, int val2) 199 { 200 s32 value; 201 int ret; 202 203 if (val1 < 0 || val2 < 0) 204 return -EINVAL; 205 206 value = val1 * pow_10(6) + val2; 207 if (value) { 208 if (st->poll.units == HID_USAGE_SENSOR_UNITS_MILLISECOND) 209 value = pow_10(9)/value; 210 else if (st->poll.units == HID_USAGE_SENSOR_UNITS_SECOND) 211 value = pow_10(6)/value; 212 else 213 value = 0; 214 } 215 ret = sensor_hub_set_feature(st->hsdev, st->poll.report_id, 216 st->poll.index, sizeof(value), &value); 217 if (ret < 0 || value < 0) 218 ret = -EINVAL; 219 220 return ret; 221 } 222 EXPORT_SYMBOL(hid_sensor_write_samp_freq_value); 223 224 int hid_sensor_read_raw_hyst_value(struct hid_sensor_common *st, 225 int *val1, int *val2) 226 { 227 s32 value; 228 int ret; 229 230 ret = sensor_hub_get_feature(st->hsdev, 231 st->sensitivity.report_id, 232 st->sensitivity.index, sizeof(value), 233 &value); 234 if (ret < 0 || value < 0) { 235 *val1 = *val2 = 0; 236 return -EINVAL; 237 } else { 238 convert_from_vtf_format(value, st->sensitivity.size, 239 st->sensitivity.unit_expo, 240 val1, val2); 241 } 242 243 return IIO_VAL_INT_PLUS_MICRO; 244 } 245 EXPORT_SYMBOL(hid_sensor_read_raw_hyst_value); 246 247 int hid_sensor_write_raw_hyst_value(struct hid_sensor_common *st, 248 int val1, int val2) 249 { 250 s32 value; 251 int ret; 252 253 if (val1 < 0 || val2 < 0) 254 return -EINVAL; 255 256 value = convert_to_vtf_format(st->sensitivity.size, 257 st->sensitivity.unit_expo, 258 val1, val2); 259 ret = sensor_hub_set_feature(st->hsdev, st->sensitivity.report_id, 260 st->sensitivity.index, sizeof(value), 261 &value); 262 if (ret < 0 || value < 0) 263 ret = -EINVAL; 264 265 return ret; 266 } 267 EXPORT_SYMBOL(hid_sensor_write_raw_hyst_value); 268 269 /* 270 * This fuction applies the unit exponent to the scale. 271 * For example: 272 * 9.806650000 ->exp:2-> val0[980]val1[665000000] 273 * 9.000806000 ->exp:2-> val0[900]val1[80600000] 274 * 0.174535293 ->exp:2-> val0[17]val1[453529300] 275 * 1.001745329 ->exp:0-> val0[1]val1[1745329] 276 * 1.001745329 ->exp:2-> val0[100]val1[174532900] 277 * 1.001745329 ->exp:4-> val0[10017]val1[453290000] 278 * 9.806650000 ->exp:-2-> val0[0]val1[98066500] 279 */ 280 static void adjust_exponent_nano(int *val0, int *val1, int scale0, 281 int scale1, int exp) 282 { 283 int i; 284 int x; 285 int res; 286 int rem; 287 288 if (exp > 0) { 289 *val0 = scale0 * pow_10(exp); 290 res = 0; 291 if (exp > 9) { 292 *val1 = 0; 293 return; 294 } 295 for (i = 0; i < exp; ++i) { 296 x = scale1 / pow_10(8 - i); 297 res += (pow_10(exp - 1 - i) * x); 298 scale1 = scale1 % pow_10(8 - i); 299 } 300 *val0 += res; 301 *val1 = scale1 * pow_10(exp); 302 } else if (exp < 0) { 303 exp = abs(exp); 304 if (exp > 9) { 305 *val0 = *val1 = 0; 306 return; 307 } 308 *val0 = scale0 / pow_10(exp); 309 rem = scale0 % pow_10(exp); 310 res = 0; 311 for (i = 0; i < (9 - exp); ++i) { 312 x = scale1 / pow_10(8 - i); 313 res += (pow_10(8 - exp - i) * x); 314 scale1 = scale1 % pow_10(8 - i); 315 } 316 *val1 = rem * pow_10(9 - exp) + res; 317 } else { 318 *val0 = scale0; 319 *val1 = scale1; 320 } 321 } 322 323 int hid_sensor_format_scale(u32 usage_id, 324 struct hid_sensor_hub_attribute_info *attr_info, 325 int *val0, int *val1) 326 { 327 int i; 328 int exp; 329 330 *val0 = 1; 331 *val1 = 0; 332 333 for (i = 0; i < ARRAY_SIZE(unit_conversion); ++i) { 334 if (unit_conversion[i].usage_id == usage_id && 335 unit_conversion[i].unit == attr_info->units) { 336 exp = hid_sensor_convert_exponent( 337 attr_info->unit_expo); 338 adjust_exponent_nano(val0, val1, 339 unit_conversion[i].scale_val0, 340 unit_conversion[i].scale_val1, exp); 341 break; 342 } 343 } 344 345 return IIO_VAL_INT_PLUS_NANO; 346 } 347 EXPORT_SYMBOL(hid_sensor_format_scale); 348 349 static 350 int hid_sensor_get_reporting_interval(struct hid_sensor_hub_device *hsdev, 351 u32 usage_id, 352 struct hid_sensor_common *st) 353 { 354 sensor_hub_input_get_attribute_info(hsdev, 355 HID_FEATURE_REPORT, usage_id, 356 HID_USAGE_SENSOR_PROP_REPORT_INTERVAL, 357 &st->poll); 358 /* Default unit of measure is milliseconds */ 359 if (st->poll.units == 0) 360 st->poll.units = HID_USAGE_SENSOR_UNITS_MILLISECOND; 361 return 0; 362 363 } 364 365 int hid_sensor_parse_common_attributes(struct hid_sensor_hub_device *hsdev, 366 u32 usage_id, 367 struct hid_sensor_common *st) 368 { 369 370 371 hid_sensor_get_reporting_interval(hsdev, usage_id, st); 372 373 sensor_hub_input_get_attribute_info(hsdev, 374 HID_FEATURE_REPORT, usage_id, 375 HID_USAGE_SENSOR_PROP_REPORT_STATE, 376 &st->report_state); 377 378 sensor_hub_input_get_attribute_info(hsdev, 379 HID_FEATURE_REPORT, usage_id, 380 HID_USAGE_SENSOR_PROY_POWER_STATE, 381 &st->power_state); 382 383 sensor_hub_input_get_attribute_info(hsdev, 384 HID_FEATURE_REPORT, usage_id, 385 HID_USAGE_SENSOR_PROP_SENSITIVITY_ABS, 386 &st->sensitivity); 387 388 hid_dbg(hsdev->hdev, "common attributes: %x:%x, %x:%x, %x:%x %x:%x\n", 389 st->poll.index, st->poll.report_id, 390 st->report_state.index, st->report_state.report_id, 391 st->power_state.index, st->power_state.report_id, 392 st->sensitivity.index, st->sensitivity.report_id); 393 394 return 0; 395 } 396 EXPORT_SYMBOL(hid_sensor_parse_common_attributes); 397 398 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>"); 399 MODULE_DESCRIPTION("HID Sensor common attribute processing"); 400 MODULE_LICENSE("GPL"); 401