usbaudio.c 93 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334
  1. /*
  2. * (Tentative) USB Audio Driver for ALSA
  3. *
  4. * Main and PCM part
  5. *
  6. * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
  7. *
  8. * Many codes borrowed from audio.c by
  9. * Alan Cox (alan@lxorguk.ukuu.org.uk)
  10. * Thomas Sailer (sailer@ife.ee.ethz.ch)
  11. *
  12. *
  13. * This program is free software; you can redistribute it and/or modify
  14. * it under the terms of the GNU General Public License as published by
  15. * the Free Software Foundation; either version 2 of the License, or
  16. * (at your option) any later version.
  17. *
  18. * This program is distributed in the hope that it will be useful,
  19. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  21. * GNU General Public License for more details.
  22. *
  23. * You should have received a copy of the GNU General Public License
  24. * along with this program; if not, write to the Free Software
  25. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  26. *
  27. *
  28. * NOTES:
  29. *
  30. * - async unlink should be used for avoiding the sleep inside lock.
  31. * 2.4.22 usb-uhci seems buggy for async unlinking and results in
  32. * oops. in such a cse, pass async_unlink=0 option.
  33. * - the linked URBs would be preferred but not used so far because of
  34. * the instability of unlinking.
  35. * - type II is not supported properly. there is no device which supports
  36. * this type *correctly*. SB extigy looks as if it supports, but it's
  37. * indeed an AC3 stream packed in SPDIF frames (i.e. no real AC3 stream).
  38. */
  39. #include <sound/driver.h>
  40. #include <linux/bitops.h>
  41. #include <linux/init.h>
  42. #include <linux/list.h>
  43. #include <linux/slab.h>
  44. #include <linux/string.h>
  45. #include <linux/usb.h>
  46. #include <linux/moduleparam.h>
  47. #include <sound/core.h>
  48. #include <sound/info.h>
  49. #include <sound/pcm.h>
  50. #include <sound/pcm_params.h>
  51. #include <sound/initval.h>
  52. #include "usbaudio.h"
  53. MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
  54. MODULE_DESCRIPTION("USB Audio");
  55. MODULE_LICENSE("GPL");
  56. MODULE_SUPPORTED_DEVICE("{{Generic,USB Audio}}");
  57. static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
  58. static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
  59. static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
  60. static int vid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 }; /* Vendor ID for this card */
  61. static int pid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 }; /* Product ID for this card */
  62. static int nrpacks = 4; /* max. number of packets per urb */
  63. static int async_unlink = 1;
  64. module_param_array(index, int, NULL, 0444);
  65. MODULE_PARM_DESC(index, "Index value for the USB audio adapter.");
  66. module_param_array(id, charp, NULL, 0444);
  67. MODULE_PARM_DESC(id, "ID string for the USB audio adapter.");
  68. module_param_array(enable, bool, NULL, 0444);
  69. MODULE_PARM_DESC(enable, "Enable USB audio adapter.");
  70. module_param_array(vid, int, NULL, 0444);
  71. MODULE_PARM_DESC(vid, "Vendor ID for the USB audio device.");
  72. module_param_array(pid, int, NULL, 0444);
  73. MODULE_PARM_DESC(pid, "Product ID for the USB audio device.");
  74. module_param(nrpacks, int, 0444);
  75. MODULE_PARM_DESC(nrpacks, "Max. number of packets per URB.");
  76. module_param(async_unlink, bool, 0444);
  77. MODULE_PARM_DESC(async_unlink, "Use async unlink mode.");
  78. /*
  79. * debug the h/w constraints
  80. */
  81. /* #define HW_CONST_DEBUG */
  82. /*
  83. *
  84. */
  85. #define MAX_PACKS 10
  86. #define MAX_PACKS_HS (MAX_PACKS * 8) /* in high speed mode */
  87. #define MAX_URBS 5 /* max. 20ms long packets */
  88. #define SYNC_URBS 2 /* always two urbs for sync */
  89. #define MIN_PACKS_URB 1 /* minimum 1 packet per urb */
  90. typedef struct snd_usb_substream snd_usb_substream_t;
  91. typedef struct snd_usb_stream snd_usb_stream_t;
  92. typedef struct snd_urb_ctx snd_urb_ctx_t;
  93. struct audioformat {
  94. struct list_head list;
  95. snd_pcm_format_t format; /* format type */
  96. unsigned int channels; /* # channels */
  97. unsigned int fmt_type; /* USB audio format type (1-3) */
  98. unsigned int frame_size; /* samples per frame for non-audio */
  99. int iface; /* interface number */
  100. unsigned char altsetting; /* corresponding alternate setting */
  101. unsigned char altset_idx; /* array index of altenate setting */
  102. unsigned char attributes; /* corresponding attributes of cs endpoint */
  103. unsigned char endpoint; /* endpoint */
  104. unsigned char ep_attr; /* endpoint attributes */
  105. unsigned int maxpacksize; /* max. packet size */
  106. unsigned int rates; /* rate bitmasks */
  107. unsigned int rate_min, rate_max; /* min/max rates */
  108. unsigned int nr_rates; /* number of rate table entries */
  109. unsigned int *rate_table; /* rate table */
  110. };
  111. struct snd_urb_ctx {
  112. struct urb *urb;
  113. snd_usb_substream_t *subs;
  114. int index; /* index for urb array */
  115. int packets; /* number of packets per urb */
  116. int transfer; /* transferred size */
  117. char *buf; /* buffer for capture */
  118. };
  119. struct snd_urb_ops {
  120. int (*prepare)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
  121. int (*retire)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
  122. int (*prepare_sync)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
  123. int (*retire_sync)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
  124. };
  125. struct snd_usb_substream {
  126. snd_usb_stream_t *stream;
  127. struct usb_device *dev;
  128. snd_pcm_substream_t *pcm_substream;
  129. int direction; /* playback or capture */
  130. int interface; /* current interface */
  131. int endpoint; /* assigned endpoint */
  132. struct audioformat *cur_audiofmt; /* current audioformat pointer (for hw_params callback) */
  133. unsigned int cur_rate; /* current rate (for hw_params callback) */
  134. unsigned int period_bytes; /* current period bytes (for hw_params callback) */
  135. unsigned int format; /* USB data format */
  136. unsigned int datapipe; /* the data i/o pipe */
  137. unsigned int syncpipe; /* 1 - async out or adaptive in */
  138. unsigned int syncinterval; /* P for adaptive mode, 0 otherwise */
  139. unsigned int freqn; /* nominal sampling rate in fs/fps in Q16.16 format */
  140. unsigned int freqm; /* momentary sampling rate in fs/fps in Q16.16 format */
  141. unsigned int freqmax; /* maximum sampling rate, used for buffer management */
  142. unsigned int phase; /* phase accumulator */
  143. unsigned int maxpacksize; /* max packet size in bytes */
  144. unsigned int maxframesize; /* max packet size in frames */
  145. unsigned int curpacksize; /* current packet size in bytes (for capture) */
  146. unsigned int curframesize; /* current packet size in frames (for capture) */
  147. unsigned int fill_max: 1; /* fill max packet size always */
  148. unsigned int fmt_type; /* USB audio format type (1-3) */
  149. unsigned int running: 1; /* running status */
  150. unsigned int hwptr; /* free frame position in the buffer (only for playback) */
  151. unsigned int hwptr_done; /* processed frame position in the buffer */
  152. unsigned int transfer_sched; /* scheduled frames since last period (for playback) */
  153. unsigned int transfer_done; /* processed frames since last period update */
  154. unsigned long active_mask; /* bitmask of active urbs */
  155. unsigned long unlink_mask; /* bitmask of unlinked urbs */
  156. unsigned int nurbs; /* # urbs */
  157. snd_urb_ctx_t dataurb[MAX_URBS]; /* data urb table */
  158. snd_urb_ctx_t syncurb[SYNC_URBS]; /* sync urb table */
  159. char syncbuf[SYNC_URBS * 4]; /* sync buffer; it's so small - let's get static */
  160. char *tmpbuf; /* temporary buffer for playback */
  161. u64 formats; /* format bitmasks (all or'ed) */
  162. unsigned int num_formats; /* number of supported audio formats (list) */
  163. struct list_head fmt_list; /* format list */
  164. spinlock_t lock;
  165. struct snd_urb_ops ops; /* callbacks (must be filled at init) */
  166. };
  167. struct snd_usb_stream {
  168. snd_usb_audio_t *chip;
  169. snd_pcm_t *pcm;
  170. int pcm_index;
  171. unsigned int fmt_type; /* USB audio format type (1-3) */
  172. snd_usb_substream_t substream[2];
  173. struct list_head list;
  174. };
  175. /*
  176. * we keep the snd_usb_audio_t instances by ourselves for merging
  177. * the all interfaces on the same card as one sound device.
  178. */
  179. static DECLARE_MUTEX(register_mutex);
  180. static snd_usb_audio_t *usb_chip[SNDRV_CARDS];
  181. /*
  182. * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
  183. * this will overflow at approx 524 kHz
  184. */
  185. inline static unsigned get_usb_full_speed_rate(unsigned int rate)
  186. {
  187. return ((rate << 13) + 62) / 125;
  188. }
  189. /*
  190. * convert a sampling rate into USB high speed format (fs/8000 in Q16.16)
  191. * this will overflow at approx 4 MHz
  192. */
  193. inline static unsigned get_usb_high_speed_rate(unsigned int rate)
  194. {
  195. return ((rate << 10) + 62) / 125;
  196. }
  197. /* convert our full speed USB rate into sampling rate in Hz */
  198. inline static unsigned get_full_speed_hz(unsigned int usb_rate)
  199. {
  200. return (usb_rate * 125 + (1 << 12)) >> 13;
  201. }
  202. /* convert our high speed USB rate into sampling rate in Hz */
  203. inline static unsigned get_high_speed_hz(unsigned int usb_rate)
  204. {
  205. return (usb_rate * 125 + (1 << 9)) >> 10;
  206. }
  207. /*
  208. * prepare urb for full speed capture sync pipe
  209. *
  210. * fill the length and offset of each urb descriptor.
  211. * the fixed 10.14 frequency is passed through the pipe.
  212. */
  213. static int prepare_capture_sync_urb(snd_usb_substream_t *subs,
  214. snd_pcm_runtime_t *runtime,
  215. struct urb *urb)
  216. {
  217. unsigned char *cp = urb->transfer_buffer;
  218. snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
  219. urb->dev = ctx->subs->dev; /* we need to set this at each time */
  220. urb->iso_frame_desc[0].length = 3;
  221. urb->iso_frame_desc[0].offset = 0;
  222. cp[0] = subs->freqn >> 2;
  223. cp[1] = subs->freqn >> 10;
  224. cp[2] = subs->freqn >> 18;
  225. return 0;
  226. }
  227. /*
  228. * prepare urb for high speed capture sync pipe
  229. *
  230. * fill the length and offset of each urb descriptor.
  231. * the fixed 12.13 frequency is passed as 16.16 through the pipe.
  232. */
  233. static int prepare_capture_sync_urb_hs(snd_usb_substream_t *subs,
  234. snd_pcm_runtime_t *runtime,
  235. struct urb *urb)
  236. {
  237. unsigned char *cp = urb->transfer_buffer;
  238. snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
  239. urb->dev = ctx->subs->dev; /* we need to set this at each time */
  240. urb->iso_frame_desc[0].length = 4;
  241. urb->iso_frame_desc[0].offset = 0;
  242. cp[0] = subs->freqn;
  243. cp[1] = subs->freqn >> 8;
  244. cp[2] = subs->freqn >> 16;
  245. cp[3] = subs->freqn >> 24;
  246. return 0;
  247. }
  248. /*
  249. * process after capture sync complete
  250. * - nothing to do
  251. */
  252. static int retire_capture_sync_urb(snd_usb_substream_t *subs,
  253. snd_pcm_runtime_t *runtime,
  254. struct urb *urb)
  255. {
  256. return 0;
  257. }
  258. /*
  259. * prepare urb for capture data pipe
  260. *
  261. * fill the offset and length of each descriptor.
  262. *
  263. * we use a temporary buffer to write the captured data.
  264. * since the length of written data is determined by host, we cannot
  265. * write onto the pcm buffer directly... the data is thus copied
  266. * later at complete callback to the global buffer.
  267. */
  268. static int prepare_capture_urb(snd_usb_substream_t *subs,
  269. snd_pcm_runtime_t *runtime,
  270. struct urb *urb)
  271. {
  272. int i, offs;
  273. unsigned long flags;
  274. snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
  275. offs = 0;
  276. urb->dev = ctx->subs->dev; /* we need to set this at each time */
  277. urb->number_of_packets = 0;
  278. spin_lock_irqsave(&subs->lock, flags);
  279. for (i = 0; i < ctx->packets; i++) {
  280. urb->iso_frame_desc[i].offset = offs;
  281. urb->iso_frame_desc[i].length = subs->curpacksize;
  282. offs += subs->curpacksize;
  283. urb->number_of_packets++;
  284. subs->transfer_sched += subs->curframesize;
  285. if (subs->transfer_sched >= runtime->period_size) {
  286. subs->transfer_sched -= runtime->period_size;
  287. break;
  288. }
  289. }
  290. spin_unlock_irqrestore(&subs->lock, flags);
  291. urb->transfer_buffer = ctx->buf;
  292. urb->transfer_buffer_length = offs;
  293. #if 0 // for check
  294. if (! urb->bandwidth) {
  295. int bustime;
  296. bustime = usb_check_bandwidth(urb->dev, urb);
  297. if (bustime < 0)
  298. return bustime;
  299. printk("urb %d: bandwidth = %d (packets = %d)\n", ctx->index, bustime, urb->number_of_packets);
  300. usb_claim_bandwidth(urb->dev, urb, bustime, 1);
  301. }
  302. #endif // for check
  303. return 0;
  304. }
  305. /*
  306. * process after capture complete
  307. *
  308. * copy the data from each desctiptor to the pcm buffer, and
  309. * update the current position.
  310. */
  311. static int retire_capture_urb(snd_usb_substream_t *subs,
  312. snd_pcm_runtime_t *runtime,
  313. struct urb *urb)
  314. {
  315. unsigned long flags;
  316. unsigned char *cp;
  317. int i;
  318. unsigned int stride, len, oldptr;
  319. stride = runtime->frame_bits >> 3;
  320. for (i = 0; i < urb->number_of_packets; i++) {
  321. cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset;
  322. if (urb->iso_frame_desc[i].status) {
  323. snd_printd(KERN_ERR "frame %d active: %d\n", i, urb->iso_frame_desc[i].status);
  324. // continue;
  325. }
  326. len = urb->iso_frame_desc[i].actual_length / stride;
  327. if (! len)
  328. continue;
  329. /* update the current pointer */
  330. spin_lock_irqsave(&subs->lock, flags);
  331. oldptr = subs->hwptr_done;
  332. subs->hwptr_done += len;
  333. if (subs->hwptr_done >= runtime->buffer_size)
  334. subs->hwptr_done -= runtime->buffer_size;
  335. subs->transfer_done += len;
  336. spin_unlock_irqrestore(&subs->lock, flags);
  337. /* copy a data chunk */
  338. if (oldptr + len > runtime->buffer_size) {
  339. unsigned int cnt = runtime->buffer_size - oldptr;
  340. unsigned int blen = cnt * stride;
  341. memcpy(runtime->dma_area + oldptr * stride, cp, blen);
  342. memcpy(runtime->dma_area, cp + blen, len * stride - blen);
  343. } else {
  344. memcpy(runtime->dma_area + oldptr * stride, cp, len * stride);
  345. }
  346. /* update the pointer, call callback if necessary */
  347. spin_lock_irqsave(&subs->lock, flags);
  348. if (subs->transfer_done >= runtime->period_size) {
  349. subs->transfer_done -= runtime->period_size;
  350. spin_unlock_irqrestore(&subs->lock, flags);
  351. snd_pcm_period_elapsed(subs->pcm_substream);
  352. } else
  353. spin_unlock_irqrestore(&subs->lock, flags);
  354. }
  355. return 0;
  356. }
  357. /*
  358. * prepare urb for full speed playback sync pipe
  359. *
  360. * set up the offset and length to receive the current frequency.
  361. */
  362. static int prepare_playback_sync_urb(snd_usb_substream_t *subs,
  363. snd_pcm_runtime_t *runtime,
  364. struct urb *urb)
  365. {
  366. snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
  367. urb->dev = ctx->subs->dev; /* we need to set this at each time */
  368. urb->iso_frame_desc[0].length = 3;
  369. urb->iso_frame_desc[0].offset = 0;
  370. return 0;
  371. }
  372. /*
  373. * prepare urb for high speed playback sync pipe
  374. *
  375. * set up the offset and length to receive the current frequency.
  376. */
  377. static int prepare_playback_sync_urb_hs(snd_usb_substream_t *subs,
  378. snd_pcm_runtime_t *runtime,
  379. struct urb *urb)
  380. {
  381. snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
  382. urb->dev = ctx->subs->dev; /* we need to set this at each time */
  383. urb->iso_frame_desc[0].length = 4;
  384. urb->iso_frame_desc[0].offset = 0;
  385. return 0;
  386. }
  387. /*
  388. * process after full speed playback sync complete
  389. *
  390. * retrieve the current 10.14 frequency from pipe, and set it.
  391. * the value is referred in prepare_playback_urb().
  392. */
  393. static int retire_playback_sync_urb(snd_usb_substream_t *subs,
  394. snd_pcm_runtime_t *runtime,
  395. struct urb *urb)
  396. {
  397. unsigned int f;
  398. unsigned long flags;
  399. if (urb->iso_frame_desc[0].status == 0 &&
  400. urb->iso_frame_desc[0].actual_length == 3) {
  401. f = combine_triple((u8*)urb->transfer_buffer) << 2;
  402. #if 0
  403. if (f < subs->freqn - (subs->freqn>>3) || f > subs->freqmax) {
  404. snd_printd(KERN_WARNING "requested frequency %d (%u,%03uHz) out of range (current nominal %d (%u,%03uHz))\n",
  405. f, f >> 14, (f & ((1 << 14) - 1) * 1000) / ((1 << 14) - 1),
  406. subs->freqn, subs->freqn >> 14, (subs->freqn & ((1 << 14) - 1) * 1000) / ((1 << 14) - 1));
  407. continue;
  408. }
  409. #endif
  410. spin_lock_irqsave(&subs->lock, flags);
  411. subs->freqm = f;
  412. spin_unlock_irqrestore(&subs->lock, flags);
  413. }
  414. return 0;
  415. }
  416. /*
  417. * process after high speed playback sync complete
  418. *
  419. * retrieve the current 12.13 frequency from pipe, and set it.
  420. * the value is referred in prepare_playback_urb().
  421. */
  422. static int retire_playback_sync_urb_hs(snd_usb_substream_t *subs,
  423. snd_pcm_runtime_t *runtime,
  424. struct urb *urb)
  425. {
  426. unsigned int f;
  427. unsigned long flags;
  428. if (urb->iso_frame_desc[0].status == 0 &&
  429. urb->iso_frame_desc[0].actual_length == 4) {
  430. f = combine_quad((u8*)urb->transfer_buffer) & 0x0fffffff;
  431. spin_lock_irqsave(&subs->lock, flags);
  432. subs->freqm = f;
  433. spin_unlock_irqrestore(&subs->lock, flags);
  434. }
  435. return 0;
  436. }
  437. /*
  438. * prepare urb for playback data pipe
  439. *
  440. * we copy the data directly from the pcm buffer.
  441. * the current position to be copied is held in hwptr field.
  442. * since a urb can handle only a single linear buffer, if the total
  443. * transferred area overflows the buffer boundary, we cannot send
  444. * it directly from the buffer. thus the data is once copied to
  445. * a temporary buffer and urb points to that.
  446. */
  447. static int prepare_playback_urb(snd_usb_substream_t *subs,
  448. snd_pcm_runtime_t *runtime,
  449. struct urb *urb)
  450. {
  451. int i, stride, offs;
  452. unsigned int counts;
  453. unsigned long flags;
  454. snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
  455. stride = runtime->frame_bits >> 3;
  456. offs = 0;
  457. urb->dev = ctx->subs->dev; /* we need to set this at each time */
  458. urb->number_of_packets = 0;
  459. spin_lock_irqsave(&subs->lock, flags);
  460. for (i = 0; i < ctx->packets; i++) {
  461. /* calculate the size of a packet */
  462. if (subs->fill_max)
  463. counts = subs->maxframesize; /* fixed */
  464. else {
  465. subs->phase = (subs->phase & 0xffff) + subs->freqm;
  466. counts = subs->phase >> 16;
  467. if (counts > subs->maxframesize)
  468. counts = subs->maxframesize;
  469. }
  470. /* set up descriptor */
  471. urb->iso_frame_desc[i].offset = offs * stride;
  472. urb->iso_frame_desc[i].length = counts * stride;
  473. offs += counts;
  474. urb->number_of_packets++;
  475. subs->transfer_sched += counts;
  476. if (subs->transfer_sched >= runtime->period_size) {
  477. subs->transfer_sched -= runtime->period_size;
  478. if (subs->fmt_type == USB_FORMAT_TYPE_II) {
  479. if (subs->transfer_sched > 0) {
  480. /* FIXME: fill-max mode is not supported yet */
  481. offs -= subs->transfer_sched;
  482. counts -= subs->transfer_sched;
  483. urb->iso_frame_desc[i].length = counts * stride;
  484. subs->transfer_sched = 0;
  485. }
  486. i++;
  487. if (i < ctx->packets) {
  488. /* add a transfer delimiter */
  489. urb->iso_frame_desc[i].offset = offs * stride;
  490. urb->iso_frame_desc[i].length = 0;
  491. urb->number_of_packets++;
  492. }
  493. }
  494. break;
  495. }
  496. }
  497. if (subs->hwptr + offs > runtime->buffer_size) {
  498. /* err, the transferred area goes over buffer boundary.
  499. * copy the data to the temp buffer.
  500. */
  501. int len;
  502. len = runtime->buffer_size - subs->hwptr;
  503. urb->transfer_buffer = subs->tmpbuf;
  504. memcpy(subs->tmpbuf, runtime->dma_area + subs->hwptr * stride, len * stride);
  505. memcpy(subs->tmpbuf + len * stride, runtime->dma_area, (offs - len) * stride);
  506. subs->hwptr += offs;
  507. subs->hwptr -= runtime->buffer_size;
  508. } else {
  509. /* set the buffer pointer */
  510. urb->transfer_buffer = runtime->dma_area + subs->hwptr * stride;
  511. subs->hwptr += offs;
  512. }
  513. spin_unlock_irqrestore(&subs->lock, flags);
  514. urb->transfer_buffer_length = offs * stride;
  515. ctx->transfer = offs;
  516. return 0;
  517. }
  518. /*
  519. * process after playback data complete
  520. *
  521. * update the current position and call callback if a period is processed.
  522. */
  523. static int retire_playback_urb(snd_usb_substream_t *subs,
  524. snd_pcm_runtime_t *runtime,
  525. struct urb *urb)
  526. {
  527. unsigned long flags;
  528. snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
  529. spin_lock_irqsave(&subs->lock, flags);
  530. subs->transfer_done += ctx->transfer;
  531. subs->hwptr_done += ctx->transfer;
  532. ctx->transfer = 0;
  533. if (subs->hwptr_done >= runtime->buffer_size)
  534. subs->hwptr_done -= runtime->buffer_size;
  535. if (subs->transfer_done >= runtime->period_size) {
  536. subs->transfer_done -= runtime->period_size;
  537. spin_unlock_irqrestore(&subs->lock, flags);
  538. snd_pcm_period_elapsed(subs->pcm_substream);
  539. } else
  540. spin_unlock_irqrestore(&subs->lock, flags);
  541. return 0;
  542. }
  543. /*
  544. */
  545. static struct snd_urb_ops audio_urb_ops[2] = {
  546. {
  547. .prepare = prepare_playback_urb,
  548. .retire = retire_playback_urb,
  549. .prepare_sync = prepare_playback_sync_urb,
  550. .retire_sync = retire_playback_sync_urb,
  551. },
  552. {
  553. .prepare = prepare_capture_urb,
  554. .retire = retire_capture_urb,
  555. .prepare_sync = prepare_capture_sync_urb,
  556. .retire_sync = retire_capture_sync_urb,
  557. },
  558. };
  559. static struct snd_urb_ops audio_urb_ops_high_speed[2] = {
  560. {
  561. .prepare = prepare_playback_urb,
  562. .retire = retire_playback_urb,
  563. .prepare_sync = prepare_playback_sync_urb_hs,
  564. .retire_sync = retire_playback_sync_urb_hs,
  565. },
  566. {
  567. .prepare = prepare_capture_urb,
  568. .retire = retire_capture_urb,
  569. .prepare_sync = prepare_capture_sync_urb_hs,
  570. .retire_sync = retire_capture_sync_urb,
  571. },
  572. };
  573. /*
  574. * complete callback from data urb
  575. */
  576. static void snd_complete_urb(struct urb *urb, struct pt_regs *regs)
  577. {
  578. snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
  579. snd_usb_substream_t *subs = ctx->subs;
  580. snd_pcm_substream_t *substream = ctx->subs->pcm_substream;
  581. int err = 0;
  582. if ((subs->running && subs->ops.retire(subs, substream->runtime, urb)) ||
  583. ! subs->running || /* can be stopped during retire callback */
  584. (err = subs->ops.prepare(subs, substream->runtime, urb)) < 0 ||
  585. (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
  586. clear_bit(ctx->index, &subs->active_mask);
  587. if (err < 0) {
  588. snd_printd(KERN_ERR "cannot submit urb (err = %d)\n", err);
  589. snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
  590. }
  591. }
  592. }
  593. /*
  594. * complete callback from sync urb
  595. */
  596. static void snd_complete_sync_urb(struct urb *urb, struct pt_regs *regs)
  597. {
  598. snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
  599. snd_usb_substream_t *subs = ctx->subs;
  600. snd_pcm_substream_t *substream = ctx->subs->pcm_substream;
  601. int err = 0;
  602. if ((subs->running && subs->ops.retire_sync(subs, substream->runtime, urb)) ||
  603. ! subs->running || /* can be stopped during retire callback */
  604. (err = subs->ops.prepare_sync(subs, substream->runtime, urb)) < 0 ||
  605. (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
  606. clear_bit(ctx->index + 16, &subs->active_mask);
  607. if (err < 0) {
  608. snd_printd(KERN_ERR "cannot submit sync urb (err = %d)\n", err);
  609. snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
  610. }
  611. }
  612. }
  613. /*
  614. * unlink active urbs.
  615. */
  616. static int deactivate_urbs(snd_usb_substream_t *subs, int force, int can_sleep)
  617. {
  618. unsigned int i;
  619. int async;
  620. subs->running = 0;
  621. if (!force && subs->stream->chip->shutdown) /* to be sure... */
  622. return -EBADFD;
  623. async = !can_sleep && async_unlink;
  624. if (! async && in_interrupt())
  625. return 0;
  626. for (i = 0; i < subs->nurbs; i++) {
  627. if (test_bit(i, &subs->active_mask)) {
  628. if (! test_and_set_bit(i, &subs->unlink_mask)) {
  629. struct urb *u = subs->dataurb[i].urb;
  630. if (async) {
  631. u->transfer_flags |= URB_ASYNC_UNLINK;
  632. usb_unlink_urb(u);
  633. } else
  634. usb_kill_urb(u);
  635. }
  636. }
  637. }
  638. if (subs->syncpipe) {
  639. for (i = 0; i < SYNC_URBS; i++) {
  640. if (test_bit(i+16, &subs->active_mask)) {
  641. if (! test_and_set_bit(i+16, &subs->unlink_mask)) {
  642. struct urb *u = subs->syncurb[i].urb;
  643. if (async) {
  644. u->transfer_flags |= URB_ASYNC_UNLINK;
  645. usb_unlink_urb(u);
  646. } else
  647. usb_kill_urb(u);
  648. }
  649. }
  650. }
  651. }
  652. return 0;
  653. }
  654. /*
  655. * set up and start data/sync urbs
  656. */
  657. static int start_urbs(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime)
  658. {
  659. unsigned int i;
  660. int err;
  661. if (subs->stream->chip->shutdown)
  662. return -EBADFD;
  663. for (i = 0; i < subs->nurbs; i++) {
  664. snd_assert(subs->dataurb[i].urb, return -EINVAL);
  665. if (subs->ops.prepare(subs, runtime, subs->dataurb[i].urb) < 0) {
  666. snd_printk(KERN_ERR "cannot prepare datapipe for urb %d\n", i);
  667. goto __error;
  668. }
  669. }
  670. if (subs->syncpipe) {
  671. for (i = 0; i < SYNC_URBS; i++) {
  672. snd_assert(subs->syncurb[i].urb, return -EINVAL);
  673. if (subs->ops.prepare_sync(subs, runtime, subs->syncurb[i].urb) < 0) {
  674. snd_printk(KERN_ERR "cannot prepare syncpipe for urb %d\n", i);
  675. goto __error;
  676. }
  677. }
  678. }
  679. subs->active_mask = 0;
  680. subs->unlink_mask = 0;
  681. subs->running = 1;
  682. for (i = 0; i < subs->nurbs; i++) {
  683. if ((err = usb_submit_urb(subs->dataurb[i].urb, GFP_ATOMIC)) < 0) {
  684. snd_printk(KERN_ERR "cannot submit datapipe for urb %d, err = %d\n", i, err);
  685. goto __error;
  686. }
  687. set_bit(i, &subs->active_mask);
  688. }
  689. if (subs->syncpipe) {
  690. for (i = 0; i < SYNC_URBS; i++) {
  691. if ((err = usb_submit_urb(subs->syncurb[i].urb, GFP_ATOMIC)) < 0) {
  692. snd_printk(KERN_ERR "cannot submit syncpipe for urb %d, err = %d\n", i, err);
  693. goto __error;
  694. }
  695. set_bit(i + 16, &subs->active_mask);
  696. }
  697. }
  698. return 0;
  699. __error:
  700. // snd_pcm_stop(subs->pcm_substream, SNDRV_PCM_STATE_XRUN);
  701. deactivate_urbs(subs, 0, 0);
  702. return -EPIPE;
  703. }
  704. /*
  705. * wait until all urbs are processed.
  706. */
  707. static int wait_clear_urbs(snd_usb_substream_t *subs)
  708. {
  709. int timeout = HZ;
  710. unsigned int i;
  711. int alive;
  712. do {
  713. alive = 0;
  714. for (i = 0; i < subs->nurbs; i++) {
  715. if (test_bit(i, &subs->active_mask))
  716. alive++;
  717. }
  718. if (subs->syncpipe) {
  719. for (i = 0; i < SYNC_URBS; i++) {
  720. if (test_bit(i + 16, &subs->active_mask))
  721. alive++;
  722. }
  723. }
  724. if (! alive)
  725. break;
  726. set_current_state(TASK_UNINTERRUPTIBLE);
  727. schedule_timeout(1);
  728. } while (--timeout > 0);
  729. if (alive)
  730. snd_printk(KERN_ERR "timeout: still %d active urbs..\n", alive);
  731. return 0;
  732. }
  733. /*
  734. * return the current pcm pointer. just return the hwptr_done value.
  735. */
  736. static snd_pcm_uframes_t snd_usb_pcm_pointer(snd_pcm_substream_t *substream)
  737. {
  738. snd_usb_substream_t *subs = (snd_usb_substream_t *)substream->runtime->private_data;
  739. return subs->hwptr_done;
  740. }
  741. /*
  742. * start/stop substream
  743. */
  744. static int snd_usb_pcm_trigger(snd_pcm_substream_t *substream, int cmd)
  745. {
  746. snd_usb_substream_t *subs = (snd_usb_substream_t *)substream->runtime->private_data;
  747. int err;
  748. switch (cmd) {
  749. case SNDRV_PCM_TRIGGER_START:
  750. err = start_urbs(subs, substream->runtime);
  751. break;
  752. case SNDRV_PCM_TRIGGER_STOP:
  753. err = deactivate_urbs(subs, 0, 0);
  754. break;
  755. default:
  756. err = -EINVAL;
  757. break;
  758. }
  759. return err < 0 ? err : 0;
  760. }
  761. /*
  762. * release a urb data
  763. */
  764. static void release_urb_ctx(snd_urb_ctx_t *u)
  765. {
  766. if (u->urb) {
  767. usb_free_urb(u->urb);
  768. u->urb = NULL;
  769. }
  770. if (u->buf) {
  771. kfree(u->buf);
  772. u->buf = NULL;
  773. }
  774. }
  775. /*
  776. * release a substream
  777. */
  778. static void release_substream_urbs(snd_usb_substream_t *subs, int force)
  779. {
  780. int i;
  781. /* stop urbs (to be sure) */
  782. deactivate_urbs(subs, force, 1);
  783. wait_clear_urbs(subs);
  784. for (i = 0; i < MAX_URBS; i++)
  785. release_urb_ctx(&subs->dataurb[i]);
  786. for (i = 0; i < SYNC_URBS; i++)
  787. release_urb_ctx(&subs->syncurb[i]);
  788. if (subs->tmpbuf) {
  789. kfree(subs->tmpbuf);
  790. subs->tmpbuf = NULL;
  791. }
  792. subs->nurbs = 0;
  793. }
  794. /*
  795. * initialize a substream for plaback/capture
  796. */
  797. static int init_substream_urbs(snd_usb_substream_t *subs, unsigned int period_bytes,
  798. unsigned int rate, unsigned int frame_bits)
  799. {
  800. unsigned int maxsize, n, i;
  801. int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
  802. unsigned int npacks[MAX_URBS], urb_packs, total_packs;
  803. /* calculate the frequency in 16.16 format */
  804. if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
  805. subs->freqn = get_usb_full_speed_rate(rate);
  806. else
  807. subs->freqn = get_usb_high_speed_rate(rate);
  808. subs->freqm = subs->freqn;
  809. subs->freqmax = subs->freqn + (subs->freqn >> 2); /* max. allowed frequency */
  810. subs->phase = 0;
  811. /* calculate the max. size of packet */
  812. maxsize = ((subs->freqmax + 0xffff) * (frame_bits >> 3)) >> 16;
  813. if (subs->maxpacksize && maxsize > subs->maxpacksize) {
  814. //snd_printd(KERN_DEBUG "maxsize %d is greater than defined size %d\n",
  815. // maxsize, subs->maxpacksize);
  816. maxsize = subs->maxpacksize;
  817. }
  818. if (subs->fill_max)
  819. subs->curpacksize = subs->maxpacksize;
  820. else
  821. subs->curpacksize = maxsize;
  822. if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
  823. urb_packs = nrpacks;
  824. else
  825. urb_packs = nrpacks * 8;
  826. /* allocate a temporary buffer for playback */
  827. if (is_playback) {
  828. subs->tmpbuf = kmalloc(maxsize * urb_packs, GFP_KERNEL);
  829. if (! subs->tmpbuf) {
  830. snd_printk(KERN_ERR "cannot malloc tmpbuf\n");
  831. return -ENOMEM;
  832. }
  833. }
  834. /* decide how many packets to be used */
  835. total_packs = (period_bytes + maxsize - 1) / maxsize;
  836. if (total_packs < 2 * MIN_PACKS_URB)
  837. total_packs = 2 * MIN_PACKS_URB;
  838. subs->nurbs = (total_packs + urb_packs - 1) / urb_packs;
  839. if (subs->nurbs > MAX_URBS) {
  840. /* too much... */
  841. subs->nurbs = MAX_URBS;
  842. total_packs = MAX_URBS * urb_packs;
  843. }
  844. n = total_packs;
  845. for (i = 0; i < subs->nurbs; i++) {
  846. npacks[i] = n > urb_packs ? urb_packs : n;
  847. n -= urb_packs;
  848. }
  849. if (subs->nurbs <= 1) {
  850. /* too little - we need at least two packets
  851. * to ensure contiguous playback/capture
  852. */
  853. subs->nurbs = 2;
  854. npacks[0] = (total_packs + 1) / 2;
  855. npacks[1] = total_packs - npacks[0];
  856. } else if (npacks[subs->nurbs-1] < MIN_PACKS_URB) {
  857. /* the last packet is too small.. */
  858. if (subs->nurbs > 2) {
  859. /* merge to the first one */
  860. npacks[0] += npacks[subs->nurbs - 1];
  861. subs->nurbs--;
  862. } else {
  863. /* divide to two */
  864. subs->nurbs = 2;
  865. npacks[0] = (total_packs + 1) / 2;
  866. npacks[1] = total_packs - npacks[0];
  867. }
  868. }
  869. /* allocate and initialize data urbs */
  870. for (i = 0; i < subs->nurbs; i++) {
  871. snd_urb_ctx_t *u = &subs->dataurb[i];
  872. u->index = i;
  873. u->subs = subs;
  874. u->transfer = 0;
  875. u->packets = npacks[i];
  876. if (subs->fmt_type == USB_FORMAT_TYPE_II)
  877. u->packets++; /* for transfer delimiter */
  878. if (! is_playback) {
  879. /* allocate a capture buffer per urb */
  880. u->buf = kmalloc(maxsize * u->packets, GFP_KERNEL);
  881. if (! u->buf) {
  882. release_substream_urbs(subs, 0);
  883. return -ENOMEM;
  884. }
  885. }
  886. u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
  887. if (! u->urb) {
  888. release_substream_urbs(subs, 0);
  889. return -ENOMEM;
  890. }
  891. u->urb->dev = subs->dev;
  892. u->urb->pipe = subs->datapipe;
  893. u->urb->transfer_flags = URB_ISO_ASAP;
  894. u->urb->number_of_packets = u->packets;
  895. u->urb->interval = 1;
  896. u->urb->context = u;
  897. u->urb->complete = snd_usb_complete_callback(snd_complete_urb);
  898. }
  899. if (subs->syncpipe) {
  900. /* allocate and initialize sync urbs */
  901. for (i = 0; i < SYNC_URBS; i++) {
  902. snd_urb_ctx_t *u = &subs->syncurb[i];
  903. u->index = i;
  904. u->subs = subs;
  905. u->packets = 1;
  906. u->urb = usb_alloc_urb(1, GFP_KERNEL);
  907. if (! u->urb) {
  908. release_substream_urbs(subs, 0);
  909. return -ENOMEM;
  910. }
  911. u->urb->transfer_buffer = subs->syncbuf + i * 4;
  912. u->urb->transfer_buffer_length = 4;
  913. u->urb->dev = subs->dev;
  914. u->urb->pipe = subs->syncpipe;
  915. u->urb->transfer_flags = URB_ISO_ASAP;
  916. u->urb->number_of_packets = 1;
  917. u->urb->interval = 1 << subs->syncinterval;
  918. u->urb->context = u;
  919. u->urb->complete = snd_usb_complete_callback(snd_complete_sync_urb);
  920. }
  921. }
  922. return 0;
  923. }
  924. /*
  925. * find a matching audio format
  926. */
  927. static struct audioformat *find_format(snd_usb_substream_t *subs, unsigned int format,
  928. unsigned int rate, unsigned int channels)
  929. {
  930. struct list_head *p;
  931. struct audioformat *found = NULL;
  932. int cur_attr = 0, attr;
  933. list_for_each(p, &subs->fmt_list) {
  934. struct audioformat *fp;
  935. fp = list_entry(p, struct audioformat, list);
  936. if (fp->format != format || fp->channels != channels)
  937. continue;
  938. if (rate < fp->rate_min || rate > fp->rate_max)
  939. continue;
  940. if (! (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)) {
  941. unsigned int i;
  942. for (i = 0; i < fp->nr_rates; i++)
  943. if (fp->rate_table[i] == rate)
  944. break;
  945. if (i >= fp->nr_rates)
  946. continue;
  947. }
  948. attr = fp->ep_attr & EP_ATTR_MASK;
  949. if (! found) {
  950. found = fp;
  951. cur_attr = attr;
  952. continue;
  953. }
  954. /* avoid async out and adaptive in if the other method
  955. * supports the same format.
  956. * this is a workaround for the case like
  957. * M-audio audiophile USB.
  958. */
  959. if (attr != cur_attr) {
  960. if ((attr == EP_ATTR_ASYNC &&
  961. subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
  962. (attr == EP_ATTR_ADAPTIVE &&
  963. subs->direction == SNDRV_PCM_STREAM_CAPTURE))
  964. continue;
  965. if ((cur_attr == EP_ATTR_ASYNC &&
  966. subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
  967. (cur_attr == EP_ATTR_ADAPTIVE &&
  968. subs->direction == SNDRV_PCM_STREAM_CAPTURE)) {
  969. found = fp;
  970. cur_attr = attr;
  971. continue;
  972. }
  973. }
  974. /* find the format with the largest max. packet size */
  975. if (fp->maxpacksize > found->maxpacksize) {
  976. found = fp;
  977. cur_attr = attr;
  978. }
  979. }
  980. return found;
  981. }
  982. /*
  983. * initialize the picth control and sample rate
  984. */
  985. static int init_usb_pitch(struct usb_device *dev, int iface,
  986. struct usb_host_interface *alts,
  987. struct audioformat *fmt)
  988. {
  989. unsigned int ep;
  990. unsigned char data[1];
  991. int err;
  992. ep = get_endpoint(alts, 0)->bEndpointAddress;
  993. /* if endpoint has pitch control, enable it */
  994. if (fmt->attributes & EP_CS_ATTR_PITCH_CONTROL) {
  995. data[0] = 1;
  996. if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
  997. USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
  998. PITCH_CONTROL << 8, ep, data, 1, 1000)) < 0) {
  999. snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH\n",
  1000. dev->devnum, iface, ep);
  1001. return err;
  1002. }
  1003. }
  1004. return 0;
  1005. }
  1006. static int init_usb_sample_rate(struct usb_device *dev, int iface,
  1007. struct usb_host_interface *alts,
  1008. struct audioformat *fmt, int rate)
  1009. {
  1010. unsigned int ep;
  1011. unsigned char data[3];
  1012. int err;
  1013. ep = get_endpoint(alts, 0)->bEndpointAddress;
  1014. /* if endpoint has sampling rate control, set it */
  1015. if (fmt->attributes & EP_CS_ATTR_SAMPLE_RATE) {
  1016. int crate;
  1017. data[0] = rate;
  1018. data[1] = rate >> 8;
  1019. data[2] = rate >> 16;
  1020. if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
  1021. USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
  1022. SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
  1023. snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep 0x%x\n",
  1024. dev->devnum, iface, fmt->altsetting, rate, ep);
  1025. return err;
  1026. }
  1027. if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR,
  1028. USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
  1029. SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
  1030. snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep 0x%x\n",
  1031. dev->devnum, iface, fmt->altsetting, ep);
  1032. return 0; /* some devices don't support reading */
  1033. }
  1034. crate = data[0] | (data[1] << 8) | (data[2] << 16);
  1035. if (crate != rate) {
  1036. snd_printd(KERN_WARNING "current rate %d is different from the runtime rate %d\n", crate, rate);
  1037. // runtime->rate = crate;
  1038. }
  1039. }
  1040. return 0;
  1041. }
  1042. /*
  1043. * find a matching format and set up the interface
  1044. */
  1045. static int set_format(snd_usb_substream_t *subs, struct audioformat *fmt)
  1046. {
  1047. struct usb_device *dev = subs->dev;
  1048. struct usb_host_interface *alts;
  1049. struct usb_interface_descriptor *altsd;
  1050. struct usb_interface *iface;
  1051. unsigned int ep, attr;
  1052. int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
  1053. int err;
  1054. iface = usb_ifnum_to_if(dev, fmt->iface);
  1055. snd_assert(iface, return -EINVAL);
  1056. alts = &iface->altsetting[fmt->altset_idx];
  1057. altsd = get_iface_desc(alts);
  1058. snd_assert(altsd->bAlternateSetting == fmt->altsetting, return -EINVAL);
  1059. if (fmt == subs->cur_audiofmt)
  1060. return 0;
  1061. /* close the old interface */
  1062. if (subs->interface >= 0 && subs->interface != fmt->iface) {
  1063. usb_set_interface(subs->dev, subs->interface, 0);
  1064. subs->interface = -1;
  1065. subs->format = 0;
  1066. }
  1067. /* set interface */
  1068. if (subs->interface != fmt->iface || subs->format != fmt->altset_idx) {
  1069. if (usb_set_interface(dev, fmt->iface, fmt->altsetting) < 0) {
  1070. snd_printk(KERN_ERR "%d:%d:%d: usb_set_interface failed\n",
  1071. dev->devnum, fmt->iface, fmt->altsetting);
  1072. return -EIO;
  1073. }
  1074. snd_printdd(KERN_INFO "setting usb interface %d:%d\n", fmt->iface, fmt->altsetting);
  1075. subs->interface = fmt->iface;
  1076. subs->format = fmt->altset_idx;
  1077. }
  1078. /* create a data pipe */
  1079. ep = fmt->endpoint & USB_ENDPOINT_NUMBER_MASK;
  1080. if (is_playback)
  1081. subs->datapipe = usb_sndisocpipe(dev, ep);
  1082. else
  1083. subs->datapipe = usb_rcvisocpipe(dev, ep);
  1084. subs->syncpipe = subs->syncinterval = 0;
  1085. subs->maxpacksize = fmt->maxpacksize;
  1086. subs->fill_max = 0;
  1087. /* we need a sync pipe in async OUT or adaptive IN mode */
  1088. /* check the number of EP, since some devices have broken
  1089. * descriptors which fool us. if it has only one EP,
  1090. * assume it as adaptive-out or sync-in.
  1091. */
  1092. attr = fmt->ep_attr & EP_ATTR_MASK;
  1093. if (((is_playback && attr == EP_ATTR_ASYNC) ||
  1094. (! is_playback && attr == EP_ATTR_ADAPTIVE)) &&
  1095. altsd->bNumEndpoints >= 2) {
  1096. /* check sync-pipe endpoint */
  1097. /* ... and check descriptor size before accessing bSynchAddress
  1098. because there is a version of the SB Audigy 2 NX firmware lacking
  1099. the audio fields in the endpoint descriptors */
  1100. if ((get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 0x01 ||
  1101. (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
  1102. get_endpoint(alts, 1)->bSynchAddress != 0)) {
  1103. snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
  1104. dev->devnum, fmt->iface, fmt->altsetting);
  1105. return -EINVAL;
  1106. }
  1107. ep = get_endpoint(alts, 1)->bEndpointAddress;
  1108. if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
  1109. (( is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) ||
  1110. (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) {
  1111. snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
  1112. dev->devnum, fmt->iface, fmt->altsetting);
  1113. return -EINVAL;
  1114. }
  1115. ep &= USB_ENDPOINT_NUMBER_MASK;
  1116. if (is_playback)
  1117. subs->syncpipe = usb_rcvisocpipe(dev, ep);
  1118. else
  1119. subs->syncpipe = usb_sndisocpipe(dev, ep);
  1120. if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
  1121. get_endpoint(alts, 1)->bRefresh >= 1 &&
  1122. get_endpoint(alts, 1)->bRefresh <= 9)
  1123. subs->syncinterval = get_endpoint(alts, 1)->bRefresh;
  1124. else
  1125. subs->syncinterval = 1;
  1126. }
  1127. /* always fill max packet size */
  1128. if (fmt->attributes & EP_CS_ATTR_FILL_MAX)
  1129. subs->fill_max = 1;
  1130. if ((err = init_usb_pitch(dev, subs->interface, alts, fmt)) < 0)
  1131. return err;
  1132. subs->cur_audiofmt = fmt;
  1133. #if 0
  1134. printk("setting done: format = %d, rate = %d, channels = %d\n",
  1135. fmt->format, fmt->rate, fmt->channels);
  1136. printk(" datapipe = 0x%0x, syncpipe = 0x%0x\n",
  1137. subs->datapipe, subs->syncpipe);
  1138. #endif
  1139. return 0;
  1140. }
  1141. /*
  1142. * hw_params callback
  1143. *
  1144. * allocate a buffer and set the given audio format.
  1145. *
  1146. * so far we use a physically linear buffer although packetize transfer
  1147. * doesn't need a continuous area.
  1148. * if sg buffer is supported on the later version of alsa, we'll follow
  1149. * that.
  1150. */
  1151. static int snd_usb_hw_params(snd_pcm_substream_t *substream,
  1152. snd_pcm_hw_params_t *hw_params)
  1153. {
  1154. snd_usb_substream_t *subs = (snd_usb_substream_t *)substream->runtime->private_data;
  1155. struct audioformat *fmt;
  1156. unsigned int channels, rate, format;
  1157. int ret, changed;
  1158. ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
  1159. if (ret < 0)
  1160. return ret;
  1161. format = params_format(hw_params);
  1162. rate = params_rate(hw_params);
  1163. channels = params_channels(hw_params);
  1164. fmt = find_format(subs, format, rate, channels);
  1165. if (! fmt) {
  1166. snd_printd(KERN_DEBUG "cannot set format: format = %s, rate = %d, channels = %d\n",
  1167. snd_pcm_format_name(format), rate, channels);
  1168. return -EINVAL;
  1169. }
  1170. changed = subs->cur_audiofmt != fmt ||
  1171. subs->period_bytes != params_period_bytes(hw_params) ||
  1172. subs->cur_rate != rate;
  1173. if ((ret = set_format(subs, fmt)) < 0)
  1174. return ret;
  1175. if (subs->cur_rate != rate) {
  1176. struct usb_host_interface *alts;
  1177. struct usb_interface *iface;
  1178. iface = usb_ifnum_to_if(subs->dev, fmt->iface);
  1179. alts = &iface->altsetting[fmt->altset_idx];
  1180. ret = init_usb_sample_rate(subs->dev, subs->interface, alts, fmt, rate);
  1181. if (ret < 0)
  1182. return ret;
  1183. subs->cur_rate = rate;
  1184. }
  1185. if (changed) {
  1186. /* format changed */
  1187. release_substream_urbs(subs, 0);
  1188. /* influenced: period_bytes, channels, rate, format, */
  1189. ret = init_substream_urbs(subs, params_period_bytes(hw_params),
  1190. params_rate(hw_params),
  1191. snd_pcm_format_physical_width(params_format(hw_params)) * params_channels(hw_params));
  1192. }
  1193. return ret;
  1194. }
  1195. /*
  1196. * hw_free callback
  1197. *
  1198. * reset the audio format and release the buffer
  1199. */
  1200. static int snd_usb_hw_free(snd_pcm_substream_t *substream)
  1201. {
  1202. snd_usb_substream_t *subs = (snd_usb_substream_t *)substream->runtime->private_data;
  1203. subs->cur_audiofmt = NULL;
  1204. subs->cur_rate = 0;
  1205. subs->period_bytes = 0;
  1206. release_substream_urbs(subs, 0);
  1207. return snd_pcm_lib_free_pages(substream);
  1208. }
  1209. /*
  1210. * prepare callback
  1211. *
  1212. * only a few subtle things...
  1213. */
  1214. static int snd_usb_pcm_prepare(snd_pcm_substream_t *substream)
  1215. {
  1216. snd_pcm_runtime_t *runtime = substream->runtime;
  1217. snd_usb_substream_t *subs = (snd_usb_substream_t *)runtime->private_data;
  1218. if (! subs->cur_audiofmt) {
  1219. snd_printk(KERN_ERR "usbaudio: no format is specified!\n");
  1220. return -ENXIO;
  1221. }
  1222. /* some unit conversions in runtime */
  1223. subs->maxframesize = bytes_to_frames(runtime, subs->maxpacksize);
  1224. subs->curframesize = bytes_to_frames(runtime, subs->curpacksize);
  1225. /* reset the pointer */
  1226. subs->hwptr = 0;
  1227. subs->hwptr_done = 0;
  1228. subs->transfer_sched = 0;
  1229. subs->transfer_done = 0;
  1230. subs->phase = 0;
  1231. /* clear urbs (to be sure) */
  1232. deactivate_urbs(subs, 0, 1);
  1233. wait_clear_urbs(subs);
  1234. return 0;
  1235. }
  1236. static snd_pcm_hardware_t snd_usb_playback =
  1237. {
  1238. .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
  1239. SNDRV_PCM_INFO_BLOCK_TRANSFER |
  1240. SNDRV_PCM_INFO_MMAP_VALID),
  1241. .buffer_bytes_max = (128*1024),
  1242. .period_bytes_min = 64,
  1243. .period_bytes_max = (128*1024),
  1244. .periods_min = 2,
  1245. .periods_max = 1024,
  1246. };
  1247. static snd_pcm_hardware_t snd_usb_capture =
  1248. {
  1249. .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
  1250. SNDRV_PCM_INFO_BLOCK_TRANSFER |
  1251. SNDRV_PCM_INFO_MMAP_VALID),
  1252. .buffer_bytes_max = (128*1024),
  1253. .period_bytes_min = 64,
  1254. .period_bytes_max = (128*1024),
  1255. .periods_min = 2,
  1256. .periods_max = 1024,
  1257. };
  1258. /*
  1259. * h/w constraints
  1260. */
  1261. #ifdef HW_CONST_DEBUG
  1262. #define hwc_debug(fmt, args...) printk(KERN_DEBUG fmt, ##args)
  1263. #else
  1264. #define hwc_debug(fmt, args...) /**/
  1265. #endif
  1266. static int hw_check_valid_format(snd_pcm_hw_params_t *params, struct audioformat *fp)
  1267. {
  1268. snd_interval_t *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
  1269. snd_interval_t *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
  1270. snd_mask_t *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
  1271. /* check the format */
  1272. if (! snd_mask_test(fmts, fp->format)) {
  1273. hwc_debug(" > check: no supported format %d\n", fp->format);
  1274. return 0;
  1275. }
  1276. /* check the channels */
  1277. if (fp->channels < ct->min || fp->channels > ct->max) {
  1278. hwc_debug(" > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max);
  1279. return 0;
  1280. }
  1281. /* check the rate is within the range */
  1282. if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) {
  1283. hwc_debug(" > check: rate_min %d > max %d\n", fp->rate_min, it->max);
  1284. return 0;
  1285. }
  1286. if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) {
  1287. hwc_debug(" > check: rate_max %d < min %d\n", fp->rate_max, it->min);
  1288. return 0;
  1289. }
  1290. return 1;
  1291. }
  1292. static int hw_rule_rate(snd_pcm_hw_params_t *params,
  1293. snd_pcm_hw_rule_t *rule)
  1294. {
  1295. snd_usb_substream_t *subs = rule->private;
  1296. struct list_head *p;
  1297. snd_interval_t *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
  1298. unsigned int rmin, rmax;
  1299. int changed;
  1300. hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max);
  1301. changed = 0;
  1302. rmin = rmax = 0;
  1303. list_for_each(p, &subs->fmt_list) {
  1304. struct audioformat *fp;
  1305. fp = list_entry(p, struct audioformat, list);
  1306. if (! hw_check_valid_format(params, fp))
  1307. continue;
  1308. if (changed++) {
  1309. if (rmin > fp->rate_min)
  1310. rmin = fp->rate_min;
  1311. if (rmax < fp->rate_max)
  1312. rmax = fp->rate_max;
  1313. } else {
  1314. rmin = fp->rate_min;
  1315. rmax = fp->rate_max;
  1316. }
  1317. }
  1318. if (! changed) {
  1319. hwc_debug(" --> get empty\n");
  1320. it->empty = 1;
  1321. return -EINVAL;
  1322. }
  1323. changed = 0;
  1324. if (it->min < rmin) {
  1325. it->min = rmin;
  1326. it->openmin = 0;
  1327. changed = 1;
  1328. }
  1329. if (it->max > rmax) {
  1330. it->max = rmax;
  1331. it->openmax = 0;
  1332. changed = 1;
  1333. }
  1334. if (snd_interval_checkempty(it)) {
  1335. it->empty = 1;
  1336. return -EINVAL;
  1337. }
  1338. hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
  1339. return changed;
  1340. }
  1341. static int hw_rule_channels(snd_pcm_hw_params_t *params,
  1342. snd_pcm_hw_rule_t *rule)
  1343. {
  1344. snd_usb_substream_t *subs = rule->private;
  1345. struct list_head *p;
  1346. snd_interval_t *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
  1347. unsigned int rmin, rmax;
  1348. int changed;
  1349. hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max);
  1350. changed = 0;
  1351. rmin = rmax = 0;
  1352. list_for_each(p, &subs->fmt_list) {
  1353. struct audioformat *fp;
  1354. fp = list_entry(p, struct audioformat, list);
  1355. if (! hw_check_valid_format(params, fp))
  1356. continue;
  1357. if (changed++) {
  1358. if (rmin > fp->channels)
  1359. rmin = fp->channels;
  1360. if (rmax < fp->channels)
  1361. rmax = fp->channels;
  1362. } else {
  1363. rmin = fp->channels;
  1364. rmax = fp->channels;
  1365. }
  1366. }
  1367. if (! changed) {
  1368. hwc_debug(" --> get empty\n");
  1369. it->empty = 1;
  1370. return -EINVAL;
  1371. }
  1372. changed = 0;
  1373. if (it->min < rmin) {
  1374. it->min = rmin;
  1375. it->openmin = 0;
  1376. changed = 1;
  1377. }
  1378. if (it->max > rmax) {
  1379. it->max = rmax;
  1380. it->openmax = 0;
  1381. changed = 1;
  1382. }
  1383. if (snd_interval_checkempty(it)) {
  1384. it->empty = 1;
  1385. return -EINVAL;
  1386. }
  1387. hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
  1388. return changed;
  1389. }
  1390. static int hw_rule_format(snd_pcm_hw_params_t *params,
  1391. snd_pcm_hw_rule_t *rule)
  1392. {
  1393. snd_usb_substream_t *subs = rule->private;
  1394. struct list_head *p;
  1395. snd_mask_t *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
  1396. u64 fbits;
  1397. u32 oldbits[2];
  1398. int changed;
  1399. hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]);
  1400. fbits = 0;
  1401. list_for_each(p, &subs->fmt_list) {
  1402. struct audioformat *fp;
  1403. fp = list_entry(p, struct audioformat, list);
  1404. if (! hw_check_valid_format(params, fp))
  1405. continue;
  1406. fbits |= (1ULL << fp->format);
  1407. }
  1408. oldbits[0] = fmt->bits[0];
  1409. oldbits[1] = fmt->bits[1];
  1410. fmt->bits[0] &= (u32)fbits;
  1411. fmt->bits[1] &= (u32)(fbits >> 32);
  1412. if (! fmt->bits[0] && ! fmt->bits[1]) {
  1413. hwc_debug(" --> get empty\n");
  1414. return -EINVAL;
  1415. }
  1416. changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]);
  1417. hwc_debug(" --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed);
  1418. return changed;
  1419. }
  1420. #define MAX_MASK 64
  1421. /*
  1422. * check whether the registered audio formats need special hw-constraints
  1423. */
  1424. static int check_hw_params_convention(snd_usb_substream_t *subs)
  1425. {
  1426. int i;
  1427. u32 *channels;
  1428. u32 *rates;
  1429. u32 cmaster, rmaster;
  1430. u32 rate_min = 0, rate_max = 0;
  1431. struct list_head *p;
  1432. int err = 1;
  1433. channels = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL);
  1434. rates = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL);
  1435. list_for_each(p, &subs->fmt_list) {
  1436. struct audioformat *f;
  1437. f = list_entry(p, struct audioformat, list);
  1438. /* unconventional channels? */
  1439. if (f->channels > 32)
  1440. goto __out;
  1441. /* continuous rate min/max matches? */
  1442. if (f->rates & SNDRV_PCM_RATE_CONTINUOUS) {
  1443. if (rate_min && f->rate_min != rate_min)
  1444. goto __out;
  1445. if (rate_max && f->rate_max != rate_max)
  1446. goto __out;
  1447. rate_min = f->rate_min;
  1448. rate_max = f->rate_max;
  1449. }
  1450. /* combination of continuous rates and fixed rates? */
  1451. if (rates[f->format] & SNDRV_PCM_RATE_CONTINUOUS) {
  1452. if (f->rates != rates[f->format])
  1453. goto __out;
  1454. }
  1455. if (f->rates & SNDRV_PCM_RATE_CONTINUOUS) {
  1456. if (rates[f->format] && rates[f->format] != f->rates)
  1457. goto __out;
  1458. }
  1459. channels[f->format] |= (1 << f->channels);
  1460. rates[f->format] |= f->rates;
  1461. }
  1462. /* check whether channels and rates match for all formats */
  1463. cmaster = rmaster = 0;
  1464. for (i = 0; i < MAX_MASK; i++) {
  1465. if (cmaster != channels[i] && cmaster && channels[i])
  1466. goto __out;
  1467. if (rmaster != rates[i] && rmaster && rates[i])
  1468. goto __out;
  1469. if (channels[i])
  1470. cmaster = channels[i];
  1471. if (rates[i])
  1472. rmaster = rates[i];
  1473. }
  1474. /* check whether channels match for all distinct rates */
  1475. memset(channels, 0, MAX_MASK * sizeof(u32));
  1476. list_for_each(p, &subs->fmt_list) {
  1477. struct audioformat *f;
  1478. f = list_entry(p, struct audioformat, list);
  1479. if (f->rates & SNDRV_PCM_RATE_CONTINUOUS)
  1480. continue;
  1481. for (i = 0; i < 32; i++) {
  1482. if (f->rates & (1 << i))
  1483. channels[i] |= (1 << f->channels);
  1484. }
  1485. }
  1486. cmaster = 0;
  1487. for (i = 0; i < 32; i++) {
  1488. if (cmaster != channels[i] && cmaster && channels[i])
  1489. goto __out;
  1490. if (channels[i])
  1491. cmaster = channels[i];
  1492. }
  1493. err = 0;
  1494. __out:
  1495. kfree(channels);
  1496. kfree(rates);
  1497. return err;
  1498. }
  1499. /*
  1500. * set up the runtime hardware information.
  1501. */
  1502. static int setup_hw_info(snd_pcm_runtime_t *runtime, snd_usb_substream_t *subs)
  1503. {
  1504. struct list_head *p;
  1505. int err;
  1506. runtime->hw.formats = subs->formats;
  1507. runtime->hw.rate_min = 0x7fffffff;
  1508. runtime->hw.rate_max = 0;
  1509. runtime->hw.channels_min = 256;
  1510. runtime->hw.channels_max = 0;
  1511. runtime->hw.rates = 0;
  1512. /* check min/max rates and channels */
  1513. list_for_each(p, &subs->fmt_list) {
  1514. struct audioformat *fp;
  1515. fp = list_entry(p, struct audioformat, list);
  1516. runtime->hw.rates |= fp->rates;
  1517. if (runtime->hw.rate_min > fp->rate_min)
  1518. runtime->hw.rate_min = fp->rate_min;
  1519. if (runtime->hw.rate_max < fp->rate_max)
  1520. runtime->hw.rate_max = fp->rate_max;
  1521. if (runtime->hw.channels_min > fp->channels)
  1522. runtime->hw.channels_min = fp->channels;
  1523. if (runtime->hw.channels_max < fp->channels)
  1524. runtime->hw.channels_max = fp->channels;
  1525. if (fp->fmt_type == USB_FORMAT_TYPE_II && fp->frame_size > 0) {
  1526. /* FIXME: there might be more than one audio formats... */
  1527. runtime->hw.period_bytes_min = runtime->hw.period_bytes_max =
  1528. fp->frame_size;
  1529. }
  1530. }
  1531. /* set the period time minimum 1ms */
  1532. snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
  1533. 1000 * MIN_PACKS_URB,
  1534. /*(nrpacks * MAX_URBS) * 1000*/ UINT_MAX);
  1535. if (check_hw_params_convention(subs)) {
  1536. hwc_debug("setting extra hw constraints...\n");
  1537. if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
  1538. hw_rule_rate, subs,
  1539. SNDRV_PCM_HW_PARAM_FORMAT,
  1540. SNDRV_PCM_HW_PARAM_CHANNELS,
  1541. -1)) < 0)
  1542. return err;
  1543. if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
  1544. hw_rule_channels, subs,
  1545. SNDRV_PCM_HW_PARAM_FORMAT,
  1546. SNDRV_PCM_HW_PARAM_RATE,
  1547. -1)) < 0)
  1548. return err;
  1549. if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
  1550. hw_rule_format, subs,
  1551. SNDRV_PCM_HW_PARAM_RATE,
  1552. SNDRV_PCM_HW_PARAM_CHANNELS,
  1553. -1)) < 0)
  1554. return err;
  1555. }
  1556. return 0;
  1557. }
  1558. static int snd_usb_pcm_open(snd_pcm_substream_t *substream, int direction,
  1559. snd_pcm_hardware_t *hw)
  1560. {
  1561. snd_usb_stream_t *as = snd_pcm_substream_chip(substream);
  1562. snd_pcm_runtime_t *runtime = substream->runtime;
  1563. snd_usb_substream_t *subs = &as->substream[direction];
  1564. subs->interface = -1;
  1565. subs->format = 0;
  1566. runtime->hw = *hw;
  1567. runtime->private_data = subs;
  1568. subs->pcm_substream = substream;
  1569. return setup_hw_info(runtime, subs);
  1570. }
  1571. static int snd_usb_pcm_close(snd_pcm_substream_t *substream, int direction)
  1572. {
  1573. snd_usb_stream_t *as = snd_pcm_substream_chip(substream);
  1574. snd_usb_substream_t *subs = &as->substream[direction];
  1575. if (subs->interface >= 0) {
  1576. usb_set_interface(subs->dev, subs->interface, 0);
  1577. subs->interface = -1;
  1578. }
  1579. subs->pcm_substream = NULL;
  1580. return 0;
  1581. }
  1582. static int snd_usb_playback_open(snd_pcm_substream_t *substream)
  1583. {
  1584. return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_PLAYBACK, &snd_usb_playback);
  1585. }
  1586. static int snd_usb_playback_close(snd_pcm_substream_t *substream)
  1587. {
  1588. return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_PLAYBACK);
  1589. }
  1590. static int snd_usb_capture_open(snd_pcm_substream_t *substream)
  1591. {
  1592. return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_CAPTURE, &snd_usb_capture);
  1593. }
  1594. static int snd_usb_capture_close(snd_pcm_substream_t *substream)
  1595. {
  1596. return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_CAPTURE);
  1597. }
  1598. static snd_pcm_ops_t snd_usb_playback_ops = {
  1599. .open = snd_usb_playback_open,
  1600. .close = snd_usb_playback_close,
  1601. .ioctl = snd_pcm_lib_ioctl,
  1602. .hw_params = snd_usb_hw_params,
  1603. .hw_free = snd_usb_hw_free,
  1604. .prepare = snd_usb_pcm_prepare,
  1605. .trigger = snd_usb_pcm_trigger,
  1606. .pointer = snd_usb_pcm_pointer,
  1607. };
  1608. static snd_pcm_ops_t snd_usb_capture_ops = {
  1609. .open = snd_usb_capture_open,
  1610. .close = snd_usb_capture_close,
  1611. .ioctl = snd_pcm_lib_ioctl,
  1612. .hw_params = snd_usb_hw_params,
  1613. .hw_free = snd_usb_hw_free,
  1614. .prepare = snd_usb_pcm_prepare,
  1615. .trigger = snd_usb_pcm_trigger,
  1616. .pointer = snd_usb_pcm_pointer,
  1617. };
  1618. /*
  1619. * helper functions
  1620. */
  1621. /*
  1622. * combine bytes and get an integer value
  1623. */
  1624. unsigned int snd_usb_combine_bytes(unsigned char *bytes, int size)
  1625. {
  1626. switch (size) {
  1627. case 1: return *bytes;
  1628. case 2: return combine_word(bytes);
  1629. case 3: return combine_triple(bytes);
  1630. case 4: return combine_quad(bytes);
  1631. default: return 0;
  1632. }
  1633. }
  1634. /*
  1635. * parse descriptor buffer and return the pointer starting the given
  1636. * descriptor type.
  1637. */
  1638. void *snd_usb_find_desc(void *descstart, int desclen, void *after, u8 dtype)
  1639. {
  1640. u8 *p, *end, *next;
  1641. p = descstart;
  1642. end = p + desclen;
  1643. for (; p < end;) {
  1644. if (p[0] < 2)
  1645. return NULL;
  1646. next = p + p[0];
  1647. if (next > end)
  1648. return NULL;
  1649. if (p[1] == dtype && (!after || (void *)p > after)) {
  1650. return p;
  1651. }
  1652. p = next;
  1653. }
  1654. return NULL;
  1655. }
  1656. /*
  1657. * find a class-specified interface descriptor with the given subtype.
  1658. */
  1659. void *snd_usb_find_csint_desc(void *buffer, int buflen, void *after, u8 dsubtype)
  1660. {
  1661. unsigned char *p = after;
  1662. while ((p = snd_usb_find_desc(buffer, buflen, p,
  1663. USB_DT_CS_INTERFACE)) != NULL) {
  1664. if (p[0] >= 3 && p[2] == dsubtype)
  1665. return p;
  1666. }
  1667. return NULL;
  1668. }
  1669. /*
  1670. * Wrapper for usb_control_msg().
  1671. * Allocates a temp buffer to prevent dmaing from/to the stack.
  1672. */
  1673. int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
  1674. __u8 requesttype, __u16 value, __u16 index, void *data,
  1675. __u16 size, int timeout)
  1676. {
  1677. int err;
  1678. void *buf = NULL;
  1679. if (size > 0) {
  1680. buf = kmalloc(size, GFP_KERNEL);
  1681. if (!buf)
  1682. return -ENOMEM;
  1683. memcpy(buf, data, size);
  1684. }
  1685. err = usb_control_msg(dev, pipe, request, requesttype,
  1686. value, index, buf, size, timeout);
  1687. if (size > 0) {
  1688. memcpy(data, buf, size);
  1689. kfree(buf);
  1690. }
  1691. return err;
  1692. }
  1693. /*
  1694. * entry point for linux usb interface
  1695. */
  1696. static int usb_audio_probe(struct usb_interface *intf,
  1697. const struct usb_device_id *id);
  1698. static void usb_audio_disconnect(struct usb_interface *intf);
  1699. static struct usb_device_id usb_audio_ids [] = {
  1700. #include "usbquirks.h"
  1701. { .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS),
  1702. .bInterfaceClass = USB_CLASS_AUDIO,
  1703. .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL },
  1704. { } /* Terminating entry */
  1705. };
  1706. MODULE_DEVICE_TABLE (usb, usb_audio_ids);
  1707. static struct usb_driver usb_audio_driver = {
  1708. .owner = THIS_MODULE,
  1709. .name = "snd-usb-audio",
  1710. .probe = usb_audio_probe,
  1711. .disconnect = usb_audio_disconnect,
  1712. .id_table = usb_audio_ids,
  1713. };
  1714. /*
  1715. * proc interface for list the supported pcm formats
  1716. */
  1717. static void proc_dump_substream_formats(snd_usb_substream_t *subs, snd_info_buffer_t *buffer)
  1718. {
  1719. struct list_head *p;
  1720. static char *sync_types[4] = {
  1721. "NONE", "ASYNC", "ADAPTIVE", "SYNC"
  1722. };
  1723. list_for_each(p, &subs->fmt_list) {
  1724. struct audioformat *fp;
  1725. fp = list_entry(p, struct audioformat, list);
  1726. snd_iprintf(buffer, " Interface %d\n", fp->iface);
  1727. snd_iprintf(buffer, " Altset %d\n", fp->altsetting);
  1728. snd_iprintf(buffer, " Format: %s\n", snd_pcm_format_name(fp->format));
  1729. snd_iprintf(buffer, " Channels: %d\n", fp->channels);
  1730. snd_iprintf(buffer, " Endpoint: %d %s (%s)\n",
  1731. fp->endpoint & USB_ENDPOINT_NUMBER_MASK,
  1732. fp->endpoint & USB_DIR_IN ? "IN" : "OUT",
  1733. sync_types[(fp->ep_attr & EP_ATTR_MASK) >> 2]);
  1734. if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) {
  1735. snd_iprintf(buffer, " Rates: %d - %d (continuous)\n",
  1736. fp->rate_min, fp->rate_max);
  1737. } else {
  1738. unsigned int i;
  1739. snd_iprintf(buffer, " Rates: ");
  1740. for (i = 0; i < fp->nr_rates; i++) {
  1741. if (i > 0)
  1742. snd_iprintf(buffer, ", ");
  1743. snd_iprintf(buffer, "%d", fp->rate_table[i]);
  1744. }
  1745. snd_iprintf(buffer, "\n");
  1746. }
  1747. // snd_iprintf(buffer, " Max Packet Size = %d\n", fp->maxpacksize);
  1748. // snd_iprintf(buffer, " EP Attribute = 0x%x\n", fp->attributes);
  1749. }
  1750. }
  1751. static void proc_dump_substream_status(snd_usb_substream_t *subs, snd_info_buffer_t *buffer)
  1752. {
  1753. if (subs->running) {
  1754. unsigned int i;
  1755. snd_iprintf(buffer, " Status: Running\n");
  1756. snd_iprintf(buffer, " Interface = %d\n", subs->interface);
  1757. snd_iprintf(buffer, " Altset = %d\n", subs->format);
  1758. snd_iprintf(buffer, " URBs = %d [ ", subs->nurbs);
  1759. for (i = 0; i < subs->nurbs; i++)
  1760. snd_iprintf(buffer, "%d ", subs->dataurb[i].packets);
  1761. snd_iprintf(buffer, "]\n");
  1762. snd_iprintf(buffer, " Packet Size = %d\n", subs->curpacksize);
  1763. snd_iprintf(buffer, " Momentary freq = %u Hz (%#x.%04x)\n",
  1764. snd_usb_get_speed(subs->dev) == USB_SPEED_FULL
  1765. ? get_full_speed_hz(subs->freqm)
  1766. : get_high_speed_hz(subs->freqm),
  1767. subs->freqm >> 16, subs->freqm & 0xffff);
  1768. } else {
  1769. snd_iprintf(buffer, " Status: Stop\n");
  1770. }
  1771. }
  1772. static void proc_pcm_format_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
  1773. {
  1774. snd_usb_stream_t *stream = entry->private_data;
  1775. snd_iprintf(buffer, "%s : %s\n", stream->chip->card->longname, stream->pcm->name);
  1776. if (stream->substream[SNDRV_PCM_STREAM_PLAYBACK].num_formats) {
  1777. snd_iprintf(buffer, "\nPlayback:\n");
  1778. proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
  1779. proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
  1780. }
  1781. if (stream->substream[SNDRV_PCM_STREAM_CAPTURE].num_formats) {
  1782. snd_iprintf(buffer, "\nCapture:\n");
  1783. proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
  1784. proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
  1785. }
  1786. }
  1787. static void proc_pcm_format_add(snd_usb_stream_t *stream)
  1788. {
  1789. snd_info_entry_t *entry;
  1790. char name[32];
  1791. snd_card_t *card = stream->chip->card;
  1792. sprintf(name, "stream%d", stream->pcm_index);
  1793. if (! snd_card_proc_new(card, name, &entry))
  1794. snd_info_set_text_ops(entry, stream, 1024, proc_pcm_format_read);
  1795. }
  1796. /*
  1797. * initialize the substream instance.
  1798. */
  1799. static void init_substream(snd_usb_stream_t *as, int stream, struct audioformat *fp)
  1800. {
  1801. snd_usb_substream_t *subs = &as->substream[stream];
  1802. INIT_LIST_HEAD(&subs->fmt_list);
  1803. spin_lock_init(&subs->lock);
  1804. subs->stream = as;
  1805. subs->direction = stream;
  1806. subs->dev = as->chip->dev;
  1807. if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
  1808. subs->ops = audio_urb_ops[stream];
  1809. else
  1810. subs->ops = audio_urb_ops_high_speed[stream];
  1811. snd_pcm_lib_preallocate_pages(as->pcm->streams[stream].substream,
  1812. SNDRV_DMA_TYPE_CONTINUOUS,
  1813. snd_dma_continuous_data(GFP_KERNEL),
  1814. 64 * 1024, 128 * 1024);
  1815. snd_pcm_set_ops(as->pcm, stream,
  1816. stream == SNDRV_PCM_STREAM_PLAYBACK ?
  1817. &snd_usb_playback_ops : &snd_usb_capture_ops);
  1818. list_add_tail(&fp->list, &subs->fmt_list);
  1819. subs->formats |= 1ULL << fp->format;
  1820. subs->endpoint = fp->endpoint;
  1821. subs->num_formats++;
  1822. subs->fmt_type = fp->fmt_type;
  1823. }
  1824. /*
  1825. * free a substream
  1826. */
  1827. static void free_substream(snd_usb_substream_t *subs)
  1828. {
  1829. struct list_head *p, *n;
  1830. if (! subs->num_formats)
  1831. return; /* not initialized */
  1832. list_for_each_safe(p, n, &subs->fmt_list) {
  1833. struct audioformat *fp = list_entry(p, struct audioformat, list);
  1834. kfree(fp->rate_table);
  1835. kfree(fp);
  1836. }
  1837. }
  1838. /*
  1839. * free a usb stream instance
  1840. */
  1841. static void snd_usb_audio_stream_free(snd_usb_stream_t *stream)
  1842. {
  1843. free_substream(&stream->substream[0]);
  1844. free_substream(&stream->substream[1]);
  1845. list_del(&stream->list);
  1846. kfree(stream);
  1847. }
  1848. static void snd_usb_audio_pcm_free(snd_pcm_t *pcm)
  1849. {
  1850. snd_usb_stream_t *stream = pcm->private_data;
  1851. if (stream) {
  1852. stream->pcm = NULL;
  1853. snd_pcm_lib_preallocate_free_for_all(pcm);
  1854. snd_usb_audio_stream_free(stream);
  1855. }
  1856. }
  1857. /*
  1858. * add this endpoint to the chip instance.
  1859. * if a stream with the same endpoint already exists, append to it.
  1860. * if not, create a new pcm stream.
  1861. */
  1862. static int add_audio_endpoint(snd_usb_audio_t *chip, int stream, struct audioformat *fp)
  1863. {
  1864. struct list_head *p;
  1865. snd_usb_stream_t *as;
  1866. snd_usb_substream_t *subs;
  1867. snd_pcm_t *pcm;
  1868. int err;
  1869. list_for_each(p, &chip->pcm_list) {
  1870. as = list_entry(p, snd_usb_stream_t, list);
  1871. if (as->fmt_type != fp->fmt_type)
  1872. continue;
  1873. subs = &as->substream[stream];
  1874. if (! subs->endpoint)
  1875. continue;
  1876. if (subs->endpoint == fp->endpoint) {
  1877. list_add_tail(&fp->list, &subs->fmt_list);
  1878. subs->num_formats++;
  1879. subs->formats |= 1ULL << fp->format;
  1880. return 0;
  1881. }
  1882. }
  1883. /* look for an empty stream */
  1884. list_for_each(p, &chip->pcm_list) {
  1885. as = list_entry(p, snd_usb_stream_t, list);
  1886. if (as->fmt_type != fp->fmt_type)
  1887. continue;
  1888. subs = &as->substream[stream];
  1889. if (subs->endpoint)
  1890. continue;
  1891. err = snd_pcm_new_stream(as->pcm, stream, 1);
  1892. if (err < 0)
  1893. return err;
  1894. init_substream(as, stream, fp);
  1895. return 0;
  1896. }
  1897. /* create a new pcm */
  1898. as = kmalloc(sizeof(*as), GFP_KERNEL);
  1899. if (! as)
  1900. return -ENOMEM;
  1901. memset(as, 0, sizeof(*as));
  1902. as->pcm_index = chip->pcm_devs;
  1903. as->chip = chip;
  1904. as->fmt_type = fp->fmt_type;
  1905. err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs,
  1906. stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0,
  1907. stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1,
  1908. &pcm);
  1909. if (err < 0) {
  1910. kfree(as);
  1911. return err;
  1912. }
  1913. as->pcm = pcm;
  1914. pcm->private_data = as;
  1915. pcm->private_free = snd_usb_audio_pcm_free;
  1916. pcm->info_flags = 0;
  1917. if (chip->pcm_devs > 0)
  1918. sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs);
  1919. else
  1920. strcpy(pcm->name, "USB Audio");
  1921. init_substream(as, stream, fp);
  1922. list_add(&as->list, &chip->pcm_list);
  1923. chip->pcm_devs++;
  1924. proc_pcm_format_add(as);
  1925. return 0;
  1926. }
  1927. /*
  1928. * check if the device uses big-endian samples
  1929. */
  1930. static int is_big_endian_format(snd_usb_audio_t *chip, struct audioformat *fp)
  1931. {
  1932. switch (chip->usb_id) {
  1933. case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */
  1934. if (fp->endpoint & USB_DIR_IN)
  1935. return 1;
  1936. break;
  1937. case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
  1938. return 1;
  1939. }
  1940. return 0;
  1941. }
  1942. /*
  1943. * parse the audio format type I descriptor
  1944. * and returns the corresponding pcm format
  1945. *
  1946. * @dev: usb device
  1947. * @fp: audioformat record
  1948. * @format: the format tag (wFormatTag)
  1949. * @fmt: the format type descriptor
  1950. */
  1951. static int parse_audio_format_i_type(snd_usb_audio_t *chip, struct audioformat *fp,
  1952. int format, unsigned char *fmt)
  1953. {
  1954. int pcm_format;
  1955. int sample_width, sample_bytes;
  1956. /* FIXME: correct endianess and sign? */
  1957. pcm_format = -1;
  1958. sample_width = fmt[6];
  1959. sample_bytes = fmt[5];
  1960. switch (format) {
  1961. case 0: /* some devices don't define this correctly... */
  1962. snd_printdd(KERN_INFO "%d:%u:%d : format type 0 is detected, processed as PCM\n",
  1963. chip->dev->devnum, fp->iface, fp->altsetting);
  1964. /* fall-through */
  1965. case USB_AUDIO_FORMAT_PCM:
  1966. if (sample_width > sample_bytes * 8) {
  1967. snd_printk(KERN_INFO "%d:%u:%d : sample bitwidth %d in over sample bytes %d\n",
  1968. chip->dev->devnum, fp->iface, fp->altsetting,
  1969. sample_width, sample_bytes);
  1970. }
  1971. /* check the format byte size */
  1972. switch (fmt[5]) {
  1973. case 1:
  1974. pcm_format = SNDRV_PCM_FORMAT_S8;
  1975. break;
  1976. case 2:
  1977. if (is_big_endian_format(chip, fp))
  1978. pcm_format = SNDRV_PCM_FORMAT_S16_BE; /* grrr, big endian!! */
  1979. else
  1980. pcm_format = SNDRV_PCM_FORMAT_S16_LE;
  1981. break;
  1982. case 3:
  1983. if (is_big_endian_format(chip, fp))
  1984. pcm_format = SNDRV_PCM_FORMAT_S24_3BE; /* grrr, big endian!! */
  1985. else
  1986. pcm_format = SNDRV_PCM_FORMAT_S24_3LE;
  1987. break;
  1988. case 4:
  1989. pcm_format = SNDRV_PCM_FORMAT_S32_LE;
  1990. break;
  1991. default:
  1992. snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n",
  1993. chip->dev->devnum, fp->iface,
  1994. fp->altsetting, sample_width, sample_bytes);
  1995. break;
  1996. }
  1997. break;
  1998. case USB_AUDIO_FORMAT_PCM8:
  1999. /* Dallas DS4201 workaround */
  2000. if (chip->usb_id == USB_ID(0x04fa, 0x4201))
  2001. pcm_format = SNDRV_PCM_FORMAT_S8;
  2002. else
  2003. pcm_format = SNDRV_PCM_FORMAT_U8;
  2004. break;
  2005. case USB_AUDIO_FORMAT_IEEE_FLOAT:
  2006. pcm_format = SNDRV_PCM_FORMAT_FLOAT_LE;
  2007. break;
  2008. case USB_AUDIO_FORMAT_ALAW:
  2009. pcm_format = SNDRV_PCM_FORMAT_A_LAW;
  2010. break;
  2011. case USB_AUDIO_FORMAT_MU_LAW:
  2012. pcm_format = SNDRV_PCM_FORMAT_MU_LAW;
  2013. break;
  2014. default:
  2015. snd_printk(KERN_INFO "%d:%u:%d : unsupported format type %d\n",
  2016. chip->dev->devnum, fp->iface, fp->altsetting, format);
  2017. break;
  2018. }
  2019. return pcm_format;
  2020. }
  2021. /*
  2022. * parse the format descriptor and stores the possible sample rates
  2023. * on the audioformat table.
  2024. *
  2025. * @dev: usb device
  2026. * @fp: audioformat record
  2027. * @fmt: the format descriptor
  2028. * @offset: the start offset of descriptor pointing the rate type
  2029. * (7 for type I and II, 8 for type II)
  2030. */
  2031. static int parse_audio_format_rates(snd_usb_audio_t *chip, struct audioformat *fp,
  2032. unsigned char *fmt, int offset)
  2033. {
  2034. int nr_rates = fmt[offset];
  2035. if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) {
  2036. snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
  2037. chip->dev->devnum, fp->iface, fp->altsetting);
  2038. return -1;
  2039. }
  2040. if (nr_rates) {
  2041. /*
  2042. * build the rate table and bitmap flags
  2043. */
  2044. int r, idx, c;
  2045. /* this table corresponds to the SNDRV_PCM_RATE_XXX bit */
  2046. static unsigned int conv_rates[] = {
  2047. 5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000,
  2048. 64000, 88200, 96000, 176400, 192000
  2049. };
  2050. fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
  2051. if (fp->rate_table == NULL) {
  2052. snd_printk(KERN_ERR "cannot malloc\n");
  2053. return -1;
  2054. }
  2055. fp->nr_rates = nr_rates;
  2056. fp->rate_min = fp->rate_max = combine_triple(&fmt[8]);
  2057. for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) {
  2058. unsigned int rate = fp->rate_table[r] = combine_triple(&fmt[idx]);
  2059. if (rate < fp->rate_min)
  2060. fp->rate_min = rate;
  2061. else if (rate > fp->rate_max)
  2062. fp->rate_max = rate;
  2063. for (c = 0; c < (int)ARRAY_SIZE(conv_rates); c++) {
  2064. if (rate == conv_rates[c]) {
  2065. fp->rates |= (1 << c);
  2066. break;
  2067. }
  2068. }
  2069. }
  2070. } else {
  2071. /* continuous rates */
  2072. fp->rates = SNDRV_PCM_RATE_CONTINUOUS;
  2073. fp->rate_min = combine_triple(&fmt[offset + 1]);
  2074. fp->rate_max = combine_triple(&fmt[offset + 4]);
  2075. }
  2076. return 0;
  2077. }
  2078. /*
  2079. * parse the format type I and III descriptors
  2080. */
  2081. static int parse_audio_format_i(snd_usb_audio_t *chip, struct audioformat *fp,
  2082. int format, unsigned char *fmt)
  2083. {
  2084. int pcm_format;
  2085. if (fmt[3] == USB_FORMAT_TYPE_III) {
  2086. /* FIXME: the format type is really IECxxx
  2087. * but we give normal PCM format to get the existing
  2088. * apps working...
  2089. */
  2090. pcm_format = SNDRV_PCM_FORMAT_S16_LE;
  2091. } else {
  2092. pcm_format = parse_audio_format_i_type(chip, fp, format, fmt);
  2093. if (pcm_format < 0)
  2094. return -1;
  2095. }
  2096. fp->format = pcm_format;
  2097. fp->channels = fmt[4];
  2098. if (fp->channels < 1) {
  2099. snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n",
  2100. chip->dev->devnum, fp->iface, fp->altsetting, fp->channels);
  2101. return -1;
  2102. }
  2103. return parse_audio_format_rates(chip, fp, fmt, 7);
  2104. }
  2105. /*
  2106. * prase the format type II descriptor
  2107. */
  2108. static int parse_audio_format_ii(snd_usb_audio_t *chip, struct audioformat *fp,
  2109. int format, unsigned char *fmt)
  2110. {
  2111. int brate, framesize;
  2112. switch (format) {
  2113. case USB_AUDIO_FORMAT_AC3:
  2114. /* FIXME: there is no AC3 format defined yet */
  2115. // fp->format = SNDRV_PCM_FORMAT_AC3;
  2116. fp->format = SNDRV_PCM_FORMAT_U8; /* temporarily hack to receive byte streams */
  2117. break;
  2118. case USB_AUDIO_FORMAT_MPEG:
  2119. fp->format = SNDRV_PCM_FORMAT_MPEG;
  2120. break;
  2121. default:
  2122. snd_printd(KERN_INFO "%d:%u:%d : unknown format tag 0x%x is detected. processed as MPEG.\n",
  2123. chip->dev->devnum, fp->iface, fp->altsetting, format);
  2124. fp->format = SNDRV_PCM_FORMAT_MPEG;
  2125. break;
  2126. }
  2127. fp->channels = 1;
  2128. brate = combine_word(&fmt[4]); /* fmt[4,5] : wMaxBitRate (in kbps) */
  2129. framesize = combine_word(&fmt[6]); /* fmt[6,7]: wSamplesPerFrame */
  2130. snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
  2131. fp->frame_size = framesize;
  2132. return parse_audio_format_rates(chip, fp, fmt, 8); /* fmt[8..] sample rates */
  2133. }
  2134. static int parse_audio_format(snd_usb_audio_t *chip, struct audioformat *fp,
  2135. int format, unsigned char *fmt, int stream)
  2136. {
  2137. int err;
  2138. switch (fmt[3]) {
  2139. case USB_FORMAT_TYPE_I:
  2140. case USB_FORMAT_TYPE_III:
  2141. err = parse_audio_format_i(chip, fp, format, fmt);
  2142. break;
  2143. case USB_FORMAT_TYPE_II:
  2144. err = parse_audio_format_ii(chip, fp, format, fmt);
  2145. break;
  2146. default:
  2147. snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n",
  2148. chip->dev->devnum, fp->iface, fp->altsetting, fmt[3]);
  2149. return -1;
  2150. }
  2151. fp->fmt_type = fmt[3];
  2152. if (err < 0)
  2153. return err;
  2154. #if 1
  2155. /* FIXME: temporary hack for extigy/audigy 2 nx */
  2156. /* extigy apparently supports sample rates other than 48k
  2157. * but not in ordinary way. so we enable only 48k atm.
  2158. */
  2159. if (chip->usb_id == USB_ID(0x041e, 0x3000) ||
  2160. chip->usb_id == USB_ID(0x041e, 0x3020)) {
  2161. if (fmt[3] == USB_FORMAT_TYPE_I &&
  2162. stream == SNDRV_PCM_STREAM_PLAYBACK &&
  2163. fp->rates != SNDRV_PCM_RATE_48000 &&
  2164. fp->rates != SNDRV_PCM_RATE_96000)
  2165. return -1; /* use 48k only */
  2166. }
  2167. #endif
  2168. return 0;
  2169. }
  2170. static int parse_audio_endpoints(snd_usb_audio_t *chip, int iface_no)
  2171. {
  2172. struct usb_device *dev;
  2173. struct usb_interface *iface;
  2174. struct usb_host_interface *alts;
  2175. struct usb_interface_descriptor *altsd;
  2176. int i, altno, err, stream;
  2177. int format;
  2178. struct audioformat *fp;
  2179. unsigned char *fmt, *csep;
  2180. dev = chip->dev;
  2181. /* parse the interface's altsettings */
  2182. iface = usb_ifnum_to_if(dev, iface_no);
  2183. for (i = 0; i < iface->num_altsetting; i++) {
  2184. alts = &iface->altsetting[i];
  2185. altsd = get_iface_desc(alts);
  2186. /* skip invalid one */
  2187. if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
  2188. altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
  2189. (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING &&
  2190. altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC) ||
  2191. altsd->bNumEndpoints < 1 ||
  2192. le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0)
  2193. continue;
  2194. /* must be isochronous */
  2195. if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
  2196. USB_ENDPOINT_XFER_ISOC)
  2197. continue;
  2198. /* check direction */
  2199. stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ?
  2200. SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
  2201. altno = altsd->bAlternateSetting;
  2202. /* get audio formats */
  2203. fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, AS_GENERAL);
  2204. if (!fmt) {
  2205. snd_printk(KERN_ERR "%d:%u:%d : AS_GENERAL descriptor not found\n",
  2206. dev->devnum, iface_no, altno);
  2207. continue;
  2208. }
  2209. if (fmt[0] < 7) {
  2210. snd_printk(KERN_ERR "%d:%u:%d : invalid AS_GENERAL desc\n",
  2211. dev->devnum, iface_no, altno);
  2212. continue;
  2213. }
  2214. format = (fmt[6] << 8) | fmt[5]; /* remember the format value */
  2215. /* get format type */
  2216. fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, FORMAT_TYPE);
  2217. if (!fmt) {
  2218. snd_printk(KERN_ERR "%d:%u:%d : no FORMAT_TYPE desc\n",
  2219. dev->devnum, iface_no, altno);
  2220. continue;
  2221. }
  2222. if (fmt[0] < 8) {
  2223. snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
  2224. dev->devnum, iface_no, altno);
  2225. continue;
  2226. }
  2227. csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT);
  2228. /* Creamware Noah has this descriptor after the 2nd endpoint */
  2229. if (!csep && altsd->bNumEndpoints >= 2)
  2230. csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT);
  2231. if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) {
  2232. snd_printk(KERN_ERR "%d:%u:%d : no or invalid class specific endpoint descriptor\n",
  2233. dev->devnum, iface_no, altno);
  2234. continue;
  2235. }
  2236. fp = kmalloc(sizeof(*fp), GFP_KERNEL);
  2237. if (! fp) {
  2238. snd_printk(KERN_ERR "cannot malloc\n");
  2239. return -ENOMEM;
  2240. }
  2241. memset(fp, 0, sizeof(*fp));
  2242. fp->iface = iface_no;
  2243. fp->altsetting = altno;
  2244. fp->altset_idx = i;
  2245. fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
  2246. fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
  2247. /* FIXME: decode wMaxPacketSize of high bandwith endpoints */
  2248. fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
  2249. fp->attributes = csep[3];
  2250. /* some quirks for attributes here */
  2251. switch (chip->usb_id) {
  2252. case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */
  2253. /* Optoplay sets the sample rate attribute although
  2254. * it seems not supporting it in fact.
  2255. */
  2256. fp->attributes &= ~EP_CS_ATTR_SAMPLE_RATE;
  2257. break;
  2258. case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
  2259. case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
  2260. /* doesn't set the sample rate attribute, but supports it */
  2261. fp->attributes |= EP_CS_ATTR_SAMPLE_RATE;
  2262. break;
  2263. case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
  2264. case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
  2265. an older model 77d:223) */
  2266. /*
  2267. * plantronics headset and Griffin iMic have set adaptive-in
  2268. * although it's really not...
  2269. */
  2270. fp->ep_attr &= ~EP_ATTR_MASK;
  2271. if (stream == SNDRV_PCM_STREAM_PLAYBACK)
  2272. fp->ep_attr |= EP_ATTR_ADAPTIVE;
  2273. else
  2274. fp->ep_attr |= EP_ATTR_SYNC;
  2275. break;
  2276. }
  2277. /* ok, let's parse further... */
  2278. if (parse_audio_format(chip, fp, format, fmt, stream) < 0) {
  2279. kfree(fp->rate_table);
  2280. kfree(fp);
  2281. continue;
  2282. }
  2283. snd_printdd(KERN_INFO "%d:%u:%d: add audio endpoint 0x%x\n", dev->devnum, iface_no, i, fp->endpoint);
  2284. err = add_audio_endpoint(chip, stream, fp);
  2285. if (err < 0) {
  2286. kfree(fp->rate_table);
  2287. kfree(fp);
  2288. return err;
  2289. }
  2290. /* try to set the interface... */
  2291. usb_set_interface(chip->dev, iface_no, altno);
  2292. init_usb_pitch(chip->dev, iface_no, alts, fp);
  2293. init_usb_sample_rate(chip->dev, iface_no, alts, fp, fp->rate_max);
  2294. }
  2295. return 0;
  2296. }
  2297. /*
  2298. * disconnect streams
  2299. * called from snd_usb_audio_disconnect()
  2300. */
  2301. static void snd_usb_stream_disconnect(struct list_head *head)
  2302. {
  2303. int idx;
  2304. snd_usb_stream_t *as;
  2305. snd_usb_substream_t *subs;
  2306. as = list_entry(head, snd_usb_stream_t, list);
  2307. for (idx = 0; idx < 2; idx++) {
  2308. subs = &as->substream[idx];
  2309. if (!subs->num_formats)
  2310. return;
  2311. release_substream_urbs(subs, 1);
  2312. subs->interface = -1;
  2313. }
  2314. }
  2315. /*
  2316. * parse audio control descriptor and create pcm/midi streams
  2317. */
  2318. static int snd_usb_create_streams(snd_usb_audio_t *chip, int ctrlif)
  2319. {
  2320. struct usb_device *dev = chip->dev;
  2321. struct usb_host_interface *host_iface;
  2322. struct usb_interface *iface;
  2323. unsigned char *p1;
  2324. int i, j;
  2325. /* find audiocontrol interface */
  2326. host_iface = &usb_ifnum_to_if(dev, ctrlif)->altsetting[0];
  2327. if (!(p1 = snd_usb_find_csint_desc(host_iface->extra, host_iface->extralen, NULL, HEADER))) {
  2328. snd_printk(KERN_ERR "cannot find HEADER\n");
  2329. return -EINVAL;
  2330. }
  2331. if (! p1[7] || p1[0] < 8 + p1[7]) {
  2332. snd_printk(KERN_ERR "invalid HEADER\n");
  2333. return -EINVAL;
  2334. }
  2335. /*
  2336. * parse all USB audio streaming interfaces
  2337. */
  2338. for (i = 0; i < p1[7]; i++) {
  2339. struct usb_host_interface *alts;
  2340. struct usb_interface_descriptor *altsd;
  2341. j = p1[8 + i];
  2342. iface = usb_ifnum_to_if(dev, j);
  2343. if (!iface) {
  2344. snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
  2345. dev->devnum, ctrlif, j);
  2346. continue;
  2347. }
  2348. if (usb_interface_claimed(iface)) {
  2349. snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n", dev->devnum, ctrlif, j);
  2350. continue;
  2351. }
  2352. alts = &iface->altsetting[0];
  2353. altsd = get_iface_desc(alts);
  2354. if ((altsd->bInterfaceClass == USB_CLASS_AUDIO ||
  2355. altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) &&
  2356. altsd->bInterfaceSubClass == USB_SUBCLASS_MIDI_STREAMING) {
  2357. if (snd_usb_create_midi_interface(chip, iface, NULL) < 0) {
  2358. snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n", dev->devnum, ctrlif, j);
  2359. continue;
  2360. }
  2361. usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
  2362. continue;
  2363. }
  2364. if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
  2365. altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
  2366. altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING) {
  2367. snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n", dev->devnum, ctrlif, j, altsd->bInterfaceClass);
  2368. /* skip non-supported classes */
  2369. continue;
  2370. }
  2371. if (! parse_audio_endpoints(chip, j)) {
  2372. usb_set_interface(dev, j, 0); /* reset the current interface */
  2373. usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
  2374. }
  2375. }
  2376. return 0;
  2377. }
  2378. /*
  2379. * create a stream for an endpoint/altsetting without proper descriptors
  2380. */
  2381. static int create_fixed_stream_quirk(snd_usb_audio_t *chip,
  2382. struct usb_interface *iface,
  2383. const snd_usb_audio_quirk_t *quirk)
  2384. {
  2385. struct audioformat *fp;
  2386. struct usb_host_interface *alts;
  2387. int stream, err;
  2388. int *rate_table = NULL;
  2389. fp = kmalloc(sizeof(*fp), GFP_KERNEL);
  2390. if (! fp) {
  2391. snd_printk(KERN_ERR "cannot malloc\n");
  2392. return -ENOMEM;
  2393. }
  2394. memcpy(fp, quirk->data, sizeof(*fp));
  2395. if (fp->nr_rates > 0) {
  2396. rate_table = kmalloc(sizeof(int) * fp->nr_rates, GFP_KERNEL);
  2397. if (!rate_table) {
  2398. kfree(fp);
  2399. return -ENOMEM;
  2400. }
  2401. memcpy(rate_table, fp->rate_table, sizeof(int) * fp->nr_rates);
  2402. fp->rate_table = rate_table;
  2403. }
  2404. stream = (fp->endpoint & USB_DIR_IN)
  2405. ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
  2406. err = add_audio_endpoint(chip, stream, fp);
  2407. if (err < 0) {
  2408. kfree(fp);
  2409. kfree(rate_table);
  2410. return err;
  2411. }
  2412. if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber ||
  2413. fp->altset_idx >= iface->num_altsetting) {
  2414. kfree(fp);
  2415. kfree(rate_table);
  2416. return -EINVAL;
  2417. }
  2418. alts = &iface->altsetting[fp->altset_idx];
  2419. usb_set_interface(chip->dev, fp->iface, 0);
  2420. init_usb_pitch(chip->dev, fp->iface, alts, fp);
  2421. init_usb_sample_rate(chip->dev, fp->iface, alts, fp, fp->rate_max);
  2422. return 0;
  2423. }
  2424. /*
  2425. * create a stream for an interface with proper descriptors
  2426. */
  2427. static int create_standard_interface_quirk(snd_usb_audio_t *chip,
  2428. struct usb_interface *iface,
  2429. const snd_usb_audio_quirk_t *quirk)
  2430. {
  2431. struct usb_host_interface *alts;
  2432. struct usb_interface_descriptor *altsd;
  2433. int err;
  2434. alts = &iface->altsetting[0];
  2435. altsd = get_iface_desc(alts);
  2436. switch (quirk->type) {
  2437. case QUIRK_AUDIO_STANDARD_INTERFACE:
  2438. err = parse_audio_endpoints(chip, altsd->bInterfaceNumber);
  2439. if (!err)
  2440. usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0); /* reset the current interface */
  2441. break;
  2442. case QUIRK_MIDI_STANDARD_INTERFACE:
  2443. err = snd_usb_create_midi_interface(chip, iface, NULL);
  2444. break;
  2445. default:
  2446. snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type);
  2447. return -ENXIO;
  2448. }
  2449. if (err < 0) {
  2450. snd_printk(KERN_ERR "cannot setup if %d: error %d\n",
  2451. altsd->bInterfaceNumber, err);
  2452. return err;
  2453. }
  2454. return 0;
  2455. }
  2456. /*
  2457. * Create a stream for an Edirol UA-700/UA-25 interface. The only way
  2458. * to detect the sample rate is by looking at wMaxPacketSize.
  2459. */
  2460. static int create_ua700_ua25_quirk(snd_usb_audio_t *chip,
  2461. struct usb_interface *iface)
  2462. {
  2463. static const struct audioformat ua_format = {
  2464. .format = SNDRV_PCM_FORMAT_S24_3LE,
  2465. .channels = 2,
  2466. .fmt_type = USB_FORMAT_TYPE_I,
  2467. .altsetting = 1,
  2468. .altset_idx = 1,
  2469. .rates = SNDRV_PCM_RATE_CONTINUOUS,
  2470. };
  2471. struct usb_host_interface *alts;
  2472. struct usb_interface_descriptor *altsd;
  2473. struct audioformat *fp;
  2474. int stream, err;
  2475. /* both PCM and MIDI interfaces have 2 altsettings */
  2476. if (iface->num_altsetting != 2)
  2477. return -ENXIO;
  2478. alts = &iface->altsetting[1];
  2479. altsd = get_iface_desc(alts);
  2480. if (altsd->bNumEndpoints == 2) {
  2481. static const snd_usb_midi_endpoint_info_t ua700_ep = {
  2482. .out_cables = 0x0003,
  2483. .in_cables = 0x0003
  2484. };
  2485. static const snd_usb_audio_quirk_t ua700_quirk = {
  2486. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  2487. .data = &ua700_ep
  2488. };
  2489. static const snd_usb_midi_endpoint_info_t ua25_ep = {
  2490. .out_cables = 0x0001,
  2491. .in_cables = 0x0001
  2492. };
  2493. static const snd_usb_audio_quirk_t ua25_quirk = {
  2494. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  2495. .data = &ua25_ep
  2496. };
  2497. if (chip->usb_id == USB_ID(0x0582, 0x002b))
  2498. return snd_usb_create_midi_interface(chip, iface,
  2499. &ua700_quirk);
  2500. else
  2501. return snd_usb_create_midi_interface(chip, iface,
  2502. &ua25_quirk);
  2503. }
  2504. if (altsd->bNumEndpoints != 1)
  2505. return -ENXIO;
  2506. fp = kmalloc(sizeof(*fp), GFP_KERNEL);
  2507. if (!fp)
  2508. return -ENOMEM;
  2509. memcpy(fp, &ua_format, sizeof(*fp));
  2510. fp->iface = altsd->bInterfaceNumber;
  2511. fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
  2512. fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
  2513. fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
  2514. switch (fp->maxpacksize) {
  2515. case 0x120:
  2516. fp->rate_max = fp->rate_min = 44100;
  2517. break;
  2518. case 0x138:
  2519. case 0x140:
  2520. fp->rate_max = fp->rate_min = 48000;
  2521. break;
  2522. case 0x258:
  2523. case 0x260:
  2524. fp->rate_max = fp->rate_min = 96000;
  2525. break;
  2526. default:
  2527. snd_printk(KERN_ERR "unknown sample rate\n");
  2528. kfree(fp);
  2529. return -ENXIO;
  2530. }
  2531. stream = (fp->endpoint & USB_DIR_IN)
  2532. ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
  2533. err = add_audio_endpoint(chip, stream, fp);
  2534. if (err < 0) {
  2535. kfree(fp);
  2536. return err;
  2537. }
  2538. usb_set_interface(chip->dev, fp->iface, 0);
  2539. return 0;
  2540. }
  2541. /*
  2542. * Create a stream for an Edirol UA-1000 interface.
  2543. */
  2544. static int create_ua1000_quirk(snd_usb_audio_t *chip, struct usb_interface *iface)
  2545. {
  2546. static const struct audioformat ua1000_format = {
  2547. .format = SNDRV_PCM_FORMAT_S32_LE,
  2548. .fmt_type = USB_FORMAT_TYPE_I,
  2549. .altsetting = 1,
  2550. .altset_idx = 1,
  2551. .attributes = 0,
  2552. .rates = SNDRV_PCM_RATE_CONTINUOUS,
  2553. };
  2554. struct usb_host_interface *alts;
  2555. struct usb_interface_descriptor *altsd;
  2556. struct audioformat *fp;
  2557. int stream, err;
  2558. if (iface->num_altsetting != 2)
  2559. return -ENXIO;
  2560. alts = &iface->altsetting[1];
  2561. altsd = get_iface_desc(alts);
  2562. if (alts->extralen != 11 || alts->extra[1] != CS_AUDIO_INTERFACE ||
  2563. altsd->bNumEndpoints != 1)
  2564. return -ENXIO;
  2565. fp = kmalloc(sizeof(*fp), GFP_KERNEL);
  2566. if (!fp)
  2567. return -ENOMEM;
  2568. memcpy(fp, &ua1000_format, sizeof(*fp));
  2569. fp->channels = alts->extra[4];
  2570. fp->iface = altsd->bInterfaceNumber;
  2571. fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
  2572. fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
  2573. fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
  2574. fp->rate_max = fp->rate_min = combine_triple(&alts->extra[8]);
  2575. stream = (fp->endpoint & USB_DIR_IN)
  2576. ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
  2577. err = add_audio_endpoint(chip, stream, fp);
  2578. if (err < 0) {
  2579. kfree(fp);
  2580. return err;
  2581. }
  2582. /* FIXME: playback must be synchronized to capture */
  2583. usb_set_interface(chip->dev, fp->iface, 0);
  2584. return 0;
  2585. }
  2586. static int snd_usb_create_quirk(snd_usb_audio_t *chip,
  2587. struct usb_interface *iface,
  2588. const snd_usb_audio_quirk_t *quirk);
  2589. /*
  2590. * handle the quirks for the contained interfaces
  2591. */
  2592. static int create_composite_quirk(snd_usb_audio_t *chip,
  2593. struct usb_interface *iface,
  2594. const snd_usb_audio_quirk_t *quirk)
  2595. {
  2596. int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
  2597. int err;
  2598. for (quirk = quirk->data; quirk->ifnum >= 0; ++quirk) {
  2599. iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
  2600. if (!iface)
  2601. continue;
  2602. if (quirk->ifnum != probed_ifnum &&
  2603. usb_interface_claimed(iface))
  2604. continue;
  2605. err = snd_usb_create_quirk(chip, iface, quirk);
  2606. if (err < 0)
  2607. return err;
  2608. if (quirk->ifnum != probed_ifnum)
  2609. usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
  2610. }
  2611. return 0;
  2612. }
  2613. /*
  2614. * boot quirks
  2615. */
  2616. #define EXTIGY_FIRMWARE_SIZE_OLD 794
  2617. #define EXTIGY_FIRMWARE_SIZE_NEW 483
  2618. static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf)
  2619. {
  2620. struct usb_host_config *config = dev->actconfig;
  2621. int err;
  2622. if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD ||
  2623. le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) {
  2624. snd_printdd("sending Extigy boot sequence...\n");
  2625. /* Send message to force it to reconnect with full interface. */
  2626. err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0),
  2627. 0x10, 0x43, 0x0001, 0x000a, NULL, 0, 1000);
  2628. if (err < 0) snd_printdd("error sending boot message: %d\n", err);
  2629. err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
  2630. &dev->descriptor, sizeof(dev->descriptor));
  2631. config = dev->actconfig;
  2632. if (err < 0) snd_printdd("error usb_get_descriptor: %d\n", err);
  2633. err = usb_reset_configuration(dev);
  2634. if (err < 0) snd_printdd("error usb_reset_configuration: %d\n", err);
  2635. snd_printdd("extigy_boot: new boot length = %d\n",
  2636. le16_to_cpu(get_cfg_desc(config)->wTotalLength));
  2637. return -ENODEV; /* quit this anyway */
  2638. }
  2639. return 0;
  2640. }
  2641. static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev)
  2642. {
  2643. #if 0
  2644. /* TODO: enable this when high speed synchronization actually works */
  2645. u8 buf = 1;
  2646. snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a,
  2647. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
  2648. 0, 0, &buf, 1, 1000);
  2649. if (buf == 0) {
  2650. snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29,
  2651. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
  2652. 1, 2000, NULL, 0, 1000);
  2653. return -ENODEV;
  2654. }
  2655. #endif
  2656. return 0;
  2657. }
  2658. /*
  2659. * audio-interface quirks
  2660. *
  2661. * returns zero if no standard audio/MIDI parsing is needed.
  2662. * returns a postive value if standard audio/midi interfaces are parsed
  2663. * after this.
  2664. * returns a negative value at error.
  2665. */
  2666. static int snd_usb_create_quirk(snd_usb_audio_t *chip,
  2667. struct usb_interface *iface,
  2668. const snd_usb_audio_quirk_t *quirk)
  2669. {
  2670. switch (quirk->type) {
  2671. case QUIRK_MIDI_FIXED_ENDPOINT:
  2672. case QUIRK_MIDI_YAMAHA:
  2673. case QUIRK_MIDI_MIDIMAN:
  2674. case QUIRK_MIDI_NOVATION:
  2675. case QUIRK_MIDI_MOTU:
  2676. case QUIRK_MIDI_EMAGIC:
  2677. return snd_usb_create_midi_interface(chip, iface, quirk);
  2678. case QUIRK_COMPOSITE:
  2679. return create_composite_quirk(chip, iface, quirk);
  2680. case QUIRK_AUDIO_FIXED_ENDPOINT:
  2681. return create_fixed_stream_quirk(chip, iface, quirk);
  2682. case QUIRK_AUDIO_STANDARD_INTERFACE:
  2683. case QUIRK_MIDI_STANDARD_INTERFACE:
  2684. return create_standard_interface_quirk(chip, iface, quirk);
  2685. case QUIRK_AUDIO_EDIROL_UA700_UA25:
  2686. return create_ua700_ua25_quirk(chip, iface);
  2687. case QUIRK_AUDIO_EDIROL_UA1000:
  2688. return create_ua1000_quirk(chip, iface);
  2689. case QUIRK_IGNORE_INTERFACE:
  2690. return 0;
  2691. default:
  2692. snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type);
  2693. return -ENXIO;
  2694. }
  2695. }
  2696. /*
  2697. * common proc files to show the usb device info
  2698. */
  2699. static void proc_audio_usbbus_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
  2700. {
  2701. snd_usb_audio_t *chip = entry->private_data;
  2702. if (! chip->shutdown)
  2703. snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum);
  2704. }
  2705. static void proc_audio_usbid_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
  2706. {
  2707. snd_usb_audio_t *chip = entry->private_data;
  2708. if (! chip->shutdown)
  2709. snd_iprintf(buffer, "%04x:%04x\n",
  2710. USB_ID_VENDOR(chip->usb_id),
  2711. USB_ID_PRODUCT(chip->usb_id));
  2712. }
  2713. static void snd_usb_audio_create_proc(snd_usb_audio_t *chip)
  2714. {
  2715. snd_info_entry_t *entry;
  2716. if (! snd_card_proc_new(chip->card, "usbbus", &entry))
  2717. snd_info_set_text_ops(entry, chip, 1024, proc_audio_usbbus_read);
  2718. if (! snd_card_proc_new(chip->card, "usbid", &entry))
  2719. snd_info_set_text_ops(entry, chip, 1024, proc_audio_usbid_read);
  2720. }
  2721. /*
  2722. * free the chip instance
  2723. *
  2724. * here we have to do not much, since pcm and controls are already freed
  2725. *
  2726. */
  2727. static int snd_usb_audio_free(snd_usb_audio_t *chip)
  2728. {
  2729. kfree(chip);
  2730. return 0;
  2731. }
  2732. static int snd_usb_audio_dev_free(snd_device_t *device)
  2733. {
  2734. snd_usb_audio_t *chip = device->device_data;
  2735. return snd_usb_audio_free(chip);
  2736. }
  2737. /*
  2738. * create a chip instance and set its names.
  2739. */
  2740. static int snd_usb_audio_create(struct usb_device *dev, int idx,
  2741. const snd_usb_audio_quirk_t *quirk,
  2742. snd_usb_audio_t **rchip)
  2743. {
  2744. snd_card_t *card;
  2745. snd_usb_audio_t *chip;
  2746. int err, len;
  2747. char component[14];
  2748. static snd_device_ops_t ops = {
  2749. .dev_free = snd_usb_audio_dev_free,
  2750. };
  2751. *rchip = NULL;
  2752. if (snd_usb_get_speed(dev) != USB_SPEED_FULL &&
  2753. snd_usb_get_speed(dev) != USB_SPEED_HIGH) {
  2754. snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev));
  2755. return -ENXIO;
  2756. }
  2757. card = snd_card_new(index[idx], id[idx], THIS_MODULE, 0);
  2758. if (card == NULL) {
  2759. snd_printk(KERN_ERR "cannot create card instance %d\n", idx);
  2760. return -ENOMEM;
  2761. }
  2762. chip = kcalloc(1, sizeof(*chip), GFP_KERNEL);
  2763. if (! chip) {
  2764. snd_card_free(card);
  2765. return -ENOMEM;
  2766. }
  2767. chip->index = idx;
  2768. chip->dev = dev;
  2769. chip->card = card;
  2770. chip->usb_id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
  2771. le16_to_cpu(dev->descriptor.idProduct));
  2772. INIT_LIST_HEAD(&chip->pcm_list);
  2773. INIT_LIST_HEAD(&chip->midi_list);
  2774. INIT_LIST_HEAD(&chip->mixer_list);
  2775. if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
  2776. snd_usb_audio_free(chip);
  2777. snd_card_free(card);
  2778. return err;
  2779. }
  2780. strcpy(card->driver, "USB-Audio");
  2781. sprintf(component, "USB%04x:%04x",
  2782. USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id));
  2783. snd_component_add(card, component);
  2784. /* retrieve the device string as shortname */
  2785. if (quirk && quirk->product_name) {
  2786. strlcpy(card->shortname, quirk->product_name, sizeof(card->shortname));
  2787. } else {
  2788. if (!dev->descriptor.iProduct ||
  2789. usb_string(dev, dev->descriptor.iProduct,
  2790. card->shortname, sizeof(card->shortname)) <= 0) {
  2791. /* no name available from anywhere, so use ID */
  2792. sprintf(card->shortname, "USB Device %#04x:%#04x",
  2793. USB_ID_VENDOR(chip->usb_id),
  2794. USB_ID_PRODUCT(chip->usb_id));
  2795. }
  2796. }
  2797. /* retrieve the vendor and device strings as longname */
  2798. if (quirk && quirk->vendor_name) {
  2799. len = strlcpy(card->longname, quirk->vendor_name, sizeof(card->longname));
  2800. } else {
  2801. if (dev->descriptor.iManufacturer)
  2802. len = usb_string(dev, dev->descriptor.iManufacturer,
  2803. card->longname, sizeof(card->longname));
  2804. else
  2805. len = 0;
  2806. /* we don't really care if there isn't any vendor string */
  2807. }
  2808. if (len > 0)
  2809. strlcat(card->longname, " ", sizeof(card->longname));
  2810. strlcat(card->longname, card->shortname, sizeof(card->longname));
  2811. len = strlcat(card->longname, " at ", sizeof(card->longname));
  2812. if (len < sizeof(card->longname))
  2813. usb_make_path(dev, card->longname + len, sizeof(card->longname) - len);
  2814. strlcat(card->longname,
  2815. snd_usb_get_speed(dev) == USB_SPEED_FULL ? ", full speed" : ", high speed",
  2816. sizeof(card->longname));
  2817. snd_usb_audio_create_proc(chip);
  2818. *rchip = chip;
  2819. return 0;
  2820. }
  2821. /*
  2822. * probe the active usb device
  2823. *
  2824. * note that this can be called multiple times per a device, when it
  2825. * includes multiple audio control interfaces.
  2826. *
  2827. * thus we check the usb device pointer and creates the card instance
  2828. * only at the first time. the successive calls of this function will
  2829. * append the pcm interface to the corresponding card.
  2830. */
  2831. static void *snd_usb_audio_probe(struct usb_device *dev,
  2832. struct usb_interface *intf,
  2833. const struct usb_device_id *usb_id)
  2834. {
  2835. struct usb_host_config *config = dev->actconfig;
  2836. const snd_usb_audio_quirk_t *quirk = (const snd_usb_audio_quirk_t *)usb_id->driver_info;
  2837. int i, err;
  2838. snd_usb_audio_t *chip;
  2839. struct usb_host_interface *alts;
  2840. int ifnum;
  2841. u32 id;
  2842. alts = &intf->altsetting[0];
  2843. ifnum = get_iface_desc(alts)->bInterfaceNumber;
  2844. id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
  2845. le16_to_cpu(dev->descriptor.idProduct));
  2846. if (quirk && quirk->ifnum >= 0 && ifnum != quirk->ifnum)
  2847. goto __err_val;
  2848. /* SB Extigy needs special boot-up sequence */
  2849. /* if more models come, this will go to the quirk list. */
  2850. if (id == USB_ID(0x041e, 0x3000)) {
  2851. if (snd_usb_extigy_boot_quirk(dev, intf) < 0)
  2852. goto __err_val;
  2853. config = dev->actconfig;
  2854. }
  2855. /* SB Audigy 2 NX needs its own boot-up magic, too */
  2856. if (id == USB_ID(0x041e, 0x3020)) {
  2857. if (snd_usb_audigy2nx_boot_quirk(dev) < 0)
  2858. goto __err_val;
  2859. }
  2860. /*
  2861. * found a config. now register to ALSA
  2862. */
  2863. /* check whether it's already registered */
  2864. chip = NULL;
  2865. down(&register_mutex);
  2866. for (i = 0; i < SNDRV_CARDS; i++) {
  2867. if (usb_chip[i] && usb_chip[i]->dev == dev) {
  2868. if (usb_chip[i]->shutdown) {
  2869. snd_printk(KERN_ERR "USB device is in the shutdown state, cannot create a card instance\n");
  2870. goto __error;
  2871. }
  2872. chip = usb_chip[i];
  2873. break;
  2874. }
  2875. }
  2876. if (! chip) {
  2877. /* it's a fresh one.
  2878. * now look for an empty slot and create a new card instance
  2879. */
  2880. /* first, set the current configuration for this device */
  2881. if (usb_reset_configuration(dev) < 0) {
  2882. snd_printk(KERN_ERR "cannot reset configuration (value 0x%x)\n", get_cfg_desc(config)->bConfigurationValue);
  2883. goto __error;
  2884. }
  2885. for (i = 0; i < SNDRV_CARDS; i++)
  2886. if (enable[i] && ! usb_chip[i] &&
  2887. (vid[i] == -1 || vid[i] == USB_ID_VENDOR(id)) &&
  2888. (pid[i] == -1 || pid[i] == USB_ID_PRODUCT(id))) {
  2889. if (snd_usb_audio_create(dev, i, quirk, &chip) < 0) {
  2890. goto __error;
  2891. }
  2892. snd_card_set_dev(chip->card, &intf->dev);
  2893. break;
  2894. }
  2895. if (! chip) {
  2896. snd_printk(KERN_ERR "no available usb audio device\n");
  2897. goto __error;
  2898. }
  2899. }
  2900. err = 1; /* continue */
  2901. if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) {
  2902. /* need some special handlings */
  2903. if ((err = snd_usb_create_quirk(chip, intf, quirk)) < 0)
  2904. goto __error;
  2905. }
  2906. if (err > 0) {
  2907. /* create normal USB audio interfaces */
  2908. if (snd_usb_create_streams(chip, ifnum) < 0 ||
  2909. snd_usb_create_mixer(chip, ifnum) < 0) {
  2910. goto __error;
  2911. }
  2912. }
  2913. /* we are allowed to call snd_card_register() many times */
  2914. if (snd_card_register(chip->card) < 0) {
  2915. goto __error;
  2916. }
  2917. usb_chip[chip->index] = chip;
  2918. chip->num_interfaces++;
  2919. up(&register_mutex);
  2920. return chip;
  2921. __error:
  2922. if (chip && !chip->num_interfaces)
  2923. snd_card_free(chip->card);
  2924. up(&register_mutex);
  2925. __err_val:
  2926. return NULL;
  2927. }
  2928. /*
  2929. * we need to take care of counter, since disconnection can be called also
  2930. * many times as well as usb_audio_probe().
  2931. */
  2932. static void snd_usb_audio_disconnect(struct usb_device *dev, void *ptr)
  2933. {
  2934. snd_usb_audio_t *chip;
  2935. snd_card_t *card;
  2936. struct list_head *p;
  2937. if (ptr == (void *)-1L)
  2938. return;
  2939. chip = ptr;
  2940. card = chip->card;
  2941. down(&register_mutex);
  2942. chip->shutdown = 1;
  2943. chip->num_interfaces--;
  2944. if (chip->num_interfaces <= 0) {
  2945. snd_card_disconnect(card);
  2946. /* release the pcm resources */
  2947. list_for_each(p, &chip->pcm_list) {
  2948. snd_usb_stream_disconnect(p);
  2949. }
  2950. /* release the midi resources */
  2951. list_for_each(p, &chip->midi_list) {
  2952. snd_usbmidi_disconnect(p);
  2953. }
  2954. /* release mixer resources */
  2955. list_for_each(p, &chip->mixer_list) {
  2956. snd_usb_mixer_disconnect(p);
  2957. }
  2958. usb_chip[chip->index] = NULL;
  2959. up(&register_mutex);
  2960. snd_card_free(card);
  2961. } else {
  2962. up(&register_mutex);
  2963. }
  2964. }
  2965. /*
  2966. * new 2.5 USB kernel API
  2967. */
  2968. static int usb_audio_probe(struct usb_interface *intf,
  2969. const struct usb_device_id *id)
  2970. {
  2971. void *chip;
  2972. chip = snd_usb_audio_probe(interface_to_usbdev(intf), intf, id);
  2973. if (chip) {
  2974. dev_set_drvdata(&intf->dev, chip);
  2975. return 0;
  2976. } else
  2977. return -EIO;
  2978. }
  2979. static void usb_audio_disconnect(struct usb_interface *intf)
  2980. {
  2981. snd_usb_audio_disconnect(interface_to_usbdev(intf),
  2982. dev_get_drvdata(&intf->dev));
  2983. }
  2984. static int __init snd_usb_audio_init(void)
  2985. {
  2986. if (nrpacks < MIN_PACKS_URB || nrpacks > MAX_PACKS) {
  2987. printk(KERN_WARNING "invalid nrpacks value.\n");
  2988. return -EINVAL;
  2989. }
  2990. usb_register(&usb_audio_driver);
  2991. return 0;
  2992. }
  2993. static void __exit snd_usb_audio_cleanup(void)
  2994. {
  2995. usb_deregister(&usb_audio_driver);
  2996. }
  2997. module_init(snd_usb_audio_init);
  2998. module_exit(snd_usb_audio_cleanup);