drivers/misc/lis3lv02d/lis3lv02d_i2c.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * drivers/hwmon/lis3lv02d_i2c.c
   4  *
   5  * Implements I2C interface for lis3lv02d (STMicroelectronics) accelerometer.
   6  * Driver is based on corresponding SPI driver written by Daniel Mack
   7  * (lis3lv02d_spi.c (C) 2009 Daniel Mack <daniel@caiaq.de> ).
   8  *
   9  * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
  10  *
  11  * Contact: Samu Onkalo <samu.p.onkalo@nokia.com>
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/kernel.h>
  16 #include <linux/err.h>
  17 #include <linux/i2c.h>
  18 #include <linux/pm_runtime.h>
  19 #include <linux/delay.h>
  20 #include <linux/of.h>
  21 #include <linux/of_platform.h>
  22 #include <linux/of_device.h>
  23
  24 #include "lis3lv02d.h"
  25
  26 #define DRV_NAME        "lis3lv02d_i2c"
  27
  28 static const char reg_vdd[]    = "Vdd";
  29 static const char reg_vdd_io[] = "Vdd_IO";
  30
  31 static int lis3_reg_ctrl(struct lis3lv02d *lis3, bool state)
  32 {
  33         int ret;
  34         if (state == LIS3_REG_OFF) {
  35                 ret = regulator_bulk_disable(ARRAY_SIZE(lis3->regulators),
  36                                         lis3->regulators);
  37         } else {
  38                 ret = regulator_bulk_enable(ARRAY_SIZE(lis3->regulators),
  39                                         lis3->regulators);
  40                 /* Chip needs time to wakeup. Not mentioned in datasheet */
  41                 usleep_range(10000, 20000);
  42         }
  43         return ret;
  44 }
  45
  46 static inline s32 lis3_i2c_write(struct lis3lv02d *lis3, int reg, u8 value)
  47 {
  48         struct i2c_client *c = lis3->bus_priv;
  49         return i2c_smbus_write_byte_data(c, reg, value);
  50 }
  51
  52 static inline s32 lis3_i2c_read(struct lis3lv02d *lis3, int reg, u8 *v)
  53 {
  54         struct i2c_client *c = lis3->bus_priv;
  55         *v = i2c_smbus_read_byte_data(c, reg);
  56         return 0;
  57 }
  58
  59 static inline s32 lis3_i2c_blockread(struct lis3lv02d *lis3, int reg, int len,
  60                                 u8 *v)
  61 {
  62         struct i2c_client *c = lis3->bus_priv;
  63         reg |= (1 << 7); /* 7th bit enables address auto incrementation */
  64         return i2c_smbus_read_i2c_block_data(c, reg, len, v);
  65 }
  66
  67 static int lis3_i2c_init(struct lis3lv02d *lis3)
  68 {
  69         u8 reg;
  70         int ret;
  71
  72         lis3_reg_ctrl(lis3, LIS3_REG_ON);
  73
  74         lis3->read(lis3, WHO_AM_I, &reg);
  75         if (reg != lis3->whoami)
  76                 printk(KERN_ERR "lis3: power on failure\n");
  77
  78         /* power up the device */
  79         ret = lis3->read(lis3, CTRL_REG1, &reg);
  80         if (ret < 0)
  81                 return ret;
  82
  83         if (lis3->whoami == WAI_3DLH)
  84                 reg |= CTRL1_PM0 | CTRL1_Xen | CTRL1_Yen | CTRL1_Zen;
  85         else
  86                 reg |= CTRL1_PD0 | CTRL1_Xen | CTRL1_Yen | CTRL1_Zen;
  87
  88         return lis3->write(lis3, CTRL_REG1, reg);
  89 }
  90
  91 /* Default axis mapping but it can be overwritten by platform data */
  92 static union axis_conversion lis3lv02d_axis_map =
  93         { .as_array = { LIS3_DEV_X, LIS3_DEV_Y, LIS3_DEV_Z } };
  94
  95 #ifdef CONFIG_OF
  96 static const struct of_device_id lis3lv02d_i2c_dt_ids[] = {
  97         { .compatible = "st,lis3lv02d" },
  98         {}
  99 };
 100 MODULE_DEVICE_TABLE(of, lis3lv02d_i2c_dt_ids);
 101 #endif
 102
 103 static int lis3lv02d_i2c_probe(struct i2c_client *client,
 104                                         const struct i2c_device_id *id)
 105 {
 106         int ret = 0;
 107         struct lis3lv02d_platform_data *pdata = client->dev.platform_data;
 108
 109 #ifdef CONFIG_OF
 110         if (of_match_device(lis3lv02d_i2c_dt_ids, &client->dev)) {
 111                 lis3_dev.of_node = client->dev.of_node;
 112                 ret = lis3lv02d_init_dt(&lis3_dev);
 113                 if (ret)
 114                         return ret;
 115                 pdata = lis3_dev.pdata;
 116         }
 117 #endif
 118
 119         if (pdata) {
 120                 if ((pdata->driver_features & LIS3_USE_BLOCK_READ) &&
 121                         (i2c_check_functionality(client->adapter,
 122                                                 I2C_FUNC_SMBUS_I2C_BLOCK)))
 123                         lis3_dev.blkread  = lis3_i2c_blockread;
 124
 125                 if (pdata->axis_x)
 126                         lis3lv02d_axis_map.x = pdata->axis_x;
 127
 128                 if (pdata->axis_y)
 129                         lis3lv02d_axis_map.y = pdata->axis_y;
 130
 131                 if (pdata->axis_z)
 132                         lis3lv02d_axis_map.z = pdata->axis_z;
 133
 134                 if (pdata->setup_resources)
 135                         ret = pdata->setup_resources();
 136
 137                 if (ret)
 138                         goto fail;
 139         }
 140
 141         lis3_dev.regulators[0].supply = reg_vdd;
 142         lis3_dev.regulators[1].supply = reg_vdd_io;
 143         ret = regulator_bulk_get(&client->dev,
 144                                  ARRAY_SIZE(lis3_dev.regulators),
 145                                  lis3_dev.regulators);
 146         if (ret < 0)
 147                 goto fail;
 148
 149         lis3_dev.pdata    = pdata;
 150         lis3_dev.bus_priv = client;
 151         lis3_dev.init     = lis3_i2c_init;
 152         lis3_dev.read     = lis3_i2c_read;
 153         lis3_dev.write    = lis3_i2c_write;
 154         lis3_dev.irq      = client->irq;
 155         lis3_dev.ac       = lis3lv02d_axis_map;
 156         lis3_dev.pm_dev   = &client->dev;
 157
 158         i2c_set_clientdata(client, &lis3_dev);
 159
 160         /* Provide power over the init call */
 161         lis3_reg_ctrl(&lis3_dev, LIS3_REG_ON);
 162
 163         ret = lis3lv02d_init_device(&lis3_dev);
 164
 165         lis3_reg_ctrl(&lis3_dev, LIS3_REG_OFF);
 166
 167         if (ret)
 168                 goto fail2;
 169         return 0;
 170
 171 fail2:
 172         regulator_bulk_free(ARRAY_SIZE(lis3_dev.regulators),
 173                                 lis3_dev.regulators);
 174 fail:
 175         if (pdata && pdata->release_resources)
 176                 pdata->release_resources();
 177         return ret;
 178 }
 179
 180 static int lis3lv02d_i2c_remove(struct i2c_client *client)
 181 {
 182         struct lis3lv02d *lis3 = i2c_get_clientdata(client);
 183         struct lis3lv02d_platform_data *pdata = client->dev.platform_data;
 184
 185         if (pdata && pdata->release_resources)
 186                 pdata->release_resources();
 187
 188         lis3lv02d_joystick_disable(lis3);
 189         lis3lv02d_remove_fs(&lis3_dev);
 190
 191         regulator_bulk_free(ARRAY_SIZE(lis3->regulators),
 192                             lis3_dev.regulators);
 193         return 0;
 194 }
 195
 196 #ifdef CONFIG_PM_SLEEP
 197 static int lis3lv02d_i2c_suspend(struct device *dev)
 198 {
 199         struct i2c_client *client = to_i2c_client(dev);
 200         struct lis3lv02d *lis3 = i2c_get_clientdata(client);
 201
 202         if (!lis3->pdata || !lis3->pdata->wakeup_flags)
 203                 lis3lv02d_poweroff(lis3);
 204         return 0;
 205 }
 206
 207 static int lis3lv02d_i2c_resume(struct device *dev)
 208 {
 209         struct i2c_client *client = to_i2c_client(dev);
 210         struct lis3lv02d *lis3 = i2c_get_clientdata(client);
 211
 212         /*
 213          * pm_runtime documentation says that devices should always
 214          * be powered on at resume. Pm_runtime turns them off after system
 215          * wide resume is complete.
 216          */
 217         if (!lis3->pdata || !lis3->pdata->wakeup_flags ||
 218                 pm_runtime_suspended(dev))
 219                 lis3lv02d_poweron(lis3);
 220
 221         return 0;
 222 }
 223 #endif /* CONFIG_PM_SLEEP */
 224
 225 #ifdef CONFIG_PM
 226 static int lis3_i2c_runtime_suspend(struct device *dev)
 227 {
 228         struct i2c_client *client = to_i2c_client(dev);
 229         struct lis3lv02d *lis3 = i2c_get_clientdata(client);
 230
 231         lis3lv02d_poweroff(lis3);
 232         return 0;
 233 }
 234
 235 static int lis3_i2c_runtime_resume(struct device *dev)
 236 {
 237         struct i2c_client *client = to_i2c_client(dev);
 238         struct lis3lv02d *lis3 = i2c_get_clientdata(client);
 239
 240         lis3lv02d_poweron(lis3);
 241         return 0;
 242 }
 243 #endif /* CONFIG_PM */
 244
 245 static const struct i2c_device_id lis3lv02d_id[] = {
 246         {"lis3lv02d", LIS3LV02D},
 247         {"lis331dlh", LIS331DLH},
 248         {}
 249 };
 250
 251 MODULE_DEVICE_TABLE(i2c, lis3lv02d_id);
 252
 253 static const struct dev_pm_ops lis3_pm_ops = {
 254         SET_SYSTEM_SLEEP_PM_OPS(lis3lv02d_i2c_suspend,
 255                                 lis3lv02d_i2c_resume)
 256         SET_RUNTIME_PM_OPS(lis3_i2c_runtime_suspend,
 257                            lis3_i2c_runtime_resume,
 258                            NULL)
 259 };
 260
 261 static struct i2c_driver lis3lv02d_i2c_driver = {
 262         .driver  = {
 263                 .name   = DRV_NAME,
 264                 .pm     = &lis3_pm_ops,
 265                 .of_match_table = of_match_ptr(lis3lv02d_i2c_dt_ids),
 266         },
 267         .probe  = lis3lv02d_i2c_probe,
 268         .remove = lis3lv02d_i2c_remove,
 269         .id_table = lis3lv02d_id,
 270 };
 271
 272 module_i2c_driver(lis3lv02d_i2c_driver);
 273
 274 MODULE_AUTHOR("Nokia Corporation");
 275 MODULE_DESCRIPTION("lis3lv02d I2C interface");
 276 MODULE_LICENSE("GPL");