2015-11-18 00:50:30 +08:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2015 Linaro Ltd.
|
|
|
|
* Copyright (c) 2015 Hisilicon Limited.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "hisi_sas.h"
|
|
|
|
#define DRV_NAME "hisi_sas"
|
|
|
|
|
2015-11-18 00:50:49 +08:00
|
|
|
#define DEV_IS_GONE(dev) \
|
|
|
|
((!dev) || (dev->dev_type == SAS_PHY_UNUSED))
|
|
|
|
|
2016-02-25 17:42:11 +08:00
|
|
|
static int hisi_sas_debug_issue_ssp_tmf(struct domain_device *device,
|
|
|
|
u8 *lun, struct hisi_sas_tmf_task *tmf);
|
2016-08-24 19:05:47 +08:00
|
|
|
static int
|
|
|
|
hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
|
|
|
|
struct domain_device *device,
|
|
|
|
int abort_flag, int tag);
|
2017-03-23 01:25:20 +08:00
|
|
|
static int hisi_sas_softreset_ata_disk(struct domain_device *device);
|
2017-12-09 01:16:45 +08:00
|
|
|
static int hisi_sas_control_phy(struct asd_sas_phy *sas_phy, enum phy_func func,
|
|
|
|
void *funcdata);
|
2018-05-21 18:09:17 +08:00
|
|
|
static void hisi_sas_release_task(struct hisi_hba *hisi_hba,
|
|
|
|
struct domain_device *device);
|
|
|
|
static void hisi_sas_dev_gone(struct domain_device *device);
|
2016-02-25 17:42:11 +08:00
|
|
|
|
2017-12-28 18:20:47 +08:00
|
|
|
u8 hisi_sas_get_ata_protocol(struct host_to_dev_fis *fis, int direction)
|
2017-06-14 23:33:14 +08:00
|
|
|
{
|
2017-12-28 18:20:47 +08:00
|
|
|
switch (fis->command) {
|
2017-06-14 23:33:14 +08:00
|
|
|
case ATA_CMD_FPDMA_WRITE:
|
|
|
|
case ATA_CMD_FPDMA_READ:
|
|
|
|
case ATA_CMD_FPDMA_RECV:
|
|
|
|
case ATA_CMD_FPDMA_SEND:
|
|
|
|
case ATA_CMD_NCQ_NON_DATA:
|
2018-03-07 20:25:12 +08:00
|
|
|
return HISI_SAS_SATA_PROTOCOL_FPDMA;
|
2017-06-14 23:33:14 +08:00
|
|
|
|
|
|
|
case ATA_CMD_DOWNLOAD_MICRO:
|
|
|
|
case ATA_CMD_ID_ATA:
|
|
|
|
case ATA_CMD_PMP_READ:
|
|
|
|
case ATA_CMD_READ_LOG_EXT:
|
|
|
|
case ATA_CMD_PIO_READ:
|
|
|
|
case ATA_CMD_PIO_READ_EXT:
|
|
|
|
case ATA_CMD_PMP_WRITE:
|
|
|
|
case ATA_CMD_WRITE_LOG_EXT:
|
|
|
|
case ATA_CMD_PIO_WRITE:
|
|
|
|
case ATA_CMD_PIO_WRITE_EXT:
|
2018-03-07 20:25:12 +08:00
|
|
|
return HISI_SAS_SATA_PROTOCOL_PIO;
|
2017-06-14 23:33:14 +08:00
|
|
|
|
|
|
|
case ATA_CMD_DSM:
|
|
|
|
case ATA_CMD_DOWNLOAD_MICRO_DMA:
|
|
|
|
case ATA_CMD_PMP_READ_DMA:
|
|
|
|
case ATA_CMD_PMP_WRITE_DMA:
|
|
|
|
case ATA_CMD_READ:
|
|
|
|
case ATA_CMD_READ_EXT:
|
|
|
|
case ATA_CMD_READ_LOG_DMA_EXT:
|
|
|
|
case ATA_CMD_READ_STREAM_DMA_EXT:
|
|
|
|
case ATA_CMD_TRUSTED_RCV_DMA:
|
|
|
|
case ATA_CMD_TRUSTED_SND_DMA:
|
|
|
|
case ATA_CMD_WRITE:
|
|
|
|
case ATA_CMD_WRITE_EXT:
|
|
|
|
case ATA_CMD_WRITE_FUA_EXT:
|
|
|
|
case ATA_CMD_WRITE_QUEUED:
|
|
|
|
case ATA_CMD_WRITE_LOG_DMA_EXT:
|
|
|
|
case ATA_CMD_WRITE_STREAM_DMA_EXT:
|
2017-08-11 00:09:34 +08:00
|
|
|
case ATA_CMD_ZAC_MGMT_IN:
|
2018-03-07 20:25:12 +08:00
|
|
|
return HISI_SAS_SATA_PROTOCOL_DMA;
|
2017-06-14 23:33:14 +08:00
|
|
|
|
|
|
|
case ATA_CMD_CHK_POWER:
|
|
|
|
case ATA_CMD_DEV_RESET:
|
|
|
|
case ATA_CMD_EDD:
|
|
|
|
case ATA_CMD_FLUSH:
|
|
|
|
case ATA_CMD_FLUSH_EXT:
|
|
|
|
case ATA_CMD_VERIFY:
|
|
|
|
case ATA_CMD_VERIFY_EXT:
|
|
|
|
case ATA_CMD_SET_FEATURES:
|
|
|
|
case ATA_CMD_STANDBY:
|
|
|
|
case ATA_CMD_STANDBYNOW1:
|
2017-08-11 00:09:34 +08:00
|
|
|
case ATA_CMD_ZAC_MGMT_OUT:
|
2018-03-07 20:25:12 +08:00
|
|
|
return HISI_SAS_SATA_PROTOCOL_NONDATA;
|
2017-12-28 18:20:47 +08:00
|
|
|
|
2018-03-24 00:05:12 +08:00
|
|
|
case ATA_CMD_SET_MAX:
|
|
|
|
switch (fis->features) {
|
|
|
|
case ATA_SET_MAX_PASSWD:
|
|
|
|
case ATA_SET_MAX_LOCK:
|
|
|
|
return HISI_SAS_SATA_PROTOCOL_PIO;
|
2017-12-28 18:20:47 +08:00
|
|
|
|
2018-03-24 00:05:12 +08:00
|
|
|
case ATA_SET_MAX_PASSWD_DMA:
|
|
|
|
case ATA_SET_MAX_UNLOCK_DMA:
|
|
|
|
return HISI_SAS_SATA_PROTOCOL_DMA;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return HISI_SAS_SATA_PROTOCOL_NONDATA;
|
2017-12-28 18:20:47 +08:00
|
|
|
}
|
2018-03-24 00:05:12 +08:00
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2017-06-14 23:33:14 +08:00
|
|
|
if (direction == DMA_NONE)
|
|
|
|
return HISI_SAS_SATA_PROTOCOL_NONDATA;
|
|
|
|
return HISI_SAS_SATA_PROTOCOL_PIO;
|
|
|
|
}
|
2017-12-28 18:20:47 +08:00
|
|
|
}
|
2017-06-14 23:33:14 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_get_ata_protocol);
|
|
|
|
|
2017-06-14 23:33:15 +08:00
|
|
|
void hisi_sas_sata_done(struct sas_task *task,
|
|
|
|
struct hisi_sas_slot *slot)
|
|
|
|
{
|
|
|
|
struct task_status_struct *ts = &task->task_status;
|
|
|
|
struct ata_task_resp *resp = (struct ata_task_resp *)ts->buf;
|
2017-06-29 21:02:14 +08:00
|
|
|
struct hisi_sas_status_buffer *status_buf =
|
|
|
|
hisi_sas_status_buf_addr_mem(slot);
|
|
|
|
u8 *iu = &status_buf->iu[0];
|
|
|
|
struct dev_to_host_fis *d2h = (struct dev_to_host_fis *)iu;
|
2017-06-14 23:33:15 +08:00
|
|
|
|
|
|
|
resp->frame_len = sizeof(struct dev_to_host_fis);
|
|
|
|
memcpy(&resp->ending_fis[0], d2h, sizeof(struct dev_to_host_fis));
|
|
|
|
|
|
|
|
ts->buf_valid_size = sizeof(*resp);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_sata_done);
|
|
|
|
|
2017-06-14 23:33:16 +08:00
|
|
|
int hisi_sas_get_ncq_tag(struct sas_task *task, u32 *tag)
|
|
|
|
{
|
|
|
|
struct ata_queued_cmd *qc = task->uldd_task;
|
|
|
|
|
|
|
|
if (qc) {
|
|
|
|
if (qc->tf.command == ATA_CMD_FPDMA_WRITE ||
|
|
|
|
qc->tf.command == ATA_CMD_FPDMA_READ) {
|
|
|
|
*tag = qc->tag;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_get_ncq_tag);
|
|
|
|
|
2018-05-02 23:56:30 +08:00
|
|
|
/*
|
|
|
|
* This function assumes linkrate mask fits in 8 bits, which it
|
|
|
|
* does for all HW versions supported.
|
|
|
|
*/
|
|
|
|
u8 hisi_sas_get_prog_phy_linkrate_mask(enum sas_linkrate max)
|
|
|
|
{
|
|
|
|
u16 rate = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
max -= SAS_LINK_RATE_1_5_GBPS;
|
|
|
|
for (i = 0; i <= max; i++)
|
|
|
|
rate |= 1 << (i * 2);
|
|
|
|
return rate;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_get_prog_phy_linkrate_mask);
|
|
|
|
|
2015-11-18 00:50:49 +08:00
|
|
|
static struct hisi_hba *dev_to_hisi_hba(struct domain_device *device)
|
|
|
|
{
|
|
|
|
return device->port->ha->lldd_ha;
|
|
|
|
}
|
|
|
|
|
2017-03-23 01:25:17 +08:00
|
|
|
struct hisi_sas_port *to_hisi_sas_port(struct asd_sas_port *sas_port)
|
|
|
|
{
|
|
|
|
return container_of(sas_port, struct hisi_sas_port, sas_port);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(to_hisi_sas_port);
|
|
|
|
|
2017-08-11 00:09:40 +08:00
|
|
|
void hisi_sas_stop_phys(struct hisi_hba *hisi_hba)
|
|
|
|
{
|
|
|
|
int phy_no;
|
|
|
|
|
|
|
|
for (phy_no = 0; phy_no < hisi_hba->n_phy; phy_no++)
|
|
|
|
hisi_hba->hw->phy_disable(hisi_hba, phy_no);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_stop_phys);
|
|
|
|
|
2015-11-18 00:50:36 +08:00
|
|
|
static void hisi_sas_slot_index_clear(struct hisi_hba *hisi_hba, int slot_idx)
|
|
|
|
{
|
|
|
|
void *bitmap = hisi_hba->slot_index_tags;
|
|
|
|
|
|
|
|
clear_bit(slot_idx, bitmap);
|
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:49 +08:00
|
|
|
static void hisi_sas_slot_index_free(struct hisi_hba *hisi_hba, int slot_idx)
|
|
|
|
{
|
2018-09-24 23:06:33 +08:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (hisi_hba->hw->slot_index_alloc || (slot_idx >=
|
|
|
|
hisi_hba->hw->max_command_entries - HISI_SAS_RESERVED_IPTT_CNT)) {
|
|
|
|
spin_lock_irqsave(&hisi_hba->lock, flags);
|
|
|
|
hisi_sas_slot_index_clear(hisi_hba, slot_idx);
|
|
|
|
spin_unlock_irqrestore(&hisi_hba->lock, flags);
|
|
|
|
}
|
2015-11-18 00:50:49 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hisi_sas_slot_index_set(struct hisi_hba *hisi_hba, int slot_idx)
|
|
|
|
{
|
|
|
|
void *bitmap = hisi_hba->slot_index_tags;
|
|
|
|
|
|
|
|
set_bit(slot_idx, bitmap);
|
|
|
|
}
|
|
|
|
|
2018-09-24 23:06:33 +08:00
|
|
|
static int hisi_sas_slot_index_alloc(struct hisi_hba *hisi_hba,
|
|
|
|
struct scsi_cmnd *scsi_cmnd)
|
2015-11-18 00:50:49 +08:00
|
|
|
{
|
2018-09-24 23:06:33 +08:00
|
|
|
int index;
|
2015-11-18 00:50:49 +08:00
|
|
|
void *bitmap = hisi_hba->slot_index_tags;
|
2018-09-24 23:06:33 +08:00
|
|
|
unsigned long flags;
|
2015-11-18 00:50:49 +08:00
|
|
|
|
2018-09-24 23:06:33 +08:00
|
|
|
if (scsi_cmnd)
|
|
|
|
return scsi_cmnd->request->tag;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&hisi_hba->lock, flags);
|
2018-05-21 18:09:14 +08:00
|
|
|
index = find_next_zero_bit(bitmap, hisi_hba->slot_index_count,
|
2018-09-24 23:06:33 +08:00
|
|
|
hisi_hba->last_slot_index + 1);
|
2018-05-21 18:09:14 +08:00
|
|
|
if (index >= hisi_hba->slot_index_count) {
|
2018-09-24 23:06:33 +08:00
|
|
|
index = find_next_zero_bit(bitmap,
|
|
|
|
hisi_hba->slot_index_count,
|
|
|
|
hisi_hba->hw->max_command_entries -
|
|
|
|
HISI_SAS_RESERVED_IPTT_CNT);
|
|
|
|
if (index >= hisi_hba->slot_index_count) {
|
|
|
|
spin_unlock_irqrestore(&hisi_hba->lock, flags);
|
2018-05-21 18:09:14 +08:00
|
|
|
return -SAS_QUEUE_FULL;
|
2018-09-24 23:06:33 +08:00
|
|
|
}
|
2018-05-21 18:09:14 +08:00
|
|
|
}
|
2015-11-18 00:50:49 +08:00
|
|
|
hisi_sas_slot_index_set(hisi_hba, index);
|
2018-05-21 18:09:14 +08:00
|
|
|
hisi_hba->last_slot_index = index;
|
2018-09-24 23:06:33 +08:00
|
|
|
spin_unlock_irqrestore(&hisi_hba->lock, flags);
|
2018-05-21 18:09:14 +08:00
|
|
|
|
2018-09-24 23:06:33 +08:00
|
|
|
return index;
|
2015-11-18 00:50:49 +08:00
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:36 +08:00
|
|
|
static void hisi_sas_slot_index_init(struct hisi_hba *hisi_hba)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < hisi_hba->slot_index_count; ++i)
|
|
|
|
hisi_sas_slot_index_clear(hisi_hba, i);
|
|
|
|
}
|
2015-11-18 00:50:50 +08:00
|
|
|
|
|
|
|
void hisi_sas_slot_task_free(struct hisi_hba *hisi_hba, struct sas_task *task,
|
|
|
|
struct hisi_sas_slot *slot)
|
|
|
|
{
|
2018-05-09 23:10:49 +08:00
|
|
|
struct hisi_sas_dq *dq = &hisi_hba->dq[slot->dlvry_queue];
|
|
|
|
unsigned long flags;
|
2015-11-18 00:50:50 +08:00
|
|
|
|
2017-04-10 21:22:00 +08:00
|
|
|
if (task) {
|
2017-06-14 23:33:17 +08:00
|
|
|
struct device *dev = hisi_hba->dev;
|
2015-11-18 00:50:50 +08:00
|
|
|
|
2017-10-24 23:51:38 +08:00
|
|
|
if (!task->lldd_task)
|
|
|
|
return;
|
|
|
|
|
|
|
|
task->lldd_task = NULL;
|
|
|
|
|
2017-04-10 21:22:00 +08:00
|
|
|
if (!sas_protocol_ata(task->task_proto))
|
|
|
|
if (slot->n_elem)
|
2017-12-09 01:16:33 +08:00
|
|
|
dma_unmap_sg(dev, task->scatter,
|
|
|
|
task->num_scatter,
|
2017-04-10 21:22:00 +08:00
|
|
|
task->data_dir);
|
|
|
|
}
|
2015-11-18 00:50:50 +08:00
|
|
|
|
|
|
|
|
2018-05-09 23:10:49 +08:00
|
|
|
spin_lock_irqsave(&dq->lock, flags);
|
2015-11-18 00:50:50 +08:00
|
|
|
list_del_init(&slot->entry);
|
2018-05-09 23:10:49 +08:00
|
|
|
spin_unlock_irqrestore(&dq->lock, flags);
|
scsi: hisi_sas: Pre-allocate slot DMA buffers
Currently the driver spends much time allocating and freeing the slot DMA
buffer for command delivery/completion. To boost the performance,
pre-allocate the buffers for all IPTT. The downside of this approach is
that we are reallocating all buffer memory upfront, so hog memory which we
may not need.
However, the current method - DMA buffer pool - also caches all buffers and
does not free them until the pool is destroyed, so is not exactly efficient
either.
On top of this, since the slot DMA buffer is slightly bigger than a 4K
page, we need to allocate 2x4K pages per buffer (for 4K page kernel), which
is quite wasteful. For 64K page size this is not such an issue.
So, for the 4K page case, in order to make memory usage more efficient,
pre-allocating larger blocks of DMA memory for the buffers can be more
efficient.
To make DMA memory usage most efficient, we would choose a single
contiguous DMA memory block, but this could use up all the DMA memory in
the system (when CMA enabled and no IOMMU), or we may just not be able to
allocate a DMA buffer large enough when no CMA or IOMMU.
To decide the block size we use the LCM (least common multiple) of the
buffer size and the page size. We roundup(64) to ensure the LCM is not too
large, even though a little memory may be wasted per block.
So, with this, the total memory requirement is about is about 17MB for 4096
max IPTT.
Previously (for 4K pages case), it would be 32MB (for all slots
allocated).
With this change, the relative increase of IOPS for bs=4K read when
PAGE_SIZE=4K and PAGE_SIZE=64K is as follows:
IODEPTH 4K PAGE_SIZE 64K PAGE_SIZE
32 56% 47%
64 53% 44%
128 64% 43%
256 67% 45%
Signed-off-by: Xiang Chen <chenxiang66@hisilicon.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2018-05-31 20:50:48 +08:00
|
|
|
|
|
|
|
memset(slot, 0, offsetof(struct hisi_sas_slot, buf));
|
|
|
|
|
2015-11-18 00:50:50 +08:00
|
|
|
hisi_sas_slot_index_free(hisi_hba, slot->idx);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_slot_task_free);
|
|
|
|
|
2018-05-09 23:10:46 +08:00
|
|
|
static void hisi_sas_task_prep_smp(struct hisi_hba *hisi_hba,
|
2015-11-18 00:50:54 +08:00
|
|
|
struct hisi_sas_slot *slot)
|
|
|
|
{
|
2018-05-09 23:10:46 +08:00
|
|
|
hisi_hba->hw->prep_smp(hisi_hba, slot);
|
2015-11-18 00:50:54 +08:00
|
|
|
}
|
|
|
|
|
2018-05-09 23:10:46 +08:00
|
|
|
static void hisi_sas_task_prep_ssp(struct hisi_hba *hisi_hba,
|
2018-05-21 18:09:21 +08:00
|
|
|
struct hisi_sas_slot *slot)
|
2015-11-18 00:50:49 +08:00
|
|
|
{
|
2018-05-21 18:09:21 +08:00
|
|
|
hisi_hba->hw->prep_ssp(hisi_hba, slot);
|
2015-11-18 00:50:49 +08:00
|
|
|
}
|
|
|
|
|
2018-05-09 23:10:46 +08:00
|
|
|
static void hisi_sas_task_prep_ata(struct hisi_hba *hisi_hba,
|
2016-01-26 02:47:20 +08:00
|
|
|
struct hisi_sas_slot *slot)
|
|
|
|
{
|
2018-05-09 23:10:46 +08:00
|
|
|
hisi_hba->hw->prep_stp(hisi_hba, slot);
|
2016-01-26 02:47:20 +08:00
|
|
|
}
|
|
|
|
|
2018-05-09 23:10:46 +08:00
|
|
|
static void hisi_sas_task_prep_abort(struct hisi_hba *hisi_hba,
|
2016-08-24 19:05:47 +08:00
|
|
|
struct hisi_sas_slot *slot,
|
|
|
|
int device_id, int abort_flag, int tag_to_abort)
|
|
|
|
{
|
2018-05-09 23:10:46 +08:00
|
|
|
hisi_hba->hw->prep_abort(hisi_hba, slot,
|
2016-08-24 19:05:47 +08:00
|
|
|
device_id, abort_flag, tag_to_abort);
|
|
|
|
}
|
|
|
|
|
2018-12-06 21:34:41 +08:00
|
|
|
static void hisi_sas_dma_unmap(struct hisi_hba *hisi_hba,
|
|
|
|
struct sas_task *task, int n_elem,
|
|
|
|
int n_elem_req, int n_elem_resp)
|
|
|
|
{
|
|
|
|
struct device *dev = hisi_hba->dev;
|
|
|
|
|
|
|
|
if (!sas_protocol_ata(task->task_proto)) {
|
|
|
|
if (task->num_scatter) {
|
|
|
|
if (n_elem)
|
|
|
|
dma_unmap_sg(dev, task->scatter,
|
|
|
|
task->num_scatter,
|
|
|
|
task->data_dir);
|
|
|
|
} else if (task->task_proto & SAS_PROTOCOL_SMP) {
|
|
|
|
if (n_elem_req)
|
|
|
|
dma_unmap_sg(dev, &task->smp_task.smp_req,
|
|
|
|
1, DMA_TO_DEVICE);
|
|
|
|
if (n_elem_resp)
|
|
|
|
dma_unmap_sg(dev, &task->smp_task.smp_resp,
|
|
|
|
1, DMA_FROM_DEVICE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hisi_sas_dma_map(struct hisi_hba *hisi_hba,
|
|
|
|
struct sas_task *task, int *n_elem,
|
|
|
|
int *n_elem_req, int *n_elem_resp)
|
|
|
|
{
|
|
|
|
struct device *dev = hisi_hba->dev;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (sas_protocol_ata(task->task_proto)) {
|
|
|
|
*n_elem = task->num_scatter;
|
|
|
|
} else {
|
|
|
|
unsigned int req_len, resp_len;
|
|
|
|
|
|
|
|
if (task->num_scatter) {
|
|
|
|
*n_elem = dma_map_sg(dev, task->scatter,
|
|
|
|
task->num_scatter, task->data_dir);
|
|
|
|
if (!*n_elem) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto prep_out;
|
|
|
|
}
|
|
|
|
} else if (task->task_proto & SAS_PROTOCOL_SMP) {
|
|
|
|
*n_elem_req = dma_map_sg(dev, &task->smp_task.smp_req,
|
|
|
|
1, DMA_TO_DEVICE);
|
|
|
|
if (!*n_elem_req) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto prep_out;
|
|
|
|
}
|
|
|
|
req_len = sg_dma_len(&task->smp_task.smp_req);
|
|
|
|
if (req_len & 0x3) {
|
|
|
|
rc = -EINVAL;
|
|
|
|
goto err_out_dma_unmap;
|
|
|
|
}
|
|
|
|
*n_elem_resp = dma_map_sg(dev, &task->smp_task.smp_resp,
|
|
|
|
1, DMA_FROM_DEVICE);
|
|
|
|
if (!*n_elem_resp) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto err_out_dma_unmap;
|
|
|
|
}
|
|
|
|
resp_len = sg_dma_len(&task->smp_task.smp_resp);
|
|
|
|
if (resp_len & 0x3) {
|
|
|
|
rc = -EINVAL;
|
|
|
|
goto err_out_dma_unmap;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*n_elem > HISI_SAS_SGE_PAGE_CNT) {
|
|
|
|
dev_err(dev, "task prep: n_elem(%d) > HISI_SAS_SGE_PAGE_CNT",
|
|
|
|
*n_elem);
|
|
|
|
rc = -EINVAL;
|
|
|
|
goto err_out_dma_unmap;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_out_dma_unmap:
|
|
|
|
/* It would be better to call dma_unmap_sg() here, but it's messy */
|
|
|
|
hisi_sas_dma_unmap(hisi_hba, task, *n_elem,
|
|
|
|
*n_elem_req, *n_elem_resp);
|
|
|
|
prep_out:
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2018-05-09 23:10:50 +08:00
|
|
|
static int hisi_sas_task_prep(struct sas_task *task,
|
|
|
|
struct hisi_sas_dq **dq_pointer,
|
2018-05-21 18:09:21 +08:00
|
|
|
bool is_tmf, struct hisi_sas_tmf_task *tmf,
|
2018-05-09 23:10:48 +08:00
|
|
|
int *pass)
|
2015-11-18 00:50:49 +08:00
|
|
|
{
|
|
|
|
struct domain_device *device = task->dev;
|
2018-11-09 22:06:35 +08:00
|
|
|
struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
|
2015-11-18 00:50:49 +08:00
|
|
|
struct hisi_sas_device *sas_dev = device->lldd_dev;
|
|
|
|
struct hisi_sas_port *port;
|
|
|
|
struct hisi_sas_slot *slot;
|
|
|
|
struct hisi_sas_cmd_hdr *cmd_hdr_base;
|
2017-03-23 01:25:17 +08:00
|
|
|
struct asd_sas_port *sas_port = device->port;
|
2018-11-09 22:06:35 +08:00
|
|
|
struct device *dev = hisi_hba->dev;
|
2018-05-09 23:10:45 +08:00
|
|
|
int dlvry_queue_slot, dlvry_queue, rc, slot_idx;
|
2018-05-09 23:10:50 +08:00
|
|
|
int n_elem = 0, n_elem_req = 0, n_elem_resp = 0;
|
|
|
|
struct hisi_sas_dq *dq;
|
2018-07-18 22:14:31 +08:00
|
|
|
unsigned long flags;
|
2018-05-09 23:10:48 +08:00
|
|
|
int wr_q_index;
|
2015-11-18 00:50:49 +08:00
|
|
|
|
|
|
|
if (DEV_IS_GONE(sas_dev)) {
|
|
|
|
if (sas_dev)
|
2017-06-14 23:33:12 +08:00
|
|
|
dev_info(dev, "task prep: device %d not ready\n",
|
2015-11-18 00:50:49 +08:00
|
|
|
sas_dev->device_id);
|
|
|
|
else
|
|
|
|
dev_info(dev, "task prep: device %016llx not ready\n",
|
|
|
|
SAS_ADDR(device->sas_addr));
|
|
|
|
|
2018-03-07 20:25:11 +08:00
|
|
|
return -ECOMM;
|
2015-11-18 00:50:49 +08:00
|
|
|
}
|
2017-03-23 01:25:17 +08:00
|
|
|
|
2018-05-09 23:10:50 +08:00
|
|
|
*dq_pointer = dq = sas_dev->dq;
|
|
|
|
|
2017-03-23 01:25:17 +08:00
|
|
|
port = to_hisi_sas_port(sas_port);
|
2016-08-24 19:05:52 +08:00
|
|
|
if (port && !port->port_attached) {
|
2016-09-06 23:36:18 +08:00
|
|
|
dev_info(dev, "task prep: %s port%d not attach device\n",
|
2017-03-23 01:25:38 +08:00
|
|
|
(dev_is_sata(device)) ?
|
2016-09-06 23:36:18 +08:00
|
|
|
"SATA/STP" : "SAS",
|
|
|
|
device->port->id);
|
|
|
|
|
2018-03-07 20:25:11 +08:00
|
|
|
return -ECOMM;
|
2015-11-18 00:50:49 +08:00
|
|
|
}
|
|
|
|
|
2018-12-06 21:34:41 +08:00
|
|
|
rc = hisi_sas_dma_map(hisi_hba, task, &n_elem,
|
|
|
|
&n_elem_req, &n_elem_resp);
|
|
|
|
if (rc < 0)
|
|
|
|
goto prep_out;
|
2018-05-09 23:10:46 +08:00
|
|
|
|
2016-04-15 21:36:36 +08:00
|
|
|
if (hisi_hba->hw->slot_index_alloc)
|
2018-09-24 23:06:33 +08:00
|
|
|
rc = hisi_hba->hw->slot_index_alloc(hisi_hba, device);
|
|
|
|
else {
|
|
|
|
struct scsi_cmnd *scsi_cmnd = NULL;
|
|
|
|
|
|
|
|
if (task->uldd_task) {
|
|
|
|
struct ata_queued_cmd *qc;
|
|
|
|
|
|
|
|
if (dev_is_sata(device)) {
|
|
|
|
qc = task->uldd_task;
|
|
|
|
scsi_cmnd = qc->scsicmd;
|
|
|
|
} else {
|
|
|
|
scsi_cmnd = task->uldd_task;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rc = hisi_sas_slot_index_alloc(hisi_hba, scsi_cmnd);
|
|
|
|
}
|
|
|
|
if (rc < 0)
|
2018-05-09 23:10:45 +08:00
|
|
|
goto err_out_dma_unmap;
|
2017-06-14 23:33:13 +08:00
|
|
|
|
2018-09-24 23:06:33 +08:00
|
|
|
slot_idx = rc;
|
2018-05-09 23:10:47 +08:00
|
|
|
slot = &hisi_hba->slot_info[slot_idx];
|
|
|
|
|
2018-07-18 22:14:31 +08:00
|
|
|
spin_lock_irqsave(&dq->lock, flags);
|
2018-05-09 23:10:48 +08:00
|
|
|
wr_q_index = hisi_hba->hw->get_free_slot(hisi_hba, dq);
|
|
|
|
if (wr_q_index < 0) {
|
2018-07-18 22:14:31 +08:00
|
|
|
spin_unlock_irqrestore(&dq->lock, flags);
|
2018-05-21 18:09:24 +08:00
|
|
|
rc = -EAGAIN;
|
scsi: hisi_sas: Pre-allocate slot DMA buffers
Currently the driver spends much time allocating and freeing the slot DMA
buffer for command delivery/completion. To boost the performance,
pre-allocate the buffers for all IPTT. The downside of this approach is
that we are reallocating all buffer memory upfront, so hog memory which we
may not need.
However, the current method - DMA buffer pool - also caches all buffers and
does not free them until the pool is destroyed, so is not exactly efficient
either.
On top of this, since the slot DMA buffer is slightly bigger than a 4K
page, we need to allocate 2x4K pages per buffer (for 4K page kernel), which
is quite wasteful. For 64K page size this is not such an issue.
So, for the 4K page case, in order to make memory usage more efficient,
pre-allocating larger blocks of DMA memory for the buffers can be more
efficient.
To make DMA memory usage most efficient, we would choose a single
contiguous DMA memory block, but this could use up all the DMA memory in
the system (when CMA enabled and no IOMMU), or we may just not be able to
allocate a DMA buffer large enough when no CMA or IOMMU.
To decide the block size we use the LCM (least common multiple) of the
buffer size and the page size. We roundup(64) to ensure the LCM is not too
large, even though a little memory may be wasted per block.
So, with this, the total memory requirement is about is about 17MB for 4096
max IPTT.
Previously (for 4K pages case), it would be 32MB (for all slots
allocated).
With this change, the relative increase of IOPS for bs=4K read when
PAGE_SIZE=4K and PAGE_SIZE=64K is as follows:
IODEPTH 4K PAGE_SIZE 64K PAGE_SIZE
32 56% 47%
64 53% 44%
128 64% 43%
256 67% 45%
Signed-off-by: Xiang Chen <chenxiang66@hisilicon.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2018-05-31 20:50:48 +08:00
|
|
|
goto err_out_tag;
|
2018-05-09 23:10:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
list_add_tail(&slot->delivery, &dq->list);
|
2018-07-18 22:14:31 +08:00
|
|
|
list_add_tail(&slot->entry, &sas_dev->list);
|
|
|
|
spin_unlock_irqrestore(&dq->lock, flags);
|
2015-11-18 00:50:49 +08:00
|
|
|
|
2017-06-14 23:33:13 +08:00
|
|
|
dlvry_queue = dq->id;
|
2018-05-09 23:10:48 +08:00
|
|
|
dlvry_queue_slot = wr_q_index;
|
2015-11-18 00:50:49 +08:00
|
|
|
|
|
|
|
slot->n_elem = n_elem;
|
|
|
|
slot->dlvry_queue = dlvry_queue;
|
|
|
|
slot->dlvry_queue_slot = dlvry_queue_slot;
|
|
|
|
cmd_hdr_base = hisi_hba->cmd_hdr[dlvry_queue];
|
|
|
|
slot->cmd_hdr = &cmd_hdr_base[dlvry_queue_slot];
|
|
|
|
slot->task = task;
|
|
|
|
slot->port = port;
|
2018-05-21 18:09:21 +08:00
|
|
|
slot->tmf = tmf;
|
|
|
|
slot->is_internal = is_tmf;
|
2015-11-18 00:50:49 +08:00
|
|
|
task->lldd_task = slot;
|
|
|
|
|
|
|
|
memset(slot->cmd_hdr, 0, sizeof(struct hisi_sas_cmd_hdr));
|
2017-06-29 21:02:14 +08:00
|
|
|
memset(hisi_sas_cmd_hdr_addr_mem(slot), 0, HISI_SAS_COMMAND_TABLE_SZ);
|
|
|
|
memset(hisi_sas_status_buf_addr_mem(slot), 0, HISI_SAS_STATUS_BUF_SZ);
|
2015-11-18 00:50:49 +08:00
|
|
|
|
|
|
|
switch (task->task_proto) {
|
2015-11-18 00:50:54 +08:00
|
|
|
case SAS_PROTOCOL_SMP:
|
2018-05-09 23:10:46 +08:00
|
|
|
hisi_sas_task_prep_smp(hisi_hba, slot);
|
2015-11-18 00:50:54 +08:00
|
|
|
break;
|
2015-11-18 00:50:49 +08:00
|
|
|
case SAS_PROTOCOL_SSP:
|
2018-05-21 18:09:21 +08:00
|
|
|
hisi_sas_task_prep_ssp(hisi_hba, slot);
|
2015-11-18 00:50:49 +08:00
|
|
|
break;
|
|
|
|
case SAS_PROTOCOL_SATA:
|
|
|
|
case SAS_PROTOCOL_STP:
|
|
|
|
case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
|
2018-05-09 23:10:46 +08:00
|
|
|
hisi_sas_task_prep_ata(hisi_hba, slot);
|
2016-01-26 02:47:20 +08:00
|
|
|
break;
|
2015-11-18 00:50:49 +08:00
|
|
|
default:
|
|
|
|
dev_err(dev, "task prep: unknown/unsupported proto (0x%x)\n",
|
|
|
|
task->task_proto);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2017-03-23 01:25:29 +08:00
|
|
|
spin_lock_irqsave(&task->task_state_lock, flags);
|
2015-11-18 00:50:49 +08:00
|
|
|
task->task_state_flags |= SAS_TASK_AT_INITIATOR;
|
2017-03-23 01:25:29 +08:00
|
|
|
spin_unlock_irqrestore(&task->task_state_lock, flags);
|
2015-11-18 00:50:49 +08:00
|
|
|
|
|
|
|
++(*pass);
|
2018-07-18 22:14:32 +08:00
|
|
|
WRITE_ONCE(slot->ready, 1);
|
2015-11-18 00:50:49 +08:00
|
|
|
|
2015-12-09 18:48:36 +08:00
|
|
|
return 0;
|
2015-11-18 00:50:49 +08:00
|
|
|
|
|
|
|
err_out_tag:
|
|
|
|
hisi_sas_slot_index_free(hisi_hba, slot_idx);
|
2018-05-09 23:10:45 +08:00
|
|
|
err_out_dma_unmap:
|
2018-12-06 21:34:41 +08:00
|
|
|
hisi_sas_dma_unmap(hisi_hba, task, n_elem,
|
|
|
|
n_elem_req, n_elem_resp);
|
2015-11-18 00:50:49 +08:00
|
|
|
prep_out:
|
2018-05-09 23:10:45 +08:00
|
|
|
dev_err(dev, "task prep: failed[%d]!\n", rc);
|
2015-11-18 00:50:49 +08:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hisi_sas_task_exec(struct sas_task *task, gfp_t gfp_flags,
|
2018-05-21 18:09:21 +08:00
|
|
|
bool is_tmf, struct hisi_sas_tmf_task *tmf)
|
2015-11-18 00:50:49 +08:00
|
|
|
{
|
|
|
|
u32 rc;
|
|
|
|
u32 pass = 0;
|
|
|
|
unsigned long flags;
|
2018-11-09 22:06:35 +08:00
|
|
|
struct hisi_hba *hisi_hba;
|
|
|
|
struct device *dev;
|
|
|
|
struct domain_device *device = task->dev;
|
|
|
|
struct asd_sas_port *sas_port = device->port;
|
2018-05-09 23:10:50 +08:00
|
|
|
struct hisi_sas_dq *dq = NULL;
|
2015-11-18 00:50:49 +08:00
|
|
|
|
2018-11-09 22:06:35 +08:00
|
|
|
if (!sas_port) {
|
|
|
|
struct task_status_struct *ts = &task->task_status;
|
|
|
|
|
|
|
|
ts->resp = SAS_TASK_UNDELIVERED;
|
|
|
|
ts->stat = SAS_PHY_DOWN;
|
|
|
|
/*
|
|
|
|
* libsas will use dev->port, should
|
|
|
|
* not call task_done for sata
|
|
|
|
*/
|
|
|
|
if (device->dev_type != SAS_SATA_DEV)
|
|
|
|
task->task_done(task);
|
|
|
|
return -ECOMM;
|
|
|
|
}
|
|
|
|
|
|
|
|
hisi_hba = dev_to_hisi_hba(device);
|
|
|
|
dev = hisi_hba->dev;
|
|
|
|
|
2018-05-31 20:50:45 +08:00
|
|
|
if (unlikely(test_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags))) {
|
|
|
|
if (in_softirq())
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
down(&hisi_hba->sem);
|
|
|
|
up(&hisi_hba->sem);
|
|
|
|
}
|
2017-03-23 01:25:18 +08:00
|
|
|
|
2015-11-18 00:50:49 +08:00
|
|
|
/* protect task_prep and start_delivery sequence */
|
2018-05-09 23:10:50 +08:00
|
|
|
rc = hisi_sas_task_prep(task, &dq, is_tmf, tmf, &pass);
|
2015-11-18 00:50:49 +08:00
|
|
|
if (rc)
|
|
|
|
dev_err(dev, "task exec: failed[%d]!\n", rc);
|
|
|
|
|
2018-05-09 23:10:50 +08:00
|
|
|
if (likely(pass)) {
|
|
|
|
spin_lock_irqsave(&dq->lock, flags);
|
2017-06-14 23:33:13 +08:00
|
|
|
hisi_hba->hw->start_delivery(dq);
|
2018-05-09 23:10:50 +08:00
|
|
|
spin_unlock_irqrestore(&dq->lock, flags);
|
|
|
|
}
|
2015-11-18 00:50:49 +08:00
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
2015-11-18 00:50:36 +08:00
|
|
|
|
2015-11-18 00:50:48 +08:00
|
|
|
static void hisi_sas_bytes_dmaed(struct hisi_hba *hisi_hba, int phy_no)
|
|
|
|
{
|
|
|
|
struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
|
|
|
|
struct asd_sas_phy *sas_phy = &phy->sas_phy;
|
|
|
|
struct sas_ha_struct *sas_ha;
|
|
|
|
|
|
|
|
if (!phy->phy_attached)
|
|
|
|
return;
|
|
|
|
|
|
|
|
sas_ha = &hisi_hba->sha;
|
|
|
|
sas_ha->notify_phy_event(sas_phy, PHYE_OOB_DONE);
|
|
|
|
|
|
|
|
if (sas_phy->phy) {
|
|
|
|
struct sas_phy *sphy = sas_phy->phy;
|
|
|
|
|
|
|
|
sphy->negotiated_linkrate = sas_phy->linkrate;
|
|
|
|
sphy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
|
2016-11-07 20:48:40 +08:00
|
|
|
sphy->maximum_linkrate_hw =
|
|
|
|
hisi_hba->hw->phy_get_max_linkrate();
|
|
|
|
if (sphy->minimum_linkrate == SAS_LINK_RATE_UNKNOWN)
|
|
|
|
sphy->minimum_linkrate = phy->minimum_linkrate;
|
|
|
|
|
|
|
|
if (sphy->maximum_linkrate == SAS_LINK_RATE_UNKNOWN)
|
|
|
|
sphy->maximum_linkrate = phy->maximum_linkrate;
|
2015-11-18 00:50:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (phy->phy_type & PORT_TYPE_SAS) {
|
|
|
|
struct sas_identify_frame *id;
|
|
|
|
|
|
|
|
id = (struct sas_identify_frame *)phy->frame_rcvd;
|
|
|
|
id->dev_type = phy->identify.device_type;
|
|
|
|
id->initiator_bits = SAS_PROTOCOL_ALL;
|
|
|
|
id->target_bits = phy->identify.target_port_protocols;
|
|
|
|
} else if (phy->phy_type & PORT_TYPE_SATA) {
|
|
|
|
/*Nothing*/
|
|
|
|
}
|
|
|
|
|
|
|
|
sas_phy->frame_rcvd_size = phy->frame_rcvd_size;
|
|
|
|
sas_ha->notify_port_event(sas_phy, PORTE_BYTES_DMAED);
|
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:51 +08:00
|
|
|
static struct hisi_sas_device *hisi_sas_alloc_dev(struct domain_device *device)
|
|
|
|
{
|
|
|
|
struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
|
|
|
|
struct hisi_sas_device *sas_dev = NULL;
|
2017-10-24 23:51:33 +08:00
|
|
|
unsigned long flags;
|
2018-05-21 18:09:15 +08:00
|
|
|
int last = hisi_hba->last_dev_id;
|
|
|
|
int first = (hisi_hba->last_dev_id + 1) % HISI_SAS_MAX_DEVICES;
|
2015-11-18 00:50:51 +08:00
|
|
|
int i;
|
|
|
|
|
2017-10-24 23:51:33 +08:00
|
|
|
spin_lock_irqsave(&hisi_hba->lock, flags);
|
2018-05-21 18:09:15 +08:00
|
|
|
for (i = first; i != last; i %= HISI_SAS_MAX_DEVICES) {
|
2015-11-18 00:50:51 +08:00
|
|
|
if (hisi_hba->devices[i].dev_type == SAS_PHY_UNUSED) {
|
2017-06-14 23:33:13 +08:00
|
|
|
int queue = i % hisi_hba->queue_count;
|
|
|
|
struct hisi_sas_dq *dq = &hisi_hba->dq[queue];
|
|
|
|
|
2015-11-18 00:50:51 +08:00
|
|
|
hisi_hba->devices[i].device_id = i;
|
|
|
|
sas_dev = &hisi_hba->devices[i];
|
|
|
|
sas_dev->dev_status = HISI_SAS_DEV_NORMAL;
|
|
|
|
sas_dev->dev_type = device->dev_type;
|
|
|
|
sas_dev->hisi_hba = hisi_hba;
|
|
|
|
sas_dev->sas_device = device;
|
2017-06-14 23:33:13 +08:00
|
|
|
sas_dev->dq = dq;
|
2017-03-23 01:25:21 +08:00
|
|
|
INIT_LIST_HEAD(&hisi_hba->devices[i].list);
|
2015-11-18 00:50:51 +08:00
|
|
|
break;
|
|
|
|
}
|
2018-05-21 18:09:15 +08:00
|
|
|
i++;
|
2015-11-18 00:50:51 +08:00
|
|
|
}
|
2018-05-21 18:09:15 +08:00
|
|
|
hisi_hba->last_dev_id = i;
|
2017-10-24 23:51:33 +08:00
|
|
|
spin_unlock_irqrestore(&hisi_hba->lock, flags);
|
2015-11-18 00:50:51 +08:00
|
|
|
|
|
|
|
return sas_dev;
|
|
|
|
}
|
|
|
|
|
2018-05-21 18:09:17 +08:00
|
|
|
#define HISI_SAS_SRST_ATA_DISK_CNT 3
|
|
|
|
static int hisi_sas_init_device(struct domain_device *device)
|
|
|
|
{
|
|
|
|
int rc = TMF_RESP_FUNC_COMPLETE;
|
|
|
|
struct scsi_lun lun;
|
|
|
|
struct hisi_sas_tmf_task tmf_task;
|
|
|
|
int retry = HISI_SAS_SRST_ATA_DISK_CNT;
|
|
|
|
struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
|
|
|
|
|
|
|
|
switch (device->dev_type) {
|
|
|
|
case SAS_END_DEVICE:
|
|
|
|
int_to_scsilun(0, &lun);
|
|
|
|
|
|
|
|
tmf_task.tmf = TMF_CLEAR_TASK_SET;
|
|
|
|
rc = hisi_sas_debug_issue_ssp_tmf(device, lun.scsi_lun,
|
|
|
|
&tmf_task);
|
|
|
|
if (rc == TMF_RESP_FUNC_COMPLETE)
|
|
|
|
hisi_sas_release_task(hisi_hba, device);
|
|
|
|
break;
|
|
|
|
case SAS_SATA_DEV:
|
|
|
|
case SAS_SATA_PM:
|
|
|
|
case SAS_SATA_PM_PORT:
|
|
|
|
case SAS_SATA_PENDING:
|
|
|
|
while (retry-- > 0) {
|
|
|
|
rc = hisi_sas_softreset_ata_disk(device);
|
|
|
|
if (!rc)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:51 +08:00
|
|
|
static int hisi_sas_dev_found(struct domain_device *device)
|
|
|
|
{
|
|
|
|
struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
|
|
|
|
struct domain_device *parent_dev = device->parent;
|
|
|
|
struct hisi_sas_device *sas_dev;
|
2017-06-14 23:33:17 +08:00
|
|
|
struct device *dev = hisi_hba->dev;
|
2018-05-21 18:09:17 +08:00
|
|
|
int rc;
|
2015-11-18 00:50:51 +08:00
|
|
|
|
2016-04-15 21:36:36 +08:00
|
|
|
if (hisi_hba->hw->alloc_dev)
|
|
|
|
sas_dev = hisi_hba->hw->alloc_dev(device);
|
|
|
|
else
|
|
|
|
sas_dev = hisi_sas_alloc_dev(device);
|
2015-11-18 00:50:51 +08:00
|
|
|
if (!sas_dev) {
|
|
|
|
dev_err(dev, "fail alloc dev: max support %d devices\n",
|
|
|
|
HISI_SAS_MAX_DEVICES);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
device->lldd_dev = sas_dev;
|
|
|
|
hisi_hba->hw->setup_itct(hisi_hba, sas_dev);
|
|
|
|
|
|
|
|
if (parent_dev && DEV_IS_EXPANDER(parent_dev->dev_type)) {
|
|
|
|
int phy_no;
|
|
|
|
u8 phy_num = parent_dev->ex_dev.num_phys;
|
|
|
|
struct ex_phy *phy;
|
|
|
|
|
|
|
|
for (phy_no = 0; phy_no < phy_num; phy_no++) {
|
|
|
|
phy = &parent_dev->ex_dev.ex_phy[phy_no];
|
|
|
|
if (SAS_ADDR(phy->attached_sas_addr) ==
|
2018-03-24 00:05:15 +08:00
|
|
|
SAS_ADDR(device->sas_addr))
|
2015-11-18 00:50:51 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (phy_no == phy_num) {
|
|
|
|
dev_info(dev, "dev found: no attached "
|
|
|
|
"dev:%016llx at ex:%016llx\n",
|
|
|
|
SAS_ADDR(device->sas_addr),
|
|
|
|
SAS_ADDR(parent_dev->sas_addr));
|
2018-05-21 18:09:17 +08:00
|
|
|
rc = -EINVAL;
|
|
|
|
goto err_out;
|
2015-11-18 00:50:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-09 01:16:41 +08:00
|
|
|
dev_info(dev, "dev[%d:%x] found\n",
|
|
|
|
sas_dev->device_id, sas_dev->dev_type);
|
|
|
|
|
2018-05-21 18:09:17 +08:00
|
|
|
rc = hisi_sas_init_device(device);
|
|
|
|
if (rc)
|
|
|
|
goto err_out;
|
2015-11-18 00:50:51 +08:00
|
|
|
return 0;
|
2018-05-21 18:09:17 +08:00
|
|
|
|
|
|
|
err_out:
|
|
|
|
hisi_sas_dev_gone(device);
|
|
|
|
return rc;
|
2015-11-18 00:50:51 +08:00
|
|
|
}
|
|
|
|
|
2018-05-21 18:09:18 +08:00
|
|
|
int hisi_sas_slave_configure(struct scsi_device *sdev)
|
2016-02-25 17:42:14 +08:00
|
|
|
{
|
|
|
|
struct domain_device *dev = sdev_to_domain_dev(sdev);
|
|
|
|
int ret = sas_slave_configure(sdev);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
if (!dev_is_sata(dev))
|
|
|
|
sas_change_queue_depth(sdev, 64);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2018-05-21 18:09:18 +08:00
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_slave_configure);
|
2016-02-25 17:42:14 +08:00
|
|
|
|
2018-05-21 18:09:18 +08:00
|
|
|
void hisi_sas_scan_start(struct Scsi_Host *shost)
|
2015-11-18 00:50:55 +08:00
|
|
|
{
|
|
|
|
struct hisi_hba *hisi_hba = shost_priv(shost);
|
|
|
|
|
2017-03-23 01:25:19 +08:00
|
|
|
hisi_hba->hw->phys_init(hisi_hba);
|
2015-11-18 00:50:55 +08:00
|
|
|
}
|
2018-05-21 18:09:18 +08:00
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_scan_start);
|
2015-11-18 00:50:55 +08:00
|
|
|
|
2018-05-21 18:09:18 +08:00
|
|
|
int hisi_sas_scan_finished(struct Scsi_Host *shost, unsigned long time)
|
2015-11-18 00:50:55 +08:00
|
|
|
{
|
|
|
|
struct hisi_hba *hisi_hba = shost_priv(shost);
|
|
|
|
struct sas_ha_struct *sha = &hisi_hba->sha;
|
|
|
|
|
2017-03-23 01:25:19 +08:00
|
|
|
/* Wait for PHY up interrupt to occur */
|
|
|
|
if (time < HZ)
|
2015-11-18 00:50:55 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
sas_drain_work(sha);
|
|
|
|
return 1;
|
|
|
|
}
|
2018-05-21 18:09:18 +08:00
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_scan_finished);
|
2015-11-18 00:50:55 +08:00
|
|
|
|
2015-11-18 00:50:48 +08:00
|
|
|
static void hisi_sas_phyup_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct hisi_sas_phy *phy =
|
2017-12-09 01:16:44 +08:00
|
|
|
container_of(work, typeof(*phy), works[HISI_PHYE_PHY_UP]);
|
2015-11-18 00:50:48 +08:00
|
|
|
struct hisi_hba *hisi_hba = phy->hisi_hba;
|
|
|
|
struct asd_sas_phy *sas_phy = &phy->sas_phy;
|
|
|
|
int phy_no = sas_phy->id;
|
|
|
|
|
|
|
|
hisi_hba->hw->sl_notify(hisi_hba, phy_no); /* This requires a sleep */
|
|
|
|
hisi_sas_bytes_dmaed(hisi_hba, phy_no);
|
|
|
|
}
|
2015-11-18 00:50:42 +08:00
|
|
|
|
2017-12-09 01:16:45 +08:00
|
|
|
static void hisi_sas_linkreset_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct hisi_sas_phy *phy =
|
|
|
|
container_of(work, typeof(*phy), works[HISI_PHYE_LINK_RESET]);
|
|
|
|
struct asd_sas_phy *sas_phy = &phy->sas_phy;
|
|
|
|
|
|
|
|
hisi_sas_control_phy(sas_phy, PHY_FUNC_LINK_RESET, NULL);
|
|
|
|
}
|
|
|
|
|
2017-12-09 01:16:44 +08:00
|
|
|
static const work_func_t hisi_sas_phye_fns[HISI_PHYES_NUM] = {
|
|
|
|
[HISI_PHYE_PHY_UP] = hisi_sas_phyup_work,
|
2017-12-09 01:16:45 +08:00
|
|
|
[HISI_PHYE_LINK_RESET] = hisi_sas_linkreset_work,
|
2017-12-09 01:16:44 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
bool hisi_sas_notify_phy_event(struct hisi_sas_phy *phy,
|
|
|
|
enum hisi_sas_phy_event event)
|
|
|
|
{
|
|
|
|
struct hisi_hba *hisi_hba = phy->hisi_hba;
|
|
|
|
|
|
|
|
if (WARN_ON(event >= HISI_PHYES_NUM))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return queue_work(hisi_hba->wq, &phy->works[event]);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_notify_phy_event);
|
|
|
|
|
2015-11-18 00:50:42 +08:00
|
|
|
static void hisi_sas_phy_init(struct hisi_hba *hisi_hba, int phy_no)
|
|
|
|
{
|
|
|
|
struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
|
|
|
|
struct asd_sas_phy *sas_phy = &phy->sas_phy;
|
2017-12-09 01:16:44 +08:00
|
|
|
int i;
|
2015-11-18 00:50:42 +08:00
|
|
|
|
|
|
|
phy->hisi_hba = hisi_hba;
|
|
|
|
phy->port = NULL;
|
2018-03-07 20:25:07 +08:00
|
|
|
phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
|
|
|
|
phy->maximum_linkrate = hisi_hba->hw->phy_get_max_linkrate();
|
2015-11-18 00:50:42 +08:00
|
|
|
sas_phy->enabled = (phy_no < hisi_hba->n_phy) ? 1 : 0;
|
|
|
|
sas_phy->class = SAS;
|
|
|
|
sas_phy->iproto = SAS_PROTOCOL_ALL;
|
|
|
|
sas_phy->tproto = 0;
|
|
|
|
sas_phy->type = PHY_TYPE_PHYSICAL;
|
|
|
|
sas_phy->role = PHY_ROLE_INITIATOR;
|
|
|
|
sas_phy->oob_mode = OOB_NOT_CONNECTED;
|
|
|
|
sas_phy->linkrate = SAS_LINK_RATE_UNKNOWN;
|
|
|
|
sas_phy->id = phy_no;
|
|
|
|
sas_phy->sas_addr = &hisi_hba->sas_addr[0];
|
|
|
|
sas_phy->frame_rcvd = &phy->frame_rcvd[0];
|
|
|
|
sas_phy->ha = (struct sas_ha_struct *)hisi_hba->shost->hostdata;
|
|
|
|
sas_phy->lldd_phy = phy;
|
2015-11-18 00:50:48 +08:00
|
|
|
|
2017-12-09 01:16:44 +08:00
|
|
|
for (i = 0; i < HISI_PHYES_NUM; i++)
|
|
|
|
INIT_WORK(&phy->works[i], hisi_sas_phye_fns[i]);
|
2018-05-31 20:50:49 +08:00
|
|
|
|
|
|
|
spin_lock_init(&phy->lock);
|
2015-11-18 00:50:42 +08:00
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:52 +08:00
|
|
|
static void hisi_sas_port_notify_formed(struct asd_sas_phy *sas_phy)
|
|
|
|
{
|
|
|
|
struct sas_ha_struct *sas_ha = sas_phy->ha;
|
|
|
|
struct hisi_hba *hisi_hba = sas_ha->lldd_ha;
|
|
|
|
struct hisi_sas_phy *phy = sas_phy->lldd_phy;
|
|
|
|
struct asd_sas_port *sas_port = sas_phy->port;
|
2017-03-23 01:25:17 +08:00
|
|
|
struct hisi_sas_port *port = to_hisi_sas_port(sas_port);
|
2015-11-18 00:50:52 +08:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (!sas_port)
|
|
|
|
return;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&hisi_hba->lock, flags);
|
|
|
|
port->port_attached = 1;
|
|
|
|
port->id = phy->port_id;
|
|
|
|
phy->port = port;
|
|
|
|
sas_port->lldd_port = port;
|
|
|
|
spin_unlock_irqrestore(&hisi_hba->lock, flags);
|
|
|
|
}
|
|
|
|
|
2017-04-10 21:22:00 +08:00
|
|
|
static void hisi_sas_do_release_task(struct hisi_hba *hisi_hba, struct sas_task *task,
|
2017-03-23 01:25:21 +08:00
|
|
|
struct hisi_sas_slot *slot)
|
2015-11-18 00:50:52 +08:00
|
|
|
{
|
2017-04-10 21:22:00 +08:00
|
|
|
if (task) {
|
|
|
|
unsigned long flags;
|
|
|
|
struct task_status_struct *ts;
|
2015-11-18 00:50:52 +08:00
|
|
|
|
2017-04-10 21:22:00 +08:00
|
|
|
ts = &task->task_status;
|
2015-11-18 00:50:52 +08:00
|
|
|
|
2017-04-10 21:22:00 +08:00
|
|
|
ts->resp = SAS_TASK_COMPLETE;
|
|
|
|
ts->stat = SAS_ABORTED_TASK;
|
|
|
|
spin_lock_irqsave(&task->task_state_lock, flags);
|
|
|
|
task->task_state_flags &=
|
|
|
|
~(SAS_TASK_STATE_PENDING | SAS_TASK_AT_INITIATOR);
|
|
|
|
task->task_state_flags |= SAS_TASK_STATE_DONE;
|
|
|
|
spin_unlock_irqrestore(&task->task_state_lock, flags);
|
|
|
|
}
|
2015-11-18 00:50:52 +08:00
|
|
|
|
2017-03-23 01:25:21 +08:00
|
|
|
hisi_sas_slot_task_free(hisi_hba, task, slot);
|
2015-11-18 00:50:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hisi_sas_release_task(struct hisi_hba *hisi_hba,
|
|
|
|
struct domain_device *device)
|
|
|
|
{
|
2017-03-23 01:25:21 +08:00
|
|
|
struct hisi_sas_slot *slot, *slot2;
|
|
|
|
struct hisi_sas_device *sas_dev = device->lldd_dev;
|
2015-11-18 00:50:52 +08:00
|
|
|
|
2017-03-23 01:25:21 +08:00
|
|
|
list_for_each_entry_safe(slot, slot2, &sas_dev->list, entry)
|
|
|
|
hisi_sas_do_release_task(hisi_hba, slot->task, slot);
|
2015-11-18 00:50:52 +08:00
|
|
|
}
|
|
|
|
|
2017-12-09 01:16:50 +08:00
|
|
|
void hisi_sas_release_tasks(struct hisi_hba *hisi_hba)
|
2017-03-23 01:25:18 +08:00
|
|
|
{
|
2017-03-23 01:25:21 +08:00
|
|
|
struct hisi_sas_device *sas_dev;
|
|
|
|
struct domain_device *device;
|
2017-03-23 01:25:18 +08:00
|
|
|
int i;
|
|
|
|
|
2017-03-23 01:25:21 +08:00
|
|
|
for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
|
|
|
|
sas_dev = &hisi_hba->devices[i];
|
|
|
|
device = sas_dev->sas_device;
|
2017-03-23 01:25:18 +08:00
|
|
|
|
2017-03-23 01:25:21 +08:00
|
|
|
if ((sas_dev->dev_type == SAS_PHY_UNUSED) ||
|
|
|
|
!device)
|
2017-03-23 01:25:18 +08:00
|
|
|
continue;
|
2017-03-23 01:25:21 +08:00
|
|
|
|
|
|
|
hisi_sas_release_task(hisi_hba, device);
|
2017-03-23 01:25:18 +08:00
|
|
|
}
|
|
|
|
}
|
2017-12-09 01:16:50 +08:00
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_release_tasks);
|
2017-03-23 01:25:18 +08:00
|
|
|
|
2017-06-14 23:33:32 +08:00
|
|
|
static void hisi_sas_dereg_device(struct hisi_hba *hisi_hba,
|
|
|
|
struct domain_device *device)
|
|
|
|
{
|
|
|
|
if (hisi_hba->hw->dereg_device)
|
|
|
|
hisi_hba->hw->dereg_device(hisi_hba, device);
|
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:51 +08:00
|
|
|
static void hisi_sas_dev_gone(struct domain_device *device)
|
|
|
|
{
|
|
|
|
struct hisi_sas_device *sas_dev = device->lldd_dev;
|
|
|
|
struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
|
2017-06-14 23:33:17 +08:00
|
|
|
struct device *dev = hisi_hba->dev;
|
2015-11-18 00:50:51 +08:00
|
|
|
|
2017-12-09 01:16:41 +08:00
|
|
|
dev_info(dev, "dev[%d:%x] is gone\n",
|
2015-11-18 00:50:51 +08:00
|
|
|
sas_dev->device_id, sas_dev->dev_type);
|
|
|
|
|
2017-12-09 01:16:37 +08:00
|
|
|
if (!test_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags)) {
|
|
|
|
hisi_sas_internal_task_abort(hisi_hba, device,
|
2016-08-24 19:05:48 +08:00
|
|
|
HISI_SAS_INT_ABT_DEV, 0);
|
|
|
|
|
2017-12-09 01:16:37 +08:00
|
|
|
hisi_sas_dereg_device(hisi_hba, device);
|
|
|
|
|
2018-05-31 20:50:44 +08:00
|
|
|
down(&hisi_hba->sem);
|
2017-12-09 01:16:37 +08:00
|
|
|
hisi_hba->hw->clear_itct(hisi_hba, sas_dev);
|
2018-05-31 20:50:44 +08:00
|
|
|
up(&hisi_hba->sem);
|
2017-12-09 01:16:37 +08:00
|
|
|
device->lldd_dev = NULL;
|
|
|
|
}
|
2017-06-14 23:33:32 +08:00
|
|
|
|
2017-12-09 01:16:34 +08:00
|
|
|
if (hisi_hba->hw->free_device)
|
|
|
|
hisi_hba->hw->free_device(sas_dev);
|
2015-11-18 00:50:51 +08:00
|
|
|
sas_dev->dev_type = SAS_PHY_UNUSED;
|
|
|
|
}
|
2015-11-18 00:50:49 +08:00
|
|
|
|
|
|
|
static int hisi_sas_queue_command(struct sas_task *task, gfp_t gfp_flags)
|
|
|
|
{
|
|
|
|
return hisi_sas_task_exec(task, gfp_flags, 0, NULL);
|
|
|
|
}
|
|
|
|
|
2018-05-21 18:09:13 +08:00
|
|
|
static void hisi_sas_phy_set_linkrate(struct hisi_hba *hisi_hba, int phy_no,
|
|
|
|
struct sas_phy_linkrates *r)
|
|
|
|
{
|
|
|
|
struct sas_phy_linkrates _r;
|
|
|
|
|
|
|
|
struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
|
|
|
|
struct asd_sas_phy *sas_phy = &phy->sas_phy;
|
|
|
|
enum sas_linkrate min, max;
|
|
|
|
|
|
|
|
if (r->maximum_linkrate == SAS_LINK_RATE_UNKNOWN) {
|
|
|
|
max = sas_phy->phy->maximum_linkrate;
|
|
|
|
min = r->minimum_linkrate;
|
|
|
|
} else if (r->minimum_linkrate == SAS_LINK_RATE_UNKNOWN) {
|
|
|
|
max = r->maximum_linkrate;
|
|
|
|
min = sas_phy->phy->minimum_linkrate;
|
|
|
|
} else
|
|
|
|
return;
|
|
|
|
|
|
|
|
_r.maximum_linkrate = max;
|
|
|
|
_r.minimum_linkrate = min;
|
|
|
|
|
2018-09-24 23:06:28 +08:00
|
|
|
sas_phy->phy->maximum_linkrate = max;
|
|
|
|
sas_phy->phy->minimum_linkrate = min;
|
|
|
|
|
2018-05-21 18:09:13 +08:00
|
|
|
hisi_hba->hw->phy_disable(hisi_hba, phy_no);
|
|
|
|
msleep(100);
|
|
|
|
hisi_hba->hw->phy_set_linkrate(hisi_hba, phy_no, &_r);
|
|
|
|
hisi_hba->hw->phy_start(hisi_hba, phy_no);
|
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:57 +08:00
|
|
|
static int hisi_sas_control_phy(struct asd_sas_phy *sas_phy, enum phy_func func,
|
|
|
|
void *funcdata)
|
|
|
|
{
|
|
|
|
struct sas_ha_struct *sas_ha = sas_phy->ha;
|
|
|
|
struct hisi_hba *hisi_hba = sas_ha->lldd_ha;
|
|
|
|
int phy_no = sas_phy->id;
|
|
|
|
|
|
|
|
switch (func) {
|
|
|
|
case PHY_FUNC_HARD_RESET:
|
|
|
|
hisi_hba->hw->phy_hard_reset(hisi_hba, phy_no);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PHY_FUNC_LINK_RESET:
|
2017-03-23 01:25:23 +08:00
|
|
|
hisi_hba->hw->phy_disable(hisi_hba, phy_no);
|
|
|
|
msleep(100);
|
2017-10-24 23:51:36 +08:00
|
|
|
hisi_hba->hw->phy_start(hisi_hba, phy_no);
|
2015-11-18 00:50:57 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case PHY_FUNC_DISABLE:
|
|
|
|
hisi_hba->hw->phy_disable(hisi_hba, phy_no);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PHY_FUNC_SET_LINK_RATE:
|
2018-05-21 18:09:13 +08:00
|
|
|
hisi_sas_phy_set_linkrate(hisi_hba, phy_no, funcdata);
|
2016-11-07 20:48:40 +08:00
|
|
|
break;
|
2017-08-11 00:09:29 +08:00
|
|
|
case PHY_FUNC_GET_EVENTS:
|
|
|
|
if (hisi_hba->hw->get_events) {
|
|
|
|
hisi_hba->hw->get_events(hisi_hba, phy_no);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* fallthru */
|
2015-11-18 00:50:57 +08:00
|
|
|
case PHY_FUNC_RELEASE_SPINUP_HOLD:
|
|
|
|
default:
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2015-11-18 00:50:52 +08:00
|
|
|
|
2015-11-18 00:50:56 +08:00
|
|
|
static void hisi_sas_task_done(struct sas_task *task)
|
|
|
|
{
|
2018-09-24 23:06:30 +08:00
|
|
|
del_timer(&task->slow_task->timer);
|
2015-11-18 00:50:56 +08:00
|
|
|
complete(&task->slow_task->completion);
|
|
|
|
}
|
|
|
|
|
2017-08-23 07:05:14 +08:00
|
|
|
static void hisi_sas_tmf_timedout(struct timer_list *t)
|
2015-11-18 00:50:56 +08:00
|
|
|
{
|
2017-08-23 07:05:14 +08:00
|
|
|
struct sas_task_slow *slow = from_timer(slow, t, timer);
|
|
|
|
struct sas_task *task = slow->task;
|
2017-06-14 23:33:11 +08:00
|
|
|
unsigned long flags;
|
2018-09-24 23:06:30 +08:00
|
|
|
bool is_completed = true;
|
2017-06-14 23:33:11 +08:00
|
|
|
|
|
|
|
spin_lock_irqsave(&task->task_state_lock, flags);
|
2018-09-24 23:06:30 +08:00
|
|
|
if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
|
2017-06-14 23:33:11 +08:00
|
|
|
task->task_state_flags |= SAS_TASK_STATE_ABORTED;
|
2018-09-24 23:06:30 +08:00
|
|
|
is_completed = false;
|
|
|
|
}
|
2017-06-14 23:33:11 +08:00
|
|
|
spin_unlock_irqrestore(&task->task_state_lock, flags);
|
2015-11-18 00:50:56 +08:00
|
|
|
|
2018-09-24 23:06:30 +08:00
|
|
|
if (!is_completed)
|
|
|
|
complete(&task->slow_task->completion);
|
2015-11-18 00:50:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#define TASK_TIMEOUT 20
|
|
|
|
#define TASK_RETRY 3
|
2018-03-07 20:25:09 +08:00
|
|
|
#define INTERNAL_ABORT_TIMEOUT 6
|
2015-11-18 00:50:56 +08:00
|
|
|
static int hisi_sas_exec_internal_tmf_task(struct domain_device *device,
|
|
|
|
void *parameter, u32 para_len,
|
|
|
|
struct hisi_sas_tmf_task *tmf)
|
|
|
|
{
|
|
|
|
struct hisi_sas_device *sas_dev = device->lldd_dev;
|
|
|
|
struct hisi_hba *hisi_hba = sas_dev->hisi_hba;
|
2017-06-14 23:33:17 +08:00
|
|
|
struct device *dev = hisi_hba->dev;
|
2015-11-18 00:50:56 +08:00
|
|
|
struct sas_task *task;
|
|
|
|
int res, retry;
|
|
|
|
|
|
|
|
for (retry = 0; retry < TASK_RETRY; retry++) {
|
|
|
|
task = sas_alloc_slow_task(GFP_KERNEL);
|
|
|
|
if (!task)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
task->dev = device;
|
|
|
|
task->task_proto = device->tproto;
|
|
|
|
|
2017-03-23 01:25:20 +08:00
|
|
|
if (dev_is_sata(device)) {
|
|
|
|
task->ata_task.device_control_reg_update = 1;
|
|
|
|
memcpy(&task->ata_task.fis, parameter, para_len);
|
|
|
|
} else {
|
|
|
|
memcpy(&task->ssp_task, parameter, para_len);
|
|
|
|
}
|
2015-11-18 00:50:56 +08:00
|
|
|
task->task_done = hisi_sas_task_done;
|
|
|
|
|
2017-10-23 15:40:42 +08:00
|
|
|
task->slow_task->timer.function = hisi_sas_tmf_timedout;
|
2015-11-18 00:50:56 +08:00
|
|
|
task->slow_task->timer.expires = jiffies + TASK_TIMEOUT*HZ;
|
|
|
|
add_timer(&task->slow_task->timer);
|
|
|
|
|
|
|
|
res = hisi_sas_task_exec(task, GFP_KERNEL, 1, tmf);
|
|
|
|
|
|
|
|
if (res) {
|
|
|
|
del_timer(&task->slow_task->timer);
|
|
|
|
dev_err(dev, "abort tmf: executing internal task failed: %d\n",
|
|
|
|
res);
|
|
|
|
goto ex_err;
|
|
|
|
}
|
|
|
|
|
|
|
|
wait_for_completion(&task->slow_task->completion);
|
|
|
|
res = TMF_RESP_FUNC_FAILED;
|
|
|
|
/* Even TMF timed out, return direct. */
|
|
|
|
if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
|
|
|
|
if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
|
2017-04-10 21:22:00 +08:00
|
|
|
struct hisi_sas_slot *slot = task->lldd_task;
|
|
|
|
|
2017-12-09 01:16:41 +08:00
|
|
|
dev_err(dev, "abort tmf: TMF task timeout and not done\n");
|
2018-09-24 23:06:30 +08:00
|
|
|
if (slot) {
|
2018-10-19 00:59:39 +08:00
|
|
|
struct hisi_sas_cq *cq =
|
|
|
|
&hisi_hba->cq[slot->dlvry_queue];
|
2018-09-24 23:06:30 +08:00
|
|
|
/*
|
|
|
|
* flush tasklet to avoid free'ing task
|
|
|
|
* before using task in IO completion
|
|
|
|
*/
|
|
|
|
tasklet_kill(&cq->tasklet);
|
2017-04-10 21:22:00 +08:00
|
|
|
slot->task = NULL;
|
2018-09-24 23:06:30 +08:00
|
|
|
}
|
2017-04-10 21:22:00 +08:00
|
|
|
|
2015-11-18 00:50:56 +08:00
|
|
|
goto ex_err;
|
2017-12-09 01:16:41 +08:00
|
|
|
} else
|
|
|
|
dev_err(dev, "abort tmf: TMF task timeout\n");
|
2015-11-18 00:50:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (task->task_status.resp == SAS_TASK_COMPLETE &&
|
2016-02-25 17:42:10 +08:00
|
|
|
task->task_status.stat == TMF_RESP_FUNC_COMPLETE) {
|
2015-11-18 00:50:56 +08:00
|
|
|
res = TMF_RESP_FUNC_COMPLETE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-08-24 19:05:53 +08:00
|
|
|
if (task->task_status.resp == SAS_TASK_COMPLETE &&
|
|
|
|
task->task_status.stat == TMF_RESP_FUNC_SUCC) {
|
|
|
|
res = TMF_RESP_FUNC_SUCC;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:56 +08:00
|
|
|
if (task->task_status.resp == SAS_TASK_COMPLETE &&
|
|
|
|
task->task_status.stat == SAS_DATA_UNDERRUN) {
|
|
|
|
/* no error, but return the number of bytes of
|
|
|
|
* underrun
|
|
|
|
*/
|
|
|
|
dev_warn(dev, "abort tmf: task to dev %016llx "
|
|
|
|
"resp: 0x%x sts 0x%x underrun\n",
|
|
|
|
SAS_ADDR(device->sas_addr),
|
|
|
|
task->task_status.resp,
|
|
|
|
task->task_status.stat);
|
|
|
|
res = task->task_status.residual;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (task->task_status.resp == SAS_TASK_COMPLETE &&
|
|
|
|
task->task_status.stat == SAS_DATA_OVERRUN) {
|
|
|
|
dev_warn(dev, "abort tmf: blocked task error\n");
|
|
|
|
res = -EMSGSIZE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_warn(dev, "abort tmf: task to dev "
|
|
|
|
"%016llx resp: 0x%x status 0x%x\n",
|
|
|
|
SAS_ADDR(device->sas_addr), task->task_status.resp,
|
|
|
|
task->task_status.stat);
|
|
|
|
sas_free_task(task);
|
|
|
|
task = NULL;
|
|
|
|
}
|
|
|
|
ex_err:
|
2016-11-07 20:48:34 +08:00
|
|
|
if (retry == TASK_RETRY)
|
|
|
|
dev_warn(dev, "abort tmf: executing internal task failed!\n");
|
2015-11-18 00:50:56 +08:00
|
|
|
sas_free_task(task);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2017-03-23 01:25:20 +08:00
|
|
|
static void hisi_sas_fill_ata_reset_cmd(struct ata_device *dev,
|
|
|
|
bool reset, int pmp, u8 *fis)
|
|
|
|
{
|
|
|
|
struct ata_taskfile tf;
|
|
|
|
|
|
|
|
ata_tf_init(dev, &tf);
|
|
|
|
if (reset)
|
|
|
|
tf.ctl |= ATA_SRST;
|
|
|
|
else
|
|
|
|
tf.ctl &= ~ATA_SRST;
|
|
|
|
tf.command = ATA_CMD_DEV_RESET;
|
|
|
|
ata_tf_to_fis(&tf, pmp, 0, fis);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hisi_sas_softreset_ata_disk(struct domain_device *device)
|
|
|
|
{
|
|
|
|
u8 fis[20] = {0};
|
|
|
|
struct ata_port *ap = device->sata_dev.ap;
|
|
|
|
struct ata_link *link;
|
|
|
|
int rc = TMF_RESP_FUNC_FAILED;
|
|
|
|
struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
|
2017-06-14 23:33:17 +08:00
|
|
|
struct device *dev = hisi_hba->dev;
|
2017-03-23 01:25:20 +08:00
|
|
|
int s = sizeof(struct host_to_dev_fis);
|
|
|
|
|
|
|
|
ata_for_each_link(link, ap, EDGE) {
|
|
|
|
int pmp = sata_srst_pmp(link);
|
|
|
|
|
|
|
|
hisi_sas_fill_ata_reset_cmd(link->device, 1, pmp, fis);
|
|
|
|
rc = hisi_sas_exec_internal_tmf_task(device, fis, s, NULL);
|
|
|
|
if (rc != TMF_RESP_FUNC_COMPLETE)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rc == TMF_RESP_FUNC_COMPLETE) {
|
|
|
|
ata_for_each_link(link, ap, EDGE) {
|
|
|
|
int pmp = sata_srst_pmp(link);
|
|
|
|
|
|
|
|
hisi_sas_fill_ata_reset_cmd(link->device, 0, pmp, fis);
|
|
|
|
rc = hisi_sas_exec_internal_tmf_task(device, fis,
|
|
|
|
s, NULL);
|
|
|
|
if (rc != TMF_RESP_FUNC_COMPLETE)
|
|
|
|
dev_err(dev, "ata disk de-reset failed\n");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
dev_err(dev, "ata disk reset failed\n");
|
|
|
|
}
|
|
|
|
|
2018-05-09 23:10:49 +08:00
|
|
|
if (rc == TMF_RESP_FUNC_COMPLETE)
|
2017-03-23 01:25:20 +08:00
|
|
|
hisi_sas_release_task(hisi_hba, device);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:56 +08:00
|
|
|
static int hisi_sas_debug_issue_ssp_tmf(struct domain_device *device,
|
|
|
|
u8 *lun, struct hisi_sas_tmf_task *tmf)
|
|
|
|
{
|
|
|
|
struct sas_ssp_task ssp_task;
|
|
|
|
|
|
|
|
if (!(device->tproto & SAS_PROTOCOL_SSP))
|
|
|
|
return TMF_RESP_FUNC_ESUPP;
|
|
|
|
|
|
|
|
memcpy(ssp_task.LUN, lun, 8);
|
|
|
|
|
|
|
|
return hisi_sas_exec_internal_tmf_task(device, &ssp_task,
|
|
|
|
sizeof(ssp_task), tmf);
|
|
|
|
}
|
|
|
|
|
2017-12-09 01:16:35 +08:00
|
|
|
static void hisi_sas_refresh_port_id(struct hisi_hba *hisi_hba)
|
2017-08-11 00:09:26 +08:00
|
|
|
{
|
2017-12-09 01:16:35 +08:00
|
|
|
u32 state = hisi_hba->hw->get_phys_state(hisi_hba);
|
2017-08-11 00:09:26 +08:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
|
2017-12-09 01:16:35 +08:00
|
|
|
struct hisi_sas_device *sas_dev = &hisi_hba->devices[i];
|
|
|
|
struct domain_device *device = sas_dev->sas_device;
|
|
|
|
struct asd_sas_port *sas_port;
|
|
|
|
struct hisi_sas_port *port;
|
|
|
|
struct hisi_sas_phy *phy = NULL;
|
|
|
|
struct asd_sas_phy *sas_phy;
|
|
|
|
|
2017-08-11 00:09:26 +08:00
|
|
|
if ((sas_dev->dev_type == SAS_PHY_UNUSED)
|
2017-12-09 01:16:35 +08:00
|
|
|
|| !device || !device->port)
|
2017-08-11 00:09:26 +08:00
|
|
|
continue;
|
|
|
|
|
2017-12-09 01:16:35 +08:00
|
|
|
sas_port = device->port;
|
|
|
|
port = to_hisi_sas_port(sas_port);
|
|
|
|
|
|
|
|
list_for_each_entry(sas_phy, &sas_port->phy_list, port_phy_el)
|
|
|
|
if (state & BIT(sas_phy->id)) {
|
|
|
|
phy = sas_phy->lldd_phy;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (phy) {
|
|
|
|
port->id = phy->port_id;
|
2017-08-11 00:09:26 +08:00
|
|
|
|
2017-12-09 01:16:35 +08:00
|
|
|
/* Update linkrate of directly attached device. */
|
|
|
|
if (!device->parent)
|
|
|
|
device->linkrate = phy->sas_phy.linkrate;
|
2017-08-11 00:09:26 +08:00
|
|
|
|
2017-12-09 01:16:35 +08:00
|
|
|
hisi_hba->hw->setup_itct(hisi_hba, sas_dev);
|
|
|
|
} else
|
|
|
|
port->id = 0xff;
|
2017-08-11 00:09:26 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hisi_sas_rescan_topology(struct hisi_hba *hisi_hba, u32 old_state,
|
|
|
|
u32 state)
|
|
|
|
{
|
|
|
|
struct sas_ha_struct *sas_ha = &hisi_hba->sha;
|
|
|
|
struct asd_sas_port *_sas_port = NULL;
|
|
|
|
int phy_no;
|
|
|
|
|
|
|
|
for (phy_no = 0; phy_no < hisi_hba->n_phy; phy_no++) {
|
|
|
|
struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
|
|
|
|
struct asd_sas_phy *sas_phy = &phy->sas_phy;
|
|
|
|
struct asd_sas_port *sas_port = sas_phy->port;
|
|
|
|
bool do_port_check = !!(_sas_port != sas_port);
|
|
|
|
|
|
|
|
if (!sas_phy->phy->enabled)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Report PHY state change to libsas */
|
2017-12-09 01:16:35 +08:00
|
|
|
if (state & BIT(phy_no)) {
|
|
|
|
if (do_port_check && sas_port && sas_port->port_dev) {
|
2017-08-11 00:09:26 +08:00
|
|
|
struct domain_device *dev = sas_port->port_dev;
|
|
|
|
|
|
|
|
_sas_port = sas_port;
|
|
|
|
|
|
|
|
if (DEV_IS_EXPANDER(dev->dev_type))
|
|
|
|
sas_ha->notify_port_event(sas_phy,
|
|
|
|
PORTE_BROADCAST_RCVD);
|
|
|
|
}
|
|
|
|
} else if (old_state & (1 << phy_no))
|
|
|
|
/* PHY down but was up before */
|
|
|
|
hisi_sas_phy_down(hisi_hba, phy_no, 0);
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-21 18:09:19 +08:00
|
|
|
static void hisi_sas_reset_init_all_devices(struct hisi_hba *hisi_hba)
|
|
|
|
{
|
|
|
|
struct hisi_sas_device *sas_dev;
|
|
|
|
struct domain_device *device;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
|
|
|
|
sas_dev = &hisi_hba->devices[i];
|
|
|
|
device = sas_dev->sas_device;
|
|
|
|
|
|
|
|
if ((sas_dev->dev_type == SAS_PHY_UNUSED) || !device)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
hisi_sas_init_device(device);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-21 18:09:23 +08:00
|
|
|
static void hisi_sas_send_ata_reset_each_phy(struct hisi_hba *hisi_hba,
|
|
|
|
struct asd_sas_port *sas_port,
|
|
|
|
struct domain_device *device)
|
|
|
|
{
|
|
|
|
struct hisi_sas_tmf_task tmf_task = { .force_phy = 1 };
|
|
|
|
struct ata_port *ap = device->sata_dev.ap;
|
|
|
|
struct device *dev = hisi_hba->dev;
|
|
|
|
int s = sizeof(struct host_to_dev_fis);
|
|
|
|
int rc = TMF_RESP_FUNC_FAILED;
|
|
|
|
struct asd_sas_phy *sas_phy;
|
|
|
|
struct ata_link *link;
|
|
|
|
u8 fis[20] = {0};
|
|
|
|
u32 state;
|
|
|
|
|
|
|
|
state = hisi_hba->hw->get_phys_state(hisi_hba);
|
|
|
|
list_for_each_entry(sas_phy, &sas_port->phy_list, port_phy_el) {
|
|
|
|
if (!(state & BIT(sas_phy->id)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ata_for_each_link(link, ap, EDGE) {
|
|
|
|
int pmp = sata_srst_pmp(link);
|
|
|
|
|
|
|
|
tmf_task.phy_id = sas_phy->id;
|
|
|
|
hisi_sas_fill_ata_reset_cmd(link->device, 1, pmp, fis);
|
|
|
|
rc = hisi_sas_exec_internal_tmf_task(device, fis, s,
|
|
|
|
&tmf_task);
|
|
|
|
if (rc != TMF_RESP_FUNC_COMPLETE) {
|
|
|
|
dev_err(dev, "phy%d ata reset failed rc=%d\n",
|
|
|
|
sas_phy->id, rc);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hisi_sas_terminate_stp_reject(struct hisi_hba *hisi_hba)
|
|
|
|
{
|
|
|
|
struct device *dev = hisi_hba->dev;
|
|
|
|
int port_no, rc, i;
|
|
|
|
|
|
|
|
for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
|
|
|
|
struct hisi_sas_device *sas_dev = &hisi_hba->devices[i];
|
|
|
|
struct domain_device *device = sas_dev->sas_device;
|
|
|
|
|
|
|
|
if ((sas_dev->dev_type == SAS_PHY_UNUSED) || !device)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
rc = hisi_sas_internal_task_abort(hisi_hba, device,
|
|
|
|
HISI_SAS_INT_ABT_DEV, 0);
|
|
|
|
if (rc < 0)
|
|
|
|
dev_err(dev, "STP reject: abort dev failed %d\n", rc);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (port_no = 0; port_no < hisi_hba->n_phy; port_no++) {
|
|
|
|
struct hisi_sas_port *port = &hisi_hba->port[port_no];
|
|
|
|
struct asd_sas_port *sas_port = &port->sas_port;
|
|
|
|
struct domain_device *port_dev = sas_port->port_dev;
|
|
|
|
struct domain_device *device;
|
|
|
|
|
|
|
|
if (!port_dev || !DEV_IS_EXPANDER(port_dev->dev_type))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Try to find a SATA device */
|
|
|
|
list_for_each_entry(device, &sas_port->dev_list,
|
|
|
|
dev_list_node) {
|
|
|
|
if (dev_is_sata(device)) {
|
|
|
|
hisi_sas_send_ata_reset_each_phy(hisi_hba,
|
|
|
|
sas_port,
|
|
|
|
device);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-18 22:14:28 +08:00
|
|
|
void hisi_sas_controller_reset_prepare(struct hisi_hba *hisi_hba)
|
2017-03-23 01:25:18 +08:00
|
|
|
{
|
2017-08-11 00:09:26 +08:00
|
|
|
struct Scsi_Host *shost = hisi_hba->shost;
|
2017-03-23 01:25:18 +08:00
|
|
|
|
2018-05-31 20:50:44 +08:00
|
|
|
down(&hisi_hba->sem);
|
2018-07-18 22:14:28 +08:00
|
|
|
hisi_hba->phy_state = hisi_hba->hw->get_phys_state(hisi_hba);
|
2017-03-23 01:25:18 +08:00
|
|
|
|
2017-08-11 00:09:26 +08:00
|
|
|
scsi_block_requests(shost);
|
2018-05-21 18:09:20 +08:00
|
|
|
hisi_hba->hw->wait_cmds_complete_timeout(hisi_hba, 100, 5000);
|
|
|
|
|
2018-05-02 23:56:29 +08:00
|
|
|
if (timer_pending(&hisi_hba->timer))
|
|
|
|
del_timer_sync(&hisi_hba->timer);
|
|
|
|
|
2017-08-11 00:09:26 +08:00
|
|
|
set_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags);
|
2018-07-18 22:14:28 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_controller_reset_prepare);
|
|
|
|
|
|
|
|
void hisi_sas_controller_reset_done(struct hisi_hba *hisi_hba)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = hisi_hba->shost;
|
|
|
|
u32 state;
|
2017-08-11 00:09:26 +08:00
|
|
|
|
|
|
|
/* Init and wait for PHYs to come up and all libsas event finished. */
|
|
|
|
hisi_hba->hw->phys_init(hisi_hba);
|
|
|
|
msleep(1000);
|
2017-12-09 01:16:35 +08:00
|
|
|
hisi_sas_refresh_port_id(hisi_hba);
|
2018-05-31 20:50:45 +08:00
|
|
|
clear_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags);
|
2018-05-31 20:50:44 +08:00
|
|
|
up(&hisi_hba->sem);
|
2018-05-21 18:09:23 +08:00
|
|
|
|
|
|
|
if (hisi_hba->reject_stp_links_msk)
|
|
|
|
hisi_sas_terminate_stp_reject(hisi_hba);
|
2018-05-21 18:09:19 +08:00
|
|
|
hisi_sas_reset_init_all_devices(hisi_hba);
|
2017-12-09 01:16:36 +08:00
|
|
|
scsi_unblock_requests(shost);
|
2018-05-31 20:50:45 +08:00
|
|
|
clear_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags);
|
2017-08-11 00:09:26 +08:00
|
|
|
|
|
|
|
state = hisi_hba->hw->get_phys_state(hisi_hba);
|
2018-07-18 22:14:28 +08:00
|
|
|
hisi_sas_rescan_topology(hisi_hba, hisi_hba->phy_state, state);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_controller_reset_done);
|
|
|
|
|
|
|
|
static int hisi_sas_controller_reset(struct hisi_hba *hisi_hba)
|
|
|
|
{
|
|
|
|
struct device *dev = hisi_hba->dev;
|
|
|
|
struct Scsi_Host *shost = hisi_hba->shost;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (!hisi_hba->hw->soft_reset)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (test_and_set_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
dev_info(dev, "controller resetting...\n");
|
|
|
|
hisi_sas_controller_reset_prepare(hisi_hba);
|
|
|
|
|
|
|
|
rc = hisi_hba->hw->soft_reset(hisi_hba);
|
|
|
|
if (rc) {
|
|
|
|
dev_warn(dev, "controller reset failed (%d)\n", rc);
|
|
|
|
clear_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags);
|
|
|
|
up(&hisi_hba->sem);
|
|
|
|
scsi_unblock_requests(shost);
|
|
|
|
clear_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
hisi_sas_controller_reset_done(hisi_hba);
|
2017-12-09 01:16:36 +08:00
|
|
|
dev_info(dev, "controller reset complete\n");
|
2017-03-23 01:25:18 +08:00
|
|
|
|
2018-05-31 20:50:45 +08:00
|
|
|
return 0;
|
2017-03-23 01:25:18 +08:00
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:56 +08:00
|
|
|
static int hisi_sas_abort_task(struct sas_task *task)
|
|
|
|
{
|
|
|
|
struct scsi_lun lun;
|
|
|
|
struct hisi_sas_tmf_task tmf_task;
|
|
|
|
struct domain_device *device = task->dev;
|
|
|
|
struct hisi_sas_device *sas_dev = device->lldd_dev;
|
2018-05-02 23:56:28 +08:00
|
|
|
struct hisi_hba *hisi_hba;
|
|
|
|
struct device *dev;
|
2015-11-18 00:50:56 +08:00
|
|
|
int rc = TMF_RESP_FUNC_FAILED;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2018-05-02 23:56:28 +08:00
|
|
|
if (!sas_dev)
|
2015-11-18 00:50:56 +08:00
|
|
|
return TMF_RESP_FUNC_FAILED;
|
2018-05-02 23:56:28 +08:00
|
|
|
|
|
|
|
hisi_hba = dev_to_hisi_hba(task->dev);
|
|
|
|
dev = hisi_hba->dev;
|
2015-11-18 00:50:56 +08:00
|
|
|
|
2018-05-02 23:56:25 +08:00
|
|
|
spin_lock_irqsave(&task->task_state_lock, flags);
|
2015-11-18 00:50:56 +08:00
|
|
|
if (task->task_state_flags & SAS_TASK_STATE_DONE) {
|
2018-09-24 23:06:30 +08:00
|
|
|
struct hisi_sas_slot *slot = task->lldd_task;
|
|
|
|
struct hisi_sas_cq *cq;
|
|
|
|
|
|
|
|
if (slot) {
|
|
|
|
/*
|
|
|
|
* flush tasklet to avoid free'ing task
|
|
|
|
* before using task in IO completion
|
|
|
|
*/
|
|
|
|
cq = &hisi_hba->cq[slot->dlvry_queue];
|
|
|
|
tasklet_kill(&cq->tasklet);
|
|
|
|
}
|
2018-05-02 23:56:25 +08:00
|
|
|
spin_unlock_irqrestore(&task->task_state_lock, flags);
|
2015-11-18 00:50:56 +08:00
|
|
|
rc = TMF_RESP_FUNC_COMPLETE;
|
|
|
|
goto out;
|
|
|
|
}
|
2018-05-02 23:56:25 +08:00
|
|
|
task->task_state_flags |= SAS_TASK_STATE_ABORTED;
|
|
|
|
spin_unlock_irqrestore(&task->task_state_lock, flags);
|
2015-11-18 00:50:56 +08:00
|
|
|
|
|
|
|
sas_dev->dev_status = HISI_SAS_DEV_EH;
|
|
|
|
if (task->lldd_task && task->task_proto & SAS_PROTOCOL_SSP) {
|
|
|
|
struct scsi_cmnd *cmnd = task->uldd_task;
|
|
|
|
struct hisi_sas_slot *slot = task->lldd_task;
|
2018-12-06 21:34:40 +08:00
|
|
|
u16 tag = slot->idx;
|
2017-03-23 01:25:25 +08:00
|
|
|
int rc2;
|
2015-11-18 00:50:56 +08:00
|
|
|
|
|
|
|
int_to_scsilun(cmnd->device->lun, &lun);
|
|
|
|
tmf_task.tmf = TMF_ABORT_TASK;
|
2018-12-06 21:34:40 +08:00
|
|
|
tmf_task.tag_of_task_to_be_managed = tag;
|
2015-11-18 00:50:56 +08:00
|
|
|
|
|
|
|
rc = hisi_sas_debug_issue_ssp_tmf(task->dev, lun.scsi_lun,
|
|
|
|
&tmf_task);
|
|
|
|
|
2017-03-23 01:25:25 +08:00
|
|
|
rc2 = hisi_sas_internal_task_abort(hisi_hba, device,
|
|
|
|
HISI_SAS_INT_ABT_CMD, tag);
|
scsi: hisi_sas: judge result of internal abort
Normally, hardware should ensure that internal abort timeout will never
happen. If happen, it would be an SoC failure. What's more, HW will not
process any other commands if an internal abort hasn't return CQ, and they
will time out also.
So, we should judge the result of internal abort in SCSI EH, if it is failed,
we should give up to do TMF/softreset and return failure to the upper layer
directly.
This patch do following things to achieve this:
1. When internal abort timeout happened, we set return value to -EIO in
hisi_sas_internal_task_abort().
2. If prep_abort() is not support, let hisi_sas_internal_task_abort() return
TMF_RESP_FUNC_FAILED.
3. If hisi_sas_internal_task_abort() return an negative number, it can be
thought that it not executed properly or internal abort timeout. Then we
won't do behind TMF or softreset, and return failure directly.
Signed-off-by: Xiaofei Tan <tanxiaofei@huawei.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2017-12-09 01:16:46 +08:00
|
|
|
if (rc2 < 0) {
|
|
|
|
dev_err(dev, "abort task: internal abort (%d)\n", rc2);
|
|
|
|
return TMF_RESP_FUNC_FAILED;
|
|
|
|
}
|
|
|
|
|
2017-03-23 01:25:25 +08:00
|
|
|
/*
|
|
|
|
* If the TMF finds that the IO is not in the device and also
|
|
|
|
* the internal abort does not succeed, then it is safe to
|
|
|
|
* free the slot.
|
|
|
|
* Note: if the internal abort succeeds then the slot
|
|
|
|
* will have already been completed
|
|
|
|
*/
|
|
|
|
if (rc == TMF_RESP_FUNC_COMPLETE && rc2 != TMF_RESP_FUNC_SUCC) {
|
2018-05-09 23:10:49 +08:00
|
|
|
if (task->lldd_task)
|
2017-03-23 01:25:25 +08:00
|
|
|
hisi_sas_do_release_task(hisi_hba, task, slot);
|
2015-11-18 00:50:56 +08:00
|
|
|
}
|
|
|
|
} else if (task->task_proto & SAS_PROTOCOL_SATA ||
|
|
|
|
task->task_proto & SAS_PROTOCOL_STP) {
|
|
|
|
if (task->dev->dev_type == SAS_SATA_DEV) {
|
scsi: hisi_sas: judge result of internal abort
Normally, hardware should ensure that internal abort timeout will never
happen. If happen, it would be an SoC failure. What's more, HW will not
process any other commands if an internal abort hasn't return CQ, and they
will time out also.
So, we should judge the result of internal abort in SCSI EH, if it is failed,
we should give up to do TMF/softreset and return failure to the upper layer
directly.
This patch do following things to achieve this:
1. When internal abort timeout happened, we set return value to -EIO in
hisi_sas_internal_task_abort().
2. If prep_abort() is not support, let hisi_sas_internal_task_abort() return
TMF_RESP_FUNC_FAILED.
3. If hisi_sas_internal_task_abort() return an negative number, it can be
thought that it not executed properly or internal abort timeout. Then we
won't do behind TMF or softreset, and return failure directly.
Signed-off-by: Xiaofei Tan <tanxiaofei@huawei.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2017-12-09 01:16:46 +08:00
|
|
|
rc = hisi_sas_internal_task_abort(hisi_hba, device,
|
|
|
|
HISI_SAS_INT_ABT_DEV, 0);
|
|
|
|
if (rc < 0) {
|
|
|
|
dev_err(dev, "abort task: internal abort failed\n");
|
|
|
|
goto out;
|
|
|
|
}
|
2017-06-14 23:33:32 +08:00
|
|
|
hisi_sas_dereg_device(hisi_hba, device);
|
2017-03-23 01:25:20 +08:00
|
|
|
rc = hisi_sas_softreset_ata_disk(device);
|
2015-11-18 00:50:56 +08:00
|
|
|
}
|
2017-05-23 02:00:29 +08:00
|
|
|
} else if (task->lldd_task && task->task_proto & SAS_PROTOCOL_SMP) {
|
2016-08-24 19:05:49 +08:00
|
|
|
/* SMP */
|
|
|
|
struct hisi_sas_slot *slot = task->lldd_task;
|
|
|
|
u32 tag = slot->idx;
|
2018-09-24 23:06:30 +08:00
|
|
|
struct hisi_sas_cq *cq = &hisi_hba->cq[slot->dlvry_queue];
|
2015-11-18 00:50:56 +08:00
|
|
|
|
2017-03-23 01:25:36 +08:00
|
|
|
rc = hisi_sas_internal_task_abort(hisi_hba, device,
|
|
|
|
HISI_SAS_INT_ABT_CMD, tag);
|
scsi: hisi_sas: judge result of internal abort
Normally, hardware should ensure that internal abort timeout will never
happen. If happen, it would be an SoC failure. What's more, HW will not
process any other commands if an internal abort hasn't return CQ, and they
will time out also.
So, we should judge the result of internal abort in SCSI EH, if it is failed,
we should give up to do TMF/softreset and return failure to the upper layer
directly.
This patch do following things to achieve this:
1. When internal abort timeout happened, we set return value to -EIO in
hisi_sas_internal_task_abort().
2. If prep_abort() is not support, let hisi_sas_internal_task_abort() return
TMF_RESP_FUNC_FAILED.
3. If hisi_sas_internal_task_abort() return an negative number, it can be
thought that it not executed properly or internal abort timeout. Then we
won't do behind TMF or softreset, and return failure directly.
Signed-off-by: Xiaofei Tan <tanxiaofei@huawei.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2017-12-09 01:16:46 +08:00
|
|
|
if (((rc < 0) || (rc == TMF_RESP_FUNC_FAILED)) &&
|
2018-09-24 23:06:30 +08:00
|
|
|
task->lldd_task) {
|
|
|
|
/*
|
|
|
|
* flush tasklet to avoid free'ing task
|
|
|
|
* before using task in IO completion
|
|
|
|
*/
|
|
|
|
tasklet_kill(&cq->tasklet);
|
|
|
|
slot->task = NULL;
|
|
|
|
}
|
2015-11-18 00:50:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (rc != TMF_RESP_FUNC_COMPLETE)
|
|
|
|
dev_notice(dev, "abort task: rc=%d\n", rc);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hisi_sas_abort_task_set(struct domain_device *device, u8 *lun)
|
|
|
|
{
|
2017-12-09 01:16:47 +08:00
|
|
|
struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
|
|
|
|
struct device *dev = hisi_hba->dev;
|
2015-11-18 00:50:56 +08:00
|
|
|
struct hisi_sas_tmf_task tmf_task;
|
|
|
|
int rc = TMF_RESP_FUNC_FAILED;
|
2017-12-09 01:16:47 +08:00
|
|
|
|
|
|
|
rc = hisi_sas_internal_task_abort(hisi_hba, device,
|
|
|
|
HISI_SAS_INT_ABT_DEV, 0);
|
|
|
|
if (rc < 0) {
|
|
|
|
dev_err(dev, "abort task set: internal abort rc=%d\n", rc);
|
|
|
|
return TMF_RESP_FUNC_FAILED;
|
|
|
|
}
|
|
|
|
hisi_sas_dereg_device(hisi_hba, device);
|
2015-11-18 00:50:56 +08:00
|
|
|
|
|
|
|
tmf_task.tmf = TMF_ABORT_TASK_SET;
|
|
|
|
rc = hisi_sas_debug_issue_ssp_tmf(device, lun, &tmf_task);
|
|
|
|
|
2018-05-09 23:10:49 +08:00
|
|
|
if (rc == TMF_RESP_FUNC_COMPLETE)
|
2017-12-09 01:16:47 +08:00
|
|
|
hisi_sas_release_task(hisi_hba, device);
|
|
|
|
|
2015-11-18 00:50:56 +08:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hisi_sas_clear_aca(struct domain_device *device, u8 *lun)
|
|
|
|
{
|
|
|
|
int rc = TMF_RESP_FUNC_FAILED;
|
|
|
|
struct hisi_sas_tmf_task tmf_task;
|
|
|
|
|
|
|
|
tmf_task.tmf = TMF_CLEAR_ACA;
|
|
|
|
rc = hisi_sas_debug_issue_ssp_tmf(device, lun, &tmf_task);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hisi_sas_debug_I_T_nexus_reset(struct domain_device *device)
|
|
|
|
{
|
2018-05-21 18:09:25 +08:00
|
|
|
struct sas_phy *local_phy = sas_get_local_phy(device);
|
2015-11-18 00:50:56 +08:00
|
|
|
int rc, reset_type = (device->dev_type == SAS_SATA_DEV ||
|
|
|
|
(device->tproto & SAS_PROTOCOL_STP)) ? 0 : 1;
|
2018-05-21 18:09:25 +08:00
|
|
|
struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
|
|
|
|
struct sas_ha_struct *sas_ha = &hisi_hba->sha;
|
|
|
|
struct asd_sas_phy *sas_phy = sas_ha->sas_phy[local_phy->number];
|
|
|
|
struct hisi_sas_phy *phy = container_of(sas_phy,
|
|
|
|
struct hisi_sas_phy, sas_phy);
|
|
|
|
DECLARE_COMPLETION_ONSTACK(phyreset);
|
|
|
|
|
|
|
|
if (scsi_is_sas_phy_local(local_phy)) {
|
|
|
|
phy->in_reset = 1;
|
|
|
|
phy->reset_completion = &phyreset;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = sas_phy_reset(local_phy, reset_type);
|
|
|
|
sas_put_local_phy(local_phy);
|
|
|
|
|
|
|
|
if (scsi_is_sas_phy_local(local_phy)) {
|
|
|
|
int ret = wait_for_completion_timeout(&phyreset, 2 * HZ);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&phy->lock, flags);
|
|
|
|
phy->reset_completion = NULL;
|
|
|
|
phy->in_reset = 0;
|
|
|
|
spin_unlock_irqrestore(&phy->lock, flags);
|
|
|
|
|
|
|
|
/* report PHY down if timed out */
|
|
|
|
if (!ret)
|
|
|
|
hisi_sas_phy_down(hisi_hba, sas_phy->id, 0);
|
|
|
|
} else
|
|
|
|
msleep(2000);
|
|
|
|
|
2015-11-18 00:50:56 +08:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hisi_sas_I_T_nexus_reset(struct domain_device *device)
|
|
|
|
{
|
|
|
|
struct hisi_sas_device *sas_dev = device->lldd_dev;
|
|
|
|
struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
|
scsi: hisi_sas: judge result of internal abort
Normally, hardware should ensure that internal abort timeout will never
happen. If happen, it would be an SoC failure. What's more, HW will not
process any other commands if an internal abort hasn't return CQ, and they
will time out also.
So, we should judge the result of internal abort in SCSI EH, if it is failed,
we should give up to do TMF/softreset and return failure to the upper layer
directly.
This patch do following things to achieve this:
1. When internal abort timeout happened, we set return value to -EIO in
hisi_sas_internal_task_abort().
2. If prep_abort() is not support, let hisi_sas_internal_task_abort() return
TMF_RESP_FUNC_FAILED.
3. If hisi_sas_internal_task_abort() return an negative number, it can be
thought that it not executed properly or internal abort timeout. Then we
won't do behind TMF or softreset, and return failure directly.
Signed-off-by: Xiaofei Tan <tanxiaofei@huawei.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2017-12-09 01:16:46 +08:00
|
|
|
struct device *dev = hisi_hba->dev;
|
2015-11-18 00:50:56 +08:00
|
|
|
int rc = TMF_RESP_FUNC_FAILED;
|
|
|
|
|
|
|
|
if (sas_dev->dev_status != HISI_SAS_DEV_EH)
|
|
|
|
return TMF_RESP_FUNC_FAILED;
|
|
|
|
sas_dev->dev_status = HISI_SAS_DEV_NORMAL;
|
|
|
|
|
scsi: hisi_sas: judge result of internal abort
Normally, hardware should ensure that internal abort timeout will never
happen. If happen, it would be an SoC failure. What's more, HW will not
process any other commands if an internal abort hasn't return CQ, and they
will time out also.
So, we should judge the result of internal abort in SCSI EH, if it is failed,
we should give up to do TMF/softreset and return failure to the upper layer
directly.
This patch do following things to achieve this:
1. When internal abort timeout happened, we set return value to -EIO in
hisi_sas_internal_task_abort().
2. If prep_abort() is not support, let hisi_sas_internal_task_abort() return
TMF_RESP_FUNC_FAILED.
3. If hisi_sas_internal_task_abort() return an negative number, it can be
thought that it not executed properly or internal abort timeout. Then we
won't do behind TMF or softreset, and return failure directly.
Signed-off-by: Xiaofei Tan <tanxiaofei@huawei.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2017-12-09 01:16:46 +08:00
|
|
|
rc = hisi_sas_internal_task_abort(hisi_hba, device,
|
2017-06-14 23:33:32 +08:00
|
|
|
HISI_SAS_INT_ABT_DEV, 0);
|
scsi: hisi_sas: judge result of internal abort
Normally, hardware should ensure that internal abort timeout will never
happen. If happen, it would be an SoC failure. What's more, HW will not
process any other commands if an internal abort hasn't return CQ, and they
will time out also.
So, we should judge the result of internal abort in SCSI EH, if it is failed,
we should give up to do TMF/softreset and return failure to the upper layer
directly.
This patch do following things to achieve this:
1. When internal abort timeout happened, we set return value to -EIO in
hisi_sas_internal_task_abort().
2. If prep_abort() is not support, let hisi_sas_internal_task_abort() return
TMF_RESP_FUNC_FAILED.
3. If hisi_sas_internal_task_abort() return an negative number, it can be
thought that it not executed properly or internal abort timeout. Then we
won't do behind TMF or softreset, and return failure directly.
Signed-off-by: Xiaofei Tan <tanxiaofei@huawei.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2017-12-09 01:16:46 +08:00
|
|
|
if (rc < 0) {
|
|
|
|
dev_err(dev, "I_T nexus reset: internal abort (%d)\n", rc);
|
|
|
|
return TMF_RESP_FUNC_FAILED;
|
|
|
|
}
|
2017-06-14 23:33:32 +08:00
|
|
|
hisi_sas_dereg_device(hisi_hba, device);
|
|
|
|
|
2015-11-18 00:50:56 +08:00
|
|
|
rc = hisi_sas_debug_I_T_nexus_reset(device);
|
|
|
|
|
2018-05-09 23:10:49 +08:00
|
|
|
if ((rc == TMF_RESP_FUNC_COMPLETE) || (rc == -ENODEV))
|
2017-03-23 01:25:28 +08:00
|
|
|
hisi_sas_release_task(hisi_hba, device);
|
2018-05-09 23:10:49 +08:00
|
|
|
|
2017-03-23 01:25:28 +08:00
|
|
|
return rc;
|
2015-11-18 00:50:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hisi_sas_lu_reset(struct domain_device *device, u8 *lun)
|
|
|
|
{
|
|
|
|
struct hisi_sas_device *sas_dev = device->lldd_dev;
|
|
|
|
struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
|
2017-06-14 23:33:17 +08:00
|
|
|
struct device *dev = hisi_hba->dev;
|
2015-11-18 00:50:56 +08:00
|
|
|
int rc = TMF_RESP_FUNC_FAILED;
|
|
|
|
|
|
|
|
sas_dev->dev_status = HISI_SAS_DEV_EH;
|
2017-03-23 01:25:26 +08:00
|
|
|
if (dev_is_sata(device)) {
|
|
|
|
struct sas_phy *phy;
|
|
|
|
|
|
|
|
/* Clear internal IO and then hardreset */
|
|
|
|
rc = hisi_sas_internal_task_abort(hisi_hba, device,
|
|
|
|
HISI_SAS_INT_ABT_DEV, 0);
|
scsi: hisi_sas: judge result of internal abort
Normally, hardware should ensure that internal abort timeout will never
happen. If happen, it would be an SoC failure. What's more, HW will not
process any other commands if an internal abort hasn't return CQ, and they
will time out also.
So, we should judge the result of internal abort in SCSI EH, if it is failed,
we should give up to do TMF/softreset and return failure to the upper layer
directly.
This patch do following things to achieve this:
1. When internal abort timeout happened, we set return value to -EIO in
hisi_sas_internal_task_abort().
2. If prep_abort() is not support, let hisi_sas_internal_task_abort() return
TMF_RESP_FUNC_FAILED.
3. If hisi_sas_internal_task_abort() return an negative number, it can be
thought that it not executed properly or internal abort timeout. Then we
won't do behind TMF or softreset, and return failure directly.
Signed-off-by: Xiaofei Tan <tanxiaofei@huawei.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2017-12-09 01:16:46 +08:00
|
|
|
if (rc < 0) {
|
|
|
|
dev_err(dev, "lu_reset: internal abort failed\n");
|
2017-03-23 01:25:26 +08:00
|
|
|
goto out;
|
scsi: hisi_sas: judge result of internal abort
Normally, hardware should ensure that internal abort timeout will never
happen. If happen, it would be an SoC failure. What's more, HW will not
process any other commands if an internal abort hasn't return CQ, and they
will time out also.
So, we should judge the result of internal abort in SCSI EH, if it is failed,
we should give up to do TMF/softreset and return failure to the upper layer
directly.
This patch do following things to achieve this:
1. When internal abort timeout happened, we set return value to -EIO in
hisi_sas_internal_task_abort().
2. If prep_abort() is not support, let hisi_sas_internal_task_abort() return
TMF_RESP_FUNC_FAILED.
3. If hisi_sas_internal_task_abort() return an negative number, it can be
thought that it not executed properly or internal abort timeout. Then we
won't do behind TMF or softreset, and return failure directly.
Signed-off-by: Xiaofei Tan <tanxiaofei@huawei.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2017-12-09 01:16:46 +08:00
|
|
|
}
|
2017-06-14 23:33:32 +08:00
|
|
|
hisi_sas_dereg_device(hisi_hba, device);
|
2015-11-18 00:50:56 +08:00
|
|
|
|
2017-03-23 01:25:26 +08:00
|
|
|
phy = sas_get_local_phy(device);
|
|
|
|
|
|
|
|
rc = sas_phy_reset(phy, 1);
|
|
|
|
|
2018-05-09 23:10:49 +08:00
|
|
|
if (rc == 0)
|
2017-03-23 01:25:26 +08:00
|
|
|
hisi_sas_release_task(hisi_hba, device);
|
|
|
|
sas_put_local_phy(phy);
|
|
|
|
} else {
|
|
|
|
struct hisi_sas_tmf_task tmf_task = { .tmf = TMF_LU_RESET };
|
|
|
|
|
2017-12-09 01:16:47 +08:00
|
|
|
rc = hisi_sas_internal_task_abort(hisi_hba, device,
|
|
|
|
HISI_SAS_INT_ABT_DEV, 0);
|
|
|
|
if (rc < 0) {
|
|
|
|
dev_err(dev, "lu_reset: internal abort failed\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
hisi_sas_dereg_device(hisi_hba, device);
|
|
|
|
|
2017-03-23 01:25:26 +08:00
|
|
|
rc = hisi_sas_debug_issue_ssp_tmf(device, lun, &tmf_task);
|
2018-05-09 23:10:49 +08:00
|
|
|
if (rc == TMF_RESP_FUNC_COMPLETE)
|
2017-03-23 01:25:26 +08:00
|
|
|
hisi_sas_release_task(hisi_hba, device);
|
|
|
|
}
|
|
|
|
out:
|
2017-03-23 01:25:37 +08:00
|
|
|
if (rc != TMF_RESP_FUNC_COMPLETE)
|
2017-06-14 23:33:12 +08:00
|
|
|
dev_err(dev, "lu_reset: for device[%d]:rc= %d\n",
|
2017-03-23 01:25:37 +08:00
|
|
|
sas_dev->device_id, rc);
|
2015-11-18 00:50:56 +08:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2017-03-23 01:25:35 +08:00
|
|
|
static int hisi_sas_clear_nexus_ha(struct sas_ha_struct *sas_ha)
|
|
|
|
{
|
|
|
|
struct hisi_hba *hisi_hba = sas_ha->lldd_ha;
|
2018-05-31 20:50:47 +08:00
|
|
|
struct device *dev = hisi_hba->dev;
|
2017-12-09 01:16:38 +08:00
|
|
|
HISI_SAS_DECLARE_RST_WORK_ON_STACK(r);
|
2018-05-31 20:50:47 +08:00
|
|
|
int rc, i;
|
2017-03-23 01:25:35 +08:00
|
|
|
|
2017-12-09 01:16:38 +08:00
|
|
|
queue_work(hisi_hba->wq, &r.work);
|
|
|
|
wait_for_completion(r.completion);
|
2018-05-31 20:50:47 +08:00
|
|
|
if (!r.done)
|
|
|
|
return TMF_RESP_FUNC_FAILED;
|
|
|
|
|
|
|
|
for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
|
|
|
|
struct hisi_sas_device *sas_dev = &hisi_hba->devices[i];
|
|
|
|
struct domain_device *device = sas_dev->sas_device;
|
|
|
|
|
|
|
|
if ((sas_dev->dev_type == SAS_PHY_UNUSED) || !device ||
|
|
|
|
DEV_IS_EXPANDER(device->dev_type))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
rc = hisi_sas_debug_I_T_nexus_reset(device);
|
|
|
|
if (rc != TMF_RESP_FUNC_COMPLETE)
|
|
|
|
dev_info(dev, "clear nexus ha: for device[%d] rc=%d\n",
|
|
|
|
sas_dev->device_id, rc);
|
|
|
|
}
|
|
|
|
|
|
|
|
hisi_sas_release_tasks(hisi_hba);
|
2017-12-09 01:16:38 +08:00
|
|
|
|
2018-05-31 20:50:47 +08:00
|
|
|
return TMF_RESP_FUNC_COMPLETE;
|
2017-03-23 01:25:35 +08:00
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:56 +08:00
|
|
|
static int hisi_sas_query_task(struct sas_task *task)
|
|
|
|
{
|
|
|
|
struct scsi_lun lun;
|
|
|
|
struct hisi_sas_tmf_task tmf_task;
|
|
|
|
int rc = TMF_RESP_FUNC_FAILED;
|
|
|
|
|
|
|
|
if (task->lldd_task && task->task_proto & SAS_PROTOCOL_SSP) {
|
|
|
|
struct scsi_cmnd *cmnd = task->uldd_task;
|
|
|
|
struct domain_device *device = task->dev;
|
|
|
|
struct hisi_sas_slot *slot = task->lldd_task;
|
|
|
|
u32 tag = slot->idx;
|
|
|
|
|
|
|
|
int_to_scsilun(cmnd->device->lun, &lun);
|
|
|
|
tmf_task.tmf = TMF_QUERY_TASK;
|
2018-12-06 21:34:40 +08:00
|
|
|
tmf_task.tag_of_task_to_be_managed = tag;
|
2015-11-18 00:50:56 +08:00
|
|
|
|
|
|
|
rc = hisi_sas_debug_issue_ssp_tmf(device,
|
|
|
|
lun.scsi_lun,
|
|
|
|
&tmf_task);
|
|
|
|
switch (rc) {
|
|
|
|
/* The task is still in Lun, release it then */
|
|
|
|
case TMF_RESP_FUNC_SUCC:
|
|
|
|
/* The task is not in Lun or failed, reset the phy */
|
|
|
|
case TMF_RESP_FUNC_FAILED:
|
|
|
|
case TMF_RESP_FUNC_COMPLETE:
|
|
|
|
break;
|
2016-11-07 20:48:35 +08:00
|
|
|
default:
|
|
|
|
rc = TMF_RESP_FUNC_FAILED;
|
|
|
|
break;
|
2015-11-18 00:50:56 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2016-08-24 19:05:47 +08:00
|
|
|
static int
|
2017-06-14 23:33:12 +08:00
|
|
|
hisi_sas_internal_abort_task_exec(struct hisi_hba *hisi_hba, int device_id,
|
2016-08-24 19:05:47 +08:00
|
|
|
struct sas_task *task, int abort_flag,
|
|
|
|
int task_tag)
|
|
|
|
{
|
|
|
|
struct domain_device *device = task->dev;
|
|
|
|
struct hisi_sas_device *sas_dev = device->lldd_dev;
|
2017-06-14 23:33:17 +08:00
|
|
|
struct device *dev = hisi_hba->dev;
|
2016-08-24 19:05:47 +08:00
|
|
|
struct hisi_sas_port *port;
|
|
|
|
struct hisi_sas_slot *slot;
|
2017-03-23 01:25:17 +08:00
|
|
|
struct asd_sas_port *sas_port = device->port;
|
2016-08-24 19:05:47 +08:00
|
|
|
struct hisi_sas_cmd_hdr *cmd_hdr_base;
|
2017-06-14 23:33:13 +08:00
|
|
|
struct hisi_sas_dq *dq = sas_dev->dq;
|
2016-08-24 19:05:47 +08:00
|
|
|
int dlvry_queue_slot, dlvry_queue, n_elem = 0, rc, slot_idx;
|
2018-05-09 23:10:48 +08:00
|
|
|
unsigned long flags, flags_dq = 0;
|
|
|
|
int wr_q_index;
|
2016-08-24 19:05:47 +08:00
|
|
|
|
2017-08-11 00:09:26 +08:00
|
|
|
if (unlikely(test_bit(HISI_SAS_REJECT_CMD_BIT, &hisi_hba->flags)))
|
2017-03-23 01:25:18 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2016-08-24 19:05:47 +08:00
|
|
|
if (!device->port)
|
|
|
|
return -1;
|
|
|
|
|
2017-03-23 01:25:17 +08:00
|
|
|
port = to_hisi_sas_port(sas_port);
|
2016-08-24 19:05:47 +08:00
|
|
|
|
|
|
|
/* simply get a slot and send abort command */
|
2018-09-24 23:06:33 +08:00
|
|
|
rc = hisi_sas_slot_index_alloc(hisi_hba, NULL);
|
|
|
|
if (rc < 0)
|
2016-08-24 19:05:47 +08:00
|
|
|
goto err_out;
|
2017-06-14 23:33:13 +08:00
|
|
|
|
2018-09-24 23:06:33 +08:00
|
|
|
slot_idx = rc;
|
2018-05-09 23:10:47 +08:00
|
|
|
slot = &hisi_hba->slot_info[slot_idx];
|
2018-05-09 23:10:48 +08:00
|
|
|
|
2017-06-14 23:33:13 +08:00
|
|
|
spin_lock_irqsave(&dq->lock, flags_dq);
|
2018-05-09 23:10:48 +08:00
|
|
|
wr_q_index = hisi_hba->hw->get_free_slot(hisi_hba, dq);
|
|
|
|
if (wr_q_index < 0) {
|
2018-05-09 23:10:47 +08:00
|
|
|
spin_unlock_irqrestore(&dq->lock, flags_dq);
|
2018-05-21 18:09:24 +08:00
|
|
|
rc = -EAGAIN;
|
scsi: hisi_sas: Pre-allocate slot DMA buffers
Currently the driver spends much time allocating and freeing the slot DMA
buffer for command delivery/completion. To boost the performance,
pre-allocate the buffers for all IPTT. The downside of this approach is
that we are reallocating all buffer memory upfront, so hog memory which we
may not need.
However, the current method - DMA buffer pool - also caches all buffers and
does not free them until the pool is destroyed, so is not exactly efficient
either.
On top of this, since the slot DMA buffer is slightly bigger than a 4K
page, we need to allocate 2x4K pages per buffer (for 4K page kernel), which
is quite wasteful. For 64K page size this is not such an issue.
So, for the 4K page case, in order to make memory usage more efficient,
pre-allocating larger blocks of DMA memory for the buffers can be more
efficient.
To make DMA memory usage most efficient, we would choose a single
contiguous DMA memory block, but this could use up all the DMA memory in
the system (when CMA enabled and no IOMMU), or we may just not be able to
allocate a DMA buffer large enough when no CMA or IOMMU.
To decide the block size we use the LCM (least common multiple) of the
buffer size and the page size. We roundup(64) to ensure the LCM is not too
large, even though a little memory may be wasted per block.
So, with this, the total memory requirement is about is about 17MB for 4096
max IPTT.
Previously (for 4K pages case), it would be 32MB (for all slots
allocated).
With this change, the relative increase of IOPS for bs=4K read when
PAGE_SIZE=4K and PAGE_SIZE=64K is as follows:
IODEPTH 4K PAGE_SIZE 64K PAGE_SIZE
32 56% 47%
64 53% 44%
128 64% 43%
256 67% 45%
Signed-off-by: Xiang Chen <chenxiang66@hisilicon.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2018-05-31 20:50:48 +08:00
|
|
|
goto err_out_tag;
|
2018-05-09 23:10:47 +08:00
|
|
|
}
|
2018-05-09 23:10:48 +08:00
|
|
|
list_add_tail(&slot->delivery, &dq->list);
|
|
|
|
spin_unlock_irqrestore(&dq->lock, flags_dq);
|
2016-08-24 19:05:47 +08:00
|
|
|
|
2017-06-14 23:33:13 +08:00
|
|
|
dlvry_queue = dq->id;
|
2018-05-09 23:10:48 +08:00
|
|
|
dlvry_queue_slot = wr_q_index;
|
2017-06-14 23:33:13 +08:00
|
|
|
|
2016-08-24 19:05:47 +08:00
|
|
|
slot->n_elem = n_elem;
|
|
|
|
slot->dlvry_queue = dlvry_queue;
|
|
|
|
slot->dlvry_queue_slot = dlvry_queue_slot;
|
|
|
|
cmd_hdr_base = hisi_hba->cmd_hdr[dlvry_queue];
|
|
|
|
slot->cmd_hdr = &cmd_hdr_base[dlvry_queue_slot];
|
|
|
|
slot->task = task;
|
|
|
|
slot->port = port;
|
2018-05-02 23:56:26 +08:00
|
|
|
slot->is_internal = true;
|
2016-08-24 19:05:47 +08:00
|
|
|
task->lldd_task = slot;
|
|
|
|
|
|
|
|
memset(slot->cmd_hdr, 0, sizeof(struct hisi_sas_cmd_hdr));
|
2017-08-11 00:09:35 +08:00
|
|
|
memset(hisi_sas_cmd_hdr_addr_mem(slot), 0, HISI_SAS_COMMAND_TABLE_SZ);
|
|
|
|
memset(hisi_sas_status_buf_addr_mem(slot), 0, HISI_SAS_STATUS_BUF_SZ);
|
2016-08-24 19:05:47 +08:00
|
|
|
|
2018-05-09 23:10:46 +08:00
|
|
|
hisi_sas_task_prep_abort(hisi_hba, slot, device_id,
|
2016-08-24 19:05:47 +08:00
|
|
|
abort_flag, task_tag);
|
|
|
|
|
2017-03-23 01:25:29 +08:00
|
|
|
spin_lock_irqsave(&task->task_state_lock, flags);
|
2016-08-24 19:05:47 +08:00
|
|
|
task->task_state_flags |= SAS_TASK_AT_INITIATOR;
|
2017-03-23 01:25:29 +08:00
|
|
|
spin_unlock_irqrestore(&task->task_state_lock, flags);
|
2018-07-18 22:14:32 +08:00
|
|
|
WRITE_ONCE(slot->ready, 1);
|
2017-06-14 23:33:13 +08:00
|
|
|
/* send abort command to the chip */
|
2018-05-09 23:10:48 +08:00
|
|
|
spin_lock_irqsave(&dq->lock, flags);
|
|
|
|
list_add_tail(&slot->entry, &sas_dev->list);
|
2017-06-14 23:33:13 +08:00
|
|
|
hisi_hba->hw->start_delivery(dq);
|
2018-05-09 23:10:48 +08:00
|
|
|
spin_unlock_irqrestore(&dq->lock, flags);
|
2016-08-24 19:05:47 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_out_tag:
|
|
|
|
hisi_sas_slot_index_free(hisi_hba, slot_idx);
|
|
|
|
err_out:
|
|
|
|
dev_err(dev, "internal abort task prep: failed[%d]!\n", rc);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* hisi_sas_internal_task_abort -- execute an internal
|
|
|
|
* abort command for single IO command or a device
|
|
|
|
* @hisi_hba: host controller struct
|
|
|
|
* @device: domain device
|
|
|
|
* @abort_flag: mode of operation, device or single IO
|
|
|
|
* @tag: tag of IO to be aborted (only relevant to single
|
|
|
|
* IO mode)
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
|
|
|
|
struct domain_device *device,
|
|
|
|
int abort_flag, int tag)
|
|
|
|
{
|
|
|
|
struct sas_task *task;
|
|
|
|
struct hisi_sas_device *sas_dev = device->lldd_dev;
|
2017-06-14 23:33:17 +08:00
|
|
|
struct device *dev = hisi_hba->dev;
|
2016-08-24 19:05:47 +08:00
|
|
|
int res;
|
|
|
|
|
scsi: hisi_sas: judge result of internal abort
Normally, hardware should ensure that internal abort timeout will never
happen. If happen, it would be an SoC failure. What's more, HW will not
process any other commands if an internal abort hasn't return CQ, and they
will time out also.
So, we should judge the result of internal abort in SCSI EH, if it is failed,
we should give up to do TMF/softreset and return failure to the upper layer
directly.
This patch do following things to achieve this:
1. When internal abort timeout happened, we set return value to -EIO in
hisi_sas_internal_task_abort().
2. If prep_abort() is not support, let hisi_sas_internal_task_abort() return
TMF_RESP_FUNC_FAILED.
3. If hisi_sas_internal_task_abort() return an negative number, it can be
thought that it not executed properly or internal abort timeout. Then we
won't do behind TMF or softreset, and return failure directly.
Signed-off-by: Xiaofei Tan <tanxiaofei@huawei.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2017-12-09 01:16:46 +08:00
|
|
|
/*
|
|
|
|
* The interface is not realized means this HW don't support internal
|
|
|
|
* abort, or don't need to do internal abort. Then here, we return
|
|
|
|
* TMF_RESP_FUNC_FAILED and let other steps go on, which depends that
|
|
|
|
* the internal abort has been executed and returned CQ.
|
|
|
|
*/
|
2016-08-24 19:05:47 +08:00
|
|
|
if (!hisi_hba->hw->prep_abort)
|
scsi: hisi_sas: judge result of internal abort
Normally, hardware should ensure that internal abort timeout will never
happen. If happen, it would be an SoC failure. What's more, HW will not
process any other commands if an internal abort hasn't return CQ, and they
will time out also.
So, we should judge the result of internal abort in SCSI EH, if it is failed,
we should give up to do TMF/softreset and return failure to the upper layer
directly.
This patch do following things to achieve this:
1. When internal abort timeout happened, we set return value to -EIO in
hisi_sas_internal_task_abort().
2. If prep_abort() is not support, let hisi_sas_internal_task_abort() return
TMF_RESP_FUNC_FAILED.
3. If hisi_sas_internal_task_abort() return an negative number, it can be
thought that it not executed properly or internal abort timeout. Then we
won't do behind TMF or softreset, and return failure directly.
Signed-off-by: Xiaofei Tan <tanxiaofei@huawei.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2017-12-09 01:16:46 +08:00
|
|
|
return TMF_RESP_FUNC_FAILED;
|
2016-08-24 19:05:47 +08:00
|
|
|
|
|
|
|
task = sas_alloc_slow_task(GFP_KERNEL);
|
|
|
|
if (!task)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
task->dev = device;
|
|
|
|
task->task_proto = device->tproto;
|
|
|
|
task->task_done = hisi_sas_task_done;
|
2017-10-23 15:40:42 +08:00
|
|
|
task->slow_task->timer.function = hisi_sas_tmf_timedout;
|
2018-03-07 20:25:09 +08:00
|
|
|
task->slow_task->timer.expires = jiffies + INTERNAL_ABORT_TIMEOUT*HZ;
|
2016-08-24 19:05:47 +08:00
|
|
|
add_timer(&task->slow_task->timer);
|
|
|
|
|
|
|
|
res = hisi_sas_internal_abort_task_exec(hisi_hba, sas_dev->device_id,
|
|
|
|
task, abort_flag, tag);
|
|
|
|
if (res) {
|
|
|
|
del_timer(&task->slow_task->timer);
|
|
|
|
dev_err(dev, "internal task abort: executing internal task failed: %d\n",
|
|
|
|
res);
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
wait_for_completion(&task->slow_task->completion);
|
|
|
|
res = TMF_RESP_FUNC_FAILED;
|
|
|
|
|
2017-06-14 23:33:11 +08:00
|
|
|
/* Internal abort timed out */
|
|
|
|
if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
|
|
|
|
if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
|
|
|
|
struct hisi_sas_slot *slot = task->lldd_task;
|
2018-09-24 23:06:30 +08:00
|
|
|
|
|
|
|
if (slot) {
|
2018-10-19 00:59:39 +08:00
|
|
|
struct hisi_sas_cq *cq =
|
|
|
|
&hisi_hba->cq[slot->dlvry_queue];
|
2018-09-24 23:06:30 +08:00
|
|
|
/*
|
|
|
|
* flush tasklet to avoid free'ing task
|
|
|
|
* before using task in IO completion
|
|
|
|
*/
|
|
|
|
tasklet_kill(&cq->tasklet);
|
2017-06-14 23:33:11 +08:00
|
|
|
slot->task = NULL;
|
2018-09-24 23:06:30 +08:00
|
|
|
}
|
2017-12-09 01:16:41 +08:00
|
|
|
dev_err(dev, "internal task abort: timeout and not done.\n");
|
scsi: hisi_sas: judge result of internal abort
Normally, hardware should ensure that internal abort timeout will never
happen. If happen, it would be an SoC failure. What's more, HW will not
process any other commands if an internal abort hasn't return CQ, and they
will time out also.
So, we should judge the result of internal abort in SCSI EH, if it is failed,
we should give up to do TMF/softreset and return failure to the upper layer
directly.
This patch do following things to achieve this:
1. When internal abort timeout happened, we set return value to -EIO in
hisi_sas_internal_task_abort().
2. If prep_abort() is not support, let hisi_sas_internal_task_abort() return
TMF_RESP_FUNC_FAILED.
3. If hisi_sas_internal_task_abort() return an negative number, it can be
thought that it not executed properly or internal abort timeout. Then we
won't do behind TMF or softreset, and return failure directly.
Signed-off-by: Xiaofei Tan <tanxiaofei@huawei.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2017-12-09 01:16:46 +08:00
|
|
|
res = -EIO;
|
2017-10-24 23:51:32 +08:00
|
|
|
goto exit;
|
2017-12-09 01:16:41 +08:00
|
|
|
} else
|
|
|
|
dev_err(dev, "internal task abort: timeout.\n");
|
2017-06-14 23:33:11 +08:00
|
|
|
}
|
|
|
|
|
2016-08-24 19:05:47 +08:00
|
|
|
if (task->task_status.resp == SAS_TASK_COMPLETE &&
|
|
|
|
task->task_status.stat == TMF_RESP_FUNC_COMPLETE) {
|
|
|
|
res = TMF_RESP_FUNC_COMPLETE;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2017-03-23 01:25:25 +08:00
|
|
|
if (task->task_status.resp == SAS_TASK_COMPLETE &&
|
|
|
|
task->task_status.stat == TMF_RESP_FUNC_SUCC) {
|
|
|
|
res = TMF_RESP_FUNC_SUCC;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2016-08-24 19:05:47 +08:00
|
|
|
exit:
|
2017-01-20 20:45:22 +08:00
|
|
|
dev_dbg(dev, "internal task abort: task to dev %016llx task=%p "
|
2016-08-24 19:05:47 +08:00
|
|
|
"resp: 0x%x sts 0x%x\n",
|
|
|
|
SAS_ADDR(device->sas_addr),
|
|
|
|
task,
|
|
|
|
task->task_status.resp, /* 0 is complete, -1 is undelivered */
|
|
|
|
task->task_status.stat);
|
|
|
|
sas_free_task(task);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:52 +08:00
|
|
|
static void hisi_sas_port_formed(struct asd_sas_phy *sas_phy)
|
|
|
|
{
|
|
|
|
hisi_sas_port_notify_formed(sas_phy);
|
|
|
|
}
|
|
|
|
|
2018-01-18 00:46:53 +08:00
|
|
|
static int hisi_sas_write_gpio(struct sas_ha_struct *sha, u8 reg_type,
|
|
|
|
u8 reg_index, u8 reg_count, u8 *write_data)
|
|
|
|
{
|
|
|
|
struct hisi_hba *hisi_hba = sha->lldd_ha;
|
|
|
|
|
|
|
|
if (!hisi_hba->hw->write_gpio)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
return hisi_hba->hw->write_gpio(hisi_hba, reg_type,
|
|
|
|
reg_index, reg_count, write_data);
|
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:52 +08:00
|
|
|
static void hisi_sas_phy_disconnected(struct hisi_sas_phy *phy)
|
|
|
|
{
|
|
|
|
phy->phy_attached = 0;
|
|
|
|
phy->phy_type = 0;
|
|
|
|
phy->port = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void hisi_sas_phy_down(struct hisi_hba *hisi_hba, int phy_no, int rdy)
|
|
|
|
{
|
|
|
|
struct hisi_sas_phy *phy = &hisi_hba->phy[phy_no];
|
|
|
|
struct asd_sas_phy *sas_phy = &phy->sas_phy;
|
|
|
|
struct sas_ha_struct *sas_ha = &hisi_hba->sha;
|
2018-05-21 18:09:25 +08:00
|
|
|
struct device *dev = hisi_hba->dev;
|
2015-11-18 00:50:52 +08:00
|
|
|
|
|
|
|
if (rdy) {
|
|
|
|
/* Phy down but ready */
|
|
|
|
hisi_sas_bytes_dmaed(hisi_hba, phy_no);
|
|
|
|
hisi_sas_port_notify_formed(sas_phy);
|
|
|
|
} else {
|
|
|
|
struct hisi_sas_port *port = phy->port;
|
|
|
|
|
2018-05-31 20:50:46 +08:00
|
|
|
if (test_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags) ||
|
|
|
|
phy->in_reset) {
|
2018-05-21 18:09:25 +08:00
|
|
|
dev_info(dev, "ignore flutter phy%d down\n", phy_no);
|
|
|
|
return;
|
|
|
|
}
|
2015-11-18 00:50:52 +08:00
|
|
|
/* Phy down and not ready */
|
|
|
|
sas_ha->notify_phy_event(sas_phy, PHYE_LOSS_OF_SIGNAL);
|
|
|
|
sas_phy_disconnected(sas_phy);
|
|
|
|
|
|
|
|
if (port) {
|
|
|
|
if (phy->phy_type & PORT_TYPE_SAS) {
|
|
|
|
int port_id = port->id;
|
|
|
|
|
|
|
|
if (!hisi_hba->hw->get_wideport_bitmap(hisi_hba,
|
|
|
|
port_id))
|
|
|
|
port->port_attached = 0;
|
|
|
|
} else if (phy->phy_type & PORT_TYPE_SATA)
|
|
|
|
port->port_attached = 0;
|
|
|
|
}
|
|
|
|
hisi_sas_phy_disconnected(phy);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_phy_down);
|
|
|
|
|
2017-10-24 23:51:47 +08:00
|
|
|
void hisi_sas_kill_tasklets(struct hisi_hba *hisi_hba)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < hisi_hba->queue_count; i++) {
|
|
|
|
struct hisi_sas_cq *cq = &hisi_hba->cq[i];
|
|
|
|
|
|
|
|
tasklet_kill(&cq->tasklet);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_kill_tasklets);
|
2017-03-23 01:25:18 +08:00
|
|
|
|
2017-06-14 23:33:20 +08:00
|
|
|
struct scsi_transport_template *hisi_sas_stt;
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_stt);
|
2015-11-18 00:50:30 +08:00
|
|
|
|
|
|
|
static struct sas_domain_function_template hisi_sas_transport_ops = {
|
2015-11-18 00:50:51 +08:00
|
|
|
.lldd_dev_found = hisi_sas_dev_found,
|
|
|
|
.lldd_dev_gone = hisi_sas_dev_gone,
|
2015-11-18 00:50:49 +08:00
|
|
|
.lldd_execute_task = hisi_sas_queue_command,
|
2015-11-18 00:50:57 +08:00
|
|
|
.lldd_control_phy = hisi_sas_control_phy,
|
2015-11-18 00:50:56 +08:00
|
|
|
.lldd_abort_task = hisi_sas_abort_task,
|
|
|
|
.lldd_abort_task_set = hisi_sas_abort_task_set,
|
|
|
|
.lldd_clear_aca = hisi_sas_clear_aca,
|
|
|
|
.lldd_I_T_nexus_reset = hisi_sas_I_T_nexus_reset,
|
|
|
|
.lldd_lu_reset = hisi_sas_lu_reset,
|
|
|
|
.lldd_query_task = hisi_sas_query_task,
|
2018-09-25 10:56:51 +08:00
|
|
|
.lldd_clear_nexus_ha = hisi_sas_clear_nexus_ha,
|
2015-11-18 00:50:52 +08:00
|
|
|
.lldd_port_formed = hisi_sas_port_formed,
|
2018-09-25 10:56:51 +08:00
|
|
|
.lldd_write_gpio = hisi_sas_write_gpio,
|
2015-11-18 00:50:30 +08:00
|
|
|
};
|
|
|
|
|
2017-03-23 01:25:18 +08:00
|
|
|
void hisi_sas_init_mem(struct hisi_hba *hisi_hba)
|
|
|
|
{
|
|
|
|
int i, s, max_command_entries = hisi_hba->hw->max_command_entries;
|
|
|
|
|
|
|
|
for (i = 0; i < hisi_hba->queue_count; i++) {
|
|
|
|
struct hisi_sas_cq *cq = &hisi_hba->cq[i];
|
|
|
|
struct hisi_sas_dq *dq = &hisi_hba->dq[i];
|
|
|
|
|
|
|
|
s = sizeof(struct hisi_sas_cmd_hdr) * HISI_SAS_QUEUE_SLOTS;
|
|
|
|
memset(hisi_hba->cmd_hdr[i], 0, s);
|
|
|
|
dq->wr_point = 0;
|
|
|
|
|
|
|
|
s = hisi_hba->hw->complete_hdr_size * HISI_SAS_QUEUE_SLOTS;
|
|
|
|
memset(hisi_hba->complete_hdr[i], 0, s);
|
|
|
|
cq->rd_point = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
s = sizeof(struct hisi_sas_initial_fis) * hisi_hba->n_phy;
|
|
|
|
memset(hisi_hba->initial_fis, 0, s);
|
|
|
|
|
|
|
|
s = max_command_entries * sizeof(struct hisi_sas_iost);
|
|
|
|
memset(hisi_hba->iost, 0, s);
|
|
|
|
|
|
|
|
s = max_command_entries * sizeof(struct hisi_sas_breakpoint);
|
|
|
|
memset(hisi_hba->breakpoint, 0, s);
|
|
|
|
|
2017-10-24 23:51:35 +08:00
|
|
|
s = HISI_SAS_MAX_ITCT_ENTRIES * sizeof(struct hisi_sas_sata_breakpoint);
|
2017-03-23 01:25:18 +08:00
|
|
|
memset(hisi_hba->sata_breakpoint, 0, s);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_init_mem);
|
|
|
|
|
2017-06-14 23:33:20 +08:00
|
|
|
int hisi_sas_alloc(struct hisi_hba *hisi_hba, struct Scsi_Host *shost)
|
2015-11-18 00:50:34 +08:00
|
|
|
{
|
2017-06-14 23:33:17 +08:00
|
|
|
struct device *dev = hisi_hba->dev;
|
scsi: hisi_sas: Pre-allocate slot DMA buffers
Currently the driver spends much time allocating and freeing the slot DMA
buffer for command delivery/completion. To boost the performance,
pre-allocate the buffers for all IPTT. The downside of this approach is
that we are reallocating all buffer memory upfront, so hog memory which we
may not need.
However, the current method - DMA buffer pool - also caches all buffers and
does not free them until the pool is destroyed, so is not exactly efficient
either.
On top of this, since the slot DMA buffer is slightly bigger than a 4K
page, we need to allocate 2x4K pages per buffer (for 4K page kernel), which
is quite wasteful. For 64K page size this is not such an issue.
So, for the 4K page case, in order to make memory usage more efficient,
pre-allocating larger blocks of DMA memory for the buffers can be more
efficient.
To make DMA memory usage most efficient, we would choose a single
contiguous DMA memory block, but this could use up all the DMA memory in
the system (when CMA enabled and no IOMMU), or we may just not be able to
allocate a DMA buffer large enough when no CMA or IOMMU.
To decide the block size we use the LCM (least common multiple) of the
buffer size and the page size. We roundup(64) to ensure the LCM is not too
large, even though a little memory may be wasted per block.
So, with this, the total memory requirement is about is about 17MB for 4096
max IPTT.
Previously (for 4K pages case), it would be 32MB (for all slots
allocated).
With this change, the relative increase of IOPS for bs=4K read when
PAGE_SIZE=4K and PAGE_SIZE=64K is as follows:
IODEPTH 4K PAGE_SIZE 64K PAGE_SIZE
32 56% 47%
64 53% 44%
128 64% 43%
256 67% 45%
Signed-off-by: Xiang Chen <chenxiang66@hisilicon.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2018-05-31 20:50:48 +08:00
|
|
|
int i, j, s, max_command_entries = hisi_hba->hw->max_command_entries;
|
|
|
|
int max_command_entries_ru, sz_slot_buf_ru;
|
|
|
|
int blk_cnt, slots_per_blk;
|
2015-11-18 00:50:34 +08:00
|
|
|
|
2018-05-31 20:50:44 +08:00
|
|
|
sema_init(&hisi_hba->sem, 1);
|
2015-11-18 00:50:43 +08:00
|
|
|
spin_lock_init(&hisi_hba->lock);
|
2015-11-18 00:50:42 +08:00
|
|
|
for (i = 0; i < hisi_hba->n_phy; i++) {
|
|
|
|
hisi_sas_phy_init(hisi_hba, i);
|
|
|
|
hisi_hba->port[i].port_attached = 0;
|
|
|
|
hisi_hba->port[i].id = -1;
|
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:41 +08:00
|
|
|
for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
|
|
|
|
hisi_hba->devices[i].dev_type = SAS_PHY_UNUSED;
|
|
|
|
hisi_hba->devices[i].device_id = i;
|
|
|
|
hisi_hba->devices[i].dev_status = HISI_SAS_DEV_NORMAL;
|
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:34 +08:00
|
|
|
for (i = 0; i < hisi_hba->queue_count; i++) {
|
2015-11-18 00:50:37 +08:00
|
|
|
struct hisi_sas_cq *cq = &hisi_hba->cq[i];
|
2016-09-06 23:36:12 +08:00
|
|
|
struct hisi_sas_dq *dq = &hisi_hba->dq[i];
|
2015-11-18 00:50:37 +08:00
|
|
|
|
|
|
|
/* Completion queue structure */
|
|
|
|
cq->id = i;
|
|
|
|
cq->hisi_hba = hisi_hba;
|
|
|
|
|
2016-09-06 23:36:12 +08:00
|
|
|
/* Delivery queue structure */
|
2017-12-09 01:16:32 +08:00
|
|
|
spin_lock_init(&dq->lock);
|
2018-05-09 23:10:48 +08:00
|
|
|
INIT_LIST_HEAD(&dq->list);
|
2016-09-06 23:36:12 +08:00
|
|
|
dq->id = i;
|
|
|
|
dq->hisi_hba = hisi_hba;
|
|
|
|
|
2015-11-18 00:50:34 +08:00
|
|
|
/* Delivery queue */
|
|
|
|
s = sizeof(struct hisi_sas_cmd_hdr) * HISI_SAS_QUEUE_SLOTS;
|
2018-05-31 20:50:42 +08:00
|
|
|
hisi_hba->cmd_hdr[i] = dmam_alloc_coherent(dev, s,
|
|
|
|
&hisi_hba->cmd_hdr_dma[i],
|
|
|
|
GFP_KERNEL);
|
2015-11-18 00:50:34 +08:00
|
|
|
if (!hisi_hba->cmd_hdr[i])
|
|
|
|
goto err_out;
|
|
|
|
|
|
|
|
/* Completion queue */
|
|
|
|
s = hisi_hba->hw->complete_hdr_size * HISI_SAS_QUEUE_SLOTS;
|
2018-05-31 20:50:42 +08:00
|
|
|
hisi_hba->complete_hdr[i] = dmam_alloc_coherent(dev, s,
|
|
|
|
&hisi_hba->complete_hdr_dma[i],
|
|
|
|
GFP_KERNEL);
|
2015-11-18 00:50:34 +08:00
|
|
|
if (!hisi_hba->complete_hdr[i])
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
s = HISI_SAS_MAX_ITCT_ENTRIES * sizeof(struct hisi_sas_itct);
|
2018-05-31 20:50:42 +08:00
|
|
|
hisi_hba->itct = dmam_alloc_coherent(dev, s, &hisi_hba->itct_dma,
|
|
|
|
GFP_KERNEL);
|
2015-11-18 00:50:34 +08:00
|
|
|
if (!hisi_hba->itct)
|
|
|
|
goto err_out;
|
2018-05-31 20:50:42 +08:00
|
|
|
memset(hisi_hba->itct, 0, s);
|
2015-11-18 00:50:34 +08:00
|
|
|
|
2016-01-26 02:47:03 +08:00
|
|
|
hisi_hba->slot_info = devm_kcalloc(dev, max_command_entries,
|
2015-11-18 00:50:34 +08:00
|
|
|
sizeof(struct hisi_sas_slot),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!hisi_hba->slot_info)
|
|
|
|
goto err_out;
|
|
|
|
|
scsi: hisi_sas: Pre-allocate slot DMA buffers
Currently the driver spends much time allocating and freeing the slot DMA
buffer for command delivery/completion. To boost the performance,
pre-allocate the buffers for all IPTT. The downside of this approach is
that we are reallocating all buffer memory upfront, so hog memory which we
may not need.
However, the current method - DMA buffer pool - also caches all buffers and
does not free them until the pool is destroyed, so is not exactly efficient
either.
On top of this, since the slot DMA buffer is slightly bigger than a 4K
page, we need to allocate 2x4K pages per buffer (for 4K page kernel), which
is quite wasteful. For 64K page size this is not such an issue.
So, for the 4K page case, in order to make memory usage more efficient,
pre-allocating larger blocks of DMA memory for the buffers can be more
efficient.
To make DMA memory usage most efficient, we would choose a single
contiguous DMA memory block, but this could use up all the DMA memory in
the system (when CMA enabled and no IOMMU), or we may just not be able to
allocate a DMA buffer large enough when no CMA or IOMMU.
To decide the block size we use the LCM (least common multiple) of the
buffer size and the page size. We roundup(64) to ensure the LCM is not too
large, even though a little memory may be wasted per block.
So, with this, the total memory requirement is about is about 17MB for 4096
max IPTT.
Previously (for 4K pages case), it would be 32MB (for all slots
allocated).
With this change, the relative increase of IOPS for bs=4K read when
PAGE_SIZE=4K and PAGE_SIZE=64K is as follows:
IODEPTH 4K PAGE_SIZE 64K PAGE_SIZE
32 56% 47%
64 53% 44%
128 64% 43%
256 67% 45%
Signed-off-by: Xiang Chen <chenxiang66@hisilicon.com>
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2018-05-31 20:50:48 +08:00
|
|
|
/* roundup to avoid overly large block size */
|
|
|
|
max_command_entries_ru = roundup(max_command_entries, 64);
|
|
|
|
sz_slot_buf_ru = roundup(sizeof(struct hisi_sas_slot_buf_table), 64);
|
|
|
|
s = lcm(max_command_entries_ru, sz_slot_buf_ru);
|
|
|
|
blk_cnt = (max_command_entries_ru * sz_slot_buf_ru) / s;
|
|
|
|
slots_per_blk = s / sz_slot_buf_ru;
|
|
|
|
for (i = 0; i < blk_cnt; i++) {
|
|
|
|
struct hisi_sas_slot_buf_table *buf;
|
|
|
|
dma_addr_t buf_dma;
|
|
|
|
int slot_index = i * slots_per_blk;
|
|
|
|
|
|
|
|
buf = dmam_alloc_coherent(dev, s, &buf_dma, GFP_KERNEL);
|
|
|
|
if (!buf)
|
|
|
|
goto err_out;
|
|
|
|
memset(buf, 0, s);
|
|
|
|
|
|
|
|
for (j = 0; j < slots_per_blk; j++, slot_index++) {
|
|
|
|
struct hisi_sas_slot *slot;
|
|
|
|
|
|
|
|
slot = &hisi_hba->slot_info[slot_index];
|
|
|
|
slot->buf = buf;
|
|
|
|
slot->buf_dma = buf_dma;
|
|
|
|
slot->idx = slot_index;
|
|
|
|
|
|
|
|
buf++;
|
|
|
|
buf_dma += sizeof(*buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-26 02:47:03 +08:00
|
|
|
s = max_command_entries * sizeof(struct hisi_sas_iost);
|
2018-05-31 20:50:42 +08:00
|
|
|
hisi_hba->iost = dmam_alloc_coherent(dev, s, &hisi_hba->iost_dma,
|
|
|
|
GFP_KERNEL);
|
2015-11-18 00:50:34 +08:00
|
|
|
if (!hisi_hba->iost)
|
|
|
|
goto err_out;
|
|
|
|
|
2016-01-26 02:47:03 +08:00
|
|
|
s = max_command_entries * sizeof(struct hisi_sas_breakpoint);
|
2018-05-31 20:50:42 +08:00
|
|
|
hisi_hba->breakpoint = dmam_alloc_coherent(dev, s,
|
|
|
|
&hisi_hba->breakpoint_dma,
|
|
|
|
GFP_KERNEL);
|
2015-11-18 00:50:34 +08:00
|
|
|
if (!hisi_hba->breakpoint)
|
|
|
|
goto err_out;
|
|
|
|
|
2016-01-26 02:47:03 +08:00
|
|
|
hisi_hba->slot_index_count = max_command_entries;
|
2016-09-06 23:36:15 +08:00
|
|
|
s = hisi_hba->slot_index_count / BITS_PER_BYTE;
|
2015-11-18 00:50:36 +08:00
|
|
|
hisi_hba->slot_index_tags = devm_kzalloc(dev, s, GFP_KERNEL);
|
|
|
|
if (!hisi_hba->slot_index_tags)
|
|
|
|
goto err_out;
|
|
|
|
|
2015-11-18 00:50:34 +08:00
|
|
|
s = sizeof(struct hisi_sas_initial_fis) * HISI_SAS_MAX_PHYS;
|
2018-05-31 20:50:42 +08:00
|
|
|
hisi_hba->initial_fis = dmam_alloc_coherent(dev, s,
|
|
|
|
&hisi_hba->initial_fis_dma,
|
|
|
|
GFP_KERNEL);
|
2015-11-18 00:50:34 +08:00
|
|
|
if (!hisi_hba->initial_fis)
|
|
|
|
goto err_out;
|
|
|
|
|
2017-10-24 23:51:35 +08:00
|
|
|
s = HISI_SAS_MAX_ITCT_ENTRIES * sizeof(struct hisi_sas_sata_breakpoint);
|
2018-05-31 20:50:42 +08:00
|
|
|
hisi_hba->sata_breakpoint = dmam_alloc_coherent(dev, s,
|
|
|
|
&hisi_hba->sata_breakpoint_dma,
|
|
|
|
GFP_KERNEL);
|
2015-11-18 00:50:34 +08:00
|
|
|
if (!hisi_hba->sata_breakpoint)
|
|
|
|
goto err_out;
|
2017-03-23 01:25:18 +08:00
|
|
|
hisi_sas_init_mem(hisi_hba);
|
2015-11-18 00:50:34 +08:00
|
|
|
|
2015-11-18 00:50:36 +08:00
|
|
|
hisi_sas_slot_index_init(hisi_hba);
|
2018-09-24 23:06:33 +08:00
|
|
|
hisi_hba->last_slot_index = hisi_hba->hw->max_command_entries -
|
|
|
|
HISI_SAS_RESERVED_IPTT_CNT;
|
2015-11-18 00:50:36 +08:00
|
|
|
|
2015-11-18 00:50:40 +08:00
|
|
|
hisi_hba->wq = create_singlethread_workqueue(dev_name(dev));
|
|
|
|
if (!hisi_hba->wq) {
|
|
|
|
dev_err(dev, "sas_alloc: failed to create workqueue\n");
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:34 +08:00
|
|
|
return 0;
|
|
|
|
err_out:
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2017-06-14 23:33:20 +08:00
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_alloc);
|
2015-11-18 00:50:34 +08:00
|
|
|
|
2017-06-14 23:33:20 +08:00
|
|
|
void hisi_sas_free(struct hisi_hba *hisi_hba)
|
2015-11-18 00:50:35 +08:00
|
|
|
{
|
2015-11-18 00:50:40 +08:00
|
|
|
if (hisi_hba->wq)
|
|
|
|
destroy_workqueue(hisi_hba->wq);
|
2015-11-18 00:50:35 +08:00
|
|
|
}
|
2017-06-14 23:33:20 +08:00
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_free);
|
2015-11-18 00:50:34 +08:00
|
|
|
|
2017-10-24 23:51:45 +08:00
|
|
|
void hisi_sas_rst_work_handler(struct work_struct *work)
|
2017-03-23 01:25:18 +08:00
|
|
|
{
|
|
|
|
struct hisi_hba *hisi_hba =
|
|
|
|
container_of(work, struct hisi_hba, rst_work);
|
|
|
|
|
|
|
|
hisi_sas_controller_reset(hisi_hba);
|
|
|
|
}
|
2017-10-24 23:51:45 +08:00
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_rst_work_handler);
|
2017-03-23 01:25:18 +08:00
|
|
|
|
2017-12-09 01:16:38 +08:00
|
|
|
void hisi_sas_sync_rst_work_handler(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct hisi_sas_rst *rst =
|
|
|
|
container_of(work, struct hisi_sas_rst, work);
|
|
|
|
|
|
|
|
if (!hisi_sas_controller_reset(rst->hisi_hba))
|
|
|
|
rst->done = true;
|
|
|
|
complete(rst->completion);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_sync_rst_work_handler);
|
|
|
|
|
2017-06-14 23:33:18 +08:00
|
|
|
int hisi_sas_get_fw_info(struct hisi_hba *hisi_hba)
|
2015-11-18 00:50:31 +08:00
|
|
|
{
|
2017-06-14 23:33:18 +08:00
|
|
|
struct device *dev = hisi_hba->dev;
|
|
|
|
struct platform_device *pdev = hisi_hba->platform_dev;
|
|
|
|
struct device_node *np = pdev ? pdev->dev.of_node : NULL;
|
2016-10-04 19:11:11 +08:00
|
|
|
struct clk *refclk;
|
2015-11-18 00:50:31 +08:00
|
|
|
|
2016-02-04 02:26:08 +08:00
|
|
|
if (device_property_read_u8_array(dev, "sas-addr", hisi_hba->sas_addr,
|
2017-06-14 23:33:18 +08:00
|
|
|
SAS_ADDR_SIZE)) {
|
|
|
|
dev_err(dev, "could not get property sas-addr\n");
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2015-11-18 00:50:32 +08:00
|
|
|
|
2016-02-04 02:26:08 +08:00
|
|
|
if (np) {
|
2017-06-14 23:33:18 +08:00
|
|
|
/*
|
|
|
|
* These properties are only required for platform device-based
|
|
|
|
* controller with DT firmware.
|
|
|
|
*/
|
2016-02-04 02:26:08 +08:00
|
|
|
hisi_hba->ctrl = syscon_regmap_lookup_by_phandle(np,
|
|
|
|
"hisilicon,sas-syscon");
|
2017-06-14 23:33:18 +08:00
|
|
|
if (IS_ERR(hisi_hba->ctrl)) {
|
|
|
|
dev_err(dev, "could not get syscon\n");
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2015-11-18 00:50:32 +08:00
|
|
|
|
2016-02-04 02:26:08 +08:00
|
|
|
if (device_property_read_u32(dev, "ctrl-reset-reg",
|
2017-06-14 23:33:18 +08:00
|
|
|
&hisi_hba->ctrl_reset_reg)) {
|
|
|
|
dev_err(dev,
|
|
|
|
"could not get property ctrl-reset-reg\n");
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2015-11-18 00:50:32 +08:00
|
|
|
|
2016-02-04 02:26:08 +08:00
|
|
|
if (device_property_read_u32(dev, "ctrl-reset-sts-reg",
|
2017-06-14 23:33:18 +08:00
|
|
|
&hisi_hba->ctrl_reset_sts_reg)) {
|
|
|
|
dev_err(dev,
|
|
|
|
"could not get property ctrl-reset-sts-reg\n");
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2015-11-18 00:50:32 +08:00
|
|
|
|
2016-02-04 02:26:08 +08:00
|
|
|
if (device_property_read_u32(dev, "ctrl-clock-ena-reg",
|
2017-06-14 23:33:18 +08:00
|
|
|
&hisi_hba->ctrl_clock_ena_reg)) {
|
|
|
|
dev_err(dev,
|
|
|
|
"could not get property ctrl-clock-ena-reg\n");
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2016-02-04 02:26:08 +08:00
|
|
|
}
|
|
|
|
|
2017-06-14 23:33:18 +08:00
|
|
|
refclk = devm_clk_get(dev, NULL);
|
2016-10-04 19:11:11 +08:00
|
|
|
if (IS_ERR(refclk))
|
2017-01-20 20:45:20 +08:00
|
|
|
dev_dbg(dev, "no ref clk property\n");
|
2016-10-04 19:11:11 +08:00
|
|
|
else
|
|
|
|
hisi_hba->refclk_frequency_mhz = clk_get_rate(refclk) / 1000000;
|
|
|
|
|
2017-06-14 23:33:18 +08:00
|
|
|
if (device_property_read_u32(dev, "phy-count", &hisi_hba->n_phy)) {
|
|
|
|
dev_err(dev, "could not get property phy-count\n");
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2015-11-18 00:50:32 +08:00
|
|
|
|
2016-02-04 02:26:08 +08:00
|
|
|
if (device_property_read_u32(dev, "queue-count",
|
2017-06-14 23:33:18 +08:00
|
|
|
&hisi_hba->queue_count)) {
|
|
|
|
dev_err(dev, "could not get property queue-count\n");
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_get_fw_info);
|
|
|
|
|
|
|
|
static struct Scsi_Host *hisi_sas_shost_alloc(struct platform_device *pdev,
|
|
|
|
const struct hisi_sas_hw *hw)
|
|
|
|
{
|
|
|
|
struct resource *res;
|
|
|
|
struct Scsi_Host *shost;
|
|
|
|
struct hisi_hba *hisi_hba;
|
|
|
|
struct device *dev = &pdev->dev;
|
|
|
|
|
2018-05-21 18:09:18 +08:00
|
|
|
shost = scsi_host_alloc(hw->sht, sizeof(*hisi_hba));
|
2017-06-14 23:33:18 +08:00
|
|
|
if (!shost) {
|
|
|
|
dev_err(dev, "scsi host alloc failed\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
hisi_hba = shost_priv(shost);
|
|
|
|
|
|
|
|
INIT_WORK(&hisi_hba->rst_work, hisi_sas_rst_work_handler);
|
|
|
|
hisi_hba->hw = hw;
|
|
|
|
hisi_hba->dev = dev;
|
|
|
|
hisi_hba->platform_dev = pdev;
|
|
|
|
hisi_hba->shost = shost;
|
|
|
|
SHOST_TO_SAS_HA(shost) = &hisi_hba->sha;
|
|
|
|
|
2017-08-23 07:05:14 +08:00
|
|
|
timer_setup(&hisi_hba->timer, NULL, 0);
|
2017-06-14 23:33:18 +08:00
|
|
|
|
|
|
|
if (hisi_sas_get_fw_info(hisi_hba) < 0)
|
2015-11-18 00:50:32 +08:00
|
|
|
goto err_out;
|
|
|
|
|
2016-09-06 23:36:19 +08:00
|
|
|
if (dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64)) &&
|
|
|
|
dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32))) {
|
|
|
|
dev_err(dev, "No usable DMA addressing method\n");
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:32 +08:00
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
hisi_hba->regs = devm_ioremap_resource(dev, res);
|
|
|
|
if (IS_ERR(hisi_hba->regs))
|
|
|
|
goto err_out;
|
|
|
|
|
2018-01-18 00:46:53 +08:00
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
|
|
|
|
if (res) {
|
|
|
|
hisi_hba->sgpio_regs = devm_ioremap_resource(dev, res);
|
|
|
|
if (IS_ERR(hisi_hba->sgpio_regs))
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
2015-11-18 00:50:35 +08:00
|
|
|
if (hisi_sas_alloc(hisi_hba, shost)) {
|
|
|
|
hisi_sas_free(hisi_hba);
|
2015-11-18 00:50:34 +08:00
|
|
|
goto err_out;
|
2015-11-18 00:50:35 +08:00
|
|
|
}
|
2015-11-18 00:50:34 +08:00
|
|
|
|
2015-11-18 00:50:31 +08:00
|
|
|
return shost;
|
|
|
|
err_out:
|
2017-08-11 00:09:43 +08:00
|
|
|
scsi_host_put(shost);
|
2015-11-18 00:50:31 +08:00
|
|
|
dev_err(dev, "shost alloc failed\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int hisi_sas_probe(struct platform_device *pdev,
|
2018-05-21 18:09:18 +08:00
|
|
|
const struct hisi_sas_hw *hw)
|
2015-11-18 00:50:31 +08:00
|
|
|
{
|
|
|
|
struct Scsi_Host *shost;
|
|
|
|
struct hisi_hba *hisi_hba;
|
|
|
|
struct device *dev = &pdev->dev;
|
|
|
|
struct asd_sas_phy **arr_phy;
|
|
|
|
struct asd_sas_port **arr_port;
|
|
|
|
struct sas_ha_struct *sha;
|
|
|
|
int rc, phy_nr, port_nr, i;
|
|
|
|
|
|
|
|
shost = hisi_sas_shost_alloc(pdev, hw);
|
2016-11-29 23:45:57 +08:00
|
|
|
if (!shost)
|
|
|
|
return -ENOMEM;
|
2015-11-18 00:50:31 +08:00
|
|
|
|
|
|
|
sha = SHOST_TO_SAS_HA(shost);
|
|
|
|
hisi_hba = shost_priv(shost);
|
|
|
|
platform_set_drvdata(pdev, sha);
|
2015-11-18 00:50:39 +08:00
|
|
|
|
2015-11-18 00:50:31 +08:00
|
|
|
phy_nr = port_nr = hisi_hba->n_phy;
|
|
|
|
|
|
|
|
arr_phy = devm_kcalloc(dev, phy_nr, sizeof(void *), GFP_KERNEL);
|
|
|
|
arr_port = devm_kcalloc(dev, port_nr, sizeof(void *), GFP_KERNEL);
|
2016-11-29 23:45:57 +08:00
|
|
|
if (!arr_phy || !arr_port) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto err_out_ha;
|
|
|
|
}
|
2015-11-18 00:50:31 +08:00
|
|
|
|
|
|
|
sha->sas_phy = arr_phy;
|
|
|
|
sha->sas_port = arr_port;
|
|
|
|
sha->lldd_ha = hisi_hba;
|
|
|
|
|
|
|
|
shost->transportt = hisi_sas_stt;
|
|
|
|
shost->max_id = HISI_SAS_MAX_DEVICES;
|
|
|
|
shost->max_lun = ~0;
|
|
|
|
shost->max_channel = 1;
|
|
|
|
shost->max_cmd_len = 16;
|
2018-09-24 23:06:33 +08:00
|
|
|
if (hisi_hba->hw->slot_index_alloc) {
|
|
|
|
shost->can_queue = hisi_hba->hw->max_command_entries;
|
|
|
|
shost->cmd_per_lun = hisi_hba->hw->max_command_entries;
|
|
|
|
} else {
|
|
|
|
shost->can_queue = hisi_hba->hw->max_command_entries -
|
|
|
|
HISI_SAS_RESERVED_IPTT_CNT;
|
|
|
|
shost->cmd_per_lun = hisi_hba->hw->max_command_entries -
|
|
|
|
HISI_SAS_RESERVED_IPTT_CNT;
|
|
|
|
}
|
2015-11-18 00:50:31 +08:00
|
|
|
|
|
|
|
sha->sas_ha_name = DRV_NAME;
|
2017-06-14 23:33:17 +08:00
|
|
|
sha->dev = hisi_hba->dev;
|
2015-11-18 00:50:31 +08:00
|
|
|
sha->lldd_module = THIS_MODULE;
|
|
|
|
sha->sas_addr = &hisi_hba->sas_addr[0];
|
|
|
|
sha->num_phys = hisi_hba->n_phy;
|
|
|
|
sha->core.shost = hisi_hba->shost;
|
|
|
|
|
|
|
|
for (i = 0; i < hisi_hba->n_phy; i++) {
|
|
|
|
sha->sas_phy[i] = &hisi_hba->phy[i].sas_phy;
|
|
|
|
sha->sas_port[i] = &hisi_hba->port[i].sas_port;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = scsi_add_host(shost, &pdev->dev);
|
|
|
|
if (rc)
|
|
|
|
goto err_out_ha;
|
|
|
|
|
|
|
|
rc = sas_register_ha(sha);
|
|
|
|
if (rc)
|
|
|
|
goto err_out_register_ha;
|
|
|
|
|
2017-01-20 20:45:23 +08:00
|
|
|
rc = hisi_hba->hw->hw_init(hisi_hba);
|
|
|
|
if (rc)
|
|
|
|
goto err_out_register_ha;
|
|
|
|
|
2015-11-18 00:50:31 +08:00
|
|
|
scsi_scan_host(shost);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_out_register_ha:
|
|
|
|
scsi_remove_host(shost);
|
|
|
|
err_out_ha:
|
2016-11-29 23:45:57 +08:00
|
|
|
hisi_sas_free(hisi_hba);
|
2017-08-11 00:09:43 +08:00
|
|
|
scsi_host_put(shost);
|
2015-11-18 00:50:31 +08:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_probe);
|
|
|
|
|
2015-11-18 00:50:35 +08:00
|
|
|
int hisi_sas_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct sas_ha_struct *sha = platform_get_drvdata(pdev);
|
|
|
|
struct hisi_hba *hisi_hba = sha->lldd_ha;
|
2016-11-29 23:45:57 +08:00
|
|
|
struct Scsi_Host *shost = sha->core.shost;
|
2015-11-18 00:50:35 +08:00
|
|
|
|
2018-03-24 00:05:10 +08:00
|
|
|
if (timer_pending(&hisi_hba->timer))
|
|
|
|
del_timer(&hisi_hba->timer);
|
|
|
|
|
2015-11-18 00:50:35 +08:00
|
|
|
sas_unregister_ha(sha);
|
|
|
|
sas_remove_host(sha->core.shost);
|
|
|
|
|
|
|
|
hisi_sas_free(hisi_hba);
|
2017-08-11 00:09:43 +08:00
|
|
|
scsi_host_put(shost);
|
2015-11-18 00:50:35 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hisi_sas_remove);
|
|
|
|
|
2015-11-18 00:50:30 +08:00
|
|
|
static __init int hisi_sas_init(void)
|
|
|
|
{
|
|
|
|
hisi_sas_stt = sas_domain_attach_transport(&hisi_sas_transport_ops);
|
|
|
|
if (!hisi_sas_stt)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __exit void hisi_sas_exit(void)
|
|
|
|
{
|
|
|
|
sas_release_transport(hisi_sas_stt);
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(hisi_sas_init);
|
|
|
|
module_exit(hisi_sas_exit);
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_AUTHOR("John Garry <john.garry@huawei.com>");
|
|
|
|
MODULE_DESCRIPTION("HISILICON SAS controller driver");
|
|
|
|
MODULE_ALIAS("platform:" DRV_NAME);
|