[linux-block.git] / sound / aoa / soundbus / i2sbus / control.c

/*
 * i2sbus driver -- bus control routines
 *
 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
 *
 * GPL v2, can be found in COPYING.
 */

#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/slab.h>

#include <asm/io.h>
#include <asm/prom.h>
#include <asm/macio.h>
#include <asm/pmac_feature.h>
#include <asm/pmac_pfunc.h>
#include <asm/keylargo.h>

#include "i2sbus.h"

int i2sbus_control_init(struct macio_dev* dev, struct i2sbus_control **c)
{
	*c = kzalloc(sizeof(struct i2sbus_control), GFP_KERNEL);
	if (!*c)
		return -ENOMEM;

	INIT_LIST_HEAD(&(*c)->list);

	(*c)->macio = dev->bus->chip;
	return 0;
}

void i2sbus_control_destroy(struct i2sbus_control *c)
{
	kfree(c);
}

/* this is serialised externally */
int i2sbus_control_add_dev(struct i2sbus_control *c,
			   struct i2sbus_dev *i2sdev)
{
	struct device_node *np;

	np = i2sdev->sound.ofdev.node;
	i2sdev->enable = pmf_find_function(np, "enable");
	i2sdev->cell_enable = pmf_find_function(np, "cell-enable");
	i2sdev->clock_enable = pmf_find_function(np, "clock-enable");
	i2sdev->cell_disable = pmf_find_function(np, "cell-disable");
	i2sdev->clock_disable = pmf_find_function(np, "clock-disable");

	/* if the bus number is not 0 or 1 we absolutely need to use
	 * the platform functions -- there's nothing in Darwin that
	 * would allow seeing a system behind what the FCRs are then,
	 * and I don't want to go parsing a bunch of platform functions
	 * by hand to try finding a system... */
	if (i2sdev->bus_number != 0 && i2sdev->bus_number != 1 &&
	    (!i2sdev->enable ||
	     !i2sdev->cell_enable || !i2sdev->clock_enable ||
	     !i2sdev->cell_disable || !i2sdev->clock_disable)) {
		pmf_put_function(i2sdev->enable);
		pmf_put_function(i2sdev->cell_enable);
		pmf_put_function(i2sdev->clock_enable);
		pmf_put_function(i2sdev->cell_disable);
		pmf_put_function(i2sdev->clock_disable);
		return -ENODEV;
	}

	list_add(&i2sdev->item, &c->list);

	return 0;
}

void i2sbus_control_remove_dev(struct i2sbus_control *c,
			       struct i2sbus_dev *i2sdev)
{
	/* this is serialised externally */
	list_del(&i2sdev->item);
	if (list_empty(&c->list))
		i2sbus_control_destroy(c);
}

int i2sbus_control_enable(struct i2sbus_control *c,
			  struct i2sbus_dev *i2sdev)
{
	struct pmf_args args = { .count = 0 };
	struct macio_chip *macio = c->macio;

	if (i2sdev->enable)
		return pmf_call_one(i2sdev->enable, &args);

	if (macio == NULL || macio->base == NULL)
		return -ENODEV;

	switch (i2sdev->bus_number) {
	case 0:
		/* these need to be locked or done through
		 * newly created feature calls! */
		MACIO_BIS(KEYLARGO_FCR1, KL1_I2S0_ENABLE);
		break;
	case 1:
		MACIO_BIS(KEYLARGO_FCR1, KL1_I2S1_ENABLE);
		break;
	default:
		return -ENODEV;
	}
	return 0;
}

int i2sbus_control_cell(struct i2sbus_control *c,
			struct i2sbus_dev *i2sdev,
			int enable)
{
	struct pmf_args args = { .count = 0 };
	struct macio_chip *macio = c->macio;

	switch (enable) {
	case 0:
		if (i2sdev->cell_disable)
			return pmf_call_one(i2sdev->cell_disable, &args);
		break;
	case 1:
		if (i2sdev->cell_enable)
			return pmf_call_one(i2sdev->cell_enable, &args);
		break;
	default:
		printk(KERN_ERR "i2sbus: INVALID CELL ENABLE VALUE\n");
		return -ENODEV;
	}

	if (macio == NULL || macio->base == NULL)
		return -ENODEV;

	switch (i2sdev->bus_number) {
	case 0:
		if (enable)
			MACIO_BIS(KEYLARGO_FCR1, KL1_I2S0_CELL_ENABLE);
		else
			MACIO_BIC(KEYLARGO_FCR1, KL1_I2S0_CELL_ENABLE);
		break;
	case 1:
		if (enable)
			MACIO_BIS(KEYLARGO_FCR1, KL1_I2S1_CELL_ENABLE);
		else
			MACIO_BIC(KEYLARGO_FCR1, KL1_I2S1_CELL_ENABLE);
		break;
	default:
		return -ENODEV;
	}
	return 0;
}

