drivers/infiniband/sw/rdmavt/vt.c

   1 /*
   2  * Copyright(c) 2015 Intel Corporation.
   3  *
   4  * This file is provided under a dual BSD/GPLv2 license.  When using or
   5  * redistributing this file, you may do so under either license.
   6  *
   7  * GPL LICENSE SUMMARY
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of version 2 of the GNU General Public License as
  11  * published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * BSD LICENSE
  19  *
  20  * Redistribution and use in source and binary forms, with or without
  21  * modification, are permitted provided that the following conditions
  22  * are met:
  23  *
  24  *  - Redistributions of source code must retain the above copyright
  25  *    notice, this list of conditions and the following disclaimer.
  26  *  - Redistributions in binary form must reproduce the above copyright
  27  *    notice, this list of conditions and the following disclaimer in
  28  *    the documentation and/or other materials provided with the
  29  *    distribution.
  30  *  - Neither the name of Intel Corporation nor the names of its
  31  *    contributors may be used to endorse or promote products derived
  32  *    from this software without specific prior written permission.
  33  *
  34  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  35  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  36  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  37  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  38  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  39  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  40  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  41  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  42  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  43  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  44  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  45  *
  46  */
  47
  48 #include <linux/module.h>
  49 #include <linux/kernel.h>
  50 #include "vt.h"
  51
  52 MODULE_LICENSE("Dual BSD/GPL");
  53 MODULE_DESCRIPTION("RDMA Verbs Transport Library");
  54
  55 static int rvt_init(void)
  56 {
  57         /* Do any work needed prior to drivers calling for registration*/
  58         return 0;
  59 }
  60 module_init(rvt_init);
  61
  62 static void rvt_cleanup(void)
  63 {
  64 }
  65 module_exit(rvt_cleanup);
  66
  67 static int rvt_query_device(struct ib_device *ibdev,
  68                             struct ib_device_attr *props,
  69                             struct ib_udata *uhw)
  70 {
  71         /*
  72          * Return rvt_dev_info.props contents
  73          */
  74         return -EOPNOTSUPP;
  75 }
  76
  77 static int rvt_modify_device(struct ib_device *device,
  78                              int device_modify_mask,
  79                              struct ib_device_modify *device_modify)
  80 {
  81         /*
  82          * Change dev props. Planned support is for node desc change and sys
  83          * guid change only. This matches hfi1 and qib behavior. Other drivers
  84          * that support existing modifications will need to add their support.
  85          */
  86
  87         /*
  88          * VT-DRIVER-API: node_desc_change()
  89          * VT-DRIVER-API: sys_guid_change()
  90          */
  91         return -EOPNOTSUPP;
  92 }
  93
  94 /**
  95  * rvt_query_port: Passes the query port call to the driver
  96  * @ibdev: Verbs IB dev
  97  * @port: port number
  98  * @props: structure to hold returned properties
  99  *
 100  * Returns 0 on success
 101  */
 102 static int rvt_query_port(struct ib_device *ibdev, u8 port,
 103                           struct ib_port_attr *props)
 104 {
 105         /*
 106          * VT-DRIVER-API: query_port_state()
 107          * driver returns pretty much everything in ib_port_attr
 108          */
 109         return -EOPNOTSUPP;
 110 }
 111
 112 /**
 113  * rvt_modify_port
 114  * @ibdev: Verbs IB dev
 115  * @port: Port number
 116  * @port_modify_mask: How to change the port
 117  * @props: Structure to fill in
 118  *
 119  * Returns 0 on success
 120  */
 121 static int rvt_modify_port(struct ib_device *ibdev, u8 port,
 122                            int port_modify_mask, struct ib_port_modify *props)
 123 {
 124         /*
 125          * VT-DRIVER-API: set_link_state()
 126          * driver will set the link state using the IB enumeration
 127          *
 128          * VT-DRIVER-API: clear_qkey_violations()
 129          * clears driver private qkey counter
 130          *
 131          * VT-DRIVER-API: get_lid()
 132          * driver needs to return the LID
 133          *
 134          * TBD: send_trap() and post_mad_send() need examined to see where they
 135          * fit in.
 136          */
 137         return -EOPNOTSUPP;
 138 }
 139
 140 /**
 141  * rvt_query_pkey - Return a pkey from the table at a given index
 142  * @ibdev: Verbs IB dev
 143  * @port: Port number
 144  * @intex: Index into pkey table
 145  *
 146  * Returns 0 on failure pkey otherwise
 147  */
 148 static int rvt_query_pkey(struct ib_device *ibdev, u8 port, u16 index,
 149                           u16 *pkey)
 150 {
 151         /*
 152          * Driver will be responsible for keeping rvt_dev_info.pkey_table up to
 153          * date. This function will just return that value. There is no need to
 154          * lock, if a stale value is read and sent to the user so be it there is
 155          * no way to protect against that anyway.
 156          */
 157         return 0;
 158 }
 159
 160 /**
 161  * rvt_query_gid - Return a gid from the table
 162  * @ibdev: Verbs IB dev
 163  * @port: Port number
 164  * @index: = Index in table
 165  * @gid: Gid to return
 166  *
 167  * Returns 0 on success
 168  */
 169 static int rvt_query_gid(struct ib_device *ibdev, u8 port,
 170                          int index, union ib_gid *gid)
 171 {
 172         /*
 173          * Driver is responsible for updating the guid table. Which will be used
 174          * to craft the return value. This will work similar to how query_pkey()
 175          * is being done.
 176          */
 177
 178         return -EOPNOTSUPP;
 179 }
 180
 181 /*
 182  * Check driver override. If driver passes a value use it, otherwise we use our
 183  * own value.
 184  */
 185 #define CHECK_DRIVER_OVERRIDE(rdi, x) \
 186         rdi->ibdev.x = rdi->ibdev.x ? : rvt_ ##x
 187
 188 int rvt_register_device(struct rvt_dev_info *rdi)
 189 {
 190         if (!rdi)
 191                 return -EINVAL;
 192
 193         /* Dev Ops */
 194         CHECK_DRIVER_OVERRIDE(rdi, query_device);
 195         CHECK_DRIVER_OVERRIDE(rdi, modify_device);
 196         CHECK_DRIVER_OVERRIDE(rdi, query_port);
 197         CHECK_DRIVER_OVERRIDE(rdi, modify_port);
 198         CHECK_DRIVER_OVERRIDE(rdi, query_pkey);
 199         CHECK_DRIVER_OVERRIDE(rdi, query_gid);
 200
 201         /* DMA Operations */
 202         rdi->ibdev.dma_ops =
 203                 rdi->ibdev.dma_ops ? : &rvt_default_dma_mapping_ops;
 204
 205         /* Protection Domain */
 206         CHECK_DRIVER_OVERRIDE(rdi, alloc_pd);
 207         CHECK_DRIVER_OVERRIDE(rdi, dealloc_pd);
 208         spin_lock_init(&rdi->n_pds_lock);
 209         rdi->n_pds_allocated = 0;
 210
 211         /* We are now good to announce we exist */
 212         return ib_register_device(&rdi->ibdev, rdi->port_callback);
 213 }
 214 EXPORT_SYMBOL(rvt_register_device);
 215
 216 void rvt_unregister_device(struct rvt_dev_info *rdi)
 217 {
 218         if (!rdi)
 219                 return;
 220
 221         ib_unregister_device(&rdi->ibdev);
 222 }
 223 EXPORT_SYMBOL(rvt_unregister_device);