1 /**********************************************************************
2 * Author: Cavium, Inc.
3 *
4 * Contact: support@cavium.com
5 * Please include "LiquidIO" in the subject.
6 *
7 * Copyright (c) 2003-2017 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 details.
17 ***********************************************************************/
18 #include <linux/pci.h>
19 #include <linux/if_vlan.h>
20 #include "liquidio_common.h"
21 #include "octeon_droq.h"
22 #include "octeon_iq.h"
23 #include "response_manager.h"
24 #include "octeon_device.h"
25 #include "octeon_nic.h"
26 #include "octeon_main.h"
27 #include "octeon_network.h"
28 #include <net/switchdev.h>
29 #include "lio_vf_rep.h"
30 #include "octeon_network.h"
31
32 static int lio_vf_rep_open(struct net_device *ndev);
33 static int lio_vf_rep_stop(struct net_device *ndev);
34 static int lio_vf_rep_pkt_xmit(struct sk_buff *skb, struct net_device *ndev);
35 static void lio_vf_rep_tx_timeout(struct net_device *netdev);
36 static int lio_vf_rep_phys_port_name(struct net_device *dev,
37 char *buf, size_t len);
38 static void lio_vf_rep_get_stats64(struct net_device *dev,
39 struct rtnl_link_stats64 *stats64);
40 static int lio_vf_rep_change_mtu(struct net_device *ndev, int new_mtu);
41
42 static const struct net_device_ops lio_vf_rep_ndev_ops = {
43 .ndo_open = lio_vf_rep_open,
44 .ndo_stop = lio_vf_rep_stop,
45 .ndo_start_xmit = lio_vf_rep_pkt_xmit,
46 .ndo_tx_timeout = lio_vf_rep_tx_timeout,
47 .ndo_get_phys_port_name = lio_vf_rep_phys_port_name,
48 .ndo_get_stats64 = lio_vf_rep_get_stats64,
49 .ndo_change_mtu = lio_vf_rep_change_mtu,
50 };
51
52 static void
lio_vf_rep_send_sc_complete(struct octeon_device * oct,u32 status,void * ptr)53 lio_vf_rep_send_sc_complete(struct octeon_device *oct,
54 u32 status, void *ptr)
55 {
56 struct octeon_soft_command *sc = (struct octeon_soft_command *)ptr;
57 struct lio_vf_rep_sc_ctx *ctx =
58 (struct lio_vf_rep_sc_ctx *)sc->ctxptr;
59 struct lio_vf_rep_resp *resp =
60 (struct lio_vf_rep_resp *)sc->virtrptr;
61
62 if (status != OCTEON_REQUEST_TIMEOUT && READ_ONCE(resp->status))
63 WRITE_ONCE(resp->status, 0);
64
65 complete(&ctx->complete);
66 }
67
68 static int
lio_vf_rep_send_soft_command(struct octeon_device * oct,void * req,int req_size,void * resp,int resp_size)69 lio_vf_rep_send_soft_command(struct octeon_device *oct,
70 void *req, int req_size,
71 void *resp, int resp_size)
72 {
73 int tot_resp_size = sizeof(struct lio_vf_rep_resp) + resp_size;
74 int ctx_size = sizeof(struct lio_vf_rep_sc_ctx);
75 struct octeon_soft_command *sc = NULL;
76 struct lio_vf_rep_resp *rep_resp;
77 struct lio_vf_rep_sc_ctx *ctx;
78 void *sc_req;
79 int err;
80
81 sc = (struct octeon_soft_command *)
82 octeon_alloc_soft_command(oct, req_size,
83 tot_resp_size, ctx_size);
84 if (!sc)
85 return -ENOMEM;
86
87 ctx = (struct lio_vf_rep_sc_ctx *)sc->ctxptr;
88 memset(ctx, 0, ctx_size);
89 init_completion(&ctx->complete);
90
91 sc_req = (struct lio_vf_rep_req *)sc->virtdptr;
92 memcpy(sc_req, req, req_size);
93
94 rep_resp = (struct lio_vf_rep_resp *)sc->virtrptr;
95 memset(rep_resp, 0, tot_resp_size);
96 WRITE_ONCE(rep_resp->status, 1);
97
98 sc->iq_no = 0;
99 octeon_prepare_soft_command(oct, sc, OPCODE_NIC,
100 OPCODE_NIC_VF_REP_CMD, 0, 0, 0);
101 sc->callback = lio_vf_rep_send_sc_complete;
102 sc->callback_arg = sc;
103 sc->wait_time = LIO_VF_REP_REQ_TMO_MS;
104
105 err = octeon_send_soft_command(oct, sc);
106 if (err == IQ_SEND_FAILED)
107 goto free_buff;
108
109 wait_for_completion_timeout(&ctx->complete,
110 msecs_to_jiffies
111 (2 * LIO_VF_REP_REQ_TMO_MS));
112 err = READ_ONCE(rep_resp->status) ? -EBUSY : 0;
113 if (err)
114 dev_err(&oct->pci_dev->dev, "VF rep send config failed\n");
115
116 if (resp)
117 memcpy(resp, (rep_resp + 1), resp_size);
118 free_buff:
119 octeon_free_soft_command(oct, sc);
120
121 return err;
122 }
123
124 static int
lio_vf_rep_open(struct net_device * ndev)125 lio_vf_rep_open(struct net_device *ndev)
126 {
127 struct lio_vf_rep_desc *vf_rep = netdev_priv(ndev);
128 struct lio_vf_rep_req rep_cfg;
129 struct octeon_device *oct;
130 int ret;
131
132 oct = vf_rep->oct;
133
134 memset(&rep_cfg, 0, sizeof(rep_cfg));
135 rep_cfg.req_type = LIO_VF_REP_REQ_STATE;
136 rep_cfg.ifidx = vf_rep->ifidx;
137 rep_cfg.rep_state.state = LIO_VF_REP_STATE_UP;
138
139 ret = lio_vf_rep_send_soft_command(oct, &rep_cfg,
140 sizeof(rep_cfg), NULL, 0);
141
142 if (ret) {
143 dev_err(&oct->pci_dev->dev,
144 "VF_REP open failed with err %d\n", ret);
145 return -EIO;
146 }
147
148 atomic_set(&vf_rep->ifstate, (atomic_read(&vf_rep->ifstate) |
149 LIO_IFSTATE_RUNNING));
150
151 netif_carrier_on(ndev);
152 netif_start_queue(ndev);
153
154 return 0;
155 }
156
157 static int
lio_vf_rep_stop(struct net_device * ndev)158 lio_vf_rep_stop(struct net_device *ndev)
159 {
160 struct lio_vf_rep_desc *vf_rep = netdev_priv(ndev);
161 struct lio_vf_rep_req rep_cfg;
162 struct octeon_device *oct;
163 int ret;
164
165 oct = vf_rep->oct;
166
167 memset(&rep_cfg, 0, sizeof(rep_cfg));
168 rep_cfg.req_type = LIO_VF_REP_REQ_STATE;
169 rep_cfg.ifidx = vf_rep->ifidx;
170 rep_cfg.rep_state.state = LIO_VF_REP_STATE_DOWN;
171
172 ret = lio_vf_rep_send_soft_command(oct, &rep_cfg,
173 sizeof(rep_cfg), NULL, 0);
174
175 if (ret) {
176 dev_err(&oct->pci_dev->dev,
177 "VF_REP dev stop failed with err %d\n", ret);
178 return -EIO;
179 }
180
181 atomic_set(&vf_rep->ifstate, (atomic_read(&vf_rep->ifstate) &
182 ~LIO_IFSTATE_RUNNING));
183
184 netif_tx_disable(ndev);
185 netif_carrier_off(ndev);
186
187 return 0;
188 }
189
190 static void
lio_vf_rep_tx_timeout(struct net_device * ndev)191 lio_vf_rep_tx_timeout(struct net_device *ndev)
192 {
193 netif_trans_update(ndev);
194
195 netif_wake_queue(ndev);
196 }
197
198 static void
lio_vf_rep_get_stats64(struct net_device * dev,struct rtnl_link_stats64 * stats64)199 lio_vf_rep_get_stats64(struct net_device *dev,
200 struct rtnl_link_stats64 *stats64)
201 {
202 struct lio_vf_rep_desc *vf_rep = netdev_priv(dev);
203
204 /* Swap tx and rx stats as VF rep is a switch port */
205 stats64->tx_packets = vf_rep->stats.rx_packets;
206 stats64->tx_bytes = vf_rep->stats.rx_bytes;
207 stats64->tx_dropped = vf_rep->stats.rx_dropped;
208
209 stats64->rx_packets = vf_rep->stats.tx_packets;
210 stats64->rx_bytes = vf_rep->stats.tx_bytes;
211 stats64->rx_dropped = vf_rep->stats.tx_dropped;
212 }
213
214 static int
lio_vf_rep_change_mtu(struct net_device * ndev,int new_mtu)215 lio_vf_rep_change_mtu(struct net_device *ndev, int new_mtu)
216 {
217 struct lio_vf_rep_desc *vf_rep = netdev_priv(ndev);
218 struct lio_vf_rep_req rep_cfg;
219 struct octeon_device *oct;
220 int ret;
221
222 oct = vf_rep->oct;
223
224 memset(&rep_cfg, 0, sizeof(rep_cfg));
225 rep_cfg.req_type = LIO_VF_REP_REQ_MTU;
226 rep_cfg.ifidx = vf_rep->ifidx;
227 rep_cfg.rep_mtu.mtu = cpu_to_be32(new_mtu);
228
229 ret = lio_vf_rep_send_soft_command(oct, &rep_cfg,
230 sizeof(rep_cfg), NULL, 0);
231 if (ret) {
232 dev_err(&oct->pci_dev->dev,
233 "Change MTU failed with err %d\n", ret);
234 return -EIO;
235 }
236
237 ndev->mtu = new_mtu;
238
239 return 0;
240 }
241
242 static int
lio_vf_rep_phys_port_name(struct net_device * dev,char * buf,size_t len)243 lio_vf_rep_phys_port_name(struct net_device *dev,
244 char *buf, size_t len)
245 {
246 struct lio_vf_rep_desc *vf_rep = netdev_priv(dev);
247 struct octeon_device *oct = vf_rep->oct;
248 int ret;
249
250 ret = snprintf(buf, len, "pf%dvf%d", oct->pf_num,
251 vf_rep->ifidx - oct->pf_num * 64 - 1);
252 if (ret >= len)
253 return -EOPNOTSUPP;
254
255 return 0;
256 }
257
258 static struct net_device *
lio_vf_rep_get_ndev(struct octeon_device * oct,int ifidx)259 lio_vf_rep_get_ndev(struct octeon_device *oct, int ifidx)
260 {
261 int vf_id, max_vfs = CN23XX_MAX_VFS_PER_PF + 1;
262 int vfid_mask = max_vfs - 1;
263
264 if (ifidx <= oct->pf_num * max_vfs ||
265 ifidx >= oct->pf_num * max_vfs + max_vfs)
266 return NULL;
267
268 /* ifidx 1-63 for PF0 VFs
269 * ifidx 65-127 for PF1 VFs
270 */
271 vf_id = (ifidx & vfid_mask) - 1;
272
273 return oct->vf_rep_list.ndev[vf_id];
274 }
275
276 static void
lio_vf_rep_copy_packet(struct octeon_device * oct,struct sk_buff * skb,int len)277 lio_vf_rep_copy_packet(struct octeon_device *oct,
278 struct sk_buff *skb,
279 int len)
280 {
281 if (likely(len > MIN_SKB_SIZE)) {
282 struct octeon_skb_page_info *pg_info;
283 unsigned char *va;
284
285 pg_info = ((struct octeon_skb_page_info *)(skb->cb));
286 if (pg_info->page) {
287 va = page_address(pg_info->page) +
288 pg_info->page_offset;
289 memcpy(skb->data, va, MIN_SKB_SIZE);
290 skb_put(skb, MIN_SKB_SIZE);
291 }
292
293 skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags,
294 pg_info->page,
295 pg_info->page_offset + MIN_SKB_SIZE,
296 len - MIN_SKB_SIZE,
297 LIO_RXBUFFER_SZ);
298 } else {
299 struct octeon_skb_page_info *pg_info =
300 ((struct octeon_skb_page_info *)(skb->cb));
301
302 skb_copy_to_linear_data(skb, page_address(pg_info->page) +
303 pg_info->page_offset, len);
304 skb_put(skb, len);
305 put_page(pg_info->page);
306 }
307 }
308
309 static int
lio_vf_rep_pkt_recv(struct octeon_recv_info * recv_info,void * buf)310 lio_vf_rep_pkt_recv(struct octeon_recv_info *recv_info, void *buf)
311 {
312 struct octeon_recv_pkt *recv_pkt = recv_info->recv_pkt;
313 struct lio_vf_rep_desc *vf_rep;
314 struct net_device *vf_ndev;
315 struct octeon_device *oct;
316 union octeon_rh *rh;
317 struct sk_buff *skb;
318 int i, ifidx;
319
320 oct = lio_get_device(recv_pkt->octeon_id);
321 if (!oct)
322 goto free_buffers;
323
324 skb = recv_pkt->buffer_ptr[0];
325 rh = &recv_pkt->rh;
326 ifidx = rh->r.ossp;
327
328 vf_ndev = lio_vf_rep_get_ndev(oct, ifidx);
329 if (!vf_ndev)
330 goto free_buffers;
331
332 vf_rep = netdev_priv(vf_ndev);
333 if (!(atomic_read(&vf_rep->ifstate) & LIO_IFSTATE_RUNNING) ||
334 recv_pkt->buffer_count > 1)
335 goto free_buffers;
336
337 skb->dev = vf_ndev;
338
339 /* Multiple buffers are not used for vf_rep packets.
340 * So just buffer_size[0] is valid.
341 */
342 lio_vf_rep_copy_packet(oct, skb, recv_pkt->buffer_size[0]);
343
344 skb_pull(skb, rh->r_dh.len * BYTES_PER_DHLEN_UNIT);
345 skb->protocol = eth_type_trans(skb, skb->dev);
346 skb->ip_summed = CHECKSUM_NONE;
347
348 netif_rx(skb);
349
350 octeon_free_recv_info(recv_info);
351
352 return 0;
353
354 free_buffers:
355 for (i = 0; i < recv_pkt->buffer_count; i++)
356 recv_buffer_free(recv_pkt->buffer_ptr[i]);
357
358 octeon_free_recv_info(recv_info);
359
360 return 0;
361 }
362
363 static void
lio_vf_rep_packet_sent_callback(struct octeon_device * oct,u32 status,void * buf)364 lio_vf_rep_packet_sent_callback(struct octeon_device *oct,
365 u32 status, void *buf)
366 {
367 struct octeon_soft_command *sc = (struct octeon_soft_command *)buf;
368 struct sk_buff *skb = sc->ctxptr;
369 struct net_device *ndev = skb->dev;
370
371 dma_unmap_single(&oct->pci_dev->dev, sc->dmadptr,
372 sc->datasize, DMA_TO_DEVICE);
373 dev_kfree_skb_any(skb);
374 octeon_free_soft_command(oct, sc);
375
376 if (octnet_iq_is_full(oct, sc->iq_no))
377 return;
378
379 if (netif_queue_stopped(ndev))
380 netif_wake_queue(ndev);
381 }
382
383 static int
lio_vf_rep_pkt_xmit(struct sk_buff * skb,struct net_device * ndev)384 lio_vf_rep_pkt_xmit(struct sk_buff *skb, struct net_device *ndev)
385 {
386 struct lio_vf_rep_desc *vf_rep = netdev_priv(ndev);
387 struct net_device *parent_ndev = vf_rep->parent_ndev;
388 struct octeon_device *oct = vf_rep->oct;
389 struct octeon_instr_pki_ih3 *pki_ih3;
390 struct octeon_soft_command *sc;
391 struct lio *parent_lio;
392 int status;
393
394 parent_lio = GET_LIO(parent_ndev);
395
396 if (!(atomic_read(&vf_rep->ifstate) & LIO_IFSTATE_RUNNING) ||
397 skb->len <= 0)
398 goto xmit_failed;
399
400 if (octnet_iq_is_full(vf_rep->oct, parent_lio->txq)) {
401 dev_err(&oct->pci_dev->dev, "VF rep: Device IQ full\n");
402 netif_stop_queue(ndev);
403 return NETDEV_TX_BUSY;
404 }
405
406 sc = (struct octeon_soft_command *)
407 octeon_alloc_soft_command(oct, 0, 0, 0);
408 if (!sc) {
409 dev_err(&oct->pci_dev->dev, "VF rep: Soft command alloc failed\n");
410 goto xmit_failed;
411 }
412
413 /* Multiple buffers are not used for vf_rep packets. */
414 if (skb_shinfo(skb)->nr_frags != 0) {
415 dev_err(&oct->pci_dev->dev, "VF rep: nr_frags != 0. Dropping packet\n");
416 goto xmit_failed;
417 }
418
419 sc->dmadptr = dma_map_single(&oct->pci_dev->dev,
420 skb->data, skb->len, DMA_TO_DEVICE);
421 if (dma_mapping_error(&oct->pci_dev->dev, sc->dmadptr)) {
422 dev_err(&oct->pci_dev->dev, "VF rep: DMA mapping failed\n");
423 goto xmit_failed;
424 }
425
426 sc->virtdptr = skb->data;
427 sc->datasize = skb->len;
428 sc->ctxptr = skb;
429 sc->iq_no = parent_lio->txq;
430
431 octeon_prepare_soft_command(oct, sc, OPCODE_NIC, OPCODE_NIC_VF_REP_PKT,
432 vf_rep->ifidx, 0, 0);
433 pki_ih3 = (struct octeon_instr_pki_ih3 *)&sc->cmd.cmd3.pki_ih3;
434 pki_ih3->tagtype = ORDERED_TAG;
435
436 sc->callback = lio_vf_rep_packet_sent_callback;
437 sc->callback_arg = sc;
438
439 status = octeon_send_soft_command(oct, sc);
440 if (status == IQ_SEND_FAILED) {
441 dma_unmap_single(&oct->pci_dev->dev, sc->dmadptr,
442 sc->datasize, DMA_TO_DEVICE);
443 goto xmit_failed;
444 }
445
446 if (status == IQ_SEND_STOP)
447 netif_stop_queue(ndev);
448
449 netif_trans_update(ndev);
450
451 return NETDEV_TX_OK;
452
453 xmit_failed:
454 dev_kfree_skb_any(skb);
455
456 return NETDEV_TX_OK;
457 }
458
459 static int
lio_vf_rep_attr_get(struct net_device * dev,struct switchdev_attr * attr)460 lio_vf_rep_attr_get(struct net_device *dev, struct switchdev_attr *attr)
461 {
462 struct lio_vf_rep_desc *vf_rep = netdev_priv(dev);
463 struct net_device *parent_ndev = vf_rep->parent_ndev;
464 struct lio *lio = GET_LIO(parent_ndev);
465
466 switch (attr->id) {
467 case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
468 attr->u.ppid.id_len = ETH_ALEN;
469 ether_addr_copy(attr->u.ppid.id,
470 (void *)&lio->linfo.hw_addr + 2);
471 break;
472
473 default:
474 return -EOPNOTSUPP;
475 }
476
477 return 0;
478 }
479
480 static const struct switchdev_ops lio_vf_rep_switchdev_ops = {
481 .switchdev_port_attr_get = lio_vf_rep_attr_get,
482 };
483
484 static void
lio_vf_rep_fetch_stats(struct work_struct * work)485 lio_vf_rep_fetch_stats(struct work_struct *work)
486 {
487 struct cavium_wk *wk = (struct cavium_wk *)work;
488 struct lio_vf_rep_desc *vf_rep = wk->ctxptr;
489 struct lio_vf_rep_stats stats;
490 struct lio_vf_rep_req rep_cfg;
491 struct octeon_device *oct;
492 int ret;
493
494 oct = vf_rep->oct;
495
496 memset(&rep_cfg, 0, sizeof(rep_cfg));
497 rep_cfg.req_type = LIO_VF_REP_REQ_STATS;
498 rep_cfg.ifidx = vf_rep->ifidx;
499
500 ret = lio_vf_rep_send_soft_command(oct, &rep_cfg, sizeof(rep_cfg),
501 &stats, sizeof(stats));
502
503 if (!ret) {
504 octeon_swap_8B_data((u64 *)&stats, (sizeof(stats) >> 3));
505 memcpy(&vf_rep->stats, &stats, sizeof(stats));
506 }
507
508 schedule_delayed_work(&vf_rep->stats_wk.work,
509 msecs_to_jiffies(LIO_VF_REP_STATS_POLL_TIME_MS));
510 }
511
512 int
lio_vf_rep_create(struct octeon_device * oct)513 lio_vf_rep_create(struct octeon_device *oct)
514 {
515 struct lio_vf_rep_desc *vf_rep;
516 struct net_device *ndev;
517 int i, num_vfs;
518
519 if (oct->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
520 return 0;
521
522 if (!oct->sriov_info.sriov_enabled)
523 return 0;
524
525 num_vfs = oct->sriov_info.num_vfs_alloced;
526
527 oct->vf_rep_list.num_vfs = 0;
528 for (i = 0; i < num_vfs; i++) {
529 ndev = alloc_etherdev(sizeof(struct lio_vf_rep_desc));
530
531 if (!ndev) {
532 dev_err(&oct->pci_dev->dev,
533 "VF rep device %d creation failed\n", i);
534 goto cleanup;
535 }
536
537 ndev->min_mtu = LIO_MIN_MTU_SIZE;
538 ndev->max_mtu = LIO_MAX_MTU_SIZE;
539 ndev->netdev_ops = &lio_vf_rep_ndev_ops;
540 SWITCHDEV_SET_OPS(ndev, &lio_vf_rep_switchdev_ops);
541
542 vf_rep = netdev_priv(ndev);
543 memset(vf_rep, 0, sizeof(*vf_rep));
544
545 vf_rep->ndev = ndev;
546 vf_rep->oct = oct;
547 vf_rep->parent_ndev = oct->props[0].netdev;
548 vf_rep->ifidx = (oct->pf_num * 64) + i + 1;
549
550 eth_hw_addr_random(ndev);
551
552 if (register_netdev(ndev)) {
553 dev_err(&oct->pci_dev->dev, "VF rep nerdev registration failed\n");
554
555 free_netdev(ndev);
556 goto cleanup;
557 }
558
559 netif_carrier_off(ndev);
560
561 INIT_DELAYED_WORK(&vf_rep->stats_wk.work,
562 lio_vf_rep_fetch_stats);
563 vf_rep->stats_wk.ctxptr = (void *)vf_rep;
564 schedule_delayed_work(&vf_rep->stats_wk.work,
565 msecs_to_jiffies
566 (LIO_VF_REP_STATS_POLL_TIME_MS));
567 oct->vf_rep_list.num_vfs++;
568 oct->vf_rep_list.ndev[i] = ndev;
569 }
570
571 if (octeon_register_dispatch_fn(oct, OPCODE_NIC,
572 OPCODE_NIC_VF_REP_PKT,
573 lio_vf_rep_pkt_recv, oct)) {
574 dev_err(&oct->pci_dev->dev, "VF rep Dispatch func registration failed\n");
575
576 goto cleanup;
577 }
578
579 return 0;
580
581 cleanup:
582 for (i = 0; i < oct->vf_rep_list.num_vfs; i++) {
583 ndev = oct->vf_rep_list.ndev[i];
584 oct->vf_rep_list.ndev[i] = NULL;
585 if (ndev) {
586 vf_rep = netdev_priv(ndev);
587 cancel_delayed_work_sync
588 (&vf_rep->stats_wk.work);
589 unregister_netdev(ndev);
590 free_netdev(ndev);
591 }
592 }
593
594 oct->vf_rep_list.num_vfs = 0;
595
596 return -1;
597 }
598
599 void
lio_vf_rep_destroy(struct octeon_device * oct)600 lio_vf_rep_destroy(struct octeon_device *oct)
601 {
602 struct lio_vf_rep_desc *vf_rep;
603 struct net_device *ndev;
604 int i;
605
606 if (oct->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
607 return;
608
609 if (!oct->sriov_info.sriov_enabled)
610 return;
611
612 for (i = 0; i < oct->vf_rep_list.num_vfs; i++) {
613 ndev = oct->vf_rep_list.ndev[i];
614 oct->vf_rep_list.ndev[i] = NULL;
615 if (ndev) {
616 vf_rep = netdev_priv(ndev);
617 cancel_delayed_work_sync
618 (&vf_rep->stats_wk.work);
619 netif_tx_disable(ndev);
620 netif_carrier_off(ndev);
621
622 unregister_netdev(ndev);
623 free_netdev(ndev);
624 }
625 }
626
627 oct->vf_rep_list.num_vfs = 0;
628 }
629
630 static int
lio_vf_rep_netdev_event(struct notifier_block * nb,unsigned long event,void * ptr)631 lio_vf_rep_netdev_event(struct notifier_block *nb,
632 unsigned long event, void *ptr)
633 {
634 struct net_device *ndev = netdev_notifier_info_to_dev(ptr);
635 struct lio_vf_rep_desc *vf_rep;
636 struct lio_vf_rep_req rep_cfg;
637 struct octeon_device *oct;
638 int ret;
639
640 switch (event) {
641 case NETDEV_REGISTER:
642 case NETDEV_CHANGENAME:
643 break;
644
645 default:
646 return NOTIFY_DONE;
647 }
648
649 if (ndev->netdev_ops != &lio_vf_rep_ndev_ops)
650 return NOTIFY_DONE;
651
652 vf_rep = netdev_priv(ndev);
653 oct = vf_rep->oct;
654
655 if (strlen(ndev->name) > LIO_IF_NAME_SIZE) {
656 dev_err(&oct->pci_dev->dev,
657 "Device name change sync failed as the size is > %d\n",
658 LIO_IF_NAME_SIZE);
659 return NOTIFY_DONE;
660 }
661
662 memset(&rep_cfg, 0, sizeof(rep_cfg));
663 rep_cfg.req_type = LIO_VF_REP_REQ_DEVNAME;
664 rep_cfg.ifidx = vf_rep->ifidx;
665 strncpy(rep_cfg.rep_name.name, ndev->name, LIO_IF_NAME_SIZE);
666
667 ret = lio_vf_rep_send_soft_command(oct, &rep_cfg,
668 sizeof(rep_cfg), NULL, 0);
669 if (ret)
670 dev_err(&oct->pci_dev->dev,
671 "vf_rep netdev name change failed with err %d\n", ret);
672
673 return NOTIFY_DONE;
674 }
675
676 static struct notifier_block lio_vf_rep_netdev_notifier = {
677 .notifier_call = lio_vf_rep_netdev_event,
678 };
679
680 int
lio_vf_rep_modinit(void)681 lio_vf_rep_modinit(void)
682 {
683 if (register_netdevice_notifier(&lio_vf_rep_netdev_notifier)) {
684 pr_err("netdev notifier registration failed\n");
685 return -EFAULT;
686 }
687
688 return 0;
689 }
690
691 void
lio_vf_rep_modexit(void)692 lio_vf_rep_modexit(void)
693 {
694 if (unregister_netdevice_notifier(&lio_vf_rep_netdev_notifier))
695 pr_err("netdev notifier unregister failed\n");
696 }
697
