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 af_pf_wait_msg(struct otx2_dev *dev, uint16_t vf, int num_msg)
  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_hdr *req_hdr;
  61         struct mbox_msghdr *msg;
  62         struct mbox_msghdr *rsp;
  63         uint64_t offset;
  64         size_t size;
  65         int i;
  66
  67         /* We need to disable PF interrupts. We are in timer interrupt */
  68         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1C);
  69
  70         /* Send message */
  71         otx2_mbox_msg_send(mbox, 0);
  72
  73         do {
  74                 rte_delay_ms(sleep);
  75                 timeout++;
  76                 if (timeout >= MBOX_RSP_TIMEOUT) {
  77                         otx2_err("Routed messages %d timeout: %dms",
  78                                  num_msg, MBOX_RSP_TIMEOUT);
  79                         break;
  80                 }
  81                 int_status = otx2_read64(dev->bar2 + RVU_PF_INT);
  82         } while ((int_status & 0x1) != 0x1);
  83
  84         /* Clear */
  85         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT);
  86
  87         /* Enable interrupts */
  88         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1S);
  89
  90         rte_spinlock_lock(&mdev->mbox_lock);
  91
  92         req_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
  93         if (req_hdr->num_msgs != num_msg)
  94                 otx2_err("Routed messages: %d received: %d", num_msg,
  95                          req_hdr->num_msgs);
  96
  97         /* Get messages from mbox */
  98         offset = mbox->rx_start +
  99                         RTE_ALIGN(sizeof(struct mbox_hdr), MBOX_MSG_ALIGN);
 100         for (i = 0; i < req_hdr->num_msgs; i++) {
 101                 msg = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
 102                 size = mbox->rx_start + msg->next_msgoff - offset;
 103
 104                 /* Reserve PF/VF mbox message */
 105                 size = RTE_ALIGN(size, MBOX_MSG_ALIGN);
 106                 rsp = otx2_mbox_alloc_msg(&dev->mbox_vfpf, vf, size);
 107                 otx2_mbox_rsp_init(msg->id, rsp);
 108
 109                 /* Copy message from AF<->PF mbox to PF<->VF mbox */
 110                 otx2_mbox_memcpy((uint8_t *)rsp + sizeof(struct mbox_msghdr),
 111                                  (uint8_t *)msg + sizeof(struct mbox_msghdr),
 112                                  size - sizeof(struct mbox_msghdr));
 113
 114                 /* Set status and sender pf_func data */
 115                 rsp->rc = msg->rc;
 116                 rsp->pcifunc = msg->pcifunc;
 117
 118                 offset = mbox->rx_start + msg->next_msgoff;
 119         }
 120         rte_spinlock_unlock(&mdev->mbox_lock);
 121
 122         return req_hdr->num_msgs;
 123 }
 124
 125 static int
 126 vf_pf_process_msgs(struct otx2_dev *dev, uint16_t vf)
 127 {
 128         int offset, routed = 0; struct otx2_mbox *mbox = &dev->mbox_vfpf;
 129         struct otx2_mbox_dev *mdev = &mbox->dev[vf];
 130         struct mbox_hdr *req_hdr;
 131         struct mbox_msghdr *msg;
 132         size_t size;
 133         uint16_t i;
 134
 135         req_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
 136         if (!req_hdr->num_msgs)
 137                 return 0;
 138
 139         offset = mbox->rx_start + RTE_ALIGN(sizeof(*req_hdr), MBOX_MSG_ALIGN);
 140
 141         for (i = 0; i < req_hdr->num_msgs; i++) {
 142
 143                 msg = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
 144                 size = mbox->rx_start + msg->next_msgoff - offset;
 145
 146                 /* RVU_PF_FUNC_S */
 147                 msg->pcifunc = otx2_pfvf_func(dev->pf, vf);
 148
 149                 if (msg->id == MBOX_MSG_READY) {
 150                         struct ready_msg_rsp *rsp;
 151                         uint16_t max_bits = sizeof(dev->active_vfs[0]) * 8;
 152
 153                         /* Handle READY message in PF */
 154                         dev->active_vfs[vf / max_bits] |=
 155                                                 BIT_ULL(vf % max_bits);
 156                         rsp = (struct ready_msg_rsp *)
 157                                otx2_mbox_alloc_msg(mbox, vf, sizeof(*rsp));
 158                         otx2_mbox_rsp_init(msg->id, rsp);
 159
 160                         /* PF/VF function ID */
 161                         rsp->hdr.pcifunc = msg->pcifunc;
 162                         rsp->hdr.rc = 0;
 163                 } else {
 164                         struct mbox_msghdr *af_req;
 165                         /* Reserve AF/PF mbox message */
 166                         size = RTE_ALIGN(size, MBOX_MSG_ALIGN);
 167                         af_req = otx2_mbox_alloc_msg(dev->mbox, 0, size);
 168                         otx2_mbox_req_init(msg->id, af_req);
 169
 170                         /* Copy message from VF<->PF mbox to PF<->AF mbox */
 171                         otx2_mbox_memcpy((uint8_t *)af_req +
 172                                    sizeof(struct mbox_msghdr),
 173                                    (uint8_t *)msg + sizeof(struct mbox_msghdr),
 174                                    size - sizeof(struct mbox_msghdr));
 175                         af_req->pcifunc = msg->pcifunc;
 176                         routed++;
 177                 }
 178                 offset = mbox->rx_start + msg->next_msgoff;
 179         }
 180
 181         if (routed > 0) {
 182                 otx2_base_dbg("pf:%d routed %d messages from vf:%d to AF",
 183                               dev->pf, routed, vf);
 184                 af_pf_wait_msg(dev, vf, routed);
 185                 otx2_mbox_reset(dev->mbox, 0);
 186         }
 187
 188         /* Send mbox responses to VF */
 189         if (mdev->num_msgs) {
 190                 otx2_base_dbg("pf:%d reply %d messages to vf:%d",
 191                               dev->pf, mdev->num_msgs, vf);
 192                 otx2_mbox_msg_send(mbox, vf);
 193         }
 194
 195         return i;
 196 }
 197
 198 static int
 199 vf_pf_process_up_msgs(struct otx2_dev *dev, uint16_t vf)
 200 {
 201         struct otx2_mbox *mbox = &dev->mbox_vfpf_up;
 202         struct otx2_mbox_dev *mdev = &mbox->dev[vf];
 203         struct mbox_hdr *req_hdr;
 204         struct mbox_msghdr *msg;
 205         int msgs_acked = 0;
 206         int offset;
 207         uint16_t i;
 208
 209         req_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
 210         if (req_hdr->num_msgs == 0)
 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                 msg = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
 217
 218                 msgs_acked++;
 219                 /* RVU_PF_FUNC_S */
 220                 msg->pcifunc = otx2_pfvf_func(dev->pf, vf);
 221
 222                 switch (msg->id) {
 223                 case MBOX_MSG_CGX_LINK_EVENT:
 224                         otx2_base_dbg("PF: Msg 0x%x (%s) fn:0x%x (pf:%d,vf:%d)",
 225                                       msg->id, otx2_mbox_id2name(msg->id),
 226                                       msg->pcifunc, otx2_get_pf(msg->pcifunc),
 227                                       otx2_get_vf(msg->pcifunc));
 228                         break;
 229                 case MBOX_MSG_CGX_PTP_RX_INFO:
 230                         otx2_base_dbg("PF: Msg 0x%x (%s) fn:0x%x (pf:%d,vf:%d)",
 231                                       msg->id, otx2_mbox_id2name(msg->id),
 232                                       msg->pcifunc, otx2_get_pf(msg->pcifunc),
 233                                       otx2_get_vf(msg->pcifunc));
 234                         break;
 235                 default:
 236                         otx2_err("Not handled UP msg 0x%x (%s) func:0x%x",
 237                                  msg->id, otx2_mbox_id2name(msg->id),
 238                                  msg->pcifunc);
 239                 }
 240                 offset = mbox->rx_start + msg->next_msgoff;
 241         }
 242         otx2_mbox_reset(mbox, vf);
 243         mdev->msgs_acked = msgs_acked;
 244         rte_wmb();
 245
 246         return i;
 247 }
 248
 249 static void
 250 otx2_vf_pf_mbox_handle_msg(void *param)
 251 {
 252         uint16_t vf, max_vf, max_bits;
 253         struct otx2_dev *dev = param;
 254
 255         max_bits = sizeof(dev->intr.bits[0]) * sizeof(uint64_t);
 256         max_vf = max_bits * MAX_VFPF_DWORD_BITS;
 257
 258         for (vf = 0; vf < max_vf; vf++) {
 259                 if (dev->intr.bits[vf/max_bits] & BIT_ULL(vf%max_bits)) {
 260                         otx2_base_dbg("Process vf:%d request (pf:%d, vf:%d)",
 261                                        vf, dev->pf, dev->vf);
 262                         vf_pf_process_msgs(dev, vf);
 263                         /* UP messages */
 264                         vf_pf_process_up_msgs(dev, vf);
 265                         dev->intr.bits[vf/max_bits] &= ~(BIT_ULL(vf%max_bits));
 266                 }
 267         }
 268         dev->timer_set = 0;
 269 }
 270
 271 static void
 272 otx2_vf_pf_mbox_irq(void *param)
 273 {
 274         struct otx2_dev *dev = param;
 275         bool alarm_set = false;
 276         uint64_t intr;
 277         int vfpf;
 278
 279         for (vfpf = 0; vfpf < MAX_VFPF_DWORD_BITS; ++vfpf) {
 280                 intr = otx2_read64(dev->bar2 + RVU_PF_VFPF_MBOX_INTX(vfpf));
 281                 if (!intr)
 282                         continue;
 283
 284                 otx2_base_dbg("vfpf: %d intr: 0x%" PRIx64 " (pf:%d, vf:%d)",
 285                               vfpf, intr, dev->pf, dev->vf);
 286
 287                 /* Save and clear intr bits */
 288                 dev->intr.bits[vfpf] |= intr;
 289                 otx2_write64(intr, dev->bar2 + RVU_PF_VFPF_MBOX_INTX(vfpf));
 290                 alarm_set = true;
 291         }
 292
 293         if (!dev->timer_set && alarm_set) {
 294                 dev->timer_set = 1;
 295                 /* Start timer to handle messages */
 296                 rte_eal_alarm_set(VF_PF_MBOX_TIMER_MS,
 297                                   otx2_vf_pf_mbox_handle_msg, dev);
 298         }
 299 }
 300
 301 static void
 302 otx2_process_msgs(struct otx2_dev *dev, struct otx2_mbox *mbox)
 303 {
 304         struct otx2_mbox_dev *mdev = &mbox->dev[0];
 305         struct mbox_hdr *req_hdr;
 306         struct mbox_msghdr *msg;
 307         int msgs_acked = 0;
 308         int offset;
 309         uint16_t i;
 310
 311         req_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
 312         if (req_hdr->num_msgs == 0)
 313                 return;
 314
 315         offset = mbox->rx_start + RTE_ALIGN(sizeof(*req_hdr), MBOX_MSG_ALIGN);
 316         for (i = 0; i < req_hdr->num_msgs; i++) {
 317                 msg = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
 318
 319                 msgs_acked++;
 320                 otx2_base_dbg("Message 0x%x (%s) pf:%d/vf:%d",
 321                               msg->id, otx2_mbox_id2name(msg->id),
 322                               otx2_get_pf(msg->pcifunc),
 323                               otx2_get_vf(msg->pcifunc));
 324
 325                 switch (msg->id) {
 326                         /* Add message id's that are handled here */
 327                 case MBOX_MSG_READY:
 328                         /* Get our identity */
 329                         dev->pf_func = msg->pcifunc;
 330                         break;
 331
 332                 default:
 333                         if (msg->rc)
 334                                 otx2_err("Message (%s) response has err=%d",
 335                                          otx2_mbox_id2name(msg->id), msg->rc);
 336                         break;
 337                 }
 338                 offset = mbox->rx_start + msg->next_msgoff;
 339         }
 340
 341         otx2_mbox_reset(mbox, 0);
 342         /* Update acked if someone is waiting a message */
 343         mdev->msgs_acked = msgs_acked;
 344         rte_wmb();
 345 }
 346
 347 /* Copies the message received from AF and sends it to VF */
 348 static void
 349 pf_vf_mbox_send_up_msg(struct otx2_dev *dev, void *rec_msg)
 350 {
 351         uint16_t max_bits = sizeof(dev->active_vfs[0]) * sizeof(uint64_t);
 352         struct otx2_mbox *vf_mbox = &dev->mbox_vfpf_up;
 353         struct msg_req *msg = rec_msg;
 354         struct mbox_msghdr *vf_msg;
 355         uint16_t vf;
 356         size_t size;
 357
 358         size = RTE_ALIGN(otx2_mbox_id2size(msg->hdr.id), MBOX_MSG_ALIGN);
 359         /* Send UP message to all VF's */
 360         for (vf = 0; vf < vf_mbox->ndevs; vf++) {
 361                 /* VF active */
 362                 if (!(dev->active_vfs[vf / max_bits] & (BIT_ULL(vf))))
 363                         continue;
 364
 365                 otx2_base_dbg("(%s) size: %zx to VF: %d",
 366                               otx2_mbox_id2name(msg->hdr.id), size, vf);
 367
 368                 /* Reserve PF/VF mbox message */
 369                 vf_msg = otx2_mbox_alloc_msg(vf_mbox, vf, size);
 370                 if (!vf_msg) {
 371                         otx2_err("Failed to alloc VF%d UP message", vf);
 372                         continue;
 373                 }
 374                 otx2_mbox_req_init(msg->hdr.id, vf_msg);
 375
 376                 /*
 377                  * Copy message from AF<->PF UP mbox
 378                  * to PF<->VF UP mbox
 379                  */
 380                 otx2_mbox_memcpy((uint8_t *)vf_msg +
 381                                  sizeof(struct mbox_msghdr), (uint8_t *)msg
 382                                  + sizeof(struct mbox_msghdr), size -
 383                                  sizeof(struct mbox_msghdr));
 384
 385                 vf_msg->rc = msg->hdr.rc;
 386                 /* Set PF to be a sender */
 387                 vf_msg->pcifunc = dev->pf_func;
 388
 389                 /* Send to VF */
 390                 otx2_mbox_msg_send(vf_mbox, vf);
 391         }
 392 }
 393
 394 static int
 395 otx2_mbox_up_handler_cgx_link_event(struct otx2_dev *dev,
 396                                     struct cgx_link_info_msg *msg,
 397                                     struct msg_rsp *rsp)
 398 {
 399         struct cgx_link_user_info *linfo = &msg->link_info;
 400
 401         otx2_base_dbg("pf:%d/vf:%d NIC Link %s --> 0x%x (%s) from: pf:%d/vf:%d",
 402                       otx2_get_pf(dev->pf_func), otx2_get_vf(dev->pf_func),
 403                       linfo->link_up ? "UP" : "DOWN", msg->hdr.id,
 404                       otx2_mbox_id2name(msg->hdr.id),
 405                       otx2_get_pf(msg->hdr.pcifunc),
 406                       otx2_get_vf(msg->hdr.pcifunc));
 407
 408         /* PF gets link notification from AF */
 409         if (otx2_get_pf(msg->hdr.pcifunc) == 0) {
 410                 if (dev->ops && dev->ops->link_status_update)
 411                         dev->ops->link_status_update(dev, linfo);
 412
 413                 /* Forward the same message as received from AF to VF */
 414                 pf_vf_mbox_send_up_msg(dev, msg);
 415         } else {
 416                 /* VF gets link up notification */
 417                 if (dev->ops && dev->ops->link_status_update)
 418                         dev->ops->link_status_update(dev, linfo);
 419         }
 420
 421         rsp->hdr.rc = 0;
 422         return 0;
 423 }
 424
 425 static int
 426 otx2_mbox_up_handler_cgx_ptp_rx_info(struct otx2_dev *dev,
 427                                      struct cgx_ptp_rx_info_msg *msg,
 428                                      struct msg_rsp *rsp)
 429 {
 430         otx2_nix_dbg("pf:%d/vf:%d PTP mode %s --> 0x%x (%s) from: pf:%d/vf:%d",
 431                  otx2_get_pf(dev->pf_func),
 432                  otx2_get_vf(dev->pf_func),
 433                  msg->ptp_en ? "ENABLED" : "DISABLED",
 434                  msg->hdr.id, otx2_mbox_id2name(msg->hdr.id),
 435                  otx2_get_pf(msg->hdr.pcifunc),
 436                  otx2_get_vf(msg->hdr.pcifunc));
 437
 438         /* PF gets PTP notification from AF */
 439         if (otx2_get_pf(msg->hdr.pcifunc) == 0) {
 440                 if (dev->ops && dev->ops->ptp_info_update)
 441                         dev->ops->ptp_info_update(dev, msg->ptp_en);
 442
 443                 /* Forward the same message as received from AF to VF */
 444                 pf_vf_mbox_send_up_msg(dev, msg);
 445         } else {
 446                 /* VF gets PTP notification */
 447                 if (dev->ops && dev->ops->ptp_info_update)
 448                         dev->ops->ptp_info_update(dev, msg->ptp_en);
 449         }
 450
 451         rsp->hdr.rc = 0;
 452         return 0;
 453 }
 454
 455 static int
 456 mbox_process_msgs_up(struct otx2_dev *dev, struct mbox_msghdr *req)
 457 {
 458         /* Check if valid, if not reply with a invalid msg */
 459         if (req->sig != OTX2_MBOX_REQ_SIG)
 460                 return -EIO;
 461
 462         switch (req->id) {
 463 #define M(_name, _id, _fn_name, _req_type, _rsp_type)           \
 464         case _id: {                                             \
 465                 struct _rsp_type *rsp;                          \
 466                 int err;                                        \
 467                                                                 \
 468                 rsp = (struct _rsp_type *)otx2_mbox_alloc_msg(  \
 469                         &dev->mbox_up, 0,                       \
 470                         sizeof(struct _rsp_type));              \
 471                 if (!rsp)                                       \
 472                         return -ENOMEM;                         \
 473                                                                 \
 474                 rsp->hdr.id = _id;                              \
 475                 rsp->hdr.sig = OTX2_MBOX_RSP_SIG;               \
 476                 rsp->hdr.pcifunc = dev->pf_func;                \
 477                 rsp->hdr.rc = 0;                                \
 478                                                                 \
 479                 err = otx2_mbox_up_handler_ ## _fn_name(        \
 480                         dev, (struct _req_type *)req, rsp);     \
 481                 return err;                                     \
 482         }
 483 MBOX_UP_CGX_MESSAGES
 484 #undef M
 485
 486         default :
 487                 otx2_reply_invalid_msg(&dev->mbox_up, 0, 0, req->id);
 488         }
 489
 490         return -ENODEV;
 491 }
 492
 493 static void
 494 otx2_process_msgs_up(struct otx2_dev *dev, struct otx2_mbox *mbox)
 495 {
 496         struct otx2_mbox_dev *mdev = &mbox->dev[0];
 497         struct mbox_hdr *req_hdr;
 498         struct mbox_msghdr *msg;
 499         int i, err, offset;
 500
 501         req_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
 502         if (req_hdr->num_msgs == 0)
 503                 return;
 504
 505         offset = mbox->rx_start + RTE_ALIGN(sizeof(*req_hdr), MBOX_MSG_ALIGN);
 506         for (i = 0; i < req_hdr->num_msgs; i++) {
 507                 msg = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
 508
 509                 otx2_base_dbg("Message 0x%x (%s) pf:%d/vf:%d",
 510                                 msg->id, otx2_mbox_id2name(msg->id),
 511                                 otx2_get_pf(msg->pcifunc),
 512                                 otx2_get_vf(msg->pcifunc));
 513                 err = mbox_process_msgs_up(dev, msg);
 514                 if (err)
 515                         otx2_err("Error %d handling 0x%x (%s)",
 516                                  err, msg->id, otx2_mbox_id2name(msg->id));
 517                 offset = mbox->rx_start + msg->next_msgoff;
 518         }
 519         /* Send mbox responses */
 520         if (mdev->num_msgs) {
 521                 otx2_base_dbg("Reply num_msgs:%d", mdev->num_msgs);
 522                 otx2_mbox_msg_send(mbox, 0);
 523         }
 524 }
 525
 526 static void
 527 otx2_pf_vf_mbox_irq(void *param)
 528 {
 529         struct otx2_dev *dev = param;
 530         uint64_t intr;
 531
 532         intr = otx2_read64(dev->bar2 + RVU_VF_INT);
 533         if (intr == 0)
 534                 return;
 535
 536         otx2_write64(intr, dev->bar2 + RVU_VF_INT);
 537         otx2_base_dbg("Irq 0x%" PRIx64 "(pf:%d,vf:%d)", intr, dev->pf, dev->vf);
 538         if (intr) {
 539                 /* First process all configuration messages */
 540                 otx2_process_msgs(dev, dev->mbox);
 541
 542                 /* Process Uplink messages */
 543                 otx2_process_msgs_up(dev, &dev->mbox_up);
 544         }
 545 }
 546
 547 static void
 548 otx2_af_pf_mbox_irq(void *param)
 549 {
 550         struct otx2_dev *dev = param;
 551         uint64_t intr;
 552
 553         intr = otx2_read64(dev->bar2 + RVU_PF_INT);
 554         if (intr == 0)
 555                 return;
 556
 557         otx2_write64(intr, dev->bar2 + RVU_PF_INT);
 558
 559         otx2_base_dbg("Irq 0x%" PRIx64 "(pf:%d,vf:%d)", intr, dev->pf, dev->vf);
 560         if (intr) {
 561                 /* First process all configuration messages */
 562                 otx2_process_msgs(dev, dev->mbox);
 563
 564                 /* Process Uplink messages */
 565                 otx2_process_msgs_up(dev, &dev->mbox_up);
 566         }
 567 }
 568
 569 static int
 570 mbox_register_pf_irq(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 571 {
 572         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
 573         int i, rc;
 574
 575         /* HW clear irq */
 576         for (i = 0; i < MAX_VFPF_DWORD_BITS; ++i)
 577                 otx2_write64(~0ull, dev->bar2 +
 578                              RVU_PF_VFPF_MBOX_INT_ENA_W1CX(i));
 579
 580         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1C);
 581
 582         dev->timer_set = 0;
 583
 584         /* MBOX interrupt for VF(0...63) <-> PF */
 585         rc = otx2_register_irq(intr_handle, otx2_vf_pf_mbox_irq, dev,
 586                                RVU_PF_INT_VEC_VFPF_MBOX0);
 587
 588         if (rc) {
 589                 otx2_err("Fail to register PF(VF0-63) mbox irq");
 590                 return rc;
 591         }
 592         /* MBOX interrupt for VF(64...128) <-> PF */
 593         rc = otx2_register_irq(intr_handle, otx2_vf_pf_mbox_irq, dev,
 594                                RVU_PF_INT_VEC_VFPF_MBOX1);
 595
 596         if (rc) {
 597                 otx2_err("Fail to register PF(VF64-128) mbox irq");
 598                 return rc;
 599         }
 600         /* MBOX interrupt AF <-> PF */
 601         rc = otx2_register_irq(intr_handle, otx2_af_pf_mbox_irq,
 602                                dev, RVU_PF_INT_VEC_AFPF_MBOX);
 603         if (rc) {
 604                 otx2_err("Fail to register AF<->PF mbox irq");
 605                 return rc;
 606         }
 607
 608         /* HW enable intr */
 609         for (i = 0; i < MAX_VFPF_DWORD_BITS; ++i)
 610                 otx2_write64(~0ull, dev->bar2 +
 611                         RVU_PF_VFPF_MBOX_INT_ENA_W1SX(i));
 612
 613         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT);
 614         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1S);
 615
 616         return rc;
 617 }
 618
 619 static int
 620 mbox_register_vf_irq(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 621 {
 622         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
 623         int rc;
 624
 625         /* Clear irq */
 626         otx2_write64(~0ull, dev->bar2 + RVU_VF_INT_ENA_W1C);
 627
 628         /* MBOX interrupt PF <-> VF */
 629         rc = otx2_register_irq(intr_handle, otx2_pf_vf_mbox_irq,
 630                                dev, RVU_VF_INT_VEC_MBOX);
 631         if (rc) {
 632                 otx2_err("Fail to register PF<->VF mbox irq");
 633                 return rc;
 634         }
 635
 636         /* HW enable intr */
 637         otx2_write64(~0ull, dev->bar2 + RVU_VF_INT);
 638         otx2_write64(~0ull, dev->bar2 + RVU_VF_INT_ENA_W1S);
 639
 640         return rc;
 641 }
 642
 643 static int
 644 mbox_register_irq(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 645 {
 646         if (otx2_dev_is_vf(dev))
 647                 return mbox_register_vf_irq(pci_dev, dev);
 648         else
 649                 return mbox_register_pf_irq(pci_dev, dev);
 650 }
 651
 652 static void
 653 mbox_unregister_pf_irq(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 654 {
 655         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
 656         int i;
 657
 658         /* HW clear irq */
 659         for (i = 0; i < MAX_VFPF_DWORD_BITS; ++i)
 660                 otx2_write64(~0ull, dev->bar2 +
 661                              RVU_PF_VFPF_MBOX_INT_ENA_W1CX(i));
 662
 663         otx2_write64(~0ull, dev->bar2 + RVU_PF_INT_ENA_W1C);
 664
 665         dev->timer_set = 0;
 666
 667         rte_eal_alarm_cancel(otx2_vf_pf_mbox_handle_msg, dev);
 668
 669         /* Unregister the interrupt handler for each vectors */
 670         /* MBOX interrupt for VF(0...63) <-> PF */
 671         otx2_unregister_irq(intr_handle, otx2_vf_pf_mbox_irq, dev,
 672                             RVU_PF_INT_VEC_VFPF_MBOX0);
 673
 674         /* MBOX interrupt for VF(64...128) <-> PF */
 675         otx2_unregister_irq(intr_handle, otx2_vf_pf_mbox_irq, dev,
 676                             RVU_PF_INT_VEC_VFPF_MBOX1);
 677
 678         /* MBOX interrupt AF <-> PF */
 679         otx2_unregister_irq(intr_handle, otx2_af_pf_mbox_irq, dev,
 680                             RVU_PF_INT_VEC_AFPF_MBOX);
 681
 682 }
 683
 684 static void
 685 mbox_unregister_vf_irq(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 686 {
 687         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
 688
 689         /* Clear irq */
 690         otx2_write64(~0ull, dev->bar2 + RVU_VF_INT_ENA_W1C);
 691
 692         /* Unregister the interrupt handler */
 693         otx2_unregister_irq(intr_handle, otx2_pf_vf_mbox_irq, dev,
 694                             RVU_VF_INT_VEC_MBOX);
 695 }
 696
 697 static void
 698 mbox_unregister_irq(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 699 {
 700         if (otx2_dev_is_vf(dev))
 701                 return mbox_unregister_vf_irq(pci_dev, dev);
 702         else
 703                 return mbox_unregister_pf_irq(pci_dev, dev);
 704 }
 705
 706 static void
 707 otx2_update_pass_hwcap(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 708 {
 709         RTE_SET_USED(pci_dev);
 710
 711         /* Update this logic when we have A1 */
 712         dev->hwcap |= OTX2_HWCAP_F_A0;
 713 }
 714
 715 static void
 716 otx2_update_vf_hwcap(struct rte_pci_device *pci_dev, struct otx2_dev *dev)
 717 {
 718         dev->hwcap = 0;
 719
 720         switch (pci_dev->id.device_id) {
 721         case PCI_DEVID_OCTEONTX2_RVU_PF:
 722                 break;
 723         case PCI_DEVID_OCTEONTX2_RVU_SSO_TIM_VF:
 724         case PCI_DEVID_OCTEONTX2_RVU_NPA_VF:
 725         case PCI_DEVID_OCTEONTX2_RVU_CPT_VF:
 726         case PCI_DEVID_OCTEONTX2_RVU_AF_VF:
 727         case PCI_DEVID_OCTEONTX2_RVU_VF:
 728                 dev->hwcap |= OTX2_HWCAP_F_VF;
 729                 break;
 730         }
 731 }
 732
 733 /**
 734  * @internal
 735  * Initialize the otx2 device
 736  */
 737 int
 738 otx2_dev_init(struct rte_pci_device *pci_dev, void *otx2_dev)
 739 {
 740         int up_direction = MBOX_DIR_PFAF_UP;
 741         int rc, direction = MBOX_DIR_PFAF;
 742         struct otx2_dev *dev = otx2_dev;
 743         uintptr_t bar2, bar4;
 744         uint64_t bar4_addr;
 745         void *hwbase;
 746
 747         bar2 = (uintptr_t)pci_dev->mem_resource[2].addr;
 748         bar4 = (uintptr_t)pci_dev->mem_resource[4].addr;
 749
 750         if (bar2 == 0 || bar4 == 0) {
 751                 otx2_err("Failed to get pci bars");
 752                 rc = -ENODEV;
 753                 goto error;
 754         }
 755
 756         dev->node = pci_dev->device.numa_node;
 757         dev->maxvf = pci_dev->max_vfs;
 758         dev->bar2 = bar2;
 759         dev->bar4 = bar4;
 760
 761         otx2_update_vf_hwcap(pci_dev, dev);
 762         otx2_update_pass_hwcap(pci_dev, dev);
 763
 764         if (otx2_dev_is_vf(dev)) {
 765                 direction = MBOX_DIR_VFPF;
 766                 up_direction = MBOX_DIR_VFPF_UP;
 767         }
 768
 769         /* Initialize the local mbox */
 770         rc = otx2_mbox_init(&dev->mbox_local, bar4, bar2, direction, 1);
 771         if (rc)
 772                 goto error;
 773         dev->mbox = &dev->mbox_local;
 774
 775         rc = otx2_mbox_init(&dev->mbox_up, bar4, bar2, up_direction, 1);
 776         if (rc)
 777                 goto error;
 778
 779         /* Register mbox interrupts */
 780         rc = mbox_register_irq(pci_dev, dev);
 781         if (rc)
 782                 goto mbox_fini;
 783
 784         /* Check the readiness of PF/VF */
 785         rc = otx2_send_ready_msg(dev->mbox, &dev->pf_func);
 786         if (rc)
 787                 goto mbox_unregister;
 788
 789         dev->pf = otx2_get_pf(dev->pf_func);
 790         dev->vf = otx2_get_vf(dev->pf_func);
 791         memset(&dev->active_vfs, 0, sizeof(dev->active_vfs));
 792
 793         /* Found VF devices in a PF device */
 794         if (pci_dev->max_vfs > 0) {
 795
 796                 /* Remap mbox area for all vf's */
 797                 bar4_addr = otx2_read64(bar2 + RVU_PF_VF_BAR4_ADDR);
 798                 if (bar4_addr == 0) {
 799                         rc = -ENODEV;
 800                         goto mbox_fini;
 801                 }
 802
 803                 hwbase = mbox_mem_map(bar4_addr, MBOX_SIZE * pci_dev->max_vfs);
 804                 if (hwbase == MAP_FAILED) {
 805                         rc = -ENOMEM;
 806                         goto mbox_fini;
 807                 }
 808                 /* Init mbox object */
 809                 rc = otx2_mbox_init(&dev->mbox_vfpf, (uintptr_t)hwbase,
 810                                     bar2, MBOX_DIR_PFVF, pci_dev->max_vfs);
 811                 if (rc)
 812                         goto iounmap;
 813
 814                 /* PF -> VF UP messages */
 815                 rc = otx2_mbox_init(&dev->mbox_vfpf_up, (uintptr_t)hwbase,
 816                                     bar2, MBOX_DIR_PFVF_UP, pci_dev->max_vfs);
 817                 if (rc)
 818                         goto mbox_fini;
 819         }
 820
 821         dev->mbox_active = 1;
 822         return rc;
 823
 824 iounmap:
 825         mbox_mem_unmap(hwbase, MBOX_SIZE * pci_dev->max_vfs);
 826 mbox_unregister:
 827         mbox_unregister_irq(pci_dev, dev);
 828 mbox_fini:
 829         otx2_mbox_fini(dev->mbox);
 830         otx2_mbox_fini(&dev->mbox_up);
 831 error:
 832         return rc;
 833 }
 834
 835 /**
 836  * @internal
 837  * Finalize the otx2 device
 838  */
 839 void
 840 otx2_dev_fini(struct rte_pci_device *pci_dev, void *otx2_dev)
 841 {
 842         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
 843         struct otx2_dev *dev = otx2_dev;
 844         struct otx2_idev_cfg *idev;
 845         struct otx2_mbox *mbox;
 846
 847         /* Clear references to this pci dev */
 848         idev = otx2_intra_dev_get_cfg();
 849         if (idev->npa_lf && idev->npa_lf->pci_dev == pci_dev)
 850                 idev->npa_lf = NULL;
 851
 852         mbox_unregister_irq(pci_dev, dev);
 853
 854         /* Release PF - VF */
 855         mbox = &dev->mbox_vfpf;
 856         if (mbox->hwbase && mbox->dev)
 857                 mbox_mem_unmap((void *)mbox->hwbase,
 858                                MBOX_SIZE * pci_dev->max_vfs);
 859         otx2_mbox_fini(mbox);
 860         mbox = &dev->mbox_vfpf_up;
 861         otx2_mbox_fini(mbox);
 862
 863         /* Release PF - AF */
 864         mbox = dev->mbox;
 865         otx2_mbox_fini(mbox);
 866         mbox = &dev->mbox_up;
 867         otx2_mbox_fini(mbox);
 868         dev->mbox_active = 0;
 869
 870         /* Disable MSIX vectors */
 871         otx2_disable_irqs(intr_handle);
 872 }