hisi_sas_main.c 73.3 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-or-later
2 3 4 5 6 7 8 9
/*
 * Copyright (c) 2015 Linaro Ltd.
 * Copyright (c) 2015 Hisilicon Limited.
 */

#include "hisi_sas.h"
#define DRV_NAME "hisi_sas"

J
John Garry 已提交
10 11 12
#define DEV_IS_GONE(dev) \
	((!dev) || (dev->dev_type == SAS_PHY_UNUSED))

J
John Garry 已提交
13 14
static int hisi_sas_debug_issue_ssp_tmf(struct domain_device *device,
				u8 *lun, struct hisi_sas_tmf_task *tmf);
15 16 17 18
static int
hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
			     struct domain_device *device,
			     int abort_flag, int tag);
19
static int hisi_sas_softreset_ata_disk(struct domain_device *device);
20 21
static int hisi_sas_control_phy(struct asd_sas_phy *sas_phy, enum phy_func func,
				void *funcdata);
22 23 24
static void hisi_sas_release_task(struct hisi_hba *hisi_hba,
				  struct domain_device *device);
static void hisi_sas_dev_gone(struct domain_device *device);
J
John Garry 已提交
25

26
u8 hisi_sas_get_ata_protocol(struct host_to_dev_fis *fis, int direction)
27
{
28
	switch (fis->command) {
29 30 31 32 33
	case ATA_CMD_FPDMA_WRITE:
	case ATA_CMD_FPDMA_READ:
	case ATA_CMD_FPDMA_RECV:
	case ATA_CMD_FPDMA_SEND:
	case ATA_CMD_NCQ_NON_DATA:
34
		return HISI_SAS_SATA_PROTOCOL_FPDMA;
35 36 37 38 39 40 41 42 43 44 45

	case ATA_CMD_DOWNLOAD_MICRO:
	case ATA_CMD_ID_ATA:
	case ATA_CMD_PMP_READ:
	case ATA_CMD_READ_LOG_EXT:
	case ATA_CMD_PIO_READ:
	case ATA_CMD_PIO_READ_EXT:
	case ATA_CMD_PMP_WRITE:
	case ATA_CMD_WRITE_LOG_EXT:
	case ATA_CMD_PIO_WRITE:
	case ATA_CMD_PIO_WRITE_EXT:
46
		return HISI_SAS_SATA_PROTOCOL_PIO;
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

	case ATA_CMD_DSM:
	case ATA_CMD_DOWNLOAD_MICRO_DMA:
	case ATA_CMD_PMP_READ_DMA:
	case ATA_CMD_PMP_WRITE_DMA:
	case ATA_CMD_READ:
	case ATA_CMD_READ_EXT:
	case ATA_CMD_READ_LOG_DMA_EXT:
	case ATA_CMD_READ_STREAM_DMA_EXT:
	case ATA_CMD_TRUSTED_RCV_DMA:
	case ATA_CMD_TRUSTED_SND_DMA:
	case ATA_CMD_WRITE:
	case ATA_CMD_WRITE_EXT:
	case ATA_CMD_WRITE_FUA_EXT:
	case ATA_CMD_WRITE_QUEUED:
	case ATA_CMD_WRITE_LOG_DMA_EXT:
	case ATA_CMD_WRITE_STREAM_DMA_EXT:
64
	case ATA_CMD_ZAC_MGMT_IN:
65
		return HISI_SAS_SATA_PROTOCOL_DMA;
66 67 68 69 70 71 72 73 74 75 76

	case ATA_CMD_CHK_POWER:
	case ATA_CMD_DEV_RESET:
	case ATA_CMD_EDD:
	case ATA_CMD_FLUSH:
	case ATA_CMD_FLUSH_EXT:
	case ATA_CMD_VERIFY:
	case ATA_CMD_VERIFY_EXT:
	case ATA_CMD_SET_FEATURES:
	case ATA_CMD_STANDBY:
	case ATA_CMD_STANDBYNOW1:
77
	case ATA_CMD_ZAC_MGMT_OUT:
78
		return HISI_SAS_SATA_PROTOCOL_NONDATA;
79

80 81 82 83 84
	case ATA_CMD_SET_MAX:
		switch (fis->features) {
		case ATA_SET_MAX_PASSWD:
		case ATA_SET_MAX_LOCK:
			return HISI_SAS_SATA_PROTOCOL_PIO;
85

86 87 88 89 90 91
		case ATA_SET_MAX_PASSWD_DMA:
		case ATA_SET_MAX_UNLOCK_DMA:
			return HISI_SAS_SATA_PROTOCOL_DMA;

		default:
			return HISI_SAS_SATA_PROTOCOL_NONDATA;
92
		}
93 94 95

	default:
	{
96 97 98 99
		if (direction == DMA_NONE)
			return HISI_SAS_SATA_PROTOCOL_NONDATA;
		return HISI_SAS_SATA_PROTOCOL_PIO;
	}
100
	}
101 102 103
}
EXPORT_SYMBOL_GPL(hisi_sas_get_ata_protocol);

104 105 106 107 108
void hisi_sas_sata_done(struct sas_task *task,
			    struct hisi_sas_slot *slot)
{
	struct task_status_struct *ts = &task->task_status;
	struct ata_task_resp *resp = (struct ata_task_resp *)ts->buf;
109 110 111 112
	struct hisi_sas_status_buffer *status_buf =
			hisi_sas_status_buf_addr_mem(slot);
	u8 *iu = &status_buf->iu[0];
	struct dev_to_host_fis *d2h =  (struct dev_to_host_fis *)iu;
113 114 115 116 117 118 119 120

	resp->frame_len = sizeof(struct dev_to_host_fis);
	memcpy(&resp->ending_fis[0], d2h, sizeof(struct dev_to_host_fis));

	ts->buf_valid_size = sizeof(*resp);
}
EXPORT_SYMBOL_GPL(hisi_sas_sata_done);

121 122 123 124 125 126
/*
 * This function assumes linkrate mask fits in 8 bits, which it
 * does for all HW versions supported.
 */
u8 hisi_sas_get_prog_phy_linkrate_mask(enum sas_linkrate max)
{
127
	u8 rate = 0;
128 129 130 131 132 133 134 135 136
	int i;

	max -= SAS_LINK_RATE_1_5_GBPS;
	for (i = 0; i <= max; i++)
		rate |= 1 << (i * 2);
	return rate;
}
EXPORT_SYMBOL_GPL(hisi_sas_get_prog_phy_linkrate_mask);

J
John Garry 已提交
137 138 139 140 141
static struct hisi_hba *dev_to_hisi_hba(struct domain_device *device)
{
	return device->port->ha->lldd_ha;
}

142 143 144 145 146 147
struct hisi_sas_port *to_hisi_sas_port(struct asd_sas_port *sas_port)
{
	return container_of(sas_port, struct hisi_sas_port, sas_port);
}
EXPORT_SYMBOL_GPL(to_hisi_sas_port);

148 149 150 151 152
void hisi_sas_stop_phys(struct hisi_hba *hisi_hba)
{
	int phy_no;

	for (phy_no = 0; phy_no < hisi_hba->n_phy; phy_no++)
153
		hisi_sas_phy_enable(hisi_hba, phy_no, 0);
154 155 156
}
EXPORT_SYMBOL_GPL(hisi_sas_stop_phys);

J
John Garry 已提交
157 158 159 160 161 162 163
static void hisi_sas_slot_index_clear(struct hisi_hba *hisi_hba, int slot_idx)
{
	void *bitmap = hisi_hba->slot_index_tags;

	clear_bit(slot_idx, bitmap);
}

J
John Garry 已提交
164 165
static void hisi_sas_slot_index_free(struct hisi_hba *hisi_hba, int slot_idx)
{
166 167
	if (hisi_hba->hw->slot_index_alloc ||
	    slot_idx >= HISI_SAS_UNRESERVED_IPTT) {
168
		spin_lock(&hisi_hba->lock);
169
		hisi_sas_slot_index_clear(hisi_hba, slot_idx);
170
		spin_unlock(&hisi_hba->lock);
171
	}
J
John Garry 已提交
172 173 174 175 176 177 178 179 180
}

static void hisi_sas_slot_index_set(struct hisi_hba *hisi_hba, int slot_idx)
{
	void *bitmap = hisi_hba->slot_index_tags;

	set_bit(slot_idx, bitmap);
}

181 182
static int hisi_sas_slot_index_alloc(struct hisi_hba *hisi_hba,
				     struct scsi_cmnd *scsi_cmnd)
J
John Garry 已提交
183
{
184
	int index;
J
John Garry 已提交
185 186
	void *bitmap = hisi_hba->slot_index_tags;

187 188 189
	if (scsi_cmnd)
		return scsi_cmnd->request->tag;

190
	spin_lock(&hisi_hba->lock);
191
	index = find_next_zero_bit(bitmap, hisi_hba->slot_index_count,
192
				   hisi_hba->last_slot_index + 1);
193
	if (index >= hisi_hba->slot_index_count) {
194 195
		index = find_next_zero_bit(bitmap,
				hisi_hba->slot_index_count,
196
				HISI_SAS_UNRESERVED_IPTT);
197
		if (index >= hisi_hba->slot_index_count) {
198
			spin_unlock(&hisi_hba->lock);
199
			return -SAS_QUEUE_FULL;
200
		}
201
	}
J
John Garry 已提交
202
	hisi_sas_slot_index_set(hisi_hba, index);
203
	hisi_hba->last_slot_index = index;
204
	spin_unlock(&hisi_hba->lock);
205

206
	return index;
J
John Garry 已提交
207 208
}

J
John Garry 已提交
209 210 211 212 213 214 215
static void hisi_sas_slot_index_init(struct hisi_hba *hisi_hba)
{
	int i;

	for (i = 0; i < hisi_hba->slot_index_count; ++i)
		hisi_sas_slot_index_clear(hisi_hba, i);
}
J
John Garry 已提交
216 217 218 219

void hisi_sas_slot_task_free(struct hisi_hba *hisi_hba, struct sas_task *task,
			     struct hisi_sas_slot *slot)
{
220 221
	int device_id = slot->device_id;
	struct hisi_sas_device *sas_dev = &hisi_hba->devices[device_id];
J
John Garry 已提交
222

223
	if (task) {
224
		struct device *dev = hisi_hba->dev;
J
John Garry 已提交
225

226 227 228 229 230
		if (!task->lldd_task)
			return;

		task->lldd_task = NULL;

231
		if (!sas_protocol_ata(task->task_proto)) {
232
			if (slot->n_elem)
233 234
				dma_unmap_sg(dev, task->scatter,
					     task->num_scatter,
235
					     task->data_dir);
236 237 238 239
			if (slot->n_elem_dif) {
				struct sas_ssp_task *ssp_task = &task->ssp_task;
				struct scsi_cmnd *scsi_cmnd = ssp_task->cmd;

240 241 242
				dma_unmap_sg(dev, scsi_prot_sglist(scsi_cmnd),
					     scsi_prot_sg_count(scsi_cmnd),
					     task->data_dir);
243
			}
244
		}
245
	}
J
John Garry 已提交
246

247
	spin_lock(&sas_dev->lock);
J
John Garry 已提交
248
	list_del_init(&slot->entry);
249
	spin_unlock(&sas_dev->lock);
250 251 252

	memset(slot, 0, offsetof(struct hisi_sas_slot, buf));

J
John Garry 已提交
253 254 255 256
	hisi_sas_slot_index_free(hisi_hba, slot->idx);
}
EXPORT_SYMBOL_GPL(hisi_sas_slot_task_free);

257
static void hisi_sas_task_prep_smp(struct hisi_hba *hisi_hba,
J
John Garry 已提交
258 259
				  struct hisi_sas_slot *slot)
{
260
	hisi_hba->hw->prep_smp(hisi_hba, slot);
J
John Garry 已提交
261 262
}

263
static void hisi_sas_task_prep_ssp(struct hisi_hba *hisi_hba,
264
				  struct hisi_sas_slot *slot)
J
John Garry 已提交
265
{
266
	hisi_hba->hw->prep_ssp(hisi_hba, slot);
J
John Garry 已提交
267 268
}

269
static void hisi_sas_task_prep_ata(struct hisi_hba *hisi_hba,
270 271
				  struct hisi_sas_slot *slot)
{
272
	hisi_hba->hw->prep_stp(hisi_hba, slot);
273 274
}

275
static void hisi_sas_task_prep_abort(struct hisi_hba *hisi_hba,
276 277 278
		struct hisi_sas_slot *slot,
		int device_id, int abort_flag, int tag_to_abort)
{
279
	hisi_hba->hw->prep_abort(hisi_hba, slot,
280 281 282
			device_id, abort_flag, tag_to_abort);
}

283 284
static void hisi_sas_dma_unmap(struct hisi_hba *hisi_hba,
			       struct sas_task *task, int n_elem,
285
			       int n_elem_req)
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
{
	struct device *dev = hisi_hba->dev;

	if (!sas_protocol_ata(task->task_proto)) {
		if (task->num_scatter) {
			if (n_elem)
				dma_unmap_sg(dev, task->scatter,
					     task->num_scatter,
					     task->data_dir);
		} else if (task->task_proto & SAS_PROTOCOL_SMP) {
			if (n_elem_req)
				dma_unmap_sg(dev, &task->smp_task.smp_req,
					     1, DMA_TO_DEVICE);
		}
	}
}

static int hisi_sas_dma_map(struct hisi_hba *hisi_hba,
			    struct sas_task *task, int *n_elem,
305
			    int *n_elem_req)
306 307 308 309 310 311 312
{
	struct device *dev = hisi_hba->dev;
	int rc;

	if (sas_protocol_ata(task->task_proto)) {
		*n_elem = task->num_scatter;
	} else {
313
		unsigned int req_len;
314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337

		if (task->num_scatter) {
			*n_elem = dma_map_sg(dev, task->scatter,
					     task->num_scatter, task->data_dir);
			if (!*n_elem) {
				rc = -ENOMEM;
				goto prep_out;
			}
		} else if (task->task_proto & SAS_PROTOCOL_SMP) {
			*n_elem_req = dma_map_sg(dev, &task->smp_task.smp_req,
						 1, DMA_TO_DEVICE);
			if (!*n_elem_req) {
				rc = -ENOMEM;
				goto prep_out;
			}
			req_len = sg_dma_len(&task->smp_task.smp_req);
			if (req_len & 0x3) {
				rc = -EINVAL;
				goto err_out_dma_unmap;
			}
		}
	}

	if (*n_elem > HISI_SAS_SGE_PAGE_CNT) {
338
		dev_err(dev, "task prep: n_elem(%d) > HISI_SAS_SGE_PAGE_CNT\n",
339 340 341 342 343 344 345 346 347
			*n_elem);
		rc = -EINVAL;
		goto err_out_dma_unmap;
	}
	return 0;

err_out_dma_unmap:
	/* It would be better to call dma_unmap_sg() here, but it's messy */
	hisi_sas_dma_unmap(hisi_hba, task, *n_elem,
348
			   *n_elem_req);
349 350 351 352
prep_out:
	return rc;
}

353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
static void hisi_sas_dif_dma_unmap(struct hisi_hba *hisi_hba,
				   struct sas_task *task, int n_elem_dif)
{
	struct device *dev = hisi_hba->dev;

