mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-06 10:56:38 +07:00
26780d9e12
This is a new driver for ATTO Technology's ExpressSAS series of hardware RAID adapters. It supports the following adapters: - ExpressSAS R60F - ExpressSAS R680 - ExpressSAS R608 - ExpressSAS R644 Signed-off-by: Bradley Grove <bgrove@attotech.com> Signed-off-by: James Bottomley <JBottomley@Parallels.com>
881 lines
23 KiB
C
881 lines
23 KiB
C
/*
|
|
* linux/drivers/scsi/esas2r/esas2r_io.c
|
|
* For use with ATTO ExpressSAS R6xx SAS/SATA RAID controllers
|
|
*
|
|
* Copyright (c) 2001-2013 ATTO Technology, Inc.
|
|
* (mailto:linuxdrivers@attotech.com)mpt3sas/mpt3sas_trigger_diag.
|
|
*
|
|
* 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.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* NO WARRANTY
|
|
* THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
|
|
* CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
|
|
* LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
|
|
* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
|
|
* solely responsible for determining the appropriateness of using and
|
|
* distributing the Program and assumes all risks associated with its
|
|
* exercise of rights under this Agreement, including but not limited to
|
|
* the risks and costs of program errors, damage to or loss of data,
|
|
* programs or equipment, and unavailability or interruption of operations.
|
|
*
|
|
* DISCLAIMER OF LIABILITY
|
|
* NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
|
|
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
|
|
* USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
|
|
* HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
|
* USA.
|
|
*/
|
|
|
|
#include "esas2r.h"
|
|
|
|
void esas2r_start_request(struct esas2r_adapter *a, struct esas2r_request *rq)
|
|
{
|
|
struct esas2r_target *t = NULL;
|
|
struct esas2r_request *startrq = rq;
|
|
unsigned long flags;
|
|
|
|
if (unlikely(a->flags & (AF_DEGRADED_MODE | AF_POWER_DOWN))) {
|
|
if (rq->vrq->scsi.function == VDA_FUNC_SCSI)
|
|
rq->req_stat = RS_SEL2;
|
|
else
|
|
rq->req_stat = RS_DEGRADED;
|
|
} else if (likely(rq->vrq->scsi.function == VDA_FUNC_SCSI)) {
|
|
t = a->targetdb + rq->target_id;
|
|
|
|
if (unlikely(t >= a->targetdb_end
|
|
|| !(t->flags & TF_USED))) {
|
|
rq->req_stat = RS_SEL;
|
|
} else {
|
|
/* copy in the target ID. */
|
|
rq->vrq->scsi.target_id = cpu_to_le16(t->virt_targ_id);
|
|
|
|
/*
|
|
* Test if we want to report RS_SEL for missing target.
|
|
* Note that if AF_DISC_PENDING is set than this will
|
|
* go on the defer queue.
|
|
*/
|
|
if (unlikely(t->target_state != TS_PRESENT
|
|
&& !(a->flags & AF_DISC_PENDING)))
|
|
rq->req_stat = RS_SEL;
|
|
}
|
|
}
|
|
|
|
if (unlikely(rq->req_stat != RS_PENDING)) {
|
|
esas2r_complete_request(a, rq);
|
|
return;
|
|
}
|
|
|
|
esas2r_trace("rq=%p", rq);
|
|
esas2r_trace("rq->vrq->scsi.handle=%x", rq->vrq->scsi.handle);
|
|
|
|
if (rq->vrq->scsi.function == VDA_FUNC_SCSI) {
|
|
esas2r_trace("rq->target_id=%d", rq->target_id);
|
|
esas2r_trace("rq->vrq->scsi.flags=%x", rq->vrq->scsi.flags);
|
|
}
|
|
|
|
spin_lock_irqsave(&a->queue_lock, flags);
|
|
|
|
if (likely(list_empty(&a->defer_list) &&
|
|
!(a->flags &
|
|
(AF_CHPRST_PENDING | AF_FLASHING | AF_DISC_PENDING))))
|
|
esas2r_local_start_request(a, startrq);
|
|
else
|
|
list_add_tail(&startrq->req_list, &a->defer_list);
|
|
|
|
spin_unlock_irqrestore(&a->queue_lock, flags);
|
|
}
|
|
|
|
/*
|
|
* Starts the specified request. all requests have RS_PENDING set when this
|
|
* routine is called. The caller is usually esas2r_start_request, but
|
|
* esas2r_do_deferred_processes will start request that are deferred.
|
|
*
|
|
* The caller must ensure that requests can be started.
|
|
*
|
|
* esas2r_start_request will defer a request if there are already requests
|
|
* waiting or there is a chip reset pending. once the reset condition clears,
|
|
* esas2r_do_deferred_processes will call this function to start the request.
|
|
*
|
|
* When a request is started, it is placed on the active list and queued to
|
|
* the controller.
|
|
*/
|
|
void esas2r_local_start_request(struct esas2r_adapter *a,
|
|
struct esas2r_request *rq)
|
|
{
|
|
esas2r_trace_enter();
|
|
esas2r_trace("rq=%p", rq);
|
|
esas2r_trace("rq->vrq:%p", rq->vrq);
|
|
esas2r_trace("rq->vrq_md->phys_addr:%x", rq->vrq_md->phys_addr);
|
|
|
|
if (unlikely(rq->vrq->scsi.function == VDA_FUNC_FLASH
|
|
&& rq->vrq->flash.sub_func == VDA_FLASH_COMMIT))
|
|
esas2r_lock_set_flags(&a->flags, AF_FLASHING);
|
|
|
|
list_add_tail(&rq->req_list, &a->active_list);
|
|
esas2r_start_vda_request(a, rq);
|
|
esas2r_trace_exit();
|
|
return;
|
|
}
|
|
|
|
void esas2r_start_vda_request(struct esas2r_adapter *a,
|
|
struct esas2r_request *rq)
|
|
{
|
|
struct esas2r_inbound_list_source_entry *element;
|
|
u32 dw;
|
|
|
|
rq->req_stat = RS_STARTED;
|
|
/*
|
|
* Calculate the inbound list entry location and the current state of
|
|
* toggle bit.
|
|
*/
|
|
a->last_write++;
|
|
if (a->last_write >= a->list_size) {
|
|
a->last_write = 0;
|
|
/* update the toggle bit */
|
|
if (a->flags & AF_COMM_LIST_TOGGLE)
|
|
esas2r_lock_clear_flags(&a->flags,
|
|
AF_COMM_LIST_TOGGLE);
|
|
else
|
|
esas2r_lock_set_flags(&a->flags, AF_COMM_LIST_TOGGLE);
|
|
}
|
|
|
|
element =
|
|
(struct esas2r_inbound_list_source_entry *)a->inbound_list_md.
|
|
virt_addr
|
|
+ a->last_write;
|
|
|
|
/* Set the VDA request size if it was never modified */
|
|
if (rq->vda_req_sz == RQ_SIZE_DEFAULT)
|
|
rq->vda_req_sz = (u16)(a->max_vdareq_size / sizeof(u32));
|
|
|
|
element->address = cpu_to_le64(rq->vrq_md->phys_addr);
|
|
element->length = cpu_to_le32(rq->vda_req_sz);
|
|
|
|
/* Update the write pointer */
|
|
dw = a->last_write;
|
|
|
|
if (a->flags & AF_COMM_LIST_TOGGLE)
|
|
dw |= MU_ILW_TOGGLE;
|
|
|
|
esas2r_trace("rq->vrq->scsi.handle:%x", rq->vrq->scsi.handle);
|
|
esas2r_trace("dw:%x", dw);
|
|
esas2r_trace("rq->vda_req_sz:%x", rq->vda_req_sz);
|
|
esas2r_write_register_dword(a, MU_IN_LIST_WRITE, dw);
|
|
}
|
|
|
|
/*
|
|
* Build the scatter/gather list for an I/O request according to the
|
|
* specifications placed in the s/g context. The caller must initialize
|
|
* context prior to the initial call by calling esas2r_sgc_init().
|
|
*/
|
|
bool esas2r_build_sg_list_sge(struct esas2r_adapter *a,
|
|
struct esas2r_sg_context *sgc)
|
|
{
|
|
struct esas2r_request *rq = sgc->first_req;
|
|
union atto_vda_req *vrq = rq->vrq;
|
|
|
|
while (sgc->length) {
|
|
u32 rem = 0;
|
|
u64 addr;
|
|
u32 len;
|
|
|
|
len = (*sgc->get_phys_addr)(sgc, &addr);
|
|
|
|
if (unlikely(len == 0))
|
|
return false;
|
|
|
|
/* if current length is more than what's left, stop there */
|
|
if (unlikely(len > sgc->length))
|
|
len = sgc->length;
|
|
|
|
another_entry:
|
|
/* limit to a round number less than the maximum length */
|
|
if (len > SGE_LEN_MAX) {
|
|
/*
|
|
* Save the remainder of the split. Whenever we limit
|
|
* an entry we come back around to build entries out
|
|
* of the leftover. We do this to prevent multiple
|
|
* calls to the get_phys_addr() function for an SGE
|
|
* that is too large.
|
|
*/
|
|
rem = len - SGE_LEN_MAX;
|
|
len = SGE_LEN_MAX;
|
|
}
|
|
|
|
/* See if we need to allocate a new SGL */
|
|
if (unlikely(sgc->sge.a64.curr > sgc->sge.a64.limit)) {
|
|
u8 sgelen;
|
|
struct esas2r_mem_desc *sgl;
|
|
|
|
/*
|
|
* If no SGls are available, return failure. The
|
|
* caller can call us later with the current context
|
|
* to pick up here.
|
|
*/
|
|
sgl = esas2r_alloc_sgl(a);
|
|
|
|
if (unlikely(sgl == NULL))
|
|
return false;
|
|
|
|
/* Calculate the length of the last SGE filled in */
|
|
sgelen = (u8)((u8 *)sgc->sge.a64.curr
|
|
- (u8 *)sgc->sge.a64.last);
|
|
|
|
/*
|
|
* Copy the last SGE filled in to the first entry of
|
|
* the new SGL to make room for the chain entry.
|
|
*/
|
|
memcpy(sgl->virt_addr, sgc->sge.a64.last, sgelen);
|
|
|
|
/* Figure out the new curr pointer in the new segment */
|
|
sgc->sge.a64.curr =
|
|
(struct atto_vda_sge *)((u8 *)sgl->virt_addr +
|
|
sgelen);
|
|
|
|
/* Set the limit pointer and build the chain entry */
|
|
sgc->sge.a64.limit =
|
|
(struct atto_vda_sge *)((u8 *)sgl->virt_addr
|
|
+ sgl_page_size
|
|
- sizeof(struct
|
|
atto_vda_sge));
|
|
sgc->sge.a64.last->length = cpu_to_le32(
|
|
SGE_CHAIN | SGE_ADDR_64);
|
|
sgc->sge.a64.last->address =
|
|
cpu_to_le64(sgl->phys_addr);
|
|
|
|
/*
|
|
* Now, if there was a previous chain entry, then
|
|
* update it to contain the length of this segment
|
|
* and size of this chain. otherwise this is the
|
|
* first SGL, so set the chain_offset in the request.
|
|
*/
|
|
if (sgc->sge.a64.chain) {
|
|
sgc->sge.a64.chain->length |=
|
|
cpu_to_le32(
|
|
((u8 *)(sgc->sge.a64.
|
|
last + 1)
|
|
- (u8 *)rq->sg_table->
|
|
virt_addr)
|
|
+ sizeof(struct atto_vda_sge) *
|
|
LOBIT(SGE_CHAIN_SZ));
|
|
} else {
|
|
vrq->scsi.chain_offset = (u8)
|
|
((u8 *)sgc->
|
|
sge.a64.last -
|
|
(u8 *)vrq);
|
|
|
|
/*
|
|
* This is the first SGL, so set the
|
|
* chain_offset and the VDA request size in
|
|
* the request.
|
|
*/
|
|
rq->vda_req_sz =
|
|
(vrq->scsi.chain_offset +
|
|
sizeof(struct atto_vda_sge) +
|
|
3)
|
|
/ sizeof(u32);
|
|
}
|
|
|
|
/*
|
|
* Remember this so when we get a new SGL filled in we
|
|
* can update the length of this chain entry.
|
|
*/
|
|
sgc->sge.a64.chain = sgc->sge.a64.last;
|
|
|
|
/* Now link the new SGL onto the primary request. */
|
|
list_add(&sgl->next_desc, &rq->sg_table_head);
|
|
}
|
|
|
|
/* Update last one filled in */
|
|
sgc->sge.a64.last = sgc->sge.a64.curr;
|
|
|
|
/* Build the new SGE and update the S/G context */
|
|
sgc->sge.a64.curr->length = cpu_to_le32(SGE_ADDR_64 | len);
|
|
sgc->sge.a64.curr->address = cpu_to_le32(addr);
|
|
sgc->sge.a64.curr++;
|
|
sgc->cur_offset += len;
|
|
sgc->length -= len;
|
|
|
|
/*
|
|
* Check if we previously split an entry. If so we have to
|
|
* pick up where we left off.
|
|
*/
|
|
if (rem) {
|
|
addr += len;
|
|
len = rem;
|
|
rem = 0;
|
|
goto another_entry;
|
|
}
|
|
}
|
|
|
|
/* Mark the end of the SGL */
|
|
sgc->sge.a64.last->length |= cpu_to_le32(SGE_LAST);
|
|
|
|
/*
|
|
* If there was a previous chain entry, update the length to indicate
|
|
* the length of this last segment.
|
|
*/
|
|
if (sgc->sge.a64.chain) {
|
|
sgc->sge.a64.chain->length |= cpu_to_le32(
|
|
((u8 *)(sgc->sge.a64.curr) -
|
|
(u8 *)rq->sg_table->virt_addr));
|
|
} else {
|
|
u16 reqsize;
|
|
|
|
/*
|
|
* The entire VDA request was not used so lets
|
|
* set the size of the VDA request to be DMA'd
|
|
*/
|
|
reqsize =
|
|
((u16)((u8 *)sgc->sge.a64.last - (u8 *)vrq)
|
|
+ sizeof(struct atto_vda_sge) + 3) / sizeof(u32);
|
|
|
|
/*
|
|
* Only update the request size if it is bigger than what is
|
|
* already there. We can come in here twice for some management
|
|
* commands.
|
|
*/
|
|
if (reqsize > rq->vda_req_sz)
|
|
rq->vda_req_sz = reqsize;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
* Create PRD list for each I-block consumed by the command. This routine
|
|
* determines how much data is required from each I-block being consumed
|
|
* by the command. The first and last I-blocks can be partials and all of
|
|
* the I-blocks in between are for a full I-block of data.
|
|
*
|
|
* The interleave size is used to determine the number of bytes in the 1st
|
|
* I-block and the remaining I-blocks are what remeains.
|
|
*/
|
|
static bool esas2r_build_prd_iblk(struct esas2r_adapter *a,
|
|
struct esas2r_sg_context *sgc)
|
|
{
|
|
struct esas2r_request *rq = sgc->first_req;
|
|
u64 addr;
|
|
u32 len;
|
|
struct esas2r_mem_desc *sgl;
|
|
u32 numchain = 1;
|
|
u32 rem = 0;
|
|
|
|
while (sgc->length) {
|
|
/* Get the next address/length pair */
|
|
|
|
len = (*sgc->get_phys_addr)(sgc, &addr);
|
|
|
|
if (unlikely(len == 0))
|
|
return false;
|
|
|
|
/* If current length is more than what's left, stop there */
|
|
|
|
if (unlikely(len > sgc->length))
|
|
len = sgc->length;
|
|
|
|
another_entry:
|
|
/* Limit to a round number less than the maximum length */
|
|
|
|
if (len > PRD_LEN_MAX) {
|
|
/*
|
|
* Save the remainder of the split. whenever we limit
|
|
* an entry we come back around to build entries out
|
|
* of the leftover. We do this to prevent multiple
|
|
* calls to the get_phys_addr() function for an SGE
|
|
* that is too large.
|
|
*/
|
|
rem = len - PRD_LEN_MAX;
|
|
len = PRD_LEN_MAX;
|
|
}
|
|
|
|
/* See if we need to allocate a new SGL */
|
|
if (sgc->sge.prd.sge_cnt == 0) {
|
|
if (len == sgc->length) {
|
|
/*
|
|
* We only have 1 PRD entry left.
|
|
* It can be placed where the chain
|
|
* entry would have gone
|
|
*/
|
|
|
|
/* Build the simple SGE */
|
|
sgc->sge.prd.curr->ctl_len = cpu_to_le32(
|
|
PRD_DATA | len);
|
|
sgc->sge.prd.curr->address = cpu_to_le64(addr);
|
|
|
|
/* Adjust length related fields */
|
|
sgc->cur_offset += len;
|
|
sgc->length -= len;
|
|
|
|
/* We use the reserved chain entry for data */
|
|
numchain = 0;
|
|
|
|
break;
|
|
}
|
|
|
|
if (sgc->sge.prd.chain) {
|
|
/*
|
|
* Fill # of entries of current SGL in previous
|
|
* chain the length of this current SGL may not
|
|
* full.
|
|
*/
|
|
|
|
sgc->sge.prd.chain->ctl_len |= cpu_to_le32(
|
|
sgc->sge.prd.sgl_max_cnt);
|
|
}
|
|
|
|
/*
|
|
* If no SGls are available, return failure. The
|
|
* caller can call us later with the current context
|
|
* to pick up here.
|
|
*/
|
|
|
|
sgl = esas2r_alloc_sgl(a);
|
|
|
|
if (unlikely(sgl == NULL))
|
|
return false;
|
|
|
|
/*
|
|
* Link the new SGL onto the chain
|
|
* They are in reverse order
|
|
*/
|
|
list_add(&sgl->next_desc, &rq->sg_table_head);
|
|
|
|
/*
|
|
* An SGL was just filled in and we are starting
|
|
* a new SGL. Prime the chain of the ending SGL with
|
|
* info that points to the new SGL. The length gets
|
|
* filled in when the new SGL is filled or ended
|
|
*/
|
|
|
|
sgc->sge.prd.chain = sgc->sge.prd.curr;
|
|
|
|
sgc->sge.prd.chain->ctl_len = cpu_to_le32(PRD_CHAIN);
|
|
sgc->sge.prd.chain->address =
|
|
cpu_to_le64(sgl->phys_addr);
|
|
|
|
/*
|
|
* Start a new segment.
|
|
* Take one away and save for chain SGE
|
|
*/
|
|
|
|
sgc->sge.prd.curr =
|
|
(struct atto_physical_region_description *)sgl
|
|
->
|
|
virt_addr;
|
|
sgc->sge.prd.sge_cnt = sgc->sge.prd.sgl_max_cnt - 1;
|
|
}
|
|
|
|
sgc->sge.prd.sge_cnt--;
|
|
/* Build the simple SGE */
|
|
sgc->sge.prd.curr->ctl_len = cpu_to_le32(PRD_DATA | len);
|
|
sgc->sge.prd.curr->address = cpu_to_le64(addr);
|
|
|
|
/* Used another element. Point to the next one */
|
|
|
|
sgc->sge.prd.curr++;
|
|
|
|
/* Adjust length related fields */
|
|
|
|
sgc->cur_offset += len;
|
|
sgc->length -= len;
|
|
|
|
/*
|
|
* Check if we previously split an entry. If so we have to
|
|
* pick up where we left off.
|
|
*/
|
|
|
|
if (rem) {
|
|
addr += len;
|
|
len = rem;
|
|
rem = 0;
|
|
goto another_entry;
|
|
}
|
|
}
|
|
|
|
if (!list_empty(&rq->sg_table_head)) {
|
|
if (sgc->sge.prd.chain) {
|
|
sgc->sge.prd.chain->ctl_len |=
|
|
cpu_to_le32(sgc->sge.prd.sgl_max_cnt
|
|
- sgc->sge.prd.sge_cnt
|
|
- numchain);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool esas2r_build_sg_list_prd(struct esas2r_adapter *a,
|
|
struct esas2r_sg_context *sgc)
|
|
{
|
|
struct esas2r_request *rq = sgc->first_req;
|
|
u32 len = sgc->length;
|
|
struct esas2r_target *t = a->targetdb + rq->target_id;
|
|
u8 is_i_o = 0;
|
|
u16 reqsize;
|
|
struct atto_physical_region_description *curr_iblk_chn;
|
|
u8 *cdb = (u8 *)&rq->vrq->scsi.cdb[0];
|
|
|
|
/*
|
|
* extract LBA from command so we can determine
|
|
* the I-Block boundary
|
|
*/
|
|
|
|
if (rq->vrq->scsi.function == VDA_FUNC_SCSI
|
|
&& t->target_state == TS_PRESENT
|
|
&& !(t->flags & TF_PASS_THRU)) {
|
|
u32 lbalo = 0;
|
|
|
|
switch (rq->vrq->scsi.cdb[0]) {
|
|
case READ_16:
|
|
case WRITE_16:
|
|
{
|
|
lbalo =
|
|
MAKEDWORD(MAKEWORD(cdb[9],
|
|
cdb[8]),
|
|
MAKEWORD(cdb[7],
|
|
cdb[6]));
|
|
is_i_o = 1;
|
|
break;
|
|
}
|
|
|
|
case READ_12:
|
|
case WRITE_12:
|
|
case READ_10:
|
|
case WRITE_10:
|
|
{
|
|
lbalo =
|
|
MAKEDWORD(MAKEWORD(cdb[5],
|
|
cdb[4]),
|
|
MAKEWORD(cdb[3],
|
|
cdb[2]));
|
|
is_i_o = 1;
|
|
break;
|
|
}
|
|
|
|
case READ_6:
|
|
case WRITE_6:
|
|
{
|
|
lbalo =
|
|
MAKEDWORD(MAKEWORD(cdb[3],
|
|
cdb[2]),
|
|
MAKEWORD(cdb[1] & 0x1F,
|
|
0));
|
|
is_i_o = 1;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (is_i_o) {
|
|
u32 startlba;
|
|
|
|
rq->vrq->scsi.iblk_cnt_prd = 0;
|
|
|
|
/* Determine size of 1st I-block PRD list */
|
|
startlba = t->inter_block - (lbalo & (t->inter_block -
|
|
1));
|
|
sgc->length = startlba * t->block_size;
|
|
|
|
/* Chk if the 1st iblk chain starts at base of Iblock */
|
|
if ((lbalo & (t->inter_block - 1)) == 0)
|
|
rq->flags |= RF_1ST_IBLK_BASE;
|
|
|
|
if (sgc->length > len)
|
|
sgc->length = len;
|
|
} else {
|
|
sgc->length = len;
|
|
}
|
|
} else {
|
|
sgc->length = len;
|
|
}
|
|
|
|
/* get our starting chain address */
|
|
|
|
curr_iblk_chn =
|
|
(struct atto_physical_region_description *)sgc->sge.a64.curr;
|
|
|
|
sgc->sge.prd.sgl_max_cnt = sgl_page_size /
|
|
sizeof(struct
|
|
atto_physical_region_description);
|
|
|
|
/* create all of the I-block PRD lists */
|
|
|
|
while (len) {
|
|
sgc->sge.prd.sge_cnt = 0;
|
|
sgc->sge.prd.chain = NULL;
|
|
sgc->sge.prd.curr = curr_iblk_chn;
|
|
|
|
/* increment to next I-Block */
|
|
|
|
len -= sgc->length;
|
|
|
|
/* go build the next I-Block PRD list */
|
|
|
|
if (unlikely(!esas2r_build_prd_iblk(a, sgc)))
|
|
return false;
|
|
|
|
curr_iblk_chn++;
|
|
|
|
if (is_i_o) {
|
|
rq->vrq->scsi.iblk_cnt_prd++;
|
|
|
|
if (len > t->inter_byte)
|
|
sgc->length = t->inter_byte;
|
|
else
|
|
sgc->length = len;
|
|
}
|
|
}
|
|
|
|
/* figure out the size used of the VDA request */
|
|
|
|
reqsize = ((u16)((u8 *)curr_iblk_chn - (u8 *)rq->vrq))
|
|
/ sizeof(u32);
|
|
|
|
/*
|
|
* only update the request size if it is bigger than what is
|
|
* already there. we can come in here twice for some management
|
|
* commands.
|
|
*/
|
|
|
|
if (reqsize > rq->vda_req_sz)
|
|
rq->vda_req_sz = reqsize;
|
|
|
|
return true;
|
|
}
|
|
|
|
static void esas2r_handle_pending_reset(struct esas2r_adapter *a, u32 currtime)
|
|
{
|
|
u32 delta = currtime - a->chip_init_time;
|
|
|
|
if (delta <= ESAS2R_CHPRST_WAIT_TIME) {
|
|
/* Wait before accessing registers */
|
|
} else if (delta >= ESAS2R_CHPRST_TIME) {
|
|
/*
|
|
* The last reset failed so try again. Reset
|
|
* processing will give up after three tries.
|
|
*/
|
|
esas2r_local_reset_adapter(a);
|
|
} else {
|
|
/* We can now see if the firmware is ready */
|
|
u32 doorbell;
|
|
|
|
doorbell = esas2r_read_register_dword(a, MU_DOORBELL_OUT);
|
|
if (doorbell == 0xFFFFFFFF || !(doorbell & DRBL_FORCE_INT)) {
|
|
esas2r_force_interrupt(a);
|
|
} else {
|
|
u32 ver = (doorbell & DRBL_FW_VER_MSK);
|
|
|
|
/* Driver supports API version 0 and 1 */
|
|
esas2r_write_register_dword(a, MU_DOORBELL_OUT,
|
|
doorbell);
|
|
if (ver == DRBL_FW_VER_0) {
|
|
esas2r_lock_set_flags(&a->flags,
|
|
AF_CHPRST_DETECTED);
|
|
esas2r_lock_set_flags(&a->flags,
|
|
AF_LEGACY_SGE_MODE);
|
|
|
|
a->max_vdareq_size = 128;
|
|
a->build_sgl = esas2r_build_sg_list_sge;
|
|
} else if (ver == DRBL_FW_VER_1) {
|
|
esas2r_lock_set_flags(&a->flags,
|
|
AF_CHPRST_DETECTED);
|
|
esas2r_lock_clear_flags(&a->flags,
|
|
AF_LEGACY_SGE_MODE);
|
|
|
|
a->max_vdareq_size = 1024;
|
|
a->build_sgl = esas2r_build_sg_list_prd;
|
|
} else {
|
|
esas2r_local_reset_adapter(a);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* This function must be called once per timer tick */
|
|
void esas2r_timer_tick(struct esas2r_adapter *a)
|
|
{
|
|
u32 currtime = jiffies_to_msecs(jiffies);
|
|
u32 deltatime = currtime - a->last_tick_time;
|
|
|
|
a->last_tick_time = currtime;
|
|
|
|
/* count down the uptime */
|
|
if (a->chip_uptime
|
|
&& !(a->flags & (AF_CHPRST_PENDING | AF_DISC_PENDING))) {
|
|
if (deltatime >= a->chip_uptime)
|
|
a->chip_uptime = 0;
|
|
else
|
|
a->chip_uptime -= deltatime;
|
|
}
|
|
|
|
if (a->flags & AF_CHPRST_PENDING) {
|
|
if (!(a->flags & AF_CHPRST_NEEDED)
|
|
&& !(a->flags & AF_CHPRST_DETECTED))
|
|
esas2r_handle_pending_reset(a, currtime);
|
|
} else {
|
|
if (a->flags & AF_DISC_PENDING)
|
|
esas2r_disc_check_complete(a);
|
|
|
|
if (a->flags & AF_HEARTBEAT_ENB) {
|
|
if (a->flags & AF_HEARTBEAT) {
|
|
if ((currtime - a->heartbeat_time) >=
|
|
ESAS2R_HEARTBEAT_TIME) {
|
|
esas2r_lock_clear_flags(&a->flags,
|
|
AF_HEARTBEAT);
|
|
esas2r_hdebug("heartbeat failed");
|
|
esas2r_log(ESAS2R_LOG_CRIT,
|
|
"heartbeat failed");
|
|
esas2r_bugon();
|
|
esas2r_local_reset_adapter(a);
|
|
}
|
|
} else {
|
|
esas2r_lock_set_flags(&a->flags, AF_HEARTBEAT);
|
|
a->heartbeat_time = currtime;
|
|
esas2r_force_interrupt(a);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (atomic_read(&a->disable_cnt) == 0)
|
|
esas2r_do_deferred_processes(a);
|
|
}
|
|
|
|
/*
|
|
* Send the specified task management function to the target and LUN
|
|
* specified in rqaux. in addition, immediately abort any commands that
|
|
* are queued but not sent to the device according to the rules specified
|
|
* by the task management function.
|
|
*/
|
|
bool esas2r_send_task_mgmt(struct esas2r_adapter *a,
|
|
struct esas2r_request *rqaux, u8 task_mgt_func)
|
|
{
|
|
u16 targetid = rqaux->target_id;
|
|
u8 lun = (u8)le32_to_cpu(rqaux->vrq->scsi.flags);
|
|
bool ret = false;
|
|
struct esas2r_request *rq;
|
|
struct list_head *next, *element;
|
|
unsigned long flags;
|
|
|
|
LIST_HEAD(comp_list);
|
|
|
|
esas2r_trace_enter();
|
|
esas2r_trace("rqaux:%p", rqaux);
|
|
esas2r_trace("task_mgt_func:%x", task_mgt_func);
|
|
spin_lock_irqsave(&a->queue_lock, flags);
|
|
|
|
/* search the defer queue looking for requests for the device */
|
|
list_for_each_safe(element, next, &a->defer_list) {
|
|
rq = list_entry(element, struct esas2r_request, req_list);
|
|
|
|
if (rq->vrq->scsi.function == VDA_FUNC_SCSI
|
|
&& rq->target_id == targetid
|
|
&& (((u8)le32_to_cpu(rq->vrq->scsi.flags)) == lun
|
|
|| task_mgt_func == 0x20)) { /* target reset */
|
|
/* Found a request affected by the task management */
|
|
if (rq->req_stat == RS_PENDING) {
|
|
/*
|
|
* The request is pending or waiting. We can
|
|
* safelycomplete the request now.
|
|
*/
|
|
if (esas2r_ioreq_aborted(a, rq, RS_ABORTED))
|
|
list_add_tail(&rq->comp_list,
|
|
&comp_list);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Send the task management request to the firmware */
|
|
rqaux->sense_len = 0;
|
|
rqaux->vrq->scsi.length = 0;
|
|
rqaux->target_id = targetid;
|
|
rqaux->vrq->scsi.flags |= cpu_to_le32(lun);
|
|
memset(rqaux->vrq->scsi.cdb, 0, sizeof(rqaux->vrq->scsi.cdb));
|
|
rqaux->vrq->scsi.flags |=
|
|
cpu_to_le16(task_mgt_func * LOBIT(FCP_CMND_TM_MASK));
|
|
|
|
if (a->flags & AF_FLASHING) {
|
|
/* Assume success. if there are active requests, return busy */
|
|
rqaux->req_stat = RS_SUCCESS;
|
|
|
|
list_for_each_safe(element, next, &a->active_list) {
|
|
rq = list_entry(element, struct esas2r_request,
|
|
req_list);
|
|
if (rq->vrq->scsi.function == VDA_FUNC_SCSI
|
|
&& rq->target_id == targetid
|
|
&& (((u8)le32_to_cpu(rq->vrq->scsi.flags)) == lun
|
|
|| task_mgt_func == 0x20)) /* target reset */
|
|
rqaux->req_stat = RS_BUSY;
|
|
}
|
|
|
|
ret = true;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&a->queue_lock, flags);
|
|
|
|
if (!(a->flags & AF_FLASHING))
|
|
esas2r_start_request(a, rqaux);
|
|
|
|
esas2r_comp_list_drain(a, &comp_list);
|
|
|
|
if (atomic_read(&a->disable_cnt) == 0)
|
|
esas2r_do_deferred_processes(a);
|
|
|
|
esas2r_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
|
|
void esas2r_reset_bus(struct esas2r_adapter *a)
|
|
{
|
|
esas2r_log(ESAS2R_LOG_INFO, "performing a bus reset");
|
|
|
|
if (!(a->flags & AF_DEGRADED_MODE)
|
|
&& !(a->flags & (AF_CHPRST_PENDING | AF_DISC_PENDING))) {
|
|
esas2r_lock_set_flags(&a->flags, AF_BUSRST_NEEDED);
|
|
esas2r_lock_set_flags(&a->flags, AF_BUSRST_PENDING);
|
|
esas2r_lock_set_flags(&a->flags, AF_OS_RESET);
|
|
|
|
esas2r_schedule_tasklet(a);
|
|
}
|
|
}
|
|
|
|
bool esas2r_ioreq_aborted(struct esas2r_adapter *a, struct esas2r_request *rq,
|
|
u8 status)
|
|
{
|
|
esas2r_trace_enter();
|
|
esas2r_trace("rq:%p", rq);
|
|
list_del_init(&rq->req_list);
|
|
if (rq->timeout > RQ_MAX_TIMEOUT) {
|
|
/*
|
|
* The request timed out, but we could not abort it because a
|
|
* chip reset occurred. Return busy status.
|
|
*/
|
|
rq->req_stat = RS_BUSY;
|
|
esas2r_trace_exit();
|
|
return true;
|
|
}
|
|
|
|
rq->req_stat = status;
|
|
esas2r_trace_exit();
|
|
return true;
|
|
}
|