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 40 static const struct iio_mount_matrix * 41 st_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 49 static 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 54 static 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 73 static 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 92 static 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 111 static 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 [1] = IIS328DQ_ACCEL_DEV_NAME, 521 }, 522 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 523 .odr = { 524 .addr = 0x20, 525 .mask = 0x18, 526 .odr_avl = { 527 { .hz = 50, .value = 0x00, }, 528 { .hz = 100, .value = 0x01, }, 529 { .hz = 400, .value = 0x02, }, 530 { .hz = 1000, .value = 0x03, }, 531 }, 532 }, 533 .pw = { 534 .addr = 0x20, 535 .mask = 0x20, 536 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 537 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 538 }, 539 .enable_axis = { 540 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 541 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 542 }, 543 .fs = { 544 .addr = 0x23, 545 .mask = 0x30, 546 .fs_avl = { 547 [0] = { 548 .num = ST_ACCEL_FS_AVL_100G, 549 .value = 0x00, 550 .gain = IIO_G_TO_M_S_2(49000), 551 }, 552 [1] = { 553 .num = ST_ACCEL_FS_AVL_200G, 554 .value = 0x01, 555 .gain = IIO_G_TO_M_S_2(98000), 556 }, 557 [2] = { 558 .num = ST_ACCEL_FS_AVL_400G, 559 .value = 0x03, 560 .gain = IIO_G_TO_M_S_2(195000), 561 }, 562 }, 563 }, 564 .bdu = { 565 .addr = 0x23, 566 .mask = 0x80, 567 }, 568 .drdy_irq = { 569 .int1 = { 570 .addr = 0x22, 571 .mask = 0x02, 572 }, 573 .int2 = { 574 .addr = 0x22, 575 .mask = 0x10, 576 }, 577 .addr_ihl = 0x22, 578 .mask_ihl = 0x80, 579 }, 580 .sim = { 581 .addr = 0x23, 582 .value = BIT(0), 583 }, 584 .multi_read_bit = true, 585 .bootime = 2, 586 }, 587 { 588 /* No WAI register present */ 589 .sensors_supported = { 590 [0] = LIS3L02DQ_ACCEL_DEV_NAME, 591 }, 592 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 593 .odr = { 594 .addr = 0x20, 595 .mask = 0x30, 596 .odr_avl = { 597 { .hz = 280, .value = 0x00, }, 598 { .hz = 560, .value = 0x01, }, 599 { .hz = 1120, .value = 0x02, }, 600 { .hz = 4480, .value = 0x03, }, 601 }, 602 }, 603 .pw = { 604 .addr = 0x20, 605 .mask = 0xc0, 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 .fs_avl = { 615 [0] = { 616 .num = ST_ACCEL_FS_AVL_2G, 617 .gain = IIO_G_TO_M_S_2(488), 618 }, 619 }, 620 }, 621 /* 622 * The part has a BDU bit but if set the data is never 623 * updated so don't set it. 624 */ 625 .bdu = { 626 }, 627 .drdy_irq = { 628 .int1 = { 629 .addr = 0x21, 630 .mask = 0x04, 631 }, 632 .stat_drdy = { 633 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 634 .mask = 0x07, 635 }, 636 }, 637 .sim = { 638 .addr = 0x21, 639 .value = BIT(1), 640 }, 641 .multi_read_bit = false, 642 .bootime = 2, 643 }, 644 { 645 .wai = 0x33, 646 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 647 .sensors_supported = { 648 [0] = LNG2DM_ACCEL_DEV_NAME, 649 }, 650 .ch = (struct iio_chan_spec *)st_accel_8bit_channels, 651 .odr = { 652 .addr = 0x20, 653 .mask = 0xf0, 654 .odr_avl = { 655 { .hz = 1, .value = 0x01, }, 656 { .hz = 10, .value = 0x02, }, 657 { .hz = 25, .value = 0x03, }, 658 { .hz = 50, .value = 0x04, }, 659 { .hz = 100, .value = 0x05, }, 660 { .hz = 200, .value = 0x06, }, 661 { .hz = 400, .value = 0x07, }, 662 { .hz = 1600, .value = 0x08, }, 663 }, 664 }, 665 .pw = { 666 .addr = 0x20, 667 .mask = 0xf0, 668 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 669 }, 670 .enable_axis = { 671 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 672 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 673 }, 674 .fs = { 675 .addr = 0x23, 676 .mask = 0x30, 677 .fs_avl = { 678 [0] = { 679 .num = ST_ACCEL_FS_AVL_2G, 680 .value = 0x00, 681 .gain = IIO_G_TO_M_S_2(15600), 682 }, 683 [1] = { 684 .num = ST_ACCEL_FS_AVL_4G, 685 .value = 0x01, 686 .gain = IIO_G_TO_M_S_2(31200), 687 }, 688 [2] = { 689 .num = ST_ACCEL_FS_AVL_8G, 690 .value = 0x02, 691 .gain = IIO_G_TO_M_S_2(62500), 692 }, 693 [3] = { 694 .num = ST_ACCEL_FS_AVL_16G, 695 .value = 0x03, 696 .gain = IIO_G_TO_M_S_2(187500), 697 }, 698 }, 699 }, 700 .drdy_irq = { 701 .int1 = { 702 .addr = 0x22, 703 .mask = 0x10, 704 }, 705 .addr_ihl = 0x25, 706 .mask_ihl = 0x02, 707 .stat_drdy = { 708 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 709 .mask = 0x07, 710 }, 711 }, 712 .sim = { 713 .addr = 0x23, 714 .value = BIT(0), 715 }, 716 .multi_read_bit = true, 717 .bootime = 2, 718 }, 719 { 720 .wai = 0x44, 721 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 722 .sensors_supported = { 723 [0] = LIS2DW12_ACCEL_DEV_NAME, 724 }, 725 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 726 .odr = { 727 .addr = 0x20, 728 .mask = 0xf0, 729 .odr_avl = { 730 { .hz = 1, .value = 0x01, }, 731 { .hz = 12, .value = 0x02, }, 732 { .hz = 25, .value = 0x03, }, 733 { .hz = 50, .value = 0x04, }, 734 { .hz = 100, .value = 0x05, }, 735 { .hz = 200, .value = 0x06, }, 736 }, 737 }, 738 .pw = { 739 .addr = 0x20, 740 .mask = 0xf0, 741 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 742 }, 743 .fs = { 744 .addr = 0x25, 745 .mask = 0x30, 746 .fs_avl = { 747 [0] = { 748 .num = ST_ACCEL_FS_AVL_2G, 749 .value = 0x00, 750 .gain = IIO_G_TO_M_S_2(976), 751 }, 752 [1] = { 753 .num = ST_ACCEL_FS_AVL_4G, 754 .value = 0x01, 755 .gain = IIO_G_TO_M_S_2(1952), 756 }, 757 [2] = { 758 .num = ST_ACCEL_FS_AVL_8G, 759 .value = 0x02, 760 .gain = IIO_G_TO_M_S_2(3904), 761 }, 762 [3] = { 763 .num = ST_ACCEL_FS_AVL_16G, 764 .value = 0x03, 765 .gain = IIO_G_TO_M_S_2(7808), 766 }, 767 }, 768 }, 769 .bdu = { 770 .addr = 0x21, 771 .mask = 0x08, 772 }, 773 .drdy_irq = { 774 .int1 = { 775 .addr = 0x23, 776 .mask = 0x01, 777 .addr_od = 0x22, 778 .mask_od = 0x20, 779 }, 780 .int2 = { 781 .addr = 0x24, 782 .mask = 0x01, 783 .addr_od = 0x22, 784 .mask_od = 0x20, 785 }, 786 .addr_ihl = 0x22, 787 .mask_ihl = 0x08, 788 .stat_drdy = { 789 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 790 .mask = 0x01, 791 }, 792 }, 793 .sim = { 794 .addr = 0x21, 795 .value = BIT(0), 796 }, 797 .multi_read_bit = false, 798 .bootime = 2, 799 }, 800 { 801 .wai = 0x11, 802 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 803 .sensors_supported = { 804 [0] = LIS3DHH_ACCEL_DEV_NAME, 805 }, 806 .ch = (struct iio_chan_spec *)st_accel_16bit_channels, 807 .odr = { 808 /* just ODR = 1100Hz available */ 809 .odr_avl = { 810 { .hz = 1100, .value = 0x00, }, 811 }, 812 }, 813 .pw = { 814 .addr = 0x20, 815 .mask = 0x80, 816 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 817 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 818 }, 819 .fs = { 820 .fs_avl = { 821 [0] = { 822 .num = ST_ACCEL_FS_AVL_2G, 823 .gain = IIO_G_TO_M_S_2(76), 824 }, 825 }, 826 }, 827 .bdu = { 828 .addr = 0x20, 829 .mask = 0x01, 830 }, 831 .drdy_irq = { 832 .int1 = { 833 .addr = 0x21, 834 .mask = 0x80, 835 .addr_od = 0x23, 836 .mask_od = 0x04, 837 }, 838 .int2 = { 839 .addr = 0x22, 840 .mask = 0x80, 841 .addr_od = 0x23, 842 .mask_od = 0x08, 843 }, 844 .stat_drdy = { 845 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 846 .mask = 0x07, 847 }, 848 }, 849 .multi_read_bit = false, 850 .bootime = 2, 851 }, 852 { 853 .wai = 0x33, 854 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 855 .sensors_supported = { 856 [0] = LIS2DE12_ACCEL_DEV_NAME, 857 }, 858 .ch = (struct iio_chan_spec *)st_accel_8bit_channels, 859 .odr = { 860 .addr = 0x20, 861 .mask = 0xf0, 862 .odr_avl = { 863 { .hz = 1, .value = 0x01, }, 864 { .hz = 10, .value = 0x02, }, 865 { .hz = 25, .value = 0x03, }, 866 { .hz = 50, .value = 0x04, }, 867 { .hz = 100, .value = 0x05, }, 868 { .hz = 200, .value = 0x06, }, 869 { .hz = 400, .value = 0x07, }, 870 { .hz = 1620, .value = 0x08, }, 871 { .hz = 5376, .value = 0x09, }, 872 }, 873 }, 874 .pw = { 875 .addr = 0x20, 876 .mask = 0xf0, 877 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 878 }, 879 .enable_axis = { 880 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 881 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 882 }, 883 .fs = { 884 .addr = 0x23, 885 .mask = 0x30, 886 .fs_avl = { 887 [0] = { 888 .num = ST_ACCEL_FS_AVL_2G, 889 .value = 0x00, 890 .gain = IIO_G_TO_M_S_2(15600), 891 }, 892 [1] = { 893 .num = ST_ACCEL_FS_AVL_4G, 894 .value = 0x01, 895 .gain = IIO_G_TO_M_S_2(31200), 896 }, 897 [2] = { 898 .num = ST_ACCEL_FS_AVL_8G, 899 .value = 0x02, 900 .gain = IIO_G_TO_M_S_2(62500), 901 }, 902 [3] = { 903 .num = ST_ACCEL_FS_AVL_16G, 904 .value = 0x03, 905 .gain = IIO_G_TO_M_S_2(187500), 906 }, 907 }, 908 }, 909 .drdy_irq = { 910 .int1 = { 911 .addr = 0x22, 912 .mask = 0x10, 913 }, 914 .addr_ihl = 0x25, 915 .mask_ihl = 0x02, 916 .stat_drdy = { 917 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 918 .mask = 0x07, 919 }, 920 }, 921 .sim = { 922 .addr = 0x23, 923 .value = BIT(0), 924 }, 925 .multi_read_bit = true, 926 .bootime = 2, 927 }, 928 { 929 .wai = 0x43, 930 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 931 .sensors_supported = { 932 [0] = LIS2DS12_ACCEL_DEV_NAME, 933 }, 934 .ch = (struct iio_chan_spec *)st_accel_16bit_channels, 935 .odr = { 936 .addr = 0x20, 937 .mask = 0xf0, 938 .odr_avl = { 939 { .hz = 10, .value = 0x01, }, 940 { .hz = 50, .value = 0x02, }, 941 { .hz = 100, .value = 0x03, }, 942 { .hz = 200, .value = 0x04, }, 943 { .hz = 400, .value = 0x05, }, 944 { .hz = 800, .value = 0x06, }, 945 }, 946 }, 947 .pw = { 948 .addr = 0x20, 949 .mask = 0xf0, 950 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 951 }, 952 .enable_axis = { 953 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 954 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 955 }, 956 .fs = { 957 .addr = 0x20, 958 .mask = 0x0c, 959 .fs_avl = { 960 [0] = { 961 .num = ST_ACCEL_FS_AVL_2G, 962 .value = 0x00, 963 .gain = IIO_G_TO_M_S_2(61), 964 }, 965 [1] = { 966 .num = ST_ACCEL_FS_AVL_4G, 967 .value = 0x02, 968 .gain = IIO_G_TO_M_S_2(122), 969 }, 970 [2] = { 971 .num = ST_ACCEL_FS_AVL_8G, 972 .value = 0x03, 973 .gain = IIO_G_TO_M_S_2(244), 974 }, 975 [3] = { 976 .num = ST_ACCEL_FS_AVL_16G, 977 .value = 0x01, 978 .gain = IIO_G_TO_M_S_2(488), 979 }, 980 }, 981 }, 982 .bdu = { 983 .addr = 0x20, 984 .mask = 0x01, 985 }, 986 .drdy_irq = { 987 .int1 = { 988 .addr = 0x23, 989 .mask = 0x01, 990 }, 991 .int2 = { 992 .addr = 0x24, 993 .mask = 0x01, 994 }, 995 .addr_ihl = 0x22, 996 .mask_ihl = 0x02, 997 .stat_drdy = { 998 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 999 .mask = 0x01, 1000 }, 1001 }, 1002 .sim = { 1003 .addr = 0x21, 1004 .value = BIT(0), 1005 }, 1006 .multi_read_bit = true, 1007 .bootime = 2, 1008 }, 1009 { 1010 .wai = 0x41, 1011 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 1012 .sensors_supported = { 1013 [0] = LIS2HH12_ACCEL_DEV_NAME, 1014 [1] = LSM303C_ACCEL_DEV_NAME, 1015 }, 1016 .ch = (struct iio_chan_spec *)st_accel_16bit_channels, 1017 .odr = { 1018 .addr = 0x20, 1019 .mask = 0x70, 1020 .odr_avl = { 1021 { .hz = 10, .value = 0x01, }, 1022 { .hz = 50, .value = 0x02, }, 1023 { .hz = 100, .value = 0x03, }, 1024 { .hz = 200, .value = 0x04, }, 1025 { .hz = 400, .value = 0x05, }, 1026 { .hz = 800, .value = 0x06, }, 1027 }, 1028 }, 1029 .pw = { 1030 .addr = 0x20, 1031 .mask = 0x70, 1032 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 1033 }, 1034 .enable_axis = { 1035 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 1036 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 1037 }, 1038 .fs = { 1039 .addr = 0x23, 1040 .mask = 0x30, 1041 .fs_avl = { 1042 [0] = { 1043 .num = ST_ACCEL_FS_AVL_2G, 1044 .value = 0x00, 1045 .gain = IIO_G_TO_M_S_2(61), 1046 }, 1047 [1] = { 1048 .num = ST_ACCEL_FS_AVL_4G, 1049 .value = 0x02, 1050 .gain = IIO_G_TO_M_S_2(122), 1051 }, 1052 [2] = { 1053 .num = ST_ACCEL_FS_AVL_8G, 1054 .value = 0x03, 1055 .gain = IIO_G_TO_M_S_2(244), 1056 }, 1057 }, 1058 }, 1059 .bdu = { 1060 .addr = 0x20, 1061 .mask = 0x08, 1062 }, 1063 .drdy_irq = { 1064 .int1 = { 1065 .addr = 0x22, 1066 .mask = 0x01, 1067 }, 1068 .int2 = { 1069 .addr = 0x25, 1070 .mask = 0x01, 1071 }, 1072 .addr_ihl = 0x24, 1073 .mask_ihl = 0x02, 1074 .stat_drdy = { 1075 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 1076 .mask = 0x07, 1077 }, 1078 }, 1079 .sim = { 1080 .addr = 0x23, 1081 .value = BIT(0), 1082 }, 1083 .multi_read_bit = true, 1084 .bootime = 2, 1085 }, 1086 { 1087 .wai = 0x49, 1088 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 1089 .sensors_supported = { 1090 [0] = LSM9DS0_IMU_DEV_NAME, 1091 [1] = LSM303D_IMU_DEV_NAME, 1092 }, 1093 .ch = (struct iio_chan_spec *)st_accel_16bit_channels, 1094 .odr = { 1095 .addr = 0x20, 1096 .mask = GENMASK(7, 4), 1097 .odr_avl = { 1098 { 3, 0x01, }, 1099 { 6, 0x02, }, 1100 { 12, 0x03, }, 1101 { 25, 0x04, }, 1102 { 50, 0x05, }, 1103 { 100, 0x06, }, 1104 { 200, 0x07, }, 1105 { 400, 0x08, }, 1106 { 800, 0x09, }, 1107 { 1600, 0x0a, }, 1108 }, 1109 }, 1110 .pw = { 1111 .addr = 0x20, 1112 .mask = GENMASK(7, 4), 1113 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 1114 }, 1115 .enable_axis = { 1116 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 1117 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 1118 }, 1119 .fs = { 1120 .addr = 0x21, 1121 .mask = GENMASK(5, 3), 1122 .fs_avl = { 1123 [0] = { 1124 .num = ST_ACCEL_FS_AVL_2G, 1125 .value = 0x00, 1126 .gain = IIO_G_TO_M_S_2(61), 1127 }, 1128 [1] = { 1129 .num = ST_ACCEL_FS_AVL_4G, 1130 .value = 0x01, 1131 .gain = IIO_G_TO_M_S_2(122), 1132 }, 1133 [2] = { 1134 .num = ST_ACCEL_FS_AVL_6G, 1135 .value = 0x02, 1136 .gain = IIO_G_TO_M_S_2(183), 1137 }, 1138 [3] = { 1139 .num = ST_ACCEL_FS_AVL_8G, 1140 .value = 0x03, 1141 .gain = IIO_G_TO_M_S_2(244), 1142 }, 1143 [4] = { 1144 .num = ST_ACCEL_FS_AVL_16G, 1145 .value = 0x04, 1146 .gain = IIO_G_TO_M_S_2(732), 1147 }, 1148 }, 1149 }, 1150 .bdu = { 1151 .addr = 0x20, 1152 .mask = BIT(3), 1153 }, 1154 .drdy_irq = { 1155 .int1 = { 1156 .addr = 0x22, 1157 .mask = BIT(2), 1158 }, 1159 .int2 = { 1160 .addr = 0x23, 1161 .mask = BIT(3), 1162 }, 1163 .stat_drdy = { 1164 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 1165 .mask = GENMASK(2, 0), 1166 }, 1167 }, 1168 .sim = { 1169 .addr = 0x21, 1170 .value = BIT(0), 1171 }, 1172 .multi_read_bit = true, 1173 .bootime = 2, 1174 }, 1175 { 1176 /* 1177 * Not an ST part. Register-compatible with the LIS2DH, even 1178 * though the WAI value is different. 1179 */ 1180 .wai = 0x11, 1181 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 1182 .sensors_supported = { 1183 [0] = SC7A20_ACCEL_DEV_NAME, 1184 }, 1185 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 1186 .odr = { 1187 .addr = 0x20, 1188 .mask = 0xf0, 1189 .odr_avl = { 1190 { .hz = 1, .value = 0x01, }, 1191 { .hz = 10, .value = 0x02, }, 1192 { .hz = 25, .value = 0x03, }, 1193 { .hz = 50, .value = 0x04, }, 1194 { .hz = 100, .value = 0x05, }, 1195 { .hz = 200, .value = 0x06, }, 1196 { .hz = 400, .value = 0x07, }, 1197 { .hz = 1600, .value = 0x08, }, 1198 }, 1199 }, 1200 .pw = { 1201 .addr = 0x20, 1202 .mask = 0xf0, 1203 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 1204 }, 1205 .enable_axis = { 1206 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 1207 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 1208 }, 1209 .fs = { 1210 .addr = 0x23, 1211 .mask = 0x30, 1212 .fs_avl = { 1213 [0] = { 1214 .num = ST_ACCEL_FS_AVL_2G, 1215 .value = 0x00, 1216 .gain = IIO_G_TO_M_S_2(1000), 1217 }, 1218 [1] = { 1219 .num = ST_ACCEL_FS_AVL_4G, 1220 .value = 0x01, 1221 .gain = IIO_G_TO_M_S_2(2000), 1222 }, 1223 [2] = { 1224 .num = ST_ACCEL_FS_AVL_8G, 1225 .value = 0x02, 1226 .gain = IIO_G_TO_M_S_2(4000), 1227 }, 1228 [3] = { 1229 .num = ST_ACCEL_FS_AVL_16G, 1230 .value = 0x03, 1231 .gain = IIO_G_TO_M_S_2(12000), 1232 }, 1233 }, 1234 }, 1235 .bdu = { 1236 .addr = 0x23, 1237 .mask = 0x80, 1238 }, 1239 .drdy_irq = { 1240 .int1 = { 1241 .addr = 0x22, 1242 .mask = 0x10, 1243 }, 1244 .addr_ihl = 0x25, 1245 .mask_ihl = 0x02, 1246 .stat_drdy = { 1247 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 1248 .mask = 0x07, 1249 }, 1250 }, 1251 .sim = { 1252 .addr = 0x23, 1253 .value = BIT(0), 1254 }, 1255 .multi_read_bit = true, 1256 .bootime = 2, 1257 }, 1258 }; 1259 1260 /* Default accel DRDY is available on INT1 pin */ 1261 static const struct st_sensors_platform_data default_accel_pdata = { 1262 .drdy_int_pin = 1, 1263 }; 1264 1265 static int st_accel_read_raw(struct iio_dev *indio_dev, 1266 struct iio_chan_spec const *ch, int *val, 1267 int *val2, long mask) 1268 { 1269 int err; 1270 struct st_sensor_data *adata = iio_priv(indio_dev); 1271 1272 switch (mask) { 1273 case IIO_CHAN_INFO_RAW: 1274 err = st_sensors_read_info_raw(indio_dev, ch, val); 1275 if (err < 0) 1276 goto read_error; 1277 1278 return IIO_VAL_INT; 1279 case IIO_CHAN_INFO_SCALE: 1280 *val = adata->current_fullscale->gain / 1000000; 1281 *val2 = adata->current_fullscale->gain % 1000000; 1282 return IIO_VAL_INT_PLUS_MICRO; 1283 case IIO_CHAN_INFO_SAMP_FREQ: 1284 *val = adata->odr; 1285 return IIO_VAL_INT; 1286 default: 1287 return -EINVAL; 1288 } 1289 1290 read_error: 1291 return err; 1292 } 1293 1294 static int st_accel_write_raw(struct iio_dev *indio_dev, 1295 struct iio_chan_spec const *chan, int val, int val2, long mask) 1296 { 1297 switch (mask) { 1298 case IIO_CHAN_INFO_SCALE: { 1299 int gain; 1300 1301 gain = val * 1000000 + val2; 1302 return st_sensors_set_fullscale_by_gain(indio_dev, gain); 1303 } 1304 case IIO_CHAN_INFO_SAMP_FREQ: 1305 if (val2) 1306 return -EINVAL; 1307 1308 return st_sensors_set_odr(indio_dev, val); 1309 default: 1310 return -EINVAL; 1311 } 1312 } 1313 1314 static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL(); 1315 static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_accel_scale_available); 1316 1317 static struct attribute *st_accel_attributes[] = { 1318 &iio_dev_attr_sampling_frequency_available.dev_attr.attr, 1319 &iio_dev_attr_in_accel_scale_available.dev_attr.attr, 1320 NULL, 1321 }; 1322 1323 static const struct attribute_group st_accel_attribute_group = { 1324 .attrs = st_accel_attributes, 1325 }; 1326 1327 static const struct iio_info accel_info = { 1328 .attrs = &st_accel_attribute_group, 1329 .read_raw = &st_accel_read_raw, 1330 .write_raw = &st_accel_write_raw, 1331 .debugfs_reg_access = &st_sensors_debugfs_reg_access, 1332 }; 1333 1334 #ifdef CONFIG_IIO_TRIGGER 1335 static const struct iio_trigger_ops st_accel_trigger_ops = { 1336 .set_trigger_state = ST_ACCEL_TRIGGER_SET_STATE, 1337 .validate_device = st_sensors_validate_device, 1338 }; 1339 #define ST_ACCEL_TRIGGER_OPS (&st_accel_trigger_ops) 1340 #else 1341 #define ST_ACCEL_TRIGGER_OPS NULL 1342 #endif 1343 1344 #ifdef CONFIG_ACPI 1345 /* Read ST-specific _ONT orientation data from ACPI and generate an 1346 * appropriate mount matrix. 1347 */ 1348 static int apply_acpi_orientation(struct iio_dev *indio_dev) 1349 { 1350 struct st_sensor_data *adata = iio_priv(indio_dev); 1351 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; 1352 struct acpi_device *adev; 1353 union acpi_object *ont; 1354 union acpi_object *elements; 1355 acpi_status status; 1356 int ret = -EINVAL; 1357 unsigned int val; 1358 int i, j; 1359 int final_ont[3][3] = { { 0 }, }; 1360 1361 /* For some reason, ST's _ONT translation does not apply directly 1362 * to the data read from the sensor. Another translation must be 1363 * performed first, as described by the matrix below. Perhaps 1364 * ST required this specific translation for the first product 1365 * where the device was mounted? 1366 */ 1367 const int default_ont[3][3] = { 1368 { 0, 1, 0 }, 1369 { -1, 0, 0 }, 1370 { 0, 0, -1 }, 1371 }; 1372 1373 1374 adev = ACPI_COMPANION(indio_dev->dev.parent); 1375 if (!adev) 1376 return -ENXIO; 1377 1378 /* Read _ONT data, which should be a package of 6 integers. */ 1379 status = acpi_evaluate_object(adev->handle, "_ONT", NULL, &buffer); 1380 if (status == AE_NOT_FOUND) { 1381 return -ENXIO; 1382 } else if (ACPI_FAILURE(status)) { 1383 dev_warn(&indio_dev->dev, "failed to execute _ONT: %d\n", 1384 status); 1385 return status; 1386 } 1387 1388 ont = buffer.pointer; 1389 if (ont->type != ACPI_TYPE_PACKAGE || ont->package.count != 6) 1390 goto out; 1391 1392 /* The first 3 integers provide axis order information. 1393 * e.g. 0 1 2 would indicate normal X,Y,Z ordering. 1394 * e.g. 1 0 2 indicates that data arrives in order Y,X,Z. 1395 */ 1396 elements = ont->package.elements; 1397 for (i = 0; i < 3; i++) { 1398 if (elements[i].type != ACPI_TYPE_INTEGER) 1399 goto out; 1400 1401 val = elements[i].integer.value; 1402 if (val > 2) 1403 goto out; 1404 1405 /* Avoiding full matrix multiplication, we simply reorder the 1406 * columns in the default_ont matrix according to the 1407 * ordering provided by _ONT. 1408 */ 1409 final_ont[0][i] = default_ont[0][val]; 1410 final_ont[1][i] = default_ont[1][val]; 1411 final_ont[2][i] = default_ont[2][val]; 1412 } 1413 1414 /* The final 3 integers provide sign flip information. 1415 * 0 means no change, 1 means flip. 1416 * e.g. 0 0 1 means that Z data should be sign-flipped. 1417 * This is applied after the axis reordering from above. 1418 */ 1419 elements += 3; 1420 for (i = 0; i < 3; i++) { 1421 if (elements[i].type != ACPI_TYPE_INTEGER) 1422 goto out; 1423 1424 val = elements[i].integer.value; 1425 if (val != 0 && val != 1) 1426 goto out; 1427 if (!val) 1428 continue; 1429 1430 /* Flip the values in the indicated column */ 1431 final_ont[0][i] *= -1; 1432 final_ont[1][i] *= -1; 1433 final_ont[2][i] *= -1; 1434 } 1435 1436 /* Convert our integer matrix to a string-based iio_mount_matrix */ 1437 for (i = 0; i < 3; i++) { 1438 for (j = 0; j < 3; j++) { 1439 int matrix_val = final_ont[i][j]; 1440 char *str_value; 1441 1442 switch (matrix_val) { 1443 case -1: 1444 str_value = "-1"; 1445 break; 1446 case 0: 1447 str_value = "0"; 1448 break; 1449 case 1: 1450 str_value = "1"; 1451 break; 1452 default: 1453 goto out; 1454 } 1455 adata->mount_matrix.rotation[i * 3 + j] = str_value; 1456 } 1457 } 1458 1459 ret = 0; 1460 dev_info(&indio_dev->dev, "computed mount matrix from ACPI\n"); 1461 1462 out: 1463 kfree(buffer.pointer); 1464 if (ret) 1465 dev_dbg(&indio_dev->dev, 1466 "failed to apply ACPI orientation data: %d\n", ret); 1467 1468 return ret; 1469 } 1470 #else /* !CONFIG_ACPI */ 1471 static int apply_acpi_orientation(struct iio_dev *indio_dev) 1472 { 1473 return -EINVAL; 1474 } 1475 #endif 1476 1477 /* 1478 * st_accel_get_settings() - get sensor settings from device name 1479 * @name: device name buffer reference. 1480 * 1481 * Return: valid reference on success, NULL otherwise. 1482 */ 1483 const struct st_sensor_settings *st_accel_get_settings(const char *name) 1484 { 1485 int index = st_sensors_get_settings_index(name, 1486 st_accel_sensors_settings, 1487 ARRAY_SIZE(st_accel_sensors_settings)); 1488 if (index < 0) 1489 return NULL; 1490 1491 return &st_accel_sensors_settings[index]; 1492 } 1493 EXPORT_SYMBOL_NS(st_accel_get_settings, IIO_ST_SENSORS); 1494 1495 int st_accel_common_probe(struct iio_dev *indio_dev) 1496 { 1497 struct st_sensor_data *adata = iio_priv(indio_dev); 1498 struct device *parent = indio_dev->dev.parent; 1499 struct st_sensors_platform_data *pdata = dev_get_platdata(parent); 1500 int err; 1501 1502 indio_dev->modes = INDIO_DIRECT_MODE; 1503 indio_dev->info = &accel_info; 1504 1505 err = st_sensors_verify_id(indio_dev); 1506 if (err < 0) 1507 return err; 1508 1509 adata->num_data_channels = ST_ACCEL_NUMBER_DATA_CHANNELS; 1510 indio_dev->channels = adata->sensor_settings->ch; 1511 indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS; 1512 1513 /* 1514 * First try specific ACPI methods to retrieve orientation then try the 1515 * generic function. 1516 */ 1517 err = apply_acpi_orientation(indio_dev); 1518 if (err) { 1519 err = iio_read_mount_matrix(parent, &adata->mount_matrix); 1520 if (err) 1521 return err; 1522 } 1523 1524 adata->current_fullscale = &adata->sensor_settings->fs.fs_avl[0]; 1525 adata->odr = adata->sensor_settings->odr.odr_avl[0].hz; 1526 1527 if (!pdata) 1528 pdata = (struct st_sensors_platform_data *)&default_accel_pdata; 1529 1530 err = st_sensors_init_sensor(indio_dev, pdata); 1531 if (err < 0) 1532 return err; 1533 1534 err = st_accel_allocate_ring(indio_dev); 1535 if (err < 0) 1536 return err; 1537 1538 if (adata->irq > 0) { 1539 err = st_sensors_allocate_trigger(indio_dev, 1540 ST_ACCEL_TRIGGER_OPS); 1541 if (err < 0) 1542 return err; 1543 } 1544 1545 return devm_iio_device_register(parent, indio_dev); 1546 } 1547 EXPORT_SYMBOL_NS(st_accel_common_probe, IIO_ST_SENSORS); 1548 1549 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>"); 1550 MODULE_DESCRIPTION("STMicroelectronics accelerometers driver"); 1551 MODULE_LICENSE("GPL v2"); 1552 MODULE_IMPORT_NS(IIO_ST_SENSORS); 1553