November 2018 - Alsa-devel - mailman.alsa-project.org

[alsa-devel] [PATCH v1 0/3] ASoC: last minute fixes
by Marcel Ziswiler 15 Jan '19

15 Jan '19

This series comes with some last minutes fixes and clean-up. Changes in v1: - Split from the Tegra series as suggested by Mark. - Fix issue in soc-core rather than working around it in tegra_sgtl5000. Marcel Ziswiler (3): ASoC: tegra_sgtl5000: fix device_node refcounting ASoC: soc-core: fix trivial checkpatch issues ASoC: soc-core: fix platform name vs. of_node assignement sound/soc/soc-core.c | 162 ++++++++++++++++++++++++--------------- sound/soc/tegra/tegra_sgtl5000.c | 17 +++- 2 files changed, 116 insertions(+), 63 deletions(-) -- 2.14.4

5 30

[alsa-devel] [snd_hda_intel] snd_hda_intel causes high CPU lockup and system instability if mic disabled in BIOS on Lenovo P50
by Alexander Kappner 07 Jan '19

07 Jan '19

My Lenovo P50 laptop has a BIOS option to disable the microphone. When this option gets chosen, the snd_hda_intel driver causes high CPU load on a single kworker thread, spinning on "process_unsol_events", and system instability. This behavior occurs from the time that the snd_hda_intel module is loaded, irrespective of whether anything is attempting to access the mic. The sound output still works. When in this state, the module cannot be removed cleanly; attempting to remove it (even without rmmod -f) triggers an oops. I have attached two exemplary dmesg outputs. Strangely enough, the exact location of the oops varies, but further up the call chain, I always see process_unsol_events. When the mic is not disabled in the BIOS, the module works stable, regardless whether or not the mic is muted in ALSA. I wasn't able to pinpoint the root cause. Any pointers on where to start? Much appreciated. Best regards Alexander First dmesg: [31592.691573] BUG: unable to handle kernel NULL pointer dereference at 000000000000020c [31592.691600] IP: mux_select+0x1d/0x190 [snd_hda_codec_generic] [31592.691601] PGD 0 P4D 0 [31592.691604] Oops: 0000 [#1] PREEMPT SMP [31592.691606] Modules linked in: snd_hda_codec_hdmi snd_hda_codec_realtek snd_hda_codec_generic snd_hda_intel(-) snd_hda_codec snd_hwdep snd_hda_core snd_pcm snd_timer zfs(PO) zunicode(PO) zlua(PO) nvidia_drm(PO) nvidia_modeset(PO) nvidia(PO) iwlmvm mac80211 qmi_wwan iwlwifi cfg80211 thinkpad_acpi rfkill zcommon(PO) znvpair(PO) zavl(PO) icp(PO) spl(O) sdhci_pci cqhci sdhci mmc_block rtsx_pci_sdmmc rtsx_pci mfd_core [31592.691639] CPU: 3 PID: 11044 Comm: kworker/3:1 Tainted: P O 4.16.0-rc7-00206-gf461da3-dirty #33 [31592.691640] Hardware name: LENOVO 20ENCTO1WW/20ENCTO1WW, BIOS N1EET62W (1.35 ) 11/10/2016 [31592.691643] Workqueue: events process_unsol_events [snd_hda_core] [31592.691647] RIP: 0010:mux_select+0x1d/0x190 [snd_hda_codec_generic] [31592.691648] RSP: 0018:ffffc9000f0dfe08 EFLAGS: 00010292 [31592.691650] RAX: 0000000000000001 RBX: ffff880e44737300 RCX: 00000000ffffffff [31592.691651] RDX: 0000000000000000 RSI: 0000000000000000 RDI: ffff880ee6368800 [31592.691652] RBP: 0000000000000000 R08: 0000000000000f09 R09: 0000000000000000 [31592.691653] R10: 0000000000000018 R11: 0000000000000003 R12: ffff880ee6368800 [31592.691655] R13: 0000000000000000 R14: ffff881053ce6100 R15: 0ffff881053ce610 [31592.691656] FS: 0000000000000000(0000) GS:ffff881053cc0000(0000) knlGS:0000000000000000 [31592.691658] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [31592.691659] CR2: 000000000000020c CR3: 000000000220a004 CR4: 00000000003606e0 [31592.691661] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 [31592.691662] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 [31592.691662] Call Trace: [31592.691668] ? snd_hda_jack_detect_state+0x4b/0x60 [snd_hda_codec] [31592.691672] call_jack_callback.isra.1+0x20/0xa0 [snd_hda_codec] [31592.691676] snd_hda_jack_unsol_event+0x62/0x70 [snd_hda_codec] [31592.691679] process_unsol_events+0x64/0x80 [snd_hda_core] [31592.691682] process_one_work+0x13e/0x380 [31592.691684] worker_thread+0x62/0x3e0 [31592.691686] ? rescuer_thread+0x2d0/0x2d0 [31592.691689] kthread+0x10d/0x140 [31592.691690] ? kthread_bind+0x10/0x10 [31592.691693] ret_from_fork+0x35/0x40 [31592.691695] Code: e2 01 e9 77 fb ff ff c3 66 0f 1f 44 00 00 0f 1f 44 00 00 41 57 41 56 41 55 41 54 49 89 fc 55 53 48 83 ec 08 48 8b af 08 04 00 00 <8b> 85 0c 02 00 00 85 c0 74 73 89 d3 41 89 f5 8d 50 ff 39 d8 89 [31592.691721] RIP: mux_select+0x1d/0x190 [snd_hda_codec_generic] RSP: ffffc9000f0dfe08 [31592.691723] CR2: 000000000000020c [31592.691725] ---[ end trace dee155e55b20eab8 ]--- Second dmesg: [115121.084841] BUG: unable to handle kernel NULL pointer dereference at 00000000000005f8 [115121.084844] PGD 0 P4D 0 [115121.084847] Oops: 0000 [#1] PREEMPT SMP [115121.084850] CPU: 2 PID: 12228 Comm: kworker/2:1 Tainted: P O 4.18.0-rc2-00223-g1904148-dirty #39 [115121.084851] Hardware name: LENOVO 20ENCTO1WW/20ENCTO1WW, BIOS N1EET62W (1.35 ) 11/10/2016 [115121.084856] Workqueue: events process_unsol_events [snd_hda_core] [115121.084859] RIP: 0010:set_path_power+0x24/0x120 [snd_hda_codec_generic] [115121.084860] Code: 66 0f 1f 44 00 00 0f 1f 44 00 00 41 57 41 89 f7 41 56 41 55 41 54 55 48 89 fd 53 48 83 ec 08 4c 8b b7 08 04 00 00 89 54 24 04 <41> 8b be f8 05 00 00 49 8b b6 08 06 00 00 85 ff 0f 84 ce 00 00 00 [115121.084901] RSP: 0018:ffffc900243e3de8 EFLAGS: 00010296 [115121.084903] RAX: 0000000000000000 RBX: 0000000000000018 RCX: 00000000ffffffff [115121.084904] RDX: 0000000000000000 RSI: 0000000000000018 RDI: ffff880f993a2800 [115121.084906] RBP: ffff880f993a2800 R08: 0000000000000f09 R09: 0000000000000000 [115121.084907] R10: 0000000000000019 R11: 0000000000000000 R12: 0000000000000000 [115121.084908] R13: 0000000000000000 R14: 0000000000000000 R15: 0000000000000018 [115121.084910] FS: 0000000000000000(0000) GS:ffff881053c80000(0000) knlGS:0000000000000000 [115121.084911] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [115121.084912] CR2: 00000000000005f8 CR3: 000000000260a004 CR4: 00000000003606e0 [115121.084914] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 [115121.084915] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 [115121.084916] Call Trace: [115121.084922] pin_power_callback+0x4f/0x80 [snd_hda_codec_generic] [115121.084926] call_jack_callback.isra.1+0x20/0xa0 [snd_hda_codec] [115121.084930] snd_hda_jack_unsol_event+0x62/0x70 [snd_hda_codec] [115121.084933] process_unsol_events+0x64/0x80 [snd_hda_core] [115121.084937] process_one_work+0x157/0x390 [115121.084939] worker_thread+0x64/0x3e0 [115121.084942] ? rescuer_thread+0x2e0/0x2e0 [115121.084944] kthread+0x10d/0x140 [115121.084946] ? kthread_bind+0x10/0x10 [115121.084948] ret_from_fork+0x35/0x40 [115121.084951] Modules linked in: snd_hda_codec_hdmi snd_hda_codec_realtek snd_hda_codec_generic snd_hda_intel(-) snd_hda_codec snd_hwdep snd_hda_core snd_pcm snd_timer tun nvidia_modeset(PO) nvidia(PO) iwlmvm mac80211 iwlwifi btusb btrtl btbcm btintel bluetooth cfg80211 qmi_wwan ecdh_generic thinkpad_acpi rfkill sdhci_pci cqhci sdhci mmc_block rtsx_pci_sdmmc rtsx_pci mfd_core [115121.084969] CR2: 00000000000005f8 [115121.084971] ---[ end trace 010d684599325728 ]--- [115121.084975] RIP: 0010:set_path_power+0x24/0x120 [snd_hda_codec_generic] [115121.084976] Code: 66 0f 1f 44 00 00 0f 1f 44 00 00 41 57 41 89 f7 41 56 41 55 41 54 55 48 89 fd 53 48 83 ec 08 4c 8b b7 08 04 00 00 89 54 24 04 <41> 8b be f8 05 00 00 49 8b b6 08 06 00 00 85 ff 0f 84 ce 00 00 00 [115121.085000] RSP: 0018:ffffc900243e3de8 EFLAGS: 00010296 [115121.085001] RAX: 0000000000000000 RBX: 0000000000000018 RCX: 00000000ffffffff [115121.085002] RDX: 0000000000000000 RSI: 0000000000000018 RDI: ffff880f993a2800 [115121.085003] RBP: ffff880f993a2800 R08: 0000000000000f09 R09: 0000000000000000 [115121.085004] R10: 0000000000000019 R11: 0000000000000000 R12: 0000000000000000 [115121.085005] R13: 0000000000000000 R14: 0000000000000000 R15: 0000000000000018 [115121.085006] FS: 0000000000000000(0000) GS:ffff881053c80000(0000) knlGS:0000000000000000 [115121.085007] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [115121.085008] CR2: 00000000000005f8 CR3: 000000000260a004 CR4: 00000000003606e0 [115121.085009] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 [115121.085010] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400

