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