linux/sound/isa/ad1816a/ad1816a_lib.c
<<
>>
Prefs
   1/*
   2    ad1816a.c - lowlevel code for Analog Devices AD1816A chip.
   3    Copyright (C) 1999-2000 by Massimo Piccioni <dafastidio@libero.it>
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18*/
  19
  20#include <linux/delay.h>
  21#include <linux/init.h>
  22#include <linux/interrupt.h>
  23#include <linux/slab.h>
  24#include <linux/ioport.h>
  25#include <sound/core.h>
  26#include <sound/tlv.h>
  27#include <sound/ad1816a.h>
  28
  29#include <asm/io.h>
  30#include <asm/dma.h>
  31
  32static inline int snd_ad1816a_busy_wait(struct snd_ad1816a *chip)
  33{
  34        int timeout;
  35
  36        for (timeout = 1000; timeout-- > 0; udelay(10))
  37                if (inb(AD1816A_REG(AD1816A_CHIP_STATUS)) & AD1816A_READY)
  38                        return 0;
  39
  40        snd_printk("chip busy.\n");
  41        return -EBUSY;
  42}
  43
  44static inline unsigned char snd_ad1816a_in(struct snd_ad1816a *chip, unsigned char reg)
  45{
  46        snd_ad1816a_busy_wait(chip);
  47        return inb(AD1816A_REG(reg));
  48}
  49
  50static inline void snd_ad1816a_out(struct snd_ad1816a *chip, unsigned char reg,
  51                            unsigned char value)
  52{
  53        snd_ad1816a_busy_wait(chip);
  54        outb(value, AD1816A_REG(reg));
  55}
  56
  57static inline void snd_ad1816a_out_mask(struct snd_ad1816a *chip, unsigned char reg,
  58                                 unsigned char mask, unsigned char value)
  59{
  60        snd_ad1816a_out(chip, reg,
  61                (value & mask) | (snd_ad1816a_in(chip, reg) & ~mask));
  62}
  63
  64static unsigned short snd_ad1816a_read(struct snd_ad1816a *chip, unsigned char reg)
  65{
  66        snd_ad1816a_out(chip, AD1816A_INDIR_ADDR, reg & 0x3f);
  67        return snd_ad1816a_in(chip, AD1816A_INDIR_DATA_LOW) |
  68                (snd_ad1816a_in(chip, AD1816A_INDIR_DATA_HIGH) << 8);
  69}
  70
  71static void snd_ad1816a_write(struct snd_ad1816a *chip, unsigned char reg,
  72                              unsigned short value)
  73{
  74        snd_ad1816a_out(chip, AD1816A_INDIR_ADDR, reg & 0x3f);
  75        snd_ad1816a_out(chip, AD1816A_INDIR_DATA_LOW, value & 0xff);
  76        snd_ad1816a_out(chip, AD1816A_INDIR_DATA_HIGH, (value >> 8) & 0xff);
  77}
  78
  79static void snd_ad1816a_write_mask(struct snd_ad1816a *chip, unsigned char reg,
  80                                   unsigned short mask, unsigned short value)
  81{
  82        snd_ad1816a_write(chip, reg,
  83                (value & mask) | (snd_ad1816a_read(chip, reg) & ~mask));
  84}
  85
  86
  87static unsigned char snd_ad1816a_get_format(struct snd_ad1816a *chip,
  88                                            unsigned int format, int channels)
  89{
  90        unsigned char retval = AD1816A_FMT_LINEAR_8;
  91
  92        switch (format) {
  93        case SNDRV_PCM_FORMAT_MU_LAW:
  94                retval = AD1816A_FMT_ULAW_8;
  95                break;
  96        case SNDRV_PCM_FORMAT_A_LAW:
  97                retval = AD1816A_FMT_ALAW_8;
  98                break;
  99        case SNDRV_PCM_FORMAT_S16_LE:
 100                retval = AD1816A_FMT_LINEAR_16_LIT;
 101                break;
 102        case SNDRV_PCM_FORMAT_S16_BE:
 103                retval = AD1816A_FMT_LINEAR_16_BIG;
 104        }
 105        return (channels > 1) ? (retval | AD1816A_FMT_STEREO) : retval;
 106}
 107
 108static int snd_ad1816a_open(struct snd_ad1816a *chip, unsigned int mode)
 109{
 110        unsigned long flags;
 111
 112        spin_lock_irqsave(&chip->lock, flags);
 113
 114        if (chip->mode & mode) {
 115                spin_unlock_irqrestore(&chip->lock, flags);
 116                return -EAGAIN;
 117        }
 118
 119        switch ((mode &= AD1816A_MODE_OPEN)) {
 120        case AD1816A_MODE_PLAYBACK:
 121                snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
 122                        AD1816A_PLAYBACK_IRQ_PENDING, 0x00);
 123                snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
 124                        AD1816A_PLAYBACK_IRQ_ENABLE, 0xffff);
 125                break;
 126        case AD1816A_MODE_CAPTURE:
 127                snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
 128                        AD1816A_CAPTURE_IRQ_PENDING, 0x00);
 129                snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
 130                        AD1816A_CAPTURE_IRQ_ENABLE, 0xffff);
 131                break;
 132        case AD1816A_MODE_TIMER:
 133                snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
 134                        AD1816A_TIMER_IRQ_PENDING, 0x00);
 135                snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
 136                        AD1816A_TIMER_IRQ_ENABLE, 0xffff);
 137        }
 138        chip->mode |= mode;
 139
 140        spin_unlock_irqrestore(&chip->lock, flags);
 141        return 0;
 142}
 143
 144static void snd_ad1816a_close(struct snd_ad1816a *chip, unsigned int mode)
 145{
 146        unsigned long flags;
 147
 148        spin_lock_irqsave(&chip->lock, flags);
 149
 150        switch ((mode &= AD1816A_MODE_OPEN)) {
 151        case AD1816A_MODE_PLAYBACK:
 152                snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
 153                        AD1816A_PLAYBACK_IRQ_PENDING, 0x00);
 154                snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
 155                        AD1816A_PLAYBACK_IRQ_ENABLE, 0x0000);
 156                break;
 157        case AD1816A_MODE_CAPTURE:
 158                snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
 159                        AD1816A_CAPTURE_IRQ_PENDING, 0x00);
 160                snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
 161                        AD1816A_CAPTURE_IRQ_ENABLE, 0x0000);
 162                break;
 163        case AD1816A_MODE_TIMER:
 164                snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
 165                        AD1816A_TIMER_IRQ_PENDING, 0x00);
 166                snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
 167                        AD1816A_TIMER_IRQ_ENABLE, 0x0000);
 168        }
 169        if (!((chip->mode &= ~mode) & AD1816A_MODE_OPEN))
 170                chip->mode = 0;
 171
 172        spin_unlock_irqrestore(&chip->lock, flags);
 173}
 174
 175
 176static int snd_ad1816a_trigger(struct snd_ad1816a *chip, unsigned char what,
 177                               int channel, int cmd, int iscapture)
 178{
 179        int error = 0;
 180
 181        switch (cmd) {
 182        case SNDRV_PCM_TRIGGER_START:
 183        case SNDRV_PCM_TRIGGER_STOP:
 184                spin_lock(&chip->lock);
 185                cmd = (cmd == SNDRV_PCM_TRIGGER_START) ? 0xff: 0x00;
 186                /* if (what & AD1816A_PLAYBACK_ENABLE) */
 187                /* That is not valid, because playback and capture enable
 188                 * are the same bit pattern, just to different addresses
 189                 */
 190                if (! iscapture)
 191                        snd_ad1816a_out_mask(chip, AD1816A_PLAYBACK_CONFIG,
 192                                AD1816A_PLAYBACK_ENABLE, cmd);
 193                else
 194                        snd_ad1816a_out_mask(chip, AD1816A_CAPTURE_CONFIG,
 195                                AD1816A_CAPTURE_ENABLE, cmd);
 196                spin_unlock(&chip->lock);
 197                break;
 198        default:
 199                snd_printk("invalid trigger mode 0x%x.\n", what);
 200                error = -EINVAL;
 201        }
 202
 203        return error;
 204}
 205
 206static int snd_ad1816a_playback_trigger(struct snd_pcm_substream *substream, int cmd)
 207{
 208        struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
 209        return snd_ad1816a_trigger(chip, AD1816A_PLAYBACK_ENABLE,
 210                                   SNDRV_PCM_STREAM_PLAYBACK, cmd, 0);
 211}
 212
 213static int snd_ad1816a_capture_trigger(struct snd_pcm_substream *substream, int cmd)
 214{
 215        struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
 216        return snd_ad1816a_trigger(chip, AD1816A_CAPTURE_ENABLE,
 217                                   SNDRV_PCM_STREAM_CAPTURE, cmd, 1);
 218}
 219
 220static int snd_ad1816a_hw_params(struct snd_pcm_substream *substream,
 221                                 struct snd_pcm_hw_params *hw_params)
 222{
 223        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
 224}
 225
 226static int snd_ad1816a_hw_free(struct snd_pcm_substream *substream)
 227{
 228        return snd_pcm_lib_free_pages(substream);
 229}
 230
 231static int snd_ad1816a_playback_prepare(struct snd_pcm_substream *substream)
 232{
 233        struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
 234        unsigned long flags;
 235        struct snd_pcm_runtime *runtime = substream->runtime;
 236        unsigned int size, rate;
 237
 238        spin_lock_irqsave(&chip->lock, flags);
 239
 240        chip->p_dma_size = size = snd_pcm_lib_buffer_bytes(substream);
 241        snd_ad1816a_out_mask(chip, AD1816A_PLAYBACK_CONFIG,
 242                AD1816A_PLAYBACK_ENABLE | AD1816A_PLAYBACK_PIO, 0x00);
 243
 244        snd_dma_program(chip->dma1, runtime->dma_addr, size,
 245                        DMA_MODE_WRITE | DMA_AUTOINIT);
 246
 247        rate = runtime->rate;
 248        if (chip->clock_freq)
 249                rate = (rate * 33000) / chip->clock_freq;
 250        snd_ad1816a_write(chip, AD1816A_PLAYBACK_SAMPLE_RATE, rate);
 251        snd_ad1816a_out_mask(chip, AD1816A_PLAYBACK_CONFIG,
 252                AD1816A_FMT_ALL | AD1816A_FMT_STEREO,
 253                snd_ad1816a_get_format(chip, runtime->format,
 254                        runtime->channels));
 255
 256        snd_ad1816a_write(chip, AD1816A_PLAYBACK_BASE_COUNT,
 257                snd_pcm_lib_period_bytes(substream) / 4 - 1);
 258
 259        spin_unlock_irqrestore(&chip->lock, flags);
 260        return 0;
 261}
 262
 263static int snd_ad1816a_capture_prepare(struct snd_pcm_substream *substream)
 264{
 265        struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
 266        unsigned long flags;
 267        struct snd_pcm_runtime *runtime = substream->runtime;
 268        unsigned int size, rate;
 269
 270        spin_lock_irqsave(&chip->lock, flags);
 271
 272        chip->c_dma_size = size = snd_pcm_lib_buffer_bytes(substream);
 273        snd_ad1816a_out_mask(chip, AD1816A_CAPTURE_CONFIG,
 274                AD1816A_CAPTURE_ENABLE | AD1816A_CAPTURE_PIO, 0x00);
 275
 276        snd_dma_program(chip->dma2, runtime->dma_addr, size,
 277                        DMA_MODE_READ | DMA_AUTOINIT);
 278
 279        rate = runtime->rate;
 280        if (chip->clock_freq)
 281                rate = (rate * 33000) / chip->clock_freq;
 282        snd_ad1816a_write(chip, AD1816A_CAPTURE_SAMPLE_RATE, rate);
 283        snd_ad1816a_out_mask(chip, AD1816A_CAPTURE_CONFIG,
 284                AD1816A_FMT_ALL | AD1816A_FMT_STEREO,
 285                snd_ad1816a_get_format(chip, runtime->format,
 286                        runtime->channels));
 287
 288        snd_ad1816a_write(chip, AD1816A_CAPTURE_BASE_COUNT,
 289                snd_pcm_lib_period_bytes(substream) / 4 - 1);
 290
 291        spin_unlock_irqrestore(&chip->lock, flags);
 292        return 0;
 293}
 294
 295
 296static snd_pcm_uframes_t snd_ad1816a_playback_pointer(struct snd_pcm_substream *substream)
 297{
 298        struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
 299        size_t ptr;
 300        if (!(chip->mode & AD1816A_MODE_PLAYBACK))
 301                return 0;
 302        ptr = snd_dma_pointer(chip->dma1, chip->p_dma_size);
 303        return bytes_to_frames(substream->runtime, ptr);
 304}
 305
 306static snd_pcm_uframes_t snd_ad1816a_capture_pointer(struct snd_pcm_substream *substream)
 307{
 308        struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
 309        size_t ptr;
 310        if (!(chip->mode & AD1816A_MODE_CAPTURE))
 311                return 0;
 312        ptr = snd_dma_pointer(chip->dma2, chip->c_dma_size);
 313        return bytes_to_frames(substream->runtime, ptr);
 314}
 315
 316
 317static irqreturn_t snd_ad1816a_interrupt(int irq, void *dev_id)
 318{
 319        struct snd_ad1816a *chip = dev_id;
 320        unsigned char status;
 321
 322        spin_lock(&chip->lock);
 323        status = snd_ad1816a_in(chip, AD1816A_INTERRUPT_STATUS);
 324        spin_unlock(&chip->lock);
 325
 326        if ((status & AD1816A_PLAYBACK_IRQ_PENDING) && chip->playback_substream)
 327                snd_pcm_period_elapsed(chip->playback_substream);
 328
 329        if ((status & AD1816A_CAPTURE_IRQ_PENDING) && chip->capture_substream)
 330                snd_pcm_period_elapsed(chip->capture_substream);
 331
 332        if ((status & AD1816A_TIMER_IRQ_PENDING) && chip->timer)
 333                snd_timer_interrupt(chip->timer, chip->timer->sticks);
 334
 335        spin_lock(&chip->lock);
 336        snd_ad1816a_out(chip, AD1816A_INTERRUPT_STATUS, 0x00);
 337        spin_unlock(&chip->lock);
 338        return IRQ_HANDLED;
 339}
 340
 341
 342static struct snd_pcm_hardware snd_ad1816a_playback = {
 343        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
 344                                 SNDRV_PCM_INFO_MMAP_VALID),
 345        .formats =              (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW |
 346                                 SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
 347                                 SNDRV_PCM_FMTBIT_S16_BE),
 348        .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
 349        .rate_min =             4000,
 350        .rate_max =             55200,
 351        .channels_min =         1,
 352        .channels_max =         2,
 353        .buffer_bytes_max =     (128*1024),
 354        .period_bytes_min =     64,
 355        .period_bytes_max =     (128*1024),
 356        .periods_min =          1,
 357        .periods_max =          1024,
 358        .fifo_size =            0,
 359};
 360
 361static struct snd_pcm_hardware snd_ad1816a_capture = {
 362        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
 363                                 SNDRV_PCM_INFO_MMAP_VALID),
 364        .formats =              (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW |
 365                                 SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
 366                                 SNDRV_PCM_FMTBIT_S16_BE),
 367        .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
 368        .rate_min =             4000,
 369        .rate_max =             55200,
 370        .channels_min =         1,
 371        .channels_max =         2,
 372        .buffer_bytes_max =     (128*1024),
 373        .period_bytes_min =     64,
 374        .period_bytes_max =     (128*1024),
 375        .periods_min =          1,
 376        .periods_max =          1024,
 377        .fifo_size =            0,
 378};
 379
 380#if 0 /* not used now */
 381static int snd_ad1816a_timer_close(struct snd_timer *timer)
 382{
 383        struct snd_ad1816a *chip = snd_timer_chip(timer);
 384        snd_ad1816a_close(chip, AD1816A_MODE_TIMER);
 385        return 0;
 386}
 387
 388static int snd_ad1816a_timer_open(struct snd_timer *timer)
 389{
 390        struct snd_ad1816a *chip = snd_timer_chip(timer);
 391        snd_ad1816a_open(chip, AD1816A_MODE_TIMER);
 392        return 0;
 393}
 394
 395static unsigned long snd_ad1816a_timer_resolution(struct snd_timer *timer)
 396{
 397        if (snd_BUG_ON(!timer))
 398                return 0;
 399
 400        return 10000;
 401}
 402
 403static int snd_ad1816a_timer_start(struct snd_timer *timer)
 404{
 405        unsigned short bits;
 406        unsigned long flags;
 407        struct snd_ad1816a *chip = snd_timer_chip(timer);
 408        spin_lock_irqsave(&chip->lock, flags);
 409        bits = snd_ad1816a_read(chip, AD1816A_INTERRUPT_ENABLE);
 410
 411        if (!(bits & AD1816A_TIMER_ENABLE)) {
 412                snd_ad1816a_write(chip, AD1816A_TIMER_BASE_COUNT,
 413                        timer->sticks & 0xffff);
 414
 415                snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
 416                        AD1816A_TIMER_ENABLE, 0xffff);
 417        }
 418        spin_unlock_irqrestore(&chip->lock, flags);
 419        return 0;
 420}
 421
 422static int snd_ad1816a_timer_stop(struct snd_timer *timer)
 423{
 424        unsigned long flags;
 425        struct snd_ad1816a *chip = snd_timer_chip(timer);
 426        spin_lock_irqsave(&chip->lock, flags);
 427
 428        snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
 429                AD1816A_TIMER_ENABLE, 0x0000);
 430
 431        spin_unlock_irqrestore(&chip->lock, flags);
 432        return 0;
 433}
 434
 435static struct snd_timer_hardware snd_ad1816a_timer_table = {
 436        .flags =        SNDRV_TIMER_HW_AUTO,
 437        .resolution =   10000,
 438        .ticks =        65535,
 439        .open =         snd_ad1816a_timer_open,
 440        .close =        snd_ad1816a_timer_close,
 441        .c_resolution = snd_ad1816a_timer_resolution,
 442        .start =        snd_ad1816a_timer_start,
 443        .stop =         snd_ad1816a_timer_stop,
 444};
 445#endif /* not used now */
 446
 447
 448static int snd_ad1816a_playback_open(struct snd_pcm_substream *substream)
 449{
 450        struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
 451        struct snd_pcm_runtime *runtime = substream->runtime;
 452        int error;
 453
 454        if ((error = snd_ad1816a_open(chip, AD1816A_MODE_PLAYBACK)) < 0)
 455                return error;
 456        runtime->hw = snd_ad1816a_playback;
 457        snd_pcm_limit_isa_dma_size(chip->dma1, &runtime->hw.buffer_bytes_max);
 458        snd_pcm_limit_isa_dma_size(chip->dma1, &runtime->hw.period_bytes_max);
 459        chip->playback_substream = substream;
 460        return 0;
 461}
 462
 463static int snd_ad1816a_capture_open(struct snd_pcm_substream *substream)
 464{
 465        struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
 466        struct snd_pcm_runtime *runtime = substream->runtime;
 467        int error;
 468
 469        if ((error = snd_ad1816a_open(chip, AD1816A_MODE_CAPTURE)) < 0)
 470                return error;
 471        runtime->hw = snd_ad1816a_capture;
 472        snd_pcm_limit_isa_dma_size(chip->dma2, &runtime->hw.buffer_bytes_max);
 473        snd_pcm_limit_isa_dma_size(chip->dma2, &runtime->hw.period_bytes_max);
 474        chip->capture_substream = substream;
 475        return 0;
 476}
 477
 478static int snd_ad1816a_playback_close(struct snd_pcm_substream *substream)
 479{
 480        struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
 481
 482        chip->playback_substream = NULL;
 483        snd_ad1816a_close(chip, AD1816A_MODE_PLAYBACK);
 484        return 0;
 485}
 486
 487static int snd_ad1816a_capture_close(struct snd_pcm_substream *substream)
 488{
 489        struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
 490
 491        chip->capture_substream = NULL;
 492        snd_ad1816a_close(chip, AD1816A_MODE_CAPTURE);
 493        return 0;
 494}
 495
 496
 497static void __devinit snd_ad1816a_init(struct snd_ad1816a *chip)
 498{
 499        unsigned long flags;
 500
 501        spin_lock_irqsave(&chip->lock, flags);
 502
 503        snd_ad1816a_out(chip, AD1816A_INTERRUPT_STATUS, 0x00);
 504        snd_ad1816a_out_mask(chip, AD1816A_PLAYBACK_CONFIG,
 505                AD1816A_PLAYBACK_ENABLE | AD1816A_PLAYBACK_PIO, 0x00);
 506        snd_ad1816a_out_mask(chip, AD1816A_CAPTURE_CONFIG,
 507                AD1816A_CAPTURE_ENABLE | AD1816A_CAPTURE_PIO, 0x00);
 508        snd_ad1816a_write(chip, AD1816A_INTERRUPT_ENABLE, 0x0000);
 509        snd_ad1816a_write_mask(chip, AD1816A_CHIP_CONFIG,
 510                AD1816A_CAPTURE_NOT_EQUAL | AD1816A_WSS_ENABLE, 0xffff);
 511        snd_ad1816a_write(chip, AD1816A_DSP_CONFIG, 0x0000);
 512        snd_ad1816a_write(chip, AD1816A_POWERDOWN_CTRL, 0x0000);
 513
 514        spin_unlock_irqrestore(&chip->lock, flags);
 515}
 516
 517static int __devinit snd_ad1816a_probe(struct snd_ad1816a *chip)
 518{
 519        unsigned long flags;
 520
 521        spin_lock_irqsave(&chip->lock, flags);
 522
 523        switch (chip->version = snd_ad1816a_read(chip, AD1816A_VERSION_ID)) {
 524        case 0:
 525                chip->hardware = AD1816A_HW_AD1815;
 526                break;
 527        case 1:
 528                chip->hardware = AD1816A_HW_AD18MAX10;
 529                break;
 530        case 3:
 531                chip->hardware = AD1816A_HW_AD1816A;
 532                break;
 533        default:
 534                chip->hardware = AD1816A_HW_AUTO;
 535        }
 536
 537        spin_unlock_irqrestore(&chip->lock, flags);
 538        return 0;
 539}
 540
 541static int snd_ad1816a_free(struct snd_ad1816a *chip)
 542{
 543        release_and_free_resource(chip->res_port);
 544        if (chip->irq >= 0)
 545                free_irq(chip->irq, (void *) chip);
 546        if (chip->dma1 >= 0) {
 547                snd_dma_disable(chip->dma1);
 548                free_dma(chip->dma1);
 549        }
 550        if (chip->dma2 >= 0) {
 551                snd_dma_disable(chip->dma2);
 552                free_dma(chip->dma2);
 553        }
 554        kfree(chip);
 555        return 0;
 556}
 557
 558static int snd_ad1816a_dev_free(struct snd_device *device)
 559{
 560        struct snd_ad1816a *chip = device->device_data;
 561        return snd_ad1816a_free(chip);
 562}
 563
 564static const char __devinit *snd_ad1816a_chip_id(struct snd_ad1816a *chip)
 565{
 566        switch (chip->hardware) {
 567        case AD1816A_HW_AD1816A: return "AD1816A";
 568        case AD1816A_HW_AD1815: return "AD1815";
 569        case AD1816A_HW_AD18MAX10: return "AD18max10";
 570        default:
 571                snd_printk("Unknown chip version %d:%d.\n",
 572                        chip->version, chip->hardware);
 573                return "AD1816A - unknown";
 574        }
 575}
 576
 577int __devinit snd_ad1816a_create(struct snd_card *card,
 578                                 unsigned long port, int irq, int dma1, int dma2,
 579                                 struct snd_ad1816a **rchip)
 580{
 581        static struct snd_device_ops ops = {
 582                .dev_free =     snd_ad1816a_dev_free,
 583        };
 584        int error;
 585        struct snd_ad1816a *chip;
 586
 587        *rchip = NULL;
 588
 589        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
 590        if (chip == NULL)
 591                return -ENOMEM;
 592        chip->irq = -1;
 593        chip->dma1 = -1;
 594        chip->dma2 = -1;
 595
 596        if ((chip->res_port = request_region(port, 16, "AD1816A")) == NULL) {
 597                snd_printk(KERN_ERR "ad1816a: can't grab port 0x%lx\n", port);
 598                snd_ad1816a_free(chip);
 599                return -EBUSY;
 600        }
 601        if (request_irq(irq, snd_ad1816a_interrupt, IRQF_DISABLED, "AD1816A", (void *) chip)) {
 602                snd_printk(KERN_ERR "ad1816a: can't grab IRQ %d\n", irq);
 603                snd_ad1816a_free(chip);
 604                return -EBUSY;
 605        }
 606        chip->irq = irq;
 607        if (request_dma(dma1, "AD1816A - 1")) {
 608                snd_printk(KERN_ERR "ad1816a: can't grab DMA1 %d\n", dma1);
 609                snd_ad1816a_free(chip);
 610                return -EBUSY;
 611        }
 612        chip->dma1 = dma1;
 613        if (request_dma(dma2, "AD1816A - 2")) {
 614                snd_printk(KERN_ERR "ad1816a: can't grab DMA2 %d\n", dma2);
 615                snd_ad1816a_free(chip);
 616                return -EBUSY;
 617        }
 618        chip->dma2 = dma2;
 619
 620        chip->card = card;
 621        chip->port = port;
 622        spin_lock_init(&chip->lock);
 623
 624        if ((error = snd_ad1816a_probe(chip))) {
 625                snd_ad1816a_free(chip);
 626                return error;
 627        }
 628
 629        snd_ad1816a_init(chip);
 630
 631        /* Register device */
 632        if ((error = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
 633                snd_ad1816a_free(chip);
 634                return error;
 635        }
 636
 637        *rchip = chip;
 638        return 0;
 639}
 640
 641static struct snd_pcm_ops snd_ad1816a_playback_ops = {
 642        .open =         snd_ad1816a_playback_open,
 643        .close =        snd_ad1816a_playback_close,
 644        .ioctl =        snd_pcm_lib_ioctl,
 645        .hw_params =    snd_ad1816a_hw_params,
 646        .hw_free =      snd_ad1816a_hw_free,
 647        .prepare =      snd_ad1816a_playback_prepare,
 648        .trigger =      snd_ad1816a_playback_trigger,
 649        .pointer =      snd_ad1816a_playback_pointer,
 650};
 651
 652static struct snd_pcm_ops snd_ad1816a_capture_ops = {
 653        .open =         snd_ad1816a_capture_open,
 654        .close =        snd_ad1816a_capture_close,
 655        .ioctl =        snd_pcm_lib_ioctl,
 656        .hw_params =    snd_ad1816a_hw_params,
 657        .hw_free =      snd_ad1816a_hw_free,
 658        .prepare =      snd_ad1816a_capture_prepare,
 659        .trigger =      snd_ad1816a_capture_trigger,
 660        .pointer =      snd_ad1816a_capture_pointer,
 661};
 662
 663int __devinit snd_ad1816a_pcm(struct snd_ad1816a *chip, int device, struct snd_pcm **rpcm)
 664{
 665        int error;
 666        struct snd_pcm *pcm;
 667
 668        if ((error = snd_pcm_new(chip->card, "AD1816A", device, 1, 1, &pcm)))
 669                return error;
 670
 671        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ad1816a_playback_ops);
 672        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ad1816a_capture_ops);
 673
 674        pcm->private_data = chip;
 675        pcm->info_flags = (chip->dma1 == chip->dma2 ) ? SNDRV_PCM_INFO_JOINT_DUPLEX : 0;
 676
 677        strcpy(pcm->name, snd_ad1816a_chip_id(chip));
 678        snd_ad1816a_init(chip);
 679
 680        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
 681                                              snd_dma_isa_data(),
 682                                              64*1024, chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
 683
 684        chip->pcm = pcm;
 685        if (rpcm)
 686                *rpcm = pcm;
 687        return 0;
 688}
 689
 690#if 0 /* not used now */
 691int __devinit snd_ad1816a_timer(struct snd_ad1816a *chip, int device, struct snd_timer **rtimer)
 692{
 693        struct snd_timer *timer;
 694        struct snd_timer_id tid;
 695        int error;
 696
 697        tid.dev_class = SNDRV_TIMER_CLASS_CARD;
 698        tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
 699        tid.card = chip->card->number;
 700        tid.device = device;
 701        tid.subdevice = 0;
 702        if ((error = snd_timer_new(chip->card, "AD1816A", &tid, &timer)) < 0)
 703                return error;
 704        strcpy(timer->name, snd_ad1816a_chip_id(chip));
 705        timer->private_data = chip;
 706        chip->timer = timer;
 707        timer->hw = snd_ad1816a_timer_table;
 708        if (rtimer)
 709                *rtimer = timer;
 710        return 0;
 711}
 712#endif /* not used now */
 713
 714/*
 715 *
 716 */
 717
 718static int snd_ad1816a_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 719{
 720        static char *texts[8] = {
 721                "Line", "Mix", "CD", "Synth", "Video",
 722                "Mic", "Phone",
 723        };
 724
 725        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 726        uinfo->count = 2;
 727        uinfo->value.enumerated.items = 7;
 728        if (uinfo->value.enumerated.item > 6)
 729                uinfo->value.enumerated.item = 6;
 730        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
 731        return 0;
 732}
 733
 734static int snd_ad1816a_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 735{
 736        struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol);
 737        unsigned long flags;
 738        unsigned short val;
 739        
 740        spin_lock_irqsave(&chip->lock, flags);
 741        val = snd_ad1816a_read(chip, AD1816A_ADC_SOURCE_SEL);
 742        spin_unlock_irqrestore(&chip->lock, flags);
 743        ucontrol->value.enumerated.item[0] = (val >> 12) & 7;
 744        ucontrol->value.enumerated.item[1] = (val >> 4) & 7;
 745        return 0;
 746}
 747
 748static int snd_ad1816a_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 749{
 750        struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol);
 751        unsigned long flags;
 752        unsigned short val;
 753        int change;
 754        
 755        if (ucontrol->value.enumerated.item[0] > 6 ||
 756            ucontrol->value.enumerated.item[1] > 6)
 757                return -EINVAL;
 758        val = (ucontrol->value.enumerated.item[0] << 12) |
 759              (ucontrol->value.enumerated.item[1] << 4);
 760        spin_lock_irqsave(&chip->lock, flags);
 761        change = snd_ad1816a_read(chip, AD1816A_ADC_SOURCE_SEL) != val;
 762        snd_ad1816a_write(chip, AD1816A_ADC_SOURCE_SEL, val);
 763        spin_unlock_irqrestore(&chip->lock, flags);
 764        return change;
 765}
 766
 767#define AD1816A_SINGLE_TLV(xname, reg, shift, mask, invert, xtlv)       \
 768{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 769  .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
 770  .name = xname, .info = snd_ad1816a_info_single, \
 771  .get = snd_ad1816a_get_single, .put = snd_ad1816a_put_single, \
 772  .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24), \
 773  .tlv = { .p = (xtlv) } }
 774#define AD1816A_SINGLE(xname, reg, shift, mask, invert) \
 775{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ad1816a_info_single, \
 776  .get = snd_ad1816a_get_single, .put = snd_ad1816a_put_single, \
 777  .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
 778
 779static int snd_ad1816a_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 780{
 781        int mask = (kcontrol->private_value >> 16) & 0xff;
 782
 783        uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
 784        uinfo->count = 1;
 785        uinfo->value.integer.min = 0;
 786        uinfo->value.integer.max = mask;
 787        return 0;
 788}
 789
 790static int snd_ad1816a_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 791{
 792        struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol);
 793        unsigned long flags;
 794        int reg = kcontrol->private_value & 0xff;
 795        int shift = (kcontrol->private_value >> 8) & 0xff;
 796        int mask = (kcontrol->private_value >> 16) & 0xff;
 797        int invert = (kcontrol->private_value >> 24) & 0xff;
 798        
 799        spin_lock_irqsave(&chip->lock, flags);
 800        ucontrol->value.integer.value[0] = (snd_ad1816a_read(chip, reg) >> shift) & mask;
 801        spin_unlock_irqrestore(&chip->lock, flags);
 802        if (invert)
 803                ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
 804        return 0;
 805}
 806
 807static int snd_ad1816a_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 808{
 809        struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol);
 810        unsigned long flags;
 811        int reg = kcontrol->private_value & 0xff;
 812        int shift = (kcontrol->private_value >> 8) & 0xff;
 813        int mask = (kcontrol->private_value >> 16) & 0xff;
 814        int invert = (kcontrol->private_value >> 24) & 0xff;
 815        int change;
 816        unsigned short old_val, val;
 817        
 818        val = (ucontrol->value.integer.value[0] & mask);
 819        if (invert)
 820                val = mask - val;
 821        val <<= shift;
 822        spin_lock_irqsave(&chip->lock, flags);
 823        old_val = snd_ad1816a_read(chip, reg);
 824        val = (old_val & ~(mask << shift)) | val;
 825        change = val != old_val;
 826        snd_ad1816a_write(chip, reg, val);
 827        spin_unlock_irqrestore(&chip->lock, flags);
 828        return change;
 829}
 830
 831#define AD1816A_DOUBLE_TLV(xname, reg, shift_left, shift_right, mask, invert, xtlv) \
 832{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 833  .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
 834  .name = xname, .info = snd_ad1816a_info_double,               \
 835  .get = snd_ad1816a_get_double, .put = snd_ad1816a_put_double, \
 836  .private_value = reg | (shift_left << 8) | (shift_right << 12) | (mask << 16) | (invert << 24), \
 837  .tlv = { .p = (xtlv) } }
 838
 839#define AD1816A_DOUBLE(xname, reg, shift_left, shift_right, mask, invert) \
 840{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ad1816a_info_double, \
 841  .get = snd_ad1816a_get_double, .put = snd_ad1816a_put_double, \
 842  .private_value = reg | (shift_left << 8) | (shift_right << 12) | (mask << 16) | (invert << 24) }
 843
 844static int snd_ad1816a_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 845{
 846        int mask = (kcontrol->private_value >> 16) & 0xff;
 847
 848        uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
 849        uinfo->count = 2;
 850        uinfo->value.integer.min = 0;
 851        uinfo->value.integer.max = mask;
 852        return 0;
 853}
 854
 855static int snd_ad1816a_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 856{
 857        struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol);
 858        unsigned long flags;
 859        int reg = kcontrol->private_value & 0xff;
 860        int shift_left = (kcontrol->private_value >> 8) & 0x0f;
 861        int shift_right = (kcontrol->private_value >> 12) & 0x0f;
 862        int mask = (kcontrol->private_value >> 16) & 0xff;
 863        int invert = (kcontrol->private_value >> 24) & 0xff;
 864        unsigned short val;
 865        
 866        spin_lock_irqsave(&chip->lock, flags);
 867        val = snd_ad1816a_read(chip, reg);
 868        ucontrol->value.integer.value[0] = (val >> shift_left) & mask;
 869        ucontrol->value.integer.value[1] = (val >> shift_right) & mask;
 870        spin_unlock_irqrestore(&chip->lock, flags);
 871        if (invert) {
 872                ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
 873                ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
 874        }
 875        return 0;
 876}
 877
 878static int snd_ad1816a_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 879{
 880        struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol);
 881        unsigned long flags;
 882        int reg = kcontrol->private_value & 0xff;
 883        int shift_left = (kcontrol->private_value >> 8) & 0x0f;
 884        int shift_right = (kcontrol->private_value >> 12) & 0x0f;
 885        int mask = (kcontrol->private_value >> 16) & 0xff;
 886        int invert = (kcontrol->private_value >> 24) & 0xff;
 887        int change;
 888        unsigned short old_val, val1, val2;
 889        
 890        val1 = ucontrol->value.integer.value[0] & mask;
 891        val2 = ucontrol->value.integer.value[1] & mask;
 892        if (invert) {
 893                val1 = mask - val1;
 894                val2 = mask - val2;
 895        }
 896        val1 <<= shift_left;
 897        val2 <<= shift_right;
 898        spin_lock_irqsave(&chip->lock, flags);
 899        old_val = snd_ad1816a_read(chip, reg);
 900        val1 = (old_val & ~((mask << shift_left) | (mask << shift_right))) | val1 | val2;
 901        change = val1 != old_val;
 902        snd_ad1816a_write(chip, reg, val1);
 903        spin_unlock_irqrestore(&chip->lock, flags);
 904        return change;
 905}
 906
 907static const DECLARE_TLV_DB_SCALE(db_scale_4bit, -4500, 300, 0);
 908static const DECLARE_TLV_DB_SCALE(db_scale_5bit, -4650, 150, 0);
 909static const DECLARE_TLV_DB_SCALE(db_scale_6bit, -9450, 150, 0);
 910static const DECLARE_TLV_DB_SCALE(db_scale_5bit_12db_max, -3450, 150, 0);
 911static const DECLARE_TLV_DB_SCALE(db_scale_rec_gain, 0, 150, 0);
 912
 913static struct snd_kcontrol_new snd_ad1816a_controls[] __devinitdata = {
 914AD1816A_DOUBLE("Master Playback Switch", AD1816A_MASTER_ATT, 15, 7, 1, 1),
 915AD1816A_DOUBLE_TLV("Master Playback Volume", AD1816A_MASTER_ATT, 8, 0, 31, 1,
 916                   db_scale_5bit),
 917AD1816A_DOUBLE("PCM Playback Switch", AD1816A_VOICE_ATT, 15, 7, 1, 1),
 918AD1816A_DOUBLE_TLV("PCM Playback Volume", AD1816A_VOICE_ATT, 8, 0, 63, 1,
 919                   db_scale_6bit),
 920AD1816A_DOUBLE("Line Playback Switch", AD1816A_LINE_GAIN_ATT, 15, 7, 1, 1),
 921AD1816A_DOUBLE_TLV("Line Playback Volume", AD1816A_LINE_GAIN_ATT, 8, 0, 31, 1,
 922                   db_scale_5bit_12db_max),
 923AD1816A_DOUBLE("CD Playback Switch", AD1816A_CD_GAIN_ATT, 15, 7, 1, 1),
 924AD1816A_DOUBLE_TLV("CD Playback Volume", AD1816A_CD_GAIN_ATT, 8, 0, 31, 1,
 925                   db_scale_5bit_12db_max),
 926AD1816A_DOUBLE("Synth Playback Switch", AD1816A_SYNTH_GAIN_ATT, 15, 7, 1, 1),
 927AD1816A_DOUBLE_TLV("Synth Playback Volume", AD1816A_SYNTH_GAIN_ATT, 8, 0, 31, 1,
 928                   db_scale_5bit_12db_max),
 929AD1816A_DOUBLE("FM Playback Switch", AD1816A_FM_ATT, 15, 7, 1, 1),
 930AD1816A_DOUBLE_TLV("FM Playback Volume", AD1816A_FM_ATT, 8, 0, 63, 1,
 931                   db_scale_6bit),
 932AD1816A_SINGLE("Mic Playback Switch", AD1816A_MIC_GAIN_ATT, 15, 1, 1),
 933AD1816A_SINGLE_TLV("Mic Playback Volume", AD1816A_MIC_GAIN_ATT, 8, 31, 1,
 934                   db_scale_5bit_12db_max),
 935AD1816A_SINGLE("Mic Boost", AD1816A_MIC_GAIN_ATT, 14, 1, 0),
 936AD1816A_DOUBLE("Video Playback Switch", AD1816A_VID_GAIN_ATT, 15, 7, 1, 1),
 937AD1816A_DOUBLE_TLV("Video Playback Volume", AD1816A_VID_GAIN_ATT, 8, 0, 31, 1,
 938                   db_scale_5bit_12db_max),
 939AD1816A_SINGLE("Phone Capture Switch", AD1816A_PHONE_IN_GAIN_ATT, 15, 1, 1),
 940AD1816A_SINGLE_TLV("Phone Capture Volume", AD1816A_PHONE_IN_GAIN_ATT, 0, 15, 1,
 941                   db_scale_4bit),
 942AD1816A_SINGLE("Phone Playback Switch", AD1816A_PHONE_OUT_ATT, 7, 1, 1),
 943AD1816A_SINGLE_TLV("Phone Playback Volume", AD1816A_PHONE_OUT_ATT, 0, 31, 1,
 944                   db_scale_5bit),
 945{
 946        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 947        .name = "Capture Source",
 948        .info = snd_ad1816a_info_mux,
 949        .get = snd_ad1816a_get_mux,
 950        .put = snd_ad1816a_put_mux,
 951},
 952AD1816A_DOUBLE("Capture Switch", AD1816A_ADC_PGA, 15, 7, 1, 1),
 953AD1816A_DOUBLE_TLV("Capture Volume", AD1816A_ADC_PGA, 8, 0, 15, 0,
 954                   db_scale_rec_gain),
 955AD1816A_SINGLE("3D Control - Switch", AD1816A_3D_PHAT_CTRL, 15, 1, 1),
 956AD1816A_SINGLE("3D Control - Level", AD1816A_3D_PHAT_CTRL, 0, 15, 0),
 957};
 958                                        
 959int __devinit snd_ad1816a_mixer(struct snd_ad1816a *chip)
 960{
 961        struct snd_card *card;
 962        unsigned int idx;
 963        int err;
 964
 965        if (snd_BUG_ON(!chip || !chip->card))
 966                return -EINVAL;
 967
 968        card = chip->card;
 969
 970        strcpy(card->mixername, snd_ad1816a_chip_id(chip));
 971
 972        for (idx = 0; idx < ARRAY_SIZE(snd_ad1816a_controls); idx++) {
 973                if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_ad1816a_controls[idx], chip))) < 0)
 974                        return err;
 975        }
 976        return 0;
 977}
 978
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.