1 /* 2 * Linux MegaRAID driver for SAS based RAID controllers 3 * 4 * Copyright (c) 2003-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 * Authors: Avago Technologies 21 * Sreenivas Bagalkote 22 * Sumant Patro 23 * Bo Yang 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/slab.h> 45 #include <asm/uaccess.h> 46 #include <linux/fs.h> 47 #include <linux/compat.h> 48 #include <linux/blkdev.h> 49 #include <linux/mutex.h> 50 #include <linux/poll.h> 51 52 #include <scsi/scsi.h> 53 #include <scsi/scsi_cmnd.h> 54 #include <scsi/scsi_device.h> 55 #include <scsi/scsi_host.h> 56 #include <scsi/scsi_tcq.h> 57 #include "megaraid_sas_fusion.h" 58 #include "megaraid_sas.h" 59 60 /* 61 * Number of sectors per IO command 62 * Will be set in megasas_init_mfi if user does not provide 63 */ 64 static unsigned int max_sectors; 65 module_param_named(max_sectors, max_sectors, int, 0); 66 MODULE_PARM_DESC(max_sectors, 67 "Maximum number of sectors per IO command"); 68 69 static int msix_disable; 70 module_param(msix_disable, int, S_IRUGO); 71 MODULE_PARM_DESC(msix_disable, "Disable MSI-X interrupt handling. Default: 0"); 72 73 static unsigned int msix_vectors; 74 module_param(msix_vectors, int, S_IRUGO); 75 MODULE_PARM_DESC(msix_vectors, "MSI-X max vector count. Default: Set by FW"); 76 77 static int allow_vf_ioctls; 78 module_param(allow_vf_ioctls, int, S_IRUGO); 79 MODULE_PARM_DESC(allow_vf_ioctls, "Allow ioctls in SR-IOV VF mode. Default: 0"); 80 81 static unsigned int throttlequeuedepth = MEGASAS_THROTTLE_QUEUE_DEPTH; 82 module_param(throttlequeuedepth, int, S_IRUGO); 83 MODULE_PARM_DESC(throttlequeuedepth, 84 "Adapter queue depth when throttled due to I/O timeout. Default: 16"); 85 86 int resetwaittime = MEGASAS_RESET_WAIT_TIME; 87 module_param(resetwaittime, int, S_IRUGO); 88 MODULE_PARM_DESC(resetwaittime, "Wait time in seconds after I/O timeout " 89 "before resetting adapter. Default: 180"); 90 91 int smp_affinity_enable = 1; 92 module_param(smp_affinity_enable, int, S_IRUGO); 93 MODULE_PARM_DESC(smp_affinity_enable, "SMP affinity feature enable/disbale Default: enable(1)"); 94 95 MODULE_LICENSE("GPL"); 96 MODULE_VERSION(MEGASAS_VERSION); 97 MODULE_AUTHOR("megaraidlinux.pdl@avagotech.com"); 98 MODULE_DESCRIPTION("Avago MegaRAID SAS Driver"); 99 100 int megasas_transition_to_ready(struct megasas_instance *instance, int ocr); 101 static int megasas_get_pd_list(struct megasas_instance *instance); 102 static int megasas_ld_list_query(struct megasas_instance *instance, 103 u8 query_type); 104 static int megasas_issue_init_mfi(struct megasas_instance *instance); 105 static int megasas_register_aen(struct megasas_instance *instance, 106 u32 seq_num, u32 class_locale_word); 107 /* 108 * PCI ID table for all supported controllers 109 */ 110 static struct pci_device_id megasas_pci_table[] = { 111 112 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064R)}, 113 /* xscale IOP */ 114 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078R)}, 115 /* ppc IOP */ 116 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078DE)}, 117 /* ppc IOP */ 118 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078GEN2)}, 119 /* gen2*/ 120 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0079GEN2)}, 121 /* gen2*/ 122 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0073SKINNY)}, 123 /* skinny*/ 124 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0071SKINNY)}, 125 /* skinny*/ 126 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VERDE_ZCR)}, 127 /* xscale IOP, vega */ 128 {PCI_DEVICE(PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_PERC5)}, 129 /* xscale IOP */ 130 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FUSION)}, 131 /* Fusion */ 132 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_PLASMA)}, 133 /* Plasma */ 134 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_INVADER)}, 135 /* Invader */ 136 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FURY)}, 137 /* Fury */ 138 {} 139 }; 140 141 MODULE_DEVICE_TABLE(pci, megasas_pci_table); 142 143 static int megasas_mgmt_majorno; 144 struct megasas_mgmt_info megasas_mgmt_info; 145 static struct fasync_struct *megasas_async_queue; 146 static DEFINE_MUTEX(megasas_async_queue_mutex); 147 148 static int megasas_poll_wait_aen; 149 static DECLARE_WAIT_QUEUE_HEAD(megasas_poll_wait); 150 static u32 support_poll_for_event; 151 u32 megasas_dbg_lvl; 152 static u32 support_device_change; 153 154 /* define lock for aen poll */ 155 spinlock_t poll_aen_lock; 156 157 void 158 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd, 159 u8 alt_status); 160 static u32 161 megasas_read_fw_status_reg_gen2(struct megasas_register_set __iomem *regs); 162 static int 163 megasas_adp_reset_gen2(struct megasas_instance *instance, 164 struct megasas_register_set __iomem *reg_set); 165 static irqreturn_t megasas_isr(int irq, void *devp); 166 static u32 167 megasas_init_adapter_mfi(struct megasas_instance *instance); 168 u32 169 megasas_build_and_issue_cmd(struct megasas_instance *instance, 170 struct scsi_cmnd *scmd); 171 static void megasas_complete_cmd_dpc(unsigned long instance_addr); 172 void 173 megasas_release_fusion(struct megasas_instance *instance); 174 int 175 megasas_ioc_init_fusion(struct megasas_instance *instance); 176 void 177 megasas_free_cmds_fusion(struct megasas_instance *instance); 178 u8 179 megasas_get_map_info(struct megasas_instance *instance); 180 int 181 megasas_sync_map_info(struct megasas_instance *instance); 182 int 183 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd, 184 int seconds); 185 void megasas_reset_reply_desc(struct megasas_instance *instance); 186 int megasas_reset_fusion(struct Scsi_Host *shost, int iotimeout); 187 void megasas_fusion_ocr_wq(struct work_struct *work); 188 static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance, 189 int initial); 190 int megasas_check_mpio_paths(struct megasas_instance *instance, 191 struct scsi_cmnd *scmd); 192 193 void 194 megasas_issue_dcmd(struct megasas_instance *instance, struct megasas_cmd *cmd) 195 { 196 instance->instancet->fire_cmd(instance, 197 cmd->frame_phys_addr, 0, instance->reg_set); 198 } 199 200 /** 201 * megasas_get_cmd - Get a command from the free pool 202 * @instance: Adapter soft state 203 * 204 * Returns a free command from the pool 205 */ 206 struct megasas_cmd *megasas_get_cmd(struct megasas_instance 207 *instance) 208 { 209 unsigned long flags; 210 struct megasas_cmd *cmd = NULL; 211 212 spin_lock_irqsave(&instance->mfi_pool_lock, flags); 213 214 if (!list_empty(&instance->cmd_pool)) { 215 cmd = list_entry((&instance->cmd_pool)->next, 216 struct megasas_cmd, list); 217 list_del_init(&cmd->list); 218 } else { 219 dev_err(&instance->pdev->dev, "Command pool empty!\n"); 220 } 221 222 spin_unlock_irqrestore(&instance->mfi_pool_lock, flags); 223 return cmd; 224 } 225 226 /** 227 * megasas_return_cmd - Return a cmd to free command pool 228 * @instance: Adapter soft state 229 * @cmd: Command packet to be returned to free command pool 230 */ 231 inline void 232 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd) 233 { 234 unsigned long flags; 235 u32 blk_tags; 236 struct megasas_cmd_fusion *cmd_fusion; 237 struct fusion_context *fusion = instance->ctrl_context; 238 239 /* This flag is used only for fusion adapter. 240 * Wait for Interrupt for Polled mode DCMD 241 */ 242 if (cmd->flags & DRV_DCMD_POLLED_MODE) 243 return; 244 245 spin_lock_irqsave(&instance->mfi_pool_lock, flags); 246 247 if (fusion) { 248 blk_tags = instance->max_scsi_cmds + cmd->index; 249 cmd_fusion = fusion->cmd_list[blk_tags]; 250 megasas_return_cmd_fusion(instance, cmd_fusion); 251 } 252 cmd->scmd = NULL; 253 cmd->frame_count = 0; 254 cmd->flags = 0; 255 if (!fusion && reset_devices) 256 cmd->frame->hdr.cmd = MFI_CMD_INVALID; 257 list_add(&cmd->list, (&instance->cmd_pool)->next); 258 259 spin_unlock_irqrestore(&instance->mfi_pool_lock, flags); 260 261 } 262 263 /** 264 * The following functions are defined for xscale 265 * (deviceid : 1064R, PERC5) controllers 266 */ 267 268 /** 269 * megasas_enable_intr_xscale - Enables interrupts 270 * @regs: MFI register set 271 */ 272 static inline void 273 megasas_enable_intr_xscale(struct megasas_instance *instance) 274 { 275 struct megasas_register_set __iomem *regs; 276 277 regs = instance->reg_set; 278 writel(0, &(regs)->outbound_intr_mask); 279 280 /* Dummy readl to force pci flush */ 281 readl(®s->outbound_intr_mask); 282 } 283 284 /** 285 * megasas_disable_intr_xscale -Disables interrupt 286 * @regs: MFI register set 287 */ 288 static inline void 289 megasas_disable_intr_xscale(struct megasas_instance *instance) 290 { 291 struct megasas_register_set __iomem *regs; 292 u32 mask = 0x1f; 293 294 regs = instance->reg_set; 295 writel(mask, ®s->outbound_intr_mask); 296 /* Dummy readl to force pci flush */ 297 readl(®s->outbound_intr_mask); 298 } 299 300 /** 301 * megasas_read_fw_status_reg_xscale - returns the current FW status value 302 * @regs: MFI register set 303 */ 304 static u32 305 megasas_read_fw_status_reg_xscale(struct megasas_register_set __iomem * regs) 306 { 307 return readl(&(regs)->outbound_msg_0); 308 } 309 /** 310 * megasas_clear_interrupt_xscale - Check & clear interrupt 311 * @regs: MFI register set 312 */ 313 static int 314 megasas_clear_intr_xscale(struct megasas_register_set __iomem * regs) 315 { 316 u32 status; 317 u32 mfiStatus = 0; 318 319 /* 320 * Check if it is our interrupt 321 */ 322 status = readl(®s->outbound_intr_status); 323 324 if (status & MFI_OB_INTR_STATUS_MASK) 325 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE; 326 if (status & MFI_XSCALE_OMR0_CHANGE_INTERRUPT) 327 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE; 328 329 /* 330 * Clear the interrupt by writing back the same value 331 */ 332 if (mfiStatus) 333 writel(status, ®s->outbound_intr_status); 334 335 /* Dummy readl to force pci flush */ 336 readl(®s->outbound_intr_status); 337 338 return mfiStatus; 339 } 340 341 /** 342 * megasas_fire_cmd_xscale - Sends command to the FW 343 * @frame_phys_addr : Physical address of cmd 344 * @frame_count : Number of frames for the command 345 * @regs : MFI register set 346 */ 347 static inline void 348 megasas_fire_cmd_xscale(struct megasas_instance *instance, 349 dma_addr_t frame_phys_addr, 350 u32 frame_count, 351 struct megasas_register_set __iomem *regs) 352 { 353 unsigned long flags; 354 355 spin_lock_irqsave(&instance->hba_lock, flags); 356 writel((frame_phys_addr >> 3)|(frame_count), 357 &(regs)->inbound_queue_port); 358 spin_unlock_irqrestore(&instance->hba_lock, flags); 359 } 360 361 /** 362 * megasas_adp_reset_xscale - For controller reset 363 * @regs: MFI register set 364 */ 365 static int 366 megasas_adp_reset_xscale(struct megasas_instance *instance, 367 struct megasas_register_set __iomem *regs) 368 { 369 u32 i; 370 u32 pcidata; 371 372 writel(MFI_ADP_RESET, ®s->inbound_doorbell); 373 374 for (i = 0; i < 3; i++) 375 msleep(1000); /* sleep for 3 secs */ 376 pcidata = 0; 377 pci_read_config_dword(instance->pdev, MFI_1068_PCSR_OFFSET, &pcidata); 378 dev_notice(&instance->pdev->dev, "pcidata = %x\n", pcidata); 379 if (pcidata & 0x2) { 380 dev_notice(&instance->pdev->dev, "mfi 1068 offset read=%x\n", pcidata); 381 pcidata &= ~0x2; 382 pci_write_config_dword(instance->pdev, 383 MFI_1068_PCSR_OFFSET, pcidata); 384 385 for (i = 0; i < 2; i++) 386 msleep(1000); /* need to wait 2 secs again */ 387 388 pcidata = 0; 389 pci_read_config_dword(instance->pdev, 390 MFI_1068_FW_HANDSHAKE_OFFSET, &pcidata); 391 dev_notice(&instance->pdev->dev, "1068 offset handshake read=%x\n", pcidata); 392 if ((pcidata & 0xffff0000) == MFI_1068_FW_READY) { 393 dev_notice(&instance->pdev->dev, "1068 offset pcidt=%x\n", pcidata); 394 pcidata = 0; 395 pci_write_config_dword(instance->pdev, 396 MFI_1068_FW_HANDSHAKE_OFFSET, pcidata); 397 } 398 } 399 return 0; 400 } 401 402 /** 403 * megasas_check_reset_xscale - For controller reset check 404 * @regs: MFI register set 405 */ 406 static int 407 megasas_check_reset_xscale(struct megasas_instance *instance, 408 struct megasas_register_set __iomem *regs) 409 { 410 if ((instance->adprecovery != MEGASAS_HBA_OPERATIONAL) && 411 (le32_to_cpu(*instance->consumer) == 412 MEGASAS_ADPRESET_INPROG_SIGN)) 413 return 1; 414 return 0; 415 } 416 417 static struct megasas_instance_template megasas_instance_template_xscale = { 418 419 .fire_cmd = megasas_fire_cmd_xscale, 420 .enable_intr = megasas_enable_intr_xscale, 421 .disable_intr = megasas_disable_intr_xscale, 422 .clear_intr = megasas_clear_intr_xscale, 423 .read_fw_status_reg = megasas_read_fw_status_reg_xscale, 424 .adp_reset = megasas_adp_reset_xscale, 425 .check_reset = megasas_check_reset_xscale, 426 .service_isr = megasas_isr, 427 .tasklet = megasas_complete_cmd_dpc, 428 .init_adapter = megasas_init_adapter_mfi, 429 .build_and_issue_cmd = megasas_build_and_issue_cmd, 430 .issue_dcmd = megasas_issue_dcmd, 431 }; 432 433 /** 434 * This is the end of set of functions & definitions specific 435 * to xscale (deviceid : 1064R, PERC5) controllers 436 */ 437 438 /** 439 * The following functions are defined for ppc (deviceid : 0x60) 440 * controllers 441 */ 442 443 /** 444 * megasas_enable_intr_ppc - Enables interrupts 445 * @regs: MFI register set 446 */ 447 static inline void 448 megasas_enable_intr_ppc(struct megasas_instance *instance) 449 { 450 struct megasas_register_set __iomem *regs; 451 452 regs = instance->reg_set; 453 writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear); 454 455 writel(~0x80000000, &(regs)->outbound_intr_mask); 456 457 /* Dummy readl to force pci flush */ 458 readl(®s->outbound_intr_mask); 459 } 460 461 /** 462 * megasas_disable_intr_ppc - Disable interrupt 463 * @regs: MFI register set 464 */ 465 static inline void 466 megasas_disable_intr_ppc(struct megasas_instance *instance) 467 { 468 struct megasas_register_set __iomem *regs; 469 u32 mask = 0xFFFFFFFF; 470 471 regs = instance->reg_set; 472 writel(mask, ®s->outbound_intr_mask); 473 /* Dummy readl to force pci flush */ 474 readl(®s->outbound_intr_mask); 475 } 476 477 /** 478 * megasas_read_fw_status_reg_ppc - returns the current FW status value 479 * @regs: MFI register set 480 */ 481 static u32 482 megasas_read_fw_status_reg_ppc(struct megasas_register_set __iomem * regs) 483 { 484 return readl(&(regs)->outbound_scratch_pad); 485 } 486 487 /** 488 * megasas_clear_interrupt_ppc - Check & clear interrupt 489 * @regs: MFI register set 490 */ 491 static int 492 megasas_clear_intr_ppc(struct megasas_register_set __iomem * regs) 493 { 494 u32 status, mfiStatus = 0; 495 496 /* 497 * Check if it is our interrupt 498 */ 499 status = readl(®s->outbound_intr_status); 500 501 if (status & MFI_REPLY_1078_MESSAGE_INTERRUPT) 502 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE; 503 504 if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT) 505 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE; 506 507 /* 508 * Clear the interrupt by writing back the same value 509 */ 510 writel(status, ®s->outbound_doorbell_clear); 511 512 /* Dummy readl to force pci flush */ 513 readl(®s->outbound_doorbell_clear); 514 515 return mfiStatus; 516 } 517 518 /** 519 * megasas_fire_cmd_ppc - Sends command to the FW 520 * @frame_phys_addr : Physical address of cmd 521 * @frame_count : Number of frames for the command 522 * @regs : MFI register set 523 */ 524 static inline void 525 megasas_fire_cmd_ppc(struct megasas_instance *instance, 526 dma_addr_t frame_phys_addr, 527 u32 frame_count, 528 struct megasas_register_set __iomem *regs) 529 { 530 unsigned long flags; 531 532 spin_lock_irqsave(&instance->hba_lock, flags); 533 writel((frame_phys_addr | (frame_count<<1))|1, 534 &(regs)->inbound_queue_port); 535 spin_unlock_irqrestore(&instance->hba_lock, flags); 536 } 537 538 /** 539 * megasas_check_reset_ppc - For controller reset check 540 * @regs: MFI register set 541 */ 542 static int 543 megasas_check_reset_ppc(struct megasas_instance *instance, 544 struct megasas_register_set __iomem *regs) 545 { 546 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) 547 return 1; 548 549 return 0; 550 } 551 552 static struct megasas_instance_template megasas_instance_template_ppc = { 553 554 .fire_cmd = megasas_fire_cmd_ppc, 555 .enable_intr = megasas_enable_intr_ppc, 556 .disable_intr = megasas_disable_intr_ppc, 557 .clear_intr = megasas_clear_intr_ppc, 558 .read_fw_status_reg = megasas_read_fw_status_reg_ppc, 559 .adp_reset = megasas_adp_reset_xscale, 560 .check_reset = megasas_check_reset_ppc, 561 .service_isr = megasas_isr, 562 .tasklet = megasas_complete_cmd_dpc, 563 .init_adapter = megasas_init_adapter_mfi, 564 .build_and_issue_cmd = megasas_build_and_issue_cmd, 565 .issue_dcmd = megasas_issue_dcmd, 566 }; 567 568 /** 569 * megasas_enable_intr_skinny - Enables interrupts 570 * @regs: MFI register set 571 */ 572 static inline void 573 megasas_enable_intr_skinny(struct megasas_instance *instance) 574 { 575 struct megasas_register_set __iomem *regs; 576 577 regs = instance->reg_set; 578 writel(0xFFFFFFFF, &(regs)->outbound_intr_mask); 579 580 writel(~MFI_SKINNY_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask); 581 582 /* Dummy readl to force pci flush */ 583 readl(®s->outbound_intr_mask); 584 } 585 586 /** 587 * megasas_disable_intr_skinny - Disables interrupt 588 * @regs: MFI register set 589 */ 590 static inline void 591 megasas_disable_intr_skinny(struct megasas_instance *instance) 592 { 593 struct megasas_register_set __iomem *regs; 594 u32 mask = 0xFFFFFFFF; 595 596 regs = instance->reg_set; 597 writel(mask, ®s->outbound_intr_mask); 598 /* Dummy readl to force pci flush */ 599 readl(®s->outbound_intr_mask); 600 } 601 602 /** 603 * megasas_read_fw_status_reg_skinny - returns the current FW status value 604 * @regs: MFI register set 605 */ 606 static u32 607 megasas_read_fw_status_reg_skinny(struct megasas_register_set __iomem *regs) 608 { 609 return readl(&(regs)->outbound_scratch_pad); 610 } 611 612 /** 613 * megasas_clear_interrupt_skinny - Check & clear interrupt 614 * @regs: MFI register set 615 */ 616 static int 617 megasas_clear_intr_skinny(struct megasas_register_set __iomem *regs) 618 { 619 u32 status; 620 u32 mfiStatus = 0; 621 622 /* 623 * Check if it is our interrupt 624 */ 625 status = readl(®s->outbound_intr_status); 626 627 if (!(status & MFI_SKINNY_ENABLE_INTERRUPT_MASK)) { 628 return 0; 629 } 630 631 /* 632 * Check if it is our interrupt 633 */ 634 if ((megasas_read_fw_status_reg_skinny(regs) & MFI_STATE_MASK) == 635 MFI_STATE_FAULT) { 636 mfiStatus = MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE; 637 } else 638 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE; 639 640 /* 641 * Clear the interrupt by writing back the same value 642 */ 643 writel(status, ®s->outbound_intr_status); 644 645 /* 646 * dummy read to flush PCI 647 */ 648 readl(®s->outbound_intr_status); 649 650 return mfiStatus; 651 } 652 653 /** 654 * megasas_fire_cmd_skinny - Sends command to the FW 655 * @frame_phys_addr : Physical address of cmd 656 * @frame_count : Number of frames for the command 657 * @regs : MFI register set 658 */ 659 static inline void 660 megasas_fire_cmd_skinny(struct megasas_instance *instance, 661 dma_addr_t frame_phys_addr, 662 u32 frame_count, 663 struct megasas_register_set __iomem *regs) 664 { 665 unsigned long flags; 666 667 spin_lock_irqsave(&instance->hba_lock, flags); 668 writel(upper_32_bits(frame_phys_addr), 669 &(regs)->inbound_high_queue_port); 670 writel((lower_32_bits(frame_phys_addr) | (frame_count<<1))|1, 671 &(regs)->inbound_low_queue_port); 672 spin_unlock_irqrestore(&instance->hba_lock, flags); 673 } 674 675 /** 676 * megasas_check_reset_skinny - For controller reset check 677 * @regs: MFI register set 678 */ 679 static int 680 megasas_check_reset_skinny(struct megasas_instance *instance, 681 struct megasas_register_set __iomem *regs) 682 { 683 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) 684 return 1; 685 686 return 0; 687 } 688 689 static struct megasas_instance_template megasas_instance_template_skinny = { 690 691 .fire_cmd = megasas_fire_cmd_skinny, 692 .enable_intr = megasas_enable_intr_skinny, 693 .disable_intr = megasas_disable_intr_skinny, 694 .clear_intr = megasas_clear_intr_skinny, 695 .read_fw_status_reg = megasas_read_fw_status_reg_skinny, 696 .adp_reset = megasas_adp_reset_gen2, 697 .check_reset = megasas_check_reset_skinny, 698 .service_isr = megasas_isr, 699 .tasklet = megasas_complete_cmd_dpc, 700 .init_adapter = megasas_init_adapter_mfi, 701 .build_and_issue_cmd = megasas_build_and_issue_cmd, 702 .issue_dcmd = megasas_issue_dcmd, 703 }; 704 705 706 /** 707 * The following functions are defined for gen2 (deviceid : 0x78 0x79) 708 * controllers 709 */ 710 711 /** 712 * megasas_enable_intr_gen2 - Enables interrupts 713 * @regs: MFI register set 714 */ 715 static inline void 716 megasas_enable_intr_gen2(struct megasas_instance *instance) 717 { 718 struct megasas_register_set __iomem *regs; 719 720 regs = instance->reg_set; 721 writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear); 722 723 /* write ~0x00000005 (4 & 1) to the intr mask*/ 724 writel(~MFI_GEN2_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask); 725 726 /* Dummy readl to force pci flush */ 727 readl(®s->outbound_intr_mask); 728 } 729 730 /** 731 * megasas_disable_intr_gen2 - Disables interrupt 732 * @regs: MFI register set 733 */ 734 static inline void 735 megasas_disable_intr_gen2(struct megasas_instance *instance) 736 { 737 struct megasas_register_set __iomem *regs; 738 u32 mask = 0xFFFFFFFF; 739 740 regs = instance->reg_set; 741 writel(mask, ®s->outbound_intr_mask); 742 /* Dummy readl to force pci flush */ 743 readl(®s->outbound_intr_mask); 744 } 745 746 /** 747 * megasas_read_fw_status_reg_gen2 - returns the current FW status value 748 * @regs: MFI register set 749 */ 750 static u32 751 megasas_read_fw_status_reg_gen2(struct megasas_register_set __iomem *regs) 752 { 753 return readl(&(regs)->outbound_scratch_pad); 754 } 755 756 /** 757 * megasas_clear_interrupt_gen2 - Check & clear interrupt 758 * @regs: MFI register set 759 */ 760 static int 761 megasas_clear_intr_gen2(struct megasas_register_set __iomem *regs) 762 { 763 u32 status; 764 u32 mfiStatus = 0; 765 766 /* 767 * Check if it is our interrupt 768 */ 769 status = readl(®s->outbound_intr_status); 770 771 if (status & MFI_INTR_FLAG_REPLY_MESSAGE) { 772 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE; 773 } 774 if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT) { 775 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE; 776 } 777 778 /* 779 * Clear the interrupt by writing back the same value 780 */ 781 if (mfiStatus) 782 writel(status, ®s->outbound_doorbell_clear); 783 784 /* Dummy readl to force pci flush */ 785 readl(®s->outbound_intr_status); 786 787 return mfiStatus; 788 } 789 /** 790 * megasas_fire_cmd_gen2 - Sends command to the FW 791 * @frame_phys_addr : Physical address of cmd 792 * @frame_count : Number of frames for the command 793 * @regs : MFI register set 794 */ 795 static inline void 796 megasas_fire_cmd_gen2(struct megasas_instance *instance, 797 dma_addr_t frame_phys_addr, 798 u32 frame_count, 799 struct megasas_register_set __iomem *regs) 800 { 801 unsigned long flags; 802 803 spin_lock_irqsave(&instance->hba_lock, flags); 804 writel((frame_phys_addr | (frame_count<<1))|1, 805 &(regs)->inbound_queue_port); 806 spin_unlock_irqrestore(&instance->hba_lock, flags); 807 } 808 809 /** 810 * megasas_adp_reset_gen2 - For controller reset 811 * @regs: MFI register set 812 */ 813 static int 814 megasas_adp_reset_gen2(struct megasas_instance *instance, 815 struct megasas_register_set __iomem *reg_set) 816 { 817 u32 retry = 0 ; 818 u32 HostDiag; 819 u32 __iomem *seq_offset = ®_set->seq_offset; 820 u32 __iomem *hostdiag_offset = ®_set->host_diag; 821 822 if (instance->instancet == &megasas_instance_template_skinny) { 823 seq_offset = ®_set->fusion_seq_offset; 824 hostdiag_offset = ®_set->fusion_host_diag; 825 } 826 827 writel(0, seq_offset); 828 writel(4, seq_offset); 829 writel(0xb, seq_offset); 830 writel(2, seq_offset); 831 writel(7, seq_offset); 832 writel(0xd, seq_offset); 833 834 msleep(1000); 835 836 HostDiag = (u32)readl(hostdiag_offset); 837 838 while (!(HostDiag & DIAG_WRITE_ENABLE)) { 839 msleep(100); 840 HostDiag = (u32)readl(hostdiag_offset); 841 dev_notice(&instance->pdev->dev, "RESETGEN2: retry=%x, hostdiag=%x\n", 842 retry, HostDiag); 843 844 if (retry++ >= 100) 845 return 1; 846 847 } 848 849 dev_notice(&instance->pdev->dev, "ADP_RESET_GEN2: HostDiag=%x\n", HostDiag); 850 851 writel((HostDiag | DIAG_RESET_ADAPTER), hostdiag_offset); 852 853 ssleep(10); 854 855 HostDiag = (u32)readl(hostdiag_offset); 856 while (HostDiag & DIAG_RESET_ADAPTER) { 857 msleep(100); 858 HostDiag = (u32)readl(hostdiag_offset); 859 dev_notice(&instance->pdev->dev, "RESET_GEN2: retry=%x, hostdiag=%x\n", 860 retry, HostDiag); 861 862 if (retry++ >= 1000) 863 return 1; 864 865 } 866 return 0; 867 } 868 869 /** 870 * megasas_check_reset_gen2 - For controller reset check 871 * @regs: MFI register set 872 */ 873 static int 874 megasas_check_reset_gen2(struct megasas_instance *instance, 875 struct megasas_register_set __iomem *regs) 876 { 877 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) { 878 return 1; 879 } 880 881 return 0; 882 } 883 884 static struct megasas_instance_template megasas_instance_template_gen2 = { 885 886 .fire_cmd = megasas_fire_cmd_gen2, 887 .enable_intr = megasas_enable_intr_gen2, 888 .disable_intr = megasas_disable_intr_gen2, 889 .clear_intr = megasas_clear_intr_gen2, 890 .read_fw_status_reg = megasas_read_fw_status_reg_gen2, 891 .adp_reset = megasas_adp_reset_gen2, 892 .check_reset = megasas_check_reset_gen2, 893 .service_isr = megasas_isr, 894 .tasklet = megasas_complete_cmd_dpc, 895 .init_adapter = megasas_init_adapter_mfi, 896 .build_and_issue_cmd = megasas_build_and_issue_cmd, 897 .issue_dcmd = megasas_issue_dcmd, 898 }; 899 900 /** 901 * This is the end of set of functions & definitions 902 * specific to gen2 (deviceid : 0x78, 0x79) controllers 903 */ 904 905 /* 906 * Template added for TB (Fusion) 907 */ 908 extern struct megasas_instance_template megasas_instance_template_fusion; 909 910 /** 911 * megasas_issue_polled - Issues a polling command 912 * @instance: Adapter soft state 913 * @cmd: Command packet to be issued 914 * 915 * For polling, MFI requires the cmd_status to be set to MFI_STAT_INVALID_STATUS before posting. 916 */ 917 int 918 megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd) 919 { 920 int seconds; 921 struct megasas_header *frame_hdr = &cmd->frame->hdr; 922 923 frame_hdr->cmd_status = MFI_CMD_STATUS_POLL_MODE; 924 frame_hdr->flags |= cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE); 925 926 /* 927 * Issue the frame using inbound queue port 928 */ 929 instance->instancet->issue_dcmd(instance, cmd); 930 931 /* 932 * Wait for cmd_status to change 933 */ 934 if (instance->requestorId) 935 seconds = MEGASAS_ROUTINE_WAIT_TIME_VF; 936 else 937 seconds = MFI_POLL_TIMEOUT_SECS; 938 return wait_and_poll(instance, cmd, seconds); 939 } 940 941 /** 942 * megasas_issue_blocked_cmd - Synchronous wrapper around regular FW cmds 943 * @instance: Adapter soft state 944 * @cmd: Command to be issued 945 * @timeout: Timeout in seconds 946 * 947 * This function waits on an event for the command to be returned from ISR. 948 * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs 949 * Used to issue ioctl commands. 950 */ 951 int 952 megasas_issue_blocked_cmd(struct megasas_instance *instance, 953 struct megasas_cmd *cmd, int timeout) 954 { 955 int ret = 0; 956 957 cmd->cmd_status_drv = MFI_STAT_INVALID_STATUS; 958 959 instance->instancet->issue_dcmd(instance, cmd); 960 if (timeout) { 961 ret = wait_event_timeout(instance->int_cmd_wait_q, 962 cmd->cmd_status_drv != MFI_STAT_INVALID_STATUS, timeout * HZ); 963 if (!ret) 964 return 1; 965 } else 966 wait_event(instance->int_cmd_wait_q, 967 cmd->cmd_status_drv != MFI_STAT_INVALID_STATUS); 968 969 return (cmd->cmd_status_drv == MFI_STAT_OK) ? 970 0 : 1; 971 } 972 973 /** 974 * megasas_issue_blocked_abort_cmd - Aborts previously issued cmd 975 * @instance: Adapter soft state 976 * @cmd_to_abort: Previously issued cmd to be aborted 977 * @timeout: Timeout in seconds 978 * 979 * MFI firmware can abort previously issued AEN comamnd (automatic event 980 * notification). The megasas_issue_blocked_abort_cmd() issues such abort 981 * cmd and waits for return status. 982 * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs 983 */ 984 static int 985 megasas_issue_blocked_abort_cmd(struct megasas_instance *instance, 986 struct megasas_cmd *cmd_to_abort, int timeout) 987 { 988 struct megasas_cmd *cmd; 989 struct megasas_abort_frame *abort_fr; 990 int ret = 0; 991 992 cmd = megasas_get_cmd(instance); 993 994 if (!cmd) 995 return -1; 996 997 abort_fr = &cmd->frame->abort; 998 999 /* 1000 * Prepare and issue the abort frame 1001 */ 1002 abort_fr->cmd = MFI_CMD_ABORT; 1003 abort_fr->cmd_status = MFI_STAT_INVALID_STATUS; 1004 abort_fr->flags = cpu_to_le16(0); 1005 abort_fr->abort_context = cpu_to_le32(cmd_to_abort->index); 1006 abort_fr->abort_mfi_phys_addr_lo = 1007 cpu_to_le32(lower_32_bits(cmd_to_abort->frame_phys_addr)); 1008 abort_fr->abort_mfi_phys_addr_hi = 1009 cpu_to_le32(upper_32_bits(cmd_to_abort->frame_phys_addr)); 1010 1011 cmd->sync_cmd = 1; 1012 cmd->cmd_status_drv = MFI_STAT_INVALID_STATUS; 1013 1014 instance->instancet->issue_dcmd(instance, cmd); 1015 1016 if (timeout) { 1017 ret = wait_event_timeout(instance->abort_cmd_wait_q, 1018 cmd->cmd_status_drv != MFI_STAT_INVALID_STATUS, timeout * HZ); 1019 if (!ret) { 1020 dev_err(&instance->pdev->dev, "Command timedout" 1021 "from %s\n", __func__); 1022 return 1; 1023 } 1024 } else 1025 wait_event(instance->abort_cmd_wait_q, 1026 cmd->cmd_status_drv != MFI_STAT_INVALID_STATUS); 1027 1028 cmd->sync_cmd = 0; 1029 1030 megasas_return_cmd(instance, cmd); 1031 return 0; 1032 } 1033 1034 /** 1035 * megasas_make_sgl32 - Prepares 32-bit SGL 1036 * @instance: Adapter soft state 1037 * @scp: SCSI command from the mid-layer 1038 * @mfi_sgl: SGL to be filled in 1039 * 1040 * If successful, this function returns the number of SG elements. Otherwise, 1041 * it returnes -1. 1042 */ 1043 static int 1044 megasas_make_sgl32(struct megasas_instance *instance, struct scsi_cmnd *scp, 1045 union megasas_sgl *mfi_sgl) 1046 { 1047 int i; 1048 int sge_count; 1049 struct scatterlist *os_sgl; 1050 1051 sge_count = scsi_dma_map(scp); 1052 BUG_ON(sge_count < 0); 1053 1054 if (sge_count) { 1055 scsi_for_each_sg(scp, os_sgl, sge_count, i) { 1056 mfi_sgl->sge32[i].length = cpu_to_le32(sg_dma_len(os_sgl)); 1057 mfi_sgl->sge32[i].phys_addr = cpu_to_le32(sg_dma_address(os_sgl)); 1058 } 1059 } 1060 return sge_count; 1061 } 1062 1063 /** 1064 * megasas_make_sgl64 - Prepares 64-bit SGL 1065 * @instance: Adapter soft state 1066 * @scp: SCSI command from the mid-layer 1067 * @mfi_sgl: SGL to be filled in 1068 * 1069 * If successful, this function returns the number of SG elements. Otherwise, 1070 * it returnes -1. 1071 */ 1072 static int 1073 megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp, 1074 union megasas_sgl *mfi_sgl) 1075 { 1076 int i; 1077 int sge_count; 1078 struct scatterlist *os_sgl; 1079 1080 sge_count = scsi_dma_map(scp); 1081 BUG_ON(sge_count < 0); 1082 1083 if (sge_count) { 1084 scsi_for_each_sg(scp, os_sgl, sge_count, i) { 1085 mfi_sgl->sge64[i].length = cpu_to_le32(sg_dma_len(os_sgl)); 1086 mfi_sgl->sge64[i].phys_addr = cpu_to_le64(sg_dma_address(os_sgl)); 1087 } 1088 } 1089 return sge_count; 1090 } 1091 1092 /** 1093 * megasas_make_sgl_skinny - Prepares IEEE SGL 1094 * @instance: Adapter soft state 1095 * @scp: SCSI command from the mid-layer 1096 * @mfi_sgl: SGL to be filled in 1097 * 1098 * If successful, this function returns the number of SG elements. Otherwise, 1099 * it returnes -1. 1100 */ 1101 static int 1102 megasas_make_sgl_skinny(struct megasas_instance *instance, 1103 struct scsi_cmnd *scp, union megasas_sgl *mfi_sgl) 1104 { 1105 int i; 1106 int sge_count; 1107 struct scatterlist *os_sgl; 1108 1109 sge_count = scsi_dma_map(scp); 1110 1111 if (sge_count) { 1112 scsi_for_each_sg(scp, os_sgl, sge_count, i) { 1113 mfi_sgl->sge_skinny[i].length = 1114 cpu_to_le32(sg_dma_len(os_sgl)); 1115 mfi_sgl->sge_skinny[i].phys_addr = 1116 cpu_to_le64(sg_dma_address(os_sgl)); 1117 mfi_sgl->sge_skinny[i].flag = cpu_to_le32(0); 1118 } 1119 } 1120 return sge_count; 1121 } 1122 1123 /** 1124 * megasas_get_frame_count - Computes the number of frames 1125 * @frame_type : type of frame- io or pthru frame 1126 * @sge_count : number of sg elements 1127 * 1128 * Returns the number of frames required for numnber of sge's (sge_count) 1129 */ 1130 1131 static u32 megasas_get_frame_count(struct megasas_instance *instance, 1132 u8 sge_count, u8 frame_type) 1133 { 1134 int num_cnt; 1135 int sge_bytes; 1136 u32 sge_sz; 1137 u32 frame_count = 0; 1138 1139 sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) : 1140 sizeof(struct megasas_sge32); 1141 1142 if (instance->flag_ieee) { 1143 sge_sz = sizeof(struct megasas_sge_skinny); 1144 } 1145 1146 /* 1147 * Main frame can contain 2 SGEs for 64-bit SGLs and 1148 * 3 SGEs for 32-bit SGLs for ldio & 1149 * 1 SGEs for 64-bit SGLs and 1150 * 2 SGEs for 32-bit SGLs for pthru frame 1151 */ 1152 if (unlikely(frame_type == PTHRU_FRAME)) { 1153 if (instance->flag_ieee == 1) { 1154 num_cnt = sge_count - 1; 1155 } else if (IS_DMA64) 1156 num_cnt = sge_count - 1; 1157 else 1158 num_cnt = sge_count - 2; 1159 } else { 1160 if (instance->flag_ieee == 1) { 1161 num_cnt = sge_count - 1; 1162 } else if (IS_DMA64) 1163 num_cnt = sge_count - 2; 1164 else 1165 num_cnt = sge_count - 3; 1166 } 1167 1168 if (num_cnt > 0) { 1169 sge_bytes = sge_sz * num_cnt; 1170 1171 frame_count = (sge_bytes / MEGAMFI_FRAME_SIZE) + 1172 ((sge_bytes % MEGAMFI_FRAME_SIZE) ? 1 : 0) ; 1173 } 1174 /* Main frame */ 1175 frame_count += 1; 1176 1177 if (frame_count > 7) 1178 frame_count = 8; 1179 return frame_count; 1180 } 1181 1182 /** 1183 * megasas_build_dcdb - Prepares a direct cdb (DCDB) command 1184 * @instance: Adapter soft state 1185 * @scp: SCSI command 1186 * @cmd: Command to be prepared in 1187 * 1188 * This function prepares CDB commands. These are typcially pass-through 1189 * commands to the devices. 1190 */ 1191 static int 1192 megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp, 1193 struct megasas_cmd *cmd) 1194 { 1195 u32 is_logical; 1196 u32 device_id; 1197 u16 flags = 0; 1198 struct megasas_pthru_frame *pthru; 1199 1200 is_logical = MEGASAS_IS_LOGICAL(scp); 1201 device_id = MEGASAS_DEV_INDEX(scp); 1202 pthru = (struct megasas_pthru_frame *)cmd->frame; 1203 1204 if (scp->sc_data_direction == PCI_DMA_TODEVICE) 1205 flags = MFI_FRAME_DIR_WRITE; 1206 else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) 1207 flags = MFI_FRAME_DIR_READ; 1208 else if (scp->sc_data_direction == PCI_DMA_NONE) 1209 flags = MFI_FRAME_DIR_NONE; 1210 1211 if (instance->flag_ieee == 1) { 1212 flags |= MFI_FRAME_IEEE; 1213 } 1214 1215 /* 1216 * Prepare the DCDB frame 1217 */ 1218 pthru->cmd = (is_logical) ? MFI_CMD_LD_SCSI_IO : MFI_CMD_PD_SCSI_IO; 1219 pthru->cmd_status = 0x0; 1220 pthru->scsi_status = 0x0; 1221 pthru->target_id = device_id; 1222 pthru->lun = scp->device->lun; 1223 pthru->cdb_len = scp->cmd_len; 1224 pthru->timeout = 0; 1225 pthru->pad_0 = 0; 1226 pthru->flags = cpu_to_le16(flags); 1227 pthru->data_xfer_len = cpu_to_le32(scsi_bufflen(scp)); 1228 1229 memcpy(pthru->cdb, scp->cmnd, scp->cmd_len); 1230 1231 /* 1232 * If the command is for the tape device, set the 1233 * pthru timeout to the os layer timeout value. 1234 */ 1235 if (scp->device->type == TYPE_TAPE) { 1236 if ((scp->request->timeout / HZ) > 0xFFFF) 1237 pthru->timeout = cpu_to_le16(0xFFFF); 1238 else 1239 pthru->timeout = cpu_to_le16(scp->request->timeout / HZ); 1240 } 1241 1242 /* 1243 * Construct SGL 1244 */ 1245 if (instance->flag_ieee == 1) { 1246 pthru->flags |= cpu_to_le16(MFI_FRAME_SGL64); 1247 pthru->sge_count = megasas_make_sgl_skinny(instance, scp, 1248 &pthru->sgl); 1249 } else if (IS_DMA64) { 1250 pthru->flags |= cpu_to_le16(MFI_FRAME_SGL64); 1251 pthru->sge_count = megasas_make_sgl64(instance, scp, 1252 &pthru->sgl); 1253 } else 1254 pthru->sge_count = megasas_make_sgl32(instance, scp, 1255 &pthru->sgl); 1256 1257 if (pthru->sge_count > instance->max_num_sge) { 1258 dev_err(&instance->pdev->dev, "DCDB too many SGE NUM=%x\n", 1259 pthru->sge_count); 1260 return 0; 1261 } 1262 1263 /* 1264 * Sense info specific 1265 */ 1266 pthru->sense_len = SCSI_SENSE_BUFFERSIZE; 1267 pthru->sense_buf_phys_addr_hi = 1268 cpu_to_le32(upper_32_bits(cmd->sense_phys_addr)); 1269 pthru->sense_buf_phys_addr_lo = 1270 cpu_to_le32(lower_32_bits(cmd->sense_phys_addr)); 1271 1272 /* 1273 * Compute the total number of frames this command consumes. FW uses 1274 * this number to pull sufficient number of frames from host memory. 1275 */ 1276 cmd->frame_count = megasas_get_frame_count(instance, pthru->sge_count, 1277 PTHRU_FRAME); 1278 1279 return cmd->frame_count; 1280 } 1281 1282 /** 1283 * megasas_build_ldio - Prepares IOs to logical devices 1284 * @instance: Adapter soft state 1285 * @scp: SCSI command 1286 * @cmd: Command to be prepared 1287 * 1288 * Frames (and accompanying SGLs) for regular SCSI IOs use this function. 1289 */ 1290 static int 1291 megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp, 1292 struct megasas_cmd *cmd) 1293 { 1294 u32 device_id; 1295 u8 sc = scp->cmnd[0]; 1296 u16 flags = 0; 1297 struct megasas_io_frame *ldio; 1298 1299 device_id = MEGASAS_DEV_INDEX(scp); 1300 ldio = (struct megasas_io_frame *)cmd->frame; 1301 1302 if (scp->sc_data_direction == PCI_DMA_TODEVICE) 1303 flags = MFI_FRAME_DIR_WRITE; 1304 else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) 1305 flags = MFI_FRAME_DIR_READ; 1306 1307 if (instance->flag_ieee == 1) { 1308 flags |= MFI_FRAME_IEEE; 1309 } 1310 1311 /* 1312 * Prepare the Logical IO frame: 2nd bit is zero for all read cmds 1313 */ 1314 ldio->cmd = (sc & 0x02) ? MFI_CMD_LD_WRITE : MFI_CMD_LD_READ; 1315 ldio->cmd_status = 0x0; 1316 ldio->scsi_status = 0x0; 1317 ldio->target_id = device_id; 1318 ldio->timeout = 0; 1319 ldio->reserved_0 = 0; 1320 ldio->pad_0 = 0; 1321 ldio->flags = cpu_to_le16(flags); 1322 ldio->start_lba_hi = 0; 1323 ldio->access_byte = (scp->cmd_len != 6) ? scp->cmnd[1] : 0; 1324 1325 /* 1326 * 6-byte READ(0x08) or WRITE(0x0A) cdb 1327 */ 1328 if (scp->cmd_len == 6) { 1329 ldio->lba_count = cpu_to_le32((u32) scp->cmnd[4]); 1330 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[1] << 16) | 1331 ((u32) scp->cmnd[2] << 8) | 1332 (u32) scp->cmnd[3]); 1333 1334 ldio->start_lba_lo &= cpu_to_le32(0x1FFFFF); 1335 } 1336 1337 /* 1338 * 10-byte READ(0x28) or WRITE(0x2A) cdb 1339 */ 1340 else if (scp->cmd_len == 10) { 1341 ldio->lba_count = cpu_to_le32((u32) scp->cmnd[8] | 1342 ((u32) scp->cmnd[7] << 8)); 1343 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[2] << 24) | 1344 ((u32) scp->cmnd[3] << 16) | 1345 ((u32) scp->cmnd[4] << 8) | 1346 (u32) scp->cmnd[5]); 1347 } 1348 1349 /* 1350 * 12-byte READ(0xA8) or WRITE(0xAA) cdb 1351 */ 1352 else if (scp->cmd_len == 12) { 1353 ldio->lba_count = cpu_to_le32(((u32) scp->cmnd[6] << 24) | 1354 ((u32) scp->cmnd[7] << 16) | 1355 ((u32) scp->cmnd[8] << 8) | 1356 (u32) scp->cmnd[9]); 1357 1358 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[2] << 24) | 1359 ((u32) scp->cmnd[3] << 16) | 1360 ((u32) scp->cmnd[4] << 8) | 1361 (u32) scp->cmnd[5]); 1362 } 1363 1364 /* 1365 * 16-byte READ(0x88) or WRITE(0x8A) cdb 1366 */ 1367 else if (scp->cmd_len == 16) { 1368 ldio->lba_count = cpu_to_le32(((u32) scp->cmnd[10] << 24) | 1369 ((u32) scp->cmnd[11] << 16) | 1370 ((u32) scp->cmnd[12] << 8) | 1371 (u32) scp->cmnd[13]); 1372 1373 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[6] << 24) | 1374 ((u32) scp->cmnd[7] << 16) | 1375 ((u32) scp->cmnd[8] << 8) | 1376 (u32) scp->cmnd[9]); 1377 1378 ldio->start_lba_hi = cpu_to_le32(((u32) scp->cmnd[2] << 24) | 1379 ((u32) scp->cmnd[3] << 16) | 1380 ((u32) scp->cmnd[4] << 8) | 1381 (u32) scp->cmnd[5]); 1382 1383 } 1384 1385 /* 1386 * Construct SGL 1387 */ 1388 if (instance->flag_ieee) { 1389 ldio->flags |= cpu_to_le16(MFI_FRAME_SGL64); 1390 ldio->sge_count = megasas_make_sgl_skinny(instance, scp, 1391 &ldio->sgl); 1392 } else if (IS_DMA64) { 1393 ldio->flags |= cpu_to_le16(MFI_FRAME_SGL64); 1394 ldio->sge_count = megasas_make_sgl64(instance, scp, &ldio->sgl); 1395 } else 1396 ldio->sge_count = megasas_make_sgl32(instance, scp, &ldio->sgl); 1397 1398 if (ldio->sge_count > instance->max_num_sge) { 1399 dev_err(&instance->pdev->dev, "build_ld_io: sge_count = %x\n", 1400 ldio->sge_count); 1401 return 0; 1402 } 1403 1404 /* 1405 * Sense info specific 1406 */ 1407 ldio->sense_len = SCSI_SENSE_BUFFERSIZE; 1408 ldio->sense_buf_phys_addr_hi = 0; 1409 ldio->sense_buf_phys_addr_lo = cpu_to_le32(cmd->sense_phys_addr); 1410 1411 /* 1412 * Compute the total number of frames this command consumes. FW uses 1413 * this number to pull sufficient number of frames from host memory. 1414 */ 1415 cmd->frame_count = megasas_get_frame_count(instance, 1416 ldio->sge_count, IO_FRAME); 1417 1418 return cmd->frame_count; 1419 } 1420 1421 /** 1422 * megasas_cmd_type - Checks if the cmd is for logical drive/sysPD 1423 * and whether it's RW or non RW 1424 * @scmd: SCSI command 1425 * 1426 */ 1427 inline int megasas_cmd_type(struct scsi_cmnd *cmd) 1428 { 1429 int ret; 1430 1431 switch (cmd->cmnd[0]) { 1432 case READ_10: 1433 case WRITE_10: 1434 case READ_12: 1435 case WRITE_12: 1436 case READ_6: 1437 case WRITE_6: 1438 case READ_16: 1439 case WRITE_16: 1440 ret = (MEGASAS_IS_LOGICAL(cmd)) ? 1441 READ_WRITE_LDIO : READ_WRITE_SYSPDIO; 1442 break; 1443 default: 1444 ret = (MEGASAS_IS_LOGICAL(cmd)) ? 1445 NON_READ_WRITE_LDIO : NON_READ_WRITE_SYSPDIO; 1446 } 1447 return ret; 1448 } 1449 1450 /** 1451 * megasas_dump_pending_frames - Dumps the frame address of all pending cmds 1452 * in FW 1453 * @instance: Adapter soft state 1454 */ 1455 static inline void 1456 megasas_dump_pending_frames(struct megasas_instance *instance) 1457 { 1458 struct megasas_cmd *cmd; 1459 int i,n; 1460 union megasas_sgl *mfi_sgl; 1461 struct megasas_io_frame *ldio; 1462 struct megasas_pthru_frame *pthru; 1463 u32 sgcount; 1464 u32 max_cmd = instance->max_fw_cmds; 1465 1466 dev_err(&instance->pdev->dev, "[%d]: Dumping Frame Phys Address of all pending cmds in FW\n",instance->host->host_no); 1467 dev_err(&instance->pdev->dev, "[%d]: Total OS Pending cmds : %d\n",instance->host->host_no,atomic_read(&instance->fw_outstanding)); 1468 if (IS_DMA64) 1469 dev_err(&instance->pdev->dev, "[%d]: 64 bit SGLs were sent to FW\n",instance->host->host_no); 1470 else 1471 dev_err(&instance->pdev->dev, "[%d]: 32 bit SGLs were sent to FW\n",instance->host->host_no); 1472 1473 dev_err(&instance->pdev->dev, "[%d]: Pending OS cmds in FW : \n",instance->host->host_no); 1474 for (i = 0; i < max_cmd; i++) { 1475 cmd = instance->cmd_list[i]; 1476 if (!cmd->scmd) 1477 continue; 1478 dev_err(&instance->pdev->dev, "[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr); 1479 if (megasas_cmd_type(cmd->scmd) == READ_WRITE_LDIO) { 1480 ldio = (struct megasas_io_frame *)cmd->frame; 1481 mfi_sgl = &ldio->sgl; 1482 sgcount = ldio->sge_count; 1483 dev_err(&instance->pdev->dev, "[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x," 1484 " lba lo : 0x%x, lba_hi : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n", 1485 instance->host->host_no, cmd->frame_count, ldio->cmd, ldio->target_id, 1486 le32_to_cpu(ldio->start_lba_lo), le32_to_cpu(ldio->start_lba_hi), 1487 le32_to_cpu(ldio->sense_buf_phys_addr_lo), sgcount); 1488 } else { 1489 pthru = (struct megasas_pthru_frame *) cmd->frame; 1490 mfi_sgl = &pthru->sgl; 1491 sgcount = pthru->sge_count; 1492 dev_err(&instance->pdev->dev, "[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x, " 1493 "lun : 0x%x, cdb_len : 0x%x, data xfer len : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n", 1494 instance->host->host_no, cmd->frame_count, pthru->cmd, pthru->target_id, 1495 pthru->lun, pthru->cdb_len, le32_to_cpu(pthru->data_xfer_len), 1496 le32_to_cpu(pthru->sense_buf_phys_addr_lo), sgcount); 1497 } 1498 if (megasas_dbg_lvl & MEGASAS_DBG_LVL) { 1499 for (n = 0; n < sgcount; n++) { 1500 if (IS_DMA64) 1501 dev_err(&instance->pdev->dev, "sgl len : 0x%x, sgl addr : 0x%llx\n", 1502 le32_to_cpu(mfi_sgl->sge64[n].length), 1503 le64_to_cpu(mfi_sgl->sge64[n].phys_addr)); 1504 else 1505 dev_err(&instance->pdev->dev, "sgl len : 0x%x, sgl addr : 0x%x\n", 1506 le32_to_cpu(mfi_sgl->sge32[n].length), 1507 le32_to_cpu(mfi_sgl->sge32[n].phys_addr)); 1508 } 1509 } 1510 } /*for max_cmd*/ 1511 dev_err(&instance->pdev->dev, "[%d]: Pending Internal cmds in FW : \n",instance->host->host_no); 1512 for (i = 0; i < max_cmd; i++) { 1513 1514 cmd = instance->cmd_list[i]; 1515 1516 if (cmd->sync_cmd == 1) 1517 dev_err(&instance->pdev->dev, "0x%08lx : ", (unsigned long)cmd->frame_phys_addr); 1518 } 1519 dev_err(&instance->pdev->dev, "[%d]: Dumping Done\n\n",instance->host->host_no); 1520 } 1521 1522 u32 1523 megasas_build_and_issue_cmd(struct megasas_instance *instance, 1524 struct scsi_cmnd *scmd) 1525 { 1526 struct megasas_cmd *cmd; 1527 u32 frame_count; 1528 1529 cmd = megasas_get_cmd(instance); 1530 if (!cmd) 1531 return SCSI_MLQUEUE_HOST_BUSY; 1532 1533 /* 1534 * Logical drive command 1535 */ 1536 if (megasas_cmd_type(scmd) == READ_WRITE_LDIO) 1537 frame_count = megasas_build_ldio(instance, scmd, cmd); 1538 else 1539 frame_count = megasas_build_dcdb(instance, scmd, cmd); 1540 1541 if (!frame_count) 1542 goto out_return_cmd; 1543 1544 cmd->scmd = scmd; 1545 scmd->SCp.ptr = (char *)cmd; 1546 1547 /* 1548 * Issue the command to the FW 1549 */ 1550 atomic_inc(&instance->fw_outstanding); 1551 1552 instance->instancet->fire_cmd(instance, cmd->frame_phys_addr, 1553 cmd->frame_count-1, instance->reg_set); 1554 1555 return 0; 1556 out_return_cmd: 1557 megasas_return_cmd(instance, cmd); 1558 return 1; 1559 } 1560 1561 1562 /** 1563 * megasas_queue_command - Queue entry point 1564 * @scmd: SCSI command to be queued 1565 * @done: Callback entry point 1566 */ 1567 static int 1568 megasas_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd) 1569 { 1570 struct megasas_instance *instance; 1571 unsigned long flags; 1572 1573 instance = (struct megasas_instance *) 1574 scmd->device->host->hostdata; 1575 1576 if (instance->unload == 1) { 1577 scmd->result = DID_NO_CONNECT << 16; 1578 scmd->scsi_done(scmd); 1579 return 0; 1580 } 1581 1582 if (instance->issuepend_done == 0) 1583 return SCSI_MLQUEUE_HOST_BUSY; 1584 1585 spin_lock_irqsave(&instance->hba_lock, flags); 1586 1587 /* Check for an mpio path and adjust behavior */ 1588 if (instance->adprecovery == MEGASAS_ADPRESET_SM_INFAULT) { 1589 if (megasas_check_mpio_paths(instance, scmd) == 1590 (DID_RESET << 16)) { 1591 spin_unlock_irqrestore(&instance->hba_lock, flags); 1592 return SCSI_MLQUEUE_HOST_BUSY; 1593 } else { 1594 spin_unlock_irqrestore(&instance->hba_lock, flags); 1595 scmd->result = DID_NO_CONNECT << 16; 1596 scmd->scsi_done(scmd); 1597 return 0; 1598 } 1599 } 1600 1601 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) { 1602 spin_unlock_irqrestore(&instance->hba_lock, flags); 1603 scmd->result = DID_NO_CONNECT << 16; 1604 scmd->scsi_done(scmd); 1605 return 0; 1606 } 1607 1608 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) { 1609 spin_unlock_irqrestore(&instance->hba_lock, flags); 1610 return SCSI_MLQUEUE_HOST_BUSY; 1611 } 1612 1613 spin_unlock_irqrestore(&instance->hba_lock, flags); 1614 1615 scmd->result = 0; 1616 1617 if (MEGASAS_IS_LOGICAL(scmd) && 1618 (scmd->device->id >= instance->fw_supported_vd_count || 1619 scmd->device->lun)) { 1620 scmd->result = DID_BAD_TARGET << 16; 1621 goto out_done; 1622 } 1623 1624 switch (scmd->cmnd[0]) { 1625 case SYNCHRONIZE_CACHE: 1626 /* 1627 * FW takes care of flush cache on its own 1628 * No need to send it down 1629 */ 1630 scmd->result = DID_OK << 16; 1631 goto out_done; 1632 default: 1633 break; 1634 } 1635 1636 if (instance->instancet->build_and_issue_cmd(instance, scmd)) { 1637 dev_err(&instance->pdev->dev, "Err returned from build_and_issue_cmd\n"); 1638 return SCSI_MLQUEUE_HOST_BUSY; 1639 } 1640 1641 return 0; 1642 1643 out_done: 1644 scmd->scsi_done(scmd); 1645 return 0; 1646 } 1647 1648 static struct megasas_instance *megasas_lookup_instance(u16 host_no) 1649 { 1650 int i; 1651 1652 for (i = 0; i < megasas_mgmt_info.max_index; i++) { 1653 1654 if ((megasas_mgmt_info.instance[i]) && 1655 (megasas_mgmt_info.instance[i]->host->host_no == host_no)) 1656 return megasas_mgmt_info.instance[i]; 1657 } 1658 1659 return NULL; 1660 } 1661 1662 static int megasas_slave_configure(struct scsi_device *sdev) 1663 { 1664 /* 1665 * The RAID firmware may require extended timeouts. 1666 */ 1667 blk_queue_rq_timeout(sdev->request_queue, 1668 MEGASAS_DEFAULT_CMD_TIMEOUT * HZ); 1669 1670 return 0; 1671 } 1672 1673 static int megasas_slave_alloc(struct scsi_device *sdev) 1674 { 1675 u16 pd_index = 0; 1676 struct megasas_instance *instance ; 1677 1678 instance = megasas_lookup_instance(sdev->host->host_no); 1679 if (sdev->channel < MEGASAS_MAX_PD_CHANNELS) { 1680 /* 1681 * Open the OS scan to the SYSTEM PD 1682 */ 1683 pd_index = 1684 (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) + 1685 sdev->id; 1686 if (instance->pd_list[pd_index].driveState == 1687 MR_PD_STATE_SYSTEM) { 1688 return 0; 1689 } 1690 return -ENXIO; 1691 } 1692 return 0; 1693 } 1694 1695 /* 1696 * megasas_complete_outstanding_ioctls - Complete outstanding ioctls after a 1697 * kill adapter 1698 * @instance: Adapter soft state 1699 * 1700 */ 1701 static void megasas_complete_outstanding_ioctls(struct megasas_instance *instance) 1702 { 1703 int i; 1704 struct megasas_cmd *cmd_mfi; 1705 struct megasas_cmd_fusion *cmd_fusion; 1706 struct fusion_context *fusion = instance->ctrl_context; 1707 1708 /* Find all outstanding ioctls */ 1709 if (fusion) { 1710 for (i = 0; i < instance->max_fw_cmds; i++) { 1711 cmd_fusion = fusion->cmd_list[i]; 1712 if (cmd_fusion->sync_cmd_idx != (u32)ULONG_MAX) { 1713 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx]; 1714 if (cmd_mfi->sync_cmd && 1715 cmd_mfi->frame->hdr.cmd != MFI_CMD_ABORT) 1716 megasas_complete_cmd(instance, 1717 cmd_mfi, DID_OK); 1718 } 1719 } 1720 } else { 1721 for (i = 0; i < instance->max_fw_cmds; i++) { 1722 cmd_mfi = instance->cmd_list[i]; 1723 if (cmd_mfi->sync_cmd && cmd_mfi->frame->hdr.cmd != 1724 MFI_CMD_ABORT) 1725 megasas_complete_cmd(instance, cmd_mfi, DID_OK); 1726 } 1727 } 1728 } 1729 1730 1731 void megaraid_sas_kill_hba(struct megasas_instance *instance) 1732 { 1733 /* Set critical error to block I/O & ioctls in case caller didn't */ 1734 instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR; 1735 /* Wait 1 second to ensure IO or ioctls in build have posted */ 1736 msleep(1000); 1737 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) || 1738 (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) || 1739 (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) || 1740 (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) || 1741 (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) || 1742 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) { 1743 writel(MFI_STOP_ADP, &instance->reg_set->doorbell); 1744 /* Flush */ 1745 readl(&instance->reg_set->doorbell); 1746 if (instance->mpio && instance->requestorId) 1747 memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS); 1748 } else { 1749 writel(MFI_STOP_ADP, 1750 &instance->reg_set->inbound_doorbell); 1751 } 1752 /* Complete outstanding ioctls when adapter is killed */ 1753 megasas_complete_outstanding_ioctls(instance); 1754 } 1755 1756 /** 1757 * megasas_check_and_restore_queue_depth - Check if queue depth needs to be 1758 * restored to max value 1759 * @instance: Adapter soft state 1760 * 1761 */ 1762 void 1763 megasas_check_and_restore_queue_depth(struct megasas_instance *instance) 1764 { 1765 unsigned long flags; 1766 1767 if (instance->flag & MEGASAS_FW_BUSY 1768 && time_after(jiffies, instance->last_time + 5 * HZ) 1769 && atomic_read(&instance->fw_outstanding) < 1770 instance->throttlequeuedepth + 1) { 1771 1772 spin_lock_irqsave(instance->host->host_lock, flags); 1773 instance->flag &= ~MEGASAS_FW_BUSY; 1774 1775 instance->host->can_queue = instance->max_scsi_cmds; 1776 spin_unlock_irqrestore(instance->host->host_lock, flags); 1777 } 1778 } 1779 1780 /** 1781 * megasas_complete_cmd_dpc - Returns FW's controller structure 1782 * @instance_addr: Address of adapter soft state 1783 * 1784 * Tasklet to complete cmds 1785 */ 1786 static void megasas_complete_cmd_dpc(unsigned long instance_addr) 1787 { 1788 u32 producer; 1789 u32 consumer; 1790 u32 context; 1791 struct megasas_cmd *cmd; 1792 struct megasas_instance *instance = 1793 (struct megasas_instance *)instance_addr; 1794 unsigned long flags; 1795 1796 /* If we have already declared adapter dead, donot complete cmds */ 1797 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) 1798 return; 1799 1800 spin_lock_irqsave(&instance->completion_lock, flags); 1801 1802 producer = le32_to_cpu(*instance->producer); 1803 consumer = le32_to_cpu(*instance->consumer); 1804 1805 while (consumer != producer) { 1806 context = le32_to_cpu(instance->reply_queue[consumer]); 1807 if (context >= instance->max_fw_cmds) { 1808 dev_err(&instance->pdev->dev, "Unexpected context value %x\n", 1809 context); 1810 BUG(); 1811 } 1812 1813 cmd = instance->cmd_list[context]; 1814 1815 megasas_complete_cmd(instance, cmd, DID_OK); 1816 1817 consumer++; 1818 if (consumer == (instance->max_fw_cmds + 1)) { 1819 consumer = 0; 1820 } 1821 } 1822 1823 *instance->consumer = cpu_to_le32(producer); 1824 1825 spin_unlock_irqrestore(&instance->completion_lock, flags); 1826 1827 /* 1828 * Check if we can restore can_queue 1829 */ 1830 megasas_check_and_restore_queue_depth(instance); 1831 } 1832 1833 /** 1834 * megasas_start_timer - Initializes a timer object 1835 * @instance: Adapter soft state 1836 * @timer: timer object to be initialized 1837 * @fn: timer function 1838 * @interval: time interval between timer function call 1839 * 1840 */ 1841 void megasas_start_timer(struct megasas_instance *instance, 1842 struct timer_list *timer, 1843 void *fn, unsigned long interval) 1844 { 1845 init_timer(timer); 1846 timer->expires = jiffies + interval; 1847 timer->data = (unsigned long)instance; 1848 timer->function = fn; 1849 add_timer(timer); 1850 } 1851 1852 static void 1853 megasas_internal_reset_defer_cmds(struct megasas_instance *instance); 1854 1855 static void 1856 process_fw_state_change_wq(struct work_struct *work); 1857 1858 void megasas_do_ocr(struct megasas_instance *instance) 1859 { 1860 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) || 1861 (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) || 1862 (instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)) { 1863 *instance->consumer = cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN); 1864 } 1865 instance->instancet->disable_intr(instance); 1866 instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT; 1867 instance->issuepend_done = 0; 1868 1869 atomic_set(&instance->fw_outstanding, 0); 1870 megasas_internal_reset_defer_cmds(instance); 1871 process_fw_state_change_wq(&instance->work_init); 1872 } 1873 1874 static int megasas_get_ld_vf_affiliation_111(struct megasas_instance *instance, 1875 int initial) 1876 { 1877 struct megasas_cmd *cmd; 1878 struct megasas_dcmd_frame *dcmd; 1879 struct MR_LD_VF_AFFILIATION_111 *new_affiliation_111 = NULL; 1880 dma_addr_t new_affiliation_111_h; 1881 int ld, retval = 0; 1882 u8 thisVf; 1883 1884 cmd = megasas_get_cmd(instance); 1885 1886 if (!cmd) { 1887 dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_vf_affiliation_111:" 1888 "Failed to get cmd for scsi%d\n", 1889 instance->host->host_no); 1890 return -ENOMEM; 1891 } 1892 1893 dcmd = &cmd->frame->dcmd; 1894 1895 if (!instance->vf_affiliation_111) { 1896 dev_warn(&instance->pdev->dev, "SR-IOV: Couldn't get LD/VF " 1897 "affiliation for scsi%d\n", instance->host->host_no); 1898 megasas_return_cmd(instance, cmd); 1899 return -ENOMEM; 1900 } 1901 1902 if (initial) 1903 memset(instance->vf_affiliation_111, 0, 1904 sizeof(struct MR_LD_VF_AFFILIATION_111)); 1905 else { 1906 new_affiliation_111 = 1907 pci_alloc_consistent(instance->pdev, 1908 sizeof(struct MR_LD_VF_AFFILIATION_111), 1909 &new_affiliation_111_h); 1910 if (!new_affiliation_111) { 1911 dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate " 1912 "memory for new affiliation for scsi%d\n", 1913 instance->host->host_no); 1914 megasas_return_cmd(instance, cmd); 1915 return -ENOMEM; 1916 } 1917 memset(new_affiliation_111, 0, 1918 sizeof(struct MR_LD_VF_AFFILIATION_111)); 1919 } 1920 1921 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 1922 1923 dcmd->cmd = MFI_CMD_DCMD; 1924 dcmd->cmd_status = MFI_STAT_INVALID_STATUS; 1925 dcmd->sge_count = 1; 1926 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_BOTH); 1927 dcmd->timeout = 0; 1928 dcmd->pad_0 = 0; 1929 dcmd->data_xfer_len = 1930 cpu_to_le32(sizeof(struct MR_LD_VF_AFFILIATION_111)); 1931 dcmd->opcode = cpu_to_le32(MR_DCMD_LD_VF_MAP_GET_ALL_LDS_111); 1932 1933 if (initial) 1934 dcmd->sgl.sge32[0].phys_addr = 1935 cpu_to_le32(instance->vf_affiliation_111_h); 1936 else 1937 dcmd->sgl.sge32[0].phys_addr = 1938 cpu_to_le32(new_affiliation_111_h); 1939 1940 dcmd->sgl.sge32[0].length = cpu_to_le32( 1941 sizeof(struct MR_LD_VF_AFFILIATION_111)); 1942 1943 dev_warn(&instance->pdev->dev, "SR-IOV: Getting LD/VF affiliation for " 1944 "scsi%d\n", instance->host->host_no); 1945 1946 megasas_issue_blocked_cmd(instance, cmd, 0); 1947 1948 if (dcmd->cmd_status) { 1949 dev_warn(&instance->pdev->dev, "SR-IOV: LD/VF affiliation DCMD" 1950 " failed with status 0x%x for scsi%d\n", 1951 dcmd->cmd_status, instance->host->host_no); 1952 retval = 1; /* Do a scan if we couldn't get affiliation */ 1953 goto out; 1954 } 1955 1956 if (!initial) { 1957 thisVf = new_affiliation_111->thisVf; 1958 for (ld = 0 ; ld < new_affiliation_111->vdCount; ld++) 1959 if (instance->vf_affiliation_111->map[ld].policy[thisVf] != 1960 new_affiliation_111->map[ld].policy[thisVf]) { 1961 dev_warn(&instance->pdev->dev, "SR-IOV: " 1962 "Got new LD/VF affiliation for scsi%d\n", 1963 instance->host->host_no); 1964 memcpy(instance->vf_affiliation_111, 1965 new_affiliation_111, 1966 sizeof(struct MR_LD_VF_AFFILIATION_111)); 1967 retval = 1; 1968 goto out; 1969 } 1970 } 1971 out: 1972 if (new_affiliation_111) { 1973 pci_free_consistent(instance->pdev, 1974 sizeof(struct MR_LD_VF_AFFILIATION_111), 1975 new_affiliation_111, 1976 new_affiliation_111_h); 1977 } 1978 1979 megasas_return_cmd(instance, cmd); 1980 1981 return retval; 1982 } 1983 1984 static int megasas_get_ld_vf_affiliation_12(struct megasas_instance *instance, 1985 int initial) 1986 { 1987 struct megasas_cmd *cmd; 1988 struct megasas_dcmd_frame *dcmd; 1989 struct MR_LD_VF_AFFILIATION *new_affiliation = NULL; 1990 struct MR_LD_VF_MAP *newmap = NULL, *savedmap = NULL; 1991 dma_addr_t new_affiliation_h; 1992 int i, j, retval = 0, found = 0, doscan = 0; 1993 u8 thisVf; 1994 1995 cmd = megasas_get_cmd(instance); 1996 1997 if (!cmd) { 1998 dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_vf_affiliation12: " 1999 "Failed to get cmd for scsi%d\n", 2000 instance->host->host_no); 2001 return -ENOMEM; 2002 } 2003 2004 dcmd = &cmd->frame->dcmd; 2005 2006 if (!instance->vf_affiliation) { 2007 dev_warn(&instance->pdev->dev, "SR-IOV: Couldn't get LD/VF " 2008 "affiliation for scsi%d\n", instance->host->host_no); 2009 megasas_return_cmd(instance, cmd); 2010 return -ENOMEM; 2011 } 2012 2013 if (initial) 2014 memset(instance->vf_affiliation, 0, (MAX_LOGICAL_DRIVES + 1) * 2015 sizeof(struct MR_LD_VF_AFFILIATION)); 2016 else { 2017 new_affiliation = 2018 pci_alloc_consistent(instance->pdev, 2019 (MAX_LOGICAL_DRIVES + 1) * 2020 sizeof(struct MR_LD_VF_AFFILIATION), 2021 &new_affiliation_h); 2022 if (!new_affiliation) { 2023 dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate " 2024 "memory for new affiliation for scsi%d\n", 2025 instance->host->host_no); 2026 megasas_return_cmd(instance, cmd); 2027 return -ENOMEM; 2028 } 2029 memset(new_affiliation, 0, (MAX_LOGICAL_DRIVES + 1) * 2030 sizeof(struct MR_LD_VF_AFFILIATION)); 2031 } 2032 2033 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 2034 2035 dcmd->cmd = MFI_CMD_DCMD; 2036 dcmd->cmd_status = MFI_STAT_INVALID_STATUS; 2037 dcmd->sge_count = 1; 2038 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_BOTH); 2039 dcmd->timeout = 0; 2040 dcmd->pad_0 = 0; 2041 dcmd->data_xfer_len = cpu_to_le32((MAX_LOGICAL_DRIVES + 1) * 2042 sizeof(struct MR_LD_VF_AFFILIATION)); 2043 dcmd->opcode = cpu_to_le32(MR_DCMD_LD_VF_MAP_GET_ALL_LDS); 2044 2045 if (initial) 2046 dcmd->sgl.sge32[0].phys_addr = 2047 cpu_to_le32(instance->vf_affiliation_h); 2048 else 2049 dcmd->sgl.sge32[0].phys_addr = 2050 cpu_to_le32(new_affiliation_h); 2051 2052 dcmd->sgl.sge32[0].length = cpu_to_le32((MAX_LOGICAL_DRIVES + 1) * 2053 sizeof(struct MR_LD_VF_AFFILIATION)); 2054 2055 dev_warn(&instance->pdev->dev, "SR-IOV: Getting LD/VF affiliation for " 2056 "scsi%d\n", instance->host->host_no); 2057 2058 megasas_issue_blocked_cmd(instance, cmd, 0); 2059 2060 if (dcmd->cmd_status) { 2061 dev_warn(&instance->pdev->dev, "SR-IOV: LD/VF affiliation DCMD" 2062 " failed with status 0x%x for scsi%d\n", 2063 dcmd->cmd_status, instance->host->host_no); 2064 retval = 1; /* Do a scan if we couldn't get affiliation */ 2065 goto out; 2066 } 2067 2068 if (!initial) { 2069 if (!new_affiliation->ldCount) { 2070 dev_warn(&instance->pdev->dev, "SR-IOV: Got new LD/VF " 2071 "affiliation for passive path for scsi%d\n", 2072 instance->host->host_no); 2073 retval = 1; 2074 goto out; 2075 } 2076 newmap = new_affiliation->map; 2077 savedmap = instance->vf_affiliation->map; 2078 thisVf = new_affiliation->thisVf; 2079 for (i = 0 ; i < new_affiliation->ldCount; i++) { 2080 found = 0; 2081 for (j = 0; j < instance->vf_affiliation->ldCount; 2082 j++) { 2083 if (newmap->ref.targetId == 2084 savedmap->ref.targetId) { 2085 found = 1; 2086 if (newmap->policy[thisVf] != 2087 savedmap->policy[thisVf]) { 2088 doscan = 1; 2089 goto out; 2090 } 2091 } 2092 savedmap = (struct MR_LD_VF_MAP *) 2093 ((unsigned char *)savedmap + 2094 savedmap->size); 2095 } 2096 if (!found && newmap->policy[thisVf] != 2097 MR_LD_ACCESS_HIDDEN) { 2098 doscan = 1; 2099 goto out; 2100 } 2101 newmap = (struct MR_LD_VF_MAP *) 2102 ((unsigned char *)newmap + newmap->size); 2103 } 2104 2105 newmap = new_affiliation->map; 2106 savedmap = instance->vf_affiliation->map; 2107 2108 for (i = 0 ; i < instance->vf_affiliation->ldCount; i++) { 2109 found = 0; 2110 for (j = 0 ; j < new_affiliation->ldCount; j++) { 2111 if (savedmap->ref.targetId == 2112 newmap->ref.targetId) { 2113 found = 1; 2114 if (savedmap->policy[thisVf] != 2115 newmap->policy[thisVf]) { 2116 doscan = 1; 2117 goto out; 2118 } 2119 } 2120 newmap = (struct MR_LD_VF_MAP *) 2121 ((unsigned char *)newmap + 2122 newmap->size); 2123 } 2124 if (!found && savedmap->policy[thisVf] != 2125 MR_LD_ACCESS_HIDDEN) { 2126 doscan = 1; 2127 goto out; 2128 } 2129 savedmap = (struct MR_LD_VF_MAP *) 2130 ((unsigned char *)savedmap + 2131 savedmap->size); 2132 } 2133 } 2134 out: 2135 if (doscan) { 2136 dev_warn(&instance->pdev->dev, "SR-IOV: Got new LD/VF " 2137 "affiliation for scsi%d\n", instance->host->host_no); 2138 memcpy(instance->vf_affiliation, new_affiliation, 2139 new_affiliation->size); 2140 retval = 1; 2141 } 2142 2143 if (new_affiliation) 2144 pci_free_consistent(instance->pdev, 2145 (MAX_LOGICAL_DRIVES + 1) * 2146 sizeof(struct MR_LD_VF_AFFILIATION), 2147 new_affiliation, new_affiliation_h); 2148 megasas_return_cmd(instance, cmd); 2149 2150 return retval; 2151 } 2152 2153 /* This function will get the current SR-IOV LD/VF affiliation */ 2154 static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance, 2155 int initial) 2156 { 2157 int retval; 2158 2159 if (instance->PlasmaFW111) 2160 retval = megasas_get_ld_vf_affiliation_111(instance, initial); 2161 else 2162 retval = megasas_get_ld_vf_affiliation_12(instance, initial); 2163 return retval; 2164 } 2165 2166 /* This function will tell FW to start the SR-IOV heartbeat */ 2167 int megasas_sriov_start_heartbeat(struct megasas_instance *instance, 2168 int initial) 2169 { 2170 struct megasas_cmd *cmd; 2171 struct megasas_dcmd_frame *dcmd; 2172 int retval = 0; 2173 2174 cmd = megasas_get_cmd(instance); 2175 2176 if (!cmd) { 2177 dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_sriov_start_heartbeat: " 2178 "Failed to get cmd for scsi%d\n", 2179 instance->host->host_no); 2180 return -ENOMEM; 2181 } 2182 2183 dcmd = &cmd->frame->dcmd; 2184 2185 if (initial) { 2186 instance->hb_host_mem = 2187 pci_zalloc_consistent(instance->pdev, 2188 sizeof(struct MR_CTRL_HB_HOST_MEM), 2189 &instance->hb_host_mem_h); 2190 if (!instance->hb_host_mem) { 2191 dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate" 2192 " memory for heartbeat host memory for scsi%d\n", 2193 instance->host->host_no); 2194 retval = -ENOMEM; 2195 goto out; 2196 } 2197 } 2198 2199 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 2200 2201 dcmd->mbox.s[0] = cpu_to_le16(sizeof(struct MR_CTRL_HB_HOST_MEM)); 2202 dcmd->cmd = MFI_CMD_DCMD; 2203 dcmd->cmd_status = MFI_STAT_INVALID_STATUS; 2204 dcmd->sge_count = 1; 2205 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_BOTH); 2206 dcmd->timeout = 0; 2207 dcmd->pad_0 = 0; 2208 dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_CTRL_HB_HOST_MEM)); 2209 dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_SHARED_HOST_MEM_ALLOC); 2210 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(instance->hb_host_mem_h); 2211 dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct MR_CTRL_HB_HOST_MEM)); 2212 2213 dev_warn(&instance->pdev->dev, "SR-IOV: Starting heartbeat for scsi%d\n", 2214 instance->host->host_no); 2215 2216 if (instance->ctrl_context && !instance->mask_interrupts) 2217 retval = megasas_issue_blocked_cmd(instance, cmd, 2218 MEGASAS_ROUTINE_WAIT_TIME_VF); 2219 else 2220 retval = megasas_issue_polled(instance, cmd); 2221 2222 if (retval) { 2223 dev_warn(&instance->pdev->dev, "SR-IOV: MR_DCMD_CTRL_SHARED_HOST" 2224 "_MEM_ALLOC DCMD %s for scsi%d\n", 2225 (dcmd->cmd_status == MFI_STAT_INVALID_STATUS) ? 2226 "timed out" : "failed", instance->host->host_no); 2227 retval = 1; 2228 } 2229 2230 out: 2231 megasas_return_cmd(instance, cmd); 2232 2233 return retval; 2234 } 2235 2236 /* Handler for SR-IOV heartbeat */ 2237 void megasas_sriov_heartbeat_handler(unsigned long instance_addr) 2238 { 2239 struct megasas_instance *instance = 2240 (struct megasas_instance *)instance_addr; 2241 2242 if (instance->hb_host_mem->HB.fwCounter != 2243 instance->hb_host_mem->HB.driverCounter) { 2244 instance->hb_host_mem->HB.driverCounter = 2245 instance->hb_host_mem->HB.fwCounter; 2246 mod_timer(&instance->sriov_heartbeat_timer, 2247 jiffies + MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF); 2248 } else { 2249 dev_warn(&instance->pdev->dev, "SR-IOV: Heartbeat never " 2250 "completed for scsi%d\n", instance->host->host_no); 2251 schedule_work(&instance->work_init); 2252 } 2253 } 2254 2255 /** 2256 * megasas_wait_for_outstanding - Wait for all outstanding cmds 2257 * @instance: Adapter soft state 2258 * 2259 * This function waits for up to MEGASAS_RESET_WAIT_TIME seconds for FW to 2260 * complete all its outstanding commands. Returns error if one or more IOs 2261 * are pending after this time period. It also marks the controller dead. 2262 */ 2263 static int megasas_wait_for_outstanding(struct megasas_instance *instance) 2264 { 2265 int i; 2266 u32 reset_index; 2267 u32 wait_time = MEGASAS_RESET_WAIT_TIME; 2268 u8 adprecovery; 2269 unsigned long flags; 2270 struct list_head clist_local; 2271 struct megasas_cmd *reset_cmd; 2272 u32 fw_state; 2273 u8 kill_adapter_flag; 2274 2275 spin_lock_irqsave(&instance->hba_lock, flags); 2276 adprecovery = instance->adprecovery; 2277 spin_unlock_irqrestore(&instance->hba_lock, flags); 2278 2279 if (adprecovery != MEGASAS_HBA_OPERATIONAL) { 2280 2281 INIT_LIST_HEAD(&clist_local); 2282 spin_lock_irqsave(&instance->hba_lock, flags); 2283 list_splice_init(&instance->internal_reset_pending_q, 2284 &clist_local); 2285 spin_unlock_irqrestore(&instance->hba_lock, flags); 2286 2287 dev_notice(&instance->pdev->dev, "HBA reset wait ...\n"); 2288 for (i = 0; i < wait_time; i++) { 2289 msleep(1000); 2290 spin_lock_irqsave(&instance->hba_lock, flags); 2291 adprecovery = instance->adprecovery; 2292 spin_unlock_irqrestore(&instance->hba_lock, flags); 2293 if (adprecovery == MEGASAS_HBA_OPERATIONAL) 2294 break; 2295 } 2296 2297 if (adprecovery != MEGASAS_HBA_OPERATIONAL) { 2298 dev_notice(&instance->pdev->dev, "reset: Stopping HBA.\n"); 2299 spin_lock_irqsave(&instance->hba_lock, flags); 2300 instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR; 2301 spin_unlock_irqrestore(&instance->hba_lock, flags); 2302 return FAILED; 2303 } 2304 2305 reset_index = 0; 2306 while (!list_empty(&clist_local)) { 2307 reset_cmd = list_entry((&clist_local)->next, 2308 struct megasas_cmd, list); 2309 list_del_init(&reset_cmd->list); 2310 if (reset_cmd->scmd) { 2311 reset_cmd->scmd->result = DID_RESET << 16; 2312 dev_notice(&instance->pdev->dev, "%d:%p reset [%02x]\n", 2313 reset_index, reset_cmd, 2314 reset_cmd->scmd->cmnd[0]); 2315 2316 reset_cmd->scmd->scsi_done(reset_cmd->scmd); 2317 megasas_return_cmd(instance, reset_cmd); 2318 } else if (reset_cmd->sync_cmd) { 2319 dev_notice(&instance->pdev->dev, "%p synch cmds" 2320 "reset queue\n", 2321 reset_cmd); 2322 2323 reset_cmd->cmd_status_drv = MFI_STAT_INVALID_STATUS; 2324 instance->instancet->fire_cmd(instance, 2325 reset_cmd->frame_phys_addr, 2326 0, instance->reg_set); 2327 } else { 2328 dev_notice(&instance->pdev->dev, "%p unexpected" 2329 "cmds lst\n", 2330 reset_cmd); 2331 } 2332 reset_index++; 2333 } 2334 2335 return SUCCESS; 2336 } 2337 2338 for (i = 0; i < resetwaittime; i++) { 2339 int outstanding = atomic_read(&instance->fw_outstanding); 2340 2341 if (!outstanding) 2342 break; 2343 2344 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) { 2345 dev_notice(&instance->pdev->dev, "[%2d]waiting for %d " 2346 "commands to complete\n",i,outstanding); 2347 /* 2348 * Call cmd completion routine. Cmd to be 2349 * be completed directly without depending on isr. 2350 */ 2351 megasas_complete_cmd_dpc((unsigned long)instance); 2352 } 2353 2354 msleep(1000); 2355 } 2356 2357 i = 0; 2358 kill_adapter_flag = 0; 2359 do { 2360 fw_state = instance->instancet->read_fw_status_reg( 2361 instance->reg_set) & MFI_STATE_MASK; 2362 if ((fw_state == MFI_STATE_FAULT) && 2363 (instance->disableOnlineCtrlReset == 0)) { 2364 if (i == 3) { 2365 kill_adapter_flag = 2; 2366 break; 2367 } 2368 megasas_do_ocr(instance); 2369 kill_adapter_flag = 1; 2370 2371 /* wait for 1 secs to let FW finish the pending cmds */ 2372 msleep(1000); 2373 } 2374 i++; 2375 } while (i <= 3); 2376 2377 if (atomic_read(&instance->fw_outstanding) && !kill_adapter_flag) { 2378 if (instance->disableOnlineCtrlReset == 0) { 2379 megasas_do_ocr(instance); 2380 2381 /* wait for 5 secs to let FW finish the pending cmds */ 2382 for (i = 0; i < wait_time; i++) { 2383 int outstanding = 2384 atomic_read(&instance->fw_outstanding); 2385 if (!outstanding) 2386 return SUCCESS; 2387 msleep(1000); 2388 } 2389 } 2390 } 2391 2392 if (atomic_read(&instance->fw_outstanding) || 2393 (kill_adapter_flag == 2)) { 2394 dev_notice(&instance->pdev->dev, "pending cmds after reset\n"); 2395 /* 2396 * Send signal to FW to stop processing any pending cmds. 2397 * The controller will be taken offline by the OS now. 2398 */ 2399 if ((instance->pdev->device == 2400 PCI_DEVICE_ID_LSI_SAS0073SKINNY) || 2401 (instance->pdev->device == 2402 PCI_DEVICE_ID_LSI_SAS0071SKINNY)) { 2403 writel(MFI_STOP_ADP, 2404 &instance->reg_set->doorbell); 2405 } else { 2406 writel(MFI_STOP_ADP, 2407 &instance->reg_set->inbound_doorbell); 2408 } 2409 megasas_dump_pending_frames(instance); 2410 spin_lock_irqsave(&instance->hba_lock, flags); 2411 instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR; 2412 spin_unlock_irqrestore(&instance->hba_lock, flags); 2413 return FAILED; 2414 } 2415 2416 dev_notice(&instance->pdev->dev, "no pending cmds after reset\n"); 2417 2418 return SUCCESS; 2419 } 2420 2421 /** 2422 * megasas_generic_reset - Generic reset routine 2423 * @scmd: Mid-layer SCSI command 2424 * 2425 * This routine implements a generic reset handler for device, bus and host 2426 * reset requests. Device, bus and host specific reset handlers can use this 2427 * function after they do their specific tasks. 2428 */ 2429 static int megasas_generic_reset(struct scsi_cmnd *scmd) 2430 { 2431 int ret_val; 2432 struct megasas_instance *instance; 2433 2434 instance = (struct megasas_instance *)scmd->device->host->hostdata; 2435 2436 scmd_printk(KERN_NOTICE, scmd, "megasas: RESET cmd=%x retries=%x\n", 2437 scmd->cmnd[0], scmd->retries); 2438 2439 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) { 2440 dev_err(&instance->pdev->dev, "cannot recover from previous reset failures\n"); 2441 return FAILED; 2442 } 2443 2444 ret_val = megasas_wait_for_outstanding(instance); 2445 if (ret_val == SUCCESS) 2446 dev_notice(&instance->pdev->dev, "reset successful\n"); 2447 else 2448 dev_err(&instance->pdev->dev, "failed to do reset\n"); 2449 2450 return ret_val; 2451 } 2452 2453 /** 2454 * megasas_reset_timer - quiesce the adapter if required 2455 * @scmd: scsi cmnd 2456 * 2457 * Sets the FW busy flag and reduces the host->can_queue if the 2458 * cmd has not been completed within the timeout period. 2459 */ 2460 static enum 2461 blk_eh_timer_return megasas_reset_timer(struct scsi_cmnd *scmd) 2462 { 2463 struct megasas_instance *instance; 2464 unsigned long flags; 2465 2466 if (time_after(jiffies, scmd->jiffies_at_alloc + 2467 (MEGASAS_DEFAULT_CMD_TIMEOUT * 2) * HZ)) { 2468 return BLK_EH_NOT_HANDLED; 2469 } 2470 2471 instance = (struct megasas_instance *)scmd->device->host->hostdata; 2472 if (!(instance->flag & MEGASAS_FW_BUSY)) { 2473 /* FW is busy, throttle IO */ 2474 spin_lock_irqsave(instance->host->host_lock, flags); 2475 2476 instance->host->can_queue = instance->throttlequeuedepth; 2477 instance->last_time = jiffies; 2478 instance->flag |= MEGASAS_FW_BUSY; 2479 2480 spin_unlock_irqrestore(instance->host->host_lock, flags); 2481 } 2482 return BLK_EH_RESET_TIMER; 2483 } 2484 2485 /** 2486 * megasas_reset_device - Device reset handler entry point 2487 */ 2488 static int megasas_reset_device(struct scsi_cmnd *scmd) 2489 { 2490 /* 2491 * First wait for all commands to complete 2492 */ 2493 return megasas_generic_reset(scmd); 2494 } 2495 2496 /** 2497 * megasas_reset_bus_host - Bus & host reset handler entry point 2498 */ 2499 static int megasas_reset_bus_host(struct scsi_cmnd *scmd) 2500 { 2501 int ret; 2502 struct megasas_instance *instance; 2503 2504 instance = (struct megasas_instance *)scmd->device->host->hostdata; 2505 2506 /* 2507 * First wait for all commands to complete 2508 */ 2509 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) || 2510 (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) || 2511 (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) || 2512 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) 2513 ret = megasas_reset_fusion(scmd->device->host, 1); 2514 else 2515 ret = megasas_generic_reset(scmd); 2516 2517 return ret; 2518 } 2519 2520 /** 2521 * megasas_bios_param - Returns disk geometry for a disk 2522 * @sdev: device handle 2523 * @bdev: block device 2524 * @capacity: drive capacity 2525 * @geom: geometry parameters 2526 */ 2527 static int 2528 megasas_bios_param(struct scsi_device *sdev, struct block_device *bdev, 2529 sector_t capacity, int geom[]) 2530 { 2531 int heads; 2532 int sectors; 2533 sector_t cylinders; 2534 unsigned long tmp; 2535 2536 /* Default heads (64) & sectors (32) */ 2537 heads = 64; 2538 sectors = 32; 2539 2540 tmp = heads * sectors; 2541 cylinders = capacity; 2542 2543 sector_div(cylinders, tmp); 2544 2545 /* 2546 * Handle extended translation size for logical drives > 1Gb 2547 */ 2548 2549 if (capacity >= 0x200000) { 2550 heads = 255; 2551 sectors = 63; 2552 tmp = heads*sectors; 2553 cylinders = capacity; 2554 sector_div(cylinders, tmp); 2555 } 2556 2557 geom[0] = heads; 2558 geom[1] = sectors; 2559 geom[2] = cylinders; 2560 2561 return 0; 2562 } 2563 2564 static void megasas_aen_polling(struct work_struct *work); 2565 2566 /** 2567 * megasas_service_aen - Processes an event notification 2568 * @instance: Adapter soft state 2569 * @cmd: AEN command completed by the ISR 2570 * 2571 * For AEN, driver sends a command down to FW that is held by the FW till an 2572 * event occurs. When an event of interest occurs, FW completes the command 2573 * that it was previously holding. 2574 * 2575 * This routines sends SIGIO signal to processes that have registered with the 2576 * driver for AEN. 2577 */ 2578 static void 2579 megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd) 2580 { 2581 unsigned long flags; 2582 2583 /* 2584 * Don't signal app if it is just an aborted previously registered aen 2585 */ 2586 if ((!cmd->abort_aen) && (instance->unload == 0)) { 2587 spin_lock_irqsave(&poll_aen_lock, flags); 2588 megasas_poll_wait_aen = 1; 2589 spin_unlock_irqrestore(&poll_aen_lock, flags); 2590 wake_up(&megasas_poll_wait); 2591 kill_fasync(&megasas_async_queue, SIGIO, POLL_IN); 2592 } 2593 else 2594 cmd->abort_aen = 0; 2595 2596 instance->aen_cmd = NULL; 2597 2598 megasas_return_cmd(instance, cmd); 2599 2600 if ((instance->unload == 0) && 2601 ((instance->issuepend_done == 1))) { 2602 struct megasas_aen_event *ev; 2603 2604 ev = kzalloc(sizeof(*ev), GFP_ATOMIC); 2605 if (!ev) { 2606 dev_err(&instance->pdev->dev, "megasas_service_aen: out of memory\n"); 2607 } else { 2608 ev->instance = instance; 2609 instance->ev = ev; 2610 INIT_DELAYED_WORK(&ev->hotplug_work, 2611 megasas_aen_polling); 2612 schedule_delayed_work(&ev->hotplug_work, 0); 2613 } 2614 } 2615 } 2616 2617 static ssize_t 2618 megasas_fw_crash_buffer_store(struct device *cdev, 2619 struct device_attribute *attr, const char *buf, size_t count) 2620 { 2621 struct Scsi_Host *shost = class_to_shost(cdev); 2622 struct megasas_instance *instance = 2623 (struct megasas_instance *) shost->hostdata; 2624 int val = 0; 2625 unsigned long flags; 2626 2627 if (kstrtoint(buf, 0, &val) != 0) 2628 return -EINVAL; 2629 2630 spin_lock_irqsave(&instance->crashdump_lock, flags); 2631 instance->fw_crash_buffer_offset = val; 2632 spin_unlock_irqrestore(&instance->crashdump_lock, flags); 2633 return strlen(buf); 2634 } 2635 2636 static ssize_t 2637 megasas_fw_crash_buffer_show(struct device *cdev, 2638 struct device_attribute *attr, char *buf) 2639 { 2640 struct Scsi_Host *shost = class_to_shost(cdev); 2641 struct megasas_instance *instance = 2642 (struct megasas_instance *) shost->hostdata; 2643 u32 size; 2644 unsigned long buff_addr; 2645 unsigned long dmachunk = CRASH_DMA_BUF_SIZE; 2646 unsigned long src_addr; 2647 unsigned long flags; 2648 u32 buff_offset; 2649 2650 spin_lock_irqsave(&instance->crashdump_lock, flags); 2651 buff_offset = instance->fw_crash_buffer_offset; 2652 if (!instance->crash_dump_buf && 2653 !((instance->fw_crash_state == AVAILABLE) || 2654 (instance->fw_crash_state == COPYING))) { 2655 dev_err(&instance->pdev->dev, 2656 "Firmware crash dump is not available\n"); 2657 spin_unlock_irqrestore(&instance->crashdump_lock, flags); 2658 return -EINVAL; 2659 } 2660 2661 buff_addr = (unsigned long) buf; 2662 2663 if (buff_offset > (instance->fw_crash_buffer_size * dmachunk)) { 2664 dev_err(&instance->pdev->dev, 2665 "Firmware crash dump offset is out of range\n"); 2666 spin_unlock_irqrestore(&instance->crashdump_lock, flags); 2667 return 0; 2668 } 2669 2670 size = (instance->fw_crash_buffer_size * dmachunk) - buff_offset; 2671 size = (size >= PAGE_SIZE) ? (PAGE_SIZE - 1) : size; 2672 2673 src_addr = (unsigned long)instance->crash_buf[buff_offset / dmachunk] + 2674 (buff_offset % dmachunk); 2675 memcpy(buf, (void *)src_addr, size); 2676 spin_unlock_irqrestore(&instance->crashdump_lock, flags); 2677 2678 return size; 2679 } 2680 2681 static ssize_t 2682 megasas_fw_crash_buffer_size_show(struct device *cdev, 2683 struct device_attribute *attr, char *buf) 2684 { 2685 struct Scsi_Host *shost = class_to_shost(cdev); 2686 struct megasas_instance *instance = 2687 (struct megasas_instance *) shost->hostdata; 2688 2689 return snprintf(buf, PAGE_SIZE, "%ld\n", (unsigned long) 2690 ((instance->fw_crash_buffer_size) * 1024 * 1024)/PAGE_SIZE); 2691 } 2692 2693 static ssize_t 2694 megasas_fw_crash_state_store(struct device *cdev, 2695 struct device_attribute *attr, const char *buf, size_t count) 2696 { 2697 struct Scsi_Host *shost = class_to_shost(cdev); 2698 struct megasas_instance *instance = 2699 (struct megasas_instance *) shost->hostdata; 2700 int val = 0; 2701 unsigned long flags; 2702 2703 if (kstrtoint(buf, 0, &val) != 0) 2704 return -EINVAL; 2705 2706 if ((val <= AVAILABLE || val > COPY_ERROR)) { 2707 dev_err(&instance->pdev->dev, "application updates invalid " 2708 "firmware crash state\n"); 2709 return -EINVAL; 2710 } 2711 2712 instance->fw_crash_state = val; 2713 2714 if ((val == COPIED) || (val == COPY_ERROR)) { 2715 spin_lock_irqsave(&instance->crashdump_lock, flags); 2716 megasas_free_host_crash_buffer(instance); 2717 spin_unlock_irqrestore(&instance->crashdump_lock, flags); 2718 if (val == COPY_ERROR) 2719 dev_info(&instance->pdev->dev, "application failed to " 2720 "copy Firmware crash dump\n"); 2721 else 2722 dev_info(&instance->pdev->dev, "Firmware crash dump " 2723 "copied successfully\n"); 2724 } 2725 return strlen(buf); 2726 } 2727 2728 static ssize_t 2729 megasas_fw_crash_state_show(struct device *cdev, 2730 struct device_attribute *attr, char *buf) 2731 { 2732 struct Scsi_Host *shost = class_to_shost(cdev); 2733 struct megasas_instance *instance = 2734 (struct megasas_instance *) shost->hostdata; 2735 2736 return snprintf(buf, PAGE_SIZE, "%d\n", instance->fw_crash_state); 2737 } 2738 2739 static ssize_t 2740 megasas_page_size_show(struct device *cdev, 2741 struct device_attribute *attr, char *buf) 2742 { 2743 return snprintf(buf, PAGE_SIZE, "%ld\n", (unsigned long)PAGE_SIZE - 1); 2744 } 2745 2746 static DEVICE_ATTR(fw_crash_buffer, S_IRUGO | S_IWUSR, 2747 megasas_fw_crash_buffer_show, megasas_fw_crash_buffer_store); 2748 static DEVICE_ATTR(fw_crash_buffer_size, S_IRUGO, 2749 megasas_fw_crash_buffer_size_show, NULL); 2750 static DEVICE_ATTR(fw_crash_state, S_IRUGO | S_IWUSR, 2751 megasas_fw_crash_state_show, megasas_fw_crash_state_store); 2752 static DEVICE_ATTR(page_size, S_IRUGO, 2753 megasas_page_size_show, NULL); 2754 2755 struct device_attribute *megaraid_host_attrs[] = { 2756 &dev_attr_fw_crash_buffer_size, 2757 &dev_attr_fw_crash_buffer, 2758 &dev_attr_fw_crash_state, 2759 &dev_attr_page_size, 2760 NULL, 2761 }; 2762 2763 /* 2764 * Scsi host template for megaraid_sas driver 2765 */ 2766 static struct scsi_host_template megasas_template = { 2767 2768 .module = THIS_MODULE, 2769 .name = "Avago SAS based MegaRAID driver", 2770 .proc_name = "megaraid_sas", 2771 .slave_configure = megasas_slave_configure, 2772 .slave_alloc = megasas_slave_alloc, 2773 .queuecommand = megasas_queue_command, 2774 .eh_device_reset_handler = megasas_reset_device, 2775 .eh_bus_reset_handler = megasas_reset_bus_host, 2776 .eh_host_reset_handler = megasas_reset_bus_host, 2777 .eh_timed_out = megasas_reset_timer, 2778 .shost_attrs = megaraid_host_attrs, 2779 .bios_param = megasas_bios_param, 2780 .use_clustering = ENABLE_CLUSTERING, 2781 .change_queue_depth = scsi_change_queue_depth, 2782 .no_write_same = 1, 2783 }; 2784 2785 /** 2786 * megasas_complete_int_cmd - Completes an internal command 2787 * @instance: Adapter soft state 2788 * @cmd: Command to be completed 2789 * 2790 * The megasas_issue_blocked_cmd() function waits for a command to complete 2791 * after it issues a command. This function wakes up that waiting routine by 2792 * calling wake_up() on the wait queue. 2793 */ 2794 static void 2795 megasas_complete_int_cmd(struct megasas_instance *instance, 2796 struct megasas_cmd *cmd) 2797 { 2798 cmd->cmd_status_drv = cmd->frame->io.cmd_status; 2799 wake_up(&instance->int_cmd_wait_q); 2800 } 2801 2802 /** 2803 * megasas_complete_abort - Completes aborting a command 2804 * @instance: Adapter soft state 2805 * @cmd: Cmd that was issued to abort another cmd 2806 * 2807 * The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q 2808 * after it issues an abort on a previously issued command. This function 2809 * wakes up all functions waiting on the same wait queue. 2810 */ 2811 static void 2812 megasas_complete_abort(struct megasas_instance *instance, 2813 struct megasas_cmd *cmd) 2814 { 2815 if (cmd->sync_cmd) { 2816 cmd->sync_cmd = 0; 2817 cmd->cmd_status_drv = 0; 2818 wake_up(&instance->abort_cmd_wait_q); 2819 } 2820 } 2821 2822 /** 2823 * megasas_complete_cmd - Completes a command 2824 * @instance: Adapter soft state 2825 * @cmd: Command to be completed 2826 * @alt_status: If non-zero, use this value as status to 2827 * SCSI mid-layer instead of the value returned 2828 * by the FW. This should be used if caller wants 2829 * an alternate status (as in the case of aborted 2830 * commands) 2831 */ 2832 void 2833 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd, 2834 u8 alt_status) 2835 { 2836 int exception = 0; 2837 struct megasas_header *hdr = &cmd->frame->hdr; 2838 unsigned long flags; 2839 struct fusion_context *fusion = instance->ctrl_context; 2840 u32 opcode; 2841 2842 /* flag for the retry reset */ 2843 cmd->retry_for_fw_reset = 0; 2844 2845 if (cmd->scmd) 2846 cmd->scmd->SCp.ptr = NULL; 2847 2848 switch (hdr->cmd) { 2849 case MFI_CMD_INVALID: 2850 /* Some older 1068 controller FW may keep a pended 2851 MR_DCMD_CTRL_EVENT_GET_INFO left over from the main kernel 2852 when booting the kdump kernel. Ignore this command to 2853 prevent a kernel panic on shutdown of the kdump kernel. */ 2854 dev_warn(&instance->pdev->dev, "MFI_CMD_INVALID command " 2855 "completed\n"); 2856 dev_warn(&instance->pdev->dev, "If you have a controller " 2857 "other than PERC5, please upgrade your firmware\n"); 2858 break; 2859 case MFI_CMD_PD_SCSI_IO: 2860 case MFI_CMD_LD_SCSI_IO: 2861 2862 /* 2863 * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been 2864 * issued either through an IO path or an IOCTL path. If it 2865 * was via IOCTL, we will send it to internal completion. 2866 */ 2867 if (cmd->sync_cmd) { 2868 cmd->sync_cmd = 0; 2869 megasas_complete_int_cmd(instance, cmd); 2870 break; 2871 } 2872 2873 case MFI_CMD_LD_READ: 2874 case MFI_CMD_LD_WRITE: 2875 2876 if (alt_status) { 2877 cmd->scmd->result = alt_status << 16; 2878 exception = 1; 2879 } 2880 2881 if (exception) { 2882 2883 atomic_dec(&instance->fw_outstanding); 2884 2885 scsi_dma_unmap(cmd->scmd); 2886 cmd->scmd->scsi_done(cmd->scmd); 2887 megasas_return_cmd(instance, cmd); 2888 2889 break; 2890 } 2891 2892 switch (hdr->cmd_status) { 2893 2894 case MFI_STAT_OK: 2895 cmd->scmd->result = DID_OK << 16; 2896 break; 2897 2898 case MFI_STAT_SCSI_IO_FAILED: 2899 case MFI_STAT_LD_INIT_IN_PROGRESS: 2900 cmd->scmd->result = 2901 (DID_ERROR << 16) | hdr->scsi_status; 2902 break; 2903 2904 case MFI_STAT_SCSI_DONE_WITH_ERROR: 2905 2906 cmd->scmd->result = (DID_OK << 16) | hdr->scsi_status; 2907 2908 if (hdr->scsi_status == SAM_STAT_CHECK_CONDITION) { 2909 memset(cmd->scmd->sense_buffer, 0, 2910 SCSI_SENSE_BUFFERSIZE); 2911 memcpy(cmd->scmd->sense_buffer, cmd->sense, 2912 hdr->sense_len); 2913 2914 cmd->scmd->result |= DRIVER_SENSE << 24; 2915 } 2916 2917 break; 2918 2919 case MFI_STAT_LD_OFFLINE: 2920 case MFI_STAT_DEVICE_NOT_FOUND: 2921 cmd->scmd->result = DID_BAD_TARGET << 16; 2922 break; 2923 2924 default: 2925 dev_printk(KERN_DEBUG, &instance->pdev->dev, "MFI FW status %#x\n", 2926 hdr->cmd_status); 2927 cmd->scmd->result = DID_ERROR << 16; 2928 break; 2929 } 2930 2931 atomic_dec(&instance->fw_outstanding); 2932 2933 scsi_dma_unmap(cmd->scmd); 2934 cmd->scmd->scsi_done(cmd->scmd); 2935 megasas_return_cmd(instance, cmd); 2936 2937 break; 2938 2939 case MFI_CMD_SMP: 2940 case MFI_CMD_STP: 2941 case MFI_CMD_DCMD: 2942 opcode = le32_to_cpu(cmd->frame->dcmd.opcode); 2943 /* Check for LD map update */ 2944 if ((opcode == MR_DCMD_LD_MAP_GET_INFO) 2945 && (cmd->frame->dcmd.mbox.b[1] == 1)) { 2946 fusion->fast_path_io = 0; 2947 spin_lock_irqsave(instance->host->host_lock, flags); 2948 if (cmd->frame->hdr.cmd_status != 0) { 2949 if (cmd->frame->hdr.cmd_status != 2950 MFI_STAT_NOT_FOUND) 2951 dev_warn(&instance->pdev->dev, "map syncfailed, status = 0x%x\n", 2952 cmd->frame->hdr.cmd_status); 2953 else { 2954 megasas_return_cmd(instance, cmd); 2955 spin_unlock_irqrestore( 2956 instance->host->host_lock, 2957 flags); 2958 break; 2959 } 2960 } else 2961 instance->map_id++; 2962 megasas_return_cmd(instance, cmd); 2963 2964 /* 2965 * Set fast path IO to ZERO. 2966 * Validate Map will set proper value. 2967 * Meanwhile all IOs will go as LD IO. 2968 */ 2969 if (MR_ValidateMapInfo(instance)) 2970 fusion->fast_path_io = 1; 2971 else 2972 fusion->fast_path_io = 0; 2973 megasas_sync_map_info(instance); 2974 spin_unlock_irqrestore(instance->host->host_lock, 2975 flags); 2976 break; 2977 } 2978 if (opcode == MR_DCMD_CTRL_EVENT_GET_INFO || 2979 opcode == MR_DCMD_CTRL_EVENT_GET) { 2980 spin_lock_irqsave(&poll_aen_lock, flags); 2981 megasas_poll_wait_aen = 0; 2982 spin_unlock_irqrestore(&poll_aen_lock, flags); 2983 } 2984 2985 /* 2986 * See if got an event notification 2987 */ 2988 if (opcode == MR_DCMD_CTRL_EVENT_WAIT) 2989 megasas_service_aen(instance, cmd); 2990 else 2991 megasas_complete_int_cmd(instance, cmd); 2992 2993 break; 2994 2995 case MFI_CMD_ABORT: 2996 /* 2997 * Cmd issued to abort another cmd returned 2998 */ 2999 megasas_complete_abort(instance, cmd); 3000 break; 3001 3002 default: 3003 dev_info(&instance->pdev->dev, "Unknown command completed! [0x%X]\n", 3004 hdr->cmd); 3005 break; 3006 } 3007 } 3008 3009 /** 3010 * megasas_issue_pending_cmds_again - issue all pending cmds 3011 * in FW again because of the fw reset 3012 * @instance: Adapter soft state 3013 */ 3014 static inline void 3015 megasas_issue_pending_cmds_again(struct megasas_instance *instance) 3016 { 3017 struct megasas_cmd *cmd; 3018 struct list_head clist_local; 3019 union megasas_evt_class_locale class_locale; 3020 unsigned long flags; 3021 u32 seq_num; 3022 3023 INIT_LIST_HEAD(&clist_local); 3024 spin_lock_irqsave(&instance->hba_lock, flags); 3025 list_splice_init(&instance->internal_reset_pending_q, &clist_local); 3026 spin_unlock_irqrestore(&instance->hba_lock, flags); 3027 3028 while (!list_empty(&clist_local)) { 3029 cmd = list_entry((&clist_local)->next, 3030 struct megasas_cmd, list); 3031 list_del_init(&cmd->list); 3032 3033 if (cmd->sync_cmd || cmd->scmd) { 3034 dev_notice(&instance->pdev->dev, "command %p, %p:%d" 3035 "detected to be pending while HBA reset\n", 3036 cmd, cmd->scmd, cmd->sync_cmd); 3037 3038 cmd->retry_for_fw_reset++; 3039 3040 if (cmd->retry_for_fw_reset == 3) { 3041 dev_notice(&instance->pdev->dev, "cmd %p, %p:%d" 3042 "was tried multiple times during reset." 3043 "Shutting down the HBA\n", 3044 cmd, cmd->scmd, cmd->sync_cmd); 3045 instance->instancet->disable_intr(instance); 3046 atomic_set(&instance->fw_reset_no_pci_access, 1); 3047 megaraid_sas_kill_hba(instance); 3048 return; 3049 } 3050 } 3051 3052 if (cmd->sync_cmd == 1) { 3053 if (cmd->scmd) { 3054 dev_notice(&instance->pdev->dev, "unexpected" 3055 "cmd attached to internal command!\n"); 3056 } 3057 dev_notice(&instance->pdev->dev, "%p synchronous cmd" 3058 "on the internal reset queue," 3059 "issue it again.\n", cmd); 3060 cmd->cmd_status_drv = MFI_STAT_INVALID_STATUS; 3061 instance->instancet->fire_cmd(instance, 3062 cmd->frame_phys_addr, 3063 0, instance->reg_set); 3064 } else if (cmd->scmd) { 3065 dev_notice(&instance->pdev->dev, "%p scsi cmd [%02x]" 3066 "detected on the internal queue, issue again.\n", 3067 cmd, cmd->scmd->cmnd[0]); 3068 3069 atomic_inc(&instance->fw_outstanding); 3070 instance->instancet->fire_cmd(instance, 3071 cmd->frame_phys_addr, 3072 cmd->frame_count-1, instance->reg_set); 3073 } else { 3074 dev_notice(&instance->pdev->dev, "%p unexpected cmd on the" 3075 "internal reset defer list while re-issue!!\n", 3076 cmd); 3077 } 3078 } 3079 3080 if (instance->aen_cmd) { 3081 dev_notice(&instance->pdev->dev, "aen_cmd in def process\n"); 3082 megasas_return_cmd(instance, instance->aen_cmd); 3083 3084 instance->aen_cmd = NULL; 3085 } 3086 3087 /* 3088 * Initiate AEN (Asynchronous Event Notification) 3089 */ 3090 seq_num = instance->last_seq_num; 3091 class_locale.members.reserved = 0; 3092 class_locale.members.locale = MR_EVT_LOCALE_ALL; 3093 class_locale.members.class = MR_EVT_CLASS_DEBUG; 3094 3095 megasas_register_aen(instance, seq_num, class_locale.word); 3096 } 3097 3098 /** 3099 * Move the internal reset pending commands to a deferred queue. 3100 * 3101 * We move the commands pending at internal reset time to a 3102 * pending queue. This queue would be flushed after successful 3103 * completion of the internal reset sequence. if the internal reset 3104 * did not complete in time, the kernel reset handler would flush 3105 * these commands. 3106 **/ 3107 static void 3108 megasas_internal_reset_defer_cmds(struct megasas_instance *instance) 3109 { 3110 struct megasas_cmd *cmd; 3111 int i; 3112 u32 max_cmd = instance->max_fw_cmds; 3113 u32 defer_index; 3114 unsigned long flags; 3115 3116 defer_index = 0; 3117 spin_lock_irqsave(&instance->mfi_pool_lock, flags); 3118 for (i = 0; i < max_cmd; i++) { 3119 cmd = instance->cmd_list[i]; 3120 if (cmd->sync_cmd == 1 || cmd->scmd) { 3121 dev_notice(&instance->pdev->dev, "moving cmd[%d]:%p:%d:%p" 3122 "on the defer queue as internal\n", 3123 defer_index, cmd, cmd->sync_cmd, cmd->scmd); 3124 3125 if (!list_empty(&cmd->list)) { 3126 dev_notice(&instance->pdev->dev, "ERROR while" 3127 " moving this cmd:%p, %d %p, it was" 3128 "discovered on some list?\n", 3129 cmd, cmd->sync_cmd, cmd->scmd); 3130 3131 list_del_init(&cmd->list); 3132 } 3133 defer_index++; 3134 list_add_tail(&cmd->list, 3135 &instance->internal_reset_pending_q); 3136 } 3137 } 3138 spin_unlock_irqrestore(&instance->mfi_pool_lock, flags); 3139 } 3140 3141 3142 static void 3143 process_fw_state_change_wq(struct work_struct *work) 3144 { 3145 struct megasas_instance *instance = 3146 container_of(work, struct megasas_instance, work_init); 3147 u32 wait; 3148 unsigned long flags; 3149 3150 if (instance->adprecovery != MEGASAS_ADPRESET_SM_INFAULT) { 3151 dev_notice(&instance->pdev->dev, "error, recovery st %x\n", 3152 instance->adprecovery); 3153 return ; 3154 } 3155 3156 if (instance->adprecovery == MEGASAS_ADPRESET_SM_INFAULT) { 3157 dev_notice(&instance->pdev->dev, "FW detected to be in fault" 3158 "state, restarting it...\n"); 3159 3160 instance->instancet->disable_intr(instance); 3161 atomic_set(&instance->fw_outstanding, 0); 3162 3163 atomic_set(&instance->fw_reset_no_pci_access, 1); 3164 instance->instancet->adp_reset(instance, instance->reg_set); 3165 atomic_set(&instance->fw_reset_no_pci_access, 0); 3166 3167 dev_notice(&instance->pdev->dev, "FW restarted successfully," 3168 "initiating next stage...\n"); 3169 3170 dev_notice(&instance->pdev->dev, "HBA recovery state machine," 3171 "state 2 starting...\n"); 3172 3173 /* waiting for about 20 second before start the second init */ 3174 for (wait = 0; wait < 30; wait++) { 3175 msleep(1000); 3176 } 3177 3178 if (megasas_transition_to_ready(instance, 1)) { 3179 dev_notice(&instance->pdev->dev, "adapter not ready\n"); 3180 3181 atomic_set(&instance->fw_reset_no_pci_access, 1); 3182 megaraid_sas_kill_hba(instance); 3183 return ; 3184 } 3185 3186 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) || 3187 (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) || 3188 (instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR) 3189 ) { 3190 *instance->consumer = *instance->producer; 3191 } else { 3192 *instance->consumer = 0; 3193 *instance->producer = 0; 3194 } 3195 3196 megasas_issue_init_mfi(instance); 3197 3198 spin_lock_irqsave(&instance->hba_lock, flags); 3199 instance->adprecovery = MEGASAS_HBA_OPERATIONAL; 3200 spin_unlock_irqrestore(&instance->hba_lock, flags); 3201 instance->instancet->enable_intr(instance); 3202 3203 megasas_issue_pending_cmds_again(instance); 3204 instance->issuepend_done = 1; 3205 } 3206 } 3207 3208 /** 3209 * megasas_deplete_reply_queue - Processes all completed commands 3210 * @instance: Adapter soft state 3211 * @alt_status: Alternate status to be returned to 3212 * SCSI mid-layer instead of the status 3213 * returned by the FW 3214 * Note: this must be called with hba lock held 3215 */ 3216 static int 3217 megasas_deplete_reply_queue(struct megasas_instance *instance, 3218 u8 alt_status) 3219 { 3220 u32 mfiStatus; 3221 u32 fw_state; 3222 3223 if ((mfiStatus = instance->instancet->check_reset(instance, 3224 instance->reg_set)) == 1) { 3225 return IRQ_HANDLED; 3226 } 3227 3228 if ((mfiStatus = instance->instancet->clear_intr( 3229 instance->reg_set) 3230 ) == 0) { 3231 /* Hardware may not set outbound_intr_status in MSI-X mode */ 3232 if (!instance->msix_vectors) 3233 return IRQ_NONE; 3234 } 3235 3236 instance->mfiStatus = mfiStatus; 3237 3238 if ((mfiStatus & MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE)) { 3239 fw_state = instance->instancet->read_fw_status_reg( 3240 instance->reg_set) & MFI_STATE_MASK; 3241 3242 if (fw_state != MFI_STATE_FAULT) { 3243 dev_notice(&instance->pdev->dev, "fw state:%x\n", 3244 fw_state); 3245 } 3246 3247 if ((fw_state == MFI_STATE_FAULT) && 3248 (instance->disableOnlineCtrlReset == 0)) { 3249 dev_notice(&instance->pdev->dev, "wait adp restart\n"); 3250 3251 if ((instance->pdev->device == 3252 PCI_DEVICE_ID_LSI_SAS1064R) || 3253 (instance->pdev->device == 3254 PCI_DEVICE_ID_DELL_PERC5) || 3255 (instance->pdev->device == 3256 PCI_DEVICE_ID_LSI_VERDE_ZCR)) { 3257 3258 *instance->consumer = 3259 cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN); 3260 } 3261 3262 3263 instance->instancet->disable_intr(instance); 3264 instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT; 3265 instance->issuepend_done = 0; 3266 3267 atomic_set(&instance->fw_outstanding, 0); 3268 megasas_internal_reset_defer_cmds(instance); 3269 3270 dev_notice(&instance->pdev->dev, "fwState=%x, stage:%d\n", 3271 fw_state, instance->adprecovery); 3272 3273 schedule_work(&instance->work_init); 3274 return IRQ_HANDLED; 3275 3276 } else { 3277 dev_notice(&instance->pdev->dev, "fwstate:%x, dis_OCR=%x\n", 3278 fw_state, instance->disableOnlineCtrlReset); 3279 } 3280 } 3281 3282 tasklet_schedule(&instance->isr_tasklet); 3283 return IRQ_HANDLED; 3284 } 3285 /** 3286 * megasas_isr - isr entry point 3287 */ 3288 static irqreturn_t megasas_isr(int irq, void *devp) 3289 { 3290 struct megasas_irq_context *irq_context = devp; 3291 struct megasas_instance *instance = irq_context->instance; 3292 unsigned long flags; 3293 irqreturn_t rc; 3294 3295 if (atomic_read(&instance->fw_reset_no_pci_access)) 3296 return IRQ_HANDLED; 3297 3298 spin_lock_irqsave(&instance->hba_lock, flags); 3299 rc = megasas_deplete_reply_queue(instance, DID_OK); 3300 spin_unlock_irqrestore(&instance->hba_lock, flags); 3301 3302 return rc; 3303 } 3304 3305 /** 3306 * megasas_transition_to_ready - Move the FW to READY state 3307 * @instance: Adapter soft state 3308 * 3309 * During the initialization, FW passes can potentially be in any one of 3310 * several possible states. If the FW in operational, waiting-for-handshake 3311 * states, driver must take steps to bring it to ready state. Otherwise, it 3312 * has to wait for the ready state. 3313 */ 3314 int 3315 megasas_transition_to_ready(struct megasas_instance *instance, int ocr) 3316 { 3317 int i; 3318 u8 max_wait; 3319 u32 fw_state; 3320 u32 cur_state; 3321 u32 abs_state, curr_abs_state; 3322 3323 abs_state = instance->instancet->read_fw_status_reg(instance->reg_set); 3324 fw_state = abs_state & MFI_STATE_MASK; 3325 3326 if (fw_state != MFI_STATE_READY) 3327 dev_info(&instance->pdev->dev, "Waiting for FW to come to ready" 3328 " state\n"); 3329 3330 while (fw_state != MFI_STATE_READY) { 3331 3332 switch (fw_state) { 3333 3334 case MFI_STATE_FAULT: 3335 dev_printk(KERN_DEBUG, &instance->pdev->dev, "FW in FAULT state!!\n"); 3336 if (ocr) { 3337 max_wait = MEGASAS_RESET_WAIT_TIME; 3338 cur_state = MFI_STATE_FAULT; 3339 break; 3340 } else 3341 return -ENODEV; 3342 3343 case MFI_STATE_WAIT_HANDSHAKE: 3344 /* 3345 * Set the CLR bit in inbound doorbell 3346 */ 3347 if ((instance->pdev->device == 3348 PCI_DEVICE_ID_LSI_SAS0073SKINNY) || 3349 (instance->pdev->device == 3350 PCI_DEVICE_ID_LSI_SAS0071SKINNY) || 3351 (instance->pdev->device == 3352 PCI_DEVICE_ID_LSI_FUSION) || 3353 (instance->pdev->device == 3354 PCI_DEVICE_ID_LSI_PLASMA) || 3355 (instance->pdev->device == 3356 PCI_DEVICE_ID_LSI_INVADER) || 3357 (instance->pdev->device == 3358 PCI_DEVICE_ID_LSI_FURY)) { 3359 writel( 3360 MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG, 3361 &instance->reg_set->doorbell); 3362 } else { 3363 writel( 3364 MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG, 3365 &instance->reg_set->inbound_doorbell); 3366 } 3367 3368 max_wait = MEGASAS_RESET_WAIT_TIME; 3369 cur_state = MFI_STATE_WAIT_HANDSHAKE; 3370 break; 3371 3372 case MFI_STATE_BOOT_MESSAGE_PENDING: 3373 if ((instance->pdev->device == 3374 PCI_DEVICE_ID_LSI_SAS0073SKINNY) || 3375 (instance->pdev->device == 3376 PCI_DEVICE_ID_LSI_SAS0071SKINNY) || 3377 (instance->pdev->device == 3378 PCI_DEVICE_ID_LSI_FUSION) || 3379 (instance->pdev->device == 3380 PCI_DEVICE_ID_LSI_PLASMA) || 3381 (instance->pdev->device == 3382 PCI_DEVICE_ID_LSI_INVADER) || 3383 (instance->pdev->device == 3384 PCI_DEVICE_ID_LSI_FURY)) { 3385 writel(MFI_INIT_HOTPLUG, 3386 &instance->reg_set->doorbell); 3387 } else 3388 writel(MFI_INIT_HOTPLUG, 3389 &instance->reg_set->inbound_doorbell); 3390 3391 max_wait = MEGASAS_RESET_WAIT_TIME; 3392 cur_state = MFI_STATE_BOOT_MESSAGE_PENDING; 3393 break; 3394 3395 case MFI_STATE_OPERATIONAL: 3396 /* 3397 * Bring it to READY state; assuming max wait 10 secs 3398 */ 3399 instance->instancet->disable_intr(instance); 3400 if ((instance->pdev->device == 3401 PCI_DEVICE_ID_LSI_SAS0073SKINNY) || 3402 (instance->pdev->device == 3403 PCI_DEVICE_ID_LSI_SAS0071SKINNY) || 3404 (instance->pdev->device 3405 == PCI_DEVICE_ID_LSI_FUSION) || 3406 (instance->pdev->device 3407 == PCI_DEVICE_ID_LSI_PLASMA) || 3408 (instance->pdev->device 3409 == PCI_DEVICE_ID_LSI_INVADER) || 3410 (instance->pdev->device 3411 == PCI_DEVICE_ID_LSI_FURY)) { 3412 writel(MFI_RESET_FLAGS, 3413 &instance->reg_set->doorbell); 3414 if ((instance->pdev->device == 3415 PCI_DEVICE_ID_LSI_FUSION) || 3416 (instance->pdev->device == 3417 PCI_DEVICE_ID_LSI_PLASMA) || 3418 (instance->pdev->device == 3419 PCI_DEVICE_ID_LSI_INVADER) || 3420 (instance->pdev->device == 3421 PCI_DEVICE_ID_LSI_FURY)) { 3422 for (i = 0; i < (10 * 1000); i += 20) { 3423 if (readl( 3424 &instance-> 3425 reg_set-> 3426 doorbell) & 1) 3427 msleep(20); 3428 else 3429 break; 3430 } 3431 } 3432 } else 3433 writel(MFI_RESET_FLAGS, 3434 &instance->reg_set->inbound_doorbell); 3435 3436 max_wait = MEGASAS_RESET_WAIT_TIME; 3437 cur_state = MFI_STATE_OPERATIONAL; 3438 break; 3439 3440 case MFI_STATE_UNDEFINED: 3441 /* 3442 * This state should not last for more than 2 seconds 3443 */ 3444 max_wait = MEGASAS_RESET_WAIT_TIME; 3445 cur_state = MFI_STATE_UNDEFINED; 3446 break; 3447 3448 case MFI_STATE_BB_INIT: 3449 max_wait = MEGASAS_RESET_WAIT_TIME; 3450 cur_state = MFI_STATE_BB_INIT; 3451 break; 3452 3453 case MFI_STATE_FW_INIT: 3454 max_wait = MEGASAS_RESET_WAIT_TIME; 3455 cur_state = MFI_STATE_FW_INIT; 3456 break; 3457 3458 case MFI_STATE_FW_INIT_2: 3459 max_wait = MEGASAS_RESET_WAIT_TIME; 3460 cur_state = MFI_STATE_FW_INIT_2; 3461 break; 3462 3463 case MFI_STATE_DEVICE_SCAN: 3464 max_wait = MEGASAS_RESET_WAIT_TIME; 3465 cur_state = MFI_STATE_DEVICE_SCAN; 3466 break; 3467 3468 case MFI_STATE_FLUSH_CACHE: 3469 max_wait = MEGASAS_RESET_WAIT_TIME; 3470 cur_state = MFI_STATE_FLUSH_CACHE; 3471 break; 3472 3473 default: 3474 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Unknown state 0x%x\n", 3475 fw_state); 3476 return -ENODEV; 3477 } 3478 3479 /* 3480 * The cur_state should not last for more than max_wait secs 3481 */ 3482 for (i = 0; i < (max_wait * 1000); i++) { 3483 curr_abs_state = instance->instancet-> 3484 read_fw_status_reg(instance->reg_set); 3485 3486 if (abs_state == curr_abs_state) { 3487 msleep(1); 3488 } else 3489 break; 3490 } 3491 3492 /* 3493 * Return error if fw_state hasn't changed after max_wait 3494 */ 3495 if (curr_abs_state == abs_state) { 3496 dev_printk(KERN_DEBUG, &instance->pdev->dev, "FW state [%d] hasn't changed " 3497 "in %d secs\n", fw_state, max_wait); 3498 return -ENODEV; 3499 } 3500 3501 abs_state = curr_abs_state; 3502 fw_state = curr_abs_state & MFI_STATE_MASK; 3503 } 3504 dev_info(&instance->pdev->dev, "FW now in Ready state\n"); 3505 3506 return 0; 3507 } 3508 3509 /** 3510 * megasas_teardown_frame_pool - Destroy the cmd frame DMA pool 3511 * @instance: Adapter soft state 3512 */ 3513 static void megasas_teardown_frame_pool(struct megasas_instance *instance) 3514 { 3515 int i; 3516 u32 max_cmd = instance->max_mfi_cmds; 3517 struct megasas_cmd *cmd; 3518 3519 if (!instance->frame_dma_pool) 3520 return; 3521 3522 /* 3523 * Return all frames to pool 3524 */ 3525 for (i = 0; i < max_cmd; i++) { 3526 3527 cmd = instance->cmd_list[i]; 3528 3529 if (cmd->frame) 3530 pci_pool_free(instance->frame_dma_pool, cmd->frame, 3531 cmd->frame_phys_addr); 3532 3533 if (cmd->sense) 3534 pci_pool_free(instance->sense_dma_pool, cmd->sense, 3535 cmd->sense_phys_addr); 3536 } 3537 3538 /* 3539 * Now destroy the pool itself 3540 */ 3541 pci_pool_destroy(instance->frame_dma_pool); 3542 pci_pool_destroy(instance->sense_dma_pool); 3543 3544 instance->frame_dma_pool = NULL; 3545 instance->sense_dma_pool = NULL; 3546 } 3547 3548 /** 3549 * megasas_create_frame_pool - Creates DMA pool for cmd frames 3550 * @instance: Adapter soft state 3551 * 3552 * Each command packet has an embedded DMA memory buffer that is used for 3553 * filling MFI frame and the SG list that immediately follows the frame. This 3554 * function creates those DMA memory buffers for each command packet by using 3555 * PCI pool facility. 3556 */ 3557 static int megasas_create_frame_pool(struct megasas_instance *instance) 3558 { 3559 int i; 3560 u32 max_cmd; 3561 u32 sge_sz; 3562 u32 total_sz; 3563 u32 frame_count; 3564 struct megasas_cmd *cmd; 3565 3566 max_cmd = instance->max_mfi_cmds; 3567 3568 /* 3569 * Size of our frame is 64 bytes for MFI frame, followed by max SG 3570 * elements and finally SCSI_SENSE_BUFFERSIZE bytes for sense buffer 3571 */ 3572 sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) : 3573 sizeof(struct megasas_sge32); 3574 3575 if (instance->flag_ieee) 3576 sge_sz = sizeof(struct megasas_sge_skinny); 3577 3578 /* 3579 * For MFI controllers. 3580 * max_num_sge = 60 3581 * max_sge_sz = 16 byte (sizeof megasas_sge_skinny) 3582 * Total 960 byte (15 MFI frame of 64 byte) 3583 * 3584 * Fusion adapter require only 3 extra frame. 3585 * max_num_sge = 16 (defined as MAX_IOCTL_SGE) 3586 * max_sge_sz = 12 byte (sizeof megasas_sge64) 3587 * Total 192 byte (3 MFI frame of 64 byte) 3588 */ 3589 frame_count = instance->ctrl_context ? (3 + 1) : (15 + 1); 3590 total_sz = MEGAMFI_FRAME_SIZE * frame_count; 3591 /* 3592 * Use DMA pool facility provided by PCI layer 3593 */ 3594 instance->frame_dma_pool = pci_pool_create("megasas frame pool", 3595 instance->pdev, total_sz, 256, 0); 3596 3597 if (!instance->frame_dma_pool) { 3598 dev_printk(KERN_DEBUG, &instance->pdev->dev, "failed to setup frame pool\n"); 3599 return -ENOMEM; 3600 } 3601 3602 instance->sense_dma_pool = pci_pool_create("megasas sense pool", 3603 instance->pdev, 128, 4, 0); 3604 3605 if (!instance->sense_dma_pool) { 3606 dev_printk(KERN_DEBUG, &instance->pdev->dev, "failed to setup sense pool\n"); 3607 3608 pci_pool_destroy(instance->frame_dma_pool); 3609 instance->frame_dma_pool = NULL; 3610 3611 return -ENOMEM; 3612 } 3613 3614 /* 3615 * Allocate and attach a frame to each of the commands in cmd_list. 3616 * By making cmd->index as the context instead of the &cmd, we can 3617 * always use 32bit context regardless of the architecture 3618 */ 3619 for (i = 0; i < max_cmd; i++) { 3620 3621 cmd = instance->cmd_list[i]; 3622 3623 cmd->frame = pci_pool_alloc(instance->frame_dma_pool, 3624 GFP_KERNEL, &cmd->frame_phys_addr); 3625 3626 cmd->sense = pci_pool_alloc(instance->sense_dma_pool, 3627 GFP_KERNEL, &cmd->sense_phys_addr); 3628 3629 /* 3630 * megasas_teardown_frame_pool() takes care of freeing 3631 * whatever has been allocated 3632 */ 3633 if (!cmd->frame || !cmd->sense) { 3634 dev_printk(KERN_DEBUG, &instance->pdev->dev, "pci_pool_alloc failed\n"); 3635 megasas_teardown_frame_pool(instance); 3636 return -ENOMEM; 3637 } 3638 3639 memset(cmd->frame, 0, total_sz); 3640 cmd->frame->io.context = cpu_to_le32(cmd->index); 3641 cmd->frame->io.pad_0 = 0; 3642 if ((instance->pdev->device != PCI_DEVICE_ID_LSI_FUSION) && 3643 (instance->pdev->device != PCI_DEVICE_ID_LSI_PLASMA) && 3644 (instance->pdev->device != PCI_DEVICE_ID_LSI_INVADER) && 3645 (instance->pdev->device != PCI_DEVICE_ID_LSI_FURY) && 3646 (reset_devices)) 3647 cmd->frame->hdr.cmd = MFI_CMD_INVALID; 3648 } 3649 3650 return 0; 3651 } 3652 3653 /** 3654 * megasas_free_cmds - Free all the cmds in the free cmd pool 3655 * @instance: Adapter soft state 3656 */ 3657 void megasas_free_cmds(struct megasas_instance *instance) 3658 { 3659 int i; 3660 3661 /* First free the MFI frame pool */ 3662 megasas_teardown_frame_pool(instance); 3663 3664 /* Free all the commands in the cmd_list */ 3665 for (i = 0; i < instance->max_mfi_cmds; i++) 3666 3667 kfree(instance->cmd_list[i]); 3668 3669 /* Free the cmd_list buffer itself */ 3670 kfree(instance->cmd_list); 3671 instance->cmd_list = NULL; 3672 3673 INIT_LIST_HEAD(&instance->cmd_pool); 3674 } 3675 3676 /** 3677 * megasas_alloc_cmds - Allocates the command packets 3678 * @instance: Adapter soft state 3679 * 3680 * Each command that is issued to the FW, whether IO commands from the OS or 3681 * internal commands like IOCTLs, are wrapped in local data structure called 3682 * megasas_cmd. The frame embedded in this megasas_cmd is actually issued to 3683 * the FW. 3684 * 3685 * Each frame has a 32-bit field called context (tag). This context is used 3686 * to get back the megasas_cmd from the frame when a frame gets completed in 3687 * the ISR. Typically the address of the megasas_cmd itself would be used as 3688 * the context. But we wanted to keep the differences between 32 and 64 bit 3689 * systems to the mininum. We always use 32 bit integers for the context. In 3690 * this driver, the 32 bit values are the indices into an array cmd_list. 3691 * This array is used only to look up the megasas_cmd given the context. The 3692 * free commands themselves are maintained in a linked list called cmd_pool. 3693 */ 3694 int megasas_alloc_cmds(struct megasas_instance *instance) 3695 { 3696 int i; 3697 int j; 3698 u32 max_cmd; 3699 struct megasas_cmd *cmd; 3700 struct fusion_context *fusion; 3701 3702 fusion = instance->ctrl_context; 3703 max_cmd = instance->max_mfi_cmds; 3704 3705 /* 3706 * instance->cmd_list is an array of struct megasas_cmd pointers. 3707 * Allocate the dynamic array first and then allocate individual 3708 * commands. 3709 */ 3710 instance->cmd_list = kcalloc(max_cmd, sizeof(struct megasas_cmd*), GFP_KERNEL); 3711 3712 if (!instance->cmd_list) { 3713 dev_printk(KERN_DEBUG, &instance->pdev->dev, "out of memory\n"); 3714 return -ENOMEM; 3715 } 3716 3717 memset(instance->cmd_list, 0, sizeof(struct megasas_cmd *) *max_cmd); 3718 3719 for (i = 0; i < max_cmd; i++) { 3720 instance->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd), 3721 GFP_KERNEL); 3722 3723 if (!instance->cmd_list[i]) { 3724 3725 for (j = 0; j < i; j++) 3726 kfree(instance->cmd_list[j]); 3727 3728 kfree(instance->cmd_list); 3729 instance->cmd_list = NULL; 3730 3731 return -ENOMEM; 3732 } 3733 } 3734 3735 for (i = 0; i < max_cmd; i++) { 3736 cmd = instance->cmd_list[i]; 3737 memset(cmd, 0, sizeof(struct megasas_cmd)); 3738 cmd->index = i; 3739 cmd->scmd = NULL; 3740 cmd->instance = instance; 3741 3742 list_add_tail(&cmd->list, &instance->cmd_pool); 3743 } 3744 3745 /* 3746 * Create a frame pool and assign one frame to each cmd 3747 */ 3748 if (megasas_create_frame_pool(instance)) { 3749 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Error creating frame DMA pool\n"); 3750 megasas_free_cmds(instance); 3751 } 3752 3753 return 0; 3754 } 3755 3756 /* 3757 * megasas_get_pd_list_info - Returns FW's pd_list structure 3758 * @instance: Adapter soft state 3759 * @pd_list: pd_list structure 3760 * 3761 * Issues an internal command (DCMD) to get the FW's controller PD 3762 * list structure. This information is mainly used to find out SYSTEM 3763 * supported by the FW. 3764 */ 3765 static int 3766 megasas_get_pd_list(struct megasas_instance *instance) 3767 { 3768 int ret = 0, pd_index = 0; 3769 struct megasas_cmd *cmd; 3770 struct megasas_dcmd_frame *dcmd; 3771 struct MR_PD_LIST *ci; 3772 struct MR_PD_ADDRESS *pd_addr; 3773 dma_addr_t ci_h = 0; 3774 3775 cmd = megasas_get_cmd(instance); 3776 3777 if (!cmd) { 3778 dev_printk(KERN_DEBUG, &instance->pdev->dev, "(get_pd_list): Failed to get cmd\n"); 3779 return -ENOMEM; 3780 } 3781 3782 dcmd = &cmd->frame->dcmd; 3783 3784 ci = pci_alloc_consistent(instance->pdev, 3785 MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST), &ci_h); 3786 3787 if (!ci) { 3788 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc mem for pd_list\n"); 3789 megasas_return_cmd(instance, cmd); 3790 return -ENOMEM; 3791 } 3792 3793 memset(ci, 0, sizeof(*ci)); 3794 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 3795 3796 dcmd->mbox.b[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST; 3797 dcmd->mbox.b[1] = 0; 3798 dcmd->cmd = MFI_CMD_DCMD; 3799 dcmd->cmd_status = MFI_STAT_INVALID_STATUS; 3800 dcmd->sge_count = 1; 3801 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ); 3802 dcmd->timeout = 0; 3803 dcmd->pad_0 = 0; 3804 dcmd->data_xfer_len = cpu_to_le32(MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST)); 3805 dcmd->opcode = cpu_to_le32(MR_DCMD_PD_LIST_QUERY); 3806 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h); 3807 dcmd->sgl.sge32[0].length = cpu_to_le32(MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST)); 3808 3809 if (instance->ctrl_context && !instance->mask_interrupts) 3810 ret = megasas_issue_blocked_cmd(instance, cmd, 3811 MEGASAS_BLOCKED_CMD_TIMEOUT); 3812 else 3813 ret = megasas_issue_polled(instance, cmd); 3814 3815 /* 3816 * the following function will get the instance PD LIST. 3817 */ 3818 3819 pd_addr = ci->addr; 3820 3821 if (ret == 0 && 3822 (le32_to_cpu(ci->count) < 3823 (MEGASAS_MAX_PD_CHANNELS * MEGASAS_MAX_DEV_PER_CHANNEL))) { 3824 3825 memset(instance->local_pd_list, 0, 3826 MEGASAS_MAX_PD * sizeof(struct megasas_pd_list)); 3827 3828 for (pd_index = 0; pd_index < le32_to_cpu(ci->count); pd_index++) { 3829 3830 instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].tid = 3831 le16_to_cpu(pd_addr->deviceId); 3832 instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveType = 3833 pd_addr->scsiDevType; 3834 instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveState = 3835 MR_PD_STATE_SYSTEM; 3836 pd_addr++; 3837 } 3838 memcpy(instance->pd_list, instance->local_pd_list, 3839 sizeof(instance->pd_list)); 3840 } 3841 3842 pci_free_consistent(instance->pdev, 3843 MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST), 3844 ci, ci_h); 3845 3846 megasas_return_cmd(instance, cmd); 3847 3848 return ret; 3849 } 3850 3851 /* 3852 * megasas_get_ld_list_info - Returns FW's ld_list structure 3853 * @instance: Adapter soft state 3854 * @ld_list: ld_list structure 3855 * 3856 * Issues an internal command (DCMD) to get the FW's controller PD 3857 * list structure. This information is mainly used to find out SYSTEM 3858 * supported by the FW. 3859 */ 3860 static int 3861 megasas_get_ld_list(struct megasas_instance *instance) 3862 { 3863 int ret = 0, ld_index = 0, ids = 0; 3864 struct megasas_cmd *cmd; 3865 struct megasas_dcmd_frame *dcmd; 3866 struct MR_LD_LIST *ci; 3867 dma_addr_t ci_h = 0; 3868 u32 ld_count; 3869 3870 cmd = megasas_get_cmd(instance); 3871 3872 if (!cmd) { 3873 dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_list: Failed to get cmd\n"); 3874 return -ENOMEM; 3875 } 3876 3877 dcmd = &cmd->frame->dcmd; 3878 3879 ci = pci_alloc_consistent(instance->pdev, 3880 sizeof(struct MR_LD_LIST), 3881 &ci_h); 3882 3883 if (!ci) { 3884 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc mem in get_ld_list\n"); 3885 megasas_return_cmd(instance, cmd); 3886 return -ENOMEM; 3887 } 3888 3889 memset(ci, 0, sizeof(*ci)); 3890 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 3891 3892 if (instance->supportmax256vd) 3893 dcmd->mbox.b[0] = 1; 3894 dcmd->cmd = MFI_CMD_DCMD; 3895 dcmd->cmd_status = MFI_STAT_INVALID_STATUS; 3896 dcmd->sge_count = 1; 3897 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ); 3898 dcmd->timeout = 0; 3899 dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_LD_LIST)); 3900 dcmd->opcode = cpu_to_le32(MR_DCMD_LD_GET_LIST); 3901 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h); 3902 dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct MR_LD_LIST)); 3903 dcmd->pad_0 = 0; 3904 3905 if (instance->ctrl_context && !instance->mask_interrupts) 3906 ret = megasas_issue_blocked_cmd(instance, cmd, 3907 MEGASAS_BLOCKED_CMD_TIMEOUT); 3908 else 3909 ret = megasas_issue_polled(instance, cmd); 3910 3911 3912 ld_count = le32_to_cpu(ci->ldCount); 3913 3914 /* the following function will get the instance PD LIST */ 3915 3916 if ((ret == 0) && (ld_count <= instance->fw_supported_vd_count)) { 3917 memset(instance->ld_ids, 0xff, MAX_LOGICAL_DRIVES_EXT); 3918 3919 for (ld_index = 0; ld_index < ld_count; ld_index++) { 3920 if (ci->ldList[ld_index].state != 0) { 3921 ids = ci->ldList[ld_index].ref.targetId; 3922 instance->ld_ids[ids] = 3923 ci->ldList[ld_index].ref.targetId; 3924 } 3925 } 3926 } 3927 3928 pci_free_consistent(instance->pdev, 3929 sizeof(struct MR_LD_LIST), 3930 ci, 3931 ci_h); 3932 3933 megasas_return_cmd(instance, cmd); 3934 return ret; 3935 } 3936 3937 /** 3938 * megasas_ld_list_query - Returns FW's ld_list structure 3939 * @instance: Adapter soft state 3940 * @ld_list: ld_list structure 3941 * 3942 * Issues an internal command (DCMD) to get the FW's controller PD 3943 * list structure. This information is mainly used to find out SYSTEM 3944 * supported by the FW. 3945 */ 3946 static int 3947 megasas_ld_list_query(struct megasas_instance *instance, u8 query_type) 3948 { 3949 int ret = 0, ld_index = 0, ids = 0; 3950 struct megasas_cmd *cmd; 3951 struct megasas_dcmd_frame *dcmd; 3952 struct MR_LD_TARGETID_LIST *ci; 3953 dma_addr_t ci_h = 0; 3954 u32 tgtid_count; 3955 3956 cmd = megasas_get_cmd(instance); 3957 3958 if (!cmd) { 3959 dev_warn(&instance->pdev->dev, 3960 "megasas_ld_list_query: Failed to get cmd\n"); 3961 return -ENOMEM; 3962 } 3963 3964 dcmd = &cmd->frame->dcmd; 3965 3966 ci = pci_alloc_consistent(instance->pdev, 3967 sizeof(struct MR_LD_TARGETID_LIST), &ci_h); 3968 3969 if (!ci) { 3970 dev_warn(&instance->pdev->dev, 3971 "Failed to alloc mem for ld_list_query\n"); 3972 megasas_return_cmd(instance, cmd); 3973 return -ENOMEM; 3974 } 3975 3976 memset(ci, 0, sizeof(*ci)); 3977 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 3978 3979 dcmd->mbox.b[0] = query_type; 3980 if (instance->supportmax256vd) 3981 dcmd->mbox.b[2] = 1; 3982 3983 dcmd->cmd = MFI_CMD_DCMD; 3984 dcmd->cmd_status = MFI_STAT_INVALID_STATUS; 3985 dcmd->sge_count = 1; 3986 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ); 3987 dcmd->timeout = 0; 3988 dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_LD_TARGETID_LIST)); 3989 dcmd->opcode = cpu_to_le32(MR_DCMD_LD_LIST_QUERY); 3990 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h); 3991 dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct MR_LD_TARGETID_LIST)); 3992 dcmd->pad_0 = 0; 3993 3994 if (instance->ctrl_context && !instance->mask_interrupts) 3995 ret = megasas_issue_blocked_cmd(instance, cmd, 3996 MEGASAS_BLOCKED_CMD_TIMEOUT); 3997 else 3998 ret = megasas_issue_polled(instance, cmd); 3999 4000 tgtid_count = le32_to_cpu(ci->count); 4001 4002 if ((ret == 0) && (tgtid_count <= (instance->fw_supported_vd_count))) { 4003 memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS); 4004 for (ld_index = 0; ld_index < tgtid_count; ld_index++) { 4005 ids = ci->targetId[ld_index]; 4006 instance->ld_ids[ids] = ci->targetId[ld_index]; 4007 } 4008 4009 } 4010 4011 pci_free_consistent(instance->pdev, sizeof(struct MR_LD_TARGETID_LIST), 4012 ci, ci_h); 4013 4014 megasas_return_cmd(instance, cmd); 4015 4016 return ret; 4017 } 4018 4019 /* 4020 * megasas_update_ext_vd_details : Update details w.r.t Extended VD 4021 * instance : Controller's instance 4022 */ 4023 static void megasas_update_ext_vd_details(struct megasas_instance *instance) 4024 { 4025 struct fusion_context *fusion; 4026 u32 old_map_sz; 4027 u32 new_map_sz; 4028 4029 fusion = instance->ctrl_context; 4030 /* For MFI based controllers return dummy success */ 4031 if (!fusion) 4032 return; 4033 4034 instance->supportmax256vd = 4035 instance->ctrl_info->adapterOperations3.supportMaxExtLDs; 4036 /* Below is additional check to address future FW enhancement */ 4037 if (instance->ctrl_info->max_lds > 64) 4038 instance->supportmax256vd = 1; 4039 4040 instance->drv_supported_vd_count = MEGASAS_MAX_LD_CHANNELS 4041 * MEGASAS_MAX_DEV_PER_CHANNEL; 4042 instance->drv_supported_pd_count = MEGASAS_MAX_PD_CHANNELS 4043 * MEGASAS_MAX_DEV_PER_CHANNEL; 4044 if (instance->supportmax256vd) { 4045 instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES_EXT; 4046 instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES; 4047 } else { 4048 instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES; 4049 instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES; 4050 } 4051 4052 dev_info(&instance->pdev->dev, 4053 "firmware type\t: %s\n", 4054 instance->supportmax256vd ? "Extended VD(240 VD)firmware" : 4055 "Legacy(64 VD) firmware"); 4056 4057 old_map_sz = sizeof(struct MR_FW_RAID_MAP) + 4058 (sizeof(struct MR_LD_SPAN_MAP) * 4059 (instance->fw_supported_vd_count - 1)); 4060 new_map_sz = sizeof(struct MR_FW_RAID_MAP_EXT); 4061 fusion->drv_map_sz = sizeof(struct MR_DRV_RAID_MAP) + 4062 (sizeof(struct MR_LD_SPAN_MAP) * 4063 (instance->drv_supported_vd_count - 1)); 4064 4065 fusion->max_map_sz = max(old_map_sz, new_map_sz); 4066 4067 4068 if (instance->supportmax256vd) 4069 fusion->current_map_sz = new_map_sz; 4070 else 4071 fusion->current_map_sz = old_map_sz; 4072 } 4073 4074 /** 4075 * megasas_get_controller_info - Returns FW's controller structure 4076 * @instance: Adapter soft state 4077 * 4078 * Issues an internal command (DCMD) to get the FW's controller structure. 4079 * This information is mainly used to find out the maximum IO transfer per 4080 * command supported by the FW. 4081 */ 4082 int 4083 megasas_get_ctrl_info(struct megasas_instance *instance) 4084 { 4085 int ret = 0; 4086 struct megasas_cmd *cmd; 4087 struct megasas_dcmd_frame *dcmd; 4088 struct megasas_ctrl_info *ci; 4089 struct megasas_ctrl_info *ctrl_info; 4090 dma_addr_t ci_h = 0; 4091 4092 ctrl_info = instance->ctrl_info; 4093 4094 cmd = megasas_get_cmd(instance); 4095 4096 if (!cmd) { 4097 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get a free cmd\n"); 4098 return -ENOMEM; 4099 } 4100 4101 dcmd = &cmd->frame->dcmd; 4102 4103 ci = pci_alloc_consistent(instance->pdev, 4104 sizeof(struct megasas_ctrl_info), &ci_h); 4105 4106 if (!ci) { 4107 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc mem for ctrl info\n"); 4108 megasas_return_cmd(instance, cmd); 4109 return -ENOMEM; 4110 } 4111 4112 memset(ci, 0, sizeof(*ci)); 4113 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 4114 4115 dcmd->cmd = MFI_CMD_DCMD; 4116 dcmd->cmd_status = MFI_STAT_INVALID_STATUS; 4117 dcmd->sge_count = 1; 4118 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ); 4119 dcmd->timeout = 0; 4120 dcmd->pad_0 = 0; 4121 dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_ctrl_info)); 4122 dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_GET_INFO); 4123 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h); 4124 dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct megasas_ctrl_info)); 4125 dcmd->mbox.b[0] = 1; 4126 4127 if (instance->ctrl_context && !instance->mask_interrupts) 4128 ret = megasas_issue_blocked_cmd(instance, cmd, 4129 MEGASAS_BLOCKED_CMD_TIMEOUT); 4130 else 4131 ret = megasas_issue_polled(instance, cmd); 4132 4133 if (!ret) { 4134 memcpy(ctrl_info, ci, sizeof(struct megasas_ctrl_info)); 4135 le32_to_cpus((u32 *)&ctrl_info->properties.OnOffProperties); 4136 le32_to_cpus((u32 *)&ctrl_info->adapterOperations2); 4137 le32_to_cpus((u32 *)&ctrl_info->adapterOperations3); 4138 megasas_update_ext_vd_details(instance); 4139 instance->is_imr = (ctrl_info->memory_size ? 0 : 1); 4140 dev_info(&instance->pdev->dev, 4141 "controller type\t: %s(%dMB)\n", 4142 instance->is_imr ? "iMR" : "MR", 4143 le16_to_cpu(ctrl_info->memory_size)); 4144 } 4145 4146 pci_free_consistent(instance->pdev, sizeof(struct megasas_ctrl_info), 4147 ci, ci_h); 4148 4149 megasas_return_cmd(instance, cmd); 4150 return ret; 4151 } 4152 4153 /* 4154 * megasas_set_crash_dump_params - Sends address of crash dump DMA buffer 4155 * to firmware 4156 * 4157 * @instance: Adapter soft state 4158 * @crash_buf_state - tell FW to turn ON/OFF crash dump feature 4159 MR_CRASH_BUF_TURN_OFF = 0 4160 MR_CRASH_BUF_TURN_ON = 1 4161 * @return 0 on success non-zero on failure. 4162 * Issues an internal command (DCMD) to set parameters for crash dump feature. 4163 * Driver will send address of crash dump DMA buffer and set mbox to tell FW 4164 * that driver supports crash dump feature. This DCMD will be sent only if 4165 * crash dump feature is supported by the FW. 4166 * 4167 */ 4168 int megasas_set_crash_dump_params(struct megasas_instance *instance, 4169 u8 crash_buf_state) 4170 { 4171 int ret = 0; 4172 struct megasas_cmd *cmd; 4173 struct megasas_dcmd_frame *dcmd; 4174 4175 cmd = megasas_get_cmd(instance); 4176 4177 if (!cmd) { 4178 dev_err(&instance->pdev->dev, "Failed to get a free cmd\n"); 4179 return -ENOMEM; 4180 } 4181 4182 4183 dcmd = &cmd->frame->dcmd; 4184 4185 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 4186 dcmd->mbox.b[0] = crash_buf_state; 4187 dcmd->cmd = MFI_CMD_DCMD; 4188 dcmd->cmd_status = MFI_STAT_INVALID_STATUS; 4189 dcmd->sge_count = 1; 4190 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE); 4191 dcmd->timeout = 0; 4192 dcmd->pad_0 = 0; 4193 dcmd->data_xfer_len = cpu_to_le32(CRASH_DMA_BUF_SIZE); 4194 dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_SET_CRASH_DUMP_PARAMS); 4195 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(instance->crash_dump_h); 4196 dcmd->sgl.sge32[0].length = cpu_to_le32(CRASH_DMA_BUF_SIZE); 4197 4198 if (instance->ctrl_context && !instance->mask_interrupts) 4199 ret = megasas_issue_blocked_cmd(instance, cmd, 4200 MEGASAS_BLOCKED_CMD_TIMEOUT); 4201 else 4202 ret = megasas_issue_polled(instance, cmd); 4203 4204 megasas_return_cmd(instance, cmd); 4205 return ret; 4206 } 4207 4208 /** 4209 * megasas_issue_init_mfi - Initializes the FW 4210 * @instance: Adapter soft state 4211 * 4212 * Issues the INIT MFI cmd 4213 */ 4214 static int 4215 megasas_issue_init_mfi(struct megasas_instance *instance) 4216 { 4217 __le32 context; 4218 struct megasas_cmd *cmd; 4219 struct megasas_init_frame *init_frame; 4220 struct megasas_init_queue_info *initq_info; 4221 dma_addr_t init_frame_h; 4222 dma_addr_t initq_info_h; 4223 4224 /* 4225 * Prepare a init frame. Note the init frame points to queue info 4226 * structure. Each frame has SGL allocated after first 64 bytes. For 4227 * this frame - since we don't need any SGL - we use SGL's space as 4228 * queue info structure 4229 * 4230 * We will not get a NULL command below. We just created the pool. 4231 */ 4232 cmd = megasas_get_cmd(instance); 4233 4234 init_frame = (struct megasas_init_frame *)cmd->frame; 4235 initq_info = (struct megasas_init_queue_info *) 4236 ((unsigned long)init_frame + 64); 4237 4238 init_frame_h = cmd->frame_phys_addr; 4239 initq_info_h = init_frame_h + 64; 4240 4241 context = init_frame->context; 4242 memset(init_frame, 0, MEGAMFI_FRAME_SIZE); 4243 memset(initq_info, 0, sizeof(struct megasas_init_queue_info)); 4244 init_frame->context = context; 4245 4246 initq_info->reply_queue_entries = cpu_to_le32(instance->max_fw_cmds + 1); 4247 initq_info->reply_queue_start_phys_addr_lo = cpu_to_le32(instance->reply_queue_h); 4248 4249 initq_info->producer_index_phys_addr_lo = cpu_to_le32(instance->producer_h); 4250 initq_info->consumer_index_phys_addr_lo = cpu_to_le32(instance->consumer_h); 4251 4252 init_frame->cmd = MFI_CMD_INIT; 4253 init_frame->cmd_status = MFI_STAT_INVALID_STATUS; 4254 init_frame->queue_info_new_phys_addr_lo = 4255 cpu_to_le32(lower_32_bits(initq_info_h)); 4256 init_frame->queue_info_new_phys_addr_hi = 4257 cpu_to_le32(upper_32_bits(initq_info_h)); 4258 4259 init_frame->data_xfer_len = cpu_to_le32(sizeof(struct megasas_init_queue_info)); 4260 4261 /* 4262 * disable the intr before firing the init frame to FW 4263 */ 4264 instance->instancet->disable_intr(instance); 4265 4266 /* 4267 * Issue the init frame in polled mode 4268 */ 4269 4270 if (megasas_issue_polled(instance, cmd)) { 4271 dev_err(&instance->pdev->dev, "Failed to init firmware\n"); 4272 megasas_return_cmd(instance, cmd); 4273 goto fail_fw_init; 4274 } 4275 4276 megasas_return_cmd(instance, cmd); 4277 4278 return 0; 4279 4280 fail_fw_init: 4281 return -EINVAL; 4282 } 4283 4284 static u32 4285 megasas_init_adapter_mfi(struct megasas_instance *instance) 4286 { 4287 struct megasas_register_set __iomem *reg_set; 4288 u32 context_sz; 4289 u32 reply_q_sz; 4290 4291 reg_set = instance->reg_set; 4292 4293 /* 4294 * Get various operational parameters from status register 4295 */ 4296 instance->max_fw_cmds = instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF; 4297 /* 4298 * Reduce the max supported cmds by 1. This is to ensure that the 4299 * reply_q_sz (1 more than the max cmd that driver may send) 4300 * does not exceed max cmds that the FW can support 4301 */ 4302 instance->max_fw_cmds = instance->max_fw_cmds-1; 4303 instance->max_mfi_cmds = instance->max_fw_cmds; 4304 instance->max_num_sge = (instance->instancet->read_fw_status_reg(reg_set) & 0xFF0000) >> 4305 0x10; 4306 /* 4307 * For MFI skinny adapters, MEGASAS_SKINNY_INT_CMDS commands 4308 * are reserved for IOCTL + driver's internal DCMDs. 4309 */ 4310 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) || 4311 (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) { 4312 instance->max_scsi_cmds = (instance->max_fw_cmds - 4313 MEGASAS_SKINNY_INT_CMDS); 4314 sema_init(&instance->ioctl_sem, MEGASAS_SKINNY_INT_CMDS); 4315 } else { 4316 instance->max_scsi_cmds = (instance->max_fw_cmds - 4317 MEGASAS_INT_CMDS); 4318 sema_init(&instance->ioctl_sem, (MEGASAS_MFI_IOCTL_CMDS)); 4319 } 4320 4321 /* 4322 * Create a pool of commands 4323 */ 4324 if (megasas_alloc_cmds(instance)) 4325 goto fail_alloc_cmds; 4326 4327 /* 4328 * Allocate memory for reply queue. Length of reply queue should 4329 * be _one_ more than the maximum commands handled by the firmware. 4330 * 4331 * Note: When FW completes commands, it places corresponding contex 4332 * values in this circular reply queue. This circular queue is a fairly 4333 * typical producer-consumer queue. FW is the producer (of completed 4334 * commands) and the driver is the consumer. 4335 */ 4336 context_sz = sizeof(u32); 4337 reply_q_sz = context_sz * (instance->max_fw_cmds + 1); 4338 4339 instance->reply_queue = pci_alloc_consistent(instance->pdev, 4340 reply_q_sz, 4341 &instance->reply_queue_h); 4342 4343 if (!instance->reply_queue) { 4344 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Out of DMA mem for reply queue\n"); 4345 goto fail_reply_queue; 4346 } 4347 4348 if (megasas_issue_init_mfi(instance)) 4349 goto fail_fw_init; 4350 4351 if (megasas_get_ctrl_info(instance)) { 4352 dev_err(&instance->pdev->dev, "(%d): Could get controller info " 4353 "Fail from %s %d\n", instance->unique_id, 4354 __func__, __LINE__); 4355 goto fail_fw_init; 4356 } 4357 4358 instance->fw_support_ieee = 0; 4359 instance->fw_support_ieee = 4360 (instance->instancet->read_fw_status_reg(reg_set) & 4361 0x04000000); 4362 4363 dev_notice(&instance->pdev->dev, "megasas_init_mfi: fw_support_ieee=%d", 4364 instance->fw_support_ieee); 4365 4366 if (instance->fw_support_ieee) 4367 instance->flag_ieee = 1; 4368 4369 return 0; 4370 4371 fail_fw_init: 4372 4373 pci_free_consistent(instance->pdev, reply_q_sz, 4374 instance->reply_queue, instance->reply_queue_h); 4375 fail_reply_queue: 4376 megasas_free_cmds(instance); 4377 4378 fail_alloc_cmds: 4379 return 1; 4380 } 4381 4382 /* 4383 * megasas_setup_irqs_msix - register legacy interrupts. 4384 * @instance: Adapter soft state 4385 * 4386 * Do not enable interrupt, only setup ISRs. 4387 * 4388 * Return 0 on success. 4389 */ 4390 static int 4391 megasas_setup_irqs_ioapic(struct megasas_instance *instance) 4392 { 4393 struct pci_dev *pdev; 4394 4395 pdev = instance->pdev; 4396 instance->irq_context[0].instance = instance; 4397 instance->irq_context[0].MSIxIndex = 0; 4398 if (request_irq(pdev->irq, instance->instancet->service_isr, 4399 IRQF_SHARED, "megasas", &instance->irq_context[0])) { 4400 dev_err(&instance->pdev->dev, 4401 "Failed to register IRQ from %s %d\n", 4402 __func__, __LINE__); 4403 return -1; 4404 } 4405 return 0; 4406 } 4407 4408 /** 4409 * megasas_setup_irqs_msix - register MSI-x interrupts. 4410 * @instance: Adapter soft state 4411 * @is_probe: Driver probe check 4412 * 4413 * Do not enable interrupt, only setup ISRs. 4414 * 4415 * Return 0 on success. 4416 */ 4417 static int 4418 megasas_setup_irqs_msix(struct megasas_instance *instance, u8 is_probe) 4419 { 4420 int i, j, cpu; 4421 struct pci_dev *pdev; 4422 4423 pdev = instance->pdev; 4424 4425 /* Try MSI-x */ 4426 cpu = cpumask_first(cpu_online_mask); 4427 for (i = 0; i < instance->msix_vectors; i++) { 4428 instance->irq_context[i].instance = instance; 4429 instance->irq_context[i].MSIxIndex = i; 4430 if (request_irq(instance->msixentry[i].vector, 4431 instance->instancet->service_isr, 0, "megasas", 4432 &instance->irq_context[i])) { 4433 dev_err(&instance->pdev->dev, 4434 "Failed to register IRQ for vector %d.\n", i); 4435 for (j = 0; j < i; j++) { 4436 if (smp_affinity_enable) 4437 irq_set_affinity_hint( 4438 instance->msixentry[j].vector, NULL); 4439 free_irq(instance->msixentry[j].vector, 4440 &instance->irq_context[j]); 4441 } 4442 /* Retry irq register for IO_APIC*/ 4443 instance->msix_vectors = 0; 4444 if (is_probe) 4445 return megasas_setup_irqs_ioapic(instance); 4446 else 4447 return -1; 4448 } 4449 if (smp_affinity_enable) { 4450 if (irq_set_affinity_hint(instance->msixentry[i].vector, 4451 get_cpu_mask(cpu))) 4452 dev_err(&instance->pdev->dev, 4453 "Failed to set affinity hint" 4454 " for cpu %d\n", cpu); 4455 cpu = cpumask_next(cpu, cpu_online_mask); 4456 } 4457 } 4458 return 0; 4459 } 4460 4461 /* 4462 * megasas_destroy_irqs- unregister interrupts. 4463 * @instance: Adapter soft state 4464 * return: void 4465 */ 4466 static void 4467 megasas_destroy_irqs(struct megasas_instance *instance) { 4468 4469 int i; 4470 4471 if (instance->msix_vectors) 4472 for (i = 0; i < instance->msix_vectors; i++) { 4473 if (smp_affinity_enable) 4474 irq_set_affinity_hint( 4475 instance->msixentry[i].vector, NULL); 4476 free_irq(instance->msixentry[i].vector, 4477 &instance->irq_context[i]); 4478 } 4479 else 4480 free_irq(instance->pdev->irq, &instance->irq_context[0]); 4481 } 4482 4483 /** 4484 * megasas_init_fw - Initializes the FW 4485 * @instance: Adapter soft state 4486 * 4487 * This is the main function for initializing firmware 4488 */ 4489 4490 static int megasas_init_fw(struct megasas_instance *instance) 4491 { 4492 u32 max_sectors_1; 4493 u32 max_sectors_2; 4494 u32 tmp_sectors, msix_enable, scratch_pad_2; 4495 resource_size_t base_addr; 4496 struct megasas_register_set __iomem *reg_set; 4497 struct megasas_ctrl_info *ctrl_info = NULL; 4498 unsigned long bar_list; 4499 int i, loop, fw_msix_count = 0; 4500 struct IOV_111 *iovPtr; 4501 4502 /* Find first memory bar */ 4503 bar_list = pci_select_bars(instance->pdev, IORESOURCE_MEM); 4504 instance->bar = find_first_bit(&bar_list, sizeof(unsigned long)); 4505 if (pci_request_selected_regions(instance->pdev, instance->bar, 4506 "megasas: LSI")) { 4507 dev_printk(KERN_DEBUG, &instance->pdev->dev, "IO memory region busy!\n"); 4508 return -EBUSY; 4509 } 4510 4511 base_addr = pci_resource_start(instance->pdev, instance->bar); 4512 instance->reg_set = ioremap_nocache(base_addr, 8192); 4513 4514 if (!instance->reg_set) { 4515 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to map IO mem\n"); 4516 goto fail_ioremap; 4517 } 4518 4519 reg_set = instance->reg_set; 4520 4521 switch (instance->pdev->device) { 4522 case PCI_DEVICE_ID_LSI_FUSION: 4523 case PCI_DEVICE_ID_LSI_PLASMA: 4524 case PCI_DEVICE_ID_LSI_INVADER: 4525 case PCI_DEVICE_ID_LSI_FURY: 4526 instance->instancet = &megasas_instance_template_fusion; 4527 break; 4528 case PCI_DEVICE_ID_LSI_SAS1078R: 4529 case PCI_DEVICE_ID_LSI_SAS1078DE: 4530 instance->instancet = &megasas_instance_template_ppc; 4531 break; 4532 case PCI_DEVICE_ID_LSI_SAS1078GEN2: 4533 case PCI_DEVICE_ID_LSI_SAS0079GEN2: 4534 instance->instancet = &megasas_instance_template_gen2; 4535 break; 4536 case PCI_DEVICE_ID_LSI_SAS0073SKINNY: 4537 case PCI_DEVICE_ID_LSI_SAS0071SKINNY: 4538 instance->instancet = &megasas_instance_template_skinny; 4539 break; 4540 case PCI_DEVICE_ID_LSI_SAS1064R: 4541 case PCI_DEVICE_ID_DELL_PERC5: 4542 default: 4543 instance->instancet = &megasas_instance_template_xscale; 4544 break; 4545 } 4546 4547 if (megasas_transition_to_ready(instance, 0)) { 4548 atomic_set(&instance->fw_reset_no_pci_access, 1); 4549 instance->instancet->adp_reset 4550 (instance, instance->reg_set); 4551 atomic_set(&instance->fw_reset_no_pci_access, 0); 4552 dev_info(&instance->pdev->dev, 4553 "FW restarted successfully from %s!\n", 4554 __func__); 4555 4556 /*waitting for about 30 second before retry*/ 4557 ssleep(30); 4558 4559 if (megasas_transition_to_ready(instance, 0)) 4560 goto fail_ready_state; 4561 } 4562 4563 /* 4564 * MSI-X host index 0 is common for all adapter. 4565 * It is used for all MPT based Adapters. 4566 */ 4567 instance->reply_post_host_index_addr[0] = 4568 (u32 __iomem *)((u8 __iomem *)instance->reg_set + 4569 MPI2_REPLY_POST_HOST_INDEX_OFFSET); 4570 4571 /* Check if MSI-X is supported while in ready state */ 4572 msix_enable = (instance->instancet->read_fw_status_reg(reg_set) & 4573 0x4000000) >> 0x1a; 4574 if (msix_enable && !msix_disable) { 4575 scratch_pad_2 = readl 4576 (&instance->reg_set->outbound_scratch_pad_2); 4577 /* Check max MSI-X vectors */ 4578 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) || 4579 (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA)) { 4580 instance->msix_vectors = (scratch_pad_2 4581 & MR_MAX_REPLY_QUEUES_OFFSET) + 1; 4582 fw_msix_count = instance->msix_vectors; 4583 if (msix_vectors) 4584 instance->msix_vectors = 4585 min(msix_vectors, 4586 instance->msix_vectors); 4587 } else if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) 4588 || (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) { 4589 /* Invader/Fury supports more than 8 MSI-X */ 4590 instance->msix_vectors = ((scratch_pad_2 4591 & MR_MAX_REPLY_QUEUES_EXT_OFFSET) 4592 >> MR_MAX_REPLY_QUEUES_EXT_OFFSET_SHIFT) + 1; 4593 fw_msix_count = instance->msix_vectors; 4594 /* Save 1-15 reply post index address to local memory 4595 * Index 0 is already saved from reg offset 4596 * MPI2_REPLY_POST_HOST_INDEX_OFFSET 4597 */ 4598 for (loop = 1; loop < MR_MAX_MSIX_REG_ARRAY; loop++) { 4599 instance->reply_post_host_index_addr[loop] = 4600 (u32 __iomem *) 4601 ((u8 __iomem *)instance->reg_set + 4602 MPI2_SUP_REPLY_POST_HOST_INDEX_OFFSET 4603 + (loop * 0x10)); 4604 } 4605 if (msix_vectors) 4606 instance->msix_vectors = min(msix_vectors, 4607 instance->msix_vectors); 4608 } else 4609 instance->msix_vectors = 1; 4610 /* Don't bother allocating more MSI-X vectors than cpus */ 4611 instance->msix_vectors = min(instance->msix_vectors, 4612 (unsigned int)num_online_cpus()); 4613 for (i = 0; i < instance->msix_vectors; i++) 4614 instance->msixentry[i].entry = i; 4615 i = pci_enable_msix_range(instance->pdev, instance->msixentry, 4616 1, instance->msix_vectors); 4617 if (i > 0) 4618 instance->msix_vectors = i; 4619 else 4620 instance->msix_vectors = 0; 4621 } 4622 4623 dev_info(&instance->pdev->dev, 4624 "firmware supports msix\t: (%d)", fw_msix_count); 4625 dev_info(&instance->pdev->dev, 4626 "current msix/online cpus\t: (%d/%d)\n", 4627 instance->msix_vectors, (unsigned int)num_online_cpus()); 4628 4629 if (instance->msix_vectors ? 4630 megasas_setup_irqs_msix(instance, 1) : 4631 megasas_setup_irqs_ioapic(instance)) 4632 goto fail_setup_irqs; 4633 4634 instance->ctrl_info = kzalloc(sizeof(struct megasas_ctrl_info), 4635 GFP_KERNEL); 4636 if (instance->ctrl_info == NULL) 4637 goto fail_init_adapter; 4638 4639 /* 4640 * Below are default value for legacy Firmware. 4641 * non-fusion based controllers 4642 */ 4643 instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES; 4644 instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES; 4645 /* Get operational params, sge flags, send init cmd to controller */ 4646 if (instance->instancet->init_adapter(instance)) 4647 goto fail_init_adapter; 4648 4649 tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet, 4650 (unsigned long)instance); 4651 4652 instance->instancet->enable_intr(instance); 4653 4654 dev_err(&instance->pdev->dev, "INIT adapter done\n"); 4655 4656 /** for passthrough 4657 * the following function will get the PD LIST. 4658 */ 4659 memset(instance->pd_list, 0, 4660 (MEGASAS_MAX_PD * sizeof(struct megasas_pd_list))); 4661 if (megasas_get_pd_list(instance) < 0) { 4662 dev_err(&instance->pdev->dev, "failed to get PD list\n"); 4663 goto fail_get_pd_list; 4664 } 4665 4666 memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS); 4667 if (megasas_ld_list_query(instance, 4668 MR_LD_QUERY_TYPE_EXPOSED_TO_HOST)) 4669 megasas_get_ld_list(instance); 4670 4671 /* 4672 * Compute the max allowed sectors per IO: The controller info has two 4673 * limits on max sectors. Driver should use the minimum of these two. 4674 * 4675 * 1 << stripe_sz_ops.min = max sectors per strip 4676 * 4677 * Note that older firmwares ( < FW ver 30) didn't report information 4678 * to calculate max_sectors_1. So the number ended up as zero always. 4679 */ 4680 tmp_sectors = 0; 4681 ctrl_info = instance->ctrl_info; 4682 4683 max_sectors_1 = (1 << ctrl_info->stripe_sz_ops.min) * 4684 le16_to_cpu(ctrl_info->max_strips_per_io); 4685 max_sectors_2 = le32_to_cpu(ctrl_info->max_request_size); 4686 4687 tmp_sectors = min_t(u32, max_sectors_1, max_sectors_2); 4688 4689 instance->disableOnlineCtrlReset = 4690 ctrl_info->properties.OnOffProperties.disableOnlineCtrlReset; 4691 instance->mpio = ctrl_info->adapterOperations2.mpio; 4692 instance->UnevenSpanSupport = 4693 ctrl_info->adapterOperations2.supportUnevenSpans; 4694 if (instance->UnevenSpanSupport) { 4695 struct fusion_context *fusion = instance->ctrl_context; 4696 if (MR_ValidateMapInfo(instance)) 4697 fusion->fast_path_io = 1; 4698 else 4699 fusion->fast_path_io = 0; 4700 4701 } 4702 if (ctrl_info->host_interface.SRIOV) { 4703 if (!ctrl_info->adapterOperations2.activePassive) 4704 instance->PlasmaFW111 = 1; 4705 4706 if (!instance->PlasmaFW111) 4707 instance->requestorId = 4708 ctrl_info->iov.requestorId; 4709 else { 4710 iovPtr = (struct IOV_111 *)((unsigned char *)ctrl_info + IOV_111_OFFSET); 4711 instance->requestorId = iovPtr->requestorId; 4712 } 4713 dev_warn(&instance->pdev->dev, "I am VF " 4714 "requestorId %d\n", instance->requestorId); 4715 } 4716 4717 instance->crash_dump_fw_support = 4718 ctrl_info->adapterOperations3.supportCrashDump; 4719 instance->crash_dump_drv_support = 4720 (instance->crash_dump_fw_support && 4721 instance->crash_dump_buf); 4722 if (instance->crash_dump_drv_support) 4723 megasas_set_crash_dump_params(instance, 4724 MR_CRASH_BUF_TURN_OFF); 4725 4726 else { 4727 if (instance->crash_dump_buf) 4728 pci_free_consistent(instance->pdev, 4729 CRASH_DMA_BUF_SIZE, 4730 instance->crash_dump_buf, 4731 instance->crash_dump_h); 4732 instance->crash_dump_buf = NULL; 4733 } 4734 4735 instance->secure_jbod_support = 4736 ctrl_info->adapterOperations3.supportSecurityonJBOD; 4737 4738 dev_info(&instance->pdev->dev, 4739 "pci id\t\t: (0x%04x)/(0x%04x)/(0x%04x)/(0x%04x)\n", 4740 le16_to_cpu(ctrl_info->pci.vendor_id), 4741 le16_to_cpu(ctrl_info->pci.device_id), 4742 le16_to_cpu(ctrl_info->pci.sub_vendor_id), 4743 le16_to_cpu(ctrl_info->pci.sub_device_id)); 4744 dev_info(&instance->pdev->dev, "unevenspan support : %s\n", 4745 instance->UnevenSpanSupport ? "yes" : "no"); 4746 dev_info(&instance->pdev->dev, "disable ocr : %s\n", 4747 instance->disableOnlineCtrlReset ? "yes" : "no"); 4748 dev_info(&instance->pdev->dev, "firmware crash dump : %s\n", 4749 instance->crash_dump_drv_support ? "yes" : "no"); 4750 dev_info(&instance->pdev->dev, "secure jbod : %s\n", 4751 instance->secure_jbod_support ? "yes" : "no"); 4752 4753 4754 instance->max_sectors_per_req = instance->max_num_sge * 4755 PAGE_SIZE / 512; 4756 if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors)) 4757 instance->max_sectors_per_req = tmp_sectors; 4758 4759 /* Check for valid throttlequeuedepth module parameter */ 4760 if (throttlequeuedepth && 4761 throttlequeuedepth <= instance->max_scsi_cmds) 4762 instance->throttlequeuedepth = throttlequeuedepth; 4763 else 4764 instance->throttlequeuedepth = 4765 MEGASAS_THROTTLE_QUEUE_DEPTH; 4766 4767 4768 /* Launch SR-IOV heartbeat timer */ 4769 if (instance->requestorId) { 4770 if (!megasas_sriov_start_heartbeat(instance, 1)) 4771 megasas_start_timer(instance, 4772 &instance->sriov_heartbeat_timer, 4773 megasas_sriov_heartbeat_handler, 4774 MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF); 4775 else 4776 instance->skip_heartbeat_timer_del = 1; 4777 } 4778 4779 return 0; 4780 4781 fail_get_pd_list: 4782 instance->instancet->disable_intr(instance); 4783 fail_init_adapter: 4784 megasas_destroy_irqs(instance); 4785 fail_setup_irqs: 4786 if (instance->msix_vectors) 4787 pci_disable_msix(instance->pdev); 4788 instance->msix_vectors = 0; 4789 fail_ready_state: 4790 kfree(instance->ctrl_info); 4791 instance->ctrl_info = NULL; 4792 iounmap(instance->reg_set); 4793 4794 fail_ioremap: 4795 pci_release_selected_regions(instance->pdev, instance->bar); 4796 4797 return -EINVAL; 4798 } 4799 4800 /** 4801 * megasas_release_mfi - Reverses the FW initialization 4802 * @instance: Adapter soft state 4803 */ 4804 static void megasas_release_mfi(struct megasas_instance *instance) 4805 { 4806 u32 reply_q_sz = sizeof(u32) *(instance->max_mfi_cmds + 1); 4807 4808 if (instance->reply_queue) 4809 pci_free_consistent(instance->pdev, reply_q_sz, 4810 instance->reply_queue, instance->reply_queue_h); 4811 4812 megasas_free_cmds(instance); 4813 4814 iounmap(instance->reg_set); 4815 4816 pci_release_selected_regions(instance->pdev, instance->bar); 4817 } 4818 4819 /** 4820 * megasas_get_seq_num - Gets latest event sequence numbers 4821 * @instance: Adapter soft state 4822 * @eli: FW event log sequence numbers information 4823 * 4824 * FW maintains a log of all events in a non-volatile area. Upper layers would 4825 * usually find out the latest sequence number of the events, the seq number at 4826 * the boot etc. They would "read" all the events below the latest seq number 4827 * by issuing a direct fw cmd (DCMD). For the future events (beyond latest seq 4828 * number), they would subsribe to AEN (asynchronous event notification) and 4829 * wait for the events to happen. 4830 */ 4831 static int 4832 megasas_get_seq_num(struct megasas_instance *instance, 4833 struct megasas_evt_log_info *eli) 4834 { 4835 struct megasas_cmd *cmd; 4836 struct megasas_dcmd_frame *dcmd; 4837 struct megasas_evt_log_info *el_info; 4838 dma_addr_t el_info_h = 0; 4839 4840 cmd = megasas_get_cmd(instance); 4841 4842 if (!cmd) { 4843 return -ENOMEM; 4844 } 4845 4846 dcmd = &cmd->frame->dcmd; 4847 el_info = pci_alloc_consistent(instance->pdev, 4848 sizeof(struct megasas_evt_log_info), 4849 &el_info_h); 4850 4851 if (!el_info) { 4852 megasas_return_cmd(instance, cmd); 4853 return -ENOMEM; 4854 } 4855 4856 memset(el_info, 0, sizeof(*el_info)); 4857 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 4858 4859 dcmd->cmd = MFI_CMD_DCMD; 4860 dcmd->cmd_status = 0x0; 4861 dcmd->sge_count = 1; 4862 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ); 4863 dcmd->timeout = 0; 4864 dcmd->pad_0 = 0; 4865 dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_evt_log_info)); 4866 dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_EVENT_GET_INFO); 4867 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(el_info_h); 4868 dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct megasas_evt_log_info)); 4869 4870 if (megasas_issue_blocked_cmd(instance, cmd, 30)) 4871 dev_err(&instance->pdev->dev, "Command timedout" 4872 "from %s\n", __func__); 4873 else { 4874 /* 4875 * Copy the data back into callers buffer 4876 */ 4877 eli->newest_seq_num = el_info->newest_seq_num; 4878 eli->oldest_seq_num = el_info->oldest_seq_num; 4879 eli->clear_seq_num = el_info->clear_seq_num; 4880 eli->shutdown_seq_num = el_info->shutdown_seq_num; 4881 eli->boot_seq_num = el_info->boot_seq_num; 4882 } 4883 4884 pci_free_consistent(instance->pdev, sizeof(struct megasas_evt_log_info), 4885 el_info, el_info_h); 4886 4887 megasas_return_cmd(instance, cmd); 4888 4889 return 0; 4890 } 4891 4892 /** 4893 * megasas_register_aen - Registers for asynchronous event notification 4894 * @instance: Adapter soft state 4895 * @seq_num: The starting sequence number 4896 * @class_locale: Class of the event 4897 * 4898 * This function subscribes for AEN for events beyond the @seq_num. It requests 4899 * to be notified if and only if the event is of type @class_locale 4900 */ 4901 static int 4902 megasas_register_aen(struct megasas_instance *instance, u32 seq_num, 4903 u32 class_locale_word) 4904 { 4905 int ret_val; 4906 struct megasas_cmd *cmd; 4907 struct megasas_dcmd_frame *dcmd; 4908 union megasas_evt_class_locale curr_aen; 4909 union megasas_evt_class_locale prev_aen; 4910 4911 /* 4912 * If there an AEN pending already (aen_cmd), check if the 4913 * class_locale of that pending AEN is inclusive of the new 4914 * AEN request we currently have. If it is, then we don't have 4915 * to do anything. In other words, whichever events the current 4916 * AEN request is subscribing to, have already been subscribed 4917 * to. 4918 * 4919 * If the old_cmd is _not_ inclusive, then we have to abort 4920 * that command, form a class_locale that is superset of both 4921 * old and current and re-issue to the FW 4922 */ 4923 4924 curr_aen.word = class_locale_word; 4925 4926 if (instance->aen_cmd) { 4927 4928 prev_aen.word = 4929 le32_to_cpu(instance->aen_cmd->frame->dcmd.mbox.w[1]); 4930 4931 /* 4932 * A class whose enum value is smaller is inclusive of all 4933 * higher values. If a PROGRESS (= -1) was previously 4934 * registered, then a new registration requests for higher 4935 * classes need not be sent to FW. They are automatically 4936 * included. 4937 * 4938 * Locale numbers don't have such hierarchy. They are bitmap 4939 * values 4940 */ 4941 if ((prev_aen.members.class <= curr_aen.members.class) && 4942 !((prev_aen.members.locale & curr_aen.members.locale) ^ 4943 curr_aen.members.locale)) { 4944 /* 4945 * Previously issued event registration includes 4946 * current request. Nothing to do. 4947 */ 4948 return 0; 4949 } else { 4950 curr_aen.members.locale |= prev_aen.members.locale; 4951 4952 if (prev_aen.members.class < curr_aen.members.class) 4953 curr_aen.members.class = prev_aen.members.class; 4954 4955 instance->aen_cmd->abort_aen = 1; 4956 ret_val = megasas_issue_blocked_abort_cmd(instance, 4957 instance-> 4958 aen_cmd, 30); 4959 4960 if (ret_val) { 4961 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to abort " 4962 "previous AEN command\n"); 4963 return ret_val; 4964 } 4965 } 4966 } 4967 4968 cmd = megasas_get_cmd(instance); 4969 4970 if (!cmd) 4971 return -ENOMEM; 4972 4973 dcmd = &cmd->frame->dcmd; 4974 4975 memset(instance->evt_detail, 0, sizeof(struct megasas_evt_detail)); 4976 4977 /* 4978 * Prepare DCMD for aen registration 4979 */ 4980 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 4981 4982 dcmd->cmd = MFI_CMD_DCMD; 4983 dcmd->cmd_status = 0x0; 4984 dcmd->sge_count = 1; 4985 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ); 4986 dcmd->timeout = 0; 4987 dcmd->pad_0 = 0; 4988 dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_evt_detail)); 4989 dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_EVENT_WAIT); 4990 dcmd->mbox.w[0] = cpu_to_le32(seq_num); 4991 instance->last_seq_num = seq_num; 4992 dcmd->mbox.w[1] = cpu_to_le32(curr_aen.word); 4993 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(instance->evt_detail_h); 4994 dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct megasas_evt_detail)); 4995 4996 if (instance->aen_cmd != NULL) { 4997 megasas_return_cmd(instance, cmd); 4998 return 0; 4999 } 5000 5001 /* 5002 * Store reference to the cmd used to register for AEN. When an 5003 * application wants us to register for AEN, we have to abort this 5004 * cmd and re-register with a new EVENT LOCALE supplied by that app 5005 */ 5006 instance->aen_cmd = cmd; 5007 5008 /* 5009 * Issue the aen registration frame 5010 */ 5011 instance->instancet->issue_dcmd(instance, cmd); 5012 5013 return 0; 5014 } 5015 5016 /** 5017 * megasas_start_aen - Subscribes to AEN during driver load time 5018 * @instance: Adapter soft state 5019 */ 5020 static int megasas_start_aen(struct megasas_instance *instance) 5021 { 5022 struct megasas_evt_log_info eli; 5023 union megasas_evt_class_locale class_locale; 5024 5025 /* 5026 * Get the latest sequence number from FW 5027 */ 5028 memset(&eli, 0, sizeof(eli)); 5029 5030 if (megasas_get_seq_num(instance, &eli)) 5031 return -1; 5032 5033 /* 5034 * Register AEN with FW for latest sequence number plus 1 5035 */ 5036 class_locale.members.reserved = 0; 5037 class_locale.members.locale = MR_EVT_LOCALE_ALL; 5038 class_locale.members.class = MR_EVT_CLASS_DEBUG; 5039 5040 return megasas_register_aen(instance, 5041 le32_to_cpu(eli.newest_seq_num) + 1, 5042 class_locale.word); 5043 } 5044 5045 /** 5046 * megasas_io_attach - Attaches this driver to SCSI mid-layer 5047 * @instance: Adapter soft state 5048 */ 5049 static int megasas_io_attach(struct megasas_instance *instance) 5050 { 5051 struct Scsi_Host *host = instance->host; 5052 u32 error; 5053 5054 /* 5055 * Export parameters required by SCSI mid-layer 5056 */ 5057 host->irq = instance->pdev->irq; 5058 host->unique_id = instance->unique_id; 5059 host->can_queue = instance->max_scsi_cmds; 5060 host->this_id = instance->init_id; 5061 host->sg_tablesize = instance->max_num_sge; 5062 5063 if (instance->fw_support_ieee) 5064 instance->max_sectors_per_req = MEGASAS_MAX_SECTORS_IEEE; 5065 5066 /* 5067 * Check if the module parameter value for max_sectors can be used 5068 */ 5069 if (max_sectors && max_sectors < instance->max_sectors_per_req) 5070 instance->max_sectors_per_req = max_sectors; 5071 else { 5072 if (max_sectors) { 5073 if (((instance->pdev->device == 5074 PCI_DEVICE_ID_LSI_SAS1078GEN2) || 5075 (instance->pdev->device == 5076 PCI_DEVICE_ID_LSI_SAS0079GEN2)) && 5077 (max_sectors <= MEGASAS_MAX_SECTORS)) { 5078 instance->max_sectors_per_req = max_sectors; 5079 } else { 5080 dev_info(&instance->pdev->dev, "max_sectors should be > 0" 5081 "and <= %d (or < 1MB for GEN2 controller)\n", 5082 instance->max_sectors_per_req); 5083 } 5084 } 5085 } 5086 5087 host->max_sectors = instance->max_sectors_per_req; 5088 host->cmd_per_lun = MEGASAS_DEFAULT_CMD_PER_LUN; 5089 host->max_channel = MEGASAS_MAX_CHANNELS - 1; 5090 host->max_id = MEGASAS_MAX_DEV_PER_CHANNEL; 5091 host->max_lun = MEGASAS_MAX_LUN; 5092 host->max_cmd_len = 16; 5093 5094 /* Fusion only supports host reset */ 5095 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) || 5096 (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) || 5097 (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) || 5098 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) { 5099 host->hostt->eh_device_reset_handler = NULL; 5100 host->hostt->eh_bus_reset_handler = NULL; 5101 } 5102 error = scsi_init_shared_tag_map(host, host->can_queue); 5103 if (error) { 5104 dev_err(&instance->pdev->dev, 5105 "Failed to shared tag from %s %d\n", 5106 __func__, __LINE__); 5107 return -ENODEV; 5108 } 5109 5110 /* 5111 * Notify the mid-layer about the new controller 5112 */ 5113 if (scsi_add_host(host, &instance->pdev->dev)) { 5114 dev_err(&instance->pdev->dev, 5115 "Failed to add host from %s %d\n", 5116 __func__, __LINE__); 5117 return -ENODEV; 5118 } 5119 5120 return 0; 5121 } 5122 5123 static int 5124 megasas_set_dma_mask(struct pci_dev *pdev) 5125 { 5126 /* 5127 * All our controllers are capable of performing 64-bit DMA 5128 */ 5129 if (IS_DMA64) { 5130 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0) { 5131 5132 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0) 5133 goto fail_set_dma_mask; 5134 } 5135 } else { 5136 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0) 5137 goto fail_set_dma_mask; 5138 } 5139 /* 5140 * Ensure that all data structures are allocated in 32-bit 5141 * memory. 5142 */ 5143 if (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)) != 0) { 5144 /* Try 32bit DMA mask and 32 bit Consistent dma mask */ 5145 if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) 5146 && !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) 5147 dev_info(&pdev->dev, "set 32bit DMA mask" 5148 "and 32 bit consistent mask\n"); 5149 else 5150 goto fail_set_dma_mask; 5151 } 5152 5153 return 0; 5154 5155 fail_set_dma_mask: 5156 return 1; 5157 } 5158 5159 /** 5160 * megasas_probe_one - PCI hotplug entry point 5161 * @pdev: PCI device structure 5162 * @id: PCI ids of supported hotplugged adapter 5163 */ 5164 static int megasas_probe_one(struct pci_dev *pdev, 5165 const struct pci_device_id *id) 5166 { 5167 int rval, pos; 5168 struct Scsi_Host *host; 5169 struct megasas_instance *instance; 5170 u16 control = 0; 5171 struct fusion_context *fusion = NULL; 5172 5173 /* Reset MSI-X in the kdump kernel */ 5174 if (reset_devices) { 5175 pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX); 5176 if (pos) { 5177 pci_read_config_word(pdev, pos + PCI_MSIX_FLAGS, 5178 &control); 5179 if (control & PCI_MSIX_FLAGS_ENABLE) { 5180 dev_info(&pdev->dev, "resetting MSI-X\n"); 5181 pci_write_config_word(pdev, 5182 pos + PCI_MSIX_FLAGS, 5183 control & 5184 ~PCI_MSIX_FLAGS_ENABLE); 5185 } 5186 } 5187 } 5188 5189 /* 5190 * PCI prepping: enable device set bus mastering and dma mask 5191 */ 5192 rval = pci_enable_device_mem(pdev); 5193 5194 if (rval) { 5195 return rval; 5196 } 5197 5198 pci_set_master(pdev); 5199 5200 if (megasas_set_dma_mask(pdev)) 5201 goto fail_set_dma_mask; 5202 5203 host = scsi_host_alloc(&megasas_template, 5204 sizeof(struct megasas_instance)); 5205 5206 if (!host) { 5207 dev_printk(KERN_DEBUG, &pdev->dev, "scsi_host_alloc failed\n"); 5208 goto fail_alloc_instance; 5209 } 5210 5211 instance = (struct megasas_instance *)host->hostdata; 5212 memset(instance, 0, sizeof(*instance)); 5213 atomic_set(&instance->fw_reset_no_pci_access, 0); 5214 instance->pdev = pdev; 5215 5216 switch (instance->pdev->device) { 5217 case PCI_DEVICE_ID_LSI_FUSION: 5218 case PCI_DEVICE_ID_LSI_PLASMA: 5219 case PCI_DEVICE_ID_LSI_INVADER: 5220 case PCI_DEVICE_ID_LSI_FURY: 5221 { 5222 instance->ctrl_context_pages = 5223 get_order(sizeof(struct fusion_context)); 5224 instance->ctrl_context = (void *)__get_free_pages(GFP_KERNEL, 5225 instance->ctrl_context_pages); 5226 if (!instance->ctrl_context) { 5227 dev_printk(KERN_DEBUG, &pdev->dev, "Failed to allocate " 5228 "memory for Fusion context info\n"); 5229 goto fail_alloc_dma_buf; 5230 } 5231 fusion = instance->ctrl_context; 5232 memset(fusion, 0, 5233 ((1 << PAGE_SHIFT) << instance->ctrl_context_pages)); 5234 } 5235 break; 5236 default: /* For all other supported controllers */ 5237 5238 instance->producer = 5239 pci_alloc_consistent(pdev, sizeof(u32), 5240 &instance->producer_h); 5241 instance->consumer = 5242 pci_alloc_consistent(pdev, sizeof(u32), 5243 &instance->consumer_h); 5244 5245 if (!instance->producer || !instance->consumer) { 5246 dev_printk(KERN_DEBUG, &pdev->dev, "Failed to allocate" 5247 "memory for producer, consumer\n"); 5248 goto fail_alloc_dma_buf; 5249 } 5250 5251 *instance->producer = 0; 5252 *instance->consumer = 0; 5253 break; 5254 } 5255 5256 instance->system_info_buf = pci_zalloc_consistent(pdev, 5257 sizeof(struct MR_DRV_SYSTEM_INFO), 5258 &instance->system_info_h); 5259 5260 if (!instance->system_info_buf) 5261 dev_info(&instance->pdev->dev, "Can't allocate system info buffer\n"); 5262 5263 /* Crash dump feature related initialisation*/ 5264 instance->drv_buf_index = 0; 5265 instance->drv_buf_alloc = 0; 5266 instance->crash_dump_fw_support = 0; 5267 instance->crash_dump_app_support = 0; 5268 instance->fw_crash_state = UNAVAILABLE; 5269 spin_lock_init(&instance->crashdump_lock); 5270 instance->crash_dump_buf = NULL; 5271 5272 if (!reset_devices) 5273 instance->crash_dump_buf = pci_alloc_consistent(pdev, 5274 CRASH_DMA_BUF_SIZE, 5275 &instance->crash_dump_h); 5276 if (!instance->crash_dump_buf) 5277 dev_err(&pdev->dev, "Can't allocate Firmware " 5278 "crash dump DMA buffer\n"); 5279 5280 megasas_poll_wait_aen = 0; 5281 instance->flag_ieee = 0; 5282 instance->ev = NULL; 5283 instance->issuepend_done = 1; 5284 instance->adprecovery = MEGASAS_HBA_OPERATIONAL; 5285 instance->is_imr = 0; 5286 5287 instance->evt_detail = pci_alloc_consistent(pdev, 5288 sizeof(struct 5289 megasas_evt_detail), 5290 &instance->evt_detail_h); 5291 5292 if (!instance->evt_detail) { 5293 dev_printk(KERN_DEBUG, &pdev->dev, "Failed to allocate memory for " 5294 "event detail structure\n"); 5295 goto fail_alloc_dma_buf; 5296 } 5297 5298 /* 5299 * Initialize locks and queues 5300 */ 5301 INIT_LIST_HEAD(&instance->cmd_pool); 5302 INIT_LIST_HEAD(&instance->internal_reset_pending_q); 5303 5304 atomic_set(&instance->fw_outstanding,0); 5305 5306 init_waitqueue_head(&instance->int_cmd_wait_q); 5307 init_waitqueue_head(&instance->abort_cmd_wait_q); 5308 5309 spin_lock_init(&instance->mfi_pool_lock); 5310 spin_lock_init(&instance->hba_lock); 5311 spin_lock_init(&instance->completion_lock); 5312 5313 mutex_init(&instance->aen_mutex); 5314 mutex_init(&instance->reset_mutex); 5315 5316 /* 5317 * Initialize PCI related and misc parameters 5318 */ 5319 instance->host = host; 5320 instance->unique_id = pdev->bus->number << 8 | pdev->devfn; 5321 instance->init_id = MEGASAS_DEFAULT_INIT_ID; 5322 instance->ctrl_info = NULL; 5323 5324 5325 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) || 5326 (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) 5327 instance->flag_ieee = 1; 5328 5329 megasas_dbg_lvl = 0; 5330 instance->flag = 0; 5331 instance->unload = 1; 5332 instance->last_time = 0; 5333 instance->disableOnlineCtrlReset = 1; 5334 instance->UnevenSpanSupport = 0; 5335 5336 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) || 5337 (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) || 5338 (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) || 5339 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) { 5340 INIT_WORK(&instance->work_init, megasas_fusion_ocr_wq); 5341 INIT_WORK(&instance->crash_init, megasas_fusion_crash_dump_wq); 5342 } else 5343 INIT_WORK(&instance->work_init, process_fw_state_change_wq); 5344 5345 /* 5346 * Initialize MFI Firmware 5347 */ 5348 if (megasas_init_fw(instance)) 5349 goto fail_init_mfi; 5350 5351 if (instance->requestorId) { 5352 if (instance->PlasmaFW111) { 5353 instance->vf_affiliation_111 = 5354 pci_alloc_consistent(pdev, sizeof(struct MR_LD_VF_AFFILIATION_111), 5355 &instance->vf_affiliation_111_h); 5356 if (!instance->vf_affiliation_111) 5357 dev_warn(&pdev->dev, "Can't allocate " 5358 "memory for VF affiliation buffer\n"); 5359 } else { 5360 instance->vf_affiliation = 5361 pci_alloc_consistent(pdev, 5362 (MAX_LOGICAL_DRIVES + 1) * 5363 sizeof(struct MR_LD_VF_AFFILIATION), 5364 &instance->vf_affiliation_h); 5365 if (!instance->vf_affiliation) 5366 dev_warn(&pdev->dev, "Can't allocate " 5367 "memory for VF affiliation buffer\n"); 5368 } 5369 } 5370 5371 /* 5372 * Store instance in PCI softstate 5373 */ 5374 pci_set_drvdata(pdev, instance); 5375 5376 /* 5377 * Add this controller to megasas_mgmt_info structure so that it 5378 * can be exported to management applications 5379 */ 5380 megasas_mgmt_info.count++; 5381 megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = instance; 5382 megasas_mgmt_info.max_index++; 5383 5384 /* 5385 * Register with SCSI mid-layer 5386 */ 5387 if (megasas_io_attach(instance)) 5388 goto fail_io_attach; 5389 5390 instance->unload = 0; 5391 /* 5392 * Trigger SCSI to scan our drives 5393 */ 5394 scsi_scan_host(host); 5395 5396 /* 5397 * Initiate AEN (Asynchronous Event Notification) 5398 */ 5399 if (megasas_start_aen(instance)) { 5400 dev_printk(KERN_DEBUG, &pdev->dev, "start aen failed\n"); 5401 goto fail_start_aen; 5402 } 5403 5404 /* Get current SR-IOV LD/VF affiliation */ 5405 if (instance->requestorId) 5406 megasas_get_ld_vf_affiliation(instance, 1); 5407 5408 return 0; 5409 5410 fail_start_aen: 5411 fail_io_attach: 5412 megasas_mgmt_info.count--; 5413 megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL; 5414 megasas_mgmt_info.max_index--; 5415 5416 instance->instancet->disable_intr(instance); 5417 megasas_destroy_irqs(instance); 5418 5419 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) || 5420 (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) || 5421 (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) || 5422 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) 5423 megasas_release_fusion(instance); 5424 else 5425 megasas_release_mfi(instance); 5426 if (instance->msix_vectors) 5427 pci_disable_msix(instance->pdev); 5428 fail_init_mfi: 5429 fail_alloc_dma_buf: 5430 if (instance->evt_detail) 5431 pci_free_consistent(pdev, sizeof(struct megasas_evt_detail), 5432 instance->evt_detail, 5433 instance->evt_detail_h); 5434 5435 if (instance->producer) 5436 pci_free_consistent(pdev, sizeof(u32), instance->producer, 5437 instance->producer_h); 5438 if (instance->consumer) 5439 pci_free_consistent(pdev, sizeof(u32), instance->consumer, 5440 instance->consumer_h); 5441 scsi_host_put(host); 5442 5443 fail_alloc_instance: 5444 fail_set_dma_mask: 5445 pci_disable_device(pdev); 5446 5447 return -ENODEV; 5448 } 5449 5450 /** 5451 * megasas_flush_cache - Requests FW to flush all its caches 5452 * @instance: Adapter soft state 5453 */ 5454 static void megasas_flush_cache(struct megasas_instance *instance) 5455 { 5456 struct megasas_cmd *cmd; 5457 struct megasas_dcmd_frame *dcmd; 5458 5459 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) 5460 return; 5461 5462 cmd = megasas_get_cmd(instance); 5463 5464 if (!cmd) 5465 return; 5466 5467 dcmd = &cmd->frame->dcmd; 5468 5469 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 5470 5471 dcmd->cmd = MFI_CMD_DCMD; 5472 dcmd->cmd_status = 0x0; 5473 dcmd->sge_count = 0; 5474 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE); 5475 dcmd->timeout = 0; 5476 dcmd->pad_0 = 0; 5477 dcmd->data_xfer_len = 0; 5478 dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_CACHE_FLUSH); 5479 dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE; 5480 5481 if (megasas_issue_blocked_cmd(instance, cmd, 30)) 5482 dev_err(&instance->pdev->dev, "Command timedout" 5483 " from %s\n", __func__); 5484 5485 megasas_return_cmd(instance, cmd); 5486 } 5487 5488 /** 5489 * megasas_shutdown_controller - Instructs FW to shutdown the controller 5490 * @instance: Adapter soft state 5491 * @opcode: Shutdown/Hibernate 5492 */ 5493 static void megasas_shutdown_controller(struct megasas_instance *instance, 5494 u32 opcode) 5495 { 5496 struct megasas_cmd *cmd; 5497 struct megasas_dcmd_frame *dcmd; 5498 5499 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) 5500 return; 5501 5502 cmd = megasas_get_cmd(instance); 5503 5504 if (!cmd) 5505 return; 5506 5507 if (instance->aen_cmd) 5508 megasas_issue_blocked_abort_cmd(instance, 5509 instance->aen_cmd, 30); 5510 if (instance->map_update_cmd) 5511 megasas_issue_blocked_abort_cmd(instance, 5512 instance->map_update_cmd, 30); 5513 dcmd = &cmd->frame->dcmd; 5514 5515 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 5516 5517 dcmd->cmd = MFI_CMD_DCMD; 5518 dcmd->cmd_status = 0x0; 5519 dcmd->sge_count = 0; 5520 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE); 5521 dcmd->timeout = 0; 5522 dcmd->pad_0 = 0; 5523 dcmd->data_xfer_len = 0; 5524 dcmd->opcode = cpu_to_le32(opcode); 5525 5526 if (megasas_issue_blocked_cmd(instance, cmd, 30)) 5527 dev_err(&instance->pdev->dev, "Command timedout" 5528 "from %s\n", __func__); 5529 5530 megasas_return_cmd(instance, cmd); 5531 } 5532 5533 #ifdef CONFIG_PM 5534 /** 5535 * megasas_suspend - driver suspend entry point 5536 * @pdev: PCI device structure 5537 * @state: PCI power state to suspend routine 5538 */ 5539 static int 5540 megasas_suspend(struct pci_dev *pdev, pm_message_t state) 5541 { 5542 struct Scsi_Host *host; 5543 struct megasas_instance *instance; 5544 5545 instance = pci_get_drvdata(pdev); 5546 host = instance->host; 5547 instance->unload = 1; 5548 5549 /* Shutdown SR-IOV heartbeat timer */ 5550 if (instance->requestorId && !instance->skip_heartbeat_timer_del) 5551 del_timer_sync(&instance->sriov_heartbeat_timer); 5552 5553 megasas_flush_cache(instance); 5554 megasas_shutdown_controller(instance, MR_DCMD_HIBERNATE_SHUTDOWN); 5555 5556 /* cancel the delayed work if this work still in queue */ 5557 if (instance->ev != NULL) { 5558 struct megasas_aen_event *ev = instance->ev; 5559 cancel_delayed_work_sync(&ev->hotplug_work); 5560 instance->ev = NULL; 5561 } 5562 5563 tasklet_kill(&instance->isr_tasklet); 5564 5565 pci_set_drvdata(instance->pdev, instance); 5566 instance->instancet->disable_intr(instance); 5567 5568 megasas_destroy_irqs(instance); 5569 5570 if (instance->msix_vectors) 5571 pci_disable_msix(instance->pdev); 5572 5573 pci_save_state(pdev); 5574 pci_disable_device(pdev); 5575 5576 pci_set_power_state(pdev, pci_choose_state(pdev, state)); 5577 5578 return 0; 5579 } 5580 5581 /** 5582 * megasas_resume- driver resume entry point 5583 * @pdev: PCI device structure 5584 */ 5585 static int 5586 megasas_resume(struct pci_dev *pdev) 5587 { 5588 int rval; 5589 struct Scsi_Host *host; 5590 struct megasas_instance *instance; 5591 5592 instance = pci_get_drvdata(pdev); 5593 host = instance->host; 5594 pci_set_power_state(pdev, PCI_D0); 5595 pci_enable_wake(pdev, PCI_D0, 0); 5596 pci_restore_state(pdev); 5597 5598 /* 5599 * PCI prepping: enable device set bus mastering and dma mask 5600 */ 5601 rval = pci_enable_device_mem(pdev); 5602 5603 if (rval) { 5604 dev_err(&pdev->dev, "Enable device failed\n"); 5605 return rval; 5606 } 5607 5608 pci_set_master(pdev); 5609 5610 if (megasas_set_dma_mask(pdev)) 5611 goto fail_set_dma_mask; 5612 5613 /* 5614 * Initialize MFI Firmware 5615 */ 5616 5617 atomic_set(&instance->fw_outstanding, 0); 5618 5619 /* 5620 * We expect the FW state to be READY 5621 */ 5622 if (megasas_transition_to_ready(instance, 0)) 5623 goto fail_ready_state; 5624 5625 /* Now re-enable MSI-X */ 5626 if (instance->msix_vectors && 5627 pci_enable_msix_exact(instance->pdev, instance->msixentry, 5628 instance->msix_vectors)) 5629 goto fail_reenable_msix; 5630 5631 switch (instance->pdev->device) { 5632 case PCI_DEVICE_ID_LSI_FUSION: 5633 case PCI_DEVICE_ID_LSI_PLASMA: 5634 case PCI_DEVICE_ID_LSI_INVADER: 5635 case PCI_DEVICE_ID_LSI_FURY: 5636 { 5637 megasas_reset_reply_desc(instance); 5638 if (megasas_ioc_init_fusion(instance)) { 5639 megasas_free_cmds(instance); 5640 megasas_free_cmds_fusion(instance); 5641 goto fail_init_mfi; 5642 } 5643 if (!megasas_get_map_info(instance)) 5644 megasas_sync_map_info(instance); 5645 } 5646 break; 5647 default: 5648 *instance->producer = 0; 5649 *instance->consumer = 0; 5650 if (megasas_issue_init_mfi(instance)) 5651 goto fail_init_mfi; 5652 break; 5653 } 5654 5655 tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet, 5656 (unsigned long)instance); 5657 5658 if (instance->msix_vectors ? 5659 megasas_setup_irqs_msix(instance, 0) : 5660 megasas_setup_irqs_ioapic(instance)) 5661 goto fail_init_mfi; 5662 5663 /* Re-launch SR-IOV heartbeat timer */ 5664 if (instance->requestorId) { 5665 if (!megasas_sriov_start_heartbeat(instance, 0)) 5666 megasas_start_timer(instance, 5667 &instance->sriov_heartbeat_timer, 5668 megasas_sriov_heartbeat_handler, 5669 MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF); 5670 else { 5671 instance->skip_heartbeat_timer_del = 1; 5672 goto fail_init_mfi; 5673 } 5674 } 5675 5676 instance->instancet->enable_intr(instance); 5677 instance->unload = 0; 5678 5679 /* 5680 * Initiate AEN (Asynchronous Event Notification) 5681 */ 5682 if (megasas_start_aen(instance)) 5683 dev_err(&instance->pdev->dev, "Start AEN failed\n"); 5684 5685 return 0; 5686 5687 fail_init_mfi: 5688 if (instance->evt_detail) 5689 pci_free_consistent(pdev, sizeof(struct megasas_evt_detail), 5690 instance->evt_detail, 5691 instance->evt_detail_h); 5692 5693 if (instance->producer) 5694 pci_free_consistent(pdev, sizeof(u32), instance->producer, 5695 instance->producer_h); 5696 if (instance->consumer) 5697 pci_free_consistent(pdev, sizeof(u32), instance->consumer, 5698 instance->consumer_h); 5699 scsi_host_put(host); 5700 5701 fail_set_dma_mask: 5702 fail_ready_state: 5703 fail_reenable_msix: 5704 5705 pci_disable_device(pdev); 5706 5707 return -ENODEV; 5708 } 5709 #else 5710 #define megasas_suspend NULL 5711 #define megasas_resume NULL 5712 #endif 5713 5714 /** 5715 * megasas_detach_one - PCI hot"un"plug entry point 5716 * @pdev: PCI device structure 5717 */ 5718 static void megasas_detach_one(struct pci_dev *pdev) 5719 { 5720 int i; 5721 struct Scsi_Host *host; 5722 struct megasas_instance *instance; 5723 struct fusion_context *fusion; 5724 5725 instance = pci_get_drvdata(pdev); 5726 instance->unload = 1; 5727 host = instance->host; 5728 fusion = instance->ctrl_context; 5729 5730 /* Shutdown SR-IOV heartbeat timer */ 5731 if (instance->requestorId && !instance->skip_heartbeat_timer_del) 5732 del_timer_sync(&instance->sriov_heartbeat_timer); 5733 5734 if (instance->fw_crash_state != UNAVAILABLE) 5735 megasas_free_host_crash_buffer(instance); 5736 scsi_remove_host(instance->host); 5737 megasas_flush_cache(instance); 5738 megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN); 5739 5740 /* cancel the delayed work if this work still in queue*/ 5741 if (instance->ev != NULL) { 5742 struct megasas_aen_event *ev = instance->ev; 5743 cancel_delayed_work_sync(&ev->hotplug_work); 5744 instance->ev = NULL; 5745 } 5746 5747 /* cancel all wait events */ 5748 wake_up_all(&instance->int_cmd_wait_q); 5749 5750 tasklet_kill(&instance->isr_tasklet); 5751 5752 /* 5753 * Take the instance off the instance array. Note that we will not 5754 * decrement the max_index. We let this array be sparse array 5755 */ 5756 for (i = 0; i < megasas_mgmt_info.max_index; i++) { 5757 if (megasas_mgmt_info.instance[i] == instance) { 5758 megasas_mgmt_info.count--; 5759 megasas_mgmt_info.instance[i] = NULL; 5760 5761 break; 5762 } 5763 } 5764 5765 instance->instancet->disable_intr(instance); 5766 5767 megasas_destroy_irqs(instance); 5768 5769 if (instance->msix_vectors) 5770 pci_disable_msix(instance->pdev); 5771 5772 switch (instance->pdev->device) { 5773 case PCI_DEVICE_ID_LSI_FUSION: 5774 case PCI_DEVICE_ID_LSI_PLASMA: 5775 case PCI_DEVICE_ID_LSI_INVADER: 5776 case PCI_DEVICE_ID_LSI_FURY: 5777 megasas_release_fusion(instance); 5778 for (i = 0; i < 2 ; i++) { 5779 if (fusion->ld_map[i]) 5780 dma_free_coherent(&instance->pdev->dev, 5781 fusion->max_map_sz, 5782 fusion->ld_map[i], 5783 fusion->ld_map_phys[i]); 5784 if (fusion->ld_drv_map[i]) 5785 free_pages((ulong)fusion->ld_drv_map[i], 5786 fusion->drv_map_pages); 5787 } 5788 free_pages((ulong)instance->ctrl_context, 5789 instance->ctrl_context_pages); 5790 break; 5791 default: 5792 megasas_release_mfi(instance); 5793 pci_free_consistent(pdev, sizeof(u32), 5794 instance->producer, 5795 instance->producer_h); 5796 pci_free_consistent(pdev, sizeof(u32), 5797 instance->consumer, 5798 instance->consumer_h); 5799 break; 5800 } 5801 5802 kfree(instance->ctrl_info); 5803 5804 if (instance->evt_detail) 5805 pci_free_consistent(pdev, sizeof(struct megasas_evt_detail), 5806 instance->evt_detail, instance->evt_detail_h); 5807 5808 if (instance->vf_affiliation) 5809 pci_free_consistent(pdev, (MAX_LOGICAL_DRIVES + 1) * 5810 sizeof(struct MR_LD_VF_AFFILIATION), 5811 instance->vf_affiliation, 5812 instance->vf_affiliation_h); 5813 5814 if (instance->vf_affiliation_111) 5815 pci_free_consistent(pdev, 5816 sizeof(struct MR_LD_VF_AFFILIATION_111), 5817 instance->vf_affiliation_111, 5818 instance->vf_affiliation_111_h); 5819 5820 if (instance->hb_host_mem) 5821 pci_free_consistent(pdev, sizeof(struct MR_CTRL_HB_HOST_MEM), 5822 instance->hb_host_mem, 5823 instance->hb_host_mem_h); 5824 5825 if (instance->crash_dump_buf) 5826 pci_free_consistent(pdev, CRASH_DMA_BUF_SIZE, 5827 instance->crash_dump_buf, instance->crash_dump_h); 5828 5829 if (instance->system_info_buf) 5830 pci_free_consistent(pdev, sizeof(struct MR_DRV_SYSTEM_INFO), 5831 instance->system_info_buf, instance->system_info_h); 5832 5833 scsi_host_put(host); 5834 5835 pci_disable_device(pdev); 5836 } 5837 5838 /** 5839 * megasas_shutdown - Shutdown entry point 5840 * @device: Generic device structure 5841 */ 5842 static void megasas_shutdown(struct pci_dev *pdev) 5843 { 5844 struct megasas_instance *instance = pci_get_drvdata(pdev); 5845 5846 instance->unload = 1; 5847 megasas_flush_cache(instance); 5848 megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN); 5849 instance->instancet->disable_intr(instance); 5850 megasas_destroy_irqs(instance); 5851 5852 if (instance->msix_vectors) 5853 pci_disable_msix(instance->pdev); 5854 } 5855 5856 /** 5857 * megasas_mgmt_open - char node "open" entry point 5858 */ 5859 static int megasas_mgmt_open(struct inode *inode, struct file *filep) 5860 { 5861 /* 5862 * Allow only those users with admin rights 5863 */ 5864 if (!capable(CAP_SYS_ADMIN)) 5865 return -EACCES; 5866 5867 return 0; 5868 } 5869 5870 /** 5871 * megasas_mgmt_fasync - Async notifier registration from applications 5872 * 5873 * This function adds the calling process to a driver global queue. When an 5874 * event occurs, SIGIO will be sent to all processes in this queue. 5875 */ 5876 static int megasas_mgmt_fasync(int fd, struct file *filep, int mode) 5877 { 5878 int rc; 5879 5880 mutex_lock(&megasas_async_queue_mutex); 5881 5882 rc = fasync_helper(fd, filep, mode, &megasas_async_queue); 5883 5884 mutex_unlock(&megasas_async_queue_mutex); 5885 5886 if (rc >= 0) { 5887 /* For sanity check when we get ioctl */ 5888 filep->private_data = filep; 5889 return 0; 5890 } 5891 5892 printk(KERN_DEBUG "megasas: fasync_helper failed [%d]\n", rc); 5893 5894 return rc; 5895 } 5896 5897 /** 5898 * megasas_mgmt_poll - char node "poll" entry point 5899 * */ 5900 static unsigned int megasas_mgmt_poll(struct file *file, poll_table *wait) 5901 { 5902 unsigned int mask; 5903 unsigned long flags; 5904 5905 poll_wait(file, &megasas_poll_wait, wait); 5906 spin_lock_irqsave(&poll_aen_lock, flags); 5907 if (megasas_poll_wait_aen) 5908 mask = (POLLIN | POLLRDNORM); 5909 else 5910 mask = 0; 5911 megasas_poll_wait_aen = 0; 5912 spin_unlock_irqrestore(&poll_aen_lock, flags); 5913 return mask; 5914 } 5915 5916 /* 5917 * megasas_set_crash_dump_params_ioctl: 5918 * Send CRASH_DUMP_MODE DCMD to all controllers 5919 * @cmd: MFI command frame 5920 */ 5921 5922 static int megasas_set_crash_dump_params_ioctl(struct megasas_cmd *cmd) 5923 { 5924 struct megasas_instance *local_instance; 5925 int i, error = 0; 5926 int crash_support; 5927 5928 crash_support = cmd->frame->dcmd.mbox.w[0]; 5929 5930 for (i = 0; i < megasas_mgmt_info.max_index; i++) { 5931 local_instance = megasas_mgmt_info.instance[i]; 5932 if (local_instance && local_instance->crash_dump_drv_support) { 5933 if ((local_instance->adprecovery == 5934 MEGASAS_HBA_OPERATIONAL) && 5935 !megasas_set_crash_dump_params(local_instance, 5936 crash_support)) { 5937 local_instance->crash_dump_app_support = 5938 crash_support; 5939 dev_info(&local_instance->pdev->dev, 5940 "Application firmware crash " 5941 "dump mode set success\n"); 5942 error = 0; 5943 } else { 5944 dev_info(&local_instance->pdev->dev, 5945 "Application firmware crash " 5946 "dump mode set failed\n"); 5947 error = -1; 5948 } 5949 } 5950 } 5951 return error; 5952 } 5953 5954 /** 5955 * megasas_mgmt_fw_ioctl - Issues management ioctls to FW 5956 * @instance: Adapter soft state 5957 * @argp: User's ioctl packet 5958 */ 5959 static int 5960 megasas_mgmt_fw_ioctl(struct megasas_instance *instance, 5961 struct megasas_iocpacket __user * user_ioc, 5962 struct megasas_iocpacket *ioc) 5963 { 5964 struct megasas_sge32 *kern_sge32; 5965 struct megasas_cmd *cmd; 5966 void *kbuff_arr[MAX_IOCTL_SGE]; 5967 dma_addr_t buf_handle = 0; 5968 int error = 0, i; 5969 void *sense = NULL; 5970 dma_addr_t sense_handle; 5971 unsigned long *sense_ptr; 5972 5973 memset(kbuff_arr, 0, sizeof(kbuff_arr)); 5974 5975 if (ioc->sge_count > MAX_IOCTL_SGE) { 5976 dev_printk(KERN_DEBUG, &instance->pdev->dev, "SGE count [%d] > max limit [%d]\n", 5977 ioc->sge_count, MAX_IOCTL_SGE); 5978 return -EINVAL; 5979 } 5980 5981 cmd = megasas_get_cmd(instance); 5982 if (!cmd) { 5983 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get a cmd packet\n"); 5984 return -ENOMEM; 5985 } 5986 5987 /* 5988 * User's IOCTL packet has 2 frames (maximum). Copy those two 5989 * frames into our cmd's frames. cmd->frame's context will get 5990 * overwritten when we copy from user's frames. So set that value 5991 * alone separately 5992 */ 5993 memcpy(cmd->frame, ioc->frame.raw, 2 * MEGAMFI_FRAME_SIZE); 5994 cmd->frame->hdr.context = cpu_to_le32(cmd->index); 5995 cmd->frame->hdr.pad_0 = 0; 5996 cmd->frame->hdr.flags &= cpu_to_le16(~(MFI_FRAME_IEEE | 5997 MFI_FRAME_SGL64 | 5998 MFI_FRAME_SENSE64)); 5999 6000 if (cmd->frame->dcmd.opcode == MR_DRIVER_SET_APP_CRASHDUMP_MODE) { 6001 error = megasas_set_crash_dump_params_ioctl(cmd); 6002 megasas_return_cmd(instance, cmd); 6003 return error; 6004 } 6005 6006 /* 6007 * The management interface between applications and the fw uses 6008 * MFI frames. E.g, RAID configuration changes, LD property changes 6009 * etc are accomplishes through different kinds of MFI frames. The 6010 * driver needs to care only about substituting user buffers with 6011 * kernel buffers in SGLs. The location of SGL is embedded in the 6012 * struct iocpacket itself. 6013 */ 6014 kern_sge32 = (struct megasas_sge32 *) 6015 ((unsigned long)cmd->frame + ioc->sgl_off); 6016 6017 /* 6018 * For each user buffer, create a mirror buffer and copy in 6019 */ 6020 for (i = 0; i < ioc->sge_count; i++) { 6021 if (!ioc->sgl[i].iov_len) 6022 continue; 6023 6024 kbuff_arr[i] = dma_alloc_coherent(&instance->pdev->dev, 6025 ioc->sgl[i].iov_len, 6026 &buf_handle, GFP_KERNEL); 6027 if (!kbuff_arr[i]) { 6028 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc " 6029 "kernel SGL buffer for IOCTL\n"); 6030 error = -ENOMEM; 6031 goto out; 6032 } 6033 6034 /* 6035 * We don't change the dma_coherent_mask, so 6036 * pci_alloc_consistent only returns 32bit addresses 6037 */ 6038 kern_sge32[i].phys_addr = cpu_to_le32(buf_handle); 6039 kern_sge32[i].length = cpu_to_le32(ioc->sgl[i].iov_len); 6040 6041 /* 6042 * We created a kernel buffer corresponding to the 6043 * user buffer. Now copy in from the user buffer 6044 */ 6045 if (copy_from_user(kbuff_arr[i], ioc->sgl[i].iov_base, 6046 (u32) (ioc->sgl[i].iov_len))) { 6047 error = -EFAULT; 6048 goto out; 6049 } 6050 } 6051 6052 if (ioc->sense_len) { 6053 sense = dma_alloc_coherent(&instance->pdev->dev, ioc->sense_len, 6054 &sense_handle, GFP_KERNEL); 6055 if (!sense) { 6056 error = -ENOMEM; 6057 goto out; 6058 } 6059 6060 sense_ptr = 6061 (unsigned long *) ((unsigned long)cmd->frame + ioc->sense_off); 6062 *sense_ptr = cpu_to_le32(sense_handle); 6063 } 6064 6065 /* 6066 * Set the sync_cmd flag so that the ISR knows not to complete this 6067 * cmd to the SCSI mid-layer 6068 */ 6069 cmd->sync_cmd = 1; 6070 megasas_issue_blocked_cmd(instance, cmd, 0); 6071 cmd->sync_cmd = 0; 6072 6073 if (instance->unload == 1) { 6074 dev_info(&instance->pdev->dev, "Driver unload is in progress " 6075 "don't submit data to application\n"); 6076 goto out; 6077 } 6078 /* 6079 * copy out the kernel buffers to user buffers 6080 */ 6081 for (i = 0; i < ioc->sge_count; i++) { 6082 if (copy_to_user(ioc->sgl[i].iov_base, kbuff_arr[i], 6083 ioc->sgl[i].iov_len)) { 6084 error = -EFAULT; 6085 goto out; 6086 } 6087 } 6088 6089 /* 6090 * copy out the sense 6091 */ 6092 if (ioc->sense_len) { 6093 /* 6094 * sense_ptr points to the location that has the user 6095 * sense buffer address 6096 */ 6097 sense_ptr = (unsigned long *) ((unsigned long)ioc->frame.raw + 6098 ioc->sense_off); 6099 6100 if (copy_to_user((void __user *)((unsigned long)(*sense_ptr)), 6101 sense, ioc->sense_len)) { 6102 dev_err(&instance->pdev->dev, "Failed to copy out to user " 6103 "sense data\n"); 6104 error = -EFAULT; 6105 goto out; 6106 } 6107 } 6108 6109 /* 6110 * copy the status codes returned by the fw 6111 */ 6112 if (copy_to_user(&user_ioc->frame.hdr.cmd_status, 6113 &cmd->frame->hdr.cmd_status, sizeof(u8))) { 6114 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Error copying out cmd_status\n"); 6115 error = -EFAULT; 6116 } 6117 6118 out: 6119 if (sense) { 6120 dma_free_coherent(&instance->pdev->dev, ioc->sense_len, 6121 sense, sense_handle); 6122 } 6123 6124 for (i = 0; i < ioc->sge_count; i++) { 6125 if (kbuff_arr[i]) 6126 dma_free_coherent(&instance->pdev->dev, 6127 le32_to_cpu(kern_sge32[i].length), 6128 kbuff_arr[i], 6129 le32_to_cpu(kern_sge32[i].phys_addr)); 6130 kbuff_arr[i] = NULL; 6131 } 6132 6133 megasas_return_cmd(instance, cmd); 6134 return error; 6135 } 6136 6137 static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg) 6138 { 6139 struct megasas_iocpacket __user *user_ioc = 6140 (struct megasas_iocpacket __user *)arg; 6141 struct megasas_iocpacket *ioc; 6142 struct megasas_instance *instance; 6143 int error; 6144 int i; 6145 unsigned long flags; 6146 u32 wait_time = MEGASAS_RESET_WAIT_TIME; 6147 6148 ioc = kmalloc(sizeof(*ioc), GFP_KERNEL); 6149 if (!ioc) 6150 return -ENOMEM; 6151 6152 if (copy_from_user(ioc, user_ioc, sizeof(*ioc))) { 6153 error = -EFAULT; 6154 goto out_kfree_ioc; 6155 } 6156 6157 instance = megasas_lookup_instance(ioc->host_no); 6158 if (!instance) { 6159 error = -ENODEV; 6160 goto out_kfree_ioc; 6161 } 6162 6163 /* Adjust ioctl wait time for VF mode */ 6164 if (instance->requestorId) 6165 wait_time = MEGASAS_ROUTINE_WAIT_TIME_VF; 6166 6167 /* Block ioctls in VF mode */ 6168 if (instance->requestorId && !allow_vf_ioctls) { 6169 error = -ENODEV; 6170 goto out_kfree_ioc; 6171 } 6172 6173 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) { 6174 dev_err(&instance->pdev->dev, "Controller in crit error\n"); 6175 error = -ENODEV; 6176 goto out_kfree_ioc; 6177 } 6178 6179 if (instance->unload == 1) { 6180 error = -ENODEV; 6181 goto out_kfree_ioc; 6182 } 6183 6184 if (down_interruptible(&instance->ioctl_sem)) { 6185 error = -ERESTARTSYS; 6186 goto out_kfree_ioc; 6187 } 6188 6189 for (i = 0; i < wait_time; i++) { 6190 6191 spin_lock_irqsave(&instance->hba_lock, flags); 6192 if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) { 6193 spin_unlock_irqrestore(&instance->hba_lock, flags); 6194 break; 6195 } 6196 spin_unlock_irqrestore(&instance->hba_lock, flags); 6197 6198 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) { 6199 dev_notice(&instance->pdev->dev, "waiting" 6200 "for controller reset to finish\n"); 6201 } 6202 6203 msleep(1000); 6204 } 6205 6206 spin_lock_irqsave(&instance->hba_lock, flags); 6207 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) { 6208 spin_unlock_irqrestore(&instance->hba_lock, flags); 6209 6210 dev_err(&instance->pdev->dev, "timed out while" 6211 "waiting for HBA to recover\n"); 6212 error = -ENODEV; 6213 goto out_up; 6214 } 6215 spin_unlock_irqrestore(&instance->hba_lock, flags); 6216 6217 error = megasas_mgmt_fw_ioctl(instance, user_ioc, ioc); 6218 out_up: 6219 up(&instance->ioctl_sem); 6220 6221 out_kfree_ioc: 6222 kfree(ioc); 6223 return error; 6224 } 6225 6226 static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg) 6227 { 6228 struct megasas_instance *instance; 6229 struct megasas_aen aen; 6230 int error; 6231 int i; 6232 unsigned long flags; 6233 u32 wait_time = MEGASAS_RESET_WAIT_TIME; 6234 6235 if (file->private_data != file) { 6236 printk(KERN_DEBUG "megasas: fasync_helper was not " 6237 "called first\n"); 6238 return -EINVAL; 6239 } 6240 6241 if (copy_from_user(&aen, (void __user *)arg, sizeof(aen))) 6242 return -EFAULT; 6243 6244 instance = megasas_lookup_instance(aen.host_no); 6245 6246 if (!instance) 6247 return -ENODEV; 6248 6249 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) { 6250 return -ENODEV; 6251 } 6252 6253 if (instance->unload == 1) { 6254 return -ENODEV; 6255 } 6256 6257 for (i = 0; i < wait_time; i++) { 6258 6259 spin_lock_irqsave(&instance->hba_lock, flags); 6260 if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) { 6261 spin_unlock_irqrestore(&instance->hba_lock, 6262 flags); 6263 break; 6264 } 6265 6266 spin_unlock_irqrestore(&instance->hba_lock, flags); 6267 6268 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) { 6269 dev_notice(&instance->pdev->dev, "waiting for" 6270 "controller reset to finish\n"); 6271 } 6272 6273 msleep(1000); 6274 } 6275 6276 spin_lock_irqsave(&instance->hba_lock, flags); 6277 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) { 6278 spin_unlock_irqrestore(&instance->hba_lock, flags); 6279 dev_err(&instance->pdev->dev, "timed out while waiting" 6280 "for HBA to recover\n"); 6281 return -ENODEV; 6282 } 6283 spin_unlock_irqrestore(&instance->hba_lock, flags); 6284 6285 mutex_lock(&instance->aen_mutex); 6286 error = megasas_register_aen(instance, aen.seq_num, 6287 aen.class_locale_word); 6288 mutex_unlock(&instance->aen_mutex); 6289 return error; 6290 } 6291 6292 /** 6293 * megasas_mgmt_ioctl - char node ioctl entry point 6294 */ 6295 static long 6296 megasas_mgmt_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 6297 { 6298 switch (cmd) { 6299 case MEGASAS_IOC_FIRMWARE: 6300 return megasas_mgmt_ioctl_fw(file, arg); 6301 6302 case MEGASAS_IOC_GET_AEN: 6303 return megasas_mgmt_ioctl_aen(file, arg); 6304 } 6305 6306 return -ENOTTY; 6307 } 6308 6309 #ifdef CONFIG_COMPAT 6310 static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg) 6311 { 6312 struct compat_megasas_iocpacket __user *cioc = 6313 (struct compat_megasas_iocpacket __user *)arg; 6314 struct megasas_iocpacket __user *ioc = 6315 compat_alloc_user_space(sizeof(struct megasas_iocpacket)); 6316 int i; 6317 int error = 0; 6318 compat_uptr_t ptr; 6319 6320 if (clear_user(ioc, sizeof(*ioc))) 6321 return -EFAULT; 6322 6323 if (copy_in_user(&ioc->host_no, &cioc->host_no, sizeof(u16)) || 6324 copy_in_user(&ioc->sgl_off, &cioc->sgl_off, sizeof(u32)) || 6325 copy_in_user(&ioc->sense_off, &cioc->sense_off, sizeof(u32)) || 6326 copy_in_user(&ioc->sense_len, &cioc->sense_len, sizeof(u32)) || 6327 copy_in_user(ioc->frame.raw, cioc->frame.raw, 128) || 6328 copy_in_user(&ioc->sge_count, &cioc->sge_count, sizeof(u32))) 6329 return -EFAULT; 6330 6331 /* 6332 * The sense_ptr is used in megasas_mgmt_fw_ioctl only when 6333 * sense_len is not null, so prepare the 64bit value under 6334 * the same condition. 6335 */ 6336 if (ioc->sense_len) { 6337 void __user **sense_ioc_ptr = 6338 (void __user **)(ioc->frame.raw + ioc->sense_off); 6339 compat_uptr_t *sense_cioc_ptr = 6340 (compat_uptr_t *)(cioc->frame.raw + cioc->sense_off); 6341 if (get_user(ptr, sense_cioc_ptr) || 6342 put_user(compat_ptr(ptr), sense_ioc_ptr)) 6343 return -EFAULT; 6344 } 6345 6346 for (i = 0; i < MAX_IOCTL_SGE; i++) { 6347 if (get_user(ptr, &cioc->sgl[i].iov_base) || 6348 put_user(compat_ptr(ptr), &ioc->sgl[i].iov_base) || 6349 copy_in_user(&ioc->sgl[i].iov_len, 6350 &cioc->sgl[i].iov_len, sizeof(compat_size_t))) 6351 return -EFAULT; 6352 } 6353 6354 error = megasas_mgmt_ioctl_fw(file, (unsigned long)ioc); 6355 6356 if (copy_in_user(&cioc->frame.hdr.cmd_status, 6357 &ioc->frame.hdr.cmd_status, sizeof(u8))) { 6358 printk(KERN_DEBUG "megasas: error copy_in_user cmd_status\n"); 6359 return -EFAULT; 6360 } 6361 return error; 6362 } 6363 6364 static long 6365 megasas_mgmt_compat_ioctl(struct file *file, unsigned int cmd, 6366 unsigned long arg) 6367 { 6368 switch (cmd) { 6369 case MEGASAS_IOC_FIRMWARE32: 6370 return megasas_mgmt_compat_ioctl_fw(file, arg); 6371 case MEGASAS_IOC_GET_AEN: 6372 return megasas_mgmt_ioctl_aen(file, arg); 6373 } 6374 6375 return -ENOTTY; 6376 } 6377 #endif 6378 6379 /* 6380 * File operations structure for management interface 6381 */ 6382 static const struct file_operations megasas_mgmt_fops = { 6383 .owner = THIS_MODULE, 6384 .open = megasas_mgmt_open, 6385 .fasync = megasas_mgmt_fasync, 6386 .unlocked_ioctl = megasas_mgmt_ioctl, 6387 .poll = megasas_mgmt_poll, 6388 #ifdef CONFIG_COMPAT 6389 .compat_ioctl = megasas_mgmt_compat_ioctl, 6390 #endif 6391 .llseek = noop_llseek, 6392 }; 6393 6394 /* 6395 * PCI hotplug support registration structure 6396 */ 6397 static struct pci_driver megasas_pci_driver = { 6398 6399 .name = "megaraid_sas", 6400 .id_table = megasas_pci_table, 6401 .probe = megasas_probe_one, 6402 .remove = megasas_detach_one, 6403 .suspend = megasas_suspend, 6404 .resume = megasas_resume, 6405 .shutdown = megasas_shutdown, 6406 }; 6407 6408 /* 6409 * Sysfs driver attributes 6410 */ 6411 static ssize_t megasas_sysfs_show_version(struct device_driver *dd, char *buf) 6412 { 6413 return snprintf(buf, strlen(MEGASAS_VERSION) + 2, "%s\n", 6414 MEGASAS_VERSION); 6415 } 6416 6417 static DRIVER_ATTR(version, S_IRUGO, megasas_sysfs_show_version, NULL); 6418 6419 static ssize_t 6420 megasas_sysfs_show_release_date(struct device_driver *dd, char *buf) 6421 { 6422 return snprintf(buf, strlen(MEGASAS_RELDATE) + 2, "%s\n", 6423 MEGASAS_RELDATE); 6424 } 6425 6426 static DRIVER_ATTR(release_date, S_IRUGO, megasas_sysfs_show_release_date, NULL); 6427 6428 static ssize_t 6429 megasas_sysfs_show_support_poll_for_event(struct device_driver *dd, char *buf) 6430 { 6431 return sprintf(buf, "%u\n", support_poll_for_event); 6432 } 6433 6434 static DRIVER_ATTR(support_poll_for_event, S_IRUGO, 6435 megasas_sysfs_show_support_poll_for_event, NULL); 6436 6437 static ssize_t 6438 megasas_sysfs_show_support_device_change(struct device_driver *dd, char *buf) 6439 { 6440 return sprintf(buf, "%u\n", support_device_change); 6441 } 6442 6443 static DRIVER_ATTR(support_device_change, S_IRUGO, 6444 megasas_sysfs_show_support_device_change, NULL); 6445 6446 static ssize_t 6447 megasas_sysfs_show_dbg_lvl(struct device_driver *dd, char *buf) 6448 { 6449 return sprintf(buf, "%u\n", megasas_dbg_lvl); 6450 } 6451 6452 static ssize_t 6453 megasas_sysfs_set_dbg_lvl(struct device_driver *dd, const char *buf, size_t count) 6454 { 6455 int retval = count; 6456 6457 if (sscanf(buf, "%u", &megasas_dbg_lvl) < 1) { 6458 printk(KERN_ERR "megasas: could not set dbg_lvl\n"); 6459 retval = -EINVAL; 6460 } 6461 return retval; 6462 } 6463 6464 static DRIVER_ATTR(dbg_lvl, S_IRUGO|S_IWUSR, megasas_sysfs_show_dbg_lvl, 6465 megasas_sysfs_set_dbg_lvl); 6466 6467 static void 6468 megasas_aen_polling(struct work_struct *work) 6469 { 6470 struct megasas_aen_event *ev = 6471 container_of(work, struct megasas_aen_event, hotplug_work.work); 6472 struct megasas_instance *instance = ev->instance; 6473 union megasas_evt_class_locale class_locale; 6474 struct Scsi_Host *host; 6475 struct scsi_device *sdev1; 6476 u16 pd_index = 0; 6477 u16 ld_index = 0; 6478 int i, j, doscan = 0; 6479 u32 seq_num, wait_time = MEGASAS_RESET_WAIT_TIME; 6480 int error; 6481 6482 if (!instance) { 6483 printk(KERN_ERR "invalid instance!\n"); 6484 kfree(ev); 6485 return; 6486 } 6487 6488 /* Adjust event workqueue thread wait time for VF mode */ 6489 if (instance->requestorId) 6490 wait_time = MEGASAS_ROUTINE_WAIT_TIME_VF; 6491 6492 /* Don't run the event workqueue thread if OCR is running */ 6493 for (i = 0; i < wait_time; i++) { 6494 if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) 6495 break; 6496 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) { 6497 dev_notice(&instance->pdev->dev, "%s waiting for " 6498 "controller reset to finish for scsi%d\n", 6499 __func__, instance->host->host_no); 6500 } 6501 msleep(1000); 6502 } 6503 6504 instance->ev = NULL; 6505 host = instance->host; 6506 if (instance->evt_detail) { 6507 6508 switch (le32_to_cpu(instance->evt_detail->code)) { 6509 case MR_EVT_PD_INSERTED: 6510 if (megasas_get_pd_list(instance) == 0) { 6511 for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) { 6512 for (j = 0; 6513 j < MEGASAS_MAX_DEV_PER_CHANNEL; 6514 j++) { 6515 6516 pd_index = 6517 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j; 6518 6519 sdev1 = scsi_device_lookup(host, i, j, 0); 6520 6521 if (instance->pd_list[pd_index].driveState 6522 == MR_PD_STATE_SYSTEM) { 6523 if (!sdev1) 6524 scsi_add_device(host, i, j, 0); 6525 6526 if (sdev1) 6527 scsi_device_put(sdev1); 6528 } 6529 } 6530 } 6531 } 6532 doscan = 0; 6533 break; 6534 6535 case MR_EVT_PD_REMOVED: 6536 if (megasas_get_pd_list(instance) == 0) { 6537 for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) { 6538 for (j = 0; 6539 j < MEGASAS_MAX_DEV_PER_CHANNEL; 6540 j++) { 6541 6542 pd_index = 6543 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j; 6544 6545 sdev1 = scsi_device_lookup(host, i, j, 0); 6546 6547 if (instance->pd_list[pd_index].driveState 6548 == MR_PD_STATE_SYSTEM) { 6549 if (sdev1) 6550 scsi_device_put(sdev1); 6551 } else { 6552 if (sdev1) { 6553 scsi_remove_device(sdev1); 6554 scsi_device_put(sdev1); 6555 } 6556 } 6557 } 6558 } 6559 } 6560 doscan = 0; 6561 break; 6562 6563 case MR_EVT_LD_OFFLINE: 6564 case MR_EVT_CFG_CLEARED: 6565 case MR_EVT_LD_DELETED: 6566 if (!instance->requestorId || 6567 (instance->requestorId && 6568 megasas_get_ld_vf_affiliation(instance, 0))) { 6569 if (megasas_ld_list_query(instance, 6570 MR_LD_QUERY_TYPE_EXPOSED_TO_HOST)) 6571 megasas_get_ld_list(instance); 6572 for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) { 6573 for (j = 0; 6574 j < MEGASAS_MAX_DEV_PER_CHANNEL; 6575 j++) { 6576 6577 ld_index = 6578 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j; 6579 6580 sdev1 = scsi_device_lookup(host, MEGASAS_MAX_PD_CHANNELS + i, j, 0); 6581 6582 if (instance->ld_ids[ld_index] 6583 != 0xff) { 6584 if (sdev1) 6585 scsi_device_put(sdev1); 6586 } else { 6587 if (sdev1) { 6588 scsi_remove_device(sdev1); 6589 scsi_device_put(sdev1); 6590 } 6591 } 6592 } 6593 } 6594 doscan = 0; 6595 } 6596 break; 6597 case MR_EVT_LD_CREATED: 6598 if (!instance->requestorId || 6599 (instance->requestorId && 6600 megasas_get_ld_vf_affiliation(instance, 0))) { 6601 if (megasas_ld_list_query(instance, 6602 MR_LD_QUERY_TYPE_EXPOSED_TO_HOST)) 6603 megasas_get_ld_list(instance); 6604 for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) { 6605 for (j = 0; 6606 j < MEGASAS_MAX_DEV_PER_CHANNEL; 6607 j++) { 6608 ld_index = 6609 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j; 6610 6611 sdev1 = scsi_device_lookup(host, MEGASAS_MAX_PD_CHANNELS + i, j, 0); 6612 6613 if (instance->ld_ids[ld_index] 6614 != 0xff) { 6615 if (!sdev1) 6616 scsi_add_device(host, MEGASAS_MAX_PD_CHANNELS + i, j, 0); 6617 } 6618 if (sdev1) 6619 scsi_device_put(sdev1); 6620 } 6621 } 6622 doscan = 0; 6623 } 6624 break; 6625 case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED: 6626 case MR_EVT_FOREIGN_CFG_IMPORTED: 6627 case MR_EVT_LD_STATE_CHANGE: 6628 doscan = 1; 6629 break; 6630 default: 6631 doscan = 0; 6632 break; 6633 } 6634 } else { 6635 dev_err(&instance->pdev->dev, "invalid evt_detail!\n"); 6636 kfree(ev); 6637 return; 6638 } 6639 6640 if (doscan) { 6641 dev_info(&instance->pdev->dev, "scanning for scsi%d...\n", 6642 instance->host->host_no); 6643 if (megasas_get_pd_list(instance) == 0) { 6644 for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) { 6645 for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) { 6646 pd_index = i*MEGASAS_MAX_DEV_PER_CHANNEL + j; 6647 sdev1 = scsi_device_lookup(host, i, j, 0); 6648 if (instance->pd_list[pd_index].driveState == 6649 MR_PD_STATE_SYSTEM) { 6650 if (!sdev1) { 6651 scsi_add_device(host, i, j, 0); 6652 } 6653 if (sdev1) 6654 scsi_device_put(sdev1); 6655 } else { 6656 if (sdev1) { 6657 scsi_remove_device(sdev1); 6658 scsi_device_put(sdev1); 6659 } 6660 } 6661 } 6662 } 6663 } 6664 6665 if (!instance->requestorId || 6666 (instance->requestorId && 6667 megasas_get_ld_vf_affiliation(instance, 0))) { 6668 if (megasas_ld_list_query(instance, 6669 MR_LD_QUERY_TYPE_EXPOSED_TO_HOST)) 6670 megasas_get_ld_list(instance); 6671 for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) { 6672 for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; 6673 j++) { 6674 ld_index = 6675 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j; 6676 6677 sdev1 = scsi_device_lookup(host, 6678 MEGASAS_MAX_PD_CHANNELS + i, j, 0); 6679 if (instance->ld_ids[ld_index] 6680 != 0xff) { 6681 if (!sdev1) 6682 scsi_add_device(host, MEGASAS_MAX_PD_CHANNELS + i, j, 0); 6683 else 6684 scsi_device_put(sdev1); 6685 } else { 6686 if (sdev1) { 6687 scsi_remove_device(sdev1); 6688 scsi_device_put(sdev1); 6689 } 6690 } 6691 } 6692 } 6693 } 6694 } 6695 6696 if (instance->aen_cmd != NULL) { 6697 kfree(ev); 6698 return ; 6699 } 6700 6701 seq_num = le32_to_cpu(instance->evt_detail->seq_num) + 1; 6702 6703 /* Register AEN with FW for latest sequence number plus 1 */ 6704 class_locale.members.reserved = 0; 6705 class_locale.members.locale = MR_EVT_LOCALE_ALL; 6706 class_locale.members.class = MR_EVT_CLASS_DEBUG; 6707 mutex_lock(&instance->aen_mutex); 6708 error = megasas_register_aen(instance, seq_num, 6709 class_locale.word); 6710 mutex_unlock(&instance->aen_mutex); 6711 6712 if (error) 6713 dev_err(&instance->pdev->dev, "register aen failed error %x\n", error); 6714 6715 kfree(ev); 6716 } 6717 6718 /** 6719 * megasas_init - Driver load entry point 6720 */ 6721 static int __init megasas_init(void) 6722 { 6723 int rval; 6724 6725 /* 6726 * Announce driver version and other information 6727 */ 6728 pr_info("megasas: %s\n", MEGASAS_VERSION); 6729 6730 spin_lock_init(&poll_aen_lock); 6731 6732 support_poll_for_event = 2; 6733 support_device_change = 1; 6734 6735 memset(&megasas_mgmt_info, 0, sizeof(megasas_mgmt_info)); 6736 6737 /* 6738 * Register character device node 6739 */ 6740 rval = register_chrdev(0, "megaraid_sas_ioctl", &megasas_mgmt_fops); 6741 6742 if (rval < 0) { 6743 printk(KERN_DEBUG "megasas: failed to open device node\n"); 6744 return rval; 6745 } 6746 6747 megasas_mgmt_majorno = rval; 6748 6749 /* 6750 * Register ourselves as PCI hotplug module 6751 */ 6752 rval = pci_register_driver(&megasas_pci_driver); 6753 6754 if (rval) { 6755 printk(KERN_DEBUG "megasas: PCI hotplug registration failed \n"); 6756 goto err_pcidrv; 6757 } 6758 6759 rval = driver_create_file(&megasas_pci_driver.driver, 6760 &driver_attr_version); 6761 if (rval) 6762 goto err_dcf_attr_ver; 6763 6764 rval = driver_create_file(&megasas_pci_driver.driver, 6765 &driver_attr_release_date); 6766 if (rval) 6767 goto err_dcf_rel_date; 6768 6769 rval = driver_create_file(&megasas_pci_driver.driver, 6770 &driver_attr_support_poll_for_event); 6771 if (rval) 6772 goto err_dcf_support_poll_for_event; 6773 6774 rval = driver_create_file(&megasas_pci_driver.driver, 6775 &driver_attr_dbg_lvl); 6776 if (rval) 6777 goto err_dcf_dbg_lvl; 6778 rval = driver_create_file(&megasas_pci_driver.driver, 6779 &driver_attr_support_device_change); 6780 if (rval) 6781 goto err_dcf_support_device_change; 6782 6783 return rval; 6784 6785 err_dcf_support_device_change: 6786 driver_remove_file(&megasas_pci_driver.driver, 6787 &driver_attr_dbg_lvl); 6788 err_dcf_dbg_lvl: 6789 driver_remove_file(&megasas_pci_driver.driver, 6790 &driver_attr_support_poll_for_event); 6791 err_dcf_support_poll_for_event: 6792 driver_remove_file(&megasas_pci_driver.driver, 6793 &driver_attr_release_date); 6794 err_dcf_rel_date: 6795 driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version); 6796 err_dcf_attr_ver: 6797 pci_unregister_driver(&megasas_pci_driver); 6798 err_pcidrv: 6799 unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl"); 6800 return rval; 6801 } 6802 6803 /** 6804 * megasas_exit - Driver unload entry point 6805 */ 6806 static void __exit megasas_exit(void) 6807 { 6808 driver_remove_file(&megasas_pci_driver.driver, 6809 &driver_attr_dbg_lvl); 6810 driver_remove_file(&megasas_pci_driver.driver, 6811 &driver_attr_support_poll_for_event); 6812 driver_remove_file(&megasas_pci_driver.driver, 6813 &driver_attr_support_device_change); 6814 driver_remove_file(&megasas_pci_driver.driver, 6815 &driver_attr_release_date); 6816 driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version); 6817 6818 pci_unregister_driver(&megasas_pci_driver); 6819 unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl"); 6820 } 6821 6822 module_init(megasas_init); 6823 module_exit(megasas_exit); 6824