May 2024 - Alsa-devel - mailman.alsa-project.org

[PATCH] dt-bindings: sound:atmel-at91sam9g20ek: convert bindings to json-schema
by Balakrishnan Sambath 10 Dec '24

10 Dec '24

Convert atmel-at91sam9g20ek-wm8731-audio DT binding to yaml based json-schema.Change file name to match json-scheme naming. Signed-off-by: Balakrishnan Sambath <balakrishnan.s(a)microchip.com> --- .../bindings/sound/atmel,at91sam9g20ek-wm8731.yaml | 60 ++++++++++++++++++++++ .../sound/atmel-at91sam9g20ek-wm8731-audio.txt | 26 ---------- 2 files changed, 60 insertions(+), 26 deletions(-) diff --git a/Documentation/devicetree/bindings/sound/atmel,at91sam9g20ek-wm8731.yaml b/Documentation/devicetree/bindings/sound/atmel,at91sam9g20ek-wm8731.yaml new file mode 100644 index 000000000000..f6330707fe1b --- /dev/null +++ b/Documentation/devicetree/bindings/sound/atmel,at91sam9g20ek-wm8731.yaml @@ -0,0 +1,60 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/sound/atmel,at91sam9g20ek-wm8731.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Atmel at91sam9g20ek wm8731 audio complex + +maintainers: + - Balakrishnan Sambath <balakrishnan.s(a)microchip.com> + +properties: + compatible: + const: atmel,at91sam9g20ek-wm8731-audio + + atmel,model: + $ref: /schemas/types.yaml#/definitions/string + description: The user-visible name of this sound complex. + atmel,audio-routing: + $ref: /schemas/types.yaml#/definitions/non-unique-string-array + description: A list of the connections between audio components. + minItems: 2 + items: + enum: + # Board Connectors + - "Ext Spk" + - "Int MIC" + + # CODEC Pins + - LHPOUT + - MICIN + atmel,ssc-controller: + $ref: /schemas/types.yaml#/definitions/phandle + description: The phandle of the SSC controller + atmel,audio-codec: + $ref: /schemas/types.yaml#/definitions/phandle + description: The phandle of WM8731 audio codec + +required: + - compatible + - atmel,model + - atmel,audio-routing + - atmel,ssc-controller + - atmel,audio-codec + +additionalProperties: false + +examples: + - | + sound { + compatible = "atmel,at91sam9g20ek-wm8731-audio"; + pinctrl-names = "default"; + pinctrl-0 = <&pinctrl_pck0_as_mck>; + atmel,model = "wm8731 @ AT91SAMG20EK"; + atmel,audio-routing = + "Ext Spk", "LHPOUT", + "Int MIC", "MICIN"; + atmel,ssc-controller = <&ssc0>; + atmel,audio-codec = <&wm8731>; + }; diff --git a/Documentation/devicetree/bindings/sound/atmel-at91sam9g20ek-wm8731-audio.txt b/Documentation/devicetree/bindings/sound/atmel-at91sam9g20ek-wm8731-audio.txt deleted file mode 100644 index 9c5a9947b64d..000000000000 --- a/Documentation/devicetree/bindings/sound/atmel-at91sam9g20ek-wm8731-audio.txt +++ /dev/null @@ -1,26 +0,0 @@ -* Atmel at91sam9g20ek wm8731 audio complex - -Required properties: - - compatible: "atmel,at91sam9g20ek-wm8731-audio" - - atmel,model: The user-visible name of this sound complex. - - atmel,audio-routing: A list of the connections between audio components. - - atmel,ssc-controller: The phandle of the SSC controller - - atmel,audio-codec: The phandle of the WM8731 audio codec -Optional properties: - - pinctrl-names, pinctrl-0: Please refer to pinctrl-bindings.txt - -Example: -sound { - compatible = "atmel,at91sam9g20ek-wm8731-audio"; - pinctrl-names = "default"; - pinctrl-0 = <&pinctrl_pck0_as_mck>; - - atmel,model = "wm8731 @ AT91SAMG20EK"; - - atmel,audio-routing = - "Ext Spk", "LHPOUT", - "Int MIC", "MICIN"; - - atmel,ssc-controller = <&ssc0>; - atmel,audio-codec = <&wm8731>; -}; --- base-commit: 0dd3ee31125508cd67f7e7172247f05b7fd1753a change-id: 20240214-at91sam9g20ek-wm8731-yaml-404ddddbb91a Best regards, -- Balakrishnan Sambath <balakrishnan.s(a)microchip.com>

5 5

[PATCH v2 0/3] ASoC: mediatek:mt8186: fix both the speaker and hdmi
by Jiaxin Yu 06 Dec '24

06 Dec '24

The speaker and hdmi of mt8186 platform are shared the same port of I2S, when connect the external display, use build-in speakers to play audio, they both playback at the same time. So we want to manage the playback device through DAPM events. Change since v1: Support audio function for it6505 bridge to hdmi-codec Jiaxin Yu (3): ASoC: hdmi-codec: Add event handler for hdmi TX ASoC: mediatek: mt8186: correct the HDMI widgets drm/bridge: it6505: Add audio support drivers/gpu/drm/bridge/ite-it6505.c | 81 +++++++++++++++++-- include/sound/hdmi-codec.h | 6 ++ sound/soc/codecs/hdmi-codec.c | 37 ++++++++- .../mt8186/mt8186-mt6366-da7219-max98357.c | 2 +- .../mt8186/mt8186-mt6366-rt1019-rt5682s.c | 2 +- 5 files changed, 116 insertions(+), 12 deletions(-) -- 2.18.0

3 16

[alsa-devel] Error patching file pcm_native.c
by Delusion's Master 20 Nov '24

20 Nov '24

Hi, first of all I apologize in case you receive multiple copies of this message, but I forgot to specify a subject in the original mail. I have a problem compiling the latest alsa driver snapshots. Specifically, it's a problem when patching pcm_native.c: [..] copying file alsa-kernel/core/info.c patching file info.c copying file alsa-kernel/core/pcm.c patching file pcm.c Hunk #3 succeeded at 739 (offset 2 lines). Hunk #5 succeeded at 954 (offset 2 lines). Hunk #7 succeeded at 1045 (offset 2 lines). copying file alsa-kernel/core/pcm_native.c patching file pcm_native.c Hunk #4 succeeded at 1544 (offset -25 lines). Hunk #5 succeeded at 2827 (offset 12 lines). Hunk #6 succeeded at 2878 (offset 10 lines). Hunk #7 FAILED at 2906. Hunk #8 FAILED at 2922. Hunk #9 succeeded at 2915 (offset -23 lines). Hunk #10 succeeded at 3036 (offset 10 lines). Hunk #11 succeeded at 3027 (offset -23 lines). Hunk #12 succeeded at 3074 (offset 10 lines). Hunk #13 succeeded at 3098 (offset -23 lines). Hunk #14 succeeded at 3143 (offset 10 lines). Hunk #15 succeeded at 3124 (offset -23 lines). Hunk #16 succeeded at 3214 (offset 10 lines). Hunk #17 succeeded at 3208 (offset -23 lines). Hunk #18 succeeded at 3271 (offset 10 lines). Hunk #19 succeeded at 3304 (offset -23 lines). Hunk #20 succeeded at 3386 (offset 10 lines). Hunk #21 succeeded at 3411 (offset -23 lines). Hunk #22 succeeded at 3456 (offset 10 lines). Hunk #23 succeeded at 3450 (offset -23 lines). Hunk #24 succeeded at 3525 (offset 10 lines). Hunk #25 succeeded at 3644 (offset -23 lines). 2 out of 25 hunks FAILED -- saving rejects to file pcm_native.c.rej make[2]: *** [pcm_native.c] Error 1 It's some days I get this, but I waited to report this since I thought it could be a temporary problem. My OS is Fedora 11 x86_64. Previous snapshots didn't give me this problem, but I can't say which one broke the compilation, since I usually try updated snapshots only at kernel updates. I searched for this error and the only relevant report I could find is this one: http://mailman.alsa-project.org/pipermail/alsa-devel/2009-April/016420.html a report from last April. What could the problem be? Thanks _________________________________________________________________ Invite your mail contacts to join your friends list with Windows Live Spaces. It's easy! http://spaces.live.com/spacesapi.aspx?wx_action=create&wx_url=/friends.aspx…

3 10

[alsa-devel] [RFC PATCH 00/10] Add support for DMA and audio codec of F1C100s
by Mesih Kilinc 23 Oct '24

23 Oct '24

This is RFC patchset for Allwinner suniv F1C100s to support DMA and audio codec. Allwinner F1C100s has a audio codec that has necessary digital and analog parts. It has r-l headphone output and microphone, line, r-l FM inputs. ADC can capture any inputs and also output channels via mux. Any input channels or DAC samples can feed output channels. Add support for this audio codec. F1C100s utilizes DMA channels to send and receive ADC-DAC samples. So DMA support needed. Patch 1~5 adds support for DMA. Suniv F1C100s has very similar DMA to sun4i. But there is some dissimilarities also. Suniv features a DMA reset bit in clock control unit. It has smaller number of DMA channels. Several registers has different addresses. It's max burst size is 4 instead of 8. Also DMA endpoint numbers are different. Patch 6 adds DMA max burst option to sun4i-codec. Patch 7~8 Add support for suniv F1C100s audio codec. Patch 9 adds audio codec to suniv-f1c100s.dtsi Patch 10 adds audio codec support to Lichee Pi Nano board. Thanks! Mesih Kilinc (10): dma-engine: sun4i: Add a quirk to support different chips dma-engine: sun4i: Add has_reset option to quirk dt-bindings: dmaengine: Add Allwinner suniv F1C100s DMA dma-engine: sun4i: Add support for Allwinner suniv F1C100s ARM: dts: suniv: f1c100s: Add support for DMA ASoC: sun4i-codec: Add DMA Max Burst field dt-bindigs: sound: Add Allwinner suniv F1C100s Audio Codec ASoC: sun4i-codec: Add support for Allwinner suniv F1C100s ARM: dts: suniv: f1c100s: Add support for Audio Codec ARM: dts: suniv: f1c100s: Activate Audio Codec for Lichee Pi Nano .../devicetree/bindings/dma/sun4i-dma.txt | 4 +- .../devicetree/bindings/sound/sun4i-codec.txt | 5 + arch/arm/boot/dts/suniv-f1c100s-licheepi-nano.dts | 8 + arch/arm/boot/dts/suniv-f1c100s.dtsi | 25 ++ drivers/dma/Kconfig | 4 +- drivers/dma/sun4i-dma.c | 221 ++++++++++-- sound/soc/sunxi/sun4i-codec.c | 371 ++++++++++++++++++++- 7 files changed, 601 insertions(+), 37 deletions(-) -- 2.7.4

5 18

[PATCH 00/18] ASoC: Intel: boards: updates for 6.11
by Pierre-Louis Bossart 28 Aug '24

28 Aug '24

