drivers/net/ethernet/cavium/liquidio/octeon_nic.c

   1 /**********************************************************************
   2  * Author: Cavium, Inc.
   3  *
   4  * Contact: support@cavium.com
   5  *          Please include "LiquidIO" in the subject.
   6  *
   7  * Copyright (c) 2003-2016 Cavium, Inc.
   8  *
   9  * This file is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License, Version 2, as
  11  * published by the Free Software Foundation.
  12  *
  13  * This file is distributed in the hope that it will be useful, but
  14  * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
  15  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
  16  * NONINFRINGEMENT.  See the GNU General Public License for more
  17  * details.
  18  **********************************************************************/
  19 #include <linux/pci.h>
  20 #include <linux/netdevice.h>
  21 #include "liquidio_common.h"
  22 #include "octeon_droq.h"
  23 #include "octeon_iq.h"
  24 #include "response_manager.h"
  25 #include "octeon_device.h"
  26 #include "octeon_nic.h"
  27 #include "octeon_main.h"
  28
  29 void *
  30 octeon_alloc_soft_command_resp(struct octeon_device    *oct,
  31                                union octeon_instr_64B *cmd,
  32                                u32                     rdatasize)
  33 {
  34         struct octeon_soft_command *sc;
  35         struct octeon_instr_ih3  *ih3;
  36         struct octeon_instr_ih2  *ih2;
  37         struct octeon_instr_irh *irh;
  38         struct octeon_instr_rdp *rdp;
  39
  40         sc = (struct octeon_soft_command *)
  41                 octeon_alloc_soft_command(oct, 0, rdatasize, 0);
  42
  43         if (!sc)
  44                 return NULL;
  45
  46         /* Copy existing command structure into the soft command */
  47         memcpy(&sc->cmd, cmd, sizeof(union octeon_instr_64B));
  48
  49         /* Add in the response related fields. Opcode and Param are already
  50          * there.
  51          */
  52         if (OCTEON_CN23XX_PF(oct) || OCTEON_CN23XX_VF(oct)) {
  53                 ih3      = (struct octeon_instr_ih3 *)&sc->cmd.cmd3.ih3;
  54                 rdp     = (struct octeon_instr_rdp *)&sc->cmd.cmd3.rdp;
  55                 irh     = (struct octeon_instr_irh *)&sc->cmd.cmd3.irh;
  56                 /*pkiih3 + irh + ossp[0] + ossp[1] + rdp + rptr = 40 bytes */
  57                 ih3->fsz = LIO_SOFTCMDRESP_IH3;
  58         } else {
  59                 ih2      = (struct octeon_instr_ih2 *)&sc->cmd.cmd2.ih2;
  60                 rdp     = (struct octeon_instr_rdp *)&sc->cmd.cmd2.rdp;
  61                 irh     = (struct octeon_instr_irh *)&sc->cmd.cmd2.irh;
  62                 /* irh + ossp[0] + ossp[1] + rdp + rptr = 40 bytes */
  63                 ih2->fsz = LIO_SOFTCMDRESP_IH2;
  64         }
  65
  66         irh->rflag = 1; /* a response is required */
  67
  68         rdp->pcie_port = oct->pcie_port;
  69         rdp->rlen      = rdatasize;
  70
  71         *sc->status_word = COMPLETION_WORD_INIT;
  72
  73         if (OCTEON_CN23XX_PF(oct) || OCTEON_CN23XX_VF(oct))
  74                 sc->cmd.cmd3.rptr =  sc->dmarptr;
  75         else
  76                 sc->cmd.cmd2.rptr =  sc->dmarptr;
  77
  78         sc->expiry_time = jiffies + msecs_to_jiffies(LIO_SC_MAX_TMO_MS);
  79
  80         return sc;
  81 }
  82 EXPORT_SYMBOL_GPL(octeon_alloc_soft_command_resp);
  83
  84 int octnet_send_nic_data_pkt(struct octeon_device *oct,
  85                              struct octnic_data_pkt *ndata,
  86                              int xmit_more)
  87 {
  88         int ring_doorbell = !xmit_more;
  89
  90         return octeon_send_command(oct, ndata->q_no, ring_doorbell, &ndata->cmd,
  91                                    ndata->buf, ndata->datasize,
  92                                    ndata->reqtype);
  93 }
  94 EXPORT_SYMBOL_GPL(octnet_send_nic_data_pkt);
  95
  96 static inline struct octeon_soft_command
  97 *octnic_alloc_ctrl_pkt_sc(struct octeon_device *oct,
  98                           struct octnic_ctrl_pkt *nctrl)
  99 {
 100         struct octeon_soft_command *sc = NULL;
 101         u8 *data;
 102         u32 rdatasize;
 103         u32 uddsize = 0, datasize = 0;
 104
 105         uddsize = (u32)(nctrl->ncmd.s.more * 8);
 106
 107         datasize = OCTNET_CMD_SIZE + uddsize;
 108         rdatasize = 16;
 109
 110         sc = (struct octeon_soft_command *)
 111                 octeon_alloc_soft_command(oct, datasize, rdatasize, 0);
 112
 113         if (!sc)
 114                 return NULL;
 115
 116         data = (u8 *)sc->virtdptr;
 117
 118         memcpy(data, &nctrl->ncmd, OCTNET_CMD_SIZE);
 119
 120         octeon_swap_8B_data((u64 *)data, (OCTNET_CMD_SIZE >> 3));
 121
 122         if (uddsize) {
 123                 /* Endian-Swap for UDD should have been done by caller. */
 124                 memcpy(data + OCTNET_CMD_SIZE, nctrl->udd, uddsize);
 125         }
 126
 127         sc->iq_no = (u32)nctrl->iq_no;
 128
 129         octeon_prepare_soft_command(oct, sc, OPCODE_NIC, OPCODE_NIC_CMD,
 130                                     0, 0, 0);
 131
 132         init_completion(&sc->complete);
 133         sc->sc_status = OCTEON_REQUEST_PENDING;
 134
 135         return sc;
 136 }
 137
 138 int
 139 octnet_send_nic_ctrl_pkt(struct octeon_device *oct,
 140                          struct octnic_ctrl_pkt *nctrl)
 141 {
 142         int retval;
 143         struct octeon_soft_command *sc = NULL;
 144
 145         spin_lock_bh(&oct->cmd_resp_wqlock);
 146         /* Allow only rx ctrl command to stop traffic on the chip
 147          * during offline operations
 148          */
 149         if ((oct->cmd_resp_state == OCT_DRV_OFFLINE) &&
 150             (nctrl->ncmd.s.cmd != OCTNET_CMD_RX_CTL)) {
 151                 spin_unlock_bh(&oct->cmd_resp_wqlock);
 152                 dev_err(&oct->pci_dev->dev,
 153                         "%s cmd:%d not processed since driver offline\n",
 154                         __func__, nctrl->ncmd.s.cmd);
 155                 return -1;
 156         }
 157
 158         sc = octnic_alloc_ctrl_pkt_sc(oct, nctrl);
 159         if (!sc) {
 160                 dev_err(&oct->pci_dev->dev, "%s soft command alloc failed\n",
 161                         __func__);
 162                 spin_unlock_bh(&oct->cmd_resp_wqlock);
 163                 return -1;
 164         }
 165
 166         retval = octeon_send_soft_command(oct, sc);
 167         if (retval == IQ_SEND_FAILED) {
 168                 octeon_free_soft_command(oct, sc);
 169                 dev_err(&oct->pci_dev->dev, "%s pf_num:%d soft command:%d send failed status: %x\n",
 170                         __func__, oct->pf_num, nctrl->ncmd.s.cmd, retval);
 171                 spin_unlock_bh(&oct->cmd_resp_wqlock);
 172                 return -1;
 173         }
 174
 175         spin_unlock_bh(&oct->cmd_resp_wqlock);
 176
 177         if (nctrl->ncmd.s.cmdgroup == 0) {
 178                 switch (nctrl->ncmd.s.cmd) {
 179                         /* caller holds lock, can not sleep */
 180                 case OCTNET_CMD_CHANGE_DEVFLAGS:
 181                 case OCTNET_CMD_SET_MULTI_LIST:
 182                 case OCTNET_CMD_SET_UC_LIST:
 183                         WRITE_ONCE(sc->caller_is_done, true);
 184                         return retval;
 185                 }
 186         }
 187
 188         retval = wait_for_sc_completion_timeout(oct, sc, 0);
 189         if (retval)
 190                 return (retval);
 191
 192         nctrl->sc_status = sc->sc_status;
 193         retval = nctrl->sc_status;
 194         if (nctrl->cb_fn)
 195                 nctrl->cb_fn(nctrl);
 196
 197         WRITE_ONCE(sc->caller_is_done, true);
 198
 199         return retval;
 200 }
 201 EXPORT_SYMBOL_GPL(octnet_send_nic_ctrl_pkt);