generic.c (9338B)
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 * File: generic.c 8 * Purpose: generic board driver suitable for single device boards 9 * 10 * Note: this driver is only intended for engineering use, not for production. 11 */ 12 13 #include <shared/bsl.h> 14 15 #include <sal/core/alloc.h> 16 #include <sal/core/libc.h> 17 #include <bcm/error.h> 18 #include <bcm/stack.h> 19 #if defined(INCLUDE_LIB_STKTASK) 20 #include <appl/stktask/topo_brd.h> 21 #endif 22 #if defined(INCLUDE_LIB_DISCOVER) 23 #include <appl/discover/disc.h> 24 #endif 25 26 #include <board/board.h> 27 #include <board/manager.h> 28 #include <board/support.h> 29 #include <board/stack.h> 30 #include <board/driver.h> 31 32 #if defined (INCLUDE_BOARD_GENERIC) 33 34 #define MAX_DESC 80 35 #define MAX_UNIT 1 36 #define UNIT 0 37 38 #define PRIVATE(field) (((generic_private_data_t *)(driver->user_data))->field) 39 40 typedef struct generic_private_data_s { 41 char description[MAX_DESC]; 42 bcm_info_t info; 43 int modid; 44 bcm_gport_t cpu; 45 } generic_private_data_t; 46 47 STATIC generic_private_data_t _generic_private_data; 48 49 /* 50 * Function: 51 * _generic_modid_get 52 * Purpose: 53 * Get board modid 54 * Parameters: 55 * driver - (IN) current driver 56 * name - (IN) attribute name (ignored) 57 * modid - (OUT) modid 58 * Returns: 59 * BCM_E_NONE - success 60 * BCM_E_PARAM - modid param NULL 61 */ 62 STATIC int 63 _generic_modid_get(board_driver_t *driver, char *name, int *modid) 64 { 65 if (!modid) { 66 return BCM_E_PARAM; 67 } 68 69 *modid = PRIVATE(modid); 70 71 return BCM_E_NONE; 72 } 73 74 75 /* 76 * Function: 77 * _generic_modid_set 78 * Purpose: 79 * Set the board modid 80 * Parameters: 81 * driver - (IN) current driver 82 * name - (IN) attribute name (ignored) 83 * modid - (IN) modid 84 * Returns: 85 * BCM_E_NONE - success 86 * BCM_E_XXX - failed 87 */ 88 STATIC int 89 _generic_modid_set(board_driver_t *driver, char *name, int modid) 90 { 91 /* iterate across all units, setting modid. Handle even modid case. */ 92 BCM_IF_ERROR_RETURN(bcm_stk_my_modid_set(UNIT, modid)); 93 PRIVATE(modid) = modid; 94 95 return BCM_E_NONE; 96 } 97 98 /* 99 * Function: 100 * _generic_num_modid_get 101 * Purpose: 102 * Get the number of modids required by this board 103 * Parameters: 104 * driver - (IN) current driver (ignored) 105 * name - (IN) attribute name (ignored) 106 * modid - (OUT) modid 107 * Returns: 108 * BCM_E_NONE - success 109 * BCM_E_XXX - failed 110 */ 111 STATIC int 112 _generic_num_modid_get(board_driver_t *driver, char *name, int *num_modid) 113 { 114 return bcm_stk_modid_count(UNIT, num_modid); 115 } 116 117 #if defined(INCLUDE_LIB_CPUDB) 118 119 /* 120 * Function: 121 * _generic_stack_init 122 * Purpose: 123 * Initialize cpudb and required stacking subsystems 124 * Parameters: 125 * driver - (IN) current driver 126 * db_ref - (OUT) stack CPUDB 127 * Returns: 128 * BCM_E_NONE - success 129 * BCM_E_XXX - failed 130 */ 131 STATIC int 132 _generic_stack_init(board_driver_t *driver, cpudb_ref_t db_ref) 133 { 134 BCM_IF_ERROR_RETURN(board_cpudb_get(driver, db_ref)); 135 #if defined(INCLUDE_LIB_DISCOVER) 136 disc_ttl_max_set(2); 137 #endif 138 return BCM_E_NONE; 139 } 140 141 /* 142 * Function: 143 * _generic_stack_program 144 * Purpose: 145 * Program the board according to the CPUDB 146 * Parameters: 147 * driver - (IN) current driver 148 * db_ref - (IN) stack CPUDB 149 * topo_cpu - (IN) stack TOPO_CPU (ignored) 150 * Returns: 151 * BCM_E_NONE - success 152 * BCM_E_XXX - failed 153 */ 154 STATIC int 155 _generic_stack_program(board_driver_t *driver, 156 cpudb_ref_t db_ref, 157 topo_cpu_t *topo_cpu) 158 { 159 BCM_IF_ERROR_RETURN 160 (_generic_modid_set(driver, NULL, db_ref->local_entry->mod_ids[0])); 161 162 /* Need to determine the criteria for this; don't know if FABRIC 163 to too weak or too strong. */ 164 if (PRIVATE(info).capability & BCM_INFO_FABRIC) { 165 BCM_IF_ERROR_RETURN 166 (bcm_stk_modport_set(UNIT, PRIVATE(modid), PRIVATE(cpu))); 167 } 168 169 BCM_IF_ERROR_RETURN(board_stack_program(db_ref, 0)); 170 171 return BCM_E_NONE; 172 } 173 174 175 /* 176 * Function: 177 * _generic_stack 178 * Purpose: 179 * Manage stktask callbacks 180 * Parameters: 181 * op - (IN) current driver 182 * db_ref - (IN/OUT) stack CPUDB 183 * topo_cpu - (IN) stack TOPO_CPU (ignored) 184 * user_data - (IN) user data 185 * Returns: 186 * BCM_E_NONE - success 187 * BCM_E_XXX - failed 188 */ 189 STATIC int 190 _generic_stack(topo_board_control_t op, 191 cpudb_ref_t db_ref, 192 topo_cpu_t *topo_cpu, 193 void *user_data) 194 { 195 int rv = BCM_E_PARAM; 196 board_driver_t *driver = (board_driver_t *)user_data; 197 198 switch (op) { 199 case topoBoardInit: 200 rv = _generic_stack_init(driver, db_ref); 201 break; 202 203 case topoBoardProgram: 204 rv = _generic_stack_program(driver, db_ref, topo_cpu); 205 break; 206 207 default: 208 break; 209 210 } 211 212 return rv; 213 } 214 #endif 215 216 /* 217 * Function: 218 * _generic_description 219 * Purpose: 220 * Return the board description string 221 * Parameters: 222 * driver - (IN) current driver 223 * Returns: 224 * description string 225 */ 226 STATIC char * 227 _generic_description(board_driver_t *driver) 228 { 229 return PRIVATE(description); 230 } 231 232 /* 233 * Function: 234 * _generic_probe 235 * Purpose: 236 * Test if board devices are appropriate for this board. 237 * All single unit boards are appropriate. 238 * Parameters: 239 * driver - (IN) board driver 240 * num - (IN) number of devices; length of info array 241 * info - (IN) array of bcm_info_t 242 * Returns: 243 * BCM_E_NONE - devices match what is expected for this board 244 * BCM_E_XXX - failed 245 */ 246 STATIC int 247 _generic_probe(board_driver_t *driver, int num, bcm_info_t *info) 248 { 249 int rv = BCM_E_FAIL; 250 251 if (num == MAX_UNIT) { 252 LOG_VERBOSE(BSL_LS_BOARD_COMMON, 253 (BSL_META(__FILE__": accept\n"))); 254 rv = BCM_E_NONE; 255 } else { 256 LOG_VERBOSE(BSL_LS_BOARD_COMMON, 257 (BSL_META(__FILE__": reject - num_units(%d) != %d\n"), 258 num, MAX_UNIT)); 259 } 260 261 return rv; 262 } 263 264 /* 265 * Function: 266 * _generic_start 267 * Purpose: 268 * Start board according to flags 269 * Parameters: 270 * driver - (IN) current driver 271 * flags - (IN) start flags 272 * Returns: 273 * BCM_E_NONE - success 274 * BCM_E_XXX - failed 275 */ 276 STATIC int 277 _generic_start(board_driver_t *driver, uint32 flags) 278 { 279 280 /* init the unit */ 281 if (flags & BOARD_START_F_WARM_BOOT) { 282 return BCM_E_UNAVAIL; 283 } else { 284 BCM_IF_ERROR_RETURN(board_device_init(UNIT)); 285 BCM_IF_ERROR_RETURN(board_port_init(UNIT)); 286 #if defined(INCLUDE_I2C) 287 BCM_IF_ERROR_RETURN(board_i2c_device_init(UNIT)); 288 #endif 289 } 290 291 if (!(flags & (BOARD_START_F_CLEAR|BOARD_START_F_WARM_BOOT))) { 292 293 /* Cold start */ 294 295 /* Reset user data */ 296 sal_memset(driver->user_data, 0, sizeof(generic_private_data_t)); 297 298 BCM_IF_ERROR_RETURN(bcm_info_get(UNIT, &PRIVATE(info))); 299 300 sal_sprintf(PRIVATE(description), 301 "Generic %s board driver", 302 board_device_name(UNIT)); 303 304 BCM_IF_ERROR_RETURN 305 (board_connections_discover 306 (generic_board.num_connection, 307 generic_board.connection, 308 &generic_board.num_connection)); 309 310 311 /* Set initial CPU port and modid */ 312 BCM_IF_ERROR_RETURN(bcm_stk_my_modid_get(UNIT, &PRIVATE(modid))); 313 BCM_IF_ERROR_RETURN(board_device_cpu_port_get(UNIT, &PRIVATE(cpu))); 314 315 /* Hook into stacking */ 316 #if defined(INCLUDE_LIB_STKTASK) && defined(INCLUDE_LIB_CPUDB) 317 BCM_IF_ERROR_RETURN 318 (topo_board_register(_generic_stack, (void *)driver)); 319 #endif 320 } else if (flags & BOARD_START_F_CLEAR) { 321 /* Reset */ 322 BCM_IF_ERROR_RETURN(bcm_stk_my_modid_set(UNIT, PRIVATE(modid))); 323 } 324 325 LOG_VERBOSE(BSL_LS_BOARD_COMMON, 326 (BSL_META(__FILE__": started %s - %s\n"), 327 generic_board.name, 328 PRIVATE(description))); 329 330 return BCM_E_NONE; 331 } 332 333 /* 334 * Function: 335 * _generic_stop 336 * Purpose: 337 * Stop the board 338 * Parameters: 339 * driver - (IN) current driver 340 * Returns: 341 * BCM_E_NONE - success 342 * BCM_E_XXX - failed 343 */ 344 STATIC int 345 _generic_stop(board_driver_t *driver) 346 { 347 BCM_IF_ERROR_RETURN(board_port_deinit(UNIT)); 348 BCM_IF_ERROR_RETURN(board_device_deinit(UNIT)); 349 350 /* Free connection data */ 351 sal_free(generic_board.connection); 352 353 /* Reset user data */ 354 sal_memset(driver->user_data, 0, sizeof(generic_private_data_t)); 355 356 return BCM_E_NONE; 357 } 358 359 /* Supported attributes */ 360 STATIC board_attribute_t _generic_attrib[] = { 361 { 362 BOARD_ATTRIBUTE_MODID, 363 _generic_modid_get, 364 _generic_modid_set, 365 }, 366 { 367 BOARD_ATTRIBUTE_NUM_MODID, 368 _generic_num_modid_get, 369 NULL 370 } 371 }; 372 373 STATIC board_connection_t _generic_conn[BCM_PBMP_PORT_MAX]; 374 375 /* Board driver */ 376 board_driver_t generic_board = { 377 "generic", 378 BOARD_GENERIC_PRIORITY, 379 (void *)&_generic_private_data, 380 COUNTOF(_generic_conn), 381 _generic_conn, 382 COUNTOF(_generic_attrib), 383 _generic_attrib, 384 _generic_description, 385 _generic_probe, 386 _generic_start, 387 _generic_stop 388 }; 389 390 #endif /* INCLUDE_BOARD_GENERIC */