1 /** 2 * Sensortek STK8BA50 3-Axis Accelerometer 3 * 4 * Copyright (c) 2015, Intel Corporation. 5 * 6 * This file is subject to the terms and conditions of version 2 of 7 * the GNU General Public License. See the file COPYING in the main 8 * directory of this archive for more details. 9 * 10 * STK8BA50 7-bit I2C address: 0x18. 11 */ 12 13 #include <linux/acpi.h> 14 #include <linux/i2c.h> 15 #include <linux/interrupt.h> 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/iio/buffer.h> 19 #include <linux/iio/iio.h> 20 #include <linux/iio/sysfs.h> 21 #include <linux/iio/trigger.h> 22 #include <linux/iio/triggered_buffer.h> 23 #include <linux/iio/trigger_consumer.h> 24 25 #define STK8BA50_REG_XOUT 0x02 26 #define STK8BA50_REG_YOUT 0x04 27 #define STK8BA50_REG_ZOUT 0x06 28 #define STK8BA50_REG_RANGE 0x0F 29 #define STK8BA50_REG_BWSEL 0x10 30 #define STK8BA50_REG_POWMODE 0x11 31 #define STK8BA50_REG_SWRST 0x14 32 #define STK8BA50_REG_INTEN2 0x17 33 #define STK8BA50_REG_INTMAP2 0x1A 34 35 #define STK8BA50_MODE_NORMAL 0 36 #define STK8BA50_MODE_SUSPEND 1 37 #define STK8BA50_MODE_POWERBIT BIT(7) 38 #define STK8BA50_DATA_SHIFT 6 39 #define STK8BA50_RESET_CMD 0xB6 40 #define STK8BA50_SR_1792HZ_IDX 7 41 #define STK8BA50_DREADY_INT_MASK 0x10 42 #define STK8BA50_DREADY_INT_MAP 0x81 43 #define STK8BA50_ALL_CHANNEL_MASK 7 44 #define STK8BA50_ALL_CHANNEL_SIZE 6 45 46 #define STK8BA50_DRIVER_NAME "stk8ba50" 47 #define STK8BA50_IRQ_NAME "stk8ba50_event" 48 49 #define STK8BA50_SCALE_AVAIL "0.0384 0.0767 0.1534 0.3069" 50 51 /* 52 * The accelerometer has four measurement ranges: 53 * +/-2g; +/-4g; +/-8g; +/-16g 54 * 55 * Acceleration values are 10-bit, 2's complement. 56 * Scales are calculated as following: 57 * 58 * scale1 = (2 + 2) * 9.81 / (2^10 - 1) = 0.0384 59 * scale2 = (4 + 4) * 9.81 / (2^10 - 1) = 0.0767 60 * etc. 61 * 62 * Scales are stored in this format: 63 * { <register value>, <scale value> } 64 * 65 * Locally, the range is stored as a table index. 66 */ 67 static const struct { 68 u8 reg_val; 69 u32 scale_val; 70 } stk8ba50_scale_table[] = { 71 {3, 38400}, {5, 76700}, {8, 153400}, {12, 306900} 72 }; 73 74 /* Sample rates are stored as { <register value>, <Hz value> } */ 75 static const struct { 76 u8 reg_val; 77 u16 samp_freq; 78 } stk8ba50_samp_freq_table[] = { 79 {0x08, 14}, {0x09, 25}, {0x0A, 56}, {0x0B, 112}, 80 {0x0C, 224}, {0x0D, 448}, {0x0E, 896}, {0x0F, 1792} 81 }; 82 83 /* Used to map scan mask bits to their corresponding channel register. */ 84 static const int stk8ba50_channel_table[] = { 85 STK8BA50_REG_XOUT, 86 STK8BA50_REG_YOUT, 87 STK8BA50_REG_ZOUT 88 }; 89 90 struct stk8ba50_data { 91 struct i2c_client *client; 92 struct mutex lock; 93 int range; 94 u8 sample_rate_idx; 95 struct iio_trigger *dready_trig; 96 bool dready_trigger_on; 97 /* 98 * 3 x 16-bit channels (10-bit data, 6-bit padding) + 99 * 1 x 16 padding + 100 * 4 x 16 64-bit timestamp 101 */ 102 s16 buffer[8]; 103 }; 104 105 #define STK8BA50_ACCEL_CHANNEL(index, reg, axis) { \ 106 .type = IIO_ACCEL, \ 107 .address = reg, \ 108 .modified = 1, \ 109 .channel2 = IIO_MOD_##axis, \ 110 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 111 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 112 BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 113 .scan_index = index, \ 114 .scan_type = { \ 115 .sign = 's', \ 116 .realbits = 10, \ 117 .storagebits = 16, \ 118 .shift = STK8BA50_DATA_SHIFT, \ 119 .endianness = IIO_CPU, \ 120 }, \ 121 } 122 123 static const struct iio_chan_spec stk8ba50_channels[] = { 124 STK8BA50_ACCEL_CHANNEL(0, STK8BA50_REG_XOUT, X), 125 STK8BA50_ACCEL_CHANNEL(1, STK8BA50_REG_YOUT, Y), 126 STK8BA50_ACCEL_CHANNEL(2, STK8BA50_REG_ZOUT, Z), 127 IIO_CHAN_SOFT_TIMESTAMP(3), 128 }; 129 130 static IIO_CONST_ATTR(in_accel_scale_available, STK8BA50_SCALE_AVAIL); 131 132 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("14 25 56 112 224 448 896 1792"); 133 134 static struct attribute *stk8ba50_attributes[] = { 135 &iio_const_attr_in_accel_scale_available.dev_attr.attr, 136 &iio_const_attr_sampling_frequency_available.dev_attr.attr, 137 NULL, 138 }; 139 140 static const struct attribute_group stk8ba50_attribute_group = { 141 .attrs = stk8ba50_attributes 142 }; 143 144 static int stk8ba50_read_accel(struct stk8ba50_data *data, u8 reg) 145 { 146 int ret; 147 struct i2c_client *client = data->client; 148 149 ret = i2c_smbus_read_word_data(client, reg); 150 if (ret < 0) { 151 dev_err(&client->dev, "register read failed\n"); 152 return ret; 153 } 154 155 return ret; 156 } 157 158 static int stk8ba50_data_rdy_trigger_set_state(struct iio_trigger *trig, 159 bool state) 160 { 161 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 162 struct stk8ba50_data *data = iio_priv(indio_dev); 163 int ret; 164 165 if (state) 166 ret = i2c_smbus_write_byte_data(data->client, 167 STK8BA50_REG_INTEN2, STK8BA50_DREADY_INT_MASK); 168 else 169 ret = i2c_smbus_write_byte_data(data->client, 170 STK8BA50_REG_INTEN2, 0x00); 171 172 if (ret < 0) 173 dev_err(&data->client->dev, "failed to set trigger state\n"); 174 else 175 data->dready_trigger_on = state; 176 177 return ret; 178 } 179 180 static const struct iio_trigger_ops stk8ba50_trigger_ops = { 181 .set_trigger_state = stk8ba50_data_rdy_trigger_set_state, 182 }; 183 184 static int stk8ba50_set_power(struct stk8ba50_data *data, bool mode) 185 { 186 int ret; 187 u8 masked_reg; 188 struct i2c_client *client = data->client; 189 190 ret = i2c_smbus_read_byte_data(client, STK8BA50_REG_POWMODE); 191 if (ret < 0) 192 goto exit_err; 193 194 if (mode) 195 masked_reg = ret | STK8BA50_MODE_POWERBIT; 196 else 197 masked_reg = ret & (~STK8BA50_MODE_POWERBIT); 198 199 ret = i2c_smbus_write_byte_data(client, STK8BA50_REG_POWMODE, 200 masked_reg); 201 if (ret < 0) 202 goto exit_err; 203 204 return ret; 205 206 exit_err: 207 dev_err(&client->dev, "failed to change sensor mode\n"); 208 return ret; 209 } 210 211 static int stk8ba50_read_raw(struct iio_dev *indio_dev, 212 struct iio_chan_spec const *chan, 213 int *val, int *val2, long mask) 214 { 215 struct stk8ba50_data *data = iio_priv(indio_dev); 216 int ret; 217 218 switch (mask) { 219 case IIO_CHAN_INFO_RAW: 220 if (iio_buffer_enabled(indio_dev)) 221 return -EBUSY; 222 mutex_lock(&data->lock); 223 ret = stk8ba50_set_power(data, STK8BA50_MODE_NORMAL); 224 if (ret < 0) { 225 mutex_unlock(&data->lock); 226 return -EINVAL; 227 } 228 ret = stk8ba50_read_accel(data, chan->address); 229 if (ret < 0) { 230 stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND); 231 mutex_unlock(&data->lock); 232 return -EINVAL; 233 } 234 *val = sign_extend32(ret >> STK8BA50_DATA_SHIFT, 9); 235 stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND); 236 mutex_unlock(&data->lock); 237 return IIO_VAL_INT; 238 case IIO_CHAN_INFO_SCALE: 239 *val = 0; 240 *val2 = stk8ba50_scale_table[data->range].scale_val; 241 return IIO_VAL_INT_PLUS_MICRO; 242 case IIO_CHAN_INFO_SAMP_FREQ: 243 *val = stk8ba50_samp_freq_table 244 [data->sample_rate_idx].samp_freq; 245 *val2 = 0; 246 return IIO_VAL_INT; 247 } 248 249 return -EINVAL; 250 } 251 252 static int stk8ba50_write_raw(struct iio_dev *indio_dev, 253 struct iio_chan_spec const *chan, 254 int val, int val2, long mask) 255 { 256 int ret; 257 int i; 258 int index = -1; 259 struct stk8ba50_data *data = iio_priv(indio_dev); 260 261 switch (mask) { 262 case IIO_CHAN_INFO_SCALE: 263 if (val != 0) 264 return -EINVAL; 265 266 for (i = 0; i < ARRAY_SIZE(stk8ba50_scale_table); i++) 267 if (val2 == stk8ba50_scale_table[i].scale_val) { 268 index = i; 269 break; 270 } 271 if (index < 0) 272 return -EINVAL; 273 274 ret = i2c_smbus_write_byte_data(data->client, 275 STK8BA50_REG_RANGE, 276 stk8ba50_scale_table[index].reg_val); 277 if (ret < 0) 278 dev_err(&data->client->dev, 279 "failed to set measurement range\n"); 280 else 281 data->range = index; 282 283 return ret; 284 case IIO_CHAN_INFO_SAMP_FREQ: 285 for (i = 0; i < ARRAY_SIZE(stk8ba50_samp_freq_table); i++) 286 if (val == stk8ba50_samp_freq_table[i].samp_freq) { 287 index = i; 288 break; 289 } 290 if (index < 0) 291 return -EINVAL; 292 293 ret = i2c_smbus_write_byte_data(data->client, 294 STK8BA50_REG_BWSEL, 295 stk8ba50_samp_freq_table[index].reg_val); 296 if (ret < 0) 297 dev_err(&data->client->dev, 298 "failed to set sampling rate\n"); 299 else 300 data->sample_rate_idx = index; 301 302 return ret; 303 } 304 305 return -EINVAL; 306 } 307 308 static const struct iio_info stk8ba50_info = { 309 .read_raw = stk8ba50_read_raw, 310 .write_raw = stk8ba50_write_raw, 311 .attrs = &stk8ba50_attribute_group, 312 }; 313 314 static irqreturn_t stk8ba50_trigger_handler(int irq, void *p) 315 { 316 struct iio_poll_func *pf = p; 317 struct iio_dev *indio_dev = pf->indio_dev; 318 struct stk8ba50_data *data = iio_priv(indio_dev); 319 int bit, ret, i = 0; 320 321 mutex_lock(&data->lock); 322 /* 323 * Do a bulk read if all channels are requested, 324 * from 0x02 (XOUT1) to 0x07 (ZOUT2) 325 */ 326 if (*(indio_dev->active_scan_mask) == STK8BA50_ALL_CHANNEL_MASK) { 327 ret = i2c_smbus_read_i2c_block_data(data->client, 328 STK8BA50_REG_XOUT, 329 STK8BA50_ALL_CHANNEL_SIZE, 330 (u8 *)data->buffer); 331 if (ret < STK8BA50_ALL_CHANNEL_SIZE) { 332 dev_err(&data->client->dev, "register read failed\n"); 333 goto err; 334 } 335 } else { 336 for_each_set_bit(bit, indio_dev->active_scan_mask, 337 indio_dev->masklength) { 338 ret = stk8ba50_read_accel(data, 339 stk8ba50_channel_table[bit]); 340 if (ret < 0) 341 goto err; 342 343 data->buffer[i++] = ret; 344 } 345 } 346 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer, 347 pf->timestamp); 348 err: 349 mutex_unlock(&data->lock); 350 iio_trigger_notify_done(indio_dev->trig); 351 352 return IRQ_HANDLED; 353 } 354 355 static irqreturn_t stk8ba50_data_rdy_trig_poll(int irq, void *private) 356 { 357 struct iio_dev *indio_dev = private; 358 struct stk8ba50_data *data = iio_priv(indio_dev); 359 360 if (data->dready_trigger_on) 361 iio_trigger_poll(data->dready_trig); 362 363 return IRQ_HANDLED; 364 } 365 366 static int stk8ba50_buffer_preenable(struct iio_dev *indio_dev) 367 { 368 struct stk8ba50_data *data = iio_priv(indio_dev); 369 370 return stk8ba50_set_power(data, STK8BA50_MODE_NORMAL); 371 } 372 373 static int stk8ba50_buffer_postdisable(struct iio_dev *indio_dev) 374 { 375 struct stk8ba50_data *data = iio_priv(indio_dev); 376 377 return stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND); 378 } 379 380 static const struct iio_buffer_setup_ops stk8ba50_buffer_setup_ops = { 381 .preenable = stk8ba50_buffer_preenable, 382 .postenable = iio_triggered_buffer_postenable, 383 .predisable = iio_triggered_buffer_predisable, 384 .postdisable = stk8ba50_buffer_postdisable, 385 }; 386 387 static int stk8ba50_probe(struct i2c_client *client, 388 const struct i2c_device_id *id) 389 { 390 int ret; 391 struct iio_dev *indio_dev; 392 struct stk8ba50_data *data; 393 394 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 395 if (!indio_dev) { 396 dev_err(&client->dev, "iio allocation failed!\n"); 397 return -ENOMEM; 398 } 399 400 data = iio_priv(indio_dev); 401 data->client = client; 402 i2c_set_clientdata(client, indio_dev); 403 mutex_init(&data->lock); 404 405 indio_dev->dev.parent = &client->dev; 406 indio_dev->info = &stk8ba50_info; 407 indio_dev->name = STK8BA50_DRIVER_NAME; 408 indio_dev->modes = INDIO_DIRECT_MODE; 409 indio_dev->channels = stk8ba50_channels; 410 indio_dev->num_channels = ARRAY_SIZE(stk8ba50_channels); 411 412 /* Reset all registers on startup */ 413 ret = i2c_smbus_write_byte_data(client, 414 STK8BA50_REG_SWRST, STK8BA50_RESET_CMD); 415 if (ret < 0) { 416 dev_err(&client->dev, "failed to reset sensor\n"); 417 goto err_power_off; 418 } 419 420 /* The default range is +/-2g */ 421 data->range = 0; 422 423 /* The default sampling rate is 1792 Hz (maximum) */ 424 data->sample_rate_idx = STK8BA50_SR_1792HZ_IDX; 425 426 /* Set up interrupts */ 427 ret = i2c_smbus_write_byte_data(client, 428 STK8BA50_REG_INTEN2, STK8BA50_DREADY_INT_MASK); 429 if (ret < 0) { 430 dev_err(&client->dev, "failed to set up interrupts\n"); 431 goto err_power_off; 432 } 433 ret = i2c_smbus_write_byte_data(client, 434 STK8BA50_REG_INTMAP2, STK8BA50_DREADY_INT_MAP); 435 if (ret < 0) { 436 dev_err(&client->dev, "failed to set up interrupts\n"); 437 goto err_power_off; 438 } 439 440 if (client->irq > 0) { 441 ret = devm_request_threaded_irq(&client->dev, client->irq, 442 stk8ba50_data_rdy_trig_poll, 443 NULL, 444 IRQF_TRIGGER_RISING | 445 IRQF_ONESHOT, 446 STK8BA50_IRQ_NAME, 447 indio_dev); 448 if (ret < 0) { 449 dev_err(&client->dev, "request irq %d failed\n", 450 client->irq); 451 goto err_power_off; 452 } 453 454 data->dready_trig = devm_iio_trigger_alloc(&client->dev, 455 "%s-dev%d", 456 indio_dev->name, 457 indio_dev->id); 458 if (!data->dready_trig) { 459 ret = -ENOMEM; 460 goto err_power_off; 461 } 462 463 data->dready_trig->dev.parent = &client->dev; 464 data->dready_trig->ops = &stk8ba50_trigger_ops; 465 iio_trigger_set_drvdata(data->dready_trig, indio_dev); 466 ret = iio_trigger_register(data->dready_trig); 467 if (ret) { 468 dev_err(&client->dev, "iio trigger register failed\n"); 469 goto err_power_off; 470 } 471 } 472 473 ret = iio_triggered_buffer_setup(indio_dev, 474 iio_pollfunc_store_time, 475 stk8ba50_trigger_handler, 476 &stk8ba50_buffer_setup_ops); 477 if (ret < 0) { 478 dev_err(&client->dev, "iio triggered buffer setup failed\n"); 479 goto err_trigger_unregister; 480 } 481 482 ret = iio_device_register(indio_dev); 483 if (ret < 0) { 484 dev_err(&client->dev, "device_register failed\n"); 485 goto err_buffer_cleanup; 486 } 487 488 return ret; 489 490 err_buffer_cleanup: 491 iio_triggered_buffer_cleanup(indio_dev); 492 err_trigger_unregister: 493 if (data->dready_trig) 494 iio_trigger_unregister(data->dready_trig); 495 err_power_off: 496 stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND); 497 return ret; 498 } 499 500 static int stk8ba50_remove(struct i2c_client *client) 501 { 502 struct iio_dev *indio_dev = i2c_get_clientdata(client); 503 struct stk8ba50_data *data = iio_priv(indio_dev); 504 505 iio_device_unregister(indio_dev); 506 iio_triggered_buffer_cleanup(indio_dev); 507 508 if (data->dready_trig) 509 iio_trigger_unregister(data->dready_trig); 510 511 return stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND); 512 } 513 514 #ifdef CONFIG_PM_SLEEP 515 static int stk8ba50_suspend(struct device *dev) 516 { 517 struct stk8ba50_data *data; 518 519 data = iio_priv(i2c_get_clientdata(to_i2c_client(dev))); 520 521 return stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND); 522 } 523 524 static int stk8ba50_resume(struct device *dev) 525 { 526 struct stk8ba50_data *data; 527 528 data = iio_priv(i2c_get_clientdata(to_i2c_client(dev))); 529 530 return stk8ba50_set_power(data, STK8BA50_MODE_NORMAL); 531 } 532 533 static SIMPLE_DEV_PM_OPS(stk8ba50_pm_ops, stk8ba50_suspend, stk8ba50_resume); 534 535 #define STK8BA50_PM_OPS (&stk8ba50_pm_ops) 536 #else 537 #define STK8BA50_PM_OPS NULL 538 #endif 539 540 static const struct i2c_device_id stk8ba50_i2c_id[] = { 541 {"stk8ba50", 0}, 542 {} 543 }; 544 MODULE_DEVICE_TABLE(i2c, stk8ba50_i2c_id); 545 546 static const struct acpi_device_id stk8ba50_acpi_id[] = { 547 {"STK8BA50", 0}, 548 {} 549 }; 550 551 MODULE_DEVICE_TABLE(acpi, stk8ba50_acpi_id); 552 553 static struct i2c_driver stk8ba50_driver = { 554 .driver = { 555 .name = "stk8ba50", 556 .pm = STK8BA50_PM_OPS, 557 .acpi_match_table = ACPI_PTR(stk8ba50_acpi_id), 558 }, 559 .probe = stk8ba50_probe, 560 .remove = stk8ba50_remove, 561 .id_table = stk8ba50_i2c_id, 562 }; 563 564 module_i2c_driver(stk8ba50_driver); 565 566 MODULE_AUTHOR("Tiberiu Breana <tiberiu.a.breana@intel.com>"); 567 MODULE_DESCRIPTION("STK8BA50 3-Axis Accelerometer driver"); 568 MODULE_LICENSE("GPL v2"); 569