More simplifications from Brent Lu for Chromebooks, Bard Liao for SoundWire, and support for new Dell SKUs w/ Cirrus Logic codecs added by Charles Keepax. Bard Liao (7): ASoC: Intel: sof_sdw_cs42l42: use dai parameter ASoC: Intel: sof_sdw_rt711: use dai parameter ASoC: Intel: sof_sdw_rt5682: use dai parameter ASoC: Intel: sof_sdw_rt700: use dai parameter ASoC: Intel: sof_sdw_rt_dmic: use from dai parameter ASoC: Intel: sof_sdw_rt_sdca_jack_common: use dai parameter ASoC: Intel: sof_sdw: remove get_codec_dai_by_name Brent Lu (7): ASoC: SOF: sof-audio: rename dai clock setting query function ASoC: SOF: sof-audio: add sof_dai_get_tdm_slots function ASoC: SOF: ipc3-topology: support tdm slot number query ASoC: SOF: ipc4-topology: support tdm slot number query ASoC: Intel: maxim-common: rewrite max_98373_hw_params function ASoC: Intel: sof_da7219: remove local max98373 ops ASoC: Intel: sof_da7219: disable max98373 speaker pins in late_probe Charles Keepax (4): ASoC: Intel: sof_sdw: Add missing controls for cs42l43/cs35l56 ASoC: Intel: soc-acpi: Add match entries for some cs42l43 laptops ASoC: Intel: sof_sdw: Add quirks for some new Dell laptops ASoC: Intel: sof_sdw: Add quirks from some new Dell laptops include/sound/sof.h | 1 + sound/soc/intel/boards/sof_board_helpers.h | 2 - sound/soc/intel/boards/sof_da7219.c | 57 ++------ sound/soc/intel/boards/sof_maxim_common.c | 84 ++++++++++-- sound/soc/intel/boards/sof_sdw.c | 128 +++++++++++++++--- sound/soc/intel/boards/sof_sdw_common.h | 4 - sound/soc/intel/boards/sof_sdw_cs42l42.c | 11 +- sound/soc/intel/boards/sof_sdw_rt5682.c | 11 +- sound/soc/intel/boards/sof_sdw_rt700.c | 11 +- sound/soc/intel/boards/sof_sdw_rt711.c | 11 +- sound/soc/intel/boards/sof_sdw_rt_dmic.c | 14 +- .../boards/sof_sdw_rt_sdca_jack_common.c | 11 +- .../intel/common/soc-acpi-intel-arl-match.c | 50 +++++++ .../intel/common/soc-acpi-intel-rpl-match.c | 50 +++++++ sound/soc/sof/ipc3-topology.c | 14 +- sound/soc/sof/ipc4-topology.c | 14 +- sound/soc/sof/sof-audio.c | 20 ++- sound/soc/sof/sof-audio.h | 9 +- 18 files changed, 338 insertions(+), 164 deletions(-) -- 2.43.0

4 21

[PATCH v5 0/4] ASoC: grace time for DPCM cleanup
by Kuninori Morimoto 28 Aug '24

28 Aug '24

Hi Mark, Pierre-Louis, Jerome Cc each ASoC driver maintainer This is v5 of DPCM cleanup As we discussed in [1], we don't need to use dpcm_playback/capture flag, so we remove it. But we have been using it for 10 years, some driver might get damage. The most likely case is that the device/driver can use both playback/capture, but have only one flag, and not using xxx_only flag. [1/3] patch indicates warning in such case. These adds grace time for DPCM cleanup. I'm not sure when dpcm_xxx will be removed, and Codec check bypass will be error, but maybe v6.11 or v6.12 ? Please check each driver by that time. Previous patch-set try to check both CPU and Codec in DPCM, but we noticed that there are some special DAI which we can't handle today [2]. So I will escape it in this patch-set. [1] https://lore.kernel.org/r/87edaym2cg.wl-kuninori.morimoto.gx@renesas.com [2] https://lore.kernel.org/all/3e67d62d-fe08-4f55-ab5b-ece8a57154f9@linux.inte… Link: https://lore.kernel.org/r/87edaym2cg.wl-kuninori.morimoto.gx@renesas.com Link: https://lore.kernel.org/r/87wmo6dyxg.wl-kuninori.morimoto.gx@renesas.com Link: https://lore.kernel.org/r/87msole5wc.wl-kuninori.morimoto.gx@renesas.com Link: https://lore.kernel.org/r/871q5tnuok.wl-kuninori.morimoto.gx@renesas.com v4 -> v5 - typo fix: limition -> limitation - typo fix: catpure -> capture - include Intel patch v3 -> v4 - don't check Codec on DPCM - include Jerome's dpcm_xxx update patch v2 -> v3 - tidyup typo (reuqsts -> requests) - add Tested-by on git-log v1 -> v2 - tidyup Codec check warning output condition Jerome Brunet (1): ASoC: amlogic: do not use dpcm_playback/capture flags Kuninori Morimoto (2): ASoC: soc-pcm: Indicate warning if dpcm_playback/capture were used for availability limition ASoC: remove snd_soc_dai_link_set_capabilities() Pierre-Louis Bossart (1): ASoC: Intel: sof_sdw: use playback/capture_only flags include/sound/soc-dai.h | 1 - include/sound/soc.h | 1 + sound/soc/fsl/imx-card.c | 3 -- sound/soc/generic/audio-graph-card.c | 2 - sound/soc/generic/audio-graph-card2.c | 2 - sound/soc/generic/simple-card.c | 2 - sound/soc/intel/boards/sof_sdw.c | 4 +- sound/soc/meson/axg-card.c | 11 +++-- sound/soc/meson/gx-card.c | 1 - sound/soc/meson/meson-card-utils.c | 4 +- sound/soc/qcom/common.c | 1 - sound/soc/soc-dai.c | 38 ---------------- sound/soc/soc-pcm.c | 65 +++++++++++++++------------ 13 files changed, 47 insertions(+), 88 deletions(-) -- 2.43.0

2 9

[RFC PATCH 00/16] soundwire/ASoC: speed-up downloads with BTP/BRA protocol
by Pierre-Louis Bossart 20 Aug '24

20 Aug '24

This RFC patchset suggests a new API for ASoC codec drivers to use for firmware/table downloads. Problem statement: All existing transfers initiated by codec drivers rely on SoundWire read/write commands, which can only support ONE byte per frame. With the typical 48kHz frame rate, this means 384 kbits/s. In addition, the command/control is typically handled with a FIFO and interrupts which adds more software overhead. To give a practical reference, sending 32Kb takes 2.5s on Intel platforms, which means about 105kbit/s only. Additional non-audio activity is likely to adversely impact interrupt scheduling and further decrease the transfer speeds. New SDCA-based codecs have a need to download tables and DSP firmware which are typically between 20 and 256 Kb. The slow bus operation has a direct impact on boot/resume times, and clearly having to wait more than 300ms is a showstopper in terms of latency requirements and user-experience. Suggested solution: The MIPI specification and most of the new codecs support the Bulk Transfer Protocol (BTP) and specifically the Bulk Register Access (BRA) configuration. This mode reclaims the 'audio' data space of the SoundWire frame to send firmware/coefficients over the DataPort 0 (DP0). The API suggested is rather simple, with the following sequence expected: open(): reserve resources and prepare hardware send_async(): trigger DMAs and perform SoundWire bank switch wait(): wait for DMA completion and disable DMAs close(): release resources Benefits: Even after accounting for the protocol overhead, the data can be sent 8x or 16x faster on the link than with the regular commands. With the use of DMAs, the software overhead becomes limited to the initialization. Measured results show that transferring the same 32Kb takes about 100ms, a 25x improvement on the baseline write() commands with an actual bitrate of 2.6 Mbits/s. These results are a measure of bus/hardware performance mainly, and will typically not be too modified by the CPU activity and scheduling. The performance for reads is similar, with a 25x speedup measured. Limitations: Setting up the transfers over DP0 takes time, and the reliance on DMAs on the host side brings alignment restrictions. The BTP/BRA protocol is really only relevant for "large" transfers done during boot/resume *before* audio transfers take place. Mixing BTP/BRA and audio is a nightmare, this patchset suggests a mutual-exclusion between two usages. Scope: This patchset only exposes the API and a debugfs interface to initiate commands, validate results and measure performance. The actual use of the API is left as an exercise for codec driver developers. This patchset depends on a number of pre-requisite patches and will not build on top of any for-next branches. The main intent of this RFC is to gather comments on the usage, API, benefits and restrictions. The code and functionality was tested on an Intel LunarLake RVP platform connected to a Realtek RT711-SDCA device. Acknowledgements: Thanks to Zeek Tsai at Realtek for providing test sequences that helped reconcile the data formatted by the host driver with the expected results on the code side. Pierre-Louis Bossart (16): Documentation: driver: add SoundWire BRA description soundwire: cadence: add BTP support for DP0 soundwire: stream: extend sdw_alloc_stream() to take 'type' parameter soundwire: extend sdw_stream_type to BPT soundwire: stream: special-case the bus compute_params() routine soundwire: stream: reuse existing code for BPT stream soundwire: bus: add API for BPT protocol soundwire: bus: add bpt_stream pointer soundwire: crc8: add constant table soundwire: cadence: add BTP/BRA helpers to format data soundwire: intel_auxdevice: add indirection for BPT open/close/send_async/wait ASoC: SOF: Intel: hda-sdw-bpt: add helpers for SoundWire BPT DMA soundwire: intel: add BPT context definition soundwire: intel_ace2x: add BPT open/close/send_async/wait soundwire: debugfs: add interface for BPT/BRA transfers ASoC: rt711-sdca: add DP0 support Documentation/driver-api/soundwire/bra.rst | 478 +++++++++++++ Documentation/driver-api/soundwire/index.rst | 1 + Documentation/driver-api/soundwire/stream.rst | 2 +- .../driver-api/soundwire/summary.rst | 5 +- drivers/soundwire/Kconfig | 1 + drivers/soundwire/Makefile | 4 +- drivers/soundwire/amd_manager.c | 2 +- drivers/soundwire/bus.c | 77 +++ drivers/soundwire/bus.h | 18 + drivers/soundwire/cadence_master.c | 646 +++++++++++++++++- drivers/soundwire/cadence_master.h | 30 + drivers/soundwire/crc8.c | 277 ++++++++ drivers/soundwire/crc8.h | 11 + drivers/soundwire/debugfs.c | 122 +++- .../soundwire/generic_bandwidth_allocation.c | 84 ++- drivers/soundwire/intel.h | 12 + drivers/soundwire/intel_ace2x.c | 377 ++++++++++ drivers/soundwire/intel_auxdevice.c | 55 ++ drivers/soundwire/qcom.c | 2 +- drivers/soundwire/stream.c | 137 +++- include/linux/soundwire/sdw.h | 91 ++- include/linux/soundwire/sdw_intel.h | 16 + include/sound/hda-sdw-bpt.h | 76 +++ sound/soc/codecs/rt711-sdca-sdw.c | 8 + sound/soc/qcom/sdw.c | 2 +- sound/soc/sof/intel/Kconfig | 8 +- sound/soc/sof/intel/Makefile | 4 + sound/soc/sof/intel/hda-sdw-bpt.c | 328 +++++++++ 28 files changed, 2810 insertions(+), 64 deletions(-) create mode 100644 Documentation/driver-api/soundwire/bra.rst create mode 100644 drivers/soundwire/crc8.c create mode 100644 drivers/soundwire/crc8.h create mode 100644 include/sound/hda-sdw-bpt.h create mode 100644 sound/soc/sof/intel/hda-sdw-bpt.c -- 2.39.2

