mirror of
https://github.com/torvalds/linux.git
synced 2024-12-05 10:32:35 +00:00
9588d24e36
Previously the code embedded the kernel's test_bit/clear_bit functions in wrappers that accepted u32 parameters. The wrapper cast these parameters to longs before passing them to the kernel's bit functions. This did not work properly on platforms with 64-bit longs. Signed-off-by: Bradley Grove <bgrove@attotech.com> Signed-off-by: James Bottomley <JBottomley@Parallels.com>
878 lines
23 KiB
C
878 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(test_bit(AF_DEGRADED_MODE, &a->flags) ||
|
|
test_bit(AF_POWER_DOWN, &a->flags))) {
|
|
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 &&
|
|
!test_bit(AF_DISC_PENDING, &a->flags)))
|
|
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) &&
|
|
!test_bit(AF_CHPRST_PENDING, &a->flags) &&
|
|
!test_bit(AF_FLASHING, &a->flags) &&
|
|
!test_bit(AF_DISC_PENDING, &a->flags)))
|
|
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))
|
|
set_bit(AF_FLASHING, &a->flags);
|
|
|
|
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 (test_bit(AF_COMM_LIST_TOGGLE, &a->flags))
|
|
clear_bit(AF_COMM_LIST_TOGGLE, &a->flags);
|
|
else
|
|
set_bit(AF_COMM_LIST_TOGGLE, &a->flags);
|
|
}
|
|
|
|
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 (test_bit(AF_COMM_LIST_TOGGLE, &a->flags))
|
|
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) {
|
|
set_bit(AF_CHPRST_DETECTED, &a->flags);
|
|
set_bit(AF_LEGACY_SGE_MODE, &a->flags);
|
|
|
|
a->max_vdareq_size = 128;
|
|
a->build_sgl = esas2r_build_sg_list_sge;
|
|
} else if (ver == DRBL_FW_VER_1) {
|
|
set_bit(AF_CHPRST_DETECTED, &a->flags);
|
|
clear_bit(AF_LEGACY_SGE_MODE, &a->flags);
|
|
|
|
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 &&
|
|
!test_bit(AF_CHPRST_PENDING, &a->flags) &&
|
|
!test_bit(AF_DISC_PENDING, &a->flags)) {
|
|
if (deltatime >= a->chip_uptime)
|
|
a->chip_uptime = 0;
|
|
else
|
|
a->chip_uptime -= deltatime;
|
|
}
|
|
|
|
if (test_bit(AF_CHPRST_PENDING, &a->flags)) {
|
|
if (!test_bit(AF_CHPRST_NEEDED, &a->flags) &&
|
|
!test_bit(AF_CHPRST_DETECTED, &a->flags))
|
|
esas2r_handle_pending_reset(a, currtime);
|
|
} else {
|
|
if (test_bit(AF_DISC_PENDING, &a->flags))
|
|
esas2r_disc_check_complete(a);
|
|
if (test_bit(AF_HEARTBEAT_ENB, &a->flags)) {
|
|
if (test_bit(AF_HEARTBEAT, &a->flags)) {
|
|
if ((currtime - a->heartbeat_time) >=
|
|
ESAS2R_HEARTBEAT_TIME) {
|
|
clear_bit(AF_HEARTBEAT, &a->flags);
|
|
esas2r_hdebug("heartbeat failed");
|
|
esas2r_log(ESAS2R_LOG_CRIT,
|
|
"heartbeat failed");
|
|
esas2r_bugon();
|
|
esas2r_local_reset_adapter(a);
|
|
}
|
|
} else {
|
|
set_bit(AF_HEARTBEAT, &a->flags);
|
|
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 (test_bit(AF_FLASHING, &a->flags)) {
|
|
/* 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 (!test_bit(AF_FLASHING, &a->flags))
|
|
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 (!test_bit(AF_DEGRADED_MODE, &a->flags) &&
|
|
!test_bit(AF_CHPRST_PENDING, &a->flags) &&
|
|
!test_bit(AF_DISC_PENDING, &a->flags)) {
|
|
set_bit(AF_BUSRST_NEEDED, &a->flags);
|
|
set_bit(AF_BUSRST_PENDING, &a->flags);
|
|
set_bit(AF_OS_RESET, &a->flags);
|
|
|
|
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;
|
|
}
|