drivers/hwmon/lis3lv02d_i2c.c

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