1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (c) 2015 Linaro Ltd.
4  * Copyright (c) 2015 Hisilicon Limited.
5  */
6 
7 #include "hisi_sas.h"
8 #define DRV_NAME "hisi_sas"
9 
10 #define DEV_IS_GONE(dev) \
11 	((!dev) || (dev->dev_type == SAS_PHY_UNUSED))
12 
13 static int hisi_sas_debug_issue_ssp_tmf(struct domain_device *device,
14 				u8 *lun, struct hisi_sas_tmf_task *tmf);
15 static int
16 hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
17 			     struct domain_device *device,
18 			     int abort_flag, int tag);
19 static int hisi_sas_softreset_ata_disk(struct domain_device *device);
20 static int hisi_sas_control_phy(struct asd_sas_phy *sas_phy, enum phy_func func,
21 				void *funcdata);
22 static void hisi_sas_release_task(struct hisi_hba *hisi_hba,
23 				  struct domain_device *device);
24 static void hisi_sas_dev_gone(struct domain_device *device);
25 
26 u8 hisi_sas_get_ata_protocol(struct host_to_dev_fis *fis, int direction)
27 {
28 	switch (fis->command) {
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 
80 	case ATA_CMD_SET_MAX:
81 		switch (fis->features) {
82 		case ATA_SET_MAX_PASSWD:
83 		case ATA_SET_MAX_LOCK:
84 			return HISI_SAS_SATA_PROTOCOL_PIO;
85 
86 		case ATA_SET_MAX_PASSWD_DMA:
87 		case ATA_SET_MAX_UNLOCK_DMA:
88 			return HISI_SAS_SATA_PROTOCOL_DMA;
89 
90 		default:
91 			return HISI_SAS_SATA_PROTOCOL_NONDATA;
92 		}
93 
94 	default:
95 	{
96 		if (direction == DMA_NONE)
97 			return HISI_SAS_SATA_PROTOCOL_NONDATA;
98 		return HISI_SAS_SATA_PROTOCOL_PIO;
99 	}
100 	}
101 }
102 EXPORT_SYMBOL_GPL(hisi_sas_get_ata_protocol);
103 
104 void hisi_sas_sata_done(struct sas_task *task,
105 			    struct hisi_sas_slot *slot)
106 {
107 	struct task_status_struct *ts = &task->task_status;
108 	struct ata_task_resp *resp = (struct ata_task_resp *)ts->buf;
109 	struct hisi_sas_status_buffer *status_buf =
110 			hisi_sas_status_buf_addr_mem(slot);
111 	u8 *iu = &status_buf->iu[0];
112 	struct dev_to_host_fis *d2h =  (struct dev_to_host_fis *)iu;
113 
114 	resp->frame_len = sizeof(struct dev_to_host_fis);
115 	memcpy(&resp->ending_fis[0], d2h, sizeof(struct dev_to_host_fis));
116 
117 	ts->buf_valid_size = sizeof(*resp);
118 }
119 EXPORT_SYMBOL_GPL(hisi_sas_sata_done);
120 
121 /*
122  * This function assumes linkrate mask fits in 8 bits, which it
123  * does for all HW versions supported.
124  */
125 u8 hisi_sas_get_prog_phy_linkrate_mask(enum sas_linkrate max)
126 {
127 	u8 rate = 0;
128 	int i;
129 
130 	max -= SAS_LINK_RATE_1_5_GBPS;
131 	for (i = 0; i <= max; i++)
132 		rate |= 1 << (i * 2);
133 	return rate;
134 }
135 EXPORT_SYMBOL_GPL(hisi_sas_get_prog_phy_linkrate_mask);
136 
137 static struct hisi_hba *dev_to_hisi_hba(struct domain_device *device)
138 {
139 	return device->port->ha->lldd_ha;
140 }
141 
142 struct hisi_sas_port *to_hisi_sas_port(struct asd_sas_port *sas_port)
143 {
144 	return container_of(sas_port, struct hisi_sas_port, sas_port);
145 }
146 EXPORT_SYMBOL_GPL(to_hisi_sas_port);
147 
148 void hisi_sas_stop_phys(struct hisi_hba *hisi_hba)
149 {
150 	int phy_no;
151 
152 	for (phy_no = 0; phy_no < hisi_hba->n_phy; phy_no++)
153 		hisi_sas_phy_enable(hisi_hba, phy_no, 0);
154 }
155 EXPORT_SYMBOL_GPL(hisi_sas_stop_phys);
156 
157 static void hisi_sas_slot_index_clear(struct hisi_hba *hisi_hba, int slot_idx)
158 {
159 	void *bitmap = hisi_hba->slot_index_tags;
160 
161 	clear_bit(slot_idx, bitmap);
162 }
163 
164 static void hisi_sas_slot_index_free(struct hisi_hba *hisi_hba, int slot_idx)
165 {
166 	if (hisi_hba->hw->slot_index_alloc ||
167 	    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 	}
172 }
173 
174 static void hisi_sas_slot_index_set(struct hisi_hba *hisi_hba, int slot_idx)
175 {
176 	void *bitmap = hisi_hba->slot_index_tags;
177 
178 	set_bit(slot_idx, bitmap);
179 }
180 
181 static int hisi_sas_slot_index_alloc(struct hisi_hba *hisi_hba,
182 				     struct scsi_cmnd *scsi_cmnd)
183 {
184 	int index;
185 	void *bitmap = hisi_hba->slot_index_tags;
186 
187 	if (scsi_cmnd)
188 		return scsi_cmnd->request->tag;
189 
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 		index = find_next_zero_bit(bitmap,
195 				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 	}
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;
207 }
208 
209 static void hisi_sas_slot_index_init(struct hisi_hba *hisi_hba)
210 {
211 	int i;
212 
213 	for (i = 0; i < hisi_hba->slot_index_count; ++i)
214 		hisi_sas_slot_index_clear(hisi_hba, i);
215 }
216 
217 void hisi_sas_slot_task_free(struct hisi_hba *hisi_hba, struct sas_task *task,
218 			     struct hisi_sas_slot *slot)
219 {
220 	int device_id = slot->device_id;
221 	struct hisi_sas_device *sas_dev = &hisi_hba->devices[device_id];
222 
223 	if (task) {
224 		struct device *dev = hisi_hba->dev;
225 
226 		if (!task->lldd_task)
227 			return;
228 
229 		task->lldd_task = NULL;
230 
231 		if (!sas_protocol_ata(task->task_proto)) {
232 			struct sas_ssp_task *ssp_task = &task->ssp_task;
233 			struct scsi_cmnd *scsi_cmnd = ssp_task->cmd;
234 
235 			if (slot->n_elem)
236 				dma_unmap_sg(dev, task->scatter,
237 					     task->num_scatter,
238 					     task->data_dir);
239 			if (slot->n_elem_dif)
240 				dma_unmap_sg(dev, scsi_prot_sglist(scsi_cmnd),
241 					     scsi_prot_sg_count(scsi_cmnd),
242 					     task->data_dir);
243 		}
244 	}
245 
246 	spin_lock(&sas_dev->lock);
247 	list_del_init(&slot->entry);
248 	spin_unlock(&sas_dev->lock);
249 
250 	memset(slot, 0, offsetof(struct hisi_sas_slot, buf));
251 
252 	hisi_sas_slot_index_free(hisi_hba, slot->idx);
253 }
254 EXPORT_SYMBOL_GPL(hisi_sas_slot_task_free);
255 
256 static void hisi_sas_task_prep_smp(struct hisi_hba *hisi_hba,
257 				  struct hisi_sas_slot *slot)
258 {
259 	hisi_hba->hw->prep_smp(hisi_hba, slot);
260 }
261 
262 static void hisi_sas_task_prep_ssp(struct hisi_hba *hisi_hba,
263 				  struct hisi_sas_slot *slot)
264 {
265 	hisi_hba->hw->prep_ssp(hisi_hba, slot);
266 }
267 
268 static void hisi_sas_task_prep_ata(struct hisi_hba *hisi_hba,
269 				  struct hisi_sas_slot *slot)
270 {
271 	hisi_hba->hw->prep_stp(hisi_hba, slot);
272 }
273 
274 static void hisi_sas_task_prep_abort(struct hisi_hba *hisi_hba,
275 		struct hisi_sas_slot *slot,
276 		int device_id, int abort_flag, int tag_to_abort)
277 {
278 	hisi_hba->hw->prep_abort(hisi_hba, slot,
279 			device_id, abort_flag, tag_to_abort);
280 }
281 
282 static void hisi_sas_dma_unmap(struct hisi_hba *hisi_hba,
283 			       struct sas_task *task, int n_elem,
284 			       int n_elem_req)
285 {
286 	struct device *dev = hisi_hba->dev;
287 
288 	if (!sas_protocol_ata(task->task_proto)) {
289 		if (task->num_scatter) {
290 			if (n_elem)
291 				dma_unmap_sg(dev, task->scatter,
292 					     task->num_scatter,
293 					     task->data_dir);
294 		} else if (task->task_proto & SAS_PROTOCOL_SMP) {
295 			if (n_elem_req)
296 				dma_unmap_sg(dev, &task->smp_task.smp_req,
297 					     1, DMA_TO_DEVICE);
298 		}
299 	}
300 }
301 
302 static int hisi_sas_dma_map(struct hisi_hba *hisi_hba,
303 			    struct sas_task *task, int *n_elem,
304 			    int *n_elem_req)
305 {
306 	struct device *dev = hisi_hba->dev;
307 	int rc;
308 
309 	if (sas_protocol_ata(task->task_proto)) {
310 		*n_elem = task->num_scatter;
311 	} else {
312 		unsigned int req_len;
313 
314 		if (task->num_scatter) {
315 			*n_elem = dma_map_sg(dev, task->scatter,
316 					     task->num_scatter, task->data_dir);
317 			if (!*n_elem) {
318 				rc = -ENOMEM;
319 				goto prep_out;
320 			}
321 		} else if (task->task_proto & SAS_PROTOCOL_SMP) {
322 			*n_elem_req = dma_map_sg(dev, &task->smp_task.smp_req,
323 						 1, DMA_TO_DEVICE);
324 			if (!*n_elem_req) {
325 				rc = -ENOMEM;
326 				goto prep_out;
327 			}
328 			req_len = sg_dma_len(&task->smp_task.smp_req);
329 			if (req_len & 0x3) {
330 				rc = -EINVAL;
331 				goto err_out_dma_unmap;
332 			}
333 		}
334 	}
335 
336 	if (*n_elem > HISI_SAS_SGE_PAGE_CNT) {
337 		dev_err(dev, "task prep: n_elem(%d) > HISI_SAS_SGE_PAGE_CNT",
338 			*n_elem);
339 		rc = -EINVAL;
340 		goto err_out_dma_unmap;
341 	}
342 	return 0;
343 
344 err_out_dma_unmap:
345 	/* It would be better to call dma_unmap_sg() here, but it's messy */
346 	hisi_sas_dma_unmap(hisi_hba, task, *n_elem,
347 			   *n_elem_req);
348 prep_out:
349 	return rc;
350 }
351 
352 static void hisi_sas_dif_dma_unmap(struct hisi_hba *hisi_hba,
353 				   struct sas_task *task, int n_elem_dif)
354 {
355 	struct device *dev = hisi_hba->dev;
356 
357 	if (n_elem_dif) {
358 		struct sas_ssp_task *ssp_task = &task->ssp_task;
359 		struct scsi_cmnd *scsi_cmnd = ssp_task->cmd;
360 
361 		dma_unmap_sg(dev, scsi_prot_sglist(scsi_cmnd),
362 			     scsi_prot_sg_count(scsi_cmnd),
363 			     task->data_dir);
364 	}
365 }
366 
367 static int hisi_sas_dif_dma_map(struct hisi_hba *hisi_hba,
368 				int *n_elem_dif, struct sas_task *task)
369 {
370 	struct device *dev = hisi_hba->dev;
371 	struct sas_ssp_task *ssp_task;
372 	struct scsi_cmnd *scsi_cmnd;
373 	int rc;
374 
375 	if (task->num_scatter) {
376 		ssp_task = &task->ssp_task;
377 		scsi_cmnd = ssp_task->cmd;
378 
379 		if (scsi_prot_sg_count(scsi_cmnd)) {
380 			*n_elem_dif = dma_map_sg(dev,
381 						 scsi_prot_sglist(scsi_cmnd),
382 						 scsi_prot_sg_count(scsi_cmnd),
383 						 task->data_dir);
384 
385 			if (!*n_elem_dif)
386 				return -ENOMEM;
387 
388 			if (*n_elem_dif > HISI_SAS_SGE_DIF_PAGE_CNT) {
389 				dev_err(dev, "task prep: n_elem_dif(%d) too large\n",
390 					*n_elem_dif);
391 				rc = -EINVAL;
392 				goto err_out_dif_dma_unmap;
393 			}
394 		}
395 	}
396 
397 	return 0;
398 
399 err_out_dif_dma_unmap:
400 	dma_unmap_sg(dev, scsi_prot_sglist(scsi_cmnd),
401 		     scsi_prot_sg_count(scsi_cmnd), task->data_dir);
402 	return rc;
403 }
404 
405 static int hisi_sas_task_prep(struct sas_task *task,
406 			      struct hisi_sas_dq **dq_pointer,
407 			      bool is_tmf, struct hisi_sas_tmf_task *tmf,
408 			      int *pass)
409 {
410 	struct domain_device *device = task->dev;
411 	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
412 	struct hisi_sas_device *sas_dev = device->lldd_dev;
413 	struct hisi_sas_port *port;
414 	struct hisi_sas_slot *slot;
415 	struct hisi_sas_cmd_hdr	*cmd_hdr_base;
416 	struct asd_sas_port *sas_port = device->port;
417 	struct device *dev = hisi_hba->dev;
418 	int dlvry_queue_slot, dlvry_queue, rc, slot_idx;
419 	int n_elem = 0, n_elem_dif = 0, n_elem_req = 0;
420 	struct hisi_sas_dq *dq;
421 	unsigned long flags;
422 	int wr_q_index;
423 
424 	if (DEV_IS_GONE(sas_dev)) {
425 		if (sas_dev)
426 			dev_info(dev, "task prep: device %d not ready\n",
427 				 sas_dev->device_id);
428 		else
429 			dev_info(dev, "task prep: device %016llx not ready\n",
430 				 SAS_ADDR(device->sas_addr));
431 
432 		return -ECOMM;
433 	}
434 
435 	if (hisi_hba->reply_map) {
436 		int cpu = raw_smp_processor_id();
437 		unsigned int dq_index = hisi_hba->reply_map[cpu];
438 
439 		*dq_pointer = dq = &hisi_hba->dq[dq_index];
440 	} else {
441 		*dq_pointer = dq = sas_dev->dq;
442 	}
443 
444 	port = to_hisi_sas_port(sas_port);
445 	if (port && !port->port_attached) {
446 		dev_info(dev, "task prep: %s port%d not attach device\n",
447 			 (dev_is_sata(device)) ?
448 			 "SATA/STP" : "SAS",
449 			 device->port->id);
450 
451 		return -ECOMM;
452 	}
453 
454 	rc = hisi_sas_dma_map(hisi_hba, task, &n_elem,
455 			      &n_elem_req);
456 	if (rc < 0)
457 		goto prep_out;
458 
459 	if (!sas_protocol_ata(task->task_proto)) {
460 		rc = hisi_sas_dif_dma_map(hisi_hba, &n_elem_dif, task);
461 		if (rc < 0)
462 			goto err_out_dma_unmap;
463 	}
464 
465 	if (hisi_hba->hw->slot_index_alloc)
466 		rc = hisi_hba->hw->slot_index_alloc(hisi_hba, device);
467 	else {
468 		struct scsi_cmnd *scsi_cmnd = NULL;
469 
470 		if (task->uldd_task) {
471 			struct ata_queued_cmd *qc;
472 
473 			if (dev_is_sata(device)) {
474 				qc = task->uldd_task;
475 				scsi_cmnd = qc->scsicmd;
476 			} else {
477 				scsi_cmnd = task->uldd_task;
478 			}
479 		}
480 		rc  = hisi_sas_slot_index_alloc(hisi_hba, scsi_cmnd);
481 	}
482 	if (rc < 0)
483 		goto err_out_dif_dma_unmap;
484 
485 	slot_idx = rc;
486 	slot = &hisi_hba->slot_info[slot_idx];
487 
488 	spin_lock(&dq->lock);
489 	wr_q_index = dq->wr_point;
490 	dq->wr_point = (dq->wr_point + 1) % HISI_SAS_QUEUE_SLOTS;
491 	list_add_tail(&slot->delivery, &dq->list);
492 	spin_unlock(&dq->lock);
493 	spin_lock(&sas_dev->lock);
494 	list_add_tail(&slot->entry, &sas_dev->list);
495 	spin_unlock(&sas_dev->lock);
496 
497 	dlvry_queue = dq->id;
498 	dlvry_queue_slot = wr_q_index;
499 
500 	slot->device_id = sas_dev->device_id;
501 	slot->n_elem = n_elem;
502 	slot->n_elem_dif = n_elem_dif;
503 	slot->dlvry_queue = dlvry_queue;
504 	slot->dlvry_queue_slot = dlvry_queue_slot;
505 	cmd_hdr_base = hisi_hba->cmd_hdr[dlvry_queue];
506 	slot->cmd_hdr = &cmd_hdr_base[dlvry_queue_slot];
507 	slot->task = task;
508 	slot->port = port;
509 	slot->tmf = tmf;
510 	slot->is_internal = is_tmf;
511 	task->lldd_task = slot;
512 
513 	memset(slot->cmd_hdr, 0, sizeof(struct hisi_sas_cmd_hdr));
514 	memset(hisi_sas_cmd_hdr_addr_mem(slot), 0, HISI_SAS_COMMAND_TABLE_SZ);
515 	memset(hisi_sas_status_buf_addr_mem(slot), 0,
516 	       sizeof(struct hisi_sas_err_record));
517 
518 	switch (task->task_proto) {
519 	case SAS_PROTOCOL_SMP:
520 		hisi_sas_task_prep_smp(hisi_hba, slot);
521 		break;
522 	case SAS_PROTOCOL_SSP:
523 		hisi_sas_task_prep_ssp(hisi_hba, slot);
524 		break;
525 	case SAS_PROTOCOL_SATA:
526 	case SAS_PROTOCOL_STP:
527 	case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
528 		hisi_sas_task_prep_ata(hisi_hba, slot);
529 		break;
530 	default:
531 		dev_err(dev, "task prep: unknown/unsupported proto (0x%x)\n",
532 			task->task_proto);
533 		break;
534 	}
535 
536 	spin_lock_irqsave(&task->task_state_lock, flags);
537 	task->task_state_flags |= SAS_TASK_AT_INITIATOR;
538 	spin_unlock_irqrestore(&task->task_state_lock, flags);
539 
540 	++(*pass);
541 	WRITE_ONCE(slot->ready, 1);
542 
543 	return 0;
544 
545 err_out_dif_dma_unmap:
546 	if (!sas_protocol_ata(task->task_proto))
547 		hisi_sas_dif_dma_unmap(hisi_hba, task, n_elem_dif);
548 err_out_dma_unmap:
549 	hisi_sas_dma_unmap(hisi_hba, task, n_elem,
550 			   n_elem_req);
551 prep_out:
552 	dev_err(dev, "task prep: failed[%d]!\n", rc);
553 	return rc;
554 }
555 
556 static int hisi_sas_task_exec(struct sas_task *task, gfp_t gfp_flags,
557 			      bool is_tmf, struct hisi_sas_tmf_task *tmf)
558 {
559 	u32 rc;
560 	u32 pass = 0;
561 	struct hisi_hba *hisi_hba;
562 	struct device *dev;
563 	struct domain_device *device = task->dev;
564 	struct asd_sas_port *sas_port = device->port;
565 	struct hisi_sas_dq *dq = NULL;
566 
567 	if (!sas_port) {
568 		struct task_status_struct *ts = &task->task_status;
569 
570 		ts->resp = SAS_TASK_UNDELIVERED;
571 		ts->stat = SAS_PHY_DOWN;
572 		/*
573 		 * libsas will use dev->port, should
574 		 * not call task_done for sata
575 		 */
576 		if (device->dev_type != SAS_SATA_DEV)
577 			task->task_done(task);
578 		return -ECOMM;
579 	}
580 
581 	hisi_hba = dev_to_hisi_hba(device);
582 	dev = hisi_hba->dev;
583 
584 	if (unlikely(test_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags))) {
585 		/*
586 		 * For IOs from upper layer, it may already disable preempt
587 		 * in the IO path, if disable preempt again in down(),
588 		 * function schedule() will report schedule_bug(), so check
589 		 * preemptible() before goto down().
590 		 */
591 		if (!preemptible())
592 			return -EINVAL;
593 
594 		down(&hisi_hba->sem);
595 		up(&hisi_hba->sem);
596 	}
597 
598 	/* protect task_prep and start_delivery sequence */
599 	rc = hisi_sas_task_prep(task, &dq, is_tmf, tmf, &pass);
600 	if (rc)
601 		dev_err(dev, "task exec: failed[%d]!\n", rc);
602 
603 	if (likely(pass)) {
604 		spin_lock(&dq->lock);
605 		hisi_hba->hw->start_delivery(dq);
606 		spin_unlock(&dq->lock);
607 	}
608 
609 	return rc;
610 }
611 
612 static void hisi_sas_bytes_dmaed(struct hisi_hba *hisi_hba, int phy_no)
613 {
614 	struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
615 	struct asd_sas_phy *sas_phy = &phy->sas_phy;
616 	struct sas_ha_struct *sas_ha;
617 
618 	if (!phy->phy_attached)
619 		return;
620 
621 	sas_ha = &hisi_hba->sha;
622 	sas_ha->notify_phy_event(sas_phy, PHYE_OOB_DONE);
623 
624 	if (sas_phy->phy) {
625 		struct sas_phy *sphy = sas_phy->phy;
626 
627 		sphy->negotiated_linkrate = sas_phy->linkrate;
628 		sphy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
629 		sphy->maximum_linkrate_hw =
630 			hisi_hba->hw->phy_get_max_linkrate();
631 		if (sphy->minimum_linkrate == SAS_LINK_RATE_UNKNOWN)
632 			sphy->minimum_linkrate = phy->minimum_linkrate;
633 
634 		if (sphy->maximum_linkrate == SAS_LINK_RATE_UNKNOWN)
635 			sphy->maximum_linkrate = phy->maximum_linkrate;
636 	}
637 
638 	if (phy->phy_type & PORT_TYPE_SAS) {
639 		struct sas_identify_frame *id;
640 
641 		id = (struct sas_identify_frame *)phy->frame_rcvd;
642 		id->dev_type = phy->identify.device_type;
643 		id->initiator_bits = SAS_PROTOCOL_ALL;
644 		id->target_bits = phy->identify.target_port_protocols;
645 	} else if (phy->phy_type & PORT_TYPE_SATA) {
646 		/* Nothing */
647 	}
648 
649 	sas_phy->frame_rcvd_size = phy->frame_rcvd_size;
650 	sas_ha->notify_port_event(sas_phy, PORTE_BYTES_DMAED);
651 }
652 
653 static struct hisi_sas_device *hisi_sas_alloc_dev(struct domain_device *device)
654 {
655 	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
656 	struct hisi_sas_device *sas_dev = NULL;
657 	int last = hisi_hba->last_dev_id;
658 	int first = (hisi_hba->last_dev_id + 1) % HISI_SAS_MAX_DEVICES;
659 	int i;
660 
661 	spin_lock(&hisi_hba->lock);
662 	for (i = first; i != last; i %= HISI_SAS_MAX_DEVICES) {
663 		if (hisi_hba->devices[i].dev_type == SAS_PHY_UNUSED) {
664 			int queue = i % hisi_hba->queue_count;
665 			struct hisi_sas_dq *dq = &hisi_hba->dq[queue];
666 
667 			hisi_hba->devices[i].device_id = i;
668 			sas_dev = &hisi_hba->devices[i];
669 			sas_dev->dev_status = HISI_SAS_DEV_INIT;
670 			sas_dev->dev_type = device->dev_type;
671 			sas_dev->hisi_hba = hisi_hba;
672 			sas_dev->sas_device = device;
673 			sas_dev->dq = dq;
674 			spin_lock_init(&sas_dev->lock);
675 			INIT_LIST_HEAD(&hisi_hba->devices[i].list);
676 			break;
677 		}
678 		i++;
679 	}
680 	hisi_hba->last_dev_id = i;
681 	spin_unlock(&hisi_hba->lock);
682 
683 	return sas_dev;
684 }
685 
686 #define HISI_SAS_DISK_RECOVER_CNT 3
687 static int hisi_sas_init_device(struct domain_device *device)
688 {
689 	int rc = TMF_RESP_FUNC_COMPLETE;
690 	struct scsi_lun lun;
691 	struct hisi_sas_tmf_task tmf_task;
692 	int retry = HISI_SAS_DISK_RECOVER_CNT;
693 	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
694 	struct device *dev = hisi_hba->dev;
695 	struct sas_phy *local_phy;
696 
697 	switch (device->dev_type) {
698 	case SAS_END_DEVICE:
699 		int_to_scsilun(0, &lun);
700 
701 		tmf_task.tmf = TMF_CLEAR_TASK_SET;
702 		while (retry-- > 0) {
703 			rc = hisi_sas_debug_issue_ssp_tmf(device, lun.scsi_lun,
704 							  &tmf_task);
705 			if (rc == TMF_RESP_FUNC_COMPLETE) {
706 				hisi_sas_release_task(hisi_hba, device);
707 				break;
708 			}
709 		}
710 		break;
711 	case SAS_SATA_DEV:
712 	case SAS_SATA_PM:
713 	case SAS_SATA_PM_PORT:
714 	case SAS_SATA_PENDING:
715 		/*
716 		 * send HARD RESET to clear previous affiliation of
717 		 * STP target port
718 		 */
719 		local_phy = sas_get_local_phy(device);
720 		if (!scsi_is_sas_phy_local(local_phy) &&
721 		    !test_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags)) {
722 			unsigned long deadline = ata_deadline(jiffies, 20000);
723 			struct sata_device *sata_dev = &device->sata_dev;
724 			struct ata_host *ata_host = sata_dev->ata_host;
725 			struct ata_port_operations *ops = ata_host->ops;
726 			struct ata_port *ap = sata_dev->ap;
727 			struct ata_link *link;
728 			unsigned int classes;
729 
730 			ata_for_each_link(link, ap, EDGE)
731 				rc = ops->hardreset(link, &classes,
732 						    deadline);
733 		}
734 		sas_put_local_phy(local_phy);
735 		if (rc) {
736 			dev_warn(dev, "SATA disk hardreset fail: %d\n", rc);
737 			return rc;
738 		}
739 
740 		while (retry-- > 0) {
741 			rc = hisi_sas_softreset_ata_disk(device);
742 			if (!rc)
743 				break;
744 		}
745 		break;
746 	default:
747 		break;
748 	}
749 
750 	return rc;
751 }
752 
753 static int hisi_sas_dev_found(struct domain_device *device)
754 {
755 	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
756 	struct domain_device *parent_dev = device->parent;
757 	struct hisi_sas_device *sas_dev;
758 	struct device *dev = hisi_hba->dev;
759 	int rc;
760 
761 	if (hisi_hba->hw->alloc_dev)
762 		sas_dev = hisi_hba->hw->alloc_dev(device);
763 	else
764 		sas_dev = hisi_sas_alloc_dev(device);
765 	if (!sas_dev) {
766 		dev_err(dev, "fail alloc dev: max support %d devices\n",
767 			HISI_SAS_MAX_DEVICES);
768 		return -EINVAL;
769 	}
770 
771 	device->lldd_dev = sas_dev;
772 	hisi_hba->hw->setup_itct(hisi_hba, sas_dev);
773 
774 	if (parent_dev && dev_is_expander(parent_dev->dev_type)) {
775 		int phy_no;
776 		u8 phy_num = parent_dev->ex_dev.num_phys;
777 		struct ex_phy *phy;
778 
779 		for (phy_no = 0; phy_no < phy_num; phy_no++) {
780 			phy = &parent_dev->ex_dev.ex_phy[phy_no];
781 			if (SAS_ADDR(phy->attached_sas_addr) ==
782 				SAS_ADDR(device->sas_addr))
783 				break;
784 		}
785 
786 		if (phy_no == phy_num) {
787 			dev_info(dev, "dev found: no attached "
788 				 "dev:%016llx at ex:%016llx\n",
789 				 SAS_ADDR(device->sas_addr),
790 				 SAS_ADDR(parent_dev->sas_addr));
791 			rc = -EINVAL;
792 			goto err_out;
793 		}
794 	}
795 
796 	dev_info(dev, "dev[%d:%x] found\n",
797 		sas_dev->device_id, sas_dev->dev_type);
798 
799 	rc = hisi_sas_init_device(device);
800 	if (rc)
801 		goto err_out;
802 	sas_dev->dev_status = HISI_SAS_DEV_NORMAL;
803 	return 0;
804 
805 err_out:
806 	hisi_sas_dev_gone(device);
807 	return rc;
808 }
809 
810 int hisi_sas_slave_configure(struct scsi_device *sdev)
811 {
812 	struct domain_device *dev = sdev_to_domain_dev(sdev);
813 	int ret = sas_slave_configure(sdev);
814 
815 	if (ret)
816 		return ret;
817 	if (!dev_is_sata(dev))
818 		sas_change_queue_depth(sdev, 64);
819 
820 	return 0;
821 }
822 EXPORT_SYMBOL_GPL(hisi_sas_slave_configure);
823 
824 void hisi_sas_scan_start(struct Scsi_Host *shost)
825 {
826 	struct hisi_hba *hisi_hba = shost_priv(shost);
827 
828 	hisi_hba->hw->phys_init(hisi_hba);
829 }
830 EXPORT_SYMBOL_GPL(hisi_sas_scan_start);
831 
832 int hisi_sas_scan_finished(struct Scsi_Host *shost, unsigned long time)
833 {
834 	struct hisi_hba *hisi_hba = shost_priv(shost);
835 	struct sas_ha_struct *sha = &hisi_hba->sha;
836 
837 	/* Wait for PHY up interrupt to occur */
838 	if (time < HZ)
839 		return 0;
840 
841 	sas_drain_work(sha);
842 	return 1;
843 }
844 EXPORT_SYMBOL_GPL(hisi_sas_scan_finished);
845 
846 static void hisi_sas_phyup_work(struct work_struct *work)
847 {
848 	struct hisi_sas_phy *phy =
849 		container_of(work, typeof(*phy), works[HISI_PHYE_PHY_UP]);
850 	struct hisi_hba *hisi_hba = phy->hisi_hba;
851 	struct asd_sas_phy *sas_phy = &phy->sas_phy;
852 	int phy_no = sas_phy->id;
853 
854 	if (phy->identify.target_port_protocols == SAS_PROTOCOL_SSP)
855 		hisi_hba->hw->sl_notify_ssp(hisi_hba, phy_no);
856 	hisi_sas_bytes_dmaed(hisi_hba, phy_no);
857 }
858 
859 static void hisi_sas_linkreset_work(struct work_struct *work)
860 {
861 	struct hisi_sas_phy *phy =
862 		container_of(work, typeof(*phy), works[HISI_PHYE_LINK_RESET]);
863 	struct asd_sas_phy *sas_phy = &phy->sas_phy;
864 
865 	hisi_sas_control_phy(sas_phy, PHY_FUNC_LINK_RESET, NULL);
866 }
867 
868 static const work_func_t hisi_sas_phye_fns[HISI_PHYES_NUM] = {
869 	[HISI_PHYE_PHY_UP] = hisi_sas_phyup_work,
870 	[HISI_PHYE_LINK_RESET] = hisi_sas_linkreset_work,
871 };
872 
873 bool hisi_sas_notify_phy_event(struct hisi_sas_phy *phy,
874 				enum hisi_sas_phy_event event)
875 {
876 	struct hisi_hba *hisi_hba = phy->hisi_hba;
877 
878 	if (WARN_ON(event >= HISI_PHYES_NUM))
879 		return false;
880 
881 	return queue_work(hisi_hba->wq, &phy->works[event]);
882 }
883 EXPORT_SYMBOL_GPL(hisi_sas_notify_phy_event);
884 
885 static void hisi_sas_wait_phyup_timedout(struct timer_list *t)
886 {
887 	struct hisi_sas_phy *phy = from_timer(phy, t, timer);
888 	struct hisi_hba *hisi_hba = phy->hisi_hba;
889 	struct device *dev = hisi_hba->dev;
890 	int phy_no = phy->sas_phy.id;
891 
892 	dev_warn(dev, "phy%d wait phyup timeout, issuing link reset\n", phy_no);
893 	hisi_sas_notify_phy_event(phy, HISI_PHYE_LINK_RESET);
894 }
895 
896 void hisi_sas_phy_oob_ready(struct hisi_hba *hisi_hba, int phy_no)
897 {
898 	struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
899 	struct device *dev = hisi_hba->dev;
900 
901 	dev_dbg(dev, "phy%d OOB ready\n", phy_no);
902 	if (phy->phy_attached)
903 		return;
904 
905 	if (!timer_pending(&phy->timer)) {
906 		phy->timer.expires = jiffies + HISI_SAS_WAIT_PHYUP_TIMEOUT * HZ;
907 		add_timer(&phy->timer);
908 	}
909 }
910 EXPORT_SYMBOL_GPL(hisi_sas_phy_oob_ready);
911 
912 static void hisi_sas_phy_init(struct hisi_hba *hisi_hba, int phy_no)
913 {
914 	struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
915 	struct asd_sas_phy *sas_phy = &phy->sas_phy;
916 	int i;
917 
918 	phy->hisi_hba = hisi_hba;
919 	phy->port = NULL;
920 	phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
921 	phy->maximum_linkrate = hisi_hba->hw->phy_get_max_linkrate();
922 	sas_phy->enabled = (phy_no < hisi_hba->n_phy) ? 1 : 0;
923 	sas_phy->class = SAS;
924 	sas_phy->iproto = SAS_PROTOCOL_ALL;
925 	sas_phy->tproto = 0;
926 	sas_phy->type = PHY_TYPE_PHYSICAL;
927 	sas_phy->role = PHY_ROLE_INITIATOR;
928 	sas_phy->oob_mode = OOB_NOT_CONNECTED;
929 	sas_phy->linkrate = SAS_LINK_RATE_UNKNOWN;
930 	sas_phy->id = phy_no;
931 	sas_phy->sas_addr = &hisi_hba->sas_addr[0];
932 	sas_phy->frame_rcvd = &phy->frame_rcvd[0];
933 	sas_phy->ha = (struct sas_ha_struct *)hisi_hba->shost->hostdata;
934 	sas_phy->lldd_phy = phy;
935 
936 	for (i = 0; i < HISI_PHYES_NUM; i++)
937 		INIT_WORK(&phy->works[i], hisi_sas_phye_fns[i]);
938 
939 	spin_lock_init(&phy->lock);
940 
941 	timer_setup(&phy->timer, hisi_sas_wait_phyup_timedout, 0);
942 }
943 
944 /* Wrapper to ensure we track hisi_sas_phy.enable properly */
945 void hisi_sas_phy_enable(struct hisi_hba *hisi_hba, int phy_no, int enable)
946 {
947 	struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
948 	struct asd_sas_phy *aphy = &phy->sas_phy;
949 	struct sas_phy *sphy = aphy->phy;
950 	unsigned long flags;
951 
952 	spin_lock_irqsave(&phy->lock, flags);
953 
954 	if (enable) {
955 		/* We may have been enabled already; if so, don't touch */
956 		if (!phy->enable)
957 			sphy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
958 		hisi_hba->hw->phy_start(hisi_hba, phy_no);
959 	} else {
960 		sphy->negotiated_linkrate = SAS_PHY_DISABLED;
961 		hisi_hba->hw->phy_disable(hisi_hba, phy_no);
962 	}
963 	phy->enable = enable;
964 	spin_unlock_irqrestore(&phy->lock, flags);
965 }
966 EXPORT_SYMBOL_GPL(hisi_sas_phy_enable);
967 
968 static void hisi_sas_port_notify_formed(struct asd_sas_phy *sas_phy)
969 {
970 	struct sas_ha_struct *sas_ha = sas_phy->ha;
971 	struct hisi_hba *hisi_hba = sas_ha->lldd_ha;
972 	struct hisi_sas_phy *phy = sas_phy->lldd_phy;
973 	struct asd_sas_port *sas_port = sas_phy->port;
974 	struct hisi_sas_port *port;
975 	unsigned long flags;
976 
977 	if (!sas_port)
978 		return;
979 
980 	port = to_hisi_sas_port(sas_port);
981 	spin_lock_irqsave(&hisi_hba->lock, flags);
982 	port->port_attached = 1;
983 	port->id = phy->port_id;
984 	phy->port = port;
985 	sas_port->lldd_port = port;
986 	spin_unlock_irqrestore(&hisi_hba->lock, flags);
987 }
988 
989 static void hisi_sas_do_release_task(struct hisi_hba *hisi_hba, struct sas_task *task,
990 				     struct hisi_sas_slot *slot)
991 {
992 	if (task) {
993 		unsigned long flags;
994 		struct task_status_struct *ts;
995 
996 		ts = &task->task_status;
997 
998 		ts->resp = SAS_TASK_COMPLETE;
999 		ts->stat = SAS_ABORTED_TASK;
1000 		spin_lock_irqsave(&task->task_state_lock, flags);
1001 		task->task_state_flags &=
1002 			~(SAS_TASK_STATE_PENDING | SAS_TASK_AT_INITIATOR);
1003 		if (!slot->is_internal && task->task_proto != SAS_PROTOCOL_SMP)
1004 			task->task_state_flags |= SAS_TASK_STATE_DONE;
1005 		spin_unlock_irqrestore(&task->task_state_lock, flags);
1006 	}
1007 
1008 	hisi_sas_slot_task_free(hisi_hba, task, slot);
1009 }
1010 
1011 static void hisi_sas_release_task(struct hisi_hba *hisi_hba,
1012 			struct domain_device *device)
1013 {
1014 	struct hisi_sas_slot *slot, *slot2;
1015 	struct hisi_sas_device *sas_dev = device->lldd_dev;
1016 
1017 	list_for_each_entry_safe(slot, slot2, &sas_dev->list, entry)
1018 		hisi_sas_do_release_task(hisi_hba, slot->task, slot);
1019 }
1020 
1021 void hisi_sas_release_tasks(struct hisi_hba *hisi_hba)
1022 {
1023 	struct hisi_sas_device *sas_dev;
1024 	struct domain_device *device;
1025 	int i;
1026 
1027 	for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
1028 		sas_dev = &hisi_hba->devices[i];
1029 		device = sas_dev->sas_device;
1030 
1031 		if ((sas_dev->dev_type == SAS_PHY_UNUSED) ||
1032 		    !device)
1033 			continue;
1034 
1035 		hisi_sas_release_task(hisi_hba, device);
1036 	}
1037 }
1038 EXPORT_SYMBOL_GPL(hisi_sas_release_tasks);
1039 
1040 static void hisi_sas_dereg_device(struct hisi_hba *hisi_hba,
1041 				struct domain_device *device)
1042 {
1043 	if (hisi_hba->hw->dereg_device)
1044 		hisi_hba->hw->dereg_device(hisi_hba, device);
1045 }
1046 
1047 static void hisi_sas_dev_gone(struct domain_device *device)
1048 {
1049 	struct hisi_sas_device *sas_dev = device->lldd_dev;
1050 	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
1051 	struct device *dev = hisi_hba->dev;
1052 	int ret = 0;
1053 
1054 	dev_info(dev, "dev[%d:%x] is gone\n",
1055 		 sas_dev->device_id, sas_dev->dev_type);
1056 
1057 	down(&hisi_hba->sem);
1058 	if (!test_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags)) {
1059 		hisi_sas_internal_task_abort(hisi_hba, device,
1060 					     HISI_SAS_INT_ABT_DEV, 0);
1061 
1062 		hisi_sas_dereg_device(hisi_hba, device);
1063 
1064 		ret = hisi_hba->hw->clear_itct(hisi_hba, sas_dev);
1065 		device->lldd_dev = NULL;
1066 	}
1067 
1068 	if (hisi_hba->hw->free_device)
1069 		hisi_hba->hw->free_device(sas_dev);
1070 
1071 	/* Don't mark it as SAS_PHY_UNUSED if failed to clear ITCT */
1072 	if (!ret)
1073 		sas_dev->dev_type = SAS_PHY_UNUSED;
1074 	sas_dev->sas_device = NULL;
1075 	up(&hisi_hba->sem);
1076 }
1077 
1078 static int hisi_sas_queue_command(struct sas_task *task, gfp_t gfp_flags)
1079 {
1080 	return hisi_sas_task_exec(task, gfp_flags, 0, NULL);
1081 }
1082 
1083 static int hisi_sas_phy_set_linkrate(struct hisi_hba *hisi_hba, int phy_no,
1084 			struct sas_phy_linkrates *r)
1085 {
1086 	struct sas_phy_linkrates _r;
1087 
1088 	struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
1089 	struct asd_sas_phy *sas_phy = &phy->sas_phy;
1090 	enum sas_linkrate min, max;
1091 
1092 	if (r->minimum_linkrate > SAS_LINK_RATE_1_5_GBPS)
1093 		return -EINVAL;
1094 
1095 	if (r->maximum_linkrate == SAS_LINK_RATE_UNKNOWN) {
1096 		max = sas_phy->phy->maximum_linkrate;
1097 		min = r->minimum_linkrate;
1098 	} else if (r->minimum_linkrate == SAS_LINK_RATE_UNKNOWN) {
1099 		max = r->maximum_linkrate;
1100 		min = sas_phy->phy->minimum_linkrate;
1101 	} else
1102 		return -EINVAL;
1103 
1104 	_r.maximum_linkrate = max;
1105 	_r.minimum_linkrate = min;
1106 
1107 	sas_phy->phy->maximum_linkrate = max;
1108 	sas_phy->phy->minimum_linkrate = min;
1109 
1110 	hisi_sas_phy_enable(hisi_hba, phy_no, 0);
1111 	msleep(100);
1112 	hisi_hba->hw->phy_set_linkrate(hisi_hba, phy_no, &_r);
1113 	hisi_sas_phy_enable(hisi_hba, phy_no, 1);
1114 
1115 	return 0;
1116 }
1117 
1118 static int hisi_sas_control_phy(struct asd_sas_phy *sas_phy, enum phy_func func,
1119 				void *funcdata)
1120 {
1121 	struct sas_ha_struct *sas_ha = sas_phy->ha;
1122 	struct hisi_hba *hisi_hba = sas_ha->lldd_ha;
1123 	int phy_no = sas_phy->id;
1124 
1125 	switch (func) {
1126 	case PHY_FUNC_HARD_RESET:
1127 		hisi_hba->hw->phy_hard_reset(hisi_hba, phy_no);
1128 		break;
1129 
1130 	case PHY_FUNC_LINK_RESET:
1131 		hisi_sas_phy_enable(hisi_hba, phy_no, 0);
1132 		msleep(100);
1133 		hisi_sas_phy_enable(hisi_hba, phy_no, 1);
1134 		break;
1135 
1136 	case PHY_FUNC_DISABLE:
1137 		hisi_sas_phy_enable(hisi_hba, phy_no, 0);
1138 		break;
1139 
1140 	case PHY_FUNC_SET_LINK_RATE:
1141 		return hisi_sas_phy_set_linkrate(hisi_hba, phy_no, funcdata);
1142 	case PHY_FUNC_GET_EVENTS:
1143 		if (hisi_hba->hw->get_events) {
1144 			hisi_hba->hw->get_events(hisi_hba, phy_no);
1145 			break;
1146 		}
1147 		fallthrough;
1148 	case PHY_FUNC_RELEASE_SPINUP_HOLD:
1149 	default:
1150 		return -EOPNOTSUPP;
1151 	}
1152 	return 0;
1153 }
1154 
1155 static void hisi_sas_task_done(struct sas_task *task)
1156 {
1157 	del_timer(&task->slow_task->timer);
1158 	complete(&task->slow_task->completion);
1159 }
1160 
1161 static void hisi_sas_tmf_timedout(struct timer_list *t)
1162 {
1163 	struct sas_task_slow *slow = from_timer(slow, t, timer);
1164 	struct sas_task *task = slow->task;
1165 	unsigned long flags;
1166 	bool is_completed = true;
1167 
1168 	spin_lock_irqsave(&task->task_state_lock, flags);
1169 	if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
1170 		task->task_state_flags |= SAS_TASK_STATE_ABORTED;
1171 		is_completed = false;
1172 	}
1173 	spin_unlock_irqrestore(&task->task_state_lock, flags);
1174 
1175 	if (!is_completed)
1176 		complete(&task->slow_task->completion);
1177 }
1178 
1179 #define TASK_TIMEOUT 20
1180 #define TASK_RETRY 3
1181 #define INTERNAL_ABORT_TIMEOUT 6
1182 static int hisi_sas_exec_internal_tmf_task(struct domain_device *device,
1183 					   void *parameter, u32 para_len,
1184 					   struct hisi_sas_tmf_task *tmf)
1185 {
1186 	struct hisi_sas_device *sas_dev = device->lldd_dev;
1187 	struct hisi_hba *hisi_hba = sas_dev->hisi_hba;
1188 	struct device *dev = hisi_hba->dev;
1189 	struct sas_task *task;
1190 	int res, retry;
1191 
1192 	for (retry = 0; retry < TASK_RETRY; retry++) {
1193 		task = sas_alloc_slow_task(GFP_KERNEL);
1194 		if (!task)
1195 			return -ENOMEM;
1196 
1197 		task->dev = device;
1198 		task->task_proto = device->tproto;
1199 
1200 		if (dev_is_sata(device)) {
1201 			task->ata_task.device_control_reg_update = 1;
1202 			memcpy(&task->ata_task.fis, parameter, para_len);
1203 		} else {
1204 			memcpy(&task->ssp_task, parameter, para_len);
1205 		}
1206 		task->task_done = hisi_sas_task_done;
1207 
1208 		task->slow_task->timer.function = hisi_sas_tmf_timedout;
1209 		task->slow_task->timer.expires = jiffies + TASK_TIMEOUT * HZ;
1210 		add_timer(&task->slow_task->timer);
1211 
1212 		res = hisi_sas_task_exec(task, GFP_KERNEL, 1, tmf);
1213 
1214 		if (res) {
1215 			del_timer(&task->slow_task->timer);
1216 			dev_err(dev, "abort tmf: executing internal task failed: %d\n",
1217 				res);
1218 			goto ex_err;
1219 		}
1220 
1221 		wait_for_completion(&task->slow_task->completion);
1222 		res = TMF_RESP_FUNC_FAILED;
1223 		/* Even TMF timed out, return direct. */
1224 		if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
1225 			if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
1226 				struct hisi_sas_slot *slot = task->lldd_task;
1227 
1228 				dev_err(dev, "abort tmf: TMF task timeout and not done\n");
1229 				if (slot) {
1230 					struct hisi_sas_cq *cq =
1231 					       &hisi_hba->cq[slot->dlvry_queue];
1232 					/*
1233 					 * sync irq to avoid free'ing task
1234 					 * before using task in IO completion
1235 					 */
1236 					synchronize_irq(cq->irq_no);
1237 					slot->task = NULL;
1238 				}
1239 
1240 				goto ex_err;
1241 			} else
1242 				dev_err(dev, "abort tmf: TMF task timeout\n");
1243 		}
1244 
1245 		if (task->task_status.resp == SAS_TASK_COMPLETE &&
1246 		     task->task_status.stat == TMF_RESP_FUNC_COMPLETE) {
1247 			res = TMF_RESP_FUNC_COMPLETE;
1248 			break;
1249 		}
1250 
1251 		if (task->task_status.resp == SAS_TASK_COMPLETE &&
1252 			task->task_status.stat == TMF_RESP_FUNC_SUCC) {
1253 			res = TMF_RESP_FUNC_SUCC;
1254 			break;
1255 		}
1256 
1257 		if (task->task_status.resp == SAS_TASK_COMPLETE &&
1258 		      task->task_status.stat == SAS_DATA_UNDERRUN) {
1259 			/* no error, but return the number of bytes of
1260 			 * underrun
1261 			 */
1262 			dev_warn(dev, "abort tmf: task to dev %016llx resp: 0x%x sts 0x%x underrun\n",
1263 				 SAS_ADDR(device->sas_addr),
1264 				 task->task_status.resp,
1265 				 task->task_status.stat);
1266 			res = task->task_status.residual;
1267 			break;
1268 		}
1269 
1270 		if (task->task_status.resp == SAS_TASK_COMPLETE &&
1271 			task->task_status.stat == SAS_DATA_OVERRUN) {
1272 			dev_warn(dev, "abort tmf: blocked task error\n");
1273 			res = -EMSGSIZE;
1274 			break;
1275 		}
1276 
1277 		if (task->task_status.resp == SAS_TASK_COMPLETE &&
1278 		    task->task_status.stat == SAS_OPEN_REJECT) {
1279 			dev_warn(dev, "abort tmf: open reject failed\n");
1280 			res = -EIO;
1281 		} else {
1282 			dev_warn(dev, "abort tmf: task to dev %016llx resp: 0x%x status 0x%x\n",
1283 				 SAS_ADDR(device->sas_addr),
1284 				 task->task_status.resp,
1285 				 task->task_status.stat);
1286 		}
1287 		sas_free_task(task);
1288 		task = NULL;
1289 	}
1290 ex_err:
1291 	if (retry == TASK_RETRY)
1292 		dev_warn(dev, "abort tmf: executing internal task failed!\n");
1293 	sas_free_task(task);
1294 	return res;
1295 }
1296 
1297 static void hisi_sas_fill_ata_reset_cmd(struct ata_device *dev,
1298 		bool reset, int pmp, u8 *fis)
1299 {
1300 	struct ata_taskfile tf;
1301 
1302 	ata_tf_init(dev, &tf);
1303 	if (reset)
1304 		tf.ctl |= ATA_SRST;
1305 	else
1306 		tf.ctl &= ~ATA_SRST;
1307 	tf.command = ATA_CMD_DEV_RESET;
1308 	ata_tf_to_fis(&tf, pmp, 0, fis);
1309 }
1310 
1311 static int hisi_sas_softreset_ata_disk(struct domain_device *device)
1312 {
1313 	u8 fis[20] = {0};
1314 	struct ata_port *ap = device->sata_dev.ap;
1315 	struct ata_link *link;
1316 	int rc = TMF_RESP_FUNC_FAILED;
1317 	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
1318 	struct device *dev = hisi_hba->dev;
1319 	int s = sizeof(struct host_to_dev_fis);
1320 
1321 	ata_for_each_link(link, ap, EDGE) {
1322 		int pmp = sata_srst_pmp(link);
1323 
1324 		hisi_sas_fill_ata_reset_cmd(link->device, 1, pmp, fis);
1325 		rc = hisi_sas_exec_internal_tmf_task(device, fis, s, NULL);
1326 		if (rc != TMF_RESP_FUNC_COMPLETE)
1327 			break;
1328 	}
1329 
1330 	if (rc == TMF_RESP_FUNC_COMPLETE) {
1331 		ata_for_each_link(link, ap, EDGE) {
1332 			int pmp = sata_srst_pmp(link);
1333 
1334 			hisi_sas_fill_ata_reset_cmd(link->device, 0, pmp, fis);
1335 			rc = hisi_sas_exec_internal_tmf_task(device, fis,
1336 							     s, NULL);
1337 			if (rc != TMF_RESP_FUNC_COMPLETE)
1338 				dev_err(dev, "ata disk de-reset failed\n");
1339 		}
1340 	} else {
1341 		dev_err(dev, "ata disk reset failed\n");
1342 	}
1343 
1344 	if (rc == TMF_RESP_FUNC_COMPLETE)
1345 		hisi_sas_release_task(hisi_hba, device);
1346 
1347 	return rc;
1348 }
1349 
1350 static int hisi_sas_debug_issue_ssp_tmf(struct domain_device *device,
1351 				u8 *lun, struct hisi_sas_tmf_task *tmf)
1352 {
1353 	struct sas_ssp_task ssp_task;
1354 
1355 	if (!(device->tproto & SAS_PROTOCOL_SSP))
1356 		return TMF_RESP_FUNC_ESUPP;
1357 
1358 	memcpy(ssp_task.LUN, lun, 8);
1359 
1360 	return hisi_sas_exec_internal_tmf_task(device, &ssp_task,
1361 				sizeof(ssp_task), tmf);
1362 }
1363 
1364 static void hisi_sas_refresh_port_id(struct hisi_hba *hisi_hba)
1365 {
1366 	u32 state = hisi_hba->hw->get_phys_state(hisi_hba);
1367 	int i;
1368 
1369 	for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
1370 		struct hisi_sas_device *sas_dev = &hisi_hba->devices[i];
1371 		struct domain_device *device = sas_dev->sas_device;
1372 		struct asd_sas_port *sas_port;
1373 		struct hisi_sas_port *port;
1374 		struct hisi_sas_phy *phy = NULL;
1375 		struct asd_sas_phy *sas_phy;
1376 
1377 		if ((sas_dev->dev_type == SAS_PHY_UNUSED)
1378 				|| !device || !device->port)
1379 			continue;
1380 
1381 		sas_port = device->port;
1382 		port = to_hisi_sas_port(sas_port);
1383 
1384 		list_for_each_entry(sas_phy, &sas_port->phy_list, port_phy_el)
1385 			if (state & BIT(sas_phy->id)) {
1386 				phy = sas_phy->lldd_phy;
1387 				break;
1388 			}
1389 
1390 		if (phy) {
1391 			port->id = phy->port_id;
1392 
1393 			/* Update linkrate of directly attached device. */
1394 			if (!device->parent)
1395 				device->linkrate = phy->sas_phy.linkrate;
1396 
1397 			hisi_hba->hw->setup_itct(hisi_hba, sas_dev);
1398 		} else
1399 			port->id = 0xff;
1400 	}
1401 }
1402 
1403 static void hisi_sas_rescan_topology(struct hisi_hba *hisi_hba, u32 state)
1404 {
1405 	struct sas_ha_struct *sas_ha = &hisi_hba->sha;
1406 	struct asd_sas_port *_sas_port = NULL;
1407 	int phy_no;
1408 
1409 	for (phy_no = 0; phy_no < hisi_hba->n_phy; phy_no++) {
1410 		struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
1411 		struct asd_sas_phy *sas_phy = &phy->sas_phy;
1412 		struct asd_sas_port *sas_port = sas_phy->port;
1413 		bool do_port_check = _sas_port != sas_port;
1414 
1415 		if (!sas_phy->phy->enabled)
1416 			continue;
1417 
1418 		/* Report PHY state change to libsas */
1419 		if (state & BIT(phy_no)) {
1420 			if (do_port_check && sas_port && sas_port->port_dev) {
1421 				struct domain_device *dev = sas_port->port_dev;
1422 
1423 				_sas_port = sas_port;
1424 
1425 				if (dev_is_expander(dev->dev_type))
1426 					sas_ha->notify_port_event(sas_phy,
1427 							PORTE_BROADCAST_RCVD);
1428 			}
1429 		} else {
1430 			hisi_sas_phy_down(hisi_hba, phy_no, 0);
1431 		}
1432 
1433 	}
1434 }
1435 
1436 static void hisi_sas_reset_init_all_devices(struct hisi_hba *hisi_hba)
1437 {
1438 	struct hisi_sas_device *sas_dev;
1439 	struct domain_device *device;
1440 	int i;
1441 
1442 	for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
1443 		sas_dev = &hisi_hba->devices[i];
1444 		device = sas_dev->sas_device;
1445 
1446 		if ((sas_dev->dev_type == SAS_PHY_UNUSED) || !device)
1447 			continue;
1448 
1449 		hisi_sas_init_device(device);
1450 	}
1451 }
1452 
1453 static void hisi_sas_send_ata_reset_each_phy(struct hisi_hba *hisi_hba,
1454 					     struct asd_sas_port *sas_port,
1455 					     struct domain_device *device)
1456 {
1457 	struct hisi_sas_tmf_task tmf_task = { .force_phy = 1 };
1458 	struct ata_port *ap = device->sata_dev.ap;
1459 	struct device *dev = hisi_hba->dev;
1460 	int s = sizeof(struct host_to_dev_fis);
1461 	int rc = TMF_RESP_FUNC_FAILED;
1462 	struct asd_sas_phy *sas_phy;
1463 	struct ata_link *link;
1464 	u8 fis[20] = {0};
1465 	u32 state;
1466 
1467 	state = hisi_hba->hw->get_phys_state(hisi_hba);
1468 	list_for_each_entry(sas_phy, &sas_port->phy_list, port_phy_el) {
1469 		if (!(state & BIT(sas_phy->id)))
1470 			continue;
1471 
1472 		ata_for_each_link(link, ap, EDGE) {
1473 			int pmp = sata_srst_pmp(link);
1474 
1475 			tmf_task.phy_id = sas_phy->id;
1476 			hisi_sas_fill_ata_reset_cmd(link->device, 1, pmp, fis);
1477 			rc = hisi_sas_exec_internal_tmf_task(device, fis, s,
1478 							     &tmf_task);
1479 			if (rc != TMF_RESP_FUNC_COMPLETE) {
1480 				dev_err(dev, "phy%d ata reset failed rc=%d\n",
1481 					sas_phy->id, rc);
1482 				break;
1483 			}
1484 		}
1485 	}
1486 }
1487 
1488 static void hisi_sas_terminate_stp_reject(struct hisi_hba *hisi_hba)
1489 {
1490 	struct device *dev = hisi_hba->dev;
1491 	int port_no, rc, i;
1492 
1493 	for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
1494 		struct hisi_sas_device *sas_dev = &hisi_hba->devices[i];
1495 		struct domain_device *device = sas_dev->sas_device;
1496 
1497 		if ((sas_dev->dev_type == SAS_PHY_UNUSED) || !device)
1498 			continue;
1499 
1500 		rc = hisi_sas_internal_task_abort(hisi_hba, device,
1501 						  HISI_SAS_INT_ABT_DEV, 0);
1502 		if (rc < 0)
1503 			dev_err(dev, "STP reject: abort dev failed %d\n", rc);
1504 	}
1505 
1506 	for (port_no = 0; port_no < hisi_hba->n_phy; port_no++) {
1507 		struct hisi_sas_port *port = &hisi_hba->port[port_no];
1508 		struct asd_sas_port *sas_port = &port->sas_port;
1509 		struct domain_device *port_dev = sas_port->port_dev;
1510 		struct domain_device *device;
1511 
1512 		if (!port_dev || !dev_is_expander(port_dev->dev_type))
1513 			continue;
1514 
1515 		/* Try to find a SATA device */
1516 		list_for_each_entry(device, &sas_port->dev_list,
1517 				    dev_list_node) {
1518 			if (dev_is_sata(device)) {
1519 				hisi_sas_send_ata_reset_each_phy(hisi_hba,
1520 								 sas_port,
1521 								 device);
1522 				break;
1523 			}
1524 		}
1525 	}
1526 }
1527 
1528 void hisi_sas_controller_reset_prepare(struct hisi_hba *hisi_hba)
1529 {
1530 	struct Scsi_Host *shost = hisi_hba->shost;
1531 
1532 	down(&hisi_hba->sem);
1533 	hisi_hba->phy_state = hisi_hba->hw->get_phys_state(hisi_hba);
1534 
1535 	scsi_block_requests(shost);
1536 	hisi_hba->hw->wait_cmds_complete_timeout(hisi_hba, 100, 5000);
1537 
1538 	if (timer_pending(&hisi_hba->timer))
1539 		del_timer_sync(&hisi_hba->timer);
1540 
1541 	set_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags);
1542 }
1543 EXPORT_SYMBOL_GPL(hisi_sas_controller_reset_prepare);
1544 
1545 void hisi_sas_controller_reset_done(struct hisi_hba *hisi_hba)
1546 {
1547 	struct Scsi_Host *shost = hisi_hba->shost;
1548 	u32 state;
1549 
1550 	/* Init and wait for PHYs to come up and all libsas event finished. */
1551 	hisi_hba->hw->phys_init(hisi_hba);
1552 	msleep(1000);
1553 	hisi_sas_refresh_port_id(hisi_hba);
1554 	clear_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags);
1555 
1556 	if (hisi_hba->reject_stp_links_msk)
1557 		hisi_sas_terminate_stp_reject(hisi_hba);
1558 	hisi_sas_reset_init_all_devices(hisi_hba);
1559 	up(&hisi_hba->sem);
1560 	scsi_unblock_requests(shost);
1561 	clear_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags);
1562 
1563 	state = hisi_hba->hw->get_phys_state(hisi_hba);
1564 	hisi_sas_rescan_topology(hisi_hba, state);
1565 }
1566 EXPORT_SYMBOL_GPL(hisi_sas_controller_reset_done);
1567 
1568 static int hisi_sas_controller_reset(struct hisi_hba *hisi_hba)
1569 {
1570 	struct device *dev = hisi_hba->dev;
1571 	struct Scsi_Host *shost = hisi_hba->shost;
1572 	int rc;
1573 
1574 	if (hisi_sas_debugfs_enable && hisi_hba->debugfs_itct[0].itct)
1575 		queue_work(hisi_hba->wq, &hisi_hba->debugfs_work);
1576 
1577 	if (!hisi_hba->hw->soft_reset)
1578 		return -1;
1579 
1580 	if (test_and_set_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags))
1581 		return -1;
1582 
1583 	dev_info(dev, "controller resetting...\n");
1584 	hisi_sas_controller_reset_prepare(hisi_hba);
1585 
1586 	rc = hisi_hba->hw->soft_reset(hisi_hba);
1587 	if (rc) {
1588 		dev_warn(dev, "controller reset failed (%d)\n", rc);
1589 		clear_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags);
1590 		up(&hisi_hba->sem);
1591 		scsi_unblock_requests(shost);
1592 		clear_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags);
1593 		return rc;
1594 	}
1595 
1596 	hisi_sas_controller_reset_done(hisi_hba);
1597 	dev_info(dev, "controller reset complete\n");
1598 
1599 	return 0;
1600 }
1601 
1602 static int hisi_sas_abort_task(struct sas_task *task)
1603 {
1604 	struct scsi_lun lun;
1605 	struct hisi_sas_tmf_task tmf_task;
1606 	struct domain_device *device = task->dev;
1607 	struct hisi_sas_device *sas_dev = device->lldd_dev;
1608 	struct hisi_hba *hisi_hba;
1609 	struct device *dev;
1610 	int rc = TMF_RESP_FUNC_FAILED;
1611 	unsigned long flags;
1612 
1613 	if (!sas_dev)
1614 		return TMF_RESP_FUNC_FAILED;
1615 
1616 	hisi_hba = dev_to_hisi_hba(task->dev);
1617 	dev = hisi_hba->dev;
1618 
1619 	spin_lock_irqsave(&task->task_state_lock, flags);
1620 	if (task->task_state_flags & SAS_TASK_STATE_DONE) {
1621 		struct hisi_sas_slot *slot = task->lldd_task;
1622 		struct hisi_sas_cq *cq;
1623 
1624 		if (slot) {
1625 			/*
1626 			 * sync irq to avoid free'ing task
1627 			 * before using task in IO completion
1628 			 */
1629 			cq = &hisi_hba->cq[slot->dlvry_queue];
1630 			synchronize_irq(cq->irq_no);
1631 		}
1632 		spin_unlock_irqrestore(&task->task_state_lock, flags);
1633 		rc = TMF_RESP_FUNC_COMPLETE;
1634 		goto out;
1635 	}
1636 	task->task_state_flags |= SAS_TASK_STATE_ABORTED;
1637 	spin_unlock_irqrestore(&task->task_state_lock, flags);
1638 
1639 	if (task->lldd_task && task->task_proto & SAS_PROTOCOL_SSP) {
1640 		struct scsi_cmnd *cmnd = task->uldd_task;
1641 		struct hisi_sas_slot *slot = task->lldd_task;
1642 		u16 tag = slot->idx;
1643 		int rc2;
1644 
1645 		int_to_scsilun(cmnd->device->lun, &lun);
1646 		tmf_task.tmf = TMF_ABORT_TASK;
1647 		tmf_task.tag_of_task_to_be_managed = tag;
1648 
1649 		rc = hisi_sas_debug_issue_ssp_tmf(task->dev, lun.scsi_lun,
1650 						  &tmf_task);
1651 
1652 		rc2 = hisi_sas_internal_task_abort(hisi_hba, device,
1653 						   HISI_SAS_INT_ABT_CMD, tag);
1654 		if (rc2 < 0) {
1655 			dev_err(dev, "abort task: internal abort (%d)\n", rc2);
1656 			return TMF_RESP_FUNC_FAILED;
1657 		}
1658 
1659 		/*
1660 		 * If the TMF finds that the IO is not in the device and also
1661 		 * the internal abort does not succeed, then it is safe to
1662 		 * free the slot.
1663 		 * Note: if the internal abort succeeds then the slot
1664 		 * will have already been completed
1665 		 */
1666 		if (rc == TMF_RESP_FUNC_COMPLETE && rc2 != TMF_RESP_FUNC_SUCC) {
1667 			if (task->lldd_task)
1668 				hisi_sas_do_release_task(hisi_hba, task, slot);
1669 		}
1670 	} else if (task->task_proto & SAS_PROTOCOL_SATA ||
1671 		task->task_proto & SAS_PROTOCOL_STP) {
1672 		if (task->dev->dev_type == SAS_SATA_DEV) {
1673 			rc = hisi_sas_internal_task_abort(hisi_hba, device,
1674 							  HISI_SAS_INT_ABT_DEV,
1675 							  0);
1676 			if (rc < 0) {
1677 				dev_err(dev, "abort task: internal abort failed\n");
1678 				goto out;
1679 			}
1680 			hisi_sas_dereg_device(hisi_hba, device);
1681 			rc = hisi_sas_softreset_ata_disk(device);
1682 		}
1683 	} else if (task->lldd_task && task->task_proto & SAS_PROTOCOL_SMP) {
1684 		/* SMP */
1685 		struct hisi_sas_slot *slot = task->lldd_task;
1686 		u32 tag = slot->idx;
1687 		struct hisi_sas_cq *cq = &hisi_hba->cq[slot->dlvry_queue];
1688 
1689 		rc = hisi_sas_internal_task_abort(hisi_hba, device,
1690 						  HISI_SAS_INT_ABT_CMD, tag);
1691 		if (((rc < 0) || (rc == TMF_RESP_FUNC_FAILED)) &&
1692 					task->lldd_task) {
1693 			/*
1694 			 * sync irq to avoid free'ing task
1695 			 * before using task in IO completion
1696 			 */
1697 			synchronize_irq(cq->irq_no);
1698 			slot->task = NULL;
1699 		}
1700 	}
1701 
1702 out:
1703 	if (rc != TMF_RESP_FUNC_COMPLETE)
1704 		dev_notice(dev, "abort task: rc=%d\n", rc);
1705 	return rc;
1706 }
1707 
1708 static int hisi_sas_abort_task_set(struct domain_device *device, u8 *lun)
1709 {
1710 	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
1711 	struct device *dev = hisi_hba->dev;
1712 	struct hisi_sas_tmf_task tmf_task;
1713 	int rc;
1714 
1715 	rc = hisi_sas_internal_task_abort(hisi_hba, device,
1716 					  HISI_SAS_INT_ABT_DEV, 0);
1717 	if (rc < 0) {
1718 		dev_err(dev, "abort task set: internal abort rc=%d\n", rc);
1719 		return TMF_RESP_FUNC_FAILED;
1720 	}
1721 	hisi_sas_dereg_device(hisi_hba, device);
1722 
1723 	tmf_task.tmf = TMF_ABORT_TASK_SET;
1724 	rc = hisi_sas_debug_issue_ssp_tmf(device, lun, &tmf_task);
1725 
1726 	if (rc == TMF_RESP_FUNC_COMPLETE)
1727 		hisi_sas_release_task(hisi_hba, device);
1728 
1729 	return rc;
1730 }
1731 
1732 static int hisi_sas_clear_aca(struct domain_device *device, u8 *lun)
1733 {
1734 	struct hisi_sas_tmf_task tmf_task;
1735 	int rc;
1736 
1737 	tmf_task.tmf = TMF_CLEAR_ACA;
1738 	rc = hisi_sas_debug_issue_ssp_tmf(device, lun, &tmf_task);
1739 
1740 	return rc;
1741 }
1742 
1743 static int hisi_sas_debug_I_T_nexus_reset(struct domain_device *device)
1744 {
1745 	struct sas_phy *local_phy = sas_get_local_phy(device);
1746 	struct hisi_sas_device *sas_dev = device->lldd_dev;
1747 	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
1748 	struct sas_ha_struct *sas_ha = &hisi_hba->sha;
1749 	DECLARE_COMPLETION_ONSTACK(phyreset);
1750 	int rc, reset_type;
1751 
1752 	if (!local_phy->enabled) {
1753 		sas_put_local_phy(local_phy);
1754 		return -ENODEV;
1755 	}
1756 
1757 	if (scsi_is_sas_phy_local(local_phy)) {
1758 		struct asd_sas_phy *sas_phy =
1759 			sas_ha->sas_phy[local_phy->number];
1760 		struct hisi_sas_phy *phy =
1761 			container_of(sas_phy, struct hisi_sas_phy, sas_phy);
1762 		phy->in_reset = 1;
1763 		phy->reset_completion = &phyreset;
1764 	}
1765 
1766 	reset_type = (sas_dev->dev_status == HISI_SAS_DEV_INIT ||
1767 		      !dev_is_sata(device)) ? true : false;
1768 
1769 	rc = sas_phy_reset(local_phy, reset_type);
1770 	sas_put_local_phy(local_phy);
1771 
1772 	if (scsi_is_sas_phy_local(local_phy)) {
1773 		struct asd_sas_phy *sas_phy =
1774 			sas_ha->sas_phy[local_phy->number];
1775 		struct hisi_sas_phy *phy =
1776 			container_of(sas_phy, struct hisi_sas_phy, sas_phy);
1777 		int ret = wait_for_completion_timeout(&phyreset, 2 * HZ);
1778 		unsigned long flags;
1779 
1780 		spin_lock_irqsave(&phy->lock, flags);
1781 		phy->reset_completion = NULL;
1782 		phy->in_reset = 0;
1783 		spin_unlock_irqrestore(&phy->lock, flags);
1784 
1785 		/* report PHY down if timed out */
1786 		if (!ret)
1787 			hisi_sas_phy_down(hisi_hba, sas_phy->id, 0);
1788 	} else if (sas_dev->dev_status != HISI_SAS_DEV_INIT) {
1789 		/*
1790 		 * If in init state, we rely on caller to wait for link to be
1791 		 * ready; otherwise, except phy reset is fail, delay.
1792 		 */
1793 		if (!rc)
1794 			msleep(2000);
1795 	}
1796 
1797 	return rc;
1798 }
1799 
1800 static int hisi_sas_I_T_nexus_reset(struct domain_device *device)
1801 {
1802 	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
1803 	struct device *dev = hisi_hba->dev;
1804 	int rc;
1805 
1806 	rc = hisi_sas_internal_task_abort(hisi_hba, device,
1807 					  HISI_SAS_INT_ABT_DEV, 0);
1808 	if (rc < 0) {
1809 		dev_err(dev, "I_T nexus reset: internal abort (%d)\n", rc);
1810 		return TMF_RESP_FUNC_FAILED;
1811 	}
1812 	hisi_sas_dereg_device(hisi_hba, device);
1813 
1814 	if (dev_is_sata(device)) {
1815 		rc = hisi_sas_softreset_ata_disk(device);
1816 		if (rc == TMF_RESP_FUNC_FAILED)
1817 			return TMF_RESP_FUNC_FAILED;
1818 	}
1819 
1820 	rc = hisi_sas_debug_I_T_nexus_reset(device);
1821 
1822 	if ((rc == TMF_RESP_FUNC_COMPLETE) || (rc == -ENODEV))
1823 		hisi_sas_release_task(hisi_hba, device);
1824 
1825 	return rc;
1826 }
1827 
1828 static int hisi_sas_lu_reset(struct domain_device *device, u8 *lun)
1829 {
1830 	struct hisi_sas_device *sas_dev = device->lldd_dev;
1831 	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
1832 	struct device *dev = hisi_hba->dev;
1833 	int rc = TMF_RESP_FUNC_FAILED;
1834 
1835 	/* Clear internal IO and then lu reset */
1836 	rc = hisi_sas_internal_task_abort(hisi_hba, device,
1837 					  HISI_SAS_INT_ABT_DEV, 0);
1838 	if (rc < 0) {
1839 		dev_err(dev, "lu_reset: internal abort failed\n");
1840 		goto out;
1841 	}
1842 	hisi_sas_dereg_device(hisi_hba, device);
1843 
1844 	if (dev_is_sata(device)) {
1845 		struct sas_phy *phy;
1846 
1847 		phy = sas_get_local_phy(device);
1848 
1849 		rc = sas_phy_reset(phy, true);
1850 
1851 		if (rc == 0)
1852 			hisi_sas_release_task(hisi_hba, device);
1853 		sas_put_local_phy(phy);
1854 	} else {
1855 		struct hisi_sas_tmf_task tmf_task = { .tmf =  TMF_LU_RESET };
1856 
1857 		rc = hisi_sas_debug_issue_ssp_tmf(device, lun, &tmf_task);
1858 		if (rc == TMF_RESP_FUNC_COMPLETE)
1859 			hisi_sas_release_task(hisi_hba, device);
1860 	}
1861 out:
1862 	if (rc != TMF_RESP_FUNC_COMPLETE)
1863 		dev_err(dev, "lu_reset: for device[%d]:rc= %d\n",
1864 			     sas_dev->device_id, rc);
1865 	return rc;
1866 }
1867 
1868 static int hisi_sas_clear_nexus_ha(struct sas_ha_struct *sas_ha)
1869 {
1870 	struct hisi_hba *hisi_hba = sas_ha->lldd_ha;
1871 	struct device *dev = hisi_hba->dev;
1872 	HISI_SAS_DECLARE_RST_WORK_ON_STACK(r);
1873 	int rc, i;
1874 
1875 	queue_work(hisi_hba->wq, &r.work);
1876 	wait_for_completion(r.completion);
1877 	if (!r.done)
1878 		return TMF_RESP_FUNC_FAILED;
1879 
1880 	for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
1881 		struct hisi_sas_device *sas_dev = &hisi_hba->devices[i];
1882 		struct domain_device *device = sas_dev->sas_device;
1883 
1884 		if ((sas_dev->dev_type == SAS_PHY_UNUSED) || !device ||
1885 		    dev_is_expander(device->dev_type))
1886 			continue;
1887 
1888 		rc = hisi_sas_debug_I_T_nexus_reset(device);
1889 		if (rc != TMF_RESP_FUNC_COMPLETE)
1890 			dev_info(dev, "clear nexus ha: for device[%d] rc=%d\n",
1891 				 sas_dev->device_id, rc);
1892 	}
1893 
1894 	hisi_sas_release_tasks(hisi_hba);
1895 
1896 	return TMF_RESP_FUNC_COMPLETE;
1897 }
1898 
1899 static int hisi_sas_query_task(struct sas_task *task)
1900 {
1901 	struct scsi_lun lun;
1902 	struct hisi_sas_tmf_task tmf_task;
1903 	int rc = TMF_RESP_FUNC_FAILED;
1904 
1905 	if (task->lldd_task && task->task_proto & SAS_PROTOCOL_SSP) {
1906 		struct scsi_cmnd *cmnd = task->uldd_task;
1907 		struct domain_device *device = task->dev;
1908 		struct hisi_sas_slot *slot = task->lldd_task;
1909 		u32 tag = slot->idx;
1910 
1911 		int_to_scsilun(cmnd->device->lun, &lun);
1912 		tmf_task.tmf = TMF_QUERY_TASK;
1913 		tmf_task.tag_of_task_to_be_managed = tag;
1914 
1915 		rc = hisi_sas_debug_issue_ssp_tmf(device,
1916 						  lun.scsi_lun,
1917 						  &tmf_task);
1918 		switch (rc) {
1919 		/* The task is still in Lun, release it then */
1920 		case TMF_RESP_FUNC_SUCC:
1921 		/* The task is not in Lun or failed, reset the phy */
1922 		case TMF_RESP_FUNC_FAILED:
1923 		case TMF_RESP_FUNC_COMPLETE:
1924 			break;
1925 		default:
1926 			rc = TMF_RESP_FUNC_FAILED;
1927 			break;
1928 		}
1929 	}
1930 	return rc;
1931 }
1932 
1933 static int
1934 hisi_sas_internal_abort_task_exec(struct hisi_hba *hisi_hba, int device_id,
1935 				  struct sas_task *task, int abort_flag,
1936 				  int task_tag, struct hisi_sas_dq *dq)
1937 {
1938 	struct domain_device *device = task->dev;
1939 	struct hisi_sas_device *sas_dev = device->lldd_dev;
1940 	struct device *dev = hisi_hba->dev;
1941 	struct hisi_sas_port *port;
1942 	struct hisi_sas_slot *slot;
1943 	struct asd_sas_port *sas_port = device->port;
1944 	struct hisi_sas_cmd_hdr *cmd_hdr_base;
1945 	int dlvry_queue_slot, dlvry_queue, n_elem = 0, rc, slot_idx;
1946 	unsigned long flags;
1947 	int wr_q_index;
1948 
1949 	if (unlikely(test_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags)))
1950 		return -EINVAL;
1951 
1952 	if (!device->port)
1953 		return -1;
1954 
1955 	port = to_hisi_sas_port(sas_port);
1956 
1957 	/* simply get a slot and send abort command */
1958 	rc = hisi_sas_slot_index_alloc(hisi_hba, NULL);
1959 	if (rc < 0)
1960 		goto err_out;
1961 
1962 	slot_idx = rc;
1963 	slot = &hisi_hba->slot_info[slot_idx];
1964 
1965 	spin_lock(&dq->lock);
1966 	wr_q_index = dq->wr_point;
1967 	dq->wr_point = (dq->wr_point + 1) % HISI_SAS_QUEUE_SLOTS;
1968 	list_add_tail(&slot->delivery, &dq->list);
1969 	spin_unlock(&dq->lock);
1970 	spin_lock(&sas_dev->lock);
1971 	list_add_tail(&slot->entry, &sas_dev->list);
1972 	spin_unlock(&sas_dev->lock);
1973 
1974 	dlvry_queue = dq->id;
1975 	dlvry_queue_slot = wr_q_index;
1976 
1977 	slot->device_id = sas_dev->device_id;
1978 	slot->n_elem = n_elem;
1979 	slot->dlvry_queue = dlvry_queue;
1980 	slot->dlvry_queue_slot = dlvry_queue_slot;
1981 	cmd_hdr_base = hisi_hba->cmd_hdr[dlvry_queue];
1982 	slot->cmd_hdr = &cmd_hdr_base[dlvry_queue_slot];
1983 	slot->task = task;
1984 	slot->port = port;
1985 	slot->is_internal = true;
1986 	task->lldd_task = slot;
1987 
1988 	memset(slot->cmd_hdr, 0, sizeof(struct hisi_sas_cmd_hdr));
1989 	memset(hisi_sas_cmd_hdr_addr_mem(slot), 0, HISI_SAS_COMMAND_TABLE_SZ);
1990 	memset(hisi_sas_status_buf_addr_mem(slot), 0,
1991 	       sizeof(struct hisi_sas_err_record));
1992 
1993 	hisi_sas_task_prep_abort(hisi_hba, slot, device_id,
1994 				      abort_flag, task_tag);
1995 
1996 	spin_lock_irqsave(&task->task_state_lock, flags);
1997 	task->task_state_flags |= SAS_TASK_AT_INITIATOR;
1998 	spin_unlock_irqrestore(&task->task_state_lock, flags);
1999 	WRITE_ONCE(slot->ready, 1);
2000 	/* send abort command to the chip */
2001 	spin_lock(&dq->lock);
2002 	hisi_hba->hw->start_delivery(dq);
2003 	spin_unlock(&dq->lock);
2004 
2005 	return 0;
2006 
2007 err_out:
2008 	dev_err(dev, "internal abort task prep: failed[%d]!\n", rc);
2009 
2010 	return rc;
2011 }
2012 
2013 /**
2014  * _hisi_sas_internal_task_abort -- execute an internal
2015  * abort command for single IO command or a device
2016  * @hisi_hba: host controller struct
2017  * @device: domain device
2018  * @abort_flag: mode of operation, device or single IO
2019  * @tag: tag of IO to be aborted (only relevant to single
2020  *       IO mode)
2021  * @dq: delivery queue for this internal abort command
2022  */
2023 static int
2024 _hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
2025 			      struct domain_device *device, int abort_flag,
2026 			      int tag, struct hisi_sas_dq *dq)
2027 {
2028 	struct sas_task *task;
2029 	struct hisi_sas_device *sas_dev = device->lldd_dev;
2030 	struct device *dev = hisi_hba->dev;
2031 	int res;
2032 
2033 	/*
2034 	 * The interface is not realized means this HW don't support internal
2035 	 * abort, or don't need to do internal abort. Then here, we return
2036 	 * TMF_RESP_FUNC_FAILED and let other steps go on, which depends that
2037 	 * the internal abort has been executed and returned CQ.
2038 	 */
2039 	if (!hisi_hba->hw->prep_abort)
2040 		return TMF_RESP_FUNC_FAILED;
2041 
2042 	task = sas_alloc_slow_task(GFP_KERNEL);
2043 	if (!task)
2044 		return -ENOMEM;
2045 
2046 	task->dev = device;
2047 	task->task_proto = device->tproto;
2048 	task->task_done = hisi_sas_task_done;
2049 	task->slow_task->timer.function = hisi_sas_tmf_timedout;
2050 	task->slow_task->timer.expires = jiffies + INTERNAL_ABORT_TIMEOUT * HZ;
2051 	add_timer(&task->slow_task->timer);
2052 
2053 	res = hisi_sas_internal_abort_task_exec(hisi_hba, sas_dev->device_id,
2054 						task, abort_flag, tag, dq);
2055 	if (res) {
2056 		del_timer(&task->slow_task->timer);
2057 		dev_err(dev, "internal task abort: executing internal task failed: %d\n",
2058 			res);
2059 		goto exit;
2060 	}
2061 	wait_for_completion(&task->slow_task->completion);
2062 	res = TMF_RESP_FUNC_FAILED;
2063 
2064 	/* Internal abort timed out */
2065 	if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
2066 		if (hisi_sas_debugfs_enable && hisi_hba->debugfs_itct[0].itct)
2067 			queue_work(hisi_hba->wq, &hisi_hba->debugfs_work);
2068 
2069 		if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
2070 			struct hisi_sas_slot *slot = task->lldd_task;
2071 
2072 			if (slot) {
2073 				struct hisi_sas_cq *cq =
2074 					&hisi_hba->cq[slot->dlvry_queue];
2075 				/*
2076 				 * sync irq to avoid free'ing task
2077 				 * before using task in IO completion
2078 				 */
2079 				synchronize_irq(cq->irq_no);
2080 				slot->task = NULL;
2081 			}
2082 			dev_err(dev, "internal task abort: timeout and not done.\n");
2083 
2084 			res = -EIO;
2085 			goto exit;
2086 		} else
2087 			dev_err(dev, "internal task abort: timeout.\n");
2088 	}
2089 
2090 	if (task->task_status.resp == SAS_TASK_COMPLETE &&
2091 		task->task_status.stat == TMF_RESP_FUNC_COMPLETE) {
2092 		res = TMF_RESP_FUNC_COMPLETE;
2093 		goto exit;
2094 	}
2095 
2096 	if (task->task_status.resp == SAS_TASK_COMPLETE &&
2097 		task->task_status.stat == TMF_RESP_FUNC_SUCC) {
2098 		res = TMF_RESP_FUNC_SUCC;
2099 		goto exit;
2100 	}
2101 
2102 exit:
2103 	dev_dbg(dev, "internal task abort: task to dev %016llx task=%pK resp: 0x%x sts 0x%x\n",
2104 		SAS_ADDR(device->sas_addr), task,
2105 		task->task_status.resp, /* 0 is complete, -1 is undelivered */
2106 		task->task_status.stat);
2107 	sas_free_task(task);
2108 
2109 	return res;
2110 }
2111 
2112 static int
2113 hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
2114 			     struct domain_device *device,
2115 			     int abort_flag, int tag)
2116 {
2117 	struct hisi_sas_slot *slot;
2118 	struct device *dev = hisi_hba->dev;
2119 	struct hisi_sas_dq *dq;
2120 	int i, rc;
2121 
2122 	switch (abort_flag) {
2123 	case HISI_SAS_INT_ABT_CMD:
2124 		slot = &hisi_hba->slot_info[tag];
2125 		dq = &hisi_hba->dq[slot->dlvry_queue];
2126 		return _hisi_sas_internal_task_abort(hisi_hba, device,
2127 						     abort_flag, tag, dq);
2128 	case HISI_SAS_INT_ABT_DEV:
2129 		for (i = 0; i < hisi_hba->cq_nvecs; i++) {
2130 			struct hisi_sas_cq *cq = &hisi_hba->cq[i];
2131 			const struct cpumask *mask = cq->irq_mask;
2132 
2133 			if (mask && !cpumask_intersects(cpu_online_mask, mask))
2134 				continue;
2135 			dq = &hisi_hba->dq[i];
2136 			rc = _hisi_sas_internal_task_abort(hisi_hba, device,
2137 							   abort_flag, tag,
2138 							   dq);
2139 			if (rc)
2140 				return rc;
2141 		}
2142 		break;
2143 	default:
2144 		dev_err(dev, "Unrecognised internal abort flag (%d)\n",
2145 			abort_flag);
2146 		return -EINVAL;
2147 	}
2148 
2149 	return 0;
2150 }
2151 
2152 static void hisi_sas_port_formed(struct asd_sas_phy *sas_phy)
2153 {
2154 	hisi_sas_port_notify_formed(sas_phy);
2155 }
2156 
2157 static int hisi_sas_write_gpio(struct sas_ha_struct *sha, u8 reg_type,
2158 			u8 reg_index, u8 reg_count, u8 *write_data)
2159 {
2160 	struct hisi_hba *hisi_hba = sha->lldd_ha;
2161 
2162 	if (!hisi_hba->hw->write_gpio)
2163 		return -EOPNOTSUPP;
2164 
2165 	return hisi_hba->hw->write_gpio(hisi_hba, reg_type,
2166 				reg_index, reg_count, write_data);
2167 }
2168 
2169 static void hisi_sas_phy_disconnected(struct hisi_sas_phy *phy)
2170 {
2171 	struct asd_sas_phy *sas_phy = &phy->sas_phy;
2172 	struct sas_phy *sphy = sas_phy->phy;
2173 	unsigned long flags;
2174 
2175 	phy->phy_attached = 0;
2176 	phy->phy_type = 0;
2177 	phy->port = NULL;
2178 
2179 	spin_lock_irqsave(&phy->lock, flags);
2180 	if (phy->enable)
2181 		sphy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
2182 	else
2183 		sphy->negotiated_linkrate = SAS_PHY_DISABLED;
2184 	spin_unlock_irqrestore(&phy->lock, flags);
2185 }
2186 
2187 void hisi_sas_phy_down(struct hisi_hba *hisi_hba, int phy_no, int rdy)
2188 {
2189 	struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
2190 	struct asd_sas_phy *sas_phy = &phy->sas_phy;
2191 	struct sas_ha_struct *sas_ha = &hisi_hba->sha;
2192 	struct device *dev = hisi_hba->dev;
2193 
2194 	if (rdy) {
2195 		/* Phy down but ready */
2196 		hisi_sas_bytes_dmaed(hisi_hba, phy_no);
2197 		hisi_sas_port_notify_formed(sas_phy);
2198 	} else {
2199 		struct hisi_sas_port *port  = phy->port;
2200 
2201 		if (test_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags) ||
2202 		    phy->in_reset) {
2203 			dev_info(dev, "ignore flutter phy%d down\n", phy_no);
2204 			return;
2205 		}
2206 		/* Phy down and not ready */
2207 		sas_ha->notify_phy_event(sas_phy, PHYE_LOSS_OF_SIGNAL);
2208 		sas_phy_disconnected(sas_phy);
2209 
2210 		if (port) {
2211 			if (phy->phy_type & PORT_TYPE_SAS) {
2212 				int port_id = port->id;
2213 
2214 				if (!hisi_hba->hw->get_wideport_bitmap(hisi_hba,
2215 								       port_id))
2216 					port->port_attached = 0;
2217 			} else if (phy->phy_type & PORT_TYPE_SATA)
2218 				port->port_attached = 0;
2219 		}
2220 		hisi_sas_phy_disconnected(phy);
2221 	}
2222 }
2223 EXPORT_SYMBOL_GPL(hisi_sas_phy_down);
2224 
2225 void hisi_sas_sync_irqs(struct hisi_hba *hisi_hba)
2226 {
2227 	int i;
2228 
2229 	for (i = 0; i < hisi_hba->cq_nvecs; i++) {
2230 		struct hisi_sas_cq *cq = &hisi_hba->cq[i];
2231 
2232 		synchronize_irq(cq->irq_no);
2233 	}
2234 }
2235 EXPORT_SYMBOL_GPL(hisi_sas_sync_irqs);
2236 
2237 int hisi_sas_host_reset(struct Scsi_Host *shost, int reset_type)
2238 {
2239 	struct hisi_hba *hisi_hba = shost_priv(shost);
2240 
2241 	if (reset_type != SCSI_ADAPTER_RESET)
2242 		return -EOPNOTSUPP;
2243 
2244 	queue_work(hisi_hba->wq, &hisi_hba->rst_work);
2245 
2246 	return 0;
2247 }
2248 EXPORT_SYMBOL_GPL(hisi_sas_host_reset);
2249 
2250 struct scsi_transport_template *hisi_sas_stt;
2251 EXPORT_SYMBOL_GPL(hisi_sas_stt);
2252 
2253 static struct sas_domain_function_template hisi_sas_transport_ops = {
2254 	.lldd_dev_found		= hisi_sas_dev_found,
2255 	.lldd_dev_gone		= hisi_sas_dev_gone,
2256 	.lldd_execute_task	= hisi_sas_queue_command,
2257 	.lldd_control_phy	= hisi_sas_control_phy,
2258 	.lldd_abort_task	= hisi_sas_abort_task,
2259 	.lldd_abort_task_set	= hisi_sas_abort_task_set,
2260 	.lldd_clear_aca		= hisi_sas_clear_aca,
2261 	.lldd_I_T_nexus_reset	= hisi_sas_I_T_nexus_reset,
2262 	.lldd_lu_reset		= hisi_sas_lu_reset,
2263 	.lldd_query_task	= hisi_sas_query_task,
2264 	.lldd_clear_nexus_ha	= hisi_sas_clear_nexus_ha,
2265 	.lldd_port_formed	= hisi_sas_port_formed,
2266 	.lldd_write_gpio	= hisi_sas_write_gpio,
2267 };
2268 
2269 void hisi_sas_init_mem(struct hisi_hba *hisi_hba)
2270 {
2271 	int i, s, j, max_command_entries = HISI_SAS_MAX_COMMANDS;
2272 	struct hisi_sas_breakpoint *sata_breakpoint = hisi_hba->sata_breakpoint;
2273 
2274 	for (i = 0; i < hisi_hba->queue_count; i++) {
2275 		struct hisi_sas_cq *cq = &hisi_hba->cq[i];
2276 		struct hisi_sas_dq *dq = &hisi_hba->dq[i];
2277 		struct hisi_sas_cmd_hdr *cmd_hdr = hisi_hba->cmd_hdr[i];
2278 
2279 		s = sizeof(struct hisi_sas_cmd_hdr);
2280 		for (j = 0; j < HISI_SAS_QUEUE_SLOTS; j++)
2281 			memset(&cmd_hdr[j], 0, s);
2282 
2283 		dq->wr_point = 0;
2284 
2285 		s = hisi_hba->hw->complete_hdr_size * HISI_SAS_QUEUE_SLOTS;
2286 		memset(hisi_hba->complete_hdr[i], 0, s);
2287 		cq->rd_point = 0;
2288 	}
2289 
2290 	s = sizeof(struct hisi_sas_initial_fis) * hisi_hba->n_phy;
2291 	memset(hisi_hba->initial_fis, 0, s);
2292 
2293 	s = max_command_entries * sizeof(struct hisi_sas_iost);
2294 	memset(hisi_hba->iost, 0, s);
2295 
2296 	s = max_command_entries * sizeof(struct hisi_sas_breakpoint);
2297 	memset(hisi_hba->breakpoint, 0, s);
2298 
2299 	s = sizeof(struct hisi_sas_sata_breakpoint);
2300 	for (j = 0; j < HISI_SAS_MAX_ITCT_ENTRIES; j++)
2301 		memset(&sata_breakpoint[j], 0, s);
2302 }
2303 EXPORT_SYMBOL_GPL(hisi_sas_init_mem);
2304 
2305 int hisi_sas_alloc(struct hisi_hba *hisi_hba)
2306 {
2307 	struct device *dev = hisi_hba->dev;
2308 	int i, j, s, max_command_entries = HISI_SAS_MAX_COMMANDS;
2309 	int max_command_entries_ru, sz_slot_buf_ru;
2310 	int blk_cnt, slots_per_blk;
2311 
2312 	sema_init(&hisi_hba->sem, 1);
2313 	spin_lock_init(&hisi_hba->lock);
2314 	for (i = 0; i < hisi_hba->n_phy; i++) {
2315 		hisi_sas_phy_init(hisi_hba, i);
2316 		hisi_hba->port[i].port_attached = 0;
2317 		hisi_hba->port[i].id = -1;
2318 	}
2319 
2320 	for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
2321 		hisi_hba->devices[i].dev_type = SAS_PHY_UNUSED;
2322 		hisi_hba->devices[i].device_id = i;
2323 		hisi_hba->devices[i].dev_status = HISI_SAS_DEV_INIT;
2324 	}
2325 
2326 	for (i = 0; i < hisi_hba->queue_count; i++) {
2327 		struct hisi_sas_cq *cq = &hisi_hba->cq[i];
2328 		struct hisi_sas_dq *dq = &hisi_hba->dq[i];
2329 
2330 		/* Completion queue structure */
2331 		cq->id = i;
2332 		cq->hisi_hba = hisi_hba;
2333 
2334 		/* Delivery queue structure */
2335 		spin_lock_init(&dq->lock);
2336 		INIT_LIST_HEAD(&dq->list);
2337 		dq->id = i;
2338 		dq->hisi_hba = hisi_hba;
2339 
2340 		/* Delivery queue */
2341 		s = sizeof(struct hisi_sas_cmd_hdr) * HISI_SAS_QUEUE_SLOTS;
2342 		hisi_hba->cmd_hdr[i] = dmam_alloc_coherent(dev, s,
2343 						&hisi_hba->cmd_hdr_dma[i],
2344 						GFP_KERNEL);
2345 		if (!hisi_hba->cmd_hdr[i])
2346 			goto err_out;
2347 
2348 		/* Completion queue */
2349 		s = hisi_hba->hw->complete_hdr_size * HISI_SAS_QUEUE_SLOTS;
2350 		hisi_hba->complete_hdr[i] = dmam_alloc_coherent(dev, s,
2351 						&hisi_hba->complete_hdr_dma[i],
2352 						GFP_KERNEL);
2353 		if (!hisi_hba->complete_hdr[i])
2354 			goto err_out;
2355 	}
2356 
2357 	s = HISI_SAS_MAX_ITCT_ENTRIES * sizeof(struct hisi_sas_itct);
2358 	hisi_hba->itct = dmam_alloc_coherent(dev, s, &hisi_hba->itct_dma,
2359 					     GFP_KERNEL);
2360 	if (!hisi_hba->itct)
2361 		goto err_out;
2362 
2363 	hisi_hba->slot_info = devm_kcalloc(dev, max_command_entries,
2364 					   sizeof(struct hisi_sas_slot),
2365 					   GFP_KERNEL);
2366 	if (!hisi_hba->slot_info)
2367 		goto err_out;
2368 
2369 	/* roundup to avoid overly large block size */
2370 	max_command_entries_ru = roundup(max_command_entries, 64);
2371 	if (hisi_hba->prot_mask & HISI_SAS_DIX_PROT_MASK)
2372 		sz_slot_buf_ru = sizeof(struct hisi_sas_slot_dif_buf_table);
2373 	else
2374 		sz_slot_buf_ru = sizeof(struct hisi_sas_slot_buf_table);
2375 	sz_slot_buf_ru = roundup(sz_slot_buf_ru, 64);
2376 	s = max(lcm(max_command_entries_ru, sz_slot_buf_ru), PAGE_SIZE);
2377 	blk_cnt = (max_command_entries_ru * sz_slot_buf_ru) / s;
2378 	slots_per_blk = s / sz_slot_buf_ru;
2379 
2380 	for (i = 0; i < blk_cnt; i++) {
2381 		int slot_index = i * slots_per_blk;
2382 		dma_addr_t buf_dma;
2383 		void *buf;
2384 
2385 		buf = dmam_alloc_coherent(dev, s, &buf_dma,
2386 					  GFP_KERNEL);
2387 		if (!buf)
2388 			goto err_out;
2389 
2390 		for (j = 0; j < slots_per_blk; j++, slot_index++) {
2391 			struct hisi_sas_slot *slot;
2392 
2393 			slot = &hisi_hba->slot_info[slot_index];
2394 			slot->buf = buf;
2395 			slot->buf_dma = buf_dma;
2396 			slot->idx = slot_index;
2397 
2398 			buf += sz_slot_buf_ru;
2399 			buf_dma += sz_slot_buf_ru;
2400 		}
2401 	}
2402 
2403 	s = max_command_entries * sizeof(struct hisi_sas_iost);
2404 	hisi_hba->iost = dmam_alloc_coherent(dev, s, &hisi_hba->iost_dma,
2405 					     GFP_KERNEL);
2406 	if (!hisi_hba->iost)
2407 		goto err_out;
2408 
2409 	s = max_command_entries * sizeof(struct hisi_sas_breakpoint);
2410 	hisi_hba->breakpoint = dmam_alloc_coherent(dev, s,
2411 						   &hisi_hba->breakpoint_dma,
2412 						   GFP_KERNEL);
2413 	if (!hisi_hba->breakpoint)
2414 		goto err_out;
2415 
2416 	hisi_hba->slot_index_count = max_command_entries;
2417 	s = hisi_hba->slot_index_count / BITS_PER_BYTE;
2418 	hisi_hba->slot_index_tags = devm_kzalloc(dev, s, GFP_KERNEL);
2419 	if (!hisi_hba->slot_index_tags)
2420 		goto err_out;
2421 
2422 	s = sizeof(struct hisi_sas_initial_fis) * HISI_SAS_MAX_PHYS;
2423 	hisi_hba->initial_fis = dmam_alloc_coherent(dev, s,
2424 						    &hisi_hba->initial_fis_dma,
2425 						    GFP_KERNEL);
2426 	if (!hisi_hba->initial_fis)
2427 		goto err_out;
2428 
2429 	s = HISI_SAS_MAX_ITCT_ENTRIES * sizeof(struct hisi_sas_sata_breakpoint);
2430 	hisi_hba->sata_breakpoint = dmam_alloc_coherent(dev, s,
2431 					&hisi_hba->sata_breakpoint_dma,
2432 					GFP_KERNEL);
2433 	if (!hisi_hba->sata_breakpoint)
2434 		goto err_out;
2435 
2436 	hisi_sas_slot_index_init(hisi_hba);
2437 	hisi_hba->last_slot_index = HISI_SAS_UNRESERVED_IPTT;
2438 
2439 	hisi_hba->wq = create_singlethread_workqueue(dev_name(dev));
2440 	if (!hisi_hba->wq) {
2441 		dev_err(dev, "sas_alloc: failed to create workqueue\n");
2442 		goto err_out;
2443 	}
2444 
2445 	return 0;
2446 err_out:
2447 	return -ENOMEM;
2448 }
2449 EXPORT_SYMBOL_GPL(hisi_sas_alloc);
2450 
2451 void hisi_sas_free(struct hisi_hba *hisi_hba)
2452 {
2453 	int i;
2454 
2455 	for (i = 0; i < hisi_hba->n_phy; i++) {
2456 		struct hisi_sas_phy *phy = &hisi_hba->phy[i];
2457 
2458 		del_timer_sync(&phy->timer);
2459 	}
2460 
2461 	if (hisi_hba->wq)
2462 		destroy_workqueue(hisi_hba->wq);
2463 }
2464 EXPORT_SYMBOL_GPL(hisi_sas_free);
2465 
2466 void hisi_sas_rst_work_handler(struct work_struct *work)
2467 {
2468 	struct hisi_hba *hisi_hba =
2469 		container_of(work, struct hisi_hba, rst_work);
2470 
2471 	hisi_sas_controller_reset(hisi_hba);
2472 }
2473 EXPORT_SYMBOL_GPL(hisi_sas_rst_work_handler);
2474 
2475 void hisi_sas_sync_rst_work_handler(struct work_struct *work)
2476 {
2477 	struct hisi_sas_rst *rst =
2478 		container_of(work, struct hisi_sas_rst, work);
2479 
2480 	if (!hisi_sas_controller_reset(rst->hisi_hba))
2481 		rst->done = true;
2482 	complete(rst->completion);
2483 }
2484 EXPORT_SYMBOL_GPL(hisi_sas_sync_rst_work_handler);
2485 
2486 int hisi_sas_get_fw_info(struct hisi_hba *hisi_hba)
2487 {
2488 	struct device *dev = hisi_hba->dev;
2489 	struct platform_device *pdev = hisi_hba->platform_dev;
2490 	struct device_node *np = pdev ? pdev->dev.of_node : NULL;
2491 	struct clk *refclk;
2492 
2493 	if (device_property_read_u8_array(dev, "sas-addr", hisi_hba->sas_addr,
2494 					  SAS_ADDR_SIZE)) {
2495 		dev_err(dev, "could not get property sas-addr\n");
2496 		return -ENOENT;
2497 	}
2498 
2499 	if (np) {
2500 		/*
2501 		 * These properties are only required for platform device-based
2502 		 * controller with DT firmware.
2503 		 */
2504 		hisi_hba->ctrl = syscon_regmap_lookup_by_phandle(np,
2505 					"hisilicon,sas-syscon");
2506 		if (IS_ERR(hisi_hba->ctrl)) {
2507 			dev_err(dev, "could not get syscon\n");
2508 			return -ENOENT;
2509 		}
2510 
2511 		if (device_property_read_u32(dev, "ctrl-reset-reg",
2512 					     &hisi_hba->ctrl_reset_reg)) {
2513 			dev_err(dev, "could not get property ctrl-reset-reg\n");
2514 			return -ENOENT;
2515 		}
2516 
2517 		if (device_property_read_u32(dev, "ctrl-reset-sts-reg",
2518 					     &hisi_hba->ctrl_reset_sts_reg)) {
2519 			dev_err(dev, "could not get property ctrl-reset-sts-reg\n");
2520 			return -ENOENT;
2521 		}
2522 
2523 		if (device_property_read_u32(dev, "ctrl-clock-ena-reg",
2524 					     &hisi_hba->ctrl_clock_ena_reg)) {
2525 			dev_err(dev, "could not get property ctrl-clock-ena-reg\n");
2526 			return -ENOENT;
2527 		}
2528 	}
2529 
2530 	refclk = devm_clk_get(dev, NULL);
2531 	if (IS_ERR(refclk))
2532 		dev_dbg(dev, "no ref clk property\n");
2533 	else
2534 		hisi_hba->refclk_frequency_mhz = clk_get_rate(refclk) / 1000000;
2535 
2536 	if (device_property_read_u32(dev, "phy-count", &hisi_hba->n_phy)) {
2537 		dev_err(dev, "could not get property phy-count\n");
2538 		return -ENOENT;
2539 	}
2540 
2541 	if (device_property_read_u32(dev, "queue-count",
2542 				     &hisi_hba->queue_count)) {
2543 		dev_err(dev, "could not get property queue-count\n");
2544 		return -ENOENT;
2545 	}
2546 
2547 	return 0;
2548 }
2549 EXPORT_SYMBOL_GPL(hisi_sas_get_fw_info);
2550 
2551 static struct Scsi_Host *hisi_sas_shost_alloc(struct platform_device *pdev,
2552 					      const struct hisi_sas_hw *hw)
2553 {
2554 	struct resource *res;
2555 	struct Scsi_Host *shost;
2556 	struct hisi_hba *hisi_hba;
2557 	struct device *dev = &pdev->dev;
2558 	int error;
2559 
2560 	shost = scsi_host_alloc(hw->sht, sizeof(*hisi_hba));
2561 	if (!shost) {
2562 		dev_err(dev, "scsi host alloc failed\n");
2563 		return NULL;
2564 	}
2565 	hisi_hba = shost_priv(shost);
2566 
2567 	INIT_WORK(&hisi_hba->rst_work, hisi_sas_rst_work_handler);
2568 	hisi_hba->hw = hw;
2569 	hisi_hba->dev = dev;
2570 	hisi_hba->platform_dev = pdev;
2571 	hisi_hba->shost = shost;
2572 	SHOST_TO_SAS_HA(shost) = &hisi_hba->sha;
2573 
2574 	timer_setup(&hisi_hba->timer, NULL, 0);
2575 
2576 	if (hisi_sas_get_fw_info(hisi_hba) < 0)
2577 		goto err_out;
2578 
2579 	error = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64));
2580 	if (error)
2581 		error = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
2582 
2583 	if (error) {
2584 		dev_err(dev, "No usable DMA addressing method\n");
2585 		goto err_out;
2586 	}
2587 
2588 	hisi_hba->regs = devm_platform_ioremap_resource(pdev, 0);
2589 	if (IS_ERR(hisi_hba->regs))
2590 		goto err_out;
2591 
2592 	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
2593 	if (res) {
2594 		hisi_hba->sgpio_regs = devm_ioremap_resource(dev, res);
2595 		if (IS_ERR(hisi_hba->sgpio_regs))
2596 			goto err_out;
2597 	}
2598 
2599 	if (hisi_sas_alloc(hisi_hba)) {
2600 		hisi_sas_free(hisi_hba);
2601 		goto err_out;
2602 	}
2603 
2604 	return shost;
2605 err_out:
2606 	scsi_host_put(shost);
2607 	dev_err(dev, "shost alloc failed\n");
2608 	return NULL;
2609 }
2610 
2611 int hisi_sas_probe(struct platform_device *pdev,
2612 		   const struct hisi_sas_hw *hw)
2613 {
2614 	struct Scsi_Host *shost;
2615 	struct hisi_hba *hisi_hba;
2616 	struct device *dev = &pdev->dev;
2617 	struct asd_sas_phy **arr_phy;
2618 	struct asd_sas_port **arr_port;
2619 	struct sas_ha_struct *sha;
2620 	int rc, phy_nr, port_nr, i;
2621 
2622 	shost = hisi_sas_shost_alloc(pdev, hw);
2623 	if (!shost)
2624 		return -ENOMEM;
2625 
2626 	sha = SHOST_TO_SAS_HA(shost);
2627 	hisi_hba = shost_priv(shost);
2628 	platform_set_drvdata(pdev, sha);
2629 
2630 	phy_nr = port_nr = hisi_hba->n_phy;
2631 
2632 	arr_phy = devm_kcalloc(dev, phy_nr, sizeof(void *), GFP_KERNEL);
2633 	arr_port = devm_kcalloc(dev, port_nr, sizeof(void *), GFP_KERNEL);
2634 	if (!arr_phy || !arr_port) {
2635 		rc = -ENOMEM;
2636 		goto err_out_ha;
2637 	}
2638 
2639 	sha->sas_phy = arr_phy;
2640 	sha->sas_port = arr_port;
2641 	sha->lldd_ha = hisi_hba;
2642 
2643 	shost->transportt = hisi_sas_stt;
2644 	shost->max_id = HISI_SAS_MAX_DEVICES;
2645 	shost->max_lun = ~0;
2646 	shost->max_channel = 1;
2647 	shost->max_cmd_len = 16;
2648 	if (hisi_hba->hw->slot_index_alloc) {
2649 		shost->can_queue = HISI_SAS_MAX_COMMANDS;
2650 		shost->cmd_per_lun = HISI_SAS_MAX_COMMANDS;
2651 	} else {
2652 		shost->can_queue = HISI_SAS_UNRESERVED_IPTT;
2653 		shost->cmd_per_lun = HISI_SAS_UNRESERVED_IPTT;
2654 	}
2655 
2656 	sha->sas_ha_name = DRV_NAME;
2657 	sha->dev = hisi_hba->dev;
2658 	sha->lldd_module = THIS_MODULE;
2659 	sha->sas_addr = &hisi_hba->sas_addr[0];
2660 	sha->num_phys = hisi_hba->n_phy;
2661 	sha->core.shost = hisi_hba->shost;
2662 
2663 	for (i = 0; i < hisi_hba->n_phy; i++) {
2664 		sha->sas_phy[i] = &hisi_hba->phy[i].sas_phy;
2665 		sha->sas_port[i] = &hisi_hba->port[i].sas_port;
2666 	}
2667 
2668 	rc = scsi_add_host(shost, &pdev->dev);
2669 	if (rc)
2670 		goto err_out_ha;
2671 
2672 	rc = sas_register_ha(sha);
2673 	if (rc)
2674 		goto err_out_register_ha;
2675 
2676 	rc = hisi_hba->hw->hw_init(hisi_hba);
2677 	if (rc)
2678 		goto err_out_register_ha;
2679 
2680 	scsi_scan_host(shost);
2681 
2682 	return 0;
2683 
2684 err_out_register_ha:
2685 	scsi_remove_host(shost);
2686 err_out_ha:
2687 	hisi_sas_debugfs_exit(hisi_hba);
2688 	hisi_sas_free(hisi_hba);
2689 	scsi_host_put(shost);
2690 	return rc;
2691 }
2692 EXPORT_SYMBOL_GPL(hisi_sas_probe);
2693 
2694 struct dentry *hisi_sas_debugfs_dir;
2695 
2696 static void hisi_sas_debugfs_snapshot_cq_reg(struct hisi_hba *hisi_hba)
2697 {
2698 	int queue_entry_size = hisi_hba->hw->complete_hdr_size;
2699 	int dump_index = hisi_hba->debugfs_dump_index;
2700 	int i;
2701 
2702 	for (i = 0; i < hisi_hba->queue_count; i++)
2703 		memcpy(hisi_hba->debugfs_cq[dump_index][i].complete_hdr,
2704 		       hisi_hba->complete_hdr[i],
2705 		       HISI_SAS_QUEUE_SLOTS * queue_entry_size);
2706 }
2707 
2708 static void hisi_sas_debugfs_snapshot_dq_reg(struct hisi_hba *hisi_hba)
2709 {
2710 	int queue_entry_size = sizeof(struct hisi_sas_cmd_hdr);
2711 	int dump_index = hisi_hba->debugfs_dump_index;
2712 	int i;
2713 
2714 	for (i = 0; i < hisi_hba->queue_count; i++) {
2715 		struct hisi_sas_cmd_hdr *debugfs_cmd_hdr, *cmd_hdr;
2716 		int j;
2717 
2718 		debugfs_cmd_hdr = hisi_hba->debugfs_dq[dump_index][i].hdr;
2719 		cmd_hdr = hisi_hba->cmd_hdr[i];
2720 
2721 		for (j = 0; j < HISI_SAS_QUEUE_SLOTS; j++)
2722 			memcpy(&debugfs_cmd_hdr[j], &cmd_hdr[j],
2723 			       queue_entry_size);
2724 	}
2725 }
2726 
2727 static void hisi_sas_debugfs_snapshot_port_reg(struct hisi_hba *hisi_hba)
2728 {
2729 	int dump_index = hisi_hba->debugfs_dump_index;
2730 	const struct hisi_sas_debugfs_reg *port =
2731 		hisi_hba->hw->debugfs_reg_port;
2732 	int i, phy_cnt;
2733 	u32 offset;
2734 	u32 *databuf;
2735 
2736 	for (phy_cnt = 0; phy_cnt < hisi_hba->n_phy; phy_cnt++) {
2737 		databuf = hisi_hba->debugfs_port_reg[dump_index][phy_cnt].data;
2738 		for (i = 0; i < port->count; i++, databuf++) {
2739 			offset = port->base_off + 4 * i;
2740 			*databuf = port->read_port_reg(hisi_hba, phy_cnt,
2741 						       offset);
2742 		}
2743 	}
2744 }
2745 
2746 static void hisi_sas_debugfs_snapshot_global_reg(struct hisi_hba *hisi_hba)
2747 {
2748 	int dump_index = hisi_hba->debugfs_dump_index;
2749 	u32 *databuf = hisi_hba->debugfs_regs[dump_index][DEBUGFS_GLOBAL].data;
2750 	const struct hisi_sas_hw *hw = hisi_hba->hw;
2751 	const struct hisi_sas_debugfs_reg *global =
2752 			hw->debugfs_reg_array[DEBUGFS_GLOBAL];
2753 	int i;
2754 
2755 	for (i = 0; i < global->count; i++, databuf++)
2756 		*databuf = global->read_global_reg(hisi_hba, 4 * i);
2757 }
2758 
2759 static void hisi_sas_debugfs_snapshot_axi_reg(struct hisi_hba *hisi_hba)
2760 {
2761 	int dump_index = hisi_hba->debugfs_dump_index;
2762 	u32 *databuf = hisi_hba->debugfs_regs[dump_index][DEBUGFS_AXI].data;
2763 	const struct hisi_sas_hw *hw = hisi_hba->hw;
2764 	const struct hisi_sas_debugfs_reg *axi =
2765 			hw->debugfs_reg_array[DEBUGFS_AXI];
2766 	int i;
2767 
2768 	for (i = 0; i < axi->count; i++, databuf++)
2769 		*databuf = axi->read_global_reg(hisi_hba,
2770 						4 * i + axi->base_off);
2771 }
2772 
2773 static void hisi_sas_debugfs_snapshot_ras_reg(struct hisi_hba *hisi_hba)
2774 {
2775 	int dump_index = hisi_hba->debugfs_dump_index;
2776 	u32 *databuf = hisi_hba->debugfs_regs[dump_index][DEBUGFS_RAS].data;
2777 	const struct hisi_sas_hw *hw = hisi_hba->hw;
2778 	const struct hisi_sas_debugfs_reg *ras =
2779 			hw->debugfs_reg_array[DEBUGFS_RAS];
2780 	int i;
2781 
2782 	for (i = 0; i < ras->count; i++, databuf++)
2783 		*databuf = ras->read_global_reg(hisi_hba,
2784 						4 * i + ras->base_off);
2785 }
2786 
2787 static void hisi_sas_debugfs_snapshot_itct_reg(struct hisi_hba *hisi_hba)
2788 {
2789 	int dump_index = hisi_hba->debugfs_dump_index;
2790 	void *cachebuf = hisi_hba->debugfs_itct_cache[dump_index].cache;
2791 	void *databuf = hisi_hba->debugfs_itct[dump_index].itct;
2792 	struct hisi_sas_itct *itct;
2793 	int i;
2794 
2795 	hisi_hba->hw->read_iost_itct_cache(hisi_hba, HISI_SAS_ITCT_CACHE,
2796 					   cachebuf);
2797 
2798 	itct = hisi_hba->itct;
2799 
2800 	for (i = 0; i < HISI_SAS_MAX_ITCT_ENTRIES; i++, itct++) {
2801 		memcpy(databuf, itct, sizeof(struct hisi_sas_itct));
2802 		databuf += sizeof(struct hisi_sas_itct);
2803 	}
2804 }
2805 
2806 static void hisi_sas_debugfs_snapshot_iost_reg(struct hisi_hba *hisi_hba)
2807 {
2808 	int dump_index = hisi_hba->debugfs_dump_index;
2809 	int max_command_entries = HISI_SAS_MAX_COMMANDS;
2810 	void *cachebuf = hisi_hba->debugfs_iost_cache[dump_index].cache;
2811 	void *databuf = hisi_hba->debugfs_iost[dump_index].iost;
2812 	struct hisi_sas_iost *iost;
2813 	int i;
2814 
2815 	hisi_hba->hw->read_iost_itct_cache(hisi_hba, HISI_SAS_IOST_CACHE,
2816 					   cachebuf);
2817 
2818 	iost = hisi_hba->iost;
2819 
2820 	for (i = 0; i < max_command_entries; i++, iost++) {
2821 		memcpy(databuf, iost, sizeof(struct hisi_sas_iost));
2822 		databuf += sizeof(struct hisi_sas_iost);
2823 	}
2824 }
2825 
2826 static const char *
2827 hisi_sas_debugfs_to_reg_name(int off, int base_off,
2828 			     const struct hisi_sas_debugfs_reg_lu *lu)
2829 {
2830 	for (; lu->name; lu++) {
2831 		if (off == lu->off - base_off)
2832 			return lu->name;
2833 	}
2834 
2835 	return NULL;
2836 }
2837 
2838 static void hisi_sas_debugfs_print_reg(u32 *regs_val, const void *ptr,
2839 				       struct seq_file *s)
2840 {
2841 	const struct hisi_sas_debugfs_reg *reg = ptr;
2842 	int i;
2843 
2844 	for (i = 0; i < reg->count; i++) {
2845 		int off = i * 4;
2846 		const char *name;
2847 
2848 		name = hisi_sas_debugfs_to_reg_name(off, reg->base_off,
2849 						    reg->lu);
2850 
2851 		if (name)
2852 			seq_printf(s, "0x%08x 0x%08x %s\n", off,
2853 				   regs_val[i], name);
2854 		else
2855 			seq_printf(s, "0x%08x 0x%08x\n", off,
2856 				   regs_val[i]);
2857 	}
2858 }
2859 
2860 static int hisi_sas_debugfs_global_show(struct seq_file *s, void *p)
2861 {
2862 	struct hisi_sas_debugfs_regs *global = s->private;
2863 	struct hisi_hba *hisi_hba = global->hisi_hba;
2864 	const struct hisi_sas_hw *hw = hisi_hba->hw;
2865 	const void *reg_global = hw->debugfs_reg_array[DEBUGFS_GLOBAL];
2866 
2867 	hisi_sas_debugfs_print_reg(global->data,
2868 				   reg_global, s);
2869 
2870 	return 0;
2871 }
2872 
2873 static int hisi_sas_debugfs_global_open(struct inode *inode, struct file *filp)
2874 {
2875 	return single_open(filp, hisi_sas_debugfs_global_show,
2876 			   inode->i_private);
2877 }
2878 
2879 static const struct file_operations hisi_sas_debugfs_global_fops = {
2880 	.open = hisi_sas_debugfs_global_open,
2881 	.read = seq_read,
2882 	.llseek = seq_lseek,
2883 	.release = single_release,
2884 	.owner = THIS_MODULE,
2885 };
2886 
2887 static int hisi_sas_debugfs_axi_show(struct seq_file *s, void *p)
2888 {
2889 	struct hisi_sas_debugfs_regs *axi = s->private;
2890 	struct hisi_hba *hisi_hba = axi->hisi_hba;
2891 	const struct hisi_sas_hw *hw = hisi_hba->hw;
2892 	const void *reg_axi = hw->debugfs_reg_array[DEBUGFS_AXI];
2893 
2894 	hisi_sas_debugfs_print_reg(axi->data,
2895 				   reg_axi, s);
2896 
2897 	return 0;
2898 }
2899 
2900 static int hisi_sas_debugfs_axi_open(struct inode *inode, struct file *filp)
2901 {
2902 	return single_open(filp, hisi_sas_debugfs_axi_show,
2903 			   inode->i_private);
2904 }
2905 
2906 static const struct file_operations hisi_sas_debugfs_axi_fops = {
2907 	.open = hisi_sas_debugfs_axi_open,
2908 	.read = seq_read,
2909 	.llseek = seq_lseek,
2910 	.release = single_release,
2911 	.owner = THIS_MODULE,
2912 };
2913 
2914 static int hisi_sas_debugfs_ras_show(struct seq_file *s, void *p)
2915 {
2916 	struct hisi_sas_debugfs_regs *ras = s->private;
2917 	struct hisi_hba *hisi_hba = ras->hisi_hba;
2918 	const struct hisi_sas_hw *hw = hisi_hba->hw;
2919 	const void *reg_ras = hw->debugfs_reg_array[DEBUGFS_RAS];
2920 
2921 	hisi_sas_debugfs_print_reg(ras->data,
2922 				   reg_ras, s);
2923 
2924 	return 0;
2925 }
2926 
2927 static int hisi_sas_debugfs_ras_open(struct inode *inode, struct file *filp)
2928 {
2929 	return single_open(filp, hisi_sas_debugfs_ras_show,
2930 			   inode->i_private);
2931 }
2932 
2933 static const struct file_operations hisi_sas_debugfs_ras_fops = {
2934 	.open = hisi_sas_debugfs_ras_open,
2935 	.read = seq_read,
2936 	.llseek = seq_lseek,
2937 	.release = single_release,
2938 	.owner = THIS_MODULE,
2939 };
2940 
2941 static int hisi_sas_debugfs_port_show(struct seq_file *s, void *p)
2942 {
2943 	struct hisi_sas_debugfs_port *port = s->private;
2944 	struct hisi_sas_phy *phy = port->phy;
2945 	struct hisi_hba *hisi_hba = phy->hisi_hba;
2946 	const struct hisi_sas_hw *hw = hisi_hba->hw;
2947 	const struct hisi_sas_debugfs_reg *reg_port = hw->debugfs_reg_port;
2948 
2949 	hisi_sas_debugfs_print_reg(port->data, reg_port, s);
2950 
2951 	return 0;
2952 }
2953 
2954 static int hisi_sas_debugfs_port_open(struct inode *inode, struct file *filp)
2955 {
2956 	return single_open(filp, hisi_sas_debugfs_port_show, inode->i_private);
2957 }
2958 
2959 static const struct file_operations hisi_sas_debugfs_port_fops = {
2960 	.open = hisi_sas_debugfs_port_open,
2961 	.read = seq_read,
2962 	.llseek = seq_lseek,
2963 	.release = single_release,
2964 	.owner = THIS_MODULE,
2965 };
2966 
2967 static void hisi_sas_show_row_64(struct seq_file *s, int index,
2968 				 int sz, __le64 *ptr)
2969 {
2970 	int i;
2971 
2972 	/* completion header size not fixed per HW version */
2973 	seq_printf(s, "index %04d:\n\t", index);
2974 	for (i = 1; i <= sz / 8; i++, ptr++) {
2975 		seq_printf(s, " 0x%016llx", le64_to_cpu(*ptr));
2976 		if (!(i % 2))
2977 			seq_puts(s, "\n\t");
2978 	}
2979 
2980 	seq_puts(s, "\n");
2981 }
2982 
2983 static void hisi_sas_show_row_32(struct seq_file *s, int index,
2984 				 int sz, __le32 *ptr)
2985 {
2986 	int i;
2987 
2988 	/* completion header size not fixed per HW version */
2989 	seq_printf(s, "index %04d:\n\t", index);
2990 	for (i = 1; i <= sz / 4; i++, ptr++) {
2991 		seq_printf(s, " 0x%08x", le32_to_cpu(*ptr));
2992 		if (!(i % 4))
2993 			seq_puts(s, "\n\t");
2994 	}
2995 	seq_puts(s, "\n");
2996 }
2997 
2998 static void hisi_sas_cq_show_slot(struct seq_file *s, int slot,
2999 				  struct hisi_sas_debugfs_cq *debugfs_cq)
3000 {
3001 	struct hisi_sas_cq *cq = debugfs_cq->cq;
3002 	struct hisi_hba *hisi_hba = cq->hisi_hba;
3003 	__le32 *complete_hdr = debugfs_cq->complete_hdr +
3004 			       (hisi_hba->hw->complete_hdr_size * slot);
3005 
3006 	hisi_sas_show_row_32(s, slot,
3007 			     hisi_hba->hw->complete_hdr_size,
3008 			     complete_hdr);
3009 }
3010 
3011 static int hisi_sas_debugfs_cq_show(struct seq_file *s, void *p)
3012 {
3013 	struct hisi_sas_debugfs_cq *debugfs_cq = s->private;
3014 	int slot;
3015 
3016 	for (slot = 0; slot < HISI_SAS_QUEUE_SLOTS; slot++) {
3017 		hisi_sas_cq_show_slot(s, slot, debugfs_cq);
3018 	}
3019 	return 0;
3020 }
3021 
3022 static int hisi_sas_debugfs_cq_open(struct inode *inode, struct file *filp)
3023 {
3024 	return single_open(filp, hisi_sas_debugfs_cq_show, inode->i_private);
3025 }
3026 
3027 static const struct file_operations hisi_sas_debugfs_cq_fops = {
3028 	.open = hisi_sas_debugfs_cq_open,
3029 	.read = seq_read,
3030 	.llseek = seq_lseek,
3031 	.release = single_release,
3032 	.owner = THIS_MODULE,
3033 };
3034 
3035 static void hisi_sas_dq_show_slot(struct seq_file *s, int slot, void *dq_ptr)
3036 {
3037 	struct hisi_sas_debugfs_dq *debugfs_dq = dq_ptr;
3038 	void *cmd_queue = debugfs_dq->hdr;
3039 	__le32 *cmd_hdr = cmd_queue +
3040 		sizeof(struct hisi_sas_cmd_hdr) * slot;
3041 
3042 	hisi_sas_show_row_32(s, slot, sizeof(struct hisi_sas_cmd_hdr), cmd_hdr);
3043 }
3044 
3045 static int hisi_sas_debugfs_dq_show(struct seq_file *s, void *p)
3046 {
3047 	int slot;
3048 
3049 	for (slot = 0; slot < HISI_SAS_QUEUE_SLOTS; slot++) {
3050 		hisi_sas_dq_show_slot(s, slot, s->private);
3051 	}
3052 	return 0;
3053 }
3054 
3055 static int hisi_sas_debugfs_dq_open(struct inode *inode, struct file *filp)
3056 {
3057 	return single_open(filp, hisi_sas_debugfs_dq_show, inode->i_private);
3058 }
3059 
3060 static const struct file_operations hisi_sas_debugfs_dq_fops = {
3061 	.open = hisi_sas_debugfs_dq_open,
3062 	.read = seq_read,
3063 	.llseek = seq_lseek,
3064 	.release = single_release,
3065 	.owner = THIS_MODULE,
3066 };
3067 
3068 static int hisi_sas_debugfs_iost_show(struct seq_file *s, void *p)
3069 {
3070 	struct hisi_sas_debugfs_iost *debugfs_iost = s->private;
3071 	struct hisi_sas_iost *iost = debugfs_iost->iost;
3072 	int i, max_command_entries = HISI_SAS_MAX_COMMANDS;
3073 
3074 	for (i = 0; i < max_command_entries; i++, iost++) {
3075 		__le64 *data = &iost->qw0;
3076 
3077 		hisi_sas_show_row_64(s, i, sizeof(*iost), data);
3078 	}
3079 
3080 	return 0;
3081 }
3082 
3083 static int hisi_sas_debugfs_iost_open(struct inode *inode, struct file *filp)
3084 {
3085 	return single_open(filp, hisi_sas_debugfs_iost_show, inode->i_private);
3086 }
3087 
3088 static const struct file_operations hisi_sas_debugfs_iost_fops = {
3089 	.open = hisi_sas_debugfs_iost_open,
3090 	.read = seq_read,
3091 	.llseek = seq_lseek,
3092 	.release = single_release,
3093 	.owner = THIS_MODULE,
3094 };
3095 
3096 static int hisi_sas_debugfs_iost_cache_show(struct seq_file *s, void *p)
3097 {
3098 	struct hisi_sas_debugfs_iost_cache *debugfs_iost_cache = s->private;
3099 	struct hisi_sas_iost_itct_cache *iost_cache = debugfs_iost_cache->cache;
3100 	u32 cache_size = HISI_SAS_IOST_ITCT_CACHE_DW_SZ * 4;
3101 	int i, tab_idx;
3102 	__le64 *iost;
3103 
3104 	for (i = 0; i < HISI_SAS_IOST_ITCT_CACHE_NUM; i++, iost_cache++) {
3105 		/*
3106 		 * Data struct of IOST cache:
3107 		 * Data[1]: BIT0~15: Table index
3108 		 *	    Bit16:   Valid mask
3109 		 * Data[2]~[9]: IOST table
3110 		 */
3111 		tab_idx = (iost_cache->data[1] & 0xffff);
3112 		iost = (__le64 *)iost_cache;
3113 
3114 		hisi_sas_show_row_64(s, tab_idx, cache_size, iost);
3115 	}
3116 
3117 	return 0;
3118 }
3119 
3120 static int hisi_sas_debugfs_iost_cache_open(struct inode *inode,
3121 					    struct file *filp)
3122 {
3123 	return single_open(filp, hisi_sas_debugfs_iost_cache_show,
3124 			   inode->i_private);
3125 }
3126 
3127 static const struct file_operations hisi_sas_debugfs_iost_cache_fops = {
3128 	.open = hisi_sas_debugfs_iost_cache_open,
3129 	.read = seq_read,
3130 	.llseek = seq_lseek,
3131 	.release = single_release,
3132 	.owner = THIS_MODULE,
3133 };
3134 
3135 static int hisi_sas_debugfs_itct_show(struct seq_file *s, void *p)
3136 {
3137 	int i;
3138 	struct hisi_sas_debugfs_itct *debugfs_itct = s->private;
3139 	struct hisi_sas_itct *itct = debugfs_itct->itct;
3140 
3141 	for (i = 0; i < HISI_SAS_MAX_ITCT_ENTRIES; i++, itct++) {
3142 		__le64 *data = &itct->qw0;
3143 
3144 		hisi_sas_show_row_64(s, i, sizeof(*itct), data);
3145 	}
3146 
3147 	return 0;
3148 }
3149 
3150 static int hisi_sas_debugfs_itct_open(struct inode *inode, struct file *filp)
3151 {
3152 	return single_open(filp, hisi_sas_debugfs_itct_show, inode->i_private);
3153 }
3154 
3155 static const struct file_operations hisi_sas_debugfs_itct_fops = {
3156 	.open = hisi_sas_debugfs_itct_open,
3157 	.read = seq_read,
3158 	.llseek = seq_lseek,
3159 	.release = single_release,
3160 	.owner = THIS_MODULE,
3161 };
3162 
3163 static int hisi_sas_debugfs_itct_cache_show(struct seq_file *s, void *p)
3164 {
3165 	struct hisi_sas_debugfs_itct_cache *debugfs_itct_cache = s->private;
3166 	struct hisi_sas_iost_itct_cache *itct_cache = debugfs_itct_cache->cache;
3167 	u32 cache_size = HISI_SAS_IOST_ITCT_CACHE_DW_SZ * 4;
3168 	int i, tab_idx;
3169 	__le64 *itct;
3170 
3171 	for (i = 0; i < HISI_SAS_IOST_ITCT_CACHE_NUM; i++, itct_cache++) {
3172 		/*
3173 		 * Data struct of ITCT cache:
3174 		 * Data[1]: BIT0~15: Table index
3175 		 *	    Bit16:   Valid mask
3176 		 * Data[2]~[9]: ITCT table
3177 		 */
3178 		tab_idx = itct_cache->data[1] & 0xffff;
3179 		itct = (__le64 *)itct_cache;
3180 
3181 		hisi_sas_show_row_64(s, tab_idx, cache_size, itct);
3182 	}
3183 
3184 	return 0;
3185 }
3186 
3187 static int hisi_sas_debugfs_itct_cache_open(struct inode *inode,
3188 					    struct file *filp)
3189 {
3190 	return single_open(filp, hisi_sas_debugfs_itct_cache_show,
3191 			   inode->i_private);
3192 }
3193 
3194 static const struct file_operations hisi_sas_debugfs_itct_cache_fops = {
3195 	.open = hisi_sas_debugfs_itct_cache_open,
3196 	.read = seq_read,
3197 	.llseek = seq_lseek,
3198 	.release = single_release,
3199 	.owner = THIS_MODULE,
3200 };
3201 
3202 static void hisi_sas_debugfs_create_files(struct hisi_hba *hisi_hba)
3203 {
3204 	u64 *debugfs_timestamp;
3205 	int dump_index = hisi_hba->debugfs_dump_index;
3206 	struct dentry *dump_dentry;
3207 	struct dentry *dentry;
3208 	char name[256];
3209 	int p;
3210 	int c;
3211 	int d;
3212 
3213 	snprintf(name, 256, "%d", dump_index);
3214 
3215 	dump_dentry = debugfs_create_dir(name, hisi_hba->debugfs_dump_dentry);
3216 
3217 	debugfs_timestamp = &hisi_hba->debugfs_timestamp[dump_index];
3218 
3219 	debugfs_create_u64("timestamp", 0400, dump_dentry,
3220 			   debugfs_timestamp);
3221 
3222 	debugfs_create_file("global", 0400, dump_dentry,
3223 			   &hisi_hba->debugfs_regs[dump_index][DEBUGFS_GLOBAL],
3224 			   &hisi_sas_debugfs_global_fops);
3225 
3226 	/* Create port dir and files */
3227 	dentry = debugfs_create_dir("port", dump_dentry);
3228 	for (p = 0; p < hisi_hba->n_phy; p++) {
3229 		snprintf(name, 256, "%d", p);
3230 
3231 		debugfs_create_file(name, 0400, dentry,
3232 				    &hisi_hba->debugfs_port_reg[dump_index][p],
3233 				    &hisi_sas_debugfs_port_fops);
3234 	}
3235 
3236 	/* Create CQ dir and files */
3237 	dentry = debugfs_create_dir("cq", dump_dentry);
3238 	for (c = 0; c < hisi_hba->queue_count; c++) {
3239 		snprintf(name, 256, "%d", c);
3240 
3241 		debugfs_create_file(name, 0400, dentry,
3242 				    &hisi_hba->debugfs_cq[dump_index][c],
3243 				    &hisi_sas_debugfs_cq_fops);
3244 	}
3245 
3246 	/* Create DQ dir and files */
3247 	dentry = debugfs_create_dir("dq", dump_dentry);
3248 	for (d = 0; d < hisi_hba->queue_count; d++) {
3249 		snprintf(name, 256, "%d", d);
3250 
3251 		debugfs_create_file(name, 0400, dentry,
3252 				    &hisi_hba->debugfs_dq[dump_index][d],
3253 				    &hisi_sas_debugfs_dq_fops);
3254 	}
3255 
3256 	debugfs_create_file("iost", 0400, dump_dentry,
3257 			    &hisi_hba->debugfs_iost[dump_index],
3258 			    &hisi_sas_debugfs_iost_fops);
3259 
3260 	debugfs_create_file("iost_cache", 0400, dump_dentry,
3261 			    &hisi_hba->debugfs_iost_cache[dump_index],
3262 			    &hisi_sas_debugfs_iost_cache_fops);
3263 
3264 	debugfs_create_file("itct", 0400, dump_dentry,
3265 			    &hisi_hba->debugfs_itct[dump_index],
3266 			    &hisi_sas_debugfs_itct_fops);
3267 
3268 	debugfs_create_file("itct_cache", 0400, dump_dentry,
3269 			    &hisi_hba->debugfs_itct_cache[dump_index],
3270 			    &hisi_sas_debugfs_itct_cache_fops);
3271 
3272 	debugfs_create_file("axi", 0400, dump_dentry,
3273 			    &hisi_hba->debugfs_regs[dump_index][DEBUGFS_AXI],
3274 			    &hisi_sas_debugfs_axi_fops);
3275 
3276 	debugfs_create_file("ras", 0400, dump_dentry,
3277 			    &hisi_hba->debugfs_regs[dump_index][DEBUGFS_RAS],
3278 			    &hisi_sas_debugfs_ras_fops);
3279 
3280 	return;
3281 }
3282 
3283 static void hisi_sas_debugfs_snapshot_regs(struct hisi_hba *hisi_hba)
3284 {
3285 	hisi_hba->hw->snapshot_prepare(hisi_hba);
3286 
3287 	hisi_sas_debugfs_snapshot_global_reg(hisi_hba);
3288 	hisi_sas_debugfs_snapshot_port_reg(hisi_hba);
3289 	hisi_sas_debugfs_snapshot_axi_reg(hisi_hba);
3290 	hisi_sas_debugfs_snapshot_ras_reg(hisi_hba);
3291 	hisi_sas_debugfs_snapshot_cq_reg(hisi_hba);
3292 	hisi_sas_debugfs_snapshot_dq_reg(hisi_hba);
3293 	hisi_sas_debugfs_snapshot_itct_reg(hisi_hba);
3294 	hisi_sas_debugfs_snapshot_iost_reg(hisi_hba);
3295 
3296 	hisi_sas_debugfs_create_files(hisi_hba);
3297 
3298 	hisi_hba->hw->snapshot_restore(hisi_hba);
3299 }
3300 
3301 static ssize_t hisi_sas_debugfs_trigger_dump_write(struct file *file,
3302 						   const char __user *user_buf,
3303 						   size_t count, loff_t *ppos)
3304 {
3305 	struct hisi_hba *hisi_hba = file->f_inode->i_private;
3306 	char buf[8];
3307 
3308 	if (hisi_hba->debugfs_dump_index >= hisi_sas_debugfs_dump_count)
3309 		return -EFAULT;
3310 
3311 	if (count > 8)
3312 		return -EFAULT;
3313 
3314 	if (copy_from_user(buf, user_buf, count))
3315 		return -EFAULT;
3316 
3317 	if (buf[0] != '1')
3318 		return -EFAULT;
3319 
3320 	queue_work(hisi_hba->wq, &hisi_hba->debugfs_work);
3321 
3322 	return count;
3323 }
3324 
3325 static const struct file_operations hisi_sas_debugfs_trigger_dump_fops = {
3326 	.write = &hisi_sas_debugfs_trigger_dump_write,
3327 	.owner = THIS_MODULE,
3328 };
3329 
3330 enum {
3331 	HISI_SAS_BIST_LOOPBACK_MODE_DIGITAL = 0,
3332 	HISI_SAS_BIST_LOOPBACK_MODE_SERDES,
3333 	HISI_SAS_BIST_LOOPBACK_MODE_REMOTE,
3334 };
3335 
3336 enum {
3337 	HISI_SAS_BIST_CODE_MODE_PRBS7 = 0,
3338 	HISI_SAS_BIST_CODE_MODE_PRBS23,
3339 	HISI_SAS_BIST_CODE_MODE_PRBS31,
3340 	HISI_SAS_BIST_CODE_MODE_JTPAT,
3341 	HISI_SAS_BIST_CODE_MODE_CJTPAT,
3342 	HISI_SAS_BIST_CODE_MODE_SCRAMBED_0,
3343 	HISI_SAS_BIST_CODE_MODE_TRAIN,
3344 	HISI_SAS_BIST_CODE_MODE_TRAIN_DONE,
3345 	HISI_SAS_BIST_CODE_MODE_HFTP,
3346 	HISI_SAS_BIST_CODE_MODE_MFTP,
3347 	HISI_SAS_BIST_CODE_MODE_LFTP,
3348 	HISI_SAS_BIST_CODE_MODE_FIXED_DATA,
3349 };
3350 
3351 static const struct {
3352 	int		value;
3353 	char		*name;
3354 } hisi_sas_debugfs_loop_linkrate[] = {
3355 	{ SAS_LINK_RATE_1_5_GBPS, "1.5 Gbit" },
3356 	{ SAS_LINK_RATE_3_0_GBPS, "3.0 Gbit" },
3357 	{ SAS_LINK_RATE_6_0_GBPS, "6.0 Gbit" },
3358 	{ SAS_LINK_RATE_12_0_GBPS, "12.0 Gbit" },
3359 };
3360 
3361 static int hisi_sas_debugfs_bist_linkrate_show(struct seq_file *s, void *p)
3362 {
3363 	struct hisi_hba *hisi_hba = s->private;
3364 	int i;
3365 
3366 	for (i = 0; i < ARRAY_SIZE(hisi_sas_debugfs_loop_linkrate); i++) {
3367 		int match = (hisi_hba->debugfs_bist_linkrate ==
3368 			     hisi_sas_debugfs_loop_linkrate[i].value);
3369 
3370 		seq_printf(s, "%s%s%s ", match ? "[" : "",
3371 			   hisi_sas_debugfs_loop_linkrate[i].name,
3372 			   match ? "]" : "");
3373 	}
3374 	seq_puts(s, "\n");
3375 
3376 	return 0;
3377 }
3378 
3379 static ssize_t hisi_sas_debugfs_bist_linkrate_write(struct file *filp,
3380 						    const char __user *buf,
3381 						    size_t count, loff_t *ppos)
3382 {
3383 	struct seq_file *m = filp->private_data;
3384 	struct hisi_hba *hisi_hba = m->private;
3385 	char kbuf[16] = {}, *pkbuf;
3386 	bool found = false;
3387 	int i;
3388 
3389 	if (hisi_hba->debugfs_bist_enable)
3390 		return -EPERM;
3391 
3392 	if (count >= sizeof(kbuf))
3393 		return -EOVERFLOW;
3394 
3395 	if (copy_from_user(kbuf, buf, count))
3396 		return -EINVAL;
3397 
3398 	pkbuf = strstrip(kbuf);
3399 
3400 	for (i = 0; i < ARRAY_SIZE(hisi_sas_debugfs_loop_linkrate); i++) {
3401 		if (!strncmp(hisi_sas_debugfs_loop_linkrate[i].name,
3402 			     pkbuf, 16)) {
3403 			hisi_hba->debugfs_bist_linkrate =
3404 				hisi_sas_debugfs_loop_linkrate[i].value;
3405 			found = true;
3406 			break;
3407 		}
3408 	}
3409 
3410 	if (!found)
3411 		return -EINVAL;
3412 
3413 	return count;
3414 }
3415 
3416 static int hisi_sas_debugfs_bist_linkrate_open(struct inode *inode,
3417 					       struct file *filp)
3418 {
3419 	return single_open(filp, hisi_sas_debugfs_bist_linkrate_show,
3420 			   inode->i_private);
3421 }
3422 
3423 static const struct file_operations hisi_sas_debugfs_bist_linkrate_ops = {
3424 	.open = hisi_sas_debugfs_bist_linkrate_open,
3425 	.read = seq_read,
3426 	.write = hisi_sas_debugfs_bist_linkrate_write,
3427 	.llseek = seq_lseek,
3428 	.release = single_release,
3429 	.owner = THIS_MODULE,
3430 };
3431 
3432 static const struct {
3433 	int		value;
3434 	char		*name;
3435 } hisi_sas_debugfs_loop_code_mode[] = {
3436 	{ HISI_SAS_BIST_CODE_MODE_PRBS7, "PRBS7" },
3437 	{ HISI_SAS_BIST_CODE_MODE_PRBS23, "PRBS23" },
3438 	{ HISI_SAS_BIST_CODE_MODE_PRBS31, "PRBS31" },
3439 	{ HISI_SAS_BIST_CODE_MODE_JTPAT, "JTPAT" },
3440 	{ HISI_SAS_BIST_CODE_MODE_CJTPAT, "CJTPAT" },
3441 	{ HISI_SAS_BIST_CODE_MODE_SCRAMBED_0, "SCRAMBED_0" },
3442 	{ HISI_SAS_BIST_CODE_MODE_TRAIN, "TRAIN" },
3443 	{ HISI_SAS_BIST_CODE_MODE_TRAIN_DONE, "TRAIN_DONE" },
3444 	{ HISI_SAS_BIST_CODE_MODE_HFTP, "HFTP" },
3445 	{ HISI_SAS_BIST_CODE_MODE_MFTP, "MFTP" },
3446 	{ HISI_SAS_BIST_CODE_MODE_LFTP, "LFTP" },
3447 	{ HISI_SAS_BIST_CODE_MODE_FIXED_DATA, "FIXED_DATA" },
3448 };
3449 
3450 static int hisi_sas_debugfs_bist_code_mode_show(struct seq_file *s, void *p)
3451 {
3452 	struct hisi_hba *hisi_hba = s->private;
3453 	int i;
3454 
3455 	for (i = 0; i < ARRAY_SIZE(hisi_sas_debugfs_loop_code_mode); i++) {
3456 		int match = (hisi_hba->debugfs_bist_code_mode ==
3457 			     hisi_sas_debugfs_loop_code_mode[i].value);
3458 
3459 		seq_printf(s, "%s%s%s ", match ? "[" : "",
3460 			   hisi_sas_debugfs_loop_code_mode[i].name,
3461 			   match ? "]" : "");
3462 	}
3463 	seq_puts(s, "\n");
3464 
3465 	return 0;
3466 }
3467 
3468 static ssize_t hisi_sas_debugfs_bist_code_mode_write(struct file *filp,
3469 						     const char __user *buf,
3470 						     size_t count,
3471 						     loff_t *ppos)
3472 {
3473 	struct seq_file *m = filp->private_data;
3474 	struct hisi_hba *hisi_hba = m->private;
3475 	char kbuf[16] = {}, *pkbuf;
3476 	bool found = false;
3477 	int i;
3478 
3479 	if (hisi_hba->debugfs_bist_enable)
3480 		return -EPERM;
3481 
3482 	if (count >= sizeof(kbuf))
3483 		return -EINVAL;
3484 
3485 	if (copy_from_user(kbuf, buf, count))
3486 		return -EOVERFLOW;
3487 
3488 	pkbuf = strstrip(kbuf);
3489 
3490 	for (i = 0; i < ARRAY_SIZE(hisi_sas_debugfs_loop_code_mode); i++) {
3491 		if (!strncmp(hisi_sas_debugfs_loop_code_mode[i].name,
3492 			     pkbuf, 16)) {
3493 			hisi_hba->debugfs_bist_code_mode =
3494 				hisi_sas_debugfs_loop_code_mode[i].value;
3495 			found = true;
3496 			break;
3497 		}
3498 	}
3499 
3500 	if (!found)
3501 		return -EINVAL;
3502 
3503 	return count;
3504 }
3505 
3506 static int hisi_sas_debugfs_bist_code_mode_open(struct inode *inode,
3507 						struct file *filp)
3508 {
3509 	return single_open(filp, hisi_sas_debugfs_bist_code_mode_show,
3510 			   inode->i_private);
3511 }
3512 
3513 static const struct file_operations hisi_sas_debugfs_bist_code_mode_ops = {
3514 	.open = hisi_sas_debugfs_bist_code_mode_open,
3515 	.read = seq_read,
3516 	.write = hisi_sas_debugfs_bist_code_mode_write,
3517 	.llseek = seq_lseek,
3518 	.release = single_release,
3519 	.owner = THIS_MODULE,
3520 };
3521 
3522 static ssize_t hisi_sas_debugfs_bist_phy_write(struct file *filp,
3523 					       const char __user *buf,
3524 					       size_t count, loff_t *ppos)
3525 {
3526 	struct seq_file *m = filp->private_data;
3527 	struct hisi_hba *hisi_hba = m->private;
3528 	unsigned int phy_no;
3529 	int val;
3530 
3531 	if (hisi_hba->debugfs_bist_enable)
3532 		return -EPERM;
3533 
3534 	val = kstrtouint_from_user(buf, count, 0, &phy_no);
3535 	if (val)
3536 		return val;
3537 
3538 	if (phy_no >= hisi_hba->n_phy)
3539 		return -EINVAL;
3540 
3541 	hisi_hba->debugfs_bist_phy_no = phy_no;
3542 
3543 	return count;
3544 }
3545 
3546 static int hisi_sas_debugfs_bist_phy_show(struct seq_file *s, void *p)
3547 {
3548 	struct hisi_hba *hisi_hba = s->private;
3549 
3550 	seq_printf(s, "%d\n", hisi_hba->debugfs_bist_phy_no);
3551 
3552 	return 0;
3553 }
3554 
3555 static int hisi_sas_debugfs_bist_phy_open(struct inode *inode,
3556 					  struct file *filp)
3557 {
3558 	return single_open(filp, hisi_sas_debugfs_bist_phy_show,
3559 			   inode->i_private);
3560 }
3561 
3562 static const struct file_operations hisi_sas_debugfs_bist_phy_ops = {
3563 	.open = hisi_sas_debugfs_bist_phy_open,
3564 	.read = seq_read,
3565 	.write = hisi_sas_debugfs_bist_phy_write,
3566 	.llseek = seq_lseek,
3567 	.release = single_release,
3568 	.owner = THIS_MODULE,
3569 };
3570 
3571 static const struct {
3572 	int		value;
3573 	char		*name;
3574 } hisi_sas_debugfs_loop_modes[] = {
3575 	{ HISI_SAS_BIST_LOOPBACK_MODE_DIGITAL, "digital" },
3576 	{ HISI_SAS_BIST_LOOPBACK_MODE_SERDES, "serdes" },
3577 	{ HISI_SAS_BIST_LOOPBACK_MODE_REMOTE, "remote" },
3578 };
3579 
3580 static int hisi_sas_debugfs_bist_mode_show(struct seq_file *s, void *p)
3581 {
3582 	struct hisi_hba *hisi_hba = s->private;
3583 	int i;
3584 
3585 	for (i = 0; i < ARRAY_SIZE(hisi_sas_debugfs_loop_modes); i++) {
3586 		int match = (hisi_hba->debugfs_bist_mode ==
3587 			     hisi_sas_debugfs_loop_modes[i].value);
3588 
3589 		seq_printf(s, "%s%s%s ", match ? "[" : "",
3590 			   hisi_sas_debugfs_loop_modes[i].name,
3591 			   match ? "]" : "");
3592 	}
3593 	seq_puts(s, "\n");
3594 
3595 	return 0;
3596 }
3597 
3598 static ssize_t hisi_sas_debugfs_bist_mode_write(struct file *filp,
3599 						const char __user *buf,
3600 						size_t count, loff_t *ppos)
3601 {
3602 	struct seq_file *m = filp->private_data;
3603 	struct hisi_hba *hisi_hba = m->private;
3604 	char kbuf[16] = {}, *pkbuf;
3605 	bool found = false;
3606 	int i;
3607 
3608 	if (hisi_hba->debugfs_bist_enable)
3609 		return -EPERM;
3610 
3611 	if (count >= sizeof(kbuf))
3612 		return -EINVAL;
3613 
3614 	if (copy_from_user(kbuf, buf, count))
3615 		return -EOVERFLOW;
3616 
3617 	pkbuf = strstrip(kbuf);
3618 
3619 	for (i = 0; i < ARRAY_SIZE(hisi_sas_debugfs_loop_modes); i++) {
3620 		if (!strncmp(hisi_sas_debugfs_loop_modes[i].name, pkbuf, 16)) {
3621 			hisi_hba->debugfs_bist_mode =
3622 				hisi_sas_debugfs_loop_modes[i].value;
3623 			found = true;
3624 			break;
3625 		}
3626 	}
3627 
3628 	if (!found)
3629 		return -EINVAL;
3630 
3631 	return count;
3632 }
3633 
3634 static int hisi_sas_debugfs_bist_mode_open(struct inode *inode,
3635 					   struct file *filp)
3636 {
3637 	return single_open(filp, hisi_sas_debugfs_bist_mode_show,
3638 			   inode->i_private);
3639 }
3640 
3641 static const struct file_operations hisi_sas_debugfs_bist_mode_ops = {
3642 	.open = hisi_sas_debugfs_bist_mode_open,
3643 	.read = seq_read,
3644 	.write = hisi_sas_debugfs_bist_mode_write,
3645 	.llseek = seq_lseek,
3646 	.release = single_release,
3647 	.owner = THIS_MODULE,
3648 };
3649 
3650 static ssize_t hisi_sas_debugfs_bist_enable_write(struct file *filp,
3651 						  const char __user *buf,
3652 						  size_t count, loff_t *ppos)
3653 {
3654 	struct seq_file *m = filp->private_data;
3655 	struct hisi_hba *hisi_hba = m->private;
3656 	unsigned int enable;
3657 	int val;
3658 
3659 	val = kstrtouint_from_user(buf, count, 0, &enable);
3660 	if (val)
3661 		return val;
3662 
3663 	if (enable > 1)
3664 		return -EINVAL;
3665 
3666 	if (enable == hisi_hba->debugfs_bist_enable)
3667 		return count;
3668 
3669 	if (!hisi_hba->hw->set_bist)
3670 		return -EPERM;
3671 
3672 	val = hisi_hba->hw->set_bist(hisi_hba, enable);
3673 	if (val < 0)
3674 		return val;
3675 
3676 	hisi_hba->debugfs_bist_enable = enable;
3677 
3678 	return count;
3679 }
3680 
3681 static int hisi_sas_debugfs_bist_enable_show(struct seq_file *s, void *p)
3682 {
3683 	struct hisi_hba *hisi_hba = s->private;
3684 
3685 	seq_printf(s, "%d\n", hisi_hba->debugfs_bist_enable);
3686 
3687 	return 0;
3688 }
3689 
3690 static int hisi_sas_debugfs_bist_enable_open(struct inode *inode,
3691 					     struct file *filp)
3692 {
3693 	return single_open(filp, hisi_sas_debugfs_bist_enable_show,
3694 			   inode->i_private);
3695 }
3696 
3697 static const struct file_operations hisi_sas_debugfs_bist_enable_ops = {
3698 	.open = hisi_sas_debugfs_bist_enable_open,
3699 	.read = seq_read,
3700 	.write = hisi_sas_debugfs_bist_enable_write,
3701 	.llseek = seq_lseek,
3702 	.release = single_release,
3703 	.owner = THIS_MODULE,
3704 };
3705 
3706 static ssize_t hisi_sas_debugfs_phy_down_cnt_write(struct file *filp,
3707 						   const char __user *buf,
3708 						   size_t count, loff_t *ppos)
3709 {
3710 	struct seq_file *s = filp->private_data;
3711 	struct hisi_sas_phy *phy = s->private;
3712 	unsigned int set_val;
3713 	int res;
3714 
3715 	res = kstrtouint_from_user(buf, count, 0, &set_val);
3716 	if (res)
3717 		return res;
3718 
3719 	if (set_val > 0)
3720 		return -EINVAL;
3721 
3722 	atomic_set(&phy->down_cnt, 0);
3723 
3724 	return count;
3725 }
3726 
3727 static int hisi_sas_debugfs_phy_down_cnt_show(struct seq_file *s, void *p)
3728 {
3729 	struct hisi_sas_phy *phy = s->private;
3730 
3731 	seq_printf(s, "%d\n", atomic_read(&phy->down_cnt));
3732 
3733 	return 0;
3734 }
3735 
3736 static int hisi_sas_debugfs_phy_down_cnt_open(struct inode *inode,
3737 					      struct file *filp)
3738 {
3739 	return single_open(filp, hisi_sas_debugfs_phy_down_cnt_show,
3740 			   inode->i_private);
3741 }
3742 
3743 static const struct file_operations hisi_sas_debugfs_phy_down_cnt_ops = {
3744 	.open = hisi_sas_debugfs_phy_down_cnt_open,
3745 	.read = seq_read,
3746 	.write = hisi_sas_debugfs_phy_down_cnt_write,
3747 	.llseek = seq_lseek,
3748 	.release = single_release,
3749 	.owner = THIS_MODULE,
3750 };
3751 
3752 void hisi_sas_debugfs_work_handler(struct work_struct *work)
3753 {
3754 	struct hisi_hba *hisi_hba =
3755 		container_of(work, struct hisi_hba, debugfs_work);
3756 	int debugfs_dump_index = hisi_hba->debugfs_dump_index;
3757 	struct device *dev = hisi_hba->dev;
3758 	u64 timestamp = local_clock();
3759 
3760 	if (debugfs_dump_index >= hisi_sas_debugfs_dump_count) {
3761 		dev_warn(dev, "dump count exceeded!\n");
3762 		return;
3763 	}
3764 
3765 	do_div(timestamp, NSEC_PER_MSEC);
3766 	hisi_hba->debugfs_timestamp[debugfs_dump_index] = timestamp;
3767 
3768 	hisi_sas_debugfs_snapshot_regs(hisi_hba);
3769 	hisi_hba->debugfs_dump_index++;
3770 }
3771 EXPORT_SYMBOL_GPL(hisi_sas_debugfs_work_handler);
3772 
3773 static void hisi_sas_debugfs_release(struct hisi_hba *hisi_hba, int dump_index)
3774 {
3775 	struct device *dev = hisi_hba->dev;
3776 	int i;
3777 
3778 	devm_kfree(dev, hisi_hba->debugfs_iost_cache[dump_index].cache);
3779 	devm_kfree(dev, hisi_hba->debugfs_itct_cache[dump_index].cache);
3780 	devm_kfree(dev, hisi_hba->debugfs_iost[dump_index].iost);
3781 	devm_kfree(dev, hisi_hba->debugfs_itct[dump_index].itct);
3782 
3783 	for (i = 0; i < hisi_hba->queue_count; i++)
3784 		devm_kfree(dev, hisi_hba->debugfs_dq[dump_index][i].hdr);
3785 
3786 	for (i = 0; i < hisi_hba->queue_count; i++)
3787 		devm_kfree(dev,
3788 			   hisi_hba->debugfs_cq[dump_index][i].complete_hdr);
3789 
3790 	for (i = 0; i < DEBUGFS_REGS_NUM; i++)
3791 		devm_kfree(dev, hisi_hba->debugfs_regs[dump_index][i].data);
3792 
3793 	for (i = 0; i < hisi_hba->n_phy; i++)
3794 		devm_kfree(dev, hisi_hba->debugfs_port_reg[dump_index][i].data);
3795 }
3796 
3797 static int hisi_sas_debugfs_alloc(struct hisi_hba *hisi_hba, int dump_index)
3798 {
3799 	const struct hisi_sas_hw *hw = hisi_hba->hw;
3800 	struct device *dev = hisi_hba->dev;
3801 	int p, c, d, r, i;
3802 	size_t sz;
3803 
3804 	for (r = 0; r < DEBUGFS_REGS_NUM; r++) {
3805 		struct hisi_sas_debugfs_regs *regs =
3806 				&hisi_hba->debugfs_regs[dump_index][r];
3807 
3808 		sz = hw->debugfs_reg_array[r]->count * 4;
3809 		regs->data = devm_kmalloc(dev, sz, GFP_KERNEL);
3810 		if (!regs->data)
3811 			goto fail;
3812 		regs->hisi_hba = hisi_hba;
3813 	}
3814 
3815 	sz = hw->debugfs_reg_port->count * 4;
3816 	for (p = 0; p < hisi_hba->n_phy; p++) {
3817 		struct hisi_sas_debugfs_port *port =
3818 				&hisi_hba->debugfs_port_reg[dump_index][p];
3819 
3820 		port->data = devm_kmalloc(dev, sz, GFP_KERNEL);
3821 		if (!port->data)
3822 			goto fail;
3823 		port->phy = &hisi_hba->phy[p];
3824 	}
3825 
3826 	sz = hw->complete_hdr_size * HISI_SAS_QUEUE_SLOTS;
3827 	for (c = 0; c < hisi_hba->queue_count; c++) {
3828 		struct hisi_sas_debugfs_cq *cq =
3829 				&hisi_hba->debugfs_cq[dump_index][c];
3830 
3831 		cq->complete_hdr = devm_kmalloc(dev, sz, GFP_KERNEL);
3832 		if (!cq->complete_hdr)
3833 			goto fail;
3834 		cq->cq = &hisi_hba->cq[c];
3835 	}
3836 
3837 	sz = sizeof(struct hisi_sas_cmd_hdr) * HISI_SAS_QUEUE_SLOTS;
3838 	for (d = 0; d < hisi_hba->queue_count; d++) {
3839 		struct hisi_sas_debugfs_dq *dq =
3840 				&hisi_hba->debugfs_dq[dump_index][d];
3841 
3842 		dq->hdr = devm_kmalloc(dev, sz, GFP_KERNEL);
3843 		if (!dq->hdr)
3844 			goto fail;
3845 		dq->dq = &hisi_hba->dq[d];
3846 	}
3847 
3848 	sz = HISI_SAS_MAX_COMMANDS * sizeof(struct hisi_sas_iost);
3849 
3850 	hisi_hba->debugfs_iost[dump_index].iost =
3851 				devm_kmalloc(dev, sz, GFP_KERNEL);
3852 	if (!hisi_hba->debugfs_iost[dump_index].iost)
3853 		goto fail;
3854 
3855 	sz = HISI_SAS_IOST_ITCT_CACHE_NUM *
3856 	     sizeof(struct hisi_sas_iost_itct_cache);
3857 
3858 	hisi_hba->debugfs_iost_cache[dump_index].cache =
3859 				devm_kmalloc(dev, sz, GFP_KERNEL);
3860 	if (!hisi_hba->debugfs_iost_cache[dump_index].cache)
3861 		goto fail;
3862 
3863 	sz = HISI_SAS_IOST_ITCT_CACHE_NUM *
3864 	     sizeof(struct hisi_sas_iost_itct_cache);
3865 
3866 	hisi_hba->debugfs_itct_cache[dump_index].cache =
3867 				devm_kmalloc(dev, sz, GFP_KERNEL);
3868 	if (!hisi_hba->debugfs_itct_cache[dump_index].cache)
3869 		goto fail;
3870 
3871 	/* New memory allocation must be locate before itct */
3872 	sz = HISI_SAS_MAX_ITCT_ENTRIES * sizeof(struct hisi_sas_itct);
3873 
3874 	hisi_hba->debugfs_itct[dump_index].itct =
3875 				devm_kmalloc(dev, sz, GFP_KERNEL);
3876 	if (!hisi_hba->debugfs_itct[dump_index].itct)
3877 		goto fail;
3878 
3879 	return 0;
3880 fail:
3881 	for (i = 0; i < hisi_sas_debugfs_dump_count; i++)
3882 		hisi_sas_debugfs_release(hisi_hba, i);
3883 	return -ENOMEM;
3884 }
3885 
3886 static void hisi_sas_debugfs_phy_down_cnt_init(struct hisi_hba *hisi_hba)
3887 {
3888 	struct dentry *dir = debugfs_create_dir("phy_down_cnt",
3889 						hisi_hba->debugfs_dir);
3890 	char name[16];
3891 	int phy_no;
3892 
3893 	for (phy_no = 0; phy_no < hisi_hba->n_phy; phy_no++) {
3894 		snprintf(name, 16, "%d", phy_no);
3895 		debugfs_create_file(name, 0600, dir,
3896 				    &hisi_hba->phy[phy_no],
3897 				    &hisi_sas_debugfs_phy_down_cnt_ops);
3898 	}
3899 }
3900 
3901 static void hisi_sas_debugfs_bist_init(struct hisi_hba *hisi_hba)
3902 {
3903 	hisi_hba->debugfs_bist_dentry =
3904 			debugfs_create_dir("bist", hisi_hba->debugfs_dir);
3905 	debugfs_create_file("link_rate", 0600,
3906 			    hisi_hba->debugfs_bist_dentry, hisi_hba,
3907 			    &hisi_sas_debugfs_bist_linkrate_ops);
3908 
3909 	debugfs_create_file("code_mode", 0600,
3910 			    hisi_hba->debugfs_bist_dentry, hisi_hba,
3911 			    &hisi_sas_debugfs_bist_code_mode_ops);
3912 
3913 	debugfs_create_file("phy_id", 0600, hisi_hba->debugfs_bist_dentry,
3914 			    hisi_hba, &hisi_sas_debugfs_bist_phy_ops);
3915 
3916 	debugfs_create_u32("cnt", 0600, hisi_hba->debugfs_bist_dentry,
3917 			   &hisi_hba->debugfs_bist_cnt);
3918 
3919 	debugfs_create_file("loopback_mode", 0600,
3920 			    hisi_hba->debugfs_bist_dentry,
3921 			    hisi_hba, &hisi_sas_debugfs_bist_mode_ops);
3922 
3923 	debugfs_create_file("enable", 0600, hisi_hba->debugfs_bist_dentry,
3924 			    hisi_hba, &hisi_sas_debugfs_bist_enable_ops);
3925 
3926 	hisi_hba->debugfs_bist_linkrate = SAS_LINK_RATE_1_5_GBPS;
3927 }
3928 
3929 void hisi_sas_debugfs_init(struct hisi_hba *hisi_hba)
3930 {
3931 	struct device *dev = hisi_hba->dev;
3932 	int i;
3933 
3934 	hisi_hba->debugfs_dir = debugfs_create_dir(dev_name(dev),
3935 						   hisi_sas_debugfs_dir);
3936 	debugfs_create_file("trigger_dump", 0200,
3937 			    hisi_hba->debugfs_dir,
3938 			    hisi_hba,
3939 			    &hisi_sas_debugfs_trigger_dump_fops);
3940 
3941 	/* create bist structures */
3942 	hisi_sas_debugfs_bist_init(hisi_hba);
3943 
3944 	hisi_hba->debugfs_dump_dentry =
3945 			debugfs_create_dir("dump", hisi_hba->debugfs_dir);
3946 
3947 	hisi_sas_debugfs_phy_down_cnt_init(hisi_hba);
3948 
3949 	for (i = 0; i < hisi_sas_debugfs_dump_count; i++) {
3950 		if (hisi_sas_debugfs_alloc(hisi_hba, i)) {
3951 			debugfs_remove_recursive(hisi_hba->debugfs_dir);
3952 			dev_dbg(dev, "failed to init debugfs!\n");
3953 			break;
3954 		}
3955 	}
3956 }
3957 EXPORT_SYMBOL_GPL(hisi_sas_debugfs_init);
3958 
3959 void hisi_sas_debugfs_exit(struct hisi_hba *hisi_hba)
3960 {
3961 	debugfs_remove_recursive(hisi_hba->debugfs_dir);
3962 }
3963 EXPORT_SYMBOL_GPL(hisi_sas_debugfs_exit);
3964 
3965 int hisi_sas_remove(struct platform_device *pdev)
3966 {
3967 	struct sas_ha_struct *sha = platform_get_drvdata(pdev);
3968 	struct hisi_hba *hisi_hba = sha->lldd_ha;
3969 	struct Scsi_Host *shost = sha->core.shost;
3970 
3971 	if (timer_pending(&hisi_hba->timer))
3972 		del_timer(&hisi_hba->timer);
3973 
3974 	sas_unregister_ha(sha);
3975 	sas_remove_host(sha->core.shost);
3976 
3977 	hisi_sas_free(hisi_hba);
3978 	scsi_host_put(shost);
3979 	return 0;
3980 }
3981 EXPORT_SYMBOL_GPL(hisi_sas_remove);
3982 
3983 bool hisi_sas_debugfs_enable;
3984 EXPORT_SYMBOL_GPL(hisi_sas_debugfs_enable);
3985 module_param_named(debugfs_enable, hisi_sas_debugfs_enable, bool, 0444);
3986 MODULE_PARM_DESC(hisi_sas_debugfs_enable, "Enable driver debugfs (default disabled)");
3987 
3988 u32 hisi_sas_debugfs_dump_count = 1;
3989 EXPORT_SYMBOL_GPL(hisi_sas_debugfs_dump_count);
3990 module_param_named(debugfs_dump_count, hisi_sas_debugfs_dump_count, uint, 0444);
3991 MODULE_PARM_DESC(hisi_sas_debugfs_dump_count, "Number of debugfs dumps to allow");
3992 
3993 static __init int hisi_sas_init(void)
3994 {
3995 	hisi_sas_stt = sas_domain_attach_transport(&hisi_sas_transport_ops);
3996 	if (!hisi_sas_stt)
3997 		return -ENOMEM;
3998 
3999 	if (hisi_sas_debugfs_enable) {
4000 		hisi_sas_debugfs_dir = debugfs_create_dir("hisi_sas", NULL);
4001 		if (hisi_sas_debugfs_dump_count > HISI_SAS_MAX_DEBUGFS_DUMP) {
4002 			pr_info("hisi_sas: Limiting debugfs dump count\n");
4003 			hisi_sas_debugfs_dump_count = HISI_SAS_MAX_DEBUGFS_DUMP;
4004 		}
4005 	}
4006 
4007 	return 0;
4008 }
4009 
4010 static __exit void hisi_sas_exit(void)
4011 {
4012 	sas_release_transport(hisi_sas_stt);
4013 
4014 	debugfs_remove(hisi_sas_debugfs_dir);
4015 }
4016 
4017 module_init(hisi_sas_init);
4018 module_exit(hisi_sas_exit);
4019 
4020 MODULE_LICENSE("GPL");
4021 MODULE_AUTHOR("John Garry <john.garry@huawei.com>");
4022 MODULE_DESCRIPTION("HISILICON SAS controller driver");
4023 MODULE_ALIAS("platform:" DRV_NAME);
4024