1/* 2 * Audio Command Interface (ACI) driver (sound/aci.c) 3 * 4 * ACI is a protocol used to communicate with the microcontroller on 5 * some sound cards produced by miro, e.g. the miroSOUND PCM12 and 6 * PCM20. The ACI has been developed for miro by Norberto Pellicci 7 * <pellicci@home.com>. Special thanks to both him and miro for 8 * providing the ACI specification. 9 * 10 * The main function of the ACI is to control the mixer and to get a 11 * product identification. On the PCM20, ACI also controls the radio 12 * tuner on this card, this is supported in the Video for Linux 13 * miropcm20 driver. 14 * - 15 * This is a fullfeatured implementation. Unsupported features 16 * are bugs... (: 17 * 18 * It is not longer necessary to load the mad16 module first. The 19 * user is currently responsible to set the mad16 mixer correctly. 20 * 21 * To toggle the solo mode for full duplex operation just use the OSS 22 * record switch for the pcm ('wave') controller. Robert 23 * - 24 * 25 * Revision history: 26 * 27 * 1995-11-10 Markus Kuhn <mskuhn@cip.informatik.uni-erlangen.de> 28 * First version written. 29 * 1995-12-31 Markus Kuhn 30 * Second revision, general code cleanup. 31 * 1996-05-16 Hannu Savolainen 32 * Integrated with other parts of the driver. 33 * 1996-05-28 Markus Kuhn 34 * Initialize CS4231A mixer, make ACI first mixer, 35 * use new private mixer API for solo mode. 36 * 1998-08-18 Ruurd Reitsma <R.A.Reitsma@wbmt.tudelft.nl> 37 * Small modification to export ACI functions and 38 * complete modularisation. 39 * 2000-06-20 Robert Siemer <Robert.Siemer@gmx.de> 40 * Don't initialize the CS4231A mixer anymore, so the code is 41 * working again, and other small changes to fit in todays 42 * kernels. 43 * 2000-08-26 Robert Siemer 44 * Clean up and rewrite for 2.4.x. Maybe it's SMP safe now... (: 45 * ioctl bugfix, and integration of solo-mode into OSS-API, 46 * added (OSS-limited) equalizer support, return value bugfix, 47 * changed param aci_reset to reset, new params: ide, wss. 48 * 2001-04-20 Robert Siemer 49 * even more cleanups... 50 * 2001-10-08 Arnaldo Carvalho de Melo <acme@conectiva.com.br> 51 * Get rid of check_region, .bss optimizations, use set_current_state 52 */ 53 54#include <linux/kernel.h> 55#include <linux/init.h> 56#include <linux/module.h> 57#include <linux/proc_fs.h> 58#include <linux/slab.h> 59#include <linux/mutex.h> 60 61#include <asm/io.h> 62#include <asm/uaccess.h> 63#include "sound_config.h" 64 65int aci_port; /* as determined by bit 4 in the OPTi 929 MC4 register */ 66static int aci_idcode[2]; /* manufacturer and product ID */ 67int aci_version; /* ACI firmware version */ 68 69EXPORT_SYMBOL(aci_port); 70EXPORT_SYMBOL(aci_version); 71 72#include "aci.h" 73 74 75static int aci_solo; /* status bit of the card that can't be * 76 * checked with ACI versions prior to 0xb0 */ 77static int aci_amp; /* status bit for power-amp/line-out level 78 but I have no docs about what is what... */ 79static int aci_micpreamp=3; /* microphone preamp-level that can't be * 80 * checked with ACI versions prior to 0xb0 */ 81 82static int mixer_device; 83static struct mutex aci_mutex; 84 85#ifdef MODULE 86static int reset; 87module_param(reset, bool, 0); 88MODULE_PARM_DESC(reset,"When set to 1, reset aci mixer."); 89#else 90static int reset = 1; 91#endif 92 93static int ide=-1; 94module_param(ide, int, 0); 95MODULE_PARM_DESC(ide,"1 enable, 0 disable ide-port - untested" 96 " default: do nothing"); 97static int wss=-1; 98module_param(wss, int, 0); 99MODULE_PARM_DESC(wss,"change between ACI/WSS-mixer; use 0 and 1 - untested" 100 " default: do nothing; for PCM1-pro only"); 101 102#ifdef DEBUG 103static void print_bits(unsigned char c) 104{ 105 int j; 106 printk(KERN_DEBUG "aci: "); 107 108 for (j=7; j>=0; j--) { 109 printk("%d", (c >> j) & 0x1); 110 } 111 112 printk("\n"); 113} 114#endif 115 116/* 117 * This busy wait code normally requires less than 15 loops and 118 * practically always less than 100 loops on my i486/DX2 66 MHz. 119 * 120 * Warning: Waiting on the general status flag after reseting the MUTE 121 * function can take a VERY long time, because the PCM12 does some kind 122 * of fade-in effect. For this reason, access to the MUTE function has 123 * not been implemented at all. 124 * 125 * - The OSS interface has no mute option. It takes about 3 seconds to 126 * fade-in on my PCM20. busy_wait() handles it great now... Robert 127 */ 128 129static int busy_wait(void) 130{ 131 #define MINTIME 500 132 long timeout; 133 unsigned char byte; 134 135 for (timeout = 1; timeout <= MINTIME+30; timeout++) { 136 if (((byte=inb(BUSY_REGISTER)) & 1) == 0) { 137 if (timeout >= MINTIME) 138 printk(KERN_DEBUG "aci: Got READYFLAG in round %ld.\n", timeout-MINTIME); 139 return byte; 140 } 141 if (timeout >= MINTIME) { 142 long out=10*HZ; 143 switch (timeout-MINTIME) { 144 case 0 ... 9: 145 out /= 10; 146 case 10 ... 19: 147 out /= 10; 148 case 20 ... 30: 149 out /= 10; 150 default: 151 set_current_state(TASK_UNINTERRUPTIBLE); 152 schedule_timeout(out); 153 break; 154 } 155 } 156 } 157 printk(KERN_WARNING "aci: busy_wait() time out.\n"); 158 return -EBUSY; 159} 160 161/* The four ACI command types are fucked up. [-: 162 * implied is: 1w - special case for INIT 163 * write is: 2w1r 164 * read is: x(1w1r) where x is 1 or 2 (1 CHECK_SIG, 1 CHECK_STER, 165 * 1 VERSION, 2 IDCODE) 166 * the command is only in the first write, rest is protocol overhead 167 * 168 * indexed is technically a write and used for STATUS 169 * and the special case for TUNE is: 3w1r 170 * 171 * Here the new general sheme: TUNE --> aci_rw_cmd(x, y, z) 172 * indexed and write --> aci_rw_cmd(x, y, -1) 173 * implied and read (x=1) --> aci_rw_cmd(x, -1, -1) 174 * 175 * Read (x>=2) is not implemented (only used during initialization). 176 * Use aci_idcode[2] and aci_version... Robert 177 */ 178 179/* Some notes for error detection: theoretically it is possible. 180 * But it doubles the I/O-traffic from ww(r) to wwwrw(r) in the normal 181 * case and doesn't seem to be designed for that... Robert 182 */ 183 184static inline int aci_rawwrite(unsigned char byte) 185{ 186 if (busy_wait() >= 0) { 187#ifdef DEBUG 188 printk(KERN_DEBUG "aci_rawwrite(%d)\n", byte); 189#endif 190 outb(byte, COMMAND_REGISTER); 191 return 0; 192 } else 193 return -EBUSY; 194} 195 196static inline int aci_rawread(void) 197{ 198 unsigned char byte; 199 200 if (busy_wait() >= 0) { 201 byte=inb(STATUS_REGISTER); 202#ifdef DEBUG 203 printk(KERN_DEBUG "%d = aci_rawread()\n", byte); 204#endif 205 return byte; 206 } else 207 return -EBUSY; 208} 209 210 211int aci_rw_cmd(int write1, int write2, int write3) 212{ 213 int write[] = {write1, write2, write3}; 214 int read = -EINTR, i; 215 216 if (mutex_lock_interruptible(&aci_mutex)) 217 goto out; 218 219 for (i=0; i<3; i++) { 220 if (write[i]< 0 || write[i] > 255) 221 break; 222 else { 223 read = aci_rawwrite(write[i]); 224 if (read < 0) 225 goto out_up; 226 } 227 228 } 229 230 read = aci_rawread(); 231out_up: mutex_unlock(&aci_mutex); 232out: return read; 233} 234 235EXPORT_SYMBOL(aci_rw_cmd); 236 237static int setvolume(int __user *arg, 238 unsigned char left_index, unsigned char right_index) 239{ 240 int vol, ret, uservol, buf; 241 242 __get_user(uservol, arg); 243 244 /* left channel */ 245 vol = uservol & 0xff; 246 if (vol > 100) 247 vol = 100; 248 vol = SCALE(100, 0x20, vol); 249 if ((buf=aci_write_cmd(left_index, 0x20 - vol))<0) 250 return buf; 251 ret = SCALE(0x20, 100, vol); 252 253 254 /* right channel */ 255 vol = (uservol >> 8) & 0xff; 256 if (vol > 100) 257 vol = 100; 258 vol = SCALE(100, 0x20, vol); 259 if ((buf=aci_write_cmd(right_index, 0x20 - vol))<0) 260 return buf; 261 ret |= SCALE(0x20, 100, vol) << 8; 262 263 __put_user(ret, arg); 264 265 return 0; 266} 267 268static int getvolume(int __user *arg, 269 unsigned char left_index, unsigned char right_index) 270{ 271 int vol; 272 int buf; 273 274 /* left channel */ 275 if ((buf=aci_indexed_cmd(ACI_STATUS, left_index))<0) 276 return buf; 277 vol = SCALE(0x20, 100, buf < 0x20 ? 0x20-buf : 0); 278 279 /* right channel */ 280 if ((buf=aci_indexed_cmd(ACI_STATUS, right_index))<0) 281 return buf; 282 vol |= SCALE(0x20, 100, buf < 0x20 ? 0x20-buf : 0) << 8; 283 284 __put_user(vol, arg); 285 286 return 0; 287} 288 289 290/* The equalizer is somewhat strange on the ACI. From -12dB to +12dB 291 * write: 0xff..down.to..0x80==0x00..up.to..0x7f 292 */ 293 294static inline unsigned int eq_oss2aci(unsigned int vol) 295{ 296 int boost=0; 297 unsigned int ret; 298 299 if (vol > 100) 300 vol = 100; 301 if (vol > 50) { 302 vol -= 51; 303 boost=1; 304 } 305 if (boost) 306 ret=SCALE(49, 0x7e, vol)+1; 307 else 308 ret=0xff - SCALE(50, 0x7f, vol); 309 return ret; 310} 311 312static inline unsigned int eq_aci2oss(unsigned int vol) 313{ 314 if (vol < 0x80) 315 return SCALE(0x7f, 50, vol) + 50; 316 else 317 return SCALE(0x7f, 50, 0xff-vol); 318} 319 320 321static int setequalizer(int __user *arg, 322 unsigned char left_index, unsigned char right_index) 323{ 324 int buf; 325 unsigned int vol; 326 327 __get_user(vol, arg); 328 329 /* left channel */ 330 if ((buf=aci_write_cmd(left_index, eq_oss2aci(vol & 0xff)))<0) 331 return buf; 332 333 /* right channel */ 334 if ((buf=aci_write_cmd(right_index, eq_oss2aci((vol>>8) & 0xff)))<0) 335 return buf; 336 337 /* the ACI equalizer is more precise */ 338 return 0; 339} 340 341static int getequalizer(int __user *arg, 342 unsigned char left_index, unsigned char right_index) 343{ 344 int buf; 345 unsigned int vol; 346 347 /* left channel */ 348 if ((buf=aci_indexed_cmd(ACI_STATUS, left_index))<0) 349 return buf; 350 vol = eq_aci2oss(buf); 351 352 /* right channel */ 353 if ((buf=aci_indexed_cmd(ACI_STATUS, right_index))<0) 354 return buf; 355 vol |= eq_aci2oss(buf) << 8; 356 357 __put_user(vol, arg); 358 359 return 0; 360} 361 362static int aci_mixer_ioctl (int dev, unsigned int cmd, void __user * arg) 363{ 364 int vol, buf; 365 int __user *p = arg; 366 367 switch (cmd) { 368 case SOUND_MIXER_WRITE_VOLUME: 369 return setvolume(p, 0x01, 0x00); 370 case SOUND_MIXER_WRITE_CD: 371 return setvolume(p, 0x3c, 0x34); 372 case SOUND_MIXER_WRITE_MIC: 373 return setvolume(p, 0x38, 0x30); 374 case SOUND_MIXER_WRITE_LINE: 375 return setvolume(p, 0x39, 0x31); 376 case SOUND_MIXER_WRITE_SYNTH: 377 return setvolume(p, 0x3b, 0x33); 378 case SOUND_MIXER_WRITE_PCM: 379 return setvolume(p, 0x3a, 0x32); 380 case MIXER_WRITE(SOUND_MIXER_RADIO): /* fall through */ 381 case SOUND_MIXER_WRITE_LINE1: /* AUX1 or radio */ 382 return setvolume(p, 0x3d, 0x35); 383 case SOUND_MIXER_WRITE_LINE2: /* AUX2 */ 384 return setvolume(p, 0x3e, 0x36); 385 case SOUND_MIXER_WRITE_BASS: /* set band one and two */ 386 if (aci_idcode[1]=='C') { 387 if ((buf=setequalizer(p, 0x48, 0x40)) || 388 (buf=setequalizer(p, 0x49, 0x41))); 389 return buf; 390 } 391 break; 392 case SOUND_MIXER_WRITE_TREBLE: /* set band six and seven */ 393 if (aci_idcode[1]=='C') { 394 if ((buf=setequalizer(p, 0x4d, 0x45)) || 395 (buf=setequalizer(p, 0x4e, 0x46))); 396 return buf; 397 } 398 break; 399 case SOUND_MIXER_WRITE_IGAIN: /* MIC pre-amp */ 400 if (aci_idcode[1]=='B' || aci_idcode[1]=='C') { 401 __get_user(vol, p); 402 vol = vol & 0xff; 403 if (vol > 100) 404 vol = 100; 405 vol = SCALE(100, 3, vol); 406 if ((buf=aci_write_cmd(ACI_WRITE_IGAIN, vol))<0) 407 return buf; 408 aci_micpreamp = vol; 409 vol = SCALE(3, 100, vol); 410 vol |= (vol << 8); 411 __put_user(vol, p); 412 return 0; 413 } 414 break; 415 case SOUND_MIXER_WRITE_OGAIN: /* Power-amp/line-out level */ 416 if (aci_idcode[1]=='A' || aci_idcode[1]=='B') { 417 __get_user(buf, p); 418 buf = buf & 0xff; 419 if (buf > 50) 420 vol = 1; 421 else 422 vol = 0; 423 if ((buf=aci_write_cmd(ACI_SET_POWERAMP, vol))<0) 424 return buf; 425 aci_amp = vol; 426 if (aci_amp) 427 buf = (100 || 100<<8); 428 else 429 buf = 0; 430 __put_user(buf, p); 431 return 0; 432 } 433 break; 434 case SOUND_MIXER_WRITE_RECSRC: 435 /* handle solo mode control */ 436 __get_user(buf, p); 437 /* unset solo when RECSRC for PCM is requested */ 438 if (aci_idcode[1]=='B' || aci_idcode[1]=='C') { 439 vol = !(buf & SOUND_MASK_PCM); 440 if ((buf=aci_write_cmd(ACI_SET_SOLOMODE, vol))<0) 441 return buf; 442 aci_solo = vol; 443 } 444 buf = (SOUND_MASK_CD| SOUND_MASK_MIC| SOUND_MASK_LINE| 445 SOUND_MASK_SYNTH| SOUND_MASK_LINE2); 446 if (aci_idcode[1] == 'C') /* PCM20 radio */ 447 buf |= SOUND_MASK_RADIO; 448 else 449 buf |= SOUND_MASK_LINE1; 450 if (!aci_solo) 451 buf |= SOUND_MASK_PCM; 452 __put_user(buf, p); 453 return 0; 454 case SOUND_MIXER_READ_DEVMASK: 455 buf = (SOUND_MASK_VOLUME | SOUND_MASK_CD | 456 SOUND_MASK_MIC | SOUND_MASK_LINE | 457 SOUND_MASK_SYNTH | SOUND_MASK_PCM | 458 SOUND_MASK_LINE2); 459 switch (aci_idcode[1]) { 460 case 'C': /* PCM20 radio */ 461 buf |= (SOUND_MASK_RADIO | SOUND_MASK_IGAIN | 462 SOUND_MASK_BASS | SOUND_MASK_TREBLE); 463 break; 464 case 'B': /* PCM12 */ 465 buf |= (SOUND_MASK_LINE1 | SOUND_MASK_IGAIN | 466 SOUND_MASK_OGAIN); 467 break; 468 case 'A': /* PCM1-pro */ 469 buf |= (SOUND_MASK_LINE1 | SOUND_MASK_OGAIN); 470 break; 471 default: 472 buf |= SOUND_MASK_LINE1; 473 } 474 __put_user(buf, p); 475 return 0; 476 case SOUND_MIXER_READ_STEREODEVS: 477 buf = (SOUND_MASK_VOLUME | SOUND_MASK_CD | 478 SOUND_MASK_MIC | SOUND_MASK_LINE | 479 SOUND_MASK_SYNTH | SOUND_MASK_PCM | 480 SOUND_MASK_LINE2); 481 switch (aci_idcode[1]) { 482 case 'C': /* PCM20 radio */ 483 buf |= (SOUND_MASK_RADIO | 484 SOUND_MASK_BASS | SOUND_MASK_TREBLE); 485 break; 486 default: 487 buf |= SOUND_MASK_LINE1; 488 } 489 __put_user(buf, p); 490 return 0; 491 case SOUND_MIXER_READ_RECMASK: 492 buf = (SOUND_MASK_CD| SOUND_MASK_MIC| SOUND_MASK_LINE| 493 SOUND_MASK_SYNTH| SOUND_MASK_LINE2| SOUND_MASK_PCM); 494 if (aci_idcode[1] == 'C') /* PCM20 radio */ 495 buf |= SOUND_MASK_RADIO; 496 else 497 buf |= SOUND_MASK_LINE1; 498 499 __put_user(buf, p); 500 return 0; 501 case SOUND_MIXER_READ_RECSRC: 502 buf = (SOUND_MASK_CD | SOUND_MASK_MIC | SOUND_MASK_LINE | 503 SOUND_MASK_SYNTH | SOUND_MASK_LINE2); 504 /* do we need aci_solo or can I get it from the ACI? */ 505 switch (aci_idcode[1]) { 506 case 'B': /* PCM12 */ 507 case 'C': /* PCM20 radio */ 508 if (aci_version >= 0xb0) { 509 if ((vol=aci_rw_cmd(ACI_STATUS, 510 ACI_S_GENERAL, -1))<0) 511 return vol; 512 if (vol & 0x20) 513 buf |= SOUND_MASK_PCM; 514 } 515 else 516 if (!aci_solo) 517 buf |= SOUND_MASK_PCM; 518 break; 519 default: 520 buf |= SOUND_MASK_PCM; 521 } 522 if (aci_idcode[1] == 'C') /* PCM20 radio */ 523 buf |= SOUND_MASK_RADIO; 524 else 525 buf |= SOUND_MASK_LINE1; 526 527 __put_user(buf, p); 528 return 0; 529 case SOUND_MIXER_READ_CAPS: 530 __put_user(0, p); 531 return 0; 532 case SOUND_MIXER_READ_VOLUME: 533 return getvolume(p, 0x04, 0x03); 534 case SOUND_MIXER_READ_CD: 535 return getvolume(p, 0x0a, 0x09); 536 case SOUND_MIXER_READ_MIC: 537 return getvolume(p, 0x06, 0x05); 538 case SOUND_MIXER_READ_LINE: 539 return getvolume(p, 0x08, 0x07); 540 case SOUND_MIXER_READ_SYNTH: 541 return getvolume(p, 0x0c, 0x0b); 542 case SOUND_MIXER_READ_PCM: 543 return getvolume(p, 0x0e, 0x0d); 544 case MIXER_READ(SOUND_MIXER_RADIO): /* fall through */ 545 case SOUND_MIXER_READ_LINE1: /* AUX1 */ 546 return getvolume(p, 0x11, 0x10); 547 case SOUND_MIXER_READ_LINE2: /* AUX2 */ 548 return getvolume(p, 0x13, 0x12); 549 case SOUND_MIXER_READ_BASS: /* get band one */ 550 if (aci_idcode[1]=='C') { 551 return getequalizer(p, 0x23, 0x22); 552 } 553 break; 554 case SOUND_MIXER_READ_TREBLE: /* get band seven */ 555 if (aci_idcode[1]=='C') { 556 return getequalizer(p, 0x2f, 0x2e); 557 } 558 break; 559 case SOUND_MIXER_READ_IGAIN: /* MIC pre-amp */ 560 if (aci_idcode[1]=='B' || aci_idcode[1]=='C') { 561 /* aci_micpreamp or ACI? */ 562 if (aci_version >= 0xb0) { 563 if ((buf=aci_indexed_cmd(ACI_STATUS, 564 ACI_S_READ_IGAIN))<0) 565 return buf; 566 } 567 else 568 buf=aci_micpreamp; 569 vol = SCALE(3, 100, buf <= 3 ? buf : 3); 570 vol |= vol << 8; 571 __put_user(vol, p); 572 return 0; 573 } 574 break; 575 case SOUND_MIXER_READ_OGAIN: 576 if (aci_amp) 577 buf = (100 || 100<<8); 578 else 579 buf = 0; 580 __put_user(buf, p); 581 return 0; 582 } 583 return -EINVAL; 584} 585 586static struct mixer_operations aci_mixer_operations = 587{ 588 .owner = THIS_MODULE, 589 .id = "ACI", 590 .ioctl = aci_mixer_ioctl 591}; 592 593/* 594 * There is also an internal mixer in the codec (CS4231A or AD1845), 595 * that deserves no purpose in an ACI based system which uses an 596 * external ACI controlled stereo mixer. Make sure that this codec 597 * mixer has the AUX1 input selected as the recording source, that the 598 * input gain is set near maximum and that the other channels going 599 * from the inputs to the codec output are muted. 600 */ 601 602static int __init attach_aci(void) 603{ 604 char *boardname; 605 int i, rc = -EBUSY; 606 607 mutex_init(&aci_mutex); 608 609 outb(0xE3, 0xf8f); /* Write MAD16 password */ 610 aci_port = (inb(0xf90) & 0x10) ? 611 0x344: 0x354; /* Get aci_port from MC4_PORT */ 612 613 if (!request_region(aci_port, 3, "sound mixer (ACI)")) { 614 printk(KERN_NOTICE 615 "aci: I/O area 0x%03x-0x%03x already used.\n", 616 aci_port, aci_port+2); 617 goto out; 618 } 619 620 /* force ACI into a known state */ 621 rc = -EFAULT; 622 for (i=0; i<3; i++) 623 if (aci_rw_cmd(ACI_ERROR_OP, -1, -1)<0) 624 goto out_release_region; 625 626 /* official this is one aci read call: */ 627 rc = -EFAULT; 628 if ((aci_idcode[0]=aci_rw_cmd(ACI_READ_IDCODE, -1, -1))<0 || 629 (aci_idcode[1]=aci_rw_cmd(ACI_READ_IDCODE, -1, -1))<0) { 630 printk(KERN_ERR "aci: Failed to read idcode on 0x%03x.\n", 631 aci_port); 632 goto out_release_region; 633 } 634 635 if ((aci_version=aci_rw_cmd(ACI_READ_VERSION, -1, -1))<0) { 636 printk(KERN_ERR "aci: Failed to read version on 0x%03x.\n", 637 aci_port); 638 goto out_release_region; 639 } 640 641 if (aci_idcode[0] == 'm') { 642 /* It looks like a miro sound card. */ 643 switch (aci_idcode[1]) { 644 case 'A': 645 boardname = "PCM1 pro / early PCM12"; 646 break; 647 case 'B': 648 boardname = "PCM12"; 649 break; 650 case 'C': 651 boardname = "PCM20 radio"; 652 break; 653 default: 654 boardname = "unknown miro"; 655 } 656 } else { 657 printk(KERN_WARNING "aci: Warning: unsupported card! - " 658 "no hardware, no specs...\n"); 659 boardname = "unknown Cardinal Technologies"; 660 } 661 662 printk(KERN_INFO "<ACI 0x%02x, id %02x/%02x \"%c/%c\", (%s)> at 0x%03x\n", 663 aci_version, 664 aci_idcode[0], aci_idcode[1], 665 aci_idcode[0], aci_idcode[1], 666 boardname, aci_port); 667 668 rc = -EBUSY; 669 if (reset) { 670 /* first write()s after reset fail with my PCM20 */ 671 if (aci_rw_cmd(ACI_INIT, -1, -1)<0 || 672 aci_rw_cmd(ACI_ERROR_OP, ACI_ERROR_OP, ACI_ERROR_OP)<0 || 673 aci_rw_cmd(ACI_ERROR_OP, ACI_ERROR_OP, ACI_ERROR_OP)<0) 674 goto out_release_region; 675 } 676 677 /* the PCM20 is muted after reset (and reboot) */ 678 if (aci_rw_cmd(ACI_SET_MUTE, 0x00, -1)<0) 679 goto out_release_region; 680 681 if (ide>=0) 682 if (aci_rw_cmd(ACI_SET_IDE, !ide, -1)<0) 683 goto out_release_region; 684 685 if (wss>=0 && aci_idcode[1]=='A') 686 if (aci_rw_cmd(ACI_SET_WSS, !!wss, -1)<0) 687 goto out_release_region; 688 689 mixer_device = sound_install_mixer(MIXER_DRIVER_VERSION, boardname, 690 &aci_mixer_operations, 691 sizeof(aci_mixer_operations), NULL); 692 rc = 0; 693 if (mixer_device < 0) { 694 printk(KERN_ERR "aci: Failed to install mixer.\n"); 695 rc = mixer_device; 696 goto out_release_region; 697 } /* else Maybe initialize the CS4231A mixer here... */ 698out: return rc; 699out_release_region: 700 release_region(aci_port, 3); 701 goto out; 702} 703 704static void __exit unload_aci(void) 705{ 706 sound_unload_mixerdev(mixer_device); 707 release_region(aci_port, 3); 708} 709 710module_init(attach_aci); 711module_exit(unload_aci); 712MODULE_LICENSE("GPL"); 713