kernel/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-2015 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  * This file may also be available under a different license from Cavium.
  20  * Contact Cavium, Inc. for more information
  21  **********************************************************************/
  22 #include <linux/version.h>
  23 #include <linux/types.h>
  24 #include <linux/list.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/pci.h>
  27 #include <linux/kthread.h>
  28 #include <linux/netdevice.h>
  29 #include "octeon_config.h"
  30 #include "liquidio_common.h"
  31 #include "octeon_droq.h"
  32 #include "octeon_iq.h"
  33 #include "response_manager.h"
  34 #include "octeon_device.h"
  35 #include "octeon_nic.h"
  36 #include "octeon_main.h"
  37 #include "octeon_network.h"
  38 #include "cn66xx_regs.h"
  39 #include "cn66xx_device.h"
  40 #include "cn68xx_regs.h"
  41 #include "cn68xx_device.h"
  42 #include "liquidio_image.h"
  43 #include "octeon_mem_ops.h"
  44
  45 void *
  46 octeon_alloc_soft_command_resp(struct octeon_device    *oct,
  47                                struct octeon_instr_64B *cmd,
  48                                size_t                  rdatasize)
  49 {
  50         struct octeon_soft_command *sc;
  51         struct octeon_instr_ih  *ih;
  52         struct octeon_instr_irh *irh;
  53         struct octeon_instr_rdp *rdp;
  54
  55         sc = (struct octeon_soft_command *)
  56                 octeon_alloc_soft_command(oct, 0, rdatasize, 0);
  57
  58         if (!sc)
  59                 return NULL;
  60
  61         /* Copy existing command structure into the soft command */
  62         memcpy(&sc->cmd, cmd, sizeof(struct octeon_instr_64B));
  63
  64         /* Add in the response related fields. Opcode and Param are already
  65          * there.
  66          */
  67         ih      = (struct octeon_instr_ih *)&sc->cmd.ih;
  68         ih->fsz = 40; /* irh + ossp[0] + ossp[1] + rdp + rptr = 40 bytes */
  69
  70         irh        = (struct octeon_instr_irh *)&sc->cmd.irh;
  71         irh->rflag = 1; /* a response is required */
  72         irh->len   = 4; /* means four 64-bit words immediately follow irh */
  73
  74         rdp            = (struct octeon_instr_rdp *)&sc->cmd.rdp;
  75         rdp->pcie_port = oct->pcie_port;
  76         rdp->rlen      = rdatasize;
  77
  78         *sc->status_word = COMPLETION_WORD_INIT;
  79
  80         sc->wait_time = 1000;
  81         sc->timeout = jiffies + sc->wait_time;
  82
  83         return sc;
  84 }
  85
  86 int octnet_send_nic_data_pkt(struct octeon_device *oct,
  87                              struct octnic_data_pkt *ndata,
  88                              u32 xmit_more)
  89 {
  90         int ring_doorbell;
  91
  92         ring_doorbell = !xmit_more;
  93
  94         return octeon_send_command(oct, ndata->q_no, ring_doorbell, &ndata->cmd,
  95                                    ndata->buf, ndata->datasize,
  96                                    ndata->reqtype);
  97 }
  98
  99 static void octnet_link_ctrl_callback(struct octeon_device *oct,
 100                                       u32 status,
 101                                       void *sc_ptr)
 102 {
 103         struct octeon_soft_command *sc = (struct octeon_soft_command *)sc_ptr;
 104         struct octnic_ctrl_pkt *nctrl;
 105
 106         nctrl = (struct octnic_ctrl_pkt *)sc->ctxptr;
 107
 108         /* Call the callback function if status is OK.
 109          * Status is OK only if a response was expected and core returned
 110          * success.
 111          * If no response was expected, status is OK if the command was posted
 112          * successfully.
 113          */
 114         if (!status && nctrl->cb_fn)
 115                 nctrl->cb_fn(nctrl);
 116
 117         octeon_free_soft_command(oct, sc);
 118 }
 119
 120 static inline struct octeon_soft_command
 121 *octnic_alloc_ctrl_pkt_sc(struct octeon_device *oct,
 122                           struct octnic_ctrl_pkt *nctrl,
 123                           struct octnic_ctrl_params nparams)
 124 {
 125         struct octeon_soft_command *sc = NULL;
 126         u8 *data;
 127         size_t rdatasize;
 128         u32 uddsize = 0, datasize = 0;
 129
 130         uddsize = (u32)(nctrl->ncmd.s.more * 8);
 131
 132         datasize = OCTNET_CMD_SIZE + uddsize;
 133         rdatasize = (nctrl->wait_time) ? 16 : 0;
 134
 135         sc = (struct octeon_soft_command *)
 136                 octeon_alloc_soft_command(oct, datasize, rdatasize,
 137                                           sizeof(struct octnic_ctrl_pkt));
 138
 139         if (!sc)
 140                 return NULL;
 141
 142         memcpy(sc->ctxptr, nctrl, sizeof(struct octnic_ctrl_pkt));
 143
 144         data = (u8 *)sc->virtdptr;
 145
 146         memcpy(data, &nctrl->ncmd,  OCTNET_CMD_SIZE);
 147
 148         octeon_swap_8B_data((u64 *)data, (OCTNET_CMD_SIZE >> 3));
 149
 150         if (uddsize) {
 151                 /* Endian-Swap for UDD should have been done by caller. */
 152                 memcpy(data + OCTNET_CMD_SIZE, nctrl->udd, uddsize);
 153         }
 154
 155         octeon_prepare_soft_command(oct, sc, OPCODE_NIC, OPCODE_NIC_CMD,
 156                                     0, 0, 0);
 157
 158         sc->callback = octnet_link_ctrl_callback;
 159         sc->callback_arg = sc;
 160         sc->wait_time = nctrl->wait_time;
 161
 162         return sc;
 163 }
 164
 165 int
 166 octnet_send_nic_ctrl_pkt(struct octeon_device *oct,
 167                          struct octnic_ctrl_pkt *nctrl,
 168                          struct octnic_ctrl_params nparams)
 169 {
 170         int retval;
 171         struct octeon_soft_command *sc = NULL;
 172
 173         sc = octnic_alloc_ctrl_pkt_sc(oct, nctrl, nparams);
 174         if (!sc) {
 175                 dev_err(&oct->pci_dev->dev, "%s soft command alloc failed\n",
 176                         __func__);
 177                 return -1;
 178         }
 179
 180         retval = octeon_send_soft_command(oct, sc);
 181         if (retval) {
 182                 octeon_free_soft_command(oct, sc);
 183                 dev_err(&oct->pci_dev->dev, "%s soft command send failed status: %x\n",
 184                         __func__, retval);
 185                 return -1;
 186         }
 187
 188         return retval;
 189 }