4 60

[PATCH v11 00/10] spi: Add support for stacked/parallel memories
by Amit Kumar Mahapatra 19 Aug '24

19 Aug '24

This patch series updated the spi-nor, spi core and the AMD-Xilinx GQSPI driver to add stacked and parallel memories support. The first nine patches https://lore.kernel.org/all/20230119185342.2093323-1-amit.kumar-mahapatra@a… https://lore.kernel.org/all/20230310173217.3429788-2-amit.kumar-mahapatra@a… https://lore.kernel.org/all/20230310173217.3429788-3-amit.kumar-mahapatra@a… https://lore.kernel.org/all/20230310173217.3429788-4-amit.kumar-mahapatra@a… https://lore.kernel.org/all/20230310173217.3429788-5-amit.kumar-mahapatra@a… https://lore.kernel.org/all/20230310173217.3429788-6-amit.kumar-mahapatra@a… https://lore.kernel.org/all/20230310173217.3429788-7-amit.kumar-mahapatra@a… https://lore.kernel.org/all/20230310173217.3429788-8-amit.kumar-mahapatra@a… https://lore.kernel.org/all/20230310173217.3429788-9-amit.kumar-mahapatra@a… of the previous series got applied to https://git.kernel.org/pub/scm/linux/kernel/git/broonie/spi.git for-next But the rest of the patches in the series did not get applied as failure was reported for spi driver with GPIO CS, so send the remaining patches in the series after rebasing it on top of for-next branch and fixing the issue. CS GPIO is not tested on our hardware, but it has been tested by @Stefan https://lore.kernel.org/all/005001da1efc$619ad5a0$24d080e0$@opensource.cirr… --- BRANCH: for-next Changes in v11: - Rebased patch series on top of latest for-next branch. - Added a new patch(1/10) to replace spi->chip_select with spi_get_chipselect() call in tps6594-spi.c. - Added a new patch(2/10) to replace spi->chip_select with spi_get_chipseletc() call in cs35l56_hda_spi.c. - In spi.c initialized unused CS[] to 0xff and spi->cs_index_mask to 0x01 in all flows. - Updated spi_dev_check() to compare the CS of old spi device with the new spi device CS. - Updated cover letter description to add information regarding GPIO CS testing and added Stefen's Tested-by tag in 3/10 patch. Changes in v10: - Rebased patch series on top of latest for-next branch and fixed merge conflicts. Changes in v9: - Updated 1/8 patch description to add an high-level overview of parallel(multi-cs) & stacked design. - Initialized all unused CS to 0xFF. - Moved CS check from spi_add_device() to __spi_add_device(). - Updated __spi_add_device() to check to make sure that multiple logical CS don't map to the same physical CS and same physical CS doesn't map to different logical CS. - Updated 1/8, 5/8 & 7/8 to support arbitrary number of flash devices connected in parallel or stacked mode. - Updated documentation for chip_select. - Added a new spi-nor structure member nor->num_flash to keep track of the number of flashes connected. - Added a new patch in the series 4/8 to move write_enable call just before spi_mem ops call in SPI-NOR. - Added comments in SPI core & SPI-NOR. - Rebased the patch series on top of the latest for-next branch. Changes in v8: - Updated __spi_add_device() and spi_set_cs() to fix spi driver failure with GPIO CS. - Rebased the patch series on top of latest for-next branch and fixed merge conflicts. - Updated cover letter description to add information regarding GPIO CS testing and request Stefan to provide his Tested-by tag for 1/7 patch. - Updated 1/7 patch description. Changes in v7: - Updated spi_dev_check() to avoid failures for spi driver GPIO CS and moved the error message from __spi_add_device() to spi_dev_check(). - Resolved code indentation issue in spi_set_cs(). - In spi_set_cs() call spi_delay_exec( ) once if the controller supports multi cs with both the CS backed by GPIO. - Updated __spi_validate()to add checks for both the GPIO CS. - Replaced cs_index_mask bit mask with SPI_CS_CNT_MAX. - Updated struct spi_controller to represent multi CS capability of the spi controller through a flag bit SPI_CONTROLLER_MULTI_CS instead of a boolen structure member "multi_cs_cap". - Updated 1/7 patch description . Changes in v6: - Rebased on top of latest v6.3-rc1 and fixed merge conflicts in spi-mpc512x-psc.c, sfdp.c, spansion.c files and removed spi-omap-100k.c. - Updated spi_dev_check( ) to reject new devices if any one of the chipselect is used by another device. Changes in v5: - Rebased the patches on top of v6.3-rc1 and fixed the merge conflicts. - Fixed compilation warnings in spi-sh-msiof.c with shmobile_defconfig Changes in v4: - Fixed build error in spi-pl022.c file - reported by Mark. - Fixed build error in spi-sn-f-ospi.c file. - Added Reviewed-by: Serge Semin <fancer.lancer(a)gmail.com> tag. - Added two more patches to replace spi->chip_select with API calls in mpc832x_rdb.c & cs35l41_hda_spi.c files. Changes in v3: - Rebased the patches on top of https://git.kernel.org/pub/scm/linux/kernel/git/broonie/spi.git for-next - Added a patch to convert spi_nor_otp_region_len(nor) & spi_nor_otp_n_regions(nor) macros into inline functions - Added Reviewed-by & Acked-by tags Changes in v2: - Rebased the patches on top of v6.2-rc1 - Created separate patch to add get & set APIs for spi->chip_select & spi->cs_gpiod, and replaced all spi->chip_select and spi->cs_gpiod references with the API calls. - Created separate patch to add get & set APIs for nor->params. --- Amit Kumar Mahapatra (10): mfd: tps6594: Use set/get APIs to access spi->chip_select ALSA: hda/cs35l56: Use set/get APIs to access spi->chip_select spi: Add multi-cs memories support in SPI core mtd: spi-nor: Convert macros with inline functions mtd: spi-nor: Add APIs to set/get nor->params mtd: spi-nor: Move write enable inside specific write & erase APIs mtd: spi-nor: Add stacked memories support in spi-nor spi: spi-zynqmp-gqspi: Add stacked memories support in GQSPI driver mtd: spi-nor: Add parallel memories support in spi-nor spi: spi-zynqmp-gqspi: Add parallel memories support in GQSPI driver drivers/mfd/tps6594-spi.c | 2 +- drivers/mtd/spi-nor/atmel.c | 17 +- drivers/mtd/spi-nor/core.c | 683 +++++++++++++++++++++++++------ drivers/mtd/spi-nor/core.h | 8 + drivers/mtd/spi-nor/debugfs.c | 4 +- drivers/mtd/spi-nor/gigadevice.c | 4 +- drivers/mtd/spi-nor/issi.c | 11 +- drivers/mtd/spi-nor/macronix.c | 10 +- drivers/mtd/spi-nor/micron-st.c | 35 +- drivers/mtd/spi-nor/otp.c | 48 ++- drivers/mtd/spi-nor/sfdp.c | 33 +- drivers/mtd/spi-nor/spansion.c | 57 +-- drivers/mtd/spi-nor/sst.c | 7 +- drivers/mtd/spi-nor/swp.c | 25 +- drivers/mtd/spi-nor/winbond.c | 2 +- drivers/mtd/spi-nor/xilinx.c | 18 +- drivers/spi/spi-zynqmp-gqspi.c | 58 ++- drivers/spi/spi.c | 259 ++++++++++-- include/linux/mtd/spi-nor.h | 21 +- include/linux/spi/spi.h | 51 ++- sound/pci/hda/cs35l56_hda_spi.c | 2 +- 21 files changed, 1085 insertions(+), 270 deletions(-) -- 2.17.1

10 61

[PATCH v1] ASoc: tas2781: Add Calibration Kcontrols and tas2563 digtial gain for Chromebook
by Shenghao Ding 09 Aug '24

09 Aug '24

