blob: 27de8015717d95fdf45ac512a77c60eb32202d67 [file] [log] [blame]
Dylan Reid05e84872014-02-28 15:41:22 -08001/*
2 *
3 * Implementation of primary alsa driver code base for Intel HD Audio.
4 *
5 * Copyright(c) 2004 Intel Corporation. All rights reserved.
6 *
7 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
8 * PeiSen Hou <pshou@realtek.com.tw>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the Free
12 * Software Foundation; either version 2 of the License, or (at your option)
13 * any later version.
14 *
15 * This program is distributed in the hope that it will be useful, but WITHOUT
16 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
18 * more details.
19 *
20 *
21 */
22
23#include <linux/clocksource.h>
24#include <linux/delay.h>
Dylan Reidf0b1df82014-02-28 15:41:29 -080025#include <linux/interrupt.h>
Dylan Reid05e84872014-02-28 15:41:22 -080026#include <linux/kernel.h>
27#include <linux/module.h>
Dylan Reid154867c2014-02-28 15:41:30 -080028#include <linux/pm_runtime.h>
Dylan Reid05e84872014-02-28 15:41:22 -080029#include <linux/slab.h>
30#include <sound/core.h>
31#include <sound/initval.h>
Dylan Reid05e84872014-02-28 15:41:22 -080032#include "hda_controller.h"
33
Takashi Iwai43db4a52015-04-16 11:44:58 +020034#define CREATE_TRACE_POINTS
Libin Yang18486502015-05-12 09:43:21 +080035#include "hda_controller_trace.h"
Takashi Iwai43db4a52015-04-16 11:44:58 +020036
Dylan Reid2b5fd6c2014-02-28 15:41:24 -080037/* DSP lock helpers */
Takashi Iwai7833c3f2015-04-14 18:13:13 +020038#define dsp_lock(dev) snd_hdac_dsp_lock(azx_stream(dev))
39#define dsp_unlock(dev) snd_hdac_dsp_unlock(azx_stream(dev))
40#define dsp_is_locked(dev) snd_hdac_stream_is_locked(azx_stream(dev))
Dylan Reid2b5fd6c2014-02-28 15:41:24 -080041
Dylan Reid05e84872014-02-28 15:41:22 -080042/* assign a stream for the PCM */
43static inline struct azx_dev *
44azx_assign_device(struct azx *chip, struct snd_pcm_substream *substream)
45{
Takashi Iwai7833c3f2015-04-14 18:13:13 +020046 struct hdac_stream *s;
Dylan Reid05e84872014-02-28 15:41:22 -080047
Takashi Iwai7833c3f2015-04-14 18:13:13 +020048 s = snd_hdac_stream_assign(azx_bus(chip), substream);
49 if (!s)
50 return NULL;
51 return stream_to_azx_dev(s);
Dylan Reid05e84872014-02-28 15:41:22 -080052}
53
54/* release the assigned stream */
55static inline void azx_release_device(struct azx_dev *azx_dev)
56{
Takashi Iwai7833c3f2015-04-14 18:13:13 +020057 snd_hdac_stream_release(azx_stream(azx_dev));
Dylan Reid05e84872014-02-28 15:41:22 -080058}
59
Takashi Iwai820cc6c2015-02-20 12:50:46 +010060static inline struct hda_pcm_stream *
61to_hda_pcm_stream(struct snd_pcm_substream *substream)
62{
63 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
64 return &apcm->info->stream[substream->stream];
65}
66
Dylan Reid05e84872014-02-28 15:41:22 -080067static u64 azx_adjust_codec_delay(struct snd_pcm_substream *substream,
68 u64 nsec)
69{
70 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
Takashi Iwai820cc6c2015-02-20 12:50:46 +010071 struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
Dylan Reid05e84872014-02-28 15:41:22 -080072 u64 codec_frames, codec_nsecs;
73
74 if (!hinfo->ops.get_delay)
75 return nsec;
76
77 codec_frames = hinfo->ops.get_delay(hinfo, apcm->codec, substream);
78 codec_nsecs = div_u64(codec_frames * 1000000000LL,
79 substream->runtime->rate);
80
81 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
82 return nsec + codec_nsecs;
83
84 return (nsec > codec_nsecs) ? nsec - codec_nsecs : 0;
85}
86
87/*
Dylan Reid05e84872014-02-28 15:41:22 -080088 * PCM ops
89 */
90
91static int azx_pcm_close(struct snd_pcm_substream *substream)
92{
93 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
Takashi Iwai820cc6c2015-02-20 12:50:46 +010094 struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
Dylan Reid05e84872014-02-28 15:41:22 -080095 struct azx *chip = apcm->chip;
96 struct azx_dev *azx_dev = get_azx_dev(substream);
Dylan Reid05e84872014-02-28 15:41:22 -080097
Libin Yang18486502015-05-12 09:43:21 +080098 trace_azx_pcm_close(chip, azx_dev);
Dylan Reid05e84872014-02-28 15:41:22 -080099 mutex_lock(&chip->open_mutex);
Dylan Reid05e84872014-02-28 15:41:22 -0800100 azx_release_device(azx_dev);
Takashi Iwai61ca4102015-02-27 17:57:55 +0100101 if (hinfo->ops.close)
102 hinfo->ops.close(hinfo, apcm->codec, substream);
Dylan Reid05e84872014-02-28 15:41:22 -0800103 snd_hda_power_down(apcm->codec);
104 mutex_unlock(&chip->open_mutex);
Takashi Iwai9a6246f2015-02-27 18:17:28 +0100105 snd_hda_codec_pcm_put(apcm->info);
Dylan Reid05e84872014-02-28 15:41:22 -0800106 return 0;
107}
108
109static int azx_pcm_hw_params(struct snd_pcm_substream *substream,
110 struct snd_pcm_hw_params *hw_params)
111{
112 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
113 struct azx *chip = apcm->chip;
Takashi Iwai602518a22015-04-16 07:53:08 +0200114 struct azx_dev *azx_dev = get_azx_dev(substream);
Dylan Reid05e84872014-02-28 15:41:22 -0800115 int ret;
116
Libin Yang18486502015-05-12 09:43:21 +0800117 trace_azx_pcm_hw_params(chip, azx_dev);
Takashi Iwai602518a22015-04-16 07:53:08 +0200118 dsp_lock(azx_dev);
119 if (dsp_is_locked(azx_dev)) {
Dylan Reid05e84872014-02-28 15:41:22 -0800120 ret = -EBUSY;
121 goto unlock;
122 }
123
Takashi Iwai602518a22015-04-16 07:53:08 +0200124 azx_dev->core.bufsize = 0;
125 azx_dev->core.period_bytes = 0;
126 azx_dev->core.format_val = 0;
Dylan Reid05e84872014-02-28 15:41:22 -0800127 ret = chip->ops->substream_alloc_pages(chip, substream,
128 params_buffer_bytes(hw_params));
129unlock:
Takashi Iwai602518a22015-04-16 07:53:08 +0200130 dsp_unlock(azx_dev);
Dylan Reid05e84872014-02-28 15:41:22 -0800131 return ret;
132}
133
134static int azx_pcm_hw_free(struct snd_pcm_substream *substream)
135{
136 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
137 struct azx_dev *azx_dev = get_azx_dev(substream);
138 struct azx *chip = apcm->chip;
Takashi Iwai820cc6c2015-02-20 12:50:46 +0100139 struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
Dylan Reid05e84872014-02-28 15:41:22 -0800140 int err;
141
142 /* reset BDL address */
143 dsp_lock(azx_dev);
Takashi Iwaiccc98862015-04-14 22:06:53 +0200144 if (!dsp_is_locked(azx_dev))
145 snd_hdac_stream_cleanup(azx_stream(azx_dev));
Dylan Reid05e84872014-02-28 15:41:22 -0800146
147 snd_hda_codec_cleanup(apcm->codec, hinfo, substream);
148
149 err = chip->ops->substream_free_pages(chip, substream);
Takashi Iwai6d23c8f2015-04-17 13:34:30 +0200150 azx_stream(azx_dev)->prepared = 0;
Dylan Reid05e84872014-02-28 15:41:22 -0800151 dsp_unlock(azx_dev);
152 return err;
153}
154
155static int azx_pcm_prepare(struct snd_pcm_substream *substream)
156{
157 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
158 struct azx *chip = apcm->chip;
159 struct azx_dev *azx_dev = get_azx_dev(substream);
Takashi Iwai820cc6c2015-02-20 12:50:46 +0100160 struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
Dylan Reid05e84872014-02-28 15:41:22 -0800161 struct snd_pcm_runtime *runtime = substream->runtime;
Takashi Iwai0dd76f32015-04-18 09:59:38 +0200162 unsigned int format_val, stream_tag;
Dylan Reid05e84872014-02-28 15:41:22 -0800163 int err;
164 struct hda_spdif_out *spdif =
165 snd_hda_spdif_out_of_nid(apcm->codec, hinfo->nid);
166 unsigned short ctls = spdif ? spdif->ctls : 0;
167
Libin Yang18486502015-05-12 09:43:21 +0800168 trace_azx_pcm_prepare(chip, azx_dev);
Dylan Reid05e84872014-02-28 15:41:22 -0800169 dsp_lock(azx_dev);
170 if (dsp_is_locked(azx_dev)) {
171 err = -EBUSY;
172 goto unlock;
173 }
174
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200175 snd_hdac_stream_reset(azx_stream(azx_dev));
Takashi Iwaib7d023e2015-04-16 08:19:06 +0200176 format_val = snd_hdac_calc_stream_format(runtime->rate,
Dylan Reid05e84872014-02-28 15:41:22 -0800177 runtime->channels,
178 runtime->format,
179 hinfo->maxbps,
180 ctls);
181 if (!format_val) {
182 dev_err(chip->card->dev,
183 "invalid format_val, rate=%d, ch=%d, format=%d\n",
184 runtime->rate, runtime->channels, runtime->format);
185 err = -EINVAL;
186 goto unlock;
187 }
188
Takashi Iwai0dd76f32015-04-18 09:59:38 +0200189 err = snd_hdac_stream_set_params(azx_stream(azx_dev), format_val);
190 if (err < 0)
191 goto unlock;
Dylan Reid05e84872014-02-28 15:41:22 -0800192
Takashi Iwaiccc98862015-04-14 22:06:53 +0200193 snd_hdac_stream_setup(azx_stream(azx_dev));
Dylan Reid05e84872014-02-28 15:41:22 -0800194
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200195 stream_tag = azx_dev->core.stream_tag;
Dylan Reid05e84872014-02-28 15:41:22 -0800196 /* CA-IBG chips need the playback stream starting from 1 */
197 if ((chip->driver_caps & AZX_DCAPS_CTX_WORKAROUND) &&
198 stream_tag > chip->capture_streams)
199 stream_tag -= chip->capture_streams;
200 err = snd_hda_codec_prepare(apcm->codec, hinfo, stream_tag,
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200201 azx_dev->core.format_val, substream);
Dylan Reid05e84872014-02-28 15:41:22 -0800202
203 unlock:
204 if (!err)
Takashi Iwai6d23c8f2015-04-17 13:34:30 +0200205 azx_stream(azx_dev)->prepared = 1;
Dylan Reid05e84872014-02-28 15:41:22 -0800206 dsp_unlock(azx_dev);
207 return err;
208}
209
210static int azx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
211{
212 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
213 struct azx *chip = apcm->chip;
Takashi Iwaia41d1222015-04-14 22:13:18 +0200214 struct hdac_bus *bus = azx_bus(chip);
Dylan Reid05e84872014-02-28 15:41:22 -0800215 struct azx_dev *azx_dev;
216 struct snd_pcm_substream *s;
Takashi Iwaiccc98862015-04-14 22:06:53 +0200217 struct hdac_stream *hstr;
218 bool start;
219 int sbits = 0;
220 int sync_reg;
Dylan Reid05e84872014-02-28 15:41:22 -0800221
222 azx_dev = get_azx_dev(substream);
Takashi Iwai43db4a52015-04-16 11:44:58 +0200223 trace_azx_pcm_trigger(chip, azx_dev, cmd);
224
Takashi Iwaiccc98862015-04-14 22:06:53 +0200225 hstr = azx_stream(azx_dev);
226 if (chip->driver_caps & AZX_DCAPS_OLD_SSYNC)
227 sync_reg = AZX_REG_OLD_SSYNC;
228 else
229 sync_reg = AZX_REG_SSYNC;
Dylan Reid05e84872014-02-28 15:41:22 -0800230
Takashi Iwai6d23c8f2015-04-17 13:34:30 +0200231 if (dsp_is_locked(azx_dev) || !hstr->prepared)
Dylan Reid05e84872014-02-28 15:41:22 -0800232 return -EPIPE;
233
234 switch (cmd) {
235 case SNDRV_PCM_TRIGGER_START:
Dylan Reid05e84872014-02-28 15:41:22 -0800236 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
237 case SNDRV_PCM_TRIGGER_RESUME:
Takashi Iwaiccc98862015-04-14 22:06:53 +0200238 start = true;
Dylan Reid05e84872014-02-28 15:41:22 -0800239 break;
240 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
241 case SNDRV_PCM_TRIGGER_SUSPEND:
242 case SNDRV_PCM_TRIGGER_STOP:
Takashi Iwaiccc98862015-04-14 22:06:53 +0200243 start = false;
Dylan Reid05e84872014-02-28 15:41:22 -0800244 break;
245 default:
246 return -EINVAL;
247 }
248
249 snd_pcm_group_for_each_entry(s, substream) {
250 if (s->pcm->card != substream->pcm->card)
251 continue;
252 azx_dev = get_azx_dev(s);
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200253 sbits |= 1 << azx_dev->core.index;
Dylan Reid05e84872014-02-28 15:41:22 -0800254 snd_pcm_trigger_done(s, substream);
255 }
256
Takashi Iwaia41d1222015-04-14 22:13:18 +0200257 spin_lock(&bus->reg_lock);
Dylan Reid05e84872014-02-28 15:41:22 -0800258
259 /* first, set SYNC bits of corresponding streams */
Takashi Iwaiccc98862015-04-14 22:06:53 +0200260 snd_hdac_stream_sync_trigger(hstr, true, sbits, sync_reg);
Dylan Reid05e84872014-02-28 15:41:22 -0800261
262 snd_pcm_group_for_each_entry(s, substream) {
263 if (s->pcm->card != substream->pcm->card)
264 continue;
265 azx_dev = get_azx_dev(s);
266 if (start) {
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200267 azx_dev->insufficient = 1;
268 snd_hdac_stream_start(azx_stream(azx_dev), true);
Dylan Reid05e84872014-02-28 15:41:22 -0800269 } else {
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200270 snd_hdac_stream_stop(azx_stream(azx_dev));
Dylan Reid05e84872014-02-28 15:41:22 -0800271 }
Dylan Reid05e84872014-02-28 15:41:22 -0800272 }
Takashi Iwaia41d1222015-04-14 22:13:18 +0200273 spin_unlock(&bus->reg_lock);
Takashi Iwaiccc98862015-04-14 22:06:53 +0200274
275 snd_hdac_stream_sync(hstr, start, sbits);
276
Takashi Iwaia41d1222015-04-14 22:13:18 +0200277 spin_lock(&bus->reg_lock);
Dylan Reid05e84872014-02-28 15:41:22 -0800278 /* reset SYNC bits */
Takashi Iwaiccc98862015-04-14 22:06:53 +0200279 snd_hdac_stream_sync_trigger(hstr, false, sbits, sync_reg);
280 if (start)
281 snd_hdac_stream_timecounter_init(hstr, sbits);
Takashi Iwaia41d1222015-04-14 22:13:18 +0200282 spin_unlock(&bus->reg_lock);
Dylan Reid05e84872014-02-28 15:41:22 -0800283 return 0;
284}
285
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200286unsigned int azx_get_pos_lpib(struct azx *chip, struct azx_dev *azx_dev)
Dylan Reid05e84872014-02-28 15:41:22 -0800287{
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200288 return snd_hdac_stream_get_pos_lpib(azx_stream(azx_dev));
Dylan Reid05e84872014-02-28 15:41:22 -0800289}
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200290EXPORT_SYMBOL_GPL(azx_get_pos_lpib);
291
292unsigned int azx_get_pos_posbuf(struct azx *chip, struct azx_dev *azx_dev)
293{
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200294 return snd_hdac_stream_get_pos_posbuf(azx_stream(azx_dev));
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200295}
296EXPORT_SYMBOL_GPL(azx_get_pos_posbuf);
Dylan Reid05e84872014-02-28 15:41:22 -0800297
298unsigned int azx_get_position(struct azx *chip,
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200299 struct azx_dev *azx_dev)
Dylan Reid05e84872014-02-28 15:41:22 -0800300{
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200301 struct snd_pcm_substream *substream = azx_dev->core.substream;
Dylan Reid05e84872014-02-28 15:41:22 -0800302 unsigned int pos;
303 int stream = substream->stream;
Dylan Reid05e84872014-02-28 15:41:22 -0800304 int delay = 0;
305
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200306 if (chip->get_position[stream])
307 pos = chip->get_position[stream](chip, azx_dev);
308 else /* use the position buffer as default */
309 pos = azx_get_pos_posbuf(chip, azx_dev);
Dylan Reid05e84872014-02-28 15:41:22 -0800310
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200311 if (pos >= azx_dev->core.bufsize)
Dylan Reid05e84872014-02-28 15:41:22 -0800312 pos = 0;
313
Dylan Reid05e84872014-02-28 15:41:22 -0800314 if (substream->runtime) {
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200315 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
Takashi Iwai820cc6c2015-02-20 12:50:46 +0100316 struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200317
318 if (chip->get_delay[stream])
319 delay += chip->get_delay[stream](chip, azx_dev, pos);
Dylan Reid05e84872014-02-28 15:41:22 -0800320 if (hinfo->ops.get_delay)
321 delay += hinfo->ops.get_delay(hinfo, apcm->codec,
322 substream);
323 substream->runtime->delay = delay;
324 }
325
Takashi Iwai43db4a52015-04-16 11:44:58 +0200326 trace_azx_get_position(chip, azx_dev, pos, delay);
Dylan Reid05e84872014-02-28 15:41:22 -0800327 return pos;
328}
329EXPORT_SYMBOL_GPL(azx_get_position);
330
331static snd_pcm_uframes_t azx_pcm_pointer(struct snd_pcm_substream *substream)
332{
333 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
334 struct azx *chip = apcm->chip;
335 struct azx_dev *azx_dev = get_azx_dev(substream);
336 return bytes_to_frames(substream->runtime,
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200337 azx_get_position(chip, azx_dev));
Dylan Reid05e84872014-02-28 15:41:22 -0800338}
339
Pierre-Louis Bossart9e94df32015-02-13 15:14:07 -0600340static int azx_get_time_info(struct snd_pcm_substream *substream,
341 struct timespec *system_ts, struct timespec *audio_ts,
342 struct snd_pcm_audio_tstamp_config *audio_tstamp_config,
343 struct snd_pcm_audio_tstamp_report *audio_tstamp_report)
Dylan Reid05e84872014-02-28 15:41:22 -0800344{
345 struct azx_dev *azx_dev = get_azx_dev(substream);
346 u64 nsec;
347
Pierre-Louis Bossart9e94df32015-02-13 15:14:07 -0600348 if ((substream->runtime->hw.info & SNDRV_PCM_INFO_HAS_LINK_ATIME) &&
349 (audio_tstamp_config->type_requested == SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK)) {
Dylan Reid05e84872014-02-28 15:41:22 -0800350
Pierre-Louis Bossart9e94df32015-02-13 15:14:07 -0600351 snd_pcm_gettime(substream->runtime, system_ts);
352
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200353 nsec = timecounter_read(&azx_dev->core.tc);
Pierre-Louis Bossart9e94df32015-02-13 15:14:07 -0600354 nsec = div_u64(nsec, 3); /* can be optimized */
355 if (audio_tstamp_config->report_delay)
356 nsec = azx_adjust_codec_delay(substream, nsec);
357
358 *audio_ts = ns_to_timespec(nsec);
359
360 audio_tstamp_report->actual_type = SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK;
361 audio_tstamp_report->accuracy_report = 1; /* rest of structure is valid */
362 audio_tstamp_report->accuracy = 42; /* 24 MHz WallClock == 42ns resolution */
363
364 } else
365 audio_tstamp_report->actual_type = SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT;
Dylan Reid05e84872014-02-28 15:41:22 -0800366
367 return 0;
368}
369
370static struct snd_pcm_hardware azx_pcm_hw = {
371 .info = (SNDRV_PCM_INFO_MMAP |
372 SNDRV_PCM_INFO_INTERLEAVED |
373 SNDRV_PCM_INFO_BLOCK_TRANSFER |
374 SNDRV_PCM_INFO_MMAP_VALID |
375 /* No full-resume yet implemented */
376 /* SNDRV_PCM_INFO_RESUME |*/
377 SNDRV_PCM_INFO_PAUSE |
378 SNDRV_PCM_INFO_SYNC_START |
Pierre-Louis Bossart9e94df32015-02-13 15:14:07 -0600379 SNDRV_PCM_INFO_HAS_WALL_CLOCK | /* legacy */
380 SNDRV_PCM_INFO_HAS_LINK_ATIME |
Dylan Reid05e84872014-02-28 15:41:22 -0800381 SNDRV_PCM_INFO_NO_PERIOD_WAKEUP),
382 .formats = SNDRV_PCM_FMTBIT_S16_LE,
383 .rates = SNDRV_PCM_RATE_48000,
384 .rate_min = 48000,
385 .rate_max = 48000,
386 .channels_min = 2,
387 .channels_max = 2,
388 .buffer_bytes_max = AZX_MAX_BUF_SIZE,
389 .period_bytes_min = 128,
390 .period_bytes_max = AZX_MAX_BUF_SIZE / 2,
391 .periods_min = 2,
392 .periods_max = AZX_MAX_FRAG,
393 .fifo_size = 0,
394};
395
396static int azx_pcm_open(struct snd_pcm_substream *substream)
397{
398 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
Takashi Iwai820cc6c2015-02-20 12:50:46 +0100399 struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
Dylan Reid05e84872014-02-28 15:41:22 -0800400 struct azx *chip = apcm->chip;
401 struct azx_dev *azx_dev;
402 struct snd_pcm_runtime *runtime = substream->runtime;
Dylan Reid05e84872014-02-28 15:41:22 -0800403 int err;
404 int buff_step;
405
Takashi Iwai9a6246f2015-02-27 18:17:28 +0100406 snd_hda_codec_pcm_get(apcm->info);
Dylan Reid05e84872014-02-28 15:41:22 -0800407 mutex_lock(&chip->open_mutex);
408 azx_dev = azx_assign_device(chip, substream);
Libin Yang18486502015-05-12 09:43:21 +0800409 trace_azx_pcm_open(chip, azx_dev);
Dylan Reid05e84872014-02-28 15:41:22 -0800410 if (azx_dev == NULL) {
Takashi Iwai61ca4102015-02-27 17:57:55 +0100411 err = -EBUSY;
412 goto unlock;
Dylan Reid05e84872014-02-28 15:41:22 -0800413 }
Takashi Iwaiccc98862015-04-14 22:06:53 +0200414 runtime->private_data = azx_dev;
Dylan Reid05e84872014-02-28 15:41:22 -0800415 runtime->hw = azx_pcm_hw;
416 runtime->hw.channels_min = hinfo->channels_min;
417 runtime->hw.channels_max = hinfo->channels_max;
418 runtime->hw.formats = hinfo->formats;
419 runtime->hw.rates = hinfo->rates;
420 snd_pcm_limit_hw_rates(runtime);
421 snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
422
423 /* avoid wrap-around with wall-clock */
424 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_TIME,
425 20,
426 178000000);
427
428 if (chip->align_buffer_size)
429 /* constrain buffer sizes to be multiple of 128
430 bytes. This is more efficient in terms of memory
431 access but isn't required by the HDA spec and
432 prevents users from specifying exact period/buffer
433 sizes. For example for 44.1kHz, a period size set
434 to 20ms will be rounded to 19.59ms. */
435 buff_step = 128;
436 else
437 /* Don't enforce steps on buffer sizes, still need to
438 be multiple of 4 bytes (HDA spec). Tested on Intel
439 HDA controllers, may not work on all devices where
440 option needs to be disabled */
441 buff_step = 4;
442
443 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
444 buff_step);
445 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
446 buff_step);
Takashi Iwaicc72da72015-02-19 16:00:22 +0100447 snd_hda_power_up(apcm->codec);
Takashi Iwai61ca4102015-02-27 17:57:55 +0100448 if (hinfo->ops.open)
449 err = hinfo->ops.open(hinfo, apcm->codec, substream);
450 else
451 err = -ENODEV;
Dylan Reid05e84872014-02-28 15:41:22 -0800452 if (err < 0) {
453 azx_release_device(azx_dev);
Takashi Iwai61ca4102015-02-27 17:57:55 +0100454 goto powerdown;
Dylan Reid05e84872014-02-28 15:41:22 -0800455 }
456 snd_pcm_limit_hw_rates(runtime);
457 /* sanity check */
458 if (snd_BUG_ON(!runtime->hw.channels_min) ||
459 snd_BUG_ON(!runtime->hw.channels_max) ||
460 snd_BUG_ON(!runtime->hw.formats) ||
461 snd_BUG_ON(!runtime->hw.rates)) {
462 azx_release_device(azx_dev);
Takashi Iwai61ca4102015-02-27 17:57:55 +0100463 if (hinfo->ops.close)
464 hinfo->ops.close(hinfo, apcm->codec, substream);
465 err = -EINVAL;
466 goto powerdown;
Dylan Reid05e84872014-02-28 15:41:22 -0800467 }
468
Pierre-Louis Bossart9e94df32015-02-13 15:14:07 -0600469 /* disable LINK_ATIME timestamps for capture streams
Dylan Reid05e84872014-02-28 15:41:22 -0800470 until we figure out how to handle digital inputs */
Pierre-Louis Bossart9e94df32015-02-13 15:14:07 -0600471 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
472 runtime->hw.info &= ~SNDRV_PCM_INFO_HAS_WALL_CLOCK; /* legacy */
473 runtime->hw.info &= ~SNDRV_PCM_INFO_HAS_LINK_ATIME;
474 }
Dylan Reid05e84872014-02-28 15:41:22 -0800475
Dylan Reid05e84872014-02-28 15:41:22 -0800476 snd_pcm_set_sync(substream);
477 mutex_unlock(&chip->open_mutex);
478 return 0;
Takashi Iwai61ca4102015-02-27 17:57:55 +0100479
480 powerdown:
481 snd_hda_power_down(apcm->codec);
482 unlock:
483 mutex_unlock(&chip->open_mutex);
Takashi Iwai9a6246f2015-02-27 18:17:28 +0100484 snd_hda_codec_pcm_put(apcm->info);
Takashi Iwai61ca4102015-02-27 17:57:55 +0100485 return err;
Dylan Reid05e84872014-02-28 15:41:22 -0800486}
487
488static int azx_pcm_mmap(struct snd_pcm_substream *substream,
489 struct vm_area_struct *area)
490{
491 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
492 struct azx *chip = apcm->chip;
493 if (chip->ops->pcm_mmap_prepare)
494 chip->ops->pcm_mmap_prepare(substream, area);
495 return snd_pcm_lib_default_mmap(substream, area);
496}
497
498static struct snd_pcm_ops azx_pcm_ops = {
499 .open = azx_pcm_open,
500 .close = azx_pcm_close,
501 .ioctl = snd_pcm_lib_ioctl,
502 .hw_params = azx_pcm_hw_params,
503 .hw_free = azx_pcm_hw_free,
504 .prepare = azx_pcm_prepare,
505 .trigger = azx_pcm_trigger,
506 .pointer = azx_pcm_pointer,
Pierre-Louis Bossart9e94df32015-02-13 15:14:07 -0600507 .get_time_info = azx_get_time_info,
Dylan Reid05e84872014-02-28 15:41:22 -0800508 .mmap = azx_pcm_mmap,
509 .page = snd_pcm_sgbuf_ops_page,
510};
511
512static void azx_pcm_free(struct snd_pcm *pcm)
513{
514 struct azx_pcm *apcm = pcm->private_data;
515 if (apcm) {
516 list_del(&apcm->list);
Takashi Iwai820cc6c2015-02-20 12:50:46 +0100517 apcm->info->pcm = NULL;
Dylan Reid05e84872014-02-28 15:41:22 -0800518 kfree(apcm);
519 }
520}
521
522#define MAX_PREALLOC_SIZE (32 * 1024 * 1024)
523
Takashi Iwai0a505752015-04-16 23:25:02 +0200524int snd_hda_attach_pcm_stream(struct hda_bus *_bus, struct hda_codec *codec,
525 struct hda_pcm *cpcm)
Dylan Reid05e84872014-02-28 15:41:22 -0800526{
Takashi Iwaia41d1222015-04-14 22:13:18 +0200527 struct hdac_bus *bus = &_bus->core;
528 struct azx *chip = bus_to_azx(bus);
Dylan Reid05e84872014-02-28 15:41:22 -0800529 struct snd_pcm *pcm;
530 struct azx_pcm *apcm;
531 int pcm_dev = cpcm->device;
532 unsigned int size;
533 int s, err;
534
535 list_for_each_entry(apcm, &chip->pcm_list, list) {
536 if (apcm->pcm->device == pcm_dev) {
537 dev_err(chip->card->dev, "PCM %d already exists\n",
538 pcm_dev);
539 return -EBUSY;
540 }
541 }
542 err = snd_pcm_new(chip->card, cpcm->name, pcm_dev,
543 cpcm->stream[SNDRV_PCM_STREAM_PLAYBACK].substreams,
544 cpcm->stream[SNDRV_PCM_STREAM_CAPTURE].substreams,
545 &pcm);
546 if (err < 0)
547 return err;
548 strlcpy(pcm->name, cpcm->name, sizeof(pcm->name));
549 apcm = kzalloc(sizeof(*apcm), GFP_KERNEL);
550 if (apcm == NULL)
551 return -ENOMEM;
552 apcm->chip = chip;
553 apcm->pcm = pcm;
554 apcm->codec = codec;
Takashi Iwai820cc6c2015-02-20 12:50:46 +0100555 apcm->info = cpcm;
Dylan Reid05e84872014-02-28 15:41:22 -0800556 pcm->private_data = apcm;
557 pcm->private_free = azx_pcm_free;
558 if (cpcm->pcm_type == HDA_PCM_TYPE_MODEM)
559 pcm->dev_class = SNDRV_PCM_CLASS_MODEM;
560 list_add_tail(&apcm->list, &chip->pcm_list);
561 cpcm->pcm = pcm;
562 for (s = 0; s < 2; s++) {
Dylan Reid05e84872014-02-28 15:41:22 -0800563 if (cpcm->stream[s].substreams)
564 snd_pcm_set_ops(pcm, s, &azx_pcm_ops);
565 }
566 /* buffer pre-allocation */
567 size = CONFIG_SND_HDA_PREALLOC_SIZE * 1024;
568 if (size > MAX_PREALLOC_SIZE)
569 size = MAX_PREALLOC_SIZE;
570 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
571 chip->card->dev,
572 size, MAX_PREALLOC_SIZE);
Dylan Reid05e84872014-02-28 15:41:22 -0800573 return 0;
574}
Dylan Reid05e84872014-02-28 15:41:22 -0800575
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800576static unsigned int azx_command_addr(u32 cmd)
577{
578 unsigned int addr = cmd >> 28;
579
580 if (addr >= AZX_MAX_CODECS) {
581 snd_BUG();
582 addr = 0;
583 }
584
585 return addr;
586}
587
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800588/* receive a response */
Takashi Iwaia41d1222015-04-14 22:13:18 +0200589static int azx_rirb_get_response(struct hdac_bus *bus, unsigned int addr,
Takashi Iwaicad372f2015-03-25 17:57:00 +0100590 unsigned int *res)
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800591{
Takashi Iwaia41d1222015-04-14 22:13:18 +0200592 struct azx *chip = bus_to_azx(bus);
593 struct hda_bus *hbus = &chip->bus;
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800594 unsigned long timeout;
595 unsigned long loopcounter;
596 int do_poll = 0;
597
598 again:
599 timeout = jiffies + msecs_to_jiffies(1000);
600
601 for (loopcounter = 0;; loopcounter++) {
Takashi Iwaia41d1222015-04-14 22:13:18 +0200602 spin_lock_irq(&bus->reg_lock);
603 if (chip->polling_mode || do_poll)
604 snd_hdac_bus_update_rirb(bus);
605 if (!bus->rirb.cmds[addr]) {
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800606 if (!do_poll)
607 chip->poll_count = 0;
Takashi Iwaicad372f2015-03-25 17:57:00 +0100608 if (res)
Takashi Iwaia41d1222015-04-14 22:13:18 +0200609 *res = bus->rirb.res[addr]; /* the last value */
610 spin_unlock_irq(&bus->reg_lock);
Takashi Iwaicad372f2015-03-25 17:57:00 +0100611 return 0;
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800612 }
Takashi Iwaia41d1222015-04-14 22:13:18 +0200613 spin_unlock_irq(&bus->reg_lock);
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800614 if (time_after(jiffies, timeout))
615 break;
Takashi Iwaia41d1222015-04-14 22:13:18 +0200616 if (hbus->needs_damn_long_delay || loopcounter > 3000)
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800617 msleep(2); /* temporary workaround */
618 else {
619 udelay(10);
620 cond_resched();
621 }
622 }
623
Takashi Iwaia41d1222015-04-14 22:13:18 +0200624 if (hbus->no_response_fallback)
Takashi Iwaicad372f2015-03-25 17:57:00 +0100625 return -EIO;
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800626
627 if (!chip->polling_mode && chip->poll_count < 2) {
628 dev_dbg(chip->card->dev,
629 "azx_get_response timeout, polling the codec once: last cmd=0x%08x\n",
Takashi Iwaia41d1222015-04-14 22:13:18 +0200630 bus->last_cmd[addr]);
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800631 do_poll = 1;
632 chip->poll_count++;
633 goto again;
634 }
635
636
637 if (!chip->polling_mode) {
638 dev_warn(chip->card->dev,
639 "azx_get_response timeout, switching to polling mode: last cmd=0x%08x\n",
Takashi Iwaia41d1222015-04-14 22:13:18 +0200640 bus->last_cmd[addr]);
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800641 chip->polling_mode = 1;
642 goto again;
643 }
644
645 if (chip->msi) {
646 dev_warn(chip->card->dev,
647 "No response from codec, disabling MSI: last cmd=0x%08x\n",
Takashi Iwaia41d1222015-04-14 22:13:18 +0200648 bus->last_cmd[addr]);
649 if (chip->ops->disable_msi_reset_irq &&
Takashi Iwaicad372f2015-03-25 17:57:00 +0100650 chip->ops->disable_msi_reset_irq(chip) < 0)
651 return -EIO;
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800652 goto again;
653 }
654
655 if (chip->probing) {
656 /* If this critical timeout happens during the codec probing
657 * phase, this is likely an access to a non-existing codec
658 * slot. Better to return an error and reset the system.
659 */
Takashi Iwaicad372f2015-03-25 17:57:00 +0100660 return -EIO;
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800661 }
662
663 /* a fatal communication error; need either to reset or to fallback
664 * to the single_cmd mode
665 */
Takashi Iwaia41d1222015-04-14 22:13:18 +0200666 if (hbus->allow_bus_reset && !hbus->response_reset && !hbus->in_reset) {
667 hbus->response_reset = 1;
Takashi Iwaicad372f2015-03-25 17:57:00 +0100668 return -EAGAIN; /* give a chance to retry */
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800669 }
670
671 dev_err(chip->card->dev,
672 "azx_get_response timeout, switching to single_cmd mode: last cmd=0x%08x\n",
Takashi Iwaia41d1222015-04-14 22:13:18 +0200673 bus->last_cmd[addr]);
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800674 chip->single_cmd = 1;
Takashi Iwaia41d1222015-04-14 22:13:18 +0200675 hbus->response_reset = 0;
676 snd_hdac_bus_stop_cmd_io(bus);
Takashi Iwaicad372f2015-03-25 17:57:00 +0100677 return -EIO;
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800678}
679
680/*
681 * Use the single immediate command instead of CORB/RIRB for simplicity
682 *
683 * Note: according to Intel, this is not preferred use. The command was
684 * intended for the BIOS only, and may get confused with unsolicited
685 * responses. So, we shouldn't use it for normal operation from the
686 * driver.
687 * I left the codes, however, for debugging/testing purposes.
688 */
689
690/* receive a response */
691static int azx_single_wait_for_response(struct azx *chip, unsigned int addr)
692{
693 int timeout = 50;
694
695 while (timeout--) {
696 /* check IRV busy bit */
Takashi Iwaifb1d8ac2014-06-26 17:54:37 +0200697 if (azx_readw(chip, IRS) & AZX_IRS_VALID) {
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800698 /* reuse rirb.res as the response return value */
Takashi Iwaia41d1222015-04-14 22:13:18 +0200699 azx_bus(chip)->rirb.res[addr] = azx_readl(chip, IR);
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800700 return 0;
701 }
702 udelay(1);
703 }
704 if (printk_ratelimit())
705 dev_dbg(chip->card->dev, "get_response timeout: IRS=0x%x\n",
706 azx_readw(chip, IRS));
Takashi Iwaia41d1222015-04-14 22:13:18 +0200707 azx_bus(chip)->rirb.res[addr] = -1;
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800708 return -EIO;
709}
710
711/* send a command */
Takashi Iwaia41d1222015-04-14 22:13:18 +0200712static int azx_single_send_cmd(struct hdac_bus *bus, u32 val)
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800713{
Takashi Iwaia41d1222015-04-14 22:13:18 +0200714 struct azx *chip = bus_to_azx(bus);
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800715 unsigned int addr = azx_command_addr(val);
716 int timeout = 50;
717
Takashi Iwaia41d1222015-04-14 22:13:18 +0200718 bus->last_cmd[azx_command_addr(val)] = val;
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800719 while (timeout--) {
720 /* check ICB busy bit */
Takashi Iwaifb1d8ac2014-06-26 17:54:37 +0200721 if (!((azx_readw(chip, IRS) & AZX_IRS_BUSY))) {
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800722 /* Clear IRV valid bit */
723 azx_writew(chip, IRS, azx_readw(chip, IRS) |
Takashi Iwaifb1d8ac2014-06-26 17:54:37 +0200724 AZX_IRS_VALID);
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800725 azx_writel(chip, IC, val);
726 azx_writew(chip, IRS, azx_readw(chip, IRS) |
Takashi Iwaifb1d8ac2014-06-26 17:54:37 +0200727 AZX_IRS_BUSY);
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800728 return azx_single_wait_for_response(chip, addr);
729 }
730 udelay(1);
731 }
732 if (printk_ratelimit())
733 dev_dbg(chip->card->dev,
734 "send_cmd timeout: IRS=0x%x, val=0x%x\n",
735 azx_readw(chip, IRS), val);
736 return -EIO;
737}
738
739/* receive a response */
Takashi Iwaia41d1222015-04-14 22:13:18 +0200740static int azx_single_get_response(struct hdac_bus *bus, unsigned int addr,
Takashi Iwaicad372f2015-03-25 17:57:00 +0100741 unsigned int *res)
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800742{
Takashi Iwaicad372f2015-03-25 17:57:00 +0100743 if (res)
Takashi Iwaia41d1222015-04-14 22:13:18 +0200744 *res = bus->rirb.res[addr];
Takashi Iwaicad372f2015-03-25 17:57:00 +0100745 return 0;
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800746}
747
748/*
749 * The below are the main callbacks from hda_codec.
750 *
751 * They are just the skeleton to call sub-callbacks according to the
752 * current setting of chip->single_cmd.
753 */
754
755/* send a command */
Takashi Iwaia41d1222015-04-14 22:13:18 +0200756static int azx_send_cmd(struct hdac_bus *bus, unsigned int val)
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800757{
Takashi Iwaia41d1222015-04-14 22:13:18 +0200758 struct azx *chip = bus_to_azx(bus);
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800759
760 if (chip->disabled)
761 return 0;
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800762 if (chip->single_cmd)
763 return azx_single_send_cmd(bus, val);
764 else
Takashi Iwaia41d1222015-04-14 22:13:18 +0200765 return snd_hdac_bus_send_cmd(bus, val);
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800766}
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800767
768/* get a response */
Takashi Iwaia41d1222015-04-14 22:13:18 +0200769static int azx_get_response(struct hdac_bus *bus, unsigned int addr,
Takashi Iwaicad372f2015-03-25 17:57:00 +0100770 unsigned int *res)
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800771{
Takashi Iwaia41d1222015-04-14 22:13:18 +0200772 struct azx *chip = bus_to_azx(bus);
773
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800774 if (chip->disabled)
775 return 0;
776 if (chip->single_cmd)
Takashi Iwaicad372f2015-03-25 17:57:00 +0100777 return azx_single_get_response(bus, addr, res);
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800778 else
Takashi Iwaicad372f2015-03-25 17:57:00 +0100779 return azx_rirb_get_response(bus, addr, res);
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800780}
Dylan Reid6e85ddd2014-02-28 15:41:25 -0800781
Mengdong Lin17eccb22015-04-29 17:43:29 +0800782static int azx_link_power(struct hdac_bus *bus, bool enable)
783{
784 struct azx *chip = bus_to_azx(bus);
785
786 if (chip->ops->link_power)
787 return chip->ops->link_power(chip, enable);
788 else
789 return -EINVAL;
790}
791
Takashi Iwai7e8be1b2015-04-14 16:55:31 +0200792static const struct hdac_bus_ops bus_core_ops = {
793 .command = azx_send_cmd,
794 .get_response = azx_get_response,
Mengdong Lin17eccb22015-04-29 17:43:29 +0800795 .link_power = azx_link_power,
Takashi Iwai7e8be1b2015-04-14 16:55:31 +0200796};
797
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800798#ifdef CONFIG_SND_HDA_DSP_LOADER
799/*
800 * DSP loading code (e.g. for CA0132)
801 */
802
803/* use the first stream for loading DSP */
804static struct azx_dev *
805azx_get_dsp_loader_dev(struct azx *chip)
806{
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200807 struct hdac_bus *bus = azx_bus(chip);
808 struct hdac_stream *s;
809
810 list_for_each_entry(s, &bus->stream_list, list)
811 if (s->index == chip->playback_index_offset)
812 return stream_to_azx_dev(s);
813
814 return NULL;
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800815}
816
Takashi Iwai0a505752015-04-16 23:25:02 +0200817int snd_hda_codec_load_dsp_prepare(struct hda_codec *codec, unsigned int format,
818 unsigned int byte_size,
819 struct snd_dma_buffer *bufp)
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800820{
Takashi Iwai0a505752015-04-16 23:25:02 +0200821 struct hdac_bus *bus = &codec->bus->core;
Takashi Iwaia41d1222015-04-14 22:13:18 +0200822 struct azx *chip = bus_to_azx(bus);
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800823 struct azx_dev *azx_dev;
Takashi Iwaiccc98862015-04-14 22:06:53 +0200824 struct hdac_stream *hstr;
825 bool saved = false;
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800826 int err;
827
828 azx_dev = azx_get_dsp_loader_dev(chip);
Takashi Iwaiccc98862015-04-14 22:06:53 +0200829 hstr = azx_stream(azx_dev);
Takashi Iwaia41d1222015-04-14 22:13:18 +0200830 spin_lock_irq(&bus->reg_lock);
Takashi Iwaiccc98862015-04-14 22:06:53 +0200831 if (hstr->opened) {
832 chip->saved_azx_dev = *azx_dev;
833 saved = true;
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800834 }
Takashi Iwaia41d1222015-04-14 22:13:18 +0200835 spin_unlock_irq(&bus->reg_lock);
Takashi Iwaiccc98862015-04-14 22:06:53 +0200836
837 err = snd_hdac_dsp_prepare(hstr, format, byte_size, bufp);
838 if (err < 0) {
Takashi Iwaia41d1222015-04-14 22:13:18 +0200839 spin_lock_irq(&bus->reg_lock);
Takashi Iwaiccc98862015-04-14 22:06:53 +0200840 if (saved)
841 *azx_dev = chip->saved_azx_dev;
Takashi Iwaia41d1222015-04-14 22:13:18 +0200842 spin_unlock_irq(&bus->reg_lock);
Takashi Iwaiccc98862015-04-14 22:06:53 +0200843 return err;
844 }
845
Takashi Iwai6d23c8f2015-04-17 13:34:30 +0200846 hstr->prepared = 0;
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800847 return err;
848}
Takashi Iwai0a505752015-04-16 23:25:02 +0200849EXPORT_SYMBOL_GPL(snd_hda_codec_load_dsp_prepare);
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800850
Takashi Iwai0a505752015-04-16 23:25:02 +0200851void snd_hda_codec_load_dsp_trigger(struct hda_codec *codec, bool start)
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800852{
Takashi Iwai0a505752015-04-16 23:25:02 +0200853 struct hdac_bus *bus = &codec->bus->core;
Takashi Iwaia41d1222015-04-14 22:13:18 +0200854 struct azx *chip = bus_to_azx(bus);
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800855 struct azx_dev *azx_dev = azx_get_dsp_loader_dev(chip);
856
Takashi Iwaiccc98862015-04-14 22:06:53 +0200857 snd_hdac_dsp_trigger(azx_stream(azx_dev), start);
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800858}
Takashi Iwai0a505752015-04-16 23:25:02 +0200859EXPORT_SYMBOL_GPL(snd_hda_codec_load_dsp_trigger);
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800860
Takashi Iwai0a505752015-04-16 23:25:02 +0200861void snd_hda_codec_load_dsp_cleanup(struct hda_codec *codec,
862 struct snd_dma_buffer *dmab)
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800863{
Takashi Iwai0a505752015-04-16 23:25:02 +0200864 struct hdac_bus *bus = &codec->bus->core;
Takashi Iwaia41d1222015-04-14 22:13:18 +0200865 struct azx *chip = bus_to_azx(bus);
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800866 struct azx_dev *azx_dev = azx_get_dsp_loader_dev(chip);
Takashi Iwaiccc98862015-04-14 22:06:53 +0200867 struct hdac_stream *hstr = azx_stream(azx_dev);
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800868
Takashi Iwai0a505752015-04-16 23:25:02 +0200869 if (!dmab->area || !hstr->locked)
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800870 return;
871
Takashi Iwaiccc98862015-04-14 22:06:53 +0200872 snd_hdac_dsp_cleanup(hstr, dmab);
Takashi Iwaia41d1222015-04-14 22:13:18 +0200873 spin_lock_irq(&bus->reg_lock);
Takashi Iwaiccc98862015-04-14 22:06:53 +0200874 if (hstr->opened)
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800875 *azx_dev = chip->saved_azx_dev;
Takashi Iwaiccc98862015-04-14 22:06:53 +0200876 hstr->locked = false;
Takashi Iwaia41d1222015-04-14 22:13:18 +0200877 spin_unlock_irq(&bus->reg_lock);
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800878}
Takashi Iwai0a505752015-04-16 23:25:02 +0200879EXPORT_SYMBOL_GPL(snd_hda_codec_load_dsp_cleanup);
Dylan Reid2b5fd6c2014-02-28 15:41:24 -0800880#endif /* CONFIG_SND_HDA_DSP_LOADER */
881
Dylan Reidf43923f2014-02-28 15:41:27 -0800882/*
883 * reset and start the controller registers
884 */
Thierry Reding17c3ad02014-04-09 12:30:57 +0200885void azx_init_chip(struct azx *chip, bool full_reset)
Dylan Reidf43923f2014-02-28 15:41:27 -0800886{
Takashi Iwaia41d1222015-04-14 22:13:18 +0200887 if (snd_hdac_bus_init_chip(azx_bus(chip), full_reset)) {
888 /* correct RINTCNT for CXT */
889 if (chip->driver_caps & AZX_DCAPS_CTX_WORKAROUND)
890 azx_writew(chip, RINTCNT, 0xc0);
891 }
Dylan Reidf43923f2014-02-28 15:41:27 -0800892}
893EXPORT_SYMBOL_GPL(azx_init_chip);
894
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200895void azx_stop_all_streams(struct azx *chip)
896{
897 struct hdac_bus *bus = azx_bus(chip);
898 struct hdac_stream *s;
899
900 list_for_each_entry(s, &bus->stream_list, list)
901 snd_hdac_stream_stop(s);
902}
903EXPORT_SYMBOL_GPL(azx_stop_all_streams);
904
Dylan Reidf43923f2014-02-28 15:41:27 -0800905void azx_stop_chip(struct azx *chip)
906{
Takashi Iwaia41d1222015-04-14 22:13:18 +0200907 snd_hdac_bus_stop_chip(azx_bus(chip));
Dylan Reidf43923f2014-02-28 15:41:27 -0800908}
Dylan Reid154867c2014-02-28 15:41:30 -0800909EXPORT_SYMBOL_GPL(azx_stop_chip);
Dylan Reidf43923f2014-02-28 15:41:27 -0800910
Dylan Reidf0b1df82014-02-28 15:41:29 -0800911/*
912 * interrupt handler
913 */
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200914static void stream_update(struct hdac_bus *bus, struct hdac_stream *s)
915{
Takashi Iwaia41d1222015-04-14 22:13:18 +0200916 struct azx *chip = bus_to_azx(bus);
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200917 struct azx_dev *azx_dev = stream_to_azx_dev(s);
918
919 /* check whether this IRQ is really acceptable */
920 if (!chip->ops->position_check ||
921 chip->ops->position_check(chip, azx_dev)) {
Takashi Iwaia41d1222015-04-14 22:13:18 +0200922 spin_unlock(&bus->reg_lock);
923 snd_pcm_period_elapsed(azx_stream(azx_dev)->substream);
924 spin_lock(&bus->reg_lock);
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200925 }
926}
927
Dylan Reidf0b1df82014-02-28 15:41:29 -0800928irqreturn_t azx_interrupt(int irq, void *dev_id)
929{
930 struct azx *chip = dev_id;
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200931 struct hdac_bus *bus = azx_bus(chip);
Dylan Reidf0b1df82014-02-28 15:41:29 -0800932 u32 status;
Takashi Iwai473f4142016-02-23 15:54:47 +0100933 bool active, handled = false;
934 int repeat = 0; /* count for avoiding endless loop */
Dylan Reidf0b1df82014-02-28 15:41:29 -0800935
Rafael J. Wysocki641d3342014-12-13 00:42:18 +0100936#ifdef CONFIG_PM
Takashi Iwai364aa712015-02-19 16:51:17 +0100937 if (azx_has_pm_runtime(chip))
Dylan Reid7b0a48f2014-04-08 12:06:18 -0700938 if (!pm_runtime_active(chip->card->dev))
Dylan Reidf0b1df82014-02-28 15:41:29 -0800939 return IRQ_NONE;
940#endif
941
Takashi Iwaia41d1222015-04-14 22:13:18 +0200942 spin_lock(&bus->reg_lock);
Dylan Reidf0b1df82014-02-28 15:41:29 -0800943
Takashi Iwai473f4142016-02-23 15:54:47 +0100944 if (chip->disabled)
945 goto unlock;
Dylan Reidf0b1df82014-02-28 15:41:29 -0800946
Takashi Iwai473f4142016-02-23 15:54:47 +0100947 do {
948 status = azx_readl(chip, INTSTS);
949 if (status == 0 || status == 0xffffffff)
950 break;
Dylan Reidf0b1df82014-02-28 15:41:29 -0800951
Takashi Iwai473f4142016-02-23 15:54:47 +0100952 handled = true;
953 active = false;
954 if (snd_hdac_bus_handle_stream_irq(bus, status, stream_update))
955 active = true;
Dylan Reidf0b1df82014-02-28 15:41:29 -0800956
Takashi Iwai473f4142016-02-23 15:54:47 +0100957 /* clear rirb int */
958 status = azx_readb(chip, RIRBSTS);
959 if (status & RIRB_INT_MASK) {
960 active = true;
961 if (status & RIRB_INT_RESPONSE) {
962 if (chip->driver_caps & AZX_DCAPS_CTX_WORKAROUND)
963 udelay(80);
964 snd_hdac_bus_update_rirb(bus);
965 }
966 azx_writeb(chip, RIRBSTS, RIRB_INT_MASK);
Dylan Reidf0b1df82014-02-28 15:41:29 -0800967 }
Takashi Iwai473f4142016-02-23 15:54:47 +0100968 } while (active && ++repeat < 10);
Dylan Reidf0b1df82014-02-28 15:41:29 -0800969
Takashi Iwai473f4142016-02-23 15:54:47 +0100970 unlock:
Takashi Iwaia41d1222015-04-14 22:13:18 +0200971 spin_unlock(&bus->reg_lock);
Dylan Reidf0b1df82014-02-28 15:41:29 -0800972
Takashi Iwai473f4142016-02-23 15:54:47 +0100973 return IRQ_RETVAL(handled);
Dylan Reidf0b1df82014-02-28 15:41:29 -0800974}
975EXPORT_SYMBOL_GPL(azx_interrupt);
976
Dylan Reid154867c2014-02-28 15:41:30 -0800977/*
978 * Codec initerface
979 */
980
981/*
982 * Probe the given codec address
983 */
984static int probe_codec(struct azx *chip, int addr)
985{
986 unsigned int cmd = (addr << 28) | (AC_NODE_ROOT << 20) |
987 (AC_VERB_PARAMETERS << 8) | AC_PAR_VENDOR_ID;
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200988 struct hdac_bus *bus = azx_bus(chip);
Takashi Iwaicad372f2015-03-25 17:57:00 +0100989 int err;
Takashi Iwaia41d1222015-04-14 22:13:18 +0200990 unsigned int res = -1;
Dylan Reid154867c2014-02-28 15:41:30 -0800991
Takashi Iwai7e8be1b2015-04-14 16:55:31 +0200992 mutex_lock(&bus->cmd_mutex);
Dylan Reid154867c2014-02-28 15:41:30 -0800993 chip->probing = 1;
Takashi Iwai7e8be1b2015-04-14 16:55:31 +0200994 azx_send_cmd(bus, cmd);
995 err = azx_get_response(bus, addr, &res);
Dylan Reid154867c2014-02-28 15:41:30 -0800996 chip->probing = 0;
Takashi Iwai7e8be1b2015-04-14 16:55:31 +0200997 mutex_unlock(&bus->cmd_mutex);
Takashi Iwaicad372f2015-03-25 17:57:00 +0100998 if (err < 0 || res == -1)
Dylan Reid154867c2014-02-28 15:41:30 -0800999 return -EIO;
1000 dev_dbg(chip->card->dev, "codec #%d probed OK\n", addr);
1001 return 0;
1002}
1003
Takashi Iwai0a505752015-04-16 23:25:02 +02001004void snd_hda_bus_reset(struct hda_bus *bus)
Dylan Reid154867c2014-02-28 15:41:30 -08001005{
Takashi Iwaia41d1222015-04-14 22:13:18 +02001006 struct azx *chip = bus_to_azx(&bus->core);
Dylan Reid154867c2014-02-28 15:41:30 -08001007
1008 bus->in_reset = 1;
1009 azx_stop_chip(chip);
Thierry Reding17c3ad02014-04-09 12:30:57 +02001010 azx_init_chip(chip, true);
Takashi Iwaia41d1222015-04-14 22:13:18 +02001011 if (bus->core.chip_init)
Takashi Iwai0a505752015-04-16 23:25:02 +02001012 snd_hda_bus_reset_codecs(bus);
Dylan Reid154867c2014-02-28 15:41:30 -08001013 bus->in_reset = 0;
1014}
1015
Dylan Reid154867c2014-02-28 15:41:30 -08001016static int get_jackpoll_interval(struct azx *chip)
1017{
1018 int i;
1019 unsigned int j;
1020
1021 if (!chip->jackpoll_ms)
1022 return 0;
1023
1024 i = chip->jackpoll_ms[chip->dev_index];
1025 if (i == 0)
1026 return 0;
1027 if (i < 50 || i > 60000)
1028 j = 0;
1029 else
1030 j = msecs_to_jiffies(i);
1031 if (j == 0)
1032 dev_warn(chip->card->dev,
1033 "jackpoll_ms value out of range: %d\n", i);
1034 return j;
1035}
1036
Takashi Iwai96d2bd62015-02-19 18:12:22 +01001037/* HD-audio bus initialization */
Takashi Iwaia41d1222015-04-14 22:13:18 +02001038int azx_bus_init(struct azx *chip, const char *model,
1039 const struct hdac_io_ops *io_ops)
Dylan Reid154867c2014-02-28 15:41:30 -08001040{
Takashi Iwaia41d1222015-04-14 22:13:18 +02001041 struct hda_bus *bus = &chip->bus;
Takashi Iwai96d2bd62015-02-19 18:12:22 +01001042 int err;
Dylan Reid154867c2014-02-28 15:41:30 -08001043
Takashi Iwaia41d1222015-04-14 22:13:18 +02001044 err = snd_hdac_bus_init(&bus->core, chip->card->dev, &bus_core_ops,
1045 io_ops);
Dylan Reid154867c2014-02-28 15:41:30 -08001046 if (err < 0)
1047 return err;
1048
Takashi Iwaia41d1222015-04-14 22:13:18 +02001049 bus->card = chip->card;
1050 mutex_init(&bus->prepare_mutex);
Takashi Iwaief744972015-02-17 13:56:29 +01001051 bus->pci = chip->pci;
1052 bus->modelname = model;
Takashi Iwai2f0eaad2015-10-17 18:25:38 +02001053 bus->mixer_assigned = -1;
Takashi Iwaiccc98862015-04-14 22:06:53 +02001054 bus->core.snoop = azx_snoop(chip);
1055 if (chip->get_position[0] != azx_get_pos_lpib ||
1056 chip->get_position[1] != azx_get_pos_lpib)
1057 bus->core.use_posbuf = true;
Takashi Iwai4f0189b2015-12-10 16:44:08 +01001058 bus->core.bdl_pos_adj = chip->bdl_pos_adj;
Takashi Iwaia41d1222015-04-14 22:13:18 +02001059 if (chip->driver_caps & AZX_DCAPS_CORBRP_SELF_CLEAR)
1060 bus->core.corbrp_self_clear = true;
Takashi Iwaief744972015-02-17 13:56:29 +01001061
Takashi Iwaide1ab6a2015-11-02 17:35:34 +01001062 if (chip->driver_caps & AZX_DCAPS_4K_BDLE_BOUNDARY)
1063 bus->core.align_bdle_4k = true;
1064
Takashi Iwai96d2bd62015-02-19 18:12:22 +01001065 /* AMD chipsets often cause the communication stalls upon certain
1066 * sequence like the pin-detection. It seems that forcing the synced
1067 * access works around the stall. Grrr...
1068 */
1069 if (chip->driver_caps & AZX_DCAPS_SYNC_WRITE) {
1070 dev_dbg(chip->card->dev, "Enable sync_write for stable communication\n");
Takashi Iwaid068ebc2015-03-02 23:22:59 +01001071 bus->core.sync_write = 1;
Takashi Iwai96d2bd62015-02-19 18:12:22 +01001072 bus->allow_bus_reset = 1;
1073 }
1074
1075 return 0;
1076}
Takashi Iwaia41d1222015-04-14 22:13:18 +02001077EXPORT_SYMBOL_GPL(azx_bus_init);
Takashi Iwai96d2bd62015-02-19 18:12:22 +01001078
1079/* Probe codecs */
1080int azx_probe_codecs(struct azx *chip, unsigned int max_slots)
1081{
Takashi Iwaia41d1222015-04-14 22:13:18 +02001082 struct hdac_bus *bus = azx_bus(chip);
Takashi Iwai96d2bd62015-02-19 18:12:22 +01001083 int c, codecs, err;
1084
Dylan Reid154867c2014-02-28 15:41:30 -08001085 codecs = 0;
1086 if (!max_slots)
1087 max_slots = AZX_DEFAULT_CODECS;
1088
1089 /* First try to probe all given codec slots */
1090 for (c = 0; c < max_slots; c++) {
Takashi Iwaia41d1222015-04-14 22:13:18 +02001091 if ((bus->codec_mask & (1 << c)) & chip->codec_probe_mask) {
Dylan Reid154867c2014-02-28 15:41:30 -08001092 if (probe_codec(chip, c) < 0) {
1093 /* Some BIOSen give you wrong codec addresses
1094 * that don't exist
1095 */
1096 dev_warn(chip->card->dev,
1097 "Codec #%d probe error; disabling it...\n", c);
Takashi Iwaia41d1222015-04-14 22:13:18 +02001098 bus->codec_mask &= ~(1 << c);
Dylan Reid154867c2014-02-28 15:41:30 -08001099 /* More badly, accessing to a non-existing
1100 * codec often screws up the controller chip,
1101 * and disturbs the further communications.
1102 * Thus if an error occurs during probing,
1103 * better to reset the controller chip to
1104 * get back to the sanity state.
1105 */
1106 azx_stop_chip(chip);
Thierry Reding17c3ad02014-04-09 12:30:57 +02001107 azx_init_chip(chip, true);
Dylan Reid154867c2014-02-28 15:41:30 -08001108 }
1109 }
1110 }
1111
Dylan Reid154867c2014-02-28 15:41:30 -08001112 /* Then create codec instances */
1113 for (c = 0; c < max_slots; c++) {
Takashi Iwaia41d1222015-04-14 22:13:18 +02001114 if ((bus->codec_mask & (1 << c)) & chip->codec_probe_mask) {
Dylan Reid154867c2014-02-28 15:41:30 -08001115 struct hda_codec *codec;
Takashi Iwaia41d1222015-04-14 22:13:18 +02001116 err = snd_hda_codec_new(&chip->bus, chip->card, c, &codec);
Dylan Reid154867c2014-02-28 15:41:30 -08001117 if (err < 0)
1118 continue;
1119 codec->jackpoll_interval = get_jackpoll_interval(chip);
1120 codec->beep_mode = chip->beep_mode;
1121 codecs++;
1122 }
1123 }
1124 if (!codecs) {
1125 dev_err(chip->card->dev, "no codecs initialized\n");
1126 return -ENXIO;
1127 }
1128 return 0;
1129}
Takashi Iwai96d2bd62015-02-19 18:12:22 +01001130EXPORT_SYMBOL_GPL(azx_probe_codecs);
Dylan Reid154867c2014-02-28 15:41:30 -08001131
1132/* configure each codec instance */
1133int azx_codec_configure(struct azx *chip)
1134{
1135 struct hda_codec *codec;
Takashi Iwaia41d1222015-04-14 22:13:18 +02001136 list_for_each_codec(codec, &chip->bus) {
Dylan Reid154867c2014-02-28 15:41:30 -08001137 snd_hda_codec_configure(codec);
1138 }
1139 return 0;
1140}
1141EXPORT_SYMBOL_GPL(azx_codec_configure);
1142
Takashi Iwai7833c3f2015-04-14 18:13:13 +02001143static int stream_direction(struct azx *chip, unsigned char index)
Rafal Redzimski93e34232014-12-19 08:44:30 +08001144{
Takashi Iwai7833c3f2015-04-14 18:13:13 +02001145 if (index >= chip->capture_index_offset &&
1146 index < chip->capture_index_offset + chip->capture_streams)
1147 return SNDRV_PCM_STREAM_CAPTURE;
1148 return SNDRV_PCM_STREAM_PLAYBACK;
Rafal Redzimski93e34232014-12-19 08:44:30 +08001149}
1150
Dylan Reid154867c2014-02-28 15:41:30 -08001151/* initialize SD streams */
Takashi Iwaia41d1222015-04-14 22:13:18 +02001152int azx_init_streams(struct azx *chip)
Dylan Reid154867c2014-02-28 15:41:30 -08001153{
1154 int i;
Takashi Iwai7833c3f2015-04-14 18:13:13 +02001155 int stream_tags[2] = { 0, 0 };
Dylan Reid154867c2014-02-28 15:41:30 -08001156
1157 /* initialize each stream (aka device)
1158 * assign the starting bdl address to each stream (device)
1159 * and initialize
1160 */
1161 for (i = 0; i < chip->num_streams; i++) {
Takashi Iwai7833c3f2015-04-14 18:13:13 +02001162 struct azx_dev *azx_dev = kzalloc(sizeof(*azx_dev), GFP_KERNEL);
1163 int dir, tag;
Rafal Redzimski93e34232014-12-19 08:44:30 +08001164
Takashi Iwai7833c3f2015-04-14 18:13:13 +02001165 if (!azx_dev)
1166 return -ENOMEM;
1167
1168 dir = stream_direction(chip, i);
Rafal Redzimski93e34232014-12-19 08:44:30 +08001169 /* stream tag must be unique throughout
1170 * the stream direction group,
1171 * valid values 1...15
1172 * use separate stream tag if the flag
1173 * AZX_DCAPS_SEPARATE_STREAM_TAG is used
1174 */
1175 if (chip->driver_caps & AZX_DCAPS_SEPARATE_STREAM_TAG)
Takashi Iwai7833c3f2015-04-14 18:13:13 +02001176 tag = ++stream_tags[dir];
Rafal Redzimski93e34232014-12-19 08:44:30 +08001177 else
Takashi Iwai7833c3f2015-04-14 18:13:13 +02001178 tag = i + 1;
1179 snd_hdac_stream_init(azx_bus(chip), azx_stream(azx_dev),
1180 i, dir, tag);
Dylan Reid154867c2014-02-28 15:41:30 -08001181 }
1182
1183 return 0;
1184}
Takashi Iwaia41d1222015-04-14 22:13:18 +02001185EXPORT_SYMBOL_GPL(azx_init_streams);
1186
1187void azx_free_streams(struct azx *chip)
1188{
1189 struct hdac_bus *bus = azx_bus(chip);
1190 struct hdac_stream *s;
1191
1192 while (!list_empty(&bus->stream_list)) {
1193 s = list_first_entry(&bus->stream_list, struct hdac_stream, list);
1194 list_del(&s->list);
1195 kfree(stream_to_azx_dev(s));
1196 }
1197}
1198EXPORT_SYMBOL_GPL(azx_free_streams);