	if (n_elem_dif) {
		struct sas_ssp_task *ssp_task = &task->ssp_task;
		struct scsi_cmnd *scsi_cmnd = ssp_task->cmd;

		dma_unmap_sg(dev, scsi_prot_sglist(scsi_cmnd),
			     scsi_prot_sg_count(scsi_cmnd),
			     task->data_dir);
	}
}

static int hisi_sas_dif_dma_map(struct hisi_hba *hisi_hba,
				int *n_elem_dif, struct sas_task *task)
{
	struct device *dev = hisi_hba->dev;
	struct sas_ssp_task *ssp_task;
	struct scsi_cmnd *scsi_cmnd;
	int rc;

	if (task->num_scatter) {
		ssp_task = &task->ssp_task;
		scsi_cmnd = ssp_task->cmd;

		if (scsi_prot_sg_count(scsi_cmnd)) {
			*n_elem_dif = dma_map_sg(dev,
						 scsi_prot_sglist(scsi_cmnd),
						 scsi_prot_sg_count(scsi_cmnd),
						 task->data_dir);

			if (!*n_elem_dif)
				return -ENOMEM;

			if (*n_elem_dif > HISI_SAS_SGE_DIF_PAGE_CNT) {
				dev_err(dev, "task prep: n_elem_dif(%d) too large\n",
					*n_elem_dif);
				rc = -EINVAL;
				goto err_out_dif_dma_unmap;
			}
		}
	}

	return 0;

err_out_dif_dma_unmap:
	dma_unmap_sg(dev, scsi_prot_sglist(scsi_cmnd),
		     scsi_prot_sg_count(scsi_cmnd), task->data_dir);
	return rc;
}

406 407
static int hisi_sas_task_prep(struct sas_task *task,
			      struct hisi_sas_dq **dq_pointer,
408
			      bool is_tmf, struct hisi_sas_tmf_task *tmf,
409
			      int *pass)
J
John Garry 已提交
410 411
{
	struct domain_device *device = task->dev;
412
	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
J
John Garry 已提交
413 414 415 416
	struct hisi_sas_device *sas_dev = device->lldd_dev;
	struct hisi_sas_port *port;
	struct hisi_sas_slot *slot;
	struct hisi_sas_cmd_hdr	*cmd_hdr_base;
417
	struct asd_sas_port *sas_port = device->port;
418
	struct device *dev = hisi_hba->dev;
X
Xiang Chen 已提交
419
	int dlvry_queue_slot, dlvry_queue, rc, slot_idx;
420
	int n_elem = 0, n_elem_dif = 0, n_elem_req = 0;
J
John Garry 已提交
421
	struct scsi_cmnd *scmd = NULL;
422
	struct hisi_sas_dq *dq;
423
	unsigned long flags;
424
	int wr_q_index;
J
John Garry 已提交
425 426 427

	if (DEV_IS_GONE(sas_dev)) {
		if (sas_dev)
428
			dev_info(dev, "task prep: device %d not ready\n",
J
John Garry 已提交
429 430 431 432 433
				 sas_dev->device_id);
		else
			dev_info(dev, "task prep: device %016llx not ready\n",
				 SAS_ADDR(device->sas_addr));

434
		return -ECOMM;
J
John Garry 已提交
435
	}
436

J
John Garry 已提交
437 438
	if (task->uldd_task) {
		struct ata_queued_cmd *qc;
439

J
John Garry 已提交
440 441 442 443 444 445 446 447
		if (dev_is_sata(device)) {
			qc = task->uldd_task;
			scmd = qc->scsicmd;
		} else {
			scmd = task->uldd_task;
		}
	}

448
	if (scmd) {
J
John Garry 已提交
449 450 451 452 453
		unsigned int dq_index;
		u32 blk_tag;

		blk_tag = blk_mq_unique_tag(scmd->request);
		dq_index = blk_mq_unique_tag_to_hwq(blk_tag);
454
		*dq_pointer = dq = &hisi_hba->dq[dq_index];
455
	} else {
456 457 458 459 460
		struct Scsi_Host *shost = hisi_hba->shost;
		struct blk_mq_queue_map *qmap = &shost->tag_set.map[HCTX_TYPE_DEFAULT];
		int queue = qmap->mq_map[raw_smp_processor_id()];

		*dq_pointer = dq = &hisi_hba->dq[queue];
461
	}
462

463
	port = to_hisi_sas_port(sas_port);
464
	if (port && !port->port_attached) {
465
		dev_info(dev, "task prep: %s port%d not attach device\n",
466
			 (dev_is_sata(device)) ?
467 468 469
			 "SATA/STP" : "SAS",
			 device->port->id);

470
		return -ECOMM;
J
John Garry 已提交
471 472
	}

473
	rc = hisi_sas_dma_map(hisi_hba, task, &n_elem,
474
			      &n_elem_req);
475 476
	if (rc < 0)
		goto prep_out;
477

478 479 480 481 482 483
	if (!sas_protocol_ata(task->task_proto)) {
		rc = hisi_sas_dif_dma_map(hisi_hba, &n_elem_dif, task);
		if (rc < 0)
			goto err_out_dma_unmap;
	}

484
	if (hisi_hba->hw->slot_index_alloc)
485
		rc = hisi_hba->hw->slot_index_alloc(hisi_hba, device);
J
John Garry 已提交
486 487
	else
		rc = hisi_sas_slot_index_alloc(hisi_hba, scmd);
488 489

	if (rc < 0)
490
		goto err_out_dif_dma_unmap;
491

492
	slot_idx = rc;
493 494
	slot = &hisi_hba->slot_info[slot_idx];

495
	spin_lock(&dq->lock);
496 497
	wr_q_index = dq->wr_point;
	dq->wr_point = (dq->wr_point + 1) % HISI_SAS_QUEUE_SLOTS;
498
	list_add_tail(&slot->delivery, &dq->list);
499 500
	spin_unlock(&dq->lock);
	spin_lock(&sas_dev->lock);
501
	list_add_tail(&slot->entry, &sas_dev->list);
502
	spin_unlock(&sas_dev->lock);
J
John Garry 已提交
503

504
	dlvry_queue = dq->id;
505
	dlvry_queue_slot = wr_q_index;
J
John Garry 已提交
506

507
	slot->device_id = sas_dev->device_id;
J
John Garry 已提交
508
	slot->n_elem = n_elem;
509
	slot->n_elem_dif = n_elem_dif;
J
John Garry 已提交
510 511 512 513 514 515
	slot->dlvry_queue = dlvry_queue;
	slot->dlvry_queue_slot = dlvry_queue_slot;
	cmd_hdr_base = hisi_hba->cmd_hdr[dlvry_queue];
	slot->cmd_hdr = &cmd_hdr_base[dlvry_queue_slot];
	slot->task = task;
	slot->port = port;
516 517
	slot->tmf = tmf;
	slot->is_internal = is_tmf;
J
John Garry 已提交
518 519 520
	task->lldd_task = slot;

	memset(slot->cmd_hdr, 0, sizeof(struct hisi_sas_cmd_hdr));
521
	memset(hisi_sas_cmd_hdr_addr_mem(slot), 0, HISI_SAS_COMMAND_TABLE_SZ);
522 523
	memset(hisi_sas_status_buf_addr_mem(slot), 0,
	       sizeof(struct hisi_sas_err_record));
J
John Garry 已提交
524 525

	switch (task->task_proto) {
J
John Garry 已提交
526
	case SAS_PROTOCOL_SMP:
527
		hisi_sas_task_prep_smp(hisi_hba, slot);
J
John Garry 已提交
528
		break;
J
John Garry 已提交
529
	case SAS_PROTOCOL_SSP:
530
		hisi_sas_task_prep_ssp(hisi_hba, slot);
J
John Garry 已提交
531 532 533 534
		break;
	case SAS_PROTOCOL_SATA:
	case SAS_PROTOCOL_STP:
	case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
535
		hisi_sas_task_prep_ata(hisi_hba, slot);
536
		break;
J
John Garry 已提交
537 538 539 540 541 542
	default:
		dev_err(dev, "task prep: unknown/unsupported proto (0x%x)\n",
			task->task_proto);
		break;
	}

543
	spin_lock_irqsave(&task->task_state_lock, flags);
J
John Garry 已提交
544
	task->task_state_flags |= SAS_TASK_AT_INITIATOR;
545
	spin_unlock_irqrestore(&task->task_state_lock, flags);
J
John Garry 已提交
546 547

	++(*pass);
548
	WRITE_ONCE(slot->ready, 1);
J
John Garry 已提交
549

550
	return 0;
J
John Garry 已提交
551

552 553 554
err_out_dif_dma_unmap:
	if (!sas_protocol_ata(task->task_proto))
		hisi_sas_dif_dma_unmap(hisi_hba, task, n_elem_dif);
X
Xiang Chen 已提交
555
err_out_dma_unmap:
556
	hisi_sas_dma_unmap(hisi_hba, task, n_elem,
557
			   n_elem_req);
J
John Garry 已提交
558
prep_out:
X
Xiang Chen 已提交
559
	dev_err(dev, "task prep: failed[%d]!\n", rc);
J
John Garry 已提交
560 561 562 563
	return rc;
}

static int hisi_sas_task_exec(struct sas_task *task, gfp_t gfp_flags,
564
			      bool is_tmf, struct hisi_sas_tmf_task *tmf)
J
John Garry 已提交
565 566 567
{
	u32 rc;
	u32 pass = 0;
568 569 570 571
	struct hisi_hba *hisi_hba;
	struct device *dev;
	struct domain_device *device = task->dev;
	struct asd_sas_port *sas_port = device->port;
572
	struct hisi_sas_dq *dq = NULL;
J
John Garry 已提交
573

574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
	if (!sas_port) {
		struct task_status_struct *ts = &task->task_status;

		ts->resp = SAS_TASK_UNDELIVERED;
		ts->stat = SAS_PHY_DOWN;
		/*
		 * libsas will use dev->port, should
		 * not call task_done for sata
		 */
		if (device->dev_type != SAS_SATA_DEV)
			task->task_done(task);
		return -ECOMM;
	}

	hisi_hba = dev_to_hisi_hba(device);
	dev = hisi_hba->dev;

591
	if (unlikely(test_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags))) {
592
		if (!gfpflags_allow_blocking(gfp_flags))
593 594 595 596 597
			return -EINVAL;

		down(&hisi_hba->sem);
		up(&hisi_hba->sem);
	}
598

J
John Garry 已提交
599
	/* protect task_prep and start_delivery sequence */
600
	rc = hisi_sas_task_prep(task, &dq, is_tmf, tmf, &pass);
J
John Garry 已提交
601 602 603
	if (rc)
		dev_err(dev, "task exec: failed[%d]!\n", rc);

604
	if (likely(pass)) {
605
		spin_lock(&dq->lock);
606
		hisi_hba->hw->start_delivery(dq);
607
		spin_unlock(&dq->lock);
608
	}
J
John Garry 已提交
609 610 611

	return rc;
}
J
John Garry 已提交
612

613 614
static void hisi_sas_bytes_dmaed(struct hisi_hba *hisi_hba, int phy_no,
				 gfp_t gfp_flags)
615 616 617 618 619 620 621
{
	struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
	struct asd_sas_phy *sas_phy = &phy->sas_phy;

	if (!phy->phy_attached)
		return;

622 623 624 625 626 627
	if (test_bit(HISI_SAS_PM_BIT, &hisi_hba->flags) &&
	    !sas_phy->suspended) {
		dev_warn(hisi_hba->dev, "phy%d during suspend filtered out\n", phy_no);
		return;
	}

628
	sas_notify_phy_event(sas_phy, PHYE_OOB_DONE, gfp_flags);
629 630 631 632 633 634

	if (sas_phy->phy) {
		struct sas_phy *sphy = sas_phy->phy;

		sphy->negotiated_linkrate = sas_phy->linkrate;
		sphy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
635 636 637 638 639 640 641
		sphy->maximum_linkrate_hw =
			hisi_hba->hw->phy_get_max_linkrate();
		if (sphy->minimum_linkrate == SAS_LINK_RATE_UNKNOWN)
			sphy->minimum_linkrate = phy->minimum_linkrate;

		if (sphy->maximum_linkrate == SAS_LINK_RATE_UNKNOWN)
			sphy->maximum_linkrate = phy->maximum_linkrate;
642 643 644 645 646 647 648 649 650 651
	}

	if (phy->phy_type & PORT_TYPE_SAS) {
		struct sas_identify_frame *id;

		id = (struct sas_identify_frame *)phy->frame_rcvd;
		id->dev_type = phy->identify.device_type;
		id->initiator_bits = SAS_PROTOCOL_ALL;
		id->target_bits = phy->identify.target_port_protocols;
	} else if (phy->phy_type & PORT_TYPE_SATA) {
X
Xiang Chen 已提交
652
		/* Nothing */
653 654 655
	}

	sas_phy->frame_rcvd_size = phy->frame_rcvd_size;
656
	sas_notify_port_event(sas_phy, PORTE_BYTES_DMAED, gfp_flags);
657 658
}

J
John Garry 已提交
659 660 661 662
static struct hisi_sas_device *hisi_sas_alloc_dev(struct domain_device *device)
{
	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
	struct hisi_sas_device *sas_dev = NULL;
663 664
	int last = hisi_hba->last_dev_id;
	int first = (hisi_hba->last_dev_id + 1) % HISI_SAS_MAX_DEVICES;
J
John Garry 已提交
665 666
	int i;

667
	spin_lock(&hisi_hba->lock);
668
	for (i = first; i != last; i %= HISI_SAS_MAX_DEVICES) {
J
John Garry 已提交
669
		if (hisi_hba->devices[i].dev_type == SAS_PHY_UNUSED) {
670 671 672
			int queue = i % hisi_hba->queue_count;
			struct hisi_sas_dq *dq = &hisi_hba->dq[queue];

J
John Garry 已提交
673 674
			hisi_hba->devices[i].device_id = i;
			sas_dev = &hisi_hba->devices[i];
675
			sas_dev->dev_status = HISI_SAS_DEV_INIT;
J
John Garry 已提交
676 677 678
			sas_dev->dev_type = device->dev_type;
			sas_dev->hisi_hba = hisi_hba;
			sas_dev->sas_device = device;
679
			sas_dev->dq = dq;
680
			spin_lock_init(&sas_dev->lock);
681
			INIT_LIST_HEAD(&hisi_hba->devices[i].list);
J
John Garry 已提交
682 683
			break;
		}
684
		i++;
J
John Garry 已提交
685
	}
686
	hisi_hba->last_dev_id = i;
687
	spin_unlock(&hisi_hba->lock);
J
John Garry 已提交
688 689 690 691

	return sas_dev;
}

