1/*
 
   2 * linux/sound/soc.h -- ALSA SoC Layer
   3 *
   4 * Author:		Liam Girdwood
   5 * Created:		Aug 11th 2005
   6 * Copyright:	Wolfson Microelectronics. PLC.
   7 *
   8 * This program is free software; you can redistribute it and/or modify
   9 * it under the terms of the GNU General Public License version 2 as
  10 * published by the Free Software Foundation.
  11 */
  12
  13#ifndef __LINUX_SND_SOC_H
  14#define __LINUX_SND_SOC_H
  15
 
  16#include <linux/of.h>
  17#include <linux/platform_device.h>
  18#include <linux/types.h>
  19#include <linux/notifier.h>
  20#include <linux/workqueue.h>
  21#include <linux/interrupt.h>
  22#include <linux/kernel.h>
  23#include <linux/regmap.h>
  24#include <linux/log2.h>
  25#include <sound/core.h>
  26#include <sound/pcm.h>
  27#include <sound/compress_driver.h>
  28#include <sound/control.h>
  29#include <sound/ac97_codec.h>
  30
  31/*
  32 * Convenience kcontrol builders
  33 */
  34#define SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, xmax, xinvert, xautodisable) \
  35	((unsigned long)&(struct soc_mixer_control) \
  36	{.reg = xreg, .rreg = xreg, .shift = shift_left, \
  37	.rshift = shift_right, .max = xmax, .platform_max = xmax, \
  38	.invert = xinvert, .autodisable = xautodisable})
  39#define SOC_DOUBLE_S_VALUE(xreg, shift_left, shift_right, xmin, xmax, xsign_bit, xinvert, xautodisable) \
  40	((unsigned long)&(struct soc_mixer_control) \
  41	{.reg = xreg, .rreg = xreg, .shift = shift_left, \
  42	.rshift = shift_right, .min = xmin, .max = xmax, .platform_max = xmax, \
  43	.sign_bit = xsign_bit, .invert = xinvert, .autodisable = xautodisable})
  44#define SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, xautodisable) \
  45	SOC_DOUBLE_VALUE(xreg, xshift, xshift, xmax, xinvert, xautodisable)
  46#define SOC_SINGLE_VALUE_EXT(xreg, xmax, xinvert) \
  47	((unsigned long)&(struct soc_mixer_control) \
  48	{.reg = xreg, .max = xmax, .platform_max = xmax, .invert = xinvert})
  49#define SOC_DOUBLE_R_VALUE(xlreg, xrreg, xshift, xmax, xinvert) \
  50	((unsigned long)&(struct soc_mixer_control) \
  51	{.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
  52	.max = xmax, .platform_max = xmax, .invert = xinvert})
  53#define SOC_DOUBLE_R_S_VALUE(xlreg, xrreg, xshift, xmin, xmax, xsign_bit, xinvert) \
  54	((unsigned long)&(struct soc_mixer_control) \
  55	{.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
  56	.max = xmax, .min = xmin, .platform_max = xmax, .sign_bit = xsign_bit, \
  57	.invert = xinvert})
  58#define SOC_DOUBLE_R_RANGE_VALUE(xlreg, xrreg, xshift, xmin, xmax, xinvert) \
  59	((unsigned long)&(struct soc_mixer_control) \
  60	{.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
  61	.min = xmin, .max = xmax, .platform_max = xmax, .invert = xinvert})
  62#define SOC_SINGLE(xname, reg, shift, max, invert) \
  63{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
  64	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
  65	.put = snd_soc_put_volsw, \
  66	.private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
  67#define SOC_SINGLE_RANGE(xname, xreg, xshift, xmin, xmax, xinvert) \
  68{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
  69	.info = snd_soc_info_volsw_range, .get = snd_soc_get_volsw_range, \
  70	.put = snd_soc_put_volsw_range, \
  71	.private_value = (unsigned long)&(struct soc_mixer_control) \
  72		{.reg = xreg, .rreg = xreg, .shift = xshift, \
  73		 .rshift = xshift,  .min = xmin, .max = xmax, \
  74		 .platform_max = xmax, .invert = xinvert} }
  75#define SOC_SINGLE_TLV(xname, reg, shift, max, invert, tlv_array) \
  76{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
  77	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
  78		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
  79	.tlv.p = (tlv_array), \
  80	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
  81	.put = snd_soc_put_volsw, \
  82	.private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
  83#define SOC_SINGLE_SX_TLV(xname, xreg, xshift, xmin, xmax, tlv_array) \
  84{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
  85	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
  86	SNDRV_CTL_ELEM_ACCESS_READWRITE, \
  87	.tlv.p  = (tlv_array),\
  88	.info = snd_soc_info_volsw_sx, \
  89	.get = snd_soc_get_volsw_sx,\
  90	.put = snd_soc_put_volsw_sx, \
  91	.private_value = (unsigned long)&(struct soc_mixer_control) \
  92		{.reg = xreg, .rreg = xreg, \
  93		.shift = xshift, .rshift = xshift, \
  94		.max = xmax, .min = xmin} }
  95#define SOC_SINGLE_RANGE_TLV(xname, xreg, xshift, xmin, xmax, xinvert, tlv_array) \
  96{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
  97	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
  98		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
  99	.tlv.p = (tlv_array), \
 100	.info = snd_soc_info_volsw_range, \
 101	.get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
 102	.private_value = (unsigned long)&(struct soc_mixer_control) \
 103		{.reg = xreg, .rreg = xreg, .shift = xshift, \
 104		 .rshift = xshift, .min = xmin, .max = xmax, \
 105		 .platform_max = xmax, .invert = xinvert} }
 106#define SOC_DOUBLE(xname, reg, shift_left, shift_right, max, invert) \
 107{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
 108	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
 109	.put = snd_soc_put_volsw, \
 110	.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
 111					  max, invert, 0) }
 112#define SOC_DOUBLE_STS(xname, reg, shift_left, shift_right, max, invert) \
 113{									\
 114	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),		\
 115	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,		\
 116	.access = SNDRV_CTL_ELEM_ACCESS_READ |				\
 117		SNDRV_CTL_ELEM_ACCESS_VOLATILE,				\
 118	.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right,	\
 119					  max, invert, 0) }
 120#define SOC_DOUBLE_R(xname, reg_left, reg_right, xshift, xmax, xinvert) \
 121{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
 122	.info = snd_soc_info_volsw, \
 123	.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
 124	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
 125					    xmax, xinvert) }
 126#define SOC_DOUBLE_R_RANGE(xname, reg_left, reg_right, xshift, xmin, \
 127			   xmax, xinvert)		\
 128{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
 129	.info = snd_soc_info_volsw_range, \
 130	.get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
 131	.private_value = SOC_DOUBLE_R_RANGE_VALUE(reg_left, reg_right, \
 132					    xshift, xmin, xmax, xinvert) }
 133#define SOC_DOUBLE_TLV(xname, reg, shift_left, shift_right, max, invert, tlv_array) \
 134{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
 135	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
 136		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
 137	.tlv.p = (tlv_array), \
 138	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
 139	.put = snd_soc_put_volsw, \
 140	.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
 141					  max, invert, 0) }
 
 
 
 
 
 
 
 
 
 
 
 
 142#define SOC_DOUBLE_R_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert, tlv_array) \
 143{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
 144	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
 145		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
 146	.tlv.p = (tlv_array), \
 147	.info = snd_soc_info_volsw, \
 148	.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
 149	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
 150					    xmax, xinvert) }
 151#define SOC_DOUBLE_R_RANGE_TLV(xname, reg_left, reg_right, xshift, xmin, \
 152			       xmax, xinvert, tlv_array)		\
 153{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
 154	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
 155		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
 156	.tlv.p = (tlv_array), \
 157	.info = snd_soc_info_volsw_range, \
 158	.get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
 159	.private_value = SOC_DOUBLE_R_RANGE_VALUE(reg_left, reg_right, \
 160					    xshift, xmin, xmax, xinvert) }
 161#define SOC_DOUBLE_R_SX_TLV(xname, xreg, xrreg, xshift, xmin, xmax, tlv_array) \
 162{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
 163	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
 164	SNDRV_CTL_ELEM_ACCESS_READWRITE, \
 165	.tlv.p  = (tlv_array), \
 166	.info = snd_soc_info_volsw_sx, \
 167	.get = snd_soc_get_volsw_sx, \
 168	.put = snd_soc_put_volsw_sx, \
 169	.private_value = (unsigned long)&(struct soc_mixer_control) \
 170		{.reg = xreg, .rreg = xrreg, \
 171		.shift = xshift, .rshift = xshift, \
 172		.max = xmax, .min = xmin} }
 173#define SOC_DOUBLE_R_S_TLV(xname, reg_left, reg_right, xshift, xmin, xmax, xsign_bit, xinvert, tlv_array) \
 174{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
 175	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
 176		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
 177	.tlv.p = (tlv_array), \
 178	.info = snd_soc_info_volsw, \
 179	.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
 180	.private_value = SOC_DOUBLE_R_S_VALUE(reg_left, reg_right, xshift, \
 181					    xmin, xmax, xsign_bit, xinvert) }
 
 
 182#define SOC_SINGLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
 183{	.iface  = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
 184	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
 185		  SNDRV_CTL_ELEM_ACCESS_READWRITE, \
 186	.tlv.p  = (tlv_array), \
 187	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
 188	.put = snd_soc_put_volsw, \
 189	.private_value = (unsigned long)&(struct soc_mixer_control) \
 190	{.reg = xreg, .rreg = xreg,  \
 191	 .min = xmin, .max = xmax, .platform_max = xmax, \
 192	.sign_bit = 7,} }
 193#define SOC_DOUBLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
 194{	.iface  = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
 195	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
 196		  SNDRV_CTL_ELEM_ACCESS_READWRITE, \
 197	.tlv.p  = (tlv_array), \
 198	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
 199	.put = snd_soc_put_volsw, \
 200	.private_value = SOC_DOUBLE_S_VALUE(xreg, 0, 8, xmin, xmax, 7, 0, 0) }
 201#define SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xitems, xtexts) \
 202{	.reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
 203	.items = xitems, .texts = xtexts, \
 204	.mask = xitems ? roundup_pow_of_two(xitems) - 1 : 0}
 205#define SOC_ENUM_SINGLE(xreg, xshift, xitems, xtexts) \
 206	SOC_ENUM_DOUBLE(xreg, xshift, xshift, xitems, xtexts)
 207#define SOC_ENUM_SINGLE_EXT(xitems, xtexts) \
 208{	.items = xitems, .texts = xtexts }
 209#define SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, xitems, xtexts, xvalues) \
 210{	.reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
 211	.mask = xmask, .items = xitems, .texts = xtexts, .values = xvalues}
 212#define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xitems, xtexts, xvalues) \
 213	SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xitems, xtexts, xvalues)
 214#define SOC_VALUE_ENUM_SINGLE_AUTODISABLE(xreg, xshift, xmask, xitems, xtexts, xvalues) \
 215{	.reg = xreg, .shift_l = xshift, .shift_r = xshift, \
 216	.mask = xmask, .items = xitems, .texts = xtexts, \
 217	.values = xvalues, .autodisable = 1}
 218#define SOC_ENUM_SINGLE_VIRT(xitems, xtexts) \
 219	SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, xitems, xtexts)
 220#define SOC_ENUM(xname, xenum) \
 221{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
 222	.info = snd_soc_info_enum_double, \
 223	.get = snd_soc_get_enum_double, .put = snd_soc_put_enum_double, \
 224	.private_value = (unsigned long)&xenum }
 225#define SOC_SINGLE_EXT(xname, xreg, xshift, xmax, xinvert,\
 226	 xhandler_get, xhandler_put) \
 227{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 228	.info = snd_soc_info_volsw, \
 229	.get = xhandler_get, .put = xhandler_put, \
 230	.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
 231#define SOC_DOUBLE_EXT(xname, reg, shift_left, shift_right, max, invert,\
 232	 xhandler_get, xhandler_put) \
 233{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
 234	.info = snd_soc_info_volsw, \
 235	.get = xhandler_get, .put = xhandler_put, \
 236	.private_value = \
 237		SOC_DOUBLE_VALUE(reg, shift_left, shift_right, max, invert, 0) }
 238#define SOC_DOUBLE_R_EXT(xname, reg_left, reg_right, xshift, xmax, xinvert,\
 239	 xhandler_get, xhandler_put) \
 240{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
 241	.info = snd_soc_info_volsw, \
 242	.get = xhandler_get, .put = xhandler_put, \
 243	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
 244					    xmax, xinvert) }
 245#define SOC_SINGLE_EXT_TLV(xname, xreg, xshift, xmax, xinvert,\
 246	 xhandler_get, xhandler_put, tlv_array) \
 247{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 248	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
 249		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
 250	.tlv.p = (tlv_array), \
 251	.info = snd_soc_info_volsw, \
 252	.get = xhandler_get, .put = xhandler_put, \
 253	.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
 254#define SOC_SINGLE_RANGE_EXT_TLV(xname, xreg, xshift, xmin, xmax, xinvert, \
 255				 xhandler_get, xhandler_put, tlv_array) \
 256{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
 257	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
 258		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
 259	.tlv.p = (tlv_array), \
 260	.info = snd_soc_info_volsw_range, \
 261	.get = xhandler_get, .put = xhandler_put, \
 262	.private_value = (unsigned long)&(struct soc_mixer_control) \
 263		{.reg = xreg, .rreg = xreg, .shift = xshift, \
 264		 .rshift = xshift, .min = xmin, .max = xmax, \
 265		 .platform_max = xmax, .invert = xinvert} }
 266#define SOC_DOUBLE_EXT_TLV(xname, xreg, shift_left, shift_right, xmax, xinvert,\
 267	 xhandler_get, xhandler_put, tlv_array) \
 268{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
 269	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
 270		 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
 271	.tlv.p = (tlv_array), \
 272	.info = snd_soc_info_volsw, \
 273	.get = xhandler_get, .put = xhandler_put, \
 274	.private_value = SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, \
 275					  xmax, xinvert, 0) }
 276#define SOC_DOUBLE_R_EXT_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert,\
 277	 xhandler_get, xhandler_put, tlv_array) \
 278{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
 279	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
 280		 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
 281	.tlv.p = (tlv_array), \
 282	.info = snd_soc_info_volsw, \
 283	.get = xhandler_get, .put = xhandler_put, \
 284	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
 285					    xmax, xinvert) }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 286#define SOC_SINGLE_BOOL_EXT(xname, xdata, xhandler_get, xhandler_put) \
 287{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 288	.info = snd_soc_info_bool_ext, \
 289	.get = xhandler_get, .put = xhandler_put, \
 290	.private_value = xdata }
 291#define SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
 292{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 293	.info = snd_soc_info_enum_double, \
 294	.get = xhandler_get, .put = xhandler_put, \
 295	.private_value = (unsigned long)&xenum }
 296#define SOC_VALUE_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
 297	SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put)
 298
 299#define SND_SOC_BYTES(xname, xbase, xregs)		      \
 300{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,   \
 301	.info = snd_soc_bytes_info, .get = snd_soc_bytes_get, \
 302	.put = snd_soc_bytes_put, .private_value =	      \
 303		((unsigned long)&(struct soc_bytes)           \
 304		{.base = xbase, .num_regs = xregs }) }
 
 
 
 
 
 
 305
 306#define SND_SOC_BYTES_MASK(xname, xbase, xregs, xmask)	      \
 307{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,   \
 308	.info = snd_soc_bytes_info, .get = snd_soc_bytes_get, \
 309	.put = snd_soc_bytes_put, .private_value =	      \
 310		((unsigned long)&(struct soc_bytes)           \
 311		{.base = xbase, .num_regs = xregs,	      \
 312		 .mask = xmask }) }
 313
 314/*
 315 * SND_SOC_BYTES_EXT is deprecated, please USE SND_SOC_BYTES_TLV instead
 316 */
 317#define SND_SOC_BYTES_EXT(xname, xcount, xhandler_get, xhandler_put) \
 318{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 319	.info = snd_soc_bytes_info_ext, \
 320	.get = xhandler_get, .put = xhandler_put, \
 321	.private_value = (unsigned long)&(struct soc_bytes_ext) \
 322		{.max = xcount} }
 323#define SND_SOC_BYTES_TLV(xname, xcount, xhandler_get, xhandler_put) \
 324{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 325	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE | \
 326		  SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
 327	.tlv.c = (snd_soc_bytes_tlv_callback), \
 328	.info = snd_soc_bytes_info_ext, \
 329	.private_value = (unsigned long)&(struct soc_bytes_ext) \
 330		{.max = xcount, .get = xhandler_get, .put = xhandler_put, } }
 331#define SOC_SINGLE_XR_SX(xname, xregbase, xregcount, xnbits, \
 332		xmin, xmax, xinvert) \
 333{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
 334	.info = snd_soc_info_xr_sx, .get = snd_soc_get_xr_sx, \
 335	.put = snd_soc_put_xr_sx, \
 336	.private_value = (unsigned long)&(struct soc_mreg_control) \
 337		{.regbase = xregbase, .regcount = xregcount, .nbits = xnbits, \
 338		.invert = xinvert, .min = xmin, .max = xmax} }
 339
 340#define SOC_SINGLE_STROBE(xname, xreg, xshift, xinvert) \
 341	SOC_SINGLE_EXT(xname, xreg, xshift, 1, xinvert, \
 342		snd_soc_get_strobe, snd_soc_put_strobe)
 343
 344/*
 345 * Simplified versions of above macros, declaring a struct and calculating
 346 * ARRAY_SIZE internally
 347 */
 348#define SOC_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xtexts) \
 349	const struct soc_enum name = SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, \
 350						ARRAY_SIZE(xtexts), xtexts)
 351#define SOC_ENUM_SINGLE_DECL(name, xreg, xshift, xtexts) \
 352	SOC_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xtexts)
 353#define SOC_ENUM_SINGLE_EXT_DECL(name, xtexts) \
 354	const struct soc_enum name = SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(xtexts), xtexts)
 355#define SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xmask, xtexts, xvalues) \
 356	const struct soc_enum name = SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, \
 357							ARRAY_SIZE(xtexts), xtexts, xvalues)
 358#define SOC_VALUE_ENUM_SINGLE_DECL(name, xreg, xshift, xmask, xtexts, xvalues) \
 359	SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xmask, xtexts, xvalues)
 360
 361#define SOC_VALUE_ENUM_SINGLE_AUTODISABLE_DECL(name, xreg, xshift, xmask, xtexts, xvalues) \
 362	const struct soc_enum name = SOC_VALUE_ENUM_SINGLE_AUTODISABLE(xreg, \
 363		xshift, xmask, ARRAY_SIZE(xtexts), xtexts, xvalues)
 364
 365#define SOC_ENUM_SINGLE_VIRT_DECL(name, xtexts) \
 366	const struct soc_enum name = SOC_ENUM_SINGLE_VIRT(ARRAY_SIZE(xtexts), xtexts)
 367
 368/*
 369 * Component probe and remove ordering levels for components with runtime
 370 * dependencies.
 371 */
 372#define SND_SOC_COMP_ORDER_FIRST		-2
 373#define SND_SOC_COMP_ORDER_EARLY		-1
 374#define SND_SOC_COMP_ORDER_NORMAL		0
 375#define SND_SOC_COMP_ORDER_LATE		1
 376#define SND_SOC_COMP_ORDER_LAST		2
 377
 378/*
 379 * Bias levels
 380 *
 381 * @ON:      Bias is fully on for audio playback and capture operations.
 382 * @PREPARE: Prepare for audio operations. Called before DAPM switching for
 383 *           stream start and stop operations.
 384 * @STANDBY: Low power standby state when no playback/capture operations are
 385 *           in progress. NOTE: The transition time between STANDBY and ON
 386 *           should be as fast as possible and no longer than 10ms.
 387 * @OFF:     Power Off. No restrictions on transition times.
 388 */
 389enum snd_soc_bias_level {
 390	SND_SOC_BIAS_OFF = 0,
 391	SND_SOC_BIAS_STANDBY = 1,
 392	SND_SOC_BIAS_PREPARE = 2,
 393	SND_SOC_BIAS_ON = 3,
 394};
 395
 396struct device_node;
 397struct snd_jack;
 398struct snd_soc_card;
 399struct snd_soc_pcm_stream;
 400struct snd_soc_ops;
 401struct snd_soc_pcm_runtime;
 402struct snd_soc_dai;
 403struct snd_soc_dai_driver;
 404struct snd_soc_platform;
 405struct snd_soc_dai_link;
 406struct snd_soc_platform_driver;
 407struct snd_soc_codec;
 408struct snd_soc_codec_driver;
 409struct snd_soc_component;
 410struct snd_soc_component_driver;
 411struct soc_enum;
 412struct snd_soc_jack;
 413struct snd_soc_jack_zone;
 414struct snd_soc_jack_pin;
 415#include <sound/soc-dapm.h>
 416#include <sound/soc-dpcm.h>
 417#include <sound/soc-topology.h>
 418
 419struct snd_soc_jack_gpio;
 420
 421typedef int (*hw_write_t)(void *,const char* ,int);
 422
 423enum snd_soc_pcm_subclass {
 424	SND_SOC_PCM_CLASS_PCM	= 0,
 425	SND_SOC_PCM_CLASS_BE	= 1,
 426};
 427
 428enum snd_soc_card_subclass {
 429	SND_SOC_CARD_CLASS_INIT		= 0,
 430	SND_SOC_CARD_CLASS_RUNTIME	= 1,
 431};
 432
 433int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
 434			     int source, unsigned int freq, int dir);
 435int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
 436			  unsigned int freq_in, unsigned int freq_out);
 437int snd_soc_codec_set_jack(struct snd_soc_codec *codec,
 438			   struct snd_soc_jack *jack, void *data);
 439
 440int snd_soc_register_card(struct snd_soc_card *card);
 441int snd_soc_unregister_card(struct snd_soc_card *card);
 442int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card);
 443#ifdef CONFIG_PM_SLEEP
 444int snd_soc_suspend(struct device *dev);
 445int snd_soc_resume(struct device *dev);
 446#else
 447static inline int snd_soc_suspend(struct device *dev)
 448{
 449	return 0;
 450}
 451
 452static inline int snd_soc_resume(struct device *dev)
 453{
 454	return 0;
 455}
 456#endif
 457int snd_soc_poweroff(struct device *dev);
 458int snd_soc_register_platform(struct device *dev,
 459		const struct snd_soc_platform_driver *platform_drv);
 460int devm_snd_soc_register_platform(struct device *dev,
 461		const struct snd_soc_platform_driver *platform_drv);
 462void snd_soc_unregister_platform(struct device *dev);
 463int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,
 464		const struct snd_soc_platform_driver *platform_drv);
 465void snd_soc_remove_platform(struct snd_soc_platform *platform);
 466struct snd_soc_platform *snd_soc_lookup_platform(struct device *dev);
 467int snd_soc_register_codec(struct device *dev,
 468		const struct snd_soc_codec_driver *codec_drv,
 469		struct snd_soc_dai_driver *dai_drv, int num_dai);
 470void snd_soc_unregister_codec(struct device *dev);
 471int snd_soc_add_component(struct device *dev,
 472		struct snd_soc_component *component,
 473		const struct snd_soc_component_driver *component_driver,
 474		struct snd_soc_dai_driver *dai_drv,
 475		int num_dai);
 476int snd_soc_register_component(struct device *dev,
 477			 const struct snd_soc_component_driver *component_driver,
 478			 struct snd_soc_dai_driver *dai_drv, int num_dai);
 479int devm_snd_soc_register_component(struct device *dev,
 480			 const struct snd_soc_component_driver *component_driver,
 481			 struct snd_soc_dai_driver *dai_drv, int num_dai);
 482void snd_soc_unregister_component(struct device *dev);
 
 
 
 
 483struct snd_soc_component *snd_soc_lookup_component(struct device *dev,
 484						   const char *driver_name);
 485int snd_soc_cache_init(struct snd_soc_codec *codec);
 486int snd_soc_cache_exit(struct snd_soc_codec *codec);
 487
 488int snd_soc_platform_read(struct snd_soc_platform *platform,
 489					unsigned int reg);
 490int snd_soc_platform_write(struct snd_soc_platform *platform,
 491					unsigned int reg, unsigned int val);
 492int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
 493#ifdef CONFIG_SND_SOC_COMPRESS
 494int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num);
 
 
 
 
 
 495#endif
 496
 497void snd_soc_disconnect_sync(struct device *dev);
 498
 499struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
 500		const char *dai_link, int stream);
 501struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
 502		const char *dai_link);
 503
 504bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd);
 505void snd_soc_runtime_activate(struct snd_soc_pcm_runtime *rtd, int stream);
 506void snd_soc_runtime_deactivate(struct snd_soc_pcm_runtime *rtd, int stream);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 507
 508int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
 509	unsigned int dai_fmt);
 510
 511#ifdef CONFIG_DMI
 512int snd_soc_set_dmi_name(struct snd_soc_card *card, const char *flavour);
 513#else
 514static inline int snd_soc_set_dmi_name(struct snd_soc_card *card,
 515				       const char *flavour)
 516{
 517	return 0;
 518}
 519#endif
 520
 521/* Utility functions to get clock rates from various things */
 522int snd_soc_calc_frame_size(int sample_size, int channels, int tdm_slots);
 523int snd_soc_params_to_frame_size(struct snd_pcm_hw_params *params);
 524int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
 525int snd_soc_params_to_bclk(struct snd_pcm_hw_params *parms);
 
 
 526
 527/* set runtime hw params */
 528int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
 529	const struct snd_pcm_hardware *hw);
 530
 531int soc_dai_hw_params(struct snd_pcm_substream *substream,
 532		      struct snd_pcm_hw_params *params,
 533		      struct snd_soc_dai *dai);
 534
 535/* Jack reporting */
 536int snd_soc_card_jack_new(struct snd_soc_card *card, const char *id, int type,
 537	struct snd_soc_jack *jack, struct snd_soc_jack_pin *pins,
 538	unsigned int num_pins);
 539
 540void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask);
 541int snd_soc_jack_add_pins(struct snd_soc_jack *jack, int count,
 542			  struct snd_soc_jack_pin *pins);
 543void snd_soc_jack_notifier_register(struct snd_soc_jack *jack,
 544				    struct notifier_block *nb);
 545void snd_soc_jack_notifier_unregister(struct snd_soc_jack *jack,
 546				      struct notifier_block *nb);
 547int snd_soc_jack_add_zones(struct snd_soc_jack *jack, int count,
 548			  struct snd_soc_jack_zone *zones);
 549int snd_soc_jack_get_type(struct snd_soc_jack *jack, int micbias_voltage);
 550#ifdef CONFIG_GPIOLIB
 551int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
 552			struct snd_soc_jack_gpio *gpios);
 553int snd_soc_jack_add_gpiods(struct device *gpiod_dev,
 554			    struct snd_soc_jack *jack,
 555			    int count, struct snd_soc_jack_gpio *gpios);
 556void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
 557			struct snd_soc_jack_gpio *gpios);
 558#else
 559static inline int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
 560					 struct snd_soc_jack_gpio *gpios)
 561{
 562	return 0;
 563}
 564
 565static inline int snd_soc_jack_add_gpiods(struct device *gpiod_dev,
 566					  struct snd_soc_jack *jack,
 567					  int count,
 568					  struct snd_soc_jack_gpio *gpios)
 569{
 570	return 0;
 571}
 572
 573static inline void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
 574					   struct snd_soc_jack_gpio *gpios)
 575{
 576}
 577#endif
 578
 579/* codec register bit access */
 580int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned int reg,
 581				unsigned int mask, unsigned int value);
 582int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
 583			       unsigned int reg, unsigned int mask,
 584			       unsigned int value);
 585int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned int reg,
 586				unsigned int mask, unsigned int value);
 587
 588#ifdef CONFIG_SND_SOC_AC97_BUS
 589#define snd_soc_alloc_ac97_codec(codec) \
 590	snd_soc_alloc_ac97_component(&codec->component)
 591#define snd_soc_new_ac97_codec(codec, id, id_mask) \
 592	snd_soc_new_ac97_component(&codec->component, id, id_mask)
 593#define snd_soc_free_ac97_codec(ac97) \
 594	snd_soc_free_ac97_component(ac97)
 595
 596struct snd_ac97 *snd_soc_alloc_ac97_component(struct snd_soc_component *component);
 597struct snd_ac97 *snd_soc_new_ac97_component(struct snd_soc_component *component,
 598	unsigned int id, unsigned int id_mask);
 599void snd_soc_free_ac97_component(struct snd_ac97 *ac97);
 600
 
 601int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops);
 602int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
 603		struct platform_device *pdev);
 604
 605extern struct snd_ac97_bus_ops *soc_ac97_ops;
 606#else
 607static inline int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
 608	struct platform_device *pdev)
 609{
 610	return 0;
 611}
 612
 613static inline int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops)
 614{
 615	return 0;
 616}
 617#endif
 618
 619/*
 620 *Controls
 621 */
 622struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
 623				  void *data, const char *long_name,
 624				  const char *prefix);
 625struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
 626					       const char *name);
 627int snd_soc_add_component_controls(struct snd_soc_component *component,
 628	const struct snd_kcontrol_new *controls, unsigned int num_controls);
 629int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
 630	const struct snd_kcontrol_new *controls, unsigned int num_controls);
 631int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
 632	const struct snd_kcontrol_new *controls, unsigned int num_controls);
 633int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
 634	const struct snd_kcontrol_new *controls, int num_controls);
 635int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
 636	const struct snd_kcontrol_new *controls, int num_controls);
 637int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
 638	struct snd_ctl_elem_info *uinfo);
 639int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
 640	struct snd_ctl_elem_value *ucontrol);
 641int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
 642	struct snd_ctl_elem_value *ucontrol);
 643int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
 644	struct snd_ctl_elem_info *uinfo);
 645int snd_soc_info_volsw_sx(struct snd_kcontrol *kcontrol,
 646			  struct snd_ctl_elem_info *uinfo);
 647#define snd_soc_info_bool_ext		snd_ctl_boolean_mono_info
 648int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
 649	struct snd_ctl_elem_value *ucontrol);
 650int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
 651	struct snd_ctl_elem_value *ucontrol);
 652#define snd_soc_get_volsw_2r snd_soc_get_volsw
 653#define snd_soc_put_volsw_2r snd_soc_put_volsw
 654int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,
 655	struct snd_ctl_elem_value *ucontrol);
 656int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,
 657	struct snd_ctl_elem_value *ucontrol);
 658int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol,
 659	struct snd_ctl_elem_info *uinfo);
 660int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol,
 661	struct snd_ctl_elem_value *ucontrol);
 662int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol,
 663	struct snd_ctl_elem_value *ucontrol);
 664int snd_soc_limit_volume(struct snd_soc_card *card,
 665	const char *name, int max);
 666int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
 667		       struct snd_ctl_elem_info *uinfo);
 668int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
 669		      struct snd_ctl_elem_value *ucontrol);
 670int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
 671		      struct snd_ctl_elem_value *ucontrol);
 672int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
 673	struct snd_ctl_elem_info *ucontrol);
 674int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
 675	unsigned int size, unsigned int __user *tlv);
 676int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,
 677	struct snd_ctl_elem_info *uinfo);
 678int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,
 679	struct snd_ctl_elem_value *ucontrol);
 680int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,
 681	struct snd_ctl_elem_value *ucontrol);
 682int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
 683	struct snd_ctl_elem_value *ucontrol);
 684int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
 685	struct snd_ctl_elem_value *ucontrol);
 686
 687/**
 688 * struct snd_soc_jack_pin - Describes a pin to update based on jack detection
 689 *
 690 * @pin:    name of the pin to update
 691 * @mask:   bits to check for in reported jack status
 692 * @invert: if non-zero then pin is enabled when status is not reported
 693 * @list:   internal list entry
 694 */
 695struct snd_soc_jack_pin {
 696	struct list_head list;
 697	const char *pin;
 698	int mask;
 699	bool invert;
 700};
 701
 702/**
 703 * struct snd_soc_jack_zone - Describes voltage zones of jack detection
 704 *
 705 * @min_mv: start voltage in mv
 706 * @max_mv: end voltage in mv
 707 * @jack_type: type of jack that is expected for this voltage
 708 * @debounce_time: debounce_time for jack, codec driver should wait for this
 709 *		duration before reading the adc for voltages
 710 * @list:   internal list entry
 711 */
 712struct snd_soc_jack_zone {
 713	unsigned int min_mv;
 714	unsigned int max_mv;
 715	unsigned int jack_type;
 716	unsigned int debounce_time;
 717	struct list_head list;
 718};
 719
 720/**
 721 * struct snd_soc_jack_gpio - Describes a gpio pin for jack detection
 722 *
 723 * @gpio:         legacy gpio number
 724 * @idx:          gpio descriptor index within the function of the GPIO
 725 *                consumer device
 726 * @gpiod_dev:    GPIO consumer device
 727 * @name:         gpio name. Also as connection ID for the GPIO consumer
 728 *                device function name lookup
 729 * @report:       value to report when jack detected
 730 * @invert:       report presence in low state
 731 * @debounce_time: debounce time in ms
 732 * @wake:	  enable as wake source
 733 * @jack_status_check: callback function which overrides the detection
 734 *		       to provide more complex checks (eg, reading an
 735 *		       ADC).
 736 */
 737struct snd_soc_jack_gpio {
 738	unsigned int gpio;
 739	unsigned int idx;
 740	struct device *gpiod_dev;
 741	const char *name;
 742	int report;
 743	int invert;
 744	int debounce_time;
 745	bool wake;
 746
 747	/* private: */
 748	struct snd_soc_jack *jack;
 749	struct delayed_work work;
 750	struct notifier_block pm_notifier;
 751	struct gpio_desc *desc;
 752
 753	void *data;
 754	/* public: */
 755	int (*jack_status_check)(void *data);
 756};
 757
 758struct snd_soc_jack {
 759	struct mutex mutex;
 760	struct snd_jack *jack;
 761	struct snd_soc_card *card;
 762	struct list_head pins;
 763	int status;
 764	struct blocking_notifier_head notifier;
 765	struct list_head jack_zones;
 766};
 767
 768/* SoC PCM stream information */
 769struct snd_soc_pcm_stream {
 770	const char *stream_name;
 771	u64 formats;			/* SNDRV_PCM_FMTBIT_* */
 
 772	unsigned int rates;		/* SNDRV_PCM_RATE_* */
 773	unsigned int rate_min;		/* min rate */
 774	unsigned int rate_max;		/* max rate */
 775	unsigned int channels_min;	/* min channels */
 776	unsigned int channels_max;	/* max channels */
 777	unsigned int sig_bits;		/* number of bits of content */
 778};
 779
 780/* SoC audio ops */
 781struct snd_soc_ops {
 782	int (*startup)(struct snd_pcm_substream *);
 783	void (*shutdown)(struct snd_pcm_substream *);
 784	int (*hw_params)(struct snd_pcm_substream *, struct snd_pcm_hw_params *);
 785	int (*hw_free)(struct snd_pcm_substream *);
 786	int (*prepare)(struct snd_pcm_substream *);
 787	int (*trigger)(struct snd_pcm_substream *, int);
 788};
 789
 790struct snd_soc_compr_ops {
 791	int (*startup)(struct snd_compr_stream *);
 792	void (*shutdown)(struct snd_compr_stream *);
 793	int (*set_params)(struct snd_compr_stream *);
 794	int (*trigger)(struct snd_compr_stream *);
 795};
 796
 797/* component interface */
 798struct snd_soc_component_driver {
 799	const char *name;
 800
 801	/* Default control and setup, added after probe() is run */
 802	const struct snd_kcontrol_new *controls;
 803	unsigned int num_controls;
 804	const struct snd_soc_dapm_widget *dapm_widgets;
 805	unsigned int num_dapm_widgets;
 806	const struct snd_soc_dapm_route *dapm_routes;
 807	unsigned int num_dapm_routes;
 808
 809	int (*probe)(struct snd_soc_component *);
 810	void (*remove)(struct snd_soc_component *);
 811	int (*suspend)(struct snd_soc_component *);
 812	int (*resume)(struct snd_soc_component *);
 813
 814	unsigned int (*read)(struct snd_soc_component *, unsigned int);
 815	int (*write)(struct snd_soc_component *, unsigned int, unsigned int);
 816
 817	/* pcm creation and destruction */
 818	int (*pcm_new)(struct snd_soc_pcm_runtime *);
 819	void (*pcm_free)(struct snd_pcm *);
 820
 821	/* component wide operations */
 822	int (*set_sysclk)(struct snd_soc_component *component,
 823			  int clk_id, int source, unsigned int freq, int dir);
 824	int (*set_pll)(struct snd_soc_component *component, int pll_id,
 825		       int source, unsigned int freq_in, unsigned int freq_out);
 826	int (*set_jack)(struct snd_soc_component *component,
 827			struct snd_soc_jack *jack,  void *data);
 828
 829	/* DT */
 830	int (*of_xlate_dai_name)(struct snd_soc_component *component,
 831				 struct of_phandle_args *args,
 832				 const char **dai_name);
 833	int (*of_xlate_dai_id)(struct snd_soc_component *comment,
 834			       struct device_node *endpoint);
 835	void (*seq_notifier)(struct snd_soc_component *, enum snd_soc_dapm_type,
 836		int subseq);
 837	int (*stream_event)(struct snd_soc_component *, int event);
 838	int (*set_bias_level)(struct snd_soc_component *component,
 839			      enum snd_soc_bias_level level);
 840
 841	const struct snd_pcm_ops *ops;
 842	const struct snd_compr_ops *compr_ops;
 843
 844	/* probe ordering - for components with runtime dependencies */
 845	int probe_order;
 846	int remove_order;
 847
 848	/* bits */
 849	unsigned int idle_bias_on:1;
 850	unsigned int suspend_bias_off:1;
 851	unsigned int use_pmdown_time:1; /* care pmdown_time at stop */
 852	unsigned int endianness:1;
 853	unsigned int non_legacy_dai_naming:1;
 854};
 855
 856struct snd_soc_component {
 857	const char *name;
 858	int id;
 859	const char *name_prefix;
 860	struct device *dev;
 861	struct snd_soc_card *card;
 862
 863	unsigned int active;
 864
 865	unsigned int ignore_pmdown_time:1; /* pmdown_time is ignored at stop */
 866	unsigned int registered_as_component:1;
 867	unsigned int suspended:1; /* is in suspend PM state */
 868
 869	struct list_head list;
 870	struct list_head card_aux_list; /* for auxiliary bound components */
 871	struct list_head card_list;
 872
 873	const struct snd_soc_component_driver *driver;
 874
 875	struct list_head dai_list;
 876	int num_dai;
 877
 878	int (*read)(struct snd_soc_component *, unsigned int, unsigned int *);
 879	int (*write)(struct snd_soc_component *, unsigned int, unsigned int);
 880
 881	struct regmap *regmap;
 882	int val_bytes;
 883
 884	struct mutex io_mutex;
 885
 886	/* attached dynamic objects */
 887	struct list_head dobj_list;
 888
 889#ifdef CONFIG_DEBUG_FS
 890	struct dentry *debugfs_root;
 891#endif
 892
 893	/*
 894	* DO NOT use any of the fields below in drivers, they are temporary and
 895	* are going to be removed again soon. If you use them in driver code the
 896	* driver will be marked as BROKEN when these fields are removed.
 897	*/
 898
 899	/* Don't use these, use snd_soc_component_get_dapm() */
 900	struct snd_soc_dapm_context dapm;
 901
 902	struct snd_soc_codec *codec;
 903
 904	int (*probe)(struct snd_soc_component *);
 905	void (*remove)(struct snd_soc_component *);
 906	int (*suspend)(struct snd_soc_component *);
 907	int (*resume)(struct snd_soc_component *);
 908	int (*pcm_new)(struct snd_soc_component *, struct snd_soc_pcm_runtime *);
 909	void (*pcm_free)(struct snd_soc_component *, struct snd_pcm *);
 910
 911	int (*set_sysclk)(struct snd_soc_component *component,
 912			  int clk_id, int source, unsigned int freq, int dir);
 913	int (*set_pll)(struct snd_soc_component *component, int pll_id,
 914		       int source, unsigned int freq_in, unsigned int freq_out);
 915	int (*set_jack)(struct snd_soc_component *component,
 916			struct snd_soc_jack *jack,  void *data);
 917	int (*set_bias_level)(struct snd_soc_component *component,
 918			      enum snd_soc_bias_level level);
 919
 920	/* machine specific init */
 921	int (*init)(struct snd_soc_component *component);
 922
 923#ifdef CONFIG_DEBUG_FS
 924	void (*init_debugfs)(struct snd_soc_component *component);
 925	const char *debugfs_prefix;
 926#endif
 927};
 928
 929struct snd_soc_rtdcom_list {
 930	struct snd_soc_component *component;
 931	struct list_head list; /* rtd::component_list */
 932};
 933struct snd_soc_component*
 934snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime *rtd,
 935		       const char *driver_name);
 936#define for_each_rtdcom(rtd, rtdcom) \
 937	list_for_each_entry(rtdcom, &(rtd)->component_list, list)
 938#define for_each_rtdcom_safe(rtd, rtdcom1, rtdcom2) \
 939	list_for_each_entry_safe(rtdcom1, rtdcom2, &(rtd)->component_list, list)
 940
 941/* SoC Audio Codec device */
 942struct snd_soc_codec {
 943	struct device *dev;
 944	const struct snd_soc_codec_driver *driver;
 945
 946	struct list_head list;
 947
 948	/* runtime */
 949	unsigned int cache_init:1; /* codec cache has been initialized */
 950
 951	/* codec IO */
 952	void *control_data; /* codec control (i2c/3wire) data */
 953	hw_write_t hw_write;
 954	void *reg_cache;
 955
 956	/* component */
 957	struct snd_soc_component component;
 958};
 959
 960/* codec driver */
 961struct snd_soc_codec_driver {
 962
 963	/* driver ops */
 964	int (*probe)(struct snd_soc_codec *);
 965	int (*remove)(struct snd_soc_codec *);
 966	int (*suspend)(struct snd_soc_codec *);
 967	int (*resume)(struct snd_soc_codec *);
 968	struct snd_soc_component_driver component_driver;
 969
 970	/* codec wide operations */
 971	int (*set_sysclk)(struct snd_soc_codec *codec,
 972			  int clk_id, int source, unsigned int freq, int dir);
 973	int (*set_pll)(struct snd_soc_codec *codec, int pll_id, int source,
 974		unsigned int freq_in, unsigned int freq_out);
 975	int (*set_jack)(struct snd_soc_codec *codec,
 976			struct snd_soc_jack *jack,  void *data);
 977
 978	/* codec IO */
 979	struct regmap *(*get_regmap)(struct device *);
 980	unsigned int (*read)(struct snd_soc_codec *, unsigned int);
 981	int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
 982	unsigned int reg_cache_size;
 983	short reg_cache_step;
 984	short reg_word_size;
 985	const void *reg_cache_default;
 986
 987	/* codec bias level */
 988	int (*set_bias_level)(struct snd_soc_codec *,
 989			      enum snd_soc_bias_level level);
 990	bool idle_bias_off;
 991	bool suspend_bias_off;
 992
 993	void (*seq_notifier)(struct snd_soc_dapm_context *,
 994			     enum snd_soc_dapm_type, int);
 995
 996	bool ignore_pmdown_time;  /* Doesn't benefit from pmdown delay */
 997};
 998
 999/* SoC platform interface */