int i2sbus_control_clock(struct i2sbus_control *c,
			 struct i2sbus_dev *i2sdev,
			 int enable)
{
	struct pmf_args args = { .count = 0 };
	struct macio_chip *macio = c->macio;

	switch (enable) {
	case 0:
		if (i2sdev->clock_disable)
			return pmf_call_one(i2sdev->clock_disable, &args);
		break;
	case 1:
		if (i2sdev->clock_enable)
			return pmf_call_one(i2sdev->clock_enable, &args);
		break;
	default:
		printk(KERN_ERR "i2sbus: INVALID CLOCK ENABLE VALUE\n");
		return -ENODEV;
	}

	if (macio == NULL || macio->base == NULL)
		return -ENODEV;

	switch (i2sdev->bus_number) {
	case 0:
		if (enable)
			MACIO_BIS(KEYLARGO_FCR1, KL1_I2S0_CLK_ENABLE_BIT);
		else
			MACIO_BIC(KEYLARGO_FCR1, KL1_I2S0_CLK_ENABLE_BIT);
		break;
	case 1:
		if (enable)
			MACIO_BIS(KEYLARGO_FCR1, KL1_I2S1_CLK_ENABLE_BIT);
		else
			MACIO_BIC(KEYLARGO_FCR1, KL1_I2S1_CLK_ENABLE_BIT);
		break;
	default:
		return -ENODEV;
	}
	return 0;
}
Commit	Line	Data
f3d9478b JB	1	/*
	2	* i2sbus driver -- bus control routines
	3	*
	4	* Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
	5	*
	6	* GPL v2, can be found in COPYING.
	7	*/
	8
977c6023	9	#include <linux/kernel.h>
f3d9478b	10	#include <linux/delay.h>
5a0e3ad6	11	#include <linux/slab.h>
977c6023 BH	12
977c6023 BH	13	#include <asm/io.h>
f3d9478b JB	14	#include <asm/prom.h>
	15	#include <asm/macio.h>
	16	#include <asm/pmac_feature.h>
	17	#include <asm/pmac_pfunc.h>
