FILE
atiixp_modem.c
File preview with syntax highlighting.
linux-6.19.14/sound/pci/atiixp_modem.c
1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * ALSA driver for ATI IXP 150/200/250 AC97 modem controllers 4 * 5 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de> 6 */ 7 8#include <linux/io.h> 9#include <linux/delay.h> 10#include <linux/interrupt.h> 11#include <linux/init.h> 12#include <linux/pci.h> 13#include <linux/slab.h> 14#include <linux/module.h> 15#include <linux/mutex.h> 16#include <sound/core.h> 17#include <sound/pcm.h> 18#include <sound/pcm_params.h> 19#include <sound/info.h> 20#include <sound/ac97_codec.h> 21#include <sound/initval.h> 22 23MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>"); 24MODULE_DESCRIPTION("ATI IXP MC97 controller"); 25MODULE_LICENSE("GPL"); 26 27static int index = -2; /* Exclude the first card */ 28static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */ 29static int ac97_clock = 48000; 30 31module_param(index, int, 0444); 32MODULE_PARM_DESC(index, "Index value for ATI IXP controller."); 33module_param(id, charp, 0444); 34MODULE_PARM_DESC(id, "ID string for ATI IXP controller."); 35module_param(ac97_clock, int, 0444); 36MODULE_PARM_DESC(ac97_clock, "AC'97 codec clock (default 48000Hz)."); 37 38/* just for backward compatibility */ 39static bool enable; 40module_param(enable, bool, 0444); 41 42 43/* 44 */ 45 46#define ATI_REG_ISR 0x00 /* interrupt source */ 47#define ATI_REG_ISR_MODEM_IN_XRUN (1U<<0) 48#define ATI_REG_ISR_MODEM_IN_STATUS (1U<<1) 49#define ATI_REG_ISR_MODEM_OUT1_XRUN (1U<<2) 50#define ATI_REG_ISR_MODEM_OUT1_STATUS (1U<<3) 51#define ATI_REG_ISR_MODEM_OUT2_XRUN (1U<<4) 52#define ATI_REG_ISR_MODEM_OUT2_STATUS (1U<<5) 53#define ATI_REG_ISR_MODEM_OUT3_XRUN (1U<<6) 54#define ATI_REG_ISR_MODEM_OUT3_STATUS (1U<<7) 55#define ATI_REG_ISR_PHYS_INTR (1U<<8) 56#define ATI_REG_ISR_PHYS_MISMATCH (1U<<9) 57#define ATI_REG_ISR_CODEC0_NOT_READY (1U<<10) 58#define ATI_REG_ISR_CODEC1_NOT_READY (1U<<11) 59#define ATI_REG_ISR_CODEC2_NOT_READY (1U<<12) 60#define ATI_REG_ISR_NEW_FRAME (1U<<13) 61#define ATI_REG_ISR_MODEM_GPIO_DATA (1U<<14) 62 63#define ATI_REG_IER 0x04 /* interrupt enable */ 64#define ATI_REG_IER_MODEM_IN_XRUN_EN (1U<<0) 65#define ATI_REG_IER_MODEM_STATUS_EN (1U<<1) 66#define ATI_REG_IER_MODEM_OUT1_XRUN_EN (1U<<2) 67#define ATI_REG_IER_MODEM_OUT2_XRUN_EN (1U<<4) 68#define ATI_REG_IER_MODEM_OUT3_XRUN_EN (1U<<6) 69#define ATI_REG_IER_PHYS_INTR_EN (1U<<8) 70#define ATI_REG_IER_PHYS_MISMATCH_EN (1U<<9) 71#define ATI_REG_IER_CODEC0_INTR_EN (1U<<10) 72#define ATI_REG_IER_CODEC1_INTR_EN (1U<<11) 73#define ATI_REG_IER_CODEC2_INTR_EN (1U<<12) 74#define ATI_REG_IER_NEW_FRAME_EN (1U<<13) /* (RO */ 75#define ATI_REG_IER_MODEM_GPIO_DATA_EN (1U<<14) /* (WO) modem is running */ 76#define ATI_REG_IER_MODEM_SET_BUS_BUSY (1U<<15) 77 78#define ATI_REG_CMD 0x08 /* command */ 79#define ATI_REG_CMD_POWERDOWN (1U<<0) 80#define ATI_REG_CMD_MODEM_RECEIVE_EN (1U<<1) /* modem only */ 81#define ATI_REG_CMD_MODEM_SEND1_EN (1U<<2) /* modem only */ 82#define ATI_REG_CMD_MODEM_SEND2_EN (1U<<3) /* modem only */ 83#define ATI_REG_CMD_MODEM_SEND3_EN (1U<<4) /* modem only */ 84#define ATI_REG_CMD_MODEM_STATUS_MEM (1U<<5) /* modem only */ 85#define ATI_REG_CMD_MODEM_IN_DMA_EN (1U<<8) /* modem only */ 86#define ATI_REG_CMD_MODEM_OUT_DMA1_EN (1U<<9) /* modem only */ 87#define ATI_REG_CMD_MODEM_OUT_DMA2_EN (1U<<10) /* modem only */ 88#define ATI_REG_CMD_MODEM_OUT_DMA3_EN (1U<<11) /* modem only */ 89#define ATI_REG_CMD_AUDIO_PRESENT (1U<<20) 90#define ATI_REG_CMD_MODEM_GPIO_THRU_DMA (1U<<22) /* modem only */ 91#define ATI_REG_CMD_LOOPBACK_EN (1U<<23) 92#define ATI_REG_CMD_PACKED_DIS (1U<<24) 93#define ATI_REG_CMD_BURST_EN (1U<<25) 94#define ATI_REG_CMD_PANIC_EN (1U<<26) 95#define ATI_REG_CMD_MODEM_PRESENT (1U<<27) 96#define ATI_REG_CMD_ACLINK_ACTIVE (1U<<28) 97#define ATI_REG_CMD_AC_SOFT_RESET (1U<<29) 98#define ATI_REG_CMD_AC_SYNC (1U<<30) 99#define ATI_REG_CMD_AC_RESET (1U<<31) 100 101#define ATI_REG_PHYS_OUT_ADDR 0x0c 102#define ATI_REG_PHYS_OUT_CODEC_MASK (3U<<0) 103#define ATI_REG_PHYS_OUT_RW (1U<<2) 104#define ATI_REG_PHYS_OUT_ADDR_EN (1U<<8) 105#define ATI_REG_PHYS_OUT_ADDR_SHIFT 9 106#define ATI_REG_PHYS_OUT_DATA_SHIFT 16 107 108#define ATI_REG_PHYS_IN_ADDR 0x10 109#define ATI_REG_PHYS_IN_READ_FLAG (1U<<8) 110#define ATI_REG_PHYS_IN_ADDR_SHIFT 9 111#define ATI_REG_PHYS_IN_DATA_SHIFT 16 112 113#define ATI_REG_SLOTREQ 0x14 114 115#define ATI_REG_COUNTER 0x18 116#define ATI_REG_COUNTER_SLOT (3U<<0) /* slot # */ 117#define ATI_REG_COUNTER_BITCLOCK (31U<<8) 118 119#define ATI_REG_IN_FIFO_THRESHOLD 0x1c 120 121#define ATI_REG_MODEM_IN_DMA_LINKPTR 0x20 122#define ATI_REG_MODEM_IN_DMA_DT_START 0x24 /* RO */ 123#define ATI_REG_MODEM_IN_DMA_DT_NEXT 0x28 /* RO */ 124#define ATI_REG_MODEM_IN_DMA_DT_CUR 0x2c /* RO */ 125#define ATI_REG_MODEM_IN_DMA_DT_SIZE 0x30 126#define ATI_REG_MODEM_OUT_FIFO 0x34 /* output threshold */ 127#define ATI_REG_MODEM_OUT1_DMA_THRESHOLD_MASK (0xf<<16) 128#define ATI_REG_MODEM_OUT1_DMA_THRESHOLD_SHIFT 16 129#define ATI_REG_MODEM_OUT_DMA1_LINKPTR 0x38 130#define ATI_REG_MODEM_OUT_DMA2_LINKPTR 0x3c 131#define ATI_REG_MODEM_OUT_DMA3_LINKPTR 0x40 132#define ATI_REG_MODEM_OUT_DMA1_DT_START 0x44 133#define ATI_REG_MODEM_OUT_DMA1_DT_NEXT 0x48 134#define ATI_REG_MODEM_OUT_DMA1_DT_CUR 0x4c 135#define ATI_REG_MODEM_OUT_DMA2_DT_START 0x50 136#define ATI_REG_MODEM_OUT_DMA2_DT_NEXT 0x54 137#define ATI_REG_MODEM_OUT_DMA2_DT_CUR 0x58 138#define ATI_REG_MODEM_OUT_DMA3_DT_START 0x5c 139#define ATI_REG_MODEM_OUT_DMA3_DT_NEXT 0x60 140#define ATI_REG_MODEM_OUT_DMA3_DT_CUR 0x64 141#define ATI_REG_MODEM_OUT_DMA12_DT_SIZE 0x68 142#define ATI_REG_MODEM_OUT_DMA3_DT_SIZE 0x6c 143#define ATI_REG_MODEM_OUT_FIFO_USED 0x70 144#define ATI_REG_MODEM_OUT_GPIO 0x74 145#define ATI_REG_MODEM_OUT_GPIO_EN 1 146#define ATI_REG_MODEM_OUT_GPIO_DATA_SHIFT 5 147#define ATI_REG_MODEM_IN_GPIO 0x78 148 149#define ATI_REG_MODEM_MIRROR 0x7c 150#define ATI_REG_AUDIO_MIRROR 0x80 151 152#define ATI_REG_MODEM_FIFO_FLUSH 0x88 153#define ATI_REG_MODEM_FIFO_OUT1_FLUSH (1U<<0) 154#define ATI_REG_MODEM_FIFO_OUT2_FLUSH (1U<<1) 155#define ATI_REG_MODEM_FIFO_OUT3_FLUSH (1U<<2) 156#define ATI_REG_MODEM_FIFO_IN_FLUSH (1U<<3) 157 158/* LINKPTR */ 159#define ATI_REG_LINKPTR_EN (1U<<0) 160 161#define ATI_MAX_DESCRIPTORS 256 /* max number of descriptor packets */ 162 163 164struct atiixp_modem; 165 166/* 167 * DMA packate descriptor 168 */ 169 170struct atiixp_dma_desc { 171 __le32 addr; /* DMA buffer address */ 172 u16 status; /* status bits */ 173 u16 size; /* size of the packet in dwords */ 174 __le32 next; /* address of the next packet descriptor */ 175}; 176 177/* 178 * stream enum 179 */ 180enum { ATI_DMA_PLAYBACK, ATI_DMA_CAPTURE, NUM_ATI_DMAS }; /* DMAs */ 181enum { ATI_PCM_OUT, ATI_PCM_IN, NUM_ATI_PCMS }; /* AC97 pcm slots */ 182enum { ATI_PCMDEV_ANALOG, NUM_ATI_PCMDEVS }; /* pcm devices */ 183 184#define NUM_ATI_CODECS 3 185 186 187/* 188 * constants and callbacks for each DMA type 189 */ 190struct atiixp_dma_ops { 191 int type; /* ATI_DMA_XXX */ 192 unsigned int llp_offset; /* LINKPTR offset */ 193 unsigned int dt_cur; /* DT_CUR offset */ 194 /* called from open callback */ 195 void (*enable_dma)(struct atiixp_modem *chip, int on); 196 /* called from trigger (START/STOP) */ 197 void (*enable_transfer)(struct atiixp_modem *chip, int on); 198 /* called from trigger (STOP only) */ 199 void (*flush_dma)(struct atiixp_modem *chip); 200}; 201 202/* 203 * DMA stream 204 */ 205struct atiixp_dma { 206 const struct atiixp_dma_ops *ops; 207 struct snd_dma_buffer desc_buf; 208 struct snd_pcm_substream *substream; /* assigned PCM substream */ 209 unsigned int buf_addr, buf_bytes; /* DMA buffer address, bytes */ 210 unsigned int period_bytes, periods; 211 int opened; 212 int running; 213 int pcm_open_flag; 214 int ac97_pcm_type; /* index # of ac97_pcm to access, -1 = not used */ 215}; 216 217/* 218 * ATI IXP chip 219 */ 220struct atiixp_modem { 221 struct snd_card *card; 222 struct pci_dev *pci; 223 224 struct resource *res; /* memory i/o */ 225 unsigned long addr; 226 void __iomem *remap_addr; 227 int irq; 228 229 struct snd_ac97_bus *ac97_bus; 230 struct snd_ac97 *ac97[NUM_ATI_CODECS]; 231 232 spinlock_t reg_lock; 233 234 struct atiixp_dma dmas[NUM_ATI_DMAS]; 235 struct ac97_pcm *pcms[NUM_ATI_PCMS]; 236 struct snd_pcm *pcmdevs[NUM_ATI_PCMDEVS]; 237 238 int max_channels; /* max. channels for PCM out */ 239 240 unsigned int codec_not_ready_bits; /* for codec detection */ 241 242 int spdif_over_aclink; /* passed from the module option */ 243 struct mutex open_mutex; /* playback open mutex */ 244}; 245 246 247/* 248 */ 249static const struct pci_device_id snd_atiixp_ids[] = { 250 { PCI_VDEVICE(ATI, 0x434d), 0 }, /* SB200 */ 251 { PCI_VDEVICE(ATI, 0x4378), 0 }, /* SB400 */ 252 { 0, } 253}; 254 255MODULE_DEVICE_TABLE(pci, snd_atiixp_ids); 256 257 258/* 259 * lowlevel functions 260 */ 261 262/* 263 * update the bits of the given register. 264 * return 1 if the bits changed. 265 */ 266static int snd_atiixp_update_bits(struct atiixp_modem *chip, unsigned int reg, 267 unsigned int mask, unsigned int value) 268{ 269 void __iomem *addr = chip->remap_addr + reg; 270 unsigned int data, old_data; 271 old_data = data = readl(addr); 272 data &= ~mask; 273 data |= value; 274 if (old_data == data) 275 return 0; 276 writel(data, addr); 277 return 1; 278} 279 280/* 281 * macros for easy use 282 */ 283#define atiixp_write(chip,reg,value) \ 284 writel(value, chip->remap_addr + ATI_REG_##reg) 285#define atiixp_read(chip,reg) \ 286 readl(chip->remap_addr + ATI_REG_##reg) 287#define atiixp_update(chip,reg,mask,val) \ 288 snd_atiixp_update_bits(chip, ATI_REG_##reg, mask, val) 289 290/* 291 * handling DMA packets 292 * 293 * we allocate a linear buffer for the DMA, and split it to each packet. 294 * in a future version, a scatter-gather buffer should be implemented. 295 */ 296 297#define ATI_DESC_LIST_SIZE \ 298 PAGE_ALIGN(ATI_MAX_DESCRIPTORS * sizeof(struct atiixp_dma_desc)) 299 300/* 301 * build packets ring for the given buffer size. 302 * 303 * IXP handles the buffer descriptors, which are connected as a linked 304 * list. although we can change the list dynamically, in this version, 305 * a static RING of buffer descriptors is used. 306 * 307 * the ring is built in this function, and is set up to the hardware. 308 */ 309static int atiixp_build_dma_packets(struct atiixp_modem *chip, 310 struct atiixp_dma *dma, 311 struct snd_pcm_substream *substream, 312 unsigned int periods, 313 unsigned int period_bytes) 314{ 315 unsigned int i; 316 u32 addr, desc_addr; 317 318 if (periods > ATI_MAX_DESCRIPTORS) 319 return -ENOMEM; 320 321 if (dma->desc_buf.area == NULL) { 322 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev, 323 ATI_DESC_LIST_SIZE, &dma->desc_buf) < 0) 324 return -ENOMEM; 325 dma->period_bytes = dma->periods = 0; /* clear */ 326 } 327 328 if (dma->periods == periods && dma->period_bytes == period_bytes) 329 return 0; 330 331 /* reset DMA before changing the descriptor table */ 332 scoped_guard(spinlock_irqsave, &chip->reg_lock) { 333 writel(0, chip->remap_addr + dma->ops->llp_offset); 334 dma->ops->enable_dma(chip, 0); 335 dma->ops->enable_dma(chip, 1); 336 } 337 338 /* fill the entries */ 339 addr = (u32)substream->runtime->dma_addr; 340 desc_addr = (u32)dma->desc_buf.addr; 341 for (i = 0; i < periods; i++) { 342 struct atiixp_dma_desc *desc; 343 desc = &((struct atiixp_dma_desc *)dma->desc_buf.area)[i]; 344 desc->addr = cpu_to_le32(addr); 345 desc->status = 0; 346 desc->size = period_bytes >> 2; /* in dwords */ 347 desc_addr += sizeof(struct atiixp_dma_desc); 348 if (i == periods - 1) 349 desc->next = cpu_to_le32((u32)dma->desc_buf.addr); 350 else 351 desc->next = cpu_to_le32(desc_addr); 352 addr += period_bytes; 353 } 354 355 writel((u32)dma->desc_buf.addr | ATI_REG_LINKPTR_EN, 356 chip->remap_addr + dma->ops->llp_offset); 357 358 dma->period_bytes = period_bytes; 359 dma->periods = periods; 360 361 return 0; 362} 363 364/* 365 * remove the ring buffer and release it if assigned 366 */ 367static void atiixp_clear_dma_packets(struct atiixp_modem *chip, 368 struct atiixp_dma *dma, 369 struct snd_pcm_substream *substream) 370{ 371 if (dma->desc_buf.area) { 372 writel(0, chip->remap_addr + dma->ops->llp_offset); 373 snd_dma_free_pages(&dma->desc_buf); 374 dma->desc_buf.area = NULL; 375 } 376} 377 378/* 379 * AC97 interface 380 */ 381static int snd_atiixp_acquire_codec(struct atiixp_modem *chip) 382{ 383 int timeout = 1000; 384 385 while (atiixp_read(chip, PHYS_OUT_ADDR) & ATI_REG_PHYS_OUT_ADDR_EN) { 386 if (! timeout--) { 387 dev_warn(chip->card->dev, "codec acquire timeout\n"); 388 return -EBUSY; 389 } 390 udelay(1); 391 } 392 return 0; 393} 394 395static unsigned short snd_atiixp_codec_read(struct atiixp_modem *chip, 396 unsigned short codec, 397 unsigned short reg) 398{ 399 unsigned int data; 400 int timeout; 401 402 if (snd_atiixp_acquire_codec(chip) < 0) 403 return 0xffff; 404 data = (reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) | 405 ATI_REG_PHYS_OUT_ADDR_EN | 406 ATI_REG_PHYS_OUT_RW | 407 codec; 408 atiixp_write(chip, PHYS_OUT_ADDR, data); 409 if (snd_atiixp_acquire_codec(chip) < 0) 410 return 0xffff; 411 timeout = 1000; 412 do { 413 data = atiixp_read(chip, PHYS_IN_ADDR); 414 if (data & ATI_REG_PHYS_IN_READ_FLAG) 415 return data >> ATI_REG_PHYS_IN_DATA_SHIFT; 416 udelay(1); 417 } while (--timeout); 418 /* time out may happen during reset */ 419 if (reg < 0x7c) 420 dev_warn(chip->card->dev, "codec read timeout (reg %x)\n", reg); 421 return 0xffff; 422} 423 424 425static void snd_atiixp_codec_write(struct atiixp_modem *chip, 426 unsigned short codec, 427 unsigned short reg, unsigned short val) 428{ 429 unsigned int data; 430 431 if (snd_atiixp_acquire_codec(chip) < 0) 432 return; 433 data = ((unsigned int)val << ATI_REG_PHYS_OUT_DATA_SHIFT) | 434 ((unsigned int)reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) | 435 ATI_REG_PHYS_OUT_ADDR_EN | codec; 436 atiixp_write(chip, PHYS_OUT_ADDR, data); 437} 438 439 440static unsigned short snd_atiixp_ac97_read(struct snd_ac97 *ac97, 441 unsigned short reg) 442{ 443 struct atiixp_modem *chip = ac97->private_data; 444 return snd_atiixp_codec_read(chip, ac97->num, reg); 445 446} 447 448static void snd_atiixp_ac97_write(struct snd_ac97 *ac97, unsigned short reg, 449 unsigned short val) 450{ 451 struct atiixp_modem *chip = ac97->private_data; 452 if (reg == AC97_GPIO_STATUS) { 453 atiixp_write(chip, MODEM_OUT_GPIO, 454 (val << ATI_REG_MODEM_OUT_GPIO_DATA_SHIFT) | ATI_REG_MODEM_OUT_GPIO_EN); 455 return; 456 } 457 snd_atiixp_codec_write(chip, ac97->num, reg, val); 458} 459 460/* 461 * reset AC link 462 */ 463static int snd_atiixp_aclink_reset(struct atiixp_modem *chip) 464{ 465 int timeout; 466 467 /* reset powerdoewn */ 468 if (atiixp_update(chip, CMD, ATI_REG_CMD_POWERDOWN, 0)) 469 udelay(10); 470 471 /* perform a software reset */ 472 atiixp_update(chip, CMD, ATI_REG_CMD_AC_SOFT_RESET, ATI_REG_CMD_AC_SOFT_RESET); 473 atiixp_read(chip, CMD); 474 udelay(10); 475 atiixp_update(chip, CMD, ATI_REG_CMD_AC_SOFT_RESET, 0); 476 477 timeout = 10; 478 while (! (atiixp_read(chip, CMD) & ATI_REG_CMD_ACLINK_ACTIVE)) { 479 /* do a hard reset */ 480 atiixp_update(chip, CMD, ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET, 481 ATI_REG_CMD_AC_SYNC); 482 atiixp_read(chip, CMD); 483 msleep(1); 484 atiixp_update(chip, CMD, ATI_REG_CMD_AC_RESET, ATI_REG_CMD_AC_RESET); 485 if (!--timeout) { 486 dev_err(chip->card->dev, "codec reset timeout\n"); 487 break; 488 } 489 } 490 491 /* deassert RESET and assert SYNC to make sure */ 492 atiixp_update(chip, CMD, ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET, 493 ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET); 494 495 return 0; 496} 497 498static int snd_atiixp_aclink_down(struct atiixp_modem *chip) 499{ 500 // if (atiixp_read(chip, MODEM_MIRROR) & 0x1) /* modem running, too? */ 501 // return -EBUSY; 502 atiixp_update(chip, CMD, 503 ATI_REG_CMD_POWERDOWN | ATI_REG_CMD_AC_RESET, 504 ATI_REG_CMD_POWERDOWN); 505 return 0; 506} 507 508/* 509 * auto-detection of codecs 510 * 511 * the IXP chip can generate interrupts for the non-existing codecs. 512 * NEW_FRAME interrupt is used to make sure that the interrupt is generated 513 * even if all three codecs are connected. 514 */ 515 516#define ALL_CODEC_NOT_READY \ 517 (ATI_REG_ISR_CODEC0_NOT_READY |\ 518 ATI_REG_ISR_CODEC1_NOT_READY |\ 519 ATI_REG_ISR_CODEC2_NOT_READY) 520#define CODEC_CHECK_BITS (ALL_CODEC_NOT_READY|ATI_REG_ISR_NEW_FRAME) 521 522static int snd_atiixp_codec_detect(struct atiixp_modem *chip) 523{ 524 int timeout; 525 526 chip->codec_not_ready_bits = 0; 527 atiixp_write(chip, IER, CODEC_CHECK_BITS); 528 /* wait for the interrupts */ 529 timeout = 50; 530 while (timeout-- > 0) { 531 msleep(1); 532 if (chip->codec_not_ready_bits) 533 break; 534 } 535 atiixp_write(chip, IER, 0); /* disable irqs */ 536 537 if ((chip->codec_not_ready_bits & ALL_CODEC_NOT_READY) == ALL_CODEC_NOT_READY) { 538 dev_err(chip->card->dev, "no codec detected!\n"); 539 return -ENXIO; 540 } 541 return 0; 542} 543 544 545/* 546 * enable DMA and irqs 547 */ 548static int snd_atiixp_chip_start(struct atiixp_modem *chip) 549{ 550 unsigned int reg; 551 552 /* set up spdif, enable burst mode */ 553 reg = atiixp_read(chip, CMD); 554 reg |= ATI_REG_CMD_BURST_EN; 555 if(!(reg & ATI_REG_CMD_MODEM_PRESENT)) 556 reg |= ATI_REG_CMD_MODEM_PRESENT; 557 atiixp_write(chip, CMD, reg); 558 559 /* clear all interrupt source */ 560 atiixp_write(chip, ISR, 0xffffffff); 561 /* enable irqs */ 562 atiixp_write(chip, IER, 563 ATI_REG_IER_MODEM_STATUS_EN | 564 ATI_REG_IER_MODEM_IN_XRUN_EN | 565 ATI_REG_IER_MODEM_OUT1_XRUN_EN); 566 return 0; 567} 568 569 570/* 571 * disable DMA and IRQs 572 */ 573static int snd_atiixp_chip_stop(struct atiixp_modem *chip) 574{ 575 /* clear interrupt source */ 576 atiixp_write(chip, ISR, atiixp_read(chip, ISR)); 577 /* disable irqs */ 578 atiixp_write(chip, IER, 0); 579 return 0; 580} 581 582 583/* 584 * PCM section 585 */ 586 587/* 588 * pointer callback simplly reads XXX_DMA_DT_CUR register as the current 589 * position. when SG-buffer is implemented, the offset must be calculated 590 * correctly... 591 */ 592static snd_pcm_uframes_t snd_atiixp_pcm_pointer(struct snd_pcm_substream *substream) 593{ 594 struct atiixp_modem *chip = snd_pcm_substream_chip(substream); 595 struct snd_pcm_runtime *runtime = substream->runtime; 596 struct atiixp_dma *dma = runtime->private_data; 597 unsigned int curptr; 598 int timeout = 1000; 599 600 while (timeout--) { 601 curptr = readl(chip->remap_addr + dma->ops->dt_cur); 602 if (curptr < dma->buf_addr) 603 continue; 604 curptr -= dma->buf_addr; 605 if (curptr >= dma->buf_bytes) 606 continue; 607 return bytes_to_frames(runtime, curptr); 608 } 609 dev_dbg(chip->card->dev, "invalid DMA pointer read 0x%x (buf=%x)\n", 610 readl(chip->remap_addr + dma->ops->dt_cur), dma->buf_addr); 611 return 0; 612} 613 614/* 615 * XRUN detected, and stop the PCM substream 616 */ 617static void snd_atiixp_xrun_dma(struct atiixp_modem *chip, 618 struct atiixp_dma *dma) 619{ 620 if (! dma->substream || ! dma->running) 621 return; 622 dev_dbg(chip->card->dev, "XRUN detected (DMA %d)\n", dma->ops->type); 623 snd_pcm_stop_xrun(dma->substream); 624} 625 626/* 627 * the period ack. update the substream. 628 */ 629static void snd_atiixp_update_dma(struct atiixp_modem *chip, 630 struct atiixp_dma *dma) 631{ 632 if (! dma->substream || ! dma->running) 633 return; 634 snd_pcm_period_elapsed(dma->substream); 635} 636 637/* set BUS_BUSY interrupt bit if any DMA is running */ 638/* call with spinlock held */ 639static void snd_atiixp_check_bus_busy(struct atiixp_modem *chip) 640{ 641 unsigned int bus_busy; 642 if (atiixp_read(chip, CMD) & (ATI_REG_CMD_MODEM_SEND1_EN | 643 ATI_REG_CMD_MODEM_RECEIVE_EN)) 644 bus_busy = ATI_REG_IER_MODEM_SET_BUS_BUSY; 645 else 646 bus_busy = 0; 647 atiixp_update(chip, IER, ATI_REG_IER_MODEM_SET_BUS_BUSY, bus_busy); 648} 649 650/* common trigger callback 651 * calling the lowlevel callbacks in it 652 */ 653static int snd_atiixp_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 654{ 655 struct atiixp_modem *chip = snd_pcm_substream_chip(substream); 656 struct atiixp_dma *dma = substream->runtime->private_data; 657 int err = 0; 658 659 if (snd_BUG_ON(!dma->ops->enable_transfer || 660 !dma->ops->flush_dma)) 661 return -EINVAL; 662 663 guard(spinlock)(&chip->reg_lock); 664 switch(cmd) { 665 case SNDRV_PCM_TRIGGER_START: 666 dma->ops->enable_transfer(chip, 1); 667 dma->running = 1; 668 break; 669 case SNDRV_PCM_TRIGGER_STOP: 670 dma->ops->enable_transfer(chip, 0); 671 dma->running = 0; 672 break; 673 default: 674 err = -EINVAL; 675 break; 676 } 677 if (! err) { 678 snd_atiixp_check_bus_busy(chip); 679 if (cmd == SNDRV_PCM_TRIGGER_STOP) { 680 dma->ops->flush_dma(chip); 681 snd_atiixp_check_bus_busy(chip); 682 } 683 } 684 return err; 685} 686 687 688/* 689 * lowlevel callbacks for each DMA type 690 * 691 * every callback is supposed to be called in chip->reg_lock spinlock 692 */ 693 694/* flush FIFO of analog OUT DMA */ 695static void atiixp_out_flush_dma(struct atiixp_modem *chip) 696{ 697 atiixp_write(chip, MODEM_FIFO_FLUSH, ATI_REG_MODEM_FIFO_OUT1_FLUSH); 698} 699 700/* enable/disable analog OUT DMA */ 701static void atiixp_out_enable_dma(struct atiixp_modem *chip, int on) 702{ 703 unsigned int data; 704 data = atiixp_read(chip, CMD); 705 if (on) { 706 if (data & ATI_REG_CMD_MODEM_OUT_DMA1_EN) 707 return; 708 atiixp_out_flush_dma(chip); 709 data |= ATI_REG_CMD_MODEM_OUT_DMA1_EN; 710 } else 711 data &= ~ATI_REG_CMD_MODEM_OUT_DMA1_EN; 712 atiixp_write(chip, CMD, data); 713} 714 715/* start/stop transfer over OUT DMA */ 716static void atiixp_out_enable_transfer(struct atiixp_modem *chip, int on) 717{ 718 atiixp_update(chip, CMD, ATI_REG_CMD_MODEM_SEND1_EN, 719 on ? ATI_REG_CMD_MODEM_SEND1_EN : 0); 720} 721 722/* enable/disable analog IN DMA */ 723static void atiixp_in_enable_dma(struct atiixp_modem *chip, int on) 724{ 725 atiixp_update(chip, CMD, ATI_REG_CMD_MODEM_IN_DMA_EN, 726 on ? ATI_REG_CMD_MODEM_IN_DMA_EN : 0); 727} 728 729/* start/stop analog IN DMA */ 730static void atiixp_in_enable_transfer(struct atiixp_modem *chip, int on) 731{ 732 if (on) { 733 unsigned int data = atiixp_read(chip, CMD); 734 if (! (data & ATI_REG_CMD_MODEM_RECEIVE_EN)) { 735 data |= ATI_REG_CMD_MODEM_RECEIVE_EN; 736 atiixp_write(chip, CMD, data); 737 } 738 } else 739 atiixp_update(chip, CMD, ATI_REG_CMD_MODEM_RECEIVE_EN, 0); 740} 741 742/* flush FIFO of analog IN DMA */ 743static void atiixp_in_flush_dma(struct atiixp_modem *chip) 744{ 745 atiixp_write(chip, MODEM_FIFO_FLUSH, ATI_REG_MODEM_FIFO_IN_FLUSH); 746} 747 748/* set up slots and formats for analog OUT */ 749static int snd_atiixp_playback_prepare(struct snd_pcm_substream *substream) 750{ 751 struct atiixp_modem *chip = snd_pcm_substream_chip(substream); 752 unsigned int data; 753 754 guard(spinlock_irq)(&chip->reg_lock); 755 /* set output threshold */ 756 data = atiixp_read(chip, MODEM_OUT_FIFO); 757 data &= ~ATI_REG_MODEM_OUT1_DMA_THRESHOLD_MASK; 758 data |= 0x04 << ATI_REG_MODEM_OUT1_DMA_THRESHOLD_SHIFT; 759 atiixp_write(chip, MODEM_OUT_FIFO, data); 760 return 0; 761} 762 763/* set up slots and formats for analog IN */ 764static int snd_atiixp_capture_prepare(struct snd_pcm_substream *substream) 765{ 766 return 0; 767} 768 769/* 770 * hw_params - allocate the buffer and set up buffer descriptors 771 */ 772static int snd_atiixp_pcm_hw_params(struct snd_pcm_substream *substream, 773 struct snd_pcm_hw_params *hw_params) 774{ 775 struct atiixp_modem *chip = snd_pcm_substream_chip(substream); 776 struct atiixp_dma *dma = substream->runtime->private_data; 777 int err; 778 int i; 779 780 dma->buf_addr = substream->runtime->dma_addr; 781 dma->buf_bytes = params_buffer_bytes(hw_params); 782 783 err = atiixp_build_dma_packets(chip, dma, substream, 784 params_periods(hw_params), 785 params_period_bytes(hw_params)); 786 if (err < 0) 787 return err; 788 789 /* set up modem rate */ 790 for (i = 0; i < NUM_ATI_CODECS; i++) { 791 if (! chip->ac97[i]) 792 continue; 793 snd_ac97_write(chip->ac97[i], AC97_LINE1_RATE, params_rate(hw_params)); 794 snd_ac97_write(chip->ac97[i], AC97_LINE1_LEVEL, 0); 795 } 796 797 return err; 798} 799 800static int snd_atiixp_pcm_hw_free(struct snd_pcm_substream *substream) 801{ 802 struct atiixp_modem *chip = snd_pcm_substream_chip(substream); 803 struct atiixp_dma *dma = substream->runtime->private_data; 804 805 atiixp_clear_dma_packets(chip, dma, substream); 806 return 0; 807} 808 809 810/* 811 * pcm hardware definition, identical for all DMA types 812 */ 813static const struct snd_pcm_hardware snd_atiixp_pcm_hw = 814{ 815 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 816 SNDRV_PCM_INFO_BLOCK_TRANSFER | 817 SNDRV_PCM_INFO_MMAP_VALID), 818 .formats = SNDRV_PCM_FMTBIT_S16_LE, 819 .rates = (SNDRV_PCM_RATE_8000 | 820 SNDRV_PCM_RATE_16000 | 821 SNDRV_PCM_RATE_KNOT), 822 .rate_min = 8000, 823 .rate_max = 16000, 824 .channels_min = 2, 825 .channels_max = 2, 826 .buffer_bytes_max = 256 * 1024, 827 .period_bytes_min = 32, 828 .period_bytes_max = 128 * 1024, 829 .periods_min = 2, 830 .periods_max = ATI_MAX_DESCRIPTORS, 831}; 832 833static int snd_atiixp_pcm_open(struct snd_pcm_substream *substream, 834 struct atiixp_dma *dma, int pcm_type) 835{ 836 struct atiixp_modem *chip = snd_pcm_substream_chip(substream); 837 struct snd_pcm_runtime *runtime = substream->runtime; 838 int err; 839 static const unsigned int rates[] = { 8000, 9600, 12000, 16000 }; 840 static const struct snd_pcm_hw_constraint_list hw_constraints_rates = { 841 .count = ARRAY_SIZE(rates), 842 .list = rates, 843 .mask = 0, 844 }; 845 846 if (snd_BUG_ON(!dma->ops || !dma->ops->enable_dma)) 847 return -EINVAL; 848 849 if (dma->opened) 850 return -EBUSY; 851 dma->substream = substream; 852 runtime->hw = snd_atiixp_pcm_hw; 853 dma->ac97_pcm_type = pcm_type; 854 err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 855 &hw_constraints_rates); 856 if (err < 0) 857 return err; 858 err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); 859 if (err < 0) 860 return err; 861 runtime->private_data = dma; 862 863 /* enable DMA bits */ 864 scoped_guard(spinlock_irq, &chip->reg_lock) { 865 dma->ops->enable_dma(chip, 1); 866 } 867 dma->opened = 1; 868 869 return 0; 870} 871 872static int snd_atiixp_pcm_close(struct snd_pcm_substream *substream, 873 struct atiixp_dma *dma) 874{ 875 struct atiixp_modem *chip = snd_pcm_substream_chip(substream); 876 /* disable DMA bits */ 877 if (snd_BUG_ON(!dma->ops || !dma->ops->enable_dma)) 878 return -EINVAL; 879 scoped_guard(spinlock_irq, &chip->reg_lock) { 880 dma->ops->enable_dma(chip, 0); 881 } 882 dma->substream = NULL; 883 dma->opened = 0; 884 return 0; 885} 886 887/* 888 */ 889static int snd_atiixp_playback_open(struct snd_pcm_substream *substream) 890{ 891 struct atiixp_modem *chip = snd_pcm_substream_chip(substream); 892 893 guard(mutex)(&chip->open_mutex); 894 return snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_PLAYBACK], 0); 895} 896 897static int snd_atiixp_playback_close(struct snd_pcm_substream *substream) 898{ 899 struct atiixp_modem *chip = snd_pcm_substream_chip(substream); 900 901 guard(mutex)(&chip->open_mutex); 902 return snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_PLAYBACK]); 903} 904 905static int snd_atiixp_capture_open(struct snd_pcm_substream *substream) 906{ 907 struct atiixp_modem *chip = snd_pcm_substream_chip(substream); 908 return snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_CAPTURE], 1); 909} 910 911static int snd_atiixp_capture_close(struct snd_pcm_substream *substream) 912{ 913 struct atiixp_modem *chip = snd_pcm_substream_chip(substream); 914 return snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_CAPTURE]); 915} 916 917 918/* AC97 playback */ 919static const struct snd_pcm_ops snd_atiixp_playback_ops = { 920 .open = snd_atiixp_playback_open, 921 .close = snd_atiixp_playback_close, 922 .hw_params = snd_atiixp_pcm_hw_params, 923 .hw_free = snd_atiixp_pcm_hw_free, 924 .prepare = snd_atiixp_playback_prepare, 925 .trigger = snd_atiixp_pcm_trigger, 926 .pointer = snd_atiixp_pcm_pointer, 927}; 928 929/* AC97 capture */ 930static const struct snd_pcm_ops snd_atiixp_capture_ops = { 931 .open = snd_atiixp_capture_open, 932 .close = snd_atiixp_capture_close, 933 .hw_params = snd_atiixp_pcm_hw_params, 934 .hw_free = snd_atiixp_pcm_hw_free, 935 .prepare = snd_atiixp_capture_prepare, 936 .trigger = snd_atiixp_pcm_trigger, 937 .pointer = snd_atiixp_pcm_pointer, 938}; 939 940static const struct atiixp_dma_ops snd_atiixp_playback_dma_ops = { 941 .type = ATI_DMA_PLAYBACK, 942 .llp_offset = ATI_REG_MODEM_OUT_DMA1_LINKPTR, 943 .dt_cur = ATI_REG_MODEM_OUT_DMA1_DT_CUR, 944 .enable_dma = atiixp_out_enable_dma, 945 .enable_transfer = atiixp_out_enable_transfer, 946 .flush_dma = atiixp_out_flush_dma, 947}; 948 949static const struct atiixp_dma_ops snd_atiixp_capture_dma_ops = { 950 .type = ATI_DMA_CAPTURE, 951 .llp_offset = ATI_REG_MODEM_IN_DMA_LINKPTR, 952 .dt_cur = ATI_REG_MODEM_IN_DMA_DT_CUR, 953 .enable_dma = atiixp_in_enable_dma, 954 .enable_transfer = atiixp_in_enable_transfer, 955 .flush_dma = atiixp_in_flush_dma, 956}; 957 958static int snd_atiixp_pcm_new(struct atiixp_modem *chip) 959{ 960 struct snd_pcm *pcm; 961 int err; 962 963 /* initialize constants */ 964 chip->dmas[ATI_DMA_PLAYBACK].ops = &snd_atiixp_playback_dma_ops; 965 chip->dmas[ATI_DMA_CAPTURE].ops = &snd_atiixp_capture_dma_ops; 966 967 /* PCM #0: analog I/O */ 968 err = snd_pcm_new(chip->card, "ATI IXP MC97", ATI_PCMDEV_ANALOG, 1, 1, &pcm); 969 if (err < 0) 970 return err; 971 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_atiixp_playback_ops); 972 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_atiixp_capture_ops); 973 pcm->dev_class = SNDRV_PCM_CLASS_MODEM; 974 pcm->private_data = chip; 975 strscpy(pcm->name, "ATI IXP MC97"); 976 chip->pcmdevs[ATI_PCMDEV_ANALOG] = pcm; 977 978 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, 979 &chip->pci->dev, 64*1024, 128*1024); 980 981 return 0; 982} 983 984 985 986/* 987 * interrupt handler 988 */ 989static irqreturn_t snd_atiixp_interrupt(int irq, void *dev_id) 990{ 991 struct atiixp_modem *chip = dev_id; 992 unsigned int status; 993 994 status = atiixp_read(chip, ISR); 995 996 if (! status) 997 return IRQ_NONE; 998 999 /* process audio DMA */ 1000 if (status & ATI_REG_ISR_MODEM_OUT1_XRUN) 1001 snd_atiixp_xrun_dma(chip, &chip->dmas[ATI_DMA_PLAYBACK]); 1002 else if (status & ATI_REG_ISR_MODEM_OUT1_STATUS) 1003 snd_atiixp_update_dma(chip, &chip->dmas[ATI_DMA_PLAYBACK]); 1004 if (status & ATI_REG_ISR_MODEM_IN_XRUN) 1005 snd_atiixp_xrun_dma(chip, &chip->dmas[ATI_DMA_CAPTURE]); 1006 else if (status & ATI_REG_ISR_MODEM_IN_STATUS) 1007 snd_atiixp_update_dma(chip, &chip->dmas[ATI_DMA_CAPTURE]); 1008 1009 /* for codec detection */ 1010 if (status & CODEC_CHECK_BITS) { 1011 unsigned int detected; 1012 detected = status & CODEC_CHECK_BITS; 1013 guard(spinlock)(&chip->reg_lock); 1014 chip->codec_not_ready_bits |= detected; 1015 atiixp_update(chip, IER, detected, 0); /* disable the detected irqs */ 1016 } 1017 1018 /* ack */ 1019 atiixp_write(chip, ISR, status); 1020 1021 return IRQ_HANDLED; 1022} 1023 1024 1025/* 1026 * ac97 mixer section 1027 */ 1028 1029static int snd_atiixp_mixer_new(struct atiixp_modem *chip, int clock) 1030{ 1031 struct snd_ac97_bus *pbus; 1032 struct snd_ac97_template ac97; 1033 int i, err; 1034 int codec_count; 1035 static const struct snd_ac97_bus_ops ops = { 1036 .write = snd_atiixp_ac97_write, 1037 .read = snd_atiixp_ac97_read, 1038 }; 1039 static const unsigned int codec_skip[NUM_ATI_CODECS] = { 1040 ATI_REG_ISR_CODEC0_NOT_READY, 1041 ATI_REG_ISR_CODEC1_NOT_READY, 1042 ATI_REG_ISR_CODEC2_NOT_READY, 1043 }; 1044 1045 if (snd_atiixp_codec_detect(chip) < 0) 1046 return -ENXIO; 1047 1048 err = snd_ac97_bus(chip->card, 0, &ops, chip, &pbus); 1049 if (err < 0) 1050 return err; 1051 pbus->clock = clock; 1052 chip->ac97_bus = pbus; 1053 1054 codec_count = 0; 1055 for (i = 0; i < NUM_ATI_CODECS; i++) { 1056 if (chip->codec_not_ready_bits & codec_skip[i]) 1057 continue; 1058 memset(&ac97, 0, sizeof(ac97)); 1059 ac97.private_data = chip; 1060 ac97.pci = chip->pci; 1061 ac97.num = i; 1062 ac97.scaps = AC97_SCAP_SKIP_AUDIO | AC97_SCAP_POWER_SAVE; 1063 err = snd_ac97_mixer(pbus, &ac97, &chip->ac97[i]); 1064 if (err < 0) { 1065 chip->ac97[i] = NULL; /* to be sure */ 1066 dev_dbg(chip->card->dev, 1067 "codec %d not available for modem\n", i); 1068 continue; 1069 } 1070 codec_count++; 1071 } 1072 1073 if (! codec_count) { 1074 dev_err(chip->card->dev, "no codec available\n"); 1075 return -ENODEV; 1076 } 1077 1078 /* snd_ac97_tune_hardware(chip->ac97, ac97_quirks); */ 1079 1080 return 0; 1081} 1082 1083 1084/* 1085 * power management 1086 */ 1087static int snd_atiixp_suspend(struct device *dev) 1088{ 1089 struct snd_card *card = dev_get_drvdata(dev); 1090 struct atiixp_modem *chip = card->private_data; 1091 int i; 1092 1093 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 1094 for (i = 0; i < NUM_ATI_CODECS; i++) 1095 snd_ac97_suspend(chip->ac97[i]); 1096 snd_atiixp_aclink_down(chip); 1097 snd_atiixp_chip_stop(chip); 1098 return 0; 1099} 1100 1101static int snd_atiixp_resume(struct device *dev) 1102{ 1103 struct snd_card *card = dev_get_drvdata(dev); 1104 struct atiixp_modem *chip = card->private_data; 1105 int i; 1106 1107 snd_atiixp_aclink_reset(chip); 1108 snd_atiixp_chip_start(chip); 1109 1110 for (i = 0; i < NUM_ATI_CODECS; i++) 1111 snd_ac97_resume(chip->ac97[i]); 1112 1113 snd_power_change_state(card, SNDRV_CTL_POWER_D0); 1114 return 0; 1115} 1116 1117static DEFINE_SIMPLE_DEV_PM_OPS(snd_atiixp_pm, snd_atiixp_suspend, snd_atiixp_resume); 1118 1119/* 1120 * proc interface for register dump 1121 */ 1122 1123static void snd_atiixp_proc_read(struct snd_info_entry *entry, 1124 struct snd_info_buffer *buffer) 1125{ 1126 struct atiixp_modem *chip = entry->private_data; 1127 int i; 1128 1129 for (i = 0; i < 256; i += 4) 1130 snd_iprintf(buffer, "%02x: %08x\n", i, readl(chip->remap_addr + i)); 1131} 1132 1133static void snd_atiixp_proc_init(struct atiixp_modem *chip) 1134{ 1135 snd_card_ro_proc_new(chip->card, "atiixp-modem", chip, 1136 snd_atiixp_proc_read); 1137} 1138 1139 1140/* 1141 * destructor 1142 */ 1143 1144static void snd_atiixp_free(struct snd_card *card) 1145{ 1146 snd_atiixp_chip_stop(card->private_data); 1147} 1148 1149/* 1150 * constructor for chip instance 1151 */ 1152static int snd_atiixp_init(struct snd_card *card, struct pci_dev *pci) 1153{ 1154 struct atiixp_modem *chip = card->private_data; 1155 int err; 1156 1157 err = pcim_enable_device(pci); 1158 if (err < 0) 1159 return err; 1160 1161 spin_lock_init(&chip->reg_lock); 1162 mutex_init(&chip->open_mutex); 1163 chip->card = card; 1164 chip->pci = pci; 1165 chip->irq = -1; 1166 chip->remap_addr = pcim_iomap_region(pci, 0, "ATI IXP MC97"); 1167 if (IS_ERR(chip->remap_addr)) 1168 return PTR_ERR(chip->remap_addr); 1169 chip->addr = pci_resource_start(pci, 0); 1170 1171 if (devm_request_irq(&pci->dev, pci->irq, snd_atiixp_interrupt, 1172 IRQF_SHARED, KBUILD_MODNAME, chip)) { 1173 dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq); 1174 return -EBUSY; 1175 } 1176 chip->irq = pci->irq; 1177 card->sync_irq = chip->irq; 1178 card->private_free = snd_atiixp_free; 1179 pci_set_master(pci); 1180 1181 return 0; 1182} 1183 1184 1185static int __snd_atiixp_probe(struct pci_dev *pci, 1186 const struct pci_device_id *pci_id) 1187{ 1188 struct snd_card *card; 1189 struct atiixp_modem *chip; 1190 int err; 1191 1192 err = snd_devm_card_new(&pci->dev, index, id, THIS_MODULE, 1193 sizeof(*chip), &card); 1194 if (err < 0) 1195 return err; 1196 chip = card->private_data; 1197 1198 strscpy(card->driver, "ATIIXP-MODEM"); 1199 strscpy(card->shortname, "ATI IXP Modem"); 1200 err = snd_atiixp_init(card, pci); 1201 if (err < 0) 1202 return err; 1203 1204 err = snd_atiixp_aclink_reset(chip); 1205 if (err < 0) 1206 return err; 1207 1208 err = snd_atiixp_mixer_new(chip, ac97_clock); 1209 if (err < 0) 1210 return err; 1211 1212 err = snd_atiixp_pcm_new(chip); 1213 if (err < 0) 1214 return err; 1215 1216 snd_atiixp_proc_init(chip); 1217 1218 snd_atiixp_chip_start(chip); 1219 1220 sprintf(card->longname, "%s rev %x at 0x%lx, irq %i", 1221 card->shortname, pci->revision, chip->addr, chip->irq); 1222 1223 err = snd_card_register(card); 1224 if (err < 0) 1225 return err; 1226 1227 pci_set_drvdata(pci, card); 1228 return 0; 1229} 1230 1231static int snd_atiixp_probe(struct pci_dev *pci, 1232 const struct pci_device_id *pci_id) 1233{ 1234 return snd_card_free_on_error(&pci->dev, __snd_atiixp_probe(pci, pci_id)); 1235} 1236 1237static struct pci_driver atiixp_modem_driver = { 1238 .name = KBUILD_MODNAME, 1239 .id_table = snd_atiixp_ids, 1240 .probe = snd_atiixp_probe, 1241 .driver = { 1242 .pm = &snd_atiixp_pm, 1243 }, 1244}; 1245 1246module_pci_driver(atiixp_modem_driver);
~/
Read-only file preview.