sound/mips/sgio2audio.c

   1 /*
   2  *   Sound driver for Silicon Graphics O2 Workstations A/V board audio.
   3  *
   4  *   Copyright 2003 Vivien Chappelier <vivien.chappelier@linux-mips.org>
   5  *   Copyright 2008 Thomas Bogendoerfer <tsbogend@alpha.franken.de>
   6  *   Mxier part taken from mace_audio.c:
   7  *   Copyright 2007 Thorben Jändling <tj.trevelyan@gmail.com>
   8  *
   9  *   This program is free software; you can redistribute it and/or modify
  10  *   it under the terms of the GNU General Public License as published by
  11  *   the Free Software Foundation; either version 2 of the License, or
  12  *   (at your option) any later version.
  13  *
  14  *   This program is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *   GNU General Public License for more details.
  18  *
  19  *   You should have received a copy of the GNU General Public License
  20  *   along with this program; if not, write to the Free Software
  21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  22  *
  23  */
  24
  25 #include <linux/init.h>
  26 #include <linux/delay.h>
  27 #include <linux/spinlock.h>
  28 #include <linux/gfp.h>
  29 #include <linux/interrupt.h>
  30 #include <linux/dma-mapping.h>
  31 #include <linux/platform_device.h>
  32 #include <linux/io.h>
  33
  34 #include <asm/ip32/ip32_ints.h>
  35 #include <asm/ip32/mace.h>
  36
  37 #include <sound/core.h>
  38 #include <sound/control.h>
  39 #include <sound/pcm.h>
  40 #define SNDRV_GET_ID
  41 #include <sound/initval.h>
  42 #include <sound/ad1843.h>
  43
  44
  45 MODULE_AUTHOR("Vivien Chappelier <vivien.chappelier@linux-mips.org>");
  46 MODULE_DESCRIPTION("SGI O2 Audio");
  47 MODULE_LICENSE("GPL");
  48 MODULE_SUPPORTED_DEVICE("{{Silicon Graphics, O2 Audio}}");
  49
  50 static int index = SNDRV_DEFAULT_IDX1;  /* Index 0-MAX */
  51 static char *id = SNDRV_DEFAULT_STR1;   /* ID for this card */
  52
  53 module_param(index, int, 0444);
  54 MODULE_PARM_DESC(index, "Index value for SGI O2 soundcard.");
  55 module_param(id, charp, 0444);
  56 MODULE_PARM_DESC(id, "ID string for SGI O2 soundcard.");
  57
  58
  59 #define AUDIO_CONTROL_RESET              BIT(0) /* 1: reset audio interface */
  60 #define AUDIO_CONTROL_CODEC_PRESENT      BIT(1) /* 1: codec detected */
  61
  62 #define CODEC_CONTROL_WORD_SHIFT        0
  63 #define CODEC_CONTROL_READ              BIT(16)
  64 #define CODEC_CONTROL_ADDRESS_SHIFT     17
  65
  66 #define CHANNEL_CONTROL_RESET           BIT(10) /* 1: reset channel */
  67 #define CHANNEL_DMA_ENABLE              BIT(9)  /* 1: enable DMA transfer */
  68 #define CHANNEL_INT_THRESHOLD_DISABLED  (0 << 5) /* interrupt disabled */
  69 #define CHANNEL_INT_THRESHOLD_25        (1 << 5) /* int on buffer >25% full */
  70 #define CHANNEL_INT_THRESHOLD_50        (2 << 5) /* int on buffer >50% full */
  71 #define CHANNEL_INT_THRESHOLD_75        (3 << 5) /* int on buffer >75% full */
  72 #define CHANNEL_INT_THRESHOLD_EMPTY     (4 << 5) /* int on buffer empty */
  73 #define CHANNEL_INT_THRESHOLD_NOT_EMPTY (5 << 5) /* int on buffer !empty */
  74 #define CHANNEL_INT_THRESHOLD_FULL      (6 << 5) /* int on buffer empty */
  75 #define CHANNEL_INT_THRESHOLD_NOT_FULL  (7 << 5) /* int on buffer !empty */
  76
  77 #define CHANNEL_RING_SHIFT              12
  78 #define CHANNEL_RING_SIZE               (1 << CHANNEL_RING_SHIFT)
  79 #define CHANNEL_RING_MASK               (CHANNEL_RING_SIZE - 1)
  80
  81 #define CHANNEL_LEFT_SHIFT 40
  82 #define CHANNEL_RIGHT_SHIFT 8
  83
  84 struct snd_sgio2audio_chan {
  85         int idx;
  86         struct snd_pcm_substream *substream;
  87         int pos;
  88         snd_pcm_uframes_t size;
  89         spinlock_t lock;
  90 };
  91
  92 /* definition of the chip-specific record */
  93 struct snd_sgio2audio {
  94         struct snd_card *card;
  95
  96         /* codec */
  97         struct snd_ad1843 ad1843;
  98         spinlock_t ad1843_lock;
  99
 100         /* channels */
 101         struct snd_sgio2audio_chan channel[3];
 102
 103         /* resources */
 104         void *ring_base;
 105         dma_addr_t ring_base_dma;
 106 };
 107
 108 /* AD1843 access */
 109
 110 /*
 111  * read_ad1843_reg returns the current contents of a 16 bit AD1843 register.
 112  *
 113  * Returns unsigned register value on success, -errno on failure.
 114  */
 115 static int read_ad1843_reg(void *priv, int reg)
 116 {
 117         struct snd_sgio2audio *chip = priv;
 118         int val;
 119         unsigned long flags;
 120
 121         spin_lock_irqsave(&chip->ad1843_lock, flags);
 122
 123         writeq((reg << CODEC_CONTROL_ADDRESS_SHIFT) |
 124                CODEC_CONTROL_READ, &mace->perif.audio.codec_control);
 125         wmb();
 126         val = readq(&mace->perif.audio.codec_control); /* flush bus */
 127         udelay(200);
 128
 129         val = readq(&mace->perif.audio.codec_read);
 130
 131         spin_unlock_irqrestore(&chip->ad1843_lock, flags);
 132         return val;
 133 }
 134
 135 /*
 136  * write_ad1843_reg writes the specified value to a 16 bit AD1843 register.
 137  */
 138 static int write_ad1843_reg(void *priv, int reg, int word)
 139 {
 140         struct snd_sgio2audio *chip = priv;
 141         int val;
 142         unsigned long flags;
 143
 144         spin_lock_irqsave(&chip->ad1843_lock, flags);
 145
 146         writeq((reg << CODEC_CONTROL_ADDRESS_SHIFT) |
 147                (word << CODEC_CONTROL_WORD_SHIFT),
 148                &mace->perif.audio.codec_control);
 149         wmb();
 150         val = readq(&mace->perif.audio.codec_control); /* flush bus */
 151         udelay(200);
 152
 153         spin_unlock_irqrestore(&chip->ad1843_lock, flags);
 154         return 0;
 155 }
 156
 157 static int sgio2audio_gain_info(struct snd_kcontrol *kcontrol,
 158                                struct snd_ctl_elem_info *uinfo)
 159 {
 160         struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
 161
 162         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 163         uinfo->count = 2;
 164         uinfo->value.integer.min = 0;
 165         uinfo->value.integer.max = ad1843_get_gain_max(&chip->ad1843,
 166                                              (int)kcontrol->private_value);
 167         return 0;
 168 }
 169
 170 static int sgio2audio_gain_get(struct snd_kcontrol *kcontrol,
 171                                struct snd_ctl_elem_value *ucontrol)
 172 {
 173         struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
 174         int vol;
 175
 176         vol = ad1843_get_gain(&chip->ad1843, (int)kcontrol->private_value);
 177
 178         ucontrol->value.integer.value[0] = (vol >> 8) & 0xFF;
 179         ucontrol->value.integer.value[1] = vol & 0xFF;
 180
 181         return 0;
 182 }
 183
 184 static int sgio2audio_gain_put(struct snd_kcontrol *kcontrol,
 185                         struct snd_ctl_elem_value *ucontrol)
 186 {
 187         struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
 188         int newvol, oldvol;
 189
 190         oldvol = ad1843_get_gain(&chip->ad1843, kcontrol->private_value);
 191         newvol = (ucontrol->value.integer.value[0] << 8) |
 192                 ucontrol->value.integer.value[1];
 193
 194         newvol = ad1843_set_gain(&chip->ad1843, kcontrol->private_value,
 195                 newvol);
 196
 197         return newvol != oldvol;
 198 }
 199
 200 static int sgio2audio_source_info(struct snd_kcontrol *kcontrol,
 201                                struct snd_ctl_elem_info *uinfo)
 202 {
 203         static const char *texts[3] = {
 204                 "Cam Mic", "Mic", "Line"
 205         };
 206         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 207         uinfo->count = 1;
 208         uinfo->value.enumerated.items = 3;
 209         if (uinfo->value.enumerated.item >= 3)
 210                 uinfo->value.enumerated.item = 1;
 211         strcpy(uinfo->value.enumerated.name,
 212                texts[uinfo->value.enumerated.item]);
 213         return 0;
 214 }
 215
 216 static int sgio2audio_source_get(struct snd_kcontrol *kcontrol,
 217                                struct snd_ctl_elem_value *ucontrol)
 218 {
 219         struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
 220
 221         ucontrol->value.enumerated.item[0] = ad1843_get_recsrc(&chip->ad1843);
 222         return 0;
 223 }
 224
 225 static int sgio2audio_source_put(struct snd_kcontrol *kcontrol,
 226                         struct snd_ctl_elem_value *ucontrol)
 227 {
 228         struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
 229         int newsrc, oldsrc;
 230
 231         oldsrc = ad1843_get_recsrc(&chip->ad1843);
 232         newsrc = ad1843_set_recsrc(&chip->ad1843,
 233                                    ucontrol->value.enumerated.item[0]);
 234
 235         return newsrc != oldsrc;
 236 }
 237
 238 /* dac1/pcm0 mixer control */
 239 static struct snd_kcontrol_new sgio2audio_ctrl_pcm0 __devinitdata = {
 240         .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
 241         .name           = "PCM Playback Volume",
 242         .index          = 0,
 243         .access         = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 244         .private_value  = AD1843_GAIN_PCM_0,
 245         .info           = sgio2audio_gain_info,
 246         .get            = sgio2audio_gain_get,
 247         .put            = sgio2audio_gain_put,
 248 };
 249
 250 /* dac2/pcm1 mixer control */
 251 static struct snd_kcontrol_new sgio2audio_ctrl_pcm1 __devinitdata = {
 252         .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
 253         .name           = "PCM Playback Volume",
 254         .index          = 1,
 255         .access         = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 256         .private_value  = AD1843_GAIN_PCM_1,
 257         .info           = sgio2audio_gain_info,
 258         .get            = sgio2audio_gain_get,
 259         .put            = sgio2audio_gain_put,
 260 };
 261
 262 /* record level mixer control */
 263 static struct snd_kcontrol_new sgio2audio_ctrl_reclevel __devinitdata = {
 264         .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
 265         .name           = "Capture Volume",
 266         .access         = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 267         .private_value  = AD1843_GAIN_RECLEV,
 268         .info           = sgio2audio_gain_info,
 269         .get            = sgio2audio_gain_get,
 270         .put            = sgio2audio_gain_put,
 271 };
 272
 273 /* record level source control */
 274 static struct snd_kcontrol_new sgio2audio_ctrl_recsource __devinitdata = {
 275         .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
 276         .name           = "Capture Source",
 277         .access         = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 278         .info           = sgio2audio_source_info,
 279         .get            = sgio2audio_source_get,
 280         .put            = sgio2audio_source_put,
 281 };
 282
 283 /* line mixer control */
 284 static struct snd_kcontrol_new sgio2audio_ctrl_line __devinitdata = {
 285         .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
 286         .name           = "Line Playback Volume",
 287         .index          = 0,
 288         .access         = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 289         .private_value  = AD1843_GAIN_LINE,
 290         .info           = sgio2audio_gain_info,
 291         .get            = sgio2audio_gain_get,
 292         .put            = sgio2audio_gain_put,
 293 };
 294
 295 /* cd mixer control */
 296 static struct snd_kcontrol_new sgio2audio_ctrl_cd __devinitdata = {
 297         .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
 298         .name           = "Line Playback Volume",
 299         .index          = 1,
 300         .access         = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 301         .private_value  = AD1843_GAIN_LINE_2,
 302         .info           = sgio2audio_gain_info,
 303         .get            = sgio2audio_gain_get,
 304         .put            = sgio2audio_gain_put,
 305 };
 306
 307 /* mic mixer control */
 308 static struct snd_kcontrol_new sgio2audio_ctrl_mic __devinitdata = {
 309         .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
 310         .name           = "Mic Playback Volume",
 311         .access         = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 312         .private_value  = AD1843_GAIN_MIC,
 313         .info           = sgio2audio_gain_info,
 314         .get            = sgio2audio_gain_get,
 315         .put            = sgio2audio_gain_put,
 316 };
 317
 318
 319 static int __devinit snd_sgio2audio_new_mixer(struct snd_sgio2audio *chip)
 320 {
 321         int err;
 322
 323         err = snd_ctl_add(chip->card,
 324                           snd_ctl_new1(&sgio2audio_ctrl_pcm0, chip));
 325         if (err < 0)
 326                 return err;
 327
 328         err = snd_ctl_add(chip->card,
 329                           snd_ctl_new1(&sgio2audio_ctrl_pcm1, chip));
 330         if (err < 0)
 331                 return err;
 332
 333         err = snd_ctl_add(chip->card,
 334                           snd_ctl_new1(&sgio2audio_ctrl_reclevel, chip));
 335         if (err < 0)
 336                 return err;
 337
 338         err = snd_ctl_add(chip->card,
 339                           snd_ctl_new1(&sgio2audio_ctrl_recsource, chip));
 340         if (err < 0)
 341                 return err;
 342         err = snd_ctl_add(chip->card,
 343                           snd_ctl_new1(&sgio2audio_ctrl_line, chip));
 344         if (err < 0)
 345                 return err;
 346
 347         err = snd_ctl_add(chip->card,
 348                           snd_ctl_new1(&sgio2audio_ctrl_cd, chip));
 349         if (err < 0)
 350                 return err;
 351
 352         err = snd_ctl_add(chip->card,
 353                           snd_ctl_new1(&sgio2audio_ctrl_mic, chip));
 354         if (err < 0)
 355                 return err;
 356
 357         return 0;
 358 }
 359
 360 /* low-level audio interface DMA */
 361
 362 /* get data out of bounce buffer, count must be a multiple of 32 */
 363 /* returns 1 if a period has elapsed */
 364 static int snd_sgio2audio_dma_pull_frag(struct snd_sgio2audio *chip,
 365                                         unsigned int ch, unsigned int count)
 366 {
 367         int ret;
 368         unsigned long src_base, src_pos, dst_mask;
 369         unsigned char *dst_base;
 370         int dst_pos;
 371         u64 *src;
 372         s16 *dst;
 373         u64 x;
 374         unsigned long flags;
 375         struct snd_pcm_runtime *runtime = chip->channel[ch].substream->runtime;
 376
 377         spin_lock_irqsave(&chip->channel[ch].lock, flags);
 378
 379         src_base = (unsigned long) chip->ring_base | (ch << CHANNEL_RING_SHIFT);
 380         src_pos = readq(&mace->perif.audio.chan[ch].read_ptr);
 381         dst_base = runtime->dma_area;
 382         dst_pos = chip->channel[ch].pos;
 383         dst_mask = frames_to_bytes(runtime, runtime->buffer_size) - 1;
 384
 385         /* check if a period has elapsed */
 386         chip->channel[ch].size += (count >> 3); /* in frames */
 387         ret = chip->channel[ch].size >= runtime->period_size;
 388         chip->channel[ch].size %= runtime->period_size;
 389
 390         while (count) {
 391                 src = (u64 *)(src_base + src_pos);
 392                 dst = (s16 *)(dst_base + dst_pos);
 393
 394                 x = *src;
 395                 dst[0] = (x >> CHANNEL_LEFT_SHIFT) & 0xffff;
 396                 dst[1] = (x >> CHANNEL_RIGHT_SHIFT) & 0xffff;
 397
 398                 src_pos = (src_pos + sizeof(u64)) & CHANNEL_RING_MASK;
 399                 dst_pos = (dst_pos + 2 * sizeof(s16)) & dst_mask;
 400                 count -= sizeof(u64);
 401         }
 402
 403         writeq(src_pos, &mace->perif.audio.chan[ch].read_ptr); /* in bytes */
 404         chip->channel[ch].pos = dst_pos;
 405
 406         spin_unlock_irqrestore(&chip->channel[ch].lock, flags);
 407         return ret;
 408 }
 409
 410 /* put some DMA data in bounce buffer, count must be a multiple of 32 */
 411 /* returns 1 if a period has elapsed */
 412 static int snd_sgio2audio_dma_push_frag(struct snd_sgio2audio *chip,
 413                                         unsigned int ch, unsigned int count)
 414 {
 415         int ret;
 416         s64 l, r;
 417         unsigned long dst_base, dst_pos, src_mask;
 418         unsigned char *src_base;
 419         int src_pos;
 420         u64 *dst;
 421         s16 *src;
 422         unsigned long flags;
 423         struct snd_pcm_runtime *runtime = chip->channel[ch].substream->runtime;
 424
 425         spin_lock_irqsave(&chip->channel[ch].lock, flags);
 426
 427         dst_base = (unsigned long)chip->ring_base | (ch << CHANNEL_RING_SHIFT);
 428         dst_pos = readq(&mace->perif.audio.chan[ch].write_ptr);
 429         src_base = runtime->dma_area;
 430         src_pos = chip->channel[ch].pos;
 431         src_mask = frames_to_bytes(runtime, runtime->buffer_size) - 1;
 432
 433         /* check if a period has elapsed */
 434         chip->channel[ch].size += (count >> 3); /* in frames */
 435         ret = chip->channel[ch].size >= runtime->period_size;
 436         chip->channel[ch].size %= runtime->period_size;
 437
 438         while (count) {
 439                 src = (s16 *)(src_base + src_pos);
 440                 dst = (u64 *)(dst_base + dst_pos);
 441
 442                 l = src[0]; /* sign extend */
 443                 r = src[1]; /* sign extend */
 444
 445                 *dst = ((l & 0x00ffffff) << CHANNEL_LEFT_SHIFT) |
 446                         ((r & 0x00ffffff) << CHANNEL_RIGHT_SHIFT);
 447
 448                 dst_pos = (dst_pos + sizeof(u64)) & CHANNEL_RING_MASK;
 449                 src_pos = (src_pos + 2 * sizeof(s16)) & src_mask;
 450                 count -= sizeof(u64);
 451         }
 452
 453         writeq(dst_pos, &mace->perif.audio.chan[ch].write_ptr); /* in bytes */
 454         chip->channel[ch].pos = src_pos;
 455
 456         spin_unlock_irqrestore(&chip->channel[ch].lock, flags);
 457         return ret;
 458 }
 459
 460 static int snd_sgio2audio_dma_start(struct snd_pcm_substream *substream)
 461 {
 462         struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
 463         struct snd_sgio2audio_chan *chan = substream->runtime->private_data;
 464         int ch = chan->idx;
 465
 466         /* reset DMA channel */
 467         writeq(CHANNEL_CONTROL_RESET, &mace->perif.audio.chan[ch].control);
 468         udelay(10);
 469         writeq(0, &mace->perif.audio.chan[ch].control);
 470
 471         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 472                 /* push a full buffer */
 473                 snd_sgio2audio_dma_push_frag(chip, ch, CHANNEL_RING_SIZE - 32);
 474         }
 475         /* set DMA to wake on 50% empty and enable interrupt */
 476         writeq(CHANNEL_DMA_ENABLE | CHANNEL_INT_THRESHOLD_50,
 477                &mace->perif.audio.chan[ch].control);
 478         return 0;
 479 }
 480
 481 static int snd_sgio2audio_dma_stop(struct snd_pcm_substream *substream)
 482 {
 483         struct snd_sgio2audio_chan *chan = substream->runtime->private_data;
 484
 485         writeq(0, &mace->perif.audio.chan[chan->idx].control);
 486         return 0;
 487 }
 488
 489 static irqreturn_t snd_sgio2audio_dma_in_isr(int irq, void *dev_id)
 490 {
 491         struct snd_sgio2audio_chan *chan = dev_id;
 492         struct snd_pcm_substream *substream;
 493         struct snd_sgio2audio *chip;
 494         int count, ch;
 495
 496         substream = chan->substream;
 497         chip = snd_pcm_substream_chip(substream);
 498         ch = chan->idx;
 499
 500         /* empty the ring */
 501         count = CHANNEL_RING_SIZE -
 502                 readq(&mace->perif.audio.chan[ch].depth) - 32;
 503         if (snd_sgio2audio_dma_pull_frag(chip, ch, count))
 504                 snd_pcm_period_elapsed(substream);
 505
 506         return IRQ_HANDLED;
 507 }
 508
 509 static irqreturn_t snd_sgio2audio_dma_out_isr(int irq, void *dev_id)
 510 {
 511         struct snd_sgio2audio_chan *chan = dev_id;
 512         struct snd_pcm_substream *substream;
 513         struct snd_sgio2audio *chip;
 514         int count, ch;
 515
 516         substream = chan->substream;
 517         chip = snd_pcm_substream_chip(substream);
 518         ch = chan->idx;
 519         /* fill the ring */
 520         count = CHANNEL_RING_SIZE -
 521                 readq(&mace->perif.audio.chan[ch].depth) - 32;
 522         if (snd_sgio2audio_dma_push_frag(chip, ch, count))
 523                 snd_pcm_period_elapsed(substream);
 524
 525         return IRQ_HANDLED;
 526 }
 527
 528 static irqreturn_t snd_sgio2audio_error_isr(int irq, void *dev_id)
 529 {
 530         struct snd_sgio2audio_chan *chan = dev_id;
 531         struct snd_pcm_substream *substream;
 532
 533         substream = chan->substream;
 534         snd_sgio2audio_dma_stop(substream);
 535         snd_sgio2audio_dma_start(substream);
 536         return IRQ_HANDLED;
 537 }
 538
 539 /* PCM part */
 540 /* PCM hardware definition */
 541 static struct snd_pcm_hardware snd_sgio2audio_pcm_hw = {
 542         .info = (SNDRV_PCM_INFO_MMAP |
 543                  SNDRV_PCM_INFO_MMAP_VALID |
 544                  SNDRV_PCM_INFO_INTERLEAVED |
 545                  SNDRV_PCM_INFO_BLOCK_TRANSFER),
 546         .formats =          SNDRV_PCM_FMTBIT_S16_BE,
 547         .rates =            SNDRV_PCM_RATE_8000_48000,
 548         .rate_min =         8000,
 549         .rate_max =         48000,
 550         .channels_min =     2,
 551         .channels_max =     2,
 552         .buffer_bytes_max = 65536,
 553         .period_bytes_min = 32768,
 554         .period_bytes_max = 65536,
 555         .periods_min =      1,
 556         .periods_max =      1024,
 557 };
 558
 559 /* PCM playback open callback */
 560 static int snd_sgio2audio_playback1_open(struct snd_pcm_substream *substream)
 561 {
 562         struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
 563         struct snd_pcm_runtime *runtime = substream->runtime;
 564
 565         runtime->hw = snd_sgio2audio_pcm_hw;
 566         runtime->private_data = &chip->channel[1];
 567         return 0;
 568 }
 569
 570 static int snd_sgio2audio_playback2_open(struct snd_pcm_substream *substream)
 571 {
 572         struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
 573         struct snd_pcm_runtime *runtime = substream->runtime;
 574
 575         runtime->hw = snd_sgio2audio_pcm_hw;
 576         runtime->private_data = &chip->channel[2];
 577         return 0;
 578 }
 579
 580 /* PCM capture open callback */
 581 static int snd_sgio2audio_capture_open(struct snd_pcm_substream *substream)
 582 {
 583         struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
 584         struct snd_pcm_runtime *runtime = substream->runtime;
 585
 586         runtime->hw = snd_sgio2audio_pcm_hw;
 587         runtime->private_data = &chip->channel[0];
 588         return 0;
 589 }
 590
 591 /* PCM close callback */
 592 static int snd_sgio2audio_pcm_close(struct snd_pcm_substream *substream)
 593 {
 594         struct snd_pcm_runtime *runtime = substream->runtime;
 595
 596         runtime->private_data = NULL;
 597         return 0;
 598 }
 599
 600
 601 /* hw_params callback */
 602 static int snd_sgio2audio_pcm_hw_params(struct snd_pcm_substream *substream,
 603                                         struct snd_pcm_hw_params *hw_params)
 604 {
 605         return snd_pcm_lib_alloc_vmalloc_buffer(substream,
 606                                                 params_buffer_bytes(hw_params));
 607 }
 608
 609 /* hw_free callback */
 610 static int snd_sgio2audio_pcm_hw_free(struct snd_pcm_substream *substream)
 611 {
 612         return snd_pcm_lib_free_vmalloc_buffer(substream);
 613 }
 614
 615 /* prepare callback */
 616 static int snd_sgio2audio_pcm_prepare(struct snd_pcm_substream *substream)
 617 {
 618         struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
 619         struct snd_pcm_runtime *runtime = substream->runtime;
 620         struct snd_sgio2audio_chan *chan = substream->runtime->private_data;
 621         int ch = chan->idx;
 622         unsigned long flags;
 623
 624         spin_lock_irqsave(&chip->channel[ch].lock, flags);
 625
 626         /* Setup the pseudo-dma transfer pointers.  */
 627         chip->channel[ch].pos = 0;
 628         chip->channel[ch].size = 0;
 629         chip->channel[ch].substream = substream;
 630
 631         /* set AD1843 format */
 632         /* hardware format is always S16_LE */
 633         switch (substream->stream) {
 634         case SNDRV_PCM_STREAM_PLAYBACK:
 635                 ad1843_setup_dac(&chip->ad1843,
 636                                  ch - 1,
 637                                  runtime->rate,
 638                                  SNDRV_PCM_FORMAT_S16_LE,
 639                                  runtime->channels);
 640                 break;
 641         case SNDRV_PCM_STREAM_CAPTURE:
 642                 ad1843_setup_adc(&chip->ad1843,
 643                                  runtime->rate,
 644                                  SNDRV_PCM_FORMAT_S16_LE,
 645                                  runtime->channels);
 646                 break;
 647         }
 648         spin_unlock_irqrestore(&chip->channel[ch].lock, flags);
 649         return 0;
 650 }
 651
 652 /* trigger callback */
 653 static int snd_sgio2audio_pcm_trigger(struct snd_pcm_substream *substream,
 654                                       int cmd)
 655 {
 656         switch (cmd) {
 657         case SNDRV_PCM_TRIGGER_START:
 658                 /* start the PCM engine */
 659                 snd_sgio2audio_dma_start(substream);
 660                 break;
 661         case SNDRV_PCM_TRIGGER_STOP:
 662                 /* stop the PCM engine */
 663                 snd_sgio2audio_dma_stop(substream);
 664                 break;
 665         default:
 666                 return -EINVAL;
 667         }
 668         return 0;
 669 }
 670
 671 /* pointer callback */
 672 static snd_pcm_uframes_t
 673 snd_sgio2audio_pcm_pointer(struct snd_pcm_substream *substream)
 674 {
 675         struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
 676         struct snd_sgio2audio_chan *chan = substream->runtime->private_data;
 677
 678         /* get the current hardware pointer */
 679         return bytes_to_frames(substream->runtime,
 680                                chip->channel[chan->idx].pos);
 681 }
 682
 683 /* operators */
 684 static struct snd_pcm_ops snd_sgio2audio_playback1_ops = {
 685         .open =        snd_sgio2audio_playback1_open,
 686         .close =       snd_sgio2audio_pcm_close,
 687         .ioctl =       snd_pcm_lib_ioctl,
 688         .hw_params =   snd_sgio2audio_pcm_hw_params,
 689         .hw_free =     snd_sgio2audio_pcm_hw_free,
 690         .prepare =     snd_sgio2audio_pcm_prepare,
 691         .trigger =     snd_sgio2audio_pcm_trigger,
 692         .pointer =     snd_sgio2audio_pcm_pointer,
 693         .page =        snd_pcm_lib_get_vmalloc_page,
 694         .mmap =        snd_pcm_lib_mmap_vmalloc,
 695 };
 696
 697 static struct snd_pcm_ops snd_sgio2audio_playback2_ops = {
 698         .open =        snd_sgio2audio_playback2_open,
 699         .close =       snd_sgio2audio_pcm_close,
 700         .ioctl =       snd_pcm_lib_ioctl,
 701         .hw_params =   snd_sgio2audio_pcm_hw_params,
 702         .hw_free =     snd_sgio2audio_pcm_hw_free,
 703         .prepare =     snd_sgio2audio_pcm_prepare,
 704         .trigger =     snd_sgio2audio_pcm_trigger,
 705         .pointer =     snd_sgio2audio_pcm_pointer,
 706         .page =        snd_pcm_lib_get_vmalloc_page,
 707         .mmap =        snd_pcm_lib_mmap_vmalloc,
 708 };
 709
 710 static struct snd_pcm_ops snd_sgio2audio_capture_ops = {
 711         .open =        snd_sgio2audio_capture_open,
 712         .close =       snd_sgio2audio_pcm_close,
 713         .ioctl =       snd_pcm_lib_ioctl,
 714         .hw_params =   snd_sgio2audio_pcm_hw_params,
 715         .hw_free =     snd_sgio2audio_pcm_hw_free,
 716         .prepare =     snd_sgio2audio_pcm_prepare,
 717         .trigger =     snd_sgio2audio_pcm_trigger,
 718         .pointer =     snd_sgio2audio_pcm_pointer,
 719         .page =        snd_pcm_lib_get_vmalloc_page,
 720         .mmap =        snd_pcm_lib_mmap_vmalloc,
 721 };
 722
 723 /*
 724  *  definitions of capture are omitted here...
 725  */
 726
 727 /* create a pcm device */
 728 static int __devinit snd_sgio2audio_new_pcm(struct snd_sgio2audio *chip)
 729 {
 730         struct snd_pcm *pcm;
 731         int err;
 732
 733         /* create first pcm device with one outputs and one input */
 734         err = snd_pcm_new(chip->card, "SGI O2 Audio", 0, 1, 1, &pcm);
 735         if (err < 0)
 736                 return err;
 737
 738         pcm->private_data = chip;
 739         strcpy(pcm->name, "SGI O2 DAC1");
 740
 741         /* set operators */
 742         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
 743                         &snd_sgio2audio_playback1_ops);
 744         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
 745                         &snd_sgio2audio_capture_ops);
 746
 747         /* create second  pcm device with one outputs and no input */
 748         err = snd_pcm_new(chip->card, "SGI O2 Audio", 1, 1, 0, &pcm);
 749         if (err < 0)
 750                 return err;
 751
 752         pcm->private_data = chip;
 753         strcpy(pcm->name, "SGI O2 DAC2");
 754
 755         /* set operators */
 756         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
 757                         &snd_sgio2audio_playback2_ops);
 758
 759         return 0;
 760 }
 761
 762 static struct {
 763         int idx;
 764         int irq;
 765         irqreturn_t (*isr)(int, void *);
 766         const char *desc;
 767 } snd_sgio2_isr_table[] = {
 768         {
 769                 .idx = 0,
 770                 .irq = MACEISA_AUDIO1_DMAT_IRQ,
 771                 .isr = snd_sgio2audio_dma_in_isr,
 772                 .desc = "Capture DMA Channel 0"
 773         }, {
 774                 .idx = 0,
 775                 .irq = MACEISA_AUDIO1_OF_IRQ,
 776                 .isr = snd_sgio2audio_error_isr,
 777                 .desc = "Capture Overflow"
 778         }, {
 779                 .idx = 1,
 780                 .irq = MACEISA_AUDIO2_DMAT_IRQ,
 781                 .isr = snd_sgio2audio_dma_out_isr,
 782                 .desc = "Playback DMA Channel 1"
 783         }, {
 784                 .idx = 1,
 785                 .irq = MACEISA_AUDIO2_MERR_IRQ,
 786                 .isr = snd_sgio2audio_error_isr,
 787                 .desc = "Memory Error Channel 1"
 788         }, {
 789                 .idx = 2,
 790                 .irq = MACEISA_AUDIO3_DMAT_IRQ,
 791                 .isr = snd_sgio2audio_dma_out_isr,
 792                 .desc = "Playback DMA Channel 2"
 793         }, {
 794                 .idx = 2,
 795                 .irq = MACEISA_AUDIO3_MERR_IRQ,
 796                 .isr = snd_sgio2audio_error_isr,
 797                 .desc = "Memory Error Channel 2"
 798         }
 799 };
 800
 801 /* ALSA driver */
 802
 803 static int snd_sgio2audio_free(struct snd_sgio2audio *chip)
 804 {
 805         int i;
 806
 807         /* reset interface */
 808         writeq(AUDIO_CONTROL_RESET, &mace->perif.audio.control);
 809         udelay(1);
 810         writeq(0, &mace->perif.audio.control);
 811
 812         /* release IRQ's */
 813         for (i = 0; i < ARRAY_SIZE(snd_sgio2_isr_table); i++)
 814                 free_irq(snd_sgio2_isr_table[i].irq,
 815                          &chip->channel[snd_sgio2_isr_table[i].idx]);
 816
 817         dma_free_coherent(NULL, MACEISA_RINGBUFFERS_SIZE,
 818                           chip->ring_base, chip->ring_base_dma);
 819
 820         /* release card data */
 821         kfree(chip);
 822         return 0;
 823 }
 824
 825 static int snd_sgio2audio_dev_free(struct snd_device *device)
 826 {
 827         struct snd_sgio2audio *chip = device->device_data;
 828
 829         return snd_sgio2audio_free(chip);
 830 }
 831
 832 static struct snd_device_ops ops = {
 833         .dev_free = snd_sgio2audio_dev_free,
 834 };
 835
 836 static int __devinit snd_sgio2audio_create(struct snd_card *card,
 837                                            struct snd_sgio2audio **rchip)
 838 {
 839         struct snd_sgio2audio *chip;
 840         int i, err;
 841
 842         *rchip = NULL;
 843
 844         /* check if a codec is attached to the interface */
 845         /* (Audio or Audio/Video board present) */
 846         if (!(readq(&mace->perif.audio.control) & AUDIO_CONTROL_CODEC_PRESENT))
 847                 return -ENOENT;
 848
 849         chip = kzalloc(sizeof(struct snd_sgio2audio), GFP_KERNEL);
 850         if (chip == NULL)
 851                 return -ENOMEM;
 852
 853         chip->card = card;
 854
 855         chip->ring_base = dma_alloc_coherent(NULL, MACEISA_RINGBUFFERS_SIZE,
 856                                              &chip->ring_base_dma, GFP_USER);
 857         if (chip->ring_base == NULL) {
 858                 printk(KERN_ERR
 859                        "sgio2audio: could not allocate ring buffers\n");
 860                 kfree(chip);
 861                 return -ENOMEM;
 862         }
 863
 864         spin_lock_init(&chip->ad1843_lock);
 865
 866         /* initialize channels */
 867         for (i = 0; i < 3; i++) {
 868                 spin_lock_init(&chip->channel[i].lock);
 869                 chip->channel[i].idx = i;
 870         }
 871
 872         /* allocate IRQs */
 873         for (i = 0; i < ARRAY_SIZE(snd_sgio2_isr_table); i++) {
 874                 if (request_irq(snd_sgio2_isr_table[i].irq,
 875                                 snd_sgio2_isr_table[i].isr,
 876                                 0,
 877                                 snd_sgio2_isr_table[i].desc,
 878                                 &chip->channel[snd_sgio2_isr_table[i].idx])) {
 879                         snd_sgio2audio_free(chip);
 880                         printk(KERN_ERR "sgio2audio: cannot allocate irq %d\n",
 881                                snd_sgio2_isr_table[i].irq);
 882                         return -EBUSY;
 883                 }
 884         }
 885
 886         /* reset the interface */
 887         writeq(AUDIO_CONTROL_RESET, &mace->perif.audio.control);
 888         udelay(1);
 889         writeq(0, &mace->perif.audio.control);
 890         msleep_interruptible(1); /* give time to recover */
 891
 892         /* set ring base */
 893         writeq(chip->ring_base_dma, &mace->perif.ctrl.ringbase);
 894
 895         /* attach the AD1843 codec */
 896         chip->ad1843.read = read_ad1843_reg;
 897         chip->ad1843.write = write_ad1843_reg;
 898         chip->ad1843.chip = chip;
 899
 900         /* initialize the AD1843 codec */
 901         err = ad1843_init(&chip->ad1843);
 902         if (err < 0) {
 903                 snd_sgio2audio_free(chip);
 904                 return err;
 905         }
 906
 907         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
 908         if (err < 0) {
 909                 snd_sgio2audio_free(chip);
 910                 return err;
 911         }
 912         *rchip = chip;
 913         return 0;
 914 }
 915
 916 static int __devinit snd_sgio2audio_probe(struct platform_device *pdev)
 917 {
 918         struct snd_card *card;
 919         struct snd_sgio2audio *chip;
 920         int err;
 921
 922         err = snd_card_create(index, id, THIS_MODULE, 0, &card);
 923         if (err < 0)
 924                 return err;
 925
 926         err = snd_sgio2audio_create(card, &chip);
 927         if (err < 0) {
 928                 snd_card_free(card);
 929                 return err;
 930         }
 931         snd_card_set_dev(card, &pdev->dev);
 932
 933         err = snd_sgio2audio_new_pcm(chip);
 934         if (err < 0) {
 935                 snd_card_free(card);
 936                 return err;
 937         }
 938         err = snd_sgio2audio_new_mixer(chip);
 939         if (err < 0) {
 940                 snd_card_free(card);
 941                 return err;
 942         }
 943
 944         strcpy(card->driver, "SGI O2 Audio");
 945         strcpy(card->shortname, "SGI O2 Audio");
 946         sprintf(card->longname, "%s irq %i-%i",
 947                 card->shortname,
 948                 MACEISA_AUDIO1_DMAT_IRQ,
 949                 MACEISA_AUDIO3_MERR_IRQ);
 950
 951         err = snd_card_register(card);
 952         if (err < 0) {
 953                 snd_card_free(card);
 954                 return err;
 955         }
 956         platform_set_drvdata(pdev, card);
 957         return 0;
 958 }
 959
 960 static int __devexit snd_sgio2audio_remove(struct platform_device *pdev)
 961 {
 962         struct snd_card *card = platform_get_drvdata(pdev);
 963
 964         snd_card_free(card);
 965         platform_set_drvdata(pdev, NULL);
 966         return 0;
 967 }
 968
 969 static struct platform_driver sgio2audio_driver = {
 970         .probe  = snd_sgio2audio_probe,
 971         .remove = __devexit_p(snd_sgio2audio_remove),
 972         .driver = {
 973                 .name   = "sgio2audio",
 974                 .owner  = THIS_MODULE,
 975         }
 976 };
 977
 978 static int __init alsa_card_sgio2audio_init(void)
 979 {
 980         return platform_driver_register(&sgio2audio_driver);
 981 }
 982
 983 static void __exit alsa_card_sgio2audio_exit(void)
 984 {
 985         platform_driver_unregister(&sgio2audio_driver);
 986 }
 987
 988 module_init(alsa_card_sgio2audio_init)
 989 module_exit(alsa_card_sgio2audio_exit)