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, ®); 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, ®); 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 module_i2c_driver(lis3lv02d_i2c_driver); 260 261 MODULE_AUTHOR("Nokia Corporation"); 262 MODULE_DESCRIPTION("lis3lv02d I2C interface"); 263 MODULE_LICENSE("GPL"); 264