Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5a0fbc6d authored by Mark Brown's avatar Mark Brown
Browse files

Merge branch 'topic/adsp' of... 

Merge branch 'topic/adsp' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/sound into asoc-wm2200
parents 8858086f 2159ad93

sound/soc/codecs/Kconfig

+5 −0
Original line number Diff line number Diff line
@@ -146,6 +146,11 @@ config SND_SOC_WM_HUBS 
	default y if SND_SOC_WM8993=y || SND_SOC_WM8994=y

	default m if SND_SOC_WM8993=m || SND_SOC_WM8994=m



config SND_SOC_WM_ADSP

	tristate

	default y if SND_SOC_WM2200=y

	default m if SND_SOC_WM2200=m



config SND_SOC_AB8500_CODEC

	tristate

sound/soc/codecs/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -62,6 +62,7 @@ snd-soc-twl6040-objs := twl6040.o 
snd-soc-uda134x-objs := uda134x.o

snd-soc-uda1380-objs := uda1380.o

snd-soc-wl1273-objs := wl1273.o

snd-soc-wm-adsp-objs := wm_adsp.o

snd-soc-wm0010-objs := wm0010.o

snd-soc-wm1250-ev1-objs := wm1250-ev1.o

snd-soc-wm2000-objs := wm2000.o
@@ -229,6 +230,7 @@ obj-$(CONFIG_SND_SOC_WM9090) += snd-soc-wm9090.o 
obj-$(CONFIG_SND_SOC_WM9705)	+= snd-soc-wm9705.o

obj-$(CONFIG_SND_SOC_WM9712)	+= snd-soc-wm9712.o

obj-$(CONFIG_SND_SOC_WM9713)	+= snd-soc-wm9713.o

obj-$(CONFIG_SND_SOC_WM_ADSP)	+= snd-soc-wm-adsp.o

obj-$(CONFIG_SND_SOC_WM_HUBS)	+= snd-soc-wm-hubs.o



# Amp

sound/soc/codecs/wm_adsp.c

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

 * wm_adsp.c  --  Wolfson ADSP support

 *

 * Copyright 2012 Wolfson Microelectronics plc

 *

 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>

 *

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

 */



#include <linux/module.h>

#include <linux/moduleparam.h>

#include <linux/init.h>

#include <linux/delay.h>

#include <linux/firmware.h>

#include <linux/pm.h>

#include <linux/pm_runtime.h>

#include <linux/regmap.h>

#include <linux/slab.h>

#include <sound/core.h>

#include <sound/pcm.h>

#include <sound/pcm_params.h>

#include <sound/soc.h>

#include <sound/jack.h>

#include <sound/initval.h>

#include <sound/tlv.h>



#include <linux/mfd/arizona/registers.h>



#include "wm_adsp.h"



