1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright 2008-2016 Freescale Semiconductor Inc. 3 * Copyright 2017-2020 NXP 4 */ 5 6 #include <stdio.h> 7 #include <stdlib.h> 8 #include <string.h> 9 #include <fcntl.h> 10 #include <errno.h> 11 #include <unistd.h> 12 #include <termios.h> 13 #include <sys/ioctl.h> 14 #include <stdbool.h> 15 #include <rte_common.h> 16 17 #include "fm_ext.h" 18 #include "fm_pcd_ext.h" 19 #include "fm_port_ext.h" 20 #include <dpaa_ethdev.h> 21 22 #define DEV_TO_ID(p) \ 23 do { \ 24 t_device *p_dev = (t_device *)p; \ 25 p = UINT_TO_PTR(p_dev->id); \ 26 } while (0) 27 28 /* Major and minor are in sync with FMD, respin is for fmlib identification */ 29 #define FM_LIB_VERSION_MAJOR 21 30 #define FM_LIB_VERSION_MINOR 1 31 #define FM_LIB_VERSION_RESPIN 0 32 33 #if (FMD_API_VERSION_MAJOR != FM_LIB_VERSION_MAJOR) || \ 34 (FMD_API_VERSION_MINOR != FM_LIB_VERSION_MINOR) 35 #warning FMD and FMLIB version mismatch 36 #endif 37 38 t_handle 39 fm_open(uint8_t id) 40 { 41 t_device *p_dev; 42 int fd; 43 char dev_name[20]; 44 static bool called; 45 ioc_fm_api_version_t ver; 46 47 _fml_dbg("Calling...\n"); 48 49 p_dev = (t_device *)malloc(sizeof(t_device)); 50 if (p_dev == NULL) 51 return NULL; 52 53 memset(dev_name, 0, 20); 54 sprintf(dev_name, "%s%s%d", "/dev/", DEV_FM_NAME, id); 55 fd = open(dev_name, O_RDWR); 56 if (fd < 0) { 57 free(p_dev); 58 return NULL; 59 } 60 61 p_dev->id = id; 62 p_dev->fd = fd; 63 if (!called) { 64 called = true; 65 fm_get_api_version((t_handle)p_dev, &ver); 66 67 if (ver.version.major != FMD_API_VERSION_MAJOR || 68 ver.version.minor != FMD_API_VERSION_MINOR || 69 ver.version.respin != FMD_API_VERSION_RESPIN) { 70 DPAA_PMD_WARN("Compiled against FMD API ver %u.%u.%u", 71 FMD_API_VERSION_MAJOR, 72 FMD_API_VERSION_MINOR, FMD_API_VERSION_RESPIN); 73 DPAA_PMD_WARN("Running with FMD API ver %u.%u.%u", 74 ver.version.major, ver.version.minor, 75 ver.version.respin); 76 } 77 } 78 _fml_dbg("Finishing.\n"); 79 80 return (t_handle)p_dev; 81 } 82 83 void fm_close(t_handle h_fm) 84 { 85 t_device *p_dev = (t_device *)h_fm; 86 87 _fml_dbg("Calling...\n"); 88 89 close(p_dev->fd); 90 free(p_dev); 91 92 _fml_dbg("Finishing.\n"); 93 } 94 95 uint32_t 96 fm_get_api_version(t_handle h_fm, ioc_fm_api_version_t *p_version) 97 { 98 t_device *p_dev = (t_device *)h_fm; 99 int ret; 100 101 _fml_dbg("Calling...\n"); 102 103 ret = ioctl(p_dev->fd, FM_IOC_GET_API_VERSION, p_version); 104 if (ret) { 105 DPAA_PMD_ERR("cannot get API version, error %i (%s)\n", 106 errno, strerror(errno)); 107 RETURN_ERROR(MINOR, E_INVALID_OPERATION, NO_MSG); 108 } 109 _fml_dbg("Finishing.\n"); 110 111 return E_OK; 112 } 113 114 t_handle 115 fm_pcd_open(t_fm_pcd_params *p_fm_pcd_params) 116 { 117 t_device *p_dev; 118 int fd; 119 char dev_name[20]; 120 121 _fml_dbg("Calling...\n"); 122 123 p_dev = (t_device *)malloc(sizeof(t_device)); 124 if (p_dev == NULL) 125 return NULL; 126 127 memset(dev_name, 0, 20); 128 sprintf(dev_name, "%s%s%u-pcd", "/dev/", DEV_FM_NAME, 129 (uint32_t)((t_device *)p_fm_pcd_params->h_fm)->id); 130 fd = open(dev_name, O_RDWR); 131 if (fd < 0) { 132 free(p_dev); 133 return NULL; 134 } 135 136 p_dev->id = ((t_device *)p_fm_pcd_params->h_fm)->id; 137 p_dev->fd = fd; 138 p_dev->owners = 0; 139 140 _fml_dbg("Finishing.\n"); 141 142 return (t_handle)p_dev; 143 } 144 145 void 146 fm_pcd_close(t_handle h_fm_pcd) 147 { 148 t_device *p_dev = (t_device *)h_fm_pcd; 149 150 _fml_dbg("Calling...\n"); 151 152 close(p_dev->fd); 153 154 if (p_dev->owners) { 155 printf("\nTry delete a prev created pcd handler(owners:%u)!\n", 156 p_dev->owners); 157 return; 158 } 159 160 free(p_dev); 161 162 _fml_dbg("Finishing.\n"); 163 } 164 165 uint32_t 166 fm_pcd_enable(t_handle h_fm_pcd) 167 { 168 t_device *p_dev = (t_device *)h_fm_pcd; 169 170 _fml_dbg("Calling...\n"); 171 172 if (ioctl(p_dev->fd, FM_PCD_IOC_ENABLE)) 173 RETURN_ERROR(MINOR, E_INVALID_OPERATION, NO_MSG); 174 175 _fml_dbg("Finishing.\n"); 176 177 return E_OK; 178 } 179 180 uint32_t 181 fm_pcd_disable(t_handle h_fm_pcd) 182 { 183 t_device *p_dev = (t_device *)h_fm_pcd; 184 185 _fml_dbg("Calling...\n"); 186 187 if (ioctl(p_dev->fd, FM_PCD_IOC_DISABLE)) 188 RETURN_ERROR(MINOR, E_INVALID_OPERATION, NO_MSG); 189 190 _fml_dbg("Finishing.\n"); 191 192 return E_OK; 193 } 194 195 t_handle 196 fm_pcd_net_env_characteristics_set(t_handle h_fm_pcd, 197 ioc_fm_pcd_net_env_params_t *params) 198 { 199 t_device *p_pcd_dev = (t_device *)h_fm_pcd; 200 t_device *p_dev = NULL; 201 202 _fml_dbg("Calling...\n"); 203 204 params->id = NULL; 205 206 if (ioctl(p_pcd_dev->fd, FM_PCD_IOC_NET_ENV_CHARACTERISTICS_SET, 207 params)) 208 return NULL; 209 210 p_dev = (t_device *)malloc(sizeof(t_device)); 211 if (p_dev == NULL) 212 return NULL; 213 214 memset(p_dev, 0, sizeof(t_device)); 215 p_dev->h_user_priv = (t_handle)p_pcd_dev; 216 p_pcd_dev->owners++; 217 p_dev->id = PTR_TO_UINT(params->id); 218 219 _fml_dbg("Finishing.\n"); 220 221 return (t_handle)p_dev; 222 } 223 224 uint32_t 225 fm_pcd_net_env_characteristics_delete(t_handle h_net_env) 226 { 227 t_device *p_dev = (t_device *)h_net_env; 228 t_device *p_pcd_dev = NULL; 229 ioc_fm_obj_t id; 230 231 _fml_dbg("Calling...\n"); 232 233 p_pcd_dev = (t_device *)p_dev->h_user_priv; 234 id.obj = UINT_TO_PTR(p_dev->id); 235 236 if (ioctl(p_pcd_dev->fd, FM_PCD_IOC_NET_ENV_CHARACTERISTICS_DELETE, 237 &id)) 238 RETURN_ERROR(MINOR, E_INVALID_OPERATION, NO_MSG); 239 240 p_pcd_dev->owners--; 241 free(p_dev); 242 243 _fml_dbg("Finishing.\n"); 244 245 return E_OK; 246 } 247 248 t_handle 249 fm_pcd_kg_scheme_set(t_handle h_fm_pcd, 250 ioc_fm_pcd_kg_scheme_params_t *params) 251 { 252 t_device *p_pcd_dev = (t_device *)h_fm_pcd; 253 t_device *p_dev = NULL; 254 int ret; 255 256 _fml_dbg("Calling...\n"); 257 258 params->id = NULL; 259 260 if (params->param.modify) { 261 if (params->param.scm_id.scheme_id) 262 DEV_TO_ID(params->param.scm_id.scheme_id); 263 else 264 return NULL; 265 } 266 267 /* correct h_net_env param from scheme */ 268 if (params->param.net_env_params.net_env_id) 269 DEV_TO_ID(params->param.net_env_params.net_env_id); 270 271 /* correct next engine params handlers: cc*/ 272 if (params->param.next_engine == e_IOC_FM_PCD_CC && 273 params->param.kg_next_engine_params.cc.tree_id) 274 DEV_TO_ID(params->param.kg_next_engine_params.cc.tree_id); 275 276 ret = ioctl(p_pcd_dev->fd, FM_PCD_IOC_KG_SCHEME_SET, params); 277 if (ret) { 278 DPAA_PMD_ERR(" cannot set kg scheme, error %i (%s)\n", 279 errno, strerror(errno)); 280 return NULL; 281 } 282 283 p_dev = (t_device *)malloc(sizeof(t_device)); 284 if (p_dev == NULL) 285 return NULL; 286 287 memset(p_dev, 0, sizeof(t_device)); 288 p_dev->h_user_priv = (t_handle)p_pcd_dev; 289 /* increase owners only if a new scheme is created */ 290 if (!params->param.modify) 291 p_pcd_dev->owners++; 292 p_dev->id = PTR_TO_UINT(params->id); 293 294 _fml_dbg("Finishing.\n"); 295 296 return (t_handle)p_dev; 297 } 298 299 uint32_t 300 fm_pcd_kg_scheme_delete(t_handle h_scheme) 301 { 302 t_device *p_dev = (t_device *)h_scheme; 303 t_device *p_pcd_dev = NULL; 304 ioc_fm_obj_t id; 305 306 _fml_dbg("Calling...\n"); 307 308 p_pcd_dev = (t_device *)p_dev->h_user_priv; 309 id.obj = UINT_TO_PTR(p_dev->id); 310 311 if (ioctl(p_pcd_dev->fd, FM_PCD_IOC_KG_SCHEME_DELETE, &id)) { 312 DPAA_PMD_WARN("cannot delete kg scheme, error %i (%s)\n", 313 errno, strerror(errno)); 314 RETURN_ERROR(MINOR, E_INVALID_OPERATION, NO_MSG); 315 } 316 317 p_pcd_dev->owners--; 318 free(p_dev); 319 320 _fml_dbg("Finishing.\n"); 321 322 return E_OK; 323 } 324 325 typedef struct { 326 e_fm_port_type port_type; /**< Port type */ 327 uint8_t port_id; /**< Port Id - relative to type */ 328 } t_fm_port; 329 330 t_handle 331 fm_port_open(t_fm_port_params *p_fm_port_params) 332 { 333 t_device *p_dev; 334 int fd; 335 char dev_name[30]; 336 t_fm_port *p_fm_port; 337 338 _fml_dbg("Calling...\n"); 339 340 p_dev = (t_device *)malloc(sizeof(t_device)); 341 if (p_dev == NULL) 342 return NULL; 343 344 memset(p_dev, 0, sizeof(t_device)); 345 346 p_fm_port = (t_fm_port *)malloc(sizeof(t_fm_port)); 347 if (!p_fm_port) { 348 free(p_dev); 349 return NULL; 350 } 351 memset(p_fm_port, 0, sizeof(t_fm_port)); 352 memset(dev_name, 0, sizeof(dev_name)); 353 switch (p_fm_port_params->port_type) { 354 case e_FM_PORT_TYPE_OH_OFFLINE_PARSING: 355 sprintf(dev_name, "%s%s%u-port-oh%d", "/dev/", DEV_FM_NAME, 356 (uint32_t)((t_device *)p_fm_port_params->h_fm)->id, 357 p_fm_port_params->port_id); 358 break; 359 case e_FM_PORT_TYPE_RX: 360 sprintf(dev_name, "%s%s%u-port-rx%d", "/dev/", DEV_FM_NAME, 361 (uint32_t)((t_device *)p_fm_port_params->h_fm)->id, 362 p_fm_port_params->port_id); 363 break; 364 case e_FM_PORT_TYPE_RX_10G: 365 sprintf(dev_name, "%s%s%u-port-rx%d", "/dev/", DEV_FM_NAME, 366 (uint32_t)((t_device *)p_fm_port_params->h_fm)->id, 367 FM_MAX_NUM_OF_1G_RX_PORTS + p_fm_port_params->port_id); 368 break; 369 case e_FM_PORT_TYPE_TX: 370 sprintf(dev_name, "%s%s%u-port-tx%d", "/dev/", DEV_FM_NAME, 371 (uint32_t)((t_device *)p_fm_port_params->h_fm)->id, 372 p_fm_port_params->port_id); 373 break; 374 case e_FM_PORT_TYPE_TX_10G: 375 sprintf(dev_name, "%s%s%u-port-tx%d", "/dev/", DEV_FM_NAME, 376 (uint32_t)((t_device *)p_fm_port_params->h_fm)->id, 377 FM_MAX_NUM_OF_1G_TX_PORTS + p_fm_port_params->port_id); 378 break; 379 default: 380 free(p_fm_port); 381 free(p_dev); 382 return NULL; 383 } 384 385 fd = open(dev_name, O_RDWR); 386 if (fd < 0) { 387 free(p_fm_port); 388 free(p_dev); 389 return NULL; 390 } 391 392 p_fm_port->port_type = p_fm_port_params->port_type; 393 p_fm_port->port_id = p_fm_port_params->port_id; 394 p_dev->id = p_fm_port_params->port_id; 395 p_dev->fd = fd; 396 p_dev->h_user_priv = (t_handle)p_fm_port; 397 398 _fml_dbg("Finishing.\n"); 399 400 return (t_handle)p_dev; 401 } 402 403 void 404 fm_port_close(t_handle h_fm_port) 405 { 406 t_device *p_dev = (t_device *)h_fm_port; 407 408 _fml_dbg("Calling...\n"); 409 410 close(p_dev->fd); 411 if (p_dev->h_user_priv) 412 free(p_dev->h_user_priv); 413 free(p_dev); 414 415 _fml_dbg("Finishing.\n"); 416 } 417 418 uint32_t 419 fm_port_disable(t_handle h_fm_port) 420 { 421 t_device *p_dev = (t_device *)h_fm_port; 422 423 _fml_dbg("Calling...\n"); 424 425 if (ioctl(p_dev->fd, FM_PORT_IOC_DISABLE)) 426 RETURN_ERROR(MINOR, E_INVALID_OPERATION, NO_MSG); 427 428 _fml_dbg("Finishing.\n"); 429 430 return E_OK; 431 } 432 433 uint32_t 434 fm_port_enable(t_handle h_fm_port) 435 { 436 t_device *p_dev = (t_device *)h_fm_port; 437 438 _fml_dbg("Calling...\n"); 439 440 if (ioctl(p_dev->fd, FM_PORT_IOC_ENABLE)) 441 RETURN_ERROR(MINOR, E_INVALID_OPERATION, NO_MSG); 442 443 _fml_dbg("Finishing.\n"); 444 445 return E_OK; 446 } 447 448 uint32_t 449 fm_port_set_pcd(t_handle h_fm_port, 450 ioc_fm_port_pcd_params_t *p) 451 { 452 t_device *p_dev = (t_device *)h_fm_port; 453 454 _fml_dbg("Calling...\n"); 455 456 /* correct h_net_env param from t_fm_portPcdParams */ 457 DEV_TO_ID(p->net_env_id); 458 459 /* correct pcd structures according to what support was set */ 460 if (p->pcd_support == e_IOC_FM_PCD_PRS_KG_AND_CC || 461 p->pcd_support == e_IOC_FM_PCD_PRS_KG_AND_CC_AND_PLCR || 462 p->pcd_support == e_IOC_FM_PCD_PRS_CC) { 463 if (p->p_cc_params && p->p_cc_params->cc_tree_id) 464 DEV_TO_ID(p->p_cc_params->cc_tree_id); 465 else 466 DPAA_PMD_WARN("Coarse Classification not set !"); 467 } 468 469 if (p->pcd_support == e_IOC_FM_PCD_PRS_KG || 470 p->pcd_support == e_IOC_FM_PCD_PRS_KG_AND_CC || 471 p->pcd_support == e_IOC_FM_PCD_PRS_KG_AND_CC_AND_PLCR || 472 p->pcd_support == e_IOC_FM_PCD_PRS_KG_AND_PLCR){ 473 if (p->p_kg_params) { 474 uint32_t i; 475 ioc_fm_port_pcd_kg_params_t *kg_params; 476 477 kg_params = p->p_kg_params; 478 479 for (i = 0; i < kg_params->num_schemes; i++) 480 if (kg_params->scheme_ids[i]) 481 DEV_TO_ID(kg_params->scheme_ids[i]); 482 else 483 DPAA_PMD_WARN("Scheme:%u not set!!", i); 484 485 if (kg_params->direct_scheme) 486 DEV_TO_ID(kg_params->direct_scheme_id); 487 } else { 488 DPAA_PMD_WARN("KeyGen not set !"); 489 } 490 } 491 492 if (p->pcd_support == e_IOC_FM_PCD_PLCR_ONLY || 493 p->pcd_support == e_IOC_FM_PCD_PRS_PLCR || 494 p->pcd_support == e_IOC_FM_PCD_PRS_KG_AND_CC_AND_PLCR || 495 p->pcd_support == e_IOC_FM_PCD_PRS_KG_AND_PLCR) { 496 if (p->p_plcr_params) { 497 if (p->p_plcr_params->plcr_profile_id) 498 DEV_TO_ID(p->p_plcr_params->plcr_profile_id); 499 else 500 DPAA_PMD_WARN("Policer not set !"); 501 } 502 } 503 504 if (p->p_ip_reassembly_manip) 505 DEV_TO_ID(p->p_ip_reassembly_manip); 506 507 if (p->p_capwap_reassembly_manip) 508 DEV_TO_ID(p->p_capwap_reassembly_manip); 509 510 if (ioctl(p_dev->fd, FM_PORT_IOC_SET_PCD, p)) 511 RETURN_ERROR(MINOR, E_INVALID_OPERATION, NO_MSG); 512 513 _fml_dbg("Finishing.\n"); 514 515 return E_OK; 516 } 517 518 uint32_t 519 fm_port_delete_pcd(t_handle h_fm_port) 520 { 521 t_device *p_dev = (t_device *)h_fm_port; 522 523 _fml_dbg("Calling...\n"); 524 525 if (ioctl(p_dev->fd, FM_PORT_IOC_DELETE_PCD)) 526 RETURN_ERROR(MINOR, E_INVALID_OPERATION, NO_MSG); 527 528 _fml_dbg("Finishing.\n"); 529 530 return E_OK; 531 } 532 533 t_handle 534 create_device(t_handle h_user_priv, t_handle h_dev_id) 535 { 536 t_device *p_user_priv_dev = (t_device *)h_user_priv; 537 t_device *p_dev = NULL; 538 539 _fml_dbg("Calling...\n"); 540 541 p_dev = (t_device *)malloc(sizeof(t_device)); 542 if (p_dev == NULL) 543 return NULL; 544 545 memset(p_dev, 0, sizeof(t_device)); 546 p_dev->h_user_priv = h_user_priv; 547 p_user_priv_dev->owners++; 548 p_dev->id = PTR_TO_UINT(h_dev_id); 549 550 _fml_dbg("Finishing.\n"); 551 552 return (t_handle)p_dev; 553 } 554 555 t_handle 556 get_device_id(t_handle h_dev) 557 { 558 t_device *p_dev = (t_device *)h_dev; 559 560 return (t_handle)p_dev->id; 561 } 562