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