1/* 2 * Copyright 2001-2004 Randolph Chung <tausq@debian.org> 3 * 4 * Analog Devices 1889 PCI audio driver (AD1819 AC97-compatible codec) 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 * 20 * Notes: 21 * 1. Only flat DMA is supported; s-g is not supported right now 22 * 23 * 24<jsm> tausq: Anyway, to set up sample rates for D to A, you just use the sample rate on the codec. For A to D, you need to set the codec always to 48K (using the split sample rate feature on the codec) and then set the resampler on the AD1889 to the sample rate you want. 25<jsm> Also, when changing the sample rate on the codec you need to power it down and re power it up for the change to take effect! 26 * 27 * $Id: ad1889.c,v 1.1.1.1 2007/08/03 18:53:59 Exp $ 28 */ 29#include <linux/module.h> 30#include <linux/init.h> 31#include <linux/ioport.h> 32#include <linux/pci.h> 33#include <linux/poll.h> 34#include <linux/proc_fs.h> 35#include <linux/slab.h> 36#include <linux/soundcard.h> 37#include <linux/ac97_codec.h> 38#include <linux/sound.h> 39#include <linux/interrupt.h> 40#include <linux/mutex.h> 41 42#include <asm/delay.h> 43#include <asm/io.h> 44#include <asm/dma.h> 45#include <asm/uaccess.h> 46 47#include "ad1889.h" 48 49#define DBG(fmt, arg...) printk(fmt, ##arg) 50#define DEVNAME "ad1889" 51 52#define NR_HW_CH 4 53#define DAC_RUNNING 1 54#define ADC_RUNNING 2 55 56#define UNDERRUN(dev) (0) 57 58#define AD1889_READW(dev,reg) readw(dev->regbase + reg) 59#define AD1889_WRITEW(dev,reg,val) writew((val), dev->regbase + reg) 60#define AD1889_READL(dev,reg) readl(dev->regbase + reg) 61#define AD1889_WRITEL(dev,reg,val) writel((val), dev->regbase + reg) 62 63//now 100ms 64/* #define WAIT_10MS() schedule_timeout(HZ/10) */ 65#define WAIT_10MS() do { int __i; for (__i = 0; __i < 100; __i++) udelay(1000); } while(0) 66 67/* currently only support a single device */ 68static ad1889_dev_t *ad1889_dev = NULL; 69 70/************************* helper routines ***************************** */ 71static inline void ad1889_set_wav_rate(ad1889_dev_t *dev, int rate) 72{ 73 struct ac97_codec *ac97_codec = dev->ac97_codec; 74 75 DBG("Setting WAV rate to %d\n", rate); 76 dev->state[AD_WAV_STATE].dmabuf.rate = rate; 77 AD1889_WRITEW(dev, AD_DS_WAS, rate); 78 79 /* Cycle the DAC to enable the new rate */ 80 ac97_codec->codec_write(dev->ac97_codec, AC97_POWER_CONTROL, 0x0200); 81 WAIT_10MS(); 82 ac97_codec->codec_write(dev->ac97_codec, AC97_POWER_CONTROL, 0); 83} 84 85static inline void ad1889_set_wav_fmt(ad1889_dev_t *dev, int fmt) 86{ 87 u16 tmp; 88 89 DBG("Setting WAV format to 0x%x\n", fmt); 90 91 tmp = AD1889_READW(ad1889_dev, AD_DS_WSMC); 92 if (fmt & AFMT_S16_LE) { 93 //tmp |= 0x0100; /* set WA16 */ 94 tmp |= 0x0300; /* set WA16 stereo */ 95 } else if (fmt & AFMT_U8) { 96 tmp &= ~0x0100; /* clear WA16 */ 97 } 98 AD1889_WRITEW(ad1889_dev, AD_DS_WSMC, tmp); 99} 100 101static inline void ad1889_set_adc_fmt(ad1889_dev_t *dev, int fmt) 102{ 103 u16 tmp; 104 105 DBG("Setting ADC format to 0x%x\n", fmt); 106 107 tmp = AD1889_READW(ad1889_dev, AD_DS_RAMC); 108 if (fmt & AFMT_S16_LE) { 109 tmp |= 0x0100; /* set WA16 */ 110 } else if (fmt & AFMT_U8) { 111 tmp &= ~0x0100; /* clear WA16 */ 112 } 113 AD1889_WRITEW(ad1889_dev, AD_DS_RAMC, tmp); 114} 115 116static void ad1889_start_wav(ad1889_state_t *state) 117{ 118 unsigned long flags; 119 struct dmabuf *dmabuf = &state->dmabuf; 120 int cnt; 121 u16 tmp; 122 123 spin_lock_irqsave(&state->card->lock, flags); 124 125 if (dmabuf->dma_len) /* DMA already in flight */ 126 goto skip_dma; 127 128 /* setup dma */ 129 cnt = dmabuf->wr_ptr - dmabuf->rd_ptr; 130 if (cnt == 0) /* done - don't need to do anything */ 131 goto skip_dma; 132 133 /* If the wr_ptr has wrapped, only map to the end */ 134 if (cnt < 0) 135 cnt = DMA_SIZE - dmabuf->rd_ptr; 136 137 dmabuf->dma_handle = pci_map_single(ad1889_dev->pci, 138 dmabuf->rawbuf + dmabuf->rd_ptr, 139 cnt, PCI_DMA_TODEVICE); 140 dmabuf->dma_len = cnt; 141 dmabuf->ready = 1; 142 143 DBG("Starting playback at 0x%p for %ld bytes\n", dmabuf->rawbuf + 144 dmabuf->rd_ptr, dmabuf->dma_len); 145 146 /* load up the current register set */ 147 AD1889_WRITEL(ad1889_dev, AD_DMA_WAVCC, cnt); 148 AD1889_WRITEL(ad1889_dev, AD_DMA_WAVICC, cnt); 149 AD1889_WRITEL(ad1889_dev, AD_DMA_WAVCA, dmabuf->dma_handle); 150 151 /* TODO: for now we load the base registers with the same thing */ 152 AD1889_WRITEL(ad1889_dev, AD_DMA_WAVBC, cnt); 153 AD1889_WRITEL(ad1889_dev, AD_DMA_WAVIBC, cnt); 154 AD1889_WRITEL(ad1889_dev, AD_DMA_WAVBA, dmabuf->dma_handle); 155 156 /* and we're off to the races... */ 157 AD1889_WRITEL(ad1889_dev, AD_DMA_CHSS, 0x8); 158 tmp = AD1889_READW(ad1889_dev, AD_DS_WSMC); 159 tmp |= 0x0400; /* set WAEN */ 160 AD1889_WRITEW(ad1889_dev, AD_DS_WSMC, tmp); 161 (void) AD1889_READW(ad1889_dev, AD_DS_WSMC); /* flush posted PCI write */ 162 163 dmabuf->enable |= DAC_RUNNING; 164 165skip_dma: 166 spin_unlock_irqrestore(&state->card->lock, flags); 167} 168 169 170static void ad1889_stop_wav(ad1889_state_t *state) 171{ 172 unsigned long flags; 173 struct dmabuf *dmabuf = &state->dmabuf; 174 175 spin_lock_irqsave(&state->card->lock, flags); 176 177 if (dmabuf->enable & DAC_RUNNING) { 178 u16 tmp; 179 unsigned long cnt = dmabuf->dma_len; 180 181 tmp = AD1889_READW(ad1889_dev, AD_DS_WSMC); 182 tmp &= ~0x0400; /* clear WAEN */ 183 AD1889_WRITEW(ad1889_dev, AD_DS_WSMC, tmp); 184 (void) AD1889_READW(ad1889_dev, AD_DS_WSMC); /* flush posted PCI write */ 185 pci_unmap_single(ad1889_dev->pci, dmabuf->dma_handle, 186 cnt, PCI_DMA_TODEVICE); 187 188 dmabuf->enable &= ~DAC_RUNNING; 189 190 /* update dma pointers */ 191 dmabuf->rd_ptr += cnt; 192 dmabuf->rd_ptr &= (DMA_SIZE - 1); 193 194 dmabuf->dma_handle = 0; 195 dmabuf->dma_len = 0; 196 dmabuf->ready = 0; 197 198 wake_up(&dmabuf->wait); 199 } 200 201 spin_unlock_irqrestore(&state->card->lock, flags); 202} 203 204 205 206static ad1889_dev_t *ad1889_alloc_dev(struct pci_dev *pci) 207{ 208 ad1889_dev_t *dev; 209 struct dmabuf *dmabuf; 210 int i; 211 212 if ((dev = kzalloc(sizeof(ad1889_dev_t), GFP_KERNEL)) == NULL) 213 return NULL; 214 spin_lock_init(&dev->lock); 215 dev->pci = pci; 216 217 for (i = 0; i < AD_MAX_STATES; i++) { 218 dev->state[i].card = dev; 219 mutex_init(&dev->state[i].mutex); 220 init_waitqueue_head(&dev->state[i].dmabuf.wait); 221 } 222 223 /* allocate dma buffer */ 224 225 for (i = 0; i < AD_MAX_STATES; i++) { 226 dmabuf = &dev->state[i].dmabuf; 227 dmabuf->rawbuf = kmalloc(DMA_SIZE, GFP_KERNEL|GFP_DMA); 228 if (!dmabuf->rawbuf) 229 goto err_free_dmabuf; 230 dmabuf->rawbuf_size = DMA_SIZE; 231 dmabuf->dma_handle = 0; 232 dmabuf->rd_ptr = dmabuf->wr_ptr = dmabuf->dma_len = 0UL; 233 dmabuf->ready = 0; 234 dmabuf->rate = 48000; 235 } 236 return dev; 237 238err_free_dmabuf: 239 while (--i >= 0) 240 kfree(dev->state[i].dmabuf.rawbuf); 241 kfree(dev); 242 return NULL; 243} 244 245static void ad1889_free_dev(ad1889_dev_t *dev) 246{ 247 int j; 248 struct dmabuf *dmabuf; 249 250 if (dev == NULL) 251 return; 252 253 if (dev->ac97_codec) 254 ac97_release_codec(dev->ac97_codec); 255 256 for (j = 0; j < AD_MAX_STATES; j++) { 257 dmabuf = &dev->state[j].dmabuf; 258 kfree(dmabuf->rawbuf); 259 } 260 261 kfree(dev); 262} 263 264static inline void ad1889_trigger_playback(ad1889_dev_t *dev) 265{ 266 267 ad1889_start_wav(&dev->state[AD_WAV_STATE]); 268} 269 270static int ad1889_read_proc (char *page, char **start, off_t off, 271 int count, int *eof, void *data) 272{ 273 char *out = page; 274 int len, i; 275 ad1889_dev_t *dev = data; 276 ad1889_reg_t regs[] = { 277 { "WSMC", AD_DS_WSMC, 16 }, 278 { "RAMC", AD_DS_RAMC, 16 }, 279 { "WADA", AD_DS_WADA, 16 }, 280 { "SYDA", AD_DS_SYDA, 16 }, 281 { "WAS", AD_DS_WAS, 16 }, 282 { "RES", AD_DS_RES, 16 }, 283 { "CCS", AD_DS_CCS, 16 }, 284 { "ADCBA", AD_DMA_ADCBA, 32 }, 285 { "ADCCA", AD_DMA_ADCCA, 32 }, 286 { "ADCBC", AD_DMA_ADCBC, 32 }, 287 { "ADCCC", AD_DMA_ADCCC, 32 }, 288 { "ADCIBC", AD_DMA_ADCIBC, 32 }, 289 { "ADCICC", AD_DMA_ADCICC, 32 }, 290 { "ADCCTRL", AD_DMA_ADCCTRL, 16 }, 291 { "WAVBA", AD_DMA_WAVBA, 32 }, 292 { "WAVCA", AD_DMA_WAVCA, 32 }, 293 { "WAVBC", AD_DMA_WAVBC, 32 }, 294 { "WAVCC", AD_DMA_WAVCC, 32 }, 295 { "WAVIBC", AD_DMA_WAVIBC, 32 }, 296 { "WAVICC", AD_DMA_WAVICC, 32 }, 297 { "WAVCTRL", AD_DMA_WAVCTRL, 16 }, 298 { "DISR", AD_DMA_DISR, 32 }, 299 { "CHSS", AD_DMA_CHSS, 32 }, 300 { "IPC", AD_GPIO_IPC, 16 }, 301 { "OP", AD_GPIO_OP, 16 }, 302 { "IP", AD_GPIO_IP, 16 }, 303 { "ACIC", AD_AC97_ACIC, 16 }, 304 { "AC97_RESET", AD_AC97_BASE + AC97_RESET, 16 }, 305 { "AC97_MASTER_VOL_STEREO", AD_AC97_BASE + AC97_MASTER_VOL_STEREO, 16 }, 306 { "AC97_HEADPHONE_VOL", AD_AC97_BASE + AC97_HEADPHONE_VOL, 16 }, 307 { "AC97_MASTER_VOL_MONO", AD_AC97_BASE + AC97_MASTER_VOL_MONO, 16 }, 308 { "AC97_MASTER_TONE", AD_AC97_BASE + AC97_MASTER_TONE, 16 }, 309 { "AC97_PCBEEP_VOL", AD_AC97_BASE + AC97_PCBEEP_VOL, 16 }, 310 { "AC97_PHONE_VOL", AD_AC97_BASE + AC97_PHONE_VOL, 16 }, 311 { "AC97_MIC_VOL", AD_AC97_BASE + AC97_MIC_VOL, 16 }, 312 { "AC97_LINEIN_VOL", AD_AC97_BASE + AC97_LINEIN_VOL, 16 }, 313 { "AC97_CD_VOL", AD_AC97_BASE + AC97_CD_VOL, 16 }, 314 { "AC97_VIDEO_VOL", AD_AC97_BASE + AC97_VIDEO_VOL, 16 }, 315 { "AC97_AUX_VOL", AD_AC97_BASE + AC97_AUX_VOL, 16 }, 316 { "AC97_PCMOUT_VOL", AD_AC97_BASE + AC97_PCMOUT_VOL, 16 }, 317 { "AC97_RECORD_SELECT", AD_AC97_BASE + AC97_RECORD_SELECT, 16 }, 318 { "AC97_RECORD_GAIN", AD_AC97_BASE + AC97_RECORD_GAIN, 16 }, 319 { "AC97_RECORD_GAIN_MIC", AD_AC97_BASE + AC97_RECORD_GAIN_MIC, 16 }, 320 { "AC97_GENERAL_PURPOSE", AD_AC97_BASE + AC97_GENERAL_PURPOSE, 16 }, 321 { "AC97_3D_CONTROL", AD_AC97_BASE + AC97_3D_CONTROL, 16 }, 322 { "AC97_MODEM_RATE", AD_AC97_BASE + AC97_MODEM_RATE, 16 }, 323 { "AC97_POWER_CONTROL", AD_AC97_BASE + AC97_POWER_CONTROL, 16 }, 324 { NULL } 325 }; 326 327 if (dev == NULL) 328 return -ENODEV; 329 330 for (i = 0; regs[i].name != 0; i++) 331 out += sprintf(out, "%s: 0x%0*x\n", regs[i].name, 332 regs[i].width >> 2, 333 (regs[i].width == 16 334 ? AD1889_READW(dev, regs[i].offset) 335 : AD1889_READL(dev, regs[i].offset))); 336 337 for (i = 0; i < AD_MAX_STATES; i++) { 338 out += sprintf(out, "DMA status for %s:\n", 339 (i == AD_WAV_STATE ? "WAV" : "ADC")); 340 out += sprintf(out, "\t\t0x%p (IOVA: 0x%llu)\n", 341 dev->state[i].dmabuf.rawbuf, 342 (unsigned long long)dev->state[i].dmabuf.dma_handle); 343 344 out += sprintf(out, "\tread ptr: offset %u\n", 345 (unsigned int)dev->state[i].dmabuf.rd_ptr); 346 out += sprintf(out, "\twrite ptr: offset %u\n", 347 (unsigned int)dev->state[i].dmabuf.wr_ptr); 348 out += sprintf(out, "\tdma len: offset %u\n", 349 (unsigned int)dev->state[i].dmabuf.dma_len); 350 } 351 352 len = out - page - off; 353 if (len < count) { 354 *eof = 1; 355 if (len <= 0) return 0; 356 } else { 357 len = count; 358 } 359 *start = page + off; 360 return len; 361} 362 363/***************************** DMA interfaces ************************** */ 364 365/************************* /dev/dsp interfaces ************************* */ 366 367static ssize_t ad1889_read(struct file *file, char __user *buffer, size_t count, 368 loff_t *ppos) 369{ 370 return 0; 371} 372 373static ssize_t ad1889_write(struct file *file, const char __user *buffer, size_t count, 374 loff_t *ppos) 375{ 376 ad1889_dev_t *dev = (ad1889_dev_t *)file->private_data; 377 ad1889_state_t *state = &dev->state[AD_WAV_STATE]; 378 volatile struct dmabuf *dmabuf = &state->dmabuf; 379 ssize_t ret = 0; 380 DECLARE_WAITQUEUE(wait, current); 381 382 mutex_lock(&state->mutex); 383 if (!access_ok(VERIFY_READ, buffer, count)) { 384 ret = -EFAULT; 385 goto err1; 386 } 387 388 add_wait_queue(&state->dmabuf.wait, &wait); 389 390 /* start filling dma buffer.... */ 391 while (count > 0) { 392 long rem; 393 long cnt = count; 394 unsigned long flags; 395 396 for (;;) { 397 long used_bytes; 398 long timeout; /* max time for DMA in jiffies */ 399 400 /* buffer is full if wr catches up to rd */ 401 spin_lock_irqsave(&state->card->lock, flags); 402 used_bytes = dmabuf->wr_ptr - dmabuf->rd_ptr; 403 timeout = (dmabuf->dma_len * HZ) / dmabuf->rate; 404 spin_unlock_irqrestore(&state->card->lock, flags); 405 406 /* adjust for buffer wrap around */ 407 used_bytes = (used_bytes + DMA_SIZE) & (DMA_SIZE - 1); 408 409 /* If at least one page unused */ 410 if (used_bytes < (DMA_SIZE - 0x1000)) 411 break; 412 413 /* dma buffer full */ 414 415 if (file->f_flags & O_NONBLOCK) { 416 ret = -EAGAIN; 417 goto err2; 418 } 419 420 set_current_state(TASK_INTERRUPTIBLE); 421 schedule_timeout(timeout + 1); 422 if (signal_pending(current)) { 423 ret = -ERESTARTSYS; 424 goto err2; 425 } 426 } 427 428 /* watch out for wrapping around static buffer */ 429 spin_lock_irqsave(&state->card->lock, flags); 430 rem = DMA_SIZE - dmabuf->wr_ptr; 431 if (cnt > rem) 432 cnt = rem; 433 434 rem = dmabuf->wr_ptr; 435 436 /* update dma pointers */ 437 dmabuf->wr_ptr += cnt; 438 dmabuf->wr_ptr &= DMA_SIZE - 1; /* wrap ptr if necessary */ 439 spin_unlock_irqrestore(&state->card->lock, flags); 440 441 /* transfer unwrapped chunk */ 442 if (copy_from_user(dmabuf->rawbuf + rem, buffer, cnt)) { 443 ret = -EFAULT; 444 goto err2; 445 } 446 447 DBG("Writing 0x%lx bytes to +0x%lx\n", cnt, rem); 448 449 /* update counters */ 450 count -= cnt; 451 buffer += cnt; 452 ret += cnt; 453 454 /* we have something to play - go play it! */ 455 ad1889_trigger_playback(dev); 456 } 457 458err2: 459 remove_wait_queue(&state->dmabuf.wait, &wait); 460err1: 461 mutex_unlock(&state->mutex); 462 return ret; 463} 464 465static unsigned int ad1889_poll(struct file *file, struct poll_table_struct *wait) 466{ 467 unsigned int mask = 0; 468 return mask; 469} 470 471static int ad1889_mmap(struct file *file, struct vm_area_struct *vma) 472{ 473 return 0; 474} 475 476static int ad1889_ioctl(struct inode *inode, struct file *file, unsigned int cmd, 477 unsigned long arg) 478{ 479 int val = 0; 480 ad1889_dev_t *dev = (ad1889_dev_t *)file->private_data; 481 struct dmabuf *dmabuf; 482 audio_buf_info abinfo; 483 int __user *p = (int __user *)arg; 484 485 DBG("ad1889_ioctl cmd 0x%x arg %lu\n", cmd, arg); 486 487 switch (cmd) 488 { 489 case OSS_GETVERSION: 490 return put_user(SOUND_VERSION, p); 491 492 case SNDCTL_DSP_RESET: 493 break; 494 495 case SNDCTL_DSP_SYNC: 496 break; 497 498 case SNDCTL_DSP_SPEED: 499 /* set sampling rate */ 500 if (get_user(val, p)) 501 return -EFAULT; 502 if (val > 5400 && val < 48000) 503 { 504 if (file->f_mode & FMODE_WRITE) 505 AD1889_WRITEW(ad1889_dev, AD_DS_WAS, val); 506 if (file->f_mode & FMODE_READ) 507 AD1889_WRITEW(ad1889_dev, AD_DS_RES, val); 508 } 509 return 0; 510 511 case SNDCTL_DSP_STEREO: /* undocumented? */ 512 if (get_user(val, p)) 513 return -EFAULT; 514 if (file->f_mode & FMODE_READ) { 515 val = AD1889_READW(ad1889_dev, AD_DS_WSMC); 516 if (val) { 517 val |= 0x0200; /* set WAST */ 518 } else { 519 val &= ~0x0200; /* clear WAST */ 520 } 521 AD1889_WRITEW(ad1889_dev, AD_DS_WSMC, val); 522 } 523 if (file->f_mode & FMODE_WRITE) { 524 val = AD1889_READW(ad1889_dev, AD_DS_RAMC); 525 if (val) { 526 val |= 0x0002; /* set ADST */ 527 } else { 528 val &= ~0x0002; /* clear ADST */ 529 } 530 AD1889_WRITEW(ad1889_dev, AD_DS_RAMC, val); 531 } 532 533 return 0; 534 535 case SNDCTL_DSP_GETBLKSIZE: 536 return put_user(DMA_SIZE, p); 537 538 case SNDCTL_DSP_GETFMTS: 539 return put_user(AFMT_S16_LE|AFMT_U8, p); 540 541 case SNDCTL_DSP_SETFMT: 542 if (get_user(val, p)) 543 return -EFAULT; 544 545 if (val == 0) { 546 if (file->f_mode & FMODE_READ) 547 ad1889_set_adc_fmt(dev, val); 548 549 if (file->f_mode & FMODE_WRITE) 550 ad1889_set_wav_fmt(dev, val); 551 } else { 552 val = AFMT_S16_LE | AFMT_U8; 553 } 554 555 return put_user(val, p); 556 557 case SNDCTL_DSP_CHANNELS: 558 break; 559 560 case SNDCTL_DSP_POST: 561 /* send all data to device */ 562 break; 563 564 case SNDCTL_DSP_SUBDIVIDE: 565 break; 566 567 case SNDCTL_DSP_SETFRAGMENT: 568 /* not supported; uses fixed fragment sizes */ 569 return put_user(DMA_SIZE, p); 570 571 case SNDCTL_DSP_GETOSPACE: 572 case SNDCTL_DSP_GETISPACE: 573 /* space left in dma buffers */ 574 if (cmd == SNDCTL_DSP_GETOSPACE) 575 dmabuf = &dev->state[AD_WAV_STATE].dmabuf; 576 else 577 dmabuf = &dev->state[AD_ADC_STATE].dmabuf; 578 abinfo.fragments = 1; 579 abinfo.fragstotal = 1; 580 abinfo.fragsize = DMA_SIZE; 581 abinfo.bytes = DMA_SIZE; 582 return copy_to_user(p, &abinfo, sizeof(abinfo)) ? -EFAULT : 0; 583 case SNDCTL_DSP_NONBLOCK: 584 file->f_flags |= O_NONBLOCK; 585 return 0; 586 587 case SNDCTL_DSP_GETCAPS: 588 return put_user(0, p); 589 590 case SNDCTL_DSP_GETTRIGGER: 591 case SNDCTL_DSP_SETTRIGGER: 592 break; 593 594 case SNDCTL_DSP_GETIPTR: 595 case SNDCTL_DSP_GETOPTR: 596 break; 597 598 case SNDCTL_DSP_SETDUPLEX: 599 break; 600 601 case SNDCTL_DSP_GETODELAY: 602 break; 603 604 case SOUND_PCM_READ_RATE: 605 return put_user(AD1889_READW(ad1889_dev, AD_DS_WAS), p); 606 607 case SOUND_PCM_READ_CHANNELS: 608 case SOUND_PCM_READ_BITS: 609 break; 610 611 case SNDCTL_DSP_MAPINBUF: 612 case SNDCTL_DSP_MAPOUTBUF: 613 case SNDCTL_DSP_SETSYNCRO: 614 case SOUND_PCM_WRITE_FILTER: 615 case SOUND_PCM_READ_FILTER: 616 break; 617 618 default: 619 break; 620 } 621 622 return -ENOTTY; 623} 624 625static int ad1889_open(struct inode *inode, struct file *file) 626{ 627 /* check minor; only support /dev/dsp atm */ 628 if (iminor(inode) != 3) 629 return -ENXIO; 630 631 file->private_data = ad1889_dev; 632 633 ad1889_set_wav_rate(ad1889_dev, 48000); 634 ad1889_set_wav_fmt(ad1889_dev, AFMT_S16_LE); 635 AD1889_WRITEW(ad1889_dev, AD_DS_WADA, 0x0404); /* attenuation */ 636 return nonseekable_open(inode, file); 637} 638 639static int ad1889_release(struct inode *inode, struct file *file) 640{ 641 /* if we have state free it here */ 642 return 0; 643} 644 645static const struct file_operations ad1889_fops = { 646 .owner = THIS_MODULE, 647 .llseek = no_llseek, 648 .read = ad1889_read, 649 .write = ad1889_write, 650 .poll = ad1889_poll, 651 .ioctl = ad1889_ioctl, 652 .mmap = ad1889_mmap, 653 .open = ad1889_open, 654 .release = ad1889_release, 655}; 656 657/************************* /dev/mixer interfaces ************************ */ 658static int ad1889_mixer_open(struct inode *inode, struct file *file) 659{ 660 if (ad1889_dev->ac97_codec->dev_mixer != iminor(inode)) 661 return -ENODEV; 662 663 file->private_data = ad1889_dev->ac97_codec; 664 return 0; 665} 666 667static int ad1889_mixer_release(struct inode *inode, struct file *file) 668{ 669 return 0; 670} 671 672static int ad1889_mixer_ioctl(struct inode *inode, struct file *file, 673 unsigned int cmd, unsigned long arg) 674{ 675 struct ac97_codec *codec = (struct ac97_codec *)file->private_data; 676 return codec->mixer_ioctl(codec, cmd, arg); 677} 678 679static const struct file_operations ad1889_mixer_fops = { 680 .owner = THIS_MODULE, 681 .llseek = no_llseek, 682 .ioctl = ad1889_mixer_ioctl, 683 .open = ad1889_mixer_open, 684 .release = ad1889_mixer_release, 685}; 686 687/************************* AC97 interfaces ****************************** */ 688static void ad1889_codec_write(struct ac97_codec *ac97, u8 reg, u16 val) 689{ 690 ad1889_dev_t *dev = ac97->private_data; 691 692 //DBG("Writing 0x%x to 0x%lx\n", val, dev->regbase + AD_AC97_BASE + reg); 693 AD1889_WRITEW(dev, AD_AC97_BASE + reg, val); 694} 695 696static u16 ad1889_codec_read(struct ac97_codec *ac97, u8 reg) 697{ 698 ad1889_dev_t *dev = ac97->private_data; 699 //DBG("Reading from 0x%lx\n", dev->regbase + AD_AC97_BASE + reg); 700 return AD1889_READW(dev, AD_AC97_BASE + reg); 701} 702 703static int ad1889_ac97_init(ad1889_dev_t *dev, int id) 704{ 705 struct ac97_codec *ac97; 706 u16 eid; 707 708 if ((ac97 = ac97_alloc_codec()) == NULL) 709 return -ENOMEM; 710 711 ac97->private_data = dev; 712 ac97->id = id; 713 714 ac97->codec_read = ad1889_codec_read; 715 ac97->codec_write = ad1889_codec_write; 716 717 if (ac97_probe_codec(ac97) == 0) { 718 printk(DEVNAME ": ac97_probe_codec failed\n"); 719 goto out_free; 720 } 721 722 eid = ad1889_codec_read(ac97, AC97_EXTENDED_ID); 723 if (eid == 0xffff) { 724 printk(KERN_WARNING DEVNAME ": no codec attached?\n"); 725 goto out_free; 726 } 727 728 dev->ac97_features = eid; 729 730 if ((ac97->dev_mixer = register_sound_mixer(&ad1889_mixer_fops, -1)) < 0) { 731 printk(KERN_ERR DEVNAME ": cannot register mixer\n"); 732 goto out_free; 733 } 734 735 dev->ac97_codec = ac97; 736 return 0; 737 738out_free: 739 ac97_release_codec(ac97); 740 return -ENODEV; 741} 742 743static int ad1889_aclink_reset(struct pci_dev * pcidev) 744{ 745 u16 stat; 746 int retry = 200; 747 ad1889_dev_t *dev = pci_get_drvdata(pcidev); 748 749 AD1889_WRITEW(dev, AD_DS_CCS, 0x8000); /* turn on clock */ 750 AD1889_READW(dev, AD_DS_CCS); 751 752 WAIT_10MS(); 753 754 stat = AD1889_READW(dev, AD_AC97_ACIC); 755 stat |= 0x0002; /* Reset Disable */ 756 AD1889_WRITEW(dev, AD_AC97_ACIC, stat); 757 (void) AD1889_READW(dev, AD_AC97_ACIC); /* flush posted write */ 758 759 udelay(10); 760 761 stat = AD1889_READW(dev, AD_AC97_ACIC); 762 stat |= 0x0001; /* Interface Enable */ 763 AD1889_WRITEW(dev, AD_AC97_ACIC, stat); 764 765 do { 766 if (AD1889_READW(dev, AD_AC97_ACIC) & 0x8000) /* Ready */ 767 break; 768 WAIT_10MS(); 769 retry--; 770 } while (retry > 0); 771 772 if (!retry) { 773 printk(KERN_ERR "ad1889_aclink_reset: codec is not ready [0x%x]\n", 774 AD1889_READW(dev, AD_AC97_ACIC)); 775 return -EBUSY; 776 } 777 778 /* TODO reset AC97 codec */ 779 /* TODO set wave/adc pci ctrl status */ 780 781 stat = AD1889_READW(dev, AD_AC97_ACIC); 782 stat |= 0x0004; /* Audio Stream Output Enable */ 783 AD1889_WRITEW(dev, AD_AC97_ACIC, stat); 784 return 0; 785} 786 787/************************* PCI interfaces ****************************** */ 788/* PCI device table */ 789static struct pci_device_id ad1889_id_tbl[] = { 790 { PCI_VENDOR_ID_ANALOG_DEVICES, PCI_DEVICE_ID_AD1889JS, PCI_ANY_ID, 791 PCI_ANY_ID, 0, 0, (unsigned long)DEVNAME }, 792 { }, 793}; 794MODULE_DEVICE_TABLE(pci, ad1889_id_tbl); 795 796static irqreturn_t ad1889_interrupt(int irq, void *dev_id) 797{ 798 u32 stat; 799 ad1889_dev_t *dev = (ad1889_dev_t *)dev_id; 800 801 stat = AD1889_READL(dev, AD_DMA_DISR); 802 803 /* clear ISR */ 804 AD1889_WRITEL(dev, AD_DMA_DISR, stat); 805 806 if (stat & 0x8) { /* WAVI */ 807 DBG("WAV interrupt\n"); 808 dev->stats.wav_intrs++; 809 if (dev->state[AD_WAV_STATE].dmabuf.ready) { 810 ad1889_stop_wav(&dev->state[AD_WAV_STATE]); /* clean up */ 811 ad1889_start_wav(&dev->state[AD_WAV_STATE]); /* start new */ 812 } 813 } 814 815 if ((stat & 0x2) && dev->state[AD_ADC_STATE].dmabuf.ready) { /* ADCI */ 816 DBG("ADC interrupt\n"); 817 dev->stats.adc_intrs++; 818 } 819 if(stat) 820 return IRQ_HANDLED; 821 return IRQ_NONE; 822} 823 824static void ad1889_initcfg(ad1889_dev_t *dev) 825{ 826 u16 tmp16; 827 u32 tmp32; 828 829 /* make sure the interrupt bits are setup the way we want */ 830 tmp32 = AD1889_READL(dev, AD_DMA_WAVCTRL); 831 tmp32 &= ~0xff; /* flat dma, no sg, mask out the intr bits */ 832 tmp32 |= 0x6; /* intr on count, loop */ 833 AD1889_WRITEL(dev, AD_DMA_WAVCTRL, tmp32); 834 835 /* unmute... */ 836 tmp16 = AD1889_READW(dev, AD_DS_WADA); 837 tmp16 &= ~0x8080; 838 AD1889_WRITEW(dev, AD_DS_WADA, tmp16); 839} 840 841static int __devinit ad1889_probe(struct pci_dev *pcidev, const struct pci_device_id *ent) 842{ 843 int err; 844 ad1889_dev_t *dev; 845 unsigned long bar; 846 struct proc_dir_entry *proc_root = NULL; 847 848 if ((err = pci_enable_device(pcidev)) != 0) { 849 printk(KERN_ERR DEVNAME ": pci_enable_device failed\n"); 850 return err; 851 } 852 853 pci_set_master(pcidev); 854 if ((dev = ad1889_alloc_dev(pcidev)) == NULL) { 855 printk(KERN_ERR DEVNAME ": cannot allocate memory for device\n"); 856 return -ENOMEM; 857 } 858 pci_set_drvdata(pcidev, dev); 859 bar = pci_resource_start(pcidev, 0); 860 861 if (!(pci_resource_flags(pcidev, 0) & IORESOURCE_MEM)) { 862 printk(KERN_ERR DEVNAME ": memory region not assigned\n"); 863 goto out1; 864 } 865 866 if (pci_request_region(pcidev, 0, DEVNAME)) { 867 printk(KERN_ERR DEVNAME ": unable to request memory region\n"); 868 goto out1; 869 } 870 871 dev->regbase = ioremap_nocache(bar, AD_DS_IOMEMSIZE); 872 if (!dev->regbase) { 873 printk(KERN_ERR DEVNAME ": unable to remap iomem\n"); 874 goto out2; 875 } 876 877 if (request_irq(pcidev->irq, ad1889_interrupt, IRQF_SHARED, DEVNAME, dev) != 0) { 878 printk(KERN_ERR DEVNAME ": unable to request interrupt\n"); 879 goto out3; 880 } 881 882 printk(KERN_INFO DEVNAME ": %s at %p IRQ %d\n", 883 (char *)ent->driver_data, dev->regbase, pcidev->irq); 884 885 if (ad1889_aclink_reset(pcidev) != 0) 886 goto out4; 887 888 /* register /dev/dsp */ 889 if ((dev->dev_audio = register_sound_dsp(&ad1889_fops, -1)) < 0) { 890 printk(KERN_ERR DEVNAME ": cannot register /dev/dsp\n"); 891 goto out4; 892 } 893 894 if ((err = ad1889_ac97_init(dev, 0)) != 0) 895 goto out5; 896 897 if (((proc_root = proc_mkdir("driver/ad1889", NULL)) == NULL) || 898 create_proc_read_entry("ac97", S_IFREG|S_IRUGO, proc_root, ac97_read_proc, dev->ac97_codec) == NULL || 899 create_proc_read_entry("info", S_IFREG|S_IRUGO, proc_root, ad1889_read_proc, dev) == NULL) 900 goto out5; 901 902 ad1889_initcfg(dev); 903 904 //DBG(DEVNAME ": Driver initialization done!\n"); 905 906 ad1889_dev = dev; 907 908 return 0; 909 910out5: 911 unregister_sound_dsp(dev->dev_audio); 912out4: 913 free_irq(pcidev->irq, dev); 914out3: 915 iounmap(dev->regbase); 916out2: 917 pci_release_region(pcidev, 0); 918out1: 919 ad1889_free_dev(dev); 920 pci_set_drvdata(pcidev, NULL); 921 922 return -ENODEV; 923} 924 925static void __devexit ad1889_remove(struct pci_dev *pcidev) 926{ 927 ad1889_dev_t *dev = pci_get_drvdata(pcidev); 928 929 if (dev == NULL) return; 930 931 unregister_sound_mixer(dev->ac97_codec->dev_mixer); 932 unregister_sound_dsp(dev->dev_audio); 933 free_irq(pcidev->irq, dev); 934 iounmap(dev->regbase); 935 pci_release_region(pcidev, 0); 936 937 /* any hw programming needed? */ 938 ad1889_free_dev(dev); 939 pci_set_drvdata(pcidev, NULL); 940} 941 942MODULE_AUTHOR("Randolph Chung"); 943MODULE_DESCRIPTION("Analog Devices AD1889 PCI Audio"); 944MODULE_LICENSE("GPL"); 945 946static struct pci_driver ad1889_driver = { 947 .name = DEVNAME, 948 .id_table = ad1889_id_tbl, 949 .probe = ad1889_probe, 950 .remove = __devexit_p(ad1889_remove), 951}; 952 953static int __init ad1889_init_module(void) 954{ 955 return pci_register_driver(&ad1889_driver); 956} 957 958static void ad1889_exit_module(void) 959{ 960 pci_unregister_driver(&ad1889_driver); 961 return; 962} 963 964module_init(ad1889_init_module); 965module_exit(ad1889_exit_module); 966