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