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