drivers/common/cnxk/roc_dev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2021 Marvell.
   3  */
   4
   5 #include <fcntl.h>
   6 #include <inttypes.h>
   7 #include <string.h>
   8 #include <sys/mman.h>
   9 #include <unistd.h>
  10
  11 #include "roc_api.h"
  12 #include "roc_priv.h"
  13
  14 /* PCI Extended capability ID */
  15 #define ROC_PCI_EXT_CAP_ID_SRIOV 0x10 /* SRIOV cap */
  16
  17 /* Single Root I/O Virtualization */
  18 #define ROC_PCI_SRIOV_TOTAL_VF 0x0e /* Total VFs */
  19
  20 static void *
  21 mbox_mem_map(off_t off, size_t size)
  22 {
  23         void *va = MAP_FAILED;
  24         int mem_fd;
  25
  26         if (size <= 0 || !off) {
  27                 plt_err("Invalid mbox area off 0x%lx size %lu", off, size);
  28                 goto error;
  29         }
  30
  31         mem_fd = open("/dev/mem", O_RDWR);
  32         if (mem_fd < 0)
  33                 goto error;
  34
  35         va = plt_mmap(NULL, size, PLT_PROT_READ | PLT_PROT_WRITE,
  36                       PLT_MAP_SHARED, mem_fd, off);
  37         close(mem_fd);
  38
  39         if (va == MAP_FAILED)
  40                 plt_err("Failed to mmap sz=0x%zx, fd=%d, off=%jd", size, mem_fd,
  41                         (intmax_t)off);
  42 error:
  43         return va;
  44 }
  45
  46 static void
  47 mbox_mem_unmap(void *va, size_t size)
  48 {
  49         if (va)
  50                 munmap(va, size);
  51 }
  52
  53 static int
  54 pf_af_sync_msg(struct dev *dev, struct mbox_msghdr **rsp)
  55 {
  56         uint32_t timeout = 0, sleep = 1;
  57         struct mbox *mbox = dev->mbox;
  58         struct mbox_dev *mdev = &mbox->dev[0];
  59
  60         volatile uint64_t int_status;
  61         struct mbox_msghdr *msghdr;
  62         uint64_t off;
  63         int rc = 0;
  64
  65         /* We need to disable PF interrupts. We are in timer interrupt */
  66         plt_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1C);
  67
  68         /* Send message */
  69         mbox_msg_send(mbox, 0);
  70
  71         do {
  72                 plt_delay_ms(sleep);
  73                 timeout += sleep;
  74                 if (timeout >= mbox->rsp_tmo) {
  75                         plt_err("Message timeout: %dms", mbox->rsp_tmo);
  76                         rc = -EIO;
  77                         break;
  78                 }
  79                 int_status = plt_read64(dev->bar2 + RVU_PF_INT);
  80         } while ((int_status & 0x1) != 0x1);
  81
  82         /* Clear */
  83         plt_write64(int_status, dev->bar2 + RVU_PF_INT);
  84
  85         /* Enable interrupts */
  86         plt_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1S);
  87
  88         if (rc == 0) {
  89                 /* Get message */
  90                 off = mbox->rx_start +
  91                       PLT_ALIGN(sizeof(struct mbox_hdr), MBOX_MSG_ALIGN);
  92                 msghdr = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + off);
  93                 if (rsp)
  94                         *rsp = msghdr;
  95                 rc = msghdr->rc;
  96         }
  97
  98         return rc;
  99 }
 100
 101 static int
 102 af_pf_wait_msg(struct dev *dev, uint16_t vf, int num_msg)
 103 {
 104         uint32_t timeout = 0, sleep = 1;
 105         struct mbox *mbox = dev->mbox;
 106         struct mbox_dev *mdev = &mbox->dev[0];
 107         volatile uint64_t int_status;
 108         struct mbox_hdr *req_hdr;
 109         struct mbox_msghdr *msg;
 110         struct mbox_msghdr *rsp;
 111         uint64_t offset;
 112         size_t size;
 113         int i;
 114
 115         /* We need to disable PF interrupts. We are in timer interrupt */
 116         plt_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1C);
 117
 118         /* Send message */
 119         mbox_msg_send(mbox, 0);
 120
 121         do {
 122                 plt_delay_ms(sleep);
 123                 timeout++;
 124                 if (timeout >= mbox->rsp_tmo) {
 125                         plt_err("Routed messages %d timeout: %dms", num_msg,
 126                                 mbox->rsp_tmo);
 127                         break;
 128                 }
 129                 int_status = plt_read64(dev->bar2 + RVU_PF_INT);
 130         } while ((int_status & 0x1) != 0x1);
 131
 132         /* Clear */
 133         plt_write64(~0ull, dev->bar2 + RVU_PF_INT);
 134
 135         /* Enable interrupts */
 136         plt_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1S);
 137
 138         plt_spinlock_lock(&mdev->mbox_lock);
 139
 140         req_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
 141         if (req_hdr->num_msgs != num_msg)
 142                 plt_err("Routed messages: %d received: %d", num_msg,
 143                         req_hdr->num_msgs);
 144
 145         /* Get messages from mbox */
 146         offset = mbox->rx_start +
 147                  PLT_ALIGN(sizeof(struct mbox_hdr), MBOX_MSG_ALIGN);
 148         for (i = 0; i < req_hdr->num_msgs; i++) {
 149                 msg = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
 150                 size = mbox->rx_start + msg->next_msgoff - offset;
 151
 152                 /* Reserve PF/VF mbox message */
 153                 size = PLT_ALIGN(size, MBOX_MSG_ALIGN);
 154                 rsp = mbox_alloc_msg(&dev->mbox_vfpf, vf, size);
 155                 mbox_rsp_init(msg->id, rsp);
 156
 157                 /* Copy message from AF<->PF mbox to PF<->VF mbox */
 158                 mbox_memcpy((uint8_t *)rsp + sizeof(struct mbox_msghdr),
 159                             (uint8_t *)msg + sizeof(struct mbox_msghdr),
 160                             size - sizeof(struct mbox_msghdr));
 161
 162                 /* Set status and sender pf_func data */
 163                 rsp->rc = msg->rc;
 164                 rsp->pcifunc = msg->pcifunc;
 165
 166                 offset = mbox->rx_start + msg->next_msgoff;
 167         }
 168         plt_spinlock_unlock(&mdev->mbox_lock);
 169
 170         return req_hdr->num_msgs;
 171 }
 172
 173 static int
 174 vf_pf_process_msgs(struct dev *dev, uint16_t vf)
 175 {
 176         struct mbox *mbox = &dev->mbox_vfpf;
 177         struct mbox_dev *mdev = &mbox->dev[vf];
 178         struct mbox_hdr *req_hdr;
 179         struct mbox_msghdr *msg;
 180         int offset, routed = 0;
 181         size_t size;
 182         uint16_t i;
 183
 184         req_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
 185         if (!req_hdr->num_msgs)
 186                 return 0;
 187
 188         offset = mbox->rx_start + PLT_ALIGN(sizeof(*req_hdr), MBOX_MSG_ALIGN);
 189
 190         for (i = 0; i < req_hdr->num_msgs; i++) {
 191                 msg = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
 192                 size = mbox->rx_start + msg->next_msgoff - offset;
 193
 194                 /* RVU_PF_FUNC_S */
 195                 msg->pcifunc = dev_pf_func(dev->pf, vf);
 196
 197                 if (msg->id == MBOX_MSG_READY) {
 198                         struct ready_msg_rsp *rsp;
 199                         uint16_t max_bits = sizeof(dev->active_vfs[0]) * 8;
 200
 201                         /* Handle READY message in PF */
 202                         dev->active_vfs[vf / max_bits] |=
 203                                 BIT_ULL(vf % max_bits);
 204                         rsp = (struct ready_msg_rsp *)mbox_alloc_msg(
 205                                 mbox, vf, sizeof(*rsp));
 206                         mbox_rsp_init(msg->id, rsp);
 207
 208                         /* PF/VF function ID */
 209                         rsp->hdr.pcifunc = msg->pcifunc;
 210                         rsp->hdr.rc = 0;
 211                 } else {
 212                         struct mbox_msghdr *af_req;
 213                         /* Reserve AF/PF mbox message */
 214                         size = PLT_ALIGN(size, MBOX_MSG_ALIGN);
 215                         af_req = mbox_alloc_msg(dev->mbox, 0, size);
 216                         if (af_req == NULL)
 217                                 return -ENOSPC;
 218                         mbox_req_init(msg->id, af_req);
 219
 220                         /* Copy message from VF<->PF mbox to PF<->AF mbox */
 221                         mbox_memcpy((uint8_t *)af_req +
 222                                             sizeof(struct mbox_msghdr),
 223                                     (uint8_t *)msg + sizeof(struct mbox_msghdr),
 224                                     size - sizeof(struct mbox_msghdr));
 225                         af_req->pcifunc = msg->pcifunc;
 226                         routed++;
 227                 }
 228                 offset = mbox->rx_start + msg->next_msgoff;
 229         }
 230
 231         if (routed > 0) {
 232                 plt_base_dbg("pf:%d routed %d messages from vf:%d to AF",
 233                              dev->pf, routed, vf);
 234                 af_pf_wait_msg(dev, vf, routed);
 235                 mbox_reset(dev->mbox, 0);
 236         }
 237
 238         /* Send mbox responses to VF */
 239         if (mdev->num_msgs) {
 240                 plt_base_dbg("pf:%d reply %d messages to vf:%d", dev->pf,
 241                              mdev->num_msgs, vf);
 242                 mbox_msg_send(mbox, vf);
 243         }
 244
 245         return i;
 246 }
 247
 248 static int
 249 vf_pf_process_up_msgs(struct dev *dev, uint16_t vf)
 250 {
 251         struct mbox *mbox = &dev->mbox_vfpf_up;
 252         struct mbox_dev *mdev = &mbox->dev[vf];
 253         struct mbox_hdr *req_hdr;
 254         struct mbox_msghdr *msg;
 255         int msgs_acked = 0;
 256         int offset;
 257         uint16_t i;
 258
 259         req_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
 260         if (req_hdr->num_msgs == 0)
 261                 return 0;
 262
 263         offset = mbox->rx_start + PLT_ALIGN(sizeof(*req_hdr), MBOX_MSG_ALIGN);
 264
 265         for (i = 0; i < req_hdr->num_msgs; i++) {
 266                 msg = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
 267
 268                 msgs_acked++;
 269                 /* RVU_PF_FUNC_S */
 270                 msg->pcifunc = dev_pf_func(dev->pf, vf);
 271
 272                 switch (msg->id) {
 273                 case MBOX_MSG_CGX_LINK_EVENT:
 274                         plt_base_dbg("PF: Msg 0x%x (%s) fn:0x%x (pf:%d,vf:%d)",
 275                                      msg->id, mbox_id2name(msg->id),
 276                                      msg->pcifunc, dev_get_pf(msg->pcifunc),
 277                                      dev_get_vf(msg->pcifunc));
 278                         break;
 279                 case MBOX_MSG_CGX_PTP_RX_INFO:
 280                         plt_base_dbg("PF: Msg 0x%x (%s) fn:0x%x (pf:%d,vf:%d)",
 281                                      msg->id, mbox_id2name(msg->id),
 282                                      msg->pcifunc, dev_get_pf(msg->pcifunc),
 283                                      dev_get_vf(msg->pcifunc));
 284                         break;
 285                 default:
 286                         plt_err("Not handled UP msg 0x%x (%s) func:0x%x",
 287                                 msg->id, mbox_id2name(msg->id), msg->pcifunc);
 288                 }
 289                 offset = mbox->rx_start + msg->next_msgoff;
 290         }
 291         mbox_reset(mbox, vf);
 292         mdev->msgs_acked = msgs_acked;
 293         plt_wmb();
 294
 295         return i;
 296 }
 297
 298 static void
 299 roc_vf_pf_mbox_handle_msg(void *param)
 300 {
 301         uint16_t vf, max_vf, max_bits;
 302         struct dev *dev = param;
 303
 304         max_bits = sizeof(dev->intr.bits[0]) * sizeof(uint64_t);
 305         max_vf = max_bits * MAX_VFPF_DWORD_BITS;
 306
 307         for (vf = 0; vf < max_vf; vf++) {
 308                 if (dev->intr.bits[vf / max_bits] & BIT_ULL(vf % max_bits)) {
 309                         plt_base_dbg("Process vf:%d request (pf:%d, vf:%d)", vf,
 310                                      dev->pf, dev->vf);
 311                         vf_pf_process_msgs(dev, vf);
 312                         /* UP messages */
 313                         vf_pf_process_up_msgs(dev, vf);
 314                         dev->intr.bits[vf / max_bits] &=
 315                                 ~(BIT_ULL(vf % max_bits));
 316                 }
 317         }
 318         dev->timer_set = 0;
 319 }
 320
 321 static void
 322 roc_vf_pf_mbox_irq(void *param)
 323 {
 324         struct dev *dev = param;
 325         bool alarm_set = false;
 326         uint64_t intr;
 327         int vfpf;
 328
 329         for (vfpf = 0; vfpf < MAX_VFPF_DWORD_BITS; ++vfpf) {
 330                 intr = plt_read64(dev->bar2 + RVU_PF_VFPF_MBOX_INTX(vfpf));
 331                 if (!intr)
 332                         continue;
 333
 334                 plt_base_dbg("vfpf: %d intr: 0x%" PRIx64 " (pf:%d, vf:%d)",
 335                              vfpf, intr, dev->pf, dev->vf);
 336
 337                 /* Save and clear intr bits */
 338                 dev->intr.bits[vfpf] |= intr;
 339                 plt_write64(intr, dev->bar2 + RVU_PF_VFPF_MBOX_INTX(vfpf));
 340                 alarm_set = true;
 341         }
 342
 343         if (!dev->timer_set && alarm_set) {
 344                 dev->timer_set = 1;
 345                 /* Start timer to handle messages */
 346                 plt_alarm_set(VF_PF_MBOX_TIMER_MS, roc_vf_pf_mbox_handle_msg,
 347                               dev);
 348         }
 349 }
 350
 351 static void
 352 process_msgs(struct dev *dev, struct mbox *mbox)
 353 {
 354         struct mbox_dev *mdev = &mbox->dev[0];
 355         struct mbox_hdr *req_hdr;
 356         struct mbox_msghdr *msg;
 357         int msgs_acked = 0;
 358         int offset;
 359         uint16_t i;
 360
 361         req_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
 362         if (req_hdr->num_msgs == 0)
 363                 return;
 364
 365         offset = mbox->rx_start + PLT_ALIGN(sizeof(*req_hdr), MBOX_MSG_ALIGN);
 366         for (i = 0; i < req_hdr->num_msgs; i++) {
 367                 msg = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
 368
 369                 msgs_acked++;
 370                 plt_base_dbg("Message 0x%x (%s) pf:%d/vf:%d", msg->id,
 371                              mbox_id2name(msg->id), dev_get_pf(msg->pcifunc),
 372                              dev_get_vf(msg->pcifunc));
 373
 374                 switch (msg->id) {
 375                         /* Add message id's that are handled here */
 376                 case MBOX_MSG_READY:
 377                         /* Get our identity */
 378                         dev->pf_func = msg->pcifunc;
 379                         break;
 380
 381                 default:
 382                         if (msg->rc)
 383                                 plt_err("Message (%s) response has err=%d",
 384                                         mbox_id2name(msg->id), msg->rc);
 385                         break;
 386                 }
 387                 offset = mbox->rx_start + msg->next_msgoff;
 388         }
 389
 390         mbox_reset(mbox, 0);
 391         /* Update acked if someone is waiting a message */
 392         mdev->msgs_acked = msgs_acked;
 393         plt_wmb();
 394 }
 395
 396 /* Copies the message received from AF and sends it to VF */
 397 static void
 398 pf_vf_mbox_send_up_msg(struct dev *dev, void *rec_msg)
 399 {
 400         uint16_t max_bits = sizeof(dev->active_vfs[0]) * sizeof(uint64_t);
 401         struct mbox *vf_mbox = &dev->mbox_vfpf_up;
 402         struct msg_req *msg = rec_msg;
 403         struct mbox_msghdr *vf_msg;
 404         uint16_t vf;
 405         size_t size;
 406
 407         size = PLT_ALIGN(mbox_id2size(msg->hdr.id), MBOX_MSG_ALIGN);
 408         /* Send UP message to all VF's */
 409         for (vf = 0; vf < vf_mbox->ndevs; vf++) {
 410                 /* VF active */
 411                 if (!(dev->active_vfs[vf / max_bits] & (BIT_ULL(vf))))
 412                         continue;
 413
 414                 plt_base_dbg("(%s) size: %zx to VF: %d",
 415                              mbox_id2name(msg->hdr.id), size, vf);
 416
 417                 /* Reserve PF/VF mbox message */
 418                 vf_msg = mbox_alloc_msg(vf_mbox, vf, size);
 419                 if (!vf_msg) {
 420                         plt_err("Failed to alloc VF%d UP message", vf);
 421                         continue;
 422                 }
 423                 mbox_req_init(msg->hdr.id, vf_msg);
 424
 425                 /*
 426                  * Copy message from AF<->PF UP mbox
 427                  * to PF<->VF UP mbox
 428                  */
 429                 mbox_memcpy((uint8_t *)vf_msg + sizeof(struct mbox_msghdr),
 430                             (uint8_t *)msg + sizeof(struct mbox_msghdr),
 431                             size - sizeof(struct mbox_msghdr));
 432
 433                 vf_msg->rc = msg->hdr.rc;
 434                 /* Set PF to be a sender */
 435                 vf_msg->pcifunc = dev->pf_func;
 436
 437                 /* Send to VF */
 438                 mbox_msg_send(vf_mbox, vf);
 439         }
 440 }
 441
 442 static int
 443 mbox_up_handler_cgx_link_event(struct dev *dev, struct cgx_link_info_msg *msg,
 444                                struct msg_rsp *rsp)
 445 {
 446         struct cgx_link_user_info *linfo = &msg->link_info;
 447         void *roc_nix = dev->roc_nix;
 448
 449         plt_base_dbg("pf:%d/vf:%d NIC Link %s --> 0x%x (%s) from: pf:%d/vf:%d",
 450                      dev_get_pf(dev->pf_func), dev_get_vf(dev->pf_func),
 451                      linfo->link_up ? "UP" : "DOWN", msg->hdr.id,
 452                      mbox_id2name(msg->hdr.id), dev_get_pf(msg->hdr.pcifunc),
 453                      dev_get_vf(msg->hdr.pcifunc));
 454
 455         /* PF gets link notification from AF */
 456         if (dev_get_pf(msg->hdr.pcifunc) == 0) {
 457                 if (dev->ops && dev->ops->link_status_update)
 458                         dev->ops->link_status_update(roc_nix, linfo);
 459
 460                 /* Forward the same message as received from AF to VF */
 461                 pf_vf_mbox_send_up_msg(dev, msg);
 462         } else {
 463                 /* VF gets link up notification */
 464                 if (dev->ops && dev->ops->link_status_update)
 465                         dev->ops->link_status_update(roc_nix, linfo);
 466         }
 467
 468         rsp->hdr.rc = 0;
 469         return 0;
 470 }
 471
 472 static int
 473 mbox_up_handler_cgx_ptp_rx_info(struct dev *dev,
 474                                 struct cgx_ptp_rx_info_msg *msg,
 475                                 struct msg_rsp *rsp)
 476 {
 477         void *roc_nix = dev->roc_nix;
 478
 479         plt_base_dbg("pf:%d/vf:%d PTP mode %s --> 0x%x (%s) from: pf:%d/vf:%d",
 480                      dev_get_pf(dev->pf_func), dev_get_vf(dev->pf_func),
 481                      msg->ptp_en ? "ENABLED" : "DISABLED", msg->hdr.id,
 482                      mbox_id2name(msg->hdr.id), dev_get_pf(msg->hdr.pcifunc),
 483                      dev_get_vf(msg->hdr.pcifunc));
 484
 485         /* PF gets PTP notification from AF */
 486         if (dev_get_pf(msg->hdr.pcifunc) == 0) {
 487                 if (dev->ops && dev->ops->ptp_info_update)
 488                         dev->ops->ptp_info_update(roc_nix, msg->ptp_en);
 489
 490                 /* Forward the same message as received from AF to VF */
 491                 pf_vf_mbox_send_up_msg(dev, msg);
 492         } else {
 493                 /* VF gets PTP notification */
 494                 if (dev->ops && dev->ops->ptp_info_update)
 495                         dev->ops->ptp_info_update(roc_nix, msg->ptp_en);
 496         }
 497
 498         rsp->hdr.rc = 0;
 499         return 0;
 500 }
 501
 502 static int
 503 mbox_process_msgs_up(struct dev *dev, struct mbox_msghdr *req)
 504 {
 505         /* Check if valid, if not reply with a invalid msg */
 506         if (req->sig != MBOX_REQ_SIG)
 507                 return -EIO;
 508
 509         switch (req->id) {
 510         default:
 511                 reply_invalid_msg(&dev->mbox_up, 0, 0, req->id);
 512                 break;
 513 #define M(_name, _id, _fn_name, _req_type, _rsp_type)                          \
 514         case _id: {                                                            \
 515                 struct _rsp_type *rsp;                                         \
 516                 int err;                                                       \
 517                 rsp = (struct _rsp_type *)mbox_alloc_msg(                      \
 518                         &dev->mbox_up, 0, sizeof(struct _rsp_type));           \
 519                 if (!rsp)                                                      \
 520                         return -ENOMEM;                                        \
 521                 rsp->hdr.id = _id;                                             \
 522                 rsp->hdr.sig = MBOX_RSP_SIG;                                   \
 523                 rsp->hdr.pcifunc = dev->pf_func;                               \
 524                 rsp->hdr.rc = 0;                                               \
 525                 err = mbox_up_handler_##_fn_name(dev, (struct _req_type *)req, \
 526                                                  rsp);                         \
 527                 return err;                                                    \
 528         }
 529                 MBOX_UP_CGX_MESSAGES
 530 #undef M
 531         }
 532
 533         return -ENODEV;
 534 }
 535
 536 static void
 537 process_msgs_up(struct dev *dev, struct mbox *mbox)
 538 {
 539         struct mbox_dev *mdev = &mbox->dev[0];
 540         struct mbox_hdr *req_hdr;
 541         struct mbox_msghdr *msg;
 542         int i, err, offset;
 543
 544         req_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
 545         if (req_hdr->num_msgs == 0)
 546                 return;
 547
 548         offset = mbox->rx_start + PLT_ALIGN(sizeof(*req_hdr), MBOX_MSG_ALIGN);
 549         for (i = 0; i < req_hdr->num_msgs; i++) {
 550                 msg = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
 551
 552                 plt_base_dbg("Message 0x%x (%s) pf:%d/vf:%d", msg->id,
 553                              mbox_id2name(msg->id), dev_get_pf(msg->pcifunc),
 554                              dev_get_vf(msg->pcifunc));
 555                 err = mbox_process_msgs_up(dev, msg);
 556                 if (err)
 557                         plt_err("Error %d handling 0x%x (%s)", err, msg->id,
 558                                 mbox_id2name(msg->id));
 559                 offset = mbox->rx_start + msg->next_msgoff;
 560         }
 561         /* Send mbox responses */
 562         if (mdev->num_msgs) {
 563                 plt_base_dbg("Reply num_msgs:%d", mdev->num_msgs);
 564                 mbox_msg_send(mbox, 0);
 565         }
 566 }
 567
 568 static void
 569 roc_pf_vf_mbox_irq(void *param)
 570 {
 571         struct dev *dev = param;
 572         uint64_t intr;
 573
 574         intr = plt_read64(dev->bar2 + RVU_VF_INT);
 575         if (intr == 0)
 576                 plt_base_dbg("Proceeding to check mbox UP messages if any");
 577
 578         plt_write64(intr, dev->bar2 + RVU_VF_INT);
 579         plt_base_dbg("Irq 0x%" PRIx64 "(pf:%d,vf:%d)", intr, dev->pf, dev->vf);
 580
 581         /* First process all configuration messages */
 582         process_msgs(dev, dev->mbox);
 583
 584         /* Process Uplink messages */
 585         process_msgs_up(dev, &dev->mbox_up);
 586 }
 587
 588 static void
 589 roc_af_pf_mbox_irq(void *param)
 590 {
 591         struct dev *dev = param;
 592         uint64_t intr;
 593
 594         intr = plt_read64(dev->bar2 + RVU_PF_INT);
 595         if (intr == 0)
 596                 plt_base_dbg("Proceeding to check mbox UP messages if any");
 597
 598         plt_write64(intr, dev->bar2 + RVU_PF_INT);
 599         plt_base_dbg("Irq 0x%" PRIx64 "(pf:%d,vf:%d)", intr, dev->pf, dev->vf);
 600
 601         /* First process all configuration messages */
 602         process_msgs(dev, dev->mbox);
 603
 604         /* Process Uplink messages */
 605         process_msgs_up(dev, &dev->mbox_up);
 606 }
 607
 608 static int
 609 mbox_register_pf_irq(struct plt_pci_device *pci_dev, struct dev *dev)
 610 {
 611         struct plt_intr_handle *intr_handle = &pci_dev->intr_handle;
 612         int i, rc;
 613
 614         /* HW clear irq */
 615         for (i = 0; i < MAX_VFPF_DWORD_BITS; ++i)
 616                 plt_write64(~0ull,
 617                             dev->bar2 + RVU_PF_VFPF_MBOX_INT_ENA_W1CX(i));
 618
 619         plt_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1C);
 620
 621         dev->timer_set = 0;
 622
 623         /* MBOX interrupt for VF(0...63) <-> PF */
 624         rc = dev_irq_register(intr_handle, roc_vf_pf_mbox_irq, dev,
 625                               RVU_PF_INT_VEC_VFPF_MBOX0);
 626
 627         if (rc) {
 628                 plt_err("Fail to register PF(VF0-63) mbox irq");
 629                 return rc;
 630         }
 631         /* MBOX interrupt for VF(64...128) <-> PF */
 632         rc = dev_irq_register(intr_handle, roc_vf_pf_mbox_irq, dev,
 633                               RVU_PF_INT_VEC_VFPF_MBOX1);
 634
 635         if (rc) {
 636                 plt_err("Fail to register PF(VF64-128) mbox irq");
 637                 return rc;
 638         }
 639         /* MBOX interrupt AF <-> PF */
 640         rc = dev_irq_register(intr_handle, roc_af_pf_mbox_irq, dev,
 641                               RVU_PF_INT_VEC_AFPF_MBOX);
 642         if (rc) {
 643                 plt_err("Fail to register AF<->PF mbox irq");
 644                 return rc;
 645         }
 646
 647         /* HW enable intr */
 648         for (i = 0; i < MAX_VFPF_DWORD_BITS; ++i)
 649                 plt_write64(~0ull,
 650                             dev->bar2 + RVU_PF_VFPF_MBOX_INT_ENA_W1SX(i));
 651
 652         plt_write64(~0ull, dev->bar2 + RVU_PF_INT);
 653         plt_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1S);
 654
 655         return rc;
 656 }
 657
 658 static int
 659 mbox_register_vf_irq(struct plt_pci_device *pci_dev, struct dev *dev)
 660 {
 661         struct plt_intr_handle *intr_handle = &pci_dev->intr_handle;
 662         int rc;
 663
 664         /* Clear irq */
 665         plt_write64(~0ull, dev->bar2 + RVU_VF_INT_ENA_W1C);
 666
 667         /* MBOX interrupt PF <-> VF */
 668         rc = dev_irq_register(intr_handle, roc_pf_vf_mbox_irq, dev,
 669                               RVU_VF_INT_VEC_MBOX);
 670         if (rc) {
 671                 plt_err("Fail to register PF<->VF mbox irq");
 672                 return rc;
 673         }
 674
 675         /* HW enable intr */
 676         plt_write64(~0ull, dev->bar2 + RVU_VF_INT);
 677         plt_write64(~0ull, dev->bar2 + RVU_VF_INT_ENA_W1S);
 678
 679         return rc;
 680 }
 681
 682 static int
 683 mbox_register_irq(struct plt_pci_device *pci_dev, struct dev *dev)
 684 {
 685         if (dev_is_vf(dev))
 686                 return mbox_register_vf_irq(pci_dev, dev);
 687         else
 688                 return mbox_register_pf_irq(pci_dev, dev);
 689 }
 690
 691 static void
 692 mbox_unregister_pf_irq(struct plt_pci_device *pci_dev, struct dev *dev)
 693 {
 694         struct plt_intr_handle *intr_handle = &pci_dev->intr_handle;
 695         int i;
 696
 697         /* HW clear irq */
 698         for (i = 0; i < MAX_VFPF_DWORD_BITS; ++i)
 699                 plt_write64(~0ull,
 700                             dev->bar2 + RVU_PF_VFPF_MBOX_INT_ENA_W1CX(i));
 701
 702         plt_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1C);
 703
 704         dev->timer_set = 0;
 705
 706         plt_alarm_cancel(roc_vf_pf_mbox_handle_msg, dev);
 707
 708         /* Unregister the interrupt handler for each vectors */
 709         /* MBOX interrupt for VF(0...63) <-> PF */
 710         dev_irq_unregister(intr_handle, roc_vf_pf_mbox_irq, dev,
 711                            RVU_PF_INT_VEC_VFPF_MBOX0);
 712
 713         /* MBOX interrupt for VF(64...128) <-> PF */
 714         dev_irq_unregister(intr_handle, roc_vf_pf_mbox_irq, dev,
 715                            RVU_PF_INT_VEC_VFPF_MBOX1);
 716
 717         /* MBOX interrupt AF <-> PF */
 718         dev_irq_unregister(intr_handle, roc_af_pf_mbox_irq, dev,
 719                            RVU_PF_INT_VEC_AFPF_MBOX);
 720 }
 721
 722 static void
 723 mbox_unregister_vf_irq(struct plt_pci_device *pci_dev, struct dev *dev)
 724 {
 725         struct plt_intr_handle *intr_handle = &pci_dev->intr_handle;
 726
 727         /* Clear irq */
 728         plt_write64(~0ull, dev->bar2 + RVU_VF_INT_ENA_W1C);
 729
 730         /* Unregister the interrupt handler */
 731         dev_irq_unregister(intr_handle, roc_pf_vf_mbox_irq, dev,
 732                            RVU_VF_INT_VEC_MBOX);
 733 }
 734
 735 static void
 736 mbox_unregister_irq(struct plt_pci_device *pci_dev, struct dev *dev)
 737 {
 738         if (dev_is_vf(dev))
 739                 mbox_unregister_vf_irq(pci_dev, dev);
 740         else
 741                 mbox_unregister_pf_irq(pci_dev, dev);
 742 }
 743
 744 static int
 745 vf_flr_send_msg(struct dev *dev, uint16_t vf)
 746 {
 747         struct mbox *mbox = dev->mbox;
 748         struct msg_req *req;
 749         int rc;
 750
 751         req = mbox_alloc_msg_vf_flr(mbox);
 752         if (req == NULL)
 753                 return -ENOSPC;
 754         /* Overwrite pcifunc to indicate VF */
 755         req->hdr.pcifunc = dev_pf_func(dev->pf, vf);
 756
 757         /* Sync message in interrupt context */
 758         rc = pf_af_sync_msg(dev, NULL);
 759         if (rc)
 760                 plt_err("Failed to send VF FLR mbox msg, rc=%d", rc);
 761
 762         return rc;
 763 }
 764
 765 static void
 766 roc_pf_vf_flr_irq(void *param)
 767 {
 768         struct dev *dev = (struct dev *)param;
 769         uint16_t max_vf = 64, vf;
 770         uintptr_t bar2;
 771         uint64_t intr;
 772         int i;
 773
 774         max_vf = (dev->maxvf > 0) ? dev->maxvf : 64;
 775         bar2 = dev->bar2;
 776
 777         plt_base_dbg("FLR VF interrupt: max_vf: %d", max_vf);
 778
 779         for (i = 0; i < MAX_VFPF_DWORD_BITS; ++i) {
 780                 intr = plt_read64(bar2 + RVU_PF_VFFLR_INTX(i));
 781                 if (!intr)
 782                         continue;
 783
 784                 for (vf = 0; vf < max_vf; vf++) {
 785                         if (!(intr & (1ULL << vf)))
 786                                 continue;
 787
 788                         plt_base_dbg("FLR: i :%d intr: 0x%" PRIx64 ", vf-%d", i,
 789                                      intr, (64 * i + vf));
 790                         /* Clear interrupt */
 791                         plt_write64(BIT_ULL(vf), bar2 + RVU_PF_VFFLR_INTX(i));
 792                         /* Disable the interrupt */
 793                         plt_write64(BIT_ULL(vf),
 794                                     bar2 + RVU_PF_VFFLR_INT_ENA_W1CX(i));
 795                         /* Inform AF about VF reset */
 796                         vf_flr_send_msg(dev, vf);
 797
 798                         /* Signal FLR finish */
 799                         plt_write64(BIT_ULL(vf), bar2 + RVU_PF_VFTRPENDX(i));
 800                         /* Enable interrupt */
 801                         plt_write64(~0ull, bar2 + RVU_PF_VFFLR_INT_ENA_W1SX(i));
 802                 }
 803         }
 804 }
 805
 806 static int
 807 vf_flr_unregister_irqs(struct plt_pci_device *pci_dev, struct dev *dev)
 808 {
 809         struct plt_intr_handle *intr_handle = &pci_dev->intr_handle;
 810         int i;
 811
 812         plt_base_dbg("Unregister VF FLR interrupts for %s", pci_dev->name);
 813
 814         /* HW clear irq */
 815         for (i = 0; i < MAX_VFPF_DWORD_BITS; i++)
 816                 plt_write64(~0ull, dev->bar2 + RVU_PF_VFFLR_INT_ENA_W1CX(i));
 817
 818         dev_irq_unregister(intr_handle, roc_pf_vf_flr_irq, dev,
 819                            RVU_PF_INT_VEC_VFFLR0);
 820
 821         dev_irq_unregister(intr_handle, roc_pf_vf_flr_irq, dev,
 822                            RVU_PF_INT_VEC_VFFLR1);
 823
 824         return 0;
 825 }
 826
 827 static int
 828 vf_flr_register_irqs(struct plt_pci_device *pci_dev, struct dev *dev)
 829 {
 830         struct plt_intr_handle *handle = &pci_dev->intr_handle;
 831         int i, rc;
 832
 833         plt_base_dbg("Register VF FLR interrupts for %s", pci_dev->name);
 834
 835         rc = dev_irq_register(handle, roc_pf_vf_flr_irq, dev,
 836                               RVU_PF_INT_VEC_VFFLR0);
 837         if (rc)
 838                 plt_err("Failed to init RVU_PF_INT_VEC_VFFLR0 rc=%d", rc);
 839
 840         rc = dev_irq_register(handle, roc_pf_vf_flr_irq, dev,
 841                               RVU_PF_INT_VEC_VFFLR1);
 842         if (rc)
 843                 plt_err("Failed to init RVU_PF_INT_VEC_VFFLR1 rc=%d", rc);
 844
 845         /* Enable HW interrupt */
 846         for (i = 0; i < MAX_VFPF_DWORD_BITS; ++i) {
 847                 plt_write64(~0ull, dev->bar2 + RVU_PF_VFFLR_INTX(i));
 848                 plt_write64(~0ull, dev->bar2 + RVU_PF_VFTRPENDX(i));
 849                 plt_write64(~0ull, dev->bar2 + RVU_PF_VFFLR_INT_ENA_W1SX(i));
 850         }
 851         return 0;
 852 }
 853
 854 int
 855 dev_active_vfs(struct dev *dev)
 856 {
 857         int i, count = 0;
 858
 859         for (i = 0; i < MAX_VFPF_DWORD_BITS; i++)
 860                 count += __builtin_popcount(dev->active_vfs[i]);
 861
 862         return count;
 863 }
 864
 865 static void
 866 dev_vf_hwcap_update(struct plt_pci_device *pci_dev, struct dev *dev)
 867 {
 868         switch (pci_dev->id.device_id) {
 869         case PCI_DEVID_CNXK_RVU_PF:
 870                 break;
 871         case PCI_DEVID_CNXK_RVU_SSO_TIM_VF:
 872         case PCI_DEVID_CNXK_RVU_NPA_VF:
 873         case PCI_DEVID_CN10K_RVU_CPT_VF:
 874         case PCI_DEVID_CN9K_RVU_CPT_VF:
 875         case PCI_DEVID_CNXK_RVU_AF_VF:
 876         case PCI_DEVID_CNXK_RVU_VF:
 877         case PCI_DEVID_CNXK_RVU_SDP_VF:
 878                 dev->hwcap |= DEV_HWCAP_F_VF;
 879                 break;
 880         }
 881 }
 882
 883 static uintptr_t
 884 dev_vf_mbase_get(struct plt_pci_device *pci_dev, struct dev *dev)
 885 {
 886         void *vf_mbase = NULL;
 887         uintptr_t pa;
 888
 889         if (dev_is_vf(dev))
 890                 return 0;
 891
 892         /* For CN10K onwards, it is just after PF MBOX */
 893         if (!roc_model_is_cn9k())
 894                 return dev->bar4 + MBOX_SIZE;
 895
 896         pa = plt_read64(dev->bar2 + RVU_PF_VF_BAR4_ADDR);
 897         if (!pa) {
 898                 plt_err("Invalid VF mbox base pa");
 899                 return pa;
 900         }
 901
 902         vf_mbase = mbox_mem_map(pa, MBOX_SIZE * pci_dev->max_vfs);
 903         if (vf_mbase == MAP_FAILED) {
 904                 plt_err("Failed to mmap vf mbase at pa 0x%lx, rc=%d", pa,
 905                         errno);
 906                 return 0;
 907         }
 908         return (uintptr_t)vf_mbase;
 909 }
 910
 911 static void
 912 dev_vf_mbase_put(struct plt_pci_device *pci_dev, uintptr_t vf_mbase)
 913 {
 914         if (!vf_mbase || !pci_dev->max_vfs || !roc_model_is_cn9k())
 915                 return;
 916
 917         mbox_mem_unmap((void *)vf_mbase, MBOX_SIZE * pci_dev->max_vfs);
 918 }
 919
 920 static int
 921 dev_setup_shared_lmt_region(struct mbox *mbox, bool valid_iova, uint64_t iova)
 922 {
 923         struct lmtst_tbl_setup_req *req;
 924
 925         req = mbox_alloc_msg_lmtst_tbl_setup(mbox);
 926         /* This pcifunc is defined with primary pcifunc whose LMT address
 927          * will be shared. If call contains valid IOVA, following pcifunc
 928          * field is of no use.
 929          */
 930         req->pcifunc = valid_iova ? 0 : idev_lmt_pffunc_get();
 931         req->use_local_lmt_region = valid_iova;
 932         req->lmt_iova = iova;
 933
 934         return mbox_process(mbox);
 935 }
 936
 937 /* Total no of lines * size of each lmtline */
 938 #define LMT_REGION_SIZE (ROC_NUM_LMT_LINES * ROC_LMT_LINE_SZ)
 939 static int
 940 dev_lmt_setup(struct dev *dev)
 941 {
 942         char name[PLT_MEMZONE_NAMESIZE];
 943         const struct plt_memzone *mz;
 944         struct idev_cfg *idev;
 945         int rc;
 946
 947         if (roc_model_is_cn9k()) {
 948                 dev->lmt_base = dev->bar2 + (RVU_BLOCK_ADDR_LMT << 20);
 949                 return 0;
 950         }
 951
 952         /* [CN10K, .) */
 953
 954         /* Set common lmt region from second pf_func onwards. */
 955         if (!dev->disable_shared_lmt && idev_lmt_pffunc_get() &&
 956             dev->pf_func != idev_lmt_pffunc_get()) {
 957                 rc = dev_setup_shared_lmt_region(dev->mbox, false, 0);
 958                 if (!rc) {
 959                         /* On success, updating lmt base of secondary pf_funcs
 960                          * with primary pf_func's lmt base.
 961                          */
 962                         dev->lmt_base = roc_idev_lmt_base_addr_get();
 963                         return rc;
 964                 }
 965                 plt_err("Failed to setup shared lmt region, pf_func %d err %d "
 966                         "Using respective LMT region per pf func",
 967                         dev->pf_func, rc);
 968         }
 969
 970         /* Allocating memory for LMT region */
 971         sprintf(name, "LMT_MAP%x", dev->pf_func);
 972
 973         /* Setting alignment to ensure correct masking for resetting to lmt base
 974          * of a core after all lmt lines under that core are used.
 975          * Alignment value LMT_REGION_SIZE to handle the case where all lines
 976          * are used by 1 core.
 977          */
 978         mz = plt_lmt_region_reserve_aligned(name, LMT_REGION_SIZE,
 979                                             LMT_REGION_SIZE);
 980         if (!mz) {
 981                 plt_err("Memory alloc failed: %s", strerror(errno));
 982                 goto fail;
 983         }
 984
 985         /* Share the IOVA address with Kernel */
 986         rc = dev_setup_shared_lmt_region(dev->mbox, true, mz->iova);
 987         if (rc) {
 988                 errno = rc;
 989                 goto free;
 990         }
 991
 992         dev->lmt_base = mz->iova;
 993         dev->lmt_mz = mz;
 994         /* Base LMT address should be chosen from only those pci funcs which
 995          * participate in LMT shared mode.
 996          */
 997         if (!dev->disable_shared_lmt) {
 998                 idev = idev_get_cfg();
 999                 if (!__atomic_load_n(&idev->lmt_pf_func, __ATOMIC_ACQUIRE)) {
1000                         idev->lmt_base_addr = dev->lmt_base;
1001                         idev->lmt_pf_func = dev->pf_func;
1002                         idev->num_lmtlines = RVU_LMT_LINE_MAX;
1003                 }
1004         }
1005
1006         return 0;
1007 free:
1008         plt_memzone_free(mz);
1009 fail:
1010         return -errno;
1011 }
1012
1013 int
1014 dev_init(struct dev *dev, struct plt_pci_device *pci_dev)
1015 {
1016         int direction, up_direction, rc;
1017         uintptr_t bar2, bar4, mbox;
1018         uintptr_t vf_mbase = 0;
1019         uint64_t intr_offset;
1020
1021         bar2 = (uintptr_t)pci_dev->mem_resource[2].addr;
1022         bar4 = (uintptr_t)pci_dev->mem_resource[4].addr;
1023         if (bar2 == 0 || bar4 == 0) {
1024                 plt_err("Failed to get PCI bars");
1025                 rc = -ENODEV;
1026                 goto error;
1027         }
1028
1029         /* Trigger fault on bar2 and bar4 regions
1030          * to avoid BUG_ON in remap_pfn_range()
1031          * in latest kernel.
1032          */
1033         *(volatile uint64_t *)bar2;
1034         *(volatile uint64_t *)bar4;
1035
1036         /* Check ROC model supported */
1037         if (roc_model->flag == 0) {
1038                 rc = UTIL_ERR_INVALID_MODEL;
1039                 goto error;
1040         }
1041
1042         dev->maxvf = pci_dev->max_vfs;
1043         dev->bar2 = bar2;
1044         dev->bar4 = bar4;
1045         dev_vf_hwcap_update(pci_dev, dev);
1046
1047         if (dev_is_vf(dev)) {
1048                 mbox = (roc_model_is_cn9k() ?
1049                         bar4 : (bar2 + RVU_VF_MBOX_REGION));
1050                 direction = MBOX_DIR_VFPF;
1051                 up_direction = MBOX_DIR_VFPF_UP;
1052                 intr_offset = RVU_VF_INT;
1053         } else {
1054                 mbox = bar4;
1055                 direction = MBOX_DIR_PFAF;
1056                 up_direction = MBOX_DIR_PFAF_UP;
1057                 intr_offset = RVU_PF_INT;
1058         }
1059
1060         /* Initialize the local mbox */
1061         rc = mbox_init(&dev->mbox_local, mbox, bar2, direction, 1, intr_offset);
1062         if (rc)
1063                 goto error;
1064         dev->mbox = &dev->mbox_local;
1065
1066         rc = mbox_init(&dev->mbox_up, mbox, bar2, up_direction, 1, intr_offset);
1067         if (rc)
1068                 goto mbox_fini;
1069
1070         /* Register mbox interrupts */
1071         rc = mbox_register_irq(pci_dev, dev);
1072         if (rc)
1073                 goto mbox_fini;
1074
1075         /* Check the readiness of PF/VF */
1076         rc = send_ready_msg(dev->mbox, &dev->pf_func);
1077         if (rc)
1078                 goto mbox_unregister;
1079
1080         dev->pf = dev_get_pf(dev->pf_func);
1081         dev->vf = dev_get_vf(dev->pf_func);
1082         memset(&dev->active_vfs, 0, sizeof(dev->active_vfs));
1083
1084         /* Allocate memory for device ops */
1085         dev->ops = plt_zmalloc(sizeof(struct dev_ops), 0);
1086         if (dev->ops == NULL) {
1087                 rc = -ENOMEM;
1088                 goto mbox_unregister;
1089         }
1090
1091         /* Found VF devices in a PF device */
1092         if (pci_dev->max_vfs > 0) {
1093                 /* Remap mbox area for all vf's */
1094                 vf_mbase = dev_vf_mbase_get(pci_dev, dev);
1095                 if (!vf_mbase) {
1096                         rc = -ENODEV;
1097                         goto mbox_unregister;
1098                 }
1099                 /* Init mbox object */
1100                 rc = mbox_init(&dev->mbox_vfpf, vf_mbase, bar2, MBOX_DIR_PFVF,
1101                                pci_dev->max_vfs, intr_offset);
1102                 if (rc)
1103                         goto iounmap;
1104
1105                 /* PF -> VF UP messages */
1106                 rc = mbox_init(&dev->mbox_vfpf_up, vf_mbase, bar2,
1107                                MBOX_DIR_PFVF_UP, pci_dev->max_vfs, intr_offset);
1108                 if (rc)
1109                         goto iounmap;
1110         }
1111
1112         /* Register VF-FLR irq handlers */
1113         if (!dev_is_vf(dev)) {
1114                 rc = vf_flr_register_irqs(pci_dev, dev);
1115                 if (rc)
1116                         goto iounmap;
1117         }
1118         dev->mbox_active = 1;
1119
1120         rc = npa_lf_init(dev, pci_dev);
1121         if (rc)
1122                 goto iounmap;
1123
1124         /* Setup LMT line base */
1125         rc = dev_lmt_setup(dev);
1126         if (rc)
1127                 goto iounmap;
1128
1129         return rc;
1130 iounmap:
1131         dev_vf_mbase_put(pci_dev, vf_mbase);
1132 mbox_unregister:
1133         mbox_unregister_irq(pci_dev, dev);
1134         if (dev->ops)
1135                 plt_free(dev->ops);
1136 mbox_fini:
1137         mbox_fini(dev->mbox);
1138         mbox_fini(&dev->mbox_up);
1139 error:
1140         return rc;
1141 }
1142
1143 int
1144 dev_fini(struct dev *dev, struct plt_pci_device *pci_dev)
1145 {
1146         struct plt_intr_handle *intr_handle = &pci_dev->intr_handle;
1147         struct mbox *mbox;
1148
1149         /* Check if this dev hosts npalf and has 1+ refs */
1150         if (idev_npa_lf_active(dev) > 1)
1151                 return -EAGAIN;
1152
1153         /* Clear references to this pci dev */
1154         npa_lf_fini();
1155
1156         /* Releasing memory allocated for lmt region */
1157         if (dev->lmt_mz)
1158                 plt_memzone_free(dev->lmt_mz);
1159
1160         mbox_unregister_irq(pci_dev, dev);
1161
1162         if (!dev_is_vf(dev))
1163                 vf_flr_unregister_irqs(pci_dev, dev);
1164         /* Release PF - VF */
1165         mbox = &dev->mbox_vfpf;
1166         if (mbox->hwbase && mbox->dev)
1167                 dev_vf_mbase_put(pci_dev, mbox->hwbase);
1168
1169         if (dev->ops)
1170                 plt_free(dev->ops);
1171
1172         mbox_fini(mbox);
1173         mbox = &dev->mbox_vfpf_up;
1174         mbox_fini(mbox);
1175
1176         /* Release PF - AF */
1177         mbox = dev->mbox;
1178         mbox_fini(mbox);
1179         mbox = &dev->mbox_up;
1180         mbox_fini(mbox);
1181         dev->mbox_active = 0;
1182
1183         /* Disable MSIX vectors */
1184         dev_irqs_disable(intr_handle);
1185         return 0;
1186 }