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