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); 202