692
#define HISI_SAS_DISK_RECOVER_CNT 3
693 694 695 696 697
static int hisi_sas_init_device(struct domain_device *device)
{
	int rc = TMF_RESP_FUNC_COMPLETE;
	struct scsi_lun lun;
	struct hisi_sas_tmf_task tmf_task;
698
	int retry = HISI_SAS_DISK_RECOVER_CNT;
699
	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
700 701
	struct device *dev = hisi_hba->dev;
	struct sas_phy *local_phy;
702 703 704 705 706 707

	switch (device->dev_type) {
	case SAS_END_DEVICE:
		int_to_scsilun(0, &lun);

		tmf_task.tmf = TMF_CLEAR_TASK_SET;
708 709 710 711 712 713 714 715
		while (retry-- > 0) {
			rc = hisi_sas_debug_issue_ssp_tmf(device, lun.scsi_lun,
							  &tmf_task);
			if (rc == TMF_RESP_FUNC_COMPLETE) {
				hisi_sas_release_task(hisi_hba, device);
				break;
			}
		}
716 717 718 719 720
		break;
	case SAS_SATA_DEV:
	case SAS_SATA_PM:
	case SAS_SATA_PM_PORT:
	case SAS_SATA_PENDING:
721 722 723 724 725
		/*
		 * send HARD RESET to clear previous affiliation of
		 * STP target port
		 */
		local_phy = sas_get_local_phy(device);
726 727
		if (!scsi_is_sas_phy_local(local_phy) &&
		    !test_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags)) {
728 729 730 731 732 733 734 735 736 737 738 739 740 741
			unsigned long deadline = ata_deadline(jiffies, 20000);
			struct sata_device *sata_dev = &device->sata_dev;
			struct ata_host *ata_host = sata_dev->ata_host;
			struct ata_port_operations *ops = ata_host->ops;
			struct ata_port *ap = sata_dev->ap;
			struct ata_link *link;
			unsigned int classes;

			ata_for_each_link(link, ap, EDGE)
				rc = ops->hardreset(link, &classes,
						    deadline);
		}
		sas_put_local_phy(local_phy);
		if (rc) {
742
			dev_warn(dev, "SATA disk hardreset fail: %d\n", rc);
743 744 745
			return rc;
		}

746 747 748 749 750 751 752 753 754 755 756 757 758
		while (retry-- > 0) {
			rc = hisi_sas_softreset_ata_disk(device);
			if (!rc)
				break;
		}
		break;
	default:
		break;
	}

	return rc;
}

J
John Garry 已提交
759 760 761 762 763
static int hisi_sas_dev_found(struct domain_device *device)
{
	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
	struct domain_device *parent_dev = device->parent;
	struct hisi_sas_device *sas_dev;
764
	struct device *dev = hisi_hba->dev;
765
	int rc;
J
John Garry 已提交
766

767 768 769 770
	if (hisi_hba->hw->alloc_dev)
		sas_dev = hisi_hba->hw->alloc_dev(device);
	else
		sas_dev = hisi_sas_alloc_dev(device);
J
John Garry 已提交
771 772 773 774 775 776 777 778 779
	if (!sas_dev) {
		dev_err(dev, "fail alloc dev: max support %d devices\n",
			HISI_SAS_MAX_DEVICES);
		return -EINVAL;
	}

	device->lldd_dev = sas_dev;
	hisi_hba->hw->setup_itct(hisi_hba, sas_dev);

780
	if (parent_dev && dev_is_expander(parent_dev->dev_type)) {
J
John Garry 已提交
781 782 783 784 785 786 787
		int phy_no;
		u8 phy_num = parent_dev->ex_dev.num_phys;
		struct ex_phy *phy;

		for (phy_no = 0; phy_no < phy_num; phy_no++) {
			phy = &parent_dev->ex_dev.ex_phy[phy_no];
			if (SAS_ADDR(phy->attached_sas_addr) ==
788
				SAS_ADDR(device->sas_addr))
J
John Garry 已提交
789 790 791 792 793 794 795 796
				break;
		}

		if (phy_no == phy_num) {
			dev_info(dev, "dev found: no attached "
				 "dev:%016llx at ex:%016llx\n",
				 SAS_ADDR(device->sas_addr),
				 SAS_ADDR(parent_dev->sas_addr));
797 798
			rc = -EINVAL;
			goto err_out;
J
John Garry 已提交
799 800 801
		}
	}

802 803 804
	dev_info(dev, "dev[%d:%x] found\n",
		sas_dev->device_id, sas_dev->dev_type);

805 806 807
	rc = hisi_sas_init_device(device);
	if (rc)
		goto err_out;
808
	sas_dev->dev_status = HISI_SAS_DEV_NORMAL;
J
John Garry 已提交
809
	return 0;
810 811 812 813

err_out:
	hisi_sas_dev_gone(device);
	return rc;
J
John Garry 已提交
814 815
}

816
int hisi_sas_slave_configure(struct scsi_device *sdev)
817 818 819 820 821 822 823 824 825 826 827
{
	struct domain_device *dev = sdev_to_domain_dev(sdev);
	int ret = sas_slave_configure(sdev);

	if (ret)
		return ret;
	if (!dev_is_sata(dev))
		sas_change_queue_depth(sdev, 64);

	return 0;
}
828
EXPORT_SYMBOL_GPL(hisi_sas_slave_configure);
829

830
void hisi_sas_scan_start(struct Scsi_Host *shost)
J
John Garry 已提交
831 832 833
{
	struct hisi_hba *hisi_hba = shost_priv(shost);

834
	hisi_hba->hw->phys_init(hisi_hba);
J
John Garry 已提交
835
}
836
EXPORT_SYMBOL_GPL(hisi_sas_scan_start);
J
John Garry 已提交
837

838
int hisi_sas_scan_finished(struct Scsi_Host *shost, unsigned long time)
J
John Garry 已提交
839 840 841 842
{
	struct hisi_hba *hisi_hba = shost_priv(shost);
	struct sas_ha_struct *sha = &hisi_hba->sha;

843 844
	/* Wait for PHY up interrupt to occur */
	if (time < HZ)
J
John Garry 已提交
845 846 847 848 849
		return 0;

	sas_drain_work(sha);
	return 1;
}
850
EXPORT_SYMBOL_GPL(hisi_sas_scan_finished);
J
John Garry 已提交
851

852 853 854
static void hisi_sas_phyup_work(struct work_struct *work)
{
	struct hisi_sas_phy *phy =
855
		container_of(work, typeof(*phy), works[HISI_PHYE_PHY_UP]);
856 857 858 859
	struct hisi_hba *hisi_hba = phy->hisi_hba;
	struct asd_sas_phy *sas_phy = &phy->sas_phy;
	int phy_no = sas_phy->id;

860
	phy->wait_phyup_cnt = 0;
861 862
	if (phy->identify.target_port_protocols == SAS_PROTOCOL_SSP)
		hisi_hba->hw->sl_notify_ssp(hisi_hba, phy_no);
863
	hisi_sas_bytes_dmaed(hisi_hba, phy_no, GFP_KERNEL);
864
}
J
John Garry 已提交
865

866 867 868 869 870 871 872 873 874
static void hisi_sas_linkreset_work(struct work_struct *work)
{
	struct hisi_sas_phy *phy =
		container_of(work, typeof(*phy), works[HISI_PHYE_LINK_RESET]);
	struct asd_sas_phy *sas_phy = &phy->sas_phy;

	hisi_sas_control_phy(sas_phy, PHY_FUNC_LINK_RESET, NULL);
}

875 876
static const work_func_t hisi_sas_phye_fns[HISI_PHYES_NUM] = {
	[HISI_PHYE_PHY_UP] = hisi_sas_phyup_work,
877
	[HISI_PHYE_LINK_RESET] = hisi_sas_linkreset_work,
878 879 880 881 882 883 884 885 886 887 888 889 890 891
};

bool hisi_sas_notify_phy_event(struct hisi_sas_phy *phy,
				enum hisi_sas_phy_event event)
{
	struct hisi_hba *hisi_hba = phy->hisi_hba;

	if (WARN_ON(event >= HISI_PHYES_NUM))
		return false;

	return queue_work(hisi_hba->wq, &phy->works[event]);
}
EXPORT_SYMBOL_GPL(hisi_sas_notify_phy_event);

892 893 894 895 896 897 898 899 900 901 902
static void hisi_sas_wait_phyup_timedout(struct timer_list *t)
{
	struct hisi_sas_phy *phy = from_timer(phy, t, timer);
	struct hisi_hba *hisi_hba = phy->hisi_hba;
	struct device *dev = hisi_hba->dev;
	int phy_no = phy->sas_phy.id;

	dev_warn(dev, "phy%d wait phyup timeout, issuing link reset\n", phy_no);
	hisi_sas_notify_phy_event(phy, HISI_PHYE_LINK_RESET);
}

903 904
#define HISI_SAS_WAIT_PHYUP_RETRIES	10

905 906 907 908 909
void hisi_sas_phy_oob_ready(struct hisi_hba *hisi_hba, int phy_no)
{
	struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
	struct device *dev = hisi_hba->dev;

910 911 912 913
	dev_dbg(dev, "phy%d OOB ready\n", phy_no);
	if (phy->phy_attached)
		return;

914
	if (!timer_pending(&phy->timer)) {
915 916 917 918 919 920 921 922 923 924
		if (phy->wait_phyup_cnt < HISI_SAS_WAIT_PHYUP_RETRIES) {
			phy->wait_phyup_cnt++;
			phy->timer.expires = jiffies +
					     HISI_SAS_WAIT_PHYUP_TIMEOUT * HZ;
			add_timer(&phy->timer);
		} else {
			dev_warn(dev, "phy%d failed to come up %d times, giving up\n",
				 phy_no, phy->wait_phyup_cnt);
			phy->wait_phyup_cnt = 0;
		}
925 926 927 928
	}
}
EXPORT_SYMBOL_GPL(hisi_sas_phy_oob_ready);

J
John Garry 已提交
929 930 931 932
static void hisi_sas_phy_init(struct hisi_hba *hisi_hba, int phy_no)
{
	struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
	struct asd_sas_phy *sas_phy = &phy->sas_phy;
933
	int i;
J
John Garry 已提交
934 935 936

	phy->hisi_hba = hisi_hba;
	phy->port = NULL;
937 938
	phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
	phy->maximum_linkrate = hisi_hba->hw->phy_get_max_linkrate();
J
John Garry 已提交
939 940 941 942 943 944 945 946 947 948 949 950 951
	sas_phy->enabled = (phy_no < hisi_hba->n_phy) ? 1 : 0;
	sas_phy->class = SAS;
	sas_phy->iproto = SAS_PROTOCOL_ALL;
	sas_phy->tproto = 0;
	sas_phy->type = PHY_TYPE_PHYSICAL;
	sas_phy->role = PHY_ROLE_INITIATOR;
	sas_phy->oob_mode = OOB_NOT_CONNECTED;
	sas_phy->linkrate = SAS_LINK_RATE_UNKNOWN;
	sas_phy->id = phy_no;
	sas_phy->sas_addr = &hisi_hba->sas_addr[0];
	sas_phy->frame_rcvd = &phy->frame_rcvd[0];
	sas_phy->ha = (struct sas_ha_struct *)hisi_hba->shost->hostdata;
	sas_phy->lldd_phy = phy;
952

953 954
	for (i = 0; i < HISI_PHYES_NUM; i++)
		INIT_WORK(&phy->works[i], hisi_sas_phye_fns[i]);
955 956

	spin_lock_init(&phy->lock);
957 958

	timer_setup(&phy->timer, hisi_sas_wait_phyup_timedout, 0);
J
John Garry 已提交
959 960
}

961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984
/* Wrapper to ensure we track hisi_sas_phy.enable properly */
void hisi_sas_phy_enable(struct hisi_hba *hisi_hba, int phy_no, int enable)
{
	struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
	struct asd_sas_phy *aphy = &phy->sas_phy;
	struct sas_phy *sphy = aphy->phy;
	unsigned long flags;

	spin_lock_irqsave(&phy->lock, flags);

	if (enable) {
		/* We may have been enabled already; if so, don't touch */
		if (!phy->enable)
			sphy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
		hisi_hba->hw->phy_start(hisi_hba, phy_no);
	} else {
		sphy->negotiated_linkrate = SAS_PHY_DISABLED;
		hisi_hba->hw->phy_disable(hisi_hba, phy_no);
	}
	phy->enable = enable;
	spin_unlock_irqrestore(&phy->lock, flags);
}
EXPORT_SYMBOL_GPL(hisi_sas_phy_enable);

J
John Garry 已提交
985 986 987 988 989 990
static void hisi_sas_port_notify_formed(struct asd_sas_phy *sas_phy)
{
	struct sas_ha_struct *sas_ha = sas_phy->ha;
	struct hisi_hba *hisi_hba = sas_ha->lldd_ha;
	struct hisi_sas_phy *phy = sas_phy->lldd_phy;
	struct asd_sas_port *sas_port = sas_phy->port;
991
	struct hisi_sas_port *port;
J
John Garry 已提交
992 993 994 995 996
	unsigned long flags;

	if (!sas_port)
		return;

997
	port = to_hisi_sas_port(sas_port);
J
John Garry 已提交
998 999 1000 1001 1002 1003 1004 1005
	spin_lock_irqsave(&hisi_hba->lock, flags);
	port->port_attached = 1;
	port->id = phy->port_id;
	phy->port = port;
	sas_port->lldd_port = port;
	spin_unlock_irqrestore(&hisi_hba->lock, flags);
}

1006
static void hisi_sas_do_release_task(struct hisi_hba *hisi_hba, struct sas_task *task,
1007
				     struct hisi_sas_slot *slot)
J
John Garry 已提交
1008
{
1009 1010 1011
	if (task) {
		unsigned long flags;
		struct task_status_struct *ts;
J
John Garry 已提交
1012

1013
		ts = &task->task_status;
J
John Garry 已提交
1014

1015 1016 1017 1018 1019
		ts->resp = SAS_TASK_COMPLETE;
		ts->stat = SAS_ABORTED_TASK;
		spin_lock_irqsave(&task->task_state_lock, flags);
		task->task_state_flags &=
			~(SAS_TASK_STATE_PENDING | SAS_TASK_AT_INITIATOR);
1020 1021
		if (!slot->is_internal && task->task_proto != SAS_PROTOCOL_SMP)
			task->task_state_flags |= SAS_TASK_STATE_DONE;
1022 1023
		spin_unlock_irqrestore(&task->task_state_lock, flags);
	}
J
John Garry 已提交
1024

1025
	hisi_sas_slot_task_free(hisi_hba, task, slot);
J
John Garry 已提交
1026 1027 1028 1029 1030
}

static void hisi_sas_release_task(struct hisi_hba *hisi_hba,
			struct domain_device *device)
{
1031 1032
	struct hisi_sas_slot *slot, *slot2;
	struct hisi_sas_device *sas_dev = device->lldd_dev;
J
John Garry 已提交
1033

1034 1035
	list_for_each_entry_safe(slot, slot2, &sas_dev->list, entry)
		hisi_sas_do_release_task(hisi_hba, slot->task, slot);
J
John Garry 已提交
1036 1037
}

1038
void hisi_sas_release_tasks(struct hisi_hba *hisi_hba)
1039
{
1040 1041
	struct hisi_sas_device *sas_dev;
	struct domain_device *device;
1042 1043
	int i;

1044 1045 1046
	for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
		sas_dev = &hisi_hba->devices[i];
		device = sas_dev->sas_device;
1047

1048 1049
		if ((sas_dev->dev_type == SAS_PHY_UNUSED) ||
		    !device)
1050
			continue;
1051 1052

		hisi_sas_release_task(hisi_hba, device);
1053 1054
	}
}
1055
EXPORT_SYMBOL_GPL(hisi_sas_release_tasks);
1056

