1 /* 2 * Driver for AT73C213 16-bit stereo DAC connected to Atmel SSC 3 * 4 * Copyright (C) 2006-2007 Atmel Norway 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 as published by 8 * the Free Software Foundation. 9 */ 10 11 /*#define DEBUG*/ 12 13 #include <linux/clk.h> 14 #include <linux/err.h> 15 #include <linux/delay.h> 16 #include <linux/device.h> 17 #include <linux/dma-mapping.h> 18 #include <linux/init.h> 19 #include <linux/interrupt.h> 20 #include <linux/module.h> 21 #include <linux/mutex.h> 22 #include <linux/platform_device.h> 23 #include <linux/io.h> 24 25 #include <sound/initval.h> 26 #include <sound/control.h> 27 #include <sound/core.h> 28 #include <sound/pcm.h> 29 30 #include <linux/atmel-ssc.h> 31 32 #include <linux/spi/spi.h> 33 #include <linux/spi/at73c213.h> 34 35 #include "at73c213.h" 36 37 #define BITRATE_MIN 8000 /* Hardware limit? */ 38 #define BITRATE_TARGET CONFIG_SND_AT73C213_TARGET_BITRATE 39 #define BITRATE_MAX 50000 /* Hardware limit. */ 40 41 /* Initial (hardware reset) AT73C213 register values. */ 42 static u8 snd_at73c213_original_image[18] = 43 { 44 0x00, /* 00 - CTRL */ 45 0x05, /* 01 - LLIG */ 46 0x05, /* 02 - RLIG */ 47 0x08, /* 03 - LPMG */ 48 0x08, /* 04 - RPMG */ 49 0x00, /* 05 - LLOG */ 50 0x00, /* 06 - RLOG */ 51 0x22, /* 07 - OLC */ 52 0x09, /* 08 - MC */ 53 0x00, /* 09 - CSFC */ 54 0x00, /* 0A - MISC */ 55 0x00, /* 0B - */ 56 0x00, /* 0C - PRECH */ 57 0x05, /* 0D - AUXG */ 58 0x00, /* 0E - */ 59 0x00, /* 0F - */ 60 0x00, /* 10 - RST */ 61 0x00, /* 11 - PA_CTRL */ 62 }; 63 64 struct snd_at73c213 { 65 struct snd_card *card; 66 struct snd_pcm *pcm; 67 struct snd_pcm_substream *substream; 68 struct at73c213_board_info *board; 69 int irq; 70 int period; 71 unsigned long bitrate; 72 struct ssc_device *ssc; 73 struct spi_device *spi; 74 u8 spi_wbuffer[2]; 75 u8 spi_rbuffer[2]; 76 /* Image of the SPI registers in AT73C213. */ 77 u8 reg_image[18]; 78 /* Protect SSC registers against concurrent access. */ 79 spinlock_t lock; 80 /* Protect mixer registers against concurrent access. */ 81 struct mutex mixer_lock; 82 }; 83 84 #define get_chip(card) ((struct snd_at73c213 *)card->private_data) 85 86 static int 87 snd_at73c213_write_reg(struct snd_at73c213 *chip, u8 reg, u8 val) 88 { 89 struct spi_message msg; 90 struct spi_transfer msg_xfer = { 91 .len = 2, 92 .cs_change = 0, 93 }; 94 int retval; 95 96 spi_message_init(&msg); 97 98 chip->spi_wbuffer[0] = reg; 99 chip->spi_wbuffer[1] = val; 100 101 msg_xfer.tx_buf = chip->spi_wbuffer; 102 msg_xfer.rx_buf = chip->spi_rbuffer; 103 spi_message_add_tail(&msg_xfer, &msg); 104 105 retval = spi_sync(chip->spi, &msg); 106 107 if (!retval) 108 chip->reg_image[reg] = val; 109 110 return retval; 111 } 112 113 static struct snd_pcm_hardware snd_at73c213_playback_hw = { 114 .info = SNDRV_PCM_INFO_INTERLEAVED | 115 SNDRV_PCM_INFO_BLOCK_TRANSFER, 116 .formats = SNDRV_PCM_FMTBIT_S16_BE, 117 .rates = SNDRV_PCM_RATE_CONTINUOUS, 118 .rate_min = 8000, /* Replaced by chip->bitrate later. */ 119 .rate_max = 50000, /* Replaced by chip->bitrate later. */ 120 .channels_min = 1, 121 .channels_max = 2, 122 .buffer_bytes_max = 64 * 1024 - 1, 123 .period_bytes_min = 512, 124 .period_bytes_max = 64 * 1024 - 1, 125 .periods_min = 4, 126 .periods_max = 1024, 127 }; 128 129 /* 130 * Calculate and set bitrate and divisions. 131 */ 132 static int snd_at73c213_set_bitrate(struct snd_at73c213 *chip) 133 { 134 unsigned long ssc_rate = clk_get_rate(chip->ssc->clk); 135 unsigned long dac_rate_new, ssc_div; 136 int status; 137 unsigned long ssc_div_max, ssc_div_min; 138 int max_tries; 139 140 /* 141 * We connect two clocks here, picking divisors so the I2S clocks 142 * out data at the same rate the DAC clocks it in ... and as close 143 * as practical to the desired target rate. 144 * 145 * The DAC master clock (MCLK) is programmable, and is either 256 146 * or (not here) 384 times the I2S output clock (BCLK). 147 */ 148 149 /* SSC clock / (bitrate * stereo * 16-bit). */ 150 ssc_div = ssc_rate / (BITRATE_TARGET * 2 * 16); 151 ssc_div_min = ssc_rate / (BITRATE_MAX * 2 * 16); 152 ssc_div_max = ssc_rate / (BITRATE_MIN * 2 * 16); 153 max_tries = (ssc_div_max - ssc_div_min) / 2; 154 155 if (max_tries < 1) 156 max_tries = 1; 157 158 /* ssc_div must be even. */ 159 ssc_div = (ssc_div + 1) & ~1UL; 160 161 if ((ssc_rate / (ssc_div * 2 * 16)) < BITRATE_MIN) { 162 ssc_div -= 2; 163 if ((ssc_rate / (ssc_div * 2 * 16)) > BITRATE_MAX) 164 return -ENXIO; 165 } 166 167 /* Search for a possible bitrate. */ 168 do { 169 /* SSC clock / (ssc divider * 16-bit * stereo). */ 170 if ((ssc_rate / (ssc_div * 2 * 16)) < BITRATE_MIN) 171 return -ENXIO; 172 173 /* 256 / (2 * 16) = 8 */ 174 dac_rate_new = 8 * (ssc_rate / ssc_div); 175 176 status = clk_round_rate(chip->board->dac_clk, dac_rate_new); 177 if (status <= 0) 178 return status; 179 180 /* Ignore difference smaller than 256 Hz. */ 181 if ((status/256) == (dac_rate_new/256)) 182 goto set_rate; 183 184 ssc_div += 2; 185 } while (--max_tries); 186 187 /* Not able to find a valid bitrate. */ 188 return -ENXIO; 189 190 set_rate: 191 status = clk_set_rate(chip->board->dac_clk, status); 192 if (status < 0) 193 return status; 194 195 /* Set divider in SSC device. */ 196 ssc_writel(chip->ssc->regs, CMR, ssc_div/2); 197 198 /* SSC clock / (ssc divider * 16-bit * stereo). */ 199 chip->bitrate = ssc_rate / (ssc_div * 16 * 2); 200 201 dev_info(&chip->spi->dev, 202 "at73c213: supported bitrate is %lu (%lu divider)\n", 203 chip->bitrate, ssc_div); 204 205 return 0; 206 } 207 208 static int snd_at73c213_pcm_open(struct snd_pcm_substream *substream) 209 { 210 struct snd_at73c213 *chip = snd_pcm_substream_chip(substream); 211 struct snd_pcm_runtime *runtime = substream->runtime; 212 int err; 213 214 /* ensure buffer_size is a multiple of period_size */ 215 err = snd_pcm_hw_constraint_integer(runtime, 216 SNDRV_PCM_HW_PARAM_PERIODS); 217 if (err < 0) 218 return err; 219 snd_at73c213_playback_hw.rate_min = chip->bitrate; 220 snd_at73c213_playback_hw.rate_max = chip->bitrate; 221 runtime->hw = snd_at73c213_playback_hw; 222 chip->substream = substream; 223 224 clk_enable(chip->ssc->clk); 225 226 return 0; 227 } 228 229 static int snd_at73c213_pcm_close(struct snd_pcm_substream *substream) 230 { 231 struct snd_at73c213 *chip = snd_pcm_substream_chip(substream); 232 chip->substream = NULL; 233 clk_disable(chip->ssc->clk); 234 return 0; 235 } 236 237 static int snd_at73c213_pcm_hw_params(struct snd_pcm_substream *substream, 238 struct snd_pcm_hw_params *hw_params) 239 { 240 struct snd_at73c213 *chip = snd_pcm_substream_chip(substream); 241 int channels = params_channels(hw_params); 242 int val; 243 244 val = ssc_readl(chip->ssc->regs, TFMR); 245 val = SSC_BFINS(TFMR_DATNB, channels - 1, val); 246 ssc_writel(chip->ssc->regs, TFMR, val); 247 248 return snd_pcm_lib_malloc_pages(substream, 249 params_buffer_bytes(hw_params)); 250 } 251 252 static int snd_at73c213_pcm_hw_free(struct snd_pcm_substream *substream) 253 { 254 return snd_pcm_lib_free_pages(substream); 255 } 256 257 static int snd_at73c213_pcm_prepare(struct snd_pcm_substream *substream) 258 { 259 struct snd_at73c213 *chip = snd_pcm_substream_chip(substream); 260 struct snd_pcm_runtime *runtime = substream->runtime; 261 int block_size; 262 263 block_size = frames_to_bytes(runtime, runtime->period_size); 264 265 chip->period = 0; 266 267 ssc_writel(chip->ssc->regs, PDC_TPR, 268 (long)runtime->dma_addr); 269 ssc_writel(chip->ssc->regs, PDC_TCR, 270 runtime->period_size * runtime->channels); 271 ssc_writel(chip->ssc->regs, PDC_TNPR, 272 (long)runtime->dma_addr + block_size); 273 ssc_writel(chip->ssc->regs, PDC_TNCR, 274 runtime->period_size * runtime->channels); 275 276 return 0; 277 } 278 279 static int snd_at73c213_pcm_trigger(struct snd_pcm_substream *substream, 280 int cmd) 281 { 282 struct snd_at73c213 *chip = snd_pcm_substream_chip(substream); 283 int retval = 0; 284 285 spin_lock(&chip->lock); 286 287 switch (cmd) { 288 case SNDRV_PCM_TRIGGER_START: 289 ssc_writel(chip->ssc->regs, IER, SSC_BIT(IER_ENDTX)); 290 ssc_writel(chip->ssc->regs, PDC_PTCR, SSC_BIT(PDC_PTCR_TXTEN)); 291 break; 292 case SNDRV_PCM_TRIGGER_STOP: 293 ssc_writel(chip->ssc->regs, PDC_PTCR, SSC_BIT(PDC_PTCR_TXTDIS)); 294 ssc_writel(chip->ssc->regs, IDR, SSC_BIT(IDR_ENDTX)); 295 break; 296 default: 297 dev_dbg(&chip->spi->dev, "spurious command %x\n", cmd); 298 retval = -EINVAL; 299 break; 300 } 301 302 spin_unlock(&chip->lock); 303 304 return retval; 305 } 306 307 static snd_pcm_uframes_t 308 snd_at73c213_pcm_pointer(struct snd_pcm_substream *substream) 309 { 310 struct snd_at73c213 *chip = snd_pcm_substream_chip(substream); 311 struct snd_pcm_runtime *runtime = substream->runtime; 312 snd_pcm_uframes_t pos; 313 unsigned long bytes; 314 315 bytes = ssc_readl(chip->ssc->regs, PDC_TPR) 316 - (unsigned long)runtime->dma_addr; 317 318 pos = bytes_to_frames(runtime, bytes); 319 if (pos >= runtime->buffer_size) 320 pos -= runtime->buffer_size; 321 322 return pos; 323 } 324 325 static const struct snd_pcm_ops at73c213_playback_ops = { 326 .open = snd_at73c213_pcm_open, 327 .close = snd_at73c213_pcm_close, 328 .ioctl = snd_pcm_lib_ioctl, 329 .hw_params = snd_at73c213_pcm_hw_params, 330 .hw_free = snd_at73c213_pcm_hw_free, 331 .prepare = snd_at73c213_pcm_prepare, 332 .trigger = snd_at73c213_pcm_trigger, 333 .pointer = snd_at73c213_pcm_pointer, 334 }; 335 336 static int snd_at73c213_pcm_new(struct snd_at73c213 *chip, int device) 337 { 338 struct snd_pcm *pcm; 339 int retval; 340 341 retval = snd_pcm_new(chip->card, chip->card->shortname, 342 device, 1, 0, &pcm); 343 if (retval < 0) 344 goto out; 345 346 pcm->private_data = chip; 347 pcm->info_flags = SNDRV_PCM_INFO_BLOCK_TRANSFER; 348 strcpy(pcm->name, "at73c213"); 349 chip->pcm = pcm; 350 351 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &at73c213_playback_ops); 352 353 snd_pcm_lib_preallocate_pages_for_all(chip->pcm, 354 SNDRV_DMA_TYPE_DEV, &chip->ssc->pdev->dev, 355 64 * 1024, 64 * 1024); 356 out: 357 return retval; 358 } 359 360 static irqreturn_t snd_at73c213_interrupt(int irq, void *dev_id) 361 { 362 struct snd_at73c213 *chip = dev_id; 363 struct snd_pcm_runtime *runtime = chip->substream->runtime; 364 u32 status; 365 int offset; 366 int block_size; 367 int next_period; 368 int retval = IRQ_NONE; 369 370 spin_lock(&chip->lock); 371 372 block_size = frames_to_bytes(runtime, runtime->period_size); 373 status = ssc_readl(chip->ssc->regs, IMR); 374 375 if (status & SSC_BIT(IMR_ENDTX)) { 376 chip->period++; 377 if (chip->period == runtime->periods) 378 chip->period = 0; 379 next_period = chip->period + 1; 380 if (next_period == runtime->periods) 381 next_period = 0; 382 383 offset = block_size * next_period; 384 385 ssc_writel(chip->ssc->regs, PDC_TNPR, 386 (long)runtime->dma_addr + offset); 387 ssc_writel(chip->ssc->regs, PDC_TNCR, 388 runtime->period_size * runtime->channels); 389 retval = IRQ_HANDLED; 390 } 391 392 ssc_readl(chip->ssc->regs, IMR); 393 spin_unlock(&chip->lock); 394 395 if (status & SSC_BIT(IMR_ENDTX)) 396 snd_pcm_period_elapsed(chip->substream); 397 398 return retval; 399 } 400 401 /* 402 * Mixer functions. 403 */ 404 static int snd_at73c213_mono_get(struct snd_kcontrol *kcontrol, 405 struct snd_ctl_elem_value *ucontrol) 406 { 407 struct snd_at73c213 *chip = snd_kcontrol_chip(kcontrol); 408 int reg = kcontrol->private_value & 0xff; 409 int shift = (kcontrol->private_value >> 8) & 0xff; 410 int mask = (kcontrol->private_value >> 16) & 0xff; 411 int invert = (kcontrol->private_value >> 24) & 0xff; 412 413 mutex_lock(&chip->mixer_lock); 414 415 ucontrol->value.integer.value[0] = 416 (chip->reg_image[reg] >> shift) & mask; 417 418 if (invert) 419 ucontrol->value.integer.value[0] = 420 mask - ucontrol->value.integer.value[0]; 421 422 mutex_unlock(&chip->mixer_lock); 423 424 return 0; 425 } 426 427 static int snd_at73c213_mono_put(struct snd_kcontrol *kcontrol, 428 struct snd_ctl_elem_value *ucontrol) 429 { 430 struct snd_at73c213 *chip = snd_kcontrol_chip(kcontrol); 431 int reg = kcontrol->private_value & 0xff; 432 int shift = (kcontrol->private_value >> 8) & 0xff; 433 int mask = (kcontrol->private_value >> 16) & 0xff; 434 int invert = (kcontrol->private_value >> 24) & 0xff; 435 int change, retval; 436 unsigned short val; 437 438 val = (ucontrol->value.integer.value[0] & mask); 439 if (invert) 440 val = mask - val; 441 val <<= shift; 442 443 mutex_lock(&chip->mixer_lock); 444 445 val = (chip->reg_image[reg] & ~(mask << shift)) | val; 446 change = val != chip->reg_image[reg]; 447 retval = snd_at73c213_write_reg(chip, reg, val); 448 449 mutex_unlock(&chip->mixer_lock); 450 451 if (retval) 452 return retval; 453 454 return change; 455 } 456 457 static int snd_at73c213_stereo_info(struct snd_kcontrol *kcontrol, 458 struct snd_ctl_elem_info *uinfo) 459 { 460 int mask = (kcontrol->private_value >> 24) & 0xff; 461 462 if (mask == 1) 463 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 464 else 465 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 466 467 uinfo->count = 2; 468 uinfo->value.integer.min = 0; 469 uinfo->value.integer.max = mask; 470 471 return 0; 472 } 473 474 static int snd_at73c213_stereo_get(struct snd_kcontrol *kcontrol, 475 struct snd_ctl_elem_value *ucontrol) 476 { 477 struct snd_at73c213 *chip = snd_kcontrol_chip(kcontrol); 478 int left_reg = kcontrol->private_value & 0xff; 479 int right_reg = (kcontrol->private_value >> 8) & 0xff; 480 int shift_left = (kcontrol->private_value >> 16) & 0x07; 481 int shift_right = (kcontrol->private_value >> 19) & 0x07; 482 int mask = (kcontrol->private_value >> 24) & 0xff; 483 int invert = (kcontrol->private_value >> 22) & 1; 484 485 mutex_lock(&chip->mixer_lock); 486 487 ucontrol->value.integer.value[0] = 488 (chip->reg_image[left_reg] >> shift_left) & mask; 489 ucontrol->value.integer.value[1] = 490 (chip->reg_image[right_reg] >> shift_right) & mask; 491 492 if (invert) { 493 ucontrol->value.integer.value[0] = 494 mask - ucontrol->value.integer.value[0]; 495 ucontrol->value.integer.value[1] = 496 mask - ucontrol->value.integer.value[1]; 497 } 498 499 mutex_unlock(&chip->mixer_lock); 500 501 return 0; 502 } 503 504 static int snd_at73c213_stereo_put(struct snd_kcontrol *kcontrol, 505 struct snd_ctl_elem_value *ucontrol) 506 { 507 struct snd_at73c213 *chip = snd_kcontrol_chip(kcontrol); 508 int left_reg = kcontrol->private_value & 0xff; 509 int right_reg = (kcontrol->private_value >> 8) & 0xff; 510 int shift_left = (kcontrol->private_value >> 16) & 0x07; 511 int shift_right = (kcontrol->private_value >> 19) & 0x07; 512 int mask = (kcontrol->private_value >> 24) & 0xff; 513 int invert = (kcontrol->private_value >> 22) & 1; 514 int change, retval; 515 unsigned short val1, val2; 516 517 val1 = ucontrol->value.integer.value[0] & mask; 518 val2 = ucontrol->value.integer.value[1] & mask; 519 if (invert) { 520 val1 = mask - val1; 521 val2 = mask - val2; 522 } 523 val1 <<= shift_left; 524 val2 <<= shift_right; 525 526 mutex_lock(&chip->mixer_lock); 527 528 val1 = (chip->reg_image[left_reg] & ~(mask << shift_left)) | val1; 529 val2 = (chip->reg_image[right_reg] & ~(mask << shift_right)) | val2; 530 change = val1 != chip->reg_image[left_reg] 531 || val2 != chip->reg_image[right_reg]; 532 retval = snd_at73c213_write_reg(chip, left_reg, val1); 533 if (retval) { 534 mutex_unlock(&chip->mixer_lock); 535 goto out; 536 } 537 retval = snd_at73c213_write_reg(chip, right_reg, val2); 538 if (retval) { 539 mutex_unlock(&chip->mixer_lock); 540 goto out; 541 } 542 543 mutex_unlock(&chip->mixer_lock); 544 545 return change; 546 547 out: 548 return retval; 549 } 550 551 #define snd_at73c213_mono_switch_info snd_ctl_boolean_mono_info 552 553 static int snd_at73c213_mono_switch_get(struct snd_kcontrol *kcontrol, 554 struct snd_ctl_elem_value *ucontrol) 555 { 556 struct snd_at73c213 *chip = snd_kcontrol_chip(kcontrol); 557 int reg = kcontrol->private_value & 0xff; 558 int shift = (kcontrol->private_value >> 8) & 0xff; 559 int invert = (kcontrol->private_value >> 24) & 0xff; 560 561 mutex_lock(&chip->mixer_lock); 562 563 ucontrol->value.integer.value[0] = 564 (chip->reg_image[reg] >> shift) & 0x01; 565 566 if (invert) 567 ucontrol->value.integer.value[0] = 568 0x01 - ucontrol->value.integer.value[0]; 569 570 mutex_unlock(&chip->mixer_lock); 571 572 return 0; 573 } 574 575 static int snd_at73c213_mono_switch_put(struct snd_kcontrol *kcontrol, 576 struct snd_ctl_elem_value *ucontrol) 577 { 578 struct snd_at73c213 *chip = snd_kcontrol_chip(kcontrol); 579 int reg = kcontrol->private_value & 0xff; 580 int shift = (kcontrol->private_value >> 8) & 0xff; 581 int mask = (kcontrol->private_value >> 16) & 0xff; 582 int invert = (kcontrol->private_value >> 24) & 0xff; 583 int change, retval; 584 unsigned short val; 585 586 if (ucontrol->value.integer.value[0]) 587 val = mask; 588 else 589 val = 0; 590 591 if (invert) 592 val = mask - val; 593 val <<= shift; 594 595 mutex_lock(&chip->mixer_lock); 596 597 val |= (chip->reg_image[reg] & ~(mask << shift)); 598 change = val != chip->reg_image[reg]; 599 600 retval = snd_at73c213_write_reg(chip, reg, val); 601 602 mutex_unlock(&chip->mixer_lock); 603 604 if (retval) 605 return retval; 606 607 return change; 608 } 609 610 static int snd_at73c213_pa_volume_info(struct snd_kcontrol *kcontrol, 611 struct snd_ctl_elem_info *uinfo) 612 { 613 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 614 uinfo->count = 1; 615 uinfo->value.integer.min = 0; 616 uinfo->value.integer.max = ((kcontrol->private_value >> 16) & 0xff) - 1; 617 618 return 0; 619 } 620 621 static int snd_at73c213_line_capture_volume_info( 622 struct snd_kcontrol *kcontrol, 623 struct snd_ctl_elem_info *uinfo) 624 { 625 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 626 uinfo->count = 2; 627 /* When inverted will give values 0x10001 => 0. */ 628 uinfo->value.integer.min = 14; 629 uinfo->value.integer.max = 31; 630 631 return 0; 632 } 633 634 static int snd_at73c213_aux_capture_volume_info( 635 struct snd_kcontrol *kcontrol, 636 struct snd_ctl_elem_info *uinfo) 637 { 638 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 639 uinfo->count = 1; 640 /* When inverted will give values 0x10001 => 0. */ 641 uinfo->value.integer.min = 14; 642 uinfo->value.integer.max = 31; 643 644 return 0; 645 } 646 647 #define AT73C213_MONO_SWITCH(xname, xindex, reg, shift, mask, invert) \ 648 { \ 649 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 650 .name = xname, \ 651 .index = xindex, \ 652 .info = snd_at73c213_mono_switch_info, \ 653 .get = snd_at73c213_mono_switch_get, \ 654 .put = snd_at73c213_mono_switch_put, \ 655 .private_value = (reg | (shift << 8) | (mask << 16) | (invert << 24)) \ 656 } 657 658 #define AT73C213_STEREO(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \ 659 { \ 660 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 661 .name = xname, \ 662 .index = xindex, \ 663 .info = snd_at73c213_stereo_info, \ 664 .get = snd_at73c213_stereo_get, \ 665 .put = snd_at73c213_stereo_put, \ 666 .private_value = (left_reg | (right_reg << 8) \ 667 | (shift_left << 16) | (shift_right << 19) \ 668 | (mask << 24) | (invert << 22)) \ 669 } 670 671 static struct snd_kcontrol_new snd_at73c213_controls[] = { 672 AT73C213_STEREO("Master Playback Volume", 0, DAC_LMPG, DAC_RMPG, 0, 0, 0x1f, 1), 673 AT73C213_STEREO("Master Playback Switch", 0, DAC_LMPG, DAC_RMPG, 5, 5, 1, 1), 674 AT73C213_STEREO("PCM Playback Volume", 0, DAC_LLOG, DAC_RLOG, 0, 0, 0x1f, 1), 675 AT73C213_STEREO("PCM Playback Switch", 0, DAC_LLOG, DAC_RLOG, 5, 5, 1, 1), 676 AT73C213_MONO_SWITCH("Mono PA Playback Switch", 0, DAC_CTRL, DAC_CTRL_ONPADRV, 677 0x01, 0), 678 { 679 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 680 .name = "PA Playback Volume", 681 .index = 0, 682 .info = snd_at73c213_pa_volume_info, 683 .get = snd_at73c213_mono_get, 684 .put = snd_at73c213_mono_put, 685 .private_value = PA_CTRL | (PA_CTRL_APAGAIN << 8) | \ 686 (0x0f << 16) | (1 << 24), 687 }, 688 AT73C213_MONO_SWITCH("PA High Gain Playback Switch", 0, PA_CTRL, PA_CTRL_APALP, 689 0x01, 1), 690 AT73C213_MONO_SWITCH("PA Playback Switch", 0, PA_CTRL, PA_CTRL_APAON, 0x01, 0), 691 { 692 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 693 .name = "Aux Capture Volume", 694 .index = 0, 695 .info = snd_at73c213_aux_capture_volume_info, 696 .get = snd_at73c213_mono_get, 697 .put = snd_at73c213_mono_put, 698 .private_value = DAC_AUXG | (0 << 8) | (0x1f << 16) | (1 << 24), 699 }, 700 AT73C213_MONO_SWITCH("Aux Capture Switch", 0, DAC_CTRL, DAC_CTRL_ONAUXIN, 701 0x01, 0), 702 { 703 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 704 .name = "Line Capture Volume", 705 .index = 0, 706 .info = snd_at73c213_line_capture_volume_info, 707 .get = snd_at73c213_stereo_get, 708 .put = snd_at73c213_stereo_put, 709 .private_value = DAC_LLIG | (DAC_RLIG << 8) | (0 << 16) | (0 << 19) 710 | (0x1f << 24) | (1 << 22), 711 }, 712 AT73C213_MONO_SWITCH("Line Capture Switch", 0, DAC_CTRL, 0, 0x03, 0), 713 }; 714 715 static int snd_at73c213_mixer(struct snd_at73c213 *chip) 716 { 717 struct snd_card *card; 718 int errval, idx; 719 720 if (chip == NULL || chip->pcm == NULL) 721 return -EINVAL; 722 723 card = chip->card; 724 725 strcpy(card->mixername, chip->pcm->name); 726 727 for (idx = 0; idx < ARRAY_SIZE(snd_at73c213_controls); idx++) { 728 errval = snd_ctl_add(card, 729 snd_ctl_new1(&snd_at73c213_controls[idx], 730 chip)); 731 if (errval < 0) 732 goto cleanup; 733 } 734 735 return 0; 736 737 cleanup: 738 for (idx = 1; idx < ARRAY_SIZE(snd_at73c213_controls) + 1; idx++) { 739 struct snd_kcontrol *kctl; 740 kctl = snd_ctl_find_numid(card, idx); 741 if (kctl) 742 snd_ctl_remove(card, kctl); 743 } 744 return errval; 745 } 746 747 /* 748 * Device functions 749 */ 750 static int snd_at73c213_ssc_init(struct snd_at73c213 *chip) 751 { 752 /* 753 * Continuous clock output. 754 * Starts on falling TF. 755 * Delay 1 cycle (1 bit). 756 * Periode is 16 bit (16 - 1). 757 */ 758 ssc_writel(chip->ssc->regs, TCMR, 759 SSC_BF(TCMR_CKO, 1) 760 | SSC_BF(TCMR_START, 4) 761 | SSC_BF(TCMR_STTDLY, 1) 762 | SSC_BF(TCMR_PERIOD, 16 - 1)); 763 /* 764 * Data length is 16 bit (16 - 1). 765 * Transmit MSB first. 766 * Transmit 2 words each transfer. 767 * Frame sync length is 16 bit (16 - 1). 768 * Frame starts on negative pulse. 769 */ 770 ssc_writel(chip->ssc->regs, TFMR, 771 SSC_BF(TFMR_DATLEN, 16 - 1) 772 | SSC_BIT(TFMR_MSBF) 773 | SSC_BF(TFMR_DATNB, 1) 774 | SSC_BF(TFMR_FSLEN, 16 - 1) 775 | SSC_BF(TFMR_FSOS, 1)); 776 777 return 0; 778 } 779 780 static int snd_at73c213_chip_init(struct snd_at73c213 *chip) 781 { 782 int retval; 783 unsigned char dac_ctrl = 0; 784 785 retval = snd_at73c213_set_bitrate(chip); 786 if (retval) 787 goto out; 788 789 /* Enable DAC master clock. */ 790 clk_enable(chip->board->dac_clk); 791 792 /* Initialize at73c213 on SPI bus. */ 793 retval = snd_at73c213_write_reg(chip, DAC_RST, 0x04); 794 if (retval) 795 goto out_clk; 796 msleep(1); 797 retval = snd_at73c213_write_reg(chip, DAC_RST, 0x03); 798 if (retval) 799 goto out_clk; 800 801 /* Precharge everything. */ 802 retval = snd_at73c213_write_reg(chip, DAC_PRECH, 0xff); 803 if (retval) 804 goto out_clk; 805 retval = snd_at73c213_write_reg(chip, PA_CTRL, (1<<PA_CTRL_APAPRECH)); 806 if (retval) 807 goto out_clk; 808 retval = snd_at73c213_write_reg(chip, DAC_CTRL, 809 (1<<DAC_CTRL_ONLNOL) | (1<<DAC_CTRL_ONLNOR)); 810 if (retval) 811 goto out_clk; 812 813 msleep(50); 814 815 /* Stop precharging PA. */ 816 retval = snd_at73c213_write_reg(chip, PA_CTRL, 817 (1<<PA_CTRL_APALP) | 0x0f); 818 if (retval) 819 goto out_clk; 820 821 msleep(450); 822 823 /* Stop precharging DAC, turn on master power. */ 824 retval = snd_at73c213_write_reg(chip, DAC_PRECH, (1<<DAC_PRECH_ONMSTR)); 825 if (retval) 826 goto out_clk; 827 828 msleep(1); 829 830 /* Turn on DAC. */ 831 dac_ctrl = (1<<DAC_CTRL_ONDACL) | (1<<DAC_CTRL_ONDACR) 832 | (1<<DAC_CTRL_ONLNOL) | (1<<DAC_CTRL_ONLNOR); 833 834 retval = snd_at73c213_write_reg(chip, DAC_CTRL, dac_ctrl); 835 if (retval) 836 goto out_clk; 837 838 /* Mute sound. */ 839 retval = snd_at73c213_write_reg(chip, DAC_LMPG, 0x3f); 840 if (retval) 841 goto out_clk; 842 retval = snd_at73c213_write_reg(chip, DAC_RMPG, 0x3f); 843 if (retval) 844 goto out_clk; 845 retval = snd_at73c213_write_reg(chip, DAC_LLOG, 0x3f); 846 if (retval) 847 goto out_clk; 848 retval = snd_at73c213_write_reg(chip, DAC_RLOG, 0x3f); 849 if (retval) 850 goto out_clk; 851 retval = snd_at73c213_write_reg(chip, DAC_LLIG, 0x11); 852 if (retval) 853 goto out_clk; 854 retval = snd_at73c213_write_reg(chip, DAC_RLIG, 0x11); 855 if (retval) 856 goto out_clk; 857 retval = snd_at73c213_write_reg(chip, DAC_AUXG, 0x11); 858 if (retval) 859 goto out_clk; 860 861 /* Enable I2S device, i.e. clock output. */ 862 ssc_writel(chip->ssc->regs, CR, SSC_BIT(CR_TXEN)); 863 864 goto out; 865 866 out_clk: 867 clk_disable(chip->board->dac_clk); 868 out: 869 return retval; 870 } 871 872 static int snd_at73c213_dev_free(struct snd_device *device) 873 { 874 struct snd_at73c213 *chip = device->device_data; 875 876 ssc_writel(chip->ssc->regs, CR, SSC_BIT(CR_TXDIS)); 877 if (chip->irq >= 0) { 878 free_irq(chip->irq, chip); 879 chip->irq = -1; 880 } 881 882 return 0; 883 } 884 885 static int snd_at73c213_dev_init(struct snd_card *card, 886 struct spi_device *spi) 887 { 888 static struct snd_device_ops ops = { 889 .dev_free = snd_at73c213_dev_free, 890 }; 891 struct snd_at73c213 *chip = get_chip(card); 892 int irq, retval; 893 894 irq = chip->ssc->irq; 895 if (irq < 0) 896 return irq; 897 898 spin_lock_init(&chip->lock); 899 mutex_init(&chip->mixer_lock); 900 chip->card = card; 901 chip->irq = -1; 902 903 clk_enable(chip->ssc->clk); 904 905 retval = request_irq(irq, snd_at73c213_interrupt, 0, "at73c213", chip); 906 if (retval) { 907 dev_dbg(&chip->spi->dev, "unable to request irq %d\n", irq); 908 goto out; 909 } 910 chip->irq = irq; 911 912 memcpy(&chip->reg_image, &snd_at73c213_original_image, 913 sizeof(snd_at73c213_original_image)); 914 915 retval = snd_at73c213_ssc_init(chip); 916 if (retval) 917 goto out_irq; 918 919 retval = snd_at73c213_chip_init(chip); 920 if (retval) 921 goto out_irq; 922 923 retval = snd_at73c213_pcm_new(chip, 0); 924 if (retval) 925 goto out_irq; 926 927 retval = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); 928 if (retval) 929 goto out_irq; 930 931 retval = snd_at73c213_mixer(chip); 932 if (retval) 933 goto out_snd_dev; 934 935 goto out; 936 937 out_snd_dev: 938 snd_device_free(card, chip); 939 out_irq: 940 free_irq(chip->irq, chip); 941 chip->irq = -1; 942 out: 943 clk_disable(chip->ssc->clk); 944 945 return retval; 946 } 947 948 static int snd_at73c213_probe(struct spi_device *spi) 949 { 950 struct snd_card *card; 951 struct snd_at73c213 *chip; 952 struct at73c213_board_info *board; 953 int retval; 954 char id[16]; 955 956 board = spi->dev.platform_data; 957 if (!board) { 958 dev_dbg(&spi->dev, "no platform_data\n"); 959 return -ENXIO; 960 } 961 962 if (!board->dac_clk) { 963 dev_dbg(&spi->dev, "no DAC clk\n"); 964 return -ENXIO; 965 } 966 967 if (IS_ERR(board->dac_clk)) { 968 dev_dbg(&spi->dev, "no DAC clk\n"); 969 return PTR_ERR(board->dac_clk); 970 } 971 972 /* Allocate "card" using some unused identifiers. */ 973 snprintf(id, sizeof id, "at73c213_%d", board->ssc_id); 974 retval = snd_card_new(&spi->dev, -1, id, THIS_MODULE, 975 sizeof(struct snd_at73c213), &card); 976 if (retval < 0) 977 goto out; 978 979 chip = card->private_data; 980 chip->spi = spi; 981 chip->board = board; 982 983 chip->ssc = ssc_request(board->ssc_id); 984 if (IS_ERR(chip->ssc)) { 985 dev_dbg(&spi->dev, "could not get ssc%d device\n", 986 board->ssc_id); 987 retval = PTR_ERR(chip->ssc); 988 goto out_card; 989 } 990 991 retval = snd_at73c213_dev_init(card, spi); 992 if (retval) 993 goto out_ssc; 994 995 strcpy(card->driver, "at73c213"); 996 strcpy(card->shortname, board->shortname); 997 sprintf(card->longname, "%s on irq %d", card->shortname, chip->irq); 998 999 retval = snd_card_register(card); 1000 if (retval) 1001 goto out_ssc; 1002 1003 dev_set_drvdata(&spi->dev, card); 1004 1005 goto out; 1006 1007 out_ssc: 1008 ssc_free(chip->ssc); 1009 out_card: 1010 snd_card_free(card); 1011 out: 1012 return retval; 1013 } 1014 1015 static int snd_at73c213_remove(struct spi_device *spi) 1016 { 1017 struct snd_card *card = dev_get_drvdata(&spi->dev); 1018 struct snd_at73c213 *chip = card->private_data; 1019 int retval; 1020 1021 /* Stop playback. */ 1022 clk_enable(chip->ssc->clk); 1023 ssc_writel(chip->ssc->regs, CR, SSC_BIT(CR_TXDIS)); 1024 clk_disable(chip->ssc->clk); 1025 1026 /* Mute sound. */ 1027 retval = snd_at73c213_write_reg(chip, DAC_LMPG, 0x3f); 1028 if (retval) 1029 goto out; 1030 retval = snd_at73c213_write_reg(chip, DAC_RMPG, 0x3f); 1031 if (retval) 1032 goto out; 1033 retval = snd_at73c213_write_reg(chip, DAC_LLOG, 0x3f); 1034 if (retval) 1035 goto out; 1036 retval = snd_at73c213_write_reg(chip, DAC_RLOG, 0x3f); 1037 if (retval) 1038 goto out; 1039 retval = snd_at73c213_write_reg(chip, DAC_LLIG, 0x11); 1040 if (retval) 1041 goto out; 1042 retval = snd_at73c213_write_reg(chip, DAC_RLIG, 0x11); 1043 if (retval) 1044 goto out; 1045 retval = snd_at73c213_write_reg(chip, DAC_AUXG, 0x11); 1046 if (retval) 1047 goto out; 1048 1049 /* Turn off PA. */ 1050 retval = snd_at73c213_write_reg(chip, PA_CTRL, 1051 chip->reg_image[PA_CTRL] | 0x0f); 1052 if (retval) 1053 goto out; 1054 msleep(10); 1055 retval = snd_at73c213_write_reg(chip, PA_CTRL, 1056 (1 << PA_CTRL_APALP) | 0x0f); 1057 if (retval) 1058 goto out; 1059 1060 /* Turn off external DAC. */ 1061 retval = snd_at73c213_write_reg(chip, DAC_CTRL, 0x0c); 1062 if (retval) 1063 goto out; 1064 msleep(2); 1065 retval = snd_at73c213_write_reg(chip, DAC_CTRL, 0x00); 1066 if (retval) 1067 goto out; 1068 1069 /* Turn off master power. */ 1070 retval = snd_at73c213_write_reg(chip, DAC_PRECH, 0x00); 1071 if (retval) 1072 goto out; 1073 1074 out: 1075 /* Stop DAC master clock. */ 1076 clk_disable(chip->board->dac_clk); 1077 1078 ssc_free(chip->ssc); 1079 snd_card_free(card); 1080 1081 return 0; 1082 } 1083 1084 #ifdef CONFIG_PM_SLEEP 1085 1086 static int snd_at73c213_suspend(struct device *dev) 1087 { 1088 struct snd_card *card = dev_get_drvdata(dev); 1089 struct snd_at73c213 *chip = card->private_data; 1090 1091 ssc_writel(chip->ssc->regs, CR, SSC_BIT(CR_TXDIS)); 1092 clk_disable(chip->ssc->clk); 1093 clk_disable(chip->board->dac_clk); 1094 1095 return 0; 1096 } 1097 1098 static int snd_at73c213_resume(struct device *dev) 1099 { 1100 struct snd_card *card = dev_get_drvdata(dev); 1101 struct snd_at73c213 *chip = card->private_data; 1102 1103 clk_enable(chip->board->dac_clk); 1104 clk_enable(chip->ssc->clk); 1105 ssc_writel(chip->ssc->regs, CR, SSC_BIT(CR_TXEN)); 1106 1107 return 0; 1108 } 1109 1110 static SIMPLE_DEV_PM_OPS(at73c213_pm_ops, snd_at73c213_suspend, 1111 snd_at73c213_resume); 1112 #define AT73C213_PM_OPS (&at73c213_pm_ops) 1113 1114 #else 1115 #define AT73C213_PM_OPS NULL 1116 #endif 1117 1118 static struct spi_driver at73c213_driver = { 1119 .driver = { 1120 .name = "at73c213", 1121 .pm = AT73C213_PM_OPS, 1122 }, 1123 .probe = snd_at73c213_probe, 1124 .remove = snd_at73c213_remove, 1125 }; 1126 1127 module_spi_driver(at73c213_driver); 1128 1129 MODULE_AUTHOR("Hans-Christian Egtvedt <egtvedt@samfundet.no>"); 1130 MODULE_DESCRIPTION("Sound driver for AT73C213 with Atmel SSC"); 1131 MODULE_LICENSE("GPL"); 1132