1000struct snd_soc_platform_driver {
1001
1002	int (*probe)(struct snd_soc_platform *);
1003	int (*remove)(struct snd_soc_platform *);
1004	struct snd_soc_component_driver component_driver;
1005
1006	/* pcm creation and destruction */
1007	int (*pcm_new)(struct snd_soc_pcm_runtime *);
1008	void (*pcm_free)(struct snd_pcm *);
1009
1010	/* platform stream pcm ops */
1011	const struct snd_pcm_ops *ops;
1012
1013	/* platform stream compress ops */
1014	const struct snd_compr_ops *compr_ops;
1015};
1016
1017struct snd_soc_dai_link_component {
1018	const char *name;
1019	struct device_node *of_node;
1020	const char *dai_name;
 
1021};
1022
1023struct snd_soc_platform {
1024	struct device *dev;
1025	const struct snd_soc_platform_driver *driver;
1026
1027	struct list_head list;
1028
1029	struct snd_soc_component component;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1030};
1031
1032struct snd_soc_dai_link {
1033	/* config - must be set by machine driver */
1034	const char *name;			/* Codec name */
1035	const char *stream_name;		/* Stream name */
 
1036	/*
1037	 * You MAY specify the link's CPU-side device, either by device name,
1038	 * or by DT/OF node, but not both. If this information is omitted,
1039	 * the CPU-side DAI is matched using .cpu_dai_name only, which hence
1040	 * must be globally unique. These fields are currently typically used
1041	 * only for codec to codec links, or systems using device tree.
1042	 */
1043	const char *cpu_name;
1044	struct device_node *cpu_of_node;
1045	/*
1046	 * You MAY specify the DAI name of the CPU DAI. If this information is
1047	 * omitted, the CPU-side DAI is matched using .cpu_name/.cpu_of_node
1048	 * only, which only works well when that device exposes a single DAI.
1049	 */
1050	const char *cpu_dai_name;
 
 
1051	/*
1052	 * You MUST specify the link's codec, either by device name, or by
1053	 * DT/OF node, but not both.
1054	 */
1055	const char *codec_name;
1056	struct device_node *codec_of_node;
1057	/* You MUST specify the DAI name within the codec */
1058	const char *codec_dai_name;
1059
1060	struct snd_soc_dai_link_component *codecs;
1061	unsigned int num_codecs;
1062
 
 
 
1063	/*
1064	 * You MAY specify the link's platform/PCM/DMA driver, either by
1065	 * device name, or by DT/OF node, but not both. Some forms of link
1066	 * do not need a platform.
1067	 */
1068	const char *platform_name;
1069	struct device_node *platform_of_node;
 
1070	int id;	/* optional ID for machine driver link identification */
1071
1072	const struct snd_soc_pcm_stream *params;
1073	unsigned int num_params;
 
 
 
1074
1075	unsigned int dai_fmt;           /* format to set on init */
1076
1077	enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */
1078
1079	/* codec/machine specific init - e.g. add machine controls */
1080	int (*init)(struct snd_soc_pcm_runtime *rtd);
1081
 
 
 
1082	/* optional hw_params re-writing for BE and FE sync */
1083	int (*be_hw_params_fixup)(struct snd_soc_pcm_runtime *rtd,
1084			struct snd_pcm_hw_params *params);
1085
1086	/* machine stream operations */
1087	const struct snd_soc_ops *ops;
1088	const struct snd_soc_compr_ops *compr_ops;
1089
 
 
 
 
 
 
 
 
 
1090	/* Mark this pcm with non atomic ops */
1091	bool nonatomic;
1092
1093	/* For unidirectional dai links */
1094	unsigned int playback_only:1;
1095	unsigned int capture_only:1;
1096
1097	/* Keep DAI active over suspend */
1098	unsigned int ignore_suspend:1;
1099
1100	/* Symmetry requirements */
1101	unsigned int symmetric_rates:1;
1102	unsigned int symmetric_channels:1;
1103	unsigned int symmetric_samplebits:1;
1104
1105	/* Do not create a PCM for this DAI link (Backend link) */
1106	unsigned int no_pcm:1;
1107
1108	/* This DAI link can route to other DAI links at runtime (Frontend)*/
1109	unsigned int dynamic:1;
1110
1111	/* DPCM capture and Playback support */
1112	unsigned int dpcm_capture:1;
1113	unsigned int dpcm_playback:1;
1114
1115	/* DPCM used FE & BE merged format */
1116	unsigned int dpcm_merged_format:1;
 
 
 
 
1117
1118	/* pmdown_time is ignored at stop */
1119	unsigned int ignore_pmdown_time:1;
1120
1121	struct list_head list; /* DAI link list of the soc card */
 
 
 
1122	struct snd_soc_dobj dobj; /* For topology */
 
1123};
1124
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1125struct snd_soc_codec_conf {
1126	/*
1127	 * specify device either by device name, or by
1128	 * DT/OF node, but not both.
1129	 */
1130	const char *dev_name;
1131	struct device_node *of_node;
1132
1133	/*
1134	 * optional map of kcontrol, widget and path name prefixes that are
1135	 * associated per device
1136	 */
1137	const char *name_prefix;
1138};
1139
1140struct snd_soc_aux_dev {
1141	const char *name;		/* Codec name */
1142
1143	/*
1144	 * specify multi-codec either by device name, or by
1145	 * DT/OF node, but not both.
1146	 */
1147	const char *codec_name;
1148	struct device_node *codec_of_node;
1149
1150	/* codec/machine specific init - e.g. add machine controls */
1151	int (*init)(struct snd_soc_component *component);
1152};
1153
1154/* SoC card */
1155struct snd_soc_card {
1156	const char *name;
1157	const char *long_name;
1158	const char *driver_name;
 
 
1159	char dmi_longname[80];
 
 
 
 
 
 
 
 
 
 
 
 
 
1160
1161	struct device *dev;
1162	struct snd_card *snd_card;
1163	struct module *owner;
1164
1165	struct mutex mutex;
1166	struct mutex dapm_mutex;
1167
1168	bool instantiated;
 
 
1169
1170	int (*probe)(struct snd_soc_card *card);
1171	int (*late_probe)(struct snd_soc_card *card);
 
1172	int (*remove)(struct snd_soc_card *card);
1173
1174	/* the pre and post PM functions are used to do any PM work before and
1175	 * after the codec and DAI's do any PM work. */
1176	int (*suspend_pre)(struct snd_soc_card *card);
1177	int (*suspend_post)(struct snd_soc_card *card);
1178	int (*resume_pre)(struct snd_soc_card *card);
1179	int (*resume_post)(struct snd_soc_card *card);
1180
1181	/* callbacks */
1182	int (*set_bias_level)(struct snd_soc_card *,
1183			      struct snd_soc_dapm_context *dapm,
1184			      enum snd_soc_bias_level level);
1185	int (*set_bias_level_post)(struct snd_soc_card *,
1186				   struct snd_soc_dapm_context *dapm,
1187				   enum snd_soc_bias_level level);
1188
1189	int (*add_dai_link)(struct snd_soc_card *,
1190			    struct snd_soc_dai_link *link);
1191	void (*remove_dai_link)(struct snd_soc_card *,
1192			    struct snd_soc_dai_link *link);
1193
1194	long pmdown_time;
1195
1196	/* CPU <--> Codec DAI links  */
1197	struct snd_soc_dai_link *dai_link;  /* predefined links only */
1198	int num_links;  /* predefined links only */
1199	struct list_head dai_link_list; /* all links */
1200	int num_dai_links;
1201
1202	struct list_head rtd_list;
1203	int num_rtd;
1204
1205	/* optional codec specific configuration */
1206	struct snd_soc_codec_conf *codec_conf;
1207	int num_configs;
1208
1209	/*
1210	 * optional auxiliary devices such as amplifiers or codecs with DAI
1211	 * link unused
1212	 */
1213	struct snd_soc_aux_dev *aux_dev;
1214	int num_aux_devs;
1215	struct list_head aux_comp_list;
1216
1217	const struct snd_kcontrol_new *controls;
1218	int num_controls;
1219
1220	/*
1221	 * Card-specific routes and widgets.
1222	 * Note: of_dapm_xxx for Device Tree; Otherwise for driver build-in.
1223	 */
1224	const struct snd_soc_dapm_widget *dapm_widgets;
1225	int num_dapm_widgets;
1226	const struct snd_soc_dapm_route *dapm_routes;
1227	int num_dapm_routes;
1228	const struct snd_soc_dapm_widget *of_dapm_widgets;
1229	int num_of_dapm_widgets;
1230	const struct snd_soc_dapm_route *of_dapm_routes;
1231	int num_of_dapm_routes;
1232	bool fully_routed;
1233
1234	struct work_struct deferred_resume_work;
1235
1236	/* lists of probed devices belonging to this card */
1237	struct list_head component_dev_list;
 
1238
1239	struct list_head widgets;
1240	struct list_head paths;
1241	struct list_head dapm_list;
1242	struct list_head dapm_dirty;
1243
1244	/* attached dynamic objects */
1245	struct list_head dobj_list;
1246
1247	/* Generic DAPM context for the card */
1248	struct snd_soc_dapm_context dapm;
1249	struct snd_soc_dapm_stats dapm_stats;
1250	struct snd_soc_dapm_update *update;
1251
1252#ifdef CONFIG_DEBUG_FS
1253	struct dentry *debugfs_card_root;
1254	struct dentry *debugfs_pop_time;
 
 
1255#endif
1256	u32 pop_time;
1257
 
 
 
 
 
 
 
 
1258	void *drvdata;
1259};
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1260
1261/* SoC machine DAI configuration, glues a codec and cpu DAI together */
1262struct snd_soc_pcm_runtime {
1263	struct device *dev;
1264	struct snd_soc_card *card;
1265	struct snd_soc_dai_link *dai_link;
1266	struct mutex pcm_mutex;
1267	enum snd_soc_pcm_subclass pcm_subclass;
1268	struct snd_pcm_ops ops;
1269
 
 
1270	/* Dynamic PCM BE runtime data */
1271	struct snd_soc_dpcm_runtime dpcm[2];
1272	int fe_compr;
1273
1274	long pmdown_time;
1275
1276	/* runtime devices */
1277	struct snd_pcm *pcm;
1278	struct snd_compr *compr;
1279	struct snd_soc_codec *codec;
1280	struct snd_soc_platform *platform; /* will be removed */
1281	struct snd_soc_dai *codec_dai;
1282	struct snd_soc_dai *cpu_dai;
1283
1284	struct snd_soc_dai **codec_dais;
1285	unsigned int num_codecs;
 
 
 
 
 
 
1286
1287	struct delayed_work delayed_work;
 
1288#ifdef CONFIG_DEBUG_FS
1289	struct dentry *debugfs_dpcm_root;
1290#endif
1291
1292	unsigned int num; /* 0-based and monotonic increasing */
1293	struct list_head list; /* rtd list of the soc card */
1294	struct list_head component_list; /* list of connected components */
 
 
 
 
 
1295
1296	/* bit field */
1297	unsigned int dev_registered:1;
1298	unsigned int pop_wait:1;
 
 
 
 
 
 
1299};
1300
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1301/* mixer control */
1302struct soc_mixer_control {
1303	int min, max, platform_max;
1304	int reg, rreg;
1305	unsigned int shift, rshift;
1306	unsigned int sign_bit;
1307	unsigned int invert:1;
1308	unsigned int autodisable:1;
 
1309	struct snd_soc_dobj dobj;
 
1310};
1311
1312struct soc_bytes {
1313	int base;
1314	int num_regs;
1315	u32 mask;
1316};
1317
1318struct soc_bytes_ext {
1319	int max;
 
1320	struct snd_soc_dobj dobj;
1321
1322	/* used for TLV byte control */
1323	int (*get)(struct snd_kcontrol *kcontrol, unsigned int __user *bytes,
1324			unsigned int size);
1325	int (*put)(struct snd_kcontrol *kcontrol, const unsigned int __user *bytes,
1326			unsigned int size);
1327};
1328
1329/* multi register control */
1330struct soc_mreg_control {
1331	long min, max;
1332	unsigned int regbase, regcount, nbits, invert;
1333};
1334
1335/* enumerated kcontrol */
1336struct soc_enum {
1337	int reg;
1338	unsigned char shift_l;
1339	unsigned char shift_r;
1340	unsigned int items;
1341	unsigned int mask;
1342	const char * const *texts;
1343	const unsigned int *values;
1344	unsigned int autodisable:1;
 
1345	struct snd_soc_dobj dobj;
1346};
1347
1348/**
1349 * snd_soc_component_to_codec() - Casts a component to the CODEC it is embedded in
1350 * @component: The component to cast to a CODEC
1351 *
1352 * This function must only be used on components that are known to be CODECs.
1353 * Otherwise the behavior is undefined.
1354 */
1355static inline struct snd_soc_codec *snd_soc_component_to_codec(
1356	struct snd_soc_component *component)
1357{
1358	return container_of(component, struct snd_soc_codec, component);
1359}
1360
1361/**
1362 * snd_soc_component_to_platform() - Casts a component to the platform it is embedded in
1363 * @component: The component to cast to a platform
1364 *
1365 * This function must only be used on components that are known to be platforms.
1366 * Otherwise the behavior is undefined.
1367 */
1368static inline struct snd_soc_platform *snd_soc_component_to_platform(
1369	struct snd_soc_component *component)
1370{
1371	return container_of(component, struct snd_soc_platform, component);
1372}
1373
1374/**
1375 * snd_soc_dapm_to_component() - Casts a DAPM context to the component it is
1376 *  embedded in
1377 * @dapm: The DAPM context to cast to the component
1378 *
1379 * This function must only be used on DAPM contexts that are known to be part of
1380 * a component (e.g. in a component driver). Otherwise the behavior is
1381 * undefined.
1382 */
1383static inline struct snd_soc_component *snd_soc_dapm_to_component(
1384	struct snd_soc_dapm_context *dapm)
1385{
1386	return container_of(dapm, struct snd_soc_component, dapm);
1387}
1388
1389/**
1390 * snd_soc_dapm_to_codec() - Casts a DAPM context to the CODEC it is embedded in
1391 * @dapm: The DAPM context to cast to the CODEC
1392 *
1393 * This function must only be used on DAPM contexts that are known to be part of
1394 * a CODEC (e.g. in a CODEC driver). Otherwise the behavior is undefined.
1395 */
1396static inline struct snd_soc_codec *snd_soc_dapm_to_codec(
1397	struct snd_soc_dapm_context *dapm)
1398{
1399	return snd_soc_component_to_codec(snd_soc_dapm_to_component(dapm));
1400}
1401
1402/**
1403 * snd_soc_dapm_to_platform() - Casts a DAPM context to the platform it is
1404 *  embedded in
1405 * @dapm: The DAPM context to cast to the platform.
1406 *
1407 * This function must only be used on DAPM contexts that are known to be part of
1408 * a platform (e.g. in a platform driver). Otherwise the behavior is undefined.
1409 */
1410static inline struct snd_soc_platform *snd_soc_dapm_to_platform(
1411	struct snd_soc_dapm_context *dapm)
1412{
1413	return snd_soc_component_to_platform(snd_soc_dapm_to_component(dapm));
1414}
1415
1416/**
1417 * snd_soc_component_get_dapm() - Returns the DAPM context associated with a
1418 *  component
1419 * @component: The component for which to get the DAPM context
1420 */
1421static inline struct snd_soc_dapm_context *snd_soc_component_get_dapm(
1422	struct snd_soc_component *component)
1423{
1424	return &component->dapm;
1425}
1426
1427/**
1428 * snd_soc_codec_get_dapm() - Returns the DAPM context for the CODEC
1429 * @codec: The CODEC for which to get the DAPM context
1430 *
1431 * Note: Use this function instead of directly accessing the CODEC's dapm field
1432 */
1433static inline struct snd_soc_dapm_context *snd_soc_codec_get_dapm(
1434	struct snd_soc_codec *codec)
1435{
1436	return snd_soc_component_get_dapm(&codec->component);
1437}
1438
1439/**
1440 * snd_soc_dapm_init_bias_level() - Initialize CODEC DAPM bias level
1441 * @codec: The CODEC for which to initialize the DAPM bias level
1442 * @level: The DAPM level to initialize to
1443 *
1444 * Initializes the CODEC DAPM bias level. See snd_soc_dapm_init_bias_level().
1445 */
1446static inline void snd_soc_codec_init_bias_level(struct snd_soc_codec *codec,
1447	enum snd_soc_bias_level level)
1448{
1449	snd_soc_dapm_init_bias_level(snd_soc_codec_get_dapm(codec), level);
1450}
1451
1452/**
1453 * snd_soc_component_init_bias_level() - Initialize COMPONENT DAPM bias level
1454 * @component: The COMPONENT for which to initialize the DAPM bias level
1455 * @level: The DAPM level to initialize to
1456 *
1457 * Initializes the COMPONENT DAPM bias level. See snd_soc_dapm_init_bias_level().
1458 */
1459static inline void
1460snd_soc_component_init_bias_level(struct snd_soc_component *component,
1461				  enum snd_soc_bias_level level)
1462{
1463	snd_soc_dapm_init_bias_level(
1464		snd_soc_component_get_dapm(component), level);
1465}
1466
1467/**
1468 * snd_soc_dapm_get_bias_level() - Get current CODEC DAPM bias level
1469 * @codec: The CODEC for which to get the DAPM bias level
1470 *
1471 * Returns: The current DAPM bias level of the CODEC.
1472 */
1473static inline enum snd_soc_bias_level snd_soc_codec_get_bias_level(
1474	struct snd_soc_codec *codec)
1475{
1476	return snd_soc_dapm_get_bias_level(snd_soc_codec_get_dapm(codec));
1477}
1478
1479/**
1480 * snd_soc_component_get_bias_level() - Get current COMPONENT DAPM bias level
1481 * @component: The COMPONENT for which to get the DAPM bias level
1482 *
1483 * Returns: The current DAPM bias level of the COMPONENT.
1484 */
1485static inline enum snd_soc_bias_level
1486snd_soc_component_get_bias_level(struct snd_soc_component *component)
1487{
1488	return snd_soc_dapm_get_bias_level(
1489		snd_soc_component_get_dapm(component));
1490}
1491
1492/**
1493 * snd_soc_codec_force_bias_level() - Set the CODEC DAPM bias level
1494 * @codec: The CODEC for which to set the level
1495 * @level: The level to set to
1496 *
1497 * Forces the CODEC bias level to a specific state. See
1498 * snd_soc_dapm_force_bias_level().
1499 */
1500static inline int snd_soc_codec_force_bias_level(struct snd_soc_codec *codec,
1501	enum snd_soc_bias_level level)
1502{
1503	return snd_soc_dapm_force_bias_level(snd_soc_codec_get_dapm(codec),
1504		level);
1505}
1506
1507/**
1508 * snd_soc_component_force_bias_level() - Set the COMPONENT DAPM bias level
1509 * @component: The COMPONENT for which to set the level
1510 * @level: The level to set to
1511 *
1512 * Forces the COMPONENT bias level to a specific state. See
1513 * snd_soc_dapm_force_bias_level().
1514 */
1515static inline int
1516snd_soc_component_force_bias_level(struct snd_soc_component *component,
1517				   enum snd_soc_bias_level level)
1518{
1519	return snd_soc_dapm_force_bias_level(
1520		snd_soc_component_get_dapm(component),
1521		level);
1522}
1523
1524/**
1525 * snd_soc_dapm_kcontrol_codec() - Returns the codec associated to a kcontrol
1526 * @kcontrol: The kcontrol
1527 *
1528 * This function must only be used on DAPM contexts that are known to be part of
1529 * a CODEC (e.g. in a CODEC driver). Otherwise the behavior is undefined.
1530 */
1531static inline struct snd_soc_codec *snd_soc_dapm_kcontrol_codec(
1532	struct snd_kcontrol *kcontrol)
1533{
1534	return snd_soc_dapm_to_codec(snd_soc_dapm_kcontrol_dapm(kcontrol));
1535}
1536
1537/**
1538 * snd_soc_dapm_kcontrol_component() - Returns the component associated to a kcontrol
1539 * @kcontrol: The kcontrol
1540 *
1541 * This function must only be used on DAPM contexts that are known to be part of
1542 * a COMPONENT (e.g. in a COMPONENT driver). Otherwise the behavior is undefined.
1543 */
1544static inline struct snd_soc_component *snd_soc_dapm_kcontrol_component(
1545	struct snd_kcontrol *kcontrol)
1546{
1547	return snd_soc_dapm_to_component(snd_soc_dapm_kcontrol_dapm(kcontrol));
1548}
1549
1550/* codec IO */
1551unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg);
1552int snd_soc_write(struct snd_soc_codec *codec, unsigned int reg,
1553	unsigned int val);
1554
1555/**
1556 * snd_soc_cache_sync() - Sync the register cache with the hardware
1557 * @codec: CODEC to sync
1558 *
1559 * Note: This function will call regcache_sync()
1560 */
1561static inline int snd_soc_cache_sync(struct snd_soc_codec *codec)
1562{
1563	return regcache_sync(codec->component.regmap);
1564}
1565
1566/**
1567 * snd_soc_component_cache_sync() - Sync the register cache with the hardware
1568 * @component: COMPONENT to sync
1569 *
1570 * Note: This function will call regcache_sync()
1571 */
1572static inline int snd_soc_component_cache_sync(
1573	struct snd_soc_component *component)
1574{
1575	return regcache_sync(component->regmap);
1576}
1577
1578/* component IO */
1579int snd_soc_component_read(struct snd_soc_component *component,
1580	unsigned int reg, unsigned int *val);
1581unsigned int snd_soc_component_read32(struct snd_soc_component *component,
1582				      unsigned int reg);
1583int snd_soc_component_write(struct snd_soc_component *component,
1584	unsigned int reg, unsigned int val);
1585int snd_soc_component_update_bits(struct snd_soc_component *component,
1586	unsigned int reg, unsigned int mask, unsigned int val);
1587int snd_soc_component_update_bits_async(struct snd_soc_component *component,
1588	unsigned int reg, unsigned int mask, unsigned int val);
1589void snd_soc_component_async_complete(struct snd_soc_component *component);
1590int snd_soc_component_test_bits(struct snd_soc_component *component,
1591	unsigned int reg, unsigned int mask, unsigned int value);
1592
1593/* component wide operations */
1594int snd_soc_component_set_sysclk(struct snd_soc_component *component,
1595			int clk_id, int source, unsigned int freq, int dir);
1596int snd_soc_component_set_pll(struct snd_soc_component *component, int pll_id,
1597			      int source, unsigned int freq_in,
1598			      unsigned int freq_out);
1599int snd_soc_component_set_jack(struct snd_soc_component *component,
1600			       struct snd_soc_jack *jack, void *data);
1601
1602#ifdef CONFIG_REGMAP
1603
1604void snd_soc_component_init_regmap(struct snd_soc_component *component,
1605	struct regmap *regmap);
1606void snd_soc_component_exit_regmap(struct snd_soc_component *component);
1607
1608/**
1609 * snd_soc_codec_init_regmap() - Initialize regmap instance for the CODEC
1610 * @codec: The CODEC for which to initialize the regmap instance
1611 * @regmap: The regmap instance that should be used by the CODEC
1612 *
1613 * This function allows deferred assignment of the regmap instance that is
1614 * associated with the CODEC. Only use this if the regmap instance is not yet
1615 * ready when the CODEC is registered. The function must also be called before
1616 * the first IO attempt of the CODEC.
1617 */
1618static inline void snd_soc_codec_init_regmap(struct snd_soc_codec *codec,
1619	struct regmap *regmap)
1620{
1621	snd_soc_component_init_regmap(&codec->component, regmap);
1622}
1623
1624/**
1625 * snd_soc_codec_exit_regmap() - De-initialize regmap instance for the CODEC
1626 * @codec: The CODEC for which to de-initialize the regmap instance
1627 *
1628 * Calls regmap_exit() on the regmap instance associated to the CODEC and
1629 * removes the regmap instance from the CODEC.
1630 *
1631 * This function should only be used if snd_soc_codec_init_regmap() was used to
1632 * initialize the regmap instance.
1633 */
1634static inline void snd_soc_codec_exit_regmap(struct snd_soc_codec *codec)
1635{
1636	snd_soc_component_exit_regmap(&codec->component);
1637}
1638
1639#endif
1640
1641/* device driver data */
1642
1643static inline void snd_soc_card_set_drvdata(struct snd_soc_card *card,
1644		void *data)
1645{
1646	card->drvdata = data;
1647}
1648
1649static inline void *snd_soc_card_get_drvdata(struct snd_soc_card *card)
1650{
1651	return card->drvdata;
1652}
1653
1654static inline void snd_soc_component_set_drvdata(struct snd_soc_component *c,
1655		void *data)
1656{
1657	dev_set_drvdata(c->dev, data);
1658}
1659
1660static inline void *snd_soc_component_get_drvdata(struct snd_soc_component *c)
1661{
1662	return dev_get_drvdata(c->dev);
1663}
1664
1665static inline void snd_soc_codec_set_drvdata(struct snd_soc_codec *codec,
1666		void *data)
1667{
1668	snd_soc_component_set_drvdata(&codec->component, data);
1669}
1670
1671static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec)
1672{
1673	return snd_soc_component_get_drvdata(&codec->component);
1674}
1675
1676static inline void snd_soc_platform_set_drvdata(struct snd_soc_platform *platform,
1677		void *data)
1678{
1679	snd_soc_component_set_drvdata(&platform->component, data);
1680}
1681
1682static inline void *snd_soc_platform_get_drvdata(struct snd_soc_platform *platform)
1683{
1684	return snd_soc_component_get_drvdata(&platform->component);
1685}
1686
1687static inline void snd_soc_initialize_card_lists(struct snd_soc_card *card)
1688{
1689	INIT_LIST_HEAD(&card->widgets);
1690	INIT_LIST_HEAD(&card->paths);
1691	INIT_LIST_HEAD(&card->dapm_list);
1692	INIT_LIST_HEAD(&card->aux_comp_list);
1693	INIT_LIST_HEAD(&card->component_dev_list);
1694}
1695
1696static inline bool snd_soc_volsw_is_stereo(struct soc_mixer_control *mc)
1697{
1698	if (mc->reg == mc->rreg && mc->shift == mc->rshift)
1699		return 0;
1700	/*
1701	 * mc->reg == mc->rreg && mc->shift != mc->rshift, or
1702	 * mc->reg != mc->rreg means that the control is
1703	 * stereo (bits in one register or in two registers)
1704	 */
1705	return 1;
1706}
1707
1708static inline unsigned int snd_soc_enum_val_to_item(struct soc_enum *e,
1709	unsigned int val)
1710{
1711	unsigned int i;
1712
1713	if (!e->values)
1714		return val;
1715
1716	for (i = 0; i < e->items; i++)
1717		if (val == e->values[i])
1718			return i;
1719
1720	return 0;
1721}
1722
1723static inline unsigned int snd_soc_enum_item_to_val(struct soc_enum *e,
1724	unsigned int item)
1725{
1726	if (!e->values)
1727		return item;
1728
1729	return e->values[item];
1730}
1731
1732static inline bool snd_soc_component_is_active(
1733	struct snd_soc_component *component)
1734{
1735	return component->active != 0;
1736}
1737
1738static inline bool snd_soc_codec_is_active(struct snd_soc_codec *codec)
1739{
1740	return snd_soc_component_is_active(&codec->component);
1741}
1742
1743/**
1744 * snd_soc_kcontrol_component() - Returns the component that registered the
1745 *  control
1746 * @kcontrol: The control for which to get the component
1747 *
1748 * Note: This function will work correctly if the control has been registered
1749 * for a component. Either with snd_soc_add_codec_controls() or
1750 * snd_soc_add_platform_controls() or via  table based setup for either a
1751 * CODEC, a platform or component driver. Otherwise the behavior is undefined.
1752 */
1753static inline struct snd_soc_component *snd_soc_kcontrol_component(
1754	struct snd_kcontrol *kcontrol)
1755{
1756	return snd_kcontrol_chip(kcontrol);
1757}
1758
1759/**
1760 * snd_soc_kcontrol_codec() - Returns the CODEC that registered the control
1761 * @kcontrol: The control for which to get the CODEC
1762 *
1763 * Note: This function will only work correctly if the control has been
1764 * registered with snd_soc_add_codec_controls() or via table based setup of
1765 * snd_soc_codec_driver. Otherwise the behavior is undefined.
1766 */
1767static inline struct snd_soc_codec *snd_soc_kcontrol_codec(
1768	struct snd_kcontrol *kcontrol)
1769{
1770	return snd_soc_component_to_codec(snd_soc_kcontrol_component(kcontrol));
1771}
1772
1773/**
1774 * snd_soc_kcontrol_platform() - Returns the platform that registered the control
1775 * @kcontrol: The control for which to get the platform
1776 *
1777 * Note: This function will only work correctly if the control has been
1778 * registered with snd_soc_add_platform_controls() or via table based setup of
1779 * a snd_soc_platform_driver. Otherwise the behavior is undefined.
1780 */
1781static inline struct snd_soc_platform *snd_soc_kcontrol_platform(
1782	struct snd_kcontrol *kcontrol)
1783{
1784	return snd_soc_component_to_platform(snd_soc_kcontrol_component(kcontrol));
1785}
1786
1787int snd_soc_util_init(void);
1788void snd_soc_util_exit(void);
1789
1790int snd_soc_of_parse_card_name(struct snd_soc_card *card,
1791			       const char *propname);
1792int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
1793					  const char *propname);
 
 
 
 
1794int snd_soc_of_parse_tdm_slot(struct device_node *np,
1795			      unsigned int *tx_mask,
1796			      unsigned int *rx_mask,
1797			      unsigned int *slots,
1798			      unsigned int *slot_width);
1799void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
1800				   struct snd_soc_codec_conf *codec_conf,
1801				   struct device_node *of_node,
1802				   const char *propname);
 
 
 
 
 
 
 
 
 
 
1803int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
1804				   const char *propname);
1805unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
1806				     const char *prefix,
1807				     struct device_node **bitclkmaster,
1808				     struct device_node **framemaster);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1809int snd_soc_get_dai_id(struct device_node *ep);
1810int snd_soc_get_dai_name(struct of_phandle_args *args,
1811			 const char **dai_name);
1812int snd_soc_of_get_dai_name(struct device_node *of_node,
1813			    const char **dai_name);
1814int snd_soc_of_get_dai_link_codecs(struct device *dev,
1815				   struct device_node *of_node,
1816				   struct snd_soc_dai_link *dai_link);
1817void snd_soc_of_put_dai_link_codecs(struct snd_soc_dai_link *dai_link);
1818
1819int snd_soc_add_dai_link(struct snd_soc_card *card,
1820				struct snd_soc_dai_link *dai_link);
1821void snd_soc_remove_dai_link(struct snd_soc_card *card,
1822			     struct snd_soc_dai_link *dai_link);
1823struct snd_soc_dai_link *snd_soc_find_dai_link(struct snd_soc_card *card,
1824					       int id, const char *name,
1825					       const char *stream_name);
1826
1827int snd_soc_register_dai(struct snd_soc_component *component,
1828	struct snd_soc_dai_driver *dai_drv);
 
 
 
 
 
 
 
 
 
 
 
 
 
