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/moduleparam.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 43MODULE_AUTHOR("Matt Wu <Matt_Wu@acersoftech.com.cn>"); 44MODULE_DESCRIPTION("ALI M5451"); 45MODULE_LICENSE("GPL"); 46MODULE_SUPPORTED_DEVICE("{{ALI,M5451,pci},{ALI,M5451}}"); 47 48static int index = SNDRV_DEFAULT_IDX1; /* Index */ 49static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */ 50static int pcm_channels = 32; 51static int spdif; 52 53module_param(index, int, 0444); 54MODULE_PARM_DESC(index, "Index value for ALI M5451 PCI Audio."); 55module_param(id, charp, 0444); 56MODULE_PARM_DESC(id, "ID string for ALI M5451 PCI Audio."); 57module_param(pcm_channels, int, 0444); 58MODULE_PARM_DESC(pcm_channels, "PCM Channels"); 59module_param(spdif, bool, 0444); 60MODULE_PARM_DESC(spdif, "Support SPDIF I/O"); 61 62/* just for backward compatibility */ 63static int enable; 64module_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 173struct snd_ali; 174struct snd_ali_voice; 175 176struct 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 197struct 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 221struct 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 234struct snd_ali_image { 235 u32 regs[ALI_GLOBAL_REGS]; 236 u32 channel_regs[ALI_CHANNELS][ALI_CHANNEL_REGS]; 237}; 238 239 240struct 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 274 struct snd_ali_image *image; 275#endif 276}; 277 278static 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}; 282MODULE_DEVICE_TABLE(pci, snd_ali_ids); 283 284static void snd_ali_clear_voices(struct snd_ali *, unsigned int, unsigned int); 285static unsigned short snd_ali_codec_peek(struct snd_ali *, int, unsigned short); 286static void snd_ali_codec_poke(struct snd_ali *, int, unsigned short, 287 unsigned short); 288 289/* 290 * AC97 ACCESS 291 */ 292 293static 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 299static 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 306static 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 328static 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 349static 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 380static 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 414static 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 431static 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 444static 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 485static 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 495static 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 505static 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 515static 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 525static 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 539static 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 558static 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 606static 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 625static 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 637static 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 652static 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 708static 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 733static 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 748static 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 760static 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 783static 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 816static 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 834static 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 845static 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 855static 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 911static 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 939static 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 969static 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 994static 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 1006static 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 1043static 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 1075static 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 1097static 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 1164static 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 1201static 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 1216static 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 1223static int snd_ali_hw_free(struct snd_pcm_substream *substream) 1224{ 1225 return snd_pcm_lib_free_pages(substream); 1226} 1227 1228static 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 1320static 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 1407static snd_pcm_uframes_t 1408snd_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 1429static 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 1448static 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 1474static 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 1496static 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 1507static 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 1530static int snd_ali_playback_open(struct snd_pcm_substream *substream) 1531{ 1532 return snd_ali_open(substream, 0, -1, &snd_ali_playback); 1533} 1534 1535static int snd_ali_capture_open(struct snd_pcm_substream *substream) 1536{ 1537 return snd_ali_open(substream, 1, -1, &snd_ali_capture); 1538} 1539 1540static int snd_ali_playback_close(struct snd_pcm_substream *substream) 1541{ 1542 return 0; 1543} 1544 1545static 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 1555static 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 1566static 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 1581static 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 1592static 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 1614static 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 1631static 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 1636static 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 1641static 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 1652static 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 1664struct 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 1674static 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 1681static int __devinit 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 1714static 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 1730static int __devinit 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 1749static 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 1777static 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 1835static struct snd_kcontrol_new snd_ali5451_mixer_spdif[] __devinitdata = { 1836 /* spdif aplayback switch */ 1837 ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("Output ",NONE,SWITCH), 0, 0), 1838 /* spdif out to spdif channel */ 1839 ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("Channel Output ",NONE,SWITCH), 0, 1), 1840 /* spdif in from spdif channel */ 1841 ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), 0, 2) 1842}; 1843 1844static int __devinit snd_ali_mixer(struct snd_ali * codec) 1845{ 1846 struct snd_ac97_template ac97; 1847 unsigned int idx; 1848 int i, err; 1849 static struct snd_ac97_bus_ops ops = { 1850 .write = snd_ali_codec_write, 1851 .read = snd_ali_codec_read, 1852 }; 1853 1854 err = snd_ac97_bus(codec->card, 0, &ops, codec, &codec->ac97_bus); 1855 if (err < 0) 1856 return err; 1857 1858 memset(&ac97, 0, sizeof(ac97)); 1859 ac97.private_data = codec; 1860 1861 for (i = 0; i < codec->num_of_codecs; i++) { 1862 ac97.num = i; 1863 err = snd_ac97_mixer(codec->ac97_bus, &ac97, &codec->ac97[i]); 1864 if (err < 0) { 1865 snd_printk(KERN_ERR 1866 "ali mixer %d creating error.\n", i); 1867 if (i == 0) 1868 return err; 1869 codec->num_of_codecs = 1; 1870 break; 1871 } 1872 } 1873 1874 if (codec->spdif_support) { 1875 for (idx = 0; idx < ARRAY_SIZE(snd_ali5451_mixer_spdif); idx++) { 1876 err = snd_ctl_add(codec->card, 1877 snd_ctl_new1(&snd_ali5451_mixer_spdif[idx], codec)); 1878 if (err < 0) 1879 return err; 1880 } 1881 } 1882 return 0; 1883} 1884 1885#ifdef CONFIG_PM 1886static int ali_suspend(struct pci_dev *pci, pm_message_t state) 1887{ 1888 struct snd_card *card = pci_get_drvdata(pci); 1889 struct snd_ali *chip = card->private_data; 1890 struct snd_ali_image *im; 1891 int i, j; 1892 1893 im = chip->image; 1894 if (!im) 1895 return 0; 1896 1897 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 1898 for (i = 0; i < chip->num_of_codecs; i++) { 1899 snd_pcm_suspend_all(chip->pcm[i]); 1900 snd_ac97_suspend(chip->ac97[i]); 1901 } 1902 1903 spin_lock_irq(&chip->reg_lock); 1904 1905 im->regs[ALI_MISCINT >> 2] = inl(ALI_REG(chip, ALI_MISCINT)); 1906 /* im->regs[ALI_START >> 2] = inl(ALI_REG(chip, ALI_START)); */ 1907 im->regs[ALI_STOP >> 2] = inl(ALI_REG(chip, ALI_STOP)); 1908 1909 /* disable all IRQ bits */ 1910 outl(0, ALI_REG(chip, ALI_MISCINT)); 1911 1912 for (i = 0; i < ALI_GLOBAL_REGS; i++) { 1913 if ((i*4 == ALI_MISCINT) || (i*4 == ALI_STOP)) 1914 continue; 1915 im->regs[i] = inl(ALI_REG(chip, i*4)); 1916 } 1917 1918 for (i = 0; i < ALI_CHANNELS; i++) { 1919 outb(i, ALI_REG(chip, ALI_GC_CIR)); 1920 for (j = 0; j < ALI_CHANNEL_REGS; j++) 1921 im->channel_regs[i][j] = inl(ALI_REG(chip, j*4 + 0xe0)); 1922 } 1923 1924 /* stop all HW channel */ 1925 outl(0xffffffff, ALI_REG(chip, ALI_STOP)); 1926 1927 spin_unlock_irq(&chip->reg_lock); 1928 1929 pci_disable_device(pci); 1930 pci_save_state(pci); 1931 pci_set_power_state(pci, pci_choose_state(pci, state)); 1932 return 0; 1933} 1934 1935static int ali_resume(struct pci_dev *pci) 1936{ 1937 struct snd_card *card = pci_get_drvdata(pci); 1938 struct snd_ali *chip = card->private_data; 1939 struct snd_ali_image *im; 1940 int i, j; 1941 1942 im = chip->image; 1943 if (!im) 1944 return 0; 1945 1946 pci_set_power_state(pci, PCI_D0); 1947 pci_restore_state(pci); 1948 if (pci_enable_device(pci) < 0) { 1949 printk(KERN_ERR "ali5451: pci_enable_device failed, " 1950 "disabling device\n"); 1951 snd_card_disconnect(card); 1952 return -EIO; 1953 } 1954 pci_set_master(pci); 1955 1956 spin_lock_irq(&chip->reg_lock); 1957 1958 for (i = 0; i < ALI_CHANNELS; i++) { 1959 outb(i, ALI_REG(chip, ALI_GC_CIR)); 1960 for (j = 0; j < ALI_CHANNEL_REGS; j++) 1961 outl(im->channel_regs[i][j], ALI_REG(chip, j*4 + 0xe0)); 1962 } 1963 1964 for (i = 0; i < ALI_GLOBAL_REGS; i++) { 1965 if ((i*4 == ALI_MISCINT) || (i*4 == ALI_STOP) || 1966 (i*4 == ALI_START)) 1967 continue; 1968 outl(im->regs[i], ALI_REG(chip, i*4)); 1969 } 1970 1971 /* start HW channel */ 1972 outl(im->regs[ALI_START >> 2], ALI_REG(chip, ALI_START)); 1973 /* restore IRQ enable bits */ 1974 outl(im->regs[ALI_MISCINT >> 2], ALI_REG(chip, ALI_MISCINT)); 1975 1976 spin_unlock_irq(&chip->reg_lock); 1977 1978 for (i = 0 ; i < chip->num_of_codecs; i++) 1979 snd_ac97_resume(chip->ac97[i]); 1980 1981 snd_power_change_state(card, SNDRV_CTL_POWER_D0); 1982 return 0; 1983} 1984#endif /* CONFIG_PM */ 1985 1986static int snd_ali_free(struct snd_ali * codec) 1987{ 1988 if (codec->hw_initialized) 1989 snd_ali_disable_address_interrupt(codec); 1990 if (codec->irq >= 0) 1991 free_irq(codec->irq, codec); 1992 if (codec->port) 1993 pci_release_regions(codec->pci); 1994 pci_disable_device(codec->pci); 1995#ifdef CONFIG_PM 1996 kfree(codec->image); 1997#endif 1998 pci_dev_put(codec->pci_m1533); 1999 pci_dev_put(codec->pci_m7101); 2000 kfree(codec); 2001 return 0; 2002} 2003 2004static int snd_ali_chip_init(struct snd_ali *codec) 2005{ 2006 unsigned int legacy; 2007 unsigned char temp; 2008 struct pci_dev *pci_dev; 2009 2010 snd_ali_printk("chip initializing ... \n"); 2011 2012 if (snd_ali_reset_5451(codec)) { 2013 snd_printk(KERN_ERR "ali_chip_init: reset 5451 error.\n"); 2014 return -1; 2015 } 2016 2017 if (codec->revision == ALI_5451_V02) { 2018 pci_dev = codec->pci_m1533; 2019 pci_read_config_byte(pci_dev, 0x59, &temp); 2020 temp |= 0x80; 2021 pci_write_config_byte(pci_dev, 0x59, temp); 2022 2023 pci_dev = codec->pci_m7101; 2024 pci_read_config_byte(pci_dev, 0xb8, &temp); 2025 temp |= 0x20; 2026 pci_write_config_byte(pci_dev, 0xB8, temp); 2027 } 2028 2029 pci_read_config_dword(codec->pci, 0x44, &legacy); 2030 legacy &= 0xff00ff00; 2031 legacy |= 0x000800aa; 2032 pci_write_config_dword(codec->pci, 0x44, legacy); 2033 2034 outl(0x80000001, ALI_REG(codec, ALI_GLOBAL_CONTROL)); 2035 outl(0x00000000, ALI_REG(codec, ALI_AINTEN)); 2036 outl(0xffffffff, ALI_REG(codec, ALI_AINT)); 2037 outl(0x00000000, ALI_REG(codec, ALI_VOLUME)); 2038 outb(0x10, ALI_REG(codec, ALI_MPUR2)); 2039 2040 codec->ac97_ext_id = snd_ali_codec_peek(codec, 0, AC97_EXTENDED_ID); 2041 codec->ac97_ext_status = snd_ali_codec_peek(codec, 0, 2042 AC97_EXTENDED_STATUS); 2043 if (codec->spdif_support) { 2044 snd_ali_enable_spdif_out(codec); 2045 codec->spdif_mask = 0x00000002; 2046 } 2047 2048 codec->num_of_codecs = 1; 2049 2050 /* secondary codec - modem */ 2051 if (inl(ALI_REG(codec, ALI_SCTRL)) & ALI_SCTRL_CODEC2_READY) { 2052 codec->num_of_codecs++; 2053 outl(inl(ALI_REG(codec, ALI_SCTRL)) | 2054 (ALI_SCTRL_LINE_IN2 | ALI_SCTRL_GPIO_IN2 | 2055 ALI_SCTRL_LINE_OUT_EN), 2056 ALI_REG(codec, ALI_SCTRL)); 2057 } 2058 2059 snd_ali_printk("chip initialize succeed.\n"); 2060 return 0; 2061 2062} 2063 2064/* proc for register dump */ 2065static void snd_ali_proc_read(struct snd_info_entry *entry, 2066 struct snd_info_buffer *buf) 2067{ 2068 struct snd_ali *codec = entry->private_data; 2069 int i; 2070 for (i = 0; i < 256 ; i+= 4) 2071 snd_iprintf(buf, "%02x: %08x\n", i, inl(ALI_REG(codec, i))); 2072} 2073 2074static void __devinit snd_ali_proc_init(struct snd_ali *codec) 2075{ 2076 struct snd_info_entry *entry; 2077 if (!snd_card_proc_new(codec->card, "ali5451", &entry)) 2078 snd_info_set_text_ops(entry, codec, snd_ali_proc_read); 2079} 2080 2081static int __devinit snd_ali_resources(struct snd_ali *codec) 2082{ 2083 int err; 2084 2085 snd_ali_printk("resources allocation ...\n"); 2086 err = pci_request_regions(codec->pci, "ALI 5451"); 2087 if (err < 0) 2088 return err; 2089 codec->port = pci_resource_start(codec->pci, 0); 2090 2091 if (request_irq(codec->pci->irq, snd_ali_card_interrupt, 2092 IRQF_SHARED, "ALI 5451", codec)) { 2093 snd_printk(KERN_ERR "Unable to request irq.\n"); 2094 return -EBUSY; 2095 } 2096 codec->irq = codec->pci->irq; 2097 snd_ali_printk("resources allocated.\n"); 2098 return 0; 2099} 2100static int snd_ali_dev_free(struct snd_device *device) 2101{ 2102 struct snd_ali *codec = device->device_data; 2103 snd_ali_free(codec); 2104 return 0; 2105} 2106 2107static int __devinit snd_ali_create(struct snd_card *card, 2108 struct pci_dev *pci, 2109 int pcm_streams, 2110 int spdif_support, 2111 struct snd_ali ** r_ali) 2112{ 2113 struct snd_ali *codec; 2114 int i, err; 2115 unsigned short cmdw; 2116 static struct snd_device_ops ops = { 2117 .dev_free = snd_ali_dev_free, 2118 }; 2119 2120 *r_ali = NULL; 2121 2122 snd_ali_printk("creating ...\n"); 2123 2124 /* enable PCI device */ 2125 err = pci_enable_device(pci); 2126 if (err < 0) 2127 return err; 2128 /* check, if we can restrict PCI DMA transfers to 31 bits */ 2129 if (pci_set_dma_mask(pci, DMA_BIT_MASK(31)) < 0 || 2130 pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(31)) < 0) { 2131 snd_printk(KERN_ERR "architecture does not support " 2132 "31bit PCI busmaster DMA\n"); 2133 pci_disable_device(pci); 2134 return -ENXIO; 2135 } 2136 2137 codec = kzalloc(sizeof(*codec), GFP_KERNEL); 2138 if (!codec) { 2139 pci_disable_device(pci); 2140 return -ENOMEM; 2141 } 2142 2143 spin_lock_init(&codec->reg_lock); 2144 spin_lock_init(&codec->voice_alloc); 2145 2146 codec->card = card; 2147 codec->pci = pci; 2148 codec->irq = -1; 2149 codec->revision = pci->revision; 2150 codec->spdif_support = spdif_support; 2151 2152 if (pcm_streams < 1) 2153 pcm_streams = 1; 2154 if (pcm_streams > 32) 2155 pcm_streams = 32; 2156 2157 pci_set_master(pci); 2158 pci_read_config_word(pci, PCI_COMMAND, &cmdw); 2159 if ((cmdw & PCI_COMMAND_IO) != PCI_COMMAND_IO) { 2160 cmdw |= PCI_COMMAND_IO; 2161 pci_write_config_word(pci, PCI_COMMAND, cmdw); 2162 } 2163 pci_set_master(pci); 2164 2165 if (snd_ali_resources(codec)) { 2166 snd_ali_free(codec); 2167 return -EBUSY; 2168 } 2169 2170 synchronize_irq(pci->irq); 2171 2172 codec->synth.chmap = 0; 2173 codec->synth.chcnt = 0; 2174 codec->spdif_mask = 0; 2175 codec->synth.synthcount = 0; 2176 2177 if (codec->revision == ALI_5451_V02) 2178 codec->chregs.regs.ac97read = ALI_AC97_WRITE; 2179 else 2180 codec->chregs.regs.ac97read = ALI_AC97_READ; 2181 codec->chregs.regs.ac97write = ALI_AC97_WRITE; 2182 2183 codec->chregs.regs.start = ALI_START; 2184 codec->chregs.regs.stop = ALI_STOP; 2185 codec->chregs.regs.aint = ALI_AINT; 2186 codec->chregs.regs.ainten = ALI_AINTEN; 2187 2188 codec->chregs.data.start = 0x00; 2189 codec->chregs.data.stop = 0x00; 2190 codec->chregs.data.aint = 0x00; 2191 codec->chregs.data.ainten = 0x00; 2192 2193 /* M1533: southbridge */ 2194 codec->pci_m1533 = pci_get_device(0x10b9, 0x1533, NULL); 2195 if (!codec->pci_m1533) { 2196 snd_printk(KERN_ERR "ali5451: cannot find ALi 1533 chip.\n"); 2197 snd_ali_free(codec); 2198 return -ENODEV; 2199 } 2200 /* M7101: power management */ 2201 codec->pci_m7101 = pci_get_device(0x10b9, 0x7101, NULL); 2202 if (!codec->pci_m7101 && codec->revision == ALI_5451_V02) { 2203 snd_printk(KERN_ERR "ali5451: cannot find ALi 7101 chip.\n"); 2204 snd_ali_free(codec); 2205 return -ENODEV; 2206 } 2207 2208 snd_ali_printk("snd_device_new is called.\n"); 2209 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, codec, &ops); 2210 if (err < 0) { 2211 snd_ali_free(codec); 2212 return err; 2213 } 2214 2215 snd_card_set_dev(card, &pci->dev); 2216 2217 /* initialise synth voices*/ 2218 for (i = 0; i < ALI_CHANNELS; i++) 2219 codec->synth.voices[i].number = i; 2220 2221 err = snd_ali_chip_init(codec); 2222 if (err < 0) { 2223 snd_printk(KERN_ERR "ali create: chip init error.\n"); 2224 return err; 2225 } 2226 2227#ifdef CONFIG_PM 2228 codec->image = kmalloc(sizeof(*codec->image), GFP_KERNEL); 2229 if (!codec->image) 2230 snd_printk(KERN_WARNING "can't allocate apm buffer\n"); 2231#endif 2232 2233 snd_ali_enable_address_interrupt(codec); 2234 codec->hw_initialized = 1; 2235 2236 *r_ali = codec; 2237 snd_ali_printk("created.\n"); 2238 return 0; 2239} 2240 2241static int __devinit snd_ali_probe(struct pci_dev *pci, 2242 const struct pci_device_id *pci_id) 2243{ 2244 struct snd_card *card; 2245 struct snd_ali *codec; 2246 int err; 2247 2248 snd_ali_printk("probe ...\n"); 2249 2250 err = snd_card_create(index, id, THIS_MODULE, 0, &card); 2251 if (err < 0) 2252 return err; 2253 2254 err = snd_ali_create(card, pci, pcm_channels, spdif, &codec); 2255 if (err < 0) 2256 goto error; 2257 card->private_data = codec; 2258 2259 snd_ali_printk("mixer building ...\n"); 2260 err = snd_ali_mixer(codec); 2261 if (err < 0) 2262 goto error; 2263 2264 snd_ali_printk("pcm building ...\n"); 2265 err = snd_ali_build_pcms(codec); 2266 if (err < 0) 2267 goto error; 2268 2269 snd_ali_proc_init(codec); 2270 2271 strcpy(card->driver, "ALI5451"); 2272 strcpy(card->shortname, "ALI 5451"); 2273 2274 sprintf(card->longname, "%s at 0x%lx, irq %i", 2275 card->shortname, codec->port, codec->irq); 2276 2277 snd_ali_printk("register card.\n"); 2278 err = snd_card_register(card); 2279 if (err < 0) 2280 goto error; 2281 2282 pci_set_drvdata(pci, card); 2283 return 0; 2284 2285 error: 2286 snd_card_free(card); 2287 return err; 2288} 2289 2290static void __devexit snd_ali_remove(struct pci_dev *pci) 2291{ 2292 snd_card_free(pci_get_drvdata(pci)); 2293 pci_set_drvdata(pci, NULL); 2294} 2295 2296static struct pci_driver driver = { 2297 .name = "ALI 5451", 2298 .id_table = snd_ali_ids, 2299 .probe = snd_ali_probe, 2300 .remove = __devexit_p(snd_ali_remove), 2301#ifdef CONFIG_PM 2302 .suspend = ali_suspend, 2303 .resume = ali_resume, 2304#endif 2305}; 2306 2307static int __init alsa_card_ali_init(void) 2308{ 2309 return pci_register_driver(&driver); 2310} 2311 2312static void __exit alsa_card_ali_exit(void) 2313{ 2314 pci_unregister_driver(&driver); 2315} 2316 2317module_init(alsa_card_ali_init) 2318module_exit(alsa_card_ali_exit) 2319