1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Sensortek STK8312 3-Axis Accelerometer 4 * 5 * Copyright (c) 2015, Intel Corporation. 6 * 7 * IIO driver for STK8312; 7-bit I2C address: 0x3D. 8 */ 9 10 #include <linux/array_size.h> 11 #include <linux/bits.h> 12 #include <linux/delay.h> 13 #include <linux/dev_printk.h> 14 #include <linux/errno.h> 15 #include <linux/i2c.h> 16 #include <linux/interrupt.h> 17 #include <linux/module.h> 18 #include <linux/mod_devicetable.h> 19 #include <linux/mutex.h> 20 #include <linux/pm.h> 21 #include <linux/sysfs.h> 22 #include <linux/types.h> 23 24 #include <linux/iio/buffer.h> 25 #include <linux/iio/iio.h> 26 #include <linux/iio/sysfs.h> 27 #include <linux/iio/trigger.h> 28 #include <linux/iio/triggered_buffer.h> 29 #include <linux/iio/trigger_consumer.h> 30 31 #define STK8312_REG_XOUT 0x00 32 #define STK8312_REG_YOUT 0x01 33 #define STK8312_REG_ZOUT 0x02 34 #define STK8312_REG_INTSU 0x06 35 #define STK8312_REG_MODE 0x07 36 #define STK8312_REG_SR 0x08 37 #define STK8312_REG_STH 0x13 38 #define STK8312_REG_RESET 0x20 39 #define STK8312_REG_AFECTRL 0x24 40 #define STK8312_REG_OTPADDR 0x3D 41 #define STK8312_REG_OTPDATA 0x3E 42 #define STK8312_REG_OTPCTRL 0x3F 43 44 #define STK8312_MODE_ACTIVE BIT(0) 45 #define STK8312_MODE_STANDBY 0x00 46 #define STK8312_MODE_INT_AH_PP 0xC0 /* active-high, push-pull */ 47 #define STK8312_DREADY_BIT BIT(4) 48 #define STK8312_RNG_6G 1 49 #define STK8312_RNG_SHIFT 6 50 #define STK8312_RNG_MASK GENMASK(7, 6) 51 #define STK8312_SR_MASK GENMASK(2, 0) 52 #define STK8312_SR_400HZ_IDX 0 53 #define STK8312_ALL_CHANNEL_MASK GENMASK(2, 0) 54 #define STK8312_ALL_CHANNEL_SIZE 3 55 56 #define STK8312_DRIVER_NAME "stk8312" 57 58 /* 59 * The accelerometer has two measurement ranges: 60 * 61 * -6g - +6g (8-bit, signed) 62 * -16g - +16g (8-bit, signed) 63 * 64 * scale1 = (6 + 6) * 9.81 / (2^8 - 1) = 0.4616 65 * scale2 = (16 + 16) * 9.81 / (2^8 - 1) = 1.2311 66 */ 67 #define STK8312_SCALE_AVAIL "0.4616 1.2311" 68 69 static const int stk8312_scale_table[][2] = { 70 {0, 461600}, {1, 231100} 71 }; 72 73 static const struct { 74 int val; 75 int val2; 76 } stk8312_samp_freq_table[] = { 77 {400, 0}, {200, 0}, {100, 0}, {50, 0}, {25, 0}, 78 {12, 500000}, {6, 250000}, {3, 125000} 79 }; 80 81 #define STK8312_ACCEL_CHANNEL(index, reg, axis) { \ 82 .type = IIO_ACCEL, \ 83 .address = reg, \ 84 .modified = 1, \ 85 .channel2 = IIO_MOD_##axis, \ 86 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 87 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \ 88 BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 89 .scan_index = index, \ 90 .scan_type = { \ 91 .sign = 's', \ 92 .realbits = 8, \ 93 .storagebits = 8, \ 94 .endianness = IIO_CPU, \ 95 }, \ 96 } 97 98 static const struct iio_chan_spec stk8312_channels[] = { 99 STK8312_ACCEL_CHANNEL(0, STK8312_REG_XOUT, X), 100 STK8312_ACCEL_CHANNEL(1, STK8312_REG_YOUT, Y), 101 STK8312_ACCEL_CHANNEL(2, STK8312_REG_ZOUT, Z), 102 IIO_CHAN_SOFT_TIMESTAMP(3), 103 }; 104 105 struct stk8312_data { 106 struct i2c_client *client; 107 struct mutex lock; 108 u8 range; 109 u8 sample_rate_idx; 110 u8 mode; 111 struct iio_trigger *dready_trig; 112 bool dready_trigger_on; 113 /* Ensure timestamp is naturally aligned */ 114 struct { 115 s8 chans[3]; 116 aligned_s64 timestamp; 117 } scan; 118 }; 119 120 static IIO_CONST_ATTR(in_accel_scale_available, STK8312_SCALE_AVAIL); 121 122 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("3.125 6.25 12.5 25 50 100 200 400"); 123 124 static struct attribute *stk8312_attributes[] = { 125 &iio_const_attr_in_accel_scale_available.dev_attr.attr, 126 &iio_const_attr_sampling_frequency_available.dev_attr.attr, 127 NULL, 128 }; 129 130 static const struct attribute_group stk8312_attribute_group = { 131 .attrs = stk8312_attributes 132 }; 133 134 static int stk8312_otp_init(struct stk8312_data *data) 135 { 136 int ret; 137 int count = 10; 138 struct i2c_client *client = data->client; 139 140 ret = i2c_smbus_write_byte_data(client, STK8312_REG_OTPADDR, 0x70); 141 if (ret < 0) 142 goto exit_err; 143 ret = i2c_smbus_write_byte_data(client, STK8312_REG_OTPCTRL, 0x02); 144 if (ret < 0) 145 goto exit_err; 146 147 do { 148 usleep_range(1000, 5000); 149 ret = i2c_smbus_read_byte_data(client, STK8312_REG_OTPCTRL); 150 if (ret < 0) 151 goto exit_err; 152 count--; 153 } while (!(ret & BIT(7)) && count > 0); 154 155 if (count == 0) { 156 ret = -ETIMEDOUT; 157 goto exit_err; 158 } 159 160 ret = i2c_smbus_read_byte_data(client, STK8312_REG_OTPDATA); 161 if (ret == 0) 162 ret = -EINVAL; 163 if (ret < 0) 164 goto exit_err; 165 166 ret = i2c_smbus_write_byte_data(data->client, STK8312_REG_AFECTRL, ret); 167 if (ret < 0) 168 goto exit_err; 169 msleep(150); 170 171 return 0; 172 173 exit_err: 174 dev_err(&client->dev, "failed to initialize sensor\n"); 175 return ret; 176 } 177 178 static int stk8312_set_mode(struct stk8312_data *data, u8 mode) 179 { 180 int ret; 181 struct i2c_client *client = data->client; 182 183 if (mode == data->mode) 184 return 0; 185 186 ret = i2c_smbus_write_byte_data(client, STK8312_REG_MODE, mode); 187 if (ret < 0) { 188 dev_err(&client->dev, "failed to change sensor mode\n"); 189 return ret; 190 } 191 192 data->mode = mode; 193 if (mode & STK8312_MODE_ACTIVE) { 194 /* Need to run OTP sequence before entering active mode */ 195 usleep_range(1000, 5000); 196 ret = stk8312_otp_init(data); 197 } 198 199 return ret; 200 } 201 202 static int stk8312_set_interrupts(struct stk8312_data *data, u8 int_mask) 203 { 204 int ret; 205 u8 mode; 206 struct i2c_client *client = data->client; 207 208 mode = data->mode; 209 /* We need to go in standby mode to modify registers */ 210 ret = stk8312_set_mode(data, STK8312_MODE_STANDBY); 211 if (ret < 0) 212 return ret; 213 214 ret = i2c_smbus_write_byte_data(client, STK8312_REG_INTSU, int_mask); 215 if (ret < 0) { 216 dev_err(&client->dev, "failed to set interrupts\n"); 217 stk8312_set_mode(data, mode); 218 return ret; 219 } 220 221 return stk8312_set_mode(data, mode); 222 } 223 224 static int stk8312_data_rdy_trigger_set_state(struct iio_trigger *trig, 225 bool state) 226 { 227 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 228 struct stk8312_data *data = iio_priv(indio_dev); 229 int ret; 230 231 if (state) 232 ret = stk8312_set_interrupts(data, STK8312_DREADY_BIT); 233 else 234 ret = stk8312_set_interrupts(data, 0x00); 235 236 if (ret < 0) { 237 dev_err(&data->client->dev, "failed to set trigger state\n"); 238 return ret; 239 } 240 241 data->dready_trigger_on = state; 242 243 return 0; 244 } 245 246 static const struct iio_trigger_ops stk8312_trigger_ops = { 247 .set_trigger_state = stk8312_data_rdy_trigger_set_state, 248 }; 249 250 static int stk8312_set_sample_rate(struct stk8312_data *data, u8 rate) 251 { 252 int ret; 253 u8 masked_reg; 254 u8 mode; 255 struct i2c_client *client = data->client; 256 257 if (rate == data->sample_rate_idx) 258 return 0; 259 260 mode = data->mode; 261 /* We need to go in standby mode to modify registers */ 262 ret = stk8312_set_mode(data, STK8312_MODE_STANDBY); 263 if (ret < 0) 264 return ret; 265 266 ret = i2c_smbus_read_byte_data(client, STK8312_REG_SR); 267 if (ret < 0) 268 goto err_activate; 269 270 masked_reg = (ret & (~STK8312_SR_MASK)) | rate; 271 272 ret = i2c_smbus_write_byte_data(client, STK8312_REG_SR, masked_reg); 273 if (ret < 0) 274 goto err_activate; 275 276 data->sample_rate_idx = rate; 277 278 return stk8312_set_mode(data, mode); 279 280 err_activate: 281 dev_err(&client->dev, "failed to set sampling rate\n"); 282 stk8312_set_mode(data, mode); 283 284 return ret; 285 } 286 287 static int stk8312_set_range(struct stk8312_data *data, u8 range) 288 { 289 int ret; 290 u8 masked_reg; 291 u8 mode; 292 struct i2c_client *client = data->client; 293 294 if (range != 1 && range != 2) 295 return -EINVAL; 296 else if (range == data->range) 297 return 0; 298 299 mode = data->mode; 300 /* We need to go in standby mode to modify registers */ 301 ret = stk8312_set_mode(data, STK8312_MODE_STANDBY); 302 if (ret < 0) 303 return ret; 304 305 ret = i2c_smbus_read_byte_data(client, STK8312_REG_STH); 306 if (ret < 0) 307 goto err_activate; 308 309 masked_reg = ret & (~STK8312_RNG_MASK); 310 masked_reg |= range << STK8312_RNG_SHIFT; 311 312 ret = i2c_smbus_write_byte_data(client, STK8312_REG_STH, masked_reg); 313 if (ret < 0) 314 goto err_activate; 315 316 data->range = range; 317 318 return stk8312_set_mode(data, mode); 319 320 err_activate: 321 dev_err(&client->dev, "failed to change sensor range\n"); 322 stk8312_set_mode(data, mode); 323 324 return ret; 325 } 326 327 static int stk8312_read_accel(struct stk8312_data *data, u8 address) 328 { 329 int ret; 330 struct i2c_client *client = data->client; 331 332 if (address > 2) 333 return -EINVAL; 334 335 ret = i2c_smbus_read_byte_data(client, address); 336 if (ret < 0) 337 dev_err(&client->dev, "register read failed\n"); 338 339 return ret; 340 } 341 342 static int stk8312_read_raw(struct iio_dev *indio_dev, 343 struct iio_chan_spec const *chan, 344 int *val, int *val2, long mask) 345 { 346 struct stk8312_data *data = iio_priv(indio_dev); 347 int ret; 348 349 switch (mask) { 350 case IIO_CHAN_INFO_RAW: 351 if (iio_buffer_enabled(indio_dev)) 352 return -EBUSY; 353 mutex_lock(&data->lock); 354 ret = stk8312_set_mode(data, data->mode | STK8312_MODE_ACTIVE); 355 if (ret < 0) { 356 mutex_unlock(&data->lock); 357 return ret; 358 } 359 ret = stk8312_read_accel(data, chan->address); 360 if (ret < 0) { 361 stk8312_set_mode(data, 362 data->mode & (~STK8312_MODE_ACTIVE)); 363 mutex_unlock(&data->lock); 364 return ret; 365 } 366 *val = sign_extend32(ret, chan->scan_type.realbits - 1); 367 ret = stk8312_set_mode(data, 368 data->mode & (~STK8312_MODE_ACTIVE)); 369 mutex_unlock(&data->lock); 370 if (ret < 0) 371 return ret; 372 return IIO_VAL_INT; 373 case IIO_CHAN_INFO_SCALE: 374 *val = stk8312_scale_table[data->range - 1][0]; 375 *val2 = stk8312_scale_table[data->range - 1][1]; 376 return IIO_VAL_INT_PLUS_MICRO; 377 case IIO_CHAN_INFO_SAMP_FREQ: 378 *val = stk8312_samp_freq_table[data->sample_rate_idx].val; 379 *val2 = stk8312_samp_freq_table[data->sample_rate_idx].val2; 380 return IIO_VAL_INT_PLUS_MICRO; 381 } 382 383 return -EINVAL; 384 } 385 386 static int stk8312_write_raw(struct iio_dev *indio_dev, 387 struct iio_chan_spec const *chan, 388 int val, int val2, long mask) 389 { 390 int i; 391 int index = -1; 392 int ret; 393 struct stk8312_data *data = iio_priv(indio_dev); 394 395 switch (mask) { 396 case IIO_CHAN_INFO_SCALE: 397 for (i = 0; i < ARRAY_SIZE(stk8312_scale_table); i++) 398 if (val == stk8312_scale_table[i][0] && 399 val2 == stk8312_scale_table[i][1]) { 400 index = i + 1; 401 break; 402 } 403 if (index < 0) 404 return -EINVAL; 405 406 mutex_lock(&data->lock); 407 ret = stk8312_set_range(data, index); 408 mutex_unlock(&data->lock); 409 410 return ret; 411 case IIO_CHAN_INFO_SAMP_FREQ: 412 for (i = 0; i < ARRAY_SIZE(stk8312_samp_freq_table); i++) 413 if (val == stk8312_samp_freq_table[i].val && 414 val2 == stk8312_samp_freq_table[i].val2) { 415 index = i; 416 break; 417 } 418 if (index < 0) 419 return -EINVAL; 420 mutex_lock(&data->lock); 421 ret = stk8312_set_sample_rate(data, index); 422 mutex_unlock(&data->lock); 423 424 return ret; 425 } 426 427 return -EINVAL; 428 } 429 430 static const struct iio_info stk8312_info = { 431 .read_raw = stk8312_read_raw, 432 .write_raw = stk8312_write_raw, 433 .attrs = &stk8312_attribute_group, 434 }; 435 436 static irqreturn_t stk8312_trigger_handler(int irq, void *p) 437 { 438 struct iio_poll_func *pf = p; 439 struct iio_dev *indio_dev = pf->indio_dev; 440 struct stk8312_data *data = iio_priv(indio_dev); 441 int bit, ret, i = 0; 442 443 mutex_lock(&data->lock); 444 /* 445 * Do a bulk read if all channels are requested, 446 * from 0x00 (XOUT) to 0x02 (ZOUT) 447 */ 448 if (*(indio_dev->active_scan_mask) == STK8312_ALL_CHANNEL_MASK) { 449 ret = i2c_smbus_read_i2c_block_data(data->client, 450 STK8312_REG_XOUT, 451 STK8312_ALL_CHANNEL_SIZE, 452 data->scan.chans); 453 if (ret < STK8312_ALL_CHANNEL_SIZE) { 454 dev_err(&data->client->dev, "register read failed\n"); 455 mutex_unlock(&data->lock); 456 goto err; 457 } 458 } else { 459 iio_for_each_active_channel(indio_dev, bit) { 460 ret = stk8312_read_accel(data, bit); 461 if (ret < 0) { 462 mutex_unlock(&data->lock); 463 goto err; 464 } 465 data->scan.chans[i++] = ret; 466 } 467 } 468 mutex_unlock(&data->lock); 469 470 iio_push_to_buffers_with_ts(indio_dev, &data->scan, sizeof(data->scan), 471 pf->timestamp); 472 err: 473 iio_trigger_notify_done(indio_dev->trig); 474 475 return IRQ_HANDLED; 476 } 477 478 static irqreturn_t stk8312_data_rdy_trig_poll(int irq, void *private) 479 { 480 struct iio_dev *indio_dev = private; 481 struct stk8312_data *data = iio_priv(indio_dev); 482 483 if (data->dready_trigger_on) 484 iio_trigger_poll(data->dready_trig); 485 486 return IRQ_HANDLED; 487 } 488 489 static int stk8312_buffer_preenable(struct iio_dev *indio_dev) 490 { 491 struct stk8312_data *data = iio_priv(indio_dev); 492 493 return stk8312_set_mode(data, data->mode | STK8312_MODE_ACTIVE); 494 } 495 496 static int stk8312_buffer_postdisable(struct iio_dev *indio_dev) 497 { 498 struct stk8312_data *data = iio_priv(indio_dev); 499 500 return stk8312_set_mode(data, data->mode & (~STK8312_MODE_ACTIVE)); 501 } 502 503 static const struct iio_buffer_setup_ops stk8312_buffer_setup_ops = { 504 .preenable = stk8312_buffer_preenable, 505 .postdisable = stk8312_buffer_postdisable, 506 }; 507 508 static int stk8312_probe(struct i2c_client *client) 509 { 510 int ret; 511 struct iio_dev *indio_dev; 512 struct stk8312_data *data; 513 514 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 515 if (!indio_dev) 516 return -ENOMEM; 517 518 data = iio_priv(indio_dev); 519 data->client = client; 520 i2c_set_clientdata(client, indio_dev); 521 mutex_init(&data->lock); 522 523 indio_dev->info = &stk8312_info; 524 indio_dev->name = STK8312_DRIVER_NAME; 525 indio_dev->modes = INDIO_DIRECT_MODE; 526 indio_dev->channels = stk8312_channels; 527 indio_dev->num_channels = ARRAY_SIZE(stk8312_channels); 528 529 /* A software reset is recommended at power-on */ 530 ret = i2c_smbus_write_byte_data(data->client, STK8312_REG_RESET, 0x00); 531 if (ret < 0) { 532 dev_err(&client->dev, "failed to reset sensor\n"); 533 return ret; 534 } 535 data->sample_rate_idx = STK8312_SR_400HZ_IDX; 536 ret = stk8312_set_range(data, STK8312_RNG_6G); 537 if (ret < 0) 538 return ret; 539 540 ret = stk8312_set_mode(data, 541 STK8312_MODE_INT_AH_PP | STK8312_MODE_ACTIVE); 542 if (ret < 0) 543 return ret; 544 545 if (client->irq > 0) { 546 ret = devm_request_threaded_irq(&client->dev, client->irq, 547 stk8312_data_rdy_trig_poll, 548 NULL, 549 IRQF_TRIGGER_RISING | 550 IRQF_ONESHOT, 551 "stk8312_event", 552 indio_dev); 553 if (ret) 554 goto err_power_off; 555 556 data->dready_trig = devm_iio_trigger_alloc(&client->dev, 557 "%s-dev%d", 558 indio_dev->name, 559 iio_device_id(indio_dev)); 560 if (!data->dready_trig) { 561 ret = -ENOMEM; 562 goto err_power_off; 563 } 564 565 data->dready_trig->ops = &stk8312_trigger_ops; 566 iio_trigger_set_drvdata(data->dready_trig, indio_dev); 567 ret = iio_trigger_register(data->dready_trig); 568 if (ret) { 569 dev_err(&client->dev, "iio trigger register failed\n"); 570 goto err_power_off; 571 } 572 } 573 574 ret = iio_triggered_buffer_setup(indio_dev, 575 iio_pollfunc_store_time, 576 stk8312_trigger_handler, 577 &stk8312_buffer_setup_ops); 578 if (ret < 0) { 579 dev_err(&client->dev, "iio triggered buffer setup failed\n"); 580 goto err_trigger_unregister; 581 } 582 583 ret = iio_device_register(indio_dev); 584 if (ret < 0) { 585 dev_err(&client->dev, "device_register failed\n"); 586 goto err_buffer_cleanup; 587 } 588 589 return 0; 590 591 err_buffer_cleanup: 592 iio_triggered_buffer_cleanup(indio_dev); 593 err_trigger_unregister: 594 if (data->dready_trig) 595 iio_trigger_unregister(data->dready_trig); 596 err_power_off: 597 stk8312_set_mode(data, STK8312_MODE_STANDBY); 598 return ret; 599 } 600 601 static void stk8312_remove(struct i2c_client *client) 602 { 603 struct iio_dev *indio_dev = i2c_get_clientdata(client); 604 struct stk8312_data *data = iio_priv(indio_dev); 605 606 iio_device_unregister(indio_dev); 607 iio_triggered_buffer_cleanup(indio_dev); 608 609 if (data->dready_trig) 610 iio_trigger_unregister(data->dready_trig); 611 612 stk8312_set_mode(data, STK8312_MODE_STANDBY); 613 } 614 615 static int stk8312_suspend(struct device *dev) 616 { 617 struct stk8312_data *data; 618 619 data = iio_priv(i2c_get_clientdata(to_i2c_client(dev))); 620 621 return stk8312_set_mode(data, data->mode & (~STK8312_MODE_ACTIVE)); 622 } 623 624 static int stk8312_resume(struct device *dev) 625 { 626 struct stk8312_data *data; 627 628 data = iio_priv(i2c_get_clientdata(to_i2c_client(dev))); 629 630 return stk8312_set_mode(data, data->mode | STK8312_MODE_ACTIVE); 631 } 632 633 static DEFINE_SIMPLE_DEV_PM_OPS(stk8312_pm_ops, stk8312_suspend, 634 stk8312_resume); 635 636 static const struct i2c_device_id stk8312_i2c_id[] = { 637 /* Deprecated in favour of lowercase form */ 638 { .name = "STK8312" }, 639 { .name = "stk8312" }, 640 { } 641 }; 642 MODULE_DEVICE_TABLE(i2c, stk8312_i2c_id); 643 644 static struct i2c_driver stk8312_driver = { 645 .driver = { 646 .name = STK8312_DRIVER_NAME, 647 .pm = pm_sleep_ptr(&stk8312_pm_ops), 648 }, 649 .probe = stk8312_probe, 650 .remove = stk8312_remove, 651 .id_table = stk8312_i2c_id, 652 }; 653 654 module_i2c_driver(stk8312_driver); 655 656 MODULE_AUTHOR("Tiberiu Breana <tiberiu.a.breana@intel.com>"); 657 MODULE_DESCRIPTION("STK8312 3-Axis Accelerometer driver"); 658 MODULE_LICENSE("GPL v2"); 659