1 // SPDX-License-Identifier: GPL-2.0
2 /* Marvell Octeon EP (EndPoint) Ethernet Driver
3 *
4 * Copyright (C) 2020 Marvell.
5 *
6 */
7 #include <linux/string.h>
8 #include <linux/types.h>
9 #include <linux/etherdevice.h>
10 #include <linux/pci.h>
11 #include <linux/wait.h>
12
13 #include "octep_config.h"
14 #include "octep_main.h"
15 #include "octep_ctrl_net.h"
16
17 /* Control plane version */
18 #define OCTEP_CP_VERSION_CURRENT OCTEP_CP_VERSION(1, 0, 0)
19
20 static const u32 req_hdr_sz = sizeof(union octep_ctrl_net_req_hdr);
21 static const u32 mtu_sz = sizeof(struct octep_ctrl_net_h2f_req_cmd_mtu);
22 static const u32 mac_sz = sizeof(struct octep_ctrl_net_h2f_req_cmd_mac);
23 static const u32 state_sz = sizeof(struct octep_ctrl_net_h2f_req_cmd_state);
24 static const u32 link_info_sz = sizeof(struct octep_ctrl_net_link_info);
25 static atomic_t ctrl_net_msg_id;
26
27 /* Control plane version in which OCTEP_CTRL_NET_H2F_CMD was added */
28 static const u32 octep_ctrl_net_h2f_cmd_versions[OCTEP_CTRL_NET_H2F_CMD_MAX] = {
29 [OCTEP_CTRL_NET_H2F_CMD_INVALID ... OCTEP_CTRL_NET_H2F_CMD_LINK_INFO] =
30 OCTEP_CP_VERSION(1, 0, 0)
31 };
32
33 /* Control plane version in which OCTEP_CTRL_NET_F2H_CMD was added */
34 static const u32 octep_ctrl_net_f2h_cmd_versions[OCTEP_CTRL_NET_F2H_CMD_MAX] = {
35 [OCTEP_CTRL_NET_F2H_CMD_INVALID ... OCTEP_CTRL_NET_F2H_CMD_LINK_STATUS] =
36 OCTEP_CP_VERSION(1, 0, 0)
37 };
38
init_send_req(struct octep_ctrl_mbox_msg * msg,void * buf,u16 sz,int vfid)39 static void init_send_req(struct octep_ctrl_mbox_msg *msg, void *buf,
40 u16 sz, int vfid)
41 {
42 msg->hdr.s.flags = OCTEP_CTRL_MBOX_MSG_HDR_FLAG_REQ;
43 msg->hdr.s.msg_id = atomic_inc_return(&ctrl_net_msg_id) &
44 GENMASK(sizeof(msg->hdr.s.msg_id) * BITS_PER_BYTE, 0);
45 msg->hdr.s.sz = req_hdr_sz + sz;
46 msg->sg_num = 1;
47 msg->sg_list[0].msg = buf;
48 msg->sg_list[0].sz = msg->hdr.s.sz;
49 if (vfid != OCTEP_CTRL_NET_INVALID_VFID) {
50 msg->hdr.s.is_vf = 1;
51 msg->hdr.s.vf_idx = vfid;
52 }
53 }
54
octep_send_mbox_req(struct octep_device * oct,struct octep_ctrl_net_wait_data * d,bool wait_for_response)55 static int octep_send_mbox_req(struct octep_device *oct,
56 struct octep_ctrl_net_wait_data *d,
57 bool wait_for_response)
58 {
59 int err, ret, cmd;
60
61 /* check if firmware is compatible for this request */
62 cmd = d->data.req.hdr.s.cmd;
63 if (octep_ctrl_net_h2f_cmd_versions[cmd] > oct->ctrl_mbox.max_fw_version ||
64 octep_ctrl_net_h2f_cmd_versions[cmd] < oct->ctrl_mbox.min_fw_version)
65 return -EOPNOTSUPP;
66
67 err = octep_ctrl_mbox_send(&oct->ctrl_mbox, &d->msg);
68 if (err < 0)
69 return err;
70
71 if (!wait_for_response)
72 return 0;
73
74 d->done = 0;
75 INIT_LIST_HEAD(&d->list);
76 list_add_tail(&d->list, &oct->ctrl_req_wait_list);
77 ret = wait_event_interruptible_timeout(oct->ctrl_req_wait_q,
78 (d->done != 0),
79 msecs_to_jiffies(500));
80 list_del(&d->list);
81 if (ret == 0 || ret == 1)
82 return -EAGAIN;
83
84 /**
85 * (ret == 0) cond = false && timeout, return 0
86 * (ret < 0) interrupted by signal, return 0
87 * (ret == 1) cond = true && timeout, return 1
88 * (ret >= 1) cond = true && !timeout, return 1
89 */
90
91 if (d->data.resp.hdr.s.reply != OCTEP_CTRL_NET_REPLY_OK)
92 return -EAGAIN;
93
94 return 0;
95 }
96
octep_ctrl_net_init(struct octep_device * oct)97 int octep_ctrl_net_init(struct octep_device *oct)
98 {
99 struct octep_ctrl_mbox *ctrl_mbox;
100 struct pci_dev *pdev = oct->pdev;
101 int ret;
102
103 init_waitqueue_head(&oct->ctrl_req_wait_q);
104 INIT_LIST_HEAD(&oct->ctrl_req_wait_list);
105
106 /* Initialize control mbox */
107 ctrl_mbox = &oct->ctrl_mbox;
108 ctrl_mbox->version = OCTEP_CP_VERSION_CURRENT;
109 ctrl_mbox->barmem = CFG_GET_CTRL_MBOX_MEM_ADDR(oct->conf);
110 ret = octep_ctrl_mbox_init(ctrl_mbox);
111 if (ret) {
112 dev_err(&pdev->dev, "Failed to initialize control mbox\n");
113 return ret;
114 }
115 dev_info(&pdev->dev, "Control plane versions host: %llx, firmware: %x:%x\n",
116 ctrl_mbox->version, ctrl_mbox->min_fw_version,
117 ctrl_mbox->max_fw_version);
118 oct->ctrl_mbox_ifstats_offset = ctrl_mbox->barmem_sz;
119
120 return 0;
121 }
122
octep_ctrl_net_get_link_status(struct octep_device * oct,int vfid)123 int octep_ctrl_net_get_link_status(struct octep_device *oct, int vfid)
124 {
125 struct octep_ctrl_net_wait_data d = {0};
126 struct octep_ctrl_net_h2f_req *req = &d.data.req;
127 int err;
128
129 init_send_req(&d.msg, (void *)req, state_sz, vfid);
130 req->hdr.s.cmd = OCTEP_CTRL_NET_H2F_CMD_LINK_STATUS;
131 req->link.cmd = OCTEP_CTRL_NET_CMD_GET;
132 err = octep_send_mbox_req(oct, &d, true);
133 if (err < 0)
134 return err;
135
136 return d.data.resp.link.state;
137 }
138
octep_ctrl_net_set_link_status(struct octep_device * oct,int vfid,bool up,bool wait_for_response)139 int octep_ctrl_net_set_link_status(struct octep_device *oct, int vfid, bool up,
140 bool wait_for_response)
141 {
142 struct octep_ctrl_net_wait_data d = {0};
143 struct octep_ctrl_net_h2f_req *req = &d.data.req;
144
145 init_send_req(&d.msg, req, state_sz, vfid);
146 req->hdr.s.cmd = OCTEP_CTRL_NET_H2F_CMD_LINK_STATUS;
147 req->link.cmd = OCTEP_CTRL_NET_CMD_SET;
148 req->link.state = (up) ? OCTEP_CTRL_NET_STATE_UP :
149 OCTEP_CTRL_NET_STATE_DOWN;
150
151 return octep_send_mbox_req(oct, &d, wait_for_response);
152 }
153
octep_ctrl_net_set_rx_state(struct octep_device * oct,int vfid,bool up,bool wait_for_response)154 int octep_ctrl_net_set_rx_state(struct octep_device *oct, int vfid, bool up,
155 bool wait_for_response)
156 {
157 struct octep_ctrl_net_wait_data d = {0};
158 struct octep_ctrl_net_h2f_req *req = &d.data.req;
159
160 init_send_req(&d.msg, req, state_sz, vfid);
161 req->hdr.s.cmd = OCTEP_CTRL_NET_H2F_CMD_RX_STATE;
162 req->link.cmd = OCTEP_CTRL_NET_CMD_SET;
163 req->link.state = (up) ? OCTEP_CTRL_NET_STATE_UP :
164 OCTEP_CTRL_NET_STATE_DOWN;
165
166 return octep_send_mbox_req(oct, &d, wait_for_response);
167 }
168
octep_ctrl_net_get_mac_addr(struct octep_device * oct,int vfid,u8 * addr)169 int octep_ctrl_net_get_mac_addr(struct octep_device *oct, int vfid, u8 *addr)
170 {
171 struct octep_ctrl_net_wait_data d = {0};
172 struct octep_ctrl_net_h2f_req *req = &d.data.req;
173 int err;
174
175 init_send_req(&d.msg, req, mac_sz, vfid);
176 req->hdr.s.cmd = OCTEP_CTRL_NET_H2F_CMD_MAC;
177 req->link.cmd = OCTEP_CTRL_NET_CMD_GET;
178 err = octep_send_mbox_req(oct, &d, true);
179 if (err < 0)
180 return err;
181
182 memcpy(addr, d.data.resp.mac.addr, ETH_ALEN);
183
184 return 0;
185 }
186
octep_ctrl_net_set_mac_addr(struct octep_device * oct,int vfid,u8 * addr,bool wait_for_response)187 int octep_ctrl_net_set_mac_addr(struct octep_device *oct, int vfid, u8 *addr,
188 bool wait_for_response)
189 {
190 struct octep_ctrl_net_wait_data d = {0};
191 struct octep_ctrl_net_h2f_req *req = &d.data.req;
192
193 init_send_req(&d.msg, req, mac_sz, vfid);
194 req->hdr.s.cmd = OCTEP_CTRL_NET_H2F_CMD_MAC;
195 req->mac.cmd = OCTEP_CTRL_NET_CMD_SET;
196 memcpy(&req->mac.addr, addr, ETH_ALEN);
197
198 return octep_send_mbox_req(oct, &d, wait_for_response);
199 }
200
octep_ctrl_net_set_mtu(struct octep_device * oct,int vfid,int mtu,bool wait_for_response)201 int octep_ctrl_net_set_mtu(struct octep_device *oct, int vfid, int mtu,
202 bool wait_for_response)
203 {
204 struct octep_ctrl_net_wait_data d = {0};
205 struct octep_ctrl_net_h2f_req *req = &d.data.req;
206
207 init_send_req(&d.msg, req, mtu_sz, vfid);
208 req->hdr.s.cmd = OCTEP_CTRL_NET_H2F_CMD_MTU;
209 req->mtu.cmd = OCTEP_CTRL_NET_CMD_SET;
210 req->mtu.val = mtu;
211
212 return octep_send_mbox_req(oct, &d, wait_for_response);
213 }
214
octep_ctrl_net_get_if_stats(struct octep_device * oct,int vfid,struct octep_iface_rx_stats * rx_stats,struct octep_iface_tx_stats * tx_stats)215 int octep_ctrl_net_get_if_stats(struct octep_device *oct, int vfid,
216 struct octep_iface_rx_stats *rx_stats,
217 struct octep_iface_tx_stats *tx_stats)
218 {
219 struct octep_ctrl_net_wait_data d = {0};
220 struct octep_ctrl_net_h2f_req *req = &d.data.req;
221 struct octep_ctrl_net_h2f_resp *resp;
222 int err;
223
224 init_send_req(&d.msg, req, 0, vfid);
225 req->hdr.s.cmd = OCTEP_CTRL_NET_H2F_CMD_GET_IF_STATS;
226 err = octep_send_mbox_req(oct, &d, true);
227 if (err < 0)
228 return err;
229
230 resp = &d.data.resp;
231 memcpy(rx_stats, &resp->if_stats.rx_stats, sizeof(struct octep_iface_rx_stats));
232 memcpy(tx_stats, &resp->if_stats.tx_stats, sizeof(struct octep_iface_tx_stats));
233 return 0;
234 }
235
octep_ctrl_net_get_link_info(struct octep_device * oct,int vfid,struct octep_iface_link_info * link_info)236 int octep_ctrl_net_get_link_info(struct octep_device *oct, int vfid,
237 struct octep_iface_link_info *link_info)
238 {
239 struct octep_ctrl_net_wait_data d = {0};
240 struct octep_ctrl_net_h2f_req *req = &d.data.req;
241 struct octep_ctrl_net_h2f_resp *resp;
242 int err;
243
244 init_send_req(&d.msg, req, link_info_sz, vfid);
245 req->hdr.s.cmd = OCTEP_CTRL_NET_H2F_CMD_LINK_INFO;
246 req->link_info.cmd = OCTEP_CTRL_NET_CMD_GET;
247 err = octep_send_mbox_req(oct, &d, true);
248 if (err < 0)
249 return err;
250
251 resp = &d.data.resp;
252 link_info->supported_modes = resp->link_info.supported_modes;
253 link_info->advertised_modes = resp->link_info.advertised_modes;
254 link_info->autoneg = resp->link_info.autoneg;
255 link_info->pause = resp->link_info.pause;
256 link_info->speed = resp->link_info.speed;
257
258 return 0;
259 }
260
octep_ctrl_net_set_link_info(struct octep_device * oct,int vfid,struct octep_iface_link_info * link_info,bool wait_for_response)261 int octep_ctrl_net_set_link_info(struct octep_device *oct, int vfid,
262 struct octep_iface_link_info *link_info,
263 bool wait_for_response)
264 {
265 struct octep_ctrl_net_wait_data d = {0};
266 struct octep_ctrl_net_h2f_req *req = &d.data.req;
267
268 init_send_req(&d.msg, req, link_info_sz, vfid);
269 req->hdr.s.cmd = OCTEP_CTRL_NET_H2F_CMD_LINK_INFO;
270 req->link_info.cmd = OCTEP_CTRL_NET_CMD_SET;
271 req->link_info.info.advertised_modes = link_info->advertised_modes;
272 req->link_info.info.autoneg = link_info->autoneg;
273 req->link_info.info.pause = link_info->pause;
274 req->link_info.info.speed = link_info->speed;
275
276 return octep_send_mbox_req(oct, &d, wait_for_response);
277 }
278
process_mbox_resp(struct octep_device * oct,struct octep_ctrl_mbox_msg * msg)279 static void process_mbox_resp(struct octep_device *oct,
280 struct octep_ctrl_mbox_msg *msg)
281 {
282 struct octep_ctrl_net_wait_data *pos, *n;
283
284 list_for_each_entry_safe(pos, n, &oct->ctrl_req_wait_list, list) {
285 if (pos->msg.hdr.s.msg_id == msg->hdr.s.msg_id) {
286 memcpy(&pos->data.resp,
287 msg->sg_list[0].msg,
288 msg->hdr.s.sz);
289 pos->done = 1;
290 wake_up_interruptible_all(&oct->ctrl_req_wait_q);
291 break;
292 }
293 }
294 }
295
process_mbox_notify(struct octep_device * oct,struct octep_ctrl_mbox_msg * msg)296 static int process_mbox_notify(struct octep_device *oct,
297 struct octep_ctrl_mbox_msg *msg)
298 {
299 struct net_device *netdev = oct->netdev;
300 struct octep_ctrl_net_f2h_req *req;
301 int cmd;
302
303 req = (struct octep_ctrl_net_f2h_req *)msg->sg_list[0].msg;
304 cmd = req->hdr.s.cmd;
305
306 /* check if we support this command */
307 if (octep_ctrl_net_f2h_cmd_versions[cmd] > OCTEP_CP_VERSION_CURRENT ||
308 octep_ctrl_net_f2h_cmd_versions[cmd] < OCTEP_CP_VERSION_CURRENT)
309 return -EOPNOTSUPP;
310
311 switch (cmd) {
312 case OCTEP_CTRL_NET_F2H_CMD_LINK_STATUS:
313 if (netif_running(netdev)) {
314 if (req->link.state) {
315 dev_info(&oct->pdev->dev, "netif_carrier_on\n");
316 netif_carrier_on(netdev);
317 } else {
318 dev_info(&oct->pdev->dev, "netif_carrier_off\n");
319 netif_carrier_off(netdev);
320 }
321 }
322 break;
323 default:
324 pr_info("Unknown mbox req : %u\n", req->hdr.s.cmd);
325 break;
326 }
327
328 return 0;
329 }
330
octep_ctrl_net_recv_fw_messages(struct octep_device * oct)331 void octep_ctrl_net_recv_fw_messages(struct octep_device *oct)
332 {
333 static u16 msg_sz = sizeof(union octep_ctrl_net_max_data);
334 union octep_ctrl_net_max_data data = {0};
335 struct octep_ctrl_mbox_msg msg = {0};
336 int ret;
337
338 msg.hdr.s.sz = msg_sz;
339 msg.sg_num = 1;
340 msg.sg_list[0].sz = msg_sz;
341 msg.sg_list[0].msg = &data;
342 while (true) {
343 /* mbox will overwrite msg.hdr.s.sz so initialize it */
344 msg.hdr.s.sz = msg_sz;
345 ret = octep_ctrl_mbox_recv(&oct->ctrl_mbox, (struct octep_ctrl_mbox_msg *)&msg);
346 if (ret < 0)
347 break;
348
349 if (msg.hdr.s.flags & OCTEP_CTRL_MBOX_MSG_HDR_FLAG_RESP)
350 process_mbox_resp(oct, &msg);
351 else if (msg.hdr.s.flags & OCTEP_CTRL_MBOX_MSG_HDR_FLAG_NOTIFY)
352 process_mbox_notify(oct, &msg);
353 }
354 }
355
octep_ctrl_net_uninit(struct octep_device * oct)356 int octep_ctrl_net_uninit(struct octep_device *oct)
357 {
358 struct octep_ctrl_net_wait_data *pos, *n;
359
360 list_for_each_entry_safe(pos, n, &oct->ctrl_req_wait_list, list)
361 pos->done = 1;
362
363 wake_up_interruptible_all(&oct->ctrl_req_wait_q);
364
365 octep_ctrl_mbox_uninit(&oct->ctrl_mbox);
366
367 return 0;
368 }
369