drivers/net/qlcnic/qlcnic_ctx.c

   1 /*
   2  * Copyright (C) 2009 - QLogic Corporation.
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18  * MA  02111-1307, USA.
  19  *
  20  * The full GNU General Public License is included in this distribution
  21  * in the file called "COPYING".
  22  *
  23  */
  24
  25 #include "qlcnic.h"
  26
  27 static u32
  28 qlcnic_poll_rsp(struct qlcnic_adapter *adapter)
  29 {
  30         u32 rsp;
  31         int timeout = 0;
  32
  33         do {
  34                 /* give atleast 1ms for firmware to respond */
  35                 msleep(1);
  36
  37                 if (++timeout > QLCNIC_OS_CRB_RETRY_COUNT)
  38                         return QLCNIC_CDRP_RSP_TIMEOUT;
  39
  40                 rsp = QLCRD32(adapter, QLCNIC_CDRP_CRB_OFFSET);
  41         } while (!QLCNIC_CDRP_IS_RSP(rsp));
  42
  43         return rsp;
  44 }
  45
  46 u32
  47 qlcnic_issue_cmd(struct qlcnic_adapter *adapter,
  48         u32 pci_fn, u32 version, u32 arg1, u32 arg2, u32 arg3, u32 cmd)
  49 {
  50         u32 rsp;
  51         u32 signature;
  52         u32 rcode = QLCNIC_RCODE_SUCCESS;
  53         struct pci_dev *pdev = adapter->pdev;
  54
  55         signature = QLCNIC_CDRP_SIGNATURE_MAKE(pci_fn, version);
  56
  57         /* Acquire semaphore before accessing CRB */
  58         if (qlcnic_api_lock(adapter))
  59                 return QLCNIC_RCODE_TIMEOUT;
  60
  61         QLCWR32(adapter, QLCNIC_SIGN_CRB_OFFSET, signature);
  62         QLCWR32(adapter, QLCNIC_ARG1_CRB_OFFSET, arg1);
  63         QLCWR32(adapter, QLCNIC_ARG2_CRB_OFFSET, arg2);
  64         QLCWR32(adapter, QLCNIC_ARG3_CRB_OFFSET, arg3);
  65         QLCWR32(adapter, QLCNIC_CDRP_CRB_OFFSET, QLCNIC_CDRP_FORM_CMD(cmd));
  66
  67         rsp = qlcnic_poll_rsp(adapter);
  68
  69         if (rsp == QLCNIC_CDRP_RSP_TIMEOUT) {
  70                 dev_err(&pdev->dev, "card response timeout.\n");
  71                 rcode = QLCNIC_RCODE_TIMEOUT;
  72         } else if (rsp == QLCNIC_CDRP_RSP_FAIL) {
  73                 rcode = QLCRD32(adapter, QLCNIC_ARG1_CRB_OFFSET);
  74                 dev_err(&pdev->dev, "failed card response code:0x%x\n",
  75                                 rcode);
  76         }
  77
  78         /* Release semaphore */
  79         qlcnic_api_unlock(adapter);
  80
  81         return rcode;
  82 }
  83
  84 int
  85 qlcnic_fw_cmd_set_mtu(struct qlcnic_adapter *adapter, int mtu)
  86 {
  87         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
  88
  89         if (recv_ctx->state == QLCNIC_HOST_CTX_STATE_ACTIVE) {
  90                 if (qlcnic_issue_cmd(adapter,
  91                         adapter->ahw.pci_func,
  92                         adapter->fw_hal_version,
  93                         recv_ctx->context_id,
  94                         mtu,
  95                         0,
  96                         QLCNIC_CDRP_CMD_SET_MTU)) {
  97
  98                         dev_err(&adapter->pdev->dev, "Failed to set mtu\n");
  99                         return -EIO;
 100                 }
 101         }
 102
 103         return 0;
 104 }
 105
 106 static int
 107 qlcnic_fw_cmd_create_rx_ctx(struct qlcnic_adapter *adapter)
 108 {
 109         void *addr;
 110         struct qlcnic_hostrq_rx_ctx *prq;
 111         struct qlcnic_cardrsp_rx_ctx *prsp;
 112         struct qlcnic_hostrq_rds_ring *prq_rds;
 113         struct qlcnic_hostrq_sds_ring *prq_sds;
 114         struct qlcnic_cardrsp_rds_ring *prsp_rds;
 115         struct qlcnic_cardrsp_sds_ring *prsp_sds;
 116         struct qlcnic_host_rds_ring *rds_ring;
 117         struct qlcnic_host_sds_ring *sds_ring;
 118
 119         dma_addr_t hostrq_phys_addr, cardrsp_phys_addr;
 120         u64 phys_addr;
 121
 122         int i, nrds_rings, nsds_rings;
 123         size_t rq_size, rsp_size;
 124         u32 cap, reg, val, reg2;
 125         int err;
 126
 127         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
 128
 129         nrds_rings = adapter->max_rds_rings;
 130         nsds_rings = adapter->max_sds_rings;
 131
 132         rq_size =
 133                 SIZEOF_HOSTRQ_RX(struct qlcnic_hostrq_rx_ctx, nrds_rings,
 134                                                 nsds_rings);
 135         rsp_size =
 136                 SIZEOF_CARDRSP_RX(struct qlcnic_cardrsp_rx_ctx, nrds_rings,
 137                                                 nsds_rings);
 138
 139         addr = pci_alloc_consistent(adapter->pdev,
 140                                 rq_size, &hostrq_phys_addr);
 141         if (addr == NULL)
 142                 return -ENOMEM;
 143         prq = (struct qlcnic_hostrq_rx_ctx *)addr;
 144
 145         addr = pci_alloc_consistent(adapter->pdev,
 146                         rsp_size, &cardrsp_phys_addr);
 147         if (addr == NULL) {
 148                 err = -ENOMEM;
 149                 goto out_free_rq;
 150         }
 151         prsp = (struct qlcnic_cardrsp_rx_ctx *)addr;
 152
 153         prq->host_rsp_dma_addr = cpu_to_le64(cardrsp_phys_addr);
 154
 155         cap = (QLCNIC_CAP0_LEGACY_CONTEXT | QLCNIC_CAP0_LEGACY_MN
 156                                                 | QLCNIC_CAP0_VALIDOFF);
 157         cap |= (QLCNIC_CAP0_JUMBO_CONTIGUOUS | QLCNIC_CAP0_LRO_CONTIGUOUS);
 158
 159         prq->valid_field_offset = offsetof(struct qlcnic_hostrq_rx_ctx,
 160                                                          msix_handler);
 161         prq->txrx_sds_binding = nsds_rings - 1;
 162
 163         prq->capabilities[0] = cpu_to_le32(cap);
 164         prq->host_int_crb_mode =
 165                 cpu_to_le32(QLCNIC_HOST_INT_CRB_MODE_SHARED);
 166         prq->host_rds_crb_mode =
 167                 cpu_to_le32(QLCNIC_HOST_RDS_CRB_MODE_UNIQUE);
 168
 169         prq->num_rds_rings = cpu_to_le16(nrds_rings);
 170         prq->num_sds_rings = cpu_to_le16(nsds_rings);
 171         prq->rds_ring_offset = cpu_to_le32(0);
 172
 173         val = le32_to_cpu(prq->rds_ring_offset) +
 174                 (sizeof(struct qlcnic_hostrq_rds_ring) * nrds_rings);
 175         prq->sds_ring_offset = cpu_to_le32(val);
 176
 177         prq_rds = (struct qlcnic_hostrq_rds_ring *)(prq->data +
 178                         le32_to_cpu(prq->rds_ring_offset));
 179
 180         for (i = 0; i < nrds_rings; i++) {
 181
 182                 rds_ring = &recv_ctx->rds_rings[i];
 183                 rds_ring->producer = 0;
 184
 185                 prq_rds[i].host_phys_addr = cpu_to_le64(rds_ring->phys_addr);
 186                 prq_rds[i].ring_size = cpu_to_le32(rds_ring->num_desc);
 187                 prq_rds[i].ring_kind = cpu_to_le32(i);
 188                 prq_rds[i].buff_size = cpu_to_le64(rds_ring->dma_size);
 189         }
 190
 191         prq_sds = (struct qlcnic_hostrq_sds_ring *)(prq->data +
 192                         le32_to_cpu(prq->sds_ring_offset));
 193
 194         for (i = 0; i < nsds_rings; i++) {
 195
 196                 sds_ring = &recv_ctx->sds_rings[i];
 197                 sds_ring->consumer = 0;
 198                 memset(sds_ring->desc_head, 0, STATUS_DESC_RINGSIZE(sds_ring));
 199
 200                 prq_sds[i].host_phys_addr = cpu_to_le64(sds_ring->phys_addr);
 201                 prq_sds[i].ring_size = cpu_to_le32(sds_ring->num_desc);
 202                 prq_sds[i].msi_index = cpu_to_le16(i);
 203         }
 204
 205         phys_addr = hostrq_phys_addr;
 206         err = qlcnic_issue_cmd(adapter,
 207                         adapter->ahw.pci_func,
 208                         adapter->fw_hal_version,
 209                         (u32)(phys_addr >> 32),
 210                         (u32)(phys_addr & 0xffffffff),
 211                         rq_size,
 212                         QLCNIC_CDRP_CMD_CREATE_RX_CTX);
 213         if (err) {
 214                 dev_err(&adapter->pdev->dev,
 215                         "Failed to create rx ctx in firmware%d\n", err);
 216                 goto out_free_rsp;
 217         }
 218
 219
 220         prsp_rds = ((struct qlcnic_cardrsp_rds_ring *)
 221                          &prsp->data[le32_to_cpu(prsp->rds_ring_offset)]);
 222
 223         for (i = 0; i < le16_to_cpu(prsp->num_rds_rings); i++) {
 224                 rds_ring = &recv_ctx->rds_rings[i];
 225
 226                 reg = le32_to_cpu(prsp_rds[i].host_producer_crb);
 227                 rds_ring->crb_rcv_producer = adapter->ahw.pci_base0 + reg;
 228         }
 229
 230         prsp_sds = ((struct qlcnic_cardrsp_sds_ring *)
 231                         &prsp->data[le32_to_cpu(prsp->sds_ring_offset)]);
 232
 233         for (i = 0; i < le16_to_cpu(prsp->num_sds_rings); i++) {
 234                 sds_ring = &recv_ctx->sds_rings[i];
 235
 236                 reg = le32_to_cpu(prsp_sds[i].host_consumer_crb);
 237                 reg2 = le32_to_cpu(prsp_sds[i].interrupt_crb);
 238
 239                 sds_ring->crb_sts_consumer = adapter->ahw.pci_base0 + reg;
 240                 sds_ring->crb_intr_mask = adapter->ahw.pci_base0 + reg2;
 241         }
 242
 243         recv_ctx->state = le32_to_cpu(prsp->host_ctx_state);
 244         recv_ctx->context_id = le16_to_cpu(prsp->context_id);
 245         recv_ctx->virt_port = prsp->virt_port;
 246
 247 out_free_rsp:
 248         pci_free_consistent(adapter->pdev, rsp_size, prsp, cardrsp_phys_addr);
 249 out_free_rq:
 250         pci_free_consistent(adapter->pdev, rq_size, prq, hostrq_phys_addr);
 251         return err;
 252 }
 253
 254 static void
 255 qlcnic_fw_cmd_destroy_rx_ctx(struct qlcnic_adapter *adapter)
 256 {
 257         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
 258
 259         if (qlcnic_issue_cmd(adapter,
 260                         adapter->ahw.pci_func,
 261                         adapter->fw_hal_version,
 262                         recv_ctx->context_id,
 263                         QLCNIC_DESTROY_CTX_RESET,
 264                         0,
 265                         QLCNIC_CDRP_CMD_DESTROY_RX_CTX)) {
 266
 267                 dev_err(&adapter->pdev->dev,
 268                         "Failed to destroy rx ctx in firmware\n");
 269         }
 270
 271         recv_ctx->state = QLCNIC_HOST_CTX_STATE_FREED;
 272 }
 273
 274 static int
 275 qlcnic_fw_cmd_create_tx_ctx(struct qlcnic_adapter *adapter)
 276 {
 277         struct qlcnic_hostrq_tx_ctx     *prq;
 278         struct qlcnic_hostrq_cds_ring   *prq_cds;
 279         struct qlcnic_cardrsp_tx_ctx    *prsp;
 280         void    *rq_addr, *rsp_addr;
 281         size_t  rq_size, rsp_size;
 282         u32     temp;
 283         int     err;
 284         u64     phys_addr;
 285         dma_addr_t      rq_phys_addr, rsp_phys_addr;
 286         struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
 287
 288         /* reset host resources */
 289         tx_ring->producer = 0;
 290         tx_ring->sw_consumer = 0;
 291         *(tx_ring->hw_consumer) = 0;
 292
 293         rq_size = SIZEOF_HOSTRQ_TX(struct qlcnic_hostrq_tx_ctx);
 294         rq_addr = pci_alloc_consistent(adapter->pdev,
 295                 rq_size, &rq_phys_addr);
 296         if (!rq_addr)
 297                 return -ENOMEM;
 298
 299         rsp_size = SIZEOF_CARDRSP_TX(struct qlcnic_cardrsp_tx_ctx);
 300         rsp_addr = pci_alloc_consistent(adapter->pdev,
 301                 rsp_size, &rsp_phys_addr);
 302         if (!rsp_addr) {
 303                 err = -ENOMEM;
 304                 goto out_free_rq;
 305         }
 306
 307         memset(rq_addr, 0, rq_size);
 308         prq = (struct qlcnic_hostrq_tx_ctx *)rq_addr;
 309
 310         memset(rsp_addr, 0, rsp_size);
 311         prsp = (struct qlcnic_cardrsp_tx_ctx *)rsp_addr;
 312
 313         prq->host_rsp_dma_addr = cpu_to_le64(rsp_phys_addr);
 314
 315         temp = (QLCNIC_CAP0_LEGACY_CONTEXT | QLCNIC_CAP0_LEGACY_MN |
 316                                         QLCNIC_CAP0_LSO);
 317         prq->capabilities[0] = cpu_to_le32(temp);
 318
 319         prq->host_int_crb_mode =
 320                 cpu_to_le32(QLCNIC_HOST_INT_CRB_MODE_SHARED);
 321
 322         prq->interrupt_ctl = 0;
 323         prq->msi_index = 0;
 324         prq->cmd_cons_dma_addr = cpu_to_le64(tx_ring->hw_cons_phys_addr);
 325
 326         prq_cds = &prq->cds_ring;
 327
 328         prq_cds->host_phys_addr = cpu_to_le64(tx_ring->phys_addr);
 329         prq_cds->ring_size = cpu_to_le32(tx_ring->num_desc);
 330
 331         phys_addr = rq_phys_addr;
 332         err = qlcnic_issue_cmd(adapter,
 333                         adapter->ahw.pci_func,
 334                         adapter->fw_hal_version,
 335                         (u32)(phys_addr >> 32),
 336                         ((u32)phys_addr & 0xffffffff),
 337                         rq_size,
 338                         QLCNIC_CDRP_CMD_CREATE_TX_CTX);
 339
 340         if (err == QLCNIC_RCODE_SUCCESS) {
 341                 temp = le32_to_cpu(prsp->cds_ring.host_producer_crb);
 342                 tx_ring->crb_cmd_producer = adapter->ahw.pci_base0 + temp;
 343
 344                 adapter->tx_context_id =
 345                         le16_to_cpu(prsp->context_id);
 346         } else {
 347                 dev_err(&adapter->pdev->dev,
 348                         "Failed to create tx ctx in firmware%d\n", err);
 349                 err = -EIO;
 350         }
 351
 352         pci_free_consistent(adapter->pdev, rsp_size, rsp_addr, rsp_phys_addr);
 353
 354 out_free_rq:
 355         pci_free_consistent(adapter->pdev, rq_size, rq_addr, rq_phys_addr);
 356
 357         return err;
 358 }
 359
 360 static void
 361 qlcnic_fw_cmd_destroy_tx_ctx(struct qlcnic_adapter *adapter)
 362 {
 363         if (qlcnic_issue_cmd(adapter,
 364                         adapter->ahw.pci_func,
 365                         adapter->fw_hal_version,
 366                         adapter->tx_context_id,
 367                         QLCNIC_DESTROY_CTX_RESET,
 368                         0,
 369                         QLCNIC_CDRP_CMD_DESTROY_TX_CTX)) {
 370
 371                 dev_err(&adapter->pdev->dev,
 372                         "Failed to destroy tx ctx in firmware\n");
 373         }
 374 }
 375
 376 int
 377 qlcnic_fw_cmd_query_phy(struct qlcnic_adapter *adapter, u32 reg, u32 *val)
 378 {
 379
 380         if (qlcnic_issue_cmd(adapter,
 381                         adapter->ahw.pci_func,
 382                         adapter->fw_hal_version,
 383                         reg,
 384                         0,
 385                         0,
 386                         QLCNIC_CDRP_CMD_READ_PHY)) {
 387
 388                 return -EIO;
 389         }
 390
 391         return QLCRD32(adapter, QLCNIC_ARG1_CRB_OFFSET);
 392 }
 393
 394 int
 395 qlcnic_fw_cmd_set_phy(struct qlcnic_adapter *adapter, u32 reg, u32 val)
 396 {
 397         return qlcnic_issue_cmd(adapter,
 398                         adapter->ahw.pci_func,
 399                         adapter->fw_hal_version,
 400                         reg,
 401                         val,
 402                         0,
 403                         QLCNIC_CDRP_CMD_WRITE_PHY);
 404 }
 405
 406 int qlcnic_alloc_hw_resources(struct qlcnic_adapter *adapter)
 407 {
 408         void *addr;
 409         int err;
 410         int ring;
 411         struct qlcnic_recv_context *recv_ctx;
 412         struct qlcnic_host_rds_ring *rds_ring;
 413         struct qlcnic_host_sds_ring *sds_ring;
 414         struct qlcnic_host_tx_ring *tx_ring;
 415
 416         struct pci_dev *pdev = adapter->pdev;
 417
 418         recv_ctx = &adapter->recv_ctx;
 419         tx_ring = adapter->tx_ring;
 420
 421         tx_ring->hw_consumer = (__le32 *)pci_alloc_consistent(pdev, sizeof(u32),
 422                                                 &tx_ring->hw_cons_phys_addr);
 423         if (tx_ring->hw_consumer == NULL) {
 424                 dev_err(&pdev->dev, "failed to allocate tx consumer\n");
 425                 return -ENOMEM;
 426         }
 427         *(tx_ring->hw_consumer) = 0;
 428
 429         /* cmd desc ring */
 430         addr = pci_alloc_consistent(pdev, TX_DESC_RINGSIZE(tx_ring),
 431                         &tx_ring->phys_addr);
 432
 433         if (addr == NULL) {
 434                 dev_err(&pdev->dev, "failed to allocate tx desc ring\n");
 435                 err = -ENOMEM;
 436                 goto err_out_free;
 437         }
 438
 439         tx_ring->desc_head = (struct cmd_desc_type0 *)addr;
 440
 441         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
 442                 rds_ring = &recv_ctx->rds_rings[ring];
 443                 addr = pci_alloc_consistent(adapter->pdev,
 444                                 RCV_DESC_RINGSIZE(rds_ring),
 445                                 &rds_ring->phys_addr);
 446                 if (addr == NULL) {
 447                         dev_err(&pdev->dev,
 448                                 "failed to allocate rds ring [%d]\n", ring);
 449                         err = -ENOMEM;
 450                         goto err_out_free;
 451                 }
 452                 rds_ring->desc_head = (struct rcv_desc *)addr;
 453
 454         }
 455
 456         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 457                 sds_ring = &recv_ctx->sds_rings[ring];
 458
 459                 addr = pci_alloc_consistent(adapter->pdev,
 460                                 STATUS_DESC_RINGSIZE(sds_ring),
 461                                 &sds_ring->phys_addr);
 462                 if (addr == NULL) {
 463                         dev_err(&pdev->dev,
 464                                 "failed to allocate sds ring [%d]\n", ring);
 465                         err = -ENOMEM;
 466                         goto err_out_free;
 467                 }
 468                 sds_ring->desc_head = (struct status_desc *)addr;
 469         }
 470
 471         return 0;
 472
 473 err_out_free:
 474         qlcnic_free_hw_resources(adapter);
 475         return err;
 476 }
 477
 478
 479 int qlcnic_fw_create_ctx(struct qlcnic_adapter *adapter)
 480 {
 481         int err;
 482
 483         if (adapter->flags & QLCNIC_NEED_FLR) {
 484                 pci_reset_function(adapter->pdev);
 485                 adapter->flags &= ~QLCNIC_NEED_FLR;
 486         }
 487
 488         err = qlcnic_fw_cmd_create_rx_ctx(adapter);
 489         if (err)
 490                 return err;
 491
 492         err = qlcnic_fw_cmd_create_tx_ctx(adapter);
 493         if (err) {
 494                 qlcnic_fw_cmd_destroy_rx_ctx(adapter);
 495                 return err;
 496         }
 497
 498         set_bit(__QLCNIC_FW_ATTACHED, &adapter->state);
 499         return 0;
 500 }
 501
 502 void qlcnic_fw_destroy_ctx(struct qlcnic_adapter *adapter)
 503 {
 504         if (test_and_clear_bit(__QLCNIC_FW_ATTACHED, &adapter->state)) {
 505                 qlcnic_fw_cmd_destroy_rx_ctx(adapter);
 506                 qlcnic_fw_cmd_destroy_tx_ctx(adapter);
 507
 508                 /* Allow dma queues to drain after context reset */
 509                 msleep(20);
 510         }
 511 }
 512
 513 void qlcnic_free_hw_resources(struct qlcnic_adapter *adapter)
 514 {
 515         struct qlcnic_recv_context *recv_ctx;
 516         struct qlcnic_host_rds_ring *rds_ring;
 517         struct qlcnic_host_sds_ring *sds_ring;
 518         struct qlcnic_host_tx_ring *tx_ring;
 519         int ring;
 520
 521         recv_ctx = &adapter->recv_ctx;
 522
 523         tx_ring = adapter->tx_ring;
 524         if (tx_ring->hw_consumer != NULL) {
 525                 pci_free_consistent(adapter->pdev,
 526                                 sizeof(u32),
 527                                 tx_ring->hw_consumer,
 528                                 tx_ring->hw_cons_phys_addr);
 529                 tx_ring->hw_consumer = NULL;
 530         }
 531
 532         if (tx_ring->desc_head != NULL) {
 533                 pci_free_consistent(adapter->pdev,
 534                                 TX_DESC_RINGSIZE(tx_ring),
 535                                 tx_ring->desc_head, tx_ring->phys_addr);
 536                 tx_ring->desc_head = NULL;
 537         }
 538
 539         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
 540                 rds_ring = &recv_ctx->rds_rings[ring];
 541
 542                 if (rds_ring->desc_head != NULL) {
 543                         pci_free_consistent(adapter->pdev,
 544                                         RCV_DESC_RINGSIZE(rds_ring),
 545                                         rds_ring->desc_head,
 546                                         rds_ring->phys_addr);
 547                         rds_ring->desc_head = NULL;
 548                 }
 549         }
 550
 551         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 552                 sds_ring = &recv_ctx->sds_rings[ring];
 553
 554                 if (sds_ring->desc_head != NULL) {
 555                         pci_free_consistent(adapter->pdev,
 556                                 STATUS_DESC_RINGSIZE(sds_ring),
 557                                 sds_ring->desc_head,
 558                                 sds_ring->phys_addr);
 559                         sds_ring->desc_head = NULL;
 560                 }
 561         }
 562 }
 563
 564
 565 /* Get MAC address of a NIC partition */
 566 int qlcnic_get_mac_address(struct qlcnic_adapter *adapter, u8 *mac)
 567 {
 568         int err;
 569         u32 arg1;
 570
 571         arg1 = adapter->ahw.pci_func | BIT_8;
 572         err = qlcnic_issue_cmd(adapter,
 573                         adapter->ahw.pci_func,
 574                         adapter->fw_hal_version,
 575                         arg1,
 576                         0,
 577                         0,
 578                         QLCNIC_CDRP_CMD_MAC_ADDRESS);
 579
 580         if (err == QLCNIC_RCODE_SUCCESS)
 581                 qlcnic_fetch_mac(adapter, QLCNIC_ARG1_CRB_OFFSET,
 582                                 QLCNIC_ARG2_CRB_OFFSET, 0, mac);
 583         else {
 584                 dev_err(&adapter->pdev->dev,
 585                         "Failed to get mac address%d\n", err);
 586                 err = -EIO;
 587         }
 588
 589         return err;
 590 }
 591
 592 /* Get info of a NIC partition */
 593 int qlcnic_get_nic_info(struct qlcnic_adapter *adapter,
 594                                 struct qlcnic_info *npar_info, u8 func_id)
 595 {
 596         int     err;
 597         dma_addr_t nic_dma_t;
 598         struct qlcnic_info *nic_info;
 599         void *nic_info_addr;
 600         size_t  nic_size = sizeof(struct qlcnic_info);
 601
 602         nic_info_addr = pci_alloc_consistent(adapter->pdev,
 603                 nic_size, &nic_dma_t);
 604         if (!nic_info_addr)
 605                 return -ENOMEM;
 606         memset(nic_info_addr, 0, nic_size);
 607
 608         nic_info = (struct qlcnic_info *) nic_info_addr;
 609         err = qlcnic_issue_cmd(adapter,
 610                         adapter->ahw.pci_func,
 611                         adapter->fw_hal_version,
 612                         MSD(nic_dma_t),
 613                         LSD(nic_dma_t),
 614                         (func_id << 16 | nic_size),
 615                         QLCNIC_CDRP_CMD_GET_NIC_INFO);
 616
 617         if (err == QLCNIC_RCODE_SUCCESS) {
 618                 npar_info->pci_func = le16_to_cpu(nic_info->pci_func);
 619                 npar_info->op_mode = le16_to_cpu(nic_info->op_mode);
 620                 npar_info->phys_port = le16_to_cpu(nic_info->phys_port);
 621                 npar_info->switch_mode = le16_to_cpu(nic_info->switch_mode);
 622                 npar_info->max_tx_ques = le16_to_cpu(nic_info->max_tx_ques);
 623                 npar_info->max_rx_ques = le16_to_cpu(nic_info->max_rx_ques);
 624                 npar_info->min_tx_bw = le16_to_cpu(nic_info->min_tx_bw);
 625                 npar_info->max_tx_bw = le16_to_cpu(nic_info->max_tx_bw);
 626                 npar_info->capabilities = le32_to_cpu(nic_info->capabilities);
 627                 npar_info->max_mtu = le16_to_cpu(nic_info->max_mtu);
 628
 629                 dev_info(&adapter->pdev->dev,
 630                         "phy port: %d switch_mode: %d,\n"
 631                         "\tmax_tx_q: %d max_rx_q: %d min_tx_bw: 0x%x,\n"
 632                         "\tmax_tx_bw: 0x%x max_mtu:0x%x, capabilities: 0x%x\n",
 633                         npar_info->phys_port, npar_info->switch_mode,
 634                         npar_info->max_tx_ques, npar_info->max_rx_ques,
 635                         npar_info->min_tx_bw, npar_info->max_tx_bw,
 636                         npar_info->max_mtu, npar_info->capabilities);
 637         } else {
 638                 dev_err(&adapter->pdev->dev,
 639                         "Failed to get nic info%d\n", err);
 640                 err = -EIO;
 641         }
 642
 643         pci_free_consistent(adapter->pdev, nic_size, nic_info_addr, nic_dma_t);
 644         return err;
 645 }
 646
 647 /* Configure a NIC partition */
 648 int qlcnic_set_nic_info(struct qlcnic_adapter *adapter, struct qlcnic_info *nic)
 649 {
 650         int err = -EIO;
 651         dma_addr_t nic_dma_t;
 652         void *nic_info_addr;
 653         struct qlcnic_info *nic_info;
 654         size_t nic_size = sizeof(struct qlcnic_info);
 655
 656         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
 657                 return err;
 658
 659         nic_info_addr = pci_alloc_consistent(adapter->pdev, nic_size,
 660                         &nic_dma_t);
 661         if (!nic_info_addr)
 662                 return -ENOMEM;
 663
 664         memset(nic_info_addr, 0, nic_size);
 665         nic_info = (struct qlcnic_info *)nic_info_addr;
 666
 667         nic_info->pci_func = cpu_to_le16(nic->pci_func);
 668         nic_info->op_mode = cpu_to_le16(nic->op_mode);
 669         nic_info->phys_port = cpu_to_le16(nic->phys_port);
 670         nic_info->switch_mode = cpu_to_le16(nic->switch_mode);
 671         nic_info->capabilities = cpu_to_le32(nic->capabilities);
 672         nic_info->max_mac_filters = nic->max_mac_filters;
 673         nic_info->max_tx_ques = cpu_to_le16(nic->max_tx_ques);
 674         nic_info->max_rx_ques = cpu_to_le16(nic->max_rx_ques);
 675         nic_info->min_tx_bw = cpu_to_le16(nic->min_tx_bw);
 676         nic_info->max_tx_bw = cpu_to_le16(nic->max_tx_bw);
 677
 678         err = qlcnic_issue_cmd(adapter,
 679                         adapter->ahw.pci_func,
 680                         adapter->fw_hal_version,
 681                         MSD(nic_dma_t),
 682                         LSD(nic_dma_t),
 683                         ((nic->pci_func << 16) | nic_size),
 684                         QLCNIC_CDRP_CMD_SET_NIC_INFO);
 685
 686         if (err != QLCNIC_RCODE_SUCCESS) {
 687                 dev_err(&adapter->pdev->dev,
 688                         "Failed to set nic info%d\n", err);
 689                 err = -EIO;
 690         }
 691
 692         pci_free_consistent(adapter->pdev, nic_size, nic_info_addr, nic_dma_t);
 693         return err;
 694 }
 695
 696 /* Get PCI Info of a partition */
 697 int qlcnic_get_pci_info(struct qlcnic_adapter *adapter,
 698                                 struct qlcnic_pci_info *pci_info)
 699 {
 700         int err = 0, i;
 701         dma_addr_t pci_info_dma_t;
 702         struct qlcnic_pci_info *npar;
 703         void *pci_info_addr;
 704         size_t npar_size = sizeof(struct qlcnic_pci_info);
 705         size_t pci_size = npar_size * QLCNIC_MAX_PCI_FUNC;
 706
 707         pci_info_addr = pci_alloc_consistent(adapter->pdev, pci_size,
 708                         &pci_info_dma_t);
 709         if (!pci_info_addr)
 710                 return -ENOMEM;
 711         memset(pci_info_addr, 0, pci_size);
 712
 713         npar = (struct qlcnic_pci_info *) pci_info_addr;
 714         err = qlcnic_issue_cmd(adapter,
 715                         adapter->ahw.pci_func,
 716                         adapter->fw_hal_version,
 717                         MSD(pci_info_dma_t),
 718                         LSD(pci_info_dma_t),
 719                         pci_size,
 720                         QLCNIC_CDRP_CMD_GET_PCI_INFO);
 721
 722         if (err == QLCNIC_RCODE_SUCCESS) {
 723                 for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++, npar++, pci_info++) {
 724                         pci_info->id = le16_to_cpu(npar->id);
 725                         pci_info->active = le16_to_cpu(npar->active);
 726                         pci_info->type = le16_to_cpu(npar->type);
 727                         pci_info->default_port =
 728                                 le16_to_cpu(npar->default_port);
 729                         pci_info->tx_min_bw =
 730                                 le16_to_cpu(npar->tx_min_bw);
 731                         pci_info->tx_max_bw =
 732                                 le16_to_cpu(npar->tx_max_bw);
 733                         memcpy(pci_info->mac, npar->mac, ETH_ALEN);
 734                 }
 735         } else {
 736                 dev_err(&adapter->pdev->dev,
 737                         "Failed to get PCI Info%d\n", err);
 738                 err = -EIO;
 739         }
 740
 741         pci_free_consistent(adapter->pdev, pci_size, pci_info_addr,
 742                 pci_info_dma_t);
 743         return err;
 744 }
 745
 746 /* Configure eSwitch for port mirroring */
 747 int qlcnic_config_port_mirroring(struct qlcnic_adapter *adapter, u8 id,
 748                                 u8 enable_mirroring, u8 pci_func)
 749 {
 750         int err = -EIO;
 751         u32 arg1;
 752
 753         if (adapter->op_mode != QLCNIC_MGMT_FUNC ||
 754                 !(adapter->eswitch[id].flags & QLCNIC_SWITCH_ENABLE))
 755                 return err;
 756
 757         arg1 = id | (enable_mirroring ? BIT_4 : 0);
 758         arg1 |= pci_func << 8;
 759
 760         err = qlcnic_issue_cmd(adapter,
 761                         adapter->ahw.pci_func,
 762                         adapter->fw_hal_version,
 763                         arg1,
 764                         0,
 765                         0,
 766                         QLCNIC_CDRP_CMD_SET_PORTMIRRORING);
 767
 768         if (err != QLCNIC_RCODE_SUCCESS) {
 769                 dev_err(&adapter->pdev->dev,
 770                         "Failed to configure port mirroring%d on eswitch:%d\n",
 771                         pci_func, id);
 772         } else {
 773                 dev_info(&adapter->pdev->dev,
 774                         "Configured eSwitch %d for port mirroring:%d\n",
 775                         id, pci_func);
 776         }
 777
 778         return err;
 779 }
 780
 781 int qlcnic_get_port_stats(struct qlcnic_adapter *adapter, const u8 func,
 782                 const u8 rx_tx, struct __qlcnic_esw_statistics *esw_stats) {
 783
 784         size_t stats_size = sizeof(struct __qlcnic_esw_statistics);
 785         struct __qlcnic_esw_statistics *stats;
 786         dma_addr_t stats_dma_t;
 787         void *stats_addr;
 788         u32 arg1;
 789         int err;
 790
 791         if (esw_stats == NULL)
 792                 return -ENOMEM;
 793
 794         if (adapter->op_mode != QLCNIC_MGMT_FUNC &&
 795             func != adapter->ahw.pci_func) {
 796                 dev_err(&adapter->pdev->dev,
 797                         "Not privilege to query stats for func=%d", func);
 798                 return -EIO;
 799         }
 800
 801         stats_addr = pci_alloc_consistent(adapter->pdev, stats_size,
 802                         &stats_dma_t);
 803         if (!stats_addr) {
 804                 dev_err(&adapter->pdev->dev, "Unable to allocate memory\n");
 805                 return -ENOMEM;
 806         }
 807         memset(stats_addr, 0, stats_size);
 808
 809         arg1 = func | QLCNIC_STATS_VERSION << 8 | QLCNIC_STATS_PORT << 12;
 810         arg1 |= rx_tx << 15 | stats_size << 16;
 811
 812         err = qlcnic_issue_cmd(adapter,
 813                         adapter->ahw.pci_func,
 814                         adapter->fw_hal_version,
 815                         arg1,
 816                         MSD(stats_dma_t),
 817                         LSD(stats_dma_t),
 818                         QLCNIC_CDRP_CMD_GET_ESWITCH_STATS);
 819
 820         if (!err) {
 821                 stats = (struct __qlcnic_esw_statistics *)stats_addr;
 822                 esw_stats->context_id = le16_to_cpu(stats->context_id);
 823                 esw_stats->version = le16_to_cpu(stats->version);
 824                 esw_stats->size = le16_to_cpu(stats->size);
 825                 esw_stats->multicast_frames =
 826                                 le64_to_cpu(stats->multicast_frames);
 827                 esw_stats->broadcast_frames =
 828                                 le64_to_cpu(stats->broadcast_frames);
 829                 esw_stats->unicast_frames = le64_to_cpu(stats->unicast_frames);
 830                 esw_stats->dropped_frames = le64_to_cpu(stats->dropped_frames);
 831                 esw_stats->local_frames = le64_to_cpu(stats->local_frames);
 832                 esw_stats->errors = le64_to_cpu(stats->errors);
 833                 esw_stats->numbytes = le64_to_cpu(stats->numbytes);
 834         }
 835
 836         pci_free_consistent(adapter->pdev, stats_size, stats_addr,
 837                 stats_dma_t);
 838         return err;
 839 }
 840
 841 int qlcnic_get_eswitch_stats(struct qlcnic_adapter *adapter, const u8 eswitch,
 842                 const u8 rx_tx, struct __qlcnic_esw_statistics *esw_stats) {
 843
 844         struct __qlcnic_esw_statistics port_stats;
 845         u8 i;
 846         int ret = -EIO;
 847
 848         if (esw_stats == NULL)
 849                 return -ENOMEM;
 850         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
 851                 return -EIO;
 852         if (adapter->npars == NULL)
 853                 return -EIO;
 854
 855         memset(esw_stats, 0, sizeof(u64));
 856         esw_stats->unicast_frames = QLCNIC_ESW_STATS_NOT_AVAIL;
 857         esw_stats->multicast_frames = QLCNIC_ESW_STATS_NOT_AVAIL;
 858         esw_stats->broadcast_frames = QLCNIC_ESW_STATS_NOT_AVAIL;
 859         esw_stats->dropped_frames = QLCNIC_ESW_STATS_NOT_AVAIL;
 860         esw_stats->errors = QLCNIC_ESW_STATS_NOT_AVAIL;
 861         esw_stats->local_frames = QLCNIC_ESW_STATS_NOT_AVAIL;
 862         esw_stats->numbytes = QLCNIC_ESW_STATS_NOT_AVAIL;
 863         esw_stats->context_id = eswitch;
 864
 865         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
 866                 if (adapter->npars[i].phy_port != eswitch)
 867                         continue;
 868
 869                 memset(&port_stats, 0, sizeof(struct __qlcnic_esw_statistics));
 870                 if (qlcnic_get_port_stats(adapter, i, rx_tx, &port_stats))
 871                         continue;
 872
 873                 esw_stats->size = port_stats.size;
 874                 esw_stats->version = port_stats.version;
 875                 QLCNIC_ADD_ESW_STATS(esw_stats->unicast_frames,
 876                                                 port_stats.unicast_frames);
 877                 QLCNIC_ADD_ESW_STATS(esw_stats->multicast_frames,
 878                                                 port_stats.multicast_frames);
 879                 QLCNIC_ADD_ESW_STATS(esw_stats->broadcast_frames,
 880                                                 port_stats.broadcast_frames);
 881                 QLCNIC_ADD_ESW_STATS(esw_stats->dropped_frames,
 882                                                 port_stats.dropped_frames);
 883                 QLCNIC_ADD_ESW_STATS(esw_stats->errors,
 884                                                 port_stats.errors);
 885                 QLCNIC_ADD_ESW_STATS(esw_stats->local_frames,
 886                                                 port_stats.local_frames);
 887                 QLCNIC_ADD_ESW_STATS(esw_stats->numbytes,
 888                                                 port_stats.numbytes);
 889                 ret = 0;
 890         }
 891         return ret;
 892 }
 893
 894 int qlcnic_clear_esw_stats(struct qlcnic_adapter *adapter, const u8 func_esw,
 895                 const u8 port, const u8 rx_tx)
 896 {
 897
 898         u32 arg1;
 899
 900         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
 901                 return -EIO;
 902
 903         if (func_esw == QLCNIC_STATS_PORT) {
 904                 if (port >= QLCNIC_MAX_PCI_FUNC)
 905                         goto err_ret;
 906         } else if (func_esw == QLCNIC_STATS_ESWITCH) {
 907                 if (port >= QLCNIC_NIU_MAX_XG_PORTS)
 908                         goto err_ret;
 909         } else {
 910                 goto err_ret;
 911         }
 912
 913         if (rx_tx > QLCNIC_QUERY_TX_COUNTER)
 914                 goto err_ret;
 915
 916         arg1 = port | QLCNIC_STATS_VERSION << 8 | func_esw << 12;
 917         arg1 |= BIT_14 | rx_tx << 15;
 918
 919         return qlcnic_issue_cmd(adapter,
 920                         adapter->ahw.pci_func,
 921                         adapter->fw_hal_version,
 922                         arg1,
 923                         0,
 924                         0,
 925                         QLCNIC_CDRP_CMD_GET_ESWITCH_STATS);
 926
 927 err_ret:
 928         dev_err(&adapter->pdev->dev, "Invalid argument func_esw=%d port=%d"
 929                 "rx_ctx=%d\n", func_esw, port, rx_tx);
 930         return -EIO;
 931 }
 932
 933 static int
 934 __qlcnic_get_eswitch_port_config(struct qlcnic_adapter *adapter,
 935                                         u32 *arg1, u32 *arg2)
 936 {
 937         int err = -EIO;
 938         u8 pci_func;
 939         pci_func = (*arg1 >> 8);
 940         err = qlcnic_issue_cmd(adapter,
 941                         adapter->ahw.pci_func,
 942                         adapter->fw_hal_version,
 943                         *arg1,
 944                         0,
 945                         0,
 946                         QLCNIC_CDRP_CMD_GET_ESWITCH_PORT_CONFIG);
 947
 948         if (err == QLCNIC_RCODE_SUCCESS) {
 949                 *arg1 = QLCRD32(adapter, QLCNIC_ARG1_CRB_OFFSET);
 950                 *arg2 = QLCRD32(adapter, QLCNIC_ARG2_CRB_OFFSET);
 951                 dev_info(&adapter->pdev->dev,
 952                         "eSwitch port config for pci func %d\n", pci_func);
 953         } else {
 954                 dev_err(&adapter->pdev->dev,
 955                         "Failed to get eswitch port config for pci func %d\n",
 956                                                                 pci_func);
 957         }
 958         return err;
 959 }
 960 /* Configure eSwitch port
 961 op_mode = 0 for setting default port behavior
 962 op_mode = 1 for setting  vlan id
 963 op_mode = 2 for deleting vlan id
 964 op_type = 0 for vlan_id
 965 op_type = 1 for port vlan_id
 966 */
 967 int qlcnic_config_switch_port(struct qlcnic_adapter *adapter,
 968                 struct qlcnic_esw_func_cfg *esw_cfg)
 969 {
 970         int err = -EIO;
 971         u32 arg1, arg2 = 0;
 972         u8 pci_func;
 973
 974         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
 975                 return err;
 976         pci_func = esw_cfg->pci_func;
 977         arg1 = (adapter->npars[pci_func].phy_port & BIT_0);
 978         arg1 |= (pci_func << 8);
 979
 980         if (__qlcnic_get_eswitch_port_config(adapter, &arg1, &arg2))
 981                 return err;
 982         arg1 &= ~(0x0ff << 8);
 983         arg1 |= (pci_func << 8);
 984         arg1 &= ~(BIT_2 | BIT_3);
 985         switch (esw_cfg->op_mode) {
 986         case QLCNIC_PORT_DEFAULTS:
 987                 arg1 |= (BIT_4 | BIT_6 | BIT_7);
 988                 arg2 |= (BIT_0 | BIT_1);
 989                 if (adapter->capabilities & QLCNIC_FW_CAPABILITY_TSO)
 990                         arg2 |= (BIT_2 | BIT_3);
 991                 if (!(esw_cfg->discard_tagged))
 992                         arg1 &= ~BIT_4;
 993                 if (!(esw_cfg->promisc_mode))
 994                         arg1 &= ~BIT_6;
 995                 if (!(esw_cfg->mac_override))
 996                         arg1 &= ~BIT_7;
 997                 if (!(esw_cfg->mac_anti_spoof))
 998                         arg2 &= ~BIT_0;
 999                 if (!(esw_cfg->offload_flags & BIT_0))
1000                         arg2 &= ~(BIT_1 | BIT_2 | BIT_3);
1001                 if (!(esw_cfg->offload_flags & BIT_1))
1002                         arg2 &= ~BIT_2;
1003                 if (!(esw_cfg->offload_flags & BIT_2))
1004                         arg2 &= ~BIT_3;
1005                 break;
1006         case QLCNIC_ADD_VLAN:
1007                         arg1 |= (BIT_2 | BIT_5);
1008                         arg1 |= (esw_cfg->vlan_id << 16);
1009                         break;
1010         case QLCNIC_DEL_VLAN:
1011                         arg1 |= (BIT_3 | BIT_5);
1012                         arg1 &= ~(0x0ffff << 16);
1013                         break;
1014         default:
1015                 return err;
1016         }
1017
1018         err = qlcnic_issue_cmd(adapter,
1019                         adapter->ahw.pci_func,
1020                         adapter->fw_hal_version,
1021                         arg1,
1022                         arg2,
1023                         0,
1024                         QLCNIC_CDRP_CMD_CONFIGURE_ESWITCH);
1025
1026         if (err != QLCNIC_RCODE_SUCCESS) {
1027                 dev_err(&adapter->pdev->dev,
1028                         "Failed to configure eswitch pci func %d\n", pci_func);
1029         } else {
1030                 dev_info(&adapter->pdev->dev,
1031                         "Configured eSwitch for pci func %d\n", pci_func);
1032         }
1033
1034         return err;
1035 }
1036
1037 int
1038 qlcnic_get_eswitch_port_config(struct qlcnic_adapter *adapter,
1039                         struct qlcnic_esw_func_cfg *esw_cfg)
1040 {
1041         u32 arg1, arg2;
1042         u8 phy_port;
1043         if (adapter->op_mode == QLCNIC_MGMT_FUNC)
1044                 phy_port = adapter->npars[esw_cfg->pci_func].phy_port;
1045         else
1046                 phy_port = adapter->physical_port;
1047         arg1 = phy_port;
1048         arg1 |= (esw_cfg->pci_func << 8);
1049         if (__qlcnic_get_eswitch_port_config(adapter, &arg1, &arg2))
1050                 return -EIO;
1051
1052         esw_cfg->discard_tagged = !!(arg1 & BIT_4);
1053         esw_cfg->host_vlan_tag = !!(arg1 & BIT_5);
1054         esw_cfg->promisc_mode = !!(arg1 & BIT_6);
1055         esw_cfg->mac_override = !!(arg1 & BIT_7);
1056         esw_cfg->vlan_id = LSW(arg1 >> 16);
1057         esw_cfg->mac_anti_spoof = (arg2 & 0x1);
1058         esw_cfg->offload_flags = ((arg2 >> 1) & 0x7);
1059
1060         return 0;
1061 }