Calibrated data will be set to default after loading DSP config params, which will cause speaker protection work abnormally. Reload calibrated data after loading DSP config params. Signed-off-by: Shenghao Ding <shenghao-ding(a)ti.com> --- v1: - Changed the copyright year to 2024 in the related files. - Add CAL_DAT_SZ for calibrated data size. - Add TAS2563_DVC_LVL for digtial gain kcontrol. - Add registers for TAS2563 and TAS2781 calibration. - Add cali_data_restore for regsiter restore after calibration. - Add is_user_space_calidata to store the flag where the calibrated from, user space or bin file from driver parsing. - Add TASDEVICE_RCA_FW_OK to support only register setting bin in the device. - Add tas2563_dvc_table for relationship between tas2563 digtial gains and register values. - Correct the filename in the header comments of tas2781-comlib.c, tas2781-lib.c --> tas2781-comlib.c. - tasdevice_chn_switch for chip switch among multiple chips(tas2563 or tas2781) - Add loading the calibrated values from user space in tasdev_load_calibrated_data - Correct no dsp no work, it can still work in bypass mode. - Add calibrated register setting for tas2563&tas2781. - Add mutex into each kcontrol. - rename tas2781_force_fwload_get, tas2781_force_fwload_put--> tasdev_force_fwload_get, tasdev_force_fwload_put - rename tas2781_codec --> tasdev_codec - define tas2781_snd_control and tas2563_snd_control for volume - define tas2781_cali_control and tas2563_cali_control for calibration --- include/sound/tas2781-dsp.h | 1 + include/sound/tas2781.h | 92 ++- sound/soc/codecs/tas2781-comlib.c | 35 +- sound/soc/codecs/tas2781-fmwlib.c | 51 +- sound/soc/codecs/tas2781-i2c.c | 941 +++++++++++++++++++++++++++++- 5 files changed, 1061 insertions(+), 59 deletions(-) diff --git a/include/sound/tas2781-dsp.h b/include/sound/tas2781-dsp.h index 7fba7ea26a4b..74ab6f113029 100644 --- a/include/sound/tas2781-dsp.h +++ b/include/sound/tas2781-dsp.h @@ -121,6 +121,7 @@ enum tasdevice_dsp_fw_state { TASDEVICE_DSP_FW_NONE = 0, TASDEVICE_DSP_FW_PENDING, TASDEVICE_DSP_FW_FAIL, + TASDEVICE_RCA_FW_OK, TASDEVICE_DSP_FW_ALL_OK, }; diff --git a/include/sound/tas2781.h b/include/sound/tas2781.h index 99ca3e401fd1..2fb3d03d0040 100644 --- a/include/sound/tas2781.h +++ b/include/sound/tas2781.h @@ -2,7 +2,7 @@ // // ALSA SoC Texas Instruments TAS2563/TAS2781 Audio Smart Amplifier // -// Copyright (C) 2022 - 2023 Texas Instruments Incorporated +// Copyright (C) 2022 - 2024 Texas Instruments Incorporated // https://www.ti.com // // The TAS2563/TAS2781 driver implements a flexible and configurable @@ -23,6 +23,8 @@ #define SMARTAMP_MODULE_NAME "tas2781" #define TAS2781_GLOBAL_ADDR 0x40 #define TAS2563_GLOBAL_ADDR 0x48 +#define CAL_DAT_SZ 20 + #define TASDEVICE_RATES (SNDRV_PCM_RATE_44100 |\ SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 |\ SNDRV_PCM_RATE_88200) @@ -31,6 +33,11 @@ SNDRV_PCM_FMTBIT_S24_LE | \ SNDRV_PCM_FMTBIT_S32_LE) +#define TASDEVICE_CMD_SING_W 0x1 +#define TASDEVICE_CMD_BURST 0x2 +#define TASDEVICE_CMD_DELAY 0x3 +#define TASDEVICE_CMD_FIELD_W 0x4 + /*PAGE Control Register (available in page0 of each book) */ #define TASDEVICE_PAGE_SELECT 0x00 #define TASDEVICE_BOOKCTL_PAGE 0x00 @@ -43,21 +50,73 @@ (page * 128)) + reg) /*Software Reset */ -#define TAS2781_REG_SWRESET TASDEVICE_REG(0x0, 0X0, 0x01) -#define TAS2781_REG_SWRESET_RESET BIT(0) +#define TASDEVICE_REG_SWRESET TASDEVICE_REG(0x00, 0X00, 0x01) +#define TASDEVICE_REG_SWRESET_RESET BIT(0) /*I2C Checksum */ -#define TASDEVICE_I2CChecksum TASDEVICE_REG(0x0, 0x0, 0x7E) +#define TASDEVICE_I2CChecksum TASDEVICE_REG(0x00, 0x00, 0x7E) + +/* XM_340 */ +#define TASDEVICE_XM_A1_REG TASDEVICE_REG(0x64, 0x02, 0x4c) +/* XM_341 */ +#define TASDEVICE_XM_A2_REG TASDEVICE_REG(0x64, 0x02, 0x64) /* Volume control */ -#define TAS2781_DVC_LVL TASDEVICE_REG(0x0, 0x0, 0x1A) -#define TAS2781_AMP_LEVEL TASDEVICE_REG(0x0, 0x0, 0x03) +#define TAS2563_DVC_LVL TASDEVICE_REG(0x00, 0x02, 0x0C) +#define TAS2781_DVC_LVL TASDEVICE_REG(0x00, 0x00, 0x1A) +#define TAS2781_AMP_LEVEL TASDEVICE_REG(0x00, 0x00, 0x03) #define TAS2781_AMP_LEVEL_MASK GENMASK(5, 1) -#define TASDEVICE_CMD_SING_W 0x1 -#define TASDEVICE_CMD_BURST 0x2 -#define TASDEVICE_CMD_DELAY 0x3 -#define TASDEVICE_CMD_FIELD_W 0x4 +#define TAS2563_PRM_R0_REG TASDEVICE_REG(0x00, 0x0f, 0x34) +#define TAS2563_PRM_R0_LOW_REG TASDEVICE_REG(0x00, 0x0f, 0x48) +#define TAS2563_PRM_INVR0_REG TASDEVICE_REG(0x00, 0x0f, 0x40) +#define TAS2563_PRM_POW_REG TASDEVICE_REG(0x00, 0x0d, 0x3c) +#define TAS2563_PRM_TLIMIT_REG TASDEVICE_REG(0x00, 0x10, 0x14) + +#define TAS2563_RUNTIME_RE_REG_TF TASDEVICE_REG(0x64, 0x02, 0x70) +#define TAS2563_RUNTIME_RE_REG TASDEVICE_REG(0x64, 0x02, 0x48) + +#define TAS2563_PRM_ENFF_REG TASDEVICE_REG(0x00, 0x0d, 0x54) +#define TAS2563_PRM_DISTCK_REG TASDEVICE_REG(0x00, 0x0d, 0x58) +#define TAS2563_PRM_TE_SCTHR_REG TASDEVICE_REG(0x00, 0x0f, 0x60) +#define TAS2563_PRM_PLT_FLAG_REG TASDEVICE_REG(0x00, 0x0d, 0x74) +#define TAS2563_PRM_SINEGAIN_REG TASDEVICE_REG(0x00, 0x0d, 0x7c) +/* prm_Int_B0 */ +#define TAS2563_TE_TA1_REG TASDEVICE_REG(0x00, 0x10, 0x0c) +/* prm_Int_A1 */ +#define TAS2563_TE_TA1_AT_REG TASDEVICE_REG(0x00, 0x10, 0x10) +/* prm_TE_Beta */ +#define TAS2563_TE_TA2_REG TASDEVICE_REG(0x00, 0x0f, 0x64) +/* prm_TE_Beta1 */ +#define TAS2563_TE_AT_REG TASDEVICE_REG(0x00, 0x0f, 0x68) +/* prm_TE_1_Beta1 */ +#define TAS2563_TE_DT_REG TASDEVICE_REG(0x00, 0x0f, 0x70) + +#define TAS2781_PRM_R0_REG TASDEVICE_REG(0x00, 0x17, 0x74) +#define TAS2781_PRM_R0_LOW_REG TASDEVICE_REG(0x00, 0x18, 0x0c) +#define TAS2781_PRM_INVR0_REG TASDEVICE_REG(0x00, 0x18, 0x14) +#define TAS2781_PRM_POW_REG TASDEVICE_REG(0x00, 0x13, 0x70) +#define TAS2781_PRM_TLIMIT_REG TASDEVICE_REG(0x00, 0x18, 0x7c) + +#define TAS2781_PRM_INT_MASK_REG TASDEVICE_REG(0x00, 0x00, 0x3b) +#define TAS2781_PRM_CLK_CFG_REG TASDEVICE_REG(0x00, 0x00, 0x5c) +#define TAS2781_PRM_RSVD_REG TASDEVICE_REG(0x00, 0x01, 0x19) +#define TAS2781_PRM_TEST_57_REG TASDEVICE_REG(0x00, 0xfd, 0x39) +#define TAS2781_PRM_TEST_62_REG TASDEVICE_REG(0x00, 0xfd, 0x3e) +#define TAS2781_PRM_PVDD_UVLO_REG TASDEVICE_REG(0x00, 0x00, 0x71) +#define TAS2781_PRM_CHNL_0_REG TASDEVICE_REG(0x00, 0x00, 0x03) +#define TAS2781_PRM_NG_CFG0_REG TASDEVICE_REG(0x00, 0x00, 0x35) +#define TAS2781_PRM_IDLE_CH_DET_REG TASDEVICE_REG(0x00, 0x00, 0x66) +#define TAS2781_PRM_PLT_FLAG_REG TASDEVICE_REG(0x00, 0x14, 0x38) +#define TAS2781_PRM_SINEGAIN_REG TASDEVICE_REG(0x00, 0x14, 0x40) +#define TAS2781_PRM_SINEGAIN2_REG TASDEVICE_REG(0x00, 0x14, 0x44) + +#define TAS2781_TEST_UNLOCK_REG TASDEVICE_REG(0x00, 0xFD, 0x0D) +#define TAS2781_TEST_PAGE_UNLOCK 0x0D + +#define TAS2781_RUNTIME_LATCH_RE_REG TASDEVICE_REG(0x00, 0x00, 0x49) +#define TAS2781_RUNTIME_RE_REG_TF TASDEVICE_REG(0x64, 0x62, 0x48) +#define TAS2781_RUNTIME_RE_REG TASDEVICE_REG(0x64, 0x63, 0x44) enum audio_device { TAS2563, @@ -69,7 +128,15 @@ enum device_catlog_id { OTHERS }; +struct bulk_reg_val { + int reg; + unsigned char val[4]; + unsigned char val_len; + bool is_locked; +}; + struct tasdevice { + struct bulk_reg_val *cali_data_restore; struct tasdevice_fw *cali_data_fmw; unsigned int dev_addr; unsigned int err_code; @@ -88,6 +155,8 @@ struct tasdevice_irqinfo { struct calidata { unsigned char *data; unsigned long total_sz; + unsigned int *reg_array; + unsigned int reg_array_sz; }; struct tasdevice_priv { @@ -122,6 +191,7 @@ struct tasdevice_priv { bool force_fwload_status; bool playback_started; bool isacpi; + bool is_user_space_calidata; unsigned int global_addr; int (*fw_parse_variable_header)(struct tasdevice_priv *tas_priv, @@ -148,6 +218,8 @@ int tasdevice_init(struct tasdevice_priv *tas_priv); void tasdevice_remove(struct tasdevice_priv *tas_priv); int tasdevice_save_calibration(struct tasdevice_priv *tas_priv); void tasdevice_apply_calibration(struct tasdevice_priv *tas_priv); +int tasdevice_chn_switch(struct tasdevice_priv *tas_priv, + unsigned short chn); int tasdevice_dev_read(struct tasdevice_priv *tas_priv, unsigned short chn, unsigned int reg, unsigned int *value); int tasdevice_dev_write(struct tasdevice_priv *tas_priv, diff --git a/sound/soc/codecs/tas2781-comlib.c b/sound/soc/codecs/tas2781-comlib.c index 3aa81514dad7..9d7b56663b6b 100644 --- a/sound/soc/codecs/tas2781-comlib.c +++ b/sound/soc/codecs/tas2781-comlib.c @@ -1,8 +1,8 @@ // SPDX-License-Identifier: GPL-2.0 // -// tas2781-lib.c -- TAS2781 Common functions for HDA and ASoC Audio drivers +// tas2781-comlib.c -- TAS2781 Common functions for HDA and ASoC Audio drivers // -// Copyright 2023 Texas Instruments, Inc. +// Copyright 2023 - 2024 Texas Instruments, Inc. // // Author: Shenghao Ding <shenghao-ding(a)ti.com> @@ -89,6 +89,33 @@ static int tasdevice_change_chn_book(struct tasdevice_priv *tas_priv, return ret; } +int tasdevice_chn_switch(struct tasdevice_priv *tas_priv, + unsigned short chn) +{ + struct i2c_client *client = (struct i2c_client *)tas_priv->client; + struct tasdevice *tasdev = &tas_priv->tasdevice[chn]; + struct regmap *map = tas_priv->regmap; + int ret; + + if (client->addr != tasdev->dev_addr) { + client->addr = tasdev->dev_addr; + /* All devices share the same regmap, clear the page + * inside regmap once switching to another device. + * Register 0 at any pages and any books inside tas2781 + * is the same one for page-switching. + */ + ret = regmap_write(map, TASDEVICE_PAGE_SELECT, 0); + if (ret < 0) { + dev_err(tas_priv->dev, "%s, E=%d\n", + __func__, ret); + return ret; + } + return 1; + } + return 0; +} +EXPORT_SYMBOL_GPL(tasdevice_chn_switch); + int tasdevice_dev_read(struct tasdevice_priv *tas_priv, unsigned short chn, unsigned int reg, unsigned int *val) { @@ -254,8 +281,8 @@ void tas2781_reset(struct tasdevice_priv *tas_dev) } else { for (i = 0; i < tas_dev->ndev; i++) { ret = tasdevice_dev_write(tas_dev, i, - TAS2781_REG_SWRESET, - TAS2781_REG_SWRESET_RESET); + TASDEVICE_REG_SWRESET, + TASDEVICE_REG_SWRESET_RESET); if (ret < 0) dev_err(tas_dev->dev, "dev %d swreset fail, %d\n", diff --git a/sound/soc/codecs/tas2781-fmwlib.c b/sound/soc/codecs/tas2781-fmwlib.c index 265a8ca25cbb..19a5133083dc 100644 --- a/sound/soc/codecs/tas2781-fmwlib.c +++ b/sound/soc/codecs/tas2781-fmwlib.c @@ -2153,20 +2153,39 @@ static int tasdevice_load_data(struct tasdevice_priv *tas_priv, static void tasdev_load_calibrated_data(struct tasdevice_priv *priv, int i) { + struct tasdevice_fw *cal_fmw = priv->tasdevice[i].cali_data_fmw; + struct calidata *cali_data = &priv->cali_data; + unsigned char *data = cali_data->data; struct tasdevice_calibration *cal; - struct tasdevice_fw *cal_fmw; + int k = i * (CAL_DAT_SZ + 1); + int j, rc; - cal_fmw = priv->tasdevice[i].cali_data_fmw; + if (!priv->is_user_space_calidata && + cal_fmw) { + cal = cal_fmw->calibrations; - /* No calibrated data for current devices, playback will go ahead. */ - if (!cal_fmw) + if (cal) + load_calib_data(priv, &cal->dev_data); return; - - cal = cal_fmw->calibrations; - if (cal) + } + if (!priv->is_user_space_calidata) return; - - load_calib_data(priv, &cal->dev_data); + /* load calibrated data from user space */ + if (data[k] != i) { + dev_err(priv->dev, "%s: no cal-data for dev %d from usr-spc\n", + __func__, i); + return; + } + for (j = 0; j < cali_data->reg_array_sz; j++) { + if (data[k] != j) + rc = tasdevice_dev_bulk_write(priv, i, + cali_data->reg_array[j], + &(data[k + 4 * j]), 4); + if (rc < 0) + dev_err(priv->dev, + "chn %d calib %d bulk_wr err = %d\n", + i, j, rc); + } } int tasdevice_select_tuningprm_cfg(void *context, int prm_no, @@ -2261,9 +2280,10 @@ int tasdevice_select_tuningprm_cfg(void *context, int prm_no, tas_priv->tasdevice[i].cur_conf = cfg_no; } } - } else + } else { dev_dbg(tas_priv->dev, "%s: Unneeded loading dsp conf %d\n", __func__, cfg_no); + } status |= cfg_info[rca_conf_no]->active_dev; @@ -2324,13 +2344,15 @@ void tasdevice_tuning_switch(void *context, int state) struct tasdevice_fw *tas_fmw = tas_priv->fmw; int profile_cfg_id = tas_priv->rcabin.profile_cfg_id; - if (tas_priv->fw_state == TASDEVICE_DSP_FW_FAIL) { - dev_err(tas_priv->dev, "DSP bin file not loaded\n"); + /* Only RCA file loaded still can work without speaker protection */ + if (!(tas_priv->fw_state == TASDEVICE_RCA_FW_OK || + tas_priv->fw_state == TASDEVICE_DSP_FW_ALL_OK)) { + dev_err(tas_priv->dev, "No firmware loaded\n"); return; } if (state == 0) { - if (tas_priv->cur_prog < tas_fmw->nr_programs) { + if (tas_fmw && tas_priv->cur_prog < tas_fmw->nr_programs) { /*dsp mode or tuning mode*/ profile_cfg_id = tas_priv->rcabin.profile_cfg_id; tasdevice_select_tuningprm_cfg(tas_priv, @@ -2340,9 +2362,10 @@ void tasdevice_tuning_switch(void *context, int state) tasdevice_select_cfg_blk(tas_priv, profile_cfg_id, TASDEVICE_BIN_BLK_PRE_POWER_UP); - } else + } else { tasdevice_select_cfg_blk(tas_priv, profile_cfg_id, TASDEVICE_BIN_BLK_PRE_SHUTDOWN); + } } EXPORT_SYMBOL_NS_GPL(tasdevice_tuning_switch, SND_SOC_TAS2781_FMWLIB); diff --git a/sound/soc/codecs/tas2781-i2c.c b/sound/soc/codecs/tas2781-i2c.c index 9350972dfefe..239f3538c558 100644 --- a/sound/soc/codecs/tas2781-i2c.c +++ b/sound/soc/codecs/tas2781-i2c.c @@ -13,6 +13,7 @@ // Author: Kevin Lu <kevin-lu(a)ti.com> // +#include <asm/unaligned.h> #include <linux/crc8.h> #include <linux/firmware.h> #include <linux/gpio/consumer.h> @@ -31,6 +32,122 @@ #include <sound/tlv.h> #include <sound/tas2781-tlv.h> +static const struct bulk_reg_val tas2563_cali_start_reg[] = { + { + .reg = TAS2563_PRM_ENFF_REG, + .val = { 0x40, 0x00, 0x00, 0x00 }, + }, + { + .reg = TAS2563_PRM_DISTCK_REG, + .val = { 0x40, 0x00, 0x00, 0x00 }, + }, + { + .reg = TAS2563_PRM_TE_SCTHR_REG, + .val = { 0x7f, 0xff, 0xff, 0xff }, + }, + { + .reg = TAS2563_PRM_PLT_FLAG_REG, + .val = { 0x40, 0x00, 0x00, 0x00 }, + }, + { + .reg = TAS2563_PRM_SINEGAIN_REG, + .val = { 0x0a, 0x3d, 0x70, 0xa4 }, + }, + { + .reg = TAS2563_TE_TA1_REG, + .val = { 0x00, 0x36, 0x91, 0x5e }, + }, + { + .reg = TAS2563_TE_TA1_AT_REG, + .val = { 0x00, 0x36, 0x91, 0x5e }, + }, + { + .reg = TAS2563_TE_TA2_REG, + .val = { 0x00, 0x06, 0xd3, 0x72 }, + }, + { + .reg = TAS2563_TE_AT_REG, + .val = { 0x00, 0x36, 0x91, 0x5e }, + }, + { + .reg = TAS2563_TE_DT_REG, + .val = { 0x00, 0x36, 0x91, 0x5e }, + }, +}; + +static const struct bulk_reg_val tas2781_cali_start_reg[] = { + { + .reg = TAS2781_PRM_INT_MASK_REG, + .val = { 0xfe }, + .val_len = 1, + .is_locked = false + }, + { + .reg = TAS2781_PRM_CLK_CFG_REG, + .val = { 0xdd }, + .val_len = 1, + .is_locked = false + }, + { + .reg = TAS2781_PRM_RSVD_REG, + .val = { 0x20 }, + .val_len = 1, + .is_locked = false + }, + { + .reg = TAS2781_PRM_TEST_57_REG, + .val = { 0x14 }, + .val_len = 1, + .is_locked = true + }, + { + .reg = TAS2781_PRM_TEST_62_REG, + .val = { 0x45 }, + .val_len = 1, + .is_locked = true + }, + { + .reg = TAS2781_PRM_PVDD_UVLO_REG, + .val = { 0x03 }, + .val_len = 1, + .is_locked = false + }, + { + .reg = TAS2781_PRM_CHNL_0_REG, + .val = { 0xA8 }, + .val_len = 1, + .is_locked = false + }, + { + .reg = TAS2781_PRM_NG_CFG0_REG, + .val = { 0xb9 }, + .val_len = 1, + .is_locked = false + }, + { + .reg = TAS2781_PRM_IDLE_CH_DET_REG, + .val = { 0x92 }, + .val_len = 1, + .is_locked = false + }, + { + .reg = TAS2781_PRM_PLT_FLAG_REG, + .val = { 0x40, 0x00, 0x00, 0x00 }, + .val_len = 4, + .is_locked = false + }, + { + .reg = TAS2781_PRM_SINEGAIN_REG, + .val_len = 4, + .is_locked = false + }, + { + .reg = TAS2781_PRM_SINEGAIN2_REG, + .val_len = 4, + .is_locked = false + }, +}; + static const struct i2c_device_id tasdevice_id[] = { { "tas2563", TAS2563 }, { "tas2781", TAS2781 }, @@ -47,6 +164,22 @@ static const struct of_device_id tasdevice_of_match[] = { MODULE_DEVICE_TABLE(of, tasdevice_of_match); #endif +static const int tas2563_cali_data_reg[] = { + TAS2563_PRM_R0_REG, + TAS2563_PRM_R0_LOW_REG, + TAS2563_PRM_INVR0_REG, + TAS2563_PRM_POW_REG, + TAS2563_PRM_TLIMIT_REG, +}; + +static const int tas2781_cali_data_reg[] = { + TAS2781_PRM_R0_REG, + TAS2781_PRM_R0_LOW_REG, + TAS2781_PRM_INVR0_REG, + TAS2781_PRM_POW_REG, + TAS2781_PRM_TLIMIT_REG, +}; + /** * tas2781_digital_getvol - get the volum control * @kcontrol: control pointer @@ -65,8 +198,13 @@ static int tas2781_digital_getvol(struct snd_kcontrol *kcontrol, struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(codec); struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value; + int rc; + + mutex_lock(&tas_priv->codec_lock); + rc = tasdevice_digital_getvol(tas_priv, ucontrol, mc); + mutex_unlock(&tas_priv->codec_lock); - return tasdevice_digital_getvol(tas_priv, ucontrol, mc); + return rc; } static int tas2781_digital_putvol(struct snd_kcontrol *kcontrol, @@ -76,8 +214,13 @@ static int tas2781_digital_putvol(struct snd_kcontrol *kcontrol, struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(codec); struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value; + int rc; + + mutex_lock(&tas_priv->codec_lock); + rc = tasdevice_digital_putvol(tas_priv, ucontrol, mc); + mutex_unlock(&tas_priv->codec_lock); - return tasdevice_digital_putvol(tas_priv, ucontrol, mc); + return rc; } static int tas2781_amp_getvol(struct snd_kcontrol *kcontrol, @@ -87,8 +230,13 @@ static int tas2781_amp_getvol(struct snd_kcontrol *kcontrol, struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(codec); struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value; + int rc; + + mutex_lock(&tas_priv->codec_lock); + rc = tasdevice_amp_getvol(tas_priv, ucontrol, mc); + mutex_unlock(&tas_priv->codec_lock); - return tasdevice_amp_getvol(tas_priv, ucontrol, mc); + return rc; } static int tas2781_amp_putvol(struct snd_kcontrol *kcontrol, @@ -99,11 +247,16 @@ static int tas2781_amp_putvol(struct snd_kcontrol *kcontrol, snd_soc_component_get_drvdata(codec); struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value; + int rc; + + mutex_lock(&tas_priv->codec_lock); + rc = tasdevice_amp_putvol(tas_priv, ucontrol, mc); + mutex_unlock(&tas_priv->codec_lock); - return tasdevice_amp_putvol(tas_priv, ucontrol, mc); + return rc; } -static int tas2781_force_fwload_get(struct snd_kcontrol *kcontrol, +static int tasdev_force_fwload_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_soc_component *component = @@ -118,7 +271,7 @@ static int tas2781_force_fwload_get(struct snd_kcontrol *kcontrol, return 0; } -static int tas2781_force_fwload_put(struct snd_kcontrol *kcontrol, +static int tasdev_force_fwload_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_soc_component *component = @@ -127,18 +280,496 @@ static int tas2781_force_fwload_put(struct snd_kcontrol *kcontrol, snd_soc_component_get_drvdata(component); bool change, val = (bool)ucontrol->value.integer.value[0]; + mutex_lock(&tas_priv->codec_lock); if (tas_priv->force_fwload_status == val) change = false; else { change = true; tas_priv->force_fwload_status = val; } + mutex_unlock(&tas_priv->codec_lock); dev_dbg(tas_priv->dev, "%s : Force FWload %s\n", __func__, tas_priv->force_fwload_status ? "ON" : "OFF"); return change; } +static int tasdev_cali_data_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(comp); + struct soc_bytes_ext *bytes_ext = + (struct soc_bytes_ext *) kcontrol->private_value; + unsigned char *dst = ucontrol->value.bytes.data; + unsigned char *data = tas_priv->cali_data.data; + + mutex_lock(&tas_priv->codec_lock); + if (!tas_priv->is_user_space_calidata || + tas_priv->cali_data.total_sz != bytes_ext->max) { + goto out; + } + memcpy(dst, data, bytes_ext->max); +out: + mutex_unlock(&tas_priv->codec_lock); + return 0; +} + +static int calib_data_get(struct tasdevice_priv *tas_priv, int reg, + unsigned char *dst, int data_len) +{ + struct i2c_client *clt = (struct i2c_client *)tas_priv->client; + struct tasdevice *tasdev = tas_priv->tasdevice; + int rc = -1; + int i; + + if (data_len != 4) + return rc; + + for (i = 0; i < tas_priv->ndev; i++) { + if (clt->addr == tasdev[i].dev_addr) { + /* First byte is the device index. */ + dst[0] = i; + tasdevice_dev_bulk_read(tas_priv, i, reg, &dst[1], + 4); + rc = 0; + break; + } + } + + return rc; +} + +static int tas2781_calib_start_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(comp); + struct soc_bytes_ext *bytes_ext = + (struct soc_bytes_ext *) kcontrol->private_value; + const int sum = ARRAY_SIZE(tas2781_cali_start_reg); + unsigned char *dat = ucontrol->value.bytes.data; + int rc = 1; + int i, j; + + mutex_lock(&tas_priv->codec_lock); + if (tas_priv->chip_id != TAS2781 && + bytes_ext->max != 8 * tas_priv->ndev) { + rc = -1; + goto out; + } + + for (i = 0; i < tas_priv->ndev; i++) { + struct tasdevice *tasdev = tas_priv->tasdevice; + struct bulk_reg_val *p = tasdev[i].cali_data_restore; + int k = i * 9; + + if (p == NULL) + continue; + + for (j = 0; j < sum; j++) { + if (p[j].val_len == 1) { + if (p[j].is_locked) + tasdevice_dev_write(tas_priv, i, + TAS2781_TEST_UNLOCK_REG, + TAS2781_TEST_PAGE_UNLOCK); + tasdevice_dev_read(tas_priv, i, p[j].reg, + (int *)&p[j].val[0]); + } else + tasdevice_dev_bulk_read(tas_priv, i, p[j].reg, + p[j].val, 4); + } + + for (j = 0; j < sum - 2; j++) { + if (p[j].val_len == 1) { + if (p[j].is_locked) + tasdevice_dev_write(tas_priv, i, + TAS2781_TEST_UNLOCK_REG, + TAS2781_TEST_PAGE_UNLOCK); + tasdevice_dev_write(tas_priv, i, p[j].reg, + tas2781_cali_start_reg[j].val[0]); + } else + tasdevice_dev_bulk_write(tas_priv, i, p[j].reg, + (unsigned char *) + tas2781_cali_start_reg[j].val, 4); + } + + if (dat[k] != i) { + dev_err(tas_priv->dev, + "%s: no cal-setting for dev %d\n", __func__, + i); + continue; + } + tasdevice_dev_bulk_write(tas_priv, i, p[j].reg, + &dat[i * 9 + 1], 4); + tasdevice_dev_bulk_write(tas_priv, i, p[j + 1].reg, + &dat[i * 9 + 5], 4); + } +out: + mutex_unlock(&tas_priv->codec_lock); + return rc; +} + +static void tas2781_calib_stop_put(struct tasdevice_priv *tas_priv) +{ + const int sum = ARRAY_SIZE(tas2781_cali_start_reg); + int i, j; + + for (i = 0; i < tas_priv->ndev; i++) { + struct tasdevice *tasdev = tas_priv->tasdevice; + struct bulk_reg_val *p = tasdev[i].cali_data_restore; + + if (p == NULL) + continue; + + for (j = 0; j < sum; j++) { + if (p[j].val_len == 1) { + if (p[j].is_locked) + tasdevice_dev_write(tas_priv, i, + TAS2781_TEST_UNLOCK_REG, + TAS2781_TEST_PAGE_UNLOCK); + tasdevice_dev_write(tas_priv, i, p[j].reg, + p[j].val[0]); + } else + tasdevice_dev_bulk_write(tas_priv, i, p[j].reg, + p[j].val, 4); + } + } +} + +static int tas2563_calib_start_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(comp); + const int sum = ARRAY_SIZE(tas2563_cali_start_reg); + int rc = 1; + int i, j; + + mutex_lock(&tas_priv->codec_lock); + if (tas_priv->chip_id != TAS2563) { + rc = -1; + goto out; + } + + for (i = 0; i < tas_priv->ndev; i++) { + struct tasdevice *tasdev = tas_priv->tasdevice; + struct bulk_reg_val *p = tasdev[i].cali_data_restore; + + if (p == NULL) + continue; + for (j = 0; j < sum; j++) { + tasdevice_dev_bulk_read(tas_priv, i, p[j].reg, + p[j].val, 4); + } + + for (j = 0; j < sum; j++) { + tasdevice_dev_bulk_write(tas_priv, i, p[j].reg, + (unsigned char *)tas2563_cali_start_reg[j].val, + 4); + } + } +out: + mutex_unlock(&tas_priv->codec_lock); + return rc; +} + +static void tas2563_calib_stop_put(struct tasdevice_priv *tas_priv) +{ + const int sum = ARRAY_SIZE(tas2563_cali_start_reg); + int i, j; + + for (i = 0; i < tas_priv->ndev; i++) { + struct tasdevice *tasdev = tas_priv->tasdevice; + struct bulk_reg_val *p = tasdev[i].cali_data_restore; + + if (p == NULL) + continue; + + for (j = 0; j < sum; j++) { + tasdevice_dev_bulk_write(tas_priv, i, p[j].reg, + p[j].val, 4); + } + } +} + +static int tasdev_calib_stop_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(comp); + + mutex_lock(&tas_priv->codec_lock); + if (tas_priv->chip_id == TAS2563) + tas2563_calib_stop_put(tas_priv); + else + tas2781_calib_stop_put(tas_priv); + mutex_unlock(&tas_priv->codec_lock); + + return 1; +} + +static int tasdev_cali_data_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(comp); + struct soc_bytes_ext *bytes_ext = + (struct soc_bytes_ext *) kcontrol->private_value; + unsigned char *data = tas_priv->cali_data.data; + int rc = 1; + + mutex_lock(&tas_priv->codec_lock); + if (tas_priv->cali_data.total_sz != bytes_ext->max) { + rc = -1; + goto out; + } + tas_priv->is_user_space_calidata = true; + memcpy(data, ucontrol->value.bytes.data, bytes_ext->max); +out: + mutex_unlock(&tas_priv->codec_lock); + return rc; +} + +static int tas2781_latch_reg_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(comp); + struct i2c_client *clt = (struct i2c_client *)tas_priv->client; + struct tasdevice *tasdev = tas_priv->tasdevice; + unsigned char *dst = ucontrol->value.bytes.data; + int i, val, rc = -1; + + mutex_lock(&tas_priv->codec_lock); + for (i = 0; i < tas_priv->ndev; i++) { + if (clt->addr == tasdev[i].dev_addr) { + /* First byte is the device index. */ + dst[0] = i; + tasdevice_dev_read(tas_priv, i, + TAS2781_RUNTIME_LATCH_RE_REG, &val); + dst[1] = val; + rc = 0; + break; + } + } + mutex_unlock(&tas_priv->codec_lock); + return rc; +} + +static int tasdev_tf_data_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(comp); + struct soc_bytes_ext *bytes_ext = + (struct soc_bytes_ext *) kcontrol->private_value; + unsigned char *dst = ucontrol->value.bytes.data; + unsigned int reg; + int rc = -1; + + if (tas_priv->chip_id == TAS2781) + reg = TAS2781_RUNTIME_RE_REG_TF; + else + reg = TAS2563_RUNTIME_RE_REG_TF; + + mutex_lock(&tas_priv->codec_lock); + rc = calib_data_get(tas_priv, reg, dst, bytes_ext->max - 1); + mutex_unlock(&tas_priv->codec_lock); + + return rc; +} + +static int tasdev_re_data_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(comp); + struct soc_bytes_ext *bytes_ext = + (struct soc_bytes_ext *) kcontrol->private_value; + unsigned char *dst = ucontrol->value.bytes.data; + unsigned int reg; + int rc = -1; + + if (tas_priv->chip_id == TAS2781) + reg = TAS2781_RUNTIME_RE_REG; + else + reg = TAS2563_RUNTIME_RE_REG; + mutex_lock(&tas_priv->codec_lock); + rc = calib_data_get(tas_priv, reg, dst, bytes_ext->max - 1); + mutex_unlock(&tas_priv->codec_lock); + + return rc; +} + +static int tasdev_r0_data_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(comp); + struct soc_bytes_ext *bytes_ext = + (struct soc_bytes_ext *) kcontrol->private_value; + unsigned char *dst = ucontrol->value.bytes.data; + unsigned int reg; + int rc = -1; + + if (tas_priv->chip_id == TAS2781) + reg = TAS2781_PRM_R0_REG; + else + reg = TAS2563_PRM_R0_REG; + mutex_lock(&tas_priv->codec_lock); + rc = calib_data_get(tas_priv, reg, dst, bytes_ext->max - 1); + mutex_unlock(&tas_priv->codec_lock); + + return rc; +} + +static int tasdev_XMA1_data_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(comp); + struct soc_bytes_ext *bytes_ext = + (struct soc_bytes_ext *) kcontrol->private_value; + unsigned char *dst = ucontrol->value.bytes.data; + unsigned int reg = TASDEVICE_XM_A1_REG; + int rc = -1; + + mutex_lock(&tas_priv->codec_lock); + rc = calib_data_get(tas_priv, reg, dst, bytes_ext->max - 1); + mutex_unlock(&tas_priv->codec_lock); + + return rc; +} + +static int tasdev_XMA2_data_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(comp); + struct soc_bytes_ext *bytes_ext = + (struct soc_bytes_ext *) kcontrol->private_value; + unsigned char *dst = ucontrol->value.bytes.data; + unsigned int reg = TASDEVICE_XM_A2_REG; + int rc = -1; + + mutex_lock(&tas_priv->codec_lock); + rc = calib_data_get(tas_priv, reg, dst, bytes_ext->max - 1); + mutex_unlock(&tas_priv->codec_lock); + + return rc; +} + +static int tasdev_nop_get( + struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + return 0; +} + +static int tas2563_digital_gain_get( + struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct soc_mixer_control *mc = + (struct soc_mixer_control *)kcontrol->private_value; + struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_dev = snd_soc_component_get_drvdata(codec); + unsigned int l = 0, r = mc->max; + unsigned int target, ar_mid, mid, ar_l, ar_r; + unsigned int reg = mc->reg; + unsigned char data[4]; + int ret; + + mutex_lock(&tas_dev->codec_lock); + /* Read the primary device */ + ret = tasdevice_dev_bulk_read(tas_dev, 0, reg, data, 4); + if (ret) { + dev_err(tas_dev->dev, "%s, get AMP vol error\n", __func__); + goto out; + } + + target = get_unaligned_be32(&data[0]); + + while (r > 1 + l) { + mid = (l + r) / 2; + ar_mid = get_unaligned_be32(tas2563_dvc_table[mid]); + if (target < ar_mid) + r = mid; + else + l = mid; + } + + ar_l = get_unaligned_be32(tas2563_dvc_table[l]); + ar_r = get_unaligned_be32(tas2563_dvc_table[r]); + + ucontrol->value.integer.value[0] = + abs(target - ar_l) <= abs(target - ar_r) ? l : r; +out: + mutex_unlock(&tas_dev->codec_lock); + return 0; +} + +static int tas2563_digital_gain_put( + struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct soc_mixer_control *mc = + (struct soc_mixer_control *)kcontrol->private_value; + struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_dev = snd_soc_component_get_drvdata(codec); + unsigned int reg = mc->reg; + unsigned int volrd, volwr; + int vol = ucontrol->value.integer.value[0]; + int max = mc->max, i, ret = 1; + unsigned char data[4]; + + vol = clamp(vol, 0, max); + mutex_lock(&tas_dev->codec_lock); + /* Read the primary device */ + ret = tasdevice_dev_bulk_read(tas_dev, 0, reg, data, 4); + if (ret) { + dev_err(tas_dev->dev, "%s, get AMP vol error\n", __func__); + goto out; + } + + volrd = get_unaligned_be32(&data[0]); + volwr = get_unaligned_be32(tas2563_dvc_table[vol]); + + if (volrd == volwr) { + ret = 0; + goto out; + } + + for (i = 0; i < tas_dev->ndev; i++) { + ret = tasdevice_dev_bulk_write(tas_dev, i, reg, + (unsigned char *)tas2563_dvc_table[vol], 4); + if (ret) + dev_err(tas_dev->dev, + "%s, set digital vol error in device %d\n", + __func__, i); + } + +out: + mutex_unlock(&tas_dev->codec_lock); + return ret; +} + +static const struct snd_kcontrol_new tasdevice_snd_controls[] = { + SOC_SINGLE_BOOL_EXT("Speaker Force Firmware Load", 0, + tasdev_force_fwload_get, tasdev_force_fwload_put), +}; + +static const struct snd_kcontrol_new tasdevice_cali_controls[] = { + SOC_SINGLE_EXT("Calibration Stop", SND_SOC_NOPM, 0, 1, 0, + tasdev_nop_get, tasdev_calib_stop_put), + SND_SOC_BYTES_EXT("Amp TF Data", 5, tasdev_tf_data_get, NULL), + SND_SOC_BYTES_EXT("Amp RE Data", 5, tasdev_re_data_get, NULL), + SND_SOC_BYTES_EXT("Amp R0 Data", 5, tasdev_r0_data_get, NULL), + SND_SOC_BYTES_EXT("Amp XMA1 Data", 5, tasdev_XMA1_data_get, NULL), + SND_SOC_BYTES_EXT("Amp XMA2 Data", 5, tasdev_XMA2_data_get, NULL), +}; + static const struct snd_kcontrol_new tas2781_snd_controls[] = { SOC_SINGLE_RANGE_EXT_TLV("Speaker Analog Gain", TAS2781_AMP_LEVEL, 1, 0, 20, 0, tas2781_amp_getvol, @@ -146,8 +777,22 @@ static const struct snd_kcontrol_new tas2781_snd_controls[] = { SOC_SINGLE_RANGE_EXT_TLV("Speaker Digital Gain", TAS2781_DVC_LVL, 0, 0, 200, 1, tas2781_digital_getvol, tas2781_digital_putvol, dvc_tlv), - SOC_SINGLE_BOOL_EXT("Speaker Force Firmware Load", 0, - tas2781_force_fwload_get, tas2781_force_fwload_put), +}; + +static const struct snd_kcontrol_new tas2781_cali_controls[] = { + SND_SOC_BYTES_EXT("Amp Latch Data", 2, tas2781_latch_reg_get, NULL), +}; + +static const struct snd_kcontrol_new tas2563_snd_controls[] = { + SOC_SINGLE_RANGE_EXT_TLV("Speaker Digital Gain", TAS2563_DVC_LVL, 0, + 0, ARRAY_SIZE(tas2563_dvc_table) - 1, 0, + tas2563_digital_gain_get, tas2563_digital_gain_put, + tas2563_dvc_tlv), +}; + +static const struct snd_kcontrol_new tas2563_cali_controls[] = { + SOC_SINGLE_EXT("Calibration Start", SND_SOC_NOPM, 0, 1, 0, + tasdev_nop_get, tas2563_calib_start_put), }; static int tasdevice_set_profile_id(struct snd_kcontrol *kcontrol, @@ -167,6 +812,31 @@ static int tasdevice_set_profile_id(struct snd_kcontrol *kcontrol, return ret; } +static int tasdevice_info_active_id(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_info *uinfo) +{ + struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(codec); + + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; + uinfo->count = 1; + uinfo->value.integer.min = 0; + uinfo->value.integer.max = (int)tas_priv->ndev - 1; + + return 0; +} + +static int tasdevice_info_chip_id(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_info *uinfo) +{ + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; + uinfo->count = 1; + uinfo->value.integer.min = TAS2563; + uinfo->value.integer.max = TAS2781; + + return 0; +} + static int tasdevice_info_programs(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { @@ -223,6 +893,17 @@ static int tasdevice_get_profile_id(struct snd_kcontrol *kcontrol, return 0; } +static int tasdevice_get_chip_id(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(codec); + + ucontrol->value.integer.value[0] = tas_priv->chip_id; + + return 0; +} + static int tasdevice_create_control(struct tasdevice_priv *tas_priv) { struct snd_kcontrol_new *prof_ctrls; @@ -316,15 +997,54 @@ static int tasdevice_configuration_put( return ret; } -static int tasdevice_dsp_create_ctrls( - struct tasdevice_priv *tas_priv) +static int tasdevice_active_id_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(codec); + struct i2c_client *clt = (struct i2c_client *)tas_priv->client; + struct tasdevice *tasdev = tas_priv->tasdevice; + int i; + + for (i = 0; i < tas_priv->ndev; i++) { + if (clt->addr == tasdev[i].dev_addr) { + ucontrol->value.integer.value[0] = i; + return 0; + } + } + + return -1; +} + +static int tasdevice_active_id_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol); + struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(codec); + int nr_dev = ucontrol->value.integer.value[0]; + int max = tas_priv->ndev - 1, rc; + + nr_dev = clamp(nr_dev, 0, max); + + mutex_lock(&tas_priv->codec_lock); + rc = tasdevice_chn_switch(tas_priv, nr_dev); + mutex_unlock(&tas_priv->codec_lock); + + return rc; +} + +static int tasdevice_dsp_create_ctrls(struct tasdevice_priv *tas_priv) { + char *active_dev_name, *cali_name, *chip_id, *conf_name, *prog_name; + struct calidata *cali_data = &tas_priv->cali_data; struct snd_kcontrol_new *dsp_ctrls; - char *prog_name, *conf_name; - int nr_controls = 2; + struct soc_bytes_ext *ext_cali_data; + int nr_controls = 5; int mix_index = 0; int ret; + if (tas_priv->chip_id == TAS2781) + nr_controls++; /* Alloc kcontrol via devm_kzalloc, which don't manually * free the kcontrol */ @@ -336,11 +1056,20 @@ static int tasdevice_dsp_create_ctrls( } /* Create a mixer item for selecting the active profile */ - prog_name = devm_kzalloc(tas_priv->dev, + active_dev_name = devm_kzalloc(tas_priv->dev, + SNDRV_CTL_ELEM_ID_NAME_MAXLEN, GFP_KERNEL); + cali_name = devm_kzalloc(tas_priv->dev, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, + GFP_KERNEL); + chip_id = devm_kzalloc(tas_priv->dev, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, + GFP_KERNEL); + conf_name = devm_kzalloc(tas_priv->dev, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, GFP_KERNEL); - conf_name = devm_kzalloc(tas_priv->dev, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, + prog_name = devm_kzalloc(tas_priv->dev, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, GFP_KERNEL); - if (!prog_name || !conf_name) { + ext_cali_data = devm_kzalloc(tas_priv->dev, sizeof(*ext_cali_data), + GFP_KERNEL); + if (!active_dev_name || !cali_name || !conf_name || !chip_id || + !ext_cali_data || !prog_name) { ret = -ENOMEM; goto out; } @@ -363,6 +1092,68 @@ static int tasdevice_dsp_create_ctrls( dsp_ctrls[mix_index].put = tasdevice_configuration_put; mix_index++; + scnprintf(active_dev_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, + "Activate Tasdevice Id"); + dsp_ctrls[mix_index].name = active_dev_name; + dsp_ctrls[mix_index].iface = SNDRV_CTL_ELEM_IFACE_MIXER; + dsp_ctrls[mix_index].info = tasdevice_info_active_id; + dsp_ctrls[mix_index].get = tasdevice_active_id_get; + dsp_ctrls[mix_index].put = tasdevice_active_id_put; + mix_index++; + + scnprintf(chip_id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, + "Tasdevice Chip Id"); + dsp_ctrls[mix_index].name = chip_id; + dsp_ctrls[mix_index].iface = SNDRV_CTL_ELEM_IFACE_MIXER; + dsp_ctrls[mix_index].info = tasdevice_info_chip_id; + dsp_ctrls[mix_index].get = tasdevice_get_chip_id; + mix_index++; + + scnprintf(cali_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, + "Speaker Calibrated Data"); + ext_cali_data->max = tas_priv->ndev * CAL_DAT_SZ; + tas_priv->cali_data.total_sz = ext_cali_data->max; + tas_priv->cali_data.data = devm_kzalloc(tas_priv->dev, + ext_cali_data->max, GFP_KERNEL); + dsp_ctrls[mix_index].name = cali_name; + dsp_ctrls[mix_index].iface = SNDRV_CTL_ELEM_IFACE_MIXER; + dsp_ctrls[mix_index].info = snd_soc_bytes_info_ext; + dsp_ctrls[mix_index].get = tasdev_cali_data_get; + dsp_ctrls[mix_index].put = tasdev_cali_data_put; + dsp_ctrls[mix_index].private_value = (unsigned long)ext_cali_data; + mix_index++; + + cali_data->data = devm_kzalloc(tas_priv->dev, tas_priv->ndev * + (cali_data->reg_array_sz * 4 + 1), GFP_KERNEL); + if (!cali_data->data) + return -ENOMEM; + + if (tas_priv->chip_id == TAS2781) { + struct soc_bytes_ext *ext_cali_start; + char *cali_start_name; + + cali_start_name = devm_kzalloc(tas_priv->dev, + SNDRV_CTL_ELEM_ID_NAME_MAXLEN, GFP_KERNEL); + ext_cali_start = devm_kzalloc(tas_priv->dev, + sizeof(*ext_cali_start), GFP_KERNEL); + if (!cali_start_name || !ext_cali_start) { + ret = -ENOMEM; + goto out; + } + + scnprintf(cali_start_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, + "Calibration Start"); + ext_cali_data->max = tas_priv->ndev * 9; + dsp_ctrls[mix_index].name = cali_start_name; + dsp_ctrls[mix_index].iface = SNDRV_CTL_ELEM_IFACE_MIXER; + dsp_ctrls[mix_index].info = snd_soc_bytes_info_ext; + dsp_ctrls[mix_index].put = tas2781_calib_start_put; + dsp_ctrls[mix_index].get = tasdev_nop_get; + dsp_ctrls[mix_index].private_value = + (unsigned long)ext_cali_start; + mix_index++; + } + ret = snd_soc_add_component_controls(tas_priv->codec, dsp_ctrls, nr_controls < mix_index ? nr_controls : mix_index); @@ -370,6 +1161,54 @@ static int tasdevice_dsp_create_ctrls( return ret; } +static int tasdevice_create_cali_ctrls(struct tasdevice_priv *tas_priv) +{ + struct calidata *cali_data = &tas_priv->cali_data; + struct snd_kcontrol_new *cali_ctrls; + unsigned int num_controls; + int rc; + + rc = snd_soc_add_component_controls(tas_priv->codec, + tasdevice_cali_controls, ARRAY_SIZE(tasdevice_cali_controls)); + if (rc < 0) { + dev_err(tas_priv->dev, "%s: Add cali control err rc = %d", + __func__, rc); + return rc; + } + + if (tas_priv->chip_id == TAS2781) { + cali_ctrls = (struct snd_kcontrol_new *)tas2781_cali_controls; + num_controls = ARRAY_SIZE(tas2781_cali_controls); + cali_data->reg_array = (unsigned int *)tas2781_cali_data_reg; + cali_data->reg_array_sz = ARRAY_SIZE(tas2781_cali_data_reg); + } else { + struct tasdevice *tasdev = tas_priv->tasdevice; + int i; + + cali_ctrls = (struct snd_kcontrol_new *)tas2563_cali_controls; + num_controls = ARRAY_SIZE(tas2563_cali_controls); + cali_data->reg_array = (unsigned int *)tas2563_cali_data_reg; + cali_data->reg_array_sz = sizeof(tas2563_cali_data_reg); + for (i = 0; i < tas_priv->ndev; i++) { + tasdev[i].cali_data_restore = + kmemdup(tas2563_cali_start_reg, + sizeof(tas2563_cali_start_reg), GFP_KERNEL); + if (!tasdev[i].cali_data_restore) + return -ENOMEM; + } + } + + rc = snd_soc_add_component_controls(tas_priv->codec, cali_ctrls, + num_controls); + if (rc < 0) { + dev_err(tas_priv->dev, "%s: Add control err rc = %d", + __func__, rc); + return rc; + } + + return rc; +} + static void tasdevice_fw_ready(const struct firmware *fmw, void *context) { @@ -380,23 +1219,36 @@ static void tasdevice_fw_ready(const struct firmware *fmw, mutex_lock(&tas_priv->codec_lock); ret = tasdevice_rca_parser(tas_priv, fmw); - if (ret) + if (ret) { + tasdevice_config_info_remove(tas_priv); goto out; + } tasdevice_create_control(tas_priv); tasdevice_dsp_remove(tas_priv); tasdevice_calbin_remove(tas_priv); - tas_priv->fw_state = TASDEVICE_DSP_FW_PENDING; + tas_priv->fw_state = TASDEVICE_RCA_FW_OK; scnprintf(tas_priv->coef_binaryname, 64, "%s_coef.bin", tas_priv->dev_name); + ret = tasdevice_dsp_parser(tas_priv); if (ret) { dev_err(tas_priv->dev, "dspfw load %s error\n", tas_priv->coef_binaryname); - tas_priv->fw_state = TASDEVICE_DSP_FW_FAIL; goto out; } - tasdevice_dsp_create_ctrls(tas_priv); + + ret = tasdevice_dsp_create_ctrls(tas_priv); + if (ret) { + dev_err(tas_priv->dev, "dsp controls error\n"); + goto out; + } + + ret = tasdevice_create_cali_ctrls(tas_priv); + if (ret) { + dev_err(tas_priv->dev, "cali controls error\n"); + goto out; + } tas_priv->fw_state = TASDEVICE_DSP_FW_ALL_OK; @@ -417,9 +1269,8 @@ static void tasdevice_fw_ready(const struct firmware *fmw, tasdevice_prmg_load(tas_priv, 0); tas_priv->cur_prog = 0; out: - if (tas_priv->fw_state == TASDEVICE_DSP_FW_FAIL) { - /*If DSP FW fail, kcontrol won't be created */ - tasdevice_config_info_remove(tas_priv); + if (tas_priv->fw_state == TASDEVICE_RCA_FW_OK) { + /*If DSP FW fail, DSP kcontrol won't be created */ tasdevice_dsp_remove(tas_priv); } mutex_unlock(&tas_priv->codec_lock); @@ -466,14 +1317,14 @@ static int tasdevice_startup(struct snd_pcm_substream *substream, { struct snd_soc_component *codec = dai->component; struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(codec); - int ret = 0; - if (tas_priv->fw_state != TASDEVICE_DSP_FW_ALL_OK) { - dev_err(tas_priv->dev, "DSP bin file not loaded\n"); - ret = -EINVAL; + if (!(tas_priv->fw_state == TASDEVICE_DSP_FW_ALL_OK || + tas_priv->fw_state == TASDEVICE_RCA_FW_OK)) { + dev_err(tas_priv->dev, "Bin file not loaded\n"); + return -EINVAL; } - return ret; + return 0; } static int tasdevice_hw_params(struct snd_pcm_substream *substream, @@ -541,7 +1392,7 @@ static const struct snd_soc_dai_ops tasdevice_dai_ops = { static struct snd_soc_dai_driver tasdevice_dai_driver[] = { { - .name = "tas2781_codec", + .name = "tasdev_codec", .id = 0, .playback = { .stream_name = "Playback", @@ -565,13 +1416,41 @@ static struct snd_soc_dai_driver tasdevice_dai_driver[] = { static int tasdevice_codec_probe(struct snd_soc_component *codec) { struct tasdevice_priv *tas_priv = snd_soc_component_get_drvdata(codec); + int rc; + + if (tas_priv->chip_id == TAS2781) { + rc = snd_soc_add_component_controls(codec, + tas2781_snd_controls, + ARRAY_SIZE(tas2781_snd_controls)); + if (rc < 0) { + dev_err(tas_priv->dev, "%s: Add control err rc = %d", + __func__, rc); + return rc; + } + } else { + rc = snd_soc_add_component_controls(codec, + tas2563_snd_controls, + ARRAY_SIZE(tas2563_snd_controls)); + if (rc < 0) { + dev_err(tas_priv->dev, "%s: Add control err rc = %d", + __func__, rc); + return rc; + } + } + + rc = tascodec_init(tas_priv, codec, THIS_MODULE, tasdevice_fw_ready); - return tascodec_init(tas_priv, codec, THIS_MODULE, tasdevice_fw_ready); + return rc; } static void tasdevice_deinit(void *context) { struct tasdevice_priv *tas_priv = (struct tasdevice_priv *) context; + struct tasdevice *tasdev = tas_priv->tasdevice; + int i; + + for (i = 0; i < tas_priv->ndev; i++) + kfree(tasdev[i].cali_data_restore); tasdevice_config_info_remove(tas_priv); tasdevice_dsp_remove(tas_priv); @@ -591,8 +1470,8 @@ static const struct snd_soc_component_driver soc_codec_driver_tasdevice = { .probe = tasdevice_codec_probe, .remove = tasdevice_codec_remove, - .controls = tas2781_snd_controls, - .num_controls = ARRAY_SIZE(tas2781_snd_controls), + .controls = tasdevice_snd_controls, + .num_controls = ARRAY_SIZE(tasdevice_snd_controls), .dapm_widgets = tasdevice_dapm_widgets, .num_dapm_widgets = ARRAY_SIZE(tasdevice_dapm_widgets), .dapm_routes = tasdevice_audio_map, -- 2.34.1

