xref: /openbmc/linux/drivers/ntb/core.c (revision 015d239a)
1 /*
2  * This file is provided under a dual BSD/GPLv2 license.  When using or
3  *   redistributing this file, you may do so under either license.
4  *
5  *   GPL LICENSE SUMMARY
6  *
7  *   Copyright (C) 2015 EMC Corporation. All Rights Reserved.
8  *   Copyright (C) 2016 T-Platforms. All Rights Reserved.
9  *
10  *   This program is free software; you can redistribute it and/or modify
11  *   it under the terms of version 2 of the GNU General Public License as
12  *   published by the Free Software Foundation.
13  *
14  *   This program is distributed in the hope that it will be useful, but
15  *   WITHOUT ANY WARRANTY; without even the implied warranty of
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  *   General Public License for more details.
18  *
19  *   BSD LICENSE
20  *
21  *   Copyright (C) 2015 EMC Corporation. All Rights Reserved.
22  *   Copyright (C) 2016 T-Platforms. All Rights Reserved.
23  *
24  *   Redistribution and use in source and binary forms, with or without
25  *   modification, are permitted provided that the following conditions
26  *   are met:
27  *
28  *     * Redistributions of source code must retain the above copyright
29  *       notice, this list of conditions and the following disclaimer.
30  *     * Redistributions in binary form must reproduce the above copy
31  *       notice, this list of conditions and the following disclaimer in
32  *       the documentation and/or other materials provided with the
33  *       distribution.
34  *     * Neither the name of Intel Corporation nor the names of its
35  *       contributors may be used to endorse or promote products derived
36  *       from this software without specific prior written permission.
37  *
38  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
39  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
40  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
41  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
42  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
43  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
44  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
45  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
46  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
47  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
48  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
49  *
50  * PCIe NTB Linux driver
51  *
52  * Contact Information:
53  * Allen Hubbe <Allen.Hubbe@emc.com>
54  */
55 
56 #include <linux/device.h>
57 #include <linux/kernel.h>
58 #include <linux/module.h>
59 
60 #include <linux/ntb.h>
61 #include <linux/pci.h>
62 
63 #define DRIVER_NAME			"ntb"
64 #define DRIVER_DESCRIPTION		"PCIe NTB Driver Framework"
65 
66 #define DRIVER_VERSION			"1.0"
67 #define DRIVER_RELDATE			"24 March 2015"
68 #define DRIVER_AUTHOR			"Allen Hubbe <Allen.Hubbe@emc.com>"
69 
70 MODULE_LICENSE("Dual BSD/GPL");
71 MODULE_VERSION(DRIVER_VERSION);
72 MODULE_AUTHOR(DRIVER_AUTHOR);
73 MODULE_DESCRIPTION(DRIVER_DESCRIPTION);
74 
75 static struct bus_type ntb_bus;
76 static void ntb_dev_release(struct device *dev);
77 
78 int __ntb_register_client(struct ntb_client *client, struct module *mod,
79 			  const char *mod_name)
80 {
81 	if (!client)
82 		return -EINVAL;
83 	if (!ntb_client_ops_is_valid(&client->ops))
84 		return -EINVAL;
85 
86 	memset(&client->drv, 0, sizeof(client->drv));
87 	client->drv.bus = &ntb_bus;
88 	client->drv.name = mod_name;
89 	client->drv.owner = mod;
90 
91 	return driver_register(&client->drv);
92 }
93 EXPORT_SYMBOL(__ntb_register_client);
94 
95 void ntb_unregister_client(struct ntb_client *client)
96 {
97 	driver_unregister(&client->drv);
98 }
99 EXPORT_SYMBOL(ntb_unregister_client);
100 
101 int ntb_register_device(struct ntb_dev *ntb)
102 {
103 	if (!ntb)
104 		return -EINVAL;
105 	if (!ntb->pdev)
106 		return -EINVAL;
107 	if (!ntb->ops)
108 		return -EINVAL;
109 	if (!ntb_dev_ops_is_valid(ntb->ops))
110 		return -EINVAL;
111 
112 	init_completion(&ntb->released);
113 
114 	ntb->dev.bus = &ntb_bus;
115 	ntb->dev.parent = &ntb->pdev->dev;
116 	ntb->dev.release = ntb_dev_release;
117 	dev_set_name(&ntb->dev, "%s", pci_name(ntb->pdev));
118 
119 	ntb->ctx = NULL;
120 	ntb->ctx_ops = NULL;
121 	spin_lock_init(&ntb->ctx_lock);
122 
123 	return device_register(&ntb->dev);
124 }
125 EXPORT_SYMBOL(ntb_register_device);
126 
127 void ntb_unregister_device(struct ntb_dev *ntb)
128 {
129 	device_unregister(&ntb->dev);
130 	wait_for_completion(&ntb->released);
131 }
132 EXPORT_SYMBOL(ntb_unregister_device);
133 
134 int ntb_set_ctx(struct ntb_dev *ntb, void *ctx,
135 		const struct ntb_ctx_ops *ctx_ops)
136 {
137 	unsigned long irqflags;
138 
139 	if (!ntb_ctx_ops_is_valid(ctx_ops))
140 		return -EINVAL;
141 	if (ntb->ctx_ops)
142 		return -EINVAL;
143 
144 	spin_lock_irqsave(&ntb->ctx_lock, irqflags);
145 	{
146 		ntb->ctx = ctx;
147 		ntb->ctx_ops = ctx_ops;
148 	}
149 	spin_unlock_irqrestore(&ntb->ctx_lock, irqflags);
150 
151 	return 0;
152 }
153 EXPORT_SYMBOL(ntb_set_ctx);
154 
155 void ntb_clear_ctx(struct ntb_dev *ntb)
156 {
157 	unsigned long irqflags;
158 
159 	spin_lock_irqsave(&ntb->ctx_lock, irqflags);
160 	{
161 		ntb->ctx_ops = NULL;
162 		ntb->ctx = NULL;
163 	}
164 	spin_unlock_irqrestore(&ntb->ctx_lock, irqflags);
165 }
166 EXPORT_SYMBOL(ntb_clear_ctx);
167 
168 void ntb_link_event(struct ntb_dev *ntb)
169 {
170 	unsigned long irqflags;
171 
172 	spin_lock_irqsave(&ntb->ctx_lock, irqflags);
173 	{
174 		if (ntb->ctx_ops && ntb->ctx_ops->link_event)
175 			ntb->ctx_ops->link_event(ntb->ctx);
176 	}
177 	spin_unlock_irqrestore(&ntb->ctx_lock, irqflags);
178 }
179 EXPORT_SYMBOL(ntb_link_event);
180 
181 void ntb_db_event(struct ntb_dev *ntb, int vector)
182 {
183 	unsigned long irqflags;
184 
185 	spin_lock_irqsave(&ntb->ctx_lock, irqflags);
186 	{
187 		if (ntb->ctx_ops && ntb->ctx_ops->db_event)
188 			ntb->ctx_ops->db_event(ntb->ctx, vector);
189 	}
190 	spin_unlock_irqrestore(&ntb->ctx_lock, irqflags);
191 }
192 EXPORT_SYMBOL(ntb_db_event);
193 
194 void ntb_msg_event(struct ntb_dev *ntb)
195 {
196 	unsigned long irqflags;
197 
198 	spin_lock_irqsave(&ntb->ctx_lock, irqflags);
199 	{
200 		if (ntb->ctx_ops && ntb->ctx_ops->msg_event)
201 			ntb->ctx_ops->msg_event(ntb->ctx);
202 	}
203 	spin_unlock_irqrestore(&ntb->ctx_lock, irqflags);
204 }
205 EXPORT_SYMBOL(ntb_msg_event);
206 
207 int ntb_default_port_number(struct ntb_dev *ntb)
208 {
209 	switch (ntb->topo) {
210 	case NTB_TOPO_PRI:
211 	case NTB_TOPO_B2B_USD:
212 		return NTB_PORT_PRI_USD;
213 	case NTB_TOPO_SEC:
214 	case NTB_TOPO_B2B_DSD:
215 		return NTB_PORT_SEC_DSD;
216 	default:
217 		break;
218 	}
219 
220 	return -EINVAL;
221 }
222 EXPORT_SYMBOL(ntb_default_port_number);
223 
224 int ntb_default_peer_port_count(struct ntb_dev *ntb)
225 {
226 	return NTB_DEF_PEER_CNT;
227 }
228 EXPORT_SYMBOL(ntb_default_peer_port_count);
229 
230 int ntb_default_peer_port_number(struct ntb_dev *ntb, int pidx)
231 {
232 	if (pidx != NTB_DEF_PEER_IDX)
233 		return -EINVAL;
234 
235 	switch (ntb->topo) {
236 	case NTB_TOPO_PRI:
237 	case NTB_TOPO_B2B_USD:
238 		return NTB_PORT_SEC_DSD;
239 	case NTB_TOPO_SEC:
240 	case NTB_TOPO_B2B_DSD:
241 		return NTB_PORT_PRI_USD;
242 	default:
243 		break;
244 	}
245 
246 	return -EINVAL;
247 }
248 EXPORT_SYMBOL(ntb_default_peer_port_number);
249 
250 int ntb_default_peer_port_idx(struct ntb_dev *ntb, int port)
251 {
252 	int peer_port = ntb_default_peer_port_number(ntb, NTB_DEF_PEER_IDX);
253 
254 	if (peer_port == -EINVAL || port != peer_port)
255 		return -EINVAL;
256 
257 	return 0;
258 }
259 EXPORT_SYMBOL(ntb_default_peer_port_idx);
260 
261 static int ntb_probe(struct device *dev)
262 {
263 	struct ntb_dev *ntb;
264 	struct ntb_client *client;
265 	int rc;
266 
267 	get_device(dev);
268 	ntb = dev_ntb(dev);
269 	client = drv_ntb_client(dev->driver);
270 
271 	rc = client->ops.probe(client, ntb);
272 	if (rc)
273 		put_device(dev);
274 
275 	return rc;
276 }
277 
278 static int ntb_remove(struct device *dev)
279 {
280 	struct ntb_dev *ntb;
281 	struct ntb_client *client;
282 
283 	if (dev->driver) {
284 		ntb = dev_ntb(dev);
285 		client = drv_ntb_client(dev->driver);
286 
287 		client->ops.remove(client, ntb);
288 		put_device(dev);
289 	}
290 
291 	return 0;
292 }
293 
294 static void ntb_dev_release(struct device *dev)
295 {
296 	struct ntb_dev *ntb = dev_ntb(dev);
297 
298 	complete(&ntb->released);
299 }
300 
301 static struct bus_type ntb_bus = {
302 	.name = "ntb",
303 	.probe = ntb_probe,
304 	.remove = ntb_remove,
305 };
306 
307 static int __init ntb_driver_init(void)
308 {
309 	return bus_register(&ntb_bus);
310 }
311 module_init(ntb_driver_init);
312 
313 static void __exit ntb_driver_exit(void)
314 {
315 	bus_unregister(&ntb_bus);
316 }
317 module_exit(ntb_driver_exit);
318 
319