Commit a4749bbe authored by John Stultz's avatar John Stultz Committed by Greg Kroah-Hartman
Browse files

greybus: gb-audio: Add integrated greybus audio driver 



So here's the current greybus audio driver, which I
wanted to send out for more serious review and
consideration for merging.

I've tried to integrate much of the feedback from the
last round and most of the hotplug issues that I've found
have been resolved. I've tested this via gbsim, and the
Android ARA HAL layer seems to work with it.

Mark has also successfully played audio with this driver,
adding a few hacks to get the codec's i2c connection to
probe.

Current issues:
* Hotplug problem - When gbsim is killed, or the module
  removed, the greybus driver gets stuck since the android
  mediaserver process is holding the audio device open.
  Killing the mediaserver allows things to clean up and
  allows greybus to accept new gbsim connections. I have
  a workaround patch to the soc-core.c logic which converts
  the snd_card_free() call to snd_card_free_when_closed()
  which allows the greybus connection cleanup to finish.

Remaining todos:
* Probably need to break apart the mgmt_setup function
  to integrate better with the constraint logic. I took
  a really basic stab at this, but more is probably
  needed.
* Figure out how to properly find and tie in the
  codec's I2C bus-id to the driver.

This code requires that the kernel support the following
config options, which I've enabled in a separate kernel
patch:
	CONFIG_SND_SIMPLE_CARD
	CONFIG_SND_SOC_SPDIF
	CONFIG_SND_SOC_RT5645

I really can't calim to be the sole author of this, since
many many fixes and tweaks that have been folded in have
come from Mark Greer. His analsysis and debugging is really
what has made this dummy-framework driver evolve into an
actual audio driver. So much credit and thanks to Mark!

Signed-off-by: default avatarJohn Stultz <john.stultz@linaro.org>
Signed-off-by: default avatarMark A. Greer <mgreer@animalcreek.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@google.com>
parent 6d653370

drivers/staging/greybus/Makefile

+6 −2
Original line number Diff line number Diff line
@@ -18,7 +18,11 @@ gb-phy-y := gpb.o \ 
		hid.o	\

		i2c.o	\

		spi.o	\

		usb.o

		usb.o	\

		audio.o		\

		audio-pcm.o	\

		audio-dai.o	\

		audio-gb-cmds.o



# Prefix all modules with gb-

gb-vibrator-y := vibrator.o

drivers/staging/greybus/audio-dai.c

0 → 100644
+103 −0
Original line number Diff line number Diff line 
#include <linux/kernel.h>

#include <linux/device.h>

#include <linux/interrupt.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/workqueue.h>

#include <linux/i2c.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"

#include "gpbridge.h"

#include "audio.h"



/*

 * This is the greybus cpu dai logic. It really doesn't do much

 * other then provide the TRIGGER_START/STOP hooks that start

 * and stop the timer sending audio data in the pcm logic.

 */





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:

		gb_pcm_hrtimer_start(snd_dev);

		break;

	case SNDRV_PCM_TRIGGER_STOP:

		gb_pcm_hrtimer_stop(snd_dev);

		break;

	default:

		return -EINVAL;

	}

	return 0;

}



/*

 * XXX This is annoying, if we don't have a set_fmt function

 * the subsystem returns -ENOTSUPP, which causes applications

 * to fail, so add a dummy function here.

 */

static int gb_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)

{

	return 0;

}



static const struct snd_soc_dai_ops gb_dai_ops = {

	.trigger	= gb_dai_trigger,

	.set_fmt	= gb_dai_set_fmt,

};



struct snd_soc_dai_driver gb_cpu_dai = {

	.name			= "gb-cpu-dai",

	.playback = {

		.rates		= GB_RATES,

		.formats	= GB_FMTS,

		.channels_min	= 1,

		.channels_max	= 2,

	},

	.ops = &gb_dai_ops,

};



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_component(&pdev->dev, &gb_soc_component,

							&gb_cpu_dai, 1);

	return ret;

}



