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/slab.h> 13 #include <linux/acpi.h> 14 #include <linux/errno.h> 15 #include <linux/types.h> 16 #include <linux/interrupt.h> 17 #include <linux/i2c.h> 18 #include <linux/irq.h> 19 #include <linux/iio/iio.h> 20 #include <linux/iio/sysfs.h> 21 #include <linux/iio/trigger.h> 22 #include <linux/iio/buffer.h> 23 24 #include <linux/iio/common/st_sensors.h> 25 #include "st_accel.h" 26 27 #define ST_ACCEL_NUMBER_DATA_CHANNELS 3 28 29 /* DEFAULT VALUE FOR SENSORS */ 30 #define ST_ACCEL_DEFAULT_OUT_X_L_ADDR 0x28 31 #define ST_ACCEL_DEFAULT_OUT_Y_L_ADDR 0x2a 32 #define ST_ACCEL_DEFAULT_OUT_Z_L_ADDR 0x2c 33 34 /* FULLSCALE */ 35 #define ST_ACCEL_FS_AVL_2G 2 36 #define ST_ACCEL_FS_AVL_4G 4 37 #define ST_ACCEL_FS_AVL_6G 6 38 #define ST_ACCEL_FS_AVL_8G 8 39 #define ST_ACCEL_FS_AVL_16G 16 40 #define ST_ACCEL_FS_AVL_100G 100 41 #define ST_ACCEL_FS_AVL_200G 200 42 #define ST_ACCEL_FS_AVL_400G 400 43 44 static const struct iio_chan_spec st_accel_8bit_channels[] = { 45 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 46 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 47 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 8, 8, 48 ST_ACCEL_DEFAULT_OUT_X_L_ADDR+1), 49 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 50 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 51 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 8, 8, 52 ST_ACCEL_DEFAULT_OUT_Y_L_ADDR+1), 53 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 54 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 55 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 8, 8, 56 ST_ACCEL_DEFAULT_OUT_Z_L_ADDR+1), 57 IIO_CHAN_SOFT_TIMESTAMP(3) 58 }; 59 60 static const struct iio_chan_spec st_accel_12bit_channels[] = { 61 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 62 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 63 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 12, 16, 64 ST_ACCEL_DEFAULT_OUT_X_L_ADDR), 65 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 66 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 67 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 12, 16, 68 ST_ACCEL_DEFAULT_OUT_Y_L_ADDR), 69 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 70 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 71 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 12, 16, 72 ST_ACCEL_DEFAULT_OUT_Z_L_ADDR), 73 IIO_CHAN_SOFT_TIMESTAMP(3) 74 }; 75 76 static const struct iio_chan_spec st_accel_16bit_channels[] = { 77 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 78 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 79 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16, 80 ST_ACCEL_DEFAULT_OUT_X_L_ADDR), 81 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 82 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 83 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16, 84 ST_ACCEL_DEFAULT_OUT_Y_L_ADDR), 85 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 86 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 87 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16, 88 ST_ACCEL_DEFAULT_OUT_Z_L_ADDR), 89 IIO_CHAN_SOFT_TIMESTAMP(3) 90 }; 91 92 static const struct st_sensor_settings st_accel_sensors_settings[] = { 93 { 94 .wai = 0x33, 95 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 96 .sensors_supported = { 97 [0] = LIS3DH_ACCEL_DEV_NAME, 98 [1] = LSM303DLHC_ACCEL_DEV_NAME, 99 [2] = LSM330D_ACCEL_DEV_NAME, 100 [3] = LSM330DL_ACCEL_DEV_NAME, 101 [4] = LSM330DLC_ACCEL_DEV_NAME, 102 [5] = LSM303AGR_ACCEL_DEV_NAME, 103 [6] = LIS2DH12_ACCEL_DEV_NAME, 104 [7] = LIS3DE_ACCEL_DEV_NAME, 105 }, 106 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 107 .odr = { 108 .addr = 0x20, 109 .mask = 0xf0, 110 .odr_avl = { 111 { .hz = 1, .value = 0x01, }, 112 { .hz = 10, .value = 0x02, }, 113 { .hz = 25, .value = 0x03, }, 114 { .hz = 50, .value = 0x04, }, 115 { .hz = 100, .value = 0x05, }, 116 { .hz = 200, .value = 0x06, }, 117 { .hz = 400, .value = 0x07, }, 118 { .hz = 1600, .value = 0x08, }, 119 }, 120 }, 121 .pw = { 122 .addr = 0x20, 123 .mask = 0xf0, 124 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 125 }, 126 .enable_axis = { 127 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 128 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 129 }, 130 .fs = { 131 .addr = 0x23, 132 .mask = 0x30, 133 .fs_avl = { 134 [0] = { 135 .num = ST_ACCEL_FS_AVL_2G, 136 .value = 0x00, 137 .gain = IIO_G_TO_M_S_2(1000), 138 }, 139 [1] = { 140 .num = ST_ACCEL_FS_AVL_4G, 141 .value = 0x01, 142 .gain = IIO_G_TO_M_S_2(2000), 143 }, 144 [2] = { 145 .num = ST_ACCEL_FS_AVL_8G, 146 .value = 0x02, 147 .gain = IIO_G_TO_M_S_2(4000), 148 }, 149 [3] = { 150 .num = ST_ACCEL_FS_AVL_16G, 151 .value = 0x03, 152 .gain = IIO_G_TO_M_S_2(12000), 153 }, 154 }, 155 }, 156 .bdu = { 157 .addr = 0x23, 158 .mask = 0x80, 159 }, 160 .drdy_irq = { 161 .int1 = { 162 .addr = 0x22, 163 .mask = 0x10, 164 }, 165 .addr_ihl = 0x25, 166 .mask_ihl = 0x02, 167 .stat_drdy = { 168 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 169 .mask = 0x07, 170 }, 171 }, 172 .sim = { 173 .addr = 0x23, 174 .value = BIT(0), 175 }, 176 .multi_read_bit = true, 177 .bootime = 2, 178 }, 179 { 180 .wai = 0x32, 181 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 182 .sensors_supported = { 183 [0] = LIS331DLH_ACCEL_DEV_NAME, 184 [1] = LSM303DL_ACCEL_DEV_NAME, 185 [2] = LSM303DLH_ACCEL_DEV_NAME, 186 [3] = LSM303DLM_ACCEL_DEV_NAME, 187 }, 188 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 189 .odr = { 190 .addr = 0x20, 191 .mask = 0x18, 192 .odr_avl = { 193 { .hz = 50, .value = 0x00, }, 194 { .hz = 100, .value = 0x01, }, 195 { .hz = 400, .value = 0x02, }, 196 { .hz = 1000, .value = 0x03, }, 197 }, 198 }, 199 .pw = { 200 .addr = 0x20, 201 .mask = 0xe0, 202 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 203 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 204 }, 205 .enable_axis = { 206 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 207 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 208 }, 209 .fs = { 210 .addr = 0x23, 211 .mask = 0x30, 212 .fs_avl = { 213 [0] = { 214 .num = ST_ACCEL_FS_AVL_2G, 215 .value = 0x00, 216 .gain = IIO_G_TO_M_S_2(1000), 217 }, 218 [1] = { 219 .num = ST_ACCEL_FS_AVL_4G, 220 .value = 0x01, 221 .gain = IIO_G_TO_M_S_2(2000), 222 }, 223 [2] = { 224 .num = ST_ACCEL_FS_AVL_8G, 225 .value = 0x03, 226 .gain = IIO_G_TO_M_S_2(3900), 227 }, 228 }, 229 }, 230 .bdu = { 231 .addr = 0x23, 232 .mask = 0x80, 233 }, 234 .drdy_irq = { 235 .int1 = { 236 .addr = 0x22, 237 .mask = 0x02, 238 .addr_od = 0x22, 239 .mask_od = 0x40, 240 }, 241 .int2 = { 242 .addr = 0x22, 243 .mask = 0x10, 244 .addr_od = 0x22, 245 .mask_od = 0x40, 246 }, 247 .addr_ihl = 0x22, 248 .mask_ihl = 0x80, 249 .stat_drdy = { 250 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 251 .mask = 0x07, 252 }, 253 }, 254 .sim = { 255 .addr = 0x23, 256 .value = BIT(0), 257 }, 258 .multi_read_bit = true, 259 .bootime = 2, 260 }, 261 { 262 .wai = 0x40, 263 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 264 .sensors_supported = { 265 [0] = LSM330_ACCEL_DEV_NAME, 266 }, 267 .ch = (struct iio_chan_spec *)st_accel_16bit_channels, 268 .odr = { 269 .addr = 0x20, 270 .mask = 0xf0, 271 .odr_avl = { 272 { .hz = 3, .value = 0x01, }, 273 { .hz = 6, .value = 0x02, }, 274 { .hz = 12, .value = 0x03, }, 275 { .hz = 25, .value = 0x04, }, 276 { .hz = 50, .value = 0x05, }, 277 { .hz = 100, .value = 0x06, }, 278 { .hz = 200, .value = 0x07, }, 279 { .hz = 400, .value = 0x08, }, 280 { .hz = 800, .value = 0x09, }, 281 { .hz = 1600, .value = 0x0a, }, 282 }, 283 }, 284 .pw = { 285 .addr = 0x20, 286 .mask = 0xf0, 287 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 288 }, 289 .enable_axis = { 290 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 291 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 292 }, 293 .fs = { 294 .addr = 0x24, 295 .mask = 0x38, 296 .fs_avl = { 297 [0] = { 298 .num = ST_ACCEL_FS_AVL_2G, 299 .value = 0x00, 300 .gain = IIO_G_TO_M_S_2(61), 301 }, 302 [1] = { 303 .num = ST_ACCEL_FS_AVL_4G, 304 .value = 0x01, 305 .gain = IIO_G_TO_M_S_2(122), 306 }, 307 [2] = { 308 .num = ST_ACCEL_FS_AVL_6G, 309 .value = 0x02, 310 .gain = IIO_G_TO_M_S_2(183), 311 }, 312 [3] = { 313 .num = ST_ACCEL_FS_AVL_8G, 314 .value = 0x03, 315 .gain = IIO_G_TO_M_S_2(244), 316 }, 317 [4] = { 318 .num = ST_ACCEL_FS_AVL_16G, 319 .value = 0x04, 320 .gain = IIO_G_TO_M_S_2(732), 321 }, 322 }, 323 }, 324 .bdu = { 325 .addr = 0x20, 326 .mask = 0x08, 327 }, 328 .drdy_irq = { 329 .int1 = { 330 .addr = 0x23, 331 .mask = 0x80, 332 }, 333 .addr_ihl = 0x23, 334 .mask_ihl = 0x40, 335 .stat_drdy = { 336 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 337 .mask = 0x07, 338 }, 339 .ig1 = { 340 .en_addr = 0x23, 341 .en_mask = 0x08, 342 }, 343 }, 344 .sim = { 345 .addr = 0x24, 346 .value = BIT(0), 347 }, 348 .multi_read_bit = false, 349 .bootime = 2, 350 }, 351 { 352 .wai = 0x3a, 353 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 354 .sensors_supported = { 355 [0] = LIS3LV02DL_ACCEL_DEV_NAME, 356 }, 357 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 358 .odr = { 359 .addr = 0x20, 360 .mask = 0x30, /* DF1 and DF0 */ 361 .odr_avl = { 362 { .hz = 40, .value = 0x00, }, 363 { .hz = 160, .value = 0x01, }, 364 { .hz = 640, .value = 0x02, }, 365 { .hz = 2560, .value = 0x03, }, 366 }, 367 }, 368 .pw = { 369 .addr = 0x20, 370 .mask = 0xc0, 371 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 372 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 373 }, 374 .enable_axis = { 375 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 376 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 377 }, 378 .fs = { 379 .addr = 0x21, 380 .mask = 0x80, 381 .fs_avl = { 382 [0] = { 383 .num = ST_ACCEL_FS_AVL_2G, 384 .value = 0x00, 385 .gain = IIO_G_TO_M_S_2(1000), 386 }, 387 [1] = { 388 .num = ST_ACCEL_FS_AVL_6G, 389 .value = 0x01, 390 .gain = IIO_G_TO_M_S_2(3000), 391 }, 392 }, 393 }, 394 .bdu = { 395 .addr = 0x21, 396 .mask = 0x40, 397 }, 398 /* 399 * Data Alignment Setting - needs to be set to get 400 * left-justified data like all other sensors. 401 */ 402 .das = { 403 .addr = 0x21, 404 .mask = 0x01, 405 }, 406 .drdy_irq = { 407 .int1 = { 408 .addr = 0x21, 409 .mask = 0x04, 410 }, 411 .stat_drdy = { 412 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 413 .mask = 0x07, 414 }, 415 }, 416 .sim = { 417 .addr = 0x21, 418 .value = BIT(1), 419 }, 420 .multi_read_bit = true, 421 .bootime = 2, /* guess */ 422 }, 423 { 424 .wai = 0x3b, 425 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 426 .sensors_supported = { 427 [0] = LIS331DL_ACCEL_DEV_NAME, 428 }, 429 .ch = (struct iio_chan_spec *)st_accel_8bit_channels, 430 .odr = { 431 .addr = 0x20, 432 .mask = 0x80, 433 .odr_avl = { 434 { .hz = 100, .value = 0x00, }, 435 { .hz = 400, .value = 0x01, }, 436 }, 437 }, 438 .pw = { 439 .addr = 0x20, 440 .mask = 0x40, 441 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 442 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 443 }, 444 .enable_axis = { 445 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 446 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 447 }, 448 .fs = { 449 .addr = 0x20, 450 .mask = 0x20, 451 /* 452 * TODO: check these resulting gain settings, these are 453 * not in the datsheet 454 */ 455 .fs_avl = { 456 [0] = { 457 .num = ST_ACCEL_FS_AVL_2G, 458 .value = 0x00, 459 .gain = IIO_G_TO_M_S_2(18000), 460 }, 461 [1] = { 462 .num = ST_ACCEL_FS_AVL_8G, 463 .value = 0x01, 464 .gain = IIO_G_TO_M_S_2(72000), 465 }, 466 }, 467 }, 468 .drdy_irq = { 469 .int1 = { 470 .addr = 0x22, 471 .mask = 0x04, 472 .addr_od = 0x22, 473 .mask_od = 0x40, 474 }, 475 .int2 = { 476 .addr = 0x22, 477 .mask = 0x20, 478 .addr_od = 0x22, 479 .mask_od = 0x40, 480 }, 481 .addr_ihl = 0x22, 482 .mask_ihl = 0x80, 483 .stat_drdy = { 484 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 485 .mask = 0x07, 486 }, 487 }, 488 .sim = { 489 .addr = 0x21, 490 .value = BIT(7), 491 }, 492 .multi_read_bit = false, 493 .bootime = 2, /* guess */ 494 }, 495 { 496 .wai = 0x32, 497 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 498 .sensors_supported = { 499 [0] = H3LIS331DL_ACCEL_DEV_NAME, 500 }, 501 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 502 .odr = { 503 .addr = 0x20, 504 .mask = 0x18, 505 .odr_avl = { 506 { .hz = 50, .value = 0x00, }, 507 { .hz = 100, .value = 0x01, }, 508 { .hz = 400, .value = 0x02, }, 509 { .hz = 1000, .value = 0x03, }, 510 }, 511 }, 512 .pw = { 513 .addr = 0x20, 514 .mask = 0x20, 515 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 516 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 517 }, 518 .enable_axis = { 519 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 520 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 521 }, 522 .fs = { 523 .addr = 0x23, 524 .mask = 0x30, 525 .fs_avl = { 526 [0] = { 527 .num = ST_ACCEL_FS_AVL_100G, 528 .value = 0x00, 529 .gain = IIO_G_TO_M_S_2(49000), 530 }, 531 [1] = { 532 .num = ST_ACCEL_FS_AVL_200G, 533 .value = 0x01, 534 .gain = IIO_G_TO_M_S_2(98000), 535 }, 536 [2] = { 537 .num = ST_ACCEL_FS_AVL_400G, 538 .value = 0x03, 539 .gain = IIO_G_TO_M_S_2(195000), 540 }, 541 }, 542 }, 543 .bdu = { 544 .addr = 0x23, 545 .mask = 0x80, 546 }, 547 .drdy_irq = { 548 .int1 = { 549 .addr = 0x22, 550 .mask = 0x02, 551 }, 552 .int2 = { 553 .addr = 0x22, 554 .mask = 0x10, 555 }, 556 .addr_ihl = 0x22, 557 .mask_ihl = 0x80, 558 }, 559 .sim = { 560 .addr = 0x23, 561 .value = BIT(0), 562 }, 563 .multi_read_bit = true, 564 .bootime = 2, 565 }, 566 { 567 /* No WAI register present */ 568 .sensors_supported = { 569 [0] = LIS3L02DQ_ACCEL_DEV_NAME, 570 }, 571 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 572 .odr = { 573 .addr = 0x20, 574 .mask = 0x30, 575 .odr_avl = { 576 { .hz = 280, .value = 0x00, }, 577 { .hz = 560, .value = 0x01, }, 578 { .hz = 1120, .value = 0x02, }, 579 { .hz = 4480, .value = 0x03, }, 580 }, 581 }, 582 .pw = { 583 .addr = 0x20, 584 .mask = 0xc0, 585 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 586 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 587 }, 588 .enable_axis = { 589 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 590 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 591 }, 592 .fs = { 593 .fs_avl = { 594 [0] = { 595 .num = ST_ACCEL_FS_AVL_2G, 596 .gain = IIO_G_TO_M_S_2(488), 597 }, 598 }, 599 }, 600 /* 601 * The part has a BDU bit but if set the data is never 602 * updated so don't set it. 603 */ 604 .bdu = { 605 }, 606 .drdy_irq = { 607 .int1 = { 608 .addr = 0x21, 609 .mask = 0x04, 610 }, 611 .stat_drdy = { 612 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 613 .mask = 0x07, 614 }, 615 }, 616 .sim = { 617 .addr = 0x21, 618 .value = BIT(1), 619 }, 620 .multi_read_bit = false, 621 .bootime = 2, 622 }, 623 { 624 .wai = 0x33, 625 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 626 .sensors_supported = { 627 [0] = LNG2DM_ACCEL_DEV_NAME, 628 }, 629 .ch = (struct iio_chan_spec *)st_accel_8bit_channels, 630 .odr = { 631 .addr = 0x20, 632 .mask = 0xf0, 633 .odr_avl = { 634 { .hz = 1, .value = 0x01, }, 635 { .hz = 10, .value = 0x02, }, 636 { .hz = 25, .value = 0x03, }, 637 { .hz = 50, .value = 0x04, }, 638 { .hz = 100, .value = 0x05, }, 639 { .hz = 200, .value = 0x06, }, 640 { .hz = 400, .value = 0x07, }, 641 { .hz = 1600, .value = 0x08, }, 642 }, 643 }, 644 .pw = { 645 .addr = 0x20, 646 .mask = 0xf0, 647 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 648 }, 649 .enable_axis = { 650 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 651 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 652 }, 653 .fs = { 654 .addr = 0x23, 655 .mask = 0x30, 656 .fs_avl = { 657 [0] = { 658 .num = ST_ACCEL_FS_AVL_2G, 659 .value = 0x00, 660 .gain = IIO_G_TO_M_S_2(15600), 661 }, 662 [1] = { 663 .num = ST_ACCEL_FS_AVL_4G, 664 .value = 0x01, 665 .gain = IIO_G_TO_M_S_2(31200), 666 }, 667 [2] = { 668 .num = ST_ACCEL_FS_AVL_8G, 669 .value = 0x02, 670 .gain = IIO_G_TO_M_S_2(62500), 671 }, 672 [3] = { 673 .num = ST_ACCEL_FS_AVL_16G, 674 .value = 0x03, 675 .gain = IIO_G_TO_M_S_2(187500), 676 }, 677 }, 678 }, 679 .drdy_irq = { 680 .int1 = { 681 .addr = 0x22, 682 .mask = 0x10, 683 }, 684 .addr_ihl = 0x25, 685 .mask_ihl = 0x02, 686 .stat_drdy = { 687 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 688 .mask = 0x07, 689 }, 690 }, 691 .sim = { 692 .addr = 0x23, 693 .value = BIT(0), 694 }, 695 .multi_read_bit = true, 696 .bootime = 2, 697 }, 698 { 699 .wai = 0x44, 700 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 701 .sensors_supported = { 702 [0] = LIS2DW12_ACCEL_DEV_NAME, 703 }, 704 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 705 .odr = { 706 .addr = 0x20, 707 .mask = 0xf0, 708 .odr_avl = { 709 { .hz = 1, .value = 0x01, }, 710 { .hz = 12, .value = 0x02, }, 711 { .hz = 25, .value = 0x03, }, 712 { .hz = 50, .value = 0x04, }, 713 { .hz = 100, .value = 0x05, }, 714 { .hz = 200, .value = 0x06, }, 715 }, 716 }, 717 .pw = { 718 .addr = 0x20, 719 .mask = 0xf0, 720 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 721 }, 722 .fs = { 723 .addr = 0x25, 724 .mask = 0x30, 725 .fs_avl = { 726 [0] = { 727 .num = ST_ACCEL_FS_AVL_2G, 728 .value = 0x00, 729 .gain = IIO_G_TO_M_S_2(976), 730 }, 731 [1] = { 732 .num = ST_ACCEL_FS_AVL_4G, 733 .value = 0x01, 734 .gain = IIO_G_TO_M_S_2(1952), 735 }, 736 [2] = { 737 .num = ST_ACCEL_FS_AVL_8G, 738 .value = 0x02, 739 .gain = IIO_G_TO_M_S_2(3904), 740 }, 741 [3] = { 742 .num = ST_ACCEL_FS_AVL_16G, 743 .value = 0x03, 744 .gain = IIO_G_TO_M_S_2(7808), 745 }, 746 }, 747 }, 748 .bdu = { 749 .addr = 0x21, 750 .mask = 0x08, 751 }, 752 .drdy_irq = { 753 .int1 = { 754 .addr = 0x23, 755 .mask = 0x01, 756 .addr_od = 0x22, 757 .mask_od = 0x20, 758 }, 759 .int2 = { 760 .addr = 0x24, 761 .mask = 0x01, 762 .addr_od = 0x22, 763 .mask_od = 0x20, 764 }, 765 .addr_ihl = 0x22, 766 .mask_ihl = 0x08, 767 .stat_drdy = { 768 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 769 .mask = 0x01, 770 }, 771 }, 772 .sim = { 773 .addr = 0x21, 774 .value = BIT(0), 775 }, 776 .multi_read_bit = false, 777 .bootime = 2, 778 }, 779 { 780 .wai = 0x11, 781 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 782 .sensors_supported = { 783 [0] = LIS3DHH_ACCEL_DEV_NAME, 784 }, 785 .ch = (struct iio_chan_spec *)st_accel_16bit_channels, 786 .odr = { 787 /* just ODR = 1100Hz available */ 788 .odr_avl = { 789 { .hz = 1100, .value = 0x00, }, 790 }, 791 }, 792 .pw = { 793 .addr = 0x20, 794 .mask = 0x80, 795 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 796 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 797 }, 798 .fs = { 799 .fs_avl = { 800 [0] = { 801 .num = ST_ACCEL_FS_AVL_2G, 802 .gain = IIO_G_TO_M_S_2(76), 803 }, 804 }, 805 }, 806 .bdu = { 807 .addr = 0x20, 808 .mask = 0x01, 809 }, 810 .drdy_irq = { 811 .int1 = { 812 .addr = 0x21, 813 .mask = 0x80, 814 .addr_od = 0x23, 815 .mask_od = 0x04, 816 }, 817 .int2 = { 818 .addr = 0x22, 819 .mask = 0x80, 820 .addr_od = 0x23, 821 .mask_od = 0x08, 822 }, 823 .stat_drdy = { 824 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 825 .mask = 0x07, 826 }, 827 }, 828 .multi_read_bit = false, 829 .bootime = 2, 830 }, 831 { 832 .wai = 0x33, 833 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 834 .sensors_supported = { 835 [0] = LIS2DE12_ACCEL_DEV_NAME, 836 }, 837 .ch = (struct iio_chan_spec *)st_accel_8bit_channels, 838 .odr = { 839 .addr = 0x20, 840 .mask = 0xf0, 841 .odr_avl = { 842 { .hz = 1, .value = 0x01, }, 843 { .hz = 10, .value = 0x02, }, 844 { .hz = 25, .value = 0x03, }, 845 { .hz = 50, .value = 0x04, }, 846 { .hz = 100, .value = 0x05, }, 847 { .hz = 200, .value = 0x06, }, 848 { .hz = 400, .value = 0x07, }, 849 { .hz = 1620, .value = 0x08, }, 850 { .hz = 5376, .value = 0x09, }, 851 }, 852 }, 853 .pw = { 854 .addr = 0x20, 855 .mask = 0xf0, 856 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 857 }, 858 .enable_axis = { 859 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 860 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 861 }, 862 .fs = { 863 .addr = 0x23, 864 .mask = 0x30, 865 .fs_avl = { 866 [0] = { 867 .num = ST_ACCEL_FS_AVL_2G, 868 .value = 0x00, 869 .gain = IIO_G_TO_M_S_2(15600), 870 }, 871 [1] = { 872 .num = ST_ACCEL_FS_AVL_4G, 873 .value = 0x01, 874 .gain = IIO_G_TO_M_S_2(31200), 875 }, 876 [2] = { 877 .num = ST_ACCEL_FS_AVL_8G, 878 .value = 0x02, 879 .gain = IIO_G_TO_M_S_2(62500), 880 }, 881 [3] = { 882 .num = ST_ACCEL_FS_AVL_16G, 883 .value = 0x03, 884 .gain = IIO_G_TO_M_S_2(187500), 885 }, 886 }, 887 }, 888 .drdy_irq = { 889 .int1 = { 890 .addr = 0x22, 891 .mask = 0x10, 892 }, 893 .addr_ihl = 0x25, 894 .mask_ihl = 0x02, 895 .stat_drdy = { 896 .addr = ST_SENSORS_DEFAULT_STAT_ADDR, 897 .mask = 0x07, 898 }, 899 }, 900 .sim = { 901 .addr = 0x23, 902 .value = BIT(0), 903 }, 904 .multi_read_bit = true, 905 .bootime = 2, 906 }, 907 }; 908 909 static int st_accel_read_raw(struct iio_dev *indio_dev, 910 struct iio_chan_spec const *ch, int *val, 911 int *val2, long mask) 912 { 913 int err; 914 struct st_sensor_data *adata = iio_priv(indio_dev); 915 916 switch (mask) { 917 case IIO_CHAN_INFO_RAW: 918 err = st_sensors_read_info_raw(indio_dev, ch, val); 919 if (err < 0) 920 goto read_error; 921 922 return IIO_VAL_INT; 923 case IIO_CHAN_INFO_SCALE: 924 *val = adata->current_fullscale->gain / 1000000; 925 *val2 = adata->current_fullscale->gain % 1000000; 926 return IIO_VAL_INT_PLUS_MICRO; 927 case IIO_CHAN_INFO_SAMP_FREQ: 928 *val = adata->odr; 929 return IIO_VAL_INT; 930 default: 931 return -EINVAL; 932 } 933 934 read_error: 935 return err; 936 } 937 938 static int st_accel_write_raw(struct iio_dev *indio_dev, 939 struct iio_chan_spec const *chan, int val, int val2, long mask) 940 { 941 int err; 942 943 switch (mask) { 944 case IIO_CHAN_INFO_SCALE: { 945 int gain; 946 947 gain = val * 1000000 + val2; 948 err = st_sensors_set_fullscale_by_gain(indio_dev, gain); 949 break; 950 } 951 case IIO_CHAN_INFO_SAMP_FREQ: 952 if (val2) 953 return -EINVAL; 954 mutex_lock(&indio_dev->mlock); 955 err = st_sensors_set_odr(indio_dev, val); 956 mutex_unlock(&indio_dev->mlock); 957 return err; 958 default: 959 return -EINVAL; 960 } 961 962 return err; 963 } 964 965 static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL(); 966 static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_accel_scale_available); 967 968 static struct attribute *st_accel_attributes[] = { 969 &iio_dev_attr_sampling_frequency_available.dev_attr.attr, 970 &iio_dev_attr_in_accel_scale_available.dev_attr.attr, 971 NULL, 972 }; 973 974 static const struct attribute_group st_accel_attribute_group = { 975 .attrs = st_accel_attributes, 976 }; 977 978 static const struct iio_info accel_info = { 979 .attrs = &st_accel_attribute_group, 980 .read_raw = &st_accel_read_raw, 981 .write_raw = &st_accel_write_raw, 982 .debugfs_reg_access = &st_sensors_debugfs_reg_access, 983 }; 984 985 #ifdef CONFIG_IIO_TRIGGER 986 static const struct iio_trigger_ops st_accel_trigger_ops = { 987 .set_trigger_state = ST_ACCEL_TRIGGER_SET_STATE, 988 .validate_device = st_sensors_validate_device, 989 }; 990 #define ST_ACCEL_TRIGGER_OPS (&st_accel_trigger_ops) 991 #else 992 #define ST_ACCEL_TRIGGER_OPS NULL 993 #endif 994 995 #ifdef CONFIG_ACPI 996 static const struct iio_mount_matrix * 997 get_mount_matrix(const struct iio_dev *indio_dev, 998 const struct iio_chan_spec *chan) 999 { 1000 struct st_sensor_data *adata = iio_priv(indio_dev); 1001 1002 return adata->mount_matrix; 1003 } 1004 1005 static const struct iio_chan_spec_ext_info mount_matrix_ext_info[] = { 1006 IIO_MOUNT_MATRIX(IIO_SHARED_BY_ALL, get_mount_matrix), 1007 { }, 1008 }; 1009 1010 /* Read ST-specific _ONT orientation data from ACPI and generate an 1011 * appropriate mount matrix. 1012 */ 1013 static int apply_acpi_orientation(struct iio_dev *indio_dev, 1014 struct iio_chan_spec *channels) 1015 { 1016 struct st_sensor_data *adata = iio_priv(indio_dev); 1017 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; 1018 struct acpi_device *adev; 1019 union acpi_object *ont; 1020 union acpi_object *elements; 1021 acpi_status status; 1022 int ret = -EINVAL; 1023 unsigned int val; 1024 int i, j; 1025 int final_ont[3][3] = { { 0 }, }; 1026 1027 /* For some reason, ST's _ONT translation does not apply directly 1028 * to the data read from the sensor. Another translation must be 1029 * performed first, as described by the matrix below. Perhaps 1030 * ST required this specific translation for the first product 1031 * where the device was mounted? 1032 */ 1033 const int default_ont[3][3] = { 1034 { 0, 1, 0 }, 1035 { -1, 0, 0 }, 1036 { 0, 0, -1 }, 1037 }; 1038 1039 1040 adev = ACPI_COMPANION(adata->dev); 1041 if (!adev) 1042 return 0; 1043 1044 /* Read _ONT data, which should be a package of 6 integers. */ 1045 status = acpi_evaluate_object(adev->handle, "_ONT", NULL, &buffer); 1046 if (status == AE_NOT_FOUND) { 1047 return 0; 1048 } else if (ACPI_FAILURE(status)) { 1049 dev_warn(&indio_dev->dev, "failed to execute _ONT: %d\n", 1050 status); 1051 return status; 1052 } 1053 1054 ont = buffer.pointer; 1055 if (ont->type != ACPI_TYPE_PACKAGE || ont->package.count != 6) 1056 goto out; 1057 1058 /* The first 3 integers provide axis order information. 1059 * e.g. 0 1 2 would indicate normal X,Y,Z ordering. 1060 * e.g. 1 0 2 indicates that data arrives in order Y,X,Z. 1061 */ 1062 elements = ont->package.elements; 1063 for (i = 0; i < 3; i++) { 1064 if (elements[i].type != ACPI_TYPE_INTEGER) 1065 goto out; 1066 1067 val = elements[i].integer.value; 1068 if (val > 2) 1069 goto out; 1070 1071 /* Avoiding full matrix multiplication, we simply reorder the 1072 * columns in the default_ont matrix according to the 1073 * ordering provided by _ONT. 1074 */ 1075 final_ont[0][i] = default_ont[0][val]; 1076 final_ont[1][i] = default_ont[1][val]; 1077 final_ont[2][i] = default_ont[2][val]; 1078 } 1079 1080 /* The final 3 integers provide sign flip information. 1081 * 0 means no change, 1 means flip. 1082 * e.g. 0 0 1 means that Z data should be sign-flipped. 1083 * This is applied after the axis reordering from above. 1084 */ 1085 elements += 3; 1086 for (i = 0; i < 3; i++) { 1087 if (elements[i].type != ACPI_TYPE_INTEGER) 1088 goto out; 1089 1090 val = elements[i].integer.value; 1091 if (val != 0 && val != 1) 1092 goto out; 1093 if (!val) 1094 continue; 1095 1096 /* Flip the values in the indicated column */ 1097 final_ont[0][i] *= -1; 1098 final_ont[1][i] *= -1; 1099 final_ont[2][i] *= -1; 1100 } 1101 1102 /* Convert our integer matrix to a string-based iio_mount_matrix */ 1103 adata->mount_matrix = devm_kmalloc(&indio_dev->dev, 1104 sizeof(*adata->mount_matrix), 1105 GFP_KERNEL); 1106 if (!adata->mount_matrix) { 1107 ret = -ENOMEM; 1108 goto out; 1109 } 1110 1111 for (i = 0; i < 3; i++) { 1112 for (j = 0; j < 3; j++) { 1113 int matrix_val = final_ont[i][j]; 1114 char *str_value; 1115 1116 switch (matrix_val) { 1117 case -1: 1118 str_value = "-1"; 1119 break; 1120 case 0: 1121 str_value = "0"; 1122 break; 1123 case 1: 1124 str_value = "1"; 1125 break; 1126 default: 1127 goto out; 1128 } 1129 adata->mount_matrix->rotation[i * 3 + j] = str_value; 1130 } 1131 } 1132 1133 /* Expose the mount matrix via ext_info */ 1134 for (i = 0; i < indio_dev->num_channels; i++) 1135 channels[i].ext_info = mount_matrix_ext_info; 1136 1137 ret = 0; 1138 dev_info(&indio_dev->dev, "computed mount matrix from ACPI\n"); 1139 1140 out: 1141 kfree(buffer.pointer); 1142 return ret; 1143 } 1144 #else /* !CONFIG_ACPI */ 1145 static int apply_acpi_orientation(struct iio_dev *indio_dev, 1146 struct iio_chan_spec *channels) 1147 { 1148 return 0; 1149 } 1150 #endif 1151 1152 /* 1153 * st_accel_get_settings() - get sensor settings from device name 1154 * @name: device name buffer reference. 1155 * 1156 * Return: valid reference on success, NULL otherwise. 1157 */ 1158 const struct st_sensor_settings *st_accel_get_settings(const char *name) 1159 { 1160 int index = st_sensors_get_settings_index(name, 1161 st_accel_sensors_settings, 1162 ARRAY_SIZE(st_accel_sensors_settings)); 1163 if (index < 0) 1164 return NULL; 1165 1166 return &st_accel_sensors_settings[index]; 1167 } 1168 EXPORT_SYMBOL(st_accel_get_settings); 1169 1170 int st_accel_common_probe(struct iio_dev *indio_dev) 1171 { 1172 struct st_sensor_data *adata = iio_priv(indio_dev); 1173 struct st_sensors_platform_data *pdata = 1174 (struct st_sensors_platform_data *)adata->dev->platform_data; 1175 struct iio_chan_spec *channels; 1176 size_t channels_size; 1177 int err; 1178 1179 indio_dev->modes = INDIO_DIRECT_MODE; 1180 indio_dev->info = &accel_info; 1181 1182 err = st_sensors_power_enable(indio_dev); 1183 if (err) 1184 return err; 1185 1186 err = st_sensors_verify_id(indio_dev); 1187 if (err < 0) 1188 goto st_accel_power_off; 1189 1190 adata->num_data_channels = ST_ACCEL_NUMBER_DATA_CHANNELS; 1191 indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS; 1192 1193 channels_size = indio_dev->num_channels * sizeof(struct iio_chan_spec); 1194 channels = devm_kmemdup(&indio_dev->dev, 1195 adata->sensor_settings->ch, 1196 channels_size, GFP_KERNEL); 1197 if (!channels) { 1198 err = -ENOMEM; 1199 goto st_accel_power_off; 1200 } 1201 1202 if (apply_acpi_orientation(indio_dev, channels)) 1203 dev_warn(&indio_dev->dev, 1204 "failed to apply ACPI orientation data: %d\n", err); 1205 1206 indio_dev->channels = channels; 1207 adata->current_fullscale = (struct st_sensor_fullscale_avl *) 1208 &adata->sensor_settings->fs.fs_avl[0]; 1209 adata->odr = adata->sensor_settings->odr.odr_avl[0].hz; 1210 1211 if (!pdata) 1212 pdata = (struct st_sensors_platform_data *)&default_accel_pdata; 1213 1214 err = st_sensors_init_sensor(indio_dev, pdata); 1215 if (err < 0) 1216 goto st_accel_power_off; 1217 1218 err = st_accel_allocate_ring(indio_dev); 1219 if (err < 0) 1220 goto st_accel_power_off; 1221 1222 if (adata->irq > 0) { 1223 err = st_sensors_allocate_trigger(indio_dev, 1224 ST_ACCEL_TRIGGER_OPS); 1225 if (err < 0) 1226 goto st_accel_probe_trigger_error; 1227 } 1228 1229 err = iio_device_register(indio_dev); 1230 if (err) 1231 goto st_accel_device_register_error; 1232 1233 dev_info(&indio_dev->dev, "registered accelerometer %s\n", 1234 indio_dev->name); 1235 1236 return 0; 1237 1238 st_accel_device_register_error: 1239 if (adata->irq > 0) 1240 st_sensors_deallocate_trigger(indio_dev); 1241 st_accel_probe_trigger_error: 1242 st_accel_deallocate_ring(indio_dev); 1243 st_accel_power_off: 1244 st_sensors_power_disable(indio_dev); 1245 1246 return err; 1247 } 1248 EXPORT_SYMBOL(st_accel_common_probe); 1249 1250 void st_accel_common_remove(struct iio_dev *indio_dev) 1251 { 1252 struct st_sensor_data *adata = iio_priv(indio_dev); 1253 1254 st_sensors_power_disable(indio_dev); 1255 1256 iio_device_unregister(indio_dev); 1257 if (adata->irq > 0) 1258 st_sensors_deallocate_trigger(indio_dev); 1259 1260 st_accel_deallocate_ring(indio_dev); 1261 } 1262 EXPORT_SYMBOL(st_accel_common_remove); 1263 1264 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>"); 1265 MODULE_DESCRIPTION("STMicroelectronics accelerometers driver"); 1266 MODULE_LICENSE("GPL v2"); 1267