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