compat_655.c (11792B)
1 /* 2 * 3 * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file. 4 * 5 * Copyright 2007-2019 Broadcom Inc. All rights reserved. 6 * 7 * RPC Compatibility with sdk-6.5.5 routines 8 */ 9 10 #ifdef BCM_RPC_SUPPORT 11 12 #include <shared/alloc.h> 13 14 #include <bcm/types.h> 15 #include <bcm/error.h> 16 17 #include <bcm_int/compat/compat_655.h> 18 19 /* 20 * Function: 21 * _bcm_compat655in_trunk_member_t 22 * Purpose: 23 * Convert the bcm_trunk_member_t datatype from older versions to 24 * SDK 6.5.5+ 25 * Parameters: 26 * from - (IN) The old version of the datatype 27 * to - (OUT) The SDK 6.5.5+ version of the datatype 28 * Returns: 29 * Nothing 30 */ 31 STATIC void 32 _bcm_compat655in_trunk_member_t( 33 bcm_compat655_trunk_member_t *from, 34 bcm_trunk_member_t *to) 35 { 36 to->flags = from->flags; 37 to->gport = from->gport; 38 to->dynamic_scaling_factor = from->dynamic_scaling_factor; 39 to->dynamic_load_weight = from->dynamic_load_weight; 40 41 to->dynamic_queue_size_weight = 0; 42 } 43 44 /* 45 * Function: 46 * _bcm_compat655out_trunk_member_t 47 * Purpose: 48 * Convert the bcm_trunk_member_t datatype from SDK 6.5.5+ to 49 * older versions 50 * Parameters: 51 * from - (IN) The SDK 6.5.5+ version of the datatype 52 * to - (OUT) The old version of the datatype 53 * Returns: 54 * Nothing 55 */ 56 STATIC void 57 _bcm_compat655out_trunk_member_t( 58 bcm_trunk_member_t *from, 59 bcm_compat655_trunk_member_t *to) 60 { 61 to->flags = from->flags; 62 to->gport = from->gport; 63 to->dynamic_scaling_factor = from->dynamic_scaling_factor; 64 to->dynamic_load_weight = from->dynamic_load_weight; 65 } 66 67 /* 68 * Function: 69 * bcm_compat655_trunk_set 70 * Purpose: 71 * Compatibility function for RPC call to bcm_trunk_set. Used to 72 * set bcm_trunk_set using an older version of the datatype. 73 * Parameters: 74 * member_array - (IN) The datatype being converted 75 */ 76 int 77 bcm_compat655_trunk_set( 78 int unit, 79 bcm_trunk_t tid, 80 bcm_trunk_info_t *trunk_info, 81 int member_count, 82 bcm_compat655_trunk_member_t *member_array) 83 { 84 int rv, i; 85 bcm_trunk_member_t * n_mem = NULL; 86 87 if (member_array == NULL) { 88 rv = bcm_trunk_set(unit, tid, trunk_info, member_count, n_mem); 89 } else { 90 91 if (member_count) { 92 n_mem = (bcm_trunk_member_t *)sal_alloc( 93 member_count*sizeof(bcm_trunk_member_t), 94 "rpc member_array"); 95 if(n_mem == NULL) { 96 return BCM_E_MEMORY; 97 } 98 } 99 100 /* Convert each old datatype to a new datatype before passing it all 101 * to be set 102 */ 103 for(i = 0; i < member_count; i++) { 104 _bcm_compat655in_trunk_member_t(&member_array[i], &n_mem[i]); 105 } 106 107 rv = bcm_trunk_set(unit, tid, trunk_info, member_count, n_mem); 108 109 if(n_mem != NULL) { 110 sal_free(n_mem); 111 } 112 } 113 114 return rv; 115 } 116 117 /* 118 * Function: 119 * bcm_compat655_trunk_get 120 * Purpose: 121 * Compatibility function for RPC call to bcm_trunk_set. Used to 122 * set bcm_trunk_get using an older version of the datatype. 123 * Parameters: 124 * member_array - (OUT) The old datatype being converted to 125 */ 126 int 127 bcm_compat655_trunk_get( 128 int unit, 129 bcm_trunk_t tid, 130 bcm_trunk_info_t *t_data, 131 int member_max, 132 bcm_compat655_trunk_member_t *member_array, 133 int *member_count) 134 { 135 int rv, i; 136 bcm_trunk_member_t * n_mem; 137 138 if (member_array == NULL) { 139 n_mem = NULL; 140 return bcm_trunk_get(unit, tid, t_data, member_max, 141 n_mem, member_count); 142 } 143 144 n_mem = (bcm_trunk_member_t *)sal_alloc( 145 member_max*sizeof(bcm_trunk_member_t), "rpc member_array"); 146 if(n_mem == NULL) { 147 return BCM_E_MEMORY; 148 } 149 150 rv = bcm_trunk_get(unit, tid, t_data, member_max, 151 n_mem, member_count); 152 if (rv >= 0) { 153 154 /* Convert each new datatype to the old datatype before returning 155 * from get 156 */ 157 for(i = 0; i < *member_count; i++) { 158 _bcm_compat655out_trunk_member_t(&n_mem[i], &member_array[i]); 159 } 160 } 161 162 if(n_mem != NULL) { 163 sal_free(n_mem); 164 } 165 166 return rv; 167 } 168 169 /* 170 * Function: 171 * _bcm_compat655in_field_qset_t 172 * Purpose: 173 * Convert the bcm_field_qset_t datatype from older versions to 174 * SDK 6.5.5+ 175 * Parameters: 176 * from - (IN) The old version of the datatype 177 * to - (OUT) The SDK 6.5.5+ version of the datatype 178 * Returns: 179 * Nothing 180 */ 181 STATIC void 182 _bcm_compat655in_field_qset_t( 183 bcm_compat655_field_qset_t *from, 184 bcm_field_qset_t *to) 185 { 186 uint32 field_qualify_cnt_size = 187 (BCM_COMPAT655_FIELD_QUALIFY_CNT < bcmFieldQualifyCount) ? 188 BCM_COMPAT655_FIELD_QUALIFY_CNT : bcmFieldQualifyCount; 189 uint32 field_user_num_udfs_size = 190 (BCM_COMPAT655_FIELD_USER_NUM_UDFS < BCM_FIELD_USER_NUM_UDFS) ? 191 BCM_COMPAT655_FIELD_USER_NUM_UDFS : BCM_FIELD_USER_NUM_UDFS; 192 193 SHR_BITCOPY_RANGE(to->w, 0, from->w, 0, field_qualify_cnt_size); 194 SHR_BITCOPY_RANGE(to->w, bcmFieldQualifyCount, 195 from->w, BCM_COMPAT655_FIELD_QUALIFY_CNT, 196 field_user_num_udfs_size); 197 SHR_BITCOPY_RANGE(to->udf_map, 0, 198 from->udf_map, 0, 199 field_user_num_udfs_size); 200 } 201 202 /* 203 * Function: 204 * _bcm_compat655out_field_qset_t 205 * Purpose: 206 * Convert the bcm_field_qset_t datatype from SDK 6.5.5+ to 207 * older versions 208 * Parameters: 209 * from - (IN) The SDK 6.5.5+ version of the datatype 210 * to - (OUT) The old version of the datatype 211 * Returns: 212 * Nothing 213 */ 214 STATIC void 215 _bcm_compat655out_field_qset_t( 216 bcm_field_qset_t *from, 217 bcm_compat655_field_qset_t *to) 218 { 219 uint32 field_qualify_cnt_size = 220 (BCM_COMPAT655_FIELD_QUALIFY_CNT < bcmFieldQualifyCount) ? 221 BCM_COMPAT655_FIELD_QUALIFY_CNT : bcmFieldQualifyCount; 222 uint32 field_user_num_udfs_size = 223 (BCM_COMPAT655_FIELD_USER_NUM_UDFS < BCM_FIELD_USER_NUM_UDFS) ? 224 BCM_COMPAT655_FIELD_USER_NUM_UDFS : BCM_FIELD_USER_NUM_UDFS; 225 226 SHR_BITCOPY_RANGE(to->w, 0, from->w, 0, field_qualify_cnt_size); 227 SHR_BITCOPY_RANGE(to->w, BCM_COMPAT655_FIELD_QUALIFY_CNT, 228 from->w, bcmFieldQualifyCount, 229 field_user_num_udfs_size); 230 SHR_BITCOPY_RANGE(to->udf_map, 0, 231 from->udf_map, 0, 232 field_user_num_udfs_size); 233 } 234 235 /* 236 * Function: bcm_compat655_field_group_create 237 * 238 * Purpose: 239 * Compatibility function for RPC call to bcm_field_group_create. 240 * Used to create a FP group using an older version of the datatype. 241 * 242 * Parameters: 243 * unit - (IN) BCM device number. 244 * qset - (IN) Old field qualifier set 245 * pri - (IN) Priority within allowable range, 246 * or BCM_FIELD_GROUP_PRIO_ANY to automatically assign 247 * priority; each priority value may be used only once 248 * group - (OUT) New field group ID 249 * 250 * Returns: 251 * BCM_E_INIT - BCM unit not initialized 252 * BCM_E_PARAM - pri out of range (0-15 for FB & ER) or group == NULL 253 * BCM_E_RESOURCE - no select codes will satisfy qualifier set 254 * BCM_E_MEMORY - allocation failure 255 * BCM_E_NONE - Success 256 */ 257 int 258 bcm_compat655_field_group_create(int unit, 259 bcm_compat655_field_qset_t qset, 260 int pri, 261 bcm_field_group_t *group) 262 { 263 int rv; 264 bcm_field_qset_t *p_new_qset; 265 266 /* Create the qualifier set from heap to avoid the stack to bloat */ 267 p_new_qset = 268 (bcm_field_qset_t *) sal_alloc(sizeof(bcm_field_qset_t), "NewQset"); 269 if (NULL == p_new_qset) { 270 return BCM_E_MEMORY; 271 } 272 273 /* Initialize the new qualifier set */ 274 BCM_FIELD_QSET_INIT(*p_new_qset); 275 276 /* Transform the qulaifier set from the old format to new one */ 277 _bcm_compat655in_field_qset_t(&qset, p_new_qset); 278 279 /* Call the BCM API with new qset format */ 280 rv = bcm_field_group_create(unit, *p_new_qset, pri, group); 281 282 /* Deallocate the q set memory */ 283 sal_free(p_new_qset); 284 285 return rv; 286 } 287 288 /* 289 * Function: bcm_compat655_field_group_create_id 290 * 291 * Purpose: 292 * Compatibility function for RPC call to bcm_field_group_create_id. 293 * Used to create a FP group using an older version of the datatype. 294 * 295 * Parameters: 296 * unit - (IN) BCM device number. 297 * qset - (IN) Old field qualifier set 298 * pri - (IN) Priority within allowable range, 299 * or BCM_FIELD_GROUP_PRIO_ANY to automatically assign 300 * priority; each priority value may be used only once 301 * group - (IN) Requested new field group ID 302 * 303 * Returns: 304 * BCM_E_INIT - BCM unit not initialized 305 * BCM_E_RESOURCE - No unused group/slices left 306 * BCM_E_PARAM - priority out of range (0-15 for FB & ER) 307 * BCM_E_EXISTS - group with that id already exists on this unit. 308 * BCM_E_MEMORY - Memory allocation failure 309 * BCM_E_NONE - Success 310 */ 311 int 312 bcm_compat655_field_group_create_id(int unit, 313 bcm_compat655_field_qset_t qset, 314 int pri, 315 bcm_field_group_t group) 316 { 317 int rv; 318 bcm_field_qset_t *p_new_qset; 319 320 /* Create the qualifier set from heap to avoid the huge stack variable */ 321 p_new_qset = 322 (bcm_field_qset_t *) sal_alloc(sizeof(bcm_field_qset_t), "NewQset"); 323 if (NULL == p_new_qset) { 324 return BCM_E_MEMORY; 325 } 326 327 /* Initialize the new qualifier set */ 328 BCM_FIELD_QSET_INIT(*p_new_qset); 329 330 /* Transform the qulaifier set from the old format to new one */ 331 _bcm_compat655in_field_qset_t(&qset, p_new_qset); 332 333 /* Call the BCM API with new qset format */ 334 rv = bcm_field_group_create_id(unit, *p_new_qset, pri, group); 335 336 /* Deallocate the q set memory */ 337 sal_free(p_new_qset); 338 339 return (rv); 340 } 341 342 343 /* 344 * Function: bcm_compat655_field_qset_data_qualifier_add 345 * 346 * Purpose: 347 * Compatibility function for RPC call to bcm_field_qset_data_qualifier_add 348 * Used to add field data qualifier to group qset. 349 * 350 * Parameters: 351 * unit - (IN) BCM device number. 352 * qset - (IN/OUT) Old group qualifier set 353 * qualifier_id - (IN) Data qualifier id. 354 * 355 * Returns: 356 * BCM_E_XXX 357 */ 358 int 359 bcm_compat655_field_qset_data_qualifier_add(int unit, 360 bcm_compat655_field_qset_t *qset, 361 int qual_id) 362 { 363 int rv; 364 bcm_field_qset_t *p_new_qset=NULL; 365 366 /* Only tranform qualifier set if given a valid qset */ 367 if (qset) { 368 369 /* Create the qualifier set from heap to avoid the stack to bloat */ 370 p_new_qset = 371 (bcm_field_qset_t *)sal_alloc(sizeof(bcm_field_qset_t), "NewQset"); 372 if (NULL == p_new_qset) { 373 return BCM_E_MEMORY; 374 } 375 376 /* Initialize the new qualifier set */ 377 BCM_FIELD_QSET_INIT(*p_new_qset); 378 379 /* Transform the qualifier set from the old format to new one */ 380 _bcm_compat655in_field_qset_t(qset, p_new_qset); 381 } 382 383 /* Call the BCM API with new qset format */ 384 rv = bcm_field_qset_data_qualifier_add(unit, p_new_qset, qual_id); 385 386 if (qset) { 387 /* Copy back the qset from new to old format */ 388 if (BCM_SUCCESS(rv)) { 389 _bcm_compat655out_field_qset_t(p_new_qset, qset); 390 } 391 392 /* Deallocate the q set memory */ 393 sal_free(p_new_qset); 394 } 395 396 return (rv); 397 } 398 399 #endif /* BCM_RPC_SUPPORT */