1829
1830struct snd_soc_dai *snd_soc_find_dai(
1831	const struct snd_soc_dai_link_component *dlc);
 
 
1832
1833#include <sound/soc-dai.h>
1834
1835static inline
1836struct snd_soc_dai *snd_soc_card_get_codec_dai(struct snd_soc_card *card,
1837					       const char *dai_name)
1838{
1839	struct snd_soc_pcm_runtime *rtd;
 
 
 
 
 
1840
1841	list_for_each_entry(rtd, &card->rtd_list, list) {
1842		if (!strcmp(rtd->codec_dai->name, dai_name))
1843			return rtd->codec_dai;
 
 
 
 
 
 
 
 
 
 
 
 
1844	}
1845
1846	return NULL;
1847}
1848
1849#ifdef CONFIG_DEBUG_FS
1850extern struct dentry *snd_soc_debugfs_root;
1851#endif
1852
1853extern const struct dev_pm_ops snd_soc_pm_ops;
1854
1855/* Helper functions */
1856static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1857{
1858	mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
1859}
1860
1861static inline void snd_soc_dapm_mutex_unlock(struct snd_soc_dapm_context *dapm)
1862{
1863	mutex_unlock(&dapm->card->dapm_mutex);
1864}
1865
1866int snd_soc_component_enable_pin(struct snd_soc_component *component,
1867				 const char *pin);
1868int snd_soc_component_enable_pin_unlocked(struct snd_soc_component *component,
1869					  const char *pin);
1870int snd_soc_component_disable_pin(struct snd_soc_component *component,
1871				  const char *pin);
1872int snd_soc_component_disable_pin_unlocked(struct snd_soc_component *component,
1873					   const char *pin);
1874int snd_soc_component_nc_pin(struct snd_soc_component *component,
1875			     const char *pin);
1876int snd_soc_component_nc_pin_unlocked(struct snd_soc_component *component,
1877				      const char *pin);
1878int snd_soc_component_get_pin_status(struct snd_soc_component *component,
1879				     const char *pin);
1880int snd_soc_component_force_enable_pin(struct snd_soc_component *component,
1881				       const char *pin);
1882int snd_soc_component_force_enable_pin_unlocked(
1883					struct snd_soc_component *component,
1884					const char *pin);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1885
1886#endif