Commit | Line | Data |
---|---|---|
e60fea79 | 1 | /* |
2 | * Generic battery driver code using IIO | |
3 | * Copyright (C) 2012, Anish Kumar <anish198519851985@gmail.com> | |
4 | * based on jz4740-battery.c | |
5 | * based on s3c_adc_battery.c | |
6 | * | |
7 | * This file is subject to the terms and conditions of the GNU General Public | |
8 | * License. See the file COPYING in the main directory of this archive for | |
9 | * more details. | |
10 | * | |
11 | */ | |
12 | #include <linux/interrupt.h> | |
13 | #include <linux/platform_device.h> | |
14 | #include <linux/power_supply.h> | |
15 | #include <linux/gpio.h> | |
16 | #include <linux/err.h> | |
17 | #include <linux/timer.h> | |
18 | #include <linux/jiffies.h> | |
19 | #include <linux/errno.h> | |
20 | #include <linux/init.h> | |
21 | #include <linux/module.h> | |
22 | #include <linux/slab.h> | |
23 | #include <linux/iio/consumer.h> | |
24 | #include <linux/iio/types.h> | |
25 | #include <linux/power/generic-adc-battery.h> | |
26 | ||
27 | #define JITTER_DEFAULT 10 /* hope 10ms is enough */ | |
28 | ||
29 | enum gab_chan_type { | |
30 | GAB_VOLTAGE = 0, | |
31 | GAB_CURRENT, | |
32 | GAB_POWER, | |
33 | GAB_MAX_CHAN_TYPE | |
34 | }; | |
35 | ||
36 | /* | |
37 | * gab_chan_name suggests the standard channel names for commonly used | |
38 | * channel types. | |
39 | */ | |
40 | static const char *const gab_chan_name[] = { | |
41 | [GAB_VOLTAGE] = "voltage", | |
42 | [GAB_CURRENT] = "current", | |
43 | [GAB_POWER] = "power", | |
44 | }; | |
45 | ||
46 | struct gab { | |
47 | struct power_supply psy; | |
48 | struct iio_channel *channel[GAB_MAX_CHAN_TYPE]; | |
49 | struct gab_platform_data *pdata; | |
50 | struct delayed_work bat_work; | |
51 | int level; | |
52 | int status; | |
53 | bool cable_plugged; | |
54 | }; | |
55 | ||
56 | static struct gab *to_generic_bat(struct power_supply *psy) | |
57 | { | |
58 | return container_of(psy, struct gab, psy); | |
59 | } | |
60 | ||
61 | static void gab_ext_power_changed(struct power_supply *psy) | |
62 | { | |
63 | struct gab *adc_bat = to_generic_bat(psy); | |
64 | ||
65 | schedule_delayed_work(&adc_bat->bat_work, msecs_to_jiffies(0)); | |
66 | } | |
67 | ||
68 | static const enum power_supply_property gab_props[] = { | |
69 | POWER_SUPPLY_PROP_STATUS, | |
70 | POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, | |
71 | POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN, | |
72 | POWER_SUPPLY_PROP_CHARGE_NOW, | |
73 | POWER_SUPPLY_PROP_VOLTAGE_NOW, | |
74 | POWER_SUPPLY_PROP_CURRENT_NOW, | |
75 | POWER_SUPPLY_PROP_TECHNOLOGY, | |
76 | POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, | |
77 | POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, | |
78 | POWER_SUPPLY_PROP_MODEL_NAME, | |
79 | }; | |
80 | ||
81 | /* | |
82 | * This properties are set based on the received platform data and this | |
83 | * should correspond one-to-one with enum chan_type. | |
84 | */ | |
85 | static const enum power_supply_property gab_dyn_props[] = { | |
86 | POWER_SUPPLY_PROP_VOLTAGE_NOW, | |
87 | POWER_SUPPLY_PROP_CURRENT_NOW, | |
88 | POWER_SUPPLY_PROP_POWER_NOW, | |
89 | }; | |
90 | ||
91 | static bool gab_charge_finished(struct gab *adc_bat) | |
92 | { | |
93 | struct gab_platform_data *pdata = adc_bat->pdata; | |
94 | bool ret = gpio_get_value(pdata->gpio_charge_finished); | |
95 | bool inv = pdata->gpio_inverted; | |
96 | ||
97 | if (!gpio_is_valid(pdata->gpio_charge_finished)) | |
98 | return false; | |
99 | return ret ^ inv; | |
100 | } | |
101 | ||
102 | static int gab_get_status(struct gab *adc_bat) | |
103 | { | |
104 | struct gab_platform_data *pdata = adc_bat->pdata; | |
105 | struct power_supply_info *bat_info; | |
106 | ||
107 | bat_info = &pdata->battery_info; | |
108 | if (adc_bat->level == bat_info->charge_full_design) | |
109 | return POWER_SUPPLY_STATUS_FULL; | |
110 | return adc_bat->status; | |
111 | } | |
112 | ||
113 | static enum gab_chan_type gab_prop_to_chan(enum power_supply_property psp) | |
114 | { | |
115 | switch (psp) { | |
116 | case POWER_SUPPLY_PROP_POWER_NOW: | |
117 | return GAB_POWER; | |
118 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: | |
119 | return GAB_VOLTAGE; | |
120 | case POWER_SUPPLY_PROP_CURRENT_NOW: | |
121 | return GAB_CURRENT; | |
122 | default: | |
123 | WARN_ON(1); | |
124 | break; | |
125 | } | |
126 | return GAB_POWER; | |
127 | } | |
128 | ||
129 | static int read_channel(struct gab *adc_bat, enum power_supply_property psp, | |
130 | int *result) | |
131 | { | |
132 | int ret; | |
133 | int chan_index; | |
134 | ||
135 | chan_index = gab_prop_to_chan(psp); | |
136 | ret = iio_read_channel_processed(adc_bat->channel[chan_index], | |
137 | result); | |
138 | if (ret < 0) | |
139 | pr_err("read channel error\n"); | |
140 | return ret; | |
141 | } | |
142 | ||
143 | static int gab_get_property(struct power_supply *psy, | |
144 | enum power_supply_property psp, union power_supply_propval *val) | |
145 | { | |
146 | struct gab *adc_bat; | |
147 | struct gab_platform_data *pdata; | |
148 | struct power_supply_info *bat_info; | |
149 | int result = 0; | |
150 | int ret = 0; | |
151 | ||
152 | adc_bat = to_generic_bat(psy); | |
153 | if (!adc_bat) { | |
154 | dev_err(psy->dev, "no battery infos ?!\n"); | |
155 | return -EINVAL; | |
156 | } | |
157 | pdata = adc_bat->pdata; | |
158 | bat_info = &pdata->battery_info; | |
159 | ||
160 | switch (psp) { | |
161 | case POWER_SUPPLY_PROP_STATUS: | |
162 | gab_get_status(adc_bat); | |
163 | break; | |
164 | case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN: | |
165 | val->intval = 0; | |
166 | break; | |
167 | case POWER_SUPPLY_PROP_CHARGE_NOW: | |
168 | val->intval = pdata->cal_charge(result); | |
169 | break; | |
170 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: | |
171 | case POWER_SUPPLY_PROP_CURRENT_NOW: | |
172 | case POWER_SUPPLY_PROP_POWER_NOW: | |
173 | ret = read_channel(adc_bat, psp, &result); | |
174 | if (ret < 0) | |
175 | goto err; | |
176 | val->intval = result; | |
177 | break; | |
178 | case POWER_SUPPLY_PROP_TECHNOLOGY: | |
179 | val->intval = bat_info->technology; | |
180 | break; | |
181 | case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: | |
182 | val->intval = bat_info->voltage_min_design; | |
183 | break; | |
184 | case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: | |
185 | val->intval = bat_info->voltage_max_design; | |
186 | break; | |
187 | case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: | |
188 | val->intval = bat_info->charge_full_design; | |
189 | break; | |
190 | case POWER_SUPPLY_PROP_MODEL_NAME: | |
191 | val->strval = bat_info->name; | |
192 | break; | |
193 | default: | |
194 | return -EINVAL; | |
195 | } | |
196 | err: | |
197 | return ret; | |
198 | } | |
199 | ||
200 | static void gab_work(struct work_struct *work) | |
201 | { | |
202 | struct gab *adc_bat; | |
203 | struct gab_platform_data *pdata; | |
204 | struct delayed_work *delayed_work; | |
205 | bool is_plugged; | |
206 | int status; | |
207 | ||
208 | delayed_work = container_of(work, struct delayed_work, work); | |
209 | adc_bat = container_of(delayed_work, struct gab, bat_work); | |
210 | pdata = adc_bat->pdata; | |
211 | status = adc_bat->status; | |
212 | ||
213 | is_plugged = power_supply_am_i_supplied(&adc_bat->psy); | |
214 | adc_bat->cable_plugged = is_plugged; | |
215 | ||
216 | if (!is_plugged) | |
217 | adc_bat->status = POWER_SUPPLY_STATUS_DISCHARGING; | |
218 | else if (gab_charge_finished(adc_bat)) | |
219 | adc_bat->status = POWER_SUPPLY_STATUS_NOT_CHARGING; | |
220 | else | |
221 | adc_bat->status = POWER_SUPPLY_STATUS_CHARGING; | |
222 | ||
223 | if (status != adc_bat->status) | |
224 | power_supply_changed(&adc_bat->psy); | |
225 | } | |
226 | ||
227 | static irqreturn_t gab_charged(int irq, void *dev_id) | |
228 | { | |
229 | struct gab *adc_bat = dev_id; | |
230 | struct gab_platform_data *pdata = adc_bat->pdata; | |
231 | int delay; | |
232 | ||
233 | delay = pdata->jitter_delay ? pdata->jitter_delay : JITTER_DEFAULT; | |
234 | schedule_delayed_work(&adc_bat->bat_work, | |
235 | msecs_to_jiffies(delay)); | |
236 | return IRQ_HANDLED; | |
237 | } | |
238 | ||
c8afa640 | 239 | static int gab_probe(struct platform_device *pdev) |
e60fea79 | 240 | { |
241 | struct gab *adc_bat; | |
242 | struct power_supply *psy; | |
243 | struct gab_platform_data *pdata = pdev->dev.platform_data; | |
244 | enum power_supply_property *properties; | |
245 | int ret = 0; | |
246 | int chan; | |
247 | int index = 0; | |
248 | ||
249 | adc_bat = devm_kzalloc(&pdev->dev, sizeof(*adc_bat), GFP_KERNEL); | |
250 | if (!adc_bat) { | |
251 | dev_err(&pdev->dev, "failed to allocate memory\n"); | |
252 | return -ENOMEM; | |
253 | } | |
254 | ||
255 | psy = &adc_bat->psy; | |
256 | psy->name = pdata->battery_info.name; | |
257 | ||
258 | /* bootup default values for the battery */ | |
259 | adc_bat->cable_plugged = false; | |
260 | adc_bat->status = POWER_SUPPLY_STATUS_DISCHARGING; | |
261 | psy->type = POWER_SUPPLY_TYPE_BATTERY; | |
262 | psy->get_property = gab_get_property; | |
263 | psy->external_power_changed = gab_ext_power_changed; | |
264 | adc_bat->pdata = pdata; | |
265 | ||
e60fea79 | 266 | /* |
267 | * copying the static properties and allocating extra memory for holding | |
268 | * the extra configurable properties received from platform data. | |
269 | */ | |
270 | psy->properties = kcalloc(ARRAY_SIZE(gab_props) + | |
271 | ARRAY_SIZE(gab_chan_name), | |
272 | sizeof(*psy->properties), GFP_KERNEL); | |
273 | if (!psy->properties) { | |
274 | ret = -ENOMEM; | |
275 | goto first_mem_fail; | |
276 | } | |
277 | ||
278 | memcpy(psy->properties, gab_props, sizeof(gab_props)); | |
a77d60ae DC |
279 | properties = (enum power_supply_property *) |
280 | ((char *)psy->properties + sizeof(gab_props)); | |
e60fea79 | 281 | |
282 | /* | |
283 | * getting channel from iio and copying the battery properties | |
284 | * based on the channel supported by consumer device. | |
285 | */ | |
286 | for (chan = 0; chan < ARRAY_SIZE(gab_chan_name); chan++) { | |
5aa57f0a GR |
287 | adc_bat->channel[chan] = iio_channel_get(&pdev->dev, |
288 | gab_chan_name[chan]); | |
e60fea79 | 289 | if (IS_ERR(adc_bat->channel[chan])) { |
290 | ret = PTR_ERR(adc_bat->channel[chan]); | |
64d26f22 | 291 | adc_bat->channel[chan] = NULL; |
e60fea79 | 292 | } else { |
293 | /* copying properties for supported channels only */ | |
294 | memcpy(properties + sizeof(*(psy->properties)) * index, | |
295 | &gab_dyn_props[chan], | |
296 | sizeof(gab_dyn_props[chan])); | |
297 | index++; | |
298 | } | |
299 | } | |
300 | ||
301 | /* none of the channels are supported so let's bail out */ | |
d211c6e8 AL |
302 | if (index == 0) { |
303 | ret = -ENODEV; | |
e60fea79 | 304 | goto second_mem_fail; |
d211c6e8 | 305 | } |
e60fea79 | 306 | |
307 | /* | |
308 | * Total number of properties is equal to static properties | |
309 | * plus the dynamic properties.Some properties may not be set | |
310 | * as come channels may be not be supported by the device.So | |
311 | * we need to take care of that. | |
312 | */ | |
313 | psy->num_properties = ARRAY_SIZE(gab_props) + index; | |
314 | ||
315 | ret = power_supply_register(&pdev->dev, psy); | |
316 | if (ret) | |
317 | goto err_reg_fail; | |
318 | ||
319 | INIT_DELAYED_WORK(&adc_bat->bat_work, gab_work); | |
320 | ||
321 | if (gpio_is_valid(pdata->gpio_charge_finished)) { | |
322 | int irq; | |
323 | ret = gpio_request(pdata->gpio_charge_finished, "charged"); | |
324 | if (ret) | |
325 | goto gpio_req_fail; | |
326 | ||
327 | irq = gpio_to_irq(pdata->gpio_charge_finished); | |
328 | ret = request_any_context_irq(irq, gab_charged, | |
329 | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, | |
330 | "battery charged", adc_bat); | |
a5af0922 | 331 | if (ret < 0) |
e60fea79 | 332 | goto err_gpio; |
333 | } | |
334 | ||
335 | platform_set_drvdata(pdev, adc_bat); | |
336 | ||
337 | /* Schedule timer to check current status */ | |
338 | schedule_delayed_work(&adc_bat->bat_work, | |
339 | msecs_to_jiffies(0)); | |
340 | return 0; | |
341 | ||
342 | err_gpio: | |
343 | gpio_free(pdata->gpio_charge_finished); | |
344 | gpio_req_fail: | |
345 | power_supply_unregister(psy); | |
346 | err_reg_fail: | |
64d26f22 DC |
347 | for (chan = 0; chan < ARRAY_SIZE(gab_chan_name); chan++) { |
348 | if (adc_bat->channel[chan]) | |
349 | iio_channel_release(adc_bat->channel[chan]); | |
350 | } | |
e60fea79 | 351 | second_mem_fail: |
352 | kfree(psy->properties); | |
353 | first_mem_fail: | |
354 | return ret; | |
355 | } | |
356 | ||
415ec69f | 357 | static int gab_remove(struct platform_device *pdev) |
e60fea79 | 358 | { |
359 | int chan; | |
360 | struct gab *adc_bat = platform_get_drvdata(pdev); | |
361 | struct gab_platform_data *pdata = adc_bat->pdata; | |
362 | ||
363 | power_supply_unregister(&adc_bat->psy); | |
364 | ||
365 | if (gpio_is_valid(pdata->gpio_charge_finished)) { | |
366 | free_irq(gpio_to_irq(pdata->gpio_charge_finished), adc_bat); | |
367 | gpio_free(pdata->gpio_charge_finished); | |
368 | } | |
369 | ||
64d26f22 DC |
370 | for (chan = 0; chan < ARRAY_SIZE(gab_chan_name); chan++) { |
371 | if (adc_bat->channel[chan]) | |
372 | iio_channel_release(adc_bat->channel[chan]); | |
373 | } | |
e60fea79 | 374 | |
375 | kfree(adc_bat->psy.properties); | |
376 | cancel_delayed_work(&adc_bat->bat_work); | |
377 | return 0; | |
378 | } | |
379 | ||
380 | #ifdef CONFIG_PM | |
381 | static int gab_suspend(struct device *dev) | |
382 | { | |
383 | struct gab *adc_bat = dev_get_drvdata(dev); | |
384 | ||
385 | cancel_delayed_work_sync(&adc_bat->bat_work); | |
386 | adc_bat->status = POWER_SUPPLY_STATUS_UNKNOWN; | |
387 | return 0; | |
388 | } | |
389 | ||
390 | static int gab_resume(struct device *dev) | |
391 | { | |
392 | struct gab *adc_bat = dev_get_drvdata(dev); | |
393 | struct gab_platform_data *pdata = adc_bat->pdata; | |
394 | int delay; | |
395 | ||
396 | delay = pdata->jitter_delay ? pdata->jitter_delay : JITTER_DEFAULT; | |
397 | ||
398 | /* Schedule timer to check current status */ | |
399 | schedule_delayed_work(&adc_bat->bat_work, | |
400 | msecs_to_jiffies(delay)); | |
401 | return 0; | |
402 | } | |
403 | ||
404 | static const struct dev_pm_ops gab_pm_ops = { | |
405 | .suspend = gab_suspend, | |
406 | .resume = gab_resume, | |
407 | }; | |
408 | ||
409 | #define GAB_PM_OPS (&gab_pm_ops) | |
410 | #else | |
411 | #define GAB_PM_OPS (NULL) | |
412 | #endif | |
413 | ||
414 | static struct platform_driver gab_driver = { | |
415 | .driver = { | |
416 | .name = "generic-adc-battery", | |
417 | .owner = THIS_MODULE, | |
418 | .pm = GAB_PM_OPS | |
419 | }, | |
420 | .probe = gab_probe, | |
28ea73f4 | 421 | .remove = gab_remove, |
e60fea79 | 422 | }; |
423 | module_platform_driver(gab_driver); | |
424 | ||
425 | MODULE_AUTHOR("anish kumar <anish198519851985@gmail.com>"); | |
426 | MODULE_DESCRIPTION("generic battery driver using IIO"); | |
427 | MODULE_LICENSE("GPL"); |