msnd_pinnacle.c 47 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921
  1. /*********************************************************************
  2. *
  3. * Turtle Beach MultiSound Sound Card Driver for Linux
  4. * Linux 2.0/2.2 Version
  5. *
  6. * msnd_pinnacle.c / msnd_classic.c
  7. *
  8. * -- If MSND_CLASSIC is defined:
  9. *
  10. * -> driver for Turtle Beach Classic/Monterey/Tahiti
  11. *
  12. * -- Else
  13. *
  14. * -> driver for Turtle Beach Pinnacle/Fiji
  15. *
  16. * Copyright (C) 1998 Andrew Veliath
  17. *
  18. * This program is free software; you can redistribute it and/or modify
  19. * it under the terms of the GNU General Public License as published by
  20. * the Free Software Foundation; either version 2 of the License, or
  21. * (at your option) any later version.
  22. *
  23. * This program is distributed in the hope that it will be useful,
  24. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  26. * GNU General Public License for more details.
  27. *
  28. * You should have received a copy of the GNU General Public License
  29. * along with this program; if not, write to the Free Software
  30. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31. *
  32. * $Id: msnd_pinnacle.c,v 1.1.1.1 2007/06/12 07:27:11 eyryu Exp $
  33. *
  34. * 12-3-2000 Modified IO port validation Steve Sycamore
  35. *
  36. *
  37. * $$$: msnd_pinnacle.c,v 1.75 1999/03/21 16:50:09 andrewtv $$$ $
  38. *
  39. ********************************************************************/
  40. #include <linux/kernel.h>
  41. #include <linux/module.h>
  42. #include <linux/slab.h>
  43. #include <linux/types.h>
  44. #include <linux/delay.h>
  45. #include <linux/init.h>
  46. #include <linux/interrupt.h>
  47. #include <linux/smp_lock.h>
  48. #include <asm/irq.h>
  49. #include <asm/io.h>
  50. #include "sound_config.h"
  51. #include "sound_firmware.h"
  52. #ifdef MSND_CLASSIC
  53. # ifndef __alpha__
  54. # define SLOWIO
  55. # endif
  56. #endif
  57. #include "msnd.h"
  58. #ifdef MSND_CLASSIC
  59. # ifdef CONFIG_MSNDCLAS_HAVE_BOOT
  60. # define HAVE_DSPCODEH
  61. # endif
  62. # include "msnd_classic.h"
  63. # define LOGNAME "msnd_classic"
  64. #else
  65. # ifdef CONFIG_MSNDPIN_HAVE_BOOT
  66. # define HAVE_DSPCODEH
  67. # endif
  68. # include "msnd_pinnacle.h"
  69. # define LOGNAME "msnd_pinnacle"
  70. #endif
  71. #ifndef CONFIG_MSND_WRITE_NDELAY
  72. # define CONFIG_MSND_WRITE_NDELAY 1
  73. #endif
  74. #define get_play_delay_jiffies(size) ((size) * HZ * \
  75. dev.play_sample_size / 8 / \
  76. dev.play_sample_rate / \
  77. dev.play_channels)
  78. #define get_rec_delay_jiffies(size) ((size) * HZ * \
  79. dev.rec_sample_size / 8 / \
  80. dev.rec_sample_rate / \
  81. dev.rec_channels)
  82. static multisound_dev_t dev;
  83. #ifndef HAVE_DSPCODEH
  84. static char *dspini, *permini;
  85. static int sizeof_dspini, sizeof_permini;
  86. #endif
  87. static int dsp_full_reset(void);
  88. static void dsp_write_flush(void);
  89. static __inline__ int chk_send_dsp_cmd(multisound_dev_t *dev, register BYTE cmd)
  90. {
  91. if (msnd_send_dsp_cmd(dev, cmd) == 0)
  92. return 0;
  93. dsp_full_reset();
  94. return msnd_send_dsp_cmd(dev, cmd);
  95. }
  96. static void reset_play_queue(void)
  97. {
  98. int n;
  99. LPDAQD lpDAQ;
  100. dev.last_playbank = -1;
  101. writew(PCTODSP_OFFSET(0 * DAQDS__size), dev.DAPQ + JQS_wHead);
  102. writew(PCTODSP_OFFSET(0 * DAQDS__size), dev.DAPQ + JQS_wTail);
  103. for (n = 0, lpDAQ = dev.base + DAPQ_DATA_BUFF; n < 3; ++n, lpDAQ += DAQDS__size) {
  104. writew(PCTODSP_BASED((DWORD)(DAP_BUFF_SIZE * n)), lpDAQ + DAQDS_wStart);
  105. writew(0, lpDAQ + DAQDS_wSize);
  106. writew(1, lpDAQ + DAQDS_wFormat);
  107. writew(dev.play_sample_size, lpDAQ + DAQDS_wSampleSize);
  108. writew(dev.play_channels, lpDAQ + DAQDS_wChannels);
  109. writew(dev.play_sample_rate, lpDAQ + DAQDS_wSampleRate);
  110. writew(HIMT_PLAY_DONE * 0x100 + n, lpDAQ + DAQDS_wIntMsg);
  111. writew(n, lpDAQ + DAQDS_wFlags);
  112. }
  113. }
  114. static void reset_record_queue(void)
  115. {
  116. int n;
  117. LPDAQD lpDAQ;
  118. unsigned long flags;
  119. dev.last_recbank = 2;
  120. writew(PCTODSP_OFFSET(0 * DAQDS__size), dev.DARQ + JQS_wHead);
  121. writew(PCTODSP_OFFSET(dev.last_recbank * DAQDS__size), dev.DARQ + JQS_wTail);
  122. /* Critical section: bank 1 access */
  123. spin_lock_irqsave(&dev.lock, flags);
  124. msnd_outb(HPBLKSEL_1, dev.io + HP_BLKS);
  125. memset_io(dev.base, 0, DAR_BUFF_SIZE * 3);
  126. msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
  127. spin_unlock_irqrestore(&dev.lock, flags);
  128. for (n = 0, lpDAQ = dev.base + DARQ_DATA_BUFF; n < 3; ++n, lpDAQ += DAQDS__size) {
  129. writew(PCTODSP_BASED((DWORD)(DAR_BUFF_SIZE * n)) + 0x4000, lpDAQ + DAQDS_wStart);
  130. writew(DAR_BUFF_SIZE, lpDAQ + DAQDS_wSize);
  131. writew(1, lpDAQ + DAQDS_wFormat);
  132. writew(dev.rec_sample_size, lpDAQ + DAQDS_wSampleSize);
  133. writew(dev.rec_channels, lpDAQ + DAQDS_wChannels);
  134. writew(dev.rec_sample_rate, lpDAQ + DAQDS_wSampleRate);
  135. writew(HIMT_RECORD_DONE * 0x100 + n, lpDAQ + DAQDS_wIntMsg);
  136. writew(n, lpDAQ + DAQDS_wFlags);
  137. }
  138. }
  139. static void reset_queues(void)
  140. {
  141. if (dev.mode & FMODE_WRITE) {
  142. msnd_fifo_make_empty(&dev.DAPF);
  143. reset_play_queue();
  144. }
  145. if (dev.mode & FMODE_READ) {
  146. msnd_fifo_make_empty(&dev.DARF);
  147. reset_record_queue();
  148. }
  149. }
  150. static int dsp_set_format(struct file *file, int val)
  151. {
  152. int data, i;
  153. LPDAQD lpDAQ, lpDARQ;
  154. lpDAQ = dev.base + DAPQ_DATA_BUFF;
  155. lpDARQ = dev.base + DARQ_DATA_BUFF;
  156. switch (val) {
  157. case AFMT_U8:
  158. case AFMT_S16_LE:
  159. data = val;
  160. break;
  161. default:
  162. data = DEFSAMPLESIZE;
  163. break;
  164. }
  165. for (i = 0; i < 3; ++i, lpDAQ += DAQDS__size, lpDARQ += DAQDS__size) {
  166. if (file->f_mode & FMODE_WRITE)
  167. writew(data, lpDAQ + DAQDS_wSampleSize);
  168. if (file->f_mode & FMODE_READ)
  169. writew(data, lpDARQ + DAQDS_wSampleSize);
  170. }
  171. if (file->f_mode & FMODE_WRITE)
  172. dev.play_sample_size = data;
  173. if (file->f_mode & FMODE_READ)
  174. dev.rec_sample_size = data;
  175. return data;
  176. }
  177. static int dsp_get_frag_size(void)
  178. {
  179. int size;
  180. size = dev.fifosize / 4;
  181. if (size > 32 * 1024)
  182. size = 32 * 1024;
  183. return size;
  184. }
  185. static int dsp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  186. {
  187. int val, i, data, tmp;
  188. LPDAQD lpDAQ, lpDARQ;
  189. audio_buf_info abinfo;
  190. unsigned long flags;
  191. int __user *p = (int __user *)arg;
  192. lpDAQ = dev.base + DAPQ_DATA_BUFF;
  193. lpDARQ = dev.base + DARQ_DATA_BUFF;
  194. switch (cmd) {
  195. case SNDCTL_DSP_SUBDIVIDE:
  196. case SNDCTL_DSP_SETFRAGMENT:
  197. case SNDCTL_DSP_SETDUPLEX:
  198. case SNDCTL_DSP_POST:
  199. return 0;
  200. case SNDCTL_DSP_GETIPTR:
  201. case SNDCTL_DSP_GETOPTR:
  202. case SNDCTL_DSP_MAPINBUF:
  203. case SNDCTL_DSP_MAPOUTBUF:
  204. return -EINVAL;
  205. case SNDCTL_DSP_GETOSPACE:
  206. if (!(file->f_mode & FMODE_WRITE))
  207. return -EINVAL;
  208. spin_lock_irqsave(&dev.lock, flags);
  209. abinfo.fragsize = dsp_get_frag_size();
  210. abinfo.bytes = dev.DAPF.n - dev.DAPF.len;
  211. abinfo.fragstotal = dev.DAPF.n / abinfo.fragsize;
  212. abinfo.fragments = abinfo.bytes / abinfo.fragsize;
  213. spin_unlock_irqrestore(&dev.lock, flags);
  214. return copy_to_user((void __user *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
  215. case SNDCTL_DSP_GETISPACE:
  216. if (!(file->f_mode & FMODE_READ))
  217. return -EINVAL;
  218. spin_lock_irqsave(&dev.lock, flags);
  219. abinfo.fragsize = dsp_get_frag_size();
  220. abinfo.bytes = dev.DARF.n - dev.DARF.len;
  221. abinfo.fragstotal = dev.DARF.n / abinfo.fragsize;
  222. abinfo.fragments = abinfo.bytes / abinfo.fragsize;
  223. spin_unlock_irqrestore(&dev.lock, flags);
  224. return copy_to_user((void __user *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
  225. case SNDCTL_DSP_RESET:
  226. dev.nresets = 0;
  227. reset_queues();
  228. return 0;
  229. case SNDCTL_DSP_SYNC:
  230. dsp_write_flush();
  231. return 0;
  232. case SNDCTL_DSP_GETBLKSIZE:
  233. tmp = dsp_get_frag_size();
  234. if (put_user(tmp, p))
  235. return -EFAULT;
  236. return 0;
  237. case SNDCTL_DSP_GETFMTS:
  238. val = AFMT_S16_LE | AFMT_U8;
  239. if (put_user(val, p))
  240. return -EFAULT;
  241. return 0;
  242. case SNDCTL_DSP_SETFMT:
  243. if (get_user(val, p))
  244. return -EFAULT;
  245. if (file->f_mode & FMODE_WRITE)
  246. data = val == AFMT_QUERY
  247. ? dev.play_sample_size
  248. : dsp_set_format(file, val);
  249. else
  250. data = val == AFMT_QUERY
  251. ? dev.rec_sample_size
  252. : dsp_set_format(file, val);
  253. if (put_user(data, p))
  254. return -EFAULT;
  255. return 0;
  256. case SNDCTL_DSP_NONBLOCK:
  257. if (!test_bit(F_DISABLE_WRITE_NDELAY, &dev.flags) &&
  258. file->f_mode & FMODE_WRITE)
  259. dev.play_ndelay = 1;
  260. if (file->f_mode & FMODE_READ)
  261. dev.rec_ndelay = 1;
  262. return 0;
  263. case SNDCTL_DSP_GETCAPS:
  264. val = DSP_CAP_DUPLEX | DSP_CAP_BATCH;
  265. if (put_user(val, p))
  266. return -EFAULT;
  267. return 0;
  268. case SNDCTL_DSP_SPEED:
  269. if (get_user(val, p))
  270. return -EFAULT;
  271. if (val < 8000)
  272. val = 8000;
  273. if (val > 48000)
  274. val = 48000;
  275. data = val;
  276. for (i = 0; i < 3; ++i, lpDAQ += DAQDS__size, lpDARQ += DAQDS__size) {
  277. if (file->f_mode & FMODE_WRITE)
  278. writew(data, lpDAQ + DAQDS_wSampleRate);
  279. if (file->f_mode & FMODE_READ)
  280. writew(data, lpDARQ + DAQDS_wSampleRate);
  281. }
  282. if (file->f_mode & FMODE_WRITE)
  283. dev.play_sample_rate = data;
  284. if (file->f_mode & FMODE_READ)
  285. dev.rec_sample_rate = data;
  286. if (put_user(data, p))
  287. return -EFAULT;
  288. return 0;
  289. case SNDCTL_DSP_CHANNELS:
  290. case SNDCTL_DSP_STEREO:
  291. if (get_user(val, p))
  292. return -EFAULT;
  293. if (cmd == SNDCTL_DSP_CHANNELS) {
  294. switch (val) {
  295. case 1:
  296. case 2:
  297. data = val;
  298. break;
  299. default:
  300. val = data = 2;
  301. break;
  302. }
  303. } else {
  304. switch (val) {
  305. case 0:
  306. data = 1;
  307. break;
  308. default:
  309. val = 1;
  310. case 1:
  311. data = 2;
  312. break;
  313. }
  314. }
  315. for (i = 0; i < 3; ++i, lpDAQ += DAQDS__size, lpDARQ += DAQDS__size) {
  316. if (file->f_mode & FMODE_WRITE)
  317. writew(data, lpDAQ + DAQDS_wChannels);
  318. if (file->f_mode & FMODE_READ)
  319. writew(data, lpDARQ + DAQDS_wChannels);
  320. }
  321. if (file->f_mode & FMODE_WRITE)
  322. dev.play_channels = data;
  323. if (file->f_mode & FMODE_READ)
  324. dev.rec_channels = data;
  325. if (put_user(val, p))
  326. return -EFAULT;
  327. return 0;
  328. }
  329. return -EINVAL;
  330. }
  331. static int mixer_get(int d)
  332. {
  333. if (d > 31)
  334. return -EINVAL;
  335. switch (d) {
  336. case SOUND_MIXER_VOLUME:
  337. case SOUND_MIXER_PCM:
  338. case SOUND_MIXER_LINE:
  339. case SOUND_MIXER_IMIX:
  340. case SOUND_MIXER_LINE1:
  341. #ifndef MSND_CLASSIC
  342. case SOUND_MIXER_MIC:
  343. case SOUND_MIXER_SYNTH:
  344. #endif
  345. return (dev.left_levels[d] >> 8) * 100 / 0xff |
  346. (((dev.right_levels[d] >> 8) * 100 / 0xff) << 8);
  347. default:
  348. return 0;
  349. }
  350. }
  351. #define update_volm(a,b) \
  352. writew((dev.left_levels[a] >> 1) * \
  353. readw(dev.SMA + SMA_wCurrMastVolLeft) / 0xffff, \
  354. dev.SMA + SMA_##b##Left); \
  355. writew((dev.right_levels[a] >> 1) * \
  356. readw(dev.SMA + SMA_wCurrMastVolRight) / 0xffff, \
  357. dev.SMA + SMA_##b##Right);
  358. #define update_potm(d,s,ar) \
  359. writeb((dev.left_levels[d] >> 8) * \
  360. readw(dev.SMA + SMA_wCurrMastVolLeft) / 0xffff, \
  361. dev.SMA + SMA_##s##Left); \
  362. writeb((dev.right_levels[d] >> 8) * \
  363. readw(dev.SMA + SMA_wCurrMastVolRight) / 0xffff, \
  364. dev.SMA + SMA_##s##Right); \
  365. if (msnd_send_word(&dev, 0, 0, ar) == 0) \
  366. chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
  367. #define update_pot(d,s,ar) \
  368. writeb(dev.left_levels[d] >> 8, \
  369. dev.SMA + SMA_##s##Left); \
  370. writeb(dev.right_levels[d] >> 8, \
  371. dev.SMA + SMA_##s##Right); \
  372. if (msnd_send_word(&dev, 0, 0, ar) == 0) \
  373. chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
  374. static int mixer_set(int d, int value)
  375. {
  376. int left = value & 0x000000ff;
  377. int right = (value & 0x0000ff00) >> 8;
  378. int bLeft, bRight;
  379. int wLeft, wRight;
  380. int updatemaster = 0;
  381. if (d > 31)
  382. return -EINVAL;
  383. bLeft = left * 0xff / 100;
  384. wLeft = left * 0xffff / 100;
  385. bRight = right * 0xff / 100;
  386. wRight = right * 0xffff / 100;
  387. dev.left_levels[d] = wLeft;
  388. dev.right_levels[d] = wRight;
  389. switch (d) {
  390. /* master volume unscaled controls */
  391. case SOUND_MIXER_LINE: /* line pot control */
  392. /* scaled by IMIX in digital mix */
  393. writeb(bLeft, dev.SMA + SMA_bInPotPosLeft);
  394. writeb(bRight, dev.SMA + SMA_bInPotPosRight);
  395. if (msnd_send_word(&dev, 0, 0, HDEXAR_IN_SET_POTS) == 0)
  396. chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
  397. break;
  398. #ifndef MSND_CLASSIC
  399. case SOUND_MIXER_MIC: /* mic pot control */
  400. /* scaled by IMIX in digital mix */
  401. writeb(bLeft, dev.SMA + SMA_bMicPotPosLeft);
  402. writeb(bRight, dev.SMA + SMA_bMicPotPosRight);
  403. if (msnd_send_word(&dev, 0, 0, HDEXAR_MIC_SET_POTS) == 0)
  404. chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
  405. break;
  406. #endif
  407. case SOUND_MIXER_VOLUME: /* master volume */
  408. writew(wLeft, dev.SMA + SMA_wCurrMastVolLeft);
  409. writew(wRight, dev.SMA + SMA_wCurrMastVolRight);
  410. /* fall through */
  411. case SOUND_MIXER_LINE1: /* aux pot control */
  412. /* scaled by master volume */
  413. /* fall through */
  414. /* digital controls */
  415. case SOUND_MIXER_SYNTH: /* synth vol (dsp mix) */
  416. case SOUND_MIXER_PCM: /* pcm vol (dsp mix) */
  417. case SOUND_MIXER_IMIX: /* input monitor (dsp mix) */
  418. /* scaled by master volume */
  419. updatemaster = 1;
  420. break;
  421. default:
  422. return 0;
  423. }
  424. if (updatemaster) {
  425. /* update master volume scaled controls */
  426. update_volm(SOUND_MIXER_PCM, wCurrPlayVol);
  427. update_volm(SOUND_MIXER_IMIX, wCurrInVol);
  428. #ifndef MSND_CLASSIC
  429. update_volm(SOUND_MIXER_SYNTH, wCurrMHdrVol);
  430. #endif
  431. update_potm(SOUND_MIXER_LINE1, bAuxPotPos, HDEXAR_AUX_SET_POTS);
  432. }
  433. return mixer_get(d);
  434. }
  435. static void mixer_setup(void)
  436. {
  437. update_pot(SOUND_MIXER_LINE, bInPotPos, HDEXAR_IN_SET_POTS);
  438. update_potm(SOUND_MIXER_LINE1, bAuxPotPos, HDEXAR_AUX_SET_POTS);
  439. update_volm(SOUND_MIXER_PCM, wCurrPlayVol);
  440. update_volm(SOUND_MIXER_IMIX, wCurrInVol);
  441. #ifndef MSND_CLASSIC
  442. update_pot(SOUND_MIXER_MIC, bMicPotPos, HDEXAR_MIC_SET_POTS);
  443. update_volm(SOUND_MIXER_SYNTH, wCurrMHdrVol);
  444. #endif
  445. }
  446. static unsigned long set_recsrc(unsigned long recsrc)
  447. {
  448. if (dev.recsrc == recsrc)
  449. return dev.recsrc;
  450. #ifdef HAVE_NORECSRC
  451. else if (recsrc == 0)
  452. dev.recsrc = 0;
  453. #endif
  454. else
  455. dev.recsrc ^= recsrc;
  456. #ifndef MSND_CLASSIC
  457. if (dev.recsrc & SOUND_MASK_IMIX) {
  458. if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_ANA_IN) == 0)
  459. chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
  460. }
  461. else if (dev.recsrc & SOUND_MASK_SYNTH) {
  462. if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_SYNTH_IN) == 0)
  463. chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
  464. }
  465. else if ((dev.recsrc & SOUND_MASK_DIGITAL1) && test_bit(F_HAVEDIGITAL, &dev.flags)) {
  466. if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_DAT_IN) == 0)
  467. chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
  468. }
  469. else {
  470. #ifdef HAVE_NORECSRC
  471. /* Select no input (?) */
  472. dev.recsrc = 0;
  473. #else
  474. dev.recsrc = SOUND_MASK_IMIX;
  475. if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_ANA_IN) == 0)
  476. chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
  477. #endif
  478. }
  479. #endif /* MSND_CLASSIC */
  480. return dev.recsrc;
  481. }
  482. static unsigned long force_recsrc(unsigned long recsrc)
  483. {
  484. dev.recsrc = 0;
  485. return set_recsrc(recsrc);
  486. }
  487. #define set_mixer_info() \
  488. memset(&info, 0, sizeof(info)); \
  489. strlcpy(info.id, "MSNDMIXER", sizeof(info.id)); \
  490. strlcpy(info.name, "MultiSound Mixer", sizeof(info.name));
  491. static int mixer_ioctl(unsigned int cmd, unsigned long arg)
  492. {
  493. if (cmd == SOUND_MIXER_INFO) {
  494. mixer_info info;
  495. set_mixer_info();
  496. info.modify_counter = dev.mixer_mod_count;
  497. if (copy_to_user((void __user *)arg, &info, sizeof(info)))
  498. return -EFAULT;
  499. return 0;
  500. } else if (cmd == SOUND_OLD_MIXER_INFO) {
  501. _old_mixer_info info;
  502. set_mixer_info();
  503. if (copy_to_user((void __user *)arg, &info, sizeof(info)))
  504. return -EFAULT;
  505. return 0;
  506. } else if (cmd == SOUND_MIXER_PRIVATE1) {
  507. dev.nresets = 0;
  508. dsp_full_reset();
  509. return 0;
  510. } else if (((cmd >> 8) & 0xff) == 'M') {
  511. int val = 0;
  512. if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
  513. switch (cmd & 0xff) {
  514. case SOUND_MIXER_RECSRC:
  515. if (get_user(val, (int __user *)arg))
  516. return -EFAULT;
  517. val = set_recsrc(val);
  518. break;
  519. default:
  520. if (get_user(val, (int __user *)arg))
  521. return -EFAULT;
  522. val = mixer_set(cmd & 0xff, val);
  523. break;
  524. }
  525. ++dev.mixer_mod_count;
  526. return put_user(val, (int __user *)arg);
  527. } else {
  528. switch (cmd & 0xff) {
  529. case SOUND_MIXER_RECSRC:
  530. val = dev.recsrc;
  531. break;
  532. case SOUND_MIXER_DEVMASK:
  533. case SOUND_MIXER_STEREODEVS:
  534. val = SOUND_MASK_PCM |
  535. SOUND_MASK_LINE |
  536. SOUND_MASK_IMIX |
  537. SOUND_MASK_LINE1 |
  538. #ifndef MSND_CLASSIC
  539. SOUND_MASK_MIC |
  540. SOUND_MASK_SYNTH |
  541. #endif
  542. SOUND_MASK_VOLUME;
  543. break;
  544. case SOUND_MIXER_RECMASK:
  545. #ifdef MSND_CLASSIC
  546. val = 0;
  547. #else
  548. val = SOUND_MASK_IMIX |
  549. SOUND_MASK_SYNTH;
  550. if (test_bit(F_HAVEDIGITAL, &dev.flags))
  551. val |= SOUND_MASK_DIGITAL1;
  552. #endif
  553. break;
  554. case SOUND_MIXER_CAPS:
  555. val = SOUND_CAP_EXCL_INPUT;
  556. break;
  557. default:
  558. if ((val = mixer_get(cmd & 0xff)) < 0)
  559. return -EINVAL;
  560. break;
  561. }
  562. }
  563. return put_user(val, (int __user *)arg);
  564. }
  565. return -EINVAL;
  566. }
  567. static int dev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  568. {
  569. int minor = iminor(inode);
  570. if (cmd == OSS_GETVERSION) {
  571. int sound_version = SOUND_VERSION;
  572. return put_user(sound_version, (int __user *)arg);
  573. }
  574. if (minor == dev.dsp_minor)
  575. return dsp_ioctl(file, cmd, arg);
  576. else if (minor == dev.mixer_minor)
  577. return mixer_ioctl(cmd, arg);
  578. return -EINVAL;
  579. }
  580. static void dsp_write_flush(void)
  581. {
  582. if (!(dev.mode & FMODE_WRITE) || !test_bit(F_WRITING, &dev.flags))
  583. return;
  584. set_bit(F_WRITEFLUSH, &dev.flags);
  585. interruptible_sleep_on_timeout(
  586. &dev.writeflush,
  587. get_play_delay_jiffies(dev.DAPF.len));
  588. clear_bit(F_WRITEFLUSH, &dev.flags);
  589. if (!signal_pending(current)) {
  590. current->state = TASK_INTERRUPTIBLE;
  591. schedule_timeout(get_play_delay_jiffies(DAP_BUFF_SIZE));
  592. }
  593. clear_bit(F_WRITING, &dev.flags);
  594. }
  595. static void dsp_halt(struct file *file)
  596. {
  597. if ((file ? file->f_mode : dev.mode) & FMODE_READ) {
  598. clear_bit(F_READING, &dev.flags);
  599. chk_send_dsp_cmd(&dev, HDEX_RECORD_STOP);
  600. msnd_disable_irq(&dev);
  601. if (file) {
  602. printk(KERN_DEBUG LOGNAME ": Stopping read for %p\n", file);
  603. dev.mode &= ~FMODE_READ;
  604. }
  605. clear_bit(F_AUDIO_READ_INUSE, &dev.flags);
  606. }
  607. if ((file ? file->f_mode : dev.mode) & FMODE_WRITE) {
  608. if (test_bit(F_WRITING, &dev.flags)) {
  609. dsp_write_flush();
  610. chk_send_dsp_cmd(&dev, HDEX_PLAY_STOP);
  611. }
  612. msnd_disable_irq(&dev);
  613. if (file) {
  614. printk(KERN_DEBUG LOGNAME ": Stopping write for %p\n", file);
  615. dev.mode &= ~FMODE_WRITE;
  616. }
  617. clear_bit(F_AUDIO_WRITE_INUSE, &dev.flags);
  618. }
  619. }
  620. static int dsp_release(struct file *file)
  621. {
  622. dsp_halt(file);
  623. return 0;
  624. }
  625. static int dsp_open(struct file *file)
  626. {
  627. if ((file ? file->f_mode : dev.mode) & FMODE_WRITE) {
  628. set_bit(F_AUDIO_WRITE_INUSE, &dev.flags);
  629. clear_bit(F_WRITING, &dev.flags);
  630. msnd_fifo_make_empty(&dev.DAPF);
  631. reset_play_queue();
  632. if (file) {
  633. printk(KERN_DEBUG LOGNAME ": Starting write for %p\n", file);
  634. dev.mode |= FMODE_WRITE;
  635. }
  636. msnd_enable_irq(&dev);
  637. }
  638. if ((file ? file->f_mode : dev.mode) & FMODE_READ) {
  639. set_bit(F_AUDIO_READ_INUSE, &dev.flags);
  640. clear_bit(F_READING, &dev.flags);
  641. msnd_fifo_make_empty(&dev.DARF);
  642. reset_record_queue();
  643. if (file) {
  644. printk(KERN_DEBUG LOGNAME ": Starting read for %p\n", file);
  645. dev.mode |= FMODE_READ;
  646. }
  647. msnd_enable_irq(&dev);
  648. }
  649. return 0;
  650. }
  651. static void set_default_play_audio_parameters(void)
  652. {
  653. dev.play_sample_size = DEFSAMPLESIZE;
  654. dev.play_sample_rate = DEFSAMPLERATE;
  655. dev.play_channels = DEFCHANNELS;
  656. }
  657. static void set_default_rec_audio_parameters(void)
  658. {
  659. dev.rec_sample_size = DEFSAMPLESIZE;
  660. dev.rec_sample_rate = DEFSAMPLERATE;
  661. dev.rec_channels = DEFCHANNELS;
  662. }
  663. static void set_default_audio_parameters(void)
  664. {
  665. set_default_play_audio_parameters();
  666. set_default_rec_audio_parameters();
  667. }
  668. static int dev_open(struct inode *inode, struct file *file)
  669. {
  670. int minor = iminor(inode);
  671. int err = 0;
  672. if (minor == dev.dsp_minor) {
  673. if ((file->f_mode & FMODE_WRITE &&
  674. test_bit(F_AUDIO_WRITE_INUSE, &dev.flags)) ||
  675. (file->f_mode & FMODE_READ &&
  676. test_bit(F_AUDIO_READ_INUSE, &dev.flags)))
  677. return -EBUSY;
  678. if ((err = dsp_open(file)) >= 0) {
  679. dev.nresets = 0;
  680. if (file->f_mode & FMODE_WRITE) {
  681. set_default_play_audio_parameters();
  682. if (!test_bit(F_DISABLE_WRITE_NDELAY, &dev.flags))
  683. dev.play_ndelay = (file->f_flags & O_NDELAY) ? 1 : 0;
  684. else
  685. dev.play_ndelay = 0;
  686. }
  687. if (file->f_mode & FMODE_READ) {
  688. set_default_rec_audio_parameters();
  689. dev.rec_ndelay = (file->f_flags & O_NDELAY) ? 1 : 0;
  690. }
  691. }
  692. }
  693. else if (minor == dev.mixer_minor) {
  694. /* nothing */
  695. } else
  696. err = -EINVAL;
  697. return err;
  698. }
  699. static int dev_release(struct inode *inode, struct file *file)
  700. {
  701. int minor = iminor(inode);
  702. int err = 0;
  703. lock_kernel();
  704. if (minor == dev.dsp_minor)
  705. err = dsp_release(file);
  706. else if (minor == dev.mixer_minor) {
  707. /* nothing */
  708. } else
  709. err = -EINVAL;
  710. unlock_kernel();
  711. return err;
  712. }
  713. static __inline__ int pack_DARQ_to_DARF(register int bank)
  714. {
  715. register int size, timeout = 3;
  716. register WORD wTmp;
  717. LPDAQD DAQD;
  718. /* Increment the tail and check for queue wrap */
  719. wTmp = readw(dev.DARQ + JQS_wTail) + PCTODSP_OFFSET(DAQDS__size);
  720. if (wTmp > readw(dev.DARQ + JQS_wSize))
  721. wTmp = 0;
  722. while (wTmp == readw(dev.DARQ + JQS_wHead) && timeout--)
  723. udelay(1);
  724. writew(wTmp, dev.DARQ + JQS_wTail);
  725. /* Get our digital audio queue struct */
  726. DAQD = bank * DAQDS__size + dev.base + DARQ_DATA_BUFF;
  727. /* Get length of data */
  728. size = readw(DAQD + DAQDS_wSize);
  729. /* Read data from the head (unprotected bank 1 access okay
  730. since this is only called inside an interrupt) */
  731. msnd_outb(HPBLKSEL_1, dev.io + HP_BLKS);
  732. msnd_fifo_write_io(
  733. &dev.DARF,
  734. dev.base + bank * DAR_BUFF_SIZE,
  735. size);
  736. msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
  737. return 1;
  738. }
  739. static __inline__ int pack_DAPF_to_DAPQ(register int start)
  740. {
  741. register WORD DAPQ_tail;
  742. register int protect = start, nbanks = 0;
  743. LPDAQD DAQD;
  744. DAPQ_tail = readw(dev.DAPQ + JQS_wTail);
  745. while (DAPQ_tail != readw(dev.DAPQ + JQS_wHead) || start) {
  746. register int bank_num = DAPQ_tail / PCTODSP_OFFSET(DAQDS__size);
  747. register int n;
  748. unsigned long flags;
  749. /* Write the data to the new tail */
  750. if (protect) {
  751. /* Critical section: protect fifo in non-interrupt */
  752. spin_lock_irqsave(&dev.lock, flags);
  753. n = msnd_fifo_read_io(
  754. &dev.DAPF,
  755. dev.base + bank_num * DAP_BUFF_SIZE,
  756. DAP_BUFF_SIZE);
  757. spin_unlock_irqrestore(&dev.lock, flags);
  758. } else {
  759. n = msnd_fifo_read_io(
  760. &dev.DAPF,
  761. dev.base + bank_num * DAP_BUFF_SIZE,
  762. DAP_BUFF_SIZE);
  763. }
  764. if (!n)
  765. break;
  766. if (start)
  767. start = 0;
  768. /* Get our digital audio queue struct */
  769. DAQD = bank_num * DAQDS__size + dev.base + DAPQ_DATA_BUFF;
  770. /* Write size of this bank */
  771. writew(n, DAQD + DAQDS_wSize);
  772. ++nbanks;
  773. /* Then advance the tail */
  774. DAPQ_tail = (++bank_num % 3) * PCTODSP_OFFSET(DAQDS__size);
  775. writew(DAPQ_tail, dev.DAPQ + JQS_wTail);
  776. /* Tell the DSP to play the bank */
  777. msnd_send_dsp_cmd(&dev, HDEX_PLAY_START);
  778. }
  779. return nbanks;
  780. }
  781. static int dsp_read(char __user *buf, size_t len)
  782. {
  783. int count = len;
  784. char *page = (char *)__get_free_page(GFP_KERNEL);
  785. if (!page)
  786. return -ENOMEM;
  787. while (count > 0) {
  788. int n, k;
  789. unsigned long flags;
  790. k = PAGE_SIZE;
  791. if (k > count)
  792. k = count;
  793. /* Critical section: protect fifo in non-interrupt */
  794. spin_lock_irqsave(&dev.lock, flags);
  795. n = msnd_fifo_read(&dev.DARF, page, k);
  796. spin_unlock_irqrestore(&dev.lock, flags);
  797. if (copy_to_user(buf, page, n)) {
  798. free_page((unsigned long)page);
  799. return -EFAULT;
  800. }
  801. buf += n;
  802. count -= n;
  803. if (n == k && count)
  804. continue;
  805. if (!test_bit(F_READING, &dev.flags) && dev.mode & FMODE_READ) {
  806. dev.last_recbank = -1;
  807. if (chk_send_dsp_cmd(&dev, HDEX_RECORD_START) == 0)
  808. set_bit(F_READING, &dev.flags);
  809. }
  810. if (dev.rec_ndelay) {
  811. free_page((unsigned long)page);
  812. return count == len ? -EAGAIN : len - count;
  813. }
  814. if (count > 0) {
  815. set_bit(F_READBLOCK, &dev.flags);
  816. if (!interruptible_sleep_on_timeout(
  817. &dev.readblock,
  818. get_rec_delay_jiffies(DAR_BUFF_SIZE)))
  819. clear_bit(F_READING, &dev.flags);
  820. clear_bit(F_READBLOCK, &dev.flags);
  821. if (signal_pending(current)) {
  822. free_page((unsigned long)page);
  823. return -EINTR;
  824. }
  825. }
  826. }
  827. free_page((unsigned long)page);
  828. return len - count;
  829. }
  830. static int dsp_write(const char __user *buf, size_t len)
  831. {
  832. int count = len;
  833. char *page = (char *)__get_free_page(GFP_KERNEL);
  834. if (!page)
  835. return -ENOMEM;
  836. while (count > 0) {
  837. int n, k;
  838. unsigned long flags;
  839. k = PAGE_SIZE;
  840. if (k > count)
  841. k = count;
  842. if (copy_from_user(page, buf, k)) {
  843. free_page((unsigned long)page);
  844. return -EFAULT;
  845. }
  846. /* Critical section: protect fifo in non-interrupt */
  847. spin_lock_irqsave(&dev.lock, flags);
  848. n = msnd_fifo_write(&dev.DAPF, page, k);
  849. spin_unlock_irqrestore(&dev.lock, flags);
  850. buf += n;
  851. count -= n;
  852. if (count && n == k)
  853. continue;
  854. if (!test_bit(F_WRITING, &dev.flags) && (dev.mode & FMODE_WRITE)) {
  855. dev.last_playbank = -1;
  856. if (pack_DAPF_to_DAPQ(1) > 0)
  857. set_bit(F_WRITING, &dev.flags);
  858. }
  859. if (dev.play_ndelay) {
  860. free_page((unsigned long)page);
  861. return count == len ? -EAGAIN : len - count;
  862. }
  863. if (count > 0) {
  864. set_bit(F_WRITEBLOCK, &dev.flags);
  865. interruptible_sleep_on_timeout(
  866. &dev.writeblock,
  867. get_play_delay_jiffies(DAP_BUFF_SIZE));
  868. clear_bit(F_WRITEBLOCK, &dev.flags);
  869. if (signal_pending(current)) {
  870. free_page((unsigned long)page);
  871. return -EINTR;
  872. }
  873. }
  874. }
  875. free_page((unsigned long)page);
  876. return len - count;
  877. }
  878. static ssize_t dev_read(struct file *file, char __user *buf, size_t count, loff_t *off)
  879. {
  880. int minor = iminor(file->f_path.dentry->d_inode);
  881. if (minor == dev.dsp_minor)
  882. return dsp_read(buf, count);
  883. else
  884. return -EINVAL;
  885. }
  886. static ssize_t dev_write(struct file *file, const char __user *buf, size_t count, loff_t *off)
  887. {
  888. int minor = iminor(file->f_path.dentry->d_inode);
  889. if (minor == dev.dsp_minor)
  890. return dsp_write(buf, count);
  891. else
  892. return -EINVAL;
  893. }
  894. static __inline__ void eval_dsp_msg(register WORD wMessage)
  895. {
  896. switch (HIBYTE(wMessage)) {
  897. case HIMT_PLAY_DONE:
  898. if (dev.last_playbank == LOBYTE(wMessage) || !test_bit(F_WRITING, &dev.flags))
  899. break;
  900. dev.last_playbank = LOBYTE(wMessage);
  901. if (pack_DAPF_to_DAPQ(0) <= 0) {
  902. if (!test_bit(F_WRITEBLOCK, &dev.flags)) {
  903. if (test_and_clear_bit(F_WRITEFLUSH, &dev.flags))
  904. wake_up_interruptible(&dev.writeflush);
  905. }
  906. clear_bit(F_WRITING, &dev.flags);
  907. }
  908. if (test_bit(F_WRITEBLOCK, &dev.flags))
  909. wake_up_interruptible(&dev.writeblock);
  910. break;
  911. case HIMT_RECORD_DONE:
  912. if (dev.last_recbank == LOBYTE(wMessage))
  913. break;
  914. dev.last_recbank = LOBYTE(wMessage);
  915. pack_DARQ_to_DARF(dev.last_recbank);
  916. if (test_bit(F_READBLOCK, &dev.flags))
  917. wake_up_interruptible(&dev.readblock);
  918. break;
  919. case HIMT_DSP:
  920. switch (LOBYTE(wMessage)) {
  921. #ifndef MSND_CLASSIC
  922. case HIDSP_PLAY_UNDER:
  923. #endif
  924. case HIDSP_INT_PLAY_UNDER:
  925. /* printk(KERN_DEBUG LOGNAME ": Play underflow\n"); */
  926. clear_bit(F_WRITING, &dev.flags);
  927. break;
  928. case HIDSP_INT_RECORD_OVER:
  929. /* printk(KERN_DEBUG LOGNAME ": Record overflow\n"); */
  930. clear_bit(F_READING, &dev.flags);
  931. break;
  932. default:
  933. /* printk(KERN_DEBUG LOGNAME ": DSP message %d 0x%02x\n",
  934. LOBYTE(wMessage), LOBYTE(wMessage)); */
  935. break;
  936. }
  937. break;
  938. case HIMT_MIDI_IN_UCHAR:
  939. if (dev.midi_in_interrupt)
  940. (*dev.midi_in_interrupt)(&dev);
  941. break;
  942. default:
  943. /* printk(KERN_DEBUG LOGNAME ": HIMT message %d 0x%02x\n", HIBYTE(wMessage), HIBYTE(wMessage)); */
  944. break;
  945. }
  946. }
  947. static irqreturn_t intr(int irq, void *dev_id)
  948. {
  949. /* Send ack to DSP */
  950. msnd_inb(dev.io + HP_RXL);
  951. /* Evaluate queued DSP messages */
  952. while (readw(dev.DSPQ + JQS_wTail) != readw(dev.DSPQ + JQS_wHead)) {
  953. register WORD wTmp;
  954. eval_dsp_msg(readw(dev.pwDSPQData + 2*readw(dev.DSPQ + JQS_wHead)));
  955. if ((wTmp = readw(dev.DSPQ + JQS_wHead) + 1) > readw(dev.DSPQ + JQS_wSize))
  956. writew(0, dev.DSPQ + JQS_wHead);
  957. else
  958. writew(wTmp, dev.DSPQ + JQS_wHead);
  959. }
  960. return IRQ_HANDLED;
  961. }
  962. static const struct file_operations dev_fileops = {
  963. .owner = THIS_MODULE,
  964. .read = dev_read,
  965. .write = dev_write,
  966. .ioctl = dev_ioctl,
  967. .open = dev_open,
  968. .release = dev_release,
  969. };
  970. static int reset_dsp(void)
  971. {
  972. int timeout = 100;
  973. msnd_outb(HPDSPRESET_ON, dev.io + HP_DSPR);
  974. mdelay(1);
  975. #ifndef MSND_CLASSIC
  976. dev.info = msnd_inb(dev.io + HP_INFO);
  977. #endif
  978. msnd_outb(HPDSPRESET_OFF, dev.io + HP_DSPR);
  979. mdelay(1);
  980. while (timeout-- > 0) {
  981. if (msnd_inb(dev.io + HP_CVR) == HP_CVR_DEF)
  982. return 0;
  983. mdelay(1);
  984. }
  985. printk(KERN_ERR LOGNAME ": Cannot reset DSP\n");
  986. return -EIO;
  987. }
  988. static int __init probe_multisound(void)
  989. {
  990. #ifndef MSND_CLASSIC
  991. char *xv, *rev = NULL;
  992. char *pin = "Pinnacle", *fiji = "Fiji";
  993. char *pinfiji = "Pinnacle/Fiji";
  994. #endif
  995. if (!request_region(dev.io, dev.numio, "probing")) {
  996. printk(KERN_ERR LOGNAME ": I/O port conflict\n");
  997. return -ENODEV;
  998. }
  999. if (reset_dsp() < 0) {
  1000. release_region(dev.io, dev.numio);
  1001. return -ENODEV;
  1002. }
  1003. #ifdef MSND_CLASSIC
  1004. dev.name = "Classic/Tahiti/Monterey";
  1005. printk(KERN_INFO LOGNAME ": %s, "
  1006. #else
  1007. switch (dev.info >> 4) {
  1008. case 0xf: xv = "<= 1.15"; break;
  1009. case 0x1: xv = "1.18/1.2"; break;
  1010. case 0x2: xv = "1.3"; break;
  1011. case 0x3: xv = "1.4"; break;
  1012. default: xv = "unknown"; break;
  1013. }
  1014. switch (dev.info & 0x7) {
  1015. case 0x0: rev = "I"; dev.name = pin; break;
  1016. case 0x1: rev = "F"; dev.name = pin; break;
  1017. case 0x2: rev = "G"; dev.name = pin; break;
  1018. case 0x3: rev = "H"; dev.name = pin; break;
  1019. case 0x4: rev = "E"; dev.name = fiji; break;
  1020. case 0x5: rev = "C"; dev.name = fiji; break;
  1021. case 0x6: rev = "D"; dev.name = fiji; break;
  1022. case 0x7:
  1023. rev = "A-B (Fiji) or A-E (Pinnacle)";
  1024. dev.name = pinfiji;
  1025. break;
  1026. }
  1027. printk(KERN_INFO LOGNAME ": %s revision %s, Xilinx version %s, "
  1028. #endif /* MSND_CLASSIC */
  1029. "I/O 0x%x-0x%x, IRQ %d, memory mapped to %p-%p\n",
  1030. dev.name,
  1031. #ifndef MSND_CLASSIC
  1032. rev, xv,
  1033. #endif
  1034. dev.io, dev.io + dev.numio - 1,
  1035. dev.irq,
  1036. dev.base, dev.base + 0x7fff);
  1037. release_region(dev.io, dev.numio);
  1038. return 0;
  1039. }
  1040. static int init_sma(void)
  1041. {
  1042. static int initted;
  1043. WORD mastVolLeft, mastVolRight;
  1044. unsigned long flags;
  1045. #ifdef MSND_CLASSIC
  1046. msnd_outb(dev.memid, dev.io + HP_MEMM);
  1047. #endif
  1048. msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
  1049. if (initted) {
  1050. mastVolLeft = readw(dev.SMA + SMA_wCurrMastVolLeft);
  1051. mastVolRight = readw(dev.SMA + SMA_wCurrMastVolRight);
  1052. } else
  1053. mastVolLeft = mastVolRight = 0;
  1054. memset_io(dev.base, 0, 0x8000);
  1055. /* Critical section: bank 1 access */
  1056. spin_lock_irqsave(&dev.lock, flags);
  1057. msnd_outb(HPBLKSEL_1, dev.io + HP_BLKS);
  1058. memset_io(dev.base, 0, 0x8000);
  1059. msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
  1060. spin_unlock_irqrestore(&dev.lock, flags);
  1061. dev.pwDSPQData = (dev.base + DSPQ_DATA_BUFF);
  1062. dev.pwMODQData = (dev.base + MODQ_DATA_BUFF);
  1063. dev.pwMIDQData = (dev.base + MIDQ_DATA_BUFF);
  1064. /* Motorola 56k shared memory base */
  1065. dev.SMA = dev.base + SMA_STRUCT_START;
  1066. /* Digital audio play queue */
  1067. dev.DAPQ = dev.base + DAPQ_OFFSET;
  1068. msnd_init_queue(dev.DAPQ, DAPQ_DATA_BUFF, DAPQ_BUFF_SIZE);
  1069. /* Digital audio record queue */
  1070. dev.DARQ = dev.base + DARQ_OFFSET;
  1071. msnd_init_queue(dev.DARQ, DARQ_DATA_BUFF, DARQ_BUFF_SIZE);
  1072. /* MIDI out queue */
  1073. dev.MODQ = dev.base + MODQ_OFFSET;
  1074. msnd_init_queue(dev.MODQ, MODQ_DATA_BUFF, MODQ_BUFF_SIZE);
  1075. /* MIDI in queue */
  1076. dev.MIDQ = dev.base + MIDQ_OFFSET;
  1077. msnd_init_queue(dev.MIDQ, MIDQ_DATA_BUFF, MIDQ_BUFF_SIZE);
  1078. /* DSP -> host message queue */
  1079. dev.DSPQ = dev.base + DSPQ_OFFSET;
  1080. msnd_init_queue(dev.DSPQ, DSPQ_DATA_BUFF, DSPQ_BUFF_SIZE);
  1081. /* Setup some DSP values */
  1082. #ifndef MSND_CLASSIC
  1083. writew(1, dev.SMA + SMA_wCurrPlayFormat);
  1084. writew(dev.play_sample_size, dev.SMA + SMA_wCurrPlaySampleSize);
  1085. writew(dev.play_channels, dev.SMA + SMA_wCurrPlayChannels);
  1086. writew(dev.play_sample_rate, dev.SMA + SMA_wCurrPlaySampleRate);
  1087. #endif
  1088. writew(dev.play_sample_rate, dev.SMA + SMA_wCalFreqAtoD);
  1089. writew(mastVolLeft, dev.SMA + SMA_wCurrMastVolLeft);
  1090. writew(mastVolRight, dev.SMA + SMA_wCurrMastVolRight);
  1091. #ifndef MSND_CLASSIC
  1092. writel(0x00010000, dev.SMA + SMA_dwCurrPlayPitch);
  1093. writel(0x00000001, dev.SMA + SMA_dwCurrPlayRate);
  1094. #endif
  1095. writew(0x303, dev.SMA + SMA_wCurrInputTagBits);
  1096. initted = 1;
  1097. return 0;
  1098. }
  1099. static int __init calibrate_adc(WORD srate)
  1100. {
  1101. writew(srate, dev.SMA + SMA_wCalFreqAtoD);
  1102. if (dev.calibrate_signal == 0)
  1103. writew(readw(dev.SMA + SMA_wCurrHostStatusFlags)
  1104. | 0x0001, dev.SMA + SMA_wCurrHostStatusFlags);
  1105. else
  1106. writew(readw(dev.SMA + SMA_wCurrHostStatusFlags)
  1107. & ~0x0001, dev.SMA + SMA_wCurrHostStatusFlags);
  1108. if (msnd_send_word(&dev, 0, 0, HDEXAR_CAL_A_TO_D) == 0 &&
  1109. chk_send_dsp_cmd(&dev, HDEX_AUX_REQ) == 0) {
  1110. current->state = TASK_INTERRUPTIBLE;
  1111. schedule_timeout(HZ / 3);
  1112. return 0;
  1113. }
  1114. printk(KERN_WARNING LOGNAME ": ADC calibration failed\n");
  1115. return -EIO;
  1116. }
  1117. static int upload_dsp_code(void)
  1118. {
  1119. msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
  1120. #ifndef HAVE_DSPCODEH
  1121. INITCODESIZE = mod_firmware_load(INITCODEFILE, &INITCODE);
  1122. if (!INITCODE) {
  1123. printk(KERN_ERR LOGNAME ": Error loading " INITCODEFILE);
  1124. return -EBUSY;
  1125. }
  1126. PERMCODESIZE = mod_firmware_load(PERMCODEFILE, &PERMCODE);
  1127. if (!PERMCODE) {
  1128. printk(KERN_ERR LOGNAME ": Error loading " PERMCODEFILE);
  1129. vfree(INITCODE);
  1130. return -EBUSY;
  1131. }
  1132. #endif
  1133. memcpy_toio(dev.base, PERMCODE, PERMCODESIZE);
  1134. if (msnd_upload_host(&dev, INITCODE, INITCODESIZE) < 0) {
  1135. printk(KERN_WARNING LOGNAME ": Error uploading to DSP\n");
  1136. return -ENODEV;
  1137. }
  1138. #ifdef HAVE_DSPCODEH
  1139. printk(KERN_INFO LOGNAME ": DSP firmware uploaded (resident)\n");
  1140. #else
  1141. printk(KERN_INFO LOGNAME ": DSP firmware uploaded\n");
  1142. #endif
  1143. #ifndef HAVE_DSPCODEH
  1144. vfree(INITCODE);
  1145. vfree(PERMCODE);
  1146. #endif
  1147. return 0;
  1148. }
  1149. #ifdef MSND_CLASSIC
  1150. static void reset_proteus(void)
  1151. {
  1152. msnd_outb(HPPRORESET_ON, dev.io + HP_PROR);
  1153. mdelay(TIME_PRO_RESET);
  1154. msnd_outb(HPPRORESET_OFF, dev.io + HP_PROR);
  1155. mdelay(TIME_PRO_RESET_DONE);
  1156. }
  1157. #endif
  1158. static int initialize(void)
  1159. {
  1160. int err, timeout;
  1161. #ifdef MSND_CLASSIC
  1162. msnd_outb(HPWAITSTATE_0, dev.io + HP_WAIT);
  1163. msnd_outb(HPBITMODE_16, dev.io + HP_BITM);
  1164. reset_proteus();
  1165. #endif
  1166. if ((err = init_sma()) < 0) {
  1167. printk(KERN_WARNING LOGNAME ": Cannot initialize SMA\n");
  1168. return err;
  1169. }
  1170. if ((err = reset_dsp()) < 0)
  1171. return err;
  1172. if ((err = upload_dsp_code()) < 0) {
  1173. printk(KERN_WARNING LOGNAME ": Cannot upload DSP code\n");
  1174. return err;
  1175. }
  1176. timeout = 200;
  1177. while (readw(dev.base)) {
  1178. mdelay(1);
  1179. if (!timeout--) {
  1180. printk(KERN_DEBUG LOGNAME ": DSP reset timeout\n");
  1181. return -EIO;
  1182. }
  1183. }
  1184. mixer_setup();
  1185. return 0;
  1186. }
  1187. static int dsp_full_reset(void)
  1188. {
  1189. int rv;
  1190. if (test_bit(F_RESETTING, &dev.flags) || ++dev.nresets > 10)
  1191. return 0;
  1192. set_bit(F_RESETTING, &dev.flags);
  1193. printk(KERN_INFO LOGNAME ": DSP reset\n");
  1194. dsp_halt(NULL); /* Unconditionally halt */
  1195. if ((rv = initialize()))
  1196. printk(KERN_WARNING LOGNAME ": DSP reset failed\n");
  1197. force_recsrc(dev.recsrc);
  1198. dsp_open(NULL);
  1199. clear_bit(F_RESETTING, &dev.flags);
  1200. return rv;
  1201. }
  1202. static int __init attach_multisound(void)
  1203. {
  1204. int err;
  1205. if ((err = request_irq(dev.irq, intr, 0, dev.name, &dev)) < 0) {
  1206. printk(KERN_ERR LOGNAME ": Couldn't grab IRQ %d\n", dev.irq);
  1207. return err;
  1208. }
  1209. request_region(dev.io, dev.numio, dev.name);
  1210. if ((err = dsp_full_reset()) < 0) {
  1211. release_region(dev.io, dev.numio);
  1212. free_irq(dev.irq, &dev);
  1213. return err;
  1214. }
  1215. if ((err = msnd_register(&dev)) < 0) {
  1216. printk(KERN_ERR LOGNAME ": Unable to register MultiSound\n");
  1217. release_region(dev.io, dev.numio);
  1218. free_irq(dev.irq, &dev);
  1219. return err;
  1220. }
  1221. if ((dev.dsp_minor = register_sound_dsp(&dev_fileops, -1)) < 0) {
  1222. printk(KERN_ERR LOGNAME ": Unable to register DSP operations\n");
  1223. msnd_unregister(&dev);
  1224. release_region(dev.io, dev.numio);
  1225. free_irq(dev.irq, &dev);
  1226. return dev.dsp_minor;
  1227. }
  1228. if ((dev.mixer_minor = register_sound_mixer(&dev_fileops, -1)) < 0) {
  1229. printk(KERN_ERR LOGNAME ": Unable to register mixer operations\n");
  1230. unregister_sound_mixer(dev.mixer_minor);
  1231. msnd_unregister(&dev);
  1232. release_region(dev.io, dev.numio);
  1233. free_irq(dev.irq, &dev);
  1234. return dev.mixer_minor;
  1235. }
  1236. dev.ext_midi_dev = dev.hdr_midi_dev = -1;
  1237. disable_irq(dev.irq);
  1238. calibrate_adc(dev.play_sample_rate);
  1239. #ifndef MSND_CLASSIC
  1240. force_recsrc(SOUND_MASK_IMIX);
  1241. #endif
  1242. return 0;
  1243. }
  1244. static void __exit unload_multisound(void)
  1245. {
  1246. release_region(dev.io, dev.numio);
  1247. free_irq(dev.irq, &dev);
  1248. unregister_sound_mixer(dev.mixer_minor);
  1249. unregister_sound_dsp(dev.dsp_minor);
  1250. msnd_unregister(&dev);
  1251. }
  1252. #ifndef MSND_CLASSIC
  1253. /* Pinnacle/Fiji Logical Device Configuration */
  1254. static int __init msnd_write_cfg(int cfg, int reg, int value)
  1255. {
  1256. msnd_outb(reg, cfg);
  1257. msnd_outb(value, cfg + 1);
  1258. if (value != msnd_inb(cfg + 1)) {
  1259. printk(KERN_ERR LOGNAME ": msnd_write_cfg: I/O error\n");
  1260. return -EIO;
  1261. }
  1262. return 0;
  1263. }
  1264. static int __init msnd_write_cfg_io0(int cfg, int num, WORD io)
  1265. {
  1266. if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
  1267. return -EIO;
  1268. if (msnd_write_cfg(cfg, IREG_IO0_BASEHI, HIBYTE(io)))
  1269. return -EIO;
  1270. if (msnd_write_cfg(cfg, IREG_IO0_BASELO, LOBYTE(io)))
  1271. return -EIO;
  1272. return 0;
  1273. }
  1274. static int __init msnd_write_cfg_io1(int cfg, int num, WORD io)
  1275. {
  1276. if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
  1277. return -EIO;
  1278. if (msnd_write_cfg(cfg, IREG_IO1_BASEHI, HIBYTE(io)))
  1279. return -EIO;
  1280. if (msnd_write_cfg(cfg, IREG_IO1_BASELO, LOBYTE(io)))
  1281. return -EIO;
  1282. return 0;
  1283. }
  1284. static int __init msnd_write_cfg_irq(int cfg, int num, WORD irq)
  1285. {
  1286. if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
  1287. return -EIO;
  1288. if (msnd_write_cfg(cfg, IREG_IRQ_NUMBER, LOBYTE(irq)))
  1289. return -EIO;
  1290. if (msnd_write_cfg(cfg, IREG_IRQ_TYPE, IRQTYPE_EDGE))
  1291. return -EIO;
  1292. return 0;
  1293. }
  1294. static int __init msnd_write_cfg_mem(int cfg, int num, int mem)
  1295. {
  1296. WORD wmem;
  1297. mem >>= 8;
  1298. mem &= 0xfff;
  1299. wmem = (WORD)mem;
  1300. if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
  1301. return -EIO;
  1302. if (msnd_write_cfg(cfg, IREG_MEMBASEHI, HIBYTE(wmem)))
  1303. return -EIO;
  1304. if (msnd_write_cfg(cfg, IREG_MEMBASELO, LOBYTE(wmem)))
  1305. return -EIO;
  1306. if (wmem && msnd_write_cfg(cfg, IREG_MEMCONTROL, (MEMTYPE_HIADDR | MEMTYPE_16BIT)))
  1307. return -EIO;
  1308. return 0;
  1309. }
  1310. static int __init msnd_activate_logical(int cfg, int num)
  1311. {
  1312. if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
  1313. return -EIO;
  1314. if (msnd_write_cfg(cfg, IREG_ACTIVATE, LD_ACTIVATE))
  1315. return -EIO;
  1316. return 0;
  1317. }
  1318. static int __init msnd_write_cfg_logical(int cfg, int num, WORD io0, WORD io1, WORD irq, int mem)
  1319. {
  1320. if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
  1321. return -EIO;
  1322. if (msnd_write_cfg_io0(cfg, num, io0))
  1323. return -EIO;
  1324. if (msnd_write_cfg_io1(cfg, num, io1))
  1325. return -EIO;
  1326. if (msnd_write_cfg_irq(cfg, num, irq))
  1327. return -EIO;
  1328. if (msnd_write_cfg_mem(cfg, num, mem))
  1329. return -EIO;
  1330. if (msnd_activate_logical(cfg, num))
  1331. return -EIO;
  1332. return 0;
  1333. }
  1334. typedef struct msnd_pinnacle_cfg_device {
  1335. WORD io0, io1, irq;
  1336. int mem;
  1337. } msnd_pinnacle_cfg_t[4];
  1338. static int __init msnd_pinnacle_cfg_devices(int cfg, int reset, msnd_pinnacle_cfg_t device)
  1339. {
  1340. int i;
  1341. /* Reset devices if told to */
  1342. if (reset) {
  1343. printk(KERN_INFO LOGNAME ": Resetting all devices\n");
  1344. for (i = 0; i < 4; ++i)
  1345. if (msnd_write_cfg_logical(cfg, i, 0, 0, 0, 0))
  1346. return -EIO;
  1347. }
  1348. /* Configure specified devices */
  1349. for (i = 0; i < 4; ++i) {
  1350. switch (i) {
  1351. case 0: /* DSP */
  1352. if (!(device[i].io0 && device[i].irq && device[i].mem))
  1353. continue;
  1354. break;
  1355. case 1: /* MPU */
  1356. if (!(device[i].io0 && device[i].irq))
  1357. continue;
  1358. printk(KERN_INFO LOGNAME
  1359. ": Configuring MPU to I/O 0x%x IRQ %d\n",
  1360. device[i].io0, device[i].irq);
  1361. break;
  1362. case 2: /* IDE */
  1363. if (!(device[i].io0 && device[i].io1 && device[i].irq))
  1364. continue;
  1365. printk(KERN_INFO LOGNAME
  1366. ": Configuring IDE to I/O 0x%x, 0x%x IRQ %d\n",
  1367. device[i].io0, device[i].io1, device[i].irq);
  1368. break;
  1369. case 3: /* Joystick */
  1370. if (!(device[i].io0))
  1371. continue;
  1372. printk(KERN_INFO LOGNAME
  1373. ": Configuring joystick to I/O 0x%x\n",
  1374. device[i].io0);
  1375. break;
  1376. }
  1377. /* Configure the device */
  1378. if (msnd_write_cfg_logical(cfg, i, device[i].io0, device[i].io1, device[i].irq, device[i].mem))
  1379. return -EIO;
  1380. }
  1381. return 0;
  1382. }
  1383. #endif
  1384. #ifdef MODULE
  1385. MODULE_AUTHOR ("Andrew Veliath <andrewtv@usa.net>");
  1386. MODULE_DESCRIPTION ("Turtle Beach " LONGNAME " Linux Driver");
  1387. MODULE_LICENSE("GPL");
  1388. static int io __initdata = -1;
  1389. static int irq __initdata = -1;
  1390. static int mem __initdata = -1;
  1391. static int write_ndelay __initdata = -1;
  1392. #ifndef MSND_CLASSIC
  1393. /* Pinnacle/Fiji non-PnP Config Port */
  1394. static int cfg __initdata = -1;
  1395. /* Extra Peripheral Configuration */
  1396. static int reset __initdata = 0;
  1397. static int mpu_io __initdata = 0;
  1398. static int mpu_irq __initdata = 0;
  1399. static int ide_io0 __initdata = 0;
  1400. static int ide_io1 __initdata = 0;
  1401. static int ide_irq __initdata = 0;
  1402. static int joystick_io __initdata = 0;
  1403. /* If we have the digital daugherboard... */
  1404. static int digital __initdata = 0;
  1405. #endif
  1406. static int fifosize __initdata = DEFFIFOSIZE;
  1407. static int calibrate_signal __initdata = 0;
  1408. #else /* not a module */
  1409. static int write_ndelay __initdata = -1;
  1410. #ifdef MSND_CLASSIC
  1411. static int io __initdata = CONFIG_MSNDCLAS_IO;
  1412. static int irq __initdata = CONFIG_MSNDCLAS_IRQ;
  1413. static int mem __initdata = CONFIG_MSNDCLAS_MEM;
  1414. #else /* Pinnacle/Fiji */
  1415. static int io __initdata = CONFIG_MSNDPIN_IO;
  1416. static int irq __initdata = CONFIG_MSNDPIN_IRQ;
  1417. static int mem __initdata = CONFIG_MSNDPIN_MEM;
  1418. /* Pinnacle/Fiji non-PnP Config Port */
  1419. #ifdef CONFIG_MSNDPIN_NONPNP
  1420. # ifndef CONFIG_MSNDPIN_CFG
  1421. # define CONFIG_MSNDPIN_CFG 0x250
  1422. # endif
  1423. #else
  1424. # ifdef CONFIG_MSNDPIN_CFG
  1425. # undef CONFIG_MSNDPIN_CFG
  1426. # endif
  1427. # define CONFIG_MSNDPIN_CFG -1
  1428. #endif
  1429. static int cfg __initdata = CONFIG_MSNDPIN_CFG;
  1430. /* If not a module, we don't need to bother with reset=1 */
  1431. static int reset;
  1432. /* Extra Peripheral Configuration (Default: Disable) */
  1433. #ifndef CONFIG_MSNDPIN_MPU_IO
  1434. # define CONFIG_MSNDPIN_MPU_IO 0
  1435. #endif
  1436. static int mpu_io __initdata = CONFIG_MSNDPIN_MPU_IO;
  1437. #ifndef CONFIG_MSNDPIN_MPU_IRQ
  1438. # define CONFIG_MSNDPIN_MPU_IRQ 0
  1439. #endif
  1440. static int mpu_irq __initdata = CONFIG_MSNDPIN_MPU_IRQ;
  1441. #ifndef CONFIG_MSNDPIN_IDE_IO0
  1442. # define CONFIG_MSNDPIN_IDE_IO0 0
  1443. #endif
  1444. static int ide_io0 __initdata = CONFIG_MSNDPIN_IDE_IO0;
  1445. #ifndef CONFIG_MSNDPIN_IDE_IO1
  1446. # define CONFIG_MSNDPIN_IDE_IO1 0
  1447. #endif
  1448. static int ide_io1 __initdata = CONFIG_MSNDPIN_IDE_IO1;
  1449. #ifndef CONFIG_MSNDPIN_IDE_IRQ
  1450. # define CONFIG_MSNDPIN_IDE_IRQ 0
  1451. #endif
  1452. static int ide_irq __initdata = CONFIG_MSNDPIN_IDE_IRQ;
  1453. #ifndef CONFIG_MSNDPIN_JOYSTICK_IO
  1454. # define CONFIG_MSNDPIN_JOYSTICK_IO 0
  1455. #endif
  1456. static int joystick_io __initdata = CONFIG_MSNDPIN_JOYSTICK_IO;
  1457. /* Have SPDIF (Digital) Daughterboard */
  1458. #ifndef CONFIG_MSNDPIN_DIGITAL
  1459. # define CONFIG_MSNDPIN_DIGITAL 0
  1460. #endif
  1461. static int digital __initdata = CONFIG_MSNDPIN_DIGITAL;
  1462. #endif /* MSND_CLASSIC */
  1463. #ifndef CONFIG_MSND_FIFOSIZE
  1464. # define CONFIG_MSND_FIFOSIZE DEFFIFOSIZE
  1465. #endif
  1466. static int fifosize __initdata = CONFIG_MSND_FIFOSIZE;
  1467. #ifndef CONFIG_MSND_CALSIGNAL
  1468. # define CONFIG_MSND_CALSIGNAL 0
  1469. #endif
  1470. static int
  1471. calibrate_signal __initdata = CONFIG_MSND_CALSIGNAL;
  1472. #endif /* MODULE */
  1473. module_param (io, int, 0);
  1474. module_param (irq, int, 0);
  1475. module_param (mem, int, 0);
  1476. module_param (write_ndelay, int, 0);
  1477. module_param (fifosize, int, 0);
  1478. module_param (calibrate_signal, int, 0);
  1479. #ifndef MSND_CLASSIC
  1480. module_param (digital, bool, 0);
  1481. module_param (cfg, int, 0);
  1482. module_param (reset, int, 0);
  1483. module_param (mpu_io, int, 0);
  1484. module_param (mpu_irq, int, 0);
  1485. module_param (ide_io0, int, 0);
  1486. module_param (ide_io1, int, 0);
  1487. module_param (ide_irq, int, 0);
  1488. module_param (joystick_io, int, 0);
  1489. #endif
  1490. static int __init msnd_init(void)
  1491. {
  1492. int err;
  1493. #ifndef MSND_CLASSIC
  1494. static msnd_pinnacle_cfg_t pinnacle_devs;
  1495. #endif /* MSND_CLASSIC */
  1496. printk(KERN_INFO LOGNAME ": Turtle Beach " LONGNAME " Linux Driver Version "
  1497. VERSION ", Copyright (C) 1998 Andrew Veliath\n");
  1498. if (io == -1 || irq == -1 || mem == -1)
  1499. printk(KERN_WARNING LOGNAME ": io, irq and mem must be set\n");
  1500. #ifdef MSND_CLASSIC
  1501. if (io == -1 ||
  1502. !(io == 0x290 ||
  1503. io == 0x260 ||
  1504. io == 0x250 ||
  1505. io == 0x240 ||
  1506. io == 0x230 ||
  1507. io == 0x220 ||
  1508. io == 0x210 ||
  1509. io == 0x3e0)) {
  1510. printk(KERN_ERR LOGNAME ": \"io\" - DSP I/O base must be set to 0x210, 0x220, 0x230, 0x240, 0x250, 0x260, 0x290, or 0x3E0\n");
  1511. return -EINVAL;
  1512. }
  1513. #else
  1514. if (io == -1 ||
  1515. io < 0x100 ||
  1516. io > 0x3e0 ||
  1517. (io % 0x10) != 0) {
  1518. printk(KERN_ERR LOGNAME ": \"io\" - DSP I/O base must within the range 0x100 to 0x3E0 and must be evenly divisible by 0x10\n");
  1519. return -EINVAL;
  1520. }
  1521. #endif /* MSND_CLASSIC */
  1522. if (irq == -1 ||
  1523. !(irq == 5 ||
  1524. irq == 7 ||
  1525. irq == 9 ||
  1526. irq == 10 ||
  1527. irq == 11 ||
  1528. irq == 12)) {
  1529. printk(KERN_ERR LOGNAME ": \"irq\" - must be set to 5, 7, 9, 10, 11 or 12\n");
  1530. return -EINVAL;
  1531. }
  1532. if (mem == -1 ||
  1533. !(mem == 0xb0000 ||
  1534. mem == 0xc8000 ||
  1535. mem == 0xd0000 ||
  1536. mem == 0xd8000 ||
  1537. mem == 0xe0000 ||
  1538. mem == 0xe8000)) {
  1539. printk(KERN_ERR LOGNAME ": \"mem\" - must be set to "
  1540. "0xb0000, 0xc8000, 0xd0000, 0xd8000, 0xe0000 or 0xe8000\n");
  1541. return -EINVAL;
  1542. }
  1543. #ifdef MSND_CLASSIC
  1544. switch (irq) {
  1545. case 5: dev.irqid = HPIRQ_5; break;
  1546. case 7: dev.irqid = HPIRQ_7; break;
  1547. case 9: dev.irqid = HPIRQ_9; break;
  1548. case 10: dev.irqid = HPIRQ_10; break;
  1549. case 11: dev.irqid = HPIRQ_11; break;
  1550. case 12: dev.irqid = HPIRQ_12; break;
  1551. }
  1552. switch (mem) {
  1553. case 0xb0000: dev.memid = HPMEM_B000; break;
  1554. case 0xc8000: dev.memid = HPMEM_C800; break;
  1555. case 0xd0000: dev.memid = HPMEM_D000; break;
  1556. case 0xd8000: dev.memid = HPMEM_D800; break;
  1557. case 0xe0000: dev.memid = HPMEM_E000; break;
  1558. case 0xe8000: dev.memid = HPMEM_E800; break;
  1559. }
  1560. #else
  1561. if (cfg == -1) {
  1562. printk(KERN_INFO LOGNAME ": Assuming PnP mode\n");
  1563. } else if (cfg != 0x250 && cfg != 0x260 && cfg != 0x270) {
  1564. printk(KERN_INFO LOGNAME ": Config port must be 0x250, 0x260 or 0x270 (or unspecified for PnP mode)\n");
  1565. return -EINVAL;
  1566. } else {
  1567. printk(KERN_INFO LOGNAME ": Non-PnP mode: configuring at port 0x%x\n", cfg);
  1568. /* DSP */
  1569. pinnacle_devs[0].io0 = io;
  1570. pinnacle_devs[0].irq = irq;
  1571. pinnacle_devs[0].mem = mem;
  1572. /* The following are Pinnacle specific */
  1573. /* MPU */
  1574. pinnacle_devs[1].io0 = mpu_io;
  1575. pinnacle_devs[1].irq = mpu_irq;
  1576. /* IDE */
  1577. pinnacle_devs[2].io0 = ide_io0;
  1578. pinnacle_devs[2].io1 = ide_io1;
  1579. pinnacle_devs[2].irq = ide_irq;
  1580. /* Joystick */
  1581. pinnacle_devs[3].io0 = joystick_io;
  1582. if (!request_region(cfg, 2, "Pinnacle/Fiji Config")) {
  1583. printk(KERN_ERR LOGNAME ": Config port 0x%x conflict\n", cfg);
  1584. return -EIO;
  1585. }
  1586. if (msnd_pinnacle_cfg_devices(cfg, reset, pinnacle_devs)) {
  1587. printk(KERN_ERR LOGNAME ": Device configuration error\n");
  1588. release_region(cfg, 2);
  1589. return -EIO;
  1590. }
  1591. release_region(cfg, 2);
  1592. }
  1593. #endif /* MSND_CLASSIC */
  1594. if (fifosize < 16)
  1595. fifosize = 16;
  1596. if (fifosize > 1024)
  1597. fifosize = 1024;
  1598. set_default_audio_parameters();
  1599. #ifdef MSND_CLASSIC
  1600. dev.type = msndClassic;
  1601. #else
  1602. dev.type = msndPinnacle;
  1603. #endif
  1604. dev.io = io;
  1605. dev.numio = DSP_NUMIO;
  1606. dev.irq = irq;
  1607. dev.base = ioremap(mem, 0x8000);
  1608. dev.fifosize = fifosize * 1024;
  1609. dev.calibrate_signal = calibrate_signal ? 1 : 0;
  1610. dev.recsrc = 0;
  1611. dev.dspq_data_buff = DSPQ_DATA_BUFF;
  1612. dev.dspq_buff_size = DSPQ_BUFF_SIZE;
  1613. if (write_ndelay == -1)
  1614. write_ndelay = CONFIG_MSND_WRITE_NDELAY;
  1615. if (write_ndelay)
  1616. clear_bit(F_DISABLE_WRITE_NDELAY, &dev.flags);
  1617. else
  1618. set_bit(F_DISABLE_WRITE_NDELAY, &dev.flags);
  1619. #ifndef MSND_CLASSIC
  1620. if (digital)
  1621. set_bit(F_HAVEDIGITAL, &dev.flags);
  1622. #endif
  1623. init_waitqueue_head(&dev.writeblock);
  1624. init_waitqueue_head(&dev.readblock);
  1625. init_waitqueue_head(&dev.writeflush);
  1626. msnd_fifo_init(&dev.DAPF);
  1627. msnd_fifo_init(&dev.DARF);
  1628. spin_lock_init(&dev.lock);
  1629. printk(KERN_INFO LOGNAME ": %u byte audio FIFOs (x2)\n", dev.fifosize);
  1630. if ((err = msnd_fifo_alloc(&dev.DAPF, dev.fifosize)) < 0) {
  1631. printk(KERN_ERR LOGNAME ": Couldn't allocate write FIFO\n");
  1632. return err;
  1633. }
  1634. if ((err = msnd_fifo_alloc(&dev.DARF, dev.fifosize)) < 0) {
  1635. printk(KERN_ERR LOGNAME ": Couldn't allocate read FIFO\n");
  1636. msnd_fifo_free(&dev.DAPF);
  1637. return err;
  1638. }
  1639. if ((err = probe_multisound()) < 0) {
  1640. printk(KERN_ERR LOGNAME ": Probe failed\n");
  1641. msnd_fifo_free(&dev.DAPF);
  1642. msnd_fifo_free(&dev.DARF);
  1643. return err;
  1644. }
  1645. if ((err = attach_multisound()) < 0) {
  1646. printk(KERN_ERR LOGNAME ": Attach failed\n");
  1647. msnd_fifo_free(&dev.DAPF);
  1648. msnd_fifo_free(&dev.DARF);
  1649. return err;
  1650. }
  1651. return 0;
  1652. }
  1653. static void __exit msdn_cleanup(void)
  1654. {
  1655. unload_multisound();
  1656. msnd_fifo_free(&dev.DAPF);
  1657. msnd_fifo_free(&dev.DARF);
  1658. }
  1659. module_init(msnd_init);
  1660. module_exit(msdn_cleanup);