LXR linux/sound/usb/clock.c

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