drivers/iio/imu/inv_mpu/inv530/inv_mpu_core.c

   1 /*
   2 * Copyright (C) 2012 Invensense, Inc.
   3 *
   4 * This software is licensed under the terms of the GNU General Public
   5 * License version 2, as published by the Free Software Foundation, and
   6 * may be copied, distributed, and modified under those terms.
   7 *
   8 * This program is distributed in the hope that it will be useful,
   9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 * GNU General Public License for more details.
  12 */
  13 #define pr_fmt(fmt) "inv_mpu: " fmt
  14
  15 #include <linux/module.h>
  16 #include <linux/init.h>
  17 #include <linux/slab.h>
  18 #include <linux/err.h>
  19 #include <linux/delay.h>
  20 #include <linux/sysfs.h>
  21 #include <linux/jiffies.h>
  22 #include <linux/irq.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/kfifo.h>
  25 #include <linux/poll.h>
  26 #include <linux/miscdevice.h>
  27 #include <linux/spinlock.h>
  28
  29 #include "inv_mpu_iio.h"
  30 #include "sysfs.h"
  31 #include "inv_test/inv_counters.h"
  32
  33 #ifdef CONFIG_DTS_INV_MPU_IIO
  34 #include "inv_mpu_dts.h"
  35 #endif
  36
  37 static const struct inv_hw_s hw_info[INV_NUM_PARTS] = {
  38         {128, "ICM20628"},
  39         {128, "ICM20728"},
  40 };
  41 static int debug_mem_read_addr = 0x900;
  42 static char debug_reg_addr = 0x6;
  43
  44 int inv_set_dmp(struct inv_mpu_state *st)
  45 {
  46         int result;
  47
  48         result = inv_set_bank(st, BANK_SEL_2);
  49         if (result)
  50                 return result;
  51         result = inv_plat_single_write(st, REG_PRGM_START_ADDRH,
  52                                                         DMP_START_ADDR >> 8);
  53         if (result)
  54                 return result;
  55         result = inv_plat_single_write(st, REG_PRGM_START_ADDRH + 1,
  56                                                         DMP_START_ADDR & 0xff);
  57         if (result)
  58                 return result;
  59         result = inv_set_bank(st, BANK_SEL_0);
  60
  61         return result;
  62 }
  63
  64 static int inv_calc_gyro_sf(s8 pll)
  65 {
  66         int a, r;
  67         int value, t;
  68
  69         t = 102870L + 81L * pll;
  70         a = (1L << 30) / t;
  71         r = (1L << 30) - a * t;
  72         value = a * 797 * DMP_DIVIDER;
  73         value += (s64)((a * 1011387LL * DMP_DIVIDER) >> 20);
  74         value += r * 797L * DMP_DIVIDER / t;
  75         value += (s32)((s64)((r * 1011387LL * DMP_DIVIDER) >> 20)) / t;
  76         value <<= 1;
  77
  78         return value;
  79 }
  80
  81 static int inv_read_timebase(struct inv_mpu_state *st)
  82 {
  83         int result;
  84         u8 d;
  85         s8 t;
  86
  87         result = inv_set_bank(st, BANK_SEL_1);
  88         if (result)
  89                 return result;
  90         result = inv_plat_read(st, REG_TIMEBASE_CORRECTION_PLL, 1, &d);
  91         if (result)
  92                 return result;
  93         t = abs(d & 0x7f);
  94         if (d & 0x80)
  95                 t = -t;
  96
  97         st->eng_info[ENGINE_ACCEL].base_time = NSEC_PER_SEC;
  98         /* talor expansion to calculate base time unit */
  99         st->eng_info[ENGINE_GYRO].base_time = NSEC_PER_SEC - t * 769903 +
 100                                                 ((t * 769903) / 1270) * t;
 101         st->eng_info[ENGINE_PRESSURE].base_time = NSEC_PER_SEC;
 102         st->eng_info[ENGINE_I2C].base_time  = NSEC_PER_SEC;
 103
 104         st->eng_info[ENGINE_ACCEL].orig_rate = BASE_SAMPLE_RATE;
 105         st->eng_info[ENGINE_GYRO].orig_rate = BASE_SAMPLE_RATE;
 106         st->eng_info[ENGINE_PRESSURE].orig_rate = MAX_PRS_RATE;
 107         st->eng_info[ENGINE_I2C].orig_rate = BASE_SAMPLE_RATE;
 108
 109         st->gyro_sf = inv_calc_gyro_sf(t);
 110         result = inv_set_bank(st, BANK_SEL_0);
 111
 112         return result;
 113 }
 114
 115 static int inv_set_gyro_sf(struct inv_mpu_state *st)
 116 {
 117         int result;
 118
 119         result = inv_set_bank(st, BANK_SEL_2);
 120         if (result)
 121                 return result;
 122         result = inv_plat_single_write(st, REG_GYRO_CONFIG_1,
 123                                 (st->chip_config.fsr << SHIFT_GYRO_FS_SEL) | 1);
 124         if (result)
 125                 return result;
 126
 127         result = inv_set_bank(st, BANK_SEL_0);
 128
 129         return result;
 130 }
 131
 132 static int inv_set_accel_sf(struct inv_mpu_state *st)
 133 {
 134         int result;
 135         int scale[] = {33554432, 67108864, 134217728, 268435456};
 136
 137         result = inv_set_bank(st, BANK_SEL_2);
 138         if (result)
 139                 return result;
 140         result = inv_plat_single_write(st, REG_ACCEL_CONFIG,
 141                         (st->chip_config.accel_fs << SHIFT_ACCEL_FS) | 0);
 142         if (result)
 143                 return result;
 144
 145         result = inv_set_bank(st, BANK_SEL_0);
 146         if (result)
 147                 return result;
 148
 149         result = write_be32_to_mem(st,
 150                         scale[st->chip_config.accel_fs], ACC_SCALE);
 151
 152         return result;
 153 }
 154
 155 static int inv_set_gyro_avg_filter(struct inv_mpu_state *st)
 156 {
 157         int result;
 158
 159         result = inv_set_bank(st, BANK_SEL_2);
 160         if (result)
 161                 return result;
 162         result = inv_plat_single_write(st, REG_GYRO_CONFIG_2,
 163                         st->chip_config.gyro_avg_filter);
 164         if (result)
 165                 return result;
 166
 167         result = inv_set_bank(st, BANK_SEL_0);
 168
 169         return result;
 170 }
 171
 172 static int inv_set_accel_avg_filter(struct inv_mpu_state *st)
 173 {
 174         int result;
 175
 176         result = inv_set_bank(st, BANK_SEL_2);
 177         if (result)
 178                 return result;
 179         result = inv_plat_single_write(st, REG_ACCEL_CONFIG_2,
 180                         st->chip_config.accel_avg_filter);
 181         if (result)
 182                 return result;
 183
 184         result = inv_set_bank(st, BANK_SEL_0);
 185
 186         return result;
 187 }
 188
 189 int inv_set_secondary(struct inv_mpu_state *st)
 190 {
 191         int r;
 192
 193         r = inv_set_bank(st, BANK_SEL_3);
 194         if (r)
 195                 return r;
 196         r = inv_plat_single_write(st, REG_I2C_MST_CTRL, BIT_I2C_MST_P_NSR);
 197         if (r)
 198                 return r;
 199
 200         r = inv_plat_single_write(st, REG_I2C_MST_ODR_CONFIG,
 201                                                         MIN_MST_ODR_CONFIG);
 202         if (r)
 203                 return r;
 204
 205         r = inv_set_bank(st, BANK_SEL_0);
 206
 207         return r;
 208 }
 209 static int inv_set_odr_sync(struct inv_mpu_state *st)
 210 {
 211         int r;
 212
 213         r = inv_set_bank(st, BANK_SEL_2);
 214         if (r)
 215                 return r;
 216         r = inv_plat_single_write(st, REG_MOD_CTRL_USR, BIT_ODR_SYNC);
 217         if (r)
 218                 return r;
 219         r = inv_set_bank(st, BANK_SEL_0);
 220
 221         return r;
 222
 223 }
 224 static int inv_init_secondary(struct inv_mpu_state *st)
 225 {
 226         st->slv_reg[0].addr = REG_I2C_SLV0_ADDR;
 227         st->slv_reg[0].reg  = REG_I2C_SLV0_REG;
 228         st->slv_reg[0].ctrl = REG_I2C_SLV0_CTRL;
 229         st->slv_reg[0].d0   = REG_I2C_SLV0_DO;
 230
 231         st->slv_reg[1].addr = REG_I2C_SLV1_ADDR;
 232         st->slv_reg[1].reg  = REG_I2C_SLV1_REG;
 233         st->slv_reg[1].ctrl = REG_I2C_SLV1_CTRL;
 234         st->slv_reg[1].d0   = REG_I2C_SLV1_DO;
 235
 236         st->slv_reg[2].addr = REG_I2C_SLV2_ADDR;
 237         st->slv_reg[2].reg  = REG_I2C_SLV2_REG;
 238         st->slv_reg[2].ctrl = REG_I2C_SLV2_CTRL;
 239         st->slv_reg[2].d0   = REG_I2C_SLV2_DO;
 240
 241         st->slv_reg[3].addr = REG_I2C_SLV3_ADDR;
 242         st->slv_reg[3].reg  = REG_I2C_SLV3_REG;
 243         st->slv_reg[3].ctrl = REG_I2C_SLV3_CTRL;
 244         st->slv_reg[3].d0   = REG_I2C_SLV3_DO;
 245
 246         return 0;
 247 }
 248
 249 static int inv_init_config(struct inv_mpu_state *st)
 250 {
 251         int res;
 252
 253         st->batch.overflow_on = 0;
 254         st->chip_config.fsr = MPU_INIT_GYRO_SCALE;
 255         st->chip_config.accel_fs = MPU_INIT_ACCEL_SCALE;
 256         st->chip_config.gyro_avg_filter = MPU_INIT_GYRO_AVG_FILTER;
 257         st->chip_config.accel_avg_filter = MPU_INIT_ACCEL_AVG_FILTER;
 258         st->ped.int_thresh = MPU_INIT_PED_INT_THRESH;
 259         st->ped.step_thresh = MPU_INIT_PED_STEP_THRESH;
 260         st->smd.timer_thresh = MPU_INIT_SMD_TIMER_THLD;
 261         st->chip_config.low_power_gyro_on = 1;
 262         st->suspend_state = false;
 263         st->firmware = 0;
 264         st->chip_config.debug_data_collection_gyro_freq = BASE_SAMPLE_RATE;
 265         st->chip_config.debug_data_collection_accel_freq = BASE_SAMPLE_RATE;
 266
 267         inv_init_secondary(st);
 268
 269         res = inv_read_timebase(st);
 270         if (res)
 271                 return res;
 272         res = inv_set_dmp(st);
 273         if (res)
 274                 return res;
 275
 276         res = inv_set_gyro_sf(st);
 277         if (res)
 278                 return res;
 279         res = inv_set_accel_sf(st);
 280         if (res)
 281                 return res;
 282         res = inv_set_gyro_avg_filter(st);
 283         if (res)
 284                 return res;
 285         res = inv_set_accel_avg_filter(st);
 286         if (res)
 287                 return res;
 288
 289         res = inv_set_odr_sync(st);
 290         if (res)
 291                 return res;
 292
 293         res = inv_set_secondary(st);
 294
 295         return res;
 296 }
 297
 298 /*
 299  * inv_firmware_loaded_store() -  calling this function will change
 300  *                        firmware load
 301  */
 302 static ssize_t inv_firmware_loaded_store(struct device *dev,
 303         struct device_attribute *attr, const char *buf, size_t count)
 304 {
 305         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 306         struct inv_mpu_state *st = iio_priv(indio_dev);
 307         int result, data;
 308
 309         result = kstrtoint(buf, 10, &data);
 310         if (result)
 311                 return -EINVAL;
 312
 313         if (data)
 314                 return -EINVAL;
 315         st->chip_config.firmware_loaded = 0;
 316
 317         return count;
 318
 319 }
 320
 321 static ssize_t _dmp_bias_store(struct device *dev,
 322         struct device_attribute *attr, const char *buf, size_t count)
 323 {
 324         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 325         struct inv_mpu_state *st = iio_priv(indio_dev);
 326         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 327         int result, data;
 328
 329         if (!st->chip_config.firmware_loaded)
 330                 return -EINVAL;
 331
 332         result = inv_switch_power_in_lp(st, true);
 333         if (result)
 334                 return result;
 335
 336         result = kstrtoint(buf, 10, &data);
 337         if (result)
 338                 goto dmp_bias_store_fail;
 339         switch (this_attr->address) {
 340         case ATTR_DMP_ACCEL_X_DMP_BIAS:
 341                 if (data)
 342                         st->sensor_acurracy_flag[SENSOR_ACCEL_ACCURACY] = DEFAULT_ACCURACY;
 343                 result = write_be32_to_mem(st, data, ACCEL_BIAS_X);
 344                 if (result)
 345                         goto dmp_bias_store_fail;
 346                 st->input_accel_dmp_bias[0] = data;
 347                 break;
 348         case ATTR_DMP_ACCEL_Y_DMP_BIAS:
 349                 result = write_be32_to_mem(st, data, ACCEL_BIAS_Y);
 350                 if (result)
 351                         goto dmp_bias_store_fail;
 352                 st->input_accel_dmp_bias[1] = data;
 353                 break;
 354         case ATTR_DMP_ACCEL_Z_DMP_BIAS:
 355                 result = write_be32_to_mem(st, data, ACCEL_BIAS_Z);
 356                 if (result)
 357                         goto dmp_bias_store_fail;
 358                 st->input_accel_dmp_bias[2] = data;
 359                 break;
 360         case ATTR_DMP_GYRO_X_DMP_BIAS:
 361                 if (data)
 362                         st->sensor_acurracy_flag[SENSOR_GYRO_ACCURACY] = DEFAULT_ACCURACY;
 363                 result = write_be32_to_mem(st, data, GYRO_BIAS_X);
 364                 if (result)
 365                         goto dmp_bias_store_fail;
 366                 st->input_gyro_dmp_bias[0] = data;
 367                 break;
 368         case ATTR_DMP_GYRO_Y_DMP_BIAS:
 369                 result = write_be32_to_mem(st, data, GYRO_BIAS_Y);
 370                 if (result)
 371                         goto dmp_bias_store_fail;
 372                 st->input_gyro_dmp_bias[1] = data;
 373                 break;
 374         case ATTR_DMP_GYRO_Z_DMP_BIAS:
 375                 result = write_be32_to_mem(st, data, GYRO_BIAS_Z);
 376                 if (result)
 377                         goto dmp_bias_store_fail;
 378                 st->input_gyro_dmp_bias[2] = data;
 379                 break;
 380         case ATTR_DMP_MAGN_X_DMP_BIAS:
 381                 if (data)
 382                         st->sensor_acurracy_flag[SENSOR_COMPASS_ACCURACY] = 3;
 383                 result = write_be32_to_mem(st, data, CPASS_BIAS_X);
 384                 if (result)
 385                         goto dmp_bias_store_fail;
 386                 st->input_compass_dmp_bias[0] = data;
 387                 break;
 388         case ATTR_DMP_MAGN_Y_DMP_BIAS:
 389                 result = write_be32_to_mem(st, data, CPASS_BIAS_Y);
 390                 if (result)
 391                         goto dmp_bias_store_fail;
 392                 st->input_compass_dmp_bias[1] = data;
 393                 break;
 394         case ATTR_DMP_MAGN_Z_DMP_BIAS:
 395                 result = write_be32_to_mem(st, data, CPASS_BIAS_Z);
 396                 if (result)
 397                         goto dmp_bias_store_fail;
 398                 st->input_compass_dmp_bias[2] = data;
 399                 break;
 400         case ATTR_DMP_MISC_GYRO_RECALIBRATION:
 401                 result = write_be32_to_mem(st, 0, GYRO_LAST_TEMPR);
 402                 if (result)
 403                         goto dmp_bias_store_fail;
 404                 break;
 405         case ATTR_DMP_MISC_ACCEL_RECALIBRATION:
 406         {
 407                 u8 d[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 408                 int i;
 409                 u32 d1[] = {0, 0, 0, 0,
 410                                 0, 0, 0, 0, 0, 0,
 411                                 3276800, 3276800, 3276800, 3276800};
 412                 u32 *w_d;
 413
 414                 if (data) {
 415                         result = inv_write_2bytes(st, ACCEL_CAL_RESET, 1);
 416                         if (result)
 417                                 goto dmp_bias_store_fail;
 418                         result = mem_w(ACCEL_PRE_SENSOR_DATA, ARRAY_SIZE(d), d);
 419                         w_d = d1;
 420                 } else {
 421                         w_d = st->accel_covariance;
 422                 }
 423                 for (i = 0; i < ARRAY_SIZE(d1); i++) {
 424                         result = write_be32_to_mem(st, w_d[i],
 425                                         ACCEL_COVARIANCE + i * sizeof(int));
 426                         if (result)
 427                                 goto dmp_bias_store_fail;
 428                 }
 429
 430                 break;
 431         }
 432         case ATTR_DMP_MISC_COMPASS_RECALIBRATION:
 433         {
 434                 u32 d[] = {0, 0, 0, 0,
 435                                 14745600, 14745600, 14745600, 14745600,
 436                                 0, 0, 0, 0,
 437                                 0, 0};
 438                 int i, *w_d;
 439
 440                 if (data) {
 441                         w_d = d;
 442                 } else {
 443                         w_d = st->compass_covariance;
 444                         for (i = 0; i < ARRAY_SIZE(d); i++) {
 445                                 result = write_be32_to_mem(st,
 446                                                 st->curr_compass_covariance[i],
 447                                                 CPASS_COVARIANCE_CUR +
 448                                                 i * sizeof(int));
 449                                 if (result)
 450                                         goto dmp_bias_store_fail;
 451                         }
 452                         result = write_be32_to_mem(st, st->ref_mag_3d,
 453                                                         CPASS_REF_MAG_3D);
 454                         if (result)
 455                                 goto dmp_bias_store_fail;
 456                 }
 457
 458                 for (i = 0; i < ARRAY_SIZE(d); i++) {
 459                         result = write_be32_to_mem(st, w_d[i],
 460                                 CPASS_COVARIANCE + i * sizeof(int));
 461                         if (result)
 462                                 goto dmp_bias_store_fail;
 463                 }
 464                 break;
 465         }
 466         case ATTR_DMP_PARAMS_ACCEL_CALIBRATION_THRESHOLD:
 467                 result = write_be32_to_mem(st, data, ACCEL_VARIANCE_THRESH);
 468                 if (result)
 469                         goto dmp_bias_store_fail;
 470                 st->accel_calib_threshold = data;
 471                 break;
 472         /* this serves as a divider of calibration rate, 0->225, 3->55 */
 473         case ATTR_DMP_PARAMS_ACCEL_CALIBRATION_RATE:
 474                 if (data < 0)
 475                         data = 0;
 476                 result = inv_write_2bytes(st, ACCEL_CAL_RATE, data);
 477                 if (result)
 478                         goto dmp_bias_store_fail;
 479                 st->accel_calib_rate = data;
 480                 break;
 481         case ATTR_DMP_DEBUG_MEM_READ:
 482                 debug_mem_read_addr = data;
 483                 break;
 484         case ATTR_DMP_DEBUG_MEM_WRITE:
 485                 inv_write_2bytes(st, debug_mem_read_addr, data);
 486                 break;
 487         default:
 488                 break;
 489         }
 490
 491 dmp_bias_store_fail:
 492         if (result)
 493                 return result;
 494         result = inv_switch_power_in_lp(st, false);
 495         if (result)
 496                 return result;
 497
 498         return count;
 499 }
 500
 501 static ssize_t inv_dmp_bias_store(struct device *dev,
 502         struct device_attribute *attr, const char *buf, size_t count)
 503 {
 504         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 505         int result;
 506
 507         mutex_lock(&indio_dev->mlock);
 508         result = _dmp_bias_store(dev, attr, buf, count);
 509         mutex_unlock(&indio_dev->mlock);
 510
 511         return result;
 512 }
 513
 514 static ssize_t inv_debug_store(struct device *dev,
 515         struct device_attribute *attr, const char *buf, size_t count)
 516 {
 517         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 518         struct inv_mpu_state *st = iio_priv(indio_dev);
 519         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 520         int result, data;
 521
 522         result = kstrtoint(buf, 10, &data);
 523         if (result)
 524                 return result;
 525         switch (this_attr->address) {
 526         case ATTR_DMP_LP_EN_OFF:
 527                 st->chip_config.lp_en_mode_off = !!data;
 528                 inv_switch_power_in_lp(st, !!data);
 529                 break;
 530         case ATTR_DMP_CYCLE_MODE_OFF:
 531                 st->chip_config.cycle_mode_off = !!data;
 532                 inv_turn_off_cycle_mode(st, !!data);
 533         case ATTR_DMP_CLK_SEL:
 534                 st->chip_config.clk_sel = !!data;
 535                 inv_switch_power_in_lp(st, !!data);
 536                 break;
 537         case ATTR_DEBUG_REG_ADDR:
 538                 debug_reg_addr = data;
 539                 break;
 540         case ATTR_DEBUG_REG_WRITE:
 541                 inv_plat_single_write(st, debug_reg_addr, data);
 542                 break;
 543         case ATTR_DEBUG_WRITE_CFG:
 544                 break;
 545         }
 546         return count;
 547 }
 548 static ssize_t _misc_attr_store(struct device *dev,
 549         struct device_attribute *attr, const char *buf, size_t count)
 550 {
 551         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 552         struct inv_mpu_state *st = iio_priv(indio_dev);
 553         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 554         int result, data;
 555
 556         if (!st->chip_config.firmware_loaded)
 557                 return -EINVAL;
 558         result = inv_switch_power_in_lp(st, true);
 559         if (result)
 560                 return result;
 561         result = kstrtoint(buf, 10, &data);
 562         if (result)
 563                 return result;
 564         switch (this_attr->address) {
 565         case ATTR_DMP_LOW_POWER_GYRO_ON:
 566                 st->chip_config.low_power_gyro_on = !!data;
 567                 break;
 568         case ATTR_DEBUG_DATA_COLLECTION_MODE:
 569                 st->chip_config.debug_data_collection_mode_on = !!data;
 570                 break;
 571         case ATTR_DEBUG_DATA_COLLECTION_GYRO_RATE:
 572                 st->chip_config.debug_data_collection_gyro_freq = data;
 573                 break;
 574         case ATTR_DEBUG_DATA_COLLECTION_ACCEL_RATE:
 575                 st->chip_config.debug_data_collection_accel_freq = data;
 576                 break;
 577         case ATTR_DMP_REF_MAG_3D:
 578                 st->ref_mag_3d = data;
 579                 return 0;
 580         case ATTR_DMP_DEBUG_DETERMINE_ENGINE_ON:
 581                 st->debug_determine_engine_on = !!data;
 582                 break;
 583         case ATTR_GYRO_SCALE:
 584                 if (data > 3)
 585                         return -EINVAL;
 586                 st->chip_config.fsr = data;
 587                 result = inv_set_gyro_sf(st);
 588
 589                 return result;
 590         case ATTR_ACCEL_SCALE:
 591                 if (data > 3)
 592                         return -EINVAL;
 593                 st->chip_config.accel_fs = data;
 594                 result = inv_set_accel_sf(st);
 595
 596                 return result;
 597         case ATTR_DMP_PED_INT_ON:
 598                 result = inv_write_cntl(st, PEDOMETER_INT_EN << 8, !!data,
 599                                                         MOTION_EVENT_CTL);
 600                 if (result)
 601                         return result;
 602                 st->ped.int_on = !!data;
 603
 604                 return 0;
 605         case ATTR_DMP_PED_STEP_THRESH:
 606                 result = inv_write_2bytes(st, PEDSTD_SB, data);
 607                 if (result)
 608                         return result;
 609                 st->ped.step_thresh = data;
 610
 611                 return 0;
 612         case ATTR_DMP_PED_INT_THRESH:
 613                 result = inv_write_2bytes(st, PEDSTD_SB2, data);
 614                 if (result)
 615                         return result;
 616                 st->ped.int_thresh = data;
 617
 618                 return 0;
 619         case ATTR_DMP_SMD_TIMER_THLD:
 620                 if (data < 0)
 621                         return -EINVAL;
 622                 result = write_be32_to_mem(st, data, SMD_TIMER_THLD);
 623                 if (result)
 624                         return result;
 625                 st->smd.timer_thresh = data;
 626                 return 0;
 627         default:
 628                 return -EINVAL;
 629         }
 630         st->trigger_state = MISC_TRIGGER;
 631         result = set_inv_enable(indio_dev);
 632
 633         return result;
 634 }
 635
 636 /*
 637  * inv_misc_attr_store() -  calling this function will store current
 638  *                        dmp parameter settings
 639  */
 640 static ssize_t inv_misc_attr_store(struct device *dev,
 641         struct device_attribute *attr, const char *buf, size_t count)
 642 {
 643         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 644         int result;
 645
 646         mutex_lock(&indio_dev->mlock);
 647         result = _misc_attr_store(dev, attr, buf, count);
 648         mutex_unlock(&indio_dev->mlock);
 649         if (result)
 650                 return result;
 651
 652         return count;
 653 }
 654
 655 static ssize_t _debug_attr_store(struct device *dev,
 656         struct device_attribute *attr, const char *buf, size_t count)
 657 {
 658         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 659         struct inv_mpu_state *st = iio_priv(indio_dev);
 660         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 661         int result, data;
 662
 663         if (!st->chip_config.firmware_loaded)
 664                 return -EINVAL;
 665         if (!st->debug_determine_engine_on)
 666                 return -EINVAL;
 667
 668         result = kstrtoint(buf, 10, &data);
 669         if (result)
 670                 return result;
 671         switch (this_attr->address) {
 672         case ATTR_DMP_IN_ANGLVEL_ACCURACY_ENABLE:
 673                 st->sensor_accuracy[SENSOR_GYRO_ACCURACY].on = !!data;
 674                 break;
 675         case ATTR_DMP_IN_ACCEL_ACCURACY_ENABLE:
 676                 st->sensor_accuracy[SENSOR_ACCEL_ACCURACY].on = !!data;
 677                 break;
 678         case ATTR_DMP_IN_MAGN_ACCURACY_ENABLE:
 679                 st->sensor_accuracy[SENSOR_COMPASS_ACCURACY].on = !!data;
 680                 break;
 681         case ATTR_DMP_ACCEL_CAL_ENABLE:
 682                 st->accel_cal_enable = !!data;
 683                 break;
 684         case ATTR_DMP_GYRO_CAL_ENABLE:
 685                 st->gyro_cal_enable = !!data;
 686                 break;
 687         case ATTR_DMP_COMPASS_CAL_ENABLE:
 688                 st->compass_cal_enable = !!data;
 689                 break;
 690         case ATTR_DMP_EVENT_INT_ON:
 691                 st->chip_config.dmp_event_int_on = !!data;
 692                 break;
 693         case ATTR_DMP_ON:
 694                 st->chip_config.dmp_on = !!data;
 695                 break;
 696         case ATTR_GYRO_ENABLE:
 697                 st->chip_config.gyro_enable = !!data;
 698                 break;
 699         case ATTR_ACCEL_ENABLE:
 700                 st->chip_config.accel_enable = !!data;
 701                 break;
 702         case ATTR_COMPASS_ENABLE:
 703                 st->chip_config.compass_enable = !!data;
 704                 break;
 705         default:
 706                 return -EINVAL;
 707         }
 708         st->trigger_state = DEBUG_TRIGGER;
 709         result = set_inv_enable(indio_dev);
 710         if (result)
 711                 return result;
 712
 713         return count;
 714 }
 715
 716 /*
 717  * inv_debug_attr_store() -  calling this function will store current
 718  *                        dmp parameter settings
 719  */
 720 static ssize_t inv_debug_attr_store(struct device *dev,
 721         struct device_attribute *attr, const char *buf, size_t count)
 722 {
 723         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 724         int result;
 725
 726         mutex_lock(&indio_dev->mlock);
 727         result = _debug_attr_store(dev, attr, buf, count);
 728         mutex_unlock(&indio_dev->mlock);
 729
 730         return result;
 731 }
 732
 733 static int inv_rate_convert(struct inv_mpu_state *st, int ind, int data)
 734 {
 735         int t, out, out1, out2;
 736
 737         out = MPU_INIT_SENSOR_RATE;
 738         if ((SENSOR_COMPASS == ind) || (SENSOR_CALIB_COMPASS == ind)) {
 739                 if ((MSEC_PER_SEC / st->slave_compass->rate_scale) < data)
 740                         out = MSEC_PER_SEC / st->slave_compass->rate_scale;
 741                 else
 742                         out = data;
 743         } else if (SENSOR_ALS == ind) {
 744                 if (data > MAX_ALS_RATE)
 745                         out = MAX_ALS_RATE;
 746                 else
 747                         out = data;
 748         } else if (SENSOR_PRESSURE == ind) {
 749                 if (data > MAX_PRESSURE_RATE)
 750                         out = MAX_PRESSURE_RATE;
 751                 else
 752                         out = data;
 753         } else {
 754                 t = MPU_DEFAULT_DMP_FREQ / data;
 755                 if (!t)
 756                         t = 1;
 757                 out1 = MPU_DEFAULT_DMP_FREQ / (t + 1);
 758                 out2 = MPU_DEFAULT_DMP_FREQ / t;
 759                 if (abs(out1 - data) < abs(out2 - data))
 760                         out = out1;
 761                 else
 762                         out = out2;
 763         }
 764
 765         return out;
 766 }
 767
 768 static ssize_t inv_sensor_rate_show(struct device *dev,
 769         struct device_attribute *attr, char *buf)
 770 {
 771         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 772         struct inv_mpu_state *st = iio_priv(indio_dev);
 773         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 774
 775         return sprintf(buf, "%d\n", st->sensor[this_attr->address].rate);
 776 }
 777 static ssize_t inv_sensor_rate_store(struct device *dev,
 778         struct device_attribute *attr, const char *buf, size_t count)
 779 {
 780         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 781         struct inv_mpu_state *st = iio_priv(indio_dev);
 782         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 783         int data, rate, ind;
 784         int result;
 785
 786         if (!st->chip_config.firmware_loaded) {
 787                 pr_err("sensor_rate_store: firmware not loaded\n");
 788                 return -EINVAL;
 789         }
 790         result = kstrtoint(buf, 10, &data);
 791         if (result)
 792                 return -EINVAL;
 793         if (data <= 0) {
 794                 pr_err("sensor_rate_store: invalid data=%d\n", data);
 795                 return -EINVAL;
 796         }
 797         ind = this_attr->address;
 798         rate = inv_rate_convert(st, ind, data);
 799         if (rate == st->sensor[ind].rate)
 800                 return count;
 801         mutex_lock(&indio_dev->mlock);
 802         st->sensor[ind].rate = rate;
 803         if (!st->sensor[ind].on) {
 804                 mutex_unlock(&indio_dev->mlock);
 805                 return count;
 806         }
 807
 808         st->trigger_state = DATA_TRIGGER;
 809         result = set_inv_enable(indio_dev);
 810         mutex_unlock(&indio_dev->mlock);
 811         if (result)
 812                 return result;
 813
 814         return count;
 815 }
 816
 817 static ssize_t inv_sensor_on_show(struct device *dev,
 818         struct device_attribute *attr, char *buf)
 819 {
 820         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 821         struct inv_mpu_state *st = iio_priv(indio_dev);
 822         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 823
 824         return sprintf(buf, "%d\n", st->sensor[this_attr->address].on);
 825 }
 826 static ssize_t inv_sensor_on_store(struct device *dev,
 827         struct device_attribute *attr, const char *buf, size_t count)
 828 {
 829         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 830         struct inv_mpu_state *st = iio_priv(indio_dev);
 831         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 832         int data, on, ind;
 833         int result;
 834
 835         if (!st->chip_config.firmware_loaded) {
 836                 pr_err("sensor_on store: firmware not loaded\n");
 837                 return -EINVAL;
 838         }
 839         result = kstrtoint(buf, 10, &data);
 840         if (result)
 841                 return -EINVAL;
 842         if (data < 0) {
 843                 pr_err("sensor_on_store: invalid data=%d\n", data);
 844                 return -EINVAL;
 845         }
 846         ind = this_attr->address;
 847         on = !!data;
 848         if (on == st->sensor[ind].on)
 849                 return count;
 850         mutex_lock(&indio_dev->mlock);
 851         st->sensor[ind].on = on;
 852         if (on && (!st->sensor[ind].rate)) {
 853                 mutex_unlock(&indio_dev->mlock);
 854                 return count;
 855         }
 856         st->trigger_state = RATE_TRIGGER;
 857         result = set_inv_enable(indio_dev);
 858         mutex_unlock(&indio_dev->mlock);
 859         if (result)
 860                 return result;
 861
 862         return count;
 863 }
 864
 865 static ssize_t _basic_attr_store(struct device *dev,
 866         struct device_attribute *attr, const char *buf, size_t count)
 867 {
 868         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 869         struct inv_mpu_state *st = iio_priv(indio_dev);
 870         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 871         int data;
 872         int result;
 873
 874         if (!st->chip_config.firmware_loaded)
 875                 return -EINVAL;
 876         result = kstrtoint(buf, 10, &data);
 877         if (result || (data < 0))
 878                 return -EINVAL;
 879
 880         switch (this_attr->address) {
 881         case ATTR_DMP_PED_ON:
 882                 if ((!!data) == st->ped.on)
 883                         return count;
 884                 st->ped.on = !!data;
 885                 break;
 886         case ATTR_DMP_SMD_ENABLE:
 887                 if ((!!data) == st->smd.on)
 888                         return count;
 889                 st->smd.on = !!data;
 890                 break;
 891         case ATTR_DMP_STEP_DETECTOR_ON:
 892                 if ((!!data) == st->chip_config.step_detector_on)
 893                         return count;
 894                 st->chip_config.step_detector_on = !!data;
 895                 break;
 896         case ATTR_DMP_STEP_INDICATOR_ON:
 897                 if ((!!data) == st->chip_config.step_indicator_on)
 898                         return count;
 899                 st->chip_config.step_indicator_on = !!data;
 900                 break;
 901         case ATTR_DMP_BATCHMODE_TIMEOUT:
 902                 if (data == st->batch.timeout)
 903                         return count;
 904                 st->batch.timeout = data;
 905                 break;
 906         default:
 907                 return -EINVAL;
 908         };
 909
 910         st->trigger_state = EVENT_TRIGGER;
 911         result = set_inv_enable(indio_dev);
 912         if (result)
 913                 return result;
 914
 915         return count;
 916 }
 917
 918 /*
 919  * inv_basic_attr_store() -  calling this function will store current
 920  *                        non-dmp parameter settings
 921  */
 922 static ssize_t inv_basic_attr_store(struct device *dev,
 923         struct device_attribute *attr, const char *buf, size_t count)
 924 {
 925         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 926         int result;
 927
 928         mutex_lock(&indio_dev->mlock);
 929         result = _basic_attr_store(dev, attr, buf, count);
 930
 931         mutex_unlock(&indio_dev->mlock);
 932
 933         return result;
 934 }
 935
 936 /*
 937  * inv_attr_bias_show() -  calling this function will show current
 938  *                        dmp gyro/accel bias.
 939  */
 940 static ssize_t inv_attr_bias_show(struct device *dev,
 941         struct device_attribute *attr, char *buf)
 942 {
 943         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 944         struct inv_mpu_state *st = iio_priv(indio_dev);
 945         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 946         int axes, addr, result, dmp_bias;
 947         int sensor_type;
 948
 949         switch (this_attr->address) {
 950         case ATTR_ANGLVEL_X_CALIBBIAS:
 951                 return sprintf(buf, "%d\n", st->gyro_bias[0]);
 952         case ATTR_ANGLVEL_Y_CALIBBIAS:
 953                 return sprintf(buf, "%d\n", st->gyro_bias[1]);
 954         case ATTR_ANGLVEL_Z_CALIBBIAS:
 955                 return sprintf(buf, "%d\n", st->gyro_bias[2]);
 956         case ATTR_ACCEL_X_CALIBBIAS:
 957                 return sprintf(buf, "%d\n", st->accel_bias[0]);
 958         case ATTR_ACCEL_Y_CALIBBIAS:
 959                 return sprintf(buf, "%d\n", st->accel_bias[1]);
 960         case ATTR_ACCEL_Z_CALIBBIAS:
 961                 return sprintf(buf, "%d\n", st->accel_bias[2]);
 962         case ATTR_DMP_ACCEL_X_DMP_BIAS:
 963                 axes = 0;
 964                 addr = ACCEL_BIAS_X;
 965                 sensor_type = SENSOR_ACCEL;
 966                 break;
 967         case ATTR_DMP_ACCEL_Y_DMP_BIAS:
 968                 axes = 1;
 969                 addr = ACCEL_BIAS_Y;
 970                 sensor_type = SENSOR_ACCEL;
 971                 break;
 972         case ATTR_DMP_ACCEL_Z_DMP_BIAS:
 973                 axes = 2;
 974                 addr = ACCEL_BIAS_Z;
 975                 sensor_type = SENSOR_ACCEL;
 976                 break;
 977         case ATTR_DMP_GYRO_X_DMP_BIAS:
 978                 axes = 0;
 979                 addr = GYRO_BIAS_X;
 980                 sensor_type = SENSOR_GYRO;
 981                 break;
 982         case ATTR_DMP_GYRO_Y_DMP_BIAS:
 983                 axes = 1;
 984                 addr = GYRO_BIAS_Y;
 985                 sensor_type = SENSOR_GYRO;
 986                 break;
 987         case ATTR_DMP_GYRO_Z_DMP_BIAS:
 988                 axes = 2;
 989                 addr = GYRO_BIAS_Z;
 990                 sensor_type = SENSOR_GYRO;
 991                 break;
 992         case ATTR_DMP_MAGN_X_DMP_BIAS:
 993                 axes = 0;
 994                 addr = CPASS_BIAS_X;
 995                 sensor_type = SENSOR_COMPASS;
 996                 break;
 997         case ATTR_DMP_MAGN_Y_DMP_BIAS:
 998                 axes = 1;
 999                 addr = CPASS_BIAS_Y;
1000                 sensor_type = SENSOR_COMPASS;
1001                 break;
1002         case ATTR_DMP_MAGN_Z_DMP_BIAS:
1003                 axes = 2;
1004                 addr = CPASS_BIAS_Z;
1005                 sensor_type = SENSOR_COMPASS;
1006                 break;
1007         default:
1008                 return -EINVAL;
1009         }
1010         result = inv_switch_power_in_lp(st, true);
1011         if (result)
1012                 return result;
1013         result = read_be32_from_mem(st, &dmp_bias, addr);
1014         if (result)
1015                 return result;
1016         inv_switch_power_in_lp(st, false);
1017         if (SENSOR_GYRO == sensor_type)
1018                 st->input_gyro_dmp_bias[axes] = dmp_bias;
1019         else if (SENSOR_ACCEL == sensor_type)
1020                 st->input_accel_dmp_bias[axes] = dmp_bias;
1021         else if (SENSOR_COMPASS == sensor_type)
1022                 st->input_compass_dmp_bias[axes] = dmp_bias;
1023         else
1024                 return -EINVAL;
1025
1026         return sprintf(buf, "%d\n", dmp_bias);
1027 }
1028
1029 /*
1030  * inv_attr_show() -  calling this function will show current
1031  *                        dmp parameters.
1032  */
1033 static ssize_t inv_attr_show(struct device *dev,
1034         struct device_attribute *attr, char *buf)
1035 {
1036         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1037         struct inv_mpu_state *st = iio_priv(indio_dev);
1038         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
1039         int result;
1040         s8 *m;
1041
1042         switch (this_attr->address) {
1043         case ATTR_GYRO_SCALE:
1044         {
1045                 const s16 gyro_scale[] = {250, 500, 1000, 2000};
1046
1047                 return sprintf(buf, "%d\n", gyro_scale[st->chip_config.fsr]);
1048         }
1049         case ATTR_ACCEL_SCALE:
1050         {
1051                 const s16 accel_scale[] = {2, 4, 8, 16};
1052                 return sprintf(buf, "%d\n",
1053                                         accel_scale[st->chip_config.accel_fs]);
1054         }
1055         case ATTR_COMPASS_SCALE:
1056                 st->slave_compass->get_scale(st, &result);
1057
1058                 return sprintf(buf, "%d\n", result);
1059         case ATTR_GYRO_ENABLE:
1060                 return sprintf(buf, "%d\n", st->chip_config.gyro_enable);
1061         case ATTR_ACCEL_ENABLE:
1062                 return sprintf(buf, "%d\n", st->chip_config.accel_enable);
1063         case ATTR_DMP_ACCEL_CAL_ENABLE:
1064                 return sprintf(buf, "%d\n", st->accel_cal_enable);
1065         case ATTR_DMP_GYRO_CAL_ENABLE:
1066                 return sprintf(buf, "%d\n", st->gyro_cal_enable);
1067         case ATTR_DMP_COMPASS_CAL_ENABLE:
1068                 return sprintf(buf, "%d\n", st->compass_cal_enable);
1069         case ATTR_DMP_DEBUG_DETERMINE_ENGINE_ON:
1070                 return sprintf(buf, "%d\n", st->debug_determine_engine_on);
1071         case ATTR_DMP_PARAMS_ACCEL_CALIBRATION_THRESHOLD:
1072                 return sprintf(buf, "%d\n", st->accel_calib_threshold);
1073         case ATTR_DMP_PARAMS_ACCEL_CALIBRATION_RATE:
1074                 return sprintf(buf, "%d\n", st->accel_calib_rate);
1075         case ATTR_FIRMWARE_LOADED:
1076                 return sprintf(buf, "%d\n", st->chip_config.firmware_loaded);
1077         case ATTR_DMP_ON:
1078                 return sprintf(buf, "%d\n", st->chip_config.dmp_on);
1079         case ATTR_DMP_BATCHMODE_TIMEOUT:
1080                 return sprintf(buf, "%d\n", st->batch.timeout);
1081         case ATTR_DMP_EVENT_INT_ON:
1082                 return sprintf(buf, "%d\n", st->chip_config.dmp_event_int_on);
1083         case ATTR_DMP_PED_INT_ON:
1084                 return sprintf(buf, "%d\n", st->ped.int_on);
1085         case ATTR_DMP_PED_ON:
1086                 return sprintf(buf, "%d\n", st->ped.on);
1087         case ATTR_DMP_PED_STEP_THRESH:
1088                 return sprintf(buf, "%d\n", st->ped.step_thresh);
1089         case ATTR_DMP_PED_INT_THRESH:
1090                 return sprintf(buf, "%d\n", st->ped.int_thresh);
1091         case ATTR_DMP_SMD_ENABLE:
1092                 return sprintf(buf, "%d\n", st->smd.on);
1093         case ATTR_DMP_SMD_TIMER_THLD:
1094                 return sprintf(buf, "%d\n", st->smd.timer_thresh);
1095         case ATTR_DMP_LOW_POWER_GYRO_ON:
1096                 return sprintf(buf, "%d\n", st->chip_config.low_power_gyro_on);
1097         case ATTR_DEBUG_DATA_COLLECTION_MODE:
1098                 return sprintf(buf, "%d\n",
1099                                 st->chip_config.debug_data_collection_mode_on);
1100         case ATTR_DEBUG_DATA_COLLECTION_GYRO_RATE:
1101                 return sprintf(buf, "%d\n",
1102                         st->chip_config.debug_data_collection_gyro_freq);
1103         case ATTR_DEBUG_DATA_COLLECTION_ACCEL_RATE:
1104                 return sprintf(buf, "%d\n",
1105                         st->chip_config.debug_data_collection_accel_freq);
1106         case ATTR_DMP_LP_EN_OFF:
1107                 return sprintf(buf, "%d\n", st->chip_config.lp_en_mode_off);
1108         case ATTR_DMP_CYCLE_MODE_OFF:
1109                 return sprintf(buf, "%d\n", st->chip_config.cycle_mode_off);
1110         case ATTR_COMPASS_ENABLE:
1111                 return sprintf(buf, "%d\n", st->chip_config.compass_enable);
1112         case ATTR_DMP_STEP_INDICATOR_ON:
1113                 return sprintf(buf, "%d\n", st->chip_config.step_indicator_on);
1114         case ATTR_DMP_STEP_DETECTOR_ON:
1115                 return sprintf(buf, "%d\n", st->chip_config.step_detector_on);
1116         case ATTR_DMP_IN_ANGLVEL_ACCURACY_ENABLE:
1117                 return sprintf(buf, "%d\n",
1118                                 st->sensor_accuracy[SENSOR_GYRO_ACCURACY].on);
1119         case ATTR_DMP_IN_ACCEL_ACCURACY_ENABLE:
1120                 return sprintf(buf, "%d\n",
1121                                 st->sensor_accuracy[SENSOR_ACCEL_ACCURACY].on);
1122         case ATTR_DMP_IN_MAGN_ACCURACY_ENABLE:
1123                 return sprintf(buf, "%d\n",
1124                         st->sensor_accuracy[SENSOR_COMPASS_ACCURACY].on);
1125         case ATTR_GYRO_MATRIX:
1126                 m = st->plat_data.orientation;
1127                 return sprintf(buf, "%d,%d,%d,%d,%d,%d,%d,%d,%d\n",
1128                         m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8]);
1129         case ATTR_ACCEL_MATRIX:
1130                 m = st->plat_data.orientation;
1131                 return sprintf(buf, "%d,%d,%d,%d,%d,%d,%d,%d,%d\n",
1132                         m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8]);
1133         case ATTR_COMPASS_MATRIX:
1134                 if (st->plat_data.sec_slave_type ==
1135                                 SECONDARY_SLAVE_TYPE_COMPASS)
1136                         m =
1137                         st->plat_data.secondary_orientation;
1138                 else
1139                         return -ENODEV;
1140                 return sprintf(buf, "%d,%d,%d,%d,%d,%d,%d,%d,%d\n",
1141                         m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8]);
1142         case ATTR_SECONDARY_NAME:
1143         {
1144                 const char *n[] = {"NULL", "AK8975", "AK8972", "AK8963",
1145                                         "MLX90399", "AK09911", "AK09912"};
1146
1147                 switch (st->plat_data.sec_slave_id) {
1148                 case COMPASS_ID_AK8975:
1149                         return sprintf(buf, "%s\n", n[1]);
1150                 case COMPASS_ID_AK8972:
1151                         return sprintf(buf, "%s\n", n[2]);
1152                 case COMPASS_ID_AK8963:
1153                         return sprintf(buf, "%s\n", n[3]);
1154                 case COMPASS_ID_MLX90399:
1155                         return sprintf(buf, "%s\n", n[4]);
1156                 case COMPASS_ID_AK09911:
1157                         return sprintf(buf, "%s\n", n[5]);
1158                 case COMPASS_ID_AK09912:
1159                         return sprintf(buf, "%s\n", n[6]);
1160                 default:
1161                         return sprintf(buf, "%s\n", n[0]);
1162                 }
1163         }
1164         case ATTR_DMP_REF_MAG_3D:
1165         {
1166                 int out;
1167                 inv_switch_power_in_lp(st, true);
1168                 result = read_be32_from_mem(st, &out, CPASS_REF_MAG_3D);
1169                 if (result)
1170                         return result;
1171                 inv_switch_power_in_lp(st, false);
1172                 return sprintf(buf, "%d\n", out);
1173         }
1174         case ATTR_DMP_DEBUG_MEM_READ:
1175         {
1176                 int out;
1177
1178                 inv_switch_power_in_lp(st, true);
1179                 result = read_be32_from_mem(st, &out, debug_mem_read_addr);
1180                 if (result)
1181                         return result;
1182                 inv_switch_power_in_lp(st, false);
1183                 return sprintf(buf, "0x%x\n", out);
1184         }
1185         case ATTR_GYRO_SF:
1186                 return sprintf(buf, "%d\n", st->gyro_sf);
1187         default:
1188                 return -EPERM;
1189         }
1190 }
1191
1192 static ssize_t inv_attr64_show(struct device *dev,
1193         struct device_attribute *attr, char *buf)
1194 {
1195         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1196         struct inv_mpu_state *st = iio_priv(indio_dev);
1197         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
1198         int result;
1199         u64 tmp;
1200         u32 ped;
1201
1202         mutex_lock(&indio_dev->mlock);
1203         if (!st->chip_config.dmp_on) {
1204                 mutex_unlock(&indio_dev->mlock);
1205                 return -EINVAL;
1206         }
1207         result = 0;
1208         switch (this_attr->address) {
1209         case ATTR_DMP_PEDOMETER_STEPS:
1210                 inv_switch_power_in_lp(st, true);
1211                 result = inv_get_pedometer_steps(st, &ped);
1212                 result |= inv_read_pedometer_counter(st);
1213                 tmp = (u64)st->ped.step + (u64)ped;
1214                 inv_switch_power_in_lp(st, false);
1215                 break;
1216         case ATTR_DMP_PEDOMETER_TIME:
1217                 inv_switch_power_in_lp(st, true);
1218                 result = inv_get_pedometer_time(st, &ped);
1219                 tmp = (u64)st->ped.time + ((u64)ped) * MS_PER_PED_TICKS;
1220                 inv_switch_power_in_lp(st, false);
1221                 break;
1222         case ATTR_DMP_PEDOMETER_COUNTER:
1223                 tmp = st->ped.last_step_time;
1224                 break;
1225         default:
1226                 tmp = 0;
1227                 result = -EINVAL;
1228                 break;
1229         }
1230
1231         mutex_unlock(&indio_dev->mlock);
1232         if (result)
1233                 return -EINVAL;
1234         return sprintf(buf, "%lld\n", tmp);
1235 }
1236
1237 static ssize_t inv_attr64_store(struct device *dev,
1238         struct device_attribute *attr, const char *buf, size_t count)
1239 {
1240         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1241         struct inv_mpu_state *st = iio_priv(indio_dev);
1242         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
1243         int result;
1244         u8 d[4] = {0, 0, 0, 0};
1245         u64 data;
1246
1247         mutex_lock(&indio_dev->mlock);
1248         if (!st->chip_config.firmware_loaded) {
1249                 mutex_unlock(&indio_dev->mlock);
1250                 return -EINVAL;
1251         }
1252         result = inv_switch_power_in_lp(st, true);
1253         if (result) {
1254                 mutex_unlock(&indio_dev->mlock);
1255                 return result;
1256         }
1257         result = kstrtoull(buf, 10, &data);
1258         if (result)
1259                 goto attr64_store_fail;
1260         switch (this_attr->address) {
1261         case ATTR_DMP_PEDOMETER_STEPS:
1262                 result = mem_w(PEDSTD_STEPCTR, ARRAY_SIZE(d), d);
1263                 if (result)
1264                         goto attr64_store_fail;
1265                 st->ped.step = data;
1266                 break;
1267         case ATTR_DMP_PEDOMETER_TIME:
1268                 result = mem_w(PEDSTD_TIMECTR, ARRAY_SIZE(d), d);
1269                 if (result)
1270                         goto attr64_store_fail;
1271                 st->ped.time = data;
1272                 break;
1273         default:
1274                 result = -EINVAL;
1275                 break;
1276         }
1277 attr64_store_fail:
1278         mutex_unlock(&indio_dev->mlock);
1279         result = inv_switch_power_in_lp(st, false);
1280         if (result)
1281                 return result;
1282
1283         return count;
1284 }
1285
1286 static ssize_t inv_self_test(struct device *dev,
1287                                 struct device_attribute *attr, char *buf)
1288 {
1289         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1290         struct inv_mpu_state *st = iio_priv(indio_dev);
1291         int res;
1292
1293         mutex_lock(&indio_dev->mlock);
1294         res = inv_hw_self_test(st);
1295         set_inv_enable(indio_dev);
1296         mutex_unlock(&indio_dev->mlock);
1297
1298         return sprintf(buf, "%d\n", res);
1299 }
1300
1301 /*
1302  *  inv_temperature_show() - Read temperature data directly from registers.
1303  */
1304 static ssize_t inv_temperature_show(struct device *dev,
1305         struct device_attribute *attr, char *buf)
1306 {
1307
1308         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1309         struct inv_mpu_state *st = iio_priv(indio_dev);
1310         int result, scale_t;
1311         short temp;
1312         u8 data[2];
1313
1314         mutex_lock(&indio_dev->mlock);
1315         result = inv_switch_power_in_lp(st, true);
1316         if (result) {
1317                 mutex_unlock(&indio_dev->mlock);
1318                 return result;
1319         }
1320
1321         result = inv_plat_read(st, REG_TEMPERATURE, 2, data);
1322         mutex_unlock(&indio_dev->mlock);
1323         if (result) {
1324                 pr_err("Could not read temperature register.\n");
1325                 return result;
1326         }
1327         result = inv_switch_power_in_lp(st, false);
1328         if (result)
1329                 return result;
1330         temp = (s16)(be16_to_cpup((short *)&data[0]));
1331         scale_t = TEMPERATURE_OFFSET +
1332                 inv_q30_mult((int)temp << MPU_TEMP_SHIFT, TEMPERATURE_SCALE);
1333
1334         INV_I2C_INC_TEMPREAD(1);
1335
1336         return sprintf(buf, "%d %lld\n", scale_t, get_time_ns());
1337 }
1338
1339 /*
1340  * inv_smd_show() -  calling this function showes smd interrupt.
1341  *                         This event must use poll.
1342  */
1343 static ssize_t inv_smd_show(struct device *dev,
1344         struct device_attribute *attr, char *buf)
1345 {
1346         return sprintf(buf, "1\n");
1347 }
1348
1349 /*
1350  * inv_ped_show() -  calling this function showes pedometer interrupt.
1351  *                         This event must use poll.
1352  */
1353 static ssize_t inv_ped_show(struct device *dev,
1354         struct device_attribute *attr, char *buf)
1355 {
1356         return sprintf(buf, "1\n");
1357 }
1358
1359 /*
1360  *  inv_reg_dump_show() - Register dump for testing.
1361  */
1362 static ssize_t inv_reg_dump_show(struct device *dev,
1363         struct device_attribute *attr, char *buf)
1364 {
1365         int ii;
1366         char data;
1367         ssize_t bytes_printed = 0;
1368         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1369         struct inv_mpu_state *st = iio_priv(indio_dev);
1370
1371         mutex_lock(&indio_dev->mlock);
1372         inv_set_bank(st, BANK_SEL_0);
1373         bytes_printed += sprintf(buf + bytes_printed, "bank 0\n");
1374
1375         for (ii = 0; ii < 0x7F; ii++) {
1376                 /* don't read fifo r/w register */
1377                 if ((ii == REG_MEM_R_W) || (ii == REG_FIFO_R_W))
1378                         data = 0;
1379                 else
1380                         inv_plat_read(st, ii, 1, &data);
1381                 bytes_printed += sprintf(buf + bytes_printed, "%#2x: %#2x\n",
1382                                          ii, data);
1383         }
1384         inv_set_bank(st, BANK_SEL_1);
1385         bytes_printed += sprintf(buf + bytes_printed, "bank 1\n");
1386         for (ii = 0; ii < 0x2A; ii++) {
1387                 inv_plat_read(st, ii, 1, &data);
1388                 bytes_printed += sprintf(buf + bytes_printed, "%#2x: %#2x\n",
1389                                          ii, data);
1390         }
1391         inv_set_bank(st, BANK_SEL_2);
1392         bytes_printed += sprintf(buf + bytes_printed, "bank 2\n");
1393         for (ii = 0; ii < 0x55; ii++) {
1394                 inv_plat_read(st, ii, 1, &data);
1395                 bytes_printed += sprintf(buf + bytes_printed, "%#2x: %#2x\n",
1396                                          ii, data);
1397         }
1398         inv_set_bank(st, BANK_SEL_3);
1399         bytes_printed += sprintf(buf + bytes_printed, "bank 3\n");
1400         for (ii = 0; ii < 0x18; ii++) {
1401                 inv_plat_read(st, ii, 1, &data);
1402                 bytes_printed += sprintf(buf + bytes_printed, "%#2x: %#2x\n",
1403                                          ii, data);
1404         }
1405         inv_set_bank(st, BANK_SEL_0);
1406         set_inv_enable(indio_dev);
1407         mutex_unlock(&indio_dev->mlock);
1408
1409         return bytes_printed;
1410 }
1411
1412 static ssize_t inv_flush_batch_show(struct device *dev,
1413         struct device_attribute *attr, char *buf)
1414 {
1415         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1416         int result;
1417         bool has_data;
1418
1419         mutex_lock(&indio_dev->mlock);
1420         result = inv_flush_batch_data(indio_dev, &has_data);
1421         mutex_unlock(&indio_dev->mlock);
1422         if (result)
1423                 return sprintf(buf, "%d\n", result);
1424         else
1425                 return sprintf(buf, "%d\n", has_data);
1426 }
1427
1428 static const struct iio_chan_spec inv_mpu_channels[] = {
1429         IIO_CHAN_SOFT_TIMESTAMP(INV_MPU_SCAN_TIMESTAMP),
1430 };
1431
1432 static DEVICE_ATTR(poll_smd, S_IRUGO, inv_smd_show, NULL);
1433 static DEVICE_ATTR(poll_pedometer, S_IRUGO, inv_ped_show, NULL);
1434
1435 /* special run time sysfs entry, read only */
1436 static DEVICE_ATTR(misc_flush_batch, S_IRUGO, inv_flush_batch_show, NULL);
1437
1438 static DEVICE_ATTR(debug_reg_dump, S_IRUGO | S_IWUGO, inv_reg_dump_show, NULL);
1439 static DEVICE_ATTR(out_temperature, S_IRUGO | S_IWUGO,
1440                                                 inv_temperature_show, NULL);
1441 static DEVICE_ATTR(misc_self_test, S_IRUGO | S_IWUGO, inv_self_test, NULL);
1442
1443 static IIO_DEVICE_ATTR(info_anglvel_matrix, S_IRUGO, inv_attr_show, NULL,
1444         ATTR_GYRO_MATRIX);
1445 static IIO_DEVICE_ATTR(info_accel_matrix, S_IRUGO, inv_attr_show, NULL,
1446         ATTR_ACCEL_MATRIX);
1447 static IIO_DEVICE_ATTR(info_magn_matrix, S_IRUGO, inv_attr_show, NULL,
1448         ATTR_COMPASS_MATRIX);
1449 static IIO_DEVICE_ATTR(info_secondary_name, S_IRUGO, inv_attr_show, NULL,
1450         ATTR_SECONDARY_NAME);
1451 static IIO_DEVICE_ATTR(info_gyro_sf, S_IRUGO, inv_attr_show, NULL,
1452                                                 ATTR_GYRO_SF);
1453
1454 /* sensor on/off sysfs control */
1455 static IIO_DEVICE_ATTR(in_accel_enable, S_IRUGO | S_IWUGO,
1456                 inv_sensor_on_show, inv_sensor_on_store, SENSOR_ACCEL);
1457 static IIO_DEVICE_ATTR(in_anglvel_enable, S_IRUGO | S_IWUGO,
1458                 inv_sensor_on_show, inv_sensor_on_store, SENSOR_GYRO);
1459 static IIO_DEVICE_ATTR(in_magn_enable, S_IRUGO | S_IWUGO,
1460                 inv_sensor_on_show, inv_sensor_on_store, SENSOR_COMPASS);
1461 static IIO_DEVICE_ATTR(in_6quat_enable, S_IRUGO | S_IWUGO,
1462                 inv_sensor_on_show, inv_sensor_on_store, SENSOR_SIXQ);
1463 static IIO_DEVICE_ATTR(in_9quat_enable, S_IRUGO | S_IWUGO,
1464                 inv_sensor_on_show, inv_sensor_on_store, SENSOR_NINEQ);
1465 static IIO_DEVICE_ATTR(in_geomag_enable, S_IRUGO | S_IWUGO,
1466                 inv_sensor_on_show, inv_sensor_on_store, SENSOR_GEOMAG);
1467 static IIO_DEVICE_ATTR(in_p6quat_enable, S_IRUGO | S_IWUGO,
1468                 inv_sensor_on_show, inv_sensor_on_store, SENSOR_PEDQ);
1469 static IIO_DEVICE_ATTR(in_pressure_enable, S_IRUGO | S_IWUGO,
1470                 inv_sensor_on_show, inv_sensor_on_store, SENSOR_PRESSURE);
1471 static IIO_DEVICE_ATTR(in_als_px_enable, S_IRUGO | S_IWUGO,
1472                 inv_sensor_on_show, inv_sensor_on_store, SENSOR_ALS);
1473 static IIO_DEVICE_ATTR(in_calib_anglvel_enable, S_IRUGO | S_IWUGO,
1474                 inv_sensor_on_show, inv_sensor_on_store, SENSOR_CALIB_GYRO);
1475 static IIO_DEVICE_ATTR(in_calib_magn_enable, S_IRUGO | S_IWUGO,
1476                 inv_sensor_on_show, inv_sensor_on_store, SENSOR_CALIB_COMPASS);
1477
1478 /* sensor rate sysfs control */
1479 static IIO_DEVICE_ATTR(in_accel_rate, S_IRUGO | S_IWUGO,
1480         inv_sensor_rate_show, inv_sensor_rate_store, SENSOR_ACCEL);
1481 static IIO_DEVICE_ATTR(in_anglvel_rate, S_IRUGO | S_IWUGO,
1482         inv_sensor_rate_show, inv_sensor_rate_store, SENSOR_GYRO);
1483 static IIO_DEVICE_ATTR(in_magn_rate, S_IRUGO | S_IWUGO,
1484         inv_sensor_rate_show, inv_sensor_rate_store, SENSOR_COMPASS);
1485 static IIO_DEVICE_ATTR(in_6quat_rate, S_IRUGO | S_IWUGO,
1486         inv_sensor_rate_show, inv_sensor_rate_store, SENSOR_SIXQ);
1487 static IIO_DEVICE_ATTR(in_9quat_rate, S_IRUGO | S_IWUGO,
1488         inv_sensor_rate_show, inv_sensor_rate_store, SENSOR_NINEQ);
1489 static IIO_DEVICE_ATTR(in_geomag_rate, S_IRUGO | S_IWUGO,
1490         inv_sensor_rate_show, inv_sensor_rate_store, SENSOR_GEOMAG);
1491 static IIO_DEVICE_ATTR(in_p6quat_rate, S_IRUGO | S_IWUGO,
1492         inv_sensor_rate_show, inv_sensor_rate_store, SENSOR_PEDQ);
1493 static IIO_DEVICE_ATTR(in_pressure_rate, S_IRUGO | S_IWUGO,
1494         inv_sensor_rate_show, inv_sensor_rate_store, SENSOR_PRESSURE);
1495 static IIO_DEVICE_ATTR(in_als_px_rate, S_IRUGO | S_IWUGO,
1496         inv_sensor_rate_show, inv_sensor_rate_store, SENSOR_ALS);
1497 static IIO_DEVICE_ATTR(in_calib_anglvel_rate, S_IRUGO | S_IWUGO,
1498         inv_sensor_rate_show, inv_sensor_rate_store, SENSOR_CALIB_GYRO);
1499 static IIO_DEVICE_ATTR(in_calib_magn_rate, S_IRUGO | S_IWUGO,
1500         inv_sensor_rate_show, inv_sensor_rate_store, SENSOR_CALIB_COMPASS);
1501
1502 /* debug determine engine related sysfs */
1503 static IIO_DEVICE_ATTR(debug_anglvel_accuracy_enable, S_IRUGO | S_IWUGO,
1504                                 inv_attr_show, inv_debug_attr_store,
1505                                 ATTR_DMP_IN_ANGLVEL_ACCURACY_ENABLE);
1506 static IIO_DEVICE_ATTR(debug_accel_accuracy_enable, S_IRUGO | S_IWUGO,
1507         inv_attr_show, inv_debug_attr_store, ATTR_DMP_IN_ACCEL_ACCURACY_ENABLE);
1508 static IIO_DEVICE_ATTR(debug_magn_accuracy_enable, S_IRUGO | S_IWUGO,
1509         inv_attr_show, inv_debug_attr_store, ATTR_DMP_IN_MAGN_ACCURACY_ENABLE);
1510 static IIO_DEVICE_ATTR(debug_gyro_cal_enable, S_IRUGO | S_IWUGO,
1511         inv_attr_show, inv_debug_attr_store, ATTR_DMP_GYRO_CAL_ENABLE);
1512 static IIO_DEVICE_ATTR(debug_accel_cal_enable, S_IRUGO | S_IWUGO,
1513         inv_attr_show, inv_debug_attr_store, ATTR_DMP_ACCEL_CAL_ENABLE);
1514 static IIO_DEVICE_ATTR(debug_compass_cal_enable, S_IRUGO | S_IWUGO,
1515         inv_attr_show, inv_debug_attr_store, ATTR_DMP_COMPASS_CAL_ENABLE);
1516 static IIO_DEVICE_ATTR(misc_magn_recalibration, S_IRUGO | S_IWUGO, NULL,
1517         inv_dmp_bias_store, ATTR_DMP_MISC_COMPASS_RECALIBRATION);
1518 static IIO_DEVICE_ATTR(misc_ref_mag_3d, S_IRUGO | S_IWUGO,
1519                 inv_attr_show, inv_misc_attr_store, ATTR_DMP_REF_MAG_3D);
1520
1521 static IIO_DEVICE_ATTR(debug_gyro_enable, S_IRUGO | S_IWUGO,
1522         inv_attr_show, inv_debug_attr_store, ATTR_GYRO_ENABLE);
1523 static IIO_DEVICE_ATTR(debug_accel_enable, S_IRUGO | S_IWUGO,
1524         inv_attr_show, inv_debug_attr_store, ATTR_ACCEL_ENABLE);
1525 static IIO_DEVICE_ATTR(debug_compass_enable, S_IRUGO | S_IWUGO,
1526         inv_attr_show, inv_debug_attr_store, ATTR_COMPASS_ENABLE);
1527 static IIO_DEVICE_ATTR(debug_dmp_on, S_IRUGO | S_IWUGO,
1528         inv_attr_show, inv_debug_attr_store, ATTR_DMP_ON);
1529 static IIO_DEVICE_ATTR(debug_dmp_event_int_on, S_IRUGO | S_IWUGO,
1530         inv_attr_show, inv_debug_attr_store, ATTR_DMP_EVENT_INT_ON);
1531 static IIO_DEVICE_ATTR(debug_mem_read, S_IRUGO | S_IWUGO,
1532         inv_attr_show, inv_dmp_bias_store, ATTR_DMP_DEBUG_MEM_READ);
1533 static IIO_DEVICE_ATTR(debug_mem_write, S_IRUGO | S_IWUGO,
1534         inv_attr_show, inv_dmp_bias_store, ATTR_DMP_DEBUG_MEM_WRITE);
1535
1536 static IIO_DEVICE_ATTR(misc_batchmode_timeout, S_IRUGO | S_IWUGO,
1537         inv_attr_show, inv_basic_attr_store, ATTR_DMP_BATCHMODE_TIMEOUT);
1538
1539 static IIO_DEVICE_ATTR(info_firmware_loaded, S_IRUGO | S_IWUGO, inv_attr_show,
1540         inv_firmware_loaded_store, ATTR_FIRMWARE_LOADED);
1541
1542 /* engine scale */
1543 static IIO_DEVICE_ATTR(in_accel_scale, S_IRUGO | S_IWUGO, inv_attr_show,
1544         inv_misc_attr_store, ATTR_ACCEL_SCALE);
1545 static IIO_DEVICE_ATTR(in_anglvel_scale, S_IRUGO | S_IWUGO, inv_attr_show,
1546         inv_misc_attr_store, ATTR_GYRO_SCALE);
1547 static IIO_DEVICE_ATTR(in_magn_scale, S_IRUGO | S_IWUGO, inv_attr_show,
1548         NULL, ATTR_COMPASS_SCALE);
1549
1550 static IIO_DEVICE_ATTR(debug_low_power_gyro_on, S_IRUGO | S_IWUGO,
1551         inv_attr_show, inv_misc_attr_store, ATTR_DMP_LOW_POWER_GYRO_ON);
1552 static IIO_DEVICE_ATTR(debug_lp_en_off, S_IRUGO | S_IWUGO,
1553         inv_attr_show, inv_debug_store, ATTR_DMP_LP_EN_OFF);
1554 static IIO_DEVICE_ATTR(debug_cycle_mode_off, S_IRUGO | S_IWUGO,
1555         inv_attr_show, inv_debug_store, ATTR_DMP_CYCLE_MODE_OFF);
1556 static IIO_DEVICE_ATTR(debug_clock_sel, S_IRUGO | S_IWUGO,
1557         inv_attr_show, inv_debug_store, ATTR_DMP_CLK_SEL);
1558 static IIO_DEVICE_ATTR(debug_reg_write, S_IRUGO | S_IWUGO,
1559         inv_attr_show, inv_debug_store, ATTR_DEBUG_REG_WRITE);
1560 static IIO_DEVICE_ATTR(debug_cfg_write, S_IRUGO | S_IWUGO,
1561         inv_attr_show, inv_debug_store, ATTR_DEBUG_WRITE_CFG);
1562 static IIO_DEVICE_ATTR(debug_reg_write_addr, S_IRUGO | S_IWUGO,
1563         inv_attr_show, inv_debug_store, ATTR_DEBUG_REG_ADDR);
1564 static IIO_DEVICE_ATTR(debug_data_collection_mode_on, S_IRUGO | S_IWUGO,
1565         inv_attr_show, inv_misc_attr_store, ATTR_DEBUG_DATA_COLLECTION_MODE);
1566 static IIO_DEVICE_ATTR(debug_data_collection_mode_gyro_rate, S_IRUGO | S_IWUGO,
1567         inv_attr_show, inv_misc_attr_store,
1568         ATTR_DEBUG_DATA_COLLECTION_GYRO_RATE);
1569 static IIO_DEVICE_ATTR(debug_data_collection_mode_accel_rate, S_IRUGO | S_IWUGO,
1570         inv_attr_show, inv_misc_attr_store,
1571         ATTR_DEBUG_DATA_COLLECTION_ACCEL_RATE);
1572
1573 static IIO_DEVICE_ATTR(in_accel_x_calibbias, S_IRUGO | S_IWUGO,
1574                         inv_attr_bias_show, NULL, ATTR_ACCEL_X_CALIBBIAS);
1575 static IIO_DEVICE_ATTR(in_accel_y_calibbias, S_IRUGO | S_IWUGO,
1576                         inv_attr_bias_show, NULL, ATTR_ACCEL_Y_CALIBBIAS);
1577 static IIO_DEVICE_ATTR(in_accel_z_calibbias, S_IRUGO | S_IWUGO,
1578                         inv_attr_bias_show, NULL, ATTR_ACCEL_Z_CALIBBIAS);
1579
1580 static IIO_DEVICE_ATTR(in_anglvel_x_calibbias, S_IRUGO | S_IWUGO,
1581                         inv_attr_bias_show, NULL, ATTR_ANGLVEL_X_CALIBBIAS);
1582 static IIO_DEVICE_ATTR(in_anglvel_y_calibbias, S_IRUGO | S_IWUGO,
1583                         inv_attr_bias_show, NULL, ATTR_ANGLVEL_Y_CALIBBIAS);
1584 static IIO_DEVICE_ATTR(in_anglvel_z_calibbias, S_IRUGO | S_IWUGO,
1585                         inv_attr_bias_show, NULL, ATTR_ANGLVEL_Z_CALIBBIAS);
1586
1587 static IIO_DEVICE_ATTR(in_accel_x_dmp_bias, S_IRUGO | S_IWUGO,
1588         inv_attr_bias_show, inv_dmp_bias_store, ATTR_DMP_ACCEL_X_DMP_BIAS);
1589 static IIO_DEVICE_ATTR(in_accel_y_dmp_bias, S_IRUGO | S_IWUGO,
1590         inv_attr_bias_show, inv_dmp_bias_store, ATTR_DMP_ACCEL_Y_DMP_BIAS);
1591 static IIO_DEVICE_ATTR(in_accel_z_dmp_bias, S_IRUGO | S_IWUGO,
1592         inv_attr_bias_show, inv_dmp_bias_store, ATTR_DMP_ACCEL_Z_DMP_BIAS);
1593
1594 static IIO_DEVICE_ATTR(in_anglvel_x_dmp_bias, S_IRUGO | S_IWUGO,
1595         inv_attr_bias_show, inv_dmp_bias_store, ATTR_DMP_GYRO_X_DMP_BIAS);
1596 static IIO_DEVICE_ATTR(in_anglvel_y_dmp_bias, S_IRUGO | S_IWUGO,
1597         inv_attr_bias_show, inv_dmp_bias_store, ATTR_DMP_GYRO_Y_DMP_BIAS);
1598 static IIO_DEVICE_ATTR(in_anglvel_z_dmp_bias, S_IRUGO | S_IWUGO,
1599         inv_attr_bias_show, inv_dmp_bias_store, ATTR_DMP_GYRO_Z_DMP_BIAS);
1600
1601 static IIO_DEVICE_ATTR(in_magn_x_dmp_bias, S_IRUGO | S_IWUGO,
1602         inv_attr_bias_show, inv_dmp_bias_store, ATTR_DMP_MAGN_X_DMP_BIAS);
1603 static IIO_DEVICE_ATTR(in_magn_y_dmp_bias, S_IRUGO | S_IWUGO,
1604         inv_attr_bias_show, inv_dmp_bias_store, ATTR_DMP_MAGN_Y_DMP_BIAS);
1605 static IIO_DEVICE_ATTR(in_magn_z_dmp_bias, S_IRUGO | S_IWUGO,
1606         inv_attr_bias_show, inv_dmp_bias_store, ATTR_DMP_MAGN_Z_DMP_BIAS);
1607
1608 static IIO_DEVICE_ATTR(debug_determine_engine_on, S_IRUGO | S_IWUGO,
1609         inv_attr_show, inv_misc_attr_store, ATTR_DMP_DEBUG_DETERMINE_ENGINE_ON);
1610 static IIO_DEVICE_ATTR(misc_gyro_recalibration, S_IRUGO | S_IWUGO, NULL,
1611         inv_dmp_bias_store, ATTR_DMP_MISC_GYRO_RECALIBRATION);
1612 static IIO_DEVICE_ATTR(misc_accel_recalibration, S_IRUGO | S_IWUGO, NULL,
1613         inv_dmp_bias_store, ATTR_DMP_MISC_ACCEL_RECALIBRATION);
1614 static IIO_DEVICE_ATTR(params_accel_calibration_threshold, S_IRUGO | S_IWUGO,
1615         inv_attr_show, inv_dmp_bias_store,
1616                         ATTR_DMP_PARAMS_ACCEL_CALIBRATION_THRESHOLD);
1617 static IIO_DEVICE_ATTR(params_accel_calibration_rate, S_IRUGO | S_IWUGO,
1618         inv_attr_show, inv_dmp_bias_store,
1619                         ATTR_DMP_PARAMS_ACCEL_CALIBRATION_RATE);
1620
1621 static IIO_DEVICE_ATTR(in_step_detector_enable, S_IRUGO | S_IWUGO,
1622         inv_attr_show, inv_basic_attr_store, ATTR_DMP_STEP_DETECTOR_ON);
1623 static IIO_DEVICE_ATTR(in_step_indicator_enable, S_IRUGO | S_IWUGO,
1624         inv_attr_show, inv_basic_attr_store, ATTR_DMP_STEP_INDICATOR_ON);
1625
1626 static IIO_DEVICE_ATTR(event_smd_enable, S_IRUGO | S_IWUGO,
1627         inv_attr_show, inv_basic_attr_store, ATTR_DMP_SMD_ENABLE);
1628 static IIO_DEVICE_ATTR(params_smd_timer_thresh, S_IRUGO | S_IWUGO,
1629         inv_attr_show, inv_misc_attr_store, ATTR_DMP_SMD_TIMER_THLD);
1630
1631 static IIO_DEVICE_ATTR(params_pedometer_int_on, S_IRUGO | S_IWUGO,
1632         inv_attr_show, inv_misc_attr_store, ATTR_DMP_PED_INT_ON);
1633 static IIO_DEVICE_ATTR(event_pedometer_enable, S_IRUGO | S_IWUGO,
1634         inv_attr_show, inv_basic_attr_store, ATTR_DMP_PED_ON);
1635 static IIO_DEVICE_ATTR(params_pedometer_step_thresh, S_IRUGO | S_IWUGO,
1636         inv_attr_show, inv_misc_attr_store, ATTR_DMP_PED_STEP_THRESH);
1637 static IIO_DEVICE_ATTR(params_pedometer_int_thresh, S_IRUGO | S_IWUGO,
1638         inv_attr_show, inv_misc_attr_store, ATTR_DMP_PED_INT_THRESH);
1639
1640 static IIO_DEVICE_ATTR(out_pedometer_steps, S_IRUGO | S_IWUGO, inv_attr64_show,
1641         inv_attr64_store, ATTR_DMP_PEDOMETER_STEPS);
1642 static IIO_DEVICE_ATTR(out_pedometer_time, S_IRUGO | S_IWUGO, inv_attr64_show,
1643         inv_attr64_store, ATTR_DMP_PEDOMETER_TIME);
1644 static IIO_DEVICE_ATTR(out_pedometer_counter, S_IRUGO | S_IWUGO,
1645                         inv_attr64_show, NULL, ATTR_DMP_PEDOMETER_COUNTER);
1646
1647 static const struct attribute *inv_raw_attributes[] = {
1648         &dev_attr_debug_reg_dump.attr,
1649         &dev_attr_out_temperature.attr,
1650         &dev_attr_misc_flush_batch.attr,
1651         &dev_attr_misc_self_test.attr,
1652         &iio_dev_attr_info_anglvel_matrix.dev_attr.attr,
1653         &iio_dev_attr_debug_gyro_enable.dev_attr.attr,
1654         &iio_dev_attr_in_anglvel_enable.dev_attr.attr,
1655         &iio_dev_attr_debug_accel_enable.dev_attr.attr,
1656         &iio_dev_attr_in_accel_enable.dev_attr.attr,
1657         &iio_dev_attr_info_accel_matrix.dev_attr.attr,
1658         &iio_dev_attr_in_accel_scale.dev_attr.attr,
1659         &iio_dev_attr_in_anglvel_scale.dev_attr.attr,
1660         &iio_dev_attr_info_firmware_loaded.dev_attr.attr,
1661         &iio_dev_attr_debug_dmp_on.dev_attr.attr,
1662         &iio_dev_attr_misc_batchmode_timeout.dev_attr.attr,
1663         &iio_dev_attr_debug_dmp_event_int_on.dev_attr.attr,
1664         &iio_dev_attr_debug_low_power_gyro_on.dev_attr.attr,
1665         &iio_dev_attr_debug_data_collection_mode_on.dev_attr.attr,
1666         &iio_dev_attr_debug_data_collection_mode_gyro_rate.dev_attr.attr,
1667         &iio_dev_attr_debug_data_collection_mode_accel_rate.dev_attr.attr,
1668         &iio_dev_attr_debug_lp_en_off.dev_attr.attr,
1669         &iio_dev_attr_debug_cycle_mode_off.dev_attr.attr,
1670         &iio_dev_attr_debug_clock_sel.dev_attr.attr,
1671         &iio_dev_attr_debug_reg_write.dev_attr.attr,
1672         &iio_dev_attr_debug_reg_write_addr.dev_attr.attr,
1673         &iio_dev_attr_debug_cfg_write.dev_attr.attr,
1674         &iio_dev_attr_in_anglvel_rate.dev_attr.attr,
1675         &iio_dev_attr_in_accel_rate.dev_attr.attr,
1676         &iio_dev_attr_in_accel_x_dmp_bias.dev_attr.attr,
1677         &iio_dev_attr_in_accel_y_dmp_bias.dev_attr.attr,
1678         &iio_dev_attr_in_accel_z_dmp_bias.dev_attr.attr,
1679         &iio_dev_attr_debug_accel_cal_enable.dev_attr.attr,
1680         &iio_dev_attr_debug_gyro_cal_enable.dev_attr.attr,
1681         &iio_dev_attr_in_anglvel_x_dmp_bias.dev_attr.attr,
1682         &iio_dev_attr_in_anglvel_y_dmp_bias.dev_attr.attr,
1683         &iio_dev_attr_in_anglvel_z_dmp_bias.dev_attr.attr,
1684         &iio_dev_attr_in_accel_x_calibbias.dev_attr.attr,
1685         &iio_dev_attr_in_accel_y_calibbias.dev_attr.attr,
1686         &iio_dev_attr_in_accel_z_calibbias.dev_attr.attr,
1687         &iio_dev_attr_in_anglvel_x_calibbias.dev_attr.attr,
1688         &iio_dev_attr_in_anglvel_y_calibbias.dev_attr.attr,
1689         &iio_dev_attr_in_anglvel_z_calibbias.dev_attr.attr,
1690         &iio_dev_attr_in_6quat_enable.dev_attr.attr,
1691         &iio_dev_attr_in_6quat_rate.dev_attr.attr,
1692         &iio_dev_attr_in_p6quat_enable.dev_attr.attr,
1693         &iio_dev_attr_in_p6quat_rate.dev_attr.attr,
1694         &iio_dev_attr_in_calib_anglvel_enable.dev_attr.attr,
1695         &iio_dev_attr_in_calib_anglvel_rate.dev_attr.attr,
1696         &iio_dev_attr_debug_anglvel_accuracy_enable.dev_attr.attr,
1697         &iio_dev_attr_debug_accel_accuracy_enable.dev_attr.attr,
1698         &iio_dev_attr_info_secondary_name.dev_attr.attr,
1699         &iio_dev_attr_info_gyro_sf.dev_attr.attr,
1700         &iio_dev_attr_debug_determine_engine_on.dev_attr.attr,
1701         &iio_dev_attr_debug_mem_read.dev_attr.attr,
1702         &iio_dev_attr_debug_mem_write.dev_attr.attr,
1703         &iio_dev_attr_misc_gyro_recalibration.dev_attr.attr,
1704         &iio_dev_attr_misc_accel_recalibration.dev_attr.attr,
1705         &iio_dev_attr_params_accel_calibration_threshold.dev_attr.attr,
1706         &iio_dev_attr_params_accel_calibration_rate.dev_attr.attr,
1707 };
1708
1709 static const struct attribute *inv_compass_attributes[] = {
1710         &iio_dev_attr_in_magn_scale.dev_attr.attr,
1711         &iio_dev_attr_debug_compass_enable.dev_attr.attr,
1712         &iio_dev_attr_info_magn_matrix.dev_attr.attr,
1713         &iio_dev_attr_in_magn_x_dmp_bias.dev_attr.attr,
1714         &iio_dev_attr_in_magn_y_dmp_bias.dev_attr.attr,
1715         &iio_dev_attr_in_magn_z_dmp_bias.dev_attr.attr,
1716         &iio_dev_attr_debug_compass_cal_enable.dev_attr.attr,
1717         &iio_dev_attr_misc_magn_recalibration.dev_attr.attr,
1718         &iio_dev_attr_misc_ref_mag_3d.dev_attr.attr,
1719         &iio_dev_attr_debug_magn_accuracy_enable.dev_attr.attr,
1720         &iio_dev_attr_in_calib_magn_enable.dev_attr.attr,
1721         &iio_dev_attr_in_calib_magn_rate.dev_attr.attr,
1722         &iio_dev_attr_in_geomag_enable.dev_attr.attr,
1723         &iio_dev_attr_in_geomag_rate.dev_attr.attr,
1724         &iio_dev_attr_in_magn_enable.dev_attr.attr,
1725         &iio_dev_attr_in_magn_rate.dev_attr.attr,
1726         &iio_dev_attr_in_9quat_enable.dev_attr.attr,
1727         &iio_dev_attr_in_9quat_rate.dev_attr.attr,
1728 };
1729
1730 static const struct attribute *inv_pedometer_attributes[] = {
1731         &dev_attr_poll_pedometer.attr,
1732         &iio_dev_attr_params_pedometer_int_on.dev_attr.attr,
1733         &iio_dev_attr_event_pedometer_enable.dev_attr.attr,
1734         &iio_dev_attr_in_step_indicator_enable.dev_attr.attr,
1735         &iio_dev_attr_in_step_detector_enable.dev_attr.attr,
1736         &iio_dev_attr_out_pedometer_steps.dev_attr.attr,
1737         &iio_dev_attr_out_pedometer_time.dev_attr.attr,
1738         &iio_dev_attr_out_pedometer_counter.dev_attr.attr,
1739         &iio_dev_attr_params_pedometer_step_thresh.dev_attr.attr,
1740         &iio_dev_attr_params_pedometer_int_thresh.dev_attr.attr,
1741 };
1742 static const struct attribute *inv_smd_attributes[] = {
1743         &dev_attr_poll_smd.attr,
1744         &iio_dev_attr_event_smd_enable.dev_attr.attr,
1745         &iio_dev_attr_params_smd_timer_thresh.dev_attr.attr,
1746 };
1747
1748 static const struct attribute *inv_pressure_attributes[] = {
1749         &iio_dev_attr_in_pressure_enable.dev_attr.attr,
1750         &iio_dev_attr_in_pressure_rate.dev_attr.attr,
1751 };
1752
1753 static const struct attribute *inv_als_attributes[] = {
1754         &iio_dev_attr_in_als_px_enable.dev_attr.attr,
1755         &iio_dev_attr_in_als_px_rate.dev_attr.attr,
1756 };
1757
1758 static struct attribute *inv_attributes[
1759         ARRAY_SIZE(inv_raw_attributes) +
1760         ARRAY_SIZE(inv_pedometer_attributes) +
1761         ARRAY_SIZE(inv_smd_attributes) +
1762         ARRAY_SIZE(inv_compass_attributes) +
1763         ARRAY_SIZE(inv_pressure_attributes) +
1764         ARRAY_SIZE(inv_als_attributes) +
1765         1
1766 ];
1767
1768 static const struct attribute_group inv_attribute_group = {
1769         .name = "mpu",
1770         .attrs = inv_attributes
1771 };
1772
1773 static const struct iio_info mpu_info = {
1774         .driver_module = THIS_MODULE,
1775         .attrs = &inv_attribute_group,
1776 };
1777
1778 /*
1779  *  inv_check_chip_type() - check and setup chip type.
1780  */
1781 int inv_check_chip_type(struct iio_dev *indio_dev, const char *name)
1782 {
1783         u8 v;
1784         int result;
1785         int t_ind;
1786         struct inv_chip_config_s *conf;
1787         struct mpu_platform_data *plat;
1788         struct inv_mpu_state *st;
1789
1790         st = iio_priv(indio_dev);
1791         conf = &st->chip_config;
1792         plat = &st->plat_data;
1793         if (!strcmp(name, "mpu7400"))
1794                 st->chip_type = ICM20628;
1795         else if (!strcmp(name, "icm20628"))
1796                 st->chip_type = ICM20628;
1797         else if (!strcmp(name, "icm20728"))
1798                 st->chip_type = ICM20728;
1799         else if (!strcmp(name, "icm20645"))
1800                 st->chip_type = ICM20628;
1801         else
1802                 return -EPERM;
1803         st->hw  = &hw_info[st->chip_type];
1804         result = inv_set_bank(st, BANK_SEL_0);
1805         if (result)
1806                 return result;
1807         /* reset to make sure previous state are not there */
1808         result = inv_plat_single_write(st, REG_PWR_MGMT_1, BIT_H_RESET);
1809         if (result)
1810                 return result;
1811         usleep_range(REG_UP_TIME_USEC, REG_UP_TIME_USEC);
1812         msleep(100);
1813         /* toggle power state */
1814         result = inv_set_power(st, false);
1815         if (result)
1816                 return result;
1817
1818         result = inv_set_power(st, true);
1819         if (result)
1820                 return result;
1821         result = inv_plat_read(st, REG_WHO_AM_I, 1, &v);
1822         if (result)
1823                 return result;
1824
1825         result = inv_plat_single_write(st, REG_USER_CTRL, st->i2c_dis);
1826         if (result)
1827                 return result;
1828         result = inv_init_config(st);
1829         if (result)
1830                 return result;
1831
1832         if (SECONDARY_SLAVE_TYPE_COMPASS == plat->sec_slave_type)
1833                 st->chip_config.has_compass = 1;
1834         else
1835                 st->chip_config.has_compass = 0;
1836         if (SECONDARY_SLAVE_TYPE_PRESSURE == plat->aux_slave_type)
1837                 st->chip_config.has_pressure = 1;
1838         else
1839                 st->chip_config.has_pressure = 0;
1840         if (SECONDARY_SLAVE_TYPE_ALS == plat->read_only_slave_type)
1841                 st->chip_config.has_als = 1;
1842         else
1843                 st->chip_config.has_als = 0;
1844
1845         if (st->chip_config.has_compass) {
1846                 result = inv_mpu_setup_compass_slave(st);
1847                 if (result) {
1848                         pr_err("compass setup failed\n");
1849                         inv_set_power(st, false);
1850                         return result;
1851                 }
1852         }
1853         if (st->chip_config.has_pressure) {
1854                 result = inv_mpu_setup_pressure_slave(st);
1855                 if (result) {
1856                         pr_err("pressure setup failed\n");
1857                         inv_set_power(st, false);
1858                         return result;
1859                 }
1860         }
1861         if (st->chip_config.has_als) {
1862                 result = inv_mpu_setup_als_slave(st);
1863                 if (result) {
1864                         pr_err("als setup failed\n");
1865                         inv_set_power(st, false);
1866                         return result;
1867                 }
1868         }
1869
1870         result = mem_r(MPU_SOFT_REV_ADDR, 1, &v);
1871         if (result)
1872                 return result;
1873         if (v & MPU_SOFT_REV_MASK) {
1874                 pr_err("incorrect software revision=%x\n", v);
1875                 return -EINVAL;
1876         }
1877         //set up the low power mode capability
1878     if (v & 0x04)
1879         st->chip_config.lp_en_mode = 1;
1880     else
1881         st->chip_config.lp_en_mode = 0;
1882
1883         t_ind = 0;
1884         memcpy(&inv_attributes[t_ind], inv_raw_attributes,
1885                                         sizeof(inv_raw_attributes));
1886         t_ind += ARRAY_SIZE(inv_raw_attributes);
1887
1888         memcpy(&inv_attributes[t_ind], inv_pedometer_attributes,
1889                                         sizeof(inv_pedometer_attributes));
1890         t_ind += ARRAY_SIZE(inv_pedometer_attributes);
1891
1892         memcpy(&inv_attributes[t_ind], inv_smd_attributes,
1893                                         sizeof(inv_smd_attributes));
1894         t_ind += ARRAY_SIZE(inv_smd_attributes);
1895
1896         if (st->chip_config.has_compass) {
1897                 memcpy(&inv_attributes[t_ind], inv_compass_attributes,
1898                        sizeof(inv_compass_attributes));
1899                 t_ind += ARRAY_SIZE(inv_compass_attributes);
1900         }
1901         if (ICM20728 == st->chip_type || st->chip_config.has_pressure) {
1902                 memcpy(&inv_attributes[t_ind], inv_pressure_attributes,
1903                        sizeof(inv_pressure_attributes));
1904                 t_ind += ARRAY_SIZE(inv_pressure_attributes);
1905         }
1906         if (st->chip_config.has_als) {
1907                 memcpy(&inv_attributes[t_ind], inv_als_attributes,
1908                        sizeof(inv_als_attributes));
1909                 t_ind += ARRAY_SIZE(inv_als_attributes);
1910         }
1911
1912         inv_attributes[t_ind] = NULL;
1913
1914         indio_dev->channels = inv_mpu_channels;
1915         indio_dev->num_channels = ARRAY_SIZE(inv_mpu_channels);
1916
1917         indio_dev->info = &mpu_info;
1918         indio_dev->modes = INDIO_DIRECT_MODE;
1919         indio_dev->currentmode = INDIO_DIRECT_MODE;
1920         INIT_KFIFO(st->kf);
1921
1922         result = inv_set_power(st, false);
1923
1924         return result;
1925 }
1926
1927 /*
1928  *  inv_create_dmp_sysfs() - create binary sysfs dmp entry.
1929  */
1930 static const struct bin_attribute dmp_firmware = {
1931         .attr = {
1932                 .name = "misc_bin_dmp_firmware",
1933                 .mode = S_IRUGO | S_IWUGO
1934         },
1935         .size = DMP_IMAGE_SIZE,
1936         .read = inv_dmp_firmware_read,
1937         .write = inv_dmp_firmware_write,
1938 };
1939
1940 static const struct bin_attribute soft_iron_matrix = {
1941         .attr = {
1942                 .name = "misc_bin_soft_iron_matrix",
1943                 .mode = S_IRUGO | S_IWUGO
1944         },
1945         .size = SOFT_IRON_MATRIX_SIZE,
1946         .write = inv_soft_iron_matrix_write,
1947 };
1948
1949 static const struct bin_attribute accel_covariance = {
1950         .attr = {
1951                 .name = "misc_bin_accel_covariance",
1952                 .mode = S_IRUGO | S_IWUGO
1953         },
1954         .size = ACCEL_COVARIANCE_SIZE,
1955         .write = inv_accel_covariance_write,
1956         .read =  inv_accel_covariance_read,
1957 };
1958
1959 static const struct bin_attribute compass_covariance = {
1960         .attr = {
1961                 .name = "misc_bin_magn_covariance",
1962                 .mode = S_IRUGO | S_IWUGO
1963         },
1964         .size = COMPASS_COVARIANCE_SIZE,
1965         .write = inv_compass_covariance_write,
1966         .read =  inv_compass_covariance_read,
1967 };
1968
1969 static const struct bin_attribute compass_cur_covariance = {
1970         .attr = {
1971                 .name = "misc_bin_cur_magn_covariance",
1972                 .mode = S_IRUGO | S_IWUGO
1973         },
1974         .size = COMPASS_COVARIANCE_SIZE,
1975         .write = inv_compass_covariance_cur_write,
1976         .read =  inv_compass_covariance_cur_read,
1977 };
1978
1979 int inv_create_dmp_sysfs(struct iio_dev *ind)
1980 {
1981         int result;
1982
1983         result = sysfs_create_bin_file(&ind->dev.kobj, &dmp_firmware);
1984         if (result)
1985                 return result;
1986         result = sysfs_create_bin_file(&ind->dev.kobj, &soft_iron_matrix);
1987         if (result)
1988                 return result;
1989
1990         result = sysfs_create_bin_file(&ind->dev.kobj, &accel_covariance);
1991         if (result)
1992                 return result;
1993         result = sysfs_create_bin_file(&ind->dev.kobj, &compass_covariance);
1994         if (result)
1995                 return result;
1996         result = sysfs_create_bin_file(&ind->dev.kobj, &compass_cur_covariance);
1997
1998         return result;
1999 }