blob: e711de400a01aaa27216318b82770bdb3647161e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (c) 2004 Topspin Communications. All rights reserved.
Roland Dreier2a1d9b72005-08-10 23:03:10 -07003 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * This software is available to you under a choice of one of two
6 * licenses. You may choose to be licensed under the terms of the GNU
7 * General Public License (GPL) Version 2, available from the file
8 * COPYING in the main directory of this source tree, or the
9 * OpenIB.org BSD license below:
10 *
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
13 * conditions are met:
14 *
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer.
18 *
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31 * SOFTWARE.
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 */
33
34#include <linux/module.h>
35#include <linux/string.h>
36#include <linux/errno.h>
Ahmed S. Darwish9a6b0902007-02-06 18:07:25 +020037#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/slab.h>
39#include <linux/init.h>
Ingo Molnar95ed6442006-01-13 14:51:39 -080040#include <linux/mutex.h>
Roland Dreierb2cbae22011-05-20 11:46:11 -070041#include <rdma/rdma_netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43#include "core_priv.h"
44
45MODULE_AUTHOR("Roland Dreier");
46MODULE_DESCRIPTION("core kernel InfiniBand API");
47MODULE_LICENSE("Dual BSD/GPL");
48
49struct ib_client_data {
50 struct list_head list;
51 struct ib_client *client;
52 void * data;
53};
54
Tejun Heof0626712010-10-19 15:24:36 +000055struct workqueue_struct *ib_wq;
56EXPORT_SYMBOL_GPL(ib_wq);
57
Linus Torvalds1da177e2005-04-16 15:20:36 -070058static LIST_HEAD(device_list);
59static LIST_HEAD(client_list);
60
61/*
Ingo Molnar95ed6442006-01-13 14:51:39 -080062 * device_mutex protects access to both device_list and client_list.
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 * There's no real point to using multiple locks or something fancier
64 * like an rwsem: we always access both lists, and we're always
65 * modifying one list or the other list. In any case this is not a
66 * hot path so there's no point in trying to optimize.
67 */
Ingo Molnar95ed6442006-01-13 14:51:39 -080068static DEFINE_MUTEX(device_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
70static int ib_device_check_mandatory(struct ib_device *device)
71{
72#define IB_MANDATORY_FUNC(x) { offsetof(struct ib_device, x), #x }
73 static const struct {
74 size_t offset;
75 char *name;
76 } mandatory_table[] = {
77 IB_MANDATORY_FUNC(query_device),
78 IB_MANDATORY_FUNC(query_port),
79 IB_MANDATORY_FUNC(query_pkey),
80 IB_MANDATORY_FUNC(query_gid),
81 IB_MANDATORY_FUNC(alloc_pd),
82 IB_MANDATORY_FUNC(dealloc_pd),
83 IB_MANDATORY_FUNC(create_ah),
84 IB_MANDATORY_FUNC(destroy_ah),
85 IB_MANDATORY_FUNC(create_qp),
86 IB_MANDATORY_FUNC(modify_qp),
87 IB_MANDATORY_FUNC(destroy_qp),
88 IB_MANDATORY_FUNC(post_send),
89 IB_MANDATORY_FUNC(post_recv),
90 IB_MANDATORY_FUNC(create_cq),
91 IB_MANDATORY_FUNC(destroy_cq),
92 IB_MANDATORY_FUNC(poll_cq),
93 IB_MANDATORY_FUNC(req_notify_cq),
94 IB_MANDATORY_FUNC(get_dma_mr),
95 IB_MANDATORY_FUNC(dereg_mr)
96 };
97 int i;
98
Ahmed S. Darwish9a6b0902007-02-06 18:07:25 +020099 for (i = 0; i < ARRAY_SIZE(mandatory_table); ++i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 if (!*(void **) ((void *) device + mandatory_table[i].offset)) {
101 printk(KERN_WARNING "Device %s is missing mandatory function %s\n",
102 device->name, mandatory_table[i].name);
103 return -EINVAL;
104 }
105 }
106
107 return 0;
108}
109
110static struct ib_device *__ib_device_get_by_name(const char *name)
111{
112 struct ib_device *device;
113
114 list_for_each_entry(device, &device_list, core_list)
115 if (!strncmp(name, device->name, IB_DEVICE_NAME_MAX))
116 return device;
117
118 return NULL;
119}
120
121
122static int alloc_name(char *name)
123{
Roland Dreier65d470b2007-10-09 19:59:04 -0700124 unsigned long *inuse;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 char buf[IB_DEVICE_NAME_MAX];
126 struct ib_device *device;
127 int i;
128
Roland Dreier65d470b2007-10-09 19:59:04 -0700129 inuse = (unsigned long *) get_zeroed_page(GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 if (!inuse)
131 return -ENOMEM;
132
133 list_for_each_entry(device, &device_list, core_list) {
134 if (!sscanf(device->name, name, &i))
135 continue;
136 if (i < 0 || i >= PAGE_SIZE * 8)
137 continue;
138 snprintf(buf, sizeof buf, name, i);
139 if (!strncmp(buf, device->name, IB_DEVICE_NAME_MAX))
140 set_bit(i, inuse);
141 }
142
143 i = find_first_zero_bit(inuse, PAGE_SIZE * 8);
144 free_page((unsigned long) inuse);
145 snprintf(buf, sizeof buf, name, i);
146
147 if (__ib_device_get_by_name(buf))
148 return -ENFILE;
149
150 strlcpy(name, buf, IB_DEVICE_NAME_MAX);
151 return 0;
152}
153
Yosef Etigin5eb620c2007-05-14 07:26:51 +0300154static int start_port(struct ib_device *device)
155{
156 return (device->node_type == RDMA_NODE_IB_SWITCH) ? 0 : 1;
157}
158
159
160static int end_port(struct ib_device *device)
161{
162 return (device->node_type == RDMA_NODE_IB_SWITCH) ?
163 0 : device->phys_port_cnt;
164}
165
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166/**
167 * ib_alloc_device - allocate an IB device struct
168 * @size:size of structure to allocate
169 *
170 * Low-level drivers should use ib_alloc_device() to allocate &struct
171 * ib_device. @size is the size of the structure to be allocated,
172 * including any private data used by the low-level driver.
173 * ib_dealloc_device() must be used to free structures allocated with
174 * ib_alloc_device().
175 */
176struct ib_device *ib_alloc_device(size_t size)
177{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 BUG_ON(size < sizeof (struct ib_device));
179
Roland Dreierde6eb662005-11-02 07:23:14 -0800180 return kzalloc(size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181}
182EXPORT_SYMBOL(ib_alloc_device);
183
184/**
185 * ib_dealloc_device - free an IB device struct
186 * @device:structure to free
187 *
188 * Free a structure allocated with ib_alloc_device().
189 */
190void ib_dealloc_device(struct ib_device *device)
191{
192 if (device->reg_state == IB_DEV_UNINITIALIZED) {
193 kfree(device);
194 return;
195 }
196
197 BUG_ON(device->reg_state != IB_DEV_UNREGISTERED);
198
Roland Dreier9206dff2009-02-25 13:27:46 -0800199 kobject_put(&device->dev.kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200}
201EXPORT_SYMBOL(ib_dealloc_device);
202
203static int add_client_context(struct ib_device *device, struct ib_client *client)
204{
205 struct ib_client_data *context;
206 unsigned long flags;
207
208 context = kmalloc(sizeof *context, GFP_KERNEL);
209 if (!context) {
210 printk(KERN_WARNING "Couldn't allocate client context for %s/%s\n",
211 device->name, client->name);
212 return -ENOMEM;
213 }
214
215 context->client = client;
216 context->data = NULL;
217
218 spin_lock_irqsave(&device->client_data_lock, flags);
219 list_add(&context->list, &device->client_data_list);
220 spin_unlock_irqrestore(&device->client_data_lock, flags);
221
222 return 0;
223}
224
Yosef Etigin5eb620c2007-05-14 07:26:51 +0300225static int read_port_table_lengths(struct ib_device *device)
226{
227 struct ib_port_attr *tprops = NULL;
228 int num_ports, ret = -ENOMEM;
229 u8 port_index;
230
231 tprops = kmalloc(sizeof *tprops, GFP_KERNEL);
232 if (!tprops)
233 goto out;
234
235 num_ports = end_port(device) - start_port(device) + 1;
236
237 device->pkey_tbl_len = kmalloc(sizeof *device->pkey_tbl_len * num_ports,
238 GFP_KERNEL);
239 device->gid_tbl_len = kmalloc(sizeof *device->gid_tbl_len * num_ports,
240 GFP_KERNEL);
241 if (!device->pkey_tbl_len || !device->gid_tbl_len)
242 goto err;
243
244 for (port_index = 0; port_index < num_ports; ++port_index) {
245 ret = ib_query_port(device, port_index + start_port(device),
246 tprops);
247 if (ret)
248 goto err;
249 device->pkey_tbl_len[port_index] = tprops->pkey_tbl_len;
250 device->gid_tbl_len[port_index] = tprops->gid_tbl_len;
251 }
252
253 ret = 0;
254 goto out;
255
256err:
257 kfree(device->gid_tbl_len);
258 kfree(device->pkey_tbl_len);
259out:
260 kfree(tprops);
261 return ret;
262}
263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264/**
265 * ib_register_device - Register an IB device with IB core
266 * @device:Device to register
267 *
268 * Low-level drivers use ib_register_device() to register their
269 * devices with the IB core. All registered clients will receive a
270 * callback for each device that is added. @device must be allocated
271 * with ib_alloc_device().
272 */
Ralph Campbell9a6edb62010-05-06 17:03:25 -0700273int ib_register_device(struct ib_device *device,
274 int (*port_callback)(struct ib_device *,
275 u8, struct kobject *))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276{
277 int ret;
278
Ingo Molnar95ed6442006-01-13 14:51:39 -0800279 mutex_lock(&device_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
281 if (strchr(device->name, '%')) {
282 ret = alloc_name(device->name);
283 if (ret)
284 goto out;
285 }
286
287 if (ib_device_check_mandatory(device)) {
288 ret = -EINVAL;
289 goto out;
290 }
291
292 INIT_LIST_HEAD(&device->event_handler_list);
293 INIT_LIST_HEAD(&device->client_data_list);
294 spin_lock_init(&device->event_handler_lock);
295 spin_lock_init(&device->client_data_lock);
296
Yosef Etigin5eb620c2007-05-14 07:26:51 +0300297 ret = read_port_table_lengths(device);
298 if (ret) {
299 printk(KERN_WARNING "Couldn't create table lengths cache for device %s\n",
300 device->name);
301 goto out;
302 }
303
Ralph Campbell9a6edb62010-05-06 17:03:25 -0700304 ret = ib_device_register_sysfs(device, port_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 if (ret) {
306 printk(KERN_WARNING "Couldn't register device %s with driver model\n",
307 device->name);
Yosef Etigin5eb620c2007-05-14 07:26:51 +0300308 kfree(device->gid_tbl_len);
309 kfree(device->pkey_tbl_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 goto out;
311 }
312
313 list_add_tail(&device->core_list, &device_list);
314
315 device->reg_state = IB_DEV_REGISTERED;
316
317 {
318 struct ib_client *client;
319
320 list_for_each_entry(client, &client_list, list)
321 if (client->add && !add_client_context(device, client))
322 client->add(device);
323 }
324
325 out:
Ingo Molnar95ed6442006-01-13 14:51:39 -0800326 mutex_unlock(&device_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 return ret;
328}
329EXPORT_SYMBOL(ib_register_device);
330
331/**
332 * ib_unregister_device - Unregister an IB device
333 * @device:Device to unregister
334 *
335 * Unregister an IB device. All clients will receive a remove callback.
336 */
337void ib_unregister_device(struct ib_device *device)
338{
339 struct ib_client *client;
340 struct ib_client_data *context, *tmp;
341 unsigned long flags;
342
Ingo Molnar95ed6442006-01-13 14:51:39 -0800343 mutex_lock(&device_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
345 list_for_each_entry_reverse(client, &client_list, list)
346 if (client->remove)
347 client->remove(device);
348
349 list_del(&device->core_list);
350
Yosef Etigin5eb620c2007-05-14 07:26:51 +0300351 kfree(device->gid_tbl_len);
352 kfree(device->pkey_tbl_len);
353
Ingo Molnar95ed6442006-01-13 14:51:39 -0800354 mutex_unlock(&device_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Roland Dreier9206dff2009-02-25 13:27:46 -0800356 ib_device_unregister_sysfs(device);
357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 spin_lock_irqsave(&device->client_data_lock, flags);
359 list_for_each_entry_safe(context, tmp, &device->client_data_list, list)
360 kfree(context);
361 spin_unlock_irqrestore(&device->client_data_lock, flags);
362
363 device->reg_state = IB_DEV_UNREGISTERED;
364}
365EXPORT_SYMBOL(ib_unregister_device);
366
367/**
368 * ib_register_client - Register an IB client
369 * @client:Client to register
370 *
371 * Upper level users of the IB drivers can use ib_register_client() to
372 * register callbacks for IB device addition and removal. When an IB
373 * device is added, each registered client's add method will be called
374 * (in the order the clients were registered), and when a device is
375 * removed, each client's remove method will be called (in the reverse
376 * order that clients were registered). In addition, when
377 * ib_register_client() is called, the client will receive an add
378 * callback for all devices already registered.
379 */
380int ib_register_client(struct ib_client *client)
381{
382 struct ib_device *device;
383
Ingo Molnar95ed6442006-01-13 14:51:39 -0800384 mutex_lock(&device_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
386 list_add_tail(&client->list, &client_list);
387 list_for_each_entry(device, &device_list, core_list)
388 if (client->add && !add_client_context(device, client))
389 client->add(device);
390
Ingo Molnar95ed6442006-01-13 14:51:39 -0800391 mutex_unlock(&device_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
393 return 0;
394}
395EXPORT_SYMBOL(ib_register_client);
396
397/**
398 * ib_unregister_client - Unregister an IB client
399 * @client:Client to unregister
400 *
401 * Upper level users use ib_unregister_client() to remove their client
402 * registration. When ib_unregister_client() is called, the client
403 * will receive a remove callback for each IB device still registered.
404 */
405void ib_unregister_client(struct ib_client *client)
406{
407 struct ib_client_data *context, *tmp;
408 struct ib_device *device;
409 unsigned long flags;
410
Ingo Molnar95ed6442006-01-13 14:51:39 -0800411 mutex_lock(&device_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
413 list_for_each_entry(device, &device_list, core_list) {
414 if (client->remove)
415 client->remove(device);
416
417 spin_lock_irqsave(&device->client_data_lock, flags);
418 list_for_each_entry_safe(context, tmp, &device->client_data_list, list)
419 if (context->client == client) {
420 list_del(&context->list);
421 kfree(context);
422 }
423 spin_unlock_irqrestore(&device->client_data_lock, flags);
424 }
425 list_del(&client->list);
426
Ingo Molnar95ed6442006-01-13 14:51:39 -0800427 mutex_unlock(&device_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428}
429EXPORT_SYMBOL(ib_unregister_client);
430
431/**
432 * ib_get_client_data - Get IB client context
433 * @device:Device to get context for
434 * @client:Client to get context for
435 *
436 * ib_get_client_data() returns client context set with
437 * ib_set_client_data().
438 */
439void *ib_get_client_data(struct ib_device *device, struct ib_client *client)
440{
441 struct ib_client_data *context;
442 void *ret = NULL;
443 unsigned long flags;
444
445 spin_lock_irqsave(&device->client_data_lock, flags);
446 list_for_each_entry(context, &device->client_data_list, list)
447 if (context->client == client) {
448 ret = context->data;
449 break;
450 }
451 spin_unlock_irqrestore(&device->client_data_lock, flags);
452
453 return ret;
454}
455EXPORT_SYMBOL(ib_get_client_data);
456
457/**
Krishna Kumar9cd330d2006-09-22 15:22:58 -0700458 * ib_set_client_data - Set IB client context
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 * @device:Device to set context for
460 * @client:Client to set context for
461 * @data:Context to set
462 *
463 * ib_set_client_data() sets client context that can be retrieved with
464 * ib_get_client_data().
465 */
466void ib_set_client_data(struct ib_device *device, struct ib_client *client,
467 void *data)
468{
469 struct ib_client_data *context;
470 unsigned long flags;
471
472 spin_lock_irqsave(&device->client_data_lock, flags);
473 list_for_each_entry(context, &device->client_data_list, list)
474 if (context->client == client) {
475 context->data = data;
476 goto out;
477 }
478
479 printk(KERN_WARNING "No client context found for %s/%s\n",
480 device->name, client->name);
481
482out:
483 spin_unlock_irqrestore(&device->client_data_lock, flags);
484}
485EXPORT_SYMBOL(ib_set_client_data);
486
487/**
488 * ib_register_event_handler - Register an IB event handler
489 * @event_handler:Handler to register
490 *
491 * ib_register_event_handler() registers an event handler that will be
492 * called back when asynchronous IB events occur (as defined in
493 * chapter 11 of the InfiniBand Architecture Specification). This
494 * callback may occur in interrupt context.
495 */
496int ib_register_event_handler (struct ib_event_handler *event_handler)
497{
498 unsigned long flags;
499
500 spin_lock_irqsave(&event_handler->device->event_handler_lock, flags);
501 list_add_tail(&event_handler->list,
502 &event_handler->device->event_handler_list);
503 spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);
504
505 return 0;
506}
507EXPORT_SYMBOL(ib_register_event_handler);
508
509/**
510 * ib_unregister_event_handler - Unregister an event handler
511 * @event_handler:Handler to unregister
512 *
513 * Unregister an event handler registered with
514 * ib_register_event_handler().
515 */
516int ib_unregister_event_handler(struct ib_event_handler *event_handler)
517{
518 unsigned long flags;
519
520 spin_lock_irqsave(&event_handler->device->event_handler_lock, flags);
521 list_del(&event_handler->list);
522 spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);
523
524 return 0;
525}
526EXPORT_SYMBOL(ib_unregister_event_handler);
527
528/**
529 * ib_dispatch_event - Dispatch an asynchronous event
530 * @event:Event to dispatch
531 *
532 * Low-level drivers must call ib_dispatch_event() to dispatch the
533 * event to all registered event handlers when an asynchronous event
534 * occurs.
535 */
536void ib_dispatch_event(struct ib_event *event)
537{
538 unsigned long flags;
539 struct ib_event_handler *handler;
540
541 spin_lock_irqsave(&event->device->event_handler_lock, flags);
542
543 list_for_each_entry(handler, &event->device->event_handler_list, list)
544 handler->handler(handler, event);
545
546 spin_unlock_irqrestore(&event->device->event_handler_lock, flags);
547}
548EXPORT_SYMBOL(ib_dispatch_event);
549
550/**
551 * ib_query_device - Query IB device attributes
552 * @device:Device to query
553 * @device_attr:Device attributes
554 *
555 * ib_query_device() returns the attributes of a device through the
556 * @device_attr pointer.
557 */
558int ib_query_device(struct ib_device *device,
559 struct ib_device_attr *device_attr)
560{
561 return device->query_device(device, device_attr);
562}
563EXPORT_SYMBOL(ib_query_device);
564
565/**
566 * ib_query_port - Query IB port attributes
567 * @device:Device to query
568 * @port_num:Port number to query
569 * @port_attr:Port attributes
570 *
571 * ib_query_port() returns the attributes of a port through the
572 * @port_attr pointer.
573 */
574int ib_query_port(struct ib_device *device,
575 u8 port_num,
576 struct ib_port_attr *port_attr)
577{
Roland Dreier1af4c432007-05-19 08:51:54 -0700578 if (port_num < start_port(device) || port_num > end_port(device))
Roland Dreier116c0072005-10-03 09:32:33 -0700579 return -EINVAL;
580
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 return device->query_port(device, port_num, port_attr);
582}
583EXPORT_SYMBOL(ib_query_port);
584
585/**
586 * ib_query_gid - Get GID table entry
587 * @device:Device to query
588 * @port_num:Port number to query
589 * @index:GID table index to query
590 * @gid:Returned GID
591 *
592 * ib_query_gid() fetches the specified GID table entry.
593 */
594int ib_query_gid(struct ib_device *device,
595 u8 port_num, int index, union ib_gid *gid)
596{
597 return device->query_gid(device, port_num, index, gid);
598}
599EXPORT_SYMBOL(ib_query_gid);
600
601/**
602 * ib_query_pkey - Get P_Key table entry
603 * @device:Device to query
604 * @port_num:Port number to query
605 * @index:P_Key table index to query
606 * @pkey:Returned P_Key
607 *
608 * ib_query_pkey() fetches the specified P_Key table entry.
609 */
610int ib_query_pkey(struct ib_device *device,
611 u8 port_num, u16 index, u16 *pkey)
612{
613 return device->query_pkey(device, port_num, index, pkey);
614}
615EXPORT_SYMBOL(ib_query_pkey);
616
617/**
618 * ib_modify_device - Change IB device attributes
619 * @device:Device to modify
620 * @device_modify_mask:Mask of attributes to change
621 * @device_modify:New attribute values
622 *
623 * ib_modify_device() changes a device's attributes as specified by
624 * the @device_modify_mask and @device_modify structure.
625 */
626int ib_modify_device(struct ib_device *device,
627 int device_modify_mask,
628 struct ib_device_modify *device_modify)
629{
Bart Van Assche10e1b542011-06-18 16:35:42 +0000630 if (!device->modify_device)
631 return -ENOSYS;
632
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 return device->modify_device(device, device_modify_mask,
634 device_modify);
635}
636EXPORT_SYMBOL(ib_modify_device);
637
638/**
639 * ib_modify_port - Modifies the attributes for the specified port.
640 * @device: The device to modify.
641 * @port_num: The number of the port to modify.
642 * @port_modify_mask: Mask used to specify which attributes of the port
643 * to change.
644 * @port_modify: New attribute values for the port.
645 *
646 * ib_modify_port() changes a port's attributes as specified by the
647 * @port_modify_mask and @port_modify structure.
648 */
649int ib_modify_port(struct ib_device *device,
650 u8 port_num, int port_modify_mask,
651 struct ib_port_modify *port_modify)
652{
Bart Van Assche10e1b542011-06-18 16:35:42 +0000653 if (!device->modify_port)
654 return -ENOSYS;
655
Roland Dreier1af4c432007-05-19 08:51:54 -0700656 if (port_num < start_port(device) || port_num > end_port(device))
Roland Dreier116c0072005-10-03 09:32:33 -0700657 return -EINVAL;
658
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 return device->modify_port(device, port_num, port_modify_mask,
660 port_modify);
661}
662EXPORT_SYMBOL(ib_modify_port);
663
Yosef Etigin5eb620c2007-05-14 07:26:51 +0300664/**
665 * ib_find_gid - Returns the port number and GID table index where
666 * a specified GID value occurs.
667 * @device: The device to query.
668 * @gid: The GID value to search for.
669 * @port_num: The port number of the device where the GID value was found.
670 * @index: The index into the GID table where the GID was found. This
671 * parameter may be NULL.
672 */
673int ib_find_gid(struct ib_device *device, union ib_gid *gid,
674 u8 *port_num, u16 *index)
675{
676 union ib_gid tmp_gid;
677 int ret, port, i;
678
679 for (port = start_port(device); port <= end_port(device); ++port) {
680 for (i = 0; i < device->gid_tbl_len[port - start_port(device)]; ++i) {
681 ret = ib_query_gid(device, port, i, &tmp_gid);
682 if (ret)
683 return ret;
684 if (!memcmp(&tmp_gid, gid, sizeof *gid)) {
685 *port_num = port;
686 if (index)
687 *index = i;
688 return 0;
689 }
690 }
691 }
692
693 return -ENOENT;
694}
695EXPORT_SYMBOL(ib_find_gid);
696
697/**
698 * ib_find_pkey - Returns the PKey table index where a specified
699 * PKey value occurs.
700 * @device: The device to query.
701 * @port_num: The port number of the device to search for the PKey.
702 * @pkey: The PKey value to search for.
703 * @index: The index into the PKey table where the PKey was found.
704 */
705int ib_find_pkey(struct ib_device *device,
706 u8 port_num, u16 pkey, u16 *index)
707{
708 int ret, i;
709 u16 tmp_pkey;
710
711 for (i = 0; i < device->pkey_tbl_len[port_num - start_port(device)]; ++i) {
712 ret = ib_query_pkey(device, port_num, i, &tmp_pkey);
713 if (ret)
714 return ret;
715
Moni Shoua36026ec2007-07-23 10:07:42 +0300716 if ((pkey & 0x7fff) == (tmp_pkey & 0x7fff)) {
Yosef Etigin5eb620c2007-05-14 07:26:51 +0300717 *index = i;
718 return 0;
719 }
720 }
721
722 return -ENOENT;
723}
724EXPORT_SYMBOL(ib_find_pkey);
725
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726static int __init ib_core_init(void)
727{
728 int ret;
729
Tejun Heof0626712010-10-19 15:24:36 +0000730 ib_wq = alloc_workqueue("infiniband", 0, 0);
731 if (!ib_wq)
732 return -ENOMEM;
733
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 ret = ib_sysfs_setup();
Nir Muchtarfd75c782011-05-20 11:46:10 -0700735 if (ret) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 printk(KERN_WARNING "Couldn't create InfiniBand device class\n");
Nir Muchtarfd75c782011-05-20 11:46:10 -0700737 goto err;
738 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
Roland Dreierb2cbae22011-05-20 11:46:11 -0700740 ret = ibnl_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 if (ret) {
Roland Dreierb2cbae22011-05-20 11:46:11 -0700742 printk(KERN_WARNING "Couldn't init IB netlink interface\n");
Nir Muchtarfd75c782011-05-20 11:46:10 -0700743 goto err_sysfs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 }
745
Roland Dreierb2cbae22011-05-20 11:46:11 -0700746 ret = ib_cache_setup();
747 if (ret) {
748 printk(KERN_WARNING "Couldn't set up InfiniBand P_Key/GID cache\n");
749 goto err_nl;
750 }
751
Nir Muchtarfd75c782011-05-20 11:46:10 -0700752 return 0;
753
Roland Dreierb2cbae22011-05-20 11:46:11 -0700754err_nl:
755 ibnl_cleanup();
756
Nir Muchtarfd75c782011-05-20 11:46:10 -0700757err_sysfs:
758 ib_sysfs_cleanup();
759
760err:
761 destroy_workqueue(ib_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 return ret;
763}
764
765static void __exit ib_core_cleanup(void)
766{
767 ib_cache_cleanup();
Roland Dreierb2cbae22011-05-20 11:46:11 -0700768 ibnl_cleanup();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 ib_sysfs_cleanup();
Roland Dreierf7c6a7b2007-03-04 16:15:11 -0800770 /* Make sure that any pending umem accounting work is done. */
Tejun Heof0626712010-10-19 15:24:36 +0000771 destroy_workqueue(ib_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772}
773
774module_init(ib_core_init);
775module_exit(ib_core_cleanup);