sound/usb/format.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  */
   4
   5 #include <linux/init.h>
   6 #include <linux/slab.h>
   7 #include <linux/usb.h>
   8 #include <linux/usb/audio.h>
   9 #include <linux/usb/audio-v2.h>
  10 #include <linux/usb/audio-v3.h>
  11
  12 #include <sound/core.h>
  13 #include <sound/pcm.h>
  14
  15 #include "usbaudio.h"
  16 #include "card.h"
  17 #include "quirks.h"
  18 #include "helper.h"
  19 #include "clock.h"
  20 #include "format.h"
  21
  22 /*
  23  * parse the audio format type I descriptor
  24  * and returns the corresponding pcm format
  25  *
  26  * @dev: usb device
  27  * @fp: audioformat record
  28  * @format: the format tag (wFormatTag)
  29  * @fmt: the format type descriptor (v1/v2) or AudioStreaming descriptor (v3)
  30  */
  31 static u64 parse_audio_format_i_type(struct snd_usb_audio *chip,
  32                                      struct audioformat *fp,
  33                                      u64 format, void *_fmt)
  34 {
  35         int sample_width, sample_bytes;
  36         u64 pcm_formats = 0;
  37
  38         switch (fp->protocol) {
  39         case UAC_VERSION_1:
  40         default: {
  41                 struct uac_format_type_i_discrete_descriptor *fmt = _fmt;
  42                 if (format >= 64) {
  43                         usb_audio_info(chip,
  44                                        "%u:%d: invalid format type 0x%llx is detected, processed as PCM\n",
  45                                        fp->iface, fp->altsetting, format);
  46                         format = UAC_FORMAT_TYPE_I_PCM;
  47                 }
  48                 sample_width = fmt->bBitResolution;
  49                 sample_bytes = fmt->bSubframeSize;
  50                 format = 1ULL << format;
  51                 break;
  52         }
  53
  54         case UAC_VERSION_2: {
  55                 struct uac_format_type_i_ext_descriptor *fmt = _fmt;
  56                 sample_width = fmt->bBitResolution;
  57                 sample_bytes = fmt->bSubslotSize;
  58
  59                 if (format & UAC2_FORMAT_TYPE_I_RAW_DATA) {
  60                         pcm_formats |= SNDRV_PCM_FMTBIT_SPECIAL;
  61                         /* flag potentially raw DSD capable altsettings */
  62                         fp->dsd_raw = true;
  63                         /* clear special format bit to avoid "unsupported format" msg below */
  64                         format &= ~UAC2_FORMAT_TYPE_I_RAW_DATA;
  65                 }
  66
  67                 format <<= 1;
  68                 break;
  69         }
  70         case UAC_VERSION_3: {
  71                 struct uac3_as_header_descriptor *as = _fmt;
  72
  73                 sample_width = as->bBitResolution;
  74                 sample_bytes = as->bSubslotSize;
  75
  76                 if (format & UAC3_FORMAT_TYPE_I_RAW_DATA) {
  77                         pcm_formats |= SNDRV_PCM_FMTBIT_SPECIAL;
  78                         /* clear special format bit to avoid "unsupported format" msg below */
  79                         format &= ~UAC3_FORMAT_TYPE_I_RAW_DATA;
  80                 }
  81
  82                 format <<= 1;
  83                 break;
  84         }
  85         }
  86
  87         fp->fmt_bits = sample_width;
  88
  89         if ((pcm_formats == 0) &&
  90             (format == 0 || format == BIT(UAC_FORMAT_TYPE_I_UNDEFINED))) {
  91                 /* some devices don't define this correctly... */
  92                 usb_audio_info(chip, "%u:%d : format type 0 is detected, processed as PCM\n",
  93                         fp->iface, fp->altsetting);
  94                 format = BIT(UAC_FORMAT_TYPE_I_PCM);
  95         }
  96         if (format & BIT(UAC_FORMAT_TYPE_I_PCM)) {
  97                 if (((chip->usb_id == USB_ID(0x0582, 0x0016)) ||
  98                      /* Edirol SD-90 */
  99                      (chip->usb_id == USB_ID(0x0582, 0x000c))) &&
 100                      /* Roland SC-D70 */
 101                     sample_width == 24 && sample_bytes == 2)
 102                         sample_bytes = 3;
 103                 else if (sample_width > sample_bytes * 8) {
 104                         usb_audio_info(chip, "%u:%d : sample bitwidth %d in over sample bytes %d\n",
 105                                  fp->iface, fp->altsetting,
 106                                  sample_width, sample_bytes);
 107                 }
 108                 /* check the format byte size */
 109                 switch (sample_bytes) {
 110                 case 1:
 111                         pcm_formats |= SNDRV_PCM_FMTBIT_S8;
 112                         break;
 113                 case 2:
 114                         if (snd_usb_is_big_endian_format(chip, fp))
 115                                 pcm_formats |= SNDRV_PCM_FMTBIT_S16_BE; /* grrr, big endian!! */
 116                         else
 117                                 pcm_formats |= SNDRV_PCM_FMTBIT_S16_LE;
 118                         break;
 119                 case 3:
 120                         if (snd_usb_is_big_endian_format(chip, fp))
 121                                 pcm_formats |= SNDRV_PCM_FMTBIT_S24_3BE; /* grrr, big endian!! */
 122                         else
 123                                 pcm_formats |= SNDRV_PCM_FMTBIT_S24_3LE;
 124                         break;
 125                 case 4:
 126                         pcm_formats |= SNDRV_PCM_FMTBIT_S32_LE;
 127                         break;
 128                 default:
 129                         usb_audio_info(chip,
 130                                  "%u:%d : unsupported sample bitwidth %d in %d bytes\n",
 131                                  fp->iface, fp->altsetting,
 132                                  sample_width, sample_bytes);
 133                         break;
 134                 }
 135         }
 136         if (format & BIT(UAC_FORMAT_TYPE_I_PCM8)) {
 137                 /* Dallas DS4201 workaround: it advertises U8 format, but really
 138                    supports S8. */
 139                 if (chip->usb_id == USB_ID(0x04fa, 0x4201))
 140                         pcm_formats |= SNDRV_PCM_FMTBIT_S8;
 141                 else
 142                         pcm_formats |= SNDRV_PCM_FMTBIT_U8;
 143         }
 144         if (format & BIT(UAC_FORMAT_TYPE_I_IEEE_FLOAT))
 145                 pcm_formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
 146         if (format & BIT(UAC_FORMAT_TYPE_I_ALAW))
 147                 pcm_formats |= SNDRV_PCM_FMTBIT_A_LAW;
 148         if (format & BIT(UAC_FORMAT_TYPE_I_MULAW))
 149                 pcm_formats |= SNDRV_PCM_FMTBIT_MU_LAW;
 150         if (format & ~0x3f) {
 151                 usb_audio_info(chip,
 152                          "%u:%d : unsupported format bits %#llx\n",
 153                          fp->iface, fp->altsetting, format);
 154         }
 155
 156         pcm_formats |= snd_usb_interface_dsd_format_quirks(chip, fp, sample_bytes);
 157
 158         return pcm_formats;
 159 }
 160
 161 static int set_fixed_rate(struct audioformat *fp, int rate, int rate_bits)
 162 {
 163         kfree(fp->rate_table);
 164         fp->rate_table = kmalloc(sizeof(int), GFP_KERNEL);
 165         if (!fp->rate_table)
 166                 return -ENOMEM;
 167         fp->nr_rates = 1;
 168         fp->rate_min = rate;
 169         fp->rate_max = rate;
 170         fp->rates = rate_bits;
 171         fp->rate_table[0] = rate;
 172         return 0;
 173 }
 174
 175 /* set up rate_min, rate_max and rates from the rate table */
 176 static void set_rate_table_min_max(struct audioformat *fp)
 177 {
 178         unsigned int rate;
 179         int i;
 180
 181         fp->rate_min = INT_MAX;
 182         fp->rate_max = 0;
 183         fp->rates = 0;
 184         for (i = 0; i < fp->nr_rates; i++) {
 185                 rate = fp->rate_table[i];
 186                 fp->rate_min = min(fp->rate_min, rate);
 187                 fp->rate_max = max(fp->rate_max, rate);
 188                 fp->rates |= snd_pcm_rate_to_rate_bit(rate);
 189         }
 190 }
 191
 192 /*
 193  * parse the format descriptor and stores the possible sample rates
 194  * on the audioformat table (audio class v1).
 195  *
 196  * @dev: usb device
 197  * @fp: audioformat record
 198  * @fmt: the format descriptor
 199  * @offset: the start offset of descriptor pointing the rate type
 200  *          (7 for type I and II, 8 for type II)
 201  */
 202 static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audioformat *fp,
 203                                        unsigned char *fmt, int offset)
 204 {
 205         int nr_rates = fmt[offset];
 206
 207         if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) {
 208                 usb_audio_err(chip,
 209                         "%u:%d : invalid UAC_FORMAT_TYPE desc\n",
 210                         fp->iface, fp->altsetting);
 211                 return -EINVAL;
 212         }
 213
 214         if (nr_rates) {
 215                 /*
 216                  * build the rate table and bitmap flags
 217                  */
 218                 int r, idx;
 219
 220                 fp->rate_table = kmalloc_array(nr_rates, sizeof(int),
 221                                                GFP_KERNEL);
 222                 if (fp->rate_table == NULL)
 223                         return -ENOMEM;
 224
 225                 fp->nr_rates = 0;
 226                 for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) {
 227                         unsigned int rate = combine_triple(&fmt[idx]);
 228                         if (!rate)
 229                                 continue;
 230                         /* C-Media CM6501 mislabels its 96 kHz altsetting */
 231                         /* Terratec Aureon 7.1 USB C-Media 6206, too */
 232                         /* Ozone Z90 USB C-Media, too */
 233                         if (rate == 48000 && nr_rates == 1 &&
 234                             (chip->usb_id == USB_ID(0x0d8c, 0x0201) ||
 235                              chip->usb_id == USB_ID(0x0d8c, 0x0102) ||
 236                              chip->usb_id == USB_ID(0x0d8c, 0x0078) ||
 237                              chip->usb_id == USB_ID(0x0ccd, 0x00b1)) &&
 238                             fp->altsetting == 5 && fp->maxpacksize == 392)
 239                                 rate = 96000;
 240                         /* Creative VF0420/VF0470 Live Cams report 16 kHz instead of 8kHz */
 241                         if (rate == 16000 &&
 242                             (chip->usb_id == USB_ID(0x041e, 0x4064) ||
 243                              chip->usb_id == USB_ID(0x041e, 0x4068)))
 244                                 rate = 8000;
 245
 246                         fp->rate_table[fp->nr_rates++] = rate;
 247                 }
 248                 if (!fp->nr_rates) {
 249                         usb_audio_info(chip,
 250                                        "%u:%d: All rates were zero\n",
 251                                        fp->iface, fp->altsetting);
 252                         return -EINVAL;
 253                 }
 254                 set_rate_table_min_max(fp);
 255         } else {
 256                 /* continuous rates */
 257                 fp->rates = SNDRV_PCM_RATE_CONTINUOUS;
 258                 fp->rate_min = combine_triple(&fmt[offset + 1]);
 259                 fp->rate_max = combine_triple(&fmt[offset + 4]);
 260         }
 261
 262         /* Jabra Evolve 65 headset */
 263         if (chip->usb_id == USB_ID(0x0b0e, 0x030b)) {
 264                 /* only 48kHz for playback while keeping 16kHz for capture */
 265                 if (fp->nr_rates != 1)
 266                         return set_fixed_rate(fp, 48000, SNDRV_PCM_RATE_48000);
 267         }
 268
 269         return 0;
 270 }
 271
 272
 273 /*
 274  * Presonus Studio 1810c supports a limited set of sampling
 275  * rates per altsetting but reports the full set each time.
 276  * If we don't filter out the unsupported rates and attempt
 277  * to configure the card, it will hang refusing to do any
 278  * further audio I/O until a hard reset is performed.
 279  *
 280  * The list of supported rates per altsetting (set of available
 281  * I/O channels) is described in the owner's manual, section 2.2.
 282  */
 283 static bool s1810c_valid_sample_rate(struct audioformat *fp,
 284                                      unsigned int rate)
 285 {
 286         switch (fp->altsetting) {
 287         case 1:
 288                 /* All ADAT ports available */
 289                 return rate <= 48000;
 290         case 2:
 291                 /* Half of ADAT ports available */
 292                 return (rate == 88200 || rate == 96000);
 293         case 3:
 294                 /* Analog I/O only (no S/PDIF nor ADAT) */
 295                 return rate >= 176400;
 296         default:
 297                 return false;
 298         }
 299         return false;
 300 }
 301
 302 /*
 303  * Many Focusrite devices supports a limited set of sampling rates per
 304  * altsetting. Maximum rate is exposed in the last 4 bytes of Format Type
 305  * descriptor which has a non-standard bLength = 10.
 306  */
 307 static bool focusrite_valid_sample_rate(struct snd_usb_audio *chip,
 308                                         struct audioformat *fp,
 309                                         unsigned int rate)
 310 {
 311         struct usb_interface *iface;
 312         struct usb_host_interface *alts;
 313         unsigned char *fmt;
 314         unsigned int max_rate;
 315
 316         iface = usb_ifnum_to_if(chip->dev, fp->iface);
 317         if (!iface)
 318                 return true;
 319
 320         alts = &iface->altsetting[fp->altset_idx];
 321         fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen,
 322                                       NULL, UAC_FORMAT_TYPE);
 323         if (!fmt)
 324                 return true;
 325
 326         if (fmt[0] == 10) { /* bLength */
 327                 max_rate = combine_quad(&fmt[6]);
 328
 329                 /* Validate max rate */
 330                 if (max_rate != 48000 &&
 331                     max_rate != 96000 &&
 332                     max_rate != 192000 &&
 333                     max_rate != 384000) {
 334
 335                         usb_audio_info(chip,
 336                                 "%u:%d : unexpected max rate: %u\n",
 337                                 fp->iface, fp->altsetting, max_rate);
 338
 339                         return true;
 340                 }
 341
 342                 return rate <= max_rate;
 343         }
 344
 345         return true;
 346 }
 347
 348 /*
 349  * Helper function to walk the array of sample rate triplets reported by
 350  * the device. The problem is that we need to parse whole array first to
 351  * get to know how many sample rates we have to expect.
 352  * Then fp->rate_table can be allocated and filled.
 353  */
 354 static int parse_uac2_sample_rate_range(struct snd_usb_audio *chip,
 355                                         struct audioformat *fp, int nr_triplets,
 356                                         const unsigned char *data)
 357 {
 358         int i, nr_rates = 0;
 359
 360         for (i = 0; i < nr_triplets; i++) {
 361                 int min = combine_quad(&data[2 + 12 * i]);
 362                 int max = combine_quad(&data[6 + 12 * i]);
 363                 int res = combine_quad(&data[10 + 12 * i]);
 364                 unsigned int rate;
 365
 366                 if ((max < 0) || (min < 0) || (res < 0) || (max < min))
 367                         continue;
 368
 369                 /*
 370                  * for ranges with res == 1, we announce a continuous sample
 371                  * rate range, and this function should return 0 for no further
 372                  * parsing.
 373                  */
 374                 if (res == 1) {
 375                         fp->rate_min = min;
 376                         fp->rate_max = max;
 377                         fp->rates = SNDRV_PCM_RATE_CONTINUOUS;
 378                         return 0;
 379                 }
 380
 381                 for (rate = min; rate <= max; rate += res) {
 382
 383                         /* Filter out invalid rates on Presonus Studio 1810c */
 384                         if (chip->usb_id == USB_ID(0x194f, 0x010c) &&
 385                             !s1810c_valid_sample_rate(fp, rate))
 386                                 goto skip_rate;
 387
 388                         /* Filter out invalid rates on Focusrite devices */
 389                         if (USB_ID_VENDOR(chip->usb_id) == 0x1235 &&
 390                             !focusrite_valid_sample_rate(chip, fp, rate))
 391                                 goto skip_rate;
 392
 393                         if (fp->rate_table)
 394                                 fp->rate_table[nr_rates] = rate;
 395                         nr_rates++;
 396                         if (nr_rates >= MAX_NR_RATES) {
 397                                 usb_audio_err(chip, "invalid uac2 rates\n");
 398                                 break;
 399                         }
 400
 401 skip_rate:
 402                         /* avoid endless loop */
 403                         if (res == 0)
 404                                 break;
 405                 }
 406         }
 407
 408         return nr_rates;
 409 }
 410
 411 /* Line6 Helix series and the Rode Rodecaster Pro don't support the
 412  * UAC2_CS_RANGE usb function call. Return a static table of known
 413  * clock rates.
 414  */
 415 static int line6_parse_audio_format_rates_quirk(struct snd_usb_audio *chip,
 416                                                 struct audioformat *fp)
 417 {
 418         switch (chip->usb_id) {
 419         case USB_ID(0x0e41, 0x4241): /* Line6 Helix */
 420         case USB_ID(0x0e41, 0x4242): /* Line6 Helix Rack */
 421         case USB_ID(0x0e41, 0x4244): /* Line6 Helix LT */
 422         case USB_ID(0x0e41, 0x4246): /* Line6 HX-Stomp */
 423         case USB_ID(0x0e41, 0x4253): /* Line6 HX-Stomp XL */
 424         case USB_ID(0x0e41, 0x4247): /* Line6 Pod Go */
 425         case USB_ID(0x0e41, 0x4248): /* Line6 Helix >= fw 2.82 */
 426         case USB_ID(0x0e41, 0x4249): /* Line6 Helix Rack >= fw 2.82 */
 427         case USB_ID(0x0e41, 0x424a): /* Line6 Helix LT >= fw 2.82 */
 428         case USB_ID(0x0e41, 0x424b): /* Line6 Pod Go */
 429         case USB_ID(0x19f7, 0x0011): /* Rode Rodecaster Pro */
 430                 return set_fixed_rate(fp, 48000, SNDRV_PCM_RATE_48000);
 431         }
 432
 433         return -ENODEV;
 434 }
 435
 436 /* check whether the given altsetting is supported for the already set rate */
 437 static bool check_valid_altsetting_v2v3(struct snd_usb_audio *chip, int iface,
 438                                         int altsetting)
 439 {
 440         struct usb_device *dev = chip->dev;
 441         __le64 raw_data = 0;
 442         u64 data;
 443         int err;
 444
 445         /* we assume 64bit is enough for any altsettings */
 446         if (snd_BUG_ON(altsetting >= 64 - 8))
 447                 return false;
 448
 449         err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR,
 450                               USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
 451                               UAC2_AS_VAL_ALT_SETTINGS << 8,
 452                               iface, &raw_data, sizeof(raw_data));
 453         if (err < 0)
 454                 return false;
 455
 456         data = le64_to_cpu(raw_data);
 457         /* first byte contains the bitmap size */
 458         if ((data & 0xff) * 8 < altsetting)
 459                 return false;
 460         if (data & (1ULL << (altsetting + 8)))
 461                 return true;
 462
 463         return false;
 464 }
 465
 466 /*
 467  * Validate each sample rate with the altsetting
 468  * Rebuild the rate table if only partial values are valid
 469  */
 470 static int validate_sample_rate_table_v2v3(struct snd_usb_audio *chip,
 471                                            struct audioformat *fp,
 472                                            int clock)
 473 {
 474         struct usb_device *dev = chip->dev;
 475         struct usb_host_interface *alts;
 476         unsigned int *table;
 477         unsigned int nr_rates;
 478         int i, err;
 479         u32 bmControls;
 480
 481         /* performing the rate verification may lead to unexpected USB bus
 482          * behavior afterwards by some unknown reason.  Do this only for the
 483          * known devices.
 484          */
 485         if (!(chip->quirk_flags & QUIRK_FLAG_VALIDATE_RATES))
 486                 return 0; /* don't perform the validation as default */
 487
 488         alts = snd_usb_get_host_interface(chip, fp->iface, fp->altsetting);
 489         if (!alts)
 490                 return 0;
 491
 492         if (fp->protocol == UAC_VERSION_3) {
 493                 struct uac3_as_header_descriptor *as = snd_usb_find_csint_desc(
 494                                 alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
 495                 bmControls = le32_to_cpu(as->bmControls);
 496         } else {
 497                 struct uac2_as_header_descriptor *as = snd_usb_find_csint_desc(
 498                                 alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
 499                 bmControls = as->bmControls;
 500         }
 501
 502         if (!uac_v2v3_control_is_readable(bmControls,
 503                                 UAC2_AS_VAL_ALT_SETTINGS))
 504                 return 0;
 505
 506         table = kcalloc(fp->nr_rates, sizeof(*table), GFP_KERNEL);
 507         if (!table)
 508                 return -ENOMEM;
 509
 510         /* clear the interface altsetting at first */
 511         usb_set_interface(dev, fp->iface, 0);
 512
 513         nr_rates = 0;
 514         for (i = 0; i < fp->nr_rates; i++) {
 515                 err = snd_usb_set_sample_rate_v2v3(chip, fp, clock,
 516                                                    fp->rate_table[i]);
 517                 if (err < 0)
 518                         continue;
 519
 520                 if (check_valid_altsetting_v2v3(chip, fp->iface, fp->altsetting))
 521                         table[nr_rates++] = fp->rate_table[i];
 522         }
 523
 524         if (!nr_rates) {
 525                 usb_audio_dbg(chip,
 526                               "No valid sample rate available for %d:%d, assuming a firmware bug\n",
 527                               fp->iface, fp->altsetting);
 528                 nr_rates = fp->nr_rates; /* continue as is */
 529         }
 530
 531         if (fp->nr_rates == nr_rates) {
 532                 kfree(table);
 533                 return 0;
 534         }
 535
 536         kfree(fp->rate_table);
 537         fp->rate_table = table;
 538         fp->nr_rates = nr_rates;
 539         return 0;
 540 }
 541
 542 /*
 543  * parse the format descriptor and stores the possible sample rates
 544  * on the audioformat table (audio class v2 and v3).
 545  */
 546 static int parse_audio_format_rates_v2v3(struct snd_usb_audio *chip,
 547                                        struct audioformat *fp)
 548 {
 549         struct usb_device *dev = chip->dev;
 550         unsigned char tmp[2], *data;
 551         int nr_triplets, data_size, ret = 0, ret_l6;
 552         int clock = snd_usb_clock_find_source(chip, fp, false);
 553         struct usb_host_interface *ctrl_intf;
 554
 555         ctrl_intf = snd_usb_find_ctrl_interface(chip, fp->iface);
 556         if (clock < 0) {
 557                 dev_err(&dev->dev,
 558                         "%s(): unable to find clock source (clock %d)\n",
 559                                 __func__, clock);
 560                 goto err;
 561         }
 562
 563         /* get the number of sample rates first by only fetching 2 bytes */
 564         ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
 565                               USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
 566                               UAC2_CS_CONTROL_SAM_FREQ << 8,
 567                               snd_usb_ctrl_intf(ctrl_intf) | (clock << 8),
 568                               tmp, sizeof(tmp));
 569
 570         if (ret < 0) {
 571                 /* line6 helix devices don't support UAC2_CS_CONTROL_SAM_FREQ call */
 572                 ret_l6 = line6_parse_audio_format_rates_quirk(chip, fp);
 573                 if (ret_l6 == -ENODEV) {
 574                         /* no line6 device found continue showing the error */
 575                         dev_err(&dev->dev,
 576                                 "%s(): unable to retrieve number of sample rates (clock %d)\n",
 577                                 __func__, clock);
 578                         goto err;
 579                 }
 580                 if (ret_l6 == 0) {
 581                         dev_info(&dev->dev,
 582                                 "%s(): unable to retrieve number of sample rates: set it to a predefined value (clock %d).\n",
 583                                 __func__, clock);
 584                         return 0;
 585                 }
 586                 ret = ret_l6;
 587                 goto err;
 588         }
 589
 590         nr_triplets = (tmp[1] << 8) | tmp[0];
 591         data_size = 2 + 12 * nr_triplets;
 592         data = kzalloc(data_size, GFP_KERNEL);
 593         if (!data) {
 594                 ret = -ENOMEM;
 595                 goto err;
 596         }
 597
 598         /* now get the full information */
 599         ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
 600                               USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
 601                               UAC2_CS_CONTROL_SAM_FREQ << 8,
 602                               snd_usb_ctrl_intf(ctrl_intf) | (clock << 8),
 603                               data, data_size);
 604
 605         if (ret < 0) {
 606                 dev_err(&dev->dev,
 607                         "%s(): unable to retrieve sample rate range (clock %d)\n",
 608                                 __func__, clock);
 609                 ret = -EINVAL;
 610                 goto err_free;
 611         }
 612
 613         /* Call the triplet parser, and make sure fp->rate_table is NULL.
 614          * We just use the return value to know how many sample rates we
 615          * will have to deal with. */
 616         kfree(fp->rate_table);
 617         fp->rate_table = NULL;
 618         fp->nr_rates = parse_uac2_sample_rate_range(chip, fp, nr_triplets, data);
 619
 620         if (fp->nr_rates == 0) {
 621                 /* SNDRV_PCM_RATE_CONTINUOUS */
 622                 ret = 0;
 623                 goto err_free;
 624         }
 625
 626         fp->rate_table = kmalloc_array(fp->nr_rates, sizeof(int), GFP_KERNEL);
 627         if (!fp->rate_table) {
 628                 ret = -ENOMEM;
 629                 goto err_free;
 630         }
 631
 632         /* Call the triplet parser again, but this time, fp->rate_table is
 633          * allocated, so the rates will be stored */
 634         parse_uac2_sample_rate_range(chip, fp, nr_triplets, data);
 635
 636         ret = validate_sample_rate_table_v2v3(chip, fp, clock);
 637         if (ret < 0)
 638                 goto err_free;
 639
 640         set_rate_table_min_max(fp);
 641
 642 err_free:
 643         kfree(data);
 644 err:
 645         return ret;
 646 }
 647
 648 /*
 649  * parse the format type I and III descriptors
 650  */
 651 static int parse_audio_format_i(struct snd_usb_audio *chip,
 652                                 struct audioformat *fp, u64 format,
 653                                 void *_fmt)
 654 {
 655         snd_pcm_format_t pcm_format;
 656         unsigned int fmt_type;
 657         int ret;
 658
 659         switch (fp->protocol) {
 660         default:
 661         case UAC_VERSION_1:
 662         case UAC_VERSION_2: {
 663                 struct uac_format_type_i_continuous_descriptor *fmt = _fmt;
 664
 665                 fmt_type = fmt->bFormatType;
 666                 break;
 667         }
 668         case UAC_VERSION_3: {
 669                 /* fp->fmt_type is already set in this case */
 670                 fmt_type = fp->fmt_type;
 671                 break;
 672         }
 673         }
 674
 675         if (fmt_type == UAC_FORMAT_TYPE_III) {
 676                 /* FIXME: the format type is really IECxxx
 677                  *        but we give normal PCM format to get the existing
 678                  *        apps working...
 679                  */
 680                 switch (chip->usb_id) {
 681
 682                 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
 683                         if (chip->setup == 0x00 &&
 684                             fp->altsetting == 6)
 685                                 pcm_format = SNDRV_PCM_FORMAT_S16_BE;
 686                         else
 687                                 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
 688                         break;
 689                 default:
 690                         pcm_format = SNDRV_PCM_FORMAT_S16_LE;
 691                 }
 692                 fp->formats = pcm_format_to_bits(pcm_format);
 693         } else {
 694                 fp->formats = parse_audio_format_i_type(chip, fp, format, _fmt);
 695                 if (!fp->formats)
 696                         return -EINVAL;
 697         }
 698
 699         /* gather possible sample rates */
 700         /* audio class v1 reports possible sample rates as part of the
 701          * proprietary class specific descriptor.
 702          * audio class v2 uses class specific EP0 range requests for that.
 703          */
 704         switch (fp->protocol) {
 705         default:
 706         case UAC_VERSION_1: {
 707                 struct uac_format_type_i_continuous_descriptor *fmt = _fmt;
 708
 709                 fp->channels = fmt->bNrChannels;
 710                 ret = parse_audio_format_rates_v1(chip, fp, (unsigned char *) fmt, 7);
 711                 break;
 712         }
 713         case UAC_VERSION_2:
 714         case UAC_VERSION_3: {
 715                 /* fp->channels is already set in this case */
 716                 ret = parse_audio_format_rates_v2v3(chip, fp);
 717                 break;
 718         }
 719         }
 720
 721         if (fp->channels < 1) {
 722                 usb_audio_err(chip,
 723                         "%u:%d : invalid channels %d\n",
 724                         fp->iface, fp->altsetting, fp->channels);
 725                 return -EINVAL;
 726         }
 727
 728         return ret;
 729 }
 730
 731 /*
 732  * parse the format type II descriptor
 733  */
 734 static int parse_audio_format_ii(struct snd_usb_audio *chip,
 735                                  struct audioformat *fp,
 736                                  u64 format, void *_fmt)
 737 {
 738         int brate, framesize, ret;
 739
 740         switch (format) {
 741         case UAC_FORMAT_TYPE_II_AC3:
 742                 /* FIXME: there is no AC3 format defined yet */
 743                 // fp->formats = SNDRV_PCM_FMTBIT_AC3;
 744                 fp->formats = SNDRV_PCM_FMTBIT_U8; /* temporary hack to receive byte streams */
 745                 break;
 746         case UAC_FORMAT_TYPE_II_MPEG:
 747                 fp->formats = SNDRV_PCM_FMTBIT_MPEG;
 748                 break;
 749         default:
 750                 usb_audio_info(chip,
 751                          "%u:%d : unknown format tag %#llx is detected.  processed as MPEG.\n",
 752                          fp->iface, fp->altsetting, format);
 753                 fp->formats = SNDRV_PCM_FMTBIT_MPEG;
 754                 break;
 755         }
 756
 757         fp->channels = 1;
 758
 759         switch (fp->protocol) {
 760         default:
 761         case UAC_VERSION_1: {
 762                 struct uac_format_type_ii_discrete_descriptor *fmt = _fmt;
 763                 brate = le16_to_cpu(fmt->wMaxBitRate);
 764                 framesize = le16_to_cpu(fmt->wSamplesPerFrame);
 765                 usb_audio_info(chip, "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
 766                 fp->frame_size = framesize;
 767                 ret = parse_audio_format_rates_v1(chip, fp, _fmt, 8); /* fmt[8..] sample rates */
 768                 break;
 769         }
 770         case UAC_VERSION_2: {
 771                 struct uac_format_type_ii_ext_descriptor *fmt = _fmt;
 772                 brate = le16_to_cpu(fmt->wMaxBitRate);
 773                 framesize = le16_to_cpu(fmt->wSamplesPerFrame);
 774                 usb_audio_info(chip, "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
 775                 fp->frame_size = framesize;
 776                 ret = parse_audio_format_rates_v2v3(chip, fp);
 777                 break;
 778         }
 779         }
 780
 781         return ret;
 782 }
 783
 784 int snd_usb_parse_audio_format(struct snd_usb_audio *chip,
 785                                struct audioformat *fp, u64 format,
 786                                struct uac_format_type_i_continuous_descriptor *fmt,
 787                                int stream)
 788 {
 789         int err;
 790
 791         switch (fmt->bFormatType) {
 792         case UAC_FORMAT_TYPE_I:
 793         case UAC_FORMAT_TYPE_III:
 794                 err = parse_audio_format_i(chip, fp, format, fmt);
 795                 break;
 796         case UAC_FORMAT_TYPE_II:
 797                 err = parse_audio_format_ii(chip, fp, format, fmt);
 798                 break;
 799         default:
 800                 usb_audio_info(chip,
 801                          "%u:%d : format type %d is not supported yet\n",
 802                          fp->iface, fp->altsetting,
 803                          fmt->bFormatType);
 804                 return -ENOTSUPP;
 805         }
 806         fp->fmt_type = fmt->bFormatType;
 807         if (err < 0)
 808                 return err;
 809 #if 1
 810         /* FIXME: temporary hack for extigy/audigy 2 nx/zs */
 811         /* extigy apparently supports sample rates other than 48k
 812          * but not in ordinary way.  so we enable only 48k atm.
 813          */
 814         if (chip->usb_id == USB_ID(0x041e, 0x3000) ||
 815             chip->usb_id == USB_ID(0x041e, 0x3020) ||
 816             chip->usb_id == USB_ID(0x041e, 0x3061)) {
 817                 if (fmt->bFormatType == UAC_FORMAT_TYPE_I &&
 818                     fp->rates != SNDRV_PCM_RATE_48000 &&
 819                     fp->rates != SNDRV_PCM_RATE_96000)
 820                         return -ENOTSUPP;
 821         }
 822 #endif
 823         return 0;
 824 }
 825
 826 int snd_usb_parse_audio_format_v3(struct snd_usb_audio *chip,
 827                                struct audioformat *fp,
 828                                struct uac3_as_header_descriptor *as,
 829                                int stream)
 830 {
 831         u64 format = le64_to_cpu(as->bmFormats);
 832         int err;
 833
 834         /*
 835          * Type I format bits are D0..D6
 836          * This test works because type IV is not supported
 837          */
 838         if (format & 0x7f)
 839                 fp->fmt_type = UAC_FORMAT_TYPE_I;
 840         else
 841                 fp->fmt_type = UAC_FORMAT_TYPE_III;
 842
 843         err = parse_audio_format_i(chip, fp, format, as);
 844         if (err < 0)
 845                 return err;
 846
 847         return 0;
 848 }