7624 lines
214 KiB
C
7624 lines
214 KiB
C
/*
|
|
* linux/drivers/message/fusion/mptbase.c
|
|
* This is the Fusion MPT base driver which supports multiple
|
|
* (SCSI + LAN) specialized protocol drivers.
|
|
* For use with LSI PCI chip/adapter(s)
|
|
* running LSI Fusion MPT (Message Passing Technology) firmware.
|
|
*
|
|
* Copyright (c) 1999-2008 LSI Corporation
|
|
* (mailto:DL-MPTFusionLinux@lsi.com)
|
|
*
|
|
*/
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/*
|
|
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 <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/init.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/types.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/kdev_t.h>
|
|
#include <linux/blkdev.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/interrupt.h> /* needed for in_interrupt() proto */
|
|
#include <linux/dma-mapping.h>
|
|
#include <asm/io.h>
|
|
#ifdef CONFIG_MTRR
|
|
#include <asm/mtrr.h>
|
|
#endif
|
|
|
|
#include "mptbase.h"
|
|
#include "lsi/mpi_log_fc.h"
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
#define my_NAME "Fusion MPT base driver"
|
|
#define my_VERSION MPT_LINUX_VERSION_COMMON
|
|
#define MYNAM "mptbase"
|
|
|
|
MODULE_AUTHOR(MODULEAUTHOR);
|
|
MODULE_DESCRIPTION(my_NAME);
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_VERSION(my_VERSION);
|
|
|
|
/*
|
|
* cmd line parameters
|
|
*/
|
|
static int mpt_msi_enable = -1;
|
|
module_param(mpt_msi_enable, int, 0);
|
|
MODULE_PARM_DESC(mpt_msi_enable, " MSI Support Enable (default=0)");
|
|
|
|
static int mpt_channel_mapping;
|
|
module_param(mpt_channel_mapping, int, 0);
|
|
MODULE_PARM_DESC(mpt_channel_mapping, " Mapping id's to channels (default=0)");
|
|
|
|
static int mpt_debug_level;
|
|
static int mpt_set_debug_level(const char *val, struct kernel_param *kp);
|
|
module_param_call(mpt_debug_level, mpt_set_debug_level, param_get_int,
|
|
&mpt_debug_level, 0600);
|
|
MODULE_PARM_DESC(mpt_debug_level, " debug level - refer to mptdebug.h - (default=0)");
|
|
|
|
#ifdef MFCNT
|
|
static int mfcounter = 0;
|
|
#define PRINT_MF_COUNT 20000
|
|
#endif
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/*
|
|
* Public data...
|
|
*/
|
|
|
|
static struct proc_dir_entry *mpt_proc_root_dir;
|
|
|
|
#define WHOINIT_UNKNOWN 0xAA
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/*
|
|
* Private data...
|
|
*/
|
|
/* Adapter link list */
|
|
LIST_HEAD(ioc_list);
|
|
/* Callback lookup table */
|
|
static MPT_CALLBACK MptCallbacks[MPT_MAX_PROTOCOL_DRIVERS];
|
|
/* Protocol driver class lookup table */
|
|
static int MptDriverClass[MPT_MAX_PROTOCOL_DRIVERS];
|
|
/* Event handler lookup table */
|
|
static MPT_EVHANDLER MptEvHandlers[MPT_MAX_PROTOCOL_DRIVERS];
|
|
/* Reset handler lookup table */
|
|
static MPT_RESETHANDLER MptResetHandlers[MPT_MAX_PROTOCOL_DRIVERS];
|
|
static struct mpt_pci_driver *MptDeviceDriverHandlers[MPT_MAX_PROTOCOL_DRIVERS];
|
|
|
|
static DECLARE_WAIT_QUEUE_HEAD(mpt_waitq);
|
|
|
|
/*
|
|
* Driver Callback Index's
|
|
*/
|
|
static u8 mpt_base_index = MPT_MAX_PROTOCOL_DRIVERS;
|
|
static u8 last_drv_idx;
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/*
|
|
* Forward protos...
|
|
*/
|
|
static irqreturn_t mpt_interrupt(int irq, void *bus_id);
|
|
static int mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);
|
|
static int mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes,
|
|
u32 *req, int replyBytes, u16 *u16reply, int maxwait,
|
|
int sleepFlag);
|
|
static int mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag);
|
|
static void mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev);
|
|
static void mpt_adapter_disable(MPT_ADAPTER *ioc);
|
|
static void mpt_adapter_dispose(MPT_ADAPTER *ioc);
|
|
|
|
static void MptDisplayIocCapabilities(MPT_ADAPTER *ioc);
|
|
static int MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag);
|
|
static int GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason);
|
|
static int GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
|
|
static int SendIocInit(MPT_ADAPTER *ioc, int sleepFlag);
|
|
static int SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
|
|
static int mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag);
|
|
static int mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag);
|
|
static int mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
|
|
static int KickStart(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
|
|
static int SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag);
|
|
static int PrimeIocFifos(MPT_ADAPTER *ioc);
|
|
static int WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
|
|
static int WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
|
|
static int WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
|
|
static int GetLanConfigPages(MPT_ADAPTER *ioc);
|
|
static int GetIoUnitPage2(MPT_ADAPTER *ioc);
|
|
int mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode);
|
|
static int mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum);
|
|
static int mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum);
|
|
static void mpt_read_ioc_pg_1(MPT_ADAPTER *ioc);
|
|
static void mpt_read_ioc_pg_4(MPT_ADAPTER *ioc);
|
|
static void mpt_timer_expired(unsigned long data);
|
|
static void mpt_get_manufacturing_pg_0(MPT_ADAPTER *ioc);
|
|
static int SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch);
|
|
static int SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp);
|
|
static int mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag);
|
|
static int mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init);
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
static int procmpt_summary_read(char *buf, char **start, off_t offset,
|
|
int request, int *eof, void *data);
|
|
static int procmpt_version_read(char *buf, char **start, off_t offset,
|
|
int request, int *eof, void *data);
|
|
static int procmpt_iocinfo_read(char *buf, char **start, off_t offset,
|
|
int request, int *eof, void *data);
|
|
#endif
|
|
static void mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc);
|
|
|
|
//int mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag);
|
|
static int ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *evReply, int *evHandlers);
|
|
static void mpt_iocstatus_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf);
|
|
static void mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info);
|
|
static void mpt_spi_log_info(MPT_ADAPTER *ioc, u32 log_info);
|
|
static void mpt_sas_log_info(MPT_ADAPTER *ioc, u32 log_info);
|
|
static int mpt_read_ioc_pg_3(MPT_ADAPTER *ioc);
|
|
static void mpt_inactive_raid_list_free(MPT_ADAPTER *ioc);
|
|
|
|
/* module entry point */
|
|
static int __init fusion_init (void);
|
|
static void __exit fusion_exit (void);
|
|
|
|
#define CHIPREG_READ32(addr) readl_relaxed(addr)
|
|
#define CHIPREG_READ32_dmasync(addr) readl(addr)
|
|
#define CHIPREG_WRITE32(addr,val) writel(val, addr)
|
|
#define CHIPREG_PIO_WRITE32(addr,val) outl(val, (unsigned long)addr)
|
|
#define CHIPREG_PIO_READ32(addr) inl((unsigned long)addr)
|
|
|
|
static void
|
|
pci_disable_io_access(struct pci_dev *pdev)
|
|
{
|
|
u16 command_reg;
|
|
|
|
pci_read_config_word(pdev, PCI_COMMAND, &command_reg);
|
|
command_reg &= ~1;
|
|
pci_write_config_word(pdev, PCI_COMMAND, command_reg);
|
|
}
|
|
|
|
static void
|
|
pci_enable_io_access(struct pci_dev *pdev)
|
|
{
|
|
u16 command_reg;
|
|
|
|
pci_read_config_word(pdev, PCI_COMMAND, &command_reg);
|
|
command_reg |= 1;
|
|
pci_write_config_word(pdev, PCI_COMMAND, command_reg);
|
|
}
|
|
|
|
static int mpt_set_debug_level(const char *val, struct kernel_param *kp)
|
|
{
|
|
int ret = param_set_int(val, kp);
|
|
MPT_ADAPTER *ioc;
|
|
|
|
if (ret)
|
|
return ret;
|
|
|
|
list_for_each_entry(ioc, &ioc_list, list)
|
|
ioc->debug_level = mpt_debug_level;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* mpt_get_cb_idx - obtain cb_idx for registered driver
|
|
* @dclass: class driver enum
|
|
*
|
|
* Returns cb_idx, or zero means it wasn't found
|
|
**/
|
|
static u8
|
|
mpt_get_cb_idx(MPT_DRIVER_CLASS dclass)
|
|
{
|
|
u8 cb_idx;
|
|
|
|
for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--)
|
|
if (MptDriverClass[cb_idx] == dclass)
|
|
return cb_idx;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* mpt_fault_reset_work - work performed on workq after ioc fault
|
|
* @work: input argument, used to derive ioc
|
|
*
|
|
**/
|
|
static void
|
|
mpt_fault_reset_work(struct work_struct *work)
|
|
{
|
|
MPT_ADAPTER *ioc =
|
|
container_of(work, MPT_ADAPTER, fault_reset_work.work);
|
|
u32 ioc_raw_state;
|
|
int rc;
|
|
unsigned long flags;
|
|
|
|
if (ioc->diagPending || !ioc->active)
|
|
goto out;
|
|
|
|
ioc_raw_state = mpt_GetIocState(ioc, 0);
|
|
if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
|
|
printk(MYIOC_s_WARN_FMT "IOC is in FAULT state (%04xh)!!!\n",
|
|
ioc->name, ioc_raw_state & MPI_DOORBELL_DATA_MASK);
|
|
printk(MYIOC_s_WARN_FMT "Issuing HardReset from %s!!\n",
|
|
ioc->name, __func__);
|
|
rc = mpt_HardResetHandler(ioc, CAN_SLEEP);
|
|
printk(MYIOC_s_WARN_FMT "%s: HardReset: %s\n", ioc->name,
|
|
__func__, (rc == 0) ? "success" : "failed");
|
|
ioc_raw_state = mpt_GetIocState(ioc, 0);
|
|
if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT)
|
|
printk(MYIOC_s_WARN_FMT "IOC is in FAULT state after "
|
|
"reset (%04xh)\n", ioc->name, ioc_raw_state &
|
|
MPI_DOORBELL_DATA_MASK);
|
|
}
|
|
|
|
out:
|
|
/*
|
|
* Take turns polling alternate controller
|
|
*/
|
|
if (ioc->alt_ioc)
|
|
ioc = ioc->alt_ioc;
|
|
|
|
/* rearm the timer */
|
|
spin_lock_irqsave(&ioc->fault_reset_work_lock, flags);
|
|
if (ioc->reset_work_q)
|
|
queue_delayed_work(ioc->reset_work_q, &ioc->fault_reset_work,
|
|
msecs_to_jiffies(MPT_POLLING_INTERVAL));
|
|
spin_unlock_irqrestore(&ioc->fault_reset_work_lock, flags);
|
|
}
|
|
|
|
|
|
/*
|
|
* Process turbo (context) reply...
|
|
*/
|
|
static void
|
|
mpt_turbo_reply(MPT_ADAPTER *ioc, u32 pa)
|
|
{
|
|
MPT_FRAME_HDR *mf = NULL;
|
|
MPT_FRAME_HDR *mr = NULL;
|
|
u16 req_idx = 0;
|
|
u8 cb_idx;
|
|
|
|
dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Got TURBO reply req_idx=%08x\n",
|
|
ioc->name, pa));
|
|
|
|
switch (pa >> MPI_CONTEXT_REPLY_TYPE_SHIFT) {
|
|
case MPI_CONTEXT_REPLY_TYPE_SCSI_INIT:
|
|
req_idx = pa & 0x0000FFFF;
|
|
cb_idx = (pa & 0x00FF0000) >> 16;
|
|
mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
|
|
break;
|
|
case MPI_CONTEXT_REPLY_TYPE_LAN:
|
|
cb_idx = mpt_get_cb_idx(MPTLAN_DRIVER);
|
|
/*
|
|
* Blind set of mf to NULL here was fatal
|
|
* after lan_reply says "freeme"
|
|
* Fix sort of combined with an optimization here;
|
|
* added explicit check for case where lan_reply
|
|
* was just returning 1 and doing nothing else.
|
|
* For this case skip the callback, but set up
|
|
* proper mf value first here:-)
|
|
*/
|
|
if ((pa & 0x58000000) == 0x58000000) {
|
|
req_idx = pa & 0x0000FFFF;
|
|
mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
|
|
mpt_free_msg_frame(ioc, mf);
|
|
mb();
|
|
return;
|
|
break;
|
|
}
|
|
mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
|
|
break;
|
|
case MPI_CONTEXT_REPLY_TYPE_SCSI_TARGET:
|
|
cb_idx = mpt_get_cb_idx(MPTSTM_DRIVER);
|
|
mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
|
|
break;
|
|
default:
|
|
cb_idx = 0;
|
|
BUG();
|
|
}
|
|
|
|
/* Check for (valid) IO callback! */
|
|
if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
|
|
MptCallbacks[cb_idx] == NULL) {
|
|
printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
|
|
__func__, ioc->name, cb_idx);
|
|
goto out;
|
|
}
|
|
|
|
if (MptCallbacks[cb_idx](ioc, mf, mr))
|
|
mpt_free_msg_frame(ioc, mf);
|
|
out:
|
|
mb();
|
|
}
|
|
|
|
static void
|
|
mpt_reply(MPT_ADAPTER *ioc, u32 pa)
|
|
{
|
|
MPT_FRAME_HDR *mf;
|
|
MPT_FRAME_HDR *mr;
|
|
u16 req_idx;
|
|
u8 cb_idx;
|
|
int freeme;
|
|
|
|
u32 reply_dma_low;
|
|
u16 ioc_stat;
|
|
|
|
/* non-TURBO reply! Hmmm, something may be up...
|
|
* Newest turbo reply mechanism; get address
|
|
* via left shift 1 (get rid of MPI_ADDRESS_REPLY_A_BIT)!
|
|
*/
|
|
|
|
/* Map DMA address of reply header to cpu address.
|
|
* pa is 32 bits - but the dma address may be 32 or 64 bits
|
|
* get offset based only only the low addresses
|
|
*/
|
|
|
|
reply_dma_low = (pa <<= 1);
|
|
mr = (MPT_FRAME_HDR *)((u8 *)ioc->reply_frames +
|
|
(reply_dma_low - ioc->reply_frames_low_dma));
|
|
|
|
req_idx = le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx);
|
|
cb_idx = mr->u.frame.hwhdr.msgctxu.fld.cb_idx;
|
|
mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
|
|
|
|
dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Got non-TURBO reply=%p req_idx=%x cb_idx=%x Function=%x\n",
|
|
ioc->name, mr, req_idx, cb_idx, mr->u.hdr.Function));
|
|
DBG_DUMP_REPLY_FRAME(ioc, (u32 *)mr);
|
|
|
|
/* Check/log IOC log info
|
|
*/
|
|
ioc_stat = le16_to_cpu(mr->u.reply.IOCStatus);
|
|
if (ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) {
|
|
u32 log_info = le32_to_cpu(mr->u.reply.IOCLogInfo);
|
|
if (ioc->bus_type == FC)
|
|
mpt_fc_log_info(ioc, log_info);
|
|
else if (ioc->bus_type == SPI)
|
|
mpt_spi_log_info(ioc, log_info);
|
|
else if (ioc->bus_type == SAS)
|
|
mpt_sas_log_info(ioc, log_info);
|
|
}
|
|
|
|
if (ioc_stat & MPI_IOCSTATUS_MASK)
|
|
mpt_iocstatus_info(ioc, (u32)ioc_stat, mf);
|
|
|
|
/* Check for (valid) IO callback! */
|
|
if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
|
|
MptCallbacks[cb_idx] == NULL) {
|
|
printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
|
|
__func__, ioc->name, cb_idx);
|
|
freeme = 0;
|
|
goto out;
|
|
}
|
|
|
|
freeme = MptCallbacks[cb_idx](ioc, mf, mr);
|
|
|
|
out:
|
|
/* Flush (non-TURBO) reply with a WRITE! */
|
|
CHIPREG_WRITE32(&ioc->chip->ReplyFifo, pa);
|
|
|
|
if (freeme)
|
|
mpt_free_msg_frame(ioc, mf);
|
|
mb();
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_interrupt - MPT adapter (IOC) specific interrupt handler.
|
|
* @irq: irq number (not used)
|
|
* @bus_id: bus identifier cookie == pointer to MPT_ADAPTER structure
|
|
*
|
|
* This routine is registered via the request_irq() kernel API call,
|
|
* and handles all interrupts generated from a specific MPT adapter
|
|
* (also referred to as a IO Controller or IOC).
|
|
* This routine must clear the interrupt from the adapter and does
|
|
* so by reading the reply FIFO. Multiple replies may be processed
|
|
* per single call to this routine.
|
|
*
|
|
* This routine handles register-level access of the adapter but
|
|
* dispatches (calls) a protocol-specific callback routine to handle
|
|
* the protocol-specific details of the MPT request completion.
|
|
*/
|
|
static irqreturn_t
|
|
mpt_interrupt(int irq, void *bus_id)
|
|
{
|
|
MPT_ADAPTER *ioc = bus_id;
|
|
u32 pa = CHIPREG_READ32_dmasync(&ioc->chip->ReplyFifo);
|
|
|
|
if (pa == 0xFFFFFFFF)
|
|
return IRQ_NONE;
|
|
|
|
/*
|
|
* Drain the reply FIFO!
|
|
*/
|
|
do {
|
|
if (pa & MPI_ADDRESS_REPLY_A_BIT)
|
|
mpt_reply(ioc, pa);
|
|
else
|
|
mpt_turbo_reply(ioc, pa);
|
|
pa = CHIPREG_READ32_dmasync(&ioc->chip->ReplyFifo);
|
|
} while (pa != 0xFFFFFFFF);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_base_reply - MPT base driver's callback routine
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @mf: Pointer to original MPT request frame
|
|
* @reply: Pointer to MPT reply frame (NULL if TurboReply)
|
|
*
|
|
* MPT base driver's callback routine; all base driver
|
|
* "internal" request/reply processing is routed here.
|
|
* Currently used for EventNotification and EventAck handling.
|
|
*
|
|
* Returns 1 indicating original alloc'd request frame ptr
|
|
* should be freed, or 0 if it shouldn't.
|
|
*/
|
|
static int
|
|
mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply)
|
|
{
|
|
int freereq = 1;
|
|
u8 func;
|
|
|
|
dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply() called\n", ioc->name));
|
|
#ifdef CONFIG_FUSION_LOGGING
|
|
if ((ioc->debug_level & MPT_DEBUG_MSG_FRAME) &&
|
|
!(reply->u.hdr.MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY)) {
|
|
dmfprintk(ioc, printk(MYIOC_s_INFO_FMT ": Original request frame (@%p) header\n",
|
|
ioc->name, mf));
|
|
DBG_DUMP_REQUEST_FRAME_HDR(ioc, (u32 *)mf);
|
|
}
|
|
#endif
|
|
|
|
func = reply->u.hdr.Function;
|
|
dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply, Function=%02Xh\n",
|
|
ioc->name, func));
|
|
|
|
if (func == MPI_FUNCTION_EVENT_NOTIFICATION) {
|
|
EventNotificationReply_t *pEvReply = (EventNotificationReply_t *) reply;
|
|
int evHandlers = 0;
|
|
int results;
|
|
|
|
results = ProcessEventNotification(ioc, pEvReply, &evHandlers);
|
|
if (results != evHandlers) {
|
|
/* CHECKME! Any special handling needed here? */
|
|
devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "Called %d event handlers, sum results = %d\n",
|
|
ioc->name, evHandlers, results));
|
|
}
|
|
|
|
/*
|
|
* Hmmm... It seems that EventNotificationReply is an exception
|
|
* to the rule of one reply per request.
|
|
*/
|
|
if (pEvReply->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY) {
|
|
freereq = 0;
|
|
} else {
|
|
devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "EVENT_NOTIFICATION reply %p returns Request frame\n",
|
|
ioc->name, pEvReply));
|
|
}
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
// LogEvent(ioc, pEvReply);
|
|
#endif
|
|
|
|
} else if (func == MPI_FUNCTION_EVENT_ACK) {
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply, EventAck reply received\n",
|
|
ioc->name));
|
|
} else if (func == MPI_FUNCTION_CONFIG) {
|
|
CONFIGPARMS *pCfg;
|
|
unsigned long flags;
|
|
|
|
dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "config_complete (mf=%p,mr=%p)\n",
|
|
ioc->name, mf, reply));
|
|
|
|
pCfg = * ((CONFIGPARMS **)((u8 *) mf + ioc->req_sz - sizeof(void *)));
|
|
|
|
if (pCfg) {
|
|
/* disable timer and remove from linked list */
|
|
del_timer(&pCfg->timer);
|
|
|
|
spin_lock_irqsave(&ioc->FreeQlock, flags);
|
|
list_del(&pCfg->linkage);
|
|
spin_unlock_irqrestore(&ioc->FreeQlock, flags);
|
|
|
|
/*
|
|
* If IOC Status is SUCCESS, save the header
|
|
* and set the status code to GOOD.
|
|
*/
|
|
pCfg->status = MPT_CONFIG_ERROR;
|
|
if (reply) {
|
|
ConfigReply_t *pReply = (ConfigReply_t *)reply;
|
|
u16 status;
|
|
|
|
status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
|
|
dcprintk(ioc, printk(MYIOC_s_NOTE_FMT " IOCStatus=%04xh, IOCLogInfo=%08xh\n",
|
|
ioc->name, status, le32_to_cpu(pReply->IOCLogInfo)));
|
|
|
|
pCfg->status = status;
|
|
if (status == MPI_IOCSTATUS_SUCCESS) {
|
|
if ((pReply->Header.PageType &
|
|
MPI_CONFIG_PAGETYPE_MASK) ==
|
|
MPI_CONFIG_PAGETYPE_EXTENDED) {
|
|
pCfg->cfghdr.ehdr->ExtPageLength =
|
|
le16_to_cpu(pReply->ExtPageLength);
|
|
pCfg->cfghdr.ehdr->ExtPageType =
|
|
pReply->ExtPageType;
|
|
}
|
|
pCfg->cfghdr.hdr->PageVersion = pReply->Header.PageVersion;
|
|
|
|
/* If this is a regular header, save PageLength. */
|
|
/* LMP Do this better so not using a reserved field! */
|
|
pCfg->cfghdr.hdr->PageLength = pReply->Header.PageLength;
|
|
pCfg->cfghdr.hdr->PageNumber = pReply->Header.PageNumber;
|
|
pCfg->cfghdr.hdr->PageType = pReply->Header.PageType;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Wake up the original calling thread
|
|
*/
|
|
pCfg->wait_done = 1;
|
|
wake_up(&mpt_waitq);
|
|
}
|
|
} else if (func == MPI_FUNCTION_SAS_IO_UNIT_CONTROL) {
|
|
/* we should be always getting a reply frame */
|
|
memcpy(ioc->persist_reply_frame, reply,
|
|
min(MPT_DEFAULT_FRAME_SIZE,
|
|
4*reply->u.reply.MsgLength));
|
|
del_timer(&ioc->persist_timer);
|
|
ioc->persist_wait_done = 1;
|
|
wake_up(&mpt_waitq);
|
|
} else {
|
|
printk(MYIOC_s_ERR_FMT "Unexpected msg function (=%02Xh) reply received!\n",
|
|
ioc->name, func);
|
|
}
|
|
|
|
/*
|
|
* Conditionally tell caller to free the original
|
|
* EventNotification/EventAck/unexpected request frame!
|
|
*/
|
|
return freereq;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_register - Register protocol-specific main callback handler.
|
|
* @cbfunc: callback function pointer
|
|
* @dclass: Protocol driver's class (%MPT_DRIVER_CLASS enum value)
|
|
*
|
|
* This routine is called by a protocol-specific driver (SCSI host,
|
|
* LAN, SCSI target) to register its reply callback routine. Each
|
|
* protocol-specific driver must do this before it will be able to
|
|
* use any IOC resources, such as obtaining request frames.
|
|
*
|
|
* NOTES: The SCSI protocol driver currently calls this routine thrice
|
|
* in order to register separate callbacks; one for "normal" SCSI IO;
|
|
* one for MptScsiTaskMgmt requests; one for Scan/DV requests.
|
|
*
|
|
* Returns u8 valued "handle" in the range (and S.O.D. order)
|
|
* {N,...,7,6,5,...,1} if successful.
|
|
* A return value of MPT_MAX_PROTOCOL_DRIVERS (including zero!) should be
|
|
* considered an error by the caller.
|
|
*/
|
|
u8
|
|
mpt_register(MPT_CALLBACK cbfunc, MPT_DRIVER_CLASS dclass)
|
|
{
|
|
u8 cb_idx;
|
|
last_drv_idx = MPT_MAX_PROTOCOL_DRIVERS;
|
|
|
|
/*
|
|
* Search for empty callback slot in this order: {N,...,7,6,5,...,1}
|
|
* (slot/handle 0 is reserved!)
|
|
*/
|
|
for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
|
|
if (MptCallbacks[cb_idx] == NULL) {
|
|
MptCallbacks[cb_idx] = cbfunc;
|
|
MptDriverClass[cb_idx] = dclass;
|
|
MptEvHandlers[cb_idx] = NULL;
|
|
last_drv_idx = cb_idx;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return last_drv_idx;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_deregister - Deregister a protocol drivers resources.
|
|
* @cb_idx: previously registered callback handle
|
|
*
|
|
* Each protocol-specific driver should call this routine when its
|
|
* module is unloaded.
|
|
*/
|
|
void
|
|
mpt_deregister(u8 cb_idx)
|
|
{
|
|
if (cb_idx && (cb_idx < MPT_MAX_PROTOCOL_DRIVERS)) {
|
|
MptCallbacks[cb_idx] = NULL;
|
|
MptDriverClass[cb_idx] = MPTUNKNOWN_DRIVER;
|
|
MptEvHandlers[cb_idx] = NULL;
|
|
|
|
last_drv_idx++;
|
|
}
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_event_register - Register protocol-specific event callback handler.
|
|
* @cb_idx: previously registered (via mpt_register) callback handle
|
|
* @ev_cbfunc: callback function
|
|
*
|
|
* This routine can be called by one or more protocol-specific drivers
|
|
* if/when they choose to be notified of MPT events.
|
|
*
|
|
* Returns 0 for success.
|
|
*/
|
|
int
|
|
mpt_event_register(u8 cb_idx, MPT_EVHANDLER ev_cbfunc)
|
|
{
|
|
if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
|
|
return -1;
|
|
|
|
MptEvHandlers[cb_idx] = ev_cbfunc;
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_event_deregister - Deregister protocol-specific event callback handler
|
|
* @cb_idx: previously registered callback handle
|
|
*
|
|
* Each protocol-specific driver should call this routine
|
|
* when it does not (or can no longer) handle events,
|
|
* or when its module is unloaded.
|
|
*/
|
|
void
|
|
mpt_event_deregister(u8 cb_idx)
|
|
{
|
|
if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
|
|
return;
|
|
|
|
MptEvHandlers[cb_idx] = NULL;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_reset_register - Register protocol-specific IOC reset handler.
|
|
* @cb_idx: previously registered (via mpt_register) callback handle
|
|
* @reset_func: reset function
|
|
*
|
|
* This routine can be called by one or more protocol-specific drivers
|
|
* if/when they choose to be notified of IOC resets.
|
|
*
|
|
* Returns 0 for success.
|
|
*/
|
|
int
|
|
mpt_reset_register(u8 cb_idx, MPT_RESETHANDLER reset_func)
|
|
{
|
|
if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
|
|
return -1;
|
|
|
|
MptResetHandlers[cb_idx] = reset_func;
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_reset_deregister - Deregister protocol-specific IOC reset handler.
|
|
* @cb_idx: previously registered callback handle
|
|
*
|
|
* Each protocol-specific driver should call this routine
|
|
* when it does not (or can no longer) handle IOC reset handling,
|
|
* or when its module is unloaded.
|
|
*/
|
|
void
|
|
mpt_reset_deregister(u8 cb_idx)
|
|
{
|
|
if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
|
|
return;
|
|
|
|
MptResetHandlers[cb_idx] = NULL;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_device_driver_register - Register device driver hooks
|
|
* @dd_cbfunc: driver callbacks struct
|
|
* @cb_idx: MPT protocol driver index
|
|
*/
|
|
int
|
|
mpt_device_driver_register(struct mpt_pci_driver * dd_cbfunc, u8 cb_idx)
|
|
{
|
|
MPT_ADAPTER *ioc;
|
|
const struct pci_device_id *id;
|
|
|
|
if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
|
|
return -EINVAL;
|
|
|
|
MptDeviceDriverHandlers[cb_idx] = dd_cbfunc;
|
|
|
|
/* call per pci device probe entry point */
|
|
list_for_each_entry(ioc, &ioc_list, list) {
|
|
id = ioc->pcidev->driver ?
|
|
ioc->pcidev->driver->id_table : NULL;
|
|
if (dd_cbfunc->probe)
|
|
dd_cbfunc->probe(ioc->pcidev, id);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_device_driver_deregister - DeRegister device driver hooks
|
|
* @cb_idx: MPT protocol driver index
|
|
*/
|
|
void
|
|
mpt_device_driver_deregister(u8 cb_idx)
|
|
{
|
|
struct mpt_pci_driver *dd_cbfunc;
|
|
MPT_ADAPTER *ioc;
|
|
|
|
if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
|
|
return;
|
|
|
|
dd_cbfunc = MptDeviceDriverHandlers[cb_idx];
|
|
|
|
list_for_each_entry(ioc, &ioc_list, list) {
|
|
if (dd_cbfunc->remove)
|
|
dd_cbfunc->remove(ioc->pcidev);
|
|
}
|
|
|
|
MptDeviceDriverHandlers[cb_idx] = NULL;
|
|
}
|
|
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_get_msg_frame - Obtain an MPT request frame from the pool
|
|
* @cb_idx: Handle of registered MPT protocol driver
|
|
* @ioc: Pointer to MPT adapter structure
|
|
*
|
|
* Obtain an MPT request frame from the pool (of 1024) that are
|
|
* allocated per MPT adapter.
|
|
*
|
|
* Returns pointer to a MPT request frame or %NULL if none are available
|
|
* or IOC is not active.
|
|
*/
|
|
MPT_FRAME_HDR*
|
|
mpt_get_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc)
|
|
{
|
|
MPT_FRAME_HDR *mf;
|
|
unsigned long flags;
|
|
u16 req_idx; /* Request index */
|
|
|
|
/* validate handle and ioc identifier */
|
|
|
|
#ifdef MFCNT
|
|
if (!ioc->active)
|
|
printk(MYIOC_s_WARN_FMT "IOC Not Active! mpt_get_msg_frame "
|
|
"returning NULL!\n", ioc->name);
|
|
#endif
|
|
|
|
/* If interrupts are not attached, do not return a request frame */
|
|
if (!ioc->active)
|
|
return NULL;
|
|
|
|
spin_lock_irqsave(&ioc->FreeQlock, flags);
|
|
if (!list_empty(&ioc->FreeQ)) {
|
|
int req_offset;
|
|
|
|
mf = list_entry(ioc->FreeQ.next, MPT_FRAME_HDR,
|
|
u.frame.linkage.list);
|
|
list_del(&mf->u.frame.linkage.list);
|
|
mf->u.frame.linkage.arg1 = 0;
|
|
mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx; /* byte */
|
|
req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
|
|
/* u16! */
|
|
req_idx = req_offset / ioc->req_sz;
|
|
mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
|
|
mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
|
|
/* Default, will be changed if necessary in SG generation */
|
|
ioc->RequestNB[req_idx] = ioc->NB_for_64_byte_frame;
|
|
#ifdef MFCNT
|
|
ioc->mfcnt++;
|
|
#endif
|
|
}
|
|
else
|
|
mf = NULL;
|
|
spin_unlock_irqrestore(&ioc->FreeQlock, flags);
|
|
|
|
#ifdef MFCNT
|
|
if (mf == NULL)
|
|
printk(MYIOC_s_WARN_FMT "IOC Active. No free Msg Frames! "
|
|
"Count 0x%x Max 0x%x\n", ioc->name, ioc->mfcnt,
|
|
ioc->req_depth);
|
|
mfcounter++;
|
|
if (mfcounter == PRINT_MF_COUNT)
|
|
printk(MYIOC_s_INFO_FMT "MF Count 0x%x Max 0x%x \n", ioc->name,
|
|
ioc->mfcnt, ioc->req_depth);
|
|
#endif
|
|
|
|
dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_get_msg_frame(%d,%d), got mf=%p\n",
|
|
ioc->name, cb_idx, ioc->id, mf));
|
|
return mf;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_put_msg_frame - Send a protocol-specific MPT request frame to an IOC
|
|
* @cb_idx: Handle of registered MPT protocol driver
|
|
* @ioc: Pointer to MPT adapter structure
|
|
* @mf: Pointer to MPT request frame
|
|
*
|
|
* This routine posts an MPT request frame to the request post FIFO of a
|
|
* specific MPT adapter.
|
|
*/
|
|
void
|
|
mpt_put_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
|
|
{
|
|
u32 mf_dma_addr;
|
|
int req_offset;
|
|
u16 req_idx; /* Request index */
|
|
|
|
/* ensure values are reset properly! */
|
|
mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx; /* byte */
|
|
req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
|
|
/* u16! */
|
|
req_idx = req_offset / ioc->req_sz;
|
|
mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
|
|
mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
|
|
|
|
DBG_DUMP_PUT_MSG_FRAME(ioc, (u32 *)mf);
|
|
|
|
mf_dma_addr = (ioc->req_frames_low_dma + req_offset) | ioc->RequestNB[req_idx];
|
|
dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mf_dma_addr=%x req_idx=%d "
|
|
"RequestNB=%x\n", ioc->name, mf_dma_addr, req_idx,
|
|
ioc->RequestNB[req_idx]));
|
|
CHIPREG_WRITE32(&ioc->chip->RequestFifo, mf_dma_addr);
|
|
}
|
|
|
|
/**
|
|
* mpt_put_msg_frame_hi_pri - Send a hi-pri protocol-specific MPT request frame
|
|
* @cb_idx: Handle of registered MPT protocol driver
|
|
* @ioc: Pointer to MPT adapter structure
|
|
* @mf: Pointer to MPT request frame
|
|
*
|
|
* Send a protocol-specific MPT request frame to an IOC using
|
|
* hi-priority request queue.
|
|
*
|
|
* This routine posts an MPT request frame to the request post FIFO of a
|
|
* specific MPT adapter.
|
|
**/
|
|
void
|
|
mpt_put_msg_frame_hi_pri(u8 cb_idx, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
|
|
{
|
|
u32 mf_dma_addr;
|
|
int req_offset;
|
|
u16 req_idx; /* Request index */
|
|
|
|
/* ensure values are reset properly! */
|
|
mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx;
|
|
req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
|
|
req_idx = req_offset / ioc->req_sz;
|
|
mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
|
|
mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
|
|
|
|
DBG_DUMP_PUT_MSG_FRAME(ioc, (u32 *)mf);
|
|
|
|
mf_dma_addr = (ioc->req_frames_low_dma + req_offset);
|
|
dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mf_dma_addr=%x req_idx=%d\n",
|
|
ioc->name, mf_dma_addr, req_idx));
|
|
CHIPREG_WRITE32(&ioc->chip->RequestHiPriFifo, mf_dma_addr);
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_free_msg_frame - Place MPT request frame back on FreeQ.
|
|
* @ioc: Pointer to MPT adapter structure
|
|
* @mf: Pointer to MPT request frame
|
|
*
|
|
* This routine places a MPT request frame back on the MPT adapter's
|
|
* FreeQ.
|
|
*/
|
|
void
|
|
mpt_free_msg_frame(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
|
|
{
|
|
unsigned long flags;
|
|
|
|
/* Put Request back on FreeQ! */
|
|
spin_lock_irqsave(&ioc->FreeQlock, flags);
|
|
mf->u.frame.linkage.arg1 = 0xdeadbeaf; /* signature to know if this mf is freed */
|
|
list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeQ);
|
|
#ifdef MFCNT
|
|
ioc->mfcnt--;
|
|
#endif
|
|
spin_unlock_irqrestore(&ioc->FreeQlock, flags);
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_add_sge - Place a simple SGE at address pAddr.
|
|
* @pAddr: virtual address for SGE
|
|
* @flagslength: SGE flags and data transfer length
|
|
* @dma_addr: Physical address
|
|
*
|
|
* This routine places a MPT request frame back on the MPT adapter's
|
|
* FreeQ.
|
|
*/
|
|
void
|
|
mpt_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
|
|
{
|
|
if (sizeof(dma_addr_t) == sizeof(u64)) {
|
|
SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
|
|
u32 tmp = dma_addr & 0xFFFFFFFF;
|
|
|
|
pSge->FlagsLength = cpu_to_le32(flagslength);
|
|
pSge->Address.Low = cpu_to_le32(tmp);
|
|
tmp = (u32) ((u64)dma_addr >> 32);
|
|
pSge->Address.High = cpu_to_le32(tmp);
|
|
|
|
} else {
|
|
SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
|
|
pSge->FlagsLength = cpu_to_le32(flagslength);
|
|
pSge->Address = cpu_to_le32(dma_addr);
|
|
}
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_send_handshake_request - Send MPT request via doorbell handshake method.
|
|
* @cb_idx: Handle of registered MPT protocol driver
|
|
* @ioc: Pointer to MPT adapter structure
|
|
* @reqBytes: Size of the request in bytes
|
|
* @req: Pointer to MPT request frame
|
|
* @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
|
|
*
|
|
* This routine is used exclusively to send MptScsiTaskMgmt
|
|
* requests since they are required to be sent via doorbell handshake.
|
|
*
|
|
* NOTE: It is the callers responsibility to byte-swap fields in the
|
|
* request which are greater than 1 byte in size.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt_send_handshake_request(u8 cb_idx, MPT_ADAPTER *ioc, int reqBytes, u32 *req, int sleepFlag)
|
|
{
|
|
int r = 0;
|
|
u8 *req_as_bytes;
|
|
int ii;
|
|
|
|
/* State is known to be good upon entering
|
|
* this function so issue the bus reset
|
|
* request.
|
|
*/
|
|
|
|
/*
|
|
* Emulate what mpt_put_msg_frame() does /wrt to sanity
|
|
* setting cb_idx/req_idx. But ONLY if this request
|
|
* is in proper (pre-alloc'd) request buffer range...
|
|
*/
|
|
ii = MFPTR_2_MPT_INDEX(ioc,(MPT_FRAME_HDR*)req);
|
|
if (reqBytes >= 12 && ii >= 0 && ii < ioc->req_depth) {
|
|
MPT_FRAME_HDR *mf = (MPT_FRAME_HDR*)req;
|
|
mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(ii);
|
|
mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx;
|
|
}
|
|
|
|
/* Make sure there are no doorbells */
|
|
CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
|
|
|
|
CHIPREG_WRITE32(&ioc->chip->Doorbell,
|
|
((MPI_FUNCTION_HANDSHAKE<<MPI_DOORBELL_FUNCTION_SHIFT) |
|
|
((reqBytes/4)<<MPI_DOORBELL_ADD_DWORDS_SHIFT)));
|
|
|
|
/* Wait for IOC doorbell int */
|
|
if ((ii = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0) {
|
|
return ii;
|
|
}
|
|
|
|
/* Read doorbell and check for active bit */
|
|
if (!(CHIPREG_READ32(&ioc->chip->Doorbell) & MPI_DOORBELL_ACTIVE))
|
|
return -5;
|
|
|
|
dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_send_handshake_request start, WaitCnt=%d\n",
|
|
ioc->name, ii));
|
|
|
|
CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
|
|
|
|
if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
|
|
return -2;
|
|
}
|
|
|
|
/* Send request via doorbell handshake */
|
|
req_as_bytes = (u8 *) req;
|
|
for (ii = 0; ii < reqBytes/4; ii++) {
|
|
u32 word;
|
|
|
|
word = ((req_as_bytes[(ii*4) + 0] << 0) |
|
|
(req_as_bytes[(ii*4) + 1] << 8) |
|
|
(req_as_bytes[(ii*4) + 2] << 16) |
|
|
(req_as_bytes[(ii*4) + 3] << 24));
|
|
CHIPREG_WRITE32(&ioc->chip->Doorbell, word);
|
|
if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
|
|
r = -3;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (r >= 0 && WaitForDoorbellInt(ioc, 10, sleepFlag) >= 0)
|
|
r = 0;
|
|
else
|
|
r = -4;
|
|
|
|
/* Make sure there are no doorbells */
|
|
CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
|
|
|
|
return r;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_host_page_access_control - control the IOC's Host Page Buffer access
|
|
* @ioc: Pointer to MPT adapter structure
|
|
* @access_control_value: define bits below
|
|
* @sleepFlag: Specifies whether the process can sleep
|
|
*
|
|
* Provides mechanism for the host driver to control the IOC's
|
|
* Host Page Buffer access.
|
|
*
|
|
* Access Control Value - bits[15:12]
|
|
* 0h Reserved
|
|
* 1h Enable Access { MPI_DB_HPBAC_ENABLE_ACCESS }
|
|
* 2h Disable Access { MPI_DB_HPBAC_DISABLE_ACCESS }
|
|
* 3h Free Buffer { MPI_DB_HPBAC_FREE_BUFFER }
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
|
|
static int
|
|
mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag)
|
|
{
|
|
int r = 0;
|
|
|
|
/* return if in use */
|
|
if (CHIPREG_READ32(&ioc->chip->Doorbell)
|
|
& MPI_DOORBELL_ACTIVE)
|
|
return -1;
|
|
|
|
CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
|
|
|
|
CHIPREG_WRITE32(&ioc->chip->Doorbell,
|
|
((MPI_FUNCTION_HOST_PAGEBUF_ACCESS_CONTROL
|
|
<<MPI_DOORBELL_FUNCTION_SHIFT) |
|
|
(access_control_value<<12)));
|
|
|
|
/* Wait for IOC to clear Doorbell Status bit */
|
|
if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
|
|
return -2;
|
|
}else
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_host_page_alloc - allocate system memory for the fw
|
|
* @ioc: Pointer to pointer to IOC adapter
|
|
* @ioc_init: Pointer to ioc init config page
|
|
*
|
|
* If we already allocated memory in past, then resend the same pointer.
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
static int
|
|
mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init)
|
|
{
|
|
char *psge;
|
|
int flags_length;
|
|
u32 host_page_buffer_sz=0;
|
|
|
|
if(!ioc->HostPageBuffer) {
|
|
|
|
host_page_buffer_sz =
|
|
le32_to_cpu(ioc->facts.HostPageBufferSGE.FlagsLength) & 0xFFFFFF;
|
|
|
|
if(!host_page_buffer_sz)
|
|
return 0; /* fw doesn't need any host buffers */
|
|
|
|
/* spin till we get enough memory */
|
|
while(host_page_buffer_sz > 0) {
|
|
|
|
if((ioc->HostPageBuffer = pci_alloc_consistent(
|
|
ioc->pcidev,
|
|
host_page_buffer_sz,
|
|
&ioc->HostPageBuffer_dma)) != NULL) {
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"host_page_buffer @ %p, dma @ %x, sz=%d bytes\n",
|
|
ioc->name, ioc->HostPageBuffer,
|
|
(u32)ioc->HostPageBuffer_dma,
|
|
host_page_buffer_sz));
|
|
ioc->alloc_total += host_page_buffer_sz;
|
|
ioc->HostPageBuffer_sz = host_page_buffer_sz;
|
|
break;
|
|
}
|
|
|
|
host_page_buffer_sz -= (4*1024);
|
|
}
|
|
}
|
|
|
|
if(!ioc->HostPageBuffer) {
|
|
printk(MYIOC_s_ERR_FMT
|
|
"Failed to alloc memory for host_page_buffer!\n",
|
|
ioc->name);
|
|
return -999;
|
|
}
|
|
|
|
psge = (char *)&ioc_init->HostPageBufferSGE;
|
|
flags_length = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
|
|
MPI_SGE_FLAGS_SYSTEM_ADDRESS |
|
|
MPI_SGE_FLAGS_32_BIT_ADDRESSING |
|
|
MPI_SGE_FLAGS_HOST_TO_IOC |
|
|
MPI_SGE_FLAGS_END_OF_BUFFER;
|
|
if (sizeof(dma_addr_t) == sizeof(u64)) {
|
|
flags_length |= MPI_SGE_FLAGS_64_BIT_ADDRESSING;
|
|
}
|
|
flags_length = flags_length << MPI_SGE_FLAGS_SHIFT;
|
|
flags_length |= ioc->HostPageBuffer_sz;
|
|
mpt_add_sge(psge, flags_length, ioc->HostPageBuffer_dma);
|
|
ioc->facts.HostPageBufferSGE = ioc_init->HostPageBufferSGE;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_verify_adapter - Given IOC identifier, set pointer to its adapter structure.
|
|
* @iocid: IOC unique identifier (integer)
|
|
* @iocpp: Pointer to pointer to IOC adapter
|
|
*
|
|
* Given a unique IOC identifier, set pointer to the associated MPT
|
|
* adapter structure.
|
|
*
|
|
* Returns iocid and sets iocpp if iocid is found.
|
|
* Returns -1 if iocid is not found.
|
|
*/
|
|
int
|
|
mpt_verify_adapter(int iocid, MPT_ADAPTER **iocpp)
|
|
{
|
|
MPT_ADAPTER *ioc;
|
|
|
|
list_for_each_entry(ioc,&ioc_list,list) {
|
|
if (ioc->id == iocid) {
|
|
*iocpp =ioc;
|
|
return iocid;
|
|
}
|
|
}
|
|
|
|
*iocpp = NULL;
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* mpt_get_product_name - returns product string
|
|
* @vendor: pci vendor id
|
|
* @device: pci device id
|
|
* @revision: pci revision id
|
|
* @prod_name: string returned
|
|
*
|
|
* Returns product string displayed when driver loads,
|
|
* in /proc/mpt/summary and /sysfs/class/scsi_host/host<X>/version_product
|
|
*
|
|
**/
|
|
static void
|
|
mpt_get_product_name(u16 vendor, u16 device, u8 revision, char *prod_name)
|
|
{
|
|
char *product_str = NULL;
|
|
|
|
if (vendor == PCI_VENDOR_ID_BROCADE) {
|
|
switch (device)
|
|
{
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC949E:
|
|
switch (revision)
|
|
{
|
|
case 0x00:
|
|
product_str = "BRE040 A0";
|
|
break;
|
|
case 0x01:
|
|
product_str = "BRE040 A1";
|
|
break;
|
|
default:
|
|
product_str = "BRE040";
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
goto out;
|
|
}
|
|
|
|
switch (device)
|
|
{
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC909:
|
|
product_str = "LSIFC909 B1";
|
|
break;
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC919:
|
|
product_str = "LSIFC919 B0";
|
|
break;
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC929:
|
|
product_str = "LSIFC929 B0";
|
|
break;
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC919X:
|
|
if (revision < 0x80)
|
|
product_str = "LSIFC919X A0";
|
|
else
|
|
product_str = "LSIFC919XL A1";
|
|
break;
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC929X:
|
|
if (revision < 0x80)
|
|
product_str = "LSIFC929X A0";
|
|
else
|
|
product_str = "LSIFC929XL A1";
|
|
break;
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC939X:
|
|
product_str = "LSIFC939X A1";
|
|
break;
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC949X:
|
|
product_str = "LSIFC949X A1";
|
|
break;
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC949E:
|
|
switch (revision)
|
|
{
|
|
case 0x00:
|
|
product_str = "LSIFC949E A0";
|
|
break;
|
|
case 0x01:
|
|
product_str = "LSIFC949E A1";
|
|
break;
|
|
default:
|
|
product_str = "LSIFC949E";
|
|
break;
|
|
}
|
|
break;
|
|
case MPI_MANUFACTPAGE_DEVID_53C1030:
|
|
switch (revision)
|
|
{
|
|
case 0x00:
|
|
product_str = "LSI53C1030 A0";
|
|
break;
|
|
case 0x01:
|
|
product_str = "LSI53C1030 B0";
|
|
break;
|
|
case 0x03:
|
|
product_str = "LSI53C1030 B1";
|
|
break;
|
|
case 0x07:
|
|
product_str = "LSI53C1030 B2";
|
|
break;
|
|
case 0x08:
|
|
product_str = "LSI53C1030 C0";
|
|
break;
|
|
case 0x80:
|
|
product_str = "LSI53C1030T A0";
|
|
break;
|
|
case 0x83:
|
|
product_str = "LSI53C1030T A2";
|
|
break;
|
|
case 0x87:
|
|
product_str = "LSI53C1030T A3";
|
|
break;
|
|
case 0xc1:
|
|
product_str = "LSI53C1020A A1";
|
|
break;
|
|
default:
|
|
product_str = "LSI53C1030";
|
|
break;
|
|
}
|
|
break;
|
|
case MPI_MANUFACTPAGE_DEVID_1030_53C1035:
|
|
switch (revision)
|
|
{
|
|
case 0x03:
|
|
product_str = "LSI53C1035 A2";
|
|
break;
|
|
case 0x04:
|
|
product_str = "LSI53C1035 B0";
|
|
break;
|
|
default:
|
|
product_str = "LSI53C1035";
|
|
break;
|
|
}
|
|
break;
|
|
case MPI_MANUFACTPAGE_DEVID_SAS1064:
|
|
switch (revision)
|
|
{
|
|
case 0x00:
|
|
product_str = "LSISAS1064 A1";
|
|
break;
|
|
case 0x01:
|
|
product_str = "LSISAS1064 A2";
|
|
break;
|
|
case 0x02:
|
|
product_str = "LSISAS1064 A3";
|
|
break;
|
|
case 0x03:
|
|
product_str = "LSISAS1064 A4";
|
|
break;
|
|
default:
|
|
product_str = "LSISAS1064";
|
|
break;
|
|
}
|
|
break;
|
|
case MPI_MANUFACTPAGE_DEVID_SAS1064E:
|
|
switch (revision)
|
|
{
|
|
case 0x00:
|
|
product_str = "LSISAS1064E A0";
|
|
break;
|
|
case 0x01:
|
|
product_str = "LSISAS1064E B0";
|
|
break;
|
|
case 0x02:
|
|
product_str = "LSISAS1064E B1";
|
|
break;
|
|
case 0x04:
|
|
product_str = "LSISAS1064E B2";
|
|
break;
|
|
case 0x08:
|
|
product_str = "LSISAS1064E B3";
|
|
break;
|
|
default:
|
|
product_str = "LSISAS1064E";
|
|
break;
|
|
}
|
|
break;
|
|
case MPI_MANUFACTPAGE_DEVID_SAS1068:
|
|
switch (revision)
|
|
{
|
|
case 0x00:
|
|
product_str = "LSISAS1068 A0";
|
|
break;
|
|
case 0x01:
|
|
product_str = "LSISAS1068 B0";
|
|
break;
|
|
case 0x02:
|
|
product_str = "LSISAS1068 B1";
|
|
break;
|
|
default:
|
|
product_str = "LSISAS1068";
|
|
break;
|
|
}
|
|
break;
|
|
case MPI_MANUFACTPAGE_DEVID_SAS1068E:
|
|
switch (revision)
|
|
{
|
|
case 0x00:
|
|
product_str = "LSISAS1068E A0";
|
|
break;
|
|
case 0x01:
|
|
product_str = "LSISAS1068E B0";
|
|
break;
|
|
case 0x02:
|
|
product_str = "LSISAS1068E B1";
|
|
break;
|
|
case 0x04:
|
|
product_str = "LSISAS1068E B2";
|
|
break;
|
|
case 0x08:
|
|
product_str = "LSISAS1068E B3";
|
|
break;
|
|
default:
|
|
product_str = "LSISAS1068E";
|
|
break;
|
|
}
|
|
break;
|
|
case MPI_MANUFACTPAGE_DEVID_SAS1078:
|
|
switch (revision)
|
|
{
|
|
case 0x00:
|
|
product_str = "LSISAS1078 A0";
|
|
break;
|
|
case 0x01:
|
|
product_str = "LSISAS1078 B0";
|
|
break;
|
|
case 0x02:
|
|
product_str = "LSISAS1078 C0";
|
|
break;
|
|
case 0x03:
|
|
product_str = "LSISAS1078 C1";
|
|
break;
|
|
case 0x04:
|
|
product_str = "LSISAS1078 C2";
|
|
break;
|
|
default:
|
|
product_str = "LSISAS1078";
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
out:
|
|
if (product_str)
|
|
sprintf(prod_name, "%s", product_str);
|
|
}
|
|
|
|
/**
|
|
* mpt_mapresources - map in memory mapped io
|
|
* @ioc: Pointer to pointer to IOC adapter
|
|
*
|
|
**/
|
|
static int
|
|
mpt_mapresources(MPT_ADAPTER *ioc)
|
|
{
|
|
u8 __iomem *mem;
|
|
int ii;
|
|
unsigned long mem_phys;
|
|
unsigned long port;
|
|
u32 msize;
|
|
u32 psize;
|
|
u8 revision;
|
|
int r = -ENODEV;
|
|
struct pci_dev *pdev;
|
|
|
|
pdev = ioc->pcidev;
|
|
ioc->bars = pci_select_bars(pdev, IORESOURCE_MEM);
|
|
if (pci_enable_device_mem(pdev)) {
|
|
printk(MYIOC_s_ERR_FMT "pci_enable_device_mem() "
|
|
"failed\n", ioc->name);
|
|
return r;
|
|
}
|
|
if (pci_request_selected_regions(pdev, ioc->bars, "mpt")) {
|
|
printk(MYIOC_s_ERR_FMT "pci_request_selected_regions() with "
|
|
"MEM failed\n", ioc->name);
|
|
return r;
|
|
}
|
|
|
|
pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
|
|
|
|
if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)
|
|
&& !pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK)) {
|
|
dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
|
|
": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
|
|
ioc->name));
|
|
} else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)
|
|
&& !pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
|
|
dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
|
|
": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
|
|
ioc->name));
|
|
} else {
|
|
printk(MYIOC_s_WARN_FMT "no suitable DMA mask for %s\n",
|
|
ioc->name, pci_name(pdev));
|
|
pci_release_selected_regions(pdev, ioc->bars);
|
|
return r;
|
|
}
|
|
|
|
mem_phys = msize = 0;
|
|
port = psize = 0;
|
|
for (ii = 0; ii < DEVICE_COUNT_RESOURCE; ii++) {
|
|
if (pci_resource_flags(pdev, ii) & PCI_BASE_ADDRESS_SPACE_IO) {
|
|
if (psize)
|
|
continue;
|
|
/* Get I/O space! */
|
|
port = pci_resource_start(pdev, ii);
|
|
psize = pci_resource_len(pdev, ii);
|
|
} else {
|
|
if (msize)
|
|
continue;
|
|
/* Get memmap */
|
|
mem_phys = pci_resource_start(pdev, ii);
|
|
msize = pci_resource_len(pdev, ii);
|
|
}
|
|
}
|
|
ioc->mem_size = msize;
|
|
|
|
mem = NULL;
|
|
/* Get logical ptr for PciMem0 space */
|
|
/*mem = ioremap(mem_phys, msize);*/
|
|
mem = ioremap(mem_phys, msize);
|
|
if (mem == NULL) {
|
|
printk(MYIOC_s_ERR_FMT ": ERROR - Unable to map adapter"
|
|
" memory!\n", ioc->name);
|
|
return -EINVAL;
|
|
}
|
|
ioc->memmap = mem;
|
|
dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "mem = %p, mem_phys = %lx\n",
|
|
ioc->name, mem, mem_phys));
|
|
|
|
ioc->mem_phys = mem_phys;
|
|
ioc->chip = (SYSIF_REGS __iomem *)mem;
|
|
|
|
/* Save Port IO values in case we need to do downloadboot */
|
|
ioc->pio_mem_phys = port;
|
|
ioc->pio_chip = (SYSIF_REGS __iomem *)port;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_attach - Install a PCI intelligent MPT adapter.
|
|
* @pdev: Pointer to pci_dev structure
|
|
* @id: PCI device ID information
|
|
*
|
|
* This routine performs all the steps necessary to bring the IOC of
|
|
* a MPT adapter to a OPERATIONAL state. This includes registering
|
|
* memory regions, registering the interrupt, and allocating request
|
|
* and reply memory pools.
|
|
*
|
|
* This routine also pre-fetches the LAN MAC address of a Fibre Channel
|
|
* MPT adapter.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*
|
|
* TODO: Add support for polled controllers
|
|
*/
|
|
int
|
|
mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id)
|
|
{
|
|
MPT_ADAPTER *ioc;
|
|
u8 cb_idx;
|
|
int r = -ENODEV;
|
|
u8 revision;
|
|
u8 pcixcmd;
|
|
static int mpt_ids = 0;
|
|
#ifdef CONFIG_PROC_FS
|
|
struct proc_dir_entry *dent, *ent;
|
|
#endif
|
|
|
|
ioc = kzalloc(sizeof(MPT_ADAPTER), GFP_ATOMIC);
|
|
if (ioc == NULL) {
|
|
printk(KERN_ERR MYNAM ": ERROR - Insufficient memory to add adapter!\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
ioc->id = mpt_ids++;
|
|
sprintf(ioc->name, "ioc%d", ioc->id);
|
|
|
|
/*
|
|
* set initial debug level
|
|
* (refer to mptdebug.h)
|
|
*
|
|
*/
|
|
ioc->debug_level = mpt_debug_level;
|
|
if (mpt_debug_level)
|
|
printk(KERN_INFO "mpt_debug_level=%xh\n", mpt_debug_level);
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": mpt_adapter_install\n", ioc->name));
|
|
|
|
ioc->pcidev = pdev;
|
|
if (mpt_mapresources(ioc)) {
|
|
kfree(ioc);
|
|
return r;
|
|
}
|
|
|
|
ioc->alloc_total = sizeof(MPT_ADAPTER);
|
|
ioc->req_sz = MPT_DEFAULT_FRAME_SIZE; /* avoid div by zero! */
|
|
ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
|
|
|
|
ioc->pcidev = pdev;
|
|
ioc->diagPending = 0;
|
|
spin_lock_init(&ioc->diagLock);
|
|
spin_lock_init(&ioc->initializing_hba_lock);
|
|
|
|
/* Initialize the event logging.
|
|
*/
|
|
ioc->eventTypes = 0; /* None */
|
|
ioc->eventContext = 0;
|
|
ioc->eventLogSize = 0;
|
|
ioc->events = NULL;
|
|
|
|
#ifdef MFCNT
|
|
ioc->mfcnt = 0;
|
|
#endif
|
|
|
|
ioc->cached_fw = NULL;
|
|
|
|
/* Initilize SCSI Config Data structure
|
|
*/
|
|
memset(&ioc->spi_data, 0, sizeof(SpiCfgData));
|
|
|
|
/* Initialize the running configQ head.
|
|
*/
|
|
INIT_LIST_HEAD(&ioc->configQ);
|
|
|
|
/* Initialize the fc rport list head.
|
|
*/
|
|
INIT_LIST_HEAD(&ioc->fc_rports);
|
|
|
|
/* Find lookup slot. */
|
|
INIT_LIST_HEAD(&ioc->list);
|
|
|
|
|
|
/* Initialize workqueue */
|
|
INIT_DELAYED_WORK(&ioc->fault_reset_work, mpt_fault_reset_work);
|
|
spin_lock_init(&ioc->fault_reset_work_lock);
|
|
|
|
snprintf(ioc->reset_work_q_name, sizeof(ioc->reset_work_q_name),
|
|
"mpt_poll_%d", ioc->id);
|
|
ioc->reset_work_q =
|
|
create_singlethread_workqueue(ioc->reset_work_q_name);
|
|
if (!ioc->reset_work_q) {
|
|
printk(MYIOC_s_ERR_FMT "Insufficient memory to add adapter!\n",
|
|
ioc->name);
|
|
pci_release_selected_regions(pdev, ioc->bars);
|
|
kfree(ioc);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "facts @ %p, pfacts[0] @ %p\n",
|
|
ioc->name, &ioc->facts, &ioc->pfacts[0]));
|
|
|
|
pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
|
|
mpt_get_product_name(pdev->vendor, pdev->device, revision, ioc->prod_name);
|
|
|
|
switch (pdev->device)
|
|
{
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC939X:
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC949X:
|
|
ioc->errata_flag_1064 = 1;
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC909:
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC929:
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC919:
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC949E:
|
|
ioc->bus_type = FC;
|
|
break;
|
|
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC929X:
|
|
if (revision < XL_929) {
|
|
/* 929X Chip Fix. Set Split transactions level
|
|
* for PCIX. Set MOST bits to zero.
|
|
*/
|
|
pci_read_config_byte(pdev, 0x6a, &pcixcmd);
|
|
pcixcmd &= 0x8F;
|
|
pci_write_config_byte(pdev, 0x6a, pcixcmd);
|
|
} else {
|
|
/* 929XL Chip Fix. Set MMRBC to 0x08.
|
|
*/
|
|
pci_read_config_byte(pdev, 0x6a, &pcixcmd);
|
|
pcixcmd |= 0x08;
|
|
pci_write_config_byte(pdev, 0x6a, pcixcmd);
|
|
}
|
|
ioc->bus_type = FC;
|
|
break;
|
|
|
|
case MPI_MANUFACTPAGE_DEVICEID_FC919X:
|
|
/* 919X Chip Fix. Set Split transactions level
|
|
* for PCIX. Set MOST bits to zero.
|
|
*/
|
|
pci_read_config_byte(pdev, 0x6a, &pcixcmd);
|
|
pcixcmd &= 0x8F;
|
|
pci_write_config_byte(pdev, 0x6a, pcixcmd);
|
|
ioc->bus_type = FC;
|
|
break;
|
|
|
|
case MPI_MANUFACTPAGE_DEVID_53C1030:
|
|
/* 1030 Chip Fix. Disable Split transactions
|
|
* for PCIX. Set MOST bits to zero if Rev < C0( = 8).
|
|
*/
|
|
if (revision < C0_1030) {
|
|
pci_read_config_byte(pdev, 0x6a, &pcixcmd);
|
|
pcixcmd &= 0x8F;
|
|
pci_write_config_byte(pdev, 0x6a, pcixcmd);
|
|
}
|
|
|
|
case MPI_MANUFACTPAGE_DEVID_1030_53C1035:
|
|
ioc->bus_type = SPI;
|
|
break;
|
|
|
|
case MPI_MANUFACTPAGE_DEVID_SAS1064:
|
|
case MPI_MANUFACTPAGE_DEVID_SAS1068:
|
|
ioc->errata_flag_1064 = 1;
|
|
|
|
case MPI_MANUFACTPAGE_DEVID_SAS1064E:
|
|
case MPI_MANUFACTPAGE_DEVID_SAS1068E:
|
|
case MPI_MANUFACTPAGE_DEVID_SAS1078:
|
|
ioc->bus_type = SAS;
|
|
}
|
|
|
|
if (mpt_msi_enable == -1) {
|
|
/* Enable on SAS, disable on FC and SPI */
|
|
if (ioc->bus_type == SAS)
|
|
ioc->msi_enable = 1;
|
|
else
|
|
ioc->msi_enable = 0;
|
|
} else
|
|
/* follow flag: 0 - disable; 1 - enable */
|
|
ioc->msi_enable = mpt_msi_enable;
|
|
|
|
if (ioc->errata_flag_1064)
|
|
pci_disable_io_access(pdev);
|
|
|
|
spin_lock_init(&ioc->FreeQlock);
|
|
|
|
/* Disable all! */
|
|
CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
|
|
ioc->active = 0;
|
|
CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
|
|
|
|
/* Set IOC ptr in the pcidev's driver data. */
|
|
pci_set_drvdata(ioc->pcidev, ioc);
|
|
|
|
/* Set lookup ptr. */
|
|
list_add_tail(&ioc->list, &ioc_list);
|
|
|
|
/* Check for "bound ports" (929, 929X, 1030, 1035) to reduce redundant resets.
|
|
*/
|
|
mpt_detect_bound_ports(ioc, pdev);
|
|
|
|
if ((r = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP,
|
|
CAN_SLEEP)) != 0){
|
|
printk(MYIOC_s_ERR_FMT "didn't initialize properly! (%d)\n",
|
|
ioc->name, r);
|
|
|
|
list_del(&ioc->list);
|
|
if (ioc->alt_ioc)
|
|
ioc->alt_ioc->alt_ioc = NULL;
|
|
iounmap(ioc->memmap);
|
|
if (r != -5)
|
|
pci_release_selected_regions(pdev, ioc->bars);
|
|
|
|
destroy_workqueue(ioc->reset_work_q);
|
|
ioc->reset_work_q = NULL;
|
|
|
|
kfree(ioc);
|
|
pci_set_drvdata(pdev, NULL);
|
|
return r;
|
|
}
|
|
|
|
/* call per device driver probe entry point */
|
|
for(cb_idx = 0; cb_idx < MPT_MAX_PROTOCOL_DRIVERS; cb_idx++) {
|
|
if(MptDeviceDriverHandlers[cb_idx] &&
|
|
MptDeviceDriverHandlers[cb_idx]->probe) {
|
|
MptDeviceDriverHandlers[cb_idx]->probe(pdev,id);
|
|
}
|
|
}
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
/*
|
|
* Create "/proc/mpt/iocN" subdirectory entry for each MPT adapter.
|
|
*/
|
|
dent = proc_mkdir(ioc->name, mpt_proc_root_dir);
|
|
if (dent) {
|
|
ent = create_proc_entry("info", S_IFREG|S_IRUGO, dent);
|
|
if (ent) {
|
|
ent->read_proc = procmpt_iocinfo_read;
|
|
ent->data = ioc;
|
|
}
|
|
ent = create_proc_entry("summary", S_IFREG|S_IRUGO, dent);
|
|
if (ent) {
|
|
ent->read_proc = procmpt_summary_read;
|
|
ent->data = ioc;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (!ioc->alt_ioc)
|
|
queue_delayed_work(ioc->reset_work_q, &ioc->fault_reset_work,
|
|
msecs_to_jiffies(MPT_POLLING_INTERVAL));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_detach - Remove a PCI intelligent MPT adapter.
|
|
* @pdev: Pointer to pci_dev structure
|
|
*/
|
|
|
|
void
|
|
mpt_detach(struct pci_dev *pdev)
|
|
{
|
|
MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
|
|
char pname[32];
|
|
u8 cb_idx;
|
|
unsigned long flags;
|
|
struct workqueue_struct *wq;
|
|
|
|
/*
|
|
* Stop polling ioc for fault condition
|
|
*/
|
|
spin_lock_irqsave(&ioc->fault_reset_work_lock, flags);
|
|
wq = ioc->reset_work_q;
|
|
ioc->reset_work_q = NULL;
|
|
spin_unlock_irqrestore(&ioc->fault_reset_work_lock, flags);
|
|
cancel_delayed_work(&ioc->fault_reset_work);
|
|
destroy_workqueue(wq);
|
|
|
|
|
|
sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/summary", ioc->name);
|
|
remove_proc_entry(pname, NULL);
|
|
sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/info", ioc->name);
|
|
remove_proc_entry(pname, NULL);
|
|
sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s", ioc->name);
|
|
remove_proc_entry(pname, NULL);
|
|
|
|
/* call per device driver remove entry point */
|
|
for(cb_idx = 0; cb_idx < MPT_MAX_PROTOCOL_DRIVERS; cb_idx++) {
|
|
if(MptDeviceDriverHandlers[cb_idx] &&
|
|
MptDeviceDriverHandlers[cb_idx]->remove) {
|
|
MptDeviceDriverHandlers[cb_idx]->remove(pdev);
|
|
}
|
|
}
|
|
|
|
/* Disable interrupts! */
|
|
CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
|
|
|
|
ioc->active = 0;
|
|
synchronize_irq(pdev->irq);
|
|
|
|
/* Clear any lingering interrupt */
|
|
CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
|
|
|
|
CHIPREG_READ32(&ioc->chip->IntStatus);
|
|
|
|
mpt_adapter_dispose(ioc);
|
|
|
|
pci_set_drvdata(pdev, NULL);
|
|
}
|
|
|
|
/**************************************************************************
|
|
* Power Management
|
|
*/
|
|
#ifdef CONFIG_PM
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_suspend - Fusion MPT base driver suspend routine.
|
|
* @pdev: Pointer to pci_dev structure
|
|
* @state: new state to enter
|
|
*/
|
|
int
|
|
mpt_suspend(struct pci_dev *pdev, pm_message_t state)
|
|
{
|
|
u32 device_state;
|
|
MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
|
|
|
|
device_state = pci_choose_state(pdev, state);
|
|
printk(MYIOC_s_INFO_FMT "pci-suspend: pdev=0x%p, slot=%s, Entering "
|
|
"operating state [D%d]\n", ioc->name, pdev, pci_name(pdev),
|
|
device_state);
|
|
|
|
/* put ioc into READY_STATE */
|
|
if(SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, CAN_SLEEP)) {
|
|
printk(MYIOC_s_ERR_FMT
|
|
"pci-suspend: IOC msg unit reset failed!\n", ioc->name);
|
|
}
|
|
|
|
/* disable interrupts */
|
|
CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
|
|
ioc->active = 0;
|
|
|
|
/* Clear any lingering interrupt */
|
|
CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
|
|
|
|
free_irq(ioc->pci_irq, ioc);
|
|
if (ioc->msi_enable)
|
|
pci_disable_msi(ioc->pcidev);
|
|
ioc->pci_irq = -1;
|
|
pci_save_state(pdev);
|
|
pci_disable_device(pdev);
|
|
pci_release_selected_regions(pdev, ioc->bars);
|
|
pci_set_power_state(pdev, device_state);
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_resume - Fusion MPT base driver resume routine.
|
|
* @pdev: Pointer to pci_dev structure
|
|
*/
|
|
int
|
|
mpt_resume(struct pci_dev *pdev)
|
|
{
|
|
MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
|
|
u32 device_state = pdev->current_state;
|
|
int recovery_state;
|
|
int err;
|
|
|
|
printk(MYIOC_s_INFO_FMT "pci-resume: pdev=0x%p, slot=%s, Previous "
|
|
"operating state [D%d]\n", ioc->name, pdev, pci_name(pdev),
|
|
device_state);
|
|
|
|
pci_set_power_state(pdev, PCI_D0);
|
|
pci_enable_wake(pdev, PCI_D0, 0);
|
|
pci_restore_state(pdev);
|
|
ioc->pcidev = pdev;
|
|
err = mpt_mapresources(ioc);
|
|
if (err)
|
|
return err;
|
|
|
|
printk(MYIOC_s_INFO_FMT "pci-resume: ioc-state=0x%x,doorbell=0x%x\n",
|
|
ioc->name, (mpt_GetIocState(ioc, 1) >> MPI_IOC_STATE_SHIFT),
|
|
CHIPREG_READ32(&ioc->chip->Doorbell));
|
|
|
|
/*
|
|
* Errata workaround for SAS pci express:
|
|
* Upon returning to the D0 state, the contents of the doorbell will be
|
|
* stale data, and this will incorrectly signal to the host driver that
|
|
* the firmware is ready to process mpt commands. The workaround is
|
|
* to issue a diagnostic reset.
|
|
*/
|
|
if (ioc->bus_type == SAS && (pdev->device ==
|
|
MPI_MANUFACTPAGE_DEVID_SAS1068E || pdev->device ==
|
|
MPI_MANUFACTPAGE_DEVID_SAS1064E)) {
|
|
if (KickStart(ioc, 1, CAN_SLEEP) < 0) {
|
|
printk(MYIOC_s_WARN_FMT "pci-resume: Cannot recover\n",
|
|
ioc->name);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
/* bring ioc to operational state */
|
|
printk(MYIOC_s_INFO_FMT "Sending mpt_do_ioc_recovery\n", ioc->name);
|
|
recovery_state = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP,
|
|
CAN_SLEEP);
|
|
if (recovery_state != 0)
|
|
printk(MYIOC_s_WARN_FMT "pci-resume: Cannot recover, "
|
|
"error:[%x]\n", ioc->name, recovery_state);
|
|
else
|
|
printk(MYIOC_s_INFO_FMT
|
|
"pci-resume: success\n", ioc->name);
|
|
out:
|
|
return 0;
|
|
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
mpt_signal_reset(u8 index, MPT_ADAPTER *ioc, int reset_phase)
|
|
{
|
|
if ((MptDriverClass[index] == MPTSPI_DRIVER &&
|
|
ioc->bus_type != SPI) ||
|
|
(MptDriverClass[index] == MPTFC_DRIVER &&
|
|
ioc->bus_type != FC) ||
|
|
(MptDriverClass[index] == MPTSAS_DRIVER &&
|
|
ioc->bus_type != SAS))
|
|
/* make sure we only call the relevant reset handler
|
|
* for the bus */
|
|
return 0;
|
|
return (MptResetHandlers[index])(ioc, reset_phase);
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_do_ioc_recovery - Initialize or recover MPT adapter.
|
|
* @ioc: Pointer to MPT adapter structure
|
|
* @reason: Event word / reason
|
|
* @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
|
|
*
|
|
* This routine performs all the steps necessary to bring the IOC
|
|
* to a OPERATIONAL state.
|
|
*
|
|
* This routine also pre-fetches the LAN MAC address of a Fibre Channel
|
|
* MPT adapter.
|
|
*
|
|
* Returns:
|
|
* 0 for success
|
|
* -1 if failed to get board READY
|
|
* -2 if READY but IOCFacts Failed
|
|
* -3 if READY but PrimeIOCFifos Failed
|
|
* -4 if READY but IOCInit Failed
|
|
* -5 if failed to enable_device and/or request_selected_regions
|
|
* -6 if failed to upload firmware
|
|
*/
|
|
static int
|
|
mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag)
|
|
{
|
|
int hard_reset_done = 0;
|
|
int alt_ioc_ready = 0;
|
|
int hard;
|
|
int rc=0;
|
|
int ii;
|
|
u8 cb_idx;
|
|
int handlers;
|
|
int ret = 0;
|
|
int reset_alt_ioc_active = 0;
|
|
int irq_allocated = 0;
|
|
u8 *a;
|
|
|
|
printk(MYIOC_s_INFO_FMT "Initiating %s\n", ioc->name,
|
|
reason == MPT_HOSTEVENT_IOC_BRINGUP ? "bringup" : "recovery");
|
|
|
|
/* Disable reply interrupts (also blocks FreeQ) */
|
|
CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
|
|
ioc->active = 0;
|
|
|
|
if (ioc->alt_ioc) {
|
|
if (ioc->alt_ioc->active)
|
|
reset_alt_ioc_active = 1;
|
|
|
|
/* Disable alt-IOC's reply interrupts (and FreeQ) for a bit ... */
|
|
CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, 0xFFFFFFFF);
|
|
ioc->alt_ioc->active = 0;
|
|
}
|
|
|
|
hard = 1;
|
|
if (reason == MPT_HOSTEVENT_IOC_BRINGUP)
|
|
hard = 0;
|
|
|
|
if ((hard_reset_done = MakeIocReady(ioc, hard, sleepFlag)) < 0) {
|
|
if (hard_reset_done == -4) {
|
|
printk(MYIOC_s_WARN_FMT "Owned by PEER..skipping!\n",
|
|
ioc->name);
|
|
|
|
if (reset_alt_ioc_active && ioc->alt_ioc) {
|
|
/* (re)Enable alt-IOC! (reply interrupt, FreeQ) */
|
|
dprintk(ioc, printk(MYIOC_s_INFO_FMT
|
|
"alt_ioc reply irq re-enabled\n", ioc->alt_ioc->name));
|
|
CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
|
|
ioc->alt_ioc->active = 1;
|
|
}
|
|
|
|
} else {
|
|
printk(MYIOC_s_WARN_FMT "NOT READY!\n", ioc->name);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/* hard_reset_done = 0 if a soft reset was performed
|
|
* and 1 if a hard reset was performed.
|
|
*/
|
|
if (hard_reset_done && reset_alt_ioc_active && ioc->alt_ioc) {
|
|
if ((rc = MakeIocReady(ioc->alt_ioc, 0, sleepFlag)) == 0)
|
|
alt_ioc_ready = 1;
|
|
else
|
|
printk(MYIOC_s_WARN_FMT "alt_ioc not ready!\n", ioc->alt_ioc->name);
|
|
}
|
|
|
|
for (ii=0; ii<5; ii++) {
|
|
/* Get IOC facts! Allow 5 retries */
|
|
if ((rc = GetIocFacts(ioc, sleepFlag, reason)) == 0)
|
|
break;
|
|
}
|
|
|
|
|
|
if (ii == 5) {
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"Retry IocFacts failed rc=%x\n", ioc->name, rc));
|
|
ret = -2;
|
|
} else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
|
|
MptDisplayIocCapabilities(ioc);
|
|
}
|
|
|
|
if (alt_ioc_ready) {
|
|
if ((rc = GetIocFacts(ioc->alt_ioc, sleepFlag, reason)) != 0) {
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"Initial Alt IocFacts failed rc=%x\n", ioc->name, rc));
|
|
/* Retry - alt IOC was initialized once
|
|
*/
|
|
rc = GetIocFacts(ioc->alt_ioc, sleepFlag, reason);
|
|
}
|
|
if (rc) {
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"Retry Alt IocFacts failed rc=%x\n", ioc->name, rc));
|
|
alt_ioc_ready = 0;
|
|
reset_alt_ioc_active = 0;
|
|
} else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
|
|
MptDisplayIocCapabilities(ioc->alt_ioc);
|
|
}
|
|
}
|
|
|
|
if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP) &&
|
|
(ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)) {
|
|
pci_release_selected_regions(ioc->pcidev, ioc->bars);
|
|
ioc->bars = pci_select_bars(ioc->pcidev, IORESOURCE_MEM |
|
|
IORESOURCE_IO);
|
|
if (pci_enable_device(ioc->pcidev))
|
|
return -5;
|
|
if (pci_request_selected_regions(ioc->pcidev, ioc->bars,
|
|
"mpt"))
|
|
return -5;
|
|
}
|
|
|
|
/*
|
|
* Device is reset now. It must have de-asserted the interrupt line
|
|
* (if it was asserted) and it should be safe to register for the
|
|
* interrupt now.
|
|
*/
|
|
if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP)) {
|
|
ioc->pci_irq = -1;
|
|
if (ioc->pcidev->irq) {
|
|
if (ioc->msi_enable && !pci_enable_msi(ioc->pcidev))
|
|
printk(MYIOC_s_INFO_FMT "PCI-MSI enabled\n",
|
|
ioc->name);
|
|
else
|
|
ioc->msi_enable = 0;
|
|
rc = request_irq(ioc->pcidev->irq, mpt_interrupt,
|
|
IRQF_SHARED, ioc->name, ioc);
|
|
if (rc < 0) {
|
|
printk(MYIOC_s_ERR_FMT "Unable to allocate "
|
|
"interrupt %d!\n", ioc->name, ioc->pcidev->irq);
|
|
if (ioc->msi_enable)
|
|
pci_disable_msi(ioc->pcidev);
|
|
return -EBUSY;
|
|
}
|
|
irq_allocated = 1;
|
|
ioc->pci_irq = ioc->pcidev->irq;
|
|
pci_set_master(ioc->pcidev); /* ?? */
|
|
dprintk(ioc, printk(MYIOC_s_INFO_FMT "installed at interrupt "
|
|
"%d\n", ioc->name, ioc->pcidev->irq));
|
|
}
|
|
}
|
|
|
|
/* Prime reply & request queues!
|
|
* (mucho alloc's) Must be done prior to
|
|
* init as upper addresses are needed for init.
|
|
* If fails, continue with alt-ioc processing
|
|
*/
|
|
if ((ret == 0) && ((rc = PrimeIocFifos(ioc)) != 0))
|
|
ret = -3;
|
|
|
|
/* May need to check/upload firmware & data here!
|
|
* If fails, continue with alt-ioc processing
|
|
*/
|
|
if ((ret == 0) && ((rc = SendIocInit(ioc, sleepFlag)) != 0))
|
|
ret = -4;
|
|
// NEW!
|
|
if (alt_ioc_ready && ((rc = PrimeIocFifos(ioc->alt_ioc)) != 0)) {
|
|
printk(MYIOC_s_WARN_FMT ": alt_ioc (%d) FIFO mgmt alloc!\n",
|
|
ioc->alt_ioc->name, rc);
|
|
alt_ioc_ready = 0;
|
|
reset_alt_ioc_active = 0;
|
|
}
|
|
|
|
if (alt_ioc_ready) {
|
|
if ((rc = SendIocInit(ioc->alt_ioc, sleepFlag)) != 0) {
|
|
alt_ioc_ready = 0;
|
|
reset_alt_ioc_active = 0;
|
|
printk(MYIOC_s_WARN_FMT "alt_ioc (%d) init failure!\n",
|
|
ioc->alt_ioc->name, rc);
|
|
}
|
|
}
|
|
|
|
if (reason == MPT_HOSTEVENT_IOC_BRINGUP){
|
|
if (ioc->upload_fw) {
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"firmware upload required!\n", ioc->name));
|
|
|
|
/* Controller is not operational, cannot do upload
|
|
*/
|
|
if (ret == 0) {
|
|
rc = mpt_do_upload(ioc, sleepFlag);
|
|
if (rc == 0) {
|
|
if (ioc->alt_ioc && ioc->alt_ioc->cached_fw) {
|
|
/*
|
|
* Maintain only one pointer to FW memory
|
|
* so there will not be two attempt to
|
|
* downloadboot onboard dual function
|
|
* chips (mpt_adapter_disable,
|
|
* mpt_diag_reset)
|
|
*/
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"mpt_upload: alt_%s has cached_fw=%p \n",
|
|
ioc->name, ioc->alt_ioc->name, ioc->alt_ioc->cached_fw));
|
|
ioc->cached_fw = NULL;
|
|
}
|
|
} else {
|
|
printk(MYIOC_s_WARN_FMT
|
|
"firmware upload failure!\n", ioc->name);
|
|
ret = -6;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ret == 0) {
|
|
/* Enable! (reply interrupt) */
|
|
CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);
|
|
ioc->active = 1;
|
|
}
|
|
|
|
if (reset_alt_ioc_active && ioc->alt_ioc) {
|
|
/* (re)Enable alt-IOC! (reply interrupt) */
|
|
dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "alt_ioc reply irq re-enabled\n",
|
|
ioc->alt_ioc->name));
|
|
CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
|
|
ioc->alt_ioc->active = 1;
|
|
}
|
|
|
|
/* Enable MPT base driver management of EventNotification
|
|
* and EventAck handling.
|
|
*/
|
|
if ((ret == 0) && (!ioc->facts.EventState))
|
|
(void) SendEventNotification(ioc, 1); /* 1=Enable EventNotification */
|
|
|
|
if (ioc->alt_ioc && alt_ioc_ready && !ioc->alt_ioc->facts.EventState)
|
|
(void) SendEventNotification(ioc->alt_ioc, 1); /* 1=Enable EventNotification */
|
|
|
|
/* Add additional "reason" check before call to GetLanConfigPages
|
|
* (combined with GetIoUnitPage2 call). This prevents a somewhat
|
|
* recursive scenario; GetLanConfigPages times out, timer expired
|
|
* routine calls HardResetHandler, which calls into here again,
|
|
* and we try GetLanConfigPages again...
|
|
*/
|
|
if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP)) {
|
|
|
|
/*
|
|
* Initalize link list for inactive raid volumes.
|
|
*/
|
|
mutex_init(&ioc->raid_data.inactive_list_mutex);
|
|
INIT_LIST_HEAD(&ioc->raid_data.inactive_list);
|
|
|
|
if (ioc->bus_type == SAS) {
|
|
|
|
/* clear persistency table */
|
|
if(ioc->facts.IOCExceptions &
|
|
MPI_IOCFACTS_EXCEPT_PERSISTENT_TABLE_FULL) {
|
|
ret = mptbase_sas_persist_operation(ioc,
|
|
MPI_SAS_OP_CLEAR_NOT_PRESENT);
|
|
if(ret != 0)
|
|
goto out;
|
|
}
|
|
|
|
/* Find IM volumes
|
|
*/
|
|
mpt_findImVolumes(ioc);
|
|
|
|
} else if (ioc->bus_type == FC) {
|
|
if ((ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) &&
|
|
(ioc->lan_cnfg_page0.Header.PageLength == 0)) {
|
|
/*
|
|
* Pre-fetch the ports LAN MAC address!
|
|
* (LANPage1_t stuff)
|
|
*/
|
|
(void) GetLanConfigPages(ioc);
|
|
a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
|
|
ioc->name, a[5], a[4], a[3], a[2], a[1], a[0]));
|
|
|
|
}
|
|
} else {
|
|
/* Get NVRAM and adapter maximums from SPP 0 and 2
|
|
*/
|
|
mpt_GetScsiPortSettings(ioc, 0);
|
|
|
|
/* Get version and length of SDP 1
|
|
*/
|
|
mpt_readScsiDevicePageHeaders(ioc, 0);
|
|
|
|
/* Find IM volumes
|
|
*/
|
|
if (ioc->facts.MsgVersion >= MPI_VERSION_01_02)
|
|
mpt_findImVolumes(ioc);
|
|
|
|
/* Check, and possibly reset, the coalescing value
|
|
*/
|
|
mpt_read_ioc_pg_1(ioc);
|
|
|
|
mpt_read_ioc_pg_4(ioc);
|
|
}
|
|
|
|
GetIoUnitPage2(ioc);
|
|
mpt_get_manufacturing_pg_0(ioc);
|
|
}
|
|
|
|
/*
|
|
* Call each currently registered protocol IOC reset handler
|
|
* with post-reset indication.
|
|
* NOTE: If we're doing _IOC_BRINGUP, there can be no
|
|
* MptResetHandlers[] registered yet.
|
|
*/
|
|
if (hard_reset_done) {
|
|
rc = handlers = 0;
|
|
for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
|
|
if ((ret == 0) && MptResetHandlers[cb_idx]) {
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"Calling IOC post_reset handler #%d\n",
|
|
ioc->name, cb_idx));
|
|
rc += mpt_signal_reset(cb_idx, ioc, MPT_IOC_POST_RESET);
|
|
handlers++;
|
|
}
|
|
|
|
if (alt_ioc_ready && MptResetHandlers[cb_idx]) {
|
|
drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"Calling IOC post_reset handler #%d\n",
|
|
ioc->alt_ioc->name, cb_idx));
|
|
rc += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_POST_RESET);
|
|
handlers++;
|
|
}
|
|
}
|
|
/* FIXME? Examine results here? */
|
|
}
|
|
|
|
out:
|
|
if ((ret != 0) && irq_allocated) {
|
|
free_irq(ioc->pci_irq, ioc);
|
|
if (ioc->msi_enable)
|
|
pci_disable_msi(ioc->pcidev);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_detect_bound_ports - Search for matching PCI bus/dev_function
|
|
* @ioc: Pointer to MPT adapter structure
|
|
* @pdev: Pointer to (struct pci_dev) structure
|
|
*
|
|
* Search for PCI bus/dev_function which matches
|
|
* PCI bus/dev_function (+/-1) for newly discovered 929,
|
|
* 929X, 1030 or 1035.
|
|
*
|
|
* If match on PCI dev_function +/-1 is found, bind the two MPT adapters
|
|
* using alt_ioc pointer fields in their %MPT_ADAPTER structures.
|
|
*/
|
|
static void
|
|
mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev)
|
|
{
|
|
struct pci_dev *peer=NULL;
|
|
unsigned int slot = PCI_SLOT(pdev->devfn);
|
|
unsigned int func = PCI_FUNC(pdev->devfn);
|
|
MPT_ADAPTER *ioc_srch;
|
|
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PCI device %s devfn=%x/%x,"
|
|
" searching for devfn match on %x or %x\n",
|
|
ioc->name, pci_name(pdev), pdev->bus->number,
|
|
pdev->devfn, func-1, func+1));
|
|
|
|
peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func-1));
|
|
if (!peer) {
|
|
peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func+1));
|
|
if (!peer)
|
|
return;
|
|
}
|
|
|
|
list_for_each_entry(ioc_srch, &ioc_list, list) {
|
|
struct pci_dev *_pcidev = ioc_srch->pcidev;
|
|
if (_pcidev == peer) {
|
|
/* Paranoia checks */
|
|
if (ioc->alt_ioc != NULL) {
|
|
printk(MYIOC_s_WARN_FMT "Oops, already bound to %s!\n",
|
|
ioc->name, ioc->alt_ioc->name);
|
|
break;
|
|
} else if (ioc_srch->alt_ioc != NULL) {
|
|
printk(MYIOC_s_WARN_FMT "Oops, already bound to %s!\n",
|
|
ioc_srch->name, ioc_srch->alt_ioc->name);
|
|
break;
|
|
}
|
|
dprintk(ioc, printk(MYIOC_s_INFO_FMT "FOUND! binding to %s\n",
|
|
ioc->name, ioc_srch->name));
|
|
ioc_srch->alt_ioc = ioc;
|
|
ioc->alt_ioc = ioc_srch;
|
|
}
|
|
}
|
|
pci_dev_put(peer);
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_adapter_disable - Disable misbehaving MPT adapter.
|
|
* @ioc: Pointer to MPT adapter structure
|
|
*/
|
|
static void
|
|
mpt_adapter_disable(MPT_ADAPTER *ioc)
|
|
{
|
|
int sz;
|
|
int ret;
|
|
|
|
if (ioc->cached_fw != NULL) {
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: Pushing FW onto "
|
|
"adapter\n", __func__, ioc->name));
|
|
if ((ret = mpt_downloadboot(ioc, (MpiFwHeader_t *)
|
|
ioc->cached_fw, CAN_SLEEP)) < 0) {
|
|
printk(MYIOC_s_WARN_FMT
|
|
": firmware downloadboot failure (%d)!\n",
|
|
ioc->name, ret);
|
|
}
|
|
}
|
|
|
|
/* Disable adapter interrupts! */
|
|
CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
|
|
ioc->active = 0;
|
|
/* Clear any lingering interrupt */
|
|
CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
|
|
|
|
if (ioc->alloc != NULL) {
|
|
sz = ioc->alloc_sz;
|
|
dexitprintk(ioc, printk(MYIOC_s_INFO_FMT "free @ %p, sz=%d bytes\n",
|
|
ioc->name, ioc->alloc, ioc->alloc_sz));
|
|
pci_free_consistent(ioc->pcidev, sz,
|
|
ioc->alloc, ioc->alloc_dma);
|
|
ioc->reply_frames = NULL;
|
|
ioc->req_frames = NULL;
|
|
ioc->alloc = NULL;
|
|
ioc->alloc_total -= sz;
|
|
}
|
|
|
|
if (ioc->sense_buf_pool != NULL) {
|
|
sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
|
|
pci_free_consistent(ioc->pcidev, sz,
|
|
ioc->sense_buf_pool, ioc->sense_buf_pool_dma);
|
|
ioc->sense_buf_pool = NULL;
|
|
ioc->alloc_total -= sz;
|
|
}
|
|
|
|
if (ioc->events != NULL){
|
|
sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
|
|
kfree(ioc->events);
|
|
ioc->events = NULL;
|
|
ioc->alloc_total -= sz;
|
|
}
|
|
|
|
mpt_free_fw_memory(ioc);
|
|
|
|
kfree(ioc->spi_data.nvram);
|
|
mpt_inactive_raid_list_free(ioc);
|
|
kfree(ioc->raid_data.pIocPg2);
|
|
kfree(ioc->raid_data.pIocPg3);
|
|
ioc->spi_data.nvram = NULL;
|
|
ioc->raid_data.pIocPg3 = NULL;
|
|
|
|
if (ioc->spi_data.pIocPg4 != NULL) {
|
|
sz = ioc->spi_data.IocPg4Sz;
|
|
pci_free_consistent(ioc->pcidev, sz,
|
|
ioc->spi_data.pIocPg4,
|
|
ioc->spi_data.IocPg4_dma);
|
|
ioc->spi_data.pIocPg4 = NULL;
|
|
ioc->alloc_total -= sz;
|
|
}
|
|
|
|
if (ioc->ReqToChain != NULL) {
|
|
kfree(ioc->ReqToChain);
|
|
kfree(ioc->RequestNB);
|
|
ioc->ReqToChain = NULL;
|
|
}
|
|
|
|
kfree(ioc->ChainToChain);
|
|
ioc->ChainToChain = NULL;
|
|
|
|
if (ioc->HostPageBuffer != NULL) {
|
|
if((ret = mpt_host_page_access_control(ioc,
|
|
MPI_DB_HPBAC_FREE_BUFFER, NO_SLEEP)) != 0) {
|
|
printk(MYIOC_s_ERR_FMT
|
|
"host page buffers free failed (%d)!\n",
|
|
ioc->name, ret);
|
|
}
|
|
dexitprintk(ioc, printk(MYIOC_s_INFO_FMT "HostPageBuffer free @ %p, sz=%d bytes\n",
|
|
ioc->name, ioc->HostPageBuffer, ioc->HostPageBuffer_sz));
|
|
pci_free_consistent(ioc->pcidev, ioc->HostPageBuffer_sz,
|
|
ioc->HostPageBuffer, ioc->HostPageBuffer_dma);
|
|
ioc->HostPageBuffer = NULL;
|
|
ioc->HostPageBuffer_sz = 0;
|
|
ioc->alloc_total -= ioc->HostPageBuffer_sz;
|
|
}
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_adapter_dispose - Free all resources associated with an MPT adapter
|
|
* @ioc: Pointer to MPT adapter structure
|
|
*
|
|
* This routine unregisters h/w resources and frees all alloc'd memory
|
|
* associated with a MPT adapter structure.
|
|
*/
|
|
static void
|
|
mpt_adapter_dispose(MPT_ADAPTER *ioc)
|
|
{
|
|
int sz_first, sz_last;
|
|
|
|
if (ioc == NULL)
|
|
return;
|
|
|
|
sz_first = ioc->alloc_total;
|
|
|
|
mpt_adapter_disable(ioc);
|
|
|
|
if (ioc->pci_irq != -1) {
|
|
free_irq(ioc->pci_irq, ioc);
|
|
if (ioc->msi_enable)
|
|
pci_disable_msi(ioc->pcidev);
|
|
ioc->pci_irq = -1;
|
|
}
|
|
|
|
if (ioc->memmap != NULL) {
|
|
iounmap(ioc->memmap);
|
|
ioc->memmap = NULL;
|
|
}
|
|
|
|
pci_disable_device(ioc->pcidev);
|
|
pci_release_selected_regions(ioc->pcidev, ioc->bars);
|
|
|
|
#if defined(CONFIG_MTRR) && 0
|
|
if (ioc->mtrr_reg > 0) {
|
|
mtrr_del(ioc->mtrr_reg, 0, 0);
|
|
dprintk(ioc, printk(MYIOC_s_INFO_FMT "MTRR region de-registered\n", ioc->name));
|
|
}
|
|
#endif
|
|
|
|
/* Zap the adapter lookup ptr! */
|
|
list_del(&ioc->list);
|
|
|
|
sz_last = ioc->alloc_total;
|
|
dprintk(ioc, printk(MYIOC_s_INFO_FMT "free'd %d of %d bytes\n",
|
|
ioc->name, sz_first-sz_last+(int)sizeof(*ioc), sz_first));
|
|
|
|
if (ioc->alt_ioc)
|
|
ioc->alt_ioc->alt_ioc = NULL;
|
|
|
|
kfree(ioc);
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* MptDisplayIocCapabilities - Disply IOC's capabilities.
|
|
* @ioc: Pointer to MPT adapter structure
|
|
*/
|
|
static void
|
|
MptDisplayIocCapabilities(MPT_ADAPTER *ioc)
|
|
{
|
|
int i = 0;
|
|
|
|
printk(KERN_INFO "%s: ", ioc->name);
|
|
if (ioc->prod_name)
|
|
printk("%s: ", ioc->prod_name);
|
|
printk("Capabilities={");
|
|
|
|
if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_INITIATOR) {
|
|
printk("Initiator");
|
|
i++;
|
|
}
|
|
|
|
if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
|
|
printk("%sTarget", i ? "," : "");
|
|
i++;
|
|
}
|
|
|
|
if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) {
|
|
printk("%sLAN", i ? "," : "");
|
|
i++;
|
|
}
|
|
|
|
#if 0
|
|
/*
|
|
* This would probably evoke more questions than it's worth
|
|
*/
|
|
if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
|
|
printk("%sLogBusAddr", i ? "," : "");
|
|
i++;
|
|
}
|
|
#endif
|
|
|
|
printk("}\n");
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* MakeIocReady - Get IOC to a READY state, using KickStart if needed.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @force: Force hard KickStart of IOC
|
|
* @sleepFlag: Specifies whether the process can sleep
|
|
*
|
|
* Returns:
|
|
* 1 - DIAG reset and READY
|
|
* 0 - READY initially OR soft reset and READY
|
|
* -1 - Any failure on KickStart
|
|
* -2 - Msg Unit Reset Failed
|
|
* -3 - IO Unit Reset Failed
|
|
* -4 - IOC owned by a PEER
|
|
*/
|
|
static int
|
|
MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag)
|
|
{
|
|
u32 ioc_state;
|
|
int statefault = 0;
|
|
int cntdn;
|
|
int hard_reset_done = 0;
|
|
int r;
|
|
int ii;
|
|
int whoinit;
|
|
|
|
/* Get current [raw] IOC state */
|
|
ioc_state = mpt_GetIocState(ioc, 0);
|
|
dhsprintk(ioc, printk(MYIOC_s_INFO_FMT "MakeIocReady [raw] state=%08x\n", ioc->name, ioc_state));
|
|
|
|
/*
|
|
* Check to see if IOC got left/stuck in doorbell handshake
|
|
* grip of death. If so, hard reset the IOC.
|
|
*/
|
|
if (ioc_state & MPI_DOORBELL_ACTIVE) {
|
|
statefault = 1;
|
|
printk(MYIOC_s_WARN_FMT "Unexpected doorbell active!\n",
|
|
ioc->name);
|
|
}
|
|
|
|
/* Is it already READY? */
|
|
if (!statefault && (ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_READY)
|
|
return 0;
|
|
|
|
/*
|
|
* Check to see if IOC is in FAULT state.
|
|
*/
|
|
if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
|
|
statefault = 2;
|
|
printk(MYIOC_s_WARN_FMT "IOC is in FAULT state!!!\n",
|
|
ioc->name);
|
|
printk(MYIOC_s_WARN_FMT " FAULT code = %04xh\n",
|
|
ioc->name, ioc_state & MPI_DOORBELL_DATA_MASK);
|
|
}
|
|
|
|
/*
|
|
* Hmmm... Did it get left operational?
|
|
*/
|
|
if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_OPERATIONAL) {
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOC operational unexpected\n",
|
|
ioc->name));
|
|
|
|
/* Check WhoInit.
|
|
* If PCI Peer, exit.
|
|
* Else, if no fault conditions are present, issue a MessageUnitReset
|
|
* Else, fall through to KickStart case
|
|
*/
|
|
whoinit = (ioc_state & MPI_DOORBELL_WHO_INIT_MASK) >> MPI_DOORBELL_WHO_INIT_SHIFT;
|
|
dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
|
|
"whoinit 0x%x statefault %d force %d\n",
|
|
ioc->name, whoinit, statefault, force));
|
|
if (whoinit == MPI_WHOINIT_PCI_PEER)
|
|
return -4;
|
|
else {
|
|
if ((statefault == 0 ) && (force == 0)) {
|
|
if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) == 0)
|
|
return 0;
|
|
}
|
|
statefault = 3;
|
|
}
|
|
}
|
|
|
|
hard_reset_done = KickStart(ioc, statefault||force, sleepFlag);
|
|
if (hard_reset_done < 0)
|
|
return -1;
|
|
|
|
/*
|
|
* Loop here waiting for IOC to come READY.
|
|
*/
|
|
ii = 0;
|
|
cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 5; /* 5 seconds */
|
|
|
|
while ((ioc_state = mpt_GetIocState(ioc, 1)) != MPI_IOC_STATE_READY) {
|
|
if (ioc_state == MPI_IOC_STATE_OPERATIONAL) {
|
|
/*
|
|
* BIOS or previous driver load left IOC in OP state.
|
|
* Reset messaging FIFOs.
|
|
*/
|
|
if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) != 0) {
|
|
printk(MYIOC_s_ERR_FMT "IOC msg unit reset failed!\n", ioc->name);
|
|
return -2;
|
|
}
|
|
} else if (ioc_state == MPI_IOC_STATE_RESET) {
|
|
/*
|
|
* Something is wrong. Try to get IOC back
|
|
* to a known state.
|
|
*/
|
|
if ((r = SendIocReset(ioc, MPI_FUNCTION_IO_UNIT_RESET, sleepFlag)) != 0) {
|
|
printk(MYIOC_s_ERR_FMT "IO unit reset failed!\n", ioc->name);
|
|
return -3;
|
|
}
|
|
}
|
|
|
|
ii++; cntdn--;
|
|
if (!cntdn) {
|
|
printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
|
|
ioc->name, (int)((ii+5)/HZ));
|
|
return -ETIME;
|
|
}
|
|
|
|
if (sleepFlag == CAN_SLEEP) {
|
|
msleep(1);
|
|
} else {
|
|
mdelay (1); /* 1 msec delay */
|
|
}
|
|
|
|
}
|
|
|
|
if (statefault < 3) {
|
|
printk(MYIOC_s_INFO_FMT "Recovered from %s\n",
|
|
ioc->name,
|
|
statefault==1 ? "stuck handshake" : "IOC FAULT");
|
|
}
|
|
|
|
return hard_reset_done;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_GetIocState - Get the current state of a MPT adapter.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @cooked: Request raw or cooked IOC state
|
|
*
|
|
* Returns all IOC Doorbell register bits if cooked==0, else just the
|
|
* Doorbell bits in MPI_IOC_STATE_MASK.
|
|
*/
|
|
u32
|
|
mpt_GetIocState(MPT_ADAPTER *ioc, int cooked)
|
|
{
|
|
u32 s, sc;
|
|
|
|
/* Get! */
|
|
s = CHIPREG_READ32(&ioc->chip->Doorbell);
|
|
sc = s & MPI_IOC_STATE_MASK;
|
|
|
|
/* Save! */
|
|
ioc->last_state = sc;
|
|
|
|
return cooked ? sc : s;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* GetIocFacts - Send IOCFacts request to MPT adapter.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @sleepFlag: Specifies whether the process can sleep
|
|
* @reason: If recovery, only update facts.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
static int
|
|
GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason)
|
|
{
|
|
IOCFacts_t get_facts;
|
|
IOCFactsReply_t *facts;
|
|
int r;
|
|
int req_sz;
|
|
int reply_sz;
|
|
int sz;
|
|
u32 status, vv;
|
|
u8 shiftFactor=1;
|
|
|
|
/* IOC *must* NOT be in RESET state! */
|
|
if (ioc->last_state == MPI_IOC_STATE_RESET) {
|
|
printk(MYIOC_s_ERR_FMT "Can't get IOCFacts NOT READY! (%08x)\n",
|
|
ioc->name, ioc->last_state );
|
|
return -44;
|
|
}
|
|
|
|
facts = &ioc->facts;
|
|
|
|
/* Destination (reply area)... */
|
|
reply_sz = sizeof(*facts);
|
|
memset(facts, 0, reply_sz);
|
|
|
|
/* Request area (get_facts on the stack right now!) */
|
|
req_sz = sizeof(get_facts);
|
|
memset(&get_facts, 0, req_sz);
|
|
|
|
get_facts.Function = MPI_FUNCTION_IOC_FACTS;
|
|
/* Assert: All other get_facts fields are zero! */
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"Sending get IocFacts request req_sz=%d reply_sz=%d\n",
|
|
ioc->name, req_sz, reply_sz));
|
|
|
|
/* No non-zero fields in the get_facts request are greater than
|
|
* 1 byte in size, so we can just fire it off as is.
|
|
*/
|
|
r = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_facts,
|
|
reply_sz, (u16*)facts, 5 /*seconds*/, sleepFlag);
|
|
if (r != 0)
|
|
return r;
|
|
|
|
/*
|
|
* Now byte swap (GRRR) the necessary fields before any further
|
|
* inspection of reply contents.
|
|
*
|
|
* But need to do some sanity checks on MsgLength (byte) field
|
|
* to make sure we don't zero IOC's req_sz!
|
|
*/
|
|
/* Did we get a valid reply? */
|
|
if (facts->MsgLength > offsetof(IOCFactsReply_t, RequestFrameSize)/sizeof(u32)) {
|
|
if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
|
|
/*
|
|
* If not been here, done that, save off first WhoInit value
|
|
*/
|
|
if (ioc->FirstWhoInit == WHOINIT_UNKNOWN)
|
|
ioc->FirstWhoInit = facts->WhoInit;
|
|
}
|
|
|
|
facts->MsgVersion = le16_to_cpu(facts->MsgVersion);
|
|
facts->MsgContext = le32_to_cpu(facts->MsgContext);
|
|
facts->IOCExceptions = le16_to_cpu(facts->IOCExceptions);
|
|
facts->IOCStatus = le16_to_cpu(facts->IOCStatus);
|
|
facts->IOCLogInfo = le32_to_cpu(facts->IOCLogInfo);
|
|
status = le16_to_cpu(facts->IOCStatus) & MPI_IOCSTATUS_MASK;
|
|
/* CHECKME! IOCStatus, IOCLogInfo */
|
|
|
|
facts->ReplyQueueDepth = le16_to_cpu(facts->ReplyQueueDepth);
|
|
facts->RequestFrameSize = le16_to_cpu(facts->RequestFrameSize);
|
|
|
|
/*
|
|
* FC f/w version changed between 1.1 and 1.2
|
|
* Old: u16{Major(4),Minor(4),SubMinor(8)}
|
|
* New: u32{Major(8),Minor(8),Unit(8),Dev(8)}
|
|
*/
|
|
if (facts->MsgVersion < 0x0102) {
|
|
/*
|
|
* Handle old FC f/w style, convert to new...
|
|
*/
|
|
u16 oldv = le16_to_cpu(facts->Reserved_0101_FWVersion);
|
|
facts->FWVersion.Word =
|
|
((oldv<<12) & 0xFF000000) |
|
|
((oldv<<8) & 0x000FFF00);
|
|
} else
|
|
facts->FWVersion.Word = le32_to_cpu(facts->FWVersion.Word);
|
|
|
|
facts->ProductID = le16_to_cpu(facts->ProductID);
|
|
if ((ioc->facts.ProductID & MPI_FW_HEADER_PID_PROD_MASK)
|
|
> MPI_FW_HEADER_PID_PROD_TARGET_SCSI)
|
|
ioc->ir_firmware = 1;
|
|
facts->CurrentHostMfaHighAddr =
|
|
le32_to_cpu(facts->CurrentHostMfaHighAddr);
|
|
facts->GlobalCredits = le16_to_cpu(facts->GlobalCredits);
|
|
facts->CurrentSenseBufferHighAddr =
|
|
le32_to_cpu(facts->CurrentSenseBufferHighAddr);
|
|
facts->CurReplyFrameSize =
|
|
le16_to_cpu(facts->CurReplyFrameSize);
|
|
facts->IOCCapabilities = le32_to_cpu(facts->IOCCapabilities);
|
|
|
|
/*
|
|
* Handle NEW (!) IOCFactsReply fields in MPI-1.01.xx
|
|
* Older MPI-1.00.xx struct had 13 dwords, and enlarged
|
|
* to 14 in MPI-1.01.0x.
|
|
*/
|
|
if (facts->MsgLength >= (offsetof(IOCFactsReply_t,FWImageSize) + 7)/4 &&
|
|
facts->MsgVersion > 0x0100) {
|
|
facts->FWImageSize = le32_to_cpu(facts->FWImageSize);
|
|
}
|
|
|
|
sz = facts->FWImageSize;
|
|
if ( sz & 0x01 )
|
|
sz += 1;
|
|
if ( sz & 0x02 )
|
|
sz += 2;
|
|
facts->FWImageSize = sz;
|
|
|
|
if (!facts->RequestFrameSize) {
|
|
/* Something is wrong! */
|
|
printk(MYIOC_s_ERR_FMT "IOC reported invalid 0 request size!\n",
|
|
ioc->name);
|
|
return -55;
|
|
}
|
|
|
|
r = sz = facts->BlockSize;
|
|
vv = ((63 / (sz * 4)) + 1) & 0x03;
|
|
ioc->NB_for_64_byte_frame = vv;
|
|
while ( sz )
|
|
{
|
|
shiftFactor++;
|
|
sz = sz >> 1;
|
|
}
|
|
ioc->NBShiftFactor = shiftFactor;
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"NB_for_64_byte_frame=%x NBShiftFactor=%x BlockSize=%x\n",
|
|
ioc->name, vv, shiftFactor, r));
|
|
|
|
if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
|
|
/*
|
|
* Set values for this IOC's request & reply frame sizes,
|
|
* and request & reply queue depths...
|
|
*/
|
|
ioc->req_sz = min(MPT_DEFAULT_FRAME_SIZE, facts->RequestFrameSize * 4);
|
|
ioc->req_depth = min_t(int, MPT_MAX_REQ_DEPTH, facts->GlobalCredits);
|
|
ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
|
|
ioc->reply_depth = min_t(int, MPT_DEFAULT_REPLY_DEPTH, facts->ReplyQueueDepth);
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "reply_sz=%3d, reply_depth=%4d\n",
|
|
ioc->name, ioc->reply_sz, ioc->reply_depth));
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "req_sz =%3d, req_depth =%4d\n",
|
|
ioc->name, ioc->req_sz, ioc->req_depth));
|
|
|
|
/* Get port facts! */
|
|
if ( (r = GetPortFacts(ioc, 0, sleepFlag)) != 0 )
|
|
return r;
|
|
}
|
|
} else {
|
|
printk(MYIOC_s_ERR_FMT
|
|
"Invalid IOC facts reply, msgLength=%d offsetof=%zd!\n",
|
|
ioc->name, facts->MsgLength, (offsetof(IOCFactsReply_t,
|
|
RequestFrameSize)/sizeof(u32)));
|
|
return -66;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* GetPortFacts - Send PortFacts request to MPT adapter.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @portnum: Port number
|
|
* @sleepFlag: Specifies whether the process can sleep
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
static int
|
|
GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
|
|
{
|
|
PortFacts_t get_pfacts;
|
|
PortFactsReply_t *pfacts;
|
|
int ii;
|
|
int req_sz;
|
|
int reply_sz;
|
|
int max_id;
|
|
|
|
/* IOC *must* NOT be in RESET state! */
|
|
if (ioc->last_state == MPI_IOC_STATE_RESET) {
|
|
printk(MYIOC_s_ERR_FMT "Can't get PortFacts NOT READY! (%08x)\n",
|
|
ioc->name, ioc->last_state );
|
|
return -4;
|
|
}
|
|
|
|
pfacts = &ioc->pfacts[portnum];
|
|
|
|
/* Destination (reply area)... */
|
|
reply_sz = sizeof(*pfacts);
|
|
memset(pfacts, 0, reply_sz);
|
|
|
|
/* Request area (get_pfacts on the stack right now!) */
|
|
req_sz = sizeof(get_pfacts);
|
|
memset(&get_pfacts, 0, req_sz);
|
|
|
|
get_pfacts.Function = MPI_FUNCTION_PORT_FACTS;
|
|
get_pfacts.PortNumber = portnum;
|
|
/* Assert: All other get_pfacts fields are zero! */
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending get PortFacts(%d) request\n",
|
|
ioc->name, portnum));
|
|
|
|
/* No non-zero fields in the get_pfacts request are greater than
|
|
* 1 byte in size, so we can just fire it off as is.
|
|
*/
|
|
ii = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_pfacts,
|
|
reply_sz, (u16*)pfacts, 5 /*seconds*/, sleepFlag);
|
|
if (ii != 0)
|
|
return ii;
|
|
|
|
/* Did we get a valid reply? */
|
|
|
|
/* Now byte swap the necessary fields in the response. */
|
|
pfacts->MsgContext = le32_to_cpu(pfacts->MsgContext);
|
|
pfacts->IOCStatus = le16_to_cpu(pfacts->IOCStatus);
|
|
pfacts->IOCLogInfo = le32_to_cpu(pfacts->IOCLogInfo);
|
|
pfacts->MaxDevices = le16_to_cpu(pfacts->MaxDevices);
|
|
pfacts->PortSCSIID = le16_to_cpu(pfacts->PortSCSIID);
|
|
pfacts->ProtocolFlags = le16_to_cpu(pfacts->ProtocolFlags);
|
|
pfacts->MaxPostedCmdBuffers = le16_to_cpu(pfacts->MaxPostedCmdBuffers);
|
|
pfacts->MaxPersistentIDs = le16_to_cpu(pfacts->MaxPersistentIDs);
|
|
pfacts->MaxLanBuckets = le16_to_cpu(pfacts->MaxLanBuckets);
|
|
|
|
max_id = (ioc->bus_type == SAS) ? pfacts->PortSCSIID :
|
|
pfacts->MaxDevices;
|
|
ioc->devices_per_bus = (max_id > 255) ? 256 : max_id;
|
|
ioc->number_of_buses = (ioc->devices_per_bus < 256) ? 1 : max_id/256;
|
|
|
|
/*
|
|
* Place all the devices on channels
|
|
*
|
|
* (for debuging)
|
|
*/
|
|
if (mpt_channel_mapping) {
|
|
ioc->devices_per_bus = 1;
|
|
ioc->number_of_buses = (max_id > 255) ? 255 : max_id;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* SendIocInit - Send IOCInit request to MPT adapter.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @sleepFlag: Specifies whether the process can sleep
|
|
*
|
|
* Send IOCInit followed by PortEnable to bring IOC to OPERATIONAL state.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
static int
|
|
SendIocInit(MPT_ADAPTER *ioc, int sleepFlag)
|
|
{
|
|
IOCInit_t ioc_init;
|
|
MPIDefaultReply_t init_reply;
|
|
u32 state;
|
|
int r;
|
|
int count;
|
|
int cntdn;
|
|
|
|
memset(&ioc_init, 0, sizeof(ioc_init));
|
|
memset(&init_reply, 0, sizeof(init_reply));
|
|
|
|
ioc_init.WhoInit = MPI_WHOINIT_HOST_DRIVER;
|
|
ioc_init.Function = MPI_FUNCTION_IOC_INIT;
|
|
|
|
/* If we are in a recovery mode and we uploaded the FW image,
|
|
* then this pointer is not NULL. Skip the upload a second time.
|
|
* Set this flag if cached_fw set for either IOC.
|
|
*/
|
|
if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)
|
|
ioc->upload_fw = 1;
|
|
else
|
|
ioc->upload_fw = 0;
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "upload_fw %d facts.Flags=%x\n",
|
|
ioc->name, ioc->upload_fw, ioc->facts.Flags));
|
|
|
|
ioc_init.MaxDevices = (U8)ioc->devices_per_bus;
|
|
ioc_init.MaxBuses = (U8)ioc->number_of_buses;
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "facts.MsgVersion=%x\n",
|
|
ioc->name, ioc->facts.MsgVersion));
|
|
if (ioc->facts.MsgVersion >= MPI_VERSION_01_05) {
|
|
// set MsgVersion and HeaderVersion host driver was built with
|
|
ioc_init.MsgVersion = cpu_to_le16(MPI_VERSION);
|
|
ioc_init.HeaderVersion = cpu_to_le16(MPI_HEADER_VERSION);
|
|
|
|
if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_HOST_PAGE_BUFFER_PERSISTENT) {
|
|
ioc_init.HostPageBufferSGE = ioc->facts.HostPageBufferSGE;
|
|
} else if(mpt_host_page_alloc(ioc, &ioc_init))
|
|
return -99;
|
|
}
|
|
ioc_init.ReplyFrameSize = cpu_to_le16(ioc->reply_sz); /* in BYTES */
|
|
|
|
if (sizeof(dma_addr_t) == sizeof(u64)) {
|
|
/* Save the upper 32-bits of the request
|
|
* (reply) and sense buffers.
|
|
*/
|
|
ioc_init.HostMfaHighAddr = cpu_to_le32((u32)((u64)ioc->alloc_dma >> 32));
|
|
ioc_init.SenseBufferHighAddr = cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
|
|
} else {
|
|
/* Force 32-bit addressing */
|
|
ioc_init.HostMfaHighAddr = cpu_to_le32(0);
|
|
ioc_init.SenseBufferHighAddr = cpu_to_le32(0);
|
|
}
|
|
|
|
ioc->facts.CurrentHostMfaHighAddr = ioc_init.HostMfaHighAddr;
|
|
ioc->facts.CurrentSenseBufferHighAddr = ioc_init.SenseBufferHighAddr;
|
|
ioc->facts.MaxDevices = ioc_init.MaxDevices;
|
|
ioc->facts.MaxBuses = ioc_init.MaxBuses;
|
|
|
|
dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending IOCInit (req @ %p)\n",
|
|
ioc->name, &ioc_init));
|
|
|
|
r = mpt_handshake_req_reply_wait(ioc, sizeof(IOCInit_t), (u32*)&ioc_init,
|
|
sizeof(MPIDefaultReply_t), (u16*)&init_reply, 10 /*seconds*/, sleepFlag);
|
|
if (r != 0) {
|
|
printk(MYIOC_s_ERR_FMT "Sending IOCInit failed(%d)!\n",ioc->name, r);
|
|
return r;
|
|
}
|
|
|
|
/* No need to byte swap the multibyte fields in the reply
|
|
* since we don't even look at its contents.
|
|
*/
|
|
|
|
dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending PortEnable (req @ %p)\n",
|
|
ioc->name, &ioc_init));
|
|
|
|
if ((r = SendPortEnable(ioc, 0, sleepFlag)) != 0) {
|
|
printk(MYIOC_s_ERR_FMT "Sending PortEnable failed(%d)!\n",ioc->name, r);
|
|
return r;
|
|
}
|
|
|
|
/* YIKES! SUPER IMPORTANT!!!
|
|
* Poll IocState until _OPERATIONAL while IOC is doing
|
|
* LoopInit and TargetDiscovery!
|
|
*/
|
|
count = 0;
|
|
cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 60; /* 60 seconds */
|
|
state = mpt_GetIocState(ioc, 1);
|
|
while (state != MPI_IOC_STATE_OPERATIONAL && --cntdn) {
|
|
if (sleepFlag == CAN_SLEEP) {
|
|
msleep(1);
|
|
} else {
|
|
mdelay(1);
|
|
}
|
|
|
|
if (!cntdn) {
|
|
printk(MYIOC_s_ERR_FMT "Wait IOC_OP state timeout(%d)!\n",
|
|
ioc->name, (int)((count+5)/HZ));
|
|
return -9;
|
|
}
|
|
|
|
state = mpt_GetIocState(ioc, 1);
|
|
count++;
|
|
}
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Wait IOC_OPERATIONAL state (cnt=%d)\n",
|
|
ioc->name, count));
|
|
|
|
ioc->aen_event_read_flag=0;
|
|
return r;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* SendPortEnable - Send PortEnable request to MPT adapter port.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @portnum: Port number to enable
|
|
* @sleepFlag: Specifies whether the process can sleep
|
|
*
|
|
* Send PortEnable to bring IOC to OPERATIONAL state.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
static int
|
|
SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
|
|
{
|
|
PortEnable_t port_enable;
|
|
MPIDefaultReply_t reply_buf;
|
|
int rc;
|
|
int req_sz;
|
|
int reply_sz;
|
|
|
|
/* Destination... */
|
|
reply_sz = sizeof(MPIDefaultReply_t);
|
|
memset(&reply_buf, 0, reply_sz);
|
|
|
|
req_sz = sizeof(PortEnable_t);
|
|
memset(&port_enable, 0, req_sz);
|
|
|
|
port_enable.Function = MPI_FUNCTION_PORT_ENABLE;
|
|
port_enable.PortNumber = portnum;
|
|
/* port_enable.ChainOffset = 0; */
|
|
/* port_enable.MsgFlags = 0; */
|
|
/* port_enable.MsgContext = 0; */
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Port(%d)Enable (req @ %p)\n",
|
|
ioc->name, portnum, &port_enable));
|
|
|
|
/* RAID FW may take a long time to enable
|
|
*/
|
|
if (ioc->ir_firmware || ioc->bus_type == SAS) {
|
|
rc = mpt_handshake_req_reply_wait(ioc, req_sz,
|
|
(u32*)&port_enable, reply_sz, (u16*)&reply_buf,
|
|
300 /*seconds*/, sleepFlag);
|
|
} else {
|
|
rc = mpt_handshake_req_reply_wait(ioc, req_sz,
|
|
(u32*)&port_enable, reply_sz, (u16*)&reply_buf,
|
|
30 /*seconds*/, sleepFlag);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* mpt_alloc_fw_memory - allocate firmware memory
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @size: total FW bytes
|
|
*
|
|
* If memory has already been allocated, the same (cached) value
|
|
* is returned.
|
|
*
|
|
* Return 0 if successfull, or non-zero for failure
|
|
**/
|
|
int
|
|
mpt_alloc_fw_memory(MPT_ADAPTER *ioc, int size)
|
|
{
|
|
int rc;
|
|
|
|
if (ioc->cached_fw) {
|
|
rc = 0; /* use already allocated memory */
|
|
goto out;
|
|
}
|
|
else if (ioc->alt_ioc && ioc->alt_ioc->cached_fw) {
|
|
ioc->cached_fw = ioc->alt_ioc->cached_fw; /* use alt_ioc's memory */
|
|
ioc->cached_fw_dma = ioc->alt_ioc->cached_fw_dma;
|
|
rc = 0;
|
|
goto out;
|
|
}
|
|
ioc->cached_fw = pci_alloc_consistent(ioc->pcidev, size, &ioc->cached_fw_dma);
|
|
if (!ioc->cached_fw) {
|
|
printk(MYIOC_s_ERR_FMT "Unable to allocate memory for the cached firmware image!\n",
|
|
ioc->name);
|
|
rc = -1;
|
|
} else {
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "FW Image @ %p[%p], sz=%d[%x] bytes\n",
|
|
ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, size, size));
|
|
ioc->alloc_total += size;
|
|
rc = 0;
|
|
}
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* mpt_free_fw_memory - free firmware memory
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
*
|
|
* If alt_img is NULL, delete from ioc structure.
|
|
* Else, delete a secondary image in same format.
|
|
**/
|
|
void
|
|
mpt_free_fw_memory(MPT_ADAPTER *ioc)
|
|
{
|
|
int sz;
|
|
|
|
if (!ioc->cached_fw)
|
|
return;
|
|
|
|
sz = ioc->facts.FWImageSize;
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "free_fw_memory: FW Image @ %p[%p], sz=%d[%x] bytes\n",
|
|
ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
|
|
pci_free_consistent(ioc->pcidev, sz, ioc->cached_fw, ioc->cached_fw_dma);
|
|
ioc->alloc_total -= sz;
|
|
ioc->cached_fw = NULL;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_do_upload - Construct and Send FWUpload request to MPT adapter port.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @sleepFlag: Specifies whether the process can sleep
|
|
*
|
|
* Returns 0 for success, >0 for handshake failure
|
|
* <0 for fw upload failure.
|
|
*
|
|
* Remark: If bound IOC and a successful FWUpload was performed
|
|
* on the bound IOC, the second image is discarded
|
|
* and memory is free'd. Both channels must upload to prevent
|
|
* IOC from running in degraded mode.
|
|
*/
|
|
static int
|
|
mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag)
|
|
{
|
|
u8 reply[sizeof(FWUploadReply_t)];
|
|
FWUpload_t *prequest;
|
|
FWUploadReply_t *preply;
|
|
FWUploadTCSGE_t *ptcsge;
|
|
int sgeoffset;
|
|
u32 flagsLength;
|
|
int ii, sz, reply_sz;
|
|
int cmdStatus;
|
|
|
|
/* If the image size is 0, we are done.
|
|
*/
|
|
if ((sz = ioc->facts.FWImageSize) == 0)
|
|
return 0;
|
|
|
|
if (mpt_alloc_fw_memory(ioc, ioc->facts.FWImageSize) != 0)
|
|
return -ENOMEM;
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": FW Image @ %p[%p], sz=%d[%x] bytes\n",
|
|
ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
|
|
|
|
prequest = (sleepFlag == NO_SLEEP) ? kzalloc(ioc->req_sz, GFP_ATOMIC) :
|
|
kzalloc(ioc->req_sz, GFP_KERNEL);
|
|
if (!prequest) {
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "fw upload failed "
|
|
"while allocating memory \n", ioc->name));
|
|
mpt_free_fw_memory(ioc);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
preply = (FWUploadReply_t *)&reply;
|
|
|
|
reply_sz = sizeof(reply);
|
|
memset(preply, 0, reply_sz);
|
|
|
|
prequest->ImageType = MPI_FW_UPLOAD_ITYPE_FW_IOC_MEM;
|
|
prequest->Function = MPI_FUNCTION_FW_UPLOAD;
|
|
|
|
ptcsge = (FWUploadTCSGE_t *) &prequest->SGL;
|
|
ptcsge->DetailsLength = 12;
|
|
ptcsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
|
|
ptcsge->ImageSize = cpu_to_le32(sz);
|
|
ptcsge++;
|
|
|
|
sgeoffset = sizeof(FWUpload_t) - sizeof(SGE_MPI_UNION) + sizeof(FWUploadTCSGE_t);
|
|
|
|
flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ | sz;
|
|
mpt_add_sge((char *)ptcsge, flagsLength, ioc->cached_fw_dma);
|
|
|
|
sgeoffset += sizeof(u32) + sizeof(dma_addr_t);
|
|
dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": Sending FW Upload (req @ %p) sgeoffset=%d \n",
|
|
ioc->name, prequest, sgeoffset));
|
|
DBG_DUMP_FW_REQUEST_FRAME(ioc, (u32 *)prequest);
|
|
|
|
ii = mpt_handshake_req_reply_wait(ioc, sgeoffset, (u32*)prequest,
|
|
reply_sz, (u16*)preply, 65 /*seconds*/, sleepFlag);
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": FW Upload completed rc=%x \n", ioc->name, ii));
|
|
|
|
cmdStatus = -EFAULT;
|
|
if (ii == 0) {
|
|
/* Handshake transfer was complete and successful.
|
|
* Check the Reply Frame.
|
|
*/
|
|
int status, transfer_sz;
|
|
status = le16_to_cpu(preply->IOCStatus);
|
|
if (status == MPI_IOCSTATUS_SUCCESS) {
|
|
transfer_sz = le32_to_cpu(preply->ActualImageSize);
|
|
if (transfer_sz == sz)
|
|
cmdStatus = 0;
|
|
}
|
|
}
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": do_upload cmdStatus=%d \n",
|
|
ioc->name, cmdStatus));
|
|
|
|
|
|
if (cmdStatus) {
|
|
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": fw upload failed, freeing image \n",
|
|
ioc->name));
|
|
mpt_free_fw_memory(ioc);
|
|
}
|
|
kfree(prequest);
|
|
|
|
return cmdStatus;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_downloadboot - DownloadBoot code
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @pFwHeader: Pointer to firmware header info
|
|
* @sleepFlag: Specifies whether the process can sleep
|
|
*
|
|
* FwDownloadBoot requires Programmed IO access.
|
|
*
|
|
* Returns 0 for success
|
|
* -1 FW Image size is 0
|
|
* -2 No valid cached_fw Pointer
|
|
* <0 for fw upload failure.
|
|
*/
|
|
static int
|
|
mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag)
|
|
{
|
|
MpiExtImageHeader_t *pExtImage;
|
|
u32 fwSize;
|
|
u32 diag0val;
|
|
int count;
|
|
u32 *ptrFw;
|
|
u32 diagRwData;
|
|
u32 nextImage;
|
|
u32 load_addr;
|
|
u32 ioc_state=0;
|
|
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot: fw size 0x%x (%d), FW Ptr %p\n",
|
|
ioc->name, pFwHeader->ImageSize, pFwHeader->ImageSize, pFwHeader));
|
|
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
|
|
|
|
CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM));
|
|
|
|
/* wait 1 msec */
|
|
if (sleepFlag == CAN_SLEEP) {
|
|
msleep(1);
|
|
} else {
|
|
mdelay (1);
|
|
}
|
|
|
|
diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
|
|
CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
|
|
|
|
for (count = 0; count < 30; count ++) {
|
|
diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
|
|
if (!(diag0val & MPI_DIAG_RESET_ADAPTER)) {
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RESET_ADAPTER cleared, count=%d\n",
|
|
ioc->name, count));
|
|
break;
|
|
}
|
|
/* wait .1 sec */
|
|
if (sleepFlag == CAN_SLEEP) {
|
|
msleep (100);
|
|
} else {
|
|
mdelay (100);
|
|
}
|
|
}
|
|
|
|
if ( count == 30 ) {
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot failed! "
|
|
"Unable to get MPI_DIAG_DRWE mode, diag0val=%x\n",
|
|
ioc->name, diag0val));
|
|
return -3;
|
|
}
|
|
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
|
|
|
|
/* Set the DiagRwEn and Disable ARM bits */
|
|
CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_RW_ENABLE | MPI_DIAG_DISABLE_ARM));
|
|
|
|
fwSize = (pFwHeader->ImageSize + 3)/4;
|
|
ptrFw = (u32 *) pFwHeader;
|
|
|
|
/* Write the LoadStartAddress to the DiagRw Address Register
|
|
* using Programmed IO
|
|
*/
|
|
if (ioc->errata_flag_1064)
|
|
pci_enable_io_access(ioc->pcidev);
|
|
|
|
CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->LoadStartAddress);
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "LoadStart addr written 0x%x \n",
|
|
ioc->name, pFwHeader->LoadStartAddress));
|
|
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write FW Image: 0x%x bytes @ %p\n",
|
|
ioc->name, fwSize*4, ptrFw));
|
|
while (fwSize--) {
|
|
CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
|
|
}
|
|
|
|
nextImage = pFwHeader->NextImageHeaderOffset;
|
|
while (nextImage) {
|
|
pExtImage = (MpiExtImageHeader_t *) ((char *)pFwHeader + nextImage);
|
|
|
|
load_addr = pExtImage->LoadStartAddress;
|
|
|
|
fwSize = (pExtImage->ImageSize + 3) >> 2;
|
|
ptrFw = (u32 *)pExtImage;
|
|
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write Ext Image: 0x%x (%d) bytes @ %p load_addr=%x\n",
|
|
ioc->name, fwSize*4, fwSize*4, ptrFw, load_addr));
|
|
CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, load_addr);
|
|
|
|
while (fwSize--) {
|
|
CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
|
|
}
|
|
nextImage = pExtImage->NextImageHeaderOffset;
|
|
}
|
|
|
|
/* Write the IopResetVectorRegAddr */
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Addr=%x! \n", ioc->name, pFwHeader->IopResetRegAddr));
|
|
CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->IopResetRegAddr);
|
|
|
|
/* Write the IopResetVectorValue */
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Value=%x! \n", ioc->name, pFwHeader->IopResetVectorValue));
|
|
CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, pFwHeader->IopResetVectorValue);
|
|
|
|
/* Clear the internal flash bad bit - autoincrementing register,
|
|
* so must do two writes.
|
|
*/
|
|
if (ioc->bus_type == SPI) {
|
|
/*
|
|
* 1030 and 1035 H/W errata, workaround to access
|
|
* the ClearFlashBadSignatureBit
|
|
*/
|
|
CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
|
|
diagRwData = CHIPREG_PIO_READ32(&ioc->pio_chip->DiagRwData);
|
|
diagRwData |= 0x40000000;
|
|
CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
|
|
CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, diagRwData);
|
|
|
|
} else /* if((ioc->bus_type == SAS) || (ioc->bus_type == FC)) */ {
|
|
diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
|
|
CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val |
|
|
MPI_DIAG_CLEAR_FLASH_BAD_SIG);
|
|
|
|
/* wait 1 msec */
|
|
if (sleepFlag == CAN_SLEEP) {
|
|
msleep (1);
|
|
} else {
|
|
mdelay (1);
|
|
}
|
|
}
|
|
|
|
if (ioc->errata_flag_1064)
|
|
pci_disable_io_access(ioc->pcidev);
|
|
|
|
diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot diag0val=%x, "
|
|
"turning off PREVENT_IOC_BOOT, DISABLE_ARM, RW_ENABLE\n",
|
|
ioc->name, diag0val));
|
|
diag0val &= ~(MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM | MPI_DIAG_RW_ENABLE);
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot now diag0val=%x\n",
|
|
ioc->name, diag0val));
|
|
CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
|
|
|
|
/* Write 0xFF to reset the sequencer */
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
|
|
|
|
if (ioc->bus_type == SAS) {
|
|
ioc_state = mpt_GetIocState(ioc, 0);
|
|
if ( (GetIocFacts(ioc, sleepFlag,
|
|
MPT_HOSTEVENT_IOC_BRINGUP)) != 0 ) {
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "GetIocFacts failed: IocState=%x\n",
|
|
ioc->name, ioc_state));
|
|
return -EFAULT;
|
|
}
|
|
}
|
|
|
|
for (count=0; count<HZ*20; count++) {
|
|
if ((ioc_state = mpt_GetIocState(ioc, 0)) & MPI_IOC_STATE_READY) {
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"downloadboot successful! (count=%d) IocState=%x\n",
|
|
ioc->name, count, ioc_state));
|
|
if (ioc->bus_type == SAS) {
|
|
return 0;
|
|
}
|
|
if ((SendIocInit(ioc, sleepFlag)) != 0) {
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"downloadboot: SendIocInit failed\n",
|
|
ioc->name));
|
|
return -EFAULT;
|
|
}
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"downloadboot: SendIocInit successful\n",
|
|
ioc->name));
|
|
return 0;
|
|
}
|
|
if (sleepFlag == CAN_SLEEP) {
|
|
msleep (10);
|
|
} else {
|
|
mdelay (10);
|
|
}
|
|
}
|
|
ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"downloadboot failed! IocState=%x\n",ioc->name, ioc_state));
|
|
return -EFAULT;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* KickStart - Perform hard reset of MPT adapter.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @force: Force hard reset
|
|
* @sleepFlag: Specifies whether the process can sleep
|
|
*
|
|
* This routine places MPT adapter in diagnostic mode via the
|
|
* WriteSequence register, and then performs a hard reset of adapter
|
|
* via the Diagnostic register.
|
|
*
|
|
* Inputs: sleepflag - CAN_SLEEP (non-interrupt thread)
|
|
* or NO_SLEEP (interrupt thread, use mdelay)
|
|
* force - 1 if doorbell active, board fault state
|
|
* board operational, IOC_RECOVERY or
|
|
* IOC_BRINGUP and there is an alt_ioc.
|
|
* 0 else
|
|
*
|
|
* Returns:
|
|
* 1 - hard reset, READY
|
|
* 0 - no reset due to History bit, READY
|
|
* -1 - no reset due to History bit but not READY
|
|
* OR reset but failed to come READY
|
|
* -2 - no reset, could not enter DIAG mode
|
|
* -3 - reset but bad FW bit
|
|
*/
|
|
static int
|
|
KickStart(MPT_ADAPTER *ioc, int force, int sleepFlag)
|
|
{
|
|
int hard_reset_done = 0;
|
|
u32 ioc_state=0;
|
|
int cnt,cntdn;
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "KickStarting!\n", ioc->name));
|
|
if (ioc->bus_type == SPI) {
|
|
/* Always issue a Msg Unit Reset first. This will clear some
|
|
* SCSI bus hang conditions.
|
|
*/
|
|
SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag);
|
|
|
|
if (sleepFlag == CAN_SLEEP) {
|
|
msleep (1000);
|
|
} else {
|
|
mdelay (1000);
|
|
}
|
|
}
|
|
|
|
hard_reset_done = mpt_diag_reset(ioc, force, sleepFlag);
|
|
if (hard_reset_done < 0)
|
|
return hard_reset_done;
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Diagnostic reset successful!\n",
|
|
ioc->name));
|
|
|
|
cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 2; /* 2 seconds */
|
|
for (cnt=0; cnt<cntdn; cnt++) {
|
|
ioc_state = mpt_GetIocState(ioc, 1);
|
|
if ((ioc_state == MPI_IOC_STATE_READY) || (ioc_state == MPI_IOC_STATE_OPERATIONAL)) {
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "KickStart successful! (cnt=%d)\n",
|
|
ioc->name, cnt));
|
|
return hard_reset_done;
|
|
}
|
|
if (sleepFlag == CAN_SLEEP) {
|
|
msleep (10);
|
|
} else {
|
|
mdelay (10);
|
|
}
|
|
}
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_ERR_FMT "Failed to come READY after reset! IocState=%x\n",
|
|
ioc->name, mpt_GetIocState(ioc, 0)));
|
|
return -1;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_diag_reset - Perform hard reset of the adapter.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @ignore: Set if to honor and clear to ignore
|
|
* the reset history bit
|
|
* @sleepFlag: CAN_SLEEP if called in a non-interrupt thread,
|
|
* else set to NO_SLEEP (use mdelay instead)
|
|
*
|
|
* This routine places the adapter in diagnostic mode via the
|
|
* WriteSequence register and then performs a hard reset of adapter
|
|
* via the Diagnostic register. Adapter should be in ready state
|
|
* upon successful completion.
|
|
*
|
|
* Returns: 1 hard reset successful
|
|
* 0 no reset performed because reset history bit set
|
|
* -2 enabling diagnostic mode failed
|
|
* -3 diagnostic reset failed
|
|
*/
|
|
static int
|
|
mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag)
|
|
{
|
|
u32 diag0val;
|
|
u32 doorbell;
|
|
int hard_reset_done = 0;
|
|
int count = 0;
|
|
u32 diag1val = 0;
|
|
MpiFwHeader_t *cached_fw; /* Pointer to FW */
|
|
|
|
/* Clear any existing interrupts */
|
|
CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
|
|
|
|
if (ioc->pcidev->device == MPI_MANUFACTPAGE_DEVID_SAS1078) {
|
|
drsprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: Doorbell=%p; 1078 reset "
|
|
"address=%p\n", ioc->name, __func__,
|
|
&ioc->chip->Doorbell, &ioc->chip->Reset_1078));
|
|
CHIPREG_WRITE32(&ioc->chip->Reset_1078, 0x07);
|
|
if (sleepFlag == CAN_SLEEP)
|
|
msleep(1);
|
|
else
|
|
mdelay(1);
|
|
|
|
for (count = 0; count < 60; count ++) {
|
|
doorbell = CHIPREG_READ32(&ioc->chip->Doorbell);
|
|
doorbell &= MPI_IOC_STATE_MASK;
|
|
|
|
drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"looking for READY STATE: doorbell=%x"
|
|
" count=%d\n",
|
|
ioc->name, doorbell, count));
|
|
if (doorbell == MPI_IOC_STATE_READY) {
|
|
return 1;
|
|
}
|
|
|
|
/* wait 1 sec */
|
|
if (sleepFlag == CAN_SLEEP)
|
|
msleep(1000);
|
|
else
|
|
mdelay(1000);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/* Use "Diagnostic reset" method! (only thing available!) */
|
|
diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
|
|
|
|
if (ioc->debug_level & MPT_DEBUG) {
|
|
if (ioc->alt_ioc)
|
|
diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG1: diag0=%08x, diag1=%08x\n",
|
|
ioc->name, diag0val, diag1val));
|
|
}
|
|
|
|
/* Do the reset if we are told to ignore the reset history
|
|
* or if the reset history is 0
|
|
*/
|
|
if (ignore || !(diag0val & MPI_DIAG_RESET_HISTORY)) {
|
|
while ((diag0val & MPI_DIAG_DRWE) == 0) {
|
|
/* Write magic sequence to WriteSequence register
|
|
* Loop until in diagnostic mode
|
|
*/
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
|
|
|
|
/* wait 100 msec */
|
|
if (sleepFlag == CAN_SLEEP) {
|
|
msleep (100);
|
|
} else {
|
|
mdelay (100);
|
|
}
|
|
|
|
count++;
|
|
if (count > 20) {
|
|
printk(MYIOC_s_ERR_FMT "Enable Diagnostic mode FAILED! (%02xh)\n",
|
|
ioc->name, diag0val);
|
|
return -2;
|
|
|
|
}
|
|
|
|
diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
|
|
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Wrote magic DiagWriteEn sequence (%x)\n",
|
|
ioc->name, diag0val));
|
|
}
|
|
|
|
if (ioc->debug_level & MPT_DEBUG) {
|
|
if (ioc->alt_ioc)
|
|
diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG2: diag0=%08x, diag1=%08x\n",
|
|
ioc->name, diag0val, diag1val));
|
|
}
|
|
/*
|
|
* Disable the ARM (Bug fix)
|
|
*
|
|
*/
|
|
CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_DISABLE_ARM);
|
|
mdelay(1);
|
|
|
|
/*
|
|
* Now hit the reset bit in the Diagnostic register
|
|
* (THE BIG HAMMER!) (Clears DRWE bit).
|
|
*/
|
|
CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
|
|
hard_reset_done = 1;
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Diagnostic reset performed\n",
|
|
ioc->name));
|
|
|
|
/*
|
|
* Call each currently registered protocol IOC reset handler
|
|
* with pre-reset indication.
|
|
* NOTE: If we're doing _IOC_BRINGUP, there can be no
|
|
* MptResetHandlers[] registered yet.
|
|
*/
|
|
{
|
|
u8 cb_idx;
|
|
int r = 0;
|
|
|
|
for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
|
|
if (MptResetHandlers[cb_idx]) {
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"Calling IOC pre_reset handler #%d\n",
|
|
ioc->name, cb_idx));
|
|
r += mpt_signal_reset(cb_idx, ioc, MPT_IOC_PRE_RESET);
|
|
if (ioc->alt_ioc) {
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"Calling alt-%s pre_reset handler #%d\n",
|
|
ioc->name, ioc->alt_ioc->name, cb_idx));
|
|
r += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_PRE_RESET);
|
|
}
|
|
}
|
|
}
|
|
/* FIXME? Examine results here? */
|
|
}
|
|
|
|
if (ioc->cached_fw)
|
|
cached_fw = (MpiFwHeader_t *)ioc->cached_fw;
|
|
else if (ioc->alt_ioc && ioc->alt_ioc->cached_fw)
|
|
cached_fw = (MpiFwHeader_t *)ioc->alt_ioc->cached_fw;
|
|
else
|
|
cached_fw = NULL;
|
|
if (cached_fw) {
|
|
/* If the DownloadBoot operation fails, the
|
|
* IOC will be left unusable. This is a fatal error
|
|
* case. _diag_reset will return < 0
|
|
*/
|
|
for (count = 0; count < 30; count ++) {
|
|
diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
|
|
if (!(diag0val & MPI_DIAG_RESET_ADAPTER)) {
|
|
break;
|
|
}
|
|
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "cached_fw: diag0val=%x count=%d\n",
|
|
ioc->name, diag0val, count));
|
|
/* wait 1 sec */
|
|
if (sleepFlag == CAN_SLEEP) {
|
|
msleep (1000);
|
|
} else {
|
|
mdelay (1000);
|
|
}
|
|
}
|
|
if ((count = mpt_downloadboot(ioc, cached_fw, sleepFlag)) < 0) {
|
|
printk(MYIOC_s_WARN_FMT
|
|
"firmware downloadboot failure (%d)!\n", ioc->name, count);
|
|
}
|
|
|
|
} else {
|
|
/* Wait for FW to reload and for board
|
|
* to go to the READY state.
|
|
* Maximum wait is 60 seconds.
|
|
* If fail, no error will check again
|
|
* with calling program.
|
|
*/
|
|
for (count = 0; count < 60; count ++) {
|
|
doorbell = CHIPREG_READ32(&ioc->chip->Doorbell);
|
|
doorbell &= MPI_IOC_STATE_MASK;
|
|
|
|
if (doorbell == MPI_IOC_STATE_READY) {
|
|
break;
|
|
}
|
|
|
|
/* wait 1 sec */
|
|
if (sleepFlag == CAN_SLEEP) {
|
|
msleep (1000);
|
|
} else {
|
|
mdelay (1000);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
|
|
if (ioc->debug_level & MPT_DEBUG) {
|
|
if (ioc->alt_ioc)
|
|
diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG3: diag0=%08x, diag1=%08x\n",
|
|
ioc->name, diag0val, diag1val));
|
|
}
|
|
|
|
/* Clear RESET_HISTORY bit! Place board in the
|
|
* diagnostic mode to update the diag register.
|
|
*/
|
|
diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
|
|
count = 0;
|
|
while ((diag0val & MPI_DIAG_DRWE) == 0) {
|
|
/* Write magic sequence to WriteSequence register
|
|
* Loop until in diagnostic mode
|
|
*/
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
|
|
|
|
/* wait 100 msec */
|
|
if (sleepFlag == CAN_SLEEP) {
|
|
msleep (100);
|
|
} else {
|
|
mdelay (100);
|
|
}
|
|
|
|
count++;
|
|
if (count > 20) {
|
|
printk(MYIOC_s_ERR_FMT "Enable Diagnostic mode FAILED! (%02xh)\n",
|
|
ioc->name, diag0val);
|
|
break;
|
|
}
|
|
diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
|
|
}
|
|
diag0val &= ~MPI_DIAG_RESET_HISTORY;
|
|
CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
|
|
diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
|
|
if (diag0val & MPI_DIAG_RESET_HISTORY) {
|
|
printk(MYIOC_s_WARN_FMT "ResetHistory bit failed to clear!\n",
|
|
ioc->name);
|
|
}
|
|
|
|
/* Disable Diagnostic Mode
|
|
*/
|
|
CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFFFFFFFF);
|
|
|
|
/* Check FW reload status flags.
|
|
*/
|
|
diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
|
|
if (diag0val & (MPI_DIAG_FLASH_BAD_SIG | MPI_DIAG_RESET_ADAPTER | MPI_DIAG_DISABLE_ARM)) {
|
|
printk(MYIOC_s_ERR_FMT "Diagnostic reset FAILED! (%02xh)\n",
|
|
ioc->name, diag0val);
|
|
return -3;
|
|
}
|
|
|
|
if (ioc->debug_level & MPT_DEBUG) {
|
|
if (ioc->alt_ioc)
|
|
diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG4: diag0=%08x, diag1=%08x\n",
|
|
ioc->name, diag0val, diag1val));
|
|
}
|
|
|
|
/*
|
|
* Reset flag that says we've enabled event notification
|
|
*/
|
|
ioc->facts.EventState = 0;
|
|
|
|
if (ioc->alt_ioc)
|
|
ioc->alt_ioc->facts.EventState = 0;
|
|
|
|
return hard_reset_done;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* SendIocReset - Send IOCReset request to MPT adapter.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @reset_type: reset type, expected values are
|
|
* %MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET or %MPI_FUNCTION_IO_UNIT_RESET
|
|
* @sleepFlag: Specifies whether the process can sleep
|
|
*
|
|
* Send IOCReset request to the MPT adapter.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
static int
|
|
SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag)
|
|
{
|
|
int r;
|
|
u32 state;
|
|
int cntdn, count;
|
|
|
|
drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending IOC reset(0x%02x)!\n",
|
|
ioc->name, reset_type));
|
|
CHIPREG_WRITE32(&ioc->chip->Doorbell, reset_type<<MPI_DOORBELL_FUNCTION_SHIFT);
|
|
if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
|
|
return r;
|
|
|
|
/* FW ACK'd request, wait for READY state
|
|
*/
|
|
count = 0;
|
|
cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 15; /* 15 seconds */
|
|
|
|
while ((state = mpt_GetIocState(ioc, 1)) != MPI_IOC_STATE_READY) {
|
|
cntdn--;
|
|
count++;
|
|
if (!cntdn) {
|
|
if (sleepFlag != CAN_SLEEP)
|
|
count *= 10;
|
|
|
|
printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
|
|
ioc->name, (int)((count+5)/HZ));
|
|
return -ETIME;
|
|
}
|
|
|
|
if (sleepFlag == CAN_SLEEP) {
|
|
msleep(1);
|
|
} else {
|
|
mdelay (1); /* 1 msec delay */
|
|
}
|
|
}
|
|
|
|
/* TODO!
|
|
* Cleanup all event stuff for this IOC; re-issue EventNotification
|
|
* request if needed.
|
|
*/
|
|
if (ioc->facts.Function)
|
|
ioc->facts.EventState = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* initChainBuffers - Allocate memory for and initialize chain buffers
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
*
|
|
* Allocates memory for and initializes chain buffers,
|
|
* chain buffer control arrays and spinlock.
|
|
*/
|
|
static int
|
|
initChainBuffers(MPT_ADAPTER *ioc)
|
|
{
|
|
u8 *mem;
|
|
int sz, ii, num_chain;
|
|
int scale, num_sge, numSGE;
|
|
|
|
/* ReqToChain size must equal the req_depth
|
|
* index = req_idx
|
|
*/
|
|
if (ioc->ReqToChain == NULL) {
|
|
sz = ioc->req_depth * sizeof(int);
|
|
mem = kmalloc(sz, GFP_ATOMIC);
|
|
if (mem == NULL)
|
|
return -1;
|
|
|
|
ioc->ReqToChain = (int *) mem;
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReqToChain alloc @ %p, sz=%d bytes\n",
|
|
ioc->name, mem, sz));
|
|
mem = kmalloc(sz, GFP_ATOMIC);
|
|
if (mem == NULL)
|
|
return -1;
|
|
|
|
ioc->RequestNB = (int *) mem;
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestNB alloc @ %p, sz=%d bytes\n",
|
|
ioc->name, mem, sz));
|
|
}
|
|
for (ii = 0; ii < ioc->req_depth; ii++) {
|
|
ioc->ReqToChain[ii] = MPT_HOST_NO_CHAIN;
|
|
}
|
|
|
|
/* ChainToChain size must equal the total number
|
|
* of chain buffers to be allocated.
|
|
* index = chain_idx
|
|
*
|
|
* Calculate the number of chain buffers needed(plus 1) per I/O
|
|
* then multiply the maximum number of simultaneous cmds
|
|
*
|
|
* num_sge = num sge in request frame + last chain buffer
|
|
* scale = num sge per chain buffer if no chain element
|
|
*/
|
|
scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
|
|
if (sizeof(dma_addr_t) == sizeof(u64))
|
|
num_sge = scale + (ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
|
|
else
|
|
num_sge = 1+ scale + (ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
|
|
|
|
if (sizeof(dma_addr_t) == sizeof(u64)) {
|
|
numSGE = (scale - 1) * (ioc->facts.MaxChainDepth-1) + scale +
|
|
(ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
|
|
} else {
|
|
numSGE = 1 + (scale - 1) * (ioc->facts.MaxChainDepth-1) + scale +
|
|
(ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
|
|
}
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "num_sge=%d numSGE=%d\n",
|
|
ioc->name, num_sge, numSGE));
|
|
|
|
if ( numSGE > MPT_SCSI_SG_DEPTH )
|
|
numSGE = MPT_SCSI_SG_DEPTH;
|
|
|
|
num_chain = 1;
|
|
while (numSGE - num_sge > 0) {
|
|
num_chain++;
|
|
num_sge += (scale - 1);
|
|
}
|
|
num_chain++;
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Now numSGE=%d num_sge=%d num_chain=%d\n",
|
|
ioc->name, numSGE, num_sge, num_chain));
|
|
|
|
if (ioc->bus_type == SPI)
|
|
num_chain *= MPT_SCSI_CAN_QUEUE;
|
|
else
|
|
num_chain *= MPT_FC_CAN_QUEUE;
|
|
|
|
ioc->num_chain = num_chain;
|
|
|
|
sz = num_chain * sizeof(int);
|
|
if (ioc->ChainToChain == NULL) {
|
|
mem = kmalloc(sz, GFP_ATOMIC);
|
|
if (mem == NULL)
|
|
return -1;
|
|
|
|
ioc->ChainToChain = (int *) mem;
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainToChain alloc @ %p, sz=%d bytes\n",
|
|
ioc->name, mem, sz));
|
|
} else {
|
|
mem = (u8 *) ioc->ChainToChain;
|
|
}
|
|
memset(mem, 0xFF, sz);
|
|
return num_chain;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* PrimeIocFifos - Initialize IOC request and reply FIFOs.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
*
|
|
* This routine allocates memory for the MPT reply and request frame
|
|
* pools (if necessary), and primes the IOC reply FIFO with
|
|
* reply frames.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
static int
|
|
PrimeIocFifos(MPT_ADAPTER *ioc)
|
|
{
|
|
MPT_FRAME_HDR *mf;
|
|
unsigned long flags;
|
|
dma_addr_t alloc_dma;
|
|
u8 *mem;
|
|
int i, reply_sz, sz, total_size, num_chain;
|
|
|
|
/* Prime reply FIFO... */
|
|
|
|
if (ioc->reply_frames == NULL) {
|
|
if ( (num_chain = initChainBuffers(ioc)) < 0)
|
|
return -1;
|
|
|
|
total_size = reply_sz = (ioc->reply_sz * ioc->reply_depth);
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffer sz=%d bytes, ReplyDepth=%d\n",
|
|
ioc->name, ioc->reply_sz, ioc->reply_depth));
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffer sz=%d[%x] bytes\n",
|
|
ioc->name, reply_sz, reply_sz));
|
|
|
|
sz = (ioc->req_sz * ioc->req_depth);
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestBuffer sz=%d bytes, RequestDepth=%d\n",
|
|
ioc->name, ioc->req_sz, ioc->req_depth));
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestBuffer sz=%d[%x] bytes\n",
|
|
ioc->name, sz, sz));
|
|
total_size += sz;
|
|
|
|
sz = num_chain * ioc->req_sz; /* chain buffer pool size */
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainBuffer sz=%d bytes, ChainDepth=%d\n",
|
|
ioc->name, ioc->req_sz, num_chain));
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainBuffer sz=%d[%x] bytes num_chain=%d\n",
|
|
ioc->name, sz, sz, num_chain));
|
|
|
|
total_size += sz;
|
|
mem = pci_alloc_consistent(ioc->pcidev, total_size, &alloc_dma);
|
|
if (mem == NULL) {
|
|
printk(MYIOC_s_ERR_FMT "Unable to allocate Reply, Request, Chain Buffers!\n",
|
|
ioc->name);
|
|
goto out_fail;
|
|
}
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Total alloc @ %p[%p], sz=%d[%x] bytes\n",
|
|
ioc->name, mem, (void *)(ulong)alloc_dma, total_size, total_size));
|
|
|
|
memset(mem, 0, total_size);
|
|
ioc->alloc_total += total_size;
|
|
ioc->alloc = mem;
|
|
ioc->alloc_dma = alloc_dma;
|
|
ioc->alloc_sz = total_size;
|
|
ioc->reply_frames = (MPT_FRAME_HDR *) mem;
|
|
ioc->reply_frames_low_dma = (u32) (alloc_dma & 0xFFFFFFFF);
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffers @ %p[%p]\n",
|
|
ioc->name, ioc->reply_frames, (void *)(ulong)alloc_dma));
|
|
|
|
alloc_dma += reply_sz;
|
|
mem += reply_sz;
|
|
|
|
/* Request FIFO - WE manage this! */
|
|
|
|
ioc->req_frames = (MPT_FRAME_HDR *) mem;
|
|
ioc->req_frames_dma = alloc_dma;
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestBuffers @ %p[%p]\n",
|
|
ioc->name, mem, (void *)(ulong)alloc_dma));
|
|
|
|
ioc->req_frames_low_dma = (u32) (alloc_dma & 0xFFFFFFFF);
|
|
|
|
#if defined(CONFIG_MTRR) && 0
|
|
/*
|
|
* Enable Write Combining MTRR for IOC's memory region.
|
|
* (at least as much as we can; "size and base must be
|
|
* multiples of 4 kiB"
|
|
*/
|
|
ioc->mtrr_reg = mtrr_add(ioc->req_frames_dma,
|
|
sz,
|
|
MTRR_TYPE_WRCOMB, 1);
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MTRR region registered (base:size=%08x:%x)\n",
|
|
ioc->name, ioc->req_frames_dma, sz));
|
|
#endif
|
|
|
|
for (i = 0; i < ioc->req_depth; i++) {
|
|
alloc_dma += ioc->req_sz;
|
|
mem += ioc->req_sz;
|
|
}
|
|
|
|
ioc->ChainBuffer = mem;
|
|
ioc->ChainBufferDMA = alloc_dma;
|
|
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainBuffers @ %p(%p)\n",
|
|
ioc->name, ioc->ChainBuffer, (void *)(ulong)ioc->ChainBufferDMA));
|
|
|
|
/* Initialize the free chain Q.
|
|
*/
|
|
|
|
INIT_LIST_HEAD(&ioc->FreeChainQ);
|
|
|
|
/* Post the chain buffers to the FreeChainQ.
|
|
*/
|
|
mem = (u8 *)ioc->ChainBuffer;
|
|
for (i=0; i < num_chain; i++) {
|
|
mf = (MPT_FRAME_HDR *) mem;
|
|
list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeChainQ);
|
|
mem += ioc->req_sz;
|
|
}
|
|
|
|
/* Initialize Request frames linked list
|
|
*/
|
|
alloc_dma = ioc->req_frames_dma;
|
|
mem = (u8 *) ioc->req_frames;
|
|
|
|
spin_lock_irqsave(&ioc->FreeQlock, flags);
|
|
INIT_LIST_HEAD(&ioc->FreeQ);
|
|
for (i = 0; i < ioc->req_depth; i++) {
|
|
mf = (MPT_FRAME_HDR *) mem;
|
|
|
|
/* Queue REQUESTs *internally*! */
|
|
list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeQ);
|
|
|
|
mem += ioc->req_sz;
|
|
}
|
|
spin_unlock_irqrestore(&ioc->FreeQlock, flags);
|
|
|
|
sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
|
|
ioc->sense_buf_pool =
|
|
pci_alloc_consistent(ioc->pcidev, sz, &ioc->sense_buf_pool_dma);
|
|
if (ioc->sense_buf_pool == NULL) {
|
|
printk(MYIOC_s_ERR_FMT "Unable to allocate Sense Buffers!\n",
|
|
ioc->name);
|
|
goto out_fail;
|
|
}
|
|
|
|
ioc->sense_buf_low_dma = (u32) (ioc->sense_buf_pool_dma & 0xFFFFFFFF);
|
|
ioc->alloc_total += sz;
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SenseBuffers @ %p[%p]\n",
|
|
ioc->name, ioc->sense_buf_pool, (void *)(ulong)ioc->sense_buf_pool_dma));
|
|
|
|
}
|
|
|
|
/* Post Reply frames to FIFO
|
|
*/
|
|
alloc_dma = ioc->alloc_dma;
|
|
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffers @ %p[%p]\n",
|
|
ioc->name, ioc->reply_frames, (void *)(ulong)alloc_dma));
|
|
|
|
for (i = 0; i < ioc->reply_depth; i++) {
|
|
/* Write each address to the IOC! */
|
|
CHIPREG_WRITE32(&ioc->chip->ReplyFifo, alloc_dma);
|
|
alloc_dma += ioc->reply_sz;
|
|
}
|
|
|
|
return 0;
|
|
|
|
out_fail:
|
|
if (ioc->alloc != NULL) {
|
|
sz = ioc->alloc_sz;
|
|
pci_free_consistent(ioc->pcidev,
|
|
sz,
|
|
ioc->alloc, ioc->alloc_dma);
|
|
ioc->reply_frames = NULL;
|
|
ioc->req_frames = NULL;
|
|
ioc->alloc_total -= sz;
|
|
}
|
|
if (ioc->sense_buf_pool != NULL) {
|
|
sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
|
|
pci_free_consistent(ioc->pcidev,
|
|
sz,
|
|
ioc->sense_buf_pool, ioc->sense_buf_pool_dma);
|
|
ioc->sense_buf_pool = NULL;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_handshake_req_reply_wait - Send MPT request to and receive reply
|
|
* from IOC via doorbell handshake method.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @reqBytes: Size of the request in bytes
|
|
* @req: Pointer to MPT request frame
|
|
* @replyBytes: Expected size of the reply in bytes
|
|
* @u16reply: Pointer to area where reply should be written
|
|
* @maxwait: Max wait time for a reply (in seconds)
|
|
* @sleepFlag: Specifies whether the process can sleep
|
|
*
|
|
* NOTES: It is the callers responsibility to byte-swap fields in the
|
|
* request which are greater than 1 byte in size. It is also the
|
|
* callers responsibility to byte-swap response fields which are
|
|
* greater than 1 byte in size.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
static int
|
|
mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes, u32 *req,
|
|
int replyBytes, u16 *u16reply, int maxwait, int sleepFlag)
|
|
{
|
|
MPIDefaultReply_t *mptReply;
|
|
int failcnt = 0;
|
|
int t;
|
|
|
|
/*
|
|
* Get ready to cache a handshake reply
|
|
*/
|
|
ioc->hs_reply_idx = 0;
|
|
mptReply = (MPIDefaultReply_t *) ioc->hs_reply;
|
|
mptReply->MsgLength = 0;
|
|
|
|
/*
|
|
* Make sure there are no doorbells (WRITE 0 to IntStatus reg),
|
|
* then tell IOC that we want to handshake a request of N words.
|
|
* (WRITE u32val to Doorbell reg).
|
|
*/
|
|
CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
|
|
CHIPREG_WRITE32(&ioc->chip->Doorbell,
|
|
((MPI_FUNCTION_HANDSHAKE<<MPI_DOORBELL_FUNCTION_SHIFT) |
|
|
((reqBytes/4)<<MPI_DOORBELL_ADD_DWORDS_SHIFT)));
|
|
|
|
/*
|
|
* Wait for IOC's doorbell handshake int
|
|
*/
|
|
if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
|
|
failcnt++;
|
|
|
|
dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HandShake request start reqBytes=%d, WaitCnt=%d%s\n",
|
|
ioc->name, reqBytes, t, failcnt ? " - MISSING DOORBELL HANDSHAKE!" : ""));
|
|
|
|
/* Read doorbell and check for active bit */
|
|
if (!(CHIPREG_READ32(&ioc->chip->Doorbell) & MPI_DOORBELL_ACTIVE))
|
|
return -1;
|
|
|
|
/*
|
|
* Clear doorbell int (WRITE 0 to IntStatus reg),
|
|
* then wait for IOC to ACKnowledge that it's ready for
|
|
* our handshake request.
|
|
*/
|
|
CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
|
|
if (!failcnt && (t = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
|
|
failcnt++;
|
|
|
|
if (!failcnt) {
|
|
int ii;
|
|
u8 *req_as_bytes = (u8 *) req;
|
|
|
|
/*
|
|
* Stuff request words via doorbell handshake,
|
|
* with ACK from IOC for each.
|
|
*/
|
|
for (ii = 0; !failcnt && ii < reqBytes/4; ii++) {
|
|
u32 word = ((req_as_bytes[(ii*4) + 0] << 0) |
|
|
(req_as_bytes[(ii*4) + 1] << 8) |
|
|
(req_as_bytes[(ii*4) + 2] << 16) |
|
|
(req_as_bytes[(ii*4) + 3] << 24));
|
|
|
|
CHIPREG_WRITE32(&ioc->chip->Doorbell, word);
|
|
if ((t = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
|
|
failcnt++;
|
|
}
|
|
|
|
dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handshake request frame (@%p) header\n", ioc->name, req));
|
|
DBG_DUMP_REQUEST_FRAME_HDR(ioc, (u32 *)req);
|
|
|
|
dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HandShake request post done, WaitCnt=%d%s\n",
|
|
ioc->name, t, failcnt ? " - MISSING DOORBELL ACK!" : ""));
|
|
|
|
/*
|
|
* Wait for completion of doorbell handshake reply from the IOC
|
|
*/
|
|
if (!failcnt && (t = WaitForDoorbellReply(ioc, maxwait, sleepFlag)) < 0)
|
|
failcnt++;
|
|
|
|
dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HandShake reply count=%d%s\n",
|
|
ioc->name, t, failcnt ? " - MISSING DOORBELL REPLY!" : ""));
|
|
|
|
/*
|
|
* Copy out the cached reply...
|
|
*/
|
|
for (ii=0; ii < min(replyBytes/2,mptReply->MsgLength*2); ii++)
|
|
u16reply[ii] = ioc->hs_reply[ii];
|
|
} else {
|
|
return -99;
|
|
}
|
|
|
|
return -failcnt;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* WaitForDoorbellAck - Wait for IOC doorbell handshake acknowledge
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @howlong: How long to wait (in seconds)
|
|
* @sleepFlag: Specifies whether the process can sleep
|
|
*
|
|
* This routine waits (up to ~2 seconds max) for IOC doorbell
|
|
* handshake ACKnowledge, indicated by the IOP_DOORBELL_STATUS
|
|
* bit in its IntStatus register being clear.
|
|
*
|
|
* Returns a negative value on failure, else wait loop count.
|
|
*/
|
|
static int
|
|
WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
|
|
{
|
|
int cntdn;
|
|
int count = 0;
|
|
u32 intstat=0;
|
|
|
|
cntdn = 1000 * howlong;
|
|
|
|
if (sleepFlag == CAN_SLEEP) {
|
|
while (--cntdn) {
|
|
msleep (1);
|
|
intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
|
|
if (! (intstat & MPI_HIS_IOP_DOORBELL_STATUS))
|
|
break;
|
|
count++;
|
|
}
|
|
} else {
|
|
while (--cntdn) {
|
|
udelay (1000);
|
|
intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
|
|
if (! (intstat & MPI_HIS_IOP_DOORBELL_STATUS))
|
|
break;
|
|
count++;
|
|
}
|
|
}
|
|
|
|
if (cntdn) {
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitForDoorbell ACK (count=%d)\n",
|
|
ioc->name, count));
|
|
return count;
|
|
}
|
|
|
|
printk(MYIOC_s_ERR_FMT "Doorbell ACK timeout (count=%d), IntStatus=%x!\n",
|
|
ioc->name, count, intstat);
|
|
return -1;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* WaitForDoorbellInt - Wait for IOC to set its doorbell interrupt bit
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @howlong: How long to wait (in seconds)
|
|
* @sleepFlag: Specifies whether the process can sleep
|
|
*
|
|
* This routine waits (up to ~2 seconds max) for IOC doorbell interrupt
|
|
* (MPI_HIS_DOORBELL_INTERRUPT) to be set in the IntStatus register.
|
|
*
|
|
* Returns a negative value on failure, else wait loop count.
|
|
*/
|
|
static int
|
|
WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
|
|
{
|
|
int cntdn;
|
|
int count = 0;
|
|
u32 intstat=0;
|
|
|
|
cntdn = 1000 * howlong;
|
|
if (sleepFlag == CAN_SLEEP) {
|
|
while (--cntdn) {
|
|
intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
|
|
if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
|
|
break;
|
|
msleep(1);
|
|
count++;
|
|
}
|
|
} else {
|
|
while (--cntdn) {
|
|
intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
|
|
if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
|
|
break;
|
|
udelay (1000);
|
|
count++;
|
|
}
|
|
}
|
|
|
|
if (cntdn) {
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitForDoorbell INT (cnt=%d) howlong=%d\n",
|
|
ioc->name, count, howlong));
|
|
return count;
|
|
}
|
|
|
|
printk(MYIOC_s_ERR_FMT "Doorbell INT timeout (count=%d), IntStatus=%x!\n",
|
|
ioc->name, count, intstat);
|
|
return -1;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* WaitForDoorbellReply - Wait for and capture an IOC handshake reply.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @howlong: How long to wait (in seconds)
|
|
* @sleepFlag: Specifies whether the process can sleep
|
|
*
|
|
* This routine polls the IOC for a handshake reply, 16 bits at a time.
|
|
* Reply is cached to IOC private area large enough to hold a maximum
|
|
* of 128 bytes of reply data.
|
|
*
|
|
* Returns a negative value on failure, else size of reply in WORDS.
|
|
*/
|
|
static int
|
|
WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
|
|
{
|
|
int u16cnt = 0;
|
|
int failcnt = 0;
|
|
int t;
|
|
u16 *hs_reply = ioc->hs_reply;
|
|
volatile MPIDefaultReply_t *mptReply = (MPIDefaultReply_t *) ioc->hs_reply;
|
|
u16 hword;
|
|
|
|
hs_reply[0] = hs_reply[1] = hs_reply[7] = 0;
|
|
|
|
/*
|
|
* Get first two u16's so we can look at IOC's intended reply MsgLength
|
|
*/
|
|
u16cnt=0;
|
|
if ((t = WaitForDoorbellInt(ioc, howlong, sleepFlag)) < 0) {
|
|
failcnt++;
|
|
} else {
|
|
hs_reply[u16cnt++] = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
|
|
CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
|
|
if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
|
|
failcnt++;
|
|
else {
|
|
hs_reply[u16cnt++] = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
|
|
CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
|
|
}
|
|
}
|
|
|
|
dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitCnt=%d First handshake reply word=%08x%s\n",
|
|
ioc->name, t, le32_to_cpu(*(u32 *)hs_reply),
|
|
failcnt ? " - MISSING DOORBELL HANDSHAKE!" : ""));
|
|
|
|
/*
|
|
* If no error (and IOC said MsgLength is > 0), piece together
|
|
* reply 16 bits at a time.
|
|
*/
|
|
for (u16cnt=2; !failcnt && u16cnt < (2 * mptReply->MsgLength); u16cnt++) {
|
|
if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
|
|
failcnt++;
|
|
hword = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
|
|
/* don't overflow our IOC hs_reply[] buffer! */
|
|
if (u16cnt < ARRAY_SIZE(ioc->hs_reply))
|
|
hs_reply[u16cnt] = hword;
|
|
CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
|
|
}
|
|
|
|
if (!failcnt && (t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
|
|
failcnt++;
|
|
CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
|
|
|
|
if (failcnt) {
|
|
printk(MYIOC_s_ERR_FMT "Handshake reply failure!\n",
|
|
ioc->name);
|
|
return -failcnt;
|
|
}
|
|
#if 0
|
|
else if (u16cnt != (2 * mptReply->MsgLength)) {
|
|
return -101;
|
|
}
|
|
else if ((mptReply->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
|
|
return -102;
|
|
}
|
|
#endif
|
|
|
|
dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Got Handshake reply:\n", ioc->name));
|
|
DBG_DUMP_REPLY_FRAME(ioc, (u32 *)mptReply);
|
|
|
|
dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitForDoorbell REPLY WaitCnt=%d (sz=%d)\n",
|
|
ioc->name, t, u16cnt/2));
|
|
return u16cnt/2;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* GetLanConfigPages - Fetch LANConfig pages.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
*
|
|
* Return: 0 for success
|
|
* -ENOMEM if no memory available
|
|
* -EPERM if not allowed due to ISR context
|
|
* -EAGAIN if no msg frames currently available
|
|
* -EFAULT for non-successful reply or no reply (timeout)
|
|
*/
|
|
static int
|
|
GetLanConfigPages(MPT_ADAPTER *ioc)
|
|
{
|
|
ConfigPageHeader_t hdr;
|
|
CONFIGPARMS cfg;
|
|
LANPage0_t *ppage0_alloc;
|
|
dma_addr_t page0_dma;
|
|
LANPage1_t *ppage1_alloc;
|
|
dma_addr_t page1_dma;
|
|
int rc = 0;
|
|
int data_sz;
|
|
int copy_sz;
|
|
|
|
/* Get LAN Page 0 header */
|
|
hdr.PageVersion = 0;
|
|
hdr.PageLength = 0;
|
|
hdr.PageNumber = 0;
|
|
hdr.PageType = MPI_CONFIG_PAGETYPE_LAN;
|
|
cfg.cfghdr.hdr = &hdr;
|
|
cfg.physAddr = -1;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
|
|
cfg.dir = 0;
|
|
cfg.pageAddr = 0;
|
|
cfg.timeout = 0;
|
|
|
|
if ((rc = mpt_config(ioc, &cfg)) != 0)
|
|
return rc;
|
|
|
|
if (hdr.PageLength > 0) {
|
|
data_sz = hdr.PageLength * 4;
|
|
ppage0_alloc = (LANPage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page0_dma);
|
|
rc = -ENOMEM;
|
|
if (ppage0_alloc) {
|
|
memset((u8 *)ppage0_alloc, 0, data_sz);
|
|
cfg.physAddr = page0_dma;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
|
|
if ((rc = mpt_config(ioc, &cfg)) == 0) {
|
|
/* save the data */
|
|
copy_sz = min_t(int, sizeof(LANPage0_t), data_sz);
|
|
memcpy(&ioc->lan_cnfg_page0, ppage0_alloc, copy_sz);
|
|
|
|
}
|
|
|
|
pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage0_alloc, page0_dma);
|
|
|
|
/* FIXME!
|
|
* Normalize endianness of structure data,
|
|
* by byte-swapping all > 1 byte fields!
|
|
*/
|
|
|
|
}
|
|
|
|
if (rc)
|
|
return rc;
|
|
}
|
|
|
|
/* Get LAN Page 1 header */
|
|
hdr.PageVersion = 0;
|
|
hdr.PageLength = 0;
|
|
hdr.PageNumber = 1;
|
|
hdr.PageType = MPI_CONFIG_PAGETYPE_LAN;
|
|
cfg.cfghdr.hdr = &hdr;
|
|
cfg.physAddr = -1;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
|
|
cfg.dir = 0;
|
|
cfg.pageAddr = 0;
|
|
|
|
if ((rc = mpt_config(ioc, &cfg)) != 0)
|
|
return rc;
|
|
|
|
if (hdr.PageLength == 0)
|
|
return 0;
|
|
|
|
data_sz = hdr.PageLength * 4;
|
|
rc = -ENOMEM;
|
|
ppage1_alloc = (LANPage1_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page1_dma);
|
|
if (ppage1_alloc) {
|
|
memset((u8 *)ppage1_alloc, 0, data_sz);
|
|
cfg.physAddr = page1_dma;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
|
|
if ((rc = mpt_config(ioc, &cfg)) == 0) {
|
|
/* save the data */
|
|
copy_sz = min_t(int, sizeof(LANPage1_t), data_sz);
|
|
memcpy(&ioc->lan_cnfg_page1, ppage1_alloc, copy_sz);
|
|
}
|
|
|
|
pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage1_alloc, page1_dma);
|
|
|
|
/* FIXME!
|
|
* Normalize endianness of structure data,
|
|
* by byte-swapping all > 1 byte fields!
|
|
*/
|
|
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mptbase_sas_persist_operation - Perform operation on SAS Persistent Table
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @persist_opcode: see below
|
|
*
|
|
* MPI_SAS_OP_CLEAR_NOT_PRESENT - Free all persist TargetID mappings for
|
|
* devices not currently present.
|
|
* MPI_SAS_OP_CLEAR_ALL_PERSISTENT - Clear al persist TargetID mappings
|
|
*
|
|
* NOTE: Don't use not this function during interrupt time.
|
|
*
|
|
* Returns 0 for success, non-zero error
|
|
*/
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
int
|
|
mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode)
|
|
{
|
|
SasIoUnitControlRequest_t *sasIoUnitCntrReq;
|
|
SasIoUnitControlReply_t *sasIoUnitCntrReply;
|
|
MPT_FRAME_HDR *mf = NULL;
|
|
MPIHeader_t *mpi_hdr;
|
|
|
|
|
|
/* insure garbage is not sent to fw */
|
|
switch(persist_opcode) {
|
|
|
|
case MPI_SAS_OP_CLEAR_NOT_PRESENT:
|
|
case MPI_SAS_OP_CLEAR_ALL_PERSISTENT:
|
|
break;
|
|
|
|
default:
|
|
return -1;
|
|
break;
|
|
}
|
|
|
|
printk("%s: persist_opcode=%x\n",__func__, persist_opcode);
|
|
|
|
/* Get a MF for this command.
|
|
*/
|
|
if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
|
|
printk("%s: no msg frames!\n",__func__);
|
|
return -1;
|
|
}
|
|
|
|
mpi_hdr = (MPIHeader_t *) mf;
|
|
sasIoUnitCntrReq = (SasIoUnitControlRequest_t *)mf;
|
|
memset(sasIoUnitCntrReq,0,sizeof(SasIoUnitControlRequest_t));
|
|
sasIoUnitCntrReq->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
|
|
sasIoUnitCntrReq->MsgContext = mpi_hdr->MsgContext;
|
|
sasIoUnitCntrReq->Operation = persist_opcode;
|
|
|
|
init_timer(&ioc->persist_timer);
|
|
ioc->persist_timer.data = (unsigned long) ioc;
|
|
ioc->persist_timer.function = mpt_timer_expired;
|
|
ioc->persist_timer.expires = jiffies + HZ*10 /* 10 sec */;
|
|
ioc->persist_wait_done=0;
|
|
add_timer(&ioc->persist_timer);
|
|
mpt_put_msg_frame(mpt_base_index, ioc, mf);
|
|
wait_event(mpt_waitq, ioc->persist_wait_done);
|
|
|
|
sasIoUnitCntrReply =
|
|
(SasIoUnitControlReply_t *)ioc->persist_reply_frame;
|
|
if (le16_to_cpu(sasIoUnitCntrReply->IOCStatus) != MPI_IOCSTATUS_SUCCESS) {
|
|
printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
|
|
__func__,
|
|
sasIoUnitCntrReply->IOCStatus,
|
|
sasIoUnitCntrReply->IOCLogInfo);
|
|
return -1;
|
|
}
|
|
|
|
printk("%s: success\n",__func__);
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
|
|
static void
|
|
mptbase_raid_process_event_data(MPT_ADAPTER *ioc,
|
|
MpiEventDataRaid_t * pRaidEventData)
|
|
{
|
|
int volume;
|
|
int reason;
|
|
int disk;
|
|
int status;
|
|
int flags;
|
|
int state;
|
|
|
|
volume = pRaidEventData->VolumeID;
|
|
reason = pRaidEventData->ReasonCode;
|
|
disk = pRaidEventData->PhysDiskNum;
|
|
status = le32_to_cpu(pRaidEventData->SettingsStatus);
|
|
flags = (status >> 0) & 0xff;
|
|
state = (status >> 8) & 0xff;
|
|
|
|
if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
|
|
return;
|
|
}
|
|
|
|
if ((reason >= MPI_EVENT_RAID_RC_PHYSDISK_CREATED &&
|
|
reason <= MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED) ||
|
|
(reason == MPI_EVENT_RAID_RC_SMART_DATA)) {
|
|
printk(MYIOC_s_INFO_FMT "RAID STATUS CHANGE for PhysDisk %d id=%d\n",
|
|
ioc->name, disk, volume);
|
|
} else {
|
|
printk(MYIOC_s_INFO_FMT "RAID STATUS CHANGE for VolumeID %d\n",
|
|
ioc->name, volume);
|
|
}
|
|
|
|
switch(reason) {
|
|
case MPI_EVENT_RAID_RC_VOLUME_CREATED:
|
|
printk(MYIOC_s_INFO_FMT " volume has been created\n",
|
|
ioc->name);
|
|
break;
|
|
|
|
case MPI_EVENT_RAID_RC_VOLUME_DELETED:
|
|
|
|
printk(MYIOC_s_INFO_FMT " volume has been deleted\n",
|
|
ioc->name);
|
|
break;
|
|
|
|
case MPI_EVENT_RAID_RC_VOLUME_SETTINGS_CHANGED:
|
|
printk(MYIOC_s_INFO_FMT " volume settings have been changed\n",
|
|
ioc->name);
|
|
break;
|
|
|
|
case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
|
|
printk(MYIOC_s_INFO_FMT " volume is now %s%s%s%s\n",
|
|
ioc->name,
|
|
state == MPI_RAIDVOL0_STATUS_STATE_OPTIMAL
|
|
? "optimal"
|
|
: state == MPI_RAIDVOL0_STATUS_STATE_DEGRADED
|
|
? "degraded"
|
|
: state == MPI_RAIDVOL0_STATUS_STATE_FAILED
|
|
? "failed"
|
|
: "state unknown",
|
|
flags & MPI_RAIDVOL0_STATUS_FLAG_ENABLED
|
|
? ", enabled" : "",
|
|
flags & MPI_RAIDVOL0_STATUS_FLAG_QUIESCED
|
|
? ", quiesced" : "",
|
|
flags & MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS
|
|
? ", resync in progress" : "" );
|
|
break;
|
|
|
|
case MPI_EVENT_RAID_RC_VOLUME_PHYSDISK_CHANGED:
|
|
printk(MYIOC_s_INFO_FMT " volume membership of PhysDisk %d has changed\n",
|
|
ioc->name, disk);
|
|
break;
|
|
|
|
case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
|
|
printk(MYIOC_s_INFO_FMT " PhysDisk has been created\n",
|
|
ioc->name);
|
|
break;
|
|
|
|
case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
|
|
printk(MYIOC_s_INFO_FMT " PhysDisk has been deleted\n",
|
|
ioc->name);
|
|
break;
|
|
|
|
case MPI_EVENT_RAID_RC_PHYSDISK_SETTINGS_CHANGED:
|
|
printk(MYIOC_s_INFO_FMT " PhysDisk settings have been changed\n",
|
|
ioc->name);
|
|
break;
|
|
|
|
case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
|
|
printk(MYIOC_s_INFO_FMT " PhysDisk is now %s%s%s\n",
|
|
ioc->name,
|
|
state == MPI_PHYSDISK0_STATUS_ONLINE
|
|
? "online"
|
|
: state == MPI_PHYSDISK0_STATUS_MISSING
|
|
? "missing"
|
|
: state == MPI_PHYSDISK0_STATUS_NOT_COMPATIBLE
|
|
? "not compatible"
|
|
: state == MPI_PHYSDISK0_STATUS_FAILED
|
|
? "failed"
|
|
: state == MPI_PHYSDISK0_STATUS_INITIALIZING
|
|
? "initializing"
|
|
: state == MPI_PHYSDISK0_STATUS_OFFLINE_REQUESTED
|
|
? "offline requested"
|
|
: state == MPI_PHYSDISK0_STATUS_FAILED_REQUESTED
|
|
? "failed requested"
|
|
: state == MPI_PHYSDISK0_STATUS_OTHER_OFFLINE
|
|
? "offline"
|
|
: "state unknown",
|
|
flags & MPI_PHYSDISK0_STATUS_FLAG_OUT_OF_SYNC
|
|
? ", out of sync" : "",
|
|
flags & MPI_PHYSDISK0_STATUS_FLAG_QUIESCED
|
|
? ", quiesced" : "" );
|
|
break;
|
|
|
|
case MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED:
|
|
printk(MYIOC_s_INFO_FMT " Domain Validation needed for PhysDisk %d\n",
|
|
ioc->name, disk);
|
|
break;
|
|
|
|
case MPI_EVENT_RAID_RC_SMART_DATA:
|
|
printk(MYIOC_s_INFO_FMT " SMART data received, ASC/ASCQ = %02xh/%02xh\n",
|
|
ioc->name, pRaidEventData->ASC, pRaidEventData->ASCQ);
|
|
break;
|
|
|
|
case MPI_EVENT_RAID_RC_REPLACE_ACTION_STARTED:
|
|
printk(MYIOC_s_INFO_FMT " replacement of PhysDisk %d has started\n",
|
|
ioc->name, disk);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* GetIoUnitPage2 - Retrieve BIOS version and boot order information.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
*
|
|
* Returns: 0 for success
|
|
* -ENOMEM if no memory available
|
|
* -EPERM if not allowed due to ISR context
|
|
* -EAGAIN if no msg frames currently available
|
|
* -EFAULT for non-successful reply or no reply (timeout)
|
|
*/
|
|
static int
|
|
GetIoUnitPage2(MPT_ADAPTER *ioc)
|
|
{
|
|
ConfigPageHeader_t hdr;
|
|
CONFIGPARMS cfg;
|
|
IOUnitPage2_t *ppage_alloc;
|
|
dma_addr_t page_dma;
|
|
int data_sz;
|
|
int rc;
|
|
|
|
/* Get the page header */
|
|
hdr.PageVersion = 0;
|
|
hdr.PageLength = 0;
|
|
hdr.PageNumber = 2;
|
|
hdr.PageType = MPI_CONFIG_PAGETYPE_IO_UNIT;
|
|
cfg.cfghdr.hdr = &hdr;
|
|
cfg.physAddr = -1;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
|
|
cfg.dir = 0;
|
|
cfg.pageAddr = 0;
|
|
cfg.timeout = 0;
|
|
|
|
if ((rc = mpt_config(ioc, &cfg)) != 0)
|
|
return rc;
|
|
|
|
if (hdr.PageLength == 0)
|
|
return 0;
|
|
|
|
/* Read the config page */
|
|
data_sz = hdr.PageLength * 4;
|
|
rc = -ENOMEM;
|
|
ppage_alloc = (IOUnitPage2_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
|
|
if (ppage_alloc) {
|
|
memset((u8 *)ppage_alloc, 0, data_sz);
|
|
cfg.physAddr = page_dma;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
|
|
/* If Good, save data */
|
|
if ((rc = mpt_config(ioc, &cfg)) == 0)
|
|
ioc->biosVersion = le32_to_cpu(ppage_alloc->BiosVersion);
|
|
|
|
pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage_alloc, page_dma);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_GetScsiPortSettings - read SCSI Port Page 0 and 2
|
|
* @ioc: Pointer to a Adapter Strucutre
|
|
* @portnum: IOC port number
|
|
*
|
|
* Return: -EFAULT if read of config page header fails
|
|
* or if no nvram
|
|
* If read of SCSI Port Page 0 fails,
|
|
* NVRAM = MPT_HOST_NVRAM_INVALID (0xFFFFFFFF)
|
|
* Adapter settings: async, narrow
|
|
* Return 1
|
|
* If read of SCSI Port Page 2 fails,
|
|
* Adapter settings valid
|
|
* NVRAM = MPT_HOST_NVRAM_INVALID (0xFFFFFFFF)
|
|
* Return 1
|
|
* Else
|
|
* Both valid
|
|
* Return 0
|
|
* CHECK - what type of locking mechanisms should be used????
|
|
*/
|
|
static int
|
|
mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum)
|
|
{
|
|
u8 *pbuf;
|
|
dma_addr_t buf_dma;
|
|
CONFIGPARMS cfg;
|
|
ConfigPageHeader_t header;
|
|
int ii;
|
|
int data, rc = 0;
|
|
|
|
/* Allocate memory
|
|
*/
|
|
if (!ioc->spi_data.nvram) {
|
|
int sz;
|
|
u8 *mem;
|
|
sz = MPT_MAX_SCSI_DEVICES * sizeof(int);
|
|
mem = kmalloc(sz, GFP_ATOMIC);
|
|
if (mem == NULL)
|
|
return -EFAULT;
|
|
|
|
ioc->spi_data.nvram = (int *) mem;
|
|
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SCSI device NVRAM settings @ %p, sz=%d\n",
|
|
ioc->name, ioc->spi_data.nvram, sz));
|
|
}
|
|
|
|
/* Invalidate NVRAM information
|
|
*/
|
|
for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
|
|
ioc->spi_data.nvram[ii] = MPT_HOST_NVRAM_INVALID;
|
|
}
|
|
|
|
/* Read SPP0 header, allocate memory, then read page.
|
|
*/
|
|
header.PageVersion = 0;
|
|
header.PageLength = 0;
|
|
header.PageNumber = 0;
|
|
header.PageType = MPI_CONFIG_PAGETYPE_SCSI_PORT;
|
|
cfg.cfghdr.hdr = &header;
|
|
cfg.physAddr = -1;
|
|
cfg.pageAddr = portnum;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
|
|
cfg.dir = 0;
|
|
cfg.timeout = 0; /* use default */
|
|
if (mpt_config(ioc, &cfg) != 0)
|
|
return -EFAULT;
|
|
|
|
if (header.PageLength > 0) {
|
|
pbuf = pci_alloc_consistent(ioc->pcidev, header.PageLength * 4, &buf_dma);
|
|
if (pbuf) {
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
cfg.physAddr = buf_dma;
|
|
if (mpt_config(ioc, &cfg) != 0) {
|
|
ioc->spi_data.maxBusWidth = MPT_NARROW;
|
|
ioc->spi_data.maxSyncOffset = 0;
|
|
ioc->spi_data.minSyncFactor = MPT_ASYNC;
|
|
ioc->spi_data.busType = MPT_HOST_BUS_UNKNOWN;
|
|
rc = 1;
|
|
ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"Unable to read PortPage0 minSyncFactor=%x\n",
|
|
ioc->name, ioc->spi_data.minSyncFactor));
|
|
} else {
|
|
/* Save the Port Page 0 data
|
|
*/
|
|
SCSIPortPage0_t *pPP0 = (SCSIPortPage0_t *) pbuf;
|
|
pPP0->Capabilities = le32_to_cpu(pPP0->Capabilities);
|
|
pPP0->PhysicalInterface = le32_to_cpu(pPP0->PhysicalInterface);
|
|
|
|
if ( (pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_QAS) == 0 ) {
|
|
ioc->spi_data.noQas |= MPT_TARGET_NO_NEGO_QAS;
|
|
ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"noQas due to Capabilities=%x\n",
|
|
ioc->name, pPP0->Capabilities));
|
|
}
|
|
ioc->spi_data.maxBusWidth = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_WIDE ? 1 : 0;
|
|
data = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_MAX_SYNC_OFFSET_MASK;
|
|
if (data) {
|
|
ioc->spi_data.maxSyncOffset = (u8) (data >> 16);
|
|
data = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_MIN_SYNC_PERIOD_MASK;
|
|
ioc->spi_data.minSyncFactor = (u8) (data >> 8);
|
|
ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"PortPage0 minSyncFactor=%x\n",
|
|
ioc->name, ioc->spi_data.minSyncFactor));
|
|
} else {
|
|
ioc->spi_data.maxSyncOffset = 0;
|
|
ioc->spi_data.minSyncFactor = MPT_ASYNC;
|
|
}
|
|
|
|
ioc->spi_data.busType = pPP0->PhysicalInterface & MPI_SCSIPORTPAGE0_PHY_SIGNAL_TYPE_MASK;
|
|
|
|
/* Update the minSyncFactor based on bus type.
|
|
*/
|
|
if ((ioc->spi_data.busType == MPI_SCSIPORTPAGE0_PHY_SIGNAL_HVD) ||
|
|
(ioc->spi_data.busType == MPI_SCSIPORTPAGE0_PHY_SIGNAL_SE)) {
|
|
|
|
if (ioc->spi_data.minSyncFactor < MPT_ULTRA) {
|
|
ioc->spi_data.minSyncFactor = MPT_ULTRA;
|
|
ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"HVD or SE detected, minSyncFactor=%x\n",
|
|
ioc->name, ioc->spi_data.minSyncFactor));
|
|
}
|
|
}
|
|
}
|
|
if (pbuf) {
|
|
pci_free_consistent(ioc->pcidev, header.PageLength * 4, pbuf, buf_dma);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* SCSI Port Page 2 - Read the header then the page.
|
|
*/
|
|
header.PageVersion = 0;
|
|
header.PageLength = 0;
|
|
header.PageNumber = 2;
|
|
header.PageType = MPI_CONFIG_PAGETYPE_SCSI_PORT;
|
|
cfg.cfghdr.hdr = &header;
|
|
cfg.physAddr = -1;
|
|
cfg.pageAddr = portnum;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
|
|
cfg.dir = 0;
|
|
if (mpt_config(ioc, &cfg) != 0)
|
|
return -EFAULT;
|
|
|
|
if (header.PageLength > 0) {
|
|
/* Allocate memory and read SCSI Port Page 2
|
|
*/
|
|
pbuf = pci_alloc_consistent(ioc->pcidev, header.PageLength * 4, &buf_dma);
|
|
if (pbuf) {
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_NVRAM;
|
|
cfg.physAddr = buf_dma;
|
|
if (mpt_config(ioc, &cfg) != 0) {
|
|
/* Nvram data is left with INVALID mark
|
|
*/
|
|
rc = 1;
|
|
} else if (ioc->pcidev->vendor == PCI_VENDOR_ID_ATTO) {
|
|
|
|
/* This is an ATTO adapter, read Page2 accordingly
|
|
*/
|
|
ATTO_SCSIPortPage2_t *pPP2 = (ATTO_SCSIPortPage2_t *) pbuf;
|
|
ATTODeviceInfo_t *pdevice = NULL;
|
|
u16 ATTOFlags;
|
|
|
|
/* Save the Port Page 2 data
|
|
* (reformat into a 32bit quantity)
|
|
*/
|
|
for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
|
|
pdevice = &pPP2->DeviceSettings[ii];
|
|
ATTOFlags = le16_to_cpu(pdevice->ATTOFlags);
|
|
data = 0;
|
|
|
|
/* Translate ATTO device flags to LSI format
|
|
*/
|
|
if (ATTOFlags & ATTOFLAG_DISC)
|
|
data |= (MPI_SCSIPORTPAGE2_DEVICE_DISCONNECT_ENABLE);
|
|
if (ATTOFlags & ATTOFLAG_ID_ENB)
|
|
data |= (MPI_SCSIPORTPAGE2_DEVICE_ID_SCAN_ENABLE);
|
|
if (ATTOFlags & ATTOFLAG_LUN_ENB)
|
|
data |= (MPI_SCSIPORTPAGE2_DEVICE_LUN_SCAN_ENABLE);
|
|
if (ATTOFlags & ATTOFLAG_TAGGED)
|
|
data |= (MPI_SCSIPORTPAGE2_DEVICE_TAG_QUEUE_ENABLE);
|
|
if (!(ATTOFlags & ATTOFLAG_WIDE_ENB))
|
|
data |= (MPI_SCSIPORTPAGE2_DEVICE_WIDE_DISABLE);
|
|
|
|
data = (data << 16) | (pdevice->Period << 8) | 10;
|
|
ioc->spi_data.nvram[ii] = data;
|
|
}
|
|
} else {
|
|
SCSIPortPage2_t *pPP2 = (SCSIPortPage2_t *) pbuf;
|
|
MpiDeviceInfo_t *pdevice = NULL;
|
|
|
|
/*
|
|
* Save "Set to Avoid SCSI Bus Resets" flag
|
|
*/
|
|
ioc->spi_data.bus_reset =
|
|
(le32_to_cpu(pPP2->PortFlags) &
|
|
MPI_SCSIPORTPAGE2_PORT_FLAGS_AVOID_SCSI_RESET) ?
|
|
0 : 1 ;
|
|
|
|
/* Save the Port Page 2 data
|
|
* (reformat into a 32bit quantity)
|
|
*/
|
|
data = le32_to_cpu(pPP2->PortFlags) & MPI_SCSIPORTPAGE2_PORT_FLAGS_DV_MASK;
|
|
ioc->spi_data.PortFlags = data;
|
|
for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
|
|
pdevice = &pPP2->DeviceSettings[ii];
|
|
data = (le16_to_cpu(pdevice->DeviceFlags) << 16) |
|
|
(pdevice->SyncFactor << 8) | pdevice->Timeout;
|
|
ioc->spi_data.nvram[ii] = data;
|
|
}
|
|
}
|
|
|
|
pci_free_consistent(ioc->pcidev, header.PageLength * 4, pbuf, buf_dma);
|
|
}
|
|
}
|
|
|
|
/* Update Adapter limits with those from NVRAM
|
|
* Comment: Don't need to do this. Target performance
|
|
* parameters will never exceed the adapters limits.
|
|
*/
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_readScsiDevicePageHeaders - save version and length of SDP1
|
|
* @ioc: Pointer to a Adapter Strucutre
|
|
* @portnum: IOC port number
|
|
*
|
|
* Return: -EFAULT if read of config page header fails
|
|
* or 0 if success.
|
|
*/
|
|
static int
|
|
mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum)
|
|
{
|
|
CONFIGPARMS cfg;
|
|
ConfigPageHeader_t header;
|
|
|
|
/* Read the SCSI Device Page 1 header
|
|
*/
|
|
header.PageVersion = 0;
|
|
header.PageLength = 0;
|
|
header.PageNumber = 1;
|
|
header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
|
|
cfg.cfghdr.hdr = &header;
|
|
cfg.physAddr = -1;
|
|
cfg.pageAddr = portnum;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
|
|
cfg.dir = 0;
|
|
cfg.timeout = 0;
|
|
if (mpt_config(ioc, &cfg) != 0)
|
|
return -EFAULT;
|
|
|
|
ioc->spi_data.sdp1version = cfg.cfghdr.hdr->PageVersion;
|
|
ioc->spi_data.sdp1length = cfg.cfghdr.hdr->PageLength;
|
|
|
|
header.PageVersion = 0;
|
|
header.PageLength = 0;
|
|
header.PageNumber = 0;
|
|
header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
|
|
if (mpt_config(ioc, &cfg) != 0)
|
|
return -EFAULT;
|
|
|
|
ioc->spi_data.sdp0version = cfg.cfghdr.hdr->PageVersion;
|
|
ioc->spi_data.sdp0length = cfg.cfghdr.hdr->PageLength;
|
|
|
|
dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Headers: 0: version %d length %d\n",
|
|
ioc->name, ioc->spi_data.sdp0version, ioc->spi_data.sdp0length));
|
|
|
|
dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Headers: 1: version %d length %d\n",
|
|
ioc->name, ioc->spi_data.sdp1version, ioc->spi_data.sdp1length));
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* mpt_inactive_raid_list_free - This clears this link list.
|
|
* @ioc : pointer to per adapter structure
|
|
**/
|
|
static void
|
|
mpt_inactive_raid_list_free(MPT_ADAPTER *ioc)
|
|
{
|
|
struct inactive_raid_component_info *component_info, *pNext;
|
|
|
|
if (list_empty(&ioc->raid_data.inactive_list))
|
|
return;
|
|
|
|
mutex_lock(&ioc->raid_data.inactive_list_mutex);
|
|
list_for_each_entry_safe(component_info, pNext,
|
|
&ioc->raid_data.inactive_list, list) {
|
|
list_del(&component_info->list);
|
|
kfree(component_info);
|
|
}
|
|
mutex_unlock(&ioc->raid_data.inactive_list_mutex);
|
|
}
|
|
|
|
/**
|
|
* mpt_inactive_raid_volumes - sets up link list of phy_disk_nums for devices belonging in an inactive volume
|
|
*
|
|
* @ioc : pointer to per adapter structure
|
|
* @channel : volume channel
|
|
* @id : volume target id
|
|
**/
|
|
static void
|
|
mpt_inactive_raid_volumes(MPT_ADAPTER *ioc, u8 channel, u8 id)
|
|
{
|
|
CONFIGPARMS cfg;
|
|
ConfigPageHeader_t hdr;
|
|
dma_addr_t dma_handle;
|
|
pRaidVolumePage0_t buffer = NULL;
|
|
int i;
|
|
RaidPhysDiskPage0_t phys_disk;
|
|
struct inactive_raid_component_info *component_info;
|
|
int handle_inactive_volumes;
|
|
|
|
memset(&cfg, 0 , sizeof(CONFIGPARMS));
|
|
memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
|
|
hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
|
|
cfg.pageAddr = (channel << 8) + id;
|
|
cfg.cfghdr.hdr = &hdr;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
|
|
|
|
if (mpt_config(ioc, &cfg) != 0)
|
|
goto out;
|
|
|
|
if (!hdr.PageLength)
|
|
goto out;
|
|
|
|
buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
|
|
&dma_handle);
|
|
|
|
if (!buffer)
|
|
goto out;
|
|
|
|
cfg.physAddr = dma_handle;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
|
|
if (mpt_config(ioc, &cfg) != 0)
|
|
goto out;
|
|
|
|
if (!buffer->NumPhysDisks)
|
|
goto out;
|
|
|
|
handle_inactive_volumes =
|
|
(buffer->VolumeStatus.Flags & MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE ||
|
|
(buffer->VolumeStatus.Flags & MPI_RAIDVOL0_STATUS_FLAG_ENABLED) == 0 ||
|
|
buffer->VolumeStatus.State == MPI_RAIDVOL0_STATUS_STATE_FAILED ||
|
|
buffer->VolumeStatus.State == MPI_RAIDVOL0_STATUS_STATE_MISSING) ? 1 : 0;
|
|
|
|
if (!handle_inactive_volumes)
|
|
goto out;
|
|
|
|
mutex_lock(&ioc->raid_data.inactive_list_mutex);
|
|
for (i = 0; i < buffer->NumPhysDisks; i++) {
|
|
if(mpt_raid_phys_disk_pg0(ioc,
|
|
buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
|
|
continue;
|
|
|
|
if ((component_info = kmalloc(sizeof (*component_info),
|
|
GFP_KERNEL)) == NULL)
|
|
continue;
|
|
|
|
component_info->volumeID = id;
|
|
component_info->volumeBus = channel;
|
|
component_info->d.PhysDiskNum = phys_disk.PhysDiskNum;
|
|
component_info->d.PhysDiskBus = phys_disk.PhysDiskBus;
|
|
component_info->d.PhysDiskID = phys_disk.PhysDiskID;
|
|
component_info->d.PhysDiskIOC = phys_disk.PhysDiskIOC;
|
|
|
|
list_add_tail(&component_info->list,
|
|
&ioc->raid_data.inactive_list);
|
|
}
|
|
mutex_unlock(&ioc->raid_data.inactive_list_mutex);
|
|
|
|
out:
|
|
if (buffer)
|
|
pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
|
|
dma_handle);
|
|
}
|
|
|
|
/**
|
|
* mpt_raid_phys_disk_pg0 - returns phys disk page zero
|
|
* @ioc: Pointer to a Adapter Structure
|
|
* @phys_disk_num: io unit unique phys disk num generated by the ioc
|
|
* @phys_disk: requested payload data returned
|
|
*
|
|
* Return:
|
|
* 0 on success
|
|
* -EFAULT if read of config page header fails or data pointer not NULL
|
|
* -ENOMEM if pci_alloc failed
|
|
**/
|
|
int
|
|
mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc, u8 phys_disk_num, pRaidPhysDiskPage0_t phys_disk)
|
|
{
|
|
CONFIGPARMS cfg;
|
|
ConfigPageHeader_t hdr;
|
|
dma_addr_t dma_handle;
|
|
pRaidPhysDiskPage0_t buffer = NULL;
|
|
int rc;
|
|
|
|
memset(&cfg, 0 , sizeof(CONFIGPARMS));
|
|
memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
|
|
|
|
hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
|
|
cfg.cfghdr.hdr = &hdr;
|
|
cfg.physAddr = -1;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
|
|
|
|
if (mpt_config(ioc, &cfg) != 0) {
|
|
rc = -EFAULT;
|
|
goto out;
|
|
}
|
|
|
|
if (!hdr.PageLength) {
|
|
rc = -EFAULT;
|
|
goto out;
|
|
}
|
|
|
|
buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
|
|
&dma_handle);
|
|
|
|
if (!buffer) {
|
|
rc = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
cfg.physAddr = dma_handle;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
cfg.pageAddr = phys_disk_num;
|
|
|
|
if (mpt_config(ioc, &cfg) != 0) {
|
|
rc = -EFAULT;
|
|
goto out;
|
|
}
|
|
|
|
rc = 0;
|
|
memcpy(phys_disk, buffer, sizeof(*buffer));
|
|
phys_disk->MaxLBA = le32_to_cpu(buffer->MaxLBA);
|
|
|
|
out:
|
|
|
|
if (buffer)
|
|
pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
|
|
dma_handle);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* mpt_findImVolumes - Identify IDs of hidden disks and RAID Volumes
|
|
* @ioc: Pointer to a Adapter Strucutre
|
|
*
|
|
* Return:
|
|
* 0 on success
|
|
* -EFAULT if read of config page header fails or data pointer not NULL
|
|
* -ENOMEM if pci_alloc failed
|
|
**/
|
|
int
|
|
mpt_findImVolumes(MPT_ADAPTER *ioc)
|
|
{
|
|
IOCPage2_t *pIoc2;
|
|
u8 *mem;
|
|
dma_addr_t ioc2_dma;
|
|
CONFIGPARMS cfg;
|
|
ConfigPageHeader_t header;
|
|
int rc = 0;
|
|
int iocpage2sz;
|
|
int i;
|
|
|
|
if (!ioc->ir_firmware)
|
|
return 0;
|
|
|
|
/* Free the old page
|
|
*/
|
|
kfree(ioc->raid_data.pIocPg2);
|
|
ioc->raid_data.pIocPg2 = NULL;
|
|
mpt_inactive_raid_list_free(ioc);
|
|
|
|
/* Read IOCP2 header then the page.
|
|
*/
|
|
header.PageVersion = 0;
|
|
header.PageLength = 0;
|
|
header.PageNumber = 2;
|
|
header.PageType = MPI_CONFIG_PAGETYPE_IOC;
|
|
cfg.cfghdr.hdr = &header;
|
|
cfg.physAddr = -1;
|
|
cfg.pageAddr = 0;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
|
|
cfg.dir = 0;
|
|
cfg.timeout = 0;
|
|
if (mpt_config(ioc, &cfg) != 0)
|
|
return -EFAULT;
|
|
|
|
if (header.PageLength == 0)
|
|
return -EFAULT;
|
|
|
|
iocpage2sz = header.PageLength * 4;
|
|
pIoc2 = pci_alloc_consistent(ioc->pcidev, iocpage2sz, &ioc2_dma);
|
|
if (!pIoc2)
|
|
return -ENOMEM;
|
|
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
cfg.physAddr = ioc2_dma;
|
|
if (mpt_config(ioc, &cfg) != 0)
|
|
goto out;
|
|
|
|
mem = kmalloc(iocpage2sz, GFP_KERNEL);
|
|
if (!mem)
|
|
goto out;
|
|
|
|
memcpy(mem, (u8 *)pIoc2, iocpage2sz);
|
|
ioc->raid_data.pIocPg2 = (IOCPage2_t *) mem;
|
|
|
|
mpt_read_ioc_pg_3(ioc);
|
|
|
|
for (i = 0; i < pIoc2->NumActiveVolumes ; i++)
|
|
mpt_inactive_raid_volumes(ioc,
|
|
pIoc2->RaidVolume[i].VolumeBus,
|
|
pIoc2->RaidVolume[i].VolumeID);
|
|
|
|
out:
|
|
pci_free_consistent(ioc->pcidev, iocpage2sz, pIoc2, ioc2_dma);
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int
|
|
mpt_read_ioc_pg_3(MPT_ADAPTER *ioc)
|
|
{
|
|
IOCPage3_t *pIoc3;
|
|
u8 *mem;
|
|
CONFIGPARMS cfg;
|
|
ConfigPageHeader_t header;
|
|
dma_addr_t ioc3_dma;
|
|
int iocpage3sz = 0;
|
|
|
|
/* Free the old page
|
|
*/
|
|
kfree(ioc->raid_data.pIocPg3);
|
|
ioc->raid_data.pIocPg3 = NULL;
|
|
|
|
/* There is at least one physical disk.
|
|
* Read and save IOC Page 3
|
|
*/
|
|
header.PageVersion = 0;
|
|
header.PageLength = 0;
|
|
header.PageNumber = 3;
|
|
header.PageType = MPI_CONFIG_PAGETYPE_IOC;
|
|
cfg.cfghdr.hdr = &header;
|
|
cfg.physAddr = -1;
|
|
cfg.pageAddr = 0;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
|
|
cfg.dir = 0;
|
|
cfg.timeout = 0;
|
|
if (mpt_config(ioc, &cfg) != 0)
|
|
return 0;
|
|
|
|
if (header.PageLength == 0)
|
|
return 0;
|
|
|
|
/* Read Header good, alloc memory
|
|
*/
|
|
iocpage3sz = header.PageLength * 4;
|
|
pIoc3 = pci_alloc_consistent(ioc->pcidev, iocpage3sz, &ioc3_dma);
|
|
if (!pIoc3)
|
|
return 0;
|
|
|
|
/* Read the Page and save the data
|
|
* into malloc'd memory.
|
|
*/
|
|
cfg.physAddr = ioc3_dma;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
if (mpt_config(ioc, &cfg) == 0) {
|
|
mem = kmalloc(iocpage3sz, GFP_KERNEL);
|
|
if (mem) {
|
|
memcpy(mem, (u8 *)pIoc3, iocpage3sz);
|
|
ioc->raid_data.pIocPg3 = (IOCPage3_t *) mem;
|
|
}
|
|
}
|
|
|
|
pci_free_consistent(ioc->pcidev, iocpage3sz, pIoc3, ioc3_dma);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
mpt_read_ioc_pg_4(MPT_ADAPTER *ioc)
|
|
{
|
|
IOCPage4_t *pIoc4;
|
|
CONFIGPARMS cfg;
|
|
ConfigPageHeader_t header;
|
|
dma_addr_t ioc4_dma;
|
|
int iocpage4sz;
|
|
|
|
/* Read and save IOC Page 4
|
|
*/
|
|
header.PageVersion = 0;
|
|
header.PageLength = 0;
|
|
header.PageNumber = 4;
|
|
header.PageType = MPI_CONFIG_PAGETYPE_IOC;
|
|
cfg.cfghdr.hdr = &header;
|
|
cfg.physAddr = -1;
|
|
cfg.pageAddr = 0;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
|
|
cfg.dir = 0;
|
|
cfg.timeout = 0;
|
|
if (mpt_config(ioc, &cfg) != 0)
|
|
return;
|
|
|
|
if (header.PageLength == 0)
|
|
return;
|
|
|
|
if ( (pIoc4 = ioc->spi_data.pIocPg4) == NULL ) {
|
|
iocpage4sz = (header.PageLength + 4) * 4; /* Allow 4 additional SEP's */
|
|
pIoc4 = pci_alloc_consistent(ioc->pcidev, iocpage4sz, &ioc4_dma);
|
|
if (!pIoc4)
|
|
return;
|
|
ioc->alloc_total += iocpage4sz;
|
|
} else {
|
|
ioc4_dma = ioc->spi_data.IocPg4_dma;
|
|
iocpage4sz = ioc->spi_data.IocPg4Sz;
|
|
}
|
|
|
|
/* Read the Page into dma memory.
|
|
*/
|
|
cfg.physAddr = ioc4_dma;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
if (mpt_config(ioc, &cfg) == 0) {
|
|
ioc->spi_data.pIocPg4 = (IOCPage4_t *) pIoc4;
|
|
ioc->spi_data.IocPg4_dma = ioc4_dma;
|
|
ioc->spi_data.IocPg4Sz = iocpage4sz;
|
|
} else {
|
|
pci_free_consistent(ioc->pcidev, iocpage4sz, pIoc4, ioc4_dma);
|
|
ioc->spi_data.pIocPg4 = NULL;
|
|
ioc->alloc_total -= iocpage4sz;
|
|
}
|
|
}
|
|
|
|
static void
|
|
mpt_read_ioc_pg_1(MPT_ADAPTER *ioc)
|
|
{
|
|
IOCPage1_t *pIoc1;
|
|
CONFIGPARMS cfg;
|
|
ConfigPageHeader_t header;
|
|
dma_addr_t ioc1_dma;
|
|
int iocpage1sz = 0;
|
|
u32 tmp;
|
|
|
|
/* Check the Coalescing Timeout in IOC Page 1
|
|
*/
|
|
header.PageVersion = 0;
|
|
header.PageLength = 0;
|
|
header.PageNumber = 1;
|
|
header.PageType = MPI_CONFIG_PAGETYPE_IOC;
|
|
cfg.cfghdr.hdr = &header;
|
|
cfg.physAddr = -1;
|
|
cfg.pageAddr = 0;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
|
|
cfg.dir = 0;
|
|
cfg.timeout = 0;
|
|
if (mpt_config(ioc, &cfg) != 0)
|
|
return;
|
|
|
|
if (header.PageLength == 0)
|
|
return;
|
|
|
|
/* Read Header good, alloc memory
|
|
*/
|
|
iocpage1sz = header.PageLength * 4;
|
|
pIoc1 = pci_alloc_consistent(ioc->pcidev, iocpage1sz, &ioc1_dma);
|
|
if (!pIoc1)
|
|
return;
|
|
|
|
/* Read the Page and check coalescing timeout
|
|
*/
|
|
cfg.physAddr = ioc1_dma;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
if (mpt_config(ioc, &cfg) == 0) {
|
|
|
|
tmp = le32_to_cpu(pIoc1->Flags) & MPI_IOCPAGE1_REPLY_COALESCING;
|
|
if (tmp == MPI_IOCPAGE1_REPLY_COALESCING) {
|
|
tmp = le32_to_cpu(pIoc1->CoalescingTimeout);
|
|
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Coalescing Enabled Timeout = %d\n",
|
|
ioc->name, tmp));
|
|
|
|
if (tmp > MPT_COALESCING_TIMEOUT) {
|
|
pIoc1->CoalescingTimeout = cpu_to_le32(MPT_COALESCING_TIMEOUT);
|
|
|
|
/* Write NVRAM and current
|
|
*/
|
|
cfg.dir = 1;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
|
|
if (mpt_config(ioc, &cfg) == 0) {
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Reset Current Coalescing Timeout to = %d\n",
|
|
ioc->name, MPT_COALESCING_TIMEOUT));
|
|
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM;
|
|
if (mpt_config(ioc, &cfg) == 0) {
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"Reset NVRAM Coalescing Timeout to = %d\n",
|
|
ioc->name, MPT_COALESCING_TIMEOUT));
|
|
} else {
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"Reset NVRAM Coalescing Timeout Failed\n",
|
|
ioc->name));
|
|
}
|
|
|
|
} else {
|
|
dprintk(ioc, printk(MYIOC_s_WARN_FMT
|
|
"Reset of Current Coalescing Timeout Failed!\n",
|
|
ioc->name));
|
|
}
|
|
}
|
|
|
|
} else {
|
|
dprintk(ioc, printk(MYIOC_s_WARN_FMT "Coalescing Disabled\n", ioc->name));
|
|
}
|
|
}
|
|
|
|
pci_free_consistent(ioc->pcidev, iocpage1sz, pIoc1, ioc1_dma);
|
|
|
|
return;
|
|
}
|
|
|
|
static void
|
|
mpt_get_manufacturing_pg_0(MPT_ADAPTER *ioc)
|
|
{
|
|
CONFIGPARMS cfg;
|
|
ConfigPageHeader_t hdr;
|
|
dma_addr_t buf_dma;
|
|
ManufacturingPage0_t *pbuf = NULL;
|
|
|
|
memset(&cfg, 0 , sizeof(CONFIGPARMS));
|
|
memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
|
|
|
|
hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
|
|
cfg.cfghdr.hdr = &hdr;
|
|
cfg.physAddr = -1;
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
|
|
cfg.timeout = 10;
|
|
|
|
if (mpt_config(ioc, &cfg) != 0)
|
|
goto out;
|
|
|
|
if (!cfg.cfghdr.hdr->PageLength)
|
|
goto out;
|
|
|
|
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
|
|
if (!pbuf)
|
|
goto out;
|
|
|
|
cfg.physAddr = buf_dma;
|
|
|
|
if (mpt_config(ioc, &cfg) != 0)
|
|
goto out;
|
|
|
|
memcpy(ioc->board_name, pbuf->BoardName, sizeof(ioc->board_name));
|
|
memcpy(ioc->board_assembly, pbuf->BoardAssembly, sizeof(ioc->board_assembly));
|
|
memcpy(ioc->board_tracer, pbuf->BoardTracerNumber, sizeof(ioc->board_tracer));
|
|
|
|
out:
|
|
|
|
if (pbuf)
|
|
pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* SendEventNotification - Send EventNotification (on or off) request to adapter
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @EvSwitch: Event switch flags
|
|
*/
|
|
static int
|
|
SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch)
|
|
{
|
|
EventNotification_t *evnp;
|
|
|
|
evnp = (EventNotification_t *) mpt_get_msg_frame(mpt_base_index, ioc);
|
|
if (evnp == NULL) {
|
|
devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "Unable to allocate event request frame!\n",
|
|
ioc->name));
|
|
return 0;
|
|
}
|
|
memset(evnp, 0, sizeof(*evnp));
|
|
|
|
devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending EventNotification (%d) request %p\n", ioc->name, EvSwitch, evnp));
|
|
|
|
evnp->Function = MPI_FUNCTION_EVENT_NOTIFICATION;
|
|
evnp->ChainOffset = 0;
|
|
evnp->MsgFlags = 0;
|
|
evnp->Switch = EvSwitch;
|
|
|
|
mpt_put_msg_frame(mpt_base_index, ioc, (MPT_FRAME_HDR *)evnp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* SendEventAck - Send EventAck request to MPT adapter.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @evnp: Pointer to original EventNotification request
|
|
*/
|
|
static int
|
|
SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp)
|
|
{
|
|
EventAck_t *pAck;
|
|
|
|
if ((pAck = (EventAck_t *) mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
|
|
dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames!!\n",
|
|
ioc->name,__func__));
|
|
return -1;
|
|
}
|
|
|
|
devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending EventAck\n", ioc->name));
|
|
|
|
pAck->Function = MPI_FUNCTION_EVENT_ACK;
|
|
pAck->ChainOffset = 0;
|
|
pAck->Reserved[0] = pAck->Reserved[1] = 0;
|
|
pAck->MsgFlags = 0;
|
|
pAck->Reserved1[0] = pAck->Reserved1[1] = pAck->Reserved1[2] = 0;
|
|
pAck->Event = evnp->Event;
|
|
pAck->EventContext = evnp->EventContext;
|
|
|
|
mpt_put_msg_frame(mpt_base_index, ioc, (MPT_FRAME_HDR *)pAck);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_config - Generic function to issue config message
|
|
* @ioc: Pointer to an adapter structure
|
|
* @pCfg: Pointer to a configuration structure. Struct contains
|
|
* action, page address, direction, physical address
|
|
* and pointer to a configuration page header
|
|
* Page header is updated.
|
|
*
|
|
* Returns 0 for success
|
|
* -EPERM if not allowed due to ISR context
|
|
* -EAGAIN if no msg frames currently available
|
|
* -EFAULT for non-successful reply or no reply (timeout)
|
|
*/
|
|
int
|
|
mpt_config(MPT_ADAPTER *ioc, CONFIGPARMS *pCfg)
|
|
{
|
|
Config_t *pReq;
|
|
ConfigExtendedPageHeader_t *pExtHdr = NULL;
|
|
MPT_FRAME_HDR *mf;
|
|
unsigned long flags;
|
|
int ii, rc;
|
|
int flagsLength;
|
|
int in_isr;
|
|
|
|
/* Prevent calling wait_event() (below), if caller happens
|
|
* to be in ISR context, because that is fatal!
|
|
*/
|
|
in_isr = in_interrupt();
|
|
if (in_isr) {
|
|
dcprintk(ioc, printk(MYIOC_s_WARN_FMT "Config request not allowed in ISR context!\n",
|
|
ioc->name));
|
|
return -EPERM;
|
|
}
|
|
|
|
/* Get and Populate a free Frame
|
|
*/
|
|
if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
|
|
dcprintk(ioc, printk(MYIOC_s_WARN_FMT "mpt_config: no msg frames!\n",
|
|
ioc->name));
|
|
return -EAGAIN;
|
|
}
|
|
pReq = (Config_t *)mf;
|
|
pReq->Action = pCfg->action;
|
|
pReq->Reserved = 0;
|
|
pReq->ChainOffset = 0;
|
|
pReq->Function = MPI_FUNCTION_CONFIG;
|
|
|
|
/* Assume page type is not extended and clear "reserved" fields. */
|
|
pReq->ExtPageLength = 0;
|
|
pReq->ExtPageType = 0;
|
|
pReq->MsgFlags = 0;
|
|
|
|
for (ii=0; ii < 8; ii++)
|
|
pReq->Reserved2[ii] = 0;
|
|
|
|
pReq->Header.PageVersion = pCfg->cfghdr.hdr->PageVersion;
|
|
pReq->Header.PageLength = pCfg->cfghdr.hdr->PageLength;
|
|
pReq->Header.PageNumber = pCfg->cfghdr.hdr->PageNumber;
|
|
pReq->Header.PageType = (pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK);
|
|
|
|
if ((pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK) == MPI_CONFIG_PAGETYPE_EXTENDED) {
|
|
pExtHdr = (ConfigExtendedPageHeader_t *)pCfg->cfghdr.ehdr;
|
|
pReq->ExtPageLength = cpu_to_le16(pExtHdr->ExtPageLength);
|
|
pReq->ExtPageType = pExtHdr->ExtPageType;
|
|
pReq->Header.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
|
|
|
|
/* Page Length must be treated as a reserved field for the extended header. */
|
|
pReq->Header.PageLength = 0;
|
|
}
|
|
|
|
pReq->PageAddress = cpu_to_le32(pCfg->pageAddr);
|
|
|
|
/* Add a SGE to the config request.
|
|
*/
|
|
if (pCfg->dir)
|
|
flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
|
|
else
|
|
flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
|
|
|
|
if ((pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK) == MPI_CONFIG_PAGETYPE_EXTENDED) {
|
|
flagsLength |= pExtHdr->ExtPageLength * 4;
|
|
|
|
dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Config request type %d, page %d and action %d\n",
|
|
ioc->name, pReq->ExtPageType, pReq->Header.PageNumber, pReq->Action));
|
|
}
|
|
else {
|
|
flagsLength |= pCfg->cfghdr.hdr->PageLength * 4;
|
|
|
|
dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Config request type %d, page %d and action %d\n",
|
|
ioc->name, pReq->Header.PageType, pReq->Header.PageNumber, pReq->Action));
|
|
}
|
|
|
|
mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, pCfg->physAddr);
|
|
|
|
/* Append pCfg pointer to end of mf
|
|
*/
|
|
*((void **) (((u8 *) mf) + (ioc->req_sz - sizeof(void *)))) = (void *) pCfg;
|
|
|
|
/* Initalize the timer
|
|
*/
|
|
init_timer(&pCfg->timer);
|
|
pCfg->timer.data = (unsigned long) ioc;
|
|
pCfg->timer.function = mpt_timer_expired;
|
|
pCfg->wait_done = 0;
|
|
|
|
/* Set the timer; ensure 10 second minimum */
|
|
if (pCfg->timeout < 10)
|
|
pCfg->timer.expires = jiffies + HZ*10;
|
|
else
|
|
pCfg->timer.expires = jiffies + HZ*pCfg->timeout;
|
|
|
|
/* Add to end of Q, set timer and then issue this command */
|
|
spin_lock_irqsave(&ioc->FreeQlock, flags);
|
|
list_add_tail(&pCfg->linkage, &ioc->configQ);
|
|
spin_unlock_irqrestore(&ioc->FreeQlock, flags);
|
|
|
|
add_timer(&pCfg->timer);
|
|
mpt_put_msg_frame(mpt_base_index, ioc, mf);
|
|
wait_event(mpt_waitq, pCfg->wait_done);
|
|
|
|
/* mf has been freed - do not access */
|
|
|
|
rc = pCfg->status;
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_timer_expired - Callback for timer process.
|
|
* Used only internal config functionality.
|
|
* @data: Pointer to MPT_SCSI_HOST recast as an unsigned long
|
|
*/
|
|
static void
|
|
mpt_timer_expired(unsigned long data)
|
|
{
|
|
MPT_ADAPTER *ioc = (MPT_ADAPTER *) data;
|
|
|
|
dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_timer_expired! \n", ioc->name));
|
|
|
|
/* Perform a FW reload */
|
|
if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0)
|
|
printk(MYIOC_s_WARN_FMT "Firmware Reload FAILED!\n", ioc->name);
|
|
|
|
/* No more processing.
|
|
* Hard reset clean-up will wake up
|
|
* process and free all resources.
|
|
*/
|
|
dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_timer_expired complete!\n", ioc->name));
|
|
|
|
return;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_ioc_reset - Base cleanup for hard reset
|
|
* @ioc: Pointer to the adapter structure
|
|
* @reset_phase: Indicates pre- or post-reset functionality
|
|
*
|
|
* Remark: Frees resources with internally generated commands.
|
|
*/
|
|
static int
|
|
mpt_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
|
|
{
|
|
CONFIGPARMS *pCfg;
|
|
unsigned long flags;
|
|
|
|
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
": IOC %s_reset routed to MPT base driver!\n",
|
|
ioc->name, reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
|
|
reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
|
|
|
|
if (reset_phase == MPT_IOC_SETUP_RESET) {
|
|
;
|
|
} else if (reset_phase == MPT_IOC_PRE_RESET) {
|
|
/* If the internal config Q is not empty -
|
|
* delete timer. MF resources will be freed when
|
|
* the FIFO's are primed.
|
|
*/
|
|
spin_lock_irqsave(&ioc->FreeQlock, flags);
|
|
list_for_each_entry(pCfg, &ioc->configQ, linkage)
|
|
del_timer(&pCfg->timer);
|
|
spin_unlock_irqrestore(&ioc->FreeQlock, flags);
|
|
|
|
} else {
|
|
CONFIGPARMS *pNext;
|
|
|
|
/* Search the configQ for internal commands.
|
|
* Flush the Q, and wake up all suspended threads.
|
|
*/
|
|
spin_lock_irqsave(&ioc->FreeQlock, flags);
|
|
list_for_each_entry_safe(pCfg, pNext, &ioc->configQ, linkage) {
|
|
list_del(&pCfg->linkage);
|
|
|
|
pCfg->status = MPT_CONFIG_ERROR;
|
|
pCfg->wait_done = 1;
|
|
wake_up(&mpt_waitq);
|
|
}
|
|
spin_unlock_irqrestore(&ioc->FreeQlock, flags);
|
|
}
|
|
|
|
return 1; /* currently means nothing really */
|
|
}
|
|
|
|
|
|
#ifdef CONFIG_PROC_FS /* { */
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/*
|
|
* procfs (%MPT_PROCFS_MPTBASEDIR/...) support stuff...
|
|
*/
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* procmpt_create - Create %MPT_PROCFS_MPTBASEDIR entries.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
static int
|
|
procmpt_create(void)
|
|
{
|
|
struct proc_dir_entry *ent;
|
|
|
|
mpt_proc_root_dir = proc_mkdir(MPT_PROCFS_MPTBASEDIR, NULL);
|
|
if (mpt_proc_root_dir == NULL)
|
|
return -ENOTDIR;
|
|
|
|
ent = create_proc_entry("summary", S_IFREG|S_IRUGO, mpt_proc_root_dir);
|
|
if (ent)
|
|
ent->read_proc = procmpt_summary_read;
|
|
|
|
ent = create_proc_entry("version", S_IFREG|S_IRUGO, mpt_proc_root_dir);
|
|
if (ent)
|
|
ent->read_proc = procmpt_version_read;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* procmpt_destroy - Tear down %MPT_PROCFS_MPTBASEDIR entries.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
static void
|
|
procmpt_destroy(void)
|
|
{
|
|
remove_proc_entry("version", mpt_proc_root_dir);
|
|
remove_proc_entry("summary", mpt_proc_root_dir);
|
|
remove_proc_entry(MPT_PROCFS_MPTBASEDIR, NULL);
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* procmpt_summary_read - Handle read request of a summary file
|
|
* @buf: Pointer to area to write information
|
|
* @start: Pointer to start pointer
|
|
* @offset: Offset to start writing
|
|
* @request: Amount of read data requested
|
|
* @eof: Pointer to EOF integer
|
|
* @data: Pointer
|
|
*
|
|
* Handles read request from /proc/mpt/summary or /proc/mpt/iocN/summary.
|
|
* Returns number of characters written to process performing the read.
|
|
*/
|
|
static int
|
|
procmpt_summary_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
|
|
{
|
|
MPT_ADAPTER *ioc;
|
|
char *out = buf;
|
|
int len;
|
|
|
|
if (data) {
|
|
int more = 0;
|
|
|
|
ioc = data;
|
|
mpt_print_ioc_summary(ioc, out, &more, 0, 1);
|
|
|
|
out += more;
|
|
} else {
|
|
list_for_each_entry(ioc, &ioc_list, list) {
|
|
int more = 0;
|
|
|
|
mpt_print_ioc_summary(ioc, out, &more, 0, 1);
|
|
|
|
out += more;
|
|
if ((out-buf) >= request)
|
|
break;
|
|
}
|
|
}
|
|
|
|
len = out - buf;
|
|
|
|
MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* procmpt_version_read - Handle read request from /proc/mpt/version.
|
|
* @buf: Pointer to area to write information
|
|
* @start: Pointer to start pointer
|
|
* @offset: Offset to start writing
|
|
* @request: Amount of read data requested
|
|
* @eof: Pointer to EOF integer
|
|
* @data: Pointer
|
|
*
|
|
* Returns number of characters written to process performing the read.
|
|
*/
|
|
static int
|
|
procmpt_version_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
|
|
{
|
|
u8 cb_idx;
|
|
int scsi, fc, sas, lan, ctl, targ, dmp;
|
|
char *drvname;
|
|
int len;
|
|
|
|
len = sprintf(buf, "%s-%s\n", "mptlinux", MPT_LINUX_VERSION_COMMON);
|
|
len += sprintf(buf+len, " Fusion MPT base driver\n");
|
|
|
|
scsi = fc = sas = lan = ctl = targ = dmp = 0;
|
|
for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
|
|
drvname = NULL;
|
|
if (MptCallbacks[cb_idx]) {
|
|
switch (MptDriverClass[cb_idx]) {
|
|
case MPTSPI_DRIVER:
|
|
if (!scsi++) drvname = "SPI host";
|
|
break;
|
|
case MPTFC_DRIVER:
|
|
if (!fc++) drvname = "FC host";
|
|
break;
|
|
case MPTSAS_DRIVER:
|
|
if (!sas++) drvname = "SAS host";
|
|
break;
|
|
case MPTLAN_DRIVER:
|
|
if (!lan++) drvname = "LAN";
|
|
break;
|
|
case MPTSTM_DRIVER:
|
|
if (!targ++) drvname = "SCSI target";
|
|
break;
|
|
case MPTCTL_DRIVER:
|
|
if (!ctl++) drvname = "ioctl";
|
|
break;
|
|
}
|
|
|
|
if (drvname)
|
|
len += sprintf(buf+len, " Fusion MPT %s driver\n", drvname);
|
|
}
|
|
}
|
|
|
|
MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* procmpt_iocinfo_read - Handle read request from /proc/mpt/iocN/info.
|
|
* @buf: Pointer to area to write information
|
|
* @start: Pointer to start pointer
|
|
* @offset: Offset to start writing
|
|
* @request: Amount of read data requested
|
|
* @eof: Pointer to EOF integer
|
|
* @data: Pointer
|
|
*
|
|
* Returns number of characters written to process performing the read.
|
|
*/
|
|
static int
|
|
procmpt_iocinfo_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
|
|
{
|
|
MPT_ADAPTER *ioc = data;
|
|
int len;
|
|
char expVer[32];
|
|
int sz;
|
|
int p;
|
|
|
|
mpt_get_fw_exp_ver(expVer, ioc);
|
|
|
|
len = sprintf(buf, "%s:", ioc->name);
|
|
if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)
|
|
len += sprintf(buf+len, " (f/w download boot flag set)");
|
|
// if (ioc->facts.IOCExceptions & MPI_IOCFACTS_EXCEPT_CONFIG_CHECKSUM_FAIL)
|
|
// len += sprintf(buf+len, " CONFIG_CHECKSUM_FAIL!");
|
|
|
|
len += sprintf(buf+len, "\n ProductID = 0x%04x (%s)\n",
|
|
ioc->facts.ProductID,
|
|
ioc->prod_name);
|
|
len += sprintf(buf+len, " FWVersion = 0x%08x%s", ioc->facts.FWVersion.Word, expVer);
|
|
if (ioc->facts.FWImageSize)
|
|
len += sprintf(buf+len, " (fw_size=%d)", ioc->facts.FWImageSize);
|
|
len += sprintf(buf+len, "\n MsgVersion = 0x%04x\n", ioc->facts.MsgVersion);
|
|
len += sprintf(buf+len, " FirstWhoInit = 0x%02x\n", ioc->FirstWhoInit);
|
|
len += sprintf(buf+len, " EventState = 0x%02x\n", ioc->facts.EventState);
|
|
|
|
len += sprintf(buf+len, " CurrentHostMfaHighAddr = 0x%08x\n",
|
|
ioc->facts.CurrentHostMfaHighAddr);
|
|
len += sprintf(buf+len, " CurrentSenseBufferHighAddr = 0x%08x\n",
|
|
ioc->facts.CurrentSenseBufferHighAddr);
|
|
|
|
len += sprintf(buf+len, " MaxChainDepth = 0x%02x frames\n", ioc->facts.MaxChainDepth);
|
|
len += sprintf(buf+len, " MinBlockSize = 0x%02x bytes\n", 4*ioc->facts.BlockSize);
|
|
|
|
len += sprintf(buf+len, " RequestFrames @ 0x%p (Dma @ 0x%p)\n",
|
|
(void *)ioc->req_frames, (void *)(ulong)ioc->req_frames_dma);
|
|
/*
|
|
* Rounding UP to nearest 4-kB boundary here...
|
|
*/
|
|
sz = (ioc->req_sz * ioc->req_depth) + 128;
|
|
sz = ((sz + 0x1000UL - 1UL) / 0x1000) * 0x1000;
|
|
len += sprintf(buf+len, " {CurReqSz=%d} x {CurReqDepth=%d} = %d bytes ^= 0x%x\n",
|
|
ioc->req_sz, ioc->req_depth, ioc->req_sz*ioc->req_depth, sz);
|
|
len += sprintf(buf+len, " {MaxReqSz=%d} {MaxReqDepth=%d}\n",
|
|
4*ioc->facts.RequestFrameSize,
|
|
ioc->facts.GlobalCredits);
|
|
|
|
len += sprintf(buf+len, " Frames @ 0x%p (Dma @ 0x%p)\n",
|
|
(void *)ioc->alloc, (void *)(ulong)ioc->alloc_dma);
|
|
sz = (ioc->reply_sz * ioc->reply_depth) + 128;
|
|
len += sprintf(buf+len, " {CurRepSz=%d} x {CurRepDepth=%d} = %d bytes ^= 0x%x\n",
|
|
ioc->reply_sz, ioc->reply_depth, ioc->reply_sz*ioc->reply_depth, sz);
|
|
len += sprintf(buf+len, " {MaxRepSz=%d} {MaxRepDepth=%d}\n",
|
|
ioc->facts.CurReplyFrameSize,
|
|
ioc->facts.ReplyQueueDepth);
|
|
|
|
len += sprintf(buf+len, " MaxDevices = %d\n",
|
|
(ioc->facts.MaxDevices==0) ? 255 : ioc->facts.MaxDevices);
|
|
len += sprintf(buf+len, " MaxBuses = %d\n", ioc->facts.MaxBuses);
|
|
|
|
/* per-port info */
|
|
for (p=0; p < ioc->facts.NumberOfPorts; p++) {
|
|
len += sprintf(buf+len, " PortNumber = %d (of %d)\n",
|
|
p+1,
|
|
ioc->facts.NumberOfPorts);
|
|
if (ioc->bus_type == FC) {
|
|
if (ioc->pfacts[p].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) {
|
|
u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
|
|
len += sprintf(buf+len, " LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
|
|
a[5], a[4], a[3], a[2], a[1], a[0]);
|
|
}
|
|
len += sprintf(buf+len, " WWN = %08X%08X:%08X%08X\n",
|
|
ioc->fc_port_page0[p].WWNN.High,
|
|
ioc->fc_port_page0[p].WWNN.Low,
|
|
ioc->fc_port_page0[p].WWPN.High,
|
|
ioc->fc_port_page0[p].WWPN.Low);
|
|
}
|
|
}
|
|
|
|
MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
|
|
}
|
|
|
|
#endif /* CONFIG_PROC_FS } */
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
static void
|
|
mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc)
|
|
{
|
|
buf[0] ='\0';
|
|
if ((ioc->facts.FWVersion.Word >> 24) == 0x0E) {
|
|
sprintf(buf, " (Exp %02d%02d)",
|
|
(ioc->facts.FWVersion.Word >> 16) & 0x00FF, /* Month */
|
|
(ioc->facts.FWVersion.Word >> 8) & 0x1F); /* Day */
|
|
|
|
/* insider hack! */
|
|
if ((ioc->facts.FWVersion.Word >> 8) & 0x80)
|
|
strcat(buf, " [MDBG]");
|
|
}
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_print_ioc_summary - Write ASCII summary of IOC to a buffer.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @buffer: Pointer to buffer where IOC summary info should be written
|
|
* @size: Pointer to number of bytes we wrote (set by this routine)
|
|
* @len: Offset at which to start writing in buffer
|
|
* @showlan: Display LAN stuff?
|
|
*
|
|
* This routine writes (english readable) ASCII text, which represents
|
|
* a summary of IOC information, to a buffer.
|
|
*/
|
|
void
|
|
mpt_print_ioc_summary(MPT_ADAPTER *ioc, char *buffer, int *size, int len, int showlan)
|
|
{
|
|
char expVer[32];
|
|
int y;
|
|
|
|
mpt_get_fw_exp_ver(expVer, ioc);
|
|
|
|
/*
|
|
* Shorter summary of attached ioc's...
|
|
*/
|
|
y = sprintf(buffer+len, "%s: %s, %s%08xh%s, Ports=%d, MaxQ=%d",
|
|
ioc->name,
|
|
ioc->prod_name,
|
|
MPT_FW_REV_MAGIC_ID_STRING, /* "FwRev=" or somesuch */
|
|
ioc->facts.FWVersion.Word,
|
|
expVer,
|
|
ioc->facts.NumberOfPorts,
|
|
ioc->req_depth);
|
|
|
|
if (showlan && (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN)) {
|
|
u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
|
|
y += sprintf(buffer+len+y, ", LanAddr=%02X:%02X:%02X:%02X:%02X:%02X",
|
|
a[5], a[4], a[3], a[2], a[1], a[0]);
|
|
}
|
|
|
|
y += sprintf(buffer+len+y, ", IRQ=%d", ioc->pci_irq);
|
|
|
|
if (!ioc->active)
|
|
y += sprintf(buffer+len+y, " (disabled)");
|
|
|
|
y += sprintf(buffer+len+y, "\n");
|
|
|
|
*size = y;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/*
|
|
* Reset Handling
|
|
*/
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_HardResetHandler - Generic reset handler
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @sleepFlag: Indicates if sleep or schedule must be called.
|
|
*
|
|
* Issues SCSI Task Management call based on input arg values.
|
|
* If TaskMgmt fails, returns associated SCSI request.
|
|
*
|
|
* Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
|
|
* or a non-interrupt thread. In the former, must not call schedule().
|
|
*
|
|
* Note: A return of -1 is a FATAL error case, as it means a
|
|
* FW reload/initialization failed.
|
|
*
|
|
* Returns 0 for SUCCESS or -1 if FAILED.
|
|
*/
|
|
int
|
|
mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag)
|
|
{
|
|
int rc;
|
|
unsigned long flags;
|
|
|
|
dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HardResetHandler Entered!\n", ioc->name));
|
|
#ifdef MFCNT
|
|
printk(MYIOC_s_INFO_FMT "HardResetHandler Entered!\n", ioc->name);
|
|
printk("MF count 0x%x !\n", ioc->mfcnt);
|
|
#endif
|
|
|
|
/* Reset the adapter. Prevent more than 1 call to
|
|
* mpt_do_ioc_recovery at any instant in time.
|
|
*/
|
|
spin_lock_irqsave(&ioc->diagLock, flags);
|
|
if ((ioc->diagPending) || (ioc->alt_ioc && ioc->alt_ioc->diagPending)){
|
|
spin_unlock_irqrestore(&ioc->diagLock, flags);
|
|
return 0;
|
|
} else {
|
|
ioc->diagPending = 1;
|
|
}
|
|
spin_unlock_irqrestore(&ioc->diagLock, flags);
|
|
|
|
/* FIXME: If do_ioc_recovery fails, repeat....
|
|
*/
|
|
|
|
/* The SCSI driver needs to adjust timeouts on all current
|
|
* commands prior to the diagnostic reset being issued.
|
|
* Prevents timeouts occurring during a diagnostic reset...very bad.
|
|
* For all other protocol drivers, this is a no-op.
|
|
*/
|
|
{
|
|
u8 cb_idx;
|
|
int r = 0;
|
|
|
|
for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
|
|
if (MptResetHandlers[cb_idx]) {
|
|
dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling IOC reset_setup handler #%d\n",
|
|
ioc->name, cb_idx));
|
|
r += mpt_signal_reset(cb_idx, ioc, MPT_IOC_SETUP_RESET);
|
|
if (ioc->alt_ioc) {
|
|
dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling alt-%s setup reset handler #%d\n",
|
|
ioc->name, ioc->alt_ioc->name, cb_idx));
|
|
r += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_SETUP_RESET);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((rc = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_RECOVER, sleepFlag)) != 0) {
|
|
printk(MYIOC_s_WARN_FMT "Cannot recover rc = %d!\n", ioc->name, rc);
|
|
}
|
|
ioc->reload_fw = 0;
|
|
if (ioc->alt_ioc)
|
|
ioc->alt_ioc->reload_fw = 0;
|
|
|
|
spin_lock_irqsave(&ioc->diagLock, flags);
|
|
ioc->diagPending = 0;
|
|
if (ioc->alt_ioc)
|
|
ioc->alt_ioc->diagPending = 0;
|
|
spin_unlock_irqrestore(&ioc->diagLock, flags);
|
|
|
|
dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HardResetHandler rc = %d!\n", ioc->name, rc));
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
static void
|
|
EventDescriptionStr(u8 event, u32 evData0, char *evStr)
|
|
{
|
|
char *ds = NULL;
|
|
|
|
switch(event) {
|
|
case MPI_EVENT_NONE:
|
|
ds = "None";
|
|
break;
|
|
case MPI_EVENT_LOG_DATA:
|
|
ds = "Log Data";
|
|
break;
|
|
case MPI_EVENT_STATE_CHANGE:
|
|
ds = "State Change";
|
|
break;
|
|
case MPI_EVENT_UNIT_ATTENTION:
|
|
ds = "Unit Attention";
|
|
break;
|
|
case MPI_EVENT_IOC_BUS_RESET:
|
|
ds = "IOC Bus Reset";
|
|
break;
|
|
case MPI_EVENT_EXT_BUS_RESET:
|
|
ds = "External Bus Reset";
|
|
break;
|
|
case MPI_EVENT_RESCAN:
|
|
ds = "Bus Rescan Event";
|
|
break;
|
|
case MPI_EVENT_LINK_STATUS_CHANGE:
|
|
if (evData0 == MPI_EVENT_LINK_STATUS_FAILURE)
|
|
ds = "Link Status(FAILURE) Change";
|
|
else
|
|
ds = "Link Status(ACTIVE) Change";
|
|
break;
|
|
case MPI_EVENT_LOOP_STATE_CHANGE:
|
|
if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LIP)
|
|
ds = "Loop State(LIP) Change";
|
|
else if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LPE)
|
|
ds = "Loop State(LPE) Change"; /* ??? */
|
|
else
|
|
ds = "Loop State(LPB) Change"; /* ??? */
|
|
break;
|
|
case MPI_EVENT_LOGOUT:
|
|
ds = "Logout";
|
|
break;
|
|
case MPI_EVENT_EVENT_CHANGE:
|
|
if (evData0)
|
|
ds = "Events ON";
|
|
else
|
|
ds = "Events OFF";
|
|
break;
|
|
case MPI_EVENT_INTEGRATED_RAID:
|
|
{
|
|
u8 ReasonCode = (u8)(evData0 >> 16);
|
|
switch (ReasonCode) {
|
|
case MPI_EVENT_RAID_RC_VOLUME_CREATED :
|
|
ds = "Integrated Raid: Volume Created";
|
|
break;
|
|
case MPI_EVENT_RAID_RC_VOLUME_DELETED :
|
|
ds = "Integrated Raid: Volume Deleted";
|
|
break;
|
|
case MPI_EVENT_RAID_RC_VOLUME_SETTINGS_CHANGED :
|
|
ds = "Integrated Raid: Volume Settings Changed";
|
|
break;
|
|
case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED :
|
|
ds = "Integrated Raid: Volume Status Changed";
|
|
break;
|
|
case MPI_EVENT_RAID_RC_VOLUME_PHYSDISK_CHANGED :
|
|
ds = "Integrated Raid: Volume Physdisk Changed";
|
|
break;
|
|
case MPI_EVENT_RAID_RC_PHYSDISK_CREATED :
|
|
ds = "Integrated Raid: Physdisk Created";
|
|
break;
|
|
case MPI_EVENT_RAID_RC_PHYSDISK_DELETED :
|
|
ds = "Integrated Raid: Physdisk Deleted";
|
|
break;
|
|
case MPI_EVENT_RAID_RC_PHYSDISK_SETTINGS_CHANGED :
|
|
ds = "Integrated Raid: Physdisk Settings Changed";
|
|
break;
|
|
case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED :
|
|
ds = "Integrated Raid: Physdisk Status Changed";
|
|
break;
|
|
case MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED :
|
|
ds = "Integrated Raid: Domain Validation Needed";
|
|
break;
|
|
case MPI_EVENT_RAID_RC_SMART_DATA :
|
|
ds = "Integrated Raid; Smart Data";
|
|
break;
|
|
case MPI_EVENT_RAID_RC_REPLACE_ACTION_STARTED :
|
|
ds = "Integrated Raid: Replace Action Started";
|
|
break;
|
|
default:
|
|
ds = "Integrated Raid";
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE:
|
|
ds = "SCSI Device Status Change";
|
|
break;
|
|
case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
|
|
{
|
|
u8 id = (u8)(evData0);
|
|
u8 channel = (u8)(evData0 >> 8);
|
|
u8 ReasonCode = (u8)(evData0 >> 16);
|
|
switch (ReasonCode) {
|
|
case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS Device Status Change: Added: "
|
|
"id=%d channel=%d", id, channel);
|
|
break;
|
|
case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS Device Status Change: Deleted: "
|
|
"id=%d channel=%d", id, channel);
|
|
break;
|
|
case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS Device Status Change: SMART Data: "
|
|
"id=%d channel=%d", id, channel);
|
|
break;
|
|
case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS Device Status Change: No Persistancy: "
|
|
"id=%d channel=%d", id, channel);
|
|
break;
|
|
case MPI_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS Device Status Change: Unsupported Device "
|
|
"Discovered : id=%d channel=%d", id, channel);
|
|
break;
|
|
case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS Device Status Change: Internal Device "
|
|
"Reset : id=%d channel=%d", id, channel);
|
|
break;
|
|
case MPI_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS Device Status Change: Internal Task "
|
|
"Abort : id=%d channel=%d", id, channel);
|
|
break;
|
|
case MPI_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS Device Status Change: Internal Abort "
|
|
"Task Set : id=%d channel=%d", id, channel);
|
|
break;
|
|
case MPI_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS Device Status Change: Internal Clear "
|
|
"Task Set : id=%d channel=%d", id, channel);
|
|
break;
|
|
case MPI_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS Device Status Change: Internal Query "
|
|
"Task : id=%d channel=%d", id, channel);
|
|
break;
|
|
default:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS Device Status Change: Unknown: "
|
|
"id=%d channel=%d", id, channel);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case MPI_EVENT_ON_BUS_TIMER_EXPIRED:
|
|
ds = "Bus Timer Expired";
|
|
break;
|
|
case MPI_EVENT_QUEUE_FULL:
|
|
{
|
|
u16 curr_depth = (u16)(evData0 >> 16);
|
|
u8 channel = (u8)(evData0 >> 8);
|
|
u8 id = (u8)(evData0);
|
|
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"Queue Full: channel=%d id=%d depth=%d",
|
|
channel, id, curr_depth);
|
|
break;
|
|
}
|
|
case MPI_EVENT_SAS_SES:
|
|
ds = "SAS SES Event";
|
|
break;
|
|
case MPI_EVENT_PERSISTENT_TABLE_FULL:
|
|
ds = "Persistent Table Full";
|
|
break;
|
|
case MPI_EVENT_SAS_PHY_LINK_STATUS:
|
|
{
|
|
u8 LinkRates = (u8)(evData0 >> 8);
|
|
u8 PhyNumber = (u8)(evData0);
|
|
LinkRates = (LinkRates & MPI_EVENT_SAS_PLS_LR_CURRENT_MASK) >>
|
|
MPI_EVENT_SAS_PLS_LR_CURRENT_SHIFT;
|
|
switch (LinkRates) {
|
|
case MPI_EVENT_SAS_PLS_LR_RATE_UNKNOWN:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS PHY Link Status: Phy=%d:"
|
|
" Rate Unknown",PhyNumber);
|
|
break;
|
|
case MPI_EVENT_SAS_PLS_LR_RATE_PHY_DISABLED:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS PHY Link Status: Phy=%d:"
|
|
" Phy Disabled",PhyNumber);
|
|
break;
|
|
case MPI_EVENT_SAS_PLS_LR_RATE_FAILED_SPEED_NEGOTIATION:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS PHY Link Status: Phy=%d:"
|
|
" Failed Speed Nego",PhyNumber);
|
|
break;
|
|
case MPI_EVENT_SAS_PLS_LR_RATE_SATA_OOB_COMPLETE:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS PHY Link Status: Phy=%d:"
|
|
" Sata OOB Completed",PhyNumber);
|
|
break;
|
|
case MPI_EVENT_SAS_PLS_LR_RATE_1_5:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS PHY Link Status: Phy=%d:"
|
|
" Rate 1.5 Gbps",PhyNumber);
|
|
break;
|
|
case MPI_EVENT_SAS_PLS_LR_RATE_3_0:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS PHY Link Status: Phy=%d:"
|
|
" Rate 3.0 Gpbs",PhyNumber);
|
|
break;
|
|
default:
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS PHY Link Status: Phy=%d", PhyNumber);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case MPI_EVENT_SAS_DISCOVERY_ERROR:
|
|
ds = "SAS Discovery Error";
|
|
break;
|
|
case MPI_EVENT_IR_RESYNC_UPDATE:
|
|
{
|
|
u8 resync_complete = (u8)(evData0 >> 16);
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"IR Resync Update: Complete = %d:",resync_complete);
|
|
break;
|
|
}
|
|
case MPI_EVENT_IR2:
|
|
{
|
|
u8 ReasonCode = (u8)(evData0 >> 16);
|
|
switch (ReasonCode) {
|
|
case MPI_EVENT_IR2_RC_LD_STATE_CHANGED:
|
|
ds = "IR2: LD State Changed";
|
|
break;
|
|
case MPI_EVENT_IR2_RC_PD_STATE_CHANGED:
|
|
ds = "IR2: PD State Changed";
|
|
break;
|
|
case MPI_EVENT_IR2_RC_BAD_BLOCK_TABLE_FULL:
|
|
ds = "IR2: Bad Block Table Full";
|
|
break;
|
|
case MPI_EVENT_IR2_RC_PD_INSERTED:
|
|
ds = "IR2: PD Inserted";
|
|
break;
|
|
case MPI_EVENT_IR2_RC_PD_REMOVED:
|
|
ds = "IR2: PD Removed";
|
|
break;
|
|
case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED:
|
|
ds = "IR2: Foreign CFG Detected";
|
|
break;
|
|
case MPI_EVENT_IR2_RC_REBUILD_MEDIUM_ERROR:
|
|
ds = "IR2: Rebuild Medium Error";
|
|
break;
|
|
default:
|
|
ds = "IR2";
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case MPI_EVENT_SAS_DISCOVERY:
|
|
{
|
|
if (evData0)
|
|
ds = "SAS Discovery: Start";
|
|
else
|
|
ds = "SAS Discovery: Stop";
|
|
break;
|
|
}
|
|
case MPI_EVENT_LOG_ENTRY_ADDED:
|
|
ds = "SAS Log Entry Added";
|
|
break;
|
|
|
|
case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
|
|
{
|
|
u8 phy_num = (u8)(evData0);
|
|
u8 port_num = (u8)(evData0 >> 8);
|
|
u8 port_width = (u8)(evData0 >> 16);
|
|
u8 primative = (u8)(evData0 >> 24);
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS Broadcase Primative: phy=%d port=%d "
|
|
"width=%d primative=0x%02x",
|
|
phy_num, port_num, port_width, primative);
|
|
break;
|
|
}
|
|
|
|
case MPI_EVENT_SAS_INIT_DEVICE_STATUS_CHANGE:
|
|
{
|
|
u8 reason = (u8)(evData0);
|
|
u8 port_num = (u8)(evData0 >> 8);
|
|
u16 handle = le16_to_cpu(evData0 >> 16);
|
|
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS Initiator Device Status Change: reason=0x%02x "
|
|
"port=%d handle=0x%04x",
|
|
reason, port_num, handle);
|
|
break;
|
|
}
|
|
|
|
case MPI_EVENT_SAS_INIT_TABLE_OVERFLOW:
|
|
{
|
|
u8 max_init = (u8)(evData0);
|
|
u8 current_init = (u8)(evData0 >> 8);
|
|
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS Initiator Device Table Overflow: max initiators=%02d "
|
|
"current initators=%02d",
|
|
max_init, current_init);
|
|
break;
|
|
}
|
|
case MPI_EVENT_SAS_SMP_ERROR:
|
|
{
|
|
u8 status = (u8)(evData0);
|
|
u8 port_num = (u8)(evData0 >> 8);
|
|
u8 result = (u8)(evData0 >> 16);
|
|
|
|
if (status == MPI_EVENT_SAS_SMP_FUNCTION_RESULT_VALID)
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS SMP Error: port=%d result=0x%02x",
|
|
port_num, result);
|
|
else if (status == MPI_EVENT_SAS_SMP_CRC_ERROR)
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS SMP Error: port=%d : CRC Error",
|
|
port_num);
|
|
else if (status == MPI_EVENT_SAS_SMP_TIMEOUT)
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS SMP Error: port=%d : Timeout",
|
|
port_num);
|
|
else if (status == MPI_EVENT_SAS_SMP_NO_DESTINATION)
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS SMP Error: port=%d : No Destination",
|
|
port_num);
|
|
else if (status == MPI_EVENT_SAS_SMP_BAD_DESTINATION)
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS SMP Error: port=%d : Bad Destination",
|
|
port_num);
|
|
else
|
|
snprintf(evStr, EVENT_DESCR_STR_SZ,
|
|
"SAS SMP Error: port=%d : status=0x%02x",
|
|
port_num, status);
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* MPT base "custom" events may be added here...
|
|
*/
|
|
default:
|
|
ds = "Unknown";
|
|
break;
|
|
}
|
|
if (ds)
|
|
strncpy(evStr, ds, EVENT_DESCR_STR_SZ);
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* ProcessEventNotification - Route EventNotificationReply to all event handlers
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @pEventReply: Pointer to EventNotification reply frame
|
|
* @evHandlers: Pointer to integer, number of event handlers
|
|
*
|
|
* Routes a received EventNotificationReply to all currently registered
|
|
* event handlers.
|
|
* Returns sum of event handlers return values.
|
|
*/
|
|
static int
|
|
ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *pEventReply, int *evHandlers)
|
|
{
|
|
u16 evDataLen;
|
|
u32 evData0 = 0;
|
|
// u32 evCtx;
|
|
int ii;
|
|
u8 cb_idx;
|
|
int r = 0;
|
|
int handlers = 0;
|
|
char evStr[EVENT_DESCR_STR_SZ];
|
|
u8 event;
|
|
|
|
/*
|
|
* Do platform normalization of values
|
|
*/
|
|
event = le32_to_cpu(pEventReply->Event) & 0xFF;
|
|
// evCtx = le32_to_cpu(pEventReply->EventContext);
|
|
evDataLen = le16_to_cpu(pEventReply->EventDataLength);
|
|
if (evDataLen) {
|
|
evData0 = le32_to_cpu(pEventReply->Data[0]);
|
|
}
|
|
|
|
EventDescriptionStr(event, evData0, evStr);
|
|
devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MPT event:(%02Xh) : %s\n",
|
|
ioc->name,
|
|
event,
|
|
evStr));
|
|
|
|
#ifdef CONFIG_FUSION_LOGGING
|
|
devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
": Event data:\n", ioc->name));
|
|
for (ii = 0; ii < evDataLen; ii++)
|
|
devtverboseprintk(ioc, printk(" %08x",
|
|
le32_to_cpu(pEventReply->Data[ii])));
|
|
devtverboseprintk(ioc, printk("\n"));
|
|
#endif
|
|
|
|
/*
|
|
* Do general / base driver event processing
|
|
*/
|
|
switch(event) {
|
|
case MPI_EVENT_EVENT_CHANGE: /* 0A */
|
|
if (evDataLen) {
|
|
u8 evState = evData0 & 0xFF;
|
|
|
|
/* CHECKME! What if evState unexpectedly says OFF (0)? */
|
|
|
|
/* Update EventState field in cached IocFacts */
|
|
if (ioc->facts.Function) {
|
|
ioc->facts.EventState = evState;
|
|
}
|
|
}
|
|
break;
|
|
case MPI_EVENT_INTEGRATED_RAID:
|
|
mptbase_raid_process_event_data(ioc,
|
|
(MpiEventDataRaid_t *)pEventReply->Data);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Should this event be logged? Events are written sequentially.
|
|
* When buffer is full, start again at the top.
|
|
*/
|
|
if (ioc->events && (ioc->eventTypes & ( 1 << event))) {
|
|
int idx;
|
|
|
|
idx = ioc->eventContext % MPTCTL_EVENT_LOG_SIZE;
|
|
|
|
ioc->events[idx].event = event;
|
|
ioc->events[idx].eventContext = ioc->eventContext;
|
|
|
|
for (ii = 0; ii < 2; ii++) {
|
|
if (ii < evDataLen)
|
|
ioc->events[idx].data[ii] = le32_to_cpu(pEventReply->Data[ii]);
|
|
else
|
|
ioc->events[idx].data[ii] = 0;
|
|
}
|
|
|
|
ioc->eventContext++;
|
|
}
|
|
|
|
|
|
/*
|
|
* Call each currently registered protocol event handler.
|
|
*/
|
|
for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
|
|
if (MptEvHandlers[cb_idx]) {
|
|
devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Routing Event to event handler #%d\n",
|
|
ioc->name, cb_idx));
|
|
r += (*(MptEvHandlers[cb_idx]))(ioc, pEventReply);
|
|
handlers++;
|
|
}
|
|
}
|
|
/* FIXME? Examine results here? */
|
|
|
|
/*
|
|
* If needed, send (a single) EventAck.
|
|
*/
|
|
if (pEventReply->AckRequired == MPI_EVENT_NOTIFICATION_ACK_REQUIRED) {
|
|
devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
|
|
"EventAck required\n",ioc->name));
|
|
if ((ii = SendEventAck(ioc, pEventReply)) != 0) {
|
|
devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SendEventAck returned %d\n",
|
|
ioc->name, ii));
|
|
}
|
|
}
|
|
|
|
*evHandlers = handlers;
|
|
return r;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_fc_log_info - Log information returned from Fibre Channel IOC.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @log_info: U32 LogInfo reply word from the IOC
|
|
*
|
|
* Refer to lsi/mpi_log_fc.h.
|
|
*/
|
|
static void
|
|
mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info)
|
|
{
|
|
char *desc = "unknown";
|
|
|
|
switch (log_info & 0xFF000000) {
|
|
case MPI_IOCLOGINFO_FC_INIT_BASE:
|
|
desc = "FCP Initiator";
|
|
break;
|
|
case MPI_IOCLOGINFO_FC_TARGET_BASE:
|
|
desc = "FCP Target";
|
|
break;
|
|
case MPI_IOCLOGINFO_FC_LAN_BASE:
|
|
desc = "LAN";
|
|
break;
|
|
case MPI_IOCLOGINFO_FC_MSG_BASE:
|
|
desc = "MPI Message Layer";
|
|
break;
|
|
case MPI_IOCLOGINFO_FC_LINK_BASE:
|
|
desc = "FC Link";
|
|
break;
|
|
case MPI_IOCLOGINFO_FC_CTX_BASE:
|
|
desc = "Context Manager";
|
|
break;
|
|
case MPI_IOCLOGINFO_FC_INVALID_FIELD_BYTE_OFFSET:
|
|
desc = "Invalid Field Offset";
|
|
break;
|
|
case MPI_IOCLOGINFO_FC_STATE_CHANGE:
|
|
desc = "State Change Info";
|
|
break;
|
|
}
|
|
|
|
printk(MYIOC_s_INFO_FMT "LogInfo(0x%08x): SubClass={%s}, Value=(0x%06x)\n",
|
|
ioc->name, log_info, desc, (log_info & 0xFFFFFF));
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_spi_log_info - Log information returned from SCSI Parallel IOC.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @log_info: U32 LogInfo word from the IOC
|
|
*
|
|
* Refer to lsi/sp_log.h.
|
|
*/
|
|
static void
|
|
mpt_spi_log_info(MPT_ADAPTER *ioc, u32 log_info)
|
|
{
|
|
u32 info = log_info & 0x00FF0000;
|
|
char *desc = "unknown";
|
|
|
|
switch (info) {
|
|
case 0x00010000:
|
|
desc = "bug! MID not found";
|
|
if (ioc->reload_fw == 0)
|
|
ioc->reload_fw++;
|
|
break;
|
|
|
|
case 0x00020000:
|
|
desc = "Parity Error";
|
|
break;
|
|
|
|
case 0x00030000:
|
|
desc = "ASYNC Outbound Overrun";
|
|
break;
|
|
|
|
case 0x00040000:
|
|
desc = "SYNC Offset Error";
|
|
break;
|
|
|
|
case 0x00050000:
|
|
desc = "BM Change";
|
|
break;
|
|
|
|
case 0x00060000:
|
|
desc = "Msg In Overflow";
|
|
break;
|
|
|
|
case 0x00070000:
|
|
desc = "DMA Error";
|
|
break;
|
|
|
|
case 0x00080000:
|
|
desc = "Outbound DMA Overrun";
|
|
break;
|
|
|
|
case 0x00090000:
|
|
desc = "Task Management";
|
|
break;
|
|
|
|
case 0x000A0000:
|
|
desc = "Device Problem";
|
|
break;
|
|
|
|
case 0x000B0000:
|
|
desc = "Invalid Phase Change";
|
|
break;
|
|
|
|
case 0x000C0000:
|
|
desc = "Untagged Table Size";
|
|
break;
|
|
|
|
}
|
|
|
|
printk(MYIOC_s_INFO_FMT "LogInfo(0x%08x): F/W: %s\n", ioc->name, log_info, desc);
|
|
}
|
|
|
|
/* strings for sas loginfo */
|
|
static char *originator_str[] = {
|
|
"IOP", /* 00h */
|
|
"PL", /* 01h */
|
|
"IR" /* 02h */
|
|
};
|
|
static char *iop_code_str[] = {
|
|
NULL, /* 00h */
|
|
"Invalid SAS Address", /* 01h */
|
|
NULL, /* 02h */
|
|
"Invalid Page", /* 03h */
|
|
"Diag Message Error", /* 04h */
|
|
"Task Terminated", /* 05h */
|
|
"Enclosure Management", /* 06h */
|
|
"Target Mode" /* 07h */
|
|
};
|
|
static char *pl_code_str[] = {
|
|
NULL, /* 00h */
|
|
"Open Failure", /* 01h */
|
|
"Invalid Scatter Gather List", /* 02h */
|
|
"Wrong Relative Offset or Frame Length", /* 03h */
|
|
"Frame Transfer Error", /* 04h */
|
|
"Transmit Frame Connected Low", /* 05h */
|
|
"SATA Non-NCQ RW Error Bit Set", /* 06h */
|
|
"SATA Read Log Receive Data Error", /* 07h */
|
|
"SATA NCQ Fail All Commands After Error", /* 08h */
|
|
"SATA Error in Receive Set Device Bit FIS", /* 09h */
|
|
"Receive Frame Invalid Message", /* 0Ah */
|
|
"Receive Context Message Valid Error", /* 0Bh */
|
|
"Receive Frame Current Frame Error", /* 0Ch */
|
|
"SATA Link Down", /* 0Dh */
|
|
"Discovery SATA Init W IOS", /* 0Eh */
|
|
"Config Invalid Page", /* 0Fh */
|
|
"Discovery SATA Init Timeout", /* 10h */
|
|
"Reset", /* 11h */
|
|
"Abort", /* 12h */
|
|
"IO Not Yet Executed", /* 13h */
|
|
"IO Executed", /* 14h */
|
|
"Persistent Reservation Out Not Affiliation "
|
|
"Owner", /* 15h */
|
|
"Open Transmit DMA Abort", /* 16h */
|
|
"IO Device Missing Delay Retry", /* 17h */
|
|
"IO Cancelled Due to Recieve Error", /* 18h */
|
|
NULL, /* 19h */
|
|
NULL, /* 1Ah */
|
|
NULL, /* 1Bh */
|
|
NULL, /* 1Ch */
|
|
NULL, /* 1Dh */
|
|
NULL, /* 1Eh */
|
|
NULL, /* 1Fh */
|
|
"Enclosure Management" /* 20h */
|
|
};
|
|
static char *ir_code_str[] = {
|
|
"Raid Action Error", /* 00h */
|
|
NULL, /* 00h */
|
|
NULL, /* 01h */
|
|
NULL, /* 02h */
|
|
NULL, /* 03h */
|
|
NULL, /* 04h */
|
|
NULL, /* 05h */
|
|
NULL, /* 06h */
|
|
NULL /* 07h */
|
|
};
|
|
static char *raid_sub_code_str[] = {
|
|
NULL, /* 00h */
|
|
"Volume Creation Failed: Data Passed too "
|
|
"Large", /* 01h */
|
|
"Volume Creation Failed: Duplicate Volumes "
|
|
"Attempted", /* 02h */
|
|
"Volume Creation Failed: Max Number "
|
|
"Supported Volumes Exceeded", /* 03h */
|
|
"Volume Creation Failed: DMA Error", /* 04h */
|
|
"Volume Creation Failed: Invalid Volume Type", /* 05h */
|
|
"Volume Creation Failed: Error Reading "
|
|
"MFG Page 4", /* 06h */
|
|
"Volume Creation Failed: Creating Internal "
|
|
"Structures", /* 07h */
|
|
NULL, /* 08h */
|
|
NULL, /* 09h */
|
|
NULL, /* 0Ah */
|
|
NULL, /* 0Bh */
|
|
NULL, /* 0Ch */
|
|
NULL, /* 0Dh */
|
|
NULL, /* 0Eh */
|
|
NULL, /* 0Fh */
|
|
"Activation failed: Already Active Volume", /* 10h */
|
|
"Activation failed: Unsupported Volume Type", /* 11h */
|
|
"Activation failed: Too Many Active Volumes", /* 12h */
|
|
"Activation failed: Volume ID in Use", /* 13h */
|
|
"Activation failed: Reported Failure", /* 14h */
|
|
"Activation failed: Importing a Volume", /* 15h */
|
|
NULL, /* 16h */
|
|
NULL, /* 17h */
|
|
NULL, /* 18h */
|
|
NULL, /* 19h */
|
|
NULL, /* 1Ah */
|
|
NULL, /* 1Bh */
|
|
NULL, /* 1Ch */
|
|
NULL, /* 1Dh */
|
|
NULL, /* 1Eh */
|
|
NULL, /* 1Fh */
|
|
"Phys Disk failed: Too Many Phys Disks", /* 20h */
|
|
"Phys Disk failed: Data Passed too Large", /* 21h */
|
|
"Phys Disk failed: DMA Error", /* 22h */
|
|
"Phys Disk failed: Invalid <channel:id>", /* 23h */
|
|
"Phys Disk failed: Creating Phys Disk Config "
|
|
"Page", /* 24h */
|
|
NULL, /* 25h */
|
|
NULL, /* 26h */
|
|
NULL, /* 27h */
|
|
NULL, /* 28h */
|
|
NULL, /* 29h */
|
|
NULL, /* 2Ah */
|
|
NULL, /* 2Bh */
|
|
NULL, /* 2Ch */
|
|
NULL, /* 2Dh */
|
|
NULL, /* 2Eh */
|
|
NULL, /* 2Fh */
|
|
"Compatibility Error: IR Disabled", /* 30h */
|
|
"Compatibility Error: Inquiry Comand Failed", /* 31h */
|
|
"Compatibility Error: Device not Direct Access "
|
|
"Device ", /* 32h */
|
|
"Compatibility Error: Removable Device Found", /* 33h */
|
|
"Compatibility Error: Device SCSI Version not "
|
|
"2 or Higher", /* 34h */
|
|
"Compatibility Error: SATA Device, 48 BIT LBA "
|
|
"not Supported", /* 35h */
|
|
"Compatibility Error: Device doesn't have "
|
|
"512 Byte Block Sizes", /* 36h */
|
|
"Compatibility Error: Volume Type Check Failed", /* 37h */
|
|
"Compatibility Error: Volume Type is "
|
|
"Unsupported by FW", /* 38h */
|
|
"Compatibility Error: Disk Drive too Small for "
|
|
"use in Volume", /* 39h */
|
|
"Compatibility Error: Phys Disk for Create "
|
|
"Volume not Found", /* 3Ah */
|
|
"Compatibility Error: Too Many or too Few "
|
|
"Disks for Volume Type", /* 3Bh */
|
|
"Compatibility Error: Disk stripe Sizes "
|
|
"Must be 64KB", /* 3Ch */
|
|
"Compatibility Error: IME Size Limited to < 2TB", /* 3Dh */
|
|
};
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_sas_log_info - Log information returned from SAS IOC.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @log_info: U32 LogInfo reply word from the IOC
|
|
*
|
|
* Refer to lsi/mpi_log_sas.h.
|
|
**/
|
|
static void
|
|
mpt_sas_log_info(MPT_ADAPTER *ioc, u32 log_info)
|
|
{
|
|
union loginfo_type {
|
|
u32 loginfo;
|
|
struct {
|
|
u32 subcode:16;
|
|
u32 code:8;
|
|
u32 originator:4;
|
|
u32 bus_type:4;
|
|
}dw;
|
|
};
|
|
union loginfo_type sas_loginfo;
|
|
char *originator_desc = NULL;
|
|
char *code_desc = NULL;
|
|
char *sub_code_desc = NULL;
|
|
|
|
sas_loginfo.loginfo = log_info;
|
|
if ((sas_loginfo.dw.bus_type != 3 /*SAS*/) &&
|
|
(sas_loginfo.dw.originator < ARRAY_SIZE(originator_str)))
|
|
return;
|
|
|
|
originator_desc = originator_str[sas_loginfo.dw.originator];
|
|
|
|
switch (sas_loginfo.dw.originator) {
|
|
|
|
case 0: /* IOP */
|
|
if (sas_loginfo.dw.code <
|
|
ARRAY_SIZE(iop_code_str))
|
|
code_desc = iop_code_str[sas_loginfo.dw.code];
|
|
break;
|
|
case 1: /* PL */
|
|
if (sas_loginfo.dw.code <
|
|
ARRAY_SIZE(pl_code_str))
|
|
code_desc = pl_code_str[sas_loginfo.dw.code];
|
|
break;
|
|
case 2: /* IR */
|
|
if (sas_loginfo.dw.code >=
|
|
ARRAY_SIZE(ir_code_str))
|
|
break;
|
|
code_desc = ir_code_str[sas_loginfo.dw.code];
|
|
if (sas_loginfo.dw.subcode >=
|
|
ARRAY_SIZE(raid_sub_code_str))
|
|
break;
|
|
if (sas_loginfo.dw.code == 0)
|
|
sub_code_desc =
|
|
raid_sub_code_str[sas_loginfo.dw.subcode];
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
if (sub_code_desc != NULL)
|
|
printk(MYIOC_s_INFO_FMT
|
|
"LogInfo(0x%08x): Originator={%s}, Code={%s},"
|
|
" SubCode={%s}\n",
|
|
ioc->name, log_info, originator_desc, code_desc,
|
|
sub_code_desc);
|
|
else if (code_desc != NULL)
|
|
printk(MYIOC_s_INFO_FMT
|
|
"LogInfo(0x%08x): Originator={%s}, Code={%s},"
|
|
" SubCode(0x%04x)\n",
|
|
ioc->name, log_info, originator_desc, code_desc,
|
|
sas_loginfo.dw.subcode);
|
|
else
|
|
printk(MYIOC_s_INFO_FMT
|
|
"LogInfo(0x%08x): Originator={%s}, Code=(0x%02x),"
|
|
" SubCode(0x%04x)\n",
|
|
ioc->name, log_info, originator_desc,
|
|
sas_loginfo.dw.code, sas_loginfo.dw.subcode);
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* mpt_iocstatus_info_config - IOCSTATUS information for config pages
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @ioc_status: U32 IOCStatus word from IOC
|
|
* @mf: Pointer to MPT request frame
|
|
*
|
|
* Refer to lsi/mpi.h.
|
|
**/
|
|
static void
|
|
mpt_iocstatus_info_config(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf)
|
|
{
|
|
Config_t *pReq = (Config_t *)mf;
|
|
char extend_desc[EVENT_DESCR_STR_SZ];
|
|
char *desc = NULL;
|
|
u32 form;
|
|
u8 page_type;
|
|
|
|
if (pReq->Header.PageType == MPI_CONFIG_PAGETYPE_EXTENDED)
|
|
page_type = pReq->ExtPageType;
|
|
else
|
|
page_type = pReq->Header.PageType;
|
|
|
|
/*
|
|
* ignore invalid page messages for GET_NEXT_HANDLE
|
|
*/
|
|
form = le32_to_cpu(pReq->PageAddress);
|
|
if (ioc_status == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
|
|
if (page_type == MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE ||
|
|
page_type == MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER ||
|
|
page_type == MPI_CONFIG_EXTPAGETYPE_ENCLOSURE) {
|
|
if ((form >> MPI_SAS_DEVICE_PGAD_FORM_SHIFT) ==
|
|
MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE)
|
|
return;
|
|
}
|
|
if (page_type == MPI_CONFIG_PAGETYPE_FC_DEVICE)
|
|
if ((form & MPI_FC_DEVICE_PGAD_FORM_MASK) ==
|
|
MPI_FC_DEVICE_PGAD_FORM_NEXT_DID)
|
|
return;
|
|
}
|
|
|
|
snprintf(extend_desc, EVENT_DESCR_STR_SZ,
|
|
"type=%02Xh, page=%02Xh, action=%02Xh, form=%08Xh",
|
|
page_type, pReq->Header.PageNumber, pReq->Action, form);
|
|
|
|
switch (ioc_status) {
|
|
|
|
case MPI_IOCSTATUS_CONFIG_INVALID_ACTION: /* 0x0020 */
|
|
desc = "Config Page Invalid Action";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_CONFIG_INVALID_TYPE: /* 0x0021 */
|
|
desc = "Config Page Invalid Type";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_CONFIG_INVALID_PAGE: /* 0x0022 */
|
|
desc = "Config Page Invalid Page";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_CONFIG_INVALID_DATA: /* 0x0023 */
|
|
desc = "Config Page Invalid Data";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_CONFIG_NO_DEFAULTS: /* 0x0024 */
|
|
desc = "Config Page No Defaults";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_CONFIG_CANT_COMMIT: /* 0x0025 */
|
|
desc = "Config Page Can't Commit";
|
|
break;
|
|
}
|
|
|
|
if (!desc)
|
|
return;
|
|
|
|
dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOCStatus(0x%04X): %s: %s\n",
|
|
ioc->name, ioc_status, desc, extend_desc));
|
|
}
|
|
|
|
/**
|
|
* mpt_iocstatus_info - IOCSTATUS information returned from IOC.
|
|
* @ioc: Pointer to MPT_ADAPTER structure
|
|
* @ioc_status: U32 IOCStatus word from IOC
|
|
* @mf: Pointer to MPT request frame
|
|
*
|
|
* Refer to lsi/mpi.h.
|
|
**/
|
|
static void
|
|
mpt_iocstatus_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf)
|
|
{
|
|
u32 status = ioc_status & MPI_IOCSTATUS_MASK;
|
|
char *desc = NULL;
|
|
|
|
switch (status) {
|
|
|
|
/****************************************************************************/
|
|
/* Common IOCStatus values for all replies */
|
|
/****************************************************************************/
|
|
|
|
case MPI_IOCSTATUS_INVALID_FUNCTION: /* 0x0001 */
|
|
desc = "Invalid Function";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_BUSY: /* 0x0002 */
|
|
desc = "Busy";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_INVALID_SGL: /* 0x0003 */
|
|
desc = "Invalid SGL";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_INTERNAL_ERROR: /* 0x0004 */
|
|
desc = "Internal Error";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_RESERVED: /* 0x0005 */
|
|
desc = "Reserved";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
|
|
desc = "Insufficient Resources";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_INVALID_FIELD: /* 0x0007 */
|
|
desc = "Invalid Field";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_INVALID_STATE: /* 0x0008 */
|
|
desc = "Invalid State";
|
|
break;
|
|
|
|
/****************************************************************************/
|
|
/* Config IOCStatus values */
|
|
/****************************************************************************/
|
|
|
|
case MPI_IOCSTATUS_CONFIG_INVALID_ACTION: /* 0x0020 */
|
|
case MPI_IOCSTATUS_CONFIG_INVALID_TYPE: /* 0x0021 */
|
|
case MPI_IOCSTATUS_CONFIG_INVALID_PAGE: /* 0x0022 */
|
|
case MPI_IOCSTATUS_CONFIG_INVALID_DATA: /* 0x0023 */
|
|
case MPI_IOCSTATUS_CONFIG_NO_DEFAULTS: /* 0x0024 */
|
|
case MPI_IOCSTATUS_CONFIG_CANT_COMMIT: /* 0x0025 */
|
|
mpt_iocstatus_info_config(ioc, status, mf);
|
|
break;
|
|
|
|
/****************************************************************************/
|
|
/* SCSIIO Reply (SPI, FCP, SAS) initiator values */
|
|
/* */
|
|
/* Look at mptscsih_iocstatus_info_scsiio in mptscsih.c */
|
|
/* */
|
|
/****************************************************************************/
|
|
|
|
case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
|
|
case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
|
|
case MPI_IOCSTATUS_SCSI_INVALID_BUS: /* 0x0041 */
|
|
case MPI_IOCSTATUS_SCSI_INVALID_TARGETID: /* 0x0042 */
|
|
case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
|
|
case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: /* 0x0044 */
|
|
case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
|
|
case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
|
|
case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
|
|
case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */
|
|
case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED: /* 0x004A */
|
|
case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
|
|
case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
|
|
break;
|
|
|
|
/****************************************************************************/
|
|
/* SCSI Target values */
|
|
/****************************************************************************/
|
|
|
|
case MPI_IOCSTATUS_TARGET_PRIORITY_IO: /* 0x0060 */
|
|
desc = "Target: Priority IO";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_TARGET_INVALID_PORT: /* 0x0061 */
|
|
desc = "Target: Invalid Port";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_TARGET_INVALID_IO_INDEX: /* 0x0062 */
|
|
desc = "Target Invalid IO Index:";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_TARGET_ABORTED: /* 0x0063 */
|
|
desc = "Target: Aborted";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_TARGET_NO_CONN_RETRYABLE: /* 0x0064 */
|
|
desc = "Target: No Conn Retryable";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_TARGET_NO_CONNECTION: /* 0x0065 */
|
|
desc = "Target: No Connection";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_TARGET_XFER_COUNT_MISMATCH: /* 0x006A */
|
|
desc = "Target: Transfer Count Mismatch";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_TARGET_STS_DATA_NOT_SENT: /* 0x006B */
|
|
desc = "Target: STS Data not Sent";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_TARGET_DATA_OFFSET_ERROR: /* 0x006D */
|
|
desc = "Target: Data Offset Error";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_TARGET_TOO_MUCH_WRITE_DATA: /* 0x006E */
|
|
desc = "Target: Too Much Write Data";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_TARGET_IU_TOO_SHORT: /* 0x006F */
|
|
desc = "Target: IU Too Short";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_TARGET_ACK_NAK_TIMEOUT: /* 0x0070 */
|
|
desc = "Target: ACK NAK Timeout";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_TARGET_NAK_RECEIVED: /* 0x0071 */
|
|
desc = "Target: Nak Received";
|
|
break;
|
|
|
|
/****************************************************************************/
|
|
/* Fibre Channel Direct Access values */
|
|
/****************************************************************************/
|
|
|
|
case MPI_IOCSTATUS_FC_ABORTED: /* 0x0066 */
|
|
desc = "FC: Aborted";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_FC_RX_ID_INVALID: /* 0x0067 */
|
|
desc = "FC: RX ID Invalid";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_FC_DID_INVALID: /* 0x0068 */
|
|
desc = "FC: DID Invalid";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_FC_NODE_LOGGED_OUT: /* 0x0069 */
|
|
desc = "FC: Node Logged Out";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_FC_EXCHANGE_CANCELED: /* 0x006C */
|
|
desc = "FC: Exchange Canceled";
|
|
break;
|
|
|
|
/****************************************************************************/
|
|
/* LAN values */
|
|
/****************************************************************************/
|
|
|
|
case MPI_IOCSTATUS_LAN_DEVICE_NOT_FOUND: /* 0x0080 */
|
|
desc = "LAN: Device not Found";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_LAN_DEVICE_FAILURE: /* 0x0081 */
|
|
desc = "LAN: Device Failure";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_LAN_TRANSMIT_ERROR: /* 0x0082 */
|
|
desc = "LAN: Transmit Error";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_LAN_TRANSMIT_ABORTED: /* 0x0083 */
|
|
desc = "LAN: Transmit Aborted";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_LAN_RECEIVE_ERROR: /* 0x0084 */
|
|
desc = "LAN: Receive Error";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_LAN_RECEIVE_ABORTED: /* 0x0085 */
|
|
desc = "LAN: Receive Aborted";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_LAN_PARTIAL_PACKET: /* 0x0086 */
|
|
desc = "LAN: Partial Packet";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_LAN_CANCELED: /* 0x0087 */
|
|
desc = "LAN: Canceled";
|
|
break;
|
|
|
|
/****************************************************************************/
|
|
/* Serial Attached SCSI values */
|
|
/****************************************************************************/
|
|
|
|
case MPI_IOCSTATUS_SAS_SMP_REQUEST_FAILED: /* 0x0090 */
|
|
desc = "SAS: SMP Request Failed";
|
|
break;
|
|
|
|
case MPI_IOCSTATUS_SAS_SMP_DATA_OVERRUN: /* 0x0090 */
|
|
desc = "SAS: SMP Data Overrun";
|
|
break;
|
|
|
|
default:
|
|
desc = "Others";
|
|
break;
|
|
}
|
|
|
|
if (!desc)
|
|
return;
|
|
|
|
dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOCStatus(0x%04X): %s\n",
|
|
ioc->name, status, desc));
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
EXPORT_SYMBOL(mpt_attach);
|
|
EXPORT_SYMBOL(mpt_detach);
|
|
#ifdef CONFIG_PM
|
|
EXPORT_SYMBOL(mpt_resume);
|
|
EXPORT_SYMBOL(mpt_suspend);
|
|
#endif
|
|
EXPORT_SYMBOL(ioc_list);
|
|
EXPORT_SYMBOL(mpt_register);
|
|
EXPORT_SYMBOL(mpt_deregister);
|
|
EXPORT_SYMBOL(mpt_event_register);
|
|
EXPORT_SYMBOL(mpt_event_deregister);
|
|
EXPORT_SYMBOL(mpt_reset_register);
|
|
EXPORT_SYMBOL(mpt_reset_deregister);
|
|
EXPORT_SYMBOL(mpt_device_driver_register);
|
|
EXPORT_SYMBOL(mpt_device_driver_deregister);
|
|
EXPORT_SYMBOL(mpt_get_msg_frame);
|
|
EXPORT_SYMBOL(mpt_put_msg_frame);
|
|
EXPORT_SYMBOL(mpt_put_msg_frame_hi_pri);
|
|
EXPORT_SYMBOL(mpt_free_msg_frame);
|
|
EXPORT_SYMBOL(mpt_add_sge);
|
|
EXPORT_SYMBOL(mpt_send_handshake_request);
|
|
EXPORT_SYMBOL(mpt_verify_adapter);
|
|
EXPORT_SYMBOL(mpt_GetIocState);
|
|
EXPORT_SYMBOL(mpt_print_ioc_summary);
|
|
EXPORT_SYMBOL(mpt_HardResetHandler);
|
|
EXPORT_SYMBOL(mpt_config);
|
|
EXPORT_SYMBOL(mpt_findImVolumes);
|
|
EXPORT_SYMBOL(mpt_alloc_fw_memory);
|
|
EXPORT_SYMBOL(mpt_free_fw_memory);
|
|
EXPORT_SYMBOL(mptbase_sas_persist_operation);
|
|
EXPORT_SYMBOL(mpt_raid_phys_disk_pg0);
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* fusion_init - Fusion MPT base driver initialization routine.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
static int __init
|
|
fusion_init(void)
|
|
{
|
|
u8 cb_idx;
|
|
|
|
show_mptmod_ver(my_NAME, my_VERSION);
|
|
printk(KERN_INFO COPYRIGHT "\n");
|
|
|
|
for (cb_idx = 0; cb_idx < MPT_MAX_PROTOCOL_DRIVERS; cb_idx++) {
|
|
MptCallbacks[cb_idx] = NULL;
|
|
MptDriverClass[cb_idx] = MPTUNKNOWN_DRIVER;
|
|
MptEvHandlers[cb_idx] = NULL;
|
|
MptResetHandlers[cb_idx] = NULL;
|
|
}
|
|
|
|
/* Register ourselves (mptbase) in order to facilitate
|
|
* EventNotification handling.
|
|
*/
|
|
mpt_base_index = mpt_register(mpt_base_reply, MPTBASE_DRIVER);
|
|
|
|
/* Register for hard reset handling callbacks.
|
|
*/
|
|
mpt_reset_register(mpt_base_index, mpt_ioc_reset);
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
(void) procmpt_create();
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
|
|
/**
|
|
* fusion_exit - Perform driver unload cleanup.
|
|
*
|
|
* This routine frees all resources associated with each MPT adapter
|
|
* and removes all %MPT_PROCFS_MPTBASEDIR entries.
|
|
*/
|
|
static void __exit
|
|
fusion_exit(void)
|
|
{
|
|
|
|
mpt_reset_deregister(mpt_base_index);
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
procmpt_destroy();
|
|
#endif
|
|
}
|
|
|
|
module_init(fusion_init);
|
|
module_exit(fusion_exit);
|