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