1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2018 Intel Corporation 3 */ 4 5 #include "opae_hw_api.h" 6 #include "opae_debug.h" 7 #include "ifpga_api.h" 8 9 /* OPAE Bridge Functions */ 10 11 /** 12 * opae_bridge_alloc - alloc opae_bridge data structure 13 * @name: bridge name. 14 * @ops: ops of this bridge. 15 * @data: private data of this bridge. 16 * 17 * Return opae_bridge on success, otherwise NULL. 18 */ 19 struct opae_bridge * 20 opae_bridge_alloc(const char *name, struct opae_bridge_ops *ops, void *data) 21 { 22 struct opae_bridge *br = opae_zmalloc(sizeof(*br)); 23 24 if (!br) 25 return NULL; 26 27 br->name = name; 28 br->ops = ops; 29 br->data = data; 30 31 opae_log("%s %p\n", __func__, br); 32 33 return br; 34 } 35 36 /** 37 * opae_bridge_reset - reset opae_bridge 38 * @br: bridge to be reset. 39 * 40 * Return: 0 on success, otherwise error code. 41 */ 42 int opae_bridge_reset(struct opae_bridge *br) 43 { 44 if (!br) 45 return -EINVAL; 46 47 if (br->ops && br->ops->reset) 48 return br->ops->reset(br); 49 50 opae_log("%s no ops\n", __func__); 51 52 return -ENOENT; 53 } 54 55 /* Accelerator Functions */ 56 57 /** 58 * opae_accelerator_alloc - alloc opae_accelerator data structure 59 * @name: accelerator name. 60 * @ops: ops of this accelerator. 61 * @data: private data of this accelerator. 62 * 63 * Return: opae_accelerator on success, otherwise NULL. 64 */ 65 struct opae_accelerator * 66 opae_accelerator_alloc(const char *name, struct opae_accelerator_ops *ops, 67 void *data) 68 { 69 struct opae_accelerator *acc = opae_zmalloc(sizeof(*acc)); 70 71 if (!acc) 72 return NULL; 73 74 acc->name = name; 75 acc->ops = ops; 76 acc->data = data; 77 78 opae_log("%s %p\n", __func__, acc); 79 80 return acc; 81 } 82 83 /** 84 * opae_acc_reg_read - read accelerator's register from its reg region. 85 * @acc: accelerator to read. 86 * @region_idx: reg region index. 87 * @offset: reg offset. 88 * @byte: read operation width, e.g 4 byte = 32bit read. 89 * @data: data to store the value read from the register. 90 * 91 * Return: 0 on success, otherwise error code. 92 */ 93 int opae_acc_reg_read(struct opae_accelerator *acc, unsigned int region_idx, 94 u64 offset, unsigned int byte, void *data) 95 { 96 if (!acc || !data) 97 return -EINVAL; 98 99 if (acc->ops && acc->ops->read) 100 return acc->ops->read(acc, region_idx, offset, byte, data); 101 102 return -ENOENT; 103 } 104 105 /** 106 * opae_acc_reg_write - write to accelerator's register from its reg region. 107 * @acc: accelerator to write. 108 * @region_idx: reg region index. 109 * @offset: reg offset. 110 * @byte: write operation width, e.g 4 byte = 32bit write. 111 * @data: data stored the value to write to the register. 112 * 113 * Return: 0 on success, otherwise error code. 114 */ 115 int opae_acc_reg_write(struct opae_accelerator *acc, unsigned int region_idx, 116 u64 offset, unsigned int byte, void *data) 117 { 118 if (!acc || !data) 119 return -EINVAL; 120 121 if (acc->ops && acc->ops->write) 122 return acc->ops->write(acc, region_idx, offset, byte, data); 123 124 return -ENOENT; 125 } 126 127 /** 128 * opae_acc_get_info - get information of an accelerator. 129 * @acc: targeted accelerator 130 * @info: accelerator info data structure to be filled. 131 * 132 * Return: 0 on success, otherwise error code. 133 */ 134 int opae_acc_get_info(struct opae_accelerator *acc, struct opae_acc_info *info) 135 { 136 if (!acc || !info) 137 return -EINVAL; 138 139 if (acc->ops && acc->ops->get_info) 140 return acc->ops->get_info(acc, info); 141 142 return -ENOENT; 143 } 144 145 /** 146 * opae_acc_get_region_info - get information of an accelerator register region. 147 * @acc: targeted accelerator 148 * @info: accelerator region info data structure to be filled. 149 * 150 * Return: 0 on success, otherwise error code. 151 */ 152 int opae_acc_get_region_info(struct opae_accelerator *acc, 153 struct opae_acc_region_info *info) 154 { 155 if (!acc || !info) 156 return -EINVAL; 157 158 if (acc->ops && acc->ops->get_region_info) 159 return acc->ops->get_region_info(acc, info); 160 161 return -ENOENT; 162 } 163 164 /** 165 * opae_acc_set_irq - set an accelerator's irq. 166 * @acc: targeted accelerator 167 * @start: start vector number 168 * @count: count of vectors to be set from the start vector 169 * @evtfds: event fds to be notified when corresponding irqs happens 170 * 171 * Return: 0 on success, otherwise error code. 172 */ 173 int opae_acc_set_irq(struct opae_accelerator *acc, 174 u32 start, u32 count, s32 evtfds[]) 175 { 176 if (!acc || !acc->data) 177 return -EINVAL; 178 179 if (start + count <= start) 180 return -EINVAL; 181 182 if (acc->ops && acc->ops->set_irq) 183 return acc->ops->set_irq(acc, start, count, evtfds); 184 185 return -ENOENT; 186 } 187 188 /** 189 * opae_acc_get_uuid - get accelerator's UUID. 190 * @acc: targeted accelerator 191 * @uuid: a pointer to UUID 192 * 193 * Return: 0 on success, otherwise error code. 194 */ 195 int opae_acc_get_uuid(struct opae_accelerator *acc, 196 struct uuid *uuid) 197 { 198 if (!acc || !uuid) 199 return -EINVAL; 200 201 if (acc->ops && acc->ops->get_uuid) 202 return acc->ops->get_uuid(acc, uuid); 203 204 return -ENOENT; 205 } 206 207 /* Manager Functions */ 208 209 /** 210 * opae_manager_alloc - alloc opae_manager data structure 211 * @name: manager name. 212 * @ops: ops of this manager. 213 * @network_ops: ops of network management. 214 * @data: private data of this manager. 215 * 216 * Return: opae_manager on success, otherwise NULL. 217 */ 218 struct opae_manager * 219 opae_manager_alloc(const char *name, struct opae_manager_ops *ops, 220 struct opae_manager_networking_ops *network_ops, void *data) 221 { 222 struct opae_manager *mgr = opae_zmalloc(sizeof(*mgr)); 223 224 if (!mgr) 225 return NULL; 226 227 mgr->name = name; 228 mgr->ops = ops; 229 mgr->network_ops = network_ops; 230 mgr->data = data; 231 232 opae_log("%s %p\n", __func__, mgr); 233 234 return mgr; 235 } 236 237 /** 238 * opae_manager_flash - flash a reconfiguration image via opae_manager 239 * @mgr: opae_manager for flash. 240 * @id: id of target region (accelerator). 241 * @buf: image data buffer. 242 * @size: buffer size. 243 * @status: status to store flash result. 244 * 245 * Return: 0 on success, otherwise error code. 246 */ 247 int opae_manager_flash(struct opae_manager *mgr, int id, const char *buf, 248 u32 size, u64 *status) 249 { 250 if (!mgr) 251 return -EINVAL; 252 253 if (mgr && mgr->ops && mgr->ops->flash) 254 return mgr->ops->flash(mgr, id, buf, size, status); 255 256 return -ENOENT; 257 } 258 259 /* Adapter Functions */ 260 261 /** 262 * opae_adapter_data_alloc - alloc opae_adapter_data data structure 263 * @type: opae_adapter_type. 264 * 265 * Return: opae_adapter_data on success, otherwise NULL. 266 */ 267 void *opae_adapter_data_alloc(enum opae_adapter_type type) 268 { 269 struct opae_adapter_data *data; 270 int size; 271 272 switch (type) { 273 case OPAE_FPGA_PCI: 274 size = sizeof(struct opae_adapter_data_pci); 275 break; 276 case OPAE_FPGA_NET: 277 size = sizeof(struct opae_adapter_data_net); 278 break; 279 default: 280 size = sizeof(struct opae_adapter_data); 281 break; 282 } 283 284 data = opae_zmalloc(size); 285 if (!data) 286 return NULL; 287 288 data->type = type; 289 290 return data; 291 } 292 293 static struct opae_adapter_ops *match_ops(struct opae_adapter *adapter) 294 { 295 struct opae_adapter_data *data; 296 297 if (!adapter || !adapter->data) 298 return NULL; 299 300 data = adapter->data; 301 302 if (data->type == OPAE_FPGA_PCI) 303 return &ifpga_adapter_ops; 304 305 return NULL; 306 } 307 308 /** 309 * opae_adapter_init - init opae_adapter data structure 310 * @adapter: pointer of opae_adapter data structure 311 * @name: adapter name. 312 * @data: private data of this adapter. 313 * 314 * Return: 0 on success. 315 */ 316 int opae_adapter_init(struct opae_adapter *adapter, 317 const char *name, void *data) 318 { 319 if (!adapter) 320 return -ENOMEM; 321 322 TAILQ_INIT(&adapter->acc_list); 323 adapter->data = data; 324 adapter->name = name; 325 adapter->ops = match_ops(adapter); 326 327 return 0; 328 } 329 330 /** 331 * opae_adapter_enumerate - enumerate this adapter 332 * @adapter: adapter to enumerate. 333 * 334 * Return: 0 on success, otherwise error code. 335 */ 336 int opae_adapter_enumerate(struct opae_adapter *adapter) 337 { 338 int ret = -ENOENT; 339 340 if (!adapter) 341 return -EINVAL; 342 343 if (adapter->ops && adapter->ops->enumerate) 344 ret = adapter->ops->enumerate(adapter); 345 346 if (!ret) 347 opae_adapter_dump(adapter, 0); 348 349 return ret; 350 } 351 352 /** 353 * opae_adapter_destroy - destroy this adapter 354 * @adapter: adapter to destroy. 355 * 356 * destroy things allocated during adapter enumeration. 357 */ 358 void opae_adapter_destroy(struct opae_adapter *adapter) 359 { 360 if (adapter && adapter->ops && adapter->ops->destroy) 361 adapter->ops->destroy(adapter); 362 } 363 364 /** 365 * opae_adapter_get_acc - find and return accelerator with matched id 366 * @adapter: adapter to find the accelerator. 367 * @acc_id: id (index) of the accelerator. 368 * 369 * destroy things allocated during adapter enumeration. 370 */ 371 struct opae_accelerator * 372 opae_adapter_get_acc(struct opae_adapter *adapter, int acc_id) 373 { 374 struct opae_accelerator *acc = NULL; 375 376 if (!adapter) 377 return NULL; 378 379 opae_adapter_for_each_acc(adapter, acc) 380 if (acc->index == acc_id) 381 return acc; 382 383 return NULL; 384 } 385 386 /** 387 * opae_manager_read_mac_rom - read the content of the MAC ROM 388 * @mgr: opae_manager for MAC ROM 389 * @port: the port number of retimer 390 * @addr: buffer of the MAC address 391 * 392 * Return: return the bytes of read successfully 393 */ 394 int opae_manager_read_mac_rom(struct opae_manager *mgr, int port, 395 struct opae_ether_addr *addr) 396 { 397 if (!mgr || !mgr->network_ops) 398 return -EINVAL; 399 400 if (mgr->network_ops->read_mac_rom) 401 return mgr->network_ops->read_mac_rom(mgr, 402 port * sizeof(struct opae_ether_addr), 403 addr, sizeof(struct opae_ether_addr)); 404 405 return -ENOENT; 406 } 407 408 /** 409 * opae_manager_write_mac_rom - write data into MAC ROM 410 * @mgr: opae_manager for MAC ROM 411 * @port: the port number of the retimer 412 * @addr: data of the MAC address 413 * 414 * Return: return written bytes 415 */ 416 int opae_manager_write_mac_rom(struct opae_manager *mgr, int port, 417 struct opae_ether_addr *addr) 418 { 419 if (!mgr || !mgr->network_ops) 420 return -EINVAL; 421 422 if (mgr->network_ops && mgr->network_ops->write_mac_rom) 423 return mgr->network_ops->write_mac_rom(mgr, 424 port * sizeof(struct opae_ether_addr), 425 addr, sizeof(struct opae_ether_addr)); 426 427 return -ENOENT; 428 } 429 430 /** 431 * opae_manager_get_eth_group_nums - get eth group numbers 432 * @mgr: opae_manager for eth group 433 * 434 * Return: the numbers of eth group 435 */ 436 int opae_manager_get_eth_group_nums(struct opae_manager *mgr) 437 { 438 if (!mgr || !mgr->network_ops) 439 return -EINVAL; 440 441 if (mgr->network_ops->get_retimer_info) 442 return mgr->network_ops->get_eth_group_nums(mgr); 443 444 return -ENOENT; 445 } 446 447 /** 448 * opae_manager_get_eth_group_info - get eth group info 449 * @mgr: opae_manager for eth group 450 * @group_id: id for eth group 451 * @info: info return to caller 452 * 453 * Return: 0 on success, otherwise error code 454 */ 455 int opae_manager_get_eth_group_info(struct opae_manager *mgr, 456 u8 group_id, struct opae_eth_group_info *info) 457 { 458 if (!mgr || !mgr->network_ops) 459 return -EINVAL; 460 461 if (mgr->network_ops->get_retimer_info) 462 return mgr->network_ops->get_eth_group_info(mgr, 463 group_id, info); 464 465 return -ENOENT; 466 } 467 468 /** 469 * opae_manager_get_eth_group_region_info 470 * @mgr: opae_manager for flash. 471 * @info: the memory region info for eth group 472 * 473 * Return: 0 on success, otherwise error code. 474 */ 475 int opae_manager_get_eth_group_region_info(struct opae_manager *mgr, 476 u8 group_id, struct opae_eth_group_region_info *info) 477 { 478 if (!mgr) 479 return -EINVAL; 480 481 if (group_id >= MAX_ETH_GROUP_DEVICES) 482 return -EINVAL; 483 484 info->group_id = group_id; 485 486 if (mgr && mgr->ops && mgr->ops->get_eth_group_region_info) 487 return mgr->ops->get_eth_group_region_info(mgr, info); 488 489 return -ENOENT; 490 } 491 492 /** 493 * opae_manager_eth_group_read_reg - read ETH group register 494 * @mgr: opae_manager for ETH Group 495 * @group_id: ETH group id 496 * @type: eth type 497 * @index: port index in eth group device 498 * @addr: register address of ETH Group 499 * @data: read buffer 500 * 501 * Return: 0 on success, otherwise error code 502 */ 503 int opae_manager_eth_group_read_reg(struct opae_manager *mgr, u8 group_id, 504 u8 type, u8 index, u16 addr, u32 *data) 505 { 506 if (!mgr || !mgr->network_ops) 507 return -EINVAL; 508 509 if (mgr->network_ops->eth_group_reg_read) 510 return mgr->network_ops->eth_group_reg_read(mgr, group_id, 511 type, index, addr, data); 512 513 return -ENOENT; 514 } 515 516 /** 517 * opae_manager_eth_group_write_reg - write ETH group register 518 * @mgr: opae_manager for ETH Group 519 * @group_id: ETH group id 520 * @type: eth type 521 * @index: port index in eth group device 522 * @addr: register address of ETH Group 523 * @data: data will write to register 524 * 525 * Return: 0 on success, otherwise error code 526 */ 527 int opae_manager_eth_group_write_reg(struct opae_manager *mgr, u8 group_id, 528 u8 type, u8 index, u16 addr, u32 data) 529 { 530 if (!mgr || !mgr->network_ops) 531 return -EINVAL; 532 533 if (mgr->network_ops->eth_group_reg_write) 534 return mgr->network_ops->eth_group_reg_write(mgr, group_id, 535 type, index, addr, data); 536 537 return -ENOENT; 538 } 539 540 /** 541 * opae_manager_get_retimer_info - get retimer info like PKVL chip 542 * @mgr: opae_manager for retimer 543 * @info: info return to caller 544 * 545 * Return: 0 on success, otherwise error code 546 */ 547 int opae_manager_get_retimer_info(struct opae_manager *mgr, 548 struct opae_retimer_info *info) 549 { 550 if (!mgr || !mgr->network_ops) 551 return -EINVAL; 552 553 if (mgr->network_ops->get_retimer_info) 554 return mgr->network_ops->get_retimer_info(mgr, info); 555 556 return -ENOENT; 557 } 558 559 /** 560 * opae_manager_get_retimer_status - get retimer status 561 * @mgr: opae_manager of retimer 562 * @status: status of retimer 563 * 564 * Return: 0 on success, otherwise error code 565 */ 566 int opae_manager_get_retimer_status(struct opae_manager *mgr, 567 struct opae_retimer_status *status) 568 { 569 if (!mgr || !mgr->network_ops) 570 return -EINVAL; 571 572 if (mgr->network_ops->get_retimer_status) 573 return mgr->network_ops->get_retimer_status(mgr, 574 status); 575 576 return -ENOENT; 577 } 578