1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
4 //
5 // Authors: Cezary Rojewski <cezary.rojewski@intel.com>
6 // Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
7 //
8
9 #include <linux/devcoredump.h>
10 #include <linux/slab.h>
11 #include "avs.h"
12 #include "messages.h"
13 #include "path.h"
14 #include "topology.h"
15
16 static int __maybe_unused
avs_apl_enable_logs(struct avs_dev * adev,enum avs_log_enable enable,u32 aging_period,u32 fifo_full_period,unsigned long resource_mask,u32 * priorities)17 avs_apl_enable_logs(struct avs_dev *adev, enum avs_log_enable enable, u32 aging_period,
18 u32 fifo_full_period, unsigned long resource_mask, u32 *priorities)
19 {
20 struct avs_apl_log_state_info *info;
21 u32 size, num_cores = adev->hw_cfg.dsp_cores;
22 int ret, i;
23
24 if (fls_long(resource_mask) > num_cores)
25 return -EINVAL;
26 size = struct_size(info, logs_core, num_cores);
27 info = kzalloc(size, GFP_KERNEL);
28 if (!info)
29 return -ENOMEM;
30
31 info->aging_timer_period = aging_period;
32 info->fifo_full_timer_period = fifo_full_period;
33 info->core_mask = resource_mask;
34 if (enable)
35 for_each_set_bit(i, &resource_mask, num_cores) {
36 info->logs_core[i].enable = enable;
37 info->logs_core[i].min_priority = *priorities++;
38 }
39 else
40 for_each_set_bit(i, &resource_mask, num_cores)
41 info->logs_core[i].enable = enable;
42
43 ret = avs_ipc_set_enable_logs(adev, (u8 *)info, size);
44 kfree(info);
45 if (ret)
46 return AVS_IPC_RET(ret);
47
48 return 0;
49 }
50
avs_apl_log_buffer_status(struct avs_dev * adev,union avs_notify_msg * msg)51 static int avs_apl_log_buffer_status(struct avs_dev *adev, union avs_notify_msg *msg)
52 {
53 struct avs_apl_log_buffer_layout layout;
54 void __iomem *addr, *buf;
55
56 addr = avs_log_buffer_addr(adev, msg->log.core);
57 if (!addr)
58 return -ENXIO;
59
60 memcpy_fromio(&layout, addr, sizeof(layout));
61
62 if (!avs_logging_fw(adev))
63 /* consume the logs regardless of consumer presence */
64 goto update_read_ptr;
65
66 buf = avs_apl_log_payload_addr(addr);
67
68 if (layout.read_ptr > layout.write_ptr) {
69 avs_dump_fw_log(adev, buf + layout.read_ptr,
70 avs_apl_log_payload_size(adev) - layout.read_ptr);
71 layout.read_ptr = 0;
72 }
73 avs_dump_fw_log_wakeup(adev, buf + layout.read_ptr, layout.write_ptr - layout.read_ptr);
74
75 update_read_ptr:
76 writel(layout.write_ptr, addr);
77 return 0;
78 }
79
avs_apl_wait_log_entry(struct avs_dev * adev,u32 core,struct avs_apl_log_buffer_layout * layout)80 static int avs_apl_wait_log_entry(struct avs_dev *adev, u32 core,
81 struct avs_apl_log_buffer_layout *layout)
82 {
83 unsigned long timeout;
84 void __iomem *addr;
85
86 addr = avs_log_buffer_addr(adev, core);
87 if (!addr)
88 return -ENXIO;
89
90 timeout = jiffies + msecs_to_jiffies(10);
91
92 do {
93 memcpy_fromio(layout, addr, sizeof(*layout));
94 if (layout->read_ptr != layout->write_ptr)
95 return 0;
96 usleep_range(500, 1000);
97 } while (!time_after(jiffies, timeout));
98
99 return -ETIMEDOUT;
100 }
101
102 /* reads log header and tests its type */
103 #define avs_apl_is_entry_stackdump(addr) ((readl(addr) >> 30) & 0x1)
104
avs_apl_coredump(struct avs_dev * adev,union avs_notify_msg * msg)105 static int avs_apl_coredump(struct avs_dev *adev, union avs_notify_msg *msg)
106 {
107 struct avs_apl_log_buffer_layout layout;
108 void __iomem *addr, *buf;
109 size_t dump_size;
110 u32 offset = 0;
111 u8 *dump, *pos;
112
113 dump_size = AVS_FW_REGS_SIZE + msg->ext.coredump.stack_dump_size;
114 dump = vzalloc(dump_size);
115 if (!dump)
116 return -ENOMEM;
117
118 memcpy_fromio(dump, avs_sram_addr(adev, AVS_FW_REGS_WINDOW), AVS_FW_REGS_SIZE);
119
120 if (!msg->ext.coredump.stack_dump_size)
121 goto exit;
122
123 /* Dump the registers even if an external error prevents gathering the stack. */
124 addr = avs_log_buffer_addr(adev, msg->ext.coredump.core_id);
125 if (!addr)
126 goto exit;
127
128 buf = avs_apl_log_payload_addr(addr);
129 memcpy_fromio(&layout, addr, sizeof(layout));
130 if (!avs_apl_is_entry_stackdump(buf + layout.read_ptr)) {
131 union avs_notify_msg lbs_msg = AVS_NOTIFICATION(LOG_BUFFER_STATUS);
132
133 /*
134 * DSP awaits the remaining logs to be
135 * gathered before dumping stack
136 */
137 lbs_msg.log.core = msg->ext.coredump.core_id;
138 avs_log_buffer_status_locked(adev, &lbs_msg);
139 }
140
141 pos = dump + AVS_FW_REGS_SIZE;
142 /* gather the stack */
143 do {
144 u32 count;
145
146 if (avs_apl_wait_log_entry(adev, msg->ext.coredump.core_id, &layout))
147 break;
148
149 if (layout.read_ptr > layout.write_ptr) {
150 count = avs_apl_log_payload_size(adev) - layout.read_ptr;
151 memcpy_fromio(pos + offset, buf + layout.read_ptr, count);
152 layout.read_ptr = 0;
153 offset += count;
154 }
155 count = layout.write_ptr - layout.read_ptr;
156 memcpy_fromio(pos + offset, buf + layout.read_ptr, count);
157 offset += count;
158
159 /* update read pointer */
160 writel(layout.write_ptr, addr);
161 } while (offset < msg->ext.coredump.stack_dump_size);
162
163 exit:
164 dev_coredumpv(adev->dev, dump, dump_size, GFP_KERNEL);
165
166 return 0;
167 }
168
avs_apl_lp_streaming(struct avs_dev * adev)169 static bool avs_apl_lp_streaming(struct avs_dev *adev)
170 {
171 struct avs_path *path;
172
173 spin_lock(&adev->path_list_lock);
174 /* Any gateway without buffer allocated in LP area disqualifies D0IX. */
175 list_for_each_entry(path, &adev->path_list, node) {
176 struct avs_path_pipeline *ppl;
177
178 list_for_each_entry(ppl, &path->ppl_list, node) {
179 struct avs_path_module *mod;
180
181 list_for_each_entry(mod, &ppl->mod_list, node) {
182 struct avs_tplg_modcfg_ext *cfg;
183
184 cfg = mod->template->cfg_ext;
185
186 /* only copiers have gateway attributes */
187 if (!guid_equal(&cfg->type, &AVS_COPIER_MOD_UUID))
188 continue;
189 /* non-gateway copiers do not prevent PG */
190 if (cfg->copier.dma_type == INVALID_OBJECT_ID)
191 continue;
192
193 if (!mod->gtw_attrs.lp_buffer_alloc) {
194 spin_unlock(&adev->path_list_lock);
195 return false;
196 }
197 }
198 }
199 }
200 spin_unlock(&adev->path_list_lock);
201
202 return true;
203 }
204
avs_apl_d0ix_toggle(struct avs_dev * adev,struct avs_ipc_msg * tx,bool wake)205 static bool avs_apl_d0ix_toggle(struct avs_dev *adev, struct avs_ipc_msg *tx, bool wake)
206 {
207 /* wake in all cases */
208 if (wake)
209 return true;
210
211 /*
212 * If no pipelines are running, allow for d0ix schedule.
213 * If all gateways have lp=1, allow for d0ix schedule.
214 * If any gateway with lp=0 is allocated, abort scheduling d0ix.
215 *
216 * Note: for cAVS 1.5+ and 1.8, D0IX is LP-firmware transition,
217 * not the power-gating mechanism known from cAVS 2.0.
218 */
219 return avs_apl_lp_streaming(adev);
220 }
221
avs_apl_set_d0ix(struct avs_dev * adev,bool enable)222 static int avs_apl_set_d0ix(struct avs_dev *adev, bool enable)
223 {
224 bool streaming = false;
225 int ret;
226
227 if (enable)
228 /* Either idle or all gateways with lp=1. */
229 streaming = !list_empty(&adev->path_list);
230
231 ret = avs_ipc_set_d0ix(adev, enable, streaming);
232 return AVS_IPC_RET(ret);
233 }
234
235 const struct avs_dsp_ops avs_apl_dsp_ops = {
236 .power = avs_dsp_core_power,
237 .reset = avs_dsp_core_reset,
238 .stall = avs_dsp_core_stall,
239 .irq_handler = avs_dsp_irq_handler,
240 .irq_thread = avs_dsp_irq_thread,
241 .int_control = avs_dsp_interrupt_control,
242 .load_basefw = avs_hda_load_basefw,
243 .load_lib = avs_hda_load_library,
244 .transfer_mods = avs_hda_transfer_modules,
245 .log_buffer_offset = avs_skl_log_buffer_offset,
246 .log_buffer_status = avs_apl_log_buffer_status,
247 .coredump = avs_apl_coredump,
248 .d0ix_toggle = avs_apl_d0ix_toggle,
249 .set_d0ix = avs_apl_set_d0ix,
250 AVS_SET_ENABLE_LOGS_OP(apl)
251 };
252