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->wait_time = 1000;
79 	sc->timeout = jiffies + sc->wait_time;
80 
81 	return sc;
82 }
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 
95 static void octnet_link_ctrl_callback(struct octeon_device *oct,
96 				      u32 status,
97 				      void *sc_ptr)
98 {
99 	struct octeon_soft_command *sc = (struct octeon_soft_command *)sc_ptr;
100 	struct octnic_ctrl_pkt *nctrl;
101 
102 	nctrl = (struct octnic_ctrl_pkt *)sc->ctxptr;
103 
104 	/* Call the callback function if status is zero (meaning OK) or status
105 	 * contains a firmware status code bigger than zero (meaning the
106 	 * firmware is reporting an error).
107 	 * If no response was expected, status is OK if the command was posted
108 	 * successfully.
109 	 */
110 	if ((!status || status > FIRMWARE_STATUS_CODE(0)) && nctrl->cb_fn) {
111 		nctrl->status = status;
112 		nctrl->cb_fn(nctrl);
113 	}
114 
115 	octeon_free_soft_command(oct, sc);
116 }
117 
118 static inline struct octeon_soft_command
119 *octnic_alloc_ctrl_pkt_sc(struct octeon_device *oct,
120 			  struct octnic_ctrl_pkt *nctrl)
121 {
122 	struct octeon_soft_command *sc = NULL;
123 	u8 *data;
124 	u32 rdatasize;
125 	u32 uddsize = 0, datasize = 0;
126 
127 	uddsize = (u32)(nctrl->ncmd.s.more * 8);
128 
129 	datasize = OCTNET_CMD_SIZE + uddsize;
130 	rdatasize = (nctrl->wait_time) ? 16 : 0;
131 
132 	sc = (struct octeon_soft_command *)
133 		octeon_alloc_soft_command(oct, datasize, rdatasize,
134 					  sizeof(struct octnic_ctrl_pkt));
135 
136 	if (!sc)
137 		return NULL;
138 
139 	memcpy(sc->ctxptr, nctrl, sizeof(struct octnic_ctrl_pkt));
140 
141 	data = (u8 *)sc->virtdptr;
142 
143 	memcpy(data, &nctrl->ncmd, OCTNET_CMD_SIZE);
144 
145 	octeon_swap_8B_data((u64 *)data, (OCTNET_CMD_SIZE >> 3));
146 
147 	if (uddsize) {
148 		/* Endian-Swap for UDD should have been done by caller. */
149 		memcpy(data + OCTNET_CMD_SIZE, nctrl->udd, uddsize);
150 	}
151 
152 	sc->iq_no = (u32)nctrl->iq_no;
153 
154 	octeon_prepare_soft_command(oct, sc, OPCODE_NIC, OPCODE_NIC_CMD,
155 				    0, 0, 0);
156 
157 	sc->callback = octnet_link_ctrl_callback;
158 	sc->callback_arg = sc;
159 	sc->wait_time = nctrl->wait_time;
160 
161 	return sc;
162 }
163 
164 int
165 octnet_send_nic_ctrl_pkt(struct octeon_device *oct,
166 			 struct octnic_ctrl_pkt *nctrl)
167 {
168 	int retval;
169 	struct octeon_soft_command *sc = NULL;
170 
171 	spin_lock_bh(&oct->cmd_resp_wqlock);
172 	/* Allow only rx ctrl command to stop traffic on the chip
173 	 * during offline operations
174 	 */
175 	if ((oct->cmd_resp_state == OCT_DRV_OFFLINE) &&
176 	    (nctrl->ncmd.s.cmd != OCTNET_CMD_RX_CTL)) {
177 		spin_unlock_bh(&oct->cmd_resp_wqlock);
178 		dev_err(&oct->pci_dev->dev,
179 			"%s cmd:%d not processed since driver offline\n",
180 			__func__, nctrl->ncmd.s.cmd);
181 		return -1;
182 	}
183 
184 	sc = octnic_alloc_ctrl_pkt_sc(oct, nctrl);
185 	if (!sc) {
186 		dev_err(&oct->pci_dev->dev, "%s soft command alloc failed\n",
187 			__func__);
188 		spin_unlock_bh(&oct->cmd_resp_wqlock);
189 		return -1;
190 	}
191 
192 	retval = octeon_send_soft_command(oct, sc);
193 	if (retval == IQ_SEND_FAILED) {
194 		octeon_free_soft_command(oct, sc);
195 		dev_err(&oct->pci_dev->dev, "%s pf_num:%d soft command:%d send failed status: %x\n",
196 			__func__, oct->pf_num, nctrl->ncmd.s.cmd, retval);
197 		spin_unlock_bh(&oct->cmd_resp_wqlock);
198 		return -1;
199 	}
200 
201 	spin_unlock_bh(&oct->cmd_resp_wqlock);
202 	return retval;
203 }
204