drivers/iio/magnetometer/st_magn_core.c

   1 /*
   2  * STMicroelectronics magnetometers driver
   3  *
   4  * Copyright 2012-2013 STMicroelectronics Inc.
   5  *
   6  * Denis Ciocca <denis.ciocca@st.com>
   7  *
   8  * Licensed under the GPL-2.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/slab.h>
  14 #include <linux/errno.h>
  15 #include <linux/types.h>
  16 #include <linux/mutex.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/i2c.h>
  19 #include <linux/gpio.h>
  20 #include <linux/irq.h>
  21 #include <linux/delay.h>
  22 #include <linux/iio/iio.h>
  23 #include <linux/iio/sysfs.h>
  24 #include <linux/iio/buffer.h>
  25
  26 #include <linux/iio/common/st_sensors.h>
  27 #include "st_magn.h"
  28
  29 #define ST_MAGN_NUMBER_DATA_CHANNELS            3
  30
  31 /* DEFAULT VALUE FOR SENSORS */
  32 #define ST_MAGN_DEFAULT_OUT_X_H_ADDR            0X03
  33 #define ST_MAGN_DEFAULT_OUT_Y_H_ADDR            0X07
  34 #define ST_MAGN_DEFAULT_OUT_Z_H_ADDR            0X05
  35
  36 /* FULLSCALE */
  37 #define ST_MAGN_FS_AVL_1300MG                   1300
  38 #define ST_MAGN_FS_AVL_1900MG                   1900
  39 #define ST_MAGN_FS_AVL_2500MG                   2500
  40 #define ST_MAGN_FS_AVL_4000MG                   4000
  41 #define ST_MAGN_FS_AVL_4700MG                   4700
  42 #define ST_MAGN_FS_AVL_5600MG                   5600
  43 #define ST_MAGN_FS_AVL_8000MG                   8000
  44 #define ST_MAGN_FS_AVL_8100MG                   8100
  45 #define ST_MAGN_FS_AVL_12000MG                  12000
  46 #define ST_MAGN_FS_AVL_16000MG                  16000
  47
  48 /* CUSTOM VALUES FOR SENSOR 1 */
  49 #define ST_MAGN_1_WAI_EXP                       0x3c
  50 #define ST_MAGN_1_ODR_ADDR                      0x00
  51 #define ST_MAGN_1_ODR_MASK                      0x1c
  52 #define ST_MAGN_1_ODR_AVL_1HZ_VAL               0x00
  53 #define ST_MAGN_1_ODR_AVL_2HZ_VAL               0x01
  54 #define ST_MAGN_1_ODR_AVL_3HZ_VAL               0x02
  55 #define ST_MAGN_1_ODR_AVL_8HZ_VAL               0x03
  56 #define ST_MAGN_1_ODR_AVL_15HZ_VAL              0x04
  57 #define ST_MAGN_1_ODR_AVL_30HZ_VAL              0x05
  58 #define ST_MAGN_1_ODR_AVL_75HZ_VAL              0x06
  59 #define ST_MAGN_1_ODR_AVL_220HZ_VAL             0x07
  60 #define ST_MAGN_1_PW_ADDR                       0x02
  61 #define ST_MAGN_1_PW_MASK                       0x03
  62 #define ST_MAGN_1_PW_ON                         0x00
  63 #define ST_MAGN_1_PW_OFF                        0x03
  64 #define ST_MAGN_1_FS_ADDR                       0x01
  65 #define ST_MAGN_1_FS_MASK                       0xe0
  66 #define ST_MAGN_1_FS_AVL_1300_VAL               0x01
  67 #define ST_MAGN_1_FS_AVL_1900_VAL               0x02
  68 #define ST_MAGN_1_FS_AVL_2500_VAL               0x03
  69 #define ST_MAGN_1_FS_AVL_4000_VAL               0x04
  70 #define ST_MAGN_1_FS_AVL_4700_VAL               0x05
  71 #define ST_MAGN_1_FS_AVL_5600_VAL               0x06
  72 #define ST_MAGN_1_FS_AVL_8100_VAL               0x07
  73 #define ST_MAGN_1_FS_AVL_1300_GAIN_XY           909
  74 #define ST_MAGN_1_FS_AVL_1900_GAIN_XY           1169
  75 #define ST_MAGN_1_FS_AVL_2500_GAIN_XY           1492
  76 #define ST_MAGN_1_FS_AVL_4000_GAIN_XY           2222
  77 #define ST_MAGN_1_FS_AVL_4700_GAIN_XY           2500
  78 #define ST_MAGN_1_FS_AVL_5600_GAIN_XY           3030
  79 #define ST_MAGN_1_FS_AVL_8100_GAIN_XY           4347
  80 #define ST_MAGN_1_FS_AVL_1300_GAIN_Z            1020
  81 #define ST_MAGN_1_FS_AVL_1900_GAIN_Z            1315
  82 #define ST_MAGN_1_FS_AVL_2500_GAIN_Z            1666
  83 #define ST_MAGN_1_FS_AVL_4000_GAIN_Z            2500
  84 #define ST_MAGN_1_FS_AVL_4700_GAIN_Z            2816
  85 #define ST_MAGN_1_FS_AVL_5600_GAIN_Z            3389
  86 #define ST_MAGN_1_FS_AVL_8100_GAIN_Z            4878
  87 #define ST_MAGN_1_MULTIREAD_BIT                 false
  88
  89 /* CUSTOM VALUES FOR SENSOR 2 */
  90 #define ST_MAGN_2_WAI_EXP                       0x3d
  91 #define ST_MAGN_2_ODR_ADDR                      0x20
  92 #define ST_MAGN_2_ODR_MASK                      0x1c
  93 #define ST_MAGN_2_ODR_AVL_1HZ_VAL               0x00
  94 #define ST_MAGN_2_ODR_AVL_2HZ_VAL               0x01
  95 #define ST_MAGN_2_ODR_AVL_3HZ_VAL               0x02
  96 #define ST_MAGN_2_ODR_AVL_5HZ_VAL               0x03
  97 #define ST_MAGN_2_ODR_AVL_10HZ_VAL              0x04
  98 #define ST_MAGN_2_ODR_AVL_20HZ_VAL              0x05
  99 #define ST_MAGN_2_ODR_AVL_40HZ_VAL              0x06
 100 #define ST_MAGN_2_ODR_AVL_80HZ_VAL              0x07
 101 #define ST_MAGN_2_PW_ADDR                       0x22
 102 #define ST_MAGN_2_PW_MASK                       0x03
 103 #define ST_MAGN_2_PW_ON                         0x00
 104 #define ST_MAGN_2_PW_OFF                        0x03
 105 #define ST_MAGN_2_FS_ADDR                       0x21
 106 #define ST_MAGN_2_FS_MASK                       0x60
 107 #define ST_MAGN_2_FS_AVL_4000_VAL               0x00
 108 #define ST_MAGN_2_FS_AVL_8000_VAL               0x01
 109 #define ST_MAGN_2_FS_AVL_12000_VAL              0x02
 110 #define ST_MAGN_2_FS_AVL_16000_VAL              0x03
 111 #define ST_MAGN_2_FS_AVL_4000_GAIN              146
 112 #define ST_MAGN_2_FS_AVL_8000_GAIN              292
 113 #define ST_MAGN_2_FS_AVL_12000_GAIN             438
 114 #define ST_MAGN_2_FS_AVL_16000_GAIN             584
 115 #define ST_MAGN_2_MULTIREAD_BIT                 false
 116 #define ST_MAGN_2_OUT_X_L_ADDR                  0x28
 117 #define ST_MAGN_2_OUT_Y_L_ADDR                  0x2a
 118 #define ST_MAGN_2_OUT_Z_L_ADDR                  0x2c
 119
 120 static const struct iio_chan_spec st_magn_16bit_channels[] = {
 121         ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
 122                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 123                         ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_BE, 16, 16,
 124                         ST_MAGN_DEFAULT_OUT_X_H_ADDR),
 125         ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
 126                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 127                         ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_BE, 16, 16,
 128                         ST_MAGN_DEFAULT_OUT_Y_H_ADDR),
 129         ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
 130                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 131                         ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_BE, 16, 16,
 132                         ST_MAGN_DEFAULT_OUT_Z_H_ADDR),
 133         IIO_CHAN_SOFT_TIMESTAMP(3)
 134 };
 135
 136 static const struct iio_chan_spec st_magn_2_16bit_channels[] = {
 137         ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
 138                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 139                         ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
 140                         ST_MAGN_2_OUT_X_L_ADDR),
 141         ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
 142                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 143                         ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
 144                         ST_MAGN_2_OUT_Y_L_ADDR),
 145         ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
 146                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 147                         ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
 148                         ST_MAGN_2_OUT_Z_L_ADDR),
 149         IIO_CHAN_SOFT_TIMESTAMP(3)
 150 };
 151
 152 static const struct st_sensor_settings st_magn_sensors_settings[] = {
 153         {
 154                 .wai = ST_MAGN_1_WAI_EXP,
 155                 .sensors_supported = {
 156                         [0] = LSM303DLHC_MAGN_DEV_NAME,
 157                         [1] = LSM303DLM_MAGN_DEV_NAME,
 158                 },
 159                 .ch = (struct iio_chan_spec *)st_magn_16bit_channels,
 160                 .odr = {
 161                         .addr = ST_MAGN_1_ODR_ADDR,
 162                         .mask = ST_MAGN_1_ODR_MASK,
 163                         .odr_avl = {
 164                                 { 1, ST_MAGN_1_ODR_AVL_1HZ_VAL, },
 165                                 { 2, ST_MAGN_1_ODR_AVL_2HZ_VAL, },
 166                                 { 3, ST_MAGN_1_ODR_AVL_3HZ_VAL, },
 167                                 { 8, ST_MAGN_1_ODR_AVL_8HZ_VAL, },
 168                                 { 15, ST_MAGN_1_ODR_AVL_15HZ_VAL, },
 169                                 { 30, ST_MAGN_1_ODR_AVL_30HZ_VAL, },
 170                                 { 75, ST_MAGN_1_ODR_AVL_75HZ_VAL, },
 171                                 { 220, ST_MAGN_1_ODR_AVL_220HZ_VAL, },
 172                         },
 173                 },
 174                 .pw = {
 175                         .addr = ST_MAGN_1_PW_ADDR,
 176                         .mask = ST_MAGN_1_PW_MASK,
 177                         .value_on = ST_MAGN_1_PW_ON,
 178                         .value_off = ST_MAGN_1_PW_OFF,
 179                 },
 180                 .fs = {
 181                         .addr = ST_MAGN_1_FS_ADDR,
 182                         .mask = ST_MAGN_1_FS_MASK,
 183                         .fs_avl = {
 184                                 [0] = {
 185                                         .num = ST_MAGN_FS_AVL_1300MG,
 186                                         .value = ST_MAGN_1_FS_AVL_1300_VAL,
 187                                         .gain = ST_MAGN_1_FS_AVL_1300_GAIN_XY,
 188                                         .gain2 = ST_MAGN_1_FS_AVL_1300_GAIN_Z,
 189                                 },
 190                                 [1] = {
 191                                         .num = ST_MAGN_FS_AVL_1900MG,
 192                                         .value = ST_MAGN_1_FS_AVL_1900_VAL,
 193                                         .gain = ST_MAGN_1_FS_AVL_1900_GAIN_XY,
 194                                         .gain2 = ST_MAGN_1_FS_AVL_1900_GAIN_Z,
 195                                 },
 196                                 [2] = {
 197                                         .num = ST_MAGN_FS_AVL_2500MG,
 198                                         .value = ST_MAGN_1_FS_AVL_2500_VAL,
 199                                         .gain = ST_MAGN_1_FS_AVL_2500_GAIN_XY,
 200                                         .gain2 = ST_MAGN_1_FS_AVL_2500_GAIN_Z,
 201                                 },
 202                                 [3] = {
 203                                         .num = ST_MAGN_FS_AVL_4000MG,
 204                                         .value = ST_MAGN_1_FS_AVL_4000_VAL,
 205                                         .gain = ST_MAGN_1_FS_AVL_4000_GAIN_XY,
 206                                         .gain2 = ST_MAGN_1_FS_AVL_4000_GAIN_Z,
 207                                 },
 208                                 [4] = {
 209                                         .num = ST_MAGN_FS_AVL_4700MG,
 210                                         .value = ST_MAGN_1_FS_AVL_4700_VAL,
 211                                         .gain = ST_MAGN_1_FS_AVL_4700_GAIN_XY,
 212                                         .gain2 = ST_MAGN_1_FS_AVL_4700_GAIN_Z,
 213                                 },
 214                                 [5] = {
 215                                         .num = ST_MAGN_FS_AVL_5600MG,
 216                                         .value = ST_MAGN_1_FS_AVL_5600_VAL,
 217                                         .gain = ST_MAGN_1_FS_AVL_5600_GAIN_XY,
 218                                         .gain2 = ST_MAGN_1_FS_AVL_5600_GAIN_Z,
 219                                 },
 220                                 [6] = {
 221                                         .num = ST_MAGN_FS_AVL_8100MG,
 222                                         .value = ST_MAGN_1_FS_AVL_8100_VAL,
 223                                         .gain = ST_MAGN_1_FS_AVL_8100_GAIN_XY,
 224                                         .gain2 = ST_MAGN_1_FS_AVL_8100_GAIN_Z,
 225                                 },
 226                         },
 227                 },
 228                 .multi_read_bit = ST_MAGN_1_MULTIREAD_BIT,
 229                 .bootime = 2,
 230         },
 231         {
 232                 .wai = ST_MAGN_2_WAI_EXP,
 233                 .sensors_supported = {
 234                         [0] = LIS3MDL_MAGN_DEV_NAME,
 235                 },
 236                 .ch = (struct iio_chan_spec *)st_magn_2_16bit_channels,
 237                 .odr = {
 238                         .addr = ST_MAGN_2_ODR_ADDR,
 239                         .mask = ST_MAGN_2_ODR_MASK,
 240                         .odr_avl = {
 241                                 { 1, ST_MAGN_2_ODR_AVL_1HZ_VAL, },
 242                                 { 2, ST_MAGN_2_ODR_AVL_2HZ_VAL, },
 243                                 { 3, ST_MAGN_2_ODR_AVL_3HZ_VAL, },
 244                                 { 5, ST_MAGN_2_ODR_AVL_5HZ_VAL, },
 245                                 { 10, ST_MAGN_2_ODR_AVL_10HZ_VAL, },
 246                                 { 20, ST_MAGN_2_ODR_AVL_20HZ_VAL, },
 247                                 { 40, ST_MAGN_2_ODR_AVL_40HZ_VAL, },
 248                                 { 80, ST_MAGN_2_ODR_AVL_80HZ_VAL, },
 249                         },
 250                 },
 251                 .pw = {
 252                         .addr = ST_MAGN_2_PW_ADDR,
 253                         .mask = ST_MAGN_2_PW_MASK,
 254                         .value_on = ST_MAGN_2_PW_ON,
 255                         .value_off = ST_MAGN_2_PW_OFF,
 256                 },
 257                 .fs = {
 258                         .addr = ST_MAGN_2_FS_ADDR,
 259                         .mask = ST_MAGN_2_FS_MASK,
 260                         .fs_avl = {
 261                                 [0] = {
 262                                         .num = ST_MAGN_FS_AVL_4000MG,
 263                                         .value = ST_MAGN_2_FS_AVL_4000_VAL,
 264                                         .gain = ST_MAGN_2_FS_AVL_4000_GAIN,
 265                                 },
 266                                 [1] = {
 267                                         .num = ST_MAGN_FS_AVL_8000MG,
 268                                         .value = ST_MAGN_2_FS_AVL_8000_VAL,
 269                                         .gain = ST_MAGN_2_FS_AVL_8000_GAIN,
 270                                 },
 271                                 [2] = {
 272                                         .num = ST_MAGN_FS_AVL_12000MG,
 273                                         .value = ST_MAGN_2_FS_AVL_12000_VAL,
 274                                         .gain = ST_MAGN_2_FS_AVL_12000_GAIN,
 275                                 },
 276                                 [3] = {
 277                                         .num = ST_MAGN_FS_AVL_16000MG,
 278                                         .value = ST_MAGN_2_FS_AVL_16000_VAL,
 279                                         .gain = ST_MAGN_2_FS_AVL_16000_GAIN,
 280                                 },
 281                         },
 282                 },
 283                 .multi_read_bit = ST_MAGN_2_MULTIREAD_BIT,
 284                 .bootime = 2,
 285         },
 286 };
 287
 288 static int st_magn_read_raw(struct iio_dev *indio_dev,
 289                         struct iio_chan_spec const *ch, int *val,
 290                                                         int *val2, long mask)
 291 {
 292         int err;
 293         struct st_sensor_data *mdata = iio_priv(indio_dev);
 294
 295         switch (mask) {
 296         case IIO_CHAN_INFO_RAW:
 297                 err = st_sensors_read_info_raw(indio_dev, ch, val);
 298                 if (err < 0)
 299                         goto read_error;
 300
 301                 return IIO_VAL_INT;
 302         case IIO_CHAN_INFO_SCALE:
 303                 *val = 0;
 304                 if ((ch->scan_index == ST_SENSORS_SCAN_Z) &&
 305                                         (mdata->current_fullscale->gain2 != 0))
 306                         *val2 = mdata->current_fullscale->gain2;
 307                 else
 308                         *val2 = mdata->current_fullscale->gain;
 309                 return IIO_VAL_INT_PLUS_MICRO;
 310         case IIO_CHAN_INFO_SAMP_FREQ:
 311                 *val = mdata->odr;
 312                 return IIO_VAL_INT;
 313         default:
 314                 return -EINVAL;
 315         }
 316
 317 read_error:
 318         return err;
 319 }
 320
 321 static int st_magn_write_raw(struct iio_dev *indio_dev,
 322                 struct iio_chan_spec const *chan, int val, int val2, long mask)
 323 {
 324         int err;
 325
 326         switch (mask) {
 327         case IIO_CHAN_INFO_SCALE:
 328                 err = st_sensors_set_fullscale_by_gain(indio_dev, val2);
 329                 break;
 330         case IIO_CHAN_INFO_SAMP_FREQ:
 331                 if (val2)
 332                         return -EINVAL;
 333                 mutex_lock(&indio_dev->mlock);
 334                 err = st_sensors_set_odr(indio_dev, val);
 335                 mutex_unlock(&indio_dev->mlock);
 336                 return err;
 337         default:
 338                 err = -EINVAL;
 339         }
 340
 341         return err;
 342 }
 343
 344 static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
 345 static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_magn_scale_available);
 346
 347 static struct attribute *st_magn_attributes[] = {
 348         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
 349         &iio_dev_attr_in_magn_scale_available.dev_attr.attr,
 350         NULL,
 351 };
 352
 353 static const struct attribute_group st_magn_attribute_group = {
 354         .attrs = st_magn_attributes,
 355 };
 356
 357 static const struct iio_info magn_info = {
 358         .driver_module = THIS_MODULE,
 359         .attrs = &st_magn_attribute_group,
 360         .read_raw = &st_magn_read_raw,
 361         .write_raw = &st_magn_write_raw,
 362 };
 363
 364 int st_magn_common_probe(struct iio_dev *indio_dev)
 365 {
 366         struct st_sensor_data *mdata = iio_priv(indio_dev);
 367         int irq = mdata->get_irq_data_ready(indio_dev);
 368         int err;
 369
 370         indio_dev->modes = INDIO_DIRECT_MODE;
 371         indio_dev->info = &magn_info;
 372
 373         st_sensors_power_enable(indio_dev);
 374
 375         err = st_sensors_check_device_support(indio_dev,
 376                                         ARRAY_SIZE(st_magn_sensors_settings),
 377                                         st_magn_sensors_settings);
 378         if (err < 0)
 379                 return err;
 380
 381         mdata->num_data_channels = ST_MAGN_NUMBER_DATA_CHANNELS;
 382         mdata->multiread_bit = mdata->sensor_settings->multi_read_bit;
 383         indio_dev->channels = mdata->sensor_settings->ch;
 384         indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
 385
 386         mdata->current_fullscale = (struct st_sensor_fullscale_avl *)
 387                                         &mdata->sensor_settings->fs.fs_avl[0];
 388         mdata->odr = mdata->sensor_settings->odr.odr_avl[0].hz;
 389
 390         err = st_sensors_init_sensor(indio_dev, NULL);
 391         if (err < 0)
 392                 return err;
 393
 394         err = st_magn_allocate_ring(indio_dev);
 395         if (err < 0)
 396                 return err;
 397
 398         if (irq > 0) {
 399                 err = st_sensors_allocate_trigger(indio_dev, NULL);
 400                 if (err < 0)
 401                         goto st_magn_probe_trigger_error;
 402         }
 403
 404         err = iio_device_register(indio_dev);
 405         if (err)
 406                 goto st_magn_device_register_error;
 407
 408         dev_info(&indio_dev->dev, "registered magnetometer %s\n",
 409                  indio_dev->name);
 410
 411         return 0;
 412
 413 st_magn_device_register_error:
 414         if (irq > 0)
 415                 st_sensors_deallocate_trigger(indio_dev);
 416 st_magn_probe_trigger_error:
 417         st_magn_deallocate_ring(indio_dev);
 418
 419         return err;
 420 }
 421 EXPORT_SYMBOL(st_magn_common_probe);
 422
 423 void st_magn_common_remove(struct iio_dev *indio_dev)
 424 {
 425         struct st_sensor_data *mdata = iio_priv(indio_dev);
 426
 427         st_sensors_power_disable(indio_dev);
 428
 429         iio_device_unregister(indio_dev);
 430         if (mdata->get_irq_data_ready(indio_dev) > 0)
 431                 st_sensors_deallocate_trigger(indio_dev);
 432
 433         st_magn_deallocate_ring(indio_dev);
 434 }
 435 EXPORT_SYMBOL(st_magn_common_remove);
 436
 437 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
 438 MODULE_DESCRIPTION("STMicroelectronics magnetometers driver");
 439 MODULE_LICENSE("GPL v2");