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 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) 990