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, 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 | } |
82 | EXPORT_SYMBOL_GPL(octeon_alloc_soft_command_resp); |
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, iq_no: ndata->q_no, force_db: ring_doorbell, cmd: &ndata->cmd, |
91 | buf: ndata->buf, datasize: ndata->datasize, |
92 | reqtype: ndata->reqtype); |
93 | } |
94 | EXPORT_SYMBOL_GPL(octnet_send_nic_data_pkt); |
95 | |
96 | static 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 | |
138 | int |
139 | octnet_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 | } |
201 | EXPORT_SYMBOL_GPL(octnet_send_nic_ctrl_pkt); |
202 | |