5 6

[PATCH 0/3] slimbus: use 'time_left' instead of 'timeout' with wait_for_*() functions
by Wolfram Sang 01 Aug '24

01 Aug '24

There is a confusing pattern in the kernel to use a variable named 'timeout' to store the result of wait_for_*() functions causing patterns like: timeout = wait_for_completion_timeout(...) if (!timeout) return -ETIMEDOUT; with all kinds of permutations. Use 'time_left' as a variable to make the code obvious and self explaining. This is part of a tree-wide series. The rest of the patches can be found here (some parts may still be WIP): git://git.kernel.org/pub/scm/linux/kernel/git/wsa/linux.git i2c/time_left Because these patches are generated, I audit them before sending. This is why I will send series step by step. Build bot is happy with these patches, though. No functional changes intended. Wolfram Sang (3): slimbus: messaging: use 'time_left' variable with wait_for_completion_timeout() slimbus: qcom-ctrl: use 'time_left' variable with wait_for_completion_timeout() slimbus: qcom-ngd-ctrl: use 'time_left' variable with wait_for_completion_timeout() drivers/slimbus/messaging.c | 9 +++++---- drivers/slimbus/qcom-ctrl.c | 7 ++++--- drivers/slimbus/qcom-ngd-ctrl.c | 29 ++++++++++++++++------------- 3 files changed, 25 insertions(+), 20 deletions(-) -- 2.43.0

3 6