Commit 0b83ddeb authored by Peter Ujfalusi's avatar Peter Ujfalusi Committed by Mark Brown
Browse files

MFD: twl4030: add twl4030_codec MFD as a new child to the core 



New MFD child to twl4030 MFD device.

Reason for the twl4030_codec MFD: the vibra control is actually in the codec
part of the twl4030. If both the vibra and the audio functionality is needed
from the twl4030 at the same time, than they need to control the codec power
and APLL at the same time without breaking the other driver.
Also these two has to be able to work without the need for the other driver.

This MFD device will be used by the drivers, which needs resources
from the twl4030 codec like audio and vibra.

The platform specific configuration data is passed along to the
child drivers (audio, vibra).

Signed-off-by: default avatarPeter Ujfalusi <peter.ujfalusi@nokia.com>
Acked-by: default avatarSamuel Ortiz <sameo@linux.intel.com>
Signed-off-by: default avatarMark Brown <broonie@opensource.wolfsonmicro.com>
parent 0ffc1180

drivers/mfd/Kconfig

+6 −0
Original line number Diff line number Diff line
@@ -121,6 +121,12 @@ config TWL4030_POWER 
	  and load scripts controling which resources are switched off/on

	  or reset when a sleep, wakeup or warm reset event occurs.



config TWL4030_CODEC

	bool

	depends on TWL4030_CORE

	select MFD_CORE

	default n



config MFD_TMIO

	bool

	default n

drivers/mfd/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ obj-$(CONFIG_MENELAUS) += menelaus.o 


obj-$(CONFIG_TWL4030_CORE)	+= twl4030-core.o twl4030-irq.o

obj-$(CONFIG_TWL4030_POWER)    += twl4030-power.o

obj-$(CONFIG_TWL4030_CODEC)	+= twl4030-codec.o



obj-$(CONFIG_MFD_MC13783)	+= mc13783-core.o

drivers/mfd/twl4030-codec.c

0 → 100644
+241 −0
Original line number Diff line number Diff line 
/*

 * MFD driver for twl4030 codec submodule

 *

 * Author:	Peter Ujfalusi <peter.ujfalusi@nokia.com>

 *

 * Copyright:   (C) 2009 Nokia Corporation

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 *

 * 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.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

 * 02110-1301 USA

 *

 */



#include <linux/module.h>

#include <linux/types.h>

#include <linux/kernel.h>

#include <linux/fs.h>

#include <linux/platform_device.h>

#include <linux/i2c/twl4030.h>

#include <linux/mfd/core.h>

#include <linux/mfd/twl4030-codec.h>



#define TWL4030_CODEC_CELLS	2



static struct platform_device *twl4030_codec_dev;



struct twl4030_codec_resource {

	int request_count;

	u8 reg;

	u8 mask;

};



struct twl4030_codec {

	struct mutex mutex;

	struct twl4030_codec_resource resource[TWL4030_CODEC_RES_MAX];

	struct mfd_cell cells[TWL4030_CODEC_CELLS];

};



/*

 * Modify the resource, the function returns the content of the register

 * after the modification.

 */

static int twl4030_codec_set_resource(enum twl4030_codec_res id, int enable)

{

	struct twl4030_codec *codec = platform_get_drvdata(twl4030_codec_dev);

	u8 val;



	twl4030_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &val,

			codec->resource[id].reg);



	if (enable)

		val |= codec->resource[id].mask;

	else

		val &= ~codec->resource[id].mask;



	twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,

					val, codec->resource[id].reg);



	return val;

}



static inline int twl4030_codec_get_resource(enum twl4030_codec_res id)

{

	struct twl4030_codec *codec = platform_get_drvdata(twl4030_codec_dev);

	u8 val;



	twl4030_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &val,

			codec->resource[id].reg);



	return val;

}



/*

 * Enable the resource.

 * The function returns with error or the content of the register

 */

int twl4030_codec_enable_resource(enum twl4030_codec_res id)

{

	struct twl4030_codec *codec = platform_get_drvdata(twl4030_codec_dev);

	int val;



	if (id >= TWL4030_CODEC_RES_MAX) {

		dev_err(&twl4030_codec_dev->dev,

				"Invalid resource ID (%u)\n", id);

		return -EINVAL;

	}



	mutex_lock(&codec->mutex);

	if (!codec->resource[id].request_count)

		/* Resource was disabled, enable it */

		val = twl4030_codec_set_resource(id, 1);

	else

		val = twl4030_codec_get_resource(id);



	codec->resource[id].request_count++;

	mutex_unlock(&codec->mutex);



	return val;

}

EXPORT_SYMBOL_GPL(twl4030_codec_enable_resource);



/*

 * Disable the resource.

 * The function returns with error or the content of the register

 */

int twl4030_codec_disable_resource(unsigned id)

{

	struct twl4030_codec *codec = platform_get_drvdata(twl4030_codec_dev);

	int val;



	if (id >= TWL4030_CODEC_RES_MAX) {

		dev_err(&twl4030_codec_dev->dev,

				"Invalid resource ID (%u)\n", id);

		return -EINVAL;

	}



	mutex_lock(&codec->mutex);

	if (!codec->resource[id].request_count) {

		dev_err(&twl4030_codec_dev->dev,

			"Resource has been disabled already (%u)\n", id);

		mutex_unlock(&codec->mutex);

		return -EPERM;

	}

	codec->resource[id].request_count--;



	if (!codec->resource[id].request_count)

		/* Resource can be disabled now */

		val = twl4030_codec_set_resource(id, 0);

	else

		val = twl4030_codec_get_resource(id);



	mutex_unlock(&codec->mutex);



	return val;

}

