1 /* 2 * BSD LICENSE 3 * 4 * Copyright(c) 2017 Cavium, Inc.. All rights reserved. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Cavium, Inc. nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 /*$FreeBSD$*/ 34 35 #include "lio_bsd.h" 36 #include "lio_common.h" 37 #include "lio_droq.h" 38 #include "lio_iq.h" 39 #include "lio_response_manager.h" 40 #include "lio_device.h" 41 #include "lio_ctrl.h" 42 #include "lio_main.h" 43 44 int 45 lio_send_data_pkt(struct octeon_device *oct, struct lio_data_pkt *ndata) 46 { 47 int ring_doorbell = 1; 48 49 return (lio_send_command(oct, ndata->q_no, ring_doorbell, &ndata->cmd, 50 ndata->buf, ndata->datasize, ndata->reqtype)); 51 } 52 53 static void 54 lio_ctrl_callback(struct octeon_device *oct, uint32_t status, void *sc_ptr) 55 { 56 struct lio_soft_command *sc = (struct lio_soft_command *)sc_ptr; 57 struct lio_ctrl_pkt *nctrl; 58 59 nctrl = (struct lio_ctrl_pkt *)sc->ctxptr; 60 61 /* 62 * Call the callback function if status is OK. 63 * Status is OK only if a response was expected and core returned 64 * success. 65 * If no response was expected, status is OK if the command was posted 66 * successfully. 67 */ 68 if (!status && nctrl->cb_fn) 69 nctrl->cb_fn(nctrl); 70 71 lio_free_soft_command(oct, sc); 72 } 73 74 static inline struct lio_soft_command * 75 lio_alloc_ctrl_pkt_sc(struct octeon_device *oct, struct lio_ctrl_pkt *nctrl) 76 { 77 struct lio_soft_command *sc = NULL; 78 uint32_t datasize = 0, rdatasize, uddsize = 0; 79 uint8_t *data; 80 81 uddsize = (uint32_t)(nctrl->ncmd.s.more * 8); 82 83 datasize = OCTEON_CMD_SIZE + uddsize; 84 rdatasize = (nctrl->wait_time) ? 16 : 0; 85 86 sc = lio_alloc_soft_command(oct, datasize, rdatasize, 87 sizeof(struct lio_ctrl_pkt)); 88 89 if (sc == NULL) 90 return (NULL); 91 92 memcpy(sc->ctxptr, nctrl, sizeof(struct lio_ctrl_pkt)); 93 94 data = (uint8_t *)sc->virtdptr; 95 96 memcpy(data, &nctrl->ncmd, OCTEON_CMD_SIZE); 97 98 lio_swap_8B_data((uint64_t *)data, (OCTEON_CMD_SIZE >> 3)); 99 100 if (uddsize) { 101 /* Endian-Swap for UDD should have been done by caller. */ 102 memcpy(data + OCTEON_CMD_SIZE, nctrl->udd, uddsize); 103 } 104 sc->iq_no = (uint32_t)nctrl->iq_no; 105 106 lio_prepare_soft_command(oct, sc, LIO_OPCODE_NIC, LIO_OPCODE_NIC_CMD, 0, 107 0, 0); 108 109 sc->callback = lio_ctrl_callback; 110 sc->callback_arg = sc; 111 sc->wait_time = nctrl->wait_time; 112 113 return (sc); 114 } 115 116 int 117 lio_send_ctrl_pkt(struct octeon_device *oct, struct lio_ctrl_pkt *nctrl) 118 { 119 struct lio_soft_command *sc = NULL; 120 int retval; 121 122 mtx_lock(&oct->cmd_resp_wqlock); 123 /* 124 * Allow only rx ctrl command to stop traffic on the chip 125 * during offline operations 126 */ 127 if ((oct->cmd_resp_state == LIO_DRV_OFFLINE) && 128 (nctrl->ncmd.s.cmd != LIO_CMD_RX_CTL)) { 129 mtx_unlock(&oct->cmd_resp_wqlock); 130 lio_dev_err(oct, "%s cmd:%d not processed since driver offline\n", 131 __func__, nctrl->ncmd.s.cmd); 132 return (-1); 133 } 134 135 sc = lio_alloc_ctrl_pkt_sc(oct, nctrl); 136 if (sc == NULL) { 137 lio_dev_err(oct, "%s soft command alloc failed\n", __func__); 138 mtx_unlock(&oct->cmd_resp_wqlock); 139 return (-1); 140 } 141 142 retval = lio_send_soft_command(oct, sc); 143 if (retval == LIO_IQ_SEND_FAILED) { 144 lio_free_soft_command(oct, sc); 145 lio_dev_err(oct, "%s pf_num:%d soft command:%d send failed status: %x\n", 146 __func__, oct->pf_num, nctrl->ncmd.s.cmd, retval); 147 mtx_unlock(&oct->cmd_resp_wqlock); 148 return (-1); 149 } 150 151 mtx_unlock(&oct->cmd_resp_wqlock); 152 return (retval); 153 } 154