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