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
29void *
30octeon_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, datasize: 0, rdatasize, ctxsize: 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}
82EXPORT_SYMBOL_GPL(octeon_alloc_soft_command_resp);
83
84int 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, iq_no: ndata->q_no, force_db: ring_doorbell, cmd: &ndata->cmd,
91 buf: ndata->buf, datasize: ndata->datasize,
92 reqtype: ndata->reqtype);
93}
94EXPORT_SYMBOL_GPL(octnet_send_nic_data_pkt);
95
96static 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, ctxsize: 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(data: (u64 *)data, blocks: (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 irh_ossp: 0, ossp0: 0, ossp1: 0);
131
132 init_completion(x: &sc->complete);
133 sc->sc_status = OCTEON_REQUEST_PENDING;
134
135 return sc;
136}
137
138int
139octnet_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(lock: &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(lock: &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(lock: &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(lock: &oct->cmd_resp_wqlock);
172 return -1;
173 }
174
175 spin_unlock_bh(lock: &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_dev: oct, sc, timeout: 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}
201EXPORT_SYMBOL_GPL(octnet_send_nic_ctrl_pkt);
202

source code of linux/drivers/net/ethernet/cavium/liquidio/octeon_nic.c