1 /* Hewlett-Packard Harmony audio driver 2 * 3 * This is a driver for the Harmony audio chipset found 4 * on the LASI ASIC of various early HP PA-RISC workstations. 5 * 6 * Copyright (C) 2004, Kyle McMartin <kyle@{debian.org,parisc-linux.org}> 7 * 8 * Based on the previous Harmony incarnations by, 9 * Copyright 2000 (c) Linuxcare Canada, Alex deVries 10 * Copyright 2000-2003 (c) Helge Deller 11 * Copyright 2001 (c) Matthieu Delahaye 12 * Copyright 2001 (c) Jean-Christophe Vaugeois 13 * Copyright 2003 (c) Laurent Canet 14 * Copyright 2004 (c) Stuart Brady 15 * 16 * This program is free software; you can redistribute it and/or modify 17 * it under the terms of the GNU General Public License, version 2, as 18 * published by the Free Software Foundation. 19 * 20 * This program is distributed in the hope that it will be useful, 21 * but WITHOUT ANY WARRANTY; without even the implied warranty of 22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 23 * GNU General Public License for more details. 24 * 25 * You should have received a copy of the GNU General Public License 26 * along with this program; if not, write to the Free Software 27 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 28 * 29 * Notes: 30 * - graveyard and silence buffers last for lifetime of 31 * the driver. playback and capture buffers are allocated 32 * per _open()/_close(). 33 * 34 * TODO: 35 * 36 */ 37 38 #include <linux/init.h> 39 #include <linux/slab.h> 40 #include <linux/time.h> 41 #include <linux/wait.h> 42 #include <linux/delay.h> 43 #include <linux/module.h> 44 #include <linux/interrupt.h> 45 #include <linux/spinlock.h> 46 #include <linux/dma-mapping.h> 47 #include <linux/io.h> 48 49 #include <sound/core.h> 50 #include <sound/pcm.h> 51 #include <sound/control.h> 52 #include <sound/rawmidi.h> 53 #include <sound/initval.h> 54 #include <sound/info.h> 55 56 #include <asm/hardware.h> 57 #include <asm/parisc-device.h> 58 59 #include "harmony.h" 60 61 static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */ 62 static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */ 63 module_param(index, int, 0444); 64 MODULE_PARM_DESC(index, "Index value for Harmony driver."); 65 module_param(id, charp, 0444); 66 MODULE_PARM_DESC(id, "ID string for Harmony driver."); 67 68 69 static struct parisc_device_id snd_harmony_devtable[] = { 70 /* bushmaster / flounder */ 71 { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0007A }, 72 /* 712 / 715 */ 73 { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0007B }, 74 /* pace */ 75 { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0007E }, 76 /* outfield / coral II */ 77 { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0007F }, 78 { 0, } 79 }; 80 81 MODULE_DEVICE_TABLE(parisc, snd_harmony_devtable); 82 83 #define NAME "harmony" 84 #define PFX NAME ": " 85 86 static unsigned int snd_harmony_rates[] = { 87 5512, 6615, 8000, 9600, 88 11025, 16000, 18900, 22050, 89 27428, 32000, 33075, 37800, 90 44100, 48000 91 }; 92 93 static unsigned int rate_bits[14] = { 94 HARMONY_SR_5KHZ, HARMONY_SR_6KHZ, HARMONY_SR_8KHZ, 95 HARMONY_SR_9KHZ, HARMONY_SR_11KHZ, HARMONY_SR_16KHZ, 96 HARMONY_SR_18KHZ, HARMONY_SR_22KHZ, HARMONY_SR_27KHZ, 97 HARMONY_SR_32KHZ, HARMONY_SR_33KHZ, HARMONY_SR_37KHZ, 98 HARMONY_SR_44KHZ, HARMONY_SR_48KHZ 99 }; 100 101 static struct snd_pcm_hw_constraint_list hw_constraint_rates = { 102 .count = ARRAY_SIZE(snd_harmony_rates), 103 .list = snd_harmony_rates, 104 .mask = 0, 105 }; 106 107 static inline unsigned long 108 harmony_read(struct snd_harmony *h, unsigned r) 109 { 110 return __raw_readl(h->iobase + r); 111 } 112 113 static inline void 114 harmony_write(struct snd_harmony *h, unsigned r, unsigned long v) 115 { 116 __raw_writel(v, h->iobase + r); 117 } 118 119 static inline void 120 harmony_wait_for_control(struct snd_harmony *h) 121 { 122 while (harmony_read(h, HARMONY_CNTL) & HARMONY_CNTL_C) ; 123 } 124 125 static inline void 126 harmony_reset(struct snd_harmony *h) 127 { 128 harmony_write(h, HARMONY_RESET, 1); 129 mdelay(50); 130 harmony_write(h, HARMONY_RESET, 0); 131 } 132 133 static void 134 harmony_disable_interrupts(struct snd_harmony *h) 135 { 136 u32 dstatus; 137 harmony_wait_for_control(h); 138 dstatus = harmony_read(h, HARMONY_DSTATUS); 139 dstatus &= ~HARMONY_DSTATUS_IE; 140 harmony_write(h, HARMONY_DSTATUS, dstatus); 141 } 142 143 static void 144 harmony_enable_interrupts(struct snd_harmony *h) 145 { 146 u32 dstatus; 147 harmony_wait_for_control(h); 148 dstatus = harmony_read(h, HARMONY_DSTATUS); 149 dstatus |= HARMONY_DSTATUS_IE; 150 harmony_write(h, HARMONY_DSTATUS, dstatus); 151 } 152 153 static void 154 harmony_mute(struct snd_harmony *h) 155 { 156 unsigned long flags; 157 158 spin_lock_irqsave(&h->mixer_lock, flags); 159 harmony_wait_for_control(h); 160 harmony_write(h, HARMONY_GAINCTL, HARMONY_GAIN_SILENCE); 161 spin_unlock_irqrestore(&h->mixer_lock, flags); 162 } 163 164 static void 165 harmony_unmute(struct snd_harmony *h) 166 { 167 unsigned long flags; 168 169 spin_lock_irqsave(&h->mixer_lock, flags); 170 harmony_wait_for_control(h); 171 harmony_write(h, HARMONY_GAINCTL, h->st.gain); 172 spin_unlock_irqrestore(&h->mixer_lock, flags); 173 } 174 175 static void 176 harmony_set_control(struct snd_harmony *h) 177 { 178 u32 ctrl; 179 unsigned long flags; 180 181 spin_lock_irqsave(&h->lock, flags); 182 183 ctrl = (HARMONY_CNTL_C | 184 (h->st.format << 6) | 185 (h->st.stereo << 5) | 186 (h->st.rate)); 187 188 harmony_wait_for_control(h); 189 harmony_write(h, HARMONY_CNTL, ctrl); 190 191 spin_unlock_irqrestore(&h->lock, flags); 192 } 193 194 static irqreturn_t 195 snd_harmony_interrupt(int irq, void *dev) 196 { 197 u32 dstatus; 198 struct snd_harmony *h = dev; 199 200 spin_lock(&h->lock); 201 harmony_disable_interrupts(h); 202 harmony_wait_for_control(h); 203 dstatus = harmony_read(h, HARMONY_DSTATUS); 204 spin_unlock(&h->lock); 205 206 if (dstatus & HARMONY_DSTATUS_PN) { 207 if (h->psubs && h->st.playing) { 208 spin_lock(&h->lock); 209 h->pbuf.buf += h->pbuf.count; /* PAGE_SIZE */ 210 h->pbuf.buf %= h->pbuf.size; /* MAX_BUFS*PAGE_SIZE */ 211 212 harmony_write(h, HARMONY_PNXTADD, 213 h->pbuf.addr + h->pbuf.buf); 214 h->stats.play_intr++; 215 spin_unlock(&h->lock); 216 snd_pcm_period_elapsed(h->psubs); 217 } else { 218 spin_lock(&h->lock); 219 harmony_write(h, HARMONY_PNXTADD, h->sdma.addr); 220 h->stats.silence_intr++; 221 spin_unlock(&h->lock); 222 } 223 } 224 225 if (dstatus & HARMONY_DSTATUS_RN) { 226 if (h->csubs && h->st.capturing) { 227 spin_lock(&h->lock); 228 h->cbuf.buf += h->cbuf.count; 229 h->cbuf.buf %= h->cbuf.size; 230 231 harmony_write(h, HARMONY_RNXTADD, 232 h->cbuf.addr + h->cbuf.buf); 233 h->stats.rec_intr++; 234 spin_unlock(&h->lock); 235 snd_pcm_period_elapsed(h->csubs); 236 } else { 237 spin_lock(&h->lock); 238 harmony_write(h, HARMONY_RNXTADD, h->gdma.addr); 239 h->stats.graveyard_intr++; 240 spin_unlock(&h->lock); 241 } 242 } 243 244 spin_lock(&h->lock); 245 harmony_enable_interrupts(h); 246 spin_unlock(&h->lock); 247 248 return IRQ_HANDLED; 249 } 250 251 static unsigned int 252 snd_harmony_rate_bits(int rate) 253 { 254 unsigned int i; 255 256 for (i = 0; i < ARRAY_SIZE(snd_harmony_rates); i++) 257 if (snd_harmony_rates[i] == rate) 258 return rate_bits[i]; 259 260 return HARMONY_SR_44KHZ; 261 } 262 263 static struct snd_pcm_hardware snd_harmony_playback = 264 { 265 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 266 SNDRV_PCM_INFO_JOINT_DUPLEX | SNDRV_PCM_INFO_MMAP_VALID | 267 SNDRV_PCM_INFO_BLOCK_TRANSFER), 268 .formats = (SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_MU_LAW | 269 SNDRV_PCM_FMTBIT_A_LAW), 270 .rates = (SNDRV_PCM_RATE_5512 | SNDRV_PCM_RATE_8000_48000 | 271 SNDRV_PCM_RATE_KNOT), 272 .rate_min = 5512, 273 .rate_max = 48000, 274 .channels_min = 1, 275 .channels_max = 2, 276 .buffer_bytes_max = MAX_BUF_SIZE, 277 .period_bytes_min = BUF_SIZE, 278 .period_bytes_max = BUF_SIZE, 279 .periods_min = 1, 280 .periods_max = MAX_BUFS, 281 .fifo_size = 0, 282 }; 283 284 static struct snd_pcm_hardware snd_harmony_capture = 285 { 286 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 287 SNDRV_PCM_INFO_JOINT_DUPLEX | SNDRV_PCM_INFO_MMAP_VALID | 288 SNDRV_PCM_INFO_BLOCK_TRANSFER), 289 .formats = (SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_MU_LAW | 290 SNDRV_PCM_FMTBIT_A_LAW), 291 .rates = (SNDRV_PCM_RATE_5512 | SNDRV_PCM_RATE_8000_48000 | 292 SNDRV_PCM_RATE_KNOT), 293 .rate_min = 5512, 294 .rate_max = 48000, 295 .channels_min = 1, 296 .channels_max = 2, 297 .buffer_bytes_max = MAX_BUF_SIZE, 298 .period_bytes_min = BUF_SIZE, 299 .period_bytes_max = BUF_SIZE, 300 .periods_min = 1, 301 .periods_max = MAX_BUFS, 302 .fifo_size = 0, 303 }; 304 305 static int 306 snd_harmony_playback_trigger(struct snd_pcm_substream *ss, int cmd) 307 { 308 struct snd_harmony *h = snd_pcm_substream_chip(ss); 309 310 if (h->st.capturing) 311 return -EBUSY; 312 313 spin_lock(&h->lock); 314 switch (cmd) { 315 case SNDRV_PCM_TRIGGER_START: 316 h->st.playing = 1; 317 harmony_write(h, HARMONY_PNXTADD, h->pbuf.addr); 318 harmony_write(h, HARMONY_RNXTADD, h->gdma.addr); 319 harmony_unmute(h); 320 harmony_enable_interrupts(h); 321 break; 322 case SNDRV_PCM_TRIGGER_STOP: 323 h->st.playing = 0; 324 harmony_mute(h); 325 harmony_write(h, HARMONY_PNXTADD, h->sdma.addr); 326 harmony_disable_interrupts(h); 327 break; 328 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 329 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 330 case SNDRV_PCM_TRIGGER_SUSPEND: 331 default: 332 spin_unlock(&h->lock); 333 snd_BUG(); 334 return -EINVAL; 335 } 336 spin_unlock(&h->lock); 337 338 return 0; 339 } 340 341 static int 342 snd_harmony_capture_trigger(struct snd_pcm_substream *ss, int cmd) 343 { 344 struct snd_harmony *h = snd_pcm_substream_chip(ss); 345 346 if (h->st.playing) 347 return -EBUSY; 348 349 spin_lock(&h->lock); 350 switch (cmd) { 351 case SNDRV_PCM_TRIGGER_START: 352 h->st.capturing = 1; 353 harmony_write(h, HARMONY_PNXTADD, h->sdma.addr); 354 harmony_write(h, HARMONY_RNXTADD, h->cbuf.addr); 355 harmony_unmute(h); 356 harmony_enable_interrupts(h); 357 break; 358 case SNDRV_PCM_TRIGGER_STOP: 359 h->st.capturing = 0; 360 harmony_mute(h); 361 harmony_write(h, HARMONY_RNXTADD, h->gdma.addr); 362 harmony_disable_interrupts(h); 363 break; 364 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 365 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 366 case SNDRV_PCM_TRIGGER_SUSPEND: 367 default: 368 spin_unlock(&h->lock); 369 snd_BUG(); 370 return -EINVAL; 371 } 372 spin_unlock(&h->lock); 373 374 return 0; 375 } 376 377 static int 378 snd_harmony_set_data_format(struct snd_harmony *h, int fmt, int force) 379 { 380 int o = h->st.format; 381 int n; 382 383 switch(fmt) { 384 case SNDRV_PCM_FORMAT_S16_BE: 385 n = HARMONY_DF_16BIT_LINEAR; 386 break; 387 case SNDRV_PCM_FORMAT_A_LAW: 388 n = HARMONY_DF_8BIT_ALAW; 389 break; 390 case SNDRV_PCM_FORMAT_MU_LAW: 391 n = HARMONY_DF_8BIT_ULAW; 392 break; 393 default: 394 n = HARMONY_DF_16BIT_LINEAR; 395 break; 396 } 397 398 if (force || o != n) { 399 snd_pcm_format_set_silence(fmt, h->sdma.area, SILENCE_BUFSZ / 400 (snd_pcm_format_physical_width(fmt) 401 / 8)); 402 } 403 404 return n; 405 } 406 407 static int 408 snd_harmony_playback_prepare(struct snd_pcm_substream *ss) 409 { 410 struct snd_harmony *h = snd_pcm_substream_chip(ss); 411 struct snd_pcm_runtime *rt = ss->runtime; 412 413 if (h->st.capturing) 414 return -EBUSY; 415 416 h->pbuf.size = snd_pcm_lib_buffer_bytes(ss); 417 h->pbuf.count = snd_pcm_lib_period_bytes(ss); 418 if (h->pbuf.buf >= h->pbuf.size) 419 h->pbuf.buf = 0; 420 h->st.playing = 0; 421 422 h->st.rate = snd_harmony_rate_bits(rt->rate); 423 h->st.format = snd_harmony_set_data_format(h, rt->format, 0); 424 425 if (rt->channels == 2) 426 h->st.stereo = HARMONY_SS_STEREO; 427 else 428 h->st.stereo = HARMONY_SS_MONO; 429 430 harmony_set_control(h); 431 432 h->pbuf.addr = rt->dma_addr; 433 434 return 0; 435 } 436 437 static int 438 snd_harmony_capture_prepare(struct snd_pcm_substream *ss) 439 { 440 struct snd_harmony *h = snd_pcm_substream_chip(ss); 441 struct snd_pcm_runtime *rt = ss->runtime; 442 443 if (h->st.playing) 444 return -EBUSY; 445 446 h->cbuf.size = snd_pcm_lib_buffer_bytes(ss); 447 h->cbuf.count = snd_pcm_lib_period_bytes(ss); 448 if (h->cbuf.buf >= h->cbuf.size) 449 h->cbuf.buf = 0; 450 h->st.capturing = 0; 451 452 h->st.rate = snd_harmony_rate_bits(rt->rate); 453 h->st.format = snd_harmony_set_data_format(h, rt->format, 0); 454 455 if (rt->channels == 2) 456 h->st.stereo = HARMONY_SS_STEREO; 457 else 458 h->st.stereo = HARMONY_SS_MONO; 459 460 harmony_set_control(h); 461 462 h->cbuf.addr = rt->dma_addr; 463 464 return 0; 465 } 466 467 static snd_pcm_uframes_t 468 snd_harmony_playback_pointer(struct snd_pcm_substream *ss) 469 { 470 struct snd_pcm_runtime *rt = ss->runtime; 471 struct snd_harmony *h = snd_pcm_substream_chip(ss); 472 unsigned long pcuradd; 473 unsigned long played; 474 475 if (!(h->st.playing) || (h->psubs == NULL)) 476 return 0; 477 478 if ((h->pbuf.addr == 0) || (h->pbuf.size == 0)) 479 return 0; 480 481 pcuradd = harmony_read(h, HARMONY_PCURADD); 482 played = pcuradd - h->pbuf.addr; 483 484 #ifdef HARMONY_DEBUG 485 printk(KERN_DEBUG PFX "playback_pointer is 0x%lx-0x%lx = %d bytes\n", 486 pcuradd, h->pbuf.addr, played); 487 #endif 488 489 if (pcuradd > h->pbuf.addr + h->pbuf.size) { 490 return 0; 491 } 492 493 return bytes_to_frames(rt, played); 494 } 495 496 static snd_pcm_uframes_t 497 snd_harmony_capture_pointer(struct snd_pcm_substream *ss) 498 { 499 struct snd_pcm_runtime *rt = ss->runtime; 500 struct snd_harmony *h = snd_pcm_substream_chip(ss); 501 unsigned long rcuradd; 502 unsigned long caught; 503 504 if (!(h->st.capturing) || (h->csubs == NULL)) 505 return 0; 506 507 if ((h->cbuf.addr == 0) || (h->cbuf.size == 0)) 508 return 0; 509 510 rcuradd = harmony_read(h, HARMONY_RCURADD); 511 caught = rcuradd - h->cbuf.addr; 512 513 #ifdef HARMONY_DEBUG 514 printk(KERN_DEBUG PFX "capture_pointer is 0x%lx-0x%lx = %d bytes\n", 515 rcuradd, h->cbuf.addr, caught); 516 #endif 517 518 if (rcuradd > h->cbuf.addr + h->cbuf.size) { 519 return 0; 520 } 521 522 return bytes_to_frames(rt, caught); 523 } 524 525 static int 526 snd_harmony_playback_open(struct snd_pcm_substream *ss) 527 { 528 struct snd_harmony *h = snd_pcm_substream_chip(ss); 529 struct snd_pcm_runtime *rt = ss->runtime; 530 int err; 531 532 h->psubs = ss; 533 rt->hw = snd_harmony_playback; 534 snd_pcm_hw_constraint_list(rt, 0, SNDRV_PCM_HW_PARAM_RATE, 535 &hw_constraint_rates); 536 537 err = snd_pcm_hw_constraint_integer(rt, SNDRV_PCM_HW_PARAM_PERIODS); 538 if (err < 0) 539 return err; 540 541 return 0; 542 } 543 544 static int 545 snd_harmony_capture_open(struct snd_pcm_substream *ss) 546 { 547 struct snd_harmony *h = snd_pcm_substream_chip(ss); 548 struct snd_pcm_runtime *rt = ss->runtime; 549 int err; 550 551 h->csubs = ss; 552 rt->hw = snd_harmony_capture; 553 snd_pcm_hw_constraint_list(rt, 0, SNDRV_PCM_HW_PARAM_RATE, 554 &hw_constraint_rates); 555 556 err = snd_pcm_hw_constraint_integer(rt, SNDRV_PCM_HW_PARAM_PERIODS); 557 if (err < 0) 558 return err; 559 560 return 0; 561 } 562 563 static int 564 snd_harmony_playback_close(struct snd_pcm_substream *ss) 565 { 566 struct snd_harmony *h = snd_pcm_substream_chip(ss); 567 h->psubs = NULL; 568 return 0; 569 } 570 571 static int 572 snd_harmony_capture_close(struct snd_pcm_substream *ss) 573 { 574 struct snd_harmony *h = snd_pcm_substream_chip(ss); 575 h->csubs = NULL; 576 return 0; 577 } 578 579 static int 580 snd_harmony_hw_params(struct snd_pcm_substream *ss, 581 struct snd_pcm_hw_params *hw) 582 { 583 int err; 584 struct snd_harmony *h = snd_pcm_substream_chip(ss); 585 586 err = snd_pcm_lib_malloc_pages(ss, params_buffer_bytes(hw)); 587 if (err > 0 && h->dma.type == SNDRV_DMA_TYPE_CONTINUOUS) 588 ss->runtime->dma_addr = __pa(ss->runtime->dma_area); 589 590 return err; 591 } 592 593 static int 594 snd_harmony_hw_free(struct snd_pcm_substream *ss) 595 { 596 return snd_pcm_lib_free_pages(ss); 597 } 598 599 static struct snd_pcm_ops snd_harmony_playback_ops = { 600 .open = snd_harmony_playback_open, 601 .close = snd_harmony_playback_close, 602 .ioctl = snd_pcm_lib_ioctl, 603 .hw_params = snd_harmony_hw_params, 604 .hw_free = snd_harmony_hw_free, 605 .prepare = snd_harmony_playback_prepare, 606 .trigger = snd_harmony_playback_trigger, 607 .pointer = snd_harmony_playback_pointer, 608 }; 609 610 static struct snd_pcm_ops snd_harmony_capture_ops = { 611 .open = snd_harmony_capture_open, 612 .close = snd_harmony_capture_close, 613 .ioctl = snd_pcm_lib_ioctl, 614 .hw_params = snd_harmony_hw_params, 615 .hw_free = snd_harmony_hw_free, 616 .prepare = snd_harmony_capture_prepare, 617 .trigger = snd_harmony_capture_trigger, 618 .pointer = snd_harmony_capture_pointer, 619 }; 620 621 static int 622 snd_harmony_pcm_init(struct snd_harmony *h) 623 { 624 struct snd_pcm *pcm; 625 int err; 626 627 if (snd_BUG_ON(!h)) 628 return -EINVAL; 629 630 harmony_disable_interrupts(h); 631 632 err = snd_pcm_new(h->card, "harmony", 0, 1, 1, &pcm); 633 if (err < 0) 634 return err; 635 636 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 637 &snd_harmony_playback_ops); 638 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 639 &snd_harmony_capture_ops); 640 641 pcm->private_data = h; 642 pcm->info_flags = 0; 643 strcpy(pcm->name, "harmony"); 644 h->pcm = pcm; 645 646 h->psubs = NULL; 647 h->csubs = NULL; 648 649 /* initialize graveyard buffer */ 650 h->dma.type = SNDRV_DMA_TYPE_DEV; 651 h->dma.dev = &h->dev->dev; 652 err = snd_dma_alloc_pages(h->dma.type, 653 h->dma.dev, 654 BUF_SIZE*GRAVEYARD_BUFS, 655 &h->gdma); 656 if (err < 0) { 657 printk(KERN_ERR PFX "cannot allocate graveyard buffer!\n"); 658 return err; 659 } 660 661 /* initialize silence buffers */ 662 err = snd_dma_alloc_pages(h->dma.type, 663 h->dma.dev, 664 BUF_SIZE*SILENCE_BUFS, 665 &h->sdma); 666 if (err < 0) { 667 printk(KERN_ERR PFX "cannot allocate silence buffer!\n"); 668 return err; 669 } 670 671 /* pre-allocate space for DMA */ 672 err = snd_pcm_lib_preallocate_pages_for_all(pcm, h->dma.type, 673 h->dma.dev, 674 MAX_BUF_SIZE, 675 MAX_BUF_SIZE); 676 if (err < 0) { 677 printk(KERN_ERR PFX "buffer allocation error: %d\n", err); 678 return err; 679 } 680 681 h->st.format = snd_harmony_set_data_format(h, 682 SNDRV_PCM_FORMAT_S16_BE, 1); 683 684 return 0; 685 } 686 687 static void 688 snd_harmony_set_new_gain(struct snd_harmony *h) 689 { 690 harmony_wait_for_control(h); 691 harmony_write(h, HARMONY_GAINCTL, h->st.gain); 692 } 693 694 static int 695 snd_harmony_mixercontrol_info(struct snd_kcontrol *kc, 696 struct snd_ctl_elem_info *uinfo) 697 { 698 int mask = (kc->private_value >> 16) & 0xff; 699 int left_shift = (kc->private_value) & 0xff; 700 int right_shift = (kc->private_value >> 8) & 0xff; 701 702 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : 703 SNDRV_CTL_ELEM_TYPE_INTEGER; 704 uinfo->count = left_shift == right_shift ? 1 : 2; 705 uinfo->value.integer.min = 0; 706 uinfo->value.integer.max = mask; 707 708 return 0; 709 } 710 711 static int 712 snd_harmony_volume_get(struct snd_kcontrol *kc, 713 struct snd_ctl_elem_value *ucontrol) 714 { 715 struct snd_harmony *h = snd_kcontrol_chip(kc); 716 int shift_left = (kc->private_value) & 0xff; 717 int shift_right = (kc->private_value >> 8) & 0xff; 718 int mask = (kc->private_value >> 16) & 0xff; 719 int invert = (kc->private_value >> 24) & 0xff; 720 int left, right; 721 722 spin_lock_irq(&h->mixer_lock); 723 724 left = (h->st.gain >> shift_left) & mask; 725 right = (h->st.gain >> shift_right) & mask; 726 if (invert) { 727 left = mask - left; 728 right = mask - right; 729 } 730 731 ucontrol->value.integer.value[0] = left; 732 if (shift_left != shift_right) 733 ucontrol->value.integer.value[1] = right; 734 735 spin_unlock_irq(&h->mixer_lock); 736 737 return 0; 738 } 739 740 static int 741 snd_harmony_volume_put(struct snd_kcontrol *kc, 742 struct snd_ctl_elem_value *ucontrol) 743 { 744 struct snd_harmony *h = snd_kcontrol_chip(kc); 745 int shift_left = (kc->private_value) & 0xff; 746 int shift_right = (kc->private_value >> 8) & 0xff; 747 int mask = (kc->private_value >> 16) & 0xff; 748 int invert = (kc->private_value >> 24) & 0xff; 749 int left, right; 750 int old_gain = h->st.gain; 751 752 spin_lock_irq(&h->mixer_lock); 753 754 left = ucontrol->value.integer.value[0] & mask; 755 if (invert) 756 left = mask - left; 757 h->st.gain &= ~( (mask << shift_left ) ); 758 h->st.gain |= (left << shift_left); 759 760 if (shift_left != shift_right) { 761 right = ucontrol->value.integer.value[1] & mask; 762 if (invert) 763 right = mask - right; 764 h->st.gain &= ~( (mask << shift_right) ); 765 h->st.gain |= (right << shift_right); 766 } 767 768 snd_harmony_set_new_gain(h); 769 770 spin_unlock_irq(&h->mixer_lock); 771 772 return h->st.gain != old_gain; 773 } 774 775 static int 776 snd_harmony_captureroute_info(struct snd_kcontrol *kc, 777 struct snd_ctl_elem_info *uinfo) 778 { 779 static const char * const texts[2] = { "Line", "Mic" }; 780 781 return snd_ctl_enum_info(uinfo, 1, 2, texts); 782 } 783 784 static int 785 snd_harmony_captureroute_get(struct snd_kcontrol *kc, 786 struct snd_ctl_elem_value *ucontrol) 787 { 788 struct snd_harmony *h = snd_kcontrol_chip(kc); 789 int value; 790 791 spin_lock_irq(&h->mixer_lock); 792 793 value = (h->st.gain >> HARMONY_GAIN_IS_SHIFT) & 1; 794 ucontrol->value.enumerated.item[0] = value; 795 796 spin_unlock_irq(&h->mixer_lock); 797 798 return 0; 799 } 800 801 static int 802 snd_harmony_captureroute_put(struct snd_kcontrol *kc, 803 struct snd_ctl_elem_value *ucontrol) 804 { 805 struct snd_harmony *h = snd_kcontrol_chip(kc); 806 int value; 807 int old_gain = h->st.gain; 808 809 spin_lock_irq(&h->mixer_lock); 810 811 value = ucontrol->value.enumerated.item[0] & 1; 812 h->st.gain &= ~HARMONY_GAIN_IS_MASK; 813 h->st.gain |= value << HARMONY_GAIN_IS_SHIFT; 814 815 snd_harmony_set_new_gain(h); 816 817 spin_unlock_irq(&h->mixer_lock); 818 819 return h->st.gain != old_gain; 820 } 821 822 #define HARMONY_CONTROLS ARRAY_SIZE(snd_harmony_controls) 823 824 #define HARMONY_VOLUME(xname, left_shift, right_shift, mask, invert) \ 825 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \ 826 .info = snd_harmony_mixercontrol_info, \ 827 .get = snd_harmony_volume_get, .put = snd_harmony_volume_put, \ 828 .private_value = ((left_shift) | ((right_shift) << 8) | \ 829 ((mask) << 16) | ((invert) << 24)) } 830 831 static struct snd_kcontrol_new snd_harmony_controls[] = { 832 HARMONY_VOLUME("Master Playback Volume", HARMONY_GAIN_LO_SHIFT, 833 HARMONY_GAIN_RO_SHIFT, HARMONY_GAIN_OUT, 1), 834 HARMONY_VOLUME("Capture Volume", HARMONY_GAIN_LI_SHIFT, 835 HARMONY_GAIN_RI_SHIFT, HARMONY_GAIN_IN, 0), 836 HARMONY_VOLUME("Monitor Volume", HARMONY_GAIN_MA_SHIFT, 837 HARMONY_GAIN_MA_SHIFT, HARMONY_GAIN_MA, 1), 838 { 839 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 840 .name = "Input Route", 841 .info = snd_harmony_captureroute_info, 842 .get = snd_harmony_captureroute_get, 843 .put = snd_harmony_captureroute_put 844 }, 845 HARMONY_VOLUME("Internal Speaker Switch", HARMONY_GAIN_SE_SHIFT, 846 HARMONY_GAIN_SE_SHIFT, 1, 0), 847 HARMONY_VOLUME("Line-Out Switch", HARMONY_GAIN_LE_SHIFT, 848 HARMONY_GAIN_LE_SHIFT, 1, 0), 849 HARMONY_VOLUME("Headphones Switch", HARMONY_GAIN_HE_SHIFT, 850 HARMONY_GAIN_HE_SHIFT, 1, 0), 851 }; 852 853 static void 854 snd_harmony_mixer_reset(struct snd_harmony *h) 855 { 856 harmony_mute(h); 857 harmony_reset(h); 858 h->st.gain = HARMONY_GAIN_DEFAULT; 859 harmony_unmute(h); 860 } 861 862 static int 863 snd_harmony_mixer_init(struct snd_harmony *h) 864 { 865 struct snd_card *card; 866 int idx, err; 867 868 if (snd_BUG_ON(!h)) 869 return -EINVAL; 870 card = h->card; 871 strcpy(card->mixername, "Harmony Gain control interface"); 872 873 for (idx = 0; idx < HARMONY_CONTROLS; idx++) { 874 err = snd_ctl_add(card, 875 snd_ctl_new1(&snd_harmony_controls[idx], h)); 876 if (err < 0) 877 return err; 878 } 879 880 snd_harmony_mixer_reset(h); 881 882 return 0; 883 } 884 885 static int 886 snd_harmony_free(struct snd_harmony *h) 887 { 888 if (h->gdma.addr) 889 snd_dma_free_pages(&h->gdma); 890 if (h->sdma.addr) 891 snd_dma_free_pages(&h->sdma); 892 893 if (h->irq >= 0) 894 free_irq(h->irq, h); 895 896 iounmap(h->iobase); 897 kfree(h); 898 return 0; 899 } 900 901 static int 902 snd_harmony_dev_free(struct snd_device *dev) 903 { 904 struct snd_harmony *h = dev->device_data; 905 return snd_harmony_free(h); 906 } 907 908 static int 909 snd_harmony_create(struct snd_card *card, 910 struct parisc_device *padev, 911 struct snd_harmony **rchip) 912 { 913 int err; 914 struct snd_harmony *h; 915 static struct snd_device_ops ops = { 916 .dev_free = snd_harmony_dev_free, 917 }; 918 919 *rchip = NULL; 920 921 h = kzalloc(sizeof(*h), GFP_KERNEL); 922 if (h == NULL) 923 return -ENOMEM; 924 925 h->hpa = padev->hpa.start; 926 h->card = card; 927 h->dev = padev; 928 h->irq = -1; 929 h->iobase = ioremap_nocache(padev->hpa.start, HARMONY_SIZE); 930 if (h->iobase == NULL) { 931 printk(KERN_ERR PFX "unable to remap hpa 0x%lx\n", 932 (unsigned long)padev->hpa.start); 933 err = -EBUSY; 934 goto free_and_ret; 935 } 936 937 err = request_irq(padev->irq, snd_harmony_interrupt, 0, 938 "harmony", h); 939 if (err) { 940 printk(KERN_ERR PFX "could not obtain interrupt %d", 941 padev->irq); 942 goto free_and_ret; 943 } 944 h->irq = padev->irq; 945 946 spin_lock_init(&h->mixer_lock); 947 spin_lock_init(&h->lock); 948 949 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, 950 h, &ops)) < 0) { 951 goto free_and_ret; 952 } 953 954 *rchip = h; 955 956 return 0; 957 958 free_and_ret: 959 snd_harmony_free(h); 960 return err; 961 } 962 963 static int 964 snd_harmony_probe(struct parisc_device *padev) 965 { 966 int err; 967 struct snd_card *card; 968 struct snd_harmony *h; 969 970 err = snd_card_new(&padev->dev, index, id, THIS_MODULE, 0, &card); 971 if (err < 0) 972 return err; 973 974 err = snd_harmony_create(card, padev, &h); 975 if (err < 0) 976 goto free_and_ret; 977 978 err = snd_harmony_pcm_init(h); 979 if (err < 0) 980 goto free_and_ret; 981 982 err = snd_harmony_mixer_init(h); 983 if (err < 0) 984 goto free_and_ret; 985 986 strcpy(card->driver, "harmony"); 987 strcpy(card->shortname, "Harmony"); 988 sprintf(card->longname, "%s at 0x%lx, irq %i", 989 card->shortname, h->hpa, h->irq); 990 991 err = snd_card_register(card); 992 if (err < 0) 993 goto free_and_ret; 994 995 parisc_set_drvdata(padev, card); 996 return 0; 997 998 free_and_ret: 999 snd_card_free(card); 1000 return err; 1001 } 1002 1003 static int 1004 snd_harmony_remove(struct parisc_device *padev) 1005 { 1006 snd_card_free(parisc_get_drvdata(padev)); 1007 return 0; 1008 } 1009 1010 static struct parisc_driver snd_harmony_driver = { 1011 .name = "harmony", 1012 .id_table = snd_harmony_devtable, 1013 .probe = snd_harmony_probe, 1014 .remove = snd_harmony_remove, 1015 }; 1016 1017 static int __init 1018 alsa_harmony_init(void) 1019 { 1020 return register_parisc_driver(&snd_harmony_driver); 1021 } 1022 1023 static void __exit 1024 alsa_harmony_fini(void) 1025 { 1026 unregister_parisc_driver(&snd_harmony_driver); 1027 } 1028 1029 MODULE_LICENSE("GPL"); 1030 MODULE_AUTHOR("Kyle McMartin <kyle@parisc-linux.org>"); 1031 MODULE_DESCRIPTION("Harmony sound driver"); 1032 1033 module_init(alsa_harmony_init); 1034 module_exit(alsa_harmony_fini); 1035