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, 0); 95 MODULE_PARM_DESC(mpt_msi_enable_sas, " Enable MSI Support for SAS \ 96 controllers (default=0)"); 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_BIT_MASK(64)) 1538 && !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64))) { 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_BIT_MASK(32)) 1543 && !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) { 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_on_stack(&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); 7685