1 /* 2 * Linux MegaRAID driver for SAS based RAID controllers 3 * 4 * Copyright (c) 2009-2013 LSI Corporation 5 * Copyright (c) 2013-2014 Avago Technologies 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 2 10 * of the License, or (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * 20 * FILE: megaraid_sas_fusion.c 21 * 22 * Authors: Avago Technologies 23 * Sumant Patro 24 * Adam Radford 25 * Kashyap Desai <kashyap.desai@avagotech.com> 26 * Sumit Saxena <sumit.saxena@avagotech.com> 27 * 28 * Send feedback to: megaraidlinux.pdl@avagotech.com 29 * 30 * Mail to: Avago Technologies, 350 West Trimble Road, Building 90, 31 * San Jose, California 95131 32 */ 33 34 #include <linux/kernel.h> 35 #include <linux/types.h> 36 #include <linux/pci.h> 37 #include <linux/list.h> 38 #include <linux/moduleparam.h> 39 #include <linux/module.h> 40 #include <linux/spinlock.h> 41 #include <linux/interrupt.h> 42 #include <linux/delay.h> 43 #include <linux/uio.h> 44 #include <linux/uaccess.h> 45 #include <linux/fs.h> 46 #include <linux/compat.h> 47 #include <linux/blkdev.h> 48 #include <linux/mutex.h> 49 #include <linux/poll.h> 50 51 #include <scsi/scsi.h> 52 #include <scsi/scsi_cmnd.h> 53 #include <scsi/scsi_device.h> 54 #include <scsi/scsi_host.h> 55 #include <scsi/scsi_dbg.h> 56 57 #include "megaraid_sas_fusion.h" 58 #include "megaraid_sas.h" 59 60 extern void megasas_free_cmds(struct megasas_instance *instance); 61 extern struct megasas_cmd *megasas_get_cmd(struct megasas_instance 62 *instance); 63 extern void 64 megasas_complete_cmd(struct megasas_instance *instance, 65 struct megasas_cmd *cmd, u8 alt_status); 66 int 67 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd, 68 int seconds); 69 70 void 71 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd); 72 int megasas_alloc_cmds(struct megasas_instance *instance); 73 int 74 megasas_clear_intr_fusion(struct megasas_register_set __iomem *regs); 75 int 76 megasas_issue_polled(struct megasas_instance *instance, 77 struct megasas_cmd *cmd); 78 void 79 megasas_check_and_restore_queue_depth(struct megasas_instance *instance); 80 81 int megasas_transition_to_ready(struct megasas_instance *instance, int ocr); 82 void megaraid_sas_kill_hba(struct megasas_instance *instance); 83 84 extern u32 megasas_dbg_lvl; 85 void megasas_sriov_heartbeat_handler(unsigned long instance_addr); 86 int megasas_sriov_start_heartbeat(struct megasas_instance *instance, 87 int initial); 88 void megasas_start_timer(struct megasas_instance *instance, 89 struct timer_list *timer, 90 void *fn, unsigned long interval); 91 extern struct megasas_mgmt_info megasas_mgmt_info; 92 extern int resetwaittime; 93 94 95 96 /** 97 * megasas_enable_intr_fusion - Enables interrupts 98 * @regs: MFI register set 99 */ 100 void 101 megasas_enable_intr_fusion(struct megasas_instance *instance) 102 { 103 struct megasas_register_set __iomem *regs; 104 regs = instance->reg_set; 105 106 instance->mask_interrupts = 0; 107 /* For Thunderbolt/Invader also clear intr on enable */ 108 writel(~0, ®s->outbound_intr_status); 109 readl(®s->outbound_intr_status); 110 111 writel(~MFI_FUSION_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask); 112 113 /* Dummy readl to force pci flush */ 114 readl(®s->outbound_intr_mask); 115 } 116 117 /** 118 * megasas_disable_intr_fusion - Disables interrupt 119 * @regs: MFI register set 120 */ 121 void 122 megasas_disable_intr_fusion(struct megasas_instance *instance) 123 { 124 u32 mask = 0xFFFFFFFF; 125 u32 status; 126 struct megasas_register_set __iomem *regs; 127 regs = instance->reg_set; 128 instance->mask_interrupts = 1; 129 130 writel(mask, ®s->outbound_intr_mask); 131 /* Dummy readl to force pci flush */ 132 status = readl(®s->outbound_intr_mask); 133 } 134 135 int 136 megasas_clear_intr_fusion(struct megasas_register_set __iomem *regs) 137 { 138 u32 status; 139 /* 140 * Check if it is our interrupt 141 */ 142 status = readl(®s->outbound_intr_status); 143 144 if (status & 1) { 145 writel(status, ®s->outbound_intr_status); 146 readl(®s->outbound_intr_status); 147 return 1; 148 } 149 if (!(status & MFI_FUSION_ENABLE_INTERRUPT_MASK)) 150 return 0; 151 152 return 1; 153 } 154 155 /** 156 * megasas_get_cmd_fusion - Get a command from the free pool 157 * @instance: Adapter soft state 158 * 159 * Returns a free command from the pool 160 */ 161 struct megasas_cmd_fusion *megasas_get_cmd_fusion(struct megasas_instance 162 *instance) 163 { 164 unsigned long flags; 165 struct fusion_context *fusion = 166 (struct fusion_context *)instance->ctrl_context; 167 struct megasas_cmd_fusion *cmd = NULL; 168 169 spin_lock_irqsave(&fusion->mpt_pool_lock, flags); 170 171 if (!list_empty(&fusion->cmd_pool)) { 172 cmd = list_entry((&fusion->cmd_pool)->next, 173 struct megasas_cmd_fusion, list); 174 list_del_init(&cmd->list); 175 } else { 176 printk(KERN_ERR "megasas: Command pool (fusion) empty!\n"); 177 } 178 179 spin_unlock_irqrestore(&fusion->mpt_pool_lock, flags); 180 return cmd; 181 } 182 183 /** 184 * megasas_return_cmd_fusion - Return a cmd to free command pool 185 * @instance: Adapter soft state 186 * @cmd: Command packet to be returned to free command pool 187 */ 188 inline void megasas_return_cmd_fusion(struct megasas_instance *instance, 189 struct megasas_cmd_fusion *cmd) 190 { 191 unsigned long flags; 192 struct fusion_context *fusion = 193 (struct fusion_context *)instance->ctrl_context; 194 195 spin_lock_irqsave(&fusion->mpt_pool_lock, flags); 196 197 cmd->scmd = NULL; 198 cmd->sync_cmd_idx = (u32)ULONG_MAX; 199 memset(cmd->io_request, 0, sizeof(struct MPI2_RAID_SCSI_IO_REQUEST)); 200 list_add(&cmd->list, (&fusion->cmd_pool)->next); 201 202 spin_unlock_irqrestore(&fusion->mpt_pool_lock, flags); 203 } 204 205 /** 206 * megasas_return_mfi_mpt_pthr - Return a mfi and mpt to free command pool 207 * @instance: Adapter soft state 208 * @cmd_mfi: MFI Command packet to be returned to free command pool 209 * @cmd_mpt: MPT Command packet to be returned to free command pool 210 */ 211 inline void megasas_return_mfi_mpt_pthr(struct megasas_instance *instance, 212 struct megasas_cmd *cmd_mfi, 213 struct megasas_cmd_fusion *cmd_fusion) 214 { 215 unsigned long flags; 216 217 /* 218 * TO DO: optimize this code and use only one lock instead of two 219 * locks being used currently- mpt_pool_lock is acquired 220 * inside mfi_pool_lock 221 */ 222 spin_lock_irqsave(&instance->mfi_pool_lock, flags); 223 megasas_return_cmd_fusion(instance, cmd_fusion); 224 if (atomic_read(&cmd_mfi->mfi_mpt_pthr) != MFI_MPT_ATTACHED) 225 dev_err(&instance->pdev->dev, "Possible bug from %s %d\n", 226 __func__, __LINE__); 227 atomic_set(&cmd_mfi->mfi_mpt_pthr, MFI_MPT_DETACHED); 228 __megasas_return_cmd(instance, cmd_mfi); 229 spin_unlock_irqrestore(&instance->mfi_pool_lock, flags); 230 } 231 232 /** 233 * megasas_teardown_frame_pool_fusion - Destroy the cmd frame DMA pool 234 * @instance: Adapter soft state 235 */ 236 static void megasas_teardown_frame_pool_fusion( 237 struct megasas_instance *instance) 238 { 239 int i; 240 struct fusion_context *fusion = instance->ctrl_context; 241 242 u16 max_cmd = instance->max_fw_cmds; 243 244 struct megasas_cmd_fusion *cmd; 245 246 if (!fusion->sg_dma_pool || !fusion->sense_dma_pool) { 247 printk(KERN_ERR "megasas: dma pool is null. SG Pool %p, " 248 "sense pool : %p\n", fusion->sg_dma_pool, 249 fusion->sense_dma_pool); 250 return; 251 } 252 253 /* 254 * Return all frames to pool 255 */ 256 for (i = 0; i < max_cmd; i++) { 257 258 cmd = fusion->cmd_list[i]; 259 260 if (cmd->sg_frame) 261 pci_pool_free(fusion->sg_dma_pool, cmd->sg_frame, 262 cmd->sg_frame_phys_addr); 263 264 if (cmd->sense) 265 pci_pool_free(fusion->sense_dma_pool, cmd->sense, 266 cmd->sense_phys_addr); 267 } 268 269 /* 270 * Now destroy the pool itself 271 */ 272 pci_pool_destroy(fusion->sg_dma_pool); 273 pci_pool_destroy(fusion->sense_dma_pool); 274 275 fusion->sg_dma_pool = NULL; 276 fusion->sense_dma_pool = NULL; 277 } 278 279 /** 280 * megasas_free_cmds_fusion - Free all the cmds in the free cmd pool 281 * @instance: Adapter soft state 282 */ 283 void 284 megasas_free_cmds_fusion(struct megasas_instance *instance) 285 { 286 int i; 287 struct fusion_context *fusion = instance->ctrl_context; 288 289 u32 max_cmds, req_sz, reply_sz, io_frames_sz; 290 291 292 req_sz = fusion->request_alloc_sz; 293 reply_sz = fusion->reply_alloc_sz; 294 io_frames_sz = fusion->io_frames_alloc_sz; 295 296 max_cmds = instance->max_fw_cmds; 297 298 /* Free descriptors and request Frames memory */ 299 if (fusion->req_frames_desc) 300 dma_free_coherent(&instance->pdev->dev, req_sz, 301 fusion->req_frames_desc, 302 fusion->req_frames_desc_phys); 303 304 if (fusion->reply_frames_desc) { 305 pci_pool_free(fusion->reply_frames_desc_pool, 306 fusion->reply_frames_desc, 307 fusion->reply_frames_desc_phys); 308 pci_pool_destroy(fusion->reply_frames_desc_pool); 309 } 310 311 if (fusion->io_request_frames) { 312 pci_pool_free(fusion->io_request_frames_pool, 313 fusion->io_request_frames, 314 fusion->io_request_frames_phys); 315 pci_pool_destroy(fusion->io_request_frames_pool); 316 } 317 318 /* Free the Fusion frame pool */ 319 megasas_teardown_frame_pool_fusion(instance); 320 321 /* Free all the commands in the cmd_list */ 322 for (i = 0; i < max_cmds; i++) 323 kfree(fusion->cmd_list[i]); 324 325 /* Free the cmd_list buffer itself */ 326 kfree(fusion->cmd_list); 327 fusion->cmd_list = NULL; 328 329 INIT_LIST_HEAD(&fusion->cmd_pool); 330 } 331 332 /** 333 * megasas_create_frame_pool_fusion - Creates DMA pool for cmd frames 334 * @instance: Adapter soft state 335 * 336 */ 337 static int megasas_create_frame_pool_fusion(struct megasas_instance *instance) 338 { 339 int i; 340 u32 max_cmd; 341 struct fusion_context *fusion; 342 struct megasas_cmd_fusion *cmd; 343 u32 total_sz_chain_frame; 344 345 fusion = instance->ctrl_context; 346 max_cmd = instance->max_fw_cmds; 347 348 total_sz_chain_frame = MEGASAS_MAX_SZ_CHAIN_FRAME; 349 350 /* 351 * Use DMA pool facility provided by PCI layer 352 */ 353 354 fusion->sg_dma_pool = pci_pool_create("megasas sg pool fusion", 355 instance->pdev, 356 total_sz_chain_frame, 4, 357 0); 358 if (!fusion->sg_dma_pool) { 359 printk(KERN_DEBUG "megasas: failed to setup request pool " 360 "fusion\n"); 361 return -ENOMEM; 362 } 363 fusion->sense_dma_pool = pci_pool_create("megasas sense pool fusion", 364 instance->pdev, 365 SCSI_SENSE_BUFFERSIZE, 64, 0); 366 367 if (!fusion->sense_dma_pool) { 368 printk(KERN_DEBUG "megasas: failed to setup sense pool " 369 "fusion\n"); 370 pci_pool_destroy(fusion->sg_dma_pool); 371 fusion->sg_dma_pool = NULL; 372 return -ENOMEM; 373 } 374 375 /* 376 * Allocate and attach a frame to each of the commands in cmd_list 377 */ 378 for (i = 0; i < max_cmd; i++) { 379 380 cmd = fusion->cmd_list[i]; 381 382 cmd->sg_frame = pci_pool_alloc(fusion->sg_dma_pool, 383 GFP_KERNEL, 384 &cmd->sg_frame_phys_addr); 385 386 cmd->sense = pci_pool_alloc(fusion->sense_dma_pool, 387 GFP_KERNEL, &cmd->sense_phys_addr); 388 /* 389 * megasas_teardown_frame_pool_fusion() takes care of freeing 390 * whatever has been allocated 391 */ 392 if (!cmd->sg_frame || !cmd->sense) { 393 printk(KERN_DEBUG "megasas: pci_pool_alloc failed\n"); 394 megasas_teardown_frame_pool_fusion(instance); 395 return -ENOMEM; 396 } 397 } 398 return 0; 399 } 400 401 /** 402 * megasas_alloc_cmds_fusion - Allocates the command packets 403 * @instance: Adapter soft state 404 * 405 * 406 * Each frame has a 32-bit field called context. This context is used to get 407 * back the megasas_cmd_fusion from the frame when a frame gets completed 408 * In this driver, the 32 bit values are the indices into an array cmd_list. 409 * This array is used only to look up the megasas_cmd_fusion given the context. 410 * The free commands themselves are maintained in a linked list called cmd_pool. 411 * 412 * cmds are formed in the io_request and sg_frame members of the 413 * megasas_cmd_fusion. The context field is used to get a request descriptor 414 * and is used as SMID of the cmd. 415 * SMID value range is from 1 to max_fw_cmds. 416 */ 417 int 418 megasas_alloc_cmds_fusion(struct megasas_instance *instance) 419 { 420 int i, j, count; 421 u32 max_cmd, io_frames_sz; 422 struct fusion_context *fusion; 423 struct megasas_cmd_fusion *cmd; 424 union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc; 425 u32 offset; 426 dma_addr_t io_req_base_phys; 427 u8 *io_req_base; 428 429 fusion = instance->ctrl_context; 430 431 max_cmd = instance->max_fw_cmds; 432 433 fusion->req_frames_desc = 434 dma_alloc_coherent(&instance->pdev->dev, 435 fusion->request_alloc_sz, 436 &fusion->req_frames_desc_phys, GFP_KERNEL); 437 438 if (!fusion->req_frames_desc) { 439 printk(KERN_ERR "megasas; Could not allocate memory for " 440 "request_frames\n"); 441 goto fail_req_desc; 442 } 443 444 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1; 445 fusion->reply_frames_desc_pool = 446 pci_pool_create("reply_frames pool", instance->pdev, 447 fusion->reply_alloc_sz * count, 16, 0); 448 449 if (!fusion->reply_frames_desc_pool) { 450 printk(KERN_ERR "megasas; Could not allocate memory for " 451 "reply_frame pool\n"); 452 goto fail_reply_desc; 453 } 454 455 fusion->reply_frames_desc = 456 pci_pool_alloc(fusion->reply_frames_desc_pool, GFP_KERNEL, 457 &fusion->reply_frames_desc_phys); 458 if (!fusion->reply_frames_desc) { 459 printk(KERN_ERR "megasas; Could not allocate memory for " 460 "reply_frame pool\n"); 461 pci_pool_destroy(fusion->reply_frames_desc_pool); 462 goto fail_reply_desc; 463 } 464 465 reply_desc = fusion->reply_frames_desc; 466 for (i = 0; i < fusion->reply_q_depth * count; i++, reply_desc++) 467 reply_desc->Words = ULLONG_MAX; 468 469 io_frames_sz = fusion->io_frames_alloc_sz; 470 471 fusion->io_request_frames_pool = 472 pci_pool_create("io_request_frames pool", instance->pdev, 473 fusion->io_frames_alloc_sz, 16, 0); 474 475 if (!fusion->io_request_frames_pool) { 476 printk(KERN_ERR "megasas: Could not allocate memory for " 477 "io_request_frame pool\n"); 478 goto fail_io_frames; 479 } 480 481 fusion->io_request_frames = 482 pci_pool_alloc(fusion->io_request_frames_pool, GFP_KERNEL, 483 &fusion->io_request_frames_phys); 484 if (!fusion->io_request_frames) { 485 printk(KERN_ERR "megasas: Could not allocate memory for " 486 "io_request_frames frames\n"); 487 pci_pool_destroy(fusion->io_request_frames_pool); 488 goto fail_io_frames; 489 } 490 491 /* 492 * fusion->cmd_list is an array of struct megasas_cmd_fusion pointers. 493 * Allocate the dynamic array first and then allocate individual 494 * commands. 495 */ 496 fusion->cmd_list = kzalloc(sizeof(struct megasas_cmd_fusion *) 497 * max_cmd, GFP_KERNEL); 498 499 if (!fusion->cmd_list) { 500 printk(KERN_DEBUG "megasas: out of memory. Could not alloc " 501 "memory for cmd_list_fusion\n"); 502 goto fail_cmd_list; 503 } 504 505 max_cmd = instance->max_fw_cmds; 506 for (i = 0; i < max_cmd; i++) { 507 fusion->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd_fusion), 508 GFP_KERNEL); 509 if (!fusion->cmd_list[i]) { 510 printk(KERN_ERR "Could not alloc cmd list fusion\n"); 511 512 for (j = 0; j < i; j++) 513 kfree(fusion->cmd_list[j]); 514 515 kfree(fusion->cmd_list); 516 fusion->cmd_list = NULL; 517 goto fail_cmd_list; 518 } 519 } 520 521 /* The first 256 bytes (SMID 0) is not used. Don't add to cmd list */ 522 io_req_base = fusion->io_request_frames + 523 MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE; 524 io_req_base_phys = fusion->io_request_frames_phys + 525 MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE; 526 527 /* 528 * Add all the commands to command pool (fusion->cmd_pool) 529 */ 530 531 /* SMID 0 is reserved. Set SMID/index from 1 */ 532 for (i = 0; i < max_cmd; i++) { 533 cmd = fusion->cmd_list[i]; 534 offset = MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE * i; 535 memset(cmd, 0, sizeof(struct megasas_cmd_fusion)); 536 cmd->index = i + 1; 537 cmd->scmd = NULL; 538 cmd->sync_cmd_idx = (u32)ULONG_MAX; /* Set to Invalid */ 539 cmd->instance = instance; 540 cmd->io_request = 541 (struct MPI2_RAID_SCSI_IO_REQUEST *) 542 (io_req_base + offset); 543 memset(cmd->io_request, 0, 544 sizeof(struct MPI2_RAID_SCSI_IO_REQUEST)); 545 cmd->io_request_phys_addr = io_req_base_phys + offset; 546 547 list_add_tail(&cmd->list, &fusion->cmd_pool); 548 } 549 550 /* 551 * Create a frame pool and assign one frame to each cmd 552 */ 553 if (megasas_create_frame_pool_fusion(instance)) { 554 printk(KERN_DEBUG "megasas: Error creating frame DMA pool\n"); 555 megasas_free_cmds_fusion(instance); 556 goto fail_req_desc; 557 } 558 559 return 0; 560 561 fail_cmd_list: 562 pci_pool_free(fusion->io_request_frames_pool, fusion->io_request_frames, 563 fusion->io_request_frames_phys); 564 pci_pool_destroy(fusion->io_request_frames_pool); 565 fail_io_frames: 566 dma_free_coherent(&instance->pdev->dev, fusion->request_alloc_sz, 567 fusion->reply_frames_desc, 568 fusion->reply_frames_desc_phys); 569 pci_pool_free(fusion->reply_frames_desc_pool, 570 fusion->reply_frames_desc, 571 fusion->reply_frames_desc_phys); 572 pci_pool_destroy(fusion->reply_frames_desc_pool); 573 574 fail_reply_desc: 575 dma_free_coherent(&instance->pdev->dev, fusion->request_alloc_sz, 576 fusion->req_frames_desc, 577 fusion->req_frames_desc_phys); 578 fail_req_desc: 579 return -ENOMEM; 580 } 581 582 /** 583 * wait_and_poll - Issues a polling command 584 * @instance: Adapter soft state 585 * @cmd: Command packet to be issued 586 * 587 * For polling, MFI requires the cmd_status to be set to 0xFF before posting. 588 */ 589 int 590 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd, 591 int seconds) 592 { 593 int i; 594 struct megasas_header *frame_hdr = &cmd->frame->hdr; 595 struct fusion_context *fusion; 596 597 u32 msecs = seconds * 1000; 598 599 fusion = instance->ctrl_context; 600 /* 601 * Wait for cmd_status to change 602 */ 603 for (i = 0; (i < msecs) && (frame_hdr->cmd_status == 0xff); i += 20) { 604 rmb(); 605 msleep(20); 606 } 607 608 if (frame_hdr->cmd_status == 0xff) { 609 if (fusion) 610 megasas_return_mfi_mpt_pthr(instance, cmd, 611 cmd->mpt_pthr_cmd_blocked); 612 return -ETIME; 613 } 614 615 return 0; 616 } 617 618 /** 619 * megasas_ioc_init_fusion - Initializes the FW 620 * @instance: Adapter soft state 621 * 622 * Issues the IOC Init cmd 623 */ 624 int 625 megasas_ioc_init_fusion(struct megasas_instance *instance) 626 { 627 struct megasas_init_frame *init_frame; 628 struct MPI2_IOC_INIT_REQUEST *IOCInitMessage; 629 dma_addr_t ioc_init_handle; 630 struct megasas_cmd *cmd; 631 u8 ret; 632 struct fusion_context *fusion; 633 union MEGASAS_REQUEST_DESCRIPTOR_UNION req_desc; 634 int i; 635 struct megasas_header *frame_hdr; 636 637 fusion = instance->ctrl_context; 638 639 cmd = megasas_get_cmd(instance); 640 641 if (!cmd) { 642 printk(KERN_ERR "Could not allocate cmd for INIT Frame\n"); 643 ret = 1; 644 goto fail_get_cmd; 645 } 646 647 IOCInitMessage = 648 dma_alloc_coherent(&instance->pdev->dev, 649 sizeof(struct MPI2_IOC_INIT_REQUEST), 650 &ioc_init_handle, GFP_KERNEL); 651 652 if (!IOCInitMessage) { 653 printk(KERN_ERR "Could not allocate memory for " 654 "IOCInitMessage\n"); 655 ret = 1; 656 goto fail_fw_init; 657 } 658 659 memset(IOCInitMessage, 0, sizeof(struct MPI2_IOC_INIT_REQUEST)); 660 661 IOCInitMessage->Function = MPI2_FUNCTION_IOC_INIT; 662 IOCInitMessage->WhoInit = MPI2_WHOINIT_HOST_DRIVER; 663 IOCInitMessage->MsgVersion = cpu_to_le16(MPI2_VERSION); 664 IOCInitMessage->HeaderVersion = cpu_to_le16(MPI2_HEADER_VERSION); 665 IOCInitMessage->SystemRequestFrameSize = cpu_to_le16(MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE / 4); 666 667 IOCInitMessage->ReplyDescriptorPostQueueDepth = cpu_to_le16(fusion->reply_q_depth); 668 IOCInitMessage->ReplyDescriptorPostQueueAddress = cpu_to_le64(fusion->reply_frames_desc_phys); 669 IOCInitMessage->SystemRequestFrameBaseAddress = cpu_to_le64(fusion->io_request_frames_phys); 670 IOCInitMessage->HostMSIxVectors = instance->msix_vectors; 671 init_frame = (struct megasas_init_frame *)cmd->frame; 672 memset(init_frame, 0, MEGAMFI_FRAME_SIZE); 673 674 frame_hdr = &cmd->frame->hdr; 675 frame_hdr->cmd_status = 0xFF; 676 frame_hdr->flags |= cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE); 677 678 init_frame->cmd = MFI_CMD_INIT; 679 init_frame->cmd_status = 0xFF; 680 681 /* driver support Extended MSIX */ 682 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) || 683 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) 684 init_frame->driver_operations. 685 mfi_capabilities.support_additional_msix = 1; 686 /* driver supports HA / Remote LUN over Fast Path interface */ 687 init_frame->driver_operations.mfi_capabilities.support_fp_remote_lun 688 = 1; 689 init_frame->driver_operations.mfi_capabilities.support_max_255lds 690 = 1; 691 init_frame->driver_operations.mfi_capabilities.support_ndrive_r1_lb 692 = 1; 693 init_frame->driver_operations.mfi_capabilities.security_protocol_cmds_fw 694 = 1; 695 /* Convert capability to LE32 */ 696 cpu_to_le32s((u32 *)&init_frame->driver_operations.mfi_capabilities); 697 698 init_frame->queue_info_new_phys_addr_hi = 699 cpu_to_le32(upper_32_bits(ioc_init_handle)); 700 init_frame->queue_info_new_phys_addr_lo = 701 cpu_to_le32(lower_32_bits(ioc_init_handle)); 702 init_frame->data_xfer_len = cpu_to_le32(sizeof(struct MPI2_IOC_INIT_REQUEST)); 703 704 req_desc.u.low = cpu_to_le32(lower_32_bits(cmd->frame_phys_addr)); 705 req_desc.u.high = cpu_to_le32(upper_32_bits(cmd->frame_phys_addr)); 706 req_desc.MFAIo.RequestFlags = 707 (MEGASAS_REQ_DESCRIPT_FLAGS_MFA << 708 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 709 710 /* 711 * disable the intr before firing the init frame 712 */ 713 instance->instancet->disable_intr(instance); 714 715 for (i = 0; i < (10 * 1000); i += 20) { 716 if (readl(&instance->reg_set->doorbell) & 1) 717 msleep(20); 718 else 719 break; 720 } 721 722 instance->instancet->fire_cmd(instance, req_desc.u.low, 723 req_desc.u.high, instance->reg_set); 724 725 wait_and_poll(instance, cmd, MFI_POLL_TIMEOUT_SECS); 726 727 frame_hdr = &cmd->frame->hdr; 728 if (frame_hdr->cmd_status != 0) { 729 ret = 1; 730 goto fail_fw_init; 731 } 732 printk(KERN_ERR "megasas:IOC Init cmd success\n"); 733 734 ret = 0; 735 736 fail_fw_init: 737 megasas_return_cmd(instance, cmd); 738 if (IOCInitMessage) 739 dma_free_coherent(&instance->pdev->dev, 740 sizeof(struct MPI2_IOC_INIT_REQUEST), 741 IOCInitMessage, ioc_init_handle); 742 fail_get_cmd: 743 return ret; 744 } 745 746 /* 747 * megasas_get_ld_map_info - Returns FW's ld_map structure 748 * @instance: Adapter soft state 749 * @pend: Pend the command or not 750 * Issues an internal command (DCMD) to get the FW's controller PD 751 * list structure. This information is mainly used to find out SYSTEM 752 * supported by the FW. 753 * dcmd.mbox value setting for MR_DCMD_LD_MAP_GET_INFO 754 * dcmd.mbox.b[0] - number of LDs being sync'd 755 * dcmd.mbox.b[1] - 0 - complete command immediately. 756 * - 1 - pend till config change 757 * dcmd.mbox.b[2] - 0 - supports max 64 lds and uses legacy MR_FW_RAID_MAP 758 * - 1 - supports max MAX_LOGICAL_DRIVES_EXT lds and 759 * uses extended struct MR_FW_RAID_MAP_EXT 760 */ 761 static int 762 megasas_get_ld_map_info(struct megasas_instance *instance) 763 { 764 int ret = 0; 765 struct megasas_cmd *cmd; 766 struct megasas_dcmd_frame *dcmd; 767 void *ci; 768 dma_addr_t ci_h = 0; 769 u32 size_map_info; 770 struct fusion_context *fusion; 771 772 cmd = megasas_get_cmd(instance); 773 774 if (!cmd) { 775 printk(KERN_DEBUG "megasas: Failed to get cmd for map info.\n"); 776 return -ENOMEM; 777 } 778 779 fusion = instance->ctrl_context; 780 781 if (!fusion) { 782 megasas_return_cmd(instance, cmd); 783 return -ENXIO; 784 } 785 786 dcmd = &cmd->frame->dcmd; 787 788 size_map_info = fusion->current_map_sz; 789 790 ci = (void *) fusion->ld_map[(instance->map_id & 1)]; 791 ci_h = fusion->ld_map_phys[(instance->map_id & 1)]; 792 793 if (!ci) { 794 printk(KERN_DEBUG "Failed to alloc mem for ld_map_info\n"); 795 megasas_return_cmd(instance, cmd); 796 return -ENOMEM; 797 } 798 799 memset(ci, 0, fusion->max_map_sz); 800 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 801 #if VD_EXT_DEBUG 802 dev_dbg(&instance->pdev->dev, 803 "%s sending MR_DCMD_LD_MAP_GET_INFO with size %d\n", 804 __func__, cpu_to_le32(size_map_info)); 805 #endif 806 dcmd->cmd = MFI_CMD_DCMD; 807 dcmd->cmd_status = 0xFF; 808 dcmd->sge_count = 1; 809 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ); 810 dcmd->timeout = 0; 811 dcmd->pad_0 = 0; 812 dcmd->data_xfer_len = cpu_to_le32(size_map_info); 813 dcmd->opcode = cpu_to_le32(MR_DCMD_LD_MAP_GET_INFO); 814 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h); 815 dcmd->sgl.sge32[0].length = cpu_to_le32(size_map_info); 816 817 if (instance->ctrl_context && !instance->mask_interrupts) 818 ret = megasas_issue_blocked_cmd(instance, cmd, 819 MEGASAS_BLOCKED_CMD_TIMEOUT); 820 else 821 ret = megasas_issue_polled(instance, cmd); 822 823 if (instance->ctrl_context && cmd->mpt_pthr_cmd_blocked) 824 megasas_return_mfi_mpt_pthr(instance, cmd, 825 cmd->mpt_pthr_cmd_blocked); 826 else 827 megasas_return_cmd(instance, cmd); 828 829 return ret; 830 } 831 832 u8 833 megasas_get_map_info(struct megasas_instance *instance) 834 { 835 struct fusion_context *fusion = instance->ctrl_context; 836 837 fusion->fast_path_io = 0; 838 if (!megasas_get_ld_map_info(instance)) { 839 if (MR_ValidateMapInfo(instance)) { 840 fusion->fast_path_io = 1; 841 return 0; 842 } 843 } 844 return 1; 845 } 846 847 /* 848 * megasas_sync_map_info - Returns FW's ld_map structure 849 * @instance: Adapter soft state 850 * 851 * Issues an internal command (DCMD) to get the FW's controller PD 852 * list structure. This information is mainly used to find out SYSTEM 853 * supported by the FW. 854 */ 855 int 856 megasas_sync_map_info(struct megasas_instance *instance) 857 { 858 int ret = 0, i; 859 struct megasas_cmd *cmd; 860 struct megasas_dcmd_frame *dcmd; 861 u32 size_sync_info, num_lds; 862 struct fusion_context *fusion; 863 struct MR_LD_TARGET_SYNC *ci = NULL; 864 struct MR_DRV_RAID_MAP_ALL *map; 865 struct MR_LD_RAID *raid; 866 struct MR_LD_TARGET_SYNC *ld_sync; 867 dma_addr_t ci_h = 0; 868 u32 size_map_info; 869 870 cmd = megasas_get_cmd(instance); 871 872 if (!cmd) { 873 printk(KERN_DEBUG "megasas: Failed to get cmd for sync" 874 "info.\n"); 875 return -ENOMEM; 876 } 877 878 fusion = instance->ctrl_context; 879 880 if (!fusion) { 881 megasas_return_cmd(instance, cmd); 882 return 1; 883 } 884 885 map = fusion->ld_drv_map[instance->map_id & 1]; 886 887 num_lds = le16_to_cpu(map->raidMap.ldCount); 888 889 dcmd = &cmd->frame->dcmd; 890 891 size_sync_info = sizeof(struct MR_LD_TARGET_SYNC) *num_lds; 892 893 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 894 895 ci = (struct MR_LD_TARGET_SYNC *) 896 fusion->ld_map[(instance->map_id - 1) & 1]; 897 memset(ci, 0, fusion->max_map_sz); 898 899 ci_h = fusion->ld_map_phys[(instance->map_id - 1) & 1]; 900 901 ld_sync = (struct MR_LD_TARGET_SYNC *)ci; 902 903 for (i = 0; i < num_lds; i++, ld_sync++) { 904 raid = MR_LdRaidGet(i, map); 905 ld_sync->targetId = MR_GetLDTgtId(i, map); 906 ld_sync->seqNum = raid->seqNum; 907 } 908 909 size_map_info = fusion->current_map_sz; 910 911 dcmd->cmd = MFI_CMD_DCMD; 912 dcmd->cmd_status = 0xFF; 913 dcmd->sge_count = 1; 914 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_WRITE); 915 dcmd->timeout = 0; 916 dcmd->pad_0 = 0; 917 dcmd->data_xfer_len = cpu_to_le32(size_map_info); 918 dcmd->mbox.b[0] = num_lds; 919 dcmd->mbox.b[1] = MEGASAS_DCMD_MBOX_PEND_FLAG; 920 dcmd->opcode = cpu_to_le32(MR_DCMD_LD_MAP_GET_INFO); 921 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h); 922 dcmd->sgl.sge32[0].length = cpu_to_le32(size_map_info); 923 924 instance->map_update_cmd = cmd; 925 926 instance->instancet->issue_dcmd(instance, cmd); 927 928 return ret; 929 } 930 931 /* 932 * meagasas_display_intel_branding - Display branding string 933 * @instance: per adapter object 934 * 935 * Return nothing. 936 */ 937 static void 938 megasas_display_intel_branding(struct megasas_instance *instance) 939 { 940 if (instance->pdev->subsystem_vendor != PCI_VENDOR_ID_INTEL) 941 return; 942 943 switch (instance->pdev->device) { 944 case PCI_DEVICE_ID_LSI_INVADER: 945 switch (instance->pdev->subsystem_device) { 946 case MEGARAID_INTEL_RS3DC080_SSDID: 947 dev_info(&instance->pdev->dev, "scsi host %d: %s\n", 948 instance->host->host_no, 949 MEGARAID_INTEL_RS3DC080_BRANDING); 950 break; 951 case MEGARAID_INTEL_RS3DC040_SSDID: 952 dev_info(&instance->pdev->dev, "scsi host %d: %s\n", 953 instance->host->host_no, 954 MEGARAID_INTEL_RS3DC040_BRANDING); 955 break; 956 case MEGARAID_INTEL_RS3SC008_SSDID: 957 dev_info(&instance->pdev->dev, "scsi host %d: %s\n", 958 instance->host->host_no, 959 MEGARAID_INTEL_RS3SC008_BRANDING); 960 break; 961 case MEGARAID_INTEL_RS3MC044_SSDID: 962 dev_info(&instance->pdev->dev, "scsi host %d: %s\n", 963 instance->host->host_no, 964 MEGARAID_INTEL_RS3MC044_BRANDING); 965 break; 966 default: 967 break; 968 } 969 break; 970 case PCI_DEVICE_ID_LSI_FURY: 971 switch (instance->pdev->subsystem_device) { 972 case MEGARAID_INTEL_RS3WC080_SSDID: 973 dev_info(&instance->pdev->dev, "scsi host %d: %s\n", 974 instance->host->host_no, 975 MEGARAID_INTEL_RS3WC080_BRANDING); 976 break; 977 case MEGARAID_INTEL_RS3WC040_SSDID: 978 dev_info(&instance->pdev->dev, "scsi host %d: %s\n", 979 instance->host->host_no, 980 MEGARAID_INTEL_RS3WC040_BRANDING); 981 break; 982 default: 983 break; 984 } 985 break; 986 default: 987 break; 988 } 989 } 990 991 /** 992 * megasas_init_adapter_fusion - Initializes the FW 993 * @instance: Adapter soft state 994 * 995 * This is the main function for initializing firmware. 996 */ 997 u32 998 megasas_init_adapter_fusion(struct megasas_instance *instance) 999 { 1000 struct megasas_register_set __iomem *reg_set; 1001 struct fusion_context *fusion; 1002 u32 max_cmd; 1003 int i = 0, count; 1004 1005 fusion = instance->ctrl_context; 1006 1007 reg_set = instance->reg_set; 1008 1009 /* 1010 * Get various operational parameters from status register 1011 */ 1012 instance->max_fw_cmds = 1013 instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF; 1014 instance->max_fw_cmds = min(instance->max_fw_cmds, (u16)1008); 1015 1016 /* 1017 * Reduce the max supported cmds by 1. This is to ensure that the 1018 * reply_q_sz (1 more than the max cmd that driver may send) 1019 * does not exceed max cmds that the FW can support 1020 */ 1021 instance->max_fw_cmds = instance->max_fw_cmds-1; 1022 1023 /* 1024 * Only Driver's internal DCMDs and IOCTL DCMDs needs to have MFI frames 1025 */ 1026 instance->max_mfi_cmds = 1027 MEGASAS_FUSION_INTERNAL_CMDS + MEGASAS_FUSION_IOCTL_CMDS; 1028 1029 max_cmd = instance->max_fw_cmds; 1030 1031 fusion->reply_q_depth = 2 * (((max_cmd + 1 + 15)/16)*16); 1032 1033 fusion->request_alloc_sz = 1034 sizeof(union MEGASAS_REQUEST_DESCRIPTOR_UNION) *max_cmd; 1035 fusion->reply_alloc_sz = sizeof(union MPI2_REPLY_DESCRIPTORS_UNION) 1036 *(fusion->reply_q_depth); 1037 fusion->io_frames_alloc_sz = MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE + 1038 (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE * 1039 (max_cmd + 1)); /* Extra 1 for SMID 0 */ 1040 1041 fusion->max_sge_in_main_msg = 1042 (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE - 1043 offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL))/16; 1044 1045 fusion->max_sge_in_chain = 1046 MEGASAS_MAX_SZ_CHAIN_FRAME / sizeof(union MPI2_SGE_IO_UNION); 1047 1048 instance->max_num_sge = rounddown_pow_of_two( 1049 fusion->max_sge_in_main_msg + fusion->max_sge_in_chain - 2); 1050 1051 /* Used for pass thru MFI frame (DCMD) */ 1052 fusion->chain_offset_mfi_pthru = 1053 offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL)/16; 1054 1055 fusion->chain_offset_io_request = 1056 (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE - 1057 sizeof(union MPI2_SGE_IO_UNION))/16; 1058 1059 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1; 1060 for (i = 0 ; i < count; i++) 1061 fusion->last_reply_idx[i] = 0; 1062 1063 /* 1064 * Allocate memory for descriptors 1065 * Create a pool of commands 1066 */ 1067 if (megasas_alloc_cmds(instance)) 1068 goto fail_alloc_mfi_cmds; 1069 if (megasas_alloc_cmds_fusion(instance)) 1070 goto fail_alloc_cmds; 1071 1072 if (megasas_ioc_init_fusion(instance)) 1073 goto fail_ioc_init; 1074 1075 megasas_display_intel_branding(instance); 1076 if (megasas_get_ctrl_info(instance)) { 1077 dev_err(&instance->pdev->dev, 1078 "Could not get controller info. Fail from %s %d\n", 1079 __func__, __LINE__); 1080 goto fail_ioc_init; 1081 } 1082 1083 instance->flag_ieee = 1; 1084 fusion->fast_path_io = 0; 1085 1086 fusion->drv_map_pages = get_order(fusion->drv_map_sz); 1087 for (i = 0; i < 2; i++) { 1088 fusion->ld_map[i] = NULL; 1089 fusion->ld_drv_map[i] = (void *)__get_free_pages(GFP_KERNEL, 1090 fusion->drv_map_pages); 1091 if (!fusion->ld_drv_map[i]) { 1092 dev_err(&instance->pdev->dev, "Could not allocate " 1093 "memory for local map info for %d pages\n", 1094 fusion->drv_map_pages); 1095 if (i == 1) 1096 free_pages((ulong)fusion->ld_drv_map[0], 1097 fusion->drv_map_pages); 1098 goto fail_ioc_init; 1099 } 1100 memset(fusion->ld_drv_map[i], 0, 1101 ((1 << PAGE_SHIFT) << fusion->drv_map_pages)); 1102 } 1103 1104 for (i = 0; i < 2; i++) { 1105 fusion->ld_map[i] = dma_alloc_coherent(&instance->pdev->dev, 1106 fusion->max_map_sz, 1107 &fusion->ld_map_phys[i], 1108 GFP_KERNEL); 1109 if (!fusion->ld_map[i]) { 1110 printk(KERN_ERR "megasas: Could not allocate memory " 1111 "for map info\n"); 1112 goto fail_map_info; 1113 } 1114 } 1115 1116 if (!megasas_get_map_info(instance)) 1117 megasas_sync_map_info(instance); 1118 1119 return 0; 1120 1121 fail_map_info: 1122 if (i == 1) 1123 dma_free_coherent(&instance->pdev->dev, fusion->max_map_sz, 1124 fusion->ld_map[0], fusion->ld_map_phys[0]); 1125 fail_ioc_init: 1126 megasas_free_cmds_fusion(instance); 1127 fail_alloc_cmds: 1128 megasas_free_cmds(instance); 1129 fail_alloc_mfi_cmds: 1130 return 1; 1131 } 1132 1133 /** 1134 * megasas_fire_cmd_fusion - Sends command to the FW 1135 * @frame_phys_addr : Physical address of cmd 1136 * @frame_count : Number of frames for the command 1137 * @regs : MFI register set 1138 */ 1139 void 1140 megasas_fire_cmd_fusion(struct megasas_instance *instance, 1141 dma_addr_t req_desc_lo, 1142 u32 req_desc_hi, 1143 struct megasas_register_set __iomem *regs) 1144 { 1145 #if defined(writeq) && defined(CONFIG_64BIT) 1146 u64 req_data = (((u64)le32_to_cpu(req_desc_hi) << 32) | 1147 le32_to_cpu(req_desc_lo)); 1148 1149 writeq(req_data, &(regs)->inbound_low_queue_port); 1150 #else 1151 unsigned long flags; 1152 1153 spin_lock_irqsave(&instance->hba_lock, flags); 1154 1155 writel(le32_to_cpu(req_desc_lo), &(regs)->inbound_low_queue_port); 1156 writel(le32_to_cpu(req_desc_hi), &(regs)->inbound_high_queue_port); 1157 spin_unlock_irqrestore(&instance->hba_lock, flags); 1158 #endif 1159 } 1160 1161 /** 1162 * map_cmd_status - Maps FW cmd status to OS cmd status 1163 * @cmd : Pointer to cmd 1164 * @status : status of cmd returned by FW 1165 * @ext_status : ext status of cmd returned by FW 1166 */ 1167 1168 void 1169 map_cmd_status(struct megasas_cmd_fusion *cmd, u8 status, u8 ext_status) 1170 { 1171 1172 switch (status) { 1173 1174 case MFI_STAT_OK: 1175 cmd->scmd->result = DID_OK << 16; 1176 break; 1177 1178 case MFI_STAT_SCSI_IO_FAILED: 1179 case MFI_STAT_LD_INIT_IN_PROGRESS: 1180 cmd->scmd->result = (DID_ERROR << 16) | ext_status; 1181 break; 1182 1183 case MFI_STAT_SCSI_DONE_WITH_ERROR: 1184 1185 cmd->scmd->result = (DID_OK << 16) | ext_status; 1186 if (ext_status == SAM_STAT_CHECK_CONDITION) { 1187 memset(cmd->scmd->sense_buffer, 0, 1188 SCSI_SENSE_BUFFERSIZE); 1189 memcpy(cmd->scmd->sense_buffer, cmd->sense, 1190 SCSI_SENSE_BUFFERSIZE); 1191 cmd->scmd->result |= DRIVER_SENSE << 24; 1192 } 1193 break; 1194 1195 case MFI_STAT_LD_OFFLINE: 1196 case MFI_STAT_DEVICE_NOT_FOUND: 1197 cmd->scmd->result = DID_BAD_TARGET << 16; 1198 break; 1199 case MFI_STAT_CONFIG_SEQ_MISMATCH: 1200 cmd->scmd->result = DID_IMM_RETRY << 16; 1201 break; 1202 default: 1203 printk(KERN_DEBUG "megasas: FW status %#x\n", status); 1204 cmd->scmd->result = DID_ERROR << 16; 1205 break; 1206 } 1207 } 1208 1209 /** 1210 * megasas_make_sgl_fusion - Prepares 32-bit SGL 1211 * @instance: Adapter soft state 1212 * @scp: SCSI command from the mid-layer 1213 * @sgl_ptr: SGL to be filled in 1214 * @cmd: cmd we are working on 1215 * 1216 * If successful, this function returns the number of SG elements. 1217 */ 1218 static int 1219 megasas_make_sgl_fusion(struct megasas_instance *instance, 1220 struct scsi_cmnd *scp, 1221 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr, 1222 struct megasas_cmd_fusion *cmd) 1223 { 1224 int i, sg_processed, sge_count; 1225 struct scatterlist *os_sgl; 1226 struct fusion_context *fusion; 1227 1228 fusion = instance->ctrl_context; 1229 1230 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) || 1231 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) { 1232 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr_end = sgl_ptr; 1233 sgl_ptr_end += fusion->max_sge_in_main_msg - 1; 1234 sgl_ptr_end->Flags = 0; 1235 } 1236 1237 sge_count = scsi_dma_map(scp); 1238 1239 BUG_ON(sge_count < 0); 1240 1241 if (sge_count > instance->max_num_sge || !sge_count) 1242 return sge_count; 1243 1244 scsi_for_each_sg(scp, os_sgl, sge_count, i) { 1245 sgl_ptr->Length = cpu_to_le32(sg_dma_len(os_sgl)); 1246 sgl_ptr->Address = cpu_to_le64(sg_dma_address(os_sgl)); 1247 sgl_ptr->Flags = 0; 1248 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) || 1249 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) { 1250 if (i == sge_count - 1) 1251 sgl_ptr->Flags = IEEE_SGE_FLAGS_END_OF_LIST; 1252 } 1253 sgl_ptr++; 1254 1255 sg_processed = i + 1; 1256 1257 if ((sg_processed == (fusion->max_sge_in_main_msg - 1)) && 1258 (sge_count > fusion->max_sge_in_main_msg)) { 1259 1260 struct MPI25_IEEE_SGE_CHAIN64 *sg_chain; 1261 if ((instance->pdev->device == 1262 PCI_DEVICE_ID_LSI_INVADER) || 1263 (instance->pdev->device == 1264 PCI_DEVICE_ID_LSI_FURY)) { 1265 if ((le16_to_cpu(cmd->io_request->IoFlags) & 1266 MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH) != 1267 MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH) 1268 cmd->io_request->ChainOffset = 1269 fusion-> 1270 chain_offset_io_request; 1271 else 1272 cmd->io_request->ChainOffset = 0; 1273 } else 1274 cmd->io_request->ChainOffset = 1275 fusion->chain_offset_io_request; 1276 1277 sg_chain = sgl_ptr; 1278 /* Prepare chain element */ 1279 sg_chain->NextChainOffset = 0; 1280 if ((instance->pdev->device == 1281 PCI_DEVICE_ID_LSI_INVADER) || 1282 (instance->pdev->device == 1283 PCI_DEVICE_ID_LSI_FURY)) 1284 sg_chain->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT; 1285 else 1286 sg_chain->Flags = 1287 (IEEE_SGE_FLAGS_CHAIN_ELEMENT | 1288 MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR); 1289 sg_chain->Length = cpu_to_le32((sizeof(union MPI2_SGE_IO_UNION) * (sge_count - sg_processed))); 1290 sg_chain->Address = cpu_to_le64(cmd->sg_frame_phys_addr); 1291 1292 sgl_ptr = 1293 (struct MPI25_IEEE_SGE_CHAIN64 *)cmd->sg_frame; 1294 memset(sgl_ptr, 0, MEGASAS_MAX_SZ_CHAIN_FRAME); 1295 } 1296 } 1297 1298 return sge_count; 1299 } 1300 1301 /** 1302 * megasas_set_pd_lba - Sets PD LBA 1303 * @cdb: CDB 1304 * @cdb_len: cdb length 1305 * @start_blk: Start block of IO 1306 * 1307 * Used to set the PD LBA in CDB for FP IOs 1308 */ 1309 void 1310 megasas_set_pd_lba(struct MPI2_RAID_SCSI_IO_REQUEST *io_request, u8 cdb_len, 1311 struct IO_REQUEST_INFO *io_info, struct scsi_cmnd *scp, 1312 struct MR_DRV_RAID_MAP_ALL *local_map_ptr, u32 ref_tag) 1313 { 1314 struct MR_LD_RAID *raid; 1315 u32 ld; 1316 u64 start_blk = io_info->pdBlock; 1317 u8 *cdb = io_request->CDB.CDB32; 1318 u32 num_blocks = io_info->numBlocks; 1319 u8 opcode = 0, flagvals = 0, groupnum = 0, control = 0; 1320 1321 /* Check if T10 PI (DIF) is enabled for this LD */ 1322 ld = MR_TargetIdToLdGet(io_info->ldTgtId, local_map_ptr); 1323 raid = MR_LdRaidGet(ld, local_map_ptr); 1324 if (raid->capability.ldPiMode == MR_PROT_INFO_TYPE_CONTROLLER) { 1325 memset(cdb, 0, sizeof(io_request->CDB.CDB32)); 1326 cdb[0] = MEGASAS_SCSI_VARIABLE_LENGTH_CMD; 1327 cdb[7] = MEGASAS_SCSI_ADDL_CDB_LEN; 1328 1329 if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) 1330 cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_READ32; 1331 else 1332 cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_WRITE32; 1333 cdb[10] = MEGASAS_RD_WR_PROTECT_CHECK_ALL; 1334 1335 /* LBA */ 1336 cdb[12] = (u8)((start_blk >> 56) & 0xff); 1337 cdb[13] = (u8)((start_blk >> 48) & 0xff); 1338 cdb[14] = (u8)((start_blk >> 40) & 0xff); 1339 cdb[15] = (u8)((start_blk >> 32) & 0xff); 1340 cdb[16] = (u8)((start_blk >> 24) & 0xff); 1341 cdb[17] = (u8)((start_blk >> 16) & 0xff); 1342 cdb[18] = (u8)((start_blk >> 8) & 0xff); 1343 cdb[19] = (u8)(start_blk & 0xff); 1344 1345 /* Logical block reference tag */ 1346 io_request->CDB.EEDP32.PrimaryReferenceTag = 1347 cpu_to_be32(ref_tag); 1348 io_request->CDB.EEDP32.PrimaryApplicationTagMask = cpu_to_be16(0xffff); 1349 io_request->IoFlags = cpu_to_le16(32); /* Specify 32-byte cdb */ 1350 1351 /* Transfer length */ 1352 cdb[28] = (u8)((num_blocks >> 24) & 0xff); 1353 cdb[29] = (u8)((num_blocks >> 16) & 0xff); 1354 cdb[30] = (u8)((num_blocks >> 8) & 0xff); 1355 cdb[31] = (u8)(num_blocks & 0xff); 1356 1357 /* set SCSI IO EEDPFlags */ 1358 if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) { 1359 io_request->EEDPFlags = cpu_to_le16( 1360 MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG | 1361 MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG | 1362 MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP | 1363 MPI2_SCSIIO_EEDPFLAGS_CHECK_APPTAG | 1364 MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD); 1365 } else { 1366 io_request->EEDPFlags = cpu_to_le16( 1367 MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG | 1368 MPI2_SCSIIO_EEDPFLAGS_INSERT_OP); 1369 } 1370 io_request->Control |= cpu_to_le32((0x4 << 26)); 1371 io_request->EEDPBlockSize = cpu_to_le32(scp->device->sector_size); 1372 } else { 1373 /* Some drives don't support 16/12 byte CDB's, convert to 10 */ 1374 if (((cdb_len == 12) || (cdb_len == 16)) && 1375 (start_blk <= 0xffffffff)) { 1376 if (cdb_len == 16) { 1377 opcode = cdb[0] == READ_16 ? READ_10 : WRITE_10; 1378 flagvals = cdb[1]; 1379 groupnum = cdb[14]; 1380 control = cdb[15]; 1381 } else { 1382 opcode = cdb[0] == READ_12 ? READ_10 : WRITE_10; 1383 flagvals = cdb[1]; 1384 groupnum = cdb[10]; 1385 control = cdb[11]; 1386 } 1387 1388 memset(cdb, 0, sizeof(io_request->CDB.CDB32)); 1389 1390 cdb[0] = opcode; 1391 cdb[1] = flagvals; 1392 cdb[6] = groupnum; 1393 cdb[9] = control; 1394 1395 /* Transfer length */ 1396 cdb[8] = (u8)(num_blocks & 0xff); 1397 cdb[7] = (u8)((num_blocks >> 8) & 0xff); 1398 1399 io_request->IoFlags = cpu_to_le16(10); /* Specify 10-byte cdb */ 1400 cdb_len = 10; 1401 } else if ((cdb_len < 16) && (start_blk > 0xffffffff)) { 1402 /* Convert to 16 byte CDB for large LBA's */ 1403 switch (cdb_len) { 1404 case 6: 1405 opcode = cdb[0] == READ_6 ? READ_16 : WRITE_16; 1406 control = cdb[5]; 1407 break; 1408 case 10: 1409 opcode = 1410 cdb[0] == READ_10 ? READ_16 : WRITE_16; 1411 flagvals = cdb[1]; 1412 groupnum = cdb[6]; 1413 control = cdb[9]; 1414 break; 1415 case 12: 1416 opcode = 1417 cdb[0] == READ_12 ? READ_16 : WRITE_16; 1418 flagvals = cdb[1]; 1419 groupnum = cdb[10]; 1420 control = cdb[11]; 1421 break; 1422 } 1423 1424 memset(cdb, 0, sizeof(io_request->CDB.CDB32)); 1425 1426 cdb[0] = opcode; 1427 cdb[1] = flagvals; 1428 cdb[14] = groupnum; 1429 cdb[15] = control; 1430 1431 /* Transfer length */ 1432 cdb[13] = (u8)(num_blocks & 0xff); 1433 cdb[12] = (u8)((num_blocks >> 8) & 0xff); 1434 cdb[11] = (u8)((num_blocks >> 16) & 0xff); 1435 cdb[10] = (u8)((num_blocks >> 24) & 0xff); 1436 1437 io_request->IoFlags = cpu_to_le16(16); /* Specify 16-byte cdb */ 1438 cdb_len = 16; 1439 } 1440 1441 /* Normal case, just load LBA here */ 1442 switch (cdb_len) { 1443 case 6: 1444 { 1445 u8 val = cdb[1] & 0xE0; 1446 cdb[3] = (u8)(start_blk & 0xff); 1447 cdb[2] = (u8)((start_blk >> 8) & 0xff); 1448 cdb[1] = val | ((u8)(start_blk >> 16) & 0x1f); 1449 break; 1450 } 1451 case 10: 1452 cdb[5] = (u8)(start_blk & 0xff); 1453 cdb[4] = (u8)((start_blk >> 8) & 0xff); 1454 cdb[3] = (u8)((start_blk >> 16) & 0xff); 1455 cdb[2] = (u8)((start_blk >> 24) & 0xff); 1456 break; 1457 case 12: 1458 cdb[5] = (u8)(start_blk & 0xff); 1459 cdb[4] = (u8)((start_blk >> 8) & 0xff); 1460 cdb[3] = (u8)((start_blk >> 16) & 0xff); 1461 cdb[2] = (u8)((start_blk >> 24) & 0xff); 1462 break; 1463 case 16: 1464 cdb[9] = (u8)(start_blk & 0xff); 1465 cdb[8] = (u8)((start_blk >> 8) & 0xff); 1466 cdb[7] = (u8)((start_blk >> 16) & 0xff); 1467 cdb[6] = (u8)((start_blk >> 24) & 0xff); 1468 cdb[5] = (u8)((start_blk >> 32) & 0xff); 1469 cdb[4] = (u8)((start_blk >> 40) & 0xff); 1470 cdb[3] = (u8)((start_blk >> 48) & 0xff); 1471 cdb[2] = (u8)((start_blk >> 56) & 0xff); 1472 break; 1473 } 1474 } 1475 } 1476 1477 /** 1478 * megasas_build_ldio_fusion - Prepares IOs to devices 1479 * @instance: Adapter soft state 1480 * @scp: SCSI command 1481 * @cmd: Command to be prepared 1482 * 1483 * Prepares the io_request and chain elements (sg_frame) for IO 1484 * The IO can be for PD (Fast Path) or LD 1485 */ 1486 void 1487 megasas_build_ldio_fusion(struct megasas_instance *instance, 1488 struct scsi_cmnd *scp, 1489 struct megasas_cmd_fusion *cmd) 1490 { 1491 u8 fp_possible; 1492 u32 start_lba_lo, start_lba_hi, device_id, datalength = 0; 1493 struct MPI2_RAID_SCSI_IO_REQUEST *io_request; 1494 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc; 1495 struct IO_REQUEST_INFO io_info; 1496 struct fusion_context *fusion; 1497 struct MR_DRV_RAID_MAP_ALL *local_map_ptr; 1498 u8 *raidLUN; 1499 1500 device_id = MEGASAS_DEV_INDEX(instance, scp); 1501 1502 fusion = instance->ctrl_context; 1503 1504 io_request = cmd->io_request; 1505 io_request->RaidContext.VirtualDiskTgtId = cpu_to_le16(device_id); 1506 io_request->RaidContext.status = 0; 1507 io_request->RaidContext.exStatus = 0; 1508 1509 req_desc = (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)cmd->request_desc; 1510 1511 start_lba_lo = 0; 1512 start_lba_hi = 0; 1513 fp_possible = 0; 1514 1515 /* 1516 * 6-byte READ(0x08) or WRITE(0x0A) cdb 1517 */ 1518 if (scp->cmd_len == 6) { 1519 datalength = (u32) scp->cmnd[4]; 1520 start_lba_lo = ((u32) scp->cmnd[1] << 16) | 1521 ((u32) scp->cmnd[2] << 8) | (u32) scp->cmnd[3]; 1522 1523 start_lba_lo &= 0x1FFFFF; 1524 } 1525 1526 /* 1527 * 10-byte READ(0x28) or WRITE(0x2A) cdb 1528 */ 1529 else if (scp->cmd_len == 10) { 1530 datalength = (u32) scp->cmnd[8] | 1531 ((u32) scp->cmnd[7] << 8); 1532 start_lba_lo = ((u32) scp->cmnd[2] << 24) | 1533 ((u32) scp->cmnd[3] << 16) | 1534 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5]; 1535 } 1536 1537 /* 1538 * 12-byte READ(0xA8) or WRITE(0xAA) cdb 1539 */ 1540 else if (scp->cmd_len == 12) { 1541 datalength = ((u32) scp->cmnd[6] << 24) | 1542 ((u32) scp->cmnd[7] << 16) | 1543 ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9]; 1544 start_lba_lo = ((u32) scp->cmnd[2] << 24) | 1545 ((u32) scp->cmnd[3] << 16) | 1546 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5]; 1547 } 1548 1549 /* 1550 * 16-byte READ(0x88) or WRITE(0x8A) cdb 1551 */ 1552 else if (scp->cmd_len == 16) { 1553 datalength = ((u32) scp->cmnd[10] << 24) | 1554 ((u32) scp->cmnd[11] << 16) | 1555 ((u32) scp->cmnd[12] << 8) | (u32) scp->cmnd[13]; 1556 start_lba_lo = ((u32) scp->cmnd[6] << 24) | 1557 ((u32) scp->cmnd[7] << 16) | 1558 ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9]; 1559 1560 start_lba_hi = ((u32) scp->cmnd[2] << 24) | 1561 ((u32) scp->cmnd[3] << 16) | 1562 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5]; 1563 } 1564 1565 memset(&io_info, 0, sizeof(struct IO_REQUEST_INFO)); 1566 io_info.ldStartBlock = ((u64)start_lba_hi << 32) | start_lba_lo; 1567 io_info.numBlocks = datalength; 1568 io_info.ldTgtId = device_id; 1569 io_request->DataLength = cpu_to_le32(scsi_bufflen(scp)); 1570 1571 if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) 1572 io_info.isRead = 1; 1573 1574 local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)]; 1575 1576 if ((MR_TargetIdToLdGet(device_id, local_map_ptr) >= 1577 instance->fw_supported_vd_count) || (!fusion->fast_path_io)) { 1578 io_request->RaidContext.regLockFlags = 0; 1579 fp_possible = 0; 1580 } else { 1581 if (MR_BuildRaidContext(instance, &io_info, 1582 &io_request->RaidContext, 1583 local_map_ptr, &raidLUN)) 1584 fp_possible = io_info.fpOkForIo; 1585 } 1586 1587 /* Use raw_smp_processor_id() for now until cmd->request->cpu is CPU 1588 id by default, not CPU group id, otherwise all MSI-X queues won't 1589 be utilized */ 1590 cmd->request_desc->SCSIIO.MSIxIndex = instance->msix_vectors ? 1591 raw_smp_processor_id() % instance->msix_vectors : 0; 1592 1593 if (fp_possible) { 1594 megasas_set_pd_lba(io_request, scp->cmd_len, &io_info, scp, 1595 local_map_ptr, start_lba_lo); 1596 io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST; 1597 cmd->request_desc->SCSIIO.RequestFlags = 1598 (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY 1599 << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1600 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) || 1601 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) { 1602 if (io_request->RaidContext.regLockFlags == 1603 REGION_TYPE_UNUSED) 1604 cmd->request_desc->SCSIIO.RequestFlags = 1605 (MEGASAS_REQ_DESCRIPT_FLAGS_NO_LOCK << 1606 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1607 io_request->RaidContext.Type = MPI2_TYPE_CUDA; 1608 io_request->RaidContext.nseg = 0x1; 1609 io_request->IoFlags |= cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH); 1610 io_request->RaidContext.regLockFlags |= 1611 (MR_RL_FLAGS_GRANT_DESTINATION_CUDA | 1612 MR_RL_FLAGS_SEQ_NUM_ENABLE); 1613 } 1614 if ((fusion->load_balance_info[device_id].loadBalanceFlag) && 1615 (io_info.isRead)) { 1616 io_info.devHandle = 1617 get_updated_dev_handle(instance, 1618 &fusion->load_balance_info[device_id], 1619 &io_info); 1620 scp->SCp.Status |= MEGASAS_LOAD_BALANCE_FLAG; 1621 cmd->pd_r1_lb = io_info.pd_after_lb; 1622 } else 1623 scp->SCp.Status &= ~MEGASAS_LOAD_BALANCE_FLAG; 1624 cmd->request_desc->SCSIIO.DevHandle = io_info.devHandle; 1625 io_request->DevHandle = io_info.devHandle; 1626 /* populate the LUN field */ 1627 memcpy(io_request->LUN, raidLUN, 8); 1628 } else { 1629 io_request->RaidContext.timeoutValue = 1630 cpu_to_le16(local_map_ptr->raidMap.fpPdIoTimeoutSec); 1631 cmd->request_desc->SCSIIO.RequestFlags = 1632 (MEGASAS_REQ_DESCRIPT_FLAGS_LD_IO 1633 << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1634 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) || 1635 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) { 1636 if (io_request->RaidContext.regLockFlags == 1637 REGION_TYPE_UNUSED) 1638 cmd->request_desc->SCSIIO.RequestFlags = 1639 (MEGASAS_REQ_DESCRIPT_FLAGS_NO_LOCK << 1640 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1641 io_request->RaidContext.Type = MPI2_TYPE_CUDA; 1642 io_request->RaidContext.regLockFlags |= 1643 (MR_RL_FLAGS_GRANT_DESTINATION_CPU0 | 1644 MR_RL_FLAGS_SEQ_NUM_ENABLE); 1645 io_request->RaidContext.nseg = 0x1; 1646 } 1647 io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST; 1648 io_request->DevHandle = cpu_to_le16(device_id); 1649 } /* Not FP */ 1650 } 1651 1652 /** 1653 * megasas_build_dcdb_fusion - Prepares IOs to devices 1654 * @instance: Adapter soft state 1655 * @scp: SCSI command 1656 * @cmd: Command to be prepared 1657 * 1658 * Prepares the io_request frame for non-io cmds 1659 */ 1660 static void 1661 megasas_build_dcdb_fusion(struct megasas_instance *instance, 1662 struct scsi_cmnd *scmd, 1663 struct megasas_cmd_fusion *cmd) 1664 { 1665 u32 device_id; 1666 struct MPI2_RAID_SCSI_IO_REQUEST *io_request; 1667 u16 pd_index = 0; 1668 u16 os_timeout_value; 1669 u16 timeout_limit; 1670 struct MR_DRV_RAID_MAP_ALL *local_map_ptr; 1671 struct fusion_context *fusion = instance->ctrl_context; 1672 u8 span, physArm; 1673 u16 devHandle; 1674 u32 ld, arRef, pd; 1675 struct MR_LD_RAID *raid; 1676 struct RAID_CONTEXT *pRAID_Context; 1677 1678 io_request = cmd->io_request; 1679 device_id = MEGASAS_DEV_INDEX(instance, scmd); 1680 pd_index = (scmd->device->channel * MEGASAS_MAX_DEV_PER_CHANNEL) 1681 +scmd->device->id; 1682 local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)]; 1683 1684 io_request->DataLength = cpu_to_le32(scsi_bufflen(scmd)); 1685 1686 if (scmd->device->channel < MEGASAS_MAX_PD_CHANNELS && 1687 instance->pd_list[pd_index].driveState == MR_PD_STATE_SYSTEM) { 1688 if (fusion->fast_path_io) 1689 io_request->DevHandle = 1690 local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl; 1691 io_request->RaidContext.RAIDFlags = 1692 MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD 1693 << MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT; 1694 cmd->request_desc->SCSIIO.DevHandle = io_request->DevHandle; 1695 cmd->request_desc->SCSIIO.MSIxIndex = 1696 instance->msix_vectors ? 1697 raw_smp_processor_id() % 1698 instance->msix_vectors : 1699 0; 1700 os_timeout_value = scmd->request->timeout / HZ; 1701 1702 if (instance->secure_jbod_support && 1703 (megasas_cmd_type(scmd) == NON_READ_WRITE_SYSPDIO)) { 1704 /* system pd firmware path */ 1705 io_request->Function = 1706 MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST; 1707 cmd->request_desc->SCSIIO.RequestFlags = 1708 (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO << 1709 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1710 io_request->RaidContext.timeoutValue = 1711 cpu_to_le16(os_timeout_value); 1712 } else { 1713 /* system pd Fast Path */ 1714 io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST; 1715 io_request->RaidContext.regLockFlags = 0; 1716 io_request->RaidContext.regLockRowLBA = 0; 1717 io_request->RaidContext.regLockLength = 0; 1718 timeout_limit = (scmd->device->type == TYPE_DISK) ? 1719 255 : 0xFFFF; 1720 io_request->RaidContext.timeoutValue = 1721 cpu_to_le16((os_timeout_value > timeout_limit) ? 1722 timeout_limit : os_timeout_value); 1723 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) || 1724 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) 1725 io_request->IoFlags |= 1726 cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH); 1727 1728 cmd->request_desc->SCSIIO.RequestFlags = 1729 (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY << 1730 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1731 } 1732 } else { 1733 if (scmd->device->channel < MEGASAS_MAX_PD_CHANNELS) 1734 goto NonFastPath; 1735 1736 /* 1737 * For older firmware, Driver should not access ldTgtIdToLd 1738 * beyond index 127 and for Extended VD firmware, ldTgtIdToLd 1739 * should not go beyond 255. 1740 */ 1741 1742 if ((!fusion->fast_path_io) || 1743 (device_id >= instance->fw_supported_vd_count)) 1744 goto NonFastPath; 1745 1746 ld = MR_TargetIdToLdGet(device_id, local_map_ptr); 1747 1748 if (ld >= instance->fw_supported_vd_count) 1749 goto NonFastPath; 1750 1751 raid = MR_LdRaidGet(ld, local_map_ptr); 1752 1753 /* check if this LD is FP capable */ 1754 if (!(raid->capability.fpNonRWCapable)) 1755 /* not FP capable, send as non-FP */ 1756 goto NonFastPath; 1757 1758 /* get RAID_Context pointer */ 1759 pRAID_Context = &io_request->RaidContext; 1760 1761 /* set RAID context values */ 1762 pRAID_Context->regLockFlags = REGION_TYPE_SHARED_READ; 1763 pRAID_Context->timeoutValue = cpu_to_le16(raid->fpIoTimeoutForLd); 1764 pRAID_Context->VirtualDiskTgtId = cpu_to_le16(device_id); 1765 pRAID_Context->regLockRowLBA = 0; 1766 pRAID_Context->regLockLength = 0; 1767 pRAID_Context->configSeqNum = raid->seqNum; 1768 1769 /* get the DevHandle for the PD (since this is 1770 fpNonRWCapable, this is a single disk RAID0) */ 1771 span = physArm = 0; 1772 arRef = MR_LdSpanArrayGet(ld, span, local_map_ptr); 1773 pd = MR_ArPdGet(arRef, physArm, local_map_ptr); 1774 devHandle = MR_PdDevHandleGet(pd, local_map_ptr); 1775 1776 /* build request descriptor */ 1777 cmd->request_desc->SCSIIO.RequestFlags = 1778 (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY << 1779 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1780 cmd->request_desc->SCSIIO.DevHandle = devHandle; 1781 1782 /* populate the LUN field */ 1783 memcpy(io_request->LUN, raid->LUN, 8); 1784 1785 /* build the raidScsiIO structure */ 1786 io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST; 1787 io_request->DevHandle = devHandle; 1788 1789 return; 1790 1791 NonFastPath: 1792 io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST; 1793 io_request->DevHandle = cpu_to_le16(device_id); 1794 cmd->request_desc->SCSIIO.RequestFlags = 1795 (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO << 1796 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1797 } 1798 io_request->RaidContext.VirtualDiskTgtId = cpu_to_le16(device_id); 1799 int_to_scsilun(scmd->device->lun, (struct scsi_lun *)io_request->LUN); 1800 } 1801 1802 /** 1803 * megasas_build_io_fusion - Prepares IOs to devices 1804 * @instance: Adapter soft state 1805 * @scp: SCSI command 1806 * @cmd: Command to be prepared 1807 * 1808 * Invokes helper functions to prepare request frames 1809 * and sets flags appropriate for IO/Non-IO cmd 1810 */ 1811 int 1812 megasas_build_io_fusion(struct megasas_instance *instance, 1813 struct scsi_cmnd *scp, 1814 struct megasas_cmd_fusion *cmd) 1815 { 1816 u32 device_id, sge_count; 1817 struct MPI2_RAID_SCSI_IO_REQUEST *io_request = cmd->io_request; 1818 1819 device_id = MEGASAS_DEV_INDEX(instance, scp); 1820 1821 /* Zero out some fields so they don't get reused */ 1822 memset(io_request->LUN, 0x0, 8); 1823 io_request->CDB.EEDP32.PrimaryReferenceTag = 0; 1824 io_request->CDB.EEDP32.PrimaryApplicationTagMask = 0; 1825 io_request->EEDPFlags = 0; 1826 io_request->Control = 0; 1827 io_request->EEDPBlockSize = 0; 1828 io_request->ChainOffset = 0; 1829 io_request->RaidContext.RAIDFlags = 0; 1830 io_request->RaidContext.Type = 0; 1831 io_request->RaidContext.nseg = 0; 1832 1833 memcpy(io_request->CDB.CDB32, scp->cmnd, scp->cmd_len); 1834 /* 1835 * Just the CDB length,rest of the Flags are zero 1836 * This will be modified for FP in build_ldio_fusion 1837 */ 1838 io_request->IoFlags = cpu_to_le16(scp->cmd_len); 1839 1840 if (megasas_cmd_type(scp) == READ_WRITE_LDIO) 1841 megasas_build_ldio_fusion(instance, scp, cmd); 1842 else 1843 megasas_build_dcdb_fusion(instance, scp, cmd); 1844 1845 /* 1846 * Construct SGL 1847 */ 1848 1849 sge_count = 1850 megasas_make_sgl_fusion(instance, scp, 1851 (struct MPI25_IEEE_SGE_CHAIN64 *) 1852 &io_request->SGL, cmd); 1853 1854 if (sge_count > instance->max_num_sge) { 1855 printk(KERN_ERR "megasas: Error. sge_count (0x%x) exceeds " 1856 "max (0x%x) allowed\n", sge_count, 1857 instance->max_num_sge); 1858 return 1; 1859 } 1860 1861 io_request->RaidContext.numSGE = sge_count; 1862 1863 io_request->SGLFlags = cpu_to_le16(MPI2_SGE_FLAGS_64_BIT_ADDRESSING); 1864 1865 if (scp->sc_data_direction == PCI_DMA_TODEVICE) 1866 io_request->Control |= cpu_to_le32(MPI2_SCSIIO_CONTROL_WRITE); 1867 else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) 1868 io_request->Control |= cpu_to_le32(MPI2_SCSIIO_CONTROL_READ); 1869 1870 io_request->SGLOffset0 = 1871 offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL) / 4; 1872 1873 io_request->SenseBufferLowAddress = cpu_to_le32(cmd->sense_phys_addr); 1874 io_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE; 1875 1876 cmd->scmd = scp; 1877 scp->SCp.ptr = (char *)cmd; 1878 1879 return 0; 1880 } 1881 1882 union MEGASAS_REQUEST_DESCRIPTOR_UNION * 1883 megasas_get_request_descriptor(struct megasas_instance *instance, u16 index) 1884 { 1885 u8 *p; 1886 struct fusion_context *fusion; 1887 1888 if (index >= instance->max_fw_cmds) { 1889 printk(KERN_ERR "megasas: Invalid SMID (0x%x)request for " 1890 "descriptor for scsi%d\n", index, 1891 instance->host->host_no); 1892 return NULL; 1893 } 1894 fusion = instance->ctrl_context; 1895 p = fusion->req_frames_desc 1896 +sizeof(union MEGASAS_REQUEST_DESCRIPTOR_UNION) *index; 1897 1898 return (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)p; 1899 } 1900 1901 /** 1902 * megasas_build_and_issue_cmd_fusion -Main routine for building and 1903 * issuing non IOCTL cmd 1904 * @instance: Adapter soft state 1905 * @scmd: pointer to scsi cmd from OS 1906 */ 1907 static u32 1908 megasas_build_and_issue_cmd_fusion(struct megasas_instance *instance, 1909 struct scsi_cmnd *scmd) 1910 { 1911 struct megasas_cmd_fusion *cmd; 1912 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc; 1913 u32 index; 1914 struct fusion_context *fusion; 1915 1916 fusion = instance->ctrl_context; 1917 1918 cmd = megasas_get_cmd_fusion(instance); 1919 if (!cmd) 1920 return SCSI_MLQUEUE_HOST_BUSY; 1921 1922 index = cmd->index; 1923 1924 req_desc = megasas_get_request_descriptor(instance, index-1); 1925 if (!req_desc) 1926 return 1; 1927 1928 req_desc->Words = 0; 1929 cmd->request_desc = req_desc; 1930 1931 if (megasas_build_io_fusion(instance, scmd, cmd)) { 1932 megasas_return_cmd_fusion(instance, cmd); 1933 printk(KERN_ERR "megasas: Error building command.\n"); 1934 cmd->request_desc = NULL; 1935 return 1; 1936 } 1937 1938 req_desc = cmd->request_desc; 1939 req_desc->SCSIIO.SMID = cpu_to_le16(index); 1940 1941 if (cmd->io_request->ChainOffset != 0 && 1942 cmd->io_request->ChainOffset != 0xF) 1943 printk(KERN_ERR "megasas: The chain offset value is not " 1944 "correct : %x\n", cmd->io_request->ChainOffset); 1945 1946 /* 1947 * Issue the command to the FW 1948 */ 1949 atomic_inc(&instance->fw_outstanding); 1950 1951 instance->instancet->fire_cmd(instance, 1952 req_desc->u.low, req_desc->u.high, 1953 instance->reg_set); 1954 1955 return 0; 1956 } 1957 1958 /** 1959 * complete_cmd_fusion - Completes command 1960 * @instance: Adapter soft state 1961 * Completes all commands that is in reply descriptor queue 1962 */ 1963 int 1964 complete_cmd_fusion(struct megasas_instance *instance, u32 MSIxIndex) 1965 { 1966 union MPI2_REPLY_DESCRIPTORS_UNION *desc; 1967 struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *reply_desc; 1968 struct MPI2_RAID_SCSI_IO_REQUEST *scsi_io_req; 1969 struct fusion_context *fusion; 1970 struct megasas_cmd *cmd_mfi; 1971 struct megasas_cmd_fusion *cmd_fusion; 1972 u16 smid, num_completed; 1973 u8 reply_descript_type; 1974 u32 status, extStatus, device_id; 1975 union desc_value d_val; 1976 struct LD_LOAD_BALANCE_INFO *lbinfo; 1977 int threshold_reply_count = 0; 1978 1979 fusion = instance->ctrl_context; 1980 1981 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) 1982 return IRQ_HANDLED; 1983 1984 desc = fusion->reply_frames_desc; 1985 desc += ((MSIxIndex * fusion->reply_alloc_sz)/ 1986 sizeof(union MPI2_REPLY_DESCRIPTORS_UNION)) + 1987 fusion->last_reply_idx[MSIxIndex]; 1988 1989 reply_desc = (struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc; 1990 1991 d_val.word = desc->Words; 1992 1993 reply_descript_type = reply_desc->ReplyFlags & 1994 MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK; 1995 1996 if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED) 1997 return IRQ_NONE; 1998 1999 num_completed = 0; 2000 2001 while ((d_val.u.low != UINT_MAX) && (d_val.u.high != UINT_MAX)) { 2002 smid = le16_to_cpu(reply_desc->SMID); 2003 2004 cmd_fusion = fusion->cmd_list[smid - 1]; 2005 2006 scsi_io_req = 2007 (struct MPI2_RAID_SCSI_IO_REQUEST *) 2008 cmd_fusion->io_request; 2009 2010 if (cmd_fusion->scmd) 2011 cmd_fusion->scmd->SCp.ptr = NULL; 2012 2013 status = scsi_io_req->RaidContext.status; 2014 extStatus = scsi_io_req->RaidContext.exStatus; 2015 2016 switch (scsi_io_req->Function) { 2017 case MPI2_FUNCTION_SCSI_IO_REQUEST: /*Fast Path IO.*/ 2018 /* Update load balancing info */ 2019 device_id = MEGASAS_DEV_INDEX(instance, 2020 cmd_fusion->scmd); 2021 lbinfo = &fusion->load_balance_info[device_id]; 2022 if (cmd_fusion->scmd->SCp.Status & 2023 MEGASAS_LOAD_BALANCE_FLAG) { 2024 atomic_dec(&lbinfo->scsi_pending_cmds[cmd_fusion->pd_r1_lb]); 2025 cmd_fusion->scmd->SCp.Status &= 2026 ~MEGASAS_LOAD_BALANCE_FLAG; 2027 } 2028 if (reply_descript_type == 2029 MPI2_RPY_DESCRIPT_FLAGS_SCSI_IO_SUCCESS) { 2030 if (megasas_dbg_lvl == 5) 2031 printk(KERN_ERR "\nmegasas: FAST Path " 2032 "IO Success\n"); 2033 } 2034 /* Fall thru and complete IO */ 2035 case MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST: /* LD-IO Path */ 2036 /* Map the FW Cmd Status */ 2037 map_cmd_status(cmd_fusion, status, extStatus); 2038 scsi_dma_unmap(cmd_fusion->scmd); 2039 cmd_fusion->scmd->scsi_done(cmd_fusion->scmd); 2040 scsi_io_req->RaidContext.status = 0; 2041 scsi_io_req->RaidContext.exStatus = 0; 2042 megasas_return_cmd_fusion(instance, cmd_fusion); 2043 atomic_dec(&instance->fw_outstanding); 2044 2045 break; 2046 case MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST: /*MFI command */ 2047 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx]; 2048 2049 if (!cmd_mfi->mpt_pthr_cmd_blocked) { 2050 if (megasas_dbg_lvl == 5) 2051 dev_info(&instance->pdev->dev, 2052 "freeing mfi/mpt pass-through " 2053 "from %s %d\n", 2054 __func__, __LINE__); 2055 megasas_return_mfi_mpt_pthr(instance, cmd_mfi, 2056 cmd_fusion); 2057 } 2058 2059 megasas_complete_cmd(instance, cmd_mfi, DID_OK); 2060 cmd_fusion->flags = 0; 2061 break; 2062 } 2063 2064 fusion->last_reply_idx[MSIxIndex]++; 2065 if (fusion->last_reply_idx[MSIxIndex] >= 2066 fusion->reply_q_depth) 2067 fusion->last_reply_idx[MSIxIndex] = 0; 2068 2069 desc->Words = ULLONG_MAX; 2070 num_completed++; 2071 threshold_reply_count++; 2072 2073 /* Get the next reply descriptor */ 2074 if (!fusion->last_reply_idx[MSIxIndex]) 2075 desc = fusion->reply_frames_desc + 2076 ((MSIxIndex * fusion->reply_alloc_sz)/ 2077 sizeof(union MPI2_REPLY_DESCRIPTORS_UNION)); 2078 else 2079 desc++; 2080 2081 reply_desc = 2082 (struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc; 2083 2084 d_val.word = desc->Words; 2085 2086 reply_descript_type = reply_desc->ReplyFlags & 2087 MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK; 2088 2089 if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED) 2090 break; 2091 /* 2092 * Write to reply post host index register after completing threshold 2093 * number of reply counts and still there are more replies in reply queue 2094 * pending to be completed 2095 */ 2096 if (threshold_reply_count >= THRESHOLD_REPLY_COUNT) { 2097 if ((instance->pdev->device == 2098 PCI_DEVICE_ID_LSI_INVADER) || 2099 (instance->pdev->device == 2100 PCI_DEVICE_ID_LSI_FURY)) 2101 writel(((MSIxIndex & 0x7) << 24) | 2102 fusion->last_reply_idx[MSIxIndex], 2103 instance->reply_post_host_index_addr[MSIxIndex/8]); 2104 else 2105 writel((MSIxIndex << 24) | 2106 fusion->last_reply_idx[MSIxIndex], 2107 instance->reply_post_host_index_addr[0]); 2108 threshold_reply_count = 0; 2109 } 2110 } 2111 2112 if (!num_completed) 2113 return IRQ_NONE; 2114 2115 wmb(); 2116 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) || 2117 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) 2118 writel(((MSIxIndex & 0x7) << 24) | 2119 fusion->last_reply_idx[MSIxIndex], 2120 instance->reply_post_host_index_addr[MSIxIndex/8]); 2121 else 2122 writel((MSIxIndex << 24) | 2123 fusion->last_reply_idx[MSIxIndex], 2124 instance->reply_post_host_index_addr[0]); 2125 megasas_check_and_restore_queue_depth(instance); 2126 return IRQ_HANDLED; 2127 } 2128 2129 /** 2130 * megasas_complete_cmd_dpc_fusion - Completes command 2131 * @instance: Adapter soft state 2132 * 2133 * Tasklet to complete cmds 2134 */ 2135 void 2136 megasas_complete_cmd_dpc_fusion(unsigned long instance_addr) 2137 { 2138 struct megasas_instance *instance = 2139 (struct megasas_instance *)instance_addr; 2140 unsigned long flags; 2141 u32 count, MSIxIndex; 2142 2143 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1; 2144 2145 /* If we have already declared adapter dead, donot complete cmds */ 2146 spin_lock_irqsave(&instance->hba_lock, flags); 2147 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) { 2148 spin_unlock_irqrestore(&instance->hba_lock, flags); 2149 return; 2150 } 2151 spin_unlock_irqrestore(&instance->hba_lock, flags); 2152 2153 for (MSIxIndex = 0 ; MSIxIndex < count; MSIxIndex++) 2154 complete_cmd_fusion(instance, MSIxIndex); 2155 } 2156 2157 /** 2158 * megasas_isr_fusion - isr entry point 2159 */ 2160 irqreturn_t megasas_isr_fusion(int irq, void *devp) 2161 { 2162 struct megasas_irq_context *irq_context = devp; 2163 struct megasas_instance *instance = irq_context->instance; 2164 u32 mfiStatus, fw_state, dma_state; 2165 2166 if (instance->mask_interrupts) 2167 return IRQ_NONE; 2168 2169 if (!instance->msix_vectors) { 2170 mfiStatus = instance->instancet->clear_intr(instance->reg_set); 2171 if (!mfiStatus) 2172 return IRQ_NONE; 2173 } 2174 2175 /* If we are resetting, bail */ 2176 if (test_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags)) { 2177 instance->instancet->clear_intr(instance->reg_set); 2178 return IRQ_HANDLED; 2179 } 2180 2181 if (!complete_cmd_fusion(instance, irq_context->MSIxIndex)) { 2182 instance->instancet->clear_intr(instance->reg_set); 2183 /* If we didn't complete any commands, check for FW fault */ 2184 fw_state = instance->instancet->read_fw_status_reg( 2185 instance->reg_set) & MFI_STATE_MASK; 2186 dma_state = instance->instancet->read_fw_status_reg 2187 (instance->reg_set) & MFI_STATE_DMADONE; 2188 if (instance->crash_dump_drv_support && 2189 instance->crash_dump_app_support) { 2190 /* Start collecting crash, if DMA bit is done */ 2191 if ((fw_state == MFI_STATE_FAULT) && dma_state) 2192 schedule_work(&instance->crash_init); 2193 else if (fw_state == MFI_STATE_FAULT) 2194 schedule_work(&instance->work_init); 2195 } else if (fw_state == MFI_STATE_FAULT) { 2196 printk(KERN_WARNING "megaraid_sas: Iop2SysDoorbellInt" 2197 "for scsi%d\n", instance->host->host_no); 2198 schedule_work(&instance->work_init); 2199 } 2200 } 2201 2202 return IRQ_HANDLED; 2203 } 2204 2205 /** 2206 * build_mpt_mfi_pass_thru - builds a cmd fo MFI Pass thru 2207 * @instance: Adapter soft state 2208 * mfi_cmd: megasas_cmd pointer 2209 * 2210 */ 2211 u8 2212 build_mpt_mfi_pass_thru(struct megasas_instance *instance, 2213 struct megasas_cmd *mfi_cmd) 2214 { 2215 struct MPI25_IEEE_SGE_CHAIN64 *mpi25_ieee_chain; 2216 struct MPI2_RAID_SCSI_IO_REQUEST *io_req; 2217 struct megasas_cmd_fusion *cmd; 2218 struct fusion_context *fusion; 2219 struct megasas_header *frame_hdr = &mfi_cmd->frame->hdr; 2220 u32 opcode; 2221 2222 cmd = megasas_get_cmd_fusion(instance); 2223 if (!cmd) 2224 return 1; 2225 2226 /* Save the smid. To be used for returning the cmd */ 2227 mfi_cmd->context.smid = cmd->index; 2228 cmd->sync_cmd_idx = mfi_cmd->index; 2229 2230 /* Set this only for Blocked commands */ 2231 opcode = le32_to_cpu(mfi_cmd->frame->dcmd.opcode); 2232 if ((opcode == MR_DCMD_LD_MAP_GET_INFO) 2233 && (mfi_cmd->frame->dcmd.mbox.b[1] == 1)) 2234 mfi_cmd->is_wait_event = 1; 2235 2236 if (opcode == MR_DCMD_CTRL_EVENT_WAIT) 2237 mfi_cmd->is_wait_event = 1; 2238 2239 if (mfi_cmd->is_wait_event) 2240 mfi_cmd->mpt_pthr_cmd_blocked = cmd; 2241 2242 /* 2243 * For cmds where the flag is set, store the flag and check 2244 * on completion. For cmds with this flag, don't call 2245 * megasas_complete_cmd 2246 */ 2247 2248 if (frame_hdr->flags & cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE)) 2249 cmd->flags = MFI_FRAME_DONT_POST_IN_REPLY_QUEUE; 2250 2251 fusion = instance->ctrl_context; 2252 io_req = cmd->io_request; 2253 2254 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) || 2255 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) { 2256 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr_end = 2257 (struct MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL; 2258 sgl_ptr_end += fusion->max_sge_in_main_msg - 1; 2259 sgl_ptr_end->Flags = 0; 2260 } 2261 2262 mpi25_ieee_chain = 2263 (struct MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL.IeeeChain; 2264 2265 io_req->Function = MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST; 2266 io_req->SGLOffset0 = offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, 2267 SGL) / 4; 2268 io_req->ChainOffset = fusion->chain_offset_mfi_pthru; 2269 2270 mpi25_ieee_chain->Address = cpu_to_le64(mfi_cmd->frame_phys_addr); 2271 2272 mpi25_ieee_chain->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT | 2273 MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR; 2274 2275 mpi25_ieee_chain->Length = cpu_to_le32(MEGASAS_MAX_SZ_CHAIN_FRAME); 2276 2277 return 0; 2278 } 2279 2280 /** 2281 * build_mpt_cmd - Calls helper function to build a cmd MFI Pass thru cmd 2282 * @instance: Adapter soft state 2283 * @cmd: mfi cmd to build 2284 * 2285 */ 2286 union MEGASAS_REQUEST_DESCRIPTOR_UNION * 2287 build_mpt_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd) 2288 { 2289 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc; 2290 u16 index; 2291 2292 if (build_mpt_mfi_pass_thru(instance, cmd)) { 2293 printk(KERN_ERR "Couldn't build MFI pass thru cmd\n"); 2294 return NULL; 2295 } 2296 2297 index = cmd->context.smid; 2298 2299 req_desc = megasas_get_request_descriptor(instance, index - 1); 2300 2301 if (!req_desc) 2302 return NULL; 2303 2304 req_desc->Words = 0; 2305 req_desc->SCSIIO.RequestFlags = (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO << 2306 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 2307 2308 req_desc->SCSIIO.SMID = cpu_to_le16(index); 2309 2310 return req_desc; 2311 } 2312 2313 /** 2314 * megasas_issue_dcmd_fusion - Issues a MFI Pass thru cmd 2315 * @instance: Adapter soft state 2316 * @cmd: mfi cmd pointer 2317 * 2318 */ 2319 void 2320 megasas_issue_dcmd_fusion(struct megasas_instance *instance, 2321 struct megasas_cmd *cmd) 2322 { 2323 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc; 2324 2325 req_desc = build_mpt_cmd(instance, cmd); 2326 if (!req_desc) { 2327 printk(KERN_ERR "Couldn't issue MFI pass thru cmd\n"); 2328 return; 2329 } 2330 atomic_set(&cmd->mfi_mpt_pthr, MFI_MPT_ATTACHED); 2331 instance->instancet->fire_cmd(instance, req_desc->u.low, 2332 req_desc->u.high, instance->reg_set); 2333 } 2334 2335 /** 2336 * megasas_release_fusion - Reverses the FW initialization 2337 * @intance: Adapter soft state 2338 */ 2339 void 2340 megasas_release_fusion(struct megasas_instance *instance) 2341 { 2342 megasas_free_cmds(instance); 2343 megasas_free_cmds_fusion(instance); 2344 2345 iounmap(instance->reg_set); 2346 2347 pci_release_selected_regions(instance->pdev, instance->bar); 2348 } 2349 2350 /** 2351 * megasas_read_fw_status_reg_fusion - returns the current FW status value 2352 * @regs: MFI register set 2353 */ 2354 static u32 2355 megasas_read_fw_status_reg_fusion(struct megasas_register_set __iomem *regs) 2356 { 2357 return readl(&(regs)->outbound_scratch_pad); 2358 } 2359 2360 /** 2361 * megasas_alloc_host_crash_buffer - Host buffers for Crash dump collection from Firmware 2362 * @instance: Controller's soft instance 2363 * return: Number of allocated host crash buffers 2364 */ 2365 static void 2366 megasas_alloc_host_crash_buffer(struct megasas_instance *instance) 2367 { 2368 unsigned int i; 2369 2370 instance->crash_buf_pages = get_order(CRASH_DMA_BUF_SIZE); 2371 for (i = 0; i < MAX_CRASH_DUMP_SIZE; i++) { 2372 instance->crash_buf[i] = (void *)__get_free_pages(GFP_KERNEL, 2373 instance->crash_buf_pages); 2374 if (!instance->crash_buf[i]) { 2375 dev_info(&instance->pdev->dev, "Firmware crash dump " 2376 "memory allocation failed at index %d\n", i); 2377 break; 2378 } 2379 memset(instance->crash_buf[i], 0, 2380 ((1 << PAGE_SHIFT) << instance->crash_buf_pages)); 2381 } 2382 instance->drv_buf_alloc = i; 2383 } 2384 2385 /** 2386 * megasas_free_host_crash_buffer - Host buffers for Crash dump collection from Firmware 2387 * @instance: Controller's soft instance 2388 */ 2389 void 2390 megasas_free_host_crash_buffer(struct megasas_instance *instance) 2391 { 2392 unsigned int i 2393 ; 2394 for (i = 0; i < instance->drv_buf_alloc; i++) { 2395 if (instance->crash_buf[i]) 2396 free_pages((ulong)instance->crash_buf[i], 2397 instance->crash_buf_pages); 2398 } 2399 instance->drv_buf_index = 0; 2400 instance->drv_buf_alloc = 0; 2401 instance->fw_crash_state = UNAVAILABLE; 2402 instance->fw_crash_buffer_size = 0; 2403 } 2404 2405 /** 2406 * megasas_adp_reset_fusion - For controller reset 2407 * @regs: MFI register set 2408 */ 2409 static int 2410 megasas_adp_reset_fusion(struct megasas_instance *instance, 2411 struct megasas_register_set __iomem *regs) 2412 { 2413 return 0; 2414 } 2415 2416 /** 2417 * megasas_check_reset_fusion - For controller reset check 2418 * @regs: MFI register set 2419 */ 2420 static int 2421 megasas_check_reset_fusion(struct megasas_instance *instance, 2422 struct megasas_register_set __iomem *regs) 2423 { 2424 return 0; 2425 } 2426 2427 /* This function waits for outstanding commands on fusion to complete */ 2428 int megasas_wait_for_outstanding_fusion(struct megasas_instance *instance, 2429 int iotimeout, int *convert) 2430 { 2431 int i, outstanding, retval = 0, hb_seconds_missed = 0; 2432 u32 fw_state; 2433 2434 for (i = 0; i < resetwaittime; i++) { 2435 /* Check if firmware is in fault state */ 2436 fw_state = instance->instancet->read_fw_status_reg( 2437 instance->reg_set) & MFI_STATE_MASK; 2438 if (fw_state == MFI_STATE_FAULT) { 2439 printk(KERN_WARNING "megasas: Found FW in FAULT state," 2440 " will reset adapter scsi%d.\n", 2441 instance->host->host_no); 2442 retval = 1; 2443 goto out; 2444 } 2445 /* If SR-IOV VF mode & heartbeat timeout, don't wait */ 2446 if (instance->requestorId && !iotimeout) { 2447 retval = 1; 2448 goto out; 2449 } 2450 2451 /* If SR-IOV VF mode & I/O timeout, check for HB timeout */ 2452 if (instance->requestorId && iotimeout) { 2453 if (instance->hb_host_mem->HB.fwCounter != 2454 instance->hb_host_mem->HB.driverCounter) { 2455 instance->hb_host_mem->HB.driverCounter = 2456 instance->hb_host_mem->HB.fwCounter; 2457 hb_seconds_missed = 0; 2458 } else { 2459 hb_seconds_missed++; 2460 if (hb_seconds_missed == 2461 (MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF/HZ)) { 2462 printk(KERN_WARNING "megasas: SR-IOV:" 2463 " Heartbeat never completed " 2464 " while polling during I/O " 2465 " timeout handling for " 2466 "scsi%d.\n", 2467 instance->host->host_no); 2468 *convert = 1; 2469 retval = 1; 2470 goto out; 2471 } 2472 } 2473 } 2474 2475 outstanding = atomic_read(&instance->fw_outstanding); 2476 if (!outstanding) 2477 goto out; 2478 2479 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) { 2480 printk(KERN_NOTICE "megasas: [%2d]waiting for %d " 2481 "commands to complete for scsi%d\n", i, 2482 outstanding, instance->host->host_no); 2483 megasas_complete_cmd_dpc_fusion( 2484 (unsigned long)instance); 2485 } 2486 msleep(1000); 2487 } 2488 2489 if (atomic_read(&instance->fw_outstanding)) { 2490 printk("megaraid_sas: pending commands remain after waiting, " 2491 "will reset adapter scsi%d.\n", 2492 instance->host->host_no); 2493 retval = 1; 2494 } 2495 out: 2496 return retval; 2497 } 2498 2499 void megasas_reset_reply_desc(struct megasas_instance *instance) 2500 { 2501 int i, count; 2502 struct fusion_context *fusion; 2503 union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc; 2504 2505 fusion = instance->ctrl_context; 2506 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1; 2507 for (i = 0 ; i < count ; i++) 2508 fusion->last_reply_idx[i] = 0; 2509 reply_desc = fusion->reply_frames_desc; 2510 for (i = 0 ; i < fusion->reply_q_depth * count; i++, reply_desc++) 2511 reply_desc->Words = ULLONG_MAX; 2512 } 2513 2514 /* Check for a second path that is currently UP */ 2515 int megasas_check_mpio_paths(struct megasas_instance *instance, 2516 struct scsi_cmnd *scmd) 2517 { 2518 int i, j, retval = (DID_RESET << 16); 2519 2520 if (instance->mpio && instance->requestorId) { 2521 for (i = 0 ; i < MAX_MGMT_ADAPTERS ; i++) 2522 for (j = 0 ; j < MAX_LOGICAL_DRIVES; j++) 2523 if (megasas_mgmt_info.instance[i] && 2524 (megasas_mgmt_info.instance[i] != instance) && 2525 megasas_mgmt_info.instance[i]->mpio && 2526 megasas_mgmt_info.instance[i]->requestorId 2527 && 2528 (megasas_mgmt_info.instance[i]->ld_ids[j] 2529 == scmd->device->id)) { 2530 retval = (DID_NO_CONNECT << 16); 2531 goto out; 2532 } 2533 } 2534 out: 2535 return retval; 2536 } 2537 2538 /* Core fusion reset function */ 2539 int megasas_reset_fusion(struct Scsi_Host *shost, int iotimeout) 2540 { 2541 int retval = SUCCESS, i, j, retry = 0, convert = 0; 2542 struct megasas_instance *instance; 2543 struct megasas_cmd_fusion *cmd_fusion; 2544 struct fusion_context *fusion; 2545 struct megasas_cmd *cmd_mfi; 2546 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc; 2547 u32 host_diag, abs_state, status_reg, reset_adapter; 2548 u32 io_timeout_in_crash_mode = 0; 2549 2550 instance = (struct megasas_instance *)shost->hostdata; 2551 fusion = instance->ctrl_context; 2552 2553 mutex_lock(&instance->reset_mutex); 2554 2555 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) { 2556 printk(KERN_WARNING "megaraid_sas: Hardware critical error, " 2557 "returning FAILED for scsi%d.\n", 2558 instance->host->host_no); 2559 mutex_unlock(&instance->reset_mutex); 2560 return FAILED; 2561 } 2562 status_reg = instance->instancet->read_fw_status_reg(instance->reg_set); 2563 abs_state = status_reg & MFI_STATE_MASK; 2564 2565 /* IO timeout detected, forcibly put FW in FAULT state */ 2566 if (abs_state != MFI_STATE_FAULT && instance->crash_dump_buf && 2567 instance->crash_dump_app_support && iotimeout) { 2568 dev_info(&instance->pdev->dev, "IO timeout is detected, " 2569 "forcibly FAULT Firmware\n"); 2570 instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT; 2571 status_reg = readl(&instance->reg_set->doorbell); 2572 writel(status_reg | MFI_STATE_FORCE_OCR, 2573 &instance->reg_set->doorbell); 2574 readl(&instance->reg_set->doorbell); 2575 mutex_unlock(&instance->reset_mutex); 2576 do { 2577 ssleep(3); 2578 io_timeout_in_crash_mode++; 2579 dev_dbg(&instance->pdev->dev, "waiting for [%d] " 2580 "seconds for crash dump collection and OCR " 2581 "to be done\n", (io_timeout_in_crash_mode * 3)); 2582 } while ((instance->adprecovery != MEGASAS_HBA_OPERATIONAL) && 2583 (io_timeout_in_crash_mode < 80)); 2584 2585 if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) { 2586 dev_info(&instance->pdev->dev, "OCR done for IO " 2587 "timeout case\n"); 2588 retval = SUCCESS; 2589 } else { 2590 dev_info(&instance->pdev->dev, "Controller is not " 2591 "operational after 240 seconds wait for IO " 2592 "timeout case in FW crash dump mode\n do " 2593 "OCR/kill adapter\n"); 2594 retval = megasas_reset_fusion(shost, 0); 2595 } 2596 return retval; 2597 } 2598 2599 if (instance->requestorId && !instance->skip_heartbeat_timer_del) 2600 del_timer_sync(&instance->sriov_heartbeat_timer); 2601 set_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags); 2602 instance->adprecovery = MEGASAS_ADPRESET_SM_POLLING; 2603 instance->instancet->disable_intr(instance); 2604 msleep(1000); 2605 2606 /* First try waiting for commands to complete */ 2607 if (megasas_wait_for_outstanding_fusion(instance, iotimeout, 2608 &convert)) { 2609 instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT; 2610 printk(KERN_WARNING "megaraid_sas: resetting fusion " 2611 "adapter scsi%d.\n", instance->host->host_no); 2612 if (convert) 2613 iotimeout = 0; 2614 2615 /* Now return commands back to the OS */ 2616 for (i = 0 ; i < instance->max_fw_cmds; i++) { 2617 cmd_fusion = fusion->cmd_list[i]; 2618 if (cmd_fusion->scmd) { 2619 scsi_dma_unmap(cmd_fusion->scmd); 2620 cmd_fusion->scmd->result = 2621 megasas_check_mpio_paths(instance, 2622 cmd_fusion->scmd); 2623 cmd_fusion->scmd->scsi_done(cmd_fusion->scmd); 2624 megasas_return_cmd_fusion(instance, cmd_fusion); 2625 atomic_dec(&instance->fw_outstanding); 2626 } 2627 } 2628 2629 status_reg = instance->instancet->read_fw_status_reg( 2630 instance->reg_set); 2631 abs_state = status_reg & MFI_STATE_MASK; 2632 reset_adapter = status_reg & MFI_RESET_ADAPTER; 2633 if (instance->disableOnlineCtrlReset || 2634 (abs_state == MFI_STATE_FAULT && !reset_adapter)) { 2635 /* Reset not supported, kill adapter */ 2636 printk(KERN_WARNING "megaraid_sas: Reset not supported" 2637 ", killing adapter scsi%d.\n", 2638 instance->host->host_no); 2639 megaraid_sas_kill_hba(instance); 2640 instance->skip_heartbeat_timer_del = 1; 2641 retval = FAILED; 2642 goto out; 2643 } 2644 2645 /* Let SR-IOV VF & PF sync up if there was a HB failure */ 2646 if (instance->requestorId && !iotimeout) { 2647 msleep(MEGASAS_OCR_SETTLE_TIME_VF); 2648 /* Look for a late HB update after VF settle time */ 2649 if (abs_state == MFI_STATE_OPERATIONAL && 2650 (instance->hb_host_mem->HB.fwCounter != 2651 instance->hb_host_mem->HB.driverCounter)) { 2652 instance->hb_host_mem->HB.driverCounter = 2653 instance->hb_host_mem->HB.fwCounter; 2654 printk(KERN_WARNING "megasas: SR-IOV:" 2655 "Late FW heartbeat update for " 2656 "scsi%d.\n", 2657 instance->host->host_no); 2658 } else { 2659 /* In VF mode, first poll for FW ready */ 2660 for (i = 0; 2661 i < (MEGASAS_RESET_WAIT_TIME * 1000); 2662 i += 20) { 2663 status_reg = 2664 instance->instancet-> 2665 read_fw_status_reg( 2666 instance->reg_set); 2667 abs_state = status_reg & 2668 MFI_STATE_MASK; 2669 if (abs_state == MFI_STATE_READY) { 2670 printk(KERN_WARNING "megasas" 2671 ": SR-IOV: FW was found" 2672 "to be in ready state " 2673 "for scsi%d.\n", 2674 instance->host->host_no); 2675 break; 2676 } 2677 msleep(20); 2678 } 2679 if (abs_state != MFI_STATE_READY) { 2680 printk(KERN_WARNING "megasas: SR-IOV: " 2681 "FW not in ready state after %d" 2682 " seconds for scsi%d, status_reg = " 2683 "0x%x.\n", 2684 MEGASAS_RESET_WAIT_TIME, 2685 instance->host->host_no, 2686 status_reg); 2687 megaraid_sas_kill_hba(instance); 2688 instance->skip_heartbeat_timer_del = 1; 2689 instance->adprecovery = 2690 MEGASAS_HW_CRITICAL_ERROR; 2691 retval = FAILED; 2692 goto out; 2693 } 2694 } 2695 } 2696 2697 /* Now try to reset the chip */ 2698 for (i = 0; i < MEGASAS_FUSION_MAX_RESET_TRIES; i++) { 2699 writel(MPI2_WRSEQ_FLUSH_KEY_VALUE, 2700 &instance->reg_set->fusion_seq_offset); 2701 writel(MPI2_WRSEQ_1ST_KEY_VALUE, 2702 &instance->reg_set->fusion_seq_offset); 2703 writel(MPI2_WRSEQ_2ND_KEY_VALUE, 2704 &instance->reg_set->fusion_seq_offset); 2705 writel(MPI2_WRSEQ_3RD_KEY_VALUE, 2706 &instance->reg_set->fusion_seq_offset); 2707 writel(MPI2_WRSEQ_4TH_KEY_VALUE, 2708 &instance->reg_set->fusion_seq_offset); 2709 writel(MPI2_WRSEQ_5TH_KEY_VALUE, 2710 &instance->reg_set->fusion_seq_offset); 2711 writel(MPI2_WRSEQ_6TH_KEY_VALUE, 2712 &instance->reg_set->fusion_seq_offset); 2713 2714 /* Check that the diag write enable (DRWE) bit is on */ 2715 host_diag = readl(&instance->reg_set->fusion_host_diag); 2716 retry = 0; 2717 while (!(host_diag & HOST_DIAG_WRITE_ENABLE)) { 2718 msleep(100); 2719 host_diag = 2720 readl(&instance->reg_set->fusion_host_diag); 2721 if (retry++ == 100) { 2722 printk(KERN_WARNING "megaraid_sas: " 2723 "Host diag unlock failed! " 2724 "for scsi%d\n", 2725 instance->host->host_no); 2726 break; 2727 } 2728 } 2729 if (!(host_diag & HOST_DIAG_WRITE_ENABLE)) 2730 continue; 2731 2732 /* Send chip reset command */ 2733 writel(host_diag | HOST_DIAG_RESET_ADAPTER, 2734 &instance->reg_set->fusion_host_diag); 2735 msleep(3000); 2736 2737 /* Make sure reset adapter bit is cleared */ 2738 host_diag = readl(&instance->reg_set->fusion_host_diag); 2739 retry = 0; 2740 while (host_diag & HOST_DIAG_RESET_ADAPTER) { 2741 msleep(100); 2742 host_diag = 2743 readl(&instance->reg_set->fusion_host_diag); 2744 if (retry++ == 1000) { 2745 printk(KERN_WARNING "megaraid_sas: " 2746 "Diag reset adapter never " 2747 "cleared for scsi%d!\n", 2748 instance->host->host_no); 2749 break; 2750 } 2751 } 2752 if (host_diag & HOST_DIAG_RESET_ADAPTER) 2753 continue; 2754 2755 abs_state = 2756 instance->instancet->read_fw_status_reg( 2757 instance->reg_set) & MFI_STATE_MASK; 2758 retry = 0; 2759 2760 while ((abs_state <= MFI_STATE_FW_INIT) && 2761 (retry++ < 1000)) { 2762 msleep(100); 2763 abs_state = 2764 instance->instancet->read_fw_status_reg( 2765 instance->reg_set) & MFI_STATE_MASK; 2766 } 2767 if (abs_state <= MFI_STATE_FW_INIT) { 2768 printk(KERN_WARNING "megaraid_sas: firmware " 2769 "state < MFI_STATE_FW_INIT, state = " 2770 "0x%x for scsi%d\n", abs_state, 2771 instance->host->host_no); 2772 continue; 2773 } 2774 2775 /* Wait for FW to become ready */ 2776 if (megasas_transition_to_ready(instance, 1)) { 2777 printk(KERN_WARNING "megaraid_sas: Failed to " 2778 "transition controller to ready " 2779 "for scsi%d.\n", 2780 instance->host->host_no); 2781 continue; 2782 } 2783 2784 megasas_reset_reply_desc(instance); 2785 if (megasas_ioc_init_fusion(instance)) { 2786 printk(KERN_WARNING "megaraid_sas: " 2787 "megasas_ioc_init_fusion() failed!" 2788 " for scsi%d\n", 2789 instance->host->host_no); 2790 continue; 2791 } 2792 2793 /* Re-fire management commands */ 2794 for (j = 0 ; j < instance->max_fw_cmds; j++) { 2795 cmd_fusion = fusion->cmd_list[j]; 2796 if (cmd_fusion->sync_cmd_idx != 2797 (u32)ULONG_MAX) { 2798 cmd_mfi = 2799 instance-> 2800 cmd_list[cmd_fusion->sync_cmd_idx]; 2801 if (cmd_mfi->frame->dcmd.opcode == 2802 cpu_to_le32(MR_DCMD_LD_MAP_GET_INFO)) { 2803 megasas_return_mfi_mpt_pthr(instance, cmd_mfi, cmd_fusion); 2804 } else { 2805 req_desc = 2806 megasas_get_request_descriptor( 2807 instance, 2808 cmd_mfi->context.smid 2809 -1); 2810 if (!req_desc) { 2811 printk(KERN_WARNING 2812 "req_desc NULL" 2813 " for scsi%d\n", 2814 instance->host->host_no); 2815 /* Return leaked MPT 2816 frame */ 2817 megasas_return_cmd_fusion(instance, cmd_fusion); 2818 } else { 2819 instance->instancet-> 2820 fire_cmd(instance, 2821 req_desc-> 2822 u.low, 2823 req_desc-> 2824 u.high, 2825 instance-> 2826 reg_set); 2827 } 2828 } 2829 } 2830 } 2831 2832 if (megasas_get_ctrl_info(instance)) { 2833 dev_info(&instance->pdev->dev, 2834 "Failed from %s %d\n", 2835 __func__, __LINE__); 2836 megaraid_sas_kill_hba(instance); 2837 retval = FAILED; 2838 } 2839 /* Reset load balance info */ 2840 memset(fusion->load_balance_info, 0, 2841 sizeof(struct LD_LOAD_BALANCE_INFO) 2842 *MAX_LOGICAL_DRIVES_EXT); 2843 2844 if (!megasas_get_map_info(instance)) 2845 megasas_sync_map_info(instance); 2846 2847 clear_bit(MEGASAS_FUSION_IN_RESET, 2848 &instance->reset_flags); 2849 instance->instancet->enable_intr(instance); 2850 instance->adprecovery = MEGASAS_HBA_OPERATIONAL; 2851 2852 /* Restart SR-IOV heartbeat */ 2853 if (instance->requestorId) { 2854 if (!megasas_sriov_start_heartbeat(instance, 0)) 2855 megasas_start_timer(instance, 2856 &instance->sriov_heartbeat_timer, 2857 megasas_sriov_heartbeat_handler, 2858 MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF); 2859 else 2860 instance->skip_heartbeat_timer_del = 1; 2861 } 2862 2863 /* Adapter reset completed successfully */ 2864 printk(KERN_WARNING "megaraid_sas: Reset " 2865 "successful for scsi%d.\n", 2866 instance->host->host_no); 2867 2868 if (instance->crash_dump_drv_support && 2869 instance->crash_dump_app_support) 2870 megasas_set_crash_dump_params(instance, 2871 MR_CRASH_BUF_TURN_ON); 2872 else 2873 megasas_set_crash_dump_params(instance, 2874 MR_CRASH_BUF_TURN_OFF); 2875 2876 retval = SUCCESS; 2877 goto out; 2878 } 2879 /* Reset failed, kill the adapter */ 2880 printk(KERN_WARNING "megaraid_sas: Reset failed, killing " 2881 "adapter scsi%d.\n", instance->host->host_no); 2882 megaraid_sas_kill_hba(instance); 2883 instance->skip_heartbeat_timer_del = 1; 2884 retval = FAILED; 2885 } else { 2886 /* For VF: Restart HB timer if we didn't OCR */ 2887 if (instance->requestorId) { 2888 megasas_start_timer(instance, 2889 &instance->sriov_heartbeat_timer, 2890 megasas_sriov_heartbeat_handler, 2891 MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF); 2892 } 2893 clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags); 2894 instance->instancet->enable_intr(instance); 2895 instance->adprecovery = MEGASAS_HBA_OPERATIONAL; 2896 } 2897 out: 2898 clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags); 2899 mutex_unlock(&instance->reset_mutex); 2900 return retval; 2901 } 2902 2903 /* Fusion Crash dump collection work queue */ 2904 void megasas_fusion_crash_dump_wq(struct work_struct *work) 2905 { 2906 struct megasas_instance *instance = 2907 container_of(work, struct megasas_instance, crash_init); 2908 u32 status_reg; 2909 u8 partial_copy = 0; 2910 2911 2912 status_reg = instance->instancet->read_fw_status_reg(instance->reg_set); 2913 2914 /* 2915 * Allocate host crash buffers to copy data from 1 MB DMA crash buffer 2916 * to host crash buffers 2917 */ 2918 if (instance->drv_buf_index == 0) { 2919 /* Buffer is already allocated for old Crash dump. 2920 * Do OCR and do not wait for crash dump collection 2921 */ 2922 if (instance->drv_buf_alloc) { 2923 dev_info(&instance->pdev->dev, "earlier crash dump is " 2924 "not yet copied by application, ignoring this " 2925 "crash dump and initiating OCR\n"); 2926 status_reg |= MFI_STATE_CRASH_DUMP_DONE; 2927 writel(status_reg, 2928 &instance->reg_set->outbound_scratch_pad); 2929 readl(&instance->reg_set->outbound_scratch_pad); 2930 return; 2931 } 2932 megasas_alloc_host_crash_buffer(instance); 2933 dev_info(&instance->pdev->dev, "Number of host crash buffers " 2934 "allocated: %d\n", instance->drv_buf_alloc); 2935 } 2936 2937 /* 2938 * Driver has allocated max buffers, which can be allocated 2939 * and FW has more crash dump data, then driver will 2940 * ignore the data. 2941 */ 2942 if (instance->drv_buf_index >= (instance->drv_buf_alloc)) { 2943 dev_info(&instance->pdev->dev, "Driver is done copying " 2944 "the buffer: %d\n", instance->drv_buf_alloc); 2945 status_reg |= MFI_STATE_CRASH_DUMP_DONE; 2946 partial_copy = 1; 2947 } else { 2948 memcpy(instance->crash_buf[instance->drv_buf_index], 2949 instance->crash_dump_buf, CRASH_DMA_BUF_SIZE); 2950 instance->drv_buf_index++; 2951 status_reg &= ~MFI_STATE_DMADONE; 2952 } 2953 2954 if (status_reg & MFI_STATE_CRASH_DUMP_DONE) { 2955 dev_info(&instance->pdev->dev, "Crash Dump is available,number " 2956 "of copied buffers: %d\n", instance->drv_buf_index); 2957 instance->fw_crash_buffer_size = instance->drv_buf_index; 2958 instance->fw_crash_state = AVAILABLE; 2959 instance->drv_buf_index = 0; 2960 writel(status_reg, &instance->reg_set->outbound_scratch_pad); 2961 readl(&instance->reg_set->outbound_scratch_pad); 2962 if (!partial_copy) 2963 megasas_reset_fusion(instance->host, 0); 2964 } else { 2965 writel(status_reg, &instance->reg_set->outbound_scratch_pad); 2966 readl(&instance->reg_set->outbound_scratch_pad); 2967 } 2968 } 2969 2970 2971 /* Fusion OCR work queue */ 2972 void megasas_fusion_ocr_wq(struct work_struct *work) 2973 { 2974 struct megasas_instance *instance = 2975 container_of(work, struct megasas_instance, work_init); 2976 2977 megasas_reset_fusion(instance->host, 0); 2978 } 2979 2980 struct megasas_instance_template megasas_instance_template_fusion = { 2981 .fire_cmd = megasas_fire_cmd_fusion, 2982 .enable_intr = megasas_enable_intr_fusion, 2983 .disable_intr = megasas_disable_intr_fusion, 2984 .clear_intr = megasas_clear_intr_fusion, 2985 .read_fw_status_reg = megasas_read_fw_status_reg_fusion, 2986 .adp_reset = megasas_adp_reset_fusion, 2987 .check_reset = megasas_check_reset_fusion, 2988 .service_isr = megasas_isr_fusion, 2989 .tasklet = megasas_complete_cmd_dpc_fusion, 2990 .init_adapter = megasas_init_adapter_fusion, 2991 .build_and_issue_cmd = megasas_build_and_issue_cmd_fusion, 2992 .issue_dcmd = megasas_issue_dcmd_fusion, 2993 }; 2994