1 /* 2 * This program is free software; you can redistribute it and/or modify 3 * it under the terms of the GNU General Public License as published by 4 * the Free Software Foundation; either version 2 of the License, or 5 * (at your option) any later version. 6 * 7 * This program is distributed in the hope that it will be useful, 8 * but WITHOUT ANY WARRANTY; without even the implied warranty of 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 10 * GNU General Public License for more details. 11 * 12 * You should have received a copy of the GNU General Public License 13 * along with this program; if not, write to the Free Software 14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 15 * 16 */ 17 18 #include <linux/init.h> 19 #include <linux/usb.h> 20 #include <linux/usb/audio.h> 21 #include <linux/usb/audio-v2.h> 22 23 #include <sound/core.h> 24 #include <sound/pcm.h> 25 26 #include "usbaudio.h" 27 #include "card.h" 28 #include "quirks.h" 29 #include "helper.h" 30 #include "debug.h" 31 32 /* 33 * parse the audio format type I descriptor 34 * and returns the corresponding pcm format 35 * 36 * @dev: usb device 37 * @fp: audioformat record 38 * @format: the format tag (wFormatTag) 39 * @fmt: the format type descriptor 40 */ 41 static u64 parse_audio_format_i_type(struct snd_usb_audio *chip, 42 struct audioformat *fp, 43 int format, void *_fmt, 44 int protocol) 45 { 46 int sample_width, sample_bytes; 47 u64 pcm_formats; 48 49 switch (protocol) { 50 case UAC_VERSION_1: { 51 struct uac_format_type_i_discrete_descriptor *fmt = _fmt; 52 sample_width = fmt->bBitResolution; 53 sample_bytes = fmt->bSubframeSize; 54 format = 1 << format; 55 break; 56 } 57 58 case UAC_VERSION_2: { 59 struct uac_format_type_i_ext_descriptor *fmt = _fmt; 60 sample_width = fmt->bBitResolution; 61 sample_bytes = fmt->bSubslotSize; 62 format <<= 1; 63 break; 64 } 65 66 default: 67 return -EINVAL; 68 } 69 70 pcm_formats = 0; 71 72 if (format == 0 || format == (1 << UAC_FORMAT_TYPE_I_UNDEFINED)) { 73 /* some devices don't define this correctly... */ 74 snd_printdd(KERN_INFO "%d:%u:%d : format type 0 is detected, processed as PCM\n", 75 chip->dev->devnum, fp->iface, fp->altsetting); 76 format = 1 << UAC_FORMAT_TYPE_I_PCM; 77 } 78 if (format & (1 << UAC_FORMAT_TYPE_I_PCM)) { 79 if (sample_width > sample_bytes * 8) { 80 snd_printk(KERN_INFO "%d:%u:%d : sample bitwidth %d in over sample bytes %d\n", 81 chip->dev->devnum, fp->iface, fp->altsetting, 82 sample_width, sample_bytes); 83 } 84 /* check the format byte size */ 85 switch (sample_bytes) { 86 case 1: 87 pcm_formats |= SNDRV_PCM_FMTBIT_S8; 88 break; 89 case 2: 90 if (snd_usb_is_big_endian_format(chip, fp)) 91 pcm_formats |= SNDRV_PCM_FMTBIT_S16_BE; /* grrr, big endian!! */ 92 else 93 pcm_formats |= SNDRV_PCM_FMTBIT_S16_LE; 94 break; 95 case 3: 96 if (snd_usb_is_big_endian_format(chip, fp)) 97 pcm_formats |= SNDRV_PCM_FMTBIT_S24_3BE; /* grrr, big endian!! */ 98 else 99 pcm_formats |= SNDRV_PCM_FMTBIT_S24_3LE; 100 break; 101 case 4: 102 pcm_formats |= SNDRV_PCM_FMTBIT_S32_LE; 103 break; 104 default: 105 snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n", 106 chip->dev->devnum, fp->iface, fp->altsetting, 107 sample_width, sample_bytes); 108 break; 109 } 110 } 111 if (format & (1 << UAC_FORMAT_TYPE_I_PCM8)) { 112 /* Dallas DS4201 workaround: it advertises U8 format, but really 113 supports S8. */ 114 if (chip->usb_id == USB_ID(0x04fa, 0x4201)) 115 pcm_formats |= SNDRV_PCM_FMTBIT_S8; 116 else 117 pcm_formats |= SNDRV_PCM_FMTBIT_U8; 118 } 119 if (format & (1 << UAC_FORMAT_TYPE_I_IEEE_FLOAT)) { 120 pcm_formats |= SNDRV_PCM_FMTBIT_FLOAT_LE; 121 } 122 if (format & (1 << UAC_FORMAT_TYPE_I_ALAW)) { 123 pcm_formats |= SNDRV_PCM_FMTBIT_A_LAW; 124 } 125 if (format & (1 << UAC_FORMAT_TYPE_I_MULAW)) { 126 pcm_formats |= SNDRV_PCM_FMTBIT_MU_LAW; 127 } 128 if (format & ~0x3f) { 129 snd_printk(KERN_INFO "%d:%u:%d : unsupported format bits %#x\n", 130 chip->dev->devnum, fp->iface, fp->altsetting, format); 131 } 132 return pcm_formats; 133 } 134 135 136 /* 137 * parse the format descriptor and stores the possible sample rates 138 * on the audioformat table (audio class v1). 139 * 140 * @dev: usb device 141 * @fp: audioformat record 142 * @fmt: the format descriptor 143 * @offset: the start offset of descriptor pointing the rate type 144 * (7 for type I and II, 8 for type II) 145 */ 146 static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audioformat *fp, 147 unsigned char *fmt, int offset) 148 { 149 int nr_rates = fmt[offset]; 150 151 if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) { 152 snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n", 153 chip->dev->devnum, fp->iface, fp->altsetting); 154 return -1; 155 } 156 157 if (nr_rates) { 158 /* 159 * build the rate table and bitmap flags 160 */ 161 int r, idx; 162 163 fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL); 164 if (fp->rate_table == NULL) { 165 snd_printk(KERN_ERR "cannot malloc\n"); 166 return -1; 167 } 168 169 fp->nr_rates = 0; 170 fp->rate_min = fp->rate_max = 0; 171 for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) { 172 unsigned int rate = combine_triple(&fmt[idx]); 173 if (!rate) 174 continue; 175 /* C-Media CM6501 mislabels its 96 kHz altsetting */ 176 if (rate == 48000 && nr_rates == 1 && 177 (chip->usb_id == USB_ID(0x0d8c, 0x0201) || 178 chip->usb_id == USB_ID(0x0d8c, 0x0102)) && 179 fp->altsetting == 5 && fp->maxpacksize == 392) 180 rate = 96000; 181 /* Creative VF0470 Live Cam reports 16 kHz instead of 8kHz */ 182 if (rate == 16000 && chip->usb_id == USB_ID(0x041e, 0x4068)) 183 rate = 8000; 184 185 fp->rate_table[fp->nr_rates] = rate; 186 if (!fp->rate_min || rate < fp->rate_min) 187 fp->rate_min = rate; 188 if (!fp->rate_max || rate > fp->rate_max) 189 fp->rate_max = rate; 190 fp->rates |= snd_pcm_rate_to_rate_bit(rate); 191 fp->nr_rates++; 192 } 193 if (!fp->nr_rates) { 194 hwc_debug("All rates were zero. Skipping format!\n"); 195 return -1; 196 } 197 } else { 198 /* continuous rates */ 199 fp->rates = SNDRV_PCM_RATE_CONTINUOUS; 200 fp->rate_min = combine_triple(&fmt[offset + 1]); 201 fp->rate_max = combine_triple(&fmt[offset + 4]); 202 } 203 return 0; 204 } 205 206 /* 207 * parse the format descriptor and stores the possible sample rates 208 * on the audioformat table (audio class v2). 209 */ 210 static int parse_audio_format_rates_v2(struct snd_usb_audio *chip, 211 struct audioformat *fp, 212 struct usb_host_interface *iface) 213 { 214 struct usb_device *dev = chip->dev; 215 unsigned char tmp[2], *data; 216 int i, nr_rates, data_size, ret = 0; 217 218 /* get the number of sample rates first by only fetching 2 bytes */ 219 ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE, 220 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, 221 UAC2_CS_CONTROL_SAM_FREQ << 8, chip->clock_id << 8, 222 tmp, sizeof(tmp), 1000); 223 224 if (ret < 0) { 225 snd_printk(KERN_ERR "unable to retrieve number of sample rates\n"); 226 goto err; 227 } 228 229 nr_rates = (tmp[1] << 8) | tmp[0]; 230 data_size = 2 + 12 * nr_rates; 231 data = kzalloc(data_size, GFP_KERNEL); 232 if (!data) { 233 ret = -ENOMEM; 234 goto err; 235 } 236 237 /* now get the full information */ 238 ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE, 239 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, 240 UAC2_CS_CONTROL_SAM_FREQ << 8, chip->clock_id << 8, 241 data, data_size, 1000); 242 243 if (ret < 0) { 244 snd_printk(KERN_ERR "unable to retrieve sample rate range\n"); 245 ret = -EINVAL; 246 goto err_free; 247 } 248 249 fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL); 250 if (!fp->rate_table) { 251 ret = -ENOMEM; 252 goto err_free; 253 } 254 255 fp->nr_rates = 0; 256 fp->rate_min = fp->rate_max = 0; 257 258 for (i = 0; i < nr_rates; i++) { 259 int rate = combine_quad(&data[2 + 12 * i]); 260 261 fp->rate_table[fp->nr_rates] = rate; 262 if (!fp->rate_min || rate < fp->rate_min) 263 fp->rate_min = rate; 264 if (!fp->rate_max || rate > fp->rate_max) 265 fp->rate_max = rate; 266 fp->rates |= snd_pcm_rate_to_rate_bit(rate); 267 fp->nr_rates++; 268 } 269 270 err_free: 271 kfree(data); 272 err: 273 return ret; 274 } 275 276 /* 277 * parse the format type I and III descriptors 278 */ 279 static int parse_audio_format_i(struct snd_usb_audio *chip, 280 struct audioformat *fp, 281 int format, void *_fmt, 282 struct usb_host_interface *iface) 283 { 284 struct usb_interface_descriptor *altsd = get_iface_desc(iface); 285 struct uac_format_type_i_discrete_descriptor *fmt = _fmt; 286 int protocol = altsd->bInterfaceProtocol; 287 int pcm_format, ret; 288 289 if (fmt->bFormatType == UAC_FORMAT_TYPE_III) { 290 /* FIXME: the format type is really IECxxx 291 * but we give normal PCM format to get the existing 292 * apps working... 293 */ 294 switch (chip->usb_id) { 295 296 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */ 297 if (chip->setup == 0x00 && 298 fp->altsetting == 6) 299 pcm_format = SNDRV_PCM_FORMAT_S16_BE; 300 else 301 pcm_format = SNDRV_PCM_FORMAT_S16_LE; 302 break; 303 default: 304 pcm_format = SNDRV_PCM_FORMAT_S16_LE; 305 } 306 fp->formats = 1uLL << pcm_format; 307 } else { 308 fp->formats = parse_audio_format_i_type(chip, fp, format, 309 fmt, protocol); 310 if (!fp->formats) 311 return -1; 312 } 313 314 /* gather possible sample rates */ 315 /* audio class v1 reports possible sample rates as part of the 316 * proprietary class specific descriptor. 317 * audio class v2 uses class specific EP0 range requests for that. 318 */ 319 switch (protocol) { 320 case UAC_VERSION_1: 321 fp->channels = fmt->bNrChannels; 322 ret = parse_audio_format_rates_v1(chip, fp, _fmt, 7); 323 break; 324 case UAC_VERSION_2: 325 /* fp->channels is already set in this case */ 326 ret = parse_audio_format_rates_v2(chip, fp, iface); 327 break; 328 } 329 330 if (fp->channels < 1) { 331 snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n", 332 chip->dev->devnum, fp->iface, fp->altsetting, fp->channels); 333 return -1; 334 } 335 336 return ret; 337 } 338 339 /* 340 * parse the format type II descriptor 341 */ 342 static int parse_audio_format_ii(struct snd_usb_audio *chip, 343 struct audioformat *fp, 344 int format, void *_fmt, 345 struct usb_host_interface *iface) 346 { 347 int brate, framesize, ret; 348 struct usb_interface_descriptor *altsd = get_iface_desc(iface); 349 int protocol = altsd->bInterfaceProtocol; 350 351 switch (format) { 352 case UAC_FORMAT_TYPE_II_AC3: 353 /* FIXME: there is no AC3 format defined yet */ 354 // fp->formats = SNDRV_PCM_FMTBIT_AC3; 355 fp->formats = SNDRV_PCM_FMTBIT_U8; /* temporary hack to receive byte streams */ 356 break; 357 case UAC_FORMAT_TYPE_II_MPEG: 358 fp->formats = SNDRV_PCM_FMTBIT_MPEG; 359 break; 360 default: 361 snd_printd(KERN_INFO "%d:%u:%d : unknown format tag %#x is detected. processed as MPEG.\n", 362 chip->dev->devnum, fp->iface, fp->altsetting, format); 363 fp->formats = SNDRV_PCM_FMTBIT_MPEG; 364 break; 365 } 366 367 fp->channels = 1; 368 369 switch (protocol) { 370 case UAC_VERSION_1: { 371 struct uac_format_type_ii_discrete_descriptor *fmt = _fmt; 372 brate = le16_to_cpu(fmt->wMaxBitRate); 373 framesize = le16_to_cpu(fmt->wSamplesPerFrame); 374 snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize); 375 fp->frame_size = framesize; 376 ret = parse_audio_format_rates_v1(chip, fp, _fmt, 8); /* fmt[8..] sample rates */ 377 break; 378 } 379 case UAC_VERSION_2: { 380 struct uac_format_type_ii_ext_descriptor *fmt = _fmt; 381 brate = le16_to_cpu(fmt->wMaxBitRate); 382 framesize = le16_to_cpu(fmt->wSamplesPerFrame); 383 snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize); 384 fp->frame_size = framesize; 385 ret = parse_audio_format_rates_v2(chip, fp, iface); 386 break; 387 } 388 } 389 390 return ret; 391 } 392 393 int snd_usb_parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp, 394 int format, unsigned char *fmt, int stream, 395 struct usb_host_interface *iface) 396 { 397 int err; 398 399 switch (fmt[3]) { 400 case UAC_FORMAT_TYPE_I: 401 case UAC_FORMAT_TYPE_III: 402 err = parse_audio_format_i(chip, fp, format, fmt, iface); 403 break; 404 case UAC_FORMAT_TYPE_II: 405 err = parse_audio_format_ii(chip, fp, format, fmt, iface); 406 break; 407 default: 408 snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n", 409 chip->dev->devnum, fp->iface, fp->altsetting, fmt[3]); 410 return -1; 411 } 412 fp->fmt_type = fmt[3]; 413 if (err < 0) 414 return err; 415 #if 1 416 /* FIXME: temporary hack for extigy/audigy 2 nx/zs */ 417 /* extigy apparently supports sample rates other than 48k 418 * but not in ordinary way. so we enable only 48k atm. 419 */ 420 if (chip->usb_id == USB_ID(0x041e, 0x3000) || 421 chip->usb_id == USB_ID(0x041e, 0x3020) || 422 chip->usb_id == USB_ID(0x041e, 0x3061)) { 423 if (fmt[3] == UAC_FORMAT_TYPE_I && 424 fp->rates != SNDRV_PCM_RATE_48000 && 425 fp->rates != SNDRV_PCM_RATE_96000) 426 return -1; 427 } 428 #endif 429 return 0; 430 } 431 432