Root/
1 | /* |
2 | * max8998.c - mfd core driver for the Maxim 8998 |
3 | * |
4 | * Copyright (C) 2009-2010 Samsung Electronics |
5 | * Kyungmin Park <kyungmin.park@samsung.com> |
6 | * Marek Szyprowski <m.szyprowski@samsung.com> |
7 | * |
8 | * This program is free software; you can redistribute it and/or modify |
9 | * it under the terms of the GNU General Public License as published by |
10 | * the Free Software Foundation; either version 2 of the License, or |
11 | * (at your option) any later version. |
12 | * |
13 | * This program is distributed in the hope that it will be useful, |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
16 | * GNU General Public License for more details. |
17 | * |
18 | * You should have received a copy of the GNU General Public License |
19 | * along with this program; if not, write to the Free Software |
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
21 | */ |
22 | |
23 | #include <linux/module.h> |
24 | #include <linux/moduleparam.h> |
25 | #include <linux/init.h> |
26 | #include <linux/slab.h> |
27 | #include <linux/i2c.h> |
28 | #include <linux/interrupt.h> |
29 | #include <linux/pm_runtime.h> |
30 | #include <linux/mutex.h> |
31 | #include <linux/mfd/core.h> |
32 | #include <linux/mfd/max8998.h> |
33 | #include <linux/mfd/max8998-private.h> |
34 | |
35 | #define RTC_I2C_ADDR (0x0c >> 1) |
36 | |
37 | static struct mfd_cell max8998_devs[] = { |
38 | { |
39 | .name = "max8998-pmic", |
40 | }, { |
41 | .name = "max8998-rtc", |
42 | }, { |
43 | .name = "max8998-battery", |
44 | }, |
45 | }; |
46 | |
47 | static struct mfd_cell lp3974_devs[] = { |
48 | { |
49 | .name = "lp3974-pmic", |
50 | }, { |
51 | .name = "lp3974-rtc", |
52 | }, |
53 | }; |
54 | |
55 | int max8998_read_reg(struct i2c_client *i2c, u8 reg, u8 *dest) |
56 | { |
57 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); |
58 | int ret; |
59 | |
60 | mutex_lock(&max8998->iolock); |
61 | ret = i2c_smbus_read_byte_data(i2c, reg); |
62 | mutex_unlock(&max8998->iolock); |
63 | if (ret < 0) |
64 | return ret; |
65 | |
66 | ret &= 0xff; |
67 | *dest = ret; |
68 | return 0; |
69 | } |
70 | EXPORT_SYMBOL(max8998_read_reg); |
71 | |
72 | int max8998_bulk_read(struct i2c_client *i2c, u8 reg, int count, u8 *buf) |
73 | { |
74 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); |
75 | int ret; |
76 | |
77 | mutex_lock(&max8998->iolock); |
78 | ret = i2c_smbus_read_i2c_block_data(i2c, reg, count, buf); |
79 | mutex_unlock(&max8998->iolock); |
80 | if (ret < 0) |
81 | return ret; |
82 | |
83 | return 0; |
84 | } |
85 | EXPORT_SYMBOL(max8998_bulk_read); |
86 | |
87 | int max8998_write_reg(struct i2c_client *i2c, u8 reg, u8 value) |
88 | { |
89 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); |
90 | int ret; |
91 | |
92 | mutex_lock(&max8998->iolock); |
93 | ret = i2c_smbus_write_byte_data(i2c, reg, value); |
94 | mutex_unlock(&max8998->iolock); |
95 | return ret; |
96 | } |
97 | EXPORT_SYMBOL(max8998_write_reg); |
98 | |
99 | int max8998_bulk_write(struct i2c_client *i2c, u8 reg, int count, u8 *buf) |
100 | { |
101 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); |
102 | int ret; |
103 | |
104 | mutex_lock(&max8998->iolock); |
105 | ret = i2c_smbus_write_i2c_block_data(i2c, reg, count, buf); |
106 | mutex_unlock(&max8998->iolock); |
107 | if (ret < 0) |
108 | return ret; |
109 | |
110 | return 0; |
111 | } |
112 | EXPORT_SYMBOL(max8998_bulk_write); |
113 | |
114 | int max8998_update_reg(struct i2c_client *i2c, u8 reg, u8 val, u8 mask) |
115 | { |
116 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); |
117 | int ret; |
118 | |
119 | mutex_lock(&max8998->iolock); |
120 | ret = i2c_smbus_read_byte_data(i2c, reg); |
121 | if (ret >= 0) { |
122 | u8 old_val = ret & 0xff; |
123 | u8 new_val = (val & mask) | (old_val & (~mask)); |
124 | ret = i2c_smbus_write_byte_data(i2c, reg, new_val); |
125 | } |
126 | mutex_unlock(&max8998->iolock); |
127 | return ret; |
128 | } |
129 | EXPORT_SYMBOL(max8998_update_reg); |
130 | |
131 | static int max8998_i2c_probe(struct i2c_client *i2c, |
132 | const struct i2c_device_id *id) |
133 | { |
134 | struct max8998_platform_data *pdata = i2c->dev.platform_data; |
135 | struct max8998_dev *max8998; |
136 | int ret = 0; |
137 | |
138 | max8998 = kzalloc(sizeof(struct max8998_dev), GFP_KERNEL); |
139 | if (max8998 == NULL) |
140 | return -ENOMEM; |
141 | |
142 | i2c_set_clientdata(i2c, max8998); |
143 | max8998->dev = &i2c->dev; |
144 | max8998->i2c = i2c; |
145 | max8998->irq = i2c->irq; |
146 | max8998->type = id->driver_data; |
147 | if (pdata) { |
148 | max8998->ono = pdata->ono; |
149 | max8998->irq_base = pdata->irq_base; |
150 | max8998->wakeup = pdata->wakeup; |
151 | } |
152 | mutex_init(&max8998->iolock); |
153 | |
154 | max8998->rtc = i2c_new_dummy(i2c->adapter, RTC_I2C_ADDR); |
155 | i2c_set_clientdata(max8998->rtc, max8998); |
156 | |
157 | max8998_irq_init(max8998); |
158 | |
159 | pm_runtime_set_active(max8998->dev); |
160 | |
161 | switch (id->driver_data) { |
162 | case TYPE_LP3974: |
163 | ret = mfd_add_devices(max8998->dev, -1, |
164 | lp3974_devs, ARRAY_SIZE(lp3974_devs), |
165 | NULL, 0, NULL); |
166 | break; |
167 | case TYPE_MAX8998: |
168 | ret = mfd_add_devices(max8998->dev, -1, |
169 | max8998_devs, ARRAY_SIZE(max8998_devs), |
170 | NULL, 0, NULL); |
171 | break; |
172 | default: |
173 | ret = -EINVAL; |
174 | } |
175 | |
176 | if (ret < 0) |
177 | goto err; |
178 | |
179 | device_init_wakeup(max8998->dev, max8998->wakeup); |
180 | |
181 | return ret; |
182 | |
183 | err: |
184 | mfd_remove_devices(max8998->dev); |
185 | max8998_irq_exit(max8998); |
186 | i2c_unregister_device(max8998->rtc); |
187 | kfree(max8998); |
188 | return ret; |
189 | } |
190 | |
191 | static int max8998_i2c_remove(struct i2c_client *i2c) |
192 | { |
193 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); |
194 | |
195 | mfd_remove_devices(max8998->dev); |
196 | max8998_irq_exit(max8998); |
197 | i2c_unregister_device(max8998->rtc); |
198 | kfree(max8998); |
199 | |
200 | return 0; |
201 | } |
202 | |
203 | static const struct i2c_device_id max8998_i2c_id[] = { |
204 | { "max8998", TYPE_MAX8998 }, |
205 | { "lp3974", TYPE_LP3974}, |
206 | { } |
207 | }; |
208 | MODULE_DEVICE_TABLE(i2c, max8998_i2c_id); |
209 | |
210 | static int max8998_suspend(struct device *dev) |
211 | { |
212 | struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); |
213 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); |
214 | |
215 | if (device_may_wakeup(dev)) |
216 | irq_set_irq_wake(max8998->irq, 1); |
217 | return 0; |
218 | } |
219 | |
220 | static int max8998_resume(struct device *dev) |
221 | { |
222 | struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); |
223 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); |
224 | |
225 | if (device_may_wakeup(dev)) |
226 | irq_set_irq_wake(max8998->irq, 0); |
227 | /* |
228 | * In LP3974, if IRQ registers are not "read & clear" |
229 | * when it's set during sleep, the interrupt becomes |
230 | * disabled. |
231 | */ |
232 | return max8998_irq_resume(i2c_get_clientdata(i2c)); |
233 | } |
234 | |
235 | struct max8998_reg_dump { |
236 | u8 addr; |
237 | u8 val; |
238 | }; |
239 | #define SAVE_ITEM(x) { .addr = (x), .val = 0x0, } |
240 | static struct max8998_reg_dump max8998_dump[] = { |
241 | SAVE_ITEM(MAX8998_REG_IRQM1), |
242 | SAVE_ITEM(MAX8998_REG_IRQM2), |
243 | SAVE_ITEM(MAX8998_REG_IRQM3), |
244 | SAVE_ITEM(MAX8998_REG_IRQM4), |
245 | SAVE_ITEM(MAX8998_REG_STATUSM1), |
246 | SAVE_ITEM(MAX8998_REG_STATUSM2), |
247 | SAVE_ITEM(MAX8998_REG_CHGR1), |
248 | SAVE_ITEM(MAX8998_REG_CHGR2), |
249 | SAVE_ITEM(MAX8998_REG_LDO_ACTIVE_DISCHARGE1), |
250 | SAVE_ITEM(MAX8998_REG_LDO_ACTIVE_DISCHARGE1), |
251 | SAVE_ITEM(MAX8998_REG_BUCK_ACTIVE_DISCHARGE3), |
252 | SAVE_ITEM(MAX8998_REG_ONOFF1), |
253 | SAVE_ITEM(MAX8998_REG_ONOFF2), |
254 | SAVE_ITEM(MAX8998_REG_ONOFF3), |
255 | SAVE_ITEM(MAX8998_REG_ONOFF4), |
256 | SAVE_ITEM(MAX8998_REG_BUCK1_VOLTAGE1), |
257 | SAVE_ITEM(MAX8998_REG_BUCK1_VOLTAGE2), |
258 | SAVE_ITEM(MAX8998_REG_BUCK1_VOLTAGE3), |
259 | SAVE_ITEM(MAX8998_REG_BUCK1_VOLTAGE4), |
260 | SAVE_ITEM(MAX8998_REG_BUCK2_VOLTAGE1), |
261 | SAVE_ITEM(MAX8998_REG_BUCK2_VOLTAGE2), |
262 | SAVE_ITEM(MAX8998_REG_LDO2_LDO3), |
263 | SAVE_ITEM(MAX8998_REG_LDO4), |
264 | SAVE_ITEM(MAX8998_REG_LDO5), |
265 | SAVE_ITEM(MAX8998_REG_LDO6), |
266 | SAVE_ITEM(MAX8998_REG_LDO7), |
267 | SAVE_ITEM(MAX8998_REG_LDO8_LDO9), |
268 | SAVE_ITEM(MAX8998_REG_LDO10_LDO11), |
269 | SAVE_ITEM(MAX8998_REG_LDO12), |
270 | SAVE_ITEM(MAX8998_REG_LDO13), |
271 | SAVE_ITEM(MAX8998_REG_LDO14), |
272 | SAVE_ITEM(MAX8998_REG_LDO15), |
273 | SAVE_ITEM(MAX8998_REG_LDO16), |
274 | SAVE_ITEM(MAX8998_REG_LDO17), |
275 | SAVE_ITEM(MAX8998_REG_BKCHR), |
276 | SAVE_ITEM(MAX8998_REG_LBCNFG1), |
277 | SAVE_ITEM(MAX8998_REG_LBCNFG2), |
278 | }; |
279 | /* Save registers before hibernation */ |
280 | static int max8998_freeze(struct device *dev) |
281 | { |
282 | struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); |
283 | int i; |
284 | |
285 | for (i = 0; i < ARRAY_SIZE(max8998_dump); i++) |
286 | max8998_read_reg(i2c, max8998_dump[i].addr, |
287 | &max8998_dump[i].val); |
288 | |
289 | return 0; |
290 | } |
291 | |
292 | /* Restore registers after hibernation */ |
293 | static int max8998_restore(struct device *dev) |
294 | { |
295 | struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); |
296 | int i; |
297 | |
298 | for (i = 0; i < ARRAY_SIZE(max8998_dump); i++) |
299 | max8998_write_reg(i2c, max8998_dump[i].addr, |
300 | max8998_dump[i].val); |
301 | |
302 | return 0; |
303 | } |
304 | |
305 | static const struct dev_pm_ops max8998_pm = { |
306 | .suspend = max8998_suspend, |
307 | .resume = max8998_resume, |
308 | .freeze = max8998_freeze, |
309 | .restore = max8998_restore, |
310 | }; |
311 | |
312 | static struct i2c_driver max8998_i2c_driver = { |
313 | .driver = { |
314 | .name = "max8998", |
315 | .owner = THIS_MODULE, |
316 | .pm = &max8998_pm, |
317 | }, |
318 | .probe = max8998_i2c_probe, |
319 | .remove = max8998_i2c_remove, |
320 | .id_table = max8998_i2c_id, |
321 | }; |
322 | |
323 | static int __init max8998_i2c_init(void) |
324 | { |
325 | return i2c_add_driver(&max8998_i2c_driver); |
326 | } |
327 | /* init early so consumer devices can complete system boot */ |
328 | subsys_initcall(max8998_i2c_init); |
329 | |
330 | static void __exit max8998_i2c_exit(void) |
331 | { |
332 | i2c_del_driver(&max8998_i2c_driver); |
333 | } |
334 | module_exit(max8998_i2c_exit); |
335 | |
336 | MODULE_DESCRIPTION("MAXIM 8998 multi-function core driver"); |
337 | MODULE_AUTHOR("Kyungmin Park <kyungmin.park@samsung.com>"); |
338 | MODULE_LICENSE("GPL"); |
339 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9