eth: fbnic: Replace firmware field macros

Replace the firmware field macros with new macros which follow typical
kernel standards. No variables are required to be predefined for use and
results are now returned. These macros are prefixed with fta or fbnic
TLV attribute.

Signed-off-by: Lee Trager <lee@trager.us>
Link: https://patch.msgid.link/20250228191935.3953712-4-lee@trager.us
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/drivers/net/ethernet/meta/fbnic/fbnic_fw.c b/drivers/net/ethernet/meta/fbnic/fbnic_fw.c
index 76a225f01718683ebe73b3e679976d7d5b7be5ed..88db3dacb940596468384e79c5765929a460842f 100644 (file)
--- a/drivers/net/ethernet/meta/fbnic/fbnic_fw.c
+++ b/drivers/net/ethernet/meta/fbnic/fbnic_fw.c
@@ -494,16 +494,13 @@ static int fbnic_fw_parse_bmc_addrs(u8 bmc_mac_addr[][ETH_ALEN],
 
 static int fbnic_fw_parse_cap_resp(void *opaque, struct fbnic_tlv_msg **results)
 {
-       u32 active_slot = 0, all_multi = 0;
+       u32 all_multi = 0, version = 0;
        struct fbnic_dev *fbd = opaque;
-       u32 speed = 0, fec = 0;
-       size_t commit_size = 0;
        bool bmc_present;
        int err;
 
-       get_unsigned_result(FBNIC_FW_CAP_RESP_VERSION,
-                           fbd->fw_cap.running.mgmt.version);
-
+       version = fta_get_uint(results, FBNIC_FW_CAP_RESP_VERSION);
+       fbd->fw_cap.running.mgmt.version = version;
        if (!fbd->fw_cap.running.mgmt.version)
                return -EINVAL;
 
@@ -524,43 +521,41 @@ static int fbnic_fw_parse_cap_resp(void *opaque, struct fbnic_tlv_msg **results)
                return -EINVAL;
        }
 
-       get_string_result(FBNIC_FW_CAP_RESP_VERSION_COMMIT_STR, commit_size,
-                         fbd->fw_cap.running.mgmt.commit,
-                         FBNIC_FW_CAP_RESP_COMMIT_MAX_SIZE);
-       if (!commit_size)
+       if (fta_get_str(results, FBNIC_FW_CAP_RESP_VERSION_COMMIT_STR,
+                       fbd->fw_cap.running.mgmt.commit,
+                       FBNIC_FW_CAP_RESP_COMMIT_MAX_SIZE) <= 0)
                dev_warn(fbd->dev, "Firmware did not send mgmt commit!\n");
 
-       get_unsigned_result(FBNIC_FW_CAP_RESP_STORED_VERSION,
-                           fbd->fw_cap.stored.mgmt.version);
-       get_string_result(FBNIC_FW_CAP_RESP_STORED_COMMIT_STR, commit_size,
-                         fbd->fw_cap.stored.mgmt.commit,
-                         FBNIC_FW_CAP_RESP_COMMIT_MAX_SIZE);
-
-       get_unsigned_result(FBNIC_FW_CAP_RESP_CMRT_VERSION,
-                           fbd->fw_cap.running.bootloader.version);
-       get_string_result(FBNIC_FW_CAP_RESP_CMRT_COMMIT_STR, commit_size,
-                         fbd->fw_cap.running.bootloader.commit,
-                         FBNIC_FW_CAP_RESP_COMMIT_MAX_SIZE);
-
-       get_unsigned_result(FBNIC_FW_CAP_RESP_STORED_CMRT_VERSION,
-                           fbd->fw_cap.stored.bootloader.version);
-       get_string_result(FBNIC_FW_CAP_RESP_STORED_CMRT_COMMIT_STR, commit_size,
-                         fbd->fw_cap.stored.bootloader.commit,
-                         FBNIC_FW_CAP_RESP_COMMIT_MAX_SIZE);
-
-       get_unsigned_result(FBNIC_FW_CAP_RESP_UEFI_VERSION,
-                           fbd->fw_cap.stored.undi.version);
-       get_string_result(FBNIC_FW_CAP_RESP_UEFI_COMMIT_STR, commit_size,
-                         fbd->fw_cap.stored.undi.commit,
-                         FBNIC_FW_CAP_RESP_COMMIT_MAX_SIZE);
-
-       get_unsigned_result(FBNIC_FW_CAP_RESP_ACTIVE_FW_SLOT, active_slot);
-       fbd->fw_cap.active_slot = active_slot;
-
-       get_unsigned_result(FBNIC_FW_CAP_RESP_FW_LINK_SPEED, speed);
-       get_unsigned_result(FBNIC_FW_CAP_RESP_FW_LINK_FEC, fec);
-       fbd->fw_cap.link_speed = speed;
-       fbd->fw_cap.link_fec = fec;
+       version = fta_get_uint(results, FBNIC_FW_CAP_RESP_STORED_VERSION);
+       fbd->fw_cap.stored.mgmt.version = version;
+       fta_get_str(results, FBNIC_FW_CAP_RESP_STORED_COMMIT_STR,
+                   fbd->fw_cap.stored.mgmt.commit,
+                   FBNIC_FW_CAP_RESP_COMMIT_MAX_SIZE);
+
+       version = fta_get_uint(results, FBNIC_FW_CAP_RESP_CMRT_VERSION);
+       fbd->fw_cap.running.bootloader.version = version;
+       fta_get_str(results, FBNIC_FW_CAP_RESP_CMRT_COMMIT_STR,
+                   fbd->fw_cap.running.bootloader.commit,
+                   FBNIC_FW_CAP_RESP_COMMIT_MAX_SIZE);
+
+       version = fta_get_uint(results, FBNIC_FW_CAP_RESP_STORED_CMRT_VERSION);
+       fbd->fw_cap.stored.bootloader.version = version;
+       fta_get_str(results, FBNIC_FW_CAP_RESP_STORED_CMRT_COMMIT_STR,
+                   fbd->fw_cap.stored.bootloader.commit,
+                   FBNIC_FW_CAP_RESP_COMMIT_MAX_SIZE);
+
+       version = fta_get_uint(results, FBNIC_FW_CAP_RESP_UEFI_VERSION);
+       fbd->fw_cap.stored.undi.version = version;
+       fta_get_str(results, FBNIC_FW_CAP_RESP_UEFI_COMMIT_STR,
+                   fbd->fw_cap.stored.undi.commit,
+                   FBNIC_FW_CAP_RESP_COMMIT_MAX_SIZE);
+
+       fbd->fw_cap.active_slot =
+               fta_get_uint(results, FBNIC_FW_CAP_RESP_ACTIVE_FW_SLOT);
+       fbd->fw_cap.link_speed =
+               fta_get_uint(results, FBNIC_FW_CAP_RESP_FW_LINK_SPEED);
+       fbd->fw_cap.link_fec =
+               fta_get_uint(results, FBNIC_FW_CAP_RESP_FW_LINK_FEC);
 
        bmc_present = !!results[FBNIC_FW_CAP_RESP_BMC_PRESENT];
        if (bmc_present) {
@@ -575,7 +570,8 @@ static int fbnic_fw_parse_cap_resp(void *opaque, struct fbnic_tlv_msg **results)
                if (err)
                        return err;
 
-               get_unsigned_result(FBNIC_FW_CAP_RESP_BMC_ALL_MULTI, all_multi);
+               all_multi =
+                       fta_get_uint(results, FBNIC_FW_CAP_RESP_BMC_ALL_MULTI);
        } else {
                memset(fbd->fw_cap.bmc_mac_addr, 0,
                       sizeof(fbd->fw_cap.bmc_mac_addr));
@@ -754,32 +750,31 @@ static int fbnic_fw_parse_tsene_read_resp(void *opaque,
 {
        struct fbnic_fw_completion *cmpl_data;
        struct fbnic_dev *fbd = opaque;
+       s32 err_resp;
        int err = 0;
 
        /* Verify we have a completion pointer to provide with data */
        cmpl_data = fbnic_fw_get_cmpl_by_type(fbd,
                                              FBNIC_TLV_MSG_ID_TSENE_READ_RESP);
        if (!cmpl_data)
-               return -EINVAL;
+               return -ENOSPC;
 
-       if (results[FBNIC_FW_TSENE_ERROR]) {
-               err = fbnic_tlv_attr_get_unsigned(results[FBNIC_FW_TSENE_ERROR]);
-               if (err)
-                       goto exit_complete;
-       }
+       err_resp = fta_get_sint(results, FBNIC_FW_TSENE_ERROR);
+       if (err_resp)
+               goto msg_err;
 
        if (!results[FBNIC_FW_TSENE_THERM] || !results[FBNIC_FW_TSENE_VOLT]) {
                err = -EINVAL;
-               goto exit_complete;
+               goto msg_err;
        }
 
        cmpl_data->u.tsene.millidegrees =
-               fbnic_tlv_attr_get_signed(results[FBNIC_FW_TSENE_THERM]);
+               fta_get_sint(results, FBNIC_FW_TSENE_THERM);
        cmpl_data->u.tsene.millivolts =
-               fbnic_tlv_attr_get_signed(results[FBNIC_FW_TSENE_VOLT]);
+               fta_get_sint(results, FBNIC_FW_TSENE_VOLT);
 
-exit_complete:
-       cmpl_data->result = err;
+msg_err:
+       cmpl_data->result = err_resp ? : err;
        complete(&cmpl_data->done);
        fbnic_fw_put_cmpl(cmpl_data);
 

diff --git a/drivers/net/ethernet/meta/fbnic/fbnic_tlv.c b/drivers/net/ethernet/meta/fbnic/fbnic_tlv.c
index 400fb6c80053227a314d0d659beba850126b1531..d558d176e0dfc74bae2e6c7a952c6329cc3f0287 100644 (file)
--- a/drivers/net/ethernet/meta/fbnic/fbnic_tlv.c
+++ b/drivers/net/ethernet/meta/fbnic/fbnic_tlv.c
@@ -196,13 +196,17 @@ int fbnic_tlv_attr_put_string(struct fbnic_tlv_msg *msg, u16 attr_id,
 /**
  * fbnic_tlv_attr_get_unsigned - Retrieve unsigned value from result
  * @attr: Attribute to retrieve data from
+ * @def: The default value if attr is NULL
  *
  * Return: unsigned 64b value containing integer value
  **/
-u64 fbnic_tlv_attr_get_unsigned(struct fbnic_tlv_msg *attr)
+u64 fbnic_tlv_attr_get_unsigned(struct fbnic_tlv_msg *attr, u64 def)
 {
        __le64 le64_value = 0;
 
+       if (!attr)
+               return def;
+
        memcpy(&le64_value, &attr->value[0],
               le16_to_cpu(attr->hdr.len) - sizeof(*attr));
 
@@ -212,15 +216,21 @@ u64 fbnic_tlv_attr_get_unsigned(struct fbnic_tlv_msg *attr)
 /**
  * fbnic_tlv_attr_get_signed - Retrieve signed value from result
  * @attr: Attribute to retrieve data from
+ * @def: The default value if attr is NULL
  *
  * Return: signed 64b value containing integer value
  **/
-s64 fbnic_tlv_attr_get_signed(struct fbnic_tlv_msg *attr)
+s64 fbnic_tlv_attr_get_signed(struct fbnic_tlv_msg *attr, s64 def)
 {
-       int shift = (8 + sizeof(*attr) - le16_to_cpu(attr->hdr.len)) * 8;
        __le64 le64_value = 0;
+       int shift;
        s64 value;
 
+       if (!attr)
+               return def;
+
+       shift = (8 + sizeof(*attr) - le16_to_cpu(attr->hdr.len)) * 8;
+
        /* Copy the value and adjust for byte ordering */
        memcpy(&le64_value, &attr->value[0],
               le16_to_cpu(attr->hdr.len) - sizeof(*attr));

diff --git a/drivers/net/ethernet/meta/fbnic/fbnic_tlv.h b/drivers/net/ethernet/meta/fbnic/fbnic_tlv.h
index b29ed2649585243fee1ee321887243075fcd0f7c..c34bf87eeec9555e661d043dbf96e867a135360a 100644 (file)
--- a/drivers/net/ethernet/meta/fbnic/fbnic_tlv.h
+++ b/drivers/net/ethernet/meta/fbnic/fbnic_tlv.h
@@ -114,34 +114,10 @@ static inline bool fbnic_tlv_attr_get_bool(struct fbnic_tlv_msg *attr)
        return !!attr;
 }
 
-u64 fbnic_tlv_attr_get_unsigned(struct fbnic_tlv_msg *attr);
-s64 fbnic_tlv_attr_get_signed(struct fbnic_tlv_msg *attr);
+u64 fbnic_tlv_attr_get_unsigned(struct fbnic_tlv_msg *attr, u64 def);
+s64 fbnic_tlv_attr_get_signed(struct fbnic_tlv_msg *attr, s64 def);
 ssize_t fbnic_tlv_attr_get_string(struct fbnic_tlv_msg *attr, char *dst,
                                  size_t dstsize);
-
-#define get_unsigned_result(id, location) \
-do { \
-       struct fbnic_tlv_msg *result = results[id]; \
-       if (result) \
-               location = fbnic_tlv_attr_get_unsigned(result); \
-} while (0)
-
-#define get_signed_result(id, location) \
-do { \
-       struct fbnic_tlv_msg *result = results[id]; \
-       if (result) \
-               location = fbnic_tlv_attr_get_signed(result); \
-} while (0)
-
-#define get_string_result(id, size, str, max_size) \
-do { \
-       struct fbnic_tlv_msg *result = results[id]; \
-       if (result) \
-               size = fbnic_tlv_attr_get_string(result, str, max_size); \
-} while (0)
-
-#define get_bool(id) (!!(results[id]))
-
 struct fbnic_tlv_msg *fbnic_tlv_msg_alloc(u16 msg_id);
 int fbnic_tlv_attr_put_flag(struct fbnic_tlv_msg *msg, const u16 attr_id);
 int fbnic_tlv_attr_put_value(struct fbnic_tlv_msg *msg, const u16 attr_id,
@@ -170,6 +146,13 @@ int fbnic_tlv_msg_parse(void *opaque, struct fbnic_tlv_msg *msg,
                        const struct fbnic_tlv_parser *parser);
 int fbnic_tlv_parser_error(void *opaque, struct fbnic_tlv_msg **results);
 
+#define fta_get_uint(_results, _id) \
+       fbnic_tlv_attr_get_unsigned(_results[_id], 0)
+#define fta_get_sint(_results, _id) \
+       fbnic_tlv_attr_get_signed(_results[_id], 0)
+#define fta_get_str(_results, _id, _dst, _dstsize) \
+       fbnic_tlv_attr_get_string(_results[_id], _dst, _dstsize)
+
 #define FBNIC_TLV_MSG_ERROR \
        FBNIC_TLV_PARSER(UNKNOWN, NULL, fbnic_tlv_parser_error)
 #endif /* _FBNIC_TLV_H_ */