From patchwork Tue Mar 17 15:38:15 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Venkat Duvvuru X-Patchwork-Id: 66801 X-Patchwork-Delegate: ajit.khaparde@broadcom.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 36EEEA0565; Tue, 17 Mar 2020 16:43:22 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 905941C13B; Tue, 17 Mar 2020 16:39:38 +0100 (CET) Received: from mail-wr1-f65.google.com (mail-wr1-f65.google.com [209.85.221.65]) by dpdk.org (Postfix) with ESMTP id 471B01C13B for ; Tue, 17 Mar 2020 16:39:37 +0100 (CET) Received: by mail-wr1-f65.google.com with SMTP id f11so9509462wrp.8 for ; Tue, 17 Mar 2020 08:39:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=broadcom.com; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=DXF9yRrjT04Y6tZe43sX8pRoZaHXHH1M/m1syFJkFdc=; b=a5tZQj8PBWQoqMBr4dEr7we4WFLqOkC945wZRFCv8FIOLLi9bcWEn9rB0I+KcBfbNc tAbzb25NhriHNgM6mot2qCTa7IkqPtRXcLprzJFD8bw2WOATAQOu2RK5Eg0Av9aygNBR mxRGbDuTMTtiL63RU9UcDI/AulOByH6Dzn/5s= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=DXF9yRrjT04Y6tZe43sX8pRoZaHXHH1M/m1syFJkFdc=; b=py8ZMtkJ//knDOiazGt08jDTwneDlj0f6DsAsUfC2Kesvs5YzWzu/VFjr9JPWI8dgs JXg02sxGYRbkf8tPIxzbN7p534yKeJYAgvJ+RpWR/phXdpNyc7bezC6MRCcBQyDfEj8L eaMT3yRiOc9YF9Cr1sJxkiWs86pNnFT2sJX+BdrdPxxCaLD9D03SoEVgxIDEvg+H39qB z0BwZ1GZy+A5KgmUH1y6f/VHsjZBdNzV+rbuYx9PVHkrWK8RmU1HeCamlkacNUt7NKDh fdgY8nyU/AcQ5mvRrBxsc4d+lxteg7M2M2QQ0nDiWVyv5S5mToFFEQJ1kQROMqOMA7cx /rng== X-Gm-Message-State: ANhLgQ1DFqbUlGpvwl4kOnsUlRcRcytDjy3iR7x+JXYsUaDKRfUrA5Py vVis5VNzO2h/Kb9ZvejEgD9o4f58Hg4fujZXVIcHujBfAJ8DPyo+gQsgISLQtQ081EWtmNRp6S5 0Wp/uRpCXpnQLW4q7LkK8dZf6wx+NSUBDyG0LdNg2IDspDVICq+PW85meQ+RiDsroYhky X-Google-Smtp-Source: ADFU+vvZtoncDeYZCN6ATGwT67sJbhctDUpCTS30DBfk2+U2c3bpQGf5GZ9teubJsrUOKnHDtc4Imw== X-Received: by 2002:a5d:420c:: with SMTP id n12mr6711112wrq.173.1584459576078; Tue, 17 Mar 2020 08:39:36 -0700 (PDT) Received: from S60.dhcp.broadcom.net ([192.19.234.250]) by smtp.gmail.com with ESMTPSA id q4sm5052142wro.56.2020.03.17.08.39.33 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 17 Mar 2020 08:39:35 -0700 (PDT) From: Venkat Duvvuru To: dev@dpdk.org Cc: Mike Baucom , Kishore Padmanabha , Venkat Duvvuru Date: Tue, 17 Mar 2020 21:08:15 +0530 Message-Id: <1584459511-5353-18-git-send-email-venkatkumar.duvvuru@broadcom.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1584459511-5353-1-git-send-email-venkatkumar.duvvuru@broadcom.com> References: <1584459511-5353-1-git-send-email-venkatkumar.duvvuru@broadcom.com> Subject: [dpdk-dev] [PATCH 17/33] net/bnxt: add helper functions for blob/regfile ops X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Mike Baucom 1. blob routines for managing key/mask/result data 2. regfile routines for managing temporal data during flow construction Signed-off-by: Mike Baucom Signed-off-by: Kishore Padmanabha Signed-off-by: Venkat Duvvuru Reviewed-by: Lance Richardson Reviewed-by: Ajit Kumar Khaparde --- drivers/net/bnxt/Makefile | 1 + drivers/net/bnxt/tf_ulp/ulp_template_db.h | 12 + drivers/net/bnxt/tf_ulp/ulp_utils.c | 521 ++++++++++++++++++++++++++++++ drivers/net/bnxt/tf_ulp/ulp_utils.h | 279 ++++++++++++++++ 4 files changed, 813 insertions(+) create mode 100644 drivers/net/bnxt/tf_ulp/ulp_utils.c create mode 100644 drivers/net/bnxt/tf_ulp/ulp_utils.h diff --git a/drivers/net/bnxt/Makefile b/drivers/net/bnxt/Makefile index 87c61bf..dcf1eb4 100644 --- a/drivers/net/bnxt/Makefile +++ b/drivers/net/bnxt/Makefile @@ -61,6 +61,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_BNXT_TRUFLOW) += tf_ulp/bnxt_ulp.c SRCS-$(CONFIG_RTE_LIBRTE_BNXT_TRUFLOW) += tf_ulp/ulp_mark_mgr.c SRCS-$(CONFIG_RTE_LIBRTE_BNXT_TRUFLOW) += tf_ulp/ulp_flow_db.c SRCS-$(CONFIG_RTE_LIBRTE_BNXT_TRUFLOW) += tf_ulp/ulp_template_db.c +SRCS-$(CONFIG_RTE_LIBRTE_BNXT_TRUFLOW) += tf_ulp/ulp_utils.c # # Export include files # diff --git a/drivers/net/bnxt/tf_ulp/ulp_template_db.h b/drivers/net/bnxt/tf_ulp/ulp_template_db.h index ba2a101..1eed828 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_template_db.h +++ b/drivers/net/bnxt/tf_ulp/ulp_template_db.h @@ -27,6 +27,18 @@ enum bnxt_ulp_device_id { BNXT_ULP_DEVICE_ID_LAST }; +enum bnxt_ulp_fmf_mask { + BNXT_ULP_FMF_MASK_IGNORE, + BNXT_ULP_FMF_MASK_ANY, + BNXT_ULP_FMF_MASK_EXACT, + BNXT_ULP_FMF_MASK_WILDCARD, + BNXT_ULP_FMF_MASK_LAST +}; + +enum bnxt_ulp_regfile_index { + BNXT_ULP_REGFILE_INDEX_LAST +}; + enum bnxt_ulp_sym { BNXT_ULP_SYM_LITTLE_ENDIAN = 1, BNXT_ULP_SYM_YES = 1 diff --git a/drivers/net/bnxt/tf_ulp/ulp_utils.c b/drivers/net/bnxt/tf_ulp/ulp_utils.c new file mode 100644 index 0000000..0d38cf3 --- /dev/null +++ b/drivers/net/bnxt/tf_ulp/ulp_utils.c @@ -0,0 +1,521 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2014-2019 Broadcom + * All rights reserved. + */ + +#include "ulp_utils.h" +#include "bnxt_tf_common.h" + +/* + * Initialize the regfile structure for writing + * + * regfile [in] Ptr to a regfile instance + * + * returns 0 on error or 1 on success + */ +uint32_t +ulp_regfile_init(struct ulp_regfile *regfile) +{ + /* validate the arguments */ + if (!regfile) { + BNXT_TF_DBG(ERR, "invalid argument\n"); + return 0; /* failure */ + } + memset(regfile, 0, sizeof(struct ulp_regfile)); + return 1; /* Success */ +} + +/* + * Read a value from the regfile + * + * regfile [in] The regfile instance. Must be initialized prior to being used + * + * field [in] The field to be read within the regfile. + * + * data [in/out] + * + * returns size, zero on failure + */ +uint32_t +ulp_regfile_read(struct ulp_regfile *regfile, + enum bnxt_ulp_regfile_index field, + uint64_t *data) +{ + /* validate the arguments */ + if (!regfile || field >= BNXT_ULP_REGFILE_INDEX_LAST) { + BNXT_TF_DBG(ERR, "invalid argument\n"); + return 0; /* failure */ + } + + *data = regfile->entry[field].data; + return sizeof(*data); +} + +/* + * Write a value to the regfile + * + * regfile [in] The regfile instance. Must be initialized prior to being used + * + * field [in] The field to be written within the regfile. + * + * data [in] The value is written into this variable. It is going to be in the + * same byte order as it was written. + * + * size [in] The size in bytes of the value beingritten into this + * variable. + * + * returns 0 on fail + */ +uint32_t +ulp_regfile_write(struct ulp_regfile *regfile, + enum bnxt_ulp_regfile_index field, + uint64_t data) +{ + /* validate the arguments */ + if (!regfile || field >= BNXT_ULP_REGFILE_INDEX_LAST || field < 0) { + BNXT_TF_DBG(ERR, "invalid argument\n"); + return 0; /* failure */ + } + + regfile->entry[field].data = data; + return sizeof(data); /* Success */ +} + +static void +ulp_bs_put_msb(uint8_t *bs, uint16_t bitpos, uint8_t bitlen, uint8_t val) +{ + uint8_t bitoffs = bitpos % 8; + uint16_t index = bitpos / 8; + uint8_t mask; + uint8_t tmp; + int8_t shift; + + tmp = bs[index]; + mask = ((uint8_t)-1 >> (8 - bitlen)); + shift = 8 - bitoffs - bitlen; + val &= mask; + + if (shift >= 0) { + tmp &= ~(mask << shift); + tmp |= val << shift; + bs[index] = tmp; + } else { + tmp &= ~((uint8_t)-1 >> bitoffs); + tmp |= val >> -shift; + bs[index++] = tmp; + + tmp = bs[index]; + tmp &= ((uint8_t)-1 >> (bitlen - (8 - bitoffs))); + tmp |= val << (8 + shift); + bs[index] = tmp; + } +} + +static void +ulp_bs_put_lsb(uint8_t *bs, uint16_t bitpos, uint8_t bitlen, uint8_t val) +{ + uint8_t bitoffs = bitpos % 8; + uint16_t index = bitpos / 8; + uint8_t mask; + uint8_t tmp; + uint8_t shift; + uint8_t partial; + + tmp = bs[index]; + shift = bitoffs; + + if (bitoffs + bitlen <= 8) { + mask = ((1 << bitlen) - 1) << shift; + tmp &= ~mask; + tmp |= ((val << shift) & mask); + bs[index] = tmp; + } else { + partial = 8 - bitoffs; + mask = ((1 << partial) - 1) << shift; + tmp &= ~mask; + tmp |= ((val << shift) & mask); + bs[index++] = tmp; + + val >>= partial; + partial = bitlen - partial; + mask = ((1 << partial) - 1); + tmp = bs[index]; + tmp &= ~mask; + tmp |= (val & mask); + bs[index] = tmp; + } +} + +/* Assuming that val is in Big-Endian Format */ +static uint32_t +ulp_bs_push_lsb(uint8_t *bs, uint16_t pos, uint8_t len, uint8_t *val) +{ + int i; + int cnt = (len) / 8; + int tlen = len; + + if (cnt > 0 && !(len % 8)) + cnt -= 1; + + for (i = 0; i < cnt; i++) { + ulp_bs_put_lsb(bs, pos, 8, val[cnt - i]); + pos += 8; + tlen -= 8; + } + + /* Handle the remainder bits */ + if (tlen) + ulp_bs_put_lsb(bs, pos, tlen, val[0]); + return len; +} + +/* Assuming that val is in Big-Endian Format */ +static uint32_t +ulp_bs_push_msb(uint8_t *bs, uint16_t pos, uint8_t len, uint8_t *val) +{ + int i; + int cnt = (len + 7) / 8; + int tlen = len; + + /* Handle any remainder bits */ + int tmp = len % 8; + + if (!tmp) + tmp = 8; + + ulp_bs_put_msb(bs, pos, tmp, val[0]); + + pos += tmp; + tlen -= tmp; + + for (i = 1; i < cnt; i++) { + ulp_bs_put_msb(bs, pos, 8, val[i]); + pos += 8; + tlen -= 8; + } + + return len; +} + +/* + * Initializes the blob structure for creating binary blob + * + * blob [in] The blob to be initialized + * + * bitlen [in] The bit length of the blob + * + * order [in] The byte order for the blob. Currently only supporting + * big endian. All fields are packed with this order. + * + * returns 0 on error or 1 on success + */ +uint32_t +ulp_blob_init(struct ulp_blob *blob, + uint16_t bitlen, + enum bnxt_ulp_byte_order order) +{ + /* validate the arguments */ + if (!blob || bitlen > (8 * sizeof(blob->data))) { + BNXT_TF_DBG(ERR, "invalid argument\n"); + return 0; /* failure */ + } + blob->bitlen = bitlen; + blob->byte_order = order; + blob->write_idx = 0; + memset(blob->data, 0, sizeof(blob->data)); + return 1; /* Success */ +} + +/* + * Add data to the binary blob at the current offset. + * + * blob [in] The blob that data is added to. The blob must + * be initialized prior to pushing data. + * + * data [in] A pointer to bytes to be added to the blob. + * + * datalen [in] The number of bits to be added ot the blob. + * + * The offset of the data is updated after each push of data. + * NULL returned on error. + */ +#define ULP_BLOB_BYTE 8 +#define ULP_BLOB_BYTE_HEX 0xFF +#define BLOB_MASK_CAL(x) ((0xFF << (x)) & 0xFF) +uint32_t +ulp_blob_push(struct ulp_blob *blob, + uint8_t *data, + uint32_t datalen) +{ + uint32_t rc; + + /* validate the arguments */ + if (!blob || datalen > (uint32_t)(blob->bitlen - blob->write_idx)) { + BNXT_TF_DBG(ERR, "invalid argument\n"); + return 0; /* failure */ + } + + if (blob->byte_order == BNXT_ULP_BYTE_ORDER_BE) + rc = ulp_bs_push_msb(blob->data, + blob->write_idx, + datalen, + data); + else + rc = ulp_bs_push_lsb(blob->data, + blob->write_idx, + datalen, + data); + if (!rc) { + BNXT_TF_DBG(ERR, "Failed ro write blob\n"); + return 0; + } + blob->write_idx += datalen; + return datalen; +} + +/* + * Add data to the binary blob at the current offset. + * + * blob [in] The blob that data is added to. The blob must + * be initialized prior to pushing data. + * + * data [in] 64-bit value to be added to the blob. + * + * datalen [in] The number of bits to be added ot the blob. + * + * The offset of the data is updated after each push of data. + * NULL returned on error, pointer pushed value otherwise. + */ +uint8_t * +ulp_blob_push_64(struct ulp_blob *blob, + uint64_t *data, + uint32_t datalen) +{ + uint8_t *val = (uint8_t *)data; + int rc; + + int size = (datalen + 7) / 8; + + if (!blob || !data || + datalen > (uint32_t)(blob->bitlen - blob->write_idx)) { + BNXT_TF_DBG(ERR, "invalid argument\n"); + return 0; + } + + rc = ulp_blob_push(blob, &val[8 - size], datalen); + if (!rc) + return 0; + + return &val[8 - size]; +} + +/* + * Add encap data to the binary blob at the current offset. + * + * blob [in] The blob that data is added to. The blob must + * be initialized prior to pushing data. + * + * data [in] value to be added to the blob. + * + * datalen [in] The number of bits to be added ot the blob. + * + * The offset of the data is updated after each push of data. + * NULL returned on error, pointer pushed value otherwise. + */ +uint32_t +ulp_blob_push_encap(struct ulp_blob *blob, + uint8_t *data, + uint32_t datalen) +{ + uint8_t *val = (uint8_t *)data; + uint32_t initial_size, write_size = datalen; + uint32_t size = 0; + + if (!blob || !data || + datalen > (uint32_t)(blob->bitlen - blob->write_idx)) { + BNXT_TF_DBG(ERR, "invalid argument\n"); + return 0; + } + + initial_size = ULP_BYTE_2_BITS(sizeof(uint64_t)) - + (blob->write_idx % ULP_BYTE_2_BITS(sizeof(uint64_t))); + while (write_size > 0) { + if (initial_size && write_size > initial_size) { + size = initial_size; + initial_size = 0; + } else if (initial_size && write_size <= initial_size) { + size = write_size; + initial_size = 0; + } else if (write_size > ULP_BYTE_2_BITS(sizeof(uint64_t))) { + size = ULP_BYTE_2_BITS(sizeof(uint64_t)); + } else { + size = write_size; + } + if (!ulp_blob_push(blob, val, size)) { + BNXT_TF_DBG(ERR, "push field failed\n"); + return 0; + } + val += ULP_BITS_2_BYTE(size); + write_size -= size; + } + return datalen; +} + +/* + * Adds pad to an initialized blob at the current offset + * + * blob [in] The blob that data is added to. The blob must + * be initialized prior to pushing data. + * + * datalen [in] The number of bits of pad to add + * + * returns the number of pad bits added, zero on failure + */ +uint32_t +ulp_blob_pad_push(struct ulp_blob *blob, + uint32_t datalen) +{ + if (datalen > (uint32_t)(blob->bitlen - blob->write_idx)) { + BNXT_TF_DBG(ERR, "Pad too large for blob\n"); + return 0; + } + + blob->write_idx += datalen; + return datalen; +} + +/* + * Get the data portion of the binary blob. + * + * blob [in] The blob's data to be retrieved. The blob must be + * initialized prior to pushing data. + * + * datalen [out] The number of bits to that are filled. + * + * returns a byte array of the blob data. Returns NULL on error. + */ +uint8_t * +ulp_blob_data_get(struct ulp_blob *blob, + uint16_t *datalen) +{ + /* validate the arguments */ + if (!blob) { + BNXT_TF_DBG(ERR, "invalid argument\n"); + return NULL; /* failure */ + } + *datalen = blob->write_idx; + return blob->data; +} + +/* + * Set the encap swap start index of the binary blob. + * + * blob [in] The blob's data to be retrieved. The blob must be + * initialized prior to pushing data. + * + * returns void. + */ +void +ulp_blob_encap_swap_idx_set(struct ulp_blob *blob) +{ + /* validate the arguments */ + if (!blob) { + BNXT_TF_DBG(ERR, "invalid argument\n"); + return; /* failure */ + } + blob->encap_swap_idx = blob->write_idx; +} + +/* + * Perform the encap buffer swap to 64 bit reversal. + * + * blob [in] The blob's data to be used for swap. + * + * returns void. + */ +void +ulp_blob_perform_encap_swap(struct ulp_blob *blob) +{ + uint32_t i, idx = 0, end_idx = 0; + uint8_t temp_val_1, temp_val_2; + + /* validate the arguments */ + if (!blob) { + BNXT_TF_DBG(ERR, "invalid argument\n"); + return; /* failure */ + } + idx = ULP_BITS_2_BYTE_NR(blob->encap_swap_idx + 1); + end_idx = ULP_BITS_2_BYTE(blob->write_idx); + + while (idx <= end_idx) { + for (i = 0; i < 4; i = i + 2) { + temp_val_1 = blob->data[idx + i]; + temp_val_2 = blob->data[idx + i + 1]; + blob->data[idx + i] = blob->data[idx + 6 - i]; + blob->data[idx + i + 1] = blob->data[idx + 7 - i]; + blob->data[idx + 7 - i] = temp_val_2; + blob->data[idx + 6 - i] = temp_val_1; + } + idx += 8; + } +} + +/* + * Read data from the operand + * + * operand [in] A pointer to a 16 Byte operand + * + * val [in/out] The variable to copy the operand to + * + * bytes [in] The number of bytes to read into val + * + * returns number of bits read, zero on error + */ +uint16_t +ulp_operand_read(uint8_t *operand, + uint8_t *val, + uint16_t bytes) +{ + /* validate the arguments */ + if (!operand || !val) { + BNXT_TF_DBG(ERR, "invalid argument\n"); + return 0; /* failure */ + } + memcpy(val, operand, bytes); + return bytes; +} + +/* + * copy the buffer in the encap format which is 2 bytes. + * The MSB of the src is placed at the LSB of dst. + * + * dst [out] The destination buffer + * src [in] The source buffer dst + * size[in] size of the buffer. + */ +void +ulp_encap_buffer_copy(uint8_t *dst, + const uint8_t *src, + uint16_t size) +{ + uint16_t idx = 0; + + /* copy 2 bytes at a time. Write MSB to LSB */ + while ((idx + sizeof(uint16_t)) <= size) { + memcpy(&dst[idx], &src[size - idx - sizeof(uint16_t)], + sizeof(uint16_t)); + idx += sizeof(uint16_t); + } +} + +/* + * Check the buffer is empty + * + * buf [in] The buffer + * size [in] The size of the buffer + * + */ +int32_t ulp_buffer_is_empty(const uint8_t *buf, uint32_t size) +{ + return buf[0] == 0 && !memcmp(buf, buf + 1, size - 1); +} diff --git a/drivers/net/bnxt/tf_ulp/ulp_utils.h b/drivers/net/bnxt/tf_ulp/ulp_utils.h new file mode 100644 index 0000000..db88546 --- /dev/null +++ b/drivers/net/bnxt/tf_ulp/ulp_utils.h @@ -0,0 +1,279 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2014-2019 Broadcom + * All rights reserved. + */ + +#ifndef _ULP_UTILS_H_ +#define _ULP_UTILS_H_ + +#include "bnxt.h" +#include "ulp_template_db.h" + +/* + * Macros for bitmap sets and gets + * These macros can be used if the val are power of 2. + */ +#define ULP_BITMAP_SET(bitmap, val) ((bitmap) |= (val)) +#define ULP_BITMAP_RESET(bitmap, val) ((bitmap) &= ~(val)) +#define ULP_BITMAP_ISSET(bitmap, val) ((bitmap) & (val)) +#define ULP_BITSET_CMP(b1, b2) memcmp(&(b1)->bits, \ + &(b2)->bits, sizeof((b1)->bits)) +/* + * Macros for bitmap sets and gets + * These macros can be used if the val are not power of 2 and + * are simple index values. + */ +#define ULP_INDEX_BITMAP_SIZE (sizeof(uint64_t) * 8) +#define ULP_INDEX_BITMAP_CSET(i) (1UL << \ + ((ULP_INDEX_BITMAP_SIZE - 1) - \ + ((i) % ULP_INDEX_BITMAP_SIZE))) + +#define ULP_INDEX_BITMAP_SET(b, i) ((b) |= \ + (1UL << ((ULP_INDEX_BITMAP_SIZE - 1) - \ + ((i) % ULP_INDEX_BITMAP_SIZE)))) + +#define ULP_INDEX_BITMAP_RESET(b, i) ((b) &= \ + (~(1UL << ((ULP_INDEX_BITMAP_SIZE - 1) - \ + ((i) % ULP_INDEX_BITMAP_SIZE))))) + +#define ULP_INDEX_BITMAP_GET(b, i) (((b) >> \ + ((ULP_INDEX_BITMAP_SIZE - 1) - \ + ((i) % ULP_INDEX_BITMAP_SIZE))) & 1) + +#define ULP_DEVICE_PARAMS_INDEX(tid, dev_id) \ + (((tid) << BNXT_ULP_LOG2_MAX_NUM_DEV) | (dev_id)) + +/* Macro to convert bytes to bits */ +#define ULP_BYTE_2_BITS(byte_x) ((byte_x) * 8) +/* Macro to convert bits to bytes */ +#define ULP_BITS_2_BYTE(bits_x) (((bits_x) + 7) / 8) +/* Macro to convert bits to bytes with no round off*/ +#define ULP_BITS_2_BYTE_NR(bits_x) ((bits_x) / 8) + +/* + * Making the blob statically sized to 128 bytes for now. + * The blob must be initialized with ulp_blob_init prior to using. + */ +#define BNXT_ULP_FLMP_BLOB_SIZE (128) +#define BNXT_ULP_FLMP_BLOB_SIZE_IN_BITS ULP_BYTE_2_BITS(BNXT_ULP_FLMP_BLOB_SIZE) +struct ulp_blob { + enum bnxt_ulp_byte_order byte_order; + uint16_t write_idx; + uint16_t bitlen; + uint8_t data[BNXT_ULP_FLMP_BLOB_SIZE]; + uint16_t encap_swap_idx; +}; + +/* + * The data can likely be only 32 bits for now. Just size check + * the data when being written. + */ +#define ULP_REGFILE_ENTRY_SIZE (sizeof(uint32_t)) +struct ulp_regfile_entry { + uint64_t data; + uint32_t size; +}; + +struct ulp_regfile { + struct ulp_regfile_entry entry[BNXT_ULP_REGFILE_INDEX_LAST]; +}; + +/* + * Initialize the regfile structure for writing + * + * regfile [in] Ptr to a regfile instance + * + * returns 0 on error or 1 on success + */ +uint32_t +ulp_regfile_init(struct ulp_regfile *regfile); + +/* + * Read a value from the regfile + * + * regfile [in] The regfile instance. Must be initialized prior to being used + * + * field [in] The field to be read within the regfile. + * + * returns the byte array + */ +uint32_t +ulp_regfile_read(struct ulp_regfile *regfile, + enum bnxt_ulp_regfile_index field, + uint64_t *data); + +/* + * Write a value to the regfile + * + * regfile [in] The regfile instance. Must be initialized prior to being used + * + * field [in] The field to be written within the regfile. + * + * data [in] The value is written into this variable. It is going to be in the + * same byte order as it was written. + * + * returns zero on error + */ +uint32_t +ulp_regfile_write(struct ulp_regfile *regfile, + enum bnxt_ulp_regfile_index field, + uint64_t data); + +/* + * Initializes the blob structure for creating binary blob + * + * blob [in] The blob to be initialized + * + * bitlen [in] The bit length of the blob + * + * order [in] The byte order for the blob. Currently only supporting + * big endian. All fields are packed with this order. + * + * returns 0 on error or 1 on success + */ +uint32_t +ulp_blob_init(struct ulp_blob *blob, + uint16_t bitlen, + enum bnxt_ulp_byte_order order); + +/* + * Add data to the binary blob at the current offset. + * + * blob [in] The blob that data is added to. The blob must + * be initialized prior to pushing data. + * + * data [in] A pointer to bytes to be added to the blob. + * + * datalen [in] The number of bits to be added ot the blob. + * + * The offset of the data is updated after each push of data. + * NULL returned on error. + */ +uint32_t +ulp_blob_push(struct ulp_blob *blob, + uint8_t *data, + uint32_t datalen); + +/* + * Add data to the binary blob at the current offset. + * + * blob [in] The blob that data is added to. The blob must + * be initialized prior to pushing data. + * + * data [in] 64-bit value to be added to the blob. + * + * datalen [in] The number of bits to be added ot the blob. + * + * The offset of the data is updated after each push of data. + * NULL returned on error, ptr to pushed data otherwise + */ +uint8_t * +ulp_blob_push_64(struct ulp_blob *blob, + uint64_t *data, + uint32_t datalen); + +/* + * Add encap data to the binary blob at the current offset. + * + * blob [in] The blob that data is added to. The blob must + * be initialized prior to pushing data. + * + * data [in] value to be added to the blob. + * + * datalen [in] The number of bits to be added ot the blob. + * + * The offset of the data is updated after each push of data. + * NULL returned on error, pointer pushed value otherwise. + */ +uint32_t +ulp_blob_push_encap(struct ulp_blob *blob, + uint8_t *data, + uint32_t datalen); + +/* + * Get the data portion of the binary blob. + * + * blob [in] The blob's data to be retrieved. The blob must be + * initialized prior to pushing data. + * + * datalen [out] The number of bits to that are filled. + * + * returns a byte array of the blob data. Returns NULL on error. + */ +uint8_t * +ulp_blob_data_get(struct ulp_blob *blob, + uint16_t *datalen); + +/* + * Adds pad to an initialized blob at the current offset + * + * blob [in] The blob that data is added to. The blob must + * be initialized prior to pushing data. + * + * datalen [in] The number of bits of pad to add + * + * returns the number of pad bits added, zero on failure + */ +uint32_t +ulp_blob_pad_push(struct ulp_blob *blob, + uint32_t datalen); + +/* + * Set the 64 bit swap start index of the binary blob. + * + * blob [in] The blob's data to be retrieved. The blob must be + * initialized prior to pushing data. + * + * returns void. + */ +void +ulp_blob_encap_swap_idx_set(struct ulp_blob *blob); + +/* + * Perform the encap buffer swap to 64 bit reversal. + * + * blob [in] The blob's data to be used for swap. + * + * returns void. + */ +void +ulp_blob_perform_encap_swap(struct ulp_blob *blob); + +/* + * Read data from the operand + * + * operand [in] A pointer to a 16 Byte operand + * + * val [in/out] The variable to copy the operand to + * + * bitlen [in] The number of bits to read into val + * + * returns number of bits read, zero on error + */ +uint16_t +ulp_operand_read(uint8_t *operand, + uint8_t *val, + uint16_t bitlen); + +/* + * copy the buffer in the encap format which is 2 bytes. + * The MSB of the src is placed at the LSB of dst. + * + * dst [out] The destination buffer + * src [in] The source buffer dst + * size[in] size of the buffer. + */ +void +ulp_encap_buffer_copy(uint8_t *dst, + const uint8_t *src, + uint16_t size); + +/* + * Check the buffer is empty + * + * buf [in] The buffer + * size [in] The size of the buffer + */ +int32_t ulp_buffer_is_empty(const uint8_t *buf, uint32_t size); + +#endif /* _ULP_UTILS_H_ */