mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
944 lines
24 KiB
944 lines
24 KiB
/* |
|
* linux/drivers/scsi/esas2r/esas2r_int.c |
|
* esas2r interrupt handling |
|
* |
|
* Copyright (c) 2001-2013 ATTO Technology, Inc. |
|
* (mailto:[email protected]) |
|
*/ |
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ |
|
/* |
|
* 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; version 2 of the License. |
|
* |
|
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
*/ |
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ |
|
|
|
#include "esas2r.h" |
|
|
|
/* Local function prototypes */ |
|
static void esas2r_doorbell_interrupt(struct esas2r_adapter *a, u32 doorbell); |
|
static void esas2r_get_outbound_responses(struct esas2r_adapter *a); |
|
static void esas2r_process_bus_reset(struct esas2r_adapter *a); |
|
|
|
/* |
|
* Poll the adapter for interrupts and service them. |
|
* This function handles both legacy interrupts and MSI. |
|
*/ |
|
void esas2r_polled_interrupt(struct esas2r_adapter *a) |
|
{ |
|
u32 intstat; |
|
u32 doorbell; |
|
|
|
esas2r_disable_chip_interrupts(a); |
|
|
|
intstat = esas2r_read_register_dword(a, MU_INT_STATUS_OUT); |
|
|
|
if (intstat & MU_INTSTAT_POST_OUT) { |
|
/* clear the interrupt */ |
|
|
|
esas2r_write_register_dword(a, MU_OUT_LIST_INT_STAT, |
|
MU_OLIS_INT); |
|
esas2r_flush_register_dword(a, MU_OUT_LIST_INT_STAT); |
|
|
|
esas2r_get_outbound_responses(a); |
|
} |
|
|
|
if (intstat & MU_INTSTAT_DRBL) { |
|
doorbell = esas2r_read_register_dword(a, MU_DOORBELL_OUT); |
|
if (doorbell != 0) |
|
esas2r_doorbell_interrupt(a, doorbell); |
|
} |
|
|
|
esas2r_enable_chip_interrupts(a); |
|
|
|
if (atomic_read(&a->disable_cnt) == 0) |
|
esas2r_do_deferred_processes(a); |
|
} |
|
|
|
/* |
|
* Legacy and MSI interrupt handlers. Note that the legacy interrupt handler |
|
* schedules a TASKLET to process events, whereas the MSI handler just |
|
* processes interrupt events directly. |
|
*/ |
|
irqreturn_t esas2r_interrupt(int irq, void *dev_id) |
|
{ |
|
struct esas2r_adapter *a = (struct esas2r_adapter *)dev_id; |
|
|
|
if (!esas2r_adapter_interrupt_pending(a)) |
|
return IRQ_NONE; |
|
|
|
set_bit(AF2_INT_PENDING, &a->flags2); |
|
esas2r_schedule_tasklet(a); |
|
|
|
return IRQ_HANDLED; |
|
} |
|
|
|
void esas2r_adapter_interrupt(struct esas2r_adapter *a) |
|
{ |
|
u32 doorbell; |
|
|
|
if (likely(a->int_stat & MU_INTSTAT_POST_OUT)) { |
|
/* clear the interrupt */ |
|
esas2r_write_register_dword(a, MU_OUT_LIST_INT_STAT, |
|
MU_OLIS_INT); |
|
esas2r_flush_register_dword(a, MU_OUT_LIST_INT_STAT); |
|
esas2r_get_outbound_responses(a); |
|
} |
|
|
|
if (unlikely(a->int_stat & MU_INTSTAT_DRBL)) { |
|
doorbell = esas2r_read_register_dword(a, MU_DOORBELL_OUT); |
|
if (doorbell != 0) |
|
esas2r_doorbell_interrupt(a, doorbell); |
|
} |
|
|
|
a->int_mask = ESAS2R_INT_STS_MASK; |
|
|
|
esas2r_enable_chip_interrupts(a); |
|
|
|
if (likely(atomic_read(&a->disable_cnt) == 0)) |
|
esas2r_do_deferred_processes(a); |
|
} |
|
|
|
irqreturn_t esas2r_msi_interrupt(int irq, void *dev_id) |
|
{ |
|
struct esas2r_adapter *a = (struct esas2r_adapter *)dev_id; |
|
u32 intstat; |
|
u32 doorbell; |
|
|
|
intstat = esas2r_read_register_dword(a, MU_INT_STATUS_OUT); |
|
|
|
if (likely(intstat & MU_INTSTAT_POST_OUT)) { |
|
/* clear the interrupt */ |
|
|
|
esas2r_write_register_dword(a, MU_OUT_LIST_INT_STAT, |
|
MU_OLIS_INT); |
|
esas2r_flush_register_dword(a, MU_OUT_LIST_INT_STAT); |
|
|
|
esas2r_get_outbound_responses(a); |
|
} |
|
|
|
if (unlikely(intstat & MU_INTSTAT_DRBL)) { |
|
doorbell = esas2r_read_register_dword(a, MU_DOORBELL_OUT); |
|
if (doorbell != 0) |
|
esas2r_doorbell_interrupt(a, doorbell); |
|
} |
|
|
|
/* |
|
* Work around a chip bug and force a new MSI to be sent if one is |
|
* still pending. |
|
*/ |
|
esas2r_disable_chip_interrupts(a); |
|
esas2r_enable_chip_interrupts(a); |
|
|
|
if (likely(atomic_read(&a->disable_cnt) == 0)) |
|
esas2r_do_deferred_processes(a); |
|
|
|
esas2r_do_tasklet_tasks(a); |
|
|
|
return 1; |
|
} |
|
|
|
|
|
|
|
static void esas2r_handle_outbound_rsp_err(struct esas2r_adapter *a, |
|
struct esas2r_request *rq, |
|
struct atto_vda_ob_rsp *rsp) |
|
{ |
|
|
|
/* |
|
* For I/O requests, only copy the response if an error |
|
* occurred and setup a callback to do error processing. |
|
*/ |
|
if (unlikely(rq->req_stat != RS_SUCCESS)) { |
|
memcpy(&rq->func_rsp, &rsp->func_rsp, sizeof(rsp->func_rsp)); |
|
|
|
if (rq->req_stat == RS_ABORTED) { |
|
if (rq->timeout > RQ_MAX_TIMEOUT) |
|
rq->req_stat = RS_TIMEOUT; |
|
} else if (rq->req_stat == RS_SCSI_ERROR) { |
|
u8 scsistatus = rq->func_rsp.scsi_rsp.scsi_stat; |
|
|
|
esas2r_trace("scsistatus: %x", scsistatus); |
|
|
|
/* Any of these are a good result. */ |
|
if (scsistatus == SAM_STAT_GOOD || scsistatus == |
|
SAM_STAT_CONDITION_MET || scsistatus == |
|
SAM_STAT_INTERMEDIATE || scsistatus == |
|
SAM_STAT_INTERMEDIATE_CONDITION_MET) { |
|
rq->req_stat = RS_SUCCESS; |
|
rq->func_rsp.scsi_rsp.scsi_stat = |
|
SAM_STAT_GOOD; |
|
} |
|
} |
|
} |
|
} |
|
|
|
static void esas2r_get_outbound_responses(struct esas2r_adapter *a) |
|
{ |
|
struct atto_vda_ob_rsp *rsp; |
|
u32 rspput_ptr; |
|
u32 rspget_ptr; |
|
struct esas2r_request *rq; |
|
u32 handle; |
|
unsigned long flags; |
|
|
|
LIST_HEAD(comp_list); |
|
|
|
esas2r_trace_enter(); |
|
|
|
spin_lock_irqsave(&a->queue_lock, flags); |
|
|
|
/* Get the outbound limit and pointers */ |
|
rspput_ptr = le32_to_cpu(*a->outbound_copy) & MU_OLC_WRT_PTR; |
|
rspget_ptr = a->last_read; |
|
|
|
esas2r_trace("rspput_ptr: %x, rspget_ptr: %x", rspput_ptr, rspget_ptr); |
|
|
|
/* If we don't have anything to process, get out */ |
|
if (unlikely(rspget_ptr == rspput_ptr)) { |
|
spin_unlock_irqrestore(&a->queue_lock, flags); |
|
esas2r_trace_exit(); |
|
return; |
|
} |
|
|
|
/* Make sure the firmware is healthy */ |
|
if (unlikely(rspput_ptr >= a->list_size)) { |
|
spin_unlock_irqrestore(&a->queue_lock, flags); |
|
esas2r_bugon(); |
|
esas2r_local_reset_adapter(a); |
|
esas2r_trace_exit(); |
|
return; |
|
} |
|
|
|
do { |
|
rspget_ptr++; |
|
|
|
if (rspget_ptr >= a->list_size) |
|
rspget_ptr = 0; |
|
|
|
rsp = (struct atto_vda_ob_rsp *)a->outbound_list_md.virt_addr |
|
+ rspget_ptr; |
|
|
|
handle = rsp->handle; |
|
|
|
/* Verify the handle range */ |
|
if (unlikely(LOWORD(handle) == 0 |
|
|| LOWORD(handle) > num_requests + |
|
num_ae_requests + 1)) { |
|
esas2r_bugon(); |
|
continue; |
|
} |
|
|
|
/* Get the request for this handle */ |
|
rq = a->req_table[LOWORD(handle)]; |
|
|
|
if (unlikely(rq == NULL || rq->vrq->scsi.handle != handle)) { |
|
esas2r_bugon(); |
|
continue; |
|
} |
|
|
|
list_del(&rq->req_list); |
|
|
|
/* Get the completion status */ |
|
rq->req_stat = rsp->req_stat; |
|
|
|
esas2r_trace("handle: %x", handle); |
|
esas2r_trace("rq: %p", rq); |
|
esas2r_trace("req_status: %x", rq->req_stat); |
|
|
|
if (likely(rq->vrq->scsi.function == VDA_FUNC_SCSI)) { |
|
esas2r_handle_outbound_rsp_err(a, rq, rsp); |
|
} else { |
|
/* |
|
* Copy the outbound completion struct for non-I/O |
|
* requests. |
|
*/ |
|
memcpy(&rq->func_rsp, &rsp->func_rsp, |
|
sizeof(rsp->func_rsp)); |
|
} |
|
|
|
/* Queue the request for completion. */ |
|
list_add_tail(&rq->comp_list, &comp_list); |
|
|
|
} while (rspget_ptr != rspput_ptr); |
|
|
|
a->last_read = rspget_ptr; |
|
spin_unlock_irqrestore(&a->queue_lock, flags); |
|
|
|
esas2r_comp_list_drain(a, &comp_list); |
|
esas2r_trace_exit(); |
|
} |
|
|
|
/* |
|
* Perform all deferred processes for the adapter. Deferred |
|
* processes can only be done while the current interrupt |
|
* disable_cnt for the adapter is zero. |
|
*/ |
|
void esas2r_do_deferred_processes(struct esas2r_adapter *a) |
|
{ |
|
int startreqs = 2; |
|
struct esas2r_request *rq; |
|
unsigned long flags; |
|
|
|
/* |
|
* startreqs is used to control starting requests |
|
* that are on the deferred queue |
|
* = 0 - do not start any requests |
|
* = 1 - can start discovery requests |
|
* = 2 - can start any request |
|
*/ |
|
|
|
if (test_bit(AF_CHPRST_PENDING, &a->flags) || |
|
test_bit(AF_FLASHING, &a->flags)) |
|
startreqs = 0; |
|
else if (test_bit(AF_DISC_PENDING, &a->flags)) |
|
startreqs = 1; |
|
|
|
atomic_inc(&a->disable_cnt); |
|
|
|
/* Clear off the completed list to be processed later. */ |
|
|
|
if (esas2r_is_tasklet_pending(a)) { |
|
esas2r_schedule_tasklet(a); |
|
|
|
startreqs = 0; |
|
} |
|
|
|
/* |
|
* If we can start requests then traverse the defer queue |
|
* looking for requests to start or complete |
|
*/ |
|
if (startreqs && !list_empty(&a->defer_list)) { |
|
LIST_HEAD(comp_list); |
|
struct list_head *element, *next; |
|
|
|
spin_lock_irqsave(&a->queue_lock, flags); |
|
|
|
list_for_each_safe(element, next, &a->defer_list) { |
|
rq = list_entry(element, struct esas2r_request, |
|
req_list); |
|
|
|
if (rq->req_stat != RS_PENDING) { |
|
list_del(element); |
|
list_add_tail(&rq->comp_list, &comp_list); |
|
} |
|
/* |
|
* Process discovery and OS requests separately. We |
|
* can't hold up discovery requests when discovery is |
|
* pending. In general, there may be different sets of |
|
* conditions for starting different types of requests. |
|
*/ |
|
else if (rq->req_type == RT_DISC_REQ) { |
|
list_del(element); |
|
esas2r_disc_local_start_request(a, rq); |
|
} else if (startreqs == 2) { |
|
list_del(element); |
|
esas2r_local_start_request(a, rq); |
|
|
|
/* |
|
* Flashing could have been set by last local |
|
* start |
|
*/ |
|
if (test_bit(AF_FLASHING, &a->flags)) |
|
break; |
|
} |
|
} |
|
|
|
spin_unlock_irqrestore(&a->queue_lock, flags); |
|
esas2r_comp_list_drain(a, &comp_list); |
|
} |
|
|
|
atomic_dec(&a->disable_cnt); |
|
} |
|
|
|
/* |
|
* Process an adapter reset (or one that is about to happen) |
|
* by making sure all outstanding requests are completed that |
|
* haven't been already. |
|
*/ |
|
void esas2r_process_adapter_reset(struct esas2r_adapter *a) |
|
{ |
|
struct esas2r_request *rq = &a->general_req; |
|
unsigned long flags; |
|
struct esas2r_disc_context *dc; |
|
|
|
LIST_HEAD(comp_list); |
|
struct list_head *element; |
|
|
|
esas2r_trace_enter(); |
|
|
|
spin_lock_irqsave(&a->queue_lock, flags); |
|
|
|
/* abort the active discovery, if any. */ |
|
|
|
if (rq->interrupt_cx) { |
|
dc = (struct esas2r_disc_context *)rq->interrupt_cx; |
|
|
|
dc->disc_evt = 0; |
|
|
|
clear_bit(AF_DISC_IN_PROG, &a->flags); |
|
} |
|
|
|
/* |
|
* just clear the interrupt callback for now. it will be dequeued if |
|
* and when we find it on the active queue and we don't want the |
|
* callback called. also set the dummy completion callback in case we |
|
* were doing an I/O request. |
|
*/ |
|
|
|
rq->interrupt_cx = NULL; |
|
rq->interrupt_cb = NULL; |
|
|
|
rq->comp_cb = esas2r_dummy_complete; |
|
|
|
/* Reset the read and write pointers */ |
|
|
|
*a->outbound_copy = |
|
a->last_write = |
|
a->last_read = a->list_size - 1; |
|
|
|
set_bit(AF_COMM_LIST_TOGGLE, &a->flags); |
|
|
|
/* Kill all the requests on the active list */ |
|
list_for_each(element, &a->defer_list) { |
|
rq = list_entry(element, struct esas2r_request, req_list); |
|
|
|
if (rq->req_stat == RS_STARTED) |
|
if (esas2r_ioreq_aborted(a, rq, RS_ABORTED)) |
|
list_add_tail(&rq->comp_list, &comp_list); |
|
} |
|
|
|
spin_unlock_irqrestore(&a->queue_lock, flags); |
|
esas2r_comp_list_drain(a, &comp_list); |
|
esas2r_process_bus_reset(a); |
|
esas2r_trace_exit(); |
|
} |
|
|
|
static void esas2r_process_bus_reset(struct esas2r_adapter *a) |
|
{ |
|
struct esas2r_request *rq; |
|
struct list_head *element; |
|
unsigned long flags; |
|
|
|
LIST_HEAD(comp_list); |
|
|
|
esas2r_trace_enter(); |
|
|
|
esas2r_hdebug("reset detected"); |
|
|
|
spin_lock_irqsave(&a->queue_lock, flags); |
|
|
|
/* kill all the requests on the deferred queue */ |
|
list_for_each(element, &a->defer_list) { |
|
rq = list_entry(element, struct esas2r_request, req_list); |
|
if (esas2r_ioreq_aborted(a, rq, RS_ABORTED)) |
|
list_add_tail(&rq->comp_list, &comp_list); |
|
} |
|
|
|
spin_unlock_irqrestore(&a->queue_lock, flags); |
|
|
|
esas2r_comp_list_drain(a, &comp_list); |
|
|
|
if (atomic_read(&a->disable_cnt) == 0) |
|
esas2r_do_deferred_processes(a); |
|
|
|
clear_bit(AF_OS_RESET, &a->flags); |
|
|
|
esas2r_trace_exit(); |
|
} |
|
|
|
static void esas2r_chip_rst_needed_during_tasklet(struct esas2r_adapter *a) |
|
{ |
|
|
|
clear_bit(AF_CHPRST_NEEDED, &a->flags); |
|
clear_bit(AF_BUSRST_NEEDED, &a->flags); |
|
clear_bit(AF_BUSRST_DETECTED, &a->flags); |
|
clear_bit(AF_BUSRST_PENDING, &a->flags); |
|
/* |
|
* Make sure we don't get attempt more than 3 resets |
|
* when the uptime between resets does not exceed one |
|
* minute. This will stop any situation where there is |
|
* really something wrong with the hardware. The way |
|
* this works is that we start with uptime ticks at 0. |
|
* Each time we do a reset, we add 20 seconds worth to |
|
* the count. Each time a timer tick occurs, as long |
|
* as a chip reset is not pending, we decrement the |
|
* tick count. If the uptime ticks ever gets to 60 |
|
* seconds worth, we disable the adapter from that |
|
* point forward. Three strikes, you're out. |
|
*/ |
|
if (!esas2r_is_adapter_present(a) || (a->chip_uptime >= |
|
ESAS2R_CHP_UPTIME_MAX)) { |
|
esas2r_hdebug("*** adapter disabled ***"); |
|
|
|
/* |
|
* Ok, some kind of hard failure. Make sure we |
|
* exit this loop with chip interrupts |
|
* permanently disabled so we don't lock up the |
|
* entire system. Also flag degraded mode to |
|
* prevent the heartbeat from trying to recover. |
|
*/ |
|
|
|
set_bit(AF_DEGRADED_MODE, &a->flags); |
|
set_bit(AF_DISABLED, &a->flags); |
|
clear_bit(AF_CHPRST_PENDING, &a->flags); |
|
clear_bit(AF_DISC_PENDING, &a->flags); |
|
|
|
esas2r_disable_chip_interrupts(a); |
|
a->int_mask = 0; |
|
esas2r_process_adapter_reset(a); |
|
|
|
esas2r_log(ESAS2R_LOG_CRIT, |
|
"Adapter disabled because of hardware failure"); |
|
} else { |
|
bool alrdyrst = test_and_set_bit(AF_CHPRST_STARTED, &a->flags); |
|
|
|
if (!alrdyrst) |
|
/* |
|
* Only disable interrupts if this is |
|
* the first reset attempt. |
|
*/ |
|
esas2r_disable_chip_interrupts(a); |
|
|
|
if ((test_bit(AF_POWER_MGT, &a->flags)) && |
|
!test_bit(AF_FIRST_INIT, &a->flags) && !alrdyrst) { |
|
/* |
|
* Don't reset the chip on the first |
|
* deferred power up attempt. |
|
*/ |
|
} else { |
|
esas2r_hdebug("*** resetting chip ***"); |
|
esas2r_reset_chip(a); |
|
} |
|
|
|
/* Kick off the reinitialization */ |
|
a->chip_uptime += ESAS2R_CHP_UPTIME_CNT; |
|
a->chip_init_time = jiffies_to_msecs(jiffies); |
|
if (!test_bit(AF_POWER_MGT, &a->flags)) { |
|
esas2r_process_adapter_reset(a); |
|
|
|
if (!alrdyrst) { |
|
/* Remove devices now that I/O is cleaned up. */ |
|
a->prev_dev_cnt = |
|
esas2r_targ_db_get_tgt_cnt(a); |
|
esas2r_targ_db_remove_all(a, false); |
|
} |
|
} |
|
|
|
a->int_mask = 0; |
|
} |
|
} |
|
|
|
static void esas2r_handle_chip_rst_during_tasklet(struct esas2r_adapter *a) |
|
{ |
|
while (test_bit(AF_CHPRST_DETECTED, &a->flags)) { |
|
/* |
|
* Balance the enable in esas2r_initadapter_hw. |
|
* Esas2r_power_down already took care of it for power |
|
* management. |
|
*/ |
|
if (!test_bit(AF_DEGRADED_MODE, &a->flags) && |
|
!test_bit(AF_POWER_MGT, &a->flags)) |
|
esas2r_disable_chip_interrupts(a); |
|
|
|
/* Reinitialize the chip. */ |
|
esas2r_check_adapter(a); |
|
esas2r_init_adapter_hw(a, 0); |
|
|
|
if (test_bit(AF_CHPRST_NEEDED, &a->flags)) |
|
break; |
|
|
|
if (test_bit(AF_POWER_MGT, &a->flags)) { |
|
/* Recovery from power management. */ |
|
if (test_bit(AF_FIRST_INIT, &a->flags)) { |
|
/* Chip reset during normal power up */ |
|
esas2r_log(ESAS2R_LOG_CRIT, |
|
"The firmware was reset during a normal power-up sequence"); |
|
} else { |
|
/* Deferred power up complete. */ |
|
clear_bit(AF_POWER_MGT, &a->flags); |
|
esas2r_send_reset_ae(a, true); |
|
} |
|
} else { |
|
/* Recovery from online chip reset. */ |
|
if (test_bit(AF_FIRST_INIT, &a->flags)) { |
|
/* Chip reset during driver load */ |
|
} else { |
|
/* Chip reset after driver load */ |
|
esas2r_send_reset_ae(a, false); |
|
} |
|
|
|
esas2r_log(ESAS2R_LOG_CRIT, |
|
"Recovering from a chip reset while the chip was online"); |
|
} |
|
|
|
clear_bit(AF_CHPRST_STARTED, &a->flags); |
|
esas2r_enable_chip_interrupts(a); |
|
|
|
/* |
|
* Clear this flag last! this indicates that the chip has been |
|
* reset already during initialization. |
|
*/ |
|
clear_bit(AF_CHPRST_DETECTED, &a->flags); |
|
} |
|
} |
|
|
|
|
|
/* Perform deferred tasks when chip interrupts are disabled */ |
|
void esas2r_do_tasklet_tasks(struct esas2r_adapter *a) |
|
{ |
|
|
|
if (test_bit(AF_CHPRST_NEEDED, &a->flags) || |
|
test_bit(AF_CHPRST_DETECTED, &a->flags)) { |
|
if (test_bit(AF_CHPRST_NEEDED, &a->flags)) |
|
esas2r_chip_rst_needed_during_tasklet(a); |
|
|
|
esas2r_handle_chip_rst_during_tasklet(a); |
|
} |
|
|
|
if (test_bit(AF_BUSRST_NEEDED, &a->flags)) { |
|
esas2r_hdebug("hard resetting bus"); |
|
|
|
clear_bit(AF_BUSRST_NEEDED, &a->flags); |
|
|
|
if (test_bit(AF_FLASHING, &a->flags)) |
|
set_bit(AF_BUSRST_DETECTED, &a->flags); |
|
else |
|
esas2r_write_register_dword(a, MU_DOORBELL_IN, |
|
DRBL_RESET_BUS); |
|
} |
|
|
|
if (test_bit(AF_BUSRST_DETECTED, &a->flags)) { |
|
esas2r_process_bus_reset(a); |
|
|
|
esas2r_log_dev(ESAS2R_LOG_WARN, |
|
&(a->host->shost_gendev), |
|
"scsi_report_bus_reset() called"); |
|
|
|
scsi_report_bus_reset(a->host, 0); |
|
|
|
clear_bit(AF_BUSRST_DETECTED, &a->flags); |
|
clear_bit(AF_BUSRST_PENDING, &a->flags); |
|
|
|
esas2r_log(ESAS2R_LOG_WARN, "Bus reset complete"); |
|
} |
|
|
|
if (test_bit(AF_PORT_CHANGE, &a->flags)) { |
|
clear_bit(AF_PORT_CHANGE, &a->flags); |
|
|
|
esas2r_targ_db_report_changes(a); |
|
} |
|
|
|
if (atomic_read(&a->disable_cnt) == 0) |
|
esas2r_do_deferred_processes(a); |
|
} |
|
|
|
static void esas2r_doorbell_interrupt(struct esas2r_adapter *a, u32 doorbell) |
|
{ |
|
if (!(doorbell & DRBL_FORCE_INT)) { |
|
esas2r_trace_enter(); |
|
esas2r_trace("doorbell: %x", doorbell); |
|
} |
|
|
|
/* First clear the doorbell bits */ |
|
esas2r_write_register_dword(a, MU_DOORBELL_OUT, doorbell); |
|
|
|
if (doorbell & DRBL_RESET_BUS) |
|
set_bit(AF_BUSRST_DETECTED, &a->flags); |
|
|
|
if (doorbell & DRBL_FORCE_INT) |
|
clear_bit(AF_HEARTBEAT, &a->flags); |
|
|
|
if (doorbell & DRBL_PANIC_REASON_MASK) { |
|
esas2r_hdebug("*** Firmware Panic ***"); |
|
esas2r_log(ESAS2R_LOG_CRIT, "The firmware has panicked"); |
|
} |
|
|
|
if (doorbell & DRBL_FW_RESET) { |
|
set_bit(AF2_COREDUMP_AVAIL, &a->flags2); |
|
esas2r_local_reset_adapter(a); |
|
} |
|
|
|
if (!(doorbell & DRBL_FORCE_INT)) { |
|
esas2r_trace_exit(); |
|
} |
|
} |
|
|
|
void esas2r_force_interrupt(struct esas2r_adapter *a) |
|
{ |
|
esas2r_write_register_dword(a, MU_DOORBELL_IN, DRBL_FORCE_INT | |
|
DRBL_DRV_VER); |
|
} |
|
|
|
|
|
static void esas2r_lun_event(struct esas2r_adapter *a, union atto_vda_ae *ae, |
|
u16 target, u32 length) |
|
{ |
|
struct esas2r_target *t = a->targetdb + target; |
|
u32 cplen = length; |
|
unsigned long flags; |
|
|
|
if (cplen > sizeof(t->lu_event)) |
|
cplen = sizeof(t->lu_event); |
|
|
|
esas2r_trace("ae->lu.dwevent: %x", ae->lu.dwevent); |
|
esas2r_trace("ae->lu.bystate: %x", ae->lu.bystate); |
|
|
|
spin_lock_irqsave(&a->mem_lock, flags); |
|
|
|
t->new_target_state = TS_INVALID; |
|
|
|
if (ae->lu.dwevent & VDAAE_LU_LOST) { |
|
t->new_target_state = TS_NOT_PRESENT; |
|
} else { |
|
switch (ae->lu.bystate) { |
|
case VDAAE_LU_NOT_PRESENT: |
|
case VDAAE_LU_OFFLINE: |
|
case VDAAE_LU_DELETED: |
|
case VDAAE_LU_FACTORY_DISABLED: |
|
t->new_target_state = TS_NOT_PRESENT; |
|
break; |
|
|
|
case VDAAE_LU_ONLINE: |
|
case VDAAE_LU_DEGRADED: |
|
t->new_target_state = TS_PRESENT; |
|
break; |
|
} |
|
} |
|
|
|
if (t->new_target_state != TS_INVALID) { |
|
memcpy(&t->lu_event, &ae->lu, cplen); |
|
|
|
esas2r_disc_queue_event(a, DCDE_DEV_CHANGE); |
|
} |
|
|
|
spin_unlock_irqrestore(&a->mem_lock, flags); |
|
} |
|
|
|
|
|
|
|
void esas2r_ae_complete(struct esas2r_adapter *a, struct esas2r_request *rq) |
|
{ |
|
union atto_vda_ae *ae = |
|
(union atto_vda_ae *)rq->vda_rsp_data->ae_data.event_data; |
|
u32 length = le32_to_cpu(rq->func_rsp.ae_rsp.length); |
|
union atto_vda_ae *last = |
|
(union atto_vda_ae *)(rq->vda_rsp_data->ae_data.event_data |
|
+ length); |
|
|
|
esas2r_trace_enter(); |
|
esas2r_trace("length: %d", length); |
|
|
|
if (length > sizeof(struct atto_vda_ae_data) |
|
|| (length & 3) != 0 |
|
|| length == 0) { |
|
esas2r_log(ESAS2R_LOG_WARN, |
|
"The AE request response length (%p) is too long: %d", |
|
rq, length); |
|
|
|
esas2r_hdebug("aereq->length (0x%x) too long", length); |
|
esas2r_bugon(); |
|
|
|
last = ae; |
|
} |
|
|
|
while (ae < last) { |
|
u16 target; |
|
|
|
esas2r_trace("ae: %p", ae); |
|
esas2r_trace("ae->hdr: %p", &(ae->hdr)); |
|
|
|
length = ae->hdr.bylength; |
|
|
|
if (length > (u32)((u8 *)last - (u8 *)ae) |
|
|| (length & 3) != 0 |
|
|| length == 0) { |
|
esas2r_log(ESAS2R_LOG_CRIT, |
|
"the async event length is invalid (%p): %d", |
|
ae, length); |
|
|
|
esas2r_hdebug("ae->hdr.length (0x%x) invalid", length); |
|
esas2r_bugon(); |
|
|
|
break; |
|
} |
|
|
|
esas2r_nuxi_ae_data(ae); |
|
|
|
esas2r_queue_fw_event(a, fw_event_vda_ae, ae, |
|
sizeof(union atto_vda_ae)); |
|
|
|
switch (ae->hdr.bytype) { |
|
case VDAAE_HDR_TYPE_RAID: |
|
|
|
if (ae->raid.dwflags & (VDAAE_GROUP_STATE |
|
| VDAAE_RBLD_STATE |
|
| VDAAE_MEMBER_CHG |
|
| VDAAE_PART_CHG)) { |
|
esas2r_log(ESAS2R_LOG_INFO, |
|
"RAID event received - name:%s rebuild_state:%d group_state:%d", |
|
ae->raid.acname, |
|
ae->raid.byrebuild_state, |
|
ae->raid.bygroup_state); |
|
} |
|
|
|
break; |
|
|
|
case VDAAE_HDR_TYPE_LU: |
|
esas2r_log(ESAS2R_LOG_INFO, |
|
"LUN event received: event:%d target_id:%d LUN:%d state:%d", |
|
ae->lu.dwevent, |
|
ae->lu.id.tgtlun.wtarget_id, |
|
ae->lu.id.tgtlun.bylun, |
|
ae->lu.bystate); |
|
|
|
target = ae->lu.id.tgtlun.wtarget_id; |
|
|
|
if (target < ESAS2R_MAX_TARGETS) |
|
esas2r_lun_event(a, ae, target, length); |
|
|
|
break; |
|
|
|
case VDAAE_HDR_TYPE_DISK: |
|
esas2r_log(ESAS2R_LOG_INFO, "Disk event received"); |
|
break; |
|
|
|
default: |
|
|
|
/* Silently ignore the rest and let the apps deal with |
|
* them. |
|
*/ |
|
|
|
break; |
|
} |
|
|
|
ae = (union atto_vda_ae *)((u8 *)ae + length); |
|
} |
|
|
|
/* Now requeue it. */ |
|
esas2r_start_ae_request(a, rq); |
|
esas2r_trace_exit(); |
|
} |
|
|
|
/* Send an asynchronous event for a chip reset or power management. */ |
|
void esas2r_send_reset_ae(struct esas2r_adapter *a, bool pwr_mgt) |
|
{ |
|
struct atto_vda_ae_hdr ae; |
|
|
|
if (pwr_mgt) |
|
ae.bytype = VDAAE_HDR_TYPE_PWRMGT; |
|
else |
|
ae.bytype = VDAAE_HDR_TYPE_RESET; |
|
|
|
ae.byversion = VDAAE_HDR_VER_0; |
|
ae.byflags = 0; |
|
ae.bylength = (u8)sizeof(struct atto_vda_ae_hdr); |
|
|
|
if (pwr_mgt) { |
|
esas2r_hdebug("*** sending power management AE ***"); |
|
} else { |
|
esas2r_hdebug("*** sending reset AE ***"); |
|
} |
|
|
|
esas2r_queue_fw_event(a, fw_event_vda_ae, &ae, |
|
sizeof(union atto_vda_ae)); |
|
} |
|
|
|
void esas2r_dummy_complete(struct esas2r_adapter *a, struct esas2r_request *rq) |
|
{} |
|
|
|
static void esas2r_check_req_rsp_sense(struct esas2r_adapter *a, |
|
struct esas2r_request *rq) |
|
{ |
|
u8 snslen, snslen2; |
|
|
|
snslen = snslen2 = rq->func_rsp.scsi_rsp.sense_len; |
|
|
|
if (snslen > rq->sense_len) |
|
snslen = rq->sense_len; |
|
|
|
if (snslen) { |
|
if (rq->sense_buf) |
|
memcpy(rq->sense_buf, rq->data_buf, snslen); |
|
else |
|
rq->sense_buf = (u8 *)rq->data_buf; |
|
|
|
/* See about possible sense data */ |
|
if (snslen2 > 0x0c) { |
|
u8 *s = (u8 *)rq->data_buf; |
|
|
|
esas2r_trace_enter(); |
|
|
|
/* Report LUNS data has changed */ |
|
if (s[0x0c] == 0x3f && s[0x0d] == 0x0E) { |
|
esas2r_trace("rq->target_id: %d", |
|
rq->target_id); |
|
esas2r_target_state_changed(a, rq->target_id, |
|
TS_LUN_CHANGE); |
|
} |
|
|
|
esas2r_trace("add_sense_key=%x", s[0x0c]); |
|
esas2r_trace("add_sense_qual=%x", s[0x0d]); |
|
esas2r_trace_exit(); |
|
} |
|
} |
|
|
|
rq->sense_len = snslen; |
|
} |
|
|
|
|
|
void esas2r_complete_request(struct esas2r_adapter *a, |
|
struct esas2r_request *rq) |
|
{ |
|
if (rq->vrq->scsi.function == VDA_FUNC_FLASH |
|
&& rq->vrq->flash.sub_func == VDA_FLASH_COMMIT) |
|
clear_bit(AF_FLASHING, &a->flags); |
|
|
|
/* See if we setup a callback to do special processing */ |
|
|
|
if (rq->interrupt_cb) { |
|
(*rq->interrupt_cb)(a, rq); |
|
|
|
if (rq->req_stat == RS_PENDING) { |
|
esas2r_start_request(a, rq); |
|
return; |
|
} |
|
} |
|
|
|
if (likely(rq->vrq->scsi.function == VDA_FUNC_SCSI) |
|
&& unlikely(rq->req_stat != RS_SUCCESS)) { |
|
esas2r_check_req_rsp_sense(a, rq); |
|
esas2r_log_request_failure(a, rq); |
|
} |
|
|
|
(*rq->comp_cb)(a, rq); |
|
}
|
|
|