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