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,v 1.1.1.1 2007/10/11 23:31:50 Exp $
36 */
37
38#include <linux/module.h>
39#include <linux/errno.h>
40#include <linux/slab.h>
41#include <linux/workqueue.h>
42
43#include <rdma/ib_cache.h>
44
45#include "core_priv.h"
46
47struct ib_pkey_cache {
48	int             table_len;
49	u16             table[0];
50};
51
52struct ib_gid_cache {
53	int             table_len;
54	union ib_gid    table[0];
55};
56
57struct ib_update_work {
58	struct work_struct work;
59	struct ib_device  *device;
60	u8                 port_num;
61};
62
63static inline int start_port(struct ib_device *device)
64{
65	return (device->node_type == RDMA_NODE_IB_SWITCH) ? 0 : 1;
66}
67
68static 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
74int 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}
99EXPORT_SYMBOL(ib_get_cached_gid);
100
101int 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	}
129found:
130	read_unlock_irqrestore(&device->cache.lock, flags);
131
132	return ret;
133}
134EXPORT_SYMBOL(ib_find_cached_gid);
135
136int 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}
161EXPORT_SYMBOL(ib_get_cached_pkey);
162
163int 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}
193EXPORT_SYMBOL(ib_find_cached_pkey);
194
195int 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}
211EXPORT_SYMBOL(ib_get_cached_lmc);
212
213static 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
282err:
283	kfree(pkey_cache);
284	kfree(gid_cache);
285	kfree(tprops);
286}
287
288static 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
297static 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
318static 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
356err_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
362err:
363	kfree(device->cache.pkey_cache);
364	kfree(device->cache.gid_cache);
365	kfree(device->cache.lmc_cache);
366}
367
368static 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
385static struct ib_client cache_client = {
386	.name   = "cache",
387	.add    = ib_cache_setup_one,
388	.remove = ib_cache_cleanup_one
389};
390
391int __init ib_cache_setup(void)
392{
393	return ib_register_client(&cache_client);
394}
395
396void __exit ib_cache_cleanup(void)
397{
398	ib_unregister_client(&cache_client);
399}
400