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

   1 /*
   2  * Copyright (C) 2005 - 2014 Emulex
   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 static void _be_roce_dev_open(struct be_adapter *adapter)
 120 {
 121         if (ocrdma_drv && adapter->ocrdma_dev &&
 122             ocrdma_drv->state_change_handler)
 123                 ocrdma_drv->state_change_handler(adapter->ocrdma_dev, 0);
 124 }
 125
 126 void be_roce_dev_open(struct be_adapter *adapter)
 127 {
 128         if (be_roce_supported(adapter)) {
 129                 mutex_lock(&be_adapter_list_lock);
 130                 _be_roce_dev_open(adapter);
 131                 mutex_unlock(&be_adapter_list_lock);
 132         }
 133 }
 134
 135 static void _be_roce_dev_close(struct be_adapter *adapter)
 136 {
 137         if (ocrdma_drv && adapter->ocrdma_dev &&
 138             ocrdma_drv->state_change_handler)
 139                 ocrdma_drv->state_change_handler(adapter->ocrdma_dev, 1);
 140 }
 141
 142 void be_roce_dev_close(struct be_adapter *adapter)
 143 {
 144         if (be_roce_supported(adapter)) {
 145                 mutex_lock(&be_adapter_list_lock);
 146                 _be_roce_dev_close(adapter);
 147                 mutex_unlock(&be_adapter_list_lock);
 148         }
 149 }
 150
 151 int be_roce_register_driver(struct ocrdma_driver *drv)
 152 {
 153         struct be_adapter *dev;
 154
 155         mutex_lock(&be_adapter_list_lock);
 156         if (ocrdma_drv) {
 157                 mutex_unlock(&be_adapter_list_lock);
 158                 return -EINVAL;
 159         }
 160         ocrdma_drv = drv;
 161         list_for_each_entry(dev, &be_adapter_list, entry) {
 162                 struct net_device *netdev;
 163                 _be_roce_dev_add(dev);
 164                 netdev = dev->netdev;
 165                 if (netif_running(netdev) && netif_oper_up(netdev))
 166                         _be_roce_dev_open(dev);
 167         }
 168         mutex_unlock(&be_adapter_list_lock);
 169         return 0;
 170 }
 171 EXPORT_SYMBOL(be_roce_register_driver);
 172
 173 void be_roce_unregister_driver(struct ocrdma_driver *drv)
 174 {
 175         struct be_adapter *dev;
 176
 177         mutex_lock(&be_adapter_list_lock);
 178         list_for_each_entry(dev, &be_adapter_list, entry) {
 179                 if (dev->ocrdma_dev)
 180                         _be_roce_dev_remove(dev);
 181         }
 182         ocrdma_drv = NULL;
 183         mutex_unlock(&be_adapter_list_lock);
 184 }
 185 EXPORT_SYMBOL(be_roce_unregister_driver);