2 * Driver for AT73C213 16-bit stereo DAC connected to Atmel SSC
4 * Copyright (C) 2006-2007 Atmel Norway
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.
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>
25 #include <sound/initval.h>
26 #include <sound/control.h>
27 #include <sound/core.h>
28 #include <sound/pcm.h>
30 #include <linux/atmel-ssc.h>
32 #include <linux/spi/spi.h>
33 #include <linux/spi/at73c213.h>
37 #define BITRATE_MIN 8000 /* Hardware limit? */
38 #define BITRATE_TARGET CONFIG_SND_AT73C213_TARGET_BITRATE
39 #define BITRATE_MAX 50000 /* Hardware limit. */
41 /* Initial (hardware reset) AT73C213 register values. */
42 static u8 snd_at73c213_original_image
[18] =
56 0x00, /* 0C - PRECH */
61 0x00, /* 11 - PA_CTRL */
65 struct snd_card
*card
;
67 struct snd_pcm_substream
*substream
;
68 struct at73c213_board_info
*board
;
71 unsigned long bitrate
;
72 struct ssc_device
*ssc
;
73 struct spi_device
*spi
;
76 /* Image of the SPI registers in AT73C213. */
78 /* Protect SSC registers against concurrent access. */
80 /* Protect mixer registers against concurrent access. */
81 struct mutex mixer_lock
;
84 #define get_chip(card) ((struct snd_at73c213 *)card->private_data)
87 snd_at73c213_write_reg(struct snd_at73c213
*chip
, u8 reg
, u8 val
)
89 struct spi_message msg
;
90 struct spi_transfer msg_xfer
= {
96 spi_message_init(&msg
);
98 chip
->spi_wbuffer
[0] = reg
;
99 chip
->spi_wbuffer
[1] = val
;
101 msg_xfer
.tx_buf
= chip
->spi_wbuffer
;
102 msg_xfer
.rx_buf
= chip
->spi_rbuffer
;
103 spi_message_add_tail(&msg_xfer
, &msg
);
105 retval
= spi_sync(chip
->spi
, &msg
);
108 chip
->reg_image
[reg
] = val
;
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. */
122 .buffer_bytes_max
= 64 * 1024 - 1,
123 .period_bytes_min
= 512,
124 .period_bytes_max
= 64 * 1024 - 1,
130 * Calculate and set bitrate and divisions.
132 static int snd_at73c213_set_bitrate(struct snd_at73c213
*chip
)
134 unsigned long ssc_rate
= clk_get_rate(chip
->ssc
->clk
);
135 unsigned long dac_rate_new
, ssc_div
;
137 unsigned long ssc_div_max
, ssc_div_min
;
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.
145 * The DAC master clock (MCLK) is programmable, and is either 256
146 * or (not here) 384 times the I2S output clock (BCLK).
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;
158 /* ssc_div must be even. */
159 ssc_div
= (ssc_div
+ 1) & ~1UL;
161 if ((ssc_rate
/ (ssc_div
* 2 * 16)) < BITRATE_MIN
) {
163 if ((ssc_rate
/ (ssc_div
* 2 * 16)) > BITRATE_MAX
)
167 /* Search for a possible bitrate. */
169 /* SSC clock / (ssc divider * 16-bit * stereo). */
170 if ((ssc_rate
/ (ssc_div
* 2 * 16)) < BITRATE_MIN
)
173 /* 256 / (2 * 16) = 8 */
174 dac_rate_new
= 8 * (ssc_rate
/ ssc_div
);
176 status
= clk_round_rate(chip
->board
->dac_clk
, dac_rate_new
);
180 /* Ignore difference smaller than 256 Hz. */
181 if ((status
/256) == (dac_rate_new
/256))
185 } while (--max_tries
);
187 /* Not able to find a valid bitrate. */
191 status
= clk_set_rate(chip
->board
->dac_clk
, status
);
195 /* Set divider in SSC device. */
196 ssc_writel(chip
->ssc
->regs
, CMR
, ssc_div
/2);
198 /* SSC clock / (ssc divider * 16-bit * stereo). */
199 chip
->bitrate
= ssc_rate
/ (ssc_div
* 16 * 2);
201 dev_info(&chip
->spi
->dev
,
202 "at73c213: supported bitrate is %lu (%lu divider)\n",
203 chip
->bitrate
, ssc_div
);
208 static int snd_at73c213_pcm_open(struct snd_pcm_substream
*substream
)
210 struct snd_at73c213
*chip
= snd_pcm_substream_chip(substream
);
211 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
214 /* ensure buffer_size is a multiple of period_size */
215 err
= snd_pcm_hw_constraint_integer(runtime
,
216 SNDRV_PCM_HW_PARAM_PERIODS
);
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
;
227 static int snd_at73c213_pcm_close(struct snd_pcm_substream
*substream
)
229 struct snd_at73c213
*chip
= snd_pcm_substream_chip(substream
);
230 chip
->substream
= NULL
;
234 static int snd_at73c213_pcm_hw_params(struct snd_pcm_substream
*substream
,
235 struct snd_pcm_hw_params
*hw_params
)
237 struct snd_at73c213
*chip
= snd_pcm_substream_chip(substream
);
238 int channels
= params_channels(hw_params
);
241 val
= ssc_readl(chip
->ssc
->regs
, TFMR
);
242 val
= SSC_BFINS(TFMR_DATNB
, channels
- 1, val
);
243 ssc_writel(chip
->ssc
->regs
, TFMR
, val
);
245 return snd_pcm_lib_malloc_pages(substream
,
246 params_buffer_bytes(hw_params
));
249 static int snd_at73c213_pcm_hw_free(struct snd_pcm_substream
*substream
)
251 return snd_pcm_lib_free_pages(substream
);
254 static int snd_at73c213_pcm_prepare(struct snd_pcm_substream
*substream
)
256 struct snd_at73c213
*chip
= snd_pcm_substream_chip(substream
);
257 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
260 block_size
= frames_to_bytes(runtime
, runtime
->period_size
);
264 ssc_writel(chip
->ssc
->regs
, PDC_TPR
,
265 (long)runtime
->dma_addr
);
266 ssc_writel(chip
->ssc
->regs
, PDC_TCR
,
267 runtime
->period_size
* runtime
->channels
);
268 ssc_writel(chip
->ssc
->regs
, PDC_TNPR
,
269 (long)runtime
->dma_addr
+ block_size
);
270 ssc_writel(chip
->ssc
->regs
, PDC_TNCR
,
271 runtime
->period_size
* runtime
->channels
);
276 static int snd_at73c213_pcm_trigger(struct snd_pcm_substream
*substream
,
279 struct snd_at73c213
*chip
= snd_pcm_substream_chip(substream
);
282 spin_lock(&chip
->lock
);
285 case SNDRV_PCM_TRIGGER_START
:
286 ssc_writel(chip
->ssc
->regs
, IER
, SSC_BIT(IER_ENDTX
));
287 ssc_writel(chip
->ssc
->regs
, PDC_PTCR
, SSC_BIT(PDC_PTCR_TXTEN
));
289 case SNDRV_PCM_TRIGGER_STOP
:
290 ssc_writel(chip
->ssc
->regs
, PDC_PTCR
, SSC_BIT(PDC_PTCR_TXTDIS
));
291 ssc_writel(chip
->ssc
->regs
, IDR
, SSC_BIT(IDR_ENDTX
));
294 dev_dbg(&chip
->spi
->dev
, "spurious command %x\n", cmd
);
299 spin_unlock(&chip
->lock
);
304 static snd_pcm_uframes_t
305 snd_at73c213_pcm_pointer(struct snd_pcm_substream
*substream
)
307 struct snd_at73c213
*chip
= snd_pcm_substream_chip(substream
);
308 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
309 snd_pcm_uframes_t pos
;
312 bytes
= ssc_readl(chip
->ssc
->regs
, PDC_TPR
)
313 - (unsigned long)runtime
->dma_addr
;
315 pos
= bytes_to_frames(runtime
, bytes
);
316 if (pos
>= runtime
->buffer_size
)
317 pos
-= runtime
->buffer_size
;
322 static struct snd_pcm_ops at73c213_playback_ops
= {
323 .open
= snd_at73c213_pcm_open
,
324 .close
= snd_at73c213_pcm_close
,
325 .ioctl
= snd_pcm_lib_ioctl
,
326 .hw_params
= snd_at73c213_pcm_hw_params
,
327 .hw_free
= snd_at73c213_pcm_hw_free
,
328 .prepare
= snd_at73c213_pcm_prepare
,
329 .trigger
= snd_at73c213_pcm_trigger
,
330 .pointer
= snd_at73c213_pcm_pointer
,
333 static int __devinit
snd_at73c213_pcm_new(struct snd_at73c213
*chip
, int device
)
338 retval
= snd_pcm_new(chip
->card
, chip
->card
->shortname
,
343 pcm
->private_data
= chip
;
344 pcm
->info_flags
= SNDRV_PCM_INFO_BLOCK_TRANSFER
;
345 strcpy(pcm
->name
, "at73c213");
348 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &at73c213_playback_ops
);
350 retval
= snd_pcm_lib_preallocate_pages_for_all(chip
->pcm
,
351 SNDRV_DMA_TYPE_DEV
, &chip
->ssc
->pdev
->dev
,
352 64 * 1024, 64 * 1024);
357 static irqreturn_t
snd_at73c213_interrupt(int irq
, void *dev_id
)
359 struct snd_at73c213
*chip
= dev_id
;
360 struct snd_pcm_runtime
*runtime
= chip
->substream
->runtime
;
365 int retval
= IRQ_NONE
;
367 spin_lock(&chip
->lock
);
369 block_size
= frames_to_bytes(runtime
, runtime
->period_size
);
370 status
= ssc_readl(chip
->ssc
->regs
, IMR
);
372 if (status
& SSC_BIT(IMR_ENDTX
)) {
374 if (chip
->period
== runtime
->periods
)
376 next_period
= chip
->period
+ 1;
377 if (next_period
== runtime
->periods
)
380 offset
= block_size
* next_period
;
382 ssc_writel(chip
->ssc
->regs
, PDC_TNPR
,
383 (long)runtime
->dma_addr
+ offset
);
384 ssc_writel(chip
->ssc
->regs
, PDC_TNCR
,
385 runtime
->period_size
* runtime
->channels
);
386 retval
= IRQ_HANDLED
;
389 ssc_readl(chip
->ssc
->regs
, IMR
);
390 spin_unlock(&chip
->lock
);
392 if (status
& SSC_BIT(IMR_ENDTX
))
393 snd_pcm_period_elapsed(chip
->substream
);
401 static int snd_at73c213_mono_get(struct snd_kcontrol
*kcontrol
,
402 struct snd_ctl_elem_value
*ucontrol
)
404 struct snd_at73c213
*chip
= snd_kcontrol_chip(kcontrol
);
405 int reg
= kcontrol
->private_value
& 0xff;
406 int shift
= (kcontrol
->private_value
>> 8) & 0xff;
407 int mask
= (kcontrol
->private_value
>> 16) & 0xff;
408 int invert
= (kcontrol
->private_value
>> 24) & 0xff;
410 mutex_lock(&chip
->mixer_lock
);
412 ucontrol
->value
.integer
.value
[0] =
413 (chip
->reg_image
[reg
] >> shift
) & mask
;
416 ucontrol
->value
.integer
.value
[0] =
417 mask
- ucontrol
->value
.integer
.value
[0];
419 mutex_unlock(&chip
->mixer_lock
);
424 static int snd_at73c213_mono_put(struct snd_kcontrol
*kcontrol
,
425 struct snd_ctl_elem_value
*ucontrol
)
427 struct snd_at73c213
*chip
= snd_kcontrol_chip(kcontrol
);
428 int reg
= kcontrol
->private_value
& 0xff;
429 int shift
= (kcontrol
->private_value
>> 8) & 0xff;
430 int mask
= (kcontrol
->private_value
>> 16) & 0xff;
431 int invert
= (kcontrol
->private_value
>> 24) & 0xff;
435 val
= (ucontrol
->value
.integer
.value
[0] & mask
);
440 mutex_lock(&chip
->mixer_lock
);
442 val
= (chip
->reg_image
[reg
] & ~(mask
<< shift
)) | val
;
443 change
= val
!= chip
->reg_image
[reg
];
444 retval
= snd_at73c213_write_reg(chip
, reg
, val
);
446 mutex_unlock(&chip
->mixer_lock
);
454 static int snd_at73c213_stereo_info(struct snd_kcontrol
*kcontrol
,
455 struct snd_ctl_elem_info
*uinfo
)
457 int mask
= (kcontrol
->private_value
>> 24) & 0xff;
460 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
462 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
465 uinfo
->value
.integer
.min
= 0;
466 uinfo
->value
.integer
.max
= mask
;
471 static int snd_at73c213_stereo_get(struct snd_kcontrol
*kcontrol
,
472 struct snd_ctl_elem_value
*ucontrol
)
474 struct snd_at73c213
*chip
= snd_kcontrol_chip(kcontrol
);
475 int left_reg
= kcontrol
->private_value
& 0xff;
476 int right_reg
= (kcontrol
->private_value
>> 8) & 0xff;
477 int shift_left
= (kcontrol
->private_value
>> 16) & 0x07;
478 int shift_right
= (kcontrol
->private_value
>> 19) & 0x07;
479 int mask
= (kcontrol
->private_value
>> 24) & 0xff;
480 int invert
= (kcontrol
->private_value
>> 22) & 1;
482 mutex_lock(&chip
->mixer_lock
);
484 ucontrol
->value
.integer
.value
[0] =
485 (chip
->reg_image
[left_reg
] >> shift_left
) & mask
;
486 ucontrol
->value
.integer
.value
[1] =
487 (chip
->reg_image
[right_reg
] >> shift_right
) & mask
;
490 ucontrol
->value
.integer
.value
[0] =
491 mask
- ucontrol
->value
.integer
.value
[0];
492 ucontrol
->value
.integer
.value
[1] =
493 mask
- ucontrol
->value
.integer
.value
[1];
496 mutex_unlock(&chip
->mixer_lock
);
501 static int snd_at73c213_stereo_put(struct snd_kcontrol
*kcontrol
,
502 struct snd_ctl_elem_value
*ucontrol
)
504 struct snd_at73c213
*chip
= snd_kcontrol_chip(kcontrol
);
505 int left_reg
= kcontrol
->private_value
& 0xff;
506 int right_reg
= (kcontrol
->private_value
>> 8) & 0xff;
507 int shift_left
= (kcontrol
->private_value
>> 16) & 0x07;
508 int shift_right
= (kcontrol
->private_value
>> 19) & 0x07;
509 int mask
= (kcontrol
->private_value
>> 24) & 0xff;
510 int invert
= (kcontrol
->private_value
>> 22) & 1;
512 unsigned short val1
, val2
;
514 val1
= ucontrol
->value
.integer
.value
[0] & mask
;
515 val2
= ucontrol
->value
.integer
.value
[1] & mask
;
521 val2
<<= shift_right
;
523 mutex_lock(&chip
->mixer_lock
);
525 val1
= (chip
->reg_image
[left_reg
] & ~(mask
<< shift_left
)) | val1
;
526 val2
= (chip
->reg_image
[right_reg
] & ~(mask
<< shift_right
)) | val2
;
527 change
= val1
!= chip
->reg_image
[left_reg
]
528 || val2
!= chip
->reg_image
[right_reg
];
529 retval
= snd_at73c213_write_reg(chip
, left_reg
, val1
);
531 mutex_unlock(&chip
->mixer_lock
);
534 retval
= snd_at73c213_write_reg(chip
, right_reg
, val2
);
536 mutex_unlock(&chip
->mixer_lock
);
540 mutex_unlock(&chip
->mixer_lock
);
548 #define snd_at73c213_mono_switch_info snd_ctl_boolean_mono_info
550 static int snd_at73c213_mono_switch_get(struct snd_kcontrol
*kcontrol
,
551 struct snd_ctl_elem_value
*ucontrol
)
553 struct snd_at73c213
*chip
= snd_kcontrol_chip(kcontrol
);
554 int reg
= kcontrol
->private_value
& 0xff;
555 int shift
= (kcontrol
->private_value
>> 8) & 0xff;
556 int invert
= (kcontrol
->private_value
>> 24) & 0xff;
558 mutex_lock(&chip
->mixer_lock
);
560 ucontrol
->value
.integer
.value
[0] =
561 (chip
->reg_image
[reg
] >> shift
) & 0x01;
564 ucontrol
->value
.integer
.value
[0] =
565 0x01 - ucontrol
->value
.integer
.value
[0];
567 mutex_unlock(&chip
->mixer_lock
);
572 static int snd_at73c213_mono_switch_put(struct snd_kcontrol
*kcontrol
,
573 struct snd_ctl_elem_value
*ucontrol
)
575 struct snd_at73c213
*chip
= snd_kcontrol_chip(kcontrol
);
576 int reg
= kcontrol
->private_value
& 0xff;
577 int shift
= (kcontrol
->private_value
>> 8) & 0xff;
578 int mask
= (kcontrol
->private_value
>> 16) & 0xff;
579 int invert
= (kcontrol
->private_value
>> 24) & 0xff;
583 if (ucontrol
->value
.integer
.value
[0])
592 mutex_lock(&chip
->mixer_lock
);
594 val
|= (chip
->reg_image
[reg
] & ~(mask
<< shift
));
595 change
= val
!= chip
->reg_image
[reg
];
597 retval
= snd_at73c213_write_reg(chip
, reg
, val
);
599 mutex_unlock(&chip
->mixer_lock
);
607 static int snd_at73c213_pa_volume_info(struct snd_kcontrol
*kcontrol
,
608 struct snd_ctl_elem_info
*uinfo
)
610 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
612 uinfo
->value
.integer
.min
= 0;
613 uinfo
->value
.integer
.max
= ((kcontrol
->private_value
>> 16) & 0xff) - 1;
618 static int snd_at73c213_line_capture_volume_info(
619 struct snd_kcontrol
*kcontrol
,
620 struct snd_ctl_elem_info
*uinfo
)
622 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
624 /* When inverted will give values 0x10001 => 0. */
625 uinfo
->value
.integer
.min
= 14;
626 uinfo
->value
.integer
.max
= 31;
631 static int snd_at73c213_aux_capture_volume_info(
632 struct snd_kcontrol
*kcontrol
,
633 struct snd_ctl_elem_info
*uinfo
)
635 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
637 /* When inverted will give values 0x10001 => 0. */
638 uinfo
->value
.integer
.min
= 14;
639 uinfo
->value
.integer
.max
= 31;
644 #define AT73C213_MONO_SWITCH(xname, xindex, reg, shift, mask, invert) \
646 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
649 .info = snd_at73c213_mono_switch_info, \
650 .get = snd_at73c213_mono_switch_get, \
651 .put = snd_at73c213_mono_switch_put, \
652 .private_value = (reg | (shift << 8) | (mask << 16) | (invert << 24)) \
655 #define AT73C213_STEREO(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
657 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
660 .info = snd_at73c213_stereo_info, \
661 .get = snd_at73c213_stereo_get, \
662 .put = snd_at73c213_stereo_put, \
663 .private_value = (left_reg | (right_reg << 8) \
664 | (shift_left << 16) | (shift_right << 19) \
665 | (mask << 24) | (invert << 22)) \
668 static struct snd_kcontrol_new snd_at73c213_controls
[] __devinitdata
= {
669 AT73C213_STEREO("Master Playback Volume", 0, DAC_LMPG
, DAC_RMPG
, 0, 0, 0x1f, 1),
670 AT73C213_STEREO("Master Playback Switch", 0, DAC_LMPG
, DAC_RMPG
, 5, 5, 1, 1),
671 AT73C213_STEREO("PCM Playback Volume", 0, DAC_LLOG
, DAC_RLOG
, 0, 0, 0x1f, 1),
672 AT73C213_STEREO("PCM Playback Switch", 0, DAC_LLOG
, DAC_RLOG
, 5, 5, 1, 1),
673 AT73C213_MONO_SWITCH("Mono PA Playback Switch", 0, DAC_CTRL
, DAC_CTRL_ONPADRV
,
676 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
677 .name
= "PA Playback Volume",
679 .info
= snd_at73c213_pa_volume_info
,
680 .get
= snd_at73c213_mono_get
,
681 .put
= snd_at73c213_mono_put
,
682 .private_value
= PA_CTRL
| (PA_CTRL_APAGAIN
<< 8) | \
683 (0x0f << 16) | (1 << 24),
685 AT73C213_MONO_SWITCH("PA High Gain Playback Switch", 0, PA_CTRL
, PA_CTRL_APALP
,
687 AT73C213_MONO_SWITCH("PA Playback Switch", 0, PA_CTRL
, PA_CTRL_APAON
, 0x01, 0),
689 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
690 .name
= "Aux Capture Volume",
692 .info
= snd_at73c213_aux_capture_volume_info
,
693 .get
= snd_at73c213_mono_get
,
694 .put
= snd_at73c213_mono_put
,
695 .private_value
= DAC_AUXG
| (0 << 8) | (0x1f << 16) | (1 << 24),
697 AT73C213_MONO_SWITCH("Aux Capture Switch", 0, DAC_CTRL
, DAC_CTRL_ONAUXIN
,
700 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
701 .name
= "Line Capture Volume",
703 .info
= snd_at73c213_line_capture_volume_info
,
704 .get
= snd_at73c213_stereo_get
,
705 .put
= snd_at73c213_stereo_put
,
706 .private_value
= DAC_LLIG
| (DAC_RLIG
<< 8) | (0 << 16) | (0 << 19)
707 | (0x1f << 24) | (1 << 22),
709 AT73C213_MONO_SWITCH("Line Capture Switch", 0, DAC_CTRL
, 0, 0x03, 0),
712 static int __devinit
snd_at73c213_mixer(struct snd_at73c213
*chip
)
714 struct snd_card
*card
;
717 if (chip
== NULL
|| chip
->pcm
== NULL
)
722 strcpy(card
->mixername
, chip
->pcm
->name
);
724 for (idx
= 0; idx
< ARRAY_SIZE(snd_at73c213_controls
); idx
++) {
725 errval
= snd_ctl_add(card
,
726 snd_ctl_new1(&snd_at73c213_controls
[idx
],
735 for (idx
= 1; idx
< ARRAY_SIZE(snd_at73c213_controls
) + 1; idx
++) {
736 struct snd_kcontrol
*kctl
;
737 kctl
= snd_ctl_find_numid(card
, idx
);
739 snd_ctl_remove(card
, kctl
);
747 static int __devinit
snd_at73c213_ssc_init(struct snd_at73c213
*chip
)
750 * Continuous clock output.
751 * Starts on falling TF.
752 * Delay 1 cycle (1 bit).
753 * Periode is 16 bit (16 - 1).
755 ssc_writel(chip
->ssc
->regs
, TCMR
,
757 | SSC_BF(TCMR_START
, 4)
758 | SSC_BF(TCMR_STTDLY
, 1)
759 | SSC_BF(TCMR_PERIOD
, 16 - 1));
761 * Data length is 16 bit (16 - 1).
762 * Transmit MSB first.
763 * Transmit 2 words each transfer.
764 * Frame sync length is 16 bit (16 - 1).
765 * Frame starts on negative pulse.
767 ssc_writel(chip
->ssc
->regs
, TFMR
,
768 SSC_BF(TFMR_DATLEN
, 16 - 1)
770 | SSC_BF(TFMR_DATNB
, 1)
771 | SSC_BF(TFMR_FSLEN
, 16 - 1)
772 | SSC_BF(TFMR_FSOS
, 1));
777 static int __devinit
snd_at73c213_chip_init(struct snd_at73c213
*chip
)
780 unsigned char dac_ctrl
= 0;
782 retval
= snd_at73c213_set_bitrate(chip
);
786 /* Enable DAC master clock. */
787 clk_enable(chip
->board
->dac_clk
);
789 /* Initialize at73c213 on SPI bus. */
790 retval
= snd_at73c213_write_reg(chip
, DAC_RST
, 0x04);
794 retval
= snd_at73c213_write_reg(chip
, DAC_RST
, 0x03);
798 /* Precharge everything. */
799 retval
= snd_at73c213_write_reg(chip
, DAC_PRECH
, 0xff);
802 retval
= snd_at73c213_write_reg(chip
, PA_CTRL
, (1<<PA_CTRL_APAPRECH
));
805 retval
= snd_at73c213_write_reg(chip
, DAC_CTRL
,
806 (1<<DAC_CTRL_ONLNOL
) | (1<<DAC_CTRL_ONLNOR
));
812 /* Stop precharging PA. */
813 retval
= snd_at73c213_write_reg(chip
, PA_CTRL
,
814 (1<<PA_CTRL_APALP
) | 0x0f);
820 /* Stop precharging DAC, turn on master power. */
821 retval
= snd_at73c213_write_reg(chip
, DAC_PRECH
, (1<<DAC_PRECH_ONMSTR
));
828 dac_ctrl
= (1<<DAC_CTRL_ONDACL
) | (1<<DAC_CTRL_ONDACR
)
829 | (1<<DAC_CTRL_ONLNOL
) | (1<<DAC_CTRL_ONLNOR
);
831 retval
= snd_at73c213_write_reg(chip
, DAC_CTRL
, dac_ctrl
);
836 retval
= snd_at73c213_write_reg(chip
, DAC_LMPG
, 0x3f);
839 retval
= snd_at73c213_write_reg(chip
, DAC_RMPG
, 0x3f);
842 retval
= snd_at73c213_write_reg(chip
, DAC_LLOG
, 0x3f);
845 retval
= snd_at73c213_write_reg(chip
, DAC_RLOG
, 0x3f);
848 retval
= snd_at73c213_write_reg(chip
, DAC_LLIG
, 0x11);
851 retval
= snd_at73c213_write_reg(chip
, DAC_RLIG
, 0x11);
854 retval
= snd_at73c213_write_reg(chip
, DAC_AUXG
, 0x11);
858 /* Enable I2S device, i.e. clock output. */
859 ssc_writel(chip
->ssc
->regs
, CR
, SSC_BIT(CR_TXEN
));
864 clk_disable(chip
->board
->dac_clk
);
869 static int snd_at73c213_dev_free(struct snd_device
*device
)
871 struct snd_at73c213
*chip
= device
->device_data
;
873 ssc_writel(chip
->ssc
->regs
, CR
, SSC_BIT(CR_TXDIS
));
874 if (chip
->irq
>= 0) {
875 free_irq(chip
->irq
, chip
);
882 static int __devinit
snd_at73c213_dev_init(struct snd_card
*card
,
883 struct spi_device
*spi
)
885 static struct snd_device_ops ops
= {
886 .dev_free
= snd_at73c213_dev_free
,
888 struct snd_at73c213
*chip
= get_chip(card
);
891 irq
= chip
->ssc
->irq
;
895 spin_lock_init(&chip
->lock
);
896 mutex_init(&chip
->mixer_lock
);
900 retval
= request_irq(irq
, snd_at73c213_interrupt
, 0, "at73c213", chip
);
902 dev_dbg(&chip
->spi
->dev
, "unable to request irq %d\n", irq
);
907 memcpy(&chip
->reg_image
, &snd_at73c213_original_image
,
908 sizeof(snd_at73c213_original_image
));
910 retval
= snd_at73c213_ssc_init(chip
);
914 retval
= snd_at73c213_chip_init(chip
);
918 retval
= snd_at73c213_pcm_new(chip
, 0);
922 retval
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, chip
, &ops
);
926 retval
= snd_at73c213_mixer(chip
);
930 snd_card_set_dev(card
, &spi
->dev
);
935 snd_device_free(card
, chip
);
937 free_irq(chip
->irq
, chip
);
943 static int __devinit
snd_at73c213_probe(struct spi_device
*spi
)
945 struct snd_card
*card
;
946 struct snd_at73c213
*chip
;
947 struct at73c213_board_info
*board
;
951 board
= spi
->dev
.platform_data
;
953 dev_dbg(&spi
->dev
, "no platform_data\n");
957 if (!board
->dac_clk
) {
958 dev_dbg(&spi
->dev
, "no DAC clk\n");
962 if (IS_ERR(board
->dac_clk
)) {
963 dev_dbg(&spi
->dev
, "no DAC clk\n");
964 return PTR_ERR(board
->dac_clk
);
967 /* Allocate "card" using some unused identifiers. */
968 snprintf(id
, sizeof id
, "at73c213_%d", board
->ssc_id
);
969 retval
= snd_card_create(-1, id
, THIS_MODULE
,
970 sizeof(struct snd_at73c213
), &card
);
974 chip
= card
->private_data
;
978 chip
->ssc
= ssc_request(board
->ssc_id
);
979 if (IS_ERR(chip
->ssc
)) {
980 dev_dbg(&spi
->dev
, "could not get ssc%d device\n",
982 retval
= PTR_ERR(chip
->ssc
);
986 retval
= snd_at73c213_dev_init(card
, spi
);
990 strcpy(card
->driver
, "at73c213");
991 strcpy(card
->shortname
, board
->shortname
);
992 sprintf(card
->longname
, "%s on irq %d", card
->shortname
, chip
->irq
);
994 retval
= snd_card_register(card
);
998 dev_set_drvdata(&spi
->dev
, card
);
1003 ssc_free(chip
->ssc
);
1005 snd_card_free(card
);
1010 static int __devexit
snd_at73c213_remove(struct spi_device
*spi
)
1012 struct snd_card
*card
= dev_get_drvdata(&spi
->dev
);
1013 struct snd_at73c213
*chip
= card
->private_data
;
1016 /* Stop playback. */
1017 ssc_writel(chip
->ssc
->regs
, CR
, SSC_BIT(CR_TXDIS
));
1020 retval
= snd_at73c213_write_reg(chip
, DAC_LMPG
, 0x3f);
1023 retval
= snd_at73c213_write_reg(chip
, DAC_RMPG
, 0x3f);
1026 retval
= snd_at73c213_write_reg(chip
, DAC_LLOG
, 0x3f);
1029 retval
= snd_at73c213_write_reg(chip
, DAC_RLOG
, 0x3f);
1032 retval
= snd_at73c213_write_reg(chip
, DAC_LLIG
, 0x11);
1035 retval
= snd_at73c213_write_reg(chip
, DAC_RLIG
, 0x11);
1038 retval
= snd_at73c213_write_reg(chip
, DAC_AUXG
, 0x11);
1043 retval
= snd_at73c213_write_reg(chip
, PA_CTRL
,
1044 chip
->reg_image
[PA_CTRL
] | 0x0f);
1048 retval
= snd_at73c213_write_reg(chip
, PA_CTRL
,
1049 (1 << PA_CTRL_APALP
) | 0x0f);
1053 /* Turn off external DAC. */
1054 retval
= snd_at73c213_write_reg(chip
, DAC_CTRL
, 0x0c);
1058 retval
= snd_at73c213_write_reg(chip
, DAC_CTRL
, 0x00);
1062 /* Turn off master power. */
1063 retval
= snd_at73c213_write_reg(chip
, DAC_PRECH
, 0x00);
1068 /* Stop DAC master clock. */
1069 clk_disable(chip
->board
->dac_clk
);
1071 ssc_free(chip
->ssc
);
1072 snd_card_free(card
);
1073 dev_set_drvdata(&spi
->dev
, NULL
);
1079 static int snd_at73c213_suspend(struct spi_device
*spi
, pm_message_t msg
)
1081 struct snd_card
*card
= dev_get_drvdata(&spi
->dev
);
1082 struct snd_at73c213
*chip
= card
->private_data
;
1084 ssc_writel(chip
->ssc
->regs
, CR
, SSC_BIT(CR_TXDIS
));
1085 clk_disable(chip
->board
->dac_clk
);
1090 static int snd_at73c213_resume(struct spi_device
*spi
)
1092 struct snd_card
*card
= dev_get_drvdata(&spi
->dev
);
1093 struct snd_at73c213
*chip
= card
->private_data
;
1095 clk_enable(chip
->board
->dac_clk
);
1096 ssc_writel(chip
->ssc
->regs
, CR
, SSC_BIT(CR_TXEN
));
1101 #define snd_at73c213_suspend NULL
1102 #define snd_at73c213_resume NULL
1105 static struct spi_driver at73c213_driver
= {
1109 .probe
= snd_at73c213_probe
,
1110 .suspend
= snd_at73c213_suspend
,
1111 .resume
= snd_at73c213_resume
,
1112 .remove
= __devexit_p(snd_at73c213_remove
),
1115 module_spi_driver(at73c213_driver
);
1117 MODULE_AUTHOR("Hans-Christian Egtvedt <egtvedt@samfundet.no>");
1118 MODULE_DESCRIPTION("Sound driver for AT73C213 with Atmel SSC");
1119 MODULE_LICENSE("GPL");