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