drivers/infiniband/core/verbs.c

   1 /*
   2  * Copyright (c) 2004 Mellanox Technologies Ltd.  All rights reserved.
   3  * Copyright (c) 2004 Infinicon Corporation.  All rights reserved.
   4  * Copyright (c) 2004 Intel Corporation.  All rights reserved.
   5  * Copyright (c) 2004 Topspin Corporation.  All rights reserved.
   6  * Copyright (c) 2004 Voltaire Corporation.  All rights reserved.
   7  * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
   8  * Copyright (c) 2005, 2006 Cisco Systems.  All rights reserved.
   9  *
  10  * This software is available to you under a choice of one of two
  11  * licenses.  You may choose to be licensed under the terms of the GNU
  12  * General Public License (GPL) Version 2, available from the file
  13  * COPYING in the main directory of this source tree, or the
  14  * OpenIB.org BSD license below:
  15  *
  16  *     Redistribution and use in source and binary forms, with or
  17  *     without modification, are permitted provided that the following
  18  *     conditions are met:
  19  *
  20  *      - Redistributions of source code must retain the above
  21  *        copyright notice, this list of conditions and the following
  22  *        disclaimer.
  23  *
  24  *      - Redistributions in binary form must reproduce the above
  25  *        copyright notice, this list of conditions and the following
  26  *        disclaimer in the documentation and/or other materials
  27  *        provided with the distribution.
  28  *
  29  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  30  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  31  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  32  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  33  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  34  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  35  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  36  * SOFTWARE.
  37  */
  38
  39 #include <linux/errno.h>
  40 #include <linux/err.h>
  41 #include <linux/string.h>
  42
  43 #include <rdma/ib_verbs.h>
  44 #include <rdma/ib_cache.h>
  45
  46 int ib_rate_to_mult(enum ib_rate rate)
  47 {
  48         switch (rate) {
  49         case IB_RATE_2_5_GBPS: return  1;
  50         case IB_RATE_5_GBPS:   return  2;
  51         case IB_RATE_10_GBPS:  return  4;
  52         case IB_RATE_20_GBPS:  return  8;
  53         case IB_RATE_30_GBPS:  return 12;
  54         case IB_RATE_40_GBPS:  return 16;
  55         case IB_RATE_60_GBPS:  return 24;
  56         case IB_RATE_80_GBPS:  return 32;
  57         case IB_RATE_120_GBPS: return 48;
  58         default:               return -1;
  59         }
  60 }
  61 EXPORT_SYMBOL(ib_rate_to_mult);
  62
  63 enum ib_rate mult_to_ib_rate(int mult)
  64 {
  65         switch (mult) {
  66         case 1:  return IB_RATE_2_5_GBPS;
  67         case 2:  return IB_RATE_5_GBPS;
  68         case 4:  return IB_RATE_10_GBPS;
  69         case 8:  return IB_RATE_20_GBPS;
  70         case 12: return IB_RATE_30_GBPS;
  71         case 16: return IB_RATE_40_GBPS;
  72         case 24: return IB_RATE_60_GBPS;
  73         case 32: return IB_RATE_80_GBPS;
  74         case 48: return IB_RATE_120_GBPS;
  75         default: return IB_RATE_PORT_CURRENT;
  76         }
  77 }
  78 EXPORT_SYMBOL(mult_to_ib_rate);
  79
  80 enum rdma_transport_type
  81 rdma_node_get_transport(enum rdma_node_type node_type)
  82 {
  83         switch (node_type) {
  84         case RDMA_NODE_IB_CA:
  85         case RDMA_NODE_IB_SWITCH:
  86         case RDMA_NODE_IB_ROUTER:
  87                 return RDMA_TRANSPORT_IB;
  88         case RDMA_NODE_RNIC:
  89                 return RDMA_TRANSPORT_IWARP;
  90         default:
  91                 BUG();
  92                 return 0;
  93         }
  94 }
  95 EXPORT_SYMBOL(rdma_node_get_transport);
  96
  97 enum rdma_link_layer rdma_port_get_link_layer(struct ib_device *device, u8 port_num)
  98 {
  99         if (device->get_link_layer)
 100                 return device->get_link_layer(device, port_num);
 101
 102         switch (rdma_node_get_transport(device->node_type)) {
 103         case RDMA_TRANSPORT_IB:
 104                 return IB_LINK_LAYER_INFINIBAND;
 105         case RDMA_TRANSPORT_IWARP:
 106                 return IB_LINK_LAYER_ETHERNET;
 107         default:
 108                 return IB_LINK_LAYER_UNSPECIFIED;
 109         }
 110 }
 111 EXPORT_SYMBOL(rdma_port_get_link_layer);
 112
 113 /* Protection domains */
 114
 115 struct ib_pd *ib_alloc_pd(struct ib_device *device)
 116 {
 117         struct ib_pd *pd;
 118
 119         pd = device->alloc_pd(device, NULL, NULL);
 120
 121         if (!IS_ERR(pd)) {
 122                 pd->device  = device;
 123                 pd->uobject = NULL;
 124                 atomic_set(&pd->usecnt, 0);
 125         }
 126
 127         return pd;
 128 }
 129 EXPORT_SYMBOL(ib_alloc_pd);
 130
 131 int ib_dealloc_pd(struct ib_pd *pd)
 132 {
 133         if (atomic_read(&pd->usecnt))
 134                 return -EBUSY;
 135
 136         return pd->device->dealloc_pd(pd);
 137 }
 138 EXPORT_SYMBOL(ib_dealloc_pd);
 139
 140 /* Address handles */
 141
 142 struct ib_ah *ib_create_ah(struct ib_pd *pd, struct ib_ah_attr *ah_attr)
 143 {
 144         struct ib_ah *ah;
 145
 146         ah = pd->device->create_ah(pd, ah_attr);
 147
 148         if (!IS_ERR(ah)) {
 149                 ah->device  = pd->device;
 150                 ah->pd      = pd;
 151                 ah->uobject = NULL;
 152                 atomic_inc(&pd->usecnt);
 153         }
 154
 155         return ah;
 156 }
 157 EXPORT_SYMBOL(ib_create_ah);
 158
 159 int ib_init_ah_from_wc(struct ib_device *device, u8 port_num, struct ib_wc *wc,
 160                        struct ib_grh *grh, struct ib_ah_attr *ah_attr)
 161 {
 162         u32 flow_class;
 163         u16 gid_index;
 164         int ret;
 165
 166         memset(ah_attr, 0, sizeof *ah_attr);
 167         ah_attr->dlid = wc->slid;
 168         ah_attr->sl = wc->sl;
 169         ah_attr->src_path_bits = wc->dlid_path_bits;
 170         ah_attr->port_num = port_num;
 171
 172         if (wc->wc_flags & IB_WC_GRH) {
 173                 ah_attr->ah_flags = IB_AH_GRH;
 174                 ah_attr->grh.dgid = grh->sgid;
 175
 176                 ret = ib_find_cached_gid(device, &grh->dgid, &port_num,
 177                                          &gid_index);
 178                 if (ret)
 179                         return ret;
 180
 181                 ah_attr->grh.sgid_index = (u8) gid_index;
 182                 flow_class = be32_to_cpu(grh->version_tclass_flow);
 183                 ah_attr->grh.flow_label = flow_class & 0xFFFFF;
 184                 ah_attr->grh.hop_limit = 0xFF;
 185                 ah_attr->grh.traffic_class = (flow_class >> 20) & 0xFF;
 186         }
 187         return 0;
 188 }
 189 EXPORT_SYMBOL(ib_init_ah_from_wc);
 190
 191 struct ib_ah *ib_create_ah_from_wc(struct ib_pd *pd, struct ib_wc *wc,
 192                                    struct ib_grh *grh, u8 port_num)
 193 {
 194         struct ib_ah_attr ah_attr;
 195         int ret;
 196
 197         ret = ib_init_ah_from_wc(pd->device, port_num, wc, grh, &ah_attr);
 198         if (ret)
 199                 return ERR_PTR(ret);
 200
 201         return ib_create_ah(pd, &ah_attr);
 202 }
 203 EXPORT_SYMBOL(ib_create_ah_from_wc);
 204
 205 int ib_modify_ah(struct ib_ah *ah, struct ib_ah_attr *ah_attr)
 206 {
 207         return ah->device->modify_ah ?
 208                 ah->device->modify_ah(ah, ah_attr) :
 209                 -ENOSYS;
 210 }
 211 EXPORT_SYMBOL(ib_modify_ah);
 212
 213 int ib_query_ah(struct ib_ah *ah, struct ib_ah_attr *ah_attr)
 214 {
 215         return ah->device->query_ah ?
 216                 ah->device->query_ah(ah, ah_attr) :
 217                 -ENOSYS;
 218 }
 219 EXPORT_SYMBOL(ib_query_ah);
 220
 221 int ib_destroy_ah(struct ib_ah *ah)
 222 {
 223         struct ib_pd *pd;
 224         int ret;
 225
 226         pd = ah->pd;
 227         ret = ah->device->destroy_ah(ah);
 228         if (!ret)
 229                 atomic_dec(&pd->usecnt);
 230
 231         return ret;
 232 }
 233 EXPORT_SYMBOL(ib_destroy_ah);
 234
 235 /* Shared receive queues */
 236
 237 struct ib_srq *ib_create_srq(struct ib_pd *pd,
 238                              struct ib_srq_init_attr *srq_init_attr)
 239 {
 240         struct ib_srq *srq;
 241
 242         if (!pd->device->create_srq)
 243                 return ERR_PTR(-ENOSYS);
 244
 245         srq = pd->device->create_srq(pd, srq_init_attr, NULL);
 246
 247         if (!IS_ERR(srq)) {
 248                 srq->device        = pd->device;
 249                 srq->pd            = pd;
 250                 srq->uobject       = NULL;
 251                 srq->event_handler = srq_init_attr->event_handler;
 252                 srq->srq_context   = srq_init_attr->srq_context;
 253                 atomic_inc(&pd->usecnt);
 254                 atomic_set(&srq->usecnt, 0);
 255         }
 256
 257         return srq;
 258 }
 259 EXPORT_SYMBOL(ib_create_srq);
 260
 261 int ib_modify_srq(struct ib_srq *srq,
 262                   struct ib_srq_attr *srq_attr,
 263                   enum ib_srq_attr_mask srq_attr_mask)
 264 {
 265         return srq->device->modify_srq ?
 266                 srq->device->modify_srq(srq, srq_attr, srq_attr_mask, NULL) :
 267                 -ENOSYS;
 268 }
 269 EXPORT_SYMBOL(ib_modify_srq);
 270
 271 int ib_query_srq(struct ib_srq *srq,
 272                  struct ib_srq_attr *srq_attr)
 273 {
 274         return srq->device->query_srq ?
 275                 srq->device->query_srq(srq, srq_attr) : -ENOSYS;
 276 }
 277 EXPORT_SYMBOL(ib_query_srq);
 278
 279 int ib_destroy_srq(struct ib_srq *srq)
 280 {
 281         struct ib_pd *pd;
 282         int ret;
 283
 284         if (atomic_read(&srq->usecnt))
 285                 return -EBUSY;
 286
 287         pd = srq->pd;
 288
 289         ret = srq->device->destroy_srq(srq);
 290         if (!ret)
 291                 atomic_dec(&pd->usecnt);
 292
 293         return ret;
 294 }
 295 EXPORT_SYMBOL(ib_destroy_srq);
 296
 297 /* Queue pairs */
 298
 299 struct ib_qp *ib_create_qp(struct ib_pd *pd,
 300                            struct ib_qp_init_attr *qp_init_attr)
 301 {
 302         struct ib_qp *qp;
 303
 304         qp = pd->device->create_qp(pd, qp_init_attr, NULL);
 305
 306         if (!IS_ERR(qp)) {
 307                 qp->device        = pd->device;
 308                 qp->pd            = pd;
 309                 qp->send_cq       = qp_init_attr->send_cq;
 310                 qp->recv_cq       = qp_init_attr->recv_cq;
 311                 qp->srq           = qp_init_attr->srq;
 312                 qp->uobject       = NULL;
 313                 qp->event_handler = qp_init_attr->event_handler;
 314                 qp->qp_context    = qp_init_attr->qp_context;
 315                 qp->qp_type       = qp_init_attr->qp_type;
 316                 atomic_inc(&pd->usecnt);
 317                 atomic_inc(&qp_init_attr->send_cq->usecnt);
 318                 atomic_inc(&qp_init_attr->recv_cq->usecnt);
 319                 if (qp_init_attr->srq)
 320                         atomic_inc(&qp_init_attr->srq->usecnt);
 321         }
 322
 323         return qp;
 324 }
 325 EXPORT_SYMBOL(ib_create_qp);
 326
 327 static const struct {
 328         int                     valid;
 329         enum ib_qp_attr_mask    req_param[IB_QPT_RAW_ETHERTYPE + 1];
 330         enum ib_qp_attr_mask    opt_param[IB_QPT_RAW_ETHERTYPE + 1];
 331 } qp_state_table[IB_QPS_ERR + 1][IB_QPS_ERR + 1] = {
 332         [IB_QPS_RESET] = {
 333                 [IB_QPS_RESET] = { .valid = 1 },
 334                 [IB_QPS_INIT]  = {
 335                         .valid = 1,
 336                         .req_param = {
 337                                 [IB_QPT_UD]  = (IB_QP_PKEY_INDEX                |
 338                                                 IB_QP_PORT                      |
 339                                                 IB_QP_QKEY),
 340                                 [IB_QPT_UC]  = (IB_QP_PKEY_INDEX                |
 341                                                 IB_QP_PORT                      |
 342                                                 IB_QP_ACCESS_FLAGS),
 343                                 [IB_QPT_RC]  = (IB_QP_PKEY_INDEX                |
 344                                                 IB_QP_PORT                      |
 345                                                 IB_QP_ACCESS_FLAGS),
 346                                 [IB_QPT_SMI] = (IB_QP_PKEY_INDEX                |
 347                                                 IB_QP_QKEY),
 348                                 [IB_QPT_GSI] = (IB_QP_PKEY_INDEX                |
 349                                                 IB_QP_QKEY),
 350                         }
 351                 },
 352         },
 353         [IB_QPS_INIT]  = {
 354                 [IB_QPS_RESET] = { .valid = 1 },
 355                 [IB_QPS_ERR] =   { .valid = 1 },
 356                 [IB_QPS_INIT]  = {
 357                         .valid = 1,
 358                         .opt_param = {
 359                                 [IB_QPT_UD]  = (IB_QP_PKEY_INDEX                |
 360                                                 IB_QP_PORT                      |
 361                                                 IB_QP_QKEY),
 362                                 [IB_QPT_UC]  = (IB_QP_PKEY_INDEX                |
 363                                                 IB_QP_PORT                      |
 364                                                 IB_QP_ACCESS_FLAGS),
 365                                 [IB_QPT_RC]  = (IB_QP_PKEY_INDEX                |
 366                                                 IB_QP_PORT                      |
 367                                                 IB_QP_ACCESS_FLAGS),
 368                                 [IB_QPT_SMI] = (IB_QP_PKEY_INDEX                |
 369                                                 IB_QP_QKEY),
 370                                 [IB_QPT_GSI] = (IB_QP_PKEY_INDEX                |
 371                                                 IB_QP_QKEY),
 372                         }
 373                 },
 374                 [IB_QPS_RTR]   = {
 375                         .valid = 1,
 376                         .req_param = {
 377                                 [IB_QPT_UC]  = (IB_QP_AV                        |
 378                                                 IB_QP_PATH_MTU                  |
 379                                                 IB_QP_DEST_QPN                  |
 380                                                 IB_QP_RQ_PSN),
 381                                 [IB_QPT_RC]  = (IB_QP_AV                        |
 382                                                 IB_QP_PATH_MTU                  |
 383                                                 IB_QP_DEST_QPN                  |
 384                                                 IB_QP_RQ_PSN                    |
 385                                                 IB_QP_MAX_DEST_RD_ATOMIC        |
 386                                                 IB_QP_MIN_RNR_TIMER),
 387                         },
 388                         .opt_param = {
 389                                  [IB_QPT_UD]  = (IB_QP_PKEY_INDEX               |
 390                                                  IB_QP_QKEY),
 391                                  [IB_QPT_UC]  = (IB_QP_ALT_PATH                 |
 392                                                  IB_QP_ACCESS_FLAGS             |
 393                                                  IB_QP_PKEY_INDEX),
 394                                  [IB_QPT_RC]  = (IB_QP_ALT_PATH                 |
 395                                                  IB_QP_ACCESS_FLAGS             |
 396                                                  IB_QP_PKEY_INDEX),
 397                                  [IB_QPT_SMI] = (IB_QP_PKEY_INDEX               |
 398                                                  IB_QP_QKEY),
 399                                  [IB_QPT_GSI] = (IB_QP_PKEY_INDEX               |
 400                                                  IB_QP_QKEY),
 401                          }
 402                 }
 403         },
 404         [IB_QPS_RTR]   = {
 405                 [IB_QPS_RESET] = { .valid = 1 },
 406                 [IB_QPS_ERR] =   { .valid = 1 },
 407                 [IB_QPS_RTS]   = {
 408                         .valid = 1,
 409                         .req_param = {
 410                                 [IB_QPT_UD]  = IB_QP_SQ_PSN,
 411                                 [IB_QPT_UC]  = IB_QP_SQ_PSN,
 412                                 [IB_QPT_RC]  = (IB_QP_TIMEOUT                   |
 413                                                 IB_QP_RETRY_CNT                 |
 414                                                 IB_QP_RNR_RETRY                 |
 415                                                 IB_QP_SQ_PSN                    |
 416                                                 IB_QP_MAX_QP_RD_ATOMIC),
 417                                 [IB_QPT_SMI] = IB_QP_SQ_PSN,
 418                                 [IB_QPT_GSI] = IB_QP_SQ_PSN,
 419                         },
 420                         .opt_param = {
 421                                  [IB_QPT_UD]  = (IB_QP_CUR_STATE                |
 422                                                  IB_QP_QKEY),
 423                                  [IB_QPT_UC]  = (IB_QP_CUR_STATE                |
 424                                                  IB_QP_ALT_PATH                 |
 425                                                  IB_QP_ACCESS_FLAGS             |
 426                                                  IB_QP_PATH_MIG_STATE),
 427                                  [IB_QPT_RC]  = (IB_QP_CUR_STATE                |
 428                                                  IB_QP_ALT_PATH                 |
 429                                                  IB_QP_ACCESS_FLAGS             |
 430                                                  IB_QP_MIN_RNR_TIMER            |
 431                                                  IB_QP_PATH_MIG_STATE),
 432                                  [IB_QPT_SMI] = (IB_QP_CUR_STATE                |
 433                                                  IB_QP_QKEY),
 434                                  [IB_QPT_GSI] = (IB_QP_CUR_STATE                |
 435                                                  IB_QP_QKEY),
 436                          }
 437                 }
 438         },
 439         [IB_QPS_RTS]   = {
 440                 [IB_QPS_RESET] = { .valid = 1 },
 441                 [IB_QPS_ERR] =   { .valid = 1 },
 442                 [IB_QPS_RTS]   = {
 443                         .valid = 1,
 444                         .opt_param = {
 445                                 [IB_QPT_UD]  = (IB_QP_CUR_STATE                 |
 446                                                 IB_QP_QKEY),
 447                                 [IB_QPT_UC]  = (IB_QP_CUR_STATE                 |
 448                                                 IB_QP_ACCESS_FLAGS              |
 449                                                 IB_QP_ALT_PATH                  |
 450                                                 IB_QP_PATH_MIG_STATE),
 451                                 [IB_QPT_RC]  = (IB_QP_CUR_STATE                 |
 452                                                 IB_QP_ACCESS_FLAGS              |
 453                                                 IB_QP_ALT_PATH                  |
 454                                                 IB_QP_PATH_MIG_STATE            |
 455                                                 IB_QP_MIN_RNR_TIMER),
 456                                 [IB_QPT_SMI] = (IB_QP_CUR_STATE                 |
 457                                                 IB_QP_QKEY),
 458                                 [IB_QPT_GSI] = (IB_QP_CUR_STATE                 |
 459                                                 IB_QP_QKEY),
 460                         }
 461                 },
 462                 [IB_QPS_SQD]   = {
 463                         .valid = 1,
 464                         .opt_param = {
 465                                 [IB_QPT_UD]  = IB_QP_EN_SQD_ASYNC_NOTIFY,
 466                                 [IB_QPT_UC]  = IB_QP_EN_SQD_ASYNC_NOTIFY,
 467                                 [IB_QPT_RC]  = IB_QP_EN_SQD_ASYNC_NOTIFY,
 468                                 [IB_QPT_SMI] = IB_QP_EN_SQD_ASYNC_NOTIFY,
 469                                 [IB_QPT_GSI] = IB_QP_EN_SQD_ASYNC_NOTIFY
 470                         }
 471                 },
 472         },
 473         [IB_QPS_SQD]   = {
 474                 [IB_QPS_RESET] = { .valid = 1 },
 475                 [IB_QPS_ERR] =   { .valid = 1 },
 476                 [IB_QPS_RTS]   = {
 477                         .valid = 1,
 478                         .opt_param = {
 479                                 [IB_QPT_UD]  = (IB_QP_CUR_STATE                 |
 480                                                 IB_QP_QKEY),
 481                                 [IB_QPT_UC]  = (IB_QP_CUR_STATE                 |
 482                                                 IB_QP_ALT_PATH                  |
 483                                                 IB_QP_ACCESS_FLAGS              |
 484                                                 IB_QP_PATH_MIG_STATE),
 485                                 [IB_QPT_RC]  = (IB_QP_CUR_STATE                 |
 486                                                 IB_QP_ALT_PATH                  |
 487                                                 IB_QP_ACCESS_FLAGS              |
 488                                                 IB_QP_MIN_RNR_TIMER             |
 489                                                 IB_QP_PATH_MIG_STATE),
 490                                 [IB_QPT_SMI] = (IB_QP_CUR_STATE                 |
 491                                                 IB_QP_QKEY),
 492                                 [IB_QPT_GSI] = (IB_QP_CUR_STATE                 |
 493                                                 IB_QP_QKEY),
 494                         }
 495                 },
 496                 [IB_QPS_SQD]   = {
 497                         .valid = 1,
 498                         .opt_param = {
 499                                 [IB_QPT_UD]  = (IB_QP_PKEY_INDEX                |
 500                                                 IB_QP_QKEY),
 501                                 [IB_QPT_UC]  = (IB_QP_AV                        |
 502                                                 IB_QP_ALT_PATH                  |
 503                                                 IB_QP_ACCESS_FLAGS              |
 504                                                 IB_QP_PKEY_INDEX                |
 505                                                 IB_QP_PATH_MIG_STATE),
 506                                 [IB_QPT_RC]  = (IB_QP_PORT                      |
 507                                                 IB_QP_AV                        |
 508                                                 IB_QP_TIMEOUT                   |
 509                                                 IB_QP_RETRY_CNT                 |
 510                                                 IB_QP_RNR_RETRY                 |
 511                                                 IB_QP_MAX_QP_RD_ATOMIC          |
 512                                                 IB_QP_MAX_DEST_RD_ATOMIC        |
 513                                                 IB_QP_ALT_PATH                  |
 514                                                 IB_QP_ACCESS_FLAGS              |
 515                                                 IB_QP_PKEY_INDEX                |
 516                                                 IB_QP_MIN_RNR_TIMER             |
 517                                                 IB_QP_PATH_MIG_STATE),
 518                                 [IB_QPT_SMI] = (IB_QP_PKEY_INDEX                |
 519                                                 IB_QP_QKEY),
 520                                 [IB_QPT_GSI] = (IB_QP_PKEY_INDEX                |
 521                                                 IB_QP_QKEY),
 522                         }
 523                 }
 524         },
 525         [IB_QPS_SQE]   = {
 526                 [IB_QPS_RESET] = { .valid = 1 },
 527                 [IB_QPS_ERR] =   { .valid = 1 },
 528                 [IB_QPS_RTS]   = {
 529                         .valid = 1,
 530                         .opt_param = {
 531                                 [IB_QPT_UD]  = (IB_QP_CUR_STATE                 |
 532                                                 IB_QP_QKEY),
 533                                 [IB_QPT_UC]  = (IB_QP_CUR_STATE                 |
 534                                                 IB_QP_ACCESS_FLAGS),
 535                                 [IB_QPT_SMI] = (IB_QP_CUR_STATE                 |
 536                                                 IB_QP_QKEY),
 537                                 [IB_QPT_GSI] = (IB_QP_CUR_STATE                 |
 538                                                 IB_QP_QKEY),
 539                         }
 540                 }
 541         },
 542         [IB_QPS_ERR] = {
 543                 [IB_QPS_RESET] = { .valid = 1 },
 544                 [IB_QPS_ERR] =   { .valid = 1 }
 545         }
 546 };
 547
 548 int ib_modify_qp_is_ok(enum ib_qp_state cur_state, enum ib_qp_state next_state,
 549                        enum ib_qp_type type, enum ib_qp_attr_mask mask)
 550 {
 551         enum ib_qp_attr_mask req_param, opt_param;
 552
 553         if (cur_state  < 0 || cur_state  > IB_QPS_ERR ||
 554             next_state < 0 || next_state > IB_QPS_ERR)
 555                 return 0;
 556
 557         if (mask & IB_QP_CUR_STATE  &&
 558             cur_state != IB_QPS_RTR && cur_state != IB_QPS_RTS &&
 559             cur_state != IB_QPS_SQD && cur_state != IB_QPS_SQE)
 560                 return 0;
 561
 562         if (!qp_state_table[cur_state][next_state].valid)
 563                 return 0;
 564
 565         req_param = qp_state_table[cur_state][next_state].req_param[type];
 566         opt_param = qp_state_table[cur_state][next_state].opt_param[type];
 567
 568         if ((mask & req_param) != req_param)
 569                 return 0;
 570
 571         if (mask & ~(req_param | opt_param | IB_QP_STATE))
 572                 return 0;
 573
 574         return 1;
 575 }
 576 EXPORT_SYMBOL(ib_modify_qp_is_ok);
 577
 578 int ib_modify_qp(struct ib_qp *qp,
 579                  struct ib_qp_attr *qp_attr,
 580                  int qp_attr_mask)
 581 {
 582         return qp->device->modify_qp(qp, qp_attr, qp_attr_mask, NULL);
 583 }
 584 EXPORT_SYMBOL(ib_modify_qp);
 585
 586 int ib_query_qp(struct ib_qp *qp,
 587                 struct ib_qp_attr *qp_attr,
 588                 int qp_attr_mask,
 589                 struct ib_qp_init_attr *qp_init_attr)
 590 {
 591         return qp->device->query_qp ?
 592                 qp->device->query_qp(qp, qp_attr, qp_attr_mask, qp_init_attr) :
 593                 -ENOSYS;
 594 }
 595 EXPORT_SYMBOL(ib_query_qp);
 596
 597 int ib_destroy_qp(struct ib_qp *qp)
 598 {
 599         struct ib_pd *pd;
 600         struct ib_cq *scq, *rcq;
 601         struct ib_srq *srq;
 602         int ret;
 603
 604         pd  = qp->pd;
 605         scq = qp->send_cq;
 606         rcq = qp->recv_cq;
 607         srq = qp->srq;
 608
 609         ret = qp->device->destroy_qp(qp);
 610         if (!ret) {
 611                 atomic_dec(&pd->usecnt);
 612                 atomic_dec(&scq->usecnt);
 613                 atomic_dec(&rcq->usecnt);
 614                 if (srq)
 615                         atomic_dec(&srq->usecnt);
 616         }
 617
 618         return ret;
 619 }
 620 EXPORT_SYMBOL(ib_destroy_qp);
 621
 622 /* Completion queues */
 623
 624 struct ib_cq *ib_create_cq(struct ib_device *device,
 625                            ib_comp_handler comp_handler,
 626                            void (*event_handler)(struct ib_event *, void *),
 627                            void *cq_context, int cqe, int comp_vector)
 628 {
 629         struct ib_cq *cq;
 630
 631         cq = device->create_cq(device, cqe, comp_vector, NULL, NULL);
 632
 633         if (!IS_ERR(cq)) {
 634                 cq->device        = device;
 635                 cq->uobject       = NULL;
 636                 cq->comp_handler  = comp_handler;
 637                 cq->event_handler = event_handler;
 638                 cq->cq_context    = cq_context;
 639                 atomic_set(&cq->usecnt, 0);
 640         }
 641
 642         return cq;
 643 }
 644 EXPORT_SYMBOL(ib_create_cq);
 645
 646 int ib_modify_cq(struct ib_cq *cq, u16 cq_count, u16 cq_period)
 647 {
 648         return cq->device->modify_cq ?
 649                 cq->device->modify_cq(cq, cq_count, cq_period) : -ENOSYS;
 650 }
 651 EXPORT_SYMBOL(ib_modify_cq);
 652
 653 int ib_destroy_cq(struct ib_cq *cq)
 654 {
 655         if (atomic_read(&cq->usecnt))
 656                 return -EBUSY;
 657
 658         return cq->device->destroy_cq(cq);
 659 }
 660 EXPORT_SYMBOL(ib_destroy_cq);
 661
 662 int ib_resize_cq(struct ib_cq *cq, int cqe)
 663 {
 664         return cq->device->resize_cq ?
 665                 cq->device->resize_cq(cq, cqe, NULL) : -ENOSYS;
 666 }
 667 EXPORT_SYMBOL(ib_resize_cq);
 668
 669 /* Memory regions */
 670
 671 struct ib_mr *ib_get_dma_mr(struct ib_pd *pd, int mr_access_flags)
 672 {
 673         struct ib_mr *mr;
 674
 675         mr = pd->device->get_dma_mr(pd, mr_access_flags);
 676
 677         if (!IS_ERR(mr)) {
 678                 mr->device  = pd->device;
 679                 mr->pd      = pd;
 680                 mr->uobject = NULL;
 681                 atomic_inc(&pd->usecnt);
 682                 atomic_set(&mr->usecnt, 0);
 683         }
 684
 685         return mr;
 686 }
 687 EXPORT_SYMBOL(ib_get_dma_mr);
 688
 689 struct ib_mr *ib_reg_phys_mr(struct ib_pd *pd,
 690                              struct ib_phys_buf *phys_buf_array,
 691                              int num_phys_buf,
 692                              int mr_access_flags,
 693                              u64 *iova_start)
 694 {
 695         struct ib_mr *mr;
 696
 697         if (!pd->device->reg_phys_mr)
 698                 return ERR_PTR(-ENOSYS);
 699
 700         mr = pd->device->reg_phys_mr(pd, phys_buf_array, num_phys_buf,
 701                                      mr_access_flags, iova_start);
 702
 703         if (!IS_ERR(mr)) {
 704                 mr->device  = pd->device;
 705                 mr->pd      = pd;
 706                 mr->uobject = NULL;
 707                 atomic_inc(&pd->usecnt);
 708                 atomic_set(&mr->usecnt, 0);
 709         }
 710
 711         return mr;
 712 }
 713 EXPORT_SYMBOL(ib_reg_phys_mr);
 714
 715 int ib_rereg_phys_mr(struct ib_mr *mr,
 716                      int mr_rereg_mask,
 717                      struct ib_pd *pd,
 718                      struct ib_phys_buf *phys_buf_array,
 719                      int num_phys_buf,
 720                      int mr_access_flags,
 721                      u64 *iova_start)
 722 {
 723         struct ib_pd *old_pd;
 724         int ret;
 725
 726         if (!mr->device->rereg_phys_mr)
 727                 return -ENOSYS;
 728
 729         if (atomic_read(&mr->usecnt))
 730                 return -EBUSY;
 731
 732         old_pd = mr->pd;
 733
 734         ret = mr->device->rereg_phys_mr(mr, mr_rereg_mask, pd,
 735                                         phys_buf_array, num_phys_buf,
 736                                         mr_access_flags, iova_start);
 737
 738         if (!ret && (mr_rereg_mask & IB_MR_REREG_PD)) {
 739                 atomic_dec(&old_pd->usecnt);
 740                 atomic_inc(&pd->usecnt);
 741         }
 742
 743         return ret;
 744 }
 745 EXPORT_SYMBOL(ib_rereg_phys_mr);
 746
 747 int ib_query_mr(struct ib_mr *mr, struct ib_mr_attr *mr_attr)
 748 {
 749         return mr->device->query_mr ?
 750                 mr->device->query_mr(mr, mr_attr) : -ENOSYS;
 751 }
 752 EXPORT_SYMBOL(ib_query_mr);
 753
 754 int ib_dereg_mr(struct ib_mr *mr)
 755 {
 756         struct ib_pd *pd;
 757         int ret;
 758
 759         if (atomic_read(&mr->usecnt))
 760                 return -EBUSY;
 761
 762         pd = mr->pd;
 763         ret = mr->device->dereg_mr(mr);
 764         if (!ret)
 765                 atomic_dec(&pd->usecnt);
 766
 767         return ret;
 768 }
 769 EXPORT_SYMBOL(ib_dereg_mr);
 770
 771 struct ib_mr *ib_alloc_fast_reg_mr(struct ib_pd *pd, int max_page_list_len)
 772 {
 773         struct ib_mr *mr;
 774
 775         if (!pd->device->alloc_fast_reg_mr)
 776                 return ERR_PTR(-ENOSYS);
 777
 778         mr = pd->device->alloc_fast_reg_mr(pd, max_page_list_len);
 779
 780         if (!IS_ERR(mr)) {
 781                 mr->device  = pd->device;
 782                 mr->pd      = pd;
 783                 mr->uobject = NULL;
 784                 atomic_inc(&pd->usecnt);
 785                 atomic_set(&mr->usecnt, 0);
 786         }
 787
 788         return mr;
 789 }
 790 EXPORT_SYMBOL(ib_alloc_fast_reg_mr);
 791
 792 struct ib_fast_reg_page_list *ib_alloc_fast_reg_page_list(struct ib_device *device,
 793                                                           int max_page_list_len)
 794 {
 795         struct ib_fast_reg_page_list *page_list;
 796
 797         if (!device->alloc_fast_reg_page_list)
 798                 return ERR_PTR(-ENOSYS);
 799
 800         page_list = device->alloc_fast_reg_page_list(device, max_page_list_len);
 801
 802         if (!IS_ERR(page_list)) {
 803                 page_list->device = device;
 804                 page_list->max_page_list_len = max_page_list_len;
 805         }
 806
 807         return page_list;
 808 }
 809 EXPORT_SYMBOL(ib_alloc_fast_reg_page_list);
 810
 811 void ib_free_fast_reg_page_list(struct ib_fast_reg_page_list *page_list)
 812 {
 813         page_list->device->free_fast_reg_page_list(page_list);
 814 }
 815 EXPORT_SYMBOL(ib_free_fast_reg_page_list);
 816
 817 /* Memory windows */
 818
 819 struct ib_mw *ib_alloc_mw(struct ib_pd *pd)
 820 {
 821         struct ib_mw *mw;
 822
 823         if (!pd->device->alloc_mw)
 824                 return ERR_PTR(-ENOSYS);
 825
 826         mw = pd->device->alloc_mw(pd);
 827         if (!IS_ERR(mw)) {
 828                 mw->device  = pd->device;
 829                 mw->pd      = pd;
 830                 mw->uobject = NULL;
 831                 atomic_inc(&pd->usecnt);
 832         }
 833
 834         return mw;
 835 }
 836 EXPORT_SYMBOL(ib_alloc_mw);
 837
 838 int ib_dealloc_mw(struct ib_mw *mw)
 839 {
 840         struct ib_pd *pd;
 841         int ret;
 842
 843         pd = mw->pd;
 844         ret = mw->device->dealloc_mw(mw);
 845         if (!ret)
 846                 atomic_dec(&pd->usecnt);
 847
 848         return ret;
 849 }
 850 EXPORT_SYMBOL(ib_dealloc_mw);
 851
 852 /* "Fast" memory regions */
 853
 854 struct ib_fmr *ib_alloc_fmr(struct ib_pd *pd,
 855                             int mr_access_flags,
 856                             struct ib_fmr_attr *fmr_attr)
 857 {
 858         struct ib_fmr *fmr;
 859
 860         if (!pd->device->alloc_fmr)
 861                 return ERR_PTR(-ENOSYS);
 862
 863         fmr = pd->device->alloc_fmr(pd, mr_access_flags, fmr_attr);
 864         if (!IS_ERR(fmr)) {
 865                 fmr->device = pd->device;
 866                 fmr->pd     = pd;
 867                 atomic_inc(&pd->usecnt);
 868         }
 869
 870         return fmr;
 871 }
 872 EXPORT_SYMBOL(ib_alloc_fmr);
 873
 874 int ib_unmap_fmr(struct list_head *fmr_list)
 875 {
 876         struct ib_fmr *fmr;
 877
 878         if (list_empty(fmr_list))
 879                 return 0;
 880
 881         fmr = list_entry(fmr_list->next, struct ib_fmr, list);
 882         return fmr->device->unmap_fmr(fmr_list);
 883 }
 884 EXPORT_SYMBOL(ib_unmap_fmr);
 885
 886 int ib_dealloc_fmr(struct ib_fmr *fmr)
 887 {
 888         struct ib_pd *pd;
 889         int ret;
 890
 891         pd = fmr->pd;
 892         ret = fmr->device->dealloc_fmr(fmr);
 893         if (!ret)
 894                 atomic_dec(&pd->usecnt);
 895
 896         return ret;
 897 }
 898 EXPORT_SYMBOL(ib_dealloc_fmr);
 899
 900 /* Multicast groups */
 901
 902 int ib_attach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid)
 903 {
 904         if (!qp->device->attach_mcast)
 905                 return -ENOSYS;
 906         if (gid->raw[0] != 0xff || qp->qp_type != IB_QPT_UD)
 907                 return -EINVAL;
 908
 909         return qp->device->attach_mcast(qp, gid, lid);
 910 }
 911 EXPORT_SYMBOL(ib_attach_mcast);
 912
 913 int ib_detach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid)
 914 {
 915         if (!qp->device->detach_mcast)
 916                 return -ENOSYS;
 917         if (gid->raw[0] != 0xff || qp->qp_type != IB_QPT_UD)
 918                 return -EINVAL;
 919
 920         return qp->device->detach_mcast(qp, gid, lid);
 921 }
 922 EXPORT_SYMBOL(ib_detach_mcast);