1057 1058 1059 1060 1061 1062 1063
static void hisi_sas_dereg_device(struct hisi_hba *hisi_hba,
				struct domain_device *device)
{
	if (hisi_hba->hw->dereg_device)
		hisi_hba->hw->dereg_device(hisi_hba, device);
}

J
John Garry 已提交
1064 1065 1066 1067
static void hisi_sas_dev_gone(struct domain_device *device)
{
	struct hisi_sas_device *sas_dev = device->lldd_dev;
	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
1068
	struct device *dev = hisi_hba->dev;
1069
	int ret = 0;
J
John Garry 已提交
1070

1071
	dev_info(dev, "dev[%d:%x] is gone\n",
J
John Garry 已提交
1072 1073
		 sas_dev->device_id, sas_dev->dev_type);

1074
	down(&hisi_hba->sem);
1075 1076
	if (!test_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags)) {
		hisi_sas_internal_task_abort(hisi_hba, device,
1077
					     HISI_SAS_INT_ABT_DEV, 0);
1078

1079 1080
		hisi_sas_dereg_device(hisi_hba, device);

1081
		ret = hisi_hba->hw->clear_itct(hisi_hba, sas_dev);
1082 1083
		device->lldd_dev = NULL;
	}
1084

1085 1086
	if (hisi_hba->hw->free_device)
		hisi_hba->hw->free_device(sas_dev);
1087 1088 1089 1090

	/* Don't mark it as SAS_PHY_UNUSED if failed to clear ITCT */
	if (!ret)
		sas_dev->dev_type = SAS_PHY_UNUSED;
1091 1092
	sas_dev->sas_device = NULL;
	up(&hisi_hba->sem);
J
John Garry 已提交
1093
}
J
John Garry 已提交
1094 1095 1096 1097 1098 1099

static int hisi_sas_queue_command(struct sas_task *task, gfp_t gfp_flags)
{
	return hisi_sas_task_exec(task, gfp_flags, 0, NULL);
}

1100
static int hisi_sas_phy_set_linkrate(struct hisi_hba *hisi_hba, int phy_no,
1101 1102 1103 1104 1105 1106 1107 1108
			struct sas_phy_linkrates *r)
{
	struct sas_phy_linkrates _r;

	struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
	struct asd_sas_phy *sas_phy = &phy->sas_phy;
	enum sas_linkrate min, max;

1109 1110 1111
	if (r->minimum_linkrate > SAS_LINK_RATE_1_5_GBPS)
		return -EINVAL;

1112 1113 1114 1115 1116 1117 1118
	if (r->maximum_linkrate == SAS_LINK_RATE_UNKNOWN) {
		max = sas_phy->phy->maximum_linkrate;
		min = r->minimum_linkrate;
	} else if (r->minimum_linkrate == SAS_LINK_RATE_UNKNOWN) {
		max = r->maximum_linkrate;
		min = sas_phy->phy->minimum_linkrate;
	} else
1119
		return -EINVAL;
1120 1121 1122 1123

	_r.maximum_linkrate = max;
	_r.minimum_linkrate = min;

1124 1125 1126
	sas_phy->phy->maximum_linkrate = max;
	sas_phy->phy->minimum_linkrate = min;

1127
	hisi_sas_phy_enable(hisi_hba, phy_no, 0);
1128 1129
	msleep(100);
	hisi_hba->hw->phy_set_linkrate(hisi_hba, phy_no, &_r);
1130
	hisi_sas_phy_enable(hisi_hba, phy_no, 1);
1131 1132

	return 0;
1133 1134
}

J
John Garry 已提交
1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
static int hisi_sas_control_phy(struct asd_sas_phy *sas_phy, enum phy_func func,
				void *funcdata)
{
	struct sas_ha_struct *sas_ha = sas_phy->ha;
	struct hisi_hba *hisi_hba = sas_ha->lldd_ha;
	int phy_no = sas_phy->id;

	switch (func) {
	case PHY_FUNC_HARD_RESET:
		hisi_hba->hw->phy_hard_reset(hisi_hba, phy_no);
		break;

	case PHY_FUNC_LINK_RESET:
1148
		hisi_sas_phy_enable(hisi_hba, phy_no, 0);
1149
		msleep(100);
1150
		hisi_sas_phy_enable(hisi_hba, phy_no, 1);
J
John Garry 已提交
1151 1152 1153
		break;

	case PHY_FUNC_DISABLE:
1154
		hisi_sas_phy_enable(hisi_hba, phy_no, 0);
J
John Garry 已提交
1155 1156 1157
		break;

	case PHY_FUNC_SET_LINK_RATE:
1158
		return hisi_sas_phy_set_linkrate(hisi_hba, phy_no, funcdata);
1159 1160 1161 1162 1163
	case PHY_FUNC_GET_EVENTS:
		if (hisi_hba->hw->get_events) {
			hisi_hba->hw->get_events(hisi_hba, phy_no);
			break;
		}
1164
		fallthrough;
J
John Garry 已提交
1165 1166 1167 1168 1169 1170
	case PHY_FUNC_RELEASE_SPINUP_HOLD:
	default:
		return -EOPNOTSUPP;
	}
	return 0;
}
J
John Garry 已提交
1171

J
John Garry 已提交
1172 1173
static void hisi_sas_task_done(struct sas_task *task)
{
1174
	del_timer(&task->slow_task->timer);
J
John Garry 已提交
1175 1176 1177
	complete(&task->slow_task->completion);
}

1178
static void hisi_sas_tmf_timedout(struct timer_list *t)
J
John Garry 已提交
1179
{
1180 1181
	struct sas_task_slow *slow = from_timer(slow, t, timer);
	struct sas_task *task = slow->task;
1182
	unsigned long flags;
1183
	bool is_completed = true;
1184 1185

	spin_lock_irqsave(&task->task_state_lock, flags);
1186
	if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
1187
		task->task_state_flags |= SAS_TASK_STATE_ABORTED;
1188 1189
		is_completed = false;
	}
1190
	spin_unlock_irqrestore(&task->task_state_lock, flags);
J
John Garry 已提交
1191

1192 1193
	if (!is_completed)
		complete(&task->slow_task->completion);
J
John Garry 已提交
1194 1195 1196 1197
}

#define TASK_TIMEOUT 20
#define TASK_RETRY 3
1198
#define INTERNAL_ABORT_TIMEOUT 6
J
John Garry 已提交
1199 1200 1201 1202 1203 1204
static int hisi_sas_exec_internal_tmf_task(struct domain_device *device,
					   void *parameter, u32 para_len,
					   struct hisi_sas_tmf_task *tmf)
{
	struct hisi_sas_device *sas_dev = device->lldd_dev;
	struct hisi_hba *hisi_hba = sas_dev->hisi_hba;
1205
	struct device *dev = hisi_hba->dev;
J
John Garry 已提交
1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
	struct sas_task *task;
	int res, retry;

	for (retry = 0; retry < TASK_RETRY; retry++) {
		task = sas_alloc_slow_task(GFP_KERNEL);
		if (!task)
			return -ENOMEM;

		task->dev = device;
		task->task_proto = device->tproto;

1217 1218 1219 1220 1221 1222
		if (dev_is_sata(device)) {
			task->ata_task.device_control_reg_update = 1;
			memcpy(&task->ata_task.fis, parameter, para_len);
		} else {
			memcpy(&task->ssp_task, parameter, para_len);
		}
J
John Garry 已提交
1223 1224
		task->task_done = hisi_sas_task_done;

1225
		task->slow_task->timer.function = hisi_sas_tmf_timedout;
1226
		task->slow_task->timer.expires = jiffies + TASK_TIMEOUT * HZ;
J
John Garry 已提交
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242
		add_timer(&task->slow_task->timer);

		res = hisi_sas_task_exec(task, GFP_KERNEL, 1, tmf);

		if (res) {
			del_timer(&task->slow_task->timer);
			dev_err(dev, "abort tmf: executing internal task failed: %d\n",
				res);
			goto ex_err;
		}

		wait_for_completion(&task->slow_task->completion);
		res = TMF_RESP_FUNC_FAILED;
		/* Even TMF timed out, return direct. */
		if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
			if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
1243 1244
				struct hisi_sas_slot *slot = task->lldd_task;

1245
				dev_err(dev, "abort tmf: TMF task timeout and not done\n");
1246
				if (slot) {
1247 1248
					struct hisi_sas_cq *cq =
					       &hisi_hba->cq[slot->dlvry_queue];
1249
					/*
1250
					 * sync irq to avoid free'ing task
1251 1252
					 * before using task in IO completion
					 */
1253
					synchronize_irq(cq->irq_no);
1254
					slot->task = NULL;
1255
				}
1256

J
John Garry 已提交
1257
				goto ex_err;
1258 1259
			} else
				dev_err(dev, "abort tmf: TMF task timeout\n");
J
John Garry 已提交
1260 1261 1262
		}

		if (task->task_status.resp == SAS_TASK_COMPLETE &&
1263
		     task->task_status.stat == TMF_RESP_FUNC_COMPLETE) {
J
John Garry 已提交
1264 1265 1266 1267
			res = TMF_RESP_FUNC_COMPLETE;
			break;
		}

1268 1269 1270 1271 1272 1273
		if (task->task_status.resp == SAS_TASK_COMPLETE &&
			task->task_status.stat == TMF_RESP_FUNC_SUCC) {
			res = TMF_RESP_FUNC_SUCC;
			break;
		}

J
John Garry 已提交
1274 1275 1276 1277 1278
		if (task->task_status.resp == SAS_TASK_COMPLETE &&
		      task->task_status.stat == SAS_DATA_UNDERRUN) {
			/* no error, but return the number of bytes of
			 * underrun
			 */
1279
			dev_warn(dev, "abort tmf: task to dev %016llx resp: 0x%x sts 0x%x underrun\n",
J
John Garry 已提交
1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
				 SAS_ADDR(device->sas_addr),
				 task->task_status.resp,
				 task->task_status.stat);
			res = task->task_status.residual;
			break;
		}

		if (task->task_status.resp == SAS_TASK_COMPLETE &&
			task->task_status.stat == SAS_DATA_OVERRUN) {
			dev_warn(dev, "abort tmf: blocked task error\n");
			res = -EMSGSIZE;
			break;
		}

1294 1295 1296 1297 1298 1299 1300 1301 1302 1303
		if (task->task_status.resp == SAS_TASK_COMPLETE &&
		    task->task_status.stat == SAS_OPEN_REJECT) {
			dev_warn(dev, "abort tmf: open reject failed\n");
			res = -EIO;
		} else {
			dev_warn(dev, "abort tmf: task to dev %016llx resp: 0x%x status 0x%x\n",
				 SAS_ADDR(device->sas_addr),
				 task->task_status.resp,
				 task->task_status.stat);
		}
J
John Garry 已提交
1304 1305 1306 1307
		sas_free_task(task);
		task = NULL;
	}
ex_err:
1308 1309
	if (retry == TASK_RETRY)
		dev_warn(dev, "abort tmf: executing internal task failed!\n");
J
John Garry 已提交
1310 1311 1312 1313
	sas_free_task(task);
	return res;
}

1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334
static void hisi_sas_fill_ata_reset_cmd(struct ata_device *dev,
		bool reset, int pmp, u8 *fis)
{
	struct ata_taskfile tf;

	ata_tf_init(dev, &tf);
	if (reset)
		tf.ctl |= ATA_SRST;
	else
		tf.ctl &= ~ATA_SRST;
	tf.command = ATA_CMD_DEV_RESET;
	ata_tf_to_fis(&tf, pmp, 0, fis);
}

static int hisi_sas_softreset_ata_disk(struct domain_device *device)
{
	u8 fis[20] = {0};
	struct ata_port *ap = device->sata_dev.ap;
	struct ata_link *link;
	int rc = TMF_RESP_FUNC_FAILED;
	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
1335
	struct device *dev = hisi_hba->dev;
1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354
	int s = sizeof(struct host_to_dev_fis);

	ata_for_each_link(link, ap, EDGE) {
		int pmp = sata_srst_pmp(link);

		hisi_sas_fill_ata_reset_cmd(link->device, 1, pmp, fis);
		rc = hisi_sas_exec_internal_tmf_task(device, fis, s, NULL);
		if (rc != TMF_RESP_FUNC_COMPLETE)
			break;
	}

	if (rc == TMF_RESP_FUNC_COMPLETE) {
		ata_for_each_link(link, ap, EDGE) {
			int pmp = sata_srst_pmp(link);

			hisi_sas_fill_ata_reset_cmd(link->device, 0, pmp, fis);
			rc = hisi_sas_exec_internal_tmf_task(device, fis,
							     s, NULL);
			if (rc != TMF_RESP_FUNC_COMPLETE)
1355 1356
				dev_err(dev, "ata disk %016llx de-reset failed\n",
					SAS_ADDR(device->sas_addr));
1357 1358
		}
	} else {
1359 1360
		dev_err(dev, "ata disk %016llx reset failed\n",
			SAS_ADDR(device->sas_addr));
1361 1362
	}

1363
	if (rc == TMF_RESP_FUNC_COMPLETE)
1364 1365 1366 1367 1368
		hisi_sas_release_task(hisi_hba, device);

	return rc;
}

J
John Garry 已提交
1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
static int hisi_sas_debug_issue_ssp_tmf(struct domain_device *device,
				u8 *lun, struct hisi_sas_tmf_task *tmf)
{
	struct sas_ssp_task ssp_task;

	if (!(device->tproto & SAS_PROTOCOL_SSP))
		return TMF_RESP_FUNC_ESUPP;

	memcpy(ssp_task.LUN, lun, 8);

	return hisi_sas_exec_internal_tmf_task(device, &ssp_task,
				sizeof(ssp_task), tmf);
}

1383
static void hisi_sas_refresh_port_id(struct hisi_hba *hisi_hba)
1384
{
1385
	u32 state = hisi_hba->hw->get_phys_state(hisi_hba);
1386 1387 1388
	int i;

	for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
1389 1390 1391 1392 1393 1394 1395
		struct hisi_sas_device *sas_dev = &hisi_hba->devices[i];
		struct domain_device *device = sas_dev->sas_device;
		struct asd_sas_port *sas_port;
		struct hisi_sas_port *port;
		struct hisi_sas_phy *phy = NULL;
		struct asd_sas_phy *sas_phy;

1396
		if ((sas_dev->dev_type == SAS_PHY_UNUSED)
1397
				|| !device || !device->port)
1398 1399
			continue;

1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
		sas_port = device->port;
		port = to_hisi_sas_port(sas_port);

		list_for_each_entry(sas_phy, &sas_port->phy_list, port_phy_el)
			if (state & BIT(sas_phy->id)) {
				phy = sas_phy->lldd_phy;
				break;
			}

		if (phy) {
			port->id = phy->port_id;
1411

1412 1413 1414
			/* Update linkrate of directly attached device. */
			if (!device->parent)
				device->linkrate = phy->sas_phy.linkrate;
1415

1416 1417 1418
			hisi_hba->hw->setup_itct(hisi_hba, sas_dev);
		} else
			port->id = 0xff;
1419 1420 1421
	}
}

