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