config INFINIBAND_HFI1
        tristate "Intel OPA Gen1 support"
-       depends on X86_64
+       depends on X86_64 && INFINIBAND_RDMAVT
        select MMU_NOTIFIER
        default m
        ---help---
 
                        sdma_all_running(dd);
 
                        /* Signal the IB layer that the port has went active */
-                       event.device = &dd->verbs_dev.ibdev;
+                       event.device = &dd->verbs_dev.rdi.ibdev;
                        event.element.port_num = ppd->port;
                        event.event = IB_EVENT_PORT_ACTIVE;
                }
 
                        vl = sc4;
                } else {
                        sl = (byte_two >> 4) & 0xf;
-                       ibp = to_iport(&dd->verbs_dev.ibdev, 1);
+                       ibp = to_iport(&dd->verbs_dev.rdi.ibdev, 1);
                        sc5 = ibp->sl_to_sc[sl];
                        vl = sc_to_vlt(dd, sc5);
                        if (vl != sc4) {
 
 #include <linux/cdev.h>
 #include <linux/delay.h>
 #include <linux/kthread.h>
-#include <linux/mmu_notifier.h>
-#include <linux/rbtree.h>
+#include <rdma/rdma_vt.h>
 
 #include "chip_registers.h"
 #include "common.h"
 
 #include <linux/module.h>
 #include <linux/printk.h>
 #include <linux/hrtimer.h>
+#include <rdma/rdma_vt.h>
 
 #include "hfi.h"
 #include "device.h"
        rcu_barrier(); /* wait for rcu callbacks to complete */
        free_percpu(dd->int_counter);
        free_percpu(dd->rcv_limit);
-       ib_dealloc_device(&dd->verbs_dev.ibdev);
+       ib_dealloc_device(&dd->verbs_dev.rdi.ibdev);
 }
 
 /*
 bail:
        if (!list_empty(&dd->list))
                list_del_init(&dd->list);
-       ib_dealloc_device(&dd->verbs_dev.ibdev);
+       ib_dealloc_device(&dd->verbs_dev.rdi.ibdev);
        return ERR_PTR(ret);
 }
 
 
         */
        if (!(dd->flags & HFI1_INITTED))
                return;
-       event.device = &dd->verbs_dev.ibdev;
+       event.device = &dd->verbs_dev.rdi.ibdev;
        event.element.port_num = ppd->port;
        event.event = ev;
        ib_dispatch_event(&event);
 
                (void)hfi1_set_ib_cfg(ppd, HFI1_IB_CFG_PKEYS, 0);
 
                event.event = IB_EVENT_PKEY_CHANGE;
-               event.device = &dd->verbs_dev.ibdev;
+               event.device = &dd->verbs_dev.rdi.ibdev;
                event.element.port_num = port;
                ib_dispatch_event(&event);
        }
 
        for (p = 0; p < dd->num_pports; p++) {
                ibp = &dd->pport[p].ibport_data;
-               agent = ib_register_mad_agent(&dev->ibdev, p + 1, IB_QPT_SMI,
+               agent = ib_register_mad_agent(&dev->rdi.ibdev, p + 1,
+                                             IB_QPT_SMI,
                                              NULL, 0, send_handler,
                                              NULL, NULL, 0);
                if (IS_ERR(agent)) {
 
                return NULL;
 
        iter->dev = dev;
-       iter->specials = dev->ibdev.phys_port_cnt * 2;
+       iter->specials = dev->rdi.ibdev.phys_port_cnt * 2;
        if (qp_iter_next(iter)) {
                kfree(iter);
                return NULL;
                                struct hfi1_ibport *ibp;
                                int pidx;
 
-                               pidx = n % dev->ibdev.phys_port_cnt;
+                               pidx = n % dev->rdi.ibdev.phys_port_cnt;
                                ppd = &dd_from_dev(dev)->pport[pidx];
                                ibp = &ppd->ibport_data;
 
 
                        char *buf)
 {
        struct hfi1_ibdev *dev =
-               container_of(device, struct hfi1_ibdev, ibdev.dev);
+               container_of(device, struct hfi1_ibdev, rdi.ibdev.dev);
 
        return sprintf(buf, "%x\n", dd_from_dev(dev)->minrev);
 }
                        char *buf)
 {
        struct hfi1_ibdev *dev =
-               container_of(device, struct hfi1_ibdev, ibdev.dev);
+               container_of(device, struct hfi1_ibdev, rdi.ibdev.dev);
        struct hfi1_devdata *dd = dd_from_dev(dev);
        int ret;
 
                                 struct device_attribute *attr, char *buf)
 {
        struct hfi1_ibdev *dev =
-               container_of(device, struct hfi1_ibdev, ibdev.dev);
+               container_of(device, struct hfi1_ibdev, rdi.ibdev.dev);
        struct hfi1_devdata *dd = dd_from_dev(dev);
 
        /* The string printed here is already newline-terminated. */
                           struct device_attribute *attr, char *buf)
 {
        struct hfi1_ibdev *dev =
-               container_of(device, struct hfi1_ibdev, ibdev.dev);
+               container_of(device, struct hfi1_ibdev, rdi.ibdev.dev);
        struct hfi1_devdata *dd = dd_from_dev(dev);
 
        /*
                           struct device_attribute *attr, char *buf)
 {
        struct hfi1_ibdev *dev =
-               container_of(device, struct hfi1_ibdev, ibdev.dev);
+               container_of(device, struct hfi1_ibdev, rdi.ibdev.dev);
        struct hfi1_devdata *dd = dd_from_dev(dev);
 
        /* Return the number of free user ports (contexts) available. */
                           struct device_attribute *attr, char *buf)
 {
        struct hfi1_ibdev *dev =
-               container_of(device, struct hfi1_ibdev, ibdev.dev);
+               container_of(device, struct hfi1_ibdev, rdi.ibdev.dev);
        struct hfi1_devdata *dd = dd_from_dev(dev);
 
        return scnprintf(buf, PAGE_SIZE, "%s", dd->serial);
                                size_t count)
 {
        struct hfi1_ibdev *dev =
-               container_of(device, struct hfi1_ibdev, ibdev.dev);
+               container_of(device, struct hfi1_ibdev, rdi.ibdev.dev);
        struct hfi1_devdata *dd = dd_from_dev(dev);
        int ret;
 
                              struct device_attribute *attr, char *buf)
 {
        struct hfi1_ibdev *dev =
-               container_of(device, struct hfi1_ibdev, ibdev.dev);
+               container_of(device, struct hfi1_ibdev, rdi.ibdev.dev);
        struct hfi1_devdata *dd = dd_from_dev(dev);
        struct hfi1_temp temp;
        int ret;
  */
 int hfi1_verbs_register_sysfs(struct hfi1_devdata *dd)
 {
-       struct ib_device *dev = &dd->verbs_dev.ibdev;
+       struct ib_device *dev = &dd->verbs_dev.rdi.ibdev;
        int i, ret;
 
        for (i = 0; i < ARRAY_SIZE(hfi1_attributes); ++i) {
 
 int hfi1_register_ib_device(struct hfi1_devdata *dd)
 {
        struct hfi1_ibdev *dev = &dd->verbs_dev;
-       struct ib_device *ibdev = &dev->ibdev;
+       struct ib_device *ibdev = &dev->rdi.ibdev;
        struct hfi1_pportdata *ppd = dd->pport;
        unsigned i, lk_tab_size;
        int ret;
        strncpy(ibdev->node_desc, init_utsname()->nodename,
                sizeof(ibdev->node_desc));
 
-       ret = ib_register_device(ibdev, hfi1_create_port_files);
+       /*
+        * Fill in rvt info object.
+        */
+       dd->verbs_dev.rdi.driver_f.port_callback = hfi1_create_port_files;
+       dd->verbs_dev.rdi.dparms.props.max_pd = hfi1_max_pds;
+
+       ret = rvt_register_device(&dd->verbs_dev.rdi);
        if (ret)
                goto err_reg;
 
 err_class:
        hfi1_free_agents(dev);
 err_agents:
-       ib_unregister_device(ibdev);
+       rvt_unregister_device(&dd->verbs_dev.rdi);
 err_reg:
 err_verbs_txreq:
        kmem_cache_destroy(dev->verbs_txreq_cache);
 void hfi1_unregister_ib_device(struct hfi1_devdata *dd)
 {
        struct hfi1_ibdev *dev = &dd->verbs_dev;
-       struct ib_device *ibdev = &dev->ibdev;
 
        hfi1_verbs_unregister_sysfs(dd);
 
        hfi1_free_agents(dev);
 
-       ib_unregister_device(ibdev);
+       rvt_unregister_device(&dd->verbs_dev.rdi);
 
        if (!list_empty(&dev->txwait))
                dd_dev_err(dd, "txwait list not empty!\n");
 
 #include <rdma/ib_pack.h>
 #include <rdma/ib_user_verbs.h>
 #include <rdma/ib_mad.h>
+#include <rdma/rdma_vt.h>
 
 struct hfi1_ctxtdata;
 struct hfi1_pportdata;
 
 struct hfi1_qp_ibdev;
 struct hfi1_ibdev {
-       struct ib_device ibdev;
+       struct rvt_dev_info rdi; /* Must be first */
        struct list_head pending_mmaps;
        spinlock_t mmap_offset_lock; /* protect mmap_offset */
        u32 mmap_offset;
 
 static inline struct hfi1_ibdev *to_idev(struct ib_device *ibdev)
 {
-       return container_of(ibdev, struct hfi1_ibdev, ibdev);
+       struct rvt_dev_info *rdi;
+
+       rdi = container_of(ibdev, struct rvt_dev_info, ibdev);
+       return container_of(rdi, struct hfi1_ibdev, rdi);
 }
 
 /*