1422
static void hisi_sas_rescan_topology(struct hisi_hba *hisi_hba, u32 state)
1423 1424 1425 1426 1427 1428 1429 1430
{
	struct asd_sas_port *_sas_port = NULL;
	int phy_no;

	for (phy_no = 0; phy_no < hisi_hba->n_phy; phy_no++) {
		struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
		struct asd_sas_phy *sas_phy = &phy->sas_phy;
		struct asd_sas_port *sas_port = sas_phy->port;
1431
		bool do_port_check = _sas_port != sas_port;
1432 1433 1434 1435 1436

		if (!sas_phy->phy->enabled)
			continue;

		/* Report PHY state change to libsas */
1437 1438
		if (state & BIT(phy_no)) {
			if (do_port_check && sas_port && sas_port->port_dev) {
1439 1440 1441 1442
				struct domain_device *dev = sas_port->port_dev;

				_sas_port = sas_port;

1443
				if (dev_is_expander(dev->dev_type))
1444
					sas_notify_port_event(sas_phy,
1445 1446
							PORTE_BROADCAST_RCVD,
							GFP_KERNEL);
1447
			}
1448
		} else {
1449
			hisi_sas_phy_down(hisi_hba, phy_no, 0, GFP_KERNEL);
1450
		}
1451 1452 1453
	}
}

1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470
static void hisi_sas_reset_init_all_devices(struct hisi_hba *hisi_hba)
{
	struct hisi_sas_device *sas_dev;
	struct domain_device *device;
	int i;

	for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
		sas_dev = &hisi_hba->devices[i];
		device = sas_dev->sas_device;

		if ((sas_dev->dev_type == SAS_PHY_UNUSED) || !device)
			continue;

		hisi_sas_init_device(device);
	}
}

1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529
static void hisi_sas_send_ata_reset_each_phy(struct hisi_hba *hisi_hba,
					     struct asd_sas_port *sas_port,
					     struct domain_device *device)
{
	struct hisi_sas_tmf_task tmf_task = { .force_phy = 1 };
	struct ata_port *ap = device->sata_dev.ap;
	struct device *dev = hisi_hba->dev;
	int s = sizeof(struct host_to_dev_fis);
	int rc = TMF_RESP_FUNC_FAILED;
	struct asd_sas_phy *sas_phy;
	struct ata_link *link;
	u8 fis[20] = {0};
	u32 state;

	state = hisi_hba->hw->get_phys_state(hisi_hba);
	list_for_each_entry(sas_phy, &sas_port->phy_list, port_phy_el) {
		if (!(state & BIT(sas_phy->id)))
			continue;

		ata_for_each_link(link, ap, EDGE) {
			int pmp = sata_srst_pmp(link);

			tmf_task.phy_id = sas_phy->id;
			hisi_sas_fill_ata_reset_cmd(link->device, 1, pmp, fis);
			rc = hisi_sas_exec_internal_tmf_task(device, fis, s,
							     &tmf_task);
			if (rc != TMF_RESP_FUNC_COMPLETE) {
				dev_err(dev, "phy%d ata reset failed rc=%d\n",
					sas_phy->id, rc);
				break;
			}
		}
	}
}

static void hisi_sas_terminate_stp_reject(struct hisi_hba *hisi_hba)
{
	struct device *dev = hisi_hba->dev;
	int port_no, rc, i;

	for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
		struct hisi_sas_device *sas_dev = &hisi_hba->devices[i];
		struct domain_device *device = sas_dev->sas_device;

		if ((sas_dev->dev_type == SAS_PHY_UNUSED) || !device)
			continue;

		rc = hisi_sas_internal_task_abort(hisi_hba, device,
						  HISI_SAS_INT_ABT_DEV, 0);
		if (rc < 0)
			dev_err(dev, "STP reject: abort dev failed %d\n", rc);
	}

	for (port_no = 0; port_no < hisi_hba->n_phy; port_no++) {
		struct hisi_sas_port *port = &hisi_hba->port[port_no];
		struct asd_sas_port *sas_port = &port->sas_port;
		struct domain_device *port_dev = sas_port->port_dev;
		struct domain_device *device;

1530
		if (!port_dev || !dev_is_expander(port_dev->dev_type))
1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545
			continue;

		/* Try to find a SATA device */
		list_for_each_entry(device, &sas_port->dev_list,
				    dev_list_node) {
			if (dev_is_sata(device)) {
				hisi_sas_send_ata_reset_each_phy(hisi_hba,
								 sas_port,
								 device);
				break;
			}
		}
	}
}

1546
void hisi_sas_controller_reset_prepare(struct hisi_hba *hisi_hba)
1547
{
1548
	struct Scsi_Host *shost = hisi_hba->shost;
1549

1550
	down(&hisi_hba->sem);
1551
	hisi_hba->phy_state = hisi_hba->hw->get_phys_state(hisi_hba);
1552

1553
	scsi_block_requests(shost);
1554 1555
	hisi_hba->hw->wait_cmds_complete_timeout(hisi_hba, 100, 5000);

1556 1557 1558
	if (timer_pending(&hisi_hba->timer))
		del_timer_sync(&hisi_hba->timer);

1559
	set_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags);
1560 1561 1562 1563 1564 1565
}
EXPORT_SYMBOL_GPL(hisi_sas_controller_reset_prepare);

void hisi_sas_controller_reset_done(struct hisi_hba *hisi_hba)
{
	struct Scsi_Host *shost = hisi_hba->shost;
1566 1567 1568 1569

	/* Init and wait for PHYs to come up and all libsas event finished. */
	hisi_hba->hw->phys_init(hisi_hba);
	msleep(1000);
1570
	hisi_sas_refresh_port_id(hisi_hba);
1571
	clear_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags);
1572 1573 1574

	if (hisi_hba->reject_stp_links_msk)
		hisi_sas_terminate_stp_reject(hisi_hba);
1575
	hisi_sas_reset_init_all_devices(hisi_hba);
1576
	up(&hisi_hba->sem);
1577
	scsi_unblock_requests(shost);
1578
	clear_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags);
1579

1580
	hisi_sas_rescan_topology(hisi_hba, hisi_hba->phy_state);
1581 1582 1583
}
EXPORT_SYMBOL_GPL(hisi_sas_controller_reset_done);

1584
static int hisi_sas_controller_prereset(struct hisi_hba *hisi_hba)
1585 1586 1587 1588 1589 1590 1591
{
	if (!hisi_hba->hw->soft_reset)
		return -1;

	if (test_and_set_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags))
		return -1;

1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603
	if (hisi_sas_debugfs_enable && hisi_hba->debugfs_itct[0].itct)
		hisi_hba->hw->debugfs_snapshot_regs(hisi_hba);

	return 0;
}

static int hisi_sas_controller_reset(struct hisi_hba *hisi_hba)
{
	struct device *dev = hisi_hba->dev;
	struct Scsi_Host *shost = hisi_hba->shost;
	int rc;

1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617
	dev_info(dev, "controller resetting...\n");
	hisi_sas_controller_reset_prepare(hisi_hba);

	rc = hisi_hba->hw->soft_reset(hisi_hba);
	if (rc) {
		dev_warn(dev, "controller reset failed (%d)\n", rc);
		clear_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags);
		up(&hisi_hba->sem);
		scsi_unblock_requests(shost);
		clear_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags);
		return rc;
	}

	hisi_sas_controller_reset_done(hisi_hba);
1618
	dev_info(dev, "controller reset complete\n");
1619

1620
	return 0;
1621 1622
}

J
John Garry 已提交
1623 1624 1625 1626 1627 1628
static int hisi_sas_abort_task(struct sas_task *task)
{
	struct scsi_lun lun;
	struct hisi_sas_tmf_task tmf_task;
	struct domain_device *device = task->dev;
	struct hisi_sas_device *sas_dev = device->lldd_dev;
1629 1630
	struct hisi_hba *hisi_hba;
	struct device *dev;
J
John Garry 已提交
1631 1632 1633
	int rc = TMF_RESP_FUNC_FAILED;
	unsigned long flags;

1634
	if (!sas_dev)
J
John Garry 已提交
1635
		return TMF_RESP_FUNC_FAILED;
1636 1637 1638

	hisi_hba = dev_to_hisi_hba(task->dev);
	dev = hisi_hba->dev;
J
John Garry 已提交
1639

1640
	spin_lock_irqsave(&task->task_state_lock, flags);
J
John Garry 已提交
1641
	if (task->task_state_flags & SAS_TASK_STATE_DONE) {
1642 1643 1644 1645 1646
		struct hisi_sas_slot *slot = task->lldd_task;
		struct hisi_sas_cq *cq;

		if (slot) {
			/*
1647
			 * sync irq to avoid free'ing task
1648 1649 1650
			 * before using task in IO completion
			 */
			cq = &hisi_hba->cq[slot->dlvry_queue];
1651
			synchronize_irq(cq->irq_no);
1652
		}
1653
		spin_unlock_irqrestore(&task->task_state_lock, flags);
J
John Garry 已提交
1654 1655 1656
		rc = TMF_RESP_FUNC_COMPLETE;
		goto out;
	}
1657 1658
	task->task_state_flags |= SAS_TASK_STATE_ABORTED;
	spin_unlock_irqrestore(&task->task_state_lock, flags);
J
John Garry 已提交
1659 1660 1661 1662

	if (task->lldd_task && task->task_proto & SAS_PROTOCOL_SSP) {
		struct scsi_cmnd *cmnd = task->uldd_task;
		struct hisi_sas_slot *slot = task->lldd_task;
1663
		u16 tag = slot->idx;
1664
		int rc2;
J
John Garry 已提交
1665 1666 1667

		int_to_scsilun(cmnd->device->lun, &lun);
		tmf_task.tmf = TMF_ABORT_TASK;
1668
		tmf_task.tag_of_task_to_be_managed = tag;
J
John Garry 已提交
1669 1670 1671 1672

		rc = hisi_sas_debug_issue_ssp_tmf(task->dev, lun.scsi_lun,
						  &tmf_task);

1673 1674
		rc2 = hisi_sas_internal_task_abort(hisi_hba, device,
						   HISI_SAS_INT_ABT_CMD, tag);
1675 1676 1677 1678 1679
		if (rc2 < 0) {
			dev_err(dev, "abort task: internal abort (%d)\n", rc2);
			return TMF_RESP_FUNC_FAILED;
		}

1680 1681 1682 1683 1684 1685 1686 1687
		/*
		 * If the TMF finds that the IO is not in the device and also
		 * the internal abort does not succeed, then it is safe to
		 * free the slot.
		 * Note: if the internal abort succeeds then the slot
		 * will have already been completed
		 */
		if (rc == TMF_RESP_FUNC_COMPLETE && rc2 != TMF_RESP_FUNC_SUCC) {
1688
			if (task->lldd_task)
1689
				hisi_sas_do_release_task(hisi_hba, task, slot);
J
John Garry 已提交
1690 1691 1692 1693
		}
	} else if (task->task_proto & SAS_PROTOCOL_SATA ||
		task->task_proto & SAS_PROTOCOL_STP) {
		if (task->dev->dev_type == SAS_SATA_DEV) {
1694
			rc = hisi_sas_internal_task_abort(hisi_hba, device,
1695 1696
							  HISI_SAS_INT_ABT_DEV,
							  0);
1697 1698 1699 1700
			if (rc < 0) {
				dev_err(dev, "abort task: internal abort failed\n");
				goto out;
			}
1701
			hisi_sas_dereg_device(hisi_hba, device);
1702
			rc = hisi_sas_softreset_ata_disk(device);
J
John Garry 已提交
1703
		}
1704
	} else if (task->lldd_task && task->task_proto & SAS_PROTOCOL_SMP) {
1705 1706 1707
		/* SMP */
		struct hisi_sas_slot *slot = task->lldd_task;
		u32 tag = slot->idx;
1708
		struct hisi_sas_cq *cq = &hisi_hba->cq[slot->dlvry_queue];
J
John Garry 已提交
1709

1710
		rc = hisi_sas_internal_task_abort(hisi_hba, device,
1711
						  HISI_SAS_INT_ABT_CMD, tag);
1712
		if (((rc < 0) || (rc == TMF_RESP_FUNC_FAILED)) &&
1713 1714
					task->lldd_task) {
			/*
1715
			 * sync irq to avoid free'ing task
1716 1717
			 * before using task in IO completion
			 */
1718
			synchronize_irq(cq->irq_no);
1719 1720
			slot->task = NULL;
		}
J
John Garry 已提交
1721 1722 1723 1724 1725 1726 1727 1728 1729 1730
	}

out:
	if (rc != TMF_RESP_FUNC_COMPLETE)
		dev_notice(dev, "abort task: rc=%d\n", rc);
	return rc;
}

static int hisi_sas_abort_task_set(struct domain_device *device, u8 *lun)
{
1731 1732
	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
	struct device *dev = hisi_hba->dev;
J
John Garry 已提交
1733
	struct hisi_sas_tmf_task tmf_task;
X
Xiang Chen 已提交
1734
	int rc;
1735 1736

	rc = hisi_sas_internal_task_abort(hisi_hba, device,
1737
					  HISI_SAS_INT_ABT_DEV, 0);
1738 1739 1740 1741 1742
	if (rc < 0) {
		dev_err(dev, "abort task set: internal abort rc=%d\n", rc);
		return TMF_RESP_FUNC_FAILED;
	}
	hisi_sas_dereg_device(hisi_hba, device);
J
John Garry 已提交
1743 1744 1745 1746

	tmf_task.tmf = TMF_ABORT_TASK_SET;
	rc = hisi_sas_debug_issue_ssp_tmf(device, lun, &tmf_task);

1747
	if (rc == TMF_RESP_FUNC_COMPLETE)
1748 1749
		hisi_sas_release_task(hisi_hba, device);

J
John Garry 已提交
1750 1751 1752 1753 1754 1755
	return rc;
}

static int hisi_sas_clear_aca(struct domain_device *device, u8 *lun)
{
	struct hisi_sas_tmf_task tmf_task;
1756
	int rc;
J
John Garry 已提交
1757 1758 1759 1760 1761 1762 1763 1764 1765

	tmf_task.tmf = TMF_CLEAR_ACA;
	rc = hisi_sas_debug_issue_ssp_tmf(device, lun, &tmf_task);

	return rc;
}

static int hisi_sas_debug_I_T_nexus_reset(struct domain_device *device)
{
1766
	struct sas_phy *local_phy = sas_get_local_phy(device);
1767
	struct hisi_sas_device *sas_dev = device->lldd_dev;
1768 1769 1770
	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
	struct sas_ha_struct *sas_ha = &hisi_hba->sha;
	DECLARE_COMPLETION_ONSTACK(phyreset);
1771
	int rc, reset_type;
1772

1773 1774 1775 1776 1777
	if (!local_phy->enabled) {
		sas_put_local_phy(local_phy);
		return -ENODEV;
	}

1778
	if (scsi_is_sas_phy_local(local_phy)) {
1779 1780 1781 1782
		struct asd_sas_phy *sas_phy =
			sas_ha->sas_phy[local_phy->number];
		struct hisi_sas_phy *phy =
			container_of(sas_phy, struct hisi_sas_phy, sas_phy);
1783 1784 1785 1786
		phy->in_reset = 1;
		phy->reset_completion = &phyreset;
	}

1787
	reset_type = (sas_dev->dev_status == HISI_SAS_DEV_INIT ||
1788
		      !dev_is_sata(device)) ? true : false;
1789

1790 1791 1792 1793
	rc = sas_phy_reset(local_phy, reset_type);
	sas_put_local_phy(local_phy);

	if (scsi_is_sas_phy_local(local_phy)) {
1794 1795 1796 1797
		struct asd_sas_phy *sas_phy =
			sas_ha->sas_phy[local_phy->number];
		struct hisi_sas_phy *phy =
			container_of(sas_phy, struct hisi_sas_phy, sas_phy);
1798 1799 1800 1801 1802 1803 1804 1805 1806 1807
		int ret = wait_for_completion_timeout(&phyreset, 2 * HZ);
		unsigned long flags;

		spin_lock_irqsave(&phy->lock, flags);
		phy->reset_completion = NULL;
		phy->in_reset = 0;
		spin_unlock_irqrestore(&phy->lock, flags);

		/* report PHY down if timed out */
		if (!ret)
1808
			hisi_sas_phy_down(hisi_hba, sas_phy->id, 0, GFP_KERNEL);
1809 1810 1811
	} else if (sas_dev->dev_status != HISI_SAS_DEV_INIT) {
		/*
		 * If in init state, we rely on caller to wait for link to be
1812
		 * ready; otherwise, except phy reset is fail, delay.
1813
		 */
1814 1815
		if (!rc)
			msleep(2000);
1816
	}
1817

J
John Garry 已提交
1818 1819 1820 1821 1822 1823
	return rc;
}

