if (!iu->buf)
                goto out_free_iu;
 
-       iu->dma = ib_dma_map_single(host->dev->dev, iu->buf, size, direction);
-       if (ib_dma_mapping_error(host->dev->dev, iu->dma))
+       iu->dma = ib_dma_map_single(host->srp_dev->dev, iu->buf, size,
+                                   direction);
+       if (ib_dma_mapping_error(host->srp_dev->dev, iu->dma))
                goto out_free_buf;
 
        iu->size      = size;
        if (!iu)
                return;
 
-       ib_dma_unmap_single(host->dev->dev, iu->dma, iu->size, iu->direction);
+       ib_dma_unmap_single(host->srp_dev->dev, iu->dma, iu->size,
+                           iu->direction);
        kfree(iu->buf);
        kfree(iu);
 }
        if (!attr)
                return -ENOMEM;
 
-       ret = ib_find_cached_pkey(target->srp_host->dev->dev,
+       ret = ib_find_cached_pkey(target->srp_host->srp_dev->dev,
                                  target->srp_host->port,
                                  be16_to_cpu(target->path.pkey),
                                  &attr->pkey_index);
 {
        struct ib_cm_id *new_cm_id;
 
-       new_cm_id = ib_create_cm_id(target->srp_host->dev->dev,
+       new_cm_id = ib_create_cm_id(target->srp_host->srp_dev->dev,
                                    srp_cm_handler, target);
        if (IS_ERR(new_cm_id))
                return PTR_ERR(new_cm_id);
        if (!init_attr)
                return -ENOMEM;
 
-       target->cq = ib_create_cq(target->srp_host->dev->dev, srp_completion,
-                                 NULL, target, SRP_CQ_SIZE, 0);
+       target->cq = ib_create_cq(target->srp_host->srp_dev->dev,
+                                 srp_completion, NULL, target, SRP_CQ_SIZE, 0);
        if (IS_ERR(target->cq)) {
                ret = PTR_ERR(target->cq);
                goto out;
        init_attr->send_cq             = target->cq;
        init_attr->recv_cq             = target->cq;
 
-       target->qp = ib_create_qp(target->srp_host->dev->pd, init_attr);
+       target->qp = ib_create_qp(target->srp_host->srp_dev->pd, init_attr);
        if (IS_ERR(target->qp)) {
                ret = PTR_ERR(target->qp);
                ib_destroy_cq(target->cq);
        init_completion(&target->done);
 
        target->path_query_id = ib_sa_path_rec_get(&srp_sa_client,
-                                                  target->srp_host->dev->dev,
+                                                  target->srp_host->srp_dev->dev,
                                                   target->srp_host->port,
                                                   &target->path,
                                                   IB_SA_PATH_REC_SERVICE_ID    |
                             (unsigned long long) be64_to_cpu(target->ioc_guid));
                memset(req->priv.initiator_port_id, 0, 8);
                memcpy(req->priv.initiator_port_id + 8,
-                      &target->srp_host->dev->dev->node_guid, 8);
+                      &target->srp_host->srp_dev->dev->node_guid, 8);
        }
 
        status = ib_send_cm_req(target->cm_id, &req->param);
                req->fmr = NULL;
        }
 
-       ib_dma_unmap_sg(target->srp_host->dev->dev, scsi_sglist(scmnd),
+       ib_dma_unmap_sg(target->srp_host->srp_dev->dev, scsi_sglist(scmnd),
                        scsi_sg_count(scmnd), scmnd->sc_data_direction);
 }
 
        int page_cnt;
        int i, j;
        int ret;
-       struct srp_device *dev = target->srp_host->dev;
+       struct srp_device *dev = target->srp_host->srp_dev;
        struct ib_device *ibdev = dev->dev;
        struct scatterlist *sg;
 
        nents = scsi_sg_count(scmnd);
        scat  = scsi_sglist(scmnd);
 
-       dev = target->srp_host->dev;
+       dev = target->srp_host->srp_dev;
        ibdev = dev->dev;
 
        count = ib_dma_map_sg(ibdev, scat, nents, scmnd->sc_data_direction);
                buf->table_desc.va  =
                        cpu_to_be64(req->cmd->dma + sizeof *cmd + sizeof *buf);
                buf->table_desc.key =
-                       cpu_to_be32(target->srp_host->dev->mr->rkey);
+                       cpu_to_be32(target->srp_host->srp_dev->mr->rkey);
                buf->table_desc.len =
                        cpu_to_be32(count * sizeof (struct srp_direct_buf));
 
 
        iu = target->rx_ring[wc->wr_id & ~SRP_OP_RECV];
 
-       dev = target->srp_host->dev->dev;
+       dev = target->srp_host->srp_dev->dev;
        ib_dma_sync_single_for_cpu(dev, iu->dma, target->max_ti_iu_len,
                                   DMA_FROM_DEVICE);
 
 
        list.addr   = iu->dma;
        list.length = iu->size;
-       list.lkey   = target->srp_host->dev->mr->lkey;
+       list.lkey   = target->srp_host->srp_dev->mr->lkey;
 
        wr.next     = NULL;
        wr.sg_list  = &list;
 
        list.addr   = iu->dma;
        list.length = len;
-       list.lkey   = target->srp_host->dev->mr->lkey;
+       list.lkey   = target->srp_host->srp_dev->mr->lkey;
 
        wr.next       = NULL;
        wr.wr_id      = target->tx_head & SRP_SQ_SIZE;
        if (!iu)
                goto err;
 
-       dev = target->srp_host->dev->dev;
+       dev = target->srp_host->srp_dev->dev;
        ib_dma_sync_single_for_cpu(dev, iu->dma, srp_max_iu_len,
                                   DMA_TO_DEVICE);
 
 {
        struct srp_target_port *target = host_to_target(class_to_shost(cdev));
 
-       return sprintf(buf, "%s\n", target->srp_host->dev->dev->name);
+       return sprintf(buf, "%s\n", target->srp_host->srp_dev->dev->name);
 }
 
 static CLASS_DEVICE_ATTR(id_ext,         S_IRUGO, show_id_ext,          NULL);
        sprintf(target->target_name, "SRP.T10:%016llX",
                 (unsigned long long) be64_to_cpu(target->id_ext));
 
-       if (scsi_add_host(target->scsi_host, host->dev->dev->dma_device))
+       if (scsi_add_host(target->scsi_host, host->srp_dev->dev->dma_device))
                return -ENODEV;
 
        memcpy(ids.port_id, &target->id_ext, 8);
        if (ret)
                goto err;
 
-       ib_get_cached_gid(host->dev->dev, host->port, 0, &target->path.sgid);
+       ib_get_cached_gid(host->srp_dev->dev, host->port, 0,
+                         &target->path.sgid);
 
        shost_printk(KERN_DEBUG, target->scsi_host, PFX
                     "new target: id_ext %016llx ioc_guid %016llx pkey %04x "
        struct srp_host *host =
                container_of(class_dev, struct srp_host, class_dev);
 
-       return sprintf(buf, "%s\n", host->dev->dev->name);
+       return sprintf(buf, "%s\n", host->srp_dev->dev->name);
 }
 
 static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
        INIT_LIST_HEAD(&host->target_list);
        spin_lock_init(&host->target_lock);
        init_completion(&host->released);
-       host->dev  = device;
+       host->srp_dev = device;
        host->port = port;
 
        host->class_dev.class = &srp_class;