Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * STMicroelectronics st_lsm6dsx i2c controller driver
0003  *
0004  * i2c controller embedded in lsm6dx series can connect up to four
0005  * slave devices using accelerometer sensor as trigger for i2c
0006  * read/write operations. Current implementation relies on SLV0 channel
0007  * for slave configuration and SLV{1,2,3} to read data and push them into
0008  * the hw FIFO
0009  *
0010  * Copyright (C) 2018 Lorenzo Bianconi <lorenzo.bianconi83@gmail.com>
0011  *
0012  * Permission to use, copy, modify, and/or distribute this software for any
0013  * purpose with or without fee is hereby granted, provided that the above
0014  * copyright notice and this permission notice appear in all copies.
0015  *
0016  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
0017  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
0018  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
0019  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
0020  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
0021  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
0022  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
0023  *
0024  */
0025 #include <linux/module.h>
0026 #include <linux/regmap.h>
0027 #include <linux/iio/iio.h>
0028 #include <linux/iio/sysfs.h>
0029 #include <linux/bitfield.h>
0030 
0031 #include "st_lsm6dsx.h"
0032 
0033 #define ST_LSM6DSX_SLV_ADDR(n, base)        ((base) + (n) * 3)
0034 #define ST_LSM6DSX_SLV_SUB_ADDR(n, base)    ((base) + 1 + (n) * 3)
0035 #define ST_LSM6DSX_SLV_CONFIG(n, base)      ((base) + 2 + (n) * 3)
0036 
0037 #define ST_LS6DSX_READ_OP_MASK          GENMASK(2, 0)
0038 
0039 static const struct st_lsm6dsx_ext_dev_settings st_lsm6dsx_ext_dev_table[] = {
0040     /* LIS2MDL */
0041     {
0042         .i2c_addr = { 0x1e },
0043         .wai = {
0044             .addr = 0x4f,
0045             .val = 0x40,
0046         },
0047         .id = ST_LSM6DSX_ID_MAGN,
0048         .odr_table = {
0049             .reg = {
0050                 .addr = 0x60,
0051                 .mask = GENMASK(3, 2),
0052             },
0053             .odr_avl[0] = {  10000, 0x0 },
0054             .odr_avl[1] = {  20000, 0x1 },
0055             .odr_avl[2] = {  50000, 0x2 },
0056             .odr_avl[3] = { 100000, 0x3 },
0057             .odr_len = 4,
0058         },
0059         .fs_table = {
0060             .fs_avl[0] = {
0061                 .gain = 1500,
0062                 .val = 0x0,
0063             }, /* 1500 uG/LSB */
0064             .fs_len = 1,
0065         },
0066         .temp_comp = {
0067             .addr = 0x60,
0068             .mask = BIT(7),
0069         },
0070         .pwr_table = {
0071             .reg = {
0072                 .addr = 0x60,
0073                 .mask = GENMASK(1, 0),
0074             },
0075             .off_val = 0x2,
0076             .on_val = 0x0,
0077         },
0078         .off_canc = {
0079             .addr = 0x61,
0080             .mask = BIT(1),
0081         },
0082         .bdu = {
0083             .addr = 0x62,
0084             .mask = BIT(4),
0085         },
0086         .out = {
0087             .addr = 0x68,
0088             .len = 6,
0089         },
0090     },
0091     /* LIS3MDL */
0092     {
0093         .i2c_addr = { 0x1e },
0094         .wai = {
0095             .addr = 0x0f,
0096             .val = 0x3d,
0097         },
0098         .id = ST_LSM6DSX_ID_MAGN,
0099         .odr_table = {
0100             .reg = {
0101                 .addr = 0x20,
0102                 .mask = GENMASK(4, 2),
0103             },
0104             .odr_avl[0] = {  1000, 0x0 },
0105             .odr_avl[1] = {  2000, 0x1 },
0106             .odr_avl[2] = {  3000, 0x2 },
0107             .odr_avl[3] = {  5000, 0x3 },
0108             .odr_avl[4] = { 10000, 0x4 },
0109             .odr_avl[5] = { 20000, 0x5 },
0110             .odr_avl[6] = { 40000, 0x6 },
0111             .odr_avl[7] = { 80000, 0x7 },
0112             .odr_len = 8,
0113         },
0114         .fs_table = {
0115             .reg = {
0116                 .addr = 0x21,
0117                 .mask = GENMASK(6, 5),
0118             },
0119             .fs_avl[0] = {
0120                 .gain = 146,
0121                 .val = 0x00,
0122             }, /* 4000 uG/LSB */
0123             .fs_avl[1] = {
0124                 .gain = 292,
0125                 .val = 0x01,
0126             }, /* 8000 uG/LSB */
0127             .fs_avl[2] = {
0128                 .gain = 438,
0129                 .val = 0x02,
0130             }, /* 12000 uG/LSB */
0131             .fs_avl[3] = {
0132                 .gain = 584,
0133                 .val = 0x03,
0134             }, /* 16000 uG/LSB */
0135             .fs_len = 4,
0136         },
0137         .pwr_table = {
0138             .reg = {
0139                 .addr = 0x22,
0140                 .mask = GENMASK(1, 0),
0141             },
0142             .off_val = 0x2,
0143             .on_val = 0x0,
0144         },
0145         .bdu = {
0146             .addr = 0x24,
0147             .mask = BIT(6),
0148         },
0149         .out = {
0150             .addr = 0x28,
0151             .len = 6,
0152         },
0153     },
0154 };
0155 
0156 static void st_lsm6dsx_shub_wait_complete(struct st_lsm6dsx_hw *hw)
0157 {
0158     struct st_lsm6dsx_sensor *sensor;
0159     u32 odr, timeout;
0160 
0161     sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]);
0162     odr = (hw->enable_mask & BIT(ST_LSM6DSX_ID_ACC)) ? sensor->odr : 12500;
0163     /* set 10ms as minimum timeout for i2c slave configuration */
0164     timeout = max_t(u32, 2000000U / odr + 1, 10);
0165     msleep(timeout);
0166 }
0167 
0168 /*
0169  * st_lsm6dsx_shub_read_output - read i2c controller register
0170  *
0171  * Read st_lsm6dsx i2c controller register
0172  */
0173 static int
0174 st_lsm6dsx_shub_read_output(struct st_lsm6dsx_hw *hw, u8 *data,
0175                 int len)
0176 {
0177     const struct st_lsm6dsx_shub_settings *hub_settings;
0178     int err;
0179 
0180     mutex_lock(&hw->page_lock);
0181 
0182     hub_settings = &hw->settings->shub_settings;
0183     if (hub_settings->shub_out.sec_page) {
0184         err = st_lsm6dsx_set_page(hw, true);
0185         if (err < 0)
0186             goto out;
0187     }
0188 
0189     err = regmap_bulk_read(hw->regmap, hub_settings->shub_out.addr,
0190                    data, len);
0191 
0192     if (hub_settings->shub_out.sec_page)
0193         st_lsm6dsx_set_page(hw, false);
0194 out:
0195     mutex_unlock(&hw->page_lock);
0196 
0197     return err;
0198 }
0199 
0200 /*
0201  * st_lsm6dsx_shub_write_reg - write i2c controller register
0202  *
0203  * Write st_lsm6dsx i2c controller register
0204  */
0205 static int st_lsm6dsx_shub_write_reg(struct st_lsm6dsx_hw *hw, u8 addr,
0206                      u8 *data, int len)
0207 {
0208     int err;
0209 
0210     mutex_lock(&hw->page_lock);
0211     err = st_lsm6dsx_set_page(hw, true);
0212     if (err < 0)
0213         goto out;
0214 
0215     err = regmap_bulk_write(hw->regmap, addr, data, len);
0216 
0217     st_lsm6dsx_set_page(hw, false);
0218 out:
0219     mutex_unlock(&hw->page_lock);
0220 
0221     return err;
0222 }
0223 
0224 static int
0225 st_lsm6dsx_shub_write_reg_with_mask(struct st_lsm6dsx_hw *hw, u8 addr,
0226                     u8 mask, u8 val)
0227 {
0228     int err;
0229 
0230     mutex_lock(&hw->page_lock);
0231     err = st_lsm6dsx_set_page(hw, true);
0232     if (err < 0)
0233         goto out;
0234 
0235     err = regmap_update_bits(hw->regmap, addr, mask, val);
0236 
0237     st_lsm6dsx_set_page(hw, false);
0238 out:
0239     mutex_unlock(&hw->page_lock);
0240 
0241     return err;
0242 }
0243 
0244 static int st_lsm6dsx_shub_master_enable(struct st_lsm6dsx_sensor *sensor,
0245                      bool enable)
0246 {
0247     const struct st_lsm6dsx_shub_settings *hub_settings;
0248     struct st_lsm6dsx_hw *hw = sensor->hw;
0249     unsigned int data;
0250     int err;
0251 
0252     /* enable acc sensor as trigger */
0253     err = st_lsm6dsx_sensor_set_enable(sensor, enable);
0254     if (err < 0)
0255         return err;
0256 
0257     mutex_lock(&hw->page_lock);
0258 
0259     hub_settings = &hw->settings->shub_settings;
0260     if (hub_settings->master_en.sec_page) {
0261         err = st_lsm6dsx_set_page(hw, true);
0262         if (err < 0)
0263             goto out;
0264     }
0265 
0266     data = ST_LSM6DSX_SHIFT_VAL(enable, hub_settings->master_en.mask);
0267     err = regmap_update_bits(hw->regmap, hub_settings->master_en.addr,
0268                  hub_settings->master_en.mask, data);
0269 
0270     if (hub_settings->master_en.sec_page)
0271         st_lsm6dsx_set_page(hw, false);
0272 out:
0273     mutex_unlock(&hw->page_lock);
0274 
0275     return err;
0276 }
0277 
0278 /*
0279  * st_lsm6dsx_shub_read - read data from slave device register
0280  *
0281  * Read data from slave device register. SLV0 is used for
0282  * one-shot read operation
0283  */
0284 static int
0285 st_lsm6dsx_shub_read(struct st_lsm6dsx_sensor *sensor, u8 addr,
0286              u8 *data, int len)
0287 {
0288     const struct st_lsm6dsx_shub_settings *hub_settings;
0289     u8 config[3], slv_addr, slv_config = 0;
0290     struct st_lsm6dsx_hw *hw = sensor->hw;
0291     const struct st_lsm6dsx_reg *aux_sens;
0292     int err;
0293 
0294     hub_settings = &hw->settings->shub_settings;
0295     slv_addr = ST_LSM6DSX_SLV_ADDR(0, hub_settings->slv0_addr);
0296     aux_sens = &hw->settings->shub_settings.aux_sens;
0297     /* do not overwrite aux_sens */
0298     if (slv_addr + 2 == aux_sens->addr)
0299         slv_config = ST_LSM6DSX_SHIFT_VAL(3, aux_sens->mask);
0300 
0301     config[0] = (sensor->ext_info.addr << 1) | 1;
0302     config[1] = addr;
0303     config[2] = (len & ST_LS6DSX_READ_OP_MASK) | slv_config;
0304 
0305     err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
0306                     sizeof(config));
0307     if (err < 0)
0308         return err;
0309 
0310     err = st_lsm6dsx_shub_master_enable(sensor, true);
0311     if (err < 0)
0312         return err;
0313 
0314     st_lsm6dsx_shub_wait_complete(hw);
0315 
0316     err = st_lsm6dsx_shub_read_output(hw, data,
0317                       len & ST_LS6DSX_READ_OP_MASK);
0318     if (err < 0)
0319         return err;
0320 
0321     st_lsm6dsx_shub_master_enable(sensor, false);
0322 
0323     config[0] = hub_settings->pause;
0324     config[1] = 0;
0325     config[2] = slv_config;
0326     return st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
0327                      sizeof(config));
0328 }
0329 
0330 /*
0331  * st_lsm6dsx_shub_write - write data to slave device register
0332  *
0333  * Write data from slave device register. SLV0 is used for
0334  * one-shot write operation
0335  */
0336 static int
0337 st_lsm6dsx_shub_write(struct st_lsm6dsx_sensor *sensor, u8 addr,
0338               u8 *data, int len)
0339 {
0340     const struct st_lsm6dsx_shub_settings *hub_settings;
0341     struct st_lsm6dsx_hw *hw = sensor->hw;
0342     u8 config[2], slv_addr;
0343     int err, i;
0344 
0345     hub_settings = &hw->settings->shub_settings;
0346     if (hub_settings->wr_once.addr) {
0347         unsigned int data;
0348 
0349         data = ST_LSM6DSX_SHIFT_VAL(1, hub_settings->wr_once.mask);
0350         err = st_lsm6dsx_shub_write_reg_with_mask(hw,
0351             hub_settings->wr_once.addr,
0352             hub_settings->wr_once.mask,
0353             data);
0354         if (err < 0)
0355             return err;
0356     }
0357 
0358     slv_addr = ST_LSM6DSX_SLV_ADDR(0, hub_settings->slv0_addr);
0359     config[0] = sensor->ext_info.addr << 1;
0360     for (i = 0 ; i < len; i++) {
0361         config[1] = addr + i;
0362 
0363         err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
0364                         sizeof(config));
0365         if (err < 0)
0366             return err;
0367 
0368         err = st_lsm6dsx_shub_write_reg(hw, hub_settings->dw_slv0_addr,
0369                         &data[i], 1);
0370         if (err < 0)
0371             return err;
0372 
0373         err = st_lsm6dsx_shub_master_enable(sensor, true);
0374         if (err < 0)
0375             return err;
0376 
0377         st_lsm6dsx_shub_wait_complete(hw);
0378 
0379         st_lsm6dsx_shub_master_enable(sensor, false);
0380     }
0381 
0382     config[0] = hub_settings->pause;
0383     config[1] = 0;
0384     return st_lsm6dsx_shub_write_reg(hw, slv_addr, config, sizeof(config));
0385 }
0386 
0387 static int
0388 st_lsm6dsx_shub_write_with_mask(struct st_lsm6dsx_sensor *sensor,
0389                 u8 addr, u8 mask, u8 val)
0390 {
0391     int err;
0392     u8 data;
0393 
0394     err = st_lsm6dsx_shub_read(sensor, addr, &data, sizeof(data));
0395     if (err < 0)
0396         return err;
0397 
0398     data = ((data & ~mask) | (val << __ffs(mask) & mask));
0399 
0400     return st_lsm6dsx_shub_write(sensor, addr, &data, sizeof(data));
0401 }
0402 
0403 static int
0404 st_lsm6dsx_shub_get_odr_val(struct st_lsm6dsx_sensor *sensor,
0405                 u32 odr, u16 *val)
0406 {
0407     const struct st_lsm6dsx_ext_dev_settings *settings;
0408     int i;
0409 
0410     settings = sensor->ext_info.settings;
0411     for (i = 0; i < settings->odr_table.odr_len; i++) {
0412         if (settings->odr_table.odr_avl[i].milli_hz == odr)
0413             break;
0414     }
0415 
0416     if (i == settings->odr_table.odr_len)
0417         return -EINVAL;
0418 
0419     *val = settings->odr_table.odr_avl[i].val;
0420     return 0;
0421 }
0422 
0423 static int
0424 st_lsm6dsx_shub_set_odr(struct st_lsm6dsx_sensor *sensor, u32 odr)
0425 {
0426     const struct st_lsm6dsx_ext_dev_settings *settings;
0427     u16 val;
0428     int err;
0429 
0430     err = st_lsm6dsx_shub_get_odr_val(sensor, odr, &val);
0431     if (err < 0)
0432         return err;
0433 
0434     settings = sensor->ext_info.settings;
0435     return st_lsm6dsx_shub_write_with_mask(sensor,
0436                            settings->odr_table.reg.addr,
0437                            settings->odr_table.reg.mask,
0438                            val);
0439 }
0440 
0441 /* use SLV{1,2,3} for FIFO read operations */
0442 static int
0443 st_lsm6dsx_shub_config_channels(struct st_lsm6dsx_sensor *sensor,
0444                 bool enable)
0445 {
0446     const struct st_lsm6dsx_shub_settings *hub_settings;
0447     const struct st_lsm6dsx_ext_dev_settings *settings;
0448     u8 config[9] = {}, enable_mask, slv_addr;
0449     struct st_lsm6dsx_hw *hw = sensor->hw;
0450     struct st_lsm6dsx_sensor *cur_sensor;
0451     int i, j = 0;
0452 
0453     hub_settings = &hw->settings->shub_settings;
0454     if (enable)
0455         enable_mask = hw->enable_mask | BIT(sensor->id);
0456     else
0457         enable_mask = hw->enable_mask & ~BIT(sensor->id);
0458 
0459     for (i = ST_LSM6DSX_ID_EXT0; i <= ST_LSM6DSX_ID_EXT2; i++) {
0460         if (!hw->iio_devs[i])
0461             continue;
0462 
0463         cur_sensor = iio_priv(hw->iio_devs[i]);
0464         if (!(enable_mask & BIT(cur_sensor->id)))
0465             continue;
0466 
0467         settings = cur_sensor->ext_info.settings;
0468         config[j] = (sensor->ext_info.addr << 1) | 1;
0469         config[j + 1] = settings->out.addr;
0470         config[j + 2] = (settings->out.len & ST_LS6DSX_READ_OP_MASK) |
0471                 hub_settings->batch_en;
0472         j += 3;
0473     }
0474 
0475     slv_addr = ST_LSM6DSX_SLV_ADDR(1, hub_settings->slv0_addr);
0476     return st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
0477                      sizeof(config));
0478 }
0479 
0480 int st_lsm6dsx_shub_set_enable(struct st_lsm6dsx_sensor *sensor, bool enable)
0481 {
0482     const struct st_lsm6dsx_ext_dev_settings *settings;
0483     int err;
0484 
0485     err = st_lsm6dsx_shub_config_channels(sensor, enable);
0486     if (err < 0)
0487         return err;
0488 
0489     settings = sensor->ext_info.settings;
0490     if (enable) {
0491         err = st_lsm6dsx_shub_set_odr(sensor,
0492                           sensor->ext_info.slv_odr);
0493         if (err < 0)
0494             return err;
0495     } else {
0496         err = st_lsm6dsx_shub_write_with_mask(sensor,
0497                     settings->odr_table.reg.addr,
0498                     settings->odr_table.reg.mask, 0);
0499         if (err < 0)
0500             return err;
0501     }
0502 
0503     if (settings->pwr_table.reg.addr) {
0504         u8 val;
0505 
0506         val = enable ? settings->pwr_table.on_val
0507                  : settings->pwr_table.off_val;
0508         err = st_lsm6dsx_shub_write_with_mask(sensor,
0509                     settings->pwr_table.reg.addr,
0510                     settings->pwr_table.reg.mask, val);
0511         if (err < 0)
0512             return err;
0513     }
0514 
0515     return st_lsm6dsx_shub_master_enable(sensor, enable);
0516 }
0517 
0518 static int
0519 st_lsm6dsx_shub_read_oneshot(struct st_lsm6dsx_sensor *sensor,
0520                  struct iio_chan_spec const *ch,
0521                  int *val)
0522 {
0523     int err, delay, len;
0524     u8 data[4];
0525 
0526     err = st_lsm6dsx_shub_set_enable(sensor, true);
0527     if (err < 0)
0528         return err;
0529 
0530     delay = 1000000000 / sensor->ext_info.slv_odr;
0531     usleep_range(delay, 2 * delay);
0532 
0533     len = min_t(int, sizeof(data), ch->scan_type.realbits >> 3);
0534     err = st_lsm6dsx_shub_read(sensor, ch->address, data, len);
0535     if (err < 0)
0536         return err;
0537 
0538     err = st_lsm6dsx_shub_set_enable(sensor, false);
0539     if (err < 0)
0540         return err;
0541 
0542     switch (len) {
0543     case 2:
0544         *val = (s16)le16_to_cpu(*((__le16 *)data));
0545         break;
0546     default:
0547         return -EINVAL;
0548     }
0549 
0550     return IIO_VAL_INT;
0551 }
0552 
0553 static int
0554 st_lsm6dsx_shub_read_raw(struct iio_dev *iio_dev,
0555              struct iio_chan_spec const *ch,
0556              int *val, int *val2, long mask)
0557 {
0558     struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev);
0559     int ret;
0560 
0561     switch (mask) {
0562     case IIO_CHAN_INFO_RAW:
0563         ret = iio_device_claim_direct_mode(iio_dev);
0564         if (ret)
0565             break;
0566 
0567         ret = st_lsm6dsx_shub_read_oneshot(sensor, ch, val);
0568         iio_device_release_direct_mode(iio_dev);
0569         break;
0570     case IIO_CHAN_INFO_SAMP_FREQ:
0571         *val = sensor->ext_info.slv_odr / 1000;
0572         *val2 = (sensor->ext_info.slv_odr % 1000) * 1000;
0573         ret = IIO_VAL_INT_PLUS_MICRO;
0574         break;
0575     case IIO_CHAN_INFO_SCALE:
0576         *val = 0;
0577         *val2 = sensor->gain;
0578         ret = IIO_VAL_INT_PLUS_MICRO;
0579         break;
0580     default:
0581         ret = -EINVAL;
0582         break;
0583     }
0584 
0585     return ret;
0586 }
0587 
0588 static int
0589 st_lsm6dsx_shub_set_full_scale(struct st_lsm6dsx_sensor *sensor,
0590                    u32 gain)
0591 {
0592     const struct st_lsm6dsx_fs_table_entry *fs_table;
0593     int i, err;
0594 
0595     fs_table = &sensor->ext_info.settings->fs_table;
0596     if (!fs_table->reg.addr)
0597         return -ENOTSUPP;
0598 
0599     for (i = 0; i < fs_table->fs_len; i++) {
0600         if (fs_table->fs_avl[i].gain == gain)
0601             break;
0602     }
0603 
0604     if (i == fs_table->fs_len)
0605         return -EINVAL;
0606 
0607     err = st_lsm6dsx_shub_write_with_mask(sensor, fs_table->reg.addr,
0608                           fs_table->reg.mask,
0609                           fs_table->fs_avl[i].val);
0610     if (err < 0)
0611         return err;
0612 
0613     sensor->gain = gain;
0614 
0615     return 0;
0616 }
0617 
0618 static int
0619 st_lsm6dsx_shub_write_raw(struct iio_dev *iio_dev,
0620               struct iio_chan_spec const *chan,
0621               int val, int val2, long mask)
0622 {
0623     struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev);
0624     int err;
0625 
0626     err = iio_device_claim_direct_mode(iio_dev);
0627     if (err)
0628         return err;
0629 
0630     switch (mask) {
0631     case IIO_CHAN_INFO_SAMP_FREQ: {
0632         u16 data;
0633 
0634         val = val * 1000 + val2 / 1000;
0635         err = st_lsm6dsx_shub_get_odr_val(sensor, val, &data);
0636         if (!err) {
0637             struct st_lsm6dsx_hw *hw = sensor->hw;
0638             struct st_lsm6dsx_sensor *ref_sensor;
0639             u8 odr_val;
0640             int odr;
0641 
0642             ref_sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]);
0643             odr = st_lsm6dsx_check_odr(ref_sensor, val, &odr_val);
0644             if (odr < 0) {
0645                 err = odr;
0646                 goto release;
0647             }
0648 
0649             sensor->ext_info.slv_odr = val;
0650             sensor->odr = odr;
0651         }
0652         break;
0653     }
0654     case IIO_CHAN_INFO_SCALE:
0655         err = st_lsm6dsx_shub_set_full_scale(sensor, val2);
0656         break;
0657     default:
0658         err = -EINVAL;
0659         break;
0660     }
0661 
0662 release:
0663     iio_device_release_direct_mode(iio_dev);
0664 
0665     return err;
0666 }
0667 
0668 static ssize_t
0669 st_lsm6dsx_shub_sampling_freq_avail(struct device *dev,
0670                     struct device_attribute *attr,
0671                     char *buf)
0672 {
0673     struct st_lsm6dsx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
0674     const struct st_lsm6dsx_ext_dev_settings *settings;
0675     int i, len = 0;
0676 
0677     settings = sensor->ext_info.settings;
0678     for (i = 0; i < settings->odr_table.odr_len; i++) {
0679         u32 val = settings->odr_table.odr_avl[i].milli_hz;
0680 
0681         len += scnprintf(buf + len, PAGE_SIZE - len, "%d.%03d ",
0682                  val / 1000, val % 1000);
0683     }
0684     buf[len - 1] = '\n';
0685 
0686     return len;
0687 }
0688 
0689 static ssize_t st_lsm6dsx_shub_scale_avail(struct device *dev,
0690                        struct device_attribute *attr,
0691                        char *buf)
0692 {
0693     struct st_lsm6dsx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
0694     const struct st_lsm6dsx_ext_dev_settings *settings;
0695     int i, len = 0;
0696 
0697     settings = sensor->ext_info.settings;
0698     for (i = 0; i < settings->fs_table.fs_len; i++)
0699         len += scnprintf(buf + len, PAGE_SIZE - len, "0.%06u ",
0700                  settings->fs_table.fs_avl[i].gain);
0701     buf[len - 1] = '\n';
0702 
0703     return len;
0704 }
0705 
0706 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(st_lsm6dsx_shub_sampling_freq_avail);
0707 static IIO_DEVICE_ATTR(in_scale_available, 0444,
0708                st_lsm6dsx_shub_scale_avail, NULL, 0);
0709 static struct attribute *st_lsm6dsx_ext_attributes[] = {
0710     &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
0711     &iio_dev_attr_in_scale_available.dev_attr.attr,
0712     NULL,
0713 };
0714 
0715 static const struct attribute_group st_lsm6dsx_ext_attribute_group = {
0716     .attrs = st_lsm6dsx_ext_attributes,
0717 };
0718 
0719 static const struct iio_info st_lsm6dsx_ext_info = {
0720     .attrs = &st_lsm6dsx_ext_attribute_group,
0721     .read_raw = st_lsm6dsx_shub_read_raw,
0722     .write_raw = st_lsm6dsx_shub_write_raw,
0723     .hwfifo_set_watermark = st_lsm6dsx_set_watermark,
0724 };
0725 
0726 static struct iio_dev *
0727 st_lsm6dsx_shub_alloc_iiodev(struct st_lsm6dsx_hw *hw,
0728                  enum st_lsm6dsx_sensor_id id,
0729                  const struct st_lsm6dsx_ext_dev_settings *info,
0730                  u8 i2c_addr, const char *name)
0731 {
0732     enum st_lsm6dsx_sensor_id ref_id = ST_LSM6DSX_ID_ACC;
0733     struct iio_chan_spec *ext_channels;
0734     struct st_lsm6dsx_sensor *sensor;
0735     struct iio_dev *iio_dev;
0736 
0737     iio_dev = devm_iio_device_alloc(hw->dev, sizeof(*sensor));
0738     if (!iio_dev)
0739         return NULL;
0740 
0741     iio_dev->modes = INDIO_DIRECT_MODE;
0742     iio_dev->info = &st_lsm6dsx_ext_info;
0743 
0744     sensor = iio_priv(iio_dev);
0745     sensor->id = id;
0746     sensor->hw = hw;
0747     sensor->odr = hw->settings->odr_table[ref_id].odr_avl[0].milli_hz;
0748     sensor->ext_info.slv_odr = info->odr_table.odr_avl[0].milli_hz;
0749     sensor->gain = info->fs_table.fs_avl[0].gain;
0750     sensor->ext_info.settings = info;
0751     sensor->ext_info.addr = i2c_addr;
0752     sensor->watermark = 1;
0753 
0754     switch (info->id) {
0755     case ST_LSM6DSX_ID_MAGN: {
0756         const struct iio_chan_spec magn_channels[] = {
0757             ST_LSM6DSX_CHANNEL(IIO_MAGN, info->out.addr,
0758                        IIO_MOD_X, 0),
0759             ST_LSM6DSX_CHANNEL(IIO_MAGN, info->out.addr + 2,
0760                        IIO_MOD_Y, 1),
0761             ST_LSM6DSX_CHANNEL(IIO_MAGN, info->out.addr + 4,
0762                        IIO_MOD_Z, 2),
0763             IIO_CHAN_SOFT_TIMESTAMP(3),
0764         };
0765 
0766         ext_channels = devm_kzalloc(hw->dev, sizeof(magn_channels),
0767                         GFP_KERNEL);
0768         if (!ext_channels)
0769             return NULL;
0770 
0771         memcpy(ext_channels, magn_channels, sizeof(magn_channels));
0772         iio_dev->available_scan_masks = st_lsm6dsx_available_scan_masks;
0773         iio_dev->channels = ext_channels;
0774         iio_dev->num_channels = ARRAY_SIZE(magn_channels);
0775 
0776         scnprintf(sensor->name, sizeof(sensor->name), "%s_magn",
0777               name);
0778         break;
0779     }
0780     default:
0781         return NULL;
0782     }
0783     iio_dev->name = sensor->name;
0784 
0785     return iio_dev;
0786 }
0787 
0788 static int st_lsm6dsx_shub_init_device(struct st_lsm6dsx_sensor *sensor)
0789 {
0790     const struct st_lsm6dsx_ext_dev_settings *settings;
0791     int err;
0792 
0793     settings = sensor->ext_info.settings;
0794     if (settings->bdu.addr) {
0795         err = st_lsm6dsx_shub_write_with_mask(sensor,
0796                               settings->bdu.addr,
0797                               settings->bdu.mask, 1);
0798         if (err < 0)
0799             return err;
0800     }
0801 
0802     if (settings->temp_comp.addr) {
0803         err = st_lsm6dsx_shub_write_with_mask(sensor,
0804                     settings->temp_comp.addr,
0805                     settings->temp_comp.mask, 1);
0806         if (err < 0)
0807             return err;
0808     }
0809 
0810     if (settings->off_canc.addr) {
0811         err = st_lsm6dsx_shub_write_with_mask(sensor,
0812                     settings->off_canc.addr,
0813                     settings->off_canc.mask, 1);
0814         if (err < 0)
0815             return err;
0816     }
0817 
0818     return 0;
0819 }
0820 
0821 static int
0822 st_lsm6dsx_shub_check_wai(struct st_lsm6dsx_hw *hw, u8 *i2c_addr,
0823               const struct st_lsm6dsx_ext_dev_settings *settings)
0824 {
0825     const struct st_lsm6dsx_shub_settings *hub_settings;
0826     u8 config[3], data, slv_addr, slv_config = 0;
0827     const struct st_lsm6dsx_reg *aux_sens;
0828     struct st_lsm6dsx_sensor *sensor;
0829     bool found = false;
0830     int i, err;
0831 
0832     sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]);
0833     hub_settings = &hw->settings->shub_settings;
0834     aux_sens = &hw->settings->shub_settings.aux_sens;
0835     slv_addr = ST_LSM6DSX_SLV_ADDR(0, hub_settings->slv0_addr);
0836     /* do not overwrite aux_sens */
0837     if (slv_addr + 2 == aux_sens->addr)
0838         slv_config = ST_LSM6DSX_SHIFT_VAL(3, aux_sens->mask);
0839 
0840     for (i = 0; i < ARRAY_SIZE(settings->i2c_addr); i++) {
0841         if (!settings->i2c_addr[i])
0842             continue;
0843 
0844         /* read wai slave register */
0845         config[0] = (settings->i2c_addr[i] << 1) | 0x1;
0846         config[1] = settings->wai.addr;
0847         config[2] = 0x1 | slv_config;
0848 
0849         err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
0850                         sizeof(config));
0851         if (err < 0)
0852             return err;
0853 
0854         err = st_lsm6dsx_shub_master_enable(sensor, true);
0855         if (err < 0)
0856             return err;
0857 
0858         st_lsm6dsx_shub_wait_complete(hw);
0859 
0860         err = st_lsm6dsx_shub_read_output(hw, &data, sizeof(data));
0861 
0862         st_lsm6dsx_shub_master_enable(sensor, false);
0863 
0864         if (err < 0)
0865             return err;
0866 
0867         if (data != settings->wai.val)
0868             continue;
0869 
0870         *i2c_addr = settings->i2c_addr[i];
0871         found = true;
0872         break;
0873     }
0874 
0875     /* reset SLV0 channel */
0876     config[0] = hub_settings->pause;
0877     config[1] = 0;
0878     config[2] = slv_config;
0879     err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
0880                     sizeof(config));
0881     if (err < 0)
0882         return err;
0883 
0884     return found ? 0 : -ENODEV;
0885 }
0886 
0887 int st_lsm6dsx_shub_probe(struct st_lsm6dsx_hw *hw, const char *name)
0888 {
0889     enum st_lsm6dsx_sensor_id id = ST_LSM6DSX_ID_EXT0;
0890     struct st_lsm6dsx_sensor *sensor;
0891     int err, i, num_ext_dev = 0;
0892     u8 i2c_addr = 0;
0893 
0894     for (i = 0; i < ARRAY_SIZE(st_lsm6dsx_ext_dev_table); i++) {
0895         err = st_lsm6dsx_shub_check_wai(hw, &i2c_addr,
0896                     &st_lsm6dsx_ext_dev_table[i]);
0897         if (err == -ENODEV)
0898             continue;
0899         else if (err < 0)
0900             return err;
0901 
0902         hw->iio_devs[id] = st_lsm6dsx_shub_alloc_iiodev(hw, id,
0903                         &st_lsm6dsx_ext_dev_table[i],
0904                         i2c_addr, name);
0905         if (!hw->iio_devs[id])
0906             return -ENOMEM;
0907 
0908         sensor = iio_priv(hw->iio_devs[id]);
0909         err = st_lsm6dsx_shub_init_device(sensor);
0910         if (err < 0)
0911             return err;
0912 
0913         if (++num_ext_dev >= hw->settings->shub_settings.num_ext_dev)
0914             break;
0915         id++;
0916     }
0917 
0918     return 0;
0919 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!