static int gb_plat_remove(struct platform_device *pdev)

{

	snd_soc_unregister_component(&pdev->dev);

	snd_soc_unregister_platform(&pdev->dev);

	return 0;

}



struct platform_driver gb_audio_plat_driver = {

	.driver		= {

		.name	= "gb-dai-audio",

	},

	.probe		= gb_plat_probe,

	.remove		= gb_plat_remove,

};

drivers/staging/greybus/audio-gb-cmds.c

0 → 100644
+207 −0
Original line number Diff line number Diff line 
#include <linux/kernel.h>

#include "greybus.h"

#include "gpbridge.h"

#include "audio.h"



#define GB_I2S_MGMT_VERSION_MAJOR		0x00

#define GB_I2S_MGMT_VERSION_MINOR		0x01



#define GB_I2S_DATA_VERSION_MAJOR		0x00

#define GB_I2S_MGMT_VERSION_MINOR		0x01



/***********************************

 * GB I2S helper functions

 ***********************************/

int gb_i2s_mgmt_get_version(struct gb_connection *connection)

{

	struct gb_protocol_version_response response;



	memset(&response, 0, sizeof(response));

	return gb_protocol_get_version(connection,

				       GB_I2S_MGMT_TYPE_PROTOCOL_VERSION,

				       NULL, 0, &response,

				       GB_I2S_MGMT_VERSION_MAJOR);

}



int gb_i2s_data_get_version(struct gb_connection *connection)

{

	struct gb_protocol_version_response response;



	memset(&response, 0, sizeof(response));

	return gb_protocol_get_version(connection,

				       GB_I2S_DATA_TYPE_PROTOCOL_VERSION,

				       NULL, 0, &response,

				       GB_I2S_DATA_VERSION_MAJOR);

}



int gb_i2s_mgmt_activate_cport(struct gb_connection *connection,

				      uint16_t cport)

{

	struct gb_i2s_mgmt_activate_cport_request request;



	memset(&request, 0, sizeof(request));

	request.cport = cport;



	return gb_operation_sync(connection, GB_I2S_MGMT_TYPE_ACTIVATE_CPORT,

				 &request, sizeof(request), NULL, 0);

}



int gb_i2s_mgmt_deactivate_cport(struct gb_connection *connection,

					uint16_t cport)

{

	struct gb_i2s_mgmt_deactivate_cport_request request;



	memset(&request, 0, sizeof(request));

	request.cport = cport;



	return gb_operation_sync(connection, GB_I2S_MGMT_TYPE_DEACTIVATE_CPORT,

				 &request, sizeof(request), NULL, 0);

}



int gb_i2s_mgmt_get_supported_configurations(

	struct gb_connection *connection,

	struct gb_i2s_mgmt_get_supported_configurations_response *get_cfg,

	size_t size)

{

	return gb_operation_sync(connection,

				 GB_I2S_MGMT_TYPE_GET_SUPPORTED_CONFIGURATIONS,

				 NULL, 0, get_cfg, size);

}



int gb_i2s_mgmt_set_configuration(struct gb_connection *connection,

			struct gb_i2s_mgmt_set_configuration_request *set_cfg)

{

	return gb_operation_sync(connection, GB_I2S_MGMT_TYPE_SET_CONFIGURATION,

				 set_cfg, sizeof(*set_cfg), NULL, 0);

}



int gb_i2s_mgmt_set_samples_per_message(

				struct gb_connection *connection,

				uint16_t samples_per_message)

{

	struct gb_i2s_mgmt_set_samples_per_message_request request;



	memset(&request, 0, sizeof(request));

	request.samples_per_message = samples_per_message;



	return gb_operation_sync(connection,

				 GB_I2S_MGMT_TYPE_SET_SAMPLES_PER_MESSAGE,

				 &request, sizeof(request), NULL, 0);

}



/*

 * XXX This is sort of a generic "setup" function which  probably needs

 * to be broken up, and tied into the constraints.

 *

 * I'm on the fence if we should just dictate that we only support

 * 48k, 16bit, 2 channel, and avoid doign the whole probe for configurations

 * and then picking one.

 */

