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