[PATCH] IB/ipath: namespace cleanup: replace ips with ipath
[linux-2.6] / drivers / infiniband / hw / ipath / ipath_layer.c
1 /*
2  * Copyright (c) 2006 QLogic, Inc. 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 <linux/pci.h>
41 #include <asm/byteorder.h>
42
43 #include "ipath_kernel.h"
44 #include "ipath_layer.h"
45 #include "ipath_common.h"
46
47 /* Acquire before ipath_devs_lock. */
48 static DEFINE_MUTEX(ipath_layer_mutex);
49
50 static int ipath_verbs_registered;
51
52 u16 ipath_layer_rcv_opcode;
53
54 static int (*layer_intr)(void *, u32);
55 static int (*layer_rcv)(void *, void *, struct sk_buff *);
56 static int (*layer_rcv_lid)(void *, void *);
57 static int (*verbs_piobufavail)(void *);
58 static void (*verbs_rcv)(void *, void *, void *, u32);
59
60 static void *(*layer_add_one)(int, struct ipath_devdata *);
61 static void (*layer_remove_one)(void *);
62 static void *(*verbs_add_one)(int, struct ipath_devdata *);
63 static void (*verbs_remove_one)(void *);
64 static void (*verbs_timer_cb)(void *);
65
66 int __ipath_layer_intr(struct ipath_devdata *dd, u32 arg)
67 {
68         int ret = -ENODEV;
69
70         if (dd->ipath_layer.l_arg && layer_intr)
71                 ret = layer_intr(dd->ipath_layer.l_arg, arg);
72
73         return ret;
74 }
75
76 int ipath_layer_intr(struct ipath_devdata *dd, u32 arg)
77 {
78         int ret;
79
80         mutex_lock(&ipath_layer_mutex);
81
82         ret = __ipath_layer_intr(dd, arg);
83
84         mutex_unlock(&ipath_layer_mutex);
85
86         return ret;
87 }
88
89 int __ipath_layer_rcv(struct ipath_devdata *dd, void *hdr,
90                       struct sk_buff *skb)
91 {
92         int ret = -ENODEV;
93
94         if (dd->ipath_layer.l_arg && layer_rcv)
95                 ret = layer_rcv(dd->ipath_layer.l_arg, hdr, skb);
96
97         return ret;
98 }
99
100 int __ipath_layer_rcv_lid(struct ipath_devdata *dd, void *hdr)
101 {
102         int ret = -ENODEV;
103
104         if (dd->ipath_layer.l_arg && layer_rcv_lid)
105                 ret = layer_rcv_lid(dd->ipath_layer.l_arg, hdr);
106
107         return ret;
108 }
109
110 int __ipath_verbs_piobufavail(struct ipath_devdata *dd)
111 {
112         int ret = -ENODEV;
113
114         if (dd->verbs_layer.l_arg && verbs_piobufavail)
115                 ret = verbs_piobufavail(dd->verbs_layer.l_arg);
116
117         return ret;
118 }
119
120 int __ipath_verbs_rcv(struct ipath_devdata *dd, void *rc, void *ebuf,
121                       u32 tlen)
122 {
123         int ret = -ENODEV;
124
125         if (dd->verbs_layer.l_arg && verbs_rcv) {
126                 verbs_rcv(dd->verbs_layer.l_arg, rc, ebuf, tlen);
127                 ret = 0;
128         }
129
130         return ret;
131 }
132
133 int ipath_layer_set_linkstate(struct ipath_devdata *dd, u8 newstate)
134 {
135         u32 lstate;
136         int ret;
137
138         switch (newstate) {
139         case IPATH_IB_LINKDOWN:
140                 ipath_set_ib_lstate(dd, INFINIPATH_IBCC_LINKINITCMD_POLL <<
141                                     INFINIPATH_IBCC_LINKINITCMD_SHIFT);
142                 /* don't wait */
143                 ret = 0;
144                 goto bail;
145
146         case IPATH_IB_LINKDOWN_SLEEP:
147                 ipath_set_ib_lstate(dd, INFINIPATH_IBCC_LINKINITCMD_SLEEP <<
148                                     INFINIPATH_IBCC_LINKINITCMD_SHIFT);
149                 /* don't wait */
150                 ret = 0;
151                 goto bail;
152
153         case IPATH_IB_LINKDOWN_DISABLE:
154                 ipath_set_ib_lstate(dd,
155                                     INFINIPATH_IBCC_LINKINITCMD_DISABLE <<
156                                     INFINIPATH_IBCC_LINKINITCMD_SHIFT);
157                 /* don't wait */
158                 ret = 0;
159                 goto bail;
160
161         case IPATH_IB_LINKINIT:
162                 if (dd->ipath_flags & IPATH_LINKINIT) {
163                         ret = 0;
164                         goto bail;
165                 }
166                 ipath_set_ib_lstate(dd, INFINIPATH_IBCC_LINKCMD_INIT <<
167                                     INFINIPATH_IBCC_LINKCMD_SHIFT);
168                 lstate = IPATH_LINKINIT;
169                 break;
170
171         case IPATH_IB_LINKARM:
172                 if (dd->ipath_flags & IPATH_LINKARMED) {
173                         ret = 0;
174                         goto bail;
175                 }
176                 if (!(dd->ipath_flags &
177                       (IPATH_LINKINIT | IPATH_LINKACTIVE))) {
178                         ret = -EINVAL;
179                         goto bail;
180                 }
181                 ipath_set_ib_lstate(dd, INFINIPATH_IBCC_LINKCMD_ARMED <<
182                                     INFINIPATH_IBCC_LINKCMD_SHIFT);
183                 /*
184                  * Since the port can transition to ACTIVE by receiving
185                  * a non VL 15 packet, wait for either state.
186                  */
187                 lstate = IPATH_LINKARMED | IPATH_LINKACTIVE;
188                 break;
189
190         case IPATH_IB_LINKACTIVE:
191                 if (dd->ipath_flags & IPATH_LINKACTIVE) {
192                         ret = 0;
193                         goto bail;
194                 }
195                 if (!(dd->ipath_flags & IPATH_LINKARMED)) {
196                         ret = -EINVAL;
197                         goto bail;
198                 }
199                 ipath_set_ib_lstate(dd, INFINIPATH_IBCC_LINKCMD_ACTIVE <<
200                                     INFINIPATH_IBCC_LINKCMD_SHIFT);
201                 lstate = IPATH_LINKACTIVE;
202                 break;
203
204         default:
205                 ipath_dbg("Invalid linkstate 0x%x requested\n", newstate);
206                 ret = -EINVAL;
207                 goto bail;
208         }
209         ret = ipath_wait_linkstate(dd, lstate, 2000);
210
211 bail:
212         return ret;
213 }
214
215 EXPORT_SYMBOL_GPL(ipath_layer_set_linkstate);
216
217 /**
218  * ipath_layer_set_mtu - set the MTU
219  * @dd: the infinipath device
220  * @arg: the new MTU
221  *
222  * we can handle "any" incoming size, the issue here is whether we
223  * need to restrict our outgoing size.   For now, we don't do any
224  * sanity checking on this, and we don't deal with what happens to
225  * programs that are already running when the size changes.
226  * NOTE: changing the MTU will usually cause the IBC to go back to
227  * link initialize (IPATH_IBSTATE_INIT) state...
228  */
229 int ipath_layer_set_mtu(struct ipath_devdata *dd, u16 arg)
230 {
231         u32 piosize;
232         int changed = 0;
233         int ret;
234
235         /*
236          * mtu is IB data payload max.  It's the largest power of 2 less
237          * than piosize (or even larger, since it only really controls the
238          * largest we can receive; we can send the max of the mtu and
239          * piosize).  We check that it's one of the valid IB sizes.
240          */
241         if (arg != 256 && arg != 512 && arg != 1024 && arg != 2048 &&
242             arg != 4096) {
243                 ipath_dbg("Trying to set invalid mtu %u, failing\n", arg);
244                 ret = -EINVAL;
245                 goto bail;
246         }
247         if (dd->ipath_ibmtu == arg) {
248                 ret = 0;        /* same as current */
249                 goto bail;
250         }
251
252         piosize = dd->ipath_ibmaxlen;
253         dd->ipath_ibmtu = arg;
254
255         if (arg >= (piosize - IPATH_PIO_MAXIBHDR)) {
256                 /* Only if it's not the initial value (or reset to it) */
257                 if (piosize != dd->ipath_init_ibmaxlen) {
258                         dd->ipath_ibmaxlen = piosize;
259                         changed = 1;
260                 }
261         } else if ((arg + IPATH_PIO_MAXIBHDR) != dd->ipath_ibmaxlen) {
262                 piosize = arg + IPATH_PIO_MAXIBHDR;
263                 ipath_cdbg(VERBOSE, "ibmaxlen was 0x%x, setting to 0x%x "
264                            "(mtu 0x%x)\n", dd->ipath_ibmaxlen, piosize,
265                            arg);
266                 dd->ipath_ibmaxlen = piosize;
267                 changed = 1;
268         }
269
270         if (changed) {
271                 /*
272                  * set the IBC maxpktlength to the size of our pio
273                  * buffers in words
274                  */
275                 u64 ibc = dd->ipath_ibcctrl;
276                 ibc &= ~(INFINIPATH_IBCC_MAXPKTLEN_MASK <<
277                          INFINIPATH_IBCC_MAXPKTLEN_SHIFT);
278
279                 piosize = piosize - 2 * sizeof(u32);    /* ignore pbc */
280                 dd->ipath_ibmaxlen = piosize;
281                 piosize /= sizeof(u32); /* in words */
282                 /*
283                  * for ICRC, which we only send in diag test pkt mode, and
284                  * we don't need to worry about that for mtu
285                  */
286                 piosize += 1;
287
288                 ibc |= piosize << INFINIPATH_IBCC_MAXPKTLEN_SHIFT;
289                 dd->ipath_ibcctrl = ibc;
290                 ipath_write_kreg(dd, dd->ipath_kregs->kr_ibcctrl,
291                                  dd->ipath_ibcctrl);
292                 dd->ipath_f_tidtemplate(dd);
293         }
294
295         ret = 0;
296
297 bail:
298         return ret;
299 }
300
301 EXPORT_SYMBOL_GPL(ipath_layer_set_mtu);
302
303 int ipath_set_lid(struct ipath_devdata *dd, u32 arg, u8 lmc)
304 {
305         dd->ipath_lid = arg;
306         dd->ipath_lmc = lmc;
307
308         mutex_lock(&ipath_layer_mutex);
309
310         if (dd->ipath_layer.l_arg && layer_intr)
311                 layer_intr(dd->ipath_layer.l_arg, IPATH_LAYER_INT_LID);
312
313         mutex_unlock(&ipath_layer_mutex);
314
315         return 0;
316 }
317
318 EXPORT_SYMBOL_GPL(ipath_set_lid);
319
320 int ipath_layer_set_guid(struct ipath_devdata *dd, __be64 guid)
321 {
322         /* XXX - need to inform anyone who cares this just happened. */
323         dd->ipath_guid = guid;
324         return 0;
325 }
326
327 EXPORT_SYMBOL_GPL(ipath_layer_set_guid);
328
329 __be64 ipath_layer_get_guid(struct ipath_devdata *dd)
330 {
331         return dd->ipath_guid;
332 }
333
334 EXPORT_SYMBOL_GPL(ipath_layer_get_guid);
335
336 u32 ipath_layer_get_nguid(struct ipath_devdata *dd)
337 {
338         return dd->ipath_nguid;
339 }
340
341 EXPORT_SYMBOL_GPL(ipath_layer_get_nguid);
342
343 u32 ipath_layer_get_majrev(struct ipath_devdata *dd)
344 {
345         return dd->ipath_majrev;
346 }
347
348 EXPORT_SYMBOL_GPL(ipath_layer_get_majrev);
349
350 u32 ipath_layer_get_minrev(struct ipath_devdata *dd)
351 {
352         return dd->ipath_minrev;
353 }
354
355 EXPORT_SYMBOL_GPL(ipath_layer_get_minrev);
356
357 u32 ipath_layer_get_pcirev(struct ipath_devdata *dd)
358 {
359         return dd->ipath_pcirev;
360 }
361
362 EXPORT_SYMBOL_GPL(ipath_layer_get_pcirev);
363
364 u32 ipath_layer_get_flags(struct ipath_devdata *dd)
365 {
366         return dd->ipath_flags;
367 }
368
369 EXPORT_SYMBOL_GPL(ipath_layer_get_flags);
370
371 struct device *ipath_layer_get_device(struct ipath_devdata *dd)
372 {
373         return &dd->pcidev->dev;
374 }
375
376 EXPORT_SYMBOL_GPL(ipath_layer_get_device);
377
378 u16 ipath_layer_get_deviceid(struct ipath_devdata *dd)
379 {
380         return dd->ipath_deviceid;
381 }
382
383 EXPORT_SYMBOL_GPL(ipath_layer_get_deviceid);
384
385 u32 ipath_layer_get_vendorid(struct ipath_devdata *dd)
386 {
387         return dd->ipath_vendorid;
388 }
389
390 EXPORT_SYMBOL_GPL(ipath_layer_get_vendorid);
391
392 u64 ipath_layer_get_lastibcstat(struct ipath_devdata *dd)
393 {
394         return dd->ipath_lastibcstat;
395 }
396
397 EXPORT_SYMBOL_GPL(ipath_layer_get_lastibcstat);
398
399 u32 ipath_layer_get_ibmtu(struct ipath_devdata *dd)
400 {
401         return dd->ipath_ibmtu;
402 }
403
404 EXPORT_SYMBOL_GPL(ipath_layer_get_ibmtu);
405
406 void ipath_layer_add(struct ipath_devdata *dd)
407 {
408         mutex_lock(&ipath_layer_mutex);
409
410         if (layer_add_one)
411                 dd->ipath_layer.l_arg =
412                         layer_add_one(dd->ipath_unit, dd);
413
414         if (verbs_add_one)
415                 dd->verbs_layer.l_arg =
416                         verbs_add_one(dd->ipath_unit, dd);
417
418         mutex_unlock(&ipath_layer_mutex);
419 }
420
421 void ipath_layer_remove(struct ipath_devdata *dd)
422 {
423         mutex_lock(&ipath_layer_mutex);
424
425         if (dd->ipath_layer.l_arg && layer_remove_one) {
426                 layer_remove_one(dd->ipath_layer.l_arg);
427                 dd->ipath_layer.l_arg = NULL;
428         }
429
430         if (dd->verbs_layer.l_arg && verbs_remove_one) {
431                 verbs_remove_one(dd->verbs_layer.l_arg);
432                 dd->verbs_layer.l_arg = NULL;
433         }
434
435         mutex_unlock(&ipath_layer_mutex);
436 }
437
438 int ipath_layer_register(void *(*l_add)(int, struct ipath_devdata *),
439                          void (*l_remove)(void *),
440                          int (*l_intr)(void *, u32),
441                          int (*l_rcv)(void *, void *, struct sk_buff *),
442                          u16 l_rcv_opcode,
443                          int (*l_rcv_lid)(void *, void *))
444 {
445         struct ipath_devdata *dd, *tmp;
446         unsigned long flags;
447
448         mutex_lock(&ipath_layer_mutex);
449
450         layer_add_one = l_add;
451         layer_remove_one = l_remove;
452         layer_intr = l_intr;
453         layer_rcv = l_rcv;
454         layer_rcv_lid = l_rcv_lid;
455         ipath_layer_rcv_opcode = l_rcv_opcode;
456
457         spin_lock_irqsave(&ipath_devs_lock, flags);
458
459         list_for_each_entry_safe(dd, tmp, &ipath_dev_list, ipath_list) {
460                 if (!(dd->ipath_flags & IPATH_INITTED))
461                         continue;
462
463                 if (dd->ipath_layer.l_arg)
464                         continue;
465
466                 if (!(*dd->ipath_statusp & IPATH_STATUS_SMA))
467                         *dd->ipath_statusp |= IPATH_STATUS_OIB_SMA;
468
469                 spin_unlock_irqrestore(&ipath_devs_lock, flags);
470                 dd->ipath_layer.l_arg = l_add(dd->ipath_unit, dd);
471                 spin_lock_irqsave(&ipath_devs_lock, flags);
472         }
473
474         spin_unlock_irqrestore(&ipath_devs_lock, flags);
475         mutex_unlock(&ipath_layer_mutex);
476
477         return 0;
478 }
479
480 EXPORT_SYMBOL_GPL(ipath_layer_register);
481
482 void ipath_layer_unregister(void)
483 {
484         struct ipath_devdata *dd, *tmp;
485         unsigned long flags;
486
487         mutex_lock(&ipath_layer_mutex);
488         spin_lock_irqsave(&ipath_devs_lock, flags);
489
490         list_for_each_entry_safe(dd, tmp, &ipath_dev_list, ipath_list) {
491                 if (dd->ipath_layer.l_arg && layer_remove_one) {
492                         spin_unlock_irqrestore(&ipath_devs_lock, flags);
493                         layer_remove_one(dd->ipath_layer.l_arg);
494                         spin_lock_irqsave(&ipath_devs_lock, flags);
495                         dd->ipath_layer.l_arg = NULL;
496                 }
497         }
498
499         spin_unlock_irqrestore(&ipath_devs_lock, flags);
500
501         layer_add_one = NULL;
502         layer_remove_one = NULL;
503         layer_intr = NULL;
504         layer_rcv = NULL;
505         layer_rcv_lid = NULL;
506
507         mutex_unlock(&ipath_layer_mutex);
508 }
509
510 EXPORT_SYMBOL_GPL(ipath_layer_unregister);
511
512 static void __ipath_verbs_timer(unsigned long arg)
513 {
514         struct ipath_devdata *dd = (struct ipath_devdata *) arg;
515
516         /*
517          * If port 0 receive packet interrupts are not available, or
518          * can be missed, poll the receive queue
519          */
520         if (dd->ipath_flags & IPATH_POLL_RX_INTR)
521                 ipath_kreceive(dd);
522
523         /* Handle verbs layer timeouts. */
524         if (dd->verbs_layer.l_arg && verbs_timer_cb)
525                 verbs_timer_cb(dd->verbs_layer.l_arg);
526
527         mod_timer(&dd->verbs_layer.l_timer, jiffies + 1);
528 }
529
530 /**
531  * ipath_verbs_register - verbs layer registration
532  * @l_piobufavail: callback for when PIO buffers become available
533  * @l_rcv: callback for receiving a packet
534  * @l_timer_cb: timer callback
535  * @ipath_devdata: device data structure is put here
536  */
537 int ipath_verbs_register(void *(*l_add)(int, struct ipath_devdata *),
538                          void (*l_remove)(void *arg),
539                          int (*l_piobufavail) (void *arg),
540                          void (*l_rcv) (void *arg, void *rhdr,
541                                         void *data, u32 tlen),
542                          void (*l_timer_cb) (void *arg))
543 {
544         struct ipath_devdata *dd, *tmp;
545         unsigned long flags;
546
547         mutex_lock(&ipath_layer_mutex);
548
549         verbs_add_one = l_add;
550         verbs_remove_one = l_remove;
551         verbs_piobufavail = l_piobufavail;
552         verbs_rcv = l_rcv;
553         verbs_timer_cb = l_timer_cb;
554
555         spin_lock_irqsave(&ipath_devs_lock, flags);
556
557         list_for_each_entry_safe(dd, tmp, &ipath_dev_list, ipath_list) {
558                 if (!(dd->ipath_flags & IPATH_INITTED))
559                         continue;
560
561                 if (dd->verbs_layer.l_arg)
562                         continue;
563
564                 spin_unlock_irqrestore(&ipath_devs_lock, flags);
565                 dd->verbs_layer.l_arg = l_add(dd->ipath_unit, dd);
566                 spin_lock_irqsave(&ipath_devs_lock, flags);
567         }
568
569         spin_unlock_irqrestore(&ipath_devs_lock, flags);
570         mutex_unlock(&ipath_layer_mutex);
571
572         ipath_verbs_registered = 1;
573
574         return 0;
575 }
576
577 EXPORT_SYMBOL_GPL(ipath_verbs_register);
578
579 void ipath_verbs_unregister(void)
580 {
581         struct ipath_devdata *dd, *tmp;
582         unsigned long flags;
583
584         mutex_lock(&ipath_layer_mutex);
585         spin_lock_irqsave(&ipath_devs_lock, flags);
586
587         list_for_each_entry_safe(dd, tmp, &ipath_dev_list, ipath_list) {
588                 *dd->ipath_statusp &= ~IPATH_STATUS_OIB_SMA;
589
590                 if (dd->verbs_layer.l_arg && verbs_remove_one) {
591                         spin_unlock_irqrestore(&ipath_devs_lock, flags);
592                         verbs_remove_one(dd->verbs_layer.l_arg);
593                         spin_lock_irqsave(&ipath_devs_lock, flags);
594                         dd->verbs_layer.l_arg = NULL;
595                 }
596         }
597
598         spin_unlock_irqrestore(&ipath_devs_lock, flags);
599
600         verbs_add_one = NULL;
601         verbs_remove_one = NULL;
602         verbs_piobufavail = NULL;
603         verbs_rcv = NULL;
604         verbs_timer_cb = NULL;
605
606         ipath_verbs_registered = 0;
607
608         mutex_unlock(&ipath_layer_mutex);
609 }
610
611 EXPORT_SYMBOL_GPL(ipath_verbs_unregister);
612
613 int ipath_layer_open(struct ipath_devdata *dd, u32 * pktmax)
614 {
615         int ret;
616         u32 intval = 0;
617
618         mutex_lock(&ipath_layer_mutex);
619
620         if (!dd->ipath_layer.l_arg) {
621                 ret = -EINVAL;
622                 goto bail;
623         }
624
625         ret = ipath_setrcvhdrsize(dd, IPATH_HEADER_QUEUE_WORDS);
626
627         if (ret < 0)
628                 goto bail;
629
630         *pktmax = dd->ipath_ibmaxlen;
631
632         if (*dd->ipath_statusp & IPATH_STATUS_IB_READY)
633                 intval |= IPATH_LAYER_INT_IF_UP;
634         if (dd->ipath_lid)
635                 intval |= IPATH_LAYER_INT_LID;
636         if (dd->ipath_mlid)
637                 intval |= IPATH_LAYER_INT_BCAST;
638         /*
639          * do this on open, in case low level is already up and
640          * just layered driver was reloaded, etc.
641          */
642         if (intval)
643                 layer_intr(dd->ipath_layer.l_arg, intval);
644
645         ret = 0;
646 bail:
647         mutex_unlock(&ipath_layer_mutex);
648
649         return ret;
650 }
651
652 EXPORT_SYMBOL_GPL(ipath_layer_open);
653
654 u16 ipath_layer_get_lid(struct ipath_devdata *dd)
655 {
656         return dd->ipath_lid;
657 }
658
659 EXPORT_SYMBOL_GPL(ipath_layer_get_lid);
660
661 /**
662  * ipath_layer_get_mac - get the MAC address
663  * @dd: the infinipath device
664  * @mac: the MAC is put here
665  *
666  * This is the EUID-64 OUI octets (top 3), then
667  * skip the next 2 (which should both be zero or 0xff).
668  * The returned MAC is in network order
669  * mac points to at least 6 bytes of buffer
670  * We assume that by the time the LID is set, that the GUID is as valid
671  * as it's ever going to be, rather than adding yet another status bit.
672  */
673
674 int ipath_layer_get_mac(struct ipath_devdata *dd, u8 * mac)
675 {
676         u8 *guid;
677
678         guid = (u8 *) &dd->ipath_guid;
679
680         mac[0] = guid[0];
681         mac[1] = guid[1];
682         mac[2] = guid[2];
683         mac[3] = guid[5];
684         mac[4] = guid[6];
685         mac[5] = guid[7];
686         if ((guid[3] || guid[4]) && !(guid[3] == 0xff && guid[4] == 0xff))
687                 ipath_dbg("Warning, guid bytes 3 and 4 not 0 or 0xffff: "
688                           "%x %x\n", guid[3], guid[4]);
689         return 0;
690 }
691
692 EXPORT_SYMBOL_GPL(ipath_layer_get_mac);
693
694 u16 ipath_layer_get_bcast(struct ipath_devdata *dd)
695 {
696         return dd->ipath_mlid;
697 }
698
699 EXPORT_SYMBOL_GPL(ipath_layer_get_bcast);
700
701 u32 ipath_layer_get_cr_errpkey(struct ipath_devdata *dd)
702 {
703         return ipath_read_creg32(dd, dd->ipath_cregs->cr_errpkey);
704 }
705
706 EXPORT_SYMBOL_GPL(ipath_layer_get_cr_errpkey);
707
708 static void update_sge(struct ipath_sge_state *ss, u32 length)
709 {
710         struct ipath_sge *sge = &ss->sge;
711
712         sge->vaddr += length;
713         sge->length -= length;
714         sge->sge_length -= length;
715         if (sge->sge_length == 0) {
716                 if (--ss->num_sge)
717                         *sge = *ss->sg_list++;
718         } else if (sge->length == 0 && sge->mr != NULL) {
719                 if (++sge->n >= IPATH_SEGSZ) {
720                         if (++sge->m >= sge->mr->mapsz)
721                                 return;
722                         sge->n = 0;
723                 }
724                 sge->vaddr = sge->mr->map[sge->m]->segs[sge->n].vaddr;
725                 sge->length = sge->mr->map[sge->m]->segs[sge->n].length;
726         }
727 }
728
729 #ifdef __LITTLE_ENDIAN
730 static inline u32 get_upper_bits(u32 data, u32 shift)
731 {
732         return data >> shift;
733 }
734
735 static inline u32 set_upper_bits(u32 data, u32 shift)
736 {
737         return data << shift;
738 }
739
740 static inline u32 clear_upper_bytes(u32 data, u32 n, u32 off)
741 {
742         data <<= ((sizeof(u32) - n) * BITS_PER_BYTE);
743         data >>= ((sizeof(u32) - n - off) * BITS_PER_BYTE);
744         return data;
745 }
746 #else
747 static inline u32 get_upper_bits(u32 data, u32 shift)
748 {
749         return data << shift;
750 }
751
752 static inline u32 set_upper_bits(u32 data, u32 shift)
753 {
754         return data >> shift;
755 }
756
757 static inline u32 clear_upper_bytes(u32 data, u32 n, u32 off)
758 {
759         data >>= ((sizeof(u32) - n) * BITS_PER_BYTE);
760         data <<= ((sizeof(u32) - n - off) * BITS_PER_BYTE);
761         return data;
762 }
763 #endif
764
765 static void copy_io(u32 __iomem *piobuf, struct ipath_sge_state *ss,
766                     u32 length)
767 {
768         u32 extra = 0;
769         u32 data = 0;
770         u32 last;
771
772         while (1) {
773                 u32 len = ss->sge.length;
774                 u32 off;
775
776                 BUG_ON(len == 0);
777                 if (len > length)
778                         len = length;
779                 if (len > ss->sge.sge_length)
780                         len = ss->sge.sge_length;
781                 /* If the source address is not aligned, try to align it. */
782                 off = (unsigned long)ss->sge.vaddr & (sizeof(u32) - 1);
783                 if (off) {
784                         u32 *addr = (u32 *)((unsigned long)ss->sge.vaddr &
785                                             ~(sizeof(u32) - 1));
786                         u32 v = get_upper_bits(*addr, off * BITS_PER_BYTE);
787                         u32 y;
788
789                         y = sizeof(u32) - off;
790                         if (len > y)
791                                 len = y;
792                         if (len + extra >= sizeof(u32)) {
793                                 data |= set_upper_bits(v, extra *
794                                                        BITS_PER_BYTE);
795                                 len = sizeof(u32) - extra;
796                                 if (len == length) {
797                                         last = data;
798                                         break;
799                                 }
800                                 __raw_writel(data, piobuf);
801                                 piobuf++;
802                                 extra = 0;
803                                 data = 0;
804                         } else {
805                                 /* Clear unused upper bytes */
806                                 data |= clear_upper_bytes(v, len, extra);
807                                 if (len == length) {
808                                         last = data;
809                                         break;
810                                 }
811                                 extra += len;
812                         }
813                 } else if (extra) {
814                         /* Source address is aligned. */
815                         u32 *addr = (u32 *) ss->sge.vaddr;
816                         int shift = extra * BITS_PER_BYTE;
817                         int ushift = 32 - shift;
818                         u32 l = len;
819
820                         while (l >= sizeof(u32)) {
821                                 u32 v = *addr;
822
823                                 data |= set_upper_bits(v, shift);
824                                 __raw_writel(data, piobuf);
825                                 data = get_upper_bits(v, ushift);
826                                 piobuf++;
827                                 addr++;
828                                 l -= sizeof(u32);
829                         }
830                         /*
831                          * We still have 'extra' number of bytes leftover.
832                          */
833                         if (l) {
834                                 u32 v = *addr;
835
836                                 if (l + extra >= sizeof(u32)) {
837                                         data |= set_upper_bits(v, shift);
838                                         len -= l + extra - sizeof(u32);
839                                         if (len == length) {
840                                                 last = data;
841                                                 break;
842                                         }
843                                         __raw_writel(data, piobuf);
844                                         piobuf++;
845                                         extra = 0;
846                                         data = 0;
847                                 } else {
848                                         /* Clear unused upper bytes */
849                                         data |= clear_upper_bytes(v, l,
850                                                                   extra);
851                                         if (len == length) {
852                                                 last = data;
853                                                 break;
854                                         }
855                                         extra += l;
856                                 }
857                         } else if (len == length) {
858                                 last = data;
859                                 break;
860                         }
861                 } else if (len == length) {
862                         u32 w;
863
864                         /*
865                          * Need to round up for the last dword in the
866                          * packet.
867                          */
868                         w = (len + 3) >> 2;
869                         __iowrite32_copy(piobuf, ss->sge.vaddr, w - 1);
870                         piobuf += w - 1;
871                         last = ((u32 *) ss->sge.vaddr)[w - 1];
872                         break;
873                 } else {
874                         u32 w = len >> 2;
875
876                         __iowrite32_copy(piobuf, ss->sge.vaddr, w);
877                         piobuf += w;
878
879                         extra = len & (sizeof(u32) - 1);
880                         if (extra) {
881                                 u32 v = ((u32 *) ss->sge.vaddr)[w];
882
883                                 /* Clear unused upper bytes */
884                                 data = clear_upper_bytes(v, extra, 0);
885                         }
886                 }
887                 update_sge(ss, len);
888                 length -= len;
889         }
890         /* Update address before sending packet. */
891         update_sge(ss, length);
892         /* must flush early everything before trigger word */
893         ipath_flush_wc();
894         __raw_writel(last, piobuf);
895         /* be sure trigger word is written */
896         ipath_flush_wc();
897 }
898
899 /**
900  * ipath_verbs_send - send a packet from the verbs layer
901  * @dd: the infinipath device
902  * @hdrwords: the number of words in the header
903  * @hdr: the packet header
904  * @len: the length of the packet in bytes
905  * @ss: the SGE to send
906  *
907  * This is like ipath_sma_send_pkt() in that we need to be able to send
908  * packets after the chip is initialized (MADs) but also like
909  * ipath_layer_send_hdr() since its used by the verbs layer.
910  */
911 int ipath_verbs_send(struct ipath_devdata *dd, u32 hdrwords,
912                      u32 *hdr, u32 len, struct ipath_sge_state *ss)
913 {
914         u32 __iomem *piobuf;
915         u32 plen;
916         int ret;
917
918         /* +1 is for the qword padding of pbc */
919         plen = hdrwords + ((len + 3) >> 2) + 1;
920         if (unlikely((plen << 2) > dd->ipath_ibmaxlen)) {
921                 ipath_dbg("packet len 0x%x too long, failing\n", plen);
922                 ret = -EINVAL;
923                 goto bail;
924         }
925
926         /* Get a PIO buffer to use. */
927         piobuf = ipath_getpiobuf(dd, NULL);
928         if (unlikely(piobuf == NULL)) {
929                 ret = -EBUSY;
930                 goto bail;
931         }
932
933         /*
934          * Write len to control qword, no flags.
935          * We have to flush after the PBC for correctness on some cpus
936          * or WC buffer can be written out of order.
937          */
938         writeq(plen, piobuf);
939         ipath_flush_wc();
940         piobuf += 2;
941         if (len == 0) {
942                 /*
943                  * If there is just the header portion, must flush before
944                  * writing last word of header for correctness, and after
945                  * the last header word (trigger word).
946                  */
947                 __iowrite32_copy(piobuf, hdr, hdrwords - 1);
948                 ipath_flush_wc();
949                 __raw_writel(hdr[hdrwords - 1], piobuf + hdrwords - 1);
950                 ipath_flush_wc();
951                 ret = 0;
952                 goto bail;
953         }
954
955         __iowrite32_copy(piobuf, hdr, hdrwords);
956         piobuf += hdrwords;
957
958         /* The common case is aligned and contained in one segment. */
959         if (likely(ss->num_sge == 1 && len <= ss->sge.length &&
960                    !((unsigned long)ss->sge.vaddr & (sizeof(u32) - 1)))) {
961                 u32 w;
962                 u32 *addr = (u32 *) ss->sge.vaddr;
963
964                 /* Update address before sending packet. */
965                 update_sge(ss, len);
966                 /* Need to round up for the last dword in the packet. */
967                 w = (len + 3) >> 2;
968                 __iowrite32_copy(piobuf, addr, w - 1);
969                 /* must flush early everything before trigger word */
970                 ipath_flush_wc();
971                 __raw_writel(addr[w - 1], piobuf + w - 1);
972                 /* be sure trigger word is written */
973                 ipath_flush_wc();
974                 ret = 0;
975                 goto bail;
976         }
977         copy_io(piobuf, ss, len);
978         ret = 0;
979
980 bail:
981         return ret;
982 }
983
984 EXPORT_SYMBOL_GPL(ipath_verbs_send);
985
986 int ipath_layer_snapshot_counters(struct ipath_devdata *dd, u64 *swords,
987                                   u64 *rwords, u64 *spkts, u64 *rpkts,
988                                   u64 *xmit_wait)
989 {
990         int ret;
991
992         if (!(dd->ipath_flags & IPATH_INITTED)) {
993                 /* no hardware, freeze, etc. */
994                 ipath_dbg("unit %u not usable\n", dd->ipath_unit);
995                 ret = -EINVAL;
996                 goto bail;
997         }
998         *swords = ipath_snap_cntr(dd, dd->ipath_cregs->cr_wordsendcnt);
999         *rwords = ipath_snap_cntr(dd, dd->ipath_cregs->cr_wordrcvcnt);
1000         *spkts = ipath_snap_cntr(dd, dd->ipath_cregs->cr_pktsendcnt);
1001         *rpkts = ipath_snap_cntr(dd, dd->ipath_cregs->cr_pktrcvcnt);
1002         *xmit_wait = ipath_snap_cntr(dd, dd->ipath_cregs->cr_sendstallcnt);
1003
1004         ret = 0;
1005
1006 bail:
1007         return ret;
1008 }
1009
1010 EXPORT_SYMBOL_GPL(ipath_layer_snapshot_counters);
1011
1012 /**
1013  * ipath_layer_get_counters - get various chip counters
1014  * @dd: the infinipath device
1015  * @cntrs: counters are placed here
1016  *
1017  * Return the counters needed by recv_pma_get_portcounters().
1018  */
1019 int ipath_layer_get_counters(struct ipath_devdata *dd,
1020                               struct ipath_layer_counters *cntrs)
1021 {
1022         int ret;
1023
1024         if (!(dd->ipath_flags & IPATH_INITTED)) {
1025                 /* no hardware, freeze, etc. */
1026                 ipath_dbg("unit %u not usable\n", dd->ipath_unit);
1027                 ret = -EINVAL;
1028                 goto bail;
1029         }
1030         cntrs->symbol_error_counter =
1031                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_ibsymbolerrcnt);
1032         cntrs->link_error_recovery_counter =
1033                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_iblinkerrrecovcnt);
1034         /*
1035          * The link downed counter counts when the other side downs the
1036          * connection.  We add in the number of times we downed the link
1037          * due to local link integrity errors to compensate.
1038          */
1039         cntrs->link_downed_counter =
1040                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_iblinkdowncnt);
1041         cntrs->port_rcv_errors =
1042                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_rxdroppktcnt) +
1043                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_rcvovflcnt) +
1044                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_portovflcnt) +
1045                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_err_rlencnt) +
1046                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_invalidrlencnt) +
1047                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_erricrccnt) +
1048                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_errvcrccnt) +
1049                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_errlpcrccnt) +
1050                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_badformatcnt);
1051         cntrs->port_rcv_remphys_errors =
1052                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_rcvebpcnt);
1053         cntrs->port_xmit_discards =
1054                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_unsupvlcnt);
1055         cntrs->port_xmit_data =
1056                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_wordsendcnt);
1057         cntrs->port_rcv_data =
1058                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_wordrcvcnt);
1059         cntrs->port_xmit_packets =
1060                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_pktsendcnt);
1061         cntrs->port_rcv_packets =
1062                 ipath_snap_cntr(dd, dd->ipath_cregs->cr_pktrcvcnt);
1063         cntrs->local_link_integrity_errors = dd->ipath_lli_errors;
1064         cntrs->excessive_buffer_overrun_errors = 0; /* XXX */
1065
1066         ret = 0;
1067
1068 bail:
1069         return ret;
1070 }
1071
1072 EXPORT_SYMBOL_GPL(ipath_layer_get_counters);
1073
1074 int ipath_layer_want_buffer(struct ipath_devdata *dd)
1075 {
1076         set_bit(IPATH_S_PIOINTBUFAVAIL, &dd->ipath_sendctrl);
1077         ipath_write_kreg(dd, dd->ipath_kregs->kr_sendctrl,
1078                          dd->ipath_sendctrl);
1079
1080         return 0;
1081 }
1082
1083 EXPORT_SYMBOL_GPL(ipath_layer_want_buffer);
1084
1085 int ipath_layer_send_hdr(struct ipath_devdata *dd, struct ether_header *hdr)
1086 {
1087         int ret = 0;
1088         u32 __iomem *piobuf;
1089         u32 plen, *uhdr;
1090         size_t count;
1091         __be16 vlsllnh;
1092
1093         if (!(dd->ipath_flags & IPATH_RCVHDRSZ_SET)) {
1094                 ipath_dbg("send while not open\n");
1095                 ret = -EINVAL;
1096         } else
1097                 if ((dd->ipath_flags & (IPATH_LINKUNK | IPATH_LINKDOWN)) ||
1098                     dd->ipath_lid == 0) {
1099                         /*
1100                          * lid check is for when sma hasn't yet configured
1101                          */
1102                         ret = -ENETDOWN;
1103                         ipath_cdbg(VERBOSE, "send while not ready, "
1104                                    "mylid=%u, flags=0x%x\n",
1105                                    dd->ipath_lid, dd->ipath_flags);
1106                 }
1107
1108         vlsllnh = *((__be16 *) hdr);
1109         if (vlsllnh != htons(IPATH_LRH_BTH)) {
1110                 ipath_dbg("Warning: lrh[0] wrong (%x, not %x); "
1111                           "not sending\n", be16_to_cpu(vlsllnh),
1112                           IPATH_LRH_BTH);
1113                 ret = -EINVAL;
1114         }
1115         if (ret)
1116                 goto done;
1117
1118         /* Get a PIO buffer to use. */
1119         piobuf = ipath_getpiobuf(dd, NULL);
1120         if (piobuf == NULL) {
1121                 ret = -EBUSY;
1122                 goto done;
1123         }
1124
1125         plen = (sizeof(*hdr) >> 2); /* actual length */
1126         ipath_cdbg(EPKT, "0x%x+1w pio %p\n", plen, piobuf);
1127
1128         writeq(plen+1, piobuf); /* len (+1 for pad) to pbc, no flags */
1129         ipath_flush_wc();
1130         piobuf += 2;
1131         uhdr = (u32 *)hdr;
1132         count = plen-1; /* amount we can copy before trigger word */
1133         __iowrite32_copy(piobuf, uhdr, count);
1134         ipath_flush_wc();
1135         __raw_writel(uhdr[count], piobuf + count);
1136         ipath_flush_wc(); /* ensure it's sent, now */
1137
1138         ipath_stats.sps_ether_spkts++;  /* ether packet sent */
1139
1140 done:
1141         return ret;
1142 }
1143
1144 EXPORT_SYMBOL_GPL(ipath_layer_send_hdr);
1145
1146 int ipath_layer_set_piointbufavail_int(struct ipath_devdata *dd)
1147 {
1148         set_bit(IPATH_S_PIOINTBUFAVAIL, &dd->ipath_sendctrl);
1149
1150         ipath_write_kreg(dd, dd->ipath_kregs->kr_sendctrl,
1151                          dd->ipath_sendctrl);
1152         return 0;
1153 }
1154
1155 EXPORT_SYMBOL_GPL(ipath_layer_set_piointbufavail_int);
1156
1157 int ipath_layer_enable_timer(struct ipath_devdata *dd)
1158 {
1159         /*
1160          * HT-400 has a design flaw where the chip and kernel idea
1161          * of the tail register don't always agree, and therefore we won't
1162          * get an interrupt on the next packet received.
1163          * If the board supports per packet receive interrupts, use it.
1164          * Otherwise, the timer function periodically checks for packets
1165          * to cover this case.
1166          * Either way, the timer is needed for verbs layer related
1167          * processing.
1168          */
1169         if (dd->ipath_flags & IPATH_GPIO_INTR) {
1170                 ipath_write_kreg(dd, dd->ipath_kregs->kr_debugportselect,
1171                                  0x2074076542310ULL);
1172                 /* Enable GPIO bit 2 interrupt */
1173                 ipath_write_kreg(dd, dd->ipath_kregs->kr_gpio_mask,
1174                                  (u64) (1 << 2));
1175         }
1176
1177         init_timer(&dd->verbs_layer.l_timer);
1178         dd->verbs_layer.l_timer.function = __ipath_verbs_timer;
1179         dd->verbs_layer.l_timer.data = (unsigned long)dd;
1180         dd->verbs_layer.l_timer.expires = jiffies + 1;
1181         add_timer(&dd->verbs_layer.l_timer);
1182
1183         return 0;
1184 }
1185
1186 EXPORT_SYMBOL_GPL(ipath_layer_enable_timer);
1187
1188 int ipath_layer_disable_timer(struct ipath_devdata *dd)
1189 {
1190         /* Disable GPIO bit 2 interrupt */
1191         if (dd->ipath_flags & IPATH_GPIO_INTR)
1192                 ipath_write_kreg(dd, dd->ipath_kregs->kr_gpio_mask, 0);
1193
1194         del_timer_sync(&dd->verbs_layer.l_timer);
1195
1196         return 0;
1197 }
1198
1199 EXPORT_SYMBOL_GPL(ipath_layer_disable_timer);
1200
1201 /**
1202  * ipath_layer_set_verbs_flags - set the verbs layer flags
1203  * @dd: the infinipath device
1204  * @flags: the flags to set
1205  */
1206 int ipath_layer_set_verbs_flags(struct ipath_devdata *dd, unsigned flags)
1207 {
1208         struct ipath_devdata *ss;
1209         unsigned long lflags;
1210
1211         spin_lock_irqsave(&ipath_devs_lock, lflags);
1212
1213         list_for_each_entry(ss, &ipath_dev_list, ipath_list) {
1214                 if (!(ss->ipath_flags & IPATH_INITTED))
1215                         continue;
1216                 if ((flags & IPATH_VERBS_KERNEL_SMA) &&
1217                     !(*ss->ipath_statusp & IPATH_STATUS_SMA))
1218                         *ss->ipath_statusp |= IPATH_STATUS_OIB_SMA;
1219                 else
1220                         *ss->ipath_statusp &= ~IPATH_STATUS_OIB_SMA;
1221         }
1222
1223         spin_unlock_irqrestore(&ipath_devs_lock, lflags);
1224
1225         return 0;
1226 }
1227
1228 EXPORT_SYMBOL_GPL(ipath_layer_set_verbs_flags);
1229
1230 /**
1231  * ipath_layer_get_npkeys - return the size of the PKEY table for port 0
1232  * @dd: the infinipath device
1233  */
1234 unsigned ipath_layer_get_npkeys(struct ipath_devdata *dd)
1235 {
1236         return ARRAY_SIZE(dd->ipath_pd[0]->port_pkeys);
1237 }
1238
1239 EXPORT_SYMBOL_GPL(ipath_layer_get_npkeys);
1240
1241 /**
1242  * ipath_layer_get_pkey - return the indexed PKEY from the port 0 PKEY table
1243  * @dd: the infinipath device
1244  * @index: the PKEY index
1245  */
1246 unsigned ipath_layer_get_pkey(struct ipath_devdata *dd, unsigned index)
1247 {
1248         unsigned ret;
1249
1250         if (index >= ARRAY_SIZE(dd->ipath_pd[0]->port_pkeys))
1251                 ret = 0;
1252         else
1253                 ret = dd->ipath_pd[0]->port_pkeys[index];
1254
1255         return ret;
1256 }
1257
1258 EXPORT_SYMBOL_GPL(ipath_layer_get_pkey);
1259
1260 /**
1261  * ipath_layer_get_pkeys - return the PKEY table for port 0
1262  * @dd: the infinipath device
1263  * @pkeys: the pkey table is placed here
1264  */
1265 int ipath_layer_get_pkeys(struct ipath_devdata *dd, u16 * pkeys)
1266 {
1267         struct ipath_portdata *pd = dd->ipath_pd[0];
1268
1269         memcpy(pkeys, pd->port_pkeys, sizeof(pd->port_pkeys));
1270
1271         return 0;
1272 }
1273
1274 EXPORT_SYMBOL_GPL(ipath_layer_get_pkeys);
1275
1276 /**
1277  * rm_pkey - decrecment the reference count for the given PKEY
1278  * @dd: the infinipath device
1279  * @key: the PKEY index
1280  *
1281  * Return true if this was the last reference and the hardware table entry
1282  * needs to be changed.
1283  */
1284 static int rm_pkey(struct ipath_devdata *dd, u16 key)
1285 {
1286         int i;
1287         int ret;
1288
1289         for (i = 0; i < ARRAY_SIZE(dd->ipath_pkeys); i++) {
1290                 if (dd->ipath_pkeys[i] != key)
1291                         continue;
1292                 if (atomic_dec_and_test(&dd->ipath_pkeyrefs[i])) {
1293                         dd->ipath_pkeys[i] = 0;
1294                         ret = 1;
1295                         goto bail;
1296                 }
1297                 break;
1298         }
1299
1300         ret = 0;
1301
1302 bail:
1303         return ret;
1304 }
1305
1306 /**
1307  * add_pkey - add the given PKEY to the hardware table
1308  * @dd: the infinipath device
1309  * @key: the PKEY
1310  *
1311  * Return an error code if unable to add the entry, zero if no change,
1312  * or 1 if the hardware PKEY register needs to be updated.
1313  */
1314 static int add_pkey(struct ipath_devdata *dd, u16 key)
1315 {
1316         int i;
1317         u16 lkey = key & 0x7FFF;
1318         int any = 0;
1319         int ret;
1320
1321         if (lkey == 0x7FFF) {
1322                 ret = 0;
1323                 goto bail;
1324         }
1325
1326         /* Look for an empty slot or a matching PKEY. */
1327         for (i = 0; i < ARRAY_SIZE(dd->ipath_pkeys); i++) {
1328                 if (!dd->ipath_pkeys[i]) {
1329                         any++;
1330                         continue;
1331                 }
1332                 /* If it matches exactly, try to increment the ref count */
1333                 if (dd->ipath_pkeys[i] == key) {
1334                         if (atomic_inc_return(&dd->ipath_pkeyrefs[i]) > 1) {
1335                                 ret = 0;
1336                                 goto bail;
1337                         }
1338                         /* Lost the race. Look for an empty slot below. */
1339                         atomic_dec(&dd->ipath_pkeyrefs[i]);
1340                         any++;
1341                 }
1342                 /*
1343                  * It makes no sense to have both the limited and unlimited
1344                  * PKEY set at the same time since the unlimited one will
1345                  * disable the limited one.
1346                  */
1347                 if ((dd->ipath_pkeys[i] & 0x7FFF) == lkey) {
1348                         ret = -EEXIST;
1349                         goto bail;
1350                 }
1351         }
1352         if (!any) {
1353                 ret = -EBUSY;
1354                 goto bail;
1355         }
1356         for (i = 0; i < ARRAY_SIZE(dd->ipath_pkeys); i++) {
1357                 if (!dd->ipath_pkeys[i] &&
1358                     atomic_inc_return(&dd->ipath_pkeyrefs[i]) == 1) {
1359                         /* for ipathstats, etc. */
1360                         ipath_stats.sps_pkeys[i] = lkey;
1361                         dd->ipath_pkeys[i] = key;
1362                         ret = 1;
1363                         goto bail;
1364                 }
1365         }
1366         ret = -EBUSY;
1367
1368 bail:
1369         return ret;
1370 }
1371
1372 /**
1373  * ipath_layer_set_pkeys - set the PKEY table for port 0
1374  * @dd: the infinipath device
1375  * @pkeys: the PKEY table
1376  */
1377 int ipath_layer_set_pkeys(struct ipath_devdata *dd, u16 * pkeys)
1378 {
1379         struct ipath_portdata *pd;
1380         int i;
1381         int changed = 0;
1382
1383         pd = dd->ipath_pd[0];
1384
1385         for (i = 0; i < ARRAY_SIZE(pd->port_pkeys); i++) {
1386                 u16 key = pkeys[i];
1387                 u16 okey = pd->port_pkeys[i];
1388
1389                 if (key == okey)
1390                         continue;
1391                 /*
1392                  * The value of this PKEY table entry is changing.
1393                  * Remove the old entry in the hardware's array of PKEYs.
1394                  */
1395                 if (okey & 0x7FFF)
1396                         changed |= rm_pkey(dd, okey);
1397                 if (key & 0x7FFF) {
1398                         int ret = add_pkey(dd, key);
1399
1400                         if (ret < 0)
1401                                 key = 0;
1402                         else
1403                                 changed |= ret;
1404                 }
1405                 pd->port_pkeys[i] = key;
1406         }
1407         if (changed) {
1408                 u64 pkey;
1409
1410                 pkey = (u64) dd->ipath_pkeys[0] |
1411                         ((u64) dd->ipath_pkeys[1] << 16) |
1412                         ((u64) dd->ipath_pkeys[2] << 32) |
1413                         ((u64) dd->ipath_pkeys[3] << 48);
1414                 ipath_cdbg(VERBOSE, "p0 new pkey reg %llx\n",
1415                            (unsigned long long) pkey);
1416                 ipath_write_kreg(dd, dd->ipath_kregs->kr_partitionkey,
1417                                  pkey);
1418         }
1419         return 0;
1420 }
1421
1422 EXPORT_SYMBOL_GPL(ipath_layer_set_pkeys);
1423
1424 /**
1425  * ipath_layer_get_linkdowndefaultstate - get the default linkdown state
1426  * @dd: the infinipath device
1427  *
1428  * Returns zero if the default is POLL, 1 if the default is SLEEP.
1429  */
1430 int ipath_layer_get_linkdowndefaultstate(struct ipath_devdata *dd)
1431 {
1432         return !!(dd->ipath_ibcctrl & INFINIPATH_IBCC_LINKDOWNDEFAULTSTATE);
1433 }
1434
1435 EXPORT_SYMBOL_GPL(ipath_layer_get_linkdowndefaultstate);
1436
1437 /**
1438  * ipath_layer_set_linkdowndefaultstate - set the default linkdown state
1439  * @dd: the infinipath device
1440  * @sleep: the new state
1441  *
1442  * Note that this will only take effect when the link state changes.
1443  */
1444 int ipath_layer_set_linkdowndefaultstate(struct ipath_devdata *dd,
1445                                          int sleep)
1446 {
1447         if (sleep)
1448                 dd->ipath_ibcctrl |= INFINIPATH_IBCC_LINKDOWNDEFAULTSTATE;
1449         else
1450                 dd->ipath_ibcctrl &= ~INFINIPATH_IBCC_LINKDOWNDEFAULTSTATE;
1451         ipath_write_kreg(dd, dd->ipath_kregs->kr_ibcctrl,
1452                          dd->ipath_ibcctrl);
1453         return 0;
1454 }
1455
1456 EXPORT_SYMBOL_GPL(ipath_layer_set_linkdowndefaultstate);
1457
1458 int ipath_layer_get_phyerrthreshold(struct ipath_devdata *dd)
1459 {
1460         return (dd->ipath_ibcctrl >>
1461                 INFINIPATH_IBCC_PHYERRTHRESHOLD_SHIFT) &
1462                 INFINIPATH_IBCC_PHYERRTHRESHOLD_MASK;
1463 }
1464
1465 EXPORT_SYMBOL_GPL(ipath_layer_get_phyerrthreshold);
1466
1467 /**
1468  * ipath_layer_set_phyerrthreshold - set the physical error threshold
1469  * @dd: the infinipath device
1470  * @n: the new threshold
1471  *
1472  * Note that this will only take effect when the link state changes.
1473  */
1474 int ipath_layer_set_phyerrthreshold(struct ipath_devdata *dd, unsigned n)
1475 {
1476         unsigned v;
1477
1478         v = (dd->ipath_ibcctrl >> INFINIPATH_IBCC_PHYERRTHRESHOLD_SHIFT) &
1479                 INFINIPATH_IBCC_PHYERRTHRESHOLD_MASK;
1480         if (v != n) {
1481                 dd->ipath_ibcctrl &=
1482                         ~(INFINIPATH_IBCC_PHYERRTHRESHOLD_MASK <<
1483                           INFINIPATH_IBCC_PHYERRTHRESHOLD_SHIFT);
1484                 dd->ipath_ibcctrl |=
1485                         (u64) n << INFINIPATH_IBCC_PHYERRTHRESHOLD_SHIFT;
1486                 ipath_write_kreg(dd, dd->ipath_kregs->kr_ibcctrl,
1487                                  dd->ipath_ibcctrl);
1488         }
1489         return 0;
1490 }
1491
1492 EXPORT_SYMBOL_GPL(ipath_layer_set_phyerrthreshold);
1493
1494 int ipath_layer_get_overrunthreshold(struct ipath_devdata *dd)
1495 {
1496         return (dd->ipath_ibcctrl >>
1497                 INFINIPATH_IBCC_OVERRUNTHRESHOLD_SHIFT) &
1498                 INFINIPATH_IBCC_OVERRUNTHRESHOLD_MASK;
1499 }
1500
1501 EXPORT_SYMBOL_GPL(ipath_layer_get_overrunthreshold);
1502
1503 /**
1504  * ipath_layer_set_overrunthreshold - set the overrun threshold
1505  * @dd: the infinipath device
1506  * @n: the new threshold
1507  *
1508  * Note that this will only take effect when the link state changes.
1509  */
1510 int ipath_layer_set_overrunthreshold(struct ipath_devdata *dd, unsigned n)
1511 {
1512         unsigned v;
1513
1514         v = (dd->ipath_ibcctrl >> INFINIPATH_IBCC_OVERRUNTHRESHOLD_SHIFT) &
1515                 INFINIPATH_IBCC_OVERRUNTHRESHOLD_MASK;
1516         if (v != n) {
1517                 dd->ipath_ibcctrl &=
1518                         ~(INFINIPATH_IBCC_OVERRUNTHRESHOLD_MASK <<
1519                           INFINIPATH_IBCC_OVERRUNTHRESHOLD_SHIFT);
1520                 dd->ipath_ibcctrl |=
1521                         (u64) n << INFINIPATH_IBCC_OVERRUNTHRESHOLD_SHIFT;
1522                 ipath_write_kreg(dd, dd->ipath_kregs->kr_ibcctrl,
1523                                  dd->ipath_ibcctrl);
1524         }
1525         return 0;
1526 }
1527
1528 EXPORT_SYMBOL_GPL(ipath_layer_set_overrunthreshold);
1529
1530 int ipath_layer_get_boardname(struct ipath_devdata *dd, char *name,
1531                               size_t namelen)
1532 {
1533         return dd->ipath_f_get_boardname(dd, name, namelen);
1534 }
1535 EXPORT_SYMBOL_GPL(ipath_layer_get_boardname);
1536
1537 u32 ipath_layer_get_rcvhdrentsize(struct ipath_devdata *dd)
1538 {
1539         return dd->ipath_rcvhdrentsize;
1540 }
1541 EXPORT_SYMBOL_GPL(ipath_layer_get_rcvhdrentsize);