static int hisi_sas_I_T_nexus_reset(struct domain_device *device)
{
	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
1824
	struct device *dev = hisi_hba->dev;
1825
	int rc;
J
John Garry 已提交
1826

1827
	rc = hisi_sas_internal_task_abort(hisi_hba, device,
1828
					  HISI_SAS_INT_ABT_DEV, 0);
1829 1830 1831 1832
	if (rc < 0) {
		dev_err(dev, "I_T nexus reset: internal abort (%d)\n", rc);
		return TMF_RESP_FUNC_FAILED;
	}
1833 1834
	hisi_sas_dereg_device(hisi_hba, device);

1835 1836
	if (dev_is_sata(device)) {
		rc = hisi_sas_softreset_ata_disk(device);
1837
		if (rc == TMF_RESP_FUNC_FAILED)
1838 1839 1840
			return TMF_RESP_FUNC_FAILED;
	}

J
John Garry 已提交
1841 1842
	rc = hisi_sas_debug_I_T_nexus_reset(device);

1843
	if ((rc == TMF_RESP_FUNC_COMPLETE) || (rc == -ENODEV))
1844
		hisi_sas_release_task(hisi_hba, device);
1845

1846
	return rc;
J
John Garry 已提交
1847 1848 1849 1850 1851 1852
}

static int hisi_sas_lu_reset(struct domain_device *device, u8 *lun)
{
	struct hisi_sas_device *sas_dev = device->lldd_dev;
	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
1853
	struct device *dev = hisi_hba->dev;
J
John Garry 已提交
1854 1855
	int rc = TMF_RESP_FUNC_FAILED;

1856 1857 1858 1859 1860 1861 1862 1863 1864
	/* Clear internal IO and then lu reset */
	rc = hisi_sas_internal_task_abort(hisi_hba, device,
					  HISI_SAS_INT_ABT_DEV, 0);
	if (rc < 0) {
		dev_err(dev, "lu_reset: internal abort failed\n");
		goto out;
	}
	hisi_sas_dereg_device(hisi_hba, device);

1865 1866 1867 1868 1869
	if (dev_is_sata(device)) {
		struct sas_phy *phy;

		phy = sas_get_local_phy(device);

1870
		rc = sas_phy_reset(phy, true);
1871

1872
		if (rc == 0)
1873 1874 1875 1876 1877 1878
			hisi_sas_release_task(hisi_hba, device);
		sas_put_local_phy(phy);
	} else {
		struct hisi_sas_tmf_task tmf_task = { .tmf =  TMF_LU_RESET };

		rc = hisi_sas_debug_issue_ssp_tmf(device, lun, &tmf_task);
1879
		if (rc == TMF_RESP_FUNC_COMPLETE)
1880 1881 1882
			hisi_sas_release_task(hisi_hba, device);
	}
out:
1883
	if (rc != TMF_RESP_FUNC_COMPLETE)
1884
		dev_err(dev, "lu_reset: for device[%d]:rc= %d\n",
1885
			     sas_dev->device_id, rc);
J
John Garry 已提交
1886 1887 1888
	return rc;
}

1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900
static void hisi_sas_async_I_T_nexus_reset(void *data, async_cookie_t cookie)
{
	struct domain_device *device = data;
	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
	int rc;

	rc = hisi_sas_debug_I_T_nexus_reset(device);
	if (rc != TMF_RESP_FUNC_COMPLETE)
		dev_info(hisi_hba->dev, "I_T_nexus reset fail for dev:%016llx rc=%d\n",
			 SAS_ADDR(device->sas_addr), rc);
}

1901 1902 1903
static int hisi_sas_clear_nexus_ha(struct sas_ha_struct *sas_ha)
{
	struct hisi_hba *hisi_hba = sas_ha->lldd_ha;
1904
	HISI_SAS_DECLARE_RST_WORK_ON_STACK(r);
1905 1906
	ASYNC_DOMAIN_EXCLUSIVE(async);
	int i;
1907

1908 1909
	queue_work(hisi_hba->wq, &r.work);
	wait_for_completion(r.completion);
1910 1911 1912 1913 1914 1915 1916 1917
	if (!r.done)
		return TMF_RESP_FUNC_FAILED;

	for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
		struct hisi_sas_device *sas_dev = &hisi_hba->devices[i];
		struct domain_device *device = sas_dev->sas_device;

		if ((sas_dev->dev_type == SAS_PHY_UNUSED) || !device ||
1918
		    dev_is_expander(device->dev_type))
1919 1920
			continue;

1921 1922
		async_schedule_domain(hisi_sas_async_I_T_nexus_reset,
				      device, &async);
1923 1924
	}

1925
	async_synchronize_full_domain(&async);
1926
	hisi_sas_release_tasks(hisi_hba);
1927

1928
	return TMF_RESP_FUNC_COMPLETE;
1929 1930
}

J
John Garry 已提交
1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944
static int hisi_sas_query_task(struct sas_task *task)
{
	struct scsi_lun lun;
	struct hisi_sas_tmf_task tmf_task;
	int rc = TMF_RESP_FUNC_FAILED;

	if (task->lldd_task && task->task_proto & SAS_PROTOCOL_SSP) {
		struct scsi_cmnd *cmnd = task->uldd_task;
		struct domain_device *device = task->dev;
		struct hisi_sas_slot *slot = task->lldd_task;
		u32 tag = slot->idx;

		int_to_scsilun(cmnd->device->lun, &lun);
		tmf_task.tmf = TMF_QUERY_TASK;
1945
		tmf_task.tag_of_task_to_be_managed = tag;
J
John Garry 已提交
1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956

		rc = hisi_sas_debug_issue_ssp_tmf(device,
						  lun.scsi_lun,
						  &tmf_task);
		switch (rc) {
		/* The task is still in Lun, release it then */
		case TMF_RESP_FUNC_SUCC:
		/* The task is not in Lun or failed, reset the phy */
		case TMF_RESP_FUNC_FAILED:
		case TMF_RESP_FUNC_COMPLETE:
			break;
1957 1958 1959
		default:
			rc = TMF_RESP_FUNC_FAILED;
			break;
J
John Garry 已提交
1960 1961 1962 1963 1964
		}
	}
	return rc;
}

1965
static int
1966
hisi_sas_internal_abort_task_exec(struct hisi_hba *hisi_hba, int device_id,
1967
				  struct sas_task *task, int abort_flag,
1968
				  int task_tag, struct hisi_sas_dq *dq)
1969 1970 1971
{
	struct domain_device *device = task->dev;
	struct hisi_sas_device *sas_dev = device->lldd_dev;
1972
	struct device *dev = hisi_hba->dev;
1973 1974
	struct hisi_sas_port *port;
	struct hisi_sas_slot *slot;
1975
	struct asd_sas_port *sas_port = device->port;
1976 1977
	struct hisi_sas_cmd_hdr *cmd_hdr_base;
	int dlvry_queue_slot, dlvry_queue, n_elem = 0, rc, slot_idx;
1978
	unsigned long flags;
1979
	int wr_q_index;
1980

1981
	if (unlikely(test_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags)))
1982 1983
		return -EINVAL;

1984 1985 1986
	if (!device->port)
		return -1;

1987
	port = to_hisi_sas_port(sas_port);
1988 1989

	/* simply get a slot and send abort command */
1990 1991
	rc = hisi_sas_slot_index_alloc(hisi_hba, NULL);
	if (rc < 0)
1992
		goto err_out;
1993

1994
	slot_idx = rc;
1995
	slot = &hisi_hba->slot_info[slot_idx];
1996

1997
	spin_lock(&dq->lock);
1998 1999
	wr_q_index = dq->wr_point;
	dq->wr_point = (dq->wr_point + 1) % HISI_SAS_QUEUE_SLOTS;
2000
	list_add_tail(&slot->delivery, &dq->list);
2001 2002
	spin_unlock(&dq->lock);
	spin_lock(&sas_dev->lock);
2003
	list_add_tail(&slot->entry, &sas_dev->list);
2004
	spin_unlock(&sas_dev->lock);
2005

2006
	dlvry_queue = dq->id;
2007
	dlvry_queue_slot = wr_q_index;
2008

2009
	slot->device_id = sas_dev->device_id;
2010 2011 2012 2013 2014 2015 2016
	slot->n_elem = n_elem;
	slot->dlvry_queue = dlvry_queue;
	slot->dlvry_queue_slot = dlvry_queue_slot;
	cmd_hdr_base = hisi_hba->cmd_hdr[dlvry_queue];
	slot->cmd_hdr = &cmd_hdr_base[dlvry_queue_slot];
	slot->task = task;
	slot->port = port;
2017
	slot->is_internal = true;
2018 2019 2020
	task->lldd_task = slot;

	memset(slot->cmd_hdr, 0, sizeof(struct hisi_sas_cmd_hdr));
2021
	memset(hisi_sas_cmd_hdr_addr_mem(slot), 0, HISI_SAS_COMMAND_TABLE_SZ);
2022 2023
	memset(hisi_sas_status_buf_addr_mem(slot), 0,
	       sizeof(struct hisi_sas_err_record));
2024

2025
	hisi_sas_task_prep_abort(hisi_hba, slot, device_id,
2026 2027
				      abort_flag, task_tag);

2028
	spin_lock_irqsave(&task->task_state_lock, flags);
2029
	task->task_state_flags |= SAS_TASK_AT_INITIATOR;
2030
	spin_unlock_irqrestore(&task->task_state_lock, flags);
2031
	WRITE_ONCE(slot->ready, 1);
2032
	/* send abort command to the chip */
2033
	spin_lock(&dq->lock);
2034
	hisi_hba->hw->start_delivery(dq);
2035
	spin_unlock(&dq->lock);
2036 2037 2038 2039 2040 2041 2042 2043 2044 2045

	return 0;

err_out:
	dev_err(dev, "internal abort task prep: failed[%d]!\n", rc);

	return rc;
}

/**
2046
 * _hisi_sas_internal_task_abort -- execute an internal
2047 2048 2049 2050 2051 2052
 * abort command for single IO command or a device
 * @hisi_hba: host controller struct
 * @device: domain device
 * @abort_flag: mode of operation, device or single IO
 * @tag: tag of IO to be aborted (only relevant to single
 *       IO mode)
2053
 * @dq: delivery queue for this internal abort command
2054 2055
 */
static int
2056 2057 2058
_hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
			      struct domain_device *device, int abort_flag,
			      int tag, struct hisi_sas_dq *dq)
2059 2060 2061
{
	struct sas_task *task;
	struct hisi_sas_device *sas_dev = device->lldd_dev;
2062
	struct device *dev = hisi_hba->dev;
2063 2064
	int res;

2065 2066 2067 2068 2069 2070
	/*
	 * The interface is not realized means this HW don't support internal
	 * abort, or don't need to do internal abort. Then here, we return
	 * TMF_RESP_FUNC_FAILED and let other steps go on, which depends that
	 * the internal abort has been executed and returned CQ.
	 */
2071
	if (!hisi_hba->hw->prep_abort)
2072
		return TMF_RESP_FUNC_FAILED;
2073 2074 2075 2076 2077 2078 2079 2080

	task = sas_alloc_slow_task(GFP_KERNEL);
	if (!task)
		return -ENOMEM;

	task->dev = device;
	task->task_proto = device->tproto;
	task->task_done = hisi_sas_task_done;
2081
	task->slow_task->timer.function = hisi_sas_tmf_timedout;
2082
	task->slow_task->timer.expires = jiffies + INTERNAL_ABORT_TIMEOUT * HZ;
2083 2084 2085
	add_timer(&task->slow_task->timer);

	res = hisi_sas_internal_abort_task_exec(hisi_hba, sas_dev->device_id,
2086
						task, abort_flag, tag, dq);
2087 2088 2089 2090 2091 2092 2093 2094 2095
	if (res) {
		del_timer(&task->slow_task->timer);
		dev_err(dev, "internal task abort: executing internal task failed: %d\n",
			res);
		goto exit;
	}
	wait_for_completion(&task->slow_task->completion);
	res = TMF_RESP_FUNC_FAILED;

2096 2097
	/* Internal abort timed out */
	if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
2098
		if (hisi_sas_debugfs_enable && hisi_hba->debugfs_itct[0].itct)
2099 2100
			queue_work(hisi_hba->wq, &hisi_hba->debugfs_work);

2101 2102
		if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
			struct hisi_sas_slot *slot = task->lldd_task;
2103 2104

			if (slot) {
2105 2106
				struct hisi_sas_cq *cq =
					&hisi_hba->cq[slot->dlvry_queue];
2107
				/*
2108
				 * sync irq to avoid free'ing task
2109 2110
				 * before using task in IO completion
				 */
2111
				synchronize_irq(cq->irq_no);
2112
				slot->task = NULL;
2113
			}
2114
			dev_err(dev, "internal task abort: timeout and not done.\n");
2115

2116
			res = -EIO;
2117
			goto exit;
2118 2119
		} else
			dev_err(dev, "internal task abort: timeout.\n");
2120 2121
	}

2122 2123 2124 2125 2126 2127
	if (task->task_status.resp == SAS_TASK_COMPLETE &&
		task->task_status.stat == TMF_RESP_FUNC_COMPLETE) {
		res = TMF_RESP_FUNC_COMPLETE;
		goto exit;
	}

2128 2129 2130 2131 2132 2133
	if (task->task_status.resp == SAS_TASK_COMPLETE &&
		task->task_status.stat == TMF_RESP_FUNC_SUCC) {
		res = TMF_RESP_FUNC_SUCC;
		goto exit;
	}

2134
exit:
2135
	dev_dbg(dev, "internal task abort: task to dev %016llx task=%pK resp: 0x%x sts 0x%x\n",
2136
		SAS_ADDR(device->sas_addr), task,
2137 2138 2139 2140 2141 2142 2143
		task->task_status.resp, /* 0 is complete, -1 is undelivered */
		task->task_status.stat);
	sas_free_task(task);

	return res;
}

