473 lines · c
1// SPDX-License-Identifier: GPL-2.02/* 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 9bool 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 24bool ice_fwlog_ring_empty(struct ice_fwlog_ring *rings)25{26 return rings->head == rings->tail;27}28 29void ice_fwlog_ring_increment(u16 *item, u16 size)30{31 *item = (*item + 1) & (size - 1);32}33 34static 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 55static 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 so63 * free it64 */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 rings76 * @hw: pointer to the HW structure77 * @index: the new index to use to allocate memory for the log data78 *79 */80void 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. externally86 * the driver presents the interface to the FW log data as a number of87 * bytes because that's easy for users to understand. internally the88 * driver uses a ring of buffers because the driver doesn't know where89 * the beginning and end of any line of log data is so the driver has90 * to overwrite data as complete blocks. when the data is returned to91 * the user the driver knows that the data is correct and the FW log92 * can be correctly parsed by the tools93 */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 the99 * old rings and buffers. that way if we don't have enough100 * memory then we at least have what we had before101 */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 configuration128 * @hw: pointer to the HW structure129 *130 * This function should be called on driver initialization during131 * ice_init_hw().132 */133int 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 configuration178 * @hw: pointer to the HW structure179 *180 * This function should be called in ice_deinit_hw().181 */182void 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 state194 * for the next driver load195 */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 not219 * @hw: pointer to the HW structure220 *221 * This will always return false if called before ice_init_hw(), so it must be222 * called after ice_init_hw().223 */224bool 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 structure232 * @entries: entries to configure233 * @num_entries: number of @entries234 * @options: options from ice_fwlog_cfg->options structure235 * @log_resolution: logging resolution236 */237static int238ice_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 settings282 * @hw: pointer to the HW structure283 * @cfg: config used to set firmware logging284 *285 * This function should be called whenever the driver needs to set the firmware286 * logging configuration. It can be called on initialization, reset, or during287 * runtime.288 *289 * If the PF wishes to receive FW logging then it must register via290 * ice_fwlog_register. Note, that ice_fwlog_register does not need to be called291 * for init.292 */293int 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 structure306 * @cfg: firmware logging configuration to populate307 */308static 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 362status_out:363 kfree(buf);364 return status;365}366 367/**368 * ice_fwlog_get - Get the firmware logging settings369 * @hw: pointer to the HW structure370 * @cfg: config to populate based on current firmware logging settings371 */372int 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 structure383 * @reg: true to register and false to unregister384 */385static 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 logging399 * @hw: pointer to the HW structure400 *401 * After this call the PF will start to receive firmware logging based on the402 * configuration set in ice_fwlog_set.403 */404int 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 else415 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 logging422 * @hw: pointer to the HW structure423 */424int 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 else435 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 FW442 * @hw: pointer to the HW struct443 *444 * If FW returns success to the ice_aq_fwlog_get call then it supports FW445 * 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 if448 * the FW support FW logging.449 */450void 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 FW462 * logging is supported which is what the driver is determining now463 */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 else469 hw->fwlog_supported = true;470 471 kfree(cfg);472}473