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