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 } 190