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