IB/ipath: Update copyright dates
[linux-3.10.git] / drivers / infiniband / hw / ipath / ipath_layer.c
1 /*
2  * Copyright (c) 2006, 2007 QLogic Corporation. All rights reserved.
3  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
4  *
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.
32  */
33
34 /*
35  * These are the routines used by layered drivers, currently just the
36  * layered ethernet driver and verbs layer.
37  */
38
39 #include <linux/io.h>
40 #include <asm/byteorder.h>
41
42 #include "ipath_kernel.h"
43 #include "ipath_layer.h"
44 #include "ipath_verbs.h"
45 #include "ipath_common.h"
46
47 /* Acquire before ipath_devs_lock. */
48 static DEFINE_MUTEX(ipath_layer_mutex);
49
50 u16 ipath_layer_rcv_opcode;
51
52 static int (*layer_intr)(void *, u32);
53 static int (*layer_rcv)(void *, void *, struct sk_buff *);
54 static int (*layer_rcv_lid)(void *, void *);
55
56 static void *(*layer_add_one)(int, struct ipath_devdata *);
57 static void (*layer_remove_one)(void *);
58
59 int __ipath_layer_intr(struct ipath_devdata *dd, u32 arg)
60 {
61         int ret = -ENODEV;
62
63         if (dd->ipath_layer.l_arg && layer_intr)
64                 ret = layer_intr(dd->ipath_layer.l_arg, arg);
65
66         return ret;
67 }
68
69 int ipath_layer_intr(struct ipath_devdata *dd, u32 arg)
70 {
71         int ret;
72
73         mutex_lock(&ipath_layer_mutex);
74
75         ret = __ipath_layer_intr(dd, arg);
76
77         mutex_unlock(&ipath_layer_mutex);
78
79         return ret;
80 }
81
82 int __ipath_layer_rcv(struct ipath_devdata *dd, void *hdr,
83                       struct sk_buff *skb)
84 {
85         int ret = -ENODEV;
86
87         if (dd->ipath_layer.l_arg && layer_rcv)
88                 ret = layer_rcv(dd->ipath_layer.l_arg, hdr, skb);
89
90         return ret;
91 }
92
93 int __ipath_layer_rcv_lid(struct ipath_devdata *dd, void *hdr)
94 {
95         int ret = -ENODEV;
96
97         if (dd->ipath_layer.l_arg && layer_rcv_lid)
98                 ret = layer_rcv_lid(dd->ipath_layer.l_arg, hdr);
99
100         return ret;
101 }
102
103 void ipath_layer_lid_changed(struct ipath_devdata *dd)
104 {
105         mutex_lock(&ipath_layer_mutex);
106
107         if (dd->ipath_layer.l_arg && layer_intr)
108                 layer_intr(dd->ipath_layer.l_arg, IPATH_LAYER_INT_LID);
109
110         mutex_unlock(&ipath_layer_mutex);
111 }
112
113 void ipath_layer_add(struct ipath_devdata *dd)
114 {
115         mutex_lock(&ipath_layer_mutex);
116
117         if (layer_add_one)
118                 dd->ipath_layer.l_arg =
119                         layer_add_one(dd->ipath_unit, dd);
120
121         mutex_unlock(&ipath_layer_mutex);
122 }
123
124 void ipath_layer_remove(struct ipath_devdata *dd)
125 {
126         mutex_lock(&ipath_layer_mutex);
127
128         if (dd->ipath_layer.l_arg && layer_remove_one) {
129                 layer_remove_one(dd->ipath_layer.l_arg);
130                 dd->ipath_layer.l_arg = NULL;
131         }
132
133         mutex_unlock(&ipath_layer_mutex);
134 }
135
136 int ipath_layer_register(void *(*l_add)(int, struct ipath_devdata *),
137                          void (*l_remove)(void *),
138                          int (*l_intr)(void *, u32),
139                          int (*l_rcv)(void *, void *, struct sk_buff *),
140                          u16 l_rcv_opcode,
141                          int (*l_rcv_lid)(void *, void *))
142 {
143         struct ipath_devdata *dd, *tmp;
144         unsigned long flags;
145
146         mutex_lock(&ipath_layer_mutex);
147
148         layer_add_one = l_add;
149         layer_remove_one = l_remove;
150         layer_intr = l_intr;
151         layer_rcv = l_rcv;
152         layer_rcv_lid = l_rcv_lid;
153         ipath_layer_rcv_opcode = l_rcv_opcode;
154
155         spin_lock_irqsave(&ipath_devs_lock, flags);
156
157         list_for_each_entry_safe(dd, tmp, &ipath_dev_list, ipath_list) {
158                 if (!(dd->ipath_flags & IPATH_INITTED))
159                         continue;
160
161                 if (dd->ipath_layer.l_arg)
162                         continue;
163
164                 spin_unlock_irqrestore(&ipath_devs_lock, flags);
165                 dd->ipath_layer.l_arg = l_add(dd->ipath_unit, dd);
166                 spin_lock_irqsave(&ipath_devs_lock, flags);
167         }
168
169         spin_unlock_irqrestore(&ipath_devs_lock, flags);
170         mutex_unlock(&ipath_layer_mutex);
171
172         return 0;
173 }
174
175 EXPORT_SYMBOL_GPL(ipath_layer_register);
176
177 void ipath_layer_unregister(void)
178 {
179         struct ipath_devdata *dd, *tmp;
180         unsigned long flags;
181
182         mutex_lock(&ipath_layer_mutex);
183         spin_lock_irqsave(&ipath_devs_lock, flags);
184
185         list_for_each_entry_safe(dd, tmp, &ipath_dev_list, ipath_list) {
186                 if (dd->ipath_layer.l_arg && layer_remove_one) {
187                         spin_unlock_irqrestore(&ipath_devs_lock, flags);
188                         layer_remove_one(dd->ipath_layer.l_arg);
189                         spin_lock_irqsave(&ipath_devs_lock, flags);
190                         dd->ipath_layer.l_arg = NULL;
191                 }
192         }
193
194         spin_unlock_irqrestore(&ipath_devs_lock, flags);
195
196         layer_add_one = NULL;
197         layer_remove_one = NULL;
198         layer_intr = NULL;
199         layer_rcv = NULL;
200         layer_rcv_lid = NULL;
201
202         mutex_unlock(&ipath_layer_mutex);
203 }
204
205 EXPORT_SYMBOL_GPL(ipath_layer_unregister);
206
207 int ipath_layer_open(struct ipath_devdata *dd, u32 * pktmax)
208 {
209         int ret;
210         u32 intval = 0;
211
212         mutex_lock(&ipath_layer_mutex);
213
214         if (!dd->ipath_layer.l_arg) {
215                 ret = -EINVAL;
216                 goto bail;
217         }
218
219         ret = ipath_setrcvhdrsize(dd, IPATH_HEADER_QUEUE_WORDS);
220
221         if (ret < 0)
222                 goto bail;
223
224         *pktmax = dd->ipath_ibmaxlen;
225
226         if (*dd->ipath_statusp & IPATH_STATUS_IB_READY)
227                 intval |= IPATH_LAYER_INT_IF_UP;
228         if (dd->ipath_lid)
229                 intval |= IPATH_LAYER_INT_LID;
230         if (dd->ipath_mlid)
231                 intval |= IPATH_LAYER_INT_BCAST;
232         /*
233          * do this on open, in case low level is already up and
234          * just layered driver was reloaded, etc.
235          */
236         if (intval)
237                 layer_intr(dd->ipath_layer.l_arg, intval);
238
239         ret = 0;
240 bail:
241         mutex_unlock(&ipath_layer_mutex);
242
243         return ret;
244 }
245
246 EXPORT_SYMBOL_GPL(ipath_layer_open);
247
248 u16 ipath_layer_get_lid(struct ipath_devdata *dd)
249 {
250         return dd->ipath_lid;
251 }
252
253 EXPORT_SYMBOL_GPL(ipath_layer_get_lid);
254
255 /**
256  * ipath_layer_get_mac - get the MAC address
257  * @dd: the infinipath device
258  * @mac: the MAC is put here
259  *
260  * This is the EUID-64 OUI octets (top 3), then
261  * skip the next 2 (which should both be zero or 0xff).
262  * The returned MAC is in network order
263  * mac points to at least 6 bytes of buffer
264  * We assume that by the time the LID is set, that the GUID is as valid
265  * as it's ever going to be, rather than adding yet another status bit.
266  */
267
268 int ipath_layer_get_mac(struct ipath_devdata *dd, u8 * mac)
269 {
270         u8 *guid;
271
272         guid = (u8 *) &dd->ipath_guid;
273
274         mac[0] = guid[0];
275         mac[1] = guid[1];
276         mac[2] = guid[2];
277         mac[3] = guid[5];
278         mac[4] = guid[6];
279         mac[5] = guid[7];
280         if ((guid[3] || guid[4]) && !(guid[3] == 0xff && guid[4] == 0xff))
281                 ipath_dbg("Warning, guid bytes 3 and 4 not 0 or 0xffff: "
282                           "%x %x\n", guid[3], guid[4]);
283         return 0;
284 }
285
286 EXPORT_SYMBOL_GPL(ipath_layer_get_mac);
287
288 u16 ipath_layer_get_bcast(struct ipath_devdata *dd)
289 {
290         return dd->ipath_mlid;
291 }
292
293 EXPORT_SYMBOL_GPL(ipath_layer_get_bcast);
294
295 int ipath_layer_send_hdr(struct ipath_devdata *dd, struct ether_header *hdr)
296 {
297         int ret = 0;
298         u32 __iomem *piobuf;
299         u32 plen, *uhdr;
300         size_t count;
301         __be16 vlsllnh;
302
303         if (!(dd->ipath_flags & IPATH_RCVHDRSZ_SET)) {
304                 ipath_dbg("send while not open\n");
305                 ret = -EINVAL;
306         } else
307                 if ((dd->ipath_flags & (IPATH_LINKUNK | IPATH_LINKDOWN)) ||
308                     dd->ipath_lid == 0) {
309                         /*
310                          * lid check is for when sma hasn't yet configured
311                          */
312                         ret = -ENETDOWN;
313                         ipath_cdbg(VERBOSE, "send while not ready, "
314                                    "mylid=%u, flags=0x%x\n",
315                                    dd->ipath_lid, dd->ipath_flags);
316                 }
317
318         vlsllnh = *((__be16 *) hdr);
319         if (vlsllnh != htons(IPATH_LRH_BTH)) {
320                 ipath_dbg("Warning: lrh[0] wrong (%x, not %x); "
321                           "not sending\n", be16_to_cpu(vlsllnh),
322                           IPATH_LRH_BTH);
323                 ret = -EINVAL;
324         }
325         if (ret)
326                 goto done;
327
328         /* Get a PIO buffer to use. */
329         piobuf = ipath_getpiobuf(dd, NULL);
330         if (piobuf == NULL) {
331                 ret = -EBUSY;
332                 goto done;
333         }
334
335         plen = (sizeof(*hdr) >> 2); /* actual length */
336         ipath_cdbg(EPKT, "0x%x+1w pio %p\n", plen, piobuf);
337
338         writeq(plen+1, piobuf); /* len (+1 for pad) to pbc, no flags */
339         ipath_flush_wc();
340         piobuf += 2;
341         uhdr = (u32 *)hdr;
342         count = plen-1; /* amount we can copy before trigger word */
343         __iowrite32_copy(piobuf, uhdr, count);
344         ipath_flush_wc();
345         __raw_writel(uhdr[count], piobuf + count);
346         ipath_flush_wc(); /* ensure it's sent, now */
347
348         ipath_stats.sps_ether_spkts++;  /* ether packet sent */
349
350 done:
351         return ret;
352 }
353
354 EXPORT_SYMBOL_GPL(ipath_layer_send_hdr);
355
356 int ipath_layer_set_piointbufavail_int(struct ipath_devdata *dd)
357 {
358         set_bit(IPATH_S_PIOINTBUFAVAIL, &dd->ipath_sendctrl);
359
360         ipath_write_kreg(dd, dd->ipath_kregs->kr_sendctrl,
361                          dd->ipath_sendctrl);
362         return 0;
363 }
364
365 EXPORT_SYMBOL_GPL(ipath_layer_set_piointbufavail_int);