1 /* SPDX-License-Identifier: BSD-3-Clause 2 * see the individual elements. 3 * Copyright(c) 2019-2020 Broadcom 4 * All rights reserved. 5 */ 6 7 #include <rte_memcpy.h> 8 #include <rte_byteorder.h> 9 #include <rte_config.h> 10 #include <rte_mbuf.h> 11 #include <rte_ethdev.h> 12 #include <rte_lcore.h> 13 #include <rte_log.h> 14 #include <rte_errno.h> 15 #include <rte_malloc.h> 16 #include <rte_spinlock.h> 17 18 #include "tf_core.h" 19 #include "tfp.h" 20 #include "bnxt.h" 21 #include "bnxt_hwrm.h" 22 #include "tf_msg_common.h" 23 24 /** 25 * Sends TruFlow msg to the TruFlow Firmware using 26 * a message specific HWRM message type. 27 * 28 * Returns success or failure code. 29 */ 30 int 31 tfp_send_msg_direct(struct tf *tfp, 32 struct tfp_send_msg_parms *parms) 33 { 34 int rc = 0; 35 uint8_t use_kong_mb = 1; 36 37 if (parms == NULL) 38 return -EINVAL; 39 40 if (parms->mailbox == TF_CHIMP_MB) 41 use_kong_mb = 0; 42 43 rc = bnxt_hwrm_tf_message_direct(container_of(tfp, 44 struct bnxt, 45 tfp), 46 use_kong_mb, 47 parms->tf_type, 48 parms->req_data, 49 parms->req_size, 50 parms->resp_data, 51 parms->resp_size); 52 53 return rc; 54 } 55 56 /** 57 * Sends preformatted TruFlow msg to the TruFlow Firmware using 58 * the Truflow tunnel HWRM message type. 59 * 60 * Returns success or failure code. 61 */ 62 int 63 tfp_send_msg_tunneled(struct tf *tfp, 64 struct tfp_send_msg_parms *parms) 65 { 66 int rc = 0; 67 uint8_t use_kong_mb = 1; 68 69 if (parms == NULL) 70 return -EINVAL; 71 72 if (parms->mailbox == TF_CHIMP_MB) 73 use_kong_mb = 0; 74 75 rc = bnxt_hwrm_tf_message_tunneled(container_of(tfp, 76 struct bnxt, 77 tfp), 78 use_kong_mb, 79 parms->tf_type, 80 parms->tf_subtype, 81 &parms->tf_resp_code, 82 parms->req_data, 83 parms->req_size, 84 parms->resp_data, 85 parms->resp_size); 86 87 return rc; 88 } 89 90 #ifdef TF_USE_SYSTEM_MEM 91 int 92 tfp_msg_hwrm_oem_cmd(struct tf *tfp, 93 uint32_t max_flows) 94 { 95 return bnxt_hwrm_oem_cmd(container_of(tfp, 96 struct bnxt, 97 tfp), 98 max_flows); 99 } 100 #endif /* TF_USE_SYSTEM_MEM */ 101 102 /** 103 * Allocates zero'ed memory from the heap. 104 * 105 * Returns success or failure code. 106 */ 107 int 108 tfp_calloc(struct tfp_calloc_parms *parms) 109 { 110 if (parms == NULL) 111 return -EINVAL; 112 113 parms->mem_va = rte_zmalloc("tf", 114 (parms->nitems * parms->size), 115 parms->alignment); 116 if (parms->mem_va == NULL) { 117 TFP_DRV_LOG(ERR, "Allocate failed mem_va\n"); 118 return -ENOMEM; 119 } 120 121 parms->mem_pa = (void *)((uintptr_t)rte_mem_virt2iova(parms->mem_va)); 122 if (parms->mem_pa == (void *)((uintptr_t)RTE_BAD_IOVA)) { 123 TFP_DRV_LOG(ERR, "Allocate failed mem_pa\n"); 124 return -ENOMEM; 125 } 126 127 return 0; 128 } 129 130 /** 131 * Frees the memory space pointed to by the provided pointer. The 132 * pointer must have been returned from the tfp_calloc(). 133 */ 134 void 135 tfp_free(void *addr) 136 { 137 rte_free(addr); 138 } 139 140 /** 141 * Copies n bytes from src memory to dest memory. The memory areas 142 * must not overlap. 143 */ 144 void 145 tfp_memcpy(void *dest, void *src, size_t n) 146 { 147 rte_memcpy(dest, src, n); 148 } 149 150 /** 151 * Used to initialize portable spin lock 152 */ 153 void 154 tfp_spinlock_init(struct tfp_spinlock_parms *parms) 155 { 156 rte_spinlock_init(&parms->slock); 157 } 158 159 /** 160 * Used to lock portable spin lock 161 */ 162 void 163 tfp_spinlock_lock(struct tfp_spinlock_parms *parms) 164 { 165 rte_spinlock_lock(&parms->slock); 166 } 167 168 /** 169 * Used to unlock portable spin lock 170 */ 171 void 172 tfp_spinlock_unlock(struct tfp_spinlock_parms *parms) 173 { 174 rte_spinlock_unlock(&parms->slock); 175 } 176 177 int 178 tfp_get_fid(struct tf *tfp, uint16_t *fw_fid) 179 { 180 struct bnxt *bp = NULL; 181 182 if (tfp == NULL || fw_fid == NULL) 183 return -EINVAL; 184 185 bp = container_of(tfp, struct bnxt, tfp); 186 if (bp == NULL) 187 return -EINVAL; 188 189 *fw_fid = bp->fw_fid; 190 191 return 0; 192 } 193