greybus: gb-audio: Add integrated greybus audio driver

diff --git a/Makefile b/Makefile
index 9aebfbe..719e134 100644
--- a/Makefile
+++ b/Makefile
@@ -17,7 +17,6 @@  gb-phy-y :=	gpb.o		\
 		i2c.o	\
 		spi.o	\
 		i2s_mgmt.o		\
-		i2s_transmitter.o	\
 		usb.o
 
 # Prefix all modules with gb-
@@ -25,6 +24,7 @@  gb-vibrator-y := vibrator.o
 gb-battery-y := battery.o
 gb-es1-y := es1.o
 gb-es2-y := es2.o
+gb-audio-y := audio.o
 
 obj-m += greybus.o
 obj-m += gb-phy.o
@@ -32,6 +32,7 @@  obj-m += gb-vibrator.o
 obj-m += gb-battery.o
 obj-m += gb-es1.o
 obj-m += gb-es2.o
+obj-m += gb-audio.o
 
 KERNELVER		?= $(shell uname -r)
 KERNELDIR 		?= /lib/modules/$(KERNELVER)/build
diff --git a/audio.c b/audio.c
new file mode 100644
index 0000000..ab98f6c
--- /dev/null
+++ b/audio.c
@@ -0,0 +1,410 @@ 
+#include <linux/device.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/dmaengine_pcm.h>
+#include <sound/simple_card.h>
+#include "greybus.h"
+
+#define GB_AUDIO_DRIVER_NAME			"gb_audio"
+
+#define GB_RATES				SNDRV_PCM_RATE_8000_48000
+#define GB_FMTS					SNDRV_PCM_FMTBIT_S16_LE
+#define GB_MAX_LENGTH				256L
+#define PREALLOC_BUFFER				(32 * 1024)
+#define PREALLOC_BUFFER_MAX			(32 * 1024)
+
+/* Switch between dummy spdif and jetson rt5639 codec */
+#define USE_RT5639 0
+
+/* XXX remove this once MarkG's code lands */
+#ifndef GB_I2S_DATA_TYPE_SEND_DATA
+#define GB_I2S_DATA_TYPE_SEND_DATA	0x02
+#endif
+
+/***************************************************************
+ * This is the gb_snd structure which ties everything together
+ * and fakes DMA interrupts via a timer.
+ ***************************************************************/
+struct gb_snd {
+	struct platform_device		*card;
+	struct platform_device		*cpu_dai;
+	struct gb_connection		*connection;
+
+	struct snd_pcm_substream	*substream;
+	struct timer_list		timer;
+	int				hwptr_done;
+};
+
+static void dummy_timer_start(struct gb_snd *snd_dev)
+{
+	snd_dev->timer.expires = jiffies + HZ/8;
+	add_timer(&snd_dev->timer);
+}
+
+static void dummy_timer_stop(struct gb_snd *snd_dev)
+{
+	del_timer(&snd_dev->timer);
+	snd_dev->timer.expires = 0;
+}
+
+static void dummy_timer_function(unsigned long data)
+{
+	struct gb_snd *snd_dev = (struct gb_snd *)data;
+	struct snd_pcm_substream *substream = snd_dev->substream;
+	struct snd_pcm_runtime *runtime = substream->runtime;
+	char* address;
+	long len;
+	int ret;
+
+	address = runtime->dma_area + snd_dev->hwptr_done;
+	len = frames_to_bytes(runtime, runtime->buffer_size) - snd_dev->hwptr_done;
+	len = min(len, GB_MAX_LENGTH);
+
+	ret = gb_operation_sync(snd_dev->connection, GB_I2S_DATA_TYPE_SEND_DATA,
+							address, len, NULL, 0);
+	snd_dev->hwptr_done += len;
+
+	dummy_timer_start(snd_dev);
+	snd_pcm_period_elapsed(substream);
+}
+
+
+/******************************************
+ * dai op functions)
+ ******************************************/
+
+static int gb_dai_startup(struct snd_pcm_substream *substream,
+				struct snd_soc_dai *dai)
+{
+	return 0;
+}
+
+static void gb_dai_shutdown(struct snd_pcm_substream *substream,
+				struct snd_soc_dai *dai)
+{
+}
+
+static int gb_dai_trigger(struct snd_pcm_substream *substream, int cmd,
+				struct snd_soc_dai *dai)
+{
+	struct snd_soc_pcm_runtime *rtd = substream->private_data;
+	struct gb_snd *snd_dev;
+
+
+	snd_dev = snd_soc_dai_get_drvdata(rtd->cpu_dai);
+
+	switch (cmd) {
+	case SNDRV_PCM_TRIGGER_START:
+		dummy_timer_start(snd_dev);
+		break;
+	case SNDRV_PCM_TRIGGER_STOP:
+		dummy_timer_stop(snd_dev);
+		break;
+	default:
+		return -EINVAL;
+	}
+	return 0;
+}
+
+static int gb_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
+{
+	return 0;
+}
+
+static int gb_dai_hw_params(struct snd_pcm_substream *substream,
+				struct snd_pcm_hw_params *params,
+				struct snd_soc_dai *dai)
+{
+	return 0;
+}
+
+
+static const struct snd_soc_dai_ops gb_dai_ops = {
+	.startup        = gb_dai_startup,
+	.shutdown       = gb_dai_shutdown,
+	.trigger        = gb_dai_trigger,
+	.set_fmt        = gb_dai_set_fmt,
+	.hw_params      = gb_dai_hw_params,
+};
+
+static struct snd_soc_dai_driver gb_cpu_dai = {
+	.name                   = "gb-cpu-dai",
+	.playback = {
+		.rates          = GB_RATES,
+		.formats        = GB_FMTS,
+		.channels_min   = 2,
+		.channels_max   = 2,
+	},
+	.ops = &gb_dai_ops,
+};
+
+/******************************************************
+ * gb pcm logic
+ *****************************************************/
+static struct snd_pcm_hardware gb_plat_pcm_hardware = {
+	.info =         SNDRV_PCM_INFO_INTERLEAVED,
+	.formats                = GB_FMTS,
+	.rates                  = GB_RATES,
+	.rate_min               = 8000,
+	.rate_max               = 48000,
+	.channels_min           = 2,
+	.channels_max           = 2,
+	/* XXX - All the values below are junk */
+	.buffer_bytes_max       = 64 * 1024,
+	.period_bytes_min       = 32,
+	.period_bytes_max       = 8192,
+	.periods_min            = 1,
+	.periods_max            = 32,
+	.fifo_size              = 256,
+};
+
+static snd_pcm_uframes_t gb_pcm_pointer(struct snd_pcm_substream *substream)
+{
+	struct snd_soc_pcm_runtime *rtd = substream->private_data;
+	struct gb_snd *snd_dev;
+
+	snd_dev = snd_soc_dai_get_drvdata(rtd->cpu_dai);
+
+	return snd_dev->hwptr_done;
+}
+
+static int gb_pcm_prepare(struct snd_pcm_substream *substream)
+{
+	struct snd_soc_pcm_runtime *rtd = substream->private_data;
+	struct gb_snd *snd_dev;
+
+	snd_dev = snd_soc_dai_get_drvdata(rtd->cpu_dai);
+	snd_dev->hwptr_done = 0;
+
+	return 0;
+}
+
+static int gb_pcm_open(struct snd_pcm_substream *substream)
+{
+	struct snd_pcm_runtime *runtime = substream->runtime;
+	struct snd_soc_pcm_runtime *rtd = substream->private_data;
+	struct gb_snd *snd_dev;
+
+
+	snd_dev = snd_soc_dai_get_drvdata(rtd->cpu_dai);
+
+	snd_dev->substream = substream;
+	setup_timer(&snd_dev->timer, dummy_timer_function, (unsigned long)snd_dev);
+	runtime->private_data = snd_dev;
+
+	snd_soc_set_runtime_hwparams(substream, &gb_plat_pcm_hardware);
+	return snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
+}
+
+static int gb_pcm_close(struct snd_pcm_substream *substream)
+{
+	if (substream->runtime->private_data)
+		kfree(substream->runtime->private_data);
+	substream->runtime->private_data = NULL;
+	return 0;
+}
+
+static int gb_pcm_hw_params(struct snd_pcm_substream *substream,
+				struct snd_pcm_hw_params *hw_params)
+{
+	return snd_pcm_lib_malloc_pages(substream,
+					params_buffer_bytes(hw_params));
+}
+
+static int gb_pcm_hw_free(struct snd_pcm_substream *substream)
+{
+	return snd_pcm_lib_free_pages(substream);
+}
+
+static struct snd_pcm_ops gb_pcm_ops = {
+	.open           = gb_pcm_open,
+	.close		= gb_pcm_close,
+	.ioctl          = snd_pcm_lib_ioctl,
+	.hw_params      = gb_pcm_hw_params,
+	.hw_free        = gb_pcm_hw_free,
+	.prepare	= gb_pcm_prepare,
+	.pointer        = gb_pcm_pointer,
+};
+
+static void gb_pcm_free(struct snd_pcm *pcm)
+{
+	snd_pcm_lib_preallocate_free_for_all(pcm);
+}
+
+static int gb_pcm_new(struct snd_soc_pcm_runtime *rtd)
+{
+	struct snd_pcm *pcm = rtd->pcm;
+
+	return snd_pcm_lib_preallocate_pages_for_all(
+			pcm,
+			SNDRV_DMA_TYPE_CONTINUOUS,
+			snd_dma_continuous_data(GFP_KERNEL),
+			PREALLOC_BUFFER, PREALLOC_BUFFER_MAX);
+}
+
+static struct snd_soc_platform_driver gb_soc_platform = {
+	.ops            = &gb_pcm_ops,
+	.pcm_new        = gb_pcm_new,
+	.pcm_free       = gb_pcm_free,
+};
+
+
+/************************************************************
+ * This is the aosc simple card junk which binds the platform
+ * codec, cpu and codec-dais etc togheter, also all the
+ * nested gross platfrom driver/device junk is here.
+ ************************************************************/
+static const struct snd_soc_component_driver gb_soc_component = {
+	.name           = "gb-component",
+};
+
+static int gb_plat_probe(struct platform_device *pdev)
+{
+	struct gb_snd *snd_dev;
+	int ret;
+
+	snd_dev = (struct gb_snd *)pdev->dev.platform_data;
+	dev_set_drvdata(&pdev->dev, snd_dev);
+
+	ret = snd_soc_register_platform(&pdev->dev, &gb_soc_platform);
+	ret = snd_soc_register_component(&pdev->dev, &gb_soc_component,
+							&gb_cpu_dai, 1);
+	return ret;
+}
+
+static struct platform_driver gb_plat_driver = {
+	.driver         = {
+		.name   = "gb-pcm-audio",
+	},
+	.probe          = gb_plat_probe,
+};
+
+
+static struct asoc_simple_card_info gb_card_info = {
+	.name           = "Greybus Audio Module",
+	.card           = "gb-card",
+#if USE_RT5639
+	.codec          = "rt5639.0-001c", /* XXX this will need to be dynamic*/
+	.daifmt         = GB_FMTS,
+#else
+	.codec          = "spdif-dit", /* XXX this will need to be dynamic*/
+#endif
+	.platform       = "gb-pcm-audio.0",
+	.cpu_dai = {
+		.name   = "gb-pcm-audio.0",
+		.fmt    = GB_FMTS,
+	},
+	.codec_dai = {
+#if USE_RT5639
+		.name   = "rt5639-aif1",
+		.fmt    = SND_SOC_DAIFMT_CBM_CFM,
+		.sysclk = 11289600,
+#else
+		.name   = "dit-hifi",
+#endif
+	}
+};
+
+
+int device_count;
+
+/****************************************************************
+ * GB hooks
+ ****************************************************************/
+static int gb_i2s_transmitter_connection_init(struct gb_connection *connection)
+{
+	struct gb_snd *snd_dev;
+	int ret;
+
+	printk("JDB: gb_i2s_transmitter_connection_init!\n");
+
+	snd_dev = kzalloc(sizeof(*snd_dev), GFP_KERNEL);
+	if(!snd_dev)
+		return -ENOMEM;
+
+	snd_dev->cpu_dai = platform_device_alloc("gb-pcm-audio", device_count);
+	if (!snd_dev->cpu_dai) {
+		ret = ENOMEM;
+		goto out;
+	}
+
+	snd_dev->card = platform_device_alloc("asoc-simple-card", device_count);
+	if (!snd_dev->card) {
+		ret = ENOMEM;
+		goto out_dai;
+	}
+
+	snd_dev->connection = connection;
+
+	/* XXX there's got to be a better way to handle device counts.... */
+	device_count++;
+
+	snd_dev->card->dev.platform_data = &gb_card_info; /*XXX - prob should generate this dynamically*/
+	snd_dev->cpu_dai->dev.platform_data = snd_dev;
+	snd_dev->connection->private = snd_dev;
+
+	ret = platform_device_add(snd_dev->cpu_dai);
+	if (ret) {
+		goto out_dai;
+	}
+	ret = platform_device_add(snd_dev->card);
+	if (ret) {
+		/* XXX errrr.. figure out the right thing here... */
+		//platform_device_unregister(snd_dev->cpu_dai);
+		goto out_card;
+	}
+	return 0;
+
+out_card:
+	platform_device_put(snd_dev->card);
+out_dai:
+	platform_device_put(snd_dev->cpu_dai);
+out:
+	kfree(snd_dev);
+	return ret;
+}
+
+static void gb_i2s_transmitter_connection_exit(struct gb_connection *connection)
+{
+	struct gb_snd *snd_dev;
+
+	snd_dev = (struct gb_snd *)connection->private;
+
+	platform_device_unregister(snd_dev->card);
+	platform_device_unregister(snd_dev->cpu_dai);
+	kfree(snd_dev);
+}
+
+static struct gb_protocol gb_audio_protocol = {
+	.name			= GB_AUDIO_DRIVER_NAME,
+	.id			= GREYBUS_PROTOCOL_I2S_RECEIVER,
+	.major			= 0,
+	.minor			= 1,
+	.connection_init	= gb_i2s_transmitter_connection_init,
+	.connection_exit	= gb_i2s_transmitter_connection_exit,
+	.request_recv		= NULL,
+};
+
+
+/******************************************************************
+ * This is the basic hook to let me get things initialized
+ ******************************************************************/
+static int __init devices_setup(void)
+{
+	int err;
+	struct platform_device *device;
+
+	gb_protocol_register(&gb_audio_protocol);
+
+	err = platform_driver_register(&gb_plat_driver);
+	device = platform_device_register_simple("spdif-dit", -1, NULL, 0);
+
+	return err;
+}
+device_initcall(devices_setup);
+MODULE_LICENSE("GPL");