drivers/misc/lis3lv02d/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         lis3_reg_ctrl(lis3, LIS3_REG_ON);
  83
  84         lis3->read(lis3, WHO_AM_I, &reg);
  85         if (reg != lis3->whoami)
  86                 printk(KERN_ERR "lis3: power on failure\n");
  87
  88         /* power up the device */
  89         ret = lis3->read(lis3, CTRL_REG1, &reg);
  90         if (ret < 0)
  91                 return ret;
  92
  93         reg |= CTRL1_PD0 | CTRL1_Xen | CTRL1_Yen | CTRL1_Zen;
  94         return lis3->write(lis3, CTRL_REG1, reg);
  95 }
  96
  97 /* Default axis mapping but it can be overwritten by platform data */
  98 static union axis_conversion lis3lv02d_axis_map =
  99         { .as_array = { LIS3_DEV_X, LIS3_DEV_Y, LIS3_DEV_Z } };
 100
 101 static int __devinit lis3lv02d_i2c_probe(struct i2c_client *client,
 102                                         const struct i2c_device_id *id)
 103 {
 104         int ret = 0;
 105         struct lis3lv02d_platform_data *pdata = client->dev.platform_data;
 106
 107         if (pdata) {
 108                 if ((pdata->driver_features & LIS3_USE_BLOCK_READ) &&
 109                         (i2c_check_functionality(client->adapter,
 110                                                 I2C_FUNC_SMBUS_I2C_BLOCK)))
 111                         lis3_dev.blkread  = lis3_i2c_blockread;
 112
 113                 if (pdata->axis_x)
 114                         lis3lv02d_axis_map.x = pdata->axis_x;
 115
 116                 if (pdata->axis_y)
 117                         lis3lv02d_axis_map.y = pdata->axis_y;
 118
 119                 if (pdata->axis_z)
 120                         lis3lv02d_axis_map.z = pdata->axis_z;
 121
 122                 if (pdata->setup_resources)
 123                         ret = pdata->setup_resources();
 124
 125                 if (ret)
 126                         goto fail;
 127         }
 128
 129         lis3_dev.regulators[0].supply = reg_vdd;
 130         lis3_dev.regulators[1].supply = reg_vdd_io;
 131         ret = regulator_bulk_get(&client->dev,
 132                                  ARRAY_SIZE(lis3_dev.regulators),
 133                                  lis3_dev.regulators);
 134         if (ret < 0)
 135                 goto fail;
 136
 137         lis3_dev.pdata    = pdata;
 138         lis3_dev.bus_priv = client;
 139         lis3_dev.init     = lis3_i2c_init;
 140         lis3_dev.read     = lis3_i2c_read;
 141         lis3_dev.write    = lis3_i2c_write;
 142         lis3_dev.irq      = client->irq;
 143         lis3_dev.ac       = lis3lv02d_axis_map;
 144         lis3_dev.pm_dev   = &client->dev;
 145
 146         i2c_set_clientdata(client, &lis3_dev);
 147
 148         /* Provide power over the init call */
 149         lis3_reg_ctrl(&lis3_dev, LIS3_REG_ON);
 150
 151         ret = lis3lv02d_init_device(&lis3_dev);
 152
 153         lis3_reg_ctrl(&lis3_dev, LIS3_REG_OFF);
 154
 155         if (ret)
 156                 goto fail2;
 157         return 0;
 158
 159 fail2:
 160         regulator_bulk_free(ARRAY_SIZE(lis3_dev.regulators),
 161                                 lis3_dev.regulators);
 162 fail:
 163         if (pdata && pdata->release_resources)
 164                 pdata->release_resources();
 165         return ret;
 166 }
 167
 168 static int __devexit lis3lv02d_i2c_remove(struct i2c_client *client)
 169 {
 170         struct lis3lv02d *lis3 = i2c_get_clientdata(client);
 171         struct lis3lv02d_platform_data *pdata = client->dev.platform_data;
 172
 173         if (pdata && pdata->release_resources)
 174                 pdata->release_resources();
 175
 176         lis3lv02d_joystick_disable(lis3);
 177         lis3lv02d_remove_fs(&lis3_dev);
 178
 179         regulator_bulk_free(ARRAY_SIZE(lis3->regulators),
 180                             lis3_dev.regulators);
 181         return 0;
 182 }
 183
 184 #ifdef CONFIG_PM_SLEEP
 185 static int lis3lv02d_i2c_suspend(struct device *dev)
 186 {
 187         struct i2c_client *client = container_of(dev, struct i2c_client, dev);
 188         struct lis3lv02d *lis3 = i2c_get_clientdata(client);
 189
 190         if (!lis3->pdata || !lis3->pdata->wakeup_flags)
 191                 lis3lv02d_poweroff(lis3);
 192         return 0;
 193 }
 194
 195 static int lis3lv02d_i2c_resume(struct device *dev)
 196 {
 197         struct i2c_client *client = container_of(dev, struct i2c_client, dev);
 198         struct lis3lv02d *lis3 = i2c_get_clientdata(client);
 199
 200         /*
 201          * pm_runtime documentation says that devices should always
 202          * be powered on at resume. Pm_runtime turns them off after system
 203          * wide resume is complete.
 204          */
 205         if (!lis3->pdata || !lis3->pdata->wakeup_flags ||
 206                 pm_runtime_suspended(dev))
 207                 lis3lv02d_poweron(lis3);
 208
 209         return 0;
 210 }
 211 #endif /* CONFIG_PM_SLEEP */
 212
 213 #ifdef CONFIG_PM_RUNTIME
 214 static int lis3_i2c_runtime_suspend(struct device *dev)
 215 {
 216         struct i2c_client *client = container_of(dev, struct i2c_client, dev);
 217         struct lis3lv02d *lis3 = i2c_get_clientdata(client);
 218
 219         lis3lv02d_poweroff(lis3);
 220         return 0;
 221 }
 222
 223 static int lis3_i2c_runtime_resume(struct device *dev)
 224 {
 225         struct i2c_client *client = container_of(dev, struct i2c_client, dev);
 226         struct lis3lv02d *lis3 = i2c_get_clientdata(client);
 227
 228         lis3lv02d_poweron(lis3);
 229         return 0;
 230 }
 231 #endif /* CONFIG_PM_RUNTIME */
 232
 233 static const struct i2c_device_id lis3lv02d_id[] = {
 234         {"lis3lv02d", 0 },
 235         {}
 236 };
 237
 238 MODULE_DEVICE_TABLE(i2c, lis3lv02d_id);
 239
 240 static const struct dev_pm_ops lis3_pm_ops = {
 241         SET_SYSTEM_SLEEP_PM_OPS(lis3lv02d_i2c_suspend,
 242                                 lis3lv02d_i2c_resume)
 243         SET_RUNTIME_PM_OPS(lis3_i2c_runtime_suspend,
 244                            lis3_i2c_runtime_resume,
 245                            NULL)
 246 };
 247
 248 static struct i2c_driver lis3lv02d_i2c_driver = {
 249         .driver  = {
 250                 .name   = DRV_NAME,
 251                 .owner  = THIS_MODULE,
 252                 .pm     = &lis3_pm_ops,
 253         },
 254         .probe  = lis3lv02d_i2c_probe,
 255         .remove = __devexit_p(lis3lv02d_i2c_remove),
 256         .id_table = lis3lv02d_id,
 257 };
 258
 259 static int __init lis3lv02d_init(void)
 260 {
 261         return i2c_add_driver(&lis3lv02d_i2c_driver);
 262 }
 263
 264 static void __exit lis3lv02d_exit(void)
 265 {
 266         i2c_del_driver(&lis3lv02d_i2c_driver);
 267 }
 268
 269 MODULE_AUTHOR("Nokia Corporation");
 270 MODULE_DESCRIPTION("lis3lv02d I2C interface");
 271 MODULE_LICENSE("GPL");
 272
 273 module_init(lis3lv02d_init);
 274 module_exit(lis3lv02d_exit);