drivers/net/ethernet/emulex/benet/be_roce.c

   1 /*
   2  * Copyright (C) 2005 - 2016 Broadcom
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License version 2
   7  * as published by the Free Software Foundation. The full GNU General
   8  * Public License is included in this distribution in the file called COPYING.
   9  *
  10  * Contact Information:
  11  * linux-drivers@emulex.com
  12  *
  13  * Emulex
  14  * 3333 Susan Street
  15  * Costa Mesa, CA 92626
  16  */
  17
  18 #include <linux/mutex.h>
  19 #include <linux/list.h>
  20 #include <linux/netdevice.h>
  21 #include <linux/module.h>
  22
  23 #include "be.h"
  24 #include "be_cmds.h"
  25
  26 static struct ocrdma_driver *ocrdma_drv;
  27 static LIST_HEAD(be_adapter_list);
  28 static DEFINE_MUTEX(be_adapter_list_lock);
  29
  30 static void _be_roce_dev_add(struct be_adapter *adapter)
  31 {
  32         struct be_dev_info dev_info;
  33         int i, num_vec;
  34         struct pci_dev *pdev = adapter->pdev;
  35
  36         if (!ocrdma_drv)
  37                 return;
  38
  39         if (ocrdma_drv->be_abi_version != BE_ROCE_ABI_VERSION) {
  40                 dev_warn(&pdev->dev, "Cannot initialize RoCE due to ocrdma ABI mismatch\n");
  41                 return;
  42         }
  43
  44         if (pdev->device == OC_DEVICE_ID5) {
  45                 /* only msix is supported on these devices */
  46                 if (!msix_enabled(adapter))
  47                         return;
  48                 /* DPP region address and length */
  49                 dev_info.dpp_unmapped_addr = pci_resource_start(pdev, 2);
  50                 dev_info.dpp_unmapped_len = pci_resource_len(pdev, 2);
  51         } else {
  52                 dev_info.dpp_unmapped_addr = 0;
  53                 dev_info.dpp_unmapped_len = 0;
  54         }
  55         dev_info.pdev = adapter->pdev;
  56         dev_info.db = adapter->db;
  57         dev_info.unmapped_db = adapter->roce_db.io_addr;
  58         dev_info.db_page_size = adapter->roce_db.size;
  59         dev_info.db_total_size = adapter->roce_db.total_size;
  60         dev_info.netdev = adapter->netdev;
  61         memcpy(dev_info.mac_addr, adapter->netdev->dev_addr, ETH_ALEN);
  62         dev_info.dev_family = adapter->sli_family;
  63         if (msix_enabled(adapter)) {
  64                 /* provide all the vectors, so that EQ creation response
  65                  * can decide which one to use.
  66                  */
  67                 num_vec = adapter->num_msix_vec + adapter->num_msix_roce_vec;
  68                 dev_info.intr_mode = BE_INTERRUPT_MODE_MSIX;
  69                 dev_info.msix.num_vectors = min(num_vec, MAX_MSIX_VECTORS);
  70                 /* provide start index of the vector,
  71                  * so in case of linear usage,
  72                  * it can use the base as starting point.
  73                  */
  74                 dev_info.msix.start_vector = adapter->num_evt_qs;
  75                 for (i = 0; i < dev_info.msix.num_vectors; i++) {
  76                         dev_info.msix.vector_list[i] =
  77                             adapter->msix_entries[i].vector;
  78                 }
  79         } else {
  80                 dev_info.msix.num_vectors = 0;
  81                 dev_info.intr_mode = BE_INTERRUPT_MODE_INTX;
  82         }
  83         adapter->ocrdma_dev = ocrdma_drv->add(&dev_info);
  84 }
  85
  86 void be_roce_dev_add(struct be_adapter *adapter)
  87 {
  88         if (be_roce_supported(adapter)) {
  89                 INIT_LIST_HEAD(&adapter->entry);
  90                 mutex_lock(&be_adapter_list_lock);
  91                 list_add_tail(&adapter->entry, &be_adapter_list);
  92
  93                 /* invoke add() routine of roce driver only if
  94                  * valid driver registered with add method and add() is not yet
  95                  * invoked on a given adapter.
  96                  */
  97                 _be_roce_dev_add(adapter);
  98                 mutex_unlock(&be_adapter_list_lock);
  99         }
 100 }
 101
 102 static void _be_roce_dev_remove(struct be_adapter *adapter)
 103 {
 104         if (ocrdma_drv && ocrdma_drv->remove && adapter->ocrdma_dev)
 105                 ocrdma_drv->remove(adapter->ocrdma_dev);
 106         adapter->ocrdma_dev = NULL;
 107 }
 108
 109 void be_roce_dev_remove(struct be_adapter *adapter)
 110 {
 111         if (be_roce_supported(adapter)) {
 112                 mutex_lock(&be_adapter_list_lock);
 113                 _be_roce_dev_remove(adapter);
 114                 list_del(&adapter->entry);
 115                 mutex_unlock(&be_adapter_list_lock);
 116         }
 117 }
 118
 119 void be_roce_dev_shutdown(struct be_adapter *adapter)
 120 {
 121         if (be_roce_supported(adapter)) {
 122                 mutex_lock(&be_adapter_list_lock);
 123                 if (ocrdma_drv && adapter->ocrdma_dev &&
 124                     ocrdma_drv->state_change_handler)
 125                         ocrdma_drv->state_change_handler(adapter->ocrdma_dev,
 126                                                          BE_DEV_SHUTDOWN);
 127                 mutex_unlock(&be_adapter_list_lock);
 128         }
 129 }
 130
 131 int be_roce_register_driver(struct ocrdma_driver *drv)
 132 {
 133         struct be_adapter *dev;
 134
 135         mutex_lock(&be_adapter_list_lock);
 136         if (ocrdma_drv) {
 137                 mutex_unlock(&be_adapter_list_lock);
 138                 return -EINVAL;
 139         }
 140         ocrdma_drv = drv;
 141         list_for_each_entry(dev, &be_adapter_list, entry) {
 142                 struct net_device *netdev;
 143
 144                 _be_roce_dev_add(dev);
 145                 netdev = dev->netdev;
 146         }
 147         mutex_unlock(&be_adapter_list_lock);
 148         return 0;
 149 }
 150 EXPORT_SYMBOL(be_roce_register_driver);
 151
 152 void be_roce_unregister_driver(struct ocrdma_driver *drv)
 153 {
 154         struct be_adapter *dev;
 155
 156         mutex_lock(&be_adapter_list_lock);
 157         list_for_each_entry(dev, &be_adapter_list, entry) {
 158                 if (dev->ocrdma_dev)
 159                         _be_roce_dev_remove(dev);
 160         }
 161         ocrdma_drv = NULL;
 162         mutex_unlock(&be_adapter_list_lock);
 163 }
 164 EXPORT_SYMBOL(be_roce_unregister_driver);