drivers/iio/gyro/st_gyro_core.c

   1 /*
   2  * STMicroelectronics gyroscopes 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/trigger.h>
  25 #include <linux/iio/buffer.h>
  26
  27 #include <linux/iio/common/st_sensors.h>
  28 #include "st_gyro.h"
  29
  30 #define ST_GYRO_NUMBER_DATA_CHANNELS            3
  31
  32 /* DEFAULT VALUE FOR SENSORS */
  33 #define ST_GYRO_DEFAULT_OUT_X_L_ADDR            0x28
  34 #define ST_GYRO_DEFAULT_OUT_Y_L_ADDR            0x2a
  35 #define ST_GYRO_DEFAULT_OUT_Z_L_ADDR            0x2c
  36
  37 /* FULLSCALE */
  38 #define ST_GYRO_FS_AVL_245DPS                   245
  39 #define ST_GYRO_FS_AVL_250DPS                   250
  40 #define ST_GYRO_FS_AVL_500DPS                   500
  41 #define ST_GYRO_FS_AVL_2000DPS                  2000
  42
  43 static const struct iio_chan_spec st_gyro_16bit_channels[] = {
  44         ST_SENSORS_LSM_CHANNELS(IIO_ANGL_VEL,
  45                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  46                         ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
  47                         ST_GYRO_DEFAULT_OUT_X_L_ADDR),
  48         ST_SENSORS_LSM_CHANNELS(IIO_ANGL_VEL,
  49                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  50                         ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
  51                         ST_GYRO_DEFAULT_OUT_Y_L_ADDR),
  52         ST_SENSORS_LSM_CHANNELS(IIO_ANGL_VEL,
  53                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  54                         ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
  55                         ST_GYRO_DEFAULT_OUT_Z_L_ADDR),
  56         IIO_CHAN_SOFT_TIMESTAMP(3)
  57 };
  58
  59 static const struct st_sensor_settings st_gyro_sensors_settings[] = {
  60         {
  61                 .wai = 0xd3,
  62                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
  63                 .sensors_supported = {
  64                         [0] = L3G4200D_GYRO_DEV_NAME,
  65                         [1] = LSM330DL_GYRO_DEV_NAME,
  66                 },
  67                 .ch = (struct iio_chan_spec *)st_gyro_16bit_channels,
  68                 .odr = {
  69                         .addr = 0x20,
  70                         .mask = 0xc0,
  71                         .odr_avl = {
  72                                 { .hz = 100, .value = 0x00, },
  73                                 { .hz = 200, .value = 0x01, },
  74                                 { .hz = 400, .value = 0x02, },
  75                                 { .hz = 800, .value = 0x03, },
  76                         },
  77                 },
  78                 .pw = {
  79                         .addr = 0x20,
  80                         .mask = 0x08,
  81                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
  82                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
  83                 },
  84                 .enable_axis = {
  85                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
  86                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
  87                 },
  88                 .fs = {
  89                         .addr = 0x23,
  90                         .mask = 0x30,
  91                         .fs_avl = {
  92                                 [0] = {
  93                                         .num = ST_GYRO_FS_AVL_250DPS,
  94                                         .value = 0x00,
  95                                         .gain = IIO_DEGREE_TO_RAD(8750),
  96                                 },
  97                                 [1] = {
  98                                         .num = ST_GYRO_FS_AVL_500DPS,
  99                                         .value = 0x01,
 100                                         .gain = IIO_DEGREE_TO_RAD(17500),
 101                                 },
 102                                 [2] = {
 103                                         .num = ST_GYRO_FS_AVL_2000DPS,
 104                                         .value = 0x02,
 105                                         .gain = IIO_DEGREE_TO_RAD(70000),
 106                                 },
 107                         },
 108                 },
 109                 .bdu = {
 110                         .addr = 0x23,
 111                         .mask = 0x80,
 112                 },
 113                 .drdy_irq = {
 114                         .addr = 0x22,
 115                         .mask_int2 = 0x08,
 116                         /*
 117                          * The sensor has IHL (active low) and open
 118                          * drain settings, but only for INT1 and not
 119                          * for the DRDY line on INT2.
 120                          */
 121                         .stat_drdy = {
 122                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 123                                 .mask = 0x07,
 124                         },
 125                 },
 126                 .multi_read_bit = true,
 127                 .bootime = 2,
 128         },
 129         {
 130                 .wai = 0xd4,
 131                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 132                 .sensors_supported = {
 133                         [0] = L3GD20_GYRO_DEV_NAME,
 134                         [1] = LSM330D_GYRO_DEV_NAME,
 135                         [2] = LSM330DLC_GYRO_DEV_NAME,
 136                         [3] = L3G4IS_GYRO_DEV_NAME,
 137                         [4] = LSM330_GYRO_DEV_NAME,
 138                         [5] = LSM9DS0_GYRO_DEV_NAME,
 139                 },
 140                 .ch = (struct iio_chan_spec *)st_gyro_16bit_channels,
 141                 .odr = {
 142                         .addr = 0x20,
 143                         .mask = 0xc0,
 144                         .odr_avl = {
 145                                 { .hz = 95, .value = 0x00, },
 146                                 { .hz = 190, .value = 0x01, },
 147                                 { .hz = 380, .value = 0x02, },
 148                                 { .hz = 760, .value = 0x03, },
 149                         },
 150                 },
 151                 .pw = {
 152                         .addr = 0x20,
 153                         .mask = 0x08,
 154                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 155                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 156                 },
 157                 .enable_axis = {
 158                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 159                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 160                 },
 161                 .fs = {
 162                         .addr = 0x23,
 163                         .mask = 0x30,
 164                         .fs_avl = {
 165                                 [0] = {
 166                                         .num = ST_GYRO_FS_AVL_250DPS,
 167                                         .value = 0x00,
 168                                         .gain = IIO_DEGREE_TO_RAD(8750),
 169                                 },
 170                                 [1] = {
 171                                         .num = ST_GYRO_FS_AVL_500DPS,
 172                                         .value = 0x01,
 173                                         .gain = IIO_DEGREE_TO_RAD(17500),
 174                                 },
 175                                 [2] = {
 176                                         .num = ST_GYRO_FS_AVL_2000DPS,
 177                                         .value = 0x02,
 178                                         .gain = IIO_DEGREE_TO_RAD(70000),
 179                                 },
 180                         },
 181                 },
 182                 .bdu = {
 183                         .addr = 0x23,
 184                         .mask = 0x80,
 185                 },
 186                 .drdy_irq = {
 187                         .addr = 0x22,
 188                         .mask_int2 = 0x08,
 189                         /*
 190                          * The sensor has IHL (active low) and open
 191                          * drain settings, but only for INT1 and not
 192                          * for the DRDY line on INT2.
 193                          */
 194                         .stat_drdy = {
 195                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 196                                 .mask = 0x07,
 197                         },
 198                 },
 199                 .multi_read_bit = true,
 200                 .bootime = 2,
 201         },
 202         {
 203                 .wai = 0xd7,
 204                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 205                 .sensors_supported = {
 206                         [0] = L3GD20H_GYRO_DEV_NAME,
 207                 },
 208                 .ch = (struct iio_chan_spec *)st_gyro_16bit_channels,
 209                 .odr = {
 210                         .addr = 0x20,
 211                         .mask = 0xc0,
 212                         .odr_avl = {
 213                                 { .hz = 100, .value = 0x00, },
 214                                 { .hz = 200, .value = 0x01, },
 215                                 { .hz = 400, .value = 0x02, },
 216                                 { .hz = 800, .value = 0x03, },
 217                         },
 218                 },
 219                 .pw = {
 220                         .addr = 0x20,
 221                         .mask = 0x08,
 222                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 223                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 224                 },
 225                 .enable_axis = {
 226                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 227                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 228                 },
 229                 .fs = {
 230                         .addr = 0x23,
 231                         .mask = 0x30,
 232                         .fs_avl = {
 233                                 [0] = {
 234                                         .num = ST_GYRO_FS_AVL_245DPS,
 235                                         .value = 0x00,
 236                                         .gain = IIO_DEGREE_TO_RAD(8750),
 237                                 },
 238                                 [1] = {
 239                                         .num = ST_GYRO_FS_AVL_500DPS,
 240                                         .value = 0x01,
 241                                         .gain = IIO_DEGREE_TO_RAD(17500),
 242                                 },
 243                                 [2] = {
 244                                         .num = ST_GYRO_FS_AVL_2000DPS,
 245                                         .value = 0x02,
 246                                         .gain = IIO_DEGREE_TO_RAD(70000),
 247                                 },
 248                         },
 249                 },
 250                 .bdu = {
 251                         .addr = 0x23,
 252                         .mask = 0x80,
 253                 },
 254                 .drdy_irq = {
 255                         .addr = 0x22,
 256                         .mask_int2 = 0x08,
 257                         /*
 258                          * The sensor has IHL (active low) and open
 259                          * drain settings, but only for INT1 and not
 260                          * for the DRDY line on INT2.
 261                          */
 262                         .stat_drdy = {
 263                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 264                                 .mask = 0x07,
 265                         },
 266                 },
 267                 .multi_read_bit = true,
 268                 .bootime = 2,
 269         },
 270 };
 271
 272 static int st_gyro_read_raw(struct iio_dev *indio_dev,
 273                         struct iio_chan_spec const *ch, int *val,
 274                                                         int *val2, long mask)
 275 {
 276         int err;
 277         struct st_sensor_data *gdata = iio_priv(indio_dev);
 278
 279         switch (mask) {
 280         case IIO_CHAN_INFO_RAW:
 281                 err = st_sensors_read_info_raw(indio_dev, ch, val);
 282                 if (err < 0)
 283                         goto read_error;
 284
 285                 return IIO_VAL_INT;
 286         case IIO_CHAN_INFO_SCALE:
 287                 *val = 0;
 288                 *val2 = gdata->current_fullscale->gain;
 289                 return IIO_VAL_INT_PLUS_MICRO;
 290         case IIO_CHAN_INFO_SAMP_FREQ:
 291                 *val = gdata->odr;
 292                 return IIO_VAL_INT;
 293         default:
 294                 return -EINVAL;
 295         }
 296
 297 read_error:
 298         return err;
 299 }
 300
 301 static int st_gyro_write_raw(struct iio_dev *indio_dev,
 302                 struct iio_chan_spec const *chan, int val, int val2, long mask)
 303 {
 304         int err;
 305
 306         switch (mask) {
 307         case IIO_CHAN_INFO_SCALE:
 308                 err = st_sensors_set_fullscale_by_gain(indio_dev, val2);
 309                 break;
 310         case IIO_CHAN_INFO_SAMP_FREQ:
 311                 if (val2)
 312                         return -EINVAL;
 313                 mutex_lock(&indio_dev->mlock);
 314                 err = st_sensors_set_odr(indio_dev, val);
 315                 mutex_unlock(&indio_dev->mlock);
 316                 return err;
 317         default:
 318                 err = -EINVAL;
 319         }
 320
 321         return err;
 322 }
 323
 324 static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
 325 static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_anglvel_scale_available);
 326
 327 static struct attribute *st_gyro_attributes[] = {
 328         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
 329         &iio_dev_attr_in_anglvel_scale_available.dev_attr.attr,
 330         NULL,
 331 };
 332
 333 static const struct attribute_group st_gyro_attribute_group = {
 334         .attrs = st_gyro_attributes,
 335 };
 336
 337 static const struct iio_info gyro_info = {
 338         .driver_module = THIS_MODULE,
 339         .attrs = &st_gyro_attribute_group,
 340         .read_raw = &st_gyro_read_raw,
 341         .write_raw = &st_gyro_write_raw,
 342         .debugfs_reg_access = &st_sensors_debugfs_reg_access,
 343 };
 344
 345 #ifdef CONFIG_IIO_TRIGGER
 346 static const struct iio_trigger_ops st_gyro_trigger_ops = {
 347         .owner = THIS_MODULE,
 348         .set_trigger_state = ST_GYRO_TRIGGER_SET_STATE,
 349         .validate_device = st_sensors_validate_device,
 350 };
 351 #define ST_GYRO_TRIGGER_OPS (&st_gyro_trigger_ops)
 352 #else
 353 #define ST_GYRO_TRIGGER_OPS NULL
 354 #endif
 355
 356 int st_gyro_common_probe(struct iio_dev *indio_dev)
 357 {
 358         struct st_sensor_data *gdata = iio_priv(indio_dev);
 359         int irq = gdata->get_irq_data_ready(indio_dev);
 360         int err;
 361
 362         indio_dev->modes = INDIO_DIRECT_MODE;
 363         indio_dev->info = &gyro_info;
 364         mutex_init(&gdata->tb.buf_lock);
 365
 366         err = st_sensors_power_enable(indio_dev);
 367         if (err)
 368                 return err;
 369
 370         err = st_sensors_check_device_support(indio_dev,
 371                                         ARRAY_SIZE(st_gyro_sensors_settings),
 372                                         st_gyro_sensors_settings);
 373         if (err < 0)
 374                 goto st_gyro_power_off;
 375
 376         gdata->num_data_channels = ST_GYRO_NUMBER_DATA_CHANNELS;
 377         gdata->multiread_bit = gdata->sensor_settings->multi_read_bit;
 378         indio_dev->channels = gdata->sensor_settings->ch;
 379         indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
 380
 381         gdata->current_fullscale = (struct st_sensor_fullscale_avl *)
 382                                         &gdata->sensor_settings->fs.fs_avl[0];
 383         gdata->odr = gdata->sensor_settings->odr.odr_avl[0].hz;
 384
 385         err = st_sensors_init_sensor(indio_dev,
 386                                 (struct st_sensors_platform_data *)&gyro_pdata);
 387         if (err < 0)
 388                 goto st_gyro_power_off;
 389
 390         err = st_gyro_allocate_ring(indio_dev);
 391         if (err < 0)
 392                 goto st_gyro_power_off;
 393
 394         if (irq > 0) {
 395                 err = st_sensors_allocate_trigger(indio_dev,
 396                                                   ST_GYRO_TRIGGER_OPS);
 397                 if (err < 0)
 398                         goto st_gyro_probe_trigger_error;
 399         }
 400
 401         err = iio_device_register(indio_dev);
 402         if (err)
 403                 goto st_gyro_device_register_error;
 404
 405         dev_info(&indio_dev->dev, "registered gyroscope %s\n",
 406                  indio_dev->name);
 407
 408         return 0;
 409
 410 st_gyro_device_register_error:
 411         if (irq > 0)
 412                 st_sensors_deallocate_trigger(indio_dev);
 413 st_gyro_probe_trigger_error:
 414         st_gyro_deallocate_ring(indio_dev);
 415 st_gyro_power_off:
 416         st_sensors_power_disable(indio_dev);
 417
 418         return err;
 419 }
 420 EXPORT_SYMBOL(st_gyro_common_probe);
 421
 422 void st_gyro_common_remove(struct iio_dev *indio_dev)
 423 {
 424         struct st_sensor_data *gdata = iio_priv(indio_dev);
 425
 426         st_sensors_power_disable(indio_dev);
 427
 428         iio_device_unregister(indio_dev);
 429         if (gdata->get_irq_data_ready(indio_dev) > 0)
 430                 st_sensors_deallocate_trigger(indio_dev);
 431
 432         st_gyro_deallocate_ring(indio_dev);
 433 }
 434 EXPORT_SYMBOL(st_gyro_common_remove);
 435
 436 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
 437 MODULE_DESCRIPTION("STMicroelectronics gyroscopes driver");
 438 MODULE_LICENSE("GPL v2");