LXR linux/sound/core/pcm

   1/*
   2 *  PCM Interface - misc routines
   3 *  Copyright (c) 1998 by Jaroslav Kysela <perex@perex.cz>
   4 *
   5 *
   6 *   This library is free software; you can redistribute it and/or modify
   7 *   it under the terms of the GNU Library General Public License as
   8 *   published by the Free Software Foundation; either version 2 of
   9 *   the License, or (at your option) any later version.
  10 *
  11 *   This program is distributed in the hope that it will be useful,
  12 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 *   GNU Library General Public License for more details.
  15 *
  16 *   You should have received a copy of the GNU Library General Public
  17 *   License along with this library; if not, write to the Free Software
  18 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 *
  20 */
  21  
  22#include <linux/time.h>
  23#include <linux/export.h>
  24#include <sound/core.h>
  25#include <sound/pcm.h>
  26
  27#include "pcm_local.h"
  28
  29#define SND_PCM_FORMAT_UNKNOWN (-1)
  30
  31/* NOTE: "signed" prefix must be given below since the default char is
  32 *       unsigned on some architectures!
  33 */
  34struct pcm_format_data {
  35        unsigned char width;    /* bit width */
  36        unsigned char phys;     /* physical bit width */
  37        signed char le; /* 0 = big-endian, 1 = little-endian, -1 = others */
  38        signed char signd;      /* 0 = unsigned, 1 = signed, -1 = others */
  39        unsigned char silence[8];       /* silence data to fill */
  40};
  41
  42/* we do lots of calculations on snd_pcm_format_t; shut up sparse */
  43#define INT     __force int
  44
  45static struct pcm_format_data pcm_formats[(INT)SNDRV_PCM_FORMAT_LAST+1] = {
  46        [SNDRV_PCM_FORMAT_S8] = {
  47                .width = 8, .phys = 8, .le = -1, .signd = 1,
  48                .silence = {},
  49        },
  50        [SNDRV_PCM_FORMAT_U8] = {
  51                .width = 8, .phys = 8, .le = -1, .signd = 0,
  52                .silence = { 0x80 },
  53        },
  54        [SNDRV_PCM_FORMAT_S16_LE] = {
  55                .width = 16, .phys = 16, .le = 1, .signd = 1,
  56                .silence = {},
  57        },
  58        [SNDRV_PCM_FORMAT_S16_BE] = {
  59                .width = 16, .phys = 16, .le = 0, .signd = 1,
  60                .silence = {},
  61        },
  62        [SNDRV_PCM_FORMAT_U16_LE] = {
  63                .width = 16, .phys = 16, .le = 1, .signd = 0,
  64                .silence = { 0x00, 0x80 },
  65        },
  66        [SNDRV_PCM_FORMAT_U16_BE] = {
  67                .width = 16, .phys = 16, .le = 0, .signd = 0,
  68                .silence = { 0x80, 0x00 },
  69        },
  70        [SNDRV_PCM_FORMAT_S24_LE] = {
  71                .width = 24, .phys = 32, .le = 1, .signd = 1,
  72                .silence = {},
  73        },
  74        [SNDRV_PCM_FORMAT_S24_BE] = {
  75                .width = 24, .phys = 32, .le = 0, .signd = 1,
  76                .silence = {},
  77        },
  78        [SNDRV_PCM_FORMAT_U24_LE] = {
  79                .width = 24, .phys = 32, .le = 1, .signd = 0,
  80                .silence = { 0x00, 0x00, 0x80 },
  81        },
  82        [SNDRV_PCM_FORMAT_U24_BE] = {
  83                .width = 24, .phys = 32, .le = 0, .signd = 0,
  84                .silence = { 0x00, 0x80, 0x00, 0x00 },
  85        },
  86        [SNDRV_PCM_FORMAT_S32_LE] = {
  87                .width = 32, .phys = 32, .le = 1, .signd = 1,
  88                .silence = {},
  89        },
  90        [SNDRV_PCM_FORMAT_S32_BE] = {
  91                .width = 32, .phys = 32, .le = 0, .signd = 1,
  92                .silence = {},
  93        },
  94        [SNDRV_PCM_FORMAT_U32_LE] = {
  95                .width = 32, .phys = 32, .le = 1, .signd = 0,
  96                .silence = { 0x00, 0x00, 0x00, 0x80 },
  97        },
  98        [SNDRV_PCM_FORMAT_U32_BE] = {
  99                .width = 32, .phys = 32, .le = 0, .signd = 0,
 100                .silence = { 0x80, 0x00, 0x00, 0x00 },
 101        },
 102        [SNDRV_PCM_FORMAT_FLOAT_LE] = {
 103                .width = 32, .phys = 32, .le = 1, .signd = -1,
 104                .silence = {},
 105        },
 106        [SNDRV_PCM_FORMAT_FLOAT_BE] = {
 107                .width = 32, .phys = 32, .le = 0, .signd = -1,
 108                .silence = {},
 109        },
 110        [SNDRV_PCM_FORMAT_FLOAT64_LE] = {
 111                .width = 64, .phys = 64, .le = 1, .signd = -1,
 112                .silence = {},
 113        },
 114        [SNDRV_PCM_FORMAT_FLOAT64_BE] = {
 115                .width = 64, .phys = 64, .le = 0, .signd = -1,
 116                .silence = {},
 117        },
 118        [SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE] = {
 119                .width = 32, .phys = 32, .le = 1, .signd = -1,
 120                .silence = {},
 121        },
 122        [SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE] = {
 123                .width = 32, .phys = 32, .le = 0, .signd = -1,
 124                .silence = {},
 125        },
 126        [SNDRV_PCM_FORMAT_MU_LAW] = {
 127                .width = 8, .phys = 8, .le = -1, .signd = -1,
 128                .silence = { 0x7f },
 129        },
 130        [SNDRV_PCM_FORMAT_A_LAW] = {
 131                .width = 8, .phys = 8, .le = -1, .signd = -1,
 132                .silence = { 0x55 },
 133        },
 134        [SNDRV_PCM_FORMAT_IMA_ADPCM] = {
 135                .width = 4, .phys = 4, .le = -1, .signd = -1,
 136                .silence = {},
 137        },
 138        [SNDRV_PCM_FORMAT_G723_24] = {
 139                .width = 3, .phys = 3, .le = -1, .signd = -1,
 140                .silence = {},
 141        },
 142        [SNDRV_PCM_FORMAT_G723_40] = {
 143                .width = 5, .phys = 5, .le = -1, .signd = -1,
 144                .silence = {},
 145        },
 146        [SNDRV_PCM_FORMAT_DSD_U8] = {
 147                .width = 8, .phys = 8, .le = 1, .signd = 0,
 148                .silence = { 0x69 },
 149        },
 150        [SNDRV_PCM_FORMAT_DSD_U16_LE] = {
 151                .width = 16, .phys = 16, .le = 1, .signd = 0,
 152                .silence = { 0x69, 0x69 },
 153        },
 154        [SNDRV_PCM_FORMAT_DSD_U32_LE] = {
 155                .width = 32, .phys = 32, .le = 1, .signd = 0,
 156                .silence = { 0x69, 0x69, 0x69, 0x69 },
 157        },
 158        [SNDRV_PCM_FORMAT_DSD_U16_BE] = {
 159                .width = 16, .phys = 16, .le = 0, .signd = 0,
 160                .silence = { 0x69, 0x69 },
 161        },
 162        [SNDRV_PCM_FORMAT_DSD_U32_BE] = {
 163                .width = 32, .phys = 32, .le = 0, .signd = 0,
 164                .silence = { 0x69, 0x69, 0x69, 0x69 },
 165        },
 166        /* FIXME: the following two formats are not defined properly yet */
 167        [SNDRV_PCM_FORMAT_MPEG] = {
 168                .le = -1, .signd = -1,
 169        },
 170        [SNDRV_PCM_FORMAT_GSM] = {
 171                .le = -1, .signd = -1,
 172        },
 173        [SNDRV_PCM_FORMAT_S20_LE] = {
 174                .width = 20, .phys = 32, .le = 1, .signd = 1,
 175                .silence = {},
 176        },
 177        [SNDRV_PCM_FORMAT_S20_BE] = {
 178                .width = 20, .phys = 32, .le = 0, .signd = 1,
 179                .silence = {},
 180        },
 181        [SNDRV_PCM_FORMAT_U20_LE] = {
 182                .width = 20, .phys = 32, .le = 1, .signd = 0,
 183                .silence = { 0x00, 0x00, 0x08, 0x00 },
 184        },
 185        [SNDRV_PCM_FORMAT_U20_BE] = {
 186                .width = 20, .phys = 32, .le = 0, .signd = 0,
 187                .silence = { 0x00, 0x08, 0x00, 0x00 },
 188        },
 189        /* FIXME: the following format is not defined properly yet */
 190        [SNDRV_PCM_FORMAT_SPECIAL] = {
 191                .le = -1, .signd = -1,
 192        },
 193        [SNDRV_PCM_FORMAT_S24_3LE] = {
 194                .width = 24, .phys = 24, .le = 1, .signd = 1,
 195                .silence = {},
 196        },
 197        [SNDRV_PCM_FORMAT_S24_3BE] = {
 198                .width = 24, .phys = 24, .le = 0, .signd = 1,
 199                .silence = {},
 200        },
 201        [SNDRV_PCM_FORMAT_U24_3LE] = {
 202                .width = 24, .phys = 24, .le = 1, .signd = 0,
 203                .silence = { 0x00, 0x00, 0x80 },
 204        },
 205        [SNDRV_PCM_FORMAT_U24_3BE] = {
 206                .width = 24, .phys = 24, .le = 0, .signd = 0,
 207                .silence = { 0x80, 0x00, 0x00 },
 208        },
 209        [SNDRV_PCM_FORMAT_S20_3LE] = {
 210                .width = 20, .phys = 24, .le = 1, .signd = 1,
 211                .silence = {},
 212        },
 213        [SNDRV_PCM_FORMAT_S20_3BE] = {
 214                .width = 20, .phys = 24, .le = 0, .signd = 1,
 215                .silence = {},
 216        },
 217        [SNDRV_PCM_FORMAT_U20_3LE] = {
 218                .width = 20, .phys = 24, .le = 1, .signd = 0,
 219                .silence = { 0x00, 0x00, 0x08 },
 220        },
 221        [SNDRV_PCM_FORMAT_U20_3BE] = {
 222                .width = 20, .phys = 24, .le = 0, .signd = 0,
 223                .silence = { 0x08, 0x00, 0x00 },
 224        },
 225        [SNDRV_PCM_FORMAT_S18_3LE] = {
 226                .width = 18, .phys = 24, .le = 1, .signd = 1,
 227                .silence = {},
 228        },
 229        [SNDRV_PCM_FORMAT_S18_3BE] = {
 230                .width = 18, .phys = 24, .le = 0, .signd = 1,
 231                .silence = {},
 232        },
 233        [SNDRV_PCM_FORMAT_U18_3LE] = {
 234                .width = 18, .phys = 24, .le = 1, .signd = 0,
 235                .silence = { 0x00, 0x00, 0x02 },
 236        },
 237        [SNDRV_PCM_FORMAT_U18_3BE] = {
 238                .width = 18, .phys = 24, .le = 0, .signd = 0,
 239                .silence = { 0x02, 0x00, 0x00 },
 240        },
 241        [SNDRV_PCM_FORMAT_G723_24_1B] = {
 242                .width = 3, .phys = 8, .le = -1, .signd = -1,
 243                .silence = {},
 244        },
 245        [SNDRV_PCM_FORMAT_G723_40_1B] = {
 246                .width = 5, .phys = 8, .le = -1, .signd = -1,
 247                .silence = {},
 248        },
 249};
 250
 251
 252/**
 253 * snd_pcm_format_signed - Check the PCM format is signed linear
 254 * @format: the format to check
 255 *
 256 * Return: 1 if the given PCM format is signed linear, 0 if unsigned
 257 * linear, and a negative error code for non-linear formats.
 258 */
 259int snd_pcm_format_signed(snd_pcm_format_t format)
 260{
 261        int val;
 262        if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
 263                return -EINVAL;
 264        if ((val = pcm_formats[(INT)format].signd) < 0)
 265                return -EINVAL;
 266        return val;
 267}
 268EXPORT_SYMBOL(snd_pcm_format_signed);
 269
 270/**
 271 * snd_pcm_format_unsigned - Check the PCM format is unsigned linear
 272 * @format: the format to check
 273 *
 274 * Return: 1 if the given PCM format is unsigned linear, 0 if signed
 275 * linear, and a negative error code for non-linear formats.
 276 */
 277int snd_pcm_format_unsigned(snd_pcm_format_t format)
 278{
 279        int val;
 280
 281        val = snd_pcm_format_signed(format);
 282        if (val < 0)
 283                return val;
 284        return !val;
 285}
 286EXPORT_SYMBOL(snd_pcm_format_unsigned);
 287
 288/**
 289 * snd_pcm_format_linear - Check the PCM format is linear
 290 * @format: the format to check
 291 *
 292 * Return: 1 if the given PCM format is linear, 0 if not.
 293 */
 294int snd_pcm_format_linear(snd_pcm_format_t format)
 295{
 296        return snd_pcm_format_signed(format) >= 0;
 297}
 298EXPORT_SYMBOL(snd_pcm_format_linear);
 299
 300/**
 301 * snd_pcm_format_little_endian - Check the PCM format is little-endian
 302 * @format: the format to check
 303 *
 304 * Return: 1 if the given PCM format is little-endian, 0 if
 305 * big-endian, or a negative error code if endian not specified.
 306 */
 307int snd_pcm_format_little_endian(snd_pcm_format_t format)
 308{
 309        int val;
 310        if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
 311                return -EINVAL;
 312        if ((val = pcm_formats[(INT)format].le) < 0)
 313                return -EINVAL;
 314        return val;
 315}
 316EXPORT_SYMBOL(snd_pcm_format_little_endian);
 317
 318/**
 319 * snd_pcm_format_big_endian - Check the PCM format is big-endian
 320 * @format: the format to check
 321 *
 322 * Return: 1 if the given PCM format is big-endian, 0 if
 323 * little-endian, or a negative error code if endian not specified.
 324 */
 325int snd_pcm_format_big_endian(snd_pcm_format_t format)
 326{
 327        int val;
 328
 329        val = snd_pcm_format_little_endian(format);
 330        if (val < 0)
 331                return val;
 332        return !val;
 333}
 334EXPORT_SYMBOL(snd_pcm_format_big_endian);
 335
 336/**
 337 * snd_pcm_format_width - return the bit-width of the format
 338 * @format: the format to check
 339 *
 340 * Return: The bit-width of the format, or a negative error code
 341 * if unknown format.
 342 */
 343int snd_pcm_format_width(snd_pcm_format_t format)
 344{
 345        int val;
 346        if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
 347                return -EINVAL;
 348        if ((val = pcm_formats[(INT)format].width) == 0)
 349                return -EINVAL;
 350        return val;
 351}
 352EXPORT_SYMBOL(snd_pcm_format_width);
 353
 354/**
 355 * snd_pcm_format_physical_width - return the physical bit-width of the format
 356 * @format: the format to check
 357 *
 358 * Return: The physical bit-width of the format, or a negative error code
 359 * if unknown format.
 360 */
 361int snd_pcm_format_physical_width(snd_pcm_format_t format)
 362{
 363        int val;
 364        if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
 365                return -EINVAL;
 366        if ((val = pcm_formats[(INT)format].phys) == 0)
 367                return -EINVAL;
 368        return val;
 369}
 370EXPORT_SYMBOL(snd_pcm_format_physical_width);
 371
 372/**
 373 * snd_pcm_format_size - return the byte size of samples on the given format
 374 * @format: the format to check
 375 * @samples: sampling rate
 376 *
 377 * Return: The byte size of the given samples for the format, or a
 378 * negative error code if unknown format.
 379 */
 380ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples)
 381{
 382        int phys_width = snd_pcm_format_physical_width(format);
 383        if (phys_width < 0)
 384                return -EINVAL;
 385        return samples * phys_width / 8;
 386}
 387EXPORT_SYMBOL(snd_pcm_format_size);
 388
 389/**
 390 * snd_pcm_format_silence_64 - return the silent data in 8 bytes array
 391 * @format: the format to check
 392 *
 393 * Return: The format pattern to fill or %NULL if error.
 394 */
 395const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format)
 396{
 397        if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
 398                return NULL;
 399        if (! pcm_formats[(INT)format].phys)
 400                return NULL;
 401        return pcm_formats[(INT)format].silence;
 402}
 403EXPORT_SYMBOL(snd_pcm_format_silence_64);
 404
 405/**
 406 * snd_pcm_format_set_silence - set the silence data on the buffer
 407 * @format: the PCM format
 408 * @data: the buffer pointer
 409 * @samples: the number of samples to set silence
 410 *
 411 * Sets the silence data on the buffer for the given samples.
 412 *
 413 * Return: Zero if successful, or a negative error code on failure.
 414 */
 415int snd_pcm_format_set_silence(snd_pcm_format_t format, void *data, unsigned int samples)
 416{
 417        int width;
 418        unsigned char *dst, *pat;
 419
 420        if ((INT)format < 0 || (INT)format > (INT)SNDRV_PCM_FORMAT_LAST)
 421                return -EINVAL;
 422        if (samples == 0)
 423                return 0;
 424        width = pcm_formats[(INT)format].phys; /* physical width */
 425        pat = pcm_formats[(INT)format].silence;
 426        if (! width)
 427                return -EINVAL;
 428        /* signed or 1 byte data */
 429        if (pcm_formats[(INT)format].signd == 1 || width <= 8) {
 430                unsigned int bytes = samples * width / 8;
 431                memset(data, *pat, bytes);
 432                return 0;
 433        }
 434        /* non-zero samples, fill using a loop */
 435        width /= 8;
 436        dst = data;
 437#if 0
 438        while (samples--) {
 439                memcpy(dst, pat, width);
 440                dst += width;
 441        }
 442#else
 443        /* a bit optimization for constant width */
 444        switch (width) {
 445        case 2:
 446                while (samples--) {
 447                        memcpy(dst, pat, 2);
 448                        dst += 2;
 449                }
 450                break;
 451        case 3:
 452                while (samples--) {
 453                        memcpy(dst, pat, 3);
 454                        dst += 3;
 455                }
 456                break;
 457        case 4:
 458                while (samples--) {
 459                        memcpy(dst, pat, 4);
 460                        dst += 4;
 461                }
 462                break;
 463        case 8:
 464                while (samples--) {
 465                        memcpy(dst, pat, 8);
 466                        dst += 8;
 467                }
 468                break;
 469        }
 470#endif
 471        return 0;
 472}
 473EXPORT_SYMBOL(snd_pcm_format_set_silence);
 474
 475/**
 476 * snd_pcm_limit_hw_rates - determine rate_min/rate_max fields
 477 * @runtime: the runtime instance
 478 *
 479 * Determines the rate_min and rate_max fields from the rates bits of
 480 * the given runtime->hw.
 481 *
 482 * Return: Zero if successful.
 483 */
 484int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime)
 485{
 486        int i;
 487        for (i = 0; i < (int)snd_pcm_known_rates.count; i++) {
 488                if (runtime->hw.rates & (1 << i)) {
 489                        runtime->hw.rate_min = snd_pcm_known_rates.list[i];
 490                        break;
 491                }
 492        }
 493        for (i = (int)snd_pcm_known_rates.count - 1; i >= 0; i--) {
 494                if (runtime->hw.rates & (1 << i)) {
 495                        runtime->hw.rate_max = snd_pcm_known_rates.list[i];
 496                        break;
 497                }
 498        }
 499        return 0;
 500}
 501EXPORT_SYMBOL(snd_pcm_limit_hw_rates);
 502
 503/**
 504 * snd_pcm_rate_to_rate_bit - converts sample rate to SNDRV_PCM_RATE_xxx bit
 505 * @rate: the sample rate to convert
 506 *
 507 * Return: The SNDRV_PCM_RATE_xxx flag that corresponds to the given rate, or
 508 * SNDRV_PCM_RATE_KNOT for an unknown rate.
 509 */
 510unsigned int snd_pcm_rate_to_rate_bit(unsigned int rate)
 511{
 512        unsigned int i;
 513
 514        for (i = 0; i < snd_pcm_known_rates.count; i++)
 515                if (snd_pcm_known_rates.list[i] == rate)
 516                        return 1u << i;
 517        return SNDRV_PCM_RATE_KNOT;
 518}
 519EXPORT_SYMBOL(snd_pcm_rate_to_rate_bit);
 520
 521/**
 522 * snd_pcm_rate_bit_to_rate - converts SNDRV_PCM_RATE_xxx bit to sample rate
 523 * @rate_bit: the rate bit to convert
 524 *
 525 * Return: The sample rate that corresponds to the given SNDRV_PCM_RATE_xxx flag
 526 * or 0 for an unknown rate bit.
 527 */
 528unsigned int snd_pcm_rate_bit_to_rate(unsigned int rate_bit)
 529{
 530        unsigned int i;
 531
 532        for (i = 0; i < snd_pcm_known_rates.count; i++)
 533                if ((1u << i) == rate_bit)
 534                        return snd_pcm_known_rates.list[i];
 535        return 0;
 536}
 537EXPORT_SYMBOL(snd_pcm_rate_bit_to_rate);
 538
 539static unsigned int snd_pcm_rate_mask_sanitize(unsigned int rates)
 540{
 541        if (rates & SNDRV_PCM_RATE_CONTINUOUS)
 542                return SNDRV_PCM_RATE_CONTINUOUS;
 543        else if (rates & SNDRV_PCM_RATE_KNOT)
 544                return SNDRV_PCM_RATE_KNOT;
 545        return rates;
 546}
 547
 548/**
 549 * snd_pcm_rate_mask_intersect - computes the intersection between two rate masks
 550 * @rates_a: The first rate mask
 551 * @rates_b: The second rate mask
 552 *
 553 * This function computes the rates that are supported by both rate masks passed
 554 * to the function. It will take care of the special handling of
 555 * SNDRV_PCM_RATE_CONTINUOUS and SNDRV_PCM_RATE_KNOT.
 556 *
 557 * Return: A rate mask containing the rates that are supported by both rates_a
 558 * and rates_b.
 559 */
 560unsigned int snd_pcm_rate_mask_intersect(unsigned int rates_a,
 561        unsigned int rates_b)
 562{
 563        rates_a = snd_pcm_rate_mask_sanitize(rates_a);
 564        rates_b = snd_pcm_rate_mask_sanitize(rates_b);
 565
 566        if (rates_a & SNDRV_PCM_RATE_CONTINUOUS)
 567                return rates_b;
 568        else if (rates_b & SNDRV_PCM_RATE_CONTINUOUS)
 569                return rates_a;
 570        else if (rates_a & SNDRV_PCM_RATE_KNOT)
 571                return rates_b;
 572        else if (rates_b & SNDRV_PCM_RATE_KNOT)
 573                return rates_a;
 574        return rates_a & rates_b;
 575}
 576EXPORT_SYMBOL_GPL(snd_pcm_rate_mask_intersect);
 577
 578/**
 579 * snd_pcm_rate_range_to_bits - converts rate range to SNDRV_PCM_RATE_xxx bit
 580 * @rate_min: the minimum sample rate
 581 * @rate_max: the maximum sample rate
 582 *
 583 * This function has an implicit assumption: the rates in the given range have
 584 * only the pre-defined rates like 44100 or 16000.
 585 *
 586 * Return: The SNDRV_PCM_RATE_xxx flag that corresponds to the given rate range,
 587 * or SNDRV_PCM_RATE_KNOT for an unknown range.
 588 */
 589unsigned int snd_pcm_rate_range_to_bits(unsigned int rate_min,
 590        unsigned int rate_max)
 591{
 592        unsigned int rates = 0;
 593        int i;
 594
 595        for (i = 0; i < snd_pcm_known_rates.count; i++) {
 596                if (snd_pcm_known_rates.list[i] >= rate_min
 597                        && snd_pcm_known_rates.list[i] <= rate_max)
 598                        rates |= 1 << i;
 599        }
 600
 601        if (!rates)
 602                rates = SNDRV_PCM_RATE_KNOT;
 603
 604        return rates;
 605}
 606EXPORT_SYMBOL_GPL(snd_pcm_rate_range_to_bits);
 607