tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

ASoC: tegra: Add support for S24_LE audio format

Add support for S24_LE format for all internal and IO AHUB
modules, except for ASRC (which is already supported).

The data flow happens as mentioned below:

- ADMAIF picks 24-bit valid data and converts it to 32-bit before
sending to internal AHUB modules. This makes the driver change
simpler for internal AHUB modules.
- IO modules CIF converts the 32-bit data to 24-bit before sending it
to the external world.
- To maintain consistency across modules, conversions between 24-bit
and 32-bit occur either at ADMAIF or at the IO modules CIF.

This feature has been thoroughly tested and verified with all internal
AHUB modules on the Jetson AGX Orin Platform, as well as with the
external RT5640 codec.

Signed-off-by: Ritu Chaudhary <rituc@nvidia.com>
Signed-off-by: Sheetal <sheetal@nvidia.com>
Reviewed-by: Sameer Pujar <spujar@nvidia.com>
Link: https://patch.msgid.link/20241022041330.3421765-1-sheetal@nvidia.com
Signed-off-by: Mark Brown <broonie@kernel.org>

authored by

Ritu Chaudhary and committed by
Mark Brown 4204eccc e6d20a9b

+76 -22
+3
sound/soc/tegra/tegra186_dspk.c
··· 245 245 cif_conf.audio_bits = TEGRA_ACIF_BITS_16; 246 246 cif_conf.client_bits = TEGRA_ACIF_BITS_16; 247 247 break; 248 + case SNDRV_PCM_FORMAT_S24_LE: 248 249 case SNDRV_PCM_FORMAT_S32_LE: 249 250 cif_conf.audio_bits = TEGRA_ACIF_BITS_32; 250 251 cif_conf.client_bits = TEGRA_ACIF_BITS_24; ··· 314 313 .channels_max = 2, 315 314 .rates = SNDRV_PCM_RATE_8000_48000, 316 315 .formats = SNDRV_PCM_FMTBIT_S16_LE | 316 + SNDRV_PCM_FMTBIT_S24_LE | 317 317 SNDRV_PCM_FMTBIT_S32_LE, 318 318 }, 319 319 }, ··· 326 324 .channels_max = 2, 327 325 .rates = SNDRV_PCM_RATE_8000_48000, 328 326 .formats = SNDRV_PCM_FMTBIT_S16_LE | 327 + SNDRV_PCM_FMTBIT_S24_LE | 329 328 SNDRV_PCM_FMTBIT_S32_LE, 330 329 }, 331 330 .ops = &tegra186_dspk_dai_ops,
+9 -2
sound/soc/tegra/tegra210_admaif.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-only 2 + // SPDX-FileCopyrightText: Copyright (c) 2020-2024 NVIDIA CORPORATION & AFFILIATES. 3 + // All rights reserved. 2 4 // 3 5 // tegra210_admaif.c - Tegra ADMAIF driver 4 - // 5 - // Copyright (c) 2020 NVIDIA CORPORATION. All rights reserved. 6 6 7 7 #include <linux/clk.h> 8 8 #include <linux/device.h> ··· 285 285 cif_conf.client_bits = TEGRA_ACIF_BITS_16; 286 286 valid_bit = DATA_16BIT; 287 287 break; 288 + case SNDRV_PCM_FORMAT_S24_LE: 289 + cif_conf.audio_bits = TEGRA_ACIF_BITS_32; 290 + cif_conf.client_bits = TEGRA_ACIF_BITS_24; 291 + valid_bit = DATA_32BIT; 292 + break; 288 293 case SNDRV_PCM_FORMAT_S32_LE: 289 294 cif_conf.audio_bits = TEGRA_ACIF_BITS_32; 290 295 cif_conf.client_bits = TEGRA_ACIF_BITS_32; ··· 566 561 .rates = SNDRV_PCM_RATE_8000_192000, \ 567 562 .formats = SNDRV_PCM_FMTBIT_S8 | \ 568 563 SNDRV_PCM_FMTBIT_S16_LE | \ 564 + SNDRV_PCM_FMTBIT_S24_LE | \ 569 565 SNDRV_PCM_FMTBIT_S32_LE, \ 570 566 }, \ 571 567 .capture = { \ ··· 576 570 .rates = SNDRV_PCM_RATE_8000_192000, \ 577 571 .formats = SNDRV_PCM_FMTBIT_S8 | \ 578 572 SNDRV_PCM_FMTBIT_S16_LE | \ 573 + SNDRV_PCM_FMTBIT_S24_LE | \ 579 574 SNDRV_PCM_FMTBIT_S32_LE, \ 580 575 }, \ 581 576 .ops = &tegra_admaif_dai_ops, \
+7 -2
sound/soc/tegra/tegra210_adx.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-only 2 + // SPDX-FileCopyrightText: Copyright (c) 2021-2024 NVIDIA CORPORATION & AFFILIATES. 3 + // All rights reserved. 2 4 // 3 5 // tegra210_adx.c - Tegra210 ADX driver 4 - // 5 - // Copyright (c) 2021-2023 NVIDIA CORPORATION. All rights reserved. 6 6 7 7 #include <linux/clk.h> 8 8 #include <linux/device.h> ··· 127 127 case SNDRV_PCM_FORMAT_S16_LE: 128 128 audio_bits = TEGRA_ACIF_BITS_16; 129 129 break; 130 + case SNDRV_PCM_FORMAT_S24_LE: 130 131 case SNDRV_PCM_FORMAT_S32_LE: 131 132 audio_bits = TEGRA_ACIF_BITS_32; 132 133 break; ··· 238 237 .rates = SNDRV_PCM_RATE_8000_192000, \ 239 238 .formats = SNDRV_PCM_FMTBIT_S8 | \ 240 239 SNDRV_PCM_FMTBIT_S16_LE | \ 240 + SNDRV_PCM_FMTBIT_S24_LE | \ 241 241 SNDRV_PCM_FMTBIT_S32_LE, \ 242 242 }, \ 243 243 .capture = { \ ··· 248 246 .rates = SNDRV_PCM_RATE_8000_192000, \ 249 247 .formats = SNDRV_PCM_FMTBIT_S8 | \ 250 248 SNDRV_PCM_FMTBIT_S16_LE | \ 249 + SNDRV_PCM_FMTBIT_S24_LE | \ 251 250 SNDRV_PCM_FMTBIT_S32_LE, \ 252 251 }, \ 253 252 .ops = &tegra210_adx_in_dai_ops, \ ··· 264 261 .rates = SNDRV_PCM_RATE_8000_192000, \ 265 262 .formats = SNDRV_PCM_FMTBIT_S8 | \ 266 263 SNDRV_PCM_FMTBIT_S16_LE | \ 264 + SNDRV_PCM_FMTBIT_S16_LE | \ 267 265 SNDRV_PCM_FMTBIT_S32_LE, \ 268 266 }, \ 269 267 .capture = { \ ··· 273 269 .channels_max = 16, \ 274 270 .rates = SNDRV_PCM_RATE_8000_192000, \ 275 271 .formats = SNDRV_PCM_FMTBIT_S8 | \ 272 + SNDRV_PCM_FMTBIT_S16_LE | \ 276 273 SNDRV_PCM_FMTBIT_S16_LE | \ 277 274 SNDRV_PCM_FMTBIT_S32_LE, \ 278 275 }, \
+7 -2
sound/soc/tegra/tegra210_amx.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-only 2 + // SPDX-FileCopyrightText: Copyright (c) 2021-2024 NVIDIA CORPORATION & AFFILIATES. 3 + // All rights reserved. 2 4 // 3 5 // tegra210_amx.c - Tegra210 AMX driver 4 - // 5 - // Copyright (c) 2021-2023 NVIDIA CORPORATION. All rights reserved. 6 6 7 7 #include <linux/clk.h> 8 8 #include <linux/device.h> ··· 144 144 case SNDRV_PCM_FORMAT_S16_LE: 145 145 audio_bits = TEGRA_ACIF_BITS_16; 146 146 break; 147 + case SNDRV_PCM_FORMAT_S24_LE: 147 148 case SNDRV_PCM_FORMAT_S32_LE: 148 149 audio_bits = TEGRA_ACIF_BITS_32; 149 150 break; ··· 267 266 .rates = SNDRV_PCM_RATE_8000_192000, \ 268 267 .formats = SNDRV_PCM_FMTBIT_S8 | \ 269 268 SNDRV_PCM_FMTBIT_S16_LE | \ 269 + SNDRV_PCM_FMTBIT_S24_LE | \ 270 270 SNDRV_PCM_FMTBIT_S32_LE, \ 271 271 }, \ 272 272 .capture = { \ ··· 277 275 .rates = SNDRV_PCM_RATE_8000_192000, \ 278 276 .formats = SNDRV_PCM_FMTBIT_S8 | \ 279 277 SNDRV_PCM_FMTBIT_S16_LE | \ 278 + SNDRV_PCM_FMTBIT_S24_LE | \ 280 279 SNDRV_PCM_FMTBIT_S32_LE, \ 281 280 }, \ 282 281 .ops = &tegra210_amx_in_dai_ops, \ ··· 293 290 .rates = SNDRV_PCM_RATE_8000_192000, \ 294 291 .formats = SNDRV_PCM_FMTBIT_S8 | \ 295 292 SNDRV_PCM_FMTBIT_S16_LE | \ 293 + SNDRV_PCM_FMTBIT_S24_LE | \ 296 294 SNDRV_PCM_FMTBIT_S32_LE, \ 297 295 }, \ 298 296 .capture = { \ ··· 303 299 .rates = SNDRV_PCM_RATE_8000_192000, \ 304 300 .formats = SNDRV_PCM_FMTBIT_S8 | \ 305 301 SNDRV_PCM_FMTBIT_S16_LE | \ 302 + SNDRV_PCM_FMTBIT_S24_LE | \ 306 303 SNDRV_PCM_FMTBIT_S32_LE, \ 307 304 }, \ 308 305 .ops = &tegra210_amx_out_dai_ops, \
+5 -2
sound/soc/tegra/tegra210_dmic.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-only 2 + // SPDX-FileCopyrightText: Copyright (c) 2020-2024 NVIDIA CORPORATION & AFFILIATES. 3 + // All rights reserved. 2 4 // 3 5 // tegra210_dmic.c - Tegra210 DMIC driver 4 - // 5 - // Copyright (c) 2020 NVIDIA CORPORATION. All rights reserved. 6 6 7 7 #include <linux/clk.h> 8 8 #include <linux/device.h> ··· 139 139 case SNDRV_PCM_FORMAT_S16_LE: 140 140 cif_conf.audio_bits = TEGRA_ACIF_BITS_16; 141 141 break; 142 + case SNDRV_PCM_FORMAT_S24_LE: 142 143 case SNDRV_PCM_FORMAT_S32_LE: 143 144 cif_conf.audio_bits = TEGRA_ACIF_BITS_32; 144 145 break; ··· 326 325 .channels_max = 2, 327 326 .rates = SNDRV_PCM_RATE_8000_48000, 328 327 .formats = SNDRV_PCM_FMTBIT_S16_LE | 328 + SNDRV_PCM_FMTBIT_S24_LE | 329 329 SNDRV_PCM_FMTBIT_S32_LE, 330 330 }, 331 331 }, ··· 338 336 .channels_max = 2, 339 337 .rates = SNDRV_PCM_RATE_8000_48000, 340 338 .formats = SNDRV_PCM_FMTBIT_S16_LE | 339 + SNDRV_PCM_FMTBIT_S24_LE | 341 340 SNDRV_PCM_FMTBIT_S32_LE, 342 341 }, 343 342 .ops = &tegra210_dmic_dai_ops,
+12 -2
sound/soc/tegra/tegra210_i2s.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-only 2 + // SPDX-FileCopyrightText: Copyright (c) 2020-2024 NVIDIA CORPORATION & AFFILIATES. 3 + // All rights reserved. 2 4 // 3 5 // tegra210_i2s.c - Tegra210 I2S driver 4 - // 5 - // Copyright (c) 2020 NVIDIA CORPORATION. All rights reserved. 6 6 7 7 #include <linux/clk.h> 8 8 #include <linux/device.h> ··· 629 629 case SNDRV_PCM_FORMAT_S16_LE: 630 630 cif_conf.audio_bits = TEGRA_ACIF_BITS_16; 631 631 break; 632 + case SNDRV_PCM_FORMAT_S24_LE: 632 633 case SNDRV_PCM_FORMAT_S32_LE: 633 634 cif_conf.audio_bits = TEGRA_ACIF_BITS_32; 634 635 break; ··· 656 655 val = I2S_BITS_16; 657 656 sample_size = 16; 658 657 cif_conf.client_bits = TEGRA_ACIF_BITS_16; 658 + break; 659 + case SNDRV_PCM_FORMAT_S24_LE: 660 + val = I2S_BITS_24; 661 + sample_size = 32; 662 + cif_conf.client_bits = TEGRA_ACIF_BITS_24; 659 663 break; 660 664 case SNDRV_PCM_FORMAT_S32_LE: 661 665 val = I2S_BITS_32; ··· 726 720 .rates = SNDRV_PCM_RATE_8000_192000, 727 721 .formats = SNDRV_PCM_FMTBIT_S8 | 728 722 SNDRV_PCM_FMTBIT_S16_LE | 723 + SNDRV_PCM_FMTBIT_S24_LE | 729 724 SNDRV_PCM_FMTBIT_S32_LE, 730 725 }, 731 726 .capture = { ··· 736 729 .rates = SNDRV_PCM_RATE_8000_192000, 737 730 .formats = SNDRV_PCM_FMTBIT_S8 | 738 731 SNDRV_PCM_FMTBIT_S16_LE | 732 + SNDRV_PCM_FMTBIT_S24_LE | 739 733 SNDRV_PCM_FMTBIT_S32_LE, 740 734 }, 741 735 }, ··· 749 741 .rates = SNDRV_PCM_RATE_8000_192000, 750 742 .formats = SNDRV_PCM_FMTBIT_S8 | 751 743 SNDRV_PCM_FMTBIT_S16_LE | 744 + SNDRV_PCM_FMTBIT_S24_LE | 752 745 SNDRV_PCM_FMTBIT_S32_LE, 753 746 }, 754 747 .capture = { ··· 759 750 .rates = SNDRV_PCM_RATE_8000_192000, 760 751 .formats = SNDRV_PCM_FMTBIT_S8 | 761 752 SNDRV_PCM_FMTBIT_S16_LE | 753 + SNDRV_PCM_FMTBIT_S24_LE | 762 754 SNDRV_PCM_FMTBIT_S32_LE, 763 755 }, 764 756 .ops = &tegra210_i2s_dai_ops,
+5 -4
sound/soc/tegra/tegra210_i2s.h
··· 1 - /* SPDX-License-Identifier: GPL-2.0-only */ 2 - /* 3 - * tegra210_i2s.h - Definitions for Tegra210 I2S driver 1 + /* SPDX-License-Identifier: GPL-2.0-only 2 + * SPDX-FileCopyrightText: Copyright (c) 2020-2024 NVIDIA CORPORATION & AFFILIATES. 3 + * All rights reserved. 4 4 * 5 - * Copyright (c) 2020 NVIDIA CORPORATION. All rights reserved. 5 + * tegra210_i2s.h - Definitions for Tegra210 I2S driver 6 6 * 7 7 */ 8 8 ··· 87 87 88 88 #define I2S_BITS_8 1 89 89 #define I2S_BITS_16 3 90 + #define I2S_BITS_24 5 90 91 #define I2S_BITS_32 7 91 92 #define I2S_CTRL_BIT_SIZE_MASK 0x7 92 93
+7 -2
sound/soc/tegra/tegra210_mixer.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-only 2 + // SPDX-FileCopyrightText: Copyright (c) 2021-2024 NVIDIA CORPORATION & AFFILIATES. 3 + // All rights reserved. 2 4 // 3 5 // tegra210_mixer.c - Tegra210 MIXER driver 4 - // 5 - // Copyright (c) 2021 NVIDIA CORPORATION. All rights reserved. 6 6 7 7 #include <linux/clk.h> 8 8 #include <linux/device.h> ··· 248 248 case SNDRV_PCM_FORMAT_S16_LE: 249 249 audio_bits = TEGRA_ACIF_BITS_16; 250 250 break; 251 + case SNDRV_PCM_FORMAT_S24_LE: 251 252 case SNDRV_PCM_FORMAT_S32_LE: 252 253 audio_bits = TEGRA_ACIF_BITS_32; 253 254 break; ··· 313 312 .rates = SNDRV_PCM_RATE_8000_192000, \ 314 313 .formats = SNDRV_PCM_FMTBIT_S8 | \ 315 314 SNDRV_PCM_FMTBIT_S16_LE | \ 315 + SNDRV_PCM_FMTBIT_S24_LE | \ 316 316 SNDRV_PCM_FMTBIT_S32_LE, \ 317 317 }, \ 318 318 .capture = { \ ··· 323 321 .rates = SNDRV_PCM_RATE_8000_192000, \ 324 322 .formats = SNDRV_PCM_FMTBIT_S8 | \ 325 323 SNDRV_PCM_FMTBIT_S16_LE | \ 324 + SNDRV_PCM_FMTBIT_S24_LE | \ 326 325 SNDRV_PCM_FMTBIT_S32_LE, \ 327 326 }, \ 328 327 .ops = &tegra210_mixer_in_dai_ops, \ ··· 339 336 .rates = SNDRV_PCM_RATE_8000_192000, \ 340 337 .formats = SNDRV_PCM_FMTBIT_S8 | \ 341 338 SNDRV_PCM_FMTBIT_S16_LE | \ 339 + SNDRV_PCM_FMTBIT_S24_LE | \ 342 340 SNDRV_PCM_FMTBIT_S32_LE, \ 343 341 }, \ 344 342 .capture = { \ ··· 349 345 .rates = SNDRV_PCM_RATE_8000_192000, \ 350 346 .formats = SNDRV_PCM_FMTBIT_S8 | \ 351 347 SNDRV_PCM_FMTBIT_S16_LE | \ 348 + SNDRV_PCM_FMTBIT_S24_LE | \ 352 349 SNDRV_PCM_FMTBIT_S32_LE, \ 353 350 }, \ 354 351 .ops = &tegra210_mixer_out_dai_ops, \
+7 -2
sound/soc/tegra/tegra210_mvc.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-only 2 + // SPDX-FileCopyrightText: Copyright (c) 2021-2024 NVIDIA CORPORATION & AFFILIATES. 3 + // All rights reserved. 2 4 // 3 5 // tegra210_mvc.c - Tegra210 MVC driver 4 - // 5 - // Copyright (c) 2021 NVIDIA CORPORATION. All rights reserved. 6 6 7 7 #include <linux/clk.h> 8 8 #include <linux/device.h> ··· 441 441 case SNDRV_PCM_FORMAT_S16_LE: 442 442 audio_bits = TEGRA_ACIF_BITS_16; 443 443 break; 444 + case SNDRV_PCM_FORMAT_S24_LE: 444 445 case SNDRV_PCM_FORMAT_S32_LE: 445 446 audio_bits = TEGRA_ACIF_BITS_32; 446 447 break; ··· 570 569 .rates = SNDRV_PCM_RATE_8000_192000, 571 570 .formats = SNDRV_PCM_FMTBIT_S8 | 572 571 SNDRV_PCM_FMTBIT_S16_LE | 572 + SNDRV_PCM_FMTBIT_S24_LE | 573 573 SNDRV_PCM_FMTBIT_S32_LE, 574 574 }, 575 575 .capture = { ··· 580 578 .rates = SNDRV_PCM_RATE_8000_192000, 581 579 .formats = SNDRV_PCM_FMTBIT_S8 | 582 580 SNDRV_PCM_FMTBIT_S16_LE | 581 + SNDRV_PCM_FMTBIT_S24_LE | 583 582 SNDRV_PCM_FMTBIT_S32_LE, 584 583 }, 585 584 }, ··· 595 592 .rates = SNDRV_PCM_RATE_8000_192000, 596 593 .formats = SNDRV_PCM_FMTBIT_S8 | 597 594 SNDRV_PCM_FMTBIT_S16_LE | 595 + SNDRV_PCM_FMTBIT_S24_LE | 598 596 SNDRV_PCM_FMTBIT_S32_LE, 599 597 }, 600 598 .capture = { ··· 605 601 .rates = SNDRV_PCM_RATE_8000_192000, 606 602 .formats = SNDRV_PCM_FMTBIT_S8 | 607 603 SNDRV_PCM_FMTBIT_S16_LE | 604 + SNDRV_PCM_FMTBIT_S24_LE | 608 605 SNDRV_PCM_FMTBIT_S32_LE, 609 606 }, 610 607 .ops = &tegra210_mvc_dai_ops,
+7 -2
sound/soc/tegra/tegra210_ope.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-only 2 + // SPDX-FileCopyrightText: Copyright (c) 2022-2024 NVIDIA CORPORATION & AFFILIATES. 3 + // All rights reserved. 2 4 // 3 5 // tegra210_ope.c - Tegra210 OPE driver 4 - // 5 - // Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. 6 6 7 7 #include <linux/clk.h> 8 8 #include <linux/device.h> ··· 47 47 case SNDRV_PCM_FORMAT_S16_LE: 48 48 audio_bits = TEGRA_ACIF_BITS_16; 49 49 break; 50 + case SNDRV_PCM_FORMAT_S24_LE: 50 51 case SNDRV_PCM_FORMAT_S32_LE: 51 52 audio_bits = TEGRA_ACIF_BITS_32; 52 53 break; ··· 130 129 .rates = SNDRV_PCM_RATE_8000_192000, 131 130 .formats = SNDRV_PCM_FMTBIT_S8 | 132 131 SNDRV_PCM_FMTBIT_S16_LE | 132 + SNDRV_PCM_FMTBIT_S24_LE | 133 133 SNDRV_PCM_FMTBIT_S32_LE, 134 134 }, 135 135 .capture = { ··· 140 138 .rates = SNDRV_PCM_RATE_8000_192000, 141 139 .formats = SNDRV_PCM_FMTBIT_S8 | 142 140 SNDRV_PCM_FMTBIT_S16_LE | 141 + SNDRV_PCM_FMTBIT_S24_LE | 143 142 SNDRV_PCM_FMTBIT_S32_LE, 144 143 }, 145 144 }, ··· 153 150 .rates = SNDRV_PCM_RATE_8000_192000, 154 151 .formats = SNDRV_PCM_FMTBIT_S8 | 155 152 SNDRV_PCM_FMTBIT_S16_LE | 153 + SNDRV_PCM_FMTBIT_S24_LE | 156 154 SNDRV_PCM_FMTBIT_S32_LE, 157 155 }, 158 156 .capture = { ··· 163 159 .rates = SNDRV_PCM_RATE_8000_192000, 164 160 .formats = SNDRV_PCM_FMTBIT_S8 | 165 161 SNDRV_PCM_FMTBIT_S16_LE | 162 + SNDRV_PCM_FMTBIT_S24_LE | 166 163 SNDRV_PCM_FMTBIT_S32_LE, 167 164 }, 168 165 .ops = &tegra210_ope_dai_ops,
+7 -2
sound/soc/tegra/tegra210_sfc.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-only 2 + // SPDX-FileCopyrightText: Copyright (c) 2021-2024 NVIDIA CORPORATION & AFFILIATES. 3 + // All rights reserved. 2 4 // 3 5 // tegra210_sfc.c - Tegra210 SFC driver 4 - // 5 - // Copyright (c) 2021-2023 NVIDIA CORPORATION. All rights reserved. 6 6 7 7 #include <linux/clk.h> 8 8 #include <linux/device.h> ··· 3133 3133 case SNDRV_PCM_FORMAT_S16_LE: 3134 3134 audio_bits = TEGRA_ACIF_BITS_16; 3135 3135 break; 3136 + case SNDRV_PCM_FORMAT_S24_LE: 3136 3137 case SNDRV_PCM_FORMAT_S32_LE: 3137 3138 audio_bits = TEGRA_ACIF_BITS_32; 3138 3139 break; ··· 3396 3395 .rates = SNDRV_PCM_RATE_8000_192000, 3397 3396 .formats = SNDRV_PCM_FMTBIT_S8 | 3398 3397 SNDRV_PCM_FMTBIT_S16_LE | 3398 + SNDRV_PCM_FMTBIT_S24_LE | 3399 3399 SNDRV_PCM_FMTBIT_S32_LE, 3400 3400 }, 3401 3401 .capture = { ··· 3406 3404 .rates = SNDRV_PCM_RATE_8000_192000, 3407 3405 .formats = SNDRV_PCM_FMTBIT_S8 | 3408 3406 SNDRV_PCM_FMTBIT_S16_LE | 3407 + SNDRV_PCM_FMTBIT_S24_LE | 3409 3408 SNDRV_PCM_FMTBIT_S32_LE, 3410 3409 }, 3411 3410 .ops = &tegra210_sfc_in_dai_ops, ··· 3420 3417 .rates = SNDRV_PCM_RATE_8000_192000, 3421 3418 .formats = SNDRV_PCM_FMTBIT_S8 | 3422 3419 SNDRV_PCM_FMTBIT_S16_LE | 3420 + SNDRV_PCM_FMTBIT_S24_LE | 3423 3421 SNDRV_PCM_FMTBIT_S32_LE, 3424 3422 }, 3425 3423 .capture = { ··· 3430 3426 .rates = SNDRV_PCM_RATE_8000_192000, 3431 3427 .formats = SNDRV_PCM_FMTBIT_S8 | 3432 3428 SNDRV_PCM_FMTBIT_S16_LE | 3429 + SNDRV_PCM_FMTBIT_S24_LE | 3433 3430 SNDRV_PCM_FMTBIT_S32_LE, 3434 3431 }, 3435 3432 .ops = &tegra210_sfc_out_dai_ops,