Commit | Line | Data |
---|---|---|
0194621b DD |
1 | /* |
2 | * Copyright(c) 2015 Intel Corporation. | |
3 | * | |
4 | * This file is provided under a dual BSD/GPLv2 license. When using or | |
5 | * redistributing this file, you may do so under either license. | |
6 | * | |
7 | * GPL LICENSE SUMMARY | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of version 2 of the GNU General Public License as | |
11 | * published by the Free Software Foundation. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, but | |
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 | * General Public License for more details. | |
17 | * | |
18 | * BSD LICENSE | |
19 | * | |
20 | * Redistribution and use in source and binary forms, with or without | |
21 | * modification, are permitted provided that the following conditions | |
22 | * are met: | |
23 | * | |
24 | * - Redistributions of source code must retain the above copyright | |
25 | * notice, this list of conditions and the following disclaimer. | |
26 | * - Redistributions in binary form must reproduce the above copyright | |
27 | * notice, this list of conditions and the following disclaimer in | |
28 | * the documentation and/or other materials provided with the | |
29 | * distribution. | |
30 | * - Neither the name of Intel Corporation nor the names of its | |
31 | * contributors may be used to endorse or promote products derived | |
32 | * from this software without specific prior written permission. | |
33 | * | |
34 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
35 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
36 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
37 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
38 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
39 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
40 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
41 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
42 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
43 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
44 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
45 | * | |
46 | */ | |
47 | ||
48 | #include <linux/module.h> | |
49 | #include <linux/kernel.h> | |
50 | #include "vt.h" | |
51 | ||
52 | MODULE_LICENSE("Dual BSD/GPL"); | |
53 | MODULE_DESCRIPTION("RDMA Verbs Transport Library"); | |
54 | ||
55 | static int rvt_init(void) | |
56 | { | |
57 | /* Do any work needed prior to drivers calling for registration*/ | |
58 | return 0; | |
59 | } | |
60 | module_init(rvt_init); | |
61 | ||
62 | static void rvt_cleanup(void) | |
63 | { | |
64 | } | |
65 | module_exit(rvt_cleanup); | |
66 | ||
19ef1edd DD |
67 | static int rvt_query_device(struct ib_device *ibdev, |
68 | struct ib_device_attr *props, | |
69 | struct ib_udata *uhw) | |
70 | { | |
71 | /* | |
72 | * Return rvt_dev_info.props contents | |
73 | */ | |
74 | return -EOPNOTSUPP; | |
75 | } | |
76 | ||
77 | static int rvt_modify_device(struct ib_device *device, | |
78 | int device_modify_mask, | |
79 | struct ib_device_modify *device_modify) | |
80 | { | |
81 | /* | |
82 | * Change dev props. Planned support is for node desc change and sys | |
83 | * guid change only. This matches hfi1 and qib behavior. Other drivers | |
84 | * that support existing modifications will need to add their support. | |
85 | */ | |
86 | ||
87 | /* | |
88 | * VT-DRIVER-API: node_desc_change() | |
89 | * VT-DRIVER-API: sys_guid_change() | |
90 | */ | |
91 | return -EOPNOTSUPP; | |
92 | } | |
93 | ||
765525c1 DD |
94 | /** |
95 | * rvt_query_port: Passes the query port call to the driver | |
96 | * @ibdev: Verbs IB dev | |
97 | * @port: port number | |
98 | * @props: structure to hold returned properties | |
99 | * | |
100 | * Returns 0 on success | |
101 | */ | |
102 | static int rvt_query_port(struct ib_device *ibdev, u8 port, | |
103 | struct ib_port_attr *props) | |
104 | { | |
105 | /* | |
106 | * VT-DRIVER-API: query_port_state() | |
107 | * driver returns pretty much everything in ib_port_attr | |
108 | */ | |
109 | return -EOPNOTSUPP; | |
110 | } | |
111 | ||
112 | /** | |
113 | * rvt_modify_port | |
114 | * @ibdev: Verbs IB dev | |
115 | * @port: Port number | |
116 | * @port_modify_mask: How to change the port | |
117 | * @props: Structure to fill in | |
118 | * | |
119 | * Returns 0 on success | |
120 | */ | |
121 | static int rvt_modify_port(struct ib_device *ibdev, u8 port, | |
122 | int port_modify_mask, struct ib_port_modify *props) | |
123 | { | |
124 | /* | |
125 | * VT-DRIVER-API: set_link_state() | |
126 | * driver will set the link state using the IB enumeration | |
127 | * | |
128 | * VT-DRIVER-API: clear_qkey_violations() | |
129 | * clears driver private qkey counter | |
130 | * | |
131 | * VT-DRIVER-API: get_lid() | |
132 | * driver needs to return the LID | |
133 | * | |
134 | * TBD: send_trap() and post_mad_send() need examined to see where they | |
135 | * fit in. | |
136 | */ | |
137 | return -EOPNOTSUPP; | |
138 | } | |
139 | ||
30588643 DD |
140 | /** |
141 | * rvt_query_pkey - Return a pkey from the table at a given index | |
142 | * @ibdev: Verbs IB dev | |
143 | * @port: Port number | |
144 | * @intex: Index into pkey table | |
145 | * | |
146 | * Returns 0 on failure pkey otherwise | |
147 | */ | |
148 | static int rvt_query_pkey(struct ib_device *ibdev, u8 port, u16 index, | |
149 | u16 *pkey) | |
150 | { | |
151 | /* | |
152 | * Driver will be responsible for keeping rvt_dev_info.pkey_table up to | |
153 | * date. This function will just return that value. There is no need to | |
154 | * lock, if a stale value is read and sent to the user so be it there is | |
155 | * no way to protect against that anyway. | |
156 | */ | |
157 | return 0; | |
158 | } | |
159 | ||
2d092e11 DD |
160 | /** |
161 | * rvt_query_gid - Return a gid from the table | |
162 | * @ibdev: Verbs IB dev | |
163 | * @port: Port number | |
164 | * @index: = Index in table | |
165 | * @gid: Gid to return | |
166 | * | |
167 | * Returns 0 on success | |
168 | */ | |
169 | static int rvt_query_gid(struct ib_device *ibdev, u8 port, | |
170 | int index, union ib_gid *gid) | |
171 | { | |
172 | /* | |
173 | * Driver is responsible for updating the guid table. Which will be used | |
174 | * to craft the return value. This will work similar to how query_pkey() | |
175 | * is being done. | |
176 | */ | |
177 | ||
178 | return -EOPNOTSUPP; | |
179 | } | |
180 | ||
c4ed7d8b DD |
181 | /** |
182 | * rvt_alloc_ucontext - Allocate a user context | |
183 | * @ibdev: Vers IB dev | |
184 | * @data: User data allocated | |
185 | */ | |
186 | static struct ib_ucontext *rvt_alloc_ucontext(struct ib_device *ibdev, | |
187 | struct ib_udata *udata) | |
188 | { | |
189 | return ERR_PTR(-EOPNOTSUPP); | |
190 | } | |
191 | ||
192 | /** | |
193 | *rvt_dealloc_ucontext - Free a user context | |
194 | *@context - Free this | |
195 | */ | |
196 | static int rvt_dealloc_ucontext(struct ib_ucontext *context) | |
197 | { | |
198 | return -EOPNOTSUPP; | |
199 | } | |
200 | ||
e6a8818a DD |
201 | static int rvt_get_port_immutable(struct ib_device *ibdev, u8 port_num, |
202 | struct ib_port_immutable *immutable) | |
203 | { | |
204 | return -EOPNOTSUPP; | |
205 | } | |
206 | ||
4997870a DD |
207 | /* |
208 | * Check driver override. If driver passes a value use it, otherwise we use our | |
209 | * own value. | |
210 | */ | |
211 | #define CHECK_DRIVER_OVERRIDE(rdi, x) \ | |
212 | rdi->ibdev.x = rdi->ibdev.x ? : rvt_ ##x | |
213 | ||
0194621b DD |
214 | int rvt_register_device(struct rvt_dev_info *rdi) |
215 | { | |
b534875d | 216 | /* Validate that drivers have provided the right information */ |
7b1e2099 DD |
217 | int ret = 0; |
218 | ||
0194621b DD |
219 | if (!rdi) |
220 | return -EINVAL; | |
221 | ||
b534875d DD |
222 | if ((!rdi->driver_f.port_callback) || |
223 | (!rdi->driver_f.get_card_name) || | |
119a8e70 KH |
224 | (!rdi->driver_f.get_pci_dev) || |
225 | (!rdi->driver_f.check_ah)) { | |
0acb0cc7 | 226 | pr_err("Driver not supporting req func\n"); |
b534875d DD |
227 | return -EINVAL; |
228 | } | |
229 | ||
0acb0cc7 DD |
230 | if (!rdi->dparms.nports) { |
231 | rvt_pr_err(rdi, "Driver says it has no ports.\n"); | |
232 | return -EINVAL; | |
233 | } | |
234 | ||
235 | rdi->ports = kcalloc(rdi->dparms.nports, | |
236 | sizeof(struct rvt_ibport **), | |
237 | GFP_KERNEL); | |
238 | if (!rdi->ports) { | |
239 | rvt_pr_err(rdi, "Could not allocate port mem.\n"); | |
240 | return -ENOMEM; | |
241 | } | |
242 | ||
b534875d DD |
243 | /* Once we get past here we can use the rvt_pr macros */ |
244 | ||
19ef1edd DD |
245 | /* Dev Ops */ |
246 | CHECK_DRIVER_OVERRIDE(rdi, query_device); | |
247 | CHECK_DRIVER_OVERRIDE(rdi, modify_device); | |
765525c1 DD |
248 | CHECK_DRIVER_OVERRIDE(rdi, query_port); |
249 | CHECK_DRIVER_OVERRIDE(rdi, modify_port); | |
30588643 | 250 | CHECK_DRIVER_OVERRIDE(rdi, query_pkey); |
2d092e11 | 251 | CHECK_DRIVER_OVERRIDE(rdi, query_gid); |
c4ed7d8b DD |
252 | CHECK_DRIVER_OVERRIDE(rdi, alloc_ucontext); |
253 | CHECK_DRIVER_OVERRIDE(rdi, dealloc_ucontext); | |
e6a8818a | 254 | CHECK_DRIVER_OVERRIDE(rdi, get_port_immutable); |
19ef1edd | 255 | |
b518d3e6 | 256 | /* Queue Pairs */ |
0acb0cc7 DD |
257 | ret = rvt_driver_qp_init(rdi); |
258 | if (ret) { | |
259 | pr_err("Error in driver QP init.\n"); | |
260 | return -EINVAL; | |
261 | } | |
262 | ||
b518d3e6 DD |
263 | CHECK_DRIVER_OVERRIDE(rdi, create_qp); |
264 | CHECK_DRIVER_OVERRIDE(rdi, modify_qp); | |
265 | CHECK_DRIVER_OVERRIDE(rdi, destroy_qp); | |
266 | CHECK_DRIVER_OVERRIDE(rdi, query_qp); | |
8cf4020b DD |
267 | CHECK_DRIVER_OVERRIDE(rdi, post_send); |
268 | CHECK_DRIVER_OVERRIDE(rdi, post_recv); | |
269 | CHECK_DRIVER_OVERRIDE(rdi, post_srq_recv); | |
b518d3e6 | 270 | |
4c1e4972 DD |
271 | /* Address Handle */ |
272 | CHECK_DRIVER_OVERRIDE(rdi, create_ah); | |
273 | CHECK_DRIVER_OVERRIDE(rdi, destroy_ah); | |
274 | CHECK_DRIVER_OVERRIDE(rdi, modify_ah); | |
275 | CHECK_DRIVER_OVERRIDE(rdi, query_ah); | |
119a8e70 KH |
276 | spin_lock_init(&rdi->n_ahs_lock); |
277 | rdi->n_ahs_allocated = 0; | |
4c1e4972 | 278 | |
aad9158b DD |
279 | /* Shared Receive Queue */ |
280 | CHECK_DRIVER_OVERRIDE(rdi, create_srq); | |
281 | CHECK_DRIVER_OVERRIDE(rdi, modify_srq); | |
282 | CHECK_DRIVER_OVERRIDE(rdi, destroy_srq); | |
283 | CHECK_DRIVER_OVERRIDE(rdi, query_srq); | |
284 | ||
9fa25171 DD |
285 | /* Multicast */ |
286 | CHECK_DRIVER_OVERRIDE(rdi, attach_mcast); | |
287 | CHECK_DRIVER_OVERRIDE(rdi, detach_mcast); | |
288 | ||
2a055eb7 | 289 | /* Mem Region */ |
7b1e2099 DD |
290 | ret = rvt_driver_mr_init(rdi); |
291 | if (ret) { | |
36055a06 | 292 | pr_err("Error in driver MR init.\n"); |
7b1e2099 DD |
293 | goto bail_no_mr; |
294 | } | |
295 | ||
2a055eb7 DD |
296 | CHECK_DRIVER_OVERRIDE(rdi, get_dma_mr); |
297 | CHECK_DRIVER_OVERRIDE(rdi, reg_user_mr); | |
298 | CHECK_DRIVER_OVERRIDE(rdi, dereg_mr); | |
299 | CHECK_DRIVER_OVERRIDE(rdi, alloc_mr); | |
300 | CHECK_DRIVER_OVERRIDE(rdi, alloc_fmr); | |
301 | CHECK_DRIVER_OVERRIDE(rdi, map_phys_fmr); | |
302 | CHECK_DRIVER_OVERRIDE(rdi, unmap_fmr); | |
303 | CHECK_DRIVER_OVERRIDE(rdi, dealloc_fmr); | |
dc21752e | 304 | CHECK_DRIVER_OVERRIDE(rdi, mmap); |
2a055eb7 | 305 | |
cf16335a DD |
306 | /* Completion queues */ |
307 | CHECK_DRIVER_OVERRIDE(rdi, create_cq); | |
308 | CHECK_DRIVER_OVERRIDE(rdi, destroy_cq); | |
309 | CHECK_DRIVER_OVERRIDE(rdi, poll_cq); | |
310 | CHECK_DRIVER_OVERRIDE(rdi, req_notify_cq); | |
311 | CHECK_DRIVER_OVERRIDE(rdi, resize_cq); | |
312 | ||
8afd32eb | 313 | /* DMA Operations */ |
c1b332bc DD |
314 | rdi->ibdev.dma_ops = |
315 | rdi->ibdev.dma_ops ? : &rvt_default_dma_mapping_ops; | |
316 | ||
8afd32eb | 317 | /* Protection Domain */ |
4997870a DD |
318 | CHECK_DRIVER_OVERRIDE(rdi, alloc_pd); |
319 | CHECK_DRIVER_OVERRIDE(rdi, dealloc_pd); | |
8afd32eb DD |
320 | spin_lock_init(&rdi->n_pds_lock); |
321 | rdi->n_pds_allocated = 0; | |
322 | ||
7b1e2099 DD |
323 | /* We are now good to announce we exist */ |
324 | ret = ib_register_device(&rdi->ibdev, rdi->driver_f.port_callback); | |
325 | if (ret) { | |
326 | rvt_pr_err(rdi, "Failed to register driver with ib core.\n"); | |
327 | goto bail_mr; | |
328 | } | |
329 | ||
b534875d | 330 | rvt_pr_info(rdi, "Registration with rdmavt done.\n"); |
7b1e2099 | 331 | return ret; |
aec57787 | 332 | |
7b1e2099 DD |
333 | bail_mr: |
334 | rvt_mr_exit(rdi); | |
335 | ||
336 | bail_no_mr: | |
0acb0cc7 DD |
337 | rvt_qp_exit(rdi); |
338 | ||
7b1e2099 | 339 | return ret; |
0194621b DD |
340 | } |
341 | EXPORT_SYMBOL(rvt_register_device); | |
342 | ||
343 | void rvt_unregister_device(struct rvt_dev_info *rdi) | |
344 | { | |
345 | if (!rdi) | |
346 | return; | |
347 | ||
348 | ib_unregister_device(&rdi->ibdev); | |
7b1e2099 | 349 | rvt_mr_exit(rdi); |
0194621b DD |
350 | } |
351 | EXPORT_SYMBOL(rvt_unregister_device); | |
f3d01bbc DD |
352 | |
353 | /* | |
354 | * Keep track of a list of ports. No need to have a detach port. | |
355 | * They persist until the driver goes away. | |
356 | */ | |
357 | void rvt_attach_port(struct rvt_dev_info *rdi, struct rvt_ibport *port, | |
358 | int portnum) | |
359 | { | |
360 | rdi->ports[portnum] = port; | |
361 | } | |
362 | EXPORT_SYMBOL(rvt_attach_port); |