udf_common.h (11034B)
1 /* 2 * 3 * 4 * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file. 5 * 6 * Copyright 2007-2020 Broadcom Inc. All rights reserved. 7 */ 8 #ifndef __BCM_INT_UDF_COMMON_H__ 9 #define __BCM_INT_UDF_COMMON_H__ 10 11 #include <bcm/types.h> 12 #include <soc/drv.h> 13 #include <soc/error.h> 14 #include <soc/scache.h> 15 #include <bcm/module.h> 16 #include <bcm_int/esw/switch.h> 17 18 /* 19 * Macro: 20 * _BCM_UDF_LOCK 21 * Purpose: 22 * Take the UDF control mutex lock. 23 */ 24 #define _BCM_UDF_LOCK(unit) \ 25 sal_mutex_take(SOC_CONTROL(unit)->udf_lock, sal_mutex_FOREVER) 26 27 /* 28 * Macro: 29 * _BCM_UDF_UNLOCK 30 * Purpose: 31 * Give the UDF control mutex lock. 32 */ 33 #define _BCM_UDF_UNLOCK(unit) \ 34 sal_mutex_give(SOC_CONTROL(unit)->udf_lock); 35 36 37 /* Generic memory allocation routine. */ 38 #define _BCM_UDF_ALLOC(_ptr_,_size_of_,_descr_) \ 39 do { \ 40 if (NULL == (_ptr_)) { \ 41 (_ptr_) = sal_alloc((_size_of_), (_descr_)); \ 42 } \ 43 if((_ptr_) != NULL) { \ 44 uint32 _size_ = _size_of_; \ 45 sal_memset((_ptr_), 0, (_size_)); \ 46 LOG_DEBUG(BSL_LS_BCM_UDF, (BSL_META_U(unit, \ 47 "UDF Mem Alloc: Addr:%p bytes:%u '%s'\n\r"), \ 48 _ptr_, _size_, _descr_)); \ 49 } else { \ 50 LOG_ERROR(BSL_LS_BCM_UDF, (BSL_META_U(unit, \ 51 "UDF Mem Alloc failure: %s\n\r"), (_descr_))); \ 52 } \ 53 } while (0) 54 55 #define _BCM_UDF_FREE(_ptr_) \ 56 do { \ 57 if (NULL != (_ptr_)) { \ 58 LOG_DEBUG(BSL_LS_BCM_UDF, (BSL_META_U(unit, \ 59 "UDF Mem Free: Addr:%p\n\r"), _ptr_)); \ 60 sal_free((_ptr_)); \ 61 _ptr_ = NULL; \ 62 } else { \ 63 LOG_ERROR(BSL_LS_BCM_UDF, (BSL_META_U(unit, \ 64 "UDF Error: Freeing NULL Ptr.\n\r"))); \ 65 } \ 66 } while (0) 67 68 69 70 /********************** Linked-List Macros ***********************/ 71 /* Double Linked-list node add */ 72 #define _UDF_DLL_NODE_ADD(_u_, _new_, _head_) \ 73 do { \ 74 if (_new_ != NULL) { \ 75 /* Add new node at the tail of the head */ \ 76 if (NULL == _head_) { \ 77 /* Adding first node */ \ 78 _head_ = _new_; \ 79 } else { \ 80 _head_->next = _new_; \ 81 (_new_)->prev = _head_; \ 82 _head_ = _new_; \ 83 } \ 84 } \ 85 } while (0) 86 87 /* Double Linked-list node delete */ 88 #define _UDF_DLL_NODE_DEL(_u_, _del_, _head_, _temp_) \ 89 do { \ 90 _temp_ = _head_; \ 91 if ((_del_ != NULL) && (_head_ != NULL)) { \ 92 while(_temp_ != NULL) { \ 93 if (_del_ == _temp_) { \ 94 if ((void *)_temp_->prev != NULL) { \ 95 _temp_->prev->next = _del_->next; \ 96 } \ 97 if ((void *)_temp_->next != NULL) { \ 98 _temp_->next->prev = _del_->prev; \ 99 } \ 100 if (_head_ == _temp_) { \ 101 _head_ = _temp_->prev; \ 102 } \ 103 break; \ 104 } \ 105 _temp_ = _temp_->prev; \ 106 } \ 107 } \ 108 } while (0) 109 110 /* Double Linked-list node Get */ 111 #define _UDF_DLL_NODE_GET(_u_, _id_, _head_, _temp_, _node_) \ 112 do { \ 113 _node_ = NULL; \ 114 (_temp_) = _head_; \ 115 while ((_temp_) != NULL) { \ 116 if (_temp_->udf_id == _id_) { \ 117 _node_ = _temp_; \ 118 break; \ 119 } \ 120 _temp_ = _temp_->prev; \ 121 } \ 122 } while(0) 123 /*****************************************************************/ 124 125 /* Offset Chunk Granularity */ 126 #define _BCM_UDF_OFFSET_GRAN2 2 127 128 /* Max number of UDF Chunks Supported */ 129 #define _BCM_UDF_OFFSET_CHUNKS16 16 130 131 132 /* 133 * Typedef: 134 * _bcm_udf_funct_t 135 * Purpose: 136 * Function pointers to device specific Field functions 137 */ 138 typedef struct _bcm_udf_funct_s { 139 int(*udf_init)(int); /* Initialization function */ 140 int(*udf_detach)(int); /* detach function */ 141 int(*udf_chunk_create)( /* UDF Chunk create */ 142 int, 143 bcm_udf_alloc_hints_t *, 144 bcm_udf_chunk_info_t *, 145 bcm_udf_id_t *); 146 int(*udf_destroy)(int, bcm_udf_id_t); /* UDF destroy */ 147 int(*udf_chunk_info_get)( /* UDF Chunk get */ 148 int, 149 bcm_udf_id_t, 150 bcm_udf_chunk_info_t *); 151 int(*udf_flow_based_chunk_arrange_set) ( 152 int unit, 153 bcm_udf_tunnel_term_flow_type_t flow_type, 154 uint32 chunk_bmap); 155 int(*udf_flow_based_chunk_arrange_get) ( 156 int unit, 157 bcm_udf_tunnel_term_flow_type_t flow_type, 158 uint32 *chunk_bmap); 159 int(*udf_abstr_pkt_format_obj_list_get)( /* UDF Pkt Format Object Get */ 160 int, 161 bcm_udf_abstract_pkt_format_t, 162 int, 163 bcm_udf_id_t *, 164 int *); 165 int(*udf_abstr_pkt_format_info_get)( /* UDF Pkt Format Info Get */ 166 int, 167 bcm_udf_abstract_pkt_format_t, 168 bcm_udf_abstract_pkt_format_info_t *); 169 int(*udf_abstr_pkt_fmt_list_get)( /* UDF Pkt Fmt list get */ 170 int unit, 171 int max, 172 bcm_udf_abstract_pkt_format_t *pkt_fmt_list, 173 int *actual); 174 int(*udf_wb_sync)(int); /* UDF WB Sync */ 175 int(*udf_range_checker_chunk_info_get)( /* UDF Range checker chunk info get */ 176 int, 177 uint8 *, 178 uint32 *); 179 void(*udf_sw_dump)(int); /* UDF SW Dump */ 180 void(*udf_sw_mem_dump)(int unit, soc_mem_t, int); /* UDF SW Memory Dump */ 181 } _bcm_udf_funct_t; 182 183 /* 184 * Typedef: 185 * _bcm_udf_control_t 186 * Purpose: 187 * UDF control structure to manage and interact with 188 * device specific driver functions. 189 */ 190 typedef struct _bcm_udf_control_s { 191 uint8 flags; /* Module specific flags */ 192 uint8 gran; /* UDF granularity */ 193 uint8 num_chunks; /* Max number of chunks supported. */ 194 uint16 max_udfs; /* Maximum number of UDF objects - For WB purpose. */ 195 uint16 min_obj_id; /* Minimum Object ID */ 196 uint16 max_obj_id; /* Maximum Object ID */ 197 uint16 parse_limit; /* Maximum parse offset limit in bytes */ 198 uint16 udf_id_running; /* UDF ID running trackers */ 199 _bcm_udf_funct_t functions; /* Device specific functions. */ 200 } _bcm_udf_control_t; 201 202 203 /* 204 * Initialize for UDF control structure for MAX supported units. 205 */ 206 extern _bcm_udf_control_t *_udf_control[BCM_MAX_NUM_UNITS]; 207 208 #define UDF_CONTROL(_u_) _udf_control[(_u_)] 209 210 #define _BCM_UDF_INIT_CHECK(_u_) \ 211 do { \ 212 if (UDF_CONTROL(_u_) == NULL) { \ 213 return BCM_E_INIT; \ 214 } \ 215 } while(0) 216 217 #define _BCM_UDF_OFFSET_GRAN(_u_) UDF_CONTROL(_u_)->gran 218 219 #define _BCM_UDF_ID_MIN(_u_) UDF_CONTROL(_u_)->min_obj_id 220 #define _BCM_UDF_ID_MAX(_u_) UDF_CONTROL(_u_)->max_obj_id 221 222 #define _BCM_UDF_ID_VALIDATE(_u_, _id_) \ 223 do { \ 224 if ((_id_ < _BCM_UDF_ID_MIN(_u_)) || \ 225 (_id_ > _BCM_UDF_ID_MAX(_u_))) { \ 226 return BCM_E_PARAM; \ 227 } \ 228 } while(0) 229 230 #define _BCM_UDF_OBJ_ID_RUNNING(_u_) \ 231 (UDF_CONTROL(_u_)->udf_id_running += \ 232 (UDF_CONTROL(_u_)->udf_id_running > _BCM_UDF_ID_MAX(_u_) ? 0 : 1)) 233 234 #define BCM_IF_NULL_RETURN_PARAM(_p_) \ 235 do { \ 236 if ((_p_) == NULL) { \ 237 return BCM_E_PARAM; \ 238 } \ 239 } while(0) 240 241 #define BCM_IF_ERROR_GOTO_CLEANUP(_rv_) \ 242 do { \ 243 if (BCM_FAILURE(_rv_)) { \ 244 goto cleanup; \ 245 } \ 246 } while (0) 247 248 249 /* Granularity supported. */ 250 #define _BCM_UDF_CTRL_OFFSET_GRAN(_u_) UDF_CONTROL(_u_)->gran 251 252 /* Max number of chunks supported. */ 253 #define _BCM_UDF_CTRL_MAX_UDF_CHUNKS(_u_) UDF_CONTROL(_u_)->num_chunks 254 255 extern int 256 _bcm_udf_common_init(int unit); 257 extern int 258 _bcm_udf_common_detach(int unit); 259 #endif /* __BCM_INT_UDF_COMMON_H__ */