int gb_i2s_mgmt_setup(struct gb_connection *connection)

{

	struct gb_i2s_mgmt_get_supported_configurations_response *get_cfg;

	struct gb_i2s_mgmt_set_configuration_request set_cfg;

	struct gb_i2s_mgmt_configuration *cfg;

	size_t size;

	int i, ret;



	size = sizeof(*get_cfg) +

	       (CONFIG_COUNT_MAX * sizeof(get_cfg->config[0]));



	get_cfg = kzalloc(size, GFP_KERNEL);

	if (!get_cfg)

		return -ENOMEM;



	ret = gb_i2s_mgmt_get_supported_configurations(connection, get_cfg,

						       size);

	if (ret) {

		pr_err("get_supported_config failed: %d\n", ret);

		goto free_get_cfg;

	}



	/* Pick 48KHz 16-bits/channel */

	for (i = 0, cfg = get_cfg->config; i < CONFIG_COUNT_MAX; i++, cfg++) {

		if ((cfg->sample_frequency == GB_SAMPLE_RATE) &&

		    (cfg->num_channels == 2) &&

		    (cfg->bytes_per_channel == 2) &&

		    (cfg->byte_order & GB_I2S_MGMT_BYTE_ORDER_LE) &&

		    (cfg->spatial_locations ==

			(GB_I2S_MGMT_SPATIAL_LOCATION_FL |

			 GB_I2S_MGMT_SPATIAL_LOCATION_FR)) &&

		    (cfg->ll_protocol & GB_I2S_MGMT_PROTOCOL_I2S) &&

		    (cfg->ll_mclk_role & GB_I2S_MGMT_ROLE_MASTER) &&

		    (cfg->ll_bclk_role & GB_I2S_MGMT_ROLE_MASTER) &&

		    (cfg->ll_wclk_role & GB_I2S_MGMT_ROLE_MASTER) &&

		    (cfg->ll_wclk_polarity & GB_I2S_MGMT_POLARITY_NORMAL) &&

		    (cfg->ll_wclk_change_edge & GB_I2S_MGMT_EDGE_FALLING) &&

		    (cfg->ll_wclk_tx_edge & GB_I2S_MGMT_EDGE_FALLING) &&

		    (cfg->ll_wclk_rx_edge & GB_I2S_MGMT_EDGE_RISING) &&

		    (cfg->ll_data_offset == 1))

			break;

	}



	if (i >= CONFIG_COUNT_MAX) {

		pr_err("No valid configuration\n");

		ret = -EINVAL;

		goto free_get_cfg;

	}



	memcpy(&set_cfg, cfg, sizeof(set_cfg));

	set_cfg.config.byte_order = GB_I2S_MGMT_BYTE_ORDER_LE;

	set_cfg.config.ll_protocol = GB_I2S_MGMT_PROTOCOL_I2S;

	set_cfg.config.ll_mclk_role = GB_I2S_MGMT_ROLE_MASTER;

	set_cfg.config.ll_bclk_role = GB_I2S_MGMT_ROLE_MASTER;

	set_cfg.config.ll_wclk_role = GB_I2S_MGMT_ROLE_MASTER;

	set_cfg.config.ll_wclk_polarity = GB_I2S_MGMT_POLARITY_NORMAL;

	set_cfg.config.ll_wclk_change_edge = GB_I2S_MGMT_EDGE_RISING;

	set_cfg.config.ll_wclk_tx_edge = GB_I2S_MGMT_EDGE_FALLING;

	set_cfg.config.ll_wclk_rx_edge = GB_I2S_MGMT_EDGE_RISING;



	ret = gb_i2s_mgmt_set_configuration(connection, &set_cfg);

	if (ret) {

		pr_err("set_configuration failed: %d\n", ret);

		goto free_get_cfg;

	}



	ret = gb_i2s_mgmt_set_samples_per_message(connection,

						  CONFIG_SAMPLES_PER_MSG);

	if (ret) {

		pr_err("set_samples_per_msg failed: %d\n", ret);

		goto free_get_cfg;

	}



	/* XXX Add start delay here (probably 1ms) */

	ret = gb_i2s_mgmt_activate_cport(connection,

					 CONFIG_I2S_REMOTE_DATA_CPORT);

	if (ret) {

		pr_err("activate_cport failed: %d\n", ret);

		goto free_get_cfg;

	}



free_get_cfg:

	kfree(get_cfg);

	return ret;

}



