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