linux/sound/usb/clock.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *   Clock domain and sample rate management functions
   4 */
   5
   6#include <linux/bitops.h>
   7#include <linux/init.h>
   8#include <linux/string.h>
   9#include <linux/usb.h>
  10#include <linux/usb/audio.h>
  11#include <linux/usb/audio-v2.h>
  12#include <linux/usb/audio-v3.h>
  13
  14#include <sound/core.h>
  15#include <sound/info.h>
  16#include <sound/pcm.h>
  17
  18#include "usbaudio.h"
  19#include "card.h"
  20#include "helper.h"
  21#include "clock.h"
  22#include "quirks.h"
  23
  24static void *find_uac_clock_desc(struct usb_host_interface *iface, int id,
  25                                 bool (*validator)(void *, int), u8 type)
  26{
  27        void *cs = NULL;
  28
  29        while ((cs = snd_usb_find_csint_desc(iface->extra, iface->extralen,
  30                                             cs, type))) {
  31                if (validator(cs, id))
  32                        return cs;
  33        }
  34
  35        return NULL;
  36}
  37
  38static bool validate_clock_source_v2(void *p, int id)
  39{
  40        struct uac_clock_source_descriptor *cs = p;
  41        return cs->bClockID == id;
  42}
  43
  44static bool validate_clock_source_v3(void *p, int id)
  45{
  46        struct uac3_clock_source_descriptor *cs = p;
  47        return cs->bClockID == id;
  48}
  49
  50static bool validate_clock_selector_v2(void *p, int id)
  51{
  52        struct uac_clock_selector_descriptor *cs = p;
  53        return cs->bClockID == id;
  54}
  55
  56static bool validate_clock_selector_v3(void *p, int id)
  57{
  58        struct uac3_clock_selector_descriptor *cs = p;
  59        return cs->bClockID == id;
  60}
  61
  62static bool validate_clock_multiplier_v2(void *p, int id)
  63{
  64        struct uac_clock_multiplier_descriptor *cs = p;
  65        return cs->bClockID == id;
  66}
  67
  68static bool validate_clock_multiplier_v3(void *p, int id)
  69{
  70        struct uac3_clock_multiplier_descriptor *cs = p;
  71        return cs->bClockID == id;
  72}
  73
  74#define DEFINE_FIND_HELPER(name, obj, validator, type)          \
  75static obj *name(struct usb_host_interface *iface, int id)      \
  76{                                                               \
  77        return find_uac_clock_desc(iface, id, validator, type); \
  78}
  79
  80DEFINE_FIND_HELPER(snd_usb_find_clock_source,
  81                   struct uac_clock_source_descriptor,
  82                   validate_clock_source_v2, UAC2_CLOCK_SOURCE);
  83DEFINE_FIND_HELPER(snd_usb_find_clock_source_v3,
  84                   struct uac3_clock_source_descriptor,
  85                   validate_clock_source_v3, UAC3_CLOCK_SOURCE);
  86
  87DEFINE_FIND_HELPER(snd_usb_find_clock_selector,
  88                   struct uac_clock_selector_descriptor,
  89                   validate_clock_selector_v2, UAC2_CLOCK_SELECTOR);
  90DEFINE_FIND_HELPER(snd_usb_find_clock_selector_v3,
  91                   struct uac3_clock_selector_descriptor,
  92                   validate_clock_selector_v3, UAC3_CLOCK_SELECTOR);
  93
  94DEFINE_FIND_HELPER(snd_usb_find_clock_multiplier,
  95                   struct uac_clock_multiplier_descriptor,
  96                   validate_clock_multiplier_v2, UAC2_CLOCK_MULTIPLIER);
  97DEFINE_FIND_HELPER(snd_usb_find_clock_multiplier_v3,
  98                   struct uac3_clock_multiplier_descriptor,
  99                   validate_clock_multiplier_v3, UAC3_CLOCK_MULTIPLIER);
 100
 101static int uac_clock_selector_get_val(struct snd_usb_audio *chip, int selector_id)
 102{
 103        unsigned char buf;
 104        int ret;
 105
 106        ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0),
 107                              UAC2_CS_CUR,
 108                              USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
 109                              UAC2_CX_CLOCK_SELECTOR << 8,
 110                              snd_usb_ctrl_intf(chip) | (selector_id << 8),
 111                              &buf, sizeof(buf));
 112
 113        if (ret < 0)
 114                return ret;
 115
 116        return buf;
 117}
 118
 119static int uac_clock_selector_set_val(struct snd_usb_audio *chip, int selector_id,
 120                                        unsigned char pin)
 121{
 122        int ret;
 123
 124        ret = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0),
 125                              UAC2_CS_CUR,
 126                              USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
 127                              UAC2_CX_CLOCK_SELECTOR << 8,
 128                              snd_usb_ctrl_intf(chip) | (selector_id << 8),
 129                              &pin, sizeof(pin));
 130        if (ret < 0)
 131                return ret;
 132
 133        if (ret != sizeof(pin)) {
 134                usb_audio_err(chip,
 135                        "setting selector (id %d) unexpected length %d\n",
 136                        selector_id, ret);
 137                return -EINVAL;
 138        }
 139
 140        ret = uac_clock_selector_get_val(chip, selector_id);
 141        if (ret < 0)
 142                return ret;
 143
 144        if (ret != pin) {
 145                usb_audio_err(chip,
 146                        "setting selector (id %d) to %x failed (current: %d)\n",
 147                        selector_id, pin, ret);
 148                return -EINVAL;
 149        }
 150
 151        return ret;
 152}
 153
 154static bool uac_clock_source_is_valid(struct snd_usb_audio *chip,
 155                                      int protocol,
 156                                      int source_id)
 157{
 158        int err;
 159        unsigned char data;
 160        struct usb_device *dev = chip->dev;
 161        u32 bmControls;
 162
 163        if (protocol == UAC_VERSION_3) {
 164                struct uac3_clock_source_descriptor *cs_desc =
 165                        snd_usb_find_clock_source_v3(chip->ctrl_intf, source_id);
 166
 167                if (!cs_desc)
 168                        return 0;
 169                bmControls = le32_to_cpu(cs_desc->bmControls);
 170        } else { /* UAC_VERSION_1/2 */
 171                struct uac_clock_source_descriptor *cs_desc =
 172                        snd_usb_find_clock_source(chip->ctrl_intf, source_id);
 173
 174                if (!cs_desc)
 175                        return 0;
 176                bmControls = cs_desc->bmControls;
 177        }
 178
 179        /* If a clock source can't tell us whether it's valid, we assume it is */
 180        if (!uac_v2v3_control_is_readable(bmControls,
 181                                      UAC2_CS_CONTROL_CLOCK_VALID))
 182                return 1;
 183
 184        err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR,
 185                              USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
 186                              UAC2_CS_CONTROL_CLOCK_VALID << 8,
 187                              snd_usb_ctrl_intf(chip) | (source_id << 8),
 188                              &data, sizeof(data));
 189
 190        if (err < 0) {
 191                dev_warn(&dev->dev,
 192                         "%s(): cannot get clock validity for id %d\n",
 193                           __func__, source_id);
 194                return 0;
 195        }
 196
 197        return !!data;
 198}
 199
 200static int __uac_clock_find_source(struct snd_usb_audio *chip, int entity_id,
 201                                   unsigned long *visited, bool validate)
 202{
 203        struct uac_clock_source_descriptor *source;
 204        struct uac_clock_selector_descriptor *selector;
 205        struct uac_clock_multiplier_descriptor *multiplier;
 206
 207        entity_id &= 0xff;
 208
 209        if (test_and_set_bit(entity_id, visited)) {
 210                usb_audio_warn(chip,
 211                         "%s(): recursive clock topology detected, id %d.\n",
 212                         __func__, entity_id);
 213                return -EINVAL;
 214        }
 215
 216        /* first, see if the ID we're looking for is a clock source already */
 217        source = snd_usb_find_clock_source(chip->ctrl_intf, entity_id);
 218        if (source) {
 219                entity_id = source->bClockID;
 220                if (validate && !uac_clock_source_is_valid(chip, UAC_VERSION_2,
 221                                                                entity_id)) {
 222                        usb_audio_err(chip,
 223                                "clock source %d is not valid, cannot use\n",
 224                                entity_id);
 225                        return -ENXIO;
 226                }
 227                return entity_id;
 228        }
 229
 230        selector = snd_usb_find_clock_selector(chip->ctrl_intf, entity_id);
 231        if (selector) {
 232                int ret, i, cur;
 233
 234                /* the entity ID we are looking for is a selector.
 235                 * find out what it currently selects */
 236                ret = uac_clock_selector_get_val(chip, selector->bClockID);
 237                if (ret < 0)
 238                        return ret;
 239
 240                /* Selector values are one-based */
 241
 242                if (ret > selector->bNrInPins || ret < 1) {
 243                        usb_audio_err(chip,
 244                                "%s(): selector reported illegal value, id %d, ret %d\n",
 245                                __func__, selector->bClockID, ret);
 246
 247                        return -EINVAL;
 248                }
 249
 250                cur = ret;
 251                ret = __uac_clock_find_source(chip, selector->baCSourceID[ret - 1],
 252                                               visited, validate);
 253                if (!validate || ret > 0 || !chip->autoclock)
 254                        return ret;
 255
 256                /* The current clock source is invalid, try others. */
 257                for (i = 1; i <= selector->bNrInPins; i++) {
 258                        int err;
 259
 260                        if (i == cur)
 261                                continue;
 262
 263                        ret = __uac_clock_find_source(chip, selector->baCSourceID[i - 1],
 264                                visited, true);
 265                        if (ret < 0)
 266                                continue;
 267
 268                        err = uac_clock_selector_set_val(chip, entity_id, i);
 269                        if (err < 0)
 270                                continue;
 271
 272                        usb_audio_info(chip,
 273                                 "found and selected valid clock source %d\n",
 274                                 ret);
 275                        return ret;
 276                }
 277
 278                return -ENXIO;
 279        }
 280
 281        /* FIXME: multipliers only act as pass-thru element for now */
 282        multiplier = snd_usb_find_clock_multiplier(chip->ctrl_intf, entity_id);
 283        if (multiplier)
 284                return __uac_clock_find_source(chip, multiplier->bCSourceID,
 285                                                visited, validate);
 286
 287        return -EINVAL;
 288}
 289
 290static int __uac3_clock_find_source(struct snd_usb_audio *chip, int entity_id,
 291                                   unsigned long *visited, bool validate)
 292{
 293        struct uac3_clock_source_descriptor *source;
 294        struct uac3_clock_selector_descriptor *selector;
 295        struct uac3_clock_multiplier_descriptor *multiplier;
 296
 297        entity_id &= 0xff;
 298
 299        if (test_and_set_bit(entity_id, visited)) {
 300                usb_audio_warn(chip,
 301                         "%s(): recursive clock topology detected, id %d.\n",
 302                         __func__, entity_id);
 303                return -EINVAL;
 304        }
 305
 306        /* first, see if the ID we're looking for is a clock source already */
 307        source = snd_usb_find_clock_source_v3(chip->ctrl_intf, entity_id);
 308        if (source) {
 309                entity_id = source->bClockID;
 310                if (validate && !uac_clock_source_is_valid(chip, UAC_VERSION_3,
 311                                                                entity_id)) {
 312                        usb_audio_err(chip,
 313                                "clock source %d is not valid, cannot use\n",
 314                                entity_id);
 315                        return -ENXIO;
 316                }
 317                return entity_id;
 318        }
 319
 320        selector = snd_usb_find_clock_selector_v3(chip->ctrl_intf, entity_id);
 321        if (selector) {
 322                int ret, i, cur;
 323
 324                /* the entity ID we are looking for is a selector.
 325                 * find out what it currently selects */
 326                ret = uac_clock_selector_get_val(chip, selector->bClockID);
 327                if (ret < 0)
 328                        return ret;
 329
 330                /* Selector values are one-based */
 331
 332                if (ret > selector->bNrInPins || ret < 1) {
 333                        usb_audio_err(chip,
 334                                "%s(): selector reported illegal value, id %d, ret %d\n",
 335                                __func__, selector->bClockID, ret);
 336
 337                        return -EINVAL;
 338                }
 339
 340                cur = ret;
 341                ret = __uac3_clock_find_source(chip, selector->baCSourceID[ret - 1],
 342                                               visited, validate);
 343                if (!validate || ret > 0 || !chip->autoclock)
 344                        return ret;
 345
 346                /* The current clock source is invalid, try others. */
 347                for (i = 1; i <= selector->bNrInPins; i++) {
 348                        int err;
 349
 350                        if (i == cur)
 351                                continue;
 352
 353                        ret = __uac3_clock_find_source(chip, selector->baCSourceID[i - 1],
 354                                visited, true);
 355                        if (ret < 0)
 356                                continue;
 357
 358                        err = uac_clock_selector_set_val(chip, entity_id, i);
 359                        if (err < 0)
 360                                continue;
 361
 362                        usb_audio_info(chip,
 363                                 "found and selected valid clock source %d\n",
 364                                 ret);
 365                        return ret;
 366                }
 367
 368                return -ENXIO;
 369        }
 370
 371        /* FIXME: multipliers only act as pass-thru element for now */
 372        multiplier = snd_usb_find_clock_multiplier_v3(chip->ctrl_intf,
 373                                                      entity_id);
 374        if (multiplier)
 375                return __uac3_clock_find_source(chip, multiplier->bCSourceID,
 376                                                visited, validate);
 377
 378        return -EINVAL;
 379}
 380
 381/*
 382 * For all kinds of sample rate settings and other device queries,
 383 * the clock source (end-leaf) must be used. However, clock selectors,
 384 * clock multipliers and sample rate converters may be specified as
 385 * clock source input to terminal. This functions walks the clock path
 386 * to its end and tries to find the source.
 387 *
 388 * The 'visited' bitfield is used internally to detect recursive loops.
 389 *
 390 * Returns the clock source UnitID (>=0) on success, or an error.
 391 */
 392int snd_usb_clock_find_source(struct snd_usb_audio *chip, int protocol,
 393                              int entity_id, bool validate)
 394{
 395        DECLARE_BITMAP(visited, 256);
 396        memset(visited, 0, sizeof(visited));
 397
 398        switch (protocol) {
 399        case UAC_VERSION_2:
 400                return __uac_clock_find_source(chip, entity_id, visited,
 401                                               validate);
 402        case UAC_VERSION_3:
 403                return __uac3_clock_find_source(chip, entity_id, visited,
 404                                               validate);
 405        default:
 406                return -EINVAL;
 407        }
 408}
 409
 410static int set_sample_rate_v1(struct snd_usb_audio *chip, int iface,
 411                              struct usb_host_interface *alts,
 412                              struct audioformat *fmt, int rate)
 413{
 414        struct usb_device *dev = chip->dev;
 415        unsigned int ep;
 416        unsigned char data[3];
 417        int err, crate;
 418
 419        if (get_iface_desc(alts)->bNumEndpoints < 1)
 420                return -EINVAL;
 421        ep = get_endpoint(alts, 0)->bEndpointAddress;
 422
 423        /* if endpoint doesn't have sampling rate control, bail out */
 424        if (!(fmt->attributes & UAC_EP_CS_ATTR_SAMPLE_RATE))
 425                return 0;
 426
 427        data[0] = rate;
 428        data[1] = rate >> 8;
 429        data[2] = rate >> 16;
 430        err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
 431                              USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT,
 432                              UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,
 433                              data, sizeof(data));
 434        if (err < 0) {
 435                dev_err(&dev->dev, "%d:%d: cannot set freq %d to ep %#x\n",
 436                        iface, fmt->altsetting, rate, ep);
 437                return err;
 438        }
 439
 440        /* Don't check the sample rate for devices which we know don't
 441         * support reading */
 442        if (snd_usb_get_sample_rate_quirk(chip))
 443                return 0;
 444        /* the firmware is likely buggy, don't repeat to fail too many times */
 445        if (chip->sample_rate_read_error > 2)
 446                return 0;
 447
 448        err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
 449                              USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN,
 450                              UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,
 451                              data, sizeof(data));
 452        if (err < 0) {
 453                dev_err(&dev->dev, "%d:%d: cannot get freq at ep %#x\n",
 454                        iface, fmt->altsetting, ep);
 455                chip->sample_rate_read_error++;
 456                return 0; /* some devices don't support reading */
 457        }
 458
 459        crate = data[0] | (data[1] << 8) | (data[2] << 16);
 460        if (crate != rate) {
 461                dev_warn(&dev->dev, "current rate %d is different from the runtime rate %d\n", crate, rate);
 462                // runtime->rate = crate;
 463        }
 464
 465        return 0;
 466}
 467
 468static int get_sample_rate_v2v3(struct snd_usb_audio *chip, int iface,
 469                              int altsetting, int clock)
 470{
 471        struct usb_device *dev = chip->dev;
 472        __le32 data;
 473        int err;
 474
 475        err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR,
 476                              USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
 477                              UAC2_CS_CONTROL_SAM_FREQ << 8,
 478                              snd_usb_ctrl_intf(chip) | (clock << 8),
 479                              &data, sizeof(data));
 480        if (err < 0) {
 481                dev_warn(&dev->dev, "%d:%d: cannot get freq (v2/v3): err %d\n",
 482                         iface, altsetting, err);
 483                return 0;
 484        }
 485
 486        return le32_to_cpu(data);
 487}
 488
 489static int set_sample_rate_v2v3(struct snd_usb_audio *chip, int iface,
 490                              struct usb_host_interface *alts,
 491                              struct audioformat *fmt, int rate)
 492{
 493        struct usb_device *dev = chip->dev;
 494        __le32 data;
 495        int err, cur_rate, prev_rate;
 496        int clock;
 497        bool writeable;
 498        u32 bmControls;
 499
 500        /* First, try to find a valid clock. This may trigger
 501         * automatic clock selection if the current clock is not
 502         * valid.
 503         */
 504        clock = snd_usb_clock_find_source(chip, fmt->protocol,
 505                                          fmt->clock, true);
 506        if (clock < 0) {
 507                /* We did not find a valid clock, but that might be
 508                 * because the current sample rate does not match an
 509                 * external clock source. Try again without validation
 510                 * and we will do another validation after setting the
 511                 * rate.
 512                 */
 513                clock = snd_usb_clock_find_source(chip, fmt->protocol,
 514                                                  fmt->clock, false);
 515                if (clock < 0)
 516                        return clock;
 517        }
 518
 519        prev_rate = get_sample_rate_v2v3(chip, iface, fmt->altsetting, clock);
 520        if (prev_rate == rate)
 521                goto validation;
 522
 523        if (fmt->protocol == UAC_VERSION_3) {
 524                struct uac3_clock_source_descriptor *cs_desc;
 525
 526                cs_desc = snd_usb_find_clock_source_v3(chip->ctrl_intf, clock);
 527                bmControls = le32_to_cpu(cs_desc->bmControls);
 528        } else {
 529                struct uac_clock_source_descriptor *cs_desc;
 530
 531                cs_desc = snd_usb_find_clock_source(chip->ctrl_intf, clock);
 532                bmControls = cs_desc->bmControls;
 533        }
 534
 535        writeable = uac_v2v3_control_is_writeable(bmControls,
 536                                                  UAC2_CS_CONTROL_SAM_FREQ);
 537        if (writeable) {
 538                data = cpu_to_le32(rate);
 539                err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC2_CS_CUR,
 540                                      USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
 541                                      UAC2_CS_CONTROL_SAM_FREQ << 8,
 542                                      snd_usb_ctrl_intf(chip) | (clock << 8),
 543                                      &data, sizeof(data));
 544                if (err < 0) {
 545                        usb_audio_err(chip,
 546                                "%d:%d: cannot set freq %d (v2/v3): err %d\n",
 547                                iface, fmt->altsetting, rate, err);
 548                        return err;
 549                }
 550
 551                cur_rate = get_sample_rate_v2v3(chip, iface,
 552                                                fmt->altsetting, clock);
 553        } else {
 554                cur_rate = prev_rate;
 555        }
 556
 557        if (cur_rate != rate) {
 558                if (!writeable) {
 559                        usb_audio_warn(chip,
 560                                 "%d:%d: freq mismatch (RO clock): req %d, clock runs @%d\n",
 561                                 iface, fmt->altsetting, rate, cur_rate);
 562                        return -ENXIO;
 563                }
 564                usb_audio_dbg(chip,
 565                        "current rate %d is different from the runtime rate %d\n",
 566                        cur_rate, rate);
 567        }
 568
 569        /* Some devices doesn't respond to sample rate changes while the
 570         * interface is active. */
 571        if (rate != prev_rate) {
 572                usb_set_interface(dev, iface, 0);
 573                snd_usb_set_interface_quirk(dev);
 574                usb_set_interface(dev, iface, fmt->altsetting);
 575                snd_usb_set_interface_quirk(dev);
 576        }
 577
 578validation:
 579        /* validate clock after rate change */
 580        if (!uac_clock_source_is_valid(chip, fmt->protocol, clock))
 581                return -ENXIO;
 582        return 0;
 583}
 584
 585int snd_usb_init_sample_rate(struct snd_usb_audio *chip, int iface,
 586                             struct usb_host_interface *alts,
 587                             struct audioformat *fmt, int rate)
 588{
 589        switch (fmt->protocol) {
 590        case UAC_VERSION_1:
 591        default:
 592                return set_sample_rate_v1(chip, iface, alts, fmt, rate);
 593
 594        case UAC_VERSION_3:
 595                if (chip->badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) {
 596                        if (rate != UAC3_BADD_SAMPLING_RATE)
 597                                return -ENXIO;
 598                        else
 599                                return 0;
 600                }
 601        /* fall through */
 602        case UAC_VERSION_2:
 603                return set_sample_rate_v2v3(chip, iface, alts, fmt, rate);
 604        }
 605}
 606
 607