2 * linux/drivers/message/fusion/mptbase.c
3 * This is the Fusion MPT base driver which supports multiple
4 * (SCSI + LAN) specialized protocol drivers.
5 * For use with LSI Logic PCI chip/adapter(s)
6 * running LSI Logic Fusion MPT (Message Passing Technology) firmware.
8 * Copyright (c) 1999-2005 LSI Logic Corporation
9 * (mailto:mpt_linux_developer@lsil.com)
12 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; version 2 of the License.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
24 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
25 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
26 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
27 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
28 solely responsible for determining the appropriateness of using and
29 distributing the Program and assumes all risks associated with its
30 exercise of rights under this Agreement, including but not limited to
31 the risks and costs of program errors, damage to or loss of data,
32 programs or equipment, and unavailability or interruption of operations.
34 DISCLAIMER OF LIABILITY
35 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
36 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
38 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
39 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
40 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
41 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
43 You should have received a copy of the GNU General Public License
44 along with this program; if not, write to the Free Software
45 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
47 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
49 #include <linux/config.h>
50 #include <linux/kernel.h>
51 #include <linux/module.h>
52 #include <linux/errno.h>
53 #include <linux/init.h>
54 #include <linux/slab.h>
55 #include <linux/types.h>
56 #include <linux/pci.h>
57 #include <linux/kdev_t.h>
58 #include <linux/blkdev.h>
59 #include <linux/delay.h>
60 #include <linux/interrupt.h> /* needed for in_interrupt() proto */
61 #include <linux/dma-mapping.h>
67 #include <asm/irq.h> /* needed for __irq_itoa() proto */
72 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
73 #define my_NAME "Fusion MPT base driver"
74 #define my_VERSION MPT_LINUX_VERSION_COMMON
75 #define MYNAM "mptbase"
77 MODULE_AUTHOR(MODULEAUTHOR);
78 MODULE_DESCRIPTION(my_NAME);
79 MODULE_LICENSE("GPL");
84 static int mpt_msi_enable;
85 module_param(mpt_msi_enable, int, 0);
86 MODULE_PARM_DESC(mpt_msi_enable, " MSI Support Enable (default=0)");
89 static int mfcounter = 0;
90 #define PRINT_MF_COUNT 20000
93 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
97 int mpt_lan_index = -1;
98 int mpt_stm_index = -1;
100 struct proc_dir_entry *mpt_proc_root_dir;
102 #define WHOINIT_UNKNOWN 0xAA
104 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
108 /* Adapter link list */
110 /* Callback lookup table */
111 static MPT_CALLBACK MptCallbacks[MPT_MAX_PROTOCOL_DRIVERS];
112 /* Protocol driver class lookup table */
113 static int MptDriverClass[MPT_MAX_PROTOCOL_DRIVERS];
114 /* Event handler lookup table */
115 static MPT_EVHANDLER MptEvHandlers[MPT_MAX_PROTOCOL_DRIVERS];
116 /* Reset handler lookup table */
117 static MPT_RESETHANDLER MptResetHandlers[MPT_MAX_PROTOCOL_DRIVERS];
118 static struct mpt_pci_driver *MptDeviceDriverHandlers[MPT_MAX_PROTOCOL_DRIVERS];
120 static int mpt_base_index = -1;
121 static int last_drv_idx = -1;
123 static DECLARE_WAIT_QUEUE_HEAD(mpt_waitq);
125 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
129 static irqreturn_t mpt_interrupt(int irq, void *bus_id, struct pt_regs *r);
130 static int mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);
131 static int mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes,
132 u32 *req, int replyBytes, u16 *u16reply, int maxwait,
134 static int mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag);
135 static void mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev);
136 static void mpt_adapter_disable(MPT_ADAPTER *ioc);
137 static void mpt_adapter_dispose(MPT_ADAPTER *ioc);
139 static void MptDisplayIocCapabilities(MPT_ADAPTER *ioc);
140 static int MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag);
141 static int GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason);
142 static int GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
143 static int SendIocInit(MPT_ADAPTER *ioc, int sleepFlag);
144 static int SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
145 static int mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag);
146 static int mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag);
147 static int mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
148 static int KickStart(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
149 static int SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag);
150 static int PrimeIocFifos(MPT_ADAPTER *ioc);
151 static int WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
152 static int WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
153 static int WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
154 static int GetLanConfigPages(MPT_ADAPTER *ioc);
155 static int GetIoUnitPage2(MPT_ADAPTER *ioc);
156 int mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode);
157 static int mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum);
158 static int mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum);
159 static void mpt_read_ioc_pg_1(MPT_ADAPTER *ioc);
160 static void mpt_read_ioc_pg_4(MPT_ADAPTER *ioc);
161 static void mpt_timer_expired(unsigned long data);
162 static int SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch);
163 static int SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp);
164 static int mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag);
165 static int mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init);
167 #ifdef CONFIG_PROC_FS
168 static int procmpt_summary_read(char *buf, char **start, off_t offset,
169 int request, int *eof, void *data);
170 static int procmpt_version_read(char *buf, char **start, off_t offset,
171 int request, int *eof, void *data);
172 static int procmpt_iocinfo_read(char *buf, char **start, off_t offset,
173 int request, int *eof, void *data);
175 static void mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc);
177 //int mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag);
178 static int ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *evReply, int *evHandlers);
179 static void mpt_sp_ioc_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf);
180 static void mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info);
181 static void mpt_spi_log_info(MPT_ADAPTER *ioc, u32 log_info);
182 static void mpt_sas_log_info(MPT_ADAPTER *ioc, u32 log_info);
184 /* module entry point */
185 static int __init fusion_init (void);
186 static void __exit fusion_exit (void);
188 #define CHIPREG_READ32(addr) readl_relaxed(addr)
189 #define CHIPREG_READ32_dmasync(addr) readl(addr)
190 #define CHIPREG_WRITE32(addr,val) writel(val, addr)
191 #define CHIPREG_PIO_WRITE32(addr,val) outl(val, (unsigned long)addr)
192 #define CHIPREG_PIO_READ32(addr) inl((unsigned long)addr)
195 pci_disable_io_access(struct pci_dev *pdev)
199 pci_read_config_word(pdev, PCI_COMMAND, &command_reg);
201 pci_write_config_word(pdev, PCI_COMMAND, command_reg);
205 pci_enable_io_access(struct pci_dev *pdev)
209 pci_read_config_word(pdev, PCI_COMMAND, &command_reg);
211 pci_write_config_word(pdev, PCI_COMMAND, command_reg);
215 * Process turbo (context) reply...
218 mpt_turbo_reply(MPT_ADAPTER *ioc, u32 pa)
220 MPT_FRAME_HDR *mf = NULL;
221 MPT_FRAME_HDR *mr = NULL;
225 dmfprintk((MYIOC_s_INFO_FMT "Got TURBO reply req_idx=%08x\n",
228 switch (pa >> MPI_CONTEXT_REPLY_TYPE_SHIFT) {
229 case MPI_CONTEXT_REPLY_TYPE_SCSI_INIT:
230 req_idx = pa & 0x0000FFFF;
231 cb_idx = (pa & 0x00FF0000) >> 16;
232 mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
234 case MPI_CONTEXT_REPLY_TYPE_LAN:
235 cb_idx = mpt_lan_index;
237 * Blind set of mf to NULL here was fatal
238 * after lan_reply says "freeme"
239 * Fix sort of combined with an optimization here;
240 * added explicit check for case where lan_reply
241 * was just returning 1 and doing nothing else.
242 * For this case skip the callback, but set up
243 * proper mf value first here:-)
245 if ((pa & 0x58000000) == 0x58000000) {
246 req_idx = pa & 0x0000FFFF;
247 mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
248 mpt_free_msg_frame(ioc, mf);
253 mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
255 case MPI_CONTEXT_REPLY_TYPE_SCSI_TARGET:
256 cb_idx = mpt_stm_index;
257 mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
264 /* Check for (valid) IO callback! */
265 if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
266 MptCallbacks[cb_idx] == NULL) {
267 printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
268 __FUNCTION__, ioc->name, cb_idx);
272 if (MptCallbacks[cb_idx](ioc, mf, mr))
273 mpt_free_msg_frame(ioc, mf);
279 mpt_reply(MPT_ADAPTER *ioc, u32 pa)
290 /* non-TURBO reply! Hmmm, something may be up...
291 * Newest turbo reply mechanism; get address
292 * via left shift 1 (get rid of MPI_ADDRESS_REPLY_A_BIT)!
295 /* Map DMA address of reply header to cpu address.
296 * pa is 32 bits - but the dma address may be 32 or 64 bits
297 * get offset based only only the low addresses
300 reply_dma_low = (pa <<= 1);
301 mr = (MPT_FRAME_HDR *)((u8 *)ioc->reply_frames +
302 (reply_dma_low - ioc->reply_frames_low_dma));
304 req_idx = le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx);
305 cb_idx = mr->u.frame.hwhdr.msgctxu.fld.cb_idx;
306 mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
308 dmfprintk((MYIOC_s_INFO_FMT "Got non-TURBO reply=%p req_idx=%x cb_idx=%x Function=%x\n",
309 ioc->name, mr, req_idx, cb_idx, mr->u.hdr.Function));
310 DBG_DUMP_REPLY_FRAME(mr)
312 /* Check/log IOC log info
314 ioc_stat = le16_to_cpu(mr->u.reply.IOCStatus);
315 if (ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) {
316 u32 log_info = le32_to_cpu(mr->u.reply.IOCLogInfo);
317 if (ioc->bus_type == FC)
318 mpt_fc_log_info(ioc, log_info);
319 else if (ioc->bus_type == SPI)
320 mpt_spi_log_info(ioc, log_info);
321 else if (ioc->bus_type == SAS)
322 mpt_sas_log_info(ioc, log_info);
324 if (ioc_stat & MPI_IOCSTATUS_MASK) {
325 if (ioc->bus_type == SPI &&
326 cb_idx != mpt_stm_index &&
327 cb_idx != mpt_lan_index)
328 mpt_sp_ioc_info(ioc, (u32)ioc_stat, mf);
332 /* Check for (valid) IO callback! */
333 if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
334 MptCallbacks[cb_idx] == NULL) {
335 printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
336 __FUNCTION__, ioc->name, cb_idx);
341 freeme = MptCallbacks[cb_idx](ioc, mf, mr);
344 /* Flush (non-TURBO) reply with a WRITE! */
345 CHIPREG_WRITE32(&ioc->chip->ReplyFifo, pa);
348 mpt_free_msg_frame(ioc, mf);
352 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
354 * mpt_interrupt - MPT adapter (IOC) specific interrupt handler.
355 * @irq: irq number (not used)
356 * @bus_id: bus identifier cookie == pointer to MPT_ADAPTER structure
357 * @r: pt_regs pointer (not used)
359 * This routine is registered via the request_irq() kernel API call,
360 * and handles all interrupts generated from a specific MPT adapter
361 * (also referred to as a IO Controller or IOC).
362 * This routine must clear the interrupt from the adapter and does
363 * so by reading the reply FIFO. Multiple replies may be processed
364 * per single call to this routine.
366 * This routine handles register-level access of the adapter but
367 * dispatches (calls) a protocol-specific callback routine to handle
368 * the protocol-specific details of the MPT request completion.
371 mpt_interrupt(int irq, void *bus_id, struct pt_regs *r)
373 MPT_ADAPTER *ioc = bus_id;
377 * Drain the reply FIFO!
380 pa = CHIPREG_READ32_dmasync(&ioc->chip->ReplyFifo);
381 if (pa == 0xFFFFFFFF)
383 else if (pa & MPI_ADDRESS_REPLY_A_BIT)
386 mpt_turbo_reply(ioc, pa);
392 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
394 * mpt_base_reply - MPT base driver's callback routine; all base driver
395 * "internal" request/reply processing is routed here.
396 * Currently used for EventNotification and EventAck handling.
397 * @ioc: Pointer to MPT_ADAPTER structure
398 * @mf: Pointer to original MPT request frame
399 * @reply: Pointer to MPT reply frame (NULL if TurboReply)
401 * Returns 1 indicating original alloc'd request frame ptr
402 * should be freed, or 0 if it shouldn't.
405 mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply)
410 dmfprintk((MYIOC_s_INFO_FMT "mpt_base_reply() called\n", ioc->name));
412 #if defined(MPT_DEBUG_MSG_FRAME)
413 if (!(reply->u.hdr.MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY)) {
414 dmfprintk((KERN_INFO MYNAM ": Original request frame (@%p) header\n", mf));
415 DBG_DUMP_REQUEST_FRAME_HDR(mf)
419 func = reply->u.hdr.Function;
420 dmfprintk((MYIOC_s_INFO_FMT "mpt_base_reply, Function=%02Xh\n",
423 if (func == MPI_FUNCTION_EVENT_NOTIFICATION) {
424 EventNotificationReply_t *pEvReply = (EventNotificationReply_t *) reply;
428 results = ProcessEventNotification(ioc, pEvReply, &evHandlers);
429 if (results != evHandlers) {
430 /* CHECKME! Any special handling needed here? */
431 devtprintk((MYIOC_s_WARN_FMT "Called %d event handlers, sum results = %d\n",
432 ioc->name, evHandlers, results));
436 * Hmmm... It seems that EventNotificationReply is an exception
437 * to the rule of one reply per request.
439 if (pEvReply->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY) {
441 devtprintk((MYIOC_s_WARN_FMT "EVENT_NOTIFICATION reply %p does not return Request frame\n",
442 ioc->name, pEvReply));
444 devtprintk((MYIOC_s_WARN_FMT "EVENT_NOTIFICATION reply %p returns Request frame\n",
445 ioc->name, pEvReply));
448 #ifdef CONFIG_PROC_FS
449 // LogEvent(ioc, pEvReply);
452 } else if (func == MPI_FUNCTION_EVENT_ACK) {
453 dprintk((MYIOC_s_INFO_FMT "mpt_base_reply, EventAck reply received\n",
455 } else if (func == MPI_FUNCTION_CONFIG ||
456 func == MPI_FUNCTION_TOOLBOX) {
460 dcprintk((MYIOC_s_INFO_FMT "config_complete (mf=%p,mr=%p)\n",
461 ioc->name, mf, reply));
463 pCfg = * ((CONFIGPARMS **)((u8 *) mf + ioc->req_sz - sizeof(void *)));
466 /* disable timer and remove from linked list */
467 del_timer(&pCfg->timer);
469 spin_lock_irqsave(&ioc->FreeQlock, flags);
470 list_del(&pCfg->linkage);
471 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
474 * If IOC Status is SUCCESS, save the header
475 * and set the status code to GOOD.
477 pCfg->status = MPT_CONFIG_ERROR;
479 ConfigReply_t *pReply = (ConfigReply_t *)reply;
482 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
483 dcprintk((KERN_NOTICE " IOCStatus=%04xh, IOCLogInfo=%08xh\n",
484 status, le32_to_cpu(pReply->IOCLogInfo)));
486 pCfg->status = status;
487 if (status == MPI_IOCSTATUS_SUCCESS) {
488 if ((pReply->Header.PageType &
489 MPI_CONFIG_PAGETYPE_MASK) ==
490 MPI_CONFIG_PAGETYPE_EXTENDED) {
491 pCfg->cfghdr.ehdr->ExtPageLength =
492 le16_to_cpu(pReply->ExtPageLength);
493 pCfg->cfghdr.ehdr->ExtPageType =
496 pCfg->cfghdr.hdr->PageVersion = pReply->Header.PageVersion;
498 /* If this is a regular header, save PageLength. */
499 /* LMP Do this better so not using a reserved field! */
500 pCfg->cfghdr.hdr->PageLength = pReply->Header.PageLength;
501 pCfg->cfghdr.hdr->PageNumber = pReply->Header.PageNumber;
502 pCfg->cfghdr.hdr->PageType = pReply->Header.PageType;
507 * Wake up the original calling thread
512 } else if (func == MPI_FUNCTION_SAS_IO_UNIT_CONTROL) {
513 /* we should be always getting a reply frame */
514 memcpy(ioc->persist_reply_frame, reply,
515 min(MPT_DEFAULT_FRAME_SIZE,
516 4*reply->u.reply.MsgLength));
517 del_timer(&ioc->persist_timer);
518 ioc->persist_wait_done = 1;
521 printk(MYIOC_s_ERR_FMT "Unexpected msg function (=%02Xh) reply received!\n",
526 * Conditionally tell caller to free the original
527 * EventNotification/EventAck/unexpected request frame!
532 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
534 * mpt_register - Register protocol-specific main callback handler.
535 * @cbfunc: callback function pointer
536 * @dclass: Protocol driver's class (%MPT_DRIVER_CLASS enum value)
538 * This routine is called by a protocol-specific driver (SCSI host,
539 * LAN, SCSI target) to register it's reply callback routine. Each
540 * protocol-specific driver must do this before it will be able to
541 * use any IOC resources, such as obtaining request frames.
543 * NOTES: The SCSI protocol driver currently calls this routine thrice
544 * in order to register separate callbacks; one for "normal" SCSI IO;
545 * one for MptScsiTaskMgmt requests; one for Scan/DV requests.
547 * Returns a positive integer valued "handle" in the
548 * range (and S.O.D. order) {N,...,7,6,5,...,1} if successful.
549 * Any non-positive return value (including zero!) should be considered
550 * an error by the caller.
553 mpt_register(MPT_CALLBACK cbfunc, MPT_DRIVER_CLASS dclass)
560 * Search for empty callback slot in this order: {N,...,7,6,5,...,1}
561 * (slot/handle 0 is reserved!)
563 for (i = MPT_MAX_PROTOCOL_DRIVERS-1; i; i--) {
564 if (MptCallbacks[i] == NULL) {
565 MptCallbacks[i] = cbfunc;
566 MptDriverClass[i] = dclass;
567 MptEvHandlers[i] = NULL;
576 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
578 * mpt_deregister - Deregister a protocol drivers resources.
579 * @cb_idx: previously registered callback handle
581 * Each protocol-specific driver should call this routine when it's
582 * module is unloaded.
585 mpt_deregister(int cb_idx)
587 if ((cb_idx >= 0) && (cb_idx < MPT_MAX_PROTOCOL_DRIVERS)) {
588 MptCallbacks[cb_idx] = NULL;
589 MptDriverClass[cb_idx] = MPTUNKNOWN_DRIVER;
590 MptEvHandlers[cb_idx] = NULL;
596 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
598 * mpt_event_register - Register protocol-specific event callback
600 * @cb_idx: previously registered (via mpt_register) callback handle
601 * @ev_cbfunc: callback function
603 * This routine can be called by one or more protocol-specific drivers
604 * if/when they choose to be notified of MPT events.
606 * Returns 0 for success.
609 mpt_event_register(int cb_idx, MPT_EVHANDLER ev_cbfunc)
611 if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
614 MptEvHandlers[cb_idx] = ev_cbfunc;
618 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
620 * mpt_event_deregister - Deregister protocol-specific event callback
622 * @cb_idx: previously registered callback handle
624 * Each protocol-specific driver should call this routine
625 * when it does not (or can no longer) handle events,
626 * or when it's module is unloaded.
629 mpt_event_deregister(int cb_idx)
631 if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
634 MptEvHandlers[cb_idx] = NULL;
637 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
639 * mpt_reset_register - Register protocol-specific IOC reset handler.
640 * @cb_idx: previously registered (via mpt_register) callback handle
641 * @reset_func: reset function
643 * This routine can be called by one or more protocol-specific drivers
644 * if/when they choose to be notified of IOC resets.
646 * Returns 0 for success.
649 mpt_reset_register(int cb_idx, MPT_RESETHANDLER reset_func)
651 if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
654 MptResetHandlers[cb_idx] = reset_func;
658 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
660 * mpt_reset_deregister - Deregister protocol-specific IOC reset handler.
661 * @cb_idx: previously registered callback handle
663 * Each protocol-specific driver should call this routine
664 * when it does not (or can no longer) handle IOC reset handling,
665 * or when it's module is unloaded.
668 mpt_reset_deregister(int cb_idx)
670 if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
673 MptResetHandlers[cb_idx] = NULL;
676 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
678 * mpt_device_driver_register - Register device driver hooks
681 mpt_device_driver_register(struct mpt_pci_driver * dd_cbfunc, int cb_idx)
685 if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS) {
689 MptDeviceDriverHandlers[cb_idx] = dd_cbfunc;
691 /* call per pci device probe entry point */
692 list_for_each_entry(ioc, &ioc_list, list) {
693 if(dd_cbfunc->probe) {
694 dd_cbfunc->probe(ioc->pcidev,
695 ioc->pcidev->driver->id_table);
702 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
704 * mpt_device_driver_deregister - DeRegister device driver hooks
707 mpt_device_driver_deregister(int cb_idx)
709 struct mpt_pci_driver *dd_cbfunc;
712 if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
715 dd_cbfunc = MptDeviceDriverHandlers[cb_idx];
717 list_for_each_entry(ioc, &ioc_list, list) {
718 if (dd_cbfunc->remove)
719 dd_cbfunc->remove(ioc->pcidev);
722 MptDeviceDriverHandlers[cb_idx] = NULL;
726 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
728 * mpt_get_msg_frame - Obtain a MPT request frame from the pool (of 1024)
729 * allocated per MPT adapter.
730 * @handle: Handle of registered MPT protocol driver
731 * @ioc: Pointer to MPT adapter structure
733 * Returns pointer to a MPT request frame or %NULL if none are available
734 * or IOC is not active.
737 mpt_get_msg_frame(int handle, MPT_ADAPTER *ioc)
741 u16 req_idx; /* Request index */
743 /* validate handle and ioc identifier */
747 printk(KERN_WARNING "IOC Not Active! mpt_get_msg_frame returning NULL!\n");
750 /* If interrupts are not attached, do not return a request frame */
754 spin_lock_irqsave(&ioc->FreeQlock, flags);
755 if (!list_empty(&ioc->FreeQ)) {
758 mf = list_entry(ioc->FreeQ.next, MPT_FRAME_HDR,
759 u.frame.linkage.list);
760 list_del(&mf->u.frame.linkage.list);
761 mf->u.frame.linkage.arg1 = 0;
762 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = handle; /* byte */
763 req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
765 req_idx = req_offset / ioc->req_sz;
766 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
767 mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
768 ioc->RequestNB[req_idx] = ioc->NB_for_64_byte_frame; /* Default, will be changed if necessary in SG generation */
775 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
779 printk(KERN_WARNING "IOC Active. No free Msg Frames! Count 0x%x Max 0x%x\n", ioc->mfcnt, ioc->req_depth);
781 if (mfcounter == PRINT_MF_COUNT)
782 printk(KERN_INFO "MF Count 0x%x Max 0x%x \n", ioc->mfcnt, ioc->req_depth);
785 dmfprintk((KERN_INFO MYNAM ": %s: mpt_get_msg_frame(%d,%d), got mf=%p\n",
786 ioc->name, handle, ioc->id, mf));
790 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
792 * mpt_put_msg_frame - Send a protocol specific MPT request frame
794 * @handle: Handle of registered MPT protocol driver
795 * @ioc: Pointer to MPT adapter structure
796 * @mf: Pointer to MPT request frame
798 * This routine posts a MPT request frame to the request post FIFO of a
799 * specific MPT adapter.
802 mpt_put_msg_frame(int handle, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
806 u16 req_idx; /* Request index */
808 /* ensure values are reset properly! */
809 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = handle; /* byte */
810 req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
812 req_idx = req_offset / ioc->req_sz;
813 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
814 mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
816 #ifdef MPT_DEBUG_MSG_FRAME
818 u32 *m = mf->u.frame.hwhdr.__hdr;
821 printk(KERN_INFO MYNAM ": %s: About to Put msg frame @ %p:\n" KERN_INFO " ",
823 n = ioc->req_sz/4 - 1;
826 for (ii=0; ii<=n; ii++) {
827 if (ii && ((ii%8)==0))
828 printk("\n" KERN_INFO " ");
829 printk(" %08x", le32_to_cpu(m[ii]));
835 mf_dma_addr = (ioc->req_frames_low_dma + req_offset) | ioc->RequestNB[req_idx];
836 dsgprintk((MYIOC_s_INFO_FMT "mf_dma_addr=%x req_idx=%d RequestNB=%x\n", ioc->name, mf_dma_addr, req_idx, ioc->RequestNB[req_idx]));
837 CHIPREG_WRITE32(&ioc->chip->RequestFifo, mf_dma_addr);
840 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
842 * mpt_free_msg_frame - Place MPT request frame back on FreeQ.
843 * @handle: Handle of registered MPT protocol driver
844 * @ioc: Pointer to MPT adapter structure
845 * @mf: Pointer to MPT request frame
847 * This routine places a MPT request frame back on the MPT adapter's
851 mpt_free_msg_frame(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
855 /* Put Request back on FreeQ! */
856 spin_lock_irqsave(&ioc->FreeQlock, flags);
857 mf->u.frame.linkage.arg1 = 0xdeadbeaf; /* signature to know if this mf is freed */
858 list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeQ);
862 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
865 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
867 * mpt_add_sge - Place a simple SGE at address pAddr.
868 * @pAddr: virtual address for SGE
869 * @flagslength: SGE flags and data transfer length
870 * @dma_addr: Physical address
872 * This routine places a MPT request frame back on the MPT adapter's
876 mpt_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
878 if (sizeof(dma_addr_t) == sizeof(u64)) {
879 SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
880 u32 tmp = dma_addr & 0xFFFFFFFF;
882 pSge->FlagsLength = cpu_to_le32(flagslength);
883 pSge->Address.Low = cpu_to_le32(tmp);
884 tmp = (u32) ((u64)dma_addr >> 32);
885 pSge->Address.High = cpu_to_le32(tmp);
888 SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
889 pSge->FlagsLength = cpu_to_le32(flagslength);
890 pSge->Address = cpu_to_le32(dma_addr);
894 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
896 * mpt_send_handshake_request - Send MPT request via doorbell
898 * @handle: Handle of registered MPT protocol driver
899 * @ioc: Pointer to MPT adapter structure
900 * @reqBytes: Size of the request in bytes
901 * @req: Pointer to MPT request frame
902 * @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
904 * This routine is used exclusively to send MptScsiTaskMgmt
905 * requests since they are required to be sent via doorbell handshake.
907 * NOTE: It is the callers responsibility to byte-swap fields in the
908 * request which are greater than 1 byte in size.
910 * Returns 0 for success, non-zero for failure.
913 mpt_send_handshake_request(int handle, MPT_ADAPTER *ioc, int reqBytes, u32 *req, int sleepFlag)
919 /* State is known to be good upon entering
920 * this function so issue the bus reset
925 * Emulate what mpt_put_msg_frame() does /wrt to sanity
926 * setting cb_idx/req_idx. But ONLY if this request
927 * is in proper (pre-alloc'd) request buffer range...
929 ii = MFPTR_2_MPT_INDEX(ioc,(MPT_FRAME_HDR*)req);
930 if (reqBytes >= 12 && ii >= 0 && ii < ioc->req_depth) {
931 MPT_FRAME_HDR *mf = (MPT_FRAME_HDR*)req;
932 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(ii);
933 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = handle;
936 /* Make sure there are no doorbells */
937 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
939 CHIPREG_WRITE32(&ioc->chip->Doorbell,
940 ((MPI_FUNCTION_HANDSHAKE<<MPI_DOORBELL_FUNCTION_SHIFT) |
941 ((reqBytes/4)<<MPI_DOORBELL_ADD_DWORDS_SHIFT)));
943 /* Wait for IOC doorbell int */
944 if ((ii = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0) {
948 /* Read doorbell and check for active bit */
949 if (!(CHIPREG_READ32(&ioc->chip->Doorbell) & MPI_DOORBELL_ACTIVE))
952 dhsprintk((KERN_INFO MYNAM ": %s: mpt_send_handshake_request start, WaitCnt=%d\n",
955 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
957 if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
961 /* Send request via doorbell handshake */
962 req_as_bytes = (u8 *) req;
963 for (ii = 0; ii < reqBytes/4; ii++) {
966 word = ((req_as_bytes[(ii*4) + 0] << 0) |
967 (req_as_bytes[(ii*4) + 1] << 8) |
968 (req_as_bytes[(ii*4) + 2] << 16) |
969 (req_as_bytes[(ii*4) + 3] << 24));
970 CHIPREG_WRITE32(&ioc->chip->Doorbell, word);
971 if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
977 if (r >= 0 && WaitForDoorbellInt(ioc, 10, sleepFlag) >= 0)
982 /* Make sure there are no doorbells */
983 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
988 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
990 * mpt_host_page_access_control - provides mechanism for the host
991 * driver to control the IOC's Host Page Buffer access.
992 * @ioc: Pointer to MPT adapter structure
993 * @access_control_value: define bits below
995 * Access Control Value - bits[15:12]
997 * 1h Enable Access { MPI_DB_HPBAC_ENABLE_ACCESS }
998 * 2h Disable Access { MPI_DB_HPBAC_DISABLE_ACCESS }
999 * 3h Free Buffer { MPI_DB_HPBAC_FREE_BUFFER }
1001 * Returns 0 for success, non-zero for failure.
1005 mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag)
1009 /* return if in use */
1010 if (CHIPREG_READ32(&ioc->chip->Doorbell)
1011 & MPI_DOORBELL_ACTIVE)
1014 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1016 CHIPREG_WRITE32(&ioc->chip->Doorbell,
1017 ((MPI_FUNCTION_HOST_PAGEBUF_ACCESS_CONTROL
1018 <<MPI_DOORBELL_FUNCTION_SHIFT) |
1019 (access_control_value<<12)));
1021 /* Wait for IOC to clear Doorbell Status bit */
1022 if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
1028 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1030 * mpt_host_page_alloc - allocate system memory for the fw
1031 * If we already allocated memory in past, then resend the same pointer.
1032 * ioc@: Pointer to pointer to IOC adapter
1033 * ioc_init@: Pointer to ioc init config page
1035 * Returns 0 for success, non-zero for failure.
1038 mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init)
1042 u32 host_page_buffer_sz=0;
1044 if(!ioc->HostPageBuffer) {
1046 host_page_buffer_sz =
1047 le32_to_cpu(ioc->facts.HostPageBufferSGE.FlagsLength) & 0xFFFFFF;
1049 if(!host_page_buffer_sz)
1050 return 0; /* fw doesn't need any host buffers */
1052 /* spin till we get enough memory */
1053 while(host_page_buffer_sz > 0) {
1055 if((ioc->HostPageBuffer = pci_alloc_consistent(
1057 host_page_buffer_sz,
1058 &ioc->HostPageBuffer_dma)) != NULL) {
1060 dinitprintk((MYIOC_s_INFO_FMT
1061 "host_page_buffer @ %p, dma @ %x, sz=%d bytes\n",
1063 ioc->HostPageBuffer,
1064 ioc->HostPageBuffer_dma,
1065 host_page_buffer_sz));
1066 ioc->alloc_total += host_page_buffer_sz;
1067 ioc->HostPageBuffer_sz = host_page_buffer_sz;
1071 host_page_buffer_sz -= (4*1024);
1075 if(!ioc->HostPageBuffer) {
1076 printk(MYIOC_s_ERR_FMT
1077 "Failed to alloc memory for host_page_buffer!\n",
1082 psge = (char *)&ioc_init->HostPageBufferSGE;
1083 flags_length = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
1084 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
1085 MPI_SGE_FLAGS_32_BIT_ADDRESSING |
1086 MPI_SGE_FLAGS_HOST_TO_IOC |
1087 MPI_SGE_FLAGS_END_OF_BUFFER;
1088 if (sizeof(dma_addr_t) == sizeof(u64)) {
1089 flags_length |= MPI_SGE_FLAGS_64_BIT_ADDRESSING;
1091 flags_length = flags_length << MPI_SGE_FLAGS_SHIFT;
1092 flags_length |= ioc->HostPageBuffer_sz;
1093 mpt_add_sge(psge, flags_length, ioc->HostPageBuffer_dma);
1094 ioc->facts.HostPageBufferSGE = ioc_init->HostPageBufferSGE;
1099 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1101 * mpt_verify_adapter - Given a unique IOC identifier, set pointer to
1102 * the associated MPT adapter structure.
1103 * @iocid: IOC unique identifier (integer)
1104 * @iocpp: Pointer to pointer to IOC adapter
1106 * Returns iocid and sets iocpp.
1109 mpt_verify_adapter(int iocid, MPT_ADAPTER **iocpp)
1113 list_for_each_entry(ioc,&ioc_list,list) {
1114 if (ioc->id == iocid) {
1125 mpt_alt_ioc_wait(MPT_ADAPTER *ioc)
1127 int loop_count = 30 * 4; /* Wait 30 seconds */
1128 int status = -1; /* -1 means failed to get board READY */
1131 spin_lock(&ioc->initializing_hba_lock);
1132 if (ioc->initializing_hba_lock_flag == 0) {
1133 ioc->initializing_hba_lock_flag=1;
1134 spin_unlock(&ioc->initializing_hba_lock);
1138 spin_unlock(&ioc->initializing_hba_lock);
1139 set_current_state(TASK_INTERRUPTIBLE);
1140 schedule_timeout(HZ/4);
1141 } while (--loop_count);
1146 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1148 * mpt_bringup_adapter - This is a wrapper function for mpt_do_ioc_recovery
1149 * @ioc: Pointer to MPT adapter structure
1150 * @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
1152 * This routine performs all the steps necessary to bring the IOC
1153 * to a OPERATIONAL state.
1155 * Special Note: This function was added with spin lock's so as to allow
1156 * the dv(domain validation) work thread to succeed on the other channel
1157 * that maybe occuring at the same time when this function is called.
1158 * Without this lock, the dv would fail when message frames were
1159 * requested during hba bringup on the alternate ioc.
1162 mpt_bringup_adapter(MPT_ADAPTER *ioc, int sleepFlag)
1167 if((r=mpt_alt_ioc_wait(ioc->alt_ioc)!=0))
1171 r = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP,
1175 spin_lock(&ioc->alt_ioc->initializing_hba_lock);
1176 ioc->alt_ioc->initializing_hba_lock_flag=0;
1177 spin_unlock(&ioc->alt_ioc->initializing_hba_lock);
1183 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1185 * mpt_attach - Install a PCI intelligent MPT adapter.
1186 * @pdev: Pointer to pci_dev structure
1188 * This routine performs all the steps necessary to bring the IOC of
1189 * a MPT adapter to a OPERATIONAL state. This includes registering
1190 * memory regions, registering the interrupt, and allocating request
1191 * and reply memory pools.
1193 * This routine also pre-fetches the LAN MAC address of a Fibre Channel
1196 * Returns 0 for success, non-zero for failure.
1198 * TODO: Add support for polled controllers
1201 mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id)
1205 unsigned long mem_phys;
1213 static int mpt_ids = 0;
1214 #ifdef CONFIG_PROC_FS
1215 struct proc_dir_entry *dent, *ent;
1218 if (pci_enable_device(pdev))
1221 dinitprintk((KERN_WARNING MYNAM ": mpt_adapter_install\n"));
1223 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
1224 dprintk((KERN_INFO MYNAM
1225 ": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n"));
1226 } else if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
1227 printk(KERN_WARNING MYNAM ": 32 BIT PCI BUS DMA ADDRESSING NOT SUPPORTED\n");
1231 if (!pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK))
1232 dprintk((KERN_INFO MYNAM
1233 ": Using 64 bit consistent mask\n"));
1235 dprintk((KERN_INFO MYNAM
1236 ": Not using 64 bit consistent mask\n"));
1238 ioc = kzalloc(sizeof(MPT_ADAPTER), GFP_ATOMIC);
1240 printk(KERN_ERR MYNAM ": ERROR - Insufficient memory to add adapter!\n");
1243 ioc->alloc_total = sizeof(MPT_ADAPTER);
1244 ioc->req_sz = MPT_DEFAULT_FRAME_SIZE; /* avoid div by zero! */
1245 ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
1248 ioc->diagPending = 0;
1249 spin_lock_init(&ioc->diagLock);
1250 spin_lock_init(&ioc->fc_rescan_work_lock);
1251 spin_lock_init(&ioc->fc_rport_lock);
1252 spin_lock_init(&ioc->initializing_hba_lock);
1254 /* Initialize the event logging.
1256 ioc->eventTypes = 0; /* None */
1257 ioc->eventContext = 0;
1258 ioc->eventLogSize = 0;
1265 ioc->cached_fw = NULL;
1267 /* Initilize SCSI Config Data structure
1269 memset(&ioc->spi_data, 0, sizeof(SpiCfgData));
1271 /* Initialize the running configQ head.
1273 INIT_LIST_HEAD(&ioc->configQ);
1275 /* Initialize the fc rport list head.
1277 INIT_LIST_HEAD(&ioc->fc_rports);
1279 /* Find lookup slot. */
1280 INIT_LIST_HEAD(&ioc->list);
1281 ioc->id = mpt_ids++;
1283 mem_phys = msize = 0;
1285 for (ii=0; ii < DEVICE_COUNT_RESOURCE; ii++) {
1286 if (pci_resource_flags(pdev, ii) & PCI_BASE_ADDRESS_SPACE_IO) {
1287 /* Get I/O space! */
1288 port = pci_resource_start(pdev, ii);
1289 psize = pci_resource_len(pdev,ii);
1292 mem_phys = pci_resource_start(pdev, ii);
1293 msize = pci_resource_len(pdev,ii);
1297 ioc->mem_size = msize;
1299 if (ii == DEVICE_COUNT_RESOURCE) {
1300 printk(KERN_ERR MYNAM ": ERROR - MPT adapter has no memory regions defined!\n");
1305 dinitprintk((KERN_INFO MYNAM ": MPT adapter @ %lx, msize=%dd bytes\n", mem_phys, msize));
1306 dinitprintk((KERN_INFO MYNAM ": (port i/o @ %lx, psize=%dd bytes)\n", port, psize));
1309 /* Get logical ptr for PciMem0 space */
1310 /*mem = ioremap(mem_phys, msize);*/
1311 mem = ioremap(mem_phys, 0x100);
1313 printk(KERN_ERR MYNAM ": ERROR - Unable to map adapter memory!\n");
1318 dinitprintk((KERN_INFO MYNAM ": mem = %p, mem_phys = %lx\n", mem, mem_phys));
1320 dinitprintk((KERN_INFO MYNAM ": facts @ %p, pfacts[0] @ %p\n",
1321 &ioc->facts, &ioc->pfacts[0]));
1323 ioc->mem_phys = mem_phys;
1324 ioc->chip = (SYSIF_REGS __iomem *)mem;
1326 /* Save Port IO values in case we need to do downloadboot */
1328 u8 *pmem = (u8*)port;
1329 ioc->pio_mem_phys = port;
1330 ioc->pio_chip = (SYSIF_REGS __iomem *)pmem;
1333 if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC909) {
1334 ioc->prod_name = "LSIFC909";
1337 else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC929) {
1338 ioc->prod_name = "LSIFC929";
1341 else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC919) {
1342 ioc->prod_name = "LSIFC919";
1345 else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC929X) {
1346 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1348 if (revision < XL_929) {
1349 ioc->prod_name = "LSIFC929X";
1350 /* 929X Chip Fix. Set Split transactions level
1351 * for PCIX. Set MOST bits to zero.
1353 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1355 pci_write_config_byte(pdev, 0x6a, pcixcmd);
1357 ioc->prod_name = "LSIFC929XL";
1358 /* 929XL Chip Fix. Set MMRBC to 0x08.
1360 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1362 pci_write_config_byte(pdev, 0x6a, pcixcmd);
1365 else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC919X) {
1366 ioc->prod_name = "LSIFC919X";
1368 /* 919X Chip Fix. Set Split transactions level
1369 * for PCIX. Set MOST bits to zero.
1371 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1373 pci_write_config_byte(pdev, 0x6a, pcixcmd);
1375 else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC939X) {
1376 ioc->prod_name = "LSIFC939X";
1378 ioc->errata_flag_1064 = 1;
1380 else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC949X) {
1381 ioc->prod_name = "LSIFC949X";
1383 ioc->errata_flag_1064 = 1;
1385 else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC949E) {
1386 ioc->prod_name = "LSIFC949E";
1389 else if (pdev->device == MPI_MANUFACTPAGE_DEVID_53C1030) {
1390 ioc->prod_name = "LSI53C1030";
1391 ioc->bus_type = SPI;
1392 /* 1030 Chip Fix. Disable Split transactions
1393 * for PCIX. Set MOST bits to zero if Rev < C0( = 8).
1395 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1396 if (revision < C0_1030) {
1397 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1399 pci_write_config_byte(pdev, 0x6a, pcixcmd);
1402 else if (pdev->device == MPI_MANUFACTPAGE_DEVID_1030_53C1035) {
1403 ioc->prod_name = "LSI53C1035";
1404 ioc->bus_type = SPI;
1406 else if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1064) {
1407 ioc->prod_name = "LSISAS1064";
1408 ioc->bus_type = SAS;
1409 ioc->errata_flag_1064 = 1;
1411 else if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1066) {
1412 ioc->prod_name = "LSISAS1066";
1413 ioc->bus_type = SAS;
1414 ioc->errata_flag_1064 = 1;
1416 else if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1068) {
1417 ioc->prod_name = "LSISAS1068";
1418 ioc->bus_type = SAS;
1419 ioc->errata_flag_1064 = 1;
1421 else if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1064E) {
1422 ioc->prod_name = "LSISAS1064E";
1423 ioc->bus_type = SAS;
1425 else if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1066E) {
1426 ioc->prod_name = "LSISAS1066E";
1427 ioc->bus_type = SAS;
1429 else if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1068E) {
1430 ioc->prod_name = "LSISAS1068E";
1431 ioc->bus_type = SAS;
1434 if (ioc->errata_flag_1064)
1435 pci_disable_io_access(pdev);
1437 sprintf(ioc->name, "ioc%d", ioc->id);
1439 spin_lock_init(&ioc->FreeQlock);
1442 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1444 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1446 /* Set lookup ptr. */
1447 list_add_tail(&ioc->list, &ioc_list);
1451 if (mpt_msi_enable && !pci_enable_msi(pdev))
1452 printk(MYIOC_s_INFO_FMT "PCI-MSI enabled\n", ioc->name);
1454 r = request_irq(pdev->irq, mpt_interrupt, SA_SHIRQ, ioc->name, ioc);
1458 printk(MYIOC_s_ERR_FMT "Unable to allocate interrupt %d!\n",
1459 ioc->name, pdev->irq);
1461 printk(MYIOC_s_ERR_FMT "Unable to allocate interrupt %s!\n",
1462 ioc->name, __irq_itoa(pdev->irq));
1464 list_del(&ioc->list);
1470 ioc->pci_irq = pdev->irq;
1472 pci_set_master(pdev); /* ?? */
1473 pci_set_drvdata(pdev, ioc);
1476 dprintk((KERN_INFO MYNAM ": %s installed at interrupt %d\n", ioc->name, pdev->irq));
1478 dprintk((KERN_INFO MYNAM ": %s installed at interrupt %s\n", ioc->name, __irq_itoa(pdev->irq)));
1482 /* Check for "bound ports" (929, 929X, 1030, 1035) to reduce redundant resets.
1484 mpt_detect_bound_ports(ioc, pdev);
1486 if ((r = mpt_bringup_adapter(ioc, CAN_SLEEP)) != 0){
1487 printk(KERN_WARNING MYNAM
1488 ": WARNING - %s did not initialize properly! (%d)\n",
1491 list_del(&ioc->list);
1492 free_irq(ioc->pci_irq, ioc);
1494 pci_disable_msi(pdev);
1496 ioc->alt_ioc->alt_ioc = NULL;
1499 pci_set_drvdata(pdev, NULL);
1503 /* call per device driver probe entry point */
1504 for(ii=0; ii<MPT_MAX_PROTOCOL_DRIVERS; ii++) {
1505 if(MptDeviceDriverHandlers[ii] &&
1506 MptDeviceDriverHandlers[ii]->probe) {
1507 MptDeviceDriverHandlers[ii]->probe(pdev,id);
1511 #ifdef CONFIG_PROC_FS
1513 * Create "/proc/mpt/iocN" subdirectory entry for each MPT adapter.
1515 dent = proc_mkdir(ioc->name, mpt_proc_root_dir);
1517 ent = create_proc_entry("info", S_IFREG|S_IRUGO, dent);
1519 ent->read_proc = procmpt_iocinfo_read;
1522 ent = create_proc_entry("summary", S_IFREG|S_IRUGO, dent);
1524 ent->read_proc = procmpt_summary_read;
1533 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1535 * mpt_detach - Remove a PCI intelligent MPT adapter.
1536 * @pdev: Pointer to pci_dev structure
1541 mpt_detach(struct pci_dev *pdev)
1543 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1547 sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/summary", ioc->name);
1548 remove_proc_entry(pname, NULL);
1549 sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/info", ioc->name);
1550 remove_proc_entry(pname, NULL);
1551 sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s", ioc->name);
1552 remove_proc_entry(pname, NULL);
1554 /* call per device driver remove entry point */
1555 for(ii=0; ii<MPT_MAX_PROTOCOL_DRIVERS; ii++) {
1556 if(MptDeviceDriverHandlers[ii] &&
1557 MptDeviceDriverHandlers[ii]->remove) {
1558 MptDeviceDriverHandlers[ii]->remove(pdev);
1562 /* Disable interrupts! */
1563 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1566 synchronize_irq(pdev->irq);
1568 /* Clear any lingering interrupt */
1569 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1571 CHIPREG_READ32(&ioc->chip->IntStatus);
1573 mpt_adapter_dispose(ioc);
1575 pci_set_drvdata(pdev, NULL);
1578 /**************************************************************************
1582 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1584 * mpt_suspend - Fusion MPT base driver suspend routine.
1589 mpt_suspend(struct pci_dev *pdev, pm_message_t state)
1592 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1594 device_state=pci_choose_state(pdev, state);
1596 printk(MYIOC_s_INFO_FMT
1597 "pci-suspend: pdev=0x%p, slot=%s, Entering operating state [D%d]\n",
1598 ioc->name, pdev, pci_name(pdev), device_state);
1600 pci_save_state(pdev);
1602 /* put ioc into READY_STATE */
1603 if(SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, CAN_SLEEP)) {
1604 printk(MYIOC_s_ERR_FMT
1605 "pci-suspend: IOC msg unit reset failed!\n", ioc->name);
1608 /* disable interrupts */
1609 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1612 /* Clear any lingering interrupt */
1613 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1615 pci_disable_device(pdev);
1616 pci_set_power_state(pdev, device_state);
1621 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1623 * mpt_resume - Fusion MPT base driver resume routine.
1628 mpt_resume(struct pci_dev *pdev)
1630 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1631 u32 device_state = pdev->current_state;
1635 printk(MYIOC_s_INFO_FMT
1636 "pci-resume: pdev=0x%p, slot=%s, Previous operating state [D%d]\n",
1637 ioc->name, pdev, pci_name(pdev), device_state);
1639 pci_set_power_state(pdev, 0);
1640 pci_restore_state(pdev);
1641 pci_enable_device(pdev);
1643 /* enable interrupts */
1644 CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);
1647 /* F/W not running */
1648 if(!CHIPREG_READ32(&ioc->chip->Doorbell)) {
1649 /* enable domain validation flags */
1650 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
1651 ioc->spi_data.dvStatus[ii] |= MPT_SCSICFG_NEED_DV;
1655 printk(MYIOC_s_INFO_FMT
1656 "pci-resume: ioc-state=0x%x,doorbell=0x%x\n",
1658 (mpt_GetIocState(ioc, 1) >> MPI_IOC_STATE_SHIFT),
1659 CHIPREG_READ32(&ioc->chip->Doorbell));
1661 /* bring ioc to operational state */
1662 if ((recovery_state = mpt_do_ioc_recovery(ioc,
1663 MPT_HOSTEVENT_IOC_RECOVER, CAN_SLEEP)) != 0) {
1664 printk(MYIOC_s_INFO_FMT
1665 "pci-resume: Cannot recover, error:[%x]\n",
1666 ioc->name, recovery_state);
1668 printk(MYIOC_s_INFO_FMT
1669 "pci-resume: success\n", ioc->name);
1676 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1678 * mpt_do_ioc_recovery - Initialize or recover MPT adapter.
1679 * @ioc: Pointer to MPT adapter structure
1680 * @reason: Event word / reason
1681 * @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
1683 * This routine performs all the steps necessary to bring the IOC
1684 * to a OPERATIONAL state.
1686 * This routine also pre-fetches the LAN MAC address of a Fibre Channel
1691 * -1 if failed to get board READY
1692 * -2 if READY but IOCFacts Failed
1693 * -3 if READY but PrimeIOCFifos Failed
1694 * -4 if READY but IOCInit Failed
1697 mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag)
1699 int hard_reset_done = 0;
1700 int alt_ioc_ready = 0;
1706 int reset_alt_ioc_active = 0;
1708 printk(KERN_INFO MYNAM ": Initiating %s %s\n",
1709 ioc->name, reason==MPT_HOSTEVENT_IOC_BRINGUP ? "bringup" : "recovery");
1711 /* Disable reply interrupts (also blocks FreeQ) */
1712 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1716 if (ioc->alt_ioc->active)
1717 reset_alt_ioc_active = 1;
1719 /* Disable alt-IOC's reply interrupts (and FreeQ) for a bit ... */
1720 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, 0xFFFFFFFF);
1721 ioc->alt_ioc->active = 0;
1725 if (reason == MPT_HOSTEVENT_IOC_BRINGUP)
1728 if ((hard_reset_done = MakeIocReady(ioc, hard, sleepFlag)) < 0) {
1729 if (hard_reset_done == -4) {
1730 printk(KERN_WARNING MYNAM ": %s Owned by PEER..skipping!\n",
1733 if (reset_alt_ioc_active && ioc->alt_ioc) {
1734 /* (re)Enable alt-IOC! (reply interrupt, FreeQ) */
1735 dprintk((KERN_INFO MYNAM ": alt-%s reply irq re-enabled\n",
1736 ioc->alt_ioc->name));
1737 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
1738 ioc->alt_ioc->active = 1;
1742 printk(KERN_WARNING MYNAM ": %s NOT READY WARNING!\n",
1748 /* hard_reset_done = 0 if a soft reset was performed
1749 * and 1 if a hard reset was performed.
1751 if (hard_reset_done && reset_alt_ioc_active && ioc->alt_ioc) {
1752 if ((rc = MakeIocReady(ioc->alt_ioc, 0, sleepFlag)) == 0)
1755 printk(KERN_WARNING MYNAM
1756 ": alt-%s: Not ready WARNING!\n",
1757 ioc->alt_ioc->name);
1760 for (ii=0; ii<5; ii++) {
1761 /* Get IOC facts! Allow 5 retries */
1762 if ((rc = GetIocFacts(ioc, sleepFlag, reason)) == 0)
1768 dinitprintk((MYIOC_s_INFO_FMT "Retry IocFacts failed rc=%x\n", ioc->name, rc));
1770 } else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
1771 MptDisplayIocCapabilities(ioc);
1774 if (alt_ioc_ready) {
1775 if ((rc = GetIocFacts(ioc->alt_ioc, sleepFlag, reason)) != 0) {
1776 dinitprintk((MYIOC_s_INFO_FMT "Initial Alt IocFacts failed rc=%x\n", ioc->name, rc));
1777 /* Retry - alt IOC was initialized once
1779 rc = GetIocFacts(ioc->alt_ioc, sleepFlag, reason);
1782 dinitprintk((MYIOC_s_INFO_FMT "Retry Alt IocFacts failed rc=%x\n", ioc->name, rc));
1784 reset_alt_ioc_active = 0;
1785 } else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
1786 MptDisplayIocCapabilities(ioc->alt_ioc);
1790 /* Prime reply & request queues!
1791 * (mucho alloc's) Must be done prior to
1792 * init as upper addresses are needed for init.
1793 * If fails, continue with alt-ioc processing
1795 if ((ret == 0) && ((rc = PrimeIocFifos(ioc)) != 0))
1798 /* May need to check/upload firmware & data here!
1799 * If fails, continue with alt-ioc processing
1801 if ((ret == 0) && ((rc = SendIocInit(ioc, sleepFlag)) != 0))
1804 if (alt_ioc_ready && ((rc = PrimeIocFifos(ioc->alt_ioc)) != 0)) {
1805 printk(KERN_WARNING MYNAM ": alt-%s: (%d) FIFO mgmt alloc WARNING!\n",
1806 ioc->alt_ioc->name, rc);
1808 reset_alt_ioc_active = 0;
1811 if (alt_ioc_ready) {
1812 if ((rc = SendIocInit(ioc->alt_ioc, sleepFlag)) != 0) {
1814 reset_alt_ioc_active = 0;
1815 printk(KERN_WARNING MYNAM
1816 ": alt-%s: (%d) init failure WARNING!\n",
1817 ioc->alt_ioc->name, rc);
1821 if (reason == MPT_HOSTEVENT_IOC_BRINGUP){
1822 if (ioc->upload_fw) {
1823 ddlprintk((MYIOC_s_INFO_FMT
1824 "firmware upload required!\n", ioc->name));
1826 /* Controller is not operational, cannot do upload
1829 rc = mpt_do_upload(ioc, sleepFlag);
1831 if (ioc->alt_ioc && ioc->alt_ioc->cached_fw) {
1833 * Maintain only one pointer to FW memory
1834 * so there will not be two attempt to
1835 * downloadboot onboard dual function
1836 * chips (mpt_adapter_disable,
1839 ioc->cached_fw = NULL;
1840 ddlprintk((MYIOC_s_INFO_FMT ": mpt_upload: alt_%s has cached_fw=%p \n",
1841 ioc->name, ioc->alt_ioc->name, ioc->alt_ioc->cached_fw));
1844 printk(KERN_WARNING MYNAM ": firmware upload failure!\n");
1852 /* Enable! (reply interrupt) */
1853 CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);
1857 if (reset_alt_ioc_active && ioc->alt_ioc) {
1858 /* (re)Enable alt-IOC! (reply interrupt) */
1859 dinitprintk((KERN_INFO MYNAM ": alt-%s reply irq re-enabled\n",
1860 ioc->alt_ioc->name));
1861 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
1862 ioc->alt_ioc->active = 1;
1865 /* Enable MPT base driver management of EventNotification
1866 * and EventAck handling.
1868 if ((ret == 0) && (!ioc->facts.EventState))
1869 (void) SendEventNotification(ioc, 1); /* 1=Enable EventNotification */
1871 if (ioc->alt_ioc && alt_ioc_ready && !ioc->alt_ioc->facts.EventState)
1872 (void) SendEventNotification(ioc->alt_ioc, 1); /* 1=Enable EventNotification */
1874 /* Add additional "reason" check before call to GetLanConfigPages
1875 * (combined with GetIoUnitPage2 call). This prevents a somewhat
1876 * recursive scenario; GetLanConfigPages times out, timer expired
1877 * routine calls HardResetHandler, which calls into here again,
1878 * and we try GetLanConfigPages again...
1880 if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP)) {
1881 if (ioc->bus_type == SAS) {
1883 /* clear persistency table */
1884 if(ioc->facts.IOCExceptions &
1885 MPI_IOCFACTS_EXCEPT_PERSISTENT_TABLE_FULL) {
1886 ret = mptbase_sas_persist_operation(ioc,
1887 MPI_SAS_OP_CLEAR_NOT_PRESENT);
1894 mpt_findImVolumes(ioc);
1896 } else if (ioc->bus_type == FC) {
1898 * Pre-fetch FC port WWN and stuff...
1899 * (FCPortPage0_t stuff)
1901 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1902 (void) mptbase_GetFcPortPage0(ioc, ii);
1905 if ((ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) &&
1906 (ioc->lan_cnfg_page0.Header.PageLength == 0)) {
1908 * Pre-fetch the ports LAN MAC address!
1909 * (LANPage1_t stuff)
1911 (void) GetLanConfigPages(ioc);
1914 u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
1915 dprintk((MYIOC_s_INFO_FMT "LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
1916 ioc->name, a[5], a[4], a[3], a[2], a[1], a[0] ));
1921 /* Get NVRAM and adapter maximums from SPP 0 and 2
1923 mpt_GetScsiPortSettings(ioc, 0);
1925 /* Get version and length of SDP 1
1927 mpt_readScsiDevicePageHeaders(ioc, 0);
1931 if (ioc->facts.MsgVersion >= MPI_VERSION_01_02)
1932 mpt_findImVolumes(ioc);
1934 /* Check, and possibly reset, the coalescing value
1936 mpt_read_ioc_pg_1(ioc);
1938 mpt_read_ioc_pg_4(ioc);
1941 GetIoUnitPage2(ioc);
1945 * Call each currently registered protocol IOC reset handler
1946 * with post-reset indication.
1947 * NOTE: If we're doing _IOC_BRINGUP, there can be no
1948 * MptResetHandlers[] registered yet.
1950 if (hard_reset_done) {
1952 for (ii=MPT_MAX_PROTOCOL_DRIVERS-1; ii; ii--) {
1953 if ((ret == 0) && MptResetHandlers[ii]) {
1954 dprintk((MYIOC_s_INFO_FMT "Calling IOC post_reset handler #%d\n",
1956 rc += (*(MptResetHandlers[ii]))(ioc, MPT_IOC_POST_RESET);
1960 if (alt_ioc_ready && MptResetHandlers[ii]) {
1961 drsprintk((MYIOC_s_INFO_FMT "Calling alt-%s post_reset handler #%d\n",
1962 ioc->name, ioc->alt_ioc->name, ii));
1963 rc += (*(MptResetHandlers[ii]))(ioc->alt_ioc, MPT_IOC_POST_RESET);
1967 /* FIXME? Examine results here? */
1973 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1975 * mpt_detect_bound_ports - Search for PCI bus/dev_function
1976 * which matches PCI bus/dev_function (+/-1) for newly discovered 929,
1977 * 929X, 1030 or 1035.
1978 * @ioc: Pointer to MPT adapter structure
1979 * @pdev: Pointer to (struct pci_dev) structure
1981 * If match on PCI dev_function +/-1 is found, bind the two MPT adapters
1982 * using alt_ioc pointer fields in their %MPT_ADAPTER structures.
1985 mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev)
1987 struct pci_dev *peer=NULL;
1988 unsigned int slot = PCI_SLOT(pdev->devfn);
1989 unsigned int func = PCI_FUNC(pdev->devfn);
1990 MPT_ADAPTER *ioc_srch;
1992 dprintk((MYIOC_s_INFO_FMT "PCI device %s devfn=%x/%x,"
1993 " searching for devfn match on %x or %x\n",
1994 ioc->name, pci_name(pdev), pdev->bus->number,
1995 pdev->devfn, func-1, func+1));
1997 peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func-1));
1999 peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func+1));
2004 list_for_each_entry(ioc_srch, &ioc_list, list) {
2005 struct pci_dev *_pcidev = ioc_srch->pcidev;
2006 if (_pcidev == peer) {
2007 /* Paranoia checks */
2008 if (ioc->alt_ioc != NULL) {
2009 printk(KERN_WARNING MYNAM ": Oops, already bound (%s <==> %s)!\n",
2010 ioc->name, ioc->alt_ioc->name);
2012 } else if (ioc_srch->alt_ioc != NULL) {
2013 printk(KERN_WARNING MYNAM ": Oops, already bound (%s <==> %s)!\n",
2014 ioc_srch->name, ioc_srch->alt_ioc->name);
2017 dprintk((KERN_INFO MYNAM ": FOUND! binding %s <==> %s\n",
2018 ioc->name, ioc_srch->name));
2019 ioc_srch->alt_ioc = ioc;
2020 ioc->alt_ioc = ioc_srch;
2026 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2028 * mpt_adapter_disable - Disable misbehaving MPT adapter.
2029 * @this: Pointer to MPT adapter structure
2032 mpt_adapter_disable(MPT_ADAPTER *ioc)
2037 if (ioc->cached_fw != NULL) {
2038 ddlprintk((KERN_INFO MYNAM ": mpt_adapter_disable: Pushing FW onto adapter\n"));
2039 if ((ret = mpt_downloadboot(ioc, (MpiFwHeader_t *)ioc->cached_fw, NO_SLEEP)) < 0) {
2040 printk(KERN_WARNING MYNAM
2041 ": firmware downloadboot failure (%d)!\n", ret);
2045 /* Disable adapter interrupts! */
2046 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
2048 /* Clear any lingering interrupt */
2049 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
2051 if (ioc->alloc != NULL) {
2053 dexitprintk((KERN_INFO MYNAM ": %s.free @ %p, sz=%d bytes\n",
2054 ioc->name, ioc->alloc, ioc->alloc_sz));
2055 pci_free_consistent(ioc->pcidev, sz,
2056 ioc->alloc, ioc->alloc_dma);
2057 ioc->reply_frames = NULL;
2058 ioc->req_frames = NULL;
2060 ioc->alloc_total -= sz;
2063 if (ioc->sense_buf_pool != NULL) {
2064 sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
2065 pci_free_consistent(ioc->pcidev, sz,
2066 ioc->sense_buf_pool, ioc->sense_buf_pool_dma);
2067 ioc->sense_buf_pool = NULL;
2068 ioc->alloc_total -= sz;
2071 if (ioc->events != NULL){
2072 sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
2075 ioc->alloc_total -= sz;
2078 if (ioc->cached_fw != NULL) {
2079 sz = ioc->facts.FWImageSize;
2080 pci_free_consistent(ioc->pcidev, sz,
2081 ioc->cached_fw, ioc->cached_fw_dma);
2082 ioc->cached_fw = NULL;
2083 ioc->alloc_total -= sz;
2086 kfree(ioc->spi_data.nvram);
2087 kfree(ioc->raid_data.pIocPg3);
2088 ioc->spi_data.nvram = NULL;
2089 ioc->raid_data.pIocPg3 = NULL;
2091 if (ioc->spi_data.pIocPg4 != NULL) {
2092 sz = ioc->spi_data.IocPg4Sz;
2093 pci_free_consistent(ioc->pcidev, sz,
2094 ioc->spi_data.pIocPg4,
2095 ioc->spi_data.IocPg4_dma);
2096 ioc->spi_data.pIocPg4 = NULL;
2097 ioc->alloc_total -= sz;
2100 if (ioc->ReqToChain != NULL) {
2101 kfree(ioc->ReqToChain);
2102 kfree(ioc->RequestNB);
2103 ioc->ReqToChain = NULL;
2106 kfree(ioc->ChainToChain);
2107 ioc->ChainToChain = NULL;
2109 if (ioc->HostPageBuffer != NULL) {
2110 if((ret = mpt_host_page_access_control(ioc,
2111 MPI_DB_HPBAC_FREE_BUFFER, NO_SLEEP)) != 0) {
2112 printk(KERN_ERR MYNAM
2113 ": %s: host page buffers free failed (%d)!\n",
2116 dexitprintk((KERN_INFO MYNAM ": %s HostPageBuffer free @ %p, sz=%d bytes\n",
2117 ioc->name, ioc->HostPageBuffer, ioc->HostPageBuffer_sz));
2118 pci_free_consistent(ioc->pcidev, ioc->HostPageBuffer_sz,
2119 ioc->HostPageBuffer,
2120 ioc->HostPageBuffer_dma);
2121 ioc->HostPageBuffer = NULL;
2122 ioc->HostPageBuffer_sz = 0;
2123 ioc->alloc_total -= ioc->HostPageBuffer_sz;
2127 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2129 * mpt_adapter_dispose - Free all resources associated with a MPT
2131 * @ioc: Pointer to MPT adapter structure
2133 * This routine unregisters h/w resources and frees all alloc'd memory
2134 * associated with a MPT adapter structure.
2137 mpt_adapter_dispose(MPT_ADAPTER *ioc)
2139 int sz_first, sz_last;
2144 sz_first = ioc->alloc_total;
2146 mpt_adapter_disable(ioc);
2148 if (ioc->pci_irq != -1) {
2149 free_irq(ioc->pci_irq, ioc);
2151 pci_disable_msi(ioc->pcidev);
2155 if (ioc->memmap != NULL) {
2156 iounmap(ioc->memmap);
2160 #if defined(CONFIG_MTRR) && 0
2161 if (ioc->mtrr_reg > 0) {
2162 mtrr_del(ioc->mtrr_reg, 0, 0);
2163 dprintk((KERN_INFO MYNAM ": %s: MTRR region de-registered\n", ioc->name));
2167 /* Zap the adapter lookup ptr! */
2168 list_del(&ioc->list);
2170 sz_last = ioc->alloc_total;
2171 dprintk((KERN_INFO MYNAM ": %s: free'd %d of %d bytes\n",
2172 ioc->name, sz_first-sz_last+(int)sizeof(*ioc), sz_first));
2175 ioc->alt_ioc->alt_ioc = NULL;
2180 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2182 * MptDisplayIocCapabilities - Disply IOC's capacilities.
2183 * @ioc: Pointer to MPT adapter structure
2186 MptDisplayIocCapabilities(MPT_ADAPTER *ioc)
2190 printk(KERN_INFO "%s: ", ioc->name);
2191 if (ioc->prod_name && strlen(ioc->prod_name) > 3)
2192 printk("%s: ", ioc->prod_name+3);
2193 printk("Capabilities={");
2195 if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_INITIATOR) {
2196 printk("Initiator");
2200 if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
2201 printk("%sTarget", i ? "," : "");
2205 if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) {
2206 printk("%sLAN", i ? "," : "");
2212 * This would probably evoke more questions than it's worth
2214 if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
2215 printk("%sLogBusAddr", i ? "," : "");
2223 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2225 * MakeIocReady - Get IOC to a READY state, using KickStart if needed.
2226 * @ioc: Pointer to MPT_ADAPTER structure
2227 * @force: Force hard KickStart of IOC
2228 * @sleepFlag: Specifies whether the process can sleep
2231 * 1 - DIAG reset and READY
2232 * 0 - READY initially OR soft reset and READY
2233 * -1 - Any failure on KickStart
2234 * -2 - Msg Unit Reset Failed
2235 * -3 - IO Unit Reset Failed
2236 * -4 - IOC owned by a PEER
2239 MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag)
2244 int hard_reset_done = 0;
2249 /* Get current [raw] IOC state */
2250 ioc_state = mpt_GetIocState(ioc, 0);
2251 dhsprintk((KERN_INFO MYNAM "::MakeIocReady, %s [raw] state=%08x\n", ioc->name, ioc_state));
2254 * Check to see if IOC got left/stuck in doorbell handshake
2255 * grip of death. If so, hard reset the IOC.
2257 if (ioc_state & MPI_DOORBELL_ACTIVE) {
2259 printk(MYIOC_s_WARN_FMT "Unexpected doorbell active!\n",
2263 /* Is it already READY? */
2264 if (!statefault && (ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_READY)
2268 * Check to see if IOC is in FAULT state.
2270 if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
2272 printk(MYIOC_s_WARN_FMT "IOC is in FAULT state!!!\n",
2274 printk(KERN_WARNING " FAULT code = %04xh\n",
2275 ioc_state & MPI_DOORBELL_DATA_MASK);
2279 * Hmmm... Did it get left operational?
2281 if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_OPERATIONAL) {
2282 dinitprintk((MYIOC_s_INFO_FMT "IOC operational unexpected\n",
2286 * If PCI Peer, exit.
2287 * Else, if no fault conditions are present, issue a MessageUnitReset
2288 * Else, fall through to KickStart case
2290 whoinit = (ioc_state & MPI_DOORBELL_WHO_INIT_MASK) >> MPI_DOORBELL_WHO_INIT_SHIFT;
2291 dinitprintk((KERN_INFO MYNAM
2292 ": whoinit 0x%x statefault %d force %d\n",
2293 whoinit, statefault, force));
2294 if (whoinit == MPI_WHOINIT_PCI_PEER)
2297 if ((statefault == 0 ) && (force == 0)) {
2298 if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) == 0)
2305 hard_reset_done = KickStart(ioc, statefault||force, sleepFlag);
2306 if (hard_reset_done < 0)
2310 * Loop here waiting for IOC to come READY.
2313 cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 5; /* 5 seconds */
2315 while ((ioc_state = mpt_GetIocState(ioc, 1)) != MPI_IOC_STATE_READY) {
2316 if (ioc_state == MPI_IOC_STATE_OPERATIONAL) {
2318 * BIOS or previous driver load left IOC in OP state.
2319 * Reset messaging FIFOs.
2321 if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) != 0) {
2322 printk(MYIOC_s_ERR_FMT "IOC msg unit reset failed!\n", ioc->name);
2325 } else if (ioc_state == MPI_IOC_STATE_RESET) {
2327 * Something is wrong. Try to get IOC back
2330 if ((r = SendIocReset(ioc, MPI_FUNCTION_IO_UNIT_RESET, sleepFlag)) != 0) {
2331 printk(MYIOC_s_ERR_FMT "IO unit reset failed!\n", ioc->name);
2338 printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
2339 ioc->name, (int)((ii+5)/HZ));
2343 if (sleepFlag == CAN_SLEEP) {
2344 msleep_interruptible(1);
2346 mdelay (1); /* 1 msec delay */
2351 if (statefault < 3) {
2352 printk(MYIOC_s_INFO_FMT "Recovered from %s\n",
2354 statefault==1 ? "stuck handshake" : "IOC FAULT");
2357 return hard_reset_done;
2360 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2362 * mpt_GetIocState - Get the current state of a MPT adapter.
2363 * @ioc: Pointer to MPT_ADAPTER structure
2364 * @cooked: Request raw or cooked IOC state
2366 * Returns all IOC Doorbell register bits if cooked==0, else just the
2367 * Doorbell bits in MPI_IOC_STATE_MASK.
2370 mpt_GetIocState(MPT_ADAPTER *ioc, int cooked)
2375 s = CHIPREG_READ32(&ioc->chip->Doorbell);
2376 // dprintk((MYIOC_s_INFO_FMT "raw state = %08x\n", ioc->name, s));
2377 sc = s & MPI_IOC_STATE_MASK;
2380 ioc->last_state = sc;
2382 return cooked ? sc : s;
2385 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2387 * GetIocFacts - Send IOCFacts request to MPT adapter.
2388 * @ioc: Pointer to MPT_ADAPTER structure
2389 * @sleepFlag: Specifies whether the process can sleep
2390 * @reason: If recovery, only update facts.
2392 * Returns 0 for success, non-zero for failure.
2395 GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason)
2397 IOCFacts_t get_facts;
2398 IOCFactsReply_t *facts;
2406 /* IOC *must* NOT be in RESET state! */
2407 if (ioc->last_state == MPI_IOC_STATE_RESET) {
2408 printk(KERN_ERR MYNAM ": ERROR - Can't get IOCFacts, %s NOT READY! (%08x)\n",
2414 facts = &ioc->facts;
2416 /* Destination (reply area)... */
2417 reply_sz = sizeof(*facts);
2418 memset(facts, 0, reply_sz);
2420 /* Request area (get_facts on the stack right now!) */
2421 req_sz = sizeof(get_facts);
2422 memset(&get_facts, 0, req_sz);
2424 get_facts.Function = MPI_FUNCTION_IOC_FACTS;
2425 /* Assert: All other get_facts fields are zero! */
2427 dinitprintk((MYIOC_s_INFO_FMT
2428 "Sending get IocFacts request req_sz=%d reply_sz=%d\n",
2429 ioc->name, req_sz, reply_sz));
2431 /* No non-zero fields in the get_facts request are greater than
2432 * 1 byte in size, so we can just fire it off as is.
2434 r = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_facts,
2435 reply_sz, (u16*)facts, 5 /*seconds*/, sleepFlag);
2440 * Now byte swap (GRRR) the necessary fields before any further
2441 * inspection of reply contents.
2443 * But need to do some sanity checks on MsgLength (byte) field
2444 * to make sure we don't zero IOC's req_sz!
2446 /* Did we get a valid reply? */
2447 if (facts->MsgLength > offsetof(IOCFactsReply_t, RequestFrameSize)/sizeof(u32)) {
2448 if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2450 * If not been here, done that, save off first WhoInit value
2452 if (ioc->FirstWhoInit == WHOINIT_UNKNOWN)
2453 ioc->FirstWhoInit = facts->WhoInit;
2456 facts->MsgVersion = le16_to_cpu(facts->MsgVersion);
2457 facts->MsgContext = le32_to_cpu(facts->MsgContext);
2458 facts->IOCExceptions = le16_to_cpu(facts->IOCExceptions);
2459 facts->IOCStatus = le16_to_cpu(facts->IOCStatus);
2460 facts->IOCLogInfo = le32_to_cpu(facts->IOCLogInfo);
2461 status = le16_to_cpu(facts->IOCStatus) & MPI_IOCSTATUS_MASK;
2462 /* CHECKME! IOCStatus, IOCLogInfo */
2464 facts->ReplyQueueDepth = le16_to_cpu(facts->ReplyQueueDepth);
2465 facts->RequestFrameSize = le16_to_cpu(facts->RequestFrameSize);
2468 * FC f/w version changed between 1.1 and 1.2
2469 * Old: u16{Major(4),Minor(4),SubMinor(8)}
2470 * New: u32{Major(8),Minor(8),Unit(8),Dev(8)}
2472 if (facts->MsgVersion < 0x0102) {
2474 * Handle old FC f/w style, convert to new...
2476 u16 oldv = le16_to_cpu(facts->Reserved_0101_FWVersion);
2477 facts->FWVersion.Word =
2478 ((oldv<<12) & 0xFF000000) |
2479 ((oldv<<8) & 0x000FFF00);
2481 facts->FWVersion.Word = le32_to_cpu(facts->FWVersion.Word);
2483 facts->ProductID = le16_to_cpu(facts->ProductID);
2484 facts->CurrentHostMfaHighAddr =
2485 le32_to_cpu(facts->CurrentHostMfaHighAddr);
2486 facts->GlobalCredits = le16_to_cpu(facts->GlobalCredits);
2487 facts->CurrentSenseBufferHighAddr =
2488 le32_to_cpu(facts->CurrentSenseBufferHighAddr);
2489 facts->CurReplyFrameSize =
2490 le16_to_cpu(facts->CurReplyFrameSize);
2491 facts->IOCCapabilities = le32_to_cpu(facts->IOCCapabilities);
2494 * Handle NEW (!) IOCFactsReply fields in MPI-1.01.xx
2495 * Older MPI-1.00.xx struct had 13 dwords, and enlarged
2496 * to 14 in MPI-1.01.0x.
2498 if (facts->MsgLength >= (offsetof(IOCFactsReply_t,FWImageSize) + 7)/4 &&
2499 facts->MsgVersion > 0x0100) {
2500 facts->FWImageSize = le32_to_cpu(facts->FWImageSize);
2503 sz = facts->FWImageSize;
2508 facts->FWImageSize = sz;
2510 if (!facts->RequestFrameSize) {
2511 /* Something is wrong! */
2512 printk(MYIOC_s_ERR_FMT "IOC reported invalid 0 request size!\n",
2517 r = sz = facts->BlockSize;
2518 vv = ((63 / (sz * 4)) + 1) & 0x03;
2519 ioc->NB_for_64_byte_frame = vv;
2525 ioc->NBShiftFactor = shiftFactor;
2526 dinitprintk((MYIOC_s_INFO_FMT "NB_for_64_byte_frame=%x NBShiftFactor=%x BlockSize=%x\n",
2527 ioc->name, vv, shiftFactor, r));
2529 if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2531 * Set values for this IOC's request & reply frame sizes,
2532 * and request & reply queue depths...
2534 ioc->req_sz = min(MPT_DEFAULT_FRAME_SIZE, facts->RequestFrameSize * 4);
2535 ioc->req_depth = min_t(int, MPT_MAX_REQ_DEPTH, facts->GlobalCredits);
2536 ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
2537 ioc->reply_depth = min_t(int, MPT_DEFAULT_REPLY_DEPTH, facts->ReplyQueueDepth);
2539 dinitprintk((MYIOC_s_INFO_FMT "reply_sz=%3d, reply_depth=%4d\n",
2540 ioc->name, ioc->reply_sz, ioc->reply_depth));
2541 dinitprintk((MYIOC_s_INFO_FMT "req_sz =%3d, req_depth =%4d\n",
2542 ioc->name, ioc->req_sz, ioc->req_depth));
2544 /* Get port facts! */
2545 if ( (r = GetPortFacts(ioc, 0, sleepFlag)) != 0 )
2549 printk(MYIOC_s_ERR_FMT
2550 "Invalid IOC facts reply, msgLength=%d offsetof=%zd!\n",
2551 ioc->name, facts->MsgLength, (offsetof(IOCFactsReply_t,
2552 RequestFrameSize)/sizeof(u32)));
2559 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2561 * GetPortFacts - Send PortFacts request to MPT adapter.
2562 * @ioc: Pointer to MPT_ADAPTER structure
2563 * @portnum: Port number
2564 * @sleepFlag: Specifies whether the process can sleep
2566 * Returns 0 for success, non-zero for failure.
2569 GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
2571 PortFacts_t get_pfacts;
2572 PortFactsReply_t *pfacts;
2577 /* IOC *must* NOT be in RESET state! */
2578 if (ioc->last_state == MPI_IOC_STATE_RESET) {
2579 printk(KERN_ERR MYNAM ": ERROR - Can't get PortFacts, %s NOT READY! (%08x)\n",
2585 pfacts = &ioc->pfacts[portnum];
2587 /* Destination (reply area)... */
2588 reply_sz = sizeof(*pfacts);
2589 memset(pfacts, 0, reply_sz);
2591 /* Request area (get_pfacts on the stack right now!) */
2592 req_sz = sizeof(get_pfacts);
2593 memset(&get_pfacts, 0, req_sz);
2595 get_pfacts.Function = MPI_FUNCTION_PORT_FACTS;
2596 get_pfacts.PortNumber = portnum;
2597 /* Assert: All other get_pfacts fields are zero! */
2599 dinitprintk((MYIOC_s_INFO_FMT "Sending get PortFacts(%d) request\n",
2600 ioc->name, portnum));
2602 /* No non-zero fields in the get_pfacts request are greater than
2603 * 1 byte in size, so we can just fire it off as is.
2605 ii = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_pfacts,
2606 reply_sz, (u16*)pfacts, 5 /*seconds*/, sleepFlag);
2610 /* Did we get a valid reply? */
2612 /* Now byte swap the necessary fields in the response. */
2613 pfacts->MsgContext = le32_to_cpu(pfacts->MsgContext);
2614 pfacts->IOCStatus = le16_to_cpu(pfacts->IOCStatus);
2615 pfacts->IOCLogInfo = le32_to_cpu(pfacts->IOCLogInfo);
2616 pfacts->MaxDevices = le16_to_cpu(pfacts->MaxDevices);
2617 pfacts->PortSCSIID = le16_to_cpu(pfacts->PortSCSIID);
2618 pfacts->ProtocolFlags = le16_to_cpu(pfacts->ProtocolFlags);
2619 pfacts->MaxPostedCmdBuffers = le16_to_cpu(pfacts->MaxPostedCmdBuffers);
2620 pfacts->MaxPersistentIDs = le16_to_cpu(pfacts->MaxPersistentIDs);
2621 pfacts->MaxLanBuckets = le16_to_cpu(pfacts->MaxLanBuckets);
2626 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2628 * SendIocInit - Send IOCInit request to MPT adapter.
2629 * @ioc: Pointer to MPT_ADAPTER structure
2630 * @sleepFlag: Specifies whether the process can sleep
2632 * Send IOCInit followed by PortEnable to bring IOC to OPERATIONAL state.
2634 * Returns 0 for success, non-zero for failure.
2637 SendIocInit(MPT_ADAPTER *ioc, int sleepFlag)
2640 MPIDefaultReply_t init_reply;
2646 memset(&ioc_init, 0, sizeof(ioc_init));
2647 memset(&init_reply, 0, sizeof(init_reply));
2649 ioc_init.WhoInit = MPI_WHOINIT_HOST_DRIVER;
2650 ioc_init.Function = MPI_FUNCTION_IOC_INIT;
2652 /* If we are in a recovery mode and we uploaded the FW image,
2653 * then this pointer is not NULL. Skip the upload a second time.
2654 * Set this flag if cached_fw set for either IOC.
2656 if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)
2660 ddlprintk((MYIOC_s_INFO_FMT "upload_fw %d facts.Flags=%x\n",
2661 ioc->name, ioc->upload_fw, ioc->facts.Flags));
2663 if(ioc->bus_type == SAS)
2664 ioc_init.MaxDevices = ioc->facts.MaxDevices;
2665 else if(ioc->bus_type == FC)
2666 ioc_init.MaxDevices = MPT_MAX_FC_DEVICES;
2668 ioc_init.MaxDevices = MPT_MAX_SCSI_DEVICES;
2669 ioc_init.MaxBuses = MPT_MAX_BUS;
2670 dinitprintk((MYIOC_s_INFO_FMT "facts.MsgVersion=%x\n",
2671 ioc->name, ioc->facts.MsgVersion));
2672 if (ioc->facts.MsgVersion >= MPI_VERSION_01_05) {
2673 // set MsgVersion and HeaderVersion host driver was built with
2674 ioc_init.MsgVersion = cpu_to_le16(MPI_VERSION);
2675 ioc_init.HeaderVersion = cpu_to_le16(MPI_HEADER_VERSION);
2677 if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_HOST_PAGE_BUFFER_PERSISTENT) {
2678 ioc_init.HostPageBufferSGE = ioc->facts.HostPageBufferSGE;
2679 } else if(mpt_host_page_alloc(ioc, &ioc_init))
2682 ioc_init.ReplyFrameSize = cpu_to_le16(ioc->reply_sz); /* in BYTES */
2684 if (sizeof(dma_addr_t) == sizeof(u64)) {
2685 /* Save the upper 32-bits of the request
2686 * (reply) and sense buffers.
2688 ioc_init.HostMfaHighAddr = cpu_to_le32((u32)((u64)ioc->alloc_dma >> 32));
2689 ioc_init.SenseBufferHighAddr = cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
2691 /* Force 32-bit addressing */
2692 ioc_init.HostMfaHighAddr = cpu_to_le32(0);
2693 ioc_init.SenseBufferHighAddr = cpu_to_le32(0);
2696 ioc->facts.CurrentHostMfaHighAddr = ioc_init.HostMfaHighAddr;
2697 ioc->facts.CurrentSenseBufferHighAddr = ioc_init.SenseBufferHighAddr;
2698 ioc->facts.MaxDevices = ioc_init.MaxDevices;
2699 ioc->facts.MaxBuses = ioc_init.MaxBuses;
2701 dhsprintk((MYIOC_s_INFO_FMT "Sending IOCInit (req @ %p)\n",
2702 ioc->name, &ioc_init));
2704 r = mpt_handshake_req_reply_wait(ioc, sizeof(IOCInit_t), (u32*)&ioc_init,
2705 sizeof(MPIDefaultReply_t), (u16*)&init_reply, 10 /*seconds*/, sleepFlag);
2707 printk(MYIOC_s_ERR_FMT "Sending IOCInit failed(%d)!\n",ioc->name, r);
2711 /* No need to byte swap the multibyte fields in the reply
2712 * since we don't even look at it's contents.
2715 dhsprintk((MYIOC_s_INFO_FMT "Sending PortEnable (req @ %p)\n",
2716 ioc->name, &ioc_init));
2718 if ((r = SendPortEnable(ioc, 0, sleepFlag)) != 0) {
2719 printk(MYIOC_s_ERR_FMT "Sending PortEnable failed(%d)!\n",ioc->name, r);
2723 /* YIKES! SUPER IMPORTANT!!!
2724 * Poll IocState until _OPERATIONAL while IOC is doing
2725 * LoopInit and TargetDiscovery!
2728 cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 60; /* 60 seconds */
2729 state = mpt_GetIocState(ioc, 1);
2730 while (state != MPI_IOC_STATE_OPERATIONAL && --cntdn) {
2731 if (sleepFlag == CAN_SLEEP) {
2732 msleep_interruptible(1);
2738 printk(MYIOC_s_ERR_FMT "Wait IOC_OP state timeout(%d)!\n",
2739 ioc->name, (int)((count+5)/HZ));
2743 state = mpt_GetIocState(ioc, 1);
2746 dinitprintk((MYIOC_s_INFO_FMT "INFO - Wait IOC_OPERATIONAL state (cnt=%d)\n",
2752 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2754 * SendPortEnable - Send PortEnable request to MPT adapter port.
2755 * @ioc: Pointer to MPT_ADAPTER structure
2756 * @portnum: Port number to enable
2757 * @sleepFlag: Specifies whether the process can sleep
2759 * Send PortEnable to bring IOC to OPERATIONAL state.
2761 * Returns 0 for success, non-zero for failure.
2764 SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
2766 PortEnable_t port_enable;
2767 MPIDefaultReply_t reply_buf;
2772 /* Destination... */
2773 reply_sz = sizeof(MPIDefaultReply_t);
2774 memset(&reply_buf, 0, reply_sz);
2776 req_sz = sizeof(PortEnable_t);
2777 memset(&port_enable, 0, req_sz);
2779 port_enable.Function = MPI_FUNCTION_PORT_ENABLE;
2780 port_enable.PortNumber = portnum;
2781 /* port_enable.ChainOffset = 0; */
2782 /* port_enable.MsgFlags = 0; */
2783 /* port_enable.MsgContext = 0; */
2785 dinitprintk((MYIOC_s_INFO_FMT "Sending Port(%d)Enable (req @ %p)\n",
2786 ioc->name, portnum, &port_enable));
2788 /* RAID FW may take a long time to enable
2790 if (((ioc->facts.ProductID & MPI_FW_HEADER_PID_PROD_MASK)
2791 > MPI_FW_HEADER_PID_PROD_TARGET_SCSI) ||
2792 (ioc->bus_type == SAS)) {
2793 rc = mpt_handshake_req_reply_wait(ioc, req_sz,
2794 (u32*)&port_enable, reply_sz, (u16*)&reply_buf,
2795 300 /*seconds*/, sleepFlag);
2797 rc = mpt_handshake_req_reply_wait(ioc, req_sz,
2798 (u32*)&port_enable, reply_sz, (u16*)&reply_buf,
2799 30 /*seconds*/, sleepFlag);
2805 * ioc: Pointer to MPT_ADAPTER structure
2806 * size - total FW bytes
2809 mpt_alloc_fw_memory(MPT_ADAPTER *ioc, int size)
2812 return; /* use already allocated memory */
2813 if (ioc->alt_ioc && ioc->alt_ioc->cached_fw) {
2814 ioc->cached_fw = ioc->alt_ioc->cached_fw; /* use alt_ioc's memory */
2815 ioc->cached_fw_dma = ioc->alt_ioc->cached_fw_dma;
2817 if ( (ioc->cached_fw = pci_alloc_consistent(ioc->pcidev, size, &ioc->cached_fw_dma) ) )
2818 ioc->alloc_total += size;
2822 * If alt_img is NULL, delete from ioc structure.
2823 * Else, delete a secondary image in same format.
2826 mpt_free_fw_memory(MPT_ADAPTER *ioc)
2830 sz = ioc->facts.FWImageSize;
2831 dinitprintk((KERN_INFO MYNAM "free_fw_memory: FW Image @ %p[%p], sz=%d[%x] bytes\n",
2832 ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
2833 pci_free_consistent(ioc->pcidev, sz,
2834 ioc->cached_fw, ioc->cached_fw_dma);
2835 ioc->cached_fw = NULL;
2841 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2843 * mpt_do_upload - Construct and Send FWUpload request to MPT adapter port.
2844 * @ioc: Pointer to MPT_ADAPTER structure
2845 * @sleepFlag: Specifies whether the process can sleep
2847 * Returns 0 for success, >0 for handshake failure
2848 * <0 for fw upload failure.
2850 * Remark: If bound IOC and a successful FWUpload was performed
2851 * on the bound IOC, the second image is discarded
2852 * and memory is free'd. Both channels must upload to prevent
2853 * IOC from running in degraded mode.
2856 mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag)
2858 u8 request[ioc->req_sz];
2859 u8 reply[sizeof(FWUploadReply_t)];
2860 FWUpload_t *prequest;
2861 FWUploadReply_t *preply;
2862 FWUploadTCSGE_t *ptcsge;
2865 int ii, sz, reply_sz;
2868 /* If the image size is 0, we are done.
2870 if ((sz = ioc->facts.FWImageSize) == 0)
2873 mpt_alloc_fw_memory(ioc, sz);
2875 dinitprintk((KERN_INFO MYNAM ": FW Image @ %p[%p], sz=%d[%x] bytes\n",
2876 ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
2878 if (ioc->cached_fw == NULL) {
2884 prequest = (FWUpload_t *)&request;
2885 preply = (FWUploadReply_t *)&reply;
2887 /* Destination... */
2888 memset(prequest, 0, ioc->req_sz);
2890 reply_sz = sizeof(reply);
2891 memset(preply, 0, reply_sz);
2893 prequest->ImageType = MPI_FW_UPLOAD_ITYPE_FW_IOC_MEM;
2894 prequest->Function = MPI_FUNCTION_FW_UPLOAD;
2896 ptcsge = (FWUploadTCSGE_t *) &prequest->SGL;
2897 ptcsge->DetailsLength = 12;
2898 ptcsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
2899 ptcsge->ImageSize = cpu_to_le32(sz);
2901 sgeoffset = sizeof(FWUpload_t) - sizeof(SGE_MPI_UNION) + sizeof(FWUploadTCSGE_t);
2903 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ | sz;
2904 mpt_add_sge(&request[sgeoffset], flagsLength, ioc->cached_fw_dma);
2906 sgeoffset += sizeof(u32) + sizeof(dma_addr_t);
2907 dinitprintk((KERN_INFO MYNAM ": Sending FW Upload (req @ %p) sgeoffset=%d \n",
2908 prequest, sgeoffset));
2909 DBG_DUMP_FW_REQUEST_FRAME(prequest)
2911 ii = mpt_handshake_req_reply_wait(ioc, sgeoffset, (u32*)prequest,
2912 reply_sz, (u16*)preply, 65 /*seconds*/, sleepFlag);
2914 dinitprintk((KERN_INFO MYNAM ": FW Upload completed rc=%x \n", ii));
2916 cmdStatus = -EFAULT;
2918 /* Handshake transfer was complete and successful.
2919 * Check the Reply Frame.
2921 int status, transfer_sz;
2922 status = le16_to_cpu(preply->IOCStatus);
2923 if (status == MPI_IOCSTATUS_SUCCESS) {
2924 transfer_sz = le32_to_cpu(preply->ActualImageSize);
2925 if (transfer_sz == sz)
2929 dinitprintk((MYIOC_s_INFO_FMT ": do_upload cmdStatus=%d \n",
2930 ioc->name, cmdStatus));
2935 ddlprintk((MYIOC_s_INFO_FMT ": fw upload failed, freeing image \n",
2937 mpt_free_fw_memory(ioc);
2943 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2945 * mpt_downloadboot - DownloadBoot code
2946 * @ioc: Pointer to MPT_ADAPTER structure
2947 * @flag: Specify which part of IOC memory is to be uploaded.
2948 * @sleepFlag: Specifies whether the process can sleep
2950 * FwDownloadBoot requires Programmed IO access.
2952 * Returns 0 for success
2953 * -1 FW Image size is 0
2954 * -2 No valid cached_fw Pointer
2955 * <0 for fw upload failure.
2958 mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag)
2960 MpiExtImageHeader_t *pExtImage;
2970 ddlprintk((MYIOC_s_INFO_FMT "downloadboot: fw size 0x%x (%d), FW Ptr %p\n",
2971 ioc->name, pFwHeader->ImageSize, pFwHeader->ImageSize, pFwHeader));
2973 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
2974 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
2975 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
2976 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
2977 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
2978 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
2980 CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM));
2983 if (sleepFlag == CAN_SLEEP) {
2984 msleep_interruptible(1);
2989 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
2990 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
2992 for (count = 0; count < 30; count ++) {
2993 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
2994 if (!(diag0val & MPI_DIAG_RESET_ADAPTER)) {
2995 ddlprintk((MYIOC_s_INFO_FMT "RESET_ADAPTER cleared, count=%d\n",
3000 if (sleepFlag == CAN_SLEEP) {
3001 msleep_interruptible (100);
3007 if ( count == 30 ) {
3008 ddlprintk((MYIOC_s_INFO_FMT "downloadboot failed! "
3009 "Unable to get MPI_DIAG_DRWE mode, diag0val=%x\n",
3010 ioc->name, diag0val));
3014 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3015 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
3016 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
3017 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
3018 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
3019 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3021 /* Set the DiagRwEn and Disable ARM bits */
3022 CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_RW_ENABLE | MPI_DIAG_DISABLE_ARM));
3024 fwSize = (pFwHeader->ImageSize + 3)/4;
3025 ptrFw = (u32 *) pFwHeader;
3027 /* Write the LoadStartAddress to the DiagRw Address Register
3028 * using Programmed IO
3030 if (ioc->errata_flag_1064)
3031 pci_enable_io_access(ioc->pcidev);
3033 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->LoadStartAddress);
3034 ddlprintk((MYIOC_s_INFO_FMT "LoadStart addr written 0x%x \n",
3035 ioc->name, pFwHeader->LoadStartAddress));
3037 ddlprintk((MYIOC_s_INFO_FMT "Write FW Image: 0x%x bytes @ %p\n",
3038 ioc->name, fwSize*4, ptrFw));
3040 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
3043 nextImage = pFwHeader->NextImageHeaderOffset;
3045 pExtImage = (MpiExtImageHeader_t *) ((char *)pFwHeader + nextImage);
3047 load_addr = pExtImage->LoadStartAddress;
3049 fwSize = (pExtImage->ImageSize + 3) >> 2;
3050 ptrFw = (u32 *)pExtImage;
3052 ddlprintk((MYIOC_s_INFO_FMT "Write Ext Image: 0x%x (%d) bytes @ %p load_addr=%x\n",
3053 ioc->name, fwSize*4, fwSize*4, ptrFw, load_addr));
3054 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, load_addr);
3057 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
3059 nextImage = pExtImage->NextImageHeaderOffset;
3062 /* Write the IopResetVectorRegAddr */
3063 ddlprintk((MYIOC_s_INFO_FMT "Write IopResetVector Addr=%x! \n", ioc->name, pFwHeader->IopResetRegAddr));
3064 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->IopResetRegAddr);
3066 /* Write the IopResetVectorValue */
3067 ddlprintk((MYIOC_s_INFO_FMT "Write IopResetVector Value=%x! \n", ioc->name, pFwHeader->IopResetVectorValue));
3068 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, pFwHeader->IopResetVectorValue);
3070 /* Clear the internal flash bad bit - autoincrementing register,
3071 * so must do two writes.
3073 if (ioc->bus_type == SPI) {
3075 * 1030 and 1035 H/W errata, workaround to access
3076 * the ClearFlashBadSignatureBit
3078 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
3079 diagRwData = CHIPREG_PIO_READ32(&ioc->pio_chip->DiagRwData);
3080 diagRwData |= 0x40000000;
3081 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
3082 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, diagRwData);
3084 } else /* if((ioc->bus_type == SAS) || (ioc->bus_type == FC)) */ {
3085 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3086 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val |
3087 MPI_DIAG_CLEAR_FLASH_BAD_SIG);
3090 if (sleepFlag == CAN_SLEEP) {
3091 msleep_interruptible (1);
3097 if (ioc->errata_flag_1064)
3098 pci_disable_io_access(ioc->pcidev);
3100 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3101 ddlprintk((MYIOC_s_INFO_FMT "downloadboot diag0val=%x, "
3102 "turning off PREVENT_IOC_BOOT, DISABLE_ARM, RW_ENABLE\n",
3103 ioc->name, diag0val));
3104 diag0val &= ~(MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM | MPI_DIAG_RW_ENABLE);
3105 ddlprintk((MYIOC_s_INFO_FMT "downloadboot now diag0val=%x\n",
3106 ioc->name, diag0val));
3107 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
3109 /* Write 0xFF to reset the sequencer */
3110 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3112 if (ioc->bus_type == SAS) {
3113 ioc_state = mpt_GetIocState(ioc, 0);
3114 if ( (GetIocFacts(ioc, sleepFlag,
3115 MPT_HOSTEVENT_IOC_BRINGUP)) != 0 ) {
3116 ddlprintk((MYIOC_s_INFO_FMT "GetIocFacts failed: IocState=%x\n",
3117 ioc->name, ioc_state));
3122 for (count=0; count<HZ*20; count++) {
3123 if ((ioc_state = mpt_GetIocState(ioc, 0)) & MPI_IOC_STATE_READY) {
3124 ddlprintk((MYIOC_s_INFO_FMT "downloadboot successful! (count=%d) IocState=%x\n",
3125 ioc->name, count, ioc_state));
3126 if (ioc->bus_type == SAS) {
3129 if ((SendIocInit(ioc, sleepFlag)) != 0) {
3130 ddlprintk((MYIOC_s_INFO_FMT "downloadboot: SendIocInit failed\n",
3134 ddlprintk((MYIOC_s_INFO_FMT "downloadboot: SendIocInit successful\n",
3138 if (sleepFlag == CAN_SLEEP) {
3139 msleep_interruptible (10);
3144 ddlprintk((MYIOC_s_INFO_FMT "downloadboot failed! IocState=%x\n",
3145 ioc->name, ioc_state));
3149 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3151 * KickStart - Perform hard reset of MPT adapter.
3152 * @ioc: Pointer to MPT_ADAPTER structure
3153 * @force: Force hard reset
3154 * @sleepFlag: Specifies whether the process can sleep
3156 * This routine places MPT adapter in diagnostic mode via the
3157 * WriteSequence register, and then performs a hard reset of adapter
3158 * via the Diagnostic register.
3160 * Inputs: sleepflag - CAN_SLEEP (non-interrupt thread)
3161 * or NO_SLEEP (interrupt thread, use mdelay)
3162 * force - 1 if doorbell active, board fault state
3163 * board operational, IOC_RECOVERY or
3164 * IOC_BRINGUP and there is an alt_ioc.
3168 * 1 - hard reset, READY
3169 * 0 - no reset due to History bit, READY
3170 * -1 - no reset due to History bit but not READY
3171 * OR reset but failed to come READY
3172 * -2 - no reset, could not enter DIAG mode
3173 * -3 - reset but bad FW bit
3176 KickStart(MPT_ADAPTER *ioc, int force, int sleepFlag)
3178 int hard_reset_done = 0;
3182 dinitprintk((KERN_WARNING MYNAM ": KickStarting %s!\n", ioc->name));
3183 if (ioc->bus_type == SPI) {
3184 /* Always issue a Msg Unit Reset first. This will clear some
3185 * SCSI bus hang conditions.
3187 SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag);
3189 if (sleepFlag == CAN_SLEEP) {
3190 msleep_interruptible (1000);
3196 hard_reset_done = mpt_diag_reset(ioc, force, sleepFlag);
3197 if (hard_reset_done < 0)
3198 return hard_reset_done;
3200 dinitprintk((MYIOC_s_INFO_FMT "Diagnostic reset successful!\n",
3203 cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 2; /* 2 seconds */
3204 for (cnt=0; cnt<cntdn; cnt++) {
3205 ioc_state = mpt_GetIocState(ioc, 1);
3206 if ((ioc_state == MPI_IOC_STATE_READY) || (ioc_state == MPI_IOC_STATE_OPERATIONAL)) {
3207 dinitprintk((MYIOC_s_INFO_FMT "KickStart successful! (cnt=%d)\n",
3209 return hard_reset_done;
3211 if (sleepFlag == CAN_SLEEP) {
3212 msleep_interruptible (10);
3218 printk(MYIOC_s_ERR_FMT "Failed to come READY after reset! IocState=%x\n",
3219 ioc->name, ioc_state);
3223 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3225 * mpt_diag_reset - Perform hard reset of the adapter.
3226 * @ioc: Pointer to MPT_ADAPTER structure
3227 * @ignore: Set if to honor and clear to ignore
3228 * the reset history bit
3229 * @sleepflag: CAN_SLEEP if called in a non-interrupt thread,
3230 * else set to NO_SLEEP (use mdelay instead)
3232 * This routine places the adapter in diagnostic mode via the
3233 * WriteSequence register and then performs a hard reset of adapter
3234 * via the Diagnostic register. Adapter should be in ready state
3235 * upon successful completion.
3237 * Returns: 1 hard reset successful
3238 * 0 no reset performed because reset history bit set
3239 * -2 enabling diagnostic mode failed
3240 * -3 diagnostic reset failed
3243 mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag)
3247 int hard_reset_done = 0;
3253 /* Clear any existing interrupts */
3254 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
3256 /* Use "Diagnostic reset" method! (only thing available!) */
3257 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3261 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3262 dprintk((MYIOC_s_INFO_FMT "DbG1: diag0=%08x, diag1=%08x\n",
3263 ioc->name, diag0val, diag1val));
3266 /* Do the reset if we are told to ignore the reset history
3267 * or if the reset history is 0
3269 if (ignore || !(diag0val & MPI_DIAG_RESET_HISTORY)) {
3270 while ((diag0val & MPI_DIAG_DRWE) == 0) {
3271 /* Write magic sequence to WriteSequence register
3272 * Loop until in diagnostic mode
3274 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3275 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
3276 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
3277 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
3278 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
3279 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3282 if (sleepFlag == CAN_SLEEP) {
3283 msleep_interruptible (100);
3290 printk(MYIOC_s_ERR_FMT "Enable Diagnostic mode FAILED! (%02xh)\n",
3291 ioc->name, diag0val);
3296 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3298 dprintk((MYIOC_s_INFO_FMT "Wrote magic DiagWriteEn sequence (%x)\n",
3299 ioc->name, diag0val));
3304 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3305 dprintk((MYIOC_s_INFO_FMT "DbG2: diag0=%08x, diag1=%08x\n",
3306 ioc->name, diag0val, diag1val));
3309 * Disable the ARM (Bug fix)
3312 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_DISABLE_ARM);
3316 * Now hit the reset bit in the Diagnostic register
3317 * (THE BIG HAMMER!) (Clears DRWE bit).
3319 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
3320 hard_reset_done = 1;
3321 dprintk((MYIOC_s_INFO_FMT "Diagnostic reset performed\n",
3325 * Call each currently registered protocol IOC reset handler
3326 * with pre-reset indication.
3327 * NOTE: If we're doing _IOC_BRINGUP, there can be no
3328 * MptResetHandlers[] registered yet.
3334 for (ii=MPT_MAX_PROTOCOL_DRIVERS-1; ii; ii--) {
3335 if (MptResetHandlers[ii]) {
3336 dprintk((MYIOC_s_INFO_FMT "Calling IOC pre_reset handler #%d\n",
3338 r += (*(MptResetHandlers[ii]))(ioc, MPT_IOC_PRE_RESET);
3340 dprintk((MYIOC_s_INFO_FMT "Calling alt-%s pre_reset handler #%d\n",
3341 ioc->name, ioc->alt_ioc->name, ii));
3342 r += (*(MptResetHandlers[ii]))(ioc->alt_ioc, MPT_IOC_PRE_RESET);
3346 /* FIXME? Examine results here? */
3349 if (ioc->cached_fw) {
3350 /* If the DownloadBoot operation fails, the
3351 * IOC will be left unusable. This is a fatal error
3352 * case. _diag_reset will return < 0
3354 for (count = 0; count < 30; count ++) {
3355 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3356 if (!(diag0val & MPI_DIAG_RESET_ADAPTER)) {
3361 if (sleepFlag == CAN_SLEEP) {
3362 msleep_interruptible (1000);
3367 if ((count = mpt_downloadboot(ioc,
3368 (MpiFwHeader_t *)ioc->cached_fw, sleepFlag)) < 0) {
3369 printk(KERN_WARNING MYNAM
3370 ": firmware downloadboot failure (%d)!\n", count);
3374 /* Wait for FW to reload and for board
3375 * to go to the READY state.
3376 * Maximum wait is 60 seconds.
3377 * If fail, no error will check again
3378 * with calling program.
3380 for (count = 0; count < 60; count ++) {
3381 doorbell = CHIPREG_READ32(&ioc->chip->Doorbell);
3382 doorbell &= MPI_IOC_STATE_MASK;
3384 if (doorbell == MPI_IOC_STATE_READY) {
3389 if (sleepFlag == CAN_SLEEP) {
3390 msleep_interruptible (1000);
3398 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3401 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3402 dprintk((MYIOC_s_INFO_FMT "DbG3: diag0=%08x, diag1=%08x\n",
3403 ioc->name, diag0val, diag1val));
3406 /* Clear RESET_HISTORY bit! Place board in the
3407 * diagnostic mode to update the diag register.
3409 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3411 while ((diag0val & MPI_DIAG_DRWE) == 0) {
3412 /* Write magic sequence to WriteSequence register
3413 * Loop until in diagnostic mode
3415 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3416 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
3417 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
3418 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
3419 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
3420 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3423 if (sleepFlag == CAN_SLEEP) {
3424 msleep_interruptible (100);
3431 printk(MYIOC_s_ERR_FMT "Enable Diagnostic mode FAILED! (%02xh)\n",
3432 ioc->name, diag0val);
3435 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3437 diag0val &= ~MPI_DIAG_RESET_HISTORY;
3438 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
3439 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3440 if (diag0val & MPI_DIAG_RESET_HISTORY) {
3441 printk(MYIOC_s_WARN_FMT "ResetHistory bit failed to clear!\n",
3445 /* Disable Diagnostic Mode
3447 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFFFFFFFF);
3449 /* Check FW reload status flags.
3451 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3452 if (diag0val & (MPI_DIAG_FLASH_BAD_SIG | MPI_DIAG_RESET_ADAPTER | MPI_DIAG_DISABLE_ARM)) {
3453 printk(MYIOC_s_ERR_FMT "Diagnostic reset FAILED! (%02xh)\n",
3454 ioc->name, diag0val);
3460 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3461 dprintk((MYIOC_s_INFO_FMT "DbG4: diag0=%08x, diag1=%08x\n",
3462 ioc->name, diag0val, diag1val));
3466 * Reset flag that says we've enabled event notification
3468 ioc->facts.EventState = 0;
3471 ioc->alt_ioc->facts.EventState = 0;
3473 return hard_reset_done;
3476 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3478 * SendIocReset - Send IOCReset request to MPT adapter.
3479 * @ioc: Pointer to MPT_ADAPTER structure
3480 * @reset_type: reset type, expected values are
3481 * %MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET or %MPI_FUNCTION_IO_UNIT_RESET
3483 * Send IOCReset request to the MPT adapter.
3485 * Returns 0 for success, non-zero for failure.
3488 SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag)
3494 drsprintk((KERN_INFO MYNAM ": %s: Sending IOC reset(0x%02x)!\n",
3495 ioc->name, reset_type));
3496 CHIPREG_WRITE32(&ioc->chip->Doorbell, reset_type<<MPI_DOORBELL_FUNCTION_SHIFT);
3497 if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
3500 /* FW ACK'd request, wait for READY state
3503 cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 15; /* 15 seconds */
3505 while ((state = mpt_GetIocState(ioc, 1)) != MPI_IOC_STATE_READY) {
3509 if (sleepFlag != CAN_SLEEP)
3512 printk(KERN_ERR MYNAM ": %s: ERROR - Wait IOC_READY state timeout(%d)!\n",
3513 ioc->name, (int)((count+5)/HZ));
3517 if (sleepFlag == CAN_SLEEP) {
3518 msleep_interruptible(1);
3520 mdelay (1); /* 1 msec delay */
3525 * Cleanup all event stuff for this IOC; re-issue EventNotification
3526 * request if needed.
3528 if (ioc->facts.Function)
3529 ioc->facts.EventState = 0;
3534 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3536 * initChainBuffers - Allocate memory for and initialize
3537 * chain buffers, chain buffer control arrays and spinlock.
3538 * @hd: Pointer to MPT_SCSI_HOST structure
3539 * @init: If set, initialize the spin lock.
3542 initChainBuffers(MPT_ADAPTER *ioc)
3545 int sz, ii, num_chain;
3546 int scale, num_sge, numSGE;
3548 /* ReqToChain size must equal the req_depth
3551 if (ioc->ReqToChain == NULL) {
3552 sz = ioc->req_depth * sizeof(int);
3553 mem = kmalloc(sz, GFP_ATOMIC);
3557 ioc->ReqToChain = (int *) mem;
3558 dinitprintk((KERN_INFO MYNAM ": %s ReqToChain alloc @ %p, sz=%d bytes\n",
3559 ioc->name, mem, sz));
3560 mem = kmalloc(sz, GFP_ATOMIC);
3564 ioc->RequestNB = (int *) mem;
3565 dinitprintk((KERN_INFO MYNAM ": %s RequestNB alloc @ %p, sz=%d bytes\n",
3566 ioc->name, mem, sz));
3568 for (ii = 0; ii < ioc->req_depth; ii++) {
3569 ioc->ReqToChain[ii] = MPT_HOST_NO_CHAIN;
3572 /* ChainToChain size must equal the total number
3573 * of chain buffers to be allocated.
3576 * Calculate the number of chain buffers needed(plus 1) per I/O
3577 * then multiply the the maximum number of simultaneous cmds
3579 * num_sge = num sge in request frame + last chain buffer
3580 * scale = num sge per chain buffer if no chain element
3582 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
3583 if (sizeof(dma_addr_t) == sizeof(u64))
3584 num_sge = scale + (ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
3586 num_sge = 1+ scale + (ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
3588 if (sizeof(dma_addr_t) == sizeof(u64)) {
3589 numSGE = (scale - 1) * (ioc->facts.MaxChainDepth-1) + scale +
3590 (ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
3592 numSGE = 1 + (scale - 1) * (ioc->facts.MaxChainDepth-1) + scale +
3593 (ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
3595 dinitprintk((KERN_INFO MYNAM ": %s num_sge=%d numSGE=%d\n",
3596 ioc->name, num_sge, numSGE));
3598 if ( numSGE > MPT_SCSI_SG_DEPTH )
3599 numSGE = MPT_SCSI_SG_DEPTH;
3602 while (numSGE - num_sge > 0) {
3604 num_sge += (scale - 1);
3608 dinitprintk((KERN_INFO MYNAM ": %s Now numSGE=%d num_sge=%d num_chain=%d\n",
3609 ioc->name, numSGE, num_sge, num_chain));
3611 if (ioc->bus_type == SPI)
3612 num_chain *= MPT_SCSI_CAN_QUEUE;
3614 num_chain *= MPT_FC_CAN_QUEUE;
3616 ioc->num_chain = num_chain;
3618 sz = num_chain * sizeof(int);
3619 if (ioc->ChainToChain == NULL) {
3620 mem = kmalloc(sz, GFP_ATOMIC);
3624 ioc->ChainToChain = (int *) mem;
3625 dinitprintk((KERN_INFO MYNAM ": %s ChainToChain alloc @ %p, sz=%d bytes\n",
3626 ioc->name, mem, sz));
3628 mem = (u8 *) ioc->ChainToChain;
3630 memset(mem, 0xFF, sz);
3634 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3636 * PrimeIocFifos - Initialize IOC request and reply FIFOs.
3637 * @ioc: Pointer to MPT_ADAPTER structure
3639 * This routine allocates memory for the MPT reply and request frame
3640 * pools (if necessary), and primes the IOC reply FIFO with
3643 * Returns 0 for success, non-zero for failure.
3646 PrimeIocFifos(MPT_ADAPTER *ioc)
3649 unsigned long flags;
3650 dma_addr_t alloc_dma;
3652 int i, reply_sz, sz, total_size, num_chain;
3654 /* Prime reply FIFO... */
3656 if (ioc->reply_frames == NULL) {
3657 if ( (num_chain = initChainBuffers(ioc)) < 0)
3660 total_size = reply_sz = (ioc->reply_sz * ioc->reply_depth);
3661 dinitprintk((KERN_INFO MYNAM ": %s.ReplyBuffer sz=%d bytes, ReplyDepth=%d\n",
3662 ioc->name, ioc->reply_sz, ioc->reply_depth));
3663 dinitprintk((KERN_INFO MYNAM ": %s.ReplyBuffer sz=%d[%x] bytes\n",
3664 ioc->name, reply_sz, reply_sz));
3666 sz = (ioc->req_sz * ioc->req_depth);
3667 dinitprintk((KERN_INFO MYNAM ": %s.RequestBuffer sz=%d bytes, RequestDepth=%d\n",
3668 ioc->name, ioc->req_sz, ioc->req_depth));
3669 dinitprintk((KERN_INFO MYNAM ": %s.RequestBuffer sz=%d[%x] bytes\n",
3670 ioc->name, sz, sz));
3673 sz = num_chain * ioc->req_sz; /* chain buffer pool size */
3674 dinitprintk((KERN_INFO MYNAM ": %s.ChainBuffer sz=%d bytes, ChainDepth=%d\n",
3675 ioc->name, ioc->req_sz, num_chain));
3676 dinitprintk((KERN_INFO MYNAM ": %s.ChainBuffer sz=%d[%x] bytes num_chain=%d\n",
3677 ioc->name, sz, sz, num_chain));
3680 mem = pci_alloc_consistent(ioc->pcidev, total_size, &alloc_dma);
3682 printk(MYIOC_s_ERR_FMT "Unable to allocate Reply, Request, Chain Buffers!\n",
3687 dinitprintk((KERN_INFO MYNAM ": %s.Total alloc @ %p[%p], sz=%d[%x] bytes\n",
3688 ioc->name, mem, (void *)(ulong)alloc_dma, total_size, total_size));
3690 memset(mem, 0, total_size);
3691 ioc->alloc_total += total_size;
3693 ioc->alloc_dma = alloc_dma;
3694 ioc->alloc_sz = total_size;
3695 ioc->reply_frames = (MPT_FRAME_HDR *) mem;
3696 ioc->reply_frames_low_dma = (u32) (alloc_dma & 0xFFFFFFFF);
3698 dinitprintk((KERN_INFO MYNAM ": %s ReplyBuffers @ %p[%p]\n",
3699 ioc->name, ioc->reply_frames, (void *)(ulong)alloc_dma));
3701 alloc_dma += reply_sz;
3704 /* Request FIFO - WE manage this! */
3706 ioc->req_frames = (MPT_FRAME_HDR *) mem;
3707 ioc->req_frames_dma = alloc_dma;
3709 dinitprintk((KERN_INFO MYNAM ": %s RequestBuffers @ %p[%p]\n",
3710 ioc->name, mem, (void *)(ulong)alloc_dma));
3712 ioc->req_frames_low_dma = (u32) (alloc_dma & 0xFFFFFFFF);
3714 #if defined(CONFIG_MTRR) && 0
3716 * Enable Write Combining MTRR for IOC's memory region.
3717 * (at least as much as we can; "size and base must be
3718 * multiples of 4 kiB"
3720 ioc->mtrr_reg = mtrr_add(ioc->req_frames_dma,
3722 MTRR_TYPE_WRCOMB, 1);
3723 dprintk((MYIOC_s_INFO_FMT "MTRR region registered (base:size=%08x:%x)\n",
3724 ioc->name, ioc->req_frames_dma, sz));
3727 for (i = 0; i < ioc->req_depth; i++) {
3728 alloc_dma += ioc->req_sz;
3732 ioc->ChainBuffer = mem;
3733 ioc->ChainBufferDMA = alloc_dma;
3735 dinitprintk((KERN_INFO MYNAM " :%s ChainBuffers @ %p(%p)\n",
3736 ioc->name, ioc->ChainBuffer, (void *)(ulong)ioc->ChainBufferDMA));
3738 /* Initialize the free chain Q.
3741 INIT_LIST_HEAD(&ioc->FreeChainQ);
3743 /* Post the chain buffers to the FreeChainQ.
3745 mem = (u8 *)ioc->ChainBuffer;
3746 for (i=0; i < num_chain; i++) {
3747 mf = (MPT_FRAME_HDR *) mem;
3748 list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeChainQ);
3752 /* Initialize Request frames linked list
3754 alloc_dma = ioc->req_frames_dma;
3755 mem = (u8 *) ioc->req_frames;
3757 spin_lock_irqsave(&ioc->FreeQlock, flags);
3758 INIT_LIST_HEAD(&ioc->FreeQ);
3759 for (i = 0; i < ioc->req_depth; i++) {
3760 mf = (MPT_FRAME_HDR *) mem;
3762 /* Queue REQUESTs *internally*! */
3763 list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeQ);
3767 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
3769 sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
3770 ioc->sense_buf_pool =
3771 pci_alloc_consistent(ioc->pcidev, sz, &ioc->sense_buf_pool_dma);
3772 if (ioc->sense_buf_pool == NULL) {
3773 printk(MYIOC_s_ERR_FMT "Unable to allocate Sense Buffers!\n",
3778 ioc->sense_buf_low_dma = (u32) (ioc->sense_buf_pool_dma & 0xFFFFFFFF);
3779 ioc->alloc_total += sz;
3780 dinitprintk((KERN_INFO MYNAM ": %s.SenseBuffers @ %p[%p]\n",
3781 ioc->name, ioc->sense_buf_pool, (void *)(ulong)ioc->sense_buf_pool_dma));
3785 /* Post Reply frames to FIFO
3787 alloc_dma = ioc->alloc_dma;
3788 dinitprintk((KERN_INFO MYNAM ": %s.ReplyBuffers @ %p[%p]\n",
3789 ioc->name, ioc->reply_frames, (void *)(ulong)alloc_dma));
3791 for (i = 0; i < ioc->reply_depth; i++) {
3792 /* Write each address to the IOC! */
3793 CHIPREG_WRITE32(&ioc->chip->ReplyFifo, alloc_dma);
3794 alloc_dma += ioc->reply_sz;
3800 if (ioc->alloc != NULL) {
3802 pci_free_consistent(ioc->pcidev,
3804 ioc->alloc, ioc->alloc_dma);
3805 ioc->reply_frames = NULL;
3806 ioc->req_frames = NULL;
3807 ioc->alloc_total -= sz;
3809 if (ioc->sense_buf_pool != NULL) {
3810 sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
3811 pci_free_consistent(ioc->pcidev,
3813 ioc->sense_buf_pool, ioc->sense_buf_pool_dma);
3814 ioc->sense_buf_pool = NULL;
3819 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3821 * mpt_handshake_req_reply_wait - Send MPT request to and receive reply
3822 * from IOC via doorbell handshake method.
3823 * @ioc: Pointer to MPT_ADAPTER structure
3824 * @reqBytes: Size of the request in bytes
3825 * @req: Pointer to MPT request frame
3826 * @replyBytes: Expected size of the reply in bytes
3827 * @u16reply: Pointer to area where reply should be written
3828 * @maxwait: Max wait time for a reply (in seconds)
3829 * @sleepFlag: Specifies whether the process can sleep
3831 * NOTES: It is the callers responsibility to byte-swap fields in the
3832 * request which are greater than 1 byte in size. It is also the
3833 * callers responsibility to byte-swap response fields which are
3834 * greater than 1 byte in size.
3836 * Returns 0 for success, non-zero for failure.
3839 mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes, u32 *req,
3840 int replyBytes, u16 *u16reply, int maxwait, int sleepFlag)
3842 MPIDefaultReply_t *mptReply;
3847 * Get ready to cache a handshake reply
3849 ioc->hs_reply_idx = 0;
3850 mptReply = (MPIDefaultReply_t *) ioc->hs_reply;
3851 mptReply->MsgLength = 0;
3854 * Make sure there are no doorbells (WRITE 0 to IntStatus reg),
3855 * then tell IOC that we want to handshake a request of N words.
3856 * (WRITE u32val to Doorbell reg).
3858 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
3859 CHIPREG_WRITE32(&ioc->chip->Doorbell,
3860 ((MPI_FUNCTION_HANDSHAKE<<MPI_DOORBELL_FUNCTION_SHIFT) |
3861 ((reqBytes/4)<<MPI_DOORBELL_ADD_DWORDS_SHIFT)));
3864 * Wait for IOC's doorbell handshake int
3866 if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
3869 dhsprintk((MYIOC_s_INFO_FMT "HandShake request start reqBytes=%d, WaitCnt=%d%s\n",
3870 ioc->name, reqBytes, t, failcnt ? " - MISSING DOORBELL HANDSHAKE!" : ""));
3872 /* Read doorbell and check for active bit */
3873 if (!(CHIPREG_READ32(&ioc->chip->Doorbell) & MPI_DOORBELL_ACTIVE))
3877 * Clear doorbell int (WRITE 0 to IntStatus reg),
3878 * then wait for IOC to ACKnowledge that it's ready for
3879 * our handshake request.
3881 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
3882 if (!failcnt && (t = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
3887 u8 *req_as_bytes = (u8 *) req;
3890 * Stuff request words via doorbell handshake,
3891 * with ACK from IOC for each.
3893 for (ii = 0; !failcnt && ii < reqBytes/4; ii++) {
3894 u32 word = ((req_as_bytes[(ii*4) + 0] << 0) |
3895 (req_as_bytes[(ii*4) + 1] << 8) |
3896 (req_as_bytes[(ii*4) + 2] << 16) |
3897 (req_as_bytes[(ii*4) + 3] << 24));
3899 CHIPREG_WRITE32(&ioc->chip->Doorbell, word);
3900 if ((t = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
3904 dhsprintk((KERN_INFO MYNAM ": Handshake request frame (@%p) header\n", req));
3905 DBG_DUMP_REQUEST_FRAME_HDR(req)
3907 dhsprintk((MYIOC_s_INFO_FMT "HandShake request post done, WaitCnt=%d%s\n",
3908 ioc->name, t, failcnt ? " - MISSING DOORBELL ACK!" : ""));
3911 * Wait for completion of doorbell handshake reply from the IOC
3913 if (!failcnt && (t = WaitForDoorbellReply(ioc, maxwait, sleepFlag)) < 0)
3916 dhsprintk((MYIOC_s_INFO_FMT "HandShake reply count=%d%s\n",
3917 ioc->name, t, failcnt ? " - MISSING DOORBELL REPLY!" : ""));
3920 * Copy out the cached reply...
3922 for (ii=0; ii < min(replyBytes/2,mptReply->MsgLength*2); ii++)
3923 u16reply[ii] = ioc->hs_reply[ii];
3931 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3933 * WaitForDoorbellAck - Wait for IOC to clear the IOP_DOORBELL_STATUS bit
3934 * in it's IntStatus register.
3935 * @ioc: Pointer to MPT_ADAPTER structure
3936 * @howlong: How long to wait (in seconds)
3937 * @sleepFlag: Specifies whether the process can sleep
3939 * This routine waits (up to ~2 seconds max) for IOC doorbell
3940 * handshake ACKnowledge.
3942 * Returns a negative value on failure, else wait loop count.
3945 WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
3951 cntdn = 1000 * howlong;
3953 if (sleepFlag == CAN_SLEEP) {
3955 intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
3956 if (! (intstat & MPI_HIS_IOP_DOORBELL_STATUS))
3958 msleep_interruptible (1);
3963 intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
3964 if (! (intstat & MPI_HIS_IOP_DOORBELL_STATUS))
3972 dprintk((MYIOC_s_INFO_FMT "WaitForDoorbell ACK (count=%d)\n",
3977 printk(MYIOC_s_ERR_FMT "Doorbell ACK timeout (count=%d), IntStatus=%x!\n",
3978 ioc->name, count, intstat);
3982 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3984 * WaitForDoorbellInt - Wait for IOC to set the HIS_DOORBELL_INTERRUPT bit
3985 * in it's IntStatus register.
3986 * @ioc: Pointer to MPT_ADAPTER structure
3987 * @howlong: How long to wait (in seconds)
3988 * @sleepFlag: Specifies whether the process can sleep
3990 * This routine waits (up to ~2 seconds max) for IOC doorbell interrupt.
3992 * Returns a negative value on failure, else wait loop count.
3995 WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
4001 cntdn = 1000 * howlong;
4002 if (sleepFlag == CAN_SLEEP) {
4004 intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
4005 if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
4007 msleep_interruptible(1);
4012 intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
4013 if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
4021 dprintk((MYIOC_s_INFO_FMT "WaitForDoorbell INT (cnt=%d) howlong=%d\n",
4022 ioc->name, count, howlong));
4026 printk(MYIOC_s_ERR_FMT "Doorbell INT timeout (count=%d), IntStatus=%x!\n",
4027 ioc->name, count, intstat);
4031 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4033 * WaitForDoorbellReply - Wait for and capture a IOC handshake reply.
4034 * @ioc: Pointer to MPT_ADAPTER structure
4035 * @howlong: How long to wait (in seconds)
4036 * @sleepFlag: Specifies whether the process can sleep
4038 * This routine polls the IOC for a handshake reply, 16 bits at a time.
4039 * Reply is cached to IOC private area large enough to hold a maximum
4040 * of 128 bytes of reply data.
4042 * Returns a negative value on failure, else size of reply in WORDS.
4045 WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
4050 u16 *hs_reply = ioc->hs_reply;
4051 volatile MPIDefaultReply_t *mptReply = (MPIDefaultReply_t *) ioc->hs_reply;
4054 hs_reply[0] = hs_reply[1] = hs_reply[7] = 0;
4057 * Get first two u16's so we can look at IOC's intended reply MsgLength
4060 if ((t = WaitForDoorbellInt(ioc, howlong, sleepFlag)) < 0) {
4063 hs_reply[u16cnt++] = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
4064 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4065 if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
4068 hs_reply[u16cnt++] = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
4069 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4073 dhsprintk((MYIOC_s_INFO_FMT "WaitCnt=%d First handshake reply word=%08x%s\n",
4074 ioc->name, t, le32_to_cpu(*(u32 *)hs_reply),
4075 failcnt ? " - MISSING DOORBELL HANDSHAKE!" : ""));
4078 * If no error (and IOC said MsgLength is > 0), piece together
4079 * reply 16 bits at a time.
4081 for (u16cnt=2; !failcnt && u16cnt < (2 * mptReply->MsgLength); u16cnt++) {
4082 if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
4084 hword = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
4085 /* don't overflow our IOC hs_reply[] buffer! */
4086 if (u16cnt < sizeof(ioc->hs_reply) / sizeof(ioc->hs_reply[0]))
4087 hs_reply[u16cnt] = hword;
4088 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4091 if (!failcnt && (t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
4093 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4096 printk(MYIOC_s_ERR_FMT "Handshake reply failure!\n",
4101 else if (u16cnt != (2 * mptReply->MsgLength)) {
4104 else if ((mptReply->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
4109 dhsprintk((MYIOC_s_INFO_FMT "Got Handshake reply:\n", ioc->name));
4110 DBG_DUMP_REPLY_FRAME(mptReply)
4112 dhsprintk((MYIOC_s_INFO_FMT "WaitForDoorbell REPLY WaitCnt=%d (sz=%d)\n",
4113 ioc->name, t, u16cnt/2));
4117 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4119 * GetLanConfigPages - Fetch LANConfig pages.
4120 * @ioc: Pointer to MPT_ADAPTER structure
4122 * Return: 0 for success
4123 * -ENOMEM if no memory available
4124 * -EPERM if not allowed due to ISR context
4125 * -EAGAIN if no msg frames currently available
4126 * -EFAULT for non-successful reply or no reply (timeout)
4129 GetLanConfigPages(MPT_ADAPTER *ioc)
4131 ConfigPageHeader_t hdr;
4133 LANPage0_t *ppage0_alloc;
4134 dma_addr_t page0_dma;
4135 LANPage1_t *ppage1_alloc;
4136 dma_addr_t page1_dma;
4141 /* Get LAN Page 0 header */
4142 hdr.PageVersion = 0;
4145 hdr.PageType = MPI_CONFIG_PAGETYPE_LAN;
4146 cfg.cfghdr.hdr = &hdr;
4148 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4153 if ((rc = mpt_config(ioc, &cfg)) != 0)
4156 if (hdr.PageLength > 0) {
4157 data_sz = hdr.PageLength * 4;
4158 ppage0_alloc = (LANPage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page0_dma);
4161 memset((u8 *)ppage0_alloc, 0, data_sz);
4162 cfg.physAddr = page0_dma;
4163 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4165 if ((rc = mpt_config(ioc, &cfg)) == 0) {
4167 copy_sz = min_t(int, sizeof(LANPage0_t), data_sz);
4168 memcpy(&ioc->lan_cnfg_page0, ppage0_alloc, copy_sz);
4172 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage0_alloc, page0_dma);
4175 * Normalize endianness of structure data,
4176 * by byte-swapping all > 1 byte fields!
4185 /* Get LAN Page 1 header */
4186 hdr.PageVersion = 0;
4189 hdr.PageType = MPI_CONFIG_PAGETYPE_LAN;
4190 cfg.cfghdr.hdr = &hdr;
4192 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4196 if ((rc = mpt_config(ioc, &cfg)) != 0)
4199 if (hdr.PageLength == 0)
4202 data_sz = hdr.PageLength * 4;
4204 ppage1_alloc = (LANPage1_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page1_dma);
4206 memset((u8 *)ppage1_alloc, 0, data_sz);
4207 cfg.physAddr = page1_dma;
4208 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4210 if ((rc = mpt_config(ioc, &cfg)) == 0) {
4212 copy_sz = min_t(int, sizeof(LANPage1_t), data_sz);
4213 memcpy(&ioc->lan_cnfg_page1, ppage1_alloc, copy_sz);
4216 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage1_alloc, page1_dma);
4219 * Normalize endianness of structure data,
4220 * by byte-swapping all > 1 byte fields!
4228 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4230 * mptbase_GetFcPortPage0 - Fetch FCPort config Page0.
4231 * @ioc: Pointer to MPT_ADAPTER structure
4232 * @portnum: IOC Port number
4234 * Return: 0 for success
4235 * -ENOMEM if no memory available
4236 * -EPERM if not allowed due to ISR context
4237 * -EAGAIN if no msg frames currently available
4238 * -EFAULT for non-successful reply or no reply (timeout)
4241 mptbase_GetFcPortPage0(MPT_ADAPTER *ioc, int portnum)
4243 ConfigPageHeader_t hdr;
4245 FCPortPage0_t *ppage0_alloc;
4246 FCPortPage0_t *pp0dest;
4247 dma_addr_t page0_dma;
4254 /* Get FCPort Page 0 header */
4255 hdr.PageVersion = 0;
4258 hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT;
4259 cfg.cfghdr.hdr = &hdr;
4261 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4263 cfg.pageAddr = portnum;
4266 if ((rc = mpt_config(ioc, &cfg)) != 0)
4269 if (hdr.PageLength == 0)
4272 data_sz = hdr.PageLength * 4;
4274 ppage0_alloc = (FCPortPage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page0_dma);
4278 memset((u8 *)ppage0_alloc, 0, data_sz);
4279 cfg.physAddr = page0_dma;
4280 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4282 if ((rc = mpt_config(ioc, &cfg)) == 0) {
4284 pp0dest = &ioc->fc_port_page0[portnum];
4285 copy_sz = min_t(int, sizeof(FCPortPage0_t), data_sz);
4286 memcpy(pp0dest, ppage0_alloc, copy_sz);
4289 * Normalize endianness of structure data,
4290 * by byte-swapping all > 1 byte fields!
4292 pp0dest->Flags = le32_to_cpu(pp0dest->Flags);
4293 pp0dest->PortIdentifier = le32_to_cpu(pp0dest->PortIdentifier);
4294 pp0dest->WWNN.Low = le32_to_cpu(pp0dest->WWNN.Low);
4295 pp0dest->WWNN.High = le32_to_cpu(pp0dest->WWNN.High);
4296 pp0dest->WWPN.Low = le32_to_cpu(pp0dest->WWPN.Low);
4297 pp0dest->WWPN.High = le32_to_cpu(pp0dest->WWPN.High);
4298 pp0dest->SupportedServiceClass = le32_to_cpu(pp0dest->SupportedServiceClass);
4299 pp0dest->SupportedSpeeds = le32_to_cpu(pp0dest->SupportedSpeeds);
4300 pp0dest->CurrentSpeed = le32_to_cpu(pp0dest->CurrentSpeed);
4301 pp0dest->MaxFrameSize = le32_to_cpu(pp0dest->MaxFrameSize);
4302 pp0dest->FabricWWNN.Low = le32_to_cpu(pp0dest->FabricWWNN.Low);
4303 pp0dest->FabricWWNN.High = le32_to_cpu(pp0dest->FabricWWNN.High);
4304 pp0dest->FabricWWPN.Low = le32_to_cpu(pp0dest->FabricWWPN.Low);
4305 pp0dest->FabricWWPN.High = le32_to_cpu(pp0dest->FabricWWPN.High);
4306 pp0dest->DiscoveredPortsCount = le32_to_cpu(pp0dest->DiscoveredPortsCount);
4307 pp0dest->MaxInitiators = le32_to_cpu(pp0dest->MaxInitiators);
4310 * if still doing discovery,
4311 * hang loose a while until finished
4313 if (pp0dest->PortState == MPI_FCPORTPAGE0_PORTSTATE_UNKNOWN) {
4315 msleep_interruptible(100);
4318 printk(MYIOC_s_INFO_FMT "Firmware discovery not"
4324 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage0_alloc, page0_dma);
4330 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4332 * mptbase_sas_persist_operation - Perform operation on SAS Persitent Table
4333 * @ioc: Pointer to MPT_ADAPTER structure
4334 * @sas_address: 64bit SAS Address for operation.
4335 * @target_id: specified target for operation
4336 * @bus: specified bus for operation
4337 * @persist_opcode: see below
4339 * MPI_SAS_OP_CLEAR_NOT_PRESENT - Free all persist TargetID mappings for
4340 * devices not currently present.
4341 * MPI_SAS_OP_CLEAR_ALL_PERSISTENT - Clear al persist TargetID mappings
4343 * NOTE: Don't use not this function during interrupt time.
4345 * Returns: 0 for success, non-zero error
4348 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4350 mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode)
4352 SasIoUnitControlRequest_t *sasIoUnitCntrReq;
4353 SasIoUnitControlReply_t *sasIoUnitCntrReply;
4354 MPT_FRAME_HDR *mf = NULL;
4355 MPIHeader_t *mpi_hdr;
4358 /* insure garbage is not sent to fw */
4359 switch(persist_opcode) {
4361 case MPI_SAS_OP_CLEAR_NOT_PRESENT:
4362 case MPI_SAS_OP_CLEAR_ALL_PERSISTENT:
4370 printk("%s: persist_opcode=%x\n",__FUNCTION__, persist_opcode);
4372 /* Get a MF for this command.
4374 if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
4375 printk("%s: no msg frames!\n",__FUNCTION__);
4379 mpi_hdr = (MPIHeader_t *) mf;
4380 sasIoUnitCntrReq = (SasIoUnitControlRequest_t *)mf;
4381 memset(sasIoUnitCntrReq,0,sizeof(SasIoUnitControlRequest_t));
4382 sasIoUnitCntrReq->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
4383 sasIoUnitCntrReq->MsgContext = mpi_hdr->MsgContext;
4384 sasIoUnitCntrReq->Operation = persist_opcode;
4386 init_timer(&ioc->persist_timer);
4387 ioc->persist_timer.data = (unsigned long) ioc;
4388 ioc->persist_timer.function = mpt_timer_expired;
4389 ioc->persist_timer.expires = jiffies + HZ*10 /* 10 sec */;
4390 ioc->persist_wait_done=0;
4391 add_timer(&ioc->persist_timer);
4392 mpt_put_msg_frame(mpt_base_index, ioc, mf);
4393 wait_event(mpt_waitq, ioc->persist_wait_done);
4395 sasIoUnitCntrReply =
4396 (SasIoUnitControlReply_t *)ioc->persist_reply_frame;
4397 if (le16_to_cpu(sasIoUnitCntrReply->IOCStatus) != MPI_IOCSTATUS_SUCCESS) {
4398 printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
4400 sasIoUnitCntrReply->IOCStatus,
4401 sasIoUnitCntrReply->IOCLogInfo);
4405 printk("%s: success\n",__FUNCTION__);
4409 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4412 mptbase_raid_process_event_data(MPT_ADAPTER *ioc,
4413 MpiEventDataRaid_t * pRaidEventData)
4422 volume = pRaidEventData->VolumeID;
4423 reason = pRaidEventData->ReasonCode;
4424 disk = pRaidEventData->PhysDiskNum;
4425 status = le32_to_cpu(pRaidEventData->SettingsStatus);
4426 flags = (status >> 0) & 0xff;
4427 state = (status >> 8) & 0xff;
4429 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
4433 if ((reason >= MPI_EVENT_RAID_RC_PHYSDISK_CREATED &&
4434 reason <= MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED) ||
4435 (reason == MPI_EVENT_RAID_RC_SMART_DATA)) {
4436 printk(MYIOC_s_INFO_FMT "RAID STATUS CHANGE for PhysDisk %d\n",
4439 printk(MYIOC_s_INFO_FMT "RAID STATUS CHANGE for VolumeID %d\n",
4444 case MPI_EVENT_RAID_RC_VOLUME_CREATED:
4445 printk(MYIOC_s_INFO_FMT " volume has been created\n",
4449 case MPI_EVENT_RAID_RC_VOLUME_DELETED:
4451 printk(MYIOC_s_INFO_FMT " volume has been deleted\n",
4455 case MPI_EVENT_RAID_RC_VOLUME_SETTINGS_CHANGED:
4456 printk(MYIOC_s_INFO_FMT " volume settings have been changed\n",
4460 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
4461 printk(MYIOC_s_INFO_FMT " volume is now %s%s%s%s\n",
4463 state == MPI_RAIDVOL0_STATUS_STATE_OPTIMAL
4465 : state == MPI_RAIDVOL0_STATUS_STATE_DEGRADED
4467 : state == MPI_RAIDVOL0_STATUS_STATE_FAILED
4470 flags & MPI_RAIDVOL0_STATUS_FLAG_ENABLED
4472 flags & MPI_RAIDVOL0_STATUS_FLAG_QUIESCED
4473 ? ", quiesced" : "",
4474 flags & MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS
4475 ? ", resync in progress" : "" );
4478 case MPI_EVENT_RAID_RC_VOLUME_PHYSDISK_CHANGED:
4479 printk(MYIOC_s_INFO_FMT " volume membership of PhysDisk %d has changed\n",
4483 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
4484 printk(MYIOC_s_INFO_FMT " PhysDisk has been created\n",
4488 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
4489 printk(MYIOC_s_INFO_FMT " PhysDisk has been deleted\n",
4493 case MPI_EVENT_RAID_RC_PHYSDISK_SETTINGS_CHANGED:
4494 printk(MYIOC_s_INFO_FMT " PhysDisk settings have been changed\n",
4498 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
4499 printk(MYIOC_s_INFO_FMT " PhysDisk is now %s%s%s\n",
4501 state == MPI_PHYSDISK0_STATUS_ONLINE
4503 : state == MPI_PHYSDISK0_STATUS_MISSING
4505 : state == MPI_PHYSDISK0_STATUS_NOT_COMPATIBLE
4507 : state == MPI_PHYSDISK0_STATUS_FAILED
4509 : state == MPI_PHYSDISK0_STATUS_INITIALIZING
4511 : state == MPI_PHYSDISK0_STATUS_OFFLINE_REQUESTED
4512 ? "offline requested"
4513 : state == MPI_PHYSDISK0_STATUS_FAILED_REQUESTED
4514 ? "failed requested"
4515 : state == MPI_PHYSDISK0_STATUS_OTHER_OFFLINE
4518 flags & MPI_PHYSDISK0_STATUS_FLAG_OUT_OF_SYNC
4519 ? ", out of sync" : "",
4520 flags & MPI_PHYSDISK0_STATUS_FLAG_QUIESCED
4521 ? ", quiesced" : "" );
4524 case MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED:
4525 printk(MYIOC_s_INFO_FMT " Domain Validation needed for PhysDisk %d\n",
4529 case MPI_EVENT_RAID_RC_SMART_DATA:
4530 printk(MYIOC_s_INFO_FMT " SMART data received, ASC/ASCQ = %02xh/%02xh\n",
4531 ioc->name, pRaidEventData->ASC, pRaidEventData->ASCQ);
4534 case MPI_EVENT_RAID_RC_REPLACE_ACTION_STARTED:
4535 printk(MYIOC_s_INFO_FMT " replacement of PhysDisk %d has started\n",
4541 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4543 * GetIoUnitPage2 - Retrieve BIOS version and boot order information.
4544 * @ioc: Pointer to MPT_ADAPTER structure
4546 * Returns: 0 for success
4547 * -ENOMEM if no memory available
4548 * -EPERM if not allowed due to ISR context
4549 * -EAGAIN if no msg frames currently available
4550 * -EFAULT for non-successful reply or no reply (timeout)
4553 GetIoUnitPage2(MPT_ADAPTER *ioc)
4555 ConfigPageHeader_t hdr;
4557 IOUnitPage2_t *ppage_alloc;
4558 dma_addr_t page_dma;
4562 /* Get the page header */
4563 hdr.PageVersion = 0;
4566 hdr.PageType = MPI_CONFIG_PAGETYPE_IO_UNIT;
4567 cfg.cfghdr.hdr = &hdr;
4569 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4574 if ((rc = mpt_config(ioc, &cfg)) != 0)
4577 if (hdr.PageLength == 0)
4580 /* Read the config page */
4581 data_sz = hdr.PageLength * 4;
4583 ppage_alloc = (IOUnitPage2_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
4585 memset((u8 *)ppage_alloc, 0, data_sz);
4586 cfg.physAddr = page_dma;
4587 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4589 /* If Good, save data */
4590 if ((rc = mpt_config(ioc, &cfg)) == 0)
4591 ioc->biosVersion = le32_to_cpu(ppage_alloc->BiosVersion);
4593 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage_alloc, page_dma);
4599 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4600 /* mpt_GetScsiPortSettings - read SCSI Port Page 0 and 2
4601 * @ioc: Pointer to a Adapter Strucutre
4602 * @portnum: IOC port number
4604 * Return: -EFAULT if read of config page header fails
4606 * If read of SCSI Port Page 0 fails,
4607 * NVRAM = MPT_HOST_NVRAM_INVALID (0xFFFFFFFF)
4608 * Adapter settings: async, narrow
4610 * If read of SCSI Port Page 2 fails,
4611 * Adapter settings valid
4612 * NVRAM = MPT_HOST_NVRAM_INVALID (0xFFFFFFFF)
4617 * CHECK - what type of locking mechanisms should be used????
4620 mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum)
4625 ConfigPageHeader_t header;
4631 if (!ioc->spi_data.nvram) {
4634 sz = MPT_MAX_SCSI_DEVICES * sizeof(int);
4635 mem = kmalloc(sz, GFP_ATOMIC);
4639 ioc->spi_data.nvram = (int *) mem;
4641 dprintk((MYIOC_s_INFO_FMT "SCSI device NVRAM settings @ %p, sz=%d\n",
4642 ioc->name, ioc->spi_data.nvram, sz));
4645 /* Invalidate NVRAM information
4647 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
4648 ioc->spi_data.nvram[ii] = MPT_HOST_NVRAM_INVALID;
4651 /* Read SPP0 header, allocate memory, then read page.
4653 header.PageVersion = 0;
4654 header.PageLength = 0;
4655 header.PageNumber = 0;
4656 header.PageType = MPI_CONFIG_PAGETYPE_SCSI_PORT;
4657 cfg.cfghdr.hdr = &header;
4659 cfg.pageAddr = portnum;
4660 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4662 cfg.timeout = 0; /* use default */
4663 if (mpt_config(ioc, &cfg) != 0)
4666 if (header.PageLength > 0) {
4667 pbuf = pci_alloc_consistent(ioc->pcidev, header.PageLength * 4, &buf_dma);
4669 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4670 cfg.physAddr = buf_dma;
4671 if (mpt_config(ioc, &cfg) != 0) {
4672 ioc->spi_data.maxBusWidth = MPT_NARROW;
4673 ioc->spi_data.maxSyncOffset = 0;
4674 ioc->spi_data.minSyncFactor = MPT_ASYNC;
4675 ioc->spi_data.busType = MPT_HOST_BUS_UNKNOWN;
4677 ddvprintk((MYIOC_s_INFO_FMT "Unable to read PortPage0 minSyncFactor=%x\n",
4678 ioc->name, ioc->spi_data.minSyncFactor));
4680 /* Save the Port Page 0 data
4682 SCSIPortPage0_t *pPP0 = (SCSIPortPage0_t *) pbuf;
4683 pPP0->Capabilities = le32_to_cpu(pPP0->Capabilities);
4684 pPP0->PhysicalInterface = le32_to_cpu(pPP0->PhysicalInterface);
4686 if ( (pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_QAS) == 0 ) {
4687 ioc->spi_data.noQas |= MPT_TARGET_NO_NEGO_QAS;
4688 ddvprintk((KERN_INFO MYNAM " :%s noQas due to Capabilities=%x\n",
4689 ioc->name, pPP0->Capabilities));
4691 ioc->spi_data.maxBusWidth = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_WIDE ? 1 : 0;
4692 data = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_MAX_SYNC_OFFSET_MASK;
4694 ioc->spi_data.maxSyncOffset = (u8) (data >> 16);
4695 data = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_MIN_SYNC_PERIOD_MASK;
4696 ioc->spi_data.minSyncFactor = (u8) (data >> 8);
4697 ddvprintk((MYIOC_s_INFO_FMT "PortPage0 minSyncFactor=%x\n",
4698 ioc->name, ioc->spi_data.minSyncFactor));
4700 ioc->spi_data.maxSyncOffset = 0;
4701 ioc->spi_data.minSyncFactor = MPT_ASYNC;
4704 ioc->spi_data.busType = pPP0->PhysicalInterface & MPI_SCSIPORTPAGE0_PHY_SIGNAL_TYPE_MASK;
4706 /* Update the minSyncFactor based on bus type.
4708 if ((ioc->spi_data.busType == MPI_SCSIPORTPAGE0_PHY_SIGNAL_HVD) ||
4709 (ioc->spi_data.busType == MPI_SCSIPORTPAGE0_PHY_SIGNAL_SE)) {
4711 if (ioc->spi_data.minSyncFactor < MPT_ULTRA) {
4712 ioc->spi_data.minSyncFactor = MPT_ULTRA;
4713 ddvprintk((MYIOC_s_INFO_FMT "HVD or SE detected, minSyncFactor=%x\n",
4714 ioc->name, ioc->spi_data.minSyncFactor));
4719 pci_free_consistent(ioc->pcidev, header.PageLength * 4, pbuf, buf_dma);
4724 /* SCSI Port Page 2 - Read the header then the page.
4726 header.PageVersion = 0;
4727 header.PageLength = 0;
4728 header.PageNumber = 2;
4729 header.PageType = MPI_CONFIG_PAGETYPE_SCSI_PORT;
4730 cfg.cfghdr.hdr = &header;
4732 cfg.pageAddr = portnum;
4733 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4735 if (mpt_config(ioc, &cfg) != 0)
4738 if (header.PageLength > 0) {
4739 /* Allocate memory and read SCSI Port Page 2
4741 pbuf = pci_alloc_consistent(ioc->pcidev, header.PageLength * 4, &buf_dma);
4743 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_NVRAM;
4744 cfg.physAddr = buf_dma;
4745 if (mpt_config(ioc, &cfg) != 0) {
4746 /* Nvram data is left with INVALID mark
4750 SCSIPortPage2_t *pPP2 = (SCSIPortPage2_t *) pbuf;
4751 MpiDeviceInfo_t *pdevice = NULL;
4754 * Save "Set to Avoid SCSI Bus Resets" flag
4756 ioc->spi_data.bus_reset =
4757 (le32_to_cpu(pPP2->PortFlags) &
4758 MPI_SCSIPORTPAGE2_PORT_FLAGS_AVOID_SCSI_RESET) ?
4761 /* Save the Port Page 2 data
4762 * (reformat into a 32bit quantity)
4764 data = le32_to_cpu(pPP2->PortFlags) & MPI_SCSIPORTPAGE2_PORT_FLAGS_DV_MASK;
4765 ioc->spi_data.PortFlags = data;
4766 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
4767 pdevice = &pPP2->DeviceSettings[ii];
4768 data = (le16_to_cpu(pdevice->DeviceFlags) << 16) |
4769 (pdevice->SyncFactor << 8) | pdevice->Timeout;
4770 ioc->spi_data.nvram[ii] = data;
4774 pci_free_consistent(ioc->pcidev, header.PageLength * 4, pbuf, buf_dma);
4778 /* Update Adapter limits with those from NVRAM
4779 * Comment: Don't need to do this. Target performance
4780 * parameters will never exceed the adapters limits.
4786 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4787 /* mpt_readScsiDevicePageHeaders - save version and length of SDP1
4788 * @ioc: Pointer to a Adapter Strucutre
4789 * @portnum: IOC port number
4791 * Return: -EFAULT if read of config page header fails
4795 mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum)
4798 ConfigPageHeader_t header;
4800 /* Read the SCSI Device Page 1 header
4802 header.PageVersion = 0;
4803 header.PageLength = 0;
4804 header.PageNumber = 1;
4805 header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
4806 cfg.cfghdr.hdr = &header;
4808 cfg.pageAddr = portnum;
4809 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4812 if (mpt_config(ioc, &cfg) != 0)
4815 ioc->spi_data.sdp1version = cfg.cfghdr.hdr->PageVersion;
4816 ioc->spi_data.sdp1length = cfg.cfghdr.hdr->PageLength;
4818 header.PageVersion = 0;
4819 header.PageLength = 0;
4820 header.PageNumber = 0;
4821 header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
4822 if (mpt_config(ioc, &cfg) != 0)
4825 ioc->spi_data.sdp0version = cfg.cfghdr.hdr->PageVersion;
4826 ioc->spi_data.sdp0length = cfg.cfghdr.hdr->PageLength;
4828 dcprintk((MYIOC_s_INFO_FMT "Headers: 0: version %d length %d\n",
4829 ioc->name, ioc->spi_data.sdp0version, ioc->spi_data.sdp0length));
4831 dcprintk((MYIOC_s_INFO_FMT "Headers: 1: version %d length %d\n",
4832 ioc->name, ioc->spi_data.sdp1version, ioc->spi_data.sdp1length));
4836 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4838 * mpt_findImVolumes - Identify IDs of hidden disks and RAID Volumes
4839 * @ioc: Pointer to a Adapter Strucutre
4840 * @portnum: IOC port number
4844 * -EFAULT if read of config page header fails or data pointer not NULL
4845 * -ENOMEM if pci_alloc failed
4848 mpt_findImVolumes(MPT_ADAPTER *ioc)
4852 ConfigPageIoc2RaidVol_t *pIocRv;
4853 dma_addr_t ioc2_dma;
4855 ConfigPageHeader_t header;
4862 /* Read IOCP2 header then the page.
4864 header.PageVersion = 0;
4865 header.PageLength = 0;
4866 header.PageNumber = 2;
4867 header.PageType = MPI_CONFIG_PAGETYPE_IOC;
4868 cfg.cfghdr.hdr = &header;
4871 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4874 if (mpt_config(ioc, &cfg) != 0)
4877 if (header.PageLength == 0)
4880 iocpage2sz = header.PageLength * 4;
4881 pIoc2 = pci_alloc_consistent(ioc->pcidev, iocpage2sz, &ioc2_dma);
4885 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4886 cfg.physAddr = ioc2_dma;
4887 if (mpt_config(ioc, &cfg) != 0)
4890 if ( (mem = (u8 *)ioc->raid_data.pIocPg2) == NULL ) {
4891 mem = kmalloc(iocpage2sz, GFP_ATOMIC);
4893 ioc->raid_data.pIocPg2 = (IOCPage2_t *) mem;
4898 memcpy(mem, (u8 *)pIoc2, iocpage2sz);
4900 /* Identify RAID Volume Id's */
4901 nVols = pIoc2->NumActiveVolumes;
4907 /* At least 1 RAID Volume
4909 pIocRv = pIoc2->RaidVolume;
4910 ioc->raid_data.isRaid = 0;
4911 for (jj = 0; jj < nVols; jj++, pIocRv++) {
4912 vid = pIocRv->VolumeID;
4913 vbus = pIocRv->VolumeBus;
4914 vioc = pIocRv->VolumeIOC;
4919 ioc->raid_data.isRaid |= (1 << vid);
4921 /* Error! Always bus 0
4927 /* Identify Hidden Physical Disk Id's */
4928 nPhys = pIoc2->NumActivePhysDisks;
4930 /* No physical disks.
4933 mpt_read_ioc_pg_3(ioc);
4937 pci_free_consistent(ioc->pcidev, iocpage2sz, pIoc2, ioc2_dma);
4943 mpt_read_ioc_pg_3(MPT_ADAPTER *ioc)
4948 ConfigPageHeader_t header;
4949 dma_addr_t ioc3_dma;
4952 /* Free the old page
4954 kfree(ioc->raid_data.pIocPg3);
4955 ioc->raid_data.pIocPg3 = NULL;
4957 /* There is at least one physical disk.
4958 * Read and save IOC Page 3
4960 header.PageVersion = 0;
4961 header.PageLength = 0;
4962 header.PageNumber = 3;
4963 header.PageType = MPI_CONFIG_PAGETYPE_IOC;
4964 cfg.cfghdr.hdr = &header;
4967 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4970 if (mpt_config(ioc, &cfg) != 0)
4973 if (header.PageLength == 0)
4976 /* Read Header good, alloc memory
4978 iocpage3sz = header.PageLength * 4;
4979 pIoc3 = pci_alloc_consistent(ioc->pcidev, iocpage3sz, &ioc3_dma);
4983 /* Read the Page and save the data
4984 * into malloc'd memory.
4986 cfg.physAddr = ioc3_dma;
4987 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4988 if (mpt_config(ioc, &cfg) == 0) {
4989 mem = kmalloc(iocpage3sz, GFP_ATOMIC);
4991 memcpy(mem, (u8 *)pIoc3, iocpage3sz);
4992 ioc->raid_data.pIocPg3 = (IOCPage3_t *) mem;
4996 pci_free_consistent(ioc->pcidev, iocpage3sz, pIoc3, ioc3_dma);
5002 mpt_read_ioc_pg_4(MPT_ADAPTER *ioc)
5006 ConfigPageHeader_t header;
5007 dma_addr_t ioc4_dma;
5010 /* Read and save IOC Page 4
5012 header.PageVersion = 0;
5013 header.PageLength = 0;
5014 header.PageNumber = 4;
5015 header.PageType = MPI_CONFIG_PAGETYPE_IOC;
5016 cfg.cfghdr.hdr = &header;
5019 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5022 if (mpt_config(ioc, &cfg) != 0)
5025 if (header.PageLength == 0)
5028 if ( (pIoc4 = ioc->spi_data.pIocPg4) == NULL ) {
5029 iocpage4sz = (header.PageLength + 4) * 4; /* Allow 4 additional SEP's */
5030 pIoc4 = pci_alloc_consistent(ioc->pcidev, iocpage4sz, &ioc4_dma);
5034 ioc4_dma = ioc->spi_data.IocPg4_dma;
5035 iocpage4sz = ioc->spi_data.IocPg4Sz;
5038 /* Read the Page into dma memory.
5040 cfg.physAddr = ioc4_dma;
5041 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5042 if (mpt_config(ioc, &cfg) == 0) {
5043 ioc->spi_data.pIocPg4 = (IOCPage4_t *) pIoc4;
5044 ioc->spi_data.IocPg4_dma = ioc4_dma;
5045 ioc->spi_data.IocPg4Sz = iocpage4sz;
5047 pci_free_consistent(ioc->pcidev, iocpage4sz, pIoc4, ioc4_dma);
5048 ioc->spi_data.pIocPg4 = NULL;
5053 mpt_read_ioc_pg_1(MPT_ADAPTER *ioc)
5057 ConfigPageHeader_t header;
5058 dma_addr_t ioc1_dma;
5062 /* Check the Coalescing Timeout in IOC Page 1
5064 header.PageVersion = 0;
5065 header.PageLength = 0;
5066 header.PageNumber = 1;
5067 header.PageType = MPI_CONFIG_PAGETYPE_IOC;
5068 cfg.cfghdr.hdr = &header;
5071 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5074 if (mpt_config(ioc, &cfg) != 0)
5077 if (header.PageLength == 0)
5080 /* Read Header good, alloc memory
5082 iocpage1sz = header.PageLength * 4;
5083 pIoc1 = pci_alloc_consistent(ioc->pcidev, iocpage1sz, &ioc1_dma);
5087 /* Read the Page and check coalescing timeout
5089 cfg.physAddr = ioc1_dma;
5090 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5091 if (mpt_config(ioc, &cfg) == 0) {
5093 tmp = le32_to_cpu(pIoc1->Flags) & MPI_IOCPAGE1_REPLY_COALESCING;
5094 if (tmp == MPI_IOCPAGE1_REPLY_COALESCING) {
5095 tmp = le32_to_cpu(pIoc1->CoalescingTimeout);
5097 dprintk((MYIOC_s_INFO_FMT "Coalescing Enabled Timeout = %d\n",
5100 if (tmp > MPT_COALESCING_TIMEOUT) {
5101 pIoc1->CoalescingTimeout = cpu_to_le32(MPT_COALESCING_TIMEOUT);
5103 /* Write NVRAM and current
5106 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
5107 if (mpt_config(ioc, &cfg) == 0) {
5108 dprintk((MYIOC_s_INFO_FMT "Reset Current Coalescing Timeout to = %d\n",
5109 ioc->name, MPT_COALESCING_TIMEOUT));
5111 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM;
5112 if (mpt_config(ioc, &cfg) == 0) {
5113 dprintk((MYIOC_s_INFO_FMT "Reset NVRAM Coalescing Timeout to = %d\n",
5114 ioc->name, MPT_COALESCING_TIMEOUT));
5116 dprintk((MYIOC_s_INFO_FMT "Reset NVRAM Coalescing Timeout Failed\n",
5121 dprintk((MYIOC_s_WARN_FMT "Reset of Current Coalescing Timeout Failed!\n",
5127 dprintk((MYIOC_s_WARN_FMT "Coalescing Disabled\n", ioc->name));
5131 pci_free_consistent(ioc->pcidev, iocpage1sz, pIoc1, ioc1_dma);
5136 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5138 * SendEventNotification - Send EventNotification (on or off) request
5140 * @ioc: Pointer to MPT_ADAPTER structure
5141 * @EvSwitch: Event switch flags
5144 SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch)
5146 EventNotification_t *evnp;
5148 evnp = (EventNotification_t *) mpt_get_msg_frame(mpt_base_index, ioc);
5150 devtprintk((MYIOC_s_WARN_FMT "Unable to allocate event request frame!\n",
5154 memset(evnp, 0, sizeof(*evnp));
5156 devtprintk((MYIOC_s_INFO_FMT "Sending EventNotification (%d) request %p\n", ioc->name, EvSwitch, evnp));
5158 evnp->Function = MPI_FUNCTION_EVENT_NOTIFICATION;
5159 evnp->ChainOffset = 0;
5161 evnp->Switch = EvSwitch;
5163 mpt_put_msg_frame(mpt_base_index, ioc, (MPT_FRAME_HDR *)evnp);
5168 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5170 * SendEventAck - Send EventAck request to MPT adapter.
5171 * @ioc: Pointer to MPT_ADAPTER structure
5172 * @evnp: Pointer to original EventNotification request
5175 SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp)
5179 if ((pAck = (EventAck_t *) mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
5180 printk(MYIOC_s_WARN_FMT "Unable to allocate event ACK "
5181 "request frame for Event=%x EventContext=%x EventData=%x!\n",
5182 ioc->name, evnp->Event, le32_to_cpu(evnp->EventContext),
5183 le32_to_cpu(evnp->Data[0]));
5186 memset(pAck, 0, sizeof(*pAck));
5188 dprintk((MYIOC_s_INFO_FMT "Sending EventAck\n", ioc->name));
5190 pAck->Function = MPI_FUNCTION_EVENT_ACK;
5191 pAck->ChainOffset = 0;
5193 pAck->Event = evnp->Event;
5194 pAck->EventContext = evnp->EventContext;
5196 mpt_put_msg_frame(mpt_base_index, ioc, (MPT_FRAME_HDR *)pAck);
5201 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5203 * mpt_config - Generic function to issue config message
5204 * @ioc - Pointer to an adapter structure
5205 * @cfg - Pointer to a configuration structure. Struct contains
5206 * action, page address, direction, physical address
5207 * and pointer to a configuration page header
5208 * Page header is updated.
5210 * Returns 0 for success
5211 * -EPERM if not allowed due to ISR context
5212 * -EAGAIN if no msg frames currently available
5213 * -EFAULT for non-successful reply or no reply (timeout)
5216 mpt_config(MPT_ADAPTER *ioc, CONFIGPARMS *pCfg)
5219 ConfigExtendedPageHeader_t *pExtHdr = NULL;
5221 unsigned long flags;
5226 /* Prevent calling wait_event() (below), if caller happens
5227 * to be in ISR context, because that is fatal!
5229 in_isr = in_interrupt();
5231 dcprintk((MYIOC_s_WARN_FMT "Config request not allowed in ISR context!\n",
5236 /* Get and Populate a free Frame
5238 if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
5239 dcprintk((MYIOC_s_WARN_FMT "mpt_config: no msg frames!\n",
5243 pReq = (Config_t *)mf;
5244 pReq->Action = pCfg->action;
5246 pReq->ChainOffset = 0;
5247 pReq->Function = MPI_FUNCTION_CONFIG;
5249 /* Assume page type is not extended and clear "reserved" fields. */
5250 pReq->ExtPageLength = 0;
5251 pReq->ExtPageType = 0;
5254 for (ii=0; ii < 8; ii++)
5255 pReq->Reserved2[ii] = 0;
5257 pReq->Header.PageVersion = pCfg->cfghdr.hdr->PageVersion;
5258 pReq->Header.PageLength = pCfg->cfghdr.hdr->PageLength;
5259 pReq->Header.PageNumber = pCfg->cfghdr.hdr->PageNumber;
5260 pReq->Header.PageType = (pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK);
5262 if ((pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK) == MPI_CONFIG_PAGETYPE_EXTENDED) {
5263 pExtHdr = (ConfigExtendedPageHeader_t *)pCfg->cfghdr.ehdr;
5264 pReq->ExtPageLength = cpu_to_le16(pExtHdr->ExtPageLength);
5265 pReq->ExtPageType = pExtHdr->ExtPageType;
5266 pReq->Header.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
5268 /* Page Length must be treated as a reserved field for the extended header. */
5269 pReq->Header.PageLength = 0;
5272 pReq->PageAddress = cpu_to_le32(pCfg->pageAddr);
5274 /* Add a SGE to the config request.
5277 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
5279 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
5281 if ((pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK) == MPI_CONFIG_PAGETYPE_EXTENDED) {
5282 flagsLength |= pExtHdr->ExtPageLength * 4;
5284 dcprintk((MYIOC_s_INFO_FMT "Sending Config request type %d, page %d and action %d\n",
5285 ioc->name, pReq->ExtPageType, pReq->Header.PageNumber, pReq->Action));
5288 flagsLength |= pCfg->cfghdr.hdr->PageLength * 4;
5290 dcprintk((MYIOC_s_INFO_FMT "Sending Config request type %d, page %d and action %d\n",
5291 ioc->name, pReq->Header.PageType, pReq->Header.PageNumber, pReq->Action));
5294 mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, pCfg->physAddr);
5296 /* Append pCfg pointer to end of mf
5298 *((void **) (((u8 *) mf) + (ioc->req_sz - sizeof(void *)))) = (void *) pCfg;
5300 /* Initalize the timer
5302 init_timer(&pCfg->timer);
5303 pCfg->timer.data = (unsigned long) ioc;
5304 pCfg->timer.function = mpt_timer_expired;
5305 pCfg->wait_done = 0;
5307 /* Set the timer; ensure 10 second minimum */
5308 if (pCfg->timeout < 10)
5309 pCfg->timer.expires = jiffies + HZ*10;
5311 pCfg->timer.expires = jiffies + HZ*pCfg->timeout;
5313 /* Add to end of Q, set timer and then issue this command */
5314 spin_lock_irqsave(&ioc->FreeQlock, flags);
5315 list_add_tail(&pCfg->linkage, &ioc->configQ);
5316 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5318 add_timer(&pCfg->timer);
5319 mpt_put_msg_frame(mpt_base_index, ioc, mf);
5320 wait_event(mpt_waitq, pCfg->wait_done);
5322 /* mf has been freed - do not access */
5329 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5331 * mpt_toolbox - Generic function to issue toolbox message
5332 * @ioc - Pointer to an adapter structure
5333 * @cfg - Pointer to a toolbox structure. Struct contains
5334 * action, page address, direction, physical address
5335 * and pointer to a configuration page header
5336 * Page header is updated.
5338 * Returns 0 for success
5339 * -EPERM if not allowed due to ISR context
5340 * -EAGAIN if no msg frames currently available
5341 * -EFAULT for non-successful reply or no reply (timeout)
5344 mpt_toolbox(MPT_ADAPTER *ioc, CONFIGPARMS *pCfg)
5346 ToolboxIstwiReadWriteRequest_t *pReq;
5348 struct pci_dev *pdev;
5349 unsigned long flags;
5354 /* Prevent calling wait_event() (below), if caller happens
5355 * to be in ISR context, because that is fatal!
5357 in_isr = in_interrupt();
5359 dcprintk((MYIOC_s_WARN_FMT "toobox request not allowed in ISR context!\n",
5364 /* Get and Populate a free Frame
5366 if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
5367 dcprintk((MYIOC_s_WARN_FMT "mpt_toolbox: no msg frames!\n",
5371 pReq = (ToolboxIstwiReadWriteRequest_t *)mf;
5372 pReq->Tool = pCfg->action;
5374 pReq->ChainOffset = 0;
5375 pReq->Function = MPI_FUNCTION_TOOLBOX;
5376 pReq->Reserved1 = 0;
5377 pReq->Reserved2 = 0;
5379 pReq->Flags = pCfg->dir;
5381 pReq->Reserved3 = 0;
5382 pReq->NumAddressBytes = 0x01;
5383 pReq->Reserved4 = 0;
5384 pReq->DataLength = cpu_to_le16(0x04);
5386 if (pdev->devfn & 1)
5387 pReq->DeviceAddr = 0xB2;
5389 pReq->DeviceAddr = 0xB0;
5393 pReq->Reserved5 = 0;
5395 /* Add a SGE to the config request.
5398 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ | 4;
5400 mpt_add_sge((char *)&pReq->SGL, flagsLength, pCfg->physAddr);
5402 dcprintk((MYIOC_s_INFO_FMT "Sending Toolbox request, Tool=%x\n",
5403 ioc->name, pReq->Tool));
5405 /* Append pCfg pointer to end of mf
5407 *((void **) (((u8 *) mf) + (ioc->req_sz - sizeof(void *)))) = (void *) pCfg;
5409 /* Initalize the timer
5411 init_timer(&pCfg->timer);
5412 pCfg->timer.data = (unsigned long) ioc;
5413 pCfg->timer.function = mpt_timer_expired;
5414 pCfg->wait_done = 0;
5416 /* Set the timer; ensure 10 second minimum */
5417 if (pCfg->timeout < 10)
5418 pCfg->timer.expires = jiffies + HZ*10;
5420 pCfg->timer.expires = jiffies + HZ*pCfg->timeout;
5422 /* Add to end of Q, set timer and then issue this command */
5423 spin_lock_irqsave(&ioc->FreeQlock, flags);
5424 list_add_tail(&pCfg->linkage, &ioc->configQ);
5425 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5427 add_timer(&pCfg->timer);
5428 mpt_put_msg_frame(mpt_base_index, ioc, mf);
5429 wait_event(mpt_waitq, pCfg->wait_done);
5431 /* mf has been freed - do not access */
5438 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5440 * mpt_timer_expired - Call back for timer process.
5441 * Used only internal config functionality.
5442 * @data: Pointer to MPT_SCSI_HOST recast as an unsigned long
5445 mpt_timer_expired(unsigned long data)
5447 MPT_ADAPTER *ioc = (MPT_ADAPTER *) data;
5449 dcprintk((MYIOC_s_WARN_FMT "mpt_timer_expired! \n", ioc->name));
5451 /* Perform a FW reload */
5452 if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0)
5453 printk(MYIOC_s_WARN_FMT "Firmware Reload FAILED!\n", ioc->name);
5455 /* No more processing.
5456 * Hard reset clean-up will wake up
5457 * process and free all resources.
5459 dcprintk((MYIOC_s_WARN_FMT "mpt_timer_expired complete!\n", ioc->name));
5464 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5466 * mpt_ioc_reset - Base cleanup for hard reset
5467 * @ioc: Pointer to the adapter structure
5468 * @reset_phase: Indicates pre- or post-reset functionality
5470 * Remark: Free's resources with internally generated commands.
5473 mpt_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
5476 unsigned long flags;
5478 dprintk((KERN_WARNING MYNAM
5479 ": IOC %s_reset routed to MPT base driver!\n",
5480 reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
5481 reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
5483 if (reset_phase == MPT_IOC_SETUP_RESET) {
5485 } else if (reset_phase == MPT_IOC_PRE_RESET) {
5486 /* If the internal config Q is not empty -
5487 * delete timer. MF resources will be freed when
5488 * the FIFO's are primed.
5490 spin_lock_irqsave(&ioc->FreeQlock, flags);
5491 list_for_each_entry(pCfg, &ioc->configQ, linkage)
5492 del_timer(&pCfg->timer);
5493 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5498 /* Search the configQ for internal commands.
5499 * Flush the Q, and wake up all suspended threads.
5501 spin_lock_irqsave(&ioc->FreeQlock, flags);
5502 list_for_each_entry_safe(pCfg, pNext, &ioc->configQ, linkage) {
5503 list_del(&pCfg->linkage);
5505 pCfg->status = MPT_CONFIG_ERROR;
5506 pCfg->wait_done = 1;
5507 wake_up(&mpt_waitq);
5509 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5512 return 1; /* currently means nothing really */
5516 #ifdef CONFIG_PROC_FS /* { */
5517 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5519 * procfs (%MPT_PROCFS_MPTBASEDIR/...) support stuff...
5521 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5523 * procmpt_create - Create %MPT_PROCFS_MPTBASEDIR entries.
5525 * Returns 0 for success, non-zero for failure.
5528 procmpt_create(void)
5530 struct proc_dir_entry *ent;
5532 mpt_proc_root_dir = proc_mkdir(MPT_PROCFS_MPTBASEDIR, NULL);
5533 if (mpt_proc_root_dir == NULL)
5536 ent = create_proc_entry("summary", S_IFREG|S_IRUGO, mpt_proc_root_dir);
5538 ent->read_proc = procmpt_summary_read;
5540 ent = create_proc_entry("version", S_IFREG|S_IRUGO, mpt_proc_root_dir);
5542 ent->read_proc = procmpt_version_read;
5547 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5549 * procmpt_destroy - Tear down %MPT_PROCFS_MPTBASEDIR entries.
5551 * Returns 0 for success, non-zero for failure.
5554 procmpt_destroy(void)
5556 remove_proc_entry("version", mpt_proc_root_dir);
5557 remove_proc_entry("summary", mpt_proc_root_dir);
5558 remove_proc_entry(MPT_PROCFS_MPTBASEDIR, NULL);
5561 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5563 * procmpt_summary_read - Handle read request from /proc/mpt/summary
5564 * or from /proc/mpt/iocN/summary.
5565 * @buf: Pointer to area to write information
5566 * @start: Pointer to start pointer
5567 * @offset: Offset to start writing
5569 * @eof: Pointer to EOF integer
5572 * Returns number of characters written to process performing the read.
5575 procmpt_summary_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
5585 mpt_print_ioc_summary(ioc, out, &more, 0, 1);
5589 list_for_each_entry(ioc, &ioc_list, list) {
5592 mpt_print_ioc_summary(ioc, out, &more, 0, 1);
5595 if ((out-buf) >= request)
5602 MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
5605 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5607 * procmpt_version_read - Handle read request from /proc/mpt/version.
5608 * @buf: Pointer to area to write information
5609 * @start: Pointer to start pointer
5610 * @offset: Offset to start writing
5612 * @eof: Pointer to EOF integer
5615 * Returns number of characters written to process performing the read.
5618 procmpt_version_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
5621 int scsi, fc, sas, lan, ctl, targ, dmp;
5625 len = sprintf(buf, "%s-%s\n", "mptlinux", MPT_LINUX_VERSION_COMMON);
5626 len += sprintf(buf+len, " Fusion MPT base driver\n");
5628 scsi = fc = sas = lan = ctl = targ = dmp = 0;
5629 for (ii=MPT_MAX_PROTOCOL_DRIVERS-1; ii; ii--) {
5631 if (MptCallbacks[ii]) {
5632 switch (MptDriverClass[ii]) {
5634 if (!scsi++) drvname = "SPI host";
5637 if (!fc++) drvname = "FC host";
5640 if (!sas++) drvname = "SAS host";
5643 if (!lan++) drvname = "LAN";
5646 if (!targ++) drvname = "SCSI target";
5649 if (!ctl++) drvname = "ioctl";
5654 len += sprintf(buf+len, " Fusion MPT %s driver\n", drvname);
5658 MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
5661 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5663 * procmpt_iocinfo_read - Handle read request from /proc/mpt/iocN/info.
5664 * @buf: Pointer to area to write information
5665 * @start: Pointer to start pointer
5666 * @offset: Offset to start writing
5668 * @eof: Pointer to EOF integer
5671 * Returns number of characters written to process performing the read.
5674 procmpt_iocinfo_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
5676 MPT_ADAPTER *ioc = data;
5682 mpt_get_fw_exp_ver(expVer, ioc);
5684 len = sprintf(buf, "%s:", ioc->name);
5685 if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)
5686 len += sprintf(buf+len, " (f/w download boot flag set)");
5687 // if (ioc->facts.IOCExceptions & MPI_IOCFACTS_EXCEPT_CONFIG_CHECKSUM_FAIL)
5688 // len += sprintf(buf+len, " CONFIG_CHECKSUM_FAIL!");
5690 len += sprintf(buf+len, "\n ProductID = 0x%04x (%s)\n",
5691 ioc->facts.ProductID,
5693 len += sprintf(buf+len, " FWVersion = 0x%08x%s", ioc->facts.FWVersion.Word, expVer);
5694 if (ioc->facts.FWImageSize)
5695 len += sprintf(buf+len, " (fw_size=%d)", ioc->facts.FWImageSize);
5696 len += sprintf(buf+len, "\n MsgVersion = 0x%04x\n", ioc->facts.MsgVersion);
5697 len += sprintf(buf+len, " FirstWhoInit = 0x%02x\n", ioc->FirstWhoInit);
5698 len += sprintf(buf+len, " EventState = 0x%02x\n", ioc->facts.EventState);
5700 len += sprintf(buf+len, " CurrentHostMfaHighAddr = 0x%08x\n",
5701 ioc->facts.CurrentHostMfaHighAddr);
5702 len += sprintf(buf+len, " CurrentSenseBufferHighAddr = 0x%08x\n",
5703 ioc->facts.CurrentSenseBufferHighAddr);
5705 len += sprintf(buf+len, " MaxChainDepth = 0x%02x frames\n", ioc->facts.MaxChainDepth);
5706 len += sprintf(buf+len, " MinBlockSize = 0x%02x bytes\n", 4*ioc->facts.BlockSize);
5708 len += sprintf(buf+len, " RequestFrames @ 0x%p (Dma @ 0x%p)\n",
5709 (void *)ioc->req_frames, (void *)(ulong)ioc->req_frames_dma);
5711 * Rounding UP to nearest 4-kB boundary here...
5713 sz = (ioc->req_sz * ioc->req_depth) + 128;
5714 sz = ((sz + 0x1000UL - 1UL) / 0x1000) * 0x1000;
5715 len += sprintf(buf+len, " {CurReqSz=%d} x {CurReqDepth=%d} = %d bytes ^= 0x%x\n",
5716 ioc->req_sz, ioc->req_depth, ioc->req_sz*ioc->req_depth, sz);
5717 len += sprintf(buf+len, " {MaxReqSz=%d} {MaxReqDepth=%d}\n",
5718 4*ioc->facts.RequestFrameSize,
5719 ioc->facts.GlobalCredits);
5721 len += sprintf(buf+len, " Frames @ 0x%p (Dma @ 0x%p)\n",
5722 (void *)ioc->alloc, (void *)(ulong)ioc->alloc_dma);
5723 sz = (ioc->reply_sz * ioc->reply_depth) + 128;
5724 len += sprintf(buf+len, " {CurRepSz=%d} x {CurRepDepth=%d} = %d bytes ^= 0x%x\n",
5725 ioc->reply_sz, ioc->reply_depth, ioc->reply_sz*ioc->reply_depth, sz);
5726 len += sprintf(buf+len, " {MaxRepSz=%d} {MaxRepDepth=%d}\n",
5727 ioc->facts.CurReplyFrameSize,
5728 ioc->facts.ReplyQueueDepth);
5730 len += sprintf(buf+len, " MaxDevices = %d\n",
5731 (ioc->facts.MaxDevices==0) ? 255 : ioc->facts.MaxDevices);
5732 len += sprintf(buf+len, " MaxBuses = %d\n", ioc->facts.MaxBuses);
5735 for (p=0; p < ioc->facts.NumberOfPorts; p++) {
5736 len += sprintf(buf+len, " PortNumber = %d (of %d)\n",
5738 ioc->facts.NumberOfPorts);
5739 if (ioc->bus_type == FC) {
5740 if (ioc->pfacts[p].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) {
5741 u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
5742 len += sprintf(buf+len, " LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
5743 a[5], a[4], a[3], a[2], a[1], a[0]);
5745 len += sprintf(buf+len, " WWN = %08X%08X:%08X%08X\n",
5746 ioc->fc_port_page0[p].WWNN.High,
5747 ioc->fc_port_page0[p].WWNN.Low,
5748 ioc->fc_port_page0[p].WWPN.High,
5749 ioc->fc_port_page0[p].WWPN.Low);
5753 MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
5756 #endif /* CONFIG_PROC_FS } */
5758 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5760 mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc)
5763 if ((ioc->facts.FWVersion.Word >> 24) == 0x0E) {
5764 sprintf(buf, " (Exp %02d%02d)",
5765 (ioc->facts.FWVersion.Word >> 16) & 0x00FF, /* Month */
5766 (ioc->facts.FWVersion.Word >> 8) & 0x1F); /* Day */
5769 if ((ioc->facts.FWVersion.Word >> 8) & 0x80)
5770 strcat(buf, " [MDBG]");
5774 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5776 * mpt_print_ioc_summary - Write ASCII summary of IOC to a buffer.
5777 * @ioc: Pointer to MPT_ADAPTER structure
5778 * @buffer: Pointer to buffer where IOC summary info should be written
5779 * @size: Pointer to number of bytes we wrote (set by this routine)
5780 * @len: Offset at which to start writing in buffer
5781 * @showlan: Display LAN stuff?
5783 * This routine writes (english readable) ASCII text, which represents
5784 * a summary of IOC information, to a buffer.
5787 mpt_print_ioc_summary(MPT_ADAPTER *ioc, char *buffer, int *size, int len, int showlan)
5792 mpt_get_fw_exp_ver(expVer, ioc);
5795 * Shorter summary of attached ioc's...
5797 y = sprintf(buffer+len, "%s: %s, %s%08xh%s, Ports=%d, MaxQ=%d",
5800 MPT_FW_REV_MAGIC_ID_STRING, /* "FwRev=" or somesuch */
5801 ioc->facts.FWVersion.Word,
5803 ioc->facts.NumberOfPorts,
5806 if (showlan && (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN)) {
5807 u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
5808 y += sprintf(buffer+len+y, ", LanAddr=%02X:%02X:%02X:%02X:%02X:%02X",
5809 a[5], a[4], a[3], a[2], a[1], a[0]);
5813 y += sprintf(buffer+len+y, ", IRQ=%d", ioc->pci_irq);
5815 y += sprintf(buffer+len+y, ", IRQ=%s", __irq_itoa(ioc->pci_irq));
5819 y += sprintf(buffer+len+y, " (disabled)");
5821 y += sprintf(buffer+len+y, "\n");
5826 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5830 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5832 * mpt_HardResetHandler - Generic reset handler, issue SCSI Task
5833 * Management call based on input arg values. If TaskMgmt fails,
5834 * return associated SCSI request.
5835 * @ioc: Pointer to MPT_ADAPTER structure
5836 * @sleepFlag: Indicates if sleep or schedule must be called.
5838 * Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
5839 * or a non-interrupt thread. In the former, must not call schedule().
5841 * Remark: A return of -1 is a FATAL error case, as it means a
5842 * FW reload/initialization failed.
5844 * Returns 0 for SUCCESS or -1 if FAILED.
5847 mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag)
5850 unsigned long flags;
5852 dtmprintk((MYIOC_s_INFO_FMT "HardResetHandler Entered!\n", ioc->name));
5854 printk(MYIOC_s_INFO_FMT "HardResetHandler Entered!\n", ioc->name);
5855 printk("MF count 0x%x !\n", ioc->mfcnt);
5858 /* Reset the adapter. Prevent more than 1 call to
5859 * mpt_do_ioc_recovery at any instant in time.
5861 spin_lock_irqsave(&ioc->diagLock, flags);
5862 if ((ioc->diagPending) || (ioc->alt_ioc && ioc->alt_ioc->diagPending)){
5863 spin_unlock_irqrestore(&ioc->diagLock, flags);
5866 ioc->diagPending = 1;
5868 spin_unlock_irqrestore(&ioc->diagLock, flags);
5870 /* FIXME: If do_ioc_recovery fails, repeat....
5873 /* The SCSI driver needs to adjust timeouts on all current
5874 * commands prior to the diagnostic reset being issued.
5875 * Prevents timeouts occuring during a diagnostic reset...very bad.
5876 * For all other protocol drivers, this is a no-op.
5882 for (ii=MPT_MAX_PROTOCOL_DRIVERS-1; ii; ii--) {
5883 if (MptResetHandlers[ii]) {
5884 dtmprintk((MYIOC_s_INFO_FMT "Calling IOC reset_setup handler #%d\n",
5886 r += (*(MptResetHandlers[ii]))(ioc, MPT_IOC_SETUP_RESET);
5888 dtmprintk((MYIOC_s_INFO_FMT "Calling alt-%s setup reset handler #%d\n",
5889 ioc->name, ioc->alt_ioc->name, ii));
5890 r += (*(MptResetHandlers[ii]))(ioc->alt_ioc, MPT_IOC_SETUP_RESET);
5896 if ((rc = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_RECOVER, sleepFlag)) != 0) {
5897 printk(KERN_WARNING MYNAM ": WARNING - (%d) Cannot recover %s\n",
5902 ioc->alt_ioc->reload_fw = 0;
5904 spin_lock_irqsave(&ioc->diagLock, flags);
5905 ioc->diagPending = 0;
5907 ioc->alt_ioc->diagPending = 0;
5908 spin_unlock_irqrestore(&ioc->diagLock, flags);
5910 dtmprintk((MYIOC_s_INFO_FMT "HardResetHandler rc = %d!\n", ioc->name, rc));
5915 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5917 EventDescriptionStr(u8 event, u32 evData0, char *evStr)
5922 case MPI_EVENT_NONE:
5925 case MPI_EVENT_LOG_DATA:
5928 case MPI_EVENT_STATE_CHANGE:
5929 ds = "State Change";
5931 case MPI_EVENT_UNIT_ATTENTION:
5932 ds = "Unit Attention";
5934 case MPI_EVENT_IOC_BUS_RESET:
5935 ds = "IOC Bus Reset";
5937 case MPI_EVENT_EXT_BUS_RESET:
5938 ds = "External Bus Reset";
5940 case MPI_EVENT_RESCAN:
5941 ds = "Bus Rescan Event";
5942 /* Ok, do we need to do anything here? As far as
5943 I can tell, this is when a new device gets added
5946 case MPI_EVENT_LINK_STATUS_CHANGE:
5947 if (evData0 == MPI_EVENT_LINK_STATUS_FAILURE)
5948 ds = "Link Status(FAILURE) Change";
5950 ds = "Link Status(ACTIVE) Change";
5952 case MPI_EVENT_LOOP_STATE_CHANGE:
5953 if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LIP)
5954 ds = "Loop State(LIP) Change";
5955 else if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LPE)
5956 ds = "Loop State(LPE) Change"; /* ??? */
5958 ds = "Loop State(LPB) Change"; /* ??? */
5960 case MPI_EVENT_LOGOUT:
5963 case MPI_EVENT_EVENT_CHANGE:
5965 ds = "Events(ON) Change";
5967 ds = "Events(OFF) Change";
5969 case MPI_EVENT_INTEGRATED_RAID:
5971 u8 ReasonCode = (u8)(evData0 >> 16);
5972 switch (ReasonCode) {
5973 case MPI_EVENT_RAID_RC_VOLUME_CREATED :
5974 ds = "Integrated Raid: Volume Created";
5976 case MPI_EVENT_RAID_RC_VOLUME_DELETED :
5977 ds = "Integrated Raid: Volume Deleted";
5979 case MPI_EVENT_RAID_RC_VOLUME_SETTINGS_CHANGED :
5980 ds = "Integrated Raid: Volume Settings Changed";
5982 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED :
5983 ds = "Integrated Raid: Volume Status Changed";
5985 case MPI_EVENT_RAID_RC_VOLUME_PHYSDISK_CHANGED :
5986 ds = "Integrated Raid: Volume Physdisk Changed";
5988 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED :
5989 ds = "Integrated Raid: Physdisk Created";
5991 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED :
5992 ds = "Integrated Raid: Physdisk Deleted";
5994 case MPI_EVENT_RAID_RC_PHYSDISK_SETTINGS_CHANGED :
5995 ds = "Integrated Raid: Physdisk Settings Changed";
5997 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED :
5998 ds = "Integrated Raid: Physdisk Status Changed";
6000 case MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED :
6001 ds = "Integrated Raid: Domain Validation Needed";
6003 case MPI_EVENT_RAID_RC_SMART_DATA :
6004 ds = "Integrated Raid; Smart Data";
6006 case MPI_EVENT_RAID_RC_REPLACE_ACTION_STARTED :
6007 ds = "Integrated Raid: Replace Action Started";
6010 ds = "Integrated Raid";
6015 case MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE:
6016 ds = "SCSI Device Status Change";
6018 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
6020 u8 ReasonCode = (u8)(evData0 >> 16);
6021 switch (ReasonCode) {
6022 case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
6023 ds = "SAS Device Status Change: Added";
6025 case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
6026 ds = "SAS Device Status Change: Deleted";
6028 case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
6029 ds = "SAS Device Status Change: SMART Data";
6031 case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
6032 ds = "SAS Device Status Change: No Persistancy Added";
6035 ds = "SAS Device Status Change: Unknown";
6040 case MPI_EVENT_ON_BUS_TIMER_EXPIRED:
6041 ds = "Bus Timer Expired";
6043 case MPI_EVENT_QUEUE_FULL:
6046 case MPI_EVENT_SAS_SES:
6047 ds = "SAS SES Event";
6049 case MPI_EVENT_PERSISTENT_TABLE_FULL:
6050 ds = "Persistent Table Full";
6052 case MPI_EVENT_SAS_PHY_LINK_STATUS:
6053 ds = "SAS PHY Link Status";
6055 case MPI_EVENT_SAS_DISCOVERY_ERROR:
6056 ds = "SAS Discovery Error";
6060 * MPT base "custom" events may be added here...
6069 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6071 * ProcessEventNotification - Route a received EventNotificationReply to
6072 * all currently regeistered event handlers.
6073 * @ioc: Pointer to MPT_ADAPTER structure
6074 * @pEventReply: Pointer to EventNotification reply frame
6075 * @evHandlers: Pointer to integer, number of event handlers
6077 * Returns sum of event handlers return values.
6080 ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *pEventReply, int *evHandlers)
6092 * Do platform normalization of values
6094 event = le32_to_cpu(pEventReply->Event) & 0xFF;
6095 // evCtx = le32_to_cpu(pEventReply->EventContext);
6096 evDataLen = le16_to_cpu(pEventReply->EventDataLength);
6098 evData0 = le32_to_cpu(pEventReply->Data[0]);
6101 EventDescriptionStr(event, evData0, evStr);
6102 devtprintk((MYIOC_s_INFO_FMT "MPT event (%s=%02Xh) detected!\n",
6107 #if defined(MPT_DEBUG) || defined(MPT_DEBUG_EVENTS)
6108 printk(KERN_INFO MYNAM ": Event data:\n" KERN_INFO);
6109 for (ii = 0; ii < evDataLen; ii++)
6110 printk(" %08x", le32_to_cpu(pEventReply->Data[ii]));
6115 * Do general / base driver event processing
6118 case MPI_EVENT_EVENT_CHANGE: /* 0A */
6120 u8 evState = evData0 & 0xFF;
6122 /* CHECKME! What if evState unexpectedly says OFF (0)? */
6124 /* Update EventState field in cached IocFacts */
6125 if (ioc->facts.Function) {
6126 ioc->facts.EventState = evState;
6130 case MPI_EVENT_INTEGRATED_RAID:
6131 mptbase_raid_process_event_data(ioc,
6132 (MpiEventDataRaid_t *)pEventReply->Data);
6139 * Should this event be logged? Events are written sequentially.
6140 * When buffer is full, start again at the top.
6142 if (ioc->events && (ioc->eventTypes & ( 1 << event))) {
6145 idx = ioc->eventContext % ioc->eventLogSize;
6147 ioc->events[idx].event = event;
6148 ioc->events[idx].eventContext = ioc->eventContext;
6150 for (ii = 0; ii < 2; ii++) {
6152 ioc->events[idx].data[ii] = le32_to_cpu(pEventReply->Data[ii]);
6154 ioc->events[idx].data[ii] = 0;
6157 ioc->eventContext++;
6162 * Call each currently registered protocol event handler.
6164 for (ii=MPT_MAX_PROTOCOL_DRIVERS-1; ii; ii--) {
6165 if (MptEvHandlers[ii]) {
6166 devtprintk((MYIOC_s_INFO_FMT "Routing Event to event handler #%d\n",
6168 r += (*(MptEvHandlers[ii]))(ioc, pEventReply);
6172 /* FIXME? Examine results here? */
6175 * If needed, send (a single) EventAck.
6177 if (pEventReply->AckRequired == MPI_EVENT_NOTIFICATION_ACK_REQUIRED) {
6178 devtprintk((MYIOC_s_WARN_FMT
6179 "EventAck required\n",ioc->name));
6180 if ((ii = SendEventAck(ioc, pEventReply)) != 0) {
6181 devtprintk((MYIOC_s_WARN_FMT "SendEventAck returned %d\n",
6186 *evHandlers = handlers;
6190 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6192 * mpt_fc_log_info - Log information returned from Fibre Channel IOC.
6193 * @ioc: Pointer to MPT_ADAPTER structure
6194 * @log_info: U32 LogInfo reply word from the IOC
6196 * Refer to lsi/fc_log.h.
6199 mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info)
6201 static char *subcl_str[8] = {
6202 "FCP Initiator", "FCP Target", "LAN", "MPI Message Layer",
6203 "FC Link", "Context Manager", "Invalid Field Offset", "State Change Info"
6205 u8 subcl = (log_info >> 24) & 0x7;
6207 printk(MYIOC_s_INFO_FMT "LogInfo(0x%08x): SubCl={%s}\n",
6208 ioc->name, log_info, subcl_str[subcl]);
6211 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6213 * mpt_spi_log_info - Log information returned from SCSI Parallel IOC.
6214 * @ioc: Pointer to MPT_ADAPTER structure
6215 * @mr: Pointer to MPT reply frame
6216 * @log_info: U32 LogInfo word from the IOC
6218 * Refer to lsi/sp_log.h.
6221 mpt_spi_log_info(MPT_ADAPTER *ioc, u32 log_info)
6223 u32 info = log_info & 0x00FF0000;
6224 char *desc = "unknown";
6228 desc = "bug! MID not found";
6229 if (ioc->reload_fw == 0)
6234 desc = "Parity Error";
6238 desc = "ASYNC Outbound Overrun";
6242 desc = "SYNC Offset Error";
6250 desc = "Msg In Overflow";
6258 desc = "Outbound DMA Overrun";
6262 desc = "Task Management";
6266 desc = "Device Problem";
6270 desc = "Invalid Phase Change";
6274 desc = "Untagged Table Size";
6279 printk(MYIOC_s_INFO_FMT "LogInfo(0x%08x): F/W: %s\n", ioc->name, log_info, desc);
6282 /* strings for sas loginfo */
6283 static char *originator_str[] = {
6288 static char *iop_code_str[] = {
6290 "Invalid SAS Address", /* 01h */
6292 "Invalid Page", /* 03h */
6294 "Task Terminated" /* 05h */
6296 static char *pl_code_str[] = {
6298 "Open Failure", /* 01h */
6299 "Invalid Scatter Gather List", /* 02h */
6300 "Wrong Relative Offset or Frame Length", /* 03h */
6301 "Frame Transfer Error", /* 04h */
6302 "Transmit Frame Connected Low", /* 05h */
6303 "SATA Non-NCQ RW Error Bit Set", /* 06h */
6304 "SATA Read Log Receive Data Error", /* 07h */
6305 "SATA NCQ Fail All Commands After Error", /* 08h */
6306 "SATA Error in Receive Set Device Bit FIS", /* 09h */
6307 "Receive Frame Invalid Message", /* 0Ah */
6308 "Receive Context Message Valid Error", /* 0Bh */
6309 "Receive Frame Current Frame Error", /* 0Ch */
6310 "SATA Link Down", /* 0Dh */
6311 "Discovery SATA Init W IOS", /* 0Eh */
6312 "Config Invalid Page", /* 0Fh */
6313 "Discovery SATA Init Timeout", /* 10h */
6316 "IO Not Yet Executed", /* 13h */
6317 "IO Executed", /* 14h */
6329 "Enclosure Management" /* 20h */
6332 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6334 * mpt_sas_log_info - Log information returned from SAS IOC.
6335 * @ioc: Pointer to MPT_ADAPTER structure
6336 * @log_info: U32 LogInfo reply word from the IOC
6338 * Refer to lsi/mpi_log_sas.h.
6341 mpt_sas_log_info(MPT_ADAPTER *ioc, u32 log_info)
6343 union loginfo_type {
6352 union loginfo_type sas_loginfo;
6353 char *code_desc = NULL;
6355 sas_loginfo.loginfo = log_info;
6356 if ((sas_loginfo.dw.bus_type != 3 /*SAS*/) &&
6357 (sas_loginfo.dw.originator < sizeof(originator_str)/sizeof(char*)))
6359 if ((sas_loginfo.dw.originator == 0 /*IOP*/) &&
6360 (sas_loginfo.dw.code < sizeof(iop_code_str)/sizeof(char*))) {
6361 code_desc = iop_code_str[sas_loginfo.dw.code];
6362 }else if ((sas_loginfo.dw.originator == 1 /*PL*/) &&
6363 (sas_loginfo.dw.code < sizeof(pl_code_str)/sizeof(char*) )) {
6364 code_desc = pl_code_str[sas_loginfo.dw.code];
6367 if (code_desc != NULL)
6368 printk(MYIOC_s_INFO_FMT
6369 "LogInfo(0x%08x): Originator={%s}, Code={%s},"
6370 " SubCode(0x%04x)\n",
6373 originator_str[sas_loginfo.dw.originator],
6375 sas_loginfo.dw.subcode);
6377 printk(MYIOC_s_INFO_FMT
6378 "LogInfo(0x%08x): Originator={%s}, Code=(0x%02x),"
6379 " SubCode(0x%04x)\n",
6382 originator_str[sas_loginfo.dw.originator],
6383 sas_loginfo.dw.code,
6384 sas_loginfo.dw.subcode);
6387 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6389 * mpt_sp_ioc_info - IOC information returned from SCSI Parallel IOC.
6390 * @ioc: Pointer to MPT_ADAPTER structure
6391 * @ioc_status: U32 IOCStatus word from IOC
6392 * @mf: Pointer to MPT request frame
6394 * Refer to lsi/mpi.h.
6397 mpt_sp_ioc_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf)
6399 u32 status = ioc_status & MPI_IOCSTATUS_MASK;
6403 case MPI_IOCSTATUS_INVALID_FUNCTION: /* 0x0001 */
6404 desc = "Invalid Function";
6407 case MPI_IOCSTATUS_BUSY: /* 0x0002 */
6411 case MPI_IOCSTATUS_INVALID_SGL: /* 0x0003 */
6412 desc = "Invalid SGL";
6415 case MPI_IOCSTATUS_INTERNAL_ERROR: /* 0x0004 */
6416 desc = "Internal Error";
6419 case MPI_IOCSTATUS_RESERVED: /* 0x0005 */
6423 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
6424 desc = "Insufficient Resources";
6427 case MPI_IOCSTATUS_INVALID_FIELD: /* 0x0007 */
6428 desc = "Invalid Field";
6431 case MPI_IOCSTATUS_INVALID_STATE: /* 0x0008 */
6432 desc = "Invalid State";
6435 case MPI_IOCSTATUS_CONFIG_INVALID_ACTION: /* 0x0020 */
6436 case MPI_IOCSTATUS_CONFIG_INVALID_TYPE: /* 0x0021 */
6437 case MPI_IOCSTATUS_CONFIG_INVALID_PAGE: /* 0x0022 */
6438 case MPI_IOCSTATUS_CONFIG_INVALID_DATA: /* 0x0023 */
6439 case MPI_IOCSTATUS_CONFIG_NO_DEFAULTS: /* 0x0024 */
6440 case MPI_IOCSTATUS_CONFIG_CANT_COMMIT: /* 0x0025 */
6441 /* No message for Config IOCStatus values */
6444 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
6445 /* No message for recovered error
6446 desc = "SCSI Recovered Error";
6450 case MPI_IOCSTATUS_SCSI_INVALID_BUS: /* 0x0041 */
6451 desc = "SCSI Invalid Bus";
6454 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID: /* 0x0042 */
6455 desc = "SCSI Invalid TargetID";
6458 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
6460 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
6461 U8 cdb = pScsiReq->CDB[0];
6462 if (cdb != 0x12) { /* Inquiry is issued for device scanning */
6463 desc = "SCSI Device Not There";
6468 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: /* 0x0044 */
6469 desc = "SCSI Data Overrun";
6472 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
6473 /* This error is checked in scsi_io_done(). Skip.
6474 desc = "SCSI Data Underrun";
6478 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
6479 desc = "SCSI I/O Data Error";
6482 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
6483 desc = "SCSI Protocol Error";
6486 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
6487 desc = "SCSI Task Terminated";
6490 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */
6491 desc = "SCSI Residual Mismatch";
6494 case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED: /* 0x004A */
6495 desc = "SCSI Task Management Failed";
6498 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
6499 desc = "SCSI IOC Terminated";
6502 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
6503 desc = "SCSI Ext Terminated";
6511 printk(MYIOC_s_INFO_FMT "IOCStatus(0x%04x): %s\n", ioc->name, status, desc);
6514 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6515 EXPORT_SYMBOL(mpt_attach);
6516 EXPORT_SYMBOL(mpt_detach);
6518 EXPORT_SYMBOL(mpt_resume);
6519 EXPORT_SYMBOL(mpt_suspend);
6521 EXPORT_SYMBOL(ioc_list);
6522 EXPORT_SYMBOL(mpt_proc_root_dir);
6523 EXPORT_SYMBOL(mpt_register);
6524 EXPORT_SYMBOL(mpt_deregister);
6525 EXPORT_SYMBOL(mpt_event_register);
6526 EXPORT_SYMBOL(mpt_event_deregister);
6527 EXPORT_SYMBOL(mpt_reset_register);
6528 EXPORT_SYMBOL(mpt_reset_deregister);
6529 EXPORT_SYMBOL(mpt_device_driver_register);
6530 EXPORT_SYMBOL(mpt_device_driver_deregister);
6531 EXPORT_SYMBOL(mpt_get_msg_frame);
6532 EXPORT_SYMBOL(mpt_put_msg_frame);
6533 EXPORT_SYMBOL(mpt_free_msg_frame);
6534 EXPORT_SYMBOL(mpt_add_sge);
6535 EXPORT_SYMBOL(mpt_send_handshake_request);
6536 EXPORT_SYMBOL(mpt_verify_adapter);
6537 EXPORT_SYMBOL(mpt_GetIocState);
6538 EXPORT_SYMBOL(mpt_print_ioc_summary);
6539 EXPORT_SYMBOL(mpt_lan_index);
6540 EXPORT_SYMBOL(mpt_stm_index);
6541 EXPORT_SYMBOL(mpt_HardResetHandler);
6542 EXPORT_SYMBOL(mpt_config);
6543 EXPORT_SYMBOL(mpt_toolbox);
6544 EXPORT_SYMBOL(mpt_findImVolumes);
6545 EXPORT_SYMBOL(mpt_read_ioc_pg_3);
6546 EXPORT_SYMBOL(mpt_alloc_fw_memory);
6547 EXPORT_SYMBOL(mpt_free_fw_memory);
6548 EXPORT_SYMBOL(mptbase_sas_persist_operation);
6549 EXPORT_SYMBOL(mpt_alt_ioc_wait);
6550 EXPORT_SYMBOL(mptbase_GetFcPortPage0);
6553 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6555 * fusion_init - Fusion MPT base driver initialization routine.
6557 * Returns 0 for success, non-zero for failure.
6564 show_mptmod_ver(my_NAME, my_VERSION);
6565 printk(KERN_INFO COPYRIGHT "\n");
6567 for (i = 0; i < MPT_MAX_PROTOCOL_DRIVERS; i++) {
6568 MptCallbacks[i] = NULL;
6569 MptDriverClass[i] = MPTUNKNOWN_DRIVER;
6570 MptEvHandlers[i] = NULL;
6571 MptResetHandlers[i] = NULL;
6574 /* Register ourselves (mptbase) in order to facilitate
6575 * EventNotification handling.
6577 mpt_base_index = mpt_register(mpt_base_reply, MPTBASE_DRIVER);
6579 /* Register for hard reset handling callbacks.
6581 if (mpt_reset_register(mpt_base_index, mpt_ioc_reset) == 0) {
6582 dprintk((KERN_INFO MYNAM ": Register for IOC reset notification\n"));
6587 #ifdef CONFIG_PROC_FS
6588 (void) procmpt_create();
6593 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6595 * fusion_exit - Perform driver unload cleanup.
6597 * This routine frees all resources associated with each MPT adapter
6598 * and removes all %MPT_PROCFS_MPTBASEDIR entries.
6604 dexitprintk((KERN_INFO MYNAM ": fusion_exit() called!\n"));
6606 mpt_reset_deregister(mpt_base_index);
6608 #ifdef CONFIG_PROC_FS
6613 module_init(fusion_init);
6614 module_exit(fusion_exit);