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