mthca_mad.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*
    2  * Copyright (c) 2004 Topspin Communications.  All rights reserved.
    3  * Copyright (c) 2005 Mellanox Technologies. All rights reserved.
    4  * Copyright (c) 2004 Voltaire, Inc. All rights reserved.
    5  *
    6  * This software is available to you under a choice of one of two
    7  * licenses.  You may choose to be licensed under the terms of the GNU
    8  * General Public License (GPL) Version 2, available from the file
    9  * COPYING in the main directory of this source tree, or the
   10  * OpenIB.org BSD license below:
   11  *
   12  *     Redistribution and use in source and binary forms, with or
   13  *     without modification, are permitted provided that the following
   14  *     conditions are met:
   15  *
   16  *      - Redistributions of source code must retain the above
   17  *        copyright notice, this list of conditions and the following
   18  *        disclaimer.
   19  *
   20  *      - Redistributions in binary form must reproduce the above
   21  *        copyright notice, this list of conditions and the following
   22  *        disclaimer in the documentation and/or other materials
   23  *        provided with the distribution.
   24  *
   25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
   28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
   29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
   30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
   31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   32  * SOFTWARE.
   33  */
   34 
   35 #include <linux/string.h>
   36 #include <linux/slab.h>
   37 
   38 #include <rdma/ib_verbs.h>
   39 #include <rdma/ib_mad.h>
   40 #include <rdma/ib_smi.h>
   41 
   42 #include "mthca_dev.h"
   43 #include "mthca_cmd.h"
   44 
   45 enum {
   46         MTHCA_VENDOR_CLASS1 = 0x9,
   47         MTHCA_VENDOR_CLASS2 = 0xa
   48 };
   49 
   50 static int mthca_update_rate(struct mthca_dev *dev, u8 port_num)
   51 {
   52         struct ib_port_attr *tprops = NULL;
   53         int                  ret;
   54 
   55         tprops = kmalloc(sizeof *tprops, GFP_KERNEL);
   56         if (!tprops)
   57                 return -ENOMEM;
   58 
   59         ret = ib_query_port(&dev->ib_dev, port_num, tprops);
   60         if (ret) {
   61                 printk(KERN_WARNING "ib_query_port failed (%d) for %s port %d\n",
   62                        ret, dev->ib_dev.name, port_num);
   63                 goto out;
   64         }
   65 
   66         dev->rate[port_num - 1] = tprops->active_speed *
   67                                   ib_width_enum_to_int(tprops->active_width);
   68 
   69 out:
   70         kfree(tprops);
   71         return ret;
   72 }
   73 
   74 static void update_sm_ah(struct mthca_dev *dev,
   75                          u8 port_num, u16 lid, u8 sl)
   76 {
   77         struct ib_ah *new_ah;
   78         struct ib_ah_attr ah_attr;
   79         unsigned long flags;
   80 
   81         if (!dev->send_agent[port_num - 1][0])
   82                 return;
   83 
   84         memset(&ah_attr, 0, sizeof ah_attr);
   85         ah_attr.dlid     = lid;
   86         ah_attr.sl       = sl;
   87         ah_attr.port_num = port_num;
   88 
   89         new_ah = ib_create_ah(dev->send_agent[port_num - 1][0]->qp->pd,
   90                               &ah_attr);
   91         if (IS_ERR(new_ah))
   92                 return;
   93 
   94         spin_lock_irqsave(&dev->sm_lock, flags);
   95         if (dev->sm_ah[port_num - 1])
   96                 ib_destroy_ah(dev->sm_ah[port_num - 1]);
   97         dev->sm_ah[port_num - 1] = new_ah;
   98         spin_unlock_irqrestore(&dev->sm_lock, flags);
   99 }
  100 
  101 /*
  102  * Snoop SM MADs for port info and P_Key table sets, so we can
  103  * synthesize LID change and P_Key change events.
  104  */
  105 static void smp_snoop(struct ib_device *ibdev,
  106                       u8 port_num,
  107                       const struct ib_mad *mad,
  108                       u16 prev_lid)
  109 {
  110         struct ib_event event;
  111 
  112         if ((mad->mad_hdr.mgmt_class  == IB_MGMT_CLASS_SUBN_LID_ROUTED ||
  113              mad->mad_hdr.mgmt_class  == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) &&
  114             mad->mad_hdr.method     == IB_MGMT_METHOD_SET) {
  115                 if (mad->mad_hdr.attr_id == IB_SMP_ATTR_PORT_INFO) {
  116                         struct ib_port_info *pinfo =
  117                                 (struct ib_port_info *) ((struct ib_smp *) mad)->data;
  118                         u16 lid = be16_to_cpu(pinfo->lid);
  119 
  120                         mthca_update_rate(to_mdev(ibdev), port_num);
  121                         update_sm_ah(to_mdev(ibdev), port_num,
  122                                      be16_to_cpu(pinfo->sm_lid),
  123                                      pinfo->neighbormtu_mastersmsl & 0xf);
  124 
  125                         event.device           = ibdev;
  126                         event.element.port_num = port_num;
  127 
  128                         if (pinfo->clientrereg_resv_subnetto & 0x80) {
  129                                 event.event    = IB_EVENT_CLIENT_REREGISTER;
  130                                 ib_dispatch_event(&event);
  131                         }
  132 
  133                         if (prev_lid != lid) {
  134                                 event.event    = IB_EVENT_LID_CHANGE;
  135                                 ib_dispatch_event(&event);
  136                         }
  137                 }
  138 
  139                 if (mad->mad_hdr.attr_id == IB_SMP_ATTR_PKEY_TABLE) {
  140                         event.device           = ibdev;
  141                         event.event            = IB_EVENT_PKEY_CHANGE;
  142                         event.element.port_num = port_num;
  143                         ib_dispatch_event(&event);
  144                 }
  145         }
  146 }
  147 
  148 static void node_desc_override(struct ib_device *dev,
  149                                struct ib_mad *mad)
  150 {
  151         if ((mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_LID_ROUTED ||
  152              mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) &&
  153             mad->mad_hdr.method == IB_MGMT_METHOD_GET_RESP &&
  154             mad->mad_hdr.attr_id == IB_SMP_ATTR_NODE_DESC) {
  155                 mutex_lock(&to_mdev(dev)->cap_mask_mutex);
  156                 memcpy(((struct ib_smp *) mad)->data, dev->node_desc,
  157                        IB_DEVICE_NODE_DESC_MAX);
  158                 mutex_unlock(&to_mdev(dev)->cap_mask_mutex);
  159         }
  160 }
  161 
  162 static void forward_trap(struct mthca_dev *dev,
  163                          u8 port_num,
  164                          const struct ib_mad *mad)
  165 {
  166         int qpn = mad->mad_hdr.mgmt_class != IB_MGMT_CLASS_SUBN_LID_ROUTED;
  167         struct ib_mad_send_buf *send_buf;
  168         struct ib_mad_agent *agent = dev->send_agent[port_num - 1][qpn];
  169         int ret;
  170         unsigned long flags;
  171 
  172         if (agent) {
  173                 send_buf = ib_create_send_mad(agent, qpn, 0, 0, IB_MGMT_MAD_HDR,
  174                                               IB_MGMT_MAD_DATA, GFP_ATOMIC,
  175                                               IB_MGMT_BASE_VERSION);
  176                 if (IS_ERR(send_buf))
  177                         return;
  178                 /*
  179                  * We rely here on the fact that MLX QPs don't use the
  180                  * address handle after the send is posted (this is
  181                  * wrong following the IB spec strictly, but we know
  182                  * it's OK for our devices).
  183                  */
  184                 spin_lock_irqsave(&dev->sm_lock, flags);
  185                 memcpy(send_buf->mad, mad, sizeof *mad);
  186                 if ((send_buf->ah = dev->sm_ah[port_num - 1]))
  187                         ret = ib_post_send_mad(send_buf, NULL);
  188                 else
  189                         ret = -EINVAL;
  190                 spin_unlock_irqrestore(&dev->sm_lock, flags);
  191 
  192                 if (ret)
  193                         ib_free_send_mad(send_buf);
  194         }
  195 }
  196 
  197 int mthca_process_mad(struct ib_device *ibdev,
  198                       int mad_flags,
  199                       u8 port_num,
  200                       const struct ib_wc *in_wc,
  201                       const struct ib_grh *in_grh,
  202                       const struct ib_mad_hdr *in, size_t in_mad_size,
  203                       struct ib_mad_hdr *out, size_t *out_mad_size,
  204                       u16 *out_mad_pkey_index)
  205 {
  206         int err;
  207         u16 slid = in_wc ? in_wc->slid : be16_to_cpu(IB_LID_PERMISSIVE);
  208         u16 prev_lid = 0;
  209         struct ib_port_attr pattr;
  210         const struct ib_mad *in_mad = (const struct ib_mad *)in;
  211         struct ib_mad *out_mad = (struct ib_mad *)out;
  212 
  213         if (WARN_ON_ONCE(in_mad_size != sizeof(*in_mad) ||
  214                          *out_mad_size != sizeof(*out_mad)))
  215                 return IB_MAD_RESULT_FAILURE;
  216 
  217         /* Forward locally generated traps to the SM */
  218         if (in_mad->mad_hdr.method == IB_MGMT_METHOD_TRAP &&
  219             slid == 0) {
  220                 forward_trap(to_mdev(ibdev), port_num, in_mad);
  221                 return IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_CONSUMED;
  222         }
  223 
  224         /*
  225          * Only handle SM gets, sets and trap represses for SM class
  226          *
  227          * Only handle PMA and Mellanox vendor-specific class gets and
  228          * sets for other classes.
  229          */
  230         if (in_mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_LID_ROUTED ||
  231             in_mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) {
  232                 if (in_mad->mad_hdr.method   != IB_MGMT_METHOD_GET &&
  233                     in_mad->mad_hdr.method   != IB_MGMT_METHOD_SET &&
  234                     in_mad->mad_hdr.method   != IB_MGMT_METHOD_TRAP_REPRESS)
  235                         return IB_MAD_RESULT_SUCCESS;
  236 
  237                 /*
  238                  * Don't process SMInfo queries or vendor-specific
  239                  * MADs -- the SMA can't handle them.
  240                  */
  241                 if (in_mad->mad_hdr.attr_id == IB_SMP_ATTR_SM_INFO ||
  242                     ((in_mad->mad_hdr.attr_id & IB_SMP_ATTR_VENDOR_MASK) ==
  243                      IB_SMP_ATTR_VENDOR_MASK))
  244                         return IB_MAD_RESULT_SUCCESS;
  245         } else if (in_mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_PERF_MGMT ||
  246                    in_mad->mad_hdr.mgmt_class == MTHCA_VENDOR_CLASS1     ||
  247                    in_mad->mad_hdr.mgmt_class == MTHCA_VENDOR_CLASS2) {
  248                 if (in_mad->mad_hdr.method  != IB_MGMT_METHOD_GET &&
  249                     in_mad->mad_hdr.method  != IB_MGMT_METHOD_SET)
  250                         return IB_MAD_RESULT_SUCCESS;
  251         } else
  252                 return IB_MAD_RESULT_SUCCESS;
  253         if ((in_mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_LID_ROUTED ||
  254              in_mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) &&
  255             in_mad->mad_hdr.method == IB_MGMT_METHOD_SET &&
  256             in_mad->mad_hdr.attr_id == IB_SMP_ATTR_PORT_INFO &&
  257             !ib_query_port(ibdev, port_num, &pattr))
  258                 prev_lid = pattr.lid;
  259 
  260         err = mthca_MAD_IFC(to_mdev(ibdev),
  261                             mad_flags & IB_MAD_IGNORE_MKEY,
  262                             mad_flags & IB_MAD_IGNORE_BKEY,
  263                             port_num, in_wc, in_grh, in_mad, out_mad);
  264         if (err == -EBADMSG)
  265                 return IB_MAD_RESULT_SUCCESS;
  266         else if (err) {
  267                 mthca_err(to_mdev(ibdev), "MAD_IFC returned %d\n", err);
  268                 return IB_MAD_RESULT_FAILURE;
  269         }
  270 
  271         if (!out_mad->mad_hdr.status) {
  272                 smp_snoop(ibdev, port_num, in_mad, prev_lid);
  273                 node_desc_override(ibdev, out_mad);
  274         }
  275 
  276         /* set return bit in status of directed route responses */
  277         if (in_mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)
  278                 out_mad->mad_hdr.status |= cpu_to_be16(1 << 15);
  279 
  280         if (in_mad->mad_hdr.method == IB_MGMT_METHOD_TRAP_REPRESS)
  281                 /* no response for trap repress */
  282                 return IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_CONSUMED;
  283 
  284         return IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY;
  285 }
  286 
  287 static void send_handler(struct ib_mad_agent *agent,
  288                          struct ib_mad_send_wc *mad_send_wc)
  289 {
  290         ib_free_send_mad(mad_send_wc->send_buf);
  291 }
  292 
  293 int mthca_create_agents(struct mthca_dev *dev)
  294 {
  295         struct ib_mad_agent *agent;
  296         int p, q;
  297         int ret;
  298 
  299         spin_lock_init(&dev->sm_lock);
  300 
  301         for (p = 0; p < dev->limits.num_ports; ++p)
  302                 for (q = 0; q <= 1; ++q) {
  303                         agent = ib_register_mad_agent(&dev->ib_dev, p + 1,
  304                                                       q ? IB_QPT_GSI : IB_QPT_SMI,
  305                                                       NULL, 0, send_handler,
  306                                                       NULL, NULL, 0);
  307                         if (IS_ERR(agent)) {
  308                                 ret = PTR_ERR(agent);
  309                                 goto err;
  310                         }
  311                         dev->send_agent[p][q] = agent;
  312                 }
  313 
  314 
  315         for (p = 1; p <= dev->limits.num_ports; ++p) {
  316                 ret = mthca_update_rate(dev, p);
  317                 if (ret) {
  318                         mthca_err(dev, "Failed to obtain port %d rate."
  319                                   " aborting.\n", p);
  320                         goto err;
  321                 }
  322         }
  323 
  324         return 0;
  325 
  326 err:
  327         for (p = 0; p < dev->limits.num_ports; ++p)
  328                 for (q = 0; q <= 1; ++q)
  329                         if (dev->send_agent[p][q])
  330                                 ib_unregister_mad_agent(dev->send_agent[p][q]);
  331 
  332         return ret;
  333 }
  334 
  335 void mthca_free_agents(struct mthca_dev *dev)
  336 {
  337         struct ib_mad_agent *agent;
  338         int p, q;
  339 
  340         for (p = 0; p < dev->limits.num_ports; ++p) {
  341                 for (q = 0; q <= 1; ++q) {
  342                         agent = dev->send_agent[p][q];
  343                         dev->send_agent[p][q] = NULL;
  344                         ib_unregister_mad_agent(agent);
  345                 }
  346 
  347                 if (dev->sm_ah[p])
  348                         ib_destroy_ah(dev->sm_ah[p]);
  349         }
  350 }
Cache object: c8e9586fd976ddf59defb6534bd0451e
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/mthca/mthca_mad.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/mthca/mthca_mad.c
