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