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

/*
 * Apple Onboard Audio pmf GPIOs
 *
 * Copyright 2006 Johannes Berg <[email protected]>
 *
 * GPL v2, can be found in COPYING.
 */

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