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