/arch/arm/mach-msm/htc_power_supply.c

  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