sound/parisc/harmony.c

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