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