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