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