Merge master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6
[linux-2.6.git] / drivers / message / fusion / mptbase.c
1 /*
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.
7  *
8  *  Copyright (c) 1999-2005 LSI Logic Corporation
9  *  (mailto:mpt_linux_developer@lsil.com)
10  *
11  */
12 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13 /*
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.
17
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.
22
23     NO WARRANTY
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.
33
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
42
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
46 */
47 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
48
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>
62 #include <asm/io.h>
63 #ifdef CONFIG_MTRR
64 #include <asm/mtrr.h>
65 #endif
66 #ifdef __sparc__
67 #include <asm/irq.h>                    /* needed for __irq_itoa() proto */
68 #endif
69
70 #include "mptbase.h"
71
72 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
73 #define my_NAME         "Fusion MPT base driver"
74 #define my_VERSION      MPT_LINUX_VERSION_COMMON
75 #define MYNAM           "mptbase"
76
77 MODULE_AUTHOR(MODULEAUTHOR);
78 MODULE_DESCRIPTION(my_NAME);
79 MODULE_LICENSE("GPL");
80
81 /*
82  *  cmd line parameters
83  */
84 #ifdef MFCNT
85 static int mfcounter = 0;
86 #define PRINT_MF_COUNT 20000
87 #endif
88
89 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
90 /*
91  *  Public data...
92  */
93 int mpt_lan_index = -1;
94 int mpt_stm_index = -1;
95
96 struct proc_dir_entry *mpt_proc_root_dir;
97
98 #define WHOINIT_UNKNOWN         0xAA
99
100 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
101 /*
102  *  Private data...
103  */
104                                         /* Adapter link list */
105 LIST_HEAD(ioc_list);
106                                         /* Callback lookup table */
107 static MPT_CALLBACK              MptCallbacks[MPT_MAX_PROTOCOL_DRIVERS];
108                                         /* Protocol driver class lookup table */
109 static int                       MptDriverClass[MPT_MAX_PROTOCOL_DRIVERS];
110                                         /* Event handler lookup table */
111 static MPT_EVHANDLER             MptEvHandlers[MPT_MAX_PROTOCOL_DRIVERS];
112                                         /* Reset handler lookup table */
113 static MPT_RESETHANDLER          MptResetHandlers[MPT_MAX_PROTOCOL_DRIVERS];
114 static struct mpt_pci_driver    *MptDeviceDriverHandlers[MPT_MAX_PROTOCOL_DRIVERS];
115
116 static int      mpt_base_index = -1;
117 static int      last_drv_idx = -1;
118
119 static DECLARE_WAIT_QUEUE_HEAD(mpt_waitq);
120
121 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
122 /*
123  *  Forward protos...
124  */
125 static irqreturn_t mpt_interrupt(int irq, void *bus_id, struct pt_regs *r);
126 static int      mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);
127 static int      mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes,
128                         u32 *req, int replyBytes, u16 *u16reply, int maxwait,
129                         int sleepFlag);
130 static int      mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag);
131 static void     mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev);
132 static void     mpt_adapter_disable(MPT_ADAPTER *ioc);
133 static void     mpt_adapter_dispose(MPT_ADAPTER *ioc);
134
135 static void     MptDisplayIocCapabilities(MPT_ADAPTER *ioc);
136 static int      MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag);
137 static int      GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason);
138 static int      GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
139 static int      SendIocInit(MPT_ADAPTER *ioc, int sleepFlag);
140 static int      SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
141 static int      mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag);
142 static int      mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag);
143 static int      mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
144 static int      KickStart(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
145 static int      SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag);
146 static int      PrimeIocFifos(MPT_ADAPTER *ioc);
147 static int      WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
148 static int      WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
149 static int      WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
150 static int      GetLanConfigPages(MPT_ADAPTER *ioc);
151 static int      GetIoUnitPage2(MPT_ADAPTER *ioc);
152 int             mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode);
153 static int      mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum);
154 static int      mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum);
155 static void     mpt_read_ioc_pg_1(MPT_ADAPTER *ioc);
156 static void     mpt_read_ioc_pg_4(MPT_ADAPTER *ioc);
157 static void     mpt_timer_expired(unsigned long data);
158 static int      SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch);
159 static int      SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp);
160 static int      mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag);
161 static int      mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init);
162
163 #ifdef CONFIG_PROC_FS
164 static int      procmpt_summary_read(char *buf, char **start, off_t offset,
165                                 int request, int *eof, void *data);
166 static int      procmpt_version_read(char *buf, char **start, off_t offset,
167                                 int request, int *eof, void *data);
168 static int      procmpt_iocinfo_read(char *buf, char **start, off_t offset,
169                                 int request, int *eof, void *data);
170 #endif
171 static void     mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc);
172
173 //int           mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag);
174 static int      ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *evReply, int *evHandlers);
175 static void     mpt_sp_ioc_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf);
176 static void     mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info);
177 static void     mpt_sp_log_info(MPT_ADAPTER *ioc, u32 log_info);
178 static void     mpt_sas_log_info(MPT_ADAPTER *ioc, u32 log_info);
179
180 /* module entry point */
181 static int  __init    fusion_init  (void);
182 static void __exit    fusion_exit  (void);
183
184 #define CHIPREG_READ32(addr)            readl_relaxed(addr)
185 #define CHIPREG_READ32_dmasync(addr)    readl(addr)
186 #define CHIPREG_WRITE32(addr,val)       writel(val, addr)
187 #define CHIPREG_PIO_WRITE32(addr,val)   outl(val, (unsigned long)addr)
188 #define CHIPREG_PIO_READ32(addr)        inl((unsigned long)addr)
189
190 static void
191 pci_disable_io_access(struct pci_dev *pdev)
192 {
193         u16 command_reg;
194
195         pci_read_config_word(pdev, PCI_COMMAND, &command_reg);
196         command_reg &= ~1;
197         pci_write_config_word(pdev, PCI_COMMAND, command_reg);
198 }
199
200 static void
201 pci_enable_io_access(struct pci_dev *pdev)
202 {
203         u16 command_reg;
204
205         pci_read_config_word(pdev, PCI_COMMAND, &command_reg);
206         command_reg |= 1;
207         pci_write_config_word(pdev, PCI_COMMAND, command_reg);
208 }
209
210 /*
211  *  Process turbo (context) reply...
212  */
213 static void
214 mpt_turbo_reply(MPT_ADAPTER *ioc, u32 pa)
215 {
216         MPT_FRAME_HDR *mf = NULL;
217         MPT_FRAME_HDR *mr = NULL;
218         int req_idx = 0;
219         int cb_idx;
220
221         dmfprintk((MYIOC_s_INFO_FMT "Got TURBO reply req_idx=%08x\n",
222                                 ioc->name, pa));
223
224         switch (pa >> MPI_CONTEXT_REPLY_TYPE_SHIFT) {
225         case MPI_CONTEXT_REPLY_TYPE_SCSI_INIT:
226                 req_idx = pa & 0x0000FFFF;
227                 cb_idx = (pa & 0x00FF0000) >> 16;
228                 mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
229                 break;
230         case MPI_CONTEXT_REPLY_TYPE_LAN:
231                 cb_idx = mpt_lan_index;
232                 /*
233                  *  Blind set of mf to NULL here was fatal
234                  *  after lan_reply says "freeme"
235                  *  Fix sort of combined with an optimization here;
236                  *  added explicit check for case where lan_reply
237                  *  was just returning 1 and doing nothing else.
238                  *  For this case skip the callback, but set up
239                  *  proper mf value first here:-)
240                  */
241                 if ((pa & 0x58000000) == 0x58000000) {
242                         req_idx = pa & 0x0000FFFF;
243                         mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
244                         mpt_free_msg_frame(ioc, mf);
245                         mb();
246                         return;
247                         break;
248                 }
249                 mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
250                 break;
251         case MPI_CONTEXT_REPLY_TYPE_SCSI_TARGET:
252                 cb_idx = mpt_stm_index;
253                 mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
254                 break;
255         default:
256                 cb_idx = 0;
257                 BUG();
258         }
259
260         /*  Check for (valid) IO callback!  */
261         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
262                         MptCallbacks[cb_idx] == NULL) {
263                 printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
264                                 __FUNCTION__, ioc->name, cb_idx);
265                 goto out;
266         }
267
268         if (MptCallbacks[cb_idx](ioc, mf, mr))
269                 mpt_free_msg_frame(ioc, mf);
270  out:
271         mb();
272 }
273
274 static void
275 mpt_reply(MPT_ADAPTER *ioc, u32 pa)
276 {
277         MPT_FRAME_HDR   *mf;
278         MPT_FRAME_HDR   *mr;
279         int              req_idx;
280         int              cb_idx;
281         int              freeme;
282
283         u32 reply_dma_low;
284         u16 ioc_stat;
285
286         /* non-TURBO reply!  Hmmm, something may be up...
287          *  Newest turbo reply mechanism; get address
288          *  via left shift 1 (get rid of MPI_ADDRESS_REPLY_A_BIT)!
289          */
290
291         /* Map DMA address of reply header to cpu address.
292          * pa is 32 bits - but the dma address may be 32 or 64 bits
293          * get offset based only only the low addresses
294          */
295
296         reply_dma_low = (pa <<= 1);
297         mr = (MPT_FRAME_HDR *)((u8 *)ioc->reply_frames +
298                          (reply_dma_low - ioc->reply_frames_low_dma));
299
300         req_idx = le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx);
301         cb_idx = mr->u.frame.hwhdr.msgctxu.fld.cb_idx;
302         mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
303
304         dmfprintk((MYIOC_s_INFO_FMT "Got non-TURBO reply=%p req_idx=%x cb_idx=%x Function=%x\n",
305                         ioc->name, mr, req_idx, cb_idx, mr->u.hdr.Function));
306         DBG_DUMP_REPLY_FRAME(mr)
307
308          /*  Check/log IOC log info
309          */
310         ioc_stat = le16_to_cpu(mr->u.reply.IOCStatus);
311         if (ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) {
312                 u32      log_info = le32_to_cpu(mr->u.reply.IOCLogInfo);
313                 if (ioc->bus_type == FC)
314                         mpt_fc_log_info(ioc, log_info);
315                 else if (ioc->bus_type == SPI)
316                         mpt_sp_log_info(ioc, log_info);
317                 else if (ioc->bus_type == SAS)
318                         mpt_sas_log_info(ioc, log_info);
319         }
320         if (ioc_stat & MPI_IOCSTATUS_MASK) {
321                 if (ioc->bus_type == SPI &&
322                     cb_idx != mpt_stm_index &&
323                     cb_idx != mpt_lan_index)
324                         mpt_sp_ioc_info(ioc, (u32)ioc_stat, mf);
325         }
326
327
328         /*  Check for (valid) IO callback!  */
329         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
330                         MptCallbacks[cb_idx] == NULL) {
331                 printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
332                                 __FUNCTION__, ioc->name, cb_idx);
333                 freeme = 0;
334                 goto out;
335         }
336
337         freeme = MptCallbacks[cb_idx](ioc, mf, mr);
338
339  out:
340         /*  Flush (non-TURBO) reply with a WRITE!  */
341         CHIPREG_WRITE32(&ioc->chip->ReplyFifo, pa);
342
343         if (freeme)
344                 mpt_free_msg_frame(ioc, mf);
345         mb();
346 }
347
348 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
349 /*
350  *      mpt_interrupt - MPT adapter (IOC) specific interrupt handler.
351  *      @irq: irq number (not used)
352  *      @bus_id: bus identifier cookie == pointer to MPT_ADAPTER structure
353  *      @r: pt_regs pointer (not used)
354  *
355  *      This routine is registered via the request_irq() kernel API call,
356  *      and handles all interrupts generated from a specific MPT adapter
357  *      (also referred to as a IO Controller or IOC).
358  *      This routine must clear the interrupt from the adapter and does
359  *      so by reading the reply FIFO.  Multiple replies may be processed
360  *      per single call to this routine.
361  *
362  *      This routine handles register-level access of the adapter but
363  *      dispatches (calls) a protocol-specific callback routine to handle
364  *      the protocol-specific details of the MPT request completion.
365  */
366 static irqreturn_t
367 mpt_interrupt(int irq, void *bus_id, struct pt_regs *r)
368 {
369         MPT_ADAPTER *ioc = bus_id;
370         u32 pa;
371
372         /*
373          *  Drain the reply FIFO!
374          */
375         while (1) {
376                 pa = CHIPREG_READ32_dmasync(&ioc->chip->ReplyFifo);
377                 if (pa == 0xFFFFFFFF)
378                         return IRQ_HANDLED;
379                 else if (pa & MPI_ADDRESS_REPLY_A_BIT)
380                         mpt_reply(ioc, pa);
381                 else
382                         mpt_turbo_reply(ioc, pa);
383         }
384
385         return IRQ_HANDLED;
386 }
387
388 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
389 /*
390  *      mpt_base_reply - MPT base driver's callback routine; all base driver
391  *      "internal" request/reply processing is routed here.
392  *      Currently used for EventNotification and EventAck handling.
393  *      @ioc: Pointer to MPT_ADAPTER structure
394  *      @mf: Pointer to original MPT request frame
395  *      @reply: Pointer to MPT reply frame (NULL if TurboReply)
396  *
397  *      Returns 1 indicating original alloc'd request frame ptr
398  *      should be freed, or 0 if it shouldn't.
399  */
400 static int
401 mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply)
402 {
403         int freereq = 1;
404         u8 func;
405
406         dmfprintk((MYIOC_s_INFO_FMT "mpt_base_reply() called\n", ioc->name));
407
408 #if defined(MPT_DEBUG_MSG_FRAME)
409         if (!(reply->u.hdr.MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY)) {
410                 dmfprintk((KERN_INFO MYNAM ": Original request frame (@%p) header\n", mf));
411                 DBG_DUMP_REQUEST_FRAME_HDR(mf)
412         }
413 #endif
414
415         func = reply->u.hdr.Function;
416         dmfprintk((MYIOC_s_INFO_FMT "mpt_base_reply, Function=%02Xh\n",
417                         ioc->name, func));
418
419         if (func == MPI_FUNCTION_EVENT_NOTIFICATION) {
420                 EventNotificationReply_t *pEvReply = (EventNotificationReply_t *) reply;
421                 int evHandlers = 0;
422                 int results;
423
424                 results = ProcessEventNotification(ioc, pEvReply, &evHandlers);
425                 if (results != evHandlers) {
426                         /* CHECKME! Any special handling needed here? */
427                         devtprintk((MYIOC_s_WARN_FMT "Called %d event handlers, sum results = %d\n",
428                                         ioc->name, evHandlers, results));
429                 }
430
431                 /*
432                  *      Hmmm...  It seems that EventNotificationReply is an exception
433                  *      to the rule of one reply per request.
434                  */
435                 if (pEvReply->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY) {
436                         freereq = 0;
437                         devtprintk((MYIOC_s_WARN_FMT "EVENT_NOTIFICATION reply %p does not return Request frame\n",
438                                 ioc->name, pEvReply));
439                 } else {
440                         devtprintk((MYIOC_s_WARN_FMT "EVENT_NOTIFICATION reply %p returns Request frame\n",
441                                 ioc->name, pEvReply));
442                 }
443
444 #ifdef CONFIG_PROC_FS
445 //              LogEvent(ioc, pEvReply);
446 #endif
447
448         } else if (func == MPI_FUNCTION_EVENT_ACK) {
449                 dprintk((MYIOC_s_INFO_FMT "mpt_base_reply, EventAck reply received\n",
450                                 ioc->name));
451         } else if (func == MPI_FUNCTION_CONFIG ||
452                    func == MPI_FUNCTION_TOOLBOX) {
453                 CONFIGPARMS *pCfg;
454                 unsigned long flags;
455
456                 dcprintk((MYIOC_s_INFO_FMT "config_complete (mf=%p,mr=%p)\n",
457                                 ioc->name, mf, reply));
458
459                 pCfg = * ((CONFIGPARMS **)((u8 *) mf + ioc->req_sz - sizeof(void *)));
460
461                 if (pCfg) {
462                         /* disable timer and remove from linked list */
463                         del_timer(&pCfg->timer);
464
465                         spin_lock_irqsave(&ioc->FreeQlock, flags);
466                         list_del(&pCfg->linkage);
467                         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
468
469                         /*
470                          *      If IOC Status is SUCCESS, save the header
471                          *      and set the status code to GOOD.
472                          */
473                         pCfg->status = MPT_CONFIG_ERROR;
474                         if (reply) {
475                                 ConfigReply_t   *pReply = (ConfigReply_t *)reply;
476                                 u16              status;
477
478                                 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
479                                 dcprintk((KERN_NOTICE "  IOCStatus=%04xh, IOCLogInfo=%08xh\n",
480                                      status, le32_to_cpu(pReply->IOCLogInfo)));
481
482                                 pCfg->status = status;
483                                 if (status == MPI_IOCSTATUS_SUCCESS) {
484                                         if ((pReply->Header.PageType &
485                                             MPI_CONFIG_PAGETYPE_MASK) ==
486                                             MPI_CONFIG_PAGETYPE_EXTENDED) {
487                                                 pCfg->cfghdr.ehdr->ExtPageLength =
488                                                     le16_to_cpu(pReply->ExtPageLength);
489                                                 pCfg->cfghdr.ehdr->ExtPageType =
490                                                     pReply->ExtPageType;
491                                         }
492                                         pCfg->cfghdr.hdr->PageVersion = pReply->Header.PageVersion;
493
494                                         /* If this is a regular header, save PageLength. */
495                                         /* LMP Do this better so not using a reserved field! */
496                                         pCfg->cfghdr.hdr->PageLength = pReply->Header.PageLength;
497                                         pCfg->cfghdr.hdr->PageNumber = pReply->Header.PageNumber;
498                                         pCfg->cfghdr.hdr->PageType = pReply->Header.PageType;
499                                 }
500                         }
501
502                         /*
503                          *      Wake up the original calling thread
504                          */
505                         pCfg->wait_done = 1;
506                         wake_up(&mpt_waitq);
507                 }
508         } else if (func == MPI_FUNCTION_SAS_IO_UNIT_CONTROL) {
509                 /* we should be always getting a reply frame */
510                 memcpy(ioc->persist_reply_frame, reply,
511                     min(MPT_DEFAULT_FRAME_SIZE,
512                     4*reply->u.reply.MsgLength));
513                 del_timer(&ioc->persist_timer);
514                 ioc->persist_wait_done = 1;
515                 wake_up(&mpt_waitq);
516         } else {
517                 printk(MYIOC_s_ERR_FMT "Unexpected msg function (=%02Xh) reply received!\n",
518                                 ioc->name, func);
519         }
520
521         /*
522          *      Conditionally tell caller to free the original
523          *      EventNotification/EventAck/unexpected request frame!
524          */
525         return freereq;
526 }
527
528 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
529 /**
530  *      mpt_register - Register protocol-specific main callback handler.
531  *      @cbfunc: callback function pointer
532  *      @dclass: Protocol driver's class (%MPT_DRIVER_CLASS enum value)
533  *
534  *      This routine is called by a protocol-specific driver (SCSI host,
535  *      LAN, SCSI target) to register it's reply callback routine.  Each
536  *      protocol-specific driver must do this before it will be able to
537  *      use any IOC resources, such as obtaining request frames.
538  *
539  *      NOTES: The SCSI protocol driver currently calls this routine thrice
540  *      in order to register separate callbacks; one for "normal" SCSI IO;
541  *      one for MptScsiTaskMgmt requests; one for Scan/DV requests.
542  *
543  *      Returns a positive integer valued "handle" in the
544  *      range (and S.O.D. order) {N,...,7,6,5,...,1} if successful.
545  *      Any non-positive return value (including zero!) should be considered
546  *      an error by the caller.
547  */
548 int
549 mpt_register(MPT_CALLBACK cbfunc, MPT_DRIVER_CLASS dclass)
550 {
551         int i;
552
553         last_drv_idx = -1;
554
555         /*
556          *  Search for empty callback slot in this order: {N,...,7,6,5,...,1}
557          *  (slot/handle 0 is reserved!)
558          */
559         for (i = MPT_MAX_PROTOCOL_DRIVERS-1; i; i--) {
560                 if (MptCallbacks[i] == NULL) {
561                         MptCallbacks[i] = cbfunc;
562                         MptDriverClass[i] = dclass;
563                         MptEvHandlers[i] = NULL;
564                         last_drv_idx = i;
565                         break;
566                 }
567         }
568
569         return last_drv_idx;
570 }
571
572 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
573 /**
574  *      mpt_deregister - Deregister a protocol drivers resources.
575  *      @cb_idx: previously registered callback handle
576  *
577  *      Each protocol-specific driver should call this routine when it's
578  *      module is unloaded.
579  */
580 void
581 mpt_deregister(int cb_idx)
582 {
583         if ((cb_idx >= 0) && (cb_idx < MPT_MAX_PROTOCOL_DRIVERS)) {
584                 MptCallbacks[cb_idx] = NULL;
585                 MptDriverClass[cb_idx] = MPTUNKNOWN_DRIVER;
586                 MptEvHandlers[cb_idx] = NULL;
587
588                 last_drv_idx++;
589         }
590 }
591
592 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
593 /**
594  *      mpt_event_register - Register protocol-specific event callback
595  *      handler.
596  *      @cb_idx: previously registered (via mpt_register) callback handle
597  *      @ev_cbfunc: callback function
598  *
599  *      This routine can be called by one or more protocol-specific drivers
600  *      if/when they choose to be notified of MPT events.
601  *
602  *      Returns 0 for success.
603  */
604 int
605 mpt_event_register(int cb_idx, MPT_EVHANDLER ev_cbfunc)
606 {
607         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
608                 return -1;
609
610         MptEvHandlers[cb_idx] = ev_cbfunc;
611         return 0;
612 }
613
614 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
615 /**
616  *      mpt_event_deregister - Deregister protocol-specific event callback
617  *      handler.
618  *      @cb_idx: previously registered callback handle
619  *
620  *      Each protocol-specific driver should call this routine
621  *      when it does not (or can no longer) handle events,
622  *      or when it's module is unloaded.
623  */
624 void
625 mpt_event_deregister(int cb_idx)
626 {
627         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
628                 return;
629
630         MptEvHandlers[cb_idx] = NULL;
631 }
632
633 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
634 /**
635  *      mpt_reset_register - Register protocol-specific IOC reset handler.
636  *      @cb_idx: previously registered (via mpt_register) callback handle
637  *      @reset_func: reset function
638  *
639  *      This routine can be called by one or more protocol-specific drivers
640  *      if/when they choose to be notified of IOC resets.
641  *
642  *      Returns 0 for success.
643  */
644 int
645 mpt_reset_register(int cb_idx, MPT_RESETHANDLER reset_func)
646 {
647         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
648                 return -1;
649
650         MptResetHandlers[cb_idx] = reset_func;
651         return 0;
652 }
653
654 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
655 /**
656  *      mpt_reset_deregister - Deregister protocol-specific IOC reset handler.
657  *      @cb_idx: previously registered callback handle
658  *
659  *      Each protocol-specific driver should call this routine
660  *      when it does not (or can no longer) handle IOC reset handling,
661  *      or when it's module is unloaded.
662  */
663 void
664 mpt_reset_deregister(int cb_idx)
665 {
666         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
667                 return;
668
669         MptResetHandlers[cb_idx] = NULL;
670 }
671
672 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
673 /**
674  *      mpt_device_driver_register - Register device driver hooks
675  */
676 int
677 mpt_device_driver_register(struct mpt_pci_driver * dd_cbfunc, int cb_idx)
678 {
679         MPT_ADAPTER     *ioc;
680
681         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS) {
682                 return -EINVAL;
683         }
684
685         MptDeviceDriverHandlers[cb_idx] = dd_cbfunc;
686
687         /* call per pci device probe entry point */
688         list_for_each_entry(ioc, &ioc_list, list) {
689                 if(dd_cbfunc->probe) {
690                         dd_cbfunc->probe(ioc->pcidev,
691                           ioc->pcidev->driver->id_table);
692                 }
693          }
694
695         return 0;
696 }
697
698 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
699 /**
700  *      mpt_device_driver_deregister - DeRegister device driver hooks
701  */
702 void
703 mpt_device_driver_deregister(int cb_idx)
704 {
705         struct mpt_pci_driver *dd_cbfunc;
706         MPT_ADAPTER     *ioc;
707
708         if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
709                 return;
710
711         dd_cbfunc = MptDeviceDriverHandlers[cb_idx];
712
713         list_for_each_entry(ioc, &ioc_list, list) {
714                 if (dd_cbfunc->remove)
715                         dd_cbfunc->remove(ioc->pcidev);
716         }
717
718         MptDeviceDriverHandlers[cb_idx] = NULL;
719 }
720
721
722 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
723 /**
724  *      mpt_get_msg_frame - Obtain a MPT request frame from the pool (of 1024)
725  *      allocated per MPT adapter.
726  *      @handle: Handle of registered MPT protocol driver
727  *      @ioc: Pointer to MPT adapter structure
728  *
729  *      Returns pointer to a MPT request frame or %NULL if none are available
730  *      or IOC is not active.
731  */
732 MPT_FRAME_HDR*
733 mpt_get_msg_frame(int handle, MPT_ADAPTER *ioc)
734 {
735         MPT_FRAME_HDR *mf;
736         unsigned long flags;
737         u16      req_idx;       /* Request index */
738
739         /* validate handle and ioc identifier */
740
741 #ifdef MFCNT
742         if (!ioc->active)
743                 printk(KERN_WARNING "IOC Not Active! mpt_get_msg_frame returning NULL!\n");
744 #endif
745
746         /* If interrupts are not attached, do not return a request frame */
747         if (!ioc->active)
748                 return NULL;
749
750         spin_lock_irqsave(&ioc->FreeQlock, flags);
751         if (!list_empty(&ioc->FreeQ)) {
752                 int req_offset;
753
754                 mf = list_entry(ioc->FreeQ.next, MPT_FRAME_HDR,
755                                 u.frame.linkage.list);
756                 list_del(&mf->u.frame.linkage.list);
757                 mf->u.frame.linkage.arg1 = 0;
758                 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = handle;  /* byte */
759                 req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
760                                                                 /* u16! */
761                 req_idx = req_offset / ioc->req_sz;
762                 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
763                 mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
764                 ioc->RequestNB[req_idx] = ioc->NB_for_64_byte_frame; /* Default, will be changed if necessary in SG generation */
765 #ifdef MFCNT
766                 ioc->mfcnt++;
767 #endif
768         }
769         else
770                 mf = NULL;
771         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
772
773 #ifdef MFCNT
774         if (mf == NULL)
775                 printk(KERN_WARNING "IOC Active. No free Msg Frames! Count 0x%x Max 0x%x\n", ioc->mfcnt, ioc->req_depth);
776         mfcounter++;
777         if (mfcounter == PRINT_MF_COUNT)
778                 printk(KERN_INFO "MF Count 0x%x Max 0x%x \n", ioc->mfcnt, ioc->req_depth);
779 #endif
780
781         dmfprintk((KERN_INFO MYNAM ": %s: mpt_get_msg_frame(%d,%d), got mf=%p\n",
782                         ioc->name, handle, ioc->id, mf));
783         return mf;
784 }
785
786 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
787 /**
788  *      mpt_put_msg_frame - Send a protocol specific MPT request frame
789  *      to a IOC.
790  *      @handle: Handle of registered MPT protocol driver
791  *      @ioc: Pointer to MPT adapter structure
792  *      @mf: Pointer to MPT request frame
793  *
794  *      This routine posts a MPT request frame to the request post FIFO of a
795  *      specific MPT adapter.
796  */
797 void
798 mpt_put_msg_frame(int handle, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
799 {
800         u32 mf_dma_addr;
801         int req_offset;
802         u16      req_idx;       /* Request index */
803
804         /* ensure values are reset properly! */
805         mf->u.frame.hwhdr.msgctxu.fld.cb_idx = handle;          /* byte */
806         req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
807                                                                 /* u16! */
808         req_idx = req_offset / ioc->req_sz;
809         mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
810         mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
811
812 #ifdef MPT_DEBUG_MSG_FRAME
813         {
814                 u32     *m = mf->u.frame.hwhdr.__hdr;
815                 int      ii, n;
816
817                 printk(KERN_INFO MYNAM ": %s: About to Put msg frame @ %p:\n" KERN_INFO " ",
818                                 ioc->name, m);
819                 n = ioc->req_sz/4 - 1;
820                 while (m[n] == 0)
821                         n--;
822                 for (ii=0; ii<=n; ii++) {
823                         if (ii && ((ii%8)==0))
824                                 printk("\n" KERN_INFO " ");
825                         printk(" %08x", le32_to_cpu(m[ii]));
826                 }
827                 printk("\n");
828         }
829 #endif
830
831         mf_dma_addr = (ioc->req_frames_low_dma + req_offset) | ioc->RequestNB[req_idx];
832         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]));
833         CHIPREG_WRITE32(&ioc->chip->RequestFifo, mf_dma_addr);
834 }
835
836 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
837 /**
838  *      mpt_free_msg_frame - Place MPT request frame back on FreeQ.
839  *      @handle: Handle of registered MPT protocol driver
840  *      @ioc: Pointer to MPT adapter structure
841  *      @mf: Pointer to MPT request frame
842  *
843  *      This routine places a MPT request frame back on the MPT adapter's
844  *      FreeQ.
845  */
846 void
847 mpt_free_msg_frame(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
848 {
849         unsigned long flags;
850
851         /*  Put Request back on FreeQ!  */
852         spin_lock_irqsave(&ioc->FreeQlock, flags);
853         mf->u.frame.linkage.arg1 = 0xdeadbeaf; /* signature to know if this mf is freed */
854         list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeQ);
855 #ifdef MFCNT
856         ioc->mfcnt--;
857 #endif
858         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
859 }
860
861 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
862 /**
863  *      mpt_add_sge - Place a simple SGE at address pAddr.
864  *      @pAddr: virtual address for SGE
865  *      @flagslength: SGE flags and data transfer length
866  *      @dma_addr: Physical address
867  *
868  *      This routine places a MPT request frame back on the MPT adapter's
869  *      FreeQ.
870  */
871 void
872 mpt_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
873 {
874         if (sizeof(dma_addr_t) == sizeof(u64)) {
875                 SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
876                 u32 tmp = dma_addr & 0xFFFFFFFF;
877
878                 pSge->FlagsLength = cpu_to_le32(flagslength);
879                 pSge->Address.Low = cpu_to_le32(tmp);
880                 tmp = (u32) ((u64)dma_addr >> 32);
881                 pSge->Address.High = cpu_to_le32(tmp);
882
883         } else {
884                 SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
885                 pSge->FlagsLength = cpu_to_le32(flagslength);
886                 pSge->Address = cpu_to_le32(dma_addr);
887         }
888 }
889
890 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
891 /**
892  *      mpt_send_handshake_request - Send MPT request via doorbell
893  *      handshake method.
894  *      @handle: Handle of registered MPT protocol driver
895  *      @ioc: Pointer to MPT adapter structure
896  *      @reqBytes: Size of the request in bytes
897  *      @req: Pointer to MPT request frame
898  *      @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
899  *
900  *      This routine is used exclusively to send MptScsiTaskMgmt
901  *      requests since they are required to be sent via doorbell handshake.
902  *
903  *      NOTE: It is the callers responsibility to byte-swap fields in the
904  *      request which are greater than 1 byte in size.
905  *
906  *      Returns 0 for success, non-zero for failure.
907  */
908 int
909 mpt_send_handshake_request(int handle, MPT_ADAPTER *ioc, int reqBytes, u32 *req, int sleepFlag)
910 {
911         int              r = 0;
912         u8      *req_as_bytes;
913         int      ii;
914
915         /* State is known to be good upon entering
916          * this function so issue the bus reset
917          * request.
918          */
919
920         /*
921          * Emulate what mpt_put_msg_frame() does /wrt to sanity
922          * setting cb_idx/req_idx.  But ONLY if this request
923          * is in proper (pre-alloc'd) request buffer range...
924          */
925         ii = MFPTR_2_MPT_INDEX(ioc,(MPT_FRAME_HDR*)req);
926         if (reqBytes >= 12 && ii >= 0 && ii < ioc->req_depth) {
927                 MPT_FRAME_HDR *mf = (MPT_FRAME_HDR*)req;
928                 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(ii);
929                 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = handle;
930         }
931
932         /* Make sure there are no doorbells */
933         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
934
935         CHIPREG_WRITE32(&ioc->chip->Doorbell,
936                         ((MPI_FUNCTION_HANDSHAKE<<MPI_DOORBELL_FUNCTION_SHIFT) |
937                          ((reqBytes/4)<<MPI_DOORBELL_ADD_DWORDS_SHIFT)));
938
939         /* Wait for IOC doorbell int */
940         if ((ii = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0) {
941                 return ii;
942         }
943
944         /* Read doorbell and check for active bit */
945         if (!(CHIPREG_READ32(&ioc->chip->Doorbell) & MPI_DOORBELL_ACTIVE))
946                 return -5;
947
948         dhsprintk((KERN_INFO MYNAM ": %s: mpt_send_handshake_request start, WaitCnt=%d\n",
949                 ioc->name, ii));
950
951         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
952
953         if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
954                 return -2;
955         }
956
957         /* Send request via doorbell handshake */
958         req_as_bytes = (u8 *) req;
959         for (ii = 0; ii < reqBytes/4; ii++) {
960                 u32 word;
961
962                 word = ((req_as_bytes[(ii*4) + 0] <<  0) |
963                         (req_as_bytes[(ii*4) + 1] <<  8) |
964                         (req_as_bytes[(ii*4) + 2] << 16) |
965                         (req_as_bytes[(ii*4) + 3] << 24));
966                 CHIPREG_WRITE32(&ioc->chip->Doorbell, word);
967                 if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
968                         r = -3;
969                         break;
970                 }
971         }
972
973         if (r >= 0 && WaitForDoorbellInt(ioc, 10, sleepFlag) >= 0)
974                 r = 0;
975         else
976                 r = -4;
977
978         /* Make sure there are no doorbells */
979         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
980
981         return r;
982 }
983
984 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
985 /**
986  * mpt_host_page_access_control - provides mechanism for the host
987  * driver to control the IOC's Host Page Buffer access.
988  * @ioc: Pointer to MPT adapter structure
989  * @access_control_value: define bits below
990  *
991  * Access Control Value - bits[15:12]
992  * 0h Reserved
993  * 1h Enable Access { MPI_DB_HPBAC_ENABLE_ACCESS }
994  * 2h Disable Access { MPI_DB_HPBAC_DISABLE_ACCESS }
995  * 3h Free Buffer { MPI_DB_HPBAC_FREE_BUFFER }
996  *
997  * Returns 0 for success, non-zero for failure.
998  */
999
1000 static int
1001 mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag)
1002 {
1003         int      r = 0;
1004
1005         /* return if in use */
1006         if (CHIPREG_READ32(&ioc->chip->Doorbell)
1007             & MPI_DOORBELL_ACTIVE)
1008             return -1;
1009
1010         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1011
1012         CHIPREG_WRITE32(&ioc->chip->Doorbell,
1013                 ((MPI_FUNCTION_HOST_PAGEBUF_ACCESS_CONTROL
1014                  <<MPI_DOORBELL_FUNCTION_SHIFT) |
1015                  (access_control_value<<12)));
1016
1017         /* Wait for IOC to clear Doorbell Status bit */
1018         if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
1019                 return -2;
1020         }else
1021                 return 0;
1022 }
1023
1024 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1025 /**
1026  *      mpt_host_page_alloc - allocate system memory for the fw
1027  *      If we already allocated memory in past, then resend the same pointer.
1028  *      ioc@: Pointer to pointer to IOC adapter
1029  *      ioc_init@: Pointer to ioc init config page
1030  *
1031  *      Returns 0 for success, non-zero for failure.
1032  */
1033 static int
1034 mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init)
1035 {
1036         char    *psge;
1037         int     flags_length;
1038         u32     host_page_buffer_sz=0;
1039
1040         if(!ioc->HostPageBuffer) {
1041
1042                 host_page_buffer_sz =
1043                     le32_to_cpu(ioc->facts.HostPageBufferSGE.FlagsLength) & 0xFFFFFF;
1044
1045                 if(!host_page_buffer_sz)
1046                         return 0; /* fw doesn't need any host buffers */
1047
1048                 /* spin till we get enough memory */
1049                 while(host_page_buffer_sz > 0) {
1050
1051                         if((ioc->HostPageBuffer = pci_alloc_consistent(
1052                             ioc->pcidev,
1053                             host_page_buffer_sz,
1054                             &ioc->HostPageBuffer_dma)) != NULL) {
1055
1056                                 dinitprintk((MYIOC_s_INFO_FMT
1057                                     "host_page_buffer @ %p, dma @ %x, sz=%d bytes\n",
1058                                     ioc->name,
1059                                     ioc->HostPageBuffer,
1060                                     ioc->HostPageBuffer_dma,
1061                                     host_page_buffer_sz));
1062                                 ioc->alloc_total += host_page_buffer_sz;
1063                                 ioc->HostPageBuffer_sz = host_page_buffer_sz;
1064                                 break;
1065                         }
1066
1067                         host_page_buffer_sz -= (4*1024);
1068                 }
1069         }
1070
1071         if(!ioc->HostPageBuffer) {
1072                 printk(MYIOC_s_ERR_FMT
1073                     "Failed to alloc memory for host_page_buffer!\n",
1074                     ioc->name);
1075                 return -999;
1076         }
1077
1078         psge = (char *)&ioc_init->HostPageBufferSGE;
1079         flags_length = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
1080             MPI_SGE_FLAGS_SYSTEM_ADDRESS |
1081             MPI_SGE_FLAGS_32_BIT_ADDRESSING |
1082             MPI_SGE_FLAGS_HOST_TO_IOC |
1083             MPI_SGE_FLAGS_END_OF_BUFFER;
1084         if (sizeof(dma_addr_t) == sizeof(u64)) {
1085             flags_length |= MPI_SGE_FLAGS_64_BIT_ADDRESSING;
1086         }
1087         flags_length = flags_length << MPI_SGE_FLAGS_SHIFT;
1088         flags_length |= ioc->HostPageBuffer_sz;
1089         mpt_add_sge(psge, flags_length, ioc->HostPageBuffer_dma);
1090         ioc->facts.HostPageBufferSGE = ioc_init->HostPageBufferSGE;
1091
1092 return 0;
1093 }
1094
1095 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1096 /**
1097  *      mpt_verify_adapter - Given a unique IOC identifier, set pointer to
1098  *      the associated MPT adapter structure.
1099  *      @iocid: IOC unique identifier (integer)
1100  *      @iocpp: Pointer to pointer to IOC adapter
1101  *
1102  *      Returns iocid and sets iocpp.
1103  */
1104 int
1105 mpt_verify_adapter(int iocid, MPT_ADAPTER **iocpp)
1106 {
1107         MPT_ADAPTER *ioc;
1108
1109         list_for_each_entry(ioc,&ioc_list,list) {
1110                 if (ioc->id == iocid) {
1111                         *iocpp =ioc;
1112                         return iocid;
1113                 }
1114         }
1115
1116         *iocpp = NULL;
1117         return -1;
1118 }
1119
1120 int
1121 mpt_alt_ioc_wait(MPT_ADAPTER *ioc)
1122 {
1123         int loop_count = 30 * 4;  /* Wait 30 seconds */
1124         int status = -1; /* -1 means failed to get board READY */
1125
1126         do {
1127                 spin_lock(&ioc->initializing_hba_lock);
1128                 if (ioc->initializing_hba_lock_flag == 0) {
1129                         ioc->initializing_hba_lock_flag=1;
1130                         spin_unlock(&ioc->initializing_hba_lock);
1131                         status = 0;
1132                         break;
1133                 }
1134                 spin_unlock(&ioc->initializing_hba_lock);
1135                 set_current_state(TASK_INTERRUPTIBLE);
1136                 schedule_timeout(HZ/4);
1137         } while (--loop_count);
1138
1139         return status;
1140 }
1141
1142 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1143 /*
1144  *      mpt_bringup_adapter - This is a wrapper function for mpt_do_ioc_recovery
1145  *      @ioc: Pointer to MPT adapter structure
1146  *      @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
1147  *
1148  *      This routine performs all the steps necessary to bring the IOC
1149  *      to a OPERATIONAL state.
1150  *
1151  *      Special Note: This function was added with spin lock's so as to allow
1152  *      the dv(domain validation) work thread to succeed on the other channel
1153  *      that maybe occuring at the same time when this function is called.
1154  *      Without this lock, the dv would fail when message frames were
1155  *      requested during hba bringup on the alternate ioc.
1156  */
1157 static int
1158 mpt_bringup_adapter(MPT_ADAPTER *ioc, int sleepFlag)
1159 {
1160         int r;
1161
1162         if(ioc->alt_ioc) {
1163                 if((r=mpt_alt_ioc_wait(ioc->alt_ioc)!=0))
1164                         return r;
1165         }
1166
1167         r = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP,
1168             CAN_SLEEP);
1169
1170         if(ioc->alt_ioc) {
1171                 spin_lock(&ioc->alt_ioc->initializing_hba_lock);
1172                 ioc->alt_ioc->initializing_hba_lock_flag=0;
1173                 spin_unlock(&ioc->alt_ioc->initializing_hba_lock);
1174         }
1175
1176 return r;
1177 }
1178
1179 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1180 /*
1181  *      mpt_attach - Install a PCI intelligent MPT adapter.
1182  *      @pdev: Pointer to pci_dev structure
1183  *
1184  *      This routine performs all the steps necessary to bring the IOC of
1185  *      a MPT adapter to a OPERATIONAL state.  This includes registering
1186  *      memory regions, registering the interrupt, and allocating request
1187  *      and reply memory pools.
1188  *
1189  *      This routine also pre-fetches the LAN MAC address of a Fibre Channel
1190  *      MPT adapter.
1191  *
1192  *      Returns 0 for success, non-zero for failure.
1193  *
1194  *      TODO: Add support for polled controllers
1195  */
1196 int
1197 mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id)
1198 {
1199         MPT_ADAPTER     *ioc;
1200         u8              __iomem *mem;
1201         unsigned long    mem_phys;
1202         unsigned long    port;
1203         u32              msize;
1204         u32              psize;
1205         int              ii;
1206         int              r = -ENODEV;
1207         u8               revision;
1208         u8               pcixcmd;
1209         static int       mpt_ids = 0;
1210 #ifdef CONFIG_PROC_FS
1211         struct proc_dir_entry *dent, *ent;
1212 #endif
1213
1214         if (pci_enable_device(pdev))
1215                 return r;
1216
1217         dinitprintk((KERN_WARNING MYNAM ": mpt_adapter_install\n"));
1218
1219         if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
1220                 dprintk((KERN_INFO MYNAM
1221                         ": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n"));
1222         } else if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
1223                 printk(KERN_WARNING MYNAM ": 32 BIT PCI BUS DMA ADDRESSING NOT SUPPORTED\n");
1224                 return r;
1225         }
1226
1227         if (!pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK))
1228                 dprintk((KERN_INFO MYNAM
1229                         ": Using 64 bit consistent mask\n"));
1230         else
1231                 dprintk((KERN_INFO MYNAM
1232                         ": Not using 64 bit consistent mask\n"));
1233
1234         ioc = kzalloc(sizeof(MPT_ADAPTER), GFP_ATOMIC);
1235         if (ioc == NULL) {
1236                 printk(KERN_ERR MYNAM ": ERROR - Insufficient memory to add adapter!\n");
1237                 return -ENOMEM;
1238         }
1239         ioc->alloc_total = sizeof(MPT_ADAPTER);
1240         ioc->req_sz = MPT_DEFAULT_FRAME_SIZE;           /* avoid div by zero! */
1241         ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
1242
1243         ioc->pcidev = pdev;
1244         ioc->diagPending = 0;
1245         spin_lock_init(&ioc->diagLock);
1246         spin_lock_init(&ioc->fc_rescan_work_lock);
1247         spin_lock_init(&ioc->fc_rport_lock);
1248         spin_lock_init(&ioc->initializing_hba_lock);
1249
1250         /* Initialize the event logging.
1251          */
1252         ioc->eventTypes = 0;    /* None */
1253         ioc->eventContext = 0;
1254         ioc->eventLogSize = 0;
1255         ioc->events = NULL;
1256
1257 #ifdef MFCNT
1258         ioc->mfcnt = 0;
1259 #endif
1260
1261         ioc->cached_fw = NULL;
1262
1263         /* Initilize SCSI Config Data structure
1264          */
1265         memset(&ioc->spi_data, 0, sizeof(SpiCfgData));
1266
1267         /* Initialize the running configQ head.
1268          */
1269         INIT_LIST_HEAD(&ioc->configQ);
1270
1271         /* Initialize the fc rport list head.
1272          */
1273         INIT_LIST_HEAD(&ioc->fc_rports);
1274
1275         /* Find lookup slot. */
1276         INIT_LIST_HEAD(&ioc->list);
1277         ioc->id = mpt_ids++;
1278
1279         mem_phys = msize = 0;
1280         port = psize = 0;
1281         for (ii=0; ii < DEVICE_COUNT_RESOURCE; ii++) {
1282                 if (pci_resource_flags(pdev, ii) & PCI_BASE_ADDRESS_SPACE_IO) {
1283                         /* Get I/O space! */
1284                         port = pci_resource_start(pdev, ii);
1285                         psize = pci_resource_len(pdev,ii);
1286                 } else {
1287                         /* Get memmap */
1288                         mem_phys = pci_resource_start(pdev, ii);
1289                         msize = pci_resource_len(pdev,ii);
1290                         break;
1291                 }
1292         }
1293         ioc->mem_size = msize;
1294
1295         if (ii == DEVICE_COUNT_RESOURCE) {
1296                 printk(KERN_ERR MYNAM ": ERROR - MPT adapter has no memory regions defined!\n");
1297                 kfree(ioc);
1298                 return -EINVAL;
1299         }
1300
1301         dinitprintk((KERN_INFO MYNAM ": MPT adapter @ %lx, msize=%dd bytes\n", mem_phys, msize));
1302         dinitprintk((KERN_INFO MYNAM ": (port i/o @ %lx, psize=%dd bytes)\n", port, psize));
1303
1304         mem = NULL;
1305         /* Get logical ptr for PciMem0 space */
1306         /*mem = ioremap(mem_phys, msize);*/
1307         mem = ioremap(mem_phys, 0x100);
1308         if (mem == NULL) {
1309                 printk(KERN_ERR MYNAM ": ERROR - Unable to map adapter memory!\n");
1310                 kfree(ioc);
1311                 return -EINVAL;
1312         }
1313         ioc->memmap = mem;
1314         dinitprintk((KERN_INFO MYNAM ": mem = %p, mem_phys = %lx\n", mem, mem_phys));
1315
1316         dinitprintk((KERN_INFO MYNAM ": facts @ %p, pfacts[0] @ %p\n",
1317                         &ioc->facts, &ioc->pfacts[0]));
1318
1319         ioc->mem_phys = mem_phys;
1320         ioc->chip = (SYSIF_REGS __iomem *)mem;
1321
1322         /* Save Port IO values in case we need to do downloadboot */
1323         {
1324                 u8 *pmem = (u8*)port;
1325                 ioc->pio_mem_phys = port;
1326                 ioc->pio_chip = (SYSIF_REGS __iomem *)pmem;
1327         }
1328
1329         if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC909) {
1330                 ioc->prod_name = "LSIFC909";
1331                 ioc->bus_type = FC;
1332         }
1333         else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC929) {
1334                 ioc->prod_name = "LSIFC929";
1335                 ioc->bus_type = FC;
1336         }
1337         else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC919) {
1338                 ioc->prod_name = "LSIFC919";
1339                 ioc->bus_type = FC;
1340         }
1341         else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC929X) {
1342                 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1343                 ioc->bus_type = FC;
1344                 if (revision < XL_929) {
1345                         ioc->prod_name = "LSIFC929X";
1346                         /* 929X Chip Fix. Set Split transactions level
1347                         * for PCIX. Set MOST bits to zero.
1348                         */
1349                         pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1350                         pcixcmd &= 0x8F;
1351                         pci_write_config_byte(pdev, 0x6a, pcixcmd);
1352                 } else {
1353                         ioc->prod_name = "LSIFC929XL";
1354                         /* 929XL Chip Fix. Set MMRBC to 0x08.
1355                         */
1356                         pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1357                         pcixcmd |= 0x08;
1358                         pci_write_config_byte(pdev, 0x6a, pcixcmd);
1359                 }
1360         }
1361         else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC919X) {
1362                 ioc->prod_name = "LSIFC919X";
1363                 ioc->bus_type = FC;
1364                 /* 919X Chip Fix. Set Split transactions level
1365                  * for PCIX. Set MOST bits to zero.
1366                  */
1367                 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1368                 pcixcmd &= 0x8F;
1369                 pci_write_config_byte(pdev, 0x6a, pcixcmd);
1370         }
1371         else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC939X) {
1372                 ioc->prod_name = "LSIFC939X";
1373                 ioc->bus_type = FC;
1374                 ioc->errata_flag_1064 = 1;
1375         }
1376         else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC949X) {
1377                 ioc->prod_name = "LSIFC949X";
1378                 ioc->bus_type = FC;
1379                 ioc->errata_flag_1064 = 1;
1380         }
1381         else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC949E) {
1382                 ioc->prod_name = "LSIFC949E";
1383                 ioc->bus_type = FC;
1384         }
1385         else if (pdev->device == MPI_MANUFACTPAGE_DEVID_53C1030) {
1386                 ioc->prod_name = "LSI53C1030";
1387                 ioc->bus_type = SPI;
1388                 /* 1030 Chip Fix. Disable Split transactions
1389                  * for PCIX. Set MOST bits to zero if Rev < C0( = 8).
1390                  */
1391                 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1392                 if (revision < C0_1030) {
1393                         pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1394                         pcixcmd &= 0x8F;
1395                         pci_write_config_byte(pdev, 0x6a, pcixcmd);
1396                 }
1397         }
1398         else if (pdev->device == MPI_MANUFACTPAGE_DEVID_1030_53C1035) {
1399                 ioc->prod_name = "LSI53C1035";
1400                 ioc->bus_type = SPI;
1401         }
1402         else if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1064) {
1403                 ioc->prod_name = "LSISAS1064";
1404                 ioc->bus_type = SAS;
1405                 ioc->errata_flag_1064 = 1;
1406         }
1407         else if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1066) {
1408                 ioc->prod_name = "LSISAS1066";
1409                 ioc->bus_type = SAS;
1410                 ioc->errata_flag_1064 = 1;
1411         }
1412         else if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1068) {
1413                 ioc->prod_name = "LSISAS1068";
1414                 ioc->bus_type = SAS;
1415                 ioc->errata_flag_1064 = 1;
1416         }
1417         else if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1064E) {
1418                 ioc->prod_name = "LSISAS1064E";
1419                 ioc->bus_type = SAS;
1420         }
1421         else if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1066E) {
1422                 ioc->prod_name = "LSISAS1066E";
1423                 ioc->bus_type = SAS;
1424         }
1425         else if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1068E) {
1426                 ioc->prod_name = "LSISAS1068E";
1427                 ioc->bus_type = SAS;
1428         }
1429
1430         if (ioc->errata_flag_1064)
1431                 pci_disable_io_access(pdev);
1432
1433         sprintf(ioc->name, "ioc%d", ioc->id);
1434
1435         spin_lock_init(&ioc->FreeQlock);
1436
1437         /* Disable all! */
1438         CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1439         ioc->active = 0;
1440         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1441
1442         /* Set lookup ptr. */
1443         list_add_tail(&ioc->list, &ioc_list);
1444
1445         ioc->pci_irq = -1;
1446         if (pdev->irq) {
1447                 r = request_irq(pdev->irq, mpt_interrupt, SA_SHIRQ, ioc->name, ioc);
1448
1449                 if (r < 0) {
1450 #ifndef __sparc__
1451                         printk(MYIOC_s_ERR_FMT "Unable to allocate interrupt %d!\n",
1452                                         ioc->name, pdev->irq);
1453 #else
1454                         printk(MYIOC_s_ERR_FMT "Unable to allocate interrupt %s!\n",
1455                                         ioc->name, __irq_itoa(pdev->irq));
1456 #endif
1457                         list_del(&ioc->list);
1458                         iounmap(mem);
1459                         kfree(ioc);
1460                         return -EBUSY;
1461                 }
1462
1463                 ioc->pci_irq = pdev->irq;
1464
1465                 pci_set_master(pdev);                   /* ?? */
1466                 pci_set_drvdata(pdev, ioc);
1467
1468 #ifndef __sparc__
1469                 dprintk((KERN_INFO MYNAM ": %s installed at interrupt %d\n", ioc->name, pdev->irq));
1470 #else
1471                 dprintk((KERN_INFO MYNAM ": %s installed at interrupt %s\n", ioc->name, __irq_itoa(pdev->irq)));
1472 #endif
1473         }
1474
1475         /* Check for "bound ports" (929, 929X, 1030, 1035) to reduce redundant resets.
1476          */
1477         mpt_detect_bound_ports(ioc, pdev);
1478
1479         if ((r = mpt_bringup_adapter(ioc, CAN_SLEEP)) != 0){
1480                 printk(KERN_WARNING MYNAM
1481                   ": WARNING - %s did not initialize properly! (%d)\n",
1482                   ioc->name, r);
1483
1484                 list_del(&ioc->list);
1485                 free_irq(ioc->pci_irq, ioc);
1486                 iounmap(mem);
1487                 kfree(ioc);
1488                 pci_set_drvdata(pdev, NULL);
1489                 return r;
1490         }
1491
1492         /* call per device driver probe entry point */
1493         for(ii=0; ii<MPT_MAX_PROTOCOL_DRIVERS; ii++) {
1494                 if(MptDeviceDriverHandlers[ii] &&
1495                   MptDeviceDriverHandlers[ii]->probe) {
1496                         MptDeviceDriverHandlers[ii]->probe(pdev,id);
1497                 }
1498         }
1499
1500 #ifdef CONFIG_PROC_FS
1501         /*
1502          *  Create "/proc/mpt/iocN" subdirectory entry for each MPT adapter.
1503          */
1504         dent = proc_mkdir(ioc->name, mpt_proc_root_dir);
1505         if (dent) {
1506                 ent = create_proc_entry("info", S_IFREG|S_IRUGO, dent);
1507                 if (ent) {
1508                         ent->read_proc = procmpt_iocinfo_read;
1509                         ent->data = ioc;
1510                 }
1511                 ent = create_proc_entry("summary", S_IFREG|S_IRUGO, dent);
1512                 if (ent) {
1513                         ent->read_proc = procmpt_summary_read;
1514                         ent->data = ioc;
1515                 }
1516         }
1517 #endif
1518
1519         return 0;
1520 }
1521
1522 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1523 /*
1524  *      mpt_detach - Remove a PCI intelligent MPT adapter.
1525  *      @pdev: Pointer to pci_dev structure
1526  *
1527  */
1528
1529 void
1530 mpt_detach(struct pci_dev *pdev)
1531 {
1532         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1533         char pname[32];
1534         int ii;
1535
1536         sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/summary", ioc->name);
1537         remove_proc_entry(pname, NULL);
1538         sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/info", ioc->name);
1539         remove_proc_entry(pname, NULL);
1540         sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s", ioc->name);
1541         remove_proc_entry(pname, NULL);
1542
1543         /* call per device driver remove entry point */
1544         for(ii=0; ii<MPT_MAX_PROTOCOL_DRIVERS; ii++) {
1545                 if(MptDeviceDriverHandlers[ii] &&
1546                   MptDeviceDriverHandlers[ii]->remove) {
1547                         MptDeviceDriverHandlers[ii]->remove(pdev);
1548                 }
1549         }
1550
1551         /* Disable interrupts! */
1552         CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1553
1554         ioc->active = 0;
1555         synchronize_irq(pdev->irq);
1556
1557         /* Clear any lingering interrupt */
1558         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1559
1560         CHIPREG_READ32(&ioc->chip->IntStatus);
1561
1562         mpt_adapter_dispose(ioc);
1563
1564         pci_set_drvdata(pdev, NULL);
1565 }
1566
1567 /**************************************************************************
1568  * Power Management
1569  */
1570 #ifdef CONFIG_PM
1571 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1572 /*
1573  *      mpt_suspend - Fusion MPT base driver suspend routine.
1574  *
1575  *
1576  */
1577 int
1578 mpt_suspend(struct pci_dev *pdev, pm_message_t state)
1579 {
1580         u32 device_state;
1581         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1582
1583         device_state=pci_choose_state(pdev, state);
1584
1585         printk(MYIOC_s_INFO_FMT
1586         "pci-suspend: pdev=0x%p, slot=%s, Entering operating state [D%d]\n",
1587                 ioc->name, pdev, pci_name(pdev), device_state);
1588
1589         pci_save_state(pdev);
1590
1591         /* put ioc into READY_STATE */
1592         if(SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, CAN_SLEEP)) {
1593                 printk(MYIOC_s_ERR_FMT
1594                 "pci-suspend:  IOC msg unit reset failed!\n", ioc->name);
1595         }
1596
1597         /* disable interrupts */
1598         CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1599         ioc->active = 0;
1600
1601         /* Clear any lingering interrupt */
1602         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1603
1604         pci_disable_device(pdev);
1605         pci_set_power_state(pdev, device_state);
1606
1607         return 0;
1608 }
1609
1610 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1611 /*
1612  *      mpt_resume - Fusion MPT base driver resume routine.
1613  *
1614  *
1615  */
1616 int
1617 mpt_resume(struct pci_dev *pdev)
1618 {
1619         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1620         u32 device_state = pdev->current_state;
1621         int recovery_state;
1622         int ii;
1623
1624         printk(MYIOC_s_INFO_FMT
1625         "pci-resume: pdev=0x%p, slot=%s, Previous operating state [D%d]\n",
1626                 ioc->name, pdev, pci_name(pdev), device_state);
1627
1628         pci_set_power_state(pdev, 0);
1629         pci_restore_state(pdev);
1630         pci_enable_device(pdev);
1631
1632         /* enable interrupts */
1633         CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);
1634         ioc->active = 1;
1635
1636         /* F/W not running */
1637         if(!CHIPREG_READ32(&ioc->chip->Doorbell)) {
1638                 /* enable domain validation flags */
1639                 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
1640                         ioc->spi_data.dvStatus[ii] |= MPT_SCSICFG_NEED_DV;
1641                 }
1642         }
1643
1644         printk(MYIOC_s_INFO_FMT
1645                 "pci-resume: ioc-state=0x%x,doorbell=0x%x\n",
1646                 ioc->name,
1647                 (mpt_GetIocState(ioc, 1) >> MPI_IOC_STATE_SHIFT),
1648                 CHIPREG_READ32(&ioc->chip->Doorbell));
1649
1650         /* bring ioc to operational state */
1651         if ((recovery_state = mpt_do_ioc_recovery(ioc,
1652             MPT_HOSTEVENT_IOC_RECOVER, CAN_SLEEP)) != 0) {
1653                 printk(MYIOC_s_INFO_FMT
1654                         "pci-resume: Cannot recover, error:[%x]\n",
1655                         ioc->name, recovery_state);
1656         } else {
1657                 printk(MYIOC_s_INFO_FMT
1658                         "pci-resume: success\n", ioc->name);
1659         }
1660
1661         return 0;
1662 }
1663 #endif
1664
1665 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1666 /*
1667  *      mpt_do_ioc_recovery - Initialize or recover MPT adapter.
1668  *      @ioc: Pointer to MPT adapter structure
1669  *      @reason: Event word / reason
1670  *      @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
1671  *
1672  *      This routine performs all the steps necessary to bring the IOC
1673  *      to a OPERATIONAL state.
1674  *
1675  *      This routine also pre-fetches the LAN MAC address of a Fibre Channel
1676  *      MPT adapter.
1677  *
1678  *      Returns:
1679  *               0 for success
1680  *              -1 if failed to get board READY
1681  *              -2 if READY but IOCFacts Failed
1682  *              -3 if READY but PrimeIOCFifos Failed
1683  *              -4 if READY but IOCInit Failed
1684  */
1685 static int
1686 mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag)
1687 {
1688         int      hard_reset_done = 0;
1689         int      alt_ioc_ready = 0;
1690         int      hard;
1691         int      rc=0;
1692         int      ii;
1693         int      handlers;
1694         int      ret = 0;
1695         int      reset_alt_ioc_active = 0;
1696
1697         printk(KERN_INFO MYNAM ": Initiating %s %s\n",
1698                         ioc->name, reason==MPT_HOSTEVENT_IOC_BRINGUP ? "bringup" : "recovery");
1699
1700         /* Disable reply interrupts (also blocks FreeQ) */
1701         CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1702         ioc->active = 0;
1703
1704         if (ioc->alt_ioc) {
1705                 if (ioc->alt_ioc->active)
1706                         reset_alt_ioc_active = 1;
1707
1708                 /* Disable alt-IOC's reply interrupts (and FreeQ) for a bit ... */
1709                 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, 0xFFFFFFFF);
1710                 ioc->alt_ioc->active = 0;
1711         }
1712
1713         hard = 1;
1714         if (reason == MPT_HOSTEVENT_IOC_BRINGUP)
1715                 hard = 0;
1716
1717         if ((hard_reset_done = MakeIocReady(ioc, hard, sleepFlag)) < 0) {
1718                 if (hard_reset_done == -4) {
1719                         printk(KERN_WARNING MYNAM ": %s Owned by PEER..skipping!\n",
1720                                         ioc->name);
1721
1722                         if (reset_alt_ioc_active && ioc->alt_ioc) {
1723                                 /* (re)Enable alt-IOC! (reply interrupt, FreeQ) */
1724                                 dprintk((KERN_INFO MYNAM ": alt-%s reply irq re-enabled\n",
1725                                                 ioc->alt_ioc->name));
1726                                 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
1727                                 ioc->alt_ioc->active = 1;
1728                         }
1729
1730                 } else {
1731                         printk(KERN_WARNING MYNAM ": %s NOT READY WARNING!\n",
1732                                         ioc->name);
1733                 }
1734                 return -1;
1735         }
1736
1737         /* hard_reset_done = 0 if a soft reset was performed
1738          * and 1 if a hard reset was performed.
1739          */
1740         if (hard_reset_done && reset_alt_ioc_active && ioc->alt_ioc) {
1741                 if ((rc = MakeIocReady(ioc->alt_ioc, 0, sleepFlag)) == 0)
1742                         alt_ioc_ready = 1;
1743                 else
1744                         printk(KERN_WARNING MYNAM
1745                                         ": alt-%s: Not ready WARNING!\n",
1746                                         ioc->alt_ioc->name);
1747         }
1748
1749         for (ii=0; ii<5; ii++) {
1750                 /* Get IOC facts! Allow 5 retries */
1751                 if ((rc = GetIocFacts(ioc, sleepFlag, reason)) == 0)
1752                         break;
1753         }
1754
1755
1756         if (ii == 5) {
1757                 dinitprintk((MYIOC_s_INFO_FMT "Retry IocFacts failed rc=%x\n", ioc->name, rc));
1758                 ret = -2;
1759         } else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
1760                 MptDisplayIocCapabilities(ioc);
1761         }
1762
1763         if (alt_ioc_ready) {
1764                 if ((rc = GetIocFacts(ioc->alt_ioc, sleepFlag, reason)) != 0) {
1765                         dinitprintk((MYIOC_s_INFO_FMT "Initial Alt IocFacts failed rc=%x\n", ioc->name, rc));
1766                         /* Retry - alt IOC was initialized once
1767                          */
1768                         rc = GetIocFacts(ioc->alt_ioc, sleepFlag, reason);
1769                 }
1770                 if (rc) {
1771                         dinitprintk((MYIOC_s_INFO_FMT "Retry Alt IocFacts failed rc=%x\n", ioc->name, rc));
1772                         alt_ioc_ready = 0;
1773                         reset_alt_ioc_active = 0;
1774                 } else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
1775                         MptDisplayIocCapabilities(ioc->alt_ioc);
1776                 }
1777         }
1778
1779         /* Prime reply & request queues!
1780          * (mucho alloc's) Must be done prior to
1781          * init as upper addresses are needed for init.
1782          * If fails, continue with alt-ioc processing
1783          */
1784         if ((ret == 0) && ((rc = PrimeIocFifos(ioc)) != 0))
1785                 ret = -3;
1786
1787         /* May need to check/upload firmware & data here!
1788          * If fails, continue with alt-ioc processing
1789          */
1790         if ((ret == 0) && ((rc = SendIocInit(ioc, sleepFlag)) != 0))
1791                 ret = -4;
1792 // NEW!
1793         if (alt_ioc_ready && ((rc = PrimeIocFifos(ioc->alt_ioc)) != 0)) {
1794                 printk(KERN_WARNING MYNAM ": alt-%s: (%d) FIFO mgmt alloc WARNING!\n",
1795                                 ioc->alt_ioc->name, rc);
1796                 alt_ioc_ready = 0;
1797                 reset_alt_ioc_active = 0;
1798         }
1799
1800         if (alt_ioc_ready) {
1801                 if ((rc = SendIocInit(ioc->alt_ioc, sleepFlag)) != 0) {
1802                         alt_ioc_ready = 0;
1803                         reset_alt_ioc_active = 0;
1804                         printk(KERN_WARNING MYNAM
1805                                 ": alt-%s: (%d) init failure WARNING!\n",
1806                                         ioc->alt_ioc->name, rc);
1807                 }
1808         }
1809
1810         if (reason == MPT_HOSTEVENT_IOC_BRINGUP){
1811                 if (ioc->upload_fw) {
1812                         ddlprintk((MYIOC_s_INFO_FMT
1813                                 "firmware upload required!\n", ioc->name));
1814
1815                         /* Controller is not operational, cannot do upload
1816                          */
1817                         if (ret == 0) {
1818                                 rc = mpt_do_upload(ioc, sleepFlag);
1819                                 if (rc == 0) {
1820                                         if (ioc->alt_ioc && ioc->alt_ioc->cached_fw) {
1821                                                 /*
1822                                                  * Maintain only one pointer to FW memory
1823                                                  * so there will not be two attempt to
1824                                                  * downloadboot onboard dual function
1825                                                  * chips (mpt_adapter_disable,
1826                                                  * mpt_diag_reset)
1827                                                  */
1828                                                 ioc->cached_fw = NULL;
1829                                                 ddlprintk((MYIOC_s_INFO_FMT ": mpt_upload:  alt_%s has cached_fw=%p \n",
1830                                                         ioc->name, ioc->alt_ioc->name, ioc->alt_ioc->cached_fw));
1831                                         }
1832                                 } else {
1833                                         printk(KERN_WARNING MYNAM ": firmware upload failure!\n");
1834                                         ret = -5;
1835                                 }
1836                         }
1837                 }
1838         }
1839
1840         if (ret == 0) {
1841                 /* Enable! (reply interrupt) */
1842                 CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);
1843                 ioc->active = 1;
1844         }
1845
1846         if (reset_alt_ioc_active && ioc->alt_ioc) {
1847                 /* (re)Enable alt-IOC! (reply interrupt) */
1848                 dinitprintk((KERN_INFO MYNAM ": alt-%s reply irq re-enabled\n",
1849                                 ioc->alt_ioc->name));
1850                 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
1851                 ioc->alt_ioc->active = 1;
1852         }
1853
1854         /*  Enable MPT base driver management of EventNotification
1855          *  and EventAck handling.
1856          */
1857         if ((ret == 0) && (!ioc->facts.EventState))
1858                 (void) SendEventNotification(ioc, 1);   /* 1=Enable EventNotification */
1859
1860         if (ioc->alt_ioc && alt_ioc_ready && !ioc->alt_ioc->facts.EventState)
1861                 (void) SendEventNotification(ioc->alt_ioc, 1);  /* 1=Enable EventNotification */
1862
1863         /*      Add additional "reason" check before call to GetLanConfigPages
1864          *      (combined with GetIoUnitPage2 call).  This prevents a somewhat
1865          *      recursive scenario; GetLanConfigPages times out, timer expired
1866          *      routine calls HardResetHandler, which calls into here again,
1867          *      and we try GetLanConfigPages again...
1868          */
1869         if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP)) {
1870                 if (ioc->bus_type == SAS) {
1871
1872                         /* clear persistency table */
1873                         if(ioc->facts.IOCExceptions &
1874                             MPI_IOCFACTS_EXCEPT_PERSISTENT_TABLE_FULL) {
1875                                 ret = mptbase_sas_persist_operation(ioc,
1876                                     MPI_SAS_OP_CLEAR_NOT_PRESENT);
1877                                 if(ret != 0)
1878                                         return -1;
1879                         }
1880
1881                         /* Find IM volumes
1882                          */
1883                         mpt_findImVolumes(ioc);
1884
1885                 } else if (ioc->bus_type == FC) {
1886                         /*
1887                          *  Pre-fetch FC port WWN and stuff...
1888                          *  (FCPortPage0_t stuff)
1889                          */
1890                         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1891                                 (void) mptbase_GetFcPortPage0(ioc, ii);
1892                         }
1893
1894                         if ((ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) &&
1895                             (ioc->lan_cnfg_page0.Header.PageLength == 0)) {
1896                                 /*
1897                                  *  Pre-fetch the ports LAN MAC address!
1898                                  *  (LANPage1_t stuff)
1899                                  */
1900                                 (void) GetLanConfigPages(ioc);
1901 #ifdef MPT_DEBUG
1902                                 {
1903                                         u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
1904                                         dprintk((MYIOC_s_INFO_FMT "LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
1905                                                         ioc->name, a[5], a[4], a[3], a[2], a[1], a[0] ));
1906                                 }
1907 #endif
1908                         }
1909                 } else {
1910                         /* Get NVRAM and adapter maximums from SPP 0 and 2
1911                          */
1912                         mpt_GetScsiPortSettings(ioc, 0);
1913
1914                         /* Get version and length of SDP 1
1915                          */
1916                         mpt_readScsiDevicePageHeaders(ioc, 0);
1917
1918                         /* Find IM volumes
1919                          */
1920                         if (ioc->facts.MsgVersion >= MPI_VERSION_01_02)
1921                                 mpt_findImVolumes(ioc);
1922
1923                         /* Check, and possibly reset, the coalescing value
1924                          */
1925                         mpt_read_ioc_pg_1(ioc);
1926
1927                         mpt_read_ioc_pg_4(ioc);
1928                 }
1929
1930                 GetIoUnitPage2(ioc);
1931         }
1932
1933         /*
1934          * Call each currently registered protocol IOC reset handler
1935          * with post-reset indication.
1936          * NOTE: If we're doing _IOC_BRINGUP, there can be no
1937          * MptResetHandlers[] registered yet.
1938          */
1939         if (hard_reset_done) {
1940                 rc = handlers = 0;
1941                 for (ii=MPT_MAX_PROTOCOL_DRIVERS-1; ii; ii--) {
1942                         if ((ret == 0) && MptResetHandlers[ii]) {
1943                                 dprintk((MYIOC_s_INFO_FMT "Calling IOC post_reset handler #%d\n",
1944                                                 ioc->name, ii));
1945                                 rc += (*(MptResetHandlers[ii]))(ioc, MPT_IOC_POST_RESET);
1946                                 handlers++;
1947                         }
1948
1949                         if (alt_ioc_ready && MptResetHandlers[ii]) {
1950                                 drsprintk((MYIOC_s_INFO_FMT "Calling alt-%s post_reset handler #%d\n",
1951                                                 ioc->name, ioc->alt_ioc->name, ii));
1952                                 rc += (*(MptResetHandlers[ii]))(ioc->alt_ioc, MPT_IOC_POST_RESET);
1953                                 handlers++;
1954                         }
1955                 }
1956                 /* FIXME?  Examine results here? */
1957         }
1958
1959         return ret;
1960 }
1961
1962 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1963 /*
1964  *      mpt_detect_bound_ports - Search for PCI bus/dev_function
1965  *      which matches PCI bus/dev_function (+/-1) for newly discovered 929,
1966  *      929X, 1030 or 1035.
1967  *      @ioc: Pointer to MPT adapter structure
1968  *      @pdev: Pointer to (struct pci_dev) structure
1969  *
1970  *      If match on PCI dev_function +/-1 is found, bind the two MPT adapters
1971  *      using alt_ioc pointer fields in their %MPT_ADAPTER structures.
1972  */
1973 static void
1974 mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev)
1975 {
1976         struct pci_dev *peer=NULL;
1977         unsigned int slot = PCI_SLOT(pdev->devfn);
1978         unsigned int func = PCI_FUNC(pdev->devfn);
1979         MPT_ADAPTER *ioc_srch;
1980
1981         dprintk((MYIOC_s_INFO_FMT "PCI device %s devfn=%x/%x,"
1982             " searching for devfn match on %x or %x\n",
1983                 ioc->name, pci_name(pdev), pdev->bus->number,
1984                 pdev->devfn, func-1, func+1));
1985
1986         peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func-1));
1987         if (!peer) {
1988                 peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func+1));
1989                 if (!peer)
1990                         return;
1991         }
1992
1993         list_for_each_entry(ioc_srch, &ioc_list, list) {
1994                 struct pci_dev *_pcidev = ioc_srch->pcidev;
1995                 if (_pcidev == peer) {
1996                         /* Paranoia checks */
1997                         if (ioc->alt_ioc != NULL) {
1998                                 printk(KERN_WARNING MYNAM ": Oops, already bound (%s <==> %s)!\n",
1999                                         ioc->name, ioc->alt_ioc->name);
2000                                 break;
2001                         } else if (ioc_srch->alt_ioc != NULL) {
2002                                 printk(KERN_WARNING MYNAM ": Oops, already bound (%s <==> %s)!\n",
2003                                         ioc_srch->name, ioc_srch->alt_ioc->name);
2004                                 break;
2005                         }
2006                         dprintk((KERN_INFO MYNAM ": FOUND! binding %s <==> %s\n",
2007                                 ioc->name, ioc_srch->name));
2008                         ioc_srch->alt_ioc = ioc;
2009                         ioc->alt_ioc = ioc_srch;
2010                 }
2011         }
2012         pci_dev_put(peer);
2013 }
2014
2015 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2016 /*
2017  *      mpt_adapter_disable - Disable misbehaving MPT adapter.
2018  *      @this: Pointer to MPT adapter structure
2019  */
2020 static void
2021 mpt_adapter_disable(MPT_ADAPTER *ioc)
2022 {
2023         int sz;
2024         int ret;
2025
2026         if (ioc->cached_fw != NULL) {
2027                 ddlprintk((KERN_INFO MYNAM ": mpt_adapter_disable: Pushing FW onto adapter\n"));
2028                 if ((ret = mpt_downloadboot(ioc, (MpiFwHeader_t *)ioc->cached_fw, NO_SLEEP)) < 0) {
2029                         printk(KERN_WARNING MYNAM
2030                                 ": firmware downloadboot failure (%d)!\n", ret);
2031                 }
2032         }
2033
2034         /* Disable adapter interrupts! */
2035         CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
2036         ioc->active = 0;
2037         /* Clear any lingering interrupt */
2038         CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
2039
2040         if (ioc->alloc != NULL) {
2041                 sz = ioc->alloc_sz;
2042                 dexitprintk((KERN_INFO MYNAM ": %s.free  @ %p, sz=%d bytes\n",
2043                         ioc->name, ioc->alloc, ioc->alloc_sz));
2044                 pci_free_consistent(ioc->pcidev, sz,
2045                                 ioc->alloc, ioc->alloc_dma);
2046                 ioc->reply_frames = NULL;
2047                 ioc->req_frames = NULL;
2048                 ioc->alloc = NULL;
2049                 ioc->alloc_total -= sz;
2050         }
2051
2052         if (ioc->sense_buf_pool != NULL) {
2053                 sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
2054                 pci_free_consistent(ioc->pcidev, sz,
2055                                 ioc->sense_buf_pool, ioc->sense_buf_pool_dma);
2056                 ioc->sense_buf_pool = NULL;
2057                 ioc->alloc_total -= sz;
2058         }
2059
2060         if (ioc->events != NULL){
2061                 sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
2062                 kfree(ioc->events);
2063                 ioc->events = NULL;
2064                 ioc->alloc_total -= sz;
2065         }
2066
2067         if (ioc->cached_fw != NULL) {
2068                 sz = ioc->facts.FWImageSize;
2069                 pci_free_consistent(ioc->pcidev, sz,
2070                         ioc->cached_fw, ioc->cached_fw_dma);
2071                 ioc->cached_fw = NULL;
2072                 ioc->alloc_total -= sz;
2073         }
2074
2075         kfree(ioc->spi_data.nvram);
2076         kfree(ioc->raid_data.pIocPg3);
2077         ioc->spi_data.nvram = NULL;
2078         ioc->raid_data.pIocPg3 = NULL;
2079
2080         if (ioc->spi_data.pIocPg4 != NULL) {
2081                 sz = ioc->spi_data.IocPg4Sz;
2082                 pci_free_consistent(ioc->pcidev, sz, 
2083                         ioc->spi_data.pIocPg4,
2084                         ioc->spi_data.IocPg4_dma);
2085                 ioc->spi_data.pIocPg4 = NULL;
2086                 ioc->alloc_total -= sz;
2087         }
2088
2089         if (ioc->ReqToChain != NULL) {
2090                 kfree(ioc->ReqToChain);
2091                 kfree(ioc->RequestNB);
2092                 ioc->ReqToChain = NULL;
2093         }
2094
2095         kfree(ioc->ChainToChain);
2096         ioc->ChainToChain = NULL;
2097
2098         if (ioc->HostPageBuffer != NULL) {
2099                 if((ret = mpt_host_page_access_control(ioc,
2100                     MPI_DB_HPBAC_FREE_BUFFER, NO_SLEEP)) != 0) {
2101                         printk(KERN_ERR MYNAM
2102                            ": %s: host page buffers free failed (%d)!\n",
2103                             __FUNCTION__, ret);
2104                 }
2105                 dexitprintk((KERN_INFO MYNAM ": %s HostPageBuffer free  @ %p, sz=%d bytes\n",
2106                         ioc->name, ioc->HostPageBuffer, ioc->HostPageBuffer_sz));
2107                 pci_free_consistent(ioc->pcidev, ioc->HostPageBuffer_sz,
2108                                 ioc->HostPageBuffer,
2109                                 ioc->HostPageBuffer_dma);
2110                 ioc->HostPageBuffer = NULL;
2111                 ioc->HostPageBuffer_sz = 0;
2112                 ioc->alloc_total -= ioc->HostPageBuffer_sz;
2113         }
2114 }
2115
2116 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2117 /*
2118  *      mpt_adapter_dispose - Free all resources associated with a MPT
2119  *      adapter.
2120  *      @ioc: Pointer to MPT adapter structure
2121  *
2122  *      This routine unregisters h/w resources and frees all alloc'd memory
2123  *      associated with a MPT adapter structure.
2124  */
2125 static void
2126 mpt_adapter_dispose(MPT_ADAPTER *ioc)
2127 {
2128         int sz_first, sz_last;
2129
2130         if (ioc == NULL)
2131                 return;
2132
2133         sz_first = ioc->alloc_total;
2134
2135         mpt_adapter_disable(ioc);
2136
2137         if (ioc->pci_irq != -1) {
2138                 free_irq(ioc->pci_irq, ioc);
2139                 ioc->pci_irq = -1;
2140         }
2141
2142         if (ioc->memmap != NULL) {
2143                 iounmap(ioc->memmap);
2144                 ioc->memmap = NULL;
2145         }
2146
2147 #if defined(CONFIG_MTRR) && 0
2148         if (ioc->mtrr_reg > 0) {
2149                 mtrr_del(ioc->mtrr_reg, 0, 0);
2150                 dprintk((KERN_INFO MYNAM ": %s: MTRR region de-registered\n", ioc->name));
2151         }
2152 #endif
2153
2154         /*  Zap the adapter lookup ptr!  */
2155         list_del(&ioc->list);
2156
2157         sz_last = ioc->alloc_total;
2158         dprintk((KERN_INFO MYNAM ": %s: free'd %d of %d bytes\n",
2159                         ioc->name, sz_first-sz_last+(int)sizeof(*ioc), sz_first));
2160         kfree(ioc);
2161 }
2162
2163 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2164 /*
2165  *      MptDisplayIocCapabilities - Disply IOC's capacilities.
2166  *      @ioc: Pointer to MPT adapter structure
2167  */
2168 static void
2169 MptDisplayIocCapabilities(MPT_ADAPTER *ioc)
2170 {
2171         int i = 0;
2172
2173         printk(KERN_INFO "%s: ", ioc->name);
2174         if (ioc->prod_name && strlen(ioc->prod_name) > 3)
2175                 printk("%s: ", ioc->prod_name+3);
2176         printk("Capabilities={");
2177
2178         if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_INITIATOR) {
2179                 printk("Initiator");
2180                 i++;
2181         }
2182
2183         if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
2184                 printk("%sTarget", i ? "," : "");
2185                 i++;
2186         }
2187
2188         if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) {
2189                 printk("%sLAN", i ? "," : "");
2190                 i++;
2191         }
2192
2193 #if 0
2194         /*
2195          *  This would probably evoke more questions than it's worth
2196          */
2197         if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
2198                 printk("%sLogBusAddr", i ? "," : "");
2199                 i++;
2200         }
2201 #endif
2202
2203         printk("}\n");
2204 }
2205
2206 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2207 /*
2208  *      MakeIocReady - Get IOC to a READY state, using KickStart if needed.
2209  *      @ioc: Pointer to MPT_ADAPTER structure
2210  *      @force: Force hard KickStart of IOC
2211  *      @sleepFlag: Specifies whether the process can sleep
2212  *
2213  *      Returns:
2214  *               1 - DIAG reset and READY
2215  *               0 - READY initially OR soft reset and READY
2216  *              -1 - Any failure on KickStart
2217  *              -2 - Msg Unit Reset Failed
2218  *              -3 - IO Unit Reset Failed
2219  *              -4 - IOC owned by a PEER
2220  */
2221 static int
2222 MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag)
2223 {
2224         u32      ioc_state;
2225         int      statefault = 0;
2226         int      cntdn;
2227         int      hard_reset_done = 0;
2228         int      r;
2229         int      ii;
2230         int      whoinit;
2231
2232         /* Get current [raw] IOC state  */
2233         ioc_state = mpt_GetIocState(ioc, 0);
2234         dhsprintk((KERN_INFO MYNAM "::MakeIocReady, %s [raw] state=%08x\n", ioc->name, ioc_state));
2235
2236         /*
2237          *      Check to see if IOC got left/stuck in doorbell handshake
2238          *      grip of death.  If so, hard reset the IOC.
2239          */
2240         if (ioc_state & MPI_DOORBELL_ACTIVE) {
2241                 statefault = 1;
2242                 printk(MYIOC_s_WARN_FMT "Unexpected doorbell active!\n",
2243                                 ioc->name);
2244         }
2245
2246         /* Is it already READY? */
2247         if (!statefault && (ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_READY)
2248                 return 0;
2249
2250         /*
2251          *      Check to see if IOC is in FAULT state.
2252          */
2253         if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
2254                 statefault = 2;
2255                 printk(MYIOC_s_WARN_FMT "IOC is in FAULT state!!!\n",
2256                                 ioc->name);
2257                 printk(KERN_WARNING "           FAULT code = %04xh\n",
2258                                 ioc_state & MPI_DOORBELL_DATA_MASK);
2259         }
2260
2261         /*
2262          *      Hmmm...  Did it get left operational?
2263          */
2264         if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_OPERATIONAL) {
2265                 dinitprintk((MYIOC_s_INFO_FMT "IOC operational unexpected\n",
2266                                 ioc->name));
2267
2268                 /* Check WhoInit.
2269                  * If PCI Peer, exit.
2270                  * Else, if no fault conditions are present, issue a MessageUnitReset
2271                  * Else, fall through to KickStart case
2272                  */
2273                 whoinit = (ioc_state & MPI_DOORBELL_WHO_INIT_MASK) >> MPI_DOORBELL_WHO_INIT_SHIFT;
2274                 dinitprintk((KERN_INFO MYNAM
2275                         ": whoinit 0x%x statefault %d force %d\n",
2276                         whoinit, statefault, force));
2277                 if (whoinit == MPI_WHOINIT_PCI_PEER)
2278                         return -4;
2279                 else {
2280                         if ((statefault == 0 ) && (force == 0)) {
2281                                 if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) == 0)
2282                                         return 0;
2283                         }
2284                         statefault = 3;
2285                 }
2286         }
2287
2288         hard_reset_done = KickStart(ioc, statefault||force, sleepFlag);
2289         if (hard_reset_done < 0)
2290                 return -1;
2291
2292         /*
2293          *  Loop here waiting for IOC to come READY.
2294          */
2295         ii = 0;
2296         cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 5;     /* 5 seconds */
2297
2298         while ((ioc_state = mpt_GetIocState(ioc, 1)) != MPI_IOC_STATE_READY) {
2299                 if (ioc_state == MPI_IOC_STATE_OPERATIONAL) {
2300                         /*
2301                          *  BIOS or previous driver load left IOC in OP state.
2302                          *  Reset messaging FIFOs.
2303                          */
2304                         if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) != 0) {
2305                                 printk(MYIOC_s_ERR_FMT "IOC msg unit reset failed!\n", ioc->name);
2306                                 return -2;
2307                         }
2308                 } else if (ioc_state == MPI_IOC_STATE_RESET) {
2309                         /*
2310                          *  Something is wrong.  Try to get IOC back
2311                          *  to a known state.
2312                          */
2313                         if ((r = SendIocReset(ioc, MPI_FUNCTION_IO_UNIT_RESET, sleepFlag)) != 0) {
2314                                 printk(MYIOC_s_ERR_FMT "IO unit reset failed!\n", ioc->name);
2315                                 return -3;
2316                         }
2317                 }
2318
2319                 ii++; cntdn--;
2320                 if (!cntdn) {
2321                         printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
2322                                         ioc->name, (int)((ii+5)/HZ));
2323                         return -ETIME;
2324                 }
2325
2326                 if (sleepFlag == CAN_SLEEP) {
2327                         msleep_interruptible(1);
2328                 } else {
2329                         mdelay (1);     /* 1 msec delay */
2330                 }
2331
2332         }
2333
2334         if (statefault < 3) {
2335                 printk(MYIOC_s_INFO_FMT "Recovered from %s\n",
2336                                 ioc->name,
2337                                 statefault==1 ? "stuck handshake" : "IOC FAULT");
2338         }
2339
2340         return hard_reset_done;
2341 }
2342
2343 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2344 /*
2345  *      mpt_GetIocState - Get the current state of a MPT adapter.
2346  *      @ioc: Pointer to MPT_ADAPTER structure
2347  *      @cooked: Request raw or cooked IOC state
2348  *
2349  *      Returns all IOC Doorbell register bits if cooked==0, else just the
2350  *      Doorbell bits in MPI_IOC_STATE_MASK.
2351  */
2352 u32
2353 mpt_GetIocState(MPT_ADAPTER *ioc, int cooked)
2354 {
2355         u32 s, sc;
2356
2357         /*  Get!  */
2358         s = CHIPREG_READ32(&ioc->chip->Doorbell);
2359 //      dprintk((MYIOC_s_INFO_FMT "raw state = %08x\n", ioc->name, s));
2360         sc = s & MPI_IOC_STATE_MASK;
2361
2362         /*  Save!  */
2363         ioc->last_state = sc;
2364
2365         return cooked ? sc : s;
2366 }
2367
2368 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2369 /*
2370  *      GetIocFacts - Send IOCFacts request to MPT adapter.
2371  *      @ioc: Pointer to MPT_ADAPTER structure
2372  *      @sleepFlag: Specifies whether the process can sleep
2373  *      @reason: If recovery, only update facts.
2374  *
2375  *      Returns 0 for success, non-zero for failure.
2376  */
2377 static int
2378 GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason)
2379 {
2380         IOCFacts_t               get_facts;
2381         IOCFactsReply_t         *facts;
2382         int                      r;
2383         int                      req_sz;
2384         int                      reply_sz;
2385         int                      sz;
2386         u32                      status, vv;
2387         u8                       shiftFactor=1;
2388
2389         /* IOC *must* NOT be in RESET state! */
2390         if (ioc->last_state == MPI_IOC_STATE_RESET) {
2391                 printk(KERN_ERR MYNAM ": ERROR - Can't get IOCFacts, %s NOT READY! (%08x)\n",
2392                                 ioc->name,
2393                                 ioc->last_state );
2394                 return -44;
2395         }
2396
2397         facts = &ioc->facts;
2398
2399         /* Destination (reply area)... */
2400         reply_sz = sizeof(*facts);
2401         memset(facts, 0, reply_sz);
2402
2403         /* Request area (get_facts on the stack right now!) */
2404         req_sz = sizeof(get_facts);
2405         memset(&get_facts, 0, req_sz);
2406
2407         get_facts.Function = MPI_FUNCTION_IOC_FACTS;
2408         /* Assert: All other get_facts fields are zero! */
2409
2410         dinitprintk((MYIOC_s_INFO_FMT
2411             "Sending get IocFacts request req_sz=%d reply_sz=%d\n",
2412             ioc->name, req_sz, reply_sz));
2413
2414         /* No non-zero fields in the get_facts request are greater than
2415          * 1 byte in size, so we can just fire it off as is.
2416          */
2417         r = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_facts,
2418                         reply_sz, (u16*)facts, 5 /*seconds*/, sleepFlag);
2419         if (r != 0)
2420                 return r;
2421
2422         /*
2423          * Now byte swap (GRRR) the necessary fields before any further
2424          * inspection of reply contents.
2425          *
2426          * But need to do some sanity checks on MsgLength (byte) field
2427          * to make sure we don't zero IOC's req_sz!
2428          */
2429         /* Did we get a valid reply? */
2430         if (facts->MsgLength > offsetof(IOCFactsReply_t, RequestFrameSize)/sizeof(u32)) {
2431                 if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2432                         /*
2433                          * If not been here, done that, save off first WhoInit value
2434                          */
2435                         if (ioc->FirstWhoInit == WHOINIT_UNKNOWN)
2436                                 ioc->FirstWhoInit = facts->WhoInit;
2437                 }
2438
2439                 facts->MsgVersion = le16_to_cpu(facts->MsgVersion);
2440                 facts->MsgContext = le32_to_cpu(facts->MsgContext);
2441                 facts->IOCExceptions = le16_to_cpu(facts->IOCExceptions);
2442                 facts->IOCStatus = le16_to_cpu(facts->IOCStatus);
2443                 facts->IOCLogInfo = le32_to_cpu(facts->IOCLogInfo);
2444                 status = le16_to_cpu(facts->IOCStatus) & MPI_IOCSTATUS_MASK;
2445                 /* CHECKME! IOCStatus, IOCLogInfo */
2446
2447                 facts->ReplyQueueDepth = le16_to_cpu(facts->ReplyQueueDepth);
2448                 facts->RequestFrameSize = le16_to_cpu(facts->RequestFrameSize);
2449
2450                 /*
2451                  * FC f/w version changed between 1.1 and 1.2
2452                  *      Old: u16{Major(4),Minor(4),SubMinor(8)}
2453                  *      New: u32{Major(8),Minor(8),Unit(8),Dev(8)}
2454                  */
2455                 if (facts->MsgVersion < 0x0102) {
2456                         /*
2457                          *      Handle old FC f/w style, convert to new...
2458                          */
2459                         u16      oldv = le16_to_cpu(facts->Reserved_0101_FWVersion);
2460                         facts->FWVersion.Word =
2461                                         ((oldv<<12) & 0xFF000000) |
2462                                         ((oldv<<8)  & 0x000FFF00);
2463                 } else
2464                         facts->FWVersion.Word = le32_to_cpu(facts->FWVersion.Word);
2465
2466                 facts->ProductID = le16_to_cpu(facts->ProductID);
2467                 facts->CurrentHostMfaHighAddr =
2468                                 le32_to_cpu(facts->CurrentHostMfaHighAddr);
2469                 facts->GlobalCredits = le16_to_cpu(facts->GlobalCredits);
2470                 facts->CurrentSenseBufferHighAddr =
2471                                 le32_to_cpu(facts->CurrentSenseBufferHighAddr);
2472                 facts->CurReplyFrameSize =
2473                                 le16_to_cpu(facts->CurReplyFrameSize);
2474                 facts->IOCCapabilities = le32_to_cpu(facts->IOCCapabilities);
2475
2476                 /*
2477                  * Handle NEW (!) IOCFactsReply fields in MPI-1.01.xx
2478                  * Older MPI-1.00.xx struct had 13 dwords, and enlarged
2479                  * to 14 in MPI-1.01.0x.
2480                  */
2481                 if (facts->MsgLength >= (offsetof(IOCFactsReply_t,FWImageSize) + 7)/4 &&
2482                     facts->MsgVersion > 0x0100) {
2483                         facts->FWImageSize = le32_to_cpu(facts->FWImageSize);
2484                 }
2485
2486                 sz = facts->FWImageSize;
2487                 if ( sz & 0x01 )
2488                         sz += 1;
2489                 if ( sz & 0x02 )
2490                         sz += 2;
2491                 facts->FWImageSize = sz;
2492
2493                 if (!facts->RequestFrameSize) {
2494                         /*  Something is wrong!  */
2495                         printk(MYIOC_s_ERR_FMT "IOC reported invalid 0 request size!\n",
2496                                         ioc->name);
2497                         return -55;
2498                 }
2499
2500                 r = sz = facts->BlockSize;
2501                 vv = ((63 / (sz * 4)) + 1) & 0x03;
2502                 ioc->NB_for_64_byte_frame = vv;
2503                 while ( sz )
2504                 {
2505                         shiftFactor++;
2506                         sz = sz >> 1;
2507                 }
2508                 ioc->NBShiftFactor  = shiftFactor;
2509                 dinitprintk((MYIOC_s_INFO_FMT "NB_for_64_byte_frame=%x NBShiftFactor=%x BlockSize=%x\n",
2510                                         ioc->name, vv, shiftFactor, r));
2511
2512                 if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2513                         /*
2514                          * Set values for this IOC's request & reply frame sizes,
2515                          * and request & reply queue depths...
2516                          */
2517                         ioc->req_sz = min(MPT_DEFAULT_FRAME_SIZE, facts->RequestFrameSize * 4);
2518                         ioc->req_depth = min_t(int, MPT_MAX_REQ_DEPTH, facts->GlobalCredits);
2519                         ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
2520                         ioc->reply_depth = min_t(int, MPT_DEFAULT_REPLY_DEPTH, facts->ReplyQueueDepth);
2521
2522                         dinitprintk((MYIOC_s_INFO_FMT "reply_sz=%3d, reply_depth=%4d\n",
2523                                 ioc->name, ioc->reply_sz, ioc->reply_depth));
2524                         dinitprintk((MYIOC_s_INFO_FMT "req_sz  =%3d, req_depth  =%4d\n",
2525                                 ioc->name, ioc->req_sz, ioc->req_depth));
2526
2527                         /* Get port facts! */
2528                         if ( (r = GetPortFacts(ioc, 0, sleepFlag)) != 0 )
2529                                 return r;
2530                 }
2531         } else {
2532                 printk(MYIOC_s_ERR_FMT
2533                      "Invalid IOC facts reply, msgLength=%d offsetof=%zd!\n",
2534                      ioc->name, facts->MsgLength, (offsetof(IOCFactsReply_t,
2535                      RequestFrameSize)/sizeof(u32)));
2536                 return -66;
2537         }
2538
2539         return 0;
2540 }
2541
2542 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2543 /*
2544  *      GetPortFacts - Send PortFacts request to MPT adapter.
2545  *      @ioc: Pointer to MPT_ADAPTER structure
2546  *      @portnum: Port number
2547  *      @sleepFlag: Specifies whether the process can sleep
2548  *
2549  *      Returns 0 for success, non-zero for failure.
2550  */
2551 static int
2552 GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
2553 {
2554         PortFacts_t              get_pfacts;
2555         PortFactsReply_t        *pfacts;
2556         int                      ii;
2557         int                      req_sz;
2558         int                      reply_sz;
2559
2560         /* IOC *must* NOT be in RESET state! */
2561         if (ioc->last_state == MPI_IOC_STATE_RESET) {
2562                 printk(KERN_ERR MYNAM ": ERROR - Can't get PortFacts, %s NOT READY! (%08x)\n",
2563                                 ioc->name,
2564                                 ioc->last_state );
2565                 return -4;
2566         }
2567
2568         pfacts = &ioc->pfacts[portnum];
2569
2570         /* Destination (reply area)...  */
2571         reply_sz = sizeof(*pfacts);
2572         memset(pfacts, 0, reply_sz);
2573
2574         /* Request area (get_pfacts on the stack right now!) */
2575         req_sz = sizeof(get_pfacts);
2576         memset(&get_pfacts, 0, req_sz);
2577
2578         get_pfacts.Function = MPI_FUNCTION_PORT_FACTS;
2579         get_pfacts.PortNumber = portnum;
2580         /* Assert: All other get_pfacts fields are zero! */
2581
2582         dinitprintk((MYIOC_s_INFO_FMT "Sending get PortFacts(%d) request\n",
2583                         ioc->name, portnum));
2584
2585         /* No non-zero fields in the get_pfacts request are greater than
2586          * 1 byte in size, so we can just fire it off as is.
2587          */
2588         ii = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_pfacts,
2589                                 reply_sz, (u16*)pfacts, 5 /*seconds*/, sleepFlag);
2590         if (ii != 0)
2591                 return ii;
2592
2593         /* Did we get a valid reply? */
2594
2595         /* Now byte swap the necessary fields in the response. */
2596         pfacts->MsgContext = le32_to_cpu(pfacts->MsgContext);
2597         pfacts->IOCStatus = le16_to_cpu(pfacts->IOCStatus);
2598         pfacts->IOCLogInfo = le32_to_cpu(pfacts->IOCLogInfo);
2599         pfacts->MaxDevices = le16_to_cpu(pfacts->MaxDevices);
2600         pfacts->PortSCSIID = le16_to_cpu(pfacts->PortSCSIID);
2601         pfacts->ProtocolFlags = le16_to_cpu(pfacts->ProtocolFlags);
2602         pfacts->MaxPostedCmdBuffers = le16_to_cpu(pfacts->MaxPostedCmdBuffers);
2603         pfacts->MaxPersistentIDs = le16_to_cpu(pfacts->MaxPersistentIDs);
2604         pfacts->MaxLanBuckets = le16_to_cpu(pfacts->MaxLanBuckets);
2605
2606         return 0;
2607 }
2608
2609 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2610 /*
2611  *      SendIocInit - Send IOCInit request to MPT adapter.
2612  *      @ioc: Pointer to MPT_ADAPTER structure
2613  *      @sleepFlag: Specifies whether the process can sleep
2614  *
2615  *      Send IOCInit followed by PortEnable to bring IOC to OPERATIONAL state.
2616  *
2617  *      Returns 0 for success, non-zero for failure.
2618  */
2619 static int
2620 SendIocInit(MPT_ADAPTER *ioc, int sleepFlag)
2621 {
2622         IOCInit_t                ioc_init;
2623         MPIDefaultReply_t        init_reply;
2624         u32                      state;
2625         int                      r;
2626         int                      count;
2627         int                      cntdn;
2628
2629         memset(&ioc_init, 0, sizeof(ioc_init));
2630         memset(&init_reply, 0, sizeof(init_reply));
2631
2632         ioc_init.WhoInit = MPI_WHOINIT_HOST_DRIVER;
2633         ioc_init.Function = MPI_FUNCTION_IOC_INIT;
2634
2635         /* If we are in a recovery mode and we uploaded the FW image,
2636          * then this pointer is not NULL. Skip the upload a second time.
2637          * Set this flag if cached_fw set for either IOC.
2638          */
2639         if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)
2640                 ioc->upload_fw = 1;
2641         else
2642                 ioc->upload_fw = 0;
2643         ddlprintk((MYIOC_s_INFO_FMT "upload_fw %d facts.Flags=%x\n",
2644                    ioc->name, ioc->upload_fw, ioc->facts.Flags));
2645
2646         if(ioc->bus_type == SAS)
2647                 ioc_init.MaxDevices = ioc->facts.MaxDevices;
2648         else if(ioc->bus_type == FC)
2649                 ioc_init.MaxDevices = MPT_MAX_FC_DEVICES;
2650         else
2651                 ioc_init.MaxDevices = MPT_MAX_SCSI_DEVICES;
2652         ioc_init.MaxBuses = MPT_MAX_BUS;
2653         dinitprintk((MYIOC_s_INFO_FMT "facts.MsgVersion=%x\n",
2654                    ioc->name, ioc->facts.MsgVersion));
2655         if (ioc->facts.MsgVersion >= MPI_VERSION_01_05) {
2656                 // set MsgVersion and HeaderVersion host driver was built with
2657                 ioc_init.MsgVersion = cpu_to_le16(MPI_VERSION);
2658                 ioc_init.HeaderVersion = cpu_to_le16(MPI_HEADER_VERSION);
2659
2660                 if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_HOST_PAGE_BUFFER_PERSISTENT) {
2661                         ioc_init.HostPageBufferSGE = ioc->facts.HostPageBufferSGE;
2662                 } else if(mpt_host_page_alloc(ioc, &ioc_init))
2663                         return -99;
2664         }
2665         ioc_init.ReplyFrameSize = cpu_to_le16(ioc->reply_sz);   /* in BYTES */
2666
2667         if (sizeof(dma_addr_t) == sizeof(u64)) {
2668                 /* Save the upper 32-bits of the request
2669                  * (reply) and sense buffers.
2670                  */
2671                 ioc_init.HostMfaHighAddr = cpu_to_le32((u32)((u64)ioc->alloc_dma >> 32));
2672                 ioc_init.SenseBufferHighAddr = cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
2673         } else {
2674                 /* Force 32-bit addressing */
2675                 ioc_init.HostMfaHighAddr = cpu_to_le32(0);
2676                 ioc_init.SenseBufferHighAddr = cpu_to_le32(0);
2677         }
2678
2679         ioc->facts.CurrentHostMfaHighAddr = ioc_init.HostMfaHighAddr;
2680         ioc->facts.CurrentSenseBufferHighAddr = ioc_init.SenseBufferHighAddr;
2681         ioc->facts.MaxDevices = ioc_init.MaxDevices;
2682         ioc->facts.MaxBuses = ioc_init.MaxBuses;
2683
2684         dhsprintk((MYIOC_s_INFO_FMT "Sending IOCInit (req @ %p)\n",
2685                         ioc->name, &ioc_init));
2686
2687         r = mpt_handshake_req_reply_wait(ioc, sizeof(IOCInit_t), (u32*)&ioc_init,
2688                                 sizeof(MPIDefaultReply_t), (u16*)&init_reply, 10 /*seconds*/, sleepFlag);
2689         if (r != 0) {
2690                 printk(MYIOC_s_ERR_FMT "Sending IOCInit failed(%d)!\n",ioc->name, r);
2691                 return r;
2692         }
2693
2694         /* No need to byte swap the multibyte fields in the reply
2695          * since we don't even look at it's contents.
2696          */
2697
2698         dhsprintk((MYIOC_s_INFO_FMT "Sending PortEnable (req @ %p)\n",
2699                         ioc->name, &ioc_init));
2700
2701         if ((r = SendPortEnable(ioc, 0, sleepFlag)) != 0) {
2702                 printk(MYIOC_s_ERR_FMT "Sending PortEnable failed(%d)!\n",ioc->name, r);
2703                 return r;
2704         }
2705
2706         /* YIKES!  SUPER IMPORTANT!!!
2707          *  Poll IocState until _OPERATIONAL while IOC is doing
2708          *  LoopInit and TargetDiscovery!
2709          */
2710         count = 0;
2711         cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 60;    /* 60 seconds */
2712         state = mpt_GetIocState(ioc, 1);
2713         while (state != MPI_IOC_STATE_OPERATIONAL && --cntdn) {
2714                 if (sleepFlag == CAN_SLEEP) {
2715                         msleep_interruptible(1);
2716                 } else {
2717                         mdelay(1);
2718                 }
2719
2720                 if (!cntdn) {
2721                         printk(MYIOC_s_ERR_FMT "Wait IOC_OP state timeout(%d)!\n",
2722                                         ioc->name, (int)((count+5)/HZ));
2723                         return -9;
2724                 }
2725
2726                 state = mpt_GetIocState(ioc, 1);
2727                 count++;
2728         }
2729         dinitprintk((MYIOC_s_INFO_FMT "INFO - Wait IOC_OPERATIONAL state (cnt=%d)\n",
2730                         ioc->name, count));
2731
2732         return r;
2733 }
2734
2735 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2736 /*
2737  *      SendPortEnable - Send PortEnable request to MPT adapter port.
2738  *      @ioc: Pointer to MPT_ADAPTER structure
2739  *      @portnum: Port number to enable
2740  *      @sleepFlag: Specifies whether the process can sleep
2741  *
2742  *      Send PortEnable to bring IOC to OPERATIONAL state.
2743  *
2744  *      Returns 0 for success, non-zero for failure.
2745  */
2746 static int
2747 SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
2748 {
2749         PortEnable_t             port_enable;
2750         MPIDefaultReply_t        reply_buf;
2751         int      rc;
2752         int      req_sz;
2753         int      reply_sz;
2754
2755         /*  Destination...  */
2756         reply_sz = sizeof(MPIDefaultReply_t);
2757         memset(&reply_buf, 0, reply_sz);
2758
2759         req_sz = sizeof(PortEnable_t);
2760         memset(&port_enable, 0, req_sz);
2761
2762         port_enable.Function = MPI_FUNCTION_PORT_ENABLE;
2763         port_enable.PortNumber = portnum;
2764 /*      port_enable.ChainOffset = 0;            */
2765 /*      port_enable.MsgFlags = 0;               */
2766 /*      port_enable.MsgContext = 0;             */
2767
2768         dinitprintk((MYIOC_s_INFO_FMT "Sending Port(%d)Enable (req @ %p)\n",
2769                         ioc->name, portnum, &port_enable));
2770
2771         /* RAID FW may take a long time to enable
2772          */
2773         if ( (ioc->facts.ProductID & MPI_FW_HEADER_PID_PROD_MASK)
2774                         > MPI_FW_HEADER_PID_PROD_TARGET_SCSI ) {
2775                 rc = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&port_enable,
2776                                 reply_sz, (u16*)&reply_buf, 300 /*seconds*/, sleepFlag);
2777         } else {
2778                 rc = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&port_enable,
2779                                 reply_sz, (u16*)&reply_buf, 30 /*seconds*/, sleepFlag);
2780         }
2781         return rc;
2782 }
2783
2784 /*
2785  *      ioc: Pointer to MPT_ADAPTER structure
2786  *      size - total FW bytes
2787  */
2788 void
2789 mpt_alloc_fw_memory(MPT_ADAPTER *ioc, int size)
2790 {
2791         if (ioc->cached_fw)
2792                 return;  /* use already allocated memory */
2793         if (ioc->alt_ioc && ioc->alt_ioc->cached_fw) {
2794                 ioc->cached_fw = ioc->alt_ioc->cached_fw;  /* use alt_ioc's memory */
2795                 ioc->cached_fw_dma = ioc->alt_ioc->cached_fw_dma;
2796         } else {
2797                 if ( (ioc->cached_fw = pci_alloc_consistent(ioc->pcidev, size, &ioc->cached_fw_dma) ) )
2798                         ioc->alloc_total += size;
2799         }
2800 }
2801 /*
2802  * If alt_img is NULL, delete from ioc structure.
2803  * Else, delete a secondary image in same format.
2804  */
2805 void
2806 mpt_free_fw_memory(MPT_ADAPTER *ioc)
2807 {
2808         int sz;
2809
2810         sz = ioc->facts.FWImageSize;
2811         dinitprintk((KERN_INFO MYNAM "free_fw_memory: FW Image  @ %p[%p], sz=%d[%x] bytes\n",
2812                  ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
2813         pci_free_consistent(ioc->pcidev, sz,
2814                         ioc->cached_fw, ioc->cached_fw_dma);
2815         ioc->cached_fw = NULL;
2816
2817         return;
2818 }
2819
2820
2821 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2822 /*
2823  *      mpt_do_upload - Construct and Send FWUpload request to MPT adapter port.
2824  *      @ioc: Pointer to MPT_ADAPTER structure
2825  *      @sleepFlag: Specifies whether the process can sleep
2826  *
2827  *      Returns 0 for success, >0 for handshake failure
2828  *              <0 for fw upload failure.
2829  *
2830  *      Remark: If bound IOC and a successful FWUpload was performed
2831  *      on the bound IOC, the second image is discarded
2832  *      and memory is free'd. Both channels must upload to prevent
2833  *      IOC from running in degraded mode.
2834  */
2835 static int
2836 mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag)
2837 {
2838         u8                       request[ioc->req_sz];
2839         u8                       reply[sizeof(FWUploadReply_t)];
2840         FWUpload_t              *prequest;
2841         FWUploadReply_t         *preply;
2842         FWUploadTCSGE_t         *ptcsge;
2843         int                      sgeoffset;
2844         u32                      flagsLength;
2845         int                      ii, sz, reply_sz;
2846         int                      cmdStatus;
2847
2848         /* If the image size is 0, we are done.
2849          */
2850         if ((sz = ioc->facts.FWImageSize) == 0)
2851                 return 0;
2852
2853         mpt_alloc_fw_memory(ioc, sz);
2854
2855         dinitprintk((KERN_INFO MYNAM ": FW Image  @ %p[%p], sz=%d[%x] bytes\n",
2856                  ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
2857
2858         if (ioc->cached_fw == NULL) {
2859                 /* Major Failure.
2860                  */
2861                 return -ENOMEM;
2862         }
2863
2864         prequest = (FWUpload_t *)&request;
2865         preply = (FWUploadReply_t *)&reply;
2866
2867         /*  Destination...  */
2868         memset(prequest, 0, ioc->req_sz);
2869
2870         reply_sz = sizeof(reply);
2871         memset(preply, 0, reply_sz);
2872
2873         prequest->ImageType = MPI_FW_UPLOAD_ITYPE_FW_IOC_MEM;
2874         prequest->Function = MPI_FUNCTION_FW_UPLOAD;
2875
2876         ptcsge = (FWUploadTCSGE_t *) &prequest->SGL;
2877         ptcsge->DetailsLength = 12;
2878         ptcsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
2879         ptcsge->ImageSize = cpu_to_le32(sz);
2880
2881         sgeoffset = sizeof(FWUpload_t) - sizeof(SGE_MPI_UNION) + sizeof(FWUploadTCSGE_t);
2882
2883         flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ | sz;
2884         mpt_add_sge(&request[sgeoffset], flagsLength, ioc->cached_fw_dma);
2885
2886         sgeoffset += sizeof(u32) + sizeof(dma_addr_t);
2887         dinitprintk((KERN_INFO MYNAM ": Sending FW Upload (req @ %p) sgeoffset=%d \n",
2888                         prequest, sgeoffset));
2889         DBG_DUMP_FW_REQUEST_FRAME(prequest)
2890
2891         ii = mpt_handshake_req_reply_wait(ioc, sgeoffset, (u32*)prequest,
2892                                 reply_sz, (u16*)preply, 65 /*seconds*/, sleepFlag);
2893
2894         dinitprintk((KERN_INFO MYNAM ": FW Upload completed rc=%x \n", ii));
2895
2896         cmdStatus = -EFAULT;
2897         if (ii == 0) {
2898                 /* Handshake transfer was complete and successful.
2899                  * Check the Reply Frame.
2900                  */
2901                 int status, transfer_sz;
2902                 status = le16_to_cpu(preply->IOCStatus);
2903                 if (status == MPI_IOCSTATUS_SUCCESS) {
2904                         transfer_sz = le32_to_cpu(preply->ActualImageSize);
2905                         if (transfer_sz == sz)
2906                                 cmdStatus = 0;
2907                 }
2908         }
2909         dinitprintk((MYIOC_s_INFO_FMT ": do_upload cmdStatus=%d \n",
2910                         ioc->name, cmdStatus));
2911
2912
2913         if (cmdStatus) {
2914
2915                 ddlprintk((MYIOC_s_INFO_FMT ": fw upload failed, freeing image \n",
2916                         ioc->name));
2917                 mpt_free_fw_memory(ioc);
2918         }
2919
2920         return cmdStatus;
2921 }
2922
2923 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2924 /*
2925  *      mpt_downloadboot - DownloadBoot code
2926  *      @ioc: Pointer to MPT_ADAPTER structure
2927  *      @flag: Specify which part of IOC memory is to be uploaded.
2928  *      @sleepFlag: Specifies whether the process can sleep
2929  *
2930  *      FwDownloadBoot requires Programmed IO access.
2931  *
2932  *      Returns 0 for success
2933  *              -1 FW Image size is 0
2934  *              -2 No valid cached_fw Pointer
2935  *              <0 for fw upload failure.
2936  */
2937 static int
2938 mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag)
2939 {
2940         MpiExtImageHeader_t     *pExtImage;
2941         u32                      fwSize;
2942         u32                      diag0val;
2943         int                      count;
2944         u32                     *ptrFw;
2945         u32                      diagRwData;
2946         u32                      nextImage;
2947         u32                      load_addr;
2948         u32                      ioc_state=0;
2949
2950         ddlprintk((MYIOC_s_INFO_FMT "downloadboot: fw size 0x%x (%d), FW Ptr %p\n",
2951                                 ioc->name, pFwHeader->ImageSize, pFwHeader->ImageSize, pFwHeader));
2952
2953         CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
2954         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
2955         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
2956         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
2957         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
2958         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
2959
2960         CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM));
2961
2962         /* wait 1 msec */
2963         if (sleepFlag == CAN_SLEEP) {
2964                 msleep_interruptible(1);
2965         } else {
2966                 mdelay (1);
2967         }
2968
2969         diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
2970         CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
2971
2972         for (count = 0; count < 30; count ++) {
2973                 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
2974                 if (!(diag0val & MPI_DIAG_RESET_ADAPTER)) {
2975                         ddlprintk((MYIOC_s_INFO_FMT "RESET_ADAPTER cleared, count=%d\n",
2976                                 ioc->name, count));
2977                         break;
2978                 }
2979                 /* wait .1 sec */
2980                 if (sleepFlag == CAN_SLEEP) {
2981                         msleep_interruptible (100);
2982                 } else {
2983                         mdelay (100);
2984                 }
2985         }
2986
2987         if ( count == 30 ) {
2988                 ddlprintk((MYIOC_s_INFO_FMT "downloadboot failed! "
2989                 "Unable to get MPI_DIAG_DRWE mode, diag0val=%x\n",
2990                 ioc->name, diag0val));
2991                 return -3;
2992         }
2993
2994         CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
2995         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
2996         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
2997         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
2998         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
2999         CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3000
3001         /* Set the DiagRwEn and Disable ARM bits */
3002         CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_RW_ENABLE | MPI_DIAG_DISABLE_ARM));
3003
3004         fwSize = (pFwHeader->ImageSize + 3)/4;
3005         ptrFw = (u32 *) pFwHeader;
3006
3007         /* Write the LoadStartAddress to the DiagRw Address Register
3008          * using Programmed IO
3009          */
3010         if (ioc->errata_flag_1064)
3011                 pci_enable_io_access(ioc->pcidev);
3012
3013         CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->LoadStartAddress);
3014         ddlprintk((MYIOC_s_INFO_FMT "LoadStart addr written 0x%x \n",
3015                 ioc->name, pFwHeader->LoadStartAddress));
3016
3017         ddlprintk((MYIOC_s_INFO_FMT "Write FW Image: 0x%x bytes @ %p\n",
3018                                 ioc->name, fwSize*4, ptrFw));
3019         while (fwSize--) {
3020                 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
3021         }
3022
3023         nextImage = pFwHeader->NextImageHeaderOffset;
3024         while (nextImage) {
3025                 pExtImage = (MpiExtImageHeader_t *) ((char *)pFwHeader + nextImage);
3026
3027                 load_addr = pExtImage->LoadStartAddress;
3028
3029                 fwSize = (pExtImage->ImageSize + 3) >> 2;
3030                 ptrFw = (u32 *)pExtImage;
3031
3032                 ddlprintk((MYIOC_s_INFO_FMT "Write Ext Image: 0x%x (%d) bytes @ %p load_addr=%x\n",
3033                                                 ioc->name, fwSize*4, fwSize*4, ptrFw, load_addr));
3034                 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, load_addr);
3035
3036                 while (fwSize--) {
3037                         CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
3038                 }
3039                 nextImage = pExtImage->NextImageHeaderOffset;
3040         }
3041
3042         /* Write the IopResetVectorRegAddr */
3043         ddlprintk((MYIOC_s_INFO_FMT "Write IopResetVector Addr=%x! \n", ioc->name,      pFwHeader->IopResetRegAddr));
3044         CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->IopResetRegAddr);
3045
3046         /* Write the IopResetVectorValue */
3047         ddlprintk((MYIOC_s_INFO_FMT "Write IopResetVector Value=%x! \n", ioc->name, pFwHeader->IopResetVectorValue));
3048         CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, pFwHeader->IopResetVectorValue);
3049
3050         /* Clear the internal flash bad bit - autoincrementing register,
3051          * so must do two writes.
3052          */
3053         if (ioc->bus_type == SPI) {
3054                 /*
3055                  * 1030 and 1035 H/W errata, workaround to access
3056                  * the ClearFlashBadSignatureBit
3057                  */
3058                 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
3059                 diagRwData = CHIPREG_PIO_READ32(&ioc->pio_chip->DiagRwData);
3060                 diagRwData |= 0x40000000;
3061                 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
3062                 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, diagRwData);
3063
3064         } else /* if((ioc->bus_type == SAS) || (ioc->bus_type == FC)) */ {
3065                 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3066                 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val |
3067                     MPI_DIAG_CLEAR_FLASH_BAD_SIG);
3068
3069                 /* wait 1 msec */
3070                 if (sleepFlag == CAN_SLEEP) {
3071                         msleep_interruptible (1);
3072                 } else {
3073                         mdelay (1);
3074                 }
3075         }
3076
3077         if (ioc->errata_flag_1064)
3078                 pci_disable_io_access(ioc->pcidev);
3079
3080         diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3081         ddlprintk((MYIOC_s_INFO_FMT "downloadboot diag0val=%x, "
3082                 "turning off PREVENT_IOC_BOOT, DISABLE_ARM, RW_ENABLE\n",
3083                 ioc->name, diag0val));
3084         diag0val &= ~(MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM | MPI_DIAG_RW_ENABLE);
3085         ddlprintk((MYIOC_s_INFO_FMT "downloadboot now diag0val=%x\n",
3086                 ioc->name, diag0val));
3087         CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
3088
3089         /* Write 0xFF to reset the sequencer */
3090         CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3091
3092         if (ioc->bus_type == SAS) {
3093                 ioc_state = mpt_GetIocState(ioc, 0);
3094                 if ( (GetIocFacts(ioc, sleepFlag,
3095                                 MPT_HOSTEVENT_IOC_BRINGUP)) != 0 ) {
3096                         ddlprintk((MYIOC_s_INFO_FMT "GetIocFacts failed: IocState=%x\n",
3097                                         ioc->name, ioc_state));
3098                         return -EFAULT;
3099                 }
3100         }
3101
3102         for (count=0; count<HZ*20; count++) {
3103                 if ((ioc_state = mpt_GetIocState(ioc, 0)) & MPI_IOC_STATE_READY) {
3104                         ddlprintk((MYIOC_s_INFO_FMT "downloadboot successful! (count=%d) IocState=%x\n",
3105                                         ioc->name, count, ioc_state));
3106                         if (ioc->bus_type == SAS) {
3107                                 return 0;
3108                         }
3109                         if ((SendIocInit(ioc, sleepFlag)) != 0) {
3110                                 ddlprintk((MYIOC_s_INFO_FMT "downloadboot: SendIocInit failed\n",
3111                                         ioc->name));
3112                                 return -EFAULT;
3113                         }
3114                         ddlprintk((MYIOC_s_INFO_FMT "downloadboot: SendIocInit successful\n",
3115                                         ioc->name));
3116                         return 0;
3117                 }
3118                 if (sleepFlag == CAN_SLEEP) {
3119                         msleep_interruptible (10);
3120                 } else {
3121                         mdelay (10);
3122                 }
3123         }
3124         ddlprintk((MYIOC_s_INFO_FMT "downloadboot failed! IocState=%x\n",
3125                 ioc->name, ioc_state));