1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2022, Intel Corporation. */
3
4 #include <linux/vmalloc.h>
5 #include "ice.h"
6 #include "ice_common.h"
7 #include "ice_fwlog.h"
8
ice_fwlog_ring_full(struct ice_fwlog_ring * rings)9 bool ice_fwlog_ring_full(struct ice_fwlog_ring *rings)
10 {
11 u16 head, tail;
12
13 head = rings->head;
14 tail = rings->tail;
15
16 if (head < tail && (tail - head == (rings->size - 1)))
17 return true;
18 else if (head > tail && (tail == (head - 1)))
19 return true;
20
21 return false;
22 }
23
ice_fwlog_ring_empty(struct ice_fwlog_ring * rings)24 bool ice_fwlog_ring_empty(struct ice_fwlog_ring *rings)
25 {
26 return rings->head == rings->tail;
27 }
28
ice_fwlog_ring_increment(u16 * item,u16 size)29 void ice_fwlog_ring_increment(u16 *item, u16 size)
30 {
31 *item = (*item + 1) & (size - 1);
32 }
33
ice_fwlog_alloc_ring_buffs(struct ice_fwlog_ring * rings)34 static int ice_fwlog_alloc_ring_buffs(struct ice_fwlog_ring *rings)
35 {
36 int i, nr_bytes;
37 u8 *mem;
38
39 nr_bytes = rings->size * ICE_AQ_MAX_BUF_LEN;
40 mem = vzalloc(nr_bytes);
41 if (!mem)
42 return -ENOMEM;
43
44 for (i = 0; i < rings->size; i++) {
45 struct ice_fwlog_data *ring = &rings->rings[i];
46
47 ring->data_size = ICE_AQ_MAX_BUF_LEN;
48 ring->data = mem;
49 mem += ICE_AQ_MAX_BUF_LEN;
50 }
51
52 return 0;
53 }
54
ice_fwlog_free_ring_buffs(struct ice_fwlog_ring * rings)55 static void ice_fwlog_free_ring_buffs(struct ice_fwlog_ring *rings)
56 {
57 int i;
58
59 for (i = 0; i < rings->size; i++) {
60 struct ice_fwlog_data *ring = &rings->rings[i];
61
62 /* the first ring is the base memory for the whole range so
63 * free it
64 */
65 if (!i)
66 vfree(ring->data);
67
68 ring->data = NULL;
69 ring->data_size = 0;
70 }
71 }
72
73 #define ICE_FWLOG_INDEX_TO_BYTES(n) ((128 * 1024) << (n))
74 /**
75 * ice_fwlog_realloc_rings - reallocate the FW log rings
76 * @hw: pointer to the HW structure
77 * @index: the new index to use to allocate memory for the log data
78 *
79 */
ice_fwlog_realloc_rings(struct ice_hw * hw,int index)80 void ice_fwlog_realloc_rings(struct ice_hw *hw, int index)
81 {
82 struct ice_fwlog_ring ring;
83 int status, ring_size;
84
85 /* convert the number of bytes into a number of 4K buffers. externally
86 * the driver presents the interface to the FW log data as a number of
87 * bytes because that's easy for users to understand. internally the
88 * driver uses a ring of buffers because the driver doesn't know where
89 * the beginning and end of any line of log data is so the driver has
90 * to overwrite data as complete blocks. when the data is returned to
91 * the user the driver knows that the data is correct and the FW log
92 * can be correctly parsed by the tools
93 */
94 ring_size = ICE_FWLOG_INDEX_TO_BYTES(index) / ICE_AQ_MAX_BUF_LEN;
95 if (ring_size == hw->fwlog_ring.size)
96 return;
97
98 /* allocate space for the new rings and buffers then release the
99 * old rings and buffers. that way if we don't have enough
100 * memory then we at least have what we had before
101 */
102 ring.rings = kcalloc(ring_size, sizeof(*ring.rings), GFP_KERNEL);
103 if (!ring.rings)
104 return;
105
106 ring.size = ring_size;
107
108 status = ice_fwlog_alloc_ring_buffs(&ring);
109 if (status) {
110 dev_warn(ice_hw_to_dev(hw), "Unable to allocate memory for FW log ring data buffers\n");
111 ice_fwlog_free_ring_buffs(&ring);
112 kfree(ring.rings);
113 return;
114 }
115
116 ice_fwlog_free_ring_buffs(&hw->fwlog_ring);
117 kfree(hw->fwlog_ring.rings);
118
119 hw->fwlog_ring.rings = ring.rings;
120 hw->fwlog_ring.size = ring.size;
121 hw->fwlog_ring.index = index;
122 hw->fwlog_ring.head = 0;
123 hw->fwlog_ring.tail = 0;
124 }
125
126 /**
127 * ice_fwlog_init - Initialize FW logging configuration
128 * @hw: pointer to the HW structure
129 *
130 * This function should be called on driver initialization during
131 * ice_init_hw().
132 */
ice_fwlog_init(struct ice_hw * hw)133 int ice_fwlog_init(struct ice_hw *hw)
134 {
135 /* only support fw log commands on PF 0 */
136 if (hw->bus.func)
137 return -EINVAL;
138
139 ice_fwlog_set_supported(hw);
140
141 if (ice_fwlog_supported(hw)) {
142 int status;
143
144 /* read the current config from the FW and store it */
145 status = ice_fwlog_get(hw, &hw->fwlog_cfg);
146 if (status)
147 return status;
148
149 hw->fwlog_ring.rings = kcalloc(ICE_FWLOG_RING_SIZE_DFLT,
150 sizeof(*hw->fwlog_ring.rings),
151 GFP_KERNEL);
152 if (!hw->fwlog_ring.rings) {
153 dev_warn(ice_hw_to_dev(hw), "Unable to allocate memory for FW log rings\n");
154 return -ENOMEM;
155 }
156
157 hw->fwlog_ring.size = ICE_FWLOG_RING_SIZE_DFLT;
158 hw->fwlog_ring.index = ICE_FWLOG_RING_SIZE_INDEX_DFLT;
159
160 status = ice_fwlog_alloc_ring_buffs(&hw->fwlog_ring);
161 if (status) {
162 dev_warn(ice_hw_to_dev(hw), "Unable to allocate memory for FW log ring data buffers\n");
163 ice_fwlog_free_ring_buffs(&hw->fwlog_ring);
164 kfree(hw->fwlog_ring.rings);
165 return status;
166 }
167
168 ice_debugfs_fwlog_init(hw->back);
169 } else {
170 dev_warn(ice_hw_to_dev(hw), "FW logging is not supported in this NVM image. Please update the NVM to get FW log support\n");
171 }
172
173 return 0;
174 }
175
176 /**
177 * ice_fwlog_deinit - unroll FW logging configuration
178 * @hw: pointer to the HW structure
179 *
180 * This function should be called in ice_deinit_hw().
181 */
ice_fwlog_deinit(struct ice_hw * hw)182 void ice_fwlog_deinit(struct ice_hw *hw)
183 {
184 struct ice_pf *pf = hw->back;
185 int status;
186
187 /* only support fw log commands on PF 0 */
188 if (hw->bus.func)
189 return;
190
191 ice_debugfs_pf_deinit(hw->back);
192
193 /* make sure FW logging is disabled to not put the FW in a weird state
194 * for the next driver load
195 */
196 hw->fwlog_cfg.options &= ~ICE_FWLOG_OPTION_ARQ_ENA;
197 status = ice_fwlog_set(hw, &hw->fwlog_cfg);
198 if (status)
199 dev_warn(ice_hw_to_dev(hw), "Unable to turn off FW logging, status: %d\n",
200 status);
201
202 kfree(pf->ice_debugfs_pf_fwlog_modules);
203
204 pf->ice_debugfs_pf_fwlog_modules = NULL;
205
206 status = ice_fwlog_unregister(hw);
207 if (status)
208 dev_warn(ice_hw_to_dev(hw), "Unable to unregister FW logging, status: %d\n",
209 status);
210
211 if (hw->fwlog_ring.rings) {
212 ice_fwlog_free_ring_buffs(&hw->fwlog_ring);
213 kfree(hw->fwlog_ring.rings);
214 }
215 }
216
217 /**
218 * ice_fwlog_supported - Cached for whether FW supports FW logging or not
219 * @hw: pointer to the HW structure
220 *
221 * This will always return false if called before ice_init_hw(), so it must be
222 * called after ice_init_hw().
223 */
ice_fwlog_supported(struct ice_hw * hw)224 bool ice_fwlog_supported(struct ice_hw *hw)
225 {
226 return hw->fwlog_supported;
227 }
228
229 /**
230 * ice_aq_fwlog_set - Set FW logging configuration AQ command (0xFF30)
231 * @hw: pointer to the HW structure
232 * @entries: entries to configure
233 * @num_entries: number of @entries
234 * @options: options from ice_fwlog_cfg->options structure
235 * @log_resolution: logging resolution
236 */
237 static int
ice_aq_fwlog_set(struct ice_hw * hw,struct ice_fwlog_module_entry * entries,u16 num_entries,u16 options,u16 log_resolution)238 ice_aq_fwlog_set(struct ice_hw *hw, struct ice_fwlog_module_entry *entries,
239 u16 num_entries, u16 options, u16 log_resolution)
240 {
241 struct ice_aqc_fw_log_cfg_resp *fw_modules;
242 struct ice_aqc_fw_log *cmd;
243 struct ice_aq_desc desc;
244 int status;
245 int i;
246
247 fw_modules = kcalloc(num_entries, sizeof(*fw_modules), GFP_KERNEL);
248 if (!fw_modules)
249 return -ENOMEM;
250
251 for (i = 0; i < num_entries; i++) {
252 fw_modules[i].module_identifier =
253 cpu_to_le16(entries[i].module_id);
254 fw_modules[i].log_level = entries[i].log_level;
255 }
256
257 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_fw_logs_config);
258 desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);
259
260 cmd = &desc.params.fw_log;
261
262 cmd->cmd_flags = ICE_AQC_FW_LOG_CONF_SET_VALID;
263 cmd->ops.cfg.log_resolution = cpu_to_le16(log_resolution);
264 cmd->ops.cfg.mdl_cnt = cpu_to_le16(num_entries);
265
266 if (options & ICE_FWLOG_OPTION_ARQ_ENA)
267 cmd->cmd_flags |= ICE_AQC_FW_LOG_CONF_AQ_EN;
268 if (options & ICE_FWLOG_OPTION_UART_ENA)
269 cmd->cmd_flags |= ICE_AQC_FW_LOG_CONF_UART_EN;
270
271 status = ice_aq_send_cmd(hw, &desc, fw_modules,
272 sizeof(*fw_modules) * num_entries,
273 NULL);
274
275 kfree(fw_modules);
276
277 return status;
278 }
279
280 /**
281 * ice_fwlog_set - Set the firmware logging settings
282 * @hw: pointer to the HW structure
283 * @cfg: config used to set firmware logging
284 *
285 * This function should be called whenever the driver needs to set the firmware
286 * logging configuration. It can be called on initialization, reset, or during
287 * runtime.
288 *
289 * If the PF wishes to receive FW logging then it must register via
290 * ice_fwlog_register. Note, that ice_fwlog_register does not need to be called
291 * for init.
292 */
ice_fwlog_set(struct ice_hw * hw,struct ice_fwlog_cfg * cfg)293 int ice_fwlog_set(struct ice_hw *hw, struct ice_fwlog_cfg *cfg)
294 {
295 if (!ice_fwlog_supported(hw))
296 return -EOPNOTSUPP;
297
298 return ice_aq_fwlog_set(hw, cfg->module_entries,
299 ICE_AQC_FW_LOG_ID_MAX, cfg->options,
300 cfg->log_resolution);
301 }
302
303 /**
304 * ice_aq_fwlog_get - Get the current firmware logging configuration (0xFF32)
305 * @hw: pointer to the HW structure
306 * @cfg: firmware logging configuration to populate
307 */
ice_aq_fwlog_get(struct ice_hw * hw,struct ice_fwlog_cfg * cfg)308 static int ice_aq_fwlog_get(struct ice_hw *hw, struct ice_fwlog_cfg *cfg)
309 {
310 struct ice_aqc_fw_log_cfg_resp *fw_modules;
311 struct ice_aqc_fw_log *cmd;
312 struct ice_aq_desc desc;
313 u16 module_id_cnt;
314 int status;
315 void *buf;
316 int i;
317
318 memset(cfg, 0, sizeof(*cfg));
319
320 buf = kzalloc(ICE_AQ_MAX_BUF_LEN, GFP_KERNEL);
321 if (!buf)
322 return -ENOMEM;
323
324 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_fw_logs_query);
325 cmd = &desc.params.fw_log;
326
327 cmd->cmd_flags = ICE_AQC_FW_LOG_AQ_QUERY;
328
329 status = ice_aq_send_cmd(hw, &desc, buf, ICE_AQ_MAX_BUF_LEN, NULL);
330 if (status) {
331 ice_debug(hw, ICE_DBG_FW_LOG, "Failed to get FW log configuration\n");
332 goto status_out;
333 }
334
335 module_id_cnt = le16_to_cpu(cmd->ops.cfg.mdl_cnt);
336 if (module_id_cnt < ICE_AQC_FW_LOG_ID_MAX) {
337 ice_debug(hw, ICE_DBG_FW_LOG, "FW returned less than the expected number of FW log module IDs\n");
338 } else if (module_id_cnt > ICE_AQC_FW_LOG_ID_MAX) {
339 ice_debug(hw, ICE_DBG_FW_LOG, "FW returned more than expected number of FW log module IDs, setting module_id_cnt to software expected max %u\n",
340 ICE_AQC_FW_LOG_ID_MAX);
341 module_id_cnt = ICE_AQC_FW_LOG_ID_MAX;
342 }
343
344 cfg->log_resolution = le16_to_cpu(cmd->ops.cfg.log_resolution);
345 if (cmd->cmd_flags & ICE_AQC_FW_LOG_CONF_AQ_EN)
346 cfg->options |= ICE_FWLOG_OPTION_ARQ_ENA;
347 if (cmd->cmd_flags & ICE_AQC_FW_LOG_CONF_UART_EN)
348 cfg->options |= ICE_FWLOG_OPTION_UART_ENA;
349 if (cmd->cmd_flags & ICE_AQC_FW_LOG_QUERY_REGISTERED)
350 cfg->options |= ICE_FWLOG_OPTION_IS_REGISTERED;
351
352 fw_modules = (struct ice_aqc_fw_log_cfg_resp *)buf;
353
354 for (i = 0; i < module_id_cnt; i++) {
355 struct ice_aqc_fw_log_cfg_resp *fw_module = &fw_modules[i];
356
357 cfg->module_entries[i].module_id =
358 le16_to_cpu(fw_module->module_identifier);
359 cfg->module_entries[i].log_level = fw_module->log_level;
360 }
361
362 status_out:
363 kfree(buf);
364 return status;
365 }
366
367 /**
368 * ice_fwlog_get - Get the firmware logging settings
369 * @hw: pointer to the HW structure
370 * @cfg: config to populate based on current firmware logging settings
371 */
ice_fwlog_get(struct ice_hw * hw,struct ice_fwlog_cfg * cfg)372 int ice_fwlog_get(struct ice_hw *hw, struct ice_fwlog_cfg *cfg)
373 {
374 if (!ice_fwlog_supported(hw))
375 return -EOPNOTSUPP;
376
377 return ice_aq_fwlog_get(hw, cfg);
378 }
379
380 /**
381 * ice_aq_fwlog_register - Register PF for firmware logging events (0xFF31)
382 * @hw: pointer to the HW structure
383 * @reg: true to register and false to unregister
384 */
ice_aq_fwlog_register(struct ice_hw * hw,bool reg)385 static int ice_aq_fwlog_register(struct ice_hw *hw, bool reg)
386 {
387 struct ice_aq_desc desc;
388
389 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_fw_logs_register);
390
391 if (reg)
392 desc.params.fw_log.cmd_flags = ICE_AQC_FW_LOG_AQ_REGISTER;
393
394 return ice_aq_send_cmd(hw, &desc, NULL, 0, NULL);
395 }
396
397 /**
398 * ice_fwlog_register - Register the PF for firmware logging
399 * @hw: pointer to the HW structure
400 *
401 * After this call the PF will start to receive firmware logging based on the
402 * configuration set in ice_fwlog_set.
403 */
ice_fwlog_register(struct ice_hw * hw)404 int ice_fwlog_register(struct ice_hw *hw)
405 {
406 int status;
407
408 if (!ice_fwlog_supported(hw))
409 return -EOPNOTSUPP;
410
411 status = ice_aq_fwlog_register(hw, true);
412 if (status)
413 ice_debug(hw, ICE_DBG_FW_LOG, "Failed to register for firmware logging events over ARQ\n");
414 else
415 hw->fwlog_cfg.options |= ICE_FWLOG_OPTION_IS_REGISTERED;
416
417 return status;
418 }
419
420 /**
421 * ice_fwlog_unregister - Unregister the PF from firmware logging
422 * @hw: pointer to the HW structure
423 */
ice_fwlog_unregister(struct ice_hw * hw)424 int ice_fwlog_unregister(struct ice_hw *hw)
425 {
426 int status;
427
428 if (!ice_fwlog_supported(hw))
429 return -EOPNOTSUPP;
430
431 status = ice_aq_fwlog_register(hw, false);
432 if (status)
433 ice_debug(hw, ICE_DBG_FW_LOG, "Failed to unregister from firmware logging events over ARQ\n");
434 else
435 hw->fwlog_cfg.options &= ~ICE_FWLOG_OPTION_IS_REGISTERED;
436
437 return status;
438 }
439
440 /**
441 * ice_fwlog_set_supported - Set if FW logging is supported by FW
442 * @hw: pointer to the HW struct
443 *
444 * If FW returns success to the ice_aq_fwlog_get call then it supports FW
445 * logging, else it doesn't. Set the fwlog_supported flag accordingly.
446 *
447 * This function is only meant to be called during driver init to determine if
448 * the FW support FW logging.
449 */
ice_fwlog_set_supported(struct ice_hw * hw)450 void ice_fwlog_set_supported(struct ice_hw *hw)
451 {
452 struct ice_fwlog_cfg *cfg;
453 int status;
454
455 hw->fwlog_supported = false;
456
457 cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
458 if (!cfg)
459 return;
460
461 /* don't call ice_fwlog_get() because that would check to see if FW
462 * logging is supported which is what the driver is determining now
463 */
464 status = ice_aq_fwlog_get(hw, cfg);
465 if (status)
466 ice_debug(hw, ICE_DBG_FW_LOG, "ice_aq_fwlog_get failed, FW logging is not supported on this version of FW, status %d\n",
467 status);
468 else
469 hw->fwlog_supported = true;
470
471 kfree(cfg);
472 }
473