#define adsp_crit(_dsp, fmt, ...) \

	dev_crit(_dsp->dev, "DSP%d: " fmt, _dsp->num, ##__VA_ARGS__)

#define adsp_err(_dsp, fmt, ...) \

	dev_err(_dsp->dev, "DSP%d: " fmt, _dsp->num, ##__VA_ARGS__)

#define adsp_warn(_dsp, fmt, ...) \

	dev_warn(_dsp->dev, "DSP%d: " fmt, _dsp->num, ##__VA_ARGS__)

#define adsp_info(_dsp, fmt, ...) \

	dev_info(_dsp->dev, "DSP%d: " fmt, _dsp->num, ##__VA_ARGS__)

#define adsp_dbg(_dsp, fmt, ...) \

	dev_dbg(_dsp->dev, "DSP%d: " fmt, _dsp->num, ##__VA_ARGS__)



#define ADSP1_CONTROL_1                   0x00

#define ADSP1_CONTROL_2                   0x02

#define ADSP1_CONTROL_3                   0x03

#define ADSP1_CONTROL_4                   0x04

#define ADSP1_CONTROL_5                   0x06

#define ADSP1_CONTROL_6                   0x07

#define ADSP1_CONTROL_7                   0x08

#define ADSP1_CONTROL_8                   0x09

#define ADSP1_CONTROL_9                   0x0A

#define ADSP1_CONTROL_10                  0x0B

#define ADSP1_CONTROL_11                  0x0C

#define ADSP1_CONTROL_12                  0x0D

#define ADSP1_CONTROL_13                  0x0F

#define ADSP1_CONTROL_14                  0x10

#define ADSP1_CONTROL_15                  0x11

#define ADSP1_CONTROL_16                  0x12

#define ADSP1_CONTROL_17                  0x13

#define ADSP1_CONTROL_18                  0x14

#define ADSP1_CONTROL_19                  0x16

#define ADSP1_CONTROL_20                  0x17

#define ADSP1_CONTROL_21                  0x18

#define ADSP1_CONTROL_22                  0x1A

#define ADSP1_CONTROL_23                  0x1B

#define ADSP1_CONTROL_24                  0x1C

#define ADSP1_CONTROL_25                  0x1E

#define ADSP1_CONTROL_26                  0x20

#define ADSP1_CONTROL_27                  0x21

#define ADSP1_CONTROL_28                  0x22

#define ADSP1_CONTROL_29                  0x23

#define ADSP1_CONTROL_30                  0x24

#define ADSP1_CONTROL_31                  0x26



/*

 * ADSP1 Control 19

 */

#define ADSP1_WDMA_BUFFER_LENGTH_MASK     0x00FF  /* DSP1_WDMA_BUFFER_LENGTH - [7:0] */

#define ADSP1_WDMA_BUFFER_LENGTH_SHIFT         0  /* DSP1_WDMA_BUFFER_LENGTH - [7:0] */

#define ADSP1_WDMA_BUFFER_LENGTH_WIDTH         8  /* DSP1_WDMA_BUFFER_LENGTH - [7:0] */





/*

 * ADSP1 Control 30

 */

#define ADSP1_DBG_CLK_ENA                 0x0008  /* DSP1_DBG_CLK_ENA */

#define ADSP1_DBG_CLK_ENA_MASK            0x0008  /* DSP1_DBG_CLK_ENA */

#define ADSP1_DBG_CLK_ENA_SHIFT                3  /* DSP1_DBG_CLK_ENA */

#define ADSP1_DBG_CLK_ENA_WIDTH                1  /* DSP1_DBG_CLK_ENA */

#define ADSP1_SYS_ENA                     0x0004  /* DSP1_SYS_ENA */

#define ADSP1_SYS_ENA_MASK                0x0004  /* DSP1_SYS_ENA */

#define ADSP1_SYS_ENA_SHIFT                    2  /* DSP1_SYS_ENA */

#define ADSP1_SYS_ENA_WIDTH                    1  /* DSP1_SYS_ENA */

#define ADSP1_CORE_ENA                    0x0002  /* DSP1_CORE_ENA */

#define ADSP1_CORE_ENA_MASK               0x0002  /* DSP1_CORE_ENA */

#define ADSP1_CORE_ENA_SHIFT                   1  /* DSP1_CORE_ENA */

#define ADSP1_CORE_ENA_WIDTH                   1  /* DSP1_CORE_ENA */

#define ADSP1_START                       0x0001  /* DSP1_START */

#define ADSP1_START_MASK                  0x0001  /* DSP1_START */

#define ADSP1_START_SHIFT                      0  /* DSP1_START */

#define ADSP1_START_WIDTH                      1  /* DSP1_START */



#define ADSP2_CONTROL 0

#define ADSP2_STATUS1 4



/*

 * ADSP2 Control

 */



#define ADSP2_MEM_ENA                     0x0010  /* DSP1_MEM_ENA */

#define ADSP2_MEM_ENA_MASK                0x0010  /* DSP1_MEM_ENA */

#define ADSP2_MEM_ENA_SHIFT                    4  /* DSP1_MEM_ENA */

#define ADSP2_MEM_ENA_WIDTH                    1  /* DSP1_MEM_ENA */

#define ADSP2_SYS_ENA                     0x0004  /* DSP1_SYS_ENA */

#define ADSP2_SYS_ENA_MASK                0x0004  /* DSP1_SYS_ENA */

#define ADSP2_SYS_ENA_SHIFT                    2  /* DSP1_SYS_ENA */

#define ADSP2_SYS_ENA_WIDTH                    1  /* DSP1_SYS_ENA */

#define ADSP2_CORE_ENA                    0x0002  /* DSP1_CORE_ENA */

#define ADSP2_CORE_ENA_MASK               0x0002  /* DSP1_CORE_ENA */

#define ADSP2_CORE_ENA_SHIFT                   1  /* DSP1_CORE_ENA */

#define ADSP2_CORE_ENA_WIDTH                   1  /* DSP1_CORE_ENA */

#define ADSP2_START                       0x0001  /* DSP1_START */

#define ADSP2_START_MASK                  0x0001  /* DSP1_START */

#define ADSP2_START_SHIFT                      0  /* DSP1_START */

#define ADSP2_START_WIDTH                      1  /* DSP1_START */



/*

 * ADSP2 Status 1

 */

#define ADSP2_RAM_RDY                     0x0001

#define ADSP2_RAM_RDY_MASK                0x0001

#define ADSP2_RAM_RDY_SHIFT                    0

#define ADSP2_RAM_RDY_WIDTH                    1





static struct wm_adsp_region const *wm_adsp_find_region(struct wm_adsp *dsp,

							int type)

{

	int i;



	for (i = 0; i < dsp->num_mems; i++)

		if (dsp->mem[i].type == type)

			return &dsp->mem[i];



	return NULL;

}



static int wm_adsp_load(struct wm_adsp *dsp)

{

	const struct firmware *firmware;

	struct regmap *regmap = dsp->regmap;

	unsigned int pos = 0;

	const struct wmfw_header *header;

	const struct wmfw_adsp1_sizes *adsp1_sizes;

	const struct wmfw_adsp2_sizes *adsp2_sizes;

	const struct wmfw_footer *footer;

	const struct wmfw_region *region;

	const struct wm_adsp_region *mem;

	const char *region_name;

	char *file, *text;

	unsigned int reg;

	int regions = 0;

	int ret, offset, type, sizes;



	file = kzalloc(PAGE_SIZE, GFP_KERNEL);

	if (file == NULL)

		return -ENOMEM;



	snprintf(file, PAGE_SIZE, "%s-dsp%d.wmfw", dsp->part, dsp->num);

	file[PAGE_SIZE - 1] = '\0';



	ret = request_firmware(&firmware, file, dsp->dev);

	if (ret != 0) {

		adsp_err(dsp, "Failed to request '%s'\n", file);

		goto out;

	}

	ret = -EINVAL;



	pos = sizeof(*header) + sizeof(*adsp1_sizes) + sizeof(*footer);

	if (pos >= firmware->size) {

		adsp_err(dsp, "%s: file too short, %zu bytes\n",

			 file, firmware->size);

		goto out_fw;

	}



	header = (void*)&firmware->data[0];



	if (memcmp(&header->magic[0], "WMFW", 4) != 0) {

		adsp_err(dsp, "%s: invalid magic\n", file);

		goto out_fw;

	}



	if (header->ver != 0) {

		adsp_err(dsp, "%s: unknown file format %d\n",

			 file, header->ver);

		goto out_fw;

	}



	if (header->core != dsp->type) {

		adsp_err(dsp, "%s: invalid core %d != %d\n",

			 file, header->core, dsp->type);

		goto out_fw;

	}



	switch (dsp->type) {

	case WMFW_ADSP1:

		pos = sizeof(*header) + sizeof(*adsp1_sizes) + sizeof(*footer);

		adsp1_sizes = (void *)&(header[1]);

		footer = (void *)&(adsp1_sizes[1]);

		sizes = sizeof(*adsp1_sizes);



		adsp_dbg(dsp, "%s: %d DM, %d PM, %d ZM\n",

			 file, le32_to_cpu(adsp1_sizes->dm),

			 le32_to_cpu(adsp1_sizes->pm),

			 le32_to_cpu(adsp1_sizes->zm));

		break;



	case WMFW_ADSP2:

		pos = sizeof(*header) + sizeof(*adsp2_sizes) + sizeof(*footer);

		adsp2_sizes = (void *)&(header[1]);

		footer = (void *)&(adsp2_sizes[1]);

		sizes = sizeof(*adsp2_sizes);



		adsp_dbg(dsp, "%s: %d XM, %d YM %d PM, %d ZM\n",

			 file, le32_to_cpu(adsp2_sizes->xm),

			 le32_to_cpu(adsp2_sizes->ym),

			 le32_to_cpu(adsp2_sizes->pm),

			 le32_to_cpu(adsp2_sizes->zm));

		break;



	default:

		BUG_ON(NULL == "Unknown DSP type");

		goto out_fw;

	}



	if (le32_to_cpu(header->len) != sizeof(*header) +

	    sizes + sizeof(*footer)) {

		adsp_err(dsp, "%s: unexpected header length %d\n",

			 file, le32_to_cpu(header->len));

		goto out_fw;

	}



	adsp_dbg(dsp, "%s: timestamp %llu\n", file,

		 le64_to_cpu(footer->timestamp));



	while (pos < firmware->size &&

	       pos - firmware->size > sizeof(*region)) {

		region = (void *)&(firmware->data[pos]);

		region_name = "Unknown";

		reg = 0;

		text = NULL;

		offset = le32_to_cpu(region->offset) & 0xffffff;

		type = be32_to_cpu(region->type) & 0xff;

		mem = wm_adsp_find_region(dsp, type);

		

		switch (type) {

		case WMFW_NAME_TEXT:

			region_name = "Firmware name";

			text = kzalloc(le32_to_cpu(region->len) + 1,

				       GFP_KERNEL);

			break;

		case WMFW_INFO_TEXT:

			region_name = "Information";

			text = kzalloc(le32_to_cpu(region->len) + 1,

				       GFP_KERNEL);

			break;

		case WMFW_ABSOLUTE:

			region_name = "Absolute";

			reg = offset;

			break;

		case WMFW_ADSP1_PM:

			BUG_ON(!mem);

			region_name = "PM";

			reg = mem->base + (offset * 3);

			break;

		case WMFW_ADSP1_DM:

			BUG_ON(!mem);

			region_name = "DM";

			reg = mem->base + (offset * 2);

			break;

		case WMFW_ADSP2_XM:

			BUG_ON(!mem);

			region_name = "XM";

			reg = mem->base + (offset * 2);

			break;

		case WMFW_ADSP2_YM:

			BUG_ON(!mem);

			region_name = "YM";

			reg = mem->base + (offset * 2);

			break;

		case WMFW_ADSP1_ZM:

			BUG_ON(!mem);

			region_name = "ZM";

			reg = mem->base + (offset * 2);

			break;

		default:

			adsp_warn(dsp,

				  "%s.%d: Unknown region type %x at %d(%x)\n",

				  file, regions, type, pos, pos);

			break;

		}



		adsp_dbg(dsp, "%s.%d: %d bytes at %d in %s\n", file,

			 regions, le32_to_cpu(region->len), offset,

			 region_name);



		if (text) {

			memcpy(text, region->data, le32_to_cpu(region->len));

			adsp_info(dsp, "%s: %s\n", file, text);

			kfree(text);

		}



		if (reg) {

			ret = regmap_raw_write(regmap, reg, region->data,

					       le32_to_cpu(region->len));

			if (ret != 0) {

				adsp_err(dsp,

					"%s.%d: Failed to write %d bytes at %d in %s: %d\n",

					file, regions,

					le32_to_cpu(region->len), offset,

					region_name, ret);

				goto out_fw;

			}

		}



		pos += le32_to_cpu(region->len) + sizeof(*region);

		regions++;

	}

	

	if (pos > firmware->size)

		adsp_warn(dsp, "%s.%d: %zu bytes at end of file\n",

			  file, regions, pos - firmware->size);



out_fw:

	release_firmware(firmware);

out:

	kfree(file);



	return ret;

}



static int wm_adsp_load_coeff(struct wm_adsp *dsp)

{

	struct regmap *regmap = dsp->regmap;

	struct wmfw_coeff_hdr *hdr;

	struct wmfw_coeff_item *blk;

	const struct firmware *firmware;

	const char *region_name;

	int ret, pos, blocks, type, offset, reg;

	char *file;



	file = kzalloc(PAGE_SIZE, GFP_KERNEL);

	if (file == NULL)

		return -ENOMEM;



	snprintf(file, PAGE_SIZE, "%s-dsp%d.bin", dsp->part, dsp->num);

	file[PAGE_SIZE - 1] = '\0';



	ret = request_firmware(&firmware, file, dsp->dev);

	if (ret != 0) {

		adsp_warn(dsp, "Failed to request '%s'\n", file);

		ret = 0;

		goto out;

	}

	ret = -EINVAL;



	if (sizeof(*hdr) >= firmware->size) {

		adsp_err(dsp, "%s: file too short, %zu bytes\n",

			file, firmware->size);

		goto out_fw;

	}



	hdr = (void*)&firmware->data[0];

	if (memcmp(hdr->magic, "WMDR", 4) != 0) {

		adsp_err(dsp, "%s: invalid magic\n", file);

		return -EINVAL;

	}



	adsp_dbg(dsp, "%s: v%d.%d.%d\n", file,

		(le32_to_cpu(hdr->ver) >> 16) & 0xff,

		(le32_to_cpu(hdr->ver) >>  8) & 0xff,

		le32_to_cpu(hdr->ver) & 0xff);



	pos = le32_to_cpu(hdr->len);



	blocks = 0;

	while (pos < firmware->size &&

	       pos - firmware->size > sizeof(*blk)) {

		blk = (void*)(&firmware->data[pos]);



		type = be32_to_cpu(blk->type) & 0xff;

		offset = le32_to_cpu(blk->offset) & 0xffffff;



		adsp_dbg(dsp, "%s.%d: %x v%d.%d.%d\n",

			 file, blocks, le32_to_cpu(blk->id),

			 (le32_to_cpu(blk->ver) >> 16) & 0xff,

			 (le32_to_cpu(blk->ver) >>  8) & 0xff,

			 le32_to_cpu(blk->ver) & 0xff);

		adsp_dbg(dsp, "%s.%d: %d bytes at 0x%x in %x\n",

			 file, blocks, le32_to_cpu(blk->len), offset, type);



		reg = 0;

		region_name = "Unknown";

		switch (type) {

		case WMFW_NAME_TEXT:

		case WMFW_INFO_TEXT:

			break;

		case WMFW_ABSOLUTE:

			region_name = "register";

			reg = offset;

			break;

		default:

			adsp_err(dsp, "Unknown region type %x\n", type);

			break;

		}



		if (reg) {

			ret = regmap_raw_write(regmap, reg, blk->data,

					       le32_to_cpu(blk->len));

			if (ret != 0) {

				adsp_err(dsp,

					"%s.%d: Failed to write to %x in %s\n",

					file, blocks, reg, region_name);

			}

		}



		pos += le32_to_cpu(blk->len) + sizeof(*blk);

		blocks++;

	}



	if (pos > firmware->size)

		adsp_warn(dsp, "%s.%d: %zu bytes at end of file\n",

			  file, blocks, pos - firmware->size);



out_fw:

	release_firmware(firmware);

out:

	kfree(file);

	return 0;

}



int wm_adsp1_event(struct snd_soc_dapm_widget *w,

		   struct snd_kcontrol *kcontrol,

		   int event)

{

	struct snd_soc_codec *codec = w->codec;

	struct wm_adsp *dsps = snd_soc_codec_get_drvdata(codec);

	struct wm_adsp *dsp = &dsps[w->shift];

	int ret;



	switch (event) {

	case SND_SOC_DAPM_POST_PMU:

		regmap_update_bits(dsp->regmap, dsp->base + ADSP1_CONTROL_30,

				   ADSP1_SYS_ENA, ADSP1_SYS_ENA);



		ret = wm_adsp_load(dsp);

		if (ret != 0)

			goto err;



		ret = wm_adsp_load_coeff(dsp);

		if (ret != 0)

			goto err;



		/* Start the core running */

		regmap_update_bits(dsp->regmap, dsp->base + ADSP1_CONTROL_30,

				   ADSP1_CORE_ENA | ADSP1_START,

				   ADSP1_CORE_ENA | ADSP1_START);

		break;



	case SND_SOC_DAPM_PRE_PMD:

		/* Halt the core */

		regmap_update_bits(dsp->regmap, dsp->base + ADSP1_CONTROL_30,

				   ADSP1_CORE_ENA | ADSP1_START, 0);



		regmap_update_bits(dsp->regmap, dsp->base + ADSP1_CONTROL_19,

				   ADSP1_WDMA_BUFFER_LENGTH_MASK, 0);



		regmap_update_bits(dsp->regmap, dsp->base + ADSP1_CONTROL_30,

				   ADSP1_SYS_ENA, 0);

		break;



	default:

		break;

	}



	return 0;



err:

	regmap_update_bits(dsp->regmap, dsp->base + ADSP1_CONTROL_30,

			   ADSP1_SYS_ENA, 0);

	return ret;

}

EXPORT_SYMBOL_GPL(wm_adsp1_event);



static int wm_adsp2_ena(struct wm_adsp *dsp)

{

	unsigned int val;

	int ret, count;



	ret = regmap_update_bits(dsp->regmap, dsp->base + ADSP2_CONTROL,

				 ADSP2_SYS_ENA, ADSP2_SYS_ENA);

	if (ret != 0)

		return ret;



	/* Wait for the RAM to start, should be near instantaneous */

	count = 0;

	do {

		ret = regmap_read(dsp->regmap, dsp->base + ADSP2_STATUS1,

				  &val);

		if (ret != 0)

			return ret;

	} while (!(val & ADSP2_RAM_RDY) && ++count < 10);



	if (!(val & ADSP2_RAM_RDY)) {

		adsp_err(dsp, "Failed to start DSP RAM\n");

		return -EBUSY;

	}



	adsp_dbg(dsp, "RAM ready after %d polls\n", count);

	adsp_info(dsp, "RAM ready after %d polls\n", count);



	return 0;

}



int wm_adsp2_event(struct snd_soc_dapm_widget *w,

		   struct snd_kcontrol *kcontrol, int event)

{

	struct snd_soc_codec *codec = w->codec;

	struct wm_adsp *dsps = snd_soc_codec_get_drvdata(codec);

	struct wm_adsp *dsp = &dsps[w->shift];

	int ret;



	switch (event) {

	case SND_SOC_DAPM_POST_PMU:

		ret = wm_adsp2_ena(dsp);

		if (ret != 0)

			return ret;



		ret = wm_adsp_load(dsp);

		if (ret != 0)

			goto err;



		ret = wm_adsp_load_coeff(dsp);

		if (ret != 0)

			goto err;



		ret = regmap_update_bits(dsp->regmap,

					 dsp->base + ADSP2_CONTROL,

					 ADSP2_SYS_ENA | ADSP2_START, 0);

		if (ret != 0)

			goto err;

		break;



	case SND_SOC_DAPM_PRE_PMD:

		regmap_update_bits(dsp->regmap, dsp->base + ADSP2_CONTROL,

				   ADSP2_SYS_ENA | ADSP2_START, 0);

		break;



	default:

		break;

	}



	return 0;

err:

	regmap_update_bits(dsp->regmap, dsp->base + ADSP2_CONTROL,

			   ADSP2_SYS_ENA | ADSP2_START, 0);

	return ret;

}

EXPORT_SYMBOL_GPL(wm_adsp2_event);

sound/soc/codecs/wm_adsp.h

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

 * wm_adsp.h  --  Wolfson ADSP support

 *

 * Copyright 2012 Wolfson Microelectronics plc

 *

 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>

 *

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

 */



#ifndef __WM_ADSP_H

#define __WM_ADSP_H



#include <sound/soc.h>

#include <sound/soc-dapm.h>



#include "wmfw.h"



struct wm_adsp_region {

	int type;

	unsigned int base;

};



struct wm_adsp {

	const char *part;

	int num;

	int type;

	struct device *dev;

	struct regmap *regmap;



	int base;



	const struct wm_adsp_region *mem;

	int num_mems;

};



#define WM_ADSP1(wname, num) \

	{ .id = snd_soc_dapm_pga, .name = wname, .reg = SND_SOC_NOPM, \

	.shift = num, .event = wm_adsp1_event, \

	.event_flags = SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD }



#define WM_ADSP2(wname, num) \

{	.id = snd_soc_dapm_pga, .name = wname, .reg = SND_SOC_NOPM, \

	.shift = num, .event = wm_adsp2_event, \

	.event_flags = SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD }



int wm_adsp1_event(struct snd_soc_dapm_widget *w,

		   struct snd_kcontrol *kcontrol, int event);

int wm_adsp2_event(struct snd_soc_dapm_widget *w,

		   struct snd_kcontrol *kcontrol, int event);



#endif

sound/soc/codecs/wmfw.h

+29 −0
Original line number Diff line number Diff line
@@ -34,6 +34,13 @@ struct wmfw_adsp1_sizes { 
	__le32 zm;

} __packed;



struct wmfw_adsp2_sizes {

	__le32 xm;

	__le32 ym;

	__le32 pm;

	__le32 zm;

} __packed;



struct wmfw_region {

	union {

		__be32 type;
@@ -57,6 +64,14 @@ struct wmfw_adsp1_id_hdr { 
	__be32 algs;

} __packed;



struct wmfw_adsp2_id_hdr {

	struct wmfw_id_hdr fw;

	__be32 zm;

	__be32 xm;

	__be32 ym;

	__be32 algs;

} __packed;



struct wmfw_alg_hdr {

	__be32 id;

	__be32 ver;
@@ -68,6 +83,13 @@ struct wmfw_adsp1_alg_hdr { 
	__be32 dm;

} __packed;



struct wmfw_adsp2_alg_hdr {

	struct wmfw_alg_hdr alg;

	__be32 zm;

	__be32 xm;

	__be32 ym;

} __packed;



struct wmfw_coeff_hdr {

	u8 magic[4];

	__le32 len;
@@ -86,7 +108,9 @@ struct wmfw_coeff_item { 
	__le32 len;

	u8 data[];

} __packed;



#define WMFW_ADSP1 1

#define WMFW_ADSP2 2



#define WMFW_ABSOLUTE  0xf0

#define WMFW_NAME_TEXT 0xfe
@@ -96,4 +120,9 @@ struct wmfw_coeff_item { 
#define WMFW_ADSP1_DM 3

#define WMFW_ADSP1_ZM 4



#define WMFW_ADSP2_PM 2

#define WMFW_ADSP2_ZM 4

#define WMFW_ADSP2_XM 5

#define WMFW_ADSP2_YM 6



#endif