1 /* 2 * Linux MegaRAID driver for SAS based RAID controllers 3 * 4 * Copyright (c) 2009-2012 LSI Corporation. 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 2 9 * of the License, or (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 * 20 * FILE: megaraid_sas_fusion.c 21 * 22 * Authors: LSI Corporation 23 * Sumant Patro 24 * Adam Radford <linuxraid@lsi.com> 25 * 26 * Send feedback to: <megaraidlinux@lsi.com> 27 * 28 * Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035 29 * ATTN: Linuxraid 30 */ 31 32 #include <linux/kernel.h> 33 #include <linux/types.h> 34 #include <linux/pci.h> 35 #include <linux/list.h> 36 #include <linux/moduleparam.h> 37 #include <linux/module.h> 38 #include <linux/spinlock.h> 39 #include <linux/interrupt.h> 40 #include <linux/delay.h> 41 #include <linux/uio.h> 42 #include <linux/uaccess.h> 43 #include <linux/fs.h> 44 #include <linux/compat.h> 45 #include <linux/blkdev.h> 46 #include <linux/mutex.h> 47 #include <linux/poll.h> 48 49 #include <scsi/scsi.h> 50 #include <scsi/scsi_cmnd.h> 51 #include <scsi/scsi_device.h> 52 #include <scsi/scsi_host.h> 53 54 #include "megaraid_sas_fusion.h" 55 #include "megaraid_sas.h" 56 57 extern void megasas_free_cmds(struct megasas_instance *instance); 58 extern struct megasas_cmd *megasas_get_cmd(struct megasas_instance 59 *instance); 60 extern void 61 megasas_complete_cmd(struct megasas_instance *instance, 62 struct megasas_cmd *cmd, u8 alt_status); 63 int megasas_is_ldio(struct scsi_cmnd *cmd); 64 int 65 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd); 66 67 void 68 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd); 69 int megasas_alloc_cmds(struct megasas_instance *instance); 70 int 71 megasas_clear_intr_fusion(struct megasas_register_set __iomem *regs); 72 int 73 megasas_issue_polled(struct megasas_instance *instance, 74 struct megasas_cmd *cmd); 75 76 u8 77 MR_BuildRaidContext(struct megasas_instance *instance, 78 struct IO_REQUEST_INFO *io_info, 79 struct RAID_CONTEXT *pRAID_Context, 80 struct MR_FW_RAID_MAP_ALL *map); 81 u16 MR_TargetIdToLdGet(u32 ldTgtId, struct MR_FW_RAID_MAP_ALL *map); 82 struct MR_LD_RAID *MR_LdRaidGet(u32 ld, struct MR_FW_RAID_MAP_ALL *map); 83 84 u16 MR_GetLDTgtId(u32 ld, struct MR_FW_RAID_MAP_ALL *map); 85 86 void 87 megasas_check_and_restore_queue_depth(struct megasas_instance *instance); 88 89 u8 MR_ValidateMapInfo(struct MR_FW_RAID_MAP_ALL *map, 90 struct LD_LOAD_BALANCE_INFO *lbInfo); 91 u16 get_updated_dev_handle(struct LD_LOAD_BALANCE_INFO *lbInfo, 92 struct IO_REQUEST_INFO *in_info); 93 int megasas_transition_to_ready(struct megasas_instance *instance, int ocr); 94 void megaraid_sas_kill_hba(struct megasas_instance *instance); 95 96 extern u32 megasas_dbg_lvl; 97 extern int resetwaittime; 98 99 /** 100 * megasas_enable_intr_fusion - Enables interrupts 101 * @regs: MFI register set 102 */ 103 void 104 megasas_enable_intr_fusion(struct megasas_register_set __iomem *regs) 105 { 106 /* For Thunderbolt/Invader also clear intr on enable */ 107 writel(~0, ®s->outbound_intr_status); 108 readl(®s->outbound_intr_status); 109 110 writel(~MFI_FUSION_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask); 111 112 /* Dummy readl to force pci flush */ 113 readl(®s->outbound_intr_mask); 114 } 115 116 /** 117 * megasas_disable_intr_fusion - Disables interrupt 118 * @regs: MFI register set 119 */ 120 void 121 megasas_disable_intr_fusion(struct megasas_register_set __iomem *regs) 122 { 123 u32 mask = 0xFFFFFFFF; 124 u32 status; 125 126 writel(mask, ®s->outbound_intr_mask); 127 /* Dummy readl to force pci flush */ 128 status = readl(®s->outbound_intr_mask); 129 } 130 131 int 132 megasas_clear_intr_fusion(struct megasas_register_set __iomem *regs) 133 { 134 u32 status; 135 /* 136 * Check if it is our interrupt 137 */ 138 status = readl(®s->outbound_intr_status); 139 140 if (status & 1) { 141 writel(status, ®s->outbound_intr_status); 142 readl(®s->outbound_intr_status); 143 return 1; 144 } 145 if (!(status & MFI_FUSION_ENABLE_INTERRUPT_MASK)) 146 return 0; 147 148 return 1; 149 } 150 151 /** 152 * megasas_get_cmd_fusion - Get a command from the free pool 153 * @instance: Adapter soft state 154 * 155 * Returns a free command from the pool 156 */ 157 struct megasas_cmd_fusion *megasas_get_cmd_fusion(struct megasas_instance 158 *instance) 159 { 160 unsigned long flags; 161 struct fusion_context *fusion = 162 (struct fusion_context *)instance->ctrl_context; 163 struct megasas_cmd_fusion *cmd = NULL; 164 165 spin_lock_irqsave(&fusion->cmd_pool_lock, flags); 166 167 if (!list_empty(&fusion->cmd_pool)) { 168 cmd = list_entry((&fusion->cmd_pool)->next, 169 struct megasas_cmd_fusion, list); 170 list_del_init(&cmd->list); 171 } else { 172 printk(KERN_ERR "megasas: Command pool (fusion) empty!\n"); 173 } 174 175 spin_unlock_irqrestore(&fusion->cmd_pool_lock, flags); 176 return cmd; 177 } 178 179 /** 180 * megasas_return_cmd_fusion - Return a cmd to free command pool 181 * @instance: Adapter soft state 182 * @cmd: Command packet to be returned to free command pool 183 */ 184 static inline void 185 megasas_return_cmd_fusion(struct megasas_instance *instance, 186 struct megasas_cmd_fusion *cmd) 187 { 188 unsigned long flags; 189 struct fusion_context *fusion = 190 (struct fusion_context *)instance->ctrl_context; 191 192 spin_lock_irqsave(&fusion->cmd_pool_lock, flags); 193 194 cmd->scmd = NULL; 195 cmd->sync_cmd_idx = (u32)ULONG_MAX; 196 list_add_tail(&cmd->list, &fusion->cmd_pool); 197 198 spin_unlock_irqrestore(&fusion->cmd_pool_lock, flags); 199 } 200 201 /** 202 * megasas_teardown_frame_pool_fusion - Destroy the cmd frame DMA pool 203 * @instance: Adapter soft state 204 */ 205 static void megasas_teardown_frame_pool_fusion( 206 struct megasas_instance *instance) 207 { 208 int i; 209 struct fusion_context *fusion = instance->ctrl_context; 210 211 u16 max_cmd = instance->max_fw_cmds; 212 213 struct megasas_cmd_fusion *cmd; 214 215 if (!fusion->sg_dma_pool || !fusion->sense_dma_pool) { 216 printk(KERN_ERR "megasas: dma pool is null. SG Pool %p, " 217 "sense pool : %p\n", fusion->sg_dma_pool, 218 fusion->sense_dma_pool); 219 return; 220 } 221 222 /* 223 * Return all frames to pool 224 */ 225 for (i = 0; i < max_cmd; i++) { 226 227 cmd = fusion->cmd_list[i]; 228 229 if (cmd->sg_frame) 230 pci_pool_free(fusion->sg_dma_pool, cmd->sg_frame, 231 cmd->sg_frame_phys_addr); 232 233 if (cmd->sense) 234 pci_pool_free(fusion->sense_dma_pool, cmd->sense, 235 cmd->sense_phys_addr); 236 } 237 238 /* 239 * Now destroy the pool itself 240 */ 241 pci_pool_destroy(fusion->sg_dma_pool); 242 pci_pool_destroy(fusion->sense_dma_pool); 243 244 fusion->sg_dma_pool = NULL; 245 fusion->sense_dma_pool = NULL; 246 } 247 248 /** 249 * megasas_free_cmds_fusion - Free all the cmds in the free cmd pool 250 * @instance: Adapter soft state 251 */ 252 void 253 megasas_free_cmds_fusion(struct megasas_instance *instance) 254 { 255 int i; 256 struct fusion_context *fusion = instance->ctrl_context; 257 258 u32 max_cmds, req_sz, reply_sz, io_frames_sz; 259 260 261 req_sz = fusion->request_alloc_sz; 262 reply_sz = fusion->reply_alloc_sz; 263 io_frames_sz = fusion->io_frames_alloc_sz; 264 265 max_cmds = instance->max_fw_cmds; 266 267 /* Free descriptors and request Frames memory */ 268 if (fusion->req_frames_desc) 269 dma_free_coherent(&instance->pdev->dev, req_sz, 270 fusion->req_frames_desc, 271 fusion->req_frames_desc_phys); 272 273 if (fusion->reply_frames_desc) { 274 pci_pool_free(fusion->reply_frames_desc_pool, 275 fusion->reply_frames_desc, 276 fusion->reply_frames_desc_phys); 277 pci_pool_destroy(fusion->reply_frames_desc_pool); 278 } 279 280 if (fusion->io_request_frames) { 281 pci_pool_free(fusion->io_request_frames_pool, 282 fusion->io_request_frames, 283 fusion->io_request_frames_phys); 284 pci_pool_destroy(fusion->io_request_frames_pool); 285 } 286 287 /* Free the Fusion frame pool */ 288 megasas_teardown_frame_pool_fusion(instance); 289 290 /* Free all the commands in the cmd_list */ 291 for (i = 0; i < max_cmds; i++) 292 kfree(fusion->cmd_list[i]); 293 294 /* Free the cmd_list buffer itself */ 295 kfree(fusion->cmd_list); 296 fusion->cmd_list = NULL; 297 298 INIT_LIST_HEAD(&fusion->cmd_pool); 299 } 300 301 /** 302 * megasas_create_frame_pool_fusion - Creates DMA pool for cmd frames 303 * @instance: Adapter soft state 304 * 305 */ 306 static int megasas_create_frame_pool_fusion(struct megasas_instance *instance) 307 { 308 int i; 309 u32 max_cmd; 310 struct fusion_context *fusion; 311 struct megasas_cmd_fusion *cmd; 312 u32 total_sz_chain_frame; 313 314 fusion = instance->ctrl_context; 315 max_cmd = instance->max_fw_cmds; 316 317 total_sz_chain_frame = MEGASAS_MAX_SZ_CHAIN_FRAME; 318 319 /* 320 * Use DMA pool facility provided by PCI layer 321 */ 322 323 fusion->sg_dma_pool = pci_pool_create("megasas sg pool fusion", 324 instance->pdev, 325 total_sz_chain_frame, 4, 326 0); 327 if (!fusion->sg_dma_pool) { 328 printk(KERN_DEBUG "megasas: failed to setup request pool " 329 "fusion\n"); 330 return -ENOMEM; 331 } 332 fusion->sense_dma_pool = pci_pool_create("megasas sense pool fusion", 333 instance->pdev, 334 SCSI_SENSE_BUFFERSIZE, 64, 0); 335 336 if (!fusion->sense_dma_pool) { 337 printk(KERN_DEBUG "megasas: failed to setup sense pool " 338 "fusion\n"); 339 pci_pool_destroy(fusion->sg_dma_pool); 340 fusion->sg_dma_pool = NULL; 341 return -ENOMEM; 342 } 343 344 /* 345 * Allocate and attach a frame to each of the commands in cmd_list 346 */ 347 for (i = 0; i < max_cmd; i++) { 348 349 cmd = fusion->cmd_list[i]; 350 351 cmd->sg_frame = pci_pool_alloc(fusion->sg_dma_pool, 352 GFP_KERNEL, 353 &cmd->sg_frame_phys_addr); 354 355 cmd->sense = pci_pool_alloc(fusion->sense_dma_pool, 356 GFP_KERNEL, &cmd->sense_phys_addr); 357 /* 358 * megasas_teardown_frame_pool_fusion() takes care of freeing 359 * whatever has been allocated 360 */ 361 if (!cmd->sg_frame || !cmd->sense) { 362 printk(KERN_DEBUG "megasas: pci_pool_alloc failed\n"); 363 megasas_teardown_frame_pool_fusion(instance); 364 return -ENOMEM; 365 } 366 } 367 return 0; 368 } 369 370 /** 371 * megasas_alloc_cmds_fusion - Allocates the command packets 372 * @instance: Adapter soft state 373 * 374 * 375 * Each frame has a 32-bit field called context. This context is used to get 376 * back the megasas_cmd_fusion from the frame when a frame gets completed 377 * In this driver, the 32 bit values are the indices into an array cmd_list. 378 * This array is used only to look up the megasas_cmd_fusion given the context. 379 * The free commands themselves are maintained in a linked list called cmd_pool. 380 * 381 * cmds are formed in the io_request and sg_frame members of the 382 * megasas_cmd_fusion. The context field is used to get a request descriptor 383 * and is used as SMID of the cmd. 384 * SMID value range is from 1 to max_fw_cmds. 385 */ 386 int 387 megasas_alloc_cmds_fusion(struct megasas_instance *instance) 388 { 389 int i, j, count; 390 u32 max_cmd, io_frames_sz; 391 struct fusion_context *fusion; 392 struct megasas_cmd_fusion *cmd; 393 union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc; 394 u32 offset; 395 dma_addr_t io_req_base_phys; 396 u8 *io_req_base; 397 398 fusion = instance->ctrl_context; 399 400 max_cmd = instance->max_fw_cmds; 401 402 fusion->req_frames_desc = 403 dma_alloc_coherent(&instance->pdev->dev, 404 fusion->request_alloc_sz, 405 &fusion->req_frames_desc_phys, GFP_KERNEL); 406 407 if (!fusion->req_frames_desc) { 408 printk(KERN_ERR "megasas; Could not allocate memory for " 409 "request_frames\n"); 410 goto fail_req_desc; 411 } 412 413 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1; 414 fusion->reply_frames_desc_pool = 415 pci_pool_create("reply_frames pool", instance->pdev, 416 fusion->reply_alloc_sz * count, 16, 0); 417 418 if (!fusion->reply_frames_desc_pool) { 419 printk(KERN_ERR "megasas; Could not allocate memory for " 420 "reply_frame pool\n"); 421 goto fail_reply_desc; 422 } 423 424 fusion->reply_frames_desc = 425 pci_pool_alloc(fusion->reply_frames_desc_pool, GFP_KERNEL, 426 &fusion->reply_frames_desc_phys); 427 if (!fusion->reply_frames_desc) { 428 printk(KERN_ERR "megasas; Could not allocate memory for " 429 "reply_frame pool\n"); 430 pci_pool_destroy(fusion->reply_frames_desc_pool); 431 goto fail_reply_desc; 432 } 433 434 reply_desc = fusion->reply_frames_desc; 435 for (i = 0; i < fusion->reply_q_depth * count; i++, reply_desc++) 436 reply_desc->Words = ULLONG_MAX; 437 438 io_frames_sz = fusion->io_frames_alloc_sz; 439 440 fusion->io_request_frames_pool = 441 pci_pool_create("io_request_frames pool", instance->pdev, 442 fusion->io_frames_alloc_sz, 16, 0); 443 444 if (!fusion->io_request_frames_pool) { 445 printk(KERN_ERR "megasas: Could not allocate memory for " 446 "io_request_frame pool\n"); 447 goto fail_io_frames; 448 } 449 450 fusion->io_request_frames = 451 pci_pool_alloc(fusion->io_request_frames_pool, GFP_KERNEL, 452 &fusion->io_request_frames_phys); 453 if (!fusion->io_request_frames) { 454 printk(KERN_ERR "megasas: Could not allocate memory for " 455 "io_request_frames frames\n"); 456 pci_pool_destroy(fusion->io_request_frames_pool); 457 goto fail_io_frames; 458 } 459 460 /* 461 * fusion->cmd_list is an array of struct megasas_cmd_fusion pointers. 462 * Allocate the dynamic array first and then allocate individual 463 * commands. 464 */ 465 fusion->cmd_list = kzalloc(sizeof(struct megasas_cmd_fusion *) 466 * max_cmd, GFP_KERNEL); 467 468 if (!fusion->cmd_list) { 469 printk(KERN_DEBUG "megasas: out of memory. Could not alloc " 470 "memory for cmd_list_fusion\n"); 471 goto fail_cmd_list; 472 } 473 474 max_cmd = instance->max_fw_cmds; 475 for (i = 0; i < max_cmd; i++) { 476 fusion->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd_fusion), 477 GFP_KERNEL); 478 if (!fusion->cmd_list[i]) { 479 printk(KERN_ERR "Could not alloc cmd list fusion\n"); 480 481 for (j = 0; j < i; j++) 482 kfree(fusion->cmd_list[j]); 483 484 kfree(fusion->cmd_list); 485 fusion->cmd_list = NULL; 486 goto fail_cmd_list; 487 } 488 } 489 490 /* The first 256 bytes (SMID 0) is not used. Don't add to cmd list */ 491 io_req_base = fusion->io_request_frames + 492 MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE; 493 io_req_base_phys = fusion->io_request_frames_phys + 494 MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE; 495 496 /* 497 * Add all the commands to command pool (fusion->cmd_pool) 498 */ 499 500 /* SMID 0 is reserved. Set SMID/index from 1 */ 501 for (i = 0; i < max_cmd; i++) { 502 cmd = fusion->cmd_list[i]; 503 offset = MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE * i; 504 memset(cmd, 0, sizeof(struct megasas_cmd_fusion)); 505 cmd->index = i + 1; 506 cmd->scmd = NULL; 507 cmd->sync_cmd_idx = (u32)ULONG_MAX; /* Set to Invalid */ 508 cmd->instance = instance; 509 cmd->io_request = 510 (struct MPI2_RAID_SCSI_IO_REQUEST *) 511 (io_req_base + offset); 512 memset(cmd->io_request, 0, 513 sizeof(struct MPI2_RAID_SCSI_IO_REQUEST)); 514 cmd->io_request_phys_addr = io_req_base_phys + offset; 515 516 list_add_tail(&cmd->list, &fusion->cmd_pool); 517 } 518 519 /* 520 * Create a frame pool and assign one frame to each cmd 521 */ 522 if (megasas_create_frame_pool_fusion(instance)) { 523 printk(KERN_DEBUG "megasas: Error creating frame DMA pool\n"); 524 megasas_free_cmds_fusion(instance); 525 goto fail_req_desc; 526 } 527 528 return 0; 529 530 fail_cmd_list: 531 pci_pool_free(fusion->io_request_frames_pool, fusion->io_request_frames, 532 fusion->io_request_frames_phys); 533 pci_pool_destroy(fusion->io_request_frames_pool); 534 fail_io_frames: 535 dma_free_coherent(&instance->pdev->dev, fusion->request_alloc_sz, 536 fusion->reply_frames_desc, 537 fusion->reply_frames_desc_phys); 538 pci_pool_free(fusion->reply_frames_desc_pool, 539 fusion->reply_frames_desc, 540 fusion->reply_frames_desc_phys); 541 pci_pool_destroy(fusion->reply_frames_desc_pool); 542 543 fail_reply_desc: 544 dma_free_coherent(&instance->pdev->dev, fusion->request_alloc_sz, 545 fusion->req_frames_desc, 546 fusion->req_frames_desc_phys); 547 fail_req_desc: 548 return -ENOMEM; 549 } 550 551 /** 552 * wait_and_poll - Issues a polling command 553 * @instance: Adapter soft state 554 * @cmd: Command packet to be issued 555 * 556 * For polling, MFI requires the cmd_status to be set to 0xFF before posting. 557 */ 558 int 559 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd) 560 { 561 int i; 562 struct megasas_header *frame_hdr = &cmd->frame->hdr; 563 564 u32 msecs = MFI_POLL_TIMEOUT_SECS * 1000; 565 566 /* 567 * Wait for cmd_status to change 568 */ 569 for (i = 0; (i < msecs) && (frame_hdr->cmd_status == 0xff); i += 20) { 570 rmb(); 571 msleep(20); 572 } 573 574 if (frame_hdr->cmd_status == 0xff) 575 return -ETIME; 576 577 return 0; 578 } 579 580 /** 581 * megasas_ioc_init_fusion - Initializes the FW 582 * @instance: Adapter soft state 583 * 584 * Issues the IOC Init cmd 585 */ 586 int 587 megasas_ioc_init_fusion(struct megasas_instance *instance) 588 { 589 struct megasas_init_frame *init_frame; 590 struct MPI2_IOC_INIT_REQUEST *IOCInitMessage; 591 dma_addr_t ioc_init_handle; 592 struct megasas_cmd *cmd; 593 u8 ret; 594 struct fusion_context *fusion; 595 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc; 596 int i; 597 struct megasas_header *frame_hdr; 598 599 fusion = instance->ctrl_context; 600 601 cmd = megasas_get_cmd(instance); 602 603 if (!cmd) { 604 printk(KERN_ERR "Could not allocate cmd for INIT Frame\n"); 605 ret = 1; 606 goto fail_get_cmd; 607 } 608 609 IOCInitMessage = 610 dma_alloc_coherent(&instance->pdev->dev, 611 sizeof(struct MPI2_IOC_INIT_REQUEST), 612 &ioc_init_handle, GFP_KERNEL); 613 614 if (!IOCInitMessage) { 615 printk(KERN_ERR "Could not allocate memory for " 616 "IOCInitMessage\n"); 617 ret = 1; 618 goto fail_fw_init; 619 } 620 621 memset(IOCInitMessage, 0, sizeof(struct MPI2_IOC_INIT_REQUEST)); 622 623 IOCInitMessage->Function = MPI2_FUNCTION_IOC_INIT; 624 IOCInitMessage->WhoInit = MPI2_WHOINIT_HOST_DRIVER; 625 IOCInitMessage->MsgVersion = MPI2_VERSION; 626 IOCInitMessage->HeaderVersion = MPI2_HEADER_VERSION; 627 IOCInitMessage->SystemRequestFrameSize = 628 MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE / 4; 629 630 IOCInitMessage->ReplyDescriptorPostQueueDepth = fusion->reply_q_depth; 631 IOCInitMessage->ReplyDescriptorPostQueueAddress = 632 fusion->reply_frames_desc_phys; 633 IOCInitMessage->SystemRequestFrameBaseAddress = 634 fusion->io_request_frames_phys; 635 IOCInitMessage->HostMSIxVectors = instance->msix_vectors; 636 init_frame = (struct megasas_init_frame *)cmd->frame; 637 memset(init_frame, 0, MEGAMFI_FRAME_SIZE); 638 639 frame_hdr = &cmd->frame->hdr; 640 frame_hdr->cmd_status = 0xFF; 641 frame_hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE; 642 643 init_frame->cmd = MFI_CMD_INIT; 644 init_frame->cmd_status = 0xFF; 645 646 init_frame->queue_info_new_phys_addr_lo = ioc_init_handle; 647 init_frame->data_xfer_len = sizeof(struct MPI2_IOC_INIT_REQUEST); 648 649 req_desc = 650 (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)fusion->req_frames_desc; 651 652 req_desc->Words = cmd->frame_phys_addr; 653 req_desc->MFAIo.RequestFlags = 654 (MEGASAS_REQ_DESCRIPT_FLAGS_MFA << 655 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 656 657 /* 658 * disable the intr before firing the init frame 659 */ 660 instance->instancet->disable_intr(instance->reg_set); 661 662 for (i = 0; i < (10 * 1000); i += 20) { 663 if (readl(&instance->reg_set->doorbell) & 1) 664 msleep(20); 665 else 666 break; 667 } 668 669 instance->instancet->fire_cmd(instance, req_desc->u.low, 670 req_desc->u.high, instance->reg_set); 671 672 wait_and_poll(instance, cmd); 673 674 frame_hdr = &cmd->frame->hdr; 675 if (frame_hdr->cmd_status != 0) { 676 ret = 1; 677 goto fail_fw_init; 678 } 679 printk(KERN_ERR "megasas:IOC Init cmd success\n"); 680 681 ret = 0; 682 683 fail_fw_init: 684 megasas_return_cmd(instance, cmd); 685 if (IOCInitMessage) 686 dma_free_coherent(&instance->pdev->dev, 687 sizeof(struct MPI2_IOC_INIT_REQUEST), 688 IOCInitMessage, ioc_init_handle); 689 fail_get_cmd: 690 return ret; 691 } 692 693 /* 694 * megasas_get_ld_map_info - Returns FW's ld_map structure 695 * @instance: Adapter soft state 696 * @pend: Pend the command or not 697 * Issues an internal command (DCMD) to get the FW's controller PD 698 * list structure. This information is mainly used to find out SYSTEM 699 * supported by the FW. 700 */ 701 static int 702 megasas_get_ld_map_info(struct megasas_instance *instance) 703 { 704 int ret = 0; 705 struct megasas_cmd *cmd; 706 struct megasas_dcmd_frame *dcmd; 707 struct MR_FW_RAID_MAP_ALL *ci; 708 dma_addr_t ci_h = 0; 709 u32 size_map_info; 710 struct fusion_context *fusion; 711 712 cmd = megasas_get_cmd(instance); 713 714 if (!cmd) { 715 printk(KERN_DEBUG "megasas: Failed to get cmd for map info.\n"); 716 return -ENOMEM; 717 } 718 719 fusion = instance->ctrl_context; 720 721 if (!fusion) { 722 megasas_return_cmd(instance, cmd); 723 return 1; 724 } 725 726 dcmd = &cmd->frame->dcmd; 727 728 size_map_info = sizeof(struct MR_FW_RAID_MAP) + 729 (sizeof(struct MR_LD_SPAN_MAP) *(MAX_LOGICAL_DRIVES - 1)); 730 731 ci = fusion->ld_map[(instance->map_id & 1)]; 732 ci_h = fusion->ld_map_phys[(instance->map_id & 1)]; 733 734 if (!ci) { 735 printk(KERN_DEBUG "Failed to alloc mem for ld_map_info\n"); 736 megasas_return_cmd(instance, cmd); 737 return -ENOMEM; 738 } 739 740 memset(ci, 0, sizeof(*ci)); 741 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 742 743 dcmd->cmd = MFI_CMD_DCMD; 744 dcmd->cmd_status = 0xFF; 745 dcmd->sge_count = 1; 746 dcmd->flags = MFI_FRAME_DIR_READ; 747 dcmd->timeout = 0; 748 dcmd->pad_0 = 0; 749 dcmd->data_xfer_len = size_map_info; 750 dcmd->opcode = MR_DCMD_LD_MAP_GET_INFO; 751 dcmd->sgl.sge32[0].phys_addr = ci_h; 752 dcmd->sgl.sge32[0].length = size_map_info; 753 754 if (!megasas_issue_polled(instance, cmd)) 755 ret = 0; 756 else { 757 printk(KERN_ERR "megasas: Get LD Map Info Failed\n"); 758 ret = -1; 759 } 760 761 megasas_return_cmd(instance, cmd); 762 763 return ret; 764 } 765 766 u8 767 megasas_get_map_info(struct megasas_instance *instance) 768 { 769 struct fusion_context *fusion = instance->ctrl_context; 770 771 fusion->fast_path_io = 0; 772 if (!megasas_get_ld_map_info(instance)) { 773 if (MR_ValidateMapInfo(fusion->ld_map[(instance->map_id & 1)], 774 fusion->load_balance_info)) { 775 fusion->fast_path_io = 1; 776 return 0; 777 } 778 } 779 return 1; 780 } 781 782 /* 783 * megasas_sync_map_info - Returns FW's ld_map structure 784 * @instance: Adapter soft state 785 * 786 * Issues an internal command (DCMD) to get the FW's controller PD 787 * list structure. This information is mainly used to find out SYSTEM 788 * supported by the FW. 789 */ 790 int 791 megasas_sync_map_info(struct megasas_instance *instance) 792 { 793 int ret = 0, i; 794 struct megasas_cmd *cmd; 795 struct megasas_dcmd_frame *dcmd; 796 u32 size_sync_info, num_lds; 797 struct fusion_context *fusion; 798 struct MR_LD_TARGET_SYNC *ci = NULL; 799 struct MR_FW_RAID_MAP_ALL *map; 800 struct MR_LD_RAID *raid; 801 struct MR_LD_TARGET_SYNC *ld_sync; 802 dma_addr_t ci_h = 0; 803 u32 size_map_info; 804 805 cmd = megasas_get_cmd(instance); 806 807 if (!cmd) { 808 printk(KERN_DEBUG "megasas: Failed to get cmd for sync" 809 "info.\n"); 810 return -ENOMEM; 811 } 812 813 fusion = instance->ctrl_context; 814 815 if (!fusion) { 816 megasas_return_cmd(instance, cmd); 817 return 1; 818 } 819 820 map = fusion->ld_map[instance->map_id & 1]; 821 822 num_lds = map->raidMap.ldCount; 823 824 dcmd = &cmd->frame->dcmd; 825 826 size_sync_info = sizeof(struct MR_LD_TARGET_SYNC) *num_lds; 827 828 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 829 830 ci = (struct MR_LD_TARGET_SYNC *) 831 fusion->ld_map[(instance->map_id - 1) & 1]; 832 memset(ci, 0, sizeof(struct MR_FW_RAID_MAP_ALL)); 833 834 ci_h = fusion->ld_map_phys[(instance->map_id - 1) & 1]; 835 836 ld_sync = (struct MR_LD_TARGET_SYNC *)ci; 837 838 for (i = 0; i < num_lds; i++, ld_sync++) { 839 raid = MR_LdRaidGet(i, map); 840 ld_sync->targetId = MR_GetLDTgtId(i, map); 841 ld_sync->seqNum = raid->seqNum; 842 } 843 844 size_map_info = sizeof(struct MR_FW_RAID_MAP) + 845 (sizeof(struct MR_LD_SPAN_MAP) *(MAX_LOGICAL_DRIVES - 1)); 846 847 dcmd->cmd = MFI_CMD_DCMD; 848 dcmd->cmd_status = 0xFF; 849 dcmd->sge_count = 1; 850 dcmd->flags = MFI_FRAME_DIR_WRITE; 851 dcmd->timeout = 0; 852 dcmd->pad_0 = 0; 853 dcmd->data_xfer_len = size_map_info; 854 dcmd->mbox.b[0] = num_lds; 855 dcmd->mbox.b[1] = MEGASAS_DCMD_MBOX_PEND_FLAG; 856 dcmd->opcode = MR_DCMD_LD_MAP_GET_INFO; 857 dcmd->sgl.sge32[0].phys_addr = ci_h; 858 dcmd->sgl.sge32[0].length = size_map_info; 859 860 instance->map_update_cmd = cmd; 861 862 instance->instancet->issue_dcmd(instance, cmd); 863 864 return ret; 865 } 866 867 /** 868 * megasas_init_adapter_fusion - Initializes the FW 869 * @instance: Adapter soft state 870 * 871 * This is the main function for initializing firmware. 872 */ 873 u32 874 megasas_init_adapter_fusion(struct megasas_instance *instance) 875 { 876 struct megasas_register_set __iomem *reg_set; 877 struct fusion_context *fusion; 878 u32 max_cmd; 879 int i = 0, count; 880 881 fusion = instance->ctrl_context; 882 883 reg_set = instance->reg_set; 884 885 /* 886 * Get various operational parameters from status register 887 */ 888 instance->max_fw_cmds = 889 instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF; 890 instance->max_fw_cmds = min(instance->max_fw_cmds, (u16)1008); 891 892 /* 893 * Reduce the max supported cmds by 1. This is to ensure that the 894 * reply_q_sz (1 more than the max cmd that driver may send) 895 * does not exceed max cmds that the FW can support 896 */ 897 instance->max_fw_cmds = instance->max_fw_cmds-1; 898 /* Only internal cmds (DCMD) need to have MFI frames */ 899 instance->max_mfi_cmds = MEGASAS_INT_CMDS; 900 901 max_cmd = instance->max_fw_cmds; 902 903 fusion->reply_q_depth = ((max_cmd + 1 + 15)/16)*16; 904 905 fusion->request_alloc_sz = 906 sizeof(union MEGASAS_REQUEST_DESCRIPTOR_UNION) *max_cmd; 907 fusion->reply_alloc_sz = sizeof(union MPI2_REPLY_DESCRIPTORS_UNION) 908 *(fusion->reply_q_depth); 909 fusion->io_frames_alloc_sz = MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE + 910 (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE * 911 (max_cmd + 1)); /* Extra 1 for SMID 0 */ 912 913 fusion->max_sge_in_main_msg = 914 (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE - 915 offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL))/16; 916 917 fusion->max_sge_in_chain = 918 MEGASAS_MAX_SZ_CHAIN_FRAME / sizeof(union MPI2_SGE_IO_UNION); 919 920 instance->max_num_sge = fusion->max_sge_in_main_msg + 921 fusion->max_sge_in_chain - 2; 922 923 /* Used for pass thru MFI frame (DCMD) */ 924 fusion->chain_offset_mfi_pthru = 925 offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL)/16; 926 927 fusion->chain_offset_io_request = 928 (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE - 929 sizeof(union MPI2_SGE_IO_UNION))/16; 930 931 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1; 932 for (i = 0 ; i < count; i++) 933 fusion->last_reply_idx[i] = 0; 934 935 /* 936 * Allocate memory for descriptors 937 * Create a pool of commands 938 */ 939 if (megasas_alloc_cmds(instance)) 940 goto fail_alloc_mfi_cmds; 941 if (megasas_alloc_cmds_fusion(instance)) 942 goto fail_alloc_cmds; 943 944 if (megasas_ioc_init_fusion(instance)) 945 goto fail_ioc_init; 946 947 instance->flag_ieee = 1; 948 949 fusion->map_sz = sizeof(struct MR_FW_RAID_MAP) + 950 (sizeof(struct MR_LD_SPAN_MAP) *(MAX_LOGICAL_DRIVES - 1)); 951 952 fusion->fast_path_io = 0; 953 954 for (i = 0; i < 2; i++) { 955 fusion->ld_map[i] = dma_alloc_coherent(&instance->pdev->dev, 956 fusion->map_sz, 957 &fusion->ld_map_phys[i], 958 GFP_KERNEL); 959 if (!fusion->ld_map[i]) { 960 printk(KERN_ERR "megasas: Could not allocate memory " 961 "for map info\n"); 962 goto fail_map_info; 963 } 964 } 965 966 if (!megasas_get_map_info(instance)) 967 megasas_sync_map_info(instance); 968 969 return 0; 970 971 fail_map_info: 972 if (i == 1) 973 dma_free_coherent(&instance->pdev->dev, fusion->map_sz, 974 fusion->ld_map[0], fusion->ld_map_phys[0]); 975 fail_ioc_init: 976 megasas_free_cmds_fusion(instance); 977 fail_alloc_cmds: 978 megasas_free_cmds(instance); 979 fail_alloc_mfi_cmds: 980 return 1; 981 } 982 983 /** 984 * megasas_fire_cmd_fusion - Sends command to the FW 985 * @frame_phys_addr : Physical address of cmd 986 * @frame_count : Number of frames for the command 987 * @regs : MFI register set 988 */ 989 void 990 megasas_fire_cmd_fusion(struct megasas_instance *instance, 991 dma_addr_t req_desc_lo, 992 u32 req_desc_hi, 993 struct megasas_register_set __iomem *regs) 994 { 995 unsigned long flags; 996 997 spin_lock_irqsave(&instance->hba_lock, flags); 998 999 writel(req_desc_lo, 1000 &(regs)->inbound_low_queue_port); 1001 writel(req_desc_hi, &(regs)->inbound_high_queue_port); 1002 spin_unlock_irqrestore(&instance->hba_lock, flags); 1003 } 1004 1005 /** 1006 * map_cmd_status - Maps FW cmd status to OS cmd status 1007 * @cmd : Pointer to cmd 1008 * @status : status of cmd returned by FW 1009 * @ext_status : ext status of cmd returned by FW 1010 */ 1011 1012 void 1013 map_cmd_status(struct megasas_cmd_fusion *cmd, u8 status, u8 ext_status) 1014 { 1015 1016 switch (status) { 1017 1018 case MFI_STAT_OK: 1019 cmd->scmd->result = DID_OK << 16; 1020 break; 1021 1022 case MFI_STAT_SCSI_IO_FAILED: 1023 case MFI_STAT_LD_INIT_IN_PROGRESS: 1024 cmd->scmd->result = (DID_ERROR << 16) | ext_status; 1025 break; 1026 1027 case MFI_STAT_SCSI_DONE_WITH_ERROR: 1028 1029 cmd->scmd->result = (DID_OK << 16) | ext_status; 1030 if (ext_status == SAM_STAT_CHECK_CONDITION) { 1031 memset(cmd->scmd->sense_buffer, 0, 1032 SCSI_SENSE_BUFFERSIZE); 1033 memcpy(cmd->scmd->sense_buffer, cmd->sense, 1034 SCSI_SENSE_BUFFERSIZE); 1035 cmd->scmd->result |= DRIVER_SENSE << 24; 1036 } 1037 break; 1038 1039 case MFI_STAT_LD_OFFLINE: 1040 case MFI_STAT_DEVICE_NOT_FOUND: 1041 cmd->scmd->result = DID_BAD_TARGET << 16; 1042 break; 1043 case MFI_STAT_CONFIG_SEQ_MISMATCH: 1044 cmd->scmd->result = DID_IMM_RETRY << 16; 1045 break; 1046 default: 1047 printk(KERN_DEBUG "megasas: FW status %#x\n", status); 1048 cmd->scmd->result = DID_ERROR << 16; 1049 break; 1050 } 1051 } 1052 1053 /** 1054 * megasas_make_sgl_fusion - Prepares 32-bit SGL 1055 * @instance: Adapter soft state 1056 * @scp: SCSI command from the mid-layer 1057 * @sgl_ptr: SGL to be filled in 1058 * @cmd: cmd we are working on 1059 * 1060 * If successful, this function returns the number of SG elements. 1061 */ 1062 static int 1063 megasas_make_sgl_fusion(struct megasas_instance *instance, 1064 struct scsi_cmnd *scp, 1065 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr, 1066 struct megasas_cmd_fusion *cmd) 1067 { 1068 int i, sg_processed, sge_count; 1069 struct scatterlist *os_sgl; 1070 struct fusion_context *fusion; 1071 1072 fusion = instance->ctrl_context; 1073 1074 if (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) { 1075 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr_end = sgl_ptr; 1076 sgl_ptr_end += fusion->max_sge_in_main_msg - 1; 1077 sgl_ptr_end->Flags = 0; 1078 } 1079 1080 sge_count = scsi_dma_map(scp); 1081 1082 BUG_ON(sge_count < 0); 1083 1084 if (sge_count > instance->max_num_sge || !sge_count) 1085 return sge_count; 1086 1087 scsi_for_each_sg(scp, os_sgl, sge_count, i) { 1088 sgl_ptr->Length = sg_dma_len(os_sgl); 1089 sgl_ptr->Address = sg_dma_address(os_sgl); 1090 sgl_ptr->Flags = 0; 1091 if (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) { 1092 if (i == sge_count - 1) 1093 sgl_ptr->Flags = IEEE_SGE_FLAGS_END_OF_LIST; 1094 } 1095 sgl_ptr++; 1096 1097 sg_processed = i + 1; 1098 1099 if ((sg_processed == (fusion->max_sge_in_main_msg - 1)) && 1100 (sge_count > fusion->max_sge_in_main_msg)) { 1101 1102 struct MPI25_IEEE_SGE_CHAIN64 *sg_chain; 1103 if (instance->pdev->device == 1104 PCI_DEVICE_ID_LSI_INVADER) { 1105 if ((cmd->io_request->IoFlags & 1106 MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH) != 1107 MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH) 1108 cmd->io_request->ChainOffset = 1109 fusion-> 1110 chain_offset_io_request; 1111 else 1112 cmd->io_request->ChainOffset = 0; 1113 } else 1114 cmd->io_request->ChainOffset = 1115 fusion->chain_offset_io_request; 1116 1117 sg_chain = sgl_ptr; 1118 /* Prepare chain element */ 1119 sg_chain->NextChainOffset = 0; 1120 if (instance->pdev->device == 1121 PCI_DEVICE_ID_LSI_INVADER) 1122 sg_chain->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT; 1123 else 1124 sg_chain->Flags = 1125 (IEEE_SGE_FLAGS_CHAIN_ELEMENT | 1126 MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR); 1127 sg_chain->Length = (sizeof(union MPI2_SGE_IO_UNION) 1128 *(sge_count - sg_processed)); 1129 sg_chain->Address = cmd->sg_frame_phys_addr; 1130 1131 sgl_ptr = 1132 (struct MPI25_IEEE_SGE_CHAIN64 *)cmd->sg_frame; 1133 } 1134 } 1135 1136 return sge_count; 1137 } 1138 1139 /** 1140 * megasas_set_pd_lba - Sets PD LBA 1141 * @cdb: CDB 1142 * @cdb_len: cdb length 1143 * @start_blk: Start block of IO 1144 * 1145 * Used to set the PD LBA in CDB for FP IOs 1146 */ 1147 void 1148 megasas_set_pd_lba(struct MPI2_RAID_SCSI_IO_REQUEST *io_request, u8 cdb_len, 1149 struct IO_REQUEST_INFO *io_info, struct scsi_cmnd *scp, 1150 struct MR_FW_RAID_MAP_ALL *local_map_ptr, u32 ref_tag) 1151 { 1152 struct MR_LD_RAID *raid; 1153 u32 ld; 1154 u64 start_blk = io_info->pdBlock; 1155 u8 *cdb = io_request->CDB.CDB32; 1156 u32 num_blocks = io_info->numBlocks; 1157 u8 opcode = 0, flagvals = 0, groupnum = 0, control = 0; 1158 1159 /* Check if T10 PI (DIF) is enabled for this LD */ 1160 ld = MR_TargetIdToLdGet(io_info->ldTgtId, local_map_ptr); 1161 raid = MR_LdRaidGet(ld, local_map_ptr); 1162 if (raid->capability.ldPiMode == MR_PROT_INFO_TYPE_CONTROLLER) { 1163 memset(cdb, 0, sizeof(io_request->CDB.CDB32)); 1164 cdb[0] = MEGASAS_SCSI_VARIABLE_LENGTH_CMD; 1165 cdb[7] = MEGASAS_SCSI_ADDL_CDB_LEN; 1166 1167 if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) 1168 cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_READ32; 1169 else 1170 cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_WRITE32; 1171 cdb[10] = MEGASAS_RD_WR_PROTECT_CHECK_ALL; 1172 1173 /* LBA */ 1174 cdb[12] = (u8)((start_blk >> 56) & 0xff); 1175 cdb[13] = (u8)((start_blk >> 48) & 0xff); 1176 cdb[14] = (u8)((start_blk >> 40) & 0xff); 1177 cdb[15] = (u8)((start_blk >> 32) & 0xff); 1178 cdb[16] = (u8)((start_blk >> 24) & 0xff); 1179 cdb[17] = (u8)((start_blk >> 16) & 0xff); 1180 cdb[18] = (u8)((start_blk >> 8) & 0xff); 1181 cdb[19] = (u8)(start_blk & 0xff); 1182 1183 /* Logical block reference tag */ 1184 io_request->CDB.EEDP32.PrimaryReferenceTag = 1185 cpu_to_be32(ref_tag); 1186 io_request->CDB.EEDP32.PrimaryApplicationTagMask = 0xffff; 1187 io_request->IoFlags = 32; /* Specify 32-byte cdb */ 1188 1189 /* Transfer length */ 1190 cdb[28] = (u8)((num_blocks >> 24) & 0xff); 1191 cdb[29] = (u8)((num_blocks >> 16) & 0xff); 1192 cdb[30] = (u8)((num_blocks >> 8) & 0xff); 1193 cdb[31] = (u8)(num_blocks & 0xff); 1194 1195 /* set SCSI IO EEDPFlags */ 1196 if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) { 1197 io_request->EEDPFlags = 1198 MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG | 1199 MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG | 1200 MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP | 1201 MPI2_SCSIIO_EEDPFLAGS_CHECK_APPTAG | 1202 MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD; 1203 } else { 1204 io_request->EEDPFlags = 1205 MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG | 1206 MPI2_SCSIIO_EEDPFLAGS_INSERT_OP; 1207 } 1208 io_request->Control |= (0x4 << 26); 1209 io_request->EEDPBlockSize = scp->device->sector_size; 1210 } else { 1211 /* Some drives don't support 16/12 byte CDB's, convert to 10 */ 1212 if (((cdb_len == 12) || (cdb_len == 16)) && 1213 (start_blk <= 0xffffffff)) { 1214 if (cdb_len == 16) { 1215 opcode = cdb[0] == READ_16 ? READ_10 : WRITE_10; 1216 flagvals = cdb[1]; 1217 groupnum = cdb[14]; 1218 control = cdb[15]; 1219 } else { 1220 opcode = cdb[0] == READ_12 ? READ_10 : WRITE_10; 1221 flagvals = cdb[1]; 1222 groupnum = cdb[10]; 1223 control = cdb[11]; 1224 } 1225 1226 memset(cdb, 0, sizeof(io_request->CDB.CDB32)); 1227 1228 cdb[0] = opcode; 1229 cdb[1] = flagvals; 1230 cdb[6] = groupnum; 1231 cdb[9] = control; 1232 1233 /* Transfer length */ 1234 cdb[8] = (u8)(num_blocks & 0xff); 1235 cdb[7] = (u8)((num_blocks >> 8) & 0xff); 1236 1237 io_request->IoFlags = 10; /* Specify 10-byte cdb */ 1238 cdb_len = 10; 1239 } else if ((cdb_len < 16) && (start_blk > 0xffffffff)) { 1240 /* Convert to 16 byte CDB for large LBA's */ 1241 switch (cdb_len) { 1242 case 6: 1243 opcode = cdb[0] == READ_6 ? READ_16 : WRITE_16; 1244 control = cdb[5]; 1245 break; 1246 case 10: 1247 opcode = 1248 cdb[0] == READ_10 ? READ_16 : WRITE_16; 1249 flagvals = cdb[1]; 1250 groupnum = cdb[6]; 1251 control = cdb[9]; 1252 break; 1253 case 12: 1254 opcode = 1255 cdb[0] == READ_12 ? READ_16 : WRITE_16; 1256 flagvals = cdb[1]; 1257 groupnum = cdb[10]; 1258 control = cdb[11]; 1259 break; 1260 } 1261 1262 memset(cdb, 0, sizeof(io_request->CDB.CDB32)); 1263 1264 cdb[0] = opcode; 1265 cdb[1] = flagvals; 1266 cdb[14] = groupnum; 1267 cdb[15] = control; 1268 1269 /* Transfer length */ 1270 cdb[13] = (u8)(num_blocks & 0xff); 1271 cdb[12] = (u8)((num_blocks >> 8) & 0xff); 1272 cdb[11] = (u8)((num_blocks >> 16) & 0xff); 1273 cdb[10] = (u8)((num_blocks >> 24) & 0xff); 1274 1275 io_request->IoFlags = 16; /* Specify 16-byte cdb */ 1276 cdb_len = 16; 1277 } 1278 1279 /* Normal case, just load LBA here */ 1280 switch (cdb_len) { 1281 case 6: 1282 { 1283 u8 val = cdb[1] & 0xE0; 1284 cdb[3] = (u8)(start_blk & 0xff); 1285 cdb[2] = (u8)((start_blk >> 8) & 0xff); 1286 cdb[1] = val | ((u8)(start_blk >> 16) & 0x1f); 1287 break; 1288 } 1289 case 10: 1290 cdb[5] = (u8)(start_blk & 0xff); 1291 cdb[4] = (u8)((start_blk >> 8) & 0xff); 1292 cdb[3] = (u8)((start_blk >> 16) & 0xff); 1293 cdb[2] = (u8)((start_blk >> 24) & 0xff); 1294 break; 1295 case 12: 1296 cdb[5] = (u8)(start_blk & 0xff); 1297 cdb[4] = (u8)((start_blk >> 8) & 0xff); 1298 cdb[3] = (u8)((start_blk >> 16) & 0xff); 1299 cdb[2] = (u8)((start_blk >> 24) & 0xff); 1300 break; 1301 case 16: 1302 cdb[9] = (u8)(start_blk & 0xff); 1303 cdb[8] = (u8)((start_blk >> 8) & 0xff); 1304 cdb[7] = (u8)((start_blk >> 16) & 0xff); 1305 cdb[6] = (u8)((start_blk >> 24) & 0xff); 1306 cdb[5] = (u8)((start_blk >> 32) & 0xff); 1307 cdb[4] = (u8)((start_blk >> 40) & 0xff); 1308 cdb[3] = (u8)((start_blk >> 48) & 0xff); 1309 cdb[2] = (u8)((start_blk >> 56) & 0xff); 1310 break; 1311 } 1312 } 1313 } 1314 1315 /** 1316 * megasas_build_ldio_fusion - Prepares IOs to devices 1317 * @instance: Adapter soft state 1318 * @scp: SCSI command 1319 * @cmd: Command to be prepared 1320 * 1321 * Prepares the io_request and chain elements (sg_frame) for IO 1322 * The IO can be for PD (Fast Path) or LD 1323 */ 1324 void 1325 megasas_build_ldio_fusion(struct megasas_instance *instance, 1326 struct scsi_cmnd *scp, 1327 struct megasas_cmd_fusion *cmd) 1328 { 1329 u8 fp_possible; 1330 u32 start_lba_lo, start_lba_hi, device_id, datalength = 0; 1331 struct MPI2_RAID_SCSI_IO_REQUEST *io_request; 1332 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc; 1333 struct IO_REQUEST_INFO io_info; 1334 struct fusion_context *fusion; 1335 struct MR_FW_RAID_MAP_ALL *local_map_ptr; 1336 1337 device_id = MEGASAS_DEV_INDEX(instance, scp); 1338 1339 fusion = instance->ctrl_context; 1340 1341 io_request = cmd->io_request; 1342 io_request->RaidContext.VirtualDiskTgtId = device_id; 1343 io_request->RaidContext.status = 0; 1344 io_request->RaidContext.exStatus = 0; 1345 1346 req_desc = (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)cmd->request_desc; 1347 1348 start_lba_lo = 0; 1349 start_lba_hi = 0; 1350 fp_possible = 0; 1351 1352 /* 1353 * 6-byte READ(0x08) or WRITE(0x0A) cdb 1354 */ 1355 if (scp->cmd_len == 6) { 1356 datalength = (u32) scp->cmnd[4]; 1357 start_lba_lo = ((u32) scp->cmnd[1] << 16) | 1358 ((u32) scp->cmnd[2] << 8) | (u32) scp->cmnd[3]; 1359 1360 start_lba_lo &= 0x1FFFFF; 1361 } 1362 1363 /* 1364 * 10-byte READ(0x28) or WRITE(0x2A) cdb 1365 */ 1366 else if (scp->cmd_len == 10) { 1367 datalength = (u32) scp->cmnd[8] | 1368 ((u32) scp->cmnd[7] << 8); 1369 start_lba_lo = ((u32) scp->cmnd[2] << 24) | 1370 ((u32) scp->cmnd[3] << 16) | 1371 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5]; 1372 } 1373 1374 /* 1375 * 12-byte READ(0xA8) or WRITE(0xAA) cdb 1376 */ 1377 else if (scp->cmd_len == 12) { 1378 datalength = ((u32) scp->cmnd[6] << 24) | 1379 ((u32) scp->cmnd[7] << 16) | 1380 ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9]; 1381 start_lba_lo = ((u32) scp->cmnd[2] << 24) | 1382 ((u32) scp->cmnd[3] << 16) | 1383 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5]; 1384 } 1385 1386 /* 1387 * 16-byte READ(0x88) or WRITE(0x8A) cdb 1388 */ 1389 else if (scp->cmd_len == 16) { 1390 datalength = ((u32) scp->cmnd[10] << 24) | 1391 ((u32) scp->cmnd[11] << 16) | 1392 ((u32) scp->cmnd[12] << 8) | (u32) scp->cmnd[13]; 1393 start_lba_lo = ((u32) scp->cmnd[6] << 24) | 1394 ((u32) scp->cmnd[7] << 16) | 1395 ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9]; 1396 1397 start_lba_hi = ((u32) scp->cmnd[2] << 24) | 1398 ((u32) scp->cmnd[3] << 16) | 1399 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5]; 1400 } 1401 1402 memset(&io_info, 0, sizeof(struct IO_REQUEST_INFO)); 1403 io_info.ldStartBlock = ((u64)start_lba_hi << 32) | start_lba_lo; 1404 io_info.numBlocks = datalength; 1405 io_info.ldTgtId = device_id; 1406 io_request->DataLength = scsi_bufflen(scp); 1407 1408 if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) 1409 io_info.isRead = 1; 1410 1411 local_map_ptr = fusion->ld_map[(instance->map_id & 1)]; 1412 1413 if ((MR_TargetIdToLdGet(device_id, local_map_ptr) >= 1414 MAX_LOGICAL_DRIVES) || (!fusion->fast_path_io)) { 1415 io_request->RaidContext.regLockFlags = 0; 1416 fp_possible = 0; 1417 } else { 1418 if (MR_BuildRaidContext(instance, &io_info, 1419 &io_request->RaidContext, 1420 local_map_ptr)) 1421 fp_possible = io_info.fpOkForIo; 1422 } 1423 1424 /* Use smp_processor_id() for now until cmd->request->cpu is CPU 1425 id by default, not CPU group id, otherwise all MSI-X queues won't 1426 be utilized */ 1427 cmd->request_desc->SCSIIO.MSIxIndex = instance->msix_vectors ? 1428 smp_processor_id() % instance->msix_vectors : 0; 1429 1430 if (fp_possible) { 1431 megasas_set_pd_lba(io_request, scp->cmd_len, &io_info, scp, 1432 local_map_ptr, start_lba_lo); 1433 io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST; 1434 cmd->request_desc->SCSIIO.RequestFlags = 1435 (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY 1436 << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1437 if (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) { 1438 if (io_request->RaidContext.regLockFlags == 1439 REGION_TYPE_UNUSED) 1440 cmd->request_desc->SCSIIO.RequestFlags = 1441 (MEGASAS_REQ_DESCRIPT_FLAGS_NO_LOCK << 1442 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1443 io_request->RaidContext.Type = MPI2_TYPE_CUDA; 1444 io_request->RaidContext.nseg = 0x1; 1445 io_request->IoFlags |= 1446 MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH; 1447 io_request->RaidContext.regLockFlags |= 1448 (MR_RL_FLAGS_GRANT_DESTINATION_CUDA | 1449 MR_RL_FLAGS_SEQ_NUM_ENABLE); 1450 } 1451 if ((fusion->load_balance_info[device_id].loadBalanceFlag) && 1452 (io_info.isRead)) { 1453 io_info.devHandle = 1454 get_updated_dev_handle( 1455 &fusion->load_balance_info[device_id], 1456 &io_info); 1457 scp->SCp.Status |= MEGASAS_LOAD_BALANCE_FLAG; 1458 } else 1459 scp->SCp.Status &= ~MEGASAS_LOAD_BALANCE_FLAG; 1460 cmd->request_desc->SCSIIO.DevHandle = io_info.devHandle; 1461 io_request->DevHandle = io_info.devHandle; 1462 } else { 1463 io_request->RaidContext.timeoutValue = 1464 local_map_ptr->raidMap.fpPdIoTimeoutSec; 1465 cmd->request_desc->SCSIIO.RequestFlags = 1466 (MEGASAS_REQ_DESCRIPT_FLAGS_LD_IO 1467 << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1468 if (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) { 1469 if (io_request->RaidContext.regLockFlags == 1470 REGION_TYPE_UNUSED) 1471 cmd->request_desc->SCSIIO.RequestFlags = 1472 (MEGASAS_REQ_DESCRIPT_FLAGS_NO_LOCK << 1473 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1474 io_request->RaidContext.Type = MPI2_TYPE_CUDA; 1475 io_request->RaidContext.regLockFlags |= 1476 (MR_RL_FLAGS_GRANT_DESTINATION_CPU0 | 1477 MR_RL_FLAGS_SEQ_NUM_ENABLE); 1478 io_request->RaidContext.nseg = 0x1; 1479 } 1480 io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST; 1481 io_request->DevHandle = device_id; 1482 } /* Not FP */ 1483 } 1484 1485 /** 1486 * megasas_build_dcdb_fusion - Prepares IOs to devices 1487 * @instance: Adapter soft state 1488 * @scp: SCSI command 1489 * @cmd: Command to be prepared 1490 * 1491 * Prepares the io_request frame for non-io cmds 1492 */ 1493 static void 1494 megasas_build_dcdb_fusion(struct megasas_instance *instance, 1495 struct scsi_cmnd *scmd, 1496 struct megasas_cmd_fusion *cmd) 1497 { 1498 u32 device_id; 1499 struct MPI2_RAID_SCSI_IO_REQUEST *io_request; 1500 u16 pd_index = 0; 1501 struct MR_FW_RAID_MAP_ALL *local_map_ptr; 1502 struct fusion_context *fusion = instance->ctrl_context; 1503 1504 io_request = cmd->io_request; 1505 device_id = MEGASAS_DEV_INDEX(instance, scmd); 1506 pd_index = (scmd->device->channel * MEGASAS_MAX_DEV_PER_CHANNEL) 1507 +scmd->device->id; 1508 local_map_ptr = fusion->ld_map[(instance->map_id & 1)]; 1509 1510 /* Check if this is a system PD I/O */ 1511 if (scmd->device->channel < MEGASAS_MAX_PD_CHANNELS && 1512 instance->pd_list[pd_index].driveState == MR_PD_STATE_SYSTEM) { 1513 io_request->Function = 0; 1514 if (fusion->fast_path_io) 1515 io_request->DevHandle = 1516 local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl; 1517 io_request->RaidContext.timeoutValue = 1518 local_map_ptr->raidMap.fpPdIoTimeoutSec; 1519 io_request->RaidContext.regLockFlags = 0; 1520 io_request->RaidContext.regLockRowLBA = 0; 1521 io_request->RaidContext.regLockLength = 0; 1522 io_request->RaidContext.RAIDFlags = 1523 MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD << 1524 MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT; 1525 cmd->request_desc->SCSIIO.RequestFlags = 1526 (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY << 1527 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1528 cmd->request_desc->SCSIIO.DevHandle = 1529 local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl; 1530 } else { 1531 io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST; 1532 io_request->DevHandle = device_id; 1533 cmd->request_desc->SCSIIO.RequestFlags = 1534 (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO << 1535 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1536 } 1537 io_request->RaidContext.VirtualDiskTgtId = device_id; 1538 io_request->LUN[1] = scmd->device->lun; 1539 io_request->DataLength = scsi_bufflen(scmd); 1540 } 1541 1542 /** 1543 * megasas_build_io_fusion - Prepares IOs to devices 1544 * @instance: Adapter soft state 1545 * @scp: SCSI command 1546 * @cmd: Command to be prepared 1547 * 1548 * Invokes helper functions to prepare request frames 1549 * and sets flags appropriate for IO/Non-IO cmd 1550 */ 1551 int 1552 megasas_build_io_fusion(struct megasas_instance *instance, 1553 struct scsi_cmnd *scp, 1554 struct megasas_cmd_fusion *cmd) 1555 { 1556 u32 device_id, sge_count; 1557 struct MPI2_RAID_SCSI_IO_REQUEST *io_request = cmd->io_request; 1558 1559 device_id = MEGASAS_DEV_INDEX(instance, scp); 1560 1561 /* Zero out some fields so they don't get reused */ 1562 io_request->LUN[1] = 0; 1563 io_request->CDB.EEDP32.PrimaryReferenceTag = 0; 1564 io_request->CDB.EEDP32.PrimaryApplicationTagMask = 0; 1565 io_request->EEDPFlags = 0; 1566 io_request->Control = 0; 1567 io_request->EEDPBlockSize = 0; 1568 io_request->ChainOffset = 0; 1569 io_request->RaidContext.RAIDFlags = 0; 1570 io_request->RaidContext.Type = 0; 1571 io_request->RaidContext.nseg = 0; 1572 1573 memcpy(io_request->CDB.CDB32, scp->cmnd, scp->cmd_len); 1574 /* 1575 * Just the CDB length,rest of the Flags are zero 1576 * This will be modified for FP in build_ldio_fusion 1577 */ 1578 io_request->IoFlags = scp->cmd_len; 1579 1580 if (megasas_is_ldio(scp)) 1581 megasas_build_ldio_fusion(instance, scp, cmd); 1582 else 1583 megasas_build_dcdb_fusion(instance, scp, cmd); 1584 1585 /* 1586 * Construct SGL 1587 */ 1588 1589 sge_count = 1590 megasas_make_sgl_fusion(instance, scp, 1591 (struct MPI25_IEEE_SGE_CHAIN64 *) 1592 &io_request->SGL, cmd); 1593 1594 if (sge_count > instance->max_num_sge) { 1595 printk(KERN_ERR "megasas: Error. sge_count (0x%x) exceeds " 1596 "max (0x%x) allowed\n", sge_count, 1597 instance->max_num_sge); 1598 return 1; 1599 } 1600 1601 io_request->RaidContext.numSGE = sge_count; 1602 1603 io_request->SGLFlags = MPI2_SGE_FLAGS_64_BIT_ADDRESSING; 1604 1605 if (scp->sc_data_direction == PCI_DMA_TODEVICE) 1606 io_request->Control |= MPI2_SCSIIO_CONTROL_WRITE; 1607 else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) 1608 io_request->Control |= MPI2_SCSIIO_CONTROL_READ; 1609 1610 io_request->SGLOffset0 = 1611 offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL) / 4; 1612 1613 io_request->SenseBufferLowAddress = cmd->sense_phys_addr; 1614 io_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE; 1615 1616 cmd->scmd = scp; 1617 scp->SCp.ptr = (char *)cmd; 1618 1619 return 0; 1620 } 1621 1622 union MEGASAS_REQUEST_DESCRIPTOR_UNION * 1623 megasas_get_request_descriptor(struct megasas_instance *instance, u16 index) 1624 { 1625 u8 *p; 1626 struct fusion_context *fusion; 1627 1628 if (index >= instance->max_fw_cmds) { 1629 printk(KERN_ERR "megasas: Invalid SMID (0x%x)request for " 1630 "descriptor\n", index); 1631 return NULL; 1632 } 1633 fusion = instance->ctrl_context; 1634 p = fusion->req_frames_desc 1635 +sizeof(union MEGASAS_REQUEST_DESCRIPTOR_UNION) *index; 1636 1637 return (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)p; 1638 } 1639 1640 /** 1641 * megasas_build_and_issue_cmd_fusion -Main routine for building and 1642 * issuing non IOCTL cmd 1643 * @instance: Adapter soft state 1644 * @scmd: pointer to scsi cmd from OS 1645 */ 1646 static u32 1647 megasas_build_and_issue_cmd_fusion(struct megasas_instance *instance, 1648 struct scsi_cmnd *scmd) 1649 { 1650 struct megasas_cmd_fusion *cmd; 1651 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc; 1652 u32 index; 1653 struct fusion_context *fusion; 1654 1655 fusion = instance->ctrl_context; 1656 1657 cmd = megasas_get_cmd_fusion(instance); 1658 if (!cmd) 1659 return SCSI_MLQUEUE_HOST_BUSY; 1660 1661 index = cmd->index; 1662 1663 req_desc = megasas_get_request_descriptor(instance, index-1); 1664 if (!req_desc) 1665 return 1; 1666 1667 req_desc->Words = 0; 1668 cmd->request_desc = req_desc; 1669 1670 if (megasas_build_io_fusion(instance, scmd, cmd)) { 1671 megasas_return_cmd_fusion(instance, cmd); 1672 printk(KERN_ERR "megasas: Error building command.\n"); 1673 cmd->request_desc = NULL; 1674 return 1; 1675 } 1676 1677 req_desc = cmd->request_desc; 1678 req_desc->SCSIIO.SMID = index; 1679 1680 if (cmd->io_request->ChainOffset != 0 && 1681 cmd->io_request->ChainOffset != 0xF) 1682 printk(KERN_ERR "megasas: The chain offset value is not " 1683 "correct : %x\n", cmd->io_request->ChainOffset); 1684 1685 /* 1686 * Issue the command to the FW 1687 */ 1688 atomic_inc(&instance->fw_outstanding); 1689 1690 instance->instancet->fire_cmd(instance, 1691 req_desc->u.low, req_desc->u.high, 1692 instance->reg_set); 1693 1694 return 0; 1695 } 1696 1697 /** 1698 * complete_cmd_fusion - Completes command 1699 * @instance: Adapter soft state 1700 * Completes all commands that is in reply descriptor queue 1701 */ 1702 int 1703 complete_cmd_fusion(struct megasas_instance *instance, u32 MSIxIndex) 1704 { 1705 union MPI2_REPLY_DESCRIPTORS_UNION *desc; 1706 struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *reply_desc; 1707 struct MPI2_RAID_SCSI_IO_REQUEST *scsi_io_req; 1708 struct fusion_context *fusion; 1709 struct megasas_cmd *cmd_mfi; 1710 struct megasas_cmd_fusion *cmd_fusion; 1711 u16 smid, num_completed; 1712 u8 reply_descript_type, arm; 1713 u32 status, extStatus, device_id; 1714 union desc_value d_val; 1715 struct LD_LOAD_BALANCE_INFO *lbinfo; 1716 1717 fusion = instance->ctrl_context; 1718 1719 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) 1720 return IRQ_HANDLED; 1721 1722 desc = fusion->reply_frames_desc; 1723 desc += ((MSIxIndex * fusion->reply_alloc_sz)/ 1724 sizeof(union MPI2_REPLY_DESCRIPTORS_UNION)) + 1725 fusion->last_reply_idx[MSIxIndex]; 1726 1727 reply_desc = (struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc; 1728 1729 d_val.word = desc->Words; 1730 1731 reply_descript_type = reply_desc->ReplyFlags & 1732 MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK; 1733 1734 if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED) 1735 return IRQ_NONE; 1736 1737 num_completed = 0; 1738 1739 while ((d_val.u.low != UINT_MAX) && (d_val.u.high != UINT_MAX)) { 1740 smid = reply_desc->SMID; 1741 1742 cmd_fusion = fusion->cmd_list[smid - 1]; 1743 1744 scsi_io_req = 1745 (struct MPI2_RAID_SCSI_IO_REQUEST *) 1746 cmd_fusion->io_request; 1747 1748 if (cmd_fusion->scmd) 1749 cmd_fusion->scmd->SCp.ptr = NULL; 1750 1751 status = scsi_io_req->RaidContext.status; 1752 extStatus = scsi_io_req->RaidContext.exStatus; 1753 1754 switch (scsi_io_req->Function) { 1755 case MPI2_FUNCTION_SCSI_IO_REQUEST: /*Fast Path IO.*/ 1756 /* Update load balancing info */ 1757 device_id = MEGASAS_DEV_INDEX(instance, 1758 cmd_fusion->scmd); 1759 lbinfo = &fusion->load_balance_info[device_id]; 1760 if (cmd_fusion->scmd->SCp.Status & 1761 MEGASAS_LOAD_BALANCE_FLAG) { 1762 arm = lbinfo->raid1DevHandle[0] == 1763 cmd_fusion->io_request->DevHandle ? 0 : 1764 1; 1765 atomic_dec(&lbinfo->scsi_pending_cmds[arm]); 1766 cmd_fusion->scmd->SCp.Status &= 1767 ~MEGASAS_LOAD_BALANCE_FLAG; 1768 } 1769 if (reply_descript_type == 1770 MPI2_RPY_DESCRIPT_FLAGS_SCSI_IO_SUCCESS) { 1771 if (megasas_dbg_lvl == 5) 1772 printk(KERN_ERR "\nmegasas: FAST Path " 1773 "IO Success\n"); 1774 } 1775 /* Fall thru and complete IO */ 1776 case MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST: /* LD-IO Path */ 1777 /* Map the FW Cmd Status */ 1778 map_cmd_status(cmd_fusion, status, extStatus); 1779 scsi_dma_unmap(cmd_fusion->scmd); 1780 cmd_fusion->scmd->scsi_done(cmd_fusion->scmd); 1781 scsi_io_req->RaidContext.status = 0; 1782 scsi_io_req->RaidContext.exStatus = 0; 1783 megasas_return_cmd_fusion(instance, cmd_fusion); 1784 atomic_dec(&instance->fw_outstanding); 1785 1786 break; 1787 case MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST: /*MFI command */ 1788 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx]; 1789 megasas_complete_cmd(instance, cmd_mfi, DID_OK); 1790 cmd_fusion->flags = 0; 1791 megasas_return_cmd_fusion(instance, cmd_fusion); 1792 1793 break; 1794 } 1795 1796 fusion->last_reply_idx[MSIxIndex]++; 1797 if (fusion->last_reply_idx[MSIxIndex] >= 1798 fusion->reply_q_depth) 1799 fusion->last_reply_idx[MSIxIndex] = 0; 1800 1801 desc->Words = ULLONG_MAX; 1802 num_completed++; 1803 1804 /* Get the next reply descriptor */ 1805 if (!fusion->last_reply_idx[MSIxIndex]) 1806 desc = fusion->reply_frames_desc + 1807 ((MSIxIndex * fusion->reply_alloc_sz)/ 1808 sizeof(union MPI2_REPLY_DESCRIPTORS_UNION)); 1809 else 1810 desc++; 1811 1812 reply_desc = 1813 (struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc; 1814 1815 d_val.word = desc->Words; 1816 1817 reply_descript_type = reply_desc->ReplyFlags & 1818 MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK; 1819 1820 if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED) 1821 break; 1822 } 1823 1824 if (!num_completed) 1825 return IRQ_NONE; 1826 1827 wmb(); 1828 writel((MSIxIndex << 24) | fusion->last_reply_idx[MSIxIndex], 1829 &instance->reg_set->reply_post_host_index); 1830 megasas_check_and_restore_queue_depth(instance); 1831 return IRQ_HANDLED; 1832 } 1833 1834 /** 1835 * megasas_complete_cmd_dpc_fusion - Completes command 1836 * @instance: Adapter soft state 1837 * 1838 * Tasklet to complete cmds 1839 */ 1840 void 1841 megasas_complete_cmd_dpc_fusion(unsigned long instance_addr) 1842 { 1843 struct megasas_instance *instance = 1844 (struct megasas_instance *)instance_addr; 1845 unsigned long flags; 1846 u32 count, MSIxIndex; 1847 1848 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1; 1849 1850 /* If we have already declared adapter dead, donot complete cmds */ 1851 spin_lock_irqsave(&instance->hba_lock, flags); 1852 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) { 1853 spin_unlock_irqrestore(&instance->hba_lock, flags); 1854 return; 1855 } 1856 spin_unlock_irqrestore(&instance->hba_lock, flags); 1857 1858 for (MSIxIndex = 0 ; MSIxIndex < count; MSIxIndex++) 1859 complete_cmd_fusion(instance, MSIxIndex); 1860 } 1861 1862 /** 1863 * megasas_isr_fusion - isr entry point 1864 */ 1865 irqreturn_t megasas_isr_fusion(int irq, void *devp) 1866 { 1867 struct megasas_irq_context *irq_context = devp; 1868 struct megasas_instance *instance = irq_context->instance; 1869 u32 mfiStatus, fw_state; 1870 1871 if (!instance->msix_vectors) { 1872 mfiStatus = instance->instancet->clear_intr(instance->reg_set); 1873 if (!mfiStatus) 1874 return IRQ_NONE; 1875 } 1876 1877 /* If we are resetting, bail */ 1878 if (test_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags)) { 1879 instance->instancet->clear_intr(instance->reg_set); 1880 return IRQ_HANDLED; 1881 } 1882 1883 if (!complete_cmd_fusion(instance, irq_context->MSIxIndex)) { 1884 instance->instancet->clear_intr(instance->reg_set); 1885 /* If we didn't complete any commands, check for FW fault */ 1886 fw_state = instance->instancet->read_fw_status_reg( 1887 instance->reg_set) & MFI_STATE_MASK; 1888 if (fw_state == MFI_STATE_FAULT) 1889 schedule_work(&instance->work_init); 1890 } 1891 1892 return IRQ_HANDLED; 1893 } 1894 1895 /** 1896 * build_mpt_mfi_pass_thru - builds a cmd fo MFI Pass thru 1897 * @instance: Adapter soft state 1898 * mfi_cmd: megasas_cmd pointer 1899 * 1900 */ 1901 u8 1902 build_mpt_mfi_pass_thru(struct megasas_instance *instance, 1903 struct megasas_cmd *mfi_cmd) 1904 { 1905 struct MPI25_IEEE_SGE_CHAIN64 *mpi25_ieee_chain; 1906 struct MPI2_RAID_SCSI_IO_REQUEST *io_req; 1907 struct megasas_cmd_fusion *cmd; 1908 struct fusion_context *fusion; 1909 struct megasas_header *frame_hdr = &mfi_cmd->frame->hdr; 1910 1911 cmd = megasas_get_cmd_fusion(instance); 1912 if (!cmd) 1913 return 1; 1914 1915 /* Save the smid. To be used for returning the cmd */ 1916 mfi_cmd->context.smid = cmd->index; 1917 1918 cmd->sync_cmd_idx = mfi_cmd->index; 1919 1920 /* 1921 * For cmds where the flag is set, store the flag and check 1922 * on completion. For cmds with this flag, don't call 1923 * megasas_complete_cmd 1924 */ 1925 1926 if (frame_hdr->flags & MFI_FRAME_DONT_POST_IN_REPLY_QUEUE) 1927 cmd->flags = MFI_FRAME_DONT_POST_IN_REPLY_QUEUE; 1928 1929 fusion = instance->ctrl_context; 1930 io_req = cmd->io_request; 1931 1932 if (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) { 1933 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr_end = 1934 (struct MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL; 1935 sgl_ptr_end += fusion->max_sge_in_main_msg - 1; 1936 sgl_ptr_end->Flags = 0; 1937 } 1938 1939 mpi25_ieee_chain = 1940 (struct MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL.IeeeChain; 1941 1942 io_req->Function = MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST; 1943 io_req->SGLOffset0 = offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, 1944 SGL) / 4; 1945 io_req->ChainOffset = fusion->chain_offset_mfi_pthru; 1946 1947 mpi25_ieee_chain->Address = mfi_cmd->frame_phys_addr; 1948 1949 mpi25_ieee_chain->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT | 1950 MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR; 1951 1952 mpi25_ieee_chain->Length = MEGASAS_MAX_SZ_CHAIN_FRAME; 1953 1954 return 0; 1955 } 1956 1957 /** 1958 * build_mpt_cmd - Calls helper function to build a cmd MFI Pass thru cmd 1959 * @instance: Adapter soft state 1960 * @cmd: mfi cmd to build 1961 * 1962 */ 1963 union MEGASAS_REQUEST_DESCRIPTOR_UNION * 1964 build_mpt_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd) 1965 { 1966 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc; 1967 u16 index; 1968 1969 if (build_mpt_mfi_pass_thru(instance, cmd)) { 1970 printk(KERN_ERR "Couldn't build MFI pass thru cmd\n"); 1971 return NULL; 1972 } 1973 1974 index = cmd->context.smid; 1975 1976 req_desc = megasas_get_request_descriptor(instance, index - 1); 1977 1978 if (!req_desc) 1979 return NULL; 1980 1981 req_desc->Words = 0; 1982 req_desc->SCSIIO.RequestFlags = (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO << 1983 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1984 1985 req_desc->SCSIIO.SMID = index; 1986 1987 return req_desc; 1988 } 1989 1990 /** 1991 * megasas_issue_dcmd_fusion - Issues a MFI Pass thru cmd 1992 * @instance: Adapter soft state 1993 * @cmd: mfi cmd pointer 1994 * 1995 */ 1996 void 1997 megasas_issue_dcmd_fusion(struct megasas_instance *instance, 1998 struct megasas_cmd *cmd) 1999 { 2000 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc; 2001 2002 req_desc = build_mpt_cmd(instance, cmd); 2003 if (!req_desc) { 2004 printk(KERN_ERR "Couldn't issue MFI pass thru cmd\n"); 2005 return; 2006 } 2007 instance->instancet->fire_cmd(instance, req_desc->u.low, 2008 req_desc->u.high, instance->reg_set); 2009 } 2010 2011 /** 2012 * megasas_release_fusion - Reverses the FW initialization 2013 * @intance: Adapter soft state 2014 */ 2015 void 2016 megasas_release_fusion(struct megasas_instance *instance) 2017 { 2018 megasas_free_cmds(instance); 2019 megasas_free_cmds_fusion(instance); 2020 2021 iounmap(instance->reg_set); 2022 2023 pci_release_selected_regions(instance->pdev, instance->bar); 2024 } 2025 2026 /** 2027 * megasas_read_fw_status_reg_fusion - returns the current FW status value 2028 * @regs: MFI register set 2029 */ 2030 static u32 2031 megasas_read_fw_status_reg_fusion(struct megasas_register_set __iomem *regs) 2032 { 2033 return readl(&(regs)->outbound_scratch_pad); 2034 } 2035 2036 /** 2037 * megasas_adp_reset_fusion - For controller reset 2038 * @regs: MFI register set 2039 */ 2040 static int 2041 megasas_adp_reset_fusion(struct megasas_instance *instance, 2042 struct megasas_register_set __iomem *regs) 2043 { 2044 return 0; 2045 } 2046 2047 /** 2048 * megasas_check_reset_fusion - For controller reset check 2049 * @regs: MFI register set 2050 */ 2051 static int 2052 megasas_check_reset_fusion(struct megasas_instance *instance, 2053 struct megasas_register_set __iomem *regs) 2054 { 2055 return 0; 2056 } 2057 2058 /* This function waits for outstanding commands on fusion to complete */ 2059 int megasas_wait_for_outstanding_fusion(struct megasas_instance *instance) 2060 { 2061 int i, outstanding, retval = 0; 2062 u32 fw_state; 2063 2064 for (i = 0; i < resetwaittime; i++) { 2065 /* Check if firmware is in fault state */ 2066 fw_state = instance->instancet->read_fw_status_reg( 2067 instance->reg_set) & MFI_STATE_MASK; 2068 if (fw_state == MFI_STATE_FAULT) { 2069 printk(KERN_WARNING "megasas: Found FW in FAULT state," 2070 " will reset adapter.\n"); 2071 retval = 1; 2072 goto out; 2073 } 2074 2075 outstanding = atomic_read(&instance->fw_outstanding); 2076 if (!outstanding) 2077 goto out; 2078 2079 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) { 2080 printk(KERN_NOTICE "megasas: [%2d]waiting for %d " 2081 "commands to complete\n", i, outstanding); 2082 megasas_complete_cmd_dpc_fusion( 2083 (unsigned long)instance); 2084 } 2085 msleep(1000); 2086 } 2087 2088 if (atomic_read(&instance->fw_outstanding)) { 2089 printk("megaraid_sas: pending commands remain after waiting, " 2090 "will reset adapter.\n"); 2091 retval = 1; 2092 } 2093 out: 2094 return retval; 2095 } 2096 2097 void megasas_reset_reply_desc(struct megasas_instance *instance) 2098 { 2099 int i, count; 2100 struct fusion_context *fusion; 2101 union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc; 2102 2103 fusion = instance->ctrl_context; 2104 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1; 2105 for (i = 0 ; i < count ; i++) 2106 fusion->last_reply_idx[i] = 0; 2107 reply_desc = fusion->reply_frames_desc; 2108 for (i = 0 ; i < fusion->reply_q_depth * count; i++, reply_desc++) 2109 reply_desc->Words = ULLONG_MAX; 2110 } 2111 2112 /* Core fusion reset function */ 2113 int megasas_reset_fusion(struct Scsi_Host *shost) 2114 { 2115 int retval = SUCCESS, i, j, retry = 0; 2116 struct megasas_instance *instance; 2117 struct megasas_cmd_fusion *cmd_fusion; 2118 struct fusion_context *fusion; 2119 struct megasas_cmd *cmd_mfi; 2120 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc; 2121 u32 host_diag, abs_state, status_reg, reset_adapter; 2122 2123 instance = (struct megasas_instance *)shost->hostdata; 2124 fusion = instance->ctrl_context; 2125 2126 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) { 2127 printk(KERN_WARNING "megaraid_sas: Hardware critical error, " 2128 "returning FAILED.\n"); 2129 return FAILED; 2130 } 2131 2132 mutex_lock(&instance->reset_mutex); 2133 set_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags); 2134 instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT; 2135 instance->instancet->disable_intr(instance->reg_set); 2136 msleep(1000); 2137 2138 /* First try waiting for commands to complete */ 2139 if (megasas_wait_for_outstanding_fusion(instance)) { 2140 printk(KERN_WARNING "megaraid_sas: resetting fusion " 2141 "adapter.\n"); 2142 /* Now return commands back to the OS */ 2143 for (i = 0 ; i < instance->max_fw_cmds; i++) { 2144 cmd_fusion = fusion->cmd_list[i]; 2145 if (cmd_fusion->scmd) { 2146 scsi_dma_unmap(cmd_fusion->scmd); 2147 cmd_fusion->scmd->result = (DID_RESET << 16); 2148 cmd_fusion->scmd->scsi_done(cmd_fusion->scmd); 2149 megasas_return_cmd_fusion(instance, cmd_fusion); 2150 atomic_dec(&instance->fw_outstanding); 2151 } 2152 } 2153 2154 status_reg = instance->instancet->read_fw_status_reg( 2155 instance->reg_set); 2156 abs_state = status_reg & MFI_STATE_MASK; 2157 reset_adapter = status_reg & MFI_RESET_ADAPTER; 2158 if (instance->disableOnlineCtrlReset || 2159 (abs_state == MFI_STATE_FAULT && !reset_adapter)) { 2160 /* Reset not supported, kill adapter */ 2161 printk(KERN_WARNING "megaraid_sas: Reset not supported" 2162 ", killing adapter.\n"); 2163 megaraid_sas_kill_hba(instance); 2164 instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR; 2165 retval = FAILED; 2166 goto out; 2167 } 2168 2169 /* Now try to reset the chip */ 2170 for (i = 0; i < MEGASAS_FUSION_MAX_RESET_TRIES; i++) { 2171 writel(MPI2_WRSEQ_FLUSH_KEY_VALUE, 2172 &instance->reg_set->fusion_seq_offset); 2173 writel(MPI2_WRSEQ_1ST_KEY_VALUE, 2174 &instance->reg_set->fusion_seq_offset); 2175 writel(MPI2_WRSEQ_2ND_KEY_VALUE, 2176 &instance->reg_set->fusion_seq_offset); 2177 writel(MPI2_WRSEQ_3RD_KEY_VALUE, 2178 &instance->reg_set->fusion_seq_offset); 2179 writel(MPI2_WRSEQ_4TH_KEY_VALUE, 2180 &instance->reg_set->fusion_seq_offset); 2181 writel(MPI2_WRSEQ_5TH_KEY_VALUE, 2182 &instance->reg_set->fusion_seq_offset); 2183 writel(MPI2_WRSEQ_6TH_KEY_VALUE, 2184 &instance->reg_set->fusion_seq_offset); 2185 2186 /* Check that the diag write enable (DRWE) bit is on */ 2187 host_diag = readl(&instance->reg_set->fusion_host_diag); 2188 retry = 0; 2189 while (!(host_diag & HOST_DIAG_WRITE_ENABLE)) { 2190 msleep(100); 2191 host_diag = 2192 readl(&instance->reg_set->fusion_host_diag); 2193 if (retry++ == 100) { 2194 printk(KERN_WARNING "megaraid_sas: " 2195 "Host diag unlock failed!\n"); 2196 break; 2197 } 2198 } 2199 if (!(host_diag & HOST_DIAG_WRITE_ENABLE)) 2200 continue; 2201 2202 /* Send chip reset command */ 2203 writel(host_diag | HOST_DIAG_RESET_ADAPTER, 2204 &instance->reg_set->fusion_host_diag); 2205 msleep(3000); 2206 2207 /* Make sure reset adapter bit is cleared */ 2208 host_diag = readl(&instance->reg_set->fusion_host_diag); 2209 retry = 0; 2210 while (host_diag & HOST_DIAG_RESET_ADAPTER) { 2211 msleep(100); 2212 host_diag = 2213 readl(&instance->reg_set->fusion_host_diag); 2214 if (retry++ == 1000) { 2215 printk(KERN_WARNING "megaraid_sas: " 2216 "Diag reset adapter never " 2217 "cleared!\n"); 2218 break; 2219 } 2220 } 2221 if (host_diag & HOST_DIAG_RESET_ADAPTER) 2222 continue; 2223 2224 abs_state = 2225 instance->instancet->read_fw_status_reg( 2226 instance->reg_set) & MFI_STATE_MASK; 2227 retry = 0; 2228 2229 while ((abs_state <= MFI_STATE_FW_INIT) && 2230 (retry++ < 1000)) { 2231 msleep(100); 2232 abs_state = 2233 instance->instancet->read_fw_status_reg( 2234 instance->reg_set) & MFI_STATE_MASK; 2235 } 2236 if (abs_state <= MFI_STATE_FW_INIT) { 2237 printk(KERN_WARNING "megaraid_sas: firmware " 2238 "state < MFI_STATE_FW_INIT, state = " 2239 "0x%x\n", abs_state); 2240 continue; 2241 } 2242 2243 /* Wait for FW to become ready */ 2244 if (megasas_transition_to_ready(instance, 1)) { 2245 printk(KERN_WARNING "megaraid_sas: Failed to " 2246 "transition controller to ready.\n"); 2247 continue; 2248 } 2249 2250 megasas_reset_reply_desc(instance); 2251 if (megasas_ioc_init_fusion(instance)) { 2252 printk(KERN_WARNING "megaraid_sas: " 2253 "megasas_ioc_init_fusion() failed!\n"); 2254 continue; 2255 } 2256 2257 clear_bit(MEGASAS_FUSION_IN_RESET, 2258 &instance->reset_flags); 2259 instance->instancet->enable_intr(instance->reg_set); 2260 instance->adprecovery = MEGASAS_HBA_OPERATIONAL; 2261 2262 /* Re-fire management commands */ 2263 for (j = 0 ; j < instance->max_fw_cmds; j++) { 2264 cmd_fusion = fusion->cmd_list[j]; 2265 if (cmd_fusion->sync_cmd_idx != 2266 (u32)ULONG_MAX) { 2267 cmd_mfi = 2268 instance-> 2269 cmd_list[cmd_fusion->sync_cmd_idx]; 2270 if (cmd_mfi->frame->dcmd.opcode == 2271 MR_DCMD_LD_MAP_GET_INFO) { 2272 megasas_return_cmd(instance, 2273 cmd_mfi); 2274 megasas_return_cmd_fusion( 2275 instance, cmd_fusion); 2276 } else { 2277 req_desc = 2278 megasas_get_request_descriptor( 2279 instance, 2280 cmd_mfi->context.smid 2281 -1); 2282 if (!req_desc) 2283 printk(KERN_WARNING 2284 "req_desc NULL" 2285 "\n"); 2286 else { 2287 instance->instancet-> 2288 fire_cmd(instance, 2289 req_desc-> 2290 u.low, 2291 req_desc-> 2292 u.high, 2293 instance-> 2294 reg_set); 2295 } 2296 } 2297 } 2298 } 2299 2300 /* Reset load balance info */ 2301 memset(fusion->load_balance_info, 0, 2302 sizeof(struct LD_LOAD_BALANCE_INFO) 2303 *MAX_LOGICAL_DRIVES); 2304 2305 if (!megasas_get_map_info(instance)) 2306 megasas_sync_map_info(instance); 2307 2308 /* Adapter reset completed successfully */ 2309 printk(KERN_WARNING "megaraid_sas: Reset " 2310 "successful.\n"); 2311 retval = SUCCESS; 2312 goto out; 2313 } 2314 /* Reset failed, kill the adapter */ 2315 printk(KERN_WARNING "megaraid_sas: Reset failed, killing " 2316 "adapter.\n"); 2317 megaraid_sas_kill_hba(instance); 2318 retval = FAILED; 2319 } else { 2320 clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags); 2321 instance->instancet->enable_intr(instance->reg_set); 2322 instance->adprecovery = MEGASAS_HBA_OPERATIONAL; 2323 } 2324 out: 2325 clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags); 2326 mutex_unlock(&instance->reset_mutex); 2327 return retval; 2328 } 2329 2330 /* Fusion OCR work queue */ 2331 void megasas_fusion_ocr_wq(struct work_struct *work) 2332 { 2333 struct megasas_instance *instance = 2334 container_of(work, struct megasas_instance, work_init); 2335 2336 megasas_reset_fusion(instance->host); 2337 } 2338 2339 struct megasas_instance_template megasas_instance_template_fusion = { 2340 .fire_cmd = megasas_fire_cmd_fusion, 2341 .enable_intr = megasas_enable_intr_fusion, 2342 .disable_intr = megasas_disable_intr_fusion, 2343 .clear_intr = megasas_clear_intr_fusion, 2344 .read_fw_status_reg = megasas_read_fw_status_reg_fusion, 2345 .adp_reset = megasas_adp_reset_fusion, 2346 .check_reset = megasas_check_reset_fusion, 2347 .service_isr = megasas_isr_fusion, 2348 .tasklet = megasas_complete_cmd_dpc_fusion, 2349 .init_adapter = megasas_init_adapter_fusion, 2350 .build_and_issue_cmd = megasas_build_and_issue_cmd_fusion, 2351 .issue_dcmd = megasas_issue_dcmd_fusion, 2352 }; 2353