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 46 MODULE_AUTHOR("Vivien Chappelier <vivien.chappelier@linux-mips.org>"); 47 MODULE_DESCRIPTION("SGI O2 Audio"); 48 MODULE_LICENSE("GPL"); 49 MODULE_SUPPORTED_DEVICE("{{Silicon Graphics, O2 Audio}}"); 50 51 static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */ 52 static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */ 53 54 module_param(index, int, 0444); 55 MODULE_PARM_DESC(index, "Index value for SGI O2 soundcard."); 56 module_param(id, charp, 0444); 57 MODULE_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 85 struct 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 */ 94 struct 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 */ 116 static 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 */ 139 static 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 158 static 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 171 static 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 185 static 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 201 static 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 210 static 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 219 static 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 */ 233 static const 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 */ 245 static const 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 */ 257 static const 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 */ 268 static const 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 */ 278 static const 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 */ 290 static const 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 */ 302 static const 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 313 static 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 */ 358 static 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 */ 406 static 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 454 static 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 475 static 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 483 static 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 503 static 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 522 static 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 */ 535 static const 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 */ 554 static 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 564 static 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 */ 575 static 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 */ 586 static 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 */ 596 static 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 */ 604 static 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 */ 610 static 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 */ 647 static 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 */ 666 static snd_pcm_uframes_t 667 snd_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 */ 678 static const 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 }; 689 690 static const struct snd_pcm_ops snd_sgio2audio_playback2_ops = { 691 .open = snd_sgio2audio_playback2_open, 692 .close = snd_sgio2audio_pcm_close, 693 .ioctl = snd_pcm_lib_ioctl, 694 .hw_params = snd_sgio2audio_pcm_hw_params, 695 .hw_free = snd_sgio2audio_pcm_hw_free, 696 .prepare = snd_sgio2audio_pcm_prepare, 697 .trigger = snd_sgio2audio_pcm_trigger, 698 .pointer = snd_sgio2audio_pcm_pointer, 699 .page = snd_pcm_lib_get_vmalloc_page, 700 }; 701 702 static const struct snd_pcm_ops snd_sgio2audio_capture_ops = { 703 .open = snd_sgio2audio_capture_open, 704 .close = snd_sgio2audio_pcm_close, 705 .ioctl = snd_pcm_lib_ioctl, 706 .hw_params = snd_sgio2audio_pcm_hw_params, 707 .hw_free = snd_sgio2audio_pcm_hw_free, 708 .prepare = snd_sgio2audio_pcm_prepare, 709 .trigger = snd_sgio2audio_pcm_trigger, 710 .pointer = snd_sgio2audio_pcm_pointer, 711 .page = snd_pcm_lib_get_vmalloc_page, 712 }; 713 714 /* 715 * definitions of capture are omitted here... 716 */ 717 718 /* create a pcm device */ 719 static int snd_sgio2audio_new_pcm(struct snd_sgio2audio *chip) 720 { 721 struct snd_pcm *pcm; 722 int err; 723 724 /* create first pcm device with one outputs and one input */ 725 err = snd_pcm_new(chip->card, "SGI O2 Audio", 0, 1, 1, &pcm); 726 if (err < 0) 727 return err; 728 729 pcm->private_data = chip; 730 strcpy(pcm->name, "SGI O2 DAC1"); 731 732 /* set operators */ 733 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 734 &snd_sgio2audio_playback1_ops); 735 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 736 &snd_sgio2audio_capture_ops); 737 738 /* create second pcm device with one outputs and no input */ 739 err = snd_pcm_new(chip->card, "SGI O2 Audio", 1, 1, 0, &pcm); 740 if (err < 0) 741 return err; 742 743 pcm->private_data = chip; 744 strcpy(pcm->name, "SGI O2 DAC2"); 745 746 /* set operators */ 747 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 748 &snd_sgio2audio_playback2_ops); 749 750 return 0; 751 } 752 753 static struct { 754 int idx; 755 int irq; 756 irqreturn_t (*isr)(int, void *); 757 const char *desc; 758 } snd_sgio2_isr_table[] = { 759 { 760 .idx = 0, 761 .irq = MACEISA_AUDIO1_DMAT_IRQ, 762 .isr = snd_sgio2audio_dma_in_isr, 763 .desc = "Capture DMA Channel 0" 764 }, { 765 .idx = 0, 766 .irq = MACEISA_AUDIO1_OF_IRQ, 767 .isr = snd_sgio2audio_error_isr, 768 .desc = "Capture Overflow" 769 }, { 770 .idx = 1, 771 .irq = MACEISA_AUDIO2_DMAT_IRQ, 772 .isr = snd_sgio2audio_dma_out_isr, 773 .desc = "Playback DMA Channel 1" 774 }, { 775 .idx = 1, 776 .irq = MACEISA_AUDIO2_MERR_IRQ, 777 .isr = snd_sgio2audio_error_isr, 778 .desc = "Memory Error Channel 1" 779 }, { 780 .idx = 2, 781 .irq = MACEISA_AUDIO3_DMAT_IRQ, 782 .isr = snd_sgio2audio_dma_out_isr, 783 .desc = "Playback DMA Channel 2" 784 }, { 785 .idx = 2, 786 .irq = MACEISA_AUDIO3_MERR_IRQ, 787 .isr = snd_sgio2audio_error_isr, 788 .desc = "Memory Error Channel 2" 789 } 790 }; 791 792 /* ALSA driver */ 793 794 static int snd_sgio2audio_free(struct snd_sgio2audio *chip) 795 { 796 int i; 797 798 /* reset interface */ 799 writeq(AUDIO_CONTROL_RESET, &mace->perif.audio.control); 800 udelay(1); 801 writeq(0, &mace->perif.audio.control); 802 803 /* release IRQ's */ 804 for (i = 0; i < ARRAY_SIZE(snd_sgio2_isr_table); i++) 805 free_irq(snd_sgio2_isr_table[i].irq, 806 &chip->channel[snd_sgio2_isr_table[i].idx]); 807 808 dma_free_coherent(chip->card->dev, MACEISA_RINGBUFFERS_SIZE, 809 chip->ring_base, chip->ring_base_dma); 810 811 /* release card data */ 812 kfree(chip); 813 return 0; 814 } 815 816 static int snd_sgio2audio_dev_free(struct snd_device *device) 817 { 818 struct snd_sgio2audio *chip = device->device_data; 819 820 return snd_sgio2audio_free(chip); 821 } 822 823 static struct snd_device_ops ops = { 824 .dev_free = snd_sgio2audio_dev_free, 825 }; 826 827 static int snd_sgio2audio_create(struct snd_card *card, 828 struct snd_sgio2audio **rchip) 829 { 830 struct snd_sgio2audio *chip; 831 int i, err; 832 833 *rchip = NULL; 834 835 /* check if a codec is attached to the interface */ 836 /* (Audio or Audio/Video board present) */ 837 if (!(readq(&mace->perif.audio.control) & AUDIO_CONTROL_CODEC_PRESENT)) 838 return -ENOENT; 839 840 chip = kzalloc(sizeof(*chip), GFP_KERNEL); 841 if (chip == NULL) 842 return -ENOMEM; 843 844 chip->card = card; 845 846 chip->ring_base = dma_alloc_coherent(card->dev, 847 MACEISA_RINGBUFFERS_SIZE, 848 &chip->ring_base_dma, GFP_KERNEL); 849 if (chip->ring_base == NULL) { 850 printk(KERN_ERR 851 "sgio2audio: could not allocate ring buffers\n"); 852 kfree(chip); 853 return -ENOMEM; 854 } 855 856 spin_lock_init(&chip->ad1843_lock); 857 858 /* initialize channels */ 859 for (i = 0; i < 3; i++) { 860 spin_lock_init(&chip->channel[i].lock); 861 chip->channel[i].idx = i; 862 } 863 864 /* allocate IRQs */ 865 for (i = 0; i < ARRAY_SIZE(snd_sgio2_isr_table); i++) { 866 if (request_irq(snd_sgio2_isr_table[i].irq, 867 snd_sgio2_isr_table[i].isr, 868 0, 869 snd_sgio2_isr_table[i].desc, 870 &chip->channel[snd_sgio2_isr_table[i].idx])) { 871 snd_sgio2audio_free(chip); 872 printk(KERN_ERR "sgio2audio: cannot allocate irq %d\n", 873 snd_sgio2_isr_table[i].irq); 874 return -EBUSY; 875 } 876 } 877 878 /* reset the interface */ 879 writeq(AUDIO_CONTROL_RESET, &mace->perif.audio.control); 880 udelay(1); 881 writeq(0, &mace->perif.audio.control); 882 msleep_interruptible(1); /* give time to recover */ 883 884 /* set ring base */ 885 writeq(chip->ring_base_dma, &mace->perif.ctrl.ringbase); 886 887 /* attach the AD1843 codec */ 888 chip->ad1843.read = read_ad1843_reg; 889 chip->ad1843.write = write_ad1843_reg; 890 chip->ad1843.chip = chip; 891 892 /* initialize the AD1843 codec */ 893 err = ad1843_init(&chip->ad1843); 894 if (err < 0) { 895 snd_sgio2audio_free(chip); 896 return err; 897 } 898 899 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); 900 if (err < 0) { 901 snd_sgio2audio_free(chip); 902 return err; 903 } 904 *rchip = chip; 905 return 0; 906 } 907 908 static int snd_sgio2audio_probe(struct platform_device *pdev) 909 { 910 struct snd_card *card; 911 struct snd_sgio2audio *chip; 912 int err; 913 914 err = snd_card_new(&pdev->dev, index, id, THIS_MODULE, 0, &card); 915 if (err < 0) 916 return err; 917 918 err = snd_sgio2audio_create(card, &chip); 919 if (err < 0) { 920 snd_card_free(card); 921 return err; 922 } 923 924 err = snd_sgio2audio_new_pcm(chip); 925 if (err < 0) { 926 snd_card_free(card); 927 return err; 928 } 929 err = snd_sgio2audio_new_mixer(chip); 930 if (err < 0) { 931 snd_card_free(card); 932 return err; 933 } 934 935 strcpy(card->driver, "SGI O2 Audio"); 936 strcpy(card->shortname, "SGI O2 Audio"); 937 sprintf(card->longname, "%s irq %i-%i", 938 card->shortname, 939 MACEISA_AUDIO1_DMAT_IRQ, 940 MACEISA_AUDIO3_MERR_IRQ); 941 942 err = snd_card_register(card); 943 if (err < 0) { 944 snd_card_free(card); 945 return err; 946 } 947 platform_set_drvdata(pdev, card); 948 return 0; 949 } 950 951 static int snd_sgio2audio_remove(struct platform_device *pdev) 952 { 953 struct snd_card *card = platform_get_drvdata(pdev); 954 955 snd_card_free(card); 956 return 0; 957 } 958 959 static struct platform_driver sgio2audio_driver = { 960 .probe = snd_sgio2audio_probe, 961 .remove = snd_sgio2audio_remove, 962 .driver = { 963 .name = "sgio2audio", 964 } 965 }; 966 967 module_platform_driver(sgio2audio_driver); 968