ceph/src/seastar/dpdk/drivers/raw/ifpga_rawdev/base/opae_hw_api.c

   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, void *buf, u32 size,
 248                        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 }