sound/parisc/harmony.c

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