1 /* 2 * Matt Wu <Matt_Wu@acersoftech.com.cn> 3 * Apr 26, 2001 4 * Routines for control of ALi pci audio M5451 5 * 6 * BUGS: 7 * -- 8 * 9 * TODO: 10 * -- 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public Lcodecnse as published by 14 * the Free Software Foundation; either version 2 of the Lcodecnse, or 15 * (at your option) any later version. 16 * 17 * This program is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 * GNU General Public Lcodecnse for more details. 21 * 22 * You should have received a copy of the GNU General Public Lcodecnse 23 * along with this program; if not, write to the Free Software 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 25 * 26 */ 27 28 #include <asm/io.h> 29 #include <linux/delay.h> 30 #include <linux/interrupt.h> 31 #include <linux/init.h> 32 #include <linux/pci.h> 33 #include <linux/slab.h> 34 #include <linux/module.h> 35 #include <linux/dma-mapping.h> 36 #include <sound/core.h> 37 #include <sound/pcm.h> 38 #include <sound/info.h> 39 #include <sound/ac97_codec.h> 40 #include <sound/mpu401.h> 41 #include <sound/initval.h> 42 43 MODULE_AUTHOR("Matt Wu <Matt_Wu@acersoftech.com.cn>"); 44 MODULE_DESCRIPTION("ALI M5451"); 45 MODULE_LICENSE("GPL"); 46 MODULE_SUPPORTED_DEVICE("{{ALI,M5451,pci},{ALI,M5451}}"); 47 48 static int index = SNDRV_DEFAULT_IDX1; /* Index */ 49 static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */ 50 static int pcm_channels = 32; 51 static bool spdif; 52 53 module_param(index, int, 0444); 54 MODULE_PARM_DESC(index, "Index value for ALI M5451 PCI Audio."); 55 module_param(id, charp, 0444); 56 MODULE_PARM_DESC(id, "ID string for ALI M5451 PCI Audio."); 57 module_param(pcm_channels, int, 0444); 58 MODULE_PARM_DESC(pcm_channels, "PCM Channels"); 59 module_param(spdif, bool, 0444); 60 MODULE_PARM_DESC(spdif, "Support SPDIF I/O"); 61 62 /* just for backward compatibility */ 63 static bool enable; 64 module_param(enable, bool, 0444); 65 66 67 /* 68 * Debug part definitions 69 */ 70 71 /* #define ALI_DEBUG */ 72 73 #ifdef ALI_DEBUG 74 #define snd_ali_printk(format, args...) printk(KERN_DEBUG format, ##args); 75 #else 76 #define snd_ali_printk(format, args...) 77 #endif 78 79 /* 80 * Constants definition 81 */ 82 83 #define DEVICE_ID_ALI5451 ((PCI_VENDOR_ID_AL<<16)|PCI_DEVICE_ID_AL_M5451) 84 85 86 #define ALI_CHANNELS 32 87 88 #define ALI_PCM_IN_CHANNEL 31 89 #define ALI_SPDIF_IN_CHANNEL 19 90 #define ALI_SPDIF_OUT_CHANNEL 15 91 #define ALI_CENTER_CHANNEL 24 92 #define ALI_LEF_CHANNEL 23 93 #define ALI_SURR_LEFT_CHANNEL 26 94 #define ALI_SURR_RIGHT_CHANNEL 25 95 #define ALI_MODEM_IN_CHANNEL 21 96 #define ALI_MODEM_OUT_CHANNEL 20 97 98 #define SNDRV_ALI_VOICE_TYPE_PCM 01 99 #define SNDRV_ALI_VOICE_TYPE_OTH 02 100 101 #define ALI_5451_V02 0x02 102 103 /* 104 * Direct Registers 105 */ 106 107 #define ALI_LEGACY_DMAR0 0x00 /* ADR0 */ 108 #define ALI_LEGACY_DMAR4 0x04 /* CNT0 */ 109 #define ALI_LEGACY_DMAR11 0x0b /* MOD */ 110 #define ALI_LEGACY_DMAR15 0x0f /* MMR */ 111 #define ALI_MPUR0 0x20 112 #define ALI_MPUR1 0x21 113 #define ALI_MPUR2 0x22 114 #define ALI_MPUR3 0x23 115 116 #define ALI_AC97_WRITE 0x40 117 #define ALI_AC97_READ 0x44 118 119 #define ALI_SCTRL 0x48 120 #define ALI_SPDIF_OUT_ENABLE 0x20 121 #define ALI_SCTRL_LINE_IN2 (1 << 9) 122 #define ALI_SCTRL_GPIO_IN2 (1 << 13) 123 #define ALI_SCTRL_LINE_OUT_EN (1 << 20) 124 #define ALI_SCTRL_GPIO_OUT_EN (1 << 23) 125 #define ALI_SCTRL_CODEC1_READY (1 << 24) 126 #define ALI_SCTRL_CODEC2_READY (1 << 25) 127 #define ALI_AC97_GPIO 0x4c 128 #define ALI_AC97_GPIO_ENABLE 0x8000 129 #define ALI_AC97_GPIO_DATA_SHIFT 16 130 #define ALI_SPDIF_CS 0x70 131 #define ALI_SPDIF_CTRL 0x74 132 #define ALI_SPDIF_IN_FUNC_ENABLE 0x02 133 #define ALI_SPDIF_IN_CH_STATUS 0x40 134 #define ALI_SPDIF_OUT_CH_STATUS 0xbf 135 #define ALI_START 0x80 136 #define ALI_STOP 0x84 137 #define ALI_CSPF 0x90 138 #define ALI_AINT 0x98 139 #define ALI_GC_CIR 0xa0 140 #define ENDLP_IE 0x00001000 141 #define MIDLP_IE 0x00002000 142 #define ALI_AINTEN 0xa4 143 #define ALI_VOLUME 0xa8 144 #define ALI_SBDELTA_DELTA_R 0xac 145 #define ALI_MISCINT 0xb0 146 #define ADDRESS_IRQ 0x00000020 147 #define TARGET_REACHED 0x00008000 148 #define MIXER_OVERFLOW 0x00000800 149 #define MIXER_UNDERFLOW 0x00000400 150 #define GPIO_IRQ 0x01000000 151 #define ALI_SBBL_SBCL 0xc0 152 #define ALI_SBCTRL_SBE2R_SBDD 0xc4 153 #define ALI_STIMER 0xc8 154 #define ALI_GLOBAL_CONTROL 0xd4 155 #define ALI_SPDIF_OUT_SEL_PCM 0x00000400 /* bit 10 */ 156 #define ALI_SPDIF_IN_SUPPORT 0x00000800 /* bit 11 */ 157 #define ALI_SPDIF_OUT_CH_ENABLE 0x00008000 /* bit 15 */ 158 #define ALI_SPDIF_IN_CH_ENABLE 0x00080000 /* bit 19 */ 159 #define ALI_PCM_IN_ENABLE 0x80000000 /* bit 31 */ 160 161 #define ALI_CSO_ALPHA_FMS 0xe0 162 #define ALI_LBA 0xe4 163 #define ALI_ESO_DELTA 0xe8 164 #define ALI_GVSEL_PAN_VOC_CTRL_EC 0xf0 165 #define ALI_EBUF1 0xf4 166 #define ALI_EBUF2 0xf8 167 168 #define ALI_REG(codec, x) ((codec)->port + x) 169 170 #define MAX_CODECS 2 171 172 173 struct snd_ali; 174 struct snd_ali_voice; 175 176 struct snd_ali_channel_control { 177 /* register data */ 178 struct REGDATA { 179 unsigned int start; 180 unsigned int stop; 181 unsigned int aint; 182 unsigned int ainten; 183 } data; 184 185 /* register addresses */ 186 struct REGS { 187 unsigned int start; 188 unsigned int stop; 189 unsigned int aint; 190 unsigned int ainten; 191 unsigned int ac97read; 192 unsigned int ac97write; 193 } regs; 194 195 }; 196 197 struct snd_ali_voice { 198 unsigned int number; 199 unsigned int use :1, 200 pcm :1, 201 midi :1, 202 mode :1, 203 synth :1, 204 running :1; 205 206 /* PCM data */ 207 struct snd_ali *codec; 208 struct snd_pcm_substream *substream; 209 struct snd_ali_voice *extra; 210 211 int eso; /* final ESO value for channel */ 212 int count; /* runtime->period_size */ 213 214 /* --- */ 215 216 void *private_data; 217 void (*private_free)(void *private_data); 218 }; 219 220 221 struct snd_alidev { 222 223 struct snd_ali_voice voices[ALI_CHANNELS]; 224 225 unsigned int chcnt; /* num of opened channels */ 226 unsigned int chmap; /* bitmap for opened channels */ 227 unsigned int synthcount; 228 229 }; 230 231 232 #define ALI_GLOBAL_REGS 56 233 #define ALI_CHANNEL_REGS 8 234 struct snd_ali_image { 235 u32 regs[ALI_GLOBAL_REGS]; 236 u32 channel_regs[ALI_CHANNELS][ALI_CHANNEL_REGS]; 237 }; 238 239 240 struct snd_ali { 241 int irq; 242 unsigned long port; 243 unsigned char revision; 244 245 unsigned int hw_initialized :1; 246 unsigned int spdif_support :1; 247 248 struct pci_dev *pci; 249 struct pci_dev *pci_m1533; 250 struct pci_dev *pci_m7101; 251 252 struct snd_card *card; 253 struct snd_pcm *pcm[MAX_CODECS]; 254 struct snd_alidev synth; 255 struct snd_ali_channel_control chregs; 256 257 /* S/PDIF Mask */ 258 unsigned int spdif_mask; 259 260 unsigned int spurious_irq_count; 261 unsigned int spurious_irq_max_delta; 262 263 unsigned int num_of_codecs; 264 265 struct snd_ac97_bus *ac97_bus; 266 struct snd_ac97 *ac97[MAX_CODECS]; 267 unsigned short ac97_ext_id; 268 unsigned short ac97_ext_status; 269 270 spinlock_t reg_lock; 271 spinlock_t voice_alloc; 272 273 #ifdef CONFIG_PM_SLEEP 274 struct snd_ali_image *image; 275 #endif 276 }; 277 278 static DEFINE_PCI_DEVICE_TABLE(snd_ali_ids) = { 279 {PCI_DEVICE(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M5451), 0, 0, 0}, 280 {0, } 281 }; 282 MODULE_DEVICE_TABLE(pci, snd_ali_ids); 283 284 static void snd_ali_clear_voices(struct snd_ali *, unsigned int, unsigned int); 285 static unsigned short snd_ali_codec_peek(struct snd_ali *, int, unsigned short); 286 static void snd_ali_codec_poke(struct snd_ali *, int, unsigned short, 287 unsigned short); 288 289 /* 290 * AC97 ACCESS 291 */ 292 293 static inline unsigned int snd_ali_5451_peek(struct snd_ali *codec, 294 unsigned int port) 295 { 296 return (unsigned int)inl(ALI_REG(codec, port)); 297 } 298 299 static inline void snd_ali_5451_poke(struct snd_ali *codec, 300 unsigned int port, 301 unsigned int val) 302 { 303 outl((unsigned int)val, ALI_REG(codec, port)); 304 } 305 306 static int snd_ali_codec_ready(struct snd_ali *codec, 307 unsigned int port) 308 { 309 unsigned long end_time; 310 unsigned int res; 311 312 end_time = jiffies + msecs_to_jiffies(250); 313 314 for (;;) { 315 res = snd_ali_5451_peek(codec,port); 316 if (!(res & 0x8000)) 317 return 0; 318 if (!time_after_eq(end_time, jiffies)) 319 break; 320 schedule_timeout_uninterruptible(1); 321 } 322 323 snd_ali_5451_poke(codec, port, res & ~0x8000); 324 snd_printdd("ali_codec_ready: codec is not ready.\n "); 325 return -EIO; 326 } 327 328 static int snd_ali_stimer_ready(struct snd_ali *codec) 329 { 330 unsigned long end_time; 331 unsigned long dwChk1,dwChk2; 332 333 dwChk1 = snd_ali_5451_peek(codec, ALI_STIMER); 334 end_time = jiffies + msecs_to_jiffies(250); 335 336 for (;;) { 337 dwChk2 = snd_ali_5451_peek(codec, ALI_STIMER); 338 if (dwChk2 != dwChk1) 339 return 0; 340 if (!time_after_eq(end_time, jiffies)) 341 break; 342 schedule_timeout_uninterruptible(1); 343 } 344 345 snd_printk(KERN_ERR "ali_stimer_read: stimer is not ready.\n"); 346 return -EIO; 347 } 348 349 static void snd_ali_codec_poke(struct snd_ali *codec,int secondary, 350 unsigned short reg, 351 unsigned short val) 352 { 353 unsigned int dwVal; 354 unsigned int port; 355 356 if (reg >= 0x80) { 357 snd_printk(KERN_ERR "ali_codec_poke: reg(%xh) invalid.\n", reg); 358 return; 359 } 360 361 port = codec->chregs.regs.ac97write; 362 363 if (snd_ali_codec_ready(codec, port) < 0) 364 return; 365 if (snd_ali_stimer_ready(codec) < 0) 366 return; 367 368 dwVal = (unsigned int) (reg & 0xff); 369 dwVal |= 0x8000 | (val << 16); 370 if (secondary) 371 dwVal |= 0x0080; 372 if (codec->revision == ALI_5451_V02) 373 dwVal |= 0x0100; 374 375 snd_ali_5451_poke(codec, port, dwVal); 376 377 return ; 378 } 379 380 static unsigned short snd_ali_codec_peek(struct snd_ali *codec, 381 int secondary, 382 unsigned short reg) 383 { 384 unsigned int dwVal; 385 unsigned int port; 386 387 if (reg >= 0x80) { 388 snd_printk(KERN_ERR "ali_codec_peek: reg(%xh) invalid.\n", reg); 389 return ~0; 390 } 391 392 port = codec->chregs.regs.ac97read; 393 394 if (snd_ali_codec_ready(codec, port) < 0) 395 return ~0; 396 if (snd_ali_stimer_ready(codec) < 0) 397 return ~0; 398 399 dwVal = (unsigned int) (reg & 0xff); 400 dwVal |= 0x8000; /* bit 15*/ 401 if (secondary) 402 dwVal |= 0x0080; 403 404 snd_ali_5451_poke(codec, port, dwVal); 405 406 if (snd_ali_stimer_ready(codec) < 0) 407 return ~0; 408 if (snd_ali_codec_ready(codec, port) < 0) 409 return ~0; 410 411 return (snd_ali_5451_peek(codec, port) & 0xffff0000) >> 16; 412 } 413 414 static void snd_ali_codec_write(struct snd_ac97 *ac97, 415 unsigned short reg, 416 unsigned short val ) 417 { 418 struct snd_ali *codec = ac97->private_data; 419 420 snd_ali_printk("codec_write: reg=%xh data=%xh.\n", reg, val); 421 if (reg == AC97_GPIO_STATUS) { 422 outl((val << ALI_AC97_GPIO_DATA_SHIFT) | ALI_AC97_GPIO_ENABLE, 423 ALI_REG(codec, ALI_AC97_GPIO)); 424 return; 425 } 426 snd_ali_codec_poke(codec, ac97->num, reg, val); 427 return ; 428 } 429 430 431 static unsigned short snd_ali_codec_read(struct snd_ac97 *ac97, 432 unsigned short reg) 433 { 434 struct snd_ali *codec = ac97->private_data; 435 436 snd_ali_printk("codec_read reg=%xh.\n", reg); 437 return snd_ali_codec_peek(codec, ac97->num, reg); 438 } 439 440 /* 441 * AC97 Reset 442 */ 443 444 static int snd_ali_reset_5451(struct snd_ali *codec) 445 { 446 struct pci_dev *pci_dev; 447 unsigned short wCount, wReg; 448 unsigned int dwVal; 449 450 pci_dev = codec->pci_m1533; 451 if (pci_dev) { 452 pci_read_config_dword(pci_dev, 0x7c, &dwVal); 453 pci_write_config_dword(pci_dev, 0x7c, dwVal | 0x08000000); 454 udelay(5000); 455 pci_read_config_dword(pci_dev, 0x7c, &dwVal); 456 pci_write_config_dword(pci_dev, 0x7c, dwVal & 0xf7ffffff); 457 udelay(5000); 458 } 459 460 pci_dev = codec->pci; 461 pci_read_config_dword(pci_dev, 0x44, &dwVal); 462 pci_write_config_dword(pci_dev, 0x44, dwVal | 0x000c0000); 463 udelay(500); 464 pci_read_config_dword(pci_dev, 0x44, &dwVal); 465 pci_write_config_dword(pci_dev, 0x44, dwVal & 0xfffbffff); 466 udelay(5000); 467 468 wCount = 200; 469 while(wCount--) { 470 wReg = snd_ali_codec_peek(codec, 0, AC97_POWERDOWN); 471 if ((wReg & 0x000f) == 0x000f) 472 return 0; 473 udelay(5000); 474 } 475 476 /* non-fatal if you have a non PM capable codec */ 477 /* snd_printk(KERN_WARNING "ali5451: reset time out\n"); */ 478 return 0; 479 } 480 481 /* 482 * ALI 5451 Controller 483 */ 484 485 static void snd_ali_enable_special_channel(struct snd_ali *codec, 486 unsigned int channel) 487 { 488 unsigned long dwVal; 489 490 dwVal = inl(ALI_REG(codec, ALI_GLOBAL_CONTROL)); 491 dwVal |= 1 << (channel & 0x0000001f); 492 outl(dwVal, ALI_REG(codec, ALI_GLOBAL_CONTROL)); 493 } 494 495 static void snd_ali_disable_special_channel(struct snd_ali *codec, 496 unsigned int channel) 497 { 498 unsigned long dwVal; 499 500 dwVal = inl(ALI_REG(codec, ALI_GLOBAL_CONTROL)); 501 dwVal &= ~(1 << (channel & 0x0000001f)); 502 outl(dwVal, ALI_REG(codec, ALI_GLOBAL_CONTROL)); 503 } 504 505 static void snd_ali_enable_address_interrupt(struct snd_ali *codec) 506 { 507 unsigned int gc; 508 509 gc = inl(ALI_REG(codec, ALI_GC_CIR)); 510 gc |= ENDLP_IE; 511 gc |= MIDLP_IE; 512 outl( gc, ALI_REG(codec, ALI_GC_CIR)); 513 } 514 515 static void snd_ali_disable_address_interrupt(struct snd_ali *codec) 516 { 517 unsigned int gc; 518 519 gc = inl(ALI_REG(codec, ALI_GC_CIR)); 520 gc &= ~ENDLP_IE; 521 gc &= ~MIDLP_IE; 522 outl(gc, ALI_REG(codec, ALI_GC_CIR)); 523 } 524 525 static void snd_ali_disable_voice_irq(struct snd_ali *codec, 526 unsigned int channel) 527 { 528 unsigned int mask; 529 struct snd_ali_channel_control *pchregs = &(codec->chregs); 530 531 snd_ali_printk("disable_voice_irq channel=%d\n",channel); 532 533 mask = 1 << (channel & 0x1f); 534 pchregs->data.ainten = inl(ALI_REG(codec, pchregs->regs.ainten)); 535 pchregs->data.ainten &= ~mask; 536 outl(pchregs->data.ainten, ALI_REG(codec, pchregs->regs.ainten)); 537 } 538 539 static int snd_ali_alloc_pcm_channel(struct snd_ali *codec, int channel) 540 { 541 unsigned int idx = channel & 0x1f; 542 543 if (codec->synth.chcnt >= ALI_CHANNELS){ 544 snd_printk(KERN_ERR 545 "ali_alloc_pcm_channel: no free channels.\n"); 546 return -1; 547 } 548 549 if (!(codec->synth.chmap & (1 << idx))) { 550 codec->synth.chmap |= 1 << idx; 551 codec->synth.chcnt++; 552 snd_ali_printk("alloc_pcm_channel no. %d.\n",idx); 553 return idx; 554 } 555 return -1; 556 } 557 558 static int snd_ali_find_free_channel(struct snd_ali * codec, int rec) 559 { 560 int idx; 561 int result = -1; 562 563 snd_ali_printk("find_free_channel: for %s\n",rec ? "rec" : "pcm"); 564 565 /* recording */ 566 if (rec) { 567 if (codec->spdif_support && 568 (inl(ALI_REG(codec, ALI_GLOBAL_CONTROL)) & 569 ALI_SPDIF_IN_SUPPORT)) 570 idx = ALI_SPDIF_IN_CHANNEL; 571 else 572 idx = ALI_PCM_IN_CHANNEL; 573 574 result = snd_ali_alloc_pcm_channel(codec, idx); 575 if (result >= 0) 576 return result; 577 else { 578 snd_printk(KERN_ERR "ali_find_free_channel: " 579 "record channel is busy now.\n"); 580 return -1; 581 } 582 } 583 584 /* playback... */ 585 if (codec->spdif_support && 586 (inl(ALI_REG(codec, ALI_GLOBAL_CONTROL)) & 587 ALI_SPDIF_OUT_CH_ENABLE)) { 588 idx = ALI_SPDIF_OUT_CHANNEL; 589 result = snd_ali_alloc_pcm_channel(codec, idx); 590 if (result >= 0) 591 return result; 592 else 593 snd_printk(KERN_ERR "ali_find_free_channel: " 594 "S/PDIF out channel is in busy now.\n"); 595 } 596 597 for (idx = 0; idx < ALI_CHANNELS; idx++) { 598 result = snd_ali_alloc_pcm_channel(codec, idx); 599 if (result >= 0) 600 return result; 601 } 602 snd_printk(KERN_ERR "ali_find_free_channel: no free channels.\n"); 603 return -1; 604 } 605 606 static void snd_ali_free_channel_pcm(struct snd_ali *codec, int channel) 607 { 608 unsigned int idx = channel & 0x0000001f; 609 610 snd_ali_printk("free_channel_pcm channel=%d\n",channel); 611 612 if (channel < 0 || channel >= ALI_CHANNELS) 613 return; 614 615 if (!(codec->synth.chmap & (1 << idx))) { 616 snd_printk(KERN_ERR "ali_free_channel_pcm: " 617 "channel %d is not in use.\n", channel); 618 return; 619 } else { 620 codec->synth.chmap &= ~(1 << idx); 621 codec->synth.chcnt--; 622 } 623 } 624 625 static void snd_ali_stop_voice(struct snd_ali *codec, unsigned int channel) 626 { 627 unsigned int mask = 1 << (channel & 0x1f); 628 629 snd_ali_printk("stop_voice: channel=%d\n",channel); 630 outl(mask, ALI_REG(codec, codec->chregs.regs.stop)); 631 } 632 633 /* 634 * S/PDIF Part 635 */ 636 637 static void snd_ali_delay(struct snd_ali *codec,int interval) 638 { 639 unsigned long begintimer,currenttimer; 640 641 begintimer = inl(ALI_REG(codec, ALI_STIMER)); 642 currenttimer = inl(ALI_REG(codec, ALI_STIMER)); 643 644 while (currenttimer < begintimer + interval) { 645 if (snd_ali_stimer_ready(codec) < 0) 646 break; 647 currenttimer = inl(ALI_REG(codec, ALI_STIMER)); 648 cpu_relax(); 649 } 650 } 651 652 static void snd_ali_detect_spdif_rate(struct snd_ali *codec) 653 { 654 u16 wval; 655 u16 count = 0; 656 u8 bval, R1 = 0, R2; 657 658 bval = inb(ALI_REG(codec, ALI_SPDIF_CTRL + 1)); 659 bval |= 0x1F; 660 outb(bval, ALI_REG(codec, ALI_SPDIF_CTRL + 1)); 661 662 while ((R1 < 0x0b || R1 > 0x0e) && R1 != 0x12 && count <= 50000) { 663 count ++; 664 snd_ali_delay(codec, 6); 665 bval = inb(ALI_REG(codec, ALI_SPDIF_CTRL + 1)); 666 R1 = bval & 0x1F; 667 } 668 669 if (count > 50000) { 670 snd_printk(KERN_ERR "ali_detect_spdif_rate: timeout!\n"); 671 return; 672 } 673 674 for (count = 0; count <= 50000; count++) { 675 snd_ali_delay(codec, 6); 676 bval = inb(ALI_REG(codec,ALI_SPDIF_CTRL + 1)); 677 R2 = bval & 0x1F; 678 if (R2 != R1) 679 R1 = R2; 680 else 681 break; 682 } 683 684 if (count > 50000) { 685 snd_printk(KERN_ERR "ali_detect_spdif_rate: timeout!\n"); 686 return; 687 } 688 689 if (R2 >= 0x0b && R2 <= 0x0e) { 690 wval = inw(ALI_REG(codec, ALI_SPDIF_CTRL + 2)); 691 wval &= 0xe0f0; 692 wval |= (0x09 << 8) | 0x05; 693 outw(wval, ALI_REG(codec, ALI_SPDIF_CTRL + 2)); 694 695 bval = inb(ALI_REG(codec, ALI_SPDIF_CS + 3)) & 0xf0; 696 outb(bval | 0x02, ALI_REG(codec, ALI_SPDIF_CS + 3)); 697 } else if (R2 == 0x12) { 698 wval = inw(ALI_REG(codec, ALI_SPDIF_CTRL + 2)); 699 wval &= 0xe0f0; 700 wval |= (0x0e << 8) | 0x08; 701 outw(wval, ALI_REG(codec, ALI_SPDIF_CTRL + 2)); 702 703 bval = inb(ALI_REG(codec,ALI_SPDIF_CS + 3)) & 0xf0; 704 outb(bval | 0x03, ALI_REG(codec, ALI_SPDIF_CS + 3)); 705 } 706 } 707 708 static unsigned int snd_ali_get_spdif_in_rate(struct snd_ali *codec) 709 { 710 u32 dwRate; 711 u8 bval; 712 713 bval = inb(ALI_REG(codec, ALI_SPDIF_CTRL)); 714 bval &= 0x7f; 715 bval |= 0x40; 716 outb(bval, ALI_REG(codec, ALI_SPDIF_CTRL)); 717 718 snd_ali_detect_spdif_rate(codec); 719 720 bval = inb(ALI_REG(codec, ALI_SPDIF_CS + 3)); 721 bval &= 0x0f; 722 723 switch (bval) { 724 case 0: dwRate = 44100; break; 725 case 1: dwRate = 48000; break; 726 case 2: dwRate = 32000; break; 727 default: dwRate = 0; break; 728 } 729 730 return dwRate; 731 } 732 733 static void snd_ali_enable_spdif_in(struct snd_ali *codec) 734 { 735 unsigned int dwVal; 736 737 dwVal = inl(ALI_REG(codec, ALI_GLOBAL_CONTROL)); 738 dwVal |= ALI_SPDIF_IN_SUPPORT; 739 outl(dwVal, ALI_REG(codec, ALI_GLOBAL_CONTROL)); 740 741 dwVal = inb(ALI_REG(codec, ALI_SPDIF_CTRL)); 742 dwVal |= 0x02; 743 outb(dwVal, ALI_REG(codec, ALI_SPDIF_CTRL)); 744 745 snd_ali_enable_special_channel(codec, ALI_SPDIF_IN_CHANNEL); 746 } 747 748 static void snd_ali_disable_spdif_in(struct snd_ali *codec) 749 { 750 unsigned int dwVal; 751 752 dwVal = inl(ALI_REG(codec, ALI_GLOBAL_CONTROL)); 753 dwVal &= ~ALI_SPDIF_IN_SUPPORT; 754 outl(dwVal, ALI_REG(codec, ALI_GLOBAL_CONTROL)); 755 756 snd_ali_disable_special_channel(codec, ALI_SPDIF_IN_CHANNEL); 757 } 758 759 760 static void snd_ali_set_spdif_out_rate(struct snd_ali *codec, unsigned int rate) 761 { 762 unsigned char bVal; 763 unsigned int dwRate; 764 765 switch (rate) { 766 case 32000: dwRate = 0x300; break; 767 case 48000: dwRate = 0x200; break; 768 default: dwRate = 0; break; 769 } 770 771 bVal = inb(ALI_REG(codec, ALI_SPDIF_CTRL)); 772 bVal &= (unsigned char)(~(1<<6)); 773 774 bVal |= 0x80; /* select right */ 775 outb(bVal, ALI_REG(codec, ALI_SPDIF_CTRL)); 776 outb(dwRate | 0x20, ALI_REG(codec, ALI_SPDIF_CS + 2)); 777 778 bVal &= ~0x80; /* select left */ 779 outb(bVal, ALI_REG(codec, ALI_SPDIF_CTRL)); 780 outw(rate | 0x10, ALI_REG(codec, ALI_SPDIF_CS + 2)); 781 } 782 783 static void snd_ali_enable_spdif_out(struct snd_ali *codec) 784 { 785 unsigned short wVal; 786 unsigned char bVal; 787 struct pci_dev *pci_dev; 788 789 pci_dev = codec->pci_m1533; 790 if (pci_dev == NULL) 791 return; 792 pci_read_config_byte(pci_dev, 0x61, &bVal); 793 bVal |= 0x40; 794 pci_write_config_byte(pci_dev, 0x61, bVal); 795 pci_read_config_byte(pci_dev, 0x7d, &bVal); 796 bVal |= 0x01; 797 pci_write_config_byte(pci_dev, 0x7d, bVal); 798 799 pci_read_config_byte(pci_dev, 0x7e, &bVal); 800 bVal &= (~0x20); 801 bVal |= 0x10; 802 pci_write_config_byte(pci_dev, 0x7e, bVal); 803 804 bVal = inb(ALI_REG(codec, ALI_SCTRL)); 805 outb(bVal | ALI_SPDIF_OUT_ENABLE, ALI_REG(codec, ALI_SCTRL)); 806 807 bVal = inb(ALI_REG(codec, ALI_SPDIF_CTRL)); 808 outb(bVal & ALI_SPDIF_OUT_CH_STATUS, ALI_REG(codec, ALI_SPDIF_CTRL)); 809 810 wVal = inw(ALI_REG(codec, ALI_GLOBAL_CONTROL)); 811 wVal |= ALI_SPDIF_OUT_SEL_PCM; 812 outw(wVal, ALI_REG(codec, ALI_GLOBAL_CONTROL)); 813 snd_ali_disable_special_channel(codec, ALI_SPDIF_OUT_CHANNEL); 814 } 815 816 static void snd_ali_enable_spdif_chnout(struct snd_ali *codec) 817 { 818 unsigned short wVal; 819 820 wVal = inw(ALI_REG(codec, ALI_GLOBAL_CONTROL)); 821 wVal &= ~ALI_SPDIF_OUT_SEL_PCM; 822 outw(wVal, ALI_REG(codec, ALI_GLOBAL_CONTROL)); 823 /* 824 wVal = inw(ALI_REG(codec, ALI_SPDIF_CS)); 825 if (flag & ALI_SPDIF_OUT_NON_PCM) 826 wVal |= 0x0002; 827 else 828 wVal &= (~0x0002); 829 outw(wVal, ALI_REG(codec, ALI_SPDIF_CS)); 830 */ 831 snd_ali_enable_special_channel(codec, ALI_SPDIF_OUT_CHANNEL); 832 } 833 834 static void snd_ali_disable_spdif_chnout(struct snd_ali *codec) 835 { 836 unsigned short wVal; 837 838 wVal = inw(ALI_REG(codec, ALI_GLOBAL_CONTROL)); 839 wVal |= ALI_SPDIF_OUT_SEL_PCM; 840 outw(wVal, ALI_REG(codec, ALI_GLOBAL_CONTROL)); 841 842 snd_ali_enable_special_channel(codec, ALI_SPDIF_OUT_CHANNEL); 843 } 844 845 static void snd_ali_disable_spdif_out(struct snd_ali *codec) 846 { 847 unsigned char bVal; 848 849 bVal = inb(ALI_REG(codec, ALI_SCTRL)); 850 outb(bVal & ~ALI_SPDIF_OUT_ENABLE, ALI_REG(codec, ALI_SCTRL)); 851 852 snd_ali_disable_spdif_chnout(codec); 853 } 854 855 static void snd_ali_update_ptr(struct snd_ali *codec, int channel) 856 { 857 struct snd_ali_voice *pvoice; 858 struct snd_pcm_runtime *runtime; 859 struct snd_ali_channel_control *pchregs; 860 unsigned int old, mask; 861 #ifdef ALI_DEBUG 862 unsigned int temp, cspf; 863 #endif 864 865 pchregs = &(codec->chregs); 866 867 /* check if interrupt occurred for channel */ 868 old = pchregs->data.aint; 869 mask = 1U << (channel & 0x1f); 870 871 if (!(old & mask)) 872 return; 873 874 pvoice = &codec->synth.voices[channel]; 875 runtime = pvoice->substream->runtime; 876 877 udelay(100); 878 spin_lock(&codec->reg_lock); 879 880 if (pvoice->pcm && pvoice->substream) { 881 /* pcm interrupt */ 882 #ifdef ALI_DEBUG 883 outb((u8)(pvoice->number), ALI_REG(codec, ALI_GC_CIR)); 884 temp = inw(ALI_REG(codec, ALI_CSO_ALPHA_FMS + 2)); 885 cspf = (inl(ALI_REG(codec, ALI_CSPF)) & mask) == mask; 886 #endif 887 if (pvoice->running) { 888 snd_ali_printk("update_ptr: cso=%4.4x cspf=%d.\n", 889 (u16)temp, cspf); 890 spin_unlock(&codec->reg_lock); 891 snd_pcm_period_elapsed(pvoice->substream); 892 spin_lock(&codec->reg_lock); 893 } else { 894 snd_ali_stop_voice(codec, channel); 895 snd_ali_disable_voice_irq(codec, channel); 896 } 897 } else if (codec->synth.voices[channel].synth) { 898 /* synth interrupt */ 899 } else if (codec->synth.voices[channel].midi) { 900 /* midi interrupt */ 901 } else { 902 /* unknown interrupt */ 903 snd_ali_stop_voice(codec, channel); 904 snd_ali_disable_voice_irq(codec, channel); 905 } 906 spin_unlock(&codec->reg_lock); 907 outl(mask,ALI_REG(codec,pchregs->regs.aint)); 908 pchregs->data.aint = old & (~mask); 909 } 910 911 static irqreturn_t snd_ali_card_interrupt(int irq, void *dev_id) 912 { 913 struct snd_ali *codec = dev_id; 914 int channel; 915 unsigned int audio_int; 916 struct snd_ali_channel_control *pchregs; 917 918 if (codec == NULL || !codec->hw_initialized) 919 return IRQ_NONE; 920 921 audio_int = inl(ALI_REG(codec, ALI_MISCINT)); 922 if (!audio_int) 923 return IRQ_NONE; 924 925 pchregs = &(codec->chregs); 926 if (audio_int & ADDRESS_IRQ) { 927 /* get interrupt status for all channels */ 928 pchregs->data.aint = inl(ALI_REG(codec, pchregs->regs.aint)); 929 for (channel = 0; channel < ALI_CHANNELS; channel++) 930 snd_ali_update_ptr(codec, channel); 931 } 932 outl((TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW), 933 ALI_REG(codec, ALI_MISCINT)); 934 935 return IRQ_HANDLED; 936 } 937 938 939 static struct snd_ali_voice *snd_ali_alloc_voice(struct snd_ali * codec, 940 int type, int rec, int channel) 941 { 942 struct snd_ali_voice *pvoice; 943 int idx; 944 945 snd_ali_printk("alloc_voice: type=%d rec=%d\n", type, rec); 946 947 spin_lock_irq(&codec->voice_alloc); 948 if (type == SNDRV_ALI_VOICE_TYPE_PCM) { 949 idx = channel > 0 ? snd_ali_alloc_pcm_channel(codec, channel) : 950 snd_ali_find_free_channel(codec,rec); 951 if (idx < 0) { 952 snd_printk(KERN_ERR "ali_alloc_voice: err.\n"); 953 spin_unlock_irq(&codec->voice_alloc); 954 return NULL; 955 } 956 pvoice = &(codec->synth.voices[idx]); 957 pvoice->codec = codec; 958 pvoice->use = 1; 959 pvoice->pcm = 1; 960 pvoice->mode = rec; 961 spin_unlock_irq(&codec->voice_alloc); 962 return pvoice; 963 } 964 spin_unlock_irq(&codec->voice_alloc); 965 return NULL; 966 } 967 968 969 static void snd_ali_free_voice(struct snd_ali * codec, 970 struct snd_ali_voice *pvoice) 971 { 972 void (*private_free)(void *); 973 void *private_data; 974 975 snd_ali_printk("free_voice: channel=%d\n",pvoice->number); 976 if (!pvoice->use) 977 return; 978 snd_ali_clear_voices(codec, pvoice->number, pvoice->number); 979 spin_lock_irq(&codec->voice_alloc); 980 private_free = pvoice->private_free; 981 private_data = pvoice->private_data; 982 pvoice->private_free = NULL; 983 pvoice->private_data = NULL; 984 if (pvoice->pcm) 985 snd_ali_free_channel_pcm(codec, pvoice->number); 986 pvoice->use = pvoice->pcm = pvoice->synth = 0; 987 pvoice->substream = NULL; 988 spin_unlock_irq(&codec->voice_alloc); 989 if (private_free) 990 private_free(private_data); 991 } 992 993 994 static void snd_ali_clear_voices(struct snd_ali *codec, 995 unsigned int v_min, 996 unsigned int v_max) 997 { 998 unsigned int i; 999 1000 for (i = v_min; i <= v_max; i++) { 1001 snd_ali_stop_voice(codec, i); 1002 snd_ali_disable_voice_irq(codec, i); 1003 } 1004 } 1005 1006 static void snd_ali_write_voice_regs(struct snd_ali *codec, 1007 unsigned int Channel, 1008 unsigned int LBA, 1009 unsigned int CSO, 1010 unsigned int ESO, 1011 unsigned int DELTA, 1012 unsigned int ALPHA_FMS, 1013 unsigned int GVSEL, 1014 unsigned int PAN, 1015 unsigned int VOL, 1016 unsigned int CTRL, 1017 unsigned int EC) 1018 { 1019 unsigned int ctlcmds[4]; 1020 1021 outb((unsigned char)(Channel & 0x001f), ALI_REG(codec, ALI_GC_CIR)); 1022 1023 ctlcmds[0] = (CSO << 16) | (ALPHA_FMS & 0x0000ffff); 1024 ctlcmds[1] = LBA; 1025 ctlcmds[2] = (ESO << 16) | (DELTA & 0x0ffff); 1026 ctlcmds[3] = (GVSEL << 31) | 1027 ((PAN & 0x0000007f) << 24) | 1028 ((VOL & 0x000000ff) << 16) | 1029 ((CTRL & 0x0000000f) << 12) | 1030 (EC & 0x00000fff); 1031 1032 outb(Channel, ALI_REG(codec, ALI_GC_CIR)); 1033 1034 outl(ctlcmds[0], ALI_REG(codec, ALI_CSO_ALPHA_FMS)); 1035 outl(ctlcmds[1], ALI_REG(codec, ALI_LBA)); 1036 outl(ctlcmds[2], ALI_REG(codec, ALI_ESO_DELTA)); 1037 outl(ctlcmds[3], ALI_REG(codec, ALI_GVSEL_PAN_VOC_CTRL_EC)); 1038 1039 outl(0x30000000, ALI_REG(codec, ALI_EBUF1)); /* Still Mode */ 1040 outl(0x30000000, ALI_REG(codec, ALI_EBUF2)); /* Still Mode */ 1041 } 1042 1043 static unsigned int snd_ali_convert_rate(unsigned int rate, int rec) 1044 { 1045 unsigned int delta; 1046 1047 if (rate < 4000) 1048 rate = 4000; 1049 if (rate > 48000) 1050 rate = 48000; 1051 1052 if (rec) { 1053 if (rate == 44100) 1054 delta = 0x116a; 1055 else if (rate == 8000) 1056 delta = 0x6000; 1057 else if (rate == 48000) 1058 delta = 0x1000; 1059 else 1060 delta = ((48000 << 12) / rate) & 0x0000ffff; 1061 } else { 1062 if (rate == 44100) 1063 delta = 0xeb3; 1064 else if (rate == 8000) 1065 delta = 0x2ab; 1066 else if (rate == 48000) 1067 delta = 0x1000; 1068 else 1069 delta = (((rate << 12) + rate) / 48000) & 0x0000ffff; 1070 } 1071 1072 return delta; 1073 } 1074 1075 static unsigned int snd_ali_control_mode(struct snd_pcm_substream *substream) 1076 { 1077 unsigned int CTRL; 1078 struct snd_pcm_runtime *runtime = substream->runtime; 1079 1080 /* set ctrl mode 1081 CTRL default: 8-bit (unsigned) mono, loop mode enabled 1082 */ 1083 CTRL = 0x00000001; 1084 if (snd_pcm_format_width(runtime->format) == 16) 1085 CTRL |= 0x00000008; /* 16-bit data */ 1086 if (!snd_pcm_format_unsigned(runtime->format)) 1087 CTRL |= 0x00000002; /* signed data */ 1088 if (runtime->channels > 1) 1089 CTRL |= 0x00000004; /* stereo data */ 1090 return CTRL; 1091 } 1092 1093 /* 1094 * PCM part 1095 */ 1096 1097 static int snd_ali_trigger(struct snd_pcm_substream *substream, 1098 int cmd) 1099 1100 { 1101 struct snd_ali *codec = snd_pcm_substream_chip(substream); 1102 struct snd_pcm_substream *s; 1103 unsigned int what, whati, capture_flag; 1104 struct snd_ali_voice *pvoice, *evoice; 1105 unsigned int val; 1106 int do_start; 1107 1108 switch (cmd) { 1109 case SNDRV_PCM_TRIGGER_START: 1110 case SNDRV_PCM_TRIGGER_RESUME: 1111 do_start = 1; 1112 break; 1113 case SNDRV_PCM_TRIGGER_STOP: 1114 case SNDRV_PCM_TRIGGER_SUSPEND: 1115 do_start = 0; 1116 break; 1117 default: 1118 return -EINVAL; 1119 } 1120 1121 what = whati = capture_flag = 0; 1122 snd_pcm_group_for_each_entry(s, substream) { 1123 if ((struct snd_ali *) snd_pcm_substream_chip(s) == codec) { 1124 pvoice = s->runtime->private_data; 1125 evoice = pvoice->extra; 1126 what |= 1 << (pvoice->number & 0x1f); 1127 if (evoice == NULL) 1128 whati |= 1 << (pvoice->number & 0x1f); 1129 else { 1130 whati |= 1 << (evoice->number & 0x1f); 1131 what |= 1 << (evoice->number & 0x1f); 1132 } 1133 if (do_start) { 1134 pvoice->running = 1; 1135 if (evoice != NULL) 1136 evoice->running = 1; 1137 } else { 1138 pvoice->running = 0; 1139 if (evoice != NULL) 1140 evoice->running = 0; 1141 } 1142 snd_pcm_trigger_done(s, substream); 1143 if (pvoice->mode) 1144 capture_flag = 1; 1145 } 1146 } 1147 spin_lock(&codec->reg_lock); 1148 if (!do_start) 1149 outl(what, ALI_REG(codec, ALI_STOP)); 1150 val = inl(ALI_REG(codec, ALI_AINTEN)); 1151 if (do_start) 1152 val |= whati; 1153 else 1154 val &= ~whati; 1155 outl(val, ALI_REG(codec, ALI_AINTEN)); 1156 if (do_start) 1157 outl(what, ALI_REG(codec, ALI_START)); 1158 snd_ali_printk("trigger: what=%xh whati=%xh\n", what, whati); 1159 spin_unlock(&codec->reg_lock); 1160 1161 return 0; 1162 } 1163 1164 static int snd_ali_playback_hw_params(struct snd_pcm_substream *substream, 1165 struct snd_pcm_hw_params *hw_params) 1166 { 1167 struct snd_ali *codec = snd_pcm_substream_chip(substream); 1168 struct snd_pcm_runtime *runtime = substream->runtime; 1169 struct snd_ali_voice *pvoice = runtime->private_data; 1170 struct snd_ali_voice *evoice = pvoice->extra; 1171 int err; 1172 1173 err = snd_pcm_lib_malloc_pages(substream, 1174 params_buffer_bytes(hw_params)); 1175 if (err < 0) 1176 return err; 1177 1178 /* voice management */ 1179 1180 if (params_buffer_size(hw_params) / 2 != 1181 params_period_size(hw_params)) { 1182 if (!evoice) { 1183 evoice = snd_ali_alloc_voice(codec, 1184 SNDRV_ALI_VOICE_TYPE_PCM, 1185 0, -1); 1186 if (!evoice) 1187 return -ENOMEM; 1188 pvoice->extra = evoice; 1189 evoice->substream = substream; 1190 } 1191 } else { 1192 if (evoice) { 1193 snd_ali_free_voice(codec, evoice); 1194 pvoice->extra = evoice = NULL; 1195 } 1196 } 1197 1198 return 0; 1199 } 1200 1201 static int snd_ali_playback_hw_free(struct snd_pcm_substream *substream) 1202 { 1203 struct snd_ali *codec = snd_pcm_substream_chip(substream); 1204 struct snd_pcm_runtime *runtime = substream->runtime; 1205 struct snd_ali_voice *pvoice = runtime->private_data; 1206 struct snd_ali_voice *evoice = pvoice ? pvoice->extra : NULL; 1207 1208 snd_pcm_lib_free_pages(substream); 1209 if (evoice) { 1210 snd_ali_free_voice(codec, evoice); 1211 pvoice->extra = NULL; 1212 } 1213 return 0; 1214 } 1215 1216 static int snd_ali_hw_params(struct snd_pcm_substream *substream, 1217 struct snd_pcm_hw_params *hw_params) 1218 { 1219 return snd_pcm_lib_malloc_pages(substream, 1220 params_buffer_bytes(hw_params)); 1221 } 1222 1223 static int snd_ali_hw_free(struct snd_pcm_substream *substream) 1224 { 1225 return snd_pcm_lib_free_pages(substream); 1226 } 1227 1228 static int snd_ali_playback_prepare(struct snd_pcm_substream *substream) 1229 { 1230 struct snd_ali *codec = snd_pcm_substream_chip(substream); 1231 struct snd_pcm_runtime *runtime = substream->runtime; 1232 struct snd_ali_voice *pvoice = runtime->private_data; 1233 struct snd_ali_voice *evoice = pvoice->extra; 1234 1235 unsigned int LBA; 1236 unsigned int Delta; 1237 unsigned int ESO; 1238 unsigned int CTRL; 1239 unsigned int GVSEL; 1240 unsigned int PAN; 1241 unsigned int VOL; 1242 unsigned int EC; 1243 1244 snd_ali_printk("playback_prepare ...\n"); 1245 1246 spin_lock_irq(&codec->reg_lock); 1247 1248 /* set Delta (rate) value */ 1249 Delta = snd_ali_convert_rate(runtime->rate, 0); 1250 1251 if (pvoice->number == ALI_SPDIF_IN_CHANNEL || 1252 pvoice->number == ALI_PCM_IN_CHANNEL) 1253 snd_ali_disable_special_channel(codec, pvoice->number); 1254 else if (codec->spdif_support && 1255 (inl(ALI_REG(codec, ALI_GLOBAL_CONTROL)) & 1256 ALI_SPDIF_OUT_CH_ENABLE) 1257 && pvoice->number == ALI_SPDIF_OUT_CHANNEL) { 1258 snd_ali_set_spdif_out_rate(codec, runtime->rate); 1259 Delta = 0x1000; 1260 } 1261 1262 /* set Loop Back Address */ 1263 LBA = runtime->dma_addr; 1264 1265 /* set interrupt count size */ 1266 pvoice->count = runtime->period_size; 1267 1268 /* set target ESO for channel */ 1269 pvoice->eso = runtime->buffer_size; 1270 1271 snd_ali_printk("playback_prepare: eso=%xh count=%xh\n", 1272 pvoice->eso, pvoice->count); 1273 1274 /* set ESO to capture first MIDLP interrupt */ 1275 ESO = pvoice->eso -1; 1276 /* set ctrl mode */ 1277 CTRL = snd_ali_control_mode(substream); 1278 1279 GVSEL = 1; 1280 PAN = 0; 1281 VOL = 0; 1282 EC = 0; 1283 snd_ali_printk("playback_prepare:\n"); 1284 snd_ali_printk("ch=%d, Rate=%d Delta=%xh,GVSEL=%xh,PAN=%xh,CTRL=%xh\n", 1285 pvoice->number,runtime->rate,Delta,GVSEL,PAN,CTRL); 1286 snd_ali_write_voice_regs(codec, 1287 pvoice->number, 1288 LBA, 1289 0, /* cso */ 1290 ESO, 1291 Delta, 1292 0, /* alpha */ 1293 GVSEL, 1294 PAN, 1295 VOL, 1296 CTRL, 1297 EC); 1298 if (evoice) { 1299 evoice->count = pvoice->count; 1300 evoice->eso = pvoice->count << 1; 1301 ESO = evoice->eso - 1; 1302 snd_ali_write_voice_regs(codec, 1303 evoice->number, 1304 LBA, 1305 0, /* cso */ 1306 ESO, 1307 Delta, 1308 0, /* alpha */ 1309 GVSEL, 1310 0x7f, 1311 0x3ff, 1312 CTRL, 1313 EC); 1314 } 1315 spin_unlock_irq(&codec->reg_lock); 1316 return 0; 1317 } 1318 1319 1320 static int snd_ali_prepare(struct snd_pcm_substream *substream) 1321 { 1322 struct snd_ali *codec = snd_pcm_substream_chip(substream); 1323 struct snd_pcm_runtime *runtime = substream->runtime; 1324 struct snd_ali_voice *pvoice = runtime->private_data; 1325 unsigned int LBA; 1326 unsigned int Delta; 1327 unsigned int ESO; 1328 unsigned int CTRL; 1329 unsigned int GVSEL; 1330 unsigned int PAN; 1331 unsigned int VOL; 1332 unsigned int EC; 1333 u8 bValue; 1334 1335 spin_lock_irq(&codec->reg_lock); 1336 1337 snd_ali_printk("ali_prepare...\n"); 1338 1339 snd_ali_enable_special_channel(codec,pvoice->number); 1340 1341 Delta = (pvoice->number == ALI_MODEM_IN_CHANNEL || 1342 pvoice->number == ALI_MODEM_OUT_CHANNEL) ? 1343 0x1000 : snd_ali_convert_rate(runtime->rate, pvoice->mode); 1344 1345 /* Prepare capture intr channel */ 1346 if (pvoice->number == ALI_SPDIF_IN_CHANNEL) { 1347 1348 unsigned int rate; 1349 1350 spin_unlock_irq(&codec->reg_lock); 1351 if (codec->revision != ALI_5451_V02) 1352 return -1; 1353 1354 rate = snd_ali_get_spdif_in_rate(codec); 1355 if (rate == 0) { 1356 snd_printk(KERN_WARNING "ali_capture_preapre: " 1357 "spdif rate detect err!\n"); 1358 rate = 48000; 1359 } 1360 spin_lock_irq(&codec->reg_lock); 1361 bValue = inb(ALI_REG(codec,ALI_SPDIF_CTRL)); 1362 if (bValue & 0x10) { 1363 outb(bValue,ALI_REG(codec,ALI_SPDIF_CTRL)); 1364 printk(KERN_WARNING "clear SPDIF parity error flag.\n"); 1365 } 1366 1367 if (rate != 48000) 1368 Delta = ((rate << 12) / runtime->rate) & 0x00ffff; 1369 } 1370 1371 /* set target ESO for channel */ 1372 pvoice->eso = runtime->buffer_size; 1373 1374 /* set interrupt count size */ 1375 pvoice->count = runtime->period_size; 1376 1377 /* set Loop Back Address */ 1378 LBA = runtime->dma_addr; 1379 1380 /* set ESO to capture first MIDLP interrupt */ 1381 ESO = pvoice->eso - 1; 1382 CTRL = snd_ali_control_mode(substream); 1383 GVSEL = 0; 1384 PAN = 0x00; 1385 VOL = 0x00; 1386 EC = 0; 1387 1388 snd_ali_write_voice_regs( codec, 1389 pvoice->number, 1390 LBA, 1391 0, /* cso */ 1392 ESO, 1393 Delta, 1394 0, /* alpha */ 1395 GVSEL, 1396 PAN, 1397 VOL, 1398 CTRL, 1399 EC); 1400 1401 spin_unlock_irq(&codec->reg_lock); 1402 1403 return 0; 1404 } 1405 1406 1407 static snd_pcm_uframes_t 1408 snd_ali_playback_pointer(struct snd_pcm_substream *substream) 1409 { 1410 struct snd_ali *codec = snd_pcm_substream_chip(substream); 1411 struct snd_pcm_runtime *runtime = substream->runtime; 1412 struct snd_ali_voice *pvoice = runtime->private_data; 1413 unsigned int cso; 1414 1415 spin_lock(&codec->reg_lock); 1416 if (!pvoice->running) { 1417 spin_unlock(&codec->reg_lock); 1418 return 0; 1419 } 1420 outb(pvoice->number, ALI_REG(codec, ALI_GC_CIR)); 1421 cso = inw(ALI_REG(codec, ALI_CSO_ALPHA_FMS + 2)); 1422 spin_unlock(&codec->reg_lock); 1423 snd_ali_printk("playback pointer returned cso=%xh.\n", cso); 1424 1425 return cso; 1426 } 1427 1428 1429 static snd_pcm_uframes_t snd_ali_pointer(struct snd_pcm_substream *substream) 1430 { 1431 struct snd_ali *codec = snd_pcm_substream_chip(substream); 1432 struct snd_pcm_runtime *runtime = substream->runtime; 1433 struct snd_ali_voice *pvoice = runtime->private_data; 1434 unsigned int cso; 1435 1436 spin_lock(&codec->reg_lock); 1437 if (!pvoice->running) { 1438 spin_unlock_irq(&codec->reg_lock); 1439 return 0; 1440 } 1441 outb(pvoice->number, ALI_REG(codec, ALI_GC_CIR)); 1442 cso = inw(ALI_REG(codec, ALI_CSO_ALPHA_FMS + 2)); 1443 spin_unlock(&codec->reg_lock); 1444 1445 return cso; 1446 } 1447 1448 static struct snd_pcm_hardware snd_ali_playback = 1449 { 1450 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 1451 SNDRV_PCM_INFO_BLOCK_TRANSFER | 1452 SNDRV_PCM_INFO_MMAP_VALID | 1453 SNDRV_PCM_INFO_RESUME | 1454 SNDRV_PCM_INFO_SYNC_START), 1455 .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | 1456 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE), 1457 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, 1458 .rate_min = 4000, 1459 .rate_max = 48000, 1460 .channels_min = 1, 1461 .channels_max = 2, 1462 .buffer_bytes_max = (256*1024), 1463 .period_bytes_min = 64, 1464 .period_bytes_max = (256*1024), 1465 .periods_min = 1, 1466 .periods_max = 1024, 1467 .fifo_size = 0, 1468 }; 1469 1470 /* 1471 * Capture support device description 1472 */ 1473 1474 static struct snd_pcm_hardware snd_ali_capture = 1475 { 1476 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 1477 SNDRV_PCM_INFO_BLOCK_TRANSFER | 1478 SNDRV_PCM_INFO_MMAP_VALID | 1479 SNDRV_PCM_INFO_RESUME | 1480 SNDRV_PCM_INFO_SYNC_START), 1481 .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | 1482 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE), 1483 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, 1484 .rate_min = 4000, 1485 .rate_max = 48000, 1486 .channels_min = 1, 1487 .channels_max = 2, 1488 .buffer_bytes_max = (128*1024), 1489 .period_bytes_min = 64, 1490 .period_bytes_max = (128*1024), 1491 .periods_min = 1, 1492 .periods_max = 1024, 1493 .fifo_size = 0, 1494 }; 1495 1496 static void snd_ali_pcm_free_substream(struct snd_pcm_runtime *runtime) 1497 { 1498 struct snd_ali_voice *pvoice = runtime->private_data; 1499 struct snd_ali *codec; 1500 1501 if (pvoice) { 1502 codec = pvoice->codec; 1503 snd_ali_free_voice(pvoice->codec, pvoice); 1504 } 1505 } 1506 1507 static int snd_ali_open(struct snd_pcm_substream *substream, int rec, 1508 int channel, struct snd_pcm_hardware *phw) 1509 { 1510 struct snd_ali *codec = snd_pcm_substream_chip(substream); 1511 struct snd_pcm_runtime *runtime = substream->runtime; 1512 struct snd_ali_voice *pvoice; 1513 1514 pvoice = snd_ali_alloc_voice(codec, SNDRV_ALI_VOICE_TYPE_PCM, rec, 1515 channel); 1516 if (!pvoice) 1517 return -EAGAIN; 1518 1519 pvoice->substream = substream; 1520 runtime->private_data = pvoice; 1521 runtime->private_free = snd_ali_pcm_free_substream; 1522 1523 runtime->hw = *phw; 1524 snd_pcm_set_sync(substream); 1525 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 1526 0, 64*1024); 1527 return 0; 1528 } 1529 1530 static int snd_ali_playback_open(struct snd_pcm_substream *substream) 1531 { 1532 return snd_ali_open(substream, 0, -1, &snd_ali_playback); 1533 } 1534 1535 static int snd_ali_capture_open(struct snd_pcm_substream *substream) 1536 { 1537 return snd_ali_open(substream, 1, -1, &snd_ali_capture); 1538 } 1539 1540 static int snd_ali_playback_close(struct snd_pcm_substream *substream) 1541 { 1542 return 0; 1543 } 1544 1545 static int snd_ali_close(struct snd_pcm_substream *substream) 1546 { 1547 struct snd_ali *codec = snd_pcm_substream_chip(substream); 1548 struct snd_ali_voice *pvoice = substream->runtime->private_data; 1549 1550 snd_ali_disable_special_channel(codec,pvoice->number); 1551 1552 return 0; 1553 } 1554 1555 static struct snd_pcm_ops snd_ali_playback_ops = { 1556 .open = snd_ali_playback_open, 1557 .close = snd_ali_playback_close, 1558 .ioctl = snd_pcm_lib_ioctl, 1559 .hw_params = snd_ali_playback_hw_params, 1560 .hw_free = snd_ali_playback_hw_free, 1561 .prepare = snd_ali_playback_prepare, 1562 .trigger = snd_ali_trigger, 1563 .pointer = snd_ali_playback_pointer, 1564 }; 1565 1566 static struct snd_pcm_ops snd_ali_capture_ops = { 1567 .open = snd_ali_capture_open, 1568 .close = snd_ali_close, 1569 .ioctl = snd_pcm_lib_ioctl, 1570 .hw_params = snd_ali_hw_params, 1571 .hw_free = snd_ali_hw_free, 1572 .prepare = snd_ali_prepare, 1573 .trigger = snd_ali_trigger, 1574 .pointer = snd_ali_pointer, 1575 }; 1576 1577 /* 1578 * Modem PCM 1579 */ 1580 1581 static int snd_ali_modem_hw_params(struct snd_pcm_substream *substream, 1582 struct snd_pcm_hw_params *hw_params) 1583 { 1584 struct snd_ali *chip = snd_pcm_substream_chip(substream); 1585 unsigned int modem_num = chip->num_of_codecs - 1; 1586 snd_ac97_write(chip->ac97[modem_num], AC97_LINE1_RATE, 1587 params_rate(hw_params)); 1588 snd_ac97_write(chip->ac97[modem_num], AC97_LINE1_LEVEL, 0); 1589 return snd_ali_hw_params(substream, hw_params); 1590 } 1591 1592 static struct snd_pcm_hardware snd_ali_modem = 1593 { 1594 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 1595 SNDRV_PCM_INFO_BLOCK_TRANSFER | 1596 SNDRV_PCM_INFO_MMAP_VALID | 1597 SNDRV_PCM_INFO_RESUME | 1598 SNDRV_PCM_INFO_SYNC_START), 1599 .formats = SNDRV_PCM_FMTBIT_S16_LE, 1600 .rates = (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000 | 1601 SNDRV_PCM_RATE_16000), 1602 .rate_min = 8000, 1603 .rate_max = 16000, 1604 .channels_min = 1, 1605 .channels_max = 1, 1606 .buffer_bytes_max = (256*1024), 1607 .period_bytes_min = 64, 1608 .period_bytes_max = (256*1024), 1609 .periods_min = 1, 1610 .periods_max = 1024, 1611 .fifo_size = 0, 1612 }; 1613 1614 static int snd_ali_modem_open(struct snd_pcm_substream *substream, int rec, 1615 int channel) 1616 { 1617 static unsigned int rates[] = {8000, 9600, 12000, 16000}; 1618 static struct snd_pcm_hw_constraint_list hw_constraint_rates = { 1619 .count = ARRAY_SIZE(rates), 1620 .list = rates, 1621 .mask = 0, 1622 }; 1623 int err = snd_ali_open(substream, rec, channel, &snd_ali_modem); 1624 1625 if (err) 1626 return err; 1627 return snd_pcm_hw_constraint_list(substream->runtime, 0, 1628 SNDRV_PCM_HW_PARAM_RATE, &hw_constraint_rates); 1629 } 1630 1631 static int snd_ali_modem_playback_open(struct snd_pcm_substream *substream) 1632 { 1633 return snd_ali_modem_open(substream, 0, ALI_MODEM_OUT_CHANNEL); 1634 } 1635 1636 static int snd_ali_modem_capture_open(struct snd_pcm_substream *substream) 1637 { 1638 return snd_ali_modem_open(substream, 1, ALI_MODEM_IN_CHANNEL); 1639 } 1640 1641 static struct snd_pcm_ops snd_ali_modem_playback_ops = { 1642 .open = snd_ali_modem_playback_open, 1643 .close = snd_ali_close, 1644 .ioctl = snd_pcm_lib_ioctl, 1645 .hw_params = snd_ali_modem_hw_params, 1646 .hw_free = snd_ali_hw_free, 1647 .prepare = snd_ali_prepare, 1648 .trigger = snd_ali_trigger, 1649 .pointer = snd_ali_pointer, 1650 }; 1651 1652 static struct snd_pcm_ops snd_ali_modem_capture_ops = { 1653 .open = snd_ali_modem_capture_open, 1654 .close = snd_ali_close, 1655 .ioctl = snd_pcm_lib_ioctl, 1656 .hw_params = snd_ali_modem_hw_params, 1657 .hw_free = snd_ali_hw_free, 1658 .prepare = snd_ali_prepare, 1659 .trigger = snd_ali_trigger, 1660 .pointer = snd_ali_pointer, 1661 }; 1662 1663 1664 struct ali_pcm_description { 1665 char *name; 1666 unsigned int playback_num; 1667 unsigned int capture_num; 1668 struct snd_pcm_ops *playback_ops; 1669 struct snd_pcm_ops *capture_ops; 1670 unsigned short class; 1671 }; 1672 1673 1674 static void snd_ali_pcm_free(struct snd_pcm *pcm) 1675 { 1676 struct snd_ali *codec = pcm->private_data; 1677 codec->pcm[pcm->device] = NULL; 1678 } 1679 1680 1681 static int snd_ali_pcm(struct snd_ali *codec, int device, 1682 struct ali_pcm_description *desc) 1683 { 1684 struct snd_pcm *pcm; 1685 int err; 1686 1687 err = snd_pcm_new(codec->card, desc->name, device, 1688 desc->playback_num, desc->capture_num, &pcm); 1689 if (err < 0) { 1690 snd_printk(KERN_ERR "snd_ali_pcm: err called snd_pcm_new.\n"); 1691 return err; 1692 } 1693 pcm->private_data = codec; 1694 pcm->private_free = snd_ali_pcm_free; 1695 if (desc->playback_ops) 1696 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 1697 desc->playback_ops); 1698 if (desc->capture_ops) 1699 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 1700 desc->capture_ops); 1701 1702 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, 1703 snd_dma_pci_data(codec->pci), 1704 64*1024, 128*1024); 1705 1706 pcm->info_flags = 0; 1707 pcm->dev_class = desc->class; 1708 pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX; 1709 strcpy(pcm->name, desc->name); 1710 codec->pcm[0] = pcm; 1711 return 0; 1712 } 1713 1714 static struct ali_pcm_description ali_pcms[] = { 1715 { .name = "ALI 5451", 1716 .playback_num = ALI_CHANNELS, 1717 .capture_num = 1, 1718 .playback_ops = &snd_ali_playback_ops, 1719 .capture_ops = &snd_ali_capture_ops 1720 }, 1721 { .name = "ALI 5451 modem", 1722 .playback_num = 1, 1723 .capture_num = 1, 1724 .playback_ops = &snd_ali_modem_playback_ops, 1725 .capture_ops = &snd_ali_modem_capture_ops, 1726 .class = SNDRV_PCM_CLASS_MODEM 1727 } 1728 }; 1729 1730 static int snd_ali_build_pcms(struct snd_ali *codec) 1731 { 1732 int i, err; 1733 for (i = 0; i < codec->num_of_codecs && i < ARRAY_SIZE(ali_pcms); i++) { 1734 err = snd_ali_pcm(codec, i, &ali_pcms[i]); 1735 if (err < 0) 1736 return err; 1737 } 1738 return 0; 1739 } 1740 1741 1742 #define ALI5451_SPDIF(xname, xindex, value) \ 1743 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\ 1744 .info = snd_ali5451_spdif_info, .get = snd_ali5451_spdif_get, \ 1745 .put = snd_ali5451_spdif_put, .private_value = value} 1746 1747 #define snd_ali5451_spdif_info snd_ctl_boolean_mono_info 1748 1749 static int snd_ali5451_spdif_get(struct snd_kcontrol *kcontrol, 1750 struct snd_ctl_elem_value *ucontrol) 1751 { 1752 struct snd_ali *codec = kcontrol->private_data; 1753 unsigned int spdif_enable; 1754 1755 spdif_enable = ucontrol->value.integer.value[0] ? 1 : 0; 1756 1757 spin_lock_irq(&codec->reg_lock); 1758 switch (kcontrol->private_value) { 1759 case 0: 1760 spdif_enable = (codec->spdif_mask & 0x02) ? 1 : 0; 1761 break; 1762 case 1: 1763 spdif_enable = ((codec->spdif_mask & 0x02) && 1764 (codec->spdif_mask & 0x04)) ? 1 : 0; 1765 break; 1766 case 2: 1767 spdif_enable = (codec->spdif_mask & 0x01) ? 1 : 0; 1768 break; 1769 default: 1770 break; 1771 } 1772 ucontrol->value.integer.value[0] = spdif_enable; 1773 spin_unlock_irq(&codec->reg_lock); 1774 return 0; 1775 } 1776 1777 static int snd_ali5451_spdif_put(struct snd_kcontrol *kcontrol, 1778 struct snd_ctl_elem_value *ucontrol) 1779 { 1780 struct snd_ali *codec = kcontrol->private_data; 1781 unsigned int change = 0, spdif_enable = 0; 1782 1783 spdif_enable = ucontrol->value.integer.value[0] ? 1 : 0; 1784 1785 spin_lock_irq(&codec->reg_lock); 1786 switch (kcontrol->private_value) { 1787 case 0: 1788 change = (codec->spdif_mask & 0x02) ? 1 : 0; 1789 change = change ^ spdif_enable; 1790 if (change) { 1791 if (spdif_enable) { 1792 codec->spdif_mask |= 0x02; 1793 snd_ali_enable_spdif_out(codec); 1794 } else { 1795 codec->spdif_mask &= ~(0x02); 1796 codec->spdif_mask &= ~(0x04); 1797 snd_ali_disable_spdif_out(codec); 1798 } 1799 } 1800 break; 1801 case 1: 1802 change = (codec->spdif_mask & 0x04) ? 1 : 0; 1803 change = change ^ spdif_enable; 1804 if (change && (codec->spdif_mask & 0x02)) { 1805 if (spdif_enable) { 1806 codec->spdif_mask |= 0x04; 1807 snd_ali_enable_spdif_chnout(codec); 1808 } else { 1809 codec->spdif_mask &= ~(0x04); 1810 snd_ali_disable_spdif_chnout(codec); 1811 } 1812 } 1813 break; 1814 case 2: 1815 change = (codec->spdif_mask & 0x01) ? 1 : 0; 1816 change = change ^ spdif_enable; 1817 if (change) { 1818 if (spdif_enable) { 1819 codec->spdif_mask |= 0x01; 1820 snd_ali_enable_spdif_in(codec); 1821 } else { 1822 codec->spdif_mask &= ~(0x01); 1823 snd_ali_disable_spdif_in(codec); 1824 } 1825 } 1826 break; 1827 default: 1828 break; 1829 } 1830 spin_unlock_irq(&codec->reg_lock); 1831 1832 return change; 1833 } 1834 1835 static struct snd_kcontrol_new snd_ali5451_mixer_spdif[] = { 1836 /* spdif aplayback switch */ 1837 /* FIXME: "IEC958 Playback Switch" may conflict with one on ac97_codec */ 1838 ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("Output ",NONE,SWITCH), 0, 0), 1839 /* spdif out to spdif channel */ 1840 ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("Channel Output ",NONE,SWITCH), 0, 1), 1841 /* spdif in from spdif channel */ 1842 ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), 0, 2) 1843 }; 1844 1845 static int snd_ali_mixer(struct snd_ali *codec) 1846 { 1847 struct snd_ac97_template ac97; 1848 unsigned int idx; 1849 int i, err; 1850 static struct snd_ac97_bus_ops ops = { 1851 .write = snd_ali_codec_write, 1852 .read = snd_ali_codec_read, 1853 }; 1854 1855 err = snd_ac97_bus(codec->card, 0, &ops, codec, &codec->ac97_bus); 1856 if (err < 0) 1857 return err; 1858 1859 memset(&ac97, 0, sizeof(ac97)); 1860 ac97.private_data = codec; 1861 1862 for (i = 0; i < codec->num_of_codecs; i++) { 1863 ac97.num = i; 1864 err = snd_ac97_mixer(codec->ac97_bus, &ac97, &codec->ac97[i]); 1865 if (err < 0) { 1866 snd_printk(KERN_ERR 1867 "ali mixer %d creating error.\n", i); 1868 if (i == 0) 1869 return err; 1870 codec->num_of_codecs = 1; 1871 break; 1872 } 1873 } 1874 1875 if (codec->spdif_support) { 1876 for (idx = 0; idx < ARRAY_SIZE(snd_ali5451_mixer_spdif); idx++) { 1877 err = snd_ctl_add(codec->card, 1878 snd_ctl_new1(&snd_ali5451_mixer_spdif[idx], codec)); 1879 if (err < 0) 1880 return err; 1881 } 1882 } 1883 return 0; 1884 } 1885 1886 #ifdef CONFIG_PM_SLEEP 1887 static int ali_suspend(struct device *dev) 1888 { 1889 struct pci_dev *pci = to_pci_dev(dev); 1890 struct snd_card *card = dev_get_drvdata(dev); 1891 struct snd_ali *chip = card->private_data; 1892 struct snd_ali_image *im; 1893 int i, j; 1894 1895 im = chip->image; 1896 if (!im) 1897 return 0; 1898 1899 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 1900 for (i = 0; i < chip->num_of_codecs; i++) { 1901 snd_pcm_suspend_all(chip->pcm[i]); 1902 snd_ac97_suspend(chip->ac97[i]); 1903 } 1904 1905 spin_lock_irq(&chip->reg_lock); 1906 1907 im->regs[ALI_MISCINT >> 2] = inl(ALI_REG(chip, ALI_MISCINT)); 1908 /* im->regs[ALI_START >> 2] = inl(ALI_REG(chip, ALI_START)); */ 1909 im->regs[ALI_STOP >> 2] = inl(ALI_REG(chip, ALI_STOP)); 1910 1911 /* disable all IRQ bits */ 1912 outl(0, ALI_REG(chip, ALI_MISCINT)); 1913 1914 for (i = 0; i < ALI_GLOBAL_REGS; i++) { 1915 if ((i*4 == ALI_MISCINT) || (i*4 == ALI_STOP)) 1916 continue; 1917 im->regs[i] = inl(ALI_REG(chip, i*4)); 1918 } 1919 1920 for (i = 0; i < ALI_CHANNELS; i++) { 1921 outb(i, ALI_REG(chip, ALI_GC_CIR)); 1922 for (j = 0; j < ALI_CHANNEL_REGS; j++) 1923 im->channel_regs[i][j] = inl(ALI_REG(chip, j*4 + 0xe0)); 1924 } 1925 1926 /* stop all HW channel */ 1927 outl(0xffffffff, ALI_REG(chip, ALI_STOP)); 1928 1929 spin_unlock_irq(&chip->reg_lock); 1930 1931 pci_disable_device(pci); 1932 pci_save_state(pci); 1933 pci_set_power_state(pci, PCI_D3hot); 1934 return 0; 1935 } 1936 1937 static int ali_resume(struct device *dev) 1938 { 1939 struct pci_dev *pci = to_pci_dev(dev); 1940 struct snd_card *card = dev_get_drvdata(dev); 1941 struct snd_ali *chip = card->private_data; 1942 struct snd_ali_image *im; 1943 int i, j; 1944 1945 im = chip->image; 1946 if (!im) 1947 return 0; 1948 1949 pci_set_power_state(pci, PCI_D0); 1950 pci_restore_state(pci); 1951 if (pci_enable_device(pci) < 0) { 1952 printk(KERN_ERR "ali5451: pci_enable_device failed, " 1953 "disabling device\n"); 1954 snd_card_disconnect(card); 1955 return -EIO; 1956 } 1957 pci_set_master(pci); 1958 1959 spin_lock_irq(&chip->reg_lock); 1960 1961 for (i = 0; i < ALI_CHANNELS; i++) { 1962 outb(i, ALI_REG(chip, ALI_GC_CIR)); 1963 for (j = 0; j < ALI_CHANNEL_REGS; j++) 1964 outl(im->channel_regs[i][j], ALI_REG(chip, j*4 + 0xe0)); 1965 } 1966 1967 for (i = 0; i < ALI_GLOBAL_REGS; i++) { 1968 if ((i*4 == ALI_MISCINT) || (i*4 == ALI_STOP) || 1969 (i*4 == ALI_START)) 1970 continue; 1971 outl(im->regs[i], ALI_REG(chip, i*4)); 1972 } 1973 1974 /* start HW channel */ 1975 outl(im->regs[ALI_START >> 2], ALI_REG(chip, ALI_START)); 1976 /* restore IRQ enable bits */ 1977 outl(im->regs[ALI_MISCINT >> 2], ALI_REG(chip, ALI_MISCINT)); 1978 1979 spin_unlock_irq(&chip->reg_lock); 1980 1981 for (i = 0 ; i < chip->num_of_codecs; i++) 1982 snd_ac97_resume(chip->ac97[i]); 1983 1984 snd_power_change_state(card, SNDRV_CTL_POWER_D0); 1985 return 0; 1986 } 1987 1988 static SIMPLE_DEV_PM_OPS(ali_pm, ali_suspend, ali_resume); 1989 #define ALI_PM_OPS &ali_pm 1990 #else 1991 #define ALI_PM_OPS NULL 1992 #endif /* CONFIG_PM_SLEEP */ 1993 1994 static int snd_ali_free(struct snd_ali * codec) 1995 { 1996 if (codec->hw_initialized) 1997 snd_ali_disable_address_interrupt(codec); 1998 if (codec->irq >= 0) 1999 free_irq(codec->irq, codec); 2000 if (codec->port) 2001 pci_release_regions(codec->pci); 2002 pci_disable_device(codec->pci); 2003 #ifdef CONFIG_PM_SLEEP 2004 kfree(codec->image); 2005 #endif 2006 pci_dev_put(codec->pci_m1533); 2007 pci_dev_put(codec->pci_m7101); 2008 kfree(codec); 2009 return 0; 2010 } 2011 2012 static int snd_ali_chip_init(struct snd_ali *codec) 2013 { 2014 unsigned int legacy; 2015 unsigned char temp; 2016 struct pci_dev *pci_dev; 2017 2018 snd_ali_printk("chip initializing ... \n"); 2019 2020 if (snd_ali_reset_5451(codec)) { 2021 snd_printk(KERN_ERR "ali_chip_init: reset 5451 error.\n"); 2022 return -1; 2023 } 2024 2025 if (codec->revision == ALI_5451_V02) { 2026 pci_dev = codec->pci_m1533; 2027 pci_read_config_byte(pci_dev, 0x59, &temp); 2028 temp |= 0x80; 2029 pci_write_config_byte(pci_dev, 0x59, temp); 2030 2031 pci_dev = codec->pci_m7101; 2032 pci_read_config_byte(pci_dev, 0xb8, &temp); 2033 temp |= 0x20; 2034 pci_write_config_byte(pci_dev, 0xB8, temp); 2035 } 2036 2037 pci_read_config_dword(codec->pci, 0x44, &legacy); 2038 legacy &= 0xff00ff00; 2039 legacy |= 0x000800aa; 2040 pci_write_config_dword(codec->pci, 0x44, legacy); 2041 2042 outl(0x80000001, ALI_REG(codec, ALI_GLOBAL_CONTROL)); 2043 outl(0x00000000, ALI_REG(codec, ALI_AINTEN)); 2044 outl(0xffffffff, ALI_REG(codec, ALI_AINT)); 2045 outl(0x00000000, ALI_REG(codec, ALI_VOLUME)); 2046 outb(0x10, ALI_REG(codec, ALI_MPUR2)); 2047 2048 codec->ac97_ext_id = snd_ali_codec_peek(codec, 0, AC97_EXTENDED_ID); 2049 codec->ac97_ext_status = snd_ali_codec_peek(codec, 0, 2050 AC97_EXTENDED_STATUS); 2051 if (codec->spdif_support) { 2052 snd_ali_enable_spdif_out(codec); 2053 codec->spdif_mask = 0x00000002; 2054 } 2055 2056 codec->num_of_codecs = 1; 2057 2058 /* secondary codec - modem */ 2059 if (inl(ALI_REG(codec, ALI_SCTRL)) & ALI_SCTRL_CODEC2_READY) { 2060 codec->num_of_codecs++; 2061 outl(inl(ALI_REG(codec, ALI_SCTRL)) | 2062 (ALI_SCTRL_LINE_IN2 | ALI_SCTRL_GPIO_IN2 | 2063 ALI_SCTRL_LINE_OUT_EN), 2064 ALI_REG(codec, ALI_SCTRL)); 2065 } 2066 2067 snd_ali_printk("chip initialize succeed.\n"); 2068 return 0; 2069 2070 } 2071 2072 /* proc for register dump */ 2073 static void snd_ali_proc_read(struct snd_info_entry *entry, 2074 struct snd_info_buffer *buf) 2075 { 2076 struct snd_ali *codec = entry->private_data; 2077 int i; 2078 for (i = 0; i < 256 ; i+= 4) 2079 snd_iprintf(buf, "%02x: %08x\n", i, inl(ALI_REG(codec, i))); 2080 } 2081 2082 static void snd_ali_proc_init(struct snd_ali *codec) 2083 { 2084 struct snd_info_entry *entry; 2085 if (!snd_card_proc_new(codec->card, "ali5451", &entry)) 2086 snd_info_set_text_ops(entry, codec, snd_ali_proc_read); 2087 } 2088 2089 static int snd_ali_resources(struct snd_ali *codec) 2090 { 2091 int err; 2092 2093 snd_ali_printk("resources allocation ...\n"); 2094 err = pci_request_regions(codec->pci, "ALI 5451"); 2095 if (err < 0) 2096 return err; 2097 codec->port = pci_resource_start(codec->pci, 0); 2098 2099 if (request_irq(codec->pci->irq, snd_ali_card_interrupt, 2100 IRQF_SHARED, KBUILD_MODNAME, codec)) { 2101 snd_printk(KERN_ERR "Unable to request irq.\n"); 2102 return -EBUSY; 2103 } 2104 codec->irq = codec->pci->irq; 2105 snd_ali_printk("resources allocated.\n"); 2106 return 0; 2107 } 2108 static int snd_ali_dev_free(struct snd_device *device) 2109 { 2110 struct snd_ali *codec = device->device_data; 2111 snd_ali_free(codec); 2112 return 0; 2113 } 2114 2115 static int snd_ali_create(struct snd_card *card, 2116 struct pci_dev *pci, 2117 int pcm_streams, 2118 int spdif_support, 2119 struct snd_ali **r_ali) 2120 { 2121 struct snd_ali *codec; 2122 int i, err; 2123 unsigned short cmdw; 2124 static struct snd_device_ops ops = { 2125 .dev_free = snd_ali_dev_free, 2126 }; 2127 2128 *r_ali = NULL; 2129 2130 snd_ali_printk("creating ...\n"); 2131 2132 /* enable PCI device */ 2133 err = pci_enable_device(pci); 2134 if (err < 0) 2135 return err; 2136 /* check, if we can restrict PCI DMA transfers to 31 bits */ 2137 if (pci_set_dma_mask(pci, DMA_BIT_MASK(31)) < 0 || 2138 pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(31)) < 0) { 2139 snd_printk(KERN_ERR "architecture does not support " 2140 "31bit PCI busmaster DMA\n"); 2141 pci_disable_device(pci); 2142 return -ENXIO; 2143 } 2144 2145 codec = kzalloc(sizeof(*codec), GFP_KERNEL); 2146 if (!codec) { 2147 pci_disable_device(pci); 2148 return -ENOMEM; 2149 } 2150 2151 spin_lock_init(&codec->reg_lock); 2152 spin_lock_init(&codec->voice_alloc); 2153 2154 codec->card = card; 2155 codec->pci = pci; 2156 codec->irq = -1; 2157 codec->revision = pci->revision; 2158 codec->spdif_support = spdif_support; 2159 2160 if (pcm_streams < 1) 2161 pcm_streams = 1; 2162 if (pcm_streams > 32) 2163 pcm_streams = 32; 2164 2165 pci_set_master(pci); 2166 pci_read_config_word(pci, PCI_COMMAND, &cmdw); 2167 if ((cmdw & PCI_COMMAND_IO) != PCI_COMMAND_IO) { 2168 cmdw |= PCI_COMMAND_IO; 2169 pci_write_config_word(pci, PCI_COMMAND, cmdw); 2170 } 2171 pci_set_master(pci); 2172 2173 if (snd_ali_resources(codec)) { 2174 snd_ali_free(codec); 2175 return -EBUSY; 2176 } 2177 2178 synchronize_irq(pci->irq); 2179 2180 codec->synth.chmap = 0; 2181 codec->synth.chcnt = 0; 2182 codec->spdif_mask = 0; 2183 codec->synth.synthcount = 0; 2184 2185 if (codec->revision == ALI_5451_V02) 2186 codec->chregs.regs.ac97read = ALI_AC97_WRITE; 2187 else 2188 codec->chregs.regs.ac97read = ALI_AC97_READ; 2189 codec->chregs.regs.ac97write = ALI_AC97_WRITE; 2190 2191 codec->chregs.regs.start = ALI_START; 2192 codec->chregs.regs.stop = ALI_STOP; 2193 codec->chregs.regs.aint = ALI_AINT; 2194 codec->chregs.regs.ainten = ALI_AINTEN; 2195 2196 codec->chregs.data.start = 0x00; 2197 codec->chregs.data.stop = 0x00; 2198 codec->chregs.data.aint = 0x00; 2199 codec->chregs.data.ainten = 0x00; 2200 2201 /* M1533: southbridge */ 2202 codec->pci_m1533 = pci_get_device(0x10b9, 0x1533, NULL); 2203 if (!codec->pci_m1533) { 2204 snd_printk(KERN_ERR "ali5451: cannot find ALi 1533 chip.\n"); 2205 snd_ali_free(codec); 2206 return -ENODEV; 2207 } 2208 /* M7101: power management */ 2209 codec->pci_m7101 = pci_get_device(0x10b9, 0x7101, NULL); 2210 if (!codec->pci_m7101 && codec->revision == ALI_5451_V02) { 2211 snd_printk(KERN_ERR "ali5451: cannot find ALi 7101 chip.\n"); 2212 snd_ali_free(codec); 2213 return -ENODEV; 2214 } 2215 2216 snd_ali_printk("snd_device_new is called.\n"); 2217 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, codec, &ops); 2218 if (err < 0) { 2219 snd_ali_free(codec); 2220 return err; 2221 } 2222 2223 snd_card_set_dev(card, &pci->dev); 2224 2225 /* initialise synth voices*/ 2226 for (i = 0; i < ALI_CHANNELS; i++) 2227 codec->synth.voices[i].number = i; 2228 2229 err = snd_ali_chip_init(codec); 2230 if (err < 0) { 2231 snd_printk(KERN_ERR "ali create: chip init error.\n"); 2232 return err; 2233 } 2234 2235 #ifdef CONFIG_PM_SLEEP 2236 codec->image = kmalloc(sizeof(*codec->image), GFP_KERNEL); 2237 if (!codec->image) 2238 snd_printk(KERN_WARNING "can't allocate apm buffer\n"); 2239 #endif 2240 2241 snd_ali_enable_address_interrupt(codec); 2242 codec->hw_initialized = 1; 2243 2244 *r_ali = codec; 2245 snd_ali_printk("created.\n"); 2246 return 0; 2247 } 2248 2249 static int snd_ali_probe(struct pci_dev *pci, 2250 const struct pci_device_id *pci_id) 2251 { 2252 struct snd_card *card; 2253 struct snd_ali *codec; 2254 int err; 2255 2256 snd_ali_printk("probe ...\n"); 2257 2258 err = snd_card_create(index, id, THIS_MODULE, 0, &card); 2259 if (err < 0) 2260 return err; 2261 2262 err = snd_ali_create(card, pci, pcm_channels, spdif, &codec); 2263 if (err < 0) 2264 goto error; 2265 card->private_data = codec; 2266 2267 snd_ali_printk("mixer building ...\n"); 2268 err = snd_ali_mixer(codec); 2269 if (err < 0) 2270 goto error; 2271 2272 snd_ali_printk("pcm building ...\n"); 2273 err = snd_ali_build_pcms(codec); 2274 if (err < 0) 2275 goto error; 2276 2277 snd_ali_proc_init(codec); 2278 2279 strcpy(card->driver, "ALI5451"); 2280 strcpy(card->shortname, "ALI 5451"); 2281 2282 sprintf(card->longname, "%s at 0x%lx, irq %i", 2283 card->shortname, codec->port, codec->irq); 2284 2285 snd_ali_printk("register card.\n"); 2286 err = snd_card_register(card); 2287 if (err < 0) 2288 goto error; 2289 2290 pci_set_drvdata(pci, card); 2291 return 0; 2292 2293 error: 2294 snd_card_free(card); 2295 return err; 2296 } 2297 2298 static void snd_ali_remove(struct pci_dev *pci) 2299 { 2300 snd_card_free(pci_get_drvdata(pci)); 2301 pci_set_drvdata(pci, NULL); 2302 } 2303 2304 static struct pci_driver ali5451_driver = { 2305 .name = KBUILD_MODNAME, 2306 .id_table = snd_ali_ids, 2307 .probe = snd_ali_probe, 2308 .remove = snd_ali_remove, 2309 .driver = { 2310 .pm = ALI_PM_OPS, 2311 }, 2312 }; 2313 2314 module_pci_driver(ali5451_driver); 2315