126780d9eSBradley Grove /*
226780d9eSBradley Grove * linux/drivers/scsi/esas2r/esas2r_io.c
326780d9eSBradley Grove * For use with ATTO ExpressSAS R6xx SAS/SATA RAID controllers
426780d9eSBradley Grove *
526780d9eSBradley Grove * Copyright (c) 2001-2013 ATTO Technology, Inc.
626780d9eSBradley Grove * (mailto:linuxdrivers@attotech.com)mpt3sas/mpt3sas_trigger_diag.
726780d9eSBradley Grove *
826780d9eSBradley Grove * This program is free software; you can redistribute it and/or
926780d9eSBradley Grove * modify it under the terms of the GNU General Public License
1026780d9eSBradley Grove * as published by the Free Software Foundation; either version 2
1126780d9eSBradley Grove * of the License, or (at your option) any later version.
1226780d9eSBradley Grove *
1326780d9eSBradley Grove * This program is distributed in the hope that it will be useful,
1426780d9eSBradley Grove * but WITHOUT ANY WARRANTY; without even the implied warranty of
1526780d9eSBradley Grove * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1626780d9eSBradley Grove * GNU General Public License for more details.
1726780d9eSBradley Grove *
1826780d9eSBradley Grove * NO WARRANTY
1926780d9eSBradley Grove * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
2026780d9eSBradley Grove * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
2126780d9eSBradley Grove * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
2226780d9eSBradley Grove * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
2326780d9eSBradley Grove * solely responsible for determining the appropriateness of using and
2426780d9eSBradley Grove * distributing the Program and assumes all risks associated with its
2526780d9eSBradley Grove * exercise of rights under this Agreement, including but not limited to
2626780d9eSBradley Grove * the risks and costs of program errors, damage to or loss of data,
2726780d9eSBradley Grove * programs or equipment, and unavailability or interruption of operations.
2826780d9eSBradley Grove *
2926780d9eSBradley Grove * DISCLAIMER OF LIABILITY
3026780d9eSBradley Grove * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
3126780d9eSBradley Grove * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
3226780d9eSBradley Grove * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
3326780d9eSBradley Grove * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
3426780d9eSBradley Grove * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
3526780d9eSBradley Grove * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
3626780d9eSBradley Grove * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
3726780d9eSBradley Grove *
3826780d9eSBradley Grove * You should have received a copy of the GNU General Public License
3926780d9eSBradley Grove * along with this program; if not, write to the Free Software
4026780d9eSBradley Grove * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
4126780d9eSBradley Grove * USA.
4226780d9eSBradley Grove */
4326780d9eSBradley Grove
4426780d9eSBradley Grove #include "esas2r.h"
4526780d9eSBradley Grove
esas2r_start_request(struct esas2r_adapter * a,struct esas2r_request * rq)4626780d9eSBradley Grove void esas2r_start_request(struct esas2r_adapter *a, struct esas2r_request *rq)
4726780d9eSBradley Grove {
4826780d9eSBradley Grove struct esas2r_target *t = NULL;
4926780d9eSBradley Grove struct esas2r_request *startrq = rq;
5026780d9eSBradley Grove unsigned long flags;
5126780d9eSBradley Grove
529588d24eSBradley Grove if (unlikely(test_bit(AF_DEGRADED_MODE, &a->flags) ||
539588d24eSBradley Grove test_bit(AF_POWER_DOWN, &a->flags))) {
5426780d9eSBradley Grove if (rq->vrq->scsi.function == VDA_FUNC_SCSI)
5526780d9eSBradley Grove rq->req_stat = RS_SEL2;
5626780d9eSBradley Grove else
5726780d9eSBradley Grove rq->req_stat = RS_DEGRADED;
5826780d9eSBradley Grove } else if (likely(rq->vrq->scsi.function == VDA_FUNC_SCSI)) {
5926780d9eSBradley Grove t = a->targetdb + rq->target_id;
6026780d9eSBradley Grove
6126780d9eSBradley Grove if (unlikely(t >= a->targetdb_end
6226780d9eSBradley Grove || !(t->flags & TF_USED))) {
6326780d9eSBradley Grove rq->req_stat = RS_SEL;
6426780d9eSBradley Grove } else {
6526780d9eSBradley Grove /* copy in the target ID. */
6626780d9eSBradley Grove rq->vrq->scsi.target_id = cpu_to_le16(t->virt_targ_id);
6726780d9eSBradley Grove
6826780d9eSBradley Grove /*
6926780d9eSBradley Grove * Test if we want to report RS_SEL for missing target.
7026780d9eSBradley Grove * Note that if AF_DISC_PENDING is set than this will
7126780d9eSBradley Grove * go on the defer queue.
7226780d9eSBradley Grove */
739588d24eSBradley Grove if (unlikely(t->target_state != TS_PRESENT &&
749588d24eSBradley Grove !test_bit(AF_DISC_PENDING, &a->flags)))
7526780d9eSBradley Grove rq->req_stat = RS_SEL;
7626780d9eSBradley Grove }
7726780d9eSBradley Grove }
7826780d9eSBradley Grove
7926780d9eSBradley Grove if (unlikely(rq->req_stat != RS_PENDING)) {
8026780d9eSBradley Grove esas2r_complete_request(a, rq);
8126780d9eSBradley Grove return;
8226780d9eSBradley Grove }
8326780d9eSBradley Grove
8426780d9eSBradley Grove esas2r_trace("rq=%p", rq);
8526780d9eSBradley Grove esas2r_trace("rq->vrq->scsi.handle=%x", rq->vrq->scsi.handle);
8626780d9eSBradley Grove
8726780d9eSBradley Grove if (rq->vrq->scsi.function == VDA_FUNC_SCSI) {
8826780d9eSBradley Grove esas2r_trace("rq->target_id=%d", rq->target_id);
8926780d9eSBradley Grove esas2r_trace("rq->vrq->scsi.flags=%x", rq->vrq->scsi.flags);
9026780d9eSBradley Grove }
9126780d9eSBradley Grove
9226780d9eSBradley Grove spin_lock_irqsave(&a->queue_lock, flags);
9326780d9eSBradley Grove
9426780d9eSBradley Grove if (likely(list_empty(&a->defer_list) &&
959588d24eSBradley Grove !test_bit(AF_CHPRST_PENDING, &a->flags) &&
969588d24eSBradley Grove !test_bit(AF_FLASHING, &a->flags) &&
979588d24eSBradley Grove !test_bit(AF_DISC_PENDING, &a->flags)))
9826780d9eSBradley Grove esas2r_local_start_request(a, startrq);
9926780d9eSBradley Grove else
10026780d9eSBradley Grove list_add_tail(&startrq->req_list, &a->defer_list);
10126780d9eSBradley Grove
10226780d9eSBradley Grove spin_unlock_irqrestore(&a->queue_lock, flags);
10326780d9eSBradley Grove }
10426780d9eSBradley Grove
10526780d9eSBradley Grove /*
10626780d9eSBradley Grove * Starts the specified request. all requests have RS_PENDING set when this
10726780d9eSBradley Grove * routine is called. The caller is usually esas2r_start_request, but
10826780d9eSBradley Grove * esas2r_do_deferred_processes will start request that are deferred.
10926780d9eSBradley Grove *
11026780d9eSBradley Grove * The caller must ensure that requests can be started.
11126780d9eSBradley Grove *
11226780d9eSBradley Grove * esas2r_start_request will defer a request if there are already requests
11326780d9eSBradley Grove * waiting or there is a chip reset pending. once the reset condition clears,
11426780d9eSBradley Grove * esas2r_do_deferred_processes will call this function to start the request.
11526780d9eSBradley Grove *
11626780d9eSBradley Grove * When a request is started, it is placed on the active list and queued to
11726780d9eSBradley Grove * the controller.
11826780d9eSBradley Grove */
esas2r_local_start_request(struct esas2r_adapter * a,struct esas2r_request * rq)11926780d9eSBradley Grove void esas2r_local_start_request(struct esas2r_adapter *a,
12026780d9eSBradley Grove struct esas2r_request *rq)
12126780d9eSBradley Grove {
12226780d9eSBradley Grove esas2r_trace_enter();
12326780d9eSBradley Grove esas2r_trace("rq=%p", rq);
12426780d9eSBradley Grove esas2r_trace("rq->vrq:%p", rq->vrq);
12526780d9eSBradley Grove esas2r_trace("rq->vrq_md->phys_addr:%x", rq->vrq_md->phys_addr);
12626780d9eSBradley Grove
12726780d9eSBradley Grove if (unlikely(rq->vrq->scsi.function == VDA_FUNC_FLASH
12826780d9eSBradley Grove && rq->vrq->flash.sub_func == VDA_FLASH_COMMIT))
1299588d24eSBradley Grove set_bit(AF_FLASHING, &a->flags);
13026780d9eSBradley Grove
13126780d9eSBradley Grove list_add_tail(&rq->req_list, &a->active_list);
13226780d9eSBradley Grove esas2r_start_vda_request(a, rq);
13326780d9eSBradley Grove esas2r_trace_exit();
13426780d9eSBradley Grove return;
13526780d9eSBradley Grove }
13626780d9eSBradley Grove
esas2r_start_vda_request(struct esas2r_adapter * a,struct esas2r_request * rq)13726780d9eSBradley Grove void esas2r_start_vda_request(struct esas2r_adapter *a,
13826780d9eSBradley Grove struct esas2r_request *rq)
13926780d9eSBradley Grove {
14026780d9eSBradley Grove struct esas2r_inbound_list_source_entry *element;
14126780d9eSBradley Grove u32 dw;
14226780d9eSBradley Grove
14326780d9eSBradley Grove rq->req_stat = RS_STARTED;
14426780d9eSBradley Grove /*
14526780d9eSBradley Grove * Calculate the inbound list entry location and the current state of
14626780d9eSBradley Grove * toggle bit.
14726780d9eSBradley Grove */
14826780d9eSBradley Grove a->last_write++;
14926780d9eSBradley Grove if (a->last_write >= a->list_size) {
15026780d9eSBradley Grove a->last_write = 0;
15126780d9eSBradley Grove /* update the toggle bit */
1529588d24eSBradley Grove if (test_bit(AF_COMM_LIST_TOGGLE, &a->flags))
1539588d24eSBradley Grove clear_bit(AF_COMM_LIST_TOGGLE, &a->flags);
15426780d9eSBradley Grove else
1559588d24eSBradley Grove set_bit(AF_COMM_LIST_TOGGLE, &a->flags);
15626780d9eSBradley Grove }
15726780d9eSBradley Grove
15826780d9eSBradley Grove element =
15926780d9eSBradley Grove (struct esas2r_inbound_list_source_entry *)a->inbound_list_md.
16026780d9eSBradley Grove virt_addr
16126780d9eSBradley Grove + a->last_write;
16226780d9eSBradley Grove
16326780d9eSBradley Grove /* Set the VDA request size if it was never modified */
16426780d9eSBradley Grove if (rq->vda_req_sz == RQ_SIZE_DEFAULT)
16526780d9eSBradley Grove rq->vda_req_sz = (u16)(a->max_vdareq_size / sizeof(u32));
16626780d9eSBradley Grove
16726780d9eSBradley Grove element->address = cpu_to_le64(rq->vrq_md->phys_addr);
16826780d9eSBradley Grove element->length = cpu_to_le32(rq->vda_req_sz);
16926780d9eSBradley Grove
17026780d9eSBradley Grove /* Update the write pointer */
17126780d9eSBradley Grove dw = a->last_write;
17226780d9eSBradley Grove
1739588d24eSBradley Grove if (test_bit(AF_COMM_LIST_TOGGLE, &a->flags))
17426780d9eSBradley Grove dw |= MU_ILW_TOGGLE;
17526780d9eSBradley Grove
17626780d9eSBradley Grove esas2r_trace("rq->vrq->scsi.handle:%x", rq->vrq->scsi.handle);
17726780d9eSBradley Grove esas2r_trace("dw:%x", dw);
17826780d9eSBradley Grove esas2r_trace("rq->vda_req_sz:%x", rq->vda_req_sz);
17926780d9eSBradley Grove esas2r_write_register_dword(a, MU_IN_LIST_WRITE, dw);
18026780d9eSBradley Grove }
18126780d9eSBradley Grove
18226780d9eSBradley Grove /*
18326780d9eSBradley Grove * Build the scatter/gather list for an I/O request according to the
18426780d9eSBradley Grove * specifications placed in the s/g context. The caller must initialize
18526780d9eSBradley Grove * context prior to the initial call by calling esas2r_sgc_init().
18626780d9eSBradley Grove */
esas2r_build_sg_list_sge(struct esas2r_adapter * a,struct esas2r_sg_context * sgc)18726780d9eSBradley Grove bool esas2r_build_sg_list_sge(struct esas2r_adapter *a,
18826780d9eSBradley Grove struct esas2r_sg_context *sgc)
18926780d9eSBradley Grove {
19026780d9eSBradley Grove struct esas2r_request *rq = sgc->first_req;
19126780d9eSBradley Grove union atto_vda_req *vrq = rq->vrq;
19226780d9eSBradley Grove
19326780d9eSBradley Grove while (sgc->length) {
19426780d9eSBradley Grove u32 rem = 0;
19526780d9eSBradley Grove u64 addr;
19626780d9eSBradley Grove u32 len;
19726780d9eSBradley Grove
19826780d9eSBradley Grove len = (*sgc->get_phys_addr)(sgc, &addr);
19926780d9eSBradley Grove
20026780d9eSBradley Grove if (unlikely(len == 0))
20126780d9eSBradley Grove return false;
20226780d9eSBradley Grove
20326780d9eSBradley Grove /* if current length is more than what's left, stop there */
20426780d9eSBradley Grove if (unlikely(len > sgc->length))
20526780d9eSBradley Grove len = sgc->length;
20626780d9eSBradley Grove
20726780d9eSBradley Grove another_entry:
20826780d9eSBradley Grove /* limit to a round number less than the maximum length */
20926780d9eSBradley Grove if (len > SGE_LEN_MAX) {
21026780d9eSBradley Grove /*
21126780d9eSBradley Grove * Save the remainder of the split. Whenever we limit
21226780d9eSBradley Grove * an entry we come back around to build entries out
21326780d9eSBradley Grove * of the leftover. We do this to prevent multiple
21426780d9eSBradley Grove * calls to the get_phys_addr() function for an SGE
21526780d9eSBradley Grove * that is too large.
21626780d9eSBradley Grove */
21726780d9eSBradley Grove rem = len - SGE_LEN_MAX;
21826780d9eSBradley Grove len = SGE_LEN_MAX;
21926780d9eSBradley Grove }
22026780d9eSBradley Grove
22126780d9eSBradley Grove /* See if we need to allocate a new SGL */
22226780d9eSBradley Grove if (unlikely(sgc->sge.a64.curr > sgc->sge.a64.limit)) {
22326780d9eSBradley Grove u8 sgelen;
22426780d9eSBradley Grove struct esas2r_mem_desc *sgl;
22526780d9eSBradley Grove
22626780d9eSBradley Grove /*
22726780d9eSBradley Grove * If no SGls are available, return failure. The
22826780d9eSBradley Grove * caller can call us later with the current context
22926780d9eSBradley Grove * to pick up here.
23026780d9eSBradley Grove */
23126780d9eSBradley Grove sgl = esas2r_alloc_sgl(a);
23226780d9eSBradley Grove
23326780d9eSBradley Grove if (unlikely(sgl == NULL))
23426780d9eSBradley Grove return false;
23526780d9eSBradley Grove
23626780d9eSBradley Grove /* Calculate the length of the last SGE filled in */
23726780d9eSBradley Grove sgelen = (u8)((u8 *)sgc->sge.a64.curr
23826780d9eSBradley Grove - (u8 *)sgc->sge.a64.last);
23926780d9eSBradley Grove
24026780d9eSBradley Grove /*
24126780d9eSBradley Grove * Copy the last SGE filled in to the first entry of
24226780d9eSBradley Grove * the new SGL to make room for the chain entry.
24326780d9eSBradley Grove */
24426780d9eSBradley Grove memcpy(sgl->virt_addr, sgc->sge.a64.last, sgelen);
24526780d9eSBradley Grove
24626780d9eSBradley Grove /* Figure out the new curr pointer in the new segment */
24726780d9eSBradley Grove sgc->sge.a64.curr =
24826780d9eSBradley Grove (struct atto_vda_sge *)((u8 *)sgl->virt_addr +
24926780d9eSBradley Grove sgelen);
25026780d9eSBradley Grove
25126780d9eSBradley Grove /* Set the limit pointer and build the chain entry */
25226780d9eSBradley Grove sgc->sge.a64.limit =
25326780d9eSBradley Grove (struct atto_vda_sge *)((u8 *)sgl->virt_addr
25426780d9eSBradley Grove + sgl_page_size
25526780d9eSBradley Grove - sizeof(struct
25626780d9eSBradley Grove atto_vda_sge));
25726780d9eSBradley Grove sgc->sge.a64.last->length = cpu_to_le32(
25826780d9eSBradley Grove SGE_CHAIN | SGE_ADDR_64);
25926780d9eSBradley Grove sgc->sge.a64.last->address =
26026780d9eSBradley Grove cpu_to_le64(sgl->phys_addr);
26126780d9eSBradley Grove
26226780d9eSBradley Grove /*
26326780d9eSBradley Grove * Now, if there was a previous chain entry, then
26426780d9eSBradley Grove * update it to contain the length of this segment
26526780d9eSBradley Grove * and size of this chain. otherwise this is the
26626780d9eSBradley Grove * first SGL, so set the chain_offset in the request.
26726780d9eSBradley Grove */
26826780d9eSBradley Grove if (sgc->sge.a64.chain) {
26926780d9eSBradley Grove sgc->sge.a64.chain->length |=
27026780d9eSBradley Grove cpu_to_le32(
27126780d9eSBradley Grove ((u8 *)(sgc->sge.a64.
27226780d9eSBradley Grove last + 1)
27326780d9eSBradley Grove - (u8 *)rq->sg_table->
27426780d9eSBradley Grove virt_addr)
27526780d9eSBradley Grove + sizeof(struct atto_vda_sge) *
27626780d9eSBradley Grove LOBIT(SGE_CHAIN_SZ));
27726780d9eSBradley Grove } else {
27826780d9eSBradley Grove vrq->scsi.chain_offset = (u8)
27926780d9eSBradley Grove ((u8 *)sgc->
28026780d9eSBradley Grove sge.a64.last -
28126780d9eSBradley Grove (u8 *)vrq);
28226780d9eSBradley Grove
28326780d9eSBradley Grove /*
28426780d9eSBradley Grove * This is the first SGL, so set the
28526780d9eSBradley Grove * chain_offset and the VDA request size in
28626780d9eSBradley Grove * the request.
28726780d9eSBradley Grove */
28826780d9eSBradley Grove rq->vda_req_sz =
28926780d9eSBradley Grove (vrq->scsi.chain_offset +
29026780d9eSBradley Grove sizeof(struct atto_vda_sge) +
29126780d9eSBradley Grove 3)
29226780d9eSBradley Grove / sizeof(u32);
29326780d9eSBradley Grove }
29426780d9eSBradley Grove
29526780d9eSBradley Grove /*
29626780d9eSBradley Grove * Remember this so when we get a new SGL filled in we
29726780d9eSBradley Grove * can update the length of this chain entry.
29826780d9eSBradley Grove */
29926780d9eSBradley Grove sgc->sge.a64.chain = sgc->sge.a64.last;
30026780d9eSBradley Grove
30126780d9eSBradley Grove /* Now link the new SGL onto the primary request. */
30226780d9eSBradley Grove list_add(&sgl->next_desc, &rq->sg_table_head);
30326780d9eSBradley Grove }
30426780d9eSBradley Grove
30526780d9eSBradley Grove /* Update last one filled in */
30626780d9eSBradley Grove sgc->sge.a64.last = sgc->sge.a64.curr;
30726780d9eSBradley Grove
30826780d9eSBradley Grove /* Build the new SGE and update the S/G context */
30926780d9eSBradley Grove sgc->sge.a64.curr->length = cpu_to_le32(SGE_ADDR_64 | len);
31026780d9eSBradley Grove sgc->sge.a64.curr->address = cpu_to_le32(addr);
31126780d9eSBradley Grove sgc->sge.a64.curr++;
31226780d9eSBradley Grove sgc->cur_offset += len;
31326780d9eSBradley Grove sgc->length -= len;
31426780d9eSBradley Grove
31526780d9eSBradley Grove /*
31626780d9eSBradley Grove * Check if we previously split an entry. If so we have to
31726780d9eSBradley Grove * pick up where we left off.
31826780d9eSBradley Grove */
31926780d9eSBradley Grove if (rem) {
32026780d9eSBradley Grove addr += len;
32126780d9eSBradley Grove len = rem;
32226780d9eSBradley Grove rem = 0;
32326780d9eSBradley Grove goto another_entry;
32426780d9eSBradley Grove }
32526780d9eSBradley Grove }
32626780d9eSBradley Grove
32726780d9eSBradley Grove /* Mark the end of the SGL */
32826780d9eSBradley Grove sgc->sge.a64.last->length |= cpu_to_le32(SGE_LAST);
32926780d9eSBradley Grove
33026780d9eSBradley Grove /*
33126780d9eSBradley Grove * If there was a previous chain entry, update the length to indicate
33226780d9eSBradley Grove * the length of this last segment.
33326780d9eSBradley Grove */
33426780d9eSBradley Grove if (sgc->sge.a64.chain) {
33526780d9eSBradley Grove sgc->sge.a64.chain->length |= cpu_to_le32(
33626780d9eSBradley Grove ((u8 *)(sgc->sge.a64.curr) -
33726780d9eSBradley Grove (u8 *)rq->sg_table->virt_addr));
33826780d9eSBradley Grove } else {
33926780d9eSBradley Grove u16 reqsize;
34026780d9eSBradley Grove
34126780d9eSBradley Grove /*
34226780d9eSBradley Grove * The entire VDA request was not used so lets
34326780d9eSBradley Grove * set the size of the VDA request to be DMA'd
34426780d9eSBradley Grove */
34526780d9eSBradley Grove reqsize =
34626780d9eSBradley Grove ((u16)((u8 *)sgc->sge.a64.last - (u8 *)vrq)
34726780d9eSBradley Grove + sizeof(struct atto_vda_sge) + 3) / sizeof(u32);
34826780d9eSBradley Grove
34926780d9eSBradley Grove /*
35026780d9eSBradley Grove * Only update the request size if it is bigger than what is
35126780d9eSBradley Grove * already there. We can come in here twice for some management
35226780d9eSBradley Grove * commands.
35326780d9eSBradley Grove */
35426780d9eSBradley Grove if (reqsize > rq->vda_req_sz)
35526780d9eSBradley Grove rq->vda_req_sz = reqsize;
35626780d9eSBradley Grove }
35726780d9eSBradley Grove return true;
35826780d9eSBradley Grove }
35926780d9eSBradley Grove
36026780d9eSBradley Grove
36126780d9eSBradley Grove /*
36226780d9eSBradley Grove * Create PRD list for each I-block consumed by the command. This routine
36326780d9eSBradley Grove * determines how much data is required from each I-block being consumed
36426780d9eSBradley Grove * by the command. The first and last I-blocks can be partials and all of
36526780d9eSBradley Grove * the I-blocks in between are for a full I-block of data.
36626780d9eSBradley Grove *
36726780d9eSBradley Grove * The interleave size is used to determine the number of bytes in the 1st
36826780d9eSBradley Grove * I-block and the remaining I-blocks are what remeains.
36926780d9eSBradley Grove */
esas2r_build_prd_iblk(struct esas2r_adapter * a,struct esas2r_sg_context * sgc)37026780d9eSBradley Grove static bool esas2r_build_prd_iblk(struct esas2r_adapter *a,
37126780d9eSBradley Grove struct esas2r_sg_context *sgc)
37226780d9eSBradley Grove {
37326780d9eSBradley Grove struct esas2r_request *rq = sgc->first_req;
37426780d9eSBradley Grove u64 addr;
37526780d9eSBradley Grove u32 len;
37626780d9eSBradley Grove struct esas2r_mem_desc *sgl;
37726780d9eSBradley Grove u32 numchain = 1;
37826780d9eSBradley Grove u32 rem = 0;
37926780d9eSBradley Grove
38026780d9eSBradley Grove while (sgc->length) {
38126780d9eSBradley Grove /* Get the next address/length pair */
38226780d9eSBradley Grove
38326780d9eSBradley Grove len = (*sgc->get_phys_addr)(sgc, &addr);
38426780d9eSBradley Grove
38526780d9eSBradley Grove if (unlikely(len == 0))
38626780d9eSBradley Grove return false;
38726780d9eSBradley Grove
38826780d9eSBradley Grove /* If current length is more than what's left, stop there */
38926780d9eSBradley Grove
39026780d9eSBradley Grove if (unlikely(len > sgc->length))
39126780d9eSBradley Grove len = sgc->length;
39226780d9eSBradley Grove
39326780d9eSBradley Grove another_entry:
39426780d9eSBradley Grove /* Limit to a round number less than the maximum length */
39526780d9eSBradley Grove
39626780d9eSBradley Grove if (len > PRD_LEN_MAX) {
39726780d9eSBradley Grove /*
39826780d9eSBradley Grove * Save the remainder of the split. whenever we limit
39926780d9eSBradley Grove * an entry we come back around to build entries out
40026780d9eSBradley Grove * of the leftover. We do this to prevent multiple
40126780d9eSBradley Grove * calls to the get_phys_addr() function for an SGE
40226780d9eSBradley Grove * that is too large.
40326780d9eSBradley Grove */
40426780d9eSBradley Grove rem = len - PRD_LEN_MAX;
40526780d9eSBradley Grove len = PRD_LEN_MAX;
40626780d9eSBradley Grove }
40726780d9eSBradley Grove
40826780d9eSBradley Grove /* See if we need to allocate a new SGL */
40926780d9eSBradley Grove if (sgc->sge.prd.sge_cnt == 0) {
41026780d9eSBradley Grove if (len == sgc->length) {
41126780d9eSBradley Grove /*
41226780d9eSBradley Grove * We only have 1 PRD entry left.
41326780d9eSBradley Grove * It can be placed where the chain
41426780d9eSBradley Grove * entry would have gone
41526780d9eSBradley Grove */
41626780d9eSBradley Grove
41726780d9eSBradley Grove /* Build the simple SGE */
41826780d9eSBradley Grove sgc->sge.prd.curr->ctl_len = cpu_to_le32(
41926780d9eSBradley Grove PRD_DATA | len);
42026780d9eSBradley Grove sgc->sge.prd.curr->address = cpu_to_le64(addr);
42126780d9eSBradley Grove
42226780d9eSBradley Grove /* Adjust length related fields */
42326780d9eSBradley Grove sgc->cur_offset += len;
42426780d9eSBradley Grove sgc->length -= len;
42526780d9eSBradley Grove
42626780d9eSBradley Grove /* We use the reserved chain entry for data */
42726780d9eSBradley Grove numchain = 0;
42826780d9eSBradley Grove
42926780d9eSBradley Grove break;
43026780d9eSBradley Grove }
43126780d9eSBradley Grove
43226780d9eSBradley Grove if (sgc->sge.prd.chain) {
43326780d9eSBradley Grove /*
43426780d9eSBradley Grove * Fill # of entries of current SGL in previous
43526780d9eSBradley Grove * chain the length of this current SGL may not
43626780d9eSBradley Grove * full.
43726780d9eSBradley Grove */
43826780d9eSBradley Grove
43926780d9eSBradley Grove sgc->sge.prd.chain->ctl_len |= cpu_to_le32(
44026780d9eSBradley Grove sgc->sge.prd.sgl_max_cnt);
44126780d9eSBradley Grove }
44226780d9eSBradley Grove
44326780d9eSBradley Grove /*
44426780d9eSBradley Grove * If no SGls are available, return failure. The
44526780d9eSBradley Grove * caller can call us later with the current context
44626780d9eSBradley Grove * to pick up here.
44726780d9eSBradley Grove */
44826780d9eSBradley Grove
44926780d9eSBradley Grove sgl = esas2r_alloc_sgl(a);
45026780d9eSBradley Grove
45126780d9eSBradley Grove if (unlikely(sgl == NULL))
45226780d9eSBradley Grove return false;
45326780d9eSBradley Grove
45426780d9eSBradley Grove /*
45526780d9eSBradley Grove * Link the new SGL onto the chain
45626780d9eSBradley Grove * They are in reverse order
45726780d9eSBradley Grove */
45826780d9eSBradley Grove list_add(&sgl->next_desc, &rq->sg_table_head);
45926780d9eSBradley Grove
46026780d9eSBradley Grove /*
46126780d9eSBradley Grove * An SGL was just filled in and we are starting
46226780d9eSBradley Grove * a new SGL. Prime the chain of the ending SGL with
46326780d9eSBradley Grove * info that points to the new SGL. The length gets
46426780d9eSBradley Grove * filled in when the new SGL is filled or ended
46526780d9eSBradley Grove */
46626780d9eSBradley Grove
46726780d9eSBradley Grove sgc->sge.prd.chain = sgc->sge.prd.curr;
46826780d9eSBradley Grove
46926780d9eSBradley Grove sgc->sge.prd.chain->ctl_len = cpu_to_le32(PRD_CHAIN);
47026780d9eSBradley Grove sgc->sge.prd.chain->address =
47126780d9eSBradley Grove cpu_to_le64(sgl->phys_addr);
47226780d9eSBradley Grove
47326780d9eSBradley Grove /*
47426780d9eSBradley Grove * Start a new segment.
47526780d9eSBradley Grove * Take one away and save for chain SGE
47626780d9eSBradley Grove */
47726780d9eSBradley Grove
47826780d9eSBradley Grove sgc->sge.prd.curr =
47926780d9eSBradley Grove (struct atto_physical_region_description *)sgl
48026780d9eSBradley Grove ->
48126780d9eSBradley Grove virt_addr;
48226780d9eSBradley Grove sgc->sge.prd.sge_cnt = sgc->sge.prd.sgl_max_cnt - 1;
48326780d9eSBradley Grove }
48426780d9eSBradley Grove
48526780d9eSBradley Grove sgc->sge.prd.sge_cnt--;
48626780d9eSBradley Grove /* Build the simple SGE */
48726780d9eSBradley Grove sgc->sge.prd.curr->ctl_len = cpu_to_le32(PRD_DATA | len);
48826780d9eSBradley Grove sgc->sge.prd.curr->address = cpu_to_le64(addr);
48926780d9eSBradley Grove
49026780d9eSBradley Grove /* Used another element. Point to the next one */
49126780d9eSBradley Grove
49226780d9eSBradley Grove sgc->sge.prd.curr++;
49326780d9eSBradley Grove
49426780d9eSBradley Grove /* Adjust length related fields */
49526780d9eSBradley Grove
49626780d9eSBradley Grove sgc->cur_offset += len;
49726780d9eSBradley Grove sgc->length -= len;
49826780d9eSBradley Grove
49926780d9eSBradley Grove /*
50026780d9eSBradley Grove * Check if we previously split an entry. If so we have to
50126780d9eSBradley Grove * pick up where we left off.
50226780d9eSBradley Grove */
50326780d9eSBradley Grove
50426780d9eSBradley Grove if (rem) {
50526780d9eSBradley Grove addr += len;
50626780d9eSBradley Grove len = rem;
50726780d9eSBradley Grove rem = 0;
50826780d9eSBradley Grove goto another_entry;
50926780d9eSBradley Grove }
51026780d9eSBradley Grove }
51126780d9eSBradley Grove
51226780d9eSBradley Grove if (!list_empty(&rq->sg_table_head)) {
51326780d9eSBradley Grove if (sgc->sge.prd.chain) {
51426780d9eSBradley Grove sgc->sge.prd.chain->ctl_len |=
51526780d9eSBradley Grove cpu_to_le32(sgc->sge.prd.sgl_max_cnt
51626780d9eSBradley Grove - sgc->sge.prd.sge_cnt
51726780d9eSBradley Grove - numchain);
51826780d9eSBradley Grove }
51926780d9eSBradley Grove }
52026780d9eSBradley Grove
52126780d9eSBradley Grove return true;
52226780d9eSBradley Grove }
52326780d9eSBradley Grove
esas2r_build_sg_list_prd(struct esas2r_adapter * a,struct esas2r_sg_context * sgc)52426780d9eSBradley Grove bool esas2r_build_sg_list_prd(struct esas2r_adapter *a,
52526780d9eSBradley Grove struct esas2r_sg_context *sgc)
52626780d9eSBradley Grove {
52726780d9eSBradley Grove struct esas2r_request *rq = sgc->first_req;
52826780d9eSBradley Grove u32 len = sgc->length;
52926780d9eSBradley Grove struct esas2r_target *t = a->targetdb + rq->target_id;
53026780d9eSBradley Grove u8 is_i_o = 0;
53126780d9eSBradley Grove u16 reqsize;
53226780d9eSBradley Grove struct atto_physical_region_description *curr_iblk_chn;
53326780d9eSBradley Grove u8 *cdb = (u8 *)&rq->vrq->scsi.cdb[0];
53426780d9eSBradley Grove
53526780d9eSBradley Grove /*
53626780d9eSBradley Grove * extract LBA from command so we can determine
53726780d9eSBradley Grove * the I-Block boundary
53826780d9eSBradley Grove */
53926780d9eSBradley Grove
54026780d9eSBradley Grove if (rq->vrq->scsi.function == VDA_FUNC_SCSI
54126780d9eSBradley Grove && t->target_state == TS_PRESENT
54226780d9eSBradley Grove && !(t->flags & TF_PASS_THRU)) {
54326780d9eSBradley Grove u32 lbalo = 0;
54426780d9eSBradley Grove
54526780d9eSBradley Grove switch (rq->vrq->scsi.cdb[0]) {
54626780d9eSBradley Grove case READ_16:
54726780d9eSBradley Grove case WRITE_16:
54826780d9eSBradley Grove {
54926780d9eSBradley Grove lbalo =
55026780d9eSBradley Grove MAKEDWORD(MAKEWORD(cdb[9],
55126780d9eSBradley Grove cdb[8]),
55226780d9eSBradley Grove MAKEWORD(cdb[7],
55326780d9eSBradley Grove cdb[6]));
55426780d9eSBradley Grove is_i_o = 1;
55526780d9eSBradley Grove break;
55626780d9eSBradley Grove }
55726780d9eSBradley Grove
55826780d9eSBradley Grove case READ_12:
55926780d9eSBradley Grove case WRITE_12:
56026780d9eSBradley Grove case READ_10:
56126780d9eSBradley Grove case WRITE_10:
56226780d9eSBradley Grove {
56326780d9eSBradley Grove lbalo =
56426780d9eSBradley Grove MAKEDWORD(MAKEWORD(cdb[5],
56526780d9eSBradley Grove cdb[4]),
56626780d9eSBradley Grove MAKEWORD(cdb[3],
56726780d9eSBradley Grove cdb[2]));
56826780d9eSBradley Grove is_i_o = 1;
56926780d9eSBradley Grove break;
57026780d9eSBradley Grove }
57126780d9eSBradley Grove
57226780d9eSBradley Grove case READ_6:
57326780d9eSBradley Grove case WRITE_6:
57426780d9eSBradley Grove {
57526780d9eSBradley Grove lbalo =
57626780d9eSBradley Grove MAKEDWORD(MAKEWORD(cdb[3],
57726780d9eSBradley Grove cdb[2]),
57826780d9eSBradley Grove MAKEWORD(cdb[1] & 0x1F,
57926780d9eSBradley Grove 0));
58026780d9eSBradley Grove is_i_o = 1;
58126780d9eSBradley Grove break;
58226780d9eSBradley Grove }
58326780d9eSBradley Grove
58426780d9eSBradley Grove default:
58526780d9eSBradley Grove break;
58626780d9eSBradley Grove }
58726780d9eSBradley Grove
58826780d9eSBradley Grove if (is_i_o) {
58926780d9eSBradley Grove u32 startlba;
59026780d9eSBradley Grove
59126780d9eSBradley Grove rq->vrq->scsi.iblk_cnt_prd = 0;
59226780d9eSBradley Grove
59326780d9eSBradley Grove /* Determine size of 1st I-block PRD list */
59426780d9eSBradley Grove startlba = t->inter_block - (lbalo & (t->inter_block -
59526780d9eSBradley Grove 1));
59626780d9eSBradley Grove sgc->length = startlba * t->block_size;
59726780d9eSBradley Grove
59826780d9eSBradley Grove /* Chk if the 1st iblk chain starts at base of Iblock */
59926780d9eSBradley Grove if ((lbalo & (t->inter_block - 1)) == 0)
60026780d9eSBradley Grove rq->flags |= RF_1ST_IBLK_BASE;
60126780d9eSBradley Grove
60226780d9eSBradley Grove if (sgc->length > len)
60326780d9eSBradley Grove sgc->length = len;
60426780d9eSBradley Grove } else {
60526780d9eSBradley Grove sgc->length = len;
60626780d9eSBradley Grove }
60726780d9eSBradley Grove } else {
60826780d9eSBradley Grove sgc->length = len;
60926780d9eSBradley Grove }
61026780d9eSBradley Grove
61126780d9eSBradley Grove /* get our starting chain address */
61226780d9eSBradley Grove
61326780d9eSBradley Grove curr_iblk_chn =
61426780d9eSBradley Grove (struct atto_physical_region_description *)sgc->sge.a64.curr;
61526780d9eSBradley Grove
61626780d9eSBradley Grove sgc->sge.prd.sgl_max_cnt = sgl_page_size /
61726780d9eSBradley Grove sizeof(struct
61826780d9eSBradley Grove atto_physical_region_description);
61926780d9eSBradley Grove
62026780d9eSBradley Grove /* create all of the I-block PRD lists */
62126780d9eSBradley Grove
62226780d9eSBradley Grove while (len) {
62326780d9eSBradley Grove sgc->sge.prd.sge_cnt = 0;
62426780d9eSBradley Grove sgc->sge.prd.chain = NULL;
62526780d9eSBradley Grove sgc->sge.prd.curr = curr_iblk_chn;
62626780d9eSBradley Grove
62726780d9eSBradley Grove /* increment to next I-Block */
62826780d9eSBradley Grove
62926780d9eSBradley Grove len -= sgc->length;
63026780d9eSBradley Grove
63126780d9eSBradley Grove /* go build the next I-Block PRD list */
63226780d9eSBradley Grove
63326780d9eSBradley Grove if (unlikely(!esas2r_build_prd_iblk(a, sgc)))
63426780d9eSBradley Grove return false;
63526780d9eSBradley Grove
63626780d9eSBradley Grove curr_iblk_chn++;
63726780d9eSBradley Grove
63826780d9eSBradley Grove if (is_i_o) {
63926780d9eSBradley Grove rq->vrq->scsi.iblk_cnt_prd++;
64026780d9eSBradley Grove
64126780d9eSBradley Grove if (len > t->inter_byte)
64226780d9eSBradley Grove sgc->length = t->inter_byte;
64326780d9eSBradley Grove else
64426780d9eSBradley Grove sgc->length = len;
64526780d9eSBradley Grove }
64626780d9eSBradley Grove }
64726780d9eSBradley Grove
64826780d9eSBradley Grove /* figure out the size used of the VDA request */
64926780d9eSBradley Grove
65026780d9eSBradley Grove reqsize = ((u16)((u8 *)curr_iblk_chn - (u8 *)rq->vrq))
65126780d9eSBradley Grove / sizeof(u32);
65226780d9eSBradley Grove
65326780d9eSBradley Grove /*
65426780d9eSBradley Grove * only update the request size if it is bigger than what is
65526780d9eSBradley Grove * already there. we can come in here twice for some management
65626780d9eSBradley Grove * commands.
65726780d9eSBradley Grove */
65826780d9eSBradley Grove
65926780d9eSBradley Grove if (reqsize > rq->vda_req_sz)
66026780d9eSBradley Grove rq->vda_req_sz = reqsize;
66126780d9eSBradley Grove
66226780d9eSBradley Grove return true;
66326780d9eSBradley Grove }
66426780d9eSBradley Grove
esas2r_handle_pending_reset(struct esas2r_adapter * a,u32 currtime)66526780d9eSBradley Grove static void esas2r_handle_pending_reset(struct esas2r_adapter *a, u32 currtime)
66626780d9eSBradley Grove {
66726780d9eSBradley Grove u32 delta = currtime - a->chip_init_time;
66826780d9eSBradley Grove
66926780d9eSBradley Grove if (delta <= ESAS2R_CHPRST_WAIT_TIME) {
67026780d9eSBradley Grove /* Wait before accessing registers */
67126780d9eSBradley Grove } else if (delta >= ESAS2R_CHPRST_TIME) {
67226780d9eSBradley Grove /*
67326780d9eSBradley Grove * The last reset failed so try again. Reset
67426780d9eSBradley Grove * processing will give up after three tries.
67526780d9eSBradley Grove */
67626780d9eSBradley Grove esas2r_local_reset_adapter(a);
67726780d9eSBradley Grove } else {
67826780d9eSBradley Grove /* We can now see if the firmware is ready */
67926780d9eSBradley Grove u32 doorbell;
68026780d9eSBradley Grove
68126780d9eSBradley Grove doorbell = esas2r_read_register_dword(a, MU_DOORBELL_OUT);
68226780d9eSBradley Grove if (doorbell == 0xFFFFFFFF || !(doorbell & DRBL_FORCE_INT)) {
68326780d9eSBradley Grove esas2r_force_interrupt(a);
68426780d9eSBradley Grove } else {
68526780d9eSBradley Grove u32 ver = (doorbell & DRBL_FW_VER_MSK);
68626780d9eSBradley Grove
68726780d9eSBradley Grove /* Driver supports API version 0 and 1 */
68826780d9eSBradley Grove esas2r_write_register_dword(a, MU_DOORBELL_OUT,
68926780d9eSBradley Grove doorbell);
69026780d9eSBradley Grove if (ver == DRBL_FW_VER_0) {
6919588d24eSBradley Grove set_bit(AF_CHPRST_DETECTED, &a->flags);
6929588d24eSBradley Grove set_bit(AF_LEGACY_SGE_MODE, &a->flags);
69326780d9eSBradley Grove
69426780d9eSBradley Grove a->max_vdareq_size = 128;
69526780d9eSBradley Grove a->build_sgl = esas2r_build_sg_list_sge;
69626780d9eSBradley Grove } else if (ver == DRBL_FW_VER_1) {
6979588d24eSBradley Grove set_bit(AF_CHPRST_DETECTED, &a->flags);
6989588d24eSBradley Grove clear_bit(AF_LEGACY_SGE_MODE, &a->flags);
69926780d9eSBradley Grove
70026780d9eSBradley Grove a->max_vdareq_size = 1024;
70126780d9eSBradley Grove a->build_sgl = esas2r_build_sg_list_prd;
70226780d9eSBradley Grove } else {
70326780d9eSBradley Grove esas2r_local_reset_adapter(a);
70426780d9eSBradley Grove }
70526780d9eSBradley Grove }
70626780d9eSBradley Grove }
70726780d9eSBradley Grove }
70826780d9eSBradley Grove
70926780d9eSBradley Grove
71026780d9eSBradley Grove /* This function must be called once per timer tick */
esas2r_timer_tick(struct esas2r_adapter * a)71126780d9eSBradley Grove void esas2r_timer_tick(struct esas2r_adapter *a)
71226780d9eSBradley Grove {
71326780d9eSBradley Grove u32 currtime = jiffies_to_msecs(jiffies);
71426780d9eSBradley Grove u32 deltatime = currtime - a->last_tick_time;
71526780d9eSBradley Grove
71626780d9eSBradley Grove a->last_tick_time = currtime;
71726780d9eSBradley Grove
71826780d9eSBradley Grove /* count down the uptime */
7199588d24eSBradley Grove if (a->chip_uptime &&
7209588d24eSBradley Grove !test_bit(AF_CHPRST_PENDING, &a->flags) &&
7219588d24eSBradley Grove !test_bit(AF_DISC_PENDING, &a->flags)) {
72226780d9eSBradley Grove if (deltatime >= a->chip_uptime)
72326780d9eSBradley Grove a->chip_uptime = 0;
72426780d9eSBradley Grove else
72526780d9eSBradley Grove a->chip_uptime -= deltatime;
72626780d9eSBradley Grove }
72726780d9eSBradley Grove
7289588d24eSBradley Grove if (test_bit(AF_CHPRST_PENDING, &a->flags)) {
7299588d24eSBradley Grove if (!test_bit(AF_CHPRST_NEEDED, &a->flags) &&
7309588d24eSBradley Grove !test_bit(AF_CHPRST_DETECTED, &a->flags))
73126780d9eSBradley Grove esas2r_handle_pending_reset(a, currtime);
73226780d9eSBradley Grove } else {
7339588d24eSBradley Grove if (test_bit(AF_DISC_PENDING, &a->flags))
73426780d9eSBradley Grove esas2r_disc_check_complete(a);
7359588d24eSBradley Grove if (test_bit(AF_HEARTBEAT_ENB, &a->flags)) {
7369588d24eSBradley Grove if (test_bit(AF_HEARTBEAT, &a->flags)) {
73726780d9eSBradley Grove if ((currtime - a->heartbeat_time) >=
73826780d9eSBradley Grove ESAS2R_HEARTBEAT_TIME) {
7399588d24eSBradley Grove clear_bit(AF_HEARTBEAT, &a->flags);
74026780d9eSBradley Grove esas2r_hdebug("heartbeat failed");
74126780d9eSBradley Grove esas2r_log(ESAS2R_LOG_CRIT,
74226780d9eSBradley Grove "heartbeat failed");
74326780d9eSBradley Grove esas2r_bugon();
74426780d9eSBradley Grove esas2r_local_reset_adapter(a);
74526780d9eSBradley Grove }
74626780d9eSBradley Grove } else {
7479588d24eSBradley Grove set_bit(AF_HEARTBEAT, &a->flags);
74826780d9eSBradley Grove a->heartbeat_time = currtime;
74926780d9eSBradley Grove esas2r_force_interrupt(a);
75026780d9eSBradley Grove }
75126780d9eSBradley Grove }
75226780d9eSBradley Grove }
75326780d9eSBradley Grove
75426780d9eSBradley Grove if (atomic_read(&a->disable_cnt) == 0)
75526780d9eSBradley Grove esas2r_do_deferred_processes(a);
75626780d9eSBradley Grove }
75726780d9eSBradley Grove
75826780d9eSBradley Grove /*
75926780d9eSBradley Grove * Send the specified task management function to the target and LUN
76026780d9eSBradley Grove * specified in rqaux. in addition, immediately abort any commands that
76126780d9eSBradley Grove * are queued but not sent to the device according to the rules specified
76226780d9eSBradley Grove * by the task management function.
76326780d9eSBradley Grove */
esas2r_send_task_mgmt(struct esas2r_adapter * a,struct esas2r_request * rqaux,u8 task_mgt_func)76426780d9eSBradley Grove bool esas2r_send_task_mgmt(struct esas2r_adapter *a,
76526780d9eSBradley Grove struct esas2r_request *rqaux, u8 task_mgt_func)
76626780d9eSBradley Grove {
76726780d9eSBradley Grove u16 targetid = rqaux->target_id;
76826780d9eSBradley Grove u8 lun = (u8)le32_to_cpu(rqaux->vrq->scsi.flags);
76926780d9eSBradley Grove bool ret = false;
77026780d9eSBradley Grove struct esas2r_request *rq;
77126780d9eSBradley Grove struct list_head *next, *element;
77226780d9eSBradley Grove unsigned long flags;
77326780d9eSBradley Grove
77426780d9eSBradley Grove LIST_HEAD(comp_list);
77526780d9eSBradley Grove
77626780d9eSBradley Grove esas2r_trace_enter();
77726780d9eSBradley Grove esas2r_trace("rqaux:%p", rqaux);
77826780d9eSBradley Grove esas2r_trace("task_mgt_func:%x", task_mgt_func);
77926780d9eSBradley Grove spin_lock_irqsave(&a->queue_lock, flags);
78026780d9eSBradley Grove
78126780d9eSBradley Grove /* search the defer queue looking for requests for the device */
78226780d9eSBradley Grove list_for_each_safe(element, next, &a->defer_list) {
78326780d9eSBradley Grove rq = list_entry(element, struct esas2r_request, req_list);
78426780d9eSBradley Grove
78526780d9eSBradley Grove if (rq->vrq->scsi.function == VDA_FUNC_SCSI
78626780d9eSBradley Grove && rq->target_id == targetid
78726780d9eSBradley Grove && (((u8)le32_to_cpu(rq->vrq->scsi.flags)) == lun
78826780d9eSBradley Grove || task_mgt_func == 0x20)) { /* target reset */
78926780d9eSBradley Grove /* Found a request affected by the task management */
79026780d9eSBradley Grove if (rq->req_stat == RS_PENDING) {
79126780d9eSBradley Grove /*
79226780d9eSBradley Grove * The request is pending or waiting. We can
79326780d9eSBradley Grove * safelycomplete the request now.
79426780d9eSBradley Grove */
79526780d9eSBradley Grove if (esas2r_ioreq_aborted(a, rq, RS_ABORTED))
79626780d9eSBradley Grove list_add_tail(&rq->comp_list,
79726780d9eSBradley Grove &comp_list);
79826780d9eSBradley Grove }
79926780d9eSBradley Grove }
80026780d9eSBradley Grove }
80126780d9eSBradley Grove
80226780d9eSBradley Grove /* Send the task management request to the firmware */
80326780d9eSBradley Grove rqaux->sense_len = 0;
80426780d9eSBradley Grove rqaux->vrq->scsi.length = 0;
80526780d9eSBradley Grove rqaux->target_id = targetid;
80626780d9eSBradley Grove rqaux->vrq->scsi.flags |= cpu_to_le32(lun);
80726780d9eSBradley Grove memset(rqaux->vrq->scsi.cdb, 0, sizeof(rqaux->vrq->scsi.cdb));
80826780d9eSBradley Grove rqaux->vrq->scsi.flags |=
80926780d9eSBradley Grove cpu_to_le16(task_mgt_func * LOBIT(FCP_CMND_TM_MASK));
81026780d9eSBradley Grove
8119588d24eSBradley Grove if (test_bit(AF_FLASHING, &a->flags)) {
81226780d9eSBradley Grove /* Assume success. if there are active requests, return busy */
81326780d9eSBradley Grove rqaux->req_stat = RS_SUCCESS;
81426780d9eSBradley Grove
81526780d9eSBradley Grove list_for_each_safe(element, next, &a->active_list) {
81626780d9eSBradley Grove rq = list_entry(element, struct esas2r_request,
81726780d9eSBradley Grove req_list);
81826780d9eSBradley Grove if (rq->vrq->scsi.function == VDA_FUNC_SCSI
81926780d9eSBradley Grove && rq->target_id == targetid
82026780d9eSBradley Grove && (((u8)le32_to_cpu(rq->vrq->scsi.flags)) == lun
82126780d9eSBradley Grove || task_mgt_func == 0x20)) /* target reset */
82226780d9eSBradley Grove rqaux->req_stat = RS_BUSY;
82326780d9eSBradley Grove }
82426780d9eSBradley Grove
82526780d9eSBradley Grove ret = true;
82626780d9eSBradley Grove }
82726780d9eSBradley Grove
82826780d9eSBradley Grove spin_unlock_irqrestore(&a->queue_lock, flags);
82926780d9eSBradley Grove
8309588d24eSBradley Grove if (!test_bit(AF_FLASHING, &a->flags))
83126780d9eSBradley Grove esas2r_start_request(a, rqaux);
83226780d9eSBradley Grove
83326780d9eSBradley Grove esas2r_comp_list_drain(a, &comp_list);
83426780d9eSBradley Grove
83526780d9eSBradley Grove if (atomic_read(&a->disable_cnt) == 0)
83626780d9eSBradley Grove esas2r_do_deferred_processes(a);
83726780d9eSBradley Grove
83826780d9eSBradley Grove esas2r_trace_exit();
83926780d9eSBradley Grove
84026780d9eSBradley Grove return ret;
84126780d9eSBradley Grove }
84226780d9eSBradley Grove
esas2r_reset_bus(struct esas2r_adapter * a)84326780d9eSBradley Grove void esas2r_reset_bus(struct esas2r_adapter *a)
84426780d9eSBradley Grove {
84526780d9eSBradley Grove esas2r_log(ESAS2R_LOG_INFO, "performing a bus reset");
84626780d9eSBradley Grove
8479588d24eSBradley Grove if (!test_bit(AF_DEGRADED_MODE, &a->flags) &&
8489588d24eSBradley Grove !test_bit(AF_CHPRST_PENDING, &a->flags) &&
8499588d24eSBradley Grove !test_bit(AF_DISC_PENDING, &a->flags)) {
8509588d24eSBradley Grove set_bit(AF_BUSRST_NEEDED, &a->flags);
8519588d24eSBradley Grove set_bit(AF_BUSRST_PENDING, &a->flags);
8529588d24eSBradley Grove set_bit(AF_OS_RESET, &a->flags);
85326780d9eSBradley Grove
85426780d9eSBradley Grove esas2r_schedule_tasklet(a);
85526780d9eSBradley Grove }
85626780d9eSBradley Grove }
85726780d9eSBradley Grove
esas2r_ioreq_aborted(struct esas2r_adapter * a,struct esas2r_request * rq,u8 status)85826780d9eSBradley Grove bool esas2r_ioreq_aborted(struct esas2r_adapter *a, struct esas2r_request *rq,
85926780d9eSBradley Grove u8 status)
86026780d9eSBradley Grove {
86126780d9eSBradley Grove esas2r_trace_enter();
86226780d9eSBradley Grove esas2r_trace("rq:%p", rq);
86326780d9eSBradley Grove list_del_init(&rq->req_list);
86426780d9eSBradley Grove if (rq->timeout > RQ_MAX_TIMEOUT) {
86526780d9eSBradley Grove /*
86626780d9eSBradley Grove * The request timed out, but we could not abort it because a
86726780d9eSBradley Grove * chip reset occurred. Return busy status.
86826780d9eSBradley Grove */
86926780d9eSBradley Grove rq->req_stat = RS_BUSY;
87026780d9eSBradley Grove esas2r_trace_exit();
87126780d9eSBradley Grove return true;
87226780d9eSBradley Grove }
87326780d9eSBradley Grove
87426780d9eSBradley Grove rq->req_stat = status;
87526780d9eSBradley Grove esas2r_trace_exit();
87626780d9eSBradley Grove return true;
87726780d9eSBradley Grove }
878