int gb_i2s_send_data(struct gb_connection *connection,

					void *req_buf, void *source_addr,

					size_t len, int sample_num)

{

	struct gb_i2s_send_data_request *gb_req;

	int ret;



	gb_req = req_buf;

	gb_req->sample_number = sample_num;



	memcpy((void *)&gb_req->data[0], source_addr, len);



	if (len < MAX_SEND_DATA_LEN)

		for (; len < MAX_SEND_DATA_LEN; len++)

			gb_req->data[len] = gb_req->data[len - SAMPLE_SIZE];



	gb_req->size = len;



	ret = gb_operation_sync(connection, GB_I2S_DATA_TYPE_SEND_DATA,

				(void *) gb_req, SEND_DATA_BUF_LEN, NULL, 0);

	return ret;

}

drivers/staging/greybus/audio-pcm.c

0 → 100644
+262 −0
Original line number Diff line number Diff line 
#include <linux/kernel.h>

#include <linux/device.h>

#include <linux/interrupt.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/workqueue.h>

#include <linux/i2c.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"

#include "gpbridge.h"

#include "audio.h"



/*

 * timer/workqueue logic for pushing pcm data.

 *

 * Since when we are playing audio, we don't get any

 * status or feedback from the codec, we have to use a

 * hrtimer to trigger sending data to the remote codec.

 * However since the hrtimer runs in irq context, so we

 * have to schedule a workqueue to actually send the

 * greybus data.

 */



static void gb_pcm_work(struct work_struct *work)

{

	struct gb_snd *snd_dev = container_of(work, struct gb_snd, work);

	struct snd_pcm_substream *substream = snd_dev->substream;

	struct snd_pcm_runtime *runtime = substream->runtime;

	unsigned int stride, frames, oldptr;

	int period_elapsed;

	char *address;

	long len;



	if (!snd_dev)

		return;



	if (!atomic_read(&snd_dev->running))

		return;



	address = runtime->dma_area + snd_dev->hwptr_done;



	len = frames_to_bytes(runtime,

			      runtime->buffer_size) - snd_dev->hwptr_done;

	len = min(len, MAX_SEND_DATA_LEN);

	gb_i2s_send_data(snd_dev->i2s_tx_connection, snd_dev->send_data_req_buf,

				address, len, snd_dev->send_data_sample_count);



	snd_dev->send_data_sample_count += CONFIG_SAMPLES_PER_MSG;



	stride = runtime->frame_bits >> 3;

	frames = len/stride;



	snd_pcm_stream_lock(substream);

	oldptr = snd_dev->hwptr_done;

	snd_dev->hwptr_done += len;

	if (snd_dev->hwptr_done >= runtime->buffer_size * stride)

		snd_dev->hwptr_done -= runtime->buffer_size * stride;



	frames = (len + (oldptr % stride)) / stride;



	snd_dev->transfer_done += frames;

	if (snd_dev->transfer_done >= runtime->period_size) {

		snd_dev->transfer_done -= runtime->period_size;

		period_elapsed = 1;

	}



	snd_pcm_stream_unlock(substream);

	if (period_elapsed)

		snd_pcm_period_elapsed(snd_dev->substream);

}



static enum hrtimer_restart gb_pcm_timer_function(struct hrtimer *hrtimer)

{

	struct gb_snd *snd_dev = container_of(hrtimer, struct gb_snd, timer);



	if (!atomic_read(&snd_dev->running))

		return HRTIMER_NORESTART;

