1 /* 2 * STMicroelectronics accelerometers driver 3 * 4 * Copyright 2012-2013 STMicroelectronics Inc. 5 * 6 * Denis Ciocca <denis.ciocca@st.com> 7 * 8 * Licensed under the GPL-2. 9 */ 10 11 #include <linux/kernel.h> 12 #include <linux/module.h> 13 #include <linux/slab.h> 14 #include <linux/errno.h> 15 #include <linux/types.h> 16 #include <linux/mutex.h> 17 #include <linux/interrupt.h> 18 #include <linux/i2c.h> 19 #include <linux/gpio.h> 20 #include <linux/irq.h> 21 #include <linux/iio/iio.h> 22 #include <linux/iio/sysfs.h> 23 #include <linux/iio/trigger.h> 24 #include <linux/iio/buffer.h> 25 26 #include <linux/iio/common/st_sensors.h> 27 #include "st_accel.h" 28 29 #define ST_ACCEL_NUMBER_DATA_CHANNELS 3 30 31 /* DEFAULT VALUE FOR SENSORS */ 32 #define ST_ACCEL_DEFAULT_OUT_X_L_ADDR 0x28 33 #define ST_ACCEL_DEFAULT_OUT_Y_L_ADDR 0x2a 34 #define ST_ACCEL_DEFAULT_OUT_Z_L_ADDR 0x2c 35 36 /* FULLSCALE */ 37 #define ST_ACCEL_FS_AVL_2G 2 38 #define ST_ACCEL_FS_AVL_4G 4 39 #define ST_ACCEL_FS_AVL_6G 6 40 #define ST_ACCEL_FS_AVL_8G 8 41 #define ST_ACCEL_FS_AVL_16G 16 42 #define ST_ACCEL_FS_AVL_100G 100 43 #define ST_ACCEL_FS_AVL_200G 200 44 #define ST_ACCEL_FS_AVL_400G 400 45 46 static const struct iio_chan_spec st_accel_8bit_channels[] = { 47 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 48 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 49 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 8, 8, 50 ST_ACCEL_DEFAULT_OUT_X_L_ADDR+1), 51 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 52 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 53 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 8, 8, 54 ST_ACCEL_DEFAULT_OUT_Y_L_ADDR+1), 55 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 56 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 57 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 8, 8, 58 ST_ACCEL_DEFAULT_OUT_Z_L_ADDR+1), 59 IIO_CHAN_SOFT_TIMESTAMP(3) 60 }; 61 62 static const struct iio_chan_spec st_accel_12bit_channels[] = { 63 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 64 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 65 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 12, 16, 66 ST_ACCEL_DEFAULT_OUT_X_L_ADDR), 67 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 68 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 69 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 12, 16, 70 ST_ACCEL_DEFAULT_OUT_Y_L_ADDR), 71 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 72 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 73 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 12, 16, 74 ST_ACCEL_DEFAULT_OUT_Z_L_ADDR), 75 IIO_CHAN_SOFT_TIMESTAMP(3) 76 }; 77 78 static const struct iio_chan_spec st_accel_16bit_channels[] = { 79 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 80 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 81 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16, 82 ST_ACCEL_DEFAULT_OUT_X_L_ADDR), 83 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 84 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 85 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16, 86 ST_ACCEL_DEFAULT_OUT_Y_L_ADDR), 87 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL, 88 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 89 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16, 90 ST_ACCEL_DEFAULT_OUT_Z_L_ADDR), 91 IIO_CHAN_SOFT_TIMESTAMP(3) 92 }; 93 94 static const struct st_sensor_settings st_accel_sensors_settings[] = { 95 { 96 .wai = 0x33, 97 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 98 .sensors_supported = { 99 [0] = LIS3DH_ACCEL_DEV_NAME, 100 [1] = LSM303DLHC_ACCEL_DEV_NAME, 101 [2] = LSM330D_ACCEL_DEV_NAME, 102 [3] = LSM330DL_ACCEL_DEV_NAME, 103 [4] = LSM330DLC_ACCEL_DEV_NAME, 104 [5] = LSM303AGR_ACCEL_DEV_NAME, 105 [6] = LIS2DH12_ACCEL_DEV_NAME, 106 }, 107 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 108 .odr = { 109 .addr = 0x20, 110 .mask = 0xf0, 111 .odr_avl = { 112 { .hz = 1, .value = 0x01, }, 113 { .hz = 10, .value = 0x02, }, 114 { .hz = 25, .value = 0x03, }, 115 { .hz = 50, .value = 0x04, }, 116 { .hz = 100, .value = 0x05, }, 117 { .hz = 200, .value = 0x06, }, 118 { .hz = 400, .value = 0x07, }, 119 { .hz = 1600, .value = 0x08, }, 120 }, 121 }, 122 .pw = { 123 .addr = 0x20, 124 .mask = 0xf0, 125 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 126 }, 127 .enable_axis = { 128 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 129 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 130 }, 131 .fs = { 132 .addr = 0x23, 133 .mask = 0x30, 134 .fs_avl = { 135 [0] = { 136 .num = ST_ACCEL_FS_AVL_2G, 137 .value = 0x00, 138 .gain = IIO_G_TO_M_S_2(1000), 139 }, 140 [1] = { 141 .num = ST_ACCEL_FS_AVL_4G, 142 .value = 0x01, 143 .gain = IIO_G_TO_M_S_2(2000), 144 }, 145 [2] = { 146 .num = ST_ACCEL_FS_AVL_8G, 147 .value = 0x02, 148 .gain = IIO_G_TO_M_S_2(4000), 149 }, 150 [3] = { 151 .num = ST_ACCEL_FS_AVL_16G, 152 .value = 0x03, 153 .gain = IIO_G_TO_M_S_2(12000), 154 }, 155 }, 156 }, 157 .bdu = { 158 .addr = 0x23, 159 .mask = 0x80, 160 }, 161 .drdy_irq = { 162 .addr = 0x22, 163 .mask_int1 = 0x10, 164 .mask_int2 = 0x08, 165 .addr_ihl = 0x25, 166 .mask_ihl = 0x02, 167 .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR, 168 }, 169 .multi_read_bit = true, 170 .bootime = 2, 171 }, 172 { 173 .wai = 0x32, 174 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 175 .sensors_supported = { 176 [0] = LIS331DLH_ACCEL_DEV_NAME, 177 [1] = LSM303DL_ACCEL_DEV_NAME, 178 [2] = LSM303DLH_ACCEL_DEV_NAME, 179 [3] = LSM303DLM_ACCEL_DEV_NAME, 180 }, 181 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 182 .odr = { 183 .addr = 0x20, 184 .mask = 0x18, 185 .odr_avl = { 186 { .hz = 50, .value = 0x00, }, 187 { .hz = 100, .value = 0x01, }, 188 { .hz = 400, .value = 0x02, }, 189 { .hz = 1000, .value = 0x03, }, 190 }, 191 }, 192 .pw = { 193 .addr = 0x20, 194 .mask = 0xe0, 195 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 196 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 197 }, 198 .enable_axis = { 199 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 200 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 201 }, 202 .fs = { 203 .addr = 0x23, 204 .mask = 0x30, 205 .fs_avl = { 206 [0] = { 207 .num = ST_ACCEL_FS_AVL_2G, 208 .value = 0x00, 209 .gain = IIO_G_TO_M_S_2(1000), 210 }, 211 [1] = { 212 .num = ST_ACCEL_FS_AVL_4G, 213 .value = 0x01, 214 .gain = IIO_G_TO_M_S_2(2000), 215 }, 216 [2] = { 217 .num = ST_ACCEL_FS_AVL_8G, 218 .value = 0x03, 219 .gain = IIO_G_TO_M_S_2(3900), 220 }, 221 }, 222 }, 223 .bdu = { 224 .addr = 0x23, 225 .mask = 0x80, 226 }, 227 .drdy_irq = { 228 .addr = 0x22, 229 .mask_int1 = 0x02, 230 .mask_int2 = 0x10, 231 .addr_ihl = 0x22, 232 .mask_ihl = 0x80, 233 .addr_od = 0x22, 234 .mask_od = 0x40, 235 .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR, 236 }, 237 .multi_read_bit = true, 238 .bootime = 2, 239 }, 240 { 241 .wai = 0x40, 242 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 243 .sensors_supported = { 244 [0] = LSM330_ACCEL_DEV_NAME, 245 }, 246 .ch = (struct iio_chan_spec *)st_accel_16bit_channels, 247 .odr = { 248 .addr = 0x20, 249 .mask = 0xf0, 250 .odr_avl = { 251 { .hz = 3, .value = 0x01, }, 252 { .hz = 6, .value = 0x02, }, 253 { .hz = 12, .value = 0x03, }, 254 { .hz = 25, .value = 0x04, }, 255 { .hz = 50, .value = 0x05, }, 256 { .hz = 100, .value = 0x06, }, 257 { .hz = 200, .value = 0x07, }, 258 { .hz = 400, .value = 0x08, }, 259 { .hz = 800, .value = 0x09, }, 260 { .hz = 1600, .value = 0x0a, }, 261 }, 262 }, 263 .pw = { 264 .addr = 0x20, 265 .mask = 0xf0, 266 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 267 }, 268 .enable_axis = { 269 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 270 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 271 }, 272 .fs = { 273 .addr = 0x24, 274 .mask = 0x38, 275 .fs_avl = { 276 [0] = { 277 .num = ST_ACCEL_FS_AVL_2G, 278 .value = 0x00, 279 .gain = IIO_G_TO_M_S_2(61), 280 }, 281 [1] = { 282 .num = ST_ACCEL_FS_AVL_4G, 283 .value = 0x01, 284 .gain = IIO_G_TO_M_S_2(122), 285 }, 286 [2] = { 287 .num = ST_ACCEL_FS_AVL_6G, 288 .value = 0x02, 289 .gain = IIO_G_TO_M_S_2(183), 290 }, 291 [3] = { 292 .num = ST_ACCEL_FS_AVL_8G, 293 .value = 0x03, 294 .gain = IIO_G_TO_M_S_2(244), 295 }, 296 [4] = { 297 .num = ST_ACCEL_FS_AVL_16G, 298 .value = 0x04, 299 .gain = IIO_G_TO_M_S_2(732), 300 }, 301 }, 302 }, 303 .bdu = { 304 .addr = 0x20, 305 .mask = 0x08, 306 }, 307 .drdy_irq = { 308 .addr = 0x23, 309 .mask_int1 = 0x80, 310 .mask_int2 = 0x00, 311 .addr_ihl = 0x23, 312 .mask_ihl = 0x40, 313 .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR, 314 .ig1 = { 315 .en_addr = 0x23, 316 .en_mask = 0x08, 317 }, 318 }, 319 .multi_read_bit = false, 320 .bootime = 2, 321 }, 322 { 323 .wai = 0x3a, 324 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 325 .sensors_supported = { 326 [0] = LIS3LV02DL_ACCEL_DEV_NAME, 327 }, 328 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 329 .odr = { 330 .addr = 0x20, 331 .mask = 0x30, /* DF1 and DF0 */ 332 .odr_avl = { 333 { .hz = 40, .value = 0x00, }, 334 { .hz = 160, .value = 0x01, }, 335 { .hz = 640, .value = 0x02, }, 336 { .hz = 2560, .value = 0x03, }, 337 }, 338 }, 339 .pw = { 340 .addr = 0x20, 341 .mask = 0xc0, 342 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 343 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 344 }, 345 .enable_axis = { 346 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 347 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 348 }, 349 .fs = { 350 .addr = 0x21, 351 .mask = 0x80, 352 .fs_avl = { 353 [0] = { 354 .num = ST_ACCEL_FS_AVL_2G, 355 .value = 0x00, 356 .gain = IIO_G_TO_M_S_2(1000), 357 }, 358 [1] = { 359 .num = ST_ACCEL_FS_AVL_6G, 360 .value = 0x01, 361 .gain = IIO_G_TO_M_S_2(3000), 362 }, 363 }, 364 }, 365 .bdu = { 366 .addr = 0x21, 367 .mask = 0x40, 368 }, 369 /* 370 * Data Alignment Setting - needs to be set to get 371 * left-justified data like all other sensors. 372 */ 373 .das = { 374 .addr = 0x21, 375 .mask = 0x01, 376 }, 377 .drdy_irq = { 378 .addr = 0x21, 379 .mask_int1 = 0x04, 380 .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR, 381 }, 382 .multi_read_bit = true, 383 .bootime = 2, /* guess */ 384 }, 385 { 386 .wai = 0x3b, 387 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 388 .sensors_supported = { 389 [0] = LIS331DL_ACCEL_DEV_NAME, 390 }, 391 .ch = (struct iio_chan_spec *)st_accel_8bit_channels, 392 .odr = { 393 .addr = 0x20, 394 .mask = 0x80, 395 .odr_avl = { 396 { .hz = 100, .value = 0x00, }, 397 { .hz = 400, .value = 0x01, }, 398 }, 399 }, 400 .pw = { 401 .addr = 0x20, 402 .mask = 0x40, 403 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 404 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 405 }, 406 .enable_axis = { 407 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 408 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 409 }, 410 .fs = { 411 .addr = 0x20, 412 .mask = 0x20, 413 /* 414 * TODO: check these resulting gain settings, these are 415 * not in the datsheet 416 */ 417 .fs_avl = { 418 [0] = { 419 .num = ST_ACCEL_FS_AVL_2G, 420 .value = 0x00, 421 .gain = IIO_G_TO_M_S_2(18000), 422 }, 423 [1] = { 424 .num = ST_ACCEL_FS_AVL_8G, 425 .value = 0x01, 426 .gain = IIO_G_TO_M_S_2(72000), 427 }, 428 }, 429 }, 430 .drdy_irq = { 431 .addr = 0x22, 432 .mask_int1 = 0x04, 433 .mask_int2 = 0x20, 434 .addr_ihl = 0x22, 435 .mask_ihl = 0x80, 436 .addr_od = 0x22, 437 .mask_od = 0x40, 438 .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR, 439 }, 440 .multi_read_bit = false, 441 .bootime = 2, /* guess */ 442 }, 443 { 444 .wai = 0x32, 445 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 446 .sensors_supported = { 447 [0] = H3LIS331DL_DRIVER_NAME, 448 }, 449 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 450 .odr = { 451 .addr = 0x20, 452 .mask = 0x18, 453 .odr_avl = { 454 { .hz = 50, .value = 0x00, }, 455 { .hz = 100, .value = 0x01, }, 456 { .hz = 400, .value = 0x02, }, 457 { .hz = 1000, .value = 0x03, }, 458 }, 459 }, 460 .pw = { 461 .addr = 0x20, 462 .mask = 0x20, 463 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 464 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 465 }, 466 .enable_axis = { 467 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 468 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 469 }, 470 .fs = { 471 .addr = 0x23, 472 .mask = 0x30, 473 .fs_avl = { 474 [0] = { 475 .num = ST_ACCEL_FS_AVL_100G, 476 .value = 0x00, 477 .gain = IIO_G_TO_M_S_2(49000), 478 }, 479 [1] = { 480 .num = ST_ACCEL_FS_AVL_200G, 481 .value = 0x01, 482 .gain = IIO_G_TO_M_S_2(98000), 483 }, 484 [2] = { 485 .num = ST_ACCEL_FS_AVL_400G, 486 .value = 0x03, 487 .gain = IIO_G_TO_M_S_2(195000), 488 }, 489 }, 490 }, 491 .bdu = { 492 .addr = 0x23, 493 .mask = 0x80, 494 }, 495 .drdy_irq = { 496 .addr = 0x22, 497 .mask_int1 = 0x02, 498 .mask_int2 = 0x10, 499 .addr_ihl = 0x22, 500 .mask_ihl = 0x80, 501 }, 502 .multi_read_bit = true, 503 .bootime = 2, 504 }, 505 { 506 /* No WAI register present */ 507 .sensors_supported = { 508 [0] = LIS3L02DQ_ACCEL_DEV_NAME, 509 }, 510 .ch = (struct iio_chan_spec *)st_accel_12bit_channels, 511 .odr = { 512 .addr = 0x20, 513 .mask = 0x30, 514 .odr_avl = { 515 { .hz = 280, .value = 0x00, }, 516 { .hz = 560, .value = 0x01, }, 517 { .hz = 1120, .value = 0x02, }, 518 { .hz = 4480, .value = 0x03, }, 519 }, 520 }, 521 .pw = { 522 .addr = 0x20, 523 .mask = 0xc0, 524 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE, 525 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 526 }, 527 .enable_axis = { 528 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 529 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 530 }, 531 .fs = { 532 .fs_avl = { 533 [0] = { 534 .num = ST_ACCEL_FS_AVL_2G, 535 .gain = IIO_G_TO_M_S_2(488), 536 }, 537 }, 538 }, 539 /* 540 * The part has a BDU bit but if set the data is never 541 * updated so don't set it. 542 */ 543 .bdu = { 544 }, 545 .drdy_irq = { 546 .addr = 0x21, 547 .mask_int1 = 0x04, 548 .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR, 549 }, 550 .multi_read_bit = false, 551 .bootime = 2, 552 }, 553 { 554 .wai = 0x33, 555 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS, 556 .sensors_supported = { 557 [0] = LNG2DM_ACCEL_DEV_NAME, 558 }, 559 .ch = (struct iio_chan_spec *)st_accel_8bit_channels, 560 .odr = { 561 .addr = 0x20, 562 .mask = 0xf0, 563 .odr_avl = { 564 { .hz = 1, .value = 0x01, }, 565 { .hz = 10, .value = 0x02, }, 566 { .hz = 25, .value = 0x03, }, 567 { .hz = 50, .value = 0x04, }, 568 { .hz = 100, .value = 0x05, }, 569 { .hz = 200, .value = 0x06, }, 570 { .hz = 400, .value = 0x07, }, 571 { .hz = 1600, .value = 0x08, }, 572 }, 573 }, 574 .pw = { 575 .addr = 0x20, 576 .mask = 0xf0, 577 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE, 578 }, 579 .enable_axis = { 580 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR, 581 .mask = ST_SENSORS_DEFAULT_AXIS_MASK, 582 }, 583 .fs = { 584 .addr = 0x23, 585 .mask = 0x30, 586 .fs_avl = { 587 [0] = { 588 .num = ST_ACCEL_FS_AVL_2G, 589 .value = 0x00, 590 .gain = IIO_G_TO_M_S_2(15600), 591 }, 592 [1] = { 593 .num = ST_ACCEL_FS_AVL_4G, 594 .value = 0x01, 595 .gain = IIO_G_TO_M_S_2(31200), 596 }, 597 [2] = { 598 .num = ST_ACCEL_FS_AVL_8G, 599 .value = 0x02, 600 .gain = IIO_G_TO_M_S_2(62500), 601 }, 602 [3] = { 603 .num = ST_ACCEL_FS_AVL_16G, 604 .value = 0x03, 605 .gain = IIO_G_TO_M_S_2(187500), 606 }, 607 }, 608 }, 609 .drdy_irq = { 610 .addr = 0x22, 611 .mask_int1 = 0x10, 612 .mask_int2 = 0x08, 613 .addr_ihl = 0x25, 614 .mask_ihl = 0x02, 615 .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR, 616 }, 617 .multi_read_bit = true, 618 .bootime = 2, 619 }, 620 }; 621 622 static int st_accel_read_raw(struct iio_dev *indio_dev, 623 struct iio_chan_spec const *ch, int *val, 624 int *val2, long mask) 625 { 626 int err; 627 struct st_sensor_data *adata = iio_priv(indio_dev); 628 629 switch (mask) { 630 case IIO_CHAN_INFO_RAW: 631 err = st_sensors_read_info_raw(indio_dev, ch, val); 632 if (err < 0) 633 goto read_error; 634 635 return IIO_VAL_INT; 636 case IIO_CHAN_INFO_SCALE: 637 *val = adata->current_fullscale->gain / 1000000; 638 *val2 = adata->current_fullscale->gain % 1000000; 639 return IIO_VAL_INT_PLUS_MICRO; 640 case IIO_CHAN_INFO_SAMP_FREQ: 641 *val = adata->odr; 642 return IIO_VAL_INT; 643 default: 644 return -EINVAL; 645 } 646 647 read_error: 648 return err; 649 } 650 651 static int st_accel_write_raw(struct iio_dev *indio_dev, 652 struct iio_chan_spec const *chan, int val, int val2, long mask) 653 { 654 int err; 655 656 switch (mask) { 657 case IIO_CHAN_INFO_SCALE: { 658 int gain; 659 660 gain = val * 1000000 + val2; 661 err = st_sensors_set_fullscale_by_gain(indio_dev, gain); 662 break; 663 } 664 case IIO_CHAN_INFO_SAMP_FREQ: 665 if (val2) 666 return -EINVAL; 667 mutex_lock(&indio_dev->mlock); 668 err = st_sensors_set_odr(indio_dev, val); 669 mutex_unlock(&indio_dev->mlock); 670 return err; 671 default: 672 return -EINVAL; 673 } 674 675 return err; 676 } 677 678 static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL(); 679 static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_accel_scale_available); 680 681 static struct attribute *st_accel_attributes[] = { 682 &iio_dev_attr_sampling_frequency_available.dev_attr.attr, 683 &iio_dev_attr_in_accel_scale_available.dev_attr.attr, 684 NULL, 685 }; 686 687 static const struct attribute_group st_accel_attribute_group = { 688 .attrs = st_accel_attributes, 689 }; 690 691 static const struct iio_info accel_info = { 692 .driver_module = THIS_MODULE, 693 .attrs = &st_accel_attribute_group, 694 .read_raw = &st_accel_read_raw, 695 .write_raw = &st_accel_write_raw, 696 .debugfs_reg_access = &st_sensors_debugfs_reg_access, 697 }; 698 699 #ifdef CONFIG_IIO_TRIGGER 700 static const struct iio_trigger_ops st_accel_trigger_ops = { 701 .owner = THIS_MODULE, 702 .set_trigger_state = ST_ACCEL_TRIGGER_SET_STATE, 703 .validate_device = st_sensors_validate_device, 704 }; 705 #define ST_ACCEL_TRIGGER_OPS (&st_accel_trigger_ops) 706 #else 707 #define ST_ACCEL_TRIGGER_OPS NULL 708 #endif 709 710 int st_accel_common_probe(struct iio_dev *indio_dev) 711 { 712 struct st_sensor_data *adata = iio_priv(indio_dev); 713 int irq = adata->get_irq_data_ready(indio_dev); 714 int err; 715 716 indio_dev->modes = INDIO_DIRECT_MODE; 717 indio_dev->info = &accel_info; 718 mutex_init(&adata->tb.buf_lock); 719 720 err = st_sensors_power_enable(indio_dev); 721 if (err) 722 return err; 723 724 err = st_sensors_check_device_support(indio_dev, 725 ARRAY_SIZE(st_accel_sensors_settings), 726 st_accel_sensors_settings); 727 if (err < 0) 728 goto st_accel_power_off; 729 730 adata->num_data_channels = ST_ACCEL_NUMBER_DATA_CHANNELS; 731 adata->multiread_bit = adata->sensor_settings->multi_read_bit; 732 indio_dev->channels = adata->sensor_settings->ch; 733 indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS; 734 735 adata->current_fullscale = (struct st_sensor_fullscale_avl *) 736 &adata->sensor_settings->fs.fs_avl[0]; 737 adata->odr = adata->sensor_settings->odr.odr_avl[0].hz; 738 739 if (!adata->dev->platform_data) 740 adata->dev->platform_data = 741 (struct st_sensors_platform_data *)&default_accel_pdata; 742 743 err = st_sensors_init_sensor(indio_dev, adata->dev->platform_data); 744 if (err < 0) 745 goto st_accel_power_off; 746 747 err = st_accel_allocate_ring(indio_dev); 748 if (err < 0) 749 goto st_accel_power_off; 750 751 if (irq > 0) { 752 err = st_sensors_allocate_trigger(indio_dev, 753 ST_ACCEL_TRIGGER_OPS); 754 if (err < 0) 755 goto st_accel_probe_trigger_error; 756 } 757 758 err = iio_device_register(indio_dev); 759 if (err) 760 goto st_accel_device_register_error; 761 762 dev_info(&indio_dev->dev, "registered accelerometer %s\n", 763 indio_dev->name); 764 765 return 0; 766 767 st_accel_device_register_error: 768 if (irq > 0) 769 st_sensors_deallocate_trigger(indio_dev); 770 st_accel_probe_trigger_error: 771 st_accel_deallocate_ring(indio_dev); 772 st_accel_power_off: 773 st_sensors_power_disable(indio_dev); 774 775 return err; 776 } 777 EXPORT_SYMBOL(st_accel_common_probe); 778 779 void st_accel_common_remove(struct iio_dev *indio_dev) 780 { 781 struct st_sensor_data *adata = iio_priv(indio_dev); 782 783 st_sensors_power_disable(indio_dev); 784 785 iio_device_unregister(indio_dev); 786 if (adata->get_irq_data_ready(indio_dev) > 0) 787 st_sensors_deallocate_trigger(indio_dev); 788 789 st_accel_deallocate_ring(indio_dev); 790 } 791 EXPORT_SYMBOL(st_accel_common_remove); 792 793 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>"); 794 MODULE_DESCRIPTION("STMicroelectronics accelerometers driver"); 795 MODULE_LICENSE("GPL v2"); 796