?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
signal: Document glibc's si_code of SI_ASYNCNL
[cris-mirror.git] / drivers / scsi / hisi_sas / hisi_sas_main.c
blob5f503cb095085d2baa7e2f24248419dbbb432e29
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);
CRIS linux kernel tree