if (asd_ha->hw_prof.sas_addr[0])
                return 0;
 
-       return sas_request_addr(asd_ha->sas_ha.core.shost,
+       return sas_request_addr(asd_ha->sas_ha.shost,
                                asd_ha->hw_prof.sas_addr);
 }
 
 
 
        err = sas_unregister_ha(&asd_ha->sas_ha);
 
-       sas_remove_host(asd_ha->sas_ha.core.shost);
-       scsi_host_put(asd_ha->sas_ha.core.shost);
+       sas_remove_host(asd_ha->sas_ha.shost);
+       scsi_host_put(asd_ha->sas_ha.shost);
 
        kfree(asd_ha->sas_ha.sas_phy);
        kfree(asd_ha->sas_ha.sas_port);
        asd_printk("found %s, device %s\n", asd_ha->name, pci_name(dev));
 
        SHOST_TO_SAS_HA(shost) = &asd_ha->sas_ha;
-       asd_ha->sas_ha.core.shost = shost;
+       asd_ha->sas_ha.shost = shost;
        shost->transportt = aic94xx_transport_template;
        shost->max_id = ~0;
        shost->max_lun = ~0;
 
        sha->dev = hisi_hba->dev;
        sha->sas_addr = &hisi_hba->sas_addr[0];
        sha->num_phys = hisi_hba->n_phy;
