1553 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * STMicroelectronics accelerometers driver4 *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 324 25/* DEFAULT VALUE FOR SENSORS */26#define ST_ACCEL_DEFAULT_OUT_X_L_ADDR 0x2827#define ST_ACCEL_DEFAULT_OUT_Y_L_ADDR 0x2a28#define ST_ACCEL_DEFAULT_OUT_Z_L_ADDR 0x2c29 30/* FULLSCALE */31#define ST_ACCEL_FS_AVL_2G 232#define ST_ACCEL_FS_AVL_4G 433#define ST_ACCEL_FS_AVL_6G 634#define ST_ACCEL_FS_AVL_8G 835#define ST_ACCEL_FS_AVL_16G 1636#define ST_ACCEL_FS_AVL_100G 10037#define ST_ACCEL_FS_AVL_200G 20038#define ST_ACCEL_FS_AVL_400G 40039 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 get419 * 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 are473 * not in the datsheet474 */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 never623 * 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, even1178 * 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 */1261static const struct st_sensors_platform_data default_accel_pdata = {1262 .drdy_int_pin = 1,1263};1264 1265static 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 1290read_error:1291 return err;1292}1293 1294static 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 1314static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();1315static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_accel_scale_available);1316 1317static 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 1323static const struct attribute_group st_accel_attribute_group = {1324 .attrs = st_accel_attributes,1325};1326 1327static 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_TRIGGER1335static 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#else1341#define ST_ACCEL_TRIGGER_OPS NULL1342#endif1343 1344#ifdef CONFIG_ACPI1345/* Read ST-specific _ONT orientation data from ACPI and generate an1346 * appropriate mount matrix.1347 */1348static 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 directly1362 * to the data read from the sensor. Another translation must be1363 * performed first, as described by the matrix below. Perhaps1364 * ST required this specific translation for the first product1365 * 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 the1406 * columns in the default_ont matrix according to the1407 * 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 1462out: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 */1471static int apply_acpi_orientation(struct iio_dev *indio_dev)1472{1473 return -EINVAL;1474}1475#endif1476 1477/*1478 * st_accel_get_settings() - get sensor settings from device name1479 * @name: device name buffer reference.1480 *1481 * Return: valid reference on success, NULL otherwise.1482 */1483const 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}1493EXPORT_SYMBOL_NS(st_accel_get_settings, IIO_ST_SENSORS);1494 1495int 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 the1515 * 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}1547EXPORT_SYMBOL_NS(st_accel_common_probe, IIO_ST_SENSORS);1548 1549MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");1550MODULE_DESCRIPTION("STMicroelectronics accelerometers driver");1551MODULE_LICENSE("GPL v2");1552MODULE_IMPORT_NS(IIO_ST_SENSORS);1553