1 /* 2 * als300.c - driver for Avance Logic ALS300/ALS300+ soundcards. 3 * Copyright (C) 2005 by Ash Willis <ashwillis@programmer.net> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 * 19 * TODO 20 * 4 channel playback for ALS300+ 21 * gameport 22 * mpu401 23 * opl3 24 * 25 * NOTES 26 * The BLOCK_COUNTER registers for the ALS300(+) return a figure related to 27 * the position in the current period, NOT the whole buffer. It is important 28 * to know which period we are in so we can calculate the correct pointer. 29 * This is why we always use 2 periods. We can then use a flip-flop variable 30 * to keep track of what period we are in. 31 */ 32 33 #include <linux/delay.h> 34 #include <linux/init.h> 35 #include <linux/module.h> 36 #include <linux/pci.h> 37 #include <linux/dma-mapping.h> 38 #include <linux/interrupt.h> 39 #include <linux/slab.h> 40 41 #include <asm/io.h> 42 43 #include <sound/core.h> 44 #include <sound/control.h> 45 #include <sound/initval.h> 46 #include <sound/pcm.h> 47 #include <sound/pcm_params.h> 48 #include <sound/ac97_codec.h> 49 #include <sound/opl3.h> 50 51 /* snd_als300_set_irq_flag */ 52 #define IRQ_DISABLE 0 53 #define IRQ_ENABLE 1 54 55 /* I/O port layout */ 56 #define AC97_ACCESS 0x00 57 #define AC97_READ 0x04 58 #define AC97_STATUS 0x06 59 #define AC97_DATA_AVAIL (1<<6) 60 #define AC97_BUSY (1<<7) 61 #define ALS300_IRQ_STATUS 0x07 /* ALS300 Only */ 62 #define IRQ_PLAYBACK (1<<3) 63 #define IRQ_CAPTURE (1<<2) 64 #define GCR_DATA 0x08 65 #define GCR_INDEX 0x0C 66 #define ALS300P_DRAM_IRQ_STATUS 0x0D /* ALS300+ Only */ 67 #define MPU_IRQ_STATUS 0x0E /* ALS300 Rev. E+, ALS300+ */ 68 #define ALS300P_IRQ_STATUS 0x0F /* ALS300+ Only */ 69 70 /* General Control Registers */ 71 #define PLAYBACK_START 0x80 72 #define PLAYBACK_END 0x81 73 #define PLAYBACK_CONTROL 0x82 74 #define TRANSFER_START (1<<16) 75 #define FIFO_PAUSE (1<<17) 76 #define RECORD_START 0x83 77 #define RECORD_END 0x84 78 #define RECORD_CONTROL 0x85 79 #define DRAM_WRITE_CONTROL 0x8B 80 #define WRITE_TRANS_START (1<<16) 81 #define DRAM_MODE_2 (1<<17) 82 #define MISC_CONTROL 0x8C 83 #define IRQ_SET_BIT (1<<15) 84 #define VMUTE_NORMAL (1<<20) 85 #define MMUTE_NORMAL (1<<21) 86 #define MUS_VOC_VOL 0x8E 87 #define PLAYBACK_BLOCK_COUNTER 0x9A 88 #define RECORD_BLOCK_COUNTER 0x9B 89 90 #define DEBUG_PLAY_REC 0 91 92 #if DEBUG_PLAY_REC 93 #define snd_als300_dbgplay(format, args...) printk(KERN_ERR format, ##args) 94 #else 95 #define snd_als300_dbgplay(format, args...) 96 #endif 97 98 enum {DEVICE_ALS300, DEVICE_ALS300_PLUS}; 99 100 MODULE_AUTHOR("Ash Willis <ashwillis@programmer.net>"); 101 MODULE_DESCRIPTION("Avance Logic ALS300"); 102 MODULE_LICENSE("GPL"); 103 MODULE_SUPPORTED_DEVICE("{{Avance Logic,ALS300},{Avance Logic,ALS300+}}"); 104 105 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; 106 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; 107 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; 108 109 module_param_array(index, int, NULL, 0444); 110 MODULE_PARM_DESC(index, "Index value for ALS300 sound card."); 111 module_param_array(id, charp, NULL, 0444); 112 MODULE_PARM_DESC(id, "ID string for ALS300 sound card."); 113 module_param_array(enable, bool, NULL, 0444); 114 MODULE_PARM_DESC(enable, "Enable ALS300 sound card."); 115 116 struct snd_als300 { 117 unsigned long port; 118 spinlock_t reg_lock; 119 struct snd_card *card; 120 struct pci_dev *pci; 121 122 struct snd_pcm *pcm; 123 struct snd_pcm_substream *playback_substream; 124 struct snd_pcm_substream *capture_substream; 125 126 struct snd_ac97 *ac97; 127 struct snd_opl3 *opl3; 128 129 struct resource *res_port; 130 131 int irq; 132 133 int chip_type; /* ALS300 or ALS300+ */ 134 135 char revision; 136 }; 137 138 struct snd_als300_substream_data { 139 int period_flipflop; 140 int control_register; 141 int block_counter_register; 142 }; 143 144 static const struct pci_device_id snd_als300_ids[] = { 145 { 0x4005, 0x0300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_ALS300 }, 146 { 0x4005, 0x0308, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_ALS300_PLUS }, 147 { 0, } 148 }; 149 150 MODULE_DEVICE_TABLE(pci, snd_als300_ids); 151 152 static inline u32 snd_als300_gcr_read(unsigned long port, unsigned short reg) 153 { 154 outb(reg, port+GCR_INDEX); 155 return inl(port+GCR_DATA); 156 } 157 158 static inline void snd_als300_gcr_write(unsigned long port, 159 unsigned short reg, u32 val) 160 { 161 outb(reg, port+GCR_INDEX); 162 outl(val, port+GCR_DATA); 163 } 164 165 /* Enable/Disable Interrupts */ 166 static void snd_als300_set_irq_flag(struct snd_als300 *chip, int cmd) 167 { 168 u32 tmp = snd_als300_gcr_read(chip->port, MISC_CONTROL); 169 170 /* boolean XOR check, since old vs. new hardware have 171 directly reversed bit setting for ENABLE and DISABLE. 172 ALS300+ acts like newer versions of ALS300 */ 173 if (((chip->revision > 5 || chip->chip_type == DEVICE_ALS300_PLUS) ^ 174 (cmd == IRQ_ENABLE)) == 0) 175 tmp |= IRQ_SET_BIT; 176 else 177 tmp &= ~IRQ_SET_BIT; 178 snd_als300_gcr_write(chip->port, MISC_CONTROL, tmp); 179 } 180 181 static int snd_als300_free(struct snd_als300 *chip) 182 { 183 snd_als300_set_irq_flag(chip, IRQ_DISABLE); 184 if (chip->irq >= 0) 185 free_irq(chip->irq, chip); 186 pci_release_regions(chip->pci); 187 pci_disable_device(chip->pci); 188 kfree(chip); 189 return 0; 190 } 191 192 static int snd_als300_dev_free(struct snd_device *device) 193 { 194 struct snd_als300 *chip = device->device_data; 195 return snd_als300_free(chip); 196 } 197 198 static irqreturn_t snd_als300_interrupt(int irq, void *dev_id) 199 { 200 u8 status; 201 struct snd_als300 *chip = dev_id; 202 struct snd_als300_substream_data *data; 203 204 status = inb(chip->port+ALS300_IRQ_STATUS); 205 if (!status) /* shared IRQ, for different device?? Exit ASAP! */ 206 return IRQ_NONE; 207 208 /* ACK everything ASAP */ 209 outb(status, chip->port+ALS300_IRQ_STATUS); 210 if (status & IRQ_PLAYBACK) { 211 if (chip->pcm && chip->playback_substream) { 212 data = chip->playback_substream->runtime->private_data; 213 data->period_flipflop ^= 1; 214 snd_pcm_period_elapsed(chip->playback_substream); 215 snd_als300_dbgplay("IRQ_PLAYBACK\n"); 216 } 217 } 218 if (status & IRQ_CAPTURE) { 219 if (chip->pcm && chip->capture_substream) { 220 data = chip->capture_substream->runtime->private_data; 221 data->period_flipflop ^= 1; 222 snd_pcm_period_elapsed(chip->capture_substream); 223 snd_als300_dbgplay("IRQ_CAPTURE\n"); 224 } 225 } 226 return IRQ_HANDLED; 227 } 228 229 static irqreturn_t snd_als300plus_interrupt(int irq, void *dev_id) 230 { 231 u8 general, mpu, dram; 232 struct snd_als300 *chip = dev_id; 233 struct snd_als300_substream_data *data; 234 235 general = inb(chip->port+ALS300P_IRQ_STATUS); 236 mpu = inb(chip->port+MPU_IRQ_STATUS); 237 dram = inb(chip->port+ALS300P_DRAM_IRQ_STATUS); 238 239 /* shared IRQ, for different device?? Exit ASAP! */ 240 if ((general == 0) && ((mpu & 0x80) == 0) && ((dram & 0x01) == 0)) 241 return IRQ_NONE; 242 243 if (general & IRQ_PLAYBACK) { 244 if (chip->pcm && chip->playback_substream) { 245 outb(IRQ_PLAYBACK, chip->port+ALS300P_IRQ_STATUS); 246 data = chip->playback_substream->runtime->private_data; 247 data->period_flipflop ^= 1; 248 snd_pcm_period_elapsed(chip->playback_substream); 249 snd_als300_dbgplay("IRQ_PLAYBACK\n"); 250 } 251 } 252 if (general & IRQ_CAPTURE) { 253 if (chip->pcm && chip->capture_substream) { 254 outb(IRQ_CAPTURE, chip->port+ALS300P_IRQ_STATUS); 255 data = chip->capture_substream->runtime->private_data; 256 data->period_flipflop ^= 1; 257 snd_pcm_period_elapsed(chip->capture_substream); 258 snd_als300_dbgplay("IRQ_CAPTURE\n"); 259 } 260 } 261 /* FIXME: Ack other interrupt types. Not important right now as 262 * those other devices aren't enabled. */ 263 return IRQ_HANDLED; 264 } 265 266 static void snd_als300_remove(struct pci_dev *pci) 267 { 268 snd_card_free(pci_get_drvdata(pci)); 269 } 270 271 static unsigned short snd_als300_ac97_read(struct snd_ac97 *ac97, 272 unsigned short reg) 273 { 274 int i; 275 struct snd_als300 *chip = ac97->private_data; 276 277 for (i = 0; i < 1000; i++) { 278 if ((inb(chip->port+AC97_STATUS) & (AC97_BUSY)) == 0) 279 break; 280 udelay(10); 281 } 282 outl((reg << 24) | (1 << 31), chip->port+AC97_ACCESS); 283 284 for (i = 0; i < 1000; i++) { 285 if ((inb(chip->port+AC97_STATUS) & (AC97_DATA_AVAIL)) != 0) 286 break; 287 udelay(10); 288 } 289 return inw(chip->port+AC97_READ); 290 } 291 292 static void snd_als300_ac97_write(struct snd_ac97 *ac97, 293 unsigned short reg, unsigned short val) 294 { 295 int i; 296 struct snd_als300 *chip = ac97->private_data; 297 298 for (i = 0; i < 1000; i++) { 299 if ((inb(chip->port+AC97_STATUS) & (AC97_BUSY)) == 0) 300 break; 301 udelay(10); 302 } 303 outl((reg << 24) | val, chip->port+AC97_ACCESS); 304 } 305 306 static int snd_als300_ac97(struct snd_als300 *chip) 307 { 308 struct snd_ac97_bus *bus; 309 struct snd_ac97_template ac97; 310 int err; 311 static struct snd_ac97_bus_ops ops = { 312 .write = snd_als300_ac97_write, 313 .read = snd_als300_ac97_read, 314 }; 315 316 if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &bus)) < 0) 317 return err; 318 319 memset(&ac97, 0, sizeof(ac97)); 320 ac97.private_data = chip; 321 322 return snd_ac97_mixer(bus, &ac97, &chip->ac97); 323 } 324 325 /* hardware definition 326 * 327 * In AC97 mode, we always use 48k/16bit/stereo. 328 * Any request to change data type is ignored by 329 * the card when it is running outside of legacy 330 * mode. 331 */ 332 static struct snd_pcm_hardware snd_als300_playback_hw = 333 { 334 .info = (SNDRV_PCM_INFO_MMAP | 335 SNDRV_PCM_INFO_INTERLEAVED | 336 SNDRV_PCM_INFO_PAUSE | 337 SNDRV_PCM_INFO_MMAP_VALID), 338 .formats = SNDRV_PCM_FMTBIT_S16, 339 .rates = SNDRV_PCM_RATE_48000, 340 .rate_min = 48000, 341 .rate_max = 48000, 342 .channels_min = 2, 343 .channels_max = 2, 344 .buffer_bytes_max = 64 * 1024, 345 .period_bytes_min = 64, 346 .period_bytes_max = 32 * 1024, 347 .periods_min = 2, 348 .periods_max = 2, 349 }; 350 351 static struct snd_pcm_hardware snd_als300_capture_hw = 352 { 353 .info = (SNDRV_PCM_INFO_MMAP | 354 SNDRV_PCM_INFO_INTERLEAVED | 355 SNDRV_PCM_INFO_PAUSE | 356 SNDRV_PCM_INFO_MMAP_VALID), 357 .formats = SNDRV_PCM_FMTBIT_S16, 358 .rates = SNDRV_PCM_RATE_48000, 359 .rate_min = 48000, 360 .rate_max = 48000, 361 .channels_min = 2, 362 .channels_max = 2, 363 .buffer_bytes_max = 64 * 1024, 364 .period_bytes_min = 64, 365 .period_bytes_max = 32 * 1024, 366 .periods_min = 2, 367 .periods_max = 2, 368 }; 369 370 static int snd_als300_playback_open(struct snd_pcm_substream *substream) 371 { 372 struct snd_als300 *chip = snd_pcm_substream_chip(substream); 373 struct snd_pcm_runtime *runtime = substream->runtime; 374 struct snd_als300_substream_data *data = kzalloc(sizeof(*data), 375 GFP_KERNEL); 376 377 if (!data) 378 return -ENOMEM; 379 chip->playback_substream = substream; 380 runtime->hw = snd_als300_playback_hw; 381 runtime->private_data = data; 382 data->control_register = PLAYBACK_CONTROL; 383 data->block_counter_register = PLAYBACK_BLOCK_COUNTER; 384 return 0; 385 } 386 387 static int snd_als300_playback_close(struct snd_pcm_substream *substream) 388 { 389 struct snd_als300 *chip = snd_pcm_substream_chip(substream); 390 struct snd_als300_substream_data *data; 391 392 data = substream->runtime->private_data; 393 kfree(data); 394 chip->playback_substream = NULL; 395 snd_pcm_lib_free_pages(substream); 396 return 0; 397 } 398 399 static int snd_als300_capture_open(struct snd_pcm_substream *substream) 400 { 401 struct snd_als300 *chip = snd_pcm_substream_chip(substream); 402 struct snd_pcm_runtime *runtime = substream->runtime; 403 struct snd_als300_substream_data *data = kzalloc(sizeof(*data), 404 GFP_KERNEL); 405 406 if (!data) 407 return -ENOMEM; 408 chip->capture_substream = substream; 409 runtime->hw = snd_als300_capture_hw; 410 runtime->private_data = data; 411 data->control_register = RECORD_CONTROL; 412 data->block_counter_register = RECORD_BLOCK_COUNTER; 413 return 0; 414 } 415 416 static int snd_als300_capture_close(struct snd_pcm_substream *substream) 417 { 418 struct snd_als300 *chip = snd_pcm_substream_chip(substream); 419 struct snd_als300_substream_data *data; 420 421 data = substream->runtime->private_data; 422 kfree(data); 423 chip->capture_substream = NULL; 424 snd_pcm_lib_free_pages(substream); 425 return 0; 426 } 427 428 static int snd_als300_pcm_hw_params(struct snd_pcm_substream *substream, 429 struct snd_pcm_hw_params *hw_params) 430 { 431 return snd_pcm_lib_malloc_pages(substream, 432 params_buffer_bytes(hw_params)); 433 } 434 435 static int snd_als300_pcm_hw_free(struct snd_pcm_substream *substream) 436 { 437 return snd_pcm_lib_free_pages(substream); 438 } 439 440 static int snd_als300_playback_prepare(struct snd_pcm_substream *substream) 441 { 442 u32 tmp; 443 struct snd_als300 *chip = snd_pcm_substream_chip(substream); 444 struct snd_pcm_runtime *runtime = substream->runtime; 445 unsigned short period_bytes = snd_pcm_lib_period_bytes(substream); 446 unsigned short buffer_bytes = snd_pcm_lib_buffer_bytes(substream); 447 448 spin_lock_irq(&chip->reg_lock); 449 tmp = snd_als300_gcr_read(chip->port, PLAYBACK_CONTROL); 450 tmp &= ~TRANSFER_START; 451 452 snd_als300_dbgplay("Period bytes: %d Buffer bytes %d\n", 453 period_bytes, buffer_bytes); 454 455 /* set block size */ 456 tmp &= 0xffff0000; 457 tmp |= period_bytes - 1; 458 snd_als300_gcr_write(chip->port, PLAYBACK_CONTROL, tmp); 459 460 /* set dma area */ 461 snd_als300_gcr_write(chip->port, PLAYBACK_START, 462 runtime->dma_addr); 463 snd_als300_gcr_write(chip->port, PLAYBACK_END, 464 runtime->dma_addr + buffer_bytes - 1); 465 spin_unlock_irq(&chip->reg_lock); 466 return 0; 467 } 468 469 static int snd_als300_capture_prepare(struct snd_pcm_substream *substream) 470 { 471 u32 tmp; 472 struct snd_als300 *chip = snd_pcm_substream_chip(substream); 473 struct snd_pcm_runtime *runtime = substream->runtime; 474 unsigned short period_bytes = snd_pcm_lib_period_bytes(substream); 475 unsigned short buffer_bytes = snd_pcm_lib_buffer_bytes(substream); 476 477 spin_lock_irq(&chip->reg_lock); 478 tmp = snd_als300_gcr_read(chip->port, RECORD_CONTROL); 479 tmp &= ~TRANSFER_START; 480 481 snd_als300_dbgplay("Period bytes: %d Buffer bytes %d\n", period_bytes, 482 buffer_bytes); 483 484 /* set block size */ 485 tmp &= 0xffff0000; 486 tmp |= period_bytes - 1; 487 488 /* set dma area */ 489 snd_als300_gcr_write(chip->port, RECORD_CONTROL, tmp); 490 snd_als300_gcr_write(chip->port, RECORD_START, 491 runtime->dma_addr); 492 snd_als300_gcr_write(chip->port, RECORD_END, 493 runtime->dma_addr + buffer_bytes - 1); 494 spin_unlock_irq(&chip->reg_lock); 495 return 0; 496 } 497 498 static int snd_als300_trigger(struct snd_pcm_substream *substream, int cmd) 499 { 500 struct snd_als300 *chip = snd_pcm_substream_chip(substream); 501 u32 tmp; 502 struct snd_als300_substream_data *data; 503 unsigned short reg; 504 int ret = 0; 505 506 data = substream->runtime->private_data; 507 reg = data->control_register; 508 509 spin_lock(&chip->reg_lock); 510 switch (cmd) { 511 case SNDRV_PCM_TRIGGER_START: 512 case SNDRV_PCM_TRIGGER_RESUME: 513 tmp = snd_als300_gcr_read(chip->port, reg); 514 data->period_flipflop = 1; 515 snd_als300_gcr_write(chip->port, reg, tmp | TRANSFER_START); 516 snd_als300_dbgplay("TRIGGER START\n"); 517 break; 518 case SNDRV_PCM_TRIGGER_STOP: 519 case SNDRV_PCM_TRIGGER_SUSPEND: 520 tmp = snd_als300_gcr_read(chip->port, reg); 521 snd_als300_gcr_write(chip->port, reg, tmp & ~TRANSFER_START); 522 snd_als300_dbgplay("TRIGGER STOP\n"); 523 break; 524 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 525 tmp = snd_als300_gcr_read(chip->port, reg); 526 snd_als300_gcr_write(chip->port, reg, tmp | FIFO_PAUSE); 527 snd_als300_dbgplay("TRIGGER PAUSE\n"); 528 break; 529 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 530 tmp = snd_als300_gcr_read(chip->port, reg); 531 snd_als300_gcr_write(chip->port, reg, tmp & ~FIFO_PAUSE); 532 snd_als300_dbgplay("TRIGGER RELEASE\n"); 533 break; 534 default: 535 snd_als300_dbgplay("TRIGGER INVALID\n"); 536 ret = -EINVAL; 537 } 538 spin_unlock(&chip->reg_lock); 539 return ret; 540 } 541 542 static snd_pcm_uframes_t snd_als300_pointer(struct snd_pcm_substream *substream) 543 { 544 u16 current_ptr; 545 struct snd_als300 *chip = snd_pcm_substream_chip(substream); 546 struct snd_als300_substream_data *data; 547 unsigned short period_bytes; 548 549 data = substream->runtime->private_data; 550 period_bytes = snd_pcm_lib_period_bytes(substream); 551 552 spin_lock(&chip->reg_lock); 553 current_ptr = (u16) snd_als300_gcr_read(chip->port, 554 data->block_counter_register) + 4; 555 spin_unlock(&chip->reg_lock); 556 if (current_ptr > period_bytes) 557 current_ptr = 0; 558 else 559 current_ptr = period_bytes - current_ptr; 560 561 if (data->period_flipflop == 0) 562 current_ptr += period_bytes; 563 snd_als300_dbgplay("Pointer (bytes): %d\n", current_ptr); 564 return bytes_to_frames(substream->runtime, current_ptr); 565 } 566 567 static struct snd_pcm_ops snd_als300_playback_ops = { 568 .open = snd_als300_playback_open, 569 .close = snd_als300_playback_close, 570 .ioctl = snd_pcm_lib_ioctl, 571 .hw_params = snd_als300_pcm_hw_params, 572 .hw_free = snd_als300_pcm_hw_free, 573 .prepare = snd_als300_playback_prepare, 574 .trigger = snd_als300_trigger, 575 .pointer = snd_als300_pointer, 576 }; 577 578 static struct snd_pcm_ops snd_als300_capture_ops = { 579 .open = snd_als300_capture_open, 580 .close = snd_als300_capture_close, 581 .ioctl = snd_pcm_lib_ioctl, 582 .hw_params = snd_als300_pcm_hw_params, 583 .hw_free = snd_als300_pcm_hw_free, 584 .prepare = snd_als300_capture_prepare, 585 .trigger = snd_als300_trigger, 586 .pointer = snd_als300_pointer, 587 }; 588 589 static int snd_als300_new_pcm(struct snd_als300 *chip) 590 { 591 struct snd_pcm *pcm; 592 int err; 593 594 err = snd_pcm_new(chip->card, "ALS300", 0, 1, 1, &pcm); 595 if (err < 0) 596 return err; 597 pcm->private_data = chip; 598 strcpy(pcm->name, "ALS300"); 599 chip->pcm = pcm; 600 601 /* set operators */ 602 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 603 &snd_als300_playback_ops); 604 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 605 &snd_als300_capture_ops); 606 607 /* pre-allocation of buffers */ 608 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, 609 snd_dma_pci_data(chip->pci), 64*1024, 64*1024); 610 return 0; 611 } 612 613 static void snd_als300_init(struct snd_als300 *chip) 614 { 615 unsigned long flags; 616 u32 tmp; 617 618 spin_lock_irqsave(&chip->reg_lock, flags); 619 chip->revision = (snd_als300_gcr_read(chip->port, MISC_CONTROL) >> 16) 620 & 0x0000000F; 621 /* Setup DRAM */ 622 tmp = snd_als300_gcr_read(chip->port, DRAM_WRITE_CONTROL); 623 snd_als300_gcr_write(chip->port, DRAM_WRITE_CONTROL, 624 (tmp | DRAM_MODE_2) 625 & ~WRITE_TRANS_START); 626 627 /* Enable IRQ output */ 628 snd_als300_set_irq_flag(chip, IRQ_ENABLE); 629 630 /* Unmute hardware devices so their outputs get routed to 631 * the onboard mixer */ 632 tmp = snd_als300_gcr_read(chip->port, MISC_CONTROL); 633 snd_als300_gcr_write(chip->port, MISC_CONTROL, 634 tmp | VMUTE_NORMAL | MMUTE_NORMAL); 635 636 /* Reset volumes */ 637 snd_als300_gcr_write(chip->port, MUS_VOC_VOL, 0); 638 639 /* Make sure playback transfer is stopped */ 640 tmp = snd_als300_gcr_read(chip->port, PLAYBACK_CONTROL); 641 snd_als300_gcr_write(chip->port, PLAYBACK_CONTROL, 642 tmp & ~TRANSFER_START); 643 spin_unlock_irqrestore(&chip->reg_lock, flags); 644 } 645 646 static int snd_als300_create(struct snd_card *card, 647 struct pci_dev *pci, int chip_type, 648 struct snd_als300 **rchip) 649 { 650 struct snd_als300 *chip; 651 void *irq_handler; 652 int err; 653 654 static struct snd_device_ops ops = { 655 .dev_free = snd_als300_dev_free, 656 }; 657 *rchip = NULL; 658 659 if ((err = pci_enable_device(pci)) < 0) 660 return err; 661 662 if (pci_set_dma_mask(pci, DMA_BIT_MASK(28)) < 0 || 663 pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(28)) < 0) { 664 dev_err(card->dev, "error setting 28bit DMA mask\n"); 665 pci_disable_device(pci); 666 return -ENXIO; 667 } 668 pci_set_master(pci); 669 670 chip = kzalloc(sizeof(*chip), GFP_KERNEL); 671 if (chip == NULL) { 672 pci_disable_device(pci); 673 return -ENOMEM; 674 } 675 676 chip->card = card; 677 chip->pci = pci; 678 chip->irq = -1; 679 chip->chip_type = chip_type; 680 spin_lock_init(&chip->reg_lock); 681 682 if ((err = pci_request_regions(pci, "ALS300")) < 0) { 683 kfree(chip); 684 pci_disable_device(pci); 685 return err; 686 } 687 chip->port = pci_resource_start(pci, 0); 688 689 if (chip->chip_type == DEVICE_ALS300_PLUS) 690 irq_handler = snd_als300plus_interrupt; 691 else 692 irq_handler = snd_als300_interrupt; 693 694 if (request_irq(pci->irq, irq_handler, IRQF_SHARED, 695 KBUILD_MODNAME, chip)) { 696 dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq); 697 snd_als300_free(chip); 698 return -EBUSY; 699 } 700 chip->irq = pci->irq; 701 702 703 snd_als300_init(chip); 704 705 err = snd_als300_ac97(chip); 706 if (err < 0) { 707 dev_err(card->dev, "Could not create ac97\n"); 708 snd_als300_free(chip); 709 return err; 710 } 711 712 if ((err = snd_als300_new_pcm(chip)) < 0) { 713 dev_err(card->dev, "Could not create PCM\n"); 714 snd_als300_free(chip); 715 return err; 716 } 717 718 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, 719 chip, &ops)) < 0) { 720 snd_als300_free(chip); 721 return err; 722 } 723 724 *rchip = chip; 725 return 0; 726 } 727 728 #ifdef CONFIG_PM_SLEEP 729 static int snd_als300_suspend(struct device *dev) 730 { 731 struct snd_card *card = dev_get_drvdata(dev); 732 struct snd_als300 *chip = card->private_data; 733 734 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 735 snd_pcm_suspend_all(chip->pcm); 736 snd_ac97_suspend(chip->ac97); 737 return 0; 738 } 739 740 static int snd_als300_resume(struct device *dev) 741 { 742 struct snd_card *card = dev_get_drvdata(dev); 743 struct snd_als300 *chip = card->private_data; 744 745 snd_als300_init(chip); 746 snd_ac97_resume(chip->ac97); 747 748 snd_power_change_state(card, SNDRV_CTL_POWER_D0); 749 return 0; 750 } 751 752 static SIMPLE_DEV_PM_OPS(snd_als300_pm, snd_als300_suspend, snd_als300_resume); 753 #define SND_ALS300_PM_OPS &snd_als300_pm 754 #else 755 #define SND_ALS300_PM_OPS NULL 756 #endif 757 758 static int snd_als300_probe(struct pci_dev *pci, 759 const struct pci_device_id *pci_id) 760 { 761 static int dev; 762 struct snd_card *card; 763 struct snd_als300 *chip; 764 int err, chip_type; 765 766 if (dev >= SNDRV_CARDS) 767 return -ENODEV; 768 if (!enable[dev]) { 769 dev++; 770 return -ENOENT; 771 } 772 773 err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE, 774 0, &card); 775 776 if (err < 0) 777 return err; 778 779 chip_type = pci_id->driver_data; 780 781 if ((err = snd_als300_create(card, pci, chip_type, &chip)) < 0) { 782 snd_card_free(card); 783 return err; 784 } 785 card->private_data = chip; 786 787 strcpy(card->driver, "ALS300"); 788 if (chip->chip_type == DEVICE_ALS300_PLUS) 789 /* don't know much about ALS300+ yet 790 * print revision number for now */ 791 sprintf(card->shortname, "ALS300+ (Rev. %d)", chip->revision); 792 else 793 sprintf(card->shortname, "ALS300 (Rev. %c)", 'A' + 794 chip->revision - 1); 795 sprintf(card->longname, "%s at 0x%lx irq %i", 796 card->shortname, chip->port, chip->irq); 797 798 if ((err = snd_card_register(card)) < 0) { 799 snd_card_free(card); 800 return err; 801 } 802 pci_set_drvdata(pci, card); 803 dev++; 804 return 0; 805 } 806 807 static struct pci_driver als300_driver = { 808 .name = KBUILD_MODNAME, 809 .id_table = snd_als300_ids, 810 .probe = snd_als300_probe, 811 .remove = snd_als300_remove, 812 .driver = { 813 .pm = SND_ALS300_PM_OPS, 814 }, 815 }; 816 817 module_pci_driver(als300_driver); 818