	queue_work(snd_dev->workqueue, &snd_dev->work);

	hrtimer_forward_now(hrtimer, ns_to_ktime(CONFIG_PERIOD_NS));

	return HRTIMER_RESTART;

}



void gb_pcm_hrtimer_start(struct gb_snd *snd_dev)

{

	atomic_set(&snd_dev->running, 1);

	hrtimer_start(&snd_dev->timer, ns_to_ktime(CONFIG_PERIOD_NS),

						HRTIMER_MODE_REL);

}



void gb_pcm_hrtimer_stop(struct gb_snd *snd_dev)

{

	atomic_set(&snd_dev->running, 0);

	hrtimer_cancel(&snd_dev->timer);

}



static int gb_pcm_hrtimer_init(struct gb_snd *snd_dev)

{

	hrtimer_init(&snd_dev->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

	snd_dev->timer.function = gb_pcm_timer_function;

	atomic_set(&snd_dev->running, 0);

	snd_dev->workqueue = alloc_workqueue("gb-audio", WQ_HIGHPRI, 0);

	if (!snd_dev->workqueue)

		return -ENOMEM;

	INIT_WORK(&snd_dev->work, gb_pcm_work);

	return 0;

}





/*

 * Core gb pcm structure

 */

static struct snd_pcm_hardware gb_plat_pcm_hardware = {

	.info			= SNDRV_PCM_INFO_INTERLEAVED |

				  SNDRV_PCM_INFO_MMAP        |

				  SNDRV_PCM_INFO_MMAP_VALID,

	.formats		= GB_FMTS,

	.rates			= GB_RATES,

	.rate_min		= 8000,

	.rate_max		= GB_SAMPLE_RATE,

	.channels_min		= 1,

	.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		= 2,

	.periods_max		= 32,

};



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  / (substream->runtime->frame_bits >> 3);

}



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;

	snd_dev->transfer_done = 0;

	return 0;

}



static unsigned int rates[] = {GB_SAMPLE_RATE};

static struct snd_pcm_hw_constraint_list constraints_rates = {

	.count = ARRAY_SIZE(rates),

	.list = rates,

	.mask = 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;

	unsigned long flags;

	int ret;



	snd_dev = snd_soc_dai_get_drvdata(rtd->cpu_dai);



	spin_lock_irqsave(&snd_dev->lock, flags);

	runtime->private_data = snd_dev;

	snd_dev->substream = substream;

	ret = gb_pcm_hrtimer_init(snd_dev);

	spin_unlock_irqrestore(&snd_dev->lock, flags);



	if (ret)

		return ret;



	snd_soc_set_runtime_hwparams(substream, &gb_plat_pcm_hardware);



	ret = snd_pcm_hw_constraint_list(substream->runtime, 0,

					SNDRV_PCM_HW_PARAM_RATE,

					&constraints_rates);

	if (ret < 0)

		return ret;



	return snd_pcm_hw_constraint_integer(runtime,

					     SNDRV_PCM_HW_PARAM_PERIODS);

}



static int gb_pcm_close(struct snd_pcm_substream *substream)

{

	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);

}



struct snd_soc_platform_driver gb_soc_platform = {

	.ops		= &gb_pcm_ops,

	.pcm_new	= gb_pcm_new,

	.pcm_free	= gb_pcm_free,

};



static int gb_soc_platform_probe(struct platform_device *pdev)

{

	return snd_soc_register_platform(&pdev->dev, &gb_soc_platform);

}



static int gb_soc_platform_remove(struct platform_device *pdev)

{

	snd_soc_unregister_platform(&pdev->dev);

	return 0;

}



struct platform_driver gb_audio_pcm_driver = {

	.driver = {

			.name = "gb-pcm-audio",

			.owner = THIS_MODULE,

	},

	.probe = gb_soc_platform_probe,

	.remove = gb_soc_platform_remove,

};

drivers/staging/greybus/audio.c

0 → 100644
+432 −0

File added.

Preview size limit exceeded, changes collapsed.