?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WorkStruct: make allyesconfig
[linux-2.6/openmoko-kernel/knife-kernel.git] / drivers / infiniband / core / cache.c
blob98272fbbfb31e3d1ff4e8a010d6a7f1489a58bf8
1 /*
2 * Copyright (c) 2004 Topspin Communications. All rights reserved.
3 * Copyright (c) 2005 Intel Corporation. All rights reserved.
4 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
5 * Copyright (c) 2005 Voltaire, Inc. All rights reserved.
6 *
7 * This software is available to you under a choice of one of two
8 * licenses. You may choose to be licensed under the terms of the GNU
9 * General Public License (GPL) Version 2, available from the file
10 * COPYING in the main directory of this source tree, or the
11 * OpenIB.org BSD license below:
12 *
13 * Redistribution and use in source and binary forms, with or
14 * without modification, are permitted provided that the following
15 * conditions are met:
16 *
17 * - Redistributions of source code must retain the above
18 * copyright notice, this list of conditions and the following
19 * disclaimer.
20 *
21 * - Redistributions in binary form must reproduce the above
22 * copyright notice, this list of conditions and the following
23 * disclaimer in the documentation and/or other materials
24 * provided with the distribution.
25 *
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
30 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
31 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
32 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33 * SOFTWARE.
34 *
35 * $Id: cache.c 1349 2004-12-16 21:09:43Z roland $
36 */
37
38 #include <linux/module.h>
39 #include <linux/errno.h>
40 #include <linux/slab.h>
41 #include <linux/sched.h> /* INIT_WORK, schedule_work(), flush_scheduled_work() */
42
43 #include <rdma/ib_cache.h>
44
45 #include "core_priv.h"
46
47 struct ib_pkey_cache {
48 int table_len;
49 u16 table[0];
50 };
51
52 struct ib_gid_cache {
53 int table_len;
54 union ib_gid table[0];
55 };
56
57 struct ib_update_work {
58 struct work_struct work;
59 struct ib_device *device;
60 u8 port_num;
61 };
62
63 static inline int start_port(struct ib_device *device)
64 {
65 return (device->node_type == RDMA_NODE_IB_SWITCH) ? 0 : 1;
66 }
67
68 static inline int end_port(struct ib_device *device)
69 {
70 return (device->node_type == RDMA_NODE_IB_SWITCH) ?
71 0 : device->phys_port_cnt;
72 }
73
74 int ib_get_cached_gid(struct ib_device *device,
75 u8 port_num,
76 int index,
77 union ib_gid *gid)
78 {
79 struct ib_gid_cache *cache;
80 unsigned long flags;
81 int ret = 0;
82
83 if (port_num < start_port(device) || port_num > end_port(device))
84 return -EINVAL;
85
86 read_lock_irqsave(&device->cache.lock, flags);
87
88 cache = device->cache.gid_cache[port_num - start_port(device)];
89
90 if (index < 0 || index >= cache->table_len)
91 ret = -EINVAL;
92 else
93 *gid = cache->table[index];
94
95 read_unlock_irqrestore(&device->cache.lock, flags);
96
97 return ret;
98 }
99 EXPORT_SYMBOL(ib_get_cached_gid);
100
101 int ib_find_cached_gid(struct ib_device *device,
102 union ib_gid *gid,
103 u8 *port_num,
104 u16 *index)
105 {
106 struct ib_gid_cache *cache;
107 unsigned long flags;
108 int p, i;
109 int ret = -ENOENT;
110
111 *port_num = -1;
112 if (index)
113 *index = -1;
114
115 read_lock_irqsave(&device->cache.lock, flags);
116
117 for (p = 0; p <= end_port(device) - start_port(device); ++p) {
118 cache = device->cache.gid_cache[p];
119 for (i = 0; i < cache->table_len; ++i) {
120 if (!memcmp(gid, &cache->table[i], sizeof *gid)) {
121 *port_num = p + start_port(device);
122 if (index)
123 *index = i;
124 ret = 0;
125 goto found;
126 }
127 }
128 }
129 found:
130 read_unlock_irqrestore(&device->cache.lock, flags);
131
132 return ret;
133 }
134 EXPORT_SYMBOL(ib_find_cached_gid);
135
136 int ib_get_cached_pkey(struct ib_device *device,
137 u8 port_num,
138 int index,
139 u16 *pkey)
140 {
141 struct ib_pkey_cache *cache;
142 unsigned long flags;
143 int ret = 0;
144
145 if (port_num < start_port(device) || port_num > end_port(device))
146 return -EINVAL;
147
148 read_lock_irqsave(&device->cache.lock, flags);
149
150 cache = device->cache.pkey_cache[port_num - start_port(device)];
151
152 if (index < 0 || index >= cache->table_len)
153 ret = -EINVAL;
154 else
155 *pkey = cache->table[index];
156
157 read_unlock_irqrestore(&device->cache.lock, flags);
158
159 return ret;
160 }
161 EXPORT_SYMBOL(ib_get_cached_pkey);
162
163 int ib_find_cached_pkey(struct ib_device *device,
164 u8 port_num,
165 u16 pkey,
166 u16 *index)
167 {
168 struct ib_pkey_cache *cache;
169 unsigned long flags;
170 int i;
171 int ret = -ENOENT;
172
173 if (port_num < start_port(device) || port_num > end_port(device))
174 return -EINVAL;
175
176 read_lock_irqsave(&device->cache.lock, flags);
177
178 cache = device->cache.pkey_cache[port_num - start_port(device)];
179
180 *index = -1;
181
182 for (i = 0; i < cache->table_len; ++i)
183 if ((cache->table[i] & 0x7fff) == (pkey & 0x7fff)) {
184 *index = i;
185 ret = 0;
186 break;
187 }
188
189 read_unlock_irqrestore(&device->cache.lock, flags);
190
191 return ret;
192 }
193 EXPORT_SYMBOL(ib_find_cached_pkey);
194
195 int ib_get_cached_lmc(struct ib_device *device,
196 u8 port_num,
197 u8 *lmc)
198 {
199 unsigned long flags;
200 int ret = 0;
201
202 if (port_num < start_port(device) || port_num > end_port(device))
203 return -EINVAL;
204
205 read_lock_irqsave(&device->cache.lock, flags);
206 *lmc = device->cache.lmc_cache[port_num - start_port(device)];
207 read_unlock_irqrestore(&device->cache.lock, flags);
208
209 return ret;
210 }
211 EXPORT_SYMBOL(ib_get_cached_lmc);
212
213 static void ib_cache_update(struct ib_device *device,
214 u8 port)
215 {
216 struct ib_port_attr *tprops = NULL;
217 struct ib_pkey_cache *pkey_cache = NULL, *old_pkey_cache;
218 struct ib_gid_cache *gid_cache = NULL, *old_gid_cache;
219 int i;
220 int ret;
221
222 tprops = kmalloc(sizeof *tprops, GFP_KERNEL);
223 if (!tprops)
224 return;
225
226 ret = ib_query_port(device, port, tprops);
227 if (ret) {
228 printk(KERN_WARNING "ib_query_port failed (%d) for %s\n",
229 ret, device->name);
230 goto err;
231 }
232
233 pkey_cache = kmalloc(sizeof *pkey_cache + tprops->pkey_tbl_len *
234 sizeof *pkey_cache->table, GFP_KERNEL);
235 if (!pkey_cache)
236 goto err;
237
238 pkey_cache->table_len = tprops->pkey_tbl_len;
239
240 gid_cache = kmalloc(sizeof *gid_cache + tprops->gid_tbl_len *
241 sizeof *gid_cache->table, GFP_KERNEL);
242 if (!gid_cache)
243 goto err;
244
245 gid_cache->table_len = tprops->gid_tbl_len;
246
247 for (i = 0; i < pkey_cache->table_len; ++i) {
248 ret = ib_query_pkey(device, port, i, pkey_cache->table + i);
249 if (ret) {
250 printk(KERN_WARNING "ib_query_pkey failed (%d) for %s (index %d)\n",
251 ret, device->name, i);
252 goto err;
253 }
254 }
255
256 for (i = 0; i < gid_cache->table_len; ++i) {
257 ret = ib_query_gid(device, port, i, gid_cache->table + i);
258 if (ret) {
259 printk(KERN_WARNING "ib_query_gid failed (%d) for %s (index %d)\n",
260 ret, device->name, i);
261 goto err;
262 }
263 }
264
265 write_lock_irq(&device->cache.lock);
266
267 old_pkey_cache = device->cache.pkey_cache[port - start_port(device)];
268 old_gid_cache = device->cache.gid_cache [port - start_port(device)];
269
270 device->cache.pkey_cache[port - start_port(device)] = pkey_cache;
271 device->cache.gid_cache [port - start_port(device)] = gid_cache;
272
273 device->cache.lmc_cache[port - start_port(device)] = tprops->lmc;
274
275 write_unlock_irq(&device->cache.lock);
276
277 kfree(old_pkey_cache);
278 kfree(old_gid_cache);
279 kfree(tprops);
280 return;
281
282 err:
283 kfree(pkey_cache);
284 kfree(gid_cache);
285 kfree(tprops);
286 }
287
288 static void ib_cache_task(struct work_struct *_work)
289 {
290 struct ib_update_work *work =
291 container_of(_work, struct ib_update_work, work);
292
293 ib_cache_update(work->device, work->port_num);
294 kfree(work);
295 }
296
297 static void ib_cache_event(struct ib_event_handler *handler,
298 struct ib_event *event)
299 {
300 struct ib_update_work *work;
301
302 if (event->event == IB_EVENT_PORT_ERR ||
303 event->event == IB_EVENT_PORT_ACTIVE ||
304 event->event == IB_EVENT_LID_CHANGE ||
305 event->event == IB_EVENT_PKEY_CHANGE ||
306 event->event == IB_EVENT_SM_CHANGE ||
307 event->event == IB_EVENT_CLIENT_REREGISTER) {
308 work = kmalloc(sizeof *work, GFP_ATOMIC);
309 if (work) {
310 INIT_WORK(&work->work, ib_cache_task);
311 work->device = event->device;
312 work->port_num = event->element.port_num;
313 schedule_work(&work->work);
314 }
315 }
316 }
317
318 static void ib_cache_setup_one(struct ib_device *device)
319 {
320 int p;
321
322 rwlock_init(&device->cache.lock);
323
324 device->cache.pkey_cache =
325 kmalloc(sizeof *device->cache.pkey_cache *
326 (end_port(device) - start_port(device) + 1), GFP_KERNEL);
327 device->cache.gid_cache =
328 kmalloc(sizeof *device->cache.gid_cache *
329 (end_port(device) - start_port(device) + 1), GFP_KERNEL);
330
331 device->cache.lmc_cache = kmalloc(sizeof *device->cache.lmc_cache *
332 (end_port(device) -
333 start_port(device) + 1),
334 GFP_KERNEL);
335
336 if (!device->cache.pkey_cache || !device->cache.gid_cache ||
337 !device->cache.lmc_cache) {
338 printk(KERN_WARNING "Couldn't allocate cache "
339 "for %s\n", device->name);
340 goto err;
341 }
342
343 for (p = 0; p <= end_port(device) - start_port(device); ++p) {
344 device->cache.pkey_cache[p] = NULL;
345 device->cache.gid_cache [p] = NULL;
346 ib_cache_update(device, p + start_port(device));
347 }
348
349 INIT_IB_EVENT_HANDLER(&device->cache.event_handler,
350 device, ib_cache_event);
351 if (ib_register_event_handler(&device->cache.event_handler))
352 goto err_cache;
353
354 return;
355
356 err_cache:
357 for (p = 0; p <= end_port(device) - start_port(device); ++p) {
358 kfree(device->cache.pkey_cache[p]);
359 kfree(device->cache.gid_cache[p]);
360 }
361
362 err:
363 kfree(device->cache.pkey_cache);
364 kfree(device->cache.gid_cache);
365 kfree(device->cache.lmc_cache);
366 }
367
368 static void ib_cache_cleanup_one(struct ib_device *device)
369 {
370 int p;
371
372 ib_unregister_event_handler(&device->cache.event_handler);
373 flush_scheduled_work();
374
375 for (p = 0; p <= end_port(device) - start_port(device); ++p) {
376 kfree(device->cache.pkey_cache[p]);
377 kfree(device->cache.gid_cache[p]);
378 }
379
380 kfree(device->cache.pkey_cache);
381 kfree(device->cache.gid_cache);
382 kfree(device->cache.lmc_cache);
383 }
384
385 static struct ib_client cache_client = {
386 .name = "cache",
387 .add = ib_cache_setup_one,
388 .remove = ib_cache_cleanup_one
389 };
390
391 int __init ib_cache_setup(void)
392 {
393 return ib_register_client(&cache_client);
394 }
395
396 void __exit ib_cache_cleanup(void)
397 {
398 ib_unregister_client(&cache_client);
399 }
Community contributions to the Openmoko Kernel