2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161
static int
hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
			     struct domain_device *device,
			     int abort_flag, int tag)
{
	struct hisi_sas_slot *slot;
	struct device *dev = hisi_hba->dev;
	struct hisi_sas_dq *dq;
	int i, rc;

	switch (abort_flag) {
	case HISI_SAS_INT_ABT_CMD:
		slot = &hisi_hba->slot_info[tag];
		dq = &hisi_hba->dq[slot->dlvry_queue];
		return _hisi_sas_internal_task_abort(hisi_hba, device,
						     abort_flag, tag, dq);
	case HISI_SAS_INT_ABT_DEV:
		for (i = 0; i < hisi_hba->cq_nvecs; i++) {
2162
			struct hisi_sas_cq *cq = &hisi_hba->cq[i];
2163
			const struct cpumask *mask = cq->irq_mask;
2164 2165 2166

			if (mask && !cpumask_intersects(cpu_online_mask, mask))
				continue;
2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183
			dq = &hisi_hba->dq[i];
			rc = _hisi_sas_internal_task_abort(hisi_hba, device,
							   abort_flag, tag,
							   dq);
			if (rc)
				return rc;
		}
		break;
	default:
		dev_err(dev, "Unrecognised internal abort flag (%d)\n",
			abort_flag);
		return -EINVAL;
	}

	return 0;
}

J
John Garry 已提交
2184 2185 2186 2187 2188
static void hisi_sas_port_formed(struct asd_sas_phy *sas_phy)
{
	hisi_sas_port_notify_formed(sas_phy);
}

2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200
static int hisi_sas_write_gpio(struct sas_ha_struct *sha, u8 reg_type,
			u8 reg_index, u8 reg_count, u8 *write_data)
{
	struct hisi_hba *hisi_hba = sha->lldd_ha;

	if (!hisi_hba->hw->write_gpio)
		return -EOPNOTSUPP;

	return hisi_hba->hw->write_gpio(hisi_hba, reg_type,
				reg_index, reg_count, write_data);
}

J
John Garry 已提交
2201 2202
static void hisi_sas_phy_disconnected(struct hisi_sas_phy *phy)
{
2203 2204
	struct asd_sas_phy *sas_phy = &phy->sas_phy;
	struct sas_phy *sphy = sas_phy->phy;
2205
	unsigned long flags;
2206

J
John Garry 已提交
2207 2208 2209
	phy->phy_attached = 0;
	phy->phy_type = 0;
	phy->port = NULL;
2210

2211 2212
	spin_lock_irqsave(&phy->lock, flags);
	if (phy->enable)
2213 2214 2215
		sphy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
	else
		sphy->negotiated_linkrate = SAS_PHY_DISABLED;
2216
	spin_unlock_irqrestore(&phy->lock, flags);
J
John Garry 已提交
2217 2218
}

2219 2220
void hisi_sas_phy_down(struct hisi_hba *hisi_hba, int phy_no, int rdy,
		       gfp_t gfp_flags)
J
John Garry 已提交
2221 2222 2223
{
	struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
	struct asd_sas_phy *sas_phy = &phy->sas_phy;
2224
	struct device *dev = hisi_hba->dev;
J
John Garry 已提交
2225 2226 2227

	if (rdy) {
		/* Phy down but ready */
2228
		hisi_sas_bytes_dmaed(hisi_hba, phy_no, gfp_flags);
J
John Garry 已提交
2229 2230 2231 2232
		hisi_sas_port_notify_formed(sas_phy);
	} else {
		struct hisi_sas_port *port  = phy->port;

2233 2234
		if (test_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags) ||
		    phy->in_reset) {
2235 2236 2237
			dev_info(dev, "ignore flutter phy%d down\n", phy_no);
			return;
		}
J
John Garry 已提交
2238
		/* Phy down and not ready */
2239
		sas_notify_phy_event(sas_phy, PHYE_LOSS_OF_SIGNAL, gfp_flags);
J
John Garry 已提交
2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256
		sas_phy_disconnected(sas_phy);

		if (port) {
			if (phy->phy_type & PORT_TYPE_SAS) {
				int port_id = port->id;

				if (!hisi_hba->hw->get_wideport_bitmap(hisi_hba,
								       port_id))
					port->port_attached = 0;
			} else if (phy->phy_type & PORT_TYPE_SATA)
				port->port_attached = 0;
		}
		hisi_sas_phy_disconnected(phy);
	}
}
EXPORT_SYMBOL_GPL(hisi_sas_phy_down);

2257
void hisi_sas_sync_irqs(struct hisi_hba *hisi_hba)
2258 2259 2260
{
	int i;

2261
	for (i = 0; i < hisi_hba->cq_nvecs; i++) {
2262 2263
		struct hisi_sas_cq *cq = &hisi_hba->cq[i];

2264
		synchronize_irq(cq->irq_no);
2265 2266
	}
}
2267
EXPORT_SYMBOL_GPL(hisi_sas_sync_irqs);
2268

2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281
int hisi_sas_host_reset(struct Scsi_Host *shost, int reset_type)
{
	struct hisi_hba *hisi_hba = shost_priv(shost);

	if (reset_type != SCSI_ADAPTER_RESET)
		return -EOPNOTSUPP;

	queue_work(hisi_hba->wq, &hisi_hba->rst_work);

	return 0;
}
EXPORT_SYMBOL_GPL(hisi_sas_host_reset);

2282 2283
struct scsi_transport_template *hisi_sas_stt;
EXPORT_SYMBOL_GPL(hisi_sas_stt);
2284 2285

static struct sas_domain_function_template hisi_sas_transport_ops = {
J
John Garry 已提交
2286 2287
	.lldd_dev_found		= hisi_sas_dev_found,
	.lldd_dev_gone		= hisi_sas_dev_gone,
J
John Garry 已提交
2288
	.lldd_execute_task	= hisi_sas_queue_command,
J
John Garry 已提交
2289
	.lldd_control_phy	= hisi_sas_control_phy,
J
John Garry 已提交
2290 2291 2292 2293 2294 2295
	.lldd_abort_task	= hisi_sas_abort_task,
	.lldd_abort_task_set	= hisi_sas_abort_task_set,
	.lldd_clear_aca		= hisi_sas_clear_aca,
	.lldd_I_T_nexus_reset	= hisi_sas_I_T_nexus_reset,
	.lldd_lu_reset		= hisi_sas_lu_reset,
	.lldd_query_task	= hisi_sas_query_task,
2296
	.lldd_clear_nexus_ha	= hisi_sas_clear_nexus_ha,
J
John Garry 已提交
2297
	.lldd_port_formed	= hisi_sas_port_formed,
2298
	.lldd_write_gpio	= hisi_sas_write_gpio,
2299 2300
};

2301 2302
void hisi_sas_init_mem(struct hisi_hba *hisi_hba)
{
2303
	int i, s, j, max_command_entries = HISI_SAS_MAX_COMMANDS;
J
John Garry 已提交
2304
	struct hisi_sas_breakpoint *sata_breakpoint = hisi_hba->sata_breakpoint;
2305 2306 2307 2308

	for (i = 0; i < hisi_hba->queue_count; i++) {
		struct hisi_sas_cq *cq = &hisi_hba->cq[i];
		struct hisi_sas_dq *dq = &hisi_hba->dq[i];
J
John Garry 已提交
2309 2310 2311 2312 2313
		struct hisi_sas_cmd_hdr *cmd_hdr = hisi_hba->cmd_hdr[i];

		s = sizeof(struct hisi_sas_cmd_hdr);
		for (j = 0; j < HISI_SAS_QUEUE_SLOTS; j++)
			memset(&cmd_hdr[j], 0, s);
2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330

		dq->wr_point = 0;

		s = hisi_hba->hw->complete_hdr_size * HISI_SAS_QUEUE_SLOTS;
		memset(hisi_hba->complete_hdr[i], 0, s);
		cq->rd_point = 0;
	}

	s = sizeof(struct hisi_sas_initial_fis) * hisi_hba->n_phy;
	memset(hisi_hba->initial_fis, 0, s);

	s = max_command_entries * sizeof(struct hisi_sas_iost);
	memset(hisi_hba->iost, 0, s);

	s = max_command_entries * sizeof(struct hisi_sas_breakpoint);
	memset(hisi_hba->breakpoint, 0, s);

J
John Garry 已提交
2331 2332 2333
	s = sizeof(struct hisi_sas_sata_breakpoint);
	for (j = 0; j < HISI_SAS_MAX_ITCT_ENTRIES; j++)
		memset(&sata_breakpoint[j], 0, s);
2334 2335 2336
}
EXPORT_SYMBOL_GPL(hisi_sas_init_mem);

2337
int hisi_sas_alloc(struct hisi_hba *hisi_hba)
2338
{
2339
	struct device *dev = hisi_hba->dev;
2340
	int i, j, s, max_command_entries = HISI_SAS_MAX_COMMANDS;
2341 2342
	int max_command_entries_ru, sz_slot_buf_ru;
	int blk_cnt, slots_per_blk;
2343

2344
	sema_init(&hisi_hba->sem, 1);
J
John Garry 已提交
2345
	spin_lock_init(&hisi_hba->lock);
J
John Garry 已提交
2346 2347 2348 2349 2350 2351
	for (i = 0; i < hisi_hba->n_phy; i++) {
		hisi_sas_phy_init(hisi_hba, i);
		hisi_hba->port[i].port_attached = 0;
		hisi_hba->port[i].id = -1;
	}

J
John Garry 已提交
2352 2353 2354
	for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
		hisi_hba->devices[i].dev_type = SAS_PHY_UNUSED;
		hisi_hba->devices[i].device_id = i;
2355
		hisi_hba->devices[i].dev_status = HISI_SAS_DEV_INIT;
J
John Garry 已提交
2356 2357
	}

2358
	for (i = 0; i < hisi_hba->queue_count; i++) {
2359
		struct hisi_sas_cq *cq = &hisi_hba->cq[i];
2360
		struct hisi_sas_dq *dq = &hisi_hba->dq[i];
2361 2362 2363 2364 2365

		/* Completion queue structure */
		cq->id = i;
		cq->hisi_hba = hisi_hba;

2366
		/* Delivery queue structure */
2367
		spin_lock_init(&dq->lock);
2368
		INIT_LIST_HEAD(&dq->list);
2369 2370 2371
		dq->id = i;
		dq->hisi_hba = hisi_hba;

2372 2373
		/* Delivery queue */
		s = sizeof(struct hisi_sas_cmd_hdr) * HISI_SAS_QUEUE_SLOTS;
2374 2375 2376
		hisi_hba->cmd_hdr[i] = dmam_alloc_coherent(dev, s,
						&hisi_hba->cmd_hdr_dma[i],
						GFP_KERNEL);
2377 2378 2379 2380 2381
		if (!hisi_hba->cmd_hdr[i])
			goto err_out;

		/* Completion queue */
		s = hisi_hba->hw->complete_hdr_size * HISI_SAS_QUEUE_SLOTS;
2382 2383 2384
		hisi_hba->complete_hdr[i] = dmam_alloc_coherent(dev, s,
						&hisi_hba->complete_hdr_dma[i],
						GFP_KERNEL);
2385 2386 2387 2388 2389
		if (!hisi_hba->complete_hdr[i])
			goto err_out;
	}

	s = HISI_SAS_MAX_ITCT_ENTRIES * sizeof(struct hisi_sas_itct);
2390
	hisi_hba->itct = dmam_alloc_coherent(dev, s, &hisi_hba->itct_dma,
2391
					     GFP_KERNEL);
2392 2393 2394
	if (!hisi_hba->itct)
		goto err_out;

2395
	hisi_hba->slot_info = devm_kcalloc(dev, max_command_entries,
2396 2397 2398 2399 2400
					   sizeof(struct hisi_sas_slot),
					   GFP_KERNEL);
	if (!hisi_hba->slot_info)
		goto err_out;

2401 2402
	/* roundup to avoid overly large block size */
	max_command_entries_ru = roundup(max_command_entries, 64);
2403 2404 2405 2406 2407
	if (hisi_hba->prot_mask & HISI_SAS_DIX_PROT_MASK)
		sz_slot_buf_ru = sizeof(struct hisi_sas_slot_dif_buf_table);
	else
		sz_slot_buf_ru = sizeof(struct hisi_sas_slot_buf_table);
	sz_slot_buf_ru = roundup(sz_slot_buf_ru, 64);
2408
	s = max(lcm(max_command_entries_ru, sz_slot_buf_ru), PAGE_SIZE);
2409 2410
	blk_cnt = (max_command_entries_ru * sz_slot_buf_ru) / s;
	slots_per_blk = s / sz_slot_buf_ru;
2411

2412 2413
	for (i = 0; i < blk_cnt; i++) {
		int slot_index = i * slots_per_blk;
2414 2415
		dma_addr_t buf_dma;
		void *buf;
2416

2417
		buf = dmam_alloc_coherent(dev, s, &buf_dma,
2418
					  GFP_KERNEL);
2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429
		if (!buf)
			goto err_out;

		for (j = 0; j < slots_per_blk; j++, slot_index++) {
			struct hisi_sas_slot *slot;

			slot = &hisi_hba->slot_info[slot_index];
			slot->buf = buf;
			slot->buf_dma = buf_dma;
			slot->idx = slot_index;

2430 2431
			buf += sz_slot_buf_ru;
			buf_dma += sz_slot_buf_ru;
2432 2433 2434
		}
	}

2435
	s = max_command_entries * sizeof(struct hisi_sas_iost);
2436 2437
	hisi_hba->iost = dmam_alloc_coherent(dev, s, &hisi_hba->iost_dma,
					     GFP_KERNEL);
2438 2439 2440
	if (!hisi_hba->iost)
		goto err_out;

2441
	s = max_command_entries * sizeof(struct hisi_sas_breakpoint);
2442 2443 2444
	hisi_hba->breakpoint = dmam_alloc_coherent(dev, s,
						   &hisi_hba->breakpoint_dma,
						   GFP_KERNEL);
2445 2446 2447
	if (!hisi_hba->breakpoint)
		goto err_out;

2448
	hisi_hba->slot_index_count = max_command_entries;
2449
	s = hisi_hba->slot_index_count / BITS_PER_BYTE;
J
John Garry 已提交
2450 2451 2452 2453
	hisi_hba->slot_index_tags = devm_kzalloc(dev, s, GFP_KERNEL);
	if (!hisi_hba->slot_index_tags)
		goto err_out;

2454
	s = sizeof(struct hisi_sas_initial_fis) * HISI_SAS_MAX_PHYS;
2455 2456 2457
	hisi_hba->initial_fis = dmam_alloc_coherent(dev, s,
						    &hisi_hba->initial_fis_dma,
						    GFP_KERNEL);
2458 2459 2460
	if (!hisi_hba->initial_fis)
		goto err_out;

2461
	s = HISI_SAS_MAX_ITCT_ENTRIES * sizeof(struct hisi_sas_sata_breakpoint);
2462 2463 2464
	hisi_hba->sata_breakpoint = dmam_alloc_coherent(dev, s,
					&hisi_hba->sata_breakpoint_dma,
					GFP_KERNEL);
2465 2466 2467
	if (!hisi_hba->sata_breakpoint)
		goto err_out;

J
John Garry 已提交
2468
	hisi_sas_slot_index_init(hisi_hba);
2469
	hisi_hba->last_slot_index = HISI_SAS_UNRESERVED_IPTT;
J
John Garry 已提交
2470

