Changeset 679 for GPL/trunk/alsa-kernel/include/sound

GPL/trunk

Property svn:mergeinfo changed
/GPL/branches/uniaud32-linux-3.2.102 (added) merged: 611-614
/GPL/branches/uniaud32-next (added) merged: 615-678

GPL/trunk/alsa-kernel/include/sound/ac97_codec.h

-              r598
+              r679
+#ifndef __SOUND_AC97_CODEC_H
+#define __SOUND_AC97_CODEC_H
+/*
+/* SPDX-License-Identifier: GPL-2.0+
+ *
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
  *  Universal interface for Audio Codec '97
 …
  *  For more details look to AC '97 component specification revision 2.1
  *  by Intel Corporation (http://developer.intel.com).
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
+#ifndef __SOUND_AC97_CODEC_H
+#define __SOUND_AC97_CODEC_H
 #include <linux/bitops.h>
 #include <linux/device.h>
 #include <linux/workqueue.h>
+#include "pcm.h"
+#include "control.h"
+#include "info.h"
+#include <sound/ac97/regs.h>
+#include <sound/pcm.h>
+#include <sound/control.h>
+#include <sound/info.h>
 /* maximum number of devices on the AC97 bus */
 #define AC97_BUS_MAX_DEVICES    4
-/*
- *  AC'97 codec registers
- */
-#define AC97_RESET              0x00    /* Reset */
-#define AC97_MASTER             0x02    /* Master Volume */
-#define AC97_HEADPHONE          0x04    /* Headphone Volume (optional) */
-#define AC97_MASTER_MONO        0x06    /* Master Volume Mono (optional) */
-#define AC97_MASTER_TONE        0x08    /* Master Tone (Bass & Treble) (optional) */
-#define AC97_PC_BEEP            0x0a    /* PC Beep Volume (optinal) */
-#define AC97_PHONE              0x0c    /* Phone Volume (optional) */
-#define AC97_MIC                0x0e    /* MIC Volume */
-#define AC97_LINE               0x10    /* Line In Volume */
-#define AC97_CD                 0x12    /* CD Volume */
-#define AC97_VIDEO              0x14    /* Video Volume (optional) */
-#define AC97_AUX                0x16    /* AUX Volume (optional) */
-#define AC97_PCM                0x18    /* PCM Volume */
-#define AC97_REC_SEL            0x1a    /* Record Select */
-#define AC97_REC_GAIN           0x1c    /* Record Gain */
-#define AC97_REC_GAIN_MIC       0x1e    /* Record Gain MIC (optional) */
-#define AC97_GENERAL_PURPOSE    0x20    /* General Purpose (optional) */
-#define AC97_3D_CONTROL         0x22    /* 3D Control (optional) */
-#define AC97_INT_PAGING         0x24    /* Audio Interrupt & Paging (AC'97 2.3) */
-#define AC97_POWERDOWN          0x26    /* Powerdown control / status */
-/* range 0x28-0x3a - AUDIO AC'97 2.0 extensions */
-#define AC97_EXTENDED_ID        0x28    /* Extended Audio ID */
-#define AC97_EXTENDED_STATUS    0x2a    /* Extended Audio Status and Control */
-#define AC97_PCM_FRONT_DAC_RATE 0x2c    /* PCM Front DAC Rate */
-#define AC97_PCM_SURR_DAC_RATE  0x2e    /* PCM Surround DAC Rate */
-#define AC97_PCM_LFE_DAC_RATE   0x30    /* PCM LFE DAC Rate */
-#define AC97_PCM_LR_ADC_RATE    0x32    /* PCM LR ADC Rate */
-#define AC97_PCM_MIC_ADC_RATE   0x34    /* PCM MIC ADC Rate */
-#define AC97_CENTER_LFE_MASTER  0x36    /* Center + LFE Master Volume */
-#define AC97_SURROUND_MASTER    0x38    /* Surround (Rear) Master Volume */
-#define AC97_SPDIF              0x3a    /* S/PDIF control */
-/* range 0x3c-0x58 - MODEM */
-#define AC97_EXTENDED_MID       0x3c    /* Extended Modem ID */
-#define AC97_EXTENDED_MSTATUS   0x3e    /* Extended Modem Status and Control */
-#define AC97_LINE1_RATE         0x40    /* Line1 DAC/ADC Rate */
-#define AC97_LINE2_RATE         0x42    /* Line2 DAC/ADC Rate */
-#define AC97_HANDSET_RATE       0x44    /* Handset DAC/ADC Rate */
-#define AC97_LINE1_LEVEL        0x46    /* Line1 DAC/ADC Level */
-#define AC97_LINE2_LEVEL        0x48    /* Line2 DAC/ADC Level */
-#define AC97_HANDSET_LEVEL      0x4a    /* Handset DAC/ADC Level */
-#define AC97_GPIO_CFG           0x4c    /* GPIO Configuration */
-#define AC97_GPIO_POLARITY      0x4e    /* GPIO Pin Polarity/Type, 0=low, 1=high active */
-#define AC97_GPIO_STICKY        0x50    /* GPIO Pin Sticky, 0=not, 1=sticky */
-#define AC97_GPIO_WAKEUP        0x52    /* GPIO Pin Wakeup, 0=no int, 1=yes int */
-#define AC97_GPIO_STATUS        0x54    /* GPIO Pin Status, slot 12 */
-#define AC97_MISC_AFE           0x56    /* Miscellaneous Modem AFE Status and Control */
-/* range 0x5a-0x7b - Vendor Specific */
-#define AC97_VENDOR_ID1         0x7c    /* Vendor ID1 */
-#define AC97_VENDOR_ID2         0x7e    /* Vendor ID2 / revision */
-/* range 0x60-0x6f (page 1) - extended codec registers */
-#define AC97_CODEC_CLASS_REV    0x60    /* Codec Class/Revision */
-#define AC97_PCI_SVID           0x62    /* PCI Subsystem Vendor ID */
-#define AC97_PCI_SID            0x64    /* PCI Subsystem ID */
-#define AC97_FUNC_SELECT        0x66    /* Function Select */
-#define AC97_FUNC_INFO          0x68    /* Function Information */
-#define AC97_SENSE_INFO         0x6a    /* Sense Details */
-/* slot allocation */
-#define AC97_SLOT_TAG           0
-#define AC97_SLOT_CMD_ADDR      1
-#define AC97_SLOT_CMD_DATA      2
-#define AC97_SLOT_PCM_LEFT      3
-#define AC97_SLOT_PCM_RIGHT     4
-#define AC97_SLOT_MODEM_LINE1   5
-#define AC97_SLOT_PCM_CENTER    6
-#define AC97_SLOT_MIC           6       /* input */
-#define AC97_SLOT_SPDIF_LEFT1   6
-#define AC97_SLOT_PCM_SLEFT     7       /* surround left */
-#define AC97_SLOT_PCM_LEFT_0    7       /* double rate operation */
-#define AC97_SLOT_SPDIF_LEFT    7
-#define AC97_SLOT_PCM_SRIGHT    8       /* surround right */
-#define AC97_SLOT_PCM_RIGHT_0   8       /* double rate operation */
-#define AC97_SLOT_SPDIF_RIGHT   8
-#define AC97_SLOT_LFE           9
-#define AC97_SLOT_SPDIF_RIGHT1  9
-#define AC97_SLOT_MODEM_LINE2   10
-#define AC97_SLOT_PCM_LEFT_1    10      /* double rate operation */
-#define AC97_SLOT_SPDIF_LEFT2   10
-#define AC97_SLOT_HANDSET       11      /* output */
-#define AC97_SLOT_PCM_RIGHT_1   11      /* double rate operation */
-#define AC97_SLOT_SPDIF_RIGHT2  11
-#define AC97_SLOT_MODEM_GPIO    12      /* modem GPIO */
-#define AC97_SLOT_PCM_CENTER_1  12      /* double rate operation */
-/* basic capabilities (reset register) */
-#define AC97_BC_DEDICATED_MIC   0x0001  /* Dedicated Mic PCM In Channel */
-#define AC97_BC_RESERVED1       0x0002  /* Reserved (was Modem Line Codec support) */
-#define AC97_BC_BASS_TREBLE     0x0004  /* Bass & Treble Control */
-#define AC97_BC_SIM_STEREO      0x0008  /* Simulated stereo */
-#define AC97_BC_HEADPHONE       0x0010  /* Headphone Out Support */
-#define AC97_BC_LOUDNESS        0x0020  /* Loudness (bass boost) Support */
-#define AC97_BC_16BIT_DAC       0x0000  /* 16-bit DAC resolution */
-#define AC97_BC_18BIT_DAC       0x0040  /* 18-bit DAC resolution */
-#define AC97_BC_20BIT_DAC       0x0080  /* 20-bit DAC resolution */
-#define AC97_BC_DAC_MASK        0x00c0
-#define AC97_BC_16BIT_ADC       0x0000  /* 16-bit ADC resolution */
-#define AC97_BC_18BIT_ADC       0x0100  /* 18-bit ADC resolution */
-#define AC97_BC_20BIT_ADC       0x0200  /* 20-bit ADC resolution */
-#define AC97_BC_ADC_MASK        0x0300
-/* general purpose */
-#define AC97_GP_DRSS_MASK       0x0c00  /* double rate slot select */
-#define AC97_GP_DRSS_1011       0x0000  /* LR(C) 10+11(+12) */
-#define AC97_GP_DRSS_78         0x0400  /* LR 7+8 */
-/* powerdown bits */
-#define AC97_PD_ADC_STATUS      0x0001  /* ADC status (RO) */
-#define AC97_PD_DAC_STATUS      0x0002  /* DAC status (RO) */
-#define AC97_PD_MIXER_STATUS    0x0004  /* Analog mixer status (RO) */
-#define AC97_PD_VREF_STATUS     0x0008  /* Vref status (RO) */
-#define AC97_PD_PR0             0x0100  /* Power down PCM ADCs and input MUX */
-#define AC97_PD_PR1             0x0200  /* Power down PCM front DAC */
-#define AC97_PD_PR2             0x0400  /* Power down Mixer (Vref still on) */
-#define AC97_PD_PR3             0x0800  /* Power down Mixer (Vref off) */
-#define AC97_PD_PR4             0x1000  /* Power down AC-Link */
-#define AC97_PD_PR5             0x2000  /* Disable internal clock usage */
-#define AC97_PD_PR6             0x4000  /* Headphone amplifier */
-#define AC97_PD_EAPD            0x8000  /* External Amplifer Power Down (EAPD) */
-/* extended audio ID bit defines */
-#define AC97_EI_VRA             0x0001  /* Variable bit rate supported */
-#define AC97_EI_DRA             0x0002  /* Double rate supported */
-#define AC97_EI_SPDIF           0x0004  /* S/PDIF out supported */
-#define AC97_EI_VRM             0x0008  /* Variable bit rate supported for MIC */
-#define AC97_EI_DACS_SLOT_MASK  0x0030  /* DACs slot assignment */
-#define AC97_EI_DACS_SLOT_SHIFT 4
-#define AC97_EI_CDAC            0x0040  /* PCM Center DAC available */
-#define AC97_EI_SDAC            0x0080  /* PCM Surround DACs available */
-#define AC97_EI_LDAC            0x0100  /* PCM LFE DAC available */
-#define AC97_EI_AMAP            0x0200  /* indicates optional slot/DAC mapping based on codec ID */
-#define AC97_EI_REV_MASK        0x0c00  /* AC'97 revision mask */
-#define AC97_EI_REV_22          0x0400  /* AC'97 revision 2.2 */
-#define AC97_EI_REV_23          0x0800  /* AC'97 revision 2.3 */
-#define AC97_EI_REV_SHIFT       10
-#define AC97_EI_ADDR_MASK       0xc000  /* physical codec ID (address) */
-#define AC97_EI_ADDR_SHIFT      14
-/* extended audio status and control bit defines */
-#define AC97_EA_VRA             0x0001  /* Variable bit rate enable bit */
-#define AC97_EA_DRA             0x0002  /* Double-rate audio enable bit */
-#define AC97_EA_SPDIF           0x0004  /* S/PDIF out enable bit */
-#define AC97_EA_VRM             0x0008  /* Variable bit rate for MIC enable bit */
-#define AC97_EA_SPSA_SLOT_MASK  0x0030  /* Mask for slot assignment bits */
-#define AC97_EA_SPSA_SLOT_SHIFT 4
-#define AC97_EA_SPSA_3_4        0x0000  /* Slot assigned to 3 & 4 */
-#define AC97_EA_SPSA_7_8        0x0010  /* Slot assigned to 7 & 8 */
-#define AC97_EA_SPSA_6_9        0x0020  /* Slot assigned to 6 & 9 */
-#define AC97_EA_SPSA_10_11      0x0030  /* Slot assigned to 10 & 11 */
-#define AC97_EA_CDAC            0x0040  /* PCM Center DAC is ready (Read only) */
-#define AC97_EA_SDAC            0x0080  /* PCM Surround DACs are ready (Read only) */
-#define AC97_EA_LDAC            0x0100  /* PCM LFE DAC is ready (Read only) */
-#define AC97_EA_MDAC            0x0200  /* MIC ADC is ready (Read only) */
-#define AC97_EA_SPCV            0x0400  /* S/PDIF configuration valid (Read only) */
-#define AC97_EA_PRI             0x0800  /* Turns the PCM Center DAC off */
-#define AC97_EA_PRJ             0x1000  /* Turns the PCM Surround DACs off */
-#define AC97_EA_PRK             0x2000  /* Turns the PCM LFE DAC off */
-#define AC97_EA_PRL             0x4000  /* Turns the MIC ADC off */
-/* S/PDIF control bit defines */
-#define AC97_SC_PRO             0x0001  /* Professional status */
-#define AC97_SC_NAUDIO          0x0002  /* Non audio stream */
-#define AC97_SC_COPY            0x0004  /* Copyright status */
-#define AC97_SC_PRE             0x0008  /* Preemphasis status */
-#define AC97_SC_CC_MASK         0x07f0  /* Category Code mask */
-#define AC97_SC_CC_SHIFT        4
-#define AC97_SC_L               0x0800  /* Generation Level status */
-#define AC97_SC_SPSR_MASK       0x3000  /* S/PDIF Sample Rate bits */
-#define AC97_SC_SPSR_SHIFT      12
-#define AC97_SC_SPSR_44K        0x0000  /* Use 44.1kHz Sample rate */
-#define AC97_SC_SPSR_48K        0x2000  /* Use 48kHz Sample rate */
-#define AC97_SC_SPSR_32K        0x3000  /* Use 32kHz Sample rate */
-#define AC97_SC_DRS             0x4000  /* Double Rate S/PDIF */
-#define AC97_SC_V               0x8000  /* Validity status */
-/* Interrupt and Paging bit defines (AC'97 2.3) */
-#define AC97_PAGE_MASK          0x000f  /* Page Selector */
-#define AC97_PAGE_VENDOR        0       /* Vendor-specific registers */
-#define AC97_PAGE_1             1       /* Extended Codec Registers page 1 */
-#define AC97_INT_ENABLE         0x0800  /* Interrupt Enable */
-#define AC97_INT_SENSE          0x1000  /* Sense Cycle */
-#define AC97_INT_CAUSE_SENSE    0x2000  /* Sense Cycle Completed (RO) */
-#define AC97_INT_CAUSE_GPIO     0x4000  /* GPIO bits changed (RO) */
-#define AC97_INT_STATUS         0x8000  /* Interrupt Status */
-/* extended modem ID bit defines */
-#define AC97_MEI_LINE1          0x0001  /* Line1 present */
-#define AC97_MEI_LINE2          0x0002  /* Line2 present */
-#define AC97_MEI_HANDSET        0x0004  /* Handset present */
-#define AC97_MEI_CID1           0x0008  /* caller ID decode for Line1 is supported */
-#define AC97_MEI_CID2           0x0010  /* caller ID decode for Line2 is supported */
-#define AC97_MEI_ADDR_MASK      0xc000  /* physical codec ID (address) */
-#define AC97_MEI_ADDR_SHIFT     14
-/* extended modem status and control bit defines */
-#define AC97_MEA_GPIO           0x0001  /* GPIO is ready (ro) */
-#define AC97_MEA_MREF           0x0002  /* Vref is up to nominal level (ro) */
-#define AC97_MEA_ADC1           0x0004  /* ADC1 operational (ro) */
-#define AC97_MEA_DAC1           0x0008  /* DAC1 operational (ro) */
-#define AC97_MEA_ADC2           0x0010  /* ADC2 operational (ro) */
-#define AC97_MEA_DAC2           0x0020  /* DAC2 operational (ro) */
-#define AC97_MEA_HADC           0x0040  /* HADC operational (ro) */
-#define AC97_MEA_HDAC           0x0080  /* HDAC operational (ro) */
-#define AC97_MEA_PRA            0x0100  /* GPIO power down (high) */
-#define AC97_MEA_PRB            0x0200  /* reserved */
-#define AC97_MEA_PRC            0x0400  /* ADC1 power down (high) */
-#define AC97_MEA_PRD            0x0800  /* DAC1 power down (high) */
-#define AC97_MEA_PRE            0x1000  /* ADC2 power down (high) */
-#define AC97_MEA_PRF            0x2000  /* DAC2 power down (high) */
-#define AC97_MEA_PRG            0x4000  /* HADC power down (high) */
-#define AC97_MEA_PRH            0x8000  /* HDAC power down (high) */
-/* modem gpio status defines */
-#define AC97_GPIO_LINE1_OH      0x0001  /* Off Hook Line1 */
-#define AC97_GPIO_LINE1_RI      0x0002  /* Ring Detect Line1 */
-#define AC97_GPIO_LINE1_CID     0x0004  /* Caller ID path enable Line1 */
-#define AC97_GPIO_LINE1_LCS     0x0008  /* Loop Current Sense Line1 */
-#define AC97_GPIO_LINE1_PULSE   0x0010  /* Opt./ Pulse Dial Line1 (out) */
-#define AC97_GPIO_LINE1_HL1R    0x0020  /* Opt./ Handset to Line1 relay control (out) */
-#define AC97_GPIO_LINE1_HOHD    0x0040  /* Opt./ Handset off hook detect Line1 (in) */
-#define AC97_GPIO_LINE12_AC     0x0080  /* Opt./ Int.bit 1 / Line1/2 AC (out) */
-#define AC97_GPIO_LINE12_DC     0x0100  /* Opt./ Int.bit 2 / Line1/2 DC (out) */
-#define AC97_GPIO_LINE12_RS     0x0200  /* Opt./ Int.bit 3 / Line1/2 RS (out) */
-#define AC97_GPIO_LINE2_OH      0x0400  /* Off Hook Line2 */
-#define AC97_GPIO_LINE2_RI      0x0800  /* Ring Detect Line2 */
-#define AC97_GPIO_LINE2_CID     0x1000  /* Caller ID path enable Line2 */
-#define AC97_GPIO_LINE2_LCS     0x2000  /* Loop Current Sense Line2 */
-#define AC97_GPIO_LINE2_PULSE   0x4000  /* Opt./ Pulse Dial Line2 (out) */
-#define AC97_GPIO_LINE2_HL1R    0x8000  /* Opt./ Handset to Line2 relay control (out) */
 /* specific - SigmaTel */
 …
 #define AC97_SCAP_NO_SPDIF      (1<<9)  /* don't build SPDIF controls */
 #define AC97_SCAP_EAPD_LED      (1<<10) /* EAPD as mute LED */
 #define AC97_SCAP_POWER_SAVE    (1<<11) /* capable for aggresive power-saving */
+#define AC97_SCAP_POWER_SAVE    (1<<11) /* capable for aggressive power-saving */
 /* ac97->flags */
 …
 #define AC97_RATES_SPDIF        5
+#define AC97_NUM_GPIOS          16
 /*
+ *
 …
 struct snd_ac97;
+struct snd_ac97_gpio_priv;
+struct snd_pcm_chmap;
 struct snd_ac97_build_ops {
 …
 struct snd_ac97_bus {
         /* -- lowlevel (hardware) driver specific -- */
         struct snd_ac97_bus_ops *ops;
+        const struct snd_ac97_bus_ops *ops;
         void *private_data;
         void (*private_free) (struct snd_ac97_bus *bus);
 …
 #endif
         struct device dev;
+        struct snd_ac97_gpio_priv *gpio_priv;
+        struct snd_pcm_chmap *chmaps[2]; /* channel-maps (optional) */
 };
 …
 /* functions */
 /* create new AC97 bus */
+int snd_ac97_bus(struct snd_card *card, int num, struct snd_ac97_bus_ops *ops,
+int snd_ac97_bus(struct snd_card *card, int num,
+                 const struct snd_ac97_bus_ops *ops,
                  void *private_data, struct snd_ac97_bus **rbus);
 /* create mixer controls */
 …
 void snd_ac97_resume(struct snd_ac97 *ac97);
 #endif
+int snd_ac97_reset(struct snd_ac97 *ac97, bool try_warm, unsigned int id,
+        unsigned int id_mask);
 /* quirk types */
 …
 };
+int snd_ac97_tune_hardware(struct snd_ac97 *ac97, struct ac97_quirk *quirk, const char *override);
+int snd_ac97_tune_hardware(struct snd_ac97 *ac97,
+                           const struct ac97_quirk *quirk,
+                           const char *override);
 int snd_ac97_set_rate(struct snd_ac97 *ac97, int reg, unsigned int rate);

GPL/trunk/alsa-kernel/include/sound/ad1816a.h

-              r426
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_AD1816A_H
 #define __SOUND_AD1816A_H
 …
     Copyright (C) 1999-2000 by Massimo Piccioni <dafastidio@libero.it>
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */
 #include "control.h"
 #include "pcm.h"
 #include "timer.h"
+#include <sound/control.h>
+#include <sound/pcm.h>
+#include <sound/timer.h>
 #define AD1816A_REG(r)                  (chip->port + r)
 …
         struct snd_timer *timer;
+#ifdef CONFIG_PM
+        unsigned short image[48];
+#endif
 };
 …
 extern int snd_ad1816a_create(struct snd_card *card, unsigned long port,
                               int irq, int dma1, int dma2,
                               struct snd_ad1816a **chip);
+                              struct snd_ad1816a *chip);
 extern int snd_ad1816a_pcm(struct snd_ad1816a *chip, int device, struct snd_pcm **rpcm);
+extern int snd_ad1816a_pcm(struct snd_ad1816a *chip, int device);
 extern int snd_ad1816a_mixer(struct snd_ad1816a *chip);
+extern int snd_ad1816a_timer(struct snd_ad1816a *chip, int device,
+                             struct snd_timer **rtimer);
+extern int snd_ad1816a_timer(struct snd_ad1816a *chip, int device);
+#ifdef CONFIG_PM
+extern void snd_ad1816a_suspend(struct snd_ad1816a *chip);
+extern void snd_ad1816a_resume(struct snd_ad1816a *chip);
+#endif
 #endif  /* __SOUND_AD1816A_H */

GPL/trunk/alsa-kernel/include/sound/ak4114.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_AK4114_H
 #define __SOUND_AK4114_H
 …
  *  Routines for Asahi Kasei AK4114
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>,
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 …
 typedef unsigned char (ak4114_read_t)(void *private_data, unsigned char addr);
+enum {
+        AK4114_PARITY_ERRORS,
+        AK4114_V_BIT_ERRORS,
+        AK4114_QCRC_ERRORS,
+        AK4114_CCRC_ERRORS,
+        AK4114_NUM_ERRORS
+};
 struct ak4114 {
         struct snd_card *card;
 …
         ak4114_read_t * read;
         void * private_data;
+        unsigned int init: 1;
+        atomic_t wq_processing;
+        struct mutex reinit_mutex;
         spinlock_t lock;
         unsigned char regmap[7];
+        unsigned char regmap[6];
         unsigned char txcsb[5];
         struct snd_kcontrol *kctls[AK4114_CONTROLS];
         struct snd_pcm_substream *playback_substream;
         struct snd_pcm_substream *capture_substream;
+        unsigned long parity_errors;
+        unsigned long v_bit_errors;
+        unsigned long qcrc_errors;
+        unsigned long ccrc_errors;
+        unsigned long errors[AK4114_NUM_ERRORS];
         unsigned char rcs0;
         unsigned char rcs1;
 …
 int snd_ak4114_create(struct snd_card *card,
                       ak4114_read_t *read, ak4114_write_t *write,
                       const unsigned char pgm[7], const unsigned char txcsb[5],
+                      const unsigned char pgm[6], const unsigned char txcsb[5],
                       void *private_data, struct ak4114 **r_ak4114);
 void snd_ak4114_reg_write(struct ak4114 *ak4114, unsigned char reg, unsigned char mask, unsigned char val);
 …
 int snd_ak4114_check_rate_and_errors(struct ak4114 *ak4114, unsigned int flags);
+#ifdef CONFIG_PM
+void snd_ak4114_suspend(struct ak4114 *chip);
+void snd_ak4114_resume(struct ak4114 *chip);
+#else
+static inline void snd_ak4114_suspend(struct ak4114 *chip) {}
+static inline void snd_ak4114_resume(struct ak4114 *chip) {}
+#endif
 #endif /* __SOUND_AK4114_H */

GPL/trunk/alsa-kernel/include/sound/ak4117.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_AK4117_H
 #define __SOUND_AK4117_H
 …
  *  Routines for Asahi Kasei AK4117
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>,
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 …
 typedef unsigned char (ak4117_read_t)(void *private_data, unsigned char addr);
+enum {
+        AK4117_PARITY_ERRORS,
+        AK4117_V_BIT_ERRORS,
+        AK4117_QCRC_ERRORS,
+        AK4117_CCRC_ERRORS,
+        AK4117_NUM_ERRORS
+};
 struct ak4117 {
         struct snd_card *card;
 …
         struct snd_kcontrol *kctls[AK4117_CONTROLS];
         struct snd_pcm_substream *substream;
+        unsigned long parity_errors;
+        unsigned long v_bit_errors;
+        unsigned long qcrc_errors;
+        unsigned long ccrc_errors;
+        unsigned long errors[AK4117_NUM_ERRORS];
         unsigned char rcs0;
         unsigned char rcs1;

GPL/trunk/alsa-kernel/include/sound/ak4531_codec.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_AK4531_CODEC_H
 #define __SOUND_AK4531_CODEC_H
 …
  *  For more details look to AC '97 component specification revision 2.1
  *  by Intel Corporation (http://developer.intel.com).
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 #include "info.h"
 #include "control.h"
+#include <sound/info.h>
+#include <sound/control.h>
 /*

GPL/trunk/alsa-kernel/include/sound/ak4xxx-adda.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_AK4XXX_ADDA_H
 #define __SOUND_AK4XXX_ADDA_H
 …
+ *
  *      Copyright (c) 2000 Jaroslav Kysela <perex@perex.cz>
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */

GPL/trunk/alsa-kernel/include/sound/asequencer.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 /*
  *  Main header file for the ALSA sequencer
  *  Copyright (c) 1998-1999 by Frank van de Pol <fvdpol@coil.demon.nl>
  *            (c) 1998-1999 by Jaroslav Kysela <perex@perex.cz>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 #ifndef __SOUND_ASEQUENCER_H
 #define __SOUND_ASEQUENCER_H
-#ifdef __KERNEL__
 #include <linux/ioctl.h>
 #include <sound/asound.h>
+#endif
+/** version of the sequencer */
+#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION (1, 0, 1)
+/**
+ * definition of sequencer event types
+ */
+/** system messages
+ * event data type = #snd_seq_result
+ */
+#define SNDRV_SEQ_EVENT_SYSTEM          0
+#define SNDRV_SEQ_EVENT_RESULT          1
+/** note messages (channel specific)
+ * event data type = #snd_seq_ev_note
+ */
+#define SNDRV_SEQ_EVENT_NOTE            5
+#define SNDRV_SEQ_EVENT_NOTEON          6
+#define SNDRV_SEQ_EVENT_NOTEOFF         7
+#define SNDRV_SEQ_EVENT_KEYPRESS        8
+/** control messages (channel specific)
+ * event data type = #snd_seq_ev_ctrl
+ */
+#define SNDRV_SEQ_EVENT_CONTROLLER      10
+#define SNDRV_SEQ_EVENT_PGMCHANGE       11
+#define SNDRV_SEQ_EVENT_CHANPRESS       12
+#define SNDRV_SEQ_EVENT_PITCHBEND       13      /**< from -8192 to 8191 */
+#define SNDRV_SEQ_EVENT_CONTROL14       14      /**< 14 bit controller value */
+#define SNDRV_SEQ_EVENT_NONREGPARAM     15      /**< 14 bit NRPN address + 14 bit unsigned value */
+#define SNDRV_SEQ_EVENT_REGPARAM        16      /**< 14 bit RPN address + 14 bit unsigned value */
+/** synchronisation messages
+ * event data type = #snd_seq_ev_ctrl
+ */
+#define SNDRV_SEQ_EVENT_SONGPOS         20      /* Song Position Pointer with LSB and MSB values */
+#define SNDRV_SEQ_EVENT_SONGSEL         21      /* Song Select with song ID number */
+#define SNDRV_SEQ_EVENT_QFRAME          22      /* midi time code quarter frame */
+#define SNDRV_SEQ_EVENT_TIMESIGN        23      /* SMF Time Signature event */
+#define SNDRV_SEQ_EVENT_KEYSIGN         24      /* SMF Key Signature event */
+/** timer messages
+ * event data type = snd_seq_ev_queue_control
+ */
+#define SNDRV_SEQ_EVENT_START           30      /* midi Real Time Start message */
+#define SNDRV_SEQ_EVENT_CONTINUE        31      /* midi Real Time Continue message */
+#define SNDRV_SEQ_EVENT_STOP            32      /* midi Real Time Stop message */
+#define SNDRV_SEQ_EVENT_SETPOS_TICK     33      /* set tick queue position */
+#define SNDRV_SEQ_EVENT_SETPOS_TIME     34      /* set realtime queue position */
+#define SNDRV_SEQ_EVENT_TEMPO           35      /* (SMF) Tempo event */
+#define SNDRV_SEQ_EVENT_CLOCK           36      /* midi Real Time Clock message */
+#define SNDRV_SEQ_EVENT_TICK            37      /* midi Real Time Tick message */
+#define SNDRV_SEQ_EVENT_QUEUE_SKEW      38      /* skew queue tempo */
+/** others
+ * event data type = none
+ */
+#define SNDRV_SEQ_EVENT_TUNE_REQUEST    40      /* tune request */
+#define SNDRV_SEQ_EVENT_RESET           41      /* reset to power-on state */
+#define SNDRV_SEQ_EVENT_SENSING         42      /* "active sensing" event */
+/** echo back, kernel private messages
+ * event data type = any type
+ */
+#define SNDRV_SEQ_EVENT_ECHO            50      /* echo event */
+#define SNDRV_SEQ_EVENT_OSS             51      /* OSS raw event */
+/** system status messages (broadcast for subscribers)
+ * event data type = snd_seq_addr
+ */
+#define SNDRV_SEQ_EVENT_CLIENT_START    60      /* new client has connected */
+#define SNDRV_SEQ_EVENT_CLIENT_EXIT     61      /* client has left the system */
+#define SNDRV_SEQ_EVENT_CLIENT_CHANGE   62      /* client status/info has changed */
+#define SNDRV_SEQ_EVENT_PORT_START      63      /* new port was created */
+#define SNDRV_SEQ_EVENT_PORT_EXIT       64      /* port was deleted from system */
+#define SNDRV_SEQ_EVENT_PORT_CHANGE     65      /* port status/info has changed */
+/** port connection changes
+ * event data type = snd_seq_connect
+ */
+#define SNDRV_SEQ_EVENT_PORT_SUBSCRIBED 66      /* ports connected */
+#define SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED 67    /* ports disconnected */
+/* 70-89:  synthesizer events - obsoleted */
+/** user-defined events with fixed length
+ * event data type = any
+ */
+#define SNDRV_SEQ_EVENT_USR0            90
+#define SNDRV_SEQ_EVENT_USR1            91
+#define SNDRV_SEQ_EVENT_USR2            92
+#define SNDRV_SEQ_EVENT_USR3            93
+#define SNDRV_SEQ_EVENT_USR4            94
+#define SNDRV_SEQ_EVENT_USR5            95
+#define SNDRV_SEQ_EVENT_USR6            96
+#define SNDRV_SEQ_EVENT_USR7            97
+#define SNDRV_SEQ_EVENT_USR8            98
+#define SNDRV_SEQ_EVENT_USR9            99
+/* 100-118: instrument layer - obsoleted */
+/* 119-129: reserved */
+/* 130-139: variable length events
+ * event data type = snd_seq_ev_ext
+ * (SNDRV_SEQ_EVENT_LENGTH_VARIABLE must be set)
+ */
+#define SNDRV_SEQ_EVENT_SYSEX           130     /* system exclusive data (variable length) */
+#define SNDRV_SEQ_EVENT_BOUNCE          131     /* error event */
+/* 132-134: reserved */
+#define SNDRV_SEQ_EVENT_USR_VAR0        135
+#define SNDRV_SEQ_EVENT_USR_VAR1        136
+#define SNDRV_SEQ_EVENT_USR_VAR2        137
+#define SNDRV_SEQ_EVENT_USR_VAR3        138
+#define SNDRV_SEQ_EVENT_USR_VAR4        139
+/* 150-151: kernel events with quote - DO NOT use in user clients */
+#define SNDRV_SEQ_EVENT_KERNEL_ERROR    150
+#define SNDRV_SEQ_EVENT_KERNEL_QUOTE    151     /* obsolete */
+/* 152-191: reserved */
+/* 192-254: hardware specific events */
+/* 255: special event */
+#define SNDRV_SEQ_EVENT_NONE            255
+typedef unsigned char snd_seq_event_type_t;
+/** event address */
+struct snd_seq_addr {
+        unsigned char client;   /**< Client number:         0..255, 255 = broadcast to all clients */
+        unsigned char port;     /**< Port within client:    0..255, 255 = broadcast to all ports */
+};
+/** port connection */
+struct snd_seq_connect {
+        struct snd_seq_addr sender;
+        struct snd_seq_addr dest;
+};
+#define SNDRV_SEQ_ADDRESS_UNKNOWN       253     /* unknown source */
+#define SNDRV_SEQ_ADDRESS_SUBSCRIBERS   254     /* send event to all subscribed ports */
+#define SNDRV_SEQ_ADDRESS_BROADCAST     255     /* send event to all queues/clients/ports/channels */
+#define SNDRV_SEQ_QUEUE_DIRECT          253     /* direct dispatch */
+        /* event mode flag - NOTE: only 8 bits available! */
+#define SNDRV_SEQ_TIME_STAMP_TICK       (0<<0) /* timestamp in clock ticks */
+#define SNDRV_SEQ_TIME_STAMP_REAL       (1<<0) /* timestamp in real time */
+#define SNDRV_SEQ_TIME_STAMP_MASK       (1<<0)
+#define SNDRV_SEQ_TIME_MODE_ABS         (0<<1)  /* absolute timestamp */
+#define SNDRV_SEQ_TIME_MODE_REL         (1<<1)  /* relative to current time */
+#define SNDRV_SEQ_TIME_MODE_MASK        (1<<1)
+#define SNDRV_SEQ_EVENT_LENGTH_FIXED    (0<<2)  /* fixed event size */
+#define SNDRV_SEQ_EVENT_LENGTH_VARIABLE (1<<2)  /* variable event size */
+#define SNDRV_SEQ_EVENT_LENGTH_VARUSR   (2<<2)  /* variable event size - user memory space */
+#define SNDRV_SEQ_EVENT_LENGTH_MASK     (3<<2)
+#define SNDRV_SEQ_PRIORITY_NORMAL       (0<<4)  /* normal priority */
+#define SNDRV_SEQ_PRIORITY_HIGH         (1<<4)  /* event should be processed before others */
+#define SNDRV_SEQ_PRIORITY_MASK         (1<<4)
+        /* note event */
+struct snd_seq_ev_note {
+        unsigned char channel;
+        unsigned char note;
+        unsigned char velocity;
+        unsigned char off_velocity;     /* only for SNDRV_SEQ_EVENT_NOTE */
+        unsigned int duration;          /* only for SNDRV_SEQ_EVENT_NOTE */
+};
+        /* controller event */
+struct snd_seq_ev_ctrl {
+        unsigned char channel;
+        unsigned char unused1, unused2, unused3;        /* pad */
+        unsigned int param;
+        signed int value;
+};
+        /* generic set of bytes (12x8 bit) */
+struct snd_seq_ev_raw8 {
+        unsigned char d[12];    /* 8 bit value */
+};
+        /* generic set of integers (3x32 bit) */
+struct snd_seq_ev_raw32 {
+        unsigned int d[3];      /* 32 bit value */
+};
+        /* external stored data */
+#ifndef TARGET_OS2
+struct snd_seq_ev_ext {
+        unsigned int len;       /* length of data */
+        void *ptr;              /* pointer to data (note: maybe 64-bit) */
+} __attribute__((packed));
+#else
+#pragma pack(1)
+struct snd_seq_ev_ext {
+        unsigned int len;       /* length of data */
+        void *ptr;              /* pointer to data (note: maybe 64-bit) */
+};
+#pragma pack()
+#endif
+struct snd_seq_result {
+        int event;              /* processed event type */
+        int result;
+};
+struct snd_seq_real_time {
+        unsigned int tv_sec;    /* seconds */
+        unsigned int tv_nsec;   /* nanoseconds */
+};
+typedef unsigned int snd_seq_tick_time_t;       /* midi ticks */
+union snd_seq_timestamp {
+        snd_seq_tick_time_t tick;
+        struct snd_seq_real_time time;
+};
+struct snd_seq_queue_skew {
+        unsigned int value;
+        unsigned int base;
+};
+        /* queue timer control */
+struct snd_seq_ev_queue_control {
+        unsigned char queue;                    /* affected queue */
+        unsigned char pad[3];                   /* reserved */
+        union {
+                signed int value;               /* affected value (e.g. tempo) */
+                union snd_seq_timestamp time;   /* time */
+                unsigned int position;          /* sync position */
+                struct snd_seq_queue_skew skew;
+                unsigned int d32[2];
+                unsigned char d8[8];
+        } param;
+};
+        /* quoted event - inside the kernel only */
+#ifndef TARGET_OS2
+struct snd_seq_ev_quote {
+        struct snd_seq_addr origin;             /* original sender */
+        unsigned short value;           /* optional data */
+        struct snd_seq_event *event;            /* quoted event */
+} __attribute__((packed));
+#else
+#pragma pack(1)
+struct snd_seq_ev_quote {
+        struct snd_seq_addr origin;             /* original sender */
+        unsigned short value;           /* optional data */
+        struct snd_seq_event *event;            /* quoted event */
+};
+#pragma pack()
+#endif
+        /* sequencer event */
+struct snd_seq_event {
+        snd_seq_event_type_t type;      /* event type */
+        unsigned char flags;            /* event flags */
+        char tag;
+        unsigned char queue;            /* schedule queue */
+        union snd_seq_timestamp time;   /* schedule time */
+        struct snd_seq_addr source;     /* source address */
+        struct snd_seq_addr dest;       /* destination address */
+        union {                         /* event data... */
+                struct snd_seq_ev_note note;
+                struct snd_seq_ev_ctrl control;
+                struct snd_seq_ev_raw8 raw8;
+                struct snd_seq_ev_raw32 raw32;
+                struct snd_seq_ev_ext ext;
+                struct snd_seq_ev_queue_control queue;
+                union snd_seq_timestamp time;
+                struct snd_seq_addr addr;
+                struct snd_seq_connect connect;
+                struct snd_seq_result result;
+                struct snd_seq_ev_quote quote;
+        } data;
+};
+/*
+ * bounce event - stored as variable size data
+ */
+struct snd_seq_event_bounce {
+        int err;
+        struct snd_seq_event event;
+        /* external data follows here. */
+};
+#ifdef __KERNEL__
+#include <uapi/sound/asequencer.h>
 /* helper macro */
 …
 #define snd_seq_queue_sync_port(q)      ((q) + 16)
-#endif /* __KERNEL__ */
-        /* system information */
-struct snd_seq_system_info {
-        int queues;                     /* maximum queues count */
-        int clients;                    /* maximum clients count */
-        int ports;                      /* maximum ports per client */
-        int channels;                   /* maximum channels per port */
-        int cur_clients;                /* current clients */
-        int cur_queues;                 /* current queues */
-        char reserved[24];
-};
-        /* system running information */
-struct snd_seq_running_info {
-        unsigned char client;           /* client id */
-        unsigned char big_endian;       /* 1 = big-endian */
-        unsigned char cpu_mode;         /* 4 = 32bit, 8 = 64bit */
-        unsigned char pad;              /* reserved */
-        unsigned char reserved[12];
-};
-        /* known client numbers */
-#define SNDRV_SEQ_CLIENT_SYSTEM         0
-        /* internal client numbers */
-#define SNDRV_SEQ_CLIENT_DUMMY          14      /* midi through */
-#define SNDRV_SEQ_CLIENT_OSS            15      /* oss sequencer emulator */
-        /* client types */
-typedef int __bitwise snd_seq_client_type_t;
-#define NO_CLIENT       ((__force snd_seq_client_type_t) 0)
-#define USER_CLIENT     ((__force snd_seq_client_type_t) 1)
-#define KERNEL_CLIENT   ((__force snd_seq_client_type_t) 2)
-        /* event filter flags */
-#define SNDRV_SEQ_FILTER_BROADCAST      (1<<0)  /* accept broadcast messages */
-#define SNDRV_SEQ_FILTER_MULTICAST      (1<<1)  /* accept multicast messages */
-#define SNDRV_SEQ_FILTER_BOUNCE         (1<<2)  /* accept bounce event in error */
-#define SNDRV_SEQ_FILTER_USE_EVENT      (1<<31) /* use event filter */
-struct snd_seq_client_info {
-        int client;                     /* client number to inquire */
-        snd_seq_client_type_t type;     /* client type */
-        char name[64];                  /* client name */
-        unsigned int filter;            /* filter flags */
-        unsigned char multicast_filter[8]; /* multicast filter bitmap */
-        unsigned char event_filter[32]; /* event filter bitmap */
-        int num_ports;                  /* RO: number of ports */
-        int event_lost;                 /* number of lost events */
-        char reserved[64];              /* for future use */
-};
-/* client pool size */
-struct snd_seq_client_pool {
-        int client;                     /* client number to inquire */
-        int output_pool;                /* outgoing (write) pool size */
-        int input_pool;                 /* incoming (read) pool size */
-        int output_room;                /* minimum free pool size for select/blocking mode */
-        int output_free;                /* unused size */
-        int input_free;                 /* unused size */
-        char reserved[64];
-};
-/* Remove events by specified criteria */
-#define SNDRV_SEQ_REMOVE_INPUT          (1<<0)  /* Flush input queues */
-#define SNDRV_SEQ_REMOVE_OUTPUT         (1<<1)  /* Flush output queues */
-#define SNDRV_SEQ_REMOVE_DEST           (1<<2)  /* Restrict by destination q:client:port */
-#define SNDRV_SEQ_REMOVE_DEST_CHANNEL   (1<<3)  /* Restrict by channel */
-#define SNDRV_SEQ_REMOVE_TIME_BEFORE    (1<<4)  /* Restrict to before time */
-#define SNDRV_SEQ_REMOVE_TIME_AFTER     (1<<5)  /* Restrict to time or after */
-#define SNDRV_SEQ_REMOVE_TIME_TICK      (1<<6)  /* Time is in ticks */
-#define SNDRV_SEQ_REMOVE_EVENT_TYPE     (1<<7)  /* Restrict to event type */
-#define SNDRV_SEQ_REMOVE_IGNORE_OFF     (1<<8)  /* Do not flush off events */
-#define SNDRV_SEQ_REMOVE_TAG_MATCH      (1<<9)  /* Restrict to events with given tag */
-struct snd_seq_remove_events {
-        unsigned int  remove_mode;      /* Flags that determine what gets removed */
-        union snd_seq_timestamp time;
-        unsigned char queue;    /* Queue for REMOVE_DEST */
-        struct snd_seq_addr dest;       /* Address for REMOVE_DEST */
-        unsigned char channel;  /* Channel for REMOVE_DEST */
-        int  type;      /* For REMOVE_EVENT_TYPE */
-        char  tag;      /* Tag for REMOVE_TAG */
-        int  reserved[10];      /* To allow for future binary compatibility */
-};
-        /* known port numbers */
-#define SNDRV_SEQ_PORT_SYSTEM_TIMER     0
-#define SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE  1
-        /* port capabilities (32 bits) */
-#define SNDRV_SEQ_PORT_CAP_READ         (1<<0)  /* readable from this port */
-#define SNDRV_SEQ_PORT_CAP_WRITE        (1<<1)  /* writable to this port */
-#define SNDRV_SEQ_PORT_CAP_SYNC_READ    (1<<2)
-#define SNDRV_SEQ_PORT_CAP_SYNC_WRITE   (1<<3)
-#define SNDRV_SEQ_PORT_CAP_DUPLEX       (1<<4)
-#define SNDRV_SEQ_PORT_CAP_SUBS_READ    (1<<5)  /* allow read subscription */
-#define SNDRV_SEQ_PORT_CAP_SUBS_WRITE   (1<<6)  /* allow write subscription */
-#define SNDRV_SEQ_PORT_CAP_NO_EXPORT    (1<<7)  /* routing not allowed */
-        /* port type */
-#define SNDRV_SEQ_PORT_TYPE_SPECIFIC    (1<<0)  /* hardware specific */
-#define SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC (1<<1) /* generic MIDI device */
-#define SNDRV_SEQ_PORT_TYPE_MIDI_GM     (1<<2)  /* General MIDI compatible device */
-#define SNDRV_SEQ_PORT_TYPE_MIDI_GS     (1<<3)  /* GS compatible device */
-#define SNDRV_SEQ_PORT_TYPE_MIDI_XG     (1<<4)  /* XG compatible device */
-#define SNDRV_SEQ_PORT_TYPE_MIDI_MT32   (1<<5)  /* MT-32 compatible device */
-#define SNDRV_SEQ_PORT_TYPE_MIDI_GM2    (1<<6)  /* General MIDI 2 compatible device */
-/* other standards...*/
-#define SNDRV_SEQ_PORT_TYPE_SYNTH       (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */
-#define SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE (1<<11)       /* Sampling device (support sample download) */
-#define SNDRV_SEQ_PORT_TYPE_SAMPLE      (1<<12) /* Sampling device (sample can be downloaded at any time) */
-/*...*/
-#define SNDRV_SEQ_PORT_TYPE_HARDWARE    (1<<16) /* driver for a hardware device */
-#define SNDRV_SEQ_PORT_TYPE_SOFTWARE    (1<<17) /* implemented in software */
-#define SNDRV_SEQ_PORT_TYPE_SYNTHESIZER (1<<18) /* generates sound */
-#define SNDRV_SEQ_PORT_TYPE_PORT        (1<<19) /* connects to other device(s) */
-#define SNDRV_SEQ_PORT_TYPE_APPLICATION (1<<20) /* application (sequencer/editor) */
-/* misc. conditioning flags */
-#define SNDRV_SEQ_PORT_FLG_GIVEN_PORT   (1<<0)
-#define SNDRV_SEQ_PORT_FLG_TIMESTAMP    (1<<1)
-#define SNDRV_SEQ_PORT_FLG_TIME_REAL    (1<<2)
-struct snd_seq_port_info {
-        struct snd_seq_addr addr;       /* client/port numbers */
-        char name[64];                  /* port name */
-        unsigned int capability;        /* port capability bits */
-        unsigned int type;              /* port type bits */
-        int midi_channels;              /* channels per MIDI port */
-        int midi_voices;                /* voices per MIDI port */
-        int synth_voices;               /* voices per SYNTH port */
-        int read_use;                   /* R/O: subscribers for output (from this port) */
-        int write_use;                  /* R/O: subscribers for input (to this port) */
-        void *kernel;                   /* reserved for kernel use (must be NULL) */
-        unsigned int flags;             /* misc. conditioning */
-        unsigned char time_queue;       /* queue # for timestamping */
-        char reserved[59];              /* for future use */
-};
-/* queue flags */
-#define SNDRV_SEQ_QUEUE_FLG_SYNC        (1<<0)  /* sync enabled */
-/* queue information */
-struct snd_seq_queue_info {
-        int queue;              /* queue id */
-        /*
-         *  security settings, only owner of this queue can start/stop timer
-         *  etc. if the queue is locked for other clients
-         */
-        int owner;              /* client id for owner of the queue */
-        unsigned locked:1;      /* timing queue locked for other queues */
-        char name[64];          /* name of this queue */
-        unsigned int flags;     /* flags */
-        char reserved[60];      /* for future use */
-};
-/* queue info/status */
-struct snd_seq_queue_status {
-        int queue;                      /* queue id */
-        int events;                     /* read-only - queue size */
-        snd_seq_tick_time_t tick;       /* current tick */
-        struct snd_seq_real_time time;  /* current time */
-        int running;                    /* running state of queue */
-        int flags;                      /* various flags */
-        char reserved[64];              /* for the future */
-};
-/* queue tempo */
-struct snd_seq_queue_tempo {
-        int queue;                      /* sequencer queue */
-        unsigned int tempo;             /* current tempo, us/tick */
-        int ppq;                        /* time resolution, ticks/quarter */
-        unsigned int skew_value;        /* queue skew */
-        unsigned int skew_base;         /* queue skew base */
-        char reserved[24];              /* for the future */
-};
-/* sequencer timer sources */
-#define SNDRV_SEQ_TIMER_ALSA            0       /* ALSA timer */
-#define SNDRV_SEQ_TIMER_MIDI_CLOCK      1       /* Midi Clock (CLOCK event) */
-#define SNDRV_SEQ_TIMER_MIDI_TICK       2       /* Midi Timer Tick (TICK event) */
-/* queue timer info */
-struct snd_seq_queue_timer {
-        int queue;                      /* sequencer queue */
-        int type;                       /* source timer type */
-        union {
-                struct {
-                        struct snd_timer_id id; /* ALSA's timer ID */
-                        unsigned int resolution;        /* resolution in Hz */
-                } alsa;
-        } u;
-        char reserved[64];              /* for the future use */
-};
-struct snd_seq_queue_client {
-        int queue;              /* sequencer queue */
-        int client;             /* sequencer client */
-        int used;               /* queue is used with this client
-                                   (must be set for accepting events) */
-        /* per client watermarks */
-        char reserved[64];      /* for future use */
-};
-#define SNDRV_SEQ_PORT_SUBS_EXCLUSIVE   (1<<0)  /* exclusive connection */
-#define SNDRV_SEQ_PORT_SUBS_TIMESTAMP   (1<<1)
-#define SNDRV_SEQ_PORT_SUBS_TIME_REAL   (1<<2)
-struct snd_seq_port_subscribe {
-        struct snd_seq_addr sender;     /* sender address */
-        struct snd_seq_addr dest;       /* destination address */
-        unsigned int voices;            /* number of voices to be allocated (0 = don't care) */
-        unsigned int flags;             /* modes */
-        unsigned char queue;            /* input time-stamp queue (optional) */
-        unsigned char pad[3];           /* reserved */
-        char reserved[64];
-};
-/* type of query subscription */
-#define SNDRV_SEQ_QUERY_SUBS_READ       0
-#define SNDRV_SEQ_QUERY_SUBS_WRITE      1
-struct snd_seq_query_subs {
-        struct snd_seq_addr root;       /* client/port id to be searched */
-        int type;               /* READ or WRITE */
-        int index;              /* 0..N-1 */
-        int num_subs;           /* R/O: number of subscriptions on this port */
-        struct snd_seq_addr addr;       /* R/O: result */
-        unsigned char queue;    /* R/O: result */
-        unsigned int flags;     /* R/O: result */
-        char reserved[64];      /* for future use */
-};
-/*
- *  IOCTL commands
- */
-#define SNDRV_SEQ_IOCTL_PVERSION        _IOR ('S', 0x00, int)
-#define SNDRV_SEQ_IOCTL_CLIENT_ID       _IOR ('S', 0x01, int)
-#define SNDRV_SEQ_IOCTL_SYSTEM_INFO     _IOWR('S', 0x02, struct snd_seq_system_info)
-#define SNDRV_SEQ_IOCTL_RUNNING_MODE    _IOWR('S', 0x03, struct snd_seq_running_info)
-#define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info)
-#define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info)
-#define SNDRV_SEQ_IOCTL_CREATE_PORT     _IOWR('S', 0x20, struct snd_seq_port_info)
-#define SNDRV_SEQ_IOCTL_DELETE_PORT     _IOW ('S', 0x21, struct snd_seq_port_info)
-#define SNDRV_SEQ_IOCTL_GET_PORT_INFO   _IOWR('S', 0x22, struct snd_seq_port_info)
-#define SNDRV_SEQ_IOCTL_SET_PORT_INFO   _IOW ('S', 0x23, struct snd_seq_port_info)
-#define SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT  _IOW ('S', 0x30, struct snd_seq_port_subscribe)
-#define SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT _IOW ('S', 0x31, struct snd_seq_port_subscribe)
-#define SNDRV_SEQ_IOCTL_CREATE_QUEUE    _IOWR('S', 0x32, struct snd_seq_queue_info)
-#define SNDRV_SEQ_IOCTL_DELETE_QUEUE    _IOW ('S', 0x33, struct snd_seq_queue_info)
-#define SNDRV_SEQ_IOCTL_GET_QUEUE_INFO  _IOWR('S', 0x34, struct snd_seq_queue_info)
-#define SNDRV_SEQ_IOCTL_SET_QUEUE_INFO  _IOWR('S', 0x35, struct snd_seq_queue_info)
-#define SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE _IOWR('S', 0x36, struct snd_seq_queue_info)
-#define SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS _IOWR('S', 0x40, struct snd_seq_queue_status)
-#define SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO _IOWR('S', 0x41, struct snd_seq_queue_tempo)
-#define SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO _IOW ('S', 0x42, struct snd_seq_queue_tempo)
-#define SNDRV_SEQ_IOCTL_GET_QUEUE_OWNER _IOWR('S', 0x43, struct snd_seq_queue_owner)
-#define SNDRV_SEQ_IOCTL_SET_QUEUE_OWNER _IOW ('S', 0x44, struct snd_seq_queue_owner)
-#define SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER _IOWR('S', 0x45, struct snd_seq_queue_timer)
-#define SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER _IOW ('S', 0x46, struct snd_seq_queue_timer)
-/* XXX
-#define SNDRV_SEQ_IOCTL_GET_QUEUE_SYNC  _IOWR('S', 0x53, struct snd_seq_queue_sync)
-#define SNDRV_SEQ_IOCTL_SET_QUEUE_SYNC  _IOW ('S', 0x54, struct snd_seq_queue_sync)
-*/
-#define SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT        _IOWR('S', 0x49, struct snd_seq_queue_client)
-#define SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT        _IOW ('S', 0x4a, struct snd_seq_queue_client)
-#define SNDRV_SEQ_IOCTL_GET_CLIENT_POOL _IOWR('S', 0x4b, struct snd_seq_client_pool)
-#define SNDRV_SEQ_IOCTL_SET_CLIENT_POOL _IOW ('S', 0x4c, struct snd_seq_client_pool)
-#define SNDRV_SEQ_IOCTL_REMOVE_EVENTS   _IOW ('S', 0x4e, struct snd_seq_remove_events)
-#define SNDRV_SEQ_IOCTL_QUERY_SUBS      _IOWR('S', 0x4f, struct snd_seq_query_subs)
-#define SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION        _IOWR('S', 0x50, struct snd_seq_port_subscribe)
-#define SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT       _IOWR('S', 0x51, struct snd_seq_client_info)
-#define SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT _IOWR('S', 0x52, struct snd_seq_port_info)
 #endif /* __SOUND_ASEQUENCER_H */

GPL/trunk/alsa-kernel/include/sound/asound.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 /*
  *  Advanced Linux Sound Architecture - ALSA - Driver
  *  Copyright (c) 1994-2003 by Jaroslav Kysela <perex@perex.cz>,
  *                             Abramo Bagnara <abramo@alsa-project.org>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 #ifndef __SOUND_ASOUND_H
 #define __SOUND_ASOUND_H
-#include <linux/types.h>
-#ifdef __KERNEL__
 #include <linux/ioctl.h>
 #include <linux/time.h>
 #include <asm/byteorder.h>
 #ifdef  __LITTLE_ENDIAN
 #define SNDRV_LITTLE_ENDIAN
 …
 #endif
+#endif /* __KERNEL__ **/
+#ifndef __force
+#define __force
+#endif
+#ifndef __bitwise
+#define __bitwise
+#endif
+#ifdef TARGET_OS2
+#define SNDRV_PCM_VOL_FRONT_LEFT        0
+#define SNDRV_PCM_VOL_FRONT_RIGHT       1
+#define SNDRV_PCM_VOL_REAR_LEFT         2
+#define SNDRV_PCM_VOL_REAR_RIGHT        3
+#define SNDRV_PCM_VOL_CENTER            4
+#define SNDRV_PCM_VOL_LFE               5
+#define SNDRV_PCM_VOL_MAX               100
+struct snd_pcm_volume {
+        int nrchannels;
+        int volume[6];
+};
+#endif
+/*
+ *  protocol version
+ */
+#define SNDRV_PROTOCOL_VERSION(major, minor, subminor) (((major)<<16)|((minor)<<8)|(subminor))
+#define SNDRV_PROTOCOL_MAJOR(version) (((version)>>16)&0xffff)
+#define SNDRV_PROTOCOL_MINOR(version) (((version)>>8)&0xff)
+#define SNDRV_PROTOCOL_MICRO(version) ((version)&0xff)
+#define SNDRV_PROTOCOL_INCOMPATIBLE(kversion, uversion) \
+        (SNDRV_PROTOCOL_MAJOR(kversion) != SNDRV_PROTOCOL_MAJOR(uversion) || \
+         (SNDRV_PROTOCOL_MAJOR(kversion) == SNDRV_PROTOCOL_MAJOR(uversion) && \
+           SNDRV_PROTOCOL_MINOR(kversion) != SNDRV_PROTOCOL_MINOR(uversion)))
+/****************************************************************************
+ *                                                                          *
+ *        Digital audio interface                                           *
+ *                                                                          *
+ ****************************************************************************/
+struct snd_aes_iec958 {
+        unsigned char status[24];       /* AES/IEC958 channel status bits */
+        unsigned char subcode[147];     /* AES/IEC958 subcode bits */
+        unsigned char pad;              /* nothing */
+        unsigned char dig_subframe[4];  /* AES/IEC958 subframe bits */
+};
+/****************************************************************************
+ *                                                                          *
+ *      Section for driver hardware dependent interface - /dev/snd/hw?      *
+ *                                                                          *
+ ****************************************************************************/
+#define SNDRV_HWDEP_VERSION             SNDRV_PROTOCOL_VERSION(1, 0, 1)
+enum {
+        SNDRV_HWDEP_IFACE_OPL2 = 0,
+        SNDRV_HWDEP_IFACE_OPL3,
+        SNDRV_HWDEP_IFACE_OPL4,
+        SNDRV_HWDEP_IFACE_SB16CSP,      /* Creative Signal Processor */
+        SNDRV_HWDEP_IFACE_EMU10K1,      /* FX8010 processor in EMU10K1 chip */
+        SNDRV_HWDEP_IFACE_YSS225,       /* Yamaha FX processor */
+        SNDRV_HWDEP_IFACE_ICS2115,      /* Wavetable synth */
+        SNDRV_HWDEP_IFACE_SSCAPE,       /* Ensoniq SoundScape ISA card (MC68EC000) */
+        SNDRV_HWDEP_IFACE_VX,           /* Digigram VX cards */
+        SNDRV_HWDEP_IFACE_MIXART,       /* Digigram miXart cards */
+        SNDRV_HWDEP_IFACE_USX2Y,        /* Tascam US122, US224 & US428 usb */
+        SNDRV_HWDEP_IFACE_EMUX_WAVETABLE, /* EmuX wavetable */
+        SNDRV_HWDEP_IFACE_BLUETOOTH,    /* Bluetooth audio */
+        SNDRV_HWDEP_IFACE_USX2Y_PCM,    /* Tascam US122, US224 & US428 rawusb pcm */
+        SNDRV_HWDEP_IFACE_PCXHR,        /* Digigram PCXHR */
+        SNDRV_HWDEP_IFACE_SB_RC,        /* SB Extigy/Audigy2NX remote control */
+        SNDRV_HWDEP_IFACE_HDA,          /* HD-audio */
+        SNDRV_HWDEP_IFACE_USB_STREAM,   /* direct access to usb stream */
+        /* Don't forget to change the following: */
+        SNDRV_HWDEP_IFACE_LAST = SNDRV_HWDEP_IFACE_USB_STREAM
+};
+struct snd_hwdep_info {
+        unsigned int device;            /* WR: device number */
+        int card;                       /* R: card number */
+        unsigned char id[64];           /* ID (user selectable) */
+        unsigned char name[80];         /* hwdep name */
+        int iface;                      /* hwdep interface */
+        unsigned char reserved[64];     /* reserved for future */
+};
+/* generic DSP loader */
+struct snd_hwdep_dsp_status {
+        unsigned int version;           /* R: driver-specific version */
+        unsigned char id[32];           /* R: driver-specific ID string */
+        unsigned int num_dsps;          /* R: number of DSP images to transfer */
+        unsigned int dsp_loaded;        /* R: bit flags indicating the loaded DSPs */
+        unsigned int chip_ready;        /* R: 1 = initialization finished */
+        unsigned char reserved[16];     /* reserved for future use */
+};
+struct snd_hwdep_dsp_image {
+        unsigned int index;             /* W: DSP index */
+        unsigned char name[64];         /* W: ID (e.g. file name) */
+        unsigned char __user *image;    /* W: binary image */
+        size_t length;                  /* W: size of image in bytes */
+        unsigned long driver_data;      /* W: driver-specific data */
+};
+#define SNDRV_HWDEP_IOCTL_PVERSION      _IOR ('H', 0x00, int)
+#define SNDRV_HWDEP_IOCTL_INFO          _IOR ('H', 0x01, struct snd_hwdep_info)
+#define SNDRV_HWDEP_IOCTL_DSP_STATUS    _IOR('H', 0x02, struct snd_hwdep_dsp_status)
+#define SNDRV_HWDEP_IOCTL_DSP_LOAD      _IOW('H', 0x03, struct snd_hwdep_dsp_image)
+/*****************************************************************************
+ *                                                                           *
+ *             Digital Audio (PCM) interface - /dev/snd/pcm??                *
+ *                                                                           *
+ *****************************************************************************/
+#define SNDRV_PCM_VERSION               SNDRV_PROTOCOL_VERSION(2, 0, 10)
+typedef unsigned long snd_pcm_uframes_t;
+typedef signed long snd_pcm_sframes_t;
+enum {
+        SNDRV_PCM_CLASS_GENERIC = 0,    /* standard mono or stereo device */
+        SNDRV_PCM_CLASS_MULTI,          /* multichannel device */
+        SNDRV_PCM_CLASS_MODEM,          /* software modem class */
+        SNDRV_PCM_CLASS_DIGITIZER,      /* digitizer class */
+        /* Don't forget to change the following: */
+        SNDRV_PCM_CLASS_LAST = SNDRV_PCM_CLASS_DIGITIZER,
+};
+enum {
+        SNDRV_PCM_SUBCLASS_GENERIC_MIX = 0, /* mono or stereo subdevices are mixed together */
+        SNDRV_PCM_SUBCLASS_MULTI_MIX,   /* multichannel subdevices are mixed together */
+        /* Don't forget to change the following: */
+        SNDRV_PCM_SUBCLASS_LAST = SNDRV_PCM_SUBCLASS_MULTI_MIX,
+};
+enum {
+        SNDRV_PCM_STREAM_PLAYBACK = 0,
+        SNDRV_PCM_STREAM_CAPTURE,
+        SNDRV_PCM_STREAM_LAST = SNDRV_PCM_STREAM_CAPTURE,
+};
+typedef int __bitwise snd_pcm_access_t;
+#define SNDRV_PCM_ACCESS_MMAP_INTERLEAVED       ((__force snd_pcm_access_t) 0) /* interleaved mmap */
+#define SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED    ((__force snd_pcm_access_t) 1) /* noninterleaved mmap */
+#define SNDRV_PCM_ACCESS_MMAP_COMPLEX           ((__force snd_pcm_access_t) 2) /* complex mmap */
+#define SNDRV_PCM_ACCESS_RW_INTERLEAVED         ((__force snd_pcm_access_t) 3) /* readi/writei */
+#define SNDRV_PCM_ACCESS_RW_NONINTERLEAVED      ((__force snd_pcm_access_t) 4) /* readn/writen */
+#define SNDRV_PCM_ACCESS_LAST           SNDRV_PCM_ACCESS_RW_NONINTERLEAVED
+typedef int __bitwise snd_pcm_format_t;
+#define SNDRV_PCM_FORMAT_S8     ((__force snd_pcm_format_t) 0)
+#define SNDRV_PCM_FORMAT_U8     ((__force snd_pcm_format_t) 1)
+#define SNDRV_PCM_FORMAT_S16_LE ((__force snd_pcm_format_t) 2)
+#define SNDRV_PCM_FORMAT_S16_BE ((__force snd_pcm_format_t) 3)
+#define SNDRV_PCM_FORMAT_U16_LE ((__force snd_pcm_format_t) 4)
+#define SNDRV_PCM_FORMAT_U16_BE ((__force snd_pcm_format_t) 5)
+#define SNDRV_PCM_FORMAT_S24_LE ((__force snd_pcm_format_t) 6) /* low three bytes */
+#define SNDRV_PCM_FORMAT_S24_BE ((__force snd_pcm_format_t) 7) /* low three bytes */
+#define SNDRV_PCM_FORMAT_U24_LE ((__force snd_pcm_format_t) 8) /* low three bytes */
+#define SNDRV_PCM_FORMAT_U24_BE ((__force snd_pcm_format_t) 9) /* low three bytes */
+#define SNDRV_PCM_FORMAT_S32_LE ((__force snd_pcm_format_t) 10)
+#define SNDRV_PCM_FORMAT_S32_BE ((__force snd_pcm_format_t) 11)
+#define SNDRV_PCM_FORMAT_U32_LE ((__force snd_pcm_format_t) 12)
+#define SNDRV_PCM_FORMAT_U32_BE ((__force snd_pcm_format_t) 13)
+#define SNDRV_PCM_FORMAT_FLOAT_LE       ((__force snd_pcm_format_t) 14) /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */
+#define SNDRV_PCM_FORMAT_FLOAT_BE       ((__force snd_pcm_format_t) 15) /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */
+#define SNDRV_PCM_FORMAT_FLOAT64_LE     ((__force snd_pcm_format_t) 16) /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */
+#define SNDRV_PCM_FORMAT_FLOAT64_BE     ((__force snd_pcm_format_t) 17) /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */
+#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE ((__force snd_pcm_format_t) 18) /* IEC-958 subframe, Little Endian */
+#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE ((__force snd_pcm_format_t) 19) /* IEC-958 subframe, Big Endian */
+#define SNDRV_PCM_FORMAT_MU_LAW         ((__force snd_pcm_format_t) 20)
+#define SNDRV_PCM_FORMAT_A_LAW          ((__force snd_pcm_format_t) 21)
+#define SNDRV_PCM_FORMAT_IMA_ADPCM      ((__force snd_pcm_format_t) 22)
+#define SNDRV_PCM_FORMAT_MPEG           ((__force snd_pcm_format_t) 23)
+#define SNDRV_PCM_FORMAT_GSM            ((__force snd_pcm_format_t) 24)
+#define SNDRV_PCM_FORMAT_SPECIAL        ((__force snd_pcm_format_t) 31)
+#define SNDRV_PCM_FORMAT_S24_3LE        ((__force snd_pcm_format_t) 32) /* in three bytes */
+#define SNDRV_PCM_FORMAT_S24_3BE        ((__force snd_pcm_format_t) 33) /* in three bytes */
+#define SNDRV_PCM_FORMAT_U24_3LE        ((__force snd_pcm_format_t) 34) /* in three bytes */
+#define SNDRV_PCM_FORMAT_U24_3BE        ((__force snd_pcm_format_t) 35) /* in three bytes */
+#define SNDRV_PCM_FORMAT_S20_3LE        ((__force snd_pcm_format_t) 36) /* in three bytes */
+#define SNDRV_PCM_FORMAT_S20_3BE        ((__force snd_pcm_format_t) 37) /* in three bytes */
+#define SNDRV_PCM_FORMAT_U20_3LE        ((__force snd_pcm_format_t) 38) /* in three bytes */
+#define SNDRV_PCM_FORMAT_U20_3BE        ((__force snd_pcm_format_t) 39) /* in three bytes */
+#define SNDRV_PCM_FORMAT_S18_3LE        ((__force snd_pcm_format_t) 40) /* in three bytes */
+#define SNDRV_PCM_FORMAT_S18_3BE        ((__force snd_pcm_format_t) 41) /* in three bytes */
+#define SNDRV_PCM_FORMAT_U18_3LE        ((__force snd_pcm_format_t) 42) /* in three bytes */
+#define SNDRV_PCM_FORMAT_U18_3BE        ((__force snd_pcm_format_t) 43) /* in three bytes */
+#define SNDRV_PCM_FORMAT_G723_24        ((__force snd_pcm_format_t) 44) /* 8 samples in 3 bytes */
+#define SNDRV_PCM_FORMAT_G723_24_1B     ((__force snd_pcm_format_t) 45) /* 1 sample in 1 byte */
+#define SNDRV_PCM_FORMAT_G723_40        ((__force snd_pcm_format_t) 46) /* 8 Samples in 5 bytes */
+#define SNDRV_PCM_FORMAT_G723_40_1B     ((__force snd_pcm_format_t) 47) /* 1 sample in 1 byte */
+#define SNDRV_PCM_FORMAT_LAST           SNDRV_PCM_FORMAT_G723_40_1B
+#ifdef SNDRV_LITTLE_ENDIAN
+#define SNDRV_PCM_FORMAT_S16            SNDRV_PCM_FORMAT_S16_LE
+#define SNDRV_PCM_FORMAT_U16            SNDRV_PCM_FORMAT_U16_LE
+#define SNDRV_PCM_FORMAT_S24            SNDRV_PCM_FORMAT_S24_LE
+#define SNDRV_PCM_FORMAT_U24            SNDRV_PCM_FORMAT_U24_LE
+#define SNDRV_PCM_FORMAT_S32            SNDRV_PCM_FORMAT_S32_LE
+#define SNDRV_PCM_FORMAT_U32            SNDRV_PCM_FORMAT_U32_LE
+#define SNDRV_PCM_FORMAT_FLOAT          SNDRV_PCM_FORMAT_FLOAT_LE
+#define SNDRV_PCM_FORMAT_FLOAT64        SNDRV_PCM_FORMAT_FLOAT64_LE
+#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE
+#endif
+#ifdef SNDRV_BIG_ENDIAN
+#define SNDRV_PCM_FORMAT_S16            SNDRV_PCM_FORMAT_S16_BE
+#define SNDRV_PCM_FORMAT_U16            SNDRV_PCM_FORMAT_U16_BE
+#define SNDRV_PCM_FORMAT_S24            SNDRV_PCM_FORMAT_S24_BE
+#define SNDRV_PCM_FORMAT_U24            SNDRV_PCM_FORMAT_U24_BE
+#define SNDRV_PCM_FORMAT_S32            SNDRV_PCM_FORMAT_S32_BE
+#define SNDRV_PCM_FORMAT_U32            SNDRV_PCM_FORMAT_U32_BE
+#define SNDRV_PCM_FORMAT_FLOAT          SNDRV_PCM_FORMAT_FLOAT_BE
+#define SNDRV_PCM_FORMAT_FLOAT64        SNDRV_PCM_FORMAT_FLOAT64_BE
+#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE
+#endif
+typedef int __bitwise snd_pcm_subformat_t;
+#define SNDRV_PCM_SUBFORMAT_STD         ((__force snd_pcm_subformat_t) 0)
+#define SNDRV_PCM_SUBFORMAT_LAST        SNDRV_PCM_SUBFORMAT_STD
+#define SNDRV_PCM_INFO_MMAP             0x00000001      /* hardware supports mmap */
+#define SNDRV_PCM_INFO_MMAP_VALID       0x00000002      /* period data are valid during transfer */
+#define SNDRV_PCM_INFO_DOUBLE           0x00000004      /* Double buffering needed for PCM start/stop */
+#define SNDRV_PCM_INFO_BATCH            0x00000010      /* double buffering */
+#define SNDRV_PCM_INFO_INTERLEAVED      0x00000100      /* channels are interleaved */
+#define SNDRV_PCM_INFO_NONINTERLEAVED   0x00000200      /* channels are not interleaved */
+#define SNDRV_PCM_INFO_COMPLEX          0x00000400      /* complex frame organization (mmap only) */
+#define SNDRV_PCM_INFO_BLOCK_TRANSFER   0x00010000      /* hardware transfer block of samples */
+#define SNDRV_PCM_INFO_OVERRANGE        0x00020000      /* hardware supports ADC (capture) overrange detection */
+#define SNDRV_PCM_INFO_RESUME           0x00040000      /* hardware supports stream resume after suspend */
+#define SNDRV_PCM_INFO_PAUSE            0x00080000      /* pause ioctl is supported */
+#define SNDRV_PCM_INFO_HALF_DUPLEX      0x00100000      /* only half duplex */
+#define SNDRV_PCM_INFO_JOINT_DUPLEX     0x00200000      /* playback and capture stream are somewhat correlated */
+#define SNDRV_PCM_INFO_SYNC_START       0x00400000      /* pcm support some kind of sync go */
+#define SNDRV_PCM_INFO_NO_PERIOD_WAKEUP 0x00800000      /* period wakeup can be disabled */
+#define SNDRV_PCM_INFO_FIFO_IN_FRAMES   0x80000000      /* internal kernel flag - FIFO size is in frames */
+typedef int __bitwise snd_pcm_state_t;
+#define SNDRV_PCM_STATE_OPEN            ((__force snd_pcm_state_t) 0) /* stream is open */
+#define SNDRV_PCM_STATE_SETUP           ((__force snd_pcm_state_t) 1) /* stream has a setup */
+#define SNDRV_PCM_STATE_PREPARED        ((__force snd_pcm_state_t) 2) /* stream is ready to start */
+#define SNDRV_PCM_STATE_RUNNING         ((__force snd_pcm_state_t) 3) /* stream is running */
+#define SNDRV_PCM_STATE_XRUN            ((__force snd_pcm_state_t) 4) /* stream reached an xrun */
+#define SNDRV_PCM_STATE_DRAINING        ((__force snd_pcm_state_t) 5) /* stream is draining */
+#define SNDRV_PCM_STATE_PAUSED          ((__force snd_pcm_state_t) 6) /* stream is paused */
+#define SNDRV_PCM_STATE_SUSPENDED       ((__force snd_pcm_state_t) 7) /* hardware is suspended */
+#define SNDRV_PCM_STATE_DISCONNECTED    ((__force snd_pcm_state_t) 8) /* hardware is disconnected */
+#define SNDRV_PCM_STATE_LAST            SNDRV_PCM_STATE_DISCONNECTED
+enum {
+        SNDRV_PCM_MMAP_OFFSET_DATA = 0x00000000,
+        SNDRV_PCM_MMAP_OFFSET_STATUS = 0x80000000,
+        SNDRV_PCM_MMAP_OFFSET_CONTROL = 0x81000000,
+};
+union snd_pcm_sync_id {
+        unsigned char id[16];
+        unsigned short id16[8];
+        unsigned int id32[4];
+};
+struct snd_pcm_info {
+        unsigned int device;            /* RO/WR (control): device number */
+        unsigned int subdevice;         /* RO/WR (control): subdevice number */
+        int stream;                     /* RO/WR (control): stream direction */
+        int card;                       /* R: card number */
+        unsigned char id[64];           /* ID (user selectable) */
+        unsigned char name[80];         /* name of this device */
+        unsigned char subname[32];      /* subdevice name */
+        int dev_class;                  /* SNDRV_PCM_CLASS_* */
+        int dev_subclass;               /* SNDRV_PCM_SUBCLASS_* */
+        unsigned int subdevices_count;
+        unsigned int subdevices_avail;
+        union snd_pcm_sync_id sync;     /* hardware synchronization ID */
+        unsigned char reserved[64];     /* reserved for future... */
+};
+typedef int snd_pcm_hw_param_t;
+#define SNDRV_PCM_HW_PARAM_ACCESS       0       /* Access type */
+#ifdef TARGET_OS2
+#define SNDRV_PCM_HW_PARAM_RATE_MASK    1 /* Format */
+#endif
+#define SNDRV_PCM_HW_PARAM_FORMAT       2       /* Format */
+#define SNDRV_PCM_HW_PARAM_SUBFORMAT    3       /* Subformat */
+#define SNDRV_PCM_HW_PARAM_FIRST_MASK   SNDRV_PCM_HW_PARAM_ACCESS
+#define SNDRV_PCM_HW_PARAM_LAST_MASK    SNDRV_PCM_HW_PARAM_SUBFORMAT
+#define SNDRV_PCM_HW_PARAM_SAMPLE_BITS  8       /* Bits per sample */
+#define SNDRV_PCM_HW_PARAM_FRAME_BITS   9       /* Bits per frame */
+#define SNDRV_PCM_HW_PARAM_CHANNELS     10      /* Channels */
+#define SNDRV_PCM_HW_PARAM_RATE         11      /* Approx rate */
+#define SNDRV_PCM_HW_PARAM_PERIOD_TIME  12      /* Approx distance between
+                                                 * interrupts in us
+                                                 */
+#define SNDRV_PCM_HW_PARAM_PERIOD_SIZE  13      /* Approx frames between
+                                                 * interrupts
+                                                 */
+#define SNDRV_PCM_HW_PARAM_PERIOD_BYTES 14      /* Approx bytes between
+                                                 * interrupts
+                                                 */
+#define SNDRV_PCM_HW_PARAM_PERIODS      15      /* Approx interrupts per
+                                                 * buffer
+                                                 */
+#define SNDRV_PCM_HW_PARAM_BUFFER_TIME  16      /* Approx duration of buffer
+                                                 * in us
+                                                 */
+#define SNDRV_PCM_HW_PARAM_BUFFER_SIZE  17      /* Size of buffer in frames */
+#define SNDRV_PCM_HW_PARAM_BUFFER_BYTES 18      /* Size of buffer in bytes */
+#define SNDRV_PCM_HW_PARAM_TICK_TIME    19      /* Approx tick duration in us */
+#define SNDRV_PCM_HW_PARAM_FIRST_INTERVAL       SNDRV_PCM_HW_PARAM_SAMPLE_BITS
+#define SNDRV_PCM_HW_PARAM_LAST_INTERVAL        SNDRV_PCM_HW_PARAM_TICK_TIME
+#define SNDRV_PCM_HW_PARAMS_NORESAMPLE  (1<<0)  /* avoid rate resampling */
+#define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER       (1<<1)  /* export buffer */
+#define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP    (1<<2)  /* disable period wakeups */
+struct snd_interval {
+        unsigned int min, max;
+        unsigned int openmin:1,
+                     openmax:1,
+                     integer:1,
+                     empty:1;
+};
+#define SNDRV_MASK_MAX  256
+struct snd_mask {
+        __u32 bits[(SNDRV_MASK_MAX+31)/32];
+};
+struct snd_pcm_hw_params {
+        unsigned int flags;
+        struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK -
+                               SNDRV_PCM_HW_PARAM_FIRST_MASK + 1];
+        struct snd_mask mres[5];        /* reserved masks */
+        struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL -
+                                        SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
+        struct snd_interval ires[9];    /* reserved intervals */
+        unsigned int rmask;             /* W: requested masks */
+        unsigned int cmask;             /* R: changed masks */
+        unsigned int info;              /* R: Info flags for returned setup */
+        unsigned int msbits;            /* R: used most significant bits */
+        unsigned int rate_num;          /* R: rate numerator */
+        unsigned int rate_den;          /* R: rate denominator */
+        snd_pcm_uframes_t fifo_size;    /* R: chip FIFO size in frames */
+        unsigned char reserved[64];     /* reserved for future */
+};
+enum {
+        SNDRV_PCM_TSTAMP_NONE = 0,
+        SNDRV_PCM_TSTAMP_ENABLE,
+        SNDRV_PCM_TSTAMP_LAST = SNDRV_PCM_TSTAMP_ENABLE,
+};
+struct snd_pcm_sw_params {
+        int tstamp_mode;                        /* timestamp mode */
+        unsigned int period_step;
+        unsigned int sleep_min;                 /* min ticks to sleep */
+        snd_pcm_uframes_t avail_min;            /* min avail frames for wakeup */
+        snd_pcm_uframes_t xfer_align;           /* obsolete: xfer size need to be a multiple */
+        snd_pcm_uframes_t start_threshold;      /* min hw_avail frames for automatic start */
+        snd_pcm_uframes_t stop_threshold;       /* min avail frames for automatic stop */
+        snd_pcm_uframes_t silence_threshold;    /* min distance from noise for silence filling */
+        snd_pcm_uframes_t silence_size;         /* silence block size */
+        snd_pcm_uframes_t boundary;             /* pointers wrap point */
+        unsigned char reserved[64];             /* reserved for future */
+};
+struct snd_pcm_channel_info {
+        unsigned int channel;
+        __kernel_off_t offset;          /* mmap offset */
+        unsigned int first;             /* offset to first sample in bits */
+        unsigned int step;              /* samples distance in bits */
+};
+struct snd_pcm_status {
+        snd_pcm_state_t state;          /* stream state */
+        struct timespec trigger_tstamp; /* time when stream was started/stopped/paused */
+        struct timespec tstamp;         /* reference timestamp */
+        snd_pcm_uframes_t appl_ptr;     /* appl ptr */
+        snd_pcm_uframes_t hw_ptr;       /* hw ptr */
+        snd_pcm_sframes_t delay;        /* current delay in frames */
+        snd_pcm_uframes_t avail;        /* number of frames available */
+        snd_pcm_uframes_t avail_max;    /* max frames available on hw since last status */
+        snd_pcm_uframes_t overrange;    /* count of ADC (capture) overrange detections from last status */
+        snd_pcm_state_t suspended_state; /* suspended stream state */
+        unsigned char reserved[60];     /* must be filled with zero */
+};
+struct snd_pcm_mmap_status {
+        snd_pcm_state_t state;          /* RO: state - SNDRV_PCM_STATE_XXXX */
+        int pad1;                       /* Needed for 64 bit alignment */
+        snd_pcm_uframes_t hw_ptr;       /* RO: hw ptr (0...boundary-1) */
+        struct timespec tstamp;         /* Timestamp */
+        snd_pcm_state_t suspended_state; /* RO: suspended stream state */
+};
+struct snd_pcm_mmap_control {
+        snd_pcm_uframes_t appl_ptr;     /* RW: appl ptr (0...boundary-1) */
+        snd_pcm_uframes_t avail_min;    /* RW: min available frames for wakeup */
+};
+#define SNDRV_PCM_SYNC_PTR_HWSYNC       (1<<0)  /* execute hwsync */
+#define SNDRV_PCM_SYNC_PTR_APPL         (1<<1)  /* get appl_ptr from driver (r/w op) */
+#define SNDRV_PCM_SYNC_PTR_AVAIL_MIN    (1<<2)  /* get avail_min from driver */
+struct snd_pcm_sync_ptr {
+        unsigned int flags;
+        union {
+                struct snd_pcm_mmap_status status;
+                unsigned char reserved[64];
+        } s;
+        union {
+                struct snd_pcm_mmap_control control;
+                unsigned char reserved[64];
+        } c;
+};
+struct snd_xferi {
+        snd_pcm_sframes_t result;
+        void __user *buf;
+        snd_pcm_uframes_t frames;
+};
+struct snd_xfern {
+        snd_pcm_sframes_t result;
+        void __user * __user *bufs;
+        snd_pcm_uframes_t frames;
+};
+enum {
+        SNDRV_PCM_TSTAMP_TYPE_GETTIMEOFDAY = 0, /* gettimeofday equivalent */
+        SNDRV_PCM_TSTAMP_TYPE_MONOTONIC,        /* posix_clock_monotonic equivalent */
+        SNDRV_PCM_TSTAMP_TYPE_LAST = SNDRV_PCM_TSTAMP_TYPE_MONOTONIC,
+};
+#define SNDRV_PCM_IOCTL_PVERSION        _IOR('A', 0x00, int)
+#define SNDRV_PCM_IOCTL_INFO            _IOR('A', 0x01, struct snd_pcm_info)
+#define SNDRV_PCM_IOCTL_TSTAMP          _IOW('A', 0x02, int)
+#define SNDRV_PCM_IOCTL_TTSTAMP         _IOW('A', 0x03, int)
+#define SNDRV_PCM_IOCTL_HW_REFINE       _IOWR('A', 0x10, struct snd_pcm_hw_params)
+#define SNDRV_PCM_IOCTL_HW_PARAMS       _IOWR('A', 0x11, struct snd_pcm_hw_params)
+#define SNDRV_PCM_IOCTL_HW_FREE         _IO('A', 0x12)
+#define SNDRV_PCM_IOCTL_SW_PARAMS       _IOWR('A', 0x13, struct snd_pcm_sw_params)
+#define SNDRV_PCM_IOCTL_STATUS          _IOR('A', 0x20, struct snd_pcm_status)
+#define SNDRV_PCM_IOCTL_DELAY           _IOR('A', 0x21, snd_pcm_sframes_t)
+#define SNDRV_PCM_IOCTL_HWSYNC          _IO('A', 0x22)
+#define SNDRV_PCM_IOCTL_SYNC_PTR        _IOWR('A', 0x23, struct snd_pcm_sync_ptr)
+#define SNDRV_PCM_IOCTL_CHANNEL_INFO    _IOR('A', 0x32, struct snd_pcm_channel_info)
+#define SNDRV_PCM_IOCTL_PREPARE         _IO('A', 0x40)
+#define SNDRV_PCM_IOCTL_RESET           _IO('A', 0x41)
+#define SNDRV_PCM_IOCTL_START           _IO('A', 0x42)
+#define SNDRV_PCM_IOCTL_DROP            _IO('A', 0x43)
+#define SNDRV_PCM_IOCTL_DRAIN           _IO('A', 0x44)
+#define SNDRV_PCM_IOCTL_PAUSE           _IOW('A', 0x45, int)
+#define SNDRV_PCM_IOCTL_REWIND          _IOW('A', 0x46, snd_pcm_uframes_t)
+#define SNDRV_PCM_IOCTL_RESUME          _IO('A', 0x47)
+#define SNDRV_PCM_IOCTL_XRUN            _IO('A', 0x48)
+#define SNDRV_PCM_IOCTL_FORWARD         _IOW('A', 0x49, snd_pcm_uframes_t)
+#define SNDRV_PCM_IOCTL_WRITEI_FRAMES   _IOW('A', 0x50, struct snd_xferi)
+#define SNDRV_PCM_IOCTL_READI_FRAMES    _IOR('A', 0x51, struct snd_xferi)
+#define SNDRV_PCM_IOCTL_WRITEN_FRAMES   _IOW('A', 0x52, struct snd_xfern)
+#define SNDRV_PCM_IOCTL_READN_FRAMES    _IOR('A', 0x53, struct snd_xfern)
+#define SNDRV_PCM_IOCTL_LINK            _IOW('A', 0x60, int)
+#define SNDRV_PCM_IOCTL_UNLINK          _IO('A', 0x61)
+/*****************************************************************************
+ *                                                                           *
+ *                            MIDI v1.0 interface                            *
+ *                                                                           *
+ *****************************************************************************/
+/*
+ *  Raw MIDI section - /dev/snd/midi??
+ */
+#define SNDRV_RAWMIDI_VERSION           SNDRV_PROTOCOL_VERSION(2, 0, 0)
+enum {
+        SNDRV_RAWMIDI_STREAM_OUTPUT = 0,
+        SNDRV_RAWMIDI_STREAM_INPUT,
+        SNDRV_RAWMIDI_STREAM_LAST = SNDRV_RAWMIDI_STREAM_INPUT,
+};
+#define SNDRV_RAWMIDI_INFO_OUTPUT               0x00000001
+#define SNDRV_RAWMIDI_INFO_INPUT                0x00000002
+#define SNDRV_RAWMIDI_INFO_DUPLEX               0x00000004
+struct snd_rawmidi_info {
+        unsigned int device;            /* RO/WR (control): device number */
+        unsigned int subdevice;         /* RO/WR (control): subdevice number */
+        int stream;                     /* WR: stream */
+        int card;                       /* R: card number */
+        unsigned int flags;             /* SNDRV_RAWMIDI_INFO_XXXX */
+        unsigned char id[64];           /* ID (user selectable) */
+        unsigned char name[80];         /* name of device */
+        unsigned char subname[32];      /* name of active or selected subdevice */
+        unsigned int subdevices_count;
+        unsigned int subdevices_avail;
+        unsigned char reserved[64];     /* reserved for future use */
+};
+struct snd_rawmidi_params {
+        int stream;
+        size_t buffer_size;             /* queue size in bytes */
+        size_t avail_min;               /* minimum avail bytes for wakeup */
+        unsigned int no_active_sensing: 1; /* do not send active sensing byte in close() */
+        unsigned char reserved[16];     /* reserved for future use */
+};
+struct snd_rawmidi_status {
+        int stream;
+        struct timespec tstamp;         /* Timestamp */
+        size_t avail;                   /* available bytes */
+        size_t xruns;                   /* count of overruns since last status (in bytes) */
+        unsigned char reserved[16];     /* reserved for future use */
+};
+#define SNDRV_RAWMIDI_IOCTL_PVERSION    _IOR('W', 0x00, int)
+#define SNDRV_RAWMIDI_IOCTL_INFO        _IOR('W', 0x01, struct snd_rawmidi_info)
+#define SNDRV_RAWMIDI_IOCTL_PARAMS      _IOWR('W', 0x10, struct snd_rawmidi_params)
+#define SNDRV_RAWMIDI_IOCTL_STATUS      _IOWR('W', 0x20, struct snd_rawmidi_status)
+#define SNDRV_RAWMIDI_IOCTL_DROP        _IOW('W', 0x30, int)
+#define SNDRV_RAWMIDI_IOCTL_DRAIN       _IOW('W', 0x31, int)
+/*
+ *  Timer section - /dev/snd/timer
+ */
+#define SNDRV_TIMER_VERSION             SNDRV_PROTOCOL_VERSION(2, 0, 6)
+enum {
+        SNDRV_TIMER_CLASS_NONE = -1,
+        SNDRV_TIMER_CLASS_SLAVE = 0,
+        SNDRV_TIMER_CLASS_GLOBAL,
+        SNDRV_TIMER_CLASS_CARD,
+        SNDRV_TIMER_CLASS_PCM,
+        SNDRV_TIMER_CLASS_LAST = SNDRV_TIMER_CLASS_PCM,
+};
+/* slave timer classes */
+enum {
+        SNDRV_TIMER_SCLASS_NONE = 0,
+        SNDRV_TIMER_SCLASS_APPLICATION,
+        SNDRV_TIMER_SCLASS_SEQUENCER,           /* alias */
+        SNDRV_TIMER_SCLASS_OSS_SEQUENCER,       /* alias */
+        SNDRV_TIMER_SCLASS_LAST = SNDRV_TIMER_SCLASS_OSS_SEQUENCER,
+};
+/* global timers (device member) */
+#define SNDRV_TIMER_GLOBAL_SYSTEM       0
+#define SNDRV_TIMER_GLOBAL_RTC          1
+#define SNDRV_TIMER_GLOBAL_HPET         2
+#define SNDRV_TIMER_GLOBAL_HRTIMER      3
+/* info flags */
+#define SNDRV_TIMER_FLG_SLAVE           (1<<0)  /* cannot be controlled */
+struct snd_timer_id {
+        int dev_class;
+        int dev_sclass;
+        int card;
+        int device;
+        int subdevice;
+};
+struct snd_timer_ginfo {
+        struct snd_timer_id tid;        /* requested timer ID */
+        unsigned int flags;             /* timer flags - SNDRV_TIMER_FLG_* */
+        int card;                       /* card number */
+        unsigned char id[64];           /* timer identification */
+        unsigned char name[80];         /* timer name */
+        unsigned long reserved0;        /* reserved for future use */
+        unsigned long resolution;       /* average period resolution in ns */
+        unsigned long resolution_min;   /* minimal period resolution in ns */
+        unsigned long resolution_max;   /* maximal period resolution in ns */
+        unsigned int clients;           /* active timer clients */
+        unsigned char reserved[32];
+};
+struct snd_timer_gparams {
+        struct snd_timer_id tid;        /* requested timer ID */
+        unsigned long period_num;       /* requested precise period duration (in seconds) - numerator */
+        unsigned long period_den;       /* requested precise period duration (in seconds) - denominator */
+        unsigned char reserved[32];
+};
+struct snd_timer_gstatus {
+        struct snd_timer_id tid;        /* requested timer ID */
+        unsigned long resolution;       /* current period resolution in ns */
+        unsigned long resolution_num;   /* precise current period resolution (in seconds) - numerator */
+        unsigned long resolution_den;   /* precise current period resolution (in seconds) - denominator */
+        unsigned char reserved[32];
+};
+struct snd_timer_select {
+        struct snd_timer_id id; /* bind to timer ID */
+        unsigned char reserved[32];     /* reserved */
+};
+struct snd_timer_info {
+        unsigned int flags;             /* timer flags - SNDRV_TIMER_FLG_* */
+        int card;                       /* card number */
+        unsigned char id[64];           /* timer identificator */
+        unsigned char name[80];         /* timer name */
+        unsigned long reserved0;        /* reserved for future use */
+        unsigned long resolution;       /* average period resolution in ns */
+        unsigned char reserved[64];     /* reserved */
+};
+#define SNDRV_TIMER_PSFLG_AUTO          (1<<0)  /* auto start, otherwise one-shot */
+#define SNDRV_TIMER_PSFLG_EXCLUSIVE     (1<<1)  /* exclusive use, precise start/stop/pause/continue */
+#define SNDRV_TIMER_PSFLG_EARLY_EVENT   (1<<2)  /* write early event to the poll queue */
+struct snd_timer_params {
+        unsigned int flags;             /* flags - SNDRV_MIXER_PSFLG_* */
+        unsigned int ticks;             /* requested resolution in ticks */
+        unsigned int queue_size;        /* total size of queue (32-1024) */
+        unsigned int reserved0;         /* reserved, was: failure locations */
+        unsigned int filter;            /* event filter (bitmask of SNDRV_TIMER_EVENT_*) */
+        unsigned char reserved[60];     /* reserved */
+};
+struct snd_timer_status {
+        struct timespec tstamp;         /* Timestamp - last update */
+        unsigned int resolution;        /* current period resolution in ns */
+        unsigned int lost;              /* counter of master tick lost */
+        unsigned int overrun;           /* count of read queue overruns */
+        unsigned int queue;             /* used queue size */
+        unsigned char reserved[64];     /* reserved */
+};
+#define SNDRV_TIMER_IOCTL_PVERSION      _IOR('T', 0x00, int)
+#define SNDRV_TIMER_IOCTL_NEXT_DEVICE   _IOWR('T', 0x01, struct snd_timer_id)
+#define SNDRV_TIMER_IOCTL_TREAD         _IOW('T', 0x02, int)
+#define SNDRV_TIMER_IOCTL_GINFO         _IOWR('T', 0x03, struct snd_timer_ginfo)
+#define SNDRV_TIMER_IOCTL_GPARAMS       _IOW('T', 0x04, struct snd_timer_gparams)
+#define SNDRV_TIMER_IOCTL_GSTATUS       _IOWR('T', 0x05, struct snd_timer_gstatus)
+#define SNDRV_TIMER_IOCTL_SELECT        _IOW('T', 0x10, struct snd_timer_select)
+#define SNDRV_TIMER_IOCTL_INFO          _IOR('T', 0x11, struct snd_timer_info)
+#define SNDRV_TIMER_IOCTL_PARAMS        _IOW('T', 0x12, struct snd_timer_params)
+#define SNDRV_TIMER_IOCTL_STATUS        _IOR('T', 0x14, struct snd_timer_status)
+/* The following four ioctls are changed since 1.0.9 due to confliction */
+#define SNDRV_TIMER_IOCTL_START         _IO('T', 0xa0)
+#define SNDRV_TIMER_IOCTL_STOP          _IO('T', 0xa1)
+#define SNDRV_TIMER_IOCTL_CONTINUE      _IO('T', 0xa2)
+#define SNDRV_TIMER_IOCTL_PAUSE         _IO('T', 0xa3)
+struct snd_timer_read {
+        unsigned int resolution;
+        unsigned int ticks;
+};
+enum {
+        SNDRV_TIMER_EVENT_RESOLUTION = 0,       /* val = resolution in ns */
+        SNDRV_TIMER_EVENT_TICK,                 /* val = ticks */
+        SNDRV_TIMER_EVENT_START,                /* val = resolution in ns */
+        SNDRV_TIMER_EVENT_STOP,                 /* val = 0 */
+        SNDRV_TIMER_EVENT_CONTINUE,             /* val = resolution in ns */
+        SNDRV_TIMER_EVENT_PAUSE,                /* val = 0 */
+        SNDRV_TIMER_EVENT_EARLY,                /* val = 0, early event */
+        SNDRV_TIMER_EVENT_SUSPEND,              /* val = 0 */
+        SNDRV_TIMER_EVENT_RESUME,               /* val = resolution in ns */
+        /* master timer events for slave timer instances */
+        SNDRV_TIMER_EVENT_MSTART = SNDRV_TIMER_EVENT_START + 10,
+        SNDRV_TIMER_EVENT_MSTOP = SNDRV_TIMER_EVENT_STOP + 10,
+        SNDRV_TIMER_EVENT_MCONTINUE = SNDRV_TIMER_EVENT_CONTINUE + 10,
+        SNDRV_TIMER_EVENT_MPAUSE = SNDRV_TIMER_EVENT_PAUSE + 10,
+        SNDRV_TIMER_EVENT_MSUSPEND = SNDRV_TIMER_EVENT_SUSPEND + 10,
+        SNDRV_TIMER_EVENT_MRESUME = SNDRV_TIMER_EVENT_RESUME + 10,
+};
+struct snd_timer_tread {
+        int event;
+        struct timespec tstamp;
+        unsigned int val;
+};
+/****************************************************************************
+ *                                                                          *
+ *        Section for driver control interface - /dev/snd/control?          *
+ *                                                                          *
+ ****************************************************************************/
+#define SNDRV_CTL_VERSION               SNDRV_PROTOCOL_VERSION(2, 0, 6)
+/******************** This section used in uniaud.dll interface *********************/
+struct snd_ctl_card_info {
+        int card;                       /* card number */
+        int pad;                        /* reserved for future (was type) */
+        unsigned char id[16];           /* ID of card (user selectable) */
+        unsigned char driver[16];       /* Driver name */
+        unsigned char name[32];         /* Short name of soundcard */
+        unsigned char longname[80];     /* name + info text about soundcard */
+        unsigned char reserved_[16];    /* reserved for future (was ID of mixer) */
+        unsigned char mixername[80];    /* visual mixer identification */
+        unsigned char components[128];  /* card components / fine identification, delimited with one space (AC97 etc..) */
+};
+typedef int __bitwise snd_ctl_elem_type_t;
+#define SNDRV_CTL_ELEM_TYPE_NONE        ((__force snd_ctl_elem_type_t) 0) /* invalid */
+#define SNDRV_CTL_ELEM_TYPE_BOOLEAN     ((__force snd_ctl_elem_type_t) 1) /* boolean type */
+#define SNDRV_CTL_ELEM_TYPE_INTEGER     ((__force snd_ctl_elem_type_t) 2) /* integer type */
+#define SNDRV_CTL_ELEM_TYPE_ENUMERATED  ((__force snd_ctl_elem_type_t) 3) /* enumerated type */
+#define SNDRV_CTL_ELEM_TYPE_BYTES       ((__force snd_ctl_elem_type_t) 4) /* byte array */
+#define SNDRV_CTL_ELEM_TYPE_IEC958      ((__force snd_ctl_elem_type_t) 5) /* IEC958 (S/PDIF) setup */
+#define SNDRV_CTL_ELEM_TYPE_INTEGER64   ((__force snd_ctl_elem_type_t) 6) /* 64-bit integer type */
+#define SNDRV_CTL_ELEM_TYPE_LAST        SNDRV_CTL_ELEM_TYPE_INTEGER64
+typedef int __bitwise snd_ctl_elem_iface_t;
+#define SNDRV_CTL_ELEM_IFACE_CARD       ((__force snd_ctl_elem_iface_t) 0) /* global control */
+#define SNDRV_CTL_ELEM_IFACE_HWDEP      ((__force snd_ctl_elem_iface_t) 1) /* hardware dependent device */
+#define SNDRV_CTL_ELEM_IFACE_MIXER      ((__force snd_ctl_elem_iface_t) 2) /* virtual mixer device */
+#define SNDRV_CTL_ELEM_IFACE_PCM        ((__force snd_ctl_elem_iface_t) 3) /* PCM device */
+#define SNDRV_CTL_ELEM_IFACE_RAWMIDI    ((__force snd_ctl_elem_iface_t) 4) /* RawMidi device */
+#define SNDRV_CTL_ELEM_IFACE_TIMER      ((__force snd_ctl_elem_iface_t) 5) /* timer device */
+#define SNDRV_CTL_ELEM_IFACE_SEQUENCER  ((__force snd_ctl_elem_iface_t) 6) /* sequencer client */
+#define SNDRV_CTL_ELEM_IFACE_LAST       SNDRV_CTL_ELEM_IFACE_SEQUENCER
+#define SNDRV_CTL_ELEM_ACCESS_READ              (1<<0)
+#define SNDRV_CTL_ELEM_ACCESS_WRITE             (1<<1)
+#define SNDRV_CTL_ELEM_ACCESS_READWRITE         (SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE)
+#define SNDRV_CTL_ELEM_ACCESS_VOLATILE          (1<<2)  /* control value may be changed without a notification */
+#define SNDRV_CTL_ELEM_ACCESS_TIMESTAMP         (1<<3)  /* when was control changed */
+#define SNDRV_CTL_ELEM_ACCESS_TLV_READ          (1<<4)  /* TLV read is possible */
+#define SNDRV_CTL_ELEM_ACCESS_TLV_WRITE         (1<<5)  /* TLV write is possible */
+#define SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE     (SNDRV_CTL_ELEM_ACCESS_TLV_READ|SNDRV_CTL_ELEM_ACCESS_TLV_WRITE)
+#define SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND       (1<<6)  /* TLV command is possible */
+#define SNDRV_CTL_ELEM_ACCESS_INACTIVE          (1<<8)  /* control does actually nothing, but may be updated */
+#define SNDRV_CTL_ELEM_ACCESS_LOCK              (1<<9)  /* write lock */
+#define SNDRV_CTL_ELEM_ACCESS_OWNER             (1<<10) /* write lock owner */
+#define SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK      (1<<28) /* kernel use a TLV callback */
+#define SNDRV_CTL_ELEM_ACCESS_USER              (1<<29) /* user space element */
+/* bits 30 and 31 are obsoleted (for indirect access) */
+/* for further details see the ACPI and PCI power management specification */
+#define SNDRV_CTL_POWER_D0              0x0000  /* full On */
+#define SNDRV_CTL_POWER_D1              0x0100  /* partial On */
+#define SNDRV_CTL_POWER_D2              0x0200  /* partial On */
+#define SNDRV_CTL_POWER_D3              0x0300  /* Off */
+#define SNDRV_CTL_POWER_D3hot           (SNDRV_CTL_POWER_D3|0x0000)     /* Off, with power */
+#define SNDRV_CTL_POWER_D3cold          (SNDRV_CTL_POWER_D3|0x0001)     /* Off, without power */
+struct snd_ctl_elem_id {
+        unsigned int numid;             /* numeric identifier, zero = invalid */
+        snd_ctl_elem_iface_t iface;     /* interface identifier */
+        unsigned int device;            /* device/client number */
+        unsigned int subdevice;         /* subdevice (substream) number */
+        unsigned char name[44];         /* ASCII name of item */
+        unsigned int index;             /* index of item */
+};
+struct snd_ctl_elem_list {
+        unsigned int offset;            /* W: first element ID to get */
+        unsigned int space;             /* W: count of element IDs to get */
+        unsigned int used;              /* R: count of element IDs set */
+        unsigned int count;             /* R: count of all elements */
+        struct snd_ctl_elem_id __user *pids; /* R: IDs */
+        unsigned char reserved[50];
+};
+struct snd_ctl_elem_info {
+        struct snd_ctl_elem_id id;      /* W: element ID */
+        snd_ctl_elem_type_t type;       /* R: value type - SNDRV_CTL_ELEM_TYPE_* */
+        unsigned int access;            /* R: value access (bitmask) - SNDRV_CTL_ELEM_ACCESS_* */
+        unsigned int count;             /* count of values */
+        __kernel_pid_t owner;           /* owner's PID of this control */
+        union {
+                struct {
+                        long min;               /* R: minimum value */
+                        long max;               /* R: maximum value */
+                        long step;              /* R: step (0 variable) */
+                } integer;
+                struct {
+                        long long min;          /* R: minimum value */
+                        long long max;          /* R: maximum value */
+                        long long step;         /* R: step (0 variable) */
+                } integer64;
+                struct {
+                        unsigned int items;     /* R: number of items */
+                        unsigned int item;      /* W: item number */
+                        char name[64];          /* R: value name */
+                } enumerated;
+                unsigned char reserved[128];
+        } value;
+        union {
+                unsigned short d[4];            /* dimensions */
+                unsigned short *d_ptr;          /* indirect - obsoleted */
+        } dimen;
+        unsigned char reserved[64-4*sizeof(unsigned short)];
+};
+struct snd_ctl_elem_value {
+        struct snd_ctl_elem_id id;      /* W: element ID */
+        unsigned int indirect: 1;       /* W: indirect access - obsoleted */
+        union {
+                union {
+                        long value[128];
+                        long *value_ptr;        /* obsoleted */
+                } integer;
+                union {
+                        long long value[64];
+                        long long *value_ptr;   /* obsoleted */
+                } integer64;
+                union {
+                        unsigned int item[128];
+                        unsigned int *item_ptr; /* obsoleted */
+                } enumerated;
+                union {
+                        unsigned char data[512];
+                        unsigned char *data_ptr;        /* obsoleted */
+                } bytes;
+                struct snd_aes_iec958 iec958;
+        } value;                /* RO */
+        struct timespec tstamp;
+        unsigned char reserved[128-sizeof(struct timespec)];
+};
+struct snd_ctl_tlv {
+        unsigned int numid;     /* control element numeric identification */
+        unsigned int length;    /* in bytes aligned to 4 */
+#ifndef TARGET_OS2
+        unsigned int tlv[0];    /* first TLV */
+#else
+        unsigned int tlv[1];    /* first TLV */
+#endif
+};
+#define SNDRV_CTL_IOCTL_PVERSION        _IOR('U', 0x00, int)
+#define SNDRV_CTL_IOCTL_CARD_INFO       _IOR('U', 0x01, struct snd_ctl_card_info)
+#define SNDRV_CTL_IOCTL_ELEM_LIST       _IOWR('U', 0x10, struct snd_ctl_elem_list)
+#define SNDRV_CTL_IOCTL_ELEM_INFO       _IOWR('U', 0x11, struct snd_ctl_elem_info)
+#define SNDRV_CTL_IOCTL_ELEM_READ       _IOWR('U', 0x12, struct snd_ctl_elem_value)
+#define SNDRV_CTL_IOCTL_ELEM_WRITE      _IOWR('U', 0x13, struct snd_ctl_elem_value)
+#define SNDRV_CTL_IOCTL_ELEM_LOCK       _IOW('U', 0x14, struct snd_ctl_elem_id)
+#define SNDRV_CTL_IOCTL_ELEM_UNLOCK     _IOW('U', 0x15, struct snd_ctl_elem_id)
+#define SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS _IOWR('U', 0x16, int)
+#define SNDRV_CTL_IOCTL_ELEM_ADD        _IOWR('U', 0x17, struct snd_ctl_elem_info)
+#define SNDRV_CTL_IOCTL_ELEM_REPLACE    _IOWR('U', 0x18, struct snd_ctl_elem_info)
+#define SNDRV_CTL_IOCTL_ELEM_REMOVE     _IOWR('U', 0x19, struct snd_ctl_elem_id)
+#define SNDRV_CTL_IOCTL_TLV_READ        _IOWR('U', 0x1a, struct snd_ctl_tlv)
+#define SNDRV_CTL_IOCTL_TLV_WRITE       _IOWR('U', 0x1b, struct snd_ctl_tlv)
+#define SNDRV_CTL_IOCTL_TLV_COMMAND     _IOWR('U', 0x1c, struct snd_ctl_tlv)
+#define SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE _IOWR('U', 0x20, int)
+#define SNDRV_CTL_IOCTL_HWDEP_INFO      _IOR('U', 0x21, struct snd_hwdep_info)
+#define SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE _IOR('U', 0x30, int)
+#define SNDRV_CTL_IOCTL_PCM_INFO        _IOWR('U', 0x31, struct snd_pcm_info)
+#define SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE _IOW('U', 0x32, int)
+#define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int)
+#define SNDRV_CTL_IOCTL_RAWMIDI_INFO    _IOWR('U', 0x41, struct snd_rawmidi_info)
+#define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int)
+#define SNDRV_CTL_IOCTL_POWER           _IOWR('U', 0xd0, int)
+#define SNDRV_CTL_IOCTL_POWER_STATE     _IOR('U', 0xd1, int)
+#ifdef TARGET_OS2
+#define SNDRV_PCM_IOCTL_SETVOLUME       _IOW('A', 0x62, struct snd_pcm_volume)
+#define SNDRV_PCM_IOCTL_GETVOLUME       _IOR('A', 0x63, struct snd_pcm_volume)
+#endif
+/*
+ *  Read interface.
+ */
+enum sndrv_ctl_event_type {
+        SNDRV_CTL_EVENT_ELEM = 0,
+        SNDRV_CTL_EVENT_LAST = SNDRV_CTL_EVENT_ELEM,
+};
+#define SNDRV_CTL_EVENT_MASK_VALUE      (1<<0)  /* element value was changed */
+#define SNDRV_CTL_EVENT_MASK_INFO       (1<<1)  /* element info was changed */
+#define SNDRV_CTL_EVENT_MASK_ADD        (1<<2)  /* element was added */
+#define SNDRV_CTL_EVENT_MASK_TLV        (1<<3)  /* element TLV tree was changed */
+#define SNDRV_CTL_EVENT_MASK_REMOVE     (~0U)   /* element was removed */
+struct snd_ctl_event {
+        int type;       /* event type - SNDRV_CTL_EVENT_* */
+        union {
+                struct {
+                        unsigned int mask;
+                        struct snd_ctl_elem_id id;
+                } elem;
+                unsigned char data8[60];
+        } data;
+};
+/*
+ *  Control names
+ */
+#define SNDRV_CTL_NAME_NONE                             ""
+#define SNDRV_CTL_NAME_PLAYBACK                         "Playback "
+#define SNDRV_CTL_NAME_CAPTURE                          "Capture "
+#define SNDRV_CTL_NAME_IEC958_NONE                      ""
+#define SNDRV_CTL_NAME_IEC958_SWITCH                    "Switch"
+#define SNDRV_CTL_NAME_IEC958_VOLUME                    "Volume"
+#define SNDRV_CTL_NAME_IEC958_DEFAULT                   "Default"
+#define SNDRV_CTL_NAME_IEC958_MASK                      "Mask"
+#define SNDRV_CTL_NAME_IEC958_CON_MASK                  "Con Mask"
+#define SNDRV_CTL_NAME_IEC958_PRO_MASK                  "Pro Mask"
+#define SNDRV_CTL_NAME_IEC958_PCM_STREAM                "PCM Stream"
+#define SNDRV_CTL_NAME_IEC958(expl,direction,what)      "IEC958 " expl SNDRV_CTL_NAME_##direction SNDRV_CTL_NAME_IEC958_##what
+#include <uapi/sound/asound.h>
 #endif /* __SOUND_ASOUND_H */

GPL/trunk/alsa-kernel/include/sound/asoundef.h

-              r399
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_ASOUNDEF_H
 #define __SOUND_ASOUNDEF_H
 …
  *  Advanced Linux Sound Architecture - ALSA - Driver
  *  Copyright (c) 1994-2000 by Jaroslav Kysela <perex@perex.cz>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 …
 #define IEC958_AES5_CON_CGMSA_COPYNEVER (3<<0)  /* no copying is permitted */
+/****************************************************************************
+ *                                                                          *
+ *        CEA-861 Audio InfoFrame. Used in HDMI and DisplayPort             *
+ *                                                                          *
+ ****************************************************************************/
+#define CEA861_AUDIO_INFOFRAME_DB1CC            (7<<0) /* mask - channel count */
+#define CEA861_AUDIO_INFOFRAME_DB1CT            (0xf<<4) /* mask - coding type */
+#define CEA861_AUDIO_INFOFRAME_DB1CT_FROM_STREAM (0<<4) /* refer to stream */
+#define CEA861_AUDIO_INFOFRAME_DB1CT_IEC60958   (1<<4) /* IEC-60958 L-PCM */
+#define CEA861_AUDIO_INFOFRAME_DB1CT_AC3        (2<<4) /* AC-3 */
+#define CEA861_AUDIO_INFOFRAME_DB1CT_MPEG1      (3<<4) /* MPEG1 Layers 1 & 2 */
+#define CEA861_AUDIO_INFOFRAME_DB1CT_MP3        (4<<4) /* MPEG1 Layer 3 */
+#define CEA861_AUDIO_INFOFRAME_DB1CT_MPEG2_MULTICH (5<<4) /* MPEG2 Multichannel */
+#define CEA861_AUDIO_INFOFRAME_DB1CT_AAC        (6<<4) /* AAC */
+#define CEA861_AUDIO_INFOFRAME_DB1CT_DTS        (7<<4) /* DTS */
+#define CEA861_AUDIO_INFOFRAME_DB1CT_ATRAC      (8<<4) /* ATRAC */
+#define CEA861_AUDIO_INFOFRAME_DB1CT_ONEBIT     (9<<4) /* One Bit Audio */
+#define CEA861_AUDIO_INFOFRAME_DB1CT_DOLBY_DIG_PLUS (10<<4) /* Dolby Digital + */
+#define CEA861_AUDIO_INFOFRAME_DB1CT_DTS_HD     (11<<4) /* DTS-HD */
+#define CEA861_AUDIO_INFOFRAME_DB1CT_MAT        (12<<4) /* MAT (MLP) */
+#define CEA861_AUDIO_INFOFRAME_DB1CT_DST        (13<<4) /* DST */
+#define CEA861_AUDIO_INFOFRAME_DB1CT_WMA_PRO    (14<<4) /* WMA Pro */
+#define CEA861_AUDIO_INFOFRAME_DB2SF            (7<<2) /* mask - sample frequency */
+#define CEA861_AUDIO_INFOFRAME_DB2SF_FROM_STREAM (0<<2) /* refer to stream */
+#define CEA861_AUDIO_INFOFRAME_DB2SF_32000      (1<<2) /* 32kHz */
+#define CEA861_AUDIO_INFOFRAME_DB2SF_44100      (2<<2) /* 44.1kHz */
+#define CEA861_AUDIO_INFOFRAME_DB2SF_48000      (3<<2) /* 48kHz */
+#define CEA861_AUDIO_INFOFRAME_DB2SF_88200      (4<<2) /* 88.2kHz */
+#define CEA861_AUDIO_INFOFRAME_DB2SF_96000      (5<<2) /* 96kHz */
+#define CEA861_AUDIO_INFOFRAME_DB2SF_176400     (6<<2) /* 176.4kHz */
+#define CEA861_AUDIO_INFOFRAME_DB2SF_192000     (7<<2) /* 192kHz */
+#define CEA861_AUDIO_INFOFRAME_DB2SS            (3<<0) /* mask - sample size */
+#define CEA861_AUDIO_INFOFRAME_DB2SS_FROM_STREAM (0<<0) /* refer to stream */
+#define CEA861_AUDIO_INFOFRAME_DB2SS_16BIT      (1<<0) /* 16 bits */
+#define CEA861_AUDIO_INFOFRAME_DB2SS_20BIT      (2<<0) /* 20 bits */
+#define CEA861_AUDIO_INFOFRAME_DB2SS_24BIT      (3<<0) /* 24 bits */
+#define CEA861_AUDIO_INFOFRAME_DB5_DM_INH       (1<<7) /* mask - inhibit downmixing */
+#define CEA861_AUDIO_INFOFRAME_DB5_DM_INH_PERMITTED (0<<7) /* stereo downmix permitted */
+#define CEA861_AUDIO_INFOFRAME_DB5_DM_INH_PROHIBITED (1<<7) /* stereo downmis prohibited */
+#define CEA861_AUDIO_INFOFRAME_DB5_LSV          (0xf<<3) /* mask - level-shift values */
 /*****************************************************************************
  *                                                                           *

GPL/trunk/alsa-kernel/include/sound/config.h

-              r598
+              r679
 #include <linux/version.h>
-#include <linux/types.h>
-#include <linux/fcntl.h>
-#include <linux/signal.h>
-#include <linux/kdev_t.h>
-#include <linux/wait.h>
-#include <linux/list.h>
-#include <linux/init.h>
-#include <linux/dcache.h>
-#include <linux/vmalloc.h>
-#include <linux/tqueue.h>
-#include <linux/time.h>
-#include <linux/timer.h>
-#include <linux/stat.h>
-#include <linux/major.h>
-#include <linux/fs.h>
-#include <linux/pid.h>
-#include <linux/err.h>
-#include <linux/gfp.h>
-#include <linux/workqueue.h>
-#include <linux/byteorder/little_endian.h>
-#include <linux/lockdep.h>
-#include <linux/string.h>
-#include <asm/ioctl.h>
-#include <asm/hardirq.h>
-#include <asm/processor.h>
-#include <asm/siginfo.h>
-#include <dbgos2.h>
-#include <limits.h>
-#include <sys/cdefs.h>
-#include <stdio.h>
-#include <linux/config.h>
-#include <linux/module.h>
-#include <linux/utsname.h>
-#include <linux/errno.h>
-#include <linux/kernel.h>
-#include <linux/sched.h>
-#include <linux/malloc.h>
-#include <linux/delay.h>
-#include <linux/ioport.h>
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/segment.h>
-#include <asm/uaccess.h>
-#include <asm/system.h>
-#include <asm/string.h>
-#include <linux/pci.h>
-#include <linux/interrupt.h>
-#include <linux/pagemap.h>
-#include <linux/fs.h>
-#include <linux/fcntl.h>
-#include <linux/vmalloc.h>
-#include <linux/poll.h>
-#include <linux/reboot.h>
-#include <linux/init.h>
-#include <linux/lockdep.h>
-#include <linux/smp_lock.h>
-#include <linux/dma-mapping.h>
-#include "compat_22.h"
-#include <sound/asound.h>
-#include <sound/asoundef.h>
 /*
 …
 #define CONFIG_PCI
 #define CONFIG_PM
 #define CONFIG_PROC_FS
+#define CONFIG_PM_SLEEP
 #ifdef DEBUG
 #define CONFIG_SND_DEBUG_DETECT
+#endif
 #define CONFIG_SND_DEBUG_VERBOSE
-#endif
 #define CONFIG_SND_DMA_SGBUF
 #define CONFIG_SND_HDA_CODEC_ANALOG
 …
 #define CONFIG_SND_HDA_GENERIC
 #define CONFIG_SND_HDA_HWDEP
+#define CONFIG_SND_HDA_PREALLOC_SIZE  64
 #define CONFIG_SND_OSSEMUL
-#define CONFIG_SND_PCM_OSS
 #define CONFIG_SND_SEQUENCER
 #define CONFIG_SOUND
 #define CONFIG_SYSFS_DEPRECATED
+#define CONFIG_SND_PROC_FS
+#define CONFIG_SND_JACK
+//#define CONFIG_SND_DYNAMIC_MINORS //new 2020-12-26
+//#define CONFIG_SND_MAX_CARDS 8 //new 2020-12-26
 #define PCI_NEW_SUSPEND
 #define SNDRV_LITTLE_ENDIAN
+#define CONFIG_SND_HDA_POWER_SAVE_DEFAULT 1
+#define CONFIG_SND_PCM_TIMER 1
+#define CONFIG_PROC_FS 1 /* new oct 2020 */
+#define CONFIG_SND_PCM_OSS 1
 /* Still need to work out where the following really belong */
 #undef interrupt
-#define __builtin_return_address(a)     0
-#define __builtin_expect(x, expected_value) (x)
-#define BUG_ON(x) /* nothing */
 #define assert(a)
 #define no_llseek       NULL
 #define noop_llseek     NULL
-struct class;
-struct class_device;
-struct class_device_attribute {int x; }; /* dummy */
-#define __ATTR(cls,perm,read,write) {0 } /* dummy */
 #define min_t(type, x, y) ({                    \

GPL/trunk/alsa-kernel/include/sound/control.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_CONTROL_H
 #define __SOUND_CONTROL_H
 …
  *  Header file for control interface
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
+ *
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ */
+ */
+#include <linux/wait.h>
+#include <linux/nospec.h>
 #include <sound/asound.h>
 …
 typedef int (snd_kcontrol_put_t) (struct snd_kcontrol * kcontrol, struct snd_ctl_elem_value * ucontrol);
 typedef int (snd_kcontrol_tlv_rw_t)(struct snd_kcontrol *kcontrol,
                                     int op_flag, /* 0=read,1=write,-1=command */
+                                    int op_flag, /* SNDRV_CTL_TLV_OP_XXX */
                                     unsigned int size,
                                     unsigned int __user *tlv);
+/* internal flag for skipping validations */
+#ifdef CONFIG_SND_CTL_VALIDATION
+#define SNDRV_CTL_ELEM_ACCESS_SKIP_CHECK        (1 << 27)
+#define snd_ctl_skip_validation(info) \
+        ((info)->access & SNDRV_CTL_ELEM_ACCESS_SKIP_CHECK)
+#else
+#define SNDRV_CTL_ELEM_ACCESS_SKIP_CHECK        0
+#define snd_ctl_skip_validation(info)           true
+#endif
+enum {
+        SNDRV_CTL_TLV_OP_READ = 0,
+        SNDRV_CTL_TLV_OP_WRITE = 1,
+        SNDRV_CTL_TLV_OP_CMD = -1,
+};
 struct snd_kcontrol_new {
 …
         unsigned int device;            /* device/client number */
         unsigned int subdevice;         /* subdevice (substream) number */
         unsigned char *name;            /* ASCII name of item */
+        const char *name;               /* ASCII name of item */
         unsigned int index;             /* index of item */
         unsigned int access;            /* access rights */
 …
         } tlv;
         unsigned long private_value;
-#ifdef TARGET_OS2
-        void *private_ptr;
-#endif
         void *private_data;
         void (*private_free)(struct snd_kcontrol *kcontrol);
+#ifndef TARGET_OS2
+        struct snd_kcontrol_volatile vd[0];     /* volatile data */
+#else
+        struct snd_kcontrol_volatile vd[1];     /* volatile data */
+#endif
+        struct snd_kcontrol_volatile vd[];      /* volatile data */
 };
 …
 struct pid;
+enum {
+        SND_CTL_SUBDEV_PCM,
+        SND_CTL_SUBDEV_RAWMIDI,
+        SND_CTL_SUBDEV_ITEMS,
+};
 struct snd_ctl_file {
         struct list_head list;          /* list of all control files */
         struct snd_card *card;
         struct pid *pid;
+        int prefer_pcm_subdevice;
+        int prefer_rawmidi_subdevice;
+        int preferred_subdevice[SND_CTL_SUBDEV_ITEMS];
         wait_queue_head_t change_sleep;
         spinlock_t read_lock;
 …
 int snd_ctl_add(struct snd_card * card, struct snd_kcontrol * kcontrol);
 int snd_ctl_remove(struct snd_card * card, struct snd_kcontrol * kcontrol);
+int snd_ctl_replace(struct snd_card *card, struct snd_kcontrol *kcontrol, bool add_on_replace);
 int snd_ctl_remove_id(struct snd_card * card, struct snd_ctl_elem_id *id);
 int snd_ctl_rename_id(struct snd_card * card, struct snd_ctl_elem_id *src_id, struct snd_ctl_elem_id *dst_id);
+int snd_ctl_activate_id(struct snd_card *card, struct snd_ctl_elem_id *id,
+                        int active);
 struct snd_kcontrol *snd_ctl_find_numid(struct snd_card * card, unsigned int numid);
 struct snd_kcontrol *snd_ctl_find_id(struct snd_card * card, struct snd_ctl_elem_id *id);
 …
 #endif
+int snd_ctl_get_preferred_subdevice(struct snd_card *card, int type);
 static inline unsigned int snd_ctl_get_ioffnum(struct snd_kcontrol *kctl, struct snd_ctl_elem_id *id)
+{
+        return id->numid - kctl->id.numid;
+        unsigned int ioff = id->numid - kctl->id.numid;
+        return array_index_nospec(ioff, kctl->count);
+}
 static inline unsigned int snd_ctl_get_ioffidx(struct snd_kcontrol *kctl, struct snd_ctl_elem_id *id)
+{
+        return id->index - kctl->id.index;
+        unsigned int ioff = id->index - kctl->id.index;
+        return array_index_nospec(ioff, kctl->count);
+}
 …
 struct snd_kcontrol *snd_ctl_make_virtual_master(char *name,
                                                  const unsigned int *tlv);
+int _snd_ctl_add_slave(struct snd_kcontrol *master, struct snd_kcontrol *slave,
+                       unsigned int flags);
+/* optional flags for slave */
+#define SND_CTL_SLAVE_NEED_UPDATE       (1 << 0)
+int _snd_ctl_add_follower(struct snd_kcontrol *master,
+                          struct snd_kcontrol *follower,
+                          unsigned int flags);
+/* optional flags for follower */
+#define SND_CTL_FOLLOWER_NEED_UPDATE    (1 << 0)
 /**
  * snd_ctl_add_slave - Add a virtual slave control
+ * snd_ctl_add_follower - Add a virtual follower control
  * @master: vmaster element
  * @slave: slave element to add
+ *
  * Add a virtual slave control to the given master element created via
+ * @follower: follower element to add
+ *
+ * Add a virtual follower control to the given master element created via
  * snd_ctl_create_virtual_master() beforehand.
+ * Returns zero if successful or a negative error code.
+ *
+ * All slaves must be the same type (returning the same information
+ * via info callback).  The fucntion doesn't check it, so it's your
+ *
+ * All followers must be the same type (returning the same information
+ * via info callback).  The function doesn't check it, so it's your
  * responsibility.
+ *
 …
  * logarithmic volume control (dB level) thus no linear volume,
  * master can only attenuate the volume without gain
+ *
+ * Return: Zero if successful or a negative error code.
  */
 static inline int
 snd_ctl_add_slave(struct snd_kcontrol *master, struct snd_kcontrol *slave)
+{
         return _snd_ctl_add_slave(master, slave, 0);
+snd_ctl_add_follower(struct snd_kcontrol *master, struct snd_kcontrol *follower)
+{
+        return _snd_ctl_add_follower(master, follower, 0);
+}
 /**
  * snd_ctl_add_slave_uncached - Add a virtual slave control
+ * snd_ctl_add_follower_uncached - Add a virtual follower control
  * @master: vmaster element
  * @slave: slave element to add
+ *
  * Add a virtual slave control to the given master.
  * Unlike snd_ctl_add_slave(), the element added via this function
+ * @follower: follower element to add
+ *
+ * Add a virtual follower control to the given master.
+ * Unlike snd_ctl_add_follower(), the element added via this function
  * is supposed to have volatile values, and get callback is called
  * at each time quried from the master.
+ * at each time queried from the master.
+ *
  * When the control peeks the hardware values directly and the value
  * can be changed by other means than the put callback of the element,
  * this function should be used to keep the value always up-to-date.
+ *
+ * Return: Zero if successful or a negative error code.
  */
 static inline int
+snd_ctl_add_slave_uncached(struct snd_kcontrol *master,
+                           struct snd_kcontrol *slave)
+{
+        return _snd_ctl_add_slave(master, slave, SND_CTL_SLAVE_NEED_UPDATE);
+}
+snd_ctl_add_follower_uncached(struct snd_kcontrol *master,
+                              struct snd_kcontrol *follower)
+{
+        return _snd_ctl_add_follower(master, follower, SND_CTL_FOLLOWER_NEED_UPDATE);
+}
+int snd_ctl_add_vmaster_hook(struct snd_kcontrol *kctl,
+                             void (*hook)(void *private_data, int),
+                             void *private_data);
+void snd_ctl_sync_vmaster(struct snd_kcontrol *kctl, bool hook_only);
+#define snd_ctl_sync_vmaster_hook(kctl) snd_ctl_sync_vmaster(kctl, true)
+int snd_ctl_apply_vmaster_followers(struct snd_kcontrol *kctl,
+                                    int (*func)(struct snd_kcontrol *vfollower,
+                                                struct snd_kcontrol *follower,
+                                                void *arg),
+                                    void *arg);
+/*
+ * Helper functions for jack-detection controls
+ */
+struct snd_kcontrol *
+snd_kctl_jack_new(const char *name, struct snd_card *card);
+void snd_kctl_jack_report(struct snd_card *card,
+                          struct snd_kcontrol *kctl, bool status);
 #endif  /* __SOUND_CONTROL_H */

GPL/trunk/alsa-kernel/include/sound/core.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_CORE_H
 #define __SOUND_CORE_H
 …
  *  Main header file for the ALSA driver
  *  Copyright (c) 1994-2001 by Jaroslav Kysela <perex@perex.cz>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 #ifdef TARGET_OS2
 …
 #endif
 #include <linux/module.h>
+#include <linux/device.h>
 #include <linux/sched.h>                /* wake_up() */
 #include <linux/mutex.h>                /* struct mutex */
 #include <linux/rwsem.h>                /* struct rw_semaphore */
 #include <linux/pm.h>                   /* pm_message_t */
-#include <linux/device.h>
 #include <linux/stringify.h>
+#include <linux/printk.h>
 /* number of supported soundcards */
 #ifdef CONFIG_SND_DYNAMIC_MINORS
 #define SNDRV_CARDS 32
+#define SNDRV_CARDS CONFIG_SND_MAX_CARDS
 #else
 #define SNDRV_CARDS 8           /* don't change - minor numbers */
 …
 /* forward declarations */
-#ifdef CONFIG_PCI
 struct pci_dev;
+#endif
+struct module;
+struct completion;
 /* device allocation stuff */
+#define SNDRV_DEV_TYPE_RANGE_SIZE               0x1000
+typedef int __bitwise snd_device_type_t;
+#define SNDRV_DEV_TOPLEVEL      ((__force snd_device_type_t) 0)
+#define SNDRV_DEV_CONTROL       ((__force snd_device_type_t) 1)
+#define SNDRV_DEV_LOWLEVEL_PRE  ((__force snd_device_type_t) 2)
+#define SNDRV_DEV_LOWLEVEL_NORMAL ((__force snd_device_type_t) 0x1000)
+#define SNDRV_DEV_PCM           ((__force snd_device_type_t) 0x1001)
+#define SNDRV_DEV_RAWMIDI       ((__force snd_device_type_t) 0x1002)
+#define SNDRV_DEV_TIMER         ((__force snd_device_type_t) 0x1003)
+#define SNDRV_DEV_SEQUENCER     ((__force snd_device_type_t) 0x1004)
+#define SNDRV_DEV_HWDEP         ((__force snd_device_type_t) 0x1005)
+#define SNDRV_DEV_INFO          ((__force snd_device_type_t) 0x1006)
+#define SNDRV_DEV_BUS           ((__force snd_device_type_t) 0x1007)
+#define SNDRV_DEV_CODEC         ((__force snd_device_type_t) 0x1008)
+#define SNDRV_DEV_JACK          ((__force snd_device_type_t) 0x1009)
+#define SNDRV_DEV_LOWLEVEL      ((__force snd_device_type_t) 0x2000)
+typedef int __bitwise snd_device_state_t;
+#define SNDRV_DEV_BUILD         ((__force snd_device_state_t) 0)
+#define SNDRV_DEV_REGISTERED    ((__force snd_device_state_t) 1)
+#define SNDRV_DEV_DISCONNECTED  ((__force snd_device_state_t) 2)
+typedef int __bitwise snd_device_cmd_t;
+#define SNDRV_DEV_CMD_PRE       ((__force snd_device_cmd_t) 0)
+#define SNDRV_DEV_CMD_NORMAL    ((__force snd_device_cmd_t) 1)
+#define SNDRV_DEV_CMD_POST      ((__force snd_device_cmd_t) 2)
+/* type of the object used in snd_device_*()
+ * this also defines the calling order
+ */
+enum snd_device_type {
+        SNDRV_DEV_LOWLEVEL,
+        SNDRV_DEV_INFO,
+        SNDRV_DEV_BUS,
+        SNDRV_DEV_CODEC,
+        SNDRV_DEV_PCM,
+        SNDRV_DEV_COMPRESS,
+        SNDRV_DEV_RAWMIDI,
+        SNDRV_DEV_TIMER,
+        SNDRV_DEV_SEQUENCER,
+        SNDRV_DEV_HWDEP,
+        SNDRV_DEV_JACK,
+        SNDRV_DEV_CONTROL,      /* NOTE: this must be the last one */
+};
+enum snd_device_state {
+        SNDRV_DEV_BUILD,
+        SNDRV_DEV_REGISTERED,
+        SNDRV_DEV_DISCONNECTED,
+};
 struct snd_device;
 …
         struct list_head list;          /* list of registered devices */
         struct snd_card *card;          /* card which holds this device */
         snd_device_state_t state;       /* state of the device */
         snd_device_type_t type;         /* device type */
+        enum snd_device_state state;    /* state of the device */
+        enum snd_device_type type;      /* device type */
         void *device_data;              /* device structure */
         struct snd_device_ops *ops;     /* operations */
+        const struct snd_device_ops *ops;       /* operations */
 };
 …
         char shortname[32];             /* short name of this soundcard */
         char longname[80];              /* name of this soundcard */
+        char irq_descr[32];             /* Interrupt description */
         char mixername[80];             /* mixer name */
         char components[128];           /* card components delimited with
 …
         struct list_head devices;       /* devices */
+        struct device ctl_dev;          /* control device */
         unsigned int last_numid;        /* last used numeric ID */
         struct rw_semaphore controls_rwsem;     /* controls list lock */
 …
         struct snd_info_entry *proc_root;       /* root for soundcard specific files */
-        struct snd_info_entry *proc_id; /* the card id */
         struct proc_dir_entry *proc_root_link;  /* number link to real id */
 …
         spinlock_t files_lock;          /* lock the files for this card */
         int shutdown;                   /* this card is going down */
+        int free_on_last_close;         /* free in context of file_release */
+        wait_queue_head_t shutdown_sleep;
+        struct completion *release_completion;
         struct device *dev;             /* device assigned to this card */
+        struct device *card_dev;        /* cardX object for sysfs */
+        struct device card_dev;         /* cardX object for sysfs */
+        const struct attribute_group *dev_groups[4]; /* assigned sysfs attr */
+        bool registered;                /* card_dev is registered? */
+        int sync_irq;                   /* assigned irq, used for PCM sync */
+        wait_queue_head_t remove_sleep;
+        size_t total_pcm_alloc_bytes;   /* total amount of allocated buffers */
+        struct mutex memory_mutex;      /* protection for the above */
 #ifdef CONFIG_PM
         unsigned int power_state;       /* power state */
-        struct mutex power_lock;        /* power lock */
         wait_queue_head_t power_sleep;
 #endif
 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
         struct snd_mixer_oss *mixer_oss;
         int mixer_oss_change_count;
 …
 };
+#define dev_to_snd_card(p)      container_of(p, struct snd_card, card_dev)
 #ifdef CONFIG_PM
-static inline void snd_power_lock(struct snd_card *card)
+{
-        mutex_lock(&card->power_lock);
+}
-static inline void snd_power_unlock(struct snd_card *card)
+{
-        mutex_unlock(&card->power_lock);
+}
 static inline unsigned int snd_power_get_state(struct snd_card *card)
+{
 …
 #else /* ! CONFIG_PM */
-#define snd_power_lock(card)            do { (void)(card); } while (0)
-#define snd_power_unlock(card)          do { (void)(card); } while (0)
 static inline int snd_power_wait(struct snd_card *card, unsigned int state) { return 0; }
 #define snd_power_get_state(card)       ({ (void)(card); SNDRV_CTL_POWER_D0; })
 …
         int card;                       /* card number */
         int device;                     /* device number */
-#ifndef TARGET_OS2
         const struct file_operations *f_ops;    /* file operations */
-#else
-        struct file_operations *f_ops;  /* file operations */
-#endif
         void *private_data;             /* private data for f_ops->open */
         struct device *dev;             /* device for sysfs */
+        struct snd_card *card_ptr;      /* assigned card instance */
 };
 …
 static inline struct device *snd_card_get_device_link(struct snd_card *card)
+{
         return card ? card->card_dev : NULL;
+        return card ? &card->card_dev : NULL;
+}
 …
 void snd_request_card(int card);
+int snd_register_device_for_dev(int type, struct snd_card *card,
+                                int dev,
+#ifndef TARGET_OS2
+                                const struct file_operations *f_ops,
+#else
+                                struct file_operations *f_ops,
+#endif
+                                void *private_data,
+                                const char *name,
+                                struct device *device);
+/**
+ * snd_register_device - Register the ALSA device file for the card
+ * @type: the device type, SNDRV_DEVICE_TYPE_XXX
+ * @card: the card instance
+ * @dev: the device index
+ * @f_ops: the file operations
+ * @private_data: user pointer for f_ops->open()
+ * @name: the device file name
+ *
+ * Registers an ALSA device file for the given card.
+ * The operators have to be set in reg parameter.
+ *
+ * This function uses the card's device pointer to link to the
+ * correct &struct device.
+ *
+ * Returns zero if successful, or a negative error code on failure.
+ */
+static inline int snd_register_device(int type, struct snd_card *card, int dev,
+#ifndef TARGET_OS2
+                                      const struct file_operations *f_ops,
+#else
+                                      struct file_operations *f_ops,
+#endif
+                                      void *private_data,
+                                      const char *name)
+{
+        return snd_register_device_for_dev(type, card, dev, f_ops,
+                                           private_data, name,
+                                           snd_card_get_device_link(card));
+}
+int snd_unregister_device(int type, struct snd_card *card, int dev);
+void snd_device_initialize(struct device *dev, struct snd_card *card);
+int snd_register_device(int type, struct snd_card *card, int dev,
+                        const struct file_operations *f_ops,
+                        void *private_data, struct device *device);
+int snd_unregister_device(struct device *dev);
 void *snd_lookup_minor_data(unsigned int minor, int type);
-int snd_add_device_sysfs_file(int type, struct snd_card *card, int dev,
-                              struct device_attribute *attr);
 #ifdef CONFIG_SND_OSSEMUL
 int snd_register_oss_device(int type, struct snd_card *card, int dev,
+#ifndef TARGET_OS2
+                            const struct file_operations *f_ops, void *private_data,
+#else
+                            struct file_operations *f_ops, void *private_data,
+#endif
+                            const char *name);
+                            const struct file_operations *f_ops, void *private_data);
 int snd_unregister_oss_device(int type, struct snd_card *card, int dev);
 void *snd_lookup_oss_minor_data(unsigned int minor, int type);
 …
 int snd_minor_info_init(void);
-int snd_minor_info_done(void);
 /* sound_oss.c */
 …
 #ifdef CONFIG_SND_OSSEMUL
 int snd_minor_info_oss_init(void);
-int snd_minor_info_oss_done(void);
 #else
 static inline int snd_minor_info_oss_init(void) { return 0; }
-static inline int snd_minor_info_oss_done(void) { return 0; }
 #endif
 …
 /* init.c */
-extern struct snd_card *snd_cards[SNDRV_CARDS];
 int snd_card_locked(int card);
 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
 #define SND_MIXER_OSS_NOTIFY_REGISTER   0
 #define SND_MIXER_OSS_NOTIFY_DISCONNECT 1
 …
 #endif
 int snd_card_create(int idx, const char *id,
                     struct module *module, int extra_size,
                     struct snd_card **card_ret);
+int snd_card_new(struct device *parent, int idx, const char *xid,
+                 struct module *module, int extra_size,
+                 struct snd_card **card_ret);
 int snd_card_disconnect(struct snd_card *card);
+void snd_card_disconnect_sync(struct snd_card *card);
 int snd_card_free(struct snd_card *card);
 int snd_card_free_when_closed(struct snd_card *card);
 …
 int snd_card_register(struct snd_card *card);
 int snd_card_info_init(void);
+int snd_card_info_done(void);
+int snd_card_add_dev_attr(struct snd_card *card,
+                          const struct attribute_group *group);
 int snd_component_add(struct snd_card *card, const char *component);
 int snd_card_file_add(struct snd_card *card, struct file *file);
 int snd_card_file_remove(struct snd_card *card, struct file *file);
+struct snd_card *snd_card_ref(int card);
+/**
+ * snd_card_unref - Unreference the card object
+ * @card: the card object to unreference
+ *
+ * Call this function for the card object that was obtained via snd_card_ref()
+ * or snd_lookup_minor_data().
+ */
+static inline void snd_card_unref(struct snd_card *card)
+{
+        put_device(&card->card_dev);
+}
 #define snd_card_set_dev(card, devptr) ((card)->dev = (devptr))
 /* device.c */
 int snd_device_new(struct snd_card *card, snd_device_type_t type,
                    void *device_data, struct snd_device_ops *ops);
+int snd_device_new(struct snd_card *card, enum snd_device_type type,
+                   void *device_data, const struct snd_device_ops *ops);
 int snd_device_register(struct snd_card *card, void *device_data);
 int snd_device_register_all(struct snd_card *card);
+int snd_device_disconnect(struct snd_card *card, void *device_data);
+int snd_device_disconnect_all(struct snd_card *card);
+int snd_device_free(struct snd_card *card, void *device_data);
+int snd_device_free_all(struct snd_card *card, snd_device_cmd_t cmd);
+void snd_device_disconnect(struct snd_card *card, void *device_data);
+void snd_device_disconnect_all(struct snd_card *card);
+void snd_device_free(struct snd_card *card, void *device_data);
+void snd_device_free_all(struct snd_card *card);
+int snd_device_get_state(struct snd_card *card, void *device_data);
 /* isadma.c */
 …
 /* --- */
+/* sound printk debug levels */
+enum {
+        SND_PR_ALWAYS,
+        SND_PR_DEBUG,
+        SND_PR_VERBOSE,
+};
 #if defined(CONFIG_SND_DEBUG) || defined(CONFIG_SND_VERBOSE_PRINTK)
+void __snd_printk(unsigned int level, const char *file, int line,
                   const char *format, ...)
      __attribute__ ((format (printf, 4, 5)));
 #else
 #ifndef TARGET_OS2
 #define __snd_printk(level, file, line, format, args...) \
         printk(format, ##args)
+#error "Not valid for OS/2"
+__printf(4, 5)
+void __snd_printk(unsigned int level, const char *file, int line, const char *format, ...);
+#else
+#ifndef TARGET_OS2
+#define __snd_printk(level, file, line, format, ...) \
+ printk(format, ##__VA_ARGS__)
 #else
 #define __snd_printk printk
 #endif /* nothing */
 #endif
+#endif /* TARGET_OS2 */
+#endif /* defined(...) */
 /**
 …
  */
 #ifndef TARGET_OS2
 #define snd_printk(fmt, args...) \
         __snd_printk(0, __FILE__, __LINE__, fmt, ##args)
 #else
 #define snd_printk printk
 #endif
+#define snd_printk(fmt, ...) \
+        __snd_printk(0, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
+#else
+#define snd_printk __snd_printk
+#endif
 #ifdef CONFIG_SND_DEBUG
 …
  * Ignored when CONFIG_SND_DEBUG is not set.
  */
+#define snd_printd(fmt, args...) \
+        __snd_printk(1, __FILE__, __LINE__, fmt, ##args)
+#ifndef TARGET_OS2
+#define snd_printd(fmt, ...) \
+ __snd_printk(1, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
+#define _snd_printd(level, fmt, ...) \
+        __snd_printk(level, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
+#else /* TARGET_OS2 */
+#define snd_printd printk
+#endif /* TARGET_OS2 */
 /**
 …
  * Ignored when CONFIG_SND_DEBUG is not set.
  */
+#ifndef TARGET_OS2
 #define snd_BUG()               WARN(1, "BUG?\n")
+#else
+#define snd_BUG()
+#endif
+/**
+ * snd_printd_ratelimit - Suppress high rates of output when
+ *                        CONFIG_SND_DEBUG is enabled.
+ */
+#define snd_printd_ratelimit() printk_ratelimit()
 /**
 …
  * @cond: condition to evaluate
+ *
+ * When CONFIG_SND_DEBUG is set, this macro evaluates the given condition,
+ * and call WARN() and returns the value if it's non-zero.
+ *
+ * When CONFIG_SND_DEBUG is not set, this just returns zero, and the given
+ * condition is ignored.
+ *
+ * NOTE: the argument won't be evaluated at all when CONFIG_SND_DEBUG=n.
+ * Thus, don't put any statement that influences on the code behavior,
+ * such as pre/post increment, to the argument of this macro.
+ * If you want to evaluate and give a warning, use standard WARN_ON().
+ */
+#define snd_BUG_ON(cond)        WARN((cond), "BUG? (%s)\n", __stringify(cond))
+ * Has the same behavior as WARN_ON when CONFIG_SND_DEBUG is set,
+ * otherwise just evaluates the conditional and returns the value.
+ */
+#ifndef TARGET_OS2
+#define snd_BUG_ON(cond)        WARN_ON((cond))
+#else
+#define snd_BUG_ON(cond)
+#endif
 #else /* !CONFIG_SND_DEBUG */
 #ifndef TARGET_OS2
+#define snd_printd(fmt, args...)        do { } while (0)
+__printf(1, 2)
+static inline void snd_printd(const char *format, ...) {}
+__printf(2, 3)
+static inline void _snd_printd(int level, const char *format, ...) {}
 #define snd_BUG()                       do { } while (0)
+static inline int __snd_bug_on(int cond)
+{
         return 0;
+}
+#define snd_BUG_ON(cond)        __snd_bug_on(0 && (cond))  /* always false */
+#define snd_BUG_ON(condition) ({ \
+        int __ret_warn_on = !!(condition); \
+        unlikely(__ret_warn_on); \
+})
 #else
 #define snd_printd snd_printk
 …
 #endif
+static inline bool snd_printd_ratelimit(void) { return false; }
 #endif /* CONFIG_SND_DEBUG */
 …
  */
 #ifndef TARGET_OS2
 #define snd_printdd(format, args...) \
         __snd_printk(2, __FILE__, __LINE__, format, ##args)
+#define snd_printdd(format, ...) \
+ __snd_printk(2, __FILE__, __LINE__, format, ##__VA_ARGS__)
 #else
 #define snd_printdd snd_printk
+#endif
+#else
+#ifndef TARGET_OS2
+#define snd_printdd(format, args...)    do { } while (0)
+#else
+#define snd_printdd 1 ? (void)0 : (void)((int (*)(char *, ...)) NULL)
+#endif
+#endif
+#endif /* TARGET_OS2 */
+#else /* CONFIG_SND_DEBUG_VERBIOSE */
+#ifndef TARGET_OS2
+__printf(1, 2)
+static inline void snd_printdd(const char *format, ...) {}
+#else
+#define snd_printdd snd_printk
+#endif /* TARGET_OS2 */
+#endif /* CONFIG_SND_DEBUG_VERBIOSE */
 …
 /* for easier backward-porting */
 #if defined(CONFIG_GAMEPORT) || defined(CONFIG_GAMEPORT_MODULE)
+#if IS_ENABLED(CONFIG_GAMEPORT)
 #define gameport_set_dev_parent(gp,xdev) ((gp)->dev.parent = (xdev))
 #define gameport_set_port_data(gp,r) ((gp)->port_data = (r))
 …
         {_SND_PCI_QUIRK_ID_MASK(vend, mask, dev),                       \
                         .value = (val), .name = (xname)}
+#define snd_pci_quirk_name(q)   ((q)->name)
 #else
 #define SND_PCI_QUIRK(vend,dev,xname,val) \
 …
 #define SND_PCI_QUIRK_VENDOR(vend, xname, val)                  \
         {_SND_PCI_QUIRK_ID_MASK(vend, 0, 0), .value = (val)}
+#endif
+#define snd_pci_quirk_name(q)   ""
+#endif
+#ifdef CONFIG_PCI
 const struct snd_pci_quirk *
 snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list);
 …
 snd_pci_quirk_lookup_id(u16 vendor, u16 device,
                         const struct snd_pci_quirk *list);
+#else
+static inline const struct snd_pci_quirk *
+snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list)
+{
+        return NULL;
+}
+static inline const struct snd_pci_quirk *
+snd_pci_quirk_lookup_id(u16 vendor, u16 device,
+                        const struct snd_pci_quirk *list)
+{
+        return NULL;
+}
+#endif
 #endif /* __SOUND_CORE_H */

GPL/trunk/alsa-kernel/include/sound/cs4231-regs.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_CS4231_REGS_H
 #define __SOUND_CS4231_REGS_H
 …
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
  *  Definitions for CS4231 & InterWave chips & compatible chips registers
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */

GPL/trunk/alsa-kernel/include/sound/cs46xx_dsp_spos.h

r598	r679
148	148
149	149	struct dsp_spos_instance {
150		struct dsp_symbol_desc symbol_table; /* currently availble loaded symbols in SP */
	150	struct dsp_symbol_desc symbol_table; /* currently available loaded symbols in SP */
151	151
152	152	int nmodules;

GPL/trunk/alsa-kernel/include/sound/cs8403.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_CS8403_H
 #define __SOUND_CS8403_H
 …
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>,
  *                   Takashi Iwai <tiwai@suse.de>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */

GPL/trunk/alsa-kernel/include/sound/cs8427.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_CS8427_H
 #define __SOUND_CS8427_H
 …
  *  Routines for Cirrus Logic CS8427
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>,
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 …
 struct snd_pcm_substream;
+int snd_cs8427_init(struct snd_i2c_bus *bus, struct snd_i2c_device *device);
 int snd_cs8427_create(struct snd_i2c_bus *bus, unsigned char addr,
                       unsigned int reset_timeout, struct snd_i2c_device **r_cs8427);

GPL/trunk/alsa-kernel/include/sound/emu10k1.h

-              r598
+              r679
+#ifndef __SOUND_EMU10K1_H
+#define __SOUND_EMU10K1_H
+#include <linux/types.h>
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 /*
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>,
  *                   Creative Labs, Inc.
  *  Definitions for EMU10K1 (SB Live!) chips
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
+#ifdef __KERNEL__
+#ifndef __SOUND_EMU10K1_H
+#define __SOUND_EMU10K1_H
 #include <sound/pcm.h>
 …
 #include <linux/interrupt.h>
 #include <linux/mutex.h>
+#include <asm/io.h>
+#include <linux/firmware.h>
+#include <linux/io.h>
+#include <uapi/sound/emu10k1.h>
 /* ------------------- DEFINES -------------------- */
 …
 #define EMUPAGESIZE     4096
 #define MAXREQVOICES    8
+#define MAXPAGES        8192
+#define MAXPAGES0       4096    /* 32 bit mode */
+#define MAXPAGES1       8192    /* 31 bit mode */
 #define RESERVED        0
 #define NUM_MIDI        16
 …
 /* FIXME? - according to the OSS driver the EMU10K1 needs a 29 bit DMA mask */
 #define EMU10K1_DMA_MASK        0x7fffffffUL    /* 31bit */
+#define AUDIGY_DMA_MASK         0x7fffffffUL    /* 31bit FIXME - 32 should work? */
+                                                /* See ALSA bug #1276 - rlrevell */
+#define AUDIGY_DMA_MASK         0xffffffffUL    /* 32bit mode */
 #define TMEMSIZE        256*1024
 …
 #define CCCA_CURRADDR           0x18000008
-/* undefine CCR to avoid conflict with the definition for SH */
-#undef CCR
 #define CCR                     0x09            /* Cache control register                               */
 #define CCR_CACHEINVALIDSIZE    0x07190009
 …
 #define MAPB                    0x0d            /* Cache map B                                          */
+#define MAP_PTE_MASK            0xffffe000      /* The 19 MSBs of the PTE indexed by the PTI            */
+#define MAP_PTI_MASK            0x00001fff      /* The 13 bit index to one of the 8192 PTE dwords       */
+#define MAP_PTE_MASK0           0xfffff000      /* The 20 MSBs of the PTE indexed by the PTI            */
+#define MAP_PTI_MASK0           0x00000fff      /* The 12 bit index to one of the 4096 PTE dwords       */
+#define MAP_PTE_MASK1           0xffffe000      /* The 19 MSBs of the PTE indexed by the PTI            */
+#define MAP_PTI_MASK1           0x00001fff      /* The 13 bit index to one of the 8192 PTE dwords       */
 /* 0x0e, 0x0f: Not used */
 …
         unsigned int tram_pos;
         unsigned int tram_shift;
         struct snd_emu10k1_fx8010_irq *irq;
+        struct snd_emu10k1_fx8010_irq irq;
 };
 …
         unsigned int optical_in; /* 0:SPDIF, 1:ADAT */
         unsigned int optical_out; /* 0:SPDIF, 1:ADAT */
+        struct task_struct *firmware_thread;
+        struct delayed_work firmware_work;
+        u32 last_reg;
 };
 …
         unsigned int card_type;                 /* EMU10K1_CARD_* */
         unsigned int ecard_ctrl;                /* ecard control bits */
+        unsigned int address_mode;              /* address mode */
         unsigned long dma_mask;                 /* PCI DMA mask */
+        bool iommu_workaround;                  /* IOMMU workaround needed */
         unsigned int delay_pcm_irq;             /* in samples */
         int max_cache_pages;                    /* max memory size / PAGE_SIZE */
 …
         struct snd_util_memhdr *memhdr;         /* page allocation list */
-        struct snd_emu10k1_memblk *reserved_page;       /* reserved page */
         struct list_head mapped_link_head;
 …
         unsigned int next_free_voice;
+#ifdef CONFIG_PM
+        const struct firmware *firmware;
+        const struct firmware *dock_fw;
+#ifdef CONFIG_PM_SLEEP
         unsigned int *saved_ptr;
         unsigned int *saved_gpr;
 …
         unsigned int *p16v_saved;
         unsigned int saved_a_iocfg, saved_hcfg;
+        bool suspend;
 #endif
 …
                        struct snd_emu10k1 ** remu);
 int snd_emu10k1_pcm(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm);
 int snd_emu10k1_pcm_mic(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm);
 int snd_emu10k1_pcm_efx(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm);
 int snd_p16v_pcm(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm);
+int snd_emu10k1_pcm(struct snd_emu10k1 *emu, int device);
+int snd_emu10k1_pcm_mic(struct snd_emu10k1 *emu, int device);
+int snd_emu10k1_pcm_efx(struct snd_emu10k1 *emu, int device);
+int snd_p16v_pcm(struct snd_emu10k1 *emu, int device);
 int snd_p16v_free(struct snd_emu10k1 * emu);
 int snd_p16v_mixer(struct snd_emu10k1 * emu);
 int snd_emu10k1_pcm_multi(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm);
 int snd_emu10k1_fx8010_pcm(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm);
+int snd_emu10k1_pcm_multi(struct snd_emu10k1 *emu, int device);
+int snd_emu10k1_fx8010_pcm(struct snd_emu10k1 *emu, int device);
 int snd_emu10k1_mixer(struct snd_emu10k1 * emu, int pcm_device, int multi_device);
 int snd_emu10k1_timer(struct snd_emu10k1 * emu, int device);
 int snd_emu10k1_fx8010_new(struct snd_emu10k1 *emu, int device, struct snd_hwdep ** rhwdep);
+int snd_emu10k1_fx8010_new(struct snd_emu10k1 *emu, int device);
 irqreturn_t snd_emu10k1_interrupt(int irq, void *dev_id);
 …
 unsigned int snd_emu10k1_rate_to_pitch(unsigned int rate);
 #ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 void snd_emu10k1_suspend_regs(struct snd_emu10k1 *emu);
 void snd_emu10k1_resume_init(struct snd_emu10k1 *emu);
 …
 struct snd_util_memblk *snd_emu10k1_alloc_pages(struct snd_emu10k1 *emu, struct snd_pcm_substream *substream);
 int snd_emu10k1_free_pages(struct snd_emu10k1 *emu, struct snd_util_memblk *blk);
+int snd_emu10k1_alloc_pages_maybe_wider(struct snd_emu10k1 *emu, size_t size,
+                                        struct snd_dma_buffer *dmab);
 struct snd_util_memblk *snd_emu10k1_synth_alloc(struct snd_emu10k1 *emu, unsigned int size);
 int snd_emu10k1_synth_free(struct snd_emu10k1 *emu, struct snd_util_memblk *blk);
 …
                                             unsigned char gpr_running,
                                             void *private_data,
                                             struct snd_emu10k1_fx8010_irq **r_irq);
+                                            struct snd_emu10k1_fx8010_irq *irq);
 int snd_emu10k1_fx8010_unregister_irq_handler(struct snd_emu10k1 *emu,
                                               struct snd_emu10k1_fx8010_irq *irq);
-#endif /* __KERNEL__ */
-/*
- * ---- FX8010 ----
- */
-#define EMU10K1_CARD_CREATIVE                   0x00000000
-#define EMU10K1_CARD_EMUAPS                     0x00000001
-#define EMU10K1_FX8010_PCM_COUNT                8
-/* instruction set */
-#define iMAC0    0x00   /* R = A + (X * Y >> 31)   ; saturation */
-#define iMAC1    0x01   /* R = A + (-X * Y >> 31)  ; saturation */
-#define iMAC2    0x02   /* R = A + (X * Y >> 31)   ; wraparound */
-#define iMAC3    0x03   /* R = A + (-X * Y >> 31)  ; wraparound */
-#define iMACINT0 0x04   /* R = A + X * Y           ; saturation */
-#define iMACINT1 0x05   /* R = A + X * Y           ; wraparound (31-bit) */
-#define iACC3    0x06   /* R = A + X + Y           ; saturation */
-#define iMACMV   0x07   /* R = A, acc += X * Y >> 31 */
-#define iANDXOR  0x08   /* R = (A & X) ^ Y */
-#define iTSTNEG  0x09   /* R = (A >= Y) ? X : ~X */
-#define iLIMITGE 0x0a   /* R = (A >= Y) ? X : Y */
-#define iLIMITLT 0x0b   /* R = (A < Y) ? X : Y */
-#define iLOG     0x0c   /* R = linear_data, A (log_data), X (max_exp), Y (format_word) */
-#define iEXP     0x0d   /* R = log_data, A (linear_data), X (max_exp), Y (format_word) */
-#define iINTERP  0x0e   /* R = A + (X * (Y - A) >> 31)  ; saturation */
-#define iSKIP    0x0f   /* R = A (cc_reg), X (count), Y (cc_test) */
-/* GPRs */
-#define FXBUS(x)        (0x00 + (x))    /* x = 0x00 - 0x0f */
-#define EXTIN(x)        (0x10 + (x))    /* x = 0x00 - 0x0f */
-#define EXTOUT(x)       (0x20 + (x))    /* x = 0x00 - 0x0f physical outs -> FXWC low 16 bits */
-#define FXBUS2(x)       (0x30 + (x))    /* x = 0x00 - 0x0f copies of fx buses for capture -> FXWC high 16 bits */
-                                        /* NB: 0x31 and 0x32 are shared with Center/LFE on SB live 5.1 */
-#define C_00000000      0x40
-#define C_00000001      0x41
-#define C_00000002      0x42
-#define C_00000003      0x43
-#define C_00000004      0x44
-#define C_00000008      0x45
-#define C_00000010      0x46
-#define C_00000020      0x47
-#define C_00000100      0x48
-#define C_00010000      0x49
-#define C_00080000      0x4a
-#define C_10000000      0x4b
-#define C_20000000      0x4c
-#define C_40000000      0x4d
-#define C_80000000      0x4e
-#define C_7fffffff      0x4f
-#define C_ffffffff      0x50
-#define C_fffffffe      0x51
-#define C_c0000000      0x52
-#define C_4f1bbcdc      0x53
-#define C_5a7ef9db      0x54
-#define C_00100000      0x55            /* ?? */
-#define GPR_ACCU        0x56            /* ACCUM, accumulator */
-#define GPR_COND        0x57            /* CCR, condition register */
-#define GPR_NOISE0      0x58            /* noise source */
-#define GPR_NOISE1      0x59            /* noise source */
-#define GPR_IRQ         0x5a            /* IRQ register */
-#define GPR_DBAC        0x5b            /* TRAM Delay Base Address Counter */
-#define GPR(x)          (FXGPREGBASE + (x)) /* free GPRs: x = 0x00 - 0xff */
-#define ITRAM_DATA(x)   (TANKMEMDATAREGBASE + 0x00 + (x)) /* x = 0x00 - 0x7f */
-#define ETRAM_DATA(x)   (TANKMEMDATAREGBASE + 0x80 + (x)) /* x = 0x00 - 0x1f */
-#define ITRAM_ADDR(x)   (TANKMEMADDRREGBASE + 0x00 + (x)) /* x = 0x00 - 0x7f */
-#define ETRAM_ADDR(x)   (TANKMEMADDRREGBASE + 0x80 + (x)) /* x = 0x00 - 0x1f */
-#define A_ITRAM_DATA(x) (TANKMEMDATAREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */
-#define A_ETRAM_DATA(x) (TANKMEMDATAREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */
-#define A_ITRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */
-#define A_ETRAM_ADDR(x) (TANKMEMADDRREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */
-#define A_ITRAM_CTL(x)  (A_TANKMEMCTLREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */
-#define A_ETRAM_CTL(x)  (A_TANKMEMCTLREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */
-#define A_FXBUS(x)      (0x00 + (x))    /* x = 0x00 - 0x3f FX buses */
-#define A_EXTIN(x)      (0x40 + (x))    /* x = 0x00 - 0x0f physical ins */
-#define A_P16VIN(x)     (0x50 + (x))    /* x = 0x00 - 0x0f p16v ins (A2 only) "EMU32 inputs" */
-#define A_EXTOUT(x)     (0x60 + (x))    /* x = 0x00 - 0x1f physical outs -> A_FXWC1 0x79-7f unknown   */
-#define A_FXBUS2(x)     (0x80 + (x))    /* x = 0x00 - 0x1f extra outs used for EFX capture -> A_FXWC2 */
-#define A_EMU32OUTH(x)  (0xa0 + (x))    /* x = 0x00 - 0x0f "EMU32_OUT_10 - _1F" - ??? */
-#define A_EMU32OUTL(x)  (0xb0 + (x))    /* x = 0x00 - 0x0f "EMU32_OUT_1 - _F" - ??? */
-#define A3_EMU32IN(x)   (0x160 + (x))   /* x = 0x00 - 0x3f "EMU32_IN_00 - _3F" - Only when .device = 0x0008 */
-#define A3_EMU32OUT(x)  (0x1E0 + (x))   /* x = 0x00 - 0x0f "EMU32_OUT_00 - _3F" - Only when .device = 0x0008 */
-#define A_GPR(x)        (A_FXGPREGBASE + (x))
-/* cc_reg constants */
-#define CC_REG_NORMALIZED C_00000001
-#define CC_REG_BORROW   C_00000002
-#define CC_REG_MINUS    C_00000004
-#define CC_REG_ZERO     C_00000008
-#define CC_REG_SATURATE C_00000010
-#define CC_REG_NONZERO  C_00000100
-/* FX buses */
-#define FXBUS_PCM_LEFT          0x00
-#define FXBUS_PCM_RIGHT         0x01
-#define FXBUS_PCM_LEFT_REAR     0x02
-#define FXBUS_PCM_RIGHT_REAR    0x03
-#define FXBUS_MIDI_LEFT         0x04
-#define FXBUS_MIDI_RIGHT        0x05
-#define FXBUS_PCM_CENTER        0x06
-#define FXBUS_PCM_LFE           0x07
-#define FXBUS_PCM_LEFT_FRONT    0x08
-#define FXBUS_PCM_RIGHT_FRONT   0x09
-#define FXBUS_MIDI_REVERB       0x0c
-#define FXBUS_MIDI_CHORUS       0x0d
-#define FXBUS_PCM_LEFT_SIDE     0x0e
-#define FXBUS_PCM_RIGHT_SIDE    0x0f
-#define FXBUS_PT_LEFT           0x14
-#define FXBUS_PT_RIGHT          0x15
-/* Inputs */
-#define EXTIN_AC97_L       0x00 /* AC'97 capture channel - left */
-#define EXTIN_AC97_R       0x01 /* AC'97 capture channel - right */
-#define EXTIN_SPDIF_CD_L   0x02 /* internal S/PDIF CD - onboard - left */
-#define EXTIN_SPDIF_CD_R   0x03 /* internal S/PDIF CD - onboard - right */
-#define EXTIN_ZOOM_L       0x04 /* Zoom Video I2S - left */
-#define EXTIN_ZOOM_R       0x05 /* Zoom Video I2S - right */
-#define EXTIN_TOSLINK_L    0x06 /* LiveDrive - TOSLink Optical - left */
-#define EXTIN_TOSLINK_R    0x07 /* LiveDrive - TOSLink Optical - right */
-#define EXTIN_LINE1_L      0x08 /* LiveDrive - Line/Mic 1 - left */
-#define EXTIN_LINE1_R      0x09 /* LiveDrive - Line/Mic 1 - right */
-#define EXTIN_COAX_SPDIF_L 0x0a /* LiveDrive - Coaxial S/PDIF - left */
-#define EXTIN_COAX_SPDIF_R 0x0b /* LiveDrive - Coaxial S/PDIF - right */
-#define EXTIN_LINE2_L      0x0c /* LiveDrive - Line/Mic 2 - left */
-#define EXTIN_LINE2_R      0x0d /* LiveDrive - Line/Mic 2 - right */
-/* Outputs */
-#define EXTOUT_AC97_L      0x00 /* AC'97 playback channel - left */
-#define EXTOUT_AC97_R      0x01 /* AC'97 playback channel - right */
-#define EXTOUT_TOSLINK_L   0x02 /* LiveDrive - TOSLink Optical - left */
-#define EXTOUT_TOSLINK_R   0x03 /* LiveDrive - TOSLink Optical - right */
-#define EXTOUT_AC97_CENTER 0x04 /* SB Live 5.1 - center */
-#define EXTOUT_AC97_LFE    0x05 /* SB Live 5.1 - LFE */
-#define EXTOUT_HEADPHONE_L 0x06 /* LiveDrive - Headphone - left */
-#define EXTOUT_HEADPHONE_R 0x07 /* LiveDrive - Headphone - right */
-#define EXTOUT_REAR_L      0x08 /* Rear channel - left */
-#define EXTOUT_REAR_R      0x09 /* Rear channel - right */
-#define EXTOUT_ADC_CAP_L   0x0a /* ADC Capture buffer - left */
-#define EXTOUT_ADC_CAP_R   0x0b /* ADC Capture buffer - right */
-#define EXTOUT_MIC_CAP     0x0c /* MIC Capture buffer */
-#define EXTOUT_AC97_REAR_L 0x0d /* SB Live 5.1 (c) 2003 - Rear Left */
-#define EXTOUT_AC97_REAR_R 0x0e /* SB Live 5.1 (c) 2003 - Rear Right */
-#define EXTOUT_ACENTER     0x11 /* Analog Center */
-#define EXTOUT_ALFE        0x12 /* Analog LFE */
-/* Audigy Inputs */
-#define A_EXTIN_AC97_L          0x00    /* AC'97 capture channel - left */
-#define A_EXTIN_AC97_R          0x01    /* AC'97 capture channel - right */
-#define A_EXTIN_SPDIF_CD_L      0x02    /* digital CD left */
-#define A_EXTIN_SPDIF_CD_R      0x03    /* digital CD left */
-#define A_EXTIN_OPT_SPDIF_L     0x04    /* audigy drive Optical SPDIF - left */
-#define A_EXTIN_OPT_SPDIF_R     0x05    /*                              right */
-#define A_EXTIN_LINE2_L         0x08    /* audigy drive line2/mic2 - left */
-#define A_EXTIN_LINE2_R         0x09    /*                           right */
-#define A_EXTIN_ADC_L           0x0a    /* Philips ADC - left */
-#define A_EXTIN_ADC_R           0x0b    /*               right */
-#define A_EXTIN_AUX2_L          0x0c    /* audigy drive aux2 - left */
-#define A_EXTIN_AUX2_R          0x0d    /*                   - right */
-/* Audigiy Outputs */
-#define A_EXTOUT_FRONT_L        0x00    /* digital front left */
-#define A_EXTOUT_FRONT_R        0x01    /*               right */
-#define A_EXTOUT_CENTER         0x02    /* digital front center */
-#define A_EXTOUT_LFE            0x03    /* digital front lfe */
-#define A_EXTOUT_HEADPHONE_L    0x04    /* headphone audigy drive left */
-#define A_EXTOUT_HEADPHONE_R    0x05    /*                        right */
-#define A_EXTOUT_REAR_L         0x06    /* digital rear left */
-#define A_EXTOUT_REAR_R         0x07    /*              right */
-#define A_EXTOUT_AFRONT_L       0x08    /* analog front left */
-#define A_EXTOUT_AFRONT_R       0x09    /*              right */
-#define A_EXTOUT_ACENTER        0x0a    /* analog center */
-#define A_EXTOUT_ALFE           0x0b    /* analog LFE */
-#define A_EXTOUT_ASIDE_L        0x0c    /* analog side left  - Audigy 2 ZS */
-#define A_EXTOUT_ASIDE_R        0x0d    /*             right - Audigy 2 ZS */
-#define A_EXTOUT_AREAR_L        0x0e    /* analog rear left */
-#define A_EXTOUT_AREAR_R        0x0f    /*             right */
-#define A_EXTOUT_AC97_L         0x10    /* AC97 left (front) */
-#define A_EXTOUT_AC97_R         0x11    /*      right */
-#define A_EXTOUT_ADC_CAP_L      0x16    /* ADC capture buffer left */
-#define A_EXTOUT_ADC_CAP_R      0x17    /*                    right */
-#define A_EXTOUT_MIC_CAP        0x18    /* Mic capture buffer */
-/* Audigy constants */
-#define A_C_00000000    0xc0
-#define A_C_00000001    0xc1
-#define A_C_00000002    0xc2
-#define A_C_00000003    0xc3
-#define A_C_00000004    0xc4
-#define A_C_00000008    0xc5
-#define A_C_00000010    0xc6
-#define A_C_00000020    0xc7
-#define A_C_00000100    0xc8
-#define A_C_00010000    0xc9
-#define A_C_00000800    0xca
-#define A_C_10000000    0xcb
-#define A_C_20000000    0xcc
-#define A_C_40000000    0xcd
-#define A_C_80000000    0xce
-#define A_C_7fffffff    0xcf
-#define A_C_ffffffff    0xd0
-#define A_C_fffffffe    0xd1
-#define A_C_c0000000    0xd2
-#define A_C_4f1bbcdc    0xd3
-#define A_C_5a7ef9db    0xd4
-#define A_C_00100000    0xd5
-#define A_GPR_ACCU      0xd6            /* ACCUM, accumulator */
-#define A_GPR_COND      0xd7            /* CCR, condition register */
-#define A_GPR_NOISE0    0xd8            /* noise source */
-#define A_GPR_NOISE1    0xd9            /* noise source */
-#define A_GPR_IRQ       0xda            /* IRQ register */
-#define A_GPR_DBAC      0xdb            /* TRAM Delay Base Address Counter - internal */
-#define A_GPR_DBACE     0xde            /* TRAM Delay Base Address Counter - external */
-/* definitions for debug register */
-#define EMU10K1_DBG_ZC                  0x80000000      /* zero tram counter */
-#define EMU10K1_DBG_SATURATION_OCCURED  0x02000000      /* saturation control */
-#define EMU10K1_DBG_SATURATION_ADDR     0x01ff0000      /* saturation address */
-#define EMU10K1_DBG_SINGLE_STEP         0x00008000      /* single step mode */
-#define EMU10K1_DBG_STEP                0x00004000      /* start single step */
-#define EMU10K1_DBG_CONDITION_CODE      0x00003e00      /* condition code */
-#define EMU10K1_DBG_SINGLE_STEP_ADDR    0x000001ff      /* single step address */
-/* tank memory address line */
-#ifndef __KERNEL__
-#define TANKMEMADDRREG_ADDR_MASK 0x000fffff     /* 20 bit tank address field                    */
-#define TANKMEMADDRREG_CLEAR     0x00800000     /* Clear tank memory                            */
-#define TANKMEMADDRREG_ALIGN     0x00400000     /* Align read or write relative to tank access  */
-#define TANKMEMADDRREG_WRITE     0x00200000     /* Write to tank memory                         */
-#define TANKMEMADDRREG_READ      0x00100000     /* Read from tank memory                        */
-#endif
-struct snd_emu10k1_fx8010_info {
-        unsigned int internal_tram_size;        /* in samples */
-        unsigned int external_tram_size;        /* in samples */
-        char fxbus_names[16][32];               /* names of FXBUSes */
-        char extin_names[16][32];               /* names of external inputs */
-        char extout_names[32][32];              /* names of external outputs */
-        unsigned int gpr_controls;              /* count of GPR controls */
-};
-#define EMU10K1_GPR_TRANSLATION_NONE            0
-#define EMU10K1_GPR_TRANSLATION_TABLE100        1
-#define EMU10K1_GPR_TRANSLATION_BASS            2
-#define EMU10K1_GPR_TRANSLATION_TREBLE          3
-#define EMU10K1_GPR_TRANSLATION_ONOFF           4
-struct snd_emu10k1_fx8010_control_gpr {
-        struct snd_ctl_elem_id id;              /* full control ID definition */
-        unsigned int vcount;            /* visible count */
-        unsigned int count;             /* count of GPR (1..16) */
-        unsigned short gpr[32];         /* GPR number(s) */
-        unsigned int value[32];         /* initial values */
-        unsigned int min;               /* minimum range */
-        unsigned int max;               /* maximum range */
-        unsigned int translation;       /* translation type (EMU10K1_GPR_TRANSLATION*) */
-        const unsigned int *tlv;
-};
-/* old ABI without TLV support */
-struct snd_emu10k1_fx8010_control_old_gpr {
-        struct snd_ctl_elem_id id;
-        unsigned int vcount;
-        unsigned int count;
-        unsigned short gpr[32];
-        unsigned int value[32];
-        unsigned int min;
-        unsigned int max;
-        unsigned int translation;
-};
-struct snd_emu10k1_fx8010_code {
-        char name[128];
-        DECLARE_BITMAP(gpr_valid, 0x200); /* bitmask of valid initializers */
-        __u32 __user *gpr_map;          /* initializers */
-        unsigned int gpr_add_control_count; /* count of GPR controls to add/replace */
-        struct snd_emu10k1_fx8010_control_gpr __user *gpr_add_controls; /* GPR controls to add/replace */
-        unsigned int gpr_del_control_count; /* count of GPR controls to remove */
-        struct snd_ctl_elem_id __user *gpr_del_controls; /* IDs of GPR controls to remove */
-        unsigned int gpr_list_control_count; /* count of GPR controls to list */
-        unsigned int gpr_list_control_total; /* total count of GPR controls */
-        struct snd_emu10k1_fx8010_control_gpr __user *gpr_list_controls; /* listed GPR controls */
-        DECLARE_BITMAP(tram_valid, 0x100); /* bitmask of valid initializers */
-        __u32 __user *tram_data_map;      /* data initializers */
-        __u32 __user *tram_addr_map;      /* map initializers */
-        DECLARE_BITMAP(code_valid, 1024); /* bitmask of valid instructions */
-        __u32 __user *code;               /* one instruction - 64 bits */
-};
-struct snd_emu10k1_fx8010_tram {
-        unsigned int address;           /* 31.bit == 1 -> external TRAM */
-        unsigned int size;              /* size in samples (4 bytes) */
-        unsigned int *samples;          /* pointer to samples (20-bit) */
-                                        /* NULL->clear memory */
-};
-struct snd_emu10k1_fx8010_pcm_rec {
-        unsigned int substream;         /* substream number */
-        unsigned int res1;              /* reserved */
-        unsigned int channels;          /* 16-bit channels count, zero = remove this substream */
-        unsigned int tram_start;        /* ring buffer position in TRAM (in samples) */
-        unsigned int buffer_size;       /* count of buffered samples */
-        unsigned short gpr_size;                /* GPR containing size of ringbuffer in samples (host) */
-        unsigned short gpr_ptr;         /* GPR containing current pointer in the ring buffer (host = reset, FX8010) */
-        unsigned short gpr_count;       /* GPR containing count of samples between two interrupts (host) */
-        unsigned short gpr_tmpcount;    /* GPR containing current count of samples to interrupt (host = set, FX8010) */
-        unsigned short gpr_trigger;     /* GPR containing trigger (activate) information (host) */
-        unsigned short gpr_running;     /* GPR containing info if PCM is running (FX8010) */
-        unsigned char pad;              /* reserved */
-        unsigned char etram[32];        /* external TRAM address & data (one per channel) */
-        unsigned int res2;              /* reserved */
-};
-#define SNDRV_EMU10K1_VERSION           SNDRV_PROTOCOL_VERSION(1, 0, 1)
-#define SNDRV_EMU10K1_IOCTL_INFO        _IOR ('H', 0x10, struct snd_emu10k1_fx8010_info)
-#define SNDRV_EMU10K1_IOCTL_CODE_POKE   _IOW ('H', 0x11, struct snd_emu10k1_fx8010_code)
-#define SNDRV_EMU10K1_IOCTL_CODE_PEEK   _IOWR('H', 0x12, struct snd_emu10k1_fx8010_code)
-#define SNDRV_EMU10K1_IOCTL_TRAM_SETUP  _IOW ('H', 0x20, int)
-#define SNDRV_EMU10K1_IOCTL_TRAM_POKE   _IOW ('H', 0x21, struct snd_emu10k1_fx8010_tram)
-#define SNDRV_EMU10K1_IOCTL_TRAM_PEEK   _IOWR('H', 0x22, struct snd_emu10k1_fx8010_tram)
-#define SNDRV_EMU10K1_IOCTL_PCM_POKE    _IOW ('H', 0x30, struct snd_emu10k1_fx8010_pcm_rec)
-#define SNDRV_EMU10K1_IOCTL_PCM_PEEK    _IOWR('H', 0x31, struct snd_emu10k1_fx8010_pcm_rec)
-#define SNDRV_EMU10K1_IOCTL_PVERSION    _IOR ('H', 0x40, int)
-#define SNDRV_EMU10K1_IOCTL_STOP        _IO  ('H', 0x80)
-#define SNDRV_EMU10K1_IOCTL_CONTINUE    _IO  ('H', 0x81)
-#define SNDRV_EMU10K1_IOCTL_ZERO_TRAM_COUNTER _IO ('H', 0x82)
-#define SNDRV_EMU10K1_IOCTL_SINGLE_STEP _IOW ('H', 0x83, int)
-#define SNDRV_EMU10K1_IOCTL_DBG_READ    _IOR ('H', 0x84, int)
-/* typedefs for compatibility to user-space */
-typedef struct snd_emu10k1_fx8010_info emu10k1_fx8010_info_t;
-typedef struct snd_emu10k1_fx8010_control_gpr emu10k1_fx8010_control_gpr_t;
-typedef struct snd_emu10k1_fx8010_code emu10k1_fx8010_code_t;
-typedef struct snd_emu10k1_fx8010_tram emu10k1_fx8010_tram_t;
-typedef struct snd_emu10k1_fx8010_pcm_rec emu10k1_fx8010_pcm_t;
 #endif  /* __SOUND_EMU10K1_H */

GPL/trunk/alsa-kernel/include/sound/emu10k1_synth.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __EMU10K1_SYNTH_H
 #define __EMU10K1_SYNTH_H
 …
+ *
  *  Copyright (C) 2000 Takashi Iwai <tiwai@suse.de>
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 #include "emu10k1.h"
 #include "emux_synth.h"
+#include <sound/emu10k1.h>
+#include <sound/emux_synth.h>
 /* sequencer device id */

GPL/trunk/alsa-kernel/include/sound/emu8000.h

-              r398
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_EMU8000_H
 #define __SOUND_EMU8000_H
 …
  *  Copyright (C) 1999 Steve Ratcliffe
  *  Copyright (C) 1999-2000 Takashi Iwai <tiwai@suse.de>
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 #include "emux_synth.h"
 #include "seq_kernel.h"
+#include <sound/emux_synth.h>
+#include <sound/seq_kernel.h>
 /*

GPL/trunk/alsa-kernel/include/sound/emu8000_reg.h

-              r398
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_EMU8000_REG_H
 #define __SOUND_EMU8000_REG_H
 …
+ *
  *  Based on awe_wave.c by Takashi Iwai
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */

GPL/trunk/alsa-kernel/include/sound/emux_legacy.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_EMUX_LEGACY_H
 #define __SOUND_EMUX_LEGACY_H
 …
+ *
  *  Definitions of OSS compatible headers for Emu8000 device informations
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 #include "seq_oss_legacy.h"
+#include <sound/seq_oss_legacy.h>
 /*

GPL/trunk/alsa-kernel/include/sound/emux_synth.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_EMUX_SYNTH_H
 #define __SOUND_EMUX_SYNTH_H
 …
+ *
  *  Copyright (C) 2000 Takashi Iwai <tiwai@suse.de>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+#include "seq_kernel.h"
+#include "seq_device.h"
+#include "soundfont.h"
+#include "seq_midi_emul.h"
+#ifdef CONFIG_SND_SEQUENCER_OSS
+#include "seq_oss.h"
+#endif
+#include "emux_legacy.h"
+#include "seq_virmidi.h"
+ */
+#include <sound/seq_kernel.h>
+#include <sound/seq_device.h>
+#include <sound/soundfont.h>
+#include <sound/seq_midi_emul.h>
+#include <sound/seq_oss.h>
+#include <sound/emux_legacy.h>
+#include <sound/seq_virmidi.h>
 /*
 …
         void (*sysex)(struct snd_emux *emu, char *buf, int len, int parsed,
                       struct snd_midi_channel_set *chset);
 #ifdef CONFIG_SND_SEQUENCER_OSS
+#if IS_ENABLED(CONFIG_SND_SEQUENCER_OSS)
         int (*oss_ioctl)(struct snd_emux *emu, int cmd, int p1, int p2);
 #endif
 …
         struct snd_util_memhdr *memhdr; /* memory chunk information */
 #ifdef CONFIG_PROC_FS
+#ifdef CONFIG_SND_PROC_FS
         struct snd_info_entry *proc;
 #endif
 #ifdef CONFIG_SND_SEQUENCER_OSS
+#if IS_ENABLED(CONFIG_SND_SEQUENCER_OSS)
         struct snd_seq_device *oss_synth;
 #endif
 …
         struct snd_emux_effect_table *effect;
 #endif
 #ifdef CONFIG_SND_SEQUENCER_OSS
+#if IS_ENABLED(CONFIG_SND_SEQUENCER_OSS)
         struct snd_seq_oss_arg *oss_arg;
 #endif

GPL/trunk/alsa-kernel/include/sound/es1688.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_ES1688_H
 #define __SOUND_ES1688_H
 …
  *  Header file for ES488/ES1688
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 #include "control.h"
 #include "pcm.h"
+#include <sound/control.h>
+#include <sound/pcm.h>
 #include <linux/interrupt.h>
 …
 #define ES1688_HW_688           0x0001
 #define ES1688_HW_1688          0x0002
+#define ES1688_HW_UNDEF 0x0003
 struct snd_es1688 {
 …
                       int dma8,
                       unsigned short hardware);
+int snd_es1688_pcm(struct snd_card *card, struct snd_es1688 *chip, int device,
+                   struct snd_pcm **rpcm);
+int snd_es1688_pcm(struct snd_card *card, struct snd_es1688 *chip, int device);
 int snd_es1688_mixer(struct snd_card *card, struct snd_es1688 *chip);
 int snd_es1688_reset(struct snd_es1688 *chip);

GPL/trunk/alsa-kernel/include/sound/gus.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_GUS_H
 #define __SOUND_GUS_H
 …
  *  Global structures used for GUS part of ALSA driver
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 #include "pcm.h"
 #include "rawmidi.h"
 #include "timer.h"
 #include "seq_midi_emul.h"
 #include "seq_device.h"
 #include <asm/io.h>
+#include <sound/pcm.h>
+#include <sound/rawmidi.h>
+#include <sound/timer.h>
+#include <sound/seq_midi_emul.h>
+#include <sound/seq_device.h>
+#include <linux/io.h>
 /* IO ports */
 …
 /* gus_pcm.c */
 int snd_gf1_pcm_new(struct snd_gus_card * gus, int pcm_dev, int control_index, struct snd_pcm ** rpcm);
+int snd_gf1_pcm_new(struct snd_gus_card *gus, int pcm_dev, int control_index);
 #ifdef CONFIG_SND_DEBUG
 …
 /* gus_uart.c */
 int snd_gf1_rawmidi_new(struct snd_gus_card * gus, int device, struct snd_rawmidi **rrawmidi);
+int snd_gf1_rawmidi_new(struct snd_gus_card *gus, int device);
 /* gus_dram.c */
 …
                       unsigned int addr, unsigned int size, int rom);
+/* gus_timer.c */
+void snd_gf1_timers_init(struct snd_gus_card *gus);
+void snd_gf1_timers_done(struct snd_gus_card *gus);
 #endif /* __SOUND_GUS_H */

GPL/trunk/alsa-kernel/include/sound/hda_hwdep.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 /*
  * HWDEP Interface for HD-audio codec
+ *
  * Copyright (c) 2007 Takashi Iwai <tiwai@suse.de>
+ *
- *  This driver is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
+ *
- *  This driver is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */

GPL/trunk/alsa-kernel/include/sound/hwdep.h

-              r426
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_HWDEP_H
 #define __SOUND_HWDEP_H
 …
  *  Hardware dependent layer
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 …
         int (*open)(struct snd_hwdep *hw, struct file * file);
         int (*release)(struct snd_hwdep *hw, struct file * file);
         unsigned int (*poll)(struct snd_hwdep *hw, struct file *file,
+        __poll_t (*poll)(struct snd_hwdep *hw, struct file *file,
                              poll_table *wait);
         int (*ioctl)(struct snd_hwdep *hw, struct file *file,
 …
 #ifdef CONFIG_SND_OSSEMUL
-        char oss_dev[32];
         int oss_type;
         int ossreg;
 …
         void *private_data;
         void (*private_free) (struct snd_hwdep *hwdep);
+        struct device dev;
         struct mutex open_mutex;

GPL/trunk/alsa-kernel/include/sound/i2c.h

-              r398
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_I2C_H
 #define __SOUND_I2C_H
 /*
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ *
  */
 …
                 void *ops;
         } hw_ops;               /* lowlevel operations */
         struct snd_i2c_ops *ops;        /* midlevel operations */
+        const struct snd_i2c_ops *ops;  /* midlevel operations */
         unsigned long private_value;

GPL/trunk/alsa-kernel/include/sound/info.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_INFO_H
 #define __SOUND_INFO_H
 …
  *  Header file for info interface
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 #include <linux/poll.h>
+#include <linux/seq_file.h>
+#include <sound/core.h>
 /* buffer for information */
 …
                          void *file_private_data, struct file *file,
                          loff_t offset, int orig);
         unsigned int (*poll)(struct snd_info_entry *entry,
+        __poll_t (*poll)(struct snd_info_entry *entry,
                              void *file_private_data, struct file *file,
                              poll_table *wait);
 …
 struct snd_info_entry {
         const char *name;
         mode_t mode;
+        umode_t mode;
         long size;
         unsigned short content;
         union {
                 struct snd_info_entry_text text;
                 struct snd_info_entry_ops *ops;
+                const struct snd_info_entry_ops *ops;
         } c;
         struct snd_info_entry *parent;
-        struct snd_card *card;
         struct module *module;
         void *private_data;
 …
 };
 #if defined(CONFIG_SND_OSSEMUL) && defined(CONFIG_PROC_FS)
+#if (defined(CONFIG_SND_OSSEMUL) && defined(CONFIG_SND_PROC_FS)) || defined(TARGET_OS2)
 int snd_info_minor_register(void);
+int snd_info_minor_unregister(void);
+#else
+#define snd_info_minor_register() /* NOP */
+#define snd_info_minor_unregister() /* NOP */
+#endif
+#ifdef CONFIG_PROC_FS
+#else
+#define snd_info_minor_register()       0
+#endif
+#if defined(CONFIG_SND_PROC_FS)
 extern struct snd_info_entry *snd_seq_root;
 …
 #endif
+/**
+ * snd_iprintf - printf on the procfs buffer
+ * @buf: the procfs buffer
+ * @fmt: the printf format
+ *
+ * Outputs the string on the procfs buffer just like printf().
+ *
+ * Return: zero for success, or a negative error code.
+ */
 #ifndef TARGET_OS2
+int snd_iprintf(struct snd_info_buffer *buffer, const char *fmt, ...) \
+                                __attribute__ ((format (printf, 2, 3)));
+#else
+int snd_iprintf(struct snd_info_buffer * buffer, char *fmt,...);
+#endif
+#define snd_iprintf(buf, fmt, args...) \
+        seq_printf((struct seq_file *)(buf)->buffer, fmt, ##args)
+#else
+static inline int snd_iprintf(struct snd_info_buffer *buffer, char *fmt, ...) { return 0; }
+#endif
 int snd_info_init(void);
 int snd_info_done(void);
 …
 /* for card drivers */
+int snd_card_proc_new(struct snd_card *card, const char *name,
+                      struct snd_info_entry **entryp);
+static inline int snd_card_proc_new(struct snd_card *card, const char *name,
+                                    struct snd_info_entry **entryp)
+{
+        *entryp = snd_info_create_card_entry(card, name, card->proc_root);
+        return *entryp ? 0 : -ENOMEM;
+}
 static inline void snd_info_set_text_ops(struct snd_info_entry *entry,
 …
         entry->c.text.read = read;
+}
+int snd_card_rw_proc_new(struct snd_card *card, const char *name,
+                         void *private_data,
+                         void (*read)(struct snd_info_entry *,
+                                      struct snd_info_buffer *),
+                         void (*write)(struct snd_info_entry *entry,
+                                       struct snd_info_buffer *buffer));
 int snd_info_check_reserved_words(const char *str);
 …
 static inline int snd_card_proc_new(struct snd_card *card, const char *name,
                                     struct snd_info_entry **entryp) { return -EINVAL; }
 static inline void snd_info_set_text_ops(struct snd_info_entry *entry __attribute__((unused)),
+static inline void snd_info_set_text_ops(struct snd_info_entry *entry /*__attribute__((unused))*/,
                                          void *private_data,
                                          void (*read)(struct snd_info_entry *, struct snd_info_buffer *)) {}
+static inline int snd_card_rw_proc_new(struct snd_card *card, const char *name,
+                                       void *private_data,
+                                       void (*read)(struct snd_info_entry *,
+                                                    struct snd_info_buffer *),
+                                       void (*write)(struct snd_info_entry *entry,
+                                                     struct snd_info_buffer *buffer))
+{
+        return 0;
+}
 static inline int snd_info_check_reserved_words(const char *str) { return 1; }
 #endif
+/**
+ * snd_card_ro_proc_new - Create a read-only text proc file entry for the card
+ * @card: the card instance
+ * @name: the file name
+ * @private_data: the arbitrary private data
+ * @read: the read callback
+ *
+ * This proc file entry will be registered via snd_card_register() call, and
+ * it will be removed automatically at the card removal, too.
+ */
+static inline int
+snd_card_ro_proc_new(struct snd_card *card, const char *name,
+                     void *private_data,
+                     void (*read)(struct snd_info_entry *,
+                                  struct snd_info_buffer *))
+{
+        return snd_card_rw_proc_new(card, name, private_data, read, NULL);
+}
 /*
 …
  */
 #if defined(CONFIG_SND_OSSEMUL) && defined(CONFIG_PROC_FS)
+#if (defined(CONFIG_SND_OSSEMUL) && defined(CONFIG_SND_PROC_FS)) || defined(TARGET_OS2)
 #define SNDRV_OSS_INFO_DEV_AUDIO        0
 …
 #define snd_oss_info_unregister(dev, num) snd_oss_info_register(dev, num, NULL)
 #endif /* CONFIG_SND_OSSEMUL && CONFIG_PROC_FS */
+#endif /* CONFIG_SND_OSSEMUL && CONFIG_SND_PROC_FS */
 #endif /* __SOUND_INFO_H */

GPL/trunk/alsa-kernel/include/sound/initval.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_INITVAL_H
 #define __SOUND_INITVAL_H
 …
  *  Init values for soundcard modules
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 …
 #define MODULE_DEVICES(val)
 #define MODULE_PARM_SYNTAX(id, val)
-#define module_param_array(name, type, nump, perm)
-#define module_param(name, type, perm)
 #else
 #define MODULE_CLASSES(val) MODULE_GENERIC_STRING(info_classes, val)
 …
 #define SNDRV_PORT_DESC         SNDRV_ENABLED ",allows:{{0,0xffff}},base:16"
+#ifdef SNDRV_LEGACY_FIND_FREE_IOPORT
+static long snd_legacy_find_free_ioport(const long *port_table, long size)
+{
+        while (*port_table != -1) {
+                if (request_region(*port_table, size, "ALSA test")) {
+                        release_region(*port_table, size);
+                        return *port_table;
+                }
+                port_table++;
+        }
+        return -1;
+}
+#endif
 #ifdef SNDRV_LEGACY_FIND_FREE_IRQ
 #include <linux/interrupt.h>
 …
+}
 static int snd_legacy_find_free_irq(int *irq_table)
+static int snd_legacy_find_free_irq(const int *irq_table)
+{
         while (*irq_table != -1) {
                 if (!request_irq(*irq_table, snd_legacy_empty_irq_handler,
                                  IRQF_DISABLED | IRQF_PROBE_SHARED, "ALSA Test IRQ",
+                                 IRQF_PROBE_SHARED, "ALSA Test IRQ",
                                  (void *) irq_table)) {
                         free_irq(*irq_table, (void *) irq_table);
 …
 #ifdef SNDRV_LEGACY_FIND_FREE_DMA
 static int snd_legacy_find_free_dma(int *dma_table)
+static int snd_legacy_find_free_dma(const int *dma_table)
+{
         while (*dma_table != -1) {

GPL/trunk/alsa-kernel/include/sound/jack.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_JACK_H
 #define __SOUND_JACK_H
 …
+ *
  *  Copyright 2008 Wolfson Microelectronics plc
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 …
 /**
+ * Jack types which can be reported.  These values are used as a
+ * bitmask.
+ * enum snd_jack_types - Jack types which can be reported
+ * @SND_JACK_HEADPHONE: Headphone
+ * @SND_JACK_MICROPHONE: Microphone
+ * @SND_JACK_HEADSET: Headset
+ * @SND_JACK_LINEOUT: Line out
+ * @SND_JACK_MECHANICAL: Mechanical switch
+ * @SND_JACK_VIDEOOUT: Video out
+ * @SND_JACK_AVOUT: AV (Audio Video) out
+ * @SND_JACK_LINEIN:  Line in
+ * @SND_JACK_BTN_0: Button 0
+ * @SND_JACK_BTN_1: Button 1
+ * @SND_JACK_BTN_2: Button 2
+ * @SND_JACK_BTN_3: Button 3
+ * @SND_JACK_BTN_4: Button 4
+ * @SND_JACK_BTN_5: Button 5
+ *
+ * These values are used as a bitmask.
+ *
  * Note that this must be kept in sync with the lookup table in
 …
         SND_JACK_VIDEOOUT       = 0x0010,
         SND_JACK_AVOUT          = SND_JACK_LINEOUT | SND_JACK_VIDEOOUT,
+        SND_JACK_LINEIN         = 0x0020,
         /* Kept separate from switches to facilitate implementation */
 …
 };
+/* Keep in sync with definitions above */
+#define SND_JACK_SWITCH_TYPES 6
 struct snd_jack {
+        struct list_head kctl_list;
+        struct snd_card *card;
+        const char *id;
+#ifdef CONFIG_SND_JACK_INPUT_DEV
         struct input_dev *input_dev;
         int registered;
         int type;
-        const char *id;
         char name[100];
         unsigned int key[6];   /* Keep in sync with definitions above */
+#endif /* CONFIG_SND_JACK_INPUT_DEV */
         void *private_data;
         void (*private_free)(struct snd_jack *);
 …
 int snd_jack_new(struct snd_card *card, const char *id, int type,
+                 struct snd_jack **jack);
+                 struct snd_jack **jack, bool initial_kctl, bool phantom_jack);
+int snd_jack_add_new_kctl(struct snd_jack *jack, const char * name, int mask);
+#ifdef CONFIG_SND_JACK_INPUT_DEV
 void snd_jack_set_parent(struct snd_jack *jack, struct device *parent);
 int snd_jack_set_key(struct snd_jack *jack, enum snd_jack_types type,
                      int keytype);
+#endif
 void snd_jack_report(struct snd_jack *jack, int status);
 #else
 static inline int snd_jack_new(struct snd_card *card, const char *id, int type,
                                struct snd_jack **jack)
+                               struct snd_jack **jack, bool initial_kctl, bool phantom_jack)
+{
         return 0;
+}
+static inline void snd_jack_set_parent(struct snd_jack *jack,
+                                       struct device *parent)
+static inline int snd_jack_add_new_kctl(struct snd_jack *jack, const char * name, int mask)
+{
+        return 0;
+}
 …
 #endif
+#if !defined(CONFIG_SND_JACK) || !defined(CONFIG_SND_JACK_INPUT_DEV)
+static inline void snd_jack_set_parent(struct snd_jack *jack,
+                                       struct device *parent)
+{
+}
+static inline int snd_jack_set_key(struct snd_jack *jack,
+                                   enum snd_jack_types type,
+                                   int keytype)
+{
+        return 0;
+}
+#endif /* !CONFIG_SND_JACK || !CONFIG_SND_JACK_INPUT_DEV */
 #endif

GPL/trunk/alsa-kernel/include/sound/memalloc.h

-              r464
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 /*
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
 …
+ *
  *  Generic memory allocators
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 #ifndef __SOUND_MEMALLOC_H
 #define __SOUND_MEMALLOC_H
+#include <asm/page.h>
 struct device;
 …
 };
+#ifndef snd_dma_pci_data
+#define snd_dma_pci_data(pci)   (&(pci)->dev)
+#define snd_dma_isa_data()      NULL
+#define snd_dma_continuous_data(x)      ((struct device *)(unsigned long)(x))
+#endif
+#define snd_dma_continuous_data(x)      ((struct device *)(__force unsigned long)(x))
 …
 #define SNDRV_DMA_TYPE_CONTINUOUS       1       /* continuous no-DMA memory */
 #define SNDRV_DMA_TYPE_DEV              2       /* generic device continuous */
+#define SNDRV_DMA_TYPE_DEV_UC           5       /* continuous non-cahced */
 #ifdef CONFIG_SND_DMA_SGBUF
 #define SNDRV_DMA_TYPE_DEV_SG           3       /* generic device SG-buffer */
+#define SNDRV_DMA_TYPE_DEV_UC_SG        6       /* SG non-cached */
 #else
 #define SNDRV_DMA_TYPE_DEV_SG   SNDRV_DMA_TYPE_DEV /* no SG-buf support */
+#define SNDRV_DMA_TYPE_DEV_UC_SG        SNDRV_DMA_TYPE_DEV_UC
 #endif
+#ifdef CONFIG_GENERIC_ALLOCATOR
+#define SNDRV_DMA_TYPE_DEV_IRAM         4       /* generic device iram-buffer */
+#else
+#define SNDRV_DMA_TYPE_DEV_IRAM SNDRV_DMA_TYPE_DEV
+#endif
+#define SNDRV_DMA_TYPE_VMALLOC          7       /* vmalloc'ed buffer */
 /*
 …
         void *private_data;     /* private for allocator; don't touch */
 };
+/*
+ * return the pages matching with the given byte size
+ */
+static inline unsigned int snd_sgbuf_aligned_pages(size_t size)
+{
+        return (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
+}
 #ifdef CONFIG_SND_DMA_SGBUF
 …
 /*
- * return the pages matching with the given byte size
- */
-static inline unsigned int snd_sgbuf_aligned_pages(size_t size)
+{
-        return (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
+}
-/*
  * return the physical address at the corresponding offset
  */
+static inline dma_addr_t snd_sgbuf_get_addr(struct snd_sg_buf *sgbuf, size_t offset)
+static inline dma_addr_t snd_sgbuf_get_addr(struct snd_dma_buffer *dmab,
+                                           size_t offset)
+{
+        dma_addr_t addr = sgbuf->table[offset >> PAGE_SHIFT].addr;
+        addr &= PAGE_MASK;
+        struct snd_sg_buf *sgbuf = dmab->private_data;
+        dma_addr_t addr;
+        if (!sgbuf)
+                return dmab->addr + offset;
+        addr = sgbuf->table[offset >> PAGE_SHIFT].addr;
+        addr &= ~((dma_addr_t)PAGE_SIZE - 1);
         return addr + offset % PAGE_SIZE;
+}
 …
  * return the virtual address at the corresponding offset
  */
+static inline void *snd_sgbuf_get_ptr(struct snd_sg_buf *sgbuf, size_t offset)
+static inline void *snd_sgbuf_get_ptr(struct snd_dma_buffer *dmab,
+                                     size_t offset)
+{
+        struct snd_sg_buf *sgbuf = dmab->private_data;
+        if (!sgbuf)
+                return dmab->area + offset;
         return sgbuf->table[offset >> PAGE_SHIFT].buf + offset % PAGE_SIZE;
+}
+unsigned int snd_sgbuf_get_chunk_size(struct snd_dma_buffer *dmab,
+                                      unsigned int ofs, unsigned int size);
+#else
+/* non-SG versions */
+static inline dma_addr_t snd_sgbuf_get_addr(struct snd_dma_buffer *dmab,
+                                            size_t offset)
+{
+        return dmab->addr + offset;
+}
+static inline void *snd_sgbuf_get_ptr(struct snd_dma_buffer *dmab,
+                                      size_t offset)
+{
+        return dmab->area + offset;
+}
+#define snd_sgbuf_get_chunk_size(dmab, ofs, size)       (size)
 #endif /* CONFIG_SND_DMA_SGBUF */
 …
 void snd_dma_free_pages(struct snd_dma_buffer *dmab);
-/* buffer-preservation managements */
-#define snd_dma_pci_buf_id(pci) (((unsigned int)(pci)->vendor << 16) | (pci)->device)
-size_t snd_dma_get_reserved_buf(struct snd_dma_buffer *dmab, unsigned int id);
-int snd_dma_reserve_buf(struct snd_dma_buffer *dmab, unsigned int id);
-/* basic memory allocation functions */
-void *snd_malloc_pages(size_t size, gfp_t gfp_flags);
-void snd_free_pages(void *ptr, size_t size);
 #endif /* __SOUND_MEMALLOC_H */

GPL/trunk/alsa-kernel/include/sound/minors.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_MINORS_H
 #define __SOUND_MINORS_H
 …
 /*
  *  MINOR numbers
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 …
 #ifndef CONFIG_SND_DYNAMIC_MINORS
                                                 /* 2 - 3 (reserved) */
+#define SNDRV_MINOR_COMPRESS            2       /* 2 - 3 */
 #define SNDRV_MINOR_HWDEP               4       /* 4 - 7 */
 #define SNDRV_MINOR_RAWMIDI             8       /* 8 - 15 */
 …
 #define SNDRV_DEVICE_TYPE_SEQUENCER     SNDRV_MINOR_SEQUENCER
 #define SNDRV_DEVICE_TYPE_TIMER         SNDRV_MINOR_TIMER
+#define SNDRV_DEVICE_TYPE_COMPRESS      SNDRV_MINOR_COMPRESS
 #else /* CONFIG_SND_DYNAMIC_MINORS */
 …
         SNDRV_DEVICE_TYPE_PCM_PLAYBACK,
         SNDRV_DEVICE_TYPE_PCM_CAPTURE,
+        SNDRV_DEVICE_TYPE_COMPRESS,
 };

GPL/trunk/alsa-kernel/include/sound/mixer_oss.h

-              r398
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_MIXER_OSS_H
 #define __SOUND_MIXER_OSS_H
 …
  *  OSS MIXER API
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
 #define SNDRV_OSS_MAX_MIXERS    32
 …
 };
+int snd_mixer_oss_ioctl_card(struct snd_card *card,
+                             unsigned int cmd, unsigned long arg);
 #endif /* CONFIG_SND_MIXER_OSS */

GPL/trunk/alsa-kernel/include/sound/mpu401.h

-              r399
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_MPU401_H
 #define __SOUND_MPU401_H
 …
  *  Header file for MPU-401 and compatible cards
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 #include "rawmidi.h"
+#include <sound/rawmidi.h>
 #include <linux/interrupt.h>
 …
 #define MPU401_INFO_MMIO        (1 << 3)        /* MMIO access */
 #define MPU401_INFO_TX_IRQ      (1 << 4)        /* independent TX irq */
+#define MPU401_INFO_IRQ_HOOK    (1 << 5)        /* mpu401 irq handler is called
+                                                   from driver irq handler */
 #define MPU401_INFO_NO_ACK      (1 << 6)        /* No ACK cmd needed */
+#define MPU401_INFO_USE_TIMER   (1 << 15)       /* internal */
 #define MPU401_MODE_BIT_INPUT           0
 …
         unsigned long cport;            /* port + 1 (usually) */
         struct resource *res;           /* port resource */
+        int irq;                        /* IRQ number of MPU-401 chip (-1 = poll) */
+        int irq_flags;
+        int irq;                        /* IRQ number of MPU-401 chip */
         unsigned long mode;             /* MPU401_MODE_XXXX */
 …
                         unsigned int info_flags,
                         int irq,
-                        int irq_flags,
                         struct snd_rawmidi ** rrawmidi);

GPL/trunk/alsa-kernel/include/sound/opl3.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_OPL3_H
 #define __SOUND_OPL3_H
 …
  * Copyright (c) by Jaroslav Kysela <perex@perex.cz>,
  *                  Hannu Savolainen 1993-1996
+ *
+ *
  *      The OPL-3 mode is switched on by writing 0x01, to the offset 5
 …
  *      register of the voice (0xC0-0xC8). In 4 OP voices these bits are
  *      in the second half of the voice.
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 …
 #include <sound/timer.h>
 #include <sound/seq_midi_emul.h>
-#ifdef CONFIG_SND_SEQUENCER_OSS
 #include <sound/seq_oss.h>
 #include <sound/seq_oss_legacy.h>
-#endif
 #include <sound/seq_device.h>
 #include <sound/asound_fm.h>
 …
         unsigned char rhythm;           /* percussion mode flag */
         unsigned char max_voices;       /* max number of voices */
 #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
+#if IS_ENABLED(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER)
 #define SNDRV_OPL3_MODE_SYNTH 0         /* OSS - voices allocated by application */
 #define SNDRV_OPL3_MODE_SEQ 1           /* ALSA - driver handles voice allocation */
 …
         struct snd_midi_channel_set * chset;
 #ifdef CONFIG_SND_SEQUENCER_OSS
+#if IS_ENABLED(CONFIG_SND_SEQUENCER_OSS) || defined(CONFIG_SND_SEQUENCER)
         struct snd_seq_device *oss_seq_dev;     /* OSS sequencer device */
         struct snd_midi_channel_set * oss_chset;
 …
 void snd_opl3_reset(struct snd_opl3 * opl3);
 #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
+#if IS_ENABLED(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER)
 long snd_opl3_write(struct snd_hwdep *hw, const char __user *buf, long count,
                     loff_t *offset);

GPL/trunk/alsa-kernel/include/sound/opl4.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_OPL4_H
 #define __SOUND_OPL4_H
 …
  * Global definitions for the OPL4 driver
  * Copyright (c) 2003 by Clemens Ladisch <clemens@ladisch.de>
+ *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
+ *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */

GPL/trunk/alsa-kernel/include/sound/pcm-indirect.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 /*
  * Helper functions for indirect PCM data transfer
 …
  *  Copyright (c) by Takashi Iwai <tiwai@suse.de>
  *                   Jaroslav Kysela <perex@perex.cz>
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 …
  * helper function for playback ack callback
  */
 static inline void
+static inline int
 snd_pcm_indirect_playback_transfer(struct snd_pcm_substream *substream,
                                    struct snd_pcm_indirect *rec,
 …
                 if (diff < -(snd_pcm_sframes_t) (runtime->boundary / 2))
                         diff += runtime->boundary;
+                if (diff < 0)
+                        return -EINVAL;
                 rec->sw_ready += (int)frames_to_bytes(runtime, diff);
                 rec->appl_ptr = appl_ptr;
 …
                 rec->sw_ready -= bytes;
+        }
+        return 0;
+}
 …
  * helper function for capture ack callback
  */
 static inline void
+static inline int
 snd_pcm_indirect_capture_transfer(struct snd_pcm_substream *substream,
                                   struct snd_pcm_indirect *rec,
 …
                 if (diff < -(snd_pcm_sframes_t) (runtime->boundary / 2))
                         diff += runtime->boundary;
+                if (diff < 0)
+                        return -EINVAL;
                 rec->sw_ready -= frames_to_bytes(runtime, diff);
                 rec->appl_ptr = appl_ptr;
 …
                 rec->sw_ready += bytes;
+        }
+        return 0;
+}

GPL/trunk/alsa-kernel/include/sound/pcm.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_PCM_H
 #define __SOUND_PCM_H
 …
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
  *                   Abramo Bagnara <abramo@alsa-project.org>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 …
 #include <linux/mm.h>
 #include <linux/bitops.h>
+#include <linux/pm_qos_params.h>
+#include <linux/pm_qos.h>
+#include <linux/refcount.h>
 #define snd_pcm_substream_chip(substream) ((substream)->private_data)
 #define snd_pcm_chip(pcm) ((pcm)->private_data)
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
 #include "pcm_oss.h"
+#if IS_ENABLED(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS)
+#include <sound/pcm_oss.h>
 #endif
 …
 };
+struct snd_pcm_status64;
 struct snd_pcm_substream;
+struct snd_pcm_audio_tstamp_config; /* definitions further down */
+struct snd_pcm_audio_tstamp_report;
 struct snd_pcm_ops {
 …
         int (*prepare)(struct snd_pcm_substream *substream);
         int (*trigger)(struct snd_pcm_substream *substream, int cmd);
+        int (*sync_stop)(struct snd_pcm_substream *substream);
         snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *substream);
+        int (*copy)(struct snd_pcm_substream *substream, int channel,
+                    snd_pcm_uframes_t pos,
+                    void __user *buf, snd_pcm_uframes_t count);
+        int (*silence)(struct snd_pcm_substream *substream, int channel,
+                       snd_pcm_uframes_t pos, snd_pcm_uframes_t count);
+        int (*get_time_info)(struct snd_pcm_substream *substream,
+                        struct timespec64 *system_ts, struct timespec64 *audio_ts,
+                        struct snd_pcm_audio_tstamp_config *audio_tstamp_config,
+                        struct snd_pcm_audio_tstamp_report *audio_tstamp_report);
+        int (*fill_silence)(struct snd_pcm_substream *substream, int channel,
+                            unsigned long pos, unsigned long bytes);
+        int (*copy_user)(struct snd_pcm_substream *substream, int channel,
+                         unsigned long pos, void __user *buf,
+                         unsigned long bytes);
+        int (*copy_kernel)(struct snd_pcm_substream *substream, int channel,
+                           unsigned long pos, void *buf, unsigned long bytes);
         struct page *(*page)(struct snd_pcm_substream *substream,
                              unsigned long offset);
 …
 #endif
-#define SNDRV_PCM_IOCTL1_FALSE          ((void *)0)
-#define SNDRV_PCM_IOCTL1_TRUE           ((void *)1)
 #define SNDRV_PCM_IOCTL1_RESET          0
+#define SNDRV_PCM_IOCTL1_INFO           1
+/* 1 is absent slot. */
 #define SNDRV_PCM_IOCTL1_CHANNEL_INFO   2
+#define SNDRV_PCM_IOCTL1_GSTATE         3
+/* 3 is absent slot. */
 #define SNDRV_PCM_IOCTL1_FIFO_SIZE      4
 …
 #define SNDRV_PCM_TRIGGER_SUSPEND       5
 #define SNDRV_PCM_TRIGGER_RESUME        6
+#define SNDRV_PCM_TRIGGER_DRAIN         7
 #define SNDRV_PCM_POS_XRUN              ((snd_pcm_uframes_t)-1)
 …
 #define SNDRV_PCM_RATE_176400           (1<<11)         /* 176400Hz */
 #define SNDRV_PCM_RATE_192000           (1<<12)         /* 192000Hz */
+#define SNDRV_PCM_RATE_352800           (1<<13)         /* 352800Hz */
+#define SNDRV_PCM_RATE_384000           (1<<14)         /* 384000Hz */
 #define SNDRV_PCM_RATE_CONTINUOUS       (1<<30)         /* continuous range */
 …
 #define SNDRV_PCM_RATE_8000_192000      (SNDRV_PCM_RATE_8000_96000|SNDRV_PCM_RATE_176400|\
                                          SNDRV_PCM_RATE_192000)
+#define SNDRV_PCM_FMTBIT_S8             (1ULL << SNDRV_PCM_FORMAT_S8)
+#define SNDRV_PCM_FMTBIT_U8             (1ULL << SNDRV_PCM_FORMAT_U8)
+#define SNDRV_PCM_FMTBIT_S16_LE         (1ULL << SNDRV_PCM_FORMAT_S16_LE)
+#define SNDRV_PCM_FMTBIT_S16_BE         (1ULL << SNDRV_PCM_FORMAT_S16_BE)
+#define SNDRV_PCM_FMTBIT_U16_LE         (1ULL << SNDRV_PCM_FORMAT_U16_LE)
+#define SNDRV_PCM_FMTBIT_U16_BE         (1ULL << SNDRV_PCM_FORMAT_U16_BE)
+#define SNDRV_PCM_FMTBIT_S24_LE         (1ULL << SNDRV_PCM_FORMAT_S24_LE)
+#define SNDRV_PCM_FMTBIT_S24_BE         (1ULL << SNDRV_PCM_FORMAT_S24_BE)
+#define SNDRV_PCM_FMTBIT_U24_LE         (1ULL << SNDRV_PCM_FORMAT_U24_LE)
+#define SNDRV_PCM_FMTBIT_U24_BE         (1ULL << SNDRV_PCM_FORMAT_U24_BE)
+#define SNDRV_PCM_FMTBIT_S32_LE         (1ULL << SNDRV_PCM_FORMAT_S32_LE)
+#define SNDRV_PCM_FMTBIT_S32_BE         (1ULL << SNDRV_PCM_FORMAT_S32_BE)
+#define SNDRV_PCM_FMTBIT_U32_LE         (1ULL << SNDRV_PCM_FORMAT_U32_LE)
+#define SNDRV_PCM_FMTBIT_U32_BE         (1ULL << SNDRV_PCM_FORMAT_U32_BE)
+#define SNDRV_PCM_FMTBIT_FLOAT_LE       (1ULL << SNDRV_PCM_FORMAT_FLOAT_LE)
+#define SNDRV_PCM_FMTBIT_FLOAT_BE       (1ULL << SNDRV_PCM_FORMAT_FLOAT_BE)
+#define SNDRV_PCM_FMTBIT_FLOAT64_LE     (1ULL << SNDRV_PCM_FORMAT_FLOAT64_LE)
+#define SNDRV_PCM_FMTBIT_FLOAT64_BE     (1ULL << SNDRV_PCM_FORMAT_FLOAT64_BE)
+#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE (1ULL << SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE)
+#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE (1ULL << SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE)
+#define SNDRV_PCM_FMTBIT_MU_LAW         (1ULL << SNDRV_PCM_FORMAT_MU_LAW)
+#define SNDRV_PCM_FMTBIT_A_LAW          (1ULL << SNDRV_PCM_FORMAT_A_LAW)
+#define SNDRV_PCM_FMTBIT_IMA_ADPCM      (1ULL << SNDRV_PCM_FORMAT_IMA_ADPCM)
+#define SNDRV_PCM_FMTBIT_MPEG           (1ULL << SNDRV_PCM_FORMAT_MPEG)
+#define SNDRV_PCM_FMTBIT_GSM            (1ULL << SNDRV_PCM_FORMAT_GSM)
+#define SNDRV_PCM_FMTBIT_SPECIAL        (1ULL << SNDRV_PCM_FORMAT_SPECIAL)
+#define SNDRV_PCM_FMTBIT_S24_3LE        (1ULL << SNDRV_PCM_FORMAT_S24_3LE)
+#define SNDRV_PCM_FMTBIT_U24_3LE        (1ULL << SNDRV_PCM_FORMAT_U24_3LE)
+#define SNDRV_PCM_FMTBIT_S24_3BE        (1ULL << SNDRV_PCM_FORMAT_S24_3BE)
+#define SNDRV_PCM_FMTBIT_U24_3BE        (1ULL << SNDRV_PCM_FORMAT_U24_3BE)
+#define SNDRV_PCM_FMTBIT_S20_3LE        (1ULL << SNDRV_PCM_FORMAT_S20_3LE)
+#define SNDRV_PCM_FMTBIT_U20_3LE        (1ULL << SNDRV_PCM_FORMAT_U20_3LE)
+#define SNDRV_PCM_FMTBIT_S20_3BE        (1ULL << SNDRV_PCM_FORMAT_S20_3BE)
+#define SNDRV_PCM_FMTBIT_U20_3BE        (1ULL << SNDRV_PCM_FORMAT_U20_3BE)
+#define SNDRV_PCM_FMTBIT_S18_3LE        (1ULL << SNDRV_PCM_FORMAT_S18_3LE)
+#define SNDRV_PCM_FMTBIT_U18_3LE        (1ULL << SNDRV_PCM_FORMAT_U18_3LE)
+#define SNDRV_PCM_FMTBIT_S18_3BE        (1ULL << SNDRV_PCM_FORMAT_S18_3BE)
+#define SNDRV_PCM_FMTBIT_U18_3BE        (1ULL << SNDRV_PCM_FORMAT_U18_3BE)
+#define SNDRV_PCM_FMTBIT_G723_24        (1ULL << SNDRV_PCM_FORMAT_G723_24)
+#define SNDRV_PCM_FMTBIT_G723_24_1B     (1ULL << SNDRV_PCM_FORMAT_G723_24_1B)
+#define SNDRV_PCM_FMTBIT_G723_40        (1ULL << SNDRV_PCM_FORMAT_G723_40)
+#define SNDRV_PCM_FMTBIT_G723_40_1B     (1ULL << SNDRV_PCM_FORMAT_G723_40_1B)
+#define SNDRV_PCM_RATE_8000_384000      (SNDRV_PCM_RATE_8000_192000|\
+                                         SNDRV_PCM_RATE_352800|\
+                                         SNDRV_PCM_RATE_384000)
+#define _SNDRV_PCM_FMTBIT(fmt)          (1ULL << (__force int)SNDRV_PCM_FORMAT_##fmt)
+#define SNDRV_PCM_FMTBIT_S8             _SNDRV_PCM_FMTBIT(S8)
+#define SNDRV_PCM_FMTBIT_U8             _SNDRV_PCM_FMTBIT(U8)
+#define SNDRV_PCM_FMTBIT_S16_LE         _SNDRV_PCM_FMTBIT(S16_LE)
+#define SNDRV_PCM_FMTBIT_S16_BE         _SNDRV_PCM_FMTBIT(S16_BE)
+#define SNDRV_PCM_FMTBIT_U16_LE         _SNDRV_PCM_FMTBIT(U16_LE)
+#define SNDRV_PCM_FMTBIT_U16_BE         _SNDRV_PCM_FMTBIT(U16_BE)
+#define SNDRV_PCM_FMTBIT_S24_LE         _SNDRV_PCM_FMTBIT(S24_LE)
+#define SNDRV_PCM_FMTBIT_S24_BE         _SNDRV_PCM_FMTBIT(S24_BE)
+#define SNDRV_PCM_FMTBIT_U24_LE         _SNDRV_PCM_FMTBIT(U24_LE)
+#define SNDRV_PCM_FMTBIT_U24_BE         _SNDRV_PCM_FMTBIT(U24_BE)
+#define SNDRV_PCM_FMTBIT_S32_LE         _SNDRV_PCM_FMTBIT(S32_LE)
+#define SNDRV_PCM_FMTBIT_S32_BE         _SNDRV_PCM_FMTBIT(S32_BE)
+#define SNDRV_PCM_FMTBIT_U32_LE         _SNDRV_PCM_FMTBIT(U32_LE)
+#define SNDRV_PCM_FMTBIT_U32_BE         _SNDRV_PCM_FMTBIT(U32_BE)
+#define SNDRV_PCM_FMTBIT_FLOAT_LE       _SNDRV_PCM_FMTBIT(FLOAT_LE)
+#define SNDRV_PCM_FMTBIT_FLOAT_BE       _SNDRV_PCM_FMTBIT(FLOAT_BE)
+#define SNDRV_PCM_FMTBIT_FLOAT64_LE     _SNDRV_PCM_FMTBIT(FLOAT64_LE)
+#define SNDRV_PCM_FMTBIT_FLOAT64_BE     _SNDRV_PCM_FMTBIT(FLOAT64_BE)
+#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_LE)
+#define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_BE)
+#define SNDRV_PCM_FMTBIT_MU_LAW         _SNDRV_PCM_FMTBIT(MU_LAW)
+#define SNDRV_PCM_FMTBIT_A_LAW          _SNDRV_PCM_FMTBIT(A_LAW)
+#define SNDRV_PCM_FMTBIT_IMA_ADPCM      _SNDRV_PCM_FMTBIT(IMA_ADPCM)
+#define SNDRV_PCM_FMTBIT_MPEG           _SNDRV_PCM_FMTBIT(MPEG)
+#define SNDRV_PCM_FMTBIT_GSM            _SNDRV_PCM_FMTBIT(GSM)
+#define SNDRV_PCM_FMTBIT_S20_LE _SNDRV_PCM_FMTBIT(S20_LE)
+#define SNDRV_PCM_FMTBIT_U20_LE _SNDRV_PCM_FMTBIT(U20_LE)
+#define SNDRV_PCM_FMTBIT_S20_BE _SNDRV_PCM_FMTBIT(S20_BE)
+#define SNDRV_PCM_FMTBIT_U20_BE _SNDRV_PCM_FMTBIT(U20_BE)
+#define SNDRV_PCM_FMTBIT_SPECIAL        _SNDRV_PCM_FMTBIT(SPECIAL)
+#define SNDRV_PCM_FMTBIT_S24_3LE        _SNDRV_PCM_FMTBIT(S24_3LE)
+#define SNDRV_PCM_FMTBIT_U24_3LE        _SNDRV_PCM_FMTBIT(U24_3LE)
+#define SNDRV_PCM_FMTBIT_S24_3BE        _SNDRV_PCM_FMTBIT(S24_3BE)
+#define SNDRV_PCM_FMTBIT_U24_3BE        _SNDRV_PCM_FMTBIT(U24_3BE)
+#define SNDRV_PCM_FMTBIT_S20_3LE        _SNDRV_PCM_FMTBIT(S20_3LE)
+#define SNDRV_PCM_FMTBIT_U20_3LE        _SNDRV_PCM_FMTBIT(U20_3LE)
+#define SNDRV_PCM_FMTBIT_S20_3BE        _SNDRV_PCM_FMTBIT(S20_3BE)
+#define SNDRV_PCM_FMTBIT_U20_3BE        _SNDRV_PCM_FMTBIT(U20_3BE)
+#define SNDRV_PCM_FMTBIT_S18_3LE        _SNDRV_PCM_FMTBIT(S18_3LE)
+#define SNDRV_PCM_FMTBIT_U18_3LE        _SNDRV_PCM_FMTBIT(U18_3LE)
+#define SNDRV_PCM_FMTBIT_S18_3BE        _SNDRV_PCM_FMTBIT(S18_3BE)
+#define SNDRV_PCM_FMTBIT_U18_3BE        _SNDRV_PCM_FMTBIT(U18_3BE)
+#define SNDRV_PCM_FMTBIT_G723_24        _SNDRV_PCM_FMTBIT(G723_24)
+#define SNDRV_PCM_FMTBIT_G723_24_1B     _SNDRV_PCM_FMTBIT(G723_24_1B)
+#define SNDRV_PCM_FMTBIT_G723_40        _SNDRV_PCM_FMTBIT(G723_40)
+#define SNDRV_PCM_FMTBIT_G723_40_1B     _SNDRV_PCM_FMTBIT(G723_40_1B)
+#define SNDRV_PCM_FMTBIT_DSD_U8         _SNDRV_PCM_FMTBIT(DSD_U8)
+#define SNDRV_PCM_FMTBIT_DSD_U16_LE     _SNDRV_PCM_FMTBIT(DSD_U16_LE)
+#define SNDRV_PCM_FMTBIT_DSD_U32_LE     _SNDRV_PCM_FMTBIT(DSD_U32_LE)
+#define SNDRV_PCM_FMTBIT_DSD_U16_BE     _SNDRV_PCM_FMTBIT(DSD_U16_BE)
+#define SNDRV_PCM_FMTBIT_DSD_U32_BE     _SNDRV_PCM_FMTBIT(DSD_U32_BE)
 #ifdef SNDRV_LITTLE_ENDIAN
 …
 #define SNDRV_PCM_FMTBIT_FLOAT64        SNDRV_PCM_FMTBIT_FLOAT64_LE
 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
+#define SNDRV_PCM_FMTBIT_S20            SNDRV_PCM_FMTBIT_S20_LE
+#define SNDRV_PCM_FMTBIT_U20            SNDRV_PCM_FMTBIT_U20_LE
 #endif
 #ifdef SNDRV_BIG_ENDIAN
 …
 #define SNDRV_PCM_FMTBIT_FLOAT64        SNDRV_PCM_FMTBIT_FLOAT64_BE
 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE
+#define SNDRV_PCM_FMTBIT_S20            SNDRV_PCM_FMTBIT_S20_BE
+#define SNDRV_PCM_FMTBIT_U20            SNDRV_PCM_FMTBIT_U20_BE
 #endif
 …
         struct snd_pcm_substream *substream;
         int no_compat_mmap;
+        unsigned int user_pversion;     /* supported protocol version */
 };
 …
 struct snd_pcm_hw_rule {
         unsigned int cond;
-        snd_pcm_hw_rule_func_t func;
         int var;
         int deps[4];
+        snd_pcm_hw_rule_func_t func;
         void *private;
 };
 …
 struct snd_pcm_hw_constraint_ratnums {
         int nrats;
         struct snd_ratnum *rats;
+        const struct snd_ratnum *rats;
 };
 struct snd_pcm_hw_constraint_ratdens {
         int nrats;
         struct snd_ratden *rats;
+        const struct snd_ratden *rats;
 };
 struct snd_pcm_hw_constraint_list {
+        const unsigned int *list;
         unsigned int count;
-        unsigned int *list;
         unsigned int mask;
 };
+struct snd_pcm_hwptr_log;
+struct snd_pcm_hw_constraint_ranges {
+        unsigned int count;
+        const struct snd_interval *ranges;
+        unsigned int mask;
+};
+/*
+ * userspace-provided audio timestamp config to kernel,
+ * structure is for internal use only and filled with dedicated unpack routine
+ */
+struct snd_pcm_audio_tstamp_config {
+        /* 5 of max 16 bits used */
+        u32 type_requested:4;
+        u32 report_delay:1; /* add total delay to A/D or D/A */
+};
+static inline void snd_pcm_unpack_audio_tstamp_config(__u32 data,
+                                                struct snd_pcm_audio_tstamp_config *config)
+{
+        config->type_requested = data & 0xF;
+        config->report_delay = (data >> 4) & 1;
+}
+/*
+ * kernel-provided audio timestamp report to user-space
+ * structure is for internal use only and read by dedicated pack routine
+ */
+struct snd_pcm_audio_tstamp_report {
+        /* 6 of max 16 bits used for bit-fields */
+        /* for backwards compatibility */
+        u32 valid:1;
+        /* actual type if hardware could not support requested timestamp */
+        u32 actual_type:4;
+        /* accuracy represented in ns units */
+        u32 accuracy_report:1; /* 0 if accuracy unknown, 1 if accuracy field is valid */
+        u32 accuracy; /* up to 4.29s, will be packed in separate field  */
+};
+static inline void snd_pcm_pack_audio_tstamp_report(__u32 *data, __u32 *accuracy,
+                                                const struct snd_pcm_audio_tstamp_report *report)
+{
+        u32 tmp;
+        tmp = report->accuracy_report;
+        tmp <<= 4;
+        tmp |= report->actual_type;
+        tmp <<= 1;
+        tmp |= report->valid;
+        *data &= 0xffff; /* zero-clear MSBs */
+        *data |= (tmp << 16);
+        *accuracy = report->accuracy;
+}
 struct snd_pcm_runtime {
         /* -- Status -- */
         struct snd_pcm_substream *trigger_master;
+        struct timespec trigger_tstamp; /* trigger timestamp */
+        struct timespec64 trigger_tstamp;       /* trigger timestamp */
+        bool trigger_tstamp_latched;     /* trigger timestamp latched in low-level driver/hardware */
         int overrange;
         snd_pcm_uframes_t avail_max;
 …
         unsigned long hw_ptr_buffer_jiffies; /* buffer time in jiffies */
         snd_pcm_sframes_t delay;        /* extra delay; typically FIFO size */
+        u64 hw_ptr_wrap;                /* offset for hw_ptr due to boundary wrap-around */
         /* -- HW params -- */
 …
         wait_queue_head_t tsleep;       /* transfer sleep */
         struct fasync_struct *fasync;
+        bool stop_operating;            /* sync_stop will be called */
         /* -- private section -- */
 …
         struct snd_pcm_hardware hw;
         struct snd_pcm_hw_constraints hw_constraints;
-        /* -- interrupt callbacks -- */
-        void (*transfer_ack_begin)(struct snd_pcm_substream *substream);
-        void (*transfer_ack_end)(struct snd_pcm_substream *substream);
         /* -- timer -- */
 …
         struct snd_dma_buffer *dma_buffer_p;    /* allocated buffer */
+#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
+        unsigned int buffer_changed:1;  /* buffer allocation changed; set only in managed mode */
+        /* -- audio timestamp config -- */
+        struct snd_pcm_audio_tstamp_config audio_tstamp_config;
+        struct snd_pcm_audio_tstamp_report audio_tstamp_report;
+        struct timespec64 driver_tstamp;
+#if IS_ENABLED(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS)
         /* -- OSS things -- */
         struct snd_pcm_oss_runtime oss;
 #endif
-#ifdef CONFIG_SND_PCM_XRUN_DEBUG
-        struct snd_pcm_hwptr_log *hwptr_log;
-#endif
 };
 struct snd_pcm_group {          /* keep linked substreams */
         spinlock_t lock;
+        struct mutex mutex;
         struct list_head substreams;
         int count;
+        refcount_t refs;
 };
 …
         char name[32];                  /* substream name */
         int stream;                     /* stream (direction) */
+#ifndef TARGET_OS2
+        struct pm_qos_request_list latency_pm_qos_req; /* pm_qos request */
+#else
+        char latency_id[20];
+#endif
+        struct pm_qos_request latency_pm_qos_req; /* pm_qos request */
         size_t buffer_bytes_max;        /* limit ring buffer size */
         struct snd_dma_buffer dma_buffer;
-        unsigned int dma_buf_id;
         size_t dma_max;
         /* -- hardware operations -- */
         struct snd_pcm_ops *ops;
+        const struct snd_pcm_ops *ops;
         /* -- runtime information -- */
         struct snd_pcm_runtime *runtime;
 …
         struct snd_timer *timer;                /* timer */
         unsigned timer_running: 1;      /* time is running */
+        long wait_time; /* time in ms for R/W to wait for avail */
         /* -- next substream -- */
         struct snd_pcm_substream *next;
 …
         struct snd_pcm_group *group;            /* pointer to current group */
         /* -- assigned files -- */
-        void *file;
         int ref_count;
         atomic_t mmap_count;
 …
         void (*pcm_release)(struct snd_pcm_substream *);
         struct pid *pid;
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS)
         /* -- OSS things -- */
         struct snd_pcm_oss_substream oss;
 …
 #ifdef CONFIG_SND_VERBOSE_PROCFS
         struct snd_info_entry *proc_root;
+        struct snd_info_entry *proc_info_entry;
+        struct snd_info_entry *proc_hw_params_entry;
+        struct snd_info_entry *proc_sw_params_entry;
+        struct snd_info_entry *proc_status_entry;
+        struct snd_info_entry *proc_prealloc_entry;
+        struct snd_info_entry *proc_prealloc_max_entry;
+#endif
+#endif /* CONFIG_SND_VERBOSE_PROCFS */
         /* misc flags */
         unsigned int hw_opened: 1;
+        unsigned int managed_buffer_alloc:1;
 };
 …
         unsigned int substream_opened;
         struct snd_pcm_substream *substream;
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
+#if IS_ENABLED(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS)
         /* -- OSS things -- */
         struct snd_pcm_oss_stream oss;
 …
 #ifdef CONFIG_SND_VERBOSE_PROCFS
         struct snd_info_entry *proc_root;
-        struct snd_info_entry *proc_info_entry;
 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
         unsigned int xrun_debug;        /* 0 = disabled, 1 = verbose, 2 = stacktrace */
+        struct snd_info_entry *proc_xrun_debug_entry;
+#endif
+#endif
+#endif
+#endif
+        struct snd_kcontrol *chmap_kctl; /* channel-mapping controls */
+        struct device dev;
 };
 …
         void *private_data;
         void (*private_free) (struct snd_pcm *pcm);
+        struct device *dev; /* actual hw device this belongs to */
+#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
+        bool internal; /* pcm is for internal use only */
+        bool nonatomic; /* whole PCM operations are in non-atomic context */
+        bool no_device_suspend; /* don't invoke device PM suspend */
+#if IS_ENABLED(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS)
         struct snd_pcm_oss oss;
 #endif
 };
+/*
+ *  Registering
+ */
+extern const struct file_operations snd_pcm_f_ops[2];
+int snd_pcm_new(struct snd_card *card, const char *id, int device,
+                int playback_count, int capture_count,
+                struct snd_pcm **rpcm);
+int snd_pcm_new_internal(struct snd_card *card, const char *id, int device,
+                int playback_count, int capture_count,
+                struct snd_pcm **rpcm);
+int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count);
+#if IS_ENABLED(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS)
 struct snd_pcm_notify {
         int (*n_register) (struct snd_pcm * pcm);
 …
         struct list_head list;
 };
-/*
- *  Registering
- */
-#ifndef TARGET_OS2
-extern const struct file_operations snd_pcm_f_ops[2];
-#else
-extern struct file_operations snd_pcm_f_ops[2];
-#endif
-int snd_pcm_new(struct snd_card *card, const char *id, int device,
-                int playback_count, int capture_count,
-                struct snd_pcm **rpcm);
-int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count);
 int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree);
+#endif
 /*
  *  Native I/O
  */
-extern rwlock_t snd_pcm_link_rwlock;
 int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info);
 int snd_pcm_info_user(struct snd_pcm_substream *substream,
                       struct snd_pcm_info __user *info);
 int snd_pcm_status(struct snd_pcm_substream *substream,
                    struct snd_pcm_status *status);
+int snd_pcm_status64(struct snd_pcm_substream *substream,
+                     struct snd_pcm_status64 *status);
 int snd_pcm_start(struct snd_pcm_substream *substream);
 int snd_pcm_stop(struct snd_pcm_substream *substream, int status);
+int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t status);
 int snd_pcm_drain_done(struct snd_pcm_substream *substream);
+int snd_pcm_stop_xrun(struct snd_pcm_substream *substream);
 #ifdef CONFIG_PM
-int snd_pcm_suspend(struct snd_pcm_substream *substream);
 int snd_pcm_suspend_all(struct snd_pcm *pcm);
+#else
+static inline int snd_pcm_suspend_all(struct snd_pcm *pcm)
+{
+        return 0;
+}
 #endif
 int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg);
 …
                              struct snd_pcm_substream **rsubstream);
 void snd_pcm_detach_substream(struct snd_pcm_substream *substream);
-void snd_pcm_vma_notify_data(void *client, void *data);
 int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area);
+#ifdef CONFIG_SND_DEBUG
+void snd_pcm_debug_name(struct snd_pcm_substream *substream,
+                           char *name, size_t len);
+#else
+static inline void
+snd_pcm_debug_name(struct snd_pcm_substream *substream, char *buf, size_t size)
+{
+        *buf = 0;
+}
+#endif
 /*
 …
  */
+/**
+ * snd_pcm_stream_linked - Check whether the substream is linked with others
+ * @substream: substream to check
+ *
+ * Returns true if the given substream is being linked with others.
+ */
 static inline int snd_pcm_stream_linked(struct snd_pcm_substream *substream)
+{
 …
+}
+static inline void snd_pcm_stream_lock(struct snd_pcm_substream *substream)
+{
+        read_lock(&snd_pcm_link_rwlock);
+        spin_lock(&substream->self_group.lock);
+}
+static inline void snd_pcm_stream_unlock(struct snd_pcm_substream *substream)
+{
+        spin_unlock(&substream->self_group.lock);
+        read_unlock(&snd_pcm_link_rwlock);
+}
+static inline void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream)
+{
+        read_lock_irq(&snd_pcm_link_rwlock);
+        spin_lock(&substream->self_group.lock);
+}
+static inline void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream)
+{
+        spin_unlock(&substream->self_group.lock);
+        read_unlock_irq(&snd_pcm_link_rwlock);
+}
+#define snd_pcm_stream_lock_irqsave(substream, flags) \
+do { \
+        read_lock_irqsave(&snd_pcm_link_rwlock, (flags)); \
+        spin_lock(&substream->self_group.lock); \
+} while (0)
+#define snd_pcm_stream_unlock_irqrestore(substream, flags) \
+do { \
+        spin_unlock(&substream->self_group.lock); \
+        read_unlock_irqrestore(&snd_pcm_link_rwlock, (flags)); \
+} while (0)
+void snd_pcm_stream_lock(struct snd_pcm_substream *substream);
+void snd_pcm_stream_unlock(struct snd_pcm_substream *substream);
+void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream);
+void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream);
+unsigned long _snd_pcm_stream_lock_irqsave(struct snd_pcm_substream *substream);
+/**
+ * snd_pcm_stream_lock_irqsave - Lock the PCM stream
+ * @substream: PCM substream
+ * @flags: irq flags
+ *
+ * This locks the PCM stream like snd_pcm_stream_lock() but with the local
+ * IRQ (only when nonatomic is false).  In nonatomic case, this is identical
+ * as snd_pcm_stream_lock().
+ */
+#ifndef TARGET_OS2
+#define snd_pcm_stream_lock_irqsave(substream, flags)            \
+        do {                                                     \
+                typecheck(unsigned long, flags);                 \
+                flags = _snd_pcm_stream_lock_irqsave(substream); \
+        } while (0)
+#else
+#define snd_pcm_stream_lock_irqsave(substream, flags)            \
+        do {                                                     \
+                flags = _snd_pcm_stream_lock_irqsave(substream); \
+        } while (0)
+#endif
+void snd_pcm_stream_unlock_irqrestore(struct snd_pcm_substream *substream,
+                                      unsigned long flags);
+/**
+ * snd_pcm_group_for_each_entry - iterate over the linked substreams
+ * @s: the iterator
+ * @substream: the substream
+ *
+ * Iterate over the all linked substreams to the given @substream.
+ * When @substream isn't linked with any others, this gives returns @substream
+ * itself once.
+ */
 #define snd_pcm_group_for_each_entry(s, substream) \
         list_for_each_entry(s, &substream->group->substreams, link_list, struct snd_pcm_substream)
+#define for_each_pcm_streams(stream)                    \
+        for (stream  = SNDRV_PCM_STREAM_PLAYBACK;       \
+             stream <= SNDRV_PCM_STREAM_LAST;           \
+             stream++)
+/**
+ * snd_pcm_running - Check whether the substream is in a running state
+ * @substream: substream to check
+ *
+ * Returns true if the given substream is in the state RUNNING, or in the
+ * state DRAINING for playback.
+ */
 static inline int snd_pcm_running(struct snd_pcm_substream *substream)
+{
 …
+}
+/**
+ * bytes_to_samples - Unit conversion of the size from bytes to samples
+ * @runtime: PCM runtime instance
+ * @size: size in bytes
+ */
 static inline ssize_t bytes_to_samples(struct snd_pcm_runtime *runtime, ssize_t size)
+{
 …
+}
+/**
+ * bytes_to_frames - Unit conversion of the size from bytes to frames
+ * @runtime: PCM runtime instance
+ * @size: size in bytes
+ */
 static inline snd_pcm_sframes_t bytes_to_frames(struct snd_pcm_runtime *runtime, ssize_t size)
+{
 …
+}
+/**
+ * samples_to_bytes - Unit conversion of the size from samples to bytes
+ * @runtime: PCM runtime instance
+ * @size: size in samples
+ */
 static inline ssize_t samples_to_bytes(struct snd_pcm_runtime *runtime, ssize_t size)
+{
 …
+}
+/**
+ * frames_to_bytes - Unit conversion of the size from frames to bytes
+ * @runtime: PCM runtime instance
+ * @size: size in frames
+ */
 static inline ssize_t frames_to_bytes(struct snd_pcm_runtime *runtime, snd_pcm_sframes_t size)
+{
 …
+}
+/**
+ * frame_aligned - Check whether the byte size is aligned to frames
+ * @runtime: PCM runtime instance
+ * @bytes: size in bytes
+ */
 static inline int frame_aligned(struct snd_pcm_runtime *runtime, ssize_t bytes)
+{
 …
+}
+/**
+ * snd_pcm_lib_buffer_bytes - Get the buffer size of the current PCM in bytes
+ * @substream: PCM substream
+ */
 static inline size_t snd_pcm_lib_buffer_bytes(struct snd_pcm_substream *substream)
+{
 …
+}
+/**
+ * snd_pcm_lib_period_bytes - Get the period size of the current PCM in bytes
+ * @substream: PCM substream
+ */
 static inline size_t snd_pcm_lib_period_bytes(struct snd_pcm_substream *substream)
+{
 …
+}
+/*
+ *  result is: 0 ... (boundary - 1)
+/**
+ * snd_pcm_playback_avail - Get the available (writable) space for playback
+ * @runtime: PCM runtime instance
+ *
+ * Result is between 0 ... (boundary - 1)
  */
 static inline snd_pcm_uframes_t snd_pcm_playback_avail(struct snd_pcm_runtime *runtime)
 …
+}
+/*
+ *  result is: 0 ... (boundary - 1)
+/**
+ * snd_pcm_capture_avail - Get the available (readable) space for capture
+ * @runtime: PCM runtime instance
+ *
+ * Result is between 0 ... (boundary - 1)
  */
 static inline snd_pcm_uframes_t snd_pcm_capture_avail(struct snd_pcm_runtime *runtime)
 …
+}
+/**
+ * snd_pcm_playback_hw_avail - Get the queued space for playback
+ * @runtime: PCM runtime instance
+ */
 static inline snd_pcm_sframes_t snd_pcm_playback_hw_avail(struct snd_pcm_runtime *runtime)
+{
 …
+}
+/**
+ * snd_pcm_capture_hw_avail - Get the free space for capture
+ * @runtime: PCM runtime instance
+ */
 static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(struct snd_pcm_runtime *runtime)
+{
 …
  * Checks whether enough free space is available on the playback buffer.
+ *
  * Returns non-zero if available, or zero if not.
+ * Return: Non-zero if available, or zero if not.
  */
 static inline int snd_pcm_playback_ready(struct snd_pcm_substream *substream)
 …
  * Checks whether enough capture data is available on the capture buffer.
+ *
  * Returns non-zero if available, or zero if not.
+ * Return: Non-zero if available, or zero if not.
  */
 static inline int snd_pcm_capture_ready(struct snd_pcm_substream *substream)
 …
  * @substream: the pcm substream instance
+ *
+ * Checks whether any data exists on the playback buffer. If stop_threshold
+ * Checks whether any data exists on the playback buffer.
+ *
+ * Return: Non-zero if any data exists, or zero if not. If stop_threshold
  * is bigger or equal to boundary, then this function returns always non-zero.
+ *
- * Returns non-zero if exists, or zero if not.
  */
 static inline int snd_pcm_playback_data(struct snd_pcm_substream *substream)
 …
  * Checks whether the playback buffer is empty.
+ *
  * Returns non-zero if empty, or zero if not.
+ * Return: Non-zero if empty, or zero if not.
  */
 static inline int snd_pcm_playback_empty(struct snd_pcm_substream *substream)
 …
  * Checks whether the capture buffer is empty.
+ *
  * Returns non-zero if empty, or zero if not.
+ * Return: Non-zero if empty, or zero if not.
  */
 static inline int snd_pcm_capture_empty(struct snd_pcm_substream *substream)
 …
+}
+/**
+ * snd_pcm_trigger_done - Mark the master substream
+ * @substream: the pcm substream instance
+ * @master: the linked master substream
+ *
+ * When multiple substreams of the same card are linked and the hardware
+ * supports the single-shot operation, the driver calls this in the loop
+ * in snd_pcm_group_for_each_entry() for marking the substream as "done".
+ * Then most of trigger operations are performed only to the given master
+ * substream.
+ *
+ * The trigger_master mark is cleared at timestamp updates at the end
+ * of trigger operations.
+ */
 static inline void snd_pcm_trigger_done(struct snd_pcm_substream *substream,
                                         struct snd_pcm_substream *master)
 …
+}
+#define params_access(p) snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_ACCESS))
+#define params_format(p) snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_FORMAT))
+#define params_subformat(p) snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_SUBFORMAT))
+#define params_channels(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_CHANNELS)->min
+#define params_rate(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_RATE)->min
+#define params_period_size(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min
+#define params_period_bytes(p) ((params_period_size(p)*snd_pcm_format_physical_width(params_format(p))*params_channels(p))/8)
+#define params_periods(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_PERIODS)->min
+#define params_buffer_size(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_BUFFER_SIZE)->min
+#define params_buffer_bytes(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->min
+/**
+ * params_channels - Get the number of channels from the hw params
+ * @p: hw params
+ */
+static inline unsigned int params_channels(const struct snd_pcm_hw_params *p)
+{
+        return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_CHANNELS)->min;
+}
+/**
+ * params_rate - Get the sample rate from the hw params
+ * @p: hw params
+ */
+static inline unsigned int params_rate(const struct snd_pcm_hw_params *p)
+{
+        return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_RATE)->min;
+}
+/**
+ * params_period_size - Get the period size (in frames) from the hw params
+ * @p: hw params
+ */
+static inline unsigned int params_period_size(const struct snd_pcm_hw_params *p)
+{
+        return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min;
+}
+/**
+ * params_periods - Get the number of periods from the hw params
+ * @p: hw params
+ */
+static inline unsigned int params_periods(const struct snd_pcm_hw_params *p)
+{
+        return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_PERIODS)->min;
+}
+/**
+ * params_buffer_size - Get the buffer size (in frames) from the hw params
+ * @p: hw params
+ */
+static inline unsigned int params_buffer_size(const struct snd_pcm_hw_params *p)
+{
+        return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_BUFFER_SIZE)->min;
+}
+/**
+ * params_buffer_bytes - Get the buffer size (in bytes) from the hw params
+ * @p: hw params
+ */
+static inline unsigned int params_buffer_bytes(const struct snd_pcm_hw_params *p)
+{
+        return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->min;
+}
 int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v);
+void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c);
+void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c);
+void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b,
+                          unsigned int k, struct snd_interval *c);
+void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
+                          const struct snd_interval *b, struct snd_interval *c);
+int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask);
+int snd_interval_list(struct snd_interval *i, unsigned int count,
+                      const unsigned int *list, unsigned int mask);
+int snd_interval_ranges(struct snd_interval *i, unsigned int count,
+                        const struct snd_interval *list, unsigned int mask);
 int snd_interval_ratnum(struct snd_interval *i,
                         unsigned int rats_count, struct snd_ratnum *rats,
+                        unsigned int rats_count, const struct snd_ratnum *rats,
                         unsigned int *nump, unsigned int *denp);
 void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params);
 void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var);
-int snd_pcm_hw_params_choose(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
 int snd_pcm_hw_refine(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
-int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream);
-int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream);
-int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
-                               u_int32_t mask);
 int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
                                  u_int64_t mask);
 …
                                unsigned int cond,
                                snd_pcm_hw_param_t var,
+                               struct snd_pcm_hw_constraint_list *l);
+                               const struct snd_pcm_hw_constraint_list *l);
+int snd_pcm_hw_constraint_ranges(struct snd_pcm_runtime *runtime,
+                                 unsigned int cond,
+                                 snd_pcm_hw_param_t var,
+                                 const struct snd_pcm_hw_constraint_ranges *r);
 int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime,
                                   unsigned int cond,
                                   snd_pcm_hw_param_t var,
                                   struct snd_pcm_hw_constraint_ratnums *r);
+                                  const struct snd_pcm_hw_constraint_ratnums *r);
 int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime,
                                   unsigned int cond,
                                   snd_pcm_hw_param_t var,
                                   struct snd_pcm_hw_constraint_ratdens *r);
+                                  const struct snd_pcm_hw_constraint_ratdens *r);
 int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime,
                                  unsigned int cond,
 …
                                unsigned int cond,
                                snd_pcm_hw_param_t var);
+int snd_pcm_hw_rule_noresample(struct snd_pcm_runtime *runtime,
+                               unsigned int base_rate);
 int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime,
                         unsigned int cond,
 …
                         int dep, ...);
+/**
+ * snd_pcm_hw_constraint_single() - Constrain parameter to a single value
+ * @runtime: PCM runtime instance
+ * @var: The hw_params variable to constrain
+ * @val: The value to constrain to
+ *
+ * Return: Positive if the value is changed, zero if it's not changed, or a
+ * negative error code.
+ */
+static inline int snd_pcm_hw_constraint_single(
+        struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
+        unsigned int val)
+{
+        return snd_pcm_hw_constraint_minmax(runtime, var, val, val);
+}
 int snd_pcm_format_signed(snd_pcm_format_t format);
 int snd_pcm_format_unsigned(snd_pcm_format_t format);
 …
 int snd_pcm_format_little_endian(snd_pcm_format_t format);
 int snd_pcm_format_big_endian(snd_pcm_format_t format);
 #if 0 /* just for DocBook */
+#if 0 /* just for kernel-doc */
 /**
  * snd_pcm_format_cpu_endian - Check the PCM format is CPU-endian
  * @format: the format to check
+ *
  * Returns 1 if the given PCM format is CPU-endian, 0 if
+ * Return: 1 if the given PCM format is CPU-endian, 0 if
  * opposite, or a negative error code if endian not specified.
  */
 …
 const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format);
 int snd_pcm_format_set_silence(snd_pcm_format_t format, void *buf, unsigned int frames);
+snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_endian);
 void snd_pcm_set_ops(struct snd_pcm * pcm, int direction, struct snd_pcm_ops *ops);
+void snd_pcm_set_ops(struct snd_pcm * pcm, int direction,
+                     const struct snd_pcm_ops *ops);
 void snd_pcm_set_sync(struct snd_pcm_substream *substream);
-int snd_pcm_lib_interleave_len(struct snd_pcm_substream *substream);
 int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
                       unsigned int cmd, void *arg);
-int snd_pcm_update_state(struct snd_pcm_substream *substream,
-                         struct snd_pcm_runtime *runtime);
-int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream);
-int snd_pcm_playback_xrun_check(struct snd_pcm_substream *substream);
-int snd_pcm_capture_xrun_check(struct snd_pcm_substream *substream);
-int snd_pcm_playback_xrun_asap(struct snd_pcm_substream *substream);
-int snd_pcm_capture_xrun_asap(struct snd_pcm_substream *substream);
-void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr);
 void snd_pcm_period_elapsed(struct snd_pcm_substream *substream);
+snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream,
+                                    const void __user *buf,
+                                    snd_pcm_uframes_t frames);
+snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream,
+                                   void __user *buf, snd_pcm_uframes_t frames);
+snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
+                                     void __user **bufs, snd_pcm_uframes_t frames);
+snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
+                                    void __user **bufs, snd_pcm_uframes_t frames);
+extern const struct snd_pcm_hw_constraint_list snd_pcm_known_rates;
+int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime);
+snd_pcm_sframes_t __snd_pcm_lib_xfer(struct snd_pcm_substream *substream,
+                                     void *buf, bool interleaved,
+                                     snd_pcm_uframes_t frames, bool in_kernel);
+static inline snd_pcm_sframes_t
+snd_pcm_lib_write(struct snd_pcm_substream *substream,
+                  const void __user *buf, snd_pcm_uframes_t frames)
+{
+        return __snd_pcm_lib_xfer(substream, (void __force *)buf, true, frames, false);
+}
+static inline snd_pcm_sframes_t
+snd_pcm_lib_read(struct snd_pcm_substream *substream,
+                 void __user *buf, snd_pcm_uframes_t frames)
+{
+        return __snd_pcm_lib_xfer(substream, (void __force *)buf, true, frames, false);
+}
+static inline snd_pcm_sframes_t
+snd_pcm_lib_writev(struct snd_pcm_substream *substream,
+                   void __user **bufs, snd_pcm_uframes_t frames)
+{
+        return __snd_pcm_lib_xfer(substream, (void *)bufs, false, frames, false);
+}
+static inline snd_pcm_sframes_t
+snd_pcm_lib_readv(struct snd_pcm_substream *substream,
+                  void __user **bufs, snd_pcm_uframes_t frames)
+{
+        return __snd_pcm_lib_xfer(substream, (void *)bufs, false, frames, false);
+}
+static inline snd_pcm_sframes_t
+snd_pcm_kernel_write(struct snd_pcm_substream *substream,
+                     const void *buf, snd_pcm_uframes_t frames)
+{
+        return __snd_pcm_lib_xfer(substream, (void *)buf, true, frames, true);
+}
+static inline snd_pcm_sframes_t
+snd_pcm_kernel_read(struct snd_pcm_substream *substream,
+                    void *buf, snd_pcm_uframes_t frames)
+{
+        return __snd_pcm_lib_xfer(substream, buf, true, frames, true);
+}
+static inline snd_pcm_sframes_t
+snd_pcm_kernel_writev(struct snd_pcm_substream *substream,
+                      void **bufs, snd_pcm_uframes_t frames)
+{
+        return __snd_pcm_lib_xfer(substream, bufs, false, frames, true);
+}
+static inline snd_pcm_sframes_t
+snd_pcm_kernel_readv(struct snd_pcm_substream *substream,
+                     void **bufs, snd_pcm_uframes_t frames)
+{
+        return __snd_pcm_lib_xfer(substream, bufs, false, frames, true);
+}
+int snd_pcm_hw_limit_rates(struct snd_pcm_hardware *hw);
+static inline int
+snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime)
+{
+        return snd_pcm_hw_limit_rates(&runtime->hw);
+}
 unsigned int snd_pcm_rate_to_rate_bit(unsigned int rate);
+unsigned int snd_pcm_rate_bit_to_rate(unsigned int rate_bit);
+unsigned int snd_pcm_rate_mask_intersect(unsigned int rates_a,
+                                         unsigned int rates_b);
+unsigned int snd_pcm_rate_range_to_bits(unsigned int rate_min,
+                                        unsigned int rate_max);
+/**
+ * snd_pcm_set_runtime_buffer - Set the PCM runtime buffer
+ * @substream: PCM substream to set
+ * @bufp: the buffer information, NULL to clear
+ *
+ * Copy the buffer information to runtime->dma_buffer when @bufp is non-NULL.
+ * Otherwise it clears the current buffer information.
+ */
 static inline void snd_pcm_set_runtime_buffer(struct snd_pcm_substream *substream,
                                               struct snd_dma_buffer *bufp)
 …
+}
+/*
+ *  Timer interface
+ */
+void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream);
+void snd_pcm_timer_init(struct snd_pcm_substream *substream);
+void snd_pcm_timer_done(struct snd_pcm_substream *substream);
+/**
+ * snd_pcm_gettime - Fill the timespec64 depending on the timestamp mode
+ * @runtime: PCM runtime instance
+ * @tv: timespec64 to fill
+ */
 static inline void snd_pcm_gettime(struct snd_pcm_runtime *runtime,
+                                   struct timespec *tv)
+{
+        if (runtime->tstamp_type == SNDRV_PCM_TSTAMP_TYPE_MONOTONIC)
+                do_posix_clock_monotonic_gettime(tv);
+        else
+                getnstimeofday(tv);
+                                   struct timespec64 *tv)
+{
+        switch (runtime->tstamp_type) {
+        case SNDRV_PCM_TSTAMP_TYPE_MONOTONIC:
+                ktime_get_ts64(tv);
+                break;
+        case SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW:
+                ktime_get_raw_ts64(tv);
+                break;
+        default:
+                ktime_get_real_ts64(tv);
+                break;
+        }
+}
 …
  */
 int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream);
 int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm);
 int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream,
+void snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream);
+void snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm);
+void snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream,
                                   int type, struct device *data,
                                   size_t size, size_t max);
 int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
+void snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
                                           int type, void *data,
                                           size_t size, size_t max);
 int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size);
 int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream);
+void snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type,
+                                struct device *data, size_t size, size_t max);
+void snd_pcm_set_managed_buffer_all(struct snd_pcm *pcm, int type,
+                                    struct device *data,
+                                    size_t size, size_t max);
 int _snd_pcm_lib_alloc_vmalloc_buffer(struct snd_pcm_substream *substream,
 …
 struct page *snd_pcm_lib_get_vmalloc_page(struct snd_pcm_substream *substream,
                                           unsigned long offset);
-#if 0 /* for kernel-doc */
 /**
  * snd_pcm_lib_alloc_vmalloc_buffer - allocate virtual DMA buffer
 …
  * if the buffer is accessed by kernel code but not by device DMA.
+ *
  * Returns 1 if the buffer was changed, 0 if not changed, or a negative error
+ * Return: 1 if the buffer was changed, 0 if not changed, or a negative error
  * code.
  */
+static int snd_pcm_lib_alloc_vmalloc_buffer
+                        (struct snd_pcm_substream *substream, size_t size);
+static inline int snd_pcm_lib_alloc_vmalloc_buffer
+                        (struct snd_pcm_substream *substream, size_t size)
+{
+        return _snd_pcm_lib_alloc_vmalloc_buffer(substream, size,
+                                                 GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO);
+}
 /**
  * snd_pcm_lib_alloc_vmalloc_32_buffer - allocate 32-bit-addressable buffer
 …
  * This function works like snd_pcm_lib_alloc_vmalloc_buffer(), but uses
  * vmalloc_32(), i.e., the pages are allocated from 32-bit-addressable memory.
+ */
+static int snd_pcm_lib_alloc_vmalloc_32_buffer
+                        (struct snd_pcm_substream *substream, size_t size);
+#endif
+#define snd_pcm_lib_alloc_vmalloc_buffer(subs, size) \
+        _snd_pcm_lib_alloc_vmalloc_buffer \
+                        (subs, size, GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO)
+#define snd_pcm_lib_alloc_vmalloc_32_buffer(subs, size) \
+        _snd_pcm_lib_alloc_vmalloc_buffer \
+                        (subs, size, GFP_KERNEL | GFP_DMA32 | __GFP_ZERO)
+ *
+ * Return: 1 if the buffer was changed, 0 if not changed, or a negative error
+ * code.
+ */
+static inline int snd_pcm_lib_alloc_vmalloc_32_buffer
+                        (struct snd_pcm_substream *substream, size_t size)
+{
+        return _snd_pcm_lib_alloc_vmalloc_buffer(substream, size,
+                                                 GFP_KERNEL | GFP_DMA32 | __GFP_ZERO);
+}
+#define snd_pcm_get_dma_buf(substream) ((substream)->runtime->dma_buffer_p)
 #ifdef CONFIG_SND_DMA_SGBUF
 …
  */
 #define snd_pcm_substream_sgbuf(substream) \
+        ((substream)->runtime->dma_buffer_p->private_data)
+        snd_pcm_get_dma_buf(substream)->private_data
+#endif /* SND_DMA_SGBUF */
+/**
+ * snd_pcm_sgbuf_get_addr - Get the DMA address at the corresponding offset
+ * @substream: PCM substream
+ * @ofs: byte offset
+ */
 static inline dma_addr_t
 snd_pcm_sgbuf_get_addr(struct snd_pcm_substream *substream, unsigned int ofs)
+{
+        struct snd_sg_buf *sg = snd_pcm_substream_sgbuf(substream);
+        return snd_sgbuf_get_addr(sg, ofs);
+}
+        return snd_sgbuf_get_addr(snd_pcm_get_dma_buf(substream), ofs);
+}
+/**
+ * snd_pcm_sgbuf_get_ptr - Get the virtual address at the corresponding offset
+ * @substream: PCM substream
+ * @ofs: byte offset
+ */
 static inline void *
 snd_pcm_sgbuf_get_ptr(struct snd_pcm_substream *substream, unsigned int ofs)
+{
+        struct snd_sg_buf *sg = snd_pcm_substream_sgbuf(substream);
+        return snd_sgbuf_get_ptr(sg, ofs);
+}
+struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream,
+                                    unsigned long offset);
+unsigned int snd_pcm_sgbuf_get_chunk_size(struct snd_pcm_substream *substream,
+                                          unsigned int ofs, unsigned int size);
+#else /* !SND_DMA_SGBUF */
+/*
+ * fake using a continuous buffer
+ */
+static inline dma_addr_t
+snd_pcm_sgbuf_get_addr(struct snd_pcm_substream *substream, unsigned int ofs)
+{
+        return substream->runtime->dma_addr + ofs;
+}
+static inline void *
+snd_pcm_sgbuf_get_ptr(struct snd_pcm_substream *substream, unsigned int ofs)
+{
+        return substream->runtime->dma_area + ofs;
+}
+#define snd_pcm_sgbuf_ops_page  NULL
+#define snd_pcm_sgbuf_get_chunk_size(subs, ofs, size)   (size)
+#endif /* SND_DMA_SGBUF */
+/* handle mmap counter - PCM mmap callback should handle this counter properly */
+        return snd_sgbuf_get_ptr(snd_pcm_get_dma_buf(substream), ofs);
+}
+/**
+ * snd_pcm_sgbuf_get_chunk_size - Compute the max size that fits within the
+ * contig. page from the given size
+ * @substream: PCM substream
+ * @ofs: byte offset
+ * @size: byte size to examine
+ */
+static inline unsigned int
+snd_pcm_sgbuf_get_chunk_size(struct snd_pcm_substream *substream,
+                             unsigned int ofs, unsigned int size)
+{
+        return snd_sgbuf_get_chunk_size(snd_pcm_get_dma_buf(substream), ofs, size);
+}
+/**
+ * snd_pcm_mmap_data_open - increase the mmap counter
+ * @area: VMA
+ *
+ * PCM mmap callback should handle this counter properly
+ */
 static inline void snd_pcm_mmap_data_open(struct vm_area_struct *area)
+{
 …
+}
+/**
+ * snd_pcm_mmap_data_close - decrease the mmap counter
+ * @area: VMA
+ *
+ * PCM mmap callback should handle this counter properly
+ */
 static inline void snd_pcm_mmap_data_close(struct vm_area_struct *area)
+{
 …
+}
+int snd_pcm_lib_default_mmap(struct snd_pcm_substream *substream,
+                             struct vm_area_struct *area);
 /* mmap for io-memory area */
 #if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA)
 …
 #endif
+int snd_pcm_lib_mmap_noncached(struct snd_pcm_substream *substream,
+                               struct vm_area_struct *area);
+#define snd_pcm_lib_mmap_vmalloc        snd_pcm_lib_mmap_noncached
+/**
+ * snd_pcm_limit_isa_dma_size - Get the max size fitting with ISA DMA transfer
+ * @dma: DMA number
+ * @max: pointer to store the max size
+ */
 static inline void snd_pcm_limit_isa_dma_size(int dma, size_t *max)
+{
 …
                                          (IEC958_AES3_CON_FS_48000<<24))
-#define PCM_RUNTIME_CHECK(sub) snd_BUG_ON(!(sub) || !(sub)->runtime)
 const char *snd_pcm_format_name(snd_pcm_format_t format);
+/**
+ * snd_pcm_stream_str - Get a string naming the direction of a stream
+ * @substream: the pcm substream instance
+ *
+ * Return: A string naming the direction of the stream.
+ */
+static inline const char *snd_pcm_stream_str(struct snd_pcm_substream *substream)
+{
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                return "Playback";
+        else
+                return "Capture";
+}
+/*
+ * PCM channel-mapping control API
+ */
+/* array element of channel maps */
+struct snd_pcm_chmap_elem {
+        unsigned char channels;
+        unsigned char map[15];
+};
+/* channel map information; retrieved via snd_kcontrol_chip() */
+struct snd_pcm_chmap {
+        struct snd_pcm *pcm;    /* assigned PCM instance */
+        int stream;             /* PLAYBACK or CAPTURE */
+        struct snd_kcontrol *kctl;
+        const struct snd_pcm_chmap_elem *chmap;
+        unsigned int max_channels;
+        unsigned int channel_mask;      /* optional: active channels bitmask */
+        void *private_data;     /* optional: private data pointer */
+};
+/**
+ * snd_pcm_chmap_substream - get the PCM substream assigned to the given chmap info
+ * @info: chmap information
+ * @idx: the substream number index
+ */
+static inline struct snd_pcm_substream *
+snd_pcm_chmap_substream(struct snd_pcm_chmap *info, unsigned int idx)
+{
+        struct snd_pcm_substream *s;
+        for (s = info->pcm->streams[info->stream].substream; s; s = s->next)
+                if (s->number == idx)
+                        return s;
+        return NULL;
+}
+/* ALSA-standard channel maps (RL/RR prior to C/LFE) */
+extern const struct snd_pcm_chmap_elem snd_pcm_std_chmaps[];
+/* Other world's standard channel maps (C/LFE prior to RL/RR) */
+extern const struct snd_pcm_chmap_elem snd_pcm_alt_chmaps[];
+/* bit masks to be passed to snd_pcm_chmap.channel_mask field */
+#define SND_PCM_CHMAP_MASK_24   ((1U << 2) | (1U << 4))
+#define SND_PCM_CHMAP_MASK_246  (SND_PCM_CHMAP_MASK_24 | (1U << 6))
+#define SND_PCM_CHMAP_MASK_2468 (SND_PCM_CHMAP_MASK_246 | (1U << 8))
+int snd_pcm_add_chmap_ctls(struct snd_pcm *pcm, int stream,
+                           const struct snd_pcm_chmap_elem *chmap,
+                           int max_channels,
+                           unsigned long private_value,
+                           struct snd_pcm_chmap **info_ret);
+/**
+ * pcm_format_to_bits - Strong-typed conversion of pcm_format to bitwise
+ * @pcm_format: PCM format
+ */
+static inline u64 pcm_format_to_bits(snd_pcm_format_t pcm_format)
+{
+        return 1ULL << (__force int) pcm_format;
+}
+/**
+ * pcm_for_each_format - helper to iterate for each format type
+ * @f: the iterator variable in snd_pcm_format_t type
+ */
+#define pcm_for_each_format(f)                                          \
+        for ((f) = SNDRV_PCM_FORMAT_FIRST;                              \
+             (__force int)(f) <= (__force int)SNDRV_PCM_FORMAT_LAST;    \
+             (f) = (__force snd_pcm_format_t)((__force int)(f) + 1))
+/* printk helpers */
+#ifndef TARGET_OS2
+#define pcm_err(pcm, fmt, args...) \
+        dev_err((pcm)->card->dev, fmt, ##args)
+#define pcm_warn(pcm, fmt, args...) \
+        dev_warn((pcm)->card->dev, fmt, ##args)
+#define pcm_dbg(pcm, fmt, args...) \
+        dev_dbg((pcm)->card->dev, fmt, ##args)
+#else
+#define pcm_err pcm_dbg
+#define pcm_warn pcm_dbg
+int pcm_dbg(struct snd_pcm *dev, const char *fmt, ...);
+#endif
+struct snd_pcm_status64 {
+        snd_pcm_state_t state;          /* stream state */
+        u8 rsvd[4];
+        s64 trigger_tstamp_sec;         /* time when stream was started/stopped/paused */
+        s64 trigger_tstamp_nsec;
+        s64 tstamp_sec;                 /* reference timestamp */
+        s64 tstamp_nsec;
+        snd_pcm_uframes_t appl_ptr;     /* appl ptr */
+        snd_pcm_uframes_t hw_ptr;       /* hw ptr */
+        snd_pcm_sframes_t delay;        /* current delay in frames */
+        snd_pcm_uframes_t avail;        /* number of frames available */
+        snd_pcm_uframes_t avail_max;    /* max frames available on hw since last status */
+        snd_pcm_uframes_t overrange;    /* count of ADC (capture) overrange detections from last status */
+        snd_pcm_state_t suspended_state; /* suspended stream state */
+        __u32 audio_tstamp_data;         /* needed for 64-bit alignment, used for configs/report to/from userspace */
+        s64 audio_tstamp_sec;           /* sample counter, wall clock, PHC or on-demand sync'ed */
+        s64 audio_tstamp_nsec;
+        s64 driver_tstamp_sec;          /* useful in case reference system tstamp is reported with delay */
+        s64 driver_tstamp_nsec;
+        __u32 audio_tstamp_accuracy;    /* in ns units, only valid if indicated in audio_tstamp_data */
+        unsigned char reserved[52-4*sizeof(s64)]; /* must be filled with zero */
+};
+#define SNDRV_PCM_IOCTL_STATUS64        _IOR('A', 0x20, struct snd_pcm_status64)
+#define SNDRV_PCM_IOCTL_STATUS_EXT64    _IOWR('A', 0x24, struct snd_pcm_status64)
+struct snd_pcm_status32 {
+        snd_pcm_state_t state;          /* stream state */
+        s32 trigger_tstamp_sec; /* time when stream was started/stopped/paused */
+        s32 trigger_tstamp_nsec;
+        s32 tstamp_sec;         /* reference timestamp */
+        s32 tstamp_nsec;
+        u32 appl_ptr;           /* appl ptr */
+        u32 hw_ptr;             /* hw ptr */
+        s32 delay;              /* current delay in frames */
+        u32 avail;              /* number of frames available */
+        u32 avail_max;          /* max frames available on hw since last status */
+        u32 overrange;          /* count of ADC (capture) overrange detections from last status */
+        snd_pcm_state_t suspended_state;        /* suspended stream state */
+        u32 audio_tstamp_data;  /* needed for 64-bit alignment, used for configs/report to/from userspace */
+        s32 audio_tstamp_sec;   /* sample counter, wall clock, PHC or on-demand sync'ed */
+        s32 audio_tstamp_nsec;
+        s32 driver_tstamp_sec;  /* useful in case reference system tstamp is reported with delay */
+        s32 driver_tstamp_nsec;
+        u32 audio_tstamp_accuracy;      /* in ns units, only valid if indicated in audio_tstamp_data */
+        unsigned char reserved[52-4*sizeof(s32)]; /* must be filled with zero */
+};
+#define SNDRV_PCM_IOCTL_STATUS32        _IOR('A', 0x20, struct snd_pcm_status32)
+#define SNDRV_PCM_IOCTL_STATUS_EXT32    _IOWR('A', 0x24, struct snd_pcm_status32)
 #endif /* __SOUND_PCM_H */

GPL/trunk/alsa-kernel/include/sound/pcm_oss.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_PCM_OSS_H
 #define __SOUND_PCM_OSS_H
 …
  *  Digital Audio (PCM) - OSS compatibility abstract layer
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 …
         size_t buffer_used;                     /* used length from period buffer */
         struct mutex params_lock;
+        atomic_t rw_ref;                /* concurrent read/write accesses */
 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
         struct snd_pcm_plugin *plugin_first;

GPL/trunk/alsa-kernel/include/sound/pcm_params.h

-              r398
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_PCM_PARAMS_H
 #define __SOUND_PCM_PARAMS_H
 …
  *  PCM params helpers
  *  Copyright (c) by Abramo Bagnara <abramo@alsa-project.org>
+ *
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ */
+ */
+#include <sound/pcm.h>
 int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm,
 …
 #define MASK_BIT(i)     (1U << ((i) & 31))
-static inline unsigned int ld2(u_int32_t v)
+{
-        unsigned r = 0;
-        if (v >= 0x10000) {
-                v >>= 16;
-                r += 16;
+        }
-        if (v >= 0x100) {
-                v >>= 8;
-                r += 8;
+        }
-        if (v >= 0x10) {
-                v >>= 4;
-                r += 4;
+        }
-        if (v >= 4) {
-                v >>= 2;
-                r += 2;
+        }
-        if (v >= 2)
-                r++;
-        return r;
+}
-static inline size_t snd_mask_sizeof(void)
+{
-        return sizeof(struct snd_mask);
+}
 static inline void snd_mask_none(struct snd_mask *mask)
+{
 …
         for (i = 0; i < SNDRV_MASK_SIZE; i++) {
                 if (mask->bits[i])
                         return ffs(mask->bits[i]) - 1 + (i << 5);
+                        return __ffs(mask->bits[i]) + (i << 5);
+        }
         return 0;
 …
         for (i = SNDRV_MASK_SIZE - 1; i >= 0; i--) {
                 if (mask->bits[i])
                         return ld2(mask->bits[i]) + (i << 5);
+                        return __fls(mask->bits[i]) + (i << 5);
+        }
         return 0;
 …
+{
         mask->bits[MASK_OFS(val)] |= MASK_BIT(val);
+}
+/* Most of drivers need only this one */
+static inline void snd_mask_set_format(struct snd_mask *mask,
+                                       snd_pcm_format_t format)
+{
+        snd_mask_set(mask, (__force unsigned int)format);
+}
 …
+{
         return mask->bits[MASK_OFS(val)] & MASK_BIT(val);
+}
+/* Most of drivers need only this one */
+static inline int snd_mask_test_format(const struct snd_mask *mask,
+                                       snd_pcm_format_t format)
+{
+        return snd_mask_test(mask, (__force unsigned int)format);
+}
 …
+{
         return (i->min == i->max ||
                 (i->min + 1 == i->max && i->openmax));
+                (i->min + 1 == i->max && (i->openmin || i->openmax)));
+}
 static inline int snd_interval_value(const struct snd_interval *i)
+{
+        if (i->openmin && !i->openmax)
+                return i->max;
         return i->min;
+}
 …
+}
+static inline unsigned int add(unsigned int a, unsigned int b)
+{
+        if (a >= UINT_MAX - b)
+                return UINT_MAX;
+        return a + b;
+}
+static inline unsigned int sub(unsigned int a, unsigned int b)
+{
+        if (a > b)
+                return a - b;
+        return 0;
+/**
+ * params_access - get the access type from the hw params
+ * @p: hw params
+ */
+static inline snd_pcm_access_t params_access(const struct snd_pcm_hw_params *p)
+{
+        return (__force snd_pcm_access_t)snd_mask_min(hw_param_mask_c(p,
+                SNDRV_PCM_HW_PARAM_ACCESS));
+}
+/**
+ * params_format - get the sample format from the hw params
+ * @p: hw params
+ */
+static inline snd_pcm_format_t params_format(const struct snd_pcm_hw_params *p)
+{
+        return (__force snd_pcm_format_t)snd_mask_min(hw_param_mask_c(p,
+                SNDRV_PCM_HW_PARAM_FORMAT));
+}
+/**
+ * params_subformat - get the sample subformat from the hw params
+ * @p: hw params
+ */
+static inline snd_pcm_subformat_t
+params_subformat(const struct snd_pcm_hw_params *p)
+{
+        return (__force snd_pcm_subformat_t)snd_mask_min(hw_param_mask_c(p,
+                SNDRV_PCM_HW_PARAM_SUBFORMAT));
+}
+/**
+ * params_period_bytes - get the period size (in bytes) from the hw params
+ * @p: hw params
+ */
+static inline unsigned int
+params_period_bytes(const struct snd_pcm_hw_params *p)
+{
+        return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->min;
+}
+/**
+ * params_width - get the number of bits of the sample format from the hw params
+ * @p: hw params
+ *
+ * This function returns the number of bits per sample that the selected sample
+ * format of the hw params has.
+ */
+static inline int params_width(const struct snd_pcm_hw_params *p)
+{
+        return snd_pcm_format_width(params_format(p));
+}
+/*
+ * params_physical_width - get the storage size of the sample format from the hw params
+ * @p: hw params
+ *
+ * This functions returns the number of bits per sample that the selected sample
+ * format of the hw params takes up in memory. This will be equal or larger than
+ * params_width().
+ */
+static inline int params_physical_width(const struct snd_pcm_hw_params *p)
+{
+        return snd_pcm_format_physical_width(params_format(p));
+}
+static inline void
+params_set_format(struct snd_pcm_hw_params *p, snd_pcm_format_t fmt)
+{
+        snd_mask_set_format(hw_param_mask(p, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
+}
 #endif /* __SOUND_PCM_PARAMS_H */

GPL/trunk/alsa-kernel/include/sound/pt2258.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 /*
  *   ALSA Driver for the PT2258 volume controller.
+ *
  *      Copyright (c) 2006  Jochen Voss <voss@seehuhn.de>
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */

GPL/trunk/alsa-kernel/include/sound/rawmidi.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_RAWMIDI_H
 #define __SOUND_RAWMIDI_H
 …
  *  Abstract layer for MIDI v1.0 stream
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 …
 #include <linux/wait.h>
 #include <linux/mutex.h>
+#include <linux/workqueue.h>
+#include <linux/device.h>
 #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
 #include "seq_device.h"
+#if IS_ENABLED(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER)
+#include <sound/seq_device.h>
 #endif
 …
 struct snd_rawmidi_runtime {
+        struct snd_rawmidi_substream *substream;
         unsigned int drain: 1,  /* drain stage */
                      oss: 1;    /* OSS compatible mode */
 …
         size_t avail;           /* max used buffer for wakeup */
         size_t xruns;           /* over/underruns counter */
+        int buffer_ref;         /* buffer reference count */
         /* misc */
         spinlock_t lock;
 …
         void (*event)(struct snd_rawmidi_substream *substream);
         /* defers calls to event [input] or ops->trigger [output] */
         struct tasklet_struct tasklet;
+        struct work_struct event_work;
         /* private data */
         void *private_data;
 …
         int stream;                     /* direction */
         int number;                     /* substream number */
         unsigned int opened: 1,         /* open flag */
                      append: 1,         /* append flag (merge more streams) */
                      active_sensing: 1; /* send active sensing when close */
+        bool opened;                    /* open flag */
+        bool append;                    /* append flag (merge more streams) */
+        bool active_sensing;            /* send active sensing when close */
         int use_count;                  /* use counter (for output) */
         size_t bytes;
 …
         struct pid *pid;
         /* hardware layer */
         struct snd_rawmidi_ops *ops;
+        const struct snd_rawmidi_ops *ops;
 };
 …
 #endif
         struct snd_rawmidi_global_ops *ops;
+        const struct snd_rawmidi_global_ops *ops;
         struct snd_rawmidi_str streams[2];
 …
         wait_queue_head_t open_wait;
+        struct snd_info_entry *dev;
+        struct device dev;
         struct snd_info_entry *proc_entry;
 #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
+#if IS_ENABLED(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER)
         struct snd_seq_device *seq_dev;
 #endif
 …
                     struct snd_rawmidi **rmidi);
 void snd_rawmidi_set_ops(struct snd_rawmidi *rmidi, int stream,
                          struct snd_rawmidi_ops *ops);
+                         const struct snd_rawmidi_ops *ops);
 /* callbacks */
-void snd_rawmidi_receive_reset(struct snd_rawmidi_substream *substream);
 int snd_rawmidi_receive(struct snd_rawmidi_substream *substream,
                         const unsigned char *buffer, int count);
-void snd_rawmidi_transmit_reset(struct snd_rawmidi_substream *substream);
 int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream);
 int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream,
 …
 int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream,
                          unsigned char *buffer, int count);
+int __snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream,
+                              unsigned char *buffer, int count);
+int __snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream,
+                               int count);
+int snd_rawmidi_proceed(struct snd_rawmidi_substream *substream);
 /* main midi functions */

GPL/trunk/alsa-kernel/include/sound/sb.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_SB_H
 #define __SOUND_SB_H
 …
  *  Header file for SoundBlaster cards
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 #include "pcm.h"
 #include "rawmidi.h"
+#include <sound/pcm.h>
+#include <sound/rawmidi.h>
 #include <linux/interrupt.h>
 #include <asm/io.h>
+#include <linux/io.h>
 enum sb_hw_type {
 …
 /* sb8_init.c */
 int snd_sb8dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm);
+int snd_sb8dsp_pcm(struct snd_sb *chip, int device);
 /* sb8.c */
 irqreturn_t snd_sb8dsp_interrupt(struct snd_sb *chip);
 …
 /* midi8.c */
 irqreturn_t snd_sb8dsp_midi_interrupt(struct snd_sb *chip);
 int snd_sb8dsp_midi(struct snd_sb *chip, int device, struct snd_rawmidi ** rrawmidi);
+int snd_sb8dsp_midi(struct snd_sb *chip, int device);
 /* sb16_init.c */
 int snd_sb16dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm);
+int snd_sb16dsp_pcm(struct snd_sb *chip, int device);
 const struct snd_pcm_ops *snd_sb16dsp_get_pcm_ops(int direction);
 int snd_sb16dsp_configure(struct snd_sb *chip);

GPL/trunk/alsa-kernel/include/sound/sb16_csp.h

-              r398
+              r679
+#ifndef __SOUND_SB16_CSP_H
+#define __SOUND_SB16_CSP_H
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 /*
  *  Copyright (c) 1999 by Uros Bizjak <uros@kss-loka.si>
 …
+ *
  *  SB16ASP/AWE32 CSP control
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
+#ifndef __SOUND_SB16_CSP_H
+#define __SOUND_SB16_CSP_H
+/* CSP modes */
+#define SNDRV_SB_CSP_MODE_NONE          0x00
+#define SNDRV_SB_CSP_MODE_DSP_READ      0x01    /* Record from DSP */
+#define SNDRV_SB_CSP_MODE_DSP_WRITE     0x02    /* Play to DSP */
+#define SNDRV_SB_CSP_MODE_QSOUND                0x04    /* QSound */
+/* CSP load flags */
+#define SNDRV_SB_CSP_LOAD_FROMUSER      0x01
+#define SNDRV_SB_CSP_LOAD_INITBLOCK     0x02
+/* CSP sample width */
+#define SNDRV_SB_CSP_SAMPLE_8BIT                0x01
+#define SNDRV_SB_CSP_SAMPLE_16BIT               0x02
+/* CSP channels */
+#define SNDRV_SB_CSP_MONO                       0x01
+#define SNDRV_SB_CSP_STEREO             0x02
+/* CSP rates */
+#define SNDRV_SB_CSP_RATE_8000          0x01
+#define SNDRV_SB_CSP_RATE_11025         0x02
+#define SNDRV_SB_CSP_RATE_22050         0x04
+#define SNDRV_SB_CSP_RATE_44100         0x08
+#define SNDRV_SB_CSP_RATE_ALL           0x0f
+/* CSP running state */
+#define SNDRV_SB_CSP_ST_IDLE            0x00
+#define SNDRV_SB_CSP_ST_LOADED          0x01
+#define SNDRV_SB_CSP_ST_RUNNING         0x02
+#define SNDRV_SB_CSP_ST_PAUSED          0x04
+#define SNDRV_SB_CSP_ST_AUTO            0x08
+#define SNDRV_SB_CSP_ST_QSOUND          0x10
+/* maximum QSound value (180 degrees right) */
+#define SNDRV_SB_CSP_QSOUND_MAX_RIGHT   0x20
+/* maximum microcode RIFF file size */
+#define SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE    0x3000
+/* microcode header */
+struct snd_sb_csp_mc_header {
+        char codec_name[16];            /* id name of codec */
+        unsigned short func_req;        /* requested function */
+};
+/* microcode to be loaded */
+struct snd_sb_csp_microcode {
+        struct snd_sb_csp_mc_header info;
+        unsigned char data[SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE];
+};
+/* start CSP with sample_width in mono/stereo */
+struct snd_sb_csp_start {
+        int sample_width;       /* sample width, look above */
+        int channels;           /* channels, look above */
+};
+/* CSP information */
+struct snd_sb_csp_info {
+        char codec_name[16];            /* id name of codec */
+        unsigned short func_nr;         /* function number */
+        unsigned int acc_format;        /* accepted PCM formats */
+        unsigned short acc_channels;    /* accepted channels */
+        unsigned short acc_width;       /* accepted sample width */
+        unsigned short acc_rates;       /* accepted sample rates */
+        unsigned short csp_mode;        /* CSP mode, see above */
+        unsigned short run_channels;    /* current channels  */
+        unsigned short run_width;       /* current sample width */
+        unsigned short version;         /* version id: 0x10 - 0x1f */
+        unsigned short state;           /* state bits */
+};
+/* HWDEP controls */
+/* get CSP information */
+#define SNDRV_SB_CSP_IOCTL_INFO         _IOR('H', 0x10, struct snd_sb_csp_info)
+/* load microcode to CSP */
+#define SNDRV_SB_CSP_IOCTL_LOAD_CODE    _IOW('H', 0x11, struct snd_sb_csp_microcode)
+/* unload microcode from CSP */
+#define SNDRV_SB_CSP_IOCTL_UNLOAD_CODE  _IO('H', 0x12)
+/* start CSP */
+#define SNDRV_SB_CSP_IOCTL_START                _IOW('H', 0x13, struct snd_sb_csp_start)
+/* stop CSP */
+#define SNDRV_SB_CSP_IOCTL_STOP         _IO('H', 0x14)
+/* pause CSP and DMA transfer */
+#define SNDRV_SB_CSP_IOCTL_PAUSE                _IO('H', 0x15)
+/* restart CSP and DMA transfer */
+#define SNDRV_SB_CSP_IOCTL_RESTART      _IO('H', 0x16)
+#ifdef __KERNEL__
+#include "sb.h"
+#include "hwdep.h"
+#include <sound/sb.h>
+#include <sound/hwdep.h>
 #include <linux/firmware.h>
+#include <uapi/sound/sb16_csp.h>
 struct snd_sb_csp;
 …
         int (*csp_use) (struct snd_sb_csp * p);
         int (*csp_unuse) (struct snd_sb_csp * p);
         int (*csp_autoload) (struct snd_sb_csp * p, int pcm_sfmt, int play_rec_mode);
+        int (*csp_autoload) (struct snd_sb_csp * p, snd_pcm_format_t pcm_sfmt, int play_rec_mode);
         int (*csp_start) (struct snd_sb_csp * p, int sample_width, int channels);
         int (*csp_stop) (struct snd_sb_csp * p);
 …
 int snd_sb_csp_new(struct snd_sb *chip, int device, struct snd_hwdep ** rhwdep);
-#endif
 #endif /* __SOUND_SB16_CSP */

GPL/trunk/alsa-kernel/include/sound/seq_device.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_SEQ_DEVICE_H
 #define __SOUND_SEQ_DEVICE_H
 …
  *  ALSA sequencer device management
  *  Copyright (c) 1999 by Takashi Iwai <tiwai@suse.de>
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 …
  */
-#define ID_LEN  32
-/* status flag */
-#define SNDRV_SEQ_DEVICE_FREE           0
-#define SNDRV_SEQ_DEVICE_REGISTERED     1
 struct snd_seq_device {
         /* device info */
         struct snd_card *card;  /* sound card */
         int device;             /* device number */
         char id[ID_LEN];        /* driver id */
+        const char *id;         /* driver id */
         char name[80];          /* device name */
         int argsize;            /* size of the argument */
         void *driver_data;      /* private data for driver */
-        int status;             /* flag - read only */
         void *private_data;     /* private data for the caller */
         void (*private_free)(struct snd_seq_device *device);
         struct list_head list;  /* link to next device */
+        struct device dev;
 };
+#define to_seq_dev(_dev) \
+        container_of(_dev, struct snd_seq_device, dev)
+/* sequencer driver */
 /* driver operators
  * init_device:
+ * probe:
  *      Initialize the device with given parameters.
  *      Typically,
 …
  *              4. store the instance to dev->driver_data pointer.
+ *
  * free_device:
+ * remove:
  *      Release the private data.
  *      Typically, call snd_device_free(dev->card, dev->driver_data)
  */
+struct snd_seq_dev_ops {
+        int (*init_device)(struct snd_seq_device *dev);
+        int (*free_device)(struct snd_seq_device *dev);
+struct snd_seq_driver {
+        struct device_driver driver;
+        char *id;
+        int argsize;
 };
+#define to_seq_drv(_drv) \
+        container_of(_drv, struct snd_seq_driver, driver)
 /*
  * prototypes
  */
+#ifdef CONFIG_MODULES
 void snd_seq_device_load_drivers(void);
+int snd_seq_device_new(struct snd_card *card, int device, char *id, int argsize, struct snd_seq_device **result);
+int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry, int argsize);
+int snd_seq_device_unregister_driver(char *id);
+#else
+#define snd_seq_device_load_drivers()
+#endif
+int snd_seq_device_new(struct snd_card *card, int device, const char *id,
+                       int argsize, struct snd_seq_device **result);
 #define SNDRV_SEQ_DEVICE_ARGPTR(dev) (void *)((char *)(dev) + sizeof(struct snd_seq_device))
+int __must_check __snd_seq_driver_register(struct snd_seq_driver *drv,
+                                           struct module *mod);
+#define snd_seq_driver_register(drv) \
+        __snd_seq_driver_register(drv, THIS_MODULE)
+void snd_seq_driver_unregister(struct snd_seq_driver *drv);
+#define module_snd_seq_driver(drv) \
+        module_driver(drv, snd_seq_driver_register, snd_seq_driver_unregister)
 /*

GPL/trunk/alsa-kernel/include/sound/seq_kernel.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_SEQ_KERNEL_H
 #define __SOUND_SEQ_KERNEL_H
 …
  *  Main kernel header file for the ALSA sequencer
  *  Copyright (c) 1998 by Frank van de Pol <fvdpol@coil.demon.nl>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 #include <linux/time.h>
 #include "asequencer.h"
+#include <sound/asequencer.h>
 typedef struct snd_seq_real_time snd_seq_real_time_t;
 typedef union snd_seq_timestamp snd_seq_timestamp_t;
-/* maximum number of events dequeued per schedule interval */
-#define SNDRV_SEQ_MAX_DEQUEUE           50
 /* maximum number of queues */
 #define SNDRV_SEQ_MAX_QUEUES            8
+#define SNDRV_SEQ_MAX_QUEUES            32
 /* max number of concurrent clients */
 …
 /* max number of events in memory pool */
 #define SNDRV_SEQ_MAX_EVENTS            2000
-/* default number of events in memory chunk */
-#define SNDRV_SEQ_DEFAULT_CHUNK_EVENTS  64
 /* default number of events in memory pool */
 …
 /* max delivery path length */
+#define SNDRV_SEQ_MAX_HOPS              10
+/* NOTE: this shouldn't be greater than MAX_LOCKDEP_SUBCLASSES */
+#define SNDRV_SEQ_MAX_HOPS              8
 /* max size of event size */
 …
         int (*event_input)(struct snd_seq_event *ev, int direct, void *private_data, int atomic, int hop);
         void (*private_free)(void *private_data);
-        unsigned int callback_all;      /* call subscribe callbacks at each connection/disconnection */
         /*...*/
 };
 …
 /* interface for kernel client */
 #ifndef TARGET_OS2
+int snd_seq_create_kernel_client(struct snd_card *card, int client_index,
+                                 const char *name_fmt, ...)
+        __attribute__ ((format (printf, 3, 4)));
+#else
+__printf(3, 4)
+#endif
 int snd_seq_create_kernel_client(struct snd_card *card, int client_index,
                                  const char *name_fmt, ...);
-#endif
 int snd_seq_delete_kernel_client(int client);
+int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event *ev, int atomic, int hop);
+int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event *ev,
+                                  struct file *file, bool blocking);
 int snd_seq_kernel_client_dispatch(int client, struct snd_seq_event *ev, int atomic, int hop);
 int snd_seq_kernel_client_ctl(int client, unsigned int cmd, void *arg);
 …
 #ifdef CONFIG_MODULES
 void snd_seq_autoload_lock(void);
 void snd_seq_autoload_unlock(void);
+void snd_seq_autoload_init(void);
+void snd_seq_autoload_exit(void);
 #else
 #define snd_seq_autoload_lock()
 #define snd_seq_autoload_unlock()
+#define snd_seq_autoload_init()
+#define snd_seq_autoload_exit()
 #endif

GPL/trunk/alsa-kernel/include/sound/seq_midi_emul.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_SEQ_MIDI_EMUL_H
 #define __SOUND_SEQ_MIDI_EMUL_H
 …
+ *
  *  Copyright (C) 1999 Steve Ratcliffe
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 #include "seq_kernel.h"
+#include <sound/seq_kernel.h>
 /*
 …
 /* Prototypes for midi_process.c */
+void snd_midi_process_event(struct snd_midi_op *ops, struct snd_seq_event *ev,
+void snd_midi_process_event(const struct snd_midi_op *ops,
+                            struct snd_seq_event *ev,
                             struct snd_midi_channel_set *chanset);
 void snd_midi_channel_set_clear(struct snd_midi_channel_set *chset);

GPL/trunk/alsa-kernel/include/sound/seq_midi_event.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_SEQ_MIDI_EVENT_H
 #define __SOUND_SEQ_MIDI_EVENT_H
 …
  *  Copyright (C) 1998,99 Takashi Iwai <tiwai@suse.de>,
  *                        Jaroslav Kysela <perex@perex.cz>
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 #include "asequencer.h"
+#include <sound/asequencer.h>
 #define MAX_MIDI_EVENT_BUF      256
 …
 void snd_midi_event_reset_decode(struct snd_midi_event *dev);
 void snd_midi_event_no_status(struct snd_midi_event *dev, int on);
+/* encode from byte stream - return number of written bytes if success */
+long snd_midi_event_encode(struct snd_midi_event *dev, unsigned char *buf, long count,
+                           struct snd_seq_event *ev);
+int snd_midi_event_encode_byte(struct snd_midi_event *dev, int c, struct snd_seq_event *ev);
+bool snd_midi_event_encode_byte(struct snd_midi_event *dev, unsigned char c,
+                                struct snd_seq_event *ev);
 /* decode from event to bytes - return number of written bytes if success */
 long snd_midi_event_decode(struct snd_midi_event *dev, unsigned char *buf, long count,

GPL/trunk/alsa-kernel/include/sound/seq_oss.h

-              r398
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_SEQ_OSS_H
 #define __SOUND_SEQ_OSS_H
 …
+ *
  * Copyright (C) 1998,99 Takashi Iwai
+ *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
+ *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 #include "asequencer.h"
 #include "seq_kernel.h"
+#include <sound/asequencer.h>
+#include <sound/seq_kernel.h>
 /*

GPL/trunk/alsa-kernel/include/sound/seq_oss_legacy.h

-              r398
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_SEQ_OSS_LEGACY_H
 #define __SOUND_SEQ_OSS_LEGACY_H
 …
+ *
  * Copyright (C) 2000 Abramo Bagnara <abramo@alsa-project.org>
+ *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
+ *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */

GPL/trunk/alsa-kernel/include/sound/seq_virmidi.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_SEQ_VIRMIDI_H
 #define __SOUND_SEQ_VIRMIDI_H
 …
  *  Copyright (c) 2000 by Takashi Iwai <tiwai@suse.de>,
  *                        Jaroslav Kysela <perex@perex.cz>
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 #include "rawmidi.h"
 #include "seq_midi_event.h"
+#include <sound/rawmidi.h>
+#include <sound/seq_midi_event.h>
 /*
 …
         int client;
         int port;
         unsigned int trigger: 1;
+        bool trigger;
         struct snd_midi_event *parser;
         struct snd_seq_event event;
         struct snd_virmidi_dev *rdev;
         struct snd_rawmidi_substream *substream;
+        struct work_struct output_work;
 };
 …
         unsigned int flags;             /* SNDRV_VIRMIDI_* */
         rwlock_t filelist_lock;
+        struct rw_semaphore filelist_sem;
         struct list_head filelist;
 };

GPL/trunk/alsa-kernel/include/sound/snd_wavefront.h

-              r399
+              r679
+/* SPDX-License-Identifier: GPL-2.0 */
 #ifndef __SOUND_SND_WAVEFRONT_H__
 #define __SOUND_SND_WAVEFRONT_H__
 #include "mpu401.h"
 #include "hwdep.h"
 #include "rawmidi.h"
 #include "wavefront.h"  /* generic OSS/ALSA/user-level wavefront header */
+#include <sound/mpu401.h>
+#include <sound/hwdep.h>
+#include <sound/rawmidi.h>
+#include <sound/wavefront.h>  /* generic OSS/ALSA/user-level wavefront header */
 /* MIDI interface */
 …
         struct snd_rawmidi_substream     *substream_input[2];
         struct timer_list        timer;
+        snd_wavefront_card_t     *timer_card;
         spinlock_t               open;
         spinlock_t               virtual;     /* protects isvirtual */
 …
 #define UART_MODE_ON    0x3F
 extern struct snd_rawmidi_ops snd_wavefront_midi_output;
 extern struct snd_rawmidi_ops snd_wavefront_midi_input;
+extern const struct snd_rawmidi_ops snd_wavefront_midi_output;
+extern const struct snd_rawmidi_ops snd_wavefront_midi_input;
 extern void   snd_wavefront_midi_enable_virtual (snd_wavefront_card_t *);

GPL/trunk/alsa-kernel/include/sound/soc-dapm.h

-              r598
+              r679
+/*
+/* SPDX-License-Identifier: GPL-2.0
+ *
  * linux/sound/soc-dapm.h -- ALSA SoC Dynamic Audio Power Management
+ *
  * Author:              Liam Girdwood
  * Created:             Aug 11th 2005
+ * Author:      Liam Girdwood
+ * Created:     Aug 11th 2005
  * Copyright:   Wolfson Microelectronics. PLC.
+ *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
  */
 …
 #define __LINUX_SND_SOC_DAPM_H
-#include <linux/device.h>
 #include <linux/types.h>
 #include <sound/control.h>
+#include <sound/soc-topology.h>
+#include <sound/asoc.h>
+struct device;
+struct snd_soc_pcm_runtime;
+struct soc_enum;
 /* widget has no PM register bit */
 …
  * SoC dynamic audio power management
+ *
  * We can have upto 4 power domains
  *      1. Codec domain - VREF, VMID
+ * We can have up to 4 power domains
+ *  1. Codec domain - VREF, VMID
  *     Usually controlled at codec probe/remove, although can be set
  *     at stream time if power is not needed for sidetone, etc.
 …
 /* codec domain */
 #define SND_SOC_DAPM_VMID(wname) \
 {       .id = snd_soc_dapm_vmid, .name = wname, .kcontrols = NULL, \
+{       .id = snd_soc_dapm_vmid, .name = wname, .kcontrol_news = NULL, \
         .num_kcontrols = 0}
 /* platform domain */
+#define SND_SOC_DAPM_SIGGEN(wname) \
+{       .id = snd_soc_dapm_siggen, .name = wname, .kcontrol_news = NULL, \
+        .num_kcontrols = 0, .reg = SND_SOC_NOPM }
+#define SND_SOC_DAPM_SINK(wname) \
+{       .id = snd_soc_dapm_sink, .name = wname, .kcontrol_news = NULL, \
+        .num_kcontrols = 0, .reg = SND_SOC_NOPM }
 #define SND_SOC_DAPM_INPUT(wname) \
 {       .id = snd_soc_dapm_input, .name = wname, .kcontrols = NULL, \
         .num_kcontrols = 0}
+{       .id = snd_soc_dapm_input, .name = wname, .kcontrol_news = NULL, \
+        .num_kcontrols = 0, .reg = SND_SOC_NOPM }
 #define SND_SOC_DAPM_OUTPUT(wname) \
 {       .id = snd_soc_dapm_output, .name = wname, .kcontrols = NULL, \
         .num_kcontrols = 0}
+{       .id = snd_soc_dapm_output, .name = wname, .kcontrol_news = NULL, \
+        .num_kcontrols = 0, .reg = SND_SOC_NOPM }
 #define SND_SOC_DAPM_MIC(wname, wevent) \
 {       .id = snd_soc_dapm_mic, .name = wname, .kcontrols = NULL, \
         .num_kcontrols = 0, .event = wevent, \
+{       .id = snd_soc_dapm_mic, .name = wname, .kcontrol_news = NULL, \
+        .num_kcontrols = 0, .reg = SND_SOC_NOPM, .event = wevent, \
         .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD}
 #define SND_SOC_DAPM_HP(wname, wevent) \
 {       .id = snd_soc_dapm_hp, .name = wname, .kcontrols = NULL, \
         .num_kcontrols = 0, .event = wevent, \
+{       .id = snd_soc_dapm_hp, .name = wname, .kcontrol_news = NULL, \
+        .num_kcontrols = 0, .reg = SND_SOC_NOPM, .event = wevent, \
         .event_flags = SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD}
 #define SND_SOC_DAPM_SPK(wname, wevent) \
 {       .id = snd_soc_dapm_spk, .name = wname, .kcontrols = NULL, \
         .num_kcontrols = 0, .event = wevent, \
+{       .id = snd_soc_dapm_spk, .name = wname, .kcontrol_news = NULL, \
+        .num_kcontrols = 0, .reg = SND_SOC_NOPM, .event = wevent, \
         .event_flags = SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD}
 #define SND_SOC_DAPM_LINE(wname, wevent) \
 {       .id = snd_soc_dapm_line, .name = wname, .kcontrols = NULL, \
         .num_kcontrols = 0, .event = wevent, \
+{       .id = snd_soc_dapm_line, .name = wname, .kcontrol_news = NULL, \
+        .num_kcontrols = 0, .reg = SND_SOC_NOPM, .event = wevent, \
         .event_flags = SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD}
+#define SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert) \
+        .reg = wreg, .mask = 1, .shift = wshift, \
+        .on_val = winvert ? 0 : 1, .off_val = winvert ? 1 : 0
 /* path domain */
 #define SND_SOC_DAPM_PGA(wname, wreg, wshift, winvert,\
          wcontrols, wncontrols) \
+{       .id = snd_soc_dapm_pga, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = wncontrols}
+{       .id = snd_soc_dapm_pga, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = wncontrols}
 #define SND_SOC_DAPM_OUT_DRV(wname, wreg, wshift, winvert,\
          wcontrols, wncontrols) \
+{       .id = snd_soc_dapm_out_drv, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = wncontrols}
+{       .id = snd_soc_dapm_out_drv, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = wncontrols}
 #define SND_SOC_DAPM_MIXER(wname, wreg, wshift, winvert, \
          wcontrols, wncontrols)\
+{       .id = snd_soc_dapm_mixer, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = wncontrols}
+{       .id = snd_soc_dapm_mixer, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = wncontrols}
 #define SND_SOC_DAPM_MIXER_NAMED_CTL(wname, wreg, wshift, winvert, \
          wcontrols, wncontrols)\
+{       .id = snd_soc_dapm_mixer_named_ctl, .name = wname, .reg = wreg, \
+        .shift = wshift, .invert = winvert, .kcontrols = wcontrols, \
+        .num_kcontrols = wncontrols}
+{       .id = snd_soc_dapm_mixer_named_ctl, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = wncontrols}
+/* DEPRECATED: use SND_SOC_DAPM_SUPPLY */
 #define SND_SOC_DAPM_MICBIAS(wname, wreg, wshift, winvert) \
+{       .id = snd_soc_dapm_micbias, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = NULL, .num_kcontrols = 0}
+{       .id = snd_soc_dapm_micbias, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = NULL, .num_kcontrols = 0}
 #define SND_SOC_DAPM_SWITCH(wname, wreg, wshift, winvert, wcontrols) \
+{       .id = snd_soc_dapm_switch, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = 1}
+{       .id = snd_soc_dapm_switch, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = 1}
 #define SND_SOC_DAPM_MUX(wname, wreg, wshift, winvert, wcontrols) \
+{       .id = snd_soc_dapm_mux, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = 1}
+#define SND_SOC_DAPM_VIRT_MUX(wname, wreg, wshift, winvert, wcontrols) \
+{       .id = snd_soc_dapm_virt_mux, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = 1}
+#define SND_SOC_DAPM_VALUE_MUX(wname, wreg, wshift, winvert, wcontrols) \
+{       .id = snd_soc_dapm_value_mux, .name = wname, .reg = wreg, \
+        .shift = wshift, .invert = winvert, .kcontrols = wcontrols, \
+        .num_kcontrols = 1}
+{       .id = snd_soc_dapm_mux, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = 1}
+#define SND_SOC_DAPM_DEMUX(wname, wreg, wshift, winvert, wcontrols) \
+{       .id = snd_soc_dapm_demux, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = 1}
 /* Simplified versions of above macros, assuming wncontrols = ARRAY_SIZE(wcontrols) */
 #define SOC_PGA_ARRAY(wname, wreg, wshift, winvert,\
          wcontrols) \
+{       .id = snd_soc_dapm_pga, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = ARRAY_SIZE(wcontrols)}
+{       .id = snd_soc_dapm_pga, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = ARRAY_SIZE(wcontrols)}
 #define SOC_MIXER_ARRAY(wname, wreg, wshift, winvert, \
          wcontrols)\
+{       .id = snd_soc_dapm_mixer, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = ARRAY_SIZE(wcontrols)}
+{       .id = snd_soc_dapm_mixer, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = ARRAY_SIZE(wcontrols)}
 #define SOC_MIXER_NAMED_CTL_ARRAY(wname, wreg, wshift, winvert, \
          wcontrols)\
 {       .id = snd_soc_dapm_mixer_named_ctl, .name = wname, .reg = wreg, \
         .shift = wshift, .invert = winvert, .kcontrols = wcontrols, \
         .num_kcontrols = ARRAY_SIZE(wcontrols)}
+{       .id = snd_soc_dapm_mixer_named_ctl, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = ARRAY_SIZE(wcontrols)}
 /* path domain with event - event handler must return 0 for success */
 #define SND_SOC_DAPM_PGA_E(wname, wreg, wshift, winvert, wcontrols, \
         wncontrols, wevent, wflags) \
+{       .id = snd_soc_dapm_pga, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = wncontrols, \
+{       .id = snd_soc_dapm_pga, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = wncontrols, \
         .event = wevent, .event_flags = wflags}
 #define SND_SOC_DAPM_OUT_DRV_E(wname, wreg, wshift, winvert, wcontrols, \
         wncontrols, wevent, wflags) \
+{       .id = snd_soc_dapm_out_drv, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = wncontrols, \
+{       .id = snd_soc_dapm_out_drv, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = wncontrols, \
         .event = wevent, .event_flags = wflags}
 #define SND_SOC_DAPM_MIXER_E(wname, wreg, wshift, winvert, wcontrols, \
         wncontrols, wevent, wflags) \
+{       .id = snd_soc_dapm_mixer, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = wncontrols, \
+{       .id = snd_soc_dapm_mixer, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = wncontrols, \
         .event = wevent, .event_flags = wflags}
 #define SND_SOC_DAPM_MIXER_NAMED_CTL_E(wname, wreg, wshift, winvert, \
         wcontrols, wncontrols, wevent, wflags) \
+{       .id = snd_soc_dapm_mixer, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, \
+{       .id = snd_soc_dapm_mixer, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, \
         .num_kcontrols = wncontrols, .event = wevent, .event_flags = wflags}
-#define SND_SOC_DAPM_MICBIAS_E(wname, wreg, wshift, winvert, wevent, wflags) \
-{       .id = snd_soc_dapm_micbias, .name = wname, .reg = wreg, .shift = wshift, \
-        .invert = winvert, .kcontrols = NULL, .num_kcontrols = 0, \
-        .event = wevent, .event_flags = wflags}
 #define SND_SOC_DAPM_SWITCH_E(wname, wreg, wshift, winvert, wcontrols, \
         wevent, wflags) \
+{       .id = snd_soc_dapm_switch, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = 1, \
+{       .id = snd_soc_dapm_switch, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = 1, \
         .event = wevent, .event_flags = wflags}
 #define SND_SOC_DAPM_MUX_E(wname, wreg, wshift, winvert, wcontrols, \
         wevent, wflags) \
+{       .id = snd_soc_dapm_mux, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = 1, \
+        .event = wevent, .event_flags = wflags}
+#define SND_SOC_DAPM_VIRT_MUX_E(wname, wreg, wshift, winvert, wcontrols, \
+{       .id = snd_soc_dapm_mux, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = 1, \
+        .event = wevent, .event_flags = wflags}
+/* additional sequencing control within an event type */
+#define SND_SOC_DAPM_PGA_S(wname, wsubseq, wreg, wshift, winvert, \
         wevent, wflags) \
+{       .id = snd_soc_dapm_virt_mux, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = 1, \
+        .event = wevent, .event_flags = wflags}
+{       .id = snd_soc_dapm_pga, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .event = wevent, .event_flags = wflags, \
+        .subseq = wsubseq}
+#define SND_SOC_DAPM_SUPPLY_S(wname, wsubseq, wreg, wshift, winvert, wevent, \
+        wflags) \
+{       .id = snd_soc_dapm_supply, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .event = wevent, .event_flags = wflags, .subseq = wsubseq}
 /* Simplified versions of above macros, assuming wncontrols = ARRAY_SIZE(wcontrols) */
 #define SOC_PGA_E_ARRAY(wname, wreg, wshift, winvert, wcontrols, \
         wevent, wflags) \
+{       .id = snd_soc_dapm_pga, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = ARRAY_SIZE(wcontrols), \
+{       .id = snd_soc_dapm_pga, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = ARRAY_SIZE(wcontrols), \
         .event = wevent, .event_flags = wflags}
 #define SOC_MIXER_E_ARRAY(wname, wreg, wshift, winvert, wcontrols, \
         wevent, wflags) \
+{       .id = snd_soc_dapm_mixer, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, .num_kcontrols = ARRAY_SIZE(wcontrols), \
+{       .id = snd_soc_dapm_mixer, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = ARRAY_SIZE(wcontrols), \
         .event = wevent, .event_flags = wflags}
 #define SOC_MIXER_NAMED_CTL_E_ARRAY(wname, wreg, wshift, winvert, \
         wcontrols, wevent, wflags) \
+{       .id = snd_soc_dapm_mixer, .name = wname, .reg = wreg, .shift = wshift, \
+        .invert = winvert, .kcontrols = wcontrols, \
+        .num_kcontrols = ARRAY_SIZE(wcontrols), .event = wevent, .event_flags = wflags}
+{       .id = snd_soc_dapm_mixer, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .kcontrol_news = wcontrols, .num_kcontrols = ARRAY_SIZE(wcontrols), \
+        .event = wevent, .event_flags = wflags}
 /* events that are pre and post DAPM */
 #define SND_SOC_DAPM_PRE(wname, wevent) \
 {       .id = snd_soc_dapm_pre, .name = wname, .kcontrols = NULL, \
         .num_kcontrols = 0, .event = wevent, \
+{       .id = snd_soc_dapm_pre, .name = wname, .kcontrol_news = NULL, \
+        .num_kcontrols = 0, .reg = SND_SOC_NOPM, .event = wevent, \
         .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_PRE_PMD}
 #define SND_SOC_DAPM_POST(wname, wevent) \
 {       .id = snd_soc_dapm_post, .name = wname, .kcontrols = NULL, \
         .num_kcontrols = 0, .event = wevent, \
+{       .id = snd_soc_dapm_post, .name = wname, .kcontrol_news = NULL, \
+        .num_kcontrols = 0, .reg = SND_SOC_NOPM, .event = wevent, \
         .event_flags = SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD}
 /* stream domain */
 #define SND_SOC_DAPM_AIF_IN(wname, stname, wslot, wreg, wshift, winvert) \
+#define SND_SOC_DAPM_AIF_IN(wname, stname, wchan, wreg, wshift, winvert) \
 {       .id = snd_soc_dapm_aif_in, .name = wname, .sname = stname, \
         .reg = wreg, .shift = wshift, .invert = winvert }
 #define SND_SOC_DAPM_AIF_IN_E(wname, stname, wslot, wreg, wshift, winvert, \
+        .channel = wchan, SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), }
+#define SND_SOC_DAPM_AIF_IN_E(wname, stname, wchan, wreg, wshift, winvert, \
                               wevent, wflags)                           \
 {       .id = snd_soc_dapm_aif_in, .name = wname, .sname = stname, \
         .reg = wreg, .shift = wshift, .invert = winvert, \
+        .channel = wchan, SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
         .event = wevent, .event_flags = wflags }
 #define SND_SOC_DAPM_AIF_OUT(wname, stname, wslot, wreg, wshift, winvert) \
+#define SND_SOC_DAPM_AIF_OUT(wname, stname, wchan, wreg, wshift, winvert) \
 {       .id = snd_soc_dapm_aif_out, .name = wname, .sname = stname, \
         .reg = wreg, .shift = wshift, .invert = winvert }
 #define SND_SOC_DAPM_AIF_OUT_E(wname, stname, wslot, wreg, wshift, winvert, \
+        .channel = wchan, SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), }
+#define SND_SOC_DAPM_AIF_OUT_E(wname, stname, wchan, wreg, wshift, winvert, \
                              wevent, wflags)                            \
 {       .id = snd_soc_dapm_aif_out, .name = wname, .sname = stname, \
         .reg = wreg, .shift = wshift, .invert = winvert, \
+        .channel = wchan, SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
         .event = wevent, .event_flags = wflags }
 #define SND_SOC_DAPM_DAC(wname, stname, wreg, wshift, winvert) \
 {       .id = snd_soc_dapm_dac, .name = wname, .sname = stname, .reg = wreg, \
         .shift = wshift, .invert = winvert}
+{       .id = snd_soc_dapm_dac, .name = wname, .sname = stname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert) }
 #define SND_SOC_DAPM_DAC_E(wname, stname, wreg, wshift, winvert, \
                            wevent, wflags)                              \
+{       .id = snd_soc_dapm_dac, .name = wname, .sname = stname, .reg = wreg, \
+        .shift = wshift, .invert = winvert, \
+        .event = wevent, .event_flags = wflags}
+{       .id = snd_soc_dapm_dac, .name = wname, .sname = stname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .event = wevent, .event_flags = wflags}
 #define SND_SOC_DAPM_ADC(wname, stname, wreg, wshift, winvert) \
 {       .id = snd_soc_dapm_adc, .name = wname, .sname = stname, .reg = wreg, \
         .shift = wshift, .invert = winvert}
+{       .id = snd_soc_dapm_adc, .name = wname, .sname = stname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), }
 #define SND_SOC_DAPM_ADC_E(wname, stname, wreg, wshift, winvert, \
                            wevent, wflags)                              \
+{       .id = snd_soc_dapm_adc, .name = wname, .sname = stname, .reg = wreg, \
+        .shift = wshift, .invert = winvert, \
+        .event = wevent, .event_flags = wflags}
+{       .id = snd_soc_dapm_adc, .name = wname, .sname = stname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .event = wevent, .event_flags = wflags}
+#define SND_SOC_DAPM_CLOCK_SUPPLY(wname) \
+{       .id = snd_soc_dapm_clock_supply, .name = wname, \
+        .reg = SND_SOC_NOPM, .event = dapm_clock_event, \
+        .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD }
 /* generic widgets */
 #define SND_SOC_DAPM_REG(wid, wname, wreg, wshift, wmask, won_val, woff_val) \
+{       .id = wid, .name = wname, .kcontrols = NULL, .num_kcontrols = 0, \
+        .reg = -((wreg) + 1), .shift = wshift, .mask = wmask, \
+        .on_val = won_val, .off_val = woff_val, .event = dapm_reg_event, \
+        .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD}
+{       .id = wid, .name = wname, .kcontrol_news = NULL, .num_kcontrols = 0, \
+        .reg = wreg, .shift = wshift, .mask = wmask, \
+        .on_val = won_val, .off_val = woff_val, }
 #define SND_SOC_DAPM_SUPPLY(wname, wreg, wshift, winvert, wevent, wflags) \
+{       .id = snd_soc_dapm_supply, .name = wname, .reg = wreg,  \
+        .shift = wshift, .invert = winvert, .event = wevent, \
+        .event_flags = wflags}
+{       .id = snd_soc_dapm_supply, .name = wname, \
+        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
+        .event = wevent, .event_flags = wflags}
+#define SND_SOC_DAPM_REGULATOR_SUPPLY(wname, wdelay, wflags)        \
+{       .id = snd_soc_dapm_regulator_supply, .name = wname, \
+        .reg = SND_SOC_NOPM, .shift = wdelay, .event = dapm_regulator_event, \
+        .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD, \
+        .on_val = wflags}
+#define SND_SOC_DAPM_PINCTRL(wname, active, sleep) \
+{       .id = snd_soc_dapm_pinctrl, .name = wname, \
+        .priv = (&(struct snd_soc_dapm_pinctrl_priv) \
+                { .active_state = active, .sleep_state = sleep,}), \
+        .reg = SND_SOC_NOPM, .event = dapm_pinctrl_event, \
+        .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD }
 /* dapm kcontrol types */
+#define SOC_DAPM_DOUBLE(xname, reg, lshift, rshift, max, invert) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+        .info = snd_soc_info_volsw, \
+        .get = snd_soc_dapm_get_volsw, .put = snd_soc_dapm_put_volsw, \
+        .private_value = SOC_DOUBLE_VALUE(reg, lshift, rshift, max, invert, 0) }
+#define SOC_DAPM_DOUBLE_R(xname, lreg, rreg, shift, max, invert) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+        .info = snd_soc_info_volsw, \
+        .get = snd_soc_dapm_get_volsw, .put = snd_soc_dapm_put_volsw, \
+        .private_value = SOC_DOUBLE_R_VALUE(lreg, rreg, shift, max, invert) }
 #define SOC_DAPM_SINGLE(xname, reg, shift, max, invert) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
         .info = snd_soc_info_volsw, \
         .get = snd_soc_dapm_get_volsw, .put = snd_soc_dapm_put_volsw, \
+        .private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }
+        .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
+#define SOC_DAPM_SINGLE_AUTODISABLE(xname, reg, shift, max, invert) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+        .info = snd_soc_info_volsw, \
+        .get = snd_soc_dapm_get_volsw, .put = snd_soc_dapm_put_volsw, \
+        .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 1) }
+#define SOC_DAPM_SINGLE_VIRT(xname, max) \
+        SOC_DAPM_SINGLE(xname, SND_SOC_NOPM, 0, max, 0)
 #define SOC_DAPM_SINGLE_TLV(xname, reg, shift, max, invert, tlv_array) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 …
         .tlv.p = (tlv_array), \
         .get = snd_soc_dapm_get_volsw, .put = snd_soc_dapm_put_volsw, \
+        .private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }
+        .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
+#define SOC_DAPM_SINGLE_TLV_AUTODISABLE(xname, reg, shift, max, invert, tlv_array) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+        .info = snd_soc_info_volsw, \
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | SNDRV_CTL_ELEM_ACCESS_READWRITE,\
+        .tlv.p = (tlv_array), \
+        .get = snd_soc_dapm_get_volsw, .put = snd_soc_dapm_put_volsw, \
+        .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 1) }
+#define SOC_DAPM_SINGLE_TLV_VIRT(xname, max, tlv_array) \
+        SOC_DAPM_SINGLE(xname, SND_SOC_NOPM, 0, max, 0, tlv_array)
 #define SOC_DAPM_ENUM(xname, xenum) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 …
         .put = snd_soc_dapm_put_enum_double, \
         .private_value = (unsigned long)&xenum }
 #define SOC_DAPM_ENUM_VIRT(xname, xenum)                    \
+#define SOC_DAPM_ENUM_EXT(xname, xenum, xget, xput) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
         .info = snd_soc_info_enum_double, \
+        .get = snd_soc_dapm_get_enum_virt, \
+        .put = snd_soc_dapm_put_enum_virt, \
+        .private_value = (unsigned long)&xenum }
+#define SOC_DAPM_VALUE_ENUM(xname, xenum) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+        .info = snd_soc_info_enum_double, \
+        .get = snd_soc_dapm_get_value_enum_double, \
+        .put = snd_soc_dapm_put_value_enum_double, \
+        .get = xget, \
+        .put = xput, \
         .private_value = (unsigned long)&xenum }
 #define SOC_DAPM_PIN_SWITCH(xname) \
 …
 #define SND_SOC_DAPM_PRE_REG    0x10    /* before audio path setup */
 #define SND_SOC_DAPM_POST_REG   0x20    /* after audio path setup */
+#define SND_SOC_DAPM_WILL_PMU   0x40    /* called at start of sequence */
+#define SND_SOC_DAPM_WILL_PMD   0x80    /* called at start of sequence */
 #define SND_SOC_DAPM_PRE_POST_PMD \
                                 (SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD)
+#define SND_SOC_DAPM_PRE_POST_PMU \
+                                (SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU)
 /* convenience event type detection */
 …
 #define SND_SOC_DAPM_EVENT_OFF(e)       \
         (e & (SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD))
+/* regulator widget flags */
+#define SND_SOC_DAPM_REGULATOR_BYPASS     0x1     /* bypass when disabled */
 struct snd_soc_dapm_widget;
 …
 struct snd_soc_dapm_route;
 struct snd_soc_dapm_context;
+int dapm_reg_event(struct snd_soc_dapm_widget *w,
+                   struct snd_kcontrol *kcontrol, int event);
+struct regulator;
+struct snd_soc_dapm_widget_list;
+struct snd_soc_dapm_update;
+enum snd_soc_dapm_direction;
+/*
+ * Bias levels
+ *
+ * @ON:      Bias is fully on for audio playback and capture operations.
+ * @PREPARE: Prepare for audio operations. Called before DAPM switching for
+ *           stream start and stop operations.
+ * @STANDBY: Low power standby state when no playback/capture operations are
+ *           in progress. NOTE: The transition time between STANDBY and ON
+ *           should be as fast as possible and no longer than 10ms.
+ * @OFF:     Power Off. No restrictions on transition times.
+ */
+enum snd_soc_bias_level {
+        SND_SOC_BIAS_OFF = 0,
+        SND_SOC_BIAS_STANDBY = 1,
+        SND_SOC_BIAS_PREPARE = 2,
+        SND_SOC_BIAS_ON = 3,
+};
+int dapm_regulator_event(struct snd_soc_dapm_widget *w,
+                         struct snd_kcontrol *kcontrol, int event);
+int dapm_clock_event(struct snd_soc_dapm_widget *w,
+                         struct snd_kcontrol *kcontrol, int event);
+int dapm_pinctrl_event(struct snd_soc_dapm_widget *w,
+                         struct snd_kcontrol *kcontrol, int event);
 /* dapm controls */
 …
 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_value *ucontrol);
-int snd_soc_dapm_get_enum_virt(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol);
-int snd_soc_dapm_put_enum_virt(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol);
-int snd_soc_dapm_get_value_enum_double(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol);
-int snd_soc_dapm_put_value_enum_double(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol);
 int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_info *uinfo);
 …
 int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_value *uncontrol);
-int snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
-        const struct snd_soc_dapm_widget *widget);
 int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
         const struct snd_soc_dapm_widget *widget,
         int num);
+struct snd_soc_dapm_widget *snd_soc_dapm_new_control(
+                struct snd_soc_dapm_context *dapm,
+                const struct snd_soc_dapm_widget *widget);
+struct snd_soc_dapm_widget *snd_soc_dapm_new_control_unlocked(
+                struct snd_soc_dapm_context *dapm,
+                const struct snd_soc_dapm_widget *widget);
+int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,
+                                 struct snd_soc_dai *dai);
+int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card);
+void snd_soc_dapm_connect_dai_link_widgets(struct snd_soc_card *card);
+int snd_soc_dapm_update_dai(struct snd_pcm_substream *substream,
+                            struct snd_pcm_hw_params *params,
+                            struct snd_soc_dai *dai);
 /* dapm path setup */
 int snd_soc_dapm_new_widgets(struct snd_soc_dapm_context *dapm);
+int snd_soc_dapm_new_widgets(struct snd_soc_card *card);
 void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm);
+void snd_soc_dapm_init(struct snd_soc_dapm_context *dapm,
+                       struct snd_soc_card *card,
+                       struct snd_soc_component *component);
 int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
                             const struct snd_soc_dapm_route *route, int num);
+int snd_soc_dapm_del_routes(struct snd_soc_dapm_context *dapm,
+                            const struct snd_soc_dapm_route *route, int num);
+int snd_soc_dapm_weak_routes(struct snd_soc_dapm_context *dapm,
+                             const struct snd_soc_dapm_route *route, int num);
+void snd_soc_dapm_free_widget(struct snd_soc_dapm_widget *w);
+void snd_soc_dapm_reset_cache(struct snd_soc_dapm_context *dapm);
 /* dapm events */
+int snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd,
+        const char *stream, int event);
+void snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
+        int event);
+void snd_soc_dapm_stream_stop(struct snd_soc_pcm_runtime *rtd, int stream);
 void snd_soc_dapm_shutdown(struct snd_soc_card *card);
+/* external DAPM widget events */
+int snd_soc_dapm_mixer_update_power(struct snd_soc_dapm_context *dapm,
+                struct snd_kcontrol *kcontrol, int connect,
+                struct snd_soc_dapm_update *update);
+int snd_soc_dapm_mux_update_power(struct snd_soc_dapm_context *dapm,
+                struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e,
+                struct snd_soc_dapm_update *update);
 /* dapm sys fs - used by the core */
+int snd_soc_dapm_sys_add(struct device *dev);
+void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm);
+extern struct attribute *soc_dapm_dev_attrs[];
+void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
+                                struct dentry *parent);
 /* dapm audio pin control and status */
 int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm,
                             const char *pin);
+int snd_soc_dapm_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
+                                     const char *pin);
 int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
                              const char *pin);
+int snd_soc_dapm_disable_pin_unlocked(struct snd_soc_dapm_context *dapm,
+                                      const char *pin);
 int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin);
+int snd_soc_dapm_nc_pin_unlocked(struct snd_soc_dapm_context *dapm,
+                                 const char *pin);
 int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
                                 const char *pin);
 int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm);
+int snd_soc_dapm_sync_unlocked(struct snd_soc_dapm_context *dapm);
 int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
                                   const char *pin);
+int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
+                                           const char *pin);
 int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
                                 const char *pin);
+unsigned int dapm_kcontrol_get_value(const struct snd_kcontrol *kcontrol);
+/* Mostly internal - should not normally be used */
+void dapm_mark_endpoints_dirty(struct snd_soc_card *card);
+/* dapm path query */
+int snd_soc_dapm_dai_get_connected_widgets(struct snd_soc_dai *dai, int stream,
+        struct snd_soc_dapm_widget_list **list,
+        bool (*custom_stop_condition)(struct snd_soc_dapm_widget *,
+                                      enum snd_soc_dapm_direction));
+void snd_soc_dapm_dai_free_widgets(struct snd_soc_dapm_widget_list **list);
+struct snd_soc_dapm_context *snd_soc_dapm_kcontrol_dapm(
+        struct snd_kcontrol *kcontrol);
+struct snd_soc_dapm_widget *snd_soc_dapm_kcontrol_widget(
+                struct snd_kcontrol *kcontrol);
+int snd_soc_dapm_force_bias_level(struct snd_soc_dapm_context *dapm,
+        enum snd_soc_bias_level level);
 /* dapm widget types */
 …
         snd_soc_dapm_output,            /* output pin */
         snd_soc_dapm_mux,                       /* selects 1 analog signal from many inputs */
+        snd_soc_dapm_virt_mux,                  /* virtual version of snd_soc_dapm_mux */
+        snd_soc_dapm_value_mux,                 /* selects 1 analog signal from many inputs */
+        snd_soc_dapm_demux,                     /* connects the input to one of multiple outputs */
         snd_soc_dapm_mixer,                     /* mixes several analog signals together */
         snd_soc_dapm_mixer_named_ctl,           /* mixer with named controls */
 …
         snd_soc_dapm_adc,                       /* analog to digital converter */
         snd_soc_dapm_dac,                       /* digital to analog converter */
         snd_soc_dapm_micbias,           /* microphone bias (power) */
+        snd_soc_dapm_micbias,           /* microphone bias (power) - DEPRECATED: use snd_soc_dapm_supply */
         snd_soc_dapm_mic,                       /* microphone */
         snd_soc_dapm_hp,                        /* headphones */
 …
         snd_soc_dapm_post,                      /* machine specific post widget - exec last */
         snd_soc_dapm_supply,            /* power/clock supply */
+        snd_soc_dapm_pinctrl,           /* pinctrl */
+        snd_soc_dapm_regulator_supply,  /* external regulator */
+        snd_soc_dapm_clock_supply,      /* external clock */
         snd_soc_dapm_aif_in,            /* audio interface input */
         snd_soc_dapm_aif_out,           /* audio interface output */
+        snd_soc_dapm_siggen,            /* signal generator */
+        snd_soc_dapm_sink,
+        snd_soc_dapm_dai_in,            /* link to DAI structure */
+        snd_soc_dapm_dai_out,
+        snd_soc_dapm_dai_link,          /* link between two DAI structures */
+        snd_soc_dapm_kcontrol,          /* Auto-disabled kcontrol */
+        snd_soc_dapm_buffer,            /* DSP/CODEC internal buffer */
+        snd_soc_dapm_scheduler,         /* DSP/CODEC internal scheduler */
+        snd_soc_dapm_effect,            /* DSP/CODEC effect component */
+        snd_soc_dapm_src,               /* DSP/CODEC SRC component */
+        snd_soc_dapm_asrc,              /* DSP/CODEC ASRC component */
+        snd_soc_dapm_encoder,           /* FW/SW audio encoder component */
+        snd_soc_dapm_decoder,           /* FW/SW audio decoder component */
+        /* Don't edit below this line */
+        SND_SOC_DAPM_TYPE_COUNT
+};
+enum snd_soc_dapm_subclass {
+        SND_SOC_DAPM_CLASS_INIT         = 0,
+        SND_SOC_DAPM_CLASS_RUNTIME      = 1,
 };
 …
         int (*connected)(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink);
+        struct snd_soc_dobj dobj;
 };
 /* dapm audio path between two widgets */
 struct snd_soc_dapm_path {
+        char *name;
+        char *long_name;
+        /* source (input) and sink (output) widgets */
+        struct snd_soc_dapm_widget *source;
+        struct snd_soc_dapm_widget *sink;
+        struct snd_kcontrol *kcontrol;
+        const char *name;
+        /*
+         * source (input) and sink (output) widgets
+         * The union is for convience, since it is a lot nicer to type
+         * p->source, rather than p->node[SND_SOC_DAPM_DIR_IN]
+         */
+        union {
+                struct {
+                        struct snd_soc_dapm_widget *source;
+                        struct snd_soc_dapm_widget *sink;
+                };
+                struct snd_soc_dapm_widget *node[2];
+        };
         /* status */
         u32 connect:1;  /* source and sink widgets are connected */
+        u32 walked:1;   /* path has been walked */
+        u32 walking:1;  /* path is in the process of being walked */
+        u32 weak:1;     /* path ignored for power management */
+        u32 is_supply:1;        /* At least one of the connected widgets is a supply */
         int (*connected)(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink);
         struct list_head list_source;
         struct list_head list_sink;
+        struct list_head list_node[2];
+        struct list_head list_kcontrol;
         struct list_head list;
 };
 …
 struct snd_soc_dapm_widget {
         enum snd_soc_dapm_type id;
+        char *name;             /* widget name */
+        char *sname;    /* stream name */
+        struct snd_soc_codec *codec;
+        const char *name;               /* widget name */
+        const char *sname;      /* stream name */
         struct list_head list;
         struct snd_soc_dapm_context *dapm;
+        void *priv;                             /* widget specific data */
+        struct regulator *regulator;            /* attached regulator */
+        struct pinctrl *pinctrl;                /* attached pinctrl */
         /* dapm control */
         short reg;                                              /* negative reg = no direct dapm */
+        int reg;                                /* negative reg = no direct dapm */
         unsigned char shift;                    /* bits to shift */
-        unsigned int saved_value;               /* widget saved value */
-        unsigned int value;                             /* widget current value */
         unsigned int mask;                      /* non-shifted mask */
         unsigned int on_val;                    /* on state value */
         unsigned int off_val;                   /* off state value */
         unsigned char power:1;                  /* block power status */
-        unsigned char invert:1;                 /* invert the power bit */
         unsigned char active:1;                 /* active stream on DAC, ADC's */
         unsigned char connected:1;              /* connected codec pin */
         unsigned char new:1;                    /* cnew complete */
-        unsigned char ext:1;                    /* has external widgets */
         unsigned char force:1;                  /* force state */
         unsigned char ignore_suspend:1;         /* kept enabled over suspend */
+        unsigned char new_power:1;              /* power from this run */
+        unsigned char power_checked:1;          /* power checked this run */
+        unsigned char is_supply:1;              /* Widget is a supply type widget */
+        unsigned char is_ep:2;                  /* Widget is a endpoint type widget */
+        int subseq;                             /* sort within widget type */
         int (*power_check)(struct snd_soc_dapm_widget *w);
 …
         /* kcontrols that relate to this widget */
         int num_kcontrols;
+        const struct snd_kcontrol_new *kcontrols;
+        /* widget input and outputs */
+        struct list_head sources;
+        struct list_head sinks;
+        const struct snd_kcontrol_new *kcontrol_news;
+        struct snd_kcontrol **kcontrols;
+        struct snd_soc_dobj dobj;
+        /* widget input and output edges */
+        struct list_head edges[2];
         /* used during DAPM updates */
+        struct list_head work_list;
         struct list_head power_list;
+        struct list_head dirty;
+        int endpoints[2];
+        struct clk *clk;
+        int channel;
 };
 struct snd_soc_dapm_update {
-        struct snd_soc_dapm_widget *widget;
         struct snd_kcontrol *kcontrol;
         int reg;
         int mask;
         int val;
+        int reg2;
+        int mask2;
+        int val2;
+        bool has_second_set;
+};
+struct snd_soc_dapm_wcache {
+        struct snd_soc_dapm_widget *widget;
 };
 /* DAPM context */
 struct snd_soc_dapm_context {
-        int n_widgets; /* number of widgets in this context */
         enum snd_soc_bias_level bias_level;
-        enum snd_soc_bias_level suspend_bias_level;
-        struct delayed_work delayed_work;
         unsigned int idle_bias_off:1; /* Use BIAS_OFF instead of STANDBY */
         struct snd_soc_dapm_update *update;
+        /* Go to BIAS_OFF in suspend if the DAPM context is idle */
+        unsigned int suspend_bias_off:1;
         struct device *dev; /* from parent - for debug */
         struct snd_soc_codec *codec; /* parent codec */
+        struct snd_soc_component *component; /* parent component */
         struct snd_soc_card *card; /* parent card */
         /* used during DAPM updates */
         int dev_power;
+        enum snd_soc_bias_level target_bias_level;
         struct list_head list;
+        struct snd_soc_dapm_wcache path_sink_cache;
+        struct snd_soc_dapm_wcache path_source_cache;
 #ifdef CONFIG_DEBUG_FS
 …
 };
+/* A list of widgets associated with an object, typically a snd_kcontrol */
+struct snd_soc_dapm_widget_list {
+        int num_widgets;
+        struct snd_soc_dapm_widget *widgets[];
+};
+#define for_each_dapm_widgets(list, i, widget)                          \
+        for ((i) = 0;                                                   \
+             (i) < list->num_widgets && (widget = list->widgets[i]);    \
+             (i)++)
+struct snd_soc_dapm_stats {
+        int power_checks;
+        int path_checks;
+        int neighbour_checks;
+};
+struct snd_soc_dapm_pinctrl_priv {
+        const char *active_state;
+        const char *sleep_state;
+};
+/**
+ * snd_soc_dapm_init_bias_level() - Initialize DAPM bias level
+ * @dapm: The DAPM context to initialize
+ * @level: The DAPM level to initialize to
+ *
+ * This function only sets the driver internal state of the DAPM level and will
+ * not modify the state of the device. Hence it should not be used during normal
+ * operation, but only to synchronize the internal state to the device state.
+ * E.g. during driver probe to set the DAPM level to the one corresponding with
+ * the power-on reset state of the device.
+ *
+ * To change the DAPM state of the device use snd_soc_dapm_set_bias_level().
+ */
+static inline void snd_soc_dapm_init_bias_level(
+        struct snd_soc_dapm_context *dapm, enum snd_soc_bias_level level)
+{
+        dapm->bias_level = level;
+}
+/**
+ * snd_soc_dapm_get_bias_level() - Get current DAPM bias level
+ * @dapm: The context for which to get the bias level
+ *
+ * Returns: The current bias level of the passed DAPM context.
+ */
+static inline enum snd_soc_bias_level snd_soc_dapm_get_bias_level(
+        struct snd_soc_dapm_context *dapm)
+{
+        return dapm->bias_level;
+}
+enum snd_soc_dapm_direction {
+        SND_SOC_DAPM_DIR_IN,
+        SND_SOC_DAPM_DIR_OUT
+};
+#define SND_SOC_DAPM_DIR_TO_EP(x) BIT(x)
+#define SND_SOC_DAPM_EP_SOURCE SND_SOC_DAPM_DIR_TO_EP(SND_SOC_DAPM_DIR_IN)
+#define SND_SOC_DAPM_EP_SINK SND_SOC_DAPM_DIR_TO_EP(SND_SOC_DAPM_DIR_OUT)
+/**
+ * snd_soc_dapm_widget_for_each_sink_path - Iterates over all paths in the
+ *   specified direction of a widget
+ * @w: The widget
+ * @dir: Whether to iterate over the paths where the specified widget is the
+ *       incoming or outgoing widgets
+ * @p: The path iterator variable
+ */
+#define snd_soc_dapm_widget_for_each_path(w, dir, p) \
+        list_for_each_entry(p, &w->edges[dir], list_node[dir])
+/**
+ * snd_soc_dapm_widget_for_each_sink_path_safe - Iterates over all paths in the
+ *   specified direction of a widget
+ * @w: The widget
+ * @dir: Whether to iterate over the paths where the specified widget is the
+ *       incoming or outgoing widgets
+ * @p: The path iterator variable
+ * @next_p: Temporary storage for the next path
+ *
+ *  This function works like snd_soc_dapm_widget_for_each_sink_path, expect that
+ *  it is safe to remove the current path from the list while iterating
+ */
+#define snd_soc_dapm_widget_for_each_path_safe(w, dir, p, next_p) \
+        list_for_each_entry_safe(p, next_p, &w->edges[dir], list_node[dir])
+/**
+ * snd_soc_dapm_widget_for_each_sink_path - Iterates over all paths leaving a
+ *  widget
+ * @w: The widget
+ * @p: The path iterator variable
+ */
+#define snd_soc_dapm_widget_for_each_sink_path(w, p) \
+        snd_soc_dapm_widget_for_each_path(w, SND_SOC_DAPM_DIR_IN, p)
+/**
+ * snd_soc_dapm_widget_for_each_source_path - Iterates over all paths leading to
+ *  a widget
+ * @w: The widget
+ * @p: The path iterator variable
+ */
+#define snd_soc_dapm_widget_for_each_source_path(w, p) \
+        snd_soc_dapm_widget_for_each_path(w, SND_SOC_DAPM_DIR_OUT, p)
 #endif

GPL/trunk/alsa-kernel/include/sound/soc.h

-              r598
+              r679
+/*
+/* SPDX-License-Identifier: GPL-2.0
+ *
  * linux/sound/soc.h -- ALSA SoC Layer
+ *
  * Author:              Liam Girdwood
  * Created:             Aug 11th 2005
+ * Author:      Liam Girdwood
+ * Created:     Aug 11th 2005
  * Copyright:   Wolfson Microelectronics. PLC.
+ *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
  */
 …
 #define __LINUX_SND_SOC_H
+#include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/types.h>
 …
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
+#include <linux/regmap.h>
+#include <linux/log2.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
+#include <sound/compress_driver.h>
 #include <sound/control.h>
 #include <sound/ac97_codec.h>
 …
  * Convenience kcontrol builders
  */
 #define SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) \
+#define SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, xmax, xinvert, xautodisable) \
         ((unsigned long)&(struct soc_mixer_control) \
+        {.reg = xreg, .shift = xshift, .rshift = xshift, .max = xmax, \
+        .platform_max = xmax, .invert = xinvert})
+        {.reg = xreg, .rreg = xreg, .shift = shift_left, \
+        .rshift = shift_right, .max = xmax, .platform_max = xmax, \
+        .invert = xinvert, .autodisable = xautodisable})
+#define SOC_DOUBLE_S_VALUE(xreg, shift_left, shift_right, xmin, xmax, xsign_bit, xinvert, xautodisable) \
+        ((unsigned long)&(struct soc_mixer_control) \
+        {.reg = xreg, .rreg = xreg, .shift = shift_left, \
+        .rshift = shift_right, .min = xmin, .max = xmax, .platform_max = xmax, \
+        .sign_bit = xsign_bit, .invert = xinvert, .autodisable = xautodisable})
+#define SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, xautodisable) \
+        SOC_DOUBLE_VALUE(xreg, xshift, xshift, xmax, xinvert, xautodisable)
 #define SOC_SINGLE_VALUE_EXT(xreg, xmax, xinvert) \
         ((unsigned long)&(struct soc_mixer_control) \
         {.reg = xreg, .max = xmax, .platform_max = xmax, .invert = xinvert})
+#define SOC_DOUBLE_R_VALUE(xlreg, xrreg, xshift, xmax, xinvert) \
+        ((unsigned long)&(struct soc_mixer_control) \
+        {.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
+        .max = xmax, .platform_max = xmax, .invert = xinvert})
+#define SOC_DOUBLE_R_S_VALUE(xlreg, xrreg, xshift, xmin, xmax, xsign_bit, xinvert) \
+        ((unsigned long)&(struct soc_mixer_control) \
+        {.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
+        .max = xmax, .min = xmin, .platform_max = xmax, .sign_bit = xsign_bit, \
+        .invert = xinvert})
+#define SOC_DOUBLE_R_RANGE_VALUE(xlreg, xrreg, xshift, xmin, xmax, xinvert) \
+        ((unsigned long)&(struct soc_mixer_control) \
+        {.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
+        .min = xmin, .max = xmax, .platform_max = xmax, .invert = xinvert})
 #define SOC_SINGLE(xname, reg, shift, max, invert) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
         .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
         .put = snd_soc_put_volsw, \
+        .private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }
+        .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
+#define SOC_SINGLE_RANGE(xname, xreg, xshift, xmin, xmax, xinvert) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
+        .info = snd_soc_info_volsw_range, .get = snd_soc_get_volsw_range, \
+        .put = snd_soc_put_volsw_range, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = xreg, .rreg = xreg, .shift = xshift, \
+                 .rshift = xshift,  .min = xmin, .max = xmax, \
+                 .platform_max = xmax, .invert = xinvert} }
 #define SOC_SINGLE_TLV(xname, reg, shift, max, invert, tlv_array) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 …
         .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
         .put = snd_soc_put_volsw, \
+        .private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }
+#define SOC_DOUBLE(xname, xreg, shift_left, shift_right, xmax, xinvert) \
+        .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
+#define SOC_SINGLE_SX_TLV(xname, xreg, xshift, xmin, xmax, tlv_array) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
+        SNDRV_CTL_ELEM_ACCESS_READWRITE, \
+        .tlv.p  = (tlv_array),\
+        .info = snd_soc_info_volsw_sx, \
+        .get = snd_soc_get_volsw_sx,\
+        .put = snd_soc_put_volsw_sx, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = xreg, .rreg = xreg, \
+                .shift = xshift, .rshift = xshift, \
+                .max = xmax, .min = xmin} }
+#define SOC_SINGLE_RANGE_TLV(xname, xreg, xshift, xmin, xmax, xinvert, tlv_array) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
+                 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
+        .tlv.p = (tlv_array), \
+        .info = snd_soc_info_volsw_range, \
+        .get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = xreg, .rreg = xreg, .shift = xshift, \
+                 .rshift = xshift, .min = xmin, .max = xmax, \
+                 .platform_max = xmax, .invert = xinvert} }
+#define SOC_DOUBLE(xname, reg, shift_left, shift_right, max, invert) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
         .info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
         .put = snd_soc_put_volsw, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = xreg, .shift = shift_left, .rshift = shift_right, \
+                 .max = xmax, .platform_max = xmax, .invert = xinvert} }
+        .private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
+                                          max, invert, 0) }
+#define SOC_DOUBLE_STS(xname, reg, shift_left, shift_right, max, invert) \
+{                                                                       \
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),           \
+        .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,           \
+        .access = SNDRV_CTL_ELEM_ACCESS_READ |                          \
+                SNDRV_CTL_ELEM_ACCESS_VOLATILE,                         \
+        .private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
+                                          max, invert, 0) }
 #define SOC_DOUBLE_R(xname, reg_left, reg_right, xshift, xmax, xinvert) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
+        .info = snd_soc_info_volsw_2r, \
+        .get = snd_soc_get_volsw_2r, .put = snd_soc_put_volsw_2r, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = reg_left, .rreg = reg_right, .shift = xshift, \
+                .max = xmax, .platform_max = xmax, .invert = xinvert} }
+#define SOC_DOUBLE_TLV(xname, xreg, shift_left, shift_right, xmax, xinvert, tlv_array) \
+        .info = snd_soc_info_volsw, \
+        .get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
+        .private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
+                                            xmax, xinvert) }
+#define SOC_DOUBLE_R_RANGE(xname, reg_left, reg_right, xshift, xmin, \
+                           xmax, xinvert)               \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
+        .info = snd_soc_info_volsw_range, \
+        .get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
+        .private_value = SOC_DOUBLE_R_RANGE_VALUE(reg_left, reg_right, \
+                                            xshift, xmin, xmax, xinvert) }
+#define SOC_DOUBLE_TLV(xname, reg, shift_left, shift_right, max, invert, tlv_array) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
         .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
 …
         .info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
         .put = snd_soc_put_volsw, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = xreg, .shift = shift_left, .rshift = shift_right,\
+                 .max = xmax, .platform_max = xmax, .invert = xinvert} }
+        .private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
+                                          max, invert, 0) }
 #define SOC_DOUBLE_R_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert, tlv_array) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
 …
                  SNDRV_CTL_ELEM_ACCESS_READWRITE,\
         .tlv.p = (tlv_array), \
+        .info = snd_soc_info_volsw_2r, \
+        .get = snd_soc_get_volsw_2r, .put = snd_soc_put_volsw_2r, \
+        .info = snd_soc_info_volsw, \
+        .get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
+        .private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
+                                            xmax, xinvert) }
+#define SOC_DOUBLE_R_RANGE_TLV(xname, reg_left, reg_right, xshift, xmin, \
+                               xmax, xinvert, tlv_array)                \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
+                 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
+        .tlv.p = (tlv_array), \
+        .info = snd_soc_info_volsw_range, \
+        .get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
+        .private_value = SOC_DOUBLE_R_RANGE_VALUE(reg_left, reg_right, \
+                                            xshift, xmin, xmax, xinvert) }
+#define SOC_DOUBLE_R_SX_TLV(xname, xreg, xrreg, xshift, xmin, xmax, tlv_array) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
+        SNDRV_CTL_ELEM_ACCESS_READWRITE, \
+        .tlv.p  = (tlv_array), \
+        .info = snd_soc_info_volsw_sx, \
+        .get = snd_soc_get_volsw_sx, \
+        .put = snd_soc_put_volsw_sx, \
         .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = reg_left, .rreg = reg_right, .shift = xshift, \
+                .max = xmax, .platform_max = xmax, .invert = xinvert} }
+                {.reg = xreg, .rreg = xrreg, \
+                .shift = xshift, .rshift = xshift, \
+                .max = xmax, .min = xmin} }
+#define SOC_DOUBLE_R_S_TLV(xname, reg_left, reg_right, xshift, xmin, xmax, xsign_bit, xinvert, tlv_array) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
+                 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
+        .tlv.p = (tlv_array), \
+        .info = snd_soc_info_volsw, \
+        .get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
+        .private_value = SOC_DOUBLE_R_S_VALUE(reg_left, reg_right, xshift, \
+                                            xmin, xmax, xsign_bit, xinvert) }
+#define SOC_SINGLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
+{       .iface  = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
+                  SNDRV_CTL_ELEM_ACCESS_READWRITE, \
+        .tlv.p  = (tlv_array), \
+        .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
+        .put = snd_soc_put_volsw, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+        {.reg = xreg, .rreg = xreg,  \
+         .min = xmin, .max = xmax, .platform_max = xmax, \
+        .sign_bit = 7,} }
 #define SOC_DOUBLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
 {       .iface  = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
 …
                   SNDRV_CTL_ELEM_ACCESS_READWRITE, \
         .tlv.p  = (tlv_array), \
+        .info   = snd_soc_info_volsw_s8, .get = snd_soc_get_volsw_s8, \
+        .put    = snd_soc_put_volsw_s8, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = xreg, .min = xmin, .max = xmax, \
+                 .platform_max = xmax} }
+#define SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmax, xtexts) \
+        .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
+        .put = snd_soc_put_volsw, \
+        .private_value = SOC_DOUBLE_S_VALUE(xreg, 0, 8, xmin, xmax, 7, 0, 0) }
+#define SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xitems, xtexts) \
 {       .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
+        .max = xmax, .texts = xtexts }
+#define SOC_ENUM_SINGLE(xreg, xshift, xmax, xtexts) \
+        SOC_ENUM_DOUBLE(xreg, xshift, xshift, xmax, xtexts)
+#define SOC_ENUM_SINGLE_EXT(xmax, xtexts) \
+{       .max = xmax, .texts = xtexts }
+#define SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, xmax, xtexts, xvalues) \
+        .items = xitems, .texts = xtexts, \
+        .mask = xitems ? roundup_pow_of_two(xitems) - 1 : 0}
+#define SOC_ENUM_SINGLE(xreg, xshift, xitems, xtexts) \
+        SOC_ENUM_DOUBLE(xreg, xshift, xshift, xitems, xtexts)
+#define SOC_ENUM_SINGLE_EXT(xitems, xtexts) \
+{       .items = xitems, .texts = xtexts }
+#define SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, xitems, xtexts, xvalues) \
 {       .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
+        .mask = xmask, .max = xmax, .texts = xtexts, .values = xvalues}
+#define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xmax, xtexts, xvalues) \
+        SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xmax, xtexts, xvalues)
+        .mask = xmask, .items = xitems, .texts = xtexts, .values = xvalues}
+#define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xitems, xtexts, xvalues) \
+        SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xitems, xtexts, xvalues)
+#define SOC_VALUE_ENUM_SINGLE_AUTODISABLE(xreg, xshift, xmask, xitems, xtexts, xvalues) \
+{       .reg = xreg, .shift_l = xshift, .shift_r = xshift, \
+        .mask = xmask, .items = xitems, .texts = xtexts, \
+        .values = xvalues, .autodisable = 1}
+#define SOC_ENUM_SINGLE_VIRT(xitems, xtexts) \
+        SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, xitems, xtexts)
 #define SOC_ENUM(xname, xenum) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
         .info = snd_soc_info_enum_double, \
         .get = snd_soc_get_enum_double, .put = snd_soc_put_enum_double, \
-        .private_value = (unsigned long)&xenum }
-#define SOC_VALUE_ENUM(xname, xenum) \
-{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
-        .info = snd_soc_info_enum_double, \
-        .get = snd_soc_get_value_enum_double, \
-        .put = snd_soc_put_value_enum_double, \
         .private_value = (unsigned long)&xenum }
 #define SOC_SINGLE_EXT(xname, xreg, xshift, xmax, xinvert,\
 …
         .info = snd_soc_info_volsw, \
         .get = xhandler_get, .put = xhandler_put, \
         .private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) }
 #define SOC_DOUBLE_EXT(xname, xreg, shift_left, shift_right, xmax, xinvert,\
+        .private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
+#define SOC_DOUBLE_EXT(xname, reg, shift_left, shift_right, max, invert,\
          xhandler_get, xhandler_put) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
         .info = snd_soc_info_volsw, \
         .get = xhandler_get, .put = xhandler_put, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = xreg, .shift = shift_left, .rshift = shift_right, \
+                 .max = xmax, .platform_max = xmax, .invert = xinvert} }
+        .private_value = \
+                SOC_DOUBLE_VALUE(reg, shift_left, shift_right, max, invert, 0) }
+#define SOC_DOUBLE_R_EXT(xname, reg_left, reg_right, xshift, xmax, xinvert,\
+         xhandler_get, xhandler_put) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
+        .info = snd_soc_info_volsw, \
+        .get = xhandler_get, .put = xhandler_put, \
+        .private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
+                                            xmax, xinvert) }
 #define SOC_SINGLE_EXT_TLV(xname, xreg, xshift, xmax, xinvert,\
          xhandler_get, xhandler_put, tlv_array) \
 …
         .info = snd_soc_info_volsw, \
         .get = xhandler_get, .put = xhandler_put, \
+        .private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) }
+        .private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
+#define SOC_SINGLE_RANGE_EXT_TLV(xname, xreg, xshift, xmin, xmax, xinvert, \
+                                 xhandler_get, xhandler_put, tlv_array) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
+                 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
+        .tlv.p = (tlv_array), \
+        .info = snd_soc_info_volsw_range, \
+        .get = xhandler_get, .put = xhandler_put, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = xreg, .rreg = xreg, .shift = xshift, \
+                 .rshift = xshift, .min = xmin, .max = xmax, \
+                 .platform_max = xmax, .invert = xinvert} }
 #define SOC_DOUBLE_EXT_TLV(xname, xreg, shift_left, shift_right, xmax, xinvert,\
          xhandler_get, xhandler_put, tlv_array) \
 …
         .info = snd_soc_info_volsw, \
         .get = xhandler_get, .put = xhandler_put, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = xreg, .shift = shift_left, .rshift = shift_right, \
+                .max = xmax, .platform_max = xmax, .invert = xinvert} }
+        .private_value = SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, \
+                                          xmax, xinvert, 0) }
 #define SOC_DOUBLE_R_EXT_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert,\
          xhandler_get, xhandler_put, tlv_array) \
 …
                  SNDRV_CTL_ELEM_ACCESS_READWRITE, \
         .tlv.p = (tlv_array), \
         .info = snd_soc_info_volsw_2r, \
+        .info = snd_soc_info_volsw, \
         .get = xhandler_get, .put = xhandler_put, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = reg_left, .rreg = reg_right, .shift = xshift, \
+                .max = xmax, .platform_max = xmax, .invert = xinvert} }
+        .private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
+                                            xmax, xinvert) }
 #define SOC_SINGLE_BOOL_EXT(xname, xdata, xhandler_get, xhandler_put) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 …
 #define SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
         .info = snd_soc_info_enum_ext, \
+        .info = snd_soc_info_enum_double, \
         .get = xhandler_get, .put = xhandler_put, \
         .private_value = (unsigned long)&xenum }
+#define SOC_DOUBLE_R_SX_TLV(xname, xreg_left, xreg_right, xshift,\
+                xmin, xmax, tlv_array) \
+#define SOC_VALUE_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
+        SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put)
+#define SND_SOC_BYTES(xname, xbase, xregs)                    \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,   \
+        .info = snd_soc_bytes_info, .get = snd_soc_bytes_get, \
+        .put = snd_soc_bytes_put, .private_value =            \
+                ((unsigned long)&(struct soc_bytes)           \
+                {.base = xbase, .num_regs = xregs }) }
+#define SND_SOC_BYTES_E(xname, xbase, xregs, xhandler_get, xhandler_put) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+        .info = snd_soc_bytes_info, .get = xhandler_get, \
+        .put = xhandler_put, .private_value = \
+                ((unsigned long)&(struct soc_bytes) \
+                {.base = xbase, .num_regs = xregs }) }
+#define SND_SOC_BYTES_MASK(xname, xbase, xregs, xmask)        \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,   \
+        .info = snd_soc_bytes_info, .get = snd_soc_bytes_get, \
+        .put = snd_soc_bytes_put, .private_value =            \
+                ((unsigned long)&(struct soc_bytes)           \
+                {.base = xbase, .num_regs = xregs,            \
+                 .mask = xmask }) }
+/*
+ * SND_SOC_BYTES_EXT is deprecated, please USE SND_SOC_BYTES_TLV instead
+ */
+#define SND_SOC_BYTES_EXT(xname, xcount, xhandler_get, xhandler_put) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+        .info = snd_soc_bytes_info_ext, \
+        .get = xhandler_get, .put = xhandler_put, \
+        .private_value = (unsigned long)&(struct soc_bytes_ext) \
+                {.max = xcount} }
+#define SND_SOC_BYTES_TLV(xname, xcount, xhandler_get, xhandler_put) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE | \
+                  SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
+        .tlv.c = (snd_soc_bytes_tlv_callback), \
+        .info = snd_soc_bytes_info_ext, \
+        .private_value = (unsigned long)&(struct soc_bytes_ext) \
+                {.max = xcount, .get = xhandler_get, .put = xhandler_put, } }
+#define SOC_SINGLE_XR_SX(xname, xregbase, xregcount, xnbits, \
+                xmin, xmax, xinvert) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
+                  SNDRV_CTL_ELEM_ACCESS_READWRITE, \
+        .tlv.p = (tlv_array), \
+        .info = snd_soc_info_volsw_2r_sx, \
+        .get = snd_soc_get_volsw_2r_sx, \
+        .put = snd_soc_put_volsw_2r_sx, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = xreg_left, \
+                 .rreg = xreg_right, .shift = xshift, \
+                 .min = xmin, .max = xmax} }
+        .info = snd_soc_info_xr_sx, .get = snd_soc_get_xr_sx, \
+        .put = snd_soc_put_xr_sx, \
+        .private_value = (unsigned long)&(struct soc_mreg_control) \
+                {.regbase = xregbase, .regcount = xregcount, .nbits = xnbits, \
+                .invert = xinvert, .min = xmin, .max = xmax} }
+#define SOC_SINGLE_STROBE(xname, xreg, xshift, xinvert) \
+        SOC_SINGLE_EXT(xname, xreg, xshift, 1, xinvert, \
+                snd_soc_get_strobe, snd_soc_put_strobe)
 /*
 …
  */
 #define SOC_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xtexts) \
         struct soc_enum name = SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, \
+        const struct soc_enum name = SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, \
                                                 ARRAY_SIZE(xtexts), xtexts)
 #define SOC_ENUM_SINGLE_DECL(name, xreg, xshift, xtexts) \
         SOC_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xtexts)
 #define SOC_ENUM_SINGLE_EXT_DECL(name, xtexts) \
         struct soc_enum name = SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(xtexts), xtexts)
+        const struct soc_enum name = SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(xtexts), xtexts)
 #define SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xmask, xtexts, xvalues) \
         struct soc_enum name = SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, \
+        const struct soc_enum name = SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, \
                                                         ARRAY_SIZE(xtexts), xtexts, xvalues)
 #define SOC_VALUE_ENUM_SINGLE_DECL(name, xreg, xshift, xmask, xtexts, xvalues) \
         SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xmask, xtexts, xvalues)
+/*
+ * Bias levels
+ *
+ * @ON:      Bias is fully on for audio playback and capture operations.
+ * @PREPARE: Prepare for audio operations. Called before DAPM switching for
+ *           stream start and stop operations.
+ * @STANDBY: Low power standby state when no playback/capture operations are
+ *           in progress. NOTE: The transition time between STANDBY and ON
+ *           should be as fast as possible and no longer than 10ms.
+ * @OFF:     Power Off. No restrictions on transition times.
+ */
+enum snd_soc_bias_level {
+        SND_SOC_BIAS_OFF,
+        SND_SOC_BIAS_STANDBY,
+        SND_SOC_BIAS_PREPARE,
+        SND_SOC_BIAS_ON,
+};
+#define SOC_VALUE_ENUM_SINGLE_AUTODISABLE_DECL(name, xreg, xshift, xmask, xtexts, xvalues) \
+        const struct soc_enum name = SOC_VALUE_ENUM_SINGLE_AUTODISABLE(xreg, \
+                xshift, xmask, ARRAY_SIZE(xtexts), xtexts, xvalues)
+#define SOC_ENUM_SINGLE_VIRT_DECL(name, xtexts) \
+        const struct soc_enum name = SOC_ENUM_SINGLE_VIRT(ARRAY_SIZE(xtexts), xtexts)
+struct device_node;
 struct snd_jack;
 struct snd_soc_card;
 …
 struct snd_soc_dai;
 struct snd_soc_dai_driver;
-struct snd_soc_platform;
 struct snd_soc_dai_link;
+struct snd_soc_platform_driver;
+struct snd_soc_codec;
+struct snd_soc_codec_driver;
+struct snd_soc_component;
+struct snd_soc_component_driver;
 struct soc_enum;
 struct snd_soc_jack;
+struct snd_soc_jack_zone;
 struct snd_soc_jack_pin;
-struct snd_soc_cache_ops;
 #include <sound/soc-dapm.h>
+#ifdef CONFIG_GPIOLIB
+#include <sound/soc-dpcm.h>
+#include <sound/soc-topology.h>
 struct snd_soc_jack_gpio;
-#endif
 typedef int (*hw_write_t)(void *,const char* ,int);
+extern struct snd_ac97_bus_ops soc_ac97_ops;
+enum snd_soc_control_type {
+        SND_SOC_CUSTOM,
+        SND_SOC_I2C,
+        SND_SOC_SPI,
+};
+enum snd_soc_compress_type {
+        SND_SOC_FLAT_COMPRESSION = 1,
+        SND_SOC_LZO_COMPRESSION,
+        SND_SOC_RBTREE_COMPRESSION
+enum snd_soc_pcm_subclass {
+        SND_SOC_PCM_CLASS_PCM   = 0,
+        SND_SOC_PCM_CLASS_BE    = 1,
 };
 int snd_soc_register_card(struct snd_soc_card *card);
 int snd_soc_unregister_card(struct snd_soc_card *card);
+int snd_soc_register_platform(struct device *dev,
+                struct snd_soc_platform_driver *platform_drv);
+void snd_soc_unregister_platform(struct device *dev);
+int snd_soc_register_codec(struct device *dev,
+                const struct snd_soc_codec_driver *codec_drv,
+                struct snd_soc_dai_driver *dai_drv, int num_dai);
+void snd_soc_unregister_codec(struct device *dev);
+int snd_soc_codec_volatile_register(struct snd_soc_codec *codec, int reg);
+int snd_soc_codec_set_cache_io(struct snd_soc_codec *codec,
+                               int addr_bits, int data_bits,
+                               enum snd_soc_control_type control);
+int snd_soc_cache_sync(struct snd_soc_codec *codec);
+int snd_soc_cache_init(struct snd_soc_codec *codec);
+int snd_soc_cache_exit(struct snd_soc_codec *codec);
+int snd_soc_cache_write(struct snd_soc_codec *codec,
+                        unsigned int reg, unsigned int value);
+int snd_soc_cache_read(struct snd_soc_codec *codec,
+                       unsigned int reg, unsigned int *value);
+int snd_soc_default_volatile_register(struct snd_soc_codec *codec,
+                                      unsigned int reg);
+int snd_soc_default_readable_register(struct snd_soc_codec *codec,
+                                      unsigned int reg);
+int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card);
+#ifdef CONFIG_PM_SLEEP
+int snd_soc_suspend(struct device *dev);
+int snd_soc_resume(struct device *dev);
+#else
+static inline int snd_soc_suspend(struct device *dev)
+{
+        return 0;
+}
+static inline int snd_soc_resume(struct device *dev)
+{
+        return 0;
+}
+#endif
+int snd_soc_poweroff(struct device *dev);
+int snd_soc_component_initialize(struct snd_soc_component *component,
+                                 const struct snd_soc_component_driver *driver,
+                                 struct device *dev);
+int snd_soc_add_component(struct snd_soc_component *component,
+                          struct snd_soc_dai_driver *dai_drv,
+                          int num_dai);
+int snd_soc_register_component(struct device *dev,
+                         const struct snd_soc_component_driver *component_driver,
+                         struct snd_soc_dai_driver *dai_drv, int num_dai);
+int devm_snd_soc_register_component(struct device *dev,
+                         const struct snd_soc_component_driver *component_driver,
+                         struct snd_soc_dai_driver *dai_drv, int num_dai);
+void snd_soc_unregister_component(struct device *dev);
+void snd_soc_unregister_component_by_driver(struct device *dev,
+                         const struct snd_soc_component_driver *component_driver);
+struct snd_soc_component *snd_soc_lookup_component_nolocked(struct device *dev,
+                                                            const char *driver_name);
+struct snd_soc_component *snd_soc_lookup_component(struct device *dev,
+                                                   const char *driver_name);
+int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
+#ifdef CONFIG_SND_SOC_COMPRESS
+int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num);
+#else
+static inline int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
+{
+        return 0;
+}
+#endif
+void snd_soc_disconnect_sync(struct device *dev);
+struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
+                                struct snd_soc_dai_link *dai_link);
+bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd);
+void snd_soc_runtime_action(struct snd_soc_pcm_runtime *rtd,
+                            int stream, int action);
+static inline void snd_soc_runtime_activate(struct snd_soc_pcm_runtime *rtd,
+                                     int stream)
+{
+        snd_soc_runtime_action(rtd, stream, 1);
+}
+static inline void snd_soc_runtime_deactivate(struct snd_soc_pcm_runtime *rtd,
+                                       int stream)
+{
+        snd_soc_runtime_action(rtd, stream, -1);
+}
+int snd_soc_runtime_calc_hw(struct snd_soc_pcm_runtime *rtd,
+                            struct snd_pcm_hardware *hw, int stream);
+int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
+        unsigned int dai_fmt);
+#ifdef CONFIG_DMI
+int snd_soc_set_dmi_name(struct snd_soc_card *card, const char *flavour);
+#else
+static inline int snd_soc_set_dmi_name(struct snd_soc_card *card,
+                                       const char *flavour)
+{
+        return 0;
+}
+#endif
 /* Utility functions to get clock rates from various things */
 …
 /* Jack reporting */
-int snd_soc_jack_new(struct snd_soc_codec *codec, const char *id, int type,
-                     struct snd_soc_jack *jack);
 void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask);
 int snd_soc_jack_add_pins(struct snd_soc_jack *jack, int count,
 …
 void snd_soc_jack_notifier_unregister(struct snd_soc_jack *jack,
                                       struct notifier_block *nb);
+int snd_soc_jack_add_zones(struct snd_soc_jack *jack, int count,
+                          struct snd_soc_jack_zone *zones);
+int snd_soc_jack_get_type(struct snd_soc_jack *jack, int micbias_voltage);
 #ifdef CONFIG_GPIOLIB
 int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
                         struct snd_soc_jack_gpio *gpios);
+int snd_soc_jack_add_gpiods(struct device *gpiod_dev,
+                            struct snd_soc_jack *jack,
+                            int count, struct snd_soc_jack_gpio *gpios);
 void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
                         struct snd_soc_jack_gpio *gpios);
+#else
+static inline int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
+                                         struct snd_soc_jack_gpio *gpios)
+{
+        return 0;
+}
+static inline int snd_soc_jack_add_gpiods(struct device *gpiod_dev,
+                                          struct snd_soc_jack *jack,
+                                          int count,
+                                          struct snd_soc_jack_gpio *gpios)
+{
+        return 0;
+}
+static inline void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
+                                           struct snd_soc_jack_gpio *gpios)
+{
+}
 #endif
+/* codec register bit access */
+int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
+                                unsigned int mask, unsigned int value);
+int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
+                               unsigned short reg, unsigned int mask,
+                               unsigned int value);
+int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
+                                unsigned int mask, unsigned int value);
+int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
+        struct snd_ac97_bus_ops *ops, int num);
+void snd_soc_free_ac97_codec(struct snd_soc_codec *codec);
+struct snd_ac97 *snd_soc_alloc_ac97_component(struct snd_soc_component *component);
+struct snd_ac97 *snd_soc_new_ac97_component(struct snd_soc_component *component,
+        unsigned int id, unsigned int id_mask);
+void snd_soc_free_ac97_component(struct snd_ac97 *ac97);
+#ifdef CONFIG_SND_SOC_AC97_BUS
+int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops);
+int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
+                struct platform_device *pdev);
+extern struct snd_ac97_bus_ops *soc_ac97_ops;
+#else
+static inline int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
+        struct platform_device *pdev)
+{
+        return 0;
+}
+static inline int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops)
+{
+        return 0;
+}
+#endif
 /*
 …
  */
 struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
+        void *data, char *long_name);
+int snd_soc_add_controls(struct snd_soc_codec *codec,
+                                  void *data, const char *long_name,
+                                  const char *prefix);
+int snd_soc_add_component_controls(struct snd_soc_component *component,
+        const struct snd_kcontrol_new *controls, unsigned int num_controls);
+int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
+        const struct snd_kcontrol_new *controls, int num_controls);
+int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
         const struct snd_kcontrol_new *controls, int num_controls);
 int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_info *uinfo);
-int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_info *uinfo);
 int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
 …
 int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_value *ucontrol);
-int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol);
-int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol);
 int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_info *uinfo);
 int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_info *uinfo);
+int snd_soc_info_volsw_sx(struct snd_kcontrol *kcontrol,
+                          struct snd_ctl_elem_info *uinfo);
 #define snd_soc_info_bool_ext           snd_ctl_boolean_mono_info
 int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
 …
 int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_value *ucontrol);
+int snd_soc_info_volsw_2r(struct snd_kcontrol *kcontrol,
+#define snd_soc_get_volsw_2r snd_soc_get_volsw
+#define snd_soc_put_volsw_2r snd_soc_put_volsw
+int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol);
+int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol);
+int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_info *uinfo);
 int snd_soc_get_volsw_2r(struct snd_kcontrol *kcontrol,
+int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_value *ucontrol);
 int snd_soc_put_volsw_2r(struct snd_kcontrol *kcontrol,
+int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_value *ucontrol);
+int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
+int snd_soc_limit_volume(struct snd_soc_card *card,
+        const char *name, int max);
+int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
+                       struct snd_ctl_elem_info *uinfo);
+int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
+                      struct snd_ctl_elem_value *ucontrol);
+int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
+                      struct snd_ctl_elem_value *ucontrol);
+int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_info *ucontrol);
+int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
+        unsigned int size, unsigned int __user *tlv);
+int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_info *uinfo);
 int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
+int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_value *ucontrol);
 int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
+int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_value *ucontrol);
+int snd_soc_limit_volume(struct snd_soc_codec *codec,
+        const char *name, int max);
+int snd_soc_info_volsw_2r_sx(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_info *uinfo);
+int snd_soc_get_volsw_2r_sx(struct snd_kcontrol *kcontrol,
+int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_value *ucontrol);
 int snd_soc_put_volsw_2r_sx(struct snd_kcontrol *kcontrol,
+int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_value *ucontrol);
-/**
- * struct snd_soc_reg_access - Describes whether a given register is
- * readable, writable or volatile.
+ *
- * @reg: the register number
- * @read: whether this register is readable
- * @write: whether this register is writable
- * @vol: whether this register is volatile
- */
-struct snd_soc_reg_access {
-        u16 reg;
-        u16 read;
-        u16 write;
-        u16 vol;
-};
 /**
 …
  * @mask:   bits to check for in reported jack status
  * @invert: if non-zero then pin is enabled when status is not reported
+ * @list:   internal list entry
  */
 struct snd_soc_jack_pin {
 …
 /**
+ * struct snd_soc_jack_zone - Describes voltage zones of jack detection
+ *
+ * @min_mv: start voltage in mv
+ * @max_mv: end voltage in mv
+ * @jack_type: type of jack that is expected for this voltage
+ * @debounce_time: debounce_time for jack, codec driver should wait for this
+ *              duration before reading the adc for voltages
+ * @list:   internal list entry
+ */
+struct snd_soc_jack_zone {
+        unsigned int min_mv;
+        unsigned int max_mv;
+        unsigned int jack_type;
+        unsigned int debounce_time;
+        struct list_head list;
+};
+/**
  * struct snd_soc_jack_gpio - Describes a gpio pin for jack detection
+ *
+ * @gpio:         gpio number
+ * @name:         gpio name
+ * @gpio:         legacy gpio number
+ * @idx:          gpio descriptor index within the function of the GPIO
+ *                consumer device
+ * @gpiod_dev:    GPIO consumer device
+ * @name:         gpio name. Also as connection ID for the GPIO consumer
+ *                device function name lookup
  * @report:       value to report when jack detected
  * @invert:       report presence in low state
+ * @debouce_time: debouce time in ms
+ * @debounce_time: debounce time in ms
+ * @wake:         enable as wake source
+ * @jack_status_check: callback function which overrides the detection
+ *                     to provide more complex checks (eg, reading an
+ *                     ADC).
  */
-#ifdef CONFIG_GPIOLIB
 struct snd_soc_jack_gpio {
         unsigned int gpio;
+        unsigned int idx;
+        struct device *gpiod_dev;
         const char *name;
         int report;
         int invert;
         int debounce_time;
+        bool wake;
+        /* private: */
         struct snd_soc_jack *jack;
         struct delayed_work work;
+        int (*jack_status_check)(void);
+};
+#endif
+        struct notifier_block pm_notifier;
+        struct gpio_desc *desc;
+        void *data;
+        /* public: */
+        int (*jack_status_check)(void *data);
+};
 struct snd_soc_jack {
+        struct mutex mutex;
         struct snd_jack *jack;
         struct snd_soc_codec *codec;
+        struct snd_soc_card *card;
         struct list_head pins;
         int status;
         struct blocking_notifier_head notifier;
+        struct list_head jack_zones;
 };
 …
         unsigned int channels_min;      /* min channels */
         unsigned int channels_max;      /* max channels */
+        unsigned int sig_bits;          /* number of bits of content */
 };
 …
 };
+/* SoC cache ops */
+struct snd_soc_cache_ops {
+struct snd_soc_compr_ops {
+        int (*startup)(struct snd_compr_stream *);
+        void (*shutdown)(struct snd_compr_stream *);
+        int (*set_params)(struct snd_compr_stream *);
+        int (*trigger)(struct snd_compr_stream *);
+};
+struct snd_soc_component*
+snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime *rtd,
+                       const char *driver_name);
+struct snd_soc_dai_link_component {
         const char *name;
+        enum snd_soc_compress_type id;
+        int (*init)(struct snd_soc_codec *codec);
+        int (*exit)(struct snd_soc_codec *codec);
+        int (*read)(struct snd_soc_codec *codec, unsigned int reg,
+                unsigned int *value);
+        int (*write)(struct snd_soc_codec *codec, unsigned int reg,
+                unsigned int value);
+        int (*sync)(struct snd_soc_codec *codec);
+};
+/* SoC Audio Codec device */
+struct snd_soc_codec {
+        const char *name;
+        const char *name_prefix;
+        int id;
+        struct device *dev;
+        const struct snd_soc_codec_driver *driver;
+        struct mutex mutex;
+        struct snd_soc_card *card;
+        struct list_head list;
+        struct list_head card_list;
+        int num_dai;
+        enum snd_soc_compress_type compress_type;
+        size_t reg_size;        /* reg_cache_size * reg_word_size */
+        int (*volatile_register)(struct snd_soc_codec *, unsigned int);
+        int (*readable_register)(struct snd_soc_codec *, unsigned int);
+        /* runtime */
+        struct snd_ac97 *ac97;  /* for ad-hoc ac97 devices */
+        unsigned int active;
+        unsigned int cache_only:1;  /* Suppress writes to hardware */
+        unsigned int cache_sync:1; /* Cache needs to be synced to hardware */
+        unsigned int suspended:1; /* Codec is in suspend PM state */
+        unsigned int probed:1; /* Codec has been probed */
+        unsigned int ac97_registered:1; /* Codec has been AC97 registered */
+        unsigned int ac97_created:1; /* Codec has been created by SoC */
+        unsigned int sysfs_registered:1; /* codec has been sysfs registered */
+        unsigned int cache_init:1; /* codec cache has been initialized */
+        /* codec IO */
+        void *control_data; /* codec control (i2c/3wire) data */
+        hw_write_t hw_write;
+        unsigned int (*hw_read)(struct snd_soc_codec *, unsigned int);
+        unsigned int (*read)(struct snd_soc_codec *, unsigned int);
+        int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
+        void *reg_cache;
+        const void *reg_def_copy;
+        const struct snd_soc_cache_ops *cache_ops;
+        struct mutex cache_rw_mutex;
+        /* dapm */
+        struct snd_soc_dapm_context dapm;
+#ifdef CONFIG_DEBUG_FS
+        struct dentry *debugfs_codec_root;
+        struct dentry *debugfs_reg;
+        struct dentry *debugfs_dapm;
+#endif
+};
+/* codec driver */
+struct snd_soc_codec_driver {
+        /* driver ops */
+        int (*probe)(struct snd_soc_codec *);
+        int (*remove)(struct snd_soc_codec *);
+        int (*suspend)(struct snd_soc_codec *,
+                        pm_message_t state);
+        int (*resume)(struct snd_soc_codec *);
+        /* codec IO */
+        unsigned int (*read)(struct snd_soc_codec *, unsigned int);
+        int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
+        int (*display_register)(struct snd_soc_codec *, char *,
+                                size_t, unsigned int);
+        int (*volatile_register)(struct snd_soc_codec *, unsigned int);
+        int (*readable_register)(struct snd_soc_codec *, unsigned int);
+        short reg_cache_size;
+        short reg_cache_step;
+        short reg_word_size;
+        const void *reg_cache_default;
+        short reg_access_size;
+        const struct snd_soc_reg_access *reg_access_default;
+        enum snd_soc_compress_type compress_type;
+        /* codec bias level */
+        int (*set_bias_level)(struct snd_soc_codec *,
+                              enum snd_soc_bias_level level);
+};
+/* SoC platform interface */
+struct snd_soc_platform_driver {
+        int (*probe)(struct snd_soc_platform *);
+        int (*remove)(struct snd_soc_platform *);
+        int (*suspend)(struct snd_soc_dai *dai);
+        int (*resume)(struct snd_soc_dai *dai);
+        /* pcm creation and destruction */
+        int (*pcm_new)(struct snd_card *, struct snd_soc_dai *,
+                struct snd_pcm *);
+        void (*pcm_free)(struct snd_pcm *);
+        /*
+         * For platform caused delay reporting.
+         * Optional.
+         */
+        snd_pcm_sframes_t (*delay)(struct snd_pcm_substream *,
+                struct snd_soc_dai *);
+        /* platform stream ops */
+        struct snd_pcm_ops *ops;
+};
+struct snd_soc_platform {
+        const char *name;
+        int id;
+        struct device *dev;
+        struct snd_soc_platform_driver *driver;
+        unsigned int suspended:1; /* platform is suspended */
+        unsigned int probed:1;
+        struct snd_soc_card *card;
+        struct list_head list;
+        struct list_head card_list;
+        struct device_node *of_node;
+        const char *dai_name;
 };
 …
         const char *name;                       /* Codec name */
         const char *stream_name;                /* Stream name */
+        const char *codec_name;         /* for multi-codec */
+        const char *platform_name;      /* for multi-platform */
+        const char *cpu_dai_name;
+        const char *codec_dai_name;
+        /*
+         * You MAY specify the link's CPU-side device, either by device name,
+         * or by DT/OF node, but not both. If this information is omitted,
+         * the CPU-side DAI is matched using .cpu_dai_name only, which hence
+         * must be globally unique. These fields are currently typically used
+         * only for codec to codec links, or systems using device tree.
+         */
+        /*
+         * You MAY specify the DAI name of the CPU DAI. If this information is
+         * omitted, the CPU-side DAI is matched using .cpu_name/.cpu_of_node
+         * only, which only works well when that device exposes a single DAI.
+         */
+        struct snd_soc_dai_link_component *cpus;
+        unsigned int num_cpus;
+        /*
+         * You MUST specify the link's codec, either by device name, or by
+         * DT/OF node, but not both.
+         */
+        /* You MUST specify the DAI name within the codec */
+        struct snd_soc_dai_link_component *codecs;
+        unsigned int num_codecs;
+        /*
+         * You MAY specify the link's platform/PCM/DMA driver, either by
+         * device name, or by DT/OF node, but not both. Some forms of link
+         * do not need a platform. In such case, platforms are not mandatory.
+         */
+        struct snd_soc_dai_link_component *platforms;
+        unsigned int num_platforms;
+        int id; /* optional ID for machine driver link identification */
+        const struct snd_soc_pcm_stream *params;
+        unsigned int num_params;
+        unsigned int dai_fmt;           /* format to set on init */
+        enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */
+        /* codec/machine specific init - e.g. add machine controls */
+        int (*init)(struct snd_soc_pcm_runtime *rtd);
+        /* codec/machine specific exit - dual of init() */
+        void (*exit)(struct snd_soc_pcm_runtime *rtd);
+        /* optional hw_params re-writing for BE and FE sync */
+        int (*be_hw_params_fixup)(struct snd_soc_pcm_runtime *rtd,
+                        struct snd_pcm_hw_params *params);
+        /* machine stream operations */
+        const struct snd_soc_ops *ops;
+        const struct snd_soc_compr_ops *compr_ops;
+        /* Mark this pcm with non atomic ops */
+        unsigned int nonatomic:1;
+        /* For unidirectional dai links */
+        unsigned int playback_only:1;
+        unsigned int capture_only:1;
         /* Keep DAI active over suspend */
 …
         /* Symmetry requirements */
         unsigned int symmetric_rates:1;
+        /* codec/machine specific init - e.g. add machine controls */
+        int (*init)(struct snd_soc_pcm_runtime *rtd);
+        /* machine stream operations */
+        struct snd_soc_ops *ops;
+};
+        unsigned int symmetric_channels:1;
+        unsigned int symmetric_samplebits:1;
+        /* Do not create a PCM for this DAI link (Backend link) */
+        unsigned int no_pcm:1;
+        /* This DAI link can route to other DAI links at runtime (Frontend)*/
+        unsigned int dynamic:1;
+        /* DPCM capture and Playback support */
+        unsigned int dpcm_capture:1;
+        unsigned int dpcm_playback:1;
+        /* DPCM used FE & BE merged format */
+        unsigned int dpcm_merged_format:1;
+        /* DPCM used FE & BE merged channel */
+        unsigned int dpcm_merged_chan:1;
+        /* DPCM used FE & BE merged rate */
+        unsigned int dpcm_merged_rate:1;
+        /* pmdown_time is ignored at stop */
+        unsigned int ignore_pmdown_time:1;
+        /* Do not create a PCM for this DAI link (Backend link) */
+        unsigned int ignore:1;
+#ifdef CONFIG_SND_SOC_TOPOLOGY
+        struct snd_soc_dobj dobj; /* For topology */
+#endif
+};
+#define for_each_link_codecs(link, i, codec)                            \
+        for ((i) = 0;                                                   \
+             ((i) < link->num_codecs) && ((codec) = &link->codecs[i]);  \
+             (i)++)
+#define for_each_link_platforms(link, i, platform)                      \
+        for ((i) = 0;                                                   \
+             ((i) < link->num_platforms) &&                             \
+             ((platform) = &link->platforms[i]);                        \
+             (i)++)
+#define for_each_link_cpus(link, i, cpu)                                \
+        for ((i) = 0;                                                   \
+             ((i) < link->num_cpus) && ((cpu) = &link->cpus[i]);        \
+             (i)++)
+/*
+ * Sample 1 : Single CPU/Codec/Platform
+ *
+ * SND_SOC_DAILINK_DEFS(test,
+ *      DAILINK_COMP_ARRAY(COMP_CPU("cpu_dai")),
+ *      DAILINK_COMP_ARRAY(COMP_CODEC("codec", "codec_dai")),
+ *      DAILINK_COMP_ARRAY(COMP_PLATFORM("platform")));
+ *
+ * struct snd_soc_dai_link link = {
+ *      ...
+ *      SND_SOC_DAILINK_REG(test),
+ * };
+ *
+ * Sample 2 : Multi CPU/Codec, no Platform
+ *
+ * SND_SOC_DAILINK_DEFS(test,
+ *      DAILINK_COMP_ARRAY(COMP_CPU("cpu_dai1"),
+ *                         COMP_CPU("cpu_dai2")),
+ *      DAILINK_COMP_ARRAY(COMP_CODEC("codec1", "codec_dai1"),
+ *                         COMP_CODEC("codec2", "codec_dai2")));
+ *
+ * struct snd_soc_dai_link link = {
+ *      ...
+ *      SND_SOC_DAILINK_REG(test),
+ * };
+ *
+ * Sample 3 : Define each CPU/Codec/Platform manually
+ *
+ * SND_SOC_DAILINK_DEF(test_cpu,
+ *              DAILINK_COMP_ARRAY(COMP_CPU("cpu_dai1"),
+ *                                 COMP_CPU("cpu_dai2")));
+ * SND_SOC_DAILINK_DEF(test_codec,
+ *              DAILINK_COMP_ARRAY(COMP_CODEC("codec1", "codec_dai1"),
+ *                                 COMP_CODEC("codec2", "codec_dai2")));
+ * SND_SOC_DAILINK_DEF(test_platform,
+ *              DAILINK_COMP_ARRAY(COMP_PLATFORM("platform")));
+ *
+ * struct snd_soc_dai_link link = {
+ *      ...
+ *      SND_SOC_DAILINK_REG(test_cpu,
+ *                          test_codec,
+ *                          test_platform),
+ * };
+ *
+ * Sample 4 : Sample3 without platform
+ *
+ * struct snd_soc_dai_link link = {
+ *      ...
+ *      SND_SOC_DAILINK_REG(test_cpu,
+ *                          test_codec);
+ * };
+ */
+#define SND_SOC_DAILINK_REG1(name)       SND_SOC_DAILINK_REG3(name##_cpus, name##_codecs, name##_platforms)
+#define SND_SOC_DAILINK_REG2(cpu, codec) SND_SOC_DAILINK_REG3(cpu, codec, null_dailink_component)
+#define SND_SOC_DAILINK_REG3(cpu, codec, platform)      \
+        .cpus           = cpu,                          \
+        .num_cpus       = ARRAY_SIZE(cpu),              \
+        .codecs         = codec,                        \
+        .num_codecs     = ARRAY_SIZE(codec),            \
+        .platforms      = platform,                     \
+        .num_platforms  = ARRAY_SIZE(platform)
+#define SND_SOC_DAILINK_REGx(_1, _2, _3, func, ...) func
+#define SND_SOC_DAILINK_REG(...) \
+        SND_SOC_DAILINK_REGx(__VA_ARGS__,               \
+                        SND_SOC_DAILINK_REG3,   \
+                        SND_SOC_DAILINK_REG2,   \
+                        SND_SOC_DAILINK_REG1)(__VA_ARGS__)
+#define SND_SOC_DAILINK_DEF(name, def...)               \
+        static struct snd_soc_dai_link_component name[] = { def }
+#define SND_SOC_DAILINK_DEFS(name, cpu, codec, platform...)     \
+        SND_SOC_DAILINK_DEF(name##_cpus, cpu);                  \
+        SND_SOC_DAILINK_DEF(name##_codecs, codec);              \
+        SND_SOC_DAILINK_DEF(name##_platforms, platform)
+#define DAILINK_COMP_ARRAY(param...)    param
+#define COMP_EMPTY()                    { }
+#define COMP_CPU(_dai)                  { .dai_name = _dai, }
+#define COMP_CODEC(_name, _dai)         { .name = _name, .dai_name = _dai, }
+#define COMP_PLATFORM(_name)            { .name = _name }
+#define COMP_AUX(_name)                 { .name = _name }
+#define COMP_CODEC_CONF(_name)          { .name = _name }
+#define COMP_DUMMY()                    { .name = "snd-soc-dummy", .dai_name = "snd-soc-dummy-dai", }
+extern struct snd_soc_dai_link_component null_dailink_component[0];
 struct snd_soc_codec_conf {
+        const char *dev_name;
+        /*
+         * specify device either by device name, or by
+         * DT/OF node, but not both.
+         */
+        struct snd_soc_dai_link_component dlc;
         /*
 …
          */
         const char *name_prefix;
+};
+struct snd_soc_aux_dev {
         /*
          * set this to the desired compression type if you want to
          * override the one supplied in codec->driver->compress_type
+         * specify multi-codec either by device name, or by
+         * DT/OF node, but not both.
          */
+        enum snd_soc_compress_type compress_type;
+};
+struct snd_soc_aux_dev {
+        const char *name;               /* Codec name */
+        const char *codec_name;         /* for multi-codec */
+        struct snd_soc_dai_link_component dlc;
         /* codec/machine specific init - e.g. add machine controls */
         int (*init)(struct snd_soc_dapm_context *dapm);
+        int (*init)(struct snd_soc_component *component);
 };
 …
 struct snd_soc_card {
         const char *name;
+        const char *long_name;
+        const char *driver_name;
+        const char *components;
+#ifdef CONFIG_DMI
+        char dmi_longname[80];
+#endif /* CONFIG_DMI */
+        char topology_shortname[32];
         struct device *dev;
         struct snd_card *snd_card;
         struct module *owner;
-        struct list_head list;
         struct mutex mutex;
+        bool instantiated;
+        int (*probe)(struct platform_device *pdev);
+        int (*remove)(struct platform_device *pdev);
+        struct mutex dapm_mutex;
+        /* Mutex for PCM operations */
+        struct mutex pcm_mutex;
+        enum snd_soc_pcm_subclass pcm_subclass;
+        spinlock_t dpcm_lock;
+        int (*probe)(struct snd_soc_card *card);
+        int (*late_probe)(struct snd_soc_card *card);
+        int (*remove)(struct snd_soc_card *card);
         /* the pre and post PM functions are used to do any PM work before and
          * after the codec and DAI's do any PM work. */
         int (*suspend_pre)(struct platform_device *pdev, pm_message_t state);
         int (*suspend_post)(struct platform_device *pdev, pm_message_t state);
         int (*resume_pre)(struct platform_device *pdev);
         int (*resume_post)(struct platform_device *pdev);
+        int (*suspend_pre)(struct snd_soc_card *card);
+        int (*suspend_post)(struct snd_soc_card *card);
+        int (*resume_pre)(struct snd_soc_card *card);
+        int (*resume_post)(struct snd_soc_card *card);
         /* callbacks */
         int (*set_bias_level)(struct snd_soc_card *,
+                              struct snd_soc_dapm_context *dapm,
                               enum snd_soc_bias_level level);
         int (*set_bias_level_post)(struct snd_soc_card *,
+                                   struct snd_soc_dapm_context *dapm,
                                    enum snd_soc_bias_level level);
+        int (*add_dai_link)(struct snd_soc_card *,
+                            struct snd_soc_dai_link *link);
+        void (*remove_dai_link)(struct snd_soc_card *,
+                            struct snd_soc_dai_link *link);
         long pmdown_time;
         /* CPU <--> Codec DAI links  */
+        struct snd_soc_dai_link *dai_link;
+        int num_links;
+        struct snd_soc_pcm_runtime *rtd;
+        struct snd_soc_dai_link *dai_link;  /* predefined links only */
+        int num_links;  /* predefined links only */
+        struct list_head rtd_list;
         int num_rtd;
 …
         struct snd_soc_aux_dev *aux_dev;
         int num_aux_devs;
+        struct snd_soc_pcm_runtime *rtd_aux;
+        int num_aux_rtd;
+        struct work_struct deferred_resume_work;
+        struct list_head aux_comp_list;
+        const struct snd_kcontrol_new *controls;
+        int num_controls;
+        /*
+         * Card-specific routes and widgets.
+         * Note: of_dapm_xxx for Device Tree; Otherwise for driver build-in.
+         */
+        const struct snd_soc_dapm_widget *dapm_widgets;
+        int num_dapm_widgets;
+        const struct snd_soc_dapm_route *dapm_routes;
+        int num_dapm_routes;
+        const struct snd_soc_dapm_widget *of_dapm_widgets;
+        int num_of_dapm_widgets;
+        const struct snd_soc_dapm_route *of_dapm_routes;
+        int num_of_dapm_routes;
         /* lists of probed devices belonging to this card */
+        struct list_head codec_dev_list;
+        struct list_head platform_dev_list;
+        struct list_head dai_dev_list;
+        struct list_head component_dev_list;
+        struct list_head list;
         struct list_head widgets;
         struct list_head paths;
         struct list_head dapm_list;
+        struct list_head dapm_dirty;
+        /* attached dynamic objects */
+        struct list_head dobj_list;
+        /* Generic DAPM context for the card */
+        struct snd_soc_dapm_context dapm;
+        struct snd_soc_dapm_stats dapm_stats;
+        struct snd_soc_dapm_update *update;
 #ifdef CONFIG_DEBUG_FS
         struct dentry *debugfs_card_root;
+        struct dentry *debugfs_pop_time;
+#endif
+#ifdef CONFIG_PM_SLEEP
+        struct work_struct deferred_resume_work;
 #endif
         u32 pop_time;
+};
+        /* bit field */
+        unsigned int instantiated:1;
+        unsigned int topology_shortname_created:1;
+        unsigned int fully_routed:1;
+        unsigned int disable_route_checks:1;
+        unsigned int probed:1;
+        void *drvdata;
+};
+#define for_each_card_prelinks(card, i, link)                           \
+        for ((i) = 0;                                                   \
+             ((i) < (card)->num_links) && ((link) = &(card)->dai_link[i]); \
+             (i)++)
+#define for_each_card_pre_auxs(card, i, aux)                            \
+        for ((i) = 0;                                                   \
+             ((i) < (card)->num_aux_devs) && ((aux) = &(card)->aux_dev[i]); \
+             (i)++)
+#define for_each_card_rtds(card, rtd)                   \
+        list_for_each_entry(rtd, &(card)->rtd_list, list)
+#define for_each_card_rtds_safe(card, rtd, _rtd)        \
+        list_for_each_entry_safe(rtd, _rtd, &(card)->rtd_list, list)
+#define for_each_card_auxs(card, component)                     \
+        list_for_each_entry(component, &card->aux_comp_list, card_aux_list)
+#define for_each_card_auxs_safe(card, component, _comp) \
+        list_for_each_entry_safe(component, _comp,      \
+                                 &card->aux_comp_list, card_aux_list)
+#define for_each_card_components(card, component)                       \
+        list_for_each_entry(component, &(card)->component_dev_list, card_list)
+#define for_each_card_dapms(card, dapm)                                 \
+        list_for_each_entry(dapm, &card->dapm_list, list)
+#define for_each_card_widgets(card, w)\
+        list_for_each_entry(w, &card->widgets, list)
+#define for_each_card_widgets_safe(card, w, _w) \
+        list_for_each_entry_safe(w, _w, &card->widgets, list)
 /* SoC machine DAI configuration, glues a codec and cpu DAI together */
 struct snd_soc_pcm_runtime  {
         struct device dev;
+struct snd_soc_pcm_runtime {
+        struct device *dev;
         struct snd_soc_card *card;
         struct snd_soc_dai_link *dai_link;
+        unsigned int complete:1;
+        unsigned int dev_registered:1;
+        /* Symmetry data - only valid if symmetry is being enforced */
+        unsigned int rate;
+        struct snd_pcm_ops ops;
+        unsigned int params_select; /* currently selected param for dai link */
+        /* Dynamic PCM BE runtime data */
+        struct snd_soc_dpcm_runtime dpcm[2];
         long pmdown_time;
         /* runtime devices */
         struct snd_pcm *pcm;
+        struct snd_soc_codec *codec;
+        struct snd_soc_platform *platform;
+        struct snd_soc_dai *codec_dai;
+        struct snd_soc_dai *cpu_dai;
+        struct snd_compr *compr;
+        /*
+         * dais = cpu_dai + codec_dai
+         * see
+         *      soc_new_pcm_runtime()
+         *      asoc_rtd_to_cpu()
+         *      asoc_rtd_to_codec()
+         */
+        struct snd_soc_dai **dais;
+        unsigned int num_codecs;
+        unsigned int num_cpus;
+        struct snd_soc_dapm_widget *playback_widget;
+        struct snd_soc_dapm_widget *capture_widget;
         struct delayed_work delayed_work;
+};
+        void (*close_delayed_work_func)(struct snd_soc_pcm_runtime *rtd);
+#ifdef CONFIG_DEBUG_FS
+        struct dentry *debugfs_dpcm_root;
+#endif
+        unsigned int num; /* 0-based and monotonic increasing */
+        struct list_head list; /* rtd list of the soc card */
+        /* function mark */
+        struct snd_pcm_substream *mark_startup;
+        /* bit field */
+        unsigned int pop_wait:1;
+        unsigned int fe_compr:1; /* for Dynamic PCM */
+        int num_components;
+        struct snd_soc_component *components[]; /* CPU/Codec/Platform */
+};
+/* see soc_new_pcm_runtime()  */
+#define asoc_rtd_to_cpu(rtd, n)   (rtd)->dais[n]
+#define asoc_rtd_to_codec(rtd, n) (rtd)->dais[n + (rtd)->num_cpus]
+#define asoc_substream_to_rtd(substream) \
+        (struct snd_soc_pcm_runtime *)snd_pcm_substream_chip(substream)
+#define for_each_rtd_components(rtd, i, component)                      \
+        for ((i) = 0, component = NULL;                                 \
+             ((i) < rtd->num_components) && ((component) = rtd->components[i]);\
+             (i)++)
+#define for_each_rtd_cpu_dais(rtd, i, dai)                              \
+        for ((i) = 0;                                                   \
+             ((i) < rtd->num_cpus) && ((dai) = asoc_rtd_to_cpu(rtd, i)); \
+             (i)++)
+#define for_each_rtd_cpu_dais_rollback(rtd, i, dai)             \
+        for (; (--(i) >= 0) && ((dai) = asoc_rtd_to_cpu(rtd, i));)
+#define for_each_rtd_codec_dais(rtd, i, dai)                            \
+        for ((i) = 0;                                                   \
+             ((i) < rtd->num_codecs) && ((dai) = asoc_rtd_to_codec(rtd, i)); \
+             (i)++)
+#define for_each_rtd_codec_dais_rollback(rtd, i, dai)           \
+        for (; (--(i) >= 0) && ((dai) = asoc_rtd_to_codec(rtd, i));)
+#define for_each_rtd_dais(rtd, i, dai)                                  \
+        for ((i) = 0;                                                   \
+             ((i) < (rtd)->num_cpus + (rtd)->num_codecs) &&             \
+                     ((dai) = (rtd)->dais[i]);                          \
+             (i)++)
+#define for_each_rtd_dais_rollback(rtd, i, dai)         \
+        for (; (--(i) >= 0) && ((dai) = (rtd)->dais[i]);)
+void snd_soc_close_delayed_work(struct snd_soc_pcm_runtime *rtd);
 /* mixer control */
 struct soc_mixer_control {
         int min, max, platform_max;
+        unsigned int reg, rreg, shift, rshift, invert;
+        int reg, rreg;
+        unsigned int shift, rshift;
+        unsigned int sign_bit;
+        unsigned int invert:1;
+        unsigned int autodisable:1;
+#ifdef CONFIG_SND_SOC_TOPOLOGY
+        struct snd_soc_dobj dobj;
+#endif
+};
+struct soc_bytes {
+        int base;
+        int num_regs;
+        u32 mask;
+};
+struct soc_bytes_ext {
+        int max;
+#ifdef CONFIG_SND_SOC_TOPOLOGY
+        struct snd_soc_dobj dobj;
+#endif
+        /* used for TLV byte control */
+        int (*get)(struct snd_kcontrol *kcontrol, unsigned int __user *bytes,
+                        unsigned int size);
+        int (*put)(struct snd_kcontrol *kcontrol, const unsigned int __user *bytes,
+                        unsigned int size);
+};
+/* multi register control */
+struct soc_mreg_control {
+        long min, max;
+        unsigned int regbase, regcount, nbits, invert;
 };
 /* enumerated kcontrol */
 struct soc_enum {
+        unsigned short reg;
+        unsigned short reg2;
+        int reg;
         unsigned char shift_l;
         unsigned char shift_r;
         unsigned int max;
+        unsigned int items;
         unsigned int mask;
         const char **texts;
+        const char * const *texts;
         const unsigned int *values;
+        void *dapm;
+};
+/* codec IO */
+unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg);
+unsigned int snd_soc_write(struct snd_soc_codec *codec,
+                           unsigned int reg, unsigned int val);
+/* device driver data */
+static inline void snd_soc_codec_set_drvdata(struct snd_soc_codec *codec,
+                void *data)
+{
+        dev_set_drvdata(codec->dev, data);
+}
+static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec)
+{
+        return dev_get_drvdata(codec->dev);
+}
+static inline void snd_soc_platform_set_drvdata(struct snd_soc_platform *platform,
+                void *data)
+{
+        dev_set_drvdata(platform->dev, data);
+}
+static inline void *snd_soc_platform_get_drvdata(struct snd_soc_platform *platform)
+{
+        return dev_get_drvdata(platform->dev);
+}
+static inline void snd_soc_pcm_set_drvdata(struct snd_soc_pcm_runtime *rtd,
+                void *data)
+{
+        dev_set_drvdata(&rtd->dev, data);
+}
+static inline void *snd_soc_pcm_get_drvdata(struct snd_soc_pcm_runtime *rtd)
+{
+        return dev_get_drvdata(&rtd->dev);
+}
+static inline void snd_soc_initialize_card_lists(struct snd_soc_card *card)
+{
+        INIT_LIST_HEAD(&card->dai_dev_list);
+        INIT_LIST_HEAD(&card->codec_dev_list);
+        INIT_LIST_HEAD(&card->platform_dev_list);
+        INIT_LIST_HEAD(&card->widgets);
+        INIT_LIST_HEAD(&card->paths);
+        INIT_LIST_HEAD(&card->dapm_list);
+}
+        unsigned int autodisable:1;
+#ifdef CONFIG_SND_SOC_TOPOLOGY
+        struct snd_soc_dobj dobj;
+#endif
+};
+static inline bool snd_soc_volsw_is_stereo(struct soc_mixer_control *mc)
+{
+        if (mc->reg == mc->rreg && mc->shift == mc->rshift)
+                return false;
+        /*
+         * mc->reg == mc->rreg && mc->shift != mc->rshift, or
+         * mc->reg != mc->rreg means that the control is
+         * stereo (bits in one register or in two registers)
+         */
+        return true;
+}
+static inline unsigned int snd_soc_enum_val_to_item(struct soc_enum *e,
+        unsigned int val)
+{
+        unsigned int i;
+        if (!e->values)
+                return val;
+        for (i = 0; i < e->items; i++)
+                if (val == e->values[i])
+                        return i;
+        return 0;
+}
+static inline unsigned int snd_soc_enum_item_to_val(struct soc_enum *e,
+        unsigned int item)
+{
+        if (!e->values)
+                return item;
+        return e->values[item];
+}
+/**
+ * snd_soc_kcontrol_component() - Returns the component that registered the
+ *  control
+ * @kcontrol: The control for which to get the component
+ *
+ * Note: This function will work correctly if the control has been registered
+ * for a component. With snd_soc_add_codec_controls() or via table based
+ * setup for either a CODEC or component driver. Otherwise the behavior is
+ * undefined.
+ */
+static inline struct snd_soc_component *snd_soc_kcontrol_component(
+        struct snd_kcontrol *kcontrol)
+{
+        return snd_kcontrol_chip(kcontrol);
+}
+int snd_soc_util_init(void);
+void snd_soc_util_exit(void);
+int snd_soc_of_parse_card_name(struct snd_soc_card *card,
+                               const char *propname);
+int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
+                                          const char *propname);
+int snd_soc_of_get_slot_mask(struct device_node *np,
+                             const char *prop_name,
+                             unsigned int *mask);
+int snd_soc_of_parse_tdm_slot(struct device_node *np,
+                              unsigned int *tx_mask,
+                              unsigned int *rx_mask,
+                              unsigned int *slots,
+                              unsigned int *slot_width);
+void snd_soc_of_parse_node_prefix(struct device_node *np,
+                                   struct snd_soc_codec_conf *codec_conf,
+                                   struct device_node *of_node,
+                                   const char *propname);
+static inline
+void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
+                                   struct snd_soc_codec_conf *codec_conf,
+                                   struct device_node *of_node,
+                                   const char *propname)
+{
+        snd_soc_of_parse_node_prefix(card->dev->of_node,
+                                     codec_conf, of_node, propname);
+}
+int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
+                                   const char *propname);
+int snd_soc_of_parse_aux_devs(struct snd_soc_card *card, const char *propname);
+unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
+                                     const char *prefix,
+                                     struct device_node **bitclkmaster,
+                                     struct device_node **framemaster);
+int snd_soc_get_dai_id(struct device_node *ep);
+int snd_soc_get_dai_name(struct of_phandle_args *args,
+                         const char **dai_name);
+int snd_soc_of_get_dai_name(struct device_node *of_node,
+                            const char **dai_name);
+int snd_soc_of_get_dai_link_codecs(struct device *dev,
+                                   struct device_node *of_node,
+                                   struct snd_soc_dai_link *dai_link);
+void snd_soc_of_put_dai_link_codecs(struct snd_soc_dai_link *dai_link);
+int snd_soc_add_pcm_runtime(struct snd_soc_card *card,
+                            struct snd_soc_dai_link *dai_link);
+void snd_soc_remove_pcm_runtime(struct snd_soc_card *card,
+                                struct snd_soc_pcm_runtime *rtd);
+struct snd_soc_dai *snd_soc_register_dai(struct snd_soc_component *component,
+                                         struct snd_soc_dai_driver *dai_drv,
+                                         bool legacy_dai_naming);
+struct snd_soc_dai *devm_snd_soc_register_dai(struct device *dev,
+                                              struct snd_soc_component *component,
+                                              struct snd_soc_dai_driver *dai_drv,
+                                              bool legacy_dai_naming);
+void snd_soc_unregister_dai(struct snd_soc_dai *dai);
+struct snd_soc_dai *snd_soc_find_dai(
+        const struct snd_soc_dai_link_component *dlc);
+struct snd_soc_dai *snd_soc_find_dai_with_mutex(
+        const struct snd_soc_dai_link_component *dlc);
 #include <sound/soc-dai.h>
+static inline
+int snd_soc_fixup_dai_links_platform_name(struct snd_soc_card *card,
+                                          const char *platform_name)
+{
+        struct snd_soc_dai_link *dai_link;
+        const char *name;
+        int i;
+        if (!platform_name) /* nothing to do */
+                return 0;
+        /* set platform name for each dailink */
+        for_each_card_prelinks(card, i, dai_link) {
+                name = devm_kstrdup(card->dev, platform_name, GFP_KERNEL);
+                if (!name)
+                        return -ENOMEM;
+                if (!dai_link->platforms)
+                        return -EINVAL;
+                /* only single platform is supported for now */
+                dai_link->platforms->name = name;
+        }
+        return 0;
+}
 #ifdef CONFIG_DEBUG_FS
 …
 #endif
+extern const struct dev_pm_ops snd_soc_pm_ops;
+/* Helper functions */
+static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
+{
+        mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
+}
+static inline void snd_soc_dapm_mutex_unlock(struct snd_soc_dapm_context *dapm)
+{
+        mutex_unlock(&dapm->card->dapm_mutex);
+}
+#include <sound/soc-component.h>
+#include <sound/soc-card.h>
 #endif

GPL/trunk/alsa-kernel/include/sound/soundfont.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_SOUNDFONT_H
 #define __SOUND_SOUNDFONT_H
 …
  *  Copyright (C) 1999 Steve Ratcliffe
  *  Copyright (c) 1999-2000 Takashi iwai <tiwai@suse.de>
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 #include "sfnt_info.h"
 #include "util_mem.h"
+#include <sound/sfnt_info.h>
+#include <sound/util_mem.h>
 #define SF_MAX_INSTRUMENTS      128     /* maximum instrument number */
 …
 int snd_sf_calc_parm_attack(int msec);
 int snd_sf_calc_parm_decay(int msec);
 #define snd_sf_calc_parm_delay(msec) (0x8000 - (msec) * 1000 / 725);
+#define snd_sf_calc_parm_delay(msec) (0x8000 - (msec) * 1000 / 725)
 extern int snd_sf_vol_table[128];
 int snd_sf_linear_to_log(unsigned int amount, int offset, int ratio);

GPL/trunk/alsa-kernel/include/sound/tea575x-tuner.h

-              r426
+              r679
 #include <linux/videodev2.h>
+#include <media/v4l2-ctrls.h>
 #include <media/v4l2-dev.h>
+#include <media/v4l2-ioctl.h>
+#include <media/v4l2-device.h>
+#define TEA575X_FMIF    10700
+#define TEA575X_AMIF      450
+#define TEA575X_DATA    (1 << 0)
+#define TEA575X_CLK     (1 << 1)
+#define TEA575X_WREN    (1 << 2)
+#define TEA575X_MOST    (1 << 3)
 struct snd_tea575x;
 struct snd_tea575x_ops {
+        void (*write)(struct snd_tea575x *tea, unsigned int val);
+        unsigned int (*read)(struct snd_tea575x *tea);
+        void (*mute)(struct snd_tea575x *tea, unsigned int mute);
+        /* Drivers using snd_tea575x must either define read_ and write_val */
+        void (*write_val)(struct snd_tea575x *tea, u32 val);
+        u32 (*read_val)(struct snd_tea575x *tea);
+        /* Or define the 3 pin functions */
+        void (*set_pins)(struct snd_tea575x *tea, u8 pins);
+        u8 (*get_pins)(struct snd_tea575x *tea);
+        void (*set_direction)(struct snd_tea575x *tea, bool output);
 };
 struct snd_tea575x {
+        struct snd_card *card;
+        struct video_device *vd;        /* video device */
+        int dev_nr;                     /* requested device number + 1 */
+        int tea5759;                    /* 5759 chip is present */
+        int mute;                       /* Device is muted? */
+        unsigned int freq_fixup;        /* crystal onboard */
+        struct v4l2_device *v4l2_dev;
+        struct v4l2_file_operations fops;
+        struct video_device vd;         /* video device */
+        int radio_nr;                   /* radio_nr */
+        bool tea5759;                   /* 5759 chip is present */
+        bool has_am;                    /* Device can tune to AM freqs */
+        bool cannot_read_data;          /* Device cannot read the data pin */
+        bool cannot_mute;               /* Device cannot mute */
+        bool mute;                      /* Device is muted? */
+        bool stereo;                    /* receiving stereo */
+        bool tuned;                     /* tuned to a station */
         unsigned int val;               /* hw value */
+        unsigned long freq;             /* frequency */
+        unsigned long in_use;           /* set if the device is in use */
+        u32 band;                       /* 0: FM, 1: FM-Japan, 2: AM */
+        u32 freq;                       /* frequency */
+        struct mutex mutex;
         struct snd_tea575x_ops *ops;
         void *private_data;
+        u8 card[32];
+        u8 bus_info[32];
+        struct v4l2_ctrl_handler ctrl_handler;
+        int (*ext_init)(struct snd_tea575x *tea);
 };
 void snd_tea575x_init(struct snd_tea575x *tea);
+int snd_tea575x_init(struct snd_tea575x *tea, struct module *owner);
 void snd_tea575x_exit(struct snd_tea575x *tea);
+void snd_tea575x_set_freq(struct snd_tea575x *tea);
 #endif /* __SOUND_TEA575X_TUNER_H */

GPL/trunk/alsa-kernel/include/sound/tea6330t.h

-              r398
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_TEA6330T_H
 #define __SOUND_TEA6330T_H
 …
  *  Routines for control of TEA6330T circuit.
  *  Sound fader control circuit for car radios.
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ *
  */
 #include "i2c.h"                /* generic i2c support */
+#include <sound/i2c.h>          /* generic i2c support */
 int snd_tea6330t_detect(struct snd_i2c_bus *bus, int equalizer);

GPL/trunk/alsa-kernel/include/sound/timer.h

-              r399
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_TIMER_H
 #define __SOUND_TIMER_H
 …
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>,
  *                   Abramo Bagnara <abramo@alsa-project.org>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
 …
 #define SNDRV_TIMER_HW_SLAVE    0x00000004      /* only slave timer (variable resolution) */
 #define SNDRV_TIMER_HW_FIRST    0x00000008      /* first tick can be incomplete */
 #define SNDRV_TIMER_HW_TASKLET  0x00000010      /* timer is called from tasklet */
+#define SNDRV_TIMER_HW_WORK     0x00000010      /* timer is called from work */
 #define SNDRV_TIMER_IFLG_SLAVE    0x00000001
 …
 #define SNDRV_TIMER_IFLG_START    0x00000004
 #define SNDRV_TIMER_IFLG_AUTO     0x00000008    /* auto restart */
 #define SNDRV_TIMER_IFLG_FAST     0x00000010    /* fast callback (do not use tasklet) */
+#define SNDRV_TIMER_IFLG_FAST     0x00000010    /* fast callback (do not use work) */
 #define SNDRV_TIMER_IFLG_CALLBACK 0x00000020    /* timer callback is active */
 #define SNDRV_TIMER_IFLG_EXCLUSIVE 0x00000040   /* exclusive owner - no more instances */
 …
         struct list_head ack_list_head;
         struct list_head sack_list_head; /* slow ack list head */
+        struct tasklet_struct task_queue;
+        struct work_struct task_work;
+        int max_instances;      /* upper limit of timer instances */
+        int num_instances;      /* current number of timer instances */
 };
 …
         void (*ccallback) (struct snd_timer_instance * timeri,
                            int event,
                            struct timespec * tstamp,
+                           struct timespec64 * tstamp,
                            unsigned long resolution);
+        void (*disconnect)(struct snd_timer_instance *timeri);
         void *callback_data;
         unsigned long ticks;            /* auto-load ticks when expired */
         unsigned long cticks;           /* current ticks */
         unsigned long pticks;           /* accumulated ticks for callback */
         unsigned long resolution;       /* current resolution for tasklet */
+        unsigned long resolution;       /* current resolution for work */
         unsigned long lost;             /* lost ticks */
         int slave_class;
 …
 int snd_timer_new(struct snd_card *card, char *id, struct snd_timer_id *tid, struct snd_timer **rtimer);
 void snd_timer_notify(struct snd_timer *timer, int event, struct timespec *tstamp);
+void snd_timer_notify(struct snd_timer *timer, int event, struct timespec64 *tstamp);
 int snd_timer_global_new(char *id, int device, struct snd_timer **rtimer);
 int snd_timer_global_free(struct snd_timer *timer);
 int snd_timer_global_register(struct snd_timer *timer);
+int snd_timer_open(struct snd_timer_instance **ti, char *owner, struct snd_timer_id *tid, unsigned int slave_id);
+int snd_timer_close(struct snd_timer_instance *timeri);
+struct snd_timer_instance *snd_timer_instance_new(const char *owner);
+void snd_timer_instance_free(struct snd_timer_instance *timeri);
+int snd_timer_open(struct snd_timer_instance *timeri, struct snd_timer_id *tid, unsigned int slave_id);
+void snd_timer_close(struct snd_timer_instance *timeri);
 unsigned long snd_timer_resolution(struct snd_timer_instance *timeri);
 int snd_timer_start(struct snd_timer_instance *timeri, unsigned int ticks);

GPL/trunk/alsa-kernel/include/sound/tlv.h

-              r598
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_TLV_H
 #define __SOUND_TLV_H
 …
  *  Advanced Linux Sound Architecture - ALSA - Driver
  *  Copyright (c) 2006 by Jaroslav Kysela <perex@perex.cz>
+ *
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
  */
+#include <uapi/sound/tlv.h>
+/* For historical reasons, these macros are aliases to the ones in UAPI. */
+#define TLV_ITEM                        SNDRV_CTL_TLVD_ITEM
+#define TLV_LENGTH                      SNDRV_CTL_TLVD_LENGTH
+#define TLV_CONTAINER_ITEM              SNDRV_CTL_TLVD_CONTAINER_ITEM
+#define DECLARE_TLV_CONTAINER           SNDRV_CTL_TLVD_DECLARE_CONTAINER
+#define TLV_DB_SCALE_MASK               SNDRV_CTL_TLVD_DB_SCALE_MASK
+#define TLV_DB_SCALE_MUTE               SNDRV_CTL_TLVD_DB_SCALE_MUTE
+#define TLV_DB_SCALE_ITEM               SNDRV_CTL_TLVD_DB_SCALE_ITEM
+#define DECLARE_TLV_DB_SCALE            SNDRV_CTL_TLVD_DECLARE_DB_SCALE
+#define TLV_DB_MINMAX_ITEM              SNDRV_CTL_TLVD_DB_MINMAX_ITEM
+#define TLV_DB_MINMAX_MUTE_ITEM         SNDRV_CTL_TLVD_DB_MINMAX_MUTE_ITEM
+#define DECLARE_TLV_DB_MINMAX           SNDRV_CTL_TLVD_DECLARE_DB_MINMAX
+#define DECLARE_TLV_DB_MINMAX_MUTE      SNDRV_CTL_TLVD_DECLARE_DB_MINMAX_MUTE
+#define TLV_DB_LINEAR_ITEM              SNDRV_CTL_TLVD_DB_LINEAR_ITEM
+#define DECLARE_TLV_DB_LINEAR           SNDRV_CTL_TLVD_DECLARE_DB_LINEAR
+#define TLV_DB_RANGE_ITEM               SNDRV_CTL_TLVD_DB_RANGE_ITEM
+#define DECLARE_TLV_DB_RANGE            SNDRV_CTL_TLVD_DECLARE_DB_RANGE
+#define TLV_DB_GAIN_MUTE                SNDRV_CTL_TLVD_DB_GAIN_MUTE
 /*
+ * TLV structure is right behind the struct snd_ctl_tlv:
+ *   unsigned int type          - see SNDRV_CTL_TLVT_*
+ *   unsigned int length
+ *   .... data aligned to sizeof(unsigned int), use
+ *        block_length = (length + (sizeof(unsigned int) - 1)) &
+ *                       ~(sizeof(unsigned int) - 1)) ....
+ * The below assumes that each item TLV is 4 words like DB_SCALE or LINEAR.
+ * This is an old fasion and obsoleted by commit bf1d1c9b6179("ALSA: tlv: add
+ * DECLARE_TLV_DB_RANGE()").
  */
+#define SNDRV_CTL_TLVT_CONTAINER 0      /* one level down - group of TLVs */
+#define SNDRV_CTL_TLVT_DB_SCALE 1       /* dB scale */
+#define SNDRV_CTL_TLVT_DB_LINEAR 2      /* linear volume */
+#define SNDRV_CTL_TLVT_DB_RANGE 3       /* dB range container */
+#define SNDRV_CTL_TLVT_DB_MINMAX 4      /* dB scale with min/max */
+#define SNDRV_CTL_TLVT_DB_MINMAX_MUTE 5 /* dB scale with min/max with mute */
+#define TLV_DB_SCALE_MASK       0xffff
+#define TLV_DB_SCALE_MUTE       0x10000
+#define TLV_DB_SCALE_ITEM(min, step, mute)                      \
+        SNDRV_CTL_TLVT_DB_SCALE, 2 * sizeof(unsigned int),      \
+        (min), ((step) & TLV_DB_SCALE_MASK) | ((mute) ? TLV_DB_SCALE_MUTE : 0)
+#define DECLARE_TLV_DB_SCALE(name, min, step, mute) \
+        unsigned int name[] = { TLV_DB_SCALE_ITEM(min, step, mute) }
+/* dB scale specified with min/max values instead of step */
+#define TLV_DB_MINMAX_ITEM(min_dB, max_dB)                      \
+        SNDRV_CTL_TLVT_DB_MINMAX, 2 * sizeof(unsigned int),     \
+        (min_dB), (max_dB)
+#define TLV_DB_MINMAX_MUTE_ITEM(min_dB, max_dB)                 \
+        SNDRV_CTL_TLVT_DB_MINMAX_MUTE, 2 * sizeof(unsigned int),        \
+        (min_dB), (max_dB)
+#define DECLARE_TLV_DB_MINMAX(name, min_dB, max_dB) \
+        unsigned int name[] = { TLV_DB_MINMAX_ITEM(min_dB, max_dB) }
+#define DECLARE_TLV_DB_MINMAX_MUTE(name, min_dB, max_dB) \
+        unsigned int name[] = { TLV_DB_MINMAX_MUTE_ITEM(min_dB, max_dB) }
+/* linear volume between min_dB and max_dB (.01dB unit) */
+#define TLV_DB_LINEAR_ITEM(min_dB, max_dB)                  \
+        SNDRV_CTL_TLVT_DB_LINEAR, 2 * sizeof(unsigned int), \
+        (min_dB), (max_dB)
+#define DECLARE_TLV_DB_LINEAR(name, min_dB, max_dB)     \
+        unsigned int name[] = { TLV_DB_LINEAR_ITEM(min_dB, max_dB) }
+/* dB range container */
+/* Each item is: <min> <max> <TLV> */
+/* The below assumes that each item TLV is 4 words like DB_SCALE or LINEAR */
+#define TLV_DB_RANGE_HEAD(num)                  \
+#define TLV_DB_RANGE_HEAD(num) \
         SNDRV_CTL_TLVT_DB_RANGE, 6 * (num) * sizeof(unsigned int)
-#define TLV_DB_GAIN_MUTE        -9999999
 #endif /* __SOUND_TLV_H */

GPL/trunk/alsa-kernel/include/sound/util_mem.h

-              r305
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_UTIL_MEM_H
 #define __SOUND_UTIL_MEM_H
 …
+ *
  *  Generic memory management routines for soundcard memory allocation
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */

GPL/trunk/alsa-kernel/include/sound/version.h

r598	r679
1	1	/* include/version.h */
2		#define CONFIG_SND_VERSION "~~1.0.24~~"
	2	#define CONFIG_SND_VERSION "5.10.20"
3	3	#define CONFIG_SND_DATE ""

GPL/trunk/alsa-kernel/include/sound/vx_core.h

-              r399
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 /*
  * Driver for Digigram VX soundcards
 …
+ *
  * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 …
 #include <sound/hwdep.h>
 #include <linux/interrupt.h>
-#if defined(CONFIG_FW_LOADER) || defined(CONFIG_FW_LOADER_MODULE)
-#if !defined(CONFIG_USE_VXLOADER) && !defined(CONFIG_SND_VX_LIB) /* built-in kernel */
-#define SND_VX_FW_LOADER        /* use the standard firmware loader */
-#endif
-#endif
 struct firmware;
 …
         unsigned int references;     /* an output pipe may be used for monitoring and/or playback */
         struct vx_pipe *monitoring_pipe;  /* pointer to the monitoring pipe (capture pipe only)*/
-        struct tasklet_struct start_tq;
 };
 …
         /* low-level functions */
+        struct snd_vx_hardware *hw;
+        struct snd_vx_ops *ops;
+        spinlock_t lock;
+        spinlock_t irq_lock;
+        struct tasklet_struct tq;
+        const struct snd_vx_hardware *hw;
+        const struct snd_vx_ops *ops;
+        struct mutex lock;
         unsigned int chip_status;
 …
  * constructor
  */
+struct vx_core *snd_vx_create(struct snd_card *card, struct snd_vx_hardware *hw,
+                              struct snd_vx_ops *ops, int extra_size);
+struct vx_core *snd_vx_create(struct snd_card *card,
+                              const struct snd_vx_hardware *hw,
+                              const struct snd_vx_ops *ops, int extra_size);
 int snd_vx_setup_firmware(struct vx_core *chip);
 int snd_vx_load_boot_image(struct vx_core *chip, const struct firmware *dsp);
 …
  */
 irqreturn_t snd_vx_irq_handler(int irq, void *dev);
+irqreturn_t snd_vx_threaded_irq_handler(int irq, void *dev);
 /*
 …
  * PM
  */
 int snd_vx_suspend(struct vx_core *card, pm_message_t state);
+int snd_vx_suspend(struct vx_core *card);
 int snd_vx_resume(struct vx_core *card);

GPL/trunk/alsa-kernel/include/sound/wavefront.h

-              r398
+              r679
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 #ifndef __SOUND_WAVEFRONT_H__
 #define __SOUND_WAVEFRONT_H__
 …
+ *
  *  Copyright (c) by Paul Barton-Davis <pbd@op.net>
+ *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
+ *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
+ *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */

/GPL/branches/uniaud32-linux-3.2.102 (added)	merged: 611-614
/GPL/branches/uniaud32-next (added)	merged: 615-678

Context Navigation

Legend:

Download in other formats: