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