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