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 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 45MODULE_AUTHOR("Vivien Chappelier <vivien.chappelier@linux-mips.org>"); 46MODULE_DESCRIPTION("SGI O2 Audio"); 47MODULE_LICENSE("GPL"); 48MODULE_SUPPORTED_DEVICE("{{Silicon Graphics, O2 Audio}}"); 49 50static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */ 51static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */ 52 53module_param(index, int, 0444); 54MODULE_PARM_DESC(index, "Index value for SGI O2 soundcard."); 55module_param(id, charp, 0444); 56MODULE_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 84struct 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 */ 93struct 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 */ 115static 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 */ 138static 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 157static 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 170static 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 184static 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 200static 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 216static 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 225static 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 */ 239static 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 */ 251static 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 */ 263static 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 */ 274static 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 */ 284static 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 */ 296static 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 */ 308static 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 319static 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 */ 364static 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 */ 412static 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 460static 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 481static 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 489static 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 509static 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 528static 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 */ 541static 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 */ 560static 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 570static 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 */ 581static 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 */ 592static 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 */ 602static 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 */ 610static 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 */ 616static 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 */ 653static 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 */ 672static snd_pcm_uframes_t 673snd_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 */ 684static 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 697static 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 710static 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 */ 728static 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 762static 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 803static 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 825static 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 832static struct snd_device_ops ops = { 833 .dev_free = snd_sgio2audio_dev_free, 834}; 835 836static 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 916static 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 960static 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 969static 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 978static int __init alsa_card_sgio2audio_init(void) 979{ 980 return platform_driver_register(&sgio2audio_driver); 981} 982 983static void __exit alsa_card_sgio2audio_exit(void) 984{ 985 platform_driver_unregister(&sgio2audio_driver); 986} 987 988module_init(alsa_card_sgio2audio_init) 989module_exit(alsa_card_sgio2audio_exit) 990