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