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