drivers/infiniband/sw/rdmavt/vt.c

   1 /*
   2  * Copyright(c) 2016 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 #include "trace.h"
  52
  53 #define RVT_UVERBS_ABI_VERSION 2
  54
  55 MODULE_LICENSE("Dual BSD/GPL");
  56 MODULE_DESCRIPTION("RDMA Verbs Transport Library");
  57
  58 static int rvt_init(void)
  59 {
  60         /*
  61          * rdmavt does not need to do anything special when it starts up. All it
  62          * needs to do is sit and wait until a driver attempts registration.
  63          */
  64         return 0;
  65 }
  66 module_init(rvt_init);
  67
  68 static void rvt_cleanup(void)
  69 {
  70         /*
  71          * Nothing to do at exit time either. The module won't be able to be
  72          * removed until all drivers are gone which means all the dev structs
  73          * are gone so there is really nothing to do.
  74          */
  75 }
  76 module_exit(rvt_cleanup);
  77
  78 /**
  79  * rvt_alloc_device - allocate rdi
  80  * @size: how big of a structure to allocate
  81  * @nports: number of ports to allocate array slots for
  82  *
  83  * Use IB core device alloc to allocate space for the rdi which is assumed to be
  84  * inside of the ib_device. Any extra space that drivers require should be
  85  * included in size.
  86  *
  87  * We also allocate a port array based on the number of ports.
  88  *
  89  * Return: pointer to allocated rdi
  90  */
  91 struct rvt_dev_info *rvt_alloc_device(size_t size, int nports)
  92 {
  93         struct rvt_dev_info *rdi = ERR_PTR(-ENOMEM);
  94
  95         rdi = (struct rvt_dev_info *)ib_alloc_device(size);
  96         if (!rdi)
  97                 return rdi;
  98
  99         rdi->ports = kcalloc(nports,
 100                              sizeof(struct rvt_ibport **),
 101                              GFP_KERNEL);
 102         if (!rdi->ports)
 103                 ib_dealloc_device(&rdi->ibdev);
 104
 105         return rdi;
 106 }
 107 EXPORT_SYMBOL(rvt_alloc_device);
 108
 109 /**
 110  * rvt_dealloc_device - deallocate rdi
 111  * @rdi: structure to free
 112  *
 113  * Free a structure allocated with rvt_alloc_device()
 114  */
 115 void rvt_dealloc_device(struct rvt_dev_info *rdi)
 116 {
 117         kfree(rdi->ports);
 118         ib_dealloc_device(&rdi->ibdev);
 119 }
 120 EXPORT_SYMBOL(rvt_dealloc_device);
 121
 122 static int rvt_query_device(struct ib_device *ibdev,
 123                             struct ib_device_attr *props,
 124                             struct ib_udata *uhw)
 125 {
 126         struct rvt_dev_info *rdi = ib_to_rvt(ibdev);
 127
 128         if (uhw->inlen || uhw->outlen)
 129                 return -EINVAL;
 130         /*
 131          * Return rvt_dev_info.dparms.props contents
 132          */
 133         *props = rdi->dparms.props;
 134         return 0;
 135 }
 136
 137 static int rvt_modify_device(struct ib_device *device,
 138                              int device_modify_mask,
 139                              struct ib_device_modify *device_modify)
 140 {
 141         /*
 142          * There is currently no need to supply this based on qib and hfi1.
 143          * Future drivers may need to implement this though.
 144          */
 145
 146         return -EOPNOTSUPP;
 147 }
 148
 149 /**
 150  * rvt_query_port: Passes the query port call to the driver
 151  * @ibdev: Verbs IB dev
 152  * @port_num: port number, 1 based from ib core
 153  * @props: structure to hold returned properties
 154  *
 155  * Return: 0 on success
 156  */
 157 static int rvt_query_port(struct ib_device *ibdev, u8 port_num,
 158                           struct ib_port_attr *props)
 159 {
 160         struct rvt_dev_info *rdi = ib_to_rvt(ibdev);
 161         struct rvt_ibport *rvp;
 162         int port_index = ibport_num_to_idx(ibdev, port_num);
 163
 164         if (port_index < 0)
 165                 return -EINVAL;
 166
 167         rvp = rdi->ports[port_index];
 168         memset(props, 0, sizeof(*props));
 169         props->sm_lid = rvp->sm_lid;
 170         props->sm_sl = rvp->sm_sl;
 171         props->port_cap_flags = rvp->port_cap_flags;
 172         props->max_msg_sz = 0x80000000;
 173         props->pkey_tbl_len = rvt_get_npkeys(rdi);
 174         props->bad_pkey_cntr = rvp->pkey_violations;
 175         props->qkey_viol_cntr = rvp->qkey_violations;
 176         props->subnet_timeout = rvp->subnet_timeout;
 177         props->init_type_reply = 0;
 178
 179         /* Populate the remaining ib_port_attr elements */
 180         return rdi->driver_f.query_port_state(rdi, port_num, props);
 181 }
 182
 183 /**
 184  * rvt_modify_port
 185  * @ibdev: Verbs IB dev
 186  * @port_num: Port number, 1 based from ib core
 187  * @port_modify_mask: How to change the port
 188  * @props: Structure to fill in
 189  *
 190  * Return: 0 on success
 191  */
 192 static int rvt_modify_port(struct ib_device *ibdev, u8 port_num,
 193                            int port_modify_mask, struct ib_port_modify *props)
 194 {
 195         struct rvt_dev_info *rdi = ib_to_rvt(ibdev);
 196         struct rvt_ibport *rvp;
 197         int ret = 0;
 198         int port_index = ibport_num_to_idx(ibdev, port_num);
 199
 200         if (port_index < 0)
 201                 return -EINVAL;
 202
 203         rvp = rdi->ports[port_index];
 204         rvp->port_cap_flags |= props->set_port_cap_mask;
 205         rvp->port_cap_flags &= ~props->clr_port_cap_mask;
 206
 207         if (props->set_port_cap_mask || props->clr_port_cap_mask)
 208                 rdi->driver_f.cap_mask_chg(rdi, port_num);
 209         if (port_modify_mask & IB_PORT_SHUTDOWN)
 210                 ret = rdi->driver_f.shut_down_port(rdi, port_num);
 211         if (port_modify_mask & IB_PORT_RESET_QKEY_CNTR)
 212                 rvp->qkey_violations = 0;
 213
 214         return ret;
 215 }
 216
 217 /**
 218  * rvt_query_pkey - Return a pkey from the table at a given index
 219  * @ibdev: Verbs IB dev
 220  * @port_num: Port number, 1 based from ib core
 221  * @intex: Index into pkey table
 222  *
 223  * Return: 0 on failure pkey otherwise
 224  */
 225 static int rvt_query_pkey(struct ib_device *ibdev, u8 port_num, u16 index,
 226                           u16 *pkey)
 227 {
 228         /*
 229          * Driver will be responsible for keeping rvt_dev_info.pkey_table up to
 230          * date. This function will just return that value. There is no need to
 231          * lock, if a stale value is read and sent to the user so be it there is
 232          * no way to protect against that anyway.
 233          */
 234         struct rvt_dev_info *rdi = ib_to_rvt(ibdev);
 235         int port_index;
 236
 237         port_index = ibport_num_to_idx(ibdev, port_num);
 238         if (port_index < 0)
 239                 return -EINVAL;
 240
 241         if (index >= rvt_get_npkeys(rdi))
 242                 return -EINVAL;
 243
 244         *pkey = rvt_get_pkey(rdi, port_index, index);
 245         return 0;
 246 }
 247
 248 /**
 249  * rvt_query_gid - Return a gid from the table
 250  * @ibdev: Verbs IB dev
 251  * @port_num: Port number, 1 based from ib core
 252  * @index: = Index in table
 253  * @gid: Gid to return
 254  *
 255  * Return: 0 on success
 256  */
 257 static int rvt_query_gid(struct ib_device *ibdev, u8 port_num,
 258                          int guid_index, union ib_gid *gid)
 259 {
 260         struct rvt_dev_info *rdi;
 261         struct rvt_ibport *rvp;
 262         int port_index;
 263
 264         /*
 265          * Driver is responsible for updating the guid table. Which will be used
 266          * to craft the return value. This will work similar to how query_pkey()
 267          * is being done.
 268          */
 269         port_index = ibport_num_to_idx(ibdev, port_num);
 270         if (port_index < 0)
 271                 return -EINVAL;
 272
 273         rdi = ib_to_rvt(ibdev);
 274         rvp = rdi->ports[port_index];
 275
 276         gid->global.subnet_prefix = rvp->gid_prefix;
 277
 278         return rdi->driver_f.get_guid_be(rdi, rvp, guid_index,
 279                                          &gid->global.interface_id);
 280 }
 281
 282 struct rvt_ucontext {
 283         struct ib_ucontext ibucontext;
 284 };
 285
 286 static inline struct rvt_ucontext *to_iucontext(struct ib_ucontext
 287                                                 *ibucontext)
 288 {
 289         return container_of(ibucontext, struct rvt_ucontext, ibucontext);
 290 }
 291
 292 /**
 293  * rvt_alloc_ucontext - Allocate a user context
 294  * @ibdev: Vers IB dev
 295  * @data: User data allocated
 296  */
 297 static struct ib_ucontext *rvt_alloc_ucontext(struct ib_device *ibdev,
 298                                               struct ib_udata *udata)
 299 {
 300         struct rvt_ucontext *context;
 301
 302         context = kmalloc(sizeof(*context), GFP_KERNEL);
 303         if (!context)
 304                 return ERR_PTR(-ENOMEM);
 305         return &context->ibucontext;
 306 }
 307
 308 /**
 309  *rvt_dealloc_ucontext - Free a user context
 310  *@context - Free this
 311  */
 312 static int rvt_dealloc_ucontext(struct ib_ucontext *context)
 313 {
 314         kfree(to_iucontext(context));
 315         return 0;
 316 }
 317
 318 static int rvt_get_port_immutable(struct ib_device *ibdev, u8 port_num,
 319                                   struct ib_port_immutable *immutable)
 320 {
 321         struct rvt_dev_info *rdi = ib_to_rvt(ibdev);
 322         struct ib_port_attr attr;
 323         int err, port_index;
 324
 325         port_index = ibport_num_to_idx(ibdev, port_num);
 326         if (port_index < 0)
 327                 return -EINVAL;
 328
 329         err = rvt_query_port(ibdev, port_num, &attr);
 330         if (err)
 331                 return err;
 332
 333         immutable->pkey_tbl_len = attr.pkey_tbl_len;
 334         immutable->gid_tbl_len = attr.gid_tbl_len;
 335         immutable->core_cap_flags = rdi->dparms.core_cap_flags;
 336         immutable->max_mad_size = rdi->dparms.max_mad_size;
 337
 338         return 0;
 339 }
 340
 341 enum {
 342         MISC,
 343         QUERY_DEVICE,
 344         MODIFY_DEVICE,
 345         QUERY_PORT,
 346         MODIFY_PORT,
 347         QUERY_PKEY,
 348         QUERY_GID,
 349         ALLOC_UCONTEXT,
 350         DEALLOC_UCONTEXT,
 351         GET_PORT_IMMUTABLE,
 352         CREATE_QP,
 353         MODIFY_QP,
 354         DESTROY_QP,
 355         QUERY_QP,
 356         POST_SEND,
 357         POST_RECV,
 358         POST_SRQ_RECV,
 359         CREATE_AH,
 360         DESTROY_AH,
 361         MODIFY_AH,
 362         QUERY_AH,
 363         CREATE_SRQ,
 364         MODIFY_SRQ,
 365         DESTROY_SRQ,
 366         QUERY_SRQ,
 367         ATTACH_MCAST,
 368         DETACH_MCAST,
 369         GET_DMA_MR,
 370         REG_USER_MR,
 371         DEREG_MR,
 372         ALLOC_MR,
 373         ALLOC_FMR,
 374         MAP_PHYS_FMR,
 375         UNMAP_FMR,
 376         DEALLOC_FMR,
 377         MMAP,
 378         CREATE_CQ,
 379         DESTROY_CQ,
 380         POLL_CQ,
 381         REQ_NOTFIY_CQ,
 382         RESIZE_CQ,
 383         ALLOC_PD,
 384         DEALLOC_PD,
 385         _VERB_IDX_MAX /* Must always be last! */
 386 };
 387
 388 static inline int check_driver_override(struct rvt_dev_info *rdi,
 389                                         size_t offset, void *func)
 390 {
 391         if (!*(void **)((void *)&rdi->ibdev + offset)) {
 392                 *(void **)((void *)&rdi->ibdev + offset) = func;
 393                 return 0;
 394         }
 395
 396         return 1;
 397 }
 398
 399 static noinline int check_support(struct rvt_dev_info *rdi, int verb)
 400 {
 401         switch (verb) {
 402         case MISC:
 403                 /*
 404                  * These functions are not part of verbs specifically but are
 405                  * required for rdmavt to function.
 406                  */
 407                 if ((!rdi->driver_f.port_callback) ||
 408                     (!rdi->driver_f.get_card_name) ||
 409                     (!rdi->driver_f.get_pci_dev))
 410                         return -EINVAL;
 411                 break;
 412
 413         case QUERY_DEVICE:
 414                 check_driver_override(rdi, offsetof(struct ib_device,
 415                                                     query_device),
 416                                                     rvt_query_device);
 417                 break;
 418
 419         case MODIFY_DEVICE:
 420                 /*
 421                  * rdmavt does not support modify device currently drivers must
 422                  * provide.
 423                  */
 424                 if (!check_driver_override(rdi, offsetof(struct ib_device,
 425                                                          modify_device),
 426                                            rvt_modify_device))
 427                         return -EOPNOTSUPP;
 428                 break;
 429
 430         case QUERY_PORT:
 431                 if (!check_driver_override(rdi, offsetof(struct ib_device,
 432                                                          query_port),
 433                                            rvt_query_port))
 434                         if (!rdi->driver_f.query_port_state)
 435                                 return -EINVAL;
 436                 break;
 437
 438         case MODIFY_PORT:
 439                 if (!check_driver_override(rdi, offsetof(struct ib_device,
 440                                                          modify_port),
 441                                            rvt_modify_port))
 442                         if (!rdi->driver_f.cap_mask_chg ||
 443                             !rdi->driver_f.shut_down_port)
 444                                 return -EINVAL;
 445                 break;
 446
 447         case QUERY_PKEY:
 448                 check_driver_override(rdi, offsetof(struct ib_device,
 449                                                     query_pkey),
 450                                       rvt_query_pkey);
 451                 break;
 452
 453         case QUERY_GID:
 454                 if (!check_driver_override(rdi, offsetof(struct ib_device,
 455                                                          query_gid),
 456                                            rvt_query_gid))
 457                         if (!rdi->driver_f.get_guid_be)
 458                                 return -EINVAL;
 459                 break;
 460
 461         case ALLOC_UCONTEXT:
 462                 check_driver_override(rdi, offsetof(struct ib_device,
 463                                                     alloc_ucontext),
 464                                       rvt_alloc_ucontext);
 465                 break;
 466
 467         case DEALLOC_UCONTEXT:
 468                 check_driver_override(rdi, offsetof(struct ib_device,
 469                                                     dealloc_ucontext),
 470                                       rvt_dealloc_ucontext);
 471                 break;
 472
 473         case GET_PORT_IMMUTABLE:
 474                 check_driver_override(rdi, offsetof(struct ib_device,
 475                                                     get_port_immutable),
 476                                       rvt_get_port_immutable);
 477                 break;
 478
 479         case CREATE_QP:
 480                 if (!check_driver_override(rdi, offsetof(struct ib_device,
 481                                                          create_qp),
 482                                            rvt_create_qp))
 483                         if (!rdi->driver_f.qp_priv_alloc ||
 484                             !rdi->driver_f.qp_priv_free ||
 485                             !rdi->driver_f.notify_qp_reset ||
 486                             !rdi->driver_f.flush_qp_waiters ||
 487                             !rdi->driver_f.stop_send_queue ||
 488                             !rdi->driver_f.quiesce_qp)
 489                                 return -EINVAL;
 490                 break;
 491
 492         case MODIFY_QP:
 493                 if (!check_driver_override(rdi, offsetof(struct ib_device,
 494                                                          modify_qp),
 495                                            rvt_modify_qp))
 496                         if (!rdi->driver_f.notify_qp_reset ||
 497                             !rdi->driver_f.schedule_send ||
 498                             !rdi->driver_f.get_pmtu_from_attr ||
 499                             !rdi->driver_f.flush_qp_waiters ||
 500                             !rdi->driver_f.stop_send_queue ||
 501                             !rdi->driver_f.quiesce_qp ||
 502                             !rdi->driver_f.notify_error_qp ||
 503                             !rdi->driver_f.mtu_from_qp ||
 504                             !rdi->driver_f.mtu_to_path_mtu ||
 505                             !rdi->driver_f.shut_down_port ||
 506                             !rdi->driver_f.cap_mask_chg)
 507                                 return -EINVAL;
 508                 break;
 509
 510         case DESTROY_QP:
 511                 if (!check_driver_override(rdi, offsetof(struct ib_device,
 512                                                          destroy_qp),
 513                                            rvt_destroy_qp))
 514                         if (!rdi->driver_f.qp_priv_free ||
 515                             !rdi->driver_f.notify_qp_reset ||
 516                             !rdi->driver_f.flush_qp_waiters ||
 517                             !rdi->driver_f.stop_send_queue ||
 518                             !rdi->driver_f.quiesce_qp)
 519                                 return -EINVAL;
 520                 break;
 521
 522         case QUERY_QP:
 523                 check_driver_override(rdi, offsetof(struct ib_device,
 524                                                     query_qp),
 525                                                     rvt_query_qp);
 526                 break;
 527
 528         case POST_SEND:
 529                 if (!check_driver_override(rdi, offsetof(struct ib_device,
 530                                                          post_send),
 531                                            rvt_post_send))
 532                         if (!rdi->driver_f.schedule_send ||
 533                             !rdi->driver_f.do_send)
 534                                 return -EINVAL;
 535                 break;
 536
 537         case POST_RECV:
 538                 check_driver_override(rdi, offsetof(struct ib_device,
 539                                                     post_recv),
 540                                       rvt_post_recv);
 541                 break;
 542         case POST_SRQ_RECV:
 543                 check_driver_override(rdi, offsetof(struct ib_device,
 544                                                     post_srq_recv),
 545                                       rvt_post_srq_recv);
 546                 break;
 547
 548         case CREATE_AH:
 549                 check_driver_override(rdi, offsetof(struct ib_device,
 550                                                     create_ah),
 551                                       rvt_create_ah);
 552                 break;
 553
 554         case DESTROY_AH:
 555                 check_driver_override(rdi, offsetof(struct ib_device,
 556                                                     destroy_ah),
 557                                       rvt_destroy_ah);
 558                 break;
 559
 560         case MODIFY_AH:
 561                 check_driver_override(rdi, offsetof(struct ib_device,
 562                                                     modify_ah),
 563                                       rvt_modify_ah);
 564                 break;
 565
 566         case QUERY_AH:
 567                 check_driver_override(rdi, offsetof(struct ib_device,
 568                                                     query_ah),
 569                                       rvt_query_ah);
 570                 break;
 571
 572         case CREATE_SRQ:
 573                 check_driver_override(rdi, offsetof(struct ib_device,
 574                                                     create_srq),
 575                                       rvt_create_srq);
 576                 break;
 577
 578         case MODIFY_SRQ:
 579                 check_driver_override(rdi, offsetof(struct ib_device,
 580                                                     modify_srq),
 581                                       rvt_modify_srq);
 582                 break;
 583
 584         case DESTROY_SRQ:
 585                 check_driver_override(rdi, offsetof(struct ib_device,
 586                                                     destroy_srq),
 587                                       rvt_destroy_srq);
 588                 break;
 589
 590         case QUERY_SRQ:
 591                 check_driver_override(rdi, offsetof(struct ib_device,
 592                                                     query_srq),
 593                                       rvt_query_srq);
 594                 break;
 595
 596         case ATTACH_MCAST:
 597                 check_driver_override(rdi, offsetof(struct ib_device,
 598                                                     attach_mcast),
 599                                       rvt_attach_mcast);
 600                 break;
 601
 602         case DETACH_MCAST:
 603                 check_driver_override(rdi, offsetof(struct ib_device,
 604                                                     detach_mcast),
 605                                       rvt_detach_mcast);
 606                 break;
 607
 608         case GET_DMA_MR:
 609                 check_driver_override(rdi, offsetof(struct ib_device,
 610                                                     get_dma_mr),
 611                                       rvt_get_dma_mr);
 612                 break;
 613
 614         case REG_USER_MR:
 615                 check_driver_override(rdi, offsetof(struct ib_device,
 616                                                     reg_user_mr),
 617                                       rvt_reg_user_mr);
 618                 break;
 619
 620         case DEREG_MR:
 621                 check_driver_override(rdi, offsetof(struct ib_device,
 622                                                     dereg_mr),
 623                                       rvt_dereg_mr);
 624                 break;
 625
 626         case ALLOC_FMR:
 627                 check_driver_override(rdi, offsetof(struct ib_device,
 628                                                     alloc_fmr),
 629                                       rvt_alloc_fmr);
 630                 break;
 631
 632         case ALLOC_MR:
 633                 check_driver_override(rdi, offsetof(struct ib_device,
 634                                                     alloc_mr),
 635                                       rvt_alloc_mr);
 636                 break;
 637
 638         case MAP_PHYS_FMR:
 639                 check_driver_override(rdi, offsetof(struct ib_device,
 640                                                     map_phys_fmr),
 641                                       rvt_map_phys_fmr);
 642                 break;
 643
 644         case UNMAP_FMR:
 645                 check_driver_override(rdi, offsetof(struct ib_device,
 646                                                     unmap_fmr),
 647                                       rvt_unmap_fmr);
 648                 break;
 649
 650         case DEALLOC_FMR:
 651                 check_driver_override(rdi, offsetof(struct ib_device,
 652                                                     dealloc_fmr),
 653                                       rvt_dealloc_fmr);
 654                 break;
 655
 656         case MMAP:
 657                 check_driver_override(rdi, offsetof(struct ib_device,
 658                                                     mmap),
 659                                       rvt_mmap);
 660                 break;
 661
 662         case CREATE_CQ:
 663                 check_driver_override(rdi, offsetof(struct ib_device,
 664                                                     create_cq),
 665                                       rvt_create_cq);
 666                 break;
 667
 668         case DESTROY_CQ:
 669                 check_driver_override(rdi, offsetof(struct ib_device,
 670                                                     destroy_cq),
 671                                       rvt_destroy_cq);
 672                 break;
 673
 674         case POLL_CQ:
 675                 check_driver_override(rdi, offsetof(struct ib_device,
 676                                                     poll_cq),
 677                                       rvt_poll_cq);
 678                 break;
 679
 680         case REQ_NOTFIY_CQ:
 681                 check_driver_override(rdi, offsetof(struct ib_device,
 682                                                     req_notify_cq),
 683                                       rvt_req_notify_cq);
 684                 break;
 685
 686         case RESIZE_CQ:
 687                 check_driver_override(rdi, offsetof(struct ib_device,
 688                                                     resize_cq),
 689                                       rvt_resize_cq);
 690                 break;
 691
 692         case ALLOC_PD:
 693                 check_driver_override(rdi, offsetof(struct ib_device,
 694                                                     alloc_pd),
 695                                       rvt_alloc_pd);
 696                 break;
 697
 698         case DEALLOC_PD:
 699                 check_driver_override(rdi, offsetof(struct ib_device,
 700                                                     dealloc_pd),
 701                                       rvt_dealloc_pd);
 702                 break;
 703
 704         default:
 705                 return -EINVAL;
 706         }
 707
 708         return 0;
 709 }
 710
 711 /**
 712  * rvt_register_device - register a driver
 713  * @rdi: main dev structure for all of rdmavt operations
 714  *
 715  * It is up to drivers to allocate the rdi and fill in the appropriate
 716  * information.
 717  *
 718  * Return: 0 on success otherwise an errno.
 719  */
 720 int rvt_register_device(struct rvt_dev_info *rdi)
 721 {
 722         int ret = 0, i;
 723
 724         if (!rdi)
 725                 return -EINVAL;
 726
 727         /*
 728          * Check to ensure drivers have setup the required helpers for the verbs
 729          * they want rdmavt to handle
 730          */
 731         for (i = 0; i < _VERB_IDX_MAX; i++)
 732                 if (check_support(rdi, i)) {
 733                         pr_err("Driver support req not met at %d\n", i);
 734                         return -EINVAL;
 735                 }
 736
 737
 738         /* Once we get past here we can use rvt_pr macros and tracepoints */
 739         trace_rvt_dbg(rdi, "Driver attempting registration");
 740         rvt_mmap_init(rdi);
 741
 742         /* Queue Pairs */
 743         ret = rvt_driver_qp_init(rdi);
 744         if (ret) {
 745                 pr_err("Error in driver QP init.\n");
 746                 return -EINVAL;
 747         }
 748
 749         /* Address Handle */
 750         spin_lock_init(&rdi->n_ahs_lock);
 751         rdi->n_ahs_allocated = 0;
 752
 753         /* Shared Receive Queue */
 754         rvt_driver_srq_init(rdi);
 755
 756         /* Multicast */
 757         rvt_driver_mcast_init(rdi);
 758
 759         /* Mem Region */
 760         ret = rvt_driver_mr_init(rdi);
 761         if (ret) {
 762                 pr_err("Error in driver MR init.\n");
 763                 goto bail_no_mr;
 764         }
 765
 766         /* Completion queues */
 767         ret = rvt_driver_cq_init(rdi);
 768         if (ret) {
 769                 pr_err("Error in driver CQ init.\n");
 770                 goto bail_mr;
 771         }
 772
 773         /* DMA Operations */
 774         rdi->ibdev.dma_ops =
 775                 rdi->ibdev.dma_ops ? : &rvt_default_dma_mapping_ops;
 776
 777         /* Protection Domain */
 778         spin_lock_init(&rdi->n_pds_lock);
 779         rdi->n_pds_allocated = 0;
 780
 781         /*
 782          * There are some things which could be set by underlying drivers but
 783          * really should be up to rdmavt to set. For instance drivers can't know
 784          * exactly which functions rdmavt supports, nor do they know the ABI
 785          * version, so we do all of this sort of stuff here.
 786          */
 787         rdi->ibdev.uverbs_abi_ver = RVT_UVERBS_ABI_VERSION;
 788         rdi->ibdev.uverbs_cmd_mask =
 789                 (1ull << IB_USER_VERBS_CMD_GET_CONTEXT)         |
 790                 (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE)        |
 791                 (1ull << IB_USER_VERBS_CMD_QUERY_PORT)          |
 792                 (1ull << IB_USER_VERBS_CMD_ALLOC_PD)            |
 793                 (1ull << IB_USER_VERBS_CMD_DEALLOC_PD)          |
 794                 (1ull << IB_USER_VERBS_CMD_CREATE_AH)           |
 795                 (1ull << IB_USER_VERBS_CMD_MODIFY_AH)           |
 796                 (1ull << IB_USER_VERBS_CMD_QUERY_AH)            |
 797                 (1ull << IB_USER_VERBS_CMD_DESTROY_AH)          |
 798                 (1ull << IB_USER_VERBS_CMD_REG_MR)              |
 799                 (1ull << IB_USER_VERBS_CMD_DEREG_MR)            |
 800                 (1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL) |
 801                 (1ull << IB_USER_VERBS_CMD_CREATE_CQ)           |
 802                 (1ull << IB_USER_VERBS_CMD_RESIZE_CQ)           |
 803                 (1ull << IB_USER_VERBS_CMD_DESTROY_CQ)          |
 804                 (1ull << IB_USER_VERBS_CMD_POLL_CQ)             |
 805                 (1ull << IB_USER_VERBS_CMD_REQ_NOTIFY_CQ)       |
 806                 (1ull << IB_USER_VERBS_CMD_CREATE_QP)           |
 807                 (1ull << IB_USER_VERBS_CMD_QUERY_QP)            |
 808                 (1ull << IB_USER_VERBS_CMD_MODIFY_QP)           |
 809                 (1ull << IB_USER_VERBS_CMD_DESTROY_QP)          |
 810                 (1ull << IB_USER_VERBS_CMD_POST_SEND)           |
 811                 (1ull << IB_USER_VERBS_CMD_POST_RECV)           |
 812                 (1ull << IB_USER_VERBS_CMD_ATTACH_MCAST)        |
 813                 (1ull << IB_USER_VERBS_CMD_DETACH_MCAST)        |
 814                 (1ull << IB_USER_VERBS_CMD_CREATE_SRQ)          |
 815                 (1ull << IB_USER_VERBS_CMD_MODIFY_SRQ)          |
 816                 (1ull << IB_USER_VERBS_CMD_QUERY_SRQ)           |
 817                 (1ull << IB_USER_VERBS_CMD_DESTROY_SRQ)         |
 818                 (1ull << IB_USER_VERBS_CMD_POST_SRQ_RECV);
 819         rdi->ibdev.node_type = RDMA_NODE_IB_CA;
 820         rdi->ibdev.num_comp_vectors = 1;
 821
 822         /* We are now good to announce we exist */
 823         ret =  ib_register_device(&rdi->ibdev, rdi->driver_f.port_callback);
 824         if (ret) {
 825                 rvt_pr_err(rdi, "Failed to register driver with ib core.\n");
 826                 goto bail_cq;
 827         }
 828
 829         rvt_create_mad_agents(rdi);
 830
 831         rvt_pr_info(rdi, "Registration with rdmavt done.\n");
 832         return ret;
 833
 834 bail_cq:
 835         rvt_cq_exit(rdi);
 836
 837 bail_mr:
 838         rvt_mr_exit(rdi);
 839
 840 bail_no_mr:
 841         rvt_qp_exit(rdi);
 842
 843         return ret;
 844 }
 845 EXPORT_SYMBOL(rvt_register_device);
 846
 847 /**
 848  * rvt_unregister_device - remove a driver
 849  * @rdi: rvt dev struct
 850  */
 851 void rvt_unregister_device(struct rvt_dev_info *rdi)
 852 {
 853         trace_rvt_dbg(rdi, "Driver is unregistering.");
 854         if (!rdi)
 855                 return;
 856
 857         rvt_free_mad_agents(rdi);
 858
 859         ib_unregister_device(&rdi->ibdev);
 860         rvt_cq_exit(rdi);
 861         rvt_mr_exit(rdi);
 862         rvt_qp_exit(rdi);
 863 }
 864 EXPORT_SYMBOL(rvt_unregister_device);
 865
 866 /**
 867  * rvt_init_port - init internal data for driver port
 868  * @rdi: rvt dev strut
 869  * @port: rvt port
 870  * @port_index: 0 based index of ports, different from IB core port num
 871  *
 872  * Keep track of a list of ports. No need to have a detach port.
 873  * They persist until the driver goes away.
 874  *
 875  * Return: always 0
 876  */
 877 int rvt_init_port(struct rvt_dev_info *rdi, struct rvt_ibport *port,
 878                   int port_index, u16 *pkey_table)
 879 {
 880
 881         rdi->ports[port_index] = port;
 882         rdi->ports[port_index]->pkey_table = pkey_table;
 883
 884         return 0;
 885 }
 886 EXPORT_SYMBOL(rvt_init_port);