[linux-2.6-block.git] / sound / aoa / core / gpio-pmf.c

/*
 * Apple Onboard Audio pmf GPIOs
 *
 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
 *
 * GPL v2, can be found in COPYING.
 */

#include <linux/slab.h>
#include <asm/pmac_feature.h>
#include <asm/pmac_pfunc.h>
#include "../aoa.h"

#define PMF_GPIO(name, bit)					\
static void pmf_gpio_set_##name(struct gpio_runtime *rt, int on)\
{								\
	struct pmf_args args = { .count = 1, .u[0].v = !on };	\
	int rc;							\
							\
	if (unlikely(!rt)) return;				\
	rc = pmf_call_function(rt->node, #name "-mute", &args);	\
	if (rc && rc != -ENODEV)				\
		printk(KERN_WARNING "pmf_gpio_set_" #name	\
		" failed, rc: %d\n", rc);			\
	rt->implementation_private &= ~(1<<bit);		\
	rt->implementation_private |= (!!on << bit);		\
}								\
static int pmf_gpio_get_##name(struct gpio_runtime *rt)		\
{								\
	if (unlikely(!rt)) return 0;				\
	return (rt->implementation_private>>bit)&1;		\
}

PMF_GPIO(headphone, 0);
PMF_GPIO(amp, 1);
PMF_GPIO(lineout, 2);

static void pmf_gpio_set_hw_reset(struct gpio_runtime *rt, int on)
{
	struct pmf_args args = { .count = 1, .u[0].v = !!on };
	int rc;

	if (unlikely(!rt)) return;
	rc = pmf_call_function(rt->node, "hw-reset", &args);
	if (rc)
		printk(KERN_WARNING "pmf_gpio_set_hw_reset"
		       " failed, rc: %d\n", rc);
}

static void pmf_gpio_all_amps_off(struct gpio_runtime *rt)
{
	int saved;

	if (unlikely(!rt)) return;
	saved = rt->implementation_private;
	pmf_gpio_set_headphone(rt, 0);
	pmf_gpio_set_amp(rt, 0);
	pmf_gpio_set_lineout(rt, 0);
	rt->implementation_private = saved;
}

static void pmf_gpio_all_amps_restore(struct gpio_runtime *rt)
{
	int s;

	if (unlikely(!rt)) return;
	s = rt->implementation_private;
	pmf_gpio_set_headphone(rt, (s>>0)&1);
	pmf_gpio_set_amp(rt, (s>>1)&1);
	pmf_gpio_set_lineout(rt, (s>>2)&1);
}

static void pmf_handle_notify(struct work_struct *work)
{
	struct gpio_notification *notif =
		container_of(work, struct gpio_notification, work.work);

	mutex_lock(&notif->mutex);
	if (notif->notify)
		notif->notify(notif->data);
	mutex_unlock(&notif->mutex);
}

static void pmf_gpio_init(struct gpio_runtime *rt)
{
	pmf_gpio_all_amps_off(rt);
	rt->implementation_private = 0;
	INIT_DELAYED_WORK(&rt->headphone_notify.work, pmf_handle_notify);
	INIT_DELAYED_WORK(&rt->line_in_notify.work, pmf_handle_notify);
	INIT_DELAYED_WORK(&rt->line_out_notify.work, pmf_handle_notify);
	mutex_init(&rt->headphone_notify.mutex);
	mutex_init(&rt->line_in_notify.mutex);
	mutex_init(&rt->line_out_notify.mutex);
}

static void pmf_gpio_exit(struct gpio_runtime *rt)
{
	pmf_gpio_all_amps_off(rt);
	rt->implementation_private = 0;

	if (rt->headphone_notify.gpio_private)
		pmf_unregister_irq_client(rt->headphone_notify.gpio_private);
	if (rt->line_in_notify.gpio_private)
		pmf_unregister_irq_client(rt->line_in_notify.gpio_private);
	if (rt->line_out_notify.gpio_private)
		pmf_unregister_irq_client(rt->line_out_notify.gpio_private);

	/* make sure no work is pending before freeing
	 * all things */
	cancel_delayed_work(&rt->headphone_notify.work);
	cancel_delayed_work(&rt->line_in_notify.work);
	cancel_delayed_work(&rt->line_out_notify.work);
	flush_scheduled_work();

	mutex_destroy(&rt->headphone_notify.mutex);
	mutex_destroy(&rt->line_in_notify.mutex);
	mutex_destroy(&rt->line_out_notify.mutex);

	if (rt->headphone_notify.gpio_private)
		kfree(rt->headphone_notify.gpio_private);
	if (rt->line_in_notify.gpio_private)
		kfree(rt->line_in_notify.gpio_private);
	if (rt->line_out_notify.gpio_private)
		kfree(rt->line_out_notify.gpio_private);
}

static void pmf_handle_notify_irq(void *data)
{
	struct gpio_notification *notif = data;

	schedule_delayed_work(&notif->work, 0);
}

static int pmf_set_notify(struct gpio_runtime *rt,
			  enum notify_type type,
			  notify_func_t notify,
			  void *data)
{
	struct gpio_notification *notif;
	notify_func_t old;
	struct pmf_irq_client *irq_client;
	char *name;
	int err = -EBUSY;

	switch (type) {
	case AOA_NOTIFY_HEADPHONE:
		notif = &rt->headphone_notify;
		name = "headphone-detect";
		break;
	case AOA_NOTIFY_LINE_IN:
		notif = &rt->line_in_notify;
		name = "linein-detect";
		break;
	case AOA_NOTIFY_LINE_OUT:
		notif = &rt->line_out_notify;
		name = "lineout-detect";
		break;
	default:
		return -EINVAL;
	}

	mutex_lock(&notif->mutex);

	old = notif->notify;

	if (!old && !notify) {
		err = 0;
		goto out_unlock;
	}

	if (old && notify) {
		if (old == notify && notif->data == data)
			err = 0;
		goto out_unlock;
	}

	if (old && !notify) {
		irq_client = notif->gpio_private;
		pmf_unregister_irq_client(irq_client);
		kfree(irq_client);
		notif->gpio_private = NULL;
	}
	if (!old && notify) {
		irq_client = kzalloc(sizeof(struct pmf_irq_client),
				     GFP_KERNEL);
		if (!irq_client) {
			err = -ENOMEM;
			goto out_unlock;
		}
		irq_client->data = notif;
		irq_client->handler = pmf_handle_notify_irq;
		irq_client->owner = THIS_MODULE;
		err = pmf_register_irq_client(rt->node,
					      name,
					      irq_client);
		if (err) {
			printk(KERN_ERR "snd-aoa: gpio layer failed to"
					" register %s irq (%d)\n", name, err);
			kfree(irq_client);
			goto out_unlock;
		}
		notif->gpio_private = irq_client;
	}
	notif->notify = notify;
	notif->data = data;

	err = 0;
 out_unlock:
	mutex_unlock(&notif->mutex);
	return err;
}

static int pmf_get_detect(struct gpio_runtime *rt,
			  enum notify_type type)
{
	char *name;
	int err = -EBUSY, ret;
	struct pmf_args args = { .count = 1, .u[0].p = &ret };

	switch (type) {
	case AOA_NOTIFY_HEADPHONE:
		name = "headphone-detect";
		break;
	case AOA_NOTIFY_LINE_IN:
		name = "linein-detect";
		break;
	case AOA_NOTIFY_LINE_OUT:
		name = "lineout-detect";
		break;
	default:
		return -EINVAL;
	}

	err = pmf_call_function(rt->node, name, &args);
	if (err)
		return err;
	return ret;
}

static struct gpio_methods methods = {
	.init			= pmf_gpio_init,
	.exit			= pmf_gpio_exit,
	.all_amps_off		= pmf_gpio_all_amps_off,
	.all_amps_restore	= pmf_gpio_all_amps_restore,
	.set_headphone		= pmf_gpio_set_headphone,
	.set_speakers		= pmf_gpio_set_amp,
	.set_lineout		= pmf_gpio_set_lineout,
	.set_hw_reset		= pmf_gpio_set_hw_reset,
	.get_headphone		= pmf_gpio_get_headphone,
	.get_speakers		= pmf_gpio_get_amp,
	.get_lineout		= pmf_gpio_get_lineout,
	.set_notify		= pmf_set_notify,
	.get_detect		= pmf_get_detect,
};

struct gpio_methods *pmf_gpio_methods = &methods;
EXPORT_SYMBOL_GPL(pmf_gpio_methods);
Commit	Line	Data
f3d9478b JB	1	/*
	2	* Apple Onboard Audio pmf GPIOs
	3	*
	4	* Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
	5	*
	6	* GPL v2, can be found in COPYING.
	7	*/
	8
5a0e3ad6	9	#include <linux/slab.h>
f3d9478b JB	10	#include <asm/pmac_feature.h>
	11	#include <asm/pmac_pfunc.h>
	12	#include "../aoa.h"
	13
	14	#define PMF_GPIO(name, bit) \
	15	static void pmf_gpio_set_##name(struct gpio_runtime *rt, int on)\
	16	{ \
	17	struct pmf_args args = { .count = 1, .u[0].v = !on }; \
e53fcabc BH	18	int rc; \
e53fcabc BH	19	\
f3d9478b	20	if (unlikely(!rt)) return; \
e53fcabc	21	rc = pmf_call_function(rt->node, #name "-mute", &args); \
be6a83dd	22	if (rc && rc != -ENODEV) \
e53fcabc BH	23	printk(KERN_WARNING "pmf_gpio_set_" #name \
e53fcabc BH	24	" failed, rc: %d\n", rc); \
f3d9478b JB	25	rt->implementation_private &= ~(1<<bit); \
	26	rt->implementation_private \|= (!!on << bit); \
	27	} \
	28	static int pmf_gpio_get_##name(struct gpio_runtime *rt) \
	29	{ \
	30	if (unlikely(!rt)) return 0; \
	31	return (rt->implementation_private>>bit)&1; \
	32	}
	33
	34	PMF_GPIO(headphone, 0);
	35	PMF_GPIO(amp, 1);
	36	PMF_GPIO(lineout, 2);
	37
	38	static void pmf_gpio_set_hw_reset(struct gpio_runtime *rt, int on)
	39	{
	40	struct pmf_args args = { .count = 1, .u[0].v = !!on };
e53fcabc	41	int rc;
f3d9478b JB	42
f3d9478b JB	43	if (unlikely(!rt)) return;
e53fcabc BH	44	rc = pmf_call_function(rt->node, "hw-reset", &args);
	45	if (rc)
	46	printk(KERN_WARNING "pmf_gpio_set_hw_reset"
	47	" failed, rc: %d\n", rc);
f3d9478b JB	48	}
	49
	50	static void pmf_gpio_all_amps_off(struct gpio_runtime *rt)
	51	{
	52	int saved;
	53
	54	if (unlikely(!rt)) return;
	55	saved = rt->implementation_private;
	56	pmf_gpio_set_headphone(rt, 0);
	57	pmf_gpio_set_amp(rt, 0);
	58	pmf_gpio_set_lineout(rt, 0);
	59	rt->implementation_private = saved;
	60	}
	61
	62	static void pmf_gpio_all_amps_restore(struct gpio_runtime *rt)
	63	{
	64	int s;
	65
	66	if (unlikely(!rt)) return;
	67	s = rt->implementation_private;
	68	pmf_gpio_set_headphone(rt, (s>>0)&1);
	69	pmf_gpio_set_amp(rt, (s>>1)&1);
	70	pmf_gpio_set_lineout(rt, (s>>2)&1);
	71	}
	72
c4028958	73	static void pmf_handle_notify(struct work_struct *work)
f3d9478b	74	{
c4028958 DH	75	struct gpio_notification *notif =
c4028958 DH	76	container_of(work, struct gpio_notification, work.work);
f3d9478b JB	77
	78	mutex_lock(&notif->mutex);
	79	if (notif->notify)
	80	notif->notify(notif->data);
	81	mutex_unlock(&notif->mutex);
	82	}
	83
	84	static void pmf_gpio_init(struct gpio_runtime *rt)
	85	{
	86	pmf_gpio_all_amps_off(rt);
	87	rt->implementation_private = 0;
c4028958 DH	88	INIT_DELAYED_WORK(&rt->headphone_notify.work, pmf_handle_notify);
	89	INIT_DELAYED_WORK(&rt->line_in_notify.work, pmf_handle_notify);
	90	INIT_DELAYED_WORK(&rt->line_out_notify.work, pmf_handle_notify);
f3d9478b JB	91	mutex_init(&rt->headphone_notify.mutex);
	92	mutex_init(&rt->line_in_notify.mutex);
	93	mutex_init(&rt->line_out_notify.mutex);
	94	}
	95
	96	static void pmf_gpio_exit(struct gpio_runtime *rt)
	97	{
	98	pmf_gpio_all_amps_off(rt);
	99	rt->implementation_private = 0;
	100
	101	if (rt->headphone_notify.gpio_private)
	102	pmf_unregister_irq_client(rt->headphone_notify.gpio_private);
	103	if (rt->line_in_notify.gpio_private)
	104	pmf_unregister_irq_client(rt->line_in_notify.gpio_private);
	105	if (rt->line_out_notify.gpio_private)
	106	pmf_unregister_irq_client(rt->line_out_notify.gpio_private);
	107
	108	/* make sure no work is pending before freeing
	109	* all things */
	110	cancel_delayed_work(&rt->headphone_notify.work);
	111	cancel_delayed_work(&rt->line_in_notify.work);
	112	cancel_delayed_work(&rt->line_out_notify.work);
	113	flush_scheduled_work();
	114
	115	mutex_destroy(&rt->headphone_notify.mutex);
	116	mutex_destroy(&rt->line_in_notify.mutex);
	117	mutex_destroy(&rt->line_out_notify.mutex);
	118
	119	if (rt->headphone_notify.gpio_private)
	120	kfree(rt->headphone_notify.gpio_private);
	121	if (rt->line_in_notify.gpio_private)
	122	kfree(rt->line_in_notify.gpio_private);
	123	if (rt->line_out_notify.gpio_private)
	124	kfree(rt->line_out_notify.gpio_private);
	125	}
	126
	127	static void pmf_handle_notify_irq(void *data)
	128	{
	129	struct gpio_notification *notif = data;
	130
c4028958	131	schedule_delayed_work(&notif->work, 0);
f3d9478b JB	132	}
	133
	134	static int pmf_set_notify(struct gpio_runtime *rt,
	135	enum notify_type type,
	136	notify_func_t notify,
	137	void *data)
	138	{
	139	struct gpio_notification *notif;
	140	notify_func_t old;
	141	struct pmf_irq_client *irq_client;
	142	char *name;
	143	int err = -EBUSY;
	144
	145	switch (type) {
	146	case AOA_NOTIFY_HEADPHONE:
	147	notif = &rt->headphone_notify;
	148	name = "headphone-detect";
	149	break;
	150	case AOA_NOTIFY_LINE_IN:
	151	notif = &rt->line_in_notify;
	152	name = "linein-detect";
	153	break;
	154	case AOA_NOTIFY_LINE_OUT:
	155	notif = &rt->line_out_notify;
	156	name = "lineout-detect";
	157	break;
	158	default:
	159	return -EINVAL;
	160	}
	161
	162	mutex_lock(&notif->mutex);
	163
	164	old = notif->notify;
	165
	166	if (!old && !notify) {
	167	err = 0;
	168	goto out_unlock;
	169	}
	170
	171	if (old && notify) {
	172	if (old == notify && notif->data == data)
	173	err = 0;
	174	goto out_unlock;
	175	}
	176
	177	if (old && !notify) {
	178	irq_client = notif->gpio_private;
	179	pmf_unregister_irq_client(irq_client);
	180	kfree(irq_client);
	181	notif->gpio_private = NULL;
	182	}
	183	if (!old && notify) {
	184	irq_client = kzalloc(sizeof(struct pmf_irq_client),
	185	GFP_KERNEL);
f065fabc JL	186	if (!irq_client) {
	187	err = -ENOMEM;
	188	goto out_unlock;
	189	}
f3d9478b JB	190	irq_client->data = notif;
	191	irq_client->handler = pmf_handle_notify_irq;
	192	irq_client->owner = THIS_MODULE;
	193	err = pmf_register_irq_client(rt->node,
	194	name,
	195	irq_client);
	196	if (err) {
	197	printk(KERN_ERR "snd-aoa: gpio layer failed to"
	198	" register %s irq (%d)\n", name, err);
	199	kfree(irq_client);
	200	goto out_unlock;
	201	}
	202	notif->gpio_private = irq_client;
	203	}
	204	notif->notify = notify;
	205	notif->data = data;
	206
	207	err = 0;
	208	out_unlock:
	209	mutex_unlock(&notif->mutex);
	210	return err;
	211	}
	212
	213	static int pmf_get_detect(struct gpio_runtime *rt,
	214	enum notify_type type)
	215	{
	216	char *name;
	217	int err = -EBUSY, ret;
	218	struct pmf_args args = { .count = 1, .u[0].p = &ret };
	219
	220	switch (type) {
	221	case AOA_NOTIFY_HEADPHONE:
	222	name = "headphone-detect";
	223	break;
	224	case AOA_NOTIFY_LINE_IN:
	225	name = "linein-detect";
	226	break;
	227	case AOA_NOTIFY_LINE_OUT:
	228	name = "lineout-detect";
	229	break;
	230	default:
	231	return -EINVAL;
	232	}
	233
	234	err = pmf_call_function(rt->node, name, &args);
	235	if (err)
	236	return err;
	237	return ret;
	238	}
	239
	240	static struct gpio_methods methods = {
	241	.init = pmf_gpio_init,
	242	.exit = pmf_gpio_exit,
	243	.all_amps_off = pmf_gpio_all_amps_off,
	244	.all_amps_restore = pmf_gpio_all_amps_restore,
	245	.set_headphone = pmf_gpio_set_headphone,
	246	.set_speakers = pmf_gpio_set_amp,
	247	.set_lineout = pmf_gpio_set_lineout,
	248	.set_hw_reset = pmf_gpio_set_hw_reset,
	249	.get_headphone = pmf_gpio_get_headphone,
	250	.get_speakers = pmf_gpio_get_amp,
	251	.get_lineout = pmf_gpio_get_lineout,
	252	.set_notify = pmf_set_notify,
	253	.get_detect = pmf_get_detect,
254	};
255
256	struct gpio_methods *pmf_gpio_methods = &methods;
257	EXPORT_SYMBOL_GPL(pmf_gpio_methods);