drivers/scsi/hisi_sas/hisi_sas_main.c

   1 /*
   2  * Copyright (c) 2015 Linaro Ltd.
   3  * Copyright (c) 2015 Hisilicon Limited.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  */
  11
  12 #include "hisi_sas.h"
  13 #define DRV_NAME "hisi_sas"
  14
  15 #define DEV_IS_GONE(dev) \
  16         ((!dev) || (dev->dev_type == SAS_PHY_UNUSED))
  17
  18 static int hisi_sas_debug_issue_ssp_tmf(struct domain_device *device,
  19                                 u8 *lun, struct hisi_sas_tmf_task *tmf);
  20 static int
  21 hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
  22                              struct domain_device *device,
  23                              int abort_flag, int tag);
  24 static int hisi_sas_softreset_ata_disk(struct domain_device *device);
  25 static int hisi_sas_control_phy(struct asd_sas_phy *sas_phy, enum phy_func func,
  26                                 void *funcdata);
  27 static void hisi_sas_release_task(struct hisi_hba *hisi_hba,
  28                                   struct domain_device *device);
  29 static void hisi_sas_dev_gone(struct domain_device *device);
  30
  31 u8 hisi_sas_get_ata_protocol(struct host_to_dev_fis *fis, int direction)
  32 {
  33         switch (fis->command) {
  34         case ATA_CMD_FPDMA_WRITE:
  35         case ATA_CMD_FPDMA_READ:
  36         case ATA_CMD_FPDMA_RECV:
  37         case ATA_CMD_FPDMA_SEND:
  38         case ATA_CMD_NCQ_NON_DATA:
  39                 return HISI_SAS_SATA_PROTOCOL_FPDMA;
  40
  41         case ATA_CMD_DOWNLOAD_MICRO:
  42         case ATA_CMD_ID_ATA:
  43         case ATA_CMD_PMP_READ:
  44         case ATA_CMD_READ_LOG_EXT:
  45         case ATA_CMD_PIO_READ:
  46         case ATA_CMD_PIO_READ_EXT:
  47         case ATA_CMD_PMP_WRITE:
  48         case ATA_CMD_WRITE_LOG_EXT:
  49         case ATA_CMD_PIO_WRITE:
  50         case ATA_CMD_PIO_WRITE_EXT:
  51                 return HISI_SAS_SATA_PROTOCOL_PIO;
  52
  53         case ATA_CMD_DSM:
  54         case ATA_CMD_DOWNLOAD_MICRO_DMA:
  55         case ATA_CMD_PMP_READ_DMA:
  56         case ATA_CMD_PMP_WRITE_DMA:
  57         case ATA_CMD_READ:
  58         case ATA_CMD_READ_EXT:
  59         case ATA_CMD_READ_LOG_DMA_EXT:
  60         case ATA_CMD_READ_STREAM_DMA_EXT:
  61         case ATA_CMD_TRUSTED_RCV_DMA:
  62         case ATA_CMD_TRUSTED_SND_DMA:
  63         case ATA_CMD_WRITE:
  64         case ATA_CMD_WRITE_EXT:
  65         case ATA_CMD_WRITE_FUA_EXT:
  66         case ATA_CMD_WRITE_QUEUED:
  67         case ATA_CMD_WRITE_LOG_DMA_EXT:
  68         case ATA_CMD_WRITE_STREAM_DMA_EXT:
  69         case ATA_CMD_ZAC_MGMT_IN:
  70                 return HISI_SAS_SATA_PROTOCOL_DMA;
  71
  72         case ATA_CMD_CHK_POWER:
  73         case ATA_CMD_DEV_RESET:
  74         case ATA_CMD_EDD:
  75         case ATA_CMD_FLUSH:
  76         case ATA_CMD_FLUSH_EXT:
  77         case ATA_CMD_VERIFY:
  78         case ATA_CMD_VERIFY_EXT:
  79         case ATA_CMD_SET_FEATURES:
  80         case ATA_CMD_STANDBY:
  81         case ATA_CMD_STANDBYNOW1:
  82         case ATA_CMD_ZAC_MGMT_OUT:
  83                 return HISI_SAS_SATA_PROTOCOL_NONDATA;
  84
  85         case ATA_CMD_SET_MAX:
  86                 switch (fis->features) {
  87                 case ATA_SET_MAX_PASSWD:
  88                 case ATA_SET_MAX_LOCK:
  89                         return HISI_SAS_SATA_PROTOCOL_PIO;
  90
  91                 case ATA_SET_MAX_PASSWD_DMA:
  92                 case ATA_SET_MAX_UNLOCK_DMA:
  93                         return HISI_SAS_SATA_PROTOCOL_DMA;
  94
  95                 default:
  96                         return HISI_SAS_SATA_PROTOCOL_NONDATA;
  97                 }
  98
  99         default:
 100         {
 101                 if (direction == DMA_NONE)
 102                         return HISI_SAS_SATA_PROTOCOL_NONDATA;
 103                 return HISI_SAS_SATA_PROTOCOL_PIO;
 104         }
 105         }
 106 }
 107 EXPORT_SYMBOL_GPL(hisi_sas_get_ata_protocol);
 108
 109 void hisi_sas_sata_done(struct sas_task *task,
 110                             struct hisi_sas_slot *slot)
 111 {
 112         struct task_status_struct *ts = &task->task_status;
 113         struct ata_task_resp *resp = (struct ata_task_resp *)ts->buf;
 114         struct hisi_sas_status_buffer *status_buf =
 115                         hisi_sas_status_buf_addr_mem(slot);
 116         u8 *iu = &status_buf->iu[0];
 117         struct dev_to_host_fis *d2h =  (struct dev_to_host_fis *)iu;
 118
 119         resp->frame_len = sizeof(struct dev_to_host_fis);
 120         memcpy(&resp->ending_fis[0], d2h, sizeof(struct dev_to_host_fis));
 121
 122         ts->buf_valid_size = sizeof(*resp);
 123 }
 124 EXPORT_SYMBOL_GPL(hisi_sas_sata_done);
 125
 126 int hisi_sas_get_ncq_tag(struct sas_task *task, u32 *tag)
 127 {
 128         struct ata_queued_cmd *qc = task->uldd_task;
 129
 130         if (qc) {
 131                 if (qc->tf.command == ATA_CMD_FPDMA_WRITE ||
 132                         qc->tf.command == ATA_CMD_FPDMA_READ) {
 133                         *tag = qc->tag;
 134                         return 1;
 135                 }
 136         }
 137         return 0;
 138 }
 139 EXPORT_SYMBOL_GPL(hisi_sas_get_ncq_tag);
 140
 141 /*
 142  * This function assumes linkrate mask fits in 8 bits, which it
 143  * does for all HW versions supported.
 144  */
 145 u8 hisi_sas_get_prog_phy_linkrate_mask(enum sas_linkrate max)
 146 {
 147         u16 rate = 0;
 148         int i;
 149
 150         max -= SAS_LINK_RATE_1_5_GBPS;
 151         for (i = 0; i <= max; i++)
 152                 rate |= 1 << (i * 2);
 153         return rate;
 154 }
 155 EXPORT_SYMBOL_GPL(hisi_sas_get_prog_phy_linkrate_mask);
 156
 157 static struct hisi_hba *dev_to_hisi_hba(struct domain_device *device)
 158 {
 159         return device->port->ha->lldd_ha;
 160 }
 161
 162 struct hisi_sas_port *to_hisi_sas_port(struct asd_sas_port *sas_port)
 163 {
 164         return container_of(sas_port, struct hisi_sas_port, sas_port);
 165 }
 166 EXPORT_SYMBOL_GPL(to_hisi_sas_port);
 167
 168 void hisi_sas_stop_phys(struct hisi_hba *hisi_hba)
 169 {
 170         int phy_no;
 171
 172         for (phy_no = 0; phy_no < hisi_hba->n_phy; phy_no++)
 173                 hisi_hba->hw->phy_disable(hisi_hba, phy_no);
 174 }
 175 EXPORT_SYMBOL_GPL(hisi_sas_stop_phys);
 176
 177 static void hisi_sas_slot_index_clear(struct hisi_hba *hisi_hba, int slot_idx)
 178 {
 179         void *bitmap = hisi_hba->slot_index_tags;
 180
 181         clear_bit(slot_idx, bitmap);
 182 }
 183
 184 static void hisi_sas_slot_index_free(struct hisi_hba *hisi_hba, int slot_idx)
 185 {
 186         hisi_sas_slot_index_clear(hisi_hba, slot_idx);
 187 }
 188
 189 static void hisi_sas_slot_index_set(struct hisi_hba *hisi_hba, int slot_idx)
 190 {
 191         void *bitmap = hisi_hba->slot_index_tags;
 192
 193         set_bit(slot_idx, bitmap);
 194 }
 195
 196 static int hisi_sas_slot_index_alloc(struct hisi_hba *hisi_hba, int *slot_idx)
 197 {
 198         unsigned int index;
 199         void *bitmap = hisi_hba->slot_index_tags;
 200
 201         index = find_next_zero_bit(bitmap, hisi_hba->slot_index_count,
 202                         hisi_hba->last_slot_index + 1);
 203         if (index >= hisi_hba->slot_index_count) {
 204                 index = find_next_zero_bit(bitmap, hisi_hba->slot_index_count,
 205                                            0);
 206                 if (index >= hisi_hba->slot_index_count)
 207                         return -SAS_QUEUE_FULL;
 208         }
 209         hisi_sas_slot_index_set(hisi_hba, index);
 210         *slot_idx = index;
 211         hisi_hba->last_slot_index = index;
 212
 213         return 0;
 214 }
 215
 216 static void hisi_sas_slot_index_init(struct hisi_hba *hisi_hba)
 217 {
 218         int i;
 219
 220         for (i = 0; i < hisi_hba->slot_index_count; ++i)
 221                 hisi_sas_slot_index_clear(hisi_hba, i);
 222 }
 223
 224 void hisi_sas_slot_task_free(struct hisi_hba *hisi_hba, struct sas_task *task,
 225                              struct hisi_sas_slot *slot)
 226 {
 227         struct hisi_sas_dq *dq = &hisi_hba->dq[slot->dlvry_queue];
 228         unsigned long flags;
 229
 230         if (task) {
 231                 struct device *dev = hisi_hba->dev;
 232
 233                 if (!task->lldd_task)
 234                         return;
 235
 236                 task->lldd_task = NULL;
 237
 238                 if (!sas_protocol_ata(task->task_proto))
 239                         if (slot->n_elem)
 240                                 dma_unmap_sg(dev, task->scatter,
 241                                              task->num_scatter,
 242                                              task->data_dir);
 243         }
 244
 245
 246         spin_lock_irqsave(&dq->lock, flags);
 247         list_del_init(&slot->entry);
 248         spin_unlock_irqrestore(&dq->lock, flags);
 249
 250         memset(slot, 0, offsetof(struct hisi_sas_slot, buf));
 251
 252         spin_lock_irqsave(&hisi_hba->lock, flags);
 253         hisi_sas_slot_index_free(hisi_hba, slot->idx);
 254         spin_unlock_irqrestore(&hisi_hba->lock, flags);
 255 }
 256 EXPORT_SYMBOL_GPL(hisi_sas_slot_task_free);
 257
 258 static void hisi_sas_task_prep_smp(struct hisi_hba *hisi_hba,
 259                                   struct hisi_sas_slot *slot)
 260 {
 261         hisi_hba->hw->prep_smp(hisi_hba, slot);
 262 }
 263
 264 static void hisi_sas_task_prep_ssp(struct hisi_hba *hisi_hba,
 265                                   struct hisi_sas_slot *slot)
 266 {
 267         hisi_hba->hw->prep_ssp(hisi_hba, slot);
 268 }
 269
 270 static void hisi_sas_task_prep_ata(struct hisi_hba *hisi_hba,
 271                                   struct hisi_sas_slot *slot)
 272 {
 273         hisi_hba->hw->prep_stp(hisi_hba, slot);
 274 }
 275
 276 static void hisi_sas_task_prep_abort(struct hisi_hba *hisi_hba,
 277                 struct hisi_sas_slot *slot,
 278                 int device_id, int abort_flag, int tag_to_abort)
 279 {
 280         hisi_hba->hw->prep_abort(hisi_hba, slot,
 281                         device_id, abort_flag, tag_to_abort);
 282 }
 283
 284 static int hisi_sas_task_prep(struct sas_task *task,
 285                               struct hisi_sas_dq **dq_pointer,
 286                               bool is_tmf, struct hisi_sas_tmf_task *tmf,
 287                               int *pass)
 288 {
 289         struct domain_device *device = task->dev;
 290         struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
 291         struct hisi_sas_device *sas_dev = device->lldd_dev;
 292         struct hisi_sas_port *port;
 293         struct hisi_sas_slot *slot;
 294         struct hisi_sas_cmd_hdr *cmd_hdr_base;
 295         struct asd_sas_port *sas_port = device->port;
 296         struct device *dev = hisi_hba->dev;
 297         int dlvry_queue_slot, dlvry_queue, rc, slot_idx;
 298         int n_elem = 0, n_elem_req = 0, n_elem_resp = 0;
 299         struct hisi_sas_dq *dq;
 300         unsigned long flags;
 301         int wr_q_index;
 302
 303         if (!sas_port) {
 304                 struct task_status_struct *ts = &task->task_status;
 305
 306                 ts->resp = SAS_TASK_UNDELIVERED;
 307                 ts->stat = SAS_PHY_DOWN;
 308                 /*
 309                  * libsas will use dev->port, should
 310                  * not call task_done for sata
 311                  */
 312                 if (device->dev_type != SAS_SATA_DEV)
 313                         task->task_done(task);
 314                 return -ECOMM;
 315         }
 316
 317         if (DEV_IS_GONE(sas_dev)) {
 318                 if (sas_dev)
 319                         dev_info(dev, "task prep: device %d not ready\n",
 320                                  sas_dev->device_id);
 321                 else
 322                         dev_info(dev, "task prep: device %016llx not ready\n",
 323                                  SAS_ADDR(device->sas_addr));
 324
 325                 return -ECOMM;
 326         }
 327
 328         *dq_pointer = dq = sas_dev->dq;
 329
 330         port = to_hisi_sas_port(sas_port);
 331         if (port && !port->port_attached) {
 332                 dev_info(dev, "task prep: %s port%d not attach device\n",
 333                          (dev_is_sata(device)) ?
 334                          "SATA/STP" : "SAS",
 335                          device->port->id);
 336
 337                 return -ECOMM;
 338         }
 339
 340         if (!sas_protocol_ata(task->task_proto)) {
 341                 unsigned int req_len, resp_len;
 342
 343                 if (task->num_scatter) {
 344                         n_elem = dma_map_sg(dev, task->scatter,
 345                                             task->num_scatter, task->data_dir);
 346                         if (!n_elem) {
 347                                 rc = -ENOMEM;
 348                                 goto prep_out;
 349                         }
 350                 } else if (task->task_proto & SAS_PROTOCOL_SMP) {
 351                         n_elem_req = dma_map_sg(dev, &task->smp_task.smp_req,
 352                                                 1, DMA_TO_DEVICE);
 353                         if (!n_elem_req) {
 354                                 rc = -ENOMEM;
 355                                 goto prep_out;
 356                         }
 357                         req_len = sg_dma_len(&task->smp_task.smp_req);
 358                         if (req_len & 0x3) {
 359                                 rc = -EINVAL;
 360                                 goto err_out_dma_unmap;
 361                         }
 362                         n_elem_resp = dma_map_sg(dev, &task->smp_task.smp_resp,
 363                                                  1, DMA_FROM_DEVICE);
 364                         if (!n_elem_resp) {
 365                                 rc = -ENOMEM;
 366                                 goto err_out_dma_unmap;
 367                         }
 368                         resp_len = sg_dma_len(&task->smp_task.smp_resp);
 369                         if (resp_len & 0x3) {
 370                                 rc = -EINVAL;
 371                                 goto err_out_dma_unmap;
 372                         }
 373                 }
 374         } else
 375                 n_elem = task->num_scatter;
 376
 377         if (n_elem > HISI_SAS_SGE_PAGE_CNT) {
 378                 dev_err(dev, "task prep: n_elem(%d) > HISI_SAS_SGE_PAGE_CNT",
 379                         n_elem);
 380                 rc = -EINVAL;
 381                 goto err_out_dma_unmap;
 382         }
 383
 384         spin_lock_irqsave(&hisi_hba->lock, flags);
 385         if (hisi_hba->hw->slot_index_alloc)
 386                 rc = hisi_hba->hw->slot_index_alloc(hisi_hba, &slot_idx,
 387                                                     device);
 388         else
 389                 rc = hisi_sas_slot_index_alloc(hisi_hba, &slot_idx);
 390         spin_unlock_irqrestore(&hisi_hba->lock, flags);
 391         if (rc)
 392                 goto err_out_dma_unmap;
 393
 394         slot = &hisi_hba->slot_info[slot_idx];
 395
 396         spin_lock_irqsave(&dq->lock, flags);
 397         wr_q_index = hisi_hba->hw->get_free_slot(hisi_hba, dq);
 398         if (wr_q_index < 0) {
 399                 spin_unlock_irqrestore(&dq->lock, flags);
 400                 rc = -EAGAIN;
 401                 goto err_out_tag;
 402         }
 403
 404         list_add_tail(&slot->delivery, &dq->list);
 405         list_add_tail(&slot->entry, &sas_dev->list);
 406         spin_unlock_irqrestore(&dq->lock, flags);
 407
 408         dlvry_queue = dq->id;
 409         dlvry_queue_slot = wr_q_index;
 410
 411         slot->n_elem = n_elem;
 412         slot->dlvry_queue = dlvry_queue;
 413         slot->dlvry_queue_slot = dlvry_queue_slot;
 414         cmd_hdr_base = hisi_hba->cmd_hdr[dlvry_queue];
 415         slot->cmd_hdr = &cmd_hdr_base[dlvry_queue_slot];
 416         slot->task = task;
 417         slot->port = port;
 418         slot->tmf = tmf;
 419         slot->is_internal = is_tmf;
 420         task->lldd_task = slot;
 421
 422         memset(slot->cmd_hdr, 0, sizeof(struct hisi_sas_cmd_hdr));
 423         memset(hisi_sas_cmd_hdr_addr_mem(slot), 0, HISI_SAS_COMMAND_TABLE_SZ);
 424         memset(hisi_sas_status_buf_addr_mem(slot), 0, HISI_SAS_STATUS_BUF_SZ);
 425
 426         switch (task->task_proto) {
 427         case SAS_PROTOCOL_SMP:
 428                 hisi_sas_task_prep_smp(hisi_hba, slot);
 429                 break;
 430         case SAS_PROTOCOL_SSP:
 431                 hisi_sas_task_prep_ssp(hisi_hba, slot);
 432                 break;
 433         case SAS_PROTOCOL_SATA:
 434         case SAS_PROTOCOL_STP:
 435         case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
 436                 hisi_sas_task_prep_ata(hisi_hba, slot);
 437                 break;
 438         default:
 439                 dev_err(dev, "task prep: unknown/unsupported proto (0x%x)\n",
 440                         task->task_proto);
 441                 break;
 442         }
 443
 444         spin_lock_irqsave(&task->task_state_lock, flags);
 445         task->task_state_flags |= SAS_TASK_AT_INITIATOR;
 446         spin_unlock_irqrestore(&task->task_state_lock, flags);
 447
 448         ++(*pass);
 449         WRITE_ONCE(slot->ready, 1);
 450
 451         return 0;
 452
 453 err_out_tag:
 454         spin_lock_irqsave(&hisi_hba->lock, flags);
 455         hisi_sas_slot_index_free(hisi_hba, slot_idx);
 456         spin_unlock_irqrestore(&hisi_hba->lock, flags);
 457 err_out_dma_unmap:
 458         if (!sas_protocol_ata(task->task_proto)) {
 459                 if (task->num_scatter) {
 460                         dma_unmap_sg(dev, task->scatter, task->num_scatter,
 461                              task->data_dir);
 462                 } else if (task->task_proto & SAS_PROTOCOL_SMP) {
 463                         if (n_elem_req)
 464                                 dma_unmap_sg(dev, &task->smp_task.smp_req,
 465                                              1, DMA_TO_DEVICE);
 466                         if (n_elem_resp)
 467                                 dma_unmap_sg(dev, &task->smp_task.smp_resp,
 468                                              1, DMA_FROM_DEVICE);
 469                 }
 470         }
 471 prep_out:
 472         dev_err(dev, "task prep: failed[%d]!\n", rc);
 473         return rc;
 474 }
 475
 476 static int hisi_sas_task_exec(struct sas_task *task, gfp_t gfp_flags,
 477                               bool is_tmf, struct hisi_sas_tmf_task *tmf)
 478 {
 479         u32 rc;
 480         u32 pass = 0;
 481         unsigned long flags;
 482         struct hisi_hba *hisi_hba = dev_to_hisi_hba(task->dev);
 483         struct device *dev = hisi_hba->dev;
 484         struct hisi_sas_dq *dq = NULL;
 485
 486         if (unlikely(test_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags))) {
 487                 if (in_softirq())
 488                         return -EINVAL;
 489
 490                 down(&hisi_hba->sem);
 491                 up(&hisi_hba->sem);
 492         }
 493
 494         /* protect task_prep and start_delivery sequence */
 495         rc = hisi_sas_task_prep(task, &dq, is_tmf, tmf, &pass);
 496         if (rc)
 497                 dev_err(dev, "task exec: failed[%d]!\n", rc);
 498
 499         if (likely(pass)) {
 500                 spin_lock_irqsave(&dq->lock, flags);
 501                 hisi_hba->hw->start_delivery(dq);
 502                 spin_unlock_irqrestore(&dq->lock, flags);
 503         }
 504
 505         return rc;
 506 }
 507
 508 static void hisi_sas_bytes_dmaed(struct hisi_hba *hisi_hba, int phy_no)
 509 {
 510         struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
 511         struct asd_sas_phy *sas_phy = &phy->sas_phy;
 512         struct sas_ha_struct *sas_ha;
 513
 514         if (!phy->phy_attached)
 515                 return;
 516
 517         sas_ha = &hisi_hba->sha;
 518         sas_ha->notify_phy_event(sas_phy, PHYE_OOB_DONE);
 519
 520         if (sas_phy->phy) {
 521                 struct sas_phy *sphy = sas_phy->phy;
 522
 523                 sphy->negotiated_linkrate = sas_phy->linkrate;
 524                 sphy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
 525                 sphy->maximum_linkrate_hw =
 526                         hisi_hba->hw->phy_get_max_linkrate();
 527                 if (sphy->minimum_linkrate == SAS_LINK_RATE_UNKNOWN)
 528                         sphy->minimum_linkrate = phy->minimum_linkrate;
 529
 530                 if (sphy->maximum_linkrate == SAS_LINK_RATE_UNKNOWN)
 531                         sphy->maximum_linkrate = phy->maximum_linkrate;
 532         }
 533
 534         if (phy->phy_type & PORT_TYPE_SAS) {
 535                 struct sas_identify_frame *id;
 536
 537                 id = (struct sas_identify_frame *)phy->frame_rcvd;
 538                 id->dev_type = phy->identify.device_type;
 539                 id->initiator_bits = SAS_PROTOCOL_ALL;
 540                 id->target_bits = phy->identify.target_port_protocols;
 541         } else if (phy->phy_type & PORT_TYPE_SATA) {
 542                 /*Nothing*/
 543         }
 544
 545         sas_phy->frame_rcvd_size = phy->frame_rcvd_size;
 546         sas_ha->notify_port_event(sas_phy, PORTE_BYTES_DMAED);
 547 }
 548
 549 static struct hisi_sas_device *hisi_sas_alloc_dev(struct domain_device *device)
 550 {
 551         struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
 552         struct hisi_sas_device *sas_dev = NULL;
 553         unsigned long flags;
 554         int last = hisi_hba->last_dev_id;
 555         int first = (hisi_hba->last_dev_id + 1) % HISI_SAS_MAX_DEVICES;
 556         int i;
 557
 558         spin_lock_irqsave(&hisi_hba->lock, flags);
 559         for (i = first; i != last; i %= HISI_SAS_MAX_DEVICES) {
 560                 if (hisi_hba->devices[i].dev_type == SAS_PHY_UNUSED) {
 561                         int queue = i % hisi_hba->queue_count;
 562                         struct hisi_sas_dq *dq = &hisi_hba->dq[queue];
 563
 564                         hisi_hba->devices[i].device_id = i;
 565                         sas_dev = &hisi_hba->devices[i];
 566                         sas_dev->dev_status = HISI_SAS_DEV_NORMAL;
 567                         sas_dev->dev_type = device->dev_type;
 568                         sas_dev->hisi_hba = hisi_hba;
 569                         sas_dev->sas_device = device;
 570                         sas_dev->dq = dq;
 571                         INIT_LIST_HEAD(&hisi_hba->devices[i].list);
 572                         break;
 573                 }
 574                 i++;
 575         }
 576         hisi_hba->last_dev_id = i;
 577         spin_unlock_irqrestore(&hisi_hba->lock, flags);
 578
 579         return sas_dev;
 580 }
 581
 582 #define HISI_SAS_SRST_ATA_DISK_CNT 3
 583 static int hisi_sas_init_device(struct domain_device *device)
 584 {
 585         int rc = TMF_RESP_FUNC_COMPLETE;
 586         struct scsi_lun lun;
 587         struct hisi_sas_tmf_task tmf_task;
 588         int retry = HISI_SAS_SRST_ATA_DISK_CNT;
 589         struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
 590
 591         switch (device->dev_type) {
 592         case SAS_END_DEVICE:
 593                 int_to_scsilun(0, &lun);
 594
 595                 tmf_task.tmf = TMF_CLEAR_TASK_SET;
 596                 rc = hisi_sas_debug_issue_ssp_tmf(device, lun.scsi_lun,
 597                                                   &tmf_task);
 598                 if (rc == TMF_RESP_FUNC_COMPLETE)
 599                         hisi_sas_release_task(hisi_hba, device);
 600                 break;
 601         case SAS_SATA_DEV:
 602         case SAS_SATA_PM:
 603         case SAS_SATA_PM_PORT:
 604         case SAS_SATA_PENDING:
 605                 while (retry-- > 0) {
 606                         rc = hisi_sas_softreset_ata_disk(device);
 607                         if (!rc)
 608                                 break;
 609                 }
 610                 break;
 611         default:
 612                 break;
 613         }
 614
 615         return rc;
 616 }
 617
 618 static int hisi_sas_dev_found(struct domain_device *device)
 619 {
 620         struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
 621         struct domain_device *parent_dev = device->parent;
 622         struct hisi_sas_device *sas_dev;
 623         struct device *dev = hisi_hba->dev;
 624         int rc;
 625
 626         if (hisi_hba->hw->alloc_dev)
 627                 sas_dev = hisi_hba->hw->alloc_dev(device);
 628         else
 629                 sas_dev = hisi_sas_alloc_dev(device);
 630         if (!sas_dev) {
 631                 dev_err(dev, "fail alloc dev: max support %d devices\n",
 632                         HISI_SAS_MAX_DEVICES);
 633                 return -EINVAL;
 634         }
 635
 636         device->lldd_dev = sas_dev;
 637         hisi_hba->hw->setup_itct(hisi_hba, sas_dev);
 638
 639         if (parent_dev && DEV_IS_EXPANDER(parent_dev->dev_type)) {
 640                 int phy_no;
 641                 u8 phy_num = parent_dev->ex_dev.num_phys;
 642                 struct ex_phy *phy;
 643
 644                 for (phy_no = 0; phy_no < phy_num; phy_no++) {
 645                         phy = &parent_dev->ex_dev.ex_phy[phy_no];
 646                         if (SAS_ADDR(phy->attached_sas_addr) ==
 647                                 SAS_ADDR(device->sas_addr))
 648                                 break;
 649                 }
 650
 651                 if (phy_no == phy_num) {
 652                         dev_info(dev, "dev found: no attached "
 653                                  "dev:%016llx at ex:%016llx\n",
 654                                  SAS_ADDR(device->sas_addr),
 655                                  SAS_ADDR(parent_dev->sas_addr));
 656                         rc = -EINVAL;
 657                         goto err_out;
 658                 }
 659         }
 660
 661         dev_info(dev, "dev[%d:%x] found\n",
 662                 sas_dev->device_id, sas_dev->dev_type);
 663
 664         rc = hisi_sas_init_device(device);
 665         if (rc)
 666                 goto err_out;
 667         return 0;
 668
 669 err_out:
 670         hisi_sas_dev_gone(device);
 671         return rc;
 672 }
 673
 674 int hisi_sas_slave_configure(struct scsi_device *sdev)
 675 {
 676         struct domain_device *dev = sdev_to_domain_dev(sdev);
 677         int ret = sas_slave_configure(sdev);
 678
 679         if (ret)
 680                 return ret;
 681         if (!dev_is_sata(dev))
 682                 sas_change_queue_depth(sdev, 64);
 683
 684         return 0;
 685 }
 686 EXPORT_SYMBOL_GPL(hisi_sas_slave_configure);
 687
 688 void hisi_sas_scan_start(struct Scsi_Host *shost)
 689 {
 690         struct hisi_hba *hisi_hba = shost_priv(shost);
 691
 692         hisi_hba->hw->phys_init(hisi_hba);
 693 }
 694 EXPORT_SYMBOL_GPL(hisi_sas_scan_start);
 695
 696 int hisi_sas_scan_finished(struct Scsi_Host *shost, unsigned long time)
 697 {
 698         struct hisi_hba *hisi_hba = shost_priv(shost);
 699         struct sas_ha_struct *sha = &hisi_hba->sha;
 700
 701         /* Wait for PHY up interrupt to occur */
 702         if (time < HZ)
 703                 return 0;
 704
 705         sas_drain_work(sha);
 706         return 1;
 707 }
 708 EXPORT_SYMBOL_GPL(hisi_sas_scan_finished);
 709
 710 static void hisi_sas_phyup_work(struct work_struct *work)
 711 {
 712         struct hisi_sas_phy *phy =
 713                 container_of(work, typeof(*phy), works[HISI_PHYE_PHY_UP]);
 714         struct hisi_hba *hisi_hba = phy->hisi_hba;
 715         struct asd_sas_phy *sas_phy = &phy->sas_phy;
 716         int phy_no = sas_phy->id;
 717
 718         hisi_hba->hw->sl_notify(hisi_hba, phy_no); /* This requires a sleep */
 719         hisi_sas_bytes_dmaed(hisi_hba, phy_no);
 720 }
 721
 722 static void hisi_sas_linkreset_work(struct work_struct *work)
 723 {
 724         struct hisi_sas_phy *phy =
 725                 container_of(work, typeof(*phy), works[HISI_PHYE_LINK_RESET]);
 726         struct asd_sas_phy *sas_phy = &phy->sas_phy;
 727
 728         hisi_sas_control_phy(sas_phy, PHY_FUNC_LINK_RESET, NULL);
 729 }
 730
 731 static const work_func_t hisi_sas_phye_fns[HISI_PHYES_NUM] = {
 732         [HISI_PHYE_PHY_UP] = hisi_sas_phyup_work,
 733         [HISI_PHYE_LINK_RESET] = hisi_sas_linkreset_work,
 734 };
 735
 736 bool hisi_sas_notify_phy_event(struct hisi_sas_phy *phy,
 737                                 enum hisi_sas_phy_event event)
 738 {
 739         struct hisi_hba *hisi_hba = phy->hisi_hba;
 740
 741         if (WARN_ON(event >= HISI_PHYES_NUM))
 742                 return false;
 743
 744         return queue_work(hisi_hba->wq, &phy->works[event]);
 745 }
 746 EXPORT_SYMBOL_GPL(hisi_sas_notify_phy_event);
 747
 748 static void hisi_sas_phy_init(struct hisi_hba *hisi_hba, int phy_no)
 749 {
 750         struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
 751         struct asd_sas_phy *sas_phy = &phy->sas_phy;
 752         int i;
 753
 754         phy->hisi_hba = hisi_hba;
 755         phy->port = NULL;
 756         phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
 757         phy->maximum_linkrate = hisi_hba->hw->phy_get_max_linkrate();
 758         sas_phy->enabled = (phy_no < hisi_hba->n_phy) ? 1 : 0;
 759         sas_phy->class = SAS;
 760         sas_phy->iproto = SAS_PROTOCOL_ALL;
 761         sas_phy->tproto = 0;
 762         sas_phy->type = PHY_TYPE_PHYSICAL;
 763         sas_phy->role = PHY_ROLE_INITIATOR;
 764         sas_phy->oob_mode = OOB_NOT_CONNECTED;
 765         sas_phy->linkrate = SAS_LINK_RATE_UNKNOWN;
 766         sas_phy->id = phy_no;
 767         sas_phy->sas_addr = &hisi_hba->sas_addr[0];
 768         sas_phy->frame_rcvd = &phy->frame_rcvd[0];
 769         sas_phy->ha = (struct sas_ha_struct *)hisi_hba->shost->hostdata;
 770         sas_phy->lldd_phy = phy;
 771
 772         for (i = 0; i < HISI_PHYES_NUM; i++)
 773                 INIT_WORK(&phy->works[i], hisi_sas_phye_fns[i]);
 774
 775         spin_lock_init(&phy->lock);
 776 }
 777
 778 static void hisi_sas_port_notify_formed(struct asd_sas_phy *sas_phy)
 779 {
 780         struct sas_ha_struct *sas_ha = sas_phy->ha;
 781         struct hisi_hba *hisi_hba = sas_ha->lldd_ha;
 782         struct hisi_sas_phy *phy = sas_phy->lldd_phy;
 783         struct asd_sas_port *sas_port = sas_phy->port;
 784         struct hisi_sas_port *port = to_hisi_sas_port(sas_port);
 785         unsigned long flags;
 786
 787         if (!sas_port)
 788                 return;
 789
 790         spin_lock_irqsave(&hisi_hba->lock, flags);
 791         port->port_attached = 1;
 792         port->id = phy->port_id;
 793         phy->port = port;
 794         sas_port->lldd_port = port;
 795         spin_unlock_irqrestore(&hisi_hba->lock, flags);
 796 }
 797
 798 static void hisi_sas_do_release_task(struct hisi_hba *hisi_hba, struct sas_task *task,
 799                                      struct hisi_sas_slot *slot)
 800 {
 801         if (task) {
 802                 unsigned long flags;
 803                 struct task_status_struct *ts;
 804
 805                 ts = &task->task_status;
 806
 807                 ts->resp = SAS_TASK_COMPLETE;
 808                 ts->stat = SAS_ABORTED_TASK;
 809                 spin_lock_irqsave(&task->task_state_lock, flags);
 810                 task->task_state_flags &=
 811                         ~(SAS_TASK_STATE_PENDING | SAS_TASK_AT_INITIATOR);
 812                 task->task_state_flags |= SAS_TASK_STATE_DONE;
 813                 spin_unlock_irqrestore(&task->task_state_lock, flags);
 814         }
 815
 816         hisi_sas_slot_task_free(hisi_hba, task, slot);
 817 }
 818
 819 static void hisi_sas_release_task(struct hisi_hba *hisi_hba,
 820                         struct domain_device *device)
 821 {
 822         struct hisi_sas_slot *slot, *slot2;
 823         struct hisi_sas_device *sas_dev = device->lldd_dev;
 824
 825         list_for_each_entry_safe(slot, slot2, &sas_dev->list, entry)
 826                 hisi_sas_do_release_task(hisi_hba, slot->task, slot);
 827 }
 828
 829 void hisi_sas_release_tasks(struct hisi_hba *hisi_hba)
 830 {
 831         struct hisi_sas_device *sas_dev;
 832         struct domain_device *device;
 833         int i;
 834
 835         for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
 836                 sas_dev = &hisi_hba->devices[i];
 837                 device = sas_dev->sas_device;
 838
 839                 if ((sas_dev->dev_type == SAS_PHY_UNUSED) ||
 840                     !device)
 841                         continue;
 842
 843                 hisi_sas_release_task(hisi_hba, device);
 844         }
 845 }
 846 EXPORT_SYMBOL_GPL(hisi_sas_release_tasks);
 847
 848 static void hisi_sas_dereg_device(struct hisi_hba *hisi_hba,
 849                                 struct domain_device *device)
 850 {
 851         if (hisi_hba->hw->dereg_device)
 852                 hisi_hba->hw->dereg_device(hisi_hba, device);
 853 }
 854
 855 static void hisi_sas_dev_gone(struct domain_device *device)
 856 {
 857         struct hisi_sas_device *sas_dev = device->lldd_dev;
 858         struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
 859         struct device *dev = hisi_hba->dev;
 860
 861         dev_info(dev, "dev[%d:%x] is gone\n",
 862                  sas_dev->device_id, sas_dev->dev_type);
 863
 864         if (!test_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags)) {
 865                 hisi_sas_internal_task_abort(hisi_hba, device,
 866                                      HISI_SAS_INT_ABT_DEV, 0);
 867
 868                 hisi_sas_dereg_device(hisi_hba, device);
 869
 870                 down(&hisi_hba->sem);
 871                 hisi_hba->hw->clear_itct(hisi_hba, sas_dev);
 872                 up(&hisi_hba->sem);
 873                 device->lldd_dev = NULL;
 874         }
 875
 876         if (hisi_hba->hw->free_device)
 877                 hisi_hba->hw->free_device(sas_dev);
 878         sas_dev->dev_type = SAS_PHY_UNUSED;
 879 }
 880
 881 static int hisi_sas_queue_command(struct sas_task *task, gfp_t gfp_flags)
 882 {
 883         return hisi_sas_task_exec(task, gfp_flags, 0, NULL);
 884 }
 885
 886 static void hisi_sas_phy_set_linkrate(struct hisi_hba *hisi_hba, int phy_no,
 887                         struct sas_phy_linkrates *r)
 888 {
 889         struct sas_phy_linkrates _r;
 890
 891         struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
 892         struct asd_sas_phy *sas_phy = &phy->sas_phy;
 893         enum sas_linkrate min, max;
 894
 895         if (r->maximum_linkrate == SAS_LINK_RATE_UNKNOWN) {
 896                 max = sas_phy->phy->maximum_linkrate;
 897                 min = r->minimum_linkrate;
 898         } else if (r->minimum_linkrate == SAS_LINK_RATE_UNKNOWN) {
 899                 max = r->maximum_linkrate;
 900                 min = sas_phy->phy->minimum_linkrate;
 901         } else
 902                 return;
 903
 904         _r.maximum_linkrate = max;
 905         _r.minimum_linkrate = min;
 906
 907         hisi_hba->hw->phy_disable(hisi_hba, phy_no);
 908         msleep(100);
 909         hisi_hba->hw->phy_set_linkrate(hisi_hba, phy_no, &_r);
 910         hisi_hba->hw->phy_start(hisi_hba, phy_no);
 911 }
 912
 913 static int hisi_sas_control_phy(struct asd_sas_phy *sas_phy, enum phy_func func,
 914                                 void *funcdata)
 915 {
 916         struct sas_ha_struct *sas_ha = sas_phy->ha;
 917         struct hisi_hba *hisi_hba = sas_ha->lldd_ha;
 918         int phy_no = sas_phy->id;
 919
 920         switch (func) {
 921         case PHY_FUNC_HARD_RESET:
 922                 hisi_hba->hw->phy_hard_reset(hisi_hba, phy_no);
 923                 break;
 924
 925         case PHY_FUNC_LINK_RESET:
 926                 hisi_hba->hw->phy_disable(hisi_hba, phy_no);
 927                 msleep(100);
 928                 hisi_hba->hw->phy_start(hisi_hba, phy_no);
 929                 break;
 930
 931         case PHY_FUNC_DISABLE:
 932                 hisi_hba->hw->phy_disable(hisi_hba, phy_no);
 933                 break;
 934
 935         case PHY_FUNC_SET_LINK_RATE:
 936                 hisi_sas_phy_set_linkrate(hisi_hba, phy_no, funcdata);
 937                 break;
 938         case PHY_FUNC_GET_EVENTS:
 939                 if (hisi_hba->hw->get_events) {
 940                         hisi_hba->hw->get_events(hisi_hba, phy_no);
 941                         break;
 942                 }
 943                 /* fallthru */
 944         case PHY_FUNC_RELEASE_SPINUP_HOLD:
 945         default:
 946                 return -EOPNOTSUPP;
 947         }
 948         return 0;
 949 }
 950
 951 static void hisi_sas_task_done(struct sas_task *task)
 952 {
 953         if (!del_timer(&task->slow_task->timer))
 954                 return;
 955         complete(&task->slow_task->completion);
 956 }
 957
 958 static void hisi_sas_tmf_timedout(struct timer_list *t)
 959 {
 960         struct sas_task_slow *slow = from_timer(slow, t, timer);
 961         struct sas_task *task = slow->task;
 962         unsigned long flags;
 963
 964         spin_lock_irqsave(&task->task_state_lock, flags);
 965         if (!(task->task_state_flags & SAS_TASK_STATE_DONE))
 966                 task->task_state_flags |= SAS_TASK_STATE_ABORTED;
 967         spin_unlock_irqrestore(&task->task_state_lock, flags);
 968
 969         complete(&task->slow_task->completion);
 970 }
 971
 972 #define TASK_TIMEOUT 20
 973 #define TASK_RETRY 3
 974 #define INTERNAL_ABORT_TIMEOUT 6
 975 static int hisi_sas_exec_internal_tmf_task(struct domain_device *device,
 976                                            void *parameter, u32 para_len,
 977                                            struct hisi_sas_tmf_task *tmf)
 978 {
 979         struct hisi_sas_device *sas_dev = device->lldd_dev;
 980         struct hisi_hba *hisi_hba = sas_dev->hisi_hba;
 981         struct device *dev = hisi_hba->dev;
 982         struct sas_task *task;
 983         int res, retry;
 984
 985         for (retry = 0; retry < TASK_RETRY; retry++) {
 986                 task = sas_alloc_slow_task(GFP_KERNEL);
 987                 if (!task)
 988                         return -ENOMEM;
 989
 990                 task->dev = device;
 991                 task->task_proto = device->tproto;
 992
 993                 if (dev_is_sata(device)) {
 994                         task->ata_task.device_control_reg_update = 1;
 995                         memcpy(&task->ata_task.fis, parameter, para_len);
 996                 } else {
 997                         memcpy(&task->ssp_task, parameter, para_len);
 998                 }
 999                 task->task_done = hisi_sas_task_done;
1000
1001                 task->slow_task->timer.function = hisi_sas_tmf_timedout;
1002                 task->slow_task->timer.expires = jiffies + TASK_TIMEOUT*HZ;
1003                 add_timer(&task->slow_task->timer);
1004
1005                 res = hisi_sas_task_exec(task, GFP_KERNEL, 1, tmf);
1006
1007                 if (res) {
1008                         del_timer(&task->slow_task->timer);
1009                         dev_err(dev, "abort tmf: executing internal task failed: %d\n",
1010                                 res);
1011                         goto ex_err;
1012                 }
1013
1014                 wait_for_completion(&task->slow_task->completion);
1015                 res = TMF_RESP_FUNC_FAILED;
1016                 /* Even TMF timed out, return direct. */
1017                 if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
1018                         if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
1019                                 struct hisi_sas_slot *slot = task->lldd_task;
1020
1021                                 dev_err(dev, "abort tmf: TMF task timeout and not done\n");
1022                                 if (slot)
1023                                         slot->task = NULL;
1024
1025                                 goto ex_err;
1026                         } else
1027                                 dev_err(dev, "abort tmf: TMF task timeout\n");
1028                 }
1029
1030                 if (task->task_status.resp == SAS_TASK_COMPLETE &&
1031                      task->task_status.stat == TMF_RESP_FUNC_COMPLETE) {
1032                         res = TMF_RESP_FUNC_COMPLETE;
1033                         break;
1034                 }
1035
1036                 if (task->task_status.resp == SAS_TASK_COMPLETE &&
1037                         task->task_status.stat == TMF_RESP_FUNC_SUCC) {
1038                         res = TMF_RESP_FUNC_SUCC;
1039                         break;
1040                 }
1041
1042                 if (task->task_status.resp == SAS_TASK_COMPLETE &&
1043                       task->task_status.stat == SAS_DATA_UNDERRUN) {
1044                         /* no error, but return the number of bytes of
1045                          * underrun
1046                          */
1047                         dev_warn(dev, "abort tmf: task to dev %016llx "
1048                                  "resp: 0x%x sts 0x%x underrun\n",
1049                                  SAS_ADDR(device->sas_addr),
1050                                  task->task_status.resp,
1051                                  task->task_status.stat);
1052                         res = task->task_status.residual;
1053                         break;
1054                 }
1055
1056                 if (task->task_status.resp == SAS_TASK_COMPLETE &&
1057                         task->task_status.stat == SAS_DATA_OVERRUN) {
1058                         dev_warn(dev, "abort tmf: blocked task error\n");
1059                         res = -EMSGSIZE;
1060                         break;
1061                 }
1062
1063                 dev_warn(dev, "abort tmf: task to dev "
1064                          "%016llx resp: 0x%x status 0x%x\n",
1065                          SAS_ADDR(device->sas_addr), task->task_status.resp,
1066                          task->task_status.stat);
1067                 sas_free_task(task);
1068                 task = NULL;
1069         }
1070 ex_err:
1071         if (retry == TASK_RETRY)
1072                 dev_warn(dev, "abort tmf: executing internal task failed!\n");
1073         sas_free_task(task);
1074         return res;
1075 }
1076
1077 static void hisi_sas_fill_ata_reset_cmd(struct ata_device *dev,
1078                 bool reset, int pmp, u8 *fis)
1079 {
1080         struct ata_taskfile tf;
1081
1082         ata_tf_init(dev, &tf);
1083         if (reset)
1084                 tf.ctl |= ATA_SRST;
1085         else
1086                 tf.ctl &= ~ATA_SRST;
1087         tf.command = ATA_CMD_DEV_RESET;
1088         ata_tf_to_fis(&tf, pmp, 0, fis);
1089 }
1090
1091 static int hisi_sas_softreset_ata_disk(struct domain_device *device)
1092 {
1093         u8 fis[20] = {0};
1094         struct ata_port *ap = device->sata_dev.ap;
1095         struct ata_link *link;
1096         int rc = TMF_RESP_FUNC_FAILED;
1097         struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
1098         struct device *dev = hisi_hba->dev;
1099         int s = sizeof(struct host_to_dev_fis);
1100
1101         ata_for_each_link(link, ap, EDGE) {
1102                 int pmp = sata_srst_pmp(link);
1103
1104                 hisi_sas_fill_ata_reset_cmd(link->device, 1, pmp, fis);
1105                 rc = hisi_sas_exec_internal_tmf_task(device, fis, s, NULL);
1106                 if (rc != TMF_RESP_FUNC_COMPLETE)
1107                         break;
1108         }
1109
1110         if (rc == TMF_RESP_FUNC_COMPLETE) {
1111                 ata_for_each_link(link, ap, EDGE) {
1112                         int pmp = sata_srst_pmp(link);
1113
1114                         hisi_sas_fill_ata_reset_cmd(link->device, 0, pmp, fis);
1115                         rc = hisi_sas_exec_internal_tmf_task(device, fis,
1116                                                              s, NULL);
1117                         if (rc != TMF_RESP_FUNC_COMPLETE)
1118                                 dev_err(dev, "ata disk de-reset failed\n");
1119                 }
1120         } else {
1121                 dev_err(dev, "ata disk reset failed\n");
1122         }
1123
1124         if (rc == TMF_RESP_FUNC_COMPLETE)
1125                 hisi_sas_release_task(hisi_hba, device);
1126
1127         return rc;
1128 }
1129
1130 static int hisi_sas_debug_issue_ssp_tmf(struct domain_device *device,
1131                                 u8 *lun, struct hisi_sas_tmf_task *tmf)
1132 {
1133         struct sas_ssp_task ssp_task;
1134
1135         if (!(device->tproto & SAS_PROTOCOL_SSP))
1136                 return TMF_RESP_FUNC_ESUPP;
1137
1138         memcpy(ssp_task.LUN, lun, 8);
1139
1140         return hisi_sas_exec_internal_tmf_task(device, &ssp_task,
1141                                 sizeof(ssp_task), tmf);
1142 }
1143
1144 static void hisi_sas_refresh_port_id(struct hisi_hba *hisi_hba)
1145 {
1146         u32 state = hisi_hba->hw->get_phys_state(hisi_hba);
1147         int i;
1148
1149         for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
1150                 struct hisi_sas_device *sas_dev = &hisi_hba->devices[i];
1151                 struct domain_device *device = sas_dev->sas_device;
1152                 struct asd_sas_port *sas_port;
1153                 struct hisi_sas_port *port;
1154                 struct hisi_sas_phy *phy = NULL;
1155                 struct asd_sas_phy *sas_phy;
1156
1157                 if ((sas_dev->dev_type == SAS_PHY_UNUSED)
1158                                 || !device || !device->port)
1159                         continue;
1160
1161                 sas_port = device->port;
1162                 port = to_hisi_sas_port(sas_port);
1163
1164                 list_for_each_entry(sas_phy, &sas_port->phy_list, port_phy_el)
1165                         if (state & BIT(sas_phy->id)) {
1166                                 phy = sas_phy->lldd_phy;
1167                                 break;
1168                         }
1169
1170                 if (phy) {
1171                         port->id = phy->port_id;
1172
1173                         /* Update linkrate of directly attached device. */
1174                         if (!device->parent)
1175                                 device->linkrate = phy->sas_phy.linkrate;
1176
1177                         hisi_hba->hw->setup_itct(hisi_hba, sas_dev);
1178                 } else
1179                         port->id = 0xff;
1180         }
1181 }
1182
1183 static void hisi_sas_rescan_topology(struct hisi_hba *hisi_hba, u32 old_state,
1184                               u32 state)
1185 {
1186         struct sas_ha_struct *sas_ha = &hisi_hba->sha;
1187         struct asd_sas_port *_sas_port = NULL;
1188         int phy_no;
1189
1190         for (phy_no = 0; phy_no < hisi_hba->n_phy; phy_no++) {
1191                 struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
1192                 struct asd_sas_phy *sas_phy = &phy->sas_phy;
1193                 struct asd_sas_port *sas_port = sas_phy->port;
1194                 bool do_port_check = !!(_sas_port != sas_port);
1195
1196                 if (!sas_phy->phy->enabled)
1197                         continue;
1198
1199                 /* Report PHY state change to libsas */
1200                 if (state & BIT(phy_no)) {
1201                         if (do_port_check && sas_port && sas_port->port_dev) {
1202                                 struct domain_device *dev = sas_port->port_dev;
1203
1204                                 _sas_port = sas_port;
1205
1206                                 if (DEV_IS_EXPANDER(dev->dev_type))
1207                                         sas_ha->notify_port_event(sas_phy,
1208                                                         PORTE_BROADCAST_RCVD);
1209                         }
1210                 } else if (old_state & (1 << phy_no))
1211                         /* PHY down but was up before */
1212                         hisi_sas_phy_down(hisi_hba, phy_no, 0);
1213
1214         }
1215 }
1216
1217 static void hisi_sas_reset_init_all_devices(struct hisi_hba *hisi_hba)
1218 {
1219         struct hisi_sas_device *sas_dev;
1220         struct domain_device *device;
1221         int i;
1222
1223         for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
1224                 sas_dev = &hisi_hba->devices[i];
1225                 device = sas_dev->sas_device;
1226
1227                 if ((sas_dev->dev_type == SAS_PHY_UNUSED) || !device)
1228                         continue;
1229
1230                 hisi_sas_init_device(device);
1231         }
1232 }
1233
1234 static void hisi_sas_send_ata_reset_each_phy(struct hisi_hba *hisi_hba,
1235                                              struct asd_sas_port *sas_port,
1236                                              struct domain_device *device)
1237 {
1238         struct hisi_sas_tmf_task tmf_task = { .force_phy = 1 };
1239         struct ata_port *ap = device->sata_dev.ap;
1240         struct device *dev = hisi_hba->dev;
1241         int s = sizeof(struct host_to_dev_fis);
1242         int rc = TMF_RESP_FUNC_FAILED;
1243         struct asd_sas_phy *sas_phy;
1244         struct ata_link *link;
1245         u8 fis[20] = {0};
1246         u32 state;
1247
1248         state = hisi_hba->hw->get_phys_state(hisi_hba);
1249         list_for_each_entry(sas_phy, &sas_port->phy_list, port_phy_el) {
1250                 if (!(state & BIT(sas_phy->id)))
1251                         continue;
1252
1253                 ata_for_each_link(link, ap, EDGE) {
1254                         int pmp = sata_srst_pmp(link);
1255
1256                         tmf_task.phy_id = sas_phy->id;
1257                         hisi_sas_fill_ata_reset_cmd(link->device, 1, pmp, fis);
1258                         rc = hisi_sas_exec_internal_tmf_task(device, fis, s,
1259                                                              &tmf_task);
1260                         if (rc != TMF_RESP_FUNC_COMPLETE) {
1261                                 dev_err(dev, "phy%d ata reset failed rc=%d\n",
1262                                         sas_phy->id, rc);
1263                                 break;
1264                         }
1265                 }
1266         }
1267 }
1268
1269 static void hisi_sas_terminate_stp_reject(struct hisi_hba *hisi_hba)
1270 {
1271         struct device *dev = hisi_hba->dev;
1272         int port_no, rc, i;
1273
1274         for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
1275                 struct hisi_sas_device *sas_dev = &hisi_hba->devices[i];
1276                 struct domain_device *device = sas_dev->sas_device;
1277
1278                 if ((sas_dev->dev_type == SAS_PHY_UNUSED) || !device)
1279                         continue;
1280
1281                 rc = hisi_sas_internal_task_abort(hisi_hba, device,
1282                                                   HISI_SAS_INT_ABT_DEV, 0);
1283                 if (rc < 0)
1284                         dev_err(dev, "STP reject: abort dev failed %d\n", rc);
1285         }
1286
1287         for (port_no = 0; port_no < hisi_hba->n_phy; port_no++) {
1288                 struct hisi_sas_port *port = &hisi_hba->port[port_no];
1289                 struct asd_sas_port *sas_port = &port->sas_port;
1290                 struct domain_device *port_dev = sas_port->port_dev;
1291                 struct domain_device *device;
1292
1293                 if (!port_dev || !DEV_IS_EXPANDER(port_dev->dev_type))
1294                         continue;
1295
1296                 /* Try to find a SATA device */
1297                 list_for_each_entry(device, &sas_port->dev_list,
1298                                     dev_list_node) {
1299                         if (dev_is_sata(device)) {
1300                                 hisi_sas_send_ata_reset_each_phy(hisi_hba,
1301                                                                  sas_port,
1302                                                                  device);
1303                                 break;
1304                         }
1305                 }
1306         }
1307 }
1308
1309 void hisi_sas_controller_reset_prepare(struct hisi_hba *hisi_hba)
1310 {
1311         struct Scsi_Host *shost = hisi_hba->shost;
1312
1313         down(&hisi_hba->sem);
1314         hisi_hba->phy_state = hisi_hba->hw->get_phys_state(hisi_hba);
1315
1316         scsi_block_requests(shost);
1317         hisi_hba->hw->wait_cmds_complete_timeout(hisi_hba, 100, 5000);
1318
1319         if (timer_pending(&hisi_hba->timer))
1320                 del_timer_sync(&hisi_hba->timer);
1321
1322         set_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags);
1323 }
1324 EXPORT_SYMBOL_GPL(hisi_sas_controller_reset_prepare);
1325
1326 void hisi_sas_controller_reset_done(struct hisi_hba *hisi_hba)
1327 {
1328         struct Scsi_Host *shost = hisi_hba->shost;
1329         u32 state;
1330
1331         /* Init and wait for PHYs to come up and all libsas event finished. */
1332         hisi_hba->hw->phys_init(hisi_hba);
1333         msleep(1000);
1334         hisi_sas_refresh_port_id(hisi_hba);
1335         clear_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags);
1336         up(&hisi_hba->sem);
1337
1338         if (hisi_hba->reject_stp_links_msk)
1339                 hisi_sas_terminate_stp_reject(hisi_hba);
1340         hisi_sas_reset_init_all_devices(hisi_hba);
1341         scsi_unblock_requests(shost);
1342         clear_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags);
1343
1344         state = hisi_hba->hw->get_phys_state(hisi_hba);
1345         hisi_sas_rescan_topology(hisi_hba, hisi_hba->phy_state, state);
1346 }
1347 EXPORT_SYMBOL_GPL(hisi_sas_controller_reset_done);
1348
1349 static int hisi_sas_controller_reset(struct hisi_hba *hisi_hba)
1350 {
1351         struct device *dev = hisi_hba->dev;
1352         struct Scsi_Host *shost = hisi_hba->shost;
1353         int rc;
1354
1355         if (!hisi_hba->hw->soft_reset)
1356                 return -1;
1357
1358         if (test_and_set_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags))
1359                 return -1;
1360
1361         dev_info(dev, "controller resetting...\n");
1362         hisi_sas_controller_reset_prepare(hisi_hba);
1363
1364         rc = hisi_hba->hw->soft_reset(hisi_hba);
1365         if (rc) {
1366                 dev_warn(dev, "controller reset failed (%d)\n", rc);
1367                 clear_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags);
1368                 up(&hisi_hba->sem);
1369                 scsi_unblock_requests(shost);
1370                 clear_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags);
1371                 return rc;
1372         }
1373
1374         hisi_sas_controller_reset_done(hisi_hba);
1375         dev_info(dev, "controller reset complete\n");
1376
1377         return 0;
1378 }
1379
1380 static int hisi_sas_abort_task(struct sas_task *task)
1381 {
1382         struct scsi_lun lun;
1383         struct hisi_sas_tmf_task tmf_task;
1384         struct domain_device *device = task->dev;
1385         struct hisi_sas_device *sas_dev = device->lldd_dev;
1386         struct hisi_hba *hisi_hba;
1387         struct device *dev;
1388         int rc = TMF_RESP_FUNC_FAILED;
1389         unsigned long flags;
1390
1391         if (!sas_dev)
1392                 return TMF_RESP_FUNC_FAILED;
1393
1394         hisi_hba = dev_to_hisi_hba(task->dev);
1395         dev = hisi_hba->dev;
1396
1397         spin_lock_irqsave(&task->task_state_lock, flags);
1398         if (task->task_state_flags & SAS_TASK_STATE_DONE) {
1399                 spin_unlock_irqrestore(&task->task_state_lock, flags);
1400                 rc = TMF_RESP_FUNC_COMPLETE;
1401                 goto out;
1402         }
1403         task->task_state_flags |= SAS_TASK_STATE_ABORTED;
1404         spin_unlock_irqrestore(&task->task_state_lock, flags);
1405
1406         sas_dev->dev_status = HISI_SAS_DEV_EH;
1407         if (task->lldd_task && task->task_proto & SAS_PROTOCOL_SSP) {
1408                 struct scsi_cmnd *cmnd = task->uldd_task;
1409                 struct hisi_sas_slot *slot = task->lldd_task;
1410                 u32 tag = slot->idx;
1411                 int rc2;
1412
1413                 int_to_scsilun(cmnd->device->lun, &lun);
1414                 tmf_task.tmf = TMF_ABORT_TASK;
1415                 tmf_task.tag_of_task_to_be_managed = cpu_to_le16(tag);
1416
1417                 rc = hisi_sas_debug_issue_ssp_tmf(task->dev, lun.scsi_lun,
1418                                                   &tmf_task);
1419
1420                 rc2 = hisi_sas_internal_task_abort(hisi_hba, device,
1421                                                    HISI_SAS_INT_ABT_CMD, tag);
1422                 if (rc2 < 0) {
1423                         dev_err(dev, "abort task: internal abort (%d)\n", rc2);
1424                         return TMF_RESP_FUNC_FAILED;
1425                 }
1426
1427                 /*
1428                  * If the TMF finds that the IO is not in the device and also
1429                  * the internal abort does not succeed, then it is safe to
1430                  * free the slot.
1431                  * Note: if the internal abort succeeds then the slot
1432                  * will have already been completed
1433                  */
1434                 if (rc == TMF_RESP_FUNC_COMPLETE && rc2 != TMF_RESP_FUNC_SUCC) {
1435                         if (task->lldd_task)
1436                                 hisi_sas_do_release_task(hisi_hba, task, slot);
1437                 }
1438         } else if (task->task_proto & SAS_PROTOCOL_SATA ||
1439                 task->task_proto & SAS_PROTOCOL_STP) {
1440                 if (task->dev->dev_type == SAS_SATA_DEV) {
1441                         rc = hisi_sas_internal_task_abort(hisi_hba, device,
1442                                                 HISI_SAS_INT_ABT_DEV, 0);
1443                         if (rc < 0) {
1444                                 dev_err(dev, "abort task: internal abort failed\n");
1445                                 goto out;
1446                         }
1447                         hisi_sas_dereg_device(hisi_hba, device);
1448                         rc = hisi_sas_softreset_ata_disk(device);
1449                 }
1450         } else if (task->lldd_task && task->task_proto & SAS_PROTOCOL_SMP) {
1451                 /* SMP */
1452                 struct hisi_sas_slot *slot = task->lldd_task;
1453                 u32 tag = slot->idx;
1454
1455                 rc = hisi_sas_internal_task_abort(hisi_hba, device,
1456                              HISI_SAS_INT_ABT_CMD, tag);
1457                 if (((rc < 0) || (rc == TMF_RESP_FUNC_FAILED)) &&
1458                                         task->lldd_task)
1459                         hisi_sas_do_release_task(hisi_hba, task, slot);
1460         }
1461
1462 out:
1463         if (rc != TMF_RESP_FUNC_COMPLETE)
1464                 dev_notice(dev, "abort task: rc=%d\n", rc);
1465         return rc;
1466 }
1467
1468 static int hisi_sas_abort_task_set(struct domain_device *device, u8 *lun)
1469 {
1470         struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
1471         struct device *dev = hisi_hba->dev;
1472         struct hisi_sas_tmf_task tmf_task;
1473         int rc = TMF_RESP_FUNC_FAILED;
1474
1475         rc = hisi_sas_internal_task_abort(hisi_hba, device,
1476                                         HISI_SAS_INT_ABT_DEV, 0);
1477         if (rc < 0) {
1478                 dev_err(dev, "abort task set: internal abort rc=%d\n", rc);
1479                 return TMF_RESP_FUNC_FAILED;
1480         }
1481         hisi_sas_dereg_device(hisi_hba, device);
1482
1483         tmf_task.tmf = TMF_ABORT_TASK_SET;
1484         rc = hisi_sas_debug_issue_ssp_tmf(device, lun, &tmf_task);
1485
1486         if (rc == TMF_RESP_FUNC_COMPLETE)
1487                 hisi_sas_release_task(hisi_hba, device);
1488
1489         return rc;
1490 }
1491
1492 static int hisi_sas_clear_aca(struct domain_device *device, u8 *lun)
1493 {
1494         int rc = TMF_RESP_FUNC_FAILED;
1495         struct hisi_sas_tmf_task tmf_task;
1496
1497         tmf_task.tmf = TMF_CLEAR_ACA;
1498         rc = hisi_sas_debug_issue_ssp_tmf(device, lun, &tmf_task);
1499
1500         return rc;
1501 }
1502
1503 static int hisi_sas_debug_I_T_nexus_reset(struct domain_device *device)
1504 {
1505         struct sas_phy *local_phy = sas_get_local_phy(device);
1506         int rc, reset_type = (device->dev_type == SAS_SATA_DEV ||
1507                         (device->tproto & SAS_PROTOCOL_STP)) ? 0 : 1;
1508         struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
1509         struct sas_ha_struct *sas_ha = &hisi_hba->sha;
1510         struct asd_sas_phy *sas_phy = sas_ha->sas_phy[local_phy->number];
1511         struct hisi_sas_phy *phy = container_of(sas_phy,
1512                         struct hisi_sas_phy, sas_phy);
1513         DECLARE_COMPLETION_ONSTACK(phyreset);
1514
1515         if (scsi_is_sas_phy_local(local_phy)) {
1516                 phy->in_reset = 1;
1517                 phy->reset_completion = &phyreset;
1518         }
1519
1520         rc = sas_phy_reset(local_phy, reset_type);
1521         sas_put_local_phy(local_phy);
1522
1523         if (scsi_is_sas_phy_local(local_phy)) {
1524                 int ret = wait_for_completion_timeout(&phyreset, 2 * HZ);
1525                 unsigned long flags;
1526
1527                 spin_lock_irqsave(&phy->lock, flags);
1528                 phy->reset_completion = NULL;
1529                 phy->in_reset = 0;
1530                 spin_unlock_irqrestore(&phy->lock, flags);
1531
1532                 /* report PHY down if timed out */
1533                 if (!ret)
1534                         hisi_sas_phy_down(hisi_hba, sas_phy->id, 0);
1535         } else
1536                 msleep(2000);
1537
1538         return rc;
1539 }
1540
1541 static int hisi_sas_I_T_nexus_reset(struct domain_device *device)
1542 {
1543         struct hisi_sas_device *sas_dev = device->lldd_dev;
1544         struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
1545         struct device *dev = hisi_hba->dev;
1546         int rc = TMF_RESP_FUNC_FAILED;
1547
1548         if (sas_dev->dev_status != HISI_SAS_DEV_EH)
1549                 return TMF_RESP_FUNC_FAILED;
1550         sas_dev->dev_status = HISI_SAS_DEV_NORMAL;
1551
1552         rc = hisi_sas_internal_task_abort(hisi_hba, device,
1553                                         HISI_SAS_INT_ABT_DEV, 0);
1554         if (rc < 0) {
1555                 dev_err(dev, "I_T nexus reset: internal abort (%d)\n", rc);
1556                 return TMF_RESP_FUNC_FAILED;
1557         }
1558         hisi_sas_dereg_device(hisi_hba, device);
1559
1560         rc = hisi_sas_debug_I_T_nexus_reset(device);
1561
1562         if ((rc == TMF_RESP_FUNC_COMPLETE) || (rc == -ENODEV))
1563                 hisi_sas_release_task(hisi_hba, device);
1564
1565         return rc;
1566 }
1567
1568 static int hisi_sas_lu_reset(struct domain_device *device, u8 *lun)
1569 {
1570         struct hisi_sas_device *sas_dev = device->lldd_dev;
1571         struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
1572         struct device *dev = hisi_hba->dev;
1573         int rc = TMF_RESP_FUNC_FAILED;
1574
1575         sas_dev->dev_status = HISI_SAS_DEV_EH;
1576         if (dev_is_sata(device)) {
1577                 struct sas_phy *phy;
1578
1579                 /* Clear internal IO and then hardreset */
1580                 rc = hisi_sas_internal_task_abort(hisi_hba, device,
1581                                                   HISI_SAS_INT_ABT_DEV, 0);
1582                 if (rc < 0) {
1583                         dev_err(dev, "lu_reset: internal abort failed\n");
1584                         goto out;
1585                 }
1586                 hisi_sas_dereg_device(hisi_hba, device);
1587
1588                 phy = sas_get_local_phy(device);
1589
1590                 rc = sas_phy_reset(phy, 1);
1591
1592                 if (rc == 0)
1593                         hisi_sas_release_task(hisi_hba, device);
1594                 sas_put_local_phy(phy);
1595         } else {
1596                 struct hisi_sas_tmf_task tmf_task = { .tmf =  TMF_LU_RESET };
1597
1598                 rc = hisi_sas_internal_task_abort(hisi_hba, device,
1599                                                 HISI_SAS_INT_ABT_DEV, 0);
1600                 if (rc < 0) {
1601                         dev_err(dev, "lu_reset: internal abort failed\n");
1602                         goto out;
1603                 }
1604                 hisi_sas_dereg_device(hisi_hba, device);
1605
1606                 rc = hisi_sas_debug_issue_ssp_tmf(device, lun, &tmf_task);
1607                 if (rc == TMF_RESP_FUNC_COMPLETE)
1608                         hisi_sas_release_task(hisi_hba, device);
1609         }
1610 out:
1611         if (rc != TMF_RESP_FUNC_COMPLETE)
1612                 dev_err(dev, "lu_reset: for device[%d]:rc= %d\n",
1613                              sas_dev->device_id, rc);
1614         return rc;
1615 }
1616
1617 static int hisi_sas_clear_nexus_ha(struct sas_ha_struct *sas_ha)
1618 {
1619         struct hisi_hba *hisi_hba = sas_ha->lldd_ha;
1620         struct device *dev = hisi_hba->dev;
1621         HISI_SAS_DECLARE_RST_WORK_ON_STACK(r);
1622         int rc, i;
1623
1624         queue_work(hisi_hba->wq, &r.work);
1625         wait_for_completion(r.completion);
1626         if (!r.done)
1627                 return TMF_RESP_FUNC_FAILED;
1628
1629         for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
1630                 struct hisi_sas_device *sas_dev = &hisi_hba->devices[i];
1631                 struct domain_device *device = sas_dev->sas_device;
1632
1633                 if ((sas_dev->dev_type == SAS_PHY_UNUSED) || !device ||
1634                     DEV_IS_EXPANDER(device->dev_type))
1635                         continue;
1636
1637                 rc = hisi_sas_debug_I_T_nexus_reset(device);
1638                 if (rc != TMF_RESP_FUNC_COMPLETE)
1639                         dev_info(dev, "clear nexus ha: for device[%d] rc=%d\n",
1640                                  sas_dev->device_id, rc);
1641         }
1642
1643         hisi_sas_release_tasks(hisi_hba);
1644
1645         return TMF_RESP_FUNC_COMPLETE;
1646 }
1647
1648 static int hisi_sas_query_task(struct sas_task *task)
1649 {
1650         struct scsi_lun lun;
1651         struct hisi_sas_tmf_task tmf_task;
1652         int rc = TMF_RESP_FUNC_FAILED;
1653
1654         if (task->lldd_task && task->task_proto & SAS_PROTOCOL_SSP) {
1655                 struct scsi_cmnd *cmnd = task->uldd_task;
1656                 struct domain_device *device = task->dev;
1657                 struct hisi_sas_slot *slot = task->lldd_task;
1658                 u32 tag = slot->idx;
1659
1660                 int_to_scsilun(cmnd->device->lun, &lun);
1661                 tmf_task.tmf = TMF_QUERY_TASK;
1662                 tmf_task.tag_of_task_to_be_managed = cpu_to_le16(tag);
1663
1664                 rc = hisi_sas_debug_issue_ssp_tmf(device,
1665                                                   lun.scsi_lun,
1666                                                   &tmf_task);
1667                 switch (rc) {
1668                 /* The task is still in Lun, release it then */
1669                 case TMF_RESP_FUNC_SUCC:
1670                 /* The task is not in Lun or failed, reset the phy */
1671                 case TMF_RESP_FUNC_FAILED:
1672                 case TMF_RESP_FUNC_COMPLETE:
1673                         break;
1674                 default:
1675                         rc = TMF_RESP_FUNC_FAILED;
1676                         break;
1677                 }
1678         }
1679         return rc;
1680 }
1681
1682 static int
1683 hisi_sas_internal_abort_task_exec(struct hisi_hba *hisi_hba, int device_id,
1684                                   struct sas_task *task, int abort_flag,
1685                                   int task_tag)
1686 {
1687         struct domain_device *device = task->dev;
1688         struct hisi_sas_device *sas_dev = device->lldd_dev;
1689         struct device *dev = hisi_hba->dev;
1690         struct hisi_sas_port *port;
1691         struct hisi_sas_slot *slot;
1692         struct asd_sas_port *sas_port = device->port;
1693         struct hisi_sas_cmd_hdr *cmd_hdr_base;
1694         struct hisi_sas_dq *dq = sas_dev->dq;
1695         int dlvry_queue_slot, dlvry_queue, n_elem = 0, rc, slot_idx;
1696         unsigned long flags, flags_dq = 0;
1697         int wr_q_index;
1698
1699         if (unlikely(test_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags)))
1700                 return -EINVAL;
1701
1702         if (!device->port)
1703                 return -1;
1704
1705         port = to_hisi_sas_port(sas_port);
1706
1707         /* simply get a slot and send abort command */
1708         spin_lock_irqsave(&hisi_hba->lock, flags);
1709         rc = hisi_sas_slot_index_alloc(hisi_hba, &slot_idx);
1710         if (rc) {
1711                 spin_unlock_irqrestore(&hisi_hba->lock, flags);
1712                 goto err_out;
1713         }
1714         spin_unlock_irqrestore(&hisi_hba->lock, flags);
1715
1716         slot = &hisi_hba->slot_info[slot_idx];
1717
1718         spin_lock_irqsave(&dq->lock, flags_dq);
1719         wr_q_index = hisi_hba->hw->get_free_slot(hisi_hba, dq);
1720         if (wr_q_index < 0) {
1721                 spin_unlock_irqrestore(&dq->lock, flags_dq);
1722                 rc = -EAGAIN;
1723                 goto err_out_tag;
1724         }
1725         list_add_tail(&slot->delivery, &dq->list);
1726         spin_unlock_irqrestore(&dq->lock, flags_dq);
1727
1728         dlvry_queue = dq->id;
1729         dlvry_queue_slot = wr_q_index;
1730
1731         slot->n_elem = n_elem;
1732         slot->dlvry_queue = dlvry_queue;
1733         slot->dlvry_queue_slot = dlvry_queue_slot;
1734         cmd_hdr_base = hisi_hba->cmd_hdr[dlvry_queue];
1735         slot->cmd_hdr = &cmd_hdr_base[dlvry_queue_slot];
1736         slot->task = task;
1737         slot->port = port;
1738         slot->is_internal = true;
1739         task->lldd_task = slot;
1740
1741         memset(slot->cmd_hdr, 0, sizeof(struct hisi_sas_cmd_hdr));
1742         memset(hisi_sas_cmd_hdr_addr_mem(slot), 0, HISI_SAS_COMMAND_TABLE_SZ);
1743         memset(hisi_sas_status_buf_addr_mem(slot), 0, HISI_SAS_STATUS_BUF_SZ);
1744
1745         hisi_sas_task_prep_abort(hisi_hba, slot, device_id,
1746                                       abort_flag, task_tag);
1747
1748         spin_lock_irqsave(&task->task_state_lock, flags);
1749         task->task_state_flags |= SAS_TASK_AT_INITIATOR;
1750         spin_unlock_irqrestore(&task->task_state_lock, flags);
1751
1752         WRITE_ONCE(slot->ready, 1);
1753         /* send abort command to the chip */
1754         spin_lock_irqsave(&dq->lock, flags);
1755         list_add_tail(&slot->entry, &sas_dev->list);
1756         hisi_hba->hw->start_delivery(dq);
1757         spin_unlock_irqrestore(&dq->lock, flags);
1758
1759         return 0;
1760
1761 err_out_tag:
1762         spin_lock_irqsave(&hisi_hba->lock, flags);
1763         hisi_sas_slot_index_free(hisi_hba, slot_idx);
1764         spin_unlock_irqrestore(&hisi_hba->lock, flags);
1765 err_out:
1766         dev_err(dev, "internal abort task prep: failed[%d]!\n", rc);
1767
1768         return rc;
1769 }
1770
1771 /**
1772  * hisi_sas_internal_task_abort -- execute an internal
1773  * abort command for single IO command or a device
1774  * @hisi_hba: host controller struct
1775  * @device: domain device
1776  * @abort_flag: mode of operation, device or single IO
1777  * @tag: tag of IO to be aborted (only relevant to single
1778  *       IO mode)
1779  */
1780 static int
1781 hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
1782                              struct domain_device *device,
1783                              int abort_flag, int tag)
1784 {
1785         struct sas_task *task;
1786         struct hisi_sas_device *sas_dev = device->lldd_dev;
1787         struct device *dev = hisi_hba->dev;
1788         int res;
1789
1790         /*
1791          * The interface is not realized means this HW don't support internal
1792          * abort, or don't need to do internal abort. Then here, we return
1793          * TMF_RESP_FUNC_FAILED and let other steps go on, which depends that
1794          * the internal abort has been executed and returned CQ.
1795          */
1796         if (!hisi_hba->hw->prep_abort)
1797                 return TMF_RESP_FUNC_FAILED;
1798
1799         task = sas_alloc_slow_task(GFP_KERNEL);
1800         if (!task)
1801                 return -ENOMEM;
1802
1803         task->dev = device;
1804         task->task_proto = device->tproto;
1805         task->task_done = hisi_sas_task_done;
1806         task->slow_task->timer.function = hisi_sas_tmf_timedout;
1807         task->slow_task->timer.expires = jiffies + INTERNAL_ABORT_TIMEOUT*HZ;
1808         add_timer(&task->slow_task->timer);
1809
1810         res = hisi_sas_internal_abort_task_exec(hisi_hba, sas_dev->device_id,
1811                                                 task, abort_flag, tag);
1812         if (res) {
1813                 del_timer(&task->slow_task->timer);
1814                 dev_err(dev, "internal task abort: executing internal task failed: %d\n",
1815                         res);
1816                 goto exit;
1817         }
1818         wait_for_completion(&task->slow_task->completion);
1819         res = TMF_RESP_FUNC_FAILED;
1820
1821         /* Internal abort timed out */
1822         if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
1823                 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
1824                         struct hisi_sas_slot *slot = task->lldd_task;
1825
1826                         if (slot)
1827                                 slot->task = NULL;
1828                         dev_err(dev, "internal task abort: timeout and not done.\n");
1829                         res = -EIO;
1830                         goto exit;
1831                 } else
1832                         dev_err(dev, "internal task abort: timeout.\n");
1833         }
1834
1835         if (task->task_status.resp == SAS_TASK_COMPLETE &&
1836                 task->task_status.stat == TMF_RESP_FUNC_COMPLETE) {
1837                 res = TMF_RESP_FUNC_COMPLETE;
1838                 goto exit;
1839         }
1840
1841         if (task->task_status.resp == SAS_TASK_COMPLETE &&
1842                 task->task_status.stat == TMF_RESP_FUNC_SUCC) {
1843                 res = TMF_RESP_FUNC_SUCC;
1844                 goto exit;
1845         }
1846
1847 exit:
1848         dev_dbg(dev, "internal task abort: task to dev %016llx task=%p "
1849                 "resp: 0x%x sts 0x%x\n",
1850                 SAS_ADDR(device->sas_addr),
1851                 task,
1852                 task->task_status.resp, /* 0 is complete, -1 is undelivered */
1853                 task->task_status.stat);
1854         sas_free_task(task);
1855
1856         return res;
1857 }
1858
1859 static void hisi_sas_port_formed(struct asd_sas_phy *sas_phy)
1860 {
1861         hisi_sas_port_notify_formed(sas_phy);
1862 }
1863
1864 static void hisi_sas_port_deformed(struct asd_sas_phy *sas_phy)
1865 {
1866 }
1867
1868 static int hisi_sas_write_gpio(struct sas_ha_struct *sha, u8 reg_type,
1869                         u8 reg_index, u8 reg_count, u8 *write_data)
1870 {
1871         struct hisi_hba *hisi_hba = sha->lldd_ha;
1872
1873         if (!hisi_hba->hw->write_gpio)
1874                 return -EOPNOTSUPP;
1875
1876         return hisi_hba->hw->write_gpio(hisi_hba, reg_type,
1877                                 reg_index, reg_count, write_data);
1878 }
1879
1880 static void hisi_sas_phy_disconnected(struct hisi_sas_phy *phy)
1881 {
1882         phy->phy_attached = 0;
1883         phy->phy_type = 0;
1884         phy->port = NULL;
1885 }
1886
1887 void hisi_sas_phy_down(struct hisi_hba *hisi_hba, int phy_no, int rdy)
1888 {
1889         struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
1890         struct asd_sas_phy *sas_phy = &phy->sas_phy;
1891         struct sas_ha_struct *sas_ha = &hisi_hba->sha;
1892         struct device *dev = hisi_hba->dev;
1893
1894         if (rdy) {
1895                 /* Phy down but ready */
1896                 hisi_sas_bytes_dmaed(hisi_hba, phy_no);
1897                 hisi_sas_port_notify_formed(sas_phy);
1898         } else {
1899                 struct hisi_sas_port *port  = phy->port;
1900
1901                 if (test_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags) ||
1902                     phy->in_reset) {
1903                         dev_info(dev, "ignore flutter phy%d down\n", phy_no);
1904                         return;
1905                 }
1906                 /* Phy down and not ready */
1907                 sas_ha->notify_phy_event(sas_phy, PHYE_LOSS_OF_SIGNAL);
1908                 sas_phy_disconnected(sas_phy);
1909
1910                 if (port) {
1911                         if (phy->phy_type & PORT_TYPE_SAS) {
1912                                 int port_id = port->id;
1913
1914                                 if (!hisi_hba->hw->get_wideport_bitmap(hisi_hba,
1915                                                                        port_id))
1916                                         port->port_attached = 0;
1917                         } else if (phy->phy_type & PORT_TYPE_SATA)
1918                                 port->port_attached = 0;
1919                 }
1920                 hisi_sas_phy_disconnected(phy);
1921         }
1922 }
1923 EXPORT_SYMBOL_GPL(hisi_sas_phy_down);
1924
1925 void hisi_sas_kill_tasklets(struct hisi_hba *hisi_hba)
1926 {
1927         int i;
1928
1929         for (i = 0; i < hisi_hba->queue_count; i++) {
1930                 struct hisi_sas_cq *cq = &hisi_hba->cq[i];
1931
1932                 tasklet_kill(&cq->tasklet);
1933         }
1934 }
1935 EXPORT_SYMBOL_GPL(hisi_sas_kill_tasklets);
1936
1937 struct scsi_transport_template *hisi_sas_stt;
1938 EXPORT_SYMBOL_GPL(hisi_sas_stt);
1939
1940 struct device_attribute *host_attrs[] = {
1941         &dev_attr_phy_event_threshold,
1942         NULL,
1943 };
1944 EXPORT_SYMBOL_GPL(host_attrs);
1945
1946 static struct sas_domain_function_template hisi_sas_transport_ops = {
1947         .lldd_dev_found         = hisi_sas_dev_found,
1948         .lldd_dev_gone          = hisi_sas_dev_gone,
1949         .lldd_execute_task      = hisi_sas_queue_command,
1950         .lldd_control_phy       = hisi_sas_control_phy,
1951         .lldd_abort_task        = hisi_sas_abort_task,
1952         .lldd_abort_task_set    = hisi_sas_abort_task_set,
1953         .lldd_clear_aca         = hisi_sas_clear_aca,
1954         .lldd_I_T_nexus_reset   = hisi_sas_I_T_nexus_reset,
1955         .lldd_lu_reset          = hisi_sas_lu_reset,
1956         .lldd_query_task        = hisi_sas_query_task,
1957         .lldd_clear_nexus_ha = hisi_sas_clear_nexus_ha,
1958         .lldd_port_formed       = hisi_sas_port_formed,
1959         .lldd_port_deformed = hisi_sas_port_deformed,
1960         .lldd_write_gpio = hisi_sas_write_gpio,
1961 };
1962
1963 void hisi_sas_init_mem(struct hisi_hba *hisi_hba)
1964 {
1965         int i, s, max_command_entries = hisi_hba->hw->max_command_entries;
1966
1967         for (i = 0; i < hisi_hba->queue_count; i++) {
1968                 struct hisi_sas_cq *cq = &hisi_hba->cq[i];
1969                 struct hisi_sas_dq *dq = &hisi_hba->dq[i];
1970
1971                 s = sizeof(struct hisi_sas_cmd_hdr) * HISI_SAS_QUEUE_SLOTS;
1972                 memset(hisi_hba->cmd_hdr[i], 0, s);
1973                 dq->wr_point = 0;
1974
1975                 s = hisi_hba->hw->complete_hdr_size * HISI_SAS_QUEUE_SLOTS;
1976                 memset(hisi_hba->complete_hdr[i], 0, s);
1977                 cq->rd_point = 0;
1978         }
1979
1980         s = sizeof(struct hisi_sas_initial_fis) * hisi_hba->n_phy;
1981         memset(hisi_hba->initial_fis, 0, s);
1982
1983         s = max_command_entries * sizeof(struct hisi_sas_iost);
1984         memset(hisi_hba->iost, 0, s);
1985
1986         s = max_command_entries * sizeof(struct hisi_sas_breakpoint);
1987         memset(hisi_hba->breakpoint, 0, s);
1988
1989         s = HISI_SAS_MAX_ITCT_ENTRIES * sizeof(struct hisi_sas_sata_breakpoint);
1990         memset(hisi_hba->sata_breakpoint, 0, s);
1991 }
1992 EXPORT_SYMBOL_GPL(hisi_sas_init_mem);
1993
1994 int hisi_sas_alloc(struct hisi_hba *hisi_hba, struct Scsi_Host *shost)
1995 {
1996         struct device *dev = hisi_hba->dev;
1997         int i, j, s, max_command_entries = hisi_hba->hw->max_command_entries;
1998         int max_command_entries_ru, sz_slot_buf_ru;
1999         int blk_cnt, slots_per_blk;
2000
2001         sema_init(&hisi_hba->sem, 1);
2002         spin_lock_init(&hisi_hba->lock);
2003         for (i = 0; i < hisi_hba->n_phy; i++) {
2004                 hisi_sas_phy_init(hisi_hba, i);
2005                 hisi_hba->port[i].port_attached = 0;
2006                 hisi_hba->port[i].id = -1;
2007         }
2008
2009         for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
2010                 hisi_hba->devices[i].dev_type = SAS_PHY_UNUSED;
2011                 hisi_hba->devices[i].device_id = i;
2012                 hisi_hba->devices[i].dev_status = HISI_SAS_DEV_NORMAL;
2013         }
2014
2015         for (i = 0; i < hisi_hba->queue_count; i++) {
2016                 struct hisi_sas_cq *cq = &hisi_hba->cq[i];
2017                 struct hisi_sas_dq *dq = &hisi_hba->dq[i];
2018
2019                 /* Completion queue structure */
2020                 cq->id = i;
2021                 cq->hisi_hba = hisi_hba;
2022
2023                 /* Delivery queue structure */
2024                 spin_lock_init(&dq->lock);
2025                 INIT_LIST_HEAD(&dq->list);
2026                 dq->id = i;
2027                 dq->hisi_hba = hisi_hba;
2028
2029                 /* Delivery queue */
2030                 s = sizeof(struct hisi_sas_cmd_hdr) * HISI_SAS_QUEUE_SLOTS;
2031                 hisi_hba->cmd_hdr[i] = dmam_alloc_coherent(dev, s,
2032                                                 &hisi_hba->cmd_hdr_dma[i],
2033                                                 GFP_KERNEL);
2034                 if (!hisi_hba->cmd_hdr[i])
2035                         goto err_out;
2036
2037                 /* Completion queue */
2038                 s = hisi_hba->hw->complete_hdr_size * HISI_SAS_QUEUE_SLOTS;
2039                 hisi_hba->complete_hdr[i] = dmam_alloc_coherent(dev, s,
2040                                                 &hisi_hba->complete_hdr_dma[i],
2041                                                 GFP_KERNEL);
2042                 if (!hisi_hba->complete_hdr[i])
2043                         goto err_out;
2044         }
2045
2046         s = HISI_SAS_MAX_ITCT_ENTRIES * sizeof(struct hisi_sas_itct);
2047         hisi_hba->itct = dmam_alloc_coherent(dev, s, &hisi_hba->itct_dma,
2048                                              GFP_KERNEL);
2049         if (!hisi_hba->itct)
2050                 goto err_out;
2051         memset(hisi_hba->itct, 0, s);
2052
2053         hisi_hba->slot_info = devm_kcalloc(dev, max_command_entries,
2054                                            sizeof(struct hisi_sas_slot),
2055                                            GFP_KERNEL);
2056         if (!hisi_hba->slot_info)
2057                 goto err_out;
2058
2059         /* roundup to avoid overly large block size */
2060         max_command_entries_ru = roundup(max_command_entries, 64);
2061         sz_slot_buf_ru = roundup(sizeof(struct hisi_sas_slot_buf_table), 64);
2062         s = lcm(max_command_entries_ru, sz_slot_buf_ru);
2063         blk_cnt = (max_command_entries_ru * sz_slot_buf_ru) / s;
2064         slots_per_blk = s / sz_slot_buf_ru;
2065         for (i = 0; i < blk_cnt; i++) {
2066                 struct hisi_sas_slot_buf_table *buf;
2067                 dma_addr_t buf_dma;
2068                 int slot_index = i * slots_per_blk;
2069
2070                 buf = dmam_alloc_coherent(dev, s, &buf_dma, GFP_KERNEL);
2071                 if (!buf)
2072                         goto err_out;
2073                 memset(buf, 0, s);
2074
2075                 for (j = 0; j < slots_per_blk; j++, slot_index++) {
2076                         struct hisi_sas_slot *slot;
2077
2078                         slot = &hisi_hba->slot_info[slot_index];
2079                         slot->buf = buf;
2080                         slot->buf_dma = buf_dma;
2081                         slot->idx = slot_index;
2082
2083                         buf++;
2084                         buf_dma += sizeof(*buf);
2085                 }
2086         }
2087
2088         s = max_command_entries * sizeof(struct hisi_sas_iost);
2089         hisi_hba->iost = dmam_alloc_coherent(dev, s, &hisi_hba->iost_dma,
2090                                              GFP_KERNEL);
2091         if (!hisi_hba->iost)
2092                 goto err_out;
2093
2094         s = max_command_entries * sizeof(struct hisi_sas_breakpoint);
2095         hisi_hba->breakpoint = dmam_alloc_coherent(dev, s,
2096                                                    &hisi_hba->breakpoint_dma,
2097                                                    GFP_KERNEL);
2098         if (!hisi_hba->breakpoint)
2099                 goto err_out;
2100
2101         hisi_hba->slot_index_count = max_command_entries;
2102         s = hisi_hba->slot_index_count / BITS_PER_BYTE;
2103         hisi_hba->slot_index_tags = devm_kzalloc(dev, s, GFP_KERNEL);
2104         if (!hisi_hba->slot_index_tags)
2105                 goto err_out;
2106
2107         s = sizeof(struct hisi_sas_initial_fis) * HISI_SAS_MAX_PHYS;
2108         hisi_hba->initial_fis = dmam_alloc_coherent(dev, s,
2109                                                     &hisi_hba->initial_fis_dma,
2110                                                     GFP_KERNEL);
2111         if (!hisi_hba->initial_fis)
2112                 goto err_out;
2113
2114         s = HISI_SAS_MAX_ITCT_ENTRIES * sizeof(struct hisi_sas_sata_breakpoint);
2115         hisi_hba->sata_breakpoint = dmam_alloc_coherent(dev, s,
2116                                         &hisi_hba->sata_breakpoint_dma,
2117                                         GFP_KERNEL);
2118         if (!hisi_hba->sata_breakpoint)
2119                 goto err_out;
2120         hisi_sas_init_mem(hisi_hba);
2121
2122         hisi_sas_slot_index_init(hisi_hba);
2123
2124         hisi_hba->wq = create_singlethread_workqueue(dev_name(dev));
2125         if (!hisi_hba->wq) {
2126                 dev_err(dev, "sas_alloc: failed to create workqueue\n");
2127                 goto err_out;
2128         }
2129
2130         return 0;
2131 err_out:
2132         return -ENOMEM;
2133 }
2134 EXPORT_SYMBOL_GPL(hisi_sas_alloc);
2135
2136 void hisi_sas_free(struct hisi_hba *hisi_hba)
2137 {
2138         if (hisi_hba->wq)
2139                 destroy_workqueue(hisi_hba->wq);
2140 }
2141 EXPORT_SYMBOL_GPL(hisi_sas_free);
2142
2143 void hisi_sas_rst_work_handler(struct work_struct *work)
2144 {
2145         struct hisi_hba *hisi_hba =
2146                 container_of(work, struct hisi_hba, rst_work);
2147
2148         hisi_sas_controller_reset(hisi_hba);
2149 }
2150 EXPORT_SYMBOL_GPL(hisi_sas_rst_work_handler);
2151
2152 void hisi_sas_sync_rst_work_handler(struct work_struct *work)
2153 {
2154         struct hisi_sas_rst *rst =
2155                 container_of(work, struct hisi_sas_rst, work);
2156
2157         if (!hisi_sas_controller_reset(rst->hisi_hba))
2158                 rst->done = true;
2159         complete(rst->completion);
2160 }
2161 EXPORT_SYMBOL_GPL(hisi_sas_sync_rst_work_handler);
2162
2163 int hisi_sas_get_fw_info(struct hisi_hba *hisi_hba)
2164 {
2165         struct device *dev = hisi_hba->dev;
2166         struct platform_device *pdev = hisi_hba->platform_dev;
2167         struct device_node *np = pdev ? pdev->dev.of_node : NULL;
2168         struct clk *refclk;
2169
2170         if (device_property_read_u8_array(dev, "sas-addr", hisi_hba->sas_addr,
2171                                           SAS_ADDR_SIZE)) {
2172                 dev_err(dev, "could not get property sas-addr\n");
2173                 return -ENOENT;
2174         }
2175
2176         if (np) {
2177                 /*
2178                  * These properties are only required for platform device-based
2179                  * controller with DT firmware.
2180                  */
2181                 hisi_hba->ctrl = syscon_regmap_lookup_by_phandle(np,
2182                                         "hisilicon,sas-syscon");
2183                 if (IS_ERR(hisi_hba->ctrl)) {
2184                         dev_err(dev, "could not get syscon\n");
2185                         return -ENOENT;
2186                 }
2187
2188                 if (device_property_read_u32(dev, "ctrl-reset-reg",
2189                                              &hisi_hba->ctrl_reset_reg)) {
2190                         dev_err(dev,
2191                                 "could not get property ctrl-reset-reg\n");
2192                         return -ENOENT;
2193                 }
2194
2195                 if (device_property_read_u32(dev, "ctrl-reset-sts-reg",
2196                                              &hisi_hba->ctrl_reset_sts_reg)) {
2197                         dev_err(dev,
2198                                 "could not get property ctrl-reset-sts-reg\n");
2199                         return -ENOENT;
2200                 }
2201
2202                 if (device_property_read_u32(dev, "ctrl-clock-ena-reg",
2203                                              &hisi_hba->ctrl_clock_ena_reg)) {
2204                         dev_err(dev,
2205                                 "could not get property ctrl-clock-ena-reg\n");
2206                         return -ENOENT;
2207                 }
2208         }
2209
2210         refclk = devm_clk_get(dev, NULL);
2211         if (IS_ERR(refclk))
2212                 dev_dbg(dev, "no ref clk property\n");
2213         else
2214                 hisi_hba->refclk_frequency_mhz = clk_get_rate(refclk) / 1000000;
2215
2216         if (device_property_read_u32(dev, "phy-count", &hisi_hba->n_phy)) {
2217                 dev_err(dev, "could not get property phy-count\n");
2218                 return -ENOENT;
2219         }
2220
2221         if (device_property_read_u32(dev, "queue-count",
2222                                      &hisi_hba->queue_count)) {
2223                 dev_err(dev, "could not get property queue-count\n");
2224                 return -ENOENT;
2225         }
2226
2227         return 0;
2228 }
2229 EXPORT_SYMBOL_GPL(hisi_sas_get_fw_info);
2230
2231 static struct Scsi_Host *hisi_sas_shost_alloc(struct platform_device *pdev,
2232                                               const struct hisi_sas_hw *hw)
2233 {
2234         struct resource *res;
2235         struct Scsi_Host *shost;
2236         struct hisi_hba *hisi_hba;
2237         struct device *dev = &pdev->dev;
2238
2239         shost = scsi_host_alloc(hw->sht, sizeof(*hisi_hba));
2240         if (!shost) {
2241                 dev_err(dev, "scsi host alloc failed\n");
2242                 return NULL;
2243         }
2244         hisi_hba = shost_priv(shost);
2245
2246         INIT_WORK(&hisi_hba->rst_work, hisi_sas_rst_work_handler);
2247         hisi_hba->hw = hw;
2248         hisi_hba->dev = dev;
2249         hisi_hba->platform_dev = pdev;
2250         hisi_hba->shost = shost;
2251         SHOST_TO_SAS_HA(shost) = &hisi_hba->sha;
2252
2253         timer_setup(&hisi_hba->timer, NULL, 0);
2254
2255         if (hisi_sas_get_fw_info(hisi_hba) < 0)
2256                 goto err_out;
2257
2258         if (dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64)) &&
2259             dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32))) {
2260                 dev_err(dev, "No usable DMA addressing method\n");
2261                 goto err_out;
2262         }
2263
2264         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2265         hisi_hba->regs = devm_ioremap_resource(dev, res);
2266         if (IS_ERR(hisi_hba->regs))
2267                 goto err_out;
2268
2269         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
2270         if (res) {
2271                 hisi_hba->sgpio_regs = devm_ioremap_resource(dev, res);
2272                 if (IS_ERR(hisi_hba->sgpio_regs))
2273                         goto err_out;
2274         }
2275
2276         if (hisi_sas_alloc(hisi_hba, shost)) {
2277                 hisi_sas_free(hisi_hba);
2278                 goto err_out;
2279         }
2280
2281         return shost;
2282 err_out:
2283         scsi_host_put(shost);
2284         dev_err(dev, "shost alloc failed\n");
2285         return NULL;
2286 }
2287
2288 int hisi_sas_probe(struct platform_device *pdev,
2289                    const struct hisi_sas_hw *hw)
2290 {
2291         struct Scsi_Host *shost;
2292         struct hisi_hba *hisi_hba;
2293         struct device *dev = &pdev->dev;
2294         struct asd_sas_phy **arr_phy;
2295         struct asd_sas_port **arr_port;
2296         struct sas_ha_struct *sha;
2297         int rc, phy_nr, port_nr, i;
2298
2299         shost = hisi_sas_shost_alloc(pdev, hw);
2300         if (!shost)
2301                 return -ENOMEM;
2302
2303         sha = SHOST_TO_SAS_HA(shost);
2304         hisi_hba = shost_priv(shost);
2305         platform_set_drvdata(pdev, sha);
2306
2307         phy_nr = port_nr = hisi_hba->n_phy;
2308
2309         arr_phy = devm_kcalloc(dev, phy_nr, sizeof(void *), GFP_KERNEL);
2310         arr_port = devm_kcalloc(dev, port_nr, sizeof(void *), GFP_KERNEL);
2311         if (!arr_phy || !arr_port) {
2312                 rc = -ENOMEM;
2313                 goto err_out_ha;
2314         }
2315
2316         sha->sas_phy = arr_phy;
2317         sha->sas_port = arr_port;
2318         sha->lldd_ha = hisi_hba;
2319
2320         shost->transportt = hisi_sas_stt;
2321         shost->max_id = HISI_SAS_MAX_DEVICES;
2322         shost->max_lun = ~0;
2323         shost->max_channel = 1;
2324         shost->max_cmd_len = 16;
2325         shost->sg_tablesize = min_t(u16, SG_ALL, HISI_SAS_SGE_PAGE_CNT);
2326         shost->can_queue = hisi_hba->hw->max_command_entries;
2327         shost->cmd_per_lun = hisi_hba->hw->max_command_entries;
2328
2329         sha->sas_ha_name = DRV_NAME;
2330         sha->dev = hisi_hba->dev;
2331         sha->lldd_module = THIS_MODULE;
2332         sha->sas_addr = &hisi_hba->sas_addr[0];
2333         sha->num_phys = hisi_hba->n_phy;
2334         sha->core.shost = hisi_hba->shost;
2335
2336         for (i = 0; i < hisi_hba->n_phy; i++) {
2337                 sha->sas_phy[i] = &hisi_hba->phy[i].sas_phy;
2338                 sha->sas_port[i] = &hisi_hba->port[i].sas_port;
2339         }
2340
2341         rc = scsi_add_host(shost, &pdev->dev);
2342         if (rc)
2343                 goto err_out_ha;
2344
2345         rc = sas_register_ha(sha);
2346         if (rc)
2347                 goto err_out_register_ha;
2348
2349         rc = hisi_hba->hw->hw_init(hisi_hba);
2350         if (rc)
2351                 goto err_out_register_ha;
2352
2353         scsi_scan_host(shost);
2354
2355         return 0;
2356
2357 err_out_register_ha:
2358         scsi_remove_host(shost);
2359 err_out_ha:
2360         hisi_sas_free(hisi_hba);
2361         scsi_host_put(shost);
2362         return rc;
2363 }
2364 EXPORT_SYMBOL_GPL(hisi_sas_probe);
2365
2366 int hisi_sas_remove(struct platform_device *pdev)
2367 {
2368         struct sas_ha_struct *sha = platform_get_drvdata(pdev);
2369         struct hisi_hba *hisi_hba = sha->lldd_ha;
2370         struct Scsi_Host *shost = sha->core.shost;
2371
2372         if (timer_pending(&hisi_hba->timer))
2373                 del_timer(&hisi_hba->timer);
2374
2375         sas_unregister_ha(sha);
2376         sas_remove_host(sha->core.shost);
2377
2378         hisi_sas_free(hisi_hba);
2379         scsi_host_put(shost);
2380         return 0;
2381 }
2382 EXPORT_SYMBOL_GPL(hisi_sas_remove);
2383
2384 static __init int hisi_sas_init(void)
2385 {
2386         hisi_sas_stt = sas_domain_attach_transport(&hisi_sas_transport_ops);
2387         if (!hisi_sas_stt)
2388                 return -ENOMEM;
2389
2390         return 0;
2391 }
2392
2393 static __exit void hisi_sas_exit(void)
2394 {
2395         sas_release_transport(hisi_sas_stt);
2396 }
2397
2398 module_init(hisi_sas_init);
2399 module_exit(hisi_sas_exit);
2400
2401 MODULE_LICENSE("GPL");
2402 MODULE_AUTHOR("John Garry <john.garry@huawei.com>");
2403 MODULE_DESCRIPTION("HISILICON SAS controller driver");
2404 MODULE_ALIAS("platform:" DRV_NAME);