J
John Garry 已提交
2471 2472 2473 2474 2475 2476
	hisi_hba->wq = create_singlethread_workqueue(dev_name(dev));
	if (!hisi_hba->wq) {
		dev_err(dev, "sas_alloc: failed to create workqueue\n");
		goto err_out;
	}

2477 2478 2479 2480
	return 0;
err_out:
	return -ENOMEM;
}
2481
EXPORT_SYMBOL_GPL(hisi_sas_alloc);
2482

2483
void hisi_sas_free(struct hisi_hba *hisi_hba)
J
John Garry 已提交
2484
{
2485 2486 2487 2488 2489 2490 2491 2492
	int i;

	for (i = 0; i < hisi_hba->n_phy; i++) {
		struct hisi_sas_phy *phy = &hisi_hba->phy[i];

		del_timer_sync(&phy->timer);
	}

J
John Garry 已提交
2493 2494
	if (hisi_hba->wq)
		destroy_workqueue(hisi_hba->wq);
J
John Garry 已提交
2495
}
2496
EXPORT_SYMBOL_GPL(hisi_sas_free);
2497

2498
void hisi_sas_rst_work_handler(struct work_struct *work)
2499 2500 2501 2502
{
	struct hisi_hba *hisi_hba =
		container_of(work, struct hisi_hba, rst_work);

2503 2504 2505
	if (hisi_sas_controller_prereset(hisi_hba))
		return;

2506 2507
	hisi_sas_controller_reset(hisi_hba);
}
2508
EXPORT_SYMBOL_GPL(hisi_sas_rst_work_handler);
2509

2510 2511 2512 2513 2514
void hisi_sas_sync_rst_work_handler(struct work_struct *work)
{
	struct hisi_sas_rst *rst =
		container_of(work, struct hisi_sas_rst, work);

2515 2516 2517
	if (hisi_sas_controller_prereset(rst->hisi_hba))
		goto rst_complete;

2518 2519
	if (!hisi_sas_controller_reset(rst->hisi_hba))
		rst->done = true;
2520
rst_complete:
2521 2522 2523 2524
	complete(rst->completion);
}
EXPORT_SYMBOL_GPL(hisi_sas_sync_rst_work_handler);

2525
int hisi_sas_get_fw_info(struct hisi_hba *hisi_hba)
J
John Garry 已提交
2526
{
2527 2528 2529
	struct device *dev = hisi_hba->dev;
	struct platform_device *pdev = hisi_hba->platform_dev;
	struct device_node *np = pdev ? pdev->dev.of_node : NULL;
2530
	struct clk *refclk;
J
John Garry 已提交
2531

2532
	if (device_property_read_u8_array(dev, "sas-addr", hisi_hba->sas_addr,
2533 2534 2535 2536
					  SAS_ADDR_SIZE)) {
		dev_err(dev, "could not get property sas-addr\n");
		return -ENOENT;
	}
J
John Garry 已提交
2537

2538
	if (np) {
2539 2540 2541 2542
		/*
		 * These properties are only required for platform device-based
		 * controller with DT firmware.
		 */
2543 2544
		hisi_hba->ctrl = syscon_regmap_lookup_by_phandle(np,
					"hisilicon,sas-syscon");
2545 2546 2547 2548
		if (IS_ERR(hisi_hba->ctrl)) {
			dev_err(dev, "could not get syscon\n");
			return -ENOENT;
		}
J
John Garry 已提交
2549

2550
		if (device_property_read_u32(dev, "ctrl-reset-reg",
2551
					     &hisi_hba->ctrl_reset_reg)) {
X
Xiang Chen 已提交
2552
			dev_err(dev, "could not get property ctrl-reset-reg\n");
2553 2554
			return -ENOENT;
		}
J
John Garry 已提交
2555

2556
		if (device_property_read_u32(dev, "ctrl-reset-sts-reg",
2557
					     &hisi_hba->ctrl_reset_sts_reg)) {
X
Xiang Chen 已提交
2558
			dev_err(dev, "could not get property ctrl-reset-sts-reg\n");
2559 2560
			return -ENOENT;
		}
J
John Garry 已提交
2561

2562
		if (device_property_read_u32(dev, "ctrl-clock-ena-reg",
2563
					     &hisi_hba->ctrl_clock_ena_reg)) {
X
Xiang Chen 已提交
2564
			dev_err(dev, "could not get property ctrl-clock-ena-reg\n");
2565 2566
			return -ENOENT;
		}
2567 2568
	}

2569
	refclk = devm_clk_get(dev, NULL);
2570
	if (IS_ERR(refclk))
2571
		dev_dbg(dev, "no ref clk property\n");
2572 2573 2574
	else
		hisi_hba->refclk_frequency_mhz = clk_get_rate(refclk) / 1000000;

2575 2576 2577 2578
	if (device_property_read_u32(dev, "phy-count", &hisi_hba->n_phy)) {
		dev_err(dev, "could not get property phy-count\n");
		return -ENOENT;
	}
J
John Garry 已提交
2579

2580
	if (device_property_read_u32(dev, "queue-count",
2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596
				     &hisi_hba->queue_count)) {
		dev_err(dev, "could not get property queue-count\n");
		return -ENOENT;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(hisi_sas_get_fw_info);

static struct Scsi_Host *hisi_sas_shost_alloc(struct platform_device *pdev,
					      const struct hisi_sas_hw *hw)
{
	struct resource *res;
	struct Scsi_Host *shost;
	struct hisi_hba *hisi_hba;
	struct device *dev = &pdev->dev;
2597
	int error;
2598

2599
	shost = scsi_host_alloc(hw->sht, sizeof(*hisi_hba));
2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612
	if (!shost) {
		dev_err(dev, "scsi host alloc failed\n");
		return NULL;
	}
	hisi_hba = shost_priv(shost);

	INIT_WORK(&hisi_hba->rst_work, hisi_sas_rst_work_handler);
	hisi_hba->hw = hw;
	hisi_hba->dev = dev;
	hisi_hba->platform_dev = pdev;
	hisi_hba->shost = shost;
	SHOST_TO_SAS_HA(shost) = &hisi_hba->sha;

2613
	timer_setup(&hisi_hba->timer, NULL, 0);
2614 2615

	if (hisi_sas_get_fw_info(hisi_hba) < 0)
J
John Garry 已提交
2616 2617
		goto err_out;

2618 2619 2620 2621 2622
	error = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64));
	if (error)
		error = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));

	if (error) {
2623 2624 2625 2626
		dev_err(dev, "No usable DMA addressing method\n");
		goto err_out;
	}

2627
	hisi_hba->regs = devm_platform_ioremap_resource(pdev, 0);
J
John Garry 已提交
2628 2629 2630
	if (IS_ERR(hisi_hba->regs))
		goto err_out;

2631 2632 2633 2634 2635 2636 2637
	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	if (res) {
		hisi_hba->sgpio_regs = devm_ioremap_resource(dev, res);
		if (IS_ERR(hisi_hba->sgpio_regs))
			goto err_out;
	}

2638
	if (hisi_sas_alloc(hisi_hba)) {
J
John Garry 已提交
2639
		hisi_sas_free(hisi_hba);
2640
		goto err_out;
J
John Garry 已提交
2641
	}
2642

J
John Garry 已提交
2643 2644
	return shost;
err_out:
2645
	scsi_host_put(shost);
J
John Garry 已提交
2646 2647 2648 2649
	dev_err(dev, "shost alloc failed\n");
	return NULL;
}

2650 2651 2652 2653 2654 2655 2656
static int hisi_sas_interrupt_preinit(struct hisi_hba *hisi_hba)
{
	if (hisi_hba->hw->interrupt_preinit)
		return hisi_hba->hw->interrupt_preinit(hisi_hba);
	return 0;
}

J
John Garry 已提交
2657
int hisi_sas_probe(struct platform_device *pdev,
2658
		   const struct hisi_sas_hw *hw)
J
John Garry 已提交
2659 2660 2661 2662 2663 2664 2665 2666 2667 2668
{
	struct Scsi_Host *shost;
	struct hisi_hba *hisi_hba;
	struct device *dev = &pdev->dev;
	struct asd_sas_phy **arr_phy;
	struct asd_sas_port **arr_port;
	struct sas_ha_struct *sha;
	int rc, phy_nr, port_nr, i;

	shost = hisi_sas_shost_alloc(pdev, hw);
2669 2670
	if (!shost)
		return -ENOMEM;
J
John Garry 已提交
2671 2672 2673 2674

	sha = SHOST_TO_SAS_HA(shost);
	hisi_hba = shost_priv(shost);
	platform_set_drvdata(pdev, sha);
J
John Garry 已提交
2675

J
John Garry 已提交
2676 2677 2678 2679
	phy_nr = port_nr = hisi_hba->n_phy;

	arr_phy = devm_kcalloc(dev, phy_nr, sizeof(void *), GFP_KERNEL);
	arr_port = devm_kcalloc(dev, port_nr, sizeof(void *), GFP_KERNEL);
2680 2681 2682 2683
	if (!arr_phy || !arr_port) {
		rc = -ENOMEM;
		goto err_out_ha;
	}
J
John Garry 已提交
2684 2685 2686 2687 2688 2689 2690 2691 2692 2693

	sha->sas_phy = arr_phy;
	sha->sas_port = arr_port;
	sha->lldd_ha = hisi_hba;

	shost->transportt = hisi_sas_stt;
	shost->max_id = HISI_SAS_MAX_DEVICES;
	shost->max_lun = ~0;
	shost->max_channel = 1;
	shost->max_cmd_len = 16;
2694
	if (hisi_hba->hw->slot_index_alloc) {
2695 2696
		shost->can_queue = HISI_SAS_MAX_COMMANDS;
		shost->cmd_per_lun = HISI_SAS_MAX_COMMANDS;
2697
	} else {
2698 2699
		shost->can_queue = HISI_SAS_UNRESERVED_IPTT;
		shost->cmd_per_lun = HISI_SAS_UNRESERVED_IPTT;
2700
	}
J
John Garry 已提交
2701 2702

	sha->sas_ha_name = DRV_NAME;
2703
	sha->dev = hisi_hba->dev;
J
John Garry 已提交
2704 2705 2706 2707 2708 2709 2710 2711 2712 2713
	sha->lldd_module = THIS_MODULE;
	sha->sas_addr = &hisi_hba->sas_addr[0];
	sha->num_phys = hisi_hba->n_phy;
	sha->core.shost = hisi_hba->shost;

	for (i = 0; i < hisi_hba->n_phy; i++) {
		sha->sas_phy[i] = &hisi_hba->phy[i].sas_phy;
		sha->sas_port[i] = &hisi_hba->port[i].sas_port;
	}

2714 2715 2716 2717
	rc = hisi_sas_interrupt_preinit(hisi_hba);
	if (rc)
		goto err_out_ha;

J
John Garry 已提交
2718 2719 2720 2721 2722 2723 2724 2725
	rc = scsi_add_host(shost, &pdev->dev);
	if (rc)
		goto err_out_ha;

	rc = sas_register_ha(sha);
	if (rc)
		goto err_out_register_ha;

2726 2727
	rc = hisi_hba->hw->hw_init(hisi_hba);
	if (rc)
2728
		goto err_out_hw_init;
2729

J
John Garry 已提交
2730 2731 2732 2733
	scsi_scan_host(shost);

	return 0;

2734 2735
err_out_hw_init:
	sas_unregister_ha(sha);
J
John Garry 已提交
2736 2737 2738
err_out_register_ha:
	scsi_remove_host(shost);
err_out_ha:
2739
	hisi_sas_free(hisi_hba);
2740
	scsi_host_put(shost);
J
John Garry 已提交
2741 2742 2743 2744
	return rc;
}
EXPORT_SYMBOL_GPL(hisi_sas_probe);

J
John Garry 已提交
2745
int hisi_sas_remove(struct platform_device *pdev)
2746
{
J
John Garry 已提交
2747 2748
	struct sas_ha_struct *sha = platform_get_drvdata(pdev);
	struct hisi_hba *hisi_hba = sha->lldd_ha;
2749
	struct Scsi_Host *shost = sha->core.shost;
2750

2751 2752
	if (timer_pending(&hisi_hba->timer))
		del_timer(&hisi_hba->timer);
2753

J
John Garry 已提交
2754 2755
	sas_unregister_ha(sha);
	sas_remove_host(sha->core.shost);
2756

J
John Garry 已提交
2757
	hisi_sas_free(hisi_hba);
2758
	scsi_host_put(shost);
2759 2760
	return 0;
}
J
John Garry 已提交
2761
EXPORT_SYMBOL_GPL(hisi_sas_remove);
2762

2763 2764 2765 2766 2767 2768
#if IS_ENABLED(CONFIG_SCSI_HISI_SAS_DEBUGFS_DEFAULT_ENABLE)
#define DEBUGFS_ENABLE_DEFAULT  "enabled"
bool hisi_sas_debugfs_enable = true;
u32 hisi_sas_debugfs_dump_count = 50;
#else
#define DEBUGFS_ENABLE_DEFAULT "disabled"
2769
bool hisi_sas_debugfs_enable;
2770 2771 2772
u32 hisi_sas_debugfs_dump_count = 1;
#endif

2773 2774
EXPORT_SYMBOL_GPL(hisi_sas_debugfs_enable);
module_param_named(debugfs_enable, hisi_sas_debugfs_enable, bool, 0444);
2775 2776
MODULE_PARM_DESC(hisi_sas_debugfs_enable,
		 "Enable driver debugfs (default "DEBUGFS_ENABLE_DEFAULT")");
2777

2778 2779 2780
EXPORT_SYMBOL_GPL(hisi_sas_debugfs_dump_count);
module_param_named(debugfs_dump_count, hisi_sas_debugfs_dump_count, uint, 0444);
MODULE_PARM_DESC(hisi_sas_debugfs_dump_count, "Number of debugfs dumps to allow");
2781

2782 2783
struct dentry *hisi_sas_debugfs_dir;
EXPORT_SYMBOL_GPL(hisi_sas_debugfs_dir);
2784

2785 2786 2787 2788 2789 2790
static __init int hisi_sas_init(void)
{
	hisi_sas_stt = sas_domain_attach_transport(&hisi_sas_transport_ops);
	if (!hisi_sas_stt)
		return -ENOMEM;

2791
	if (hisi_sas_debugfs_enable) {
2792
		hisi_sas_debugfs_dir = debugfs_create_dir("hisi_sas", NULL);
2793 2794 2795 2796 2797
		if (hisi_sas_debugfs_dump_count > HISI_SAS_MAX_DEBUGFS_DUMP) {
			pr_info("hisi_sas: Limiting debugfs dump count\n");
			hisi_sas_debugfs_dump_count = HISI_SAS_MAX_DEBUGFS_DUMP;
		}
	}
2798

2799 2800 2801 2802 2803 2804
	return 0;
}

static __exit void hisi_sas_exit(void)
{
	sas_release_transport(hisi_sas_stt);
2805 2806

	debugfs_remove(hisi_sas_debugfs_dir);
2807 2808 2809 2810 2811 2812 2813 2814 2815
}

module_init(hisi_sas_init);
module_exit(hisi_sas_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("John Garry <john.garry@huawei.com>");
MODULE_DESCRIPTION("HISILICON SAS controller driver");
MODULE_ALIAS("platform:" DRV_NAME);