sys/dev/oce/oce_queue.c

   1 /*-
   2  * Copyright (C) 2013 Emulex
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  * 1. Redistributions of source code must retain the above copyright notice,
   9  *    this list of conditions and the following disclaimer.
  10  *
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * 3. Neither the name of the Emulex Corporation nor the names of its
  16  *    contributors may be used to endorse or promote products derived from
  17  *    this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  23  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  *
  31  * Contact Information:
  32  * freebsd-drivers@emulex.com
  33  *
  34  * Emulex
  35  * 3333 Susan Street
  36  * Costa Mesa, CA 92626
  37  */
  38
  39
  40
  41 /* $FreeBSD$ */
  42
  43
  44 #include "oce_if.h"
  45
  46 /*****************************************************
  47  * local queue functions
  48  *****************************************************/
  49
  50 static struct oce_wq *oce_wq_init(POCE_SOFTC sc,
  51                                   uint32_t q_len, uint32_t wq_type);
  52 static int oce_wq_create(struct oce_wq *wq, struct oce_eq *eq);
  53 static void oce_wq_free(struct oce_wq *wq);
  54 static void oce_wq_del(struct oce_wq *wq);
  55 static struct oce_rq *oce_rq_init(POCE_SOFTC sc,
  56                                   uint32_t q_len,
  57                                   uint32_t frag_size,
  58                                   uint32_t mtu, uint32_t rss);
  59 static int oce_rq_create(struct oce_rq *rq, uint32_t if_id, struct oce_eq *eq);
  60 static void oce_rq_free(struct oce_rq *rq);
  61 static void oce_rq_del(struct oce_rq *rq);
  62 static struct oce_eq *oce_eq_create(POCE_SOFTC sc,
  63                                     uint32_t q_len,
  64                                     uint32_t item_size,
  65                                     uint32_t eq_delay,
  66                                     uint32_t vector);
  67 static void oce_eq_del(struct oce_eq *eq);
  68 static struct oce_mq *oce_mq_create(POCE_SOFTC sc,
  69                                     struct oce_eq *eq, uint32_t q_len);
  70 static void oce_mq_free(struct oce_mq *mq);
  71 static int oce_destroy_q(POCE_SOFTC sc, struct oce_mbx
  72                          *mbx, size_t req_size, enum qtype qtype);
  73 struct oce_cq *oce_cq_create(POCE_SOFTC sc,
  74                              struct oce_eq *eq,
  75                              uint32_t q_len,
  76                              uint32_t item_size,
  77                              uint32_t sol_event,
  78                              uint32_t is_eventable,
  79                              uint32_t nodelay, uint32_t ncoalesce);
  80 static void oce_cq_del(POCE_SOFTC sc, struct oce_cq *cq);
  81
  82
  83
  84 /**
  85  * @brief       Create and initialize all the queues on the board
  86  * @param sc    software handle to the device
  87  * @returns 0   if successful, or error
  88  **/
  89 int
  90 oce_queue_init_all(POCE_SOFTC sc)
  91 {
  92         int rc = 0, i, vector;
  93         struct oce_wq *wq;
  94         struct oce_rq *rq;
  95         struct oce_aic_obj *aic;
  96
  97         /* alloc TX/RX queues */
  98         for_all_wq_queues(sc, wq, i) {
  99                 sc->wq[i] = oce_wq_init(sc, sc->tx_ring_size,
 100                                          NIC_WQ_TYPE_STANDARD);
 101                 if (!sc->wq[i])
 102                         goto error;
 103
 104         }
 105
 106         for_all_rq_queues(sc, rq, i) {
 107                 sc->rq[i] = oce_rq_init(sc, sc->rx_ring_size, sc->rq_frag_size,
 108                                         OCE_MAX_JUMBO_FRAME_SIZE,
 109                                         (i == 0) ? 0 : is_rss_enabled(sc));
 110                 if (!sc->rq[i])
 111                         goto error;
 112         }
 113
 114         /* Create network interface on card */
 115         if (oce_create_nw_interface(sc))
 116                 goto error;
 117
 118         /* create all of the event queues */
 119         for (vector = 0; vector < sc->intr_count; vector++) {
 120                 /* setup aic defaults for each event queue */
 121                 aic = &sc->aic_obj[vector];
 122                 aic->max_eqd = OCE_MAX_EQD;
 123                 aic->min_eqd = OCE_MIN_EQD;
 124                 aic->et_eqd = OCE_MIN_EQD;
 125                 aic->enable = TRUE;
 126
 127                 sc->eq[vector] = oce_eq_create(sc, EQ_LEN_1024, EQE_SIZE_4,
 128                                                  0, vector);
 129                 if (!sc->eq[vector])
 130                         goto error;
 131         }
 132
 133         /* create Tx, Rx and mcc queues */
 134         for_all_wq_queues(sc, wq, i) {
 135                 rc = oce_wq_create(wq, sc->eq[i]);
 136                 if (rc)
 137                         goto error;
 138                 wq->queue_index = i;
 139                 TASK_INIT(&wq->txtask, 1, oce_tx_task, wq);
 140         }
 141
 142         for_all_rq_queues(sc, rq, i) {
 143                 rc = oce_rq_create(rq, sc->if_id,
 144                                         sc->eq[(i == 0) ? 0:(i-1)]);
 145                 if (rc)
 146                         goto error;
 147                 rq->queue_index = i;
 148         }
 149
 150         sc->mq = oce_mq_create(sc, sc->eq[0], 64);
 151         if (!sc->mq)
 152                 goto error;
 153
 154         return rc;
 155
 156 error:
 157         oce_queue_release_all(sc);
 158         return 1;
 159 }
 160
 161
 162
 163 /**
 164  * @brief Releases all mailbox queues created
 165  * @param sc            software handle to the device
 166  */
 167 void
 168 oce_queue_release_all(POCE_SOFTC sc)
 169 {
 170         int i = 0;
 171         struct oce_wq *wq;
 172         struct oce_rq *rq;
 173         struct oce_eq *eq;
 174
 175         for_all_rq_queues(sc, rq, i) {
 176                 if (rq) {
 177                         oce_rq_del(sc->rq[i]);
 178                         oce_rq_free(sc->rq[i]);
 179                 }
 180         }
 181
 182         for_all_wq_queues(sc, wq, i) {
 183                 if (wq) {
 184                         oce_wq_del(sc->wq[i]);
 185                         oce_wq_free(sc->wq[i]);
 186                 }
 187         }
 188
 189         if (sc->mq)
 190                 oce_mq_free(sc->mq);
 191
 192         for_all_evnt_queues(sc, eq, i) {
 193                 if (eq)
 194                         oce_eq_del(sc->eq[i]);
 195         }
 196 }
 197
 198
 199
 200 /**
 201  * @brief               Function to create a WQ for NIC Tx
 202  * @param sc            software handle to the device
 203  * @param qlen          number of entries in the queue
 204  * @param wq_type       work queue type
 205  * @returns             the pointer to the WQ created or NULL on failure
 206  */
 207 static struct
 208 oce_wq *oce_wq_init(POCE_SOFTC sc, uint32_t q_len, uint32_t wq_type)
 209 {
 210         struct oce_wq *wq;
 211         int rc = 0, i;
 212
 213         /* q_len must be min 256 and max 2k */
 214         if (q_len < 256 || q_len > 2048) {
 215                 device_printf(sc->dev,
 216                           "Invalid q length. Must be "
 217                           "[256, 2000]: 0x%x\n", q_len);
 218                 return NULL;
 219         }
 220
 221         /* allocate wq */
 222         wq = malloc(sizeof(struct oce_wq), M_DEVBUF, M_NOWAIT | M_ZERO);
 223         if (!wq)
 224                 return NULL;
 225
 226         /* Set the wq config */
 227         wq->cfg.q_len = q_len;
 228         wq->cfg.wq_type = (uint8_t) wq_type;
 229         wq->cfg.eqd = OCE_DEFAULT_WQ_EQD;
 230         wq->cfg.nbufs = 2 * wq->cfg.q_len;
 231         wq->cfg.nhdl = 2 * wq->cfg.q_len;
 232
 233         wq->parent = (void *)sc;
 234
 235         rc = bus_dma_tag_create(bus_get_dma_tag(sc->dev),
 236                                 1, 0,
 237                                 BUS_SPACE_MAXADDR,
 238                                 BUS_SPACE_MAXADDR,
 239                                 NULL, NULL,
 240                                 OCE_MAX_TX_SIZE,
 241                                 OCE_MAX_TX_ELEMENTS,
 242                                 PAGE_SIZE, 0, NULL, NULL, &wq->tag);
 243
 244         if (rc)
 245                 goto free_wq;
 246
 247
 248         for (i = 0; i < OCE_WQ_PACKET_ARRAY_SIZE; i++) {
 249                 rc = bus_dmamap_create(wq->tag, 0, &wq->pckts[i].map);
 250                 if (rc)
 251                         goto free_wq;
 252         }
 253
 254         wq->ring = oce_create_ring_buffer(sc, q_len, NIC_WQE_SIZE);
 255         if (!wq->ring)
 256                 goto free_wq;
 257
 258
 259         LOCK_CREATE(&wq->tx_lock, "TX_lock");
 260
 261 #if __FreeBSD_version >= 800000
 262         /* Allocate buf ring for multiqueue*/
 263         wq->br = buf_ring_alloc(4096, M_DEVBUF,
 264                         M_WAITOK, &wq->tx_lock.mutex);
 265         if (!wq->br)
 266                 goto free_wq;
 267 #endif
 268         return wq;
 269
 270
 271 free_wq:
 272         device_printf(sc->dev, "Create WQ failed\n");
 273         oce_wq_free(wq);
 274         return NULL;
 275 }
 276
 277
 278
 279 /**
 280  * @brief               Frees the work queue
 281  * @param wq            pointer to work queue to free
 282  */
 283 static void
 284 oce_wq_free(struct oce_wq *wq)
 285 {
 286         POCE_SOFTC sc = (POCE_SOFTC) wq->parent;
 287         int i;
 288
 289         taskqueue_drain(taskqueue_swi, &wq->txtask);
 290
 291         if (wq->ring != NULL) {
 292                 oce_destroy_ring_buffer(sc, wq->ring);
 293                 wq->ring = NULL;
 294         }
 295
 296         for (i = 0; i < OCE_WQ_PACKET_ARRAY_SIZE; i++) {
 297                 if (wq->pckts[i].map != NULL) {
 298                         bus_dmamap_unload(wq->tag, wq->pckts[i].map);
 299                         bus_dmamap_destroy(wq->tag, wq->pckts[i].map);
 300                         wq->pckts[i].map = NULL;
 301                 }
 302         }
 303
 304         if (wq->tag != NULL)
 305                 bus_dma_tag_destroy(wq->tag);
 306         if (wq->br != NULL)
 307                 buf_ring_free(wq->br, M_DEVBUF);
 308
 309         LOCK_DESTROY(&wq->tx_lock);
 310         free(wq, M_DEVBUF);
 311 }
 312
 313
 314
 315 /**
 316  * @brief               Create a work queue
 317  * @param wq            pointer to work queue
 318  * @param eq            pointer to associated event queue
 319  */
 320 static int
 321 oce_wq_create(struct oce_wq *wq, struct oce_eq *eq)
 322 {
 323         POCE_SOFTC sc = wq->parent;
 324         struct oce_cq *cq;
 325         int rc = 0;
 326
 327         /* create the CQ */
 328         cq = oce_cq_create(sc,
 329                            eq,
 330                            CQ_LEN_1024,
 331                            sizeof(struct oce_nic_tx_cqe), 0, 1, 0, 3);
 332         if (!cq)
 333                 return ENXIO;
 334
 335
 336         wq->cq = cq;
 337
 338         rc = oce_mbox_create_wq(wq);
 339         if (rc)
 340                 goto error;
 341
 342         wq->qstate = QCREATED;
 343         wq->wq_free = wq->cfg.q_len;
 344         wq->ring->cidx = 0;
 345         wq->ring->pidx = 0;
 346
 347         eq->cq[eq->cq_valid] = cq;
 348         eq->cq_valid++;
 349         cq->cb_arg = wq;
 350         cq->cq_handler = oce_wq_handler;
 351
 352         return 0;
 353
 354 error:
 355         device_printf(sc->dev, "WQ create failed\n");
 356         oce_wq_del(wq);
 357         return rc;
 358 }
 359
 360
 361
 362
 363 /**
 364  * @brief               Delete a work queue
 365  * @param wq            pointer to work queue
 366  */
 367 static void
 368 oce_wq_del(struct oce_wq *wq)
 369 {
 370         struct oce_mbx mbx;
 371         struct mbx_delete_nic_wq *fwcmd;
 372         POCE_SOFTC sc = (POCE_SOFTC) wq->parent;
 373
 374         if (wq->qstate == QCREATED) {
 375                 bzero(&mbx, sizeof(struct oce_mbx));
 376                 /* now fill the command */
 377                 fwcmd = (struct mbx_delete_nic_wq *)&mbx.payload;
 378                 fwcmd->params.req.wq_id = wq->wq_id;
 379                 (void)oce_destroy_q(sc, &mbx,
 380                                 sizeof(struct mbx_delete_nic_wq), QTYPE_WQ);
 381                 wq->qstate = QDELETED;
 382         }
 383
 384         if (wq->cq != NULL) {
 385                 oce_cq_del(sc, wq->cq);
 386                 wq->cq = NULL;
 387         }
 388 }
 389
 390
 391
 392 /**
 393  * @brief               function to allocate receive queue resources
 394  * @param sc            software handle to the device
 395  * @param q_len         length of receive queue
 396  * @param frag_size     size of an receive queue fragment
 397  * @param mtu           maximum transmission unit
 398  * @param rss           is-rss-queue flag
 399  * @returns             the pointer to the RQ created or NULL on failure
 400  */
 401 static struct
 402 oce_rq *oce_rq_init(POCE_SOFTC sc,
 403                                   uint32_t q_len,
 404                                   uint32_t frag_size,
 405                                   uint32_t mtu, uint32_t rss)
 406 {
 407         struct oce_rq *rq;
 408         int rc = 0, i;
 409
 410         if (OCE_LOG2(frag_size) <= 0)
 411                 return NULL;
 412
 413         if ((q_len == 0) || (q_len > 1024))
 414                 return NULL;
 415
 416         /* allocate the rq */
 417         rq = malloc(sizeof(struct oce_rq), M_DEVBUF, M_NOWAIT | M_ZERO);
 418         if (!rq)
 419                 return NULL;
 420
 421
 422         rq->cfg.q_len = q_len;
 423         rq->cfg.frag_size = frag_size;
 424         rq->cfg.mtu = mtu;
 425         rq->cfg.eqd = 0;
 426         rq->lro_pkts_queued = 0;
 427         rq->cfg.is_rss_queue = rss;
 428         rq->packets_in = 0;
 429         rq->packets_out = 0;
 430         rq->pending = 0;
 431
 432         rq->parent = (void *)sc;
 433
 434         rc = bus_dma_tag_create(bus_get_dma_tag(sc->dev),
 435                                 1, 0,
 436                                 BUS_SPACE_MAXADDR,
 437                                 BUS_SPACE_MAXADDR,
 438                                 NULL, NULL,
 439                                 OCE_MAX_RX_SIZE,
 440                                 1, PAGE_SIZE, 0, NULL, NULL, &rq->tag);
 441
 442         if (rc)
 443                 goto free_rq;
 444
 445         for (i = 0; i < OCE_RQ_PACKET_ARRAY_SIZE; i++) {
 446                 rc = bus_dmamap_create(rq->tag, 0, &rq->pckts[i].map);
 447                 if (rc)
 448                         goto free_rq;
 449         }
 450
 451         /* create the ring buffer */
 452         rq->ring = oce_create_ring_buffer(sc, q_len,
 453                                  sizeof(struct oce_nic_rqe));
 454         if (!rq->ring)
 455                 goto free_rq;
 456
 457         LOCK_CREATE(&rq->rx_lock, "RX_lock");
 458
 459         return rq;
 460
 461 free_rq:
 462         device_printf(sc->dev, "Create RQ failed\n");
 463         oce_rq_free(rq);
 464         return NULL;
 465 }
 466
 467
 468
 469
 470 /**
 471  * @brief               Free a receive queue
 472  * @param rq            pointer to receive queue
 473  */
 474 static void
 475 oce_rq_free(struct oce_rq *rq)
 476 {
 477         POCE_SOFTC sc = (POCE_SOFTC) rq->parent;
 478         int i = 0 ;
 479
 480         if (rq->ring != NULL) {
 481                 oce_destroy_ring_buffer(sc, rq->ring);
 482                 rq->ring = NULL;
 483         }
 484         for (i = 0; i < OCE_RQ_PACKET_ARRAY_SIZE; i++) {
 485                 if (rq->pckts[i].map != NULL) {
 486                         bus_dmamap_unload(rq->tag, rq->pckts[i].map);
 487                         bus_dmamap_destroy(rq->tag, rq->pckts[i].map);
 488                         rq->pckts[i].map = NULL;
 489                 }
 490                 if (rq->pckts[i].mbuf) {
 491                         m_free(rq->pckts[i].mbuf);
 492                         rq->pckts[i].mbuf = NULL;
 493                 }
 494         }
 495
 496         if (rq->tag != NULL)
 497                 bus_dma_tag_destroy(rq->tag);
 498
 499         LOCK_DESTROY(&rq->rx_lock);
 500         free(rq, M_DEVBUF);
 501 }
 502
 503
 504
 505
 506 /**
 507  * @brief               Create a receive queue
 508  * @param rq            receive queue
 509  * @param if_id         interface identifier index`
 510  * @param eq            pointer to event queue
 511  */
 512 static int
 513 oce_rq_create(struct oce_rq *rq, uint32_t if_id, struct oce_eq *eq)
 514 {
 515         POCE_SOFTC sc = rq->parent;
 516         struct oce_cq *cq;
 517
 518         cq = oce_cq_create(sc,
 519                            eq,
 520                            CQ_LEN_1024,
 521                            sizeof(struct oce_nic_rx_cqe), 0, 1, 0, 3);
 522         if (!cq)
 523                 return ENXIO;
 524
 525         rq->cq = cq;
 526         rq->cfg.if_id = if_id;
 527
 528         /* Dont create RQ here. Create in if_activate */
 529         rq->qstate     = 0;
 530         rq->ring->cidx = 0;
 531         rq->ring->pidx = 0;
 532         eq->cq[eq->cq_valid] = cq;
 533         eq->cq_valid++;
 534         cq->cb_arg = rq;
 535         cq->cq_handler = oce_rq_handler;
 536
 537         return 0;
 538
 539 }
 540
 541
 542
 543
 544 /**
 545  * @brief               Delete a receive queue
 546  * @param rq            receive queue
 547  */
 548 static void
 549 oce_rq_del(struct oce_rq *rq)
 550 {
 551         POCE_SOFTC sc = (POCE_SOFTC) rq->parent;
 552         struct oce_mbx mbx;
 553         struct mbx_delete_nic_rq *fwcmd;
 554
 555         if (rq->qstate == QCREATED) {
 556                 bzero(&mbx, sizeof(mbx));
 557
 558                 fwcmd = (struct mbx_delete_nic_rq *)&mbx.payload;
 559                 fwcmd->params.req.rq_id = rq->rq_id;
 560                 (void)oce_destroy_q(sc, &mbx,
 561                                 sizeof(struct mbx_delete_nic_rq), QTYPE_RQ);
 562                 rq->qstate = QDELETED;
 563         }
 564
 565         if (rq->cq != NULL) {
 566                 oce_cq_del(sc, rq->cq);
 567                 rq->cq = NULL;
 568         }
 569 }
 570
 571
 572
 573 /**
 574  * @brief               function to create an event queue
 575  * @param sc            software handle to the device
 576  * @param q_len         length of event queue
 577  * @param item_size     size of an event queue item
 578  * @param eq_delay      event queue delay
 579  * @retval eq           success, pointer to event queue
 580  * @retval NULL         failure
 581  */
 582 static struct
 583 oce_eq *oce_eq_create(POCE_SOFTC sc, uint32_t q_len,
 584                                     uint32_t item_size,
 585                                     uint32_t eq_delay,
 586                                     uint32_t vector)
 587 {
 588         struct oce_eq *eq;
 589         int rc = 0;
 590
 591         /* allocate an eq */
 592         eq = malloc(sizeof(struct oce_eq), M_DEVBUF, M_NOWAIT | M_ZERO);
 593         if (eq == NULL)
 594                 return NULL;
 595
 596         eq->parent = (void *)sc;
 597         eq->eq_id = 0xffff;
 598         eq->ring = oce_create_ring_buffer(sc, q_len, item_size);
 599         if (!eq->ring)
 600                 goto free_eq;
 601
 602         eq->eq_cfg.q_len = q_len;
 603         eq->eq_cfg.item_size = item_size;
 604         eq->eq_cfg.cur_eqd = (uint8_t) eq_delay;
 605
 606         rc = oce_mbox_create_eq(eq);
 607         if (rc)
 608                 goto free_eq;
 609
 610         sc->intrs[sc->neqs++].eq = eq;
 611
 612         return eq;
 613
 614 free_eq:
 615         oce_eq_del(eq);
 616         return NULL;
 617 }
 618
 619
 620
 621
 622 /**
 623  * @brief               Function to delete an event queue
 624  * @param eq            pointer to an event queue
 625  */
 626 static void
 627 oce_eq_del(struct oce_eq *eq)
 628 {
 629         struct oce_mbx mbx;
 630         struct mbx_destroy_common_eq *fwcmd;
 631         POCE_SOFTC sc = (POCE_SOFTC) eq->parent;
 632
 633         if (eq->eq_id != 0xffff) {
 634                 bzero(&mbx, sizeof(mbx));
 635                 fwcmd = (struct mbx_destroy_common_eq *)&mbx.payload;
 636                 fwcmd->params.req.id = eq->eq_id;
 637                 (void)oce_destroy_q(sc, &mbx,
 638                         sizeof(struct mbx_destroy_common_eq), QTYPE_EQ);
 639         }
 640
 641         if (eq->ring != NULL) {
 642                 oce_destroy_ring_buffer(sc, eq->ring);
 643                 eq->ring = NULL;
 644         }
 645
 646         free(eq, M_DEVBUF);
 647
 648 }
 649
 650
 651
 652
 653 /**
 654  * @brief               Function to create an MQ
 655  * @param sc            software handle to the device
 656  * @param eq            the EQ to associate with the MQ for event notification
 657  * @param q_len         the number of entries to create in the MQ
 658  * @returns             pointer to the created MQ, failure otherwise
 659  */
 660 static struct oce_mq *
 661 oce_mq_create(POCE_SOFTC sc, struct oce_eq *eq, uint32_t q_len)
 662 {
 663         struct oce_mbx mbx;
 664         struct mbx_create_common_mq_ex *fwcmd = NULL;
 665         struct oce_mq *mq = NULL;
 666         int rc = 0;
 667         struct oce_cq *cq;
 668         oce_mq_ext_ctx_t *ctx;
 669         uint32_t num_pages;
 670         uint32_t page_size;
 671         int version;
 672
 673         cq = oce_cq_create(sc, eq, CQ_LEN_256,
 674                         sizeof(struct oce_mq_cqe), 1, 1, 0, 0);
 675         if (!cq)
 676                 return NULL;
 677
 678         /* allocate the mq */
 679         mq = malloc(sizeof(struct oce_mq), M_DEVBUF, M_NOWAIT | M_ZERO);
 680         if (!mq) {
 681                 oce_cq_del(sc, cq);
 682                 goto error;
 683         }
 684
 685         mq->parent = sc;
 686
 687         mq->ring = oce_create_ring_buffer(sc, q_len, sizeof(struct oce_mbx));
 688         if (!mq->ring)
 689                 goto error;
 690
 691         bzero(&mbx, sizeof(struct oce_mbx));
 692
 693         IS_XE201(sc) ? (version = OCE_MBX_VER_V1) : (version = OCE_MBX_VER_V0);
 694         fwcmd = (struct mbx_create_common_mq_ex *)&mbx.payload;
 695         mbx_common_req_hdr_init(&fwcmd->hdr, 0, 0,
 696                                 MBX_SUBSYSTEM_COMMON,
 697                                 OPCODE_COMMON_CREATE_MQ_EXT,
 698                                 MBX_TIMEOUT_SEC,
 699                                 sizeof(struct mbx_create_common_mq_ex),
 700                                 version);
 701
 702         num_pages = oce_page_list(mq->ring, &fwcmd->params.req.pages[0]);
 703         page_size = mq->ring->num_items * mq->ring->item_size;
 704
 705         ctx = &fwcmd->params.req.context;
 706
 707         if (IS_XE201(sc)) {
 708                 ctx->v1.num_pages = num_pages;
 709                 ctx->v1.ring_size = OCE_LOG2(q_len) + 1;
 710                 ctx->v1.cq_id = cq->cq_id;
 711                 ctx->v1.valid = 1;
 712                 ctx->v1.async_cq_id = cq->cq_id;
 713                 ctx->v1.async_cq_valid = 1;
 714                 /* Subscribe to Link State and Group 5 Events(bits 1 & 5 set) */
 715                 ctx->v1.async_evt_bitmap |= LE_32(0x00000022);
 716                 ctx->v1.async_evt_bitmap |= LE_32(1 << ASYNC_EVENT_CODE_DEBUG);
 717                 ctx->v1.async_evt_bitmap |=
 718                                         LE_32(1 << ASYNC_EVENT_CODE_SLIPORT);
 719         }
 720         else {
 721                 ctx->v0.num_pages = num_pages;
 722                 ctx->v0.cq_id = cq->cq_id;
 723                 ctx->v0.ring_size = OCE_LOG2(q_len) + 1;
 724                 ctx->v0.valid = 1;
 725                 /* Subscribe to Link State and Group5 Events(bits 1 & 5 set) */
 726                 ctx->v0.async_evt_bitmap = 0xffffffff;
 727         }
 728
 729         mbx.u0.s.embedded = 1;
 730         mbx.payload_length = sizeof(struct mbx_create_common_mq_ex);
 731         DW_SWAP(u32ptr(&mbx), mbx.payload_length + OCE_BMBX_RHDR_SZ);
 732
 733         rc = oce_mbox_post(sc, &mbx, NULL);
 734         if (!rc)
 735                 rc = fwcmd->hdr.u0.rsp.status;
 736         if (rc) {
 737                 device_printf(sc->dev,"%s failed - cmd status: %d\n",
 738                               __FUNCTION__, rc);
 739                 goto error;
 740         }
 741         mq->mq_id = LE_16(fwcmd->params.rsp.mq_id);
 742         mq->cq = cq;
 743         eq->cq[eq->cq_valid] = cq;
 744         eq->cq_valid++;
 745         mq->cq->eq = eq;
 746         mq->cfg.q_len = (uint8_t) q_len;
 747         mq->cfg.eqd = 0;
 748         mq->qstate = QCREATED;
 749
 750         mq->cq->cb_arg = mq;
 751         mq->cq->cq_handler = oce_mq_handler;
 752
 753         return mq;
 754
 755 error:
 756         device_printf(sc->dev, "MQ create failed\n");
 757         oce_mq_free(mq);
 758         mq = NULL;
 759         return mq;
 760 }
 761
 762
 763
 764
 765
 766 /**
 767  * @brief               Function to free a mailbox queue
 768  * @param mq            pointer to a mailbox queue
 769  */
 770 static void
 771 oce_mq_free(struct oce_mq *mq)
 772 {
 773         POCE_SOFTC sc = (POCE_SOFTC) mq->parent;
 774         struct oce_mbx mbx;
 775         struct mbx_destroy_common_mq *fwcmd;
 776
 777         if (!mq)
 778                 return;
 779
 780         if (mq->ring != NULL) {
 781                 oce_destroy_ring_buffer(sc, mq->ring);
 782                 mq->ring = NULL;
 783                 if (mq->qstate == QCREATED) {
 784                         bzero(&mbx, sizeof (struct oce_mbx));
 785                         fwcmd = (struct mbx_destroy_common_mq *)&mbx.payload;
 786                         fwcmd->params.req.id = mq->mq_id;
 787                         (void) oce_destroy_q(sc, &mbx,
 788                                 sizeof (struct mbx_destroy_common_mq),
 789                                 QTYPE_MQ);
 790                 }
 791                 mq->qstate = QDELETED;
 792         }
 793
 794         if (mq->cq != NULL) {
 795                 oce_cq_del(sc, mq->cq);
 796                 mq->cq = NULL;
 797         }
 798
 799         free(mq, M_DEVBUF);
 800         mq = NULL;
 801 }
 802
 803
 804
 805 /**
 806  * @brief               Function to delete a EQ, CQ, MQ, WQ or RQ
 807  * @param sc            sofware handle to the device
 808  * @param mbx           mailbox command to send to the fw to delete the queue
 809  *                      (mbx contains the queue information to delete)
 810  * @param req_size      the size of the mbx payload dependent on the qtype
 811  * @param qtype         the type of queue i.e. EQ, CQ, MQ, WQ or RQ
 812  * @returns             0 on success, failure otherwise
 813  */
 814 static int
 815 oce_destroy_q(POCE_SOFTC sc, struct oce_mbx *mbx, size_t req_size,
 816                 enum qtype qtype)
 817 {
 818         struct mbx_hdr *hdr = (struct mbx_hdr *)&mbx->payload;
 819         int opcode;
 820         int subsys;
 821         int rc = 0;
 822
 823         switch (qtype) {
 824         case QTYPE_EQ:
 825                 opcode = OPCODE_COMMON_DESTROY_EQ;
 826                 subsys = MBX_SUBSYSTEM_COMMON;
 827                 break;
 828         case QTYPE_CQ:
 829                 opcode = OPCODE_COMMON_DESTROY_CQ;
 830                 subsys = MBX_SUBSYSTEM_COMMON;
 831                 break;
 832         case QTYPE_MQ:
 833                 opcode = OPCODE_COMMON_DESTROY_MQ;
 834                 subsys = MBX_SUBSYSTEM_COMMON;
 835                 break;
 836         case QTYPE_WQ:
 837                 opcode = NIC_DELETE_WQ;
 838                 subsys = MBX_SUBSYSTEM_NIC;
 839                 break;
 840         case QTYPE_RQ:
 841                 opcode = NIC_DELETE_RQ;
 842                 subsys = MBX_SUBSYSTEM_NIC;
 843                 break;
 844         default:
 845                 return EINVAL;
 846         }
 847
 848         mbx_common_req_hdr_init(hdr, 0, 0, subsys,
 849                                 opcode, MBX_TIMEOUT_SEC, req_size,
 850                                 OCE_MBX_VER_V0);
 851
 852         mbx->u0.s.embedded = 1;
 853         mbx->payload_length = (uint32_t) req_size;
 854         DW_SWAP(u32ptr(mbx), mbx->payload_length + OCE_BMBX_RHDR_SZ);
 855
 856         rc = oce_mbox_post(sc, mbx, NULL);
 857         if (!rc)
 858                 rc = hdr->u0.rsp.status;
 859         if (rc)
 860                 device_printf(sc->dev,"%s failed - cmd status: %d\n",
 861                               __FUNCTION__, rc);
 862         return rc;
 863 }
 864
 865
 866
 867 /**
 868  * @brief               Function to create a completion queue
 869  * @param sc            software handle to the device
 870  * @param eq            optional eq to be associated with to the cq
 871  * @param q_len         length of completion queue
 872  * @param item_size     size of completion queue items
 873  * @param sol_event     command context event
 874  * @param is_eventable  event table
 875  * @param nodelay       no delay flag
 876  * @param ncoalesce     no coalescence flag
 877  * @returns             pointer to the cq created, NULL on failure
 878  */
 879 struct oce_cq *
 880 oce_cq_create(POCE_SOFTC sc, struct oce_eq *eq,
 881                              uint32_t q_len,
 882                              uint32_t item_size,
 883                              uint32_t sol_event,
 884                              uint32_t is_eventable,
 885                              uint32_t nodelay, uint32_t ncoalesce)
 886 {
 887         struct oce_cq *cq = NULL;
 888         int rc = 0;
 889
 890         cq = malloc(sizeof(struct oce_cq), M_DEVBUF, M_NOWAIT | M_ZERO);
 891         if (!cq)
 892                 return NULL;
 893
 894         cq->ring = oce_create_ring_buffer(sc, q_len, item_size);
 895         if (!cq->ring)
 896                 goto error;
 897
 898         cq->parent = sc;
 899         cq->eq = eq;
 900         cq->cq_cfg.q_len = q_len;
 901         cq->cq_cfg.item_size = item_size;
 902         cq->cq_cfg.nodelay = (uint8_t) nodelay;
 903
 904         rc = oce_mbox_cq_create(cq, ncoalesce, is_eventable);
 905         if (rc)
 906                 goto error;
 907
 908         sc->cq[sc->ncqs++] = cq;
 909
 910         return cq;
 911
 912 error:
 913         device_printf(sc->dev, "CQ create failed\n");
 914         oce_cq_del(sc, cq);
 915         return NULL;
 916 }
 917
 918
 919
 920 /**
 921  * @brief               Deletes the completion queue
 922  * @param sc            software handle to the device
 923  * @param cq            pointer to a completion queue
 924  */
 925 static void
 926 oce_cq_del(POCE_SOFTC sc, struct oce_cq *cq)
 927 {
 928         struct oce_mbx mbx;
 929         struct mbx_destroy_common_cq *fwcmd;
 930
 931         if (cq->ring != NULL) {
 932
 933                 bzero(&mbx, sizeof(struct oce_mbx));
 934                 /* now fill the command */
 935                 fwcmd = (struct mbx_destroy_common_cq *)&mbx.payload;
 936                 fwcmd->params.req.id = cq->cq_id;
 937                 (void)oce_destroy_q(sc, &mbx,
 938                         sizeof(struct mbx_destroy_common_cq), QTYPE_CQ);
 939                 /*NOW destroy the ring */
 940                 oce_destroy_ring_buffer(sc, cq->ring);
 941                 cq->ring = NULL;
 942         }
 943
 944         free(cq, M_DEVBUF);
 945         cq = NULL;
 946 }
 947
 948
 949
 950 /**
 951  * @brief               Start a receive queue
 952  * @param rq            pointer to a receive queue
 953  */
 954 int
 955 oce_start_rq(struct oce_rq *rq)
 956 {
 957         int rc;
 958
 959         rc = oce_alloc_rx_bufs(rq, rq->cfg.q_len);
 960
 961         if (rc == 0)
 962                 oce_arm_cq(rq->parent, rq->cq->cq_id, 0, TRUE);
 963         return rc;
 964 }
 965
 966
 967
 968 /**
 969  * @brief               Start a work queue
 970  * @param wq            pointer to a work queue
 971  */
 972 int
 973 oce_start_wq(struct oce_wq *wq)
 974 {
 975         oce_arm_cq(wq->parent, wq->cq->cq_id, 0, TRUE);
 976         return 0;
 977 }
 978
 979
 980
 981 /**
 982  * @brief               Start a mailbox queue
 983  * @param mq            pointer to a mailbox queue
 984  */
 985 int
 986 oce_start_mq(struct oce_mq *mq)
 987 {
 988         oce_arm_cq(mq->parent, mq->cq->cq_id, 0, TRUE);
 989         return 0;
 990 }
 991
 992
 993
 994 /**
 995  * @brief               Function to arm an EQ so that it can generate events
 996  * @param sc            software handle to the device
 997  * @param qid           id of the EQ returned by the fw at the time of creation
 998  * @param npopped       number of EQEs to arm
 999  * @param rearm         rearm bit enable/disable
1000  * @param clearint      bit to clear the interrupt condition because of which
1001  *                      EQEs are generated
1002  */
1003 void
1004 oce_arm_eq(POCE_SOFTC sc,
1005            int16_t qid, int npopped, uint32_t rearm, uint32_t clearint)
1006 {
1007         eq_db_t eq_db = { 0 };
1008
1009         eq_db.bits.rearm = rearm;
1010         eq_db.bits.event = 1;
1011         eq_db.bits.num_popped = npopped;
1012         eq_db.bits.clrint = clearint;
1013         eq_db.bits.qid = qid;
1014         OCE_WRITE_REG32(sc, db, PD_EQ_DB, eq_db.dw0);
1015
1016 }
1017
1018
1019
1020
1021 /**
1022  * @brief               Function to arm a CQ with CQEs
1023  * @param sc            software handle to the device
1024  * @param qid           id of the CQ returned by the fw at the time of creation
1025  * @param npopped       number of CQEs to arm
1026  * @param rearm         rearm bit enable/disable
1027  */
1028 void oce_arm_cq(POCE_SOFTC sc, int16_t qid, int npopped, uint32_t rearm)
1029 {
1030         cq_db_t cq_db = { 0 };
1031
1032         cq_db.bits.rearm = rearm;
1033         cq_db.bits.num_popped = npopped;
1034         cq_db.bits.event = 0;
1035         cq_db.bits.qid = qid;
1036         OCE_WRITE_REG32(sc, db, PD_CQ_DB, cq_db.dw0);
1037
1038 }
1039
1040
1041
1042
1043 /*
1044  * @brief               function to cleanup the eqs used during stop
1045  * @param eq            pointer to event queue structure
1046  * @returns             the number of EQs processed
1047  */
1048 void
1049 oce_drain_eq(struct oce_eq *eq)
1050 {
1051
1052         struct oce_eqe *eqe;
1053         uint16_t num_eqe = 0;
1054         POCE_SOFTC sc = eq->parent;
1055
1056         do {
1057                 eqe = RING_GET_CONSUMER_ITEM_VA(eq->ring, struct oce_eqe);
1058                 if (eqe->evnt == 0)
1059                         break;
1060                 eqe->evnt = 0;
1061                 bus_dmamap_sync(eq->ring->dma.tag, eq->ring->dma.map,
1062                                         BUS_DMASYNC_POSTWRITE);
1063                 num_eqe++;
1064                 RING_GET(eq->ring, 1);
1065
1066         } while (TRUE);
1067
1068         oce_arm_eq(sc, eq->eq_id, num_eqe, FALSE, TRUE);
1069
1070 }
1071
1072
1073
1074 void
1075 oce_drain_wq_cq(struct oce_wq *wq)
1076 {
1077         POCE_SOFTC sc = wq->parent;
1078         struct oce_cq *cq = wq->cq;
1079         struct oce_nic_tx_cqe *cqe;
1080         int num_cqes = 0;
1081
1082         bus_dmamap_sync(cq->ring->dma.tag, cq->ring->dma.map,
1083                                  BUS_DMASYNC_POSTWRITE);
1084
1085         do {
1086                 cqe = RING_GET_CONSUMER_ITEM_VA(cq->ring, struct oce_nic_tx_cqe);
1087                 if (cqe->u0.dw[3] == 0)
1088                         break;
1089                 cqe->u0.dw[3] = 0;
1090                 bus_dmamap_sync(cq->ring->dma.tag, cq->ring->dma.map,
1091                                  BUS_DMASYNC_POSTWRITE);
1092                 RING_GET(cq->ring, 1);
1093                 num_cqes++;
1094
1095         } while (TRUE);
1096
1097         oce_arm_cq(sc, cq->cq_id, num_cqes, FALSE);
1098
1099 }
1100
1101
1102 /*
1103  * @brief               function to drain a MCQ and process its CQEs
1104  * @param dev           software handle to the device
1105  * @param cq            pointer to the cq to drain
1106  * @returns             the number of CQEs processed
1107  */
1108 void
1109 oce_drain_mq_cq(void *arg)
1110 {
1111         /* TODO: additional code. */
1112         return;
1113 }
1114
1115
1116
1117 /**
1118  * @brief               function to process a Recieve queue
1119  * @param arg           pointer to the RQ to charge
1120  * @return              number of cqes processed
1121  */
1122 void
1123 oce_drain_rq_cq(struct oce_rq *rq)
1124 {
1125         struct oce_nic_rx_cqe *cqe;
1126         uint16_t num_cqe = 0;
1127         struct oce_cq  *cq;
1128         POCE_SOFTC sc;
1129
1130         sc = rq->parent;
1131         cq = rq->cq;
1132         cqe = RING_GET_CONSUMER_ITEM_VA(cq->ring, struct oce_nic_rx_cqe);
1133         /* dequeue till you reach an invalid cqe */
1134         while (RQ_CQE_VALID(cqe)) {
1135                 RQ_CQE_INVALIDATE(cqe);
1136                 RING_GET(cq->ring, 1);
1137                 cqe = RING_GET_CONSUMER_ITEM_VA(cq->ring,
1138                     struct oce_nic_rx_cqe);
1139                 num_cqe++;
1140         }
1141         oce_arm_cq(sc, cq->cq_id, num_cqe, FALSE);
1142
1143         return;
1144 }
1145
1146
1147 void
1148 oce_free_posted_rxbuf(struct oce_rq *rq)
1149 {
1150         struct oce_packet_desc *pd;
1151
1152         while (rq->pending) {
1153
1154                 pd = &rq->pckts[rq->packets_out];
1155                 bus_dmamap_sync(rq->tag, pd->map, BUS_DMASYNC_POSTWRITE);
1156                 bus_dmamap_unload(rq->tag, pd->map);
1157                 if (pd->mbuf != NULL) {
1158                         m_freem(pd->mbuf);
1159                         pd->mbuf = NULL;
1160                 }
1161
1162                 if ((rq->packets_out + 1) == OCE_RQ_PACKET_ARRAY_SIZE)
1163                         rq->packets_out = 0;
1164                 else
1165                         rq->packets_out++;
1166
1167                 rq->pending--;
1168         }
1169
1170 }
1171
1172 void
1173 oce_stop_rx(POCE_SOFTC sc)
1174 {
1175         struct oce_mbx mbx;
1176         struct mbx_delete_nic_rq *fwcmd;
1177         struct oce_rq *rq;
1178         int i = 0;
1179
1180         for_all_rq_queues(sc, rq, i) {
1181                 if (rq->qstate == QCREATED) {
1182                         /* Delete rxq in firmware */
1183
1184                         bzero(&mbx, sizeof(mbx));
1185                         fwcmd = (struct mbx_delete_nic_rq *)&mbx.payload;
1186                         fwcmd->params.req.rq_id = rq->rq_id;
1187
1188                         (void)oce_destroy_q(sc, &mbx,
1189                                 sizeof(struct mbx_delete_nic_rq), QTYPE_RQ);
1190
1191                         rq->qstate = QDELETED;
1192
1193                         DELAY(1);
1194
1195                         /* Free posted RX buffers that are not used */
1196                         oce_free_posted_rxbuf(rq);
1197
1198                 }
1199         }
1200 }
1201
1202
1203
1204 int
1205 oce_start_rx(POCE_SOFTC sc)
1206 {
1207         struct oce_rq *rq;
1208         int rc = 0, i;
1209
1210         for_all_rq_queues(sc, rq, i) {
1211                 if (rq->qstate == QCREATED)
1212                         continue;
1213                 rc = oce_mbox_create_rq(rq);
1214                 if (rc)
1215                         goto error;
1216                 /* reset queue pointers */
1217                 rq->qstate       = QCREATED;
1218                 rq->pending      = 0;
1219                 rq->ring->cidx   = 0;
1220                 rq->ring->pidx   = 0;
1221                 rq->packets_in   = 0;
1222                 rq->packets_out  = 0;
1223         }
1224
1225         DELAY(1);
1226
1227         /* RSS config */
1228         if (is_rss_enabled(sc)) {
1229                 rc = oce_config_nic_rss(sc, (uint8_t) sc->if_id, RSS_ENABLE);
1230                 if (rc)
1231                         goto error;
1232
1233         }
1234
1235         return rc;
1236 error:
1237         device_printf(sc->dev, "Start RX failed\n");
1238         return rc;
1239
1240 }
1241
1242
1243