1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * hdac-ext-controller.c - HD-audio extended controller functions.
4 *
5 * Copyright (C) 2014-2015 Intel Corp
6 * Author: Jeeja KP <jeeja.kp@intel.com>
7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8 *
9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10 */
11
12#include <linux/bitfield.h>
13#include <linux/delay.h>
14#include <linux/slab.h>
15#include <sound/hda_register.h>
16#include <sound/hdaudio_ext.h>
17
18/*
19 * processing pipe helpers - these helpers are useful for dealing with HDA
20 * new capability of processing pipelines
21 */
22
23/**
24 * snd_hdac_ext_bus_ppcap_enable - enable/disable processing pipe capability
25 * @bus: the pointer to HDAC bus object
26 * @enable: flag to turn on/off the capability
27 */
28void snd_hdac_ext_bus_ppcap_enable(struct hdac_bus *bus, bool enable)
29{
30
31 if (!bus->ppcap) {
32 dev_err(bus->dev, "Address of PP capability is NULL");
33 return;
34 }
35
36 if (enable)
37 snd_hdac_updatel(bus->ppcap, AZX_REG_PP_PPCTL,
38 AZX_PPCTL_GPROCEN, AZX_PPCTL_GPROCEN);
39 else
40 snd_hdac_updatel(bus->ppcap, AZX_REG_PP_PPCTL,
41 AZX_PPCTL_GPROCEN, 0);
42}
43EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_ppcap_enable);
44
45/**
46 * snd_hdac_ext_bus_ppcap_int_enable - ppcap interrupt enable/disable
47 * @bus: the pointer to HDAC bus object
48 * @enable: flag to enable/disable interrupt
49 */
50void snd_hdac_ext_bus_ppcap_int_enable(struct hdac_bus *bus, bool enable)
51{
52
53 if (!bus->ppcap) {
54 dev_err(bus->dev, "Address of PP capability is NULL\n");
55 return;
56 }
57
58 if (enable)
59 snd_hdac_updatel(bus->ppcap, AZX_REG_PP_PPCTL,
60 AZX_PPCTL_PIE, AZX_PPCTL_PIE);
61 else
62 snd_hdac_updatel(bus->ppcap, AZX_REG_PP_PPCTL,
63 AZX_PPCTL_PIE, 0);
64}
65EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_ppcap_int_enable);
66
67/*
68 * Multilink helpers - these helpers are useful for dealing with HDA
69 * new multilink capability
70 */
71
72/**
73 * snd_hdac_ext_bus_get_ml_capabilities - get multilink capability
74 * @bus: the pointer to HDAC bus object
75 *
76 * This will parse all links and read the mlink capabilities and add them
77 * in hlink_list of extended hdac bus
78 * Note: this will be freed on bus exit by driver
79 */
80int snd_hdac_ext_bus_get_ml_capabilities(struct hdac_bus *bus)
81{
82 int idx;
83 u32 link_count;
84 struct hdac_ext_link *hlink;
85 u32 leptr;
86
87 link_count = readl(addr: bus->mlcap + AZX_REG_ML_MLCD) + 1;
88
89 dev_dbg(bus->dev, "In %s Link count: %d\n", __func__, link_count);
90
91 for (idx = 0; idx < link_count; idx++) {
92 hlink = kzalloc(sizeof(*hlink), GFP_KERNEL);
93 if (!hlink)
94 return -ENOMEM;
95 hlink->index = idx;
96 hlink->bus = bus;
97 hlink->ml_addr = bus->mlcap + AZX_ML_BASE +
98 (AZX_ML_INTERVAL * idx);
99 hlink->lcaps = readl(addr: hlink->ml_addr + AZX_REG_ML_LCAP);
100 hlink->lsdiid = readw(addr: hlink->ml_addr + AZX_REG_ML_LSDIID);
101 hlink->slcount = FIELD_GET(AZX_ML_HDA_LCAP_SLCOUNT, hlink->lcaps) + 1;
102
103 if (hdac_ext_link_alt(hlink)) {
104 leptr = readl(addr: hlink->ml_addr + AZX_REG_ML_LEPTR);
105 hlink->id = FIELD_GET(AZX_REG_ML_LEPTR_ID, leptr);
106 }
107
108 /* since link in On, update the ref */
109 hlink->ref_count = 1;
110
111 list_add_tail(new: &hlink->list, head: &bus->hlink_list);
112 }
113
114 return 0;
115}
116EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_get_ml_capabilities);
117
118/**
119 * snd_hdac_ext_link_free_all- free hdac extended link objects
120 *
121 * @bus: the pointer to HDAC bus object
122 */
123
124void snd_hdac_ext_link_free_all(struct hdac_bus *bus)
125{
126 struct hdac_ext_link *hlink;
127
128 while (!list_empty(head: &bus->hlink_list)) {
129 hlink = list_first_entry(&bus->hlink_list, struct hdac_ext_link, list);
130 list_del(entry: &hlink->list);
131 kfree(objp: hlink);
132 }
133}
134EXPORT_SYMBOL_GPL(snd_hdac_ext_link_free_all);
135
136struct hdac_ext_link *snd_hdac_ext_bus_get_hlink_by_id(struct hdac_bus *bus, u32 id)
137{
138 struct hdac_ext_link *hlink;
139
140 list_for_each_entry(hlink, &bus->hlink_list, list)
141 if (hdac_ext_link_alt(hlink) && hlink->id == id)
142 return hlink;
143 return NULL;
144}
145EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_get_hlink_by_id);
146
147/**
148 * snd_hdac_ext_bus_get_hlink_by_addr - get hlink at specified address
149 * @bus: hlink's parent bus device
150 * @addr: codec device address
151 *
152 * Returns hlink object or NULL if matching hlink is not found.
153 */
154struct hdac_ext_link *snd_hdac_ext_bus_get_hlink_by_addr(struct hdac_bus *bus, int addr)
155{
156 struct hdac_ext_link *hlink;
157
158 list_for_each_entry(hlink, &bus->hlink_list, list)
159 if (hlink->lsdiid & (0x1 << addr))
160 return hlink;
161 return NULL;
162}
163EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_get_hlink_by_addr);
164
165/**
166 * snd_hdac_ext_bus_get_hlink_by_name - get hlink based on codec name
167 * @bus: the pointer to HDAC bus object
168 * @codec_name: codec name
169 */
170struct hdac_ext_link *snd_hdac_ext_bus_get_hlink_by_name(struct hdac_bus *bus,
171 const char *codec_name)
172{
173 int bus_idx, addr;
174
175 if (sscanf(codec_name, "ehdaudio%dD%d", &bus_idx, &addr) != 2)
176 return NULL;
177 if (bus->idx != bus_idx)
178 return NULL;
179 if (addr < 0 || addr > 31)
180 return NULL;
181
182 return snd_hdac_ext_bus_get_hlink_by_addr(bus, addr);
183}
184EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_get_hlink_by_name);
185
186static int check_hdac_link_power_active(struct hdac_ext_link *hlink, bool enable)
187{
188 int timeout;
189 u32 val;
190 int mask = (1 << AZX_ML_LCTL_CPA_SHIFT);
191
192 udelay(usec: 3);
193 timeout = 150;
194
195 do {
196 val = readl(addr: hlink->ml_addr + AZX_REG_ML_LCTL);
197 if (enable) {
198 if (((val & mask) >> AZX_ML_LCTL_CPA_SHIFT))
199 return 0;
200 } else {
201 if (!((val & mask) >> AZX_ML_LCTL_CPA_SHIFT))
202 return 0;
203 }
204 udelay(usec: 3);
205 } while (--timeout);
206
207 return -EIO;
208}
209
210/**
211 * snd_hdac_ext_bus_link_power_up -power up hda link
212 * @hlink: HD-audio extended link
213 */
214int snd_hdac_ext_bus_link_power_up(struct hdac_ext_link *hlink)
215{
216 snd_hdac_updatel(hlink->ml_addr, AZX_REG_ML_LCTL,
217 AZX_ML_LCTL_SPA, AZX_ML_LCTL_SPA);
218
219 return check_hdac_link_power_active(hlink, enable: true);
220}
221EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_power_up);
222
223/**
224 * snd_hdac_ext_bus_link_power_down -power down hda link
225 * @hlink: HD-audio extended link
226 */
227int snd_hdac_ext_bus_link_power_down(struct hdac_ext_link *hlink)
228{
229 snd_hdac_updatel(hlink->ml_addr, AZX_REG_ML_LCTL, AZX_ML_LCTL_SPA, 0);
230
231 return check_hdac_link_power_active(hlink, enable: false);
232}
233EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_power_down);
234
235/**
236 * snd_hdac_ext_bus_link_power_up_all -power up all hda link
237 * @bus: the pointer to HDAC bus object
238 */
239int snd_hdac_ext_bus_link_power_up_all(struct hdac_bus *bus)
240{
241 struct hdac_ext_link *hlink = NULL;
242 int ret;
243
244 list_for_each_entry(hlink, &bus->hlink_list, list) {
245 ret = snd_hdac_ext_bus_link_power_up(hlink);
246 if (ret < 0)
247 return ret;
248 }
249
250 return 0;
251}
252EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_power_up_all);
253
254/**
255 * snd_hdac_ext_bus_link_power_down_all -power down all hda link
256 * @bus: the pointer to HDAC bus object
257 */
258int snd_hdac_ext_bus_link_power_down_all(struct hdac_bus *bus)
259{
260 struct hdac_ext_link *hlink = NULL;
261 int ret;
262
263 list_for_each_entry(hlink, &bus->hlink_list, list) {
264 ret = snd_hdac_ext_bus_link_power_down(hlink);
265 if (ret < 0)
266 return ret;
267 }
268
269 return 0;
270}
271EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_power_down_all);
272
273/**
274 * snd_hdac_ext_bus_link_set_stream_id - maps stream id to link output
275 * @link: HD-audio ext link to set up
276 * @stream: stream id
277 */
278void snd_hdac_ext_bus_link_set_stream_id(struct hdac_ext_link *link,
279 int stream)
280{
281 snd_hdac_updatew(link->ml_addr, AZX_REG_ML_LOSIDV, (1 << stream), 1 << stream);
282}
283EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_set_stream_id);
284
285/**
286 * snd_hdac_ext_bus_link_clear_stream_id - maps stream id to link output
287 * @link: HD-audio ext link to set up
288 * @stream: stream id
289 */
290void snd_hdac_ext_bus_link_clear_stream_id(struct hdac_ext_link *link,
291 int stream)
292{
293 snd_hdac_updatew(link->ml_addr, AZX_REG_ML_LOSIDV, (1 << stream), 0);
294}
295EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_clear_stream_id);
296
297int snd_hdac_ext_bus_link_get(struct hdac_bus *bus,
298 struct hdac_ext_link *hlink)
299{
300 unsigned long codec_mask;
301 int ret = 0;
302
303 mutex_lock(&bus->lock);
304
305 /*
306 * if we move from 0 to 1, count will be 1 so power up this link
307 * as well, also check the dma status and trigger that
308 */
309 if (++hlink->ref_count == 1) {
310 if (!bus->cmd_dma_state) {
311 snd_hdac_bus_init_cmd_io(bus);
312 bus->cmd_dma_state = true;
313 }
314
315 ret = snd_hdac_ext_bus_link_power_up(hlink);
316
317 /*
318 * clear the register to invalidate all the output streams
319 */
320 snd_hdac_updatew(hlink->ml_addr, AZX_REG_ML_LOSIDV,
321 AZX_ML_LOSIDV_STREAM_MASK, 0);
322 /*
323 * wait for 521usec for codec to report status
324 * HDA spec section 4.3 - Codec Discovery
325 */
326 udelay(usec: 521);
327 codec_mask = snd_hdac_chip_readw(bus, STATESTS);
328 dev_dbg(bus->dev, "codec_mask = 0x%lx\n", codec_mask);
329 snd_hdac_chip_writew(bus, STATESTS, codec_mask);
330 if (!bus->codec_mask)
331 bus->codec_mask = codec_mask;
332 }
333
334 mutex_unlock(lock: &bus->lock);
335 return ret;
336}
337EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_get);
338
339int snd_hdac_ext_bus_link_put(struct hdac_bus *bus,
340 struct hdac_ext_link *hlink)
341{
342 int ret = 0;
343 struct hdac_ext_link *hlink_tmp;
344 bool link_up = false;
345
346 mutex_lock(&bus->lock);
347
348 /*
349 * if we move from 1 to 0, count will be 0
350 * so power down this link as well
351 */
352 if (--hlink->ref_count == 0) {
353 ret = snd_hdac_ext_bus_link_power_down(hlink);
354
355 /*
356 * now check if all links are off, if so turn off
357 * cmd dma as well
358 */
359 list_for_each_entry(hlink_tmp, &bus->hlink_list, list) {
360 if (hlink_tmp->ref_count) {
361 link_up = true;
362 break;
363 }
364 }
365
366 if (!link_up) {
367 snd_hdac_bus_stop_cmd_io(bus);
368 bus->cmd_dma_state = false;
369 }
370 }
371
372 mutex_unlock(lock: &bus->lock);
373 return ret;
374}
375EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_put);
376
377static void hdac_ext_codec_link_up(struct hdac_device *codec)
378{
379 const char *devname = dev_name(dev: &codec->dev);
380 struct hdac_ext_link *hlink =
381 snd_hdac_ext_bus_get_hlink_by_name(codec->bus, devname);
382
383 if (hlink)
384 snd_hdac_ext_bus_link_get(codec->bus, hlink);
385}
386
387static void hdac_ext_codec_link_down(struct hdac_device *codec)
388{
389 const char *devname = dev_name(dev: &codec->dev);
390 struct hdac_ext_link *hlink =
391 snd_hdac_ext_bus_get_hlink_by_name(codec->bus, devname);
392
393 if (hlink)
394 snd_hdac_ext_bus_link_put(codec->bus, hlink);
395}
396
397void snd_hdac_ext_bus_link_power(struct hdac_device *codec, bool enable)
398{
399 struct hdac_bus *bus = codec->bus;
400 bool oldstate = test_bit(codec->addr, &bus->codec_powered);
401
402 if (enable == oldstate)
403 return;
404
405 snd_hdac_bus_link_power(hdev: codec, enable);
406
407 if (enable)
408 hdac_ext_codec_link_up(codec);
409 else
410 hdac_ext_codec_link_down(codec);
411}
412EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_power);
413

source code of linux/sound/hda/ext/hdac_ext_controller.c