LXR linux/include/sound/soc.h

   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/platform_device.h>
  17#include <linux/types.h>
  18#include <linux/notifier.h>
  19#include <linux/workqueue.h>
  20#include <linux/interrupt.h>
  21#include <linux/kernel.h>
  22#include <linux/regmap.h>
  23#include <sound/core.h>
  24#include <sound/pcm.h>
  25#include <sound/control.h>
  26#include <sound/ac97_codec.h>
  27
  28/*
  29 * Convenience kcontrol builders
  30 */
  31#define SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, xmax, xinvert) \
  32        ((unsigned long)&(struct soc_mixer_control) \
  33        {.reg = xreg, .rreg = xreg, .shift = shift_left, \
  34        .rshift = shift_right, .max = xmax, .platform_max = xmax, \
  35        .invert = xinvert})
  36#define SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) \
  37        SOC_DOUBLE_VALUE(xreg, xshift, xshift, xmax, xinvert)
  38#define SOC_SINGLE_VALUE_EXT(xreg, xmax, xinvert) \
  39        ((unsigned long)&(struct soc_mixer_control) \
  40        {.reg = xreg, .max = xmax, .platform_max = xmax, .invert = xinvert})
  41#define SOC_DOUBLE_R_VALUE(xlreg, xrreg, xshift, xmax, xinvert) \
  42        ((unsigned long)&(struct soc_mixer_control) \
  43        {.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
  44        .max = xmax, .platform_max = xmax, .invert = xinvert})
  45#define SOC_SINGLE(xname, reg, shift, max, invert) \
  46{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
  47        .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
  48        .put = snd_soc_put_volsw, \
  49        .private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }
  50#define SOC_SINGLE_TLV(xname, reg, shift, max, invert, tlv_array) \
  51{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
  52        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
  53                 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
  54        .tlv.p = (tlv_array), \
  55        .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
  56        .put = snd_soc_put_volsw, \
  57        .private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }
  58#define SOC_DOUBLE(xname, reg, shift_left, shift_right, max, invert) \
  59{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
  60        .info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
  61        .put = snd_soc_put_volsw, \
  62        .private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
  63                                          max, invert) }
  64#define SOC_DOUBLE_R(xname, reg_left, reg_right, xshift, xmax, xinvert) \
  65{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
  66        .info = snd_soc_info_volsw, \
  67        .get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
  68        .private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
  69                                            xmax, xinvert) }
  70#define SOC_DOUBLE_TLV(xname, reg, shift_left, shift_right, max, invert, tlv_array) \
  71{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
  72        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
  73                 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
  74        .tlv.p = (tlv_array), \
  75        .info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
  76        .put = snd_soc_put_volsw, \
  77        .private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
  78                                          max, invert) }
  79#define SOC_DOUBLE_R_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert, tlv_array) \
  80{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
  81        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
  82                 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
  83        .tlv.p = (tlv_array), \
  84        .info = snd_soc_info_volsw, \
  85        .get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
  86        .private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
  87                                            xmax, xinvert) }
  88#define SOC_DOUBLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
  89{       .iface  = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
  90        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
  91                  SNDRV_CTL_ELEM_ACCESS_READWRITE, \
  92        .tlv.p  = (tlv_array), \
  93        .info   = snd_soc_info_volsw_s8, .get = snd_soc_get_volsw_s8, \
  94        .put    = snd_soc_put_volsw_s8, \
  95        .private_value = (unsigned long)&(struct soc_mixer_control) \
  96                {.reg = xreg, .min = xmin, .max = xmax, \
  97                 .platform_max = xmax} }
  98#define SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmax, xtexts) \
  99{       .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
 100        .max = xmax, .texts = xtexts }
 101#define SOC_ENUM_SINGLE(xreg, xshift, xmax, xtexts) \
 102        SOC_ENUM_DOUBLE(xreg, xshift, xshift, xmax, xtexts)
 103#define SOC_ENUM_SINGLE_EXT(xmax, xtexts) \
 104{       .max = xmax, .texts = xtexts }
 105#define SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, xmax, xtexts, xvalues) \
 106{       .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
 107        .mask = xmask, .max = xmax, .texts = xtexts, .values = xvalues}
 108#define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xmax, xtexts, xvalues) \
 109        SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xmax, xtexts, xvalues)
 110#define SOC_ENUM(xname, xenum) \
 111{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
 112        .info = snd_soc_info_enum_double, \
 113        .get = snd_soc_get_enum_double, .put = snd_soc_put_enum_double, \
 114        .private_value = (unsigned long)&xenum }
 115#define SOC_VALUE_ENUM(xname, xenum) \
 116{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
 117        .info = snd_soc_info_enum_double, \
 118        .get = snd_soc_get_value_enum_double, \
 119        .put = snd_soc_put_value_enum_double, \
 120        .private_value = (unsigned long)&xenum }
 121#define SOC_SINGLE_EXT(xname, xreg, xshift, xmax, xinvert,\
 122         xhandler_get, xhandler_put) \
 123{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 124        .info = snd_soc_info_volsw, \
 125        .get = xhandler_get, .put = xhandler_put, \
 126        .private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) }
 127#define SOC_DOUBLE_EXT(xname, reg, shift_left, shift_right, max, invert,\
 128         xhandler_get, xhandler_put) \
 129{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
 130        .info = snd_soc_info_volsw, \
 131        .get = xhandler_get, .put = xhandler_put, \
 132        .private_value = \
 133                SOC_DOUBLE_VALUE(reg, shift_left, shift_right, max, invert) }
 134#define SOC_SINGLE_EXT_TLV(xname, xreg, xshift, xmax, xinvert,\
 135         xhandler_get, xhandler_put, tlv_array) \
 136{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 137        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
 138                 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
 139        .tlv.p = (tlv_array), \
 140        .info = snd_soc_info_volsw, \
 141        .get = xhandler_get, .put = xhandler_put, \
 142        .private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) }
 143#define SOC_DOUBLE_EXT_TLV(xname, xreg, shift_left, shift_right, xmax, xinvert,\
 144         xhandler_get, xhandler_put, tlv_array) \
 145{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
 146        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
 147                 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
 148        .tlv.p = (tlv_array), \
 149        .info = snd_soc_info_volsw, \
 150        .get = xhandler_get, .put = xhandler_put, \
 151        .private_value = SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, \
 152                                          xmax, xinvert) }
 153#define SOC_DOUBLE_R_EXT_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert,\
 154         xhandler_get, xhandler_put, tlv_array) \
 155{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
 156        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
 157                 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
 158        .tlv.p = (tlv_array), \
 159        .info = snd_soc_info_volsw, \
 160        .get = xhandler_get, .put = xhandler_put, \
 161        .private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
 162                                            xmax, xinvert) }
 163#define SOC_SINGLE_BOOL_EXT(xname, xdata, xhandler_get, xhandler_put) \
 164{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 165        .info = snd_soc_info_bool_ext, \
 166        .get = xhandler_get, .put = xhandler_put, \
 167        .private_value = xdata }
 168#define SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
 169{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 170        .info = snd_soc_info_enum_ext, \
 171        .get = xhandler_get, .put = xhandler_put, \
 172        .private_value = (unsigned long)&xenum }
 173
 174#define SOC_DOUBLE_R_SX_TLV(xname, xreg_left, xreg_right, xshift,\
 175                xmin, xmax, tlv_array) \
 176{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
 177        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
 178                  SNDRV_CTL_ELEM_ACCESS_READWRITE, \
 179        .tlv.p = (tlv_array), \
 180        .info = snd_soc_info_volsw_2r_sx, \
 181        .get = snd_soc_get_volsw_2r_sx, \
 182        .put = snd_soc_put_volsw_2r_sx, \
 183        .private_value = (unsigned long)&(struct soc_mixer_control) \
 184                {.reg = xreg_left, \
 185                 .rreg = xreg_right, .shift = xshift, \
 186                 .min = xmin, .max = xmax} }
 187
 188
 189/*
 190 * Simplified versions of above macros, declaring a struct and calculating
 191 * ARRAY_SIZE internally
 192 */
 193#define SOC_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xtexts) \
 194        struct soc_enum name = SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, \
 195                                                ARRAY_SIZE(xtexts), xtexts)
 196#define SOC_ENUM_SINGLE_DECL(name, xreg, xshift, xtexts) \
 197        SOC_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xtexts)
 198#define SOC_ENUM_SINGLE_EXT_DECL(name, xtexts) \
 199        struct soc_enum name = SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(xtexts), xtexts)
 200#define SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xmask, xtexts, xvalues) \
 201        struct soc_enum name = SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, \
 202                                                        ARRAY_SIZE(xtexts), xtexts, xvalues)
 203#define SOC_VALUE_ENUM_SINGLE_DECL(name, xreg, xshift, xmask, xtexts, xvalues) \
 204        SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xmask, xtexts, xvalues)
 205
 206/*
 207 * Component probe and remove ordering levels for components with runtime
 208 * dependencies.
 209 */
 210#define SND_SOC_COMP_ORDER_FIRST                -2
 211#define SND_SOC_COMP_ORDER_EARLY                -1
 212#define SND_SOC_COMP_ORDER_NORMAL               0
 213#define SND_SOC_COMP_ORDER_LATE         1
 214#define SND_SOC_COMP_ORDER_LAST         2
 215
 216/*
 217 * Bias levels
 218 *
 219 * @ON:      Bias is fully on for audio playback and capture operations.
 220 * @PREPARE: Prepare for audio operations. Called before DAPM switching for
 221 *           stream start and stop operations.
 222 * @STANDBY: Low power standby state when no playback/capture operations are
 223 *           in progress. NOTE: The transition time between STANDBY and ON
 224 *           should be as fast as possible and no longer than 10ms.
 225 * @OFF:     Power Off. No restrictions on transition times.
 226 */
 227enum snd_soc_bias_level {
 228        SND_SOC_BIAS_OFF = 0,
 229        SND_SOC_BIAS_STANDBY = 1,
 230        SND_SOC_BIAS_PREPARE = 2,
 231        SND_SOC_BIAS_ON = 3,
 232};
 233
 234struct device_node;
 235struct snd_jack;
 236struct snd_soc_card;
 237struct snd_soc_pcm_stream;
 238struct snd_soc_ops;
 239struct snd_soc_pcm_runtime;
 240struct snd_soc_dai;
 241struct snd_soc_dai_driver;
 242struct snd_soc_platform;
 243struct snd_soc_dai_link;
 244struct snd_soc_platform_driver;
 245struct snd_soc_codec;
 246struct snd_soc_codec_driver;
 247struct soc_enum;
 248struct snd_soc_jack;
 249struct snd_soc_jack_zone;
 250struct snd_soc_jack_pin;
 251struct snd_soc_cache_ops;
 252#include <sound/soc-dapm.h>
 253
 254#ifdef CONFIG_GPIOLIB
 255struct snd_soc_jack_gpio;
 256#endif
 257
 258typedef int (*hw_write_t)(void *,const char* ,int);
 259
 260extern struct snd_ac97_bus_ops soc_ac97_ops;
 261
 262enum snd_soc_control_type {
 263        SND_SOC_I2C = 1,
 264        SND_SOC_SPI,
 265        SND_SOC_REGMAP,
 266};
 267
 268enum snd_soc_compress_type {
 269        SND_SOC_FLAT_COMPRESSION = 1,
 270};
 271
 272enum snd_soc_pcm_subclass {
 273        SND_SOC_PCM_CLASS_PCM   = 0,
 274        SND_SOC_PCM_CLASS_BE    = 1,
 275};
 276
 277int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
 278                             int source, unsigned int freq, int dir);
 279int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
 280                          unsigned int freq_in, unsigned int freq_out);
 281
 282int snd_soc_register_card(struct snd_soc_card *card);
 283int snd_soc_unregister_card(struct snd_soc_card *card);
 284int snd_soc_suspend(struct device *dev);
 285int snd_soc_resume(struct device *dev);
 286int snd_soc_poweroff(struct device *dev);
 287int snd_soc_register_platform(struct device *dev,
 288                struct snd_soc_platform_driver *platform_drv);
 289void snd_soc_unregister_platform(struct device *dev);
 290int snd_soc_register_codec(struct device *dev,
 291                const struct snd_soc_codec_driver *codec_drv,
 292                struct snd_soc_dai_driver *dai_drv, int num_dai);
 293void snd_soc_unregister_codec(struct device *dev);
 294int snd_soc_codec_volatile_register(struct snd_soc_codec *codec,
 295                                    unsigned int reg);
 296int snd_soc_codec_readable_register(struct snd_soc_codec *codec,
 297                                    unsigned int reg);
 298int snd_soc_codec_writable_register(struct snd_soc_codec *codec,
 299                                    unsigned int reg);
 300int snd_soc_codec_set_cache_io(struct snd_soc_codec *codec,
 301                               int addr_bits, int data_bits,
 302                               enum snd_soc_control_type control);
 303int snd_soc_cache_sync(struct snd_soc_codec *codec);
 304int snd_soc_cache_init(struct snd_soc_codec *codec);
 305int snd_soc_cache_exit(struct snd_soc_codec *codec);
 306int snd_soc_cache_write(struct snd_soc_codec *codec,
 307                        unsigned int reg, unsigned int value);
 308int snd_soc_cache_read(struct snd_soc_codec *codec,
 309                       unsigned int reg, unsigned int *value);
 310int snd_soc_default_volatile_register(struct snd_soc_codec *codec,
 311                                      unsigned int reg);
 312int snd_soc_default_readable_register(struct snd_soc_codec *codec,
 313                                      unsigned int reg);
 314int snd_soc_default_writable_register(struct snd_soc_codec *codec,
 315                                      unsigned int reg);
 316int snd_soc_platform_read(struct snd_soc_platform *platform,
 317                                        unsigned int reg);
 318int snd_soc_platform_write(struct snd_soc_platform *platform,
 319                                        unsigned int reg, unsigned int val);
 320int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
 321
 322/* Utility functions to get clock rates from various things */
 323int snd_soc_calc_frame_size(int sample_size, int channels, int tdm_slots);
 324int snd_soc_params_to_frame_size(struct snd_pcm_hw_params *params);
 325int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
 326int snd_soc_params_to_bclk(struct snd_pcm_hw_params *parms);
 327
 328/* set runtime hw params */
 329int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
 330        const struct snd_pcm_hardware *hw);
 331
 332/* Jack reporting */
 333int snd_soc_jack_new(struct snd_soc_codec *codec, const char *id, int type,
 334                     struct snd_soc_jack *jack);
 335void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask);
 336int snd_soc_jack_add_pins(struct snd_soc_jack *jack, int count,
 337                          struct snd_soc_jack_pin *pins);
 338void snd_soc_jack_notifier_register(struct snd_soc_jack *jack,
 339                                    struct notifier_block *nb);
 340void snd_soc_jack_notifier_unregister(struct snd_soc_jack *jack,
 341                                      struct notifier_block *nb);
 342int snd_soc_jack_add_zones(struct snd_soc_jack *jack, int count,
 343                          struct snd_soc_jack_zone *zones);
 344int snd_soc_jack_get_type(struct snd_soc_jack *jack, int micbias_voltage);
 345#ifdef CONFIG_GPIOLIB
 346int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
 347                        struct snd_soc_jack_gpio *gpios);
 348void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
 349                        struct snd_soc_jack_gpio *gpios);
 350#endif
 351
 352/* codec register bit access */
 353int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
 354                                unsigned int mask, unsigned int value);
 355int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
 356                               unsigned short reg, unsigned int mask,
 357                               unsigned int value);
 358int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
 359                                unsigned int mask, unsigned int value);
 360
 361int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
 362        struct snd_ac97_bus_ops *ops, int num);
 363void snd_soc_free_ac97_codec(struct snd_soc_codec *codec);
 364
 365/*
 366 *Controls
 367 */
 368struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
 369                                  void *data, char *long_name,
 370                                  const char *prefix);
 371int snd_soc_add_controls(struct snd_soc_codec *codec,
 372        const struct snd_kcontrol_new *controls, int num_controls);
 373int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
 374        const struct snd_kcontrol_new *controls, int num_controls);
 375int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
 376        struct snd_ctl_elem_info *uinfo);
 377int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
 378        struct snd_ctl_elem_info *uinfo);
 379int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
 380        struct snd_ctl_elem_value *ucontrol);
 381int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
 382        struct snd_ctl_elem_value *ucontrol);
 383int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol,
 384        struct snd_ctl_elem_value *ucontrol);
 385int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol,
 386        struct snd_ctl_elem_value *ucontrol);
 387int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
 388        struct snd_ctl_elem_info *uinfo);
 389int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
 390        struct snd_ctl_elem_info *uinfo);
 391#define snd_soc_info_bool_ext           snd_ctl_boolean_mono_info
 392int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
 393        struct snd_ctl_elem_value *ucontrol);
 394int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
 395        struct snd_ctl_elem_value *ucontrol);
 396#define snd_soc_get_volsw_2r snd_soc_get_volsw
 397#define snd_soc_put_volsw_2r snd_soc_put_volsw
 398int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
 399        struct snd_ctl_elem_info *uinfo);
 400int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
 401        struct snd_ctl_elem_value *ucontrol);
 402int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
 403        struct snd_ctl_elem_value *ucontrol);
 404int snd_soc_limit_volume(struct snd_soc_codec *codec,
 405        const char *name, int max);
 406int snd_soc_info_volsw_2r_sx(struct snd_kcontrol *kcontrol,
 407        struct snd_ctl_elem_info *uinfo);
 408int snd_soc_get_volsw_2r_sx(struct snd_kcontrol *kcontrol,
 409        struct snd_ctl_elem_value *ucontrol);
 410int snd_soc_put_volsw_2r_sx(struct snd_kcontrol *kcontrol,
 411        struct snd_ctl_elem_value *ucontrol);
 412
 413/**
 414 * struct snd_soc_reg_access - Describes whether a given register is
 415 * readable, writable or volatile.
 416 *
 417 * @reg: the register number
 418 * @read: whether this register is readable
 419 * @write: whether this register is writable
 420 * @vol: whether this register is volatile
 421 */
 422struct snd_soc_reg_access {
 423        u16 reg;
 424        u16 read;
 425        u16 write;
 426        u16 vol;
 427};
 428
 429/**
 430 * struct snd_soc_jack_pin - Describes a pin to update based on jack detection
 431 *
 432 * @pin:    name of the pin to update
 433 * @mask:   bits to check for in reported jack status
 434 * @invert: if non-zero then pin is enabled when status is not reported
 435 */
 436struct snd_soc_jack_pin {
 437        struct list_head list;
 438        const char *pin;
 439        int mask;
 440        bool invert;
 441};
 442
 443/**
 444 * struct snd_soc_jack_zone - Describes voltage zones of jack detection
 445 *
 446 * @min_mv: start voltage in mv
 447 * @max_mv: end voltage in mv
 448 * @jack_type: type of jack that is expected for this voltage
 449 * @debounce_time: debounce_time for jack, codec driver should wait for this
 450 *              duration before reading the adc for voltages
 451 * @:list: list container
 452 */
 453struct snd_soc_jack_zone {
 454        unsigned int min_mv;
 455        unsigned int max_mv;
 456        unsigned int jack_type;
 457        unsigned int debounce_time;
 458        struct list_head list;
 459};
 460
 461/**
 462 * struct snd_soc_jack_gpio - Describes a gpio pin for jack detection
 463 *
 464 * @gpio:         gpio number
 465 * @name:         gpio name
 466 * @report:       value to report when jack detected
 467 * @invert:       report presence in low state
 468 * @debouce_time: debouce time in ms
 469 * @wake:         enable as wake source
 470 * @jack_status_check: callback function which overrides the detection
 471 *                     to provide more complex checks (eg, reading an
 472 *                     ADC).
 473 */
 474#ifdef CONFIG_GPIOLIB
 475struct snd_soc_jack_gpio {
 476        unsigned int gpio;
 477        const char *name;
 478        int report;
 479        int invert;
 480        int debounce_time;
 481        bool wake;
 482
 483        struct snd_soc_jack *jack;
 484        struct delayed_work work;
 485
 486        int (*jack_status_check)(void);
 487};
 488#endif
 489
 490struct snd_soc_jack {
 491        struct snd_jack *jack;
 492        struct snd_soc_codec *codec;
 493        struct list_head pins;
 494        int status;
 495        struct blocking_notifier_head notifier;
 496        struct list_head jack_zones;
 497};
 498
 499/* SoC PCM stream information */
 500struct snd_soc_pcm_stream {
 501        const char *stream_name;
 502        u64 formats;                    /* SNDRV_PCM_FMTBIT_* */
 503        unsigned int rates;             /* SNDRV_PCM_RATE_* */
 504        unsigned int rate_min;          /* min rate */
 505        unsigned int rate_max;          /* max rate */
 506        unsigned int channels_min;      /* min channels */
 507        unsigned int channels_max;      /* max channels */
 508};
 509
 510/* SoC audio ops */
 511struct snd_soc_ops {
 512        int (*startup)(struct snd_pcm_substream *);
 513        void (*shutdown)(struct snd_pcm_substream *);
 514        int (*hw_params)(struct snd_pcm_substream *, struct snd_pcm_hw_params *);
 515        int (*hw_free)(struct snd_pcm_substream *);
 516        int (*prepare)(struct snd_pcm_substream *);
 517        int (*trigger)(struct snd_pcm_substream *, int);
 518};
 519
 520/* SoC cache ops */
 521struct snd_soc_cache_ops {
 522        const char *name;
 523        enum snd_soc_compress_type id;
 524        int (*init)(struct snd_soc_codec *codec);
 525        int (*exit)(struct snd_soc_codec *codec);
 526        int (*read)(struct snd_soc_codec *codec, unsigned int reg,
 527                unsigned int *value);
 528        int (*write)(struct snd_soc_codec *codec, unsigned int reg,
 529                unsigned int value);
 530        int (*sync)(struct snd_soc_codec *codec);
 531};
 532
 533/* SoC Audio Codec device */
 534struct snd_soc_codec {
 535        const char *name;
 536        const char *name_prefix;
 537        int id;
 538        struct device *dev;
 539        const struct snd_soc_codec_driver *driver;
 540
 541        struct mutex mutex;
 542        struct snd_soc_card *card;
 543        struct list_head list;
 544        struct list_head card_list;
 545        int num_dai;
 546        enum snd_soc_compress_type compress_type;
 547        size_t reg_size;        /* reg_cache_size * reg_word_size */
 548        int (*volatile_register)(struct snd_soc_codec *, unsigned int);
 549        int (*readable_register)(struct snd_soc_codec *, unsigned int);
 550        int (*writable_register)(struct snd_soc_codec *, unsigned int);
 551
 552        /* runtime */
 553        struct snd_ac97 *ac97;  /* for ad-hoc ac97 devices */
 554        unsigned int active;
 555        unsigned int cache_bypass:1; /* Suppress access to the cache */
 556        unsigned int suspended:1; /* Codec is in suspend PM state */
 557        unsigned int probed:1; /* Codec has been probed */
 558        unsigned int ac97_registered:1; /* Codec has been AC97 registered */
 559        unsigned int ac97_created:1; /* Codec has been created by SoC */
 560        unsigned int sysfs_registered:1; /* codec has been sysfs registered */
 561        unsigned int cache_init:1; /* codec cache has been initialized */
 562        u32 cache_only;  /* Suppress writes to hardware */
 563        u32 cache_sync; /* Cache needs to be synced to hardware */
 564
 565        /* codec IO */
 566        void *control_data; /* codec control (i2c/3wire) data */
 567        enum snd_soc_control_type control_type;
 568        hw_write_t hw_write;
 569        unsigned int (*hw_read)(struct snd_soc_codec *, unsigned int);
 570        unsigned int (*read)(struct snd_soc_codec *, unsigned int);
 571        int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
 572        int (*bulk_write_raw)(struct snd_soc_codec *, unsigned int, const void *, size_t);
 573        void *reg_cache;
 574        const void *reg_def_copy;
 575        const struct snd_soc_cache_ops *cache_ops;
 576        struct mutex cache_rw_mutex;
 577        int val_bytes;
 578
 579        /* dapm */
 580        struct snd_soc_dapm_context dapm;
 581        unsigned int ignore_pmdown_time:1; /* pmdown_time is ignored at stop */
 582
 583#ifdef CONFIG_DEBUG_FS
 584        struct dentry *debugfs_codec_root;
 585        struct dentry *debugfs_reg;
 586        struct dentry *debugfs_dapm;
 587#endif
 588};
 589
 590/* codec driver */
 591struct snd_soc_codec_driver {
 592
 593        /* driver ops */
 594        int (*probe)(struct snd_soc_codec *);
 595        int (*remove)(struct snd_soc_codec *);
 596        int (*suspend)(struct snd_soc_codec *);
 597        int (*resume)(struct snd_soc_codec *);
 598
 599        /* Default control and setup, added after probe() is run */
 600        const struct snd_kcontrol_new *controls;
 601        int num_controls;
 602        const struct snd_soc_dapm_widget *dapm_widgets;
 603        int num_dapm_widgets;
 604        const struct snd_soc_dapm_route *dapm_routes;
 605        int num_dapm_routes;
 606
 607        /* codec wide operations */
 608        int (*set_sysclk)(struct snd_soc_codec *codec,
 609                          int clk_id, int source, unsigned int freq, int dir);
 610        int (*set_pll)(struct snd_soc_codec *codec, int pll_id, int source,
 611                unsigned int freq_in, unsigned int freq_out);
 612
 613        /* codec IO */
 614        unsigned int (*read)(struct snd_soc_codec *, unsigned int);
 615        int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
 616        int (*display_register)(struct snd_soc_codec *, char *,
 617                                size_t, unsigned int);
 618        int (*volatile_register)(struct snd_soc_codec *, unsigned int);
 619        int (*readable_register)(struct snd_soc_codec *, unsigned int);
 620        int (*writable_register)(struct snd_soc_codec *, unsigned int);
 621        unsigned int reg_cache_size;
 622        short reg_cache_step;
 623        short reg_word_size;
 624        const void *reg_cache_default;
 625        short reg_access_size;
 626        const struct snd_soc_reg_access *reg_access_default;
 627        enum snd_soc_compress_type compress_type;
 628
 629        /* codec bias level */
 630        int (*set_bias_level)(struct snd_soc_codec *,
 631                              enum snd_soc_bias_level level);
 632        bool idle_bias_off;
 633
 634        void (*seq_notifier)(struct snd_soc_dapm_context *,
 635                             enum snd_soc_dapm_type, int);
 636
 637        /* codec stream completion event */
 638        int (*stream_event)(struct snd_soc_dapm_context *dapm, int event);
 639
 640        /* probe ordering - for components with runtime dependencies */
 641        int probe_order;
 642        int remove_order;
 643};
 644
 645/* SoC platform interface */
 646struct snd_soc_platform_driver {
 647
 648        int (*probe)(struct snd_soc_platform *);
 649        int (*remove)(struct snd_soc_platform *);
 650        int (*suspend)(struct snd_soc_dai *dai);
 651        int (*resume)(struct snd_soc_dai *dai);
 652
 653        /* pcm creation and destruction */
 654        int (*pcm_new)(struct snd_soc_pcm_runtime *);
 655        void (*pcm_free)(struct snd_pcm *);
 656
 657        /* Default control and setup, added after probe() is run */
 658        const struct snd_kcontrol_new *controls;
 659        int num_controls;
 660        const struct snd_soc_dapm_widget *dapm_widgets;
 661        int num_dapm_widgets;
 662        const struct snd_soc_dapm_route *dapm_routes;
 663        int num_dapm_routes;
 664
 665        /*
 666         * For platform caused delay reporting.
 667         * Optional.
 668         */
 669        snd_pcm_sframes_t (*delay)(struct snd_pcm_substream *,
 670                struct snd_soc_dai *);
 671
 672        /* platform stream ops */
 673        struct snd_pcm_ops *ops;
 674
 675        /* platform stream completion event */
 676        int (*stream_event)(struct snd_soc_dapm_context *dapm, int event);
 677
 678        /* probe ordering - for components with runtime dependencies */
 679        int probe_order;
 680        int remove_order;
 681
 682        /* platform IO - used for platform DAPM */
 683        unsigned int (*read)(struct snd_soc_platform *, unsigned int);
 684        int (*write)(struct snd_soc_platform *, unsigned int, unsigned int);
 685};
 686
 687struct snd_soc_platform {
 688        const char *name;
 689        int id;
 690        struct device *dev;
 691        struct snd_soc_platform_driver *driver;
 692
 693        unsigned int suspended:1; /* platform is suspended */
 694        unsigned int probed:1;
 695
 696        struct snd_soc_card *card;
 697        struct list_head list;
 698        struct list_head card_list;
 699
 700        struct snd_soc_dapm_context dapm;
 701};
 702
 703struct snd_soc_dai_link {
 704        /* config - must be set by machine driver */
 705        const char *name;                       /* Codec name */
 706        const char *stream_name;                /* Stream name */
 707        const char *codec_name;         /* for multi-codec */
 708        const struct device_node *codec_of_node;
 709        const char *platform_name;      /* for multi-platform */
 710        const struct device_node *platform_of_node;
 711        const char *cpu_dai_name;
 712        const struct device_node *cpu_dai_of_node;
 713        const char *codec_dai_name;
 714
 715        unsigned int dai_fmt;           /* format to set on init */
 716
 717        /* Keep DAI active over suspend */
 718        unsigned int ignore_suspend:1;
 719
 720        /* Symmetry requirements */
 721        unsigned int symmetric_rates:1;
 722
 723        /* pmdown_time is ignored at stop */
 724        unsigned int ignore_pmdown_time:1;
 725
 726        /* codec/machine specific init - e.g. add machine controls */
 727        int (*init)(struct snd_soc_pcm_runtime *rtd);
 728
 729        /* machine stream operations */
 730        struct snd_soc_ops *ops;
 731};
 732
 733struct snd_soc_codec_conf {
 734        const char *dev_name;
 735
 736        /*
 737         * optional map of kcontrol, widget and path name prefixes that are
 738         * associated per device
 739         */
 740        const char *name_prefix;
 741
 742        /*
 743         * set this to the desired compression type if you want to
 744         * override the one supplied in codec->driver->compress_type
 745         */
 746        enum snd_soc_compress_type compress_type;
 747};
 748
 749struct snd_soc_aux_dev {
 750        const char *name;               /* Codec name */
 751        const char *codec_name;         /* for multi-codec */
 752
 753        /* codec/machine specific init - e.g. add machine controls */
 754        int (*init)(struct snd_soc_dapm_context *dapm);
 755};
 756
 757/* SoC card */
 758struct snd_soc_card {
 759        const char *name;
 760        const char *long_name;
 761        const char *driver_name;
 762        struct device *dev;
 763        struct snd_card *snd_card;
 764        struct module *owner;
 765
 766        struct list_head list;
 767        struct mutex mutex;
 768
 769        bool instantiated;
 770
 771        int (*probe)(struct snd_soc_card *card);
 772        int (*late_probe)(struct snd_soc_card *card);
 773        int (*remove)(struct snd_soc_card *card);
 774
 775        /* the pre and post PM functions are used to do any PM work before and
 776         * after the codec and DAI's do any PM work. */
 777        int (*suspend_pre)(struct snd_soc_card *card);
 778        int (*suspend_post)(struct snd_soc_card *card);
 779        int (*resume_pre)(struct snd_soc_card *card);
 780        int (*resume_post)(struct snd_soc_card *card);
 781
 782        /* callbacks */
 783        int (*set_bias_level)(struct snd_soc_card *,
 784                              struct snd_soc_dapm_context *dapm,
 785                              enum snd_soc_bias_level level);
 786        int (*set_bias_level_post)(struct snd_soc_card *,
 787                                   struct snd_soc_dapm_context *dapm,
 788                                   enum snd_soc_bias_level level);
 789
 790        long pmdown_time;
 791
 792        /* CPU <--> Codec DAI links  */
 793        struct snd_soc_dai_link *dai_link;
 794        int num_links;
 795        struct snd_soc_pcm_runtime *rtd;
 796        int num_rtd;
 797
 798        /* optional codec specific configuration */
 799        struct snd_soc_codec_conf *codec_conf;
 800        int num_configs;
 801
 802        /*
 803         * optional auxiliary devices such as amplifiers or codecs with DAI
 804         * link unused
 805         */
 806        struct snd_soc_aux_dev *aux_dev;
 807        int num_aux_devs;
 808        struct snd_soc_pcm_runtime *rtd_aux;
 809        int num_aux_rtd;
 810
 811        const struct snd_kcontrol_new *controls;
 812        int num_controls;
 813
 814        /*
 815         * Card-specific routes and widgets.
 816         */
 817        const struct snd_soc_dapm_widget *dapm_widgets;
 818        int num_dapm_widgets;
 819        const struct snd_soc_dapm_route *dapm_routes;
 820        int num_dapm_routes;
 821        bool fully_routed;
 822
 823        struct work_struct deferred_resume_work;
 824
 825        /* lists of probed devices belonging to this card */
 826        struct list_head codec_dev_list;
 827        struct list_head platform_dev_list;
 828        struct list_head dai_dev_list;
 829
 830        struct list_head widgets;
 831        struct list_head paths;
 832        struct list_head dapm_list;
 833        struct list_head dapm_dirty;
 834
 835        /* Generic DAPM context for the card */
 836        struct snd_soc_dapm_context dapm;
 837        struct snd_soc_dapm_stats dapm_stats;
 838
 839#ifdef CONFIG_DEBUG_FS
 840        struct dentry *debugfs_card_root;
 841        struct dentry *debugfs_pop_time;
 842#endif
 843        u32 pop_time;
 844
 845        void *drvdata;
 846};
 847
 848/* SoC machine DAI configuration, glues a codec and cpu DAI together */
 849struct snd_soc_pcm_runtime {
 850        struct device *dev;
 851        struct snd_soc_card *card;
 852        struct snd_soc_dai_link *dai_link;
 853        struct mutex pcm_mutex;
 854        enum snd_soc_pcm_subclass pcm_subclass;
 855        struct snd_pcm_ops ops;
 856
 857        unsigned int complete:1;
 858        unsigned int dev_registered:1;
 859
 860        long pmdown_time;
 861
 862        /* runtime devices */
 863        struct snd_pcm *pcm;
 864        struct snd_soc_codec *codec;
 865        struct snd_soc_platform *platform;
 866        struct snd_soc_dai *codec_dai;
 867        struct snd_soc_dai *cpu_dai;
 868
 869        struct delayed_work delayed_work;
 870};
 871
 872/* mixer control */
 873struct soc_mixer_control {
 874        int min, max, platform_max;
 875        unsigned int reg, rreg, shift, rshift, invert;
 876};
 877
 878/* enumerated kcontrol */
 879struct soc_enum {
 880        unsigned short reg;
 881        unsigned short reg2;
 882        unsigned char shift_l;
 883        unsigned char shift_r;
 884        unsigned int max;
 885        unsigned int mask;
 886        const char * const *texts;
 887        const unsigned int *values;
 888        void *dapm;
 889};
 890
 891/* codec IO */
 892unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg);
 893unsigned int snd_soc_write(struct snd_soc_codec *codec,
 894                           unsigned int reg, unsigned int val);
 895unsigned int snd_soc_bulk_write_raw(struct snd_soc_codec *codec,
 896                                    unsigned int reg, const void *data, size_t len);
 897
 898/* device driver data */
 899
 900static inline void snd_soc_card_set_drvdata(struct snd_soc_card *card,
 901                void *data)
 902{
 903        card->drvdata = data;
 904}
 905
 906static inline void *snd_soc_card_get_drvdata(struct snd_soc_card *card)
 907{
 908        return card->drvdata;
 909}
 910
 911static inline void snd_soc_codec_set_drvdata(struct snd_soc_codec *codec,
 912                void *data)
 913{
 914        dev_set_drvdata(codec->dev, data);
 915}
 916
 917static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec)
 918{
 919        return dev_get_drvdata(codec->dev);
 920}
 921
 922static inline void snd_soc_platform_set_drvdata(struct snd_soc_platform *platform,
 923                void *data)
 924{
 925        dev_set_drvdata(platform->dev, data);
 926}
 927
 928static inline void *snd_soc_platform_get_drvdata(struct snd_soc_platform *platform)
 929{
 930        return dev_get_drvdata(platform->dev);
 931}
 932
 933static inline void snd_soc_pcm_set_drvdata(struct snd_soc_pcm_runtime *rtd,
 934                void *data)
 935{
 936        dev_set_drvdata(rtd->dev, data);
 937}
 938
 939static inline void *snd_soc_pcm_get_drvdata(struct snd_soc_pcm_runtime *rtd)
 940{
 941        return dev_get_drvdata(rtd->dev);
 942}
 943
 944static inline void snd_soc_initialize_card_lists(struct snd_soc_card *card)
 945{
 946        INIT_LIST_HEAD(&card->dai_dev_list);
 947        INIT_LIST_HEAD(&card->codec_dev_list);
 948        INIT_LIST_HEAD(&card->platform_dev_list);
 949        INIT_LIST_HEAD(&card->widgets);
 950        INIT_LIST_HEAD(&card->paths);
 951        INIT_LIST_HEAD(&card->dapm_list);
 952}
 953
 954static inline bool snd_soc_volsw_is_stereo(struct soc_mixer_control *mc)
 955{
 956        if (mc->reg == mc->rreg && mc->shift == mc->rshift)
 957                return 0;
 958        /*
 959         * mc->reg == mc->rreg && mc->shift != mc->rshift, or
 960         * mc->reg != mc->rreg means that the control is
 961         * stereo (bits in one register or in two registers)
 962         */
 963        return 1;
 964}
 965
 966int snd_soc_util_init(void);
 967void snd_soc_util_exit(void);
 968
 969int snd_soc_of_parse_card_name(struct snd_soc_card *card,
 970                               const char *propname);
 971int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
 972                                   const char *propname);
 973
 974#include <sound/soc-dai.h>
 975
 976#ifdef CONFIG_DEBUG_FS
 977extern struct dentry *snd_soc_debugfs_root;
 978#endif
 979
 980extern const struct dev_pm_ops snd_soc_pm_ops;
 981
 982#endif
 983