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