1 /* 2 * ALSA driver for VT1724 ICEnsemble ICE1724 / VIA VT1724 (Envy24HT) 3 * VIA VT1720 (Envy24PT) 4 * 5 * Copyright (c) 2000 Jaroslav Kysela <perex@perex.cz> 6 * 2002 James Stafford <jstafford@ampltd.com> 7 * 2003 Takashi Iwai <tiwai@suse.de> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 * 23 */ 24 25 #include <linux/io.h> 26 #include <linux/delay.h> 27 #include <linux/interrupt.h> 28 #include <linux/init.h> 29 #include <linux/pci.h> 30 #include <linux/slab.h> 31 #include <linux/moduleparam.h> 32 #include <linux/mutex.h> 33 #include <sound/core.h> 34 #include <sound/info.h> 35 #include <sound/rawmidi.h> 36 #include <sound/initval.h> 37 38 #include <sound/asoundef.h> 39 40 #include "ice1712.h" 41 #include "envy24ht.h" 42 43 /* lowlevel routines */ 44 #include "amp.h" 45 #include "revo.h" 46 #include "aureon.h" 47 #include "vt1720_mobo.h" 48 #include "pontis.h" 49 #include "prodigy192.h" 50 #include "prodigy_hifi.h" 51 #include "juli.h" 52 #include "phase.h" 53 #include "wtm.h" 54 #include "se.h" 55 56 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>"); 57 MODULE_DESCRIPTION("VIA ICEnsemble ICE1724/1720 (Envy24HT/PT)"); 58 MODULE_LICENSE("GPL"); 59 MODULE_SUPPORTED_DEVICE("{" 60 REVO_DEVICE_DESC 61 AMP_AUDIO2000_DEVICE_DESC 62 AUREON_DEVICE_DESC 63 VT1720_MOBO_DEVICE_DESC 64 PONTIS_DEVICE_DESC 65 PRODIGY192_DEVICE_DESC 66 PRODIGY_HIFI_DEVICE_DESC 67 JULI_DEVICE_DESC 68 PHASE_DEVICE_DESC 69 WTM_DEVICE_DESC 70 SE_DEVICE_DESC 71 "{VIA,VT1720}," 72 "{VIA,VT1724}," 73 "{ICEnsemble,Generic ICE1724}," 74 "{ICEnsemble,Generic Envy24HT}" 75 "{ICEnsemble,Generic Envy24PT}}"); 76 77 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ 78 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ 79 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */ 80 static char *model[SNDRV_CARDS]; 81 82 module_param_array(index, int, NULL, 0444); 83 MODULE_PARM_DESC(index, "Index value for ICE1724 soundcard."); 84 module_param_array(id, charp, NULL, 0444); 85 MODULE_PARM_DESC(id, "ID string for ICE1724 soundcard."); 86 module_param_array(enable, bool, NULL, 0444); 87 MODULE_PARM_DESC(enable, "Enable ICE1724 soundcard."); 88 module_param_array(model, charp, NULL, 0444); 89 MODULE_PARM_DESC(model, "Use the given board model."); 90 91 92 /* Both VT1720 and VT1724 have the same PCI IDs */ 93 static const struct pci_device_id snd_vt1724_ids[] = { 94 { PCI_VENDOR_ID_ICE, PCI_DEVICE_ID_VT1724, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, 95 { 0, } 96 }; 97 98 MODULE_DEVICE_TABLE(pci, snd_vt1724_ids); 99 100 101 static int PRO_RATE_LOCKED; 102 static int PRO_RATE_RESET = 1; 103 static unsigned int PRO_RATE_DEFAULT = 44100; 104 105 /* 106 * Basic I/O 107 */ 108 109 /* 110 * default rates, default clock routines 111 */ 112 113 /* check whether the clock mode is spdif-in */ 114 static inline int stdclock_is_spdif_master(struct snd_ice1712 *ice) 115 { 116 return (inb(ICEMT1724(ice, RATE)) & VT1724_SPDIF_MASTER) ? 1 : 0; 117 } 118 119 static inline int is_pro_rate_locked(struct snd_ice1712 *ice) 120 { 121 return ice->is_spdif_master(ice) || PRO_RATE_LOCKED; 122 } 123 124 /* 125 * ac97 section 126 */ 127 128 static unsigned char snd_vt1724_ac97_ready(struct snd_ice1712 *ice) 129 { 130 unsigned char old_cmd; 131 int tm; 132 for (tm = 0; tm < 0x10000; tm++) { 133 old_cmd = inb(ICEMT1724(ice, AC97_CMD)); 134 if (old_cmd & (VT1724_AC97_WRITE | VT1724_AC97_READ)) 135 continue; 136 if (!(old_cmd & VT1724_AC97_READY)) 137 continue; 138 return old_cmd; 139 } 140 snd_printd(KERN_ERR "snd_vt1724_ac97_ready: timeout\n"); 141 return old_cmd; 142 } 143 144 static int snd_vt1724_ac97_wait_bit(struct snd_ice1712 *ice, unsigned char bit) 145 { 146 int tm; 147 for (tm = 0; tm < 0x10000; tm++) 148 if ((inb(ICEMT1724(ice, AC97_CMD)) & bit) == 0) 149 return 0; 150 snd_printd(KERN_ERR "snd_vt1724_ac97_wait_bit: timeout\n"); 151 return -EIO; 152 } 153 154 static void snd_vt1724_ac97_write(struct snd_ac97 *ac97, 155 unsigned short reg, 156 unsigned short val) 157 { 158 struct snd_ice1712 *ice = ac97->private_data; 159 unsigned char old_cmd; 160 161 old_cmd = snd_vt1724_ac97_ready(ice); 162 old_cmd &= ~VT1724_AC97_ID_MASK; 163 old_cmd |= ac97->num; 164 outb(reg, ICEMT1724(ice, AC97_INDEX)); 165 outw(val, ICEMT1724(ice, AC97_DATA)); 166 outb(old_cmd | VT1724_AC97_WRITE, ICEMT1724(ice, AC97_CMD)); 167 snd_vt1724_ac97_wait_bit(ice, VT1724_AC97_WRITE); 168 } 169 170 static unsigned short snd_vt1724_ac97_read(struct snd_ac97 *ac97, unsigned short reg) 171 { 172 struct snd_ice1712 *ice = ac97->private_data; 173 unsigned char old_cmd; 174 175 old_cmd = snd_vt1724_ac97_ready(ice); 176 old_cmd &= ~VT1724_AC97_ID_MASK; 177 old_cmd |= ac97->num; 178 outb(reg, ICEMT1724(ice, AC97_INDEX)); 179 outb(old_cmd | VT1724_AC97_READ, ICEMT1724(ice, AC97_CMD)); 180 if (snd_vt1724_ac97_wait_bit(ice, VT1724_AC97_READ) < 0) 181 return ~0; 182 return inw(ICEMT1724(ice, AC97_DATA)); 183 } 184 185 186 /* 187 * GPIO operations 188 */ 189 190 /* set gpio direction 0 = read, 1 = write */ 191 static void snd_vt1724_set_gpio_dir(struct snd_ice1712 *ice, unsigned int data) 192 { 193 outl(data, ICEREG1724(ice, GPIO_DIRECTION)); 194 inw(ICEREG1724(ice, GPIO_DIRECTION)); /* dummy read for pci-posting */ 195 } 196 197 /* set the gpio mask (0 = writable) */ 198 static void snd_vt1724_set_gpio_mask(struct snd_ice1712 *ice, unsigned int data) 199 { 200 outw(data, ICEREG1724(ice, GPIO_WRITE_MASK)); 201 if (!ice->vt1720) /* VT1720 supports only 16 GPIO bits */ 202 outb((data >> 16) & 0xff, ICEREG1724(ice, GPIO_WRITE_MASK_22)); 203 inw(ICEREG1724(ice, GPIO_WRITE_MASK)); /* dummy read for pci-posting */ 204 } 205 206 static void snd_vt1724_set_gpio_data(struct snd_ice1712 *ice, unsigned int data) 207 { 208 outw(data, ICEREG1724(ice, GPIO_DATA)); 209 if (!ice->vt1720) 210 outb(data >> 16, ICEREG1724(ice, GPIO_DATA_22)); 211 inw(ICEREG1724(ice, GPIO_DATA)); /* dummy read for pci-posting */ 212 } 213 214 static unsigned int snd_vt1724_get_gpio_data(struct snd_ice1712 *ice) 215 { 216 unsigned int data; 217 if (!ice->vt1720) 218 data = (unsigned int)inb(ICEREG1724(ice, GPIO_DATA_22)); 219 else 220 data = 0; 221 data = (data << 16) | inw(ICEREG1724(ice, GPIO_DATA)); 222 return data; 223 } 224 225 /* 226 * MIDI 227 */ 228 229 static void vt1724_midi_clear_rx(struct snd_ice1712 *ice) 230 { 231 unsigned int count; 232 233 for (count = inb(ICEREG1724(ice, MPU_RXFIFO)); count > 0; --count) 234 inb(ICEREG1724(ice, MPU_DATA)); 235 } 236 237 static inline struct snd_rawmidi_substream * 238 get_rawmidi_substream(struct snd_ice1712 *ice, unsigned int stream) 239 { 240 return list_first_entry(&ice->rmidi[0]->streams[stream].substreams, 241 struct snd_rawmidi_substream, list); 242 } 243 244 static void enable_midi_irq(struct snd_ice1712 *ice, u8 flag, int enable); 245 246 static void vt1724_midi_write(struct snd_ice1712 *ice) 247 { 248 struct snd_rawmidi_substream *s; 249 int count, i; 250 u8 buffer[32]; 251 252 s = get_rawmidi_substream(ice, SNDRV_RAWMIDI_STREAM_OUTPUT); 253 count = 31 - inb(ICEREG1724(ice, MPU_TXFIFO)); 254 if (count > 0) { 255 count = snd_rawmidi_transmit(s, buffer, count); 256 for (i = 0; i < count; ++i) 257 outb(buffer[i], ICEREG1724(ice, MPU_DATA)); 258 } 259 /* mask irq when all bytes have been transmitted. 260 * enabled again in output_trigger when the new data comes in. 261 */ 262 enable_midi_irq(ice, VT1724_IRQ_MPU_TX, 263 !snd_rawmidi_transmit_empty(s)); 264 } 265 266 static void vt1724_midi_read(struct snd_ice1712 *ice) 267 { 268 struct snd_rawmidi_substream *s; 269 int count, i; 270 u8 buffer[32]; 271 272 s = get_rawmidi_substream(ice, SNDRV_RAWMIDI_STREAM_INPUT); 273 count = inb(ICEREG1724(ice, MPU_RXFIFO)); 274 if (count > 0) { 275 count = min(count, 32); 276 for (i = 0; i < count; ++i) 277 buffer[i] = inb(ICEREG1724(ice, MPU_DATA)); 278 snd_rawmidi_receive(s, buffer, count); 279 } 280 } 281 282 /* call with ice->reg_lock */ 283 static void enable_midi_irq(struct snd_ice1712 *ice, u8 flag, int enable) 284 { 285 u8 mask = inb(ICEREG1724(ice, IRQMASK)); 286 if (enable) 287 mask &= ~flag; 288 else 289 mask |= flag; 290 outb(mask, ICEREG1724(ice, IRQMASK)); 291 } 292 293 static void vt1724_enable_midi_irq(struct snd_rawmidi_substream *substream, 294 u8 flag, int enable) 295 { 296 struct snd_ice1712 *ice = substream->rmidi->private_data; 297 298 spin_lock_irq(&ice->reg_lock); 299 enable_midi_irq(ice, flag, enable); 300 spin_unlock_irq(&ice->reg_lock); 301 } 302 303 static int vt1724_midi_output_open(struct snd_rawmidi_substream *s) 304 { 305 return 0; 306 } 307 308 static int vt1724_midi_output_close(struct snd_rawmidi_substream *s) 309 { 310 return 0; 311 } 312 313 static void vt1724_midi_output_trigger(struct snd_rawmidi_substream *s, int up) 314 { 315 struct snd_ice1712 *ice = s->rmidi->private_data; 316 unsigned long flags; 317 318 spin_lock_irqsave(&ice->reg_lock, flags); 319 if (up) { 320 ice->midi_output = 1; 321 vt1724_midi_write(ice); 322 } else { 323 ice->midi_output = 0; 324 enable_midi_irq(ice, VT1724_IRQ_MPU_TX, 0); 325 } 326 spin_unlock_irqrestore(&ice->reg_lock, flags); 327 } 328 329 static void vt1724_midi_output_drain(struct snd_rawmidi_substream *s) 330 { 331 struct snd_ice1712 *ice = s->rmidi->private_data; 332 unsigned long timeout; 333 334 vt1724_enable_midi_irq(s, VT1724_IRQ_MPU_TX, 0); 335 /* 32 bytes should be transmitted in less than about 12 ms */ 336 timeout = jiffies + msecs_to_jiffies(15); 337 do { 338 if (inb(ICEREG1724(ice, MPU_CTRL)) & VT1724_MPU_TX_EMPTY) 339 break; 340 schedule_timeout_uninterruptible(1); 341 } while (time_after(timeout, jiffies)); 342 } 343 344 static struct snd_rawmidi_ops vt1724_midi_output_ops = { 345 .open = vt1724_midi_output_open, 346 .close = vt1724_midi_output_close, 347 .trigger = vt1724_midi_output_trigger, 348 .drain = vt1724_midi_output_drain, 349 }; 350 351 static int vt1724_midi_input_open(struct snd_rawmidi_substream *s) 352 { 353 vt1724_midi_clear_rx(s->rmidi->private_data); 354 vt1724_enable_midi_irq(s, VT1724_IRQ_MPU_RX, 1); 355 return 0; 356 } 357 358 static int vt1724_midi_input_close(struct snd_rawmidi_substream *s) 359 { 360 vt1724_enable_midi_irq(s, VT1724_IRQ_MPU_RX, 0); 361 return 0; 362 } 363 364 static void vt1724_midi_input_trigger(struct snd_rawmidi_substream *s, int up) 365 { 366 struct snd_ice1712 *ice = s->rmidi->private_data; 367 unsigned long flags; 368 369 spin_lock_irqsave(&ice->reg_lock, flags); 370 if (up) { 371 ice->midi_input = 1; 372 vt1724_midi_read(ice); 373 } else { 374 ice->midi_input = 0; 375 } 376 spin_unlock_irqrestore(&ice->reg_lock, flags); 377 } 378 379 static struct snd_rawmidi_ops vt1724_midi_input_ops = { 380 .open = vt1724_midi_input_open, 381 .close = vt1724_midi_input_close, 382 .trigger = vt1724_midi_input_trigger, 383 }; 384 385 386 /* 387 * Interrupt handler 388 */ 389 390 static irqreturn_t snd_vt1724_interrupt(int irq, void *dev_id) 391 { 392 struct snd_ice1712 *ice = dev_id; 393 unsigned char status; 394 unsigned char status_mask = 395 VT1724_IRQ_MPU_RX | VT1724_IRQ_MPU_TX | VT1724_IRQ_MTPCM; 396 int handled = 0; 397 int timeout = 0; 398 399 while (1) { 400 status = inb(ICEREG1724(ice, IRQSTAT)); 401 status &= status_mask; 402 if (status == 0) 403 break; 404 spin_lock(&ice->reg_lock); 405 if (++timeout > 10) { 406 status = inb(ICEREG1724(ice, IRQSTAT)); 407 printk(KERN_ERR "ice1724: Too long irq loop, " 408 "status = 0x%x\n", status); 409 if (status & VT1724_IRQ_MPU_TX) { 410 printk(KERN_ERR "ice1724: Disabling MPU_TX\n"); 411 enable_midi_irq(ice, VT1724_IRQ_MPU_TX, 0); 412 } 413 spin_unlock(&ice->reg_lock); 414 break; 415 } 416 handled = 1; 417 if (status & VT1724_IRQ_MPU_TX) { 418 if (ice->midi_output) 419 vt1724_midi_write(ice); 420 else 421 enable_midi_irq(ice, VT1724_IRQ_MPU_TX, 0); 422 /* Due to mysterical reasons, MPU_TX is always 423 * generated (and can't be cleared) when a PCM 424 * playback is going. So let's ignore at the 425 * next loop. 426 */ 427 status_mask &= ~VT1724_IRQ_MPU_TX; 428 } 429 if (status & VT1724_IRQ_MPU_RX) { 430 if (ice->midi_input) 431 vt1724_midi_read(ice); 432 else 433 vt1724_midi_clear_rx(ice); 434 } 435 /* ack MPU irq */ 436 outb(status, ICEREG1724(ice, IRQSTAT)); 437 spin_unlock(&ice->reg_lock); 438 if (status & VT1724_IRQ_MTPCM) { 439 /* 440 * Multi-track PCM 441 * PCM assignment are: 442 * Playback DMA0 (M/C) = playback_pro_substream 443 * Playback DMA1 = playback_con_substream_ds[0] 444 * Playback DMA2 = playback_con_substream_ds[1] 445 * Playback DMA3 = playback_con_substream_ds[2] 446 * Playback DMA4 (SPDIF) = playback_con_substream 447 * Record DMA0 = capture_pro_substream 448 * Record DMA1 = capture_con_substream 449 */ 450 unsigned char mtstat = inb(ICEMT1724(ice, IRQ)); 451 if (mtstat & VT1724_MULTI_PDMA0) { 452 if (ice->playback_pro_substream) 453 snd_pcm_period_elapsed(ice->playback_pro_substream); 454 } 455 if (mtstat & VT1724_MULTI_RDMA0) { 456 if (ice->capture_pro_substream) 457 snd_pcm_period_elapsed(ice->capture_pro_substream); 458 } 459 if (mtstat & VT1724_MULTI_PDMA1) { 460 if (ice->playback_con_substream_ds[0]) 461 snd_pcm_period_elapsed(ice->playback_con_substream_ds[0]); 462 } 463 if (mtstat & VT1724_MULTI_PDMA2) { 464 if (ice->playback_con_substream_ds[1]) 465 snd_pcm_period_elapsed(ice->playback_con_substream_ds[1]); 466 } 467 if (mtstat & VT1724_MULTI_PDMA3) { 468 if (ice->playback_con_substream_ds[2]) 469 snd_pcm_period_elapsed(ice->playback_con_substream_ds[2]); 470 } 471 if (mtstat & VT1724_MULTI_PDMA4) { 472 if (ice->playback_con_substream) 473 snd_pcm_period_elapsed(ice->playback_con_substream); 474 } 475 if (mtstat & VT1724_MULTI_RDMA1) { 476 if (ice->capture_con_substream) 477 snd_pcm_period_elapsed(ice->capture_con_substream); 478 } 479 /* ack anyway to avoid freeze */ 480 outb(mtstat, ICEMT1724(ice, IRQ)); 481 /* ought to really handle this properly */ 482 if (mtstat & VT1724_MULTI_FIFO_ERR) { 483 unsigned char fstat = inb(ICEMT1724(ice, DMA_FIFO_ERR)); 484 outb(fstat, ICEMT1724(ice, DMA_FIFO_ERR)); 485 outb(VT1724_MULTI_FIFO_ERR | inb(ICEMT1724(ice, DMA_INT_MASK)), ICEMT1724(ice, DMA_INT_MASK)); 486 /* If I don't do this, I get machine lockup due to continual interrupts */ 487 } 488 489 } 490 } 491 return IRQ_RETVAL(handled); 492 } 493 494 /* 495 * PCM code - professional part (multitrack) 496 */ 497 498 static unsigned int rates[] = { 499 8000, 9600, 11025, 12000, 16000, 22050, 24000, 500 32000, 44100, 48000, 64000, 88200, 96000, 501 176400, 192000, 502 }; 503 504 static struct snd_pcm_hw_constraint_list hw_constraints_rates_96 = { 505 .count = ARRAY_SIZE(rates) - 2, /* up to 96000 */ 506 .list = rates, 507 .mask = 0, 508 }; 509 510 static struct snd_pcm_hw_constraint_list hw_constraints_rates_48 = { 511 .count = ARRAY_SIZE(rates) - 5, /* up to 48000 */ 512 .list = rates, 513 .mask = 0, 514 }; 515 516 static struct snd_pcm_hw_constraint_list hw_constraints_rates_192 = { 517 .count = ARRAY_SIZE(rates), 518 .list = rates, 519 .mask = 0, 520 }; 521 522 struct vt1724_pcm_reg { 523 unsigned int addr; /* ADDR register offset */ 524 unsigned int size; /* SIZE register offset */ 525 unsigned int count; /* COUNT register offset */ 526 unsigned int start; /* start & pause bit */ 527 }; 528 529 static int snd_vt1724_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 530 { 531 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 532 unsigned char what; 533 unsigned char old; 534 struct snd_pcm_substream *s; 535 536 what = 0; 537 snd_pcm_group_for_each_entry(s, substream) { 538 if (snd_pcm_substream_chip(s) == ice) { 539 const struct vt1724_pcm_reg *reg; 540 reg = s->runtime->private_data; 541 what |= reg->start; 542 snd_pcm_trigger_done(s, substream); 543 } 544 } 545 546 switch (cmd) { 547 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 548 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 549 spin_lock(&ice->reg_lock); 550 old = inb(ICEMT1724(ice, DMA_PAUSE)); 551 if (cmd == SNDRV_PCM_TRIGGER_PAUSE_PUSH) 552 old |= what; 553 else 554 old &= ~what; 555 outb(old, ICEMT1724(ice, DMA_PAUSE)); 556 spin_unlock(&ice->reg_lock); 557 break; 558 559 case SNDRV_PCM_TRIGGER_START: 560 case SNDRV_PCM_TRIGGER_STOP: 561 spin_lock(&ice->reg_lock); 562 old = inb(ICEMT1724(ice, DMA_CONTROL)); 563 if (cmd == SNDRV_PCM_TRIGGER_START) 564 old |= what; 565 else 566 old &= ~what; 567 outb(old, ICEMT1724(ice, DMA_CONTROL)); 568 spin_unlock(&ice->reg_lock); 569 break; 570 571 default: 572 return -EINVAL; 573 } 574 return 0; 575 } 576 577 /* 578 */ 579 580 #define DMA_STARTS (VT1724_RDMA0_START|VT1724_PDMA0_START|VT1724_RDMA1_START|\ 581 VT1724_PDMA1_START|VT1724_PDMA2_START|VT1724_PDMA3_START|VT1724_PDMA4_START) 582 #define DMA_PAUSES (VT1724_RDMA0_PAUSE|VT1724_PDMA0_PAUSE|VT1724_RDMA1_PAUSE|\ 583 VT1724_PDMA1_PAUSE|VT1724_PDMA2_PAUSE|VT1724_PDMA3_PAUSE|VT1724_PDMA4_PAUSE) 584 585 static const unsigned int stdclock_rate_list[16] = { 586 48000, 24000, 12000, 9600, 32000, 16000, 8000, 96000, 44100, 587 22050, 11025, 88200, 176400, 0, 192000, 64000 588 }; 589 590 static unsigned int stdclock_get_rate(struct snd_ice1712 *ice) 591 { 592 unsigned int rate; 593 rate = stdclock_rate_list[inb(ICEMT1724(ice, RATE)) & 15]; 594 return rate; 595 } 596 597 static void stdclock_set_rate(struct snd_ice1712 *ice, unsigned int rate) 598 { 599 int i; 600 for (i = 0; i < ARRAY_SIZE(stdclock_rate_list); i++) { 601 if (stdclock_rate_list[i] == rate) { 602 outb(i, ICEMT1724(ice, RATE)); 603 return; 604 } 605 } 606 } 607 608 static unsigned char stdclock_set_mclk(struct snd_ice1712 *ice, 609 unsigned int rate) 610 { 611 unsigned char val, old; 612 /* check MT02 */ 613 if (ice->eeprom.data[ICE_EEP2_ACLINK] & VT1724_CFG_PRO_I2S) { 614 val = old = inb(ICEMT1724(ice, I2S_FORMAT)); 615 if (rate > 96000) 616 val |= VT1724_MT_I2S_MCLK_128X; /* 128x MCLK */ 617 else 618 val &= ~VT1724_MT_I2S_MCLK_128X; /* 256x MCLK */ 619 if (val != old) { 620 outb(val, ICEMT1724(ice, I2S_FORMAT)); 621 /* master clock changed */ 622 return 1; 623 } 624 } 625 /* no change in master clock */ 626 return 0; 627 } 628 629 static void snd_vt1724_set_pro_rate(struct snd_ice1712 *ice, unsigned int rate, 630 int force) 631 { 632 unsigned long flags; 633 unsigned char mclk_change; 634 unsigned int i, old_rate; 635 636 if (rate > ice->hw_rates->list[ice->hw_rates->count - 1]) 637 return; 638 spin_lock_irqsave(&ice->reg_lock, flags); 639 if ((inb(ICEMT1724(ice, DMA_CONTROL)) & DMA_STARTS) || 640 (inb(ICEMT1724(ice, DMA_PAUSE)) & DMA_PAUSES)) { 641 /* running? we cannot change the rate now... */ 642 spin_unlock_irqrestore(&ice->reg_lock, flags); 643 return; 644 } 645 if (!force && is_pro_rate_locked(ice)) { 646 spin_unlock_irqrestore(&ice->reg_lock, flags); 647 return; 648 } 649 650 old_rate = ice->get_rate(ice); 651 if (force || (old_rate != rate)) 652 ice->set_rate(ice, rate); 653 else if (rate == ice->cur_rate) { 654 spin_unlock_irqrestore(&ice->reg_lock, flags); 655 return; 656 } 657 658 ice->cur_rate = rate; 659 660 /* setting master clock */ 661 mclk_change = ice->set_mclk(ice, rate); 662 663 spin_unlock_irqrestore(&ice->reg_lock, flags); 664 665 if (mclk_change && ice->gpio.i2s_mclk_changed) 666 ice->gpio.i2s_mclk_changed(ice); 667 if (ice->gpio.set_pro_rate) 668 ice->gpio.set_pro_rate(ice, rate); 669 670 /* set up codecs */ 671 for (i = 0; i < ice->akm_codecs; i++) { 672 if (ice->akm[i].ops.set_rate_val) 673 ice->akm[i].ops.set_rate_val(&ice->akm[i], rate); 674 } 675 if (ice->spdif.ops.setup_rate) 676 ice->spdif.ops.setup_rate(ice, rate); 677 } 678 679 static int snd_vt1724_pcm_hw_params(struct snd_pcm_substream *substream, 680 struct snd_pcm_hw_params *hw_params) 681 { 682 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 683 int i, chs; 684 685 chs = params_channels(hw_params); 686 mutex_lock(&ice->open_mutex); 687 /* mark surround channels */ 688 if (substream == ice->playback_pro_substream) { 689 /* PDMA0 can be multi-channel up to 8 */ 690 chs = chs / 2 - 1; 691 for (i = 0; i < chs; i++) { 692 if (ice->pcm_reserved[i] && 693 ice->pcm_reserved[i] != substream) { 694 mutex_unlock(&ice->open_mutex); 695 return -EBUSY; 696 } 697 ice->pcm_reserved[i] = substream; 698 } 699 for (; i < 3; i++) { 700 if (ice->pcm_reserved[i] == substream) 701 ice->pcm_reserved[i] = NULL; 702 } 703 } else { 704 for (i = 0; i < 3; i++) { 705 /* check individual playback stream */ 706 if (ice->playback_con_substream_ds[i] == substream) { 707 if (ice->pcm_reserved[i] && 708 ice->pcm_reserved[i] != substream) { 709 mutex_unlock(&ice->open_mutex); 710 return -EBUSY; 711 } 712 ice->pcm_reserved[i] = substream; 713 break; 714 } 715 } 716 } 717 mutex_unlock(&ice->open_mutex); 718 snd_vt1724_set_pro_rate(ice, params_rate(hw_params), 0); 719 return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); 720 } 721 722 static int snd_vt1724_pcm_hw_free(struct snd_pcm_substream *substream) 723 { 724 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 725 int i; 726 727 mutex_lock(&ice->open_mutex); 728 /* unmark surround channels */ 729 for (i = 0; i < 3; i++) 730 if (ice->pcm_reserved[i] == substream) 731 ice->pcm_reserved[i] = NULL; 732 mutex_unlock(&ice->open_mutex); 733 return snd_pcm_lib_free_pages(substream); 734 } 735 736 static int snd_vt1724_playback_pro_prepare(struct snd_pcm_substream *substream) 737 { 738 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 739 unsigned char val; 740 unsigned int size; 741 742 spin_lock_irq(&ice->reg_lock); 743 val = (8 - substream->runtime->channels) >> 1; 744 outb(val, ICEMT1724(ice, BURST)); 745 746 outl(substream->runtime->dma_addr, ICEMT1724(ice, PLAYBACK_ADDR)); 747 748 size = (snd_pcm_lib_buffer_bytes(substream) >> 2) - 1; 749 /* outl(size, ICEMT1724(ice, PLAYBACK_SIZE)); */ 750 outw(size, ICEMT1724(ice, PLAYBACK_SIZE)); 751 outb(size >> 16, ICEMT1724(ice, PLAYBACK_SIZE) + 2); 752 size = (snd_pcm_lib_period_bytes(substream) >> 2) - 1; 753 /* outl(size, ICEMT1724(ice, PLAYBACK_COUNT)); */ 754 outw(size, ICEMT1724(ice, PLAYBACK_COUNT)); 755 outb(size >> 16, ICEMT1724(ice, PLAYBACK_COUNT) + 2); 756 757 spin_unlock_irq(&ice->reg_lock); 758 759 /* 760 printk(KERN_DEBUG "pro prepare: ch = %d, addr = 0x%x, " 761 "buffer = 0x%x, period = 0x%x\n", 762 substream->runtime->channels, 763 (unsigned int)substream->runtime->dma_addr, 764 snd_pcm_lib_buffer_bytes(substream), 765 snd_pcm_lib_period_bytes(substream)); 766 */ 767 return 0; 768 } 769 770 static snd_pcm_uframes_t snd_vt1724_playback_pro_pointer(struct snd_pcm_substream *substream) 771 { 772 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 773 size_t ptr; 774 775 if (!(inl(ICEMT1724(ice, DMA_CONTROL)) & VT1724_PDMA0_START)) 776 return 0; 777 #if 0 /* read PLAYBACK_ADDR */ 778 ptr = inl(ICEMT1724(ice, PLAYBACK_ADDR)); 779 if (ptr < substream->runtime->dma_addr) { 780 snd_printd("ice1724: invalid negative ptr\n"); 781 return 0; 782 } 783 ptr -= substream->runtime->dma_addr; 784 ptr = bytes_to_frames(substream->runtime, ptr); 785 if (ptr >= substream->runtime->buffer_size) { 786 snd_printd("ice1724: invalid ptr %d (size=%d)\n", 787 (int)ptr, (int)substream->runtime->period_size); 788 return 0; 789 } 790 #else /* read PLAYBACK_SIZE */ 791 ptr = inl(ICEMT1724(ice, PLAYBACK_SIZE)) & 0xffffff; 792 ptr = (ptr + 1) << 2; 793 ptr = bytes_to_frames(substream->runtime, ptr); 794 if (!ptr) 795 ; 796 else if (ptr <= substream->runtime->buffer_size) 797 ptr = substream->runtime->buffer_size - ptr; 798 else { 799 snd_printd("ice1724: invalid ptr %d (size=%d)\n", 800 (int)ptr, (int)substream->runtime->buffer_size); 801 ptr = 0; 802 } 803 #endif 804 return ptr; 805 } 806 807 static int snd_vt1724_pcm_prepare(struct snd_pcm_substream *substream) 808 { 809 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 810 const struct vt1724_pcm_reg *reg = substream->runtime->private_data; 811 812 spin_lock_irq(&ice->reg_lock); 813 outl(substream->runtime->dma_addr, ice->profi_port + reg->addr); 814 outw((snd_pcm_lib_buffer_bytes(substream) >> 2) - 1, 815 ice->profi_port + reg->size); 816 outw((snd_pcm_lib_period_bytes(substream) >> 2) - 1, 817 ice->profi_port + reg->count); 818 spin_unlock_irq(&ice->reg_lock); 819 return 0; 820 } 821 822 static snd_pcm_uframes_t snd_vt1724_pcm_pointer(struct snd_pcm_substream *substream) 823 { 824 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 825 const struct vt1724_pcm_reg *reg = substream->runtime->private_data; 826 size_t ptr; 827 828 if (!(inl(ICEMT1724(ice, DMA_CONTROL)) & reg->start)) 829 return 0; 830 #if 0 /* use ADDR register */ 831 ptr = inl(ice->profi_port + reg->addr); 832 ptr -= substream->runtime->dma_addr; 833 return bytes_to_frames(substream->runtime, ptr); 834 #else /* use SIZE register */ 835 ptr = inw(ice->profi_port + reg->size); 836 ptr = (ptr + 1) << 2; 837 ptr = bytes_to_frames(substream->runtime, ptr); 838 if (!ptr) 839 ; 840 else if (ptr <= substream->runtime->buffer_size) 841 ptr = substream->runtime->buffer_size - ptr; 842 else { 843 snd_printd("ice1724: invalid ptr %d (size=%d)\n", 844 (int)ptr, (int)substream->runtime->buffer_size); 845 ptr = 0; 846 } 847 return ptr; 848 #endif 849 } 850 851 static const struct vt1724_pcm_reg vt1724_playback_pro_reg = { 852 .addr = VT1724_MT_PLAYBACK_ADDR, 853 .size = VT1724_MT_PLAYBACK_SIZE, 854 .count = VT1724_MT_PLAYBACK_COUNT, 855 .start = VT1724_PDMA0_START, 856 }; 857 858 static const struct vt1724_pcm_reg vt1724_capture_pro_reg = { 859 .addr = VT1724_MT_CAPTURE_ADDR, 860 .size = VT1724_MT_CAPTURE_SIZE, 861 .count = VT1724_MT_CAPTURE_COUNT, 862 .start = VT1724_RDMA0_START, 863 }; 864 865 static const struct snd_pcm_hardware snd_vt1724_playback_pro = { 866 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 867 SNDRV_PCM_INFO_BLOCK_TRANSFER | 868 SNDRV_PCM_INFO_MMAP_VALID | 869 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_SYNC_START), 870 .formats = SNDRV_PCM_FMTBIT_S32_LE, 871 .rates = SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000_192000, 872 .rate_min = 8000, 873 .rate_max = 192000, 874 .channels_min = 2, 875 .channels_max = 8, 876 .buffer_bytes_max = (1UL << 21), /* 19bits dword */ 877 .period_bytes_min = 8 * 4 * 2, /* FIXME: constraints needed */ 878 .period_bytes_max = (1UL << 21), 879 .periods_min = 2, 880 .periods_max = 1024, 881 }; 882 883 static const struct snd_pcm_hardware snd_vt1724_spdif = { 884 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 885 SNDRV_PCM_INFO_BLOCK_TRANSFER | 886 SNDRV_PCM_INFO_MMAP_VALID | 887 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_SYNC_START), 888 .formats = SNDRV_PCM_FMTBIT_S32_LE, 889 .rates = (SNDRV_PCM_RATE_32000|SNDRV_PCM_RATE_44100| 890 SNDRV_PCM_RATE_48000|SNDRV_PCM_RATE_88200| 891 SNDRV_PCM_RATE_96000|SNDRV_PCM_RATE_176400| 892 SNDRV_PCM_RATE_192000), 893 .rate_min = 32000, 894 .rate_max = 192000, 895 .channels_min = 2, 896 .channels_max = 2, 897 .buffer_bytes_max = (1UL << 18), /* 16bits dword */ 898 .period_bytes_min = 2 * 4 * 2, 899 .period_bytes_max = (1UL << 18), 900 .periods_min = 2, 901 .periods_max = 1024, 902 }; 903 904 static const struct snd_pcm_hardware snd_vt1724_2ch_stereo = { 905 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 906 SNDRV_PCM_INFO_BLOCK_TRANSFER | 907 SNDRV_PCM_INFO_MMAP_VALID | 908 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_SYNC_START), 909 .formats = SNDRV_PCM_FMTBIT_S32_LE, 910 .rates = SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000_192000, 911 .rate_min = 8000, 912 .rate_max = 192000, 913 .channels_min = 2, 914 .channels_max = 2, 915 .buffer_bytes_max = (1UL << 18), /* 16bits dword */ 916 .period_bytes_min = 2 * 4 * 2, 917 .period_bytes_max = (1UL << 18), 918 .periods_min = 2, 919 .periods_max = 1024, 920 }; 921 922 /* 923 * set rate constraints 924 */ 925 static void set_std_hw_rates(struct snd_ice1712 *ice) 926 { 927 if (ice->eeprom.data[ICE_EEP2_ACLINK] & VT1724_CFG_PRO_I2S) { 928 /* I2S */ 929 /* VT1720 doesn't support more than 96kHz */ 930 if ((ice->eeprom.data[ICE_EEP2_I2S] & 0x08) && !ice->vt1720) 931 ice->hw_rates = &hw_constraints_rates_192; 932 else 933 ice->hw_rates = &hw_constraints_rates_96; 934 } else { 935 /* ACLINK */ 936 ice->hw_rates = &hw_constraints_rates_48; 937 } 938 } 939 940 static int set_rate_constraints(struct snd_ice1712 *ice, 941 struct snd_pcm_substream *substream) 942 { 943 struct snd_pcm_runtime *runtime = substream->runtime; 944 945 runtime->hw.rate_min = ice->hw_rates->list[0]; 946 runtime->hw.rate_max = ice->hw_rates->list[ice->hw_rates->count - 1]; 947 runtime->hw.rates = SNDRV_PCM_RATE_KNOT; 948 return snd_pcm_hw_constraint_list(runtime, 0, 949 SNDRV_PCM_HW_PARAM_RATE, 950 ice->hw_rates); 951 } 952 953 /* multi-channel playback needs alignment 8x32bit regardless of the channels 954 * actually used 955 */ 956 #define VT1724_BUFFER_ALIGN 0x20 957 958 static int snd_vt1724_playback_pro_open(struct snd_pcm_substream *substream) 959 { 960 struct snd_pcm_runtime *runtime = substream->runtime; 961 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 962 int chs, num_indeps; 963 964 runtime->private_data = (void *)&vt1724_playback_pro_reg; 965 ice->playback_pro_substream = substream; 966 runtime->hw = snd_vt1724_playback_pro; 967 snd_pcm_set_sync(substream); 968 snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); 969 set_rate_constraints(ice, substream); 970 mutex_lock(&ice->open_mutex); 971 /* calculate the currently available channels */ 972 num_indeps = ice->num_total_dacs / 2 - 1; 973 for (chs = 0; chs < num_indeps; chs++) { 974 if (ice->pcm_reserved[chs]) 975 break; 976 } 977 chs = (chs + 1) * 2; 978 runtime->hw.channels_max = chs; 979 if (chs > 2) /* channels must be even */ 980 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 2); 981 mutex_unlock(&ice->open_mutex); 982 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 983 VT1724_BUFFER_ALIGN); 984 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 985 VT1724_BUFFER_ALIGN); 986 return 0; 987 } 988 989 static int snd_vt1724_capture_pro_open(struct snd_pcm_substream *substream) 990 { 991 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 992 struct snd_pcm_runtime *runtime = substream->runtime; 993 994 runtime->private_data = (void *)&vt1724_capture_pro_reg; 995 ice->capture_pro_substream = substream; 996 runtime->hw = snd_vt1724_2ch_stereo; 997 snd_pcm_set_sync(substream); 998 snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); 999 set_rate_constraints(ice, substream); 1000 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 1001 VT1724_BUFFER_ALIGN); 1002 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 1003 VT1724_BUFFER_ALIGN); 1004 return 0; 1005 } 1006 1007 static int snd_vt1724_playback_pro_close(struct snd_pcm_substream *substream) 1008 { 1009 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 1010 1011 if (PRO_RATE_RESET) 1012 snd_vt1724_set_pro_rate(ice, ice->pro_rate_default, 0); 1013 ice->playback_pro_substream = NULL; 1014 1015 return 0; 1016 } 1017 1018 static int snd_vt1724_capture_pro_close(struct snd_pcm_substream *substream) 1019 { 1020 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 1021 1022 if (PRO_RATE_RESET) 1023 snd_vt1724_set_pro_rate(ice, ice->pro_rate_default, 0); 1024 ice->capture_pro_substream = NULL; 1025 return 0; 1026 } 1027 1028 static struct snd_pcm_ops snd_vt1724_playback_pro_ops = { 1029 .open = snd_vt1724_playback_pro_open, 1030 .close = snd_vt1724_playback_pro_close, 1031 .ioctl = snd_pcm_lib_ioctl, 1032 .hw_params = snd_vt1724_pcm_hw_params, 1033 .hw_free = snd_vt1724_pcm_hw_free, 1034 .prepare = snd_vt1724_playback_pro_prepare, 1035 .trigger = snd_vt1724_pcm_trigger, 1036 .pointer = snd_vt1724_playback_pro_pointer, 1037 }; 1038 1039 static struct snd_pcm_ops snd_vt1724_capture_pro_ops = { 1040 .open = snd_vt1724_capture_pro_open, 1041 .close = snd_vt1724_capture_pro_close, 1042 .ioctl = snd_pcm_lib_ioctl, 1043 .hw_params = snd_vt1724_pcm_hw_params, 1044 .hw_free = snd_vt1724_pcm_hw_free, 1045 .prepare = snd_vt1724_pcm_prepare, 1046 .trigger = snd_vt1724_pcm_trigger, 1047 .pointer = snd_vt1724_pcm_pointer, 1048 }; 1049 1050 static int __devinit snd_vt1724_pcm_profi(struct snd_ice1712 *ice, int device) 1051 { 1052 struct snd_pcm *pcm; 1053 int err; 1054 1055 err = snd_pcm_new(ice->card, "ICE1724", device, 1, 1, &pcm); 1056 if (err < 0) 1057 return err; 1058 1059 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_vt1724_playback_pro_ops); 1060 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_vt1724_capture_pro_ops); 1061 1062 pcm->private_data = ice; 1063 pcm->info_flags = 0; 1064 strcpy(pcm->name, "ICE1724"); 1065 1066 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, 1067 snd_dma_pci_data(ice->pci), 1068 256*1024, 256*1024); 1069 1070 ice->pcm_pro = pcm; 1071 1072 return 0; 1073 } 1074 1075 1076 /* 1077 * SPDIF PCM 1078 */ 1079 1080 static const struct vt1724_pcm_reg vt1724_playback_spdif_reg = { 1081 .addr = VT1724_MT_PDMA4_ADDR, 1082 .size = VT1724_MT_PDMA4_SIZE, 1083 .count = VT1724_MT_PDMA4_COUNT, 1084 .start = VT1724_PDMA4_START, 1085 }; 1086 1087 static const struct vt1724_pcm_reg vt1724_capture_spdif_reg = { 1088 .addr = VT1724_MT_RDMA1_ADDR, 1089 .size = VT1724_MT_RDMA1_SIZE, 1090 .count = VT1724_MT_RDMA1_COUNT, 1091 .start = VT1724_RDMA1_START, 1092 }; 1093 1094 /* update spdif control bits; call with reg_lock */ 1095 static void update_spdif_bits(struct snd_ice1712 *ice, unsigned int val) 1096 { 1097 unsigned char cbit, disabled; 1098 1099 cbit = inb(ICEREG1724(ice, SPDIF_CFG)); 1100 disabled = cbit & ~VT1724_CFG_SPDIF_OUT_EN; 1101 if (cbit != disabled) 1102 outb(disabled, ICEREG1724(ice, SPDIF_CFG)); 1103 outw(val, ICEMT1724(ice, SPDIF_CTRL)); 1104 if (cbit != disabled) 1105 outb(cbit, ICEREG1724(ice, SPDIF_CFG)); 1106 outw(val, ICEMT1724(ice, SPDIF_CTRL)); 1107 } 1108 1109 /* update SPDIF control bits according to the given rate */ 1110 static void update_spdif_rate(struct snd_ice1712 *ice, unsigned int rate) 1111 { 1112 unsigned int val, nval; 1113 unsigned long flags; 1114 1115 spin_lock_irqsave(&ice->reg_lock, flags); 1116 nval = val = inw(ICEMT1724(ice, SPDIF_CTRL)); 1117 nval &= ~(7 << 12); 1118 switch (rate) { 1119 case 44100: break; 1120 case 48000: nval |= 2 << 12; break; 1121 case 32000: nval |= 3 << 12; break; 1122 case 88200: nval |= 4 << 12; break; 1123 case 96000: nval |= 5 << 12; break; 1124 case 192000: nval |= 6 << 12; break; 1125 case 176400: nval |= 7 << 12; break; 1126 } 1127 if (val != nval) 1128 update_spdif_bits(ice, nval); 1129 spin_unlock_irqrestore(&ice->reg_lock, flags); 1130 } 1131 1132 static int snd_vt1724_playback_spdif_prepare(struct snd_pcm_substream *substream) 1133 { 1134 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 1135 if (!ice->force_pdma4) 1136 update_spdif_rate(ice, substream->runtime->rate); 1137 return snd_vt1724_pcm_prepare(substream); 1138 } 1139 1140 static int snd_vt1724_playback_spdif_open(struct snd_pcm_substream *substream) 1141 { 1142 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 1143 struct snd_pcm_runtime *runtime = substream->runtime; 1144 1145 runtime->private_data = (void *)&vt1724_playback_spdif_reg; 1146 ice->playback_con_substream = substream; 1147 if (ice->force_pdma4) { 1148 runtime->hw = snd_vt1724_2ch_stereo; 1149 set_rate_constraints(ice, substream); 1150 } else 1151 runtime->hw = snd_vt1724_spdif; 1152 snd_pcm_set_sync(substream); 1153 snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); 1154 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 1155 VT1724_BUFFER_ALIGN); 1156 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 1157 VT1724_BUFFER_ALIGN); 1158 if (ice->spdif.ops.open) 1159 ice->spdif.ops.open(ice, substream); 1160 return 0; 1161 } 1162 1163 static int snd_vt1724_playback_spdif_close(struct snd_pcm_substream *substream) 1164 { 1165 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 1166 1167 if (PRO_RATE_RESET) 1168 snd_vt1724_set_pro_rate(ice, ice->pro_rate_default, 0); 1169 ice->playback_con_substream = NULL; 1170 if (ice->spdif.ops.close) 1171 ice->spdif.ops.close(ice, substream); 1172 1173 return 0; 1174 } 1175 1176 static int snd_vt1724_capture_spdif_open(struct snd_pcm_substream *substream) 1177 { 1178 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 1179 struct snd_pcm_runtime *runtime = substream->runtime; 1180 1181 runtime->private_data = (void *)&vt1724_capture_spdif_reg; 1182 ice->capture_con_substream = substream; 1183 if (ice->force_rdma1) { 1184 runtime->hw = snd_vt1724_2ch_stereo; 1185 set_rate_constraints(ice, substream); 1186 } else 1187 runtime->hw = snd_vt1724_spdif; 1188 snd_pcm_set_sync(substream); 1189 snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); 1190 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 1191 VT1724_BUFFER_ALIGN); 1192 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 1193 VT1724_BUFFER_ALIGN); 1194 if (ice->spdif.ops.open) 1195 ice->spdif.ops.open(ice, substream); 1196 return 0; 1197 } 1198 1199 static int snd_vt1724_capture_spdif_close(struct snd_pcm_substream *substream) 1200 { 1201 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 1202 1203 if (PRO_RATE_RESET) 1204 snd_vt1724_set_pro_rate(ice, ice->pro_rate_default, 0); 1205 ice->capture_con_substream = NULL; 1206 if (ice->spdif.ops.close) 1207 ice->spdif.ops.close(ice, substream); 1208 1209 return 0; 1210 } 1211 1212 static struct snd_pcm_ops snd_vt1724_playback_spdif_ops = { 1213 .open = snd_vt1724_playback_spdif_open, 1214 .close = snd_vt1724_playback_spdif_close, 1215 .ioctl = snd_pcm_lib_ioctl, 1216 .hw_params = snd_vt1724_pcm_hw_params, 1217 .hw_free = snd_vt1724_pcm_hw_free, 1218 .prepare = snd_vt1724_playback_spdif_prepare, 1219 .trigger = snd_vt1724_pcm_trigger, 1220 .pointer = snd_vt1724_pcm_pointer, 1221 }; 1222 1223 static struct snd_pcm_ops snd_vt1724_capture_spdif_ops = { 1224 .open = snd_vt1724_capture_spdif_open, 1225 .close = snd_vt1724_capture_spdif_close, 1226 .ioctl = snd_pcm_lib_ioctl, 1227 .hw_params = snd_vt1724_pcm_hw_params, 1228 .hw_free = snd_vt1724_pcm_hw_free, 1229 .prepare = snd_vt1724_pcm_prepare, 1230 .trigger = snd_vt1724_pcm_trigger, 1231 .pointer = snd_vt1724_pcm_pointer, 1232 }; 1233 1234 1235 static int __devinit snd_vt1724_pcm_spdif(struct snd_ice1712 *ice, int device) 1236 { 1237 char *name; 1238 struct snd_pcm *pcm; 1239 int play, capt; 1240 int err; 1241 1242 if (ice->force_pdma4 || 1243 (ice->eeprom.data[ICE_EEP2_SPDIF] & VT1724_CFG_SPDIF_OUT_INT)) { 1244 play = 1; 1245 ice->has_spdif = 1; 1246 } else 1247 play = 0; 1248 if (ice->force_rdma1 || 1249 (ice->eeprom.data[ICE_EEP2_SPDIF] & VT1724_CFG_SPDIF_IN)) { 1250 capt = 1; 1251 ice->has_spdif = 1; 1252 } else 1253 capt = 0; 1254 if (!play && !capt) 1255 return 0; /* no spdif device */ 1256 1257 if (ice->force_pdma4 || ice->force_rdma1) 1258 name = "ICE1724 Secondary"; 1259 else 1260 name = "ICE1724 IEC958"; 1261 err = snd_pcm_new(ice->card, name, device, play, capt, &pcm); 1262 if (err < 0) 1263 return err; 1264 1265 if (play) 1266 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 1267 &snd_vt1724_playback_spdif_ops); 1268 if (capt) 1269 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 1270 &snd_vt1724_capture_spdif_ops); 1271 1272 pcm->private_data = ice; 1273 pcm->info_flags = 0; 1274 strcpy(pcm->name, name); 1275 1276 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, 1277 snd_dma_pci_data(ice->pci), 1278 64*1024, 64*1024); 1279 1280 ice->pcm = pcm; 1281 1282 return 0; 1283 } 1284 1285 1286 /* 1287 * independent surround PCMs 1288 */ 1289 1290 static const struct vt1724_pcm_reg vt1724_playback_dma_regs[3] = { 1291 { 1292 .addr = VT1724_MT_PDMA1_ADDR, 1293 .size = VT1724_MT_PDMA1_SIZE, 1294 .count = VT1724_MT_PDMA1_COUNT, 1295 .start = VT1724_PDMA1_START, 1296 }, 1297 { 1298 .addr = VT1724_MT_PDMA2_ADDR, 1299 .size = VT1724_MT_PDMA2_SIZE, 1300 .count = VT1724_MT_PDMA2_COUNT, 1301 .start = VT1724_PDMA2_START, 1302 }, 1303 { 1304 .addr = VT1724_MT_PDMA3_ADDR, 1305 .size = VT1724_MT_PDMA3_SIZE, 1306 .count = VT1724_MT_PDMA3_COUNT, 1307 .start = VT1724_PDMA3_START, 1308 }, 1309 }; 1310 1311 static int snd_vt1724_playback_indep_prepare(struct snd_pcm_substream *substream) 1312 { 1313 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 1314 unsigned char val; 1315 1316 spin_lock_irq(&ice->reg_lock); 1317 val = 3 - substream->number; 1318 if (inb(ICEMT1724(ice, BURST)) < val) 1319 outb(val, ICEMT1724(ice, BURST)); 1320 spin_unlock_irq(&ice->reg_lock); 1321 return snd_vt1724_pcm_prepare(substream); 1322 } 1323 1324 static int snd_vt1724_playback_indep_open(struct snd_pcm_substream *substream) 1325 { 1326 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 1327 struct snd_pcm_runtime *runtime = substream->runtime; 1328 1329 mutex_lock(&ice->open_mutex); 1330 /* already used by PDMA0? */ 1331 if (ice->pcm_reserved[substream->number]) { 1332 mutex_unlock(&ice->open_mutex); 1333 return -EBUSY; /* FIXME: should handle blocking mode properly */ 1334 } 1335 mutex_unlock(&ice->open_mutex); 1336 runtime->private_data = (void *)&vt1724_playback_dma_regs[substream->number]; 1337 ice->playback_con_substream_ds[substream->number] = substream; 1338 runtime->hw = snd_vt1724_2ch_stereo; 1339 snd_pcm_set_sync(substream); 1340 snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); 1341 set_rate_constraints(ice, substream); 1342 return 0; 1343 } 1344 1345 static int snd_vt1724_playback_indep_close(struct snd_pcm_substream *substream) 1346 { 1347 struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); 1348 1349 if (PRO_RATE_RESET) 1350 snd_vt1724_set_pro_rate(ice, ice->pro_rate_default, 0); 1351 ice->playback_con_substream_ds[substream->number] = NULL; 1352 ice->pcm_reserved[substream->number] = NULL; 1353 1354 return 0; 1355 } 1356 1357 static struct snd_pcm_ops snd_vt1724_playback_indep_ops = { 1358 .open = snd_vt1724_playback_indep_open, 1359 .close = snd_vt1724_playback_indep_close, 1360 .ioctl = snd_pcm_lib_ioctl, 1361 .hw_params = snd_vt1724_pcm_hw_params, 1362 .hw_free = snd_vt1724_pcm_hw_free, 1363 .prepare = snd_vt1724_playback_indep_prepare, 1364 .trigger = snd_vt1724_pcm_trigger, 1365 .pointer = snd_vt1724_pcm_pointer, 1366 }; 1367 1368 1369 static int __devinit snd_vt1724_pcm_indep(struct snd_ice1712 *ice, int device) 1370 { 1371 struct snd_pcm *pcm; 1372 int play; 1373 int err; 1374 1375 play = ice->num_total_dacs / 2 - 1; 1376 if (play <= 0) 1377 return 0; 1378 1379 err = snd_pcm_new(ice->card, "ICE1724 Surrounds", device, play, 0, &pcm); 1380 if (err < 0) 1381 return err; 1382 1383 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 1384 &snd_vt1724_playback_indep_ops); 1385 1386 pcm->private_data = ice; 1387 pcm->info_flags = 0; 1388 strcpy(pcm->name, "ICE1724 Surround PCM"); 1389 1390 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, 1391 snd_dma_pci_data(ice->pci), 1392 64*1024, 64*1024); 1393 1394 ice->pcm_ds = pcm; 1395 1396 return 0; 1397 } 1398 1399 1400 /* 1401 * Mixer section 1402 */ 1403 1404 static int __devinit snd_vt1724_ac97_mixer(struct snd_ice1712 *ice) 1405 { 1406 int err; 1407 1408 if (!(ice->eeprom.data[ICE_EEP2_ACLINK] & VT1724_CFG_PRO_I2S)) { 1409 struct snd_ac97_bus *pbus; 1410 struct snd_ac97_template ac97; 1411 static struct snd_ac97_bus_ops ops = { 1412 .write = snd_vt1724_ac97_write, 1413 .read = snd_vt1724_ac97_read, 1414 }; 1415 1416 /* cold reset */ 1417 outb(inb(ICEMT1724(ice, AC97_CMD)) | 0x80, ICEMT1724(ice, AC97_CMD)); 1418 mdelay(5); /* FIXME */ 1419 outb(inb(ICEMT1724(ice, AC97_CMD)) & ~0x80, ICEMT1724(ice, AC97_CMD)); 1420 1421 err = snd_ac97_bus(ice->card, 0, &ops, NULL, &pbus); 1422 if (err < 0) 1423 return err; 1424 memset(&ac97, 0, sizeof(ac97)); 1425 ac97.private_data = ice; 1426 err = snd_ac97_mixer(pbus, &ac97, &ice->ac97); 1427 if (err < 0) 1428 printk(KERN_WARNING "ice1712: cannot initialize pro ac97, skipped\n"); 1429 else 1430 return 0; 1431 } 1432 /* I2S mixer only */ 1433 strcat(ice->card->mixername, "ICE1724 - multitrack"); 1434 return 0; 1435 } 1436 1437 /* 1438 * 1439 */ 1440 1441 static inline unsigned int eeprom_triple(struct snd_ice1712 *ice, int idx) 1442 { 1443 return (unsigned int)ice->eeprom.data[idx] | \ 1444 ((unsigned int)ice->eeprom.data[idx + 1] << 8) | \ 1445 ((unsigned int)ice->eeprom.data[idx + 2] << 16); 1446 } 1447 1448 static void snd_vt1724_proc_read(struct snd_info_entry *entry, 1449 struct snd_info_buffer *buffer) 1450 { 1451 struct snd_ice1712 *ice = entry->private_data; 1452 unsigned int idx; 1453 1454 snd_iprintf(buffer, "%s\n\n", ice->card->longname); 1455 snd_iprintf(buffer, "EEPROM:\n"); 1456 1457 snd_iprintf(buffer, " Subvendor : 0x%x\n", ice->eeprom.subvendor); 1458 snd_iprintf(buffer, " Size : %i bytes\n", ice->eeprom.size); 1459 snd_iprintf(buffer, " Version : %i\n", ice->eeprom.version); 1460 snd_iprintf(buffer, " System Config : 0x%x\n", 1461 ice->eeprom.data[ICE_EEP2_SYSCONF]); 1462 snd_iprintf(buffer, " ACLink : 0x%x\n", 1463 ice->eeprom.data[ICE_EEP2_ACLINK]); 1464 snd_iprintf(buffer, " I2S : 0x%x\n", 1465 ice->eeprom.data[ICE_EEP2_I2S]); 1466 snd_iprintf(buffer, " S/PDIF : 0x%x\n", 1467 ice->eeprom.data[ICE_EEP2_SPDIF]); 1468 snd_iprintf(buffer, " GPIO direction : 0x%x\n", 1469 ice->eeprom.gpiodir); 1470 snd_iprintf(buffer, " GPIO mask : 0x%x\n", 1471 ice->eeprom.gpiomask); 1472 snd_iprintf(buffer, " GPIO state : 0x%x\n", 1473 ice->eeprom.gpiostate); 1474 for (idx = 0x12; idx < ice->eeprom.size; idx++) 1475 snd_iprintf(buffer, " Extra #%02i : 0x%x\n", 1476 idx, ice->eeprom.data[idx]); 1477 1478 snd_iprintf(buffer, "\nRegisters:\n"); 1479 1480 snd_iprintf(buffer, " PSDOUT03 : 0x%08x\n", 1481 (unsigned)inl(ICEMT1724(ice, ROUTE_PLAYBACK))); 1482 for (idx = 0x0; idx < 0x20 ; idx++) 1483 snd_iprintf(buffer, " CCS%02x : 0x%02x\n", 1484 idx, inb(ice->port+idx)); 1485 for (idx = 0x0; idx < 0x30 ; idx++) 1486 snd_iprintf(buffer, " MT%02x : 0x%02x\n", 1487 idx, inb(ice->profi_port+idx)); 1488 } 1489 1490 static void __devinit snd_vt1724_proc_init(struct snd_ice1712 *ice) 1491 { 1492 struct snd_info_entry *entry; 1493 1494 if (!snd_card_proc_new(ice->card, "ice1724", &entry)) 1495 snd_info_set_text_ops(entry, ice, snd_vt1724_proc_read); 1496 } 1497 1498 /* 1499 * 1500 */ 1501 1502 static int snd_vt1724_eeprom_info(struct snd_kcontrol *kcontrol, 1503 struct snd_ctl_elem_info *uinfo) 1504 { 1505 uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES; 1506 uinfo->count = sizeof(struct snd_ice1712_eeprom); 1507 return 0; 1508 } 1509 1510 static int snd_vt1724_eeprom_get(struct snd_kcontrol *kcontrol, 1511 struct snd_ctl_elem_value *ucontrol) 1512 { 1513 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1514 1515 memcpy(ucontrol->value.bytes.data, &ice->eeprom, sizeof(ice->eeprom)); 1516 return 0; 1517 } 1518 1519 static struct snd_kcontrol_new snd_vt1724_eeprom __devinitdata = { 1520 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 1521 .name = "ICE1724 EEPROM", 1522 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1523 .info = snd_vt1724_eeprom_info, 1524 .get = snd_vt1724_eeprom_get 1525 }; 1526 1527 /* 1528 */ 1529 static int snd_vt1724_spdif_info(struct snd_kcontrol *kcontrol, 1530 struct snd_ctl_elem_info *uinfo) 1531 { 1532 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 1533 uinfo->count = 1; 1534 return 0; 1535 } 1536 1537 static unsigned int encode_spdif_bits(struct snd_aes_iec958 *diga) 1538 { 1539 unsigned int val, rbits; 1540 1541 val = diga->status[0] & 0x03; /* professional, non-audio */ 1542 if (val & 0x01) { 1543 /* professional */ 1544 if ((diga->status[0] & IEC958_AES0_PRO_EMPHASIS) == 1545 IEC958_AES0_PRO_EMPHASIS_5015) 1546 val |= 1U << 3; 1547 rbits = (diga->status[4] >> 3) & 0x0f; 1548 if (rbits) { 1549 switch (rbits) { 1550 case 2: val |= 5 << 12; break; /* 96k */ 1551 case 3: val |= 6 << 12; break; /* 192k */ 1552 case 10: val |= 4 << 12; break; /* 88.2k */ 1553 case 11: val |= 7 << 12; break; /* 176.4k */ 1554 } 1555 } else { 1556 switch (diga->status[0] & IEC958_AES0_PRO_FS) { 1557 case IEC958_AES0_PRO_FS_44100: 1558 break; 1559 case IEC958_AES0_PRO_FS_32000: 1560 val |= 3U << 12; 1561 break; 1562 default: 1563 val |= 2U << 12; 1564 break; 1565 } 1566 } 1567 } else { 1568 /* consumer */ 1569 val |= diga->status[1] & 0x04; /* copyright */ 1570 if ((diga->status[0] & IEC958_AES0_CON_EMPHASIS) == 1571 IEC958_AES0_CON_EMPHASIS_5015) 1572 val |= 1U << 3; 1573 val |= (unsigned int)(diga->status[1] & 0x3f) << 4; /* category */ 1574 val |= (unsigned int)(diga->status[3] & IEC958_AES3_CON_FS) << 12; /* fs */ 1575 } 1576 return val; 1577 } 1578 1579 static void decode_spdif_bits(struct snd_aes_iec958 *diga, unsigned int val) 1580 { 1581 memset(diga->status, 0, sizeof(diga->status)); 1582 diga->status[0] = val & 0x03; /* professional, non-audio */ 1583 if (val & 0x01) { 1584 /* professional */ 1585 if (val & (1U << 3)) 1586 diga->status[0] |= IEC958_AES0_PRO_EMPHASIS_5015; 1587 switch ((val >> 12) & 0x7) { 1588 case 0: 1589 break; 1590 case 2: 1591 diga->status[0] |= IEC958_AES0_PRO_FS_32000; 1592 break; 1593 default: 1594 diga->status[0] |= IEC958_AES0_PRO_FS_48000; 1595 break; 1596 } 1597 } else { 1598 /* consumer */ 1599 diga->status[0] |= val & (1U << 2); /* copyright */ 1600 if (val & (1U << 3)) 1601 diga->status[0] |= IEC958_AES0_CON_EMPHASIS_5015; 1602 diga->status[1] |= (val >> 4) & 0x3f; /* category */ 1603 diga->status[3] |= (val >> 12) & 0x07; /* fs */ 1604 } 1605 } 1606 1607 static int snd_vt1724_spdif_default_get(struct snd_kcontrol *kcontrol, 1608 struct snd_ctl_elem_value *ucontrol) 1609 { 1610 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1611 unsigned int val; 1612 val = inw(ICEMT1724(ice, SPDIF_CTRL)); 1613 decode_spdif_bits(&ucontrol->value.iec958, val); 1614 return 0; 1615 } 1616 1617 static int snd_vt1724_spdif_default_put(struct snd_kcontrol *kcontrol, 1618 struct snd_ctl_elem_value *ucontrol) 1619 { 1620 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1621 unsigned int val, old; 1622 1623 val = encode_spdif_bits(&ucontrol->value.iec958); 1624 spin_lock_irq(&ice->reg_lock); 1625 old = inw(ICEMT1724(ice, SPDIF_CTRL)); 1626 if (val != old) 1627 update_spdif_bits(ice, val); 1628 spin_unlock_irq(&ice->reg_lock); 1629 return val != old; 1630 } 1631 1632 static struct snd_kcontrol_new snd_vt1724_spdif_default __devinitdata = 1633 { 1634 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1635 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT), 1636 .info = snd_vt1724_spdif_info, 1637 .get = snd_vt1724_spdif_default_get, 1638 .put = snd_vt1724_spdif_default_put 1639 }; 1640 1641 static int snd_vt1724_spdif_maskc_get(struct snd_kcontrol *kcontrol, 1642 struct snd_ctl_elem_value *ucontrol) 1643 { 1644 ucontrol->value.iec958.status[0] = IEC958_AES0_NONAUDIO | 1645 IEC958_AES0_PROFESSIONAL | 1646 IEC958_AES0_CON_NOT_COPYRIGHT | 1647 IEC958_AES0_CON_EMPHASIS; 1648 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_ORIGINAL | 1649 IEC958_AES1_CON_CATEGORY; 1650 ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS; 1651 return 0; 1652 } 1653 1654 static int snd_vt1724_spdif_maskp_get(struct snd_kcontrol *kcontrol, 1655 struct snd_ctl_elem_value *ucontrol) 1656 { 1657 ucontrol->value.iec958.status[0] = IEC958_AES0_NONAUDIO | 1658 IEC958_AES0_PROFESSIONAL | 1659 IEC958_AES0_PRO_FS | 1660 IEC958_AES0_PRO_EMPHASIS; 1661 return 0; 1662 } 1663 1664 static struct snd_kcontrol_new snd_vt1724_spdif_maskc __devinitdata = 1665 { 1666 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1667 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1668 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK), 1669 .info = snd_vt1724_spdif_info, 1670 .get = snd_vt1724_spdif_maskc_get, 1671 }; 1672 1673 static struct snd_kcontrol_new snd_vt1724_spdif_maskp __devinitdata = 1674 { 1675 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1676 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1677 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK), 1678 .info = snd_vt1724_spdif_info, 1679 .get = snd_vt1724_spdif_maskp_get, 1680 }; 1681 1682 #define snd_vt1724_spdif_sw_info snd_ctl_boolean_mono_info 1683 1684 static int snd_vt1724_spdif_sw_get(struct snd_kcontrol *kcontrol, 1685 struct snd_ctl_elem_value *ucontrol) 1686 { 1687 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1688 ucontrol->value.integer.value[0] = inb(ICEREG1724(ice, SPDIF_CFG)) & 1689 VT1724_CFG_SPDIF_OUT_EN ? 1 : 0; 1690 return 0; 1691 } 1692 1693 static int snd_vt1724_spdif_sw_put(struct snd_kcontrol *kcontrol, 1694 struct snd_ctl_elem_value *ucontrol) 1695 { 1696 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1697 unsigned char old, val; 1698 1699 spin_lock_irq(&ice->reg_lock); 1700 old = val = inb(ICEREG1724(ice, SPDIF_CFG)); 1701 val &= ~VT1724_CFG_SPDIF_OUT_EN; 1702 if (ucontrol->value.integer.value[0]) 1703 val |= VT1724_CFG_SPDIF_OUT_EN; 1704 if (old != val) 1705 outb(val, ICEREG1724(ice, SPDIF_CFG)); 1706 spin_unlock_irq(&ice->reg_lock); 1707 return old != val; 1708 } 1709 1710 static struct snd_kcontrol_new snd_vt1724_spdif_switch __devinitdata = 1711 { 1712 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1713 /* FIXME: the following conflict with IEC958 Playback Route */ 1714 /* .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH), */ 1715 .name = SNDRV_CTL_NAME_IEC958("Output ", NONE, SWITCH), 1716 .info = snd_vt1724_spdif_sw_info, 1717 .get = snd_vt1724_spdif_sw_get, 1718 .put = snd_vt1724_spdif_sw_put 1719 }; 1720 1721 1722 #if 0 /* NOT USED YET */ 1723 /* 1724 * GPIO access from extern 1725 */ 1726 1727 #define snd_vt1724_gpio_info snd_ctl_boolean_mono_info 1728 1729 int snd_vt1724_gpio_get(struct snd_kcontrol *kcontrol, 1730 struct snd_ctl_elem_value *ucontrol) 1731 { 1732 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1733 int shift = kcontrol->private_value & 0xff; 1734 int invert = (kcontrol->private_value & (1<<24)) ? 1 : 0; 1735 1736 snd_ice1712_save_gpio_status(ice); 1737 ucontrol->value.integer.value[0] = 1738 (snd_ice1712_gpio_read(ice) & (1 << shift) ? 1 : 0) ^ invert; 1739 snd_ice1712_restore_gpio_status(ice); 1740 return 0; 1741 } 1742 1743 int snd_ice1712_gpio_put(struct snd_kcontrol *kcontrol, 1744 struct snd_ctl_elem_value *ucontrol) 1745 { 1746 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1747 int shift = kcontrol->private_value & 0xff; 1748 int invert = (kcontrol->private_value & (1<<24)) ? mask : 0; 1749 unsigned int val, nval; 1750 1751 if (kcontrol->private_value & (1 << 31)) 1752 return -EPERM; 1753 nval = (ucontrol->value.integer.value[0] ? (1 << shift) : 0) ^ invert; 1754 snd_ice1712_save_gpio_status(ice); 1755 val = snd_ice1712_gpio_read(ice); 1756 nval |= val & ~(1 << shift); 1757 if (val != nval) 1758 snd_ice1712_gpio_write(ice, nval); 1759 snd_ice1712_restore_gpio_status(ice); 1760 return val != nval; 1761 } 1762 #endif /* NOT USED YET */ 1763 1764 /* 1765 * rate 1766 */ 1767 static int snd_vt1724_pro_internal_clock_info(struct snd_kcontrol *kcontrol, 1768 struct snd_ctl_elem_info *uinfo) 1769 { 1770 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1771 1772 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1773 uinfo->count = 1; 1774 uinfo->value.enumerated.items = ice->hw_rates->count + 1; 1775 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) 1776 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; 1777 if (uinfo->value.enumerated.item == uinfo->value.enumerated.items - 1) 1778 strcpy(uinfo->value.enumerated.name, "IEC958 Input"); 1779 else 1780 sprintf(uinfo->value.enumerated.name, "%d", 1781 ice->hw_rates->list[uinfo->value.enumerated.item]); 1782 return 0; 1783 } 1784 1785 static int snd_vt1724_pro_internal_clock_get(struct snd_kcontrol *kcontrol, 1786 struct snd_ctl_elem_value *ucontrol) 1787 { 1788 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1789 unsigned int i, rate; 1790 1791 spin_lock_irq(&ice->reg_lock); 1792 if (ice->is_spdif_master(ice)) { 1793 ucontrol->value.enumerated.item[0] = ice->hw_rates->count; 1794 } else { 1795 rate = ice->get_rate(ice); 1796 ucontrol->value.enumerated.item[0] = 0; 1797 for (i = 0; i < ice->hw_rates->count; i++) { 1798 if (ice->hw_rates->list[i] == rate) { 1799 ucontrol->value.enumerated.item[0] = i; 1800 break; 1801 } 1802 } 1803 } 1804 spin_unlock_irq(&ice->reg_lock); 1805 return 0; 1806 } 1807 1808 /* setting clock to external - SPDIF */ 1809 static void stdclock_set_spdif_clock(struct snd_ice1712 *ice) 1810 { 1811 unsigned char oval; 1812 unsigned char i2s_oval; 1813 oval = inb(ICEMT1724(ice, RATE)); 1814 outb(oval | VT1724_SPDIF_MASTER, ICEMT1724(ice, RATE)); 1815 /* setting 256fs */ 1816 i2s_oval = inb(ICEMT1724(ice, I2S_FORMAT)); 1817 outb(i2s_oval & ~VT1724_MT_I2S_MCLK_128X, ICEMT1724(ice, I2S_FORMAT)); 1818 } 1819 1820 static int snd_vt1724_pro_internal_clock_put(struct snd_kcontrol *kcontrol, 1821 struct snd_ctl_elem_value *ucontrol) 1822 { 1823 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1824 unsigned int old_rate, new_rate; 1825 unsigned int item = ucontrol->value.enumerated.item[0]; 1826 unsigned int spdif = ice->hw_rates->count; 1827 1828 if (item > spdif) 1829 return -EINVAL; 1830 1831 spin_lock_irq(&ice->reg_lock); 1832 if (ice->is_spdif_master(ice)) 1833 old_rate = 0; 1834 else 1835 old_rate = ice->get_rate(ice); 1836 if (item == spdif) { 1837 /* switching to external clock via SPDIF */ 1838 ice->set_spdif_clock(ice); 1839 new_rate = 0; 1840 } else { 1841 /* internal on-card clock */ 1842 new_rate = ice->hw_rates->list[item]; 1843 ice->pro_rate_default = new_rate; 1844 spin_unlock_irq(&ice->reg_lock); 1845 snd_vt1724_set_pro_rate(ice, ice->pro_rate_default, 1); 1846 spin_lock_irq(&ice->reg_lock); 1847 } 1848 spin_unlock_irq(&ice->reg_lock); 1849 1850 /* the first reset to the SPDIF master mode? */ 1851 if (old_rate != new_rate && !new_rate) { 1852 /* notify akm chips as well */ 1853 unsigned int i; 1854 if (ice->gpio.set_pro_rate) 1855 ice->gpio.set_pro_rate(ice, 0); 1856 for (i = 0; i < ice->akm_codecs; i++) { 1857 if (ice->akm[i].ops.set_rate_val) 1858 ice->akm[i].ops.set_rate_val(&ice->akm[i], 0); 1859 } 1860 } 1861 return old_rate != new_rate; 1862 } 1863 1864 static struct snd_kcontrol_new snd_vt1724_pro_internal_clock __devinitdata = { 1865 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1866 .name = "Multi Track Internal Clock", 1867 .info = snd_vt1724_pro_internal_clock_info, 1868 .get = snd_vt1724_pro_internal_clock_get, 1869 .put = snd_vt1724_pro_internal_clock_put 1870 }; 1871 1872 #define snd_vt1724_pro_rate_locking_info snd_ctl_boolean_mono_info 1873 1874 static int snd_vt1724_pro_rate_locking_get(struct snd_kcontrol *kcontrol, 1875 struct snd_ctl_elem_value *ucontrol) 1876 { 1877 ucontrol->value.integer.value[0] = PRO_RATE_LOCKED; 1878 return 0; 1879 } 1880 1881 static int snd_vt1724_pro_rate_locking_put(struct snd_kcontrol *kcontrol, 1882 struct snd_ctl_elem_value *ucontrol) 1883 { 1884 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1885 int change = 0, nval; 1886 1887 nval = ucontrol->value.integer.value[0] ? 1 : 0; 1888 spin_lock_irq(&ice->reg_lock); 1889 change = PRO_RATE_LOCKED != nval; 1890 PRO_RATE_LOCKED = nval; 1891 spin_unlock_irq(&ice->reg_lock); 1892 return change; 1893 } 1894 1895 static struct snd_kcontrol_new snd_vt1724_pro_rate_locking __devinitdata = { 1896 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1897 .name = "Multi Track Rate Locking", 1898 .info = snd_vt1724_pro_rate_locking_info, 1899 .get = snd_vt1724_pro_rate_locking_get, 1900 .put = snd_vt1724_pro_rate_locking_put 1901 }; 1902 1903 #define snd_vt1724_pro_rate_reset_info snd_ctl_boolean_mono_info 1904 1905 static int snd_vt1724_pro_rate_reset_get(struct snd_kcontrol *kcontrol, 1906 struct snd_ctl_elem_value *ucontrol) 1907 { 1908 ucontrol->value.integer.value[0] = PRO_RATE_RESET ? 1 : 0; 1909 return 0; 1910 } 1911 1912 static int snd_vt1724_pro_rate_reset_put(struct snd_kcontrol *kcontrol, 1913 struct snd_ctl_elem_value *ucontrol) 1914 { 1915 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1916 int change = 0, nval; 1917 1918 nval = ucontrol->value.integer.value[0] ? 1 : 0; 1919 spin_lock_irq(&ice->reg_lock); 1920 change = PRO_RATE_RESET != nval; 1921 PRO_RATE_RESET = nval; 1922 spin_unlock_irq(&ice->reg_lock); 1923 return change; 1924 } 1925 1926 static struct snd_kcontrol_new snd_vt1724_pro_rate_reset __devinitdata = { 1927 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1928 .name = "Multi Track Rate Reset", 1929 .info = snd_vt1724_pro_rate_reset_info, 1930 .get = snd_vt1724_pro_rate_reset_get, 1931 .put = snd_vt1724_pro_rate_reset_put 1932 }; 1933 1934 1935 /* 1936 * routing 1937 */ 1938 static int snd_vt1724_pro_route_info(struct snd_kcontrol *kcontrol, 1939 struct snd_ctl_elem_info *uinfo) 1940 { 1941 static char *texts[] = { 1942 "PCM Out", /* 0 */ 1943 "H/W In 0", "H/W In 1", /* 1-2 */ 1944 "IEC958 In L", "IEC958 In R", /* 3-4 */ 1945 }; 1946 1947 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1948 uinfo->count = 1; 1949 uinfo->value.enumerated.items = 5; 1950 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) 1951 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; 1952 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 1953 return 0; 1954 } 1955 1956 static inline int analog_route_shift(int idx) 1957 { 1958 return (idx % 2) * 12 + ((idx / 2) * 3) + 8; 1959 } 1960 1961 static inline int digital_route_shift(int idx) 1962 { 1963 return idx * 3; 1964 } 1965 1966 static int get_route_val(struct snd_ice1712 *ice, int shift) 1967 { 1968 unsigned long val; 1969 unsigned char eitem; 1970 static const unsigned char xlate[8] = { 1971 0, 255, 1, 2, 255, 255, 3, 4, 1972 }; 1973 1974 val = inl(ICEMT1724(ice, ROUTE_PLAYBACK)); 1975 val >>= shift; 1976 val &= 7; /* we now have 3 bits per output */ 1977 eitem = xlate[val]; 1978 if (eitem == 255) { 1979 snd_BUG(); 1980 return 0; 1981 } 1982 return eitem; 1983 } 1984 1985 static int put_route_val(struct snd_ice1712 *ice, unsigned int val, int shift) 1986 { 1987 unsigned int old_val, nval; 1988 int change; 1989 static const unsigned char xroute[8] = { 1990 0, /* PCM */ 1991 2, /* PSDIN0 Left */ 1992 3, /* PSDIN0 Right */ 1993 6, /* SPDIN Left */ 1994 7, /* SPDIN Right */ 1995 }; 1996 1997 nval = xroute[val % 5]; 1998 val = old_val = inl(ICEMT1724(ice, ROUTE_PLAYBACK)); 1999 val &= ~(0x07 << shift); 2000 val |= nval << shift; 2001 change = val != old_val; 2002 if (change) 2003 outl(val, ICEMT1724(ice, ROUTE_PLAYBACK)); 2004 return change; 2005 } 2006 2007 static int snd_vt1724_pro_route_analog_get(struct snd_kcontrol *kcontrol, 2008 struct snd_ctl_elem_value *ucontrol) 2009 { 2010 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 2011 int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 2012 ucontrol->value.enumerated.item[0] = 2013 get_route_val(ice, analog_route_shift(idx)); 2014 return 0; 2015 } 2016 2017 static int snd_vt1724_pro_route_analog_put(struct snd_kcontrol *kcontrol, 2018 struct snd_ctl_elem_value *ucontrol) 2019 { 2020 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 2021 int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 2022 return put_route_val(ice, ucontrol->value.enumerated.item[0], 2023 analog_route_shift(idx)); 2024 } 2025 2026 static int snd_vt1724_pro_route_spdif_get(struct snd_kcontrol *kcontrol, 2027 struct snd_ctl_elem_value *ucontrol) 2028 { 2029 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 2030 int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 2031 ucontrol->value.enumerated.item[0] = 2032 get_route_val(ice, digital_route_shift(idx)); 2033 return 0; 2034 } 2035 2036 static int snd_vt1724_pro_route_spdif_put(struct snd_kcontrol *kcontrol, 2037 struct snd_ctl_elem_value *ucontrol) 2038 { 2039 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 2040 int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 2041 return put_route_val(ice, ucontrol->value.enumerated.item[0], 2042 digital_route_shift(idx)); 2043 } 2044 2045 static struct snd_kcontrol_new snd_vt1724_mixer_pro_analog_route __devinitdata = { 2046 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2047 .name = "H/W Playback Route", 2048 .info = snd_vt1724_pro_route_info, 2049 .get = snd_vt1724_pro_route_analog_get, 2050 .put = snd_vt1724_pro_route_analog_put, 2051 }; 2052 2053 static struct snd_kcontrol_new snd_vt1724_mixer_pro_spdif_route __devinitdata = { 2054 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2055 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, NONE) "Route", 2056 .info = snd_vt1724_pro_route_info, 2057 .get = snd_vt1724_pro_route_spdif_get, 2058 .put = snd_vt1724_pro_route_spdif_put, 2059 .count = 2, 2060 }; 2061 2062 2063 static int snd_vt1724_pro_peak_info(struct snd_kcontrol *kcontrol, 2064 struct snd_ctl_elem_info *uinfo) 2065 { 2066 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2067 uinfo->count = 22; /* FIXME: for compatibility with ice1712... */ 2068 uinfo->value.integer.min = 0; 2069 uinfo->value.integer.max = 255; 2070 return 0; 2071 } 2072 2073 static int snd_vt1724_pro_peak_get(struct snd_kcontrol *kcontrol, 2074 struct snd_ctl_elem_value *ucontrol) 2075 { 2076 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 2077 int idx; 2078 2079 spin_lock_irq(&ice->reg_lock); 2080 for (idx = 0; idx < 22; idx++) { 2081 outb(idx, ICEMT1724(ice, MONITOR_PEAKINDEX)); 2082 ucontrol->value.integer.value[idx] = 2083 inb(ICEMT1724(ice, MONITOR_PEAKDATA)); 2084 } 2085 spin_unlock_irq(&ice->reg_lock); 2086 return 0; 2087 } 2088 2089 static struct snd_kcontrol_new snd_vt1724_mixer_pro_peak __devinitdata = { 2090 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2091 .name = "Multi Track Peak", 2092 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2093 .info = snd_vt1724_pro_peak_info, 2094 .get = snd_vt1724_pro_peak_get 2095 }; 2096 2097 /* 2098 * 2099 */ 2100 2101 static struct snd_ice1712_card_info no_matched __devinitdata; 2102 2103 static struct snd_ice1712_card_info *card_tables[] __devinitdata = { 2104 snd_vt1724_revo_cards, 2105 snd_vt1724_amp_cards, 2106 snd_vt1724_aureon_cards, 2107 snd_vt1720_mobo_cards, 2108 snd_vt1720_pontis_cards, 2109 snd_vt1724_prodigy_hifi_cards, 2110 snd_vt1724_prodigy192_cards, 2111 snd_vt1724_juli_cards, 2112 snd_vt1724_phase_cards, 2113 snd_vt1724_wtm_cards, 2114 snd_vt1724_se_cards, 2115 NULL, 2116 }; 2117 2118 2119 /* 2120 */ 2121 2122 static void wait_i2c_busy(struct snd_ice1712 *ice) 2123 { 2124 int t = 0x10000; 2125 while ((inb(ICEREG1724(ice, I2C_CTRL)) & VT1724_I2C_BUSY) && t--) 2126 ; 2127 if (t == -1) 2128 printk(KERN_ERR "ice1724: i2c busy timeout\n"); 2129 } 2130 2131 unsigned char snd_vt1724_read_i2c(struct snd_ice1712 *ice, 2132 unsigned char dev, unsigned char addr) 2133 { 2134 unsigned char val; 2135 2136 mutex_lock(&ice->i2c_mutex); 2137 wait_i2c_busy(ice); 2138 outb(addr, ICEREG1724(ice, I2C_BYTE_ADDR)); 2139 outb(dev & ~VT1724_I2C_WRITE, ICEREG1724(ice, I2C_DEV_ADDR)); 2140 wait_i2c_busy(ice); 2141 val = inb(ICEREG1724(ice, I2C_DATA)); 2142 mutex_unlock(&ice->i2c_mutex); 2143 /* 2144 printk(KERN_DEBUG "i2c_read: [0x%x,0x%x] = 0x%x\n", dev, addr, val); 2145 */ 2146 return val; 2147 } 2148 2149 void snd_vt1724_write_i2c(struct snd_ice1712 *ice, 2150 unsigned char dev, unsigned char addr, unsigned char data) 2151 { 2152 mutex_lock(&ice->i2c_mutex); 2153 wait_i2c_busy(ice); 2154 /* 2155 printk(KERN_DEBUG "i2c_write: [0x%x,0x%x] = 0x%x\n", dev, addr, data); 2156 */ 2157 outb(addr, ICEREG1724(ice, I2C_BYTE_ADDR)); 2158 outb(data, ICEREG1724(ice, I2C_DATA)); 2159 outb(dev | VT1724_I2C_WRITE, ICEREG1724(ice, I2C_DEV_ADDR)); 2160 wait_i2c_busy(ice); 2161 mutex_unlock(&ice->i2c_mutex); 2162 } 2163 2164 static int __devinit snd_vt1724_read_eeprom(struct snd_ice1712 *ice, 2165 const char *modelname) 2166 { 2167 const int dev = 0xa0; /* EEPROM device address */ 2168 unsigned int i, size; 2169 struct snd_ice1712_card_info * const *tbl, *c; 2170 2171 if (!modelname || !*modelname) { 2172 ice->eeprom.subvendor = 0; 2173 if ((inb(ICEREG1724(ice, I2C_CTRL)) & VT1724_I2C_EEPROM) != 0) 2174 ice->eeprom.subvendor = 2175 (snd_vt1724_read_i2c(ice, dev, 0x00) << 0) | 2176 (snd_vt1724_read_i2c(ice, dev, 0x01) << 8) | 2177 (snd_vt1724_read_i2c(ice, dev, 0x02) << 16) | 2178 (snd_vt1724_read_i2c(ice, dev, 0x03) << 24); 2179 if (ice->eeprom.subvendor == 0 || 2180 ice->eeprom.subvendor == (unsigned int)-1) { 2181 /* invalid subvendor from EEPROM, try the PCI 2182 * subststem ID instead 2183 */ 2184 u16 vendor, device; 2185 pci_read_config_word(ice->pci, PCI_SUBSYSTEM_VENDOR_ID, 2186 &vendor); 2187 pci_read_config_word(ice->pci, PCI_SUBSYSTEM_ID, &device); 2188 ice->eeprom.subvendor = 2189 ((unsigned int)swab16(vendor) << 16) | swab16(device); 2190 if (ice->eeprom.subvendor == 0 || 2191 ice->eeprom.subvendor == (unsigned int)-1) { 2192 printk(KERN_ERR "ice1724: No valid ID is found\n"); 2193 return -ENXIO; 2194 } 2195 } 2196 } 2197 for (tbl = card_tables; *tbl; tbl++) { 2198 for (c = *tbl; c->subvendor; c++) { 2199 if (modelname && c->model && 2200 !strcmp(modelname, c->model)) { 2201 printk(KERN_INFO "ice1724: Using board model %s\n", 2202 c->name); 2203 ice->eeprom.subvendor = c->subvendor; 2204 } else if (c->subvendor != ice->eeprom.subvendor) 2205 continue; 2206 if (!c->eeprom_size || !c->eeprom_data) 2207 goto found; 2208 /* if the EEPROM is given by the driver, use it */ 2209 snd_printdd("using the defined eeprom..\n"); 2210 ice->eeprom.version = 2; 2211 ice->eeprom.size = c->eeprom_size + 6; 2212 memcpy(ice->eeprom.data, c->eeprom_data, c->eeprom_size); 2213 goto read_skipped; 2214 } 2215 } 2216 printk(KERN_WARNING "ice1724: No matching model found for ID 0x%x\n", 2217 ice->eeprom.subvendor); 2218 2219 found: 2220 ice->eeprom.size = snd_vt1724_read_i2c(ice, dev, 0x04); 2221 if (ice->eeprom.size < 6) 2222 ice->eeprom.size = 32; 2223 else if (ice->eeprom.size > 32) { 2224 printk(KERN_ERR "ice1724: Invalid EEPROM (size = %i)\n", 2225 ice->eeprom.size); 2226 return -EIO; 2227 } 2228 ice->eeprom.version = snd_vt1724_read_i2c(ice, dev, 0x05); 2229 if (ice->eeprom.version != 2) 2230 printk(KERN_WARNING "ice1724: Invalid EEPROM version %i\n", 2231 ice->eeprom.version); 2232 size = ice->eeprom.size - 6; 2233 for (i = 0; i < size; i++) 2234 ice->eeprom.data[i] = snd_vt1724_read_i2c(ice, dev, i + 6); 2235 2236 read_skipped: 2237 ice->eeprom.gpiomask = eeprom_triple(ice, ICE_EEP2_GPIO_MASK); 2238 ice->eeprom.gpiostate = eeprom_triple(ice, ICE_EEP2_GPIO_STATE); 2239 ice->eeprom.gpiodir = eeprom_triple(ice, ICE_EEP2_GPIO_DIR); 2240 2241 return 0; 2242 } 2243 2244 2245 2246 static void __devinit snd_vt1724_chip_reset(struct snd_ice1712 *ice) 2247 { 2248 outb(VT1724_RESET , ICEREG1724(ice, CONTROL)); 2249 msleep(10); 2250 outb(0, ICEREG1724(ice, CONTROL)); 2251 msleep(10); 2252 } 2253 2254 static int __devinit snd_vt1724_chip_init(struct snd_ice1712 *ice) 2255 { 2256 outb(ice->eeprom.data[ICE_EEP2_SYSCONF], ICEREG1724(ice, SYS_CFG)); 2257 outb(ice->eeprom.data[ICE_EEP2_ACLINK], ICEREG1724(ice, AC97_CFG)); 2258 outb(ice->eeprom.data[ICE_EEP2_I2S], ICEREG1724(ice, I2S_FEATURES)); 2259 outb(ice->eeprom.data[ICE_EEP2_SPDIF], ICEREG1724(ice, SPDIF_CFG)); 2260 2261 ice->gpio.write_mask = ice->eeprom.gpiomask; 2262 ice->gpio.direction = ice->eeprom.gpiodir; 2263 snd_vt1724_set_gpio_mask(ice, ice->eeprom.gpiomask); 2264 snd_vt1724_set_gpio_dir(ice, ice->eeprom.gpiodir); 2265 snd_vt1724_set_gpio_data(ice, ice->eeprom.gpiostate); 2266 2267 outb(0, ICEREG1724(ice, POWERDOWN)); 2268 2269 return 0; 2270 } 2271 2272 static int __devinit snd_vt1724_spdif_build_controls(struct snd_ice1712 *ice) 2273 { 2274 int err; 2275 struct snd_kcontrol *kctl; 2276 2277 if (snd_BUG_ON(!ice->pcm)) 2278 return -EIO; 2279 2280 err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_vt1724_mixer_pro_spdif_route, ice)); 2281 if (err < 0) 2282 return err; 2283 2284 err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_vt1724_spdif_switch, ice)); 2285 if (err < 0) 2286 return err; 2287 2288 err = snd_ctl_add(ice->card, kctl = snd_ctl_new1(&snd_vt1724_spdif_default, ice)); 2289 if (err < 0) 2290 return err; 2291 kctl->id.device = ice->pcm->device; 2292 err = snd_ctl_add(ice->card, kctl = snd_ctl_new1(&snd_vt1724_spdif_maskc, ice)); 2293 if (err < 0) 2294 return err; 2295 kctl->id.device = ice->pcm->device; 2296 err = snd_ctl_add(ice->card, kctl = snd_ctl_new1(&snd_vt1724_spdif_maskp, ice)); 2297 if (err < 0) 2298 return err; 2299 kctl->id.device = ice->pcm->device; 2300 #if 0 /* use default only */ 2301 err = snd_ctl_add(ice->card, kctl = snd_ctl_new1(&snd_vt1724_spdif_stream, ice)); 2302 if (err < 0) 2303 return err; 2304 kctl->id.device = ice->pcm->device; 2305 ice->spdif.stream_ctl = kctl; 2306 #endif 2307 return 0; 2308 } 2309 2310 2311 static int __devinit snd_vt1724_build_controls(struct snd_ice1712 *ice) 2312 { 2313 int err; 2314 2315 err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_vt1724_eeprom, ice)); 2316 if (err < 0) 2317 return err; 2318 err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_vt1724_pro_internal_clock, ice)); 2319 if (err < 0) 2320 return err; 2321 2322 err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_vt1724_pro_rate_locking, ice)); 2323 if (err < 0) 2324 return err; 2325 err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_vt1724_pro_rate_reset, ice)); 2326 if (err < 0) 2327 return err; 2328 2329 if (ice->num_total_dacs > 0) { 2330 struct snd_kcontrol_new tmp = snd_vt1724_mixer_pro_analog_route; 2331 tmp.count = ice->num_total_dacs; 2332 if (ice->vt1720 && tmp.count > 2) 2333 tmp.count = 2; 2334 err = snd_ctl_add(ice->card, snd_ctl_new1(&tmp, ice)); 2335 if (err < 0) 2336 return err; 2337 } 2338 2339 err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_vt1724_mixer_pro_peak, ice)); 2340 if (err < 0) 2341 return err; 2342 2343 return 0; 2344 } 2345 2346 static int snd_vt1724_free(struct snd_ice1712 *ice) 2347 { 2348 if (!ice->port) 2349 goto __hw_end; 2350 /* mask all interrupts */ 2351 outb(0xff, ICEMT1724(ice, DMA_INT_MASK)); 2352 outb(0xff, ICEREG1724(ice, IRQMASK)); 2353 /* --- */ 2354 __hw_end: 2355 if (ice->irq >= 0) 2356 free_irq(ice->irq, ice); 2357 pci_release_regions(ice->pci); 2358 snd_ice1712_akm4xxx_free(ice); 2359 pci_disable_device(ice->pci); 2360 kfree(ice->spec); 2361 kfree(ice); 2362 return 0; 2363 } 2364 2365 static int snd_vt1724_dev_free(struct snd_device *device) 2366 { 2367 struct snd_ice1712 *ice = device->device_data; 2368 return snd_vt1724_free(ice); 2369 } 2370 2371 static int __devinit snd_vt1724_create(struct snd_card *card, 2372 struct pci_dev *pci, 2373 const char *modelname, 2374 struct snd_ice1712 **r_ice1712) 2375 { 2376 struct snd_ice1712 *ice; 2377 int err; 2378 static struct snd_device_ops ops = { 2379 .dev_free = snd_vt1724_dev_free, 2380 }; 2381 2382 *r_ice1712 = NULL; 2383 2384 /* enable PCI device */ 2385 err = pci_enable_device(pci); 2386 if (err < 0) 2387 return err; 2388 2389 ice = kzalloc(sizeof(*ice), GFP_KERNEL); 2390 if (ice == NULL) { 2391 pci_disable_device(pci); 2392 return -ENOMEM; 2393 } 2394 ice->vt1724 = 1; 2395 spin_lock_init(&ice->reg_lock); 2396 mutex_init(&ice->gpio_mutex); 2397 mutex_init(&ice->open_mutex); 2398 mutex_init(&ice->i2c_mutex); 2399 ice->gpio.set_mask = snd_vt1724_set_gpio_mask; 2400 ice->gpio.set_dir = snd_vt1724_set_gpio_dir; 2401 ice->gpio.set_data = snd_vt1724_set_gpio_data; 2402 ice->gpio.get_data = snd_vt1724_get_gpio_data; 2403 ice->card = card; 2404 ice->pci = pci; 2405 ice->irq = -1; 2406 pci_set_master(pci); 2407 snd_vt1724_proc_init(ice); 2408 synchronize_irq(pci->irq); 2409 2410 err = pci_request_regions(pci, "ICE1724"); 2411 if (err < 0) { 2412 kfree(ice); 2413 pci_disable_device(pci); 2414 return err; 2415 } 2416 ice->port = pci_resource_start(pci, 0); 2417 ice->profi_port = pci_resource_start(pci, 1); 2418 2419 if (request_irq(pci->irq, snd_vt1724_interrupt, 2420 IRQF_SHARED, "ICE1724", ice)) { 2421 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); 2422 snd_vt1724_free(ice); 2423 return -EIO; 2424 } 2425 2426 ice->irq = pci->irq; 2427 2428 snd_vt1724_chip_reset(ice); 2429 if (snd_vt1724_read_eeprom(ice, modelname) < 0) { 2430 snd_vt1724_free(ice); 2431 return -EIO; 2432 } 2433 if (snd_vt1724_chip_init(ice) < 0) { 2434 snd_vt1724_free(ice); 2435 return -EIO; 2436 } 2437 2438 /* MPU_RX and TX irq masks are cleared later dynamically */ 2439 outb(VT1724_IRQ_MPU_RX | VT1724_IRQ_MPU_TX , ICEREG1724(ice, IRQMASK)); 2440 2441 /* don't handle FIFO overrun/underruns (just yet), 2442 * since they cause machine lockups 2443 */ 2444 outb(VT1724_MULTI_FIFO_ERR, ICEMT1724(ice, DMA_INT_MASK)); 2445 2446 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, ice, &ops); 2447 if (err < 0) { 2448 snd_vt1724_free(ice); 2449 return err; 2450 } 2451 2452 snd_card_set_dev(card, &pci->dev); 2453 2454 *r_ice1712 = ice; 2455 return 0; 2456 } 2457 2458 2459 /* 2460 * 2461 * Registration 2462 * 2463 */ 2464 2465 static int __devinit snd_vt1724_probe(struct pci_dev *pci, 2466 const struct pci_device_id *pci_id) 2467 { 2468 static int dev; 2469 struct snd_card *card; 2470 struct snd_ice1712 *ice; 2471 int pcm_dev = 0, err; 2472 struct snd_ice1712_card_info * const *tbl, *c; 2473 2474 if (dev >= SNDRV_CARDS) 2475 return -ENODEV; 2476 if (!enable[dev]) { 2477 dev++; 2478 return -ENOENT; 2479 } 2480 2481 err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card); 2482 if (err < 0) 2483 return err; 2484 2485 strcpy(card->driver, "ICE1724"); 2486 strcpy(card->shortname, "ICEnsemble ICE1724"); 2487 2488 err = snd_vt1724_create(card, pci, model[dev], &ice); 2489 if (err < 0) { 2490 snd_card_free(card); 2491 return err; 2492 } 2493 2494 for (tbl = card_tables; *tbl; tbl++) { 2495 for (c = *tbl; c->subvendor; c++) { 2496 if (c->subvendor == ice->eeprom.subvendor) { 2497 strcpy(card->shortname, c->name); 2498 if (c->driver) /* specific driver? */ 2499 strcpy(card->driver, c->driver); 2500 if (c->chip_init) { 2501 err = c->chip_init(ice); 2502 if (err < 0) { 2503 snd_card_free(card); 2504 return err; 2505 } 2506 } 2507 goto __found; 2508 } 2509 } 2510 } 2511 c = &no_matched; 2512 __found: 2513 /* 2514 * VT1724 has separate DMAs for the analog and the SPDIF streams while 2515 * ICE1712 has only one for both (mixed up). 2516 * 2517 * Confusingly the analog PCM is named "professional" here because it 2518 * was called so in ice1712 driver, and vt1724 driver is derived from 2519 * ice1712 driver. 2520 */ 2521 ice->pro_rate_default = PRO_RATE_DEFAULT; 2522 if (!ice->is_spdif_master) 2523 ice->is_spdif_master = stdclock_is_spdif_master; 2524 if (!ice->get_rate) 2525 ice->get_rate = stdclock_get_rate; 2526 if (!ice->set_rate) 2527 ice->set_rate = stdclock_set_rate; 2528 if (!ice->set_mclk) 2529 ice->set_mclk = stdclock_set_mclk; 2530 if (!ice->set_spdif_clock) 2531 ice->set_spdif_clock = stdclock_set_spdif_clock; 2532 if (!ice->hw_rates) 2533 set_std_hw_rates(ice); 2534 2535 err = snd_vt1724_pcm_profi(ice, pcm_dev++); 2536 if (err < 0) { 2537 snd_card_free(card); 2538 return err; 2539 } 2540 2541 err = snd_vt1724_pcm_spdif(ice, pcm_dev++); 2542 if (err < 0) { 2543 snd_card_free(card); 2544 return err; 2545 } 2546 2547 err = snd_vt1724_pcm_indep(ice, pcm_dev++); 2548 if (err < 0) { 2549 snd_card_free(card); 2550 return err; 2551 } 2552 2553 err = snd_vt1724_ac97_mixer(ice); 2554 if (err < 0) { 2555 snd_card_free(card); 2556 return err; 2557 } 2558 2559 err = snd_vt1724_build_controls(ice); 2560 if (err < 0) { 2561 snd_card_free(card); 2562 return err; 2563 } 2564 2565 if (ice->pcm && ice->has_spdif) { /* has SPDIF I/O */ 2566 err = snd_vt1724_spdif_build_controls(ice); 2567 if (err < 0) { 2568 snd_card_free(card); 2569 return err; 2570 } 2571 } 2572 2573 if (c->build_controls) { 2574 err = c->build_controls(ice); 2575 if (err < 0) { 2576 snd_card_free(card); 2577 return err; 2578 } 2579 } 2580 2581 if (!c->no_mpu401) { 2582 if (ice->eeprom.data[ICE_EEP2_SYSCONF] & VT1724_CFG_MPU401) { 2583 struct snd_rawmidi *rmidi; 2584 2585 err = snd_rawmidi_new(card, "MIDI", 0, 1, 1, &rmidi); 2586 if (err < 0) { 2587 snd_card_free(card); 2588 return err; 2589 } 2590 ice->rmidi[0] = rmidi; 2591 rmidi->private_data = ice; 2592 strcpy(rmidi->name, "ICE1724 MIDI"); 2593 rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT | 2594 SNDRV_RAWMIDI_INFO_INPUT | 2595 SNDRV_RAWMIDI_INFO_DUPLEX; 2596 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, 2597 &vt1724_midi_output_ops); 2598 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, 2599 &vt1724_midi_input_ops); 2600 2601 /* set watermarks */ 2602 outb(VT1724_MPU_RX_FIFO | 0x1, 2603 ICEREG1724(ice, MPU_FIFO_WM)); 2604 outb(0x1, ICEREG1724(ice, MPU_FIFO_WM)); 2605 /* set UART mode */ 2606 outb(VT1724_MPU_UART, ICEREG1724(ice, MPU_CTRL)); 2607 } 2608 } 2609 2610 sprintf(card->longname, "%s at 0x%lx, irq %i", 2611 card->shortname, ice->port, ice->irq); 2612 2613 err = snd_card_register(card); 2614 if (err < 0) { 2615 snd_card_free(card); 2616 return err; 2617 } 2618 pci_set_drvdata(pci, card); 2619 dev++; 2620 return 0; 2621 } 2622 2623 static void __devexit snd_vt1724_remove(struct pci_dev *pci) 2624 { 2625 snd_card_free(pci_get_drvdata(pci)); 2626 pci_set_drvdata(pci, NULL); 2627 } 2628 2629 static struct pci_driver driver = { 2630 .name = "ICE1724", 2631 .id_table = snd_vt1724_ids, 2632 .probe = snd_vt1724_probe, 2633 .remove = __devexit_p(snd_vt1724_remove), 2634 }; 2635 2636 static int __init alsa_card_ice1724_init(void) 2637 { 2638 return pci_register_driver(&driver); 2639 } 2640 2641 static void __exit alsa_card_ice1724_exit(void) 2642 { 2643 pci_unregister_driver(&driver); 2644 } 2645 2646 module_init(alsa_card_ice1724_init) 2647 module_exit(alsa_card_ice1724_exit) 2648