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