977c6023 BH	18	#include <asm/keylargo.h>
977c6023 BH	19
f3d9478b JB	20	#include "i2sbus.h"
	21
	22	int i2sbus_control_init(struct macio_dev* dev, struct i2sbus_control **c)
	23	{
	24	*c = kzalloc(sizeof(struct i2sbus_control), GFP_KERNEL);
	25	if (!*c)
	26	return -ENOMEM;
	27
	28	INIT_LIST_HEAD(&(*c)->list);
	29
977c6023	30	(*c)->macio = dev->bus->chip;
f3d9478b	31	return 0;
f3d9478b JB	32	}
	33
	34	void i2sbus_control_destroy(struct i2sbus_control *c)
	35	{
f3d9478b JB	36	kfree(c);
	37	}
	38
	39	/* this is serialised externally */
	40	int i2sbus_control_add_dev(struct i2sbus_control *c,
	41	struct i2sbus_dev *i2sdev)
	42	{
	43	struct device_node *np;
	44
	45	np = i2sdev->sound.ofdev.node;
	46	i2sdev->enable = pmf_find_function(np, "enable");
	47	i2sdev->cell_enable = pmf_find_function(np, "cell-enable");
	48	i2sdev->clock_enable = pmf_find_function(np, "clock-enable");
	49	i2sdev->cell_disable = pmf_find_function(np, "cell-disable");
	50	i2sdev->clock_disable = pmf_find_function(np, "clock-disable");
	51
	52	/* if the bus number is not 0 or 1 we absolutely need to use
	53	* the platform functions -- there's nothing in Darwin that
	54	* would allow seeing a system behind what the FCRs are then,
	55	* and I don't want to go parsing a bunch of platform functions
	56	* by hand to try finding a system... */
	57	if (i2sdev->bus_number != 0 && i2sdev->bus_number != 1 &&
	58	(!i2sdev->enable \|\|
	59	!i2sdev->cell_enable \|\| !i2sdev->clock_enable \|\|
	60	!i2sdev->cell_disable \|\| !i2sdev->clock_disable)) {
	61	pmf_put_function(i2sdev->enable);
	62	pmf_put_function(i2sdev->cell_enable);
	63	pmf_put_function(i2sdev->clock_enable);
	64	pmf_put_function(i2sdev->cell_disable);
	65	pmf_put_function(i2sdev->clock_disable);
	66	return -ENODEV;
	67	}
	68
	69	list_add(&i2sdev->item, &c->list);
	70
	71	return 0;
	72	}
	73
	74	void i2sbus_control_remove_dev(struct i2sbus_control *c,
	75	struct i2sbus_dev *i2sdev)
	76	{
	77	/* this is serialised externally */
	78	list_del(&i2sdev->item);
	79	if (list_empty(&c->list))
	80	i2sbus_control_destroy(c);
	81	}
	82
	83	int i2sbus_control_enable(struct i2sbus_control *c,
	84	struct i2sbus_dev *i2sdev)
	85	{
	86	struct pmf_args args = { .count = 0 };
977c6023	87	struct macio_chip *macio = c->macio;
f3d9478b JB	88
	89	if (i2sdev->enable)
	90	return pmf_call_one(i2sdev->enable, &args);
	91
977c6023 BH	92	if (macio == NULL \|\| macio->base == NULL)
	93	return -ENODEV;
	94
f3d9478b JB	95	switch (i2sdev->bus_number) {
f3d9478b JB	96	case 0:
977c6023 BH	97	/* these need to be locked or done through
	98	* newly created feature calls! */
	99	MACIO_BIS(KEYLARGO_FCR1, KL1_I2S0_ENABLE);
f3d9478b JB	100	break;
f3d9478b JB	101	case 1:
977c6023	102	MACIO_BIS(KEYLARGO_FCR1, KL1_I2S1_ENABLE);
f3d9478b JB	103	break;
	104	default:
	105	return -ENODEV;
	106	}
	107	return 0;
	108	}
	109
	110	int i2sbus_control_cell(struct i2sbus_control *c,
	111	struct i2sbus_dev *i2sdev,
	112	int enable)
	113	{
	114	struct pmf_args args = { .count = 0 };
977c6023	115	struct macio_chip *macio = c->macio;
f3d9478b JB	116
	117	switch (enable) {
	118	case 0:
	119	if (i2sdev->cell_disable)
	120	return pmf_call_one(i2sdev->cell_disable, &args);
	121	break;
	122	case 1:
	123	if (i2sdev->cell_enable)
	124	return pmf_call_one(i2sdev->cell_enable, &args);
	125	break;
	126	default:
	127	printk(KERN_ERR "i2sbus: INVALID CELL ENABLE VALUE\n");
	128	return -ENODEV;
	129	}
977c6023 BH	130
	131	if (macio == NULL \|\| macio->base == NULL)
	132	return -ENODEV;
	133
f3d9478b JB	134	switch (i2sdev->bus_number) {
f3d9478b JB	135	case 0:
977c6023 BH	136	if (enable)
	137	MACIO_BIS(KEYLARGO_FCR1, KL1_I2S0_CELL_ENABLE);
	138	else
	139	MACIO_BIC(KEYLARGO_FCR1, KL1_I2S0_CELL_ENABLE);
f3d9478b JB	140	break;
f3d9478b JB	141	case 1:
977c6023 BH	142	if (enable)
	143	MACIO_BIS(KEYLARGO_FCR1, KL1_I2S1_CELL_ENABLE);
	144	else
	145	MACIO_BIC(KEYLARGO_FCR1, KL1_I2S1_CELL_ENABLE);
f3d9478b JB	146	break;
	147	default:
	148	return -ENODEV;
	149	}
	150	return 0;
	151	}
	152
	153	int i2sbus_control_clock(struct i2sbus_control *c,
	154	struct i2sbus_dev *i2sdev,
	155	int enable)
	156	{
	157	struct pmf_args args = { .count = 0 };
977c6023	158	struct macio_chip *macio = c->macio;
f3d9478b JB	159
	160	switch (enable) {
	161	case 0:
	162	if (i2sdev->clock_disable)
	163	return pmf_call_one(i2sdev->clock_disable, &args);
	164	break;
	165	case 1:
	166	if (i2sdev->clock_enable)
	167	return pmf_call_one(i2sdev->clock_enable, &args);
	168	break;
	169	default:
	170	printk(KERN_ERR "i2sbus: INVALID CLOCK ENABLE VALUE\n");
	171	return -ENODEV;
	172	}
977c6023 BH	173
	174	if (macio == NULL \|\| macio->base == NULL)
	175	return -ENODEV;
	176
f3d9478b JB	177	switch (i2sdev->bus_number) {
f3d9478b JB	178	case 0:
977c6023 BH	179	if (enable)
	180	MACIO_BIS(KEYLARGO_FCR1, KL1_I2S0_CLK_ENABLE_BIT);
	181	else
	182	MACIO_BIC(KEYLARGO_FCR1, KL1_I2S0_CLK_ENABLE_BIT);
f3d9478b JB	183	break;
f3d9478b JB	184	case 1:
977c6023 BH	185	if (enable)
	186	MACIO_BIS(KEYLARGO_FCR1, KL1_I2S1_CLK_ENABLE_BIT);
	187	else
	188	MACIO_BIC(KEYLARGO_FCR1, KL1_I2S1_CLK_ENABLE_BIT);
f3d9478b JB	189	break;
	190	default:
	191	return -ENODEV;
	192	}
	193	return 0;
	194	}