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