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