?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MERGE-master-patchset-edits
[linux-2.6/openmoko-kernel.git] / drivers / message / fusion / mptbase.c
blob96ac88317b8ecbadd702a3934c883b579e50aa49
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 PCI chip/adapter(s)
6 * running LSI Fusion MPT (Message Passing Technology) firmware.
7 *
8 * Copyright (c) 1999-2008 LSI Corporation
9 * (mailto:DL-MPTFusionLinux@lsi.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/kernel.h>
50 #include <linux/module.h>
51 #include <linux/errno.h>
52 #include <linux/init.h>
53 #include <linux/slab.h>
54 #include <linux/types.h>
55 #include <linux/pci.h>
56 #include <linux/kdev_t.h>
57 #include <linux/blkdev.h>
58 #include <linux/delay.h>
59 #include <linux/interrupt.h> /* needed for in_interrupt() proto */
60 #include <linux/dma-mapping.h>
61 #include <asm/io.h>
62 #ifdef CONFIG_MTRR
63 #include <asm/mtrr.h>
64 #endif
65
66 #include "mptbase.h"
67 #include "lsi/mpi_log_fc.h"
68
69 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
70 #define my_NAME "Fusion MPT base driver"
71 #define my_VERSION MPT_LINUX_VERSION_COMMON
72 #define MYNAM "mptbase"
73
74 MODULE_AUTHOR(MODULEAUTHOR);
75 MODULE_DESCRIPTION(my_NAME);
76 MODULE_LICENSE("GPL");
77 MODULE_VERSION(my_VERSION);
78
79 /*
80 * cmd line parameters
81 */
82
83 static int mpt_msi_enable_spi;
84 module_param(mpt_msi_enable_spi, int, 0);
85 MODULE_PARM_DESC(mpt_msi_enable_spi, " Enable MSI Support for SPI \
86 controllers (default=0)");
87
88 static int mpt_msi_enable_fc;
89 module_param(mpt_msi_enable_fc, int, 0);
90 MODULE_PARM_DESC(mpt_msi_enable_fc, " Enable MSI Support for FC \
91 controllers (default=0)");
92
93 static int mpt_msi_enable_sas;
94 module_param(mpt_msi_enable_sas, int, 1);
95 MODULE_PARM_DESC(mpt_msi_enable_sas, " Enable MSI Support for SAS \
96 controllers (default=1)");
97
98
99 static int mpt_channel_mapping;
100 module_param(mpt_channel_mapping, int, 0);
101 MODULE_PARM_DESC(mpt_channel_mapping, " Mapping id's to channels (default=0)");
102
103 static int mpt_debug_level;
104 static int mpt_set_debug_level(const char *val, struct kernel_param *kp);
105 module_param_call(mpt_debug_level, mpt_set_debug_level, param_get_int,
106 &mpt_debug_level, 0600);
107 MODULE_PARM_DESC(mpt_debug_level, " debug level - refer to mptdebug.h \
108 - (default=0)");
109
110 int mpt_fwfault_debug;
111 EXPORT_SYMBOL(mpt_fwfault_debug);
112 module_param_call(mpt_fwfault_debug, param_set_int, param_get_int,
113 &mpt_fwfault_debug, 0600);
114 MODULE_PARM_DESC(mpt_fwfault_debug, "Enable detection of Firmware fault"
115 " and halt Firmware on fault - (default=0)");
116
117
118
119 #ifdef MFCNT
120 static int mfcounter = 0;
121 #define PRINT_MF_COUNT 20000
122 #endif
123
124 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
125 /*
126 * Public data...
127 */
128
129 static struct proc_dir_entry *mpt_proc_root_dir;
130
131 #define WHOINIT_UNKNOWN 0xAA
132
133 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
134 /*
135 * Private data...
136 */
137 /* Adapter link list */
138 LIST_HEAD(ioc_list);
139 /* Callback lookup table */
140 static MPT_CALLBACK MptCallbacks[MPT_MAX_PROTOCOL_DRIVERS];
141 /* Protocol driver class lookup table */
142 static int MptDriverClass[MPT_MAX_PROTOCOL_DRIVERS];
143 /* Event handler lookup table */
144 static MPT_EVHANDLER MptEvHandlers[MPT_MAX_PROTOCOL_DRIVERS];
145 /* Reset handler lookup table */
146 static MPT_RESETHANDLER MptResetHandlers[MPT_MAX_PROTOCOL_DRIVERS];
147 static struct mpt_pci_driver *MptDeviceDriverHandlers[MPT_MAX_PROTOCOL_DRIVERS];
148
149 static DECLARE_WAIT_QUEUE_HEAD(mpt_waitq);
150
151 /*
152 * Driver Callback Index's
153 */
154 static u8 mpt_base_index = MPT_MAX_PROTOCOL_DRIVERS;
155 static u8 last_drv_idx;
156
157 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
158 /*
159 * Forward protos...
160 */
161 static irqreturn_t mpt_interrupt(int irq, void *bus_id);
162 static int mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);
163 static int mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes,
164 u32 *req, int replyBytes, u16 *u16reply, int maxwait,
165 int sleepFlag);
166 static int mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag);
167 static void mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev);
168 static void mpt_adapter_disable(MPT_ADAPTER *ioc);
169 static void mpt_adapter_dispose(MPT_ADAPTER *ioc);
170
171 static void MptDisplayIocCapabilities(MPT_ADAPTER *ioc);
172 static int MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag);
173 static int GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason);
174 static int GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
175 static int SendIocInit(MPT_ADAPTER *ioc, int sleepFlag);
176 static int SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
177 static int mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag);
178 static int mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag);
179 static int mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
180 static int KickStart(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
181 static int SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag);
182 static int PrimeIocFifos(MPT_ADAPTER *ioc);
183 static int WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
184 static int WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
185 static int WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
186 static int GetLanConfigPages(MPT_ADAPTER *ioc);
187 static int GetIoUnitPage2(MPT_ADAPTER *ioc);
188 int mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode);
189 static int mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum);
190 static int mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum);
191 static void mpt_read_ioc_pg_1(MPT_ADAPTER *ioc);
192 static void mpt_read_ioc_pg_4(MPT_ADAPTER *ioc);
193 static void mpt_timer_expired(unsigned long data);
194 static void mpt_get_manufacturing_pg_0(MPT_ADAPTER *ioc);
195 static int SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch);
196 static int SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp);
197 static int mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag);
198 static int mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init);
199
200 #ifdef CONFIG_PROC_FS
201 static int procmpt_summary_read(char *buf, char **start, off_t offset,
202 int request, int *eof, void *data);
203 static int procmpt_version_read(char *buf, char **start, off_t offset,
204 int request, int *eof, void *data);
205 static int procmpt_iocinfo_read(char *buf, char **start, off_t offset,
206 int request, int *eof, void *data);
207 #endif
208 static void mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc);
209
210 //int mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag);
211 static int ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *evReply, int *evHandlers);
212 static void mpt_iocstatus_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf);
213 static void mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info);
214 static void mpt_spi_log_info(MPT_ADAPTER *ioc, u32 log_info);
215 static void mpt_sas_log_info(MPT_ADAPTER *ioc, u32 log_info);
216 static int mpt_read_ioc_pg_3(MPT_ADAPTER *ioc);
217 static void mpt_inactive_raid_list_free(MPT_ADAPTER *ioc);
218
219 /* module entry point */
220 static int __init fusion_init (void);
221 static void __exit fusion_exit (void);
222
223 #define CHIPREG_READ32(addr) readl_relaxed(addr)
224 #define CHIPREG_READ32_dmasync(addr) readl(addr)
225 #define CHIPREG_WRITE32(addr,val) writel(val, addr)
226 #define CHIPREG_PIO_WRITE32(addr,val) outl(val, (unsigned long)addr)
227 #define CHIPREG_PIO_READ32(addr) inl((unsigned long)addr)
228
229 static void
230 pci_disable_io_access(struct pci_dev *pdev)
231 {
232 u16 command_reg;
233
234 pci_read_config_word(pdev, PCI_COMMAND, &command_reg);
235 command_reg &= ~1;
236 pci_write_config_word(pdev, PCI_COMMAND, command_reg);
237 }
238
239 static void
240 pci_enable_io_access(struct pci_dev *pdev)
241 {
242 u16 command_reg;
243
244 pci_read_config_word(pdev, PCI_COMMAND, &command_reg);
245 command_reg |= 1;
246 pci_write_config_word(pdev, PCI_COMMAND, command_reg);
247 }
248
249 static int mpt_set_debug_level(const char *val, struct kernel_param *kp)
250 {
251 int ret = param_set_int(val, kp);
252 MPT_ADAPTER *ioc;
253
254 if (ret)
255 return ret;
256
257 list_for_each_entry(ioc, &ioc_list, list)
258 ioc->debug_level = mpt_debug_level;
259 return 0;
260 }
261
262 /**
263 * mpt_get_cb_idx - obtain cb_idx for registered driver
264 * @dclass: class driver enum
265 *
266 * Returns cb_idx, or zero means it wasn't found
267 **/
268 static u8
269 mpt_get_cb_idx(MPT_DRIVER_CLASS dclass)
270 {
271 u8 cb_idx;
272
273 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--)
274 if (MptDriverClass[cb_idx] == dclass)
275 return cb_idx;
276 return 0;
277 }
278
279 /**
280 * mpt_fault_reset_work - work performed on workq after ioc fault
281 * @work: input argument, used to derive ioc
282 *
283 **/
284 static void
285 mpt_fault_reset_work(struct work_struct *work)
286 {
287 MPT_ADAPTER *ioc =
288 container_of(work, MPT_ADAPTER, fault_reset_work.work);
289 u32 ioc_raw_state;
290 int rc;
291 unsigned long flags;
292
293 if (ioc->diagPending || !ioc->active)
294 goto out;
295
296 ioc_raw_state = mpt_GetIocState(ioc, 0);
297 if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
298 printk(MYIOC_s_WARN_FMT "IOC is in FAULT state (%04xh)!!!\n",
299 ioc->name, ioc_raw_state & MPI_DOORBELL_DATA_MASK);
300 printk(MYIOC_s_WARN_FMT "Issuing HardReset from %s!!\n",
301 ioc->name, __func__);
302 rc = mpt_HardResetHandler(ioc, CAN_SLEEP);
303 printk(MYIOC_s_WARN_FMT "%s: HardReset: %s\n", ioc->name,
304 __func__, (rc == 0) ? "success" : "failed");
305 ioc_raw_state = mpt_GetIocState(ioc, 0);
306 if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT)
307 printk(MYIOC_s_WARN_FMT "IOC is in FAULT state after "
308 "reset (%04xh)\n", ioc->name, ioc_raw_state &
309 MPI_DOORBELL_DATA_MASK);
310 }
311
312 out:
313 /*
314 * Take turns polling alternate controller
315 */
316 if (ioc->alt_ioc)
317 ioc = ioc->alt_ioc;
318
319 /* rearm the timer */
320 spin_lock_irqsave(&ioc->fault_reset_work_lock, flags);
321 if (ioc->reset_work_q)
322 queue_delayed_work(ioc->reset_work_q, &ioc->fault_reset_work,
323 msecs_to_jiffies(MPT_POLLING_INTERVAL));
324 spin_unlock_irqrestore(&ioc->fault_reset_work_lock, flags);
325 }
326
327
328 /*
329 * Process turbo (context) reply...
330 */
331 static void
332 mpt_turbo_reply(MPT_ADAPTER *ioc, u32 pa)
333 {
334 MPT_FRAME_HDR *mf = NULL;
335 MPT_FRAME_HDR *mr = NULL;
336 u16 req_idx = 0;
337 u8 cb_idx;
338
339 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Got TURBO reply req_idx=%08x\n",
340 ioc->name, pa));
341
342 switch (pa >> MPI_CONTEXT_REPLY_TYPE_SHIFT) {
343 case MPI_CONTEXT_REPLY_TYPE_SCSI_INIT:
344 req_idx = pa & 0x0000FFFF;
345 cb_idx = (pa & 0x00FF0000) >> 16;
346 mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
347 break;
348 case MPI_CONTEXT_REPLY_TYPE_LAN:
349 cb_idx = mpt_get_cb_idx(MPTLAN_DRIVER);
350 /*
351 * Blind set of mf to NULL here was fatal
352 * after lan_reply says "freeme"
353 * Fix sort of combined with an optimization here;
354 * added explicit check for case where lan_reply
355 * was just returning 1 and doing nothing else.
356 * For this case skip the callback, but set up
357 * proper mf value first here:-)
358 */
359 if ((pa & 0x58000000) == 0x58000000) {
360 req_idx = pa & 0x0000FFFF;
361 mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
362 mpt_free_msg_frame(ioc, mf);
363 mb();
364 return;
365 break;
366 }
367 mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
368 break;
369 case MPI_CONTEXT_REPLY_TYPE_SCSI_TARGET:
370 cb_idx = mpt_get_cb_idx(MPTSTM_DRIVER);
371 mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
372 break;
373 default:
374 cb_idx = 0;
375 BUG();
376 }
377
378 /* Check for (valid) IO callback! */
379 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
380 MptCallbacks[cb_idx] == NULL) {
381 printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
382 __func__, ioc->name, cb_idx);
383 goto out;
384 }
385
386 if (MptCallbacks[cb_idx](ioc, mf, mr))
387 mpt_free_msg_frame(ioc, mf);
388 out:
389 mb();
390 }
391
392 static void
393 mpt_reply(MPT_ADAPTER *ioc, u32 pa)
394 {
395 MPT_FRAME_HDR *mf;
396 MPT_FRAME_HDR *mr;
397 u16 req_idx;
398 u8 cb_idx;
399 int freeme;
400
401 u32 reply_dma_low;
402 u16 ioc_stat;
403
404 /* non-TURBO reply! Hmmm, something may be up...
405 * Newest turbo reply mechanism; get address
406 * via left shift 1 (get rid of MPI_ADDRESS_REPLY_A_BIT)!
407 */
408
409 /* Map DMA address of reply header to cpu address.
410 * pa is 32 bits - but the dma address may be 32 or 64 bits
411 * get offset based only only the low addresses
412 */
413
414 reply_dma_low = (pa <<= 1);
415 mr = (MPT_FRAME_HDR *)((u8 *)ioc->reply_frames +
416 (reply_dma_low - ioc->reply_frames_low_dma));
417
418 req_idx = le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx);
419 cb_idx = mr->u.frame.hwhdr.msgctxu.fld.cb_idx;
420 mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
421
422 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Got non-TURBO reply=%p req_idx=%x cb_idx=%x Function=%x\n",
423 ioc->name, mr, req_idx, cb_idx, mr->u.hdr.Function));
424 DBG_DUMP_REPLY_FRAME(ioc, (u32 *)mr);
425
426 /* Check/log IOC log info
427 */
428 ioc_stat = le16_to_cpu(mr->u.reply.IOCStatus);
429 if (ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) {
430 u32 log_info = le32_to_cpu(mr->u.reply.IOCLogInfo);
431 if (ioc->bus_type == FC)
432 mpt_fc_log_info(ioc, log_info);
433 else if (ioc->bus_type == SPI)
434 mpt_spi_log_info(ioc, log_info);
435 else if (ioc->bus_type == SAS)
436 mpt_sas_log_info(ioc, log_info);
437 }
438
439 if (ioc_stat & MPI_IOCSTATUS_MASK)
440 mpt_iocstatus_info(ioc, (u32)ioc_stat, mf);
441
442 /* Check for (valid) IO callback! */
443 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
444 MptCallbacks[cb_idx] == NULL) {
445 printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
446 __func__, ioc->name, cb_idx);
447 freeme = 0;
448 goto out;
449 }
450
451 freeme = MptCallbacks[cb_idx](ioc, mf, mr);
452
453 out:
454 /* Flush (non-TURBO) reply with a WRITE! */
455 CHIPREG_WRITE32(&ioc->chip->ReplyFifo, pa);
456
457 if (freeme)
458 mpt_free_msg_frame(ioc, mf);
459 mb();
460 }
461
462 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
463 /**
464 * mpt_interrupt - MPT adapter (IOC) specific interrupt handler.
465 * @irq: irq number (not used)
466 * @bus_id: bus identifier cookie == pointer to MPT_ADAPTER structure
467 *
468 * This routine is registered via the request_irq() kernel API call,
469 * and handles all interrupts generated from a specific MPT adapter
470 * (also referred to as a IO Controller or IOC).
471 * This routine must clear the interrupt from the adapter and does
472 * so by reading the reply FIFO. Multiple replies may be processed
473 * per single call to this routine.
474 *
475 * This routine handles register-level access of the adapter but
476 * dispatches (calls) a protocol-specific callback routine to handle
477 * the protocol-specific details of the MPT request completion.
478 */
479 static irqreturn_t
480 mpt_interrupt(int irq, void *bus_id)
481 {
482 MPT_ADAPTER *ioc = bus_id;
483 u32 pa = CHIPREG_READ32_dmasync(&ioc->chip->ReplyFifo);
484
485 if (pa == 0xFFFFFFFF)
486 return IRQ_NONE;
487
488 /*
489 * Drain the reply FIFO!
490 */
491 do {
492 if (pa & MPI_ADDRESS_REPLY_A_BIT)
493 mpt_reply(ioc, pa);
494 else
495 mpt_turbo_reply(ioc, pa);
496 pa = CHIPREG_READ32_dmasync(&ioc->chip->ReplyFifo);
497 } while (pa != 0xFFFFFFFF);
498
499 return IRQ_HANDLED;
500 }
501
502 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
503 /**
504 * mpt_base_reply - MPT base driver's callback routine
505 * @ioc: Pointer to MPT_ADAPTER structure
506 * @mf: Pointer to original MPT request frame
507 * @reply: Pointer to MPT reply frame (NULL if TurboReply)
508 *
509 * MPT base driver's callback routine; all base driver
510 * "internal" request/reply processing is routed here.
511 * Currently used for EventNotification and EventAck handling.
512 *
513 * Returns 1 indicating original alloc'd request frame ptr
514 * should be freed, or 0 if it shouldn't.
515 */
516 static int
517 mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply)
518 {
519 int freereq = 1;
520 u8 func;
521
522 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply() called\n", ioc->name));
523 #ifdef CONFIG_FUSION_LOGGING
524 if ((ioc->debug_level & MPT_DEBUG_MSG_FRAME) &&
525 !(reply->u.hdr.MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY)) {
526 dmfprintk(ioc, printk(MYIOC_s_INFO_FMT ": Original request frame (@%p) header\n",
527 ioc->name, mf));
528 DBG_DUMP_REQUEST_FRAME_HDR(ioc, (u32 *)mf);
529 }
530 #endif
531
532 func = reply->u.hdr.Function;
533 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply, Function=%02Xh\n",
534 ioc->name, func));
535
536 if (func == MPI_FUNCTION_EVENT_NOTIFICATION) {
537 EventNotificationReply_t *pEvReply = (EventNotificationReply_t *) reply;
538 int evHandlers = 0;
539 int results;
540
541 results = ProcessEventNotification(ioc, pEvReply, &evHandlers);
542 if (results != evHandlers) {
543 /* CHECKME! Any special handling needed here? */
544 devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "Called %d event handlers, sum results = %d\n",
545 ioc->name, evHandlers, results));
546 }
547
548 /*
549 * Hmmm... It seems that EventNotificationReply is an exception
550 * to the rule of one reply per request.
551 */
552 if (pEvReply->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY) {
553 freereq = 0;
554 } else {
555 devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "EVENT_NOTIFICATION reply %p returns Request frame\n",
556 ioc->name, pEvReply));
557 }
558
559 #ifdef CONFIG_PROC_FS
560 // LogEvent(ioc, pEvReply);
561 #endif
562
563 } else if (func == MPI_FUNCTION_EVENT_ACK) {
564 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply, EventAck reply received\n",
565 ioc->name));
566 } else if (func == MPI_FUNCTION_CONFIG) {
567 CONFIGPARMS *pCfg;
568 unsigned long flags;
569
570 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "config_complete (mf=%p,mr=%p)\n",
571 ioc->name, mf, reply));
572
573 pCfg = * ((CONFIGPARMS **)((u8 *) mf + ioc->req_sz - sizeof(void *)));
574
575 if (pCfg) {
576 /* disable timer and remove from linked list */
577 del_timer(&pCfg->timer);
578
579 spin_lock_irqsave(&ioc->FreeQlock, flags);
580 list_del(&pCfg->linkage);
581 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
582
583 /*
584 * If IOC Status is SUCCESS, save the header
585 * and set the status code to GOOD.
586 */
587 pCfg->status = MPT_CONFIG_ERROR;
588 if (reply) {
589 ConfigReply_t *pReply = (ConfigReply_t *)reply;
590 u16 status;
591
592 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
593 dcprintk(ioc, printk(MYIOC_s_NOTE_FMT " IOCStatus=%04xh, IOCLogInfo=%08xh\n",
594 ioc->name, status, le32_to_cpu(pReply->IOCLogInfo)));
595
596 pCfg->status = status;
597 if (status == MPI_IOCSTATUS_SUCCESS) {
598 if ((pReply->Header.PageType &
599 MPI_CONFIG_PAGETYPE_MASK) ==
600 MPI_CONFIG_PAGETYPE_EXTENDED) {
601 pCfg->cfghdr.ehdr->ExtPageLength =
602 le16_to_cpu(pReply->ExtPageLength);
603 pCfg->cfghdr.ehdr->ExtPageType =
604 pReply->ExtPageType;
605 }
606 pCfg->cfghdr.hdr->PageVersion = pReply->Header.PageVersion;
607
608 /* If this is a regular header, save PageLength. */
609 /* LMP Do this better so not using a reserved field! */
610 pCfg->cfghdr.hdr->PageLength = pReply->Header.PageLength;
611 pCfg->cfghdr.hdr->PageNumber = pReply->Header.PageNumber;
612 pCfg->cfghdr.hdr->PageType = pReply->Header.PageType;
613 }
614 }
615
616 /*
617 * Wake up the original calling thread
618 */
619 pCfg->wait_done = 1;
620 wake_up(&mpt_waitq);
621 }
622 } else if (func == MPI_FUNCTION_SAS_IO_UNIT_CONTROL) {
623 /* we should be always getting a reply frame */
624 memcpy(ioc->persist_reply_frame, reply,
625 min(MPT_DEFAULT_FRAME_SIZE,
626 4*reply->u.reply.MsgLength));
627 del_timer(&ioc->persist_timer);
628 ioc->persist_wait_done = 1;
629 wake_up(&mpt_waitq);
630 } else {
631 printk(MYIOC_s_ERR_FMT "Unexpected msg function (=%02Xh) reply received!\n",
632 ioc->name, func);
633 }
634
635 /*
636 * Conditionally tell caller to free the original
637 * EventNotification/EventAck/unexpected request frame!
638 */
639 return freereq;
640 }
641
642 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
643 /**
644 * mpt_register - Register protocol-specific main callback handler.
645 * @cbfunc: callback function pointer
646 * @dclass: Protocol driver's class (%MPT_DRIVER_CLASS enum value)
647 *
648 * This routine is called by a protocol-specific driver (SCSI host,
649 * LAN, SCSI target) to register its reply callback routine. Each
650 * protocol-specific driver must do this before it will be able to
651 * use any IOC resources, such as obtaining request frames.
652 *
653 * NOTES: The SCSI protocol driver currently calls this routine thrice
654 * in order to register separate callbacks; one for "normal" SCSI IO;
655 * one for MptScsiTaskMgmt requests; one for Scan/DV requests.
656 *
657 * Returns u8 valued "handle" in the range (and S.O.D. order)
658 * {N,...,7,6,5,...,1} if successful.
659 * A return value of MPT_MAX_PROTOCOL_DRIVERS (including zero!) should be
660 * considered an error by the caller.
661 */
662 u8
663 mpt_register(MPT_CALLBACK cbfunc, MPT_DRIVER_CLASS dclass)
664 {
665 u8 cb_idx;
666 last_drv_idx = MPT_MAX_PROTOCOL_DRIVERS;
667
668 /*
669 * Search for empty callback slot in this order: {N,...,7,6,5,...,1}
670 * (slot/handle 0 is reserved!)
671 */
672 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
673 if (MptCallbacks[cb_idx] == NULL) {
674 MptCallbacks[cb_idx] = cbfunc;
675 MptDriverClass[cb_idx] = dclass;
676 MptEvHandlers[cb_idx] = NULL;
677 last_drv_idx = cb_idx;
678 break;
679 }
680 }
681
682 return last_drv_idx;
683 }
684
685 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
686 /**
687 * mpt_deregister - Deregister a protocol drivers resources.
688 * @cb_idx: previously registered callback handle
689 *
690 * Each protocol-specific driver should call this routine when its
691 * module is unloaded.
692 */
693 void
694 mpt_deregister(u8 cb_idx)
695 {
696 if (cb_idx && (cb_idx < MPT_MAX_PROTOCOL_DRIVERS)) {
697 MptCallbacks[cb_idx] = NULL;
698 MptDriverClass[cb_idx] = MPTUNKNOWN_DRIVER;
699 MptEvHandlers[cb_idx] = NULL;
700
701 last_drv_idx++;
702 }
703 }
704
705 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
706 /**
707 * mpt_event_register - Register protocol-specific event callback handler.
708 * @cb_idx: previously registered (via mpt_register) callback handle
709 * @ev_cbfunc: callback function
710 *
711 * This routine can be called by one or more protocol-specific drivers
712 * if/when they choose to be notified of MPT events.
713 *
714 * Returns 0 for success.
715 */
716 int
717 mpt_event_register(u8 cb_idx, MPT_EVHANDLER ev_cbfunc)
718 {
719 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
720 return -1;
721
722 MptEvHandlers[cb_idx] = ev_cbfunc;
723 return 0;
724 }
725
726 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
727 /**
728 * mpt_event_deregister - Deregister protocol-specific event callback handler
729 * @cb_idx: previously registered callback handle
730 *
731 * Each protocol-specific driver should call this routine
732 * when it does not (or can no longer) handle events,
733 * or when its module is unloaded.
734 */
735 void
736 mpt_event_deregister(u8 cb_idx)
737 {
738 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
739 return;
740
741 MptEvHandlers[cb_idx] = NULL;
742 }
743
744 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
745 /**
746 * mpt_reset_register - Register protocol-specific IOC reset handler.
747 * @cb_idx: previously registered (via mpt_register) callback handle
748 * @reset_func: reset function
749 *
750 * This routine can be called by one or more protocol-specific drivers
751 * if/when they choose to be notified of IOC resets.
752 *
753 * Returns 0 for success.
754 */
755 int
756 mpt_reset_register(u8 cb_idx, MPT_RESETHANDLER reset_func)
757 {
758 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
759 return -1;
760
761 MptResetHandlers[cb_idx] = reset_func;
762 return 0;
763 }
764
765 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
766 /**
767 * mpt_reset_deregister - Deregister protocol-specific IOC reset handler.
768 * @cb_idx: previously registered callback handle
769 *
770 * Each protocol-specific driver should call this routine
771 * when it does not (or can no longer) handle IOC reset handling,
772 * or when its module is unloaded.
773 */
774 void
775 mpt_reset_deregister(u8 cb_idx)
776 {
777 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
778 return;
779
780 MptResetHandlers[cb_idx] = NULL;
781 }
782
783 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
784 /**
785 * mpt_device_driver_register - Register device driver hooks
786 * @dd_cbfunc: driver callbacks struct
787 * @cb_idx: MPT protocol driver index
788 */
789 int
790 mpt_device_driver_register(struct mpt_pci_driver * dd_cbfunc, u8 cb_idx)
791 {
792 MPT_ADAPTER *ioc;
793 const struct pci_device_id *id;
794
795 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
796 return -EINVAL;
797
798 MptDeviceDriverHandlers[cb_idx] = dd_cbfunc;
799
800 /* call per pci device probe entry point */
801 list_for_each_entry(ioc, &ioc_list, list) {
802 id = ioc->pcidev->driver ?
803 ioc->pcidev->driver->id_table : NULL;
804 if (dd_cbfunc->probe)
805 dd_cbfunc->probe(ioc->pcidev, id);
806 }
807
808 return 0;
809 }
810
811 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
812 /**
813 * mpt_device_driver_deregister - DeRegister device driver hooks
814 * @cb_idx: MPT protocol driver index
815 */
816 void
817 mpt_device_driver_deregister(u8 cb_idx)
818 {
819 struct mpt_pci_driver *dd_cbfunc;
820 MPT_ADAPTER *ioc;
821
822 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
823 return;
824
825 dd_cbfunc = MptDeviceDriverHandlers[cb_idx];
826
827 list_for_each_entry(ioc, &ioc_list, list) {
828 if (dd_cbfunc->remove)
829 dd_cbfunc->remove(ioc->pcidev);
830 }
831
832 MptDeviceDriverHandlers[cb_idx] = NULL;
833 }
834
835
836 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
837 /**
838 * mpt_get_msg_frame - Obtain an MPT request frame from the pool
839 * @cb_idx: Handle of registered MPT protocol driver
840 * @ioc: Pointer to MPT adapter structure
841 *
842 * Obtain an MPT request frame from the pool (of 1024) that are
843 * allocated per MPT adapter.
844 *
845 * Returns pointer to a MPT request frame or %NULL if none are available
846 * or IOC is not active.
847 */
848 MPT_FRAME_HDR*
849 mpt_get_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc)
850 {
851 MPT_FRAME_HDR *mf;
852 unsigned long flags;
853 u16 req_idx; /* Request index */
854
855 /* validate handle and ioc identifier */
856
857 #ifdef MFCNT
858 if (!ioc->active)
859 printk(MYIOC_s_WARN_FMT "IOC Not Active! mpt_get_msg_frame "
860 "returning NULL!\n", ioc->name);
861 #endif
862
863 /* If interrupts are not attached, do not return a request frame */
864 if (!ioc->active)
865 return NULL;
866
867 spin_lock_irqsave(&ioc->FreeQlock, flags);
868 if (!list_empty(&ioc->FreeQ)) {
869 int req_offset;
870
871 mf = list_entry(ioc->FreeQ.next, MPT_FRAME_HDR,
872 u.frame.linkage.list);
873 list_del(&mf->u.frame.linkage.list);
874 mf->u.frame.linkage.arg1 = 0;
875 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx; /* byte */
876 req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
877 /* u16! */
878 req_idx = req_offset / ioc->req_sz;
879 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
880 mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
881 /* Default, will be changed if necessary in SG generation */
882 ioc->RequestNB[req_idx] = ioc->NB_for_64_byte_frame;
883 #ifdef MFCNT
884 ioc->mfcnt++;
885 #endif
886 }
887 else
888 mf = NULL;
889 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
890
891 #ifdef MFCNT
892 if (mf == NULL)
893 printk(MYIOC_s_WARN_FMT "IOC Active. No free Msg Frames! "
894 "Count 0x%x Max 0x%x\n", ioc->name, ioc->mfcnt,
895 ioc->req_depth);
896 mfcounter++;
897 if (mfcounter == PRINT_MF_COUNT)
898 printk(MYIOC_s_INFO_FMT "MF Count 0x%x Max 0x%x \n", ioc->name,
899 ioc->mfcnt, ioc->req_depth);
900 #endif
901
902 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_get_msg_frame(%d,%d), got mf=%p\n",
903 ioc->name, cb_idx, ioc->id, mf));
904 return mf;
905 }
906
907 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
908 /**
909 * mpt_put_msg_frame - Send a protocol-specific MPT request frame to an IOC
910 * @cb_idx: Handle of registered MPT protocol driver
911 * @ioc: Pointer to MPT adapter structure
912 * @mf: Pointer to MPT request frame
913 *
914 * This routine posts an MPT request frame to the request post FIFO of a
915 * specific MPT adapter.
916 */
917 void
918 mpt_put_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
919 {
920 u32 mf_dma_addr;
921 int req_offset;
922 u16 req_idx; /* Request index */
923
924 /* ensure values are reset properly! */
925 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx; /* byte */
926 req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
927 /* u16! */
928 req_idx = req_offset / ioc->req_sz;
929 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
930 mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
931
932 DBG_DUMP_PUT_MSG_FRAME(ioc, (u32 *)mf);
933
934 mf_dma_addr = (ioc->req_frames_low_dma + req_offset) | ioc->RequestNB[req_idx];
935 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mf_dma_addr=%x req_idx=%d "
936 "RequestNB=%x\n", ioc->name, mf_dma_addr, req_idx,
937 ioc->RequestNB[req_idx]));
938 CHIPREG_WRITE32(&ioc->chip->RequestFifo, mf_dma_addr);
939 }
940
941 /**
942 * mpt_put_msg_frame_hi_pri - Send a hi-pri protocol-specific MPT request frame
943 * @cb_idx: Handle of registered MPT protocol driver
944 * @ioc: Pointer to MPT adapter structure
945 * @mf: Pointer to MPT request frame
946 *
947 * Send a protocol-specific MPT request frame to an IOC using
948 * hi-priority request queue.
949 *
950 * This routine posts an MPT request frame to the request post FIFO of a
951 * specific MPT adapter.
952 **/
953 void
954 mpt_put_msg_frame_hi_pri(u8 cb_idx, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
955 {
956 u32 mf_dma_addr;
957 int req_offset;
958 u16 req_idx; /* Request index */
959
960 /* ensure values are reset properly! */
961 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx;
962 req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
963 req_idx = req_offset / ioc->req_sz;
964 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
965 mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
966
967 DBG_DUMP_PUT_MSG_FRAME(ioc, (u32 *)mf);
968
969 mf_dma_addr = (ioc->req_frames_low_dma + req_offset);
970 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mf_dma_addr=%x req_idx=%d\n",
971 ioc->name, mf_dma_addr, req_idx));
972 CHIPREG_WRITE32(&ioc->chip->RequestHiPriFifo, mf_dma_addr);
973 }
974
975 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
976 /**
977 * mpt_free_msg_frame - Place MPT request frame back on FreeQ.
978 * @ioc: Pointer to MPT adapter structure
979 * @mf: Pointer to MPT request frame
980 *
981 * This routine places a MPT request frame back on the MPT adapter's
982 * FreeQ.
983 */
984 void
985 mpt_free_msg_frame(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
986 {
987 unsigned long flags;
988
989 /* Put Request back on FreeQ! */
990 spin_lock_irqsave(&ioc->FreeQlock, flags);
991 mf->u.frame.linkage.arg1 = 0xdeadbeaf; /* signature to know if this mf is freed */
992 list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeQ);
993 #ifdef MFCNT
994 ioc->mfcnt--;
995 #endif
996 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
997 }
998
999 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1000 /**
1001 * mpt_add_sge - Place a simple SGE at address pAddr.
1002 * @pAddr: virtual address for SGE
1003 * @flagslength: SGE flags and data transfer length
1004 * @dma_addr: Physical address
1005 *
1006 * This routine places a MPT request frame back on the MPT adapter's
1007 * FreeQ.
1008 */
1009 void
1010 mpt_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
1011 {
1012 if (sizeof(dma_addr_t) == sizeof(u64)) {
1013 SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
1014 u32 tmp = dma_addr & 0xFFFFFFFF;
1015
1016 pSge->FlagsLength = cpu_to_le32(flagslength);
1017 pSge->Address.Low = cpu_to_le32(tmp);
1018 tmp = (u32) ((u64)dma_addr >> 32);
1019 pSge->Address.High = cpu_to_le32(tmp);
1020
1021 } else {
1022 SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
1023 pSge->FlagsLength = cpu_to_le32(flagslength);
1024 pSge->Address = cpu_to_le32(dma_addr);
1025 }
1026 }
1027
1028 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1029 /**
1030 * mpt_send_handshake_request - Send MPT request via doorbell handshake method.
1031 * @cb_idx: Handle of registered MPT protocol driver
1032 * @ioc: Pointer to MPT adapter structure
1033 * @reqBytes: Size of the request in bytes
1034 * @req: Pointer to MPT request frame
1035 * @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
1036 *
1037 * This routine is used exclusively to send MptScsiTaskMgmt
1038 * requests since they are required to be sent via doorbell handshake.
1039 *
1040 * NOTE: It is the callers responsibility to byte-swap fields in the
1041 * request which are greater than 1 byte in size.
1042 *
1043 * Returns 0 for success, non-zero for failure.
1044 */
1045 int
1046 mpt_send_handshake_request(u8 cb_idx, MPT_ADAPTER *ioc, int reqBytes, u32 *req, int sleepFlag)
1047 {
1048 int r = 0;
1049 u8 *req_as_bytes;
1050 int ii;
1051
1052 /* State is known to be good upon entering
1053 * this function so issue the bus reset
1054 * request.
1055 */
1056
1057 /*
1058 * Emulate what mpt_put_msg_frame() does /wrt to sanity
1059 * setting cb_idx/req_idx. But ONLY if this request
1060 * is in proper (pre-alloc'd) request buffer range...
1061 */
1062 ii = MFPTR_2_MPT_INDEX(ioc,(MPT_FRAME_HDR*)req);
1063 if (reqBytes >= 12 && ii >= 0 && ii < ioc->req_depth) {
1064 MPT_FRAME_HDR *mf = (MPT_FRAME_HDR*)req;
1065 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(ii);
1066 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx;
1067 }
1068
1069 /* Make sure there are no doorbells */
1070 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1071
1072 CHIPREG_WRITE32(&ioc->chip->Doorbell,
1073 ((MPI_FUNCTION_HANDSHAKE<<MPI_DOORBELL_FUNCTION_SHIFT) |
1074 ((reqBytes/4)<<MPI_DOORBELL_ADD_DWORDS_SHIFT)));
1075
1076 /* Wait for IOC doorbell int */
1077 if ((ii = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0) {
1078 return ii;
1079 }
1080
1081 /* Read doorbell and check for active bit */
1082 if (!(CHIPREG_READ32(&ioc->chip->Doorbell) & MPI_DOORBELL_ACTIVE))
1083 return -5;
1084
1085 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_send_handshake_request start, WaitCnt=%d\n",
1086 ioc->name, ii));
1087
1088 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1089
1090 if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
1091 return -2;
1092 }
1093
1094 /* Send request via doorbell handshake */
1095 req_as_bytes = (u8 *) req;
1096 for (ii = 0; ii < reqBytes/4; ii++) {
1097 u32 word;
1098
1099 word = ((req_as_bytes[(ii*4) + 0] << 0) |
1100 (req_as_bytes[(ii*4) + 1] << 8) |
1101 (req_as_bytes[(ii*4) + 2] << 16) |
1102 (req_as_bytes[(ii*4) + 3] << 24));
1103 CHIPREG_WRITE32(&ioc->chip->Doorbell, word);
1104 if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
1105 r = -3;
1106 break;
1107 }
1108 }
1109
1110 if (r >= 0 && WaitForDoorbellInt(ioc, 10, sleepFlag) >= 0)
1111 r = 0;
1112 else
1113 r = -4;
1114
1115 /* Make sure there are no doorbells */
1116 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1117
1118 return r;
1119 }
1120
1121 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1122 /**
1123 * mpt_host_page_access_control - control the IOC's Host Page Buffer access
1124 * @ioc: Pointer to MPT adapter structure
1125 * @access_control_value: define bits below
1126 * @sleepFlag: Specifies whether the process can sleep
1127 *
1128 * Provides mechanism for the host driver to control the IOC's
1129 * Host Page Buffer access.
1130 *
1131 * Access Control Value - bits[15:12]
1132 * 0h Reserved
1133 * 1h Enable Access { MPI_DB_HPBAC_ENABLE_ACCESS }
1134 * 2h Disable Access { MPI_DB_HPBAC_DISABLE_ACCESS }
1135 * 3h Free Buffer { MPI_DB_HPBAC_FREE_BUFFER }
1136 *
1137 * Returns 0 for success, non-zero for failure.
1138 */
1139
1140 static int
1141 mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag)
1142 {
1143 int r = 0;
1144
1145 /* return if in use */
1146 if (CHIPREG_READ32(&ioc->chip->Doorbell)
1147 & MPI_DOORBELL_ACTIVE)
1148 return -1;
1149
1150 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1151
1152 CHIPREG_WRITE32(&ioc->chip->Doorbell,
1153 ((MPI_FUNCTION_HOST_PAGEBUF_ACCESS_CONTROL
1154 <<MPI_DOORBELL_FUNCTION_SHIFT) |
1155 (access_control_value<<12)));
1156
1157 /* Wait for IOC to clear Doorbell Status bit */
1158 if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
1159 return -2;
1160 }else
1161 return 0;
1162 }
1163
1164 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1165 /**
1166 * mpt_host_page_alloc - allocate system memory for the fw
1167 * @ioc: Pointer to pointer to IOC adapter
1168 * @ioc_init: Pointer to ioc init config page
1169 *
1170 * If we already allocated memory in past, then resend the same pointer.
1171 * Returns 0 for success, non-zero for failure.
1172 */
1173 static int
1174 mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init)
1175 {
1176 char *psge;
1177 int flags_length;
1178 u32 host_page_buffer_sz=0;
1179
1180 if(!ioc->HostPageBuffer) {
1181
1182 host_page_buffer_sz =
1183 le32_to_cpu(ioc->facts.HostPageBufferSGE.FlagsLength) & 0xFFFFFF;
1184
1185 if(!host_page_buffer_sz)
1186 return 0; /* fw doesn't need any host buffers */
1187
1188 /* spin till we get enough memory */
1189 while(host_page_buffer_sz > 0) {
1190
1191 if((ioc->HostPageBuffer = pci_alloc_consistent(
1192 ioc->pcidev,
1193 host_page_buffer_sz,
1194 &ioc->HostPageBuffer_dma)) != NULL) {
1195
1196 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1197 "host_page_buffer @ %p, dma @ %x, sz=%d bytes\n",
1198 ioc->name, ioc->HostPageBuffer,
1199 (u32)ioc->HostPageBuffer_dma,
1200 host_page_buffer_sz));
1201 ioc->alloc_total += host_page_buffer_sz;
1202 ioc->HostPageBuffer_sz = host_page_buffer_sz;
1203 break;
1204 }
1205
1206 host_page_buffer_sz -= (4*1024);
1207 }
1208 }
1209
1210 if(!ioc->HostPageBuffer) {
1211 printk(MYIOC_s_ERR_FMT
1212 "Failed to alloc memory for host_page_buffer!\n",
1213 ioc->name);
1214 return -999;
1215 }
1216
1217 psge = (char *)&ioc_init->HostPageBufferSGE;
1218 flags_length = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
1219 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
1220 MPI_SGE_FLAGS_32_BIT_ADDRESSING |
1221 MPI_SGE_FLAGS_HOST_TO_IOC |
1222 MPI_SGE_FLAGS_END_OF_BUFFER;
1223 if (sizeof(dma_addr_t) == sizeof(u64)) {
1224 flags_length |= MPI_SGE_FLAGS_64_BIT_ADDRESSING;
1225 }
1226 flags_length = flags_length << MPI_SGE_FLAGS_SHIFT;
1227 flags_length |= ioc->HostPageBuffer_sz;
1228 mpt_add_sge(psge, flags_length, ioc->HostPageBuffer_dma);
1229 ioc->facts.HostPageBufferSGE = ioc_init->HostPageBufferSGE;
1230
1231 return 0;
1232 }
1233
1234 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1235 /**
1236 * mpt_verify_adapter - Given IOC identifier, set pointer to its adapter structure.
1237 * @iocid: IOC unique identifier (integer)
1238 * @iocpp: Pointer to pointer to IOC adapter
1239 *
1240 * Given a unique IOC identifier, set pointer to the associated MPT
1241 * adapter structure.
1242 *
1243 * Returns iocid and sets iocpp if iocid is found.
1244 * Returns -1 if iocid is not found.
1245 */
1246 int
1247 mpt_verify_adapter(int iocid, MPT_ADAPTER **iocpp)
1248 {
1249 MPT_ADAPTER *ioc;
1250
1251 list_for_each_entry(ioc,&ioc_list,list) {
1252 if (ioc->id == iocid) {
1253 *iocpp =ioc;
1254 return iocid;
1255 }
1256 }
1257
1258 *iocpp = NULL;
1259 return -1;
1260 }
1261
1262 /**
1263 * mpt_get_product_name - returns product string
1264 * @vendor: pci vendor id
1265 * @device: pci device id
1266 * @revision: pci revision id
1267 * @prod_name: string returned
1268 *
1269 * Returns product string displayed when driver loads,
1270 * in /proc/mpt/summary and /sysfs/class/scsi_host/host<X>/version_product
1271 *
1272 **/
1273 static void
1274 mpt_get_product_name(u16 vendor, u16 device, u8 revision, char *prod_name)
1275 {
1276 char *product_str = NULL;
1277
1278 if (vendor == PCI_VENDOR_ID_BROCADE) {
1279 switch (device)
1280 {
1281 case MPI_MANUFACTPAGE_DEVICEID_FC949E:
1282 switch (revision)
1283 {
1284 case 0x00:
1285 product_str = "BRE040 A0";
1286 break;
1287 case 0x01:
1288 product_str = "BRE040 A1";
1289 break;
1290 default:
1291 product_str = "BRE040";
1292 break;
1293 }
1294 break;
1295 }
1296 goto out;
1297 }
1298
1299 switch (device)
1300 {
1301 case MPI_MANUFACTPAGE_DEVICEID_FC909:
1302 product_str = "LSIFC909 B1";
1303 break;
1304 case MPI_MANUFACTPAGE_DEVICEID_FC919:
1305 product_str = "LSIFC919 B0";
1306 break;
1307 case MPI_MANUFACTPAGE_DEVICEID_FC929:
1308 product_str = "LSIFC929 B0";
1309 break;
1310 case MPI_MANUFACTPAGE_DEVICEID_FC919X:
1311 if (revision < 0x80)
1312 product_str = "LSIFC919X A0";
1313 else
1314 product_str = "LSIFC919XL A1";
1315 break;
1316 case MPI_MANUFACTPAGE_DEVICEID_FC929X:
1317 if (revision < 0x80)
1318 product_str = "LSIFC929X A0";
1319 else
1320 product_str = "LSIFC929XL A1";
1321 break;
1322 case MPI_MANUFACTPAGE_DEVICEID_FC939X:
1323 product_str = "LSIFC939X A1";
1324 break;
1325 case MPI_MANUFACTPAGE_DEVICEID_FC949X:
1326 product_str = "LSIFC949X A1";
1327 break;
1328 case MPI_MANUFACTPAGE_DEVICEID_FC949E:
1329 switch (revision)
1330 {
1331 case 0x00:
1332 product_str = "LSIFC949E A0";
1333 break;
1334 case 0x01:
1335 product_str = "LSIFC949E A1";
1336 break;
1337 default:
1338 product_str = "LSIFC949E";
1339 break;
1340 }
1341 break;
1342 case MPI_MANUFACTPAGE_DEVID_53C1030:
1343 switch (revision)
1344 {
1345 case 0x00:
1346 product_str = "LSI53C1030 A0";
1347 break;
1348 case 0x01:
1349 product_str = "LSI53C1030 B0";
1350 break;
1351 case 0x03:
1352 product_str = "LSI53C1030 B1";
1353 break;
1354 case 0x07:
1355 product_str = "LSI53C1030 B2";
1356 break;
1357 case 0x08:
1358 product_str = "LSI53C1030 C0";
1359 break;
1360 case 0x80:
1361 product_str = "LSI53C1030T A0";
1362 break;
1363 case 0x83:
1364 product_str = "LSI53C1030T A2";
1365 break;
1366 case 0x87:
1367 product_str = "LSI53C1030T A3";
1368 break;
1369 case 0xc1:
1370 product_str = "LSI53C1020A A1";
1371 break;
1372 default:
1373 product_str = "LSI53C1030";
1374 break;
1375 }
1376 break;
1377 case MPI_MANUFACTPAGE_DEVID_1030_53C1035:
1378 switch (revision)
1379 {
1380 case 0x03:
1381 product_str = "LSI53C1035 A2";
1382 break;
1383 case 0x04:
1384 product_str = "LSI53C1035 B0";
1385 break;
1386 default:
1387 product_str = "LSI53C1035";
1388 break;
1389 }
1390 break;
1391 case MPI_MANUFACTPAGE_DEVID_SAS1064:
1392 switch (revision)
1393 {
1394 case 0x00:
1395 product_str = "LSISAS1064 A1";
1396 break;
1397 case 0x01:
1398 product_str = "LSISAS1064 A2";
1399 break;
1400 case 0x02:
1401 product_str = "LSISAS1064 A3";
1402 break;
1403 case 0x03:
1404 product_str = "LSISAS1064 A4";
1405 break;
1406 default:
1407 product_str = "LSISAS1064";
1408 break;
1409 }
1410 break;
1411 case MPI_MANUFACTPAGE_DEVID_SAS1064E:
1412 switch (revision)
1413 {
1414 case 0x00:
1415 product_str = "LSISAS1064E A0";
1416 break;
1417 case 0x01:
1418 product_str = "LSISAS1064E B0";
1419 break;
1420 case 0x02:
1421 product_str = "LSISAS1064E B1";
1422 break;
1423 case 0x04:
1424 product_str = "LSISAS1064E B2";
1425 break;
1426 case 0x08:
1427 product_str = "LSISAS1064E B3";
1428 break;
1429 default:
1430 product_str = "LSISAS1064E";
1431 break;
1432 }
1433 break;
1434 case MPI_MANUFACTPAGE_DEVID_SAS1068:
1435 switch (revision)
1436 {
1437 case 0x00:
1438 product_str = "LSISAS1068 A0";
1439 break;
1440 case 0x01:
1441 product_str = "LSISAS1068 B0";
1442 break;
1443 case 0x02:
1444 product_str = "LSISAS1068 B1";
1445 break;
1446 default:
1447 product_str = "LSISAS1068";
1448 break;
1449 }
1450 break;
1451 case MPI_MANUFACTPAGE_DEVID_SAS1068E:
1452 switch (revision)
1453 {
1454 case 0x00:
1455 product_str = "LSISAS1068E A0";
1456 break;
1457 case 0x01:
1458 product_str = "LSISAS1068E B0";
1459 break;
1460 case 0x02:
1461 product_str = "LSISAS1068E B1";
1462 break;
1463 case 0x04:
1464 product_str = "LSISAS1068E B2";
1465 break;
1466 case 0x08:
1467 product_str = "LSISAS1068E B3";
1468 break;
1469 default:
1470 product_str = "LSISAS1068E";
1471 break;
1472 }
1473 break;
1474 case MPI_MANUFACTPAGE_DEVID_SAS1078:
1475 switch (revision)
1476 {
1477 case 0x00:
1478 product_str = "LSISAS1078 A0";
1479 break;
1480 case 0x01:
1481 product_str = "LSISAS1078 B0";
1482 break;
1483 case 0x02:
1484 product_str = "LSISAS1078 C0";
1485 break;
1486 case 0x03:
1487 product_str = "LSISAS1078 C1";
1488 break;
1489 case 0x04:
1490 product_str = "LSISAS1078 C2";
1491 break;
1492 default:
1493 product_str = "LSISAS1078";
1494 break;
1495 }
1496 break;
1497 }
1498
1499 out:
1500 if (product_str)
1501 sprintf(prod_name, "%s", product_str);
1502 }
1503
1504 /**
1505 * mpt_mapresources - map in memory mapped io
1506 * @ioc: Pointer to pointer to IOC adapter
1507 *
1508 **/
1509 static int
1510 mpt_mapresources(MPT_ADAPTER *ioc)
1511 {
1512 u8 __iomem *mem;
1513 int ii;
1514 unsigned long mem_phys;
1515 unsigned long port;
1516 u32 msize;
1517 u32 psize;
1518 u8 revision;
1519 int r = -ENODEV;
1520 struct pci_dev *pdev;
1521
1522 pdev = ioc->pcidev;
1523 ioc->bars = pci_select_bars(pdev, IORESOURCE_MEM);
1524 if (pci_enable_device_mem(pdev)) {
1525 printk(MYIOC_s_ERR_FMT "pci_enable_device_mem() "
1526 "failed\n", ioc->name);
1527 return r;
1528 }
1529 if (pci_request_selected_regions(pdev, ioc->bars, "mpt")) {
1530 printk(MYIOC_s_ERR_FMT "pci_request_selected_regions() with "
1531 "MEM failed\n", ioc->name);
1532 return r;
1533 }
1534
1535 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1536
1537 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)
1538 && !pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK)) {
1539 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
1540 ": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
1541 ioc->name));
1542 } else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)
1543 && !pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
1544 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
1545 ": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
1546 ioc->name));
1547 } else {
1548 printk(MYIOC_s_WARN_FMT "no suitable DMA mask for %s\n",
1549 ioc->name, pci_name(pdev));
1550 pci_release_selected_regions(pdev, ioc->bars);
1551 return r;
1552 }
1553
1554 mem_phys = msize = 0;
1555 port = psize = 0;
1556 for (ii = 0; ii < DEVICE_COUNT_RESOURCE; ii++) {
1557 if (pci_resource_flags(pdev, ii) & PCI_BASE_ADDRESS_SPACE_IO) {
1558 if (psize)
1559 continue;
1560 /* Get I/O space! */
1561 port = pci_resource_start(pdev, ii);
1562 psize = pci_resource_len(pdev, ii);
1563 } else {
1564 if (msize)
1565 continue;
1566 /* Get memmap */
1567 mem_phys = pci_resource_start(pdev, ii);
1568 msize = pci_resource_len(pdev, ii);
1569 }
1570 }
1571 ioc->mem_size = msize;
1572
1573 mem = NULL;
1574 /* Get logical ptr for PciMem0 space */
1575 /*mem = ioremap(mem_phys, msize);*/
1576 mem = ioremap(mem_phys, msize);
1577 if (mem == NULL) {
1578 printk(MYIOC_s_ERR_FMT ": ERROR - Unable to map adapter"
1579 " memory!\n", ioc->name);
1580 return -EINVAL;
1581 }
1582 ioc->memmap = mem;
1583 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "mem = %p, mem_phys = %lx\n",
1584 ioc->name, mem, mem_phys));
1585
1586 ioc->mem_phys = mem_phys;
1587 ioc->chip = (SYSIF_REGS __iomem *)mem;
1588
1589 /* Save Port IO values in case we need to do downloadboot */
1590 ioc->pio_mem_phys = port;
1591 ioc->pio_chip = (SYSIF_REGS __iomem *)port;
1592
1593 return 0;
1594 }
1595
1596 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1597 /**
1598 * mpt_attach - Install a PCI intelligent MPT adapter.
1599 * @pdev: Pointer to pci_dev structure
1600 * @id: PCI device ID information
1601 *
1602 * This routine performs all the steps necessary to bring the IOC of
1603 * a MPT adapter to a OPERATIONAL state. This includes registering
1604 * memory regions, registering the interrupt, and allocating request
1605 * and reply memory pools.
1606 *
1607 * This routine also pre-fetches the LAN MAC address of a Fibre Channel
1608 * MPT adapter.
1609 *
1610 * Returns 0 for success, non-zero for failure.
1611 *
1612 * TODO: Add support for polled controllers
1613 */
1614 int
1615 mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id)
1616 {
1617 MPT_ADAPTER *ioc;
1618 u8 cb_idx;
1619 int r = -ENODEV;
1620 u8 revision;
1621 u8 pcixcmd;
1622 static int mpt_ids = 0;
1623 #ifdef CONFIG_PROC_FS
1624 struct proc_dir_entry *dent, *ent;
1625 #endif
1626
1627 ioc = kzalloc(sizeof(MPT_ADAPTER), GFP_ATOMIC);
1628 if (ioc == NULL) {
1629 printk(KERN_ERR MYNAM ": ERROR - Insufficient memory to add adapter!\n");
1630 return -ENOMEM;
1631 }
1632
1633 ioc->id = mpt_ids++;
1634 sprintf(ioc->name, "ioc%d", ioc->id);
1635
1636 /*
1637 * set initial debug level
1638 * (refer to mptdebug.h)
1639 *
1640 */
1641 ioc->debug_level = mpt_debug_level;
1642 if (mpt_debug_level)
1643 printk(KERN_INFO "mpt_debug_level=%xh\n", mpt_debug_level);
1644
1645 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": mpt_adapter_install\n", ioc->name));
1646
1647 ioc->pcidev = pdev;
1648 if (mpt_mapresources(ioc)) {
1649 kfree(ioc);
1650 return r;
1651 }
1652
1653 ioc->alloc_total = sizeof(MPT_ADAPTER);
1654 ioc->req_sz = MPT_DEFAULT_FRAME_SIZE; /* avoid div by zero! */
1655 ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
1656
1657 ioc->pcidev = pdev;
1658 ioc->diagPending = 0;
1659 spin_lock_init(&ioc->diagLock);
1660 spin_lock_init(&ioc->initializing_hba_lock);
1661
1662 /* Initialize the event logging.
1663 */
1664 ioc->eventTypes = 0; /* None */
1665 ioc->eventContext = 0;
1666 ioc->eventLogSize = 0;
1667 ioc->events = NULL;
1668
1669 #ifdef MFCNT
1670 ioc->mfcnt = 0;
1671 #endif
1672
1673 ioc->cached_fw = NULL;
1674
1675 /* Initilize SCSI Config Data structure
1676 */
1677 memset(&ioc->spi_data, 0, sizeof(SpiCfgData));
1678
1679 /* Initialize the running configQ head.
1680 */
1681 INIT_LIST_HEAD(&ioc->configQ);
1682
1683 /* Initialize the fc rport list head.
1684 */
1685 INIT_LIST_HEAD(&ioc->fc_rports);
1686
1687 /* Find lookup slot. */
1688 INIT_LIST_HEAD(&ioc->list);
1689
1690
1691 /* Initialize workqueue */
1692 INIT_DELAYED_WORK(&ioc->fault_reset_work, mpt_fault_reset_work);
1693 spin_lock_init(&ioc->fault_reset_work_lock);
1694
1695 snprintf(ioc->reset_work_q_name, sizeof(ioc->reset_work_q_name),
1696 "mpt_poll_%d", ioc->id);
1697 ioc->reset_work_q =
1698 create_singlethread_workqueue(ioc->reset_work_q_name);
1699 if (!ioc->reset_work_q) {
1700 printk(MYIOC_s_ERR_FMT "Insufficient memory to add adapter!\n",
1701 ioc->name);
1702 pci_release_selected_regions(pdev, ioc->bars);
1703 kfree(ioc);
1704 return -ENOMEM;
1705 }
1706
1707 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "facts @ %p, pfacts[0] @ %p\n",
1708 ioc->name, &ioc->facts, &ioc->pfacts[0]));
1709
1710 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1711 mpt_get_product_name(pdev->vendor, pdev->device, revision, ioc->prod_name);
1712
1713 switch (pdev->device)
1714 {
1715 case MPI_MANUFACTPAGE_DEVICEID_FC939X:
1716 case MPI_MANUFACTPAGE_DEVICEID_FC949X:
1717 ioc->errata_flag_1064 = 1;
1718 case MPI_MANUFACTPAGE_DEVICEID_FC909:
1719 case MPI_MANUFACTPAGE_DEVICEID_FC929:
1720 case MPI_MANUFACTPAGE_DEVICEID_FC919:
1721 case MPI_MANUFACTPAGE_DEVICEID_FC949E:
1722 ioc->bus_type = FC;
1723 break;
1724
1725 case MPI_MANUFACTPAGE_DEVICEID_FC929X:
1726 if (revision < XL_929) {
1727 /* 929X Chip Fix. Set Split transactions level
1728 * for PCIX. Set MOST bits to zero.
1729 */
1730 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1731 pcixcmd &= 0x8F;
1732 pci_write_config_byte(pdev, 0x6a, pcixcmd);
1733 } else {
1734 /* 929XL Chip Fix. Set MMRBC to 0x08.
1735 */
1736 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1737 pcixcmd |= 0x08;
1738 pci_write_config_byte(pdev, 0x6a, pcixcmd);
1739 }
1740 ioc->bus_type = FC;
1741 break;
1742
1743 case MPI_MANUFACTPAGE_DEVICEID_FC919X:
1744 /* 919X Chip Fix. Set Split transactions level
1745 * for PCIX. Set MOST bits to zero.
1746 */
1747 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1748 pcixcmd &= 0x8F;
1749 pci_write_config_byte(pdev, 0x6a, pcixcmd);
1750 ioc->bus_type = FC;
1751 break;
1752
1753 case MPI_MANUFACTPAGE_DEVID_53C1030:
1754 /* 1030 Chip Fix. Disable Split transactions
1755 * for PCIX. Set MOST bits to zero if Rev < C0( = 8).
1756 */
1757 if (revision < C0_1030) {
1758 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1759 pcixcmd &= 0x8F;
1760 pci_write_config_byte(pdev, 0x6a, pcixcmd);
1761 }
1762
1763 case MPI_MANUFACTPAGE_DEVID_1030_53C1035:
1764 ioc->bus_type = SPI;
1765 break;
1766
1767 case MPI_MANUFACTPAGE_DEVID_SAS1064:
1768 case MPI_MANUFACTPAGE_DEVID_SAS1068:
1769 ioc->errata_flag_1064 = 1;
1770
1771 case MPI_MANUFACTPAGE_DEVID_SAS1064E:
1772 case MPI_MANUFACTPAGE_DEVID_SAS1068E:
1773 case MPI_MANUFACTPAGE_DEVID_SAS1078:
1774 ioc->bus_type = SAS;
1775 }
1776
1777
1778 switch (ioc->bus_type) {
1779
1780 case SAS:
1781 ioc->msi_enable = mpt_msi_enable_sas;
1782 break;
1783
1784 case SPI:
1785 ioc->msi_enable = mpt_msi_enable_spi;
1786 break;
1787
1788 case FC:
1789 ioc->msi_enable = mpt_msi_enable_fc;
1790 break;
1791
1792 default:
1793 ioc->msi_enable = 0;
1794 break;
1795 }
1796 if (ioc->errata_flag_1064)
1797 pci_disable_io_access(pdev);
1798
1799 spin_lock_init(&ioc->FreeQlock);
1800
1801 /* Disable all! */
1802 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1803 ioc->active = 0;
1804 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1805
1806 /* Set IOC ptr in the pcidev's driver data. */
1807 pci_set_drvdata(ioc->pcidev, ioc);
1808
1809 /* Set lookup ptr. */
1810 list_add_tail(&ioc->list, &ioc_list);
1811
1812 /* Check for "bound ports" (929, 929X, 1030, 1035) to reduce redundant resets.
1813 */
1814 mpt_detect_bound_ports(ioc, pdev);
1815
1816 if ((r = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP,
1817 CAN_SLEEP)) != 0){
1818 printk(MYIOC_s_ERR_FMT "didn't initialize properly! (%d)\n",
1819 ioc->name, r);
1820
1821 list_del(&ioc->list);
1822 if (ioc->alt_ioc)
1823 ioc->alt_ioc->alt_ioc = NULL;
1824 iounmap(ioc->memmap);
1825 if (r != -5)
1826 pci_release_selected_regions(pdev, ioc->bars);
1827
1828 destroy_workqueue(ioc->reset_work_q);
1829 ioc->reset_work_q = NULL;
1830
1831 kfree(ioc);
1832 pci_set_drvdata(pdev, NULL);
1833 return r;
1834 }
1835
1836 /* call per device driver probe entry point */
1837 for(cb_idx = 0; cb_idx < MPT_MAX_PROTOCOL_DRIVERS; cb_idx++) {
1838 if(MptDeviceDriverHandlers[cb_idx] &&
1839 MptDeviceDriverHandlers[cb_idx]->probe) {
1840 MptDeviceDriverHandlers[cb_idx]->probe(pdev,id);
1841 }
1842 }
1843
1844 #ifdef CONFIG_PROC_FS
1845 /*
1846 * Create "/proc/mpt/iocN" subdirectory entry for each MPT adapter.
1847 */
1848 dent = proc_mkdir(ioc->name, mpt_proc_root_dir);
1849 if (dent) {
1850 ent = create_proc_entry("info", S_IFREG|S_IRUGO, dent);
1851 if (ent) {
1852 ent->read_proc = procmpt_iocinfo_read;
1853 ent->data = ioc;
1854 }
1855 ent = create_proc_entry("summary", S_IFREG|S_IRUGO, dent);
1856 if (ent) {
1857 ent->read_proc = procmpt_summary_read;
1858 ent->data = ioc;
1859 }
1860 }
1861 #endif
1862
1863 if (!ioc->alt_ioc)
1864 queue_delayed_work(ioc->reset_work_q, &ioc->fault_reset_work,
1865 msecs_to_jiffies(MPT_POLLING_INTERVAL));
1866
1867 return 0;
1868 }
1869
1870 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1871 /**
1872 * mpt_detach - Remove a PCI intelligent MPT adapter.
1873 * @pdev: Pointer to pci_dev structure
1874 */
1875
1876 void
1877 mpt_detach(struct pci_dev *pdev)
1878 {
1879 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1880 char pname[32];
1881 u8 cb_idx;
1882 unsigned long flags;
1883 struct workqueue_struct *wq;
1884
1885 /*
1886 * Stop polling ioc for fault condition
1887 */
1888 spin_lock_irqsave(&ioc->fault_reset_work_lock, flags);
1889 wq = ioc->reset_work_q;
1890 ioc->reset_work_q = NULL;
1891 spin_unlock_irqrestore(&ioc->fault_reset_work_lock, flags);
1892 cancel_delayed_work(&ioc->fault_reset_work);
1893 destroy_workqueue(wq);
1894
1895
1896 sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/summary", ioc->name);
1897 remove_proc_entry(pname, NULL);
1898 sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/info", ioc->name);
1899 remove_proc_entry(pname, NULL);
1900 sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s", ioc->name);
1901 remove_proc_entry(pname, NULL);
1902
1903 /* call per device driver remove entry point */
1904 for(cb_idx = 0; cb_idx < MPT_MAX_PROTOCOL_DRIVERS; cb_idx++) {
1905 if(MptDeviceDriverHandlers[cb_idx] &&
1906 MptDeviceDriverHandlers[cb_idx]->remove) {
1907 MptDeviceDriverHandlers[cb_idx]->remove(pdev);
1908 }
1909 }
1910
1911 /* Disable interrupts! */
1912 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1913
1914 ioc->active = 0;
1915 synchronize_irq(pdev->irq);
1916
1917 /* Clear any lingering interrupt */
1918 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1919
1920 CHIPREG_READ32(&ioc->chip->IntStatus);
1921
1922 mpt_adapter_dispose(ioc);
1923
1924 pci_set_drvdata(pdev, NULL);
1925 }
1926
1927 /**************************************************************************
1928 * Power Management
1929 */
1930 #ifdef CONFIG_PM
1931 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1932 /**
1933 * mpt_suspend - Fusion MPT base driver suspend routine.
1934 * @pdev: Pointer to pci_dev structure
1935 * @state: new state to enter
1936 */
1937 int
1938 mpt_suspend(struct pci_dev *pdev, pm_message_t state)
1939 {
1940 u32 device_state;
1941 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1942
1943 device_state = pci_choose_state(pdev, state);
1944 printk(MYIOC_s_INFO_FMT "pci-suspend: pdev=0x%p, slot=%s, Entering "
1945 "operating state [D%d]\n", ioc->name, pdev, pci_name(pdev),
1946 device_state);
1947
1948 /* put ioc into READY_STATE */
1949 if(SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, CAN_SLEEP)) {
1950 printk(MYIOC_s_ERR_FMT
1951 "pci-suspend: IOC msg unit reset failed!\n", ioc->name);
1952 }
1953
1954 /* disable interrupts */
1955 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1956 ioc->active = 0;
1957
1958 /* Clear any lingering interrupt */
1959 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1960
1961 free_irq(ioc->pci_irq, ioc);
1962 if (ioc->msi_enable)
1963 pci_disable_msi(ioc->pcidev);
1964 ioc->pci_irq = -1;
1965 pci_save_state(pdev);
1966 pci_disable_device(pdev);
1967 pci_release_selected_regions(pdev, ioc->bars);
1968 pci_set_power_state(pdev, device_state);
1969 return 0;
1970 }
1971
1972 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1973 /**
1974 * mpt_resume - Fusion MPT base driver resume routine.
1975 * @pdev: Pointer to pci_dev structure
1976 */
1977 int
1978 mpt_resume(struct pci_dev *pdev)
1979 {
1980 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1981 u32 device_state = pdev->current_state;
1982 int recovery_state;
1983 int err;
1984
1985 printk(MYIOC_s_INFO_FMT "pci-resume: pdev=0x%p, slot=%s, Previous "
1986 "operating state [D%d]\n", ioc->name, pdev, pci_name(pdev),
1987 device_state);
1988
1989 pci_set_power_state(pdev, PCI_D0);
1990 pci_enable_wake(pdev, PCI_D0, 0);
1991 pci_restore_state(pdev);
1992 ioc->pcidev = pdev;
1993 err = mpt_mapresources(ioc);
1994 if (err)
1995 return err;
1996
1997 printk(MYIOC_s_INFO_FMT "pci-resume: ioc-state=0x%x,doorbell=0x%x\n",
1998 ioc->name, (mpt_GetIocState(ioc, 1) >> MPI_IOC_STATE_SHIFT),
1999 CHIPREG_READ32(&ioc->chip->Doorbell));
2000
2001 /*
2002 * Errata workaround for SAS pci express:
2003 * Upon returning to the D0 state, the contents of the doorbell will be
2004 * stale data, and this will incorrectly signal to the host driver that
2005 * the firmware is ready to process mpt commands. The workaround is
2006 * to issue a diagnostic reset.
2007 */
2008 if (ioc->bus_type == SAS && (pdev->device ==
2009 MPI_MANUFACTPAGE_DEVID_SAS1068E || pdev->device ==
2010 MPI_MANUFACTPAGE_DEVID_SAS1064E)) {
2011 if (KickStart(ioc, 1, CAN_SLEEP) < 0) {
2012 printk(MYIOC_s_WARN_FMT "pci-resume: Cannot recover\n",
2013 ioc->name);
2014 goto out;
2015 }
2016 }
2017
2018 /* bring ioc to operational state */
2019 printk(MYIOC_s_INFO_FMT "Sending mpt_do_ioc_recovery\n", ioc->name);
2020 recovery_state = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP,
2021 CAN_SLEEP);
2022 if (recovery_state != 0)
2023 printk(MYIOC_s_WARN_FMT "pci-resume: Cannot recover, "
2024 "error:[%x]\n", ioc->name, recovery_state);
2025 else
2026 printk(MYIOC_s_INFO_FMT
2027 "pci-resume: success\n", ioc->name);
2028 out:
2029 return 0;
2030
2031 }
2032 #endif
2033
2034 static int
2035 mpt_signal_reset(u8 index, MPT_ADAPTER *ioc, int reset_phase)
2036 {
2037 if ((MptDriverClass[index] == MPTSPI_DRIVER &&
2038 ioc->bus_type != SPI) ||
2039 (MptDriverClass[index] == MPTFC_DRIVER &&
2040 ioc->bus_type != FC) ||
2041 (MptDriverClass[index] == MPTSAS_DRIVER &&
2042 ioc->bus_type != SAS))
2043 /* make sure we only call the relevant reset handler
2044 * for the bus */
2045 return 0;
2046 return (MptResetHandlers[index])(ioc, reset_phase);
2047 }
2048
2049 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2050 /**
2051 * mpt_do_ioc_recovery - Initialize or recover MPT adapter.
2052 * @ioc: Pointer to MPT adapter structure
2053 * @reason: Event word / reason
2054 * @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
2055 *
2056 * This routine performs all the steps necessary to bring the IOC
2057 * to a OPERATIONAL state.
2058 *
2059 * This routine also pre-fetches the LAN MAC address of a Fibre Channel
2060 * MPT adapter.
2061 *
2062 * Returns:
2063 * 0 for success
2064 * -1 if failed to get board READY
2065 * -2 if READY but IOCFacts Failed
2066 * -3 if READY but PrimeIOCFifos Failed
2067 * -4 if READY but IOCInit Failed
2068 * -5 if failed to enable_device and/or request_selected_regions
2069 * -6 if failed to upload firmware
2070 */
2071 static int
2072 mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag)
2073 {
2074 int hard_reset_done = 0;
2075 int alt_ioc_ready = 0;
2076 int hard;
2077 int rc=0;
2078 int ii;
2079 u8 cb_idx;
2080 int handlers;
2081 int ret = 0;
2082 int reset_alt_ioc_active = 0;
2083 int irq_allocated = 0;
2084 u8 *a;
2085
2086 printk(MYIOC_s_INFO_FMT "Initiating %s\n", ioc->name,
2087 reason == MPT_HOSTEVENT_IOC_BRINGUP ? "bringup" : "recovery");
2088
2089 /* Disable reply interrupts (also blocks FreeQ) */
2090 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
2091 ioc->active = 0;
2092
2093 if (ioc->alt_ioc) {
2094 if (ioc->alt_ioc->active)
2095 reset_alt_ioc_active = 1;
2096
2097 /* Disable alt-IOC's reply interrupts (and FreeQ) for a bit ... */
2098 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, 0xFFFFFFFF);
2099 ioc->alt_ioc->active = 0;
2100 }
2101
2102 hard = 1;
2103 if (reason == MPT_HOSTEVENT_IOC_BRINGUP)
2104 hard = 0;
2105
2106 if ((hard_reset_done = MakeIocReady(ioc, hard, sleepFlag)) < 0) {
2107 if (hard_reset_done == -4) {
2108 printk(MYIOC_s_WARN_FMT "Owned by PEER..skipping!\n",
2109 ioc->name);
2110
2111 if (reset_alt_ioc_active && ioc->alt_ioc) {
2112 /* (re)Enable alt-IOC! (reply interrupt, FreeQ) */
2113 dprintk(ioc, printk(MYIOC_s_INFO_FMT
2114 "alt_ioc reply irq re-enabled\n", ioc->alt_ioc->name));
2115 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
2116 ioc->alt_ioc->active = 1;
2117 }
2118
2119 } else {
2120 printk(MYIOC_s_WARN_FMT "NOT READY!\n", ioc->name);
2121 }
2122 return -1;
2123 }
2124
2125 /* hard_reset_done = 0 if a soft reset was performed
2126 * and 1 if a hard reset was performed.
2127 */
2128 if (hard_reset_done && reset_alt_ioc_active && ioc->alt_ioc) {
2129 if ((rc = MakeIocReady(ioc->alt_ioc, 0, sleepFlag)) == 0)
2130 alt_ioc_ready = 1;
2131 else
2132 printk(MYIOC_s_WARN_FMT "alt_ioc not ready!\n", ioc->alt_ioc->name);
2133 }
2134
2135 for (ii=0; ii<5; ii++) {
2136 /* Get IOC facts! Allow 5 retries */
2137 if ((rc = GetIocFacts(ioc, sleepFlag, reason)) == 0)
2138 break;
2139 }
2140
2141
2142 if (ii == 5) {
2143 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2144 "Retry IocFacts failed rc=%x\n", ioc->name, rc));
2145 ret = -2;
2146 } else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2147 MptDisplayIocCapabilities(ioc);
2148 }
2149
2150 if (alt_ioc_ready) {
2151 if ((rc = GetIocFacts(ioc->alt_ioc, sleepFlag, reason)) != 0) {
2152 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2153 "Initial Alt IocFacts failed rc=%x\n", ioc->name, rc));
2154 /* Retry - alt IOC was initialized once
2155 */
2156 rc = GetIocFacts(ioc->alt_ioc, sleepFlag, reason);
2157 }
2158 if (rc) {
2159 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2160 "Retry Alt IocFacts failed rc=%x\n", ioc->name, rc));
2161 alt_ioc_ready = 0;
2162 reset_alt_ioc_active = 0;
2163 } else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2164 MptDisplayIocCapabilities(ioc->alt_ioc);
2165 }
2166 }
2167
2168 if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP) &&
2169 (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)) {
2170 pci_release_selected_regions(ioc->pcidev, ioc->bars);
2171 ioc->bars = pci_select_bars(ioc->pcidev, IORESOURCE_MEM |
2172 IORESOURCE_IO);
2173 if (pci_enable_device(ioc->pcidev))
2174 return -5;
2175 if (pci_request_selected_regions(ioc->pcidev, ioc->bars,
2176 "mpt"))
2177 return -5;
2178 }
2179
2180 /*
2181 * Device is reset now. It must have de-asserted the interrupt line
2182 * (if it was asserted) and it should be safe to register for the
2183 * interrupt now.
2184 */
2185 if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP)) {
2186 ioc->pci_irq = -1;
2187 if (ioc->pcidev->irq) {
2188 if (ioc->msi_enable && !pci_enable_msi(ioc->pcidev))
2189 printk(MYIOC_s_INFO_FMT "PCI-MSI enabled\n",
2190 ioc->name);
2191 else
2192 ioc->msi_enable = 0;
2193 rc = request_irq(ioc->pcidev->irq, mpt_interrupt,
2194 IRQF_SHARED, ioc->name, ioc);
2195 if (rc < 0) {
2196 printk(MYIOC_s_ERR_FMT "Unable to allocate "
2197 "interrupt %d!\n", ioc->name, ioc->pcidev->irq);
2198 if (ioc->msi_enable)
2199 pci_disable_msi(ioc->pcidev);
2200 return -EBUSY;
2201 }
2202 irq_allocated = 1;
2203 ioc->pci_irq = ioc->pcidev->irq;
2204 pci_set_master(ioc->pcidev); /* ?? */
2205 dprintk(ioc, printk(MYIOC_s_INFO_FMT "installed at interrupt "
2206 "%d\n", ioc->name, ioc->pcidev->irq));
2207 }
2208 }
2209
2210 /* Prime reply & request queues!
2211 * (mucho alloc's) Must be done prior to
2212 * init as upper addresses are needed for init.
2213 * If fails, continue with alt-ioc processing
2214 */
2215 if ((ret == 0) && ((rc = PrimeIocFifos(ioc)) != 0))
2216 ret = -3;
2217
2218 /* May need to check/upload firmware & data here!
2219 * If fails, continue with alt-ioc processing
2220 */
2221 if ((ret == 0) && ((rc = SendIocInit(ioc, sleepFlag)) != 0))
2222 ret = -4;
2223 // NEW!
2224 if (alt_ioc_ready && ((rc = PrimeIocFifos(ioc->alt_ioc)) != 0)) {
2225 printk(MYIOC_s_WARN_FMT ": alt_ioc (%d) FIFO mgmt alloc!\n",
2226 ioc->alt_ioc->name, rc);
2227 alt_ioc_ready = 0;
2228 reset_alt_ioc_active = 0;
2229 }
2230
2231 if (alt_ioc_ready) {
2232 if ((rc = SendIocInit(ioc->alt_ioc, sleepFlag)) != 0) {
2233 alt_ioc_ready = 0;
2234 reset_alt_ioc_active = 0;
2235 printk(MYIOC_s_WARN_FMT "alt_ioc (%d) init failure!\n",
2236 ioc->alt_ioc->name, rc);
2237 }
2238 }
2239
2240 if (reason == MPT_HOSTEVENT_IOC_BRINGUP){
2241 if (ioc->upload_fw) {
2242 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2243 "firmware upload required!\n", ioc->name));
2244
2245 /* Controller is not operational, cannot do upload
2246 */
2247 if (ret == 0) {
2248 rc = mpt_do_upload(ioc, sleepFlag);
2249 if (rc == 0) {
2250 if (ioc->alt_ioc && ioc->alt_ioc->cached_fw) {
2251 /*
2252 * Maintain only one pointer to FW memory
2253 * so there will not be two attempt to
2254 * downloadboot onboard dual function
2255 * chips (mpt_adapter_disable,
2256 * mpt_diag_reset)
2257 */
2258 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2259 "mpt_upload: alt_%s has cached_fw=%p \n",
2260 ioc->name, ioc->alt_ioc->name, ioc->alt_ioc->cached_fw));
2261 ioc->cached_fw = NULL;
2262 }
2263 } else {
2264 printk(MYIOC_s_WARN_FMT
2265 "firmware upload failure!\n", ioc->name);
2266 ret = -6;
2267 }
2268 }
2269 }
2270 }
2271
2272 if (ret == 0) {
2273 /* Enable! (reply interrupt) */
2274 CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);
2275 ioc->active = 1;
2276 }
2277
2278 if (reset_alt_ioc_active && ioc->alt_ioc) {
2279 /* (re)Enable alt-IOC! (reply interrupt) */
2280 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "alt_ioc reply irq re-enabled\n",
2281 ioc->alt_ioc->name));
2282 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
2283 ioc->alt_ioc->active = 1;
2284 }
2285
2286 /* Enable MPT base driver management of EventNotification
2287 * and EventAck handling.
2288 */
2289 if ((ret == 0) && (!ioc->facts.EventState))
2290 (void) SendEventNotification(ioc, 1); /* 1=Enable EventNotification */
2291
2292 if (ioc->alt_ioc && alt_ioc_ready && !ioc->alt_ioc->facts.EventState)
2293 (void) SendEventNotification(ioc->alt_ioc, 1); /* 1=Enable EventNotification */
2294
2295 /* Add additional "reason" check before call to GetLanConfigPages
2296 * (combined with GetIoUnitPage2 call). This prevents a somewhat
2297 * recursive scenario; GetLanConfigPages times out, timer expired
2298 * routine calls HardResetHandler, which calls into here again,
2299 * and we try GetLanConfigPages again...
2300 */
2301 if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP)) {
2302
2303 /*
2304 * Initalize link list for inactive raid volumes.
2305 */
2306 mutex_init(&ioc->raid_data.inactive_list_mutex);
2307 INIT_LIST_HEAD(&ioc->raid_data.inactive_list);
2308
2309 if (ioc->bus_type == SAS) {
2310
2311 /* clear persistency table */
2312 if(ioc->facts.IOCExceptions &
2313 MPI_IOCFACTS_EXCEPT_PERSISTENT_TABLE_FULL) {
2314 ret = mptbase_sas_persist_operation(ioc,
2315 MPI_SAS_OP_CLEAR_NOT_PRESENT);
2316 if(ret != 0)
2317 goto out;
2318 }
2319
2320 /* Find IM volumes
2321 */
2322 mpt_findImVolumes(ioc);
2323
2324 } else if (ioc->bus_type == FC) {
2325 if ((ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) &&
2326 (ioc->lan_cnfg_page0.Header.PageLength == 0)) {
2327 /*
2328 * Pre-fetch the ports LAN MAC address!
2329 * (LANPage1_t stuff)
2330 */
2331 (void) GetLanConfigPages(ioc);
2332 a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
2333 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2334 "LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
2335 ioc->name, a[5], a[4], a[3], a[2], a[1], a[0]));
2336
2337 }
2338 } else {
2339 /* Get NVRAM and adapter maximums from SPP 0 and 2
2340 */
2341 mpt_GetScsiPortSettings(ioc, 0);
2342
2343 /* Get version and length of SDP 1
2344 */
2345 mpt_readScsiDevicePageHeaders(ioc, 0);
2346
2347 /* Find IM volumes
2348 */
2349 if (ioc->facts.MsgVersion >= MPI_VERSION_01_02)
2350 mpt_findImVolumes(ioc);
2351
2352 /* Check, and possibly reset, the coalescing value
2353 */
2354 mpt_read_ioc_pg_1(ioc);
2355
2356 mpt_read_ioc_pg_4(ioc);
2357 }
2358
2359 GetIoUnitPage2(ioc);
2360 mpt_get_manufacturing_pg_0(ioc);
2361 }
2362
2363 /*
2364 * Call each currently registered protocol IOC reset handler
2365 * with post-reset indication.
2366 * NOTE: If we're doing _IOC_BRINGUP, there can be no
2367 * MptResetHandlers[] registered yet.
2368 */
2369 if (hard_reset_done) {
2370 rc = handlers = 0;
2371 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
2372 if ((ret == 0) && MptResetHandlers[cb_idx]) {
2373 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2374 "Calling IOC post_reset handler #%d\n",
2375 ioc->name, cb_idx));
2376 rc += mpt_signal_reset(cb_idx, ioc, MPT_IOC_POST_RESET);
2377 handlers++;
2378 }
2379
2380 if (alt_ioc_ready && MptResetHandlers[cb_idx]) {
2381 drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2382 "Calling IOC post_reset handler #%d\n",
2383 ioc->alt_ioc->name, cb_idx));
2384 rc += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_POST_RESET);
2385 handlers++;
2386 }
2387 }
2388 /* FIXME? Examine results here? */
2389 }
2390
2391 out:
2392 if ((ret != 0) && irq_allocated) {
2393 free_irq(ioc->pci_irq, ioc);
2394 if (ioc->msi_enable)
2395 pci_disable_msi(ioc->pcidev);
2396 }
2397 return ret;
2398 }
2399
2400 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2401 /**
2402 * mpt_detect_bound_ports - Search for matching PCI bus/dev_function
2403 * @ioc: Pointer to MPT adapter structure
2404 * @pdev: Pointer to (struct pci_dev) structure
2405 *
2406 * Search for PCI bus/dev_function which matches
2407 * PCI bus/dev_function (+/-1) for newly discovered 929,
2408 * 929X, 1030 or 1035.
2409 *
2410 * If match on PCI dev_function +/-1 is found, bind the two MPT adapters
2411 * using alt_ioc pointer fields in their %MPT_ADAPTER structures.
2412 */
2413 static void
2414 mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev)
2415 {
2416 struct pci_dev *peer=NULL;
2417 unsigned int slot = PCI_SLOT(pdev->devfn);
2418 unsigned int func = PCI_FUNC(pdev->devfn);
2419 MPT_ADAPTER *ioc_srch;
2420
2421 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PCI device %s devfn=%x/%x,"
2422 " searching for devfn match on %x or %x\n",
2423 ioc->name, pci_name(pdev), pdev->bus->number,
2424 pdev->devfn, func-1, func+1));
2425
2426 peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func-1));
2427 if (!peer) {
2428 peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func+1));
2429 if (!peer)
2430 return;
2431 }
2432
2433 list_for_each_entry(ioc_srch, &ioc_list, list) {
2434 struct pci_dev *_pcidev = ioc_srch->pcidev;
2435 if (_pcidev == peer) {
2436 /* Paranoia checks */
2437 if (ioc->alt_ioc != NULL) {
2438 printk(MYIOC_s_WARN_FMT "Oops, already bound to %s!\n",
2439 ioc->name, ioc->alt_ioc->name);
2440 break;
2441 } else if (ioc_srch->alt_ioc != NULL) {
2442 printk(MYIOC_s_WARN_FMT "Oops, already bound to %s!\n",
2443 ioc_srch->name, ioc_srch->alt_ioc->name);
2444 break;
2445 }
2446 dprintk(ioc, printk(MYIOC_s_INFO_FMT "FOUND! binding to %s\n",
2447 ioc->name, ioc_srch->name));
2448 ioc_srch->alt_ioc = ioc;
2449 ioc->alt_ioc = ioc_srch;
2450 }
2451 }
2452 pci_dev_put(peer);
2453 }
2454
2455 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2456 /**
2457 * mpt_adapter_disable - Disable misbehaving MPT adapter.
2458 * @ioc: Pointer to MPT adapter structure
2459 */
2460 static void
2461 mpt_adapter_disable(MPT_ADAPTER *ioc)
2462 {
2463 int sz;
2464 int ret;
2465
2466 if (ioc->cached_fw != NULL) {
2467 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: Pushing FW onto "
2468 "adapter\n", __func__, ioc->name));
2469 if ((ret = mpt_downloadboot(ioc, (MpiFwHeader_t *)
2470 ioc->cached_fw, CAN_SLEEP)) < 0) {
2471 printk(MYIOC_s_WARN_FMT
2472 ": firmware downloadboot failure (%d)!\n",
2473 ioc->name, ret);
2474 }
2475 }
2476
2477 /* Disable adapter interrupts! */
2478 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
2479 ioc->active = 0;
2480 /* Clear any lingering interrupt */
2481 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
2482
2483 if (ioc->alloc != NULL) {
2484 sz = ioc->alloc_sz;
2485 dexitprintk(ioc, printk(MYIOC_s_INFO_FMT "free @ %p, sz=%d bytes\n",
2486 ioc->name, ioc->alloc, ioc->alloc_sz));
2487 pci_free_consistent(ioc->pcidev, sz,
2488 ioc->alloc, ioc->alloc_dma);
2489 ioc->reply_frames = NULL;
2490 ioc->req_frames = NULL;
2491 ioc->alloc = NULL;
2492 ioc->alloc_total -= sz;
2493 }
2494
2495 if (ioc->sense_buf_pool != NULL) {
2496 sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
2497 pci_free_consistent(ioc->pcidev, sz,
2498 ioc->sense_buf_pool, ioc->sense_buf_pool_dma);
2499 ioc->sense_buf_pool = NULL;
2500 ioc->alloc_total -= sz;
2501 }
2502
2503 if (ioc->events != NULL){
2504 sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
2505 kfree(ioc->events);
2506 ioc->events = NULL;
2507 ioc->alloc_total -= sz;
2508 }
2509
2510 mpt_free_fw_memory(ioc);
2511
2512 kfree(ioc->spi_data.nvram);
2513 mpt_inactive_raid_list_free(ioc);
2514 kfree(ioc->raid_data.pIocPg2);
2515 kfree(ioc->raid_data.pIocPg3);
2516 ioc->spi_data.nvram = NULL;
2517 ioc->raid_data.pIocPg3 = NULL;
2518
2519 if (ioc->spi_data.pIocPg4 != NULL) {
2520 sz = ioc->spi_data.IocPg4Sz;
2521 pci_free_consistent(ioc->pcidev, sz,
2522 ioc->spi_data.pIocPg4,
2523 ioc->spi_data.IocPg4_dma);
2524 ioc->spi_data.pIocPg4 = NULL;
2525 ioc->alloc_total -= sz;
2526 }
2527
2528 if (ioc->ReqToChain != NULL) {
2529 kfree(ioc->ReqToChain);
2530 kfree(ioc->RequestNB);
2531 ioc->ReqToChain = NULL;
2532 }
2533
2534 kfree(ioc->ChainToChain);
2535 ioc->ChainToChain = NULL;
2536
2537 if (ioc->HostPageBuffer != NULL) {
2538 if((ret = mpt_host_page_access_control(ioc,
2539 MPI_DB_HPBAC_FREE_BUFFER, NO_SLEEP)) != 0) {
2540 printk(MYIOC_s_ERR_FMT
2541 "host page buffers free failed (%d)!\n",
2542 ioc->name, ret);
2543 }
2544 dexitprintk(ioc, printk(MYIOC_s_INFO_FMT "HostPageBuffer free @ %p, sz=%d bytes\n",
2545 ioc->name, ioc->HostPageBuffer, ioc->HostPageBuffer_sz));
2546 pci_free_consistent(ioc->pcidev, ioc->HostPageBuffer_sz,
2547 ioc->HostPageBuffer, ioc->HostPageBuffer_dma);
2548 ioc->HostPageBuffer = NULL;
2549 ioc->HostPageBuffer_sz = 0;
2550 ioc->alloc_total -= ioc->HostPageBuffer_sz;
2551 }
2552 }
2553
2554 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2555 /**
2556 * mpt_adapter_dispose - Free all resources associated with an MPT adapter
2557 * @ioc: Pointer to MPT adapter structure
2558 *
2559 * This routine unregisters h/w resources and frees all alloc'd memory
2560 * associated with a MPT adapter structure.
2561 */
2562 static void
2563 mpt_adapter_dispose(MPT_ADAPTER *ioc)
2564 {
2565 int sz_first, sz_last;
2566
2567 if (ioc == NULL)
2568 return;
2569
2570 sz_first = ioc->alloc_total;
2571
2572 mpt_adapter_disable(ioc);
2573
2574 if (ioc->pci_irq != -1) {
2575 free_irq(ioc->pci_irq, ioc);
2576 if (ioc->msi_enable)
2577 pci_disable_msi(ioc->pcidev);
2578 ioc->pci_irq = -1;
2579 }
2580
2581 if (ioc->memmap != NULL) {
2582 iounmap(ioc->memmap);
2583 ioc->memmap = NULL;
2584 }
2585
2586 pci_disable_device(ioc->pcidev);
2587 pci_release_selected_regions(ioc->pcidev, ioc->bars);
2588
2589 #if defined(CONFIG_MTRR) && 0
2590 if (ioc->mtrr_reg > 0) {
2591 mtrr_del(ioc->mtrr_reg, 0, 0);
2592 dprintk(ioc, printk(MYIOC_s_INFO_FMT "MTRR region de-registered\n", ioc->name));
2593 }
2594 #endif
2595
2596 /* Zap the adapter lookup ptr! */
2597 list_del(&ioc->list);
2598
2599 sz_last = ioc->alloc_total;
2600 dprintk(ioc, printk(MYIOC_s_INFO_FMT "free'd %d of %d bytes\n",
2601 ioc->name, sz_first-sz_last+(int)sizeof(*ioc), sz_first));
2602
2603 if (ioc->alt_ioc)
2604 ioc->alt_ioc->alt_ioc = NULL;
2605
2606 kfree(ioc);
2607 }
2608
2609 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2610 /**
2611 * MptDisplayIocCapabilities - Disply IOC's capabilities.
2612 * @ioc: Pointer to MPT adapter structure
2613 */
2614 static void
2615 MptDisplayIocCapabilities(MPT_ADAPTER *ioc)
2616 {
2617 int i = 0;
2618
2619 printk(KERN_INFO "%s: ", ioc->name);
2620 if (ioc->prod_name)
2621 printk("%s: ", ioc->prod_name);
2622 printk("Capabilities={");
2623
2624 if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_INITIATOR) {
2625 printk("Initiator");
2626 i++;
2627 }
2628
2629 if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
2630 printk("%sTarget", i ? "," : "");
2631 i++;
2632 }
2633
2634 if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) {
2635 printk("%sLAN", i ? "," : "");
2636 i++;
2637 }
2638
2639 #if 0
2640 /*
2641 * This would probably evoke more questions than it's worth
2642 */
2643 if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
2644 printk("%sLogBusAddr", i ? "," : "");
2645 i++;
2646 }
2647 #endif
2648
2649 printk("}\n");
2650 }
2651
2652 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2653 /**
2654 * MakeIocReady - Get IOC to a READY state, using KickStart if needed.
2655 * @ioc: Pointer to MPT_ADAPTER structure
2656 * @force: Force hard KickStart of IOC
2657 * @sleepFlag: Specifies whether the process can sleep
2658 *
2659 * Returns:
2660 * 1 - DIAG reset and READY
2661 * 0 - READY initially OR soft reset and READY
2662 * -1 - Any failure on KickStart
2663 * -2 - Msg Unit Reset Failed
2664 * -3 - IO Unit Reset Failed
2665 * -4 - IOC owned by a PEER
2666 */
2667 static int
2668 MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag)
2669 {
2670 u32 ioc_state;
2671 int statefault = 0;
2672 int cntdn;
2673 int hard_reset_done = 0;
2674 int r;
2675 int ii;
2676 int whoinit;
2677
2678 /* Get current [raw] IOC state */
2679 ioc_state = mpt_GetIocState(ioc, 0);
2680 dhsprintk(ioc, printk(MYIOC_s_INFO_FMT "MakeIocReady [raw] state=%08x\n", ioc->name, ioc_state));
2681
2682 /*
2683 * Check to see if IOC got left/stuck in doorbell handshake
2684 * grip of death. If so, hard reset the IOC.
2685 */
2686 if (ioc_state & MPI_DOORBELL_ACTIVE) {
2687 statefault = 1;
2688 printk(MYIOC_s_WARN_FMT "Unexpected doorbell active!\n",
2689 ioc->name);
2690 }
2691
2692 /* Is it already READY? */
2693 if (!statefault && (ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_READY)
2694 return 0;
2695
2696 /*
2697 * Check to see if IOC is in FAULT state.
2698 */
2699 if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
2700 statefault = 2;
2701 printk(MYIOC_s_WARN_FMT "IOC is in FAULT state!!!\n",
2702 ioc->name);
2703 printk(MYIOC_s_WARN_FMT " FAULT code = %04xh\n",
2704 ioc->name, ioc_state & MPI_DOORBELL_DATA_MASK);
2705 }
2706
2707 /*
2708 * Hmmm... Did it get left operational?
2709 */
2710 if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_OPERATIONAL) {
2711 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOC operational unexpected\n",
2712 ioc->name));
2713
2714 /* Check WhoInit.
2715 * If PCI Peer, exit.
2716 * Else, if no fault conditions are present, issue a MessageUnitReset
2717 * Else, fall through to KickStart case
2718 */
2719 whoinit = (ioc_state & MPI_DOORBELL_WHO_INIT_MASK) >> MPI_DOORBELL_WHO_INIT_SHIFT;
2720 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
2721 "whoinit 0x%x statefault %d force %d\n",
2722 ioc->name, whoinit, statefault, force));
2723 if (whoinit == MPI_WHOINIT_PCI_PEER)
2724 return -4;
2725 else {
2726 if ((statefault == 0 ) && (force == 0)) {
2727 if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) == 0)
2728 return 0;
2729 }
2730 statefault = 3;
2731 }
2732 }
2733
2734 hard_reset_done = KickStart(ioc, statefault||force, sleepFlag);
2735 if (hard_reset_done < 0)
2736 return -1;
2737
2738 /*
2739 * Loop here waiting for IOC to come READY.
2740 */
2741 ii = 0;
2742 cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 5; /* 5 seconds */
2743
2744 while ((ioc_state = mpt_GetIocState(ioc, 1)) != MPI_IOC_STATE_READY) {
2745 if (ioc_state == MPI_IOC_STATE_OPERATIONAL) {
2746 /*
2747 * BIOS or previous driver load left IOC in OP state.
2748 * Reset messaging FIFOs.
2749 */
2750 if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) != 0) {
2751 printk(MYIOC_s_ERR_FMT "IOC msg unit reset failed!\n", ioc->name);
2752 return -2;
2753 }
2754 } else if (ioc_state == MPI_IOC_STATE_RESET) {
2755 /*
2756 * Something is wrong. Try to get IOC back
2757 * to a known state.
2758 */
2759 if ((r = SendIocReset(ioc, MPI_FUNCTION_IO_UNIT_RESET, sleepFlag)) != 0) {
2760 printk(MYIOC_s_ERR_FMT "IO unit reset failed!\n", ioc->name);
2761 return -3;
2762 }
2763 }
2764
2765 ii++; cntdn--;
2766 if (!cntdn) {
2767 printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
2768 ioc->name, (int)((ii+5)/HZ));
2769 return -ETIME;
2770 }
2771
2772 if (sleepFlag == CAN_SLEEP) {
2773 msleep(1);
2774 } else {
2775 mdelay (1); /* 1 msec delay */
2776 }
2777
2778 }
2779
2780 if (statefault < 3) {
2781 printk(MYIOC_s_INFO_FMT "Recovered from %s\n",
2782 ioc->name,
2783 statefault==1 ? "stuck handshake" : "IOC FAULT");
2784 }
2785
2786 return hard_reset_done;
2787 }
2788
2789 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2790 /**
2791 * mpt_GetIocState - Get the current state of a MPT adapter.
2792 * @ioc: Pointer to MPT_ADAPTER structure
2793 * @cooked: Request raw or cooked IOC state
2794 *
2795 * Returns all IOC Doorbell register bits if cooked==0, else just the
2796 * Doorbell bits in MPI_IOC_STATE_MASK.
2797 */
2798 u32
2799 mpt_GetIocState(MPT_ADAPTER *ioc, int cooked)
2800 {
2801 u32 s, sc;
2802
2803 /* Get! */
2804 s = CHIPREG_READ32(&ioc->chip->Doorbell);
2805 sc = s & MPI_IOC_STATE_MASK;
2806
2807 /* Save! */
2808 ioc->last_state = sc;
2809
2810 return cooked ? sc : s;
2811 }
2812
2813 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2814 /**
2815 * GetIocFacts - Send IOCFacts request to MPT adapter.
2816 * @ioc: Pointer to MPT_ADAPTER structure
2817 * @sleepFlag: Specifies whether the process can sleep
2818 * @reason: If recovery, only update facts.
2819 *
2820 * Returns 0 for success, non-zero for failure.
2821 */
2822 static int
2823 GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason)
2824 {
2825 IOCFacts_t get_facts;
2826 IOCFactsReply_t *facts;
2827 int r;
2828 int req_sz;
2829 int reply_sz;
2830 int sz;
2831 u32 status, vv;
2832 u8 shiftFactor=1;
2833
2834 /* IOC *must* NOT be in RESET state! */
2835 if (ioc->last_state == MPI_IOC_STATE_RESET) {
2836 printk(MYIOC_s_ERR_FMT "Can't get IOCFacts NOT READY! (%08x)\n",
2837 ioc->name, ioc->last_state );
2838 return -44;
2839 }
2840
2841 facts = &ioc->facts;
2842
2843 /* Destination (reply area)... */
2844 reply_sz = sizeof(*facts);
2845 memset(facts, 0, reply_sz);
2846
2847 /* Request area (get_facts on the stack right now!) */
2848 req_sz = sizeof(get_facts);
2849 memset(&get_facts, 0, req_sz);
2850
2851 get_facts.Function = MPI_FUNCTION_IOC_FACTS;
2852 /* Assert: All other get_facts fields are zero! */
2853
2854 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2855 "Sending get IocFacts request req_sz=%d reply_sz=%d\n",
2856 ioc->name, req_sz, reply_sz));
2857
2858 /* No non-zero fields in the get_facts request are greater than
2859 * 1 byte in size, so we can just fire it off as is.
2860 */
2861 r = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_facts,
2862 reply_sz, (u16*)facts, 5 /*seconds*/, sleepFlag);
2863 if (r != 0)
2864 return r;
2865
2866 /*
2867 * Now byte swap (GRRR) the necessary fields before any further
2868 * inspection of reply contents.
2869 *
2870 * But need to do some sanity checks on MsgLength (byte) field
2871 * to make sure we don't zero IOC's req_sz!
2872 */
2873 /* Did we get a valid reply? */
2874 if (facts->MsgLength > offsetof(IOCFactsReply_t, RequestFrameSize)/sizeof(u32)) {
2875 if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2876 /*
2877 * If not been here, done that, save off first WhoInit value
2878 */
2879 if (ioc->FirstWhoInit == WHOINIT_UNKNOWN)
2880 ioc->FirstWhoInit = facts->WhoInit;
2881 }
2882
2883 facts->MsgVersion = le16_to_cpu(facts->MsgVersion);
2884 facts->MsgContext = le32_to_cpu(facts->MsgContext);
2885 facts->IOCExceptions = le16_to_cpu(facts->IOCExceptions);
2886 facts->IOCStatus = le16_to_cpu(facts->IOCStatus);
2887 facts->IOCLogInfo = le32_to_cpu(facts->IOCLogInfo);
2888 status = le16_to_cpu(facts->IOCStatus) & MPI_IOCSTATUS_MASK;
2889 /* CHECKME! IOCStatus, IOCLogInfo */
2890
2891 facts->ReplyQueueDepth = le16_to_cpu(facts->ReplyQueueDepth);
2892 facts->RequestFrameSize = le16_to_cpu(facts->RequestFrameSize);
2893
2894 /*
2895 * FC f/w version changed between 1.1 and 1.2
2896 * Old: u16{Major(4),Minor(4),SubMinor(8)}
2897 * New: u32{Major(8),Minor(8),Unit(8),Dev(8)}
2898 */
2899 if (facts->MsgVersion < 0x0102) {
2900 /*
2901 * Handle old FC f/w style, convert to new...
2902 */
2903 u16 oldv = le16_to_cpu(facts->Reserved_0101_FWVersion);
2904 facts->FWVersion.Word =
2905 ((oldv<<12) & 0xFF000000) |
2906 ((oldv<<8) & 0x000FFF00);
2907 } else
2908 facts->FWVersion.Word = le32_to_cpu(facts->FWVersion.Word);
2909
2910 facts->ProductID = le16_to_cpu(facts->ProductID);
2911 if ((ioc->facts.ProductID & MPI_FW_HEADER_PID_PROD_MASK)
2912 > MPI_FW_HEADER_PID_PROD_TARGET_SCSI)
2913 ioc->ir_firmware = 1;
2914 facts->CurrentHostMfaHighAddr =
2915 le32_to_cpu(facts->CurrentHostMfaHighAddr);
2916 facts->GlobalCredits = le16_to_cpu(facts->GlobalCredits);
2917 facts->CurrentSenseBufferHighAddr =
2918 le32_to_cpu(facts->CurrentSenseBufferHighAddr);
2919 facts->CurReplyFrameSize =
2920 le16_to_cpu(facts->CurReplyFrameSize);
2921 facts->IOCCapabilities = le32_to_cpu(facts->IOCCapabilities);
2922
2923 /*
2924 * Handle NEW (!) IOCFactsReply fields in MPI-1.01.xx
2925 * Older MPI-1.00.xx struct had 13 dwords, and enlarged
2926 * to 14 in MPI-1.01.0x.
2927 */
2928 if (facts->MsgLength >= (offsetof(IOCFactsReply_t,FWImageSize) + 7)/4 &&
2929 facts->MsgVersion > 0x0100) {
2930 facts->FWImageSize = le32_to_cpu(facts->FWImageSize);
2931 }
2932
2933 sz = facts->FWImageSize;
2934 if ( sz & 0x01 )
2935 sz += 1;
2936 if ( sz & 0x02 )
2937 sz += 2;
2938 facts->FWImageSize = sz;
2939
2940 if (!facts->RequestFrameSize) {
2941 /* Something is wrong! */
2942 printk(MYIOC_s_ERR_FMT "IOC reported invalid 0 request size!\n",
2943 ioc->name);
2944 return -55;
2945 }
2946
2947 r = sz = facts->BlockSize;
2948 vv = ((63 / (sz * 4)) + 1) & 0x03;
2949 ioc->NB_for_64_byte_frame = vv;
2950 while ( sz )
2951 {
2952 shiftFactor++;
2953 sz = sz >> 1;
2954 }
2955 ioc->NBShiftFactor = shiftFactor;
2956 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2957 "NB_for_64_byte_frame=%x NBShiftFactor=%x BlockSize=%x\n",
2958 ioc->name, vv, shiftFactor, r));
2959
2960 if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2961 /*
2962 * Set values for this IOC's request & reply frame sizes,
2963 * and request & reply queue depths...
2964 */
2965 ioc->req_sz = min(MPT_DEFAULT_FRAME_SIZE, facts->RequestFrameSize * 4);
2966 ioc->req_depth = min_t(int, MPT_MAX_REQ_DEPTH, facts->GlobalCredits);
2967 ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
2968 ioc->reply_depth = min_t(int, MPT_DEFAULT_REPLY_DEPTH, facts->ReplyQueueDepth);
2969
2970 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "reply_sz=%3d, reply_depth=%4d\n",
2971 ioc->name, ioc->reply_sz, ioc->reply_depth));
2972 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "req_sz =%3d, req_depth =%4d\n",
2973 ioc->name, ioc->req_sz, ioc->req_depth));
2974
2975 /* Get port facts! */
2976 if ( (r = GetPortFacts(ioc, 0, sleepFlag)) != 0 )
2977 return r;
2978 }
2979 } else {
2980 printk(MYIOC_s_ERR_FMT
2981 "Invalid IOC facts reply, msgLength=%d offsetof=%zd!\n",
2982 ioc->name, facts->MsgLength, (offsetof(IOCFactsReply_t,
2983 RequestFrameSize)/sizeof(u32)));
2984 return -66;
2985 }
2986
2987 return 0;
2988 }
2989
2990 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2991 /**
2992 * GetPortFacts - Send PortFacts request to MPT adapter.
2993 * @ioc: Pointer to MPT_ADAPTER structure
2994 * @portnum: Port number
2995 * @sleepFlag: Specifies whether the process can sleep
2996 *
2997 * Returns 0 for success, non-zero for failure.
2998 */
2999 static int
3000 GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
3001 {
3002 PortFacts_t get_pfacts;
3003 PortFactsReply_t *pfacts;
3004 int ii;
3005 int req_sz;
3006 int reply_sz;
3007 int max_id;
3008
3009 /* IOC *must* NOT be in RESET state! */
3010 if (ioc->last_state == MPI_IOC_STATE_RESET) {
3011 printk(MYIOC_s_ERR_FMT "Can't get PortFacts NOT READY! (%08x)\n",
3012 ioc->name, ioc->last_state );
3013 return -4;
3014 }
3015
3016 pfacts = &ioc->pfacts[portnum];
3017
3018 /* Destination (reply area)... */
3019 reply_sz = sizeof(*pfacts);
3020 memset(pfacts, 0, reply_sz);
3021
3022 /* Request area (get_pfacts on the stack right now!) */
3023 req_sz = sizeof(get_pfacts);
3024 memset(&get_pfacts, 0, req_sz);
3025
3026 get_pfacts.Function = MPI_FUNCTION_PORT_FACTS;
3027 get_pfacts.PortNumber = portnum;
3028 /* Assert: All other get_pfacts fields are zero! */
3029
3030 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending get PortFacts(%d) request\n",
3031 ioc->name, portnum));
3032
3033 /* No non-zero fields in the get_pfacts request are greater than
3034 * 1 byte in size, so we can just fire it off as is.
3035 */
3036 ii = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_pfacts,
3037 reply_sz, (u16*)pfacts, 5 /*seconds*/, sleepFlag);
3038 if (ii != 0)
3039 return ii;
3040
3041 /* Did we get a valid reply? */
3042
3043 /* Now byte swap the necessary fields in the response. */
3044 pfacts->MsgContext = le32_to_cpu(pfacts->MsgContext);
3045 pfacts->IOCStatus = le16_to_cpu(pfacts->IOCStatus);
3046 pfacts->IOCLogInfo = le32_to_cpu(pfacts->IOCLogInfo);
3047 pfacts->MaxDevices = le16_to_cpu(pfacts->MaxDevices);
3048 pfacts->PortSCSIID = le16_to_cpu(pfacts->PortSCSIID);
3049 pfacts->ProtocolFlags = le16_to_cpu(pfacts->ProtocolFlags);
3050 pfacts->MaxPostedCmdBuffers = le16_to_cpu(pfacts->MaxPostedCmdBuffers);
3051 pfacts->MaxPersistentIDs = le16_to_cpu(pfacts->MaxPersistentIDs);
3052 pfacts->MaxLanBuckets = le16_to_cpu(pfacts->MaxLanBuckets);
3053
3054 max_id = (ioc->bus_type == SAS) ? pfacts->PortSCSIID :
3055 pfacts->MaxDevices;
3056 ioc->devices_per_bus = (max_id > 255) ? 256 : max_id;
3057 ioc->number_of_buses = (ioc->devices_per_bus < 256) ? 1 : max_id/256;
3058
3059 /*
3060 * Place all the devices on channels
3061 *
3062 * (for debuging)
3063 */
3064 if (mpt_channel_mapping) {
3065 ioc->devices_per_bus = 1;
3066 ioc->number_of_buses = (max_id > 255) ? 255 : max_id;
3067 }
3068
3069 return 0;
3070 }
3071
3072 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3073 /**
3074 * SendIocInit - Send IOCInit request to MPT adapter.
3075 * @ioc: Pointer to MPT_ADAPTER structure
3076 * @sleepFlag: Specifies whether the process can sleep
3077 *
3078 * Send IOCInit followed by PortEnable to bring IOC to OPERATIONAL state.
3079 *
3080 * Returns 0 for success, non-zero for failure.
3081 */
3082 static int
3083 SendIocInit(MPT_ADAPTER *ioc, int sleepFlag)
3084 {
3085 IOCInit_t ioc_init;
3086 MPIDefaultReply_t init_reply;
3087 u32 state;
3088 int r;
3089 int count;
3090 int cntdn;
3091
3092 memset(&ioc_init, 0, sizeof(ioc_init));
3093 memset(&init_reply, 0, sizeof(init_reply));
3094
3095 ioc_init.WhoInit = MPI_WHOINIT_HOST_DRIVER;
3096 ioc_init.Function = MPI_FUNCTION_IOC_INIT;
3097
3098 /* If we are in a recovery mode and we uploaded the FW image,
3099 * then this pointer is not NULL. Skip the upload a second time.
3100 * Set this flag if cached_fw set for either IOC.
3101 */
3102 if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)
3103 ioc->upload_fw = 1;
3104 else
3105 ioc->upload_fw = 0;
3106 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "upload_fw %d facts.Flags=%x\n",
3107 ioc->name, ioc->upload_fw, ioc->facts.Flags));
3108
3109 ioc_init.MaxDevices = (U8)ioc->devices_per_bus;
3110 ioc_init.MaxBuses = (U8)ioc->number_of_buses;
3111 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "facts.MsgVersion=%x\n",
3112 ioc->name, ioc->facts.MsgVersion));
3113 if (ioc->facts.MsgVersion >= MPI_VERSION_01_05) {
3114 // set MsgVersion and HeaderVersion host driver was built with
3115 ioc_init.MsgVersion = cpu_to_le16(MPI_VERSION);
3116 ioc_init.HeaderVersion = cpu_to_le16(MPI_HEADER_VERSION);
3117
3118 if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_HOST_PAGE_BUFFER_PERSISTENT) {
3119 ioc_init.HostPageBufferSGE = ioc->facts.HostPageBufferSGE;
3120 } else if(mpt_host_page_alloc(ioc, &ioc_init))
3121 return -99;
3122 }
3123 ioc_init.ReplyFrameSize = cpu_to_le16(ioc->reply_sz); /* in BYTES */
3124
3125 if (sizeof(dma_addr_t) == sizeof(u64)) {
3126 /* Save the upper 32-bits of the request
3127 * (reply) and sense buffers.
3128 */
3129 ioc_init.HostMfaHighAddr = cpu_to_le32((u32)((u64)ioc->alloc_dma >> 32));
3130 ioc_init.SenseBufferHighAddr = cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
3131 } else {
3132 /* Force 32-bit addressing */
3133 ioc_init.HostMfaHighAddr = cpu_to_le32(0);
3134 ioc_init.SenseBufferHighAddr = cpu_to_le32(0);
3135 }
3136
3137 ioc->facts.CurrentHostMfaHighAddr = ioc_init.HostMfaHighAddr;
3138 ioc->facts.CurrentSenseBufferHighAddr = ioc_init.SenseBufferHighAddr;
3139 ioc->facts.MaxDevices = ioc_init.MaxDevices;
3140 ioc->facts.MaxBuses = ioc_init.MaxBuses;
3141
3142 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending IOCInit (req @ %p)\n",
3143 ioc->name, &ioc_init));
3144
3145 r = mpt_handshake_req_reply_wait(ioc, sizeof(IOCInit_t), (u32*)&ioc_init,
3146 sizeof(MPIDefaultReply_t), (u16*)&init_reply, 10 /*seconds*/, sleepFlag);
3147 if (r != 0) {
3148 printk(MYIOC_s_ERR_FMT "Sending IOCInit failed(%d)!\n",ioc->name, r);
3149 return r;
3150 }
3151
3152 /* No need to byte swap the multibyte fields in the reply
3153 * since we don't even look at its contents.
3154 */
3155
3156 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending PortEnable (req @ %p)\n",
3157 ioc->name, &ioc_init));
3158
3159 if ((r = SendPortEnable(ioc, 0, sleepFlag)) != 0) {
3160 printk(MYIOC_s_ERR_FMT "Sending PortEnable failed(%d)!\n",ioc->name, r);
3161 return r;
3162 }
3163
3164 /* YIKES! SUPER IMPORTANT!!!
3165 * Poll IocState until _OPERATIONAL while IOC is doing
3166 * LoopInit and TargetDiscovery!
3167 */
3168 count = 0;
3169 cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 60; /* 60 seconds */
3170 state = mpt_GetIocState(ioc, 1);
3171 while (state != MPI_IOC_STATE_OPERATIONAL && --cntdn) {
3172 if (sleepFlag == CAN_SLEEP) {
3173 msleep(1);
3174 } else {
3175 mdelay(1);
3176 }
3177
3178 if (!cntdn) {
3179 printk(MYIOC_s_ERR_FMT "Wait IOC_OP state timeout(%d)!\n",
3180 ioc->name, (int)((count+5)/HZ));
3181 return -9;
3182 }
3183
3184 state = mpt_GetIocState(ioc, 1);
3185 count++;
3186 }
3187 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Wait IOC_OPERATIONAL state (cnt=%d)\n",
3188 ioc->name, count));
3189
3190 ioc->aen_event_read_flag=0;
3191 return r;
3192 }
3193
3194 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3195 /**
3196 * SendPortEnable - Send PortEnable request to MPT adapter port.
3197 * @ioc: Pointer to MPT_ADAPTER structure
3198 * @portnum: Port number to enable
3199 * @sleepFlag: Specifies whether the process can sleep
3200 *
3201 * Send PortEnable to bring IOC to OPERATIONAL state.
3202 *
3203 * Returns 0 for success, non-zero for failure.
3204 */
3205 static int
3206 SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
3207 {
3208 PortEnable_t port_enable;
3209 MPIDefaultReply_t reply_buf;
3210 int rc;
3211 int req_sz;
3212 int reply_sz;
3213
3214 /* Destination... */
3215 reply_sz = sizeof(MPIDefaultReply_t);
3216 memset(&reply_buf, 0, reply_sz);
3217
3218 req_sz = sizeof(PortEnable_t);
3219 memset(&port_enable, 0, req_sz);
3220
3221 port_enable.Function = MPI_FUNCTION_PORT_ENABLE;
3222 port_enable.PortNumber = portnum;
3223 /* port_enable.ChainOffset = 0; */
3224 /* port_enable.MsgFlags = 0; */
3225 /* port_enable.MsgContext = 0; */
3226
3227 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Port(%d)Enable (req @ %p)\n",
3228 ioc->name, portnum, &port_enable));
3229
3230 /* RAID FW may take a long time to enable
3231 */
3232 if (ioc->ir_firmware || ioc->bus_type == SAS) {
3233 rc = mpt_handshake_req_reply_wait(ioc, req_sz,
3234 (u32*)&port_enable, reply_sz, (u16*)&reply_buf,
3235 300 /*seconds*/, sleepFlag);
3236 } else {
3237 rc = mpt_handshake_req_reply_wait(ioc, req_sz,
3238 (u32*)&port_enable, reply_sz, (u16*)&reply_buf,
3239 30 /*seconds*/, sleepFlag);
3240 }
3241 return rc;
3242 }
3243
3244 /**
3245 * mpt_alloc_fw_memory - allocate firmware memory
3246 * @ioc: Pointer to MPT_ADAPTER structure
3247 * @size: total FW bytes
3248 *
3249 * If memory has already been allocated, the same (cached) value
3250 * is returned.
3251 *
3252 * Return 0 if successfull, or non-zero for failure
3253 **/
3254 int
3255 mpt_alloc_fw_memory(MPT_ADAPTER *ioc, int size)
3256 {
3257 int rc;
3258
3259 if (ioc->cached_fw) {
3260 rc = 0; /* use already allocated memory */
3261 goto out;
3262 }
3263 else if (ioc->alt_ioc && ioc->alt_ioc->cached_fw) {
3264 ioc->cached_fw = ioc->alt_ioc->cached_fw; /* use alt_ioc's memory */
3265 ioc->cached_fw_dma = ioc->alt_ioc->cached_fw_dma;
3266 rc = 0;
3267 goto out;
3268 }
3269 ioc->cached_fw = pci_alloc_consistent(ioc->pcidev, size, &ioc->cached_fw_dma);
3270 if (!ioc->cached_fw) {
3271 printk(MYIOC_s_ERR_FMT "Unable to allocate memory for the cached firmware image!\n",
3272 ioc->name);
3273 rc = -1;
3274 } else {
3275 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "FW Image @ %p[%p], sz=%d[%x] bytes\n",
3276 ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, size, size));
3277 ioc->alloc_total += size;
3278 rc = 0;
3279 }
3280 out:
3281 return rc;
3282 }
3283
3284 /**
3285 * mpt_free_fw_memory - free firmware memory
3286 * @ioc: Pointer to MPT_ADAPTER structure
3287 *
3288 * If alt_img is NULL, delete from ioc structure.
3289 * Else, delete a secondary image in same format.
3290 **/
3291 void
3292 mpt_free_fw_memory(MPT_ADAPTER *ioc)
3293 {
3294 int sz;
3295
3296 if (!ioc->cached_fw)
3297 return;
3298
3299 sz = ioc->facts.FWImageSize;
3300 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "free_fw_memory: FW Image @ %p[%p], sz=%d[%x] bytes\n",
3301 ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
3302 pci_free_consistent(ioc->pcidev, sz, ioc->cached_fw, ioc->cached_fw_dma);
3303 ioc->alloc_total -= sz;
3304 ioc->cached_fw = NULL;
3305 }
3306
3307 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3308 /**
3309 * mpt_do_upload - Construct and Send FWUpload request to MPT adapter port.
3310 * @ioc: Pointer to MPT_ADAPTER structure
3311 * @sleepFlag: Specifies whether the process can sleep
3312 *
3313 * Returns 0 for success, >0 for handshake failure
3314 * <0 for fw upload failure.
3315 *
3316 * Remark: If bound IOC and a successful FWUpload was performed
3317 * on the bound IOC, the second image is discarded
3318 * and memory is free'd. Both channels must upload to prevent
3319 * IOC from running in degraded mode.
3320 */
3321 static int
3322 mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag)
3323 {
3324 u8 reply[sizeof(FWUploadReply_t)];
3325 FWUpload_t *prequest;
3326 FWUploadReply_t *preply;
3327 FWUploadTCSGE_t *ptcsge;
3328 int sgeoffset;
3329 u32 flagsLength;
3330 int ii, sz, reply_sz;
3331 int cmdStatus;
3332
3333 /* If the image size is 0, we are done.
3334 */
3335 if ((sz = ioc->facts.FWImageSize) == 0)
3336 return 0;
3337
3338 if (mpt_alloc_fw_memory(ioc, ioc->facts.FWImageSize) != 0)
3339 return -ENOMEM;
3340
3341 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": FW Image @ %p[%p], sz=%d[%x] bytes\n",
3342 ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
3343
3344 prequest = (sleepFlag == NO_SLEEP) ? kzalloc(ioc->req_sz, GFP_ATOMIC) :
3345 kzalloc(ioc->req_sz, GFP_KERNEL);
3346 if (!prequest) {
3347 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "fw upload failed "
3348 "while allocating memory \n", ioc->name));
3349 mpt_free_fw_memory(ioc);
3350 return -ENOMEM;
3351 }
3352
3353 preply = (FWUploadReply_t *)&reply;
3354
3355 reply_sz = sizeof(reply);
3356 memset(preply, 0, reply_sz);
3357
3358 prequest->ImageType = MPI_FW_UPLOAD_ITYPE_FW_IOC_MEM;
3359 prequest->Function = MPI_FUNCTION_FW_UPLOAD;
3360
3361 ptcsge = (FWUploadTCSGE_t *) &prequest->SGL;
3362 ptcsge->DetailsLength = 12;
3363 ptcsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
3364 ptcsge->ImageSize = cpu_to_le32(sz);
3365 ptcsge++;
3366
3367 sgeoffset = sizeof(FWUpload_t) - sizeof(SGE_MPI_UNION) + sizeof(FWUploadTCSGE_t);
3368
3369 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ | sz;
3370 mpt_add_sge((char *)ptcsge, flagsLength, ioc->cached_fw_dma);
3371
3372 sgeoffset += sizeof(u32) + sizeof(dma_addr_t);
3373 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": Sending FW Upload (req @ %p) sgeoffset=%d \n",
3374 ioc->name, prequest, sgeoffset));
3375 DBG_DUMP_FW_REQUEST_FRAME(ioc, (u32 *)prequest);
3376
3377 ii = mpt_handshake_req_reply_wait(ioc, sgeoffset, (u32*)prequest,
3378 reply_sz, (u16*)preply, 65 /*seconds*/, sleepFlag);
3379
3380 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": FW Upload completed rc=%x \n", ioc->name, ii));
3381
3382 cmdStatus = -EFAULT;
3383 if (ii == 0) {
3384 /* Handshake transfer was complete and successful.
3385 * Check the Reply Frame.
3386 */
3387 int status, transfer_sz;
3388 status = le16_to_cpu(preply->IOCStatus);
3389 if (status == MPI_IOCSTATUS_SUCCESS) {
3390 transfer_sz = le32_to_cpu(preply->ActualImageSize);
3391 if (transfer_sz == sz)
3392 cmdStatus = 0;
3393 }
3394 }
3395 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": do_upload cmdStatus=%d \n",
3396 ioc->name, cmdStatus));
3397
3398
3399 if (cmdStatus) {
3400
3401 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": fw upload failed, freeing image \n",
3402 ioc->name));
3403 mpt_free_fw_memory(ioc);
3404 }
3405 kfree(prequest);
3406
3407 return cmdStatus;
3408 }
3409
3410 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3411 /**
3412 * mpt_downloadboot - DownloadBoot code
3413 * @ioc: Pointer to MPT_ADAPTER structure
3414 * @pFwHeader: Pointer to firmware header info
3415 * @sleepFlag: Specifies whether the process can sleep
3416 *
3417 * FwDownloadBoot requires Programmed IO access.
3418 *
3419 * Returns 0 for success
3420 * -1 FW Image size is 0
3421 * -2 No valid cached_fw Pointer
3422 * <0 for fw upload failure.
3423 */
3424 static int
3425 mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag)
3426 {
3427 MpiExtImageHeader_t *pExtImage;
3428 u32 fwSize;
3429 u32 diag0val;
3430 int count;
3431 u32 *ptrFw;
3432 u32 diagRwData;
3433 u32 nextImage;
3434 u32 load_addr;
3435 u32 ioc_state=0;
3436
3437 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot: fw size 0x%x (%d), FW Ptr %p\n",
3438 ioc->name, pFwHeader->ImageSize, pFwHeader->ImageSize, pFwHeader));
3439
3440 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3441 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
3442 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
3443 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
3444 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
3445 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3446
3447 CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM));
3448
3449 /* wait 1 msec */
3450 if (sleepFlag == CAN_SLEEP) {
3451 msleep(1);
3452 } else {
3453 mdelay (1);
3454 }
3455
3456 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3457 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
3458
3459 for (count = 0; count < 30; count ++) {
3460 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3461 if (!(diag0val & MPI_DIAG_RESET_ADAPTER)) {
3462 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RESET_ADAPTER cleared, count=%d\n",
3463 ioc->name, count));
3464 break;
3465 }
3466 /* wait .1 sec */
3467 if (sleepFlag == CAN_SLEEP) {
3468 msleep (100);
3469 } else {
3470 mdelay (100);
3471 }
3472 }
3473
3474 if ( count == 30 ) {
3475 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot failed! "
3476 "Unable to get MPI_DIAG_DRWE mode, diag0val=%x\n",
3477 ioc->name, diag0val));
3478 return -3;
3479 }
3480
3481 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3482 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
3483 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
3484 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
3485 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
3486 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3487
3488 /* Set the DiagRwEn and Disable ARM bits */
3489 CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_RW_ENABLE | MPI_DIAG_DISABLE_ARM));
3490
3491 fwSize = (pFwHeader->ImageSize + 3)/4;
3492 ptrFw = (u32 *) pFwHeader;
3493
3494 /* Write the LoadStartAddress to the DiagRw Address Register
3495 * using Programmed IO
3496 */
3497 if (ioc->errata_flag_1064)
3498 pci_enable_io_access(ioc->pcidev);
3499
3500 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->LoadStartAddress);
3501 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "LoadStart addr written 0x%x \n",
3502 ioc->name, pFwHeader->LoadStartAddress));
3503
3504 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write FW Image: 0x%x bytes @ %p\n",
3505 ioc->name, fwSize*4, ptrFw));
3506 while (fwSize--) {
3507 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
3508 }
3509
3510 nextImage = pFwHeader->NextImageHeaderOffset;
3511 while (nextImage) {
3512 pExtImage = (MpiExtImageHeader_t *) ((char *)pFwHeader + nextImage);
3513
3514 load_addr = pExtImage->LoadStartAddress;
3515
3516 fwSize = (pExtImage->ImageSize + 3) >> 2;
3517 ptrFw = (u32 *)pExtImage;
3518
3519 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write Ext Image: 0x%x (%d) bytes @ %p load_addr=%x\n",
3520 ioc->name, fwSize*4, fwSize*4, ptrFw, load_addr));
3521 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, load_addr);
3522
3523 while (fwSize--) {
3524 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
3525 }
3526 nextImage = pExtImage->NextImageHeaderOffset;
3527 }
3528
3529 /* Write the IopResetVectorRegAddr */
3530 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Addr=%x! \n", ioc->name, pFwHeader->IopResetRegAddr));
3531 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->IopResetRegAddr);
3532
3533 /* Write the IopResetVectorValue */
3534 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Value=%x! \n", ioc->name, pFwHeader->IopResetVectorValue));
3535 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, pFwHeader->IopResetVectorValue);
3536
3537 /* Clear the internal flash bad bit - autoincrementing register,
3538 * so must do two writes.
3539 */
3540 if (ioc->bus_type == SPI) {
3541 /*
3542 * 1030 and 1035 H/W errata, workaround to access
3543 * the ClearFlashBadSignatureBit
3544 */
3545 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
3546 diagRwData = CHIPREG_PIO_READ32(&ioc->pio_chip->DiagRwData);
3547 diagRwData |= 0x40000000;
3548 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
3549 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, diagRwData);
3550
3551 } else /* if((ioc->bus_type == SAS) || (ioc->bus_type == FC)) */ {
3552 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3553 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val |
3554 MPI_DIAG_CLEAR_FLASH_BAD_SIG);
3555
3556 /* wait 1 msec */
3557 if (sleepFlag == CAN_SLEEP) {
3558 msleep (1);
3559 } else {
3560 mdelay (1);
3561 }
3562 }
3563
3564 if (ioc->errata_flag_1064)
3565 pci_disable_io_access(ioc->pcidev);
3566
3567 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3568 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot diag0val=%x, "
3569 "turning off PREVENT_IOC_BOOT, DISABLE_ARM, RW_ENABLE\n",
3570 ioc->name, diag0val));
3571 diag0val &= ~(MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM | MPI_DIAG_RW_ENABLE);
3572 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot now diag0val=%x\n",
3573 ioc->name, diag0val));
3574 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
3575
3576 /* Write 0xFF to reset the sequencer */
3577 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3578
3579 if (ioc->bus_type == SAS) {
3580 ioc_state = mpt_GetIocState(ioc, 0);
3581 if ( (GetIocFacts(ioc, sleepFlag,
3582 MPT_HOSTEVENT_IOC_BRINGUP)) != 0 ) {
3583 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "GetIocFacts failed: IocState=%x\n",
3584 ioc->name, ioc_state));
3585 return -EFAULT;
3586 }
3587 }
3588
3589 for (count=0; count<HZ*20; count++) {
3590 if ((ioc_state = mpt_GetIocState(ioc, 0)) & MPI_IOC_STATE_READY) {
3591 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3592 "downloadboot successful! (count=%d) IocState=%x\n",
3593 ioc->name, count, ioc_state));
3594 if (ioc->bus_type == SAS) {
3595 return 0;
3596 }
3597 if ((SendIocInit(ioc, sleepFlag)) != 0) {
3598 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3599 "downloadboot: SendIocInit failed\n",
3600 ioc->name));
3601 return -EFAULT;
3602 }
3603 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3604 "downloadboot: SendIocInit successful\n",
3605 ioc->name));
3606 return 0;
3607 }
3608 if (sleepFlag == CAN_SLEEP) {
3609 msleep (10);
3610 } else {
3611 mdelay (10);
3612 }
3613 }
3614 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3615 "downloadboot failed! IocState=%x\n",ioc->name, ioc_state));
3616 return -EFAULT;
3617 }
3618
3619 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3620 /**
3621 * KickStart - Perform hard reset of MPT adapter.
3622 * @ioc: Pointer to MPT_ADAPTER structure
3623 * @force: Force hard reset
3624 * @sleepFlag: Specifies whether the process can sleep
3625 *
3626 * This routine places MPT adapter in diagnostic mode via the
3627 * WriteSequence register, and then performs a hard reset of adapter
3628 * via the Diagnostic register.
3629 *
3630 * Inputs: sleepflag - CAN_SLEEP (non-interrupt thread)
3631 * or NO_SLEEP (interrupt thread, use mdelay)
3632 * force - 1 if doorbell active, board fault state
3633 * board operational, IOC_RECOVERY or
3634 * IOC_BRINGUP and there is an alt_ioc.
3635 * 0 else
3636 *
3637 * Returns:
3638 * 1 - hard reset, READY
3639 * 0 - no reset due to History bit, READY
3640 * -1 - no reset due to History bit but not READY
3641 * OR reset but failed to come READY
3642 * -2 - no reset, could not enter DIAG mode
3643 * -3 - reset but bad FW bit
3644 */
3645 static int
3646 KickStart(MPT_ADAPTER *ioc, int force, int sleepFlag)
3647 {
3648 int hard_reset_done = 0;
3649 u32 ioc_state=0;
3650 int cnt,cntdn;
3651
3652 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "KickStarting!\n", ioc->name));
3653 if (ioc->bus_type == SPI) {
3654 /* Always issue a Msg Unit Reset first. This will clear some
3655 * SCSI bus hang conditions.
3656 */
3657 SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag);
3658
3659 if (sleepFlag == CAN_SLEEP) {
3660 msleep (1000);
3661 } else {
3662 mdelay (1000);
3663 }
3664 }
3665
3666 hard_reset_done = mpt_diag_reset(ioc, force, sleepFlag);
3667 if (hard_reset_done < 0)
3668 return hard_reset_done;
3669
3670 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Diagnostic reset successful!\n",
3671 ioc->name));
3672
3673 cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 2; /* 2 seconds */
3674 for (cnt=0; cnt<cntdn; cnt++) {
3675 ioc_state = mpt_GetIocState(ioc, 1);
3676 if ((ioc_state == MPI_IOC_STATE_READY) || (ioc_state == MPI_IOC_STATE_OPERATIONAL)) {
3677 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "KickStart successful! (cnt=%d)\n",
3678 ioc->name, cnt));
3679 return hard_reset_done;
3680 }
3681 if (sleepFlag == CAN_SLEEP) {
3682 msleep (10);
3683 } else {
3684 mdelay (10);
3685 }
3686 }
3687
3688 dinitprintk(ioc, printk(MYIOC_s_ERR_FMT "Failed to come READY after reset! IocState=%x\n",
3689 ioc->name, mpt_GetIocState(ioc, 0)));
3690 return -1;
3691 }
3692
3693 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3694 /**
3695 * mpt_diag_reset - Perform hard reset of the adapter.
3696 * @ioc: Pointer to MPT_ADAPTER structure
3697 * @ignore: Set if to honor and clear to ignore
3698 * the reset history bit
3699 * @sleepFlag: CAN_SLEEP if called in a non-interrupt thread,
3700 * else set to NO_SLEEP (use mdelay instead)
3701 *
3702 * This routine places the adapter in diagnostic mode via the
3703 * WriteSequence register and then performs a hard reset of adapter
3704 * via the Diagnostic register. Adapter should be in ready state
3705 * upon successful completion.
3706 *
3707 * Returns: 1 hard reset successful
3708 * 0 no reset performed because reset history bit set
3709 * -2 enabling diagnostic mode failed
3710 * -3 diagnostic reset failed
3711 */
3712 static int
3713 mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag)
3714 {
3715 u32 diag0val;
3716 u32 doorbell;
3717 int hard_reset_done = 0;
3718 int count = 0;
3719 u32 diag1val = 0;
3720 MpiFwHeader_t *cached_fw; /* Pointer to FW */
3721
3722 /* Clear any existing interrupts */
3723 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
3724
3725 if (ioc->pcidev->device == MPI_MANUFACTPAGE_DEVID_SAS1078) {
3726 drsprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: Doorbell=%p; 1078 reset "
3727 "address=%p\n", ioc->name, __func__,
3728 &ioc->chip->Doorbell, &ioc->chip->Reset_1078));
3729 CHIPREG_WRITE32(&ioc->chip->Reset_1078, 0x07);
3730 if (sleepFlag == CAN_SLEEP)
3731 msleep(1);
3732 else
3733 mdelay(1);
3734
3735 for (count = 0; count < 60; count ++) {
3736 doorbell = CHIPREG_READ32(&ioc->chip->Doorbell);
3737 doorbell &= MPI_IOC_STATE_MASK;
3738
3739 drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3740 "looking for READY STATE: doorbell=%x"
3741 " count=%d\n",
3742 ioc->name, doorbell, count));
3743 if (doorbell == MPI_IOC_STATE_READY) {
3744 return 1;
3745 }
3746
3747 /* wait 1 sec */
3748 if (sleepFlag == CAN_SLEEP)
3749 msleep(1000);
3750 else
3751 mdelay(1000);
3752 }
3753 return -1;
3754 }
3755
3756 /* Use "Diagnostic reset" method! (only thing available!) */
3757 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3758
3759 if (ioc->debug_level & MPT_DEBUG) {
3760 if (ioc->alt_ioc)
3761 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3762 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG1: diag0=%08x, diag1=%08x\n",
3763 ioc->name, diag0val, diag1val));
3764 }
3765
3766 /* Do the reset if we are told to ignore the reset history
3767 * or if the reset history is 0
3768 */
3769 if (ignore || !(diag0val & MPI_DIAG_RESET_HISTORY)) {
3770 while ((diag0val & MPI_DIAG_DRWE) == 0) {
3771 /* Write magic sequence to WriteSequence register
3772 * Loop until in diagnostic mode
3773 */
3774 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3775 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
3776 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
3777 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
3778 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
3779 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3780
3781 /* wait 100 msec */
3782 if (sleepFlag == CAN_SLEEP) {
3783 msleep (100);
3784 } else {
3785 mdelay (100);
3786 }
3787
3788 count++;
3789 if (count > 20) {
3790 printk(MYIOC_s_ERR_FMT "Enable Diagnostic mode FAILED! (%02xh)\n",
3791 ioc->name, diag0val);
3792 return -2;
3793
3794 }
3795
3796 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3797
3798 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Wrote magic DiagWriteEn sequence (%x)\n",
3799 ioc->name, diag0val));
3800 }
3801
3802 if (ioc->debug_level & MPT_DEBUG) {
3803 if (ioc->alt_ioc)
3804 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3805 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG2: diag0=%08x, diag1=%08x\n",
3806 ioc->name, diag0val, diag1val));
3807 }
3808 /*
3809 * Disable the ARM (Bug fix)
3810 *
3811 */
3812 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_DISABLE_ARM);
3813 mdelay(1);
3814
3815 /*
3816 * Now hit the reset bit in the Diagnostic register
3817 * (THE BIG HAMMER!) (Clears DRWE bit).
3818 */
3819 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
3820 hard_reset_done = 1;
3821 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Diagnostic reset performed\n",
3822 ioc->name));
3823
3824 /*
3825 * Call each currently registered protocol IOC reset handler
3826 * with pre-reset indication.
3827 * NOTE: If we're doing _IOC_BRINGUP, there can be no
3828 * MptResetHandlers[] registered yet.
3829 */
3830 {
3831 u8 cb_idx;
3832 int r = 0;
3833
3834 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
3835 if (MptResetHandlers[cb_idx]) {
3836 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3837 "Calling IOC pre_reset handler #%d\n",
3838 ioc->name, cb_idx));
3839 r += mpt_signal_reset(cb_idx, ioc, MPT_IOC_PRE_RESET);
3840 if (ioc->alt_ioc) {
3841 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3842 "Calling alt-%s pre_reset handler #%d\n",
3843 ioc->name, ioc->alt_ioc->name, cb_idx));
3844 r += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_PRE_RESET);
3845 }
3846 }
3847 }
3848 /* FIXME? Examine results here? */
3849 }
3850
3851 if (ioc->cached_fw)
3852 cached_fw = (MpiFwHeader_t *)ioc->cached_fw;
3853 else if (ioc->alt_ioc && ioc->alt_ioc->cached_fw)
3854 cached_fw = (MpiFwHeader_t *)ioc->alt_ioc->cached_fw;
3855 else
3856 cached_fw = NULL;
3857 if (cached_fw) {
3858 /* If the DownloadBoot operation fails, the
3859 * IOC will be left unusable. This is a fatal error
3860 * case. _diag_reset will return < 0
3861 */
3862 for (count = 0; count < 30; count ++) {
3863 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3864 if (!(diag0val & MPI_DIAG_RESET_ADAPTER)) {
3865 break;
3866 }
3867
3868 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "cached_fw: diag0val=%x count=%d\n",
3869 ioc->name, diag0val, count));
3870 /* wait 1 sec */
3871 if (sleepFlag == CAN_SLEEP) {
3872 msleep (1000);
3873 } else {
3874 mdelay (1000);
3875 }
3876 }
3877 if ((count = mpt_downloadboot(ioc, cached_fw, sleepFlag)) < 0) {
3878 printk(MYIOC_s_WARN_FMT
3879 "firmware downloadboot failure (%d)!\n", ioc->name, count);
3880 }
3881
3882 } else {
3883 /* Wait for FW to reload and for board
3884 * to go to the READY state.
3885 * Maximum wait is 60 seconds.
3886 * If fail, no error will check again
3887 * with calling program.
3888 */
3889 for (count = 0; count < 60; count ++) {
3890 doorbell = CHIPREG_READ32(&ioc->chip->Doorbell);
3891 doorbell &= MPI_IOC_STATE_MASK;
3892
3893 if (doorbell == MPI_IOC_STATE_READY) {
3894 break;
3895 }
3896
3897 /* wait 1 sec */
3898 if (sleepFlag == CAN_SLEEP) {
3899 msleep (1000);
3900 } else {
3901 mdelay (1000);
3902 }
3903 }
3904 }
3905 }
3906
3907 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3908 if (ioc->debug_level & MPT_DEBUG) {
3909 if (ioc->alt_ioc)
3910 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3911 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG3: diag0=%08x, diag1=%08x\n",
3912 ioc->name, diag0val, diag1val));
3913 }
3914
3915 /* Clear RESET_HISTORY bit! Place board in the
3916 * diagnostic mode to update the diag register.
3917 */
3918 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3919 count = 0;
3920 while ((diag0val & MPI_DIAG_DRWE) == 0) {
3921 /* Write magic sequence to WriteSequence register
3922 * Loop until in diagnostic mode
3923 */
3924 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3925 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
3926 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
3927 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
3928 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
3929 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3930
3931 /* wait 100 msec */
3932 if (sleepFlag == CAN_SLEEP) {
3933 msleep (100);
3934 } else {
3935 mdelay (100);
3936 }
3937
3938 count++;
3939 if (count > 20) {
3940 printk(MYIOC_s_ERR_FMT "Enable Diagnostic mode FAILED! (%02xh)\n",
3941 ioc->name, diag0val);
3942 break;
3943 }
3944 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3945 }
3946 diag0val &= ~MPI_DIAG_RESET_HISTORY;
3947 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
3948 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3949 if (diag0val & MPI_DIAG_RESET_HISTORY) {
3950 printk(MYIOC_s_WARN_FMT "ResetHistory bit failed to clear!\n",
3951 ioc->name);
3952 }
3953
3954 /* Disable Diagnostic Mode
3955 */
3956 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFFFFFFFF);
3957
3958 /* Check FW reload status flags.
3959 */
3960 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3961 if (diag0val & (MPI_DIAG_FLASH_BAD_SIG | MPI_DIAG_RESET_ADAPTER | MPI_DIAG_DISABLE_ARM)) {
3962 printk(MYIOC_s_ERR_FMT "Diagnostic reset FAILED! (%02xh)\n",
3963 ioc->name, diag0val);
3964 return -3;
3965 }
3966
3967 if (ioc->debug_level & MPT_DEBUG) {
3968 if (ioc->alt_ioc)
3969 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3970 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG4: diag0=%08x, diag1=%08x\n",
3971 ioc->name, diag0val, diag1val));
3972 }
3973
3974 /*
3975 * Reset flag that says we've enabled event notification
3976 */
3977 ioc->facts.EventState = 0;
3978
3979 if (ioc->alt_ioc)
3980 ioc->alt_ioc->facts.EventState = 0;
3981
3982 return hard_reset_done;
3983 }
3984
3985 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3986 /**
3987 * SendIocReset - Send IOCReset request to MPT adapter.
3988 * @ioc: Pointer to MPT_ADAPTER structure
3989 * @reset_type: reset type, expected values are
3990 * %MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET or %MPI_FUNCTION_IO_UNIT_RESET
3991 * @sleepFlag: Specifies whether the process can sleep
3992 *
3993 * Send IOCReset request to the MPT adapter.
3994 *
3995 * Returns 0 for success, non-zero for failure.
3996 */
3997 static int
3998 SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag)
3999 {
4000 int r;
4001 u32 state;
4002 int cntdn, count;
4003
4004 drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending IOC reset(0x%02x)!\n",
4005 ioc->name, reset_type));
4006 CHIPREG_WRITE32(&ioc->chip->Doorbell, reset_type<<MPI_DOORBELL_FUNCTION_SHIFT);
4007 if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
4008 return r;
4009
4010 /* FW ACK'd request, wait for READY state
4011 */
4012 count = 0;
4013 cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 15; /* 15 seconds */
4014
4015 while ((state = mpt_GetIocState(ioc, 1)) != MPI_IOC_STATE_READY) {
4016 cntdn--;
4017 count++;
4018 if (!cntdn) {
4019 if (sleepFlag != CAN_SLEEP)
4020 count *= 10;
4021
4022 printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
4023 ioc->name, (int)((count+5)/HZ));
4024 return -ETIME;
4025 }
4026
4027 if (sleepFlag == CAN_SLEEP) {
4028 msleep(1);
4029 } else {
4030 mdelay (1); /* 1 msec delay */
4031 }
4032 }
4033
4034 /* TODO!
4035 * Cleanup all event stuff for this IOC; re-issue EventNotification
4036 * request if needed.
4037 */
4038 if (ioc->facts.Function)
4039 ioc->facts.EventState = 0;
4040
4041 return 0;
4042 }
4043
4044 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4045 /**
4046 * initChainBuffers - Allocate memory for and initialize chain buffers
4047 * @ioc: Pointer to MPT_ADAPTER structure
4048 *
4049 * Allocates memory for and initializes chain buffers,
4050 * chain buffer control arrays and spinlock.
4051 */
4052 static int
4053 initChainBuffers(MPT_ADAPTER *ioc)
4054 {
4055 u8 *mem;
4056 int sz, ii, num_chain;
4057 int scale, num_sge, numSGE;
4058
4059 /* ReqToChain size must equal the req_depth
4060 * index = req_idx
4061 */
4062 if (ioc->ReqToChain == NULL) {
4063 sz = ioc->req_depth * sizeof(int);
4064 mem = kmalloc(sz, GFP_ATOMIC);
4065 if (mem == NULL)
4066 return -1;
4067
4068 ioc->ReqToChain = (int *) mem;
4069 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReqToChain alloc @ %p, sz=%d bytes\n",
4070 ioc->name, mem, sz));
4071 mem = kmalloc(sz, GFP_ATOMIC);
4072 if (mem == NULL)
4073 return -1;
4074
4075 ioc->RequestNB = (int *) mem;
4076 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestNB alloc @ %p, sz=%d bytes\n",
4077 ioc->name, mem, sz));
4078 }
4079 for (ii = 0; ii < ioc->req_depth; ii++) {
4080 ioc->ReqToChain[ii] = MPT_HOST_NO_CHAIN;
4081 }
4082
4083 /* ChainToChain size must equal the total number
4084 * of chain buffers to be allocated.
4085 * index = chain_idx
4086 *
4087 * Calculate the number of chain buffers needed(plus 1) per I/O
4088 * then multiply the maximum number of simultaneous cmds
4089 *
4090 * num_sge = num sge in request frame + last chain buffer
4091 * scale = num sge per chain buffer if no chain element
4092 */
4093 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
4094 if (sizeof(dma_addr_t) == sizeof(u64))
4095 num_sge = scale + (ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
4096 else
4097 num_sge = 1+ scale + (ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
4098
4099 if (sizeof(dma_addr_t) == sizeof(u64)) {
4100 numSGE = (scale - 1) * (ioc->facts.MaxChainDepth-1) + scale +
4101 (ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
4102 } else {
4103 numSGE = 1 + (scale - 1) * (ioc->facts.MaxChainDepth-1) + scale +
4104 (ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
4105 }
4106 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "num_sge=%d numSGE=%d\n",
4107 ioc->name, num_sge, numSGE));
4108
4109 if ( numSGE > MPT_SCSI_SG_DEPTH )
4110 numSGE = MPT_SCSI_SG_DEPTH;
4111
4112 num_chain = 1;
4113 while (numSGE - num_sge > 0) {
4114 num_chain++;
4115 num_sge += (scale - 1);
4116 }
4117 num_chain++;
4118
4119 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Now numSGE=%d num_sge=%d num_chain=%d\n",
4120 ioc->name, numSGE, num_sge, num_chain));
4121
4122 if (ioc->bus_type == SPI)
4123 num_chain *= MPT_SCSI_CAN_QUEUE;
4124 else
4125 num_chain *= MPT_FC_CAN_QUEUE;
4126
4127 ioc->num_chain = num_chain;
4128
4129 sz = num_chain * sizeof(int);
4130 if (ioc->ChainToChain == NULL) {
4131 mem = kmalloc(sz, GFP_ATOMIC);
4132 if (mem == NULL)
4133 return -1;
4134
4135 ioc->ChainToChain = (int *) mem;
4136 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainToChain alloc @ %p, sz=%d bytes\n",
4137 ioc->name, mem, sz));
4138 } else {
4139 mem = (u8 *) ioc->ChainToChain;
4140 }
4141 memset(mem, 0xFF, sz);
4142 return num_chain;
4143 }
4144
4145 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4146 /**
4147 * PrimeIocFifos - Initialize IOC request and reply FIFOs.
4148 * @ioc: Pointer to MPT_ADAPTER structure
4149 *
4150 * This routine allocates memory for the MPT reply and request frame
4151 * pools (if necessary), and primes the IOC reply FIFO with
4152 * reply frames.
4153 *
4154 * Returns 0 for success, non-zero for failure.
4155 */
4156 static int
4157 PrimeIocFifos(MPT_ADAPTER *ioc)
4158 {
4159 MPT_FRAME_HDR *mf;
4160 unsigned long flags;
4161 dma_addr_t alloc_dma;
4162 u8 *mem;
4163 int i, reply_sz, sz, total_size, num_chain;
4164
4165 /* Prime reply FIFO... */
4166
4167 if (ioc->reply_frames == NULL) {
4168 if ( (num_chain = initChainBuffers(ioc)) < 0)
4169 return -1;
4170
4171 total_size = reply_sz = (ioc->reply_sz * ioc->reply_depth);
4172 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffer sz=%d bytes, ReplyDepth=%d\n",
4173 ioc->name, ioc->reply_sz, ioc->reply_depth));
4174 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffer sz=%d[%x] bytes\n",
4175 ioc->name, reply_sz, reply_sz));
4176
4177 sz = (ioc->req_sz * ioc->req_depth);
4178 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestBuffer sz=%d bytes, RequestDepth=%d\n",
4179 ioc->name, ioc->req_sz, ioc->req_depth));
4180 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestBuffer sz=%d[%x] bytes\n",
4181 ioc->name, sz, sz));
4182 total_size += sz;
4183
4184 sz = num_chain * ioc->req_sz; /* chain buffer pool size */
4185 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainBuffer sz=%d bytes, ChainDepth=%d\n",
4186 ioc->name, ioc->req_sz, num_chain));
4187 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainBuffer sz=%d[%x] bytes num_chain=%d\n",
4188 ioc->name, sz, sz, num_chain));
4189
4190 total_size += sz;
4191 mem = pci_alloc_consistent(ioc->pcidev, total_size, &alloc_dma);
4192 if (mem == NULL) {
4193 printk(MYIOC_s_ERR_FMT "Unable to allocate Reply, Request, Chain Buffers!\n",
4194 ioc->name);
4195 goto out_fail;
4196 }
4197
4198 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Total alloc @ %p[%p], sz=%d[%x] bytes\n",
4199 ioc->name, mem, (void *)(ulong)alloc_dma, total_size, total_size));
4200
4201 memset(mem, 0, total_size);
4202 ioc->alloc_total += total_size;
4203 ioc->alloc = mem;
4204 ioc->alloc_dma = alloc_dma;
4205 ioc->alloc_sz = total_size;
4206 ioc->reply_frames = (MPT_FRAME_HDR *) mem;
4207 ioc->reply_frames_low_dma = (u32) (alloc_dma & 0xFFFFFFFF);
4208
4209 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffers @ %p[%p]\n",
4210 ioc->name, ioc->reply_frames, (void *)(ulong)alloc_dma));
4211
4212 alloc_dma += reply_sz;
4213 mem += reply_sz;
4214
4215 /* Request FIFO - WE manage this! */
4216
4217 ioc->req_frames = (MPT_FRAME_HDR *) mem;
4218 ioc->req_frames_dma = alloc_dma;
4219
4220 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestBuffers @ %p[%p]\n",
4221 ioc->name, mem, (void *)(ulong)alloc_dma));
4222
4223 ioc->req_frames_low_dma = (u32) (alloc_dma & 0xFFFFFFFF);
4224
4225 #if defined(CONFIG_MTRR) && 0
4226 /*
4227 * Enable Write Combining MTRR for IOC's memory region.
4228 * (at least as much as we can; "size and base must be
4229 * multiples of 4 kiB"
4230 */
4231 ioc->mtrr_reg = mtrr_add(ioc->req_frames_dma,
4232 sz,
4233 MTRR_TYPE_WRCOMB, 1);
4234 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MTRR region registered (base:size=%08x:%x)\n",
4235 ioc->name, ioc->req_frames_dma, sz));
4236 #endif
4237
4238 for (i = 0; i < ioc->req_depth; i++) {
4239 alloc_dma += ioc->req_sz;
4240 mem += ioc->req_sz;
4241 }
4242
4243 ioc->ChainBuffer = mem;
4244 ioc->ChainBufferDMA = alloc_dma;
4245
4246 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainBuffers @ %p(%p)\n",
4247 ioc->name, ioc->ChainBuffer, (void *)(ulong)ioc->ChainBufferDMA));
4248
4249 /* Initialize the free chain Q.
4250 */
4251
4252 INIT_LIST_HEAD(&ioc->FreeChainQ);
4253
4254 /* Post the chain buffers to the FreeChainQ.
4255 */
4256 mem = (u8 *)ioc->ChainBuffer;
4257 for (i=0; i < num_chain; i++) {
4258 mf = (MPT_FRAME_HDR *) mem;
4259 list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeChainQ);
4260 mem += ioc->req_sz;
4261 }
4262
4263 /* Initialize Request frames linked list
4264 */
4265 alloc_dma = ioc->req_frames_dma;
4266 mem = (u8 *) ioc->req_frames;
4267
4268 spin_lock_irqsave(&ioc->FreeQlock, flags);
4269 INIT_LIST_HEAD(&ioc->FreeQ);
4270 for (i = 0; i < ioc->req_depth; i++) {
4271 mf = (MPT_FRAME_HDR *) mem;
4272
4273 /* Queue REQUESTs *internally*! */
4274 list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeQ);
4275
4276 mem += ioc->req_sz;
4277 }
4278 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
4279
4280 sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
4281 ioc->sense_buf_pool =
4282 pci_alloc_consistent(ioc->pcidev, sz, &ioc->sense_buf_pool_dma);
4283 if (ioc->sense_buf_pool == NULL) {
4284 printk(MYIOC_s_ERR_FMT "Unable to allocate Sense Buffers!\n",
4285 ioc->name);
4286 goto out_fail;
4287 }
4288
4289 ioc->sense_buf_low_dma = (u32) (ioc->sense_buf_pool_dma & 0xFFFFFFFF);
4290 ioc->alloc_total += sz;
4291 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SenseBuffers @ %p[%p]\n",
4292 ioc->name, ioc->sense_buf_pool, (void *)(ulong)ioc->sense_buf_pool_dma));
4293
4294 }
4295
4296 /* Post Reply frames to FIFO
4297 */
4298 alloc_dma = ioc->alloc_dma;
4299 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffers @ %p[%p]\n",
4300 ioc->name, ioc->reply_frames, (void *)(ulong)alloc_dma));
4301
4302 for (i = 0; i < ioc->reply_depth; i++) {
4303 /* Write each address to the IOC! */
4304 CHIPREG_WRITE32(&ioc->chip->ReplyFifo, alloc_dma);
4305 alloc_dma += ioc->reply_sz;
4306 }
4307
4308 return 0;
4309
4310 out_fail:
4311 if (ioc->alloc != NULL) {
4312 sz = ioc->alloc_sz;
4313 pci_free_consistent(ioc->pcidev,
4314 sz,
4315 ioc->alloc, ioc->alloc_dma);
4316 ioc->reply_frames = NULL;
4317 ioc->req_frames = NULL;
4318 ioc->alloc_total -= sz;
4319 }
4320 if (ioc->sense_buf_pool != NULL) {
4321 sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
4322 pci_free_consistent(ioc->pcidev,
4323 sz,
4324 ioc->sense_buf_pool, ioc->sense_buf_pool_dma);
4325 ioc->sense_buf_pool = NULL;
4326 }
4327 return -1;
4328 }
4329
4330 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4331 /**
4332 * mpt_handshake_req_reply_wait - Send MPT request to and receive reply
4333 * from IOC via doorbell handshake method.
4334 * @ioc: Pointer to MPT_ADAPTER structure
4335 * @reqBytes: Size of the request in bytes
4336 * @req: Pointer to MPT request frame
4337 * @replyBytes: Expected size of the reply in bytes
4338 * @u16reply: Pointer to area where reply should be written
4339 * @maxwait: Max wait time for a reply (in seconds)
4340 * @sleepFlag: Specifies whether the process can sleep
4341 *
4342 * NOTES: It is the callers responsibility to byte-swap fields in the
4343 * request which are greater than 1 byte in size. It is also the
4344 * callers responsibility to byte-swap response fields which are
4345 * greater than 1 byte in size.
4346 *
4347 * Returns 0 for success, non-zero for failure.
4348 */
4349 static int
4350 mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes, u32 *req,
4351 int replyBytes, u16 *u16reply, int maxwait, int sleepFlag)
4352 {
4353 MPIDefaultReply_t *mptReply;
4354 int failcnt = 0;
4355 int t;
4356
4357 /*
4358 * Get ready to cache a handshake reply
4359 */
4360 ioc->hs_reply_idx = 0;
4361 mptReply = (MPIDefaultReply_t *) ioc->hs_reply;
4362 mptReply->MsgLength = 0;
4363
4364 /*
4365 * Make sure there are no doorbells (WRITE 0 to IntStatus reg),
4366 * then tell IOC that we want to handshake a request of N words.
4367 * (WRITE u32val to Doorbell reg).
4368 */
4369 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4370 CHIPREG_WRITE32(&ioc->chip->Doorbell,
4371 ((MPI_FUNCTION_HANDSHAKE<<MPI_DOORBELL_FUNCTION_SHIFT) |
4372 ((reqBytes/4)<<MPI_DOORBELL_ADD_DWORDS_SHIFT)));
4373
4374 /*
4375 * Wait for IOC's doorbell handshake int
4376 */
4377 if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
4378 failcnt++;
4379
4380 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HandShake request start reqBytes=%d, WaitCnt=%d%s\n",
4381 ioc->name, reqBytes, t, failcnt ? " - MISSING DOORBELL HANDSHAKE!" : ""));
4382
4383 /* Read doorbell and check for active bit */
4384 if (!(CHIPREG_READ32(&ioc->chip->Doorbell) & MPI_DOORBELL_ACTIVE))
4385 return -1;
4386
4387 /*
4388 * Clear doorbell int (WRITE 0 to IntStatus reg),
4389 * then wait for IOC to ACKnowledge that it's ready for
4390 * our handshake request.
4391 */
4392 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4393 if (!failcnt && (t = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
4394 failcnt++;
4395
4396 if (!failcnt) {
4397 int ii;
4398 u8 *req_as_bytes = (u8 *) req;
4399
4400 /*
4401 * Stuff request words via doorbell handshake,
4402 * with ACK from IOC for each.
4403 */
4404 for (ii = 0; !failcnt && ii < reqBytes/4; ii++) {
4405 u32 word = ((req_as_bytes[(ii*4) + 0] << 0) |
4406 (req_as_bytes[(ii*4) + 1] << 8) |
4407 (req_as_bytes[(ii*4) + 2] << 16) |
4408 (req_as_bytes[(ii*4) + 3] << 24));
4409
4410 CHIPREG_WRITE32(&ioc->chip->Doorbell, word);
4411 if ((t = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
4412 failcnt++;
4413 }
4414
4415 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handshake request frame (@%p) header\n", ioc->name, req));
4416 DBG_DUMP_REQUEST_FRAME_HDR(ioc, (u32 *)req);
4417
4418 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HandShake request post done, WaitCnt=%d%s\n",
4419 ioc->name, t, failcnt ? " - MISSING DOORBELL ACK!" : ""));
4420
4421 /*
4422 * Wait for completion of doorbell handshake reply from the IOC
4423 */
4424 if (!failcnt && (t = WaitForDoorbellReply(ioc, maxwait, sleepFlag)) < 0)
4425 failcnt++;
4426
4427 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HandShake reply count=%d%s\n",
4428 ioc->name, t, failcnt ? " - MISSING DOORBELL REPLY!" : ""));
4429
4430 /*
4431 * Copy out the cached reply...
4432 */
4433 for (ii=0; ii < min(replyBytes/2,mptReply->MsgLength*2); ii++)
4434 u16reply[ii] = ioc->hs_reply[ii];
4435 } else {
4436 return -99;
4437 }
4438
4439 return -failcnt;
4440 }
4441
4442 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4443 /**
4444 * WaitForDoorbellAck - Wait for IOC doorbell handshake acknowledge
4445 * @ioc: Pointer to MPT_ADAPTER structure
4446 * @howlong: How long to wait (in seconds)
4447 * @sleepFlag: Specifies whether the process can sleep
4448 *
4449 * This routine waits (up to ~2 seconds max) for IOC doorbell
4450 * handshake ACKnowledge, indicated by the IOP_DOORBELL_STATUS
4451 * bit in its IntStatus register being clear.
4452 *
4453 * Returns a negative value on failure, else wait loop count.
4454 */
4455 static int
4456 WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
4457 {
4458 int cntdn;
4459 int count = 0;
4460 u32 intstat=0;
4461
4462 cntdn = 1000 * howlong;
4463
4464 if (sleepFlag == CAN_SLEEP) {
4465 while (--cntdn) {
4466 msleep (1);
4467 intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
4468 if (! (intstat & MPI_HIS_IOP_DOORBELL_STATUS))
4469 break;
4470 count++;
4471 }
4472 } else {
4473 while (--cntdn) {
4474 udelay (1000);
4475 intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
4476 if (! (intstat & MPI_HIS_IOP_DOORBELL_STATUS))
4477 break;
4478 count++;
4479 }
4480 }
4481
4482 if (cntdn) {
4483 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitForDoorbell ACK (count=%d)\n",
4484 ioc->name, count));
4485 return count;
4486 }
4487
4488 printk(MYIOC_s_ERR_FMT "Doorbell ACK timeout (count=%d), IntStatus=%x!\n",
4489 ioc->name, count, intstat);
4490 return -1;
4491 }
4492
4493 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4494 /**
4495 * WaitForDoorbellInt - Wait for IOC to set its doorbell interrupt bit
4496 * @ioc: Pointer to MPT_ADAPTER structure
4497 * @howlong: How long to wait (in seconds)
4498 * @sleepFlag: Specifies whether the process can sleep
4499 *
4500 * This routine waits (up to ~2 seconds max) for IOC doorbell interrupt
4501 * (MPI_HIS_DOORBELL_INTERRUPT) to be set in the IntStatus register.
4502 *
4503 * Returns a negative value on failure, else wait loop count.
4504 */
4505 static int
4506 WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
4507 {
4508 int cntdn;
4509 int count = 0;
4510 u32 intstat=0;
4511
4512 cntdn = 1000 * howlong;
4513 if (sleepFlag == CAN_SLEEP) {
4514 while (--cntdn) {
4515 intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
4516 if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
4517 break;
4518 msleep(1);
4519 count++;
4520 }
4521 } else {
4522 while (--cntdn) {
4523 intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
4524 if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
4525 break;
4526 udelay (1000);
4527 count++;
4528 }
4529 }
4530
4531 if (cntdn) {
4532 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitForDoorbell INT (cnt=%d) howlong=%d\n",
4533 ioc->name, count, howlong));
4534 return count;
4535 }
4536
4537 printk(MYIOC_s_ERR_FMT "Doorbell INT timeout (count=%d), IntStatus=%x!\n",
4538 ioc->name, count, intstat);
4539 return -1;
4540 }
4541
4542 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4543 /**
4544 * WaitForDoorbellReply - Wait for and capture an IOC handshake reply.
4545 * @ioc: Pointer to MPT_ADAPTER structure
4546 * @howlong: How long to wait (in seconds)
4547 * @sleepFlag: Specifies whether the process can sleep
4548 *
4549 * This routine polls the IOC for a handshake reply, 16 bits at a time.
4550 * Reply is cached to IOC private area large enough to hold a maximum
4551 * of 128 bytes of reply data.
4552 *
4553 * Returns a negative value on failure, else size of reply in WORDS.
4554 */
4555 static int
4556 WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
4557 {
4558 int u16cnt = 0;
4559 int failcnt = 0;
4560 int t;
4561 u16 *hs_reply = ioc->hs_reply;
4562 volatile MPIDefaultReply_t *mptReply = (MPIDefaultReply_t *) ioc->hs_reply;
4563 u16 hword;
4564
4565 hs_reply[0] = hs_reply[1] = hs_reply[7] = 0;
4566
4567 /*
4568 * Get first two u16's so we can look at IOC's intended reply MsgLength
4569 */
4570 u16cnt=0;
4571 if ((t = WaitForDoorbellInt(ioc, howlong, sleepFlag)) < 0) {
4572 failcnt++;
4573 } else {
4574 hs_reply[u16cnt++] = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
4575 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4576 if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
4577 failcnt++;
4578 else {
4579 hs_reply[u16cnt++] = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
4580 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4581 }
4582 }
4583
4584 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitCnt=%d First handshake reply word=%08x%s\n",
4585 ioc->name, t, le32_to_cpu(*(u32 *)hs_reply),
4586 failcnt ? " - MISSING DOORBELL HANDSHAKE!" : ""));
4587
4588 /*
4589 * If no error (and IOC said MsgLength is > 0), piece together
4590 * reply 16 bits at a time.
4591 */
4592 for (u16cnt=2; !failcnt && u16cnt < (2 * mptReply->MsgLength); u16cnt++) {
4593 if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
4594 failcnt++;
4595 hword = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
4596 /* don't overflow our IOC hs_reply[] buffer! */
4597 if (u16cnt < ARRAY_SIZE(ioc->hs_reply))
4598 hs_reply[u16cnt] = hword;
4599 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4600 }
4601
4602 if (!failcnt && (t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
4603 failcnt++;
4604 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4605
4606 if (failcnt) {
4607 printk(MYIOC_s_ERR_FMT "Handshake reply failure!\n",
4608 ioc->name);
4609 return -failcnt;
4610 }
4611 #if 0
4612 else if (u16cnt != (2 * mptReply->MsgLength)) {
4613 return -101;
4614 }
4615 else if ((mptReply->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
4616 return -102;
4617 }
4618 #endif
4619
4620 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Got Handshake reply:\n", ioc->name));
4621 DBG_DUMP_REPLY_FRAME(ioc, (u32 *)mptReply);
4622
4623 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitForDoorbell REPLY WaitCnt=%d (sz=%d)\n",
4624 ioc->name, t, u16cnt/2));
4625 return u16cnt/2;
4626 }
4627
4628 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4629 /**
4630 * GetLanConfigPages - Fetch LANConfig pages.
4631 * @ioc: Pointer to MPT_ADAPTER structure
4632 *
4633 * Return: 0 for success
4634 * -ENOMEM if no memory available
4635 * -EPERM if not allowed due to ISR context
4636 * -EAGAIN if no msg frames currently available
4637 * -EFAULT for non-successful reply or no reply (timeout)
4638 */
4639 static int
4640 GetLanConfigPages(MPT_ADAPTER *ioc)
4641 {
4642 ConfigPageHeader_t hdr;
4643 CONFIGPARMS cfg;
4644 LANPage0_t *ppage0_alloc;
4645 dma_addr_t page0_dma;
4646 LANPage1_t *ppage1_alloc;
4647 dma_addr_t page1_dma;
4648 int rc = 0;
4649 int data_sz;
4650 int copy_sz;
4651
4652 /* Get LAN Page 0 header */
4653 hdr.PageVersion = 0;
4654 hdr.PageLength = 0;
4655 hdr.PageNumber = 0;
4656 hdr.PageType = MPI_CONFIG_PAGETYPE_LAN;
4657 cfg.cfghdr.hdr = &hdr;
4658 cfg.physAddr = -1;
4659 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4660 cfg.dir = 0;
4661 cfg.pageAddr = 0;
4662 cfg.timeout = 0;
4663
4664 if ((rc = mpt_config(ioc, &cfg)) != 0)
4665 return rc;
4666
4667 if (hdr.PageLength > 0) {
4668 data_sz = hdr.PageLength * 4;
4669 ppage0_alloc = (LANPage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page0_dma);
4670 rc = -ENOMEM;
4671 if (ppage0_alloc) {
4672 memset((u8 *)ppage0_alloc, 0, data_sz);
4673 cfg.physAddr = page0_dma;
4674 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4675
4676 if ((rc = mpt_config(ioc, &cfg)) == 0) {
4677 /* save the data */
4678 copy_sz = min_t(int, sizeof(LANPage0_t), data_sz);
4679 memcpy(&ioc->lan_cnfg_page0, ppage0_alloc, copy_sz);
4680
4681 }
4682
4683 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage0_alloc, page0_dma);
4684
4685 /* FIXME!
4686 * Normalize endianness of structure data,
4687 * by byte-swapping all > 1 byte fields!
4688 */
4689
4690 }
4691
4692 if (rc)
4693 return rc;
4694 }
4695
4696 /* Get LAN Page 1 header */
4697 hdr.PageVersion = 0;
4698 hdr.PageLength = 0;
4699 hdr.PageNumber = 1;
4700 hdr.PageType = MPI_CONFIG_PAGETYPE_LAN;
4701 cfg.cfghdr.hdr = &hdr;
4702 cfg.physAddr = -1;
4703 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4704 cfg.dir = 0;
4705 cfg.pageAddr = 0;
4706
4707 if ((rc = mpt_config(ioc, &cfg)) != 0)
4708 return rc;
4709
4710 if (hdr.PageLength == 0)
4711 return 0;
4712
4713 data_sz = hdr.PageLength * 4;
4714 rc = -ENOMEM;
4715 ppage1_alloc = (LANPage1_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page1_dma);
4716 if (ppage1_alloc) {
4717 memset((u8 *)ppage1_alloc, 0, data_sz);
4718 cfg.physAddr = page1_dma;
4719 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4720
4721 if ((rc = mpt_config(ioc, &cfg)) == 0) {
4722 /* save the data */
4723 copy_sz = min_t(int, sizeof(LANPage1_t), data_sz);
4724 memcpy(&ioc->lan_cnfg_page1, ppage1_alloc, copy_sz);
4725 }
4726
4727 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage1_alloc, page1_dma);
4728
4729 /* FIXME!
4730 * Normalize endianness of structure data,
4731 * by byte-swapping all > 1 byte fields!
4732 */
4733
4734 }
4735
4736 return rc;
4737 }
4738
4739 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4740 /**
4741 * mptbase_sas_persist_operation - Perform operation on SAS Persistent Table
4742 * @ioc: Pointer to MPT_ADAPTER structure
4743 * @persist_opcode: see below
4744 *
4745 * MPI_SAS_OP_CLEAR_NOT_PRESENT - Free all persist TargetID mappings for
4746 * devices not currently present.
4747 * MPI_SAS_OP_CLEAR_ALL_PERSISTENT - Clear al persist TargetID mappings
4748 *
4749 * NOTE: Don't use not this function during interrupt time.
4750 *
4751 * Returns 0 for success, non-zero error
4752 */
4753
4754 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4755 int
4756 mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode)
4757 {
4758 SasIoUnitControlRequest_t *sasIoUnitCntrReq;
4759 SasIoUnitControlReply_t *sasIoUnitCntrReply;
4760 MPT_FRAME_HDR *mf = NULL;
4761 MPIHeader_t *mpi_hdr;
4762
4763
4764 /* insure garbage is not sent to fw */
4765 switch(persist_opcode) {
4766
4767 case MPI_SAS_OP_CLEAR_NOT_PRESENT:
4768 case MPI_SAS_OP_CLEAR_ALL_PERSISTENT:
4769 break;
4770
4771 default:
4772 return -1;
4773 break;
4774 }
4775
4776 printk("%s: persist_opcode=%x\n",__func__, persist_opcode);
4777
4778 /* Get a MF for this command.
4779 */
4780 if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
4781 printk("%s: no msg frames!\n",__func__);
4782 return -1;
4783 }
4784
4785 mpi_hdr = (MPIHeader_t *) mf;
4786 sasIoUnitCntrReq = (SasIoUnitControlRequest_t *)mf;
4787 memset(sasIoUnitCntrReq,0,sizeof(SasIoUnitControlRequest_t));
4788 sasIoUnitCntrReq->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
4789 sasIoUnitCntrReq->MsgContext = mpi_hdr->MsgContext;
4790 sasIoUnitCntrReq->Operation = persist_opcode;
4791
4792 init_timer(&ioc->persist_timer);
4793 ioc->persist_timer.data = (unsigned long) ioc;
4794 ioc->persist_timer.function = mpt_timer_expired;
4795 ioc->persist_timer.expires = jiffies + HZ*10 /* 10 sec */;
4796 ioc->persist_wait_done=0;
4797 add_timer(&ioc->persist_timer);
4798 mpt_put_msg_frame(mpt_base_index, ioc, mf);
4799 wait_event(mpt_waitq, ioc->persist_wait_done);
4800
4801 sasIoUnitCntrReply =
4802 (SasIoUnitControlReply_t *)ioc->persist_reply_frame;
4803 if (le16_to_cpu(sasIoUnitCntrReply->IOCStatus) != MPI_IOCSTATUS_SUCCESS) {
4804 printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
4805 __func__,
4806 sasIoUnitCntrReply->IOCStatus,
4807 sasIoUnitCntrReply->IOCLogInfo);
4808 return -1;
4809 }
4810
4811 printk("%s: success\n",__func__);
4812 return 0;
4813 }
4814
4815 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4816
4817 static void
4818 mptbase_raid_process_event_data(MPT_ADAPTER *ioc,
4819 MpiEventDataRaid_t * pRaidEventData)
4820 {
4821 int volume;
4822 int reason;
4823 int disk;
4824 int status;
4825 int flags;
4826 int state;
4827
4828 volume = pRaidEventData->VolumeID;
4829 reason = pRaidEventData->ReasonCode;
4830 disk = pRaidEventData->PhysDiskNum;
4831 status = le32_to_cpu(pRaidEventData->SettingsStatus);
4832 flags = (status >> 0) & 0xff;
4833 state = (status >> 8) & 0xff;
4834
4835 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
4836 return;
4837 }
4838
4839 if ((reason >= MPI_EVENT_RAID_RC_PHYSDISK_CREATED &&
4840 reason <= MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED) ||
4841 (reason == MPI_EVENT_RAID_RC_SMART_DATA)) {
4842 printk(MYIOC_s_INFO_FMT "RAID STATUS CHANGE for PhysDisk %d id=%d\n",
4843 ioc->name, disk, volume);
4844 } else {
4845 printk(MYIOC_s_INFO_FMT "RAID STATUS CHANGE for VolumeID %d\n",
4846 ioc->name, volume);
4847 }
4848
4849 switch(reason) {
4850 case MPI_EVENT_RAID_RC_VOLUME_CREATED:
4851 printk(MYIOC_s_INFO_FMT " volume has been created\n",
4852 ioc->name);
4853 break;
4854
4855 case MPI_EVENT_RAID_RC_VOLUME_DELETED:
4856
4857 printk(MYIOC_s_INFO_FMT " volume has been deleted\n",
4858 ioc->name);
4859 break;
4860
4861 case MPI_EVENT_RAID_RC_VOLUME_SETTINGS_CHANGED:
4862 printk(MYIOC_s_INFO_FMT " volume settings have been changed\n",
4863 ioc->name);
4864 break;
4865
4866 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
4867 printk(MYIOC_s_INFO_FMT " volume is now %s%s%s%s\n",
4868 ioc->name,
4869 state == MPI_RAIDVOL0_STATUS_STATE_OPTIMAL
4870 ? "optimal"
4871 : state == MPI_RAIDVOL0_STATUS_STATE_DEGRADED
4872 ? "degraded"
4873 : state == MPI_RAIDVOL0_STATUS_STATE_FAILED
4874 ? "failed"
4875 : "state unknown",
4876 flags & MPI_RAIDVOL0_STATUS_FLAG_ENABLED
4877 ? ", enabled" : "",
4878 flags & MPI_RAIDVOL0_STATUS_FLAG_QUIESCED
4879 ? ", quiesced" : "",
4880 flags & MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS
4881 ? ", resync in progress" : "" );
4882 break;
4883
4884 case MPI_EVENT_RAID_RC_VOLUME_PHYSDISK_CHANGED:
4885 printk(MYIOC_s_INFO_FMT " volume membership of PhysDisk %d has changed\n",
4886 ioc->name, disk);
4887 break;
4888
4889 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
4890 printk(MYIOC_s_INFO_FMT " PhysDisk has been created\n",
4891 ioc->name);
4892 break;
4893
4894 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
4895 printk(MYIOC_s_INFO_FMT " PhysDisk has been deleted\n",
4896 ioc->name);
4897 break;
4898
4899 case MPI_EVENT_RAID_RC_PHYSDISK_SETTINGS_CHANGED:
4900 printk(MYIOC_s_INFO_FMT " PhysDisk settings have been changed\n",
4901 ioc->name);
4902 break;
4903
4904 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
4905 printk(MYIOC_s_INFO_FMT " PhysDisk is now %s%s%s\n",
4906 ioc->name,
4907 state == MPI_PHYSDISK0_STATUS_ONLINE
4908 ? "online"
4909 : state == MPI_PHYSDISK0_STATUS_MISSING
4910 ? "missing"
4911 : state == MPI_PHYSDISK0_STATUS_NOT_COMPATIBLE
4912 ? "not compatible"
4913 : state == MPI_PHYSDISK0_STATUS_FAILED
4914 ? "failed"
4915 : state == MPI_PHYSDISK0_STATUS_INITIALIZING
4916 ? "initializing"
4917 : state == MPI_PHYSDISK0_STATUS_OFFLINE_REQUESTED
4918 ? "offline requested"
4919 : state == MPI_PHYSDISK0_STATUS_FAILED_REQUESTED
4920 ? "failed requested"
4921 : state == MPI_PHYSDISK0_STATUS_OTHER_OFFLINE
4922 ? "offline"
4923 : "state unknown",
4924 flags & MPI_PHYSDISK0_STATUS_FLAG_OUT_OF_SYNC
4925 ? ", out of sync" : "",
4926 flags & MPI_PHYSDISK0_STATUS_FLAG_QUIESCED
4927 ? ", quiesced" : "" );
4928 break;
4929
4930 case MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED:
4931 printk(MYIOC_s_INFO_FMT " Domain Validation needed for PhysDisk %d\n",
4932 ioc->name, disk);
4933 break;
4934
4935 case MPI_EVENT_RAID_RC_SMART_DATA:
4936 printk(MYIOC_s_INFO_FMT " SMART data received, ASC/ASCQ = %02xh/%02xh\n",
4937 ioc->name, pRaidEventData->ASC, pRaidEventData->ASCQ);
4938 break;
4939
4940 case MPI_EVENT_RAID_RC_REPLACE_ACTION_STARTED:
4941 printk(MYIOC_s_INFO_FMT " replacement of PhysDisk %d has started\n",
4942 ioc->name, disk);
4943 break;
4944 }
4945 }
4946
4947 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4948 /**
4949 * GetIoUnitPage2 - Retrieve BIOS version and boot order information.
4950 * @ioc: Pointer to MPT_ADAPTER structure
4951 *
4952 * Returns: 0 for success
4953 * -ENOMEM if no memory available
4954 * -EPERM if not allowed due to ISR context
4955 * -EAGAIN if no msg frames currently available
4956 * -EFAULT for non-successful reply or no reply (timeout)
4957 */
4958 static int
4959 GetIoUnitPage2(MPT_ADAPTER *ioc)
4960 {
4961 ConfigPageHeader_t hdr;
4962 CONFIGPARMS cfg;
4963 IOUnitPage2_t *ppage_alloc;
4964 dma_addr_t page_dma;
4965 int data_sz;
4966 int rc;
4967
4968 /* Get the page header */
4969 hdr.PageVersion = 0;
4970 hdr.PageLength = 0;
4971 hdr.PageNumber = 2;
4972 hdr.PageType = MPI_CONFIG_PAGETYPE_IO_UNIT;
4973 cfg.cfghdr.hdr = &hdr;
4974 cfg.physAddr = -1;
4975 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4976 cfg.dir = 0;
4977 cfg.pageAddr = 0;
4978 cfg.timeout = 0;
4979
4980 if ((rc = mpt_config(ioc, &cfg)) != 0)
4981 return rc;
4982
4983 if (hdr.PageLength == 0)
4984 return 0;
4985
4986 /* Read the config page */
4987 data_sz = hdr.PageLength * 4;
4988 rc = -ENOMEM;
4989 ppage_alloc = (IOUnitPage2_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
4990 if (ppage_alloc) {
4991 memset((u8 *)ppage_alloc, 0, data_sz);
4992 cfg.physAddr = page_dma;
4993 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4994
4995 /* If Good, save data */
4996 if ((rc = mpt_config(ioc, &cfg)) == 0)
4997 ioc->biosVersion = le32_to_cpu(ppage_alloc->BiosVersion);
4998
4999 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage_alloc, page_dma);
5000 }
5001
5002 return rc;
5003 }
5004
5005 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5006 /**
5007 * mpt_GetScsiPortSettings - read SCSI Port Page 0 and 2
5008 * @ioc: Pointer to a Adapter Strucutre
5009 * @portnum: IOC port number
5010 *
5011 * Return: -EFAULT if read of config page header fails
5012 * or if no nvram
5013 * If read of SCSI Port Page 0 fails,
5014 * NVRAM = MPT_HOST_NVRAM_INVALID (0xFFFFFFFF)
5015 * Adapter settings: async, narrow
5016 * Return 1
5017 * If read of SCSI Port Page 2 fails,
5018 * Adapter settings valid
5019 * NVRAM = MPT_HOST_NVRAM_INVALID (0xFFFFFFFF)
5020 * Return 1
5021 * Else
5022 * Both valid
5023 * Return 0
5024 * CHECK - what type of locking mechanisms should be used????
5025 */
5026 static int
5027 mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum)
5028 {
5029 u8 *pbuf;
5030 dma_addr_t buf_dma;
5031 CONFIGPARMS cfg;
5032 ConfigPageHeader_t header;
5033 int ii;
5034 int data, rc = 0;
5035
5036 /* Allocate memory
5037 */
5038 if (!ioc->spi_data.nvram) {
5039 int sz;
5040 u8 *mem;
5041 sz = MPT_MAX_SCSI_DEVICES * sizeof(int);
5042 mem = kmalloc(sz, GFP_ATOMIC);
5043 if (mem == NULL)
5044 return -EFAULT;
5045
5046 ioc->spi_data.nvram = (int *) mem;
5047
5048 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SCSI device NVRAM settings @ %p, sz=%d\n",
5049 ioc->name, ioc->spi_data.nvram, sz));
5050 }
5051
5052 /* Invalidate NVRAM information
5053 */
5054 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
5055 ioc->spi_data.nvram[ii] = MPT_HOST_NVRAM_INVALID;
5056 }
5057
5058 /* Read SPP0 header, allocate memory, then read page.
5059 */
5060 header.PageVersion = 0;
5061 header.PageLength = 0;
5062 header.PageNumber = 0;
5063 header.PageType = MPI_CONFIG_PAGETYPE_SCSI_PORT;
5064 cfg.cfghdr.hdr = &header;
5065 cfg.physAddr = -1;
5066 cfg.pageAddr = portnum;
5067 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5068 cfg.dir = 0;
5069 cfg.timeout = 0; /* use default */
5070 if (mpt_config(ioc, &cfg) != 0)
5071 return -EFAULT;
5072
5073 if (header.PageLength > 0) {
5074 pbuf = pci_alloc_consistent(ioc->pcidev, header.PageLength * 4, &buf_dma);
5075 if (pbuf) {
5076 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5077 cfg.physAddr = buf_dma;
5078 if (mpt_config(ioc, &cfg) != 0) {
5079 ioc->spi_data.maxBusWidth = MPT_NARROW;
5080 ioc->spi_data.maxSyncOffset = 0;
5081 ioc->spi_data.minSyncFactor = MPT_ASYNC;
5082 ioc->spi_data.busType = MPT_HOST_BUS_UNKNOWN;
5083 rc = 1;
5084 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5085 "Unable to read PortPage0 minSyncFactor=%x\n",
5086 ioc->name, ioc->spi_data.minSyncFactor));
5087 } else {
5088 /* Save the Port Page 0 data
5089 */
5090 SCSIPortPage0_t *pPP0 = (SCSIPortPage0_t *) pbuf;
5091 pPP0->Capabilities = le32_to_cpu(pPP0->Capabilities);
5092 pPP0->PhysicalInterface = le32_to_cpu(pPP0->PhysicalInterface);
5093
5094 if ( (pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_QAS) == 0 ) {
5095 ioc->spi_data.noQas |= MPT_TARGET_NO_NEGO_QAS;
5096 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5097 "noQas due to Capabilities=%x\n",
5098 ioc->name, pPP0->Capabilities));
5099 }
5100 ioc->spi_data.maxBusWidth = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_WIDE ? 1 : 0;
5101 data = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_MAX_SYNC_OFFSET_MASK;
5102 if (data) {
5103 ioc->spi_data.maxSyncOffset = (u8) (data >> 16);
5104 data = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_MIN_SYNC_PERIOD_MASK;
5105 ioc->spi_data.minSyncFactor = (u8) (data >> 8);
5106 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5107 "PortPage0 minSyncFactor=%x\n",
5108 ioc->name, ioc->spi_data.minSyncFactor));
5109 } else {
5110 ioc->spi_data.maxSyncOffset = 0;
5111 ioc->spi_data.minSyncFactor = MPT_ASYNC;
5112 }
5113
5114 ioc->spi_data.busType = pPP0->PhysicalInterface & MPI_SCSIPORTPAGE0_PHY_SIGNAL_TYPE_MASK;
5115
5116 /* Update the minSyncFactor based on bus type.
5117 */
5118 if ((ioc->spi_data.busType == MPI_SCSIPORTPAGE0_PHY_SIGNAL_HVD) ||
5119 (ioc->spi_data.busType == MPI_SCSIPORTPAGE0_PHY_SIGNAL_SE)) {
5120
5121 if (ioc->spi_data.minSyncFactor < MPT_ULTRA) {
5122 ioc->spi_data.minSyncFactor = MPT_ULTRA;
5123 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5124 "HVD or SE detected, minSyncFactor=%x\n",
5125 ioc->name, ioc->spi_data.minSyncFactor));
5126 }
5127 }
5128 }
5129 if (pbuf) {
5130 pci_free_consistent(ioc->pcidev, header.PageLength * 4, pbuf, buf_dma);
5131 }
5132 }
5133 }
5134
5135 /* SCSI Port Page 2 - Read the header then the page.
5136 */
5137 header.PageVersion = 0;
5138 header.PageLength = 0;
5139 header.PageNumber = 2;
5140 header.PageType = MPI_CONFIG_PAGETYPE_SCSI_PORT;
5141 cfg.cfghdr.hdr = &header;
5142 cfg.physAddr = -1;
5143 cfg.pageAddr = portnum;
5144 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5145 cfg.dir = 0;
5146 if (mpt_config(ioc, &cfg) != 0)
5147 return -EFAULT;
5148
5149 if (header.PageLength > 0) {
5150 /* Allocate memory and read SCSI Port Page 2
5151 */
5152 pbuf = pci_alloc_consistent(ioc->pcidev, header.PageLength * 4, &buf_dma);
5153 if (pbuf) {
5154 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_NVRAM;
5155 cfg.physAddr = buf_dma;
5156 if (mpt_config(ioc, &cfg) != 0) {
5157 /* Nvram data is left with INVALID mark
5158 */
5159 rc = 1;
5160 } else if (ioc->pcidev->vendor == PCI_VENDOR_ID_ATTO) {
5161
5162 /* This is an ATTO adapter, read Page2 accordingly
5163 */
5164 ATTO_SCSIPortPage2_t *pPP2 = (ATTO_SCSIPortPage2_t *) pbuf;
5165 ATTODeviceInfo_t *pdevice = NULL;
5166 u16 ATTOFlags;
5167
5168 /* Save the Port Page 2 data
5169 * (reformat into a 32bit quantity)
5170 */
5171 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
5172 pdevice = &pPP2->DeviceSettings[ii];
5173 ATTOFlags = le16_to_cpu(pdevice->ATTOFlags);
5174 data = 0;
5175
5176 /* Translate ATTO device flags to LSI format
5177 */
5178 if (ATTOFlags & ATTOFLAG_DISC)
5179 data |= (MPI_SCSIPORTPAGE2_DEVICE_DISCONNECT_ENABLE);
5180 if (ATTOFlags & ATTOFLAG_ID_ENB)
5181 data |= (MPI_SCSIPORTPAGE2_DEVICE_ID_SCAN_ENABLE);
5182 if (ATTOFlags & ATTOFLAG_LUN_ENB)
5183 data |= (MPI_SCSIPORTPAGE2_DEVICE_LUN_SCAN_ENABLE);
5184 if (ATTOFlags & ATTOFLAG_TAGGED)
5185 data |= (MPI_SCSIPORTPAGE2_DEVICE_TAG_QUEUE_ENABLE);
5186 if (!(ATTOFlags & ATTOFLAG_WIDE_ENB))
5187 data |= (MPI_SCSIPORTPAGE2_DEVICE_WIDE_DISABLE);
5188
5189 data = (data << 16) | (pdevice->Period << 8) | 10;
5190 ioc->spi_data.nvram[ii] = data;
5191 }
5192 } else {
5193 SCSIPortPage2_t *pPP2 = (SCSIPortPage2_t *) pbuf;
5194 MpiDeviceInfo_t *pdevice = NULL;
5195
5196 /*
5197 * Save "Set to Avoid SCSI Bus Resets" flag
5198 */
5199 ioc->spi_data.bus_reset =
5200 (le32_to_cpu(pPP2->PortFlags) &
5201 MPI_SCSIPORTPAGE2_PORT_FLAGS_AVOID_SCSI_RESET) ?
5202 0 : 1 ;
5203
5204 /* Save the Port Page 2 data
5205 * (reformat into a 32bit quantity)
5206 */
5207 data = le32_to_cpu(pPP2->PortFlags) & MPI_SCSIPORTPAGE2_PORT_FLAGS_DV_MASK;
5208 ioc->spi_data.PortFlags = data;
5209 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
5210 pdevice = &pPP2->DeviceSettings[ii];
5211 data = (le16_to_cpu(pdevice->DeviceFlags) << 16) |
5212 (pdevice->SyncFactor << 8) | pdevice->Timeout;
5213 ioc->spi_data.nvram[ii] = data;
5214 }
5215 }
5216
5217 pci_free_consistent(ioc->pcidev, header.PageLength * 4, pbuf, buf_dma);
5218 }
5219 }
5220
5221 /* Update Adapter limits with those from NVRAM
5222 * Comment: Don't need to do this. Target performance
5223 * parameters will never exceed the adapters limits.
5224 */
5225
5226 return rc;
5227 }
5228
5229 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5230 /**
5231 * mpt_readScsiDevicePageHeaders - save version and length of SDP1
5232 * @ioc: Pointer to a Adapter Strucutre
5233 * @portnum: IOC port number
5234 *
5235 * Return: -EFAULT if read of config page header fails
5236 * or 0 if success.
5237 */
5238 static int
5239 mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum)
5240 {
5241 CONFIGPARMS cfg;
5242 ConfigPageHeader_t header;
5243
5244 /* Read the SCSI Device Page 1 header
5245 */
5246 header.PageVersion = 0;
5247 header.PageLength = 0;
5248 header.PageNumber = 1;
5249 header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
5250 cfg.cfghdr.hdr = &header;
5251 cfg.physAddr = -1;
5252 cfg.pageAddr = portnum;
5253 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5254 cfg.dir = 0;
5255 cfg.timeout = 0;
5256 if (mpt_config(ioc, &cfg) != 0)
5257 return -EFAULT;
5258
5259 ioc->spi_data.sdp1version = cfg.cfghdr.hdr->PageVersion;
5260 ioc->spi_data.sdp1length = cfg.cfghdr.hdr->PageLength;
5261
5262 header.PageVersion = 0;
5263 header.PageLength = 0;
5264 header.PageNumber = 0;
5265 header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
5266 if (mpt_config(ioc, &cfg) != 0)
5267 return -EFAULT;
5268
5269 ioc->spi_data.sdp0version = cfg.cfghdr.hdr->PageVersion;
5270 ioc->spi_data.sdp0length = cfg.cfghdr.hdr->PageLength;
5271
5272 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Headers: 0: version %d length %d\n",
5273 ioc->name, ioc->spi_data.sdp0version, ioc->spi_data.sdp0length));
5274
5275 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Headers: 1: version %d length %d\n",
5276 ioc->name, ioc->spi_data.sdp1version, ioc->spi_data.sdp1length));
5277 return 0;
5278 }
5279
5280 /**
5281 * mpt_inactive_raid_list_free - This clears this link list.
5282 * @ioc : pointer to per adapter structure
5283 **/
5284 static void
5285 mpt_inactive_raid_list_free(MPT_ADAPTER *ioc)
5286 {
5287 struct inactive_raid_component_info *component_info, *pNext;
5288
5289 if (list_empty(&ioc->raid_data.inactive_list))
5290 return;
5291
5292 mutex_lock(&ioc->raid_data.inactive_list_mutex);
5293 list_for_each_entry_safe(component_info, pNext,
5294 &ioc->raid_data.inactive_list, list) {
5295 list_del(&component_info->list);
5296 kfree(component_info);
5297 }
5298 mutex_unlock(&ioc->raid_data.inactive_list_mutex);
5299 }
5300
5301 /**
5302 * mpt_inactive_raid_volumes - sets up link list of phy_disk_nums for devices belonging in an inactive volume
5303 *
5304 * @ioc : pointer to per adapter structure
5305 * @channel : volume channel
5306 * @id : volume target id
5307 **/
5308 static void
5309 mpt_inactive_raid_volumes(MPT_ADAPTER *ioc, u8 channel, u8 id)
5310 {
5311 CONFIGPARMS cfg;
5312 ConfigPageHeader_t hdr;
5313 dma_addr_t dma_handle;
5314 pRaidVolumePage0_t buffer = NULL;
5315 int i;
5316 RaidPhysDiskPage0_t phys_disk;
5317 struct inactive_raid_component_info *component_info;
5318 int handle_inactive_volumes;
5319
5320 memset(&cfg, 0 , sizeof(CONFIGPARMS));
5321 memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
5322 hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
5323 cfg.pageAddr = (channel << 8) + id;
5324 cfg.cfghdr.hdr = &hdr;
5325 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5326
5327 if (mpt_config(ioc, &cfg) != 0)
5328 goto out;
5329
5330 if (!hdr.PageLength)
5331 goto out;
5332
5333 buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
5334 &dma_handle);
5335
5336 if (!buffer)
5337 goto out;
5338
5339 cfg.physAddr = dma_handle;
5340 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5341
5342 if (mpt_config(ioc, &cfg) != 0)
5343 goto out;
5344
5345 if (!buffer->NumPhysDisks)
5346 goto out;
5347
5348 handle_inactive_volumes =
5349 (buffer->VolumeStatus.Flags & MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE ||
5350 (buffer->VolumeStatus.Flags & MPI_RAIDVOL0_STATUS_FLAG_ENABLED) == 0 ||
5351 buffer->VolumeStatus.State == MPI_RAIDVOL0_STATUS_STATE_FAILED ||
5352 buffer->VolumeStatus.State == MPI_RAIDVOL0_STATUS_STATE_MISSING) ? 1 : 0;
5353
5354 if (!handle_inactive_volumes)
5355 goto out;
5356
5357 mutex_lock(&ioc->raid_data.inactive_list_mutex);
5358 for (i = 0; i < buffer->NumPhysDisks; i++) {
5359 if(mpt_raid_phys_disk_pg0(ioc,
5360 buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
5361 continue;
5362
5363 if ((component_info = kmalloc(sizeof (*component_info),
5364 GFP_KERNEL)) == NULL)
5365 continue;
5366
5367 component_info->volumeID = id;
5368 component_info->volumeBus = channel;
5369 component_info->d.PhysDiskNum = phys_disk.PhysDiskNum;
5370 component_info->d.PhysDiskBus = phys_disk.PhysDiskBus;
5371 component_info->d.PhysDiskID = phys_disk.PhysDiskID;
5372 component_info->d.PhysDiskIOC = phys_disk.PhysDiskIOC;
5373
5374 list_add_tail(&component_info->list,
5375 &ioc->raid_data.inactive_list);
5376 }
5377 mutex_unlock(&ioc->raid_data.inactive_list_mutex);
5378
5379 out:
5380 if (buffer)
5381 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
5382 dma_handle);
5383 }
5384
5385 /**
5386 * mpt_raid_phys_disk_pg0 - returns phys disk page zero
5387 * @ioc: Pointer to a Adapter Structure
5388 * @phys_disk_num: io unit unique phys disk num generated by the ioc
5389 * @phys_disk: requested payload data returned
5390 *
5391 * Return:
5392 * 0 on success
5393 * -EFAULT if read of config page header fails or data pointer not NULL
5394 * -ENOMEM if pci_alloc failed
5395 **/
5396 int
5397 mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc, u8 phys_disk_num, pRaidPhysDiskPage0_t phys_disk)
5398 {
5399 CONFIGPARMS cfg;
5400 ConfigPageHeader_t hdr;
5401 dma_addr_t dma_handle;
5402 pRaidPhysDiskPage0_t buffer = NULL;
5403 int rc;
5404
5405 memset(&cfg, 0 , sizeof(CONFIGPARMS));
5406 memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
5407
5408 hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
5409 cfg.cfghdr.hdr = &hdr;
5410 cfg.physAddr = -1;
5411 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5412
5413 if (mpt_config(ioc, &cfg) != 0) {
5414 rc = -EFAULT;
5415 goto out;
5416 }
5417
5418 if (!hdr.PageLength) {
5419 rc = -EFAULT;
5420 goto out;
5421 }
5422
5423 buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
5424 &dma_handle);
5425
5426 if (!buffer) {
5427 rc = -ENOMEM;
5428 goto out;
5429 }
5430
5431 cfg.physAddr = dma_handle;
5432 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5433 cfg.pageAddr = phys_disk_num;
5434
5435 if (mpt_config(ioc, &cfg) != 0) {
5436 rc = -EFAULT;
5437 goto out;
5438 }
5439
5440 rc = 0;
5441 memcpy(phys_disk, buffer, sizeof(*buffer));
5442 phys_disk->MaxLBA = le32_to_cpu(buffer->MaxLBA);
5443
5444 out:
5445
5446 if (buffer)
5447 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
5448 dma_handle);
5449
5450 return rc;
5451 }
5452
5453 /**
5454 * mpt_findImVolumes - Identify IDs of hidden disks and RAID Volumes
5455 * @ioc: Pointer to a Adapter Strucutre
5456 *
5457 * Return:
5458 * 0 on success
5459 * -EFAULT if read of config page header fails or data pointer not NULL
5460 * -ENOMEM if pci_alloc failed
5461 **/
5462 int
5463 mpt_findImVolumes(MPT_ADAPTER *ioc)
5464 {
5465 IOCPage2_t *pIoc2;
5466 u8 *mem;
5467 dma_addr_t ioc2_dma;
5468 CONFIGPARMS cfg;
5469 ConfigPageHeader_t header;
5470 int rc = 0;
5471 int iocpage2sz;
5472 int i;
5473
5474 if (!ioc->ir_firmware)
5475 return 0;
5476
5477 /* Free the old page
5478 */
5479 kfree(ioc->raid_data.pIocPg2);
5480 ioc->raid_data.pIocPg2 = NULL;
5481 mpt_inactive_raid_list_free(ioc);
5482
5483 /* Read IOCP2 header then the page.
5484 */
5485 header.PageVersion = 0;
5486 header.PageLength = 0;
5487 header.PageNumber = 2;
5488 header.PageType = MPI_CONFIG_PAGETYPE_IOC;
5489 cfg.cfghdr.hdr = &header;
5490 cfg.physAddr = -1;
5491 cfg.pageAddr = 0;
5492 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5493 cfg.dir = 0;
5494 cfg.timeout = 0;
5495 if (mpt_config(ioc, &cfg) != 0)
5496 return -EFAULT;
5497
5498 if (header.PageLength == 0)
5499 return -EFAULT;
5500
5501 iocpage2sz = header.PageLength * 4;
5502 pIoc2 = pci_alloc_consistent(ioc->pcidev, iocpage2sz, &ioc2_dma);
5503 if (!pIoc2)
5504 return -ENOMEM;
5505
5506 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5507 cfg.physAddr = ioc2_dma;
5508 if (mpt_config(ioc, &cfg) != 0)
5509 goto out;
5510
5511 mem = kmalloc(iocpage2sz, GFP_KERNEL);
5512 if (!mem)
5513 goto out;
5514
5515 memcpy(mem, (u8 *)pIoc2, iocpage2sz);
5516 ioc->raid_data.pIocPg2 = (IOCPage2_t *) mem;
5517
5518 mpt_read_ioc_pg_3(ioc);
5519
5520 for (i = 0; i < pIoc2->NumActiveVolumes ; i++)
5521 mpt_inactive_raid_volumes(ioc,
5522 pIoc2->RaidVolume[i].VolumeBus,
5523 pIoc2->RaidVolume[i].VolumeID);
5524
5525 out:
5526 pci_free_consistent(ioc->pcidev, iocpage2sz, pIoc2, ioc2_dma);
5527
5528 return rc;
5529 }
5530
5531 static int
5532 mpt_read_ioc_pg_3(MPT_ADAPTER *ioc)
5533 {
5534 IOCPage3_t *pIoc3;
5535 u8 *mem;
5536 CONFIGPARMS cfg;
5537 ConfigPageHeader_t header;
5538 dma_addr_t ioc3_dma;
5539 int iocpage3sz = 0;
5540
5541 /* Free the old page
5542 */
5543 kfree(ioc->raid_data.pIocPg3);
5544 ioc->raid_data.pIocPg3 = NULL;
5545
5546 /* There is at least one physical disk.
5547 * Read and save IOC Page 3
5548 */
5549 header.PageVersion = 0;
5550 header.PageLength = 0;
5551 header.PageNumber = 3;
5552 header.PageType = MPI_CONFIG_PAGETYPE_IOC;
5553 cfg.cfghdr.hdr = &header;
5554 cfg.physAddr = -1;
5555 cfg.pageAddr = 0;
5556 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5557 cfg.dir = 0;
5558 cfg.timeout = 0;
5559 if (mpt_config(ioc, &cfg) != 0)
5560 return 0;
5561
5562 if (header.PageLength == 0)
5563 return 0;
5564
5565 /* Read Header good, alloc memory
5566 */
5567 iocpage3sz = header.PageLength * 4;
5568 pIoc3 = pci_alloc_consistent(ioc->pcidev, iocpage3sz, &ioc3_dma);
5569 if (!pIoc3)
5570 return 0;
5571
5572 /* Read the Page and save the data
5573 * into malloc'd memory.
5574 */
5575 cfg.physAddr = ioc3_dma;
5576 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5577 if (mpt_config(ioc, &cfg) == 0) {
5578 mem = kmalloc(iocpage3sz, GFP_KERNEL);
5579 if (mem) {
5580 memcpy(mem, (u8 *)pIoc3, iocpage3sz);
5581 ioc->raid_data.pIocPg3 = (IOCPage3_t *) mem;
5582 }
5583 }
5584
5585 pci_free_consistent(ioc->pcidev, iocpage3sz, pIoc3, ioc3_dma);
5586
5587 return 0;
5588 }
5589
5590 static void
5591 mpt_read_ioc_pg_4(MPT_ADAPTER *ioc)
5592 {
5593 IOCPage4_t *pIoc4;
5594 CONFIGPARMS cfg;
5595 ConfigPageHeader_t header;
5596 dma_addr_t ioc4_dma;
5597 int iocpage4sz;
5598
5599 /* Read and save IOC Page 4
5600 */
5601 header.PageVersion = 0;
5602 header.PageLength = 0;
5603 header.PageNumber = 4;
5604 header.PageType = MPI_CONFIG_PAGETYPE_IOC;
5605 cfg.cfghdr.hdr = &header;
5606 cfg.physAddr = -1;
5607 cfg.pageAddr = 0;
5608 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5609 cfg.dir = 0;
5610 cfg.timeout = 0;
5611 if (mpt_config(ioc, &cfg) != 0)
5612 return;
5613
5614 if (header.PageLength == 0)
5615 return;
5616
5617 if ( (pIoc4 = ioc->spi_data.pIocPg4) == NULL ) {
5618 iocpage4sz = (header.PageLength + 4) * 4; /* Allow 4 additional SEP's */
5619 pIoc4 = pci_alloc_consistent(ioc->pcidev, iocpage4sz, &ioc4_dma);
5620 if (!pIoc4)
5621 return;
5622 ioc->alloc_total += iocpage4sz;
5623 } else {
5624 ioc4_dma = ioc->spi_data.IocPg4_dma;
5625 iocpage4sz = ioc->spi_data.IocPg4Sz;
5626 }
5627
5628 /* Read the Page into dma memory.
5629 */
5630 cfg.physAddr = ioc4_dma;
5631 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5632 if (mpt_config(ioc, &cfg) == 0) {
5633 ioc->spi_data.pIocPg4 = (IOCPage4_t *) pIoc4;
5634 ioc->spi_data.IocPg4_dma = ioc4_dma;
5635 ioc->spi_data.IocPg4Sz = iocpage4sz;
5636 } else {
5637 pci_free_consistent(ioc->pcidev, iocpage4sz, pIoc4, ioc4_dma);
5638 ioc->spi_data.pIocPg4 = NULL;
5639 ioc->alloc_total -= iocpage4sz;
5640 }
5641 }
5642
5643 static void
5644 mpt_read_ioc_pg_1(MPT_ADAPTER *ioc)
5645 {
5646 IOCPage1_t *pIoc1;
5647 CONFIGPARMS cfg;
5648 ConfigPageHeader_t header;
5649 dma_addr_t ioc1_dma;
5650 int iocpage1sz = 0;
5651 u32 tmp;
5652
5653 /* Check the Coalescing Timeout in IOC Page 1
5654 */
5655 header.PageVersion = 0;
5656 header.PageLength = 0;
5657 header.PageNumber = 1;
5658 header.PageType = MPI_CONFIG_PAGETYPE_IOC;
5659 cfg.cfghdr.hdr = &header;
5660 cfg.physAddr = -1;
5661 cfg.pageAddr = 0;
5662 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5663 cfg.dir = 0;
5664 cfg.timeout = 0;
5665 if (mpt_config(ioc, &cfg) != 0)
5666 return;
5667
5668 if (header.PageLength == 0)
5669 return;
5670
5671 /* Read Header good, alloc memory
5672 */
5673 iocpage1sz = header.PageLength * 4;
5674 pIoc1 = pci_alloc_consistent(ioc->pcidev, iocpage1sz, &ioc1_dma);
5675 if (!pIoc1)
5676 return;
5677
5678 /* Read the Page and check coalescing timeout
5679 */
5680 cfg.physAddr = ioc1_dma;
5681 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5682 if (mpt_config(ioc, &cfg) == 0) {
5683
5684 tmp = le32_to_cpu(pIoc1->Flags) & MPI_IOCPAGE1_REPLY_COALESCING;
5685 if (tmp == MPI_IOCPAGE1_REPLY_COALESCING) {
5686 tmp = le32_to_cpu(pIoc1->CoalescingTimeout);
5687
5688 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Coalescing Enabled Timeout = %d\n",
5689 ioc->name, tmp));
5690
5691 if (tmp > MPT_COALESCING_TIMEOUT) {
5692 pIoc1->CoalescingTimeout = cpu_to_le32(MPT_COALESCING_TIMEOUT);
5693
5694 /* Write NVRAM and current
5695 */
5696 cfg.dir = 1;
5697 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
5698 if (mpt_config(ioc, &cfg) == 0) {
5699 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Reset Current Coalescing Timeout to = %d\n",
5700 ioc->name, MPT_COALESCING_TIMEOUT));
5701
5702 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM;
5703 if (mpt_config(ioc, &cfg) == 0) {
5704 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5705 "Reset NVRAM Coalescing Timeout to = %d\n",
5706 ioc->name, MPT_COALESCING_TIMEOUT));
5707 } else {
5708 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5709 "Reset NVRAM Coalescing Timeout Failed\n",
5710 ioc->name));
5711 }
5712
5713 } else {
5714 dprintk(ioc, printk(MYIOC_s_WARN_FMT
5715 "Reset of Current Coalescing Timeout Failed!\n",
5716 ioc->name));
5717 }
5718 }
5719
5720 } else {
5721 dprintk(ioc, printk(MYIOC_s_WARN_FMT "Coalescing Disabled\n", ioc->name));
5722 }
5723 }
5724
5725 pci_free_consistent(ioc->pcidev, iocpage1sz, pIoc1, ioc1_dma);
5726
5727 return;
5728 }
5729
5730 static void
5731 mpt_get_manufacturing_pg_0(MPT_ADAPTER *ioc)
5732 {
5733 CONFIGPARMS cfg;
5734 ConfigPageHeader_t hdr;
5735 dma_addr_t buf_dma;
5736 ManufacturingPage0_t *pbuf = NULL;
5737
5738 memset(&cfg, 0 , sizeof(CONFIGPARMS));
5739 memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
5740
5741 hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
5742 cfg.cfghdr.hdr = &hdr;
5743 cfg.physAddr = -1;
5744 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5745 cfg.timeout = 10;
5746
5747 if (mpt_config(ioc, &cfg) != 0)
5748 goto out;
5749
5750 if (!cfg.cfghdr.hdr->PageLength)
5751 goto out;
5752
5753 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5754 pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
5755 if (!pbuf)
5756 goto out;
5757
5758 cfg.physAddr = buf_dma;
5759
5760 if (mpt_config(ioc, &cfg) != 0)
5761 goto out;
5762
5763 memcpy(ioc->board_name, pbuf->BoardName, sizeof(ioc->board_name));
5764 memcpy(ioc->board_assembly, pbuf->BoardAssembly, sizeof(ioc->board_assembly));
5765 memcpy(ioc->board_tracer, pbuf->BoardTracerNumber, sizeof(ioc->board_tracer));
5766
5767 out:
5768
5769 if (pbuf)
5770 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
5771 }
5772
5773 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5774 /**
5775 * SendEventNotification - Send EventNotification (on or off) request to adapter
5776 * @ioc: Pointer to MPT_ADAPTER structure
5777 * @EvSwitch: Event switch flags
5778 */
5779 static int
5780 SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch)
5781 {
5782 EventNotification_t *evnp;
5783
5784 evnp = (EventNotification_t *) mpt_get_msg_frame(mpt_base_index, ioc);
5785 if (evnp == NULL) {
5786 devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "Unable to allocate event request frame!\n",
5787 ioc->name));
5788 return 0;
5789 }
5790 memset(evnp, 0, sizeof(*evnp));
5791
5792 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending EventNotification (%d) request %p\n", ioc->name, EvSwitch, evnp));
5793
5794 evnp->Function = MPI_FUNCTION_EVENT_NOTIFICATION;
5795 evnp->ChainOffset = 0;
5796 evnp->MsgFlags = 0;
5797 evnp->Switch = EvSwitch;
5798
5799 mpt_put_msg_frame(mpt_base_index, ioc, (MPT_FRAME_HDR *)evnp);
5800
5801 return 0;
5802 }
5803
5804 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5805 /**
5806 * SendEventAck - Send EventAck request to MPT adapter.
5807 * @ioc: Pointer to MPT_ADAPTER structure
5808 * @evnp: Pointer to original EventNotification request
5809 */
5810 static int
5811 SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp)
5812 {
5813 EventAck_t *pAck;
5814
5815 if ((pAck = (EventAck_t *) mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
5816 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames!!\n",
5817 ioc->name,__func__));
5818 return -1;
5819 }
5820
5821 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending EventAck\n", ioc->name));
5822
5823 pAck->Function = MPI_FUNCTION_EVENT_ACK;
5824 pAck->ChainOffset = 0;
5825 pAck->Reserved[0] = pAck->Reserved[1] = 0;
5826 pAck->MsgFlags = 0;
5827 pAck->Reserved1[0] = pAck->Reserved1[1] = pAck->Reserved1[2] = 0;
5828 pAck->Event = evnp->Event;
5829 pAck->EventContext = evnp->EventContext;
5830
5831 mpt_put_msg_frame(mpt_base_index, ioc, (MPT_FRAME_HDR *)pAck);
5832
5833 return 0;
5834 }
5835
5836 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5837 /**
5838 * mpt_config - Generic function to issue config message
5839 * @ioc: Pointer to an adapter structure
5840 * @pCfg: Pointer to a configuration structure. Struct contains
5841 * action, page address, direction, physical address
5842 * and pointer to a configuration page header
5843 * Page header is updated.
5844 *
5845 * Returns 0 for success
5846 * -EPERM if not allowed due to ISR context
5847 * -EAGAIN if no msg frames currently available
5848 * -EFAULT for non-successful reply or no reply (timeout)
5849 */
5850 int
5851 mpt_config(MPT_ADAPTER *ioc, CONFIGPARMS *pCfg)
5852 {
5853 Config_t *pReq;
5854 ConfigExtendedPageHeader_t *pExtHdr = NULL;
5855 MPT_FRAME_HDR *mf;
5856 unsigned long flags;
5857 int ii, rc;
5858 int flagsLength;
5859 int in_isr;
5860
5861 /* Prevent calling wait_event() (below), if caller happens
5862 * to be in ISR context, because that is fatal!
5863 */
5864 in_isr = in_interrupt();
5865 if (in_isr) {
5866 dcprintk(ioc, printk(MYIOC_s_WARN_FMT "Config request not allowed in ISR context!\n",
5867 ioc->name));
5868 return -EPERM;
5869 }
5870
5871 /* Get and Populate a free Frame
5872 */
5873 if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
5874 dcprintk(ioc, printk(MYIOC_s_WARN_FMT "mpt_config: no msg frames!\n",
5875 ioc->name));
5876 return -EAGAIN;
5877 }
5878 pReq = (Config_t *)mf;
5879 pReq->Action = pCfg->action;
5880 pReq->Reserved = 0;
5881 pReq->ChainOffset = 0;
5882 pReq->Function = MPI_FUNCTION_CONFIG;
5883
5884 /* Assume page type is not extended and clear "reserved" fields. */
5885 pReq->ExtPageLength = 0;
5886 pReq->ExtPageType = 0;
5887 pReq->MsgFlags = 0;
5888
5889 for (ii=0; ii < 8; ii++)
5890 pReq->Reserved2[ii] = 0;
5891
5892 pReq->Header.PageVersion = pCfg->cfghdr.hdr->PageVersion;
5893 pReq->Header.PageLength = pCfg->cfghdr.hdr->PageLength;
5894 pReq->Header.PageNumber = pCfg->cfghdr.hdr->PageNumber;
5895 pReq->Header.PageType = (pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK);
5896
5897 if ((pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK) == MPI_CONFIG_PAGETYPE_EXTENDED) {
5898 pExtHdr = (ConfigExtendedPageHeader_t *)pCfg->cfghdr.ehdr;
5899 pReq->ExtPageLength = cpu_to_le16(pExtHdr->ExtPageLength);
5900 pReq->ExtPageType = pExtHdr->ExtPageType;
5901 pReq->Header.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
5902
5903 /* Page Length must be treated as a reserved field for the extended header. */
5904 pReq->Header.PageLength = 0;
5905 }
5906
5907 pReq->PageAddress = cpu_to_le32(pCfg->pageAddr);
5908
5909 /* Add a SGE to the config request.
5910 */
5911 if (pCfg->dir)
5912 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
5913 else
5914 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
5915
5916 if ((pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK) == MPI_CONFIG_PAGETYPE_EXTENDED) {
5917 flagsLength |= pExtHdr->ExtPageLength * 4;
5918
5919 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Config request type %d, page %d and action %d\n",
5920 ioc->name, pReq->ExtPageType, pReq->Header.PageNumber, pReq->Action));
5921 }
5922 else {
5923 flagsLength |= pCfg->cfghdr.hdr->PageLength * 4;
5924
5925 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Config request type %d, page %d and action %d\n",
5926 ioc->name, pReq->Header.PageType, pReq->Header.PageNumber, pReq->Action));
5927 }
5928
5929 mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, pCfg->physAddr);
5930
5931 /* Append pCfg pointer to end of mf
5932 */
5933 *((void **) (((u8 *) mf) + (ioc->req_sz - sizeof(void *)))) = (void *) pCfg;
5934
5935 /* Initalize the timer
5936 */
5937 init_timer(&pCfg->timer);
5938 pCfg->timer.data = (unsigned long) ioc;
5939 pCfg->timer.function = mpt_timer_expired;
5940 pCfg->wait_done = 0;
5941
5942 /* Set the timer; ensure 10 second minimum */
5943 if (pCfg->timeout < 10)
5944 pCfg->timer.expires = jiffies + HZ*10;
5945 else
5946 pCfg->timer.expires = jiffies + HZ*pCfg->timeout;
5947
5948 /* Add to end of Q, set timer and then issue this command */
5949 spin_lock_irqsave(&ioc->FreeQlock, flags);
5950 list_add_tail(&pCfg->linkage, &ioc->configQ);
5951 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5952
5953 add_timer(&pCfg->timer);
5954 mpt_put_msg_frame(mpt_base_index, ioc, mf);
5955 wait_event(mpt_waitq, pCfg->wait_done);
5956
5957 /* mf has been freed - do not access */
5958
5959 rc = pCfg->status;
5960
5961 return rc;
5962 }
5963
5964 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5965 /**
5966 * mpt_timer_expired - Callback for timer process.
5967 * Used only internal config functionality.
5968 * @data: Pointer to MPT_SCSI_HOST recast as an unsigned long
5969 */
5970 static void
5971 mpt_timer_expired(unsigned long data)
5972 {
5973 MPT_ADAPTER *ioc = (MPT_ADAPTER *) data;
5974
5975 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_timer_expired! \n", ioc->name));
5976
5977 /* Perform a FW reload */
5978 if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0)
5979 printk(MYIOC_s_WARN_FMT "Firmware Reload FAILED!\n", ioc->name);
5980
5981 /* No more processing.
5982 * Hard reset clean-up will wake up
5983 * process and free all resources.
5984 */
5985 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_timer_expired complete!\n", ioc->name));
5986
5987 return;
5988 }
5989
5990 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5991 /**
5992 * mpt_ioc_reset - Base cleanup for hard reset
5993 * @ioc: Pointer to the adapter structure
5994 * @reset_phase: Indicates pre- or post-reset functionality
5995 *
5996 * Remark: Frees resources with internally generated commands.
5997 */
5998 static int
5999 mpt_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
6000 {
6001 CONFIGPARMS *pCfg;
6002 unsigned long flags;
6003
6004 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
6005 ": IOC %s_reset routed to MPT base driver!\n",
6006 ioc->name, reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
6007 reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
6008
6009 if (reset_phase == MPT_IOC_SETUP_RESET) {
6010 ;
6011 } else if (reset_phase == MPT_IOC_PRE_RESET) {
6012 /* If the internal config Q is not empty -
6013 * delete timer. MF resources will be freed when
6014 * the FIFO's are primed.
6015 */
6016 spin_lock_irqsave(&ioc->FreeQlock, flags);
6017 list_for_each_entry(pCfg, &ioc->configQ, linkage)
6018 del_timer(&pCfg->timer);
6019 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
6020
6021 } else {
6022 CONFIGPARMS *pNext;
6023
6024 /* Search the configQ for internal commands.
6025 * Flush the Q, and wake up all suspended threads.
6026 */
6027 spin_lock_irqsave(&ioc->FreeQlock, flags);
6028 list_for_each_entry_safe(pCfg, pNext, &ioc->configQ, linkage) {
6029 list_del(&pCfg->linkage);
6030
6031 pCfg->status = MPT_CONFIG_ERROR;
6032 pCfg->wait_done = 1;
6033 wake_up(&mpt_waitq);
6034 }
6035 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
6036 }
6037
6038 return 1; /* currently means nothing really */
6039 }
6040
6041
6042 #ifdef CONFIG_PROC_FS /* { */
6043 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6044 /*
6045 * procfs (%MPT_PROCFS_MPTBASEDIR/...) support stuff...
6046 */
6047 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6048 /**
6049 * procmpt_create - Create %MPT_PROCFS_MPTBASEDIR entries.
6050 *
6051 * Returns 0 for success, non-zero for failure.
6052 */
6053 static int
6054 procmpt_create(void)
6055 {
6056 struct proc_dir_entry *ent;
6057
6058 mpt_proc_root_dir = proc_mkdir(MPT_PROCFS_MPTBASEDIR, NULL);
6059 if (mpt_proc_root_dir == NULL)
6060 return -ENOTDIR;
6061
6062 ent = create_proc_entry("summary", S_IFREG|S_IRUGO, mpt_proc_root_dir);
6063 if (ent)
6064 ent->read_proc = procmpt_summary_read;
6065
6066 ent = create_proc_entry("version", S_IFREG|S_IRUGO, mpt_proc_root_dir);
6067 if (ent)
6068 ent->read_proc = procmpt_version_read;
6069
6070 return 0;
6071 }
6072
6073 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6074 /**
6075 * procmpt_destroy - Tear down %MPT_PROCFS_MPTBASEDIR entries.
6076 *
6077 * Returns 0 for success, non-zero for failure.
6078 */
6079 static void
6080 procmpt_destroy(void)
6081 {
6082 remove_proc_entry("version", mpt_proc_root_dir);
6083 remove_proc_entry("summary", mpt_proc_root_dir);
6084 remove_proc_entry(MPT_PROCFS_MPTBASEDIR, NULL);
6085 }
6086
6087 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6088 /**
6089 * procmpt_summary_read - Handle read request of a summary file
6090 * @buf: Pointer to area to write information
6091 * @start: Pointer to start pointer
6092 * @offset: Offset to start writing
6093 * @request: Amount of read data requested
6094 * @eof: Pointer to EOF integer
6095 * @data: Pointer
6096 *
6097 * Handles read request from /proc/mpt/summary or /proc/mpt/iocN/summary.
6098 * Returns number of characters written to process performing the read.
6099 */
6100 static int
6101 procmpt_summary_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
6102 {
6103 MPT_ADAPTER *ioc;
6104 char *out = buf;
6105 int len;
6106
6107 if (data) {
6108 int more = 0;
6109
6110 ioc = data;
6111 mpt_print_ioc_summary(ioc, out, &more, 0, 1);
6112
6113 out += more;
6114 } else {
6115 list_for_each_entry(ioc, &ioc_list, list) {
6116 int more = 0;
6117
6118 mpt_print_ioc_summary(ioc, out, &more, 0, 1);
6119
6120 out += more;
6121 if ((out-buf) >= request)
6122 break;
6123 }
6124 }
6125
6126 len = out - buf;
6127
6128 MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
6129 }
6130
6131 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6132 /**
6133 * procmpt_version_read - Handle read request from /proc/mpt/version.
6134 * @buf: Pointer to area to write information
6135 * @start: Pointer to start pointer
6136 * @offset: Offset to start writing
6137 * @request: Amount of read data requested
6138 * @eof: Pointer to EOF integer
6139 * @data: Pointer
6140 *
6141 * Returns number of characters written to process performing the read.
6142 */
6143 static int
6144 procmpt_version_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
6145 {
6146 u8 cb_idx;
6147 int scsi, fc, sas, lan, ctl, targ, dmp;
6148 char *drvname;
6149 int len;
6150
6151 len = sprintf(buf, "%s-%s\n", "mptlinux", MPT_LINUX_VERSION_COMMON);
6152 len += sprintf(buf+len, " Fusion MPT base driver\n");
6153
6154 scsi = fc = sas = lan = ctl = targ = dmp = 0;
6155 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
6156 drvname = NULL;
6157 if (MptCallbacks[cb_idx]) {
6158 switch (MptDriverClass[cb_idx]) {
6159 case MPTSPI_DRIVER:
6160 if (!scsi++) drvname = "SPI host";
6161 break;
6162 case MPTFC_DRIVER:
6163 if (!fc++) drvname = "FC host";
6164 break;
6165 case MPTSAS_DRIVER:
6166 if (!sas++) drvname = "SAS host";
6167 break;
6168 case MPTLAN_DRIVER:
6169 if (!lan++) drvname = "LAN";
6170 break;
6171 case MPTSTM_DRIVER:
6172 if (!targ++) drvname = "SCSI target";
6173 break;
6174 case MPTCTL_DRIVER:
6175 if (!ctl++) drvname = "ioctl";
6176 break;
6177 }
6178
6179 if (drvname)
6180 len += sprintf(buf+len, " Fusion MPT %s driver\n", drvname);
6181 }
6182 }
6183
6184 MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
6185 }
6186
6187 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6188 /**
6189 * procmpt_iocinfo_read - Handle read request from /proc/mpt/iocN/info.
6190 * @buf: Pointer to area to write information
6191 * @start: Pointer to start pointer
6192 * @offset: Offset to start writing
6193 * @request: Amount of read data requested
6194 * @eof: Pointer to EOF integer
6195 * @data: Pointer
6196 *
6197 * Returns number of characters written to process performing the read.
6198 */
6199 static int
6200 procmpt_iocinfo_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
6201 {
6202 MPT_ADAPTER *ioc = data;
6203 int len;
6204 char expVer[32];
6205 int sz;
6206 int p;
6207
6208 mpt_get_fw_exp_ver(expVer, ioc);
6209
6210 len = sprintf(buf, "%s:", ioc->name);
6211 if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)
6212 len += sprintf(buf+len, " (f/w download boot flag set)");
6213 // if (ioc->facts.IOCExceptions & MPI_IOCFACTS_EXCEPT_CONFIG_CHECKSUM_FAIL)
6214 // len += sprintf(buf+len, " CONFIG_CHECKSUM_FAIL!");
6215
6216 len += sprintf(buf+len, "\n ProductID = 0x%04x (%s)\n",
6217 ioc->facts.ProductID,
6218 ioc->prod_name);
6219 len += sprintf(buf+len, " FWVersion = 0x%08x%s", ioc->facts.FWVersion.Word, expVer);
6220 if (ioc->facts.FWImageSize)
6221 len += sprintf(buf+len, " (fw_size=%d)", ioc->facts.FWImageSize);
6222 len += sprintf(buf+len, "\n MsgVersion = 0x%04x\n", ioc->facts.MsgVersion);
6223 len += sprintf(buf+len, " FirstWhoInit = 0x%02x\n", ioc->FirstWhoInit);
6224 len += sprintf(buf+len, " EventState = 0x%02x\n", ioc->facts.EventState);
6225
6226 len += sprintf(buf+len, " CurrentHostMfaHighAddr = 0x%08x\n",
6227 ioc->facts.CurrentHostMfaHighAddr);
6228 len += sprintf(buf+len, " CurrentSenseBufferHighAddr = 0x%08x\n",
6229 ioc->facts.CurrentSenseBufferHighAddr);
6230
6231 len += sprintf(buf+len, " MaxChainDepth = 0x%02x frames\n", ioc->facts.MaxChainDepth);
6232 len += sprintf(buf+len, " MinBlockSize = 0x%02x bytes\n", 4*ioc->facts.BlockSize);
6233
6234 len += sprintf(buf+len, " RequestFrames @ 0x%p (Dma @ 0x%p)\n",
6235 (void *)ioc->req_frames, (void *)(ulong)ioc->req_frames_dma);
6236 /*
6237 * Rounding UP to nearest 4-kB boundary here...
6238 */
6239 sz = (ioc->req_sz * ioc->req_depth) + 128;
6240 sz = ((sz + 0x1000UL - 1UL) / 0x1000) * 0x1000;
6241 len += sprintf(buf+len, " {CurReqSz=%d} x {CurReqDepth=%d} = %d bytes ^= 0x%x\n",
6242 ioc->req_sz, ioc->req_depth, ioc->req_sz*ioc->req_depth, sz);
6243 len += sprintf(buf+len, " {MaxReqSz=%d} {MaxReqDepth=%d}\n",
6244 4*ioc->facts.RequestFrameSize,
6245 ioc->facts.GlobalCredits);
6246
6247 len += sprintf(buf+len, " Frames @ 0x%p (Dma @ 0x%p)\n",
6248 (void *)ioc->alloc, (void *)(ulong)ioc->alloc_dma);
6249 sz = (ioc->reply_sz * ioc->reply_depth) + 128;
6250 len += sprintf(buf+len, " {CurRepSz=%d} x {CurRepDepth=%d} = %d bytes ^= 0x%x\n",
6251 ioc->reply_sz, ioc->reply_depth, ioc->reply_sz*ioc->reply_depth, sz);
6252 len += sprintf(buf+len, " {MaxRepSz=%d} {MaxRepDepth=%d}\n",
6253 ioc->facts.CurReplyFrameSize,
6254 ioc->facts.ReplyQueueDepth);
6255
6256 len += sprintf(buf+len, " MaxDevices = %d\n",
6257 (ioc->facts.MaxDevices==0) ? 255 : ioc->facts.MaxDevices);
6258 len += sprintf(buf+len, " MaxBuses = %d\n", ioc->facts.MaxBuses);
6259
6260 /* per-port info */
6261 for (p=0; p < ioc->facts.NumberOfPorts; p++) {
6262 len += sprintf(buf+len, " PortNumber = %d (of %d)\n",
6263 p+1,
6264 ioc->facts.NumberOfPorts);
6265 if (ioc->bus_type == FC) {
6266 if (ioc->pfacts[p].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) {
6267 u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
6268 len += sprintf(buf+len, " LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
6269 a[5], a[4], a[3], a[2], a[1], a[0]);
6270 }
6271 len += sprintf(buf+len, " WWN = %08X%08X:%08X%08X\n",
6272 ioc->fc_port_page0[p].WWNN.High,
6273 ioc->fc_port_page0[p].WWNN.Low,
6274 ioc->fc_port_page0[p].WWPN.High,
6275 ioc->fc_port_page0[p].WWPN.Low);
6276 }
6277 }
6278
6279 MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
6280 }
6281
6282 #endif /* CONFIG_PROC_FS } */
6283
6284 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6285 static void
6286 mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc)
6287 {
6288 buf[0] ='\0';
6289 if ((ioc->facts.FWVersion.Word >> 24) == 0x0E) {
6290 sprintf(buf, " (Exp %02d%02d)",
6291 (ioc->facts.FWVersion.Word >> 16) & 0x00FF, /* Month */
6292 (ioc->facts.FWVersion.Word >> 8) & 0x1F); /* Day */
6293
6294 /* insider hack! */
6295 if ((ioc->facts.FWVersion.Word >> 8) & 0x80)
6296 strcat(buf, " [MDBG]");
6297 }
6298 }
6299
6300 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6301 /**
6302 * mpt_print_ioc_summary - Write ASCII summary of IOC to a buffer.
6303 * @ioc: Pointer to MPT_ADAPTER structure
6304 * @buffer: Pointer to buffer where IOC summary info should be written
6305 * @size: Pointer to number of bytes we wrote (set by this routine)
6306 * @len: Offset at which to start writing in buffer
6307 * @showlan: Display LAN stuff?
6308 *
6309 * This routine writes (english readable) ASCII text, which represents
6310 * a summary of IOC information, to a buffer.
6311 */
6312 void
6313 mpt_print_ioc_summary(MPT_ADAPTER *ioc, char *buffer, int *size, int len, int showlan)
6314 {
6315 char expVer[32];
6316 int y;
6317
6318 mpt_get_fw_exp_ver(expVer, ioc);
6319
6320 /*
6321 * Shorter summary of attached ioc's...
6322 */
6323 y = sprintf(buffer+len, "%s: %s, %s%08xh%s, Ports=%d, MaxQ=%d",
6324 ioc->name,
6325 ioc->prod_name,
6326 MPT_FW_REV_MAGIC_ID_STRING, /* "FwRev=" or somesuch */
6327 ioc->facts.FWVersion.Word,
6328 expVer,
6329 ioc->facts.NumberOfPorts,
6330 ioc->req_depth);
6331
6332 if (showlan && (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN)) {
6333 u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
6334 y += sprintf(buffer+len+y, ", LanAddr=%02X:%02X:%02X:%02X:%02X:%02X",
6335 a[5], a[4], a[3], a[2], a[1], a[0]);
6336 }
6337
6338 y += sprintf(buffer+len+y, ", IRQ=%d", ioc->pci_irq);
6339
6340 if (!ioc->active)
6341 y += sprintf(buffer+len+y, " (disabled)");
6342
6343 y += sprintf(buffer+len+y, "\n");
6344
6345 *size = y;
6346 }
6347
6348
6349 /**
6350 * mpt_halt_firmware - Halts the firmware if it is operational and panic
6351 * the kernel
6352 * @ioc: Pointer to MPT_ADAPTER structure
6353 *
6354 **/
6355 void
6356 mpt_halt_firmware(MPT_ADAPTER *ioc)
6357 {
6358 u32 ioc_raw_state;
6359
6360 ioc_raw_state = mpt_GetIocState(ioc, 0);
6361
6362 if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
6363 printk(MYIOC_s_ERR_FMT "IOC is in FAULT state (%04xh)!!!\n",
6364 ioc->name, ioc_raw_state & MPI_DOORBELL_DATA_MASK);
6365 panic("%s: IOC Fault (%04xh)!!!\n", ioc->name,
6366 ioc_raw_state & MPI_DOORBELL_DATA_MASK);
6367 } else {
6368 CHIPREG_WRITE32(&ioc->chip->Doorbell, 0xC0FFEE00);
6369 panic("%s: Firmware is halted due to command timeout\n",
6370 ioc->name);
6371 }
6372 }
6373 EXPORT_SYMBOL(mpt_halt_firmware);
6374
6375 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6376 /*
6377 * Reset Handling
6378 */
6379 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6380 /**
6381 * mpt_HardResetHandler - Generic reset handler
6382 * @ioc: Pointer to MPT_ADAPTER structure
6383 * @sleepFlag: Indicates if sleep or schedule must be called.
6384 *
6385 * Issues SCSI Task Management call based on input arg values.
6386 * If TaskMgmt fails, returns associated SCSI request.
6387 *
6388 * Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
6389 * or a non-interrupt thread. In the former, must not call schedule().
6390 *
6391 * Note: A return of -1 is a FATAL error case, as it means a
6392 * FW reload/initialization failed.
6393 *
6394 * Returns 0 for SUCCESS or -1 if FAILED.
6395 */
6396 int
6397 mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag)
6398 {
6399 int rc;
6400 unsigned long flags;
6401
6402 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HardResetHandler Entered!\n", ioc->name));
6403 #ifdef MFCNT
6404 printk(MYIOC_s_INFO_FMT "HardResetHandler Entered!\n", ioc->name);
6405 printk("MF count 0x%x !\n", ioc->mfcnt);
6406 #endif
6407 if (mpt_fwfault_debug)
6408 mpt_halt_firmware(ioc);
6409
6410 /* Reset the adapter. Prevent more than 1 call to
6411 * mpt_do_ioc_recovery at any instant in time.
6412 */
6413 spin_lock_irqsave(&ioc->diagLock, flags);
6414 if ((ioc->diagPending) || (ioc->alt_ioc && ioc->alt_ioc->diagPending)){
6415 spin_unlock_irqrestore(&ioc->diagLock, flags);
6416 return 0;
6417 } else {
6418 ioc->diagPending = 1;
6419 }
6420 spin_unlock_irqrestore(&ioc->diagLock, flags);
6421
6422 /* FIXME: If do_ioc_recovery fails, repeat....
6423 */
6424
6425 /* The SCSI driver needs to adjust timeouts on all current
6426 * commands prior to the diagnostic reset being issued.
6427 * Prevents timeouts occurring during a diagnostic reset...very bad.
6428 * For all other protocol drivers, this is a no-op.
6429 */
6430 {
6431 u8 cb_idx;
6432 int r = 0;
6433
6434 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
6435 if (MptResetHandlers[cb_idx]) {
6436 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling IOC reset_setup handler #%d\n",
6437 ioc->name, cb_idx));
6438 r += mpt_signal_reset(cb_idx, ioc, MPT_IOC_SETUP_RESET);
6439 if (ioc->alt_ioc) {
6440 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling alt-%s setup reset handler #%d\n",
6441 ioc->name, ioc->alt_ioc->name, cb_idx));
6442 r += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_SETUP_RESET);
6443 }
6444 }
6445 }
6446 }
6447
6448 if ((rc = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_RECOVER, sleepFlag)) != 0) {
6449 printk(MYIOC_s_WARN_FMT "Cannot recover rc = %d!\n", ioc->name, rc);
6450 }
6451 ioc->reload_fw = 0;
6452 if (ioc->alt_ioc)
6453 ioc->alt_ioc->reload_fw = 0;
6454
6455 spin_lock_irqsave(&ioc->diagLock, flags);
6456 ioc->diagPending = 0;
6457 if (ioc->alt_ioc)
6458 ioc->alt_ioc->diagPending = 0;
6459 spin_unlock_irqrestore(&ioc->diagLock, flags);
6460
6461 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HardResetHandler rc = %d!\n", ioc->name, rc));
6462
6463 return rc;
6464 }
6465
6466 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6467 static void
6468 EventDescriptionStr(u8 event, u32 evData0, char *evStr)
6469 {
6470 char *ds = NULL;
6471
6472 switch(event) {
6473 case MPI_EVENT_NONE:
6474 ds = "None";
6475 break;
6476 case MPI_EVENT_LOG_DATA:
6477 ds = "Log Data";
6478 break;
6479 case MPI_EVENT_STATE_CHANGE:
6480 ds = "State Change";
6481 break;
6482 case MPI_EVENT_UNIT_ATTENTION:
6483 ds = "Unit Attention";
6484 break;
6485 case MPI_EVENT_IOC_BUS_RESET:
6486 ds = "IOC Bus Reset";
6487 break;
6488 case MPI_EVENT_EXT_BUS_RESET:
6489 ds = "External Bus Reset";
6490 break;
6491 case MPI_EVENT_RESCAN:
6492 ds = "Bus Rescan Event";
6493 break;
6494 case MPI_EVENT_LINK_STATUS_CHANGE:
6495 if (evData0 == MPI_EVENT_LINK_STATUS_FAILURE)
6496 ds = "Link Status(FAILURE) Change";
6497 else
6498 ds = "Link Status(ACTIVE) Change";
6499 break;
6500 case MPI_EVENT_LOOP_STATE_CHANGE:
6501 if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LIP)
6502 ds = "Loop State(LIP) Change";
6503 else if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LPE)
6504 ds = "Loop State(LPE) Change"; /* ??? */
6505 else
6506 ds = "Loop State(LPB) Change"; /* ??? */
6507 break;
6508 case MPI_EVENT_LOGOUT:
6509 ds = "Logout";
6510 break;
6511 case MPI_EVENT_EVENT_CHANGE:
6512 if (evData0)
6513 ds = "Events ON";
6514 else
6515 ds = "Events OFF";
6516 break;
6517 case MPI_EVENT_INTEGRATED_RAID:
6518 {
6519 u8 ReasonCode = (u8)(evData0 >> 16);
6520 switch (ReasonCode) {
6521 case MPI_EVENT_RAID_RC_VOLUME_CREATED :
6522 ds = "Integrated Raid: Volume Created";
6523 break;
6524 case MPI_EVENT_RAID_RC_VOLUME_DELETED :
6525 ds = "Integrated Raid: Volume Deleted";
6526 break;
6527 case MPI_EVENT_RAID_RC_VOLUME_SETTINGS_CHANGED :
6528 ds = "Integrated Raid: Volume Settings Changed";
6529 break;
6530 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED :
6531 ds = "Integrated Raid: Volume Status Changed";
6532 break;
6533 case MPI_EVENT_RAID_RC_VOLUME_PHYSDISK_CHANGED :
6534 ds = "Integrated Raid: Volume Physdisk Changed";
6535 break;
6536 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED :
6537 ds = "Integrated Raid: Physdisk Created";
6538 break;
6539 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED :
6540 ds = "Integrated Raid: Physdisk Deleted";
6541 break;
6542 case MPI_EVENT_RAID_RC_PHYSDISK_SETTINGS_CHANGED :
6543 ds = "Integrated Raid: Physdisk Settings Changed";
6544 break;
6545 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED :
6546 ds = "Integrated Raid: Physdisk Status Changed";
6547 break;
6548 case MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED :
6549 ds = "Integrated Raid: Domain Validation Needed";
6550 break;
6551 case MPI_EVENT_RAID_RC_SMART_DATA :
6552 ds = "Integrated Raid; Smart Data";
6553 break;
6554 case MPI_EVENT_RAID_RC_REPLACE_ACTION_STARTED :
6555 ds = "Integrated Raid: Replace Action Started";
6556 break;
6557 default:
6558 ds = "Integrated Raid";
6559 break;
6560 }
6561 break;
6562 }
6563 case MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE:
6564 ds = "SCSI Device Status Change";
6565 break;
6566 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
6567 {
6568 u8 id = (u8)(evData0);
6569 u8 channel = (u8)(evData0 >> 8);
6570 u8 ReasonCode = (u8)(evData0 >> 16);
6571 switch (ReasonCode) {
6572 case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
6573 snprintf(evStr, EVENT_DESCR_STR_SZ,
6574 "SAS Device Status Change: Added: "
6575 "id=%d channel=%d", id, channel);
6576 break;
6577 case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
6578 snprintf(evStr, EVENT_DESCR_STR_SZ,
6579 "SAS Device Status Change: Deleted: "
6580 "id=%d channel=%d", id, channel);
6581 break;
6582 case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
6583 snprintf(evStr, EVENT_DESCR_STR_SZ,
6584 "SAS Device Status Change: SMART Data: "
6585 "id=%d channel=%d", id, channel);
6586 break;
6587 case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
6588 snprintf(evStr, EVENT_DESCR_STR_SZ,
6589 "SAS Device Status Change: No Persistancy: "
6590 "id=%d channel=%d", id, channel);
6591 break;
6592 case MPI_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
6593 snprintf(evStr, EVENT_DESCR_STR_SZ,
6594 "SAS Device Status Change: Unsupported Device "
6595 "Discovered : id=%d channel=%d", id, channel);
6596 break;
6597 case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
6598 snprintf(evStr, EVENT_DESCR_STR_SZ,
6599 "SAS Device Status Change: Internal Device "
6600 "Reset : id=%d channel=%d", id, channel);
6601 break;
6602 case MPI_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
6603 snprintf(evStr, EVENT_DESCR_STR_SZ,
6604 "SAS Device Status Change: Internal Task "
6605 "Abort : id=%d channel=%d", id, channel);
6606 break;
6607 case MPI_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
6608 snprintf(evStr, EVENT_DESCR_STR_SZ,
6609 "SAS Device Status Change: Internal Abort "
6610 "Task Set : id=%d channel=%d", id, channel);
6611 break;
6612 case MPI_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
6613 snprintf(evStr, EVENT_DESCR_STR_SZ,
6614 "SAS Device Status Change: Internal Clear "
6615 "Task Set : id=%d channel=%d", id, channel);
6616 break;
6617 case MPI_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
6618 snprintf(evStr, EVENT_DESCR_STR_SZ,
6619 "SAS Device Status Change: Internal Query "
6620 "Task : id=%d channel=%d", id, channel);
6621 break;
6622 default:
6623 snprintf(evStr, EVENT_DESCR_STR_SZ,
6624 "SAS Device Status Change: Unknown: "
6625 "id=%d channel=%d", id, channel);
6626 break;
6627 }
6628 break;
6629 }
6630 case MPI_EVENT_ON_BUS_TIMER_EXPIRED:
6631 ds = "Bus Timer Expired";
6632 break;
6633 case MPI_EVENT_QUEUE_FULL:
6634 {
6635 u16 curr_depth = (u16)(evData0 >> 16);
6636 u8 channel = (u8)(evData0 >> 8);
6637 u8 id = (u8)(evData0);
6638
6639 snprintf(evStr, EVENT_DESCR_STR_SZ,
6640 "Queue Full: channel=%d id=%d depth=%d",
6641 channel, id, curr_depth);
6642 break;
6643 }
6644 case MPI_EVENT_SAS_SES:
6645 ds = "SAS SES Event";
6646 break;
6647 case MPI_EVENT_PERSISTENT_TABLE_FULL:
6648 ds = "Persistent Table Full";
6649 break;
6650 case MPI_EVENT_SAS_PHY_LINK_STATUS:
6651 {
6652 u8 LinkRates = (u8)(evData0 >> 8);
6653 u8 PhyNumber = (u8)(evData0);
6654 LinkRates = (LinkRates & MPI_EVENT_SAS_PLS_LR_CURRENT_MASK) >>
6655 MPI_EVENT_SAS_PLS_LR_CURRENT_SHIFT;
6656 switch (LinkRates) {
6657 case MPI_EVENT_SAS_PLS_LR_RATE_UNKNOWN:
6658 snprintf(evStr, EVENT_DESCR_STR_SZ,
6659 "SAS PHY Link Status: Phy=%d:"
6660 " Rate Unknown",PhyNumber);
6661 break;
6662 case MPI_EVENT_SAS_PLS_LR_RATE_PHY_DISABLED:
6663 snprintf(evStr, EVENT_DESCR_STR_SZ,
6664 "SAS PHY Link Status: Phy=%d:"
6665 " Phy Disabled",PhyNumber);
6666 break;
6667 case MPI_EVENT_SAS_PLS_LR_RATE_FAILED_SPEED_NEGOTIATION:
6668 snprintf(evStr, EVENT_DESCR_STR_SZ,
6669 "SAS PHY Link Status: Phy=%d:"
6670 " Failed Speed Nego",PhyNumber);
6671 break;
6672 case MPI_EVENT_SAS_PLS_LR_RATE_SATA_OOB_COMPLETE:
6673 snprintf(evStr, EVENT_DESCR_STR_SZ,
6674 "SAS PHY Link Status: Phy=%d:"
6675 " Sata OOB Completed",PhyNumber);
6676 break;
6677 case MPI_EVENT_SAS_PLS_LR_RATE_1_5:
6678 snprintf(evStr, EVENT_DESCR_STR_SZ,
6679 "SAS PHY Link Status: Phy=%d:"
6680 " Rate 1.5 Gbps",PhyNumber);
6681 break;
6682 case MPI_EVENT_SAS_PLS_LR_RATE_3_0:
6683 snprintf(evStr, EVENT_DESCR_STR_SZ,
6684 "SAS PHY Link Status: Phy=%d:"
6685 " Rate 3.0 Gpbs",PhyNumber);
6686 break;
6687 default:
6688 snprintf(evStr, EVENT_DESCR_STR_SZ,
6689 "SAS PHY Link Status: Phy=%d", PhyNumber);
6690 break;
6691 }
6692 break;
6693 }
6694 case MPI_EVENT_SAS_DISCOVERY_ERROR:
6695 ds = "SAS Discovery Error";
6696 break;
6697 case MPI_EVENT_IR_RESYNC_UPDATE:
6698 {
6699 u8 resync_complete = (u8)(evData0 >> 16);
6700 snprintf(evStr, EVENT_DESCR_STR_SZ,
6701 "IR Resync Update: Complete = %d:",resync_complete);
6702 break;
6703 }
6704 case MPI_EVENT_IR2:
6705 {
6706 u8 ReasonCode = (u8)(evData0 >> 16);
6707 switch (ReasonCode) {
6708 case MPI_EVENT_IR2_RC_LD_STATE_CHANGED:
6709 ds = "IR2: LD State Changed";
6710 break;
6711 case MPI_EVENT_IR2_RC_PD_STATE_CHANGED:
6712 ds = "IR2: PD State Changed";
6713 break;
6714 case MPI_EVENT_IR2_RC_BAD_BLOCK_TABLE_FULL:
6715 ds = "IR2: Bad Block Table Full";
6716 break;
6717 case MPI_EVENT_IR2_RC_PD_INSERTED:
6718 ds = "IR2: PD Inserted";
6719 break;
6720 case MPI_EVENT_IR2_RC_PD_REMOVED:
6721 ds = "IR2: PD Removed";
6722 break;
6723 case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED:
6724 ds = "IR2: Foreign CFG Detected";
6725 break;
6726 case MPI_EVENT_IR2_RC_REBUILD_MEDIUM_ERROR:
6727 ds = "IR2: Rebuild Medium Error";
6728 break;
6729 default:
6730 ds = "IR2";
6731 break;
6732 }
6733 break;
6734 }
6735 case MPI_EVENT_SAS_DISCOVERY:
6736 {
6737 if (evData0)
6738 ds = "SAS Discovery: Start";
6739 else
6740 ds = "SAS Discovery: Stop";
6741 break;
6742 }
6743 case MPI_EVENT_LOG_ENTRY_ADDED:
6744 ds = "SAS Log Entry Added";
6745 break;
6746
6747 case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
6748 {
6749 u8 phy_num = (u8)(evData0);
6750 u8 port_num = (u8)(evData0 >> 8);
6751 u8 port_width = (u8)(evData0 >> 16);
6752 u8 primative = (u8)(evData0 >> 24);
6753 snprintf(evStr, EVENT_DESCR_STR_SZ,
6754 "SAS Broadcase Primative: phy=%d port=%d "
6755 "width=%d primative=0x%02x",
6756 phy_num, port_num, port_width, primative);
6757 break;
6758 }
6759
6760 case MPI_EVENT_SAS_INIT_DEVICE_STATUS_CHANGE:
6761 {
6762 u8 reason = (u8)(evData0);
6763 u8 port_num = (u8)(evData0 >> 8);
6764 u16 handle = le16_to_cpu(evData0 >> 16);
6765
6766 snprintf(evStr, EVENT_DESCR_STR_SZ,
6767 "SAS Initiator Device Status Change: reason=0x%02x "
6768 "port=%d handle=0x%04x",
6769 reason, port_num, handle);
6770 break;
6771 }
6772
6773 case MPI_EVENT_SAS_INIT_TABLE_OVERFLOW:
6774 {
6775 u8 max_init = (u8)(evData0);
6776 u8 current_init = (u8)(evData0 >> 8);
6777
6778 snprintf(evStr, EVENT_DESCR_STR_SZ,
6779 "SAS Initiator Device Table Overflow: max initiators=%02d "
6780 "current initators=%02d",
6781 max_init, current_init);
6782 break;
6783 }
6784 case MPI_EVENT_SAS_SMP_ERROR:
6785 {
6786 u8 status = (u8)(evData0);
6787 u8 port_num = (u8)(evData0 >> 8);
6788 u8 result = (u8)(evData0 >> 16);
6789
6790 if (status == MPI_EVENT_SAS_SMP_FUNCTION_RESULT_VALID)
6791 snprintf(evStr, EVENT_DESCR_STR_SZ,
6792 "SAS SMP Error: port=%d result=0x%02x",
6793 port_num, result);
6794 else if (status == MPI_EVENT_SAS_SMP_CRC_ERROR)
6795 snprintf(evStr, EVENT_DESCR_STR_SZ,
6796 "SAS SMP Error: port=%d : CRC Error",
6797 port_num);
6798 else if (status == MPI_EVENT_SAS_SMP_TIMEOUT)
6799 snprintf(evStr, EVENT_DESCR_STR_SZ,
6800 "SAS SMP Error: port=%d : Timeout",
6801 port_num);
6802 else if (status == MPI_EVENT_SAS_SMP_NO_DESTINATION)
6803 snprintf(evStr, EVENT_DESCR_STR_SZ,
6804 "SAS SMP Error: port=%d : No Destination",
6805 port_num);
6806 else if (status == MPI_EVENT_SAS_SMP_BAD_DESTINATION)
6807 snprintf(evStr, EVENT_DESCR_STR_SZ,
6808 "SAS SMP Error: port=%d : Bad Destination",
6809 port_num);
6810 else
6811 snprintf(evStr, EVENT_DESCR_STR_SZ,
6812 "SAS SMP Error: port=%d : status=0x%02x",
6813 port_num, status);
6814 break;
6815 }
6816
6817 /*
6818 * MPT base "custom" events may be added here...
6819 */
6820 default:
6821 ds = "Unknown";
6822 break;
6823 }
6824 if (ds)
6825 strncpy(evStr, ds, EVENT_DESCR_STR_SZ);
6826 }
6827
6828 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6829 /**
6830 * ProcessEventNotification - Route EventNotificationReply to all event handlers
6831 * @ioc: Pointer to MPT_ADAPTER structure
6832 * @pEventReply: Pointer to EventNotification reply frame
6833 * @evHandlers: Pointer to integer, number of event handlers
6834 *
6835 * Routes a received EventNotificationReply to all currently registered
6836 * event handlers.
6837 * Returns sum of event handlers return values.
6838 */
6839 static int
6840 ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *pEventReply, int *evHandlers)
6841 {
6842 u16 evDataLen;
6843 u32 evData0 = 0;
6844 // u32 evCtx;
6845 int ii;
6846 u8 cb_idx;
6847 int r = 0;
6848 int handlers = 0;
6849 char evStr[EVENT_DESCR_STR_SZ];
6850 u8 event;
6851
6852 /*
6853 * Do platform normalization of values
6854 */
6855 event = le32_to_cpu(pEventReply->Event) & 0xFF;
6856 // evCtx = le32_to_cpu(pEventReply->EventContext);
6857 evDataLen = le16_to_cpu(pEventReply->EventDataLength);
6858 if (evDataLen) {
6859 evData0 = le32_to_cpu(pEventReply->Data[0]);
6860 }
6861
6862 EventDescriptionStr(event, evData0, evStr);
6863 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MPT event:(%02Xh) : %s\n",
6864 ioc->name,
6865 event,
6866 evStr));
6867
6868 #ifdef CONFIG_FUSION_LOGGING
6869 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
6870 ": Event data:\n", ioc->name));
6871 for (ii = 0; ii < evDataLen; ii++)
6872 devtverboseprintk(ioc, printk(" %08x",
6873 le32_to_cpu(pEventReply->Data[ii])));
6874 devtverboseprintk(ioc, printk("\n"));
6875 #endif
6876
6877 /*
6878 * Do general / base driver event processing
6879 */
6880 switch(event) {
6881 case MPI_EVENT_EVENT_CHANGE: /* 0A */
6882 if (evDataLen) {
6883 u8 evState = evData0 & 0xFF;
6884
6885 /* CHECKME! What if evState unexpectedly says OFF (0)? */
6886
6887 /* Update EventState field in cached IocFacts */
6888 if (ioc->facts.Function) {
6889 ioc->facts.EventState = evState;
6890 }
6891 }
6892 break;
6893 case MPI_EVENT_INTEGRATED_RAID:
6894 mptbase_raid_process_event_data(ioc,
6895 (MpiEventDataRaid_t *)pEventReply->Data);
6896 break;
6897 default:
6898 break;
6899 }
6900
6901 /*
6902 * Should this event be logged? Events are written sequentially.
6903 * When buffer is full, start again at the top.
6904 */
6905 if (ioc->events && (ioc->eventTypes & ( 1 << event))) {
6906 int idx;
6907
6908 idx = ioc->eventContext % MPTCTL_EVENT_LOG_SIZE;
6909
6910 ioc->events[idx].event = event;
6911 ioc->events[idx].eventContext = ioc->eventContext;
6912
6913 for (ii = 0; ii < 2; ii++) {
6914 if (ii < evDataLen)
6915 ioc->events[idx].data[ii] = le32_to_cpu(pEventReply->Data[ii]);
6916 else
6917 ioc->events[idx].data[ii] = 0;
6918 }
6919
6920 ioc->eventContext++;
6921 }
6922
6923
6924 /*
6925 * Call each currently registered protocol event handler.
6926 */
6927 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
6928 if (MptEvHandlers[cb_idx]) {
6929 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Routing Event to event handler #%d\n",
6930 ioc->name, cb_idx));
6931 r += (*(MptEvHandlers[cb_idx]))(ioc, pEventReply);
6932 handlers++;
6933 }
6934 }
6935 /* FIXME? Examine results here? */
6936
6937 /*
6938 * If needed, send (a single) EventAck.
6939 */
6940 if (pEventReply->AckRequired == MPI_EVENT_NOTIFICATION_ACK_REQUIRED) {
6941 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
6942 "EventAck required\n",ioc->name));
6943 if ((ii = SendEventAck(ioc, pEventReply)) != 0) {
6944 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SendEventAck returned %d\n",
6945 ioc->name, ii));
6946 }
6947 }
6948
6949 *evHandlers = handlers;
6950 return r;
6951 }
6952
6953 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6954 /**
6955 * mpt_fc_log_info - Log information returned from Fibre Channel IOC.
6956 * @ioc: Pointer to MPT_ADAPTER structure
6957 * @log_info: U32 LogInfo reply word from the IOC
6958 *
6959 * Refer to lsi/mpi_log_fc.h.
6960 */
6961 static void
6962 mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info)
6963 {
6964 char *desc = "unknown";
6965
6966 switch (log_info & 0xFF000000) {
6967 case MPI_IOCLOGINFO_FC_INIT_BASE:
6968 desc = "FCP Initiator";
6969 break;
6970 case MPI_IOCLOGINFO_FC_TARGET_BASE:
6971 desc = "FCP Target";
6972 break;
6973 case MPI_IOCLOGINFO_FC_LAN_BASE:
6974 desc = "LAN";
6975 break;
6976 case MPI_IOCLOGINFO_FC_MSG_BASE:
6977 desc = "MPI Message Layer";
6978 break;
6979 case MPI_IOCLOGINFO_FC_LINK_BASE:
6980 desc = "FC Link";
6981 break;
6982 case MPI_IOCLOGINFO_FC_CTX_BASE:
6983 desc = "Context Manager";
6984 break;
6985 case MPI_IOCLOGINFO_FC_INVALID_FIELD_BYTE_OFFSET:
6986 desc = "Invalid Field Offset";
6987 break;
6988 case MPI_IOCLOGINFO_FC_STATE_CHANGE:
6989 desc = "State Change Info";
6990 break;
6991 }
6992
6993 printk(MYIOC_s_INFO_FMT "LogInfo(0x%08x): SubClass={%s}, Value=(0x%06x)\n",
6994 ioc->name, log_info, desc, (log_info & 0xFFFFFF));
6995 }
6996
6997 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6998 /**
6999 * mpt_spi_log_info - Log information returned from SCSI Parallel IOC.
7000 * @ioc: Pointer to MPT_ADAPTER structure
7001 * @log_info: U32 LogInfo word from the IOC
7002 *
7003 * Refer to lsi/sp_log.h.
7004 */
7005 static void
7006 mpt_spi_log_info(MPT_ADAPTER *ioc, u32 log_info)
7007 {
7008 u32 info = log_info & 0x00FF0000;
7009 char *desc = "unknown";
7010
7011 switch (info) {
7012 case 0x00010000:
7013 desc = "bug! MID not found";
7014 if (ioc->reload_fw == 0)
7015 ioc->reload_fw++;
7016 break;
7017
7018 case 0x00020000:
7019 desc = "Parity Error";
7020 break;
7021
7022 case 0x00030000:
7023 desc = "ASYNC Outbound Overrun";
7024 break;
7025
7026 case 0x00040000:
7027 desc = "SYNC Offset Error";
7028 break;
7029
7030 case 0x00050000:
7031 desc = "BM Change";
7032 break;
7033
7034 case 0x00060000:
7035 desc = "Msg In Overflow";
7036 break;
7037
7038 case 0x00070000:
7039 desc = "DMA Error";
7040 break;
7041
7042 case 0x00080000:
7043 desc = "Outbound DMA Overrun";
7044 break;
7045
7046 case 0x00090000:
7047 desc = "Task Management";
7048 break;
7049
7050 case 0x000A0000:
7051 desc = "Device Problem";
7052 break;
7053
7054 case 0x000B0000:
7055 desc = "Invalid Phase Change";
7056 break;
7057
7058 case 0x000C0000:
7059 desc = "Untagged Table Size";
7060 break;
7061
7062 }
7063
7064 printk(MYIOC_s_INFO_FMT "LogInfo(0x%08x): F/W: %s\n", ioc->name, log_info, desc);
7065 }
7066
7067 /* strings for sas loginfo */
7068 static char *originator_str[] = {
7069 "IOP", /* 00h */
7070 "PL", /* 01h */
7071 "IR" /* 02h */
7072 };
7073 static char *iop_code_str[] = {
7074 NULL, /* 00h */
7075 "Invalid SAS Address", /* 01h */
7076 NULL, /* 02h */
7077 "Invalid Page", /* 03h */
7078 "Diag Message Error", /* 04h */
7079 "Task Terminated", /* 05h */
7080 "Enclosure Management", /* 06h */
7081 "Target Mode" /* 07h */
7082 };
7083 static char *pl_code_str[] = {
7084 NULL, /* 00h */
7085 "Open Failure", /* 01h */
7086 "Invalid Scatter Gather List", /* 02h */
7087 "Wrong Relative Offset or Frame Length", /* 03h */
7088 "Frame Transfer Error", /* 04h */
7089 "Transmit Frame Connected Low", /* 05h */
7090 "SATA Non-NCQ RW Error Bit Set", /* 06h */
7091 "SATA Read Log Receive Data Error", /* 07h */
7092 "SATA NCQ Fail All Commands After Error", /* 08h */
7093 "SATA Error in Receive Set Device Bit FIS", /* 09h */
7094 "Receive Frame Invalid Message", /* 0Ah */
7095 "Receive Context Message Valid Error", /* 0Bh */
7096 "Receive Frame Current Frame Error", /* 0Ch */
7097 "SATA Link Down", /* 0Dh */
7098 "Discovery SATA Init W IOS", /* 0Eh */
7099 "Config Invalid Page", /* 0Fh */
7100 "Discovery SATA Init Timeout", /* 10h */
7101 "Reset", /* 11h */
7102 "Abort", /* 12h */
7103 "IO Not Yet Executed", /* 13h */
7104 "IO Executed", /* 14h */
7105 "Persistent Reservation Out Not Affiliation "
7106 "Owner", /* 15h */
7107 "Open Transmit DMA Abort", /* 16h */
7108 "IO Device Missing Delay Retry", /* 17h */
7109 "IO Cancelled Due to Recieve Error", /* 18h */
7110 NULL, /* 19h */
7111 NULL, /* 1Ah */
7112 NULL, /* 1Bh */
7113 NULL, /* 1Ch */
7114 NULL, /* 1Dh */
7115 NULL, /* 1Eh */
7116 NULL, /* 1Fh */
7117 "Enclosure Management" /* 20h */
7118 };
7119 static char *ir_code_str[] = {
7120 "Raid Action Error", /* 00h */
7121 NULL, /* 00h */
7122 NULL, /* 01h */
7123 NULL, /* 02h */
7124 NULL, /* 03h */
7125 NULL, /* 04h */
7126 NULL, /* 05h */
7127 NULL, /* 06h */
7128 NULL /* 07h */
7129 };
7130 static char *raid_sub_code_str[] = {
7131 NULL, /* 00h */
7132 "Volume Creation Failed: Data Passed too "
7133 "Large", /* 01h */
7134 "Volume Creation Failed: Duplicate Volumes "
7135 "Attempted", /* 02h */
7136 "Volume Creation Failed: Max Number "
7137 "Supported Volumes Exceeded", /* 03h */
7138 "Volume Creation Failed: DMA Error", /* 04h */
7139 "Volume Creation Failed: Invalid Volume Type", /* 05h */
7140 "Volume Creation Failed: Error Reading "
7141 "MFG Page 4", /* 06h */
7142 "Volume Creation Failed: Creating Internal "
7143 "Structures", /* 07h */
7144 NULL, /* 08h */
7145 NULL, /* 09h */
7146 NULL, /* 0Ah */
7147 NULL, /* 0Bh */
7148 NULL, /* 0Ch */
7149 NULL, /* 0Dh */
7150 NULL, /* 0Eh */
7151 NULL, /* 0Fh */
7152 "Activation failed: Already Active Volume", /* 10h */
7153 "Activation failed: Unsupported Volume Type", /* 11h */
7154 "Activation failed: Too Many Active Volumes", /* 12h */
7155 "Activation failed: Volume ID in Use", /* 13h */
7156 "Activation failed: Reported Failure", /* 14h */
7157 "Activation failed: Importing a Volume", /* 15h */
7158 NULL, /* 16h */
7159 NULL, /* 17h */
7160 NULL, /* 18h */
7161 NULL, /* 19h */
7162 NULL, /* 1Ah */
7163 NULL, /* 1Bh */
7164 NULL, /* 1Ch */
7165 NULL, /* 1Dh */
7166 NULL, /* 1Eh */
7167 NULL, /* 1Fh */
7168 "Phys Disk failed: Too Many Phys Disks", /* 20h */
7169 "Phys Disk failed: Data Passed too Large", /* 21h */
7170 "Phys Disk failed: DMA Error", /* 22h */
7171 "Phys Disk failed: Invalid <channel:id>", /* 23h */
7172 "Phys Disk failed: Creating Phys Disk Config "
7173 "Page", /* 24h */
7174 NULL, /* 25h */
7175 NULL, /* 26h */
7176 NULL, /* 27h */
7177 NULL, /* 28h */
7178 NULL, /* 29h */
7179 NULL, /* 2Ah */
7180 NULL, /* 2Bh */
7181 NULL, /* 2Ch */
7182 NULL, /* 2Dh */
7183 NULL, /* 2Eh */
7184 NULL, /* 2Fh */
7185 "Compatibility Error: IR Disabled", /* 30h */
7186 "Compatibility Error: Inquiry Comand Failed", /* 31h */
7187 "Compatibility Error: Device not Direct Access "
7188 "Device ", /* 32h */
7189 "Compatibility Error: Removable Device Found", /* 33h */
7190 "Compatibility Error: Device SCSI Version not "
7191 "2 or Higher", /* 34h */
7192 "Compatibility Error: SATA Device, 48 BIT LBA "
7193 "not Supported", /* 35h */
7194 "Compatibility Error: Device doesn't have "
7195 "512 Byte Block Sizes", /* 36h */
7196 "Compatibility Error: Volume Type Check Failed", /* 37h */
7197 "Compatibility Error: Volume Type is "
7198 "Unsupported by FW", /* 38h */
7199 "Compatibility Error: Disk Drive too Small for "
7200 "use in Volume", /* 39h */
7201 "Compatibility Error: Phys Disk for Create "
7202 "Volume not Found", /* 3Ah */
7203 "Compatibility Error: Too Many or too Few "
7204 "Disks for Volume Type", /* 3Bh */
7205 "Compatibility Error: Disk stripe Sizes "
7206 "Must be 64KB", /* 3Ch */
7207 "Compatibility Error: IME Size Limited to < 2TB", /* 3Dh */
7208 };
7209
7210 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
7211 /**
7212 * mpt_sas_log_info - Log information returned from SAS IOC.
7213 * @ioc: Pointer to MPT_ADAPTER structure
7214 * @log_info: U32 LogInfo reply word from the IOC
7215 *
7216 * Refer to lsi/mpi_log_sas.h.
7217 **/
7218 static void
7219 mpt_sas_log_info(MPT_ADAPTER *ioc, u32 log_info)
7220 {
7221 union loginfo_type {
7222 u32 loginfo;
7223 struct {
7224 u32 subcode:16;
7225 u32 code:8;
7226 u32 originator:4;
7227 u32 bus_type:4;
7228 }dw;
7229 };
7230 union loginfo_type sas_loginfo;
7231 char *originator_desc = NULL;
7232 char *code_desc = NULL;
7233 char *sub_code_desc = NULL;
7234
7235 sas_loginfo.loginfo = log_info;
7236 if ((sas_loginfo.dw.bus_type != 3 /*SAS*/) &&
7237 (sas_loginfo.dw.originator < ARRAY_SIZE(originator_str)))
7238 return;
7239
7240 originator_desc = originator_str[sas_loginfo.dw.originator];
7241
7242 switch (sas_loginfo.dw.originator) {
7243
7244 case 0: /* IOP */
7245 if (sas_loginfo.dw.code <
7246 ARRAY_SIZE(iop_code_str))
7247 code_desc = iop_code_str[sas_loginfo.dw.code];
7248 break;
7249 case 1: /* PL */
7250 if (sas_loginfo.dw.code <
7251 ARRAY_SIZE(pl_code_str))
7252 code_desc = pl_code_str[sas_loginfo.dw.code];
7253 break;
7254 case 2: /* IR */
7255 if (sas_loginfo.dw.code >=
7256 ARRAY_SIZE(ir_code_str))
7257 break;
7258 code_desc = ir_code_str[sas_loginfo.dw.code];
7259 if (sas_loginfo.dw.subcode >=
7260 ARRAY_SIZE(raid_sub_code_str))
7261 break;
7262 if (sas_loginfo.dw.code == 0)
7263 sub_code_desc =
7264 raid_sub_code_str[sas_loginfo.dw.subcode];
7265 break;
7266 default:
7267 return;
7268 }
7269
7270 if (sub_code_desc != NULL)
7271 printk(MYIOC_s_INFO_FMT
7272 "LogInfo(0x%08x): Originator={%s}, Code={%s},"
7273 " SubCode={%s}\n",
7274 ioc->name, log_info, originator_desc, code_desc,
7275 sub_code_desc);
7276 else if (code_desc != NULL)
7277 printk(MYIOC_s_INFO_FMT
7278 "LogInfo(0x%08x): Originator={%s}, Code={%s},"
7279 " SubCode(0x%04x)\n",
7280 ioc->name, log_info, originator_desc, code_desc,
7281 sas_loginfo.dw.subcode);
7282 else
7283 printk(MYIOC_s_INFO_FMT
7284 "LogInfo(0x%08x): Originator={%s}, Code=(0x%02x),"
7285 " SubCode(0x%04x)\n",
7286 ioc->name, log_info, originator_desc,
7287 sas_loginfo.dw.code, sas_loginfo.dw.subcode);
7288 }
7289
7290 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
7291 /**
7292 * mpt_iocstatus_info_config - IOCSTATUS information for config pages
7293 * @ioc: Pointer to MPT_ADAPTER structure
7294 * @ioc_status: U32 IOCStatus word from IOC
7295 * @mf: Pointer to MPT request frame
7296 *
7297 * Refer to lsi/mpi.h.
7298 **/
7299 static void
7300 mpt_iocstatus_info_config(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf)
7301 {
7302 Config_t *pReq = (Config_t *)mf;
7303 char extend_desc[EVENT_DESCR_STR_SZ];
7304 char *desc = NULL;
7305 u32 form;
7306 u8 page_type;
7307
7308 if (pReq->Header.PageType == MPI_CONFIG_PAGETYPE_EXTENDED)
7309 page_type = pReq->ExtPageType;
7310 else
7311 page_type = pReq->Header.PageType;
7312
7313 /*
7314 * ignore invalid page messages for GET_NEXT_HANDLE
7315 */
7316 form = le32_to_cpu(pReq->PageAddress);
7317 if (ioc_status == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
7318 if (page_type == MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE ||
7319 page_type == MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER ||
7320 page_type == MPI_CONFIG_EXTPAGETYPE_ENCLOSURE) {
7321 if ((form >> MPI_SAS_DEVICE_PGAD_FORM_SHIFT) ==
7322 MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE)
7323 return;
7324 }
7325 if (page_type == MPI_CONFIG_PAGETYPE_FC_DEVICE)
7326 if ((form & MPI_FC_DEVICE_PGAD_FORM_MASK) ==
7327 MPI_FC_DEVICE_PGAD_FORM_NEXT_DID)
7328 return;
7329 }
7330
7331 snprintf(extend_desc, EVENT_DESCR_STR_SZ,
7332 "type=%02Xh, page=%02Xh, action=%02Xh, form=%08Xh",
7333 page_type, pReq->Header.PageNumber, pReq->Action, form);
7334
7335 switch (ioc_status) {
7336
7337 case MPI_IOCSTATUS_CONFIG_INVALID_ACTION: /* 0x0020 */
7338 desc = "Config Page Invalid Action";
7339 break;
7340
7341 case MPI_IOCSTATUS_CONFIG_INVALID_TYPE: /* 0x0021 */
7342 desc = "Config Page Invalid Type";
7343 break;
7344
7345 case MPI_IOCSTATUS_CONFIG_INVALID_PAGE: /* 0x0022 */
7346 desc = "Config Page Invalid Page";
7347 break;
7348
7349 case MPI_IOCSTATUS_CONFIG_INVALID_DATA: /* 0x0023 */
7350 desc = "Config Page Invalid Data";
7351 break;
7352
7353 case MPI_IOCSTATUS_CONFIG_NO_DEFAULTS: /* 0x0024 */
7354 desc = "Config Page No Defaults";
7355 break;
7356
7357 case MPI_IOCSTATUS_CONFIG_CANT_COMMIT: /* 0x0025 */
7358 desc = "Config Page Can't Commit";
7359 break;
7360 }
7361
7362 if (!desc)
7363 return;
7364
7365 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOCStatus(0x%04X): %s: %s\n",
7366 ioc->name, ioc_status, desc, extend_desc));
7367 }
7368
7369 /**
7370 * mpt_iocstatus_info - IOCSTATUS information returned from IOC.
7371 * @ioc: Pointer to MPT_ADAPTER structure
7372 * @ioc_status: U32 IOCStatus word from IOC
7373 * @mf: Pointer to MPT request frame
7374 *
7375 * Refer to lsi/mpi.h.
7376 **/
7377 static void
7378 mpt_iocstatus_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf)
7379 {
7380 u32 status = ioc_status & MPI_IOCSTATUS_MASK;
7381 char *desc = NULL;
7382
7383 switch (status) {
7384
7385 /****************************************************************************/
7386 /* Common IOCStatus values for all replies */
7387 /****************************************************************************/
7388
7389 case MPI_IOCSTATUS_INVALID_FUNCTION: /* 0x0001 */
7390 desc = "Invalid Function";
7391 break;
7392
7393 case MPI_IOCSTATUS_BUSY: /* 0x0002 */
7394 desc = "Busy";
7395 break;
7396
7397 case MPI_IOCSTATUS_INVALID_SGL: /* 0x0003 */
7398 desc = "Invalid SGL";
7399 break;
7400
7401 case MPI_IOCSTATUS_INTERNAL_ERROR: /* 0x0004 */
7402 desc = "Internal Error";
7403 break;
7404
7405 case MPI_IOCSTATUS_RESERVED: /* 0x0005 */
7406 desc = "Reserved";
7407 break;
7408
7409 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
7410 desc = "Insufficient Resources";
7411 break;
7412
7413 case MPI_IOCSTATUS_INVALID_FIELD: /* 0x0007 */
7414 desc = "Invalid Field";
7415 break;
7416
7417 case MPI_IOCSTATUS_INVALID_STATE: /* 0x0008 */
7418 desc = "Invalid State";
7419 break;
7420
7421 /****************************************************************************/
7422 /* Config IOCStatus values */
7423 /****************************************************************************/
7424
7425 case MPI_IOCSTATUS_CONFIG_INVALID_ACTION: /* 0x0020 */
7426 case MPI_IOCSTATUS_CONFIG_INVALID_TYPE: /* 0x0021 */
7427 case MPI_IOCSTATUS_CONFIG_INVALID_PAGE: /* 0x0022 */
7428 case MPI_IOCSTATUS_CONFIG_INVALID_DATA: /* 0x0023 */
7429 case MPI_IOCSTATUS_CONFIG_NO_DEFAULTS: /* 0x0024 */
7430 case MPI_IOCSTATUS_CONFIG_CANT_COMMIT: /* 0x0025 */
7431 mpt_iocstatus_info_config(ioc, status, mf);
7432 break;
7433
7434 /****************************************************************************/
7435 /* SCSIIO Reply (SPI, FCP, SAS) initiator values */
7436 /* */
7437 /* Look at mptscsih_iocstatus_info_scsiio in mptscsih.c */
7438 /* */
7439 /****************************************************************************/
7440
7441 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
7442 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
7443 case MPI_IOCSTATUS_SCSI_INVALID_BUS: /* 0x0041 */
7444 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID: /* 0x0042 */
7445 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
7446 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: /* 0x0044 */
7447 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
7448 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
7449 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
7450 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */
7451 case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED: /* 0x004A */
7452 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
7453 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
7454 break;
7455
7456 /****************************************************************************/
7457 /* SCSI Target values */
7458 /****************************************************************************/
7459
7460 case MPI_IOCSTATUS_TARGET_PRIORITY_IO: /* 0x0060 */
7461 desc = "Target: Priority IO";
7462 break;
7463
7464 case MPI_IOCSTATUS_TARGET_INVALID_PORT: /* 0x0061 */
7465 desc = "Target: Invalid Port";
7466 break;
7467
7468 case MPI_IOCSTATUS_TARGET_INVALID_IO_INDEX: /* 0x0062 */
7469 desc = "Target Invalid IO Index:";
7470 break;
7471
7472 case MPI_IOCSTATUS_TARGET_ABORTED: /* 0x0063 */
7473 desc = "Target: Aborted";
7474 break;
7475
7476 case MPI_IOCSTATUS_TARGET_NO_CONN_RETRYABLE: /* 0x0064 */
7477 desc = "Target: No Conn Retryable";
7478 break;
7479
7480 case MPI_IOCSTATUS_TARGET_NO_CONNECTION: /* 0x0065 */
7481 desc = "Target: No Connection";
7482 break;
7483
7484 case MPI_IOCSTATUS_TARGET_XFER_COUNT_MISMATCH: /* 0x006A */
7485 desc = "Target: Transfer Count Mismatch";
7486 break;
7487
7488 case MPI_IOCSTATUS_TARGET_STS_DATA_NOT_SENT: /* 0x006B */
7489 desc = "Target: STS Data not Sent";
7490 break;
7491
7492 case MPI_IOCSTATUS_TARGET_DATA_OFFSET_ERROR: /* 0x006D */
7493 desc = "Target: Data Offset Error";
7494 break;
7495
7496 case MPI_IOCSTATUS_TARGET_TOO_MUCH_WRITE_DATA: /* 0x006E */
7497 desc = "Target: Too Much Write Data";
7498 break;
7499
7500 case MPI_IOCSTATUS_TARGET_IU_TOO_SHORT: /* 0x006F */
7501 desc = "Target: IU Too Short";
7502 break;
7503
7504 case MPI_IOCSTATUS_TARGET_ACK_NAK_TIMEOUT: /* 0x0070 */
7505 desc = "Target: ACK NAK Timeout";
7506 break;
7507
7508 case MPI_IOCSTATUS_TARGET_NAK_RECEIVED: /* 0x0071 */
7509 desc = "Target: Nak Received";
7510 break;
7511
7512 /****************************************************************************/
7513 /* Fibre Channel Direct Access values */
7514 /****************************************************************************/
7515
7516 case MPI_IOCSTATUS_FC_ABORTED: /* 0x0066 */
7517 desc = "FC: Aborted";
7518 break;
7519
7520 case MPI_IOCSTATUS_FC_RX_ID_INVALID: /* 0x0067 */
7521 desc = "FC: RX ID Invalid";
7522 break;
7523
7524 case MPI_IOCSTATUS_FC_DID_INVALID: /* 0x0068 */
7525 desc = "FC: DID Invalid";
7526 break;
7527
7528 case MPI_IOCSTATUS_FC_NODE_LOGGED_OUT: /* 0x0069 */
7529 desc = "FC: Node Logged Out";
7530 break;
7531
7532 case MPI_IOCSTATUS_FC_EXCHANGE_CANCELED: /* 0x006C */
7533 desc = "FC: Exchange Canceled";
7534 break;
7535
7536 /****************************************************************************/
7537 /* LAN values */
7538 /****************************************************************************/
7539
7540 case MPI_IOCSTATUS_LAN_DEVICE_NOT_FOUND: /* 0x0080 */
7541 desc = "LAN: Device not Found";
7542 break;
7543
7544 case MPI_IOCSTATUS_LAN_DEVICE_FAILURE: /* 0x0081 */
7545 desc = "LAN: Device Failure";
7546 break;
7547
7548 case MPI_IOCSTATUS_LAN_TRANSMIT_ERROR: /* 0x0082 */
7549 desc = "LAN: Transmit Error";
7550 break;
7551
7552 case MPI_IOCSTATUS_LAN_TRANSMIT_ABORTED: /* 0x0083 */
7553 desc = "LAN: Transmit Aborted";
7554 break;
7555
7556 case MPI_IOCSTATUS_LAN_RECEIVE_ERROR: /* 0x0084 */
7557 desc = "LAN: Receive Error";
7558 break;
7559
7560 case MPI_IOCSTATUS_LAN_RECEIVE_ABORTED: /* 0x0085 */
7561 desc = "LAN: Receive Aborted";
7562 break;
7563
7564 case MPI_IOCSTATUS_LAN_PARTIAL_PACKET: /* 0x0086 */
7565 desc = "LAN: Partial Packet";
7566 break;
7567
7568 case MPI_IOCSTATUS_LAN_CANCELED: /* 0x0087 */
7569 desc = "LAN: Canceled";
7570 break;
7571
7572 /****************************************************************************/
7573 /* Serial Attached SCSI values */
7574 /****************************************************************************/
7575
7576 case MPI_IOCSTATUS_SAS_SMP_REQUEST_FAILED: /* 0x0090 */
7577 desc = "SAS: SMP Request Failed";
7578 break;
7579
7580 case MPI_IOCSTATUS_SAS_SMP_DATA_OVERRUN: /* 0x0090 */
7581 desc = "SAS: SMP Data Overrun";
7582 break;
7583
7584 default:
7585 desc = "Others";
7586 break;
7587 }
7588
7589 if (!desc)
7590 return;
7591
7592 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOCStatus(0x%04X): %s\n",
7593 ioc->name, status, desc));
7594 }
7595
7596 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
7597 EXPORT_SYMBOL(mpt_attach);
7598 EXPORT_SYMBOL(mpt_detach);
7599 #ifdef CONFIG_PM
7600 EXPORT_SYMBOL(mpt_resume);
7601 EXPORT_SYMBOL(mpt_suspend);
7602 #endif
7603 EXPORT_SYMBOL(ioc_list);
7604 EXPORT_SYMBOL(mpt_register);
7605 EXPORT_SYMBOL(mpt_deregister);
7606 EXPORT_SYMBOL(mpt_event_register);
7607 EXPORT_SYMBOL(mpt_event_deregister);
7608 EXPORT_SYMBOL(mpt_reset_register);
7609 EXPORT_SYMBOL(mpt_reset_deregister);
7610 EXPORT_SYMBOL(mpt_device_driver_register);
7611 EXPORT_SYMBOL(mpt_device_driver_deregister);
7612 EXPORT_SYMBOL(mpt_get_msg_frame);
7613 EXPORT_SYMBOL(mpt_put_msg_frame);
7614 EXPORT_SYMBOL(mpt_put_msg_frame_hi_pri);
7615 EXPORT_SYMBOL(mpt_free_msg_frame);
7616 EXPORT_SYMBOL(mpt_add_sge);
7617 EXPORT_SYMBOL(mpt_send_handshake_request);
7618 EXPORT_SYMBOL(mpt_verify_adapter);
7619 EXPORT_SYMBOL(mpt_GetIocState);
7620 EXPORT_SYMBOL(mpt_print_ioc_summary);
7621 EXPORT_SYMBOL(mpt_HardResetHandler);
7622 EXPORT_SYMBOL(mpt_config);
7623 EXPORT_SYMBOL(mpt_findImVolumes);
7624 EXPORT_SYMBOL(mpt_alloc_fw_memory);
7625 EXPORT_SYMBOL(mpt_free_fw_memory);
7626 EXPORT_SYMBOL(mptbase_sas_persist_operation);
7627 EXPORT_SYMBOL(mpt_raid_phys_disk_pg0);
7628
7629 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
7630 /**
7631 * fusion_init - Fusion MPT base driver initialization routine.
7632 *
7633 * Returns 0 for success, non-zero for failure.
7634 */
7635 static int __init
7636 fusion_init(void)
7637 {
7638 u8 cb_idx;
7639
7640 show_mptmod_ver(my_NAME, my_VERSION);
7641 printk(KERN_INFO COPYRIGHT "\n");
7642
7643 for (cb_idx = 0; cb_idx < MPT_MAX_PROTOCOL_DRIVERS; cb_idx++) {
7644 MptCallbacks[cb_idx] = NULL;
7645 MptDriverClass[cb_idx] = MPTUNKNOWN_DRIVER;
7646 MptEvHandlers[cb_idx] = NULL;
7647 MptResetHandlers[cb_idx] = NULL;
7648 }
7649
7650 /* Register ourselves (mptbase) in order to facilitate
7651 * EventNotification handling.
7652 */
7653 mpt_base_index = mpt_register(mpt_base_reply, MPTBASE_DRIVER);
7654
7655 /* Register for hard reset handling callbacks.
7656 */
7657 mpt_reset_register(mpt_base_index, mpt_ioc_reset);
7658
7659 #ifdef CONFIG_PROC_FS
7660 (void) procmpt_create();
7661 #endif
7662 return 0;
7663 }
7664
7665 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
7666 /**
7667 * fusion_exit - Perform driver unload cleanup.
7668 *
7669 * This routine frees all resources associated with each MPT adapter
7670 * and removes all %MPT_PROCFS_MPTBASEDIR entries.
7671 */
7672 static void __exit
7673 fusion_exit(void)
7674 {
7675
7676 mpt_reset_deregister(mpt_base_index);
7677
7678 #ifdef CONFIG_PROC_FS
7679 procmpt_destroy();
7680 #endif
7681 }
7682
7683 module_init(fusion_init);
7684 module_exit(fusion_exit);
Openmoko development kernel tree