format.c 12 KB

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