drivers/net/ethernet/cavium/liquidio/lio_vf_rep.c

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