/arch/arm/mach-msm/htc_power_supply.c
C | 616 lines | 510 code | 84 blank | 22 comment | 72 complexity | 880cfd7455d224cc510308fb048663ec MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
1/* arch/arm/mach-msm/htc_battery.c
2 *
3 * Copyright (C) 2008 HTC Corporation.
4 * Copyright (C) 2008 Google, Inc.
5 *
6 * This software is licensed under the terms of the GNU General Public
7 * License version 2, as published by the Free Software Foundation, and
8 * may be copied, distributed, and modified under those terms.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 */
16
17#include <linux/init.h>
18#include <linux/module.h>
19#include <linux/kernel.h>
20#include <linux/err.h>
21#include <linux/power_supply.h>
22#include <linux/platform_device.h>
23#include <mach/msm_fast_timer.h>
24#include <mach/msm_rpcrouter.h>
25#include <mach/board.h>
26
27#include <linux/workqueue.h>
28#include <linux/delay.h>
29#include <linux/gpio.h>
30#include <linux/switch.h>
31
32#include "board-mahimahi.h"
33
34extern void notify_usb_connected(int);
35
36static char *supply_list[] = {
37 "battery",
38};
39
40static struct switch_dev dock_switch = {
41 .name = "dock",
42};
43
44static int vbus_present;
45static int usb_status;
46static bool dock_mains;
47
48struct dock_state {
49 struct mutex lock;
50 u32 t;
51 u32 last_edge_t[2];
52 u32 last_edge_i[2];
53 bool level;
54 bool dock_connected_unknown;
55};
56
57static struct workqueue_struct *dock_wq;
58static struct work_struct dock_work;
59static struct wake_lock dock_work_wake_lock;
60static struct dock_state ds = {
61 .lock = __MUTEX_INITIALIZER(ds.lock),
62};
63
64#define _GPIO_DOCK MAHIMAHI_GPIO_DOCK
65
66#define dock_out(n) gpio_direction_output(_GPIO_DOCK, n)
67#define dock_out2(n) gpio_set_value(_GPIO_DOCK, n)
68#define dock_in() gpio_direction_input(_GPIO_DOCK)
69#define dock_read() gpio_get_value(_GPIO_DOCK)
70
71#define MFM_DELAY_NS 10000
72
73static int dock_get_edge(struct dock_state *s, u32 timeout, u32 tmin, u32 tmax)
74{
75 bool lin;
76 bool in = s->level;
77 u32 t;
78 do {
79 lin = in;
80 in = dock_read();
81 t = msm_read_fast_timer();
82 if (in != lin) {
83 s->last_edge_t[in] = t;
84 s->last_edge_i[in] = 0;
85 s->level = in;
86 if ((s32)(t - tmin) < 0 || (s32)(t - tmax) > 0)
87 return -1;
88 return 1;
89 }
90 } while((s32)(t - timeout) < 0);
91 return 0;
92}
93
94static bool dock_sync(struct dock_state *s, u32 timeout)
95{
96 u32 t;
97
98 s->level = dock_read();
99 t = msm_read_fast_timer();
100
101 if (!dock_get_edge(s, t + timeout, 0, 0))
102 return false;
103 s->last_edge_i[s->level] = 2;
104 return !!dock_get_edge(s,
105 s->last_edge_t[s->level] + MFM_DELAY_NS * 4, 0, 0);
106}
107
108static int dock_get_next_bit(struct dock_state *s)
109{
110 u32 i = s->last_edge_i[!s->level] + ++s->last_edge_i[s->level];
111 u32 target = s->last_edge_t[!s->level] + MFM_DELAY_NS * i;
112 u32 timeout = target + MFM_DELAY_NS / 2;
113 u32 tmin = target - MFM_DELAY_NS / 4;
114 u32 tmax = target + MFM_DELAY_NS / 4;
115 return dock_get_edge(s, timeout, tmin, tmax);
116}
117
118static u32 dock_get_bits(struct dock_state *s, int count, int *errp)
119{
120 u32 data = 0;
121 u32 m = 1;
122 int ret;
123 int err = 0;
124 while (count--) {
125 ret = dock_get_next_bit(s);
126 if (ret)
127 data |= m;
128 if (ret < 0)
129 err++;
130 m <<= 1;
131 }
132 if (errp)
133 *errp = err;
134 return data;
135}
136
137static void dock_delay(u32 timeout)
138{
139 timeout += msm_read_fast_timer();
140 while (((s32)(msm_read_fast_timer() - timeout)) < 0)
141 ;
142}
143
144static int dock_send_bits(struct dock_state *s, u32 data, int count, int period)
145{
146 u32 t, t0, to;
147
148 dock_out2(s->level);
149 t = to = 0;
150 t0 = msm_read_fast_timer();
151
152 while (count--) {
153 if (data & 1)
154 dock_out2((s->level = !s->level));
155
156 t = msm_read_fast_timer() - t0;
157 if (t - to > period / 2) {
158 pr_info("dock: to = %d, t = %d\n", to, t);
159 return -EIO;
160 }
161
162 to += MFM_DELAY_NS;
163 do {
164 t = msm_read_fast_timer() - t0;
165 } while (t < to);
166 if (t - to > period / 4) {
167 pr_info("dock: to = %d, t = %d\n", to, t);
168 return -EIO;
169 }
170 data >>= 1;
171 }
172 return 0;
173}
174
175static u32 mfm_encode(u16 data, int count, bool p)
176{
177 u32 mask;
178 u32 mfm = 0;
179 u32 clock = ~data & ~(data << 1 | !!p);
180 for (mask = 1UL << (count - 1); mask; mask >>= 1) {
181 mfm |= (data & mask);
182 mfm <<= 1;
183 mfm |= (clock & mask);
184 }
185 return mfm;
186}
187
188static u32 mfm_decode(u32 mfm)
189{
190 u32 data = 0;
191 u32 clock = 0;
192 u32 mask = 1;
193 while (mfm) {
194 if (mfm & 1)
195 clock |= mask;
196 mfm >>= 1;
197 if (mfm & 1)
198 data |= mask;
199 mfm >>= 1;
200 mask <<= 1;
201 }
202 return data;
203}
204
205static int dock_command(struct dock_state *s, u16 cmd, int len, int retlen)
206{
207 u32 mfm;
208 int count;
209 u32 data = cmd;
210 int ret;
211 int err = -1;
212 unsigned long flags;
213
214 data = data << 2 | 3; /* add 0101 mfm data*/
215 mfm = mfm_encode(data, len, false);
216 count = len * 2 + 2;
217
218 msm_enable_fast_timer();
219 local_irq_save(flags);
220 ret = dock_send_bits(s, mfm, count, MFM_DELAY_NS);
221 if (!ret) {
222 dock_in();
223 if (dock_sync(s, MFM_DELAY_NS * 5))
224 ret = dock_get_bits(s, retlen * 2, &err);
225 else
226 ret = -1;
227 dock_out(s->level);
228 }
229 local_irq_restore(flags);
230
231 dock_delay((ret < 0) ? MFM_DELAY_NS * 6 : MFM_DELAY_NS * 2);
232 msm_disable_fast_timer();
233 if (ret < 0) {
234 pr_warning("dock_command: %x: no response\n", cmd);
235 return ret;
236 }
237 data = mfm_decode(ret);
238 mfm = mfm_encode(data, retlen, true);
239 if (mfm != ret || err) {
240 pr_warning("dock_command: %x: bad response, "
241 "data %x, mfm %x %x, err %d\n",
242 cmd, data, mfm, ret, err);
243 return -EIO;
244 }
245 return data;
246}
247
248static int dock_command_retry(struct dock_state *s, u16 cmd, size_t len, size_t retlen)
249{
250 int retry = 20;
251 int ret;
252 while (retry--) {
253 ret = dock_command(s, cmd, len, retlen);
254 if (ret >= 0)
255 return ret;
256 if (retry != 19)
257 msleep(10);
258 }
259 s->dock_connected_unknown = true;
260 return -EIO;
261}
262
263static int dock_read_single(struct dock_state *s, int addr)
264{
265 int ret = -1, last;
266 int retry = 20;
267 while (retry--) {
268 last = ret;
269 ret = dock_command_retry(s, addr << 1, 6, 8);
270 if (ret < 0 || ret == last)
271 return ret;
272 }
273 return -EIO;
274}
275
276static int dock_read_multi(struct dock_state *s, int addr, u8 *data, size_t len)
277{
278 int ret;
279 int i;
280 u8 suml, sumr = -1;
281 int retry = 20;
282 while (retry--) {
283 suml = 0;
284 for (i = 0; i <= len; i++) {
285 ret = dock_command_retry(s, (addr + i) << 1, 6, 8);
286 if (ret < 0)
287 return ret;
288 if (i < len) {
289 data[i] = ret;
290 suml += ret;
291 } else
292 sumr = ret;
293 }
294 if (sumr == suml)
295 return 0;
296
297 pr_warning("dock_read_multi(%x): bad checksum, %x != %x\n",
298 addr, sumr, suml);
299 }
300 return -EIO;
301}
302
303static int dock_write_byte(struct dock_state *s, int addr, u8 data)
304{
305 return dock_command_retry(s, 1 | addr << 1 | data << 4, 6 + 8, 1);
306}
307
308static int dock_write_multi(struct dock_state *s, int addr, u8 *data, size_t len)
309{
310 int ret;
311 int i;
312 u8 sum;
313 int retry = 2;
314 while (retry--) {
315 sum = 0;
316 for (i = 0; i < len; i++) {
317 sum += data[i];
318 ret = dock_write_byte(s, addr + i, data[i]);
319 if (ret < 0)
320 return ret;
321 }
322 ret = dock_write_byte(s, addr + len, sum);
323 if (ret <= 0)
324 return ret;
325 }
326 return -EIO;
327}
328
329static int dock_acquire(struct dock_state *s)
330{
331 mutex_lock(&s->lock);
332 dock_in();
333 if (dock_read()) {
334 /* Allow some time for the dock pull-down resistor to discharge
335 * the capasitor.
336 */
337 msleep(20);
338 if (dock_read()) {
339 mutex_unlock(&s->lock);
340 return -ENOENT;
341 }
342 }
343 dock_out(0);
344 s->level = false;
345 return 0;
346}
347
348static void dock_release(struct dock_state *s)
349{
350 dock_in();
351 mutex_unlock(&s->lock);
352}
353
354enum {
355 DOCK_TYPE = 0x0,
356 DOCK_BT_ADDR = 0x1, /* - 0x7 */
357
358 DOCK_PIN_CODE = 0x0,
359};
360
361static ssize_t bt_addr_show(struct device *dev, struct device_attribute *attr,
362 char *buf)
363{
364 int ret;
365 u8 bt_addr[6];
366
367 ret = dock_acquire(&ds);
368 if (ret < 0)
369 return ret;
370 ret = dock_read_multi(&ds, DOCK_BT_ADDR, bt_addr, 6);
371 dock_release(&ds);
372 if (ret < 0)
373 return ret;
374
375 return sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
376 bt_addr[0], bt_addr[1], bt_addr[2],
377 bt_addr[3], bt_addr[4], bt_addr[5]);
378}
379static DEVICE_ATTR(bt_addr, S_IRUGO | S_IWUSR, bt_addr_show, NULL);
380
381static ssize_t bt_pin_store(struct device *dev, struct device_attribute *attr,
382 const char *buf, size_t size)
383{
384 int ret, i;
385 u8 pin[4];
386
387 if (size < 4)
388 return -EINVAL;
389
390 for (i = 0; i < sizeof(pin); i++) {
391 if ((pin[i] = buf[i] - '0') > 10)
392 return -EINVAL;
393 }
394
395 ret = dock_acquire(&ds);
396 if (ret < 0)
397 return ret;
398 ret = dock_write_multi(&ds, DOCK_PIN_CODE, pin, 4);
399 dock_release(&ds);
400 if (ret < 0)
401 return ret;
402
403 return size;
404}
405static DEVICE_ATTR(bt_pin, S_IRUGO | S_IWUSR, NULL, bt_pin_store);
406
407
408static int power_get_property(struct power_supply *psy,
409 enum power_supply_property psp,
410 union power_supply_propval *val)
411{
412 if (psp != POWER_SUPPLY_PROP_ONLINE)
413 return -EINVAL;
414
415 if (psy->type == POWER_SUPPLY_TYPE_MAINS)
416 val->intval = (vbus_present && (usb_status == 2 || dock_mains));
417 else
418 val->intval = vbus_present;
419 return 0;
420}
421
422static enum power_supply_property power_properties[] = {
423 POWER_SUPPLY_PROP_ONLINE,
424};
425
426static struct power_supply ac_supply = {
427 .name = "ac",
428 .type = POWER_SUPPLY_TYPE_MAINS,
429 .supplied_to = supply_list,
430 .num_supplicants = ARRAY_SIZE(supply_list),
431 .properties = power_properties,
432 .num_properties = ARRAY_SIZE(power_properties),
433 .get_property = power_get_property,
434};
435
436static struct power_supply usb_supply = {
437 .name = "usb",
438 .type = POWER_SUPPLY_TYPE_USB,
439 .supplied_to = supply_list,
440 .num_supplicants = ARRAY_SIZE(supply_list),
441 .properties = power_properties,
442 .num_properties = ARRAY_SIZE(power_properties),
443 .get_property = power_get_property,
444};
445
446/* rpc related */
447#define APP_BATT_PDEV_NAME "rs30100001:00000000"
448#define APP_BATT_PROG 0x30100001
449#define APP_BATT_VER MSM_RPC_VERS(0,0)
450#define HTC_PROCEDURE_BATTERY_NULL 0
451#define HTC_PROCEDURE_GET_BATT_LEVEL 1
452#define HTC_PROCEDURE_GET_BATT_INFO 2
453#define HTC_PROCEDURE_GET_CABLE_STATUS 3
454#define HTC_PROCEDURE_SET_BATT_DELTA 4
455
456static struct msm_rpc_endpoint *endpoint;
457
458struct battery_info_reply {
459 u32 batt_id; /* Battery ID from ADC */
460 u32 batt_vol; /* Battery voltage from ADC */
461 u32 batt_temp; /* Battery Temperature (C) from formula and ADC */
462 u32 batt_current; /* Battery current from ADC */
463 u32 level; /* formula */
464 u32 charging_source; /* 0: no cable, 1:usb, 2:AC */
465 u32 charging_enabled; /* 0: Disable, 1: Enable */
466 u32 full_bat; /* Full capacity of battery (mAh) */
467};
468
469static void dock_work_proc(struct work_struct *work)
470{
471 int dockid;
472
473 if (!vbus_present || dock_acquire(&ds))
474 goto no_dock;
475
476 if (ds.dock_connected_unknown) {
477 /* force a new dock notification if a command failed */
478 switch_set_state(&dock_switch, 0);
479 ds.dock_connected_unknown = false;
480 }
481
482 dockid = dock_read_single(&ds, DOCK_TYPE);
483 dock_release(&ds);
484
485 pr_info("Detected dock with ID %02x\n", dockid);
486 if (dockid >= 0) {
487 msm_hsusb_set_vbus_state(0);
488 dock_mains = !!(dockid & 0x80);
489 switch_set_state(&dock_switch, (dockid & 1) ? 2 : 1);
490 goto done;
491 }
492no_dock:
493 dock_mains = false;
494 switch_set_state(&dock_switch, 0);
495 msm_hsusb_set_vbus_state(vbus_present);
496done:
497 power_supply_changed(&ac_supply);
498 power_supply_changed(&usb_supply);
499 wake_unlock(&dock_work_wake_lock);
500}
501
502static int htc_battery_probe(struct platform_device *pdev)
503{
504 struct rpc_request_hdr req;
505 struct htc_get_batt_info_rep {
506 struct rpc_reply_hdr hdr;
507 struct battery_info_reply info;
508 } rep;
509
510 int rc;
511
512 endpoint = msm_rpc_connect(APP_BATT_PROG, APP_BATT_VER, 0);
513 if (IS_ERR(endpoint)) {
514 printk(KERN_ERR "%s: init rpc failed! rc = %ld\n",
515 __FUNCTION__, PTR_ERR(endpoint));
516 return PTR_ERR(endpoint);
517 }
518
519 /* must do this or we won't get cable status updates */
520 rc = msm_rpc_call_reply(endpoint, HTC_PROCEDURE_GET_BATT_INFO,
521 &req, sizeof(req),
522 &rep, sizeof(rep),
523 5 * HZ);
524 if (rc < 0)
525 printk(KERN_ERR "%s: get info failed\n", __FUNCTION__);
526
527 power_supply_register(&pdev->dev, &ac_supply);
528 power_supply_register(&pdev->dev, &usb_supply);
529
530 INIT_WORK(&dock_work, dock_work_proc);
531 dock_wq = create_singlethread_workqueue("dock");
532
533 return 0;
534}
535
536static struct platform_driver htc_battery_driver = {
537 .probe = htc_battery_probe,
538 .driver = {
539 .name = APP_BATT_PDEV_NAME,
540 .owner = THIS_MODULE,
541 },
542};
543
544/* batt_mtoa server definitions */
545#define BATT_MTOA_PROG 0x30100000
546#define BATT_MTOA_VERS 0
547#define RPC_BATT_MTOA_NULL 0
548#define RPC_BATT_MTOA_SET_CHARGING_PROC 1
549#define RPC_BATT_MTOA_CABLE_STATUS_UPDATE_PROC 2
550#define RPC_BATT_MTOA_LEVEL_UPDATE_PROC 3
551
552struct rpc_batt_mtoa_cable_status_update_args {
553 int status;
554};
555
556static int handle_battery_call(struct msm_rpc_server *server,
557 struct rpc_request_hdr *req, unsigned len)
558{
559 struct rpc_batt_mtoa_cable_status_update_args *args;
560
561 if (req->procedure != RPC_BATT_MTOA_CABLE_STATUS_UPDATE_PROC)
562 return 0;
563
564 args = (struct rpc_batt_mtoa_cable_status_update_args *)(req + 1);
565 args->status = be32_to_cpu(args->status);
566 pr_info("cable_status_update: status=%d\n",args->status);
567
568 args->status = !!args->status;
569
570 vbus_present = args->status;
571 wake_lock(&dock_work_wake_lock);
572 queue_work(dock_wq, &dock_work);
573 return 0;
574}
575
576void notify_usb_connected(int status)
577{
578 printk("### notify_usb_connected(%d) ###\n", status);
579 usb_status = status;
580 power_supply_changed(&ac_supply);
581 power_supply_changed(&usb_supply);
582}
583
584int is_ac_power_supplied(void)
585{
586 return vbus_present && (usb_status == 2 || dock_mains);
587}
588
589static struct msm_rpc_server battery_server = {
590 .prog = BATT_MTOA_PROG,
591 .vers = BATT_MTOA_VERS,
592 .rpc_call = handle_battery_call,
593};
594
595static int __init htc_battery_init(void)
596{
597 int ret;
598 gpio_request(_GPIO_DOCK, "dock");
599 dock_in();
600 wake_lock_init(&dock_work_wake_lock, WAKE_LOCK_SUSPEND, "dock");
601 platform_driver_register(&htc_battery_driver);
602 msm_rpc_create_server(&battery_server);
603 if (switch_dev_register(&dock_switch) == 0) {
604 ret = device_create_file(dock_switch.dev, &dev_attr_bt_addr);
605 WARN_ON(ret);
606 ret = device_create_file(dock_switch.dev, &dev_attr_bt_pin);
607 WARN_ON(ret);
608 }
609
610 return 0;
611}
612
613module_init(htc_battery_init);
614MODULE_DESCRIPTION("HTC Battery Driver");
615MODULE_LICENSE("GPL");
616