1 /* 2 * kxsd9.c simple support for the Kionix KXSD9 3D 3 * accelerometer. 4 * 5 * Copyright (c) 2008-2009 Jonathan Cameron <jic23@kernel.org> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 * 11 * The i2c interface is very similar, so shouldn't be a problem once 12 * I have a suitable wire made up. 13 * 14 * TODO: Support the motion detector 15 */ 16 17 #include <linux/device.h> 18 #include <linux/kernel.h> 19 #include <linux/sysfs.h> 20 #include <linux/slab.h> 21 #include <linux/module.h> 22 #include <linux/regmap.h> 23 #include <linux/bitops.h> 24 #include <linux/delay.h> 25 #include <linux/regulator/consumer.h> 26 #include <linux/pm_runtime.h> 27 #include <linux/iio/iio.h> 28 #include <linux/iio/sysfs.h> 29 #include <linux/iio/buffer.h> 30 #include <linux/iio/triggered_buffer.h> 31 #include <linux/iio/trigger_consumer.h> 32 33 #include "kxsd9.h" 34 35 #define KXSD9_REG_X 0x00 36 #define KXSD9_REG_Y 0x02 37 #define KXSD9_REG_Z 0x04 38 #define KXSD9_REG_AUX 0x06 39 #define KXSD9_REG_RESET 0x0a 40 #define KXSD9_REG_CTRL_C 0x0c 41 42 #define KXSD9_CTRL_C_FS_MASK 0x03 43 #define KXSD9_CTRL_C_FS_8G 0x00 44 #define KXSD9_CTRL_C_FS_6G 0x01 45 #define KXSD9_CTRL_C_FS_4G 0x02 46 #define KXSD9_CTRL_C_FS_2G 0x03 47 #define KXSD9_CTRL_C_MOT_LAT BIT(3) 48 #define KXSD9_CTRL_C_MOT_LEV BIT(4) 49 #define KXSD9_CTRL_C_LP_MASK 0xe0 50 #define KXSD9_CTRL_C_LP_NONE 0x00 51 #define KXSD9_CTRL_C_LP_2000HZC BIT(5) 52 #define KXSD9_CTRL_C_LP_2000HZB BIT(6) 53 #define KXSD9_CTRL_C_LP_2000HZA (BIT(5)|BIT(6)) 54 #define KXSD9_CTRL_C_LP_1000HZ BIT(7) 55 #define KXSD9_CTRL_C_LP_500HZ (BIT(7)|BIT(5)) 56 #define KXSD9_CTRL_C_LP_100HZ (BIT(7)|BIT(6)) 57 #define KXSD9_CTRL_C_LP_50HZ (BIT(7)|BIT(6)|BIT(5)) 58 59 #define KXSD9_REG_CTRL_B 0x0d 60 61 #define KXSD9_CTRL_B_CLK_HLD BIT(7) 62 #define KXSD9_CTRL_B_ENABLE BIT(6) 63 #define KXSD9_CTRL_B_ST BIT(5) /* Self-test */ 64 65 #define KXSD9_REG_CTRL_A 0x0e 66 67 /** 68 * struct kxsd9_state - device related storage 69 * @dev: pointer to the parent device 70 * @map: regmap to the device 71 * @orientation: mounting matrix, flipped axis etc 72 * @regs: regulators for this device, VDD and IOVDD 73 * @scale: the current scaling setting 74 */ 75 struct kxsd9_state { 76 struct device *dev; 77 struct regmap *map; 78 struct iio_mount_matrix orientation; 79 struct regulator_bulk_data regs[2]; 80 u8 scale; 81 }; 82 83 #define KXSD9_SCALE_2G "0.011978" 84 #define KXSD9_SCALE_4G "0.023927" 85 #define KXSD9_SCALE_6G "0.035934" 86 #define KXSD9_SCALE_8G "0.047853" 87 88 /* reverse order */ 89 static const int kxsd9_micro_scales[4] = { 47853, 35934, 23927, 11978 }; 90 91 #define KXSD9_ZERO_G_OFFSET -2048 92 93 /* 94 * Regulator names 95 */ 96 static const char kxsd9_reg_vdd[] = "vdd"; 97 static const char kxsd9_reg_iovdd[] = "iovdd"; 98 99 static int kxsd9_write_scale(struct iio_dev *indio_dev, int micro) 100 { 101 int ret, i; 102 struct kxsd9_state *st = iio_priv(indio_dev); 103 bool foundit = false; 104 105 for (i = 0; i < 4; i++) 106 if (micro == kxsd9_micro_scales[i]) { 107 foundit = true; 108 break; 109 } 110 if (!foundit) 111 return -EINVAL; 112 113 ret = regmap_update_bits(st->map, 114 KXSD9_REG_CTRL_C, 115 KXSD9_CTRL_C_FS_MASK, 116 i); 117 if (ret < 0) 118 goto error_ret; 119 120 /* Cached scale when the sensor is powered down */ 121 st->scale = i; 122 123 error_ret: 124 return ret; 125 } 126 127 static IIO_CONST_ATTR(accel_scale_available, 128 KXSD9_SCALE_2G " " 129 KXSD9_SCALE_4G " " 130 KXSD9_SCALE_6G " " 131 KXSD9_SCALE_8G); 132 133 static struct attribute *kxsd9_attributes[] = { 134 &iio_const_attr_accel_scale_available.dev_attr.attr, 135 NULL, 136 }; 137 138 static int kxsd9_write_raw(struct iio_dev *indio_dev, 139 struct iio_chan_spec const *chan, 140 int val, 141 int val2, 142 long mask) 143 { 144 int ret = -EINVAL; 145 struct kxsd9_state *st = iio_priv(indio_dev); 146 147 pm_runtime_get_sync(st->dev); 148 149 if (mask == IIO_CHAN_INFO_SCALE) { 150 /* Check no integer component */ 151 if (val) 152 return -EINVAL; 153 ret = kxsd9_write_scale(indio_dev, val2); 154 } 155 156 pm_runtime_mark_last_busy(st->dev); 157 pm_runtime_put_autosuspend(st->dev); 158 159 return ret; 160 } 161 162 static int kxsd9_read_raw(struct iio_dev *indio_dev, 163 struct iio_chan_spec const *chan, 164 int *val, int *val2, long mask) 165 { 166 int ret = -EINVAL; 167 struct kxsd9_state *st = iio_priv(indio_dev); 168 unsigned int regval; 169 __be16 raw_val; 170 u16 nval; 171 172 pm_runtime_get_sync(st->dev); 173 174 switch (mask) { 175 case IIO_CHAN_INFO_RAW: 176 ret = regmap_bulk_read(st->map, chan->address, &raw_val, 177 sizeof(raw_val)); 178 if (ret) 179 goto error_ret; 180 nval = be16_to_cpu(raw_val); 181 /* Only 12 bits are valid */ 182 nval >>= 4; 183 *val = nval; 184 ret = IIO_VAL_INT; 185 break; 186 case IIO_CHAN_INFO_OFFSET: 187 /* This has a bias of -2048 */ 188 *val = KXSD9_ZERO_G_OFFSET; 189 ret = IIO_VAL_INT; 190 break; 191 case IIO_CHAN_INFO_SCALE: 192 ret = regmap_read(st->map, 193 KXSD9_REG_CTRL_C, 194 ®val); 195 if (ret < 0) 196 goto error_ret; 197 *val = 0; 198 *val2 = kxsd9_micro_scales[regval & KXSD9_CTRL_C_FS_MASK]; 199 ret = IIO_VAL_INT_PLUS_MICRO; 200 break; 201 } 202 203 error_ret: 204 pm_runtime_mark_last_busy(st->dev); 205 pm_runtime_put_autosuspend(st->dev); 206 207 return ret; 208 }; 209 210 static irqreturn_t kxsd9_trigger_handler(int irq, void *p) 211 { 212 const struct iio_poll_func *pf = p; 213 struct iio_dev *indio_dev = pf->indio_dev; 214 struct kxsd9_state *st = iio_priv(indio_dev); 215 int ret; 216 /* 4 * 16bit values AND timestamp */ 217 __be16 hw_values[8]; 218 219 ret = regmap_bulk_read(st->map, 220 KXSD9_REG_X, 221 &hw_values, 222 8); 223 if (ret) { 224 dev_err(st->dev, 225 "error reading data\n"); 226 return ret; 227 } 228 229 iio_push_to_buffers_with_timestamp(indio_dev, 230 hw_values, 231 iio_get_time_ns(indio_dev)); 232 iio_trigger_notify_done(indio_dev->trig); 233 234 return IRQ_HANDLED; 235 } 236 237 static int kxsd9_buffer_preenable(struct iio_dev *indio_dev) 238 { 239 struct kxsd9_state *st = iio_priv(indio_dev); 240 241 pm_runtime_get_sync(st->dev); 242 243 return 0; 244 } 245 246 static int kxsd9_buffer_postdisable(struct iio_dev *indio_dev) 247 { 248 struct kxsd9_state *st = iio_priv(indio_dev); 249 250 pm_runtime_mark_last_busy(st->dev); 251 pm_runtime_put_autosuspend(st->dev); 252 253 return 0; 254 } 255 256 static const struct iio_buffer_setup_ops kxsd9_buffer_setup_ops = { 257 .preenable = kxsd9_buffer_preenable, 258 .postenable = iio_triggered_buffer_postenable, 259 .predisable = iio_triggered_buffer_predisable, 260 .postdisable = kxsd9_buffer_postdisable, 261 }; 262 263 static const struct iio_mount_matrix * 264 kxsd9_get_mount_matrix(const struct iio_dev *indio_dev, 265 const struct iio_chan_spec *chan) 266 { 267 struct kxsd9_state *st = iio_priv(indio_dev); 268 269 return &st->orientation; 270 } 271 272 static const struct iio_chan_spec_ext_info kxsd9_ext_info[] = { 273 IIO_MOUNT_MATRIX(IIO_SHARED_BY_TYPE, kxsd9_get_mount_matrix), 274 { }, 275 }; 276 277 #define KXSD9_ACCEL_CHAN(axis, index) \ 278 { \ 279 .type = IIO_ACCEL, \ 280 .modified = 1, \ 281 .channel2 = IIO_MOD_##axis, \ 282 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 283 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \ 284 BIT(IIO_CHAN_INFO_OFFSET), \ 285 .ext_info = kxsd9_ext_info, \ 286 .address = KXSD9_REG_##axis, \ 287 .scan_index = index, \ 288 .scan_type = { \ 289 .sign = 'u', \ 290 .realbits = 12, \ 291 .storagebits = 16, \ 292 .shift = 4, \ 293 .endianness = IIO_BE, \ 294 }, \ 295 } 296 297 static const struct iio_chan_spec kxsd9_channels[] = { 298 KXSD9_ACCEL_CHAN(X, 0), 299 KXSD9_ACCEL_CHAN(Y, 1), 300 KXSD9_ACCEL_CHAN(Z, 2), 301 { 302 .type = IIO_VOLTAGE, 303 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 304 .indexed = 1, 305 .address = KXSD9_REG_AUX, 306 .scan_index = 3, 307 .scan_type = { 308 .sign = 'u', 309 .realbits = 12, 310 .storagebits = 16, 311 .shift = 4, 312 .endianness = IIO_BE, 313 }, 314 }, 315 IIO_CHAN_SOFT_TIMESTAMP(4), 316 }; 317 318 static const struct attribute_group kxsd9_attribute_group = { 319 .attrs = kxsd9_attributes, 320 }; 321 322 static int kxsd9_power_up(struct kxsd9_state *st) 323 { 324 int ret; 325 326 /* Enable the regulators */ 327 ret = regulator_bulk_enable(ARRAY_SIZE(st->regs), st->regs); 328 if (ret) { 329 dev_err(st->dev, "Cannot enable regulators\n"); 330 return ret; 331 } 332 333 /* Power up */ 334 ret = regmap_write(st->map, 335 KXSD9_REG_CTRL_B, 336 KXSD9_CTRL_B_ENABLE); 337 if (ret) 338 return ret; 339 340 /* 341 * Set 1000Hz LPF, 2g fullscale, motion wakeup threshold 1g, 342 * latched wakeup 343 */ 344 ret = regmap_write(st->map, 345 KXSD9_REG_CTRL_C, 346 KXSD9_CTRL_C_LP_1000HZ | 347 KXSD9_CTRL_C_MOT_LEV | 348 KXSD9_CTRL_C_MOT_LAT | 349 st->scale); 350 if (ret) 351 return ret; 352 353 /* 354 * Power-up time depends on the LPF setting, but typ 15.9 ms, let's 355 * set 20 ms to allow for some slack. 356 */ 357 msleep(20); 358 359 return 0; 360 }; 361 362 static int kxsd9_power_down(struct kxsd9_state *st) 363 { 364 int ret; 365 366 /* 367 * Set into low power mode - since there may be more users of the 368 * regulators this is the first step of the power saving: it will 369 * make sure we conserve power even if there are others users on the 370 * regulators. 371 */ 372 ret = regmap_update_bits(st->map, 373 KXSD9_REG_CTRL_B, 374 KXSD9_CTRL_B_ENABLE, 375 0); 376 if (ret) 377 return ret; 378 379 /* Disable the regulators */ 380 ret = regulator_bulk_disable(ARRAY_SIZE(st->regs), st->regs); 381 if (ret) { 382 dev_err(st->dev, "Cannot disable regulators\n"); 383 return ret; 384 } 385 386 return 0; 387 } 388 389 static const struct iio_info kxsd9_info = { 390 .read_raw = &kxsd9_read_raw, 391 .write_raw = &kxsd9_write_raw, 392 .attrs = &kxsd9_attribute_group, 393 }; 394 395 /* Four channels apart from timestamp, scan mask = 0x0f */ 396 static const unsigned long kxsd9_scan_masks[] = { 0xf, 0 }; 397 398 int kxsd9_common_probe(struct device *dev, 399 struct regmap *map, 400 const char *name) 401 { 402 struct iio_dev *indio_dev; 403 struct kxsd9_state *st; 404 int ret; 405 406 indio_dev = devm_iio_device_alloc(dev, sizeof(*st)); 407 if (!indio_dev) 408 return -ENOMEM; 409 410 st = iio_priv(indio_dev); 411 st->dev = dev; 412 st->map = map; 413 414 indio_dev->channels = kxsd9_channels; 415 indio_dev->num_channels = ARRAY_SIZE(kxsd9_channels); 416 indio_dev->name = name; 417 indio_dev->dev.parent = dev; 418 indio_dev->info = &kxsd9_info; 419 indio_dev->modes = INDIO_DIRECT_MODE; 420 indio_dev->available_scan_masks = kxsd9_scan_masks; 421 422 /* Read the mounting matrix, if present */ 423 ret = iio_read_mount_matrix(dev, "mount-matrix", &st->orientation); 424 if (ret) 425 return ret; 426 427 /* Fetch and turn on regulators */ 428 st->regs[0].supply = kxsd9_reg_vdd; 429 st->regs[1].supply = kxsd9_reg_iovdd; 430 ret = devm_regulator_bulk_get(dev, 431 ARRAY_SIZE(st->regs), 432 st->regs); 433 if (ret) { 434 dev_err(dev, "Cannot get regulators\n"); 435 return ret; 436 } 437 /* Default scaling */ 438 st->scale = KXSD9_CTRL_C_FS_2G; 439 440 kxsd9_power_up(st); 441 442 ret = iio_triggered_buffer_setup(indio_dev, 443 iio_pollfunc_store_time, 444 kxsd9_trigger_handler, 445 &kxsd9_buffer_setup_ops); 446 if (ret) { 447 dev_err(dev, "triggered buffer setup failed\n"); 448 goto err_power_down; 449 } 450 451 ret = iio_device_register(indio_dev); 452 if (ret) 453 goto err_cleanup_buffer; 454 455 dev_set_drvdata(dev, indio_dev); 456 457 /* Enable runtime PM */ 458 pm_runtime_get_noresume(dev); 459 pm_runtime_set_active(dev); 460 pm_runtime_enable(dev); 461 /* 462 * Set autosuspend to two orders of magnitude larger than the 463 * start-up time. 20ms start-up time means 2000ms autosuspend, 464 * i.e. 2 seconds. 465 */ 466 pm_runtime_set_autosuspend_delay(dev, 2000); 467 pm_runtime_use_autosuspend(dev); 468 pm_runtime_put(dev); 469 470 return 0; 471 472 err_cleanup_buffer: 473 iio_triggered_buffer_cleanup(indio_dev); 474 err_power_down: 475 kxsd9_power_down(st); 476 477 return ret; 478 } 479 EXPORT_SYMBOL(kxsd9_common_probe); 480 481 int kxsd9_common_remove(struct device *dev) 482 { 483 struct iio_dev *indio_dev = dev_get_drvdata(dev); 484 struct kxsd9_state *st = iio_priv(indio_dev); 485 486 iio_triggered_buffer_cleanup(indio_dev); 487 iio_device_unregister(indio_dev); 488 pm_runtime_get_sync(dev); 489 pm_runtime_put_noidle(dev); 490 pm_runtime_disable(dev); 491 kxsd9_power_down(st); 492 493 return 0; 494 } 495 EXPORT_SYMBOL(kxsd9_common_remove); 496 497 #ifdef CONFIG_PM 498 static int kxsd9_runtime_suspend(struct device *dev) 499 { 500 struct iio_dev *indio_dev = dev_get_drvdata(dev); 501 struct kxsd9_state *st = iio_priv(indio_dev); 502 503 return kxsd9_power_down(st); 504 } 505 506 static int kxsd9_runtime_resume(struct device *dev) 507 { 508 struct iio_dev *indio_dev = dev_get_drvdata(dev); 509 struct kxsd9_state *st = iio_priv(indio_dev); 510 511 return kxsd9_power_up(st); 512 } 513 #endif /* CONFIG_PM */ 514 515 const struct dev_pm_ops kxsd9_dev_pm_ops = { 516 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, 517 pm_runtime_force_resume) 518 SET_RUNTIME_PM_OPS(kxsd9_runtime_suspend, 519 kxsd9_runtime_resume, NULL) 520 }; 521 EXPORT_SYMBOL(kxsd9_dev_pm_ops); 522 523 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>"); 524 MODULE_DESCRIPTION("Kionix KXSD9 driver"); 525 MODULE_LICENSE("GPL v2"); 526