drivers/common/octeontx2/otx2_dev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2019 Marvell International Ltd.
   3  */
   4
   5 #include <fcntl.h>
   6 #include <inttypes.h>
   7 #include <sys/mman.h>
   8 #include <unistd.h>
   9
  10 #include <rte_alarm.h>
  11 #include <rte_common.h>
  12 #include <rte_eal.h>
  13 #include <rte_memcpy.h>
  14
  15 #include "otx2_dev.h"
  16 #include "otx2_mbox.h"
  17
  18 #define RVU_MAX_VF              64 /* RVU_PF_VFPF_MBOX_INT(0..1) */
  19 #define RVU_MAX_INT_RETRY       3
  20
  21 /* PF/VF message handling timer */
  22 #define VF_PF_MBOX_TIMER_MS     (20 * 1000)
  23
  24 static void *
  25 mbox_mem_map(off_t off, size_t size)
  26 {
  27         void *va = MAP_FAILED;
  28         int mem_fd;
  29
  30         if (size <= 0)
  31                 goto error;
  32
  33         mem_fd = open("/dev/mem", O_RDWR);
  34         if (mem_fd < 0)
  35                 goto error;
  36
  37         va = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, mem_fd, off);
  38         close(mem_fd);
  39
  40         if (va == MAP_FAILED)
  41                 otx2_err("Failed to mmap sz=0x%zx, fd=%d, off=%jd",
  42                          size, mem_fd, (intmax_t)off);
  43 error:
  44         return va;
  45 }
  46
  47 static void
  48 mbox_mem_unmap(void *va, size_t size)
  49 {
  50         if (va)
  51                 munmap(va, size);
  52 }
  53
  54 static int
  55 pf_af_sync_msg(struct otx2_dev *dev, struct mbox_msghdr **rsp)
  56 {
  57         uint32_t timeout = 0, sleep = 1; struct otx2_mbox *mbox = dev->mbox;
  58         struct otx2_mbox_dev *mdev = &mbox->dev[0];
  59         volatile uint64_t int_status;
  60         struct mbox_msghdr *msghdr;
  61         uint64_t off;
  62         int rc = 0;
  63
  64         /* We need to disable PF interrupts. We are in timer interrupt */
  65         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1C);
  66
  67         /* Send message */
  68         otx2_mbox_msg_send(mbox, 0);
  69
  70         do {
  71                 rte_delay_ms(sleep);
  72                 timeout += sleep;
  73                 if (timeout >= MBOX_RSP_TIMEOUT) {
  74                         otx2_err("Message timeout: %dms", MBOX_RSP_TIMEOUT);
  75                         rc = -EIO;
  76                         break;
  77                 }
  78                 int_status = otx2_read64(dev->bar2 + RVU_PF_INT);
  79         } while ((int_status & 0x1) != 0x1);
  80
  81         /* Clear */
  82         otx2_write64(int_status, dev->bar2 + RVU_PF_INT);
  83
  84         /* Enable interrupts */
  85         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1S);
  86
  87         if (rc == 0) {
  88                 /* Get message */
  89                 off = mbox->rx_start +
  90                         RTE_ALIGN(sizeof(struct mbox_hdr), MBOX_MSG_ALIGN);
  91                 msghdr = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + off);
  92                 if (rsp)
  93                         *rsp = msghdr;
  94                 rc = msghdr->rc;
  95         }
  96
  97         return rc;
  98 }
  99
 100 static int
 101 af_pf_wait_msg(struct otx2_dev *dev, uint16_t vf, int num_msg)
 102 {
 103         uint32_t timeout = 0, sleep = 1; struct otx2_mbox *mbox = dev->mbox;
 104         struct otx2_mbox_dev *mdev = &mbox->dev[0];
 105         volatile uint64_t int_status;
 106         struct mbox_hdr *req_hdr;
 107         struct mbox_msghdr *msg;
 108         struct mbox_msghdr *rsp;
 109         uint64_t offset;
 110         size_t size;
 111         int i;
 112
 113         /* We need to disable PF interrupts. We are in timer interrupt */
 114         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1C);
 115
 116         /* Send message */
 117         otx2_mbox_msg_send(mbox, 0);
 118
 119         do {
 120                 rte_delay_ms(sleep);
 121                 timeout++;
 122                 if (timeout >= MBOX_RSP_TIMEOUT) {
 123                         otx2_err("Routed messages %d timeout: %dms",
 124                                  num_msg, MBOX_RSP_TIMEOUT);
 125                         break;
 126                 }
 127                 int_status = otx2_read64(dev->bar2 + RVU_PF_INT);
 128         } while ((int_status & 0x1) != 0x1);
 129
 130         /* Clear */
 131         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT);
 132
 133         /* Enable interrupts */
 134         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1S);
 135
 136         rte_spinlock_lock(&mdev->mbox_lock);
 137
 138         req_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
 139         if (req_hdr->num_msgs != num_msg)
 140                 otx2_err("Routed messages: %d received: %d", num_msg,
 141                          req_hdr->num_msgs);
 142
 143         /* Get messages from mbox */
 144         offset = mbox->rx_start +
 145                         RTE_ALIGN(sizeof(struct mbox_hdr), MBOX_MSG_ALIGN);
 146         for (i = 0; i < req_hdr->num_msgs; i++) {
 147                 msg = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
 148                 size = mbox->rx_start + msg->next_msgoff - offset;
 149
 150                 /* Reserve PF/VF mbox message */
 151                 size = RTE_ALIGN(size, MBOX_MSG_ALIGN);
 152                 rsp = otx2_mbox_alloc_msg(&dev->mbox_vfpf, vf, size);
 153                 otx2_mbox_rsp_init(msg->id, rsp);
 154
 155                 /* Copy message from AF<->PF mbox to PF<->VF mbox */
 156                 otx2_mbox_memcpy((uint8_t *)rsp + sizeof(struct mbox_msghdr),
 157                                  (uint8_t *)msg + sizeof(struct mbox_msghdr),
 158                                  size - sizeof(struct mbox_msghdr));
 159
 160                 /* Set status and sender pf_func data */
 161                 rsp->rc = msg->rc;
 162                 rsp->pcifunc = msg->pcifunc;
 163
 164                 offset = mbox->rx_start + msg->next_msgoff;
 165         }
 166         rte_spinlock_unlock(&mdev->mbox_lock);
 167
 168         return req_hdr->num_msgs;
 169 }
 170
 171 static int
 172 vf_pf_process_msgs(struct otx2_dev *dev, uint16_t vf)
 173 {
 174         int offset, routed = 0; struct otx2_mbox *mbox = &dev->mbox_vfpf;
 175         struct otx2_mbox_dev *mdev = &mbox->dev[vf];
 176         struct mbox_hdr *req_hdr;
 177         struct mbox_msghdr *msg;
 178         size_t size;
 179         uint16_t i;
 180
 181         req_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
 182         if (!req_hdr->num_msgs)
 183                 return 0;
 184
 185         offset = mbox->rx_start + RTE_ALIGN(sizeof(*req_hdr), MBOX_MSG_ALIGN);
 186
 187         for (i = 0; i < req_hdr->num_msgs; i++) {
 188
 189                 msg = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
 190                 size = mbox->rx_start + msg->next_msgoff - offset;
 191
 192                 /* RVU_PF_FUNC_S */
 193                 msg->pcifunc = otx2_pfvf_func(dev->pf, vf);
 194
 195                 if (msg->id == MBOX_MSG_READY) {
 196                         struct ready_msg_rsp *rsp;
 197                         uint16_t max_bits = sizeof(dev->active_vfs[0]) * 8;
 198
 199                         /* Handle READY message in PF */
 200                         dev->active_vfs[vf / max_bits] |=
 201                                                 BIT_ULL(vf % max_bits);
 202                         rsp = (struct ready_msg_rsp *)
 203                                otx2_mbox_alloc_msg(mbox, vf, sizeof(*rsp));
 204                         otx2_mbox_rsp_init(msg->id, rsp);
 205
 206                         /* PF/VF function ID */
 207                         rsp->hdr.pcifunc = msg->pcifunc;
 208                         rsp->hdr.rc = 0;
 209                 } else {
 210                         struct mbox_msghdr *af_req;
 211                         /* Reserve AF/PF mbox message */
 212                         size = RTE_ALIGN(size, MBOX_MSG_ALIGN);
 213                         af_req = otx2_mbox_alloc_msg(dev->mbox, 0, size);
 214                         otx2_mbox_req_init(msg->id, af_req);
 215
 216                         /* Copy message from VF<->PF mbox to PF<->AF mbox */
 217                         otx2_mbox_memcpy((uint8_t *)af_req +
 218                                    sizeof(struct mbox_msghdr),
 219                                    (uint8_t *)msg + sizeof(struct mbox_msghdr),
 220                                    size - sizeof(struct mbox_msghdr));
 221                         af_req->pcifunc = msg->pcifunc;
 222                         routed++;
 223                 }
 224                 offset = mbox->rx_start + msg->next_msgoff;
 225         }
 226
 227         if (routed > 0) {
 228                 otx2_base_dbg("pf:%d routed %d messages from vf:%d to AF",
 229                               dev->pf, routed, vf);
 230                 af_pf_wait_msg(dev, vf, routed);
 231                 otx2_mbox_reset(dev->mbox, 0);
 232         }
 233
 234         /* Send mbox responses to VF */
 235         if (mdev->num_msgs) {
 236                 otx2_base_dbg("pf:%d reply %d messages to vf:%d",
 237                               dev->pf, mdev->num_msgs, vf);
 238                 otx2_mbox_msg_send(mbox, vf);
 239         }
 240
 241         return i;
 242 }
 243
 244 static int
 245 vf_pf_process_up_msgs(struct otx2_dev *dev, uint16_t vf)
 246 {
 247         struct otx2_mbox *mbox = &dev->mbox_vfpf_up;
 248         struct otx2_mbox_dev *mdev = &mbox->dev[vf];
 249         struct mbox_hdr *req_hdr;
 250         struct mbox_msghdr *msg;
 251         int msgs_acked = 0;
 252         int offset;
 253         uint16_t i;
 254
 255         req_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
 256         if (req_hdr->num_msgs == 0)
 257                 return 0;
 258
 259         offset = mbox->rx_start + RTE_ALIGN(sizeof(*req_hdr), MBOX_MSG_ALIGN);
 260
 261         for (i = 0; i < req_hdr->num_msgs; i++) {
 262                 msg = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
 263
 264                 msgs_acked++;
 265                 /* RVU_PF_FUNC_S */
 266                 msg->pcifunc = otx2_pfvf_func(dev->pf, vf);
 267
 268                 switch (msg->id) {
 269                 case MBOX_MSG_CGX_LINK_EVENT:
 270                         otx2_base_dbg("PF: Msg 0x%x (%s) fn:0x%x (pf:%d,vf:%d)",
 271                                       msg->id, otx2_mbox_id2name(msg->id),
 272                                       msg->pcifunc, otx2_get_pf(msg->pcifunc),
 273                                       otx2_get_vf(msg->pcifunc));
 274                         break;
 275                 case MBOX_MSG_CGX_PTP_RX_INFO:
 276                         otx2_base_dbg("PF: Msg 0x%x (%s) fn:0x%x (pf:%d,vf:%d)",
 277                                       msg->id, otx2_mbox_id2name(msg->id),
 278                                       msg->pcifunc, otx2_get_pf(msg->pcifunc),
 279                                       otx2_get_vf(msg->pcifunc));
 280                         break;
 281                 default:
 282                         otx2_err("Not handled UP msg 0x%x (%s) func:0x%x",
 283                                  msg->id, otx2_mbox_id2name(msg->id),
 284                                  msg->pcifunc);
 285                 }
 286                 offset = mbox->rx_start + msg->next_msgoff;
 287         }
 288         otx2_mbox_reset(mbox, vf);
 289         mdev->msgs_acked = msgs_acked;
 290         rte_wmb();
 291
 292         return i;
 293 }
 294
 295 static void
 296 otx2_vf_pf_mbox_handle_msg(void *param)
 297 {
 298         uint16_t vf, max_vf, max_bits;
 299         struct otx2_dev *dev = param;
 300
 301         max_bits = sizeof(dev->intr.bits[0]) * sizeof(uint64_t);
 302         max_vf = max_bits * MAX_VFPF_DWORD_BITS;
 303
 304         for (vf = 0; vf < max_vf; vf++) {
 305                 if (dev->intr.bits[vf/max_bits] & BIT_ULL(vf%max_bits)) {
 306                         otx2_base_dbg("Process vf:%d request (pf:%d, vf:%d)",
 307                                        vf, dev->pf, dev->vf);
 308                         vf_pf_process_msgs(dev, vf);
 309                         /* UP messages */
 310                         vf_pf_process_up_msgs(dev, vf);
 311                         dev->intr.bits[vf/max_bits] &= ~(BIT_ULL(vf%max_bits));
 312                 }
 313         }
 314         dev->timer_set = 0;
 315 }
 316
 317 static void
 318 otx2_vf_pf_mbox_irq(void *param)
 319 {
 320         struct otx2_dev *dev = param;
 321         bool alarm_set = false;
 322         uint64_t intr;
 323         int vfpf;
 324
 325         for (vfpf = 0; vfpf < MAX_VFPF_DWORD_BITS; ++vfpf) {
 326                 intr = otx2_read64(dev->bar2 + RVU_PF_VFPF_MBOX_INTX(vfpf));
 327                 if (!intr)
 328                         continue;
 329
 330                 otx2_base_dbg("vfpf: %d intr: 0x%" PRIx64 " (pf:%d, vf:%d)",
 331                               vfpf, intr, dev->pf, dev->vf);
 332
 333                 /* Save and clear intr bits */
 334                 dev->intr.bits[vfpf] |= intr;
 335                 otx2_write64(intr, dev->bar2 + RVU_PF_VFPF_MBOX_INTX(vfpf));
 336                 alarm_set = true;
 337         }
 338
 339         if (!dev->timer_set && alarm_set) {
 340                 dev->timer_set = 1;
 341                 /* Start timer to handle messages */
 342                 rte_eal_alarm_set(VF_PF_MBOX_TIMER_MS,
 343                                   otx2_vf_pf_mbox_handle_msg, dev);
 344         }
 345 }
 346
 347 static void
 348 otx2_process_msgs(struct otx2_dev *dev, struct otx2_mbox *mbox)
 349 {
 350         struct otx2_mbox_dev *mdev = &mbox->dev[0];
 351         struct mbox_hdr *req_hdr;
 352         struct mbox_msghdr *msg;
 353         int msgs_acked = 0;
 354         int offset;
 355         uint16_t i;
 356
 357         req_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
 358         if (req_hdr->num_msgs == 0)
 359                 return;
 360
 361         offset = mbox->rx_start + RTE_ALIGN(sizeof(*req_hdr), MBOX_MSG_ALIGN);
 362         for (i = 0; i < req_hdr->num_msgs; i++) {
 363                 msg = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
 364
 365                 msgs_acked++;
 366                 otx2_base_dbg("Message 0x%x (%s) pf:%d/vf:%d",
 367                               msg->id, otx2_mbox_id2name(msg->id),
 368                               otx2_get_pf(msg->pcifunc),
 369                               otx2_get_vf(msg->pcifunc));
 370
 371                 switch (msg->id) {
 372                         /* Add message id's that are handled here */
 373                 case MBOX_MSG_READY:
 374                         /* Get our identity */
 375                         dev->pf_func = msg->pcifunc;
 376                         break;
 377
 378                 default:
 379                         if (msg->rc)
 380                                 otx2_err("Message (%s) response has err=%d",
 381                                          otx2_mbox_id2name(msg->id), msg->rc);
 382                         break;
 383                 }
 384                 offset = mbox->rx_start + msg->next_msgoff;
 385         }
 386
 387         otx2_mbox_reset(mbox, 0);
 388         /* Update acked if someone is waiting a message */
 389         mdev->msgs_acked = msgs_acked;
 390         rte_wmb();
 391 }
 392
 393 /* Copies the message received from AF and sends it to VF */
 394 static void
 395 pf_vf_mbox_send_up_msg(struct otx2_dev *dev, void *rec_msg)
 396 {
 397         uint16_t max_bits = sizeof(dev->active_vfs[0]) * sizeof(uint64_t);
 398         struct otx2_mbox *vf_mbox = &dev->mbox_vfpf_up;
 399         struct msg_req *msg = rec_msg;
 400         struct mbox_msghdr *vf_msg;
 401         uint16_t vf;
 402         size_t size;
 403
 404         size = RTE_ALIGN(otx2_mbox_id2size(msg->hdr.id), MBOX_MSG_ALIGN);
 405         /* Send UP message to all VF's */
 406         for (vf = 0; vf < vf_mbox->ndevs; vf++) {
 407                 /* VF active */
 408                 if (!(dev->active_vfs[vf / max_bits] & (BIT_ULL(vf))))
 409                         continue;
 410
 411                 otx2_base_dbg("(%s) size: %zx to VF: %d",
 412                               otx2_mbox_id2name(msg->hdr.id), size, vf);
 413
 414                 /* Reserve PF/VF mbox message */
 415                 vf_msg = otx2_mbox_alloc_msg(vf_mbox, vf, size);
 416                 if (!vf_msg) {
 417                         otx2_err("Failed to alloc VF%d UP message", vf);
 418                         continue;
 419                 }
 420                 otx2_mbox_req_init(msg->hdr.id, vf_msg);
 421
 422                 /*
 423                  * Copy message from AF<->PF UP mbox
 424                  * to PF<->VF UP mbox
 425                  */
 426                 otx2_mbox_memcpy((uint8_t *)vf_msg +
 427                                  sizeof(struct mbox_msghdr), (uint8_t *)msg
 428                                  + sizeof(struct mbox_msghdr), size -
 429                                  sizeof(struct mbox_msghdr));
 430
 431                 vf_msg->rc = msg->hdr.rc;
 432                 /* Set PF to be a sender */
 433                 vf_msg->pcifunc = dev->pf_func;
 434
 435                 /* Send to VF */
 436                 otx2_mbox_msg_send(vf_mbox, vf);
 437         }
 438 }
 439
 440 static int
 441 otx2_mbox_up_handler_cgx_link_event(struct otx2_dev *dev,
 442                                     struct cgx_link_info_msg *msg,
 443                                     struct msg_rsp *rsp)
 444 {
 445         struct cgx_link_user_info *linfo = &msg->link_info;
 446
 447         otx2_base_dbg("pf:%d/vf:%d NIC Link %s --> 0x%x (%s) from: pf:%d/vf:%d",
 448                       otx2_get_pf(dev->pf_func), otx2_get_vf(dev->pf_func),
 449                       linfo->link_up ? "UP" : "DOWN", msg->hdr.id,
 450                       otx2_mbox_id2name(msg->hdr.id),
 451                       otx2_get_pf(msg->hdr.pcifunc),
 452                       otx2_get_vf(msg->hdr.pcifunc));
 453
 454         /* PF gets link notification from AF */
 455         if (otx2_get_pf(msg->hdr.pcifunc) == 0) {
 456                 if (dev->ops && dev->ops->link_status_update)
 457                         dev->ops->link_status_update(dev, linfo);
 458
 459                 /* Forward the same message as received from AF to VF */
 460                 pf_vf_mbox_send_up_msg(dev, msg);
 461         } else {
 462                 /* VF gets link up notification */
 463                 if (dev->ops && dev->ops->link_status_update)
 464                         dev->ops->link_status_update(dev, linfo);
 465         }
 466
 467         rsp->hdr.rc = 0;
 468         return 0;
 469 }
 470
 471 static int
 472 otx2_mbox_up_handler_cgx_ptp_rx_info(struct otx2_dev *dev,
 473                                      struct cgx_ptp_rx_info_msg *msg,
 474                                      struct msg_rsp *rsp)
 475 {
 476         otx2_nix_dbg("pf:%d/vf:%d PTP mode %s --> 0x%x (%s) from: pf:%d/vf:%d",
 477                  otx2_get_pf(dev->pf_func),
 478                  otx2_get_vf(dev->pf_func),
 479                  msg->ptp_en ? "ENABLED" : "DISABLED",
 480                  msg->hdr.id, otx2_mbox_id2name(msg->hdr.id),
 481                  otx2_get_pf(msg->hdr.pcifunc),
 482                  otx2_get_vf(msg->hdr.pcifunc));
 483
 484         /* PF gets PTP notification from AF */
 485         if (otx2_get_pf(msg->hdr.pcifunc) == 0) {
 486                 if (dev->ops && dev->ops->ptp_info_update)
 487                         dev->ops->ptp_info_update(dev, msg->ptp_en);
 488
 489                 /* Forward the same message as received from AF to VF */
 490                 pf_vf_mbox_send_up_msg(dev, msg);
 491         } else {
 492                 /* VF gets PTP notification */
 493                 if (dev->ops && dev->ops->ptp_info_update)
 494                         dev->ops->ptp_info_update(dev, msg->ptp_en);
 495         }
 496
 497         rsp->hdr.rc = 0;
 498         return 0;
 499 }
 500
 501 static int
 502 mbox_process_msgs_up(struct otx2_dev *dev, struct mbox_msghdr *req)
 503 {
 504         /* Check if valid, if not reply with a invalid msg */
 505         if (req->sig != OTX2_MBOX_REQ_SIG)
 506                 return -EIO;
 507
 508         switch (req->id) {
 509 #define M(_name, _id, _fn_name, _req_type, _rsp_type)           \
 510         case _id: {                                             \
 511                 struct _rsp_type *rsp;                          \
 512                 int err;                                        \
 513                                                                 \
 514                 rsp = (struct _rsp_type *)otx2_mbox_alloc_msg(  \
 515                         &dev->mbox_up, 0,                       \
 516                         sizeof(struct _rsp_type));              \
 517                 if (!rsp)                                       \
 518                         return -ENOMEM;                         \
 519                                                                 \
 520                 rsp->hdr.id = _id;                              \
 521                 rsp->hdr.sig = OTX2_MBOX_RSP_SIG;               \
 522                 rsp->hdr.pcifunc = dev->pf_func;                \
 523                 rsp->hdr.rc = 0;                                \
 524                                                                 \
 525                 err = otx2_mbox_up_handler_ ## _fn_name(        \
 526                         dev, (struct _req_type *)req, rsp);     \
 527                 return err;                                     \
 528         }
 529 MBOX_UP_CGX_MESSAGES
 530 #undef M
 531
 532         default :
 533                 otx2_reply_invalid_msg(&dev->mbox_up, 0, 0, req->id);
 534         }
 535
 536         return -ENODEV;
 537 }
 538
 539 static void
 540 otx2_process_msgs_up(struct otx2_dev *dev, struct otx2_mbox *mbox)
 541 {
 542         struct otx2_mbox_dev *mdev = &mbox->dev[0];
 543         struct mbox_hdr *req_hdr;
 544         struct mbox_msghdr *msg;
 545         int i, err, offset;
 546
 547         req_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
 548         if (req_hdr->num_msgs == 0)
 549                 return;
 550
 551         offset = mbox->rx_start + RTE_ALIGN(sizeof(*req_hdr), MBOX_MSG_ALIGN);
 552         for (i = 0; i < req_hdr->num_msgs; i++) {
 553                 msg = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
 554
 555                 otx2_base_dbg("Message 0x%x (%s) pf:%d/vf:%d",
 556                                 msg->id, otx2_mbox_id2name(msg->id),
 557                                 otx2_get_pf(msg->pcifunc),
 558                                 otx2_get_vf(msg->pcifunc));
 559                 err = mbox_process_msgs_up(dev, msg);
 560                 if (err)
 561                         otx2_err("Error %d handling 0x%x (%s)",
 562                                  err, msg->id, otx2_mbox_id2name(msg->id));
 563                 offset = mbox->rx_start + msg->next_msgoff;
 564         }
 565         /* Send mbox responses */
 566         if (mdev->num_msgs) {
 567                 otx2_base_dbg("Reply num_msgs:%d", mdev->num_msgs);
 568                 otx2_mbox_msg_send(mbox, 0);
 569         }
 570 }
 571
 572 static void
 573 otx2_pf_vf_mbox_irq(void *param)
 574 {
 575         struct otx2_dev *dev = param;
 576         uint64_t intr;
 577
 578         intr = otx2_read64(dev->bar2 + RVU_VF_INT);
 579         if (intr == 0)
 580                 otx2_base_dbg("Proceeding to check mbox UP messages if any");
 581
 582         otx2_write64(intr, dev->bar2 + RVU_VF_INT);
 583         otx2_base_dbg("Irq 0x%" PRIx64 "(pf:%d,vf:%d)", intr, dev->pf, dev->vf);
 584
 585         /* First process all configuration messages */
 586         otx2_process_msgs(dev, dev->mbox);
 587
 588         /* Process Uplink messages */
 589         otx2_process_msgs_up(dev, &dev->mbox_up);
 590 }
 591
 592 static void
 593 otx2_af_pf_mbox_irq(void *param)
 594 {
 595         struct otx2_dev *dev = param;
 596         uint64_t intr;
 597
 598         intr = otx2_read64(dev->bar2 + RVU_PF_INT);
 599         if (intr == 0)
 600                 otx2_base_dbg("Proceeding to check mbox UP messages if any");
 601
 602         otx2_write64(intr, dev->bar2 + RVU_PF_INT);
 603         otx2_base_dbg("Irq 0x%" PRIx64 "(pf:%d,vf:%d)", intr, dev->pf, dev->vf);
 604
 605         /* First process all configuration messages */
 606         otx2_process_msgs(dev, dev->mbox);
 607
 608         /* Process Uplink messages */
 609         otx2_process_msgs_up(dev, &dev->mbox_up);
 610 }
 611
 612 static int
 613 mbox_register_pf_irq(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 614 {
 615         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
 616         int i, rc;
 617
 618         /* HW clear irq */
 619         for (i = 0; i < MAX_VFPF_DWORD_BITS; ++i)
 620                 otx2_write64(~0ull, dev->bar2 +
 621                              RVU_PF_VFPF_MBOX_INT_ENA_W1CX(i));
 622
 623         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1C);
 624
 625         dev->timer_set = 0;
 626
 627         /* MBOX interrupt for VF(0...63) <-> PF */
 628         rc = otx2_register_irq(intr_handle, otx2_vf_pf_mbox_irq, dev,
 629                                RVU_PF_INT_VEC_VFPF_MBOX0);
 630
 631         if (rc) {
 632                 otx2_err("Fail to register PF(VF0-63) mbox irq");
 633                 return rc;
 634         }
 635         /* MBOX interrupt for VF(64...128) <-> PF */
 636         rc = otx2_register_irq(intr_handle, otx2_vf_pf_mbox_irq, dev,
 637                                RVU_PF_INT_VEC_VFPF_MBOX1);
 638
 639         if (rc) {
 640                 otx2_err("Fail to register PF(VF64-128) mbox irq");
 641                 return rc;
 642         }
 643         /* MBOX interrupt AF <-> PF */
 644         rc = otx2_register_irq(intr_handle, otx2_af_pf_mbox_irq,
 645                                dev, RVU_PF_INT_VEC_AFPF_MBOX);
 646         if (rc) {
 647                 otx2_err("Fail to register AF<->PF mbox irq");
 648                 return rc;
 649         }
 650
 651         /* HW enable intr */
 652         for (i = 0; i < MAX_VFPF_DWORD_BITS; ++i)
 653                 otx2_write64(~0ull, dev->bar2 +
 654                         RVU_PF_VFPF_MBOX_INT_ENA_W1SX(i));
 655
 656         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT);
 657         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1S);
 658
 659         return rc;
 660 }
 661
 662 static int
 663 mbox_register_vf_irq(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 664 {
 665         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
 666         int rc;
 667
 668         /* Clear irq */
 669         otx2_write64(~0ull, dev->bar2 + RVU_VF_INT_ENA_W1C);
 670
 671         /* MBOX interrupt PF <-> VF */
 672         rc = otx2_register_irq(intr_handle, otx2_pf_vf_mbox_irq,
 673                                dev, RVU_VF_INT_VEC_MBOX);
 674         if (rc) {
 675                 otx2_err("Fail to register PF<->VF mbox irq");
 676                 return rc;
 677         }
 678
 679         /* HW enable intr */
 680         otx2_write64(~0ull, dev->bar2 + RVU_VF_INT);
 681         otx2_write64(~0ull, dev->bar2 + RVU_VF_INT_ENA_W1S);
 682
 683         return rc;
 684 }
 685
 686 static int
 687 mbox_register_irq(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 688 {
 689         if (otx2_dev_is_vf(dev))
 690                 return mbox_register_vf_irq(pci_dev, dev);
 691         else
 692                 return mbox_register_pf_irq(pci_dev, dev);
 693 }
 694
 695 static void
 696 mbox_unregister_pf_irq(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 697 {
 698         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
 699         int i;
 700
 701         /* HW clear irq */
 702         for (i = 0; i < MAX_VFPF_DWORD_BITS; ++i)
 703                 otx2_write64(~0ull, dev->bar2 +
 704                              RVU_PF_VFPF_MBOX_INT_ENA_W1CX(i));
 705
 706         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1C);
 707
 708         dev->timer_set = 0;
 709
 710         rte_eal_alarm_cancel(otx2_vf_pf_mbox_handle_msg, dev);
 711
 712         /* Unregister the interrupt handler for each vectors */
 713         /* MBOX interrupt for VF(0...63) <-> PF */
 714         otx2_unregister_irq(intr_handle, otx2_vf_pf_mbox_irq, dev,
 715                             RVU_PF_INT_VEC_VFPF_MBOX0);
 716
 717         /* MBOX interrupt for VF(64...128) <-> PF */
 718         otx2_unregister_irq(intr_handle, otx2_vf_pf_mbox_irq, dev,
 719                             RVU_PF_INT_VEC_VFPF_MBOX1);
 720
 721         /* MBOX interrupt AF <-> PF */
 722         otx2_unregister_irq(intr_handle, otx2_af_pf_mbox_irq, dev,
 723                             RVU_PF_INT_VEC_AFPF_MBOX);
 724
 725 }
 726
 727 static void
 728 mbox_unregister_vf_irq(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 729 {
 730         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
 731
 732         /* Clear irq */
 733         otx2_write64(~0ull, dev->bar2 + RVU_VF_INT_ENA_W1C);
 734
 735         /* Unregister the interrupt handler */
 736         otx2_unregister_irq(intr_handle, otx2_pf_vf_mbox_irq, dev,
 737                             RVU_VF_INT_VEC_MBOX);
 738 }
 739
 740 static void
 741 mbox_unregister_irq(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 742 {
 743         if (otx2_dev_is_vf(dev))
 744                 mbox_unregister_vf_irq(pci_dev, dev);
 745         else
 746                 mbox_unregister_pf_irq(pci_dev, dev);
 747 }
 748
 749 static int
 750 vf_flr_send_msg(struct otx2_dev *dev, uint16_t vf)
 751 {
 752         struct otx2_mbox *mbox = dev->mbox;
 753         struct msg_req *req;
 754         int rc;
 755
 756         req = otx2_mbox_alloc_msg_vf_flr(mbox);
 757         /* Overwrite pcifunc to indicate VF */
 758         req->hdr.pcifunc = otx2_pfvf_func(dev->pf, vf);
 759
 760         /* Sync message in interrupt context */
 761         rc = pf_af_sync_msg(dev, NULL);
 762         if (rc)
 763                 otx2_err("Failed to send VF FLR mbox msg, rc=%d", rc);
 764
 765         return rc;
 766 }
 767
 768 static void
 769 otx2_pf_vf_flr_irq(void *param)
 770 {
 771         struct otx2_dev *dev = (struct otx2_dev *)param;
 772         uint16_t max_vf = 64, vf;
 773         uintptr_t bar2;
 774         uint64_t intr;
 775         int i;
 776
 777         max_vf = (dev->maxvf > 0) ? dev->maxvf : 64;
 778         bar2 = dev->bar2;
 779
 780         otx2_base_dbg("FLR VF interrupt: max_vf: %d", max_vf);
 781
 782         for (i = 0; i < MAX_VFPF_DWORD_BITS; ++i) {
 783                 intr = otx2_read64(bar2 + RVU_PF_VFFLR_INTX(i));
 784                 if (!intr)
 785                         continue;
 786
 787                 for (vf = 0; vf < max_vf; vf++) {
 788                         if (!(intr & (1ULL << vf)))
 789                                 continue;
 790
 791                         otx2_base_dbg("FLR: i :%d intr: 0x%" PRIx64 ", vf-%d",
 792                                       i, intr, (64 * i + vf));
 793                         /* Clear interrupt */
 794                         otx2_write64(BIT_ULL(vf), bar2 + RVU_PF_VFFLR_INTX(i));
 795                         /* Disable the interrupt */
 796                         otx2_write64(BIT_ULL(vf),
 797                                      bar2 + RVU_PF_VFFLR_INT_ENA_W1CX(i));
 798                         /* Inform AF about VF reset */
 799                         vf_flr_send_msg(dev, vf);
 800
 801                         /* Signal FLR finish */
 802                         otx2_write64(BIT_ULL(vf), bar2 + RVU_PF_VFTRPENDX(i));
 803                         /* Enable interrupt */
 804                         otx2_write64(~0ull,
 805                                      bar2 + RVU_PF_VFFLR_INT_ENA_W1SX(i));
 806                 }
 807         }
 808 }
 809
 810 static int
 811 vf_flr_unregister_irqs(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 812 {
 813         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
 814         int i;
 815
 816         otx2_base_dbg("Unregister VF FLR interrupts for %s", pci_dev->name);
 817
 818         /* HW clear irq */
 819         for (i = 0; i < MAX_VFPF_DWORD_BITS; i++)
 820                 otx2_write64(~0ull, dev->bar2 + RVU_PF_VFFLR_INT_ENA_W1CX(i));
 821
 822         otx2_unregister_irq(intr_handle, otx2_pf_vf_flr_irq, dev,
 823                             RVU_PF_INT_VEC_VFFLR0);
 824
 825         otx2_unregister_irq(intr_handle, otx2_pf_vf_flr_irq, dev,
 826                             RVU_PF_INT_VEC_VFFLR1);
 827
 828         return 0;
 829 }
 830
 831 static int
 832 vf_flr_register_irqs(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 833 {
 834         struct rte_intr_handle *handle = &pci_dev->intr_handle;
 835         int i, rc;
 836
 837         otx2_base_dbg("Register VF FLR interrupts for %s", pci_dev->name);
 838
 839         rc = otx2_register_irq(handle, otx2_pf_vf_flr_irq, dev,
 840                                RVU_PF_INT_VEC_VFFLR0);
 841         if (rc)
 842                 otx2_err("Failed to init RVU_PF_INT_VEC_VFFLR0 rc=%d", rc);
 843
 844         rc = otx2_register_irq(handle, otx2_pf_vf_flr_irq, dev,
 845                                RVU_PF_INT_VEC_VFFLR1);
 846         if (rc)
 847                 otx2_err("Failed to init RVU_PF_INT_VEC_VFFLR1 rc=%d", rc);
 848
 849         /* Enable HW interrupt */
 850         for (i = 0; i < MAX_VFPF_DWORD_BITS; ++i) {
 851                 otx2_write64(~0ull, dev->bar2 + RVU_PF_VFFLR_INTX(i));
 852                 otx2_write64(~0ull, dev->bar2 + RVU_PF_VFTRPENDX(i));
 853                 otx2_write64(~0ull, dev->bar2 + RVU_PF_VFFLR_INT_ENA_W1SX(i));
 854         }
 855         return 0;
 856 }
 857
 858 /**
 859  * @internal
 860  * Get number of active VFs for the given PF device.
 861  */
 862 int
 863 otx2_dev_active_vfs(void *otx2_dev)
 864 {
 865         struct otx2_dev *dev = otx2_dev;
 866         int i, count = 0;
 867
 868         for (i = 0; i < MAX_VFPF_DWORD_BITS; i++)
 869                 count += __builtin_popcount(dev->active_vfs[i]);
 870
 871         return count;
 872 }
 873
 874 static void
 875 otx2_update_vf_hwcap(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 876 {
 877         switch (pci_dev->id.device_id) {
 878         case PCI_DEVID_OCTEONTX2_RVU_PF:
 879                 break;
 880         case PCI_DEVID_OCTEONTX2_RVU_SSO_TIM_VF:
 881         case PCI_DEVID_OCTEONTX2_RVU_NPA_VF:
 882         case PCI_DEVID_OCTEONTX2_RVU_CPT_VF:
 883         case PCI_DEVID_OCTEONTX2_RVU_AF_VF:
 884         case PCI_DEVID_OCTEONTX2_RVU_VF:
 885         case PCI_DEVID_OCTEONTX2_RVU_SDP_VF:
 886                 dev->hwcap |= OTX2_HWCAP_F_VF;
 887                 break;
 888         }
 889 }
 890
 891 /**
 892  * @internal
 893  * Initialize the otx2 device
 894  */
 895 int
 896 otx2_dev_priv_init(struct rte_pci_device *pci_dev, void *otx2_dev)
 897 {
 898         int up_direction = MBOX_DIR_PFAF_UP;
 899         int rc, direction = MBOX_DIR_PFAF;
 900         uint64_t intr_offset = RVU_PF_INT;
 901         struct otx2_dev *dev = otx2_dev;
 902         uintptr_t bar2, bar4;
 903         uint64_t bar4_addr;
 904         void *hwbase;
 905
 906         bar2 = (uintptr_t)pci_dev->mem_resource[2].addr;
 907         bar4 = (uintptr_t)pci_dev->mem_resource[4].addr;
 908
 909         if (bar2 == 0 || bar4 == 0) {
 910                 otx2_err("Failed to get pci bars");
 911                 rc = -ENODEV;
 912                 goto error;
 913         }
 914
 915         dev->node = pci_dev->device.numa_node;
 916         dev->maxvf = pci_dev->max_vfs;
 917         dev->bar2 = bar2;
 918         dev->bar4 = bar4;
 919
 920         otx2_update_vf_hwcap(pci_dev, dev);
 921
 922         if (otx2_dev_is_vf(dev)) {
 923                 direction = MBOX_DIR_VFPF;
 924                 up_direction = MBOX_DIR_VFPF_UP;
 925                 intr_offset = RVU_VF_INT;
 926         }
 927
 928         /* Initialize the local mbox */
 929         rc = otx2_mbox_init(&dev->mbox_local, bar4, bar2, direction, 1,
 930                             intr_offset);
 931         if (rc)
 932                 goto error;
 933         dev->mbox = &dev->mbox_local;
 934
 935         rc = otx2_mbox_init(&dev->mbox_up, bar4, bar2, up_direction, 1,
 936                             intr_offset);
 937         if (rc)
 938                 goto error;
 939
 940         /* Register mbox interrupts */
 941         rc = mbox_register_irq(pci_dev, dev);
 942         if (rc)
 943                 goto mbox_fini;
 944
 945         /* Check the readiness of PF/VF */
 946         rc = otx2_send_ready_msg(dev->mbox, &dev->pf_func);
 947         if (rc)
 948                 goto mbox_unregister;
 949
 950         dev->pf = otx2_get_pf(dev->pf_func);
 951         dev->vf = otx2_get_vf(dev->pf_func);
 952         memset(&dev->active_vfs, 0, sizeof(dev->active_vfs));
 953
 954         /* Found VF devices in a PF device */
 955         if (pci_dev->max_vfs > 0) {
 956
 957                 /* Remap mbox area for all vf's */
 958                 bar4_addr = otx2_read64(bar2 + RVU_PF_VF_BAR4_ADDR);
 959                 if (bar4_addr == 0) {
 960                         rc = -ENODEV;
 961                         goto mbox_fini;
 962                 }
 963
 964                 hwbase = mbox_mem_map(bar4_addr, MBOX_SIZE * pci_dev->max_vfs);
 965                 if (hwbase == MAP_FAILED) {
 966                         rc = -ENOMEM;
 967                         goto mbox_fini;
 968                 }
 969                 /* Init mbox object */
 970                 rc = otx2_mbox_init(&dev->mbox_vfpf, (uintptr_t)hwbase,
 971                                     bar2, MBOX_DIR_PFVF, pci_dev->max_vfs,
 972                                     intr_offset);
 973                 if (rc)
 974                         goto iounmap;
 975
 976                 /* PF -> VF UP messages */
 977                 rc = otx2_mbox_init(&dev->mbox_vfpf_up, (uintptr_t)hwbase,
 978                                     bar2, MBOX_DIR_PFVF_UP, pci_dev->max_vfs,
 979                                     intr_offset);
 980                 if (rc)
 981                         goto mbox_fini;
 982         }
 983
 984         /* Register VF-FLR irq handlers */
 985         if (otx2_dev_is_pf(dev)) {
 986                 rc = vf_flr_register_irqs(pci_dev, dev);
 987                 if (rc)
 988                         goto iounmap;
 989         }
 990         dev->mbox_active = 1;
 991         return rc;
 992
 993 iounmap:
 994         mbox_mem_unmap(hwbase, MBOX_SIZE * pci_dev->max_vfs);
 995 mbox_unregister:
 996         mbox_unregister_irq(pci_dev, dev);
 997 mbox_fini:
 998         otx2_mbox_fini(dev->mbox);
 999         otx2_mbox_fini(&dev->mbox_up);
1000 error:
1001         return rc;
1002 }
1003
1004 /**
1005  * @internal
1006  * Finalize the otx2 device
1007  */
1008 void
1009 otx2_dev_fini(struct rte_pci_device *pci_dev, void *otx2_dev)
1010 {
1011         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
1012         struct otx2_dev *dev = otx2_dev;
1013         struct otx2_idev_cfg *idev;
1014         struct otx2_mbox *mbox;
1015
1016         /* Clear references to this pci dev */
1017         idev = otx2_intra_dev_get_cfg();
1018         if (idev->npa_lf && idev->npa_lf->pci_dev == pci_dev)
1019                 idev->npa_lf = NULL;
1020
1021         mbox_unregister_irq(pci_dev, dev);
1022
1023         if (otx2_dev_is_pf(dev))
1024                 vf_flr_unregister_irqs(pci_dev, dev);
1025         /* Release PF - VF */
1026         mbox = &dev->mbox_vfpf;
1027         if (mbox->hwbase && mbox->dev)
1028                 mbox_mem_unmap((void *)mbox->hwbase,
1029                                MBOX_SIZE * pci_dev->max_vfs);
1030         otx2_mbox_fini(mbox);
1031         mbox = &dev->mbox_vfpf_up;
1032         otx2_mbox_fini(mbox);
1033
1034         /* Release PF - AF */
1035         mbox = dev->mbox;
1036         otx2_mbox_fini(mbox);
1037         mbox = &dev->mbox_up;
1038         otx2_mbox_fini(mbox);
1039         dev->mbox_active = 0;
1040
1041         /* Disable MSIX vectors */
1042         otx2_disable_irqs(intr_handle);
1043 }