arch/arm/mach-omap2/board-tuna-pogo.c - kernel/omap - Git at Google

 /*
  * Copyright (C) 2011 Samsung, Inc.
  *
  * Author: Adam Hampson <ahampson@sta.samsung.com>
  *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
  * may be copied, distributed, and modified under those terms.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  */

 #define pr_fmt(fmt) "%s: " fmt, __func__

 #include <linux/kernel.h>
 #include <linux/err.h>
 #include <linux/gpio.h>
 #include <linux/delay.h>
 #include <linux/switch.h>
 #include <linux/wakelock.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
 #include <linux/sched.h>
 #include <linux/completion.h>
 #include <linux/usb/otg.h>
 #include <linux/usb/otg_id.h>

 #include <asm/div64.h>

 #include "mux.h"
 #include "control.h"
 #include "board-tuna.h"

 #define GPIO_POGO_DATA		121
 #define GPIO_POGO_DET		169

 /* The below constants are in milliseconds */
 #define POGO_WAKE_PERIOD		100
 #define POGO_ID_PERIOD_TIMEOUT		750
 #define POGO_ID_DESKDOCK		50
 #define POGO_ID_CARDOCK			100
 #define POGO_ID_CHARGER			50
 #define POGO_ID_USB			100
 #define POGO_ID_AUDIO			50
 #define POGO_ID_NO_AUDIO		100
 #define POGO_ENTER_SPDIF_WAIT_PERIOD	100
 #define POGO_ID_PERIOD_TOLERANCE	20
 #define POGO_DET_DEBOUNCE		80

 #define POGO_DOCK_ID_MAX_RETRY		10

 #define POGO_AUDIO_DISCONNECTED		0
 #define POGO_AUDIO_CONNECTED		2

 enum {
 	POGO_DOCK_DOCKED	= BIT(0),
 	POGO_DOCK_DESK		= BIT(1),	/* 0 = Car */
 	POGO_DOCK_CHARGER	= BIT(2),
 	POGO_DOCK_AUDIO_CONN	= BIT(3),
 };

 enum debounce_state {
 	POGO_DET_DOCKED,	/* interrupt enabled,  timer stopped */
 	POGO_DET_UNSTABLE,	/* interrupt disabled, timer running */
 	POGO_DET_WAIT_STABLE,	/* interrupt enabled,  timer running */
 	POGO_DET_UNDOCKED,	/* interrupt disabled, timer stopped */
 };

 struct tuna_pogo {
 	struct otg_id_notifier_block	otg_id_nb;
 	struct switch_dev		audio_switch;
 	struct wake_lock		wake_lock;
 	struct completion		completion;
 	struct timespec			timestamps[4];
 	int				ts_index;
 	int				det_irq;
 	int				data_irq;
 	unsigned int			dock_type;
 	struct mutex			mutex;
 	struct timer_list		det_timer;
 	struct work_struct		det_work;
 	spinlock_t			det_irq_lock;
 	enum debounce_state		debounce_state;
 };
 static struct tuna_pogo tuna_pogo;

 static void pogo_send_pulse(unsigned int duration_in_ms)
 {
 	gpio_direction_output(GPIO_POGO_DATA, 1);
 	msleep(duration_in_ms);
 	gpio_direction_output(GPIO_POGO_DATA, 0);
 }

 static int pogo_read_id_period(struct tuna_pogo *pogo,
 		unsigned int timeout_in_ms)
 {
 	int ret;

 	memset(pogo->timestamps, 0, sizeof(pogo->timestamps));
 	pogo->ts_index = 0;

 	gpio_direction_input(GPIO_POGO_DATA);

 	irq_set_irq_type(pogo->data_irq, IRQF_TRIGGER_HIGH);

 	enable_irq(pogo->data_irq);

 	ret = wait_for_completion_timeout(&pogo->completion,
 			msecs_to_jiffies(timeout_in_ms));
 	if (ret <= 0) {
 		if (pogo->ts_index != ARRAY_SIZE(pogo->timestamps))
 			pr_debug("No response to wake within timeout\n");
 		else
 			pr_debug("ID period did not conclude within timeout\n");
 		disable_irq(pogo->data_irq);
 		return -1;
 	}

 	return 0;
 }

 static void pogo_dock_change(struct tuna_pogo *pogo)
 {
 	char *dock_type_str;
 	char *dock_audio_str;
 	char *dock_charger_str;

 	if (!(pogo->dock_type & POGO_DOCK_DOCKED)) {
 		tuna_otg_set_dock_switch(0);
 		switch_set_state(&pogo->audio_switch, POGO_AUDIO_DISCONNECTED);
 		tuna_otg_pogo_charger(POGO_POWER_DISCONNECTED);
 		pr_info("Undocked\n");
 		return;
 	} else {
 		tuna_otg_set_dock_switch(pogo->dock_type & POGO_DOCK_DESK ? 1 : 2);
 	}

 	dock_type_str = pogo->dock_type & POGO_DOCK_DESK ? "Desk" : "Car";
 	if (pogo->dock_type & POGO_DOCK_AUDIO_CONN) {
 		switch_set_state(&pogo->audio_switch, POGO_AUDIO_CONNECTED);
 		dock_audio_str = "";
 	} else {
 		switch_set_state(&pogo->audio_switch, POGO_AUDIO_DISCONNECTED);
 		dock_audio_str = " no";
 	}
 	if (pogo->dock_type & POGO_DOCK_CHARGER) {
 		tuna_otg_pogo_charger(POGO_POWER_CHARGER);
 		dock_charger_str = "charger";
 	} else {
 		tuna_otg_pogo_charger(POGO_POWER_HOST);
 		dock_charger_str = "host";
 	}

 	pr_info("%s dock,%s audio, USB %s\n", dock_type_str, dock_audio_str,
 		dock_charger_str);
 }

 static int pogo_detect_callback(struct otg_id_notifier_block *nb)
 {
 	struct tuna_pogo *pogo = container_of(nb, struct tuna_pogo, otg_id_nb);
 	int dock_type_period;
 	int power_type_period;
 	int audio_cable_period;
 	struct timespec temp;
 	unsigned int retry = 0;
 	unsigned long irqflags;

 	if (gpio_get_value(GPIO_POGO_DET)) {
 		wake_lock(&pogo->wake_lock);

 		while (!(pogo->dock_type & POGO_DOCK_DOCKED)) {

 			if (!gpio_get_value(GPIO_POGO_DET)) {
 				wake_unlock(&pogo->wake_lock);
 				return OTG_ID_UNHANDLED;
 			}

 			if (retry++ > POGO_DOCK_ID_MAX_RETRY) {
 				wake_unlock(&pogo->wake_lock);
 				pr_err("Unable to identify pogo dock\n");
 				return OTG_ID_UNHANDLED;
 			}

 			/* Start the detection process by sending a wake pulse
 			 * to the dock.
 			 */
 			pogo_send_pulse(POGO_WAKE_PERIOD);

 			if (pogo_read_id_period(pogo, POGO_ID_PERIOD_TIMEOUT))
 				continue;

 			temp = timespec_sub(pogo->timestamps[1],
 					pogo->timestamps[0]);
 			dock_type_period = temp.tv_nsec / NSEC_PER_MSEC;

 			temp = timespec_sub(pogo->timestamps[2],
 					pogo->timestamps[1]);
 			power_type_period = temp.tv_nsec / NSEC_PER_MSEC;

 			temp = timespec_sub(pogo->timestamps[3],
 					pogo->timestamps[2]);
 			audio_cable_period = temp.tv_nsec / NSEC_PER_MSEC;

 			/* The length of the ID period will indicate the type of
 			 * dock that is attached.
 			 */
 			if (abs(dock_type_period - POGO_ID_DESKDOCK) <=
 					POGO_ID_PERIOD_TOLERANCE) {
 				pogo->dock_type |= POGO_DOCK_DESK;
 			} else if (abs(dock_type_period - POGO_ID_CARDOCK) >
 					POGO_ID_PERIOD_TOLERANCE) {
 				continue;
 			}

 			if (abs(power_type_period - POGO_ID_CHARGER) <=
 					POGO_ID_PERIOD_TOLERANCE) {
 				pogo->dock_type |= POGO_DOCK_CHARGER;
 			} else if (abs(power_type_period - POGO_ID_USB) >
 					POGO_ID_PERIOD_TOLERANCE) {
 				continue;
 			}

 			if (abs(audio_cable_period - POGO_ID_AUDIO) <=
 					POGO_ID_PERIOD_TOLERANCE) {
 				pogo->dock_type |= POGO_DOCK_AUDIO_CONN;
 				pogo->dock_type |= POGO_DOCK_DOCKED;
 			} else if (abs(audio_cable_period -
 					POGO_ID_NO_AUDIO) <=
 					POGO_ID_PERIOD_TOLERANCE) {
 				pogo->dock_type |= POGO_DOCK_DOCKED;
 			}
 		}

 		msleep(POGO_ENTER_SPDIF_WAIT_PERIOD);

 		mutex_lock(&pogo->mutex);
 		omap_mux_set_gpio(OMAP_MUX_MODE2 | OMAP_PIN_OUTPUT,
 				GPIO_POGO_DATA);

 		pogo_dock_change(pogo);
 		wake_lock_timeout(&pogo->wake_lock, msecs_to_jiffies(1000));

 		spin_lock_irqsave(&pogo->det_irq_lock, irqflags);
 		pogo->debounce_state = POGO_DET_DOCKED;
 		enable_irq(pogo->det_irq);
 		enable_irq_wake(pogo->det_irq);
 		spin_unlock_irqrestore(&pogo->det_irq_lock, irqflags);
 		mutex_unlock(&pogo->mutex);

 		return OTG_ID_HANDLED;
 	}

 	return OTG_ID_UNHANDLED;
 }

 static void pogo_dock_undock(struct tuna_pogo *pogo)
 {
 	mutex_lock(&pogo->mutex);
 	if ((pogo->dock_type & POGO_DOCK_DOCKED) &&
 	    pogo->debounce_state == POGO_DET_UNDOCKED) {
 		pogo->dock_type = 0;
 		pogo_dock_change(pogo);

 		omap_mux_set_gpio(OMAP_MUX_MODE3 | OMAP_PIN_INPUT_PULLDOWN,
 				GPIO_POGO_DATA);
 	}
 	mutex_unlock(&pogo->mutex);
 }

 /* This callback is used to cancel any ownership of the chain */
 static void pogo_cancel_callback(struct otg_id_notifier_block *nb)
 {
 	struct tuna_pogo *pogo = container_of(nb, struct tuna_pogo, otg_id_nb);
 	unsigned long irqflags;

 	/* Disable the POGO_DET IRQ and cancel any pending timer if needed */
 	spin_lock_irqsave(&pogo->det_irq_lock, irqflags);
 	switch (pogo->debounce_state) {
 	case POGO_DET_UNDOCKED:
 		break;
 	case POGO_DET_UNSTABLE:
 		del_timer(&pogo->det_timer);
 		break;
 	case POGO_DET_WAIT_STABLE:
 		del_timer(&pogo->det_timer);
 		/* fall through */
 	case POGO_DET_DOCKED:
 		disable_irq_wake(pogo->det_irq);
 		disable_irq_nosync(pogo->det_irq);
 		break;
 	}
 	pogo->debounce_state = POGO_DET_UNDOCKED;
 	spin_unlock_irqrestore(&pogo->det_irq_lock, irqflags);

 	/* Change the state to undocked */
 	pogo_dock_undock(pogo);
 }

 static void det_work_func(struct work_struct *work)
 {
 	struct tuna_pogo *pogo = container_of(work, struct tuna_pogo, det_work);

 	pogo_dock_undock(pogo);

 	/* Notify the otg_id chain that a change has occurred */
 	otg_id_notify();
 }

 static void pogo_det_timer_func(unsigned long arg)
 {
 	struct tuna_pogo *pogo = (struct tuna_pogo *)arg;
 	unsigned long irqflags;

 	spin_lock_irqsave(&pogo->det_irq_lock, irqflags);
 	switch (pogo->debounce_state) {
 	case POGO_DET_DOCKED:
 		break;
 	case POGO_DET_UNSTABLE:
 		/*
 		 * The detect gpio changed in one the previous two timeslots,
 		 * so enable the irq, reset the timer, and wait again. If the
 		 * detect gpio changed after we last disabled the interrupt we
 		 * will get anther interrupt right away and the state will go
 		 * back to POGO_DET_UNSTABLE.
 		 */
 		pogo->debounce_state = POGO_DET_WAIT_STABLE;
 		enable_irq(pogo->det_irq);
 		enable_irq_wake(pogo->det_irq);
 		mod_timer(&pogo->det_timer,
 			jiffies + msecs_to_jiffies(POGO_DET_DEBOUNCE));
 		break;
 	case POGO_DET_WAIT_STABLE:
 		if (gpio_get_value(GPIO_POGO_DET) == 0) {
 			pogo->debounce_state = POGO_DET_UNDOCKED;
 			disable_irq_wake(pogo->det_irq);
 			disable_irq_nosync(pogo->det_irq);
 			wake_lock_timeout(&pogo->wake_lock,
 					  msecs_to_jiffies(1000));
 			schedule_work(&pogo->det_work);
 		} else {
 			/* The device appears to be back in the dock */
 			pogo->debounce_state = POGO_DET_DOCKED;
 			wake_unlock(&pogo->wake_lock);
 		}
 		break;
 	case POGO_DET_UNDOCKED:
 		break;
 	}
 	spin_unlock_irqrestore(&pogo->det_irq_lock, irqflags);
 }

 static irqreturn_t pogo_det_irq(int irq, void *data)
 {
 	struct tuna_pogo *pogo = data;
 	unsigned long irqflags;

 	spin_lock_irqsave(&pogo->det_irq_lock, irqflags);
 	switch (pogo->debounce_state) {
 	case POGO_DET_DOCKED:
 		wake_lock(&pogo->wake_lock);
 		mod_timer(&pogo->det_timer,
 			jiffies + msecs_to_jiffies(POGO_DET_DEBOUNCE));
 		/* fall through */
 	case POGO_DET_WAIT_STABLE:
 		/*
 		 * Disable IRQ line in case there is noise. It will be
 		 * re-enabled when the timer expires
 		 */
 		pogo->debounce_state = POGO_DET_UNSTABLE;
 		disable_irq_wake(pogo->det_irq);
 		disable_irq_nosync(pogo->det_irq);
 		break;
 	case POGO_DET_UNSTABLE:
 	case POGO_DET_UNDOCKED:
 		break;
 	}
 	spin_unlock_irqrestore(&pogo->det_irq_lock, irqflags);

 	return IRQ_HANDLED;
 }

 static irqreturn_t pogo_data_irq(int irq, void *data)
 {
 	struct tuna_pogo *pogo = data;

 	ktime_get_ts(&pogo->timestamps[pogo->ts_index++]);
 	irq_set_irq_type(pogo->data_irq, gpio_get_value(GPIO_POGO_DATA) ?
 			IRQF_TRIGGER_LOW :
 			IRQF_TRIGGER_HIGH);
 	if (pogo->ts_index >= ARRAY_SIZE(pogo->timestamps)) {
 		complete(&pogo->completion);
 		disable_irq_nosync(pogo->data_irq);
 	}
 	return IRQ_HANDLED;
 }

 void __init omap4_tuna_pogo_init(void)
 {
 	struct tuna_pogo *pogo = &tuna_pogo;
 	unsigned int r;
 	int ret;

 	omap_mux_init_signal("usbb2_hsic_data.gpio_169",
 			OMAP_PIN_INPUT_PULLDOWN | OMAP_MUX_MODE3 |
 			OMAP_WAKEUP_EN);

 	/* The pullup/pulldown controls in the mux register are not the controls
 	 * that you are looking for.  The usbb2_hsic_data signal has a separate
 	 * special control in the CONTROL_USBB_HSIC register.
 	 */
 	r = omap4_ctrl_pad_readl(OMAP4_CTRL_MODULE_PAD_CORE_CONTROL_USBB_HSIC);
 	r &= ~OMAP4_USBB2_HSIC_DATA_WD_MASK;
 	omap4_ctrl_pad_writel(r, OMAP4_CTRL_MODULE_PAD_CORE_CONTROL_USBB_HSIC);

 	ret = gpio_request(GPIO_POGO_DET, "pogo_det");
 	if (ret < 0)
 		pr_err("request for pogo_det gpio failed, err %d\n", ret);

 	gpio_direction_input(GPIO_POGO_DET);

 	omap_mux_init_signal("abe_dmic_din2.gpio_121",
 		OMAP_PIN_INPUT_PULLDOWN | OMAP_MUX_MODE3);
 	ret = gpio_request(GPIO_POGO_DATA, "pogo_data");
 	if (ret < 0)
 		pr_err("request for pogo_data gpio failed, err %d\n", ret);

 	gpio_direction_output(GPIO_POGO_DATA, 0);

 	/* The POGO dock does not involve USB but we are reusing the existing
 	 * usb audio switch report the availabilty of SPDIF audio through the
 	 * POGO dock.
 	 */
 	pogo->audio_switch.name = "usb_audio";

 	switch_dev_register(&pogo->audio_switch);

 	wake_lock_init(&pogo->wake_lock, WAKE_LOCK_SUSPEND, "pogo");

 	init_completion(&pogo->completion);

 	pogo->otg_id_nb.detect = pogo_detect_callback;
 	pogo->otg_id_nb.proxy_wait = NULL;
 	pogo->otg_id_nb.cancel = pogo_cancel_callback;
 	pogo->otg_id_nb.priority = TUNA_OTG_ID_POGO_PRIO;

 	ret = otg_id_register_notifier(&pogo->otg_id_nb);
 	if (ret < 0)
 		pr_err("Unable to register notifier\n");

 	setup_timer(&pogo->det_timer, pogo_det_timer_func, (unsigned long)pogo);
 	spin_lock_init(&pogo->det_irq_lock);
 	mutex_init(&pogo->mutex);
 	INIT_WORK(&pogo->det_work, det_work_func);
 	pogo->debounce_state = POGO_DET_UNDOCKED;

 	pogo->det_irq = gpio_to_irq(GPIO_POGO_DET);

 	ret = request_irq(pogo->det_irq, pogo_det_irq,
 				IRQF_TRIGGER_RISING |
 				IRQF_TRIGGER_FALLING,
 				"pogo_det", pogo);
 	if (ret < 0)
 		pr_err("Unable to register pogo_det interrupt (%d)\n", ret);

 	disable_irq(pogo->det_irq);

 	pogo->data_irq = gpio_to_irq(GPIO_POGO_DATA);

 	ret = request_irq(pogo->data_irq, pogo_data_irq,
 				IRQF_TRIGGER_HIGH,
 				"pogo_data", pogo);
 	if (ret < 0)
 		pr_err("Unable to register pogo_data interrupt (%d)\n", ret);

 	disable_irq(pogo->data_irq);
 }
	/*
	* Copyright (C) 2011 Samsung, Inc.
	*
	* Author: Adam Hampson <ahampson@sta.samsung.com>
	*
	* This software is licensed under the terms of the GNU General Public
	* License version 2, as published by the Free Software Foundation, and
	* may be copied, distributed, and modified under those terms.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	*/

	#define pr_fmt(fmt) "%s: " fmt, __func__

	#include <linux/kernel.h>
	#include <linux/err.h>
	#include <linux/gpio.h>
	#include <linux/delay.h>
	#include <linux/switch.h>
	#include <linux/wakelock.h>
	#include <linux/interrupt.h>
	#include <linux/irq.h>
	#include <linux/sched.h>
	#include <linux/completion.h>
	#include <linux/usb/otg.h>
	#include <linux/usb/otg_id.h>

	#include <asm/div64.h>

	#include "mux.h"
	#include "control.h"
	#include "board-tuna.h"

	#define GPIO_POGO_DATA 121
	#define GPIO_POGO_DET 169

	/* The below constants are in milliseconds */
	#define POGO_WAKE_PERIOD 100
	#define POGO_ID_PERIOD_TIMEOUT 750
	#define POGO_ID_DESKDOCK 50
	#define POGO_ID_CARDOCK 100
	#define POGO_ID_CHARGER 50
	#define POGO_ID_USB 100
	#define POGO_ID_AUDIO 50
	#define POGO_ID_NO_AUDIO 100
	#define POGO_ENTER_SPDIF_WAIT_PERIOD 100
	#define POGO_ID_PERIOD_TOLERANCE 20
	#define POGO_DET_DEBOUNCE 80

	#define POGO_DOCK_ID_MAX_RETRY 10

	#define POGO_AUDIO_DISCONNECTED 0
	#define POGO_AUDIO_CONNECTED 2

	enum {
	POGO_DOCK_DOCKED = BIT(0),
	POGO_DOCK_DESK = BIT(1), /* 0 = Car */
	POGO_DOCK_CHARGER = BIT(2),
	POGO_DOCK_AUDIO_CONN = BIT(3),
	};

	enum debounce_state {
	POGO_DET_DOCKED, /* interrupt enabled, timer stopped */
	POGO_DET_UNSTABLE, /* interrupt disabled, timer running */
	POGO_DET_WAIT_STABLE, /* interrupt enabled, timer running */
	POGO_DET_UNDOCKED, /* interrupt disabled, timer stopped */
	};

	struct tuna_pogo {
	struct otg_id_notifier_block otg_id_nb;
	struct switch_dev audio_switch;
	struct wake_lock wake_lock;
	struct completion completion;
	struct timespec timestamps[4];
	int ts_index;
	int det_irq;
	int data_irq;
	unsigned int dock_type;
	struct mutex mutex;
	struct timer_list det_timer;
	struct work_struct det_work;
	spinlock_t det_irq_lock;
	enum debounce_state debounce_state;
	};
	static struct tuna_pogo tuna_pogo;

	static void pogo_send_pulse(unsigned int duration_in_ms)
	{
	gpio_direction_output(GPIO_POGO_DATA, 1);
	msleep(duration_in_ms);
	gpio_direction_output(GPIO_POGO_DATA, 0);
	}

	static int pogo_read_id_period(struct tuna_pogo *pogo,
	unsigned int timeout_in_ms)
	{
	int ret;

	memset(pogo->timestamps, 0, sizeof(pogo->timestamps));
	pogo->ts_index = 0;

	gpio_direction_input(GPIO_POGO_DATA);

	irq_set_irq_type(pogo->data_irq, IRQF_TRIGGER_HIGH);

	enable_irq(pogo->data_irq);

	ret = wait_for_completion_timeout(&pogo->completion,
	msecs_to_jiffies(timeout_in_ms));
	if (ret <= 0) {
	if (pogo->ts_index != ARRAY_SIZE(pogo->timestamps))
	pr_debug("No response to wake within timeout\n");
	else
	pr_debug("ID period did not conclude within timeout\n");
	disable_irq(pogo->data_irq);
	return -1;
	}

	return 0;
	}

	static void pogo_dock_change(struct tuna_pogo *pogo)
	{
	char *dock_type_str;
	char *dock_audio_str;
	char *dock_charger_str;

	if (!(pogo->dock_type & POGO_DOCK_DOCKED)) {
	tuna_otg_set_dock_switch(0);
	switch_set_state(&pogo->audio_switch, POGO_AUDIO_DISCONNECTED);
	tuna_otg_pogo_charger(POGO_POWER_DISCONNECTED);
	pr_info("Undocked\n");
	return;
	} else {
	tuna_otg_set_dock_switch(pogo->dock_type & POGO_DOCK_DESK ? 1 : 2);
	}

	dock_type_str = pogo->dock_type & POGO_DOCK_DESK ? "Desk" : "Car";
	if (pogo->dock_type & POGO_DOCK_AUDIO_CONN) {
	switch_set_state(&pogo->audio_switch, POGO_AUDIO_CONNECTED);
	dock_audio_str = "";
	} else {
	switch_set_state(&pogo->audio_switch, POGO_AUDIO_DISCONNECTED);
	dock_audio_str = " no";
	}
	if (pogo->dock_type & POGO_DOCK_CHARGER) {
	tuna_otg_pogo_charger(POGO_POWER_CHARGER);
	dock_charger_str = "charger";
	} else {
	tuna_otg_pogo_charger(POGO_POWER_HOST);
	dock_charger_str = "host";
	}

	pr_info("%s dock,%s audio, USB %s\n", dock_type_str, dock_audio_str,
	dock_charger_str);
	}

	static int pogo_detect_callback(struct otg_id_notifier_block *nb)
	{
	struct tuna_pogo *pogo = container_of(nb, struct tuna_pogo, otg_id_nb);
	int dock_type_period;
	int power_type_period;
	int audio_cable_period;
	struct timespec temp;
	unsigned int retry = 0;
	unsigned long irqflags;

	if (gpio_get_value(GPIO_POGO_DET)) {
	wake_lock(&pogo->wake_lock);

	while (!(pogo->dock_type & POGO_DOCK_DOCKED)) {

	if (!gpio_get_value(GPIO_POGO_DET)) {
	wake_unlock(&pogo->wake_lock);
	return OTG_ID_UNHANDLED;
	}

	if (retry++ > POGO_DOCK_ID_MAX_RETRY) {
	wake_unlock(&pogo->wake_lock);
	pr_err("Unable to identify pogo dock\n");
	return OTG_ID_UNHANDLED;
	}

	/* Start the detection process by sending a wake pulse
	* to the dock.
	*/
	pogo_send_pulse(POGO_WAKE_PERIOD);

	if (pogo_read_id_period(pogo, POGO_ID_PERIOD_TIMEOUT))
	continue;

	temp = timespec_sub(pogo->timestamps[1],
	pogo->timestamps[0]);
	dock_type_period = temp.tv_nsec / NSEC_PER_MSEC;

	temp = timespec_sub(pogo->timestamps[2],
	pogo->timestamps[1]);
	power_type_period = temp.tv_nsec / NSEC_PER_MSEC;

	temp = timespec_sub(pogo->timestamps[3],
	pogo->timestamps[2]);
	audio_cable_period = temp.tv_nsec / NSEC_PER_MSEC;

	/* The length of the ID period will indicate the type of
	* dock that is attached.
	*/
	if (abs(dock_type_period - POGO_ID_DESKDOCK) <=
	POGO_ID_PERIOD_TOLERANCE) {
	pogo->dock_type \|= POGO_DOCK_DESK;
	} else if (abs(dock_type_period - POGO_ID_CARDOCK) >
	POGO_ID_PERIOD_TOLERANCE) {
	continue;
	}

	if (abs(power_type_period - POGO_ID_CHARGER) <=
	POGO_ID_PERIOD_TOLERANCE) {
	pogo->dock_type \|= POGO_DOCK_CHARGER;
	} else if (abs(power_type_period - POGO_ID_USB) >
	POGO_ID_PERIOD_TOLERANCE) {
	continue;
	}

	if (abs(audio_cable_period - POGO_ID_AUDIO) <=
	POGO_ID_PERIOD_TOLERANCE) {
	pogo->dock_type \|= POGO_DOCK_AUDIO_CONN;
	pogo->dock_type \|= POGO_DOCK_DOCKED;
	} else if (abs(audio_cable_period -
	POGO_ID_NO_AUDIO) <=
	POGO_ID_PERIOD_TOLERANCE) {
	pogo->dock_type \|= POGO_DOCK_DOCKED;
	}
	}

	msleep(POGO_ENTER_SPDIF_WAIT_PERIOD);

	mutex_lock(&pogo->mutex);
	omap_mux_set_gpio(OMAP_MUX_MODE2 \| OMAP_PIN_OUTPUT,
	GPIO_POGO_DATA);

	pogo_dock_change(pogo);
	wake_lock_timeout(&pogo->wake_lock, msecs_to_jiffies(1000));

	spin_lock_irqsave(&pogo->det_irq_lock, irqflags);
	pogo->debounce_state = POGO_DET_DOCKED;
	enable_irq(pogo->det_irq);
	enable_irq_wake(pogo->det_irq);
	spin_unlock_irqrestore(&pogo->det_irq_lock, irqflags);
	mutex_unlock(&pogo->mutex);

	return OTG_ID_HANDLED;
	}

	return OTG_ID_UNHANDLED;
	}

	static void pogo_dock_undock(struct tuna_pogo *pogo)
	{
	mutex_lock(&pogo->mutex);
	if ((pogo->dock_type & POGO_DOCK_DOCKED) &&
	pogo->debounce_state == POGO_DET_UNDOCKED) {
	pogo->dock_type = 0;
	pogo_dock_change(pogo);

	omap_mux_set_gpio(OMAP_MUX_MODE3 \| OMAP_PIN_INPUT_PULLDOWN,
	GPIO_POGO_DATA);
	}
	mutex_unlock(&pogo->mutex);
	}

	/* This callback is used to cancel any ownership of the chain */
	static void pogo_cancel_callback(struct otg_id_notifier_block *nb)
	{
	struct tuna_pogo *pogo = container_of(nb, struct tuna_pogo, otg_id_nb);
	unsigned long irqflags;

	/* Disable the POGO_DET IRQ and cancel any pending timer if needed */
	spin_lock_irqsave(&pogo->det_irq_lock, irqflags);
	switch (pogo->debounce_state) {
	case POGO_DET_UNDOCKED:
	break;
	case POGO_DET_UNSTABLE:
	del_timer(&pogo->det_timer);
	break;
	case POGO_DET_WAIT_STABLE:
	del_timer(&pogo->det_timer);
	/* fall through */
	case POGO_DET_DOCKED:
	disable_irq_wake(pogo->det_irq);
	disable_irq_nosync(pogo->det_irq);
	break;
	}
	pogo->debounce_state = POGO_DET_UNDOCKED;
	spin_unlock_irqrestore(&pogo->det_irq_lock, irqflags);

	/* Change the state to undocked */
	pogo_dock_undock(pogo);
	}

	static void det_work_func(struct work_struct *work)
	{
	struct tuna_pogo *pogo = container_of(work, struct tuna_pogo, det_work);

	pogo_dock_undock(pogo);

	/* Notify the otg_id chain that a change has occurred */
	otg_id_notify();
	}

	static void pogo_det_timer_func(unsigned long arg)
	{
	struct tuna_pogo pogo = (struct tuna_pogo )arg;
	unsigned long irqflags;

	spin_lock_irqsave(&pogo->det_irq_lock, irqflags);
	switch (pogo->debounce_state) {
	case POGO_DET_DOCKED:
	break;
	case POGO_DET_UNSTABLE:
	/*
	* The detect gpio changed in one the previous two timeslots,
	* so enable the irq, reset the timer, and wait again. If the
	* detect gpio changed after we last disabled the interrupt we
	* will get anther interrupt right away and the state will go
	* back to POGO_DET_UNSTABLE.
	*/
	pogo->debounce_state = POGO_DET_WAIT_STABLE;
	enable_irq(pogo->det_irq);
	enable_irq_wake(pogo->det_irq);
	mod_timer(&pogo->det_timer,
	jiffies + msecs_to_jiffies(POGO_DET_DEBOUNCE));
	break;
	case POGO_DET_WAIT_STABLE:
	if (gpio_get_value(GPIO_POGO_DET) == 0) {
	pogo->debounce_state = POGO_DET_UNDOCKED;
	disable_irq_wake(pogo->det_irq);
	disable_irq_nosync(pogo->det_irq);
	wake_lock_timeout(&pogo->wake_lock,
	msecs_to_jiffies(1000));
	schedule_work(&pogo->det_work);
	} else {
	/* The device appears to be back in the dock */
	pogo->debounce_state = POGO_DET_DOCKED;
	wake_unlock(&pogo->wake_lock);
	}
	break;
	case POGO_DET_UNDOCKED:
	break;
	}
	spin_unlock_irqrestore(&pogo->det_irq_lock, irqflags);
	}

	static irqreturn_t pogo_det_irq(int irq, void *data)
	{
	struct tuna_pogo *pogo = data;
	unsigned long irqflags;

	spin_lock_irqsave(&pogo->det_irq_lock, irqflags);
	switch (pogo->debounce_state) {
	case POGO_DET_DOCKED:
	wake_lock(&pogo->wake_lock);
	mod_timer(&pogo->det_timer,
	jiffies + msecs_to_jiffies(POGO_DET_DEBOUNCE));
	/* fall through */
	case POGO_DET_WAIT_STABLE:
	/*
	* Disable IRQ line in case there is noise. It will be
	* re-enabled when the timer expires
	*/
	pogo->debounce_state = POGO_DET_UNSTABLE;
	disable_irq_wake(pogo->det_irq);
	disable_irq_nosync(pogo->det_irq);
	break;
	case POGO_DET_UNSTABLE:
	case POGO_DET_UNDOCKED:
	break;
	}
	spin_unlock_irqrestore(&pogo->det_irq_lock, irqflags);

	return IRQ_HANDLED;
	}

	static irqreturn_t pogo_data_irq(int irq, void *data)
	{
	struct tuna_pogo *pogo = data;

	ktime_get_ts(&pogo->timestamps[pogo->ts_index++]);
	irq_set_irq_type(pogo->data_irq, gpio_get_value(GPIO_POGO_DATA) ?
	IRQF_TRIGGER_LOW :
	IRQF_TRIGGER_HIGH);
	if (pogo->ts_index >= ARRAY_SIZE(pogo->timestamps)) {
	complete(&pogo->completion);
	disable_irq_nosync(pogo->data_irq);
	}
	return IRQ_HANDLED;
	}

	void __init omap4_tuna_pogo_init(void)
	{
	struct tuna_pogo *pogo = &tuna_pogo;
	unsigned int r;
	int ret;

	omap_mux_init_signal("usbb2_hsic_data.gpio_169",
	OMAP_PIN_INPUT_PULLDOWN \| OMAP_MUX_MODE3 \|
	OMAP_WAKEUP_EN);

	/* The pullup/pulldown controls in the mux register are not the controls
	* that you are looking for. The usbb2_hsic_data signal has a separate
	* special control in the CONTROL_USBB_HSIC register.
	*/
	r = omap4_ctrl_pad_readl(OMAP4_CTRL_MODULE_PAD_CORE_CONTROL_USBB_HSIC);
	r &= ~OMAP4_USBB2_HSIC_DATA_WD_MASK;
	omap4_ctrl_pad_writel(r, OMAP4_CTRL_MODULE_PAD_CORE_CONTROL_USBB_HSIC);

	ret = gpio_request(GPIO_POGO_DET, "pogo_det");
	if (ret < 0)
	pr_err("request for pogo_det gpio failed, err %d\n", ret);

	gpio_direction_input(GPIO_POGO_DET);

	omap_mux_init_signal("abe_dmic_din2.gpio_121",
	OMAP_PIN_INPUT_PULLDOWN \| OMAP_MUX_MODE3);
	ret = gpio_request(GPIO_POGO_DATA, "pogo_data");
	if (ret < 0)
	pr_err("request for pogo_data gpio failed, err %d\n", ret);

	gpio_direction_output(GPIO_POGO_DATA, 0);

	/* The POGO dock does not involve USB but we are reusing the existing
	* usb audio switch report the availabilty of SPDIF audio through the
	* POGO dock.
	*/
	pogo->audio_switch.name = "usb_audio";

	switch_dev_register(&pogo->audio_switch);

	wake_lock_init(&pogo->wake_lock, WAKE_LOCK_SUSPEND, "pogo");

	init_completion(&pogo->completion);

	pogo->otg_id_nb.detect = pogo_detect_callback;
	pogo->otg_id_nb.proxy_wait = NULL;
	pogo->otg_id_nb.cancel = pogo_cancel_callback;
	pogo->otg_id_nb.priority = TUNA_OTG_ID_POGO_PRIO;

	ret = otg_id_register_notifier(&pogo->otg_id_nb);
	if (ret < 0)
	pr_err("Unable to register notifier\n");

	setup_timer(&pogo->det_timer, pogo_det_timer_func, (unsigned long)pogo);
	spin_lock_init(&pogo->det_irq_lock);
	mutex_init(&pogo->mutex);
	INIT_WORK(&pogo->det_work, det_work_func);
	pogo->debounce_state = POGO_DET_UNDOCKED;

	pogo->det_irq = gpio_to_irq(GPIO_POGO_DET);

	ret = request_irq(pogo->det_irq, pogo_det_irq,
	IRQF_TRIGGER_RISING \|
	IRQF_TRIGGER_FALLING,
	"pogo_det", pogo);
	if (ret < 0)
	pr_err("Unable to register pogo_det interrupt (%d)\n", ret);

	disable_irq(pogo->det_irq);

	pogo->data_irq = gpio_to_irq(GPIO_POGO_DATA);

	ret = request_irq(pogo->data_irq, pogo_data_irq,
	IRQF_TRIGGER_HIGH,
	"pogo_data", pogo);
	if (ret < 0)
	pr_err("Unable to register pogo_data interrupt (%d)\n", ret);

	disable_irq(pogo->data_irq);
	}