2 6

[alsa-devel] Need help fixing pop/click artifacts in an ASOC driver
by Dimitris Papavasiliou 05 Jan '19

05 Jan '19

Hi, A (commercial) DAC board, I use with a Raspberry Pi is plagued by clicks and pops and I'm trying to fix it at the driver level. I have mostly fixed it, but I could use some guidance on the problem described below. I apologize in advance for the long read, but the situation is a bit convoluted (or my understanding of it is). The board (a HifiBerry DAC+ Pro) uses a PCM5122 chip which is driven by the pcm512x codec driver, but the Pro version also includes a set of external clocks on the board (one each for 48Khz and 44.1Khz sample rates and multiples thereof). There are two kinds of clicks and pops: on the one hand the board clicks when the device is opened/closed, mostly because the pcm512x codec driver doesn't support the digital_mute operation. These are relatively mild clicks, which are an annoyance at most and I have a separate patch for the pcm512x, that addresses them, which I'm currently testing and will (hopefully) submit soon. A separate case is a pop that's generated when the clock source is changed. This pop is independent of the digital volume setting and very loud. As far as I could determine, when the hw_params callback specified in the snd_soc_dai_link struct is called, it figures out what clock is needed for the giver sample rate and powers the appropriate clock through a GPIO on the PCM5122. This essentially means that the external clock source fed into the 5122 is stopped and restarted at a different rate, potentially while the DAC chip is operating. Later the hw_params callback defined in the pcm512x driver is called and it reconfigure the clock dividers for the new rate. It is at this point that the pop seems to be generated, provided that the card is not powered down or muted. If I comment out either the clock power-up/down in the dai_link hw_params, or the clock divider reconfiguration in the codec's hw_params, no pop is generated. Now, the digital_mute patch described before, also happens to fix this loud pop. I'm not sure whether that's a happy coincidence that might cease to be the case in the future though and was considering fixing the pop problem separately, at its source: the clock change. One way to fix the problem is to switch the 5122 into standby before changing the clock source in the dai_link hw_params callback and switch it back into normal operation afterwards. This seems to work regardless of whether digital_mute is implemented or not, but has the following problem: The register that's used to put the chip into/out of standby, is also used by the pcm512x driver, in the set_bias_level operation. Since the hw_params operation is, as far as I can tell, not atomic, I'm concerned that race conditions may arise, causing the card to be left powered up, when it should be off and vice-versa. Is there some way to synchronize the use of common chip registers in the DAI and codec drivers? Is the digital_mute somehow guaranteed to fix the pop originating at the DAI/machine driver level (whatever the hw_params operation in the dai_link struct is supposed to be)? Am I perhaps missing something entirely? Any help or guidance is welcome. Thanks, Dimitris

5 41

[alsa-devel] [PATCH v2] staging: bcm2835-audio: interpolate audio delay
by Mike Brady 01 Jan '19

01 Jan '19