EXPORT_SYMBOL_GPL(twl4030_codec_disable_resource);



static int __devinit twl4030_codec_probe(struct platform_device *pdev)

{

	struct twl4030_codec *codec;

	struct twl4030_codec_data *pdata = pdev->dev.platform_data;

	struct mfd_cell *cell = NULL;

	int ret, childs = 0;



	codec = kzalloc(sizeof(struct twl4030_codec), GFP_KERNEL);

	if (!codec)

		return -ENOMEM;



	platform_set_drvdata(pdev, codec);



	twl4030_codec_dev = pdev;

	mutex_init(&codec->mutex);



	/* Codec power */

	codec->resource[TWL4030_CODEC_RES_POWER].reg = TWL4030_REG_CODEC_MODE;

	codec->resource[TWL4030_CODEC_RES_POWER].mask = TWL4030_CODECPDZ;



	/* PLL */

	codec->resource[TWL4030_CODEC_RES_APLL].reg = TWL4030_REG_APLL_CTL;

	codec->resource[TWL4030_CODEC_RES_APLL].mask = TWL4030_APLL_EN;



	if (pdata->audio) {

		cell = &codec->cells[childs];

		cell->name = "twl4030_codec_audio";

		cell->platform_data = pdata->audio;

		cell->data_size = sizeof(*pdata->audio);

		childs++;

	}

	if (pdata->vibra) {

		cell = &codec->cells[childs];

		cell->name = "twl4030_codec_vibra";

		cell->platform_data = pdata->vibra;

		cell->data_size = sizeof(*pdata->vibra);

		childs++;

	}



	if (childs)

		ret = mfd_add_devices(&pdev->dev, pdev->id, codec->cells,

				      childs, NULL, 0);

	else {

		dev_err(&pdev->dev, "No platform data found for childs\n");

		ret = -ENODEV;

	}



	if (!ret)

		return 0;



	platform_set_drvdata(pdev, NULL);

	kfree(codec);

	twl4030_codec_dev = NULL;

	return ret;

}



static int __devexit twl4030_codec_remove(struct platform_device *pdev)

{

	struct twl4030_codec *codec = platform_get_drvdata(pdev);



	mfd_remove_devices(&pdev->dev);

	platform_set_drvdata(pdev, NULL);

	kfree(codec);

	twl4030_codec_dev = NULL;



	return 0;

}



MODULE_ALIAS("platform:twl4030_codec");



static struct platform_driver twl4030_codec_driver = {

	.probe		= twl4030_codec_probe,

	.remove		= __devexit_p(twl4030_codec_remove),

	.driver		= {

		.owner	= THIS_MODULE,

		.name	= "twl4030_codec",

	},

};



static int __devinit twl4030_codec_init(void)

{

	return platform_driver_register(&twl4030_codec_driver);

}

module_init(twl4030_codec_init);



static void __devexit twl4030_codec_exit(void)

{

	platform_driver_unregister(&twl4030_codec_driver);

}

module_exit(twl4030_codec_exit);



MODULE_AUTHOR("Peter Ujfalusi <peter.ujfalusi@nokia.com>");

MODULE_LICENSE("GPL");

drivers/mfd/twl4030-core.c

+14 −0
Original line number Diff line number Diff line
@@ -114,6 +114,12 @@ 
#define twl_has_watchdog()        false

#endif



#if defined(CONFIG_TWL4030_CODEC) || defined(CONFIG_TWL4030_CODEC_MODULE)

#define twl_has_codec()	true

#else

#define twl_has_codec()	false

#endif



/* Triton Core internal information (BEGIN) */



/* Last - for index max*/
@@ -557,6 +563,14 @@ add_children(struct twl4030_platform_data *pdata, unsigned long features) 
			return PTR_ERR(child);

	}



	if (twl_has_codec() && pdata->codec) {

		child = add_child(1, "twl4030_codec",

				pdata->codec, sizeof(*pdata->codec),

				false, 0, 0);

		if (IS_ERR(child))

			return PTR_ERR(child);

	}



	if (twl_has_regulator()) {

		/*

		child = add_regulator(TWL4030_REG_VPLL1, pdata->vpll1);

include/linux/i2c/twl4030.h

+18 −0
Original line number Diff line number Diff line
@@ -401,6 +401,23 @@ struct twl4030_power_data { 


extern void twl4030_power_init(struct twl4030_power_data *triton2_scripts);



struct twl4030_codec_audio_data {

	unsigned int	audio_mclk;

	unsigned int ramp_delay_value;

	unsigned int hs_extmute:1;

	void (*set_hs_extmute)(int mute);

};



struct twl4030_codec_vibra_data {

	unsigned int	audio_mclk;

	unsigned int	coexist;

};



struct twl4030_codec_data {

	struct twl4030_codec_audio_data		*audio;

	struct twl4030_codec_vibra_data		*vibra;

};



struct twl4030_platform_data {

	unsigned				irq_base, irq_end;

	struct twl4030_bci_platform_data	*bci;
@@ -409,6 +426,7 @@ struct twl4030_platform_data { 
	struct twl4030_keypad_data		*keypad;

	struct twl4030_usb_data			*usb;

	struct twl4030_power_data		*power;

	struct twl4030_codec_data		*codec;



	/* LDO regulators */

	struct regulator_init_data		*vdac;

CRA Git | Maintained and supported by SUSTech CRA and CCSE