FILE
st_accel_core.c
File preview with syntax highlighting.
linux-6.19.14/drivers/iio/accel/st_accel_core.c
1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * STMicroelectronics accelerometers driver 4 * 5 * Copyright 2012-2013 STMicroelectronics Inc. 6 * 7 * Denis Ciocca <denis.ciocca@st.com> 8 */ 9 10#include <linux/kernel.h> 11#include <linux/module.h> 12#include <linux/mutex.h> 13#include <linux/sysfs.h> 14#include <linux/slab.h> 15#include <linux/acpi.h> 16#include <linux/iio/iio.h> 17#include <linux/iio/sysfs.h> 18#include <linux/iio/trigger.h> 19 20#include <linux/iio/common/st_sensors.h> 21#include "st_accel.h" 22 23#define ST_ACCEL_NUMBER_DATA_CHANNELS 3 24 25/* DEFAULT VALUE FOR SENSORS */ 26#define ST_ACCEL_DEFAULT_OUT_X_L_ADDR 0x28 27#define ST_ACCEL_DEFAULT_OUT_Y_L_ADDR 0x2a 28#define ST_ACCEL_DEFAULT_OUT_Z_L_ADDR 0x2c 29 30/* FULLSCALE */ 31#define ST_ACCEL_FS_AVL_2G 2 32#define ST_ACCEL_FS_AVL_4G 4 33#define ST_ACCEL_FS_AVL_6G 6 34#define ST_ACCEL_FS_AVL_8G 8 35#define ST_ACCEL_FS_AVL_16G 16 36#define ST_ACCEL_FS_AVL_100G 100 37#define ST_ACCEL_FS_AVL_200G 200 38#define ST_ACCEL_FS_AVL_400G 400 39 40static const struct iio_mount_matrix * 41st_accel_get_mount_matrix(const struct iio_dev *indio_dev, 42 const struct iio_chan_spec *chan) 43{ 44 struct st_sensor_data *adata = iio_priv(indio_dev); 45 46 return &adata->mount_matrix; 47} 48 49static const struct iio_chan_spec_ext_info st_accel_mount_matrix_ext_info[] = { 50 IIO_MOUNT_MATRIX(IIO_SHARED_BY_ALL, st_accel_get_mount_matrix), 51 { } 52}; 53 54static const struct iio_chan_spec st_accel_8bit_channels[] = { 55 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL, 56 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 57 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 8, 8, 58 ST_ACCEL_DEFAULT_OUT_X_L_ADDR+1, 59 st_accel_mount_matrix_ext_info), 60 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL, 61 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 62 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 8, 8, 63 ST_ACCEL_DEFAULT_OUT_Y_L_ADDR+1, 64 st_accel_mount_matrix_ext_info), 65 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL, 66 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 67 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 8, 8, 68 ST_ACCEL_DEFAULT_OUT_Z_L_ADDR+1, 69 st_accel_mount_matrix_ext_info), 70 IIO_CHAN_SOFT_TIMESTAMP(3) 71}; 72 73static const struct iio_chan_spec st_accel_12bit_channels[] = { 74 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL, 75 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 76 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 12, 16, 77 ST_ACCEL_DEFAULT_OUT_X_L_ADDR, 78 st_accel_mount_matrix_ext_info), 79 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL, 80 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 81 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 12, 16, 82 ST_ACCEL_DEFAULT_OUT_Y_L_ADDR, 83 st_accel_mount_matrix_ext_info), 84 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL, 85 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 86 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 12, 16, 87 ST_ACCEL_DEFAULT_OUT_Z_L_ADDR, 88 st_accel_mount_matrix_ext_info), 89 IIO_CHAN_SOFT_TIMESTAMP(3) 90}; 91 92static const struct iio_chan_spec st_accel_16bit_channels[] = { 93 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL, 94 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 95 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16, 96 ST_ACCEL_DEFAULT_OUT_X_L_ADDR, 97 st_accel_mount_matrix_ext_info), 98 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL, 99 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 100 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16, 101 ST_ACCEL_DEFAULT_OUT_Y_L_ADDR, 102 st_accel_mount_matrix_ext_info), 103 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL, 104 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 105 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16, 106 ST_ACCEL_DEFAULT_OUT_Z_L_ADDR, 107 st_accel_mount_matrix_ext_info), 108 IIO_CHAN_SOFT_TIMESTAMP(3) 109}; 110 111static const struct st_sensor_settings st_accel_sensors_settings[] = { 112 { 113 .wai = 0x33, 114 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 115 .sensors_supported = { 116 [0] = LIS3DH_ACCEL_DEV_NAME, 117 [1] = LSM303DLHC_ACCEL_DEV_NAME, 118 [2] = LSM330D_ACCEL_DEV_NAME, 119 [3] = LSM330DL_ACCEL_DEV_NAME, 120 [4] = LSM330DLC_ACCEL_DEV_NAME, 121 [5] = LSM303AGR_ACCEL_DEV_NAME, 122 [6] = LIS2DH12_ACCEL_DEV_NAME, 123 [7] = LIS3DE_ACCEL_DEV_NAME, 124 }, 125 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 126 .odr = { 127 .addr = 0x20, 128 .mask = 0xf0, 129 .odr_avl = { 130 { .hz = 1, .value = 0x01, }, 131 { .hz = 10, .value = 0x02, }, 132 { .hz = 25, .value = 0x03, }, 133 { .hz = 50, .value = 0x04, }, 134 { .hz = 100, .value = 0x05, }, 135 { .hz = 200, .value = 0x06, }, 136 { .hz = 400, .value = 0x07, }, 137 { .hz = 1600, .value = 0x08, }, 138 }, 139 }, 140 .pw = { 141 .addr = 0x20, 142 .mask = 0xf0, 143 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 144 }, 145 .enable_axis = { 146 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 147 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 148 }, 149 .fs = { 150 .addr = 0x23, 151 .mask = 0x30, 152 .fs_avl = { 153 [0] = { 154 .num = ST_ACCEL_FS_AVL_2G, 155 .value = 0x00, 156 .gain = IIO_G_TO_M_S_2(1000), 157 }, 158 [1] = { 159 .num = ST_ACCEL_FS_AVL_4G, 160 .value = 0x01, 161 .gain = IIO_G_TO_M_S_2(2000), 162 }, 163 [2] = { 164 .num = ST_ACCEL_FS_AVL_8G, 165 .value = 0x02, 166 .gain = IIO_G_TO_M_S_2(4000), 167 }, 168 [3] = { 169 .num = ST_ACCEL_FS_AVL_16G, 170 .value = 0x03, 171 .gain = IIO_G_TO_M_S_2(12000), 172 }, 173 }, 174 }, 175 .bdu = { 176 .addr = 0x23, 177 .mask = 0x80, 178 }, 179 .drdy_irq = { 180 .int1 = { 181 .addr = 0x22, 182 .mask = 0x10, 183 }, 184 .addr_ihl = 0x25, 185 .mask_ihl = 0x02, 186 .stat_drdy = { 187 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 188 .mask = 0x07, 189 }, 190 }, 191 .sim = { 192 .addr = 0x23, 193 .value = BIT(0), 194 }, 195 .multi_read_bit = true, 196 .bootime = 2, 197 }, 198 { 199 .wai = 0x32, 200 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 201 .sensors_supported = { 202 [0] = LIS331DLH_ACCEL_DEV_NAME, 203 [1] = LSM303DL_ACCEL_DEV_NAME, 204 [2] = LSM303DLH_ACCEL_DEV_NAME, 205 [3] = LSM303DLM_ACCEL_DEV_NAME, 206 }, 207 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 208 .odr = { 209 .addr = 0x20, 210 .mask = 0x18, 211 .odr_avl = { 212 { .hz = 50, .value = 0x00, }, 213 { .hz = 100, .value = 0x01, }, 214 { .hz = 400, .value = 0x02, }, 215 { .hz = 1000, .value = 0x03, }, 216 }, 217 }, 218 .pw = { 219 .addr = 0x20, 220 .mask = 0xe0, 221 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 222 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 223 }, 224 .enable_axis = { 225 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 226 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 227 }, 228 .fs = { 229 .addr = 0x23, 230 .mask = 0x30, 231 .fs_avl = { 232 [0] = { 233 .num = ST_ACCEL_FS_AVL_2G, 234 .value = 0x00, 235 .gain = IIO_G_TO_M_S_2(1000), 236 }, 237 [1] = { 238 .num = ST_ACCEL_FS_AVL_4G, 239 .value = 0x01, 240 .gain = IIO_G_TO_M_S_2(2000), 241 }, 242 [2] = { 243 .num = ST_ACCEL_FS_AVL_8G, 244 .value = 0x03, 245 .gain = IIO_G_TO_M_S_2(3900), 246 }, 247 }, 248 }, 249 .bdu = { 250 .addr = 0x23, 251 .mask = 0x80, 252 }, 253 .drdy_irq = { 254 .int1 = { 255 .addr = 0x22, 256 .mask = 0x02, 257 .addr_od = 0x22, 258 .mask_od = 0x40, 259 }, 260 .int2 = { 261 .addr = 0x22, 262 .mask = 0x10, 263 .addr_od = 0x22, 264 .mask_od = 0x40, 265 }, 266 .addr_ihl = 0x22, 267 .mask_ihl = 0x80, 268 .stat_drdy = { 269 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 270 .mask = 0x07, 271 }, 272 }, 273 .sim = { 274 .addr = 0x23, 275 .value = BIT(0), 276 }, 277 .multi_read_bit = true, 278 .bootime = 2, 279 }, 280 { 281 .wai = 0x40, 282 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 283 .sensors_supported = { 284 [0] = LSM330_ACCEL_DEV_NAME, 285 }, 286 .ch = (struct iio_chan_spec *)st_accel_16bit_channels, 287 .odr = { 288 .addr = 0x20, 289 .mask = 0xf0, 290 .odr_avl = { 291 { .hz = 3, .value = 0x01, }, 292 { .hz = 6, .value = 0x02, }, 293 { .hz = 12, .value = 0x03, }, 294 { .hz = 25, .value = 0x04, }, 295 { .hz = 50, .value = 0x05, }, 296 { .hz = 100, .value = 0x06, }, 297 { .hz = 200, .value = 0x07, }, 298 { .hz = 400, .value = 0x08, }, 299 { .hz = 800, .value = 0x09, }, 300 { .hz = 1600, .value = 0x0a, }, 301 }, 302 }, 303 .pw = { 304 .addr = 0x20, 305 .mask = 0xf0, 306 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 307 }, 308 .enable_axis = { 309 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 310 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 311 }, 312 .fs = { 313 .addr = 0x24, 314 .mask = 0x38, 315 .fs_avl = { 316 [0] = { 317 .num = ST_ACCEL_FS_AVL_2G, 318 .value = 0x00, 319 .gain = IIO_G_TO_M_S_2(61), 320 }, 321 [1] = { 322 .num = ST_ACCEL_FS_AVL_4G, 323 .value = 0x01, 324 .gain = IIO_G_TO_M_S_2(122), 325 }, 326 [2] = { 327 .num = ST_ACCEL_FS_AVL_6G, 328 .value = 0x02, 329 .gain = IIO_G_TO_M_S_2(183), 330 }, 331 [3] = { 332 .num = ST_ACCEL_FS_AVL_8G, 333 .value = 0x03, 334 .gain = IIO_G_TO_M_S_2(244), 335 }, 336 [4] = { 337 .num = ST_ACCEL_FS_AVL_16G, 338 .value = 0x04, 339 .gain = IIO_G_TO_M_S_2(732), 340 }, 341 }, 342 }, 343 .bdu = { 344 .addr = 0x20, 345 .mask = 0x08, 346 }, 347 .drdy_irq = { 348 .int1 = { 349 .addr = 0x23, 350 .mask = 0x80, 351 }, 352 .addr_ihl = 0x23, 353 .mask_ihl = 0x40, 354 .stat_drdy = { 355 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 356 .mask = 0x07, 357 }, 358 .ig1 = { 359 .en_addr = 0x23, 360 .en_mask = 0x08, 361 }, 362 }, 363 .sim = { 364 .addr = 0x24, 365 .value = BIT(0), 366 }, 367 .multi_read_bit = false, 368 .bootime = 2, 369 }, 370 { 371 .wai = 0x3a, 372 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 373 .sensors_supported = { 374 [0] = LIS3LV02DL_ACCEL_DEV_NAME, 375 }, 376 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 377 .odr = { 378 .addr = 0x20, 379 .mask = 0x30, /* DF1 and DF0 */ 380 .odr_avl = { 381 { .hz = 40, .value = 0x00, }, 382 { .hz = 160, .value = 0x01, }, 383 { .hz = 640, .value = 0x02, }, 384 { .hz = 2560, .value = 0x03, }, 385 }, 386 }, 387 .pw = { 388 .addr = 0x20, 389 .mask = 0xc0, 390 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 391 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 392 }, 393 .enable_axis = { 394 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 395 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 396 }, 397 .fs = { 398 .addr = 0x21, 399 .mask = 0x80, 400 .fs_avl = { 401 [0] = { 402 .num = ST_ACCEL_FS_AVL_2G, 403 .value = 0x00, 404 .gain = IIO_G_TO_M_S_2(1000), 405 }, 406 [1] = { 407 .num = ST_ACCEL_FS_AVL_6G, 408 .value = 0x01, 409 .gain = IIO_G_TO_M_S_2(3000), 410 }, 411 }, 412 }, 413 .bdu = { 414 .addr = 0x21, 415 .mask = 0x40, 416 }, 417 /* 418 * Data Alignment Setting - needs to be set to get 419 * left-justified data like all other sensors. 420 */ 421 .das = { 422 .addr = 0x21, 423 .mask = 0x01, 424 }, 425 .drdy_irq = { 426 .int1 = { 427 .addr = 0x21, 428 .mask = 0x04, 429 }, 430 .stat_drdy = { 431 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 432 .mask = 0x07, 433 }, 434 }, 435 .sim = { 436 .addr = 0x21, 437 .value = BIT(1), 438 }, 439 .multi_read_bit = true, 440 .bootime = 2, /* guess */ 441 }, 442 { 443 .wai = 0x3b, 444 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 445 .sensors_supported = { 446 [0] = LIS331DL_ACCEL_DEV_NAME, 447 [1] = LIS302DL_ACCEL_DEV_NAME, 448 }, 449 .ch = (struct iio_chan_spec *)st_accel_8bit_channels, 450 .odr = { 451 .addr = 0x20, 452 .mask = 0x80, 453 .odr_avl = { 454 { .hz = 100, .value = 0x00, }, 455 { .hz = 400, .value = 0x01, }, 456 }, 457 }, 458 .pw = { 459 .addr = 0x20, 460 .mask = 0x40, 461 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 462 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 463 }, 464 .enable_axis = { 465 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 466 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 467 }, 468 .fs = { 469 .addr = 0x20, 470 .mask = 0x20, 471 /* 472 * TODO: check these resulting gain settings, these are 473 * not in the datsheet 474 */ 475 .fs_avl = { 476 [0] = { 477 .num = ST_ACCEL_FS_AVL_2G, 478 .value = 0x00, 479 .gain = IIO_G_TO_M_S_2(18000), 480 }, 481 [1] = { 482 .num = ST_ACCEL_FS_AVL_8G, 483 .value = 0x01, 484 .gain = IIO_G_TO_M_S_2(72000), 485 }, 486 }, 487 }, 488 .drdy_irq = { 489 .int1 = { 490 .addr = 0x22, 491 .mask = 0x04, 492 .addr_od = 0x22, 493 .mask_od = 0x40, 494 }, 495 .int2 = { 496 .addr = 0x22, 497 .mask = 0x20, 498 .addr_od = 0x22, 499 .mask_od = 0x40, 500 }, 501 .addr_ihl = 0x22, 502 .mask_ihl = 0x80, 503 .stat_drdy = { 504 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 505 .mask = 0x07, 506 }, 507 }, 508 .sim = { 509 .addr = 0x21, 510 .value = BIT(7), 511 }, 512 .multi_read_bit = false, 513 .bootime = 2, /* guess */ 514 }, 515 { 516 .wai = 0x32, 517 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 518 .sensors_supported = { 519 [0] = H3LIS331DL_ACCEL_DEV_NAME, 520 }, 521 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 522 .odr = { 523 .addr = 0x20, 524 .mask = 0x18, 525 .odr_avl = { 526 { .hz = 50, .value = 0x00, }, 527 { .hz = 100, .value = 0x01, }, 528 { .hz = 400, .value = 0x02, }, 529 { .hz = 1000, .value = 0x03, }, 530 }, 531 }, 532 .pw = { 533 .addr = 0x20, 534 .mask = 0x20, 535 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 536 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 537 }, 538 .enable_axis = { 539 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 540 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 541 }, 542 .fs = { 543 .addr = 0x23, 544 .mask = 0x30, 545 .fs_avl = { 546 [0] = { 547 .num = ST_ACCEL_FS_AVL_100G, 548 .value = 0x00, 549 .gain = IIO_G_TO_M_S_2(49000), 550 }, 551 [1] = { 552 .num = ST_ACCEL_FS_AVL_200G, 553 .value = 0x01, 554 .gain = IIO_G_TO_M_S_2(98000), 555 }, 556 [2] = { 557 .num = ST_ACCEL_FS_AVL_400G, 558 .value = 0x03, 559 .gain = IIO_G_TO_M_S_2(195000), 560 }, 561 }, 562 }, 563 .bdu = { 564 .addr = 0x23, 565 .mask = 0x80, 566 }, 567 .drdy_irq = { 568 .int1 = { 569 .addr = 0x22, 570 .mask = 0x02, 571 }, 572 .int2 = { 573 .addr = 0x22, 574 .mask = 0x10, 575 }, 576 .addr_ihl = 0x22, 577 .mask_ihl = 0x80, 578 }, 579 .sim = { 580 .addr = 0x23, 581 .value = BIT(0), 582 }, 583 .multi_read_bit = true, 584 .bootime = 2, 585 }, 586 { 587 .wai = 0x32, 588 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 589 .sensors_supported = { 590 [0] = IIS328DQ_ACCEL_DEV_NAME, 591 }, 592 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 593 .odr = { 594 .addr = 0x20, 595 .mask = 0x18, 596 .odr_avl = { 597 { .hz = 50, .value = 0x00, }, 598 { .hz = 100, .value = 0x01, }, 599 { .hz = 400, .value = 0x02, }, 600 { .hz = 1000, .value = 0x03, }, 601 }, 602 }, 603 .pw = { 604 .addr = 0x20, 605 .mask = 0x20, 606 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 607 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 608 }, 609 .enable_axis = { 610 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 611 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 612 }, 613 .fs = { 614 .addr = 0x23, 615 .mask = 0x30, 616 .fs_avl = { 617 [0] = { 618 .num = ST_ACCEL_FS_AVL_100G, 619 .value = 0x00, 620 .gain = IIO_G_TO_M_S_2(980), 621 }, 622 [1] = { 623 .num = ST_ACCEL_FS_AVL_200G, 624 .value = 0x01, 625 .gain = IIO_G_TO_M_S_2(1950), 626 }, 627 [2] = { 628 .num = ST_ACCEL_FS_AVL_400G, 629 .value = 0x03, 630 .gain = IIO_G_TO_M_S_2(3910), 631 }, 632 }, 633 }, 634 .bdu = { 635 .addr = 0x23, 636 .mask = 0x80, 637 }, 638 .drdy_irq = { 639 .int1 = { 640 .addr = 0x22, 641 .mask = 0x02, 642 }, 643 .int2 = { 644 .addr = 0x22, 645 .mask = 0x10, 646 }, 647 .addr_ihl = 0x22, 648 .mask_ihl = 0x80, 649 }, 650 .sim = { 651 .addr = 0x23, 652 .value = BIT(0), 653 }, 654 .multi_read_bit = true, 655 .bootime = 2, 656 }, 657 { 658 /* No WAI register present */ 659 .sensors_supported = { 660 [0] = LIS3L02DQ_ACCEL_DEV_NAME, 661 }, 662 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 663 .odr = { 664 .addr = 0x20, 665 .mask = 0x30, 666 .odr_avl = { 667 { .hz = 280, .value = 0x00, }, 668 { .hz = 560, .value = 0x01, }, 669 { .hz = 1120, .value = 0x02, }, 670 { .hz = 4480, .value = 0x03, }, 671 }, 672 }, 673 .pw = { 674 .addr = 0x20, 675 .mask = 0xc0, 676 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 677 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 678 }, 679 .enable_axis = { 680 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 681 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 682 }, 683 .fs = { 684 .fs_avl = { 685 [0] = { 686 .num = ST_ACCEL_FS_AVL_2G, 687 .gain = IIO_G_TO_M_S_2(488), 688 }, 689 }, 690 }, 691 /* 692 * The part has a BDU bit but if set the data is never 693 * updated so don't set it. 694 */ 695 .bdu = { 696 }, 697 .drdy_irq = { 698 .int1 = { 699 .addr = 0x21, 700 .mask = 0x04, 701 }, 702 .stat_drdy = { 703 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 704 .mask = 0x07, 705 }, 706 }, 707 .sim = { 708 .addr = 0x21, 709 .value = BIT(1), 710 }, 711 .multi_read_bit = false, 712 .bootime = 2, 713 }, 714 { 715 .wai = 0x33, 716 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 717 .sensors_supported = { 718 [0] = LNG2DM_ACCEL_DEV_NAME, 719 }, 720 .ch = (struct iio_chan_spec *)st_accel_8bit_channels, 721 .odr = { 722 .addr = 0x20, 723 .mask = 0xf0, 724 .odr_avl = { 725 { .hz = 1, .value = 0x01, }, 726 { .hz = 10, .value = 0x02, }, 727 { .hz = 25, .value = 0x03, }, 728 { .hz = 50, .value = 0x04, }, 729 { .hz = 100, .value = 0x05, }, 730 { .hz = 200, .value = 0x06, }, 731 { .hz = 400, .value = 0x07, }, 732 { .hz = 1600, .value = 0x08, }, 733 }, 734 }, 735 .pw = { 736 .addr = 0x20, 737 .mask = 0xf0, 738 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 739 }, 740 .enable_axis = { 741 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 742 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 743 }, 744 .fs = { 745 .addr = 0x23, 746 .mask = 0x30, 747 .fs_avl = { 748 [0] = { 749 .num = ST_ACCEL_FS_AVL_2G, 750 .value = 0x00, 751 .gain = IIO_G_TO_M_S_2(15600), 752 }, 753 [1] = { 754 .num = ST_ACCEL_FS_AVL_4G, 755 .value = 0x01, 756 .gain = IIO_G_TO_M_S_2(31200), 757 }, 758 [2] = { 759 .num = ST_ACCEL_FS_AVL_8G, 760 .value = 0x02, 761 .gain = IIO_G_TO_M_S_2(62500), 762 }, 763 [3] = { 764 .num = ST_ACCEL_FS_AVL_16G, 765 .value = 0x03, 766 .gain = IIO_G_TO_M_S_2(187500), 767 }, 768 }, 769 }, 770 .drdy_irq = { 771 .int1 = { 772 .addr = 0x22, 773 .mask = 0x10, 774 }, 775 .addr_ihl = 0x25, 776 .mask_ihl = 0x02, 777 .stat_drdy = { 778 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 779 .mask = 0x07, 780 }, 781 }, 782 .sim = { 783 .addr = 0x23, 784 .value = BIT(0), 785 }, 786 .multi_read_bit = true, 787 .bootime = 2, 788 }, 789 { 790 .wai = 0x44, 791 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 792 .sensors_supported = { 793 [0] = LIS2DW12_ACCEL_DEV_NAME, 794 }, 795 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 796 .odr = { 797 .addr = 0x20, 798 .mask = 0xf0, 799 .odr_avl = { 800 { .hz = 1, .value = 0x01, }, 801 { .hz = 12, .value = 0x02, }, 802 { .hz = 25, .value = 0x03, }, 803 { .hz = 50, .value = 0x04, }, 804 { .hz = 100, .value = 0x05, }, 805 { .hz = 200, .value = 0x06, }, 806 }, 807 }, 808 .pw = { 809 .addr = 0x20, 810 .mask = 0xf0, 811 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 812 }, 813 .fs = { 814 .addr = 0x25, 815 .mask = 0x30, 816 .fs_avl = { 817 [0] = { 818 .num = ST_ACCEL_FS_AVL_2G, 819 .value = 0x00, 820 .gain = IIO_G_TO_M_S_2(976), 821 }, 822 [1] = { 823 .num = ST_ACCEL_FS_AVL_4G, 824 .value = 0x01, 825 .gain = IIO_G_TO_M_S_2(1952), 826 }, 827 [2] = { 828 .num = ST_ACCEL_FS_AVL_8G, 829 .value = 0x02, 830 .gain = IIO_G_TO_M_S_2(3904), 831 }, 832 [3] = { 833 .num = ST_ACCEL_FS_AVL_16G, 834 .value = 0x03, 835 .gain = IIO_G_TO_M_S_2(7808), 836 }, 837 }, 838 }, 839 .bdu = { 840 .addr = 0x21, 841 .mask = 0x08, 842 }, 843 .drdy_irq = { 844 .int1 = { 845 .addr = 0x23, 846 .mask = 0x01, 847 .addr_od = 0x22, 848 .mask_od = 0x20, 849 }, 850 .int2 = { 851 .addr = 0x24, 852 .mask = 0x01, 853 .addr_od = 0x22, 854 .mask_od = 0x20, 855 }, 856 .addr_ihl = 0x22, 857 .mask_ihl = 0x08, 858 .stat_drdy = { 859 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 860 .mask = 0x01, 861 }, 862 }, 863 .sim = { 864 .addr = 0x21, 865 .value = BIT(0), 866 }, 867 .multi_read_bit = false, 868 .bootime = 2, 869 }, 870 { 871 .wai = 0x11, 872 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 873 .sensors_supported = { 874 [0] = LIS3DHH_ACCEL_DEV_NAME, 875 }, 876 .ch = (struct iio_chan_spec *)st_accel_16bit_channels, 877 .odr = { 878 /* just ODR = 1100Hz available */ 879 .odr_avl = { 880 { .hz = 1100, .value = 0x00, }, 881 }, 882 }, 883 .pw = { 884 .addr = 0x20, 885 .mask = 0x80, 886 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 887 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 888 }, 889 .fs = { 890 .fs_avl = { 891 [0] = { 892 .num = ST_ACCEL_FS_AVL_2G, 893 .gain = IIO_G_TO_M_S_2(76), 894 }, 895 }, 896 }, 897 .bdu = { 898 .addr = 0x20, 899 .mask = 0x01, 900 }, 901 .drdy_irq = { 902 .int1 = { 903 .addr = 0x21, 904 .mask = 0x80, 905 .addr_od = 0x23, 906 .mask_od = 0x04, 907 }, 908 .int2 = { 909 .addr = 0x22, 910 .mask = 0x80, 911 .addr_od = 0x23, 912 .mask_od = 0x08, 913 }, 914 .stat_drdy = { 915 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 916 .mask = 0x07, 917 }, 918 }, 919 .multi_read_bit = false, 920 .bootime = 2, 921 }, 922 { 923 .wai = 0x33, 924 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 925 .sensors_supported = { 926 [0] = LIS2DE12_ACCEL_DEV_NAME, 927 }, 928 .ch = (struct iio_chan_spec *)st_accel_8bit_channels, 929 .odr = { 930 .addr = 0x20, 931 .mask = 0xf0, 932 .odr_avl = { 933 { .hz = 1, .value = 0x01, }, 934 { .hz = 10, .value = 0x02, }, 935 { .hz = 25, .value = 0x03, }, 936 { .hz = 50, .value = 0x04, }, 937 { .hz = 100, .value = 0x05, }, 938 { .hz = 200, .value = 0x06, }, 939 { .hz = 400, .value = 0x07, }, 940 { .hz = 1620, .value = 0x08, }, 941 { .hz = 5376, .value = 0x09, }, 942 }, 943 }, 944 .pw = { 945 .addr = 0x20, 946 .mask = 0xf0, 947 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 948 }, 949 .enable_axis = { 950 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 951 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 952 }, 953 .fs = { 954 .addr = 0x23, 955 .mask = 0x30, 956 .fs_avl = { 957 [0] = { 958 .num = ST_ACCEL_FS_AVL_2G, 959 .value = 0x00, 960 .gain = IIO_G_TO_M_S_2(15600), 961 }, 962 [1] = { 963 .num = ST_ACCEL_FS_AVL_4G, 964 .value = 0x01, 965 .gain = IIO_G_TO_M_S_2(31200), 966 }, 967 [2] = { 968 .num = ST_ACCEL_FS_AVL_8G, 969 .value = 0x02, 970 .gain = IIO_G_TO_M_S_2(62500), 971 }, 972 [3] = { 973 .num = ST_ACCEL_FS_AVL_16G, 974 .value = 0x03, 975 .gain = IIO_G_TO_M_S_2(187500), 976 }, 977 }, 978 }, 979 .drdy_irq = { 980 .int1 = { 981 .addr = 0x22, 982 .mask = 0x10, 983 }, 984 .addr_ihl = 0x25, 985 .mask_ihl = 0x02, 986 .stat_drdy = { 987 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 988 .mask = 0x07, 989 }, 990 }, 991 .sim = { 992 .addr = 0x23, 993 .value = BIT(0), 994 }, 995 .multi_read_bit = true, 996 .bootime = 2, 997 }, 998 { 999 .wai = 0x43, 1000 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 1001 .sensors_supported = { 1002 [0] = LIS2DS12_ACCEL_DEV_NAME, 1003 }, 1004 .ch = (struct iio_chan_spec *)st_accel_16bit_channels, 1005 .odr = { 1006 .addr = 0x20, 1007 .mask = 0xf0, 1008 .odr_avl = { 1009 { .hz = 10, .value = 0x01, }, 1010 { .hz = 50, .value = 0x02, }, 1011 { .hz = 100, .value = 0x03, }, 1012 { .hz = 200, .value = 0x04, }, 1013 { .hz = 400, .value = 0x05, }, 1014 { .hz = 800, .value = 0x06, }, 1015 }, 1016 }, 1017 .pw = { 1018 .addr = 0x20, 1019 .mask = 0xf0, 1020 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 1021 }, 1022 .enable_axis = { 1023 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 1024 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 1025 }, 1026 .fs = { 1027 .addr = 0x20, 1028 .mask = 0x0c, 1029 .fs_avl = { 1030 [0] = { 1031 .num = ST_ACCEL_FS_AVL_2G, 1032 .value = 0x00, 1033 .gain = IIO_G_TO_M_S_2(61), 1034 }, 1035 [1] = { 1036 .num = ST_ACCEL_FS_AVL_4G, 1037 .value = 0x02, 1038 .gain = IIO_G_TO_M_S_2(122), 1039 }, 1040 [2] = { 1041 .num = ST_ACCEL_FS_AVL_8G, 1042 .value = 0x03, 1043 .gain = IIO_G_TO_M_S_2(244), 1044 }, 1045 [3] = { 1046 .num = ST_ACCEL_FS_AVL_16G, 1047 .value = 0x01, 1048 .gain = IIO_G_TO_M_S_2(488), 1049 }, 1050 }, 1051 }, 1052 .bdu = { 1053 .addr = 0x20, 1054 .mask = 0x01, 1055 }, 1056 .drdy_irq = { 1057 .int1 = { 1058 .addr = 0x23, 1059 .mask = 0x01, 1060 }, 1061 .int2 = { 1062 .addr = 0x24, 1063 .mask = 0x01, 1064 }, 1065 .addr_ihl = 0x22, 1066 .mask_ihl = 0x02, 1067 .stat_drdy = { 1068 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 1069 .mask = 0x01, 1070 }, 1071 }, 1072 .sim = { 1073 .addr = 0x21, 1074 .value = BIT(0), 1075 }, 1076 .multi_read_bit = true, 1077 .bootime = 2, 1078 }, 1079 { 1080 .wai = 0x41, 1081 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 1082 .sensors_supported = { 1083 [0] = LIS2HH12_ACCEL_DEV_NAME, 1084 [1] = LSM303C_ACCEL_DEV_NAME, 1085 }, 1086 .ch = (struct iio_chan_spec *)st_accel_16bit_channels, 1087 .odr = { 1088 .addr = 0x20, 1089 .mask = 0x70, 1090 .odr_avl = { 1091 { .hz = 10, .value = 0x01, }, 1092 { .hz = 50, .value = 0x02, }, 1093 { .hz = 100, .value = 0x03, }, 1094 { .hz = 200, .value = 0x04, }, 1095 { .hz = 400, .value = 0x05, }, 1096 { .hz = 800, .value = 0x06, }, 1097 }, 1098 }, 1099 .pw = { 1100 .addr = 0x20, 1101 .mask = 0x70, 1102 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 1103 }, 1104 .enable_axis = { 1105 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 1106 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 1107 }, 1108 .fs = { 1109 .addr = 0x23, 1110 .mask = 0x30, 1111 .fs_avl = { 1112 [0] = { 1113 .num = ST_ACCEL_FS_AVL_2G, 1114 .value = 0x00, 1115 .gain = IIO_G_TO_M_S_2(61), 1116 }, 1117 [1] = { 1118 .num = ST_ACCEL_FS_AVL_4G, 1119 .value = 0x02, 1120 .gain = IIO_G_TO_M_S_2(122), 1121 }, 1122 [2] = { 1123 .num = ST_ACCEL_FS_AVL_8G, 1124 .value = 0x03, 1125 .gain = IIO_G_TO_M_S_2(244), 1126 }, 1127 }, 1128 }, 1129 .bdu = { 1130 .addr = 0x20, 1131 .mask = 0x08, 1132 }, 1133 .drdy_irq = { 1134 .int1 = { 1135 .addr = 0x22, 1136 .mask = 0x01, 1137 }, 1138 .int2 = { 1139 .addr = 0x25, 1140 .mask = 0x01, 1141 }, 1142 .addr_ihl = 0x24, 1143 .mask_ihl = 0x02, 1144 .stat_drdy = { 1145 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 1146 .mask = 0x07, 1147 }, 1148 }, 1149 .sim = { 1150 .addr = 0x23, 1151 .value = BIT(0), 1152 }, 1153 .multi_read_bit = true, 1154 .bootime = 2, 1155 }, 1156 { 1157 .wai = 0x49, 1158 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 1159 .sensors_supported = { 1160 [0] = LSM9DS0_IMU_DEV_NAME, 1161 [1] = LSM303D_IMU_DEV_NAME, 1162 }, 1163 .ch = (struct iio_chan_spec *)st_accel_16bit_channels, 1164 .odr = { 1165 .addr = 0x20, 1166 .mask = GENMASK(7, 4), 1167 .odr_avl = { 1168 { 3, 0x01, }, 1169 { 6, 0x02, }, 1170 { 12, 0x03, }, 1171 { 25, 0x04, }, 1172 { 50, 0x05, }, 1173 { 100, 0x06, }, 1174 { 200, 0x07, }, 1175 { 400, 0x08, }, 1176 { 800, 0x09, }, 1177 { 1600, 0x0a, }, 1178 }, 1179 }, 1180 .pw = { 1181 .addr = 0x20, 1182 .mask = GENMASK(7, 4), 1183 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 1184 }, 1185 .enable_axis = { 1186 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 1187 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 1188 }, 1189 .fs = { 1190 .addr = 0x21, 1191 .mask = GENMASK(5, 3), 1192 .fs_avl = { 1193 [0] = { 1194 .num = ST_ACCEL_FS_AVL_2G, 1195 .value = 0x00, 1196 .gain = IIO_G_TO_M_S_2(61), 1197 }, 1198 [1] = { 1199 .num = ST_ACCEL_FS_AVL_4G, 1200 .value = 0x01, 1201 .gain = IIO_G_TO_M_S_2(122), 1202 }, 1203 [2] = { 1204 .num = ST_ACCEL_FS_AVL_6G, 1205 .value = 0x02, 1206 .gain = IIO_G_TO_M_S_2(183), 1207 }, 1208 [3] = { 1209 .num = ST_ACCEL_FS_AVL_8G, 1210 .value = 0x03, 1211 .gain = IIO_G_TO_M_S_2(244), 1212 }, 1213 [4] = { 1214 .num = ST_ACCEL_FS_AVL_16G, 1215 .value = 0x04, 1216 .gain = IIO_G_TO_M_S_2(732), 1217 }, 1218 }, 1219 }, 1220 .bdu = { 1221 .addr = 0x20, 1222 .mask = BIT(3), 1223 }, 1224 .drdy_irq = { 1225 .int1 = { 1226 .addr = 0x22, 1227 .mask = BIT(2), 1228 }, 1229 .int2 = { 1230 .addr = 0x23, 1231 .mask = BIT(3), 1232 }, 1233 .stat_drdy = { 1234 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 1235 .mask = GENMASK(2, 0), 1236 }, 1237 }, 1238 .sim = { 1239 .addr = 0x21, 1240 .value = BIT(0), 1241 }, 1242 .multi_read_bit = true, 1243 .bootime = 2, 1244 }, 1245 { 1246 /* 1247 * Not an ST part. Register-compatible with the LIS2DH, even 1248 * though the WAI value is different. 1249 */ 1250 .wai = 0x11, 1251 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 1252 .sensors_supported = { 1253 [0] = SC7A20_ACCEL_DEV_NAME, 1254 }, 1255 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 1256 .odr = { 1257 .addr = 0x20, 1258 .mask = 0xf0, 1259 .odr_avl = { 1260 { .hz = 1, .value = 0x01, }, 1261 { .hz = 10, .value = 0x02, }, 1262 { .hz = 25, .value = 0x03, }, 1263 { .hz = 50, .value = 0x04, }, 1264 { .hz = 100, .value = 0x05, }, 1265 { .hz = 200, .value = 0x06, }, 1266 { .hz = 400, .value = 0x07, }, 1267 { .hz = 1600, .value = 0x08, }, 1268 }, 1269 }, 1270 .pw = { 1271 .addr = 0x20, 1272 .mask = 0xf0, 1273 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 1274 }, 1275 .enable_axis = { 1276 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 1277 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 1278 }, 1279 .fs = { 1280 .addr = 0x23, 1281 .mask = 0x30, 1282 .fs_avl = { 1283 [0] = { 1284 .num = ST_ACCEL_FS_AVL_2G, 1285 .value = 0x00, 1286 .gain = IIO_G_TO_M_S_2(1000), 1287 }, 1288 [1] = { 1289 .num = ST_ACCEL_FS_AVL_4G, 1290 .value = 0x01, 1291 .gain = IIO_G_TO_M_S_2(2000), 1292 }, 1293 [2] = { 1294 .num = ST_ACCEL_FS_AVL_8G, 1295 .value = 0x02, 1296 .gain = IIO_G_TO_M_S_2(4000), 1297 }, 1298 [3] = { 1299 .num = ST_ACCEL_FS_AVL_16G, 1300 .value = 0x03, 1301 .gain = IIO_G_TO_M_S_2(12000), 1302 }, 1303 }, 1304 }, 1305 .bdu = { 1306 .addr = 0x23, 1307 .mask = 0x80, 1308 }, 1309 .drdy_irq = { 1310 .int1 = { 1311 .addr = 0x22, 1312 .mask = 0x10, 1313 }, 1314 .addr_ihl = 0x25, 1315 .mask_ihl = 0x02, 1316 .stat_drdy = { 1317 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 1318 .mask = 0x07, 1319 }, 1320 }, 1321 .sim = { 1322 .addr = 0x23, 1323 .value = BIT(0), 1324 }, 1325 .multi_read_bit = true, 1326 .bootime = 2, 1327 }, 1328}; 1329 1330/* Default accel DRDY is available on INT1 pin */ 1331static const struct st_sensors_platform_data default_accel_pdata = { 1332 .drdy_int_pin = 1, 1333}; 1334 1335static int st_accel_read_raw(struct iio_dev *indio_dev, 1336 struct iio_chan_spec const *ch, int *val, 1337 int *val2, long mask) 1338{ 1339 int err; 1340 struct st_sensor_data *adata = iio_priv(indio_dev); 1341 1342 switch (mask) { 1343 case IIO_CHAN_INFO_RAW: 1344 err = st_sensors_read_info_raw(indio_dev, ch, val); 1345 if (err < 0) 1346 goto read_error; 1347 1348 return IIO_VAL_INT; 1349 case IIO_CHAN_INFO_SCALE: 1350 *val = adata->current_fullscale->gain / 1000000; 1351 *val2 = adata->current_fullscale->gain % 1000000; 1352 return IIO_VAL_INT_PLUS_MICRO; 1353 case IIO_CHAN_INFO_SAMP_FREQ: 1354 *val = adata->odr; 1355 return IIO_VAL_INT; 1356 default: 1357 return -EINVAL; 1358 } 1359 1360read_error: 1361 return err; 1362} 1363 1364static int st_accel_write_raw(struct iio_dev *indio_dev, 1365 struct iio_chan_spec const *chan, int val, int val2, long mask) 1366{ 1367 switch (mask) { 1368 case IIO_CHAN_INFO_SCALE: { 1369 int gain; 1370 1371 gain = val * 1000000 + val2; 1372 return st_sensors_set_fullscale_by_gain(indio_dev, gain); 1373 } 1374 case IIO_CHAN_INFO_SAMP_FREQ: 1375 if (val2) 1376 return -EINVAL; 1377 1378 return st_sensors_set_odr(indio_dev, val); 1379 default: 1380 return -EINVAL; 1381 } 1382} 1383 1384static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL(); 1385static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_accel_scale_available); 1386 1387static struct attribute *st_accel_attributes[] = { 1388 &iio_dev_attr_sampling_frequency_available.dev_attr.attr, 1389 &iio_dev_attr_in_accel_scale_available.dev_attr.attr, 1390 NULL, 1391}; 1392 1393static const struct attribute_group st_accel_attribute_group = { 1394 .attrs = st_accel_attributes, 1395}; 1396 1397static const struct iio_info accel_info = { 1398 .attrs = &st_accel_attribute_group, 1399 .read_raw = &st_accel_read_raw, 1400 .write_raw = &st_accel_write_raw, 1401 .debugfs_reg_access = &st_sensors_debugfs_reg_access, 1402}; 1403 1404#ifdef CONFIG_IIO_TRIGGER 1405static const struct iio_trigger_ops st_accel_trigger_ops = { 1406 .set_trigger_state = ST_ACCEL_TRIGGER_SET_STATE, 1407 .validate_device = st_sensors_validate_device, 1408}; 1409#define ST_ACCEL_TRIGGER_OPS (&st_accel_trigger_ops) 1410#else 1411#define ST_ACCEL_TRIGGER_OPS NULL 1412#endif 1413 1414#ifdef CONFIG_ACPI 1415/* Read ST-specific _ONT orientation data from ACPI and generate an 1416 * appropriate mount matrix. 1417 */ 1418static int apply_acpi_orientation(struct iio_dev *indio_dev) 1419{ 1420 struct st_sensor_data *adata = iio_priv(indio_dev); 1421 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; 1422 struct acpi_device *adev; 1423 union acpi_object *ont; 1424 union acpi_object *elements; 1425 acpi_status status; 1426 struct device *parent = indio_dev->dev.parent; 1427 int ret = -EINVAL; 1428 unsigned int val; 1429 int i, j; 1430 int final_ont[3][3] = { { 0 }, }; 1431 1432 /* For some reason, ST's _ONT translation does not apply directly 1433 * to the data read from the sensor. Another translation must be 1434 * performed first, as described by the matrix below. Perhaps 1435 * ST required this specific translation for the first product 1436 * where the device was mounted? 1437 */ 1438 const int default_ont[3][3] = { 1439 { 0, 1, 0 }, 1440 { -1, 0, 0 }, 1441 { 0, 0, -1 }, 1442 }; 1443 1444 1445 adev = ACPI_COMPANION(parent); 1446 if (!adev) 1447 return -ENXIO; 1448 1449 /* Read _ONT data, which should be a package of 6 integers. */ 1450 status = acpi_evaluate_object(adev->handle, "_ONT", NULL, &buffer); 1451 if (status == AE_NOT_FOUND) { 1452 return -ENXIO; 1453 } else if (ACPI_FAILURE(status)) { 1454 dev_warn(parent, "failed to execute _ONT: %d\n", status); 1455 return status; 1456 } 1457 1458 ont = buffer.pointer; 1459 if (ont->type != ACPI_TYPE_PACKAGE || ont->package.count != 6) 1460 goto out; 1461 1462 /* The first 3 integers provide axis order information. 1463 * e.g. 0 1 2 would indicate normal X,Y,Z ordering. 1464 * e.g. 1 0 2 indicates that data arrives in order Y,X,Z. 1465 */ 1466 elements = ont->package.elements; 1467 for (i = 0; i < 3; i++) { 1468 if (elements[i].type != ACPI_TYPE_INTEGER) 1469 goto out; 1470 1471 val = elements[i].integer.value; 1472 if (val > 2) 1473 goto out; 1474 1475 /* Avoiding full matrix multiplication, we simply reorder the 1476 * columns in the default_ont matrix according to the 1477 * ordering provided by _ONT. 1478 */ 1479 final_ont[0][i] = default_ont[0][val]; 1480 final_ont[1][i] = default_ont[1][val]; 1481 final_ont[2][i] = default_ont[2][val]; 1482 } 1483 1484 /* The final 3 integers provide sign flip information. 1485 * 0 means no change, 1 means flip. 1486 * e.g. 0 0 1 means that Z data should be sign-flipped. 1487 * This is applied after the axis reordering from above. 1488 */ 1489 elements += 3; 1490 for (i = 0; i < 3; i++) { 1491 if (elements[i].type != ACPI_TYPE_INTEGER) 1492 goto out; 1493 1494 val = elements[i].integer.value; 1495 if (val != 0 && val != 1) 1496 goto out; 1497 if (!val) 1498 continue; 1499 1500 /* Flip the values in the indicated column */ 1501 final_ont[0][i] *= -1; 1502 final_ont[1][i] *= -1; 1503 final_ont[2][i] *= -1; 1504 } 1505 1506 /* Convert our integer matrix to a string-based iio_mount_matrix */ 1507 for (i = 0; i < 3; i++) { 1508 for (j = 0; j < 3; j++) { 1509 int matrix_val = final_ont[i][j]; 1510 char *str_value; 1511 1512 switch (matrix_val) { 1513 case -1: 1514 str_value = "-1"; 1515 break; 1516 case 0: 1517 str_value = "0"; 1518 break; 1519 case 1: 1520 str_value = "1"; 1521 break; 1522 default: 1523 goto out; 1524 } 1525 adata->mount_matrix.rotation[i * 3 + j] = str_value; 1526 } 1527 } 1528 1529 ret = 0; 1530 dev_info(parent, "computed mount matrix from ACPI\n"); 1531 1532out: 1533 kfree(buffer.pointer); 1534 if (ret) 1535 dev_dbg(parent, 1536 "failed to apply ACPI orientation data: %d\n", ret); 1537 1538 return ret; 1539} 1540#else /* !CONFIG_ACPI */ 1541static int apply_acpi_orientation(struct iio_dev *indio_dev) 1542{ 1543 return -EINVAL; 1544} 1545#endif 1546 1547/* 1548 * st_accel_get_settings() - get sensor settings from device name 1549 * @name: device name buffer reference. 1550 * 1551 * Return: valid reference on success, NULL otherwise. 1552 */ 1553const struct st_sensor_settings *st_accel_get_settings(const char *name) 1554{ 1555 int index = st_sensors_get_settings_index(name, 1556 st_accel_sensors_settings, 1557 ARRAY_SIZE(st_accel_sensors_settings)); 1558 if (index < 0) 1559 return NULL; 1560 1561 return &st_accel_sensors_settings[index]; 1562} 1563EXPORT_SYMBOL_NS(st_accel_get_settings, "IIO_ST_SENSORS"); 1564 1565int st_accel_common_probe(struct iio_dev *indio_dev) 1566{ 1567 struct st_sensor_data *adata = iio_priv(indio_dev); 1568 struct device *parent = indio_dev->dev.parent; 1569 struct st_sensors_platform_data *pdata = dev_get_platdata(parent); 1570 int err; 1571 1572 indio_dev->modes = INDIO_DIRECT_MODE; 1573 indio_dev->info = &accel_info; 1574 1575 err = st_sensors_verify_id(indio_dev); 1576 if (err < 0) 1577 return err; 1578 1579 adata->num_data_channels = ST_ACCEL_NUMBER_DATA_CHANNELS; 1580 indio_dev->channels = adata->sensor_settings->ch; 1581 indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS; 1582 1583 /* 1584 * First try specific ACPI methods to retrieve orientation then try the 1585 * generic function. 1586 */ 1587 err = apply_acpi_orientation(indio_dev); 1588 if (err) { 1589 err = iio_read_mount_matrix(parent, &adata->mount_matrix); 1590 if (err) 1591 return err; 1592 } 1593 1594 adata->current_fullscale = &adata->sensor_settings->fs.fs_avl[0]; 1595 adata->odr = adata->sensor_settings->odr.odr_avl[0].hz; 1596 1597 if (!pdata) 1598 pdata = (struct st_sensors_platform_data *)&default_accel_pdata; 1599 1600 err = st_sensors_init_sensor(indio_dev, pdata); 1601 if (err < 0) 1602 return err; 1603 1604 err = st_accel_allocate_ring(indio_dev); 1605 if (err < 0) 1606 return err; 1607 1608 if (adata->irq > 0) { 1609 err = st_sensors_allocate_trigger(indio_dev, 1610 ST_ACCEL_TRIGGER_OPS); 1611 if (err < 0) 1612 return err; 1613 } 1614 1615 return devm_iio_device_register(parent, indio_dev); 1616} 1617EXPORT_SYMBOL_NS(st_accel_common_probe, "IIO_ST_SENSORS"); 1618 1619MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>"); 1620MODULE_DESCRIPTION("STMicroelectronics accelerometers driver"); 1621MODULE_LICENSE("GPL v2"); 1622MODULE_IMPORT_NS("IIO_ST_SENSORS");
~/
Read-only file preview.