When the BCM2835 audio output is used, userspace sees a jitter up to 10ms in the audio position, aka "delay" -- the number of frames that must be output before a new frame would be played. Make this a bit nicer for userspace by interpolating the position using the CPU clock. The overhead is small -- an extra ktime_get() every time a GPU message is sent -- and another call and a few calculations whenever the delay is sought from userland. At 48,000 frames per second, i.e. approximately 20 microseconds per frame, it would take a clock inaccuracy of 20 microseconds in 10 milliseconds -- 2,000 parts per million -- to result in an inaccurate estimate, whereas crystal- or resonator-based clocks typically have an inaccuracy of 10s to 100s of parts per million. Signed-off-by: Mike Brady <mikebrady(a)eircom.net> --- Changes in v2 -- remove inappropriate addition of SNDRV_PCM_INFO_BATCH flag .../vc04_services/bcm2835-audio/bcm2835-pcm.c | 20 +++++++++++++++++++ .../vc04_services/bcm2835-audio/bcm2835.h | 1 + 2 files changed, 21 insertions(+) diff --git a/drivers/staging/vc04_services/bcm2835-audio/bcm2835-pcm.c b/drivers/staging/vc04_services/bcm2835-audio/bcm2835-pcm.c index e66da11af5cf..9053b996cada 100644 --- a/drivers/staging/vc04_services/bcm2835-audio/bcm2835-pcm.c +++ b/drivers/staging/vc04_services/bcm2835-audio/bcm2835-pcm.c @@ -74,6 +74,7 @@ void bcm2835_playback_fifo(struct bcm2835_alsa_stream *alsa_stream, atomic_set(&alsa_stream->pos, pos); alsa_stream->period_offset += bytes; + alsa_stream->interpolate_start = ktime_get(); if (alsa_stream->period_offset >= alsa_stream->period_size) { alsa_stream->period_offset %= alsa_stream->period_size; snd_pcm_period_elapsed(substream); @@ -243,6 +244,7 @@ static int snd_bcm2835_pcm_prepare(struct snd_pcm_substream *substream) atomic_set(&alsa_stream->pos, 0); alsa_stream->period_offset = 0; alsa_stream->draining = false; + alsa_stream->interpolate_start = ktime_get(); return 0; } @@ -292,6 +294,24 @@ snd_bcm2835_pcm_pointer(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct bcm2835_alsa_stream *alsa_stream = runtime->private_data; + ktime_t now = ktime_get(); + + /* Give userspace better delay reporting by interpolating between GPU + * notifications, assuming audio speed is close enough to the clock + * used for ktime + */ + + if ((ktime_to_ns(alsa_stream->interpolate_start)) && + (ktime_compare(alsa_stream->interpolate_start, now) < 0)) { + u64 interval = + (ktime_to_ns(ktime_sub(now, + alsa_stream->interpolate_start))); + u64 frames_output_in_interval = + div_u64((interval * runtime->rate), 1000000000); + snd_pcm_sframes_t frames_output_in_interval_sized = + -frames_output_in_interval; + runtime->delay = frames_output_in_interval_sized; + } return snd_pcm_indirect_playback_pointer(substream, &alsa_stream->pcm_indirect, diff --git a/drivers/staging/vc04_services/bcm2835-audio/bcm2835.h b/drivers/staging/vc04_services/bcm2835-audio/bcm2835.h index e13435d1c205..595ad584243f 100644 --- a/drivers/staging/vc04_services/bcm2835-audio/bcm2835.h +++ b/drivers/staging/vc04_services/bcm2835-audio/bcm2835.h @@ -78,6 +78,7 @@ struct bcm2835_alsa_stream { unsigned int period_offset; unsigned int buffer_size; unsigned int period_size; + ktime_t interpolate_start; struct bcm2835_audio_instance *instance; int idx; -- 2.17.1

4 17

[alsa-devel] [PATCH 0/6] ASoC: rt5651: Various fixes and quirks
by Hans de Goede 24 Dec '18

24 Dec '18

Hi All, Here is my last (big) round of (Intel) rt5651 support updates, with these patches combined with the updated, matching UCM profiles from here: https://github.com/jwrdegoede/alsa-lib/commits/master All 7 different devices I have work 100% OOTB, without requiring any manual config or mixer setup. After this there should be no more big changes. I will submit the matching alsa-lib UCM profile changes upstream once this set is in -next (and thus I can be sure the long-names will not change due to review). Note that unfortunately my previous round of cleanup patches removed 1 input mapping (of the 3 mappings in total it removed) which is actually necessary. So this series re-introduces that 1 mapping. I did not notice this before because UCM input profile switching does not work reliably for some reason, something which I still need to investigate. This time I manually veryfied that the correct / expected mixer settings where used while testing. Regards, Hans

4 23

[alsa-devel] [PATCH 1/3] mfd: cros_ec: Add commands to control codec
by Cheng-Yi Chiang 24 Dec '18

24 Dec '18

Add EC host commands to control codec on EC. Signed-off-by: Cheng-Yi Chiang <cychiang(a)chromium.org> --- include/linux/mfd/cros_ec_commands.h | 94 ++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+) diff --git a/include/linux/mfd/cros_ec_commands.h b/include/linux/mfd/cros_ec_commands.h index 07fe4ea0361d3..a3ac792f4915b 100644 --- a/include/linux/mfd/cros_ec_commands.h +++ b/include/linux/mfd/cros_ec_commands.h @@ -4077,6 +4077,100 @@ struct __ec_align1 ec_response_i2c_passthru_protect { uint8_t status; /* Status flags (0: unlocked, 1: locked) */ }; +/*****************************************************************************/ +/* Commands for I2S recording on audio codec. */ + +#define EC_CMD_CODEC_I2S 0x00BC + +enum ec_codec_i2s_subcmd { + EC_CODEC_SET_SAMPLE_DEPTH = 0x0, + EC_CODEC_SET_GAIN = 0x1, + EC_CODEC_GET_GAIN = 0x2, + EC_CODEC_I2S_ENABLE = 0x3, + EC_CODEC_I2S_SET_CONFIG = 0x4, + EC_CODEC_I2S_SET_TDM_CONFIG = 0x5, + EC_CODEC_I2S_SET_BCLK = 0x6, +}; + +enum ec_sample_depth_value { + EC_CODEC_SAMPLE_DEPTH_16 = 0, + EC_CODEC_SAMPLE_DEPTH_24 = 1, +}; + +enum ec_i2s_config { + EC_DAI_FMT_I2S = 0, + EC_DAI_FMT_RIGHT_J = 1, + EC_DAI_FMT_LEFT_J = 2, + EC_DAI_FMT_PCM_A = 3, + EC_DAI_FMT_PCM_B = 4, + EC_DAI_FMT_PCM_TDM = 5, +}; + +struct ec_param_codec_i2s { + /* + * enum ec_codec_i2s_subcmd + */ + uint8_t cmd; + union { + /* + * EC_CODEC_SET_SAMPLE_DEPTH + * Value should be one of ec_sample_depth_value. + */ + uint8_t depth; + + /* + * EC_CODEC_SET_GAIN + * Value should be 0~43 for both channels. + */ + struct ec_param_codec_i2s_set_gain { + uint8_t left; + uint8_t right; + } __packed gain; + + /* + * EC_CODEC_I2S_ENABLE + * 1 to enable, 0 to disable. + */ + uint8_t i2s_enable; + + /* + * EC_CODEC_I2S_SET_COFNIG + * Value should be one of ec_i2s_config. + */ + uint8_t i2s_config; + + /* + * EC_CODEC_I2S_SET_TDM_CONFIG + * Value should be one of ec_i2s_config. + */ + struct ec_param_codec_i2s_tdm { + /* + * 0 to 496 + */ + int16_t ch0_delay; + /* + * -1 to 496 + */ + int16_t ch1_delay; + uint8_t adjacent_to_ch0; + uint8_t adjacent_to_ch1; + } __packed tdm_param; + + /* + * EC_CODEC_I2S_SET_BCLK + */ + uint32_t bclk; + }; +} __packed; + +/* + * For subcommand EC_CODEC_GET_GAIN. + */ +struct ec_response_codec_gain { + uint8_t left; + uint8_t right; +} __packed; + /*****************************************************************************/ /* System commands */ -- 2.20.0.rc0.387.gc7a69e6b6c-goog

3 12

[alsa-devel] [PATCH v3] ASoC: AMD: Fix race condition between register access
by Agrawal, Akshu 19 Dec '18

19 Dec '18

During simultaneous running of playback and capture, we got hit by incorrect value write on common register. This was due to race condition between 2 streams. Fixing this by locking the common register access. Signed-off-by: Akshu Agrawal <akshu.agrawal(a)amd.com> --- v2: Added 2 helper functions, removed locking in ch enable/disable as they are separate registers. v3: Modified helper acp_reg_read_mod_write, moved pte locks to helper sound/soc/amd/acp-pcm-dma.c | 66 ++++++++++++++++++++++++++++++--------------- 1 file changed, 44 insertions(+), 22 deletions(-) diff --git a/sound/soc/amd/acp-pcm-dma.c b/sound/soc/amd/acp-pcm-dma.c index 0ac4b5b..0d4c2eb 100644 --- a/sound/soc/amd/acp-pcm-dma.c +++ b/sound/soc/amd/acp-pcm-dma.c @@ -121,6 +121,9 @@ .periods_max = CAPTURE_MAX_NUM_PERIODS, }; +/* Lock to protect access to registers */ +static DEFINE_SPINLOCK(lock); + static u32 acp_reg_read(void __iomem *acp_mmio, u32 reg) { return readl(acp_mmio + (reg * 4)); @@ -131,6 +134,31 @@ static void acp_reg_write(u32 val, void __iomem *acp_mmio, u32 reg) writel(val, acp_mmio + (reg * 4)); } +static void acp_reg_write_srbm_targ(void __iomem *acp_mmio, + u32 addr, u32 data) +{ + unsigned long flags; + + spin_lock_irqsave(&lock, flags); + acp_reg_write(addr, acp_mmio, mmACP_SRBM_Targ_Idx_Addr); + acp_reg_write(data, acp_mmio, mmACP_SRBM_Targ_Idx_Data); + spin_unlock_irqrestore(&lock, flags); +} + +static void acp_reg_read_mod_write(void __iomem *acp_mmio, u32 addr, + u32 mask, u32 value) +{ + u32 val; + unsigned long flags; + + spin_lock_irqsave(&lock, flags); + val = acp_reg_read(acp_mmio, addr); + val &= ~mask; + val |= (mask & value); + acp_reg_write(val, acp_mmio, addr); + spin_unlock_irqrestore(&lock, flags); +} + /* * Configure a given dma channel parameters - enable/disable, * number of descriptors, priority @@ -172,15 +200,12 @@ static void config_dma_descriptor_in_sram(void __iomem *acp_mmio, sram_offset = (descr_idx * sizeof(acp_dma_dscr_transfer_t)); /* program the source base address. */ - acp_reg_write(sram_offset, acp_mmio, mmACP_SRBM_Targ_Idx_Addr); - acp_reg_write(descr_info->src, acp_mmio, mmACP_SRBM_Targ_Idx_Data); + acp_reg_write_srbm_targ(acp_mmio, sram_offset, descr_info->src); /* program the destination base address. */ - acp_reg_write(sram_offset + 4, acp_mmio, mmACP_SRBM_Targ_Idx_Addr); - acp_reg_write(descr_info->dest, acp_mmio, mmACP_SRBM_Targ_Idx_Data); - + acp_reg_write_srbm_targ(acp_mmio, sram_offset + 4, descr_info->dest); /* program the number of bytes to be transferred for this descriptor. */ - acp_reg_write(sram_offset + 8, acp_mmio, mmACP_SRBM_Targ_Idx_Addr); - acp_reg_write(descr_info->xfer_val, acp_mmio, mmACP_SRBM_Targ_Idx_Data); + acp_reg_write_srbm_targ(acp_mmio, sram_offset + 8, + descr_info->xfer_val); } static void pre_config_reset(void __iomem *acp_mmio, u16 ch_num) @@ -311,24 +336,22 @@ static void acp_pte_config(void __iomem *acp_mmio, struct page *pg, u32 offset; offset = ACP_DAGB_GRP_SRBM_SRAM_BASE_OFFSET + (pte_offset * 8); + for (page_idx = 0; page_idx < (num_of_pages); page_idx++) { /* Load the low address of page int ACP SRAM through SRBM */ - acp_reg_write((offset + (page_idx * 8)), - acp_mmio, mmACP_SRBM_Targ_Idx_Addr); addr = page_to_phys(pg); low = lower_32_bits(addr); high = upper_32_bits(addr); - acp_reg_write(low, acp_mmio, mmACP_SRBM_Targ_Idx_Data); + acp_reg_write_srbm_targ(acp_mmio, (offset + (page_idx * 8)), + low); /* Load the High address of page int ACP SRAM through SRBM */ - acp_reg_write((offset + (page_idx * 8) + 4), - acp_mmio, mmACP_SRBM_Targ_Idx_Addr); - /* page enable in ACP */ high |= BIT(31); - acp_reg_write(high, acp_mmio, mmACP_SRBM_Targ_Idx_Data); + acp_reg_write_srbm_targ(acp_mmio, (offset + (page_idx * 8) + 4), + high); /* Move to next physically contiguos page */ pg++; @@ -870,29 +893,28 @@ static int acp_dma_hw_params(struct snd_pcm_substream *substream, } } if (adata->asic_type == CHIP_STONEY) { - val = acp_reg_read(adata->acp_mmio, - mmACP_I2S_16BIT_RESOLUTION_EN); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { switch (rtd->i2s_instance) { case I2S_BT_INSTANCE: - val |= ACP_I2S_BT_16BIT_RESOLUTION_EN; + val = ACP_I2S_BT_16BIT_RESOLUTION_EN; break; case I2S_SP_INSTANCE: default: - val |= ACP_I2S_SP_16BIT_RESOLUTION_EN; + val = ACP_I2S_SP_16BIT_RESOLUTION_EN; } } else { switch (rtd->i2s_instance) { case I2S_BT_INSTANCE: - val |= ACP_I2S_BT_16BIT_RESOLUTION_EN; + val = ACP_I2S_BT_16BIT_RESOLUTION_EN; break; case I2S_SP_INSTANCE: default: - val |= ACP_I2S_MIC_16BIT_RESOLUTION_EN; + val = ACP_I2S_MIC_16BIT_RESOLUTION_EN; } } - acp_reg_write(val, adata->acp_mmio, - mmACP_I2S_16BIT_RESOLUTION_EN); + acp_reg_read_mod_write(adata->acp_mmio, + mmACP_I2S_16BIT_RESOLUTION_EN, + val, val); } if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { -- 1.9.1

2 2

[alsa-devel] [Xen-devel][PATCH v2 1/3] xen: Introduce shared buffer helpers for page directory...
by Oleksandr Andrushchenko 18 Dec '18

18 Dec '18

From: Oleksandr Andrushchenko <oleksandr_andrushchenko(a)epam.com> based frontends. Currently the frontends which implement similar code for sharing big buffers between frontend and backend are para-virtualized DRM and sound drivers. Both define the same way to share grant references of a data buffer with the corresponding backend with little differences. Move shared code into a helper module, so there is a single implementation of the same functionality for all. This patch introduces code which is used by sound and display frontend drivers without functional changes with the intention to remove shared code from the corresponding drivers. Signed-off-by: Oleksandr Andrushchenko <oleksandr_andrushchenko(a)epam.com> --- drivers/xen/Kconfig | 3 + drivers/xen/Makefile | 1 + drivers/xen/xen-front-pgdir-shbuf.c | 553 ++++++++++++++++++++++++++++ include/xen/xen-front-pgdir-shbuf.h | 89 +++++ 4 files changed, 646 insertions(+) create mode 100644 drivers/xen/xen-front-pgdir-shbuf.c create mode 100644 include/xen/xen-front-pgdir-shbuf.h diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig index 815b9e9bb975..838b66a9a0e7 100644 --- a/drivers/xen/Kconfig +++ b/drivers/xen/Kconfig @@ -340,4 +340,7 @@ config XEN_SYMS config XEN_HAVE_VPMU bool +config XEN_FRONT_PGDIR_SHBUF + tristate + endmenu diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile index 3e542f60f29f..c48927a58e10 100644 --- a/drivers/xen/Makefile +++ b/drivers/xen/Makefile @@ -44,3 +44,4 @@ xen-gntdev-y := gntdev.o xen-gntdev-$(CONFIG_XEN_GNTDEV_DMABUF) += gntdev-dmabuf.o xen-gntalloc-y := gntalloc.o xen-privcmd-y := privcmd.o privcmd-buf.o +obj-$(CONFIG_XEN_FRONT_PGDIR_SHBUF) += xen-front-pgdir-shbuf.o diff --git a/drivers/xen/xen-front-pgdir-shbuf.c b/drivers/xen/xen-front-pgdir-shbuf.c new file mode 100644 index 000000000000..48a658dc7ccf --- /dev/null +++ b/drivers/xen/xen-front-pgdir-shbuf.c @@ -0,0 +1,553 @@ +// SPDX-License-Identifier: GPL-2.0 OR MIT + +/* + * Xen frontend/backend page directory based shared buffer + * helper module. + * + * Copyright (C) 2018 EPAM Systems Inc. + * + * Author: Oleksandr Andrushchenko <oleksandr_andrushchenko(a)epam.com> + */ + +#include <linux/module.h> +#include <linux/errno.h> +#include <linux/mm.h> + +#include <asm/xen/hypervisor.h> +#include <xen/balloon.h> +#include <xen/xen.h> +#include <xen/xenbus.h> +#include <xen/interface/io/ring.h> + +#include <xen/xen-front-pgdir-shbuf.h> + +#ifndef GRANT_INVALID_REF +/* + * FIXME: usage of grant reference 0 as invalid grant reference: + * grant reference 0 is valid, but never exposed to a PV driver, + * because of the fact it is already in use/reserved by the PV console. + */ +#define GRANT_INVALID_REF 0 +#endif + +/** + * This structure represents the structure of a shared page + * that contains grant references to the pages of the shared + * buffer. This structure is common to many Xen para-virtualized + * protocols at include/xen/interface/io/ + */ +struct xen_page_directory { + grant_ref_t gref_dir_next_page; + grant_ref_t gref[1]; /* Variable length */ +}; + +/** + * Shared buffer ops which are differently implemented + * depending on the allocation mode, e.g. if the buffer + * is allocated by the corresponding backend or frontend. + * Some of the operations. + */ +struct xen_front_pgdir_shbuf_ops { + /* + * Calculate number of grefs required to handle this buffer, + * e.g. if grefs are required for page directory only or the buffer + * pages as well. + */ + void (*calc_num_grefs)(struct xen_front_pgdir_shbuf *buf); + + /* Fill page directory according to para-virtual display protocol. */ + void (*fill_page_dir)(struct xen_front_pgdir_shbuf *buf); + + /* Claim grant references for the pages of the buffer. */ + int (*grant_refs_for_buffer)(struct xen_front_pgdir_shbuf *buf, + grant_ref_t *priv_gref_head, int gref_idx); + + /* Map grant references of the buffer. */ + int (*map)(struct xen_front_pgdir_shbuf *buf); + + /* Unmap grant references of the buffer. */ + int (*unmap)(struct xen_front_pgdir_shbuf *buf); +}; + +/** + * Get granted reference to the very first page of the + * page directory. Usually this is passed to the backend, + * so it can find/fill the grant references to the buffer's + * pages. + * + * \param buf shared buffer which page directory is of interest. + * \return granted reference to the very first page of the + * page directory. + */ +grant_ref_t +xen_front_pgdir_shbuf_get_dir_start(struct xen_front_pgdir_shbuf *buf) +{ + if (!buf->grefs) + return GRANT_INVALID_REF; + + return buf->grefs[0]; +} +EXPORT_SYMBOL_GPL(xen_front_pgdir_shbuf_get_dir_start); + +/** + * Map granted references of the shared buffer. + * + * Depending on the shared buffer mode of allocation + * (be_alloc flag) this can either do nothing (for buffers + * shared by the frontend itself) or map the provided granted + * references onto the backing storage (buf->pages). + * + * \param buf shared buffer which grants to be maped. + * \return zero on success or a negative number on failure. + */ +int xen_front_pgdir_shbuf_map(struct xen_front_pgdir_shbuf *buf) +{ + if (buf->ops && buf->ops->map) + return buf->ops->map(buf); + + /* No need to map own grant references. */ + return 0; +} +EXPORT_SYMBOL_GPL(xen_front_pgdir_shbuf_map); + +/** + * Unmap granted references of the shared buffer. + * + * Depending on the shared buffer mode of allocation + * (be_alloc flag) this can either do nothing (for buffers + * shared by the frontend itself) or unmap the provided granted + * references. + * + * \param buf shared buffer which grants to be unmaped. + * \return zero on success or a negative number on failure. + */ +int xen_front_pgdir_shbuf_unmap(struct xen_front_pgdir_shbuf *buf) +{ + if (buf->ops && buf->ops->unmap) + return buf->ops->unmap(buf); + + /* No need to unmap own grant references. */ + return 0; +} +EXPORT_SYMBOL_GPL(xen_front_pgdir_shbuf_unmap); + +/** + * Free all the resources of the shared buffer. + * + * \param buf shared buffer which resources to be freed. + */ +void xen_front_pgdir_shbuf_free(struct xen_front_pgdir_shbuf *buf) +{ + if (buf->grefs) { + int i; + + for (i = 0; i < buf->num_grefs; i++) + if (buf->grefs[i] != GRANT_INVALID_REF) + gnttab_end_foreign_access(buf->grefs[i], + 0, 0UL); + } + kfree(buf->grefs); + kfree(buf->directory); +} +EXPORT_SYMBOL_GPL(xen_front_pgdir_shbuf_free); + +/* + * Number of grefs a page can hold with respect to the + * struct xen_page_directory header. + */ +#define XEN_NUM_GREFS_PER_PAGE ((PAGE_SIZE - \ + offsetof(struct xen_page_directory, \ + gref)) / sizeof(grant_ref_t)) + +/** + * Get the number of pages the page directory consumes itself. + * + * \param buf shared buffer. + */ +static int get_num_pages_dir(struct xen_front_pgdir_shbuf *buf) +{ + return DIV_ROUND_UP(buf->num_pages, XEN_NUM_GREFS_PER_PAGE); +} + +/** + * Calculate the number of grant references needed to share the buffer + * and its pages when backend allocates the buffer. + * + * \param buf shared buffer. + */ +static void backend_calc_num_grefs(struct xen_front_pgdir_shbuf *buf) +{ + /* Only for pages the page directory consumes itself. */ + buf->num_grefs = get_num_pages_dir(buf); +} + +/** + * Calculate the number of grant references needed to share the buffer + * and its pages when frontend allocates the buffer. + * + * \param buf shared buffer. + */ +static void guest_calc_num_grefs(struct xen_front_pgdir_shbuf *buf) +{ + /* + * Number of pages the page directory consumes itself + * plus grefs for the buffer pages. + */ + buf->num_grefs = get_num_pages_dir(buf) + buf->num_pages; +} + +#define xen_page_to_vaddr(page) \ + ((uintptr_t)pfn_to_kaddr(page_to_xen_pfn(page))) + +/** + * Unmap the buffer previously mapped with grant references + * provided by the backend. + * + * \param buf shared buffer. + * \return zero on success or a negative number on failure. + */ +static int backend_unmap(struct xen_front_pgdir_shbuf *buf) +{ + struct gnttab_unmap_grant_ref *unmap_ops; + int i, ret; + + if (!buf->pages || !buf->backend_map_handles || !buf->grefs) + return 0; + + unmap_ops = kcalloc(buf->num_pages, sizeof(*unmap_ops), + GFP_KERNEL); + if (!unmap_ops) + return -ENOMEM; + + for (i = 0; i < buf->num_pages; i++) { + phys_addr_t addr; + + addr = xen_page_to_vaddr(buf->pages[i]); + gnttab_set_unmap_op(&unmap_ops[i], addr, GNTMAP_host_map, + buf->backend_map_handles[i]); + } + + ret = gnttab_unmap_refs(unmap_ops, NULL, buf->pages, + buf->num_pages); + + for (i = 0; i < buf->num_pages; i++) { + if (unlikely(unmap_ops[i].status != GNTST_okay)) + dev_err(&buf->xb_dev->dev, + "Failed to unmap page %d: %d\n", + i, unmap_ops[i].status); + } + + if (ret) + dev_err(&buf->xb_dev->dev, + "Failed to unmap grant references, ret %d", ret); + + kfree(unmap_ops); + kfree(buf->backend_map_handles); + buf->backend_map_handles = NULL; + return ret; +} + +/** + * Map the buffer with grant references provided by the backend. + * + * \param buf shared buffer. + * \return zero on success or a negative number on failure. + */ +static int backend_map(struct xen_front_pgdir_shbuf *buf) +{ + struct gnttab_map_grant_ref *map_ops = NULL; + unsigned char *ptr; + int ret, cur_gref, cur_dir_page, cur_page, grefs_left; + + map_ops = kcalloc(buf->num_pages, sizeof(*map_ops), GFP_KERNEL); + if (!map_ops) + return -ENOMEM; + + buf->backend_map_handles = kcalloc(buf->num_pages, + sizeof(*buf->backend_map_handles), + GFP_KERNEL); + if (!buf->backend_map_handles) { + kfree(map_ops); + return -ENOMEM; + } + + /* + * Read page directory to get grefs from the backend: for external + * buffer we only allocate buf->grefs for the page directory, + * so buf->num_grefs has number of pages in the page directory itself. + */ + ptr = buf->directory; + grefs_left = buf->num_pages; + cur_page = 0; + for (cur_dir_page = 0; cur_dir_page < buf->num_grefs; cur_dir_page++) { + struct xen_page_directory *page_dir = + (struct xen_page_directory *)ptr; + int to_copy = XEN_NUM_GREFS_PER_PAGE; + + if (to_copy > grefs_left) + to_copy = grefs_left; + + for (cur_gref = 0; cur_gref < to_copy; cur_gref++) { + phys_addr_t addr; + + addr = xen_page_to_vaddr(buf->pages[cur_page]); + gnttab_set_map_op(&map_ops[cur_page], addr, + GNTMAP_host_map, + page_dir->gref[cur_gref], + buf->xb_dev->otherend_id); + cur_page++; + } + + grefs_left -= to_copy; + ptr += PAGE_SIZE; + } + ret = gnttab_map_refs(map_ops, NULL, buf->pages, buf->num_pages); + + /* Save handles even if error, so we can unmap. */ + for (cur_page = 0; cur_page < buf->num_pages; cur_page++) { + buf->backend_map_handles[cur_page] = map_ops[cur_page].handle; + if (unlikely(map_ops[cur_page].status != GNTST_okay)) + dev_err(&buf->xb_dev->dev, + "Failed to map page %d: %d\n", + cur_page, map_ops[cur_page].status); + } + + if (ret) { + dev_err(&buf->xb_dev->dev, + "Failed to map grant references, ret %d", ret); + backend_unmap(buf); + } + + kfree(map_ops); + return ret; +} + +/** + * Fill page directory with grant references to the pages of the + * page directory itself. + * + * The grant references to the buffer pages are provided by the + * backend in this case. + * + * \param buf shared buffer. + */ +static void backend_fill_page_dir(struct xen_front_pgdir_shbuf *buf) +{ + struct xen_page_directory *page_dir; + unsigned char *ptr; + int i, num_pages_dir; + + ptr = buf->directory; + num_pages_dir = get_num_pages_dir(buf); + + /* Fill only grefs for the page directory itself. */ + for (i = 0; i < num_pages_dir - 1; i++) { + page_dir = (struct xen_page_directory *)ptr; + + page_dir->gref_dir_next_page = buf->grefs[i + 1]; + ptr += PAGE_SIZE; + } + /* Last page must say there is no more pages. */ + page_dir = (struct xen_page_directory *)ptr; + page_dir->gref_dir_next_page = GRANT_INVALID_REF; +} + +/** + * Fill page directory with grant references to the pages of the + * page directory and the buffer we share with the backend. + * + * \param buf shared buffer. + */ +static void guest_fill_page_dir(struct xen_front_pgdir_shbuf *buf) +{ + unsigned char *ptr; + int cur_gref, grefs_left, to_copy, i, num_pages_dir; + + ptr = buf->directory; + num_pages_dir = get_num_pages_dir(buf); + + /* + * While copying, skip grefs at start, they are for pages + * granted for the page directory itself. + */ + cur_gref = num_pages_dir; + grefs_left = buf->num_pages; + for (i = 0; i < num_pages_dir; i++) { + struct xen_page_directory *page_dir = + (struct xen_page_directory *)ptr; + + if (grefs_left <= XEN_NUM_GREFS_PER_PAGE) { + to_copy = grefs_left; + page_dir->gref_dir_next_page = GRANT_INVALID_REF; + } else { + to_copy = XEN_NUM_GREFS_PER_PAGE; + page_dir->gref_dir_next_page = buf->grefs[i + 1]; + } + memcpy(&page_dir->gref, &buf->grefs[cur_gref], + to_copy * sizeof(grant_ref_t)); + ptr += PAGE_SIZE; + grefs_left -= to_copy; + cur_gref += to_copy; + } +} + +/** + * Grant references to the frontend's buffer pages. + * + * These will be shared with the backend, so it can + * access the buffer's data. + * + * \param buf shared buffer. + * \return zero on success or a negative number on failure. + */ +static int guest_grant_refs_for_buffer(struct xen_front_pgdir_shbuf *buf, + grant_ref_t *priv_gref_head, + int gref_idx) +{ + int i, cur_ref, otherend_id; + + otherend_id = buf->xb_dev->otherend_id; + for (i = 0; i < buf->num_pages; i++) { + cur_ref = gnttab_claim_grant_reference(priv_gref_head); + if (cur_ref < 0) + return cur_ref; + + gnttab_grant_foreign_access_ref(cur_ref, otherend_id, + xen_page_to_gfn(buf->pages[i]), + 0); + buf->grefs[gref_idx++] = cur_ref; + } + return 0; +} + +/** + * Grant all the references needed to share the buffer. + * + * Grant references to the page directory pages and, if + * needed, also to the pages of the shared buffer data. + * + * \param buf shared buffer. + * \return zero on success or a negative number on failure. + */ +static int grant_references(struct xen_front_pgdir_shbuf *buf) +{ + grant_ref_t priv_gref_head; + int ret, i, j, cur_ref; + int otherend_id, num_pages_dir; + + ret = gnttab_alloc_grant_references(buf->num_grefs, &priv_gref_head); + if (ret < 0) { + dev_err(&buf->xb_dev->dev, + "Cannot allocate grant references\n"); + return ret; + } + + otherend_id = buf->xb_dev->otherend_id; + j = 0; + num_pages_dir = get_num_pages_dir(buf); + for (i = 0; i < num_pages_dir; i++) { + unsigned long frame; + + cur_ref = gnttab_claim_grant_reference(&priv_gref_head); + if (cur_ref < 0) + return cur_ref; + + frame = xen_page_to_gfn(virt_to_page(buf->directory + + PAGE_SIZE * i)); + gnttab_grant_foreign_access_ref(cur_ref, otherend_id, frame, 0); + buf->grefs[j++] = cur_ref; + } + + if (buf->ops->grant_refs_for_buffer) { + ret = buf->ops->grant_refs_for_buffer(buf, &priv_gref_head, j); + if (ret) + return ret; + } + + gnttab_free_grant_references(priv_gref_head); + return 0; +} + +/** + * Allocate all required structures to mange shared buffer. + * + * \param buf shared buffer. + * \return zero on success or a negative number on failure. + */ +static int alloc_storage(struct xen_front_pgdir_shbuf *buf) +{ + buf->grefs = kcalloc(buf->num_grefs, sizeof(*buf->grefs), GFP_KERNEL); + if (!buf->grefs) + return -ENOMEM; + + buf->directory = kcalloc(get_num_pages_dir(buf), PAGE_SIZE, GFP_KERNEL); + if (!buf->directory) + return -ENOMEM; + + return 0; +} + +/* + * For backend allocated buffers we don't need grant_refs_for_buffer + * as those grant references are allocated at backend side. + */ +static const struct xen_front_pgdir_shbuf_ops backend_ops = { + .calc_num_grefs = backend_calc_num_grefs, + .fill_page_dir = backend_fill_page_dir, + .map = backend_map, + .unmap = backend_unmap +}; + +/* + * For locally granted references we do not need to map/unmap + * the references. + */ +static const struct xen_front_pgdir_shbuf_ops local_ops = { + .calc_num_grefs = guest_calc_num_grefs, + .fill_page_dir = guest_fill_page_dir, + .grant_refs_for_buffer = guest_grant_refs_for_buffer, +}; + +/** + * Allocate a new instance of a shared buffer. + * + * \param cfg configuration to be used while allocating a new shared buffer. + * \return zero on success or a negative number on failure. + */ +int xen_front_pgdir_shbuf_alloc(struct xen_front_pgdir_shbuf_cfg *cfg) +{ + struct xen_front_pgdir_shbuf *buf = cfg->pgdir; + int ret; + + if (cfg->be_alloc) + buf->ops = &backend_ops; + else + buf->ops = &local_ops; + buf->xb_dev = cfg->xb_dev; + buf->num_pages = cfg->num_pages; + buf->pages = cfg->pages; + + buf->ops->calc_num_grefs(buf); + + ret = alloc_storage(buf); + if (ret) + goto fail; + + ret = grant_references(buf); + if (ret) + goto fail; + + buf->ops->fill_page_dir(buf); + + return 0; + +fail: + xen_front_pgdir_shbuf_free(buf); + return ret; +} +EXPORT_SYMBOL_GPL(xen_front_pgdir_shbuf_alloc); + +MODULE_DESCRIPTION("Xen frontend/backend page directory based " + "shared buffer handling"); +MODULE_AUTHOR("Oleksandr Andrushchenko"); +MODULE_LICENSE("GPL"); diff --git a/include/xen/xen-front-pgdir-shbuf.h b/include/xen/xen-front-pgdir-shbuf.h new file mode 100644 index 000000000000..150ef7ec51ec --- /dev/null +++ b/include/xen/xen-front-pgdir-shbuf.h @@ -0,0 +1,89 @@ +/* SPDX-License-Identifier: GPL-2.0 OR MIT */ + +/* + * Xen frontend/backend page directory based shared buffer + * helper module. + * + * Copyright (C) 2018 EPAM Systems Inc. + * + * Author: Oleksandr Andrushchenko <oleksandr_andrushchenko(a)epam.com> + */ + +#ifndef __XEN_FRONT_PGDIR_SHBUF_H_ +#define __XEN_FRONT_PGDIR_SHBUF_H_ + +#include <linux/kernel.h> + +#include <xen/grant_table.h> + +struct xen_front_pgdir_shbuf_ops; + +struct xen_front_pgdir_shbuf { + /* + * Number of references granted for the backend use: + * + * - for frontend allocated/imported buffers this holds the number + * of grant references for the page directory and the pages + * of the buffer + * + * - for the buffer provided by the backend this only holds the number + * of grant references for the page directory itself as grant + * references for the buffer will be provided by the backend. + */ + int num_grefs; + grant_ref_t *grefs; + /* Page directory backing storage. */ + u8 *directory; + + /* + * Number of pages for the shared buffer itself (excluding the page + * directory). + */ + int num_pages; + /* + * Backing storage of the shared buffer: these are the pages being + * shared. + */ + struct page **pages; + + struct xenbus_device *xb_dev; + + /* These are the ops used internally depending on be_alloc mode. */ + const struct xen_front_pgdir_shbuf_ops *ops; + + /* Xen map handles for the buffer allocated by the backend. */ + grant_handle_t *backend_map_handles; +}; + +struct xen_front_pgdir_shbuf_cfg { + struct xenbus_device *xb_dev; + + /* Number of pages of the buffer backing storage. */ + int num_pages; + /* Pages of the buffer to be shared. */ + struct page **pages; + + /* + * This is allocated outside because there are use-cases when + * the buffer structure is allocated as a part of a bigger one. + */ + struct xen_front_pgdir_shbuf *pgdir; + /* + * Mode of grant reference sharing: if set then backend will share + * grant references to the buffer with the frontend. + */ + int be_alloc; +}; + +int xen_front_pgdir_shbuf_alloc(struct xen_front_pgdir_shbuf_cfg *cfg); + +grant_ref_t +xen_front_pgdir_shbuf_get_dir_start(struct xen_front_pgdir_shbuf *buf); + +int xen_front_pgdir_shbuf_map(struct xen_front_pgdir_shbuf *buf); + +int xen_front_pgdir_shbuf_unmap(struct xen_front_pgdir_shbuf *buf); + +void xen_front_pgdir_shbuf_free(struct xen_front_pgdir_shbuf *buf); + +#endif /* __XEN_FRONT_PGDIR_SHBUF_H_ */ -- 2.19.1

4 16

[alsa-devel] [PATCH v2 1/5] ASoC: qcom: sdm845: Add board specific dapm widgets
by Cheng-Yi Chiang 18 Dec '18

18 Dec '18

Add board specific dapm widgets so these widgets can be used in the route. Signed-off-by: Rohit kumar <rohitkr(a)codeaurora.org> Signed-off-by: Cheng-Yi Chiang <cychiang(a)chromium.org> --- sound/soc/qcom/sdm845.c | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/sound/soc/qcom/sdm845.c b/sound/soc/qcom/sdm845.c index 58593db2ab151..95d8d4422dae0 100644 --- a/sound/soc/qcom/sdm845.c +++ b/sound/soc/qcom/sdm845.c @@ -212,6 +212,14 @@ static int sdm845_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd, return 0; } +static const struct snd_soc_dapm_widget sdm845_snd_widgets[] = { + SND_SOC_DAPM_HP("Headphone Jack", NULL), + SND_SOC_DAPM_MIC("Headset Mic", NULL), + SND_SOC_DAPM_SPK("Left Spk", NULL), + SND_SOC_DAPM_SPK("Right Spk", NULL), + SND_SOC_DAPM_MIC("Int Mic", NULL), +}; + static void sdm845_add_be_ops(struct snd_soc_card *card) { struct snd_soc_dai_link *link; @@ -243,6 +251,8 @@ static int sdm845_snd_platform_probe(struct platform_device *pdev) goto data_alloc_fail; } + card->dapm_widgets = sdm845_snd_widgets; + card->num_dapm_widgets = ARRAY_SIZE(sdm845_snd_widgets); card->dev = dev; dev_set_drvdata(dev, card); ret = qcom_snd_parse_of(card); -- 2.20.0.rc0.387.gc7a69e6b6c-goog

4 15

[alsa-devel] [PATCH] ASoC: pcm512x: Implement the digital_mute interface
by Dimitris Papavasiliou 17 Dec '18

17 Dec '18

Clicks and pops of various volumes can be produced while the device is opened, closed, put into and taken out of standby, or reconfigured. Fix this, by implementing the digital_mute interface, so that the output is muted during such operations. Signed-off-by: Dimitris Papavasiliou <dpapavas(a)gmail.com> --- Notes: Although the datasheet isn't very specific about it, PCM512x_ANALOG_MUTE_DET is only updated once ramp-down to digital mute is complete (followed by analog mute, assuming PCM512x_ANALOG_MUTE_CTRL is left with the default value, as is now the case). I've measured the time it takes for the polling to finish and it seems consistent with that assumption, including properly tracking changes in the ramp-down parameters. Thus, polling the register ensures that the device has been completely muted before returning. When unmuting, the time required for PCM512x_ANALOG_MUTE_DET to reflect the change, doesn't depend on the ramp-up parameters (as might be expected, since analog mute is likely lifted first). Nevertheless the value is consistently substantially larger than zero, so that it seemingly reflects a particular stage in the unmuting process. It also does no harm and seems to help minimize clicks, so I've kept the delay. I've tested this patch both in my day-to-day use of my DAC for more than a month, as well as by running a script that opens the device, performs several sample rate and format changes and closes it, every one second. Without the patch, several different kinds of clicks and pops are produced. After the patch, I've run the script for several hours with the DAC being consistently virtually silent. sound/soc/codecs/pcm512x.c | 121 ++++++++++++++++++++++++++++++++++++++++++++- sound/soc/codecs/pcm512x.h | 2 + 2 files changed, 121 insertions(+), 2 deletions(-) diff --git a/sound/soc/codecs/pcm512x.c b/sound/soc/codecs/pcm512x.c index f0f2d4fd3769..6cb1653be804 100644 --- a/sound/soc/codecs/pcm512x.c +++ b/sound/soc/codecs/pcm512x.c @@ -53,6 +53,8 @@ struct pcm512x_priv { unsigned long overclock_pll; unsigned long overclock_dac; unsigned long overclock_dsp; + int mute; + struct mutex mutex; }; /* @@ -384,6 +386,61 @@ static const struct soc_enum pcm512x_veds = SOC_ENUM_SINGLE(PCM512x_DIGITAL_MUTE_2, PCM512x_VEDS_SHIFT, 4, pcm512x_ramp_step_text); +static int pcm512x_update_mute(struct pcm512x_priv *pcm512x) +{ + return regmap_update_bits( + pcm512x->regmap, PCM512x_MUTE, PCM512x_RQML | PCM512x_RQMR, + (!!(pcm512x->mute & 0x5) << PCM512x_RQML_SHIFT) + | (!!(pcm512x->mute & 0x3) << PCM512x_RQMR_SHIFT)); +} + +static int pcm512x_digital_playback_switch_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct pcm512x_priv *pcm512x = snd_soc_component_get_drvdata(component); + + mutex_lock(&pcm512x->mutex); + ucontrol->value.integer.value[0] = !(pcm512x->mute & 0x4); + ucontrol->value.integer.value[1] = !(pcm512x->mute & 0x2); + mutex_unlock(&pcm512x->mutex); + + return 0; +} + +static int pcm512x_digital_playback_switch_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct pcm512x_priv *pcm512x = snd_soc_component_get_drvdata(component); + int ret, changed = 0; + + mutex_lock(&pcm512x->mutex); + + if ((pcm512x->mute & 0x4) == (ucontrol->value.integer.value[0] << 2)) { + pcm512x->mute ^= 0x4; + changed = 1; + } + if ((pcm512x->mute & 0x2) == (ucontrol->value.integer.value[1] << 1)) { + pcm512x->mute ^= 0x2; + changed = 1; + } + + if (changed) { + ret = pcm512x_update_mute(pcm512x); + if (ret != 0) { + dev_err(component->dev, + "Failed to update digital mute: %d\n", ret); + mutex_unlock(&pcm512x->mutex); + return ret; + } + } + + mutex_unlock(&pcm512x->mutex); + + return changed; +} + static const struct snd_kcontrol_new pcm512x_controls[] = { SOC_DOUBLE_R_TLV("Digital Playback Volume", PCM512x_DIGITAL_VOLUME_2, PCM512x_DIGITAL_VOLUME_3, 0, 255, 1, digital_tlv), @@ -391,8 +448,15 @@ SOC_DOUBLE_TLV("Analogue Playback Volume", PCM512x_ANALOG_GAIN_CTRL, PCM512x_LAGN_SHIFT, PCM512x_RAGN_SHIFT, 1, 1, analog_tlv), SOC_DOUBLE_TLV("Analogue Playback Boost Volume", PCM512x_ANALOG_GAIN_BOOST, PCM512x_AGBL_SHIFT, PCM512x_AGBR_SHIFT, 1, 0, boost_tlv), -SOC_DOUBLE("Digital Playback Switch", PCM512x_MUTE, PCM512x_RQML_SHIFT, - PCM512x_RQMR_SHIFT, 1, 1), +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "Digital Playback Switch", + .index = 0, + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, + .info = snd_ctl_boolean_stereo_info, + .get = pcm512x_digital_playback_switch_get, + .put = pcm512x_digital_playback_switch_put +}, SOC_SINGLE("Deemphasis Switch", PCM512x_DSP, PCM512x_DEMP_SHIFT, 1, 1), SOC_ENUM("DSP Program", pcm512x_dsp_program), @@ -1319,10 +1383,61 @@ static int pcm512x_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) return 0; } +static int pcm512x_digital_mute(struct snd_soc_dai *dai, int mute) +{ + struct snd_soc_component *component = dai->component; + struct pcm512x_priv *pcm512x = snd_soc_component_get_drvdata(component); + int ret; + unsigned int mute_det; + + mutex_lock(&pcm512x->mutex); + + if (mute) { + pcm512x->mute |= 0x1; + ret = regmap_update_bits(pcm512x->regmap, PCM512x_MUTE, + PCM512x_RQML | PCM512x_RQMR, + PCM512x_RQML | PCM512x_RQMR); + if (ret != 0) { + dev_err(component->dev, + "Failed to set digital mute: %d\n", ret); + mutex_unlock(&pcm512x->mutex); + return ret; + } + + regmap_read_poll_timeout(pcm512x->regmap, + PCM512x_ANALOG_MUTE_DET, + mute_det, (mute_det & 0x3) == 0, + 200, 10000); + + mutex_unlock(&pcm512x->mutex); + } else { + pcm512x->mute &= ~0x1; + ret = pcm512x_update_mute(pcm512x); + if (ret != 0) { + dev_err(component->dev, + "Failed to update digital mute: %d\n", ret); + mutex_unlock(&pcm512x->mutex); + return ret; + } + + regmap_read_poll_timeout(pcm512x->regmap, + PCM512x_ANALOG_MUTE_DET, + mute_det, + (mute_det & 0x3) + == ((~pcm512x->mute >> 1) & 0x3), + 200, 10000); + } + + mutex_unlock(&pcm512x->mutex); + + return 0; +} + static const struct snd_soc_dai_ops pcm512x_dai_ops = { .startup = pcm512x_dai_startup, .hw_params = pcm512x_hw_params, .set_fmt = pcm512x_set_fmt, + .digital_mute = pcm512x_digital_mute, }; static struct snd_soc_dai_driver pcm512x_dai = { @@ -1388,6 +1503,8 @@ int pcm512x_probe(struct device *dev, struct regmap *regmap) if (!pcm512x) return -ENOMEM; + mutex_init(&pcm512x->mutex); + dev_set_drvdata(dev, pcm512x); pcm512x->regmap = regmap; diff --git a/sound/soc/codecs/pcm512x.h b/sound/soc/codecs/pcm512x.h index d70d9c0c2088..9dda8693498e 100644 --- a/sound/soc/codecs/pcm512x.h +++ b/sound/soc/codecs/pcm512x.h @@ -112,7 +112,9 @@ #define PCM512x_RQST_SHIFT 4 /* Page 0, Register 3 - mute */ +#define PCM512x_RQMR (1 << 0) #define PCM512x_RQMR_SHIFT 0 +#define PCM512x_RQML (1 << 4) #define PCM512x_RQML_SHIFT 4 /* Page 0, Register 4 - PLL */ -- 2.11.0

2 8