-       sha->core.shost = hisi_hba->shost;
+       sha->shost = hisi_hba->shost;
 
        for (i = 0; i < hisi_hba->n_phy; i++) {
                sha->sas_phy[i] = &hisi_hba->phy[i].sas_phy;
 {
        struct sas_ha_struct *sha = platform_get_drvdata(pdev);
        struct hisi_hba *hisi_hba = sha->lldd_ha;
-       struct Scsi_Host *shost = sha->core.shost;
+       struct Scsi_Host *shost = sha->shost;
 
        del_timer_sync(&hisi_hba->timer);
 
        sas_unregister_ha(sha);
-       sas_remove_host(sha->core.shost);
+       sas_remove_host(shost);
 
        hisi_sas_free(hisi_hba);
        scsi_host_put(shost);
 
 
        sha->sas_phy = arr_phy;
        sha->sas_port = arr_port;
-       sha->core.shost = shost;
+       sha->shost = shost;
        sha->lldd_ha = hisi_hba;
 
        shost->transportt = hisi_sas_stt;
        struct device *dev = &pdev->dev;
        struct sas_ha_struct *sha = dev_get_drvdata(dev);
        struct hisi_hba *hisi_hba = sha->lldd_ha;
-       struct Scsi_Host *shost = sha->core.shost;
+       struct Scsi_Host *shost = sha->shost;
 
        pm_runtime_get_noresume(dev);
        del_timer_sync(&hisi_hba->timer);
 
        sas_unregister_ha(sha);
        flush_workqueue(hisi_hba->wq);
-       sas_remove_host(sha->core.shost);
+       sas_remove_host(shost);
 
        hisi_sas_v3_destroy_irqs(pdev, hisi_hba);
        hisi_sas_free(hisi_hba);
 
 
 static inline struct Scsi_Host *to_shost(struct isci_host *ihost)
 {
-       return ihost->sas_ha.core.shost;
+       return ihost->sas_ha.shost;
 }
 
 #define for_each_isci_host(id, ihost, pdev) \
 
                goto err_shost;
 
        SHOST_TO_SAS_HA(shost) = &ihost->sas_ha;
-       ihost->sas_ha.core.shost = shost;
+       ihost->sas_ha.shost = shost;
        shost->transportt = isci_transport_template;
 
        shost->max_id = ~0;
                sas_prep_resume_ha(&ihost->sas_ha);
 
                isci_host_init(ihost);
-               isci_host_start(ihost->sas_ha.core.shost);
+               isci_host_start(ihost->sas_ha.shost);
                wait_for_start(ihost);
 
                sas_resume_ha(&ihost->sas_ha);
 
        struct ata_port *ap = qc->ap;
        struct domain_device *dev = ap->private_data;
        struct sas_ha_struct *sas_ha = dev->port->ha;
-       struct Scsi_Host *host = sas_ha->core.shost;
+       struct Scsi_Host *host = sas_ha->shost;
        struct sas_internal *i = to_sas_internal(host->transportt);
 
        /* TODO: we should try to remove that unlock */
 
 static struct sas_internal *dev_to_sas_internal(struct domain_device *dev)
 {
-       return to_sas_internal(dev->port->ha->core.shost->transportt);
+       return to_sas_internal(dev->port->ha->shost->transportt);
 }
 
 static int sas_get_ata_command_set(struct domain_device *dev)
 int sas_ata_init(struct domain_device *found_dev)
 {
        struct sas_ha_struct *ha = found_dev->port->ha;
-       struct Scsi_Host *shost = ha->core.shost;
+       struct Scsi_Host *shost = ha->shost;
        struct ata_host *ata_host;
        struct ata_port *ap;
        int rc;
        struct sas_ha_struct *ha = dev->port->ha;
 
        sas_ata_printk(KERN_DEBUG, dev, "dev error handler\n");
-       ata_scsi_port_error_handler(ha->core.shost, ap);
+       ata_scsi_port_error_handler(ha->shost, ap);
        sas_put_device(dev);
 }
 
 
 {
        int res = 0;
        struct sas_ha_struct *sas_ha = dev->port->ha;
-       struct Scsi_Host *shost = sas_ha->core.shost;
+       struct Scsi_Host *shost = sas_ha->shost;
        struct sas_internal *i = to_sas_internal(shost->transportt);
 
        if (!i->dft->lldd_dev_found)
 void sas_notify_lldd_dev_gone(struct domain_device *dev)
 {
        struct sas_ha_struct *sas_ha = dev->port->ha;
-       struct Scsi_Host *shost = sas_ha->core.shost;
+       struct Scsi_Host *shost = sas_ha->shost;
        struct sas_internal *i = to_sas_internal(shost->transportt);
 
        if (!i->dft->lldd_dev_gone)
        struct domain_device *dev;
        struct sas_discovery_event *ev = to_sas_discovery_event(work);
        struct asd_sas_port *port = ev->port;
-       struct Scsi_Host *shost = port->ha->core.shost;
+       struct Scsi_Host *shost = port->ha->shost;
        struct sas_internal *si = to_sas_internal(shost->transportt);
 
        clear_bit(DISCE_SUSPEND, &port->disc.pending);
 static void sas_abort_device_scsi_cmds(struct domain_device *dev)
 {
        struct sas_ha_struct *sas_ha = dev->port->ha;
-       struct Scsi_Host *shost = sas_ha->core.shost;
+       struct Scsi_Host *shost = sas_ha->shost;
 
        if (dev_is_expander(dev->dev_type))
                return;
 
        int res, retry;
        struct sas_task *task = NULL;
        struct sas_internal *i =
-               to_sas_internal(dev->port->ha->core.shost->transportt);
+               to_sas_internal(dev->port->ha->shost->transportt);
        struct sas_ha_struct *ha = dev->port->ha;
 
        pm_runtime_get_sync(ha->dev);
 
                                   u8 reg_type, u8 reg_index, u8 reg_count,
                                   u8 *req_data)
 {
-       struct sas_internal *i = to_sas_internal(sas_ha->core.shost->transportt);
+       struct sas_internal *i = to_sas_internal(sas_ha->shost->transportt);
        int written;
 
        if (i->dft->lldd_write_gpio == NULL) {
                            enum sas_linkrate max, u8 *resp_data)
 {
        struct sas_internal *i =
-               to_sas_internal(sas_ha->core.shost->transportt);
+               to_sas_internal(sas_ha->shost->transportt);
        struct sas_phy_linkrates rates;
        struct asd_sas_phy *asd_phy;
 
 
                struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
                struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number];
                struct sas_internal *i =
-                       to_sas_internal(sas_ha->core.shost->transportt);
+                       to_sas_internal(sas_ha->shost->transportt);
 
                return i->dft->lldd_control_phy(asd_phy, PHY_FUNC_GET_EVENTS, NULL);
        }
                struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
                struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number];
                struct sas_internal *i =
-                       to_sas_internal(sas_ha->core.shost->transportt);
+                       to_sas_internal(sas_ha->shost->transportt);
 
                if (!hard_reset && sas_try_ata_reset(asd_phy) == 0)
                        return 0;
                struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
                struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number];
                struct sas_internal *i =
-                       to_sas_internal(sas_ha->core.shost->transportt);
+                       to_sas_internal(sas_ha->shost->transportt);
 
                if (enable)
                        ret = transport_sas_phy_reset(phy, 0);
                struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
                struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number];
                struct sas_internal *i =
-                       to_sas_internal(sas_ha->core.shost->transportt);
+                       to_sas_internal(sas_ha->shost->transportt);
 
                ret = i->dft->lldd_control_phy(asd_phy, reset_type, NULL);
        } else {
                struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
                struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number];
                struct sas_internal *i =
-                       to_sas_internal(sas_ha->core.shost->transportt);
+                       to_sas_internal(sas_ha->shost->transportt);
 
                ret = i->dft->lldd_control_phy(asd_phy, PHY_FUNC_SET_LINK_RATE,
                                               rates);
        /* all phys are back up or timed out, turn on i/o so we can
         * flush out disks that did not return
         */
-       scsi_unblock_requests(ha->core.shost);
+       scsi_unblock_requests(ha->shost);
        if (drain)
                sas_drain_work(ha);
        clear_bit(SAS_HA_RESUMING, &ha->state);
        int i;
 
        sas_disable_events(ha);
-       scsi_block_requests(ha->core.shost);
+       scsi_block_requests(ha->shost);
        for (i = 0; i < ha->num_phys; i++) {
                struct asd_sas_port *port = ha->sas_port[i];
 
        struct asd_sas_event *event;
        struct sas_ha_struct *sas_ha = phy->ha;
        struct sas_internal *i =
-               to_sas_internal(sas_ha->core.shost->transportt);
+               to_sas_internal(sas_ha->shost->transportt);
 
        event = kmem_cache_zalloc(sas_event_cache, gfp_flags);
        if (!event)
 
        struct sas_ha_struct *sas_ha = phy->ha;
        struct asd_sas_port *port = phy->port;
        struct sas_internal *i =
-               to_sas_internal(sas_ha->core.shost->transportt);
+               to_sas_internal(sas_ha->shost->transportt);
 
        sas_deform_port(phy, 1);
 
        struct asd_sas_phy *phy = ev->phy;
        struct sas_ha_struct *sas_ha = phy->ha;
        struct sas_internal *i =
-               to_sas_internal(sas_ha->core.shost->transportt);
+               to_sas_internal(sas_ha->shost->transportt);
 
        phy->error = 0;
        i->dft->lldd_control_phy(phy, PHY_FUNC_RELEASE_SPINUP_HOLD, NULL);
        struct asd_sas_phy *phy = ev->phy;
        struct sas_ha_struct *sas_ha = phy->ha;
        struct sas_internal *i =
-               to_sas_internal(sas_ha->core.shost->transportt);
+               to_sas_internal(sas_ha->shost->transportt);
 
        if (phy->enabled) {
                int ret;
                spin_lock_init(&phy->sas_prim_lock);
                phy->frame_rcvd_size = 0;
 
-               phy->phy = sas_phy_alloc(&sas_ha->core.shost->shost_gendev, i);
+               phy->phy = sas_phy_alloc(&sas_ha->shost->shost_gendev, i);
                if (!phy->phy)
                        return -ENOMEM;
 
 
        struct domain_device *dev, *n;
        struct asd_sas_port *port = phy->port;
        struct sas_ha_struct *sas_ha = phy->ha;
-       struct sas_internal *si = to_sas_internal(sas_ha->core.shost->transportt);
+       struct sas_internal *si = to_sas_internal(sas_ha->shost->transportt);
 
        if (si->dft->lldd_port_formed)
                si->dft->lldd_port_formed(phy);
        struct asd_sas_port *port = phy->port;
        struct domain_device *port_dev = NULL;
        struct sas_internal *si =
-               to_sas_internal(sas_ha->core.shost->transportt);
+               to_sas_internal(sas_ha->shost->transportt);
        unsigned long flags;
 
        if (port) {
        struct sas_ha_struct *sas_ha = phy->ha;
        struct asd_sas_port *port = phy->port;
        struct sas_internal *si =
-               to_sas_internal(sas_ha->core.shost->transportt);
+               to_sas_internal(sas_ha->shost->transportt);
        struct domain_device *dev;
        unsigned long flags;
 
 
        unsigned long flags;
        int i, res;
        struct sas_internal *si =
-               to_sas_internal(task->dev->port->ha->core.shost->transportt);
+               to_sas_internal(task->dev->port->ha->shost->transportt);
 
        for (i = 0; i < 5; i++) {
                pr_notice("%s: aborting task 0x%p\n", __func__, task);
        int res = TMF_RESP_FUNC_FAILED;
        struct scsi_lun lun;
        struct sas_internal *i =
-               to_sas_internal(dev->port->ha->core.shost->transportt);
+               to_sas_internal(dev->port->ha->shost->transportt);
 
        int_to_scsilun(cmd->device->lun, &lun);
 
 {
        int res = TMF_RESP_FUNC_FAILED;
        struct sas_internal *i =
-               to_sas_internal(dev->port->ha->core.shost->transportt);
+               to_sas_internal(dev->port->ha->shost->transportt);
 
        pr_notice("I_T nexus reset for dev %016llx\n",
                  SAS_ADDR(dev->sas_addr));
        spin_unlock_irq(&ha->lock);
 
        /* make sure SCSI EH is complete */
-       if (scsi_host_in_recovery(ha->core.shost)) {
+       if (scsi_host_in_recovery(ha->shost)) {
                msleep(10);
                goto retry;
        }
                        set_bit(SAS_DEV_EH_PENDING, &dev->state);
                        set_bit(reset_type, &dev->state);
                        int_to_scsilun(lun, &dev->ssp_dev.reset_lun);
-                       scsi_schedule_eh(ha->core.shost);
+                       scsi_schedule_eh(ha->shost);
                }
                spin_unlock_irq(&ha->lock);
 
                                      unsigned int qid, void *data)
 {
        struct sas_ha_struct *ha = device->port->ha;
-       struct sas_internal *i = to_sas_internal(ha->core.shost->transportt);
+       struct sas_internal *i = to_sas_internal(ha->shost->transportt);
        struct sas_task *task = NULL;
        int res, retry;
 
 {
        struct sas_task *task;
        struct sas_internal *i =
-               to_sas_internal(device->port->ha->core.shost->transportt);
+               to_sas_internal(device->port->ha->shost->transportt);
        int res, retry;
 
        for (retry = 0; retry < TASK_RETRY; retry++) {
 
 
        sha->sas_phy = arr_phy;
        sha->sas_port = arr_port;
-       sha->core.shost = shost;
+       sha->shost = shost;
 
        sha->lldd_ha = kzalloc(sizeof(struct mvs_prv_info), GFP_KERNEL);
        if (!sha->lldd_ha)
        shost->sg_tablesize = min_t(u16, SG_ALL, MVS_MAX_SG);
        shost->can_queue = can_queue;
        mvi->shost->cmd_per_lun = MVS_QUEUE_SIZE;
-       sha->core.shost = mvi->shost;
+       sha->shost = mvi->shost;
 }
 
 static void mvs_init_sas_add(struct mvs_info *mvi)
 
        sha->strict_wide_ports = 1;
        sha->sas_addr = &pm8001_ha->sas_addr[0];
        sha->num_phys = chip_info->n_phy;
-       sha->core.shost = shost;
+       sha->shost = shost;
 }
 
 /**
 
        void *lldd_phy;           /* not touched by the sas_class_code */
 };
 
-struct scsi_core {
-       struct Scsi_Host *shost;
-
-};
-
 enum sas_ha_state {
        SAS_HA_REGISTERED,
        SAS_HA_DRAINING,
 
        struct mutex disco_mutex;
 
-       struct scsi_core core;
+       struct Scsi_Host *shost;
 
 /* public: */
        char *sas_ha_name;