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