1 /* 2 * Linux MegaRAID driver for SAS based RAID controllers 3 * 4 * Copyright (c) 2009-2011 LSI Corporation. 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 2 9 * of the License, or (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 * 20 * FILE: megaraid_sas_base.c 21 * Version : v00.00.05.29-rc1 22 * 23 * Authors: LSI Corporation 24 * Sreenivas Bagalkote 25 * Sumant Patro 26 * Bo Yang 27 * 28 * Send feedback to: <megaraidlinux@lsi.com> 29 * 30 * Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035 31 * ATTN: Linuxraid 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 "megaraid_sas_fusion.h" 57 #include "megaraid_sas.h" 58 59 /* 60 * poll_mode_io:1- schedule complete completion from q cmd 61 */ 62 static unsigned int poll_mode_io; 63 module_param_named(poll_mode_io, poll_mode_io, int, 0); 64 MODULE_PARM_DESC(poll_mode_io, 65 "Complete cmds from IO path, (default=0)"); 66 67 /* 68 * Number of sectors per IO command 69 * Will be set in megasas_init_mfi if user does not provide 70 */ 71 static unsigned int max_sectors; 72 module_param_named(max_sectors, max_sectors, int, 0); 73 MODULE_PARM_DESC(max_sectors, 74 "Maximum number of sectors per IO command"); 75 76 static int msix_disable; 77 module_param(msix_disable, int, S_IRUGO); 78 MODULE_PARM_DESC(msix_disable, "Disable MSI-X interrupt handling. Default: 0"); 79 80 MODULE_LICENSE("GPL"); 81 MODULE_VERSION(MEGASAS_VERSION); 82 MODULE_AUTHOR("megaraidlinux@lsi.com"); 83 MODULE_DESCRIPTION("LSI MegaRAID SAS Driver"); 84 85 int megasas_transition_to_ready(struct megasas_instance *instance); 86 static int megasas_get_pd_list(struct megasas_instance *instance); 87 static int megasas_issue_init_mfi(struct megasas_instance *instance); 88 static int megasas_register_aen(struct megasas_instance *instance, 89 u32 seq_num, u32 class_locale_word); 90 /* 91 * PCI ID table for all supported controllers 92 */ 93 static struct pci_device_id megasas_pci_table[] = { 94 95 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064R)}, 96 /* xscale IOP */ 97 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078R)}, 98 /* ppc IOP */ 99 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078DE)}, 100 /* ppc IOP */ 101 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078GEN2)}, 102 /* gen2*/ 103 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0079GEN2)}, 104 /* gen2*/ 105 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0073SKINNY)}, 106 /* skinny*/ 107 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0071SKINNY)}, 108 /* skinny*/ 109 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VERDE_ZCR)}, 110 /* xscale IOP, vega */ 111 {PCI_DEVICE(PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_PERC5)}, 112 /* xscale IOP */ 113 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FUSION)}, 114 /* Fusion */ 115 {} 116 }; 117 118 MODULE_DEVICE_TABLE(pci, megasas_pci_table); 119 120 static int megasas_mgmt_majorno; 121 static struct megasas_mgmt_info megasas_mgmt_info; 122 static struct fasync_struct *megasas_async_queue; 123 static DEFINE_MUTEX(megasas_async_queue_mutex); 124 125 static int megasas_poll_wait_aen; 126 static DECLARE_WAIT_QUEUE_HEAD(megasas_poll_wait); 127 static u32 support_poll_for_event; 128 u32 megasas_dbg_lvl; 129 static u32 support_device_change; 130 131 /* define lock for aen poll */ 132 spinlock_t poll_aen_lock; 133 134 void 135 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd, 136 u8 alt_status); 137 138 static irqreturn_t megasas_isr(int irq, void *devp); 139 static u32 140 megasas_init_adapter_mfi(struct megasas_instance *instance); 141 u32 142 megasas_build_and_issue_cmd(struct megasas_instance *instance, 143 struct scsi_cmnd *scmd); 144 static void megasas_complete_cmd_dpc(unsigned long instance_addr); 145 void 146 megasas_release_fusion(struct megasas_instance *instance); 147 int 148 megasas_ioc_init_fusion(struct megasas_instance *instance); 149 void 150 megasas_free_cmds_fusion(struct megasas_instance *instance); 151 u8 152 megasas_get_map_info(struct megasas_instance *instance); 153 int 154 megasas_sync_map_info(struct megasas_instance *instance); 155 int 156 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd); 157 void megasas_reset_reply_desc(struct megasas_instance *instance); 158 u8 MR_ValidateMapInfo(struct MR_FW_RAID_MAP_ALL *map, 159 struct LD_LOAD_BALANCE_INFO *lbInfo); 160 int megasas_reset_fusion(struct Scsi_Host *shost); 161 void megasas_fusion_ocr_wq(struct work_struct *work); 162 163 void 164 megasas_issue_dcmd(struct megasas_instance *instance, struct megasas_cmd *cmd) 165 { 166 instance->instancet->fire_cmd(instance, 167 cmd->frame_phys_addr, 0, instance->reg_set); 168 } 169 170 /** 171 * megasas_get_cmd - Get a command from the free pool 172 * @instance: Adapter soft state 173 * 174 * Returns a free command from the pool 175 */ 176 struct megasas_cmd *megasas_get_cmd(struct megasas_instance 177 *instance) 178 { 179 unsigned long flags; 180 struct megasas_cmd *cmd = NULL; 181 182 spin_lock_irqsave(&instance->cmd_pool_lock, flags); 183 184 if (!list_empty(&instance->cmd_pool)) { 185 cmd = list_entry((&instance->cmd_pool)->next, 186 struct megasas_cmd, list); 187 list_del_init(&cmd->list); 188 } else { 189 printk(KERN_ERR "megasas: Command pool empty!\n"); 190 } 191 192 spin_unlock_irqrestore(&instance->cmd_pool_lock, flags); 193 return cmd; 194 } 195 196 /** 197 * megasas_return_cmd - Return a cmd to free command pool 198 * @instance: Adapter soft state 199 * @cmd: Command packet to be returned to free command pool 200 */ 201 inline void 202 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd) 203 { 204 unsigned long flags; 205 206 spin_lock_irqsave(&instance->cmd_pool_lock, flags); 207 208 cmd->scmd = NULL; 209 cmd->frame_count = 0; 210 list_add_tail(&cmd->list, &instance->cmd_pool); 211 212 spin_unlock_irqrestore(&instance->cmd_pool_lock, flags); 213 } 214 215 216 /** 217 * The following functions are defined for xscale 218 * (deviceid : 1064R, PERC5) controllers 219 */ 220 221 /** 222 * megasas_enable_intr_xscale - Enables interrupts 223 * @regs: MFI register set 224 */ 225 static inline void 226 megasas_enable_intr_xscale(struct megasas_register_set __iomem * regs) 227 { 228 writel(0, &(regs)->outbound_intr_mask); 229 230 /* Dummy readl to force pci flush */ 231 readl(®s->outbound_intr_mask); 232 } 233 234 /** 235 * megasas_disable_intr_xscale -Disables interrupt 236 * @regs: MFI register set 237 */ 238 static inline void 239 megasas_disable_intr_xscale(struct megasas_register_set __iomem * regs) 240 { 241 u32 mask = 0x1f; 242 writel(mask, ®s->outbound_intr_mask); 243 /* Dummy readl to force pci flush */ 244 readl(®s->outbound_intr_mask); 245 } 246 247 /** 248 * megasas_read_fw_status_reg_xscale - returns the current FW status value 249 * @regs: MFI register set 250 */ 251 static u32 252 megasas_read_fw_status_reg_xscale(struct megasas_register_set __iomem * regs) 253 { 254 return readl(&(regs)->outbound_msg_0); 255 } 256 /** 257 * megasas_clear_interrupt_xscale - Check & clear interrupt 258 * @regs: MFI register set 259 */ 260 static int 261 megasas_clear_intr_xscale(struct megasas_register_set __iomem * regs) 262 { 263 u32 status; 264 u32 mfiStatus = 0; 265 /* 266 * Check if it is our interrupt 267 */ 268 status = readl(®s->outbound_intr_status); 269 270 if (status & MFI_OB_INTR_STATUS_MASK) 271 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE; 272 if (status & MFI_XSCALE_OMR0_CHANGE_INTERRUPT) 273 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE; 274 275 /* 276 * Clear the interrupt by writing back the same value 277 */ 278 if (mfiStatus) 279 writel(status, ®s->outbound_intr_status); 280 281 /* Dummy readl to force pci flush */ 282 readl(®s->outbound_intr_status); 283 284 return mfiStatus; 285 } 286 287 /** 288 * megasas_fire_cmd_xscale - Sends command to the FW 289 * @frame_phys_addr : Physical address of cmd 290 * @frame_count : Number of frames for the command 291 * @regs : MFI register set 292 */ 293 static inline void 294 megasas_fire_cmd_xscale(struct megasas_instance *instance, 295 dma_addr_t frame_phys_addr, 296 u32 frame_count, 297 struct megasas_register_set __iomem *regs) 298 { 299 unsigned long flags; 300 spin_lock_irqsave(&instance->hba_lock, flags); 301 writel((frame_phys_addr >> 3)|(frame_count), 302 &(regs)->inbound_queue_port); 303 spin_unlock_irqrestore(&instance->hba_lock, flags); 304 } 305 306 /** 307 * megasas_adp_reset_xscale - For controller reset 308 * @regs: MFI register set 309 */ 310 static int 311 megasas_adp_reset_xscale(struct megasas_instance *instance, 312 struct megasas_register_set __iomem *regs) 313 { 314 u32 i; 315 u32 pcidata; 316 writel(MFI_ADP_RESET, ®s->inbound_doorbell); 317 318 for (i = 0; i < 3; i++) 319 msleep(1000); /* sleep for 3 secs */ 320 pcidata = 0; 321 pci_read_config_dword(instance->pdev, MFI_1068_PCSR_OFFSET, &pcidata); 322 printk(KERN_NOTICE "pcidata = %x\n", pcidata); 323 if (pcidata & 0x2) { 324 printk(KERN_NOTICE "mfi 1068 offset read=%x\n", pcidata); 325 pcidata &= ~0x2; 326 pci_write_config_dword(instance->pdev, 327 MFI_1068_PCSR_OFFSET, pcidata); 328 329 for (i = 0; i < 2; i++) 330 msleep(1000); /* need to wait 2 secs again */ 331 332 pcidata = 0; 333 pci_read_config_dword(instance->pdev, 334 MFI_1068_FW_HANDSHAKE_OFFSET, &pcidata); 335 printk(KERN_NOTICE "1068 offset handshake read=%x\n", pcidata); 336 if ((pcidata & 0xffff0000) == MFI_1068_FW_READY) { 337 printk(KERN_NOTICE "1068 offset pcidt=%x\n", pcidata); 338 pcidata = 0; 339 pci_write_config_dword(instance->pdev, 340 MFI_1068_FW_HANDSHAKE_OFFSET, pcidata); 341 } 342 } 343 return 0; 344 } 345 346 /** 347 * megasas_check_reset_xscale - For controller reset check 348 * @regs: MFI register set 349 */ 350 static int 351 megasas_check_reset_xscale(struct megasas_instance *instance, 352 struct megasas_register_set __iomem *regs) 353 { 354 u32 consumer; 355 consumer = *instance->consumer; 356 357 if ((instance->adprecovery != MEGASAS_HBA_OPERATIONAL) && 358 (*instance->consumer == MEGASAS_ADPRESET_INPROG_SIGN)) { 359 return 1; 360 } 361 return 0; 362 } 363 364 static struct megasas_instance_template megasas_instance_template_xscale = { 365 366 .fire_cmd = megasas_fire_cmd_xscale, 367 .enable_intr = megasas_enable_intr_xscale, 368 .disable_intr = megasas_disable_intr_xscale, 369 .clear_intr = megasas_clear_intr_xscale, 370 .read_fw_status_reg = megasas_read_fw_status_reg_xscale, 371 .adp_reset = megasas_adp_reset_xscale, 372 .check_reset = megasas_check_reset_xscale, 373 .service_isr = megasas_isr, 374 .tasklet = megasas_complete_cmd_dpc, 375 .init_adapter = megasas_init_adapter_mfi, 376 .build_and_issue_cmd = megasas_build_and_issue_cmd, 377 .issue_dcmd = megasas_issue_dcmd, 378 }; 379 380 /** 381 * This is the end of set of functions & definitions specific 382 * to xscale (deviceid : 1064R, PERC5) controllers 383 */ 384 385 /** 386 * The following functions are defined for ppc (deviceid : 0x60) 387 * controllers 388 */ 389 390 /** 391 * megasas_enable_intr_ppc - Enables interrupts 392 * @regs: MFI register set 393 */ 394 static inline void 395 megasas_enable_intr_ppc(struct megasas_register_set __iomem * regs) 396 { 397 writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear); 398 399 writel(~0x80000000, &(regs)->outbound_intr_mask); 400 401 /* Dummy readl to force pci flush */ 402 readl(®s->outbound_intr_mask); 403 } 404 405 /** 406 * megasas_disable_intr_ppc - Disable interrupt 407 * @regs: MFI register set 408 */ 409 static inline void 410 megasas_disable_intr_ppc(struct megasas_register_set __iomem * regs) 411 { 412 u32 mask = 0xFFFFFFFF; 413 writel(mask, ®s->outbound_intr_mask); 414 /* Dummy readl to force pci flush */ 415 readl(®s->outbound_intr_mask); 416 } 417 418 /** 419 * megasas_read_fw_status_reg_ppc - returns the current FW status value 420 * @regs: MFI register set 421 */ 422 static u32 423 megasas_read_fw_status_reg_ppc(struct megasas_register_set __iomem * regs) 424 { 425 return readl(&(regs)->outbound_scratch_pad); 426 } 427 428 /** 429 * megasas_clear_interrupt_ppc - Check & clear interrupt 430 * @regs: MFI register set 431 */ 432 static int 433 megasas_clear_intr_ppc(struct megasas_register_set __iomem * regs) 434 { 435 u32 status; 436 /* 437 * Check if it is our interrupt 438 */ 439 status = readl(®s->outbound_intr_status); 440 441 if (!(status & MFI_REPLY_1078_MESSAGE_INTERRUPT)) { 442 return 0; 443 } 444 445 /* 446 * Clear the interrupt by writing back the same value 447 */ 448 writel(status, ®s->outbound_doorbell_clear); 449 450 /* Dummy readl to force pci flush */ 451 readl(®s->outbound_doorbell_clear); 452 453 return 1; 454 } 455 /** 456 * megasas_fire_cmd_ppc - Sends command to the FW 457 * @frame_phys_addr : Physical address of cmd 458 * @frame_count : Number of frames for the command 459 * @regs : MFI register set 460 */ 461 static inline void 462 megasas_fire_cmd_ppc(struct megasas_instance *instance, 463 dma_addr_t frame_phys_addr, 464 u32 frame_count, 465 struct megasas_register_set __iomem *regs) 466 { 467 unsigned long flags; 468 spin_lock_irqsave(&instance->hba_lock, flags); 469 writel((frame_phys_addr | (frame_count<<1))|1, 470 &(regs)->inbound_queue_port); 471 spin_unlock_irqrestore(&instance->hba_lock, flags); 472 } 473 474 /** 475 * megasas_adp_reset_ppc - For controller reset 476 * @regs: MFI register set 477 */ 478 static int 479 megasas_adp_reset_ppc(struct megasas_instance *instance, 480 struct megasas_register_set __iomem *regs) 481 { 482 return 0; 483 } 484 485 /** 486 * megasas_check_reset_ppc - For controller reset check 487 * @regs: MFI register set 488 */ 489 static int 490 megasas_check_reset_ppc(struct megasas_instance *instance, 491 struct megasas_register_set __iomem *regs) 492 { 493 return 0; 494 } 495 static struct megasas_instance_template megasas_instance_template_ppc = { 496 497 .fire_cmd = megasas_fire_cmd_ppc, 498 .enable_intr = megasas_enable_intr_ppc, 499 .disable_intr = megasas_disable_intr_ppc, 500 .clear_intr = megasas_clear_intr_ppc, 501 .read_fw_status_reg = megasas_read_fw_status_reg_ppc, 502 .adp_reset = megasas_adp_reset_ppc, 503 .check_reset = megasas_check_reset_ppc, 504 .service_isr = megasas_isr, 505 .tasklet = megasas_complete_cmd_dpc, 506 .init_adapter = megasas_init_adapter_mfi, 507 .build_and_issue_cmd = megasas_build_and_issue_cmd, 508 .issue_dcmd = megasas_issue_dcmd, 509 }; 510 511 /** 512 * megasas_enable_intr_skinny - Enables interrupts 513 * @regs: MFI register set 514 */ 515 static inline void 516 megasas_enable_intr_skinny(struct megasas_register_set __iomem *regs) 517 { 518 writel(0xFFFFFFFF, &(regs)->outbound_intr_mask); 519 520 writel(~MFI_SKINNY_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask); 521 522 /* Dummy readl to force pci flush */ 523 readl(®s->outbound_intr_mask); 524 } 525 526 /** 527 * megasas_disable_intr_skinny - Disables interrupt 528 * @regs: MFI register set 529 */ 530 static inline void 531 megasas_disable_intr_skinny(struct megasas_register_set __iomem *regs) 532 { 533 u32 mask = 0xFFFFFFFF; 534 writel(mask, ®s->outbound_intr_mask); 535 /* Dummy readl to force pci flush */ 536 readl(®s->outbound_intr_mask); 537 } 538 539 /** 540 * megasas_read_fw_status_reg_skinny - returns the current FW status value 541 * @regs: MFI register set 542 */ 543 static u32 544 megasas_read_fw_status_reg_skinny(struct megasas_register_set __iomem *regs) 545 { 546 return readl(&(regs)->outbound_scratch_pad); 547 } 548 549 /** 550 * megasas_clear_interrupt_skinny - Check & clear interrupt 551 * @regs: MFI register set 552 */ 553 static int 554 megasas_clear_intr_skinny(struct megasas_register_set __iomem *regs) 555 { 556 u32 status; 557 /* 558 * Check if it is our interrupt 559 */ 560 status = readl(®s->outbound_intr_status); 561 562 if (!(status & MFI_SKINNY_ENABLE_INTERRUPT_MASK)) { 563 return 0; 564 } 565 566 /* 567 * Clear the interrupt by writing back the same value 568 */ 569 writel(status, ®s->outbound_intr_status); 570 571 /* 572 * dummy read to flush PCI 573 */ 574 readl(®s->outbound_intr_status); 575 576 return 1; 577 } 578 579 /** 580 * megasas_fire_cmd_skinny - Sends command to the FW 581 * @frame_phys_addr : Physical address of cmd 582 * @frame_count : Number of frames for the command 583 * @regs : MFI register set 584 */ 585 static inline void 586 megasas_fire_cmd_skinny(struct megasas_instance *instance, 587 dma_addr_t frame_phys_addr, 588 u32 frame_count, 589 struct megasas_register_set __iomem *regs) 590 { 591 unsigned long flags; 592 spin_lock_irqsave(&instance->hba_lock, flags); 593 writel(0, &(regs)->inbound_high_queue_port); 594 writel((frame_phys_addr | (frame_count<<1))|1, 595 &(regs)->inbound_low_queue_port); 596 spin_unlock_irqrestore(&instance->hba_lock, flags); 597 } 598 599 /** 600 * megasas_adp_reset_skinny - For controller reset 601 * @regs: MFI register set 602 */ 603 static int 604 megasas_adp_reset_skinny(struct megasas_instance *instance, 605 struct megasas_register_set __iomem *regs) 606 { 607 return 0; 608 } 609 610 /** 611 * megasas_check_reset_skinny - For controller reset check 612 * @regs: MFI register set 613 */ 614 static int 615 megasas_check_reset_skinny(struct megasas_instance *instance, 616 struct megasas_register_set __iomem *regs) 617 { 618 return 0; 619 } 620 621 static struct megasas_instance_template megasas_instance_template_skinny = { 622 623 .fire_cmd = megasas_fire_cmd_skinny, 624 .enable_intr = megasas_enable_intr_skinny, 625 .disable_intr = megasas_disable_intr_skinny, 626 .clear_intr = megasas_clear_intr_skinny, 627 .read_fw_status_reg = megasas_read_fw_status_reg_skinny, 628 .adp_reset = megasas_adp_reset_skinny, 629 .check_reset = megasas_check_reset_skinny, 630 .service_isr = megasas_isr, 631 .tasklet = megasas_complete_cmd_dpc, 632 .init_adapter = megasas_init_adapter_mfi, 633 .build_and_issue_cmd = megasas_build_and_issue_cmd, 634 .issue_dcmd = megasas_issue_dcmd, 635 }; 636 637 638 /** 639 * The following functions are defined for gen2 (deviceid : 0x78 0x79) 640 * controllers 641 */ 642 643 /** 644 * megasas_enable_intr_gen2 - Enables interrupts 645 * @regs: MFI register set 646 */ 647 static inline void 648 megasas_enable_intr_gen2(struct megasas_register_set __iomem *regs) 649 { 650 writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear); 651 652 /* write ~0x00000005 (4 & 1) to the intr mask*/ 653 writel(~MFI_GEN2_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask); 654 655 /* Dummy readl to force pci flush */ 656 readl(®s->outbound_intr_mask); 657 } 658 659 /** 660 * megasas_disable_intr_gen2 - Disables interrupt 661 * @regs: MFI register set 662 */ 663 static inline void 664 megasas_disable_intr_gen2(struct megasas_register_set __iomem *regs) 665 { 666 u32 mask = 0xFFFFFFFF; 667 writel(mask, ®s->outbound_intr_mask); 668 /* Dummy readl to force pci flush */ 669 readl(®s->outbound_intr_mask); 670 } 671 672 /** 673 * megasas_read_fw_status_reg_gen2 - returns the current FW status value 674 * @regs: MFI register set 675 */ 676 static u32 677 megasas_read_fw_status_reg_gen2(struct megasas_register_set __iomem *regs) 678 { 679 return readl(&(regs)->outbound_scratch_pad); 680 } 681 682 /** 683 * megasas_clear_interrupt_gen2 - Check & clear interrupt 684 * @regs: MFI register set 685 */ 686 static int 687 megasas_clear_intr_gen2(struct megasas_register_set __iomem *regs) 688 { 689 u32 status; 690 u32 mfiStatus = 0; 691 /* 692 * Check if it is our interrupt 693 */ 694 status = readl(®s->outbound_intr_status); 695 696 if (status & MFI_GEN2_ENABLE_INTERRUPT_MASK) { 697 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE; 698 } 699 if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT) { 700 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE; 701 } 702 703 /* 704 * Clear the interrupt by writing back the same value 705 */ 706 if (mfiStatus) 707 writel(status, ®s->outbound_doorbell_clear); 708 709 /* Dummy readl to force pci flush */ 710 readl(®s->outbound_intr_status); 711 712 return mfiStatus; 713 } 714 /** 715 * megasas_fire_cmd_gen2 - Sends command to the FW 716 * @frame_phys_addr : Physical address of cmd 717 * @frame_count : Number of frames for the command 718 * @regs : MFI register set 719 */ 720 static inline void 721 megasas_fire_cmd_gen2(struct megasas_instance *instance, 722 dma_addr_t frame_phys_addr, 723 u32 frame_count, 724 struct megasas_register_set __iomem *regs) 725 { 726 unsigned long flags; 727 spin_lock_irqsave(&instance->hba_lock, flags); 728 writel((frame_phys_addr | (frame_count<<1))|1, 729 &(regs)->inbound_queue_port); 730 spin_unlock_irqrestore(&instance->hba_lock, flags); 731 } 732 733 /** 734 * megasas_adp_reset_gen2 - For controller reset 735 * @regs: MFI register set 736 */ 737 static int 738 megasas_adp_reset_gen2(struct megasas_instance *instance, 739 struct megasas_register_set __iomem *reg_set) 740 { 741 u32 retry = 0 ; 742 u32 HostDiag; 743 744 writel(0, ®_set->seq_offset); 745 writel(4, ®_set->seq_offset); 746 writel(0xb, ®_set->seq_offset); 747 writel(2, ®_set->seq_offset); 748 writel(7, ®_set->seq_offset); 749 writel(0xd, ®_set->seq_offset); 750 msleep(1000); 751 752 HostDiag = (u32)readl(®_set->host_diag); 753 754 while ( !( HostDiag & DIAG_WRITE_ENABLE) ) { 755 msleep(100); 756 HostDiag = (u32)readl(®_set->host_diag); 757 printk(KERN_NOTICE "RESETGEN2: retry=%x, hostdiag=%x\n", 758 retry, HostDiag); 759 760 if (retry++ >= 100) 761 return 1; 762 763 } 764 765 printk(KERN_NOTICE "ADP_RESET_GEN2: HostDiag=%x\n", HostDiag); 766 767 writel((HostDiag | DIAG_RESET_ADAPTER), ®_set->host_diag); 768 769 ssleep(10); 770 771 HostDiag = (u32)readl(®_set->host_diag); 772 while ( ( HostDiag & DIAG_RESET_ADAPTER) ) { 773 msleep(100); 774 HostDiag = (u32)readl(®_set->host_diag); 775 printk(KERN_NOTICE "RESET_GEN2: retry=%x, hostdiag=%x\n", 776 retry, HostDiag); 777 778 if (retry++ >= 1000) 779 return 1; 780 781 } 782 return 0; 783 } 784 785 /** 786 * megasas_check_reset_gen2 - For controller reset check 787 * @regs: MFI register set 788 */ 789 static int 790 megasas_check_reset_gen2(struct megasas_instance *instance, 791 struct megasas_register_set __iomem *regs) 792 { 793 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) { 794 return 1; 795 } 796 797 return 0; 798 } 799 800 static struct megasas_instance_template megasas_instance_template_gen2 = { 801 802 .fire_cmd = megasas_fire_cmd_gen2, 803 .enable_intr = megasas_enable_intr_gen2, 804 .disable_intr = megasas_disable_intr_gen2, 805 .clear_intr = megasas_clear_intr_gen2, 806 .read_fw_status_reg = megasas_read_fw_status_reg_gen2, 807 .adp_reset = megasas_adp_reset_gen2, 808 .check_reset = megasas_check_reset_gen2, 809 .service_isr = megasas_isr, 810 .tasklet = megasas_complete_cmd_dpc, 811 .init_adapter = megasas_init_adapter_mfi, 812 .build_and_issue_cmd = megasas_build_and_issue_cmd, 813 .issue_dcmd = megasas_issue_dcmd, 814 }; 815 816 /** 817 * This is the end of set of functions & definitions 818 * specific to gen2 (deviceid : 0x78, 0x79) controllers 819 */ 820 821 /* 822 * Template added for TB (Fusion) 823 */ 824 extern struct megasas_instance_template megasas_instance_template_fusion; 825 826 /** 827 * megasas_issue_polled - Issues a polling command 828 * @instance: Adapter soft state 829 * @cmd: Command packet to be issued 830 * 831 * For polling, MFI requires the cmd_status to be set to 0xFF before posting. 832 */ 833 int 834 megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd) 835 { 836 837 struct megasas_header *frame_hdr = &cmd->frame->hdr; 838 839 frame_hdr->cmd_status = 0xFF; 840 frame_hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE; 841 842 /* 843 * Issue the frame using inbound queue port 844 */ 845 instance->instancet->issue_dcmd(instance, cmd); 846 847 /* 848 * Wait for cmd_status to change 849 */ 850 return wait_and_poll(instance, cmd); 851 } 852 853 /** 854 * megasas_issue_blocked_cmd - Synchronous wrapper around regular FW cmds 855 * @instance: Adapter soft state 856 * @cmd: Command to be issued 857 * 858 * This function waits on an event for the command to be returned from ISR. 859 * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs 860 * Used to issue ioctl commands. 861 */ 862 static int 863 megasas_issue_blocked_cmd(struct megasas_instance *instance, 864 struct megasas_cmd *cmd) 865 { 866 cmd->cmd_status = ENODATA; 867 868 instance->instancet->issue_dcmd(instance, cmd); 869 870 wait_event(instance->int_cmd_wait_q, cmd->cmd_status != ENODATA); 871 872 return 0; 873 } 874 875 /** 876 * megasas_issue_blocked_abort_cmd - Aborts previously issued cmd 877 * @instance: Adapter soft state 878 * @cmd_to_abort: Previously issued cmd to be aborted 879 * 880 * MFI firmware can abort previously issued AEN comamnd (automatic event 881 * notification). The megasas_issue_blocked_abort_cmd() issues such abort 882 * cmd and waits for return status. 883 * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs 884 */ 885 static int 886 megasas_issue_blocked_abort_cmd(struct megasas_instance *instance, 887 struct megasas_cmd *cmd_to_abort) 888 { 889 struct megasas_cmd *cmd; 890 struct megasas_abort_frame *abort_fr; 891 892 cmd = megasas_get_cmd(instance); 893 894 if (!cmd) 895 return -1; 896 897 abort_fr = &cmd->frame->abort; 898 899 /* 900 * Prepare and issue the abort frame 901 */ 902 abort_fr->cmd = MFI_CMD_ABORT; 903 abort_fr->cmd_status = 0xFF; 904 abort_fr->flags = 0; 905 abort_fr->abort_context = cmd_to_abort->index; 906 abort_fr->abort_mfi_phys_addr_lo = cmd_to_abort->frame_phys_addr; 907 abort_fr->abort_mfi_phys_addr_hi = 0; 908 909 cmd->sync_cmd = 1; 910 cmd->cmd_status = 0xFF; 911 912 instance->instancet->issue_dcmd(instance, cmd); 913 914 /* 915 * Wait for this cmd to complete 916 */ 917 wait_event(instance->abort_cmd_wait_q, cmd->cmd_status != 0xFF); 918 cmd->sync_cmd = 0; 919 920 megasas_return_cmd(instance, cmd); 921 return 0; 922 } 923 924 /** 925 * megasas_make_sgl32 - Prepares 32-bit SGL 926 * @instance: Adapter soft state 927 * @scp: SCSI command from the mid-layer 928 * @mfi_sgl: SGL to be filled in 929 * 930 * If successful, this function returns the number of SG elements. Otherwise, 931 * it returnes -1. 932 */ 933 static int 934 megasas_make_sgl32(struct megasas_instance *instance, struct scsi_cmnd *scp, 935 union megasas_sgl *mfi_sgl) 936 { 937 int i; 938 int sge_count; 939 struct scatterlist *os_sgl; 940 941 sge_count = scsi_dma_map(scp); 942 BUG_ON(sge_count < 0); 943 944 if (sge_count) { 945 scsi_for_each_sg(scp, os_sgl, sge_count, i) { 946 mfi_sgl->sge32[i].length = sg_dma_len(os_sgl); 947 mfi_sgl->sge32[i].phys_addr = sg_dma_address(os_sgl); 948 } 949 } 950 return sge_count; 951 } 952 953 /** 954 * megasas_make_sgl64 - Prepares 64-bit SGL 955 * @instance: Adapter soft state 956 * @scp: SCSI command from the mid-layer 957 * @mfi_sgl: SGL to be filled in 958 * 959 * If successful, this function returns the number of SG elements. Otherwise, 960 * it returnes -1. 961 */ 962 static int 963 megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp, 964 union megasas_sgl *mfi_sgl) 965 { 966 int i; 967 int sge_count; 968 struct scatterlist *os_sgl; 969 970 sge_count = scsi_dma_map(scp); 971 BUG_ON(sge_count < 0); 972 973 if (sge_count) { 974 scsi_for_each_sg(scp, os_sgl, sge_count, i) { 975 mfi_sgl->sge64[i].length = sg_dma_len(os_sgl); 976 mfi_sgl->sge64[i].phys_addr = sg_dma_address(os_sgl); 977 } 978 } 979 return sge_count; 980 } 981 982 /** 983 * megasas_make_sgl_skinny - Prepares IEEE SGL 984 * @instance: Adapter soft state 985 * @scp: SCSI command from the mid-layer 986 * @mfi_sgl: SGL to be filled in 987 * 988 * If successful, this function returns the number of SG elements. Otherwise, 989 * it returnes -1. 990 */ 991 static int 992 megasas_make_sgl_skinny(struct megasas_instance *instance, 993 struct scsi_cmnd *scp, union megasas_sgl *mfi_sgl) 994 { 995 int i; 996 int sge_count; 997 struct scatterlist *os_sgl; 998 999 sge_count = scsi_dma_map(scp); 1000 1001 if (sge_count) { 1002 scsi_for_each_sg(scp, os_sgl, sge_count, i) { 1003 mfi_sgl->sge_skinny[i].length = sg_dma_len(os_sgl); 1004 mfi_sgl->sge_skinny[i].phys_addr = 1005 sg_dma_address(os_sgl); 1006 mfi_sgl->sge_skinny[i].flag = 0; 1007 } 1008 } 1009 return sge_count; 1010 } 1011 1012 /** 1013 * megasas_get_frame_count - Computes the number of frames 1014 * @frame_type : type of frame- io or pthru frame 1015 * @sge_count : number of sg elements 1016 * 1017 * Returns the number of frames required for numnber of sge's (sge_count) 1018 */ 1019 1020 static u32 megasas_get_frame_count(struct megasas_instance *instance, 1021 u8 sge_count, u8 frame_type) 1022 { 1023 int num_cnt; 1024 int sge_bytes; 1025 u32 sge_sz; 1026 u32 frame_count=0; 1027 1028 sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) : 1029 sizeof(struct megasas_sge32); 1030 1031 if (instance->flag_ieee) { 1032 sge_sz = sizeof(struct megasas_sge_skinny); 1033 } 1034 1035 /* 1036 * Main frame can contain 2 SGEs for 64-bit SGLs and 1037 * 3 SGEs for 32-bit SGLs for ldio & 1038 * 1 SGEs for 64-bit SGLs and 1039 * 2 SGEs for 32-bit SGLs for pthru frame 1040 */ 1041 if (unlikely(frame_type == PTHRU_FRAME)) { 1042 if (instance->flag_ieee == 1) { 1043 num_cnt = sge_count - 1; 1044 } else if (IS_DMA64) 1045 num_cnt = sge_count - 1; 1046 else 1047 num_cnt = sge_count - 2; 1048 } else { 1049 if (instance->flag_ieee == 1) { 1050 num_cnt = sge_count - 1; 1051 } else if (IS_DMA64) 1052 num_cnt = sge_count - 2; 1053 else 1054 num_cnt = sge_count - 3; 1055 } 1056 1057 if(num_cnt>0){ 1058 sge_bytes = sge_sz * num_cnt; 1059 1060 frame_count = (sge_bytes / MEGAMFI_FRAME_SIZE) + 1061 ((sge_bytes % MEGAMFI_FRAME_SIZE) ? 1 : 0) ; 1062 } 1063 /* Main frame */ 1064 frame_count +=1; 1065 1066 if (frame_count > 7) 1067 frame_count = 8; 1068 return frame_count; 1069 } 1070 1071 /** 1072 * megasas_build_dcdb - Prepares a direct cdb (DCDB) command 1073 * @instance: Adapter soft state 1074 * @scp: SCSI command 1075 * @cmd: Command to be prepared in 1076 * 1077 * This function prepares CDB commands. These are typcially pass-through 1078 * commands to the devices. 1079 */ 1080 static int 1081 megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp, 1082 struct megasas_cmd *cmd) 1083 { 1084 u32 is_logical; 1085 u32 device_id; 1086 u16 flags = 0; 1087 struct megasas_pthru_frame *pthru; 1088 1089 is_logical = MEGASAS_IS_LOGICAL(scp); 1090 device_id = MEGASAS_DEV_INDEX(instance, scp); 1091 pthru = (struct megasas_pthru_frame *)cmd->frame; 1092 1093 if (scp->sc_data_direction == PCI_DMA_TODEVICE) 1094 flags = MFI_FRAME_DIR_WRITE; 1095 else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) 1096 flags = MFI_FRAME_DIR_READ; 1097 else if (scp->sc_data_direction == PCI_DMA_NONE) 1098 flags = MFI_FRAME_DIR_NONE; 1099 1100 if (instance->flag_ieee == 1) { 1101 flags |= MFI_FRAME_IEEE; 1102 } 1103 1104 /* 1105 * Prepare the DCDB frame 1106 */ 1107 pthru->cmd = (is_logical) ? MFI_CMD_LD_SCSI_IO : MFI_CMD_PD_SCSI_IO; 1108 pthru->cmd_status = 0x0; 1109 pthru->scsi_status = 0x0; 1110 pthru->target_id = device_id; 1111 pthru->lun = scp->device->lun; 1112 pthru->cdb_len = scp->cmd_len; 1113 pthru->timeout = 0; 1114 pthru->pad_0 = 0; 1115 pthru->flags = flags; 1116 pthru->data_xfer_len = scsi_bufflen(scp); 1117 1118 memcpy(pthru->cdb, scp->cmnd, scp->cmd_len); 1119 1120 /* 1121 * If the command is for the tape device, set the 1122 * pthru timeout to the os layer timeout value. 1123 */ 1124 if (scp->device->type == TYPE_TAPE) { 1125 if ((scp->request->timeout / HZ) > 0xFFFF) 1126 pthru->timeout = 0xFFFF; 1127 else 1128 pthru->timeout = scp->request->timeout / HZ; 1129 } 1130 1131 /* 1132 * Construct SGL 1133 */ 1134 if (instance->flag_ieee == 1) { 1135 pthru->flags |= MFI_FRAME_SGL64; 1136 pthru->sge_count = megasas_make_sgl_skinny(instance, scp, 1137 &pthru->sgl); 1138 } else if (IS_DMA64) { 1139 pthru->flags |= MFI_FRAME_SGL64; 1140 pthru->sge_count = megasas_make_sgl64(instance, scp, 1141 &pthru->sgl); 1142 } else 1143 pthru->sge_count = megasas_make_sgl32(instance, scp, 1144 &pthru->sgl); 1145 1146 if (pthru->sge_count > instance->max_num_sge) { 1147 printk(KERN_ERR "megasas: DCDB two many SGE NUM=%x\n", 1148 pthru->sge_count); 1149 return 0; 1150 } 1151 1152 /* 1153 * Sense info specific 1154 */ 1155 pthru->sense_len = SCSI_SENSE_BUFFERSIZE; 1156 pthru->sense_buf_phys_addr_hi = 0; 1157 pthru->sense_buf_phys_addr_lo = cmd->sense_phys_addr; 1158 1159 /* 1160 * Compute the total number of frames this command consumes. FW uses 1161 * this number to pull sufficient number of frames from host memory. 1162 */ 1163 cmd->frame_count = megasas_get_frame_count(instance, pthru->sge_count, 1164 PTHRU_FRAME); 1165 1166 return cmd->frame_count; 1167 } 1168 1169 /** 1170 * megasas_build_ldio - Prepares IOs to logical devices 1171 * @instance: Adapter soft state 1172 * @scp: SCSI command 1173 * @cmd: Command to be prepared 1174 * 1175 * Frames (and accompanying SGLs) for regular SCSI IOs use this function. 1176 */ 1177 static int 1178 megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp, 1179 struct megasas_cmd *cmd) 1180 { 1181 u32 device_id; 1182 u8 sc = scp->cmnd[0]; 1183 u16 flags = 0; 1184 struct megasas_io_frame *ldio; 1185 1186 device_id = MEGASAS_DEV_INDEX(instance, scp); 1187 ldio = (struct megasas_io_frame *)cmd->frame; 1188 1189 if (scp->sc_data_direction == PCI_DMA_TODEVICE) 1190 flags = MFI_FRAME_DIR_WRITE; 1191 else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) 1192 flags = MFI_FRAME_DIR_READ; 1193 1194 if (instance->flag_ieee == 1) { 1195 flags |= MFI_FRAME_IEEE; 1196 } 1197 1198 /* 1199 * Prepare the Logical IO frame: 2nd bit is zero for all read cmds 1200 */ 1201 ldio->cmd = (sc & 0x02) ? MFI_CMD_LD_WRITE : MFI_CMD_LD_READ; 1202 ldio->cmd_status = 0x0; 1203 ldio->scsi_status = 0x0; 1204 ldio->target_id = device_id; 1205 ldio->timeout = 0; 1206 ldio->reserved_0 = 0; 1207 ldio->pad_0 = 0; 1208 ldio->flags = flags; 1209 ldio->start_lba_hi = 0; 1210 ldio->access_byte = (scp->cmd_len != 6) ? scp->cmnd[1] : 0; 1211 1212 /* 1213 * 6-byte READ(0x08) or WRITE(0x0A) cdb 1214 */ 1215 if (scp->cmd_len == 6) { 1216 ldio->lba_count = (u32) scp->cmnd[4]; 1217 ldio->start_lba_lo = ((u32) scp->cmnd[1] << 16) | 1218 ((u32) scp->cmnd[2] << 8) | (u32) scp->cmnd[3]; 1219 1220 ldio->start_lba_lo &= 0x1FFFFF; 1221 } 1222 1223 /* 1224 * 10-byte READ(0x28) or WRITE(0x2A) cdb 1225 */ 1226 else if (scp->cmd_len == 10) { 1227 ldio->lba_count = (u32) scp->cmnd[8] | 1228 ((u32) scp->cmnd[7] << 8); 1229 ldio->start_lba_lo = ((u32) scp->cmnd[2] << 24) | 1230 ((u32) scp->cmnd[3] << 16) | 1231 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5]; 1232 } 1233 1234 /* 1235 * 12-byte READ(0xA8) or WRITE(0xAA) cdb 1236 */ 1237 else if (scp->cmd_len == 12) { 1238 ldio->lba_count = ((u32) scp->cmnd[6] << 24) | 1239 ((u32) scp->cmnd[7] << 16) | 1240 ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9]; 1241 1242 ldio->start_lba_lo = ((u32) scp->cmnd[2] << 24) | 1243 ((u32) scp->cmnd[3] << 16) | 1244 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5]; 1245 } 1246 1247 /* 1248 * 16-byte READ(0x88) or WRITE(0x8A) cdb 1249 */ 1250 else if (scp->cmd_len == 16) { 1251 ldio->lba_count = ((u32) scp->cmnd[10] << 24) | 1252 ((u32) scp->cmnd[11] << 16) | 1253 ((u32) scp->cmnd[12] << 8) | (u32) scp->cmnd[13]; 1254 1255 ldio->start_lba_lo = ((u32) scp->cmnd[6] << 24) | 1256 ((u32) scp->cmnd[7] << 16) | 1257 ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9]; 1258 1259 ldio->start_lba_hi = ((u32) scp->cmnd[2] << 24) | 1260 ((u32) scp->cmnd[3] << 16) | 1261 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5]; 1262 1263 } 1264 1265 /* 1266 * Construct SGL 1267 */ 1268 if (instance->flag_ieee) { 1269 ldio->flags |= MFI_FRAME_SGL64; 1270 ldio->sge_count = megasas_make_sgl_skinny(instance, scp, 1271 &ldio->sgl); 1272 } else if (IS_DMA64) { 1273 ldio->flags |= MFI_FRAME_SGL64; 1274 ldio->sge_count = megasas_make_sgl64(instance, scp, &ldio->sgl); 1275 } else 1276 ldio->sge_count = megasas_make_sgl32(instance, scp, &ldio->sgl); 1277 1278 if (ldio->sge_count > instance->max_num_sge) { 1279 printk(KERN_ERR "megasas: build_ld_io: sge_count = %x\n", 1280 ldio->sge_count); 1281 return 0; 1282 } 1283 1284 /* 1285 * Sense info specific 1286 */ 1287 ldio->sense_len = SCSI_SENSE_BUFFERSIZE; 1288 ldio->sense_buf_phys_addr_hi = 0; 1289 ldio->sense_buf_phys_addr_lo = cmd->sense_phys_addr; 1290 1291 /* 1292 * Compute the total number of frames this command consumes. FW uses 1293 * this number to pull sufficient number of frames from host memory. 1294 */ 1295 cmd->frame_count = megasas_get_frame_count(instance, 1296 ldio->sge_count, IO_FRAME); 1297 1298 return cmd->frame_count; 1299 } 1300 1301 /** 1302 * megasas_is_ldio - Checks if the cmd is for logical drive 1303 * @scmd: SCSI command 1304 * 1305 * Called by megasas_queue_command to find out if the command to be queued 1306 * is a logical drive command 1307 */ 1308 inline int megasas_is_ldio(struct scsi_cmnd *cmd) 1309 { 1310 if (!MEGASAS_IS_LOGICAL(cmd)) 1311 return 0; 1312 switch (cmd->cmnd[0]) { 1313 case READ_10: 1314 case WRITE_10: 1315 case READ_12: 1316 case WRITE_12: 1317 case READ_6: 1318 case WRITE_6: 1319 case READ_16: 1320 case WRITE_16: 1321 return 1; 1322 default: 1323 return 0; 1324 } 1325 } 1326 1327 /** 1328 * megasas_dump_pending_frames - Dumps the frame address of all pending cmds 1329 * in FW 1330 * @instance: Adapter soft state 1331 */ 1332 static inline void 1333 megasas_dump_pending_frames(struct megasas_instance *instance) 1334 { 1335 struct megasas_cmd *cmd; 1336 int i,n; 1337 union megasas_sgl *mfi_sgl; 1338 struct megasas_io_frame *ldio; 1339 struct megasas_pthru_frame *pthru; 1340 u32 sgcount; 1341 u32 max_cmd = instance->max_fw_cmds; 1342 1343 printk(KERN_ERR "\nmegasas[%d]: Dumping Frame Phys Address of all pending cmds in FW\n",instance->host->host_no); 1344 printk(KERN_ERR "megasas[%d]: Total OS Pending cmds : %d\n",instance->host->host_no,atomic_read(&instance->fw_outstanding)); 1345 if (IS_DMA64) 1346 printk(KERN_ERR "\nmegasas[%d]: 64 bit SGLs were sent to FW\n",instance->host->host_no); 1347 else 1348 printk(KERN_ERR "\nmegasas[%d]: 32 bit SGLs were sent to FW\n",instance->host->host_no); 1349 1350 printk(KERN_ERR "megasas[%d]: Pending OS cmds in FW : \n",instance->host->host_no); 1351 for (i = 0; i < max_cmd; i++) { 1352 cmd = instance->cmd_list[i]; 1353 if(!cmd->scmd) 1354 continue; 1355 printk(KERN_ERR "megasas[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr); 1356 if (megasas_is_ldio(cmd->scmd)){ 1357 ldio = (struct megasas_io_frame *)cmd->frame; 1358 mfi_sgl = &ldio->sgl; 1359 sgcount = ldio->sge_count; 1360 printk(KERN_ERR "megasas[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x, lba lo : 0x%x, lba_hi : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n",instance->host->host_no, cmd->frame_count,ldio->cmd,ldio->target_id, ldio->start_lba_lo,ldio->start_lba_hi,ldio->sense_buf_phys_addr_lo,sgcount); 1361 } 1362 else { 1363 pthru = (struct megasas_pthru_frame *) cmd->frame; 1364 mfi_sgl = &pthru->sgl; 1365 sgcount = pthru->sge_count; 1366 printk(KERN_ERR "megasas[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x, lun : 0x%x, cdb_len : 0x%x, data xfer len : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n",instance->host->host_no,cmd->frame_count,pthru->cmd,pthru->target_id,pthru->lun,pthru->cdb_len , pthru->data_xfer_len,pthru->sense_buf_phys_addr_lo,sgcount); 1367 } 1368 if(megasas_dbg_lvl & MEGASAS_DBG_LVL){ 1369 for (n = 0; n < sgcount; n++){ 1370 if (IS_DMA64) 1371 printk(KERN_ERR "megasas: sgl len : 0x%x, sgl addr : 0x%08lx ",mfi_sgl->sge64[n].length , (unsigned long)mfi_sgl->sge64[n].phys_addr) ; 1372 else 1373 printk(KERN_ERR "megasas: sgl len : 0x%x, sgl addr : 0x%x ",mfi_sgl->sge32[n].length , mfi_sgl->sge32[n].phys_addr) ; 1374 } 1375 } 1376 printk(KERN_ERR "\n"); 1377 } /*for max_cmd*/ 1378 printk(KERN_ERR "\nmegasas[%d]: Pending Internal cmds in FW : \n",instance->host->host_no); 1379 for (i = 0; i < max_cmd; i++) { 1380 1381 cmd = instance->cmd_list[i]; 1382 1383 if(cmd->sync_cmd == 1){ 1384 printk(KERN_ERR "0x%08lx : ", (unsigned long)cmd->frame_phys_addr); 1385 } 1386 } 1387 printk(KERN_ERR "megasas[%d]: Dumping Done.\n\n",instance->host->host_no); 1388 } 1389 1390 u32 1391 megasas_build_and_issue_cmd(struct megasas_instance *instance, 1392 struct scsi_cmnd *scmd) 1393 { 1394 struct megasas_cmd *cmd; 1395 u32 frame_count; 1396 1397 cmd = megasas_get_cmd(instance); 1398 if (!cmd) 1399 return SCSI_MLQUEUE_HOST_BUSY; 1400 1401 /* 1402 * Logical drive command 1403 */ 1404 if (megasas_is_ldio(scmd)) 1405 frame_count = megasas_build_ldio(instance, scmd, cmd); 1406 else 1407 frame_count = megasas_build_dcdb(instance, scmd, cmd); 1408 1409 if (!frame_count) 1410 goto out_return_cmd; 1411 1412 cmd->scmd = scmd; 1413 scmd->SCp.ptr = (char *)cmd; 1414 1415 /* 1416 * Issue the command to the FW 1417 */ 1418 atomic_inc(&instance->fw_outstanding); 1419 1420 instance->instancet->fire_cmd(instance, cmd->frame_phys_addr, 1421 cmd->frame_count-1, instance->reg_set); 1422 /* 1423 * Check if we have pend cmds to be completed 1424 */ 1425 if (poll_mode_io && atomic_read(&instance->fw_outstanding)) 1426 tasklet_schedule(&instance->isr_tasklet); 1427 1428 return 0; 1429 out_return_cmd: 1430 megasas_return_cmd(instance, cmd); 1431 return 1; 1432 } 1433 1434 1435 /** 1436 * megasas_queue_command - Queue entry point 1437 * @scmd: SCSI command to be queued 1438 * @done: Callback entry point 1439 */ 1440 static int 1441 megasas_queue_command_lck(struct scsi_cmnd *scmd, void (*done) (struct scsi_cmnd *)) 1442 { 1443 struct megasas_instance *instance; 1444 unsigned long flags; 1445 1446 instance = (struct megasas_instance *) 1447 scmd->device->host->hostdata; 1448 1449 if (instance->issuepend_done == 0) 1450 return SCSI_MLQUEUE_HOST_BUSY; 1451 1452 spin_lock_irqsave(&instance->hba_lock, flags); 1453 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) { 1454 spin_unlock_irqrestore(&instance->hba_lock, flags); 1455 return SCSI_MLQUEUE_HOST_BUSY; 1456 } 1457 1458 spin_unlock_irqrestore(&instance->hba_lock, flags); 1459 1460 scmd->scsi_done = done; 1461 scmd->result = 0; 1462 1463 if (MEGASAS_IS_LOGICAL(scmd) && 1464 (scmd->device->id >= MEGASAS_MAX_LD || scmd->device->lun)) { 1465 scmd->result = DID_BAD_TARGET << 16; 1466 goto out_done; 1467 } 1468 1469 switch (scmd->cmnd[0]) { 1470 case SYNCHRONIZE_CACHE: 1471 /* 1472 * FW takes care of flush cache on its own 1473 * No need to send it down 1474 */ 1475 scmd->result = DID_OK << 16; 1476 goto out_done; 1477 default: 1478 break; 1479 } 1480 1481 if (instance->instancet->build_and_issue_cmd(instance, scmd)) { 1482 printk(KERN_ERR "megasas: Err returned from build_and_issue_cmd\n"); 1483 return SCSI_MLQUEUE_HOST_BUSY; 1484 } 1485 1486 return 0; 1487 1488 out_done: 1489 done(scmd); 1490 return 0; 1491 } 1492 1493 static DEF_SCSI_QCMD(megasas_queue_command) 1494 1495 static struct megasas_instance *megasas_lookup_instance(u16 host_no) 1496 { 1497 int i; 1498 1499 for (i = 0; i < megasas_mgmt_info.max_index; i++) { 1500 1501 if ((megasas_mgmt_info.instance[i]) && 1502 (megasas_mgmt_info.instance[i]->host->host_no == host_no)) 1503 return megasas_mgmt_info.instance[i]; 1504 } 1505 1506 return NULL; 1507 } 1508 1509 static int megasas_slave_configure(struct scsi_device *sdev) 1510 { 1511 u16 pd_index = 0; 1512 struct megasas_instance *instance ; 1513 1514 instance = megasas_lookup_instance(sdev->host->host_no); 1515 1516 /* 1517 * Don't export physical disk devices to the disk driver. 1518 * 1519 * FIXME: Currently we don't export them to the midlayer at all. 1520 * That will be fixed once LSI engineers have audited the 1521 * firmware for possible issues. 1522 */ 1523 if (sdev->channel < MEGASAS_MAX_PD_CHANNELS && 1524 sdev->type == TYPE_DISK) { 1525 pd_index = (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) + 1526 sdev->id; 1527 if (instance->pd_list[pd_index].driveState == 1528 MR_PD_STATE_SYSTEM) { 1529 blk_queue_rq_timeout(sdev->request_queue, 1530 MEGASAS_DEFAULT_CMD_TIMEOUT * HZ); 1531 return 0; 1532 } 1533 return -ENXIO; 1534 } 1535 1536 /* 1537 * The RAID firmware may require extended timeouts. 1538 */ 1539 blk_queue_rq_timeout(sdev->request_queue, 1540 MEGASAS_DEFAULT_CMD_TIMEOUT * HZ); 1541 return 0; 1542 } 1543 1544 static int megasas_slave_alloc(struct scsi_device *sdev) 1545 { 1546 u16 pd_index = 0; 1547 struct megasas_instance *instance ; 1548 instance = megasas_lookup_instance(sdev->host->host_no); 1549 if ((sdev->channel < MEGASAS_MAX_PD_CHANNELS) && 1550 (sdev->type == TYPE_DISK)) { 1551 /* 1552 * Open the OS scan to the SYSTEM PD 1553 */ 1554 pd_index = 1555 (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) + 1556 sdev->id; 1557 if ((instance->pd_list[pd_index].driveState == 1558 MR_PD_STATE_SYSTEM) && 1559 (instance->pd_list[pd_index].driveType == 1560 TYPE_DISK)) { 1561 return 0; 1562 } 1563 return -ENXIO; 1564 } 1565 return 0; 1566 } 1567 1568 void megaraid_sas_kill_hba(struct megasas_instance *instance) 1569 { 1570 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) || 1571 (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) || 1572 (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION)) { 1573 writel(MFI_STOP_ADP, &instance->reg_set->doorbell); 1574 } else { 1575 writel(MFI_STOP_ADP, &instance->reg_set->inbound_doorbell); 1576 } 1577 } 1578 1579 /** 1580 * megasas_check_and_restore_queue_depth - Check if queue depth needs to be 1581 * restored to max value 1582 * @instance: Adapter soft state 1583 * 1584 */ 1585 void 1586 megasas_check_and_restore_queue_depth(struct megasas_instance *instance) 1587 { 1588 unsigned long flags; 1589 if (instance->flag & MEGASAS_FW_BUSY 1590 && time_after(jiffies, instance->last_time + 5 * HZ) 1591 && atomic_read(&instance->fw_outstanding) < 17) { 1592 1593 spin_lock_irqsave(instance->host->host_lock, flags); 1594 instance->flag &= ~MEGASAS_FW_BUSY; 1595 if ((instance->pdev->device == 1596 PCI_DEVICE_ID_LSI_SAS0073SKINNY) || 1597 (instance->pdev->device == 1598 PCI_DEVICE_ID_LSI_SAS0071SKINNY)) { 1599 instance->host->can_queue = 1600 instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS; 1601 } else 1602 instance->host->can_queue = 1603 instance->max_fw_cmds - MEGASAS_INT_CMDS; 1604 1605 spin_unlock_irqrestore(instance->host->host_lock, flags); 1606 } 1607 } 1608 1609 /** 1610 * megasas_complete_cmd_dpc - Returns FW's controller structure 1611 * @instance_addr: Address of adapter soft state 1612 * 1613 * Tasklet to complete cmds 1614 */ 1615 static void megasas_complete_cmd_dpc(unsigned long instance_addr) 1616 { 1617 u32 producer; 1618 u32 consumer; 1619 u32 context; 1620 struct megasas_cmd *cmd; 1621 struct megasas_instance *instance = 1622 (struct megasas_instance *)instance_addr; 1623 unsigned long flags; 1624 1625 /* If we have already declared adapter dead, donot complete cmds */ 1626 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR ) 1627 return; 1628 1629 spin_lock_irqsave(&instance->completion_lock, flags); 1630 1631 producer = *instance->producer; 1632 consumer = *instance->consumer; 1633 1634 while (consumer != producer) { 1635 context = instance->reply_queue[consumer]; 1636 if (context >= instance->max_fw_cmds) { 1637 printk(KERN_ERR "Unexpected context value %x\n", 1638 context); 1639 BUG(); 1640 } 1641 1642 cmd = instance->cmd_list[context]; 1643 1644 megasas_complete_cmd(instance, cmd, DID_OK); 1645 1646 consumer++; 1647 if (consumer == (instance->max_fw_cmds + 1)) { 1648 consumer = 0; 1649 } 1650 } 1651 1652 *instance->consumer = producer; 1653 1654 spin_unlock_irqrestore(&instance->completion_lock, flags); 1655 1656 /* 1657 * Check if we can restore can_queue 1658 */ 1659 megasas_check_and_restore_queue_depth(instance); 1660 } 1661 1662 static void 1663 megasas_internal_reset_defer_cmds(struct megasas_instance *instance); 1664 1665 static void 1666 process_fw_state_change_wq(struct work_struct *work); 1667 1668 void megasas_do_ocr(struct megasas_instance *instance) 1669 { 1670 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) || 1671 (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) || 1672 (instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)) { 1673 *instance->consumer = MEGASAS_ADPRESET_INPROG_SIGN; 1674 } 1675 instance->instancet->disable_intr(instance->reg_set); 1676 instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT; 1677 instance->issuepend_done = 0; 1678 1679 atomic_set(&instance->fw_outstanding, 0); 1680 megasas_internal_reset_defer_cmds(instance); 1681 process_fw_state_change_wq(&instance->work_init); 1682 } 1683 1684 /** 1685 * megasas_wait_for_outstanding - Wait for all outstanding cmds 1686 * @instance: Adapter soft state 1687 * 1688 * This function waits for upto MEGASAS_RESET_WAIT_TIME seconds for FW to 1689 * complete all its outstanding commands. Returns error if one or more IOs 1690 * are pending after this time period. It also marks the controller dead. 1691 */ 1692 static int megasas_wait_for_outstanding(struct megasas_instance *instance) 1693 { 1694 int i; 1695 u32 reset_index; 1696 u32 wait_time = MEGASAS_RESET_WAIT_TIME; 1697 u8 adprecovery; 1698 unsigned long flags; 1699 struct list_head clist_local; 1700 struct megasas_cmd *reset_cmd; 1701 u32 fw_state; 1702 u8 kill_adapter_flag; 1703 1704 spin_lock_irqsave(&instance->hba_lock, flags); 1705 adprecovery = instance->adprecovery; 1706 spin_unlock_irqrestore(&instance->hba_lock, flags); 1707 1708 if (adprecovery != MEGASAS_HBA_OPERATIONAL) { 1709 1710 INIT_LIST_HEAD(&clist_local); 1711 spin_lock_irqsave(&instance->hba_lock, flags); 1712 list_splice_init(&instance->internal_reset_pending_q, 1713 &clist_local); 1714 spin_unlock_irqrestore(&instance->hba_lock, flags); 1715 1716 printk(KERN_NOTICE "megasas: HBA reset wait ...\n"); 1717 for (i = 0; i < wait_time; i++) { 1718 msleep(1000); 1719 spin_lock_irqsave(&instance->hba_lock, flags); 1720 adprecovery = instance->adprecovery; 1721 spin_unlock_irqrestore(&instance->hba_lock, flags); 1722 if (adprecovery == MEGASAS_HBA_OPERATIONAL) 1723 break; 1724 } 1725 1726 if (adprecovery != MEGASAS_HBA_OPERATIONAL) { 1727 printk(KERN_NOTICE "megasas: reset: Stopping HBA.\n"); 1728 spin_lock_irqsave(&instance->hba_lock, flags); 1729 instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR; 1730 spin_unlock_irqrestore(&instance->hba_lock, flags); 1731 return FAILED; 1732 } 1733 1734 reset_index = 0; 1735 while (!list_empty(&clist_local)) { 1736 reset_cmd = list_entry((&clist_local)->next, 1737 struct megasas_cmd, list); 1738 list_del_init(&reset_cmd->list); 1739 if (reset_cmd->scmd) { 1740 reset_cmd->scmd->result = DID_RESET << 16; 1741 printk(KERN_NOTICE "%d:%p reset [%02x], %#lx\n", 1742 reset_index, reset_cmd, 1743 reset_cmd->scmd->cmnd[0], 1744 reset_cmd->scmd->serial_number); 1745 1746 reset_cmd->scmd->scsi_done(reset_cmd->scmd); 1747 megasas_return_cmd(instance, reset_cmd); 1748 } else if (reset_cmd->sync_cmd) { 1749 printk(KERN_NOTICE "megasas:%p synch cmds" 1750 "reset queue\n", 1751 reset_cmd); 1752 1753 reset_cmd->cmd_status = ENODATA; 1754 instance->instancet->fire_cmd(instance, 1755 reset_cmd->frame_phys_addr, 1756 0, instance->reg_set); 1757 } else { 1758 printk(KERN_NOTICE "megasas: %p unexpected" 1759 "cmds lst\n", 1760 reset_cmd); 1761 } 1762 reset_index++; 1763 } 1764 1765 return SUCCESS; 1766 } 1767 1768 for (i = 0; i < wait_time; i++) { 1769 1770 int outstanding = atomic_read(&instance->fw_outstanding); 1771 1772 if (!outstanding) 1773 break; 1774 1775 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) { 1776 printk(KERN_NOTICE "megasas: [%2d]waiting for %d " 1777 "commands to complete\n",i,outstanding); 1778 /* 1779 * Call cmd completion routine. Cmd to be 1780 * be completed directly without depending on isr. 1781 */ 1782 megasas_complete_cmd_dpc((unsigned long)instance); 1783 } 1784 1785 msleep(1000); 1786 } 1787 1788 i = 0; 1789 kill_adapter_flag = 0; 1790 do { 1791 fw_state = instance->instancet->read_fw_status_reg( 1792 instance->reg_set) & MFI_STATE_MASK; 1793 if ((fw_state == MFI_STATE_FAULT) && 1794 (instance->disableOnlineCtrlReset == 0)) { 1795 if (i == 3) { 1796 kill_adapter_flag = 2; 1797 break; 1798 } 1799 megasas_do_ocr(instance); 1800 kill_adapter_flag = 1; 1801 1802 /* wait for 1 secs to let FW finish the pending cmds */ 1803 msleep(1000); 1804 } 1805 i++; 1806 } while (i <= 3); 1807 1808 if (atomic_read(&instance->fw_outstanding) && 1809 !kill_adapter_flag) { 1810 if (instance->disableOnlineCtrlReset == 0) { 1811 1812 megasas_do_ocr(instance); 1813 1814 /* wait for 5 secs to let FW finish the pending cmds */ 1815 for (i = 0; i < wait_time; i++) { 1816 int outstanding = 1817 atomic_read(&instance->fw_outstanding); 1818 if (!outstanding) 1819 return SUCCESS; 1820 msleep(1000); 1821 } 1822 } 1823 } 1824 1825 if (atomic_read(&instance->fw_outstanding) || 1826 (kill_adapter_flag == 2)) { 1827 printk(KERN_NOTICE "megaraid_sas: pending cmds after reset\n"); 1828 /* 1829 * Send signal to FW to stop processing any pending cmds. 1830 * The controller will be taken offline by the OS now. 1831 */ 1832 if ((instance->pdev->device == 1833 PCI_DEVICE_ID_LSI_SAS0073SKINNY) || 1834 (instance->pdev->device == 1835 PCI_DEVICE_ID_LSI_SAS0071SKINNY)) { 1836 writel(MFI_STOP_ADP, 1837 &instance->reg_set->doorbell); 1838 } else { 1839 writel(MFI_STOP_ADP, 1840 &instance->reg_set->inbound_doorbell); 1841 } 1842 megasas_dump_pending_frames(instance); 1843 spin_lock_irqsave(&instance->hba_lock, flags); 1844 instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR; 1845 spin_unlock_irqrestore(&instance->hba_lock, flags); 1846 return FAILED; 1847 } 1848 1849 printk(KERN_NOTICE "megaraid_sas: no pending cmds after reset\n"); 1850 1851 return SUCCESS; 1852 } 1853 1854 /** 1855 * megasas_generic_reset - Generic reset routine 1856 * @scmd: Mid-layer SCSI command 1857 * 1858 * This routine implements a generic reset handler for device, bus and host 1859 * reset requests. Device, bus and host specific reset handlers can use this 1860 * function after they do their specific tasks. 1861 */ 1862 static int megasas_generic_reset(struct scsi_cmnd *scmd) 1863 { 1864 int ret_val; 1865 struct megasas_instance *instance; 1866 1867 instance = (struct megasas_instance *)scmd->device->host->hostdata; 1868 1869 scmd_printk(KERN_NOTICE, scmd, "megasas: RESET -%ld cmd=%x retries=%x\n", 1870 scmd->serial_number, scmd->cmnd[0], scmd->retries); 1871 1872 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) { 1873 printk(KERN_ERR "megasas: cannot recover from previous reset " 1874 "failures\n"); 1875 return FAILED; 1876 } 1877 1878 ret_val = megasas_wait_for_outstanding(instance); 1879 if (ret_val == SUCCESS) 1880 printk(KERN_NOTICE "megasas: reset successful \n"); 1881 else 1882 printk(KERN_ERR "megasas: failed to do reset\n"); 1883 1884 return ret_val; 1885 } 1886 1887 /** 1888 * megasas_reset_timer - quiesce the adapter if required 1889 * @scmd: scsi cmnd 1890 * 1891 * Sets the FW busy flag and reduces the host->can_queue if the 1892 * cmd has not been completed within the timeout period. 1893 */ 1894 static enum 1895 blk_eh_timer_return megasas_reset_timer(struct scsi_cmnd *scmd) 1896 { 1897 struct megasas_cmd *cmd = (struct megasas_cmd *)scmd->SCp.ptr; 1898 struct megasas_instance *instance; 1899 unsigned long flags; 1900 1901 if (time_after(jiffies, scmd->jiffies_at_alloc + 1902 (MEGASAS_DEFAULT_CMD_TIMEOUT * 2) * HZ)) { 1903 return BLK_EH_NOT_HANDLED; 1904 } 1905 1906 instance = cmd->instance; 1907 if (!(instance->flag & MEGASAS_FW_BUSY)) { 1908 /* FW is busy, throttle IO */ 1909 spin_lock_irqsave(instance->host->host_lock, flags); 1910 1911 instance->host->can_queue = 16; 1912 instance->last_time = jiffies; 1913 instance->flag |= MEGASAS_FW_BUSY; 1914 1915 spin_unlock_irqrestore(instance->host->host_lock, flags); 1916 } 1917 return BLK_EH_RESET_TIMER; 1918 } 1919 1920 /** 1921 * megasas_reset_device - Device reset handler entry point 1922 */ 1923 static int megasas_reset_device(struct scsi_cmnd *scmd) 1924 { 1925 int ret; 1926 1927 /* 1928 * First wait for all commands to complete 1929 */ 1930 ret = megasas_generic_reset(scmd); 1931 1932 return ret; 1933 } 1934 1935 /** 1936 * megasas_reset_bus_host - Bus & host reset handler entry point 1937 */ 1938 static int megasas_reset_bus_host(struct scsi_cmnd *scmd) 1939 { 1940 int ret; 1941 struct megasas_instance *instance; 1942 instance = (struct megasas_instance *)scmd->device->host->hostdata; 1943 1944 /* 1945 * First wait for all commands to complete 1946 */ 1947 if (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) 1948 ret = megasas_reset_fusion(scmd->device->host); 1949 else 1950 ret = megasas_generic_reset(scmd); 1951 1952 return ret; 1953 } 1954 1955 /** 1956 * megasas_bios_param - Returns disk geometry for a disk 1957 * @sdev: device handle 1958 * @bdev: block device 1959 * @capacity: drive capacity 1960 * @geom: geometry parameters 1961 */ 1962 static int 1963 megasas_bios_param(struct scsi_device *sdev, struct block_device *bdev, 1964 sector_t capacity, int geom[]) 1965 { 1966 int heads; 1967 int sectors; 1968 sector_t cylinders; 1969 unsigned long tmp; 1970 /* Default heads (64) & sectors (32) */ 1971 heads = 64; 1972 sectors = 32; 1973 1974 tmp = heads * sectors; 1975 cylinders = capacity; 1976 1977 sector_div(cylinders, tmp); 1978 1979 /* 1980 * Handle extended translation size for logical drives > 1Gb 1981 */ 1982 1983 if (capacity >= 0x200000) { 1984 heads = 255; 1985 sectors = 63; 1986 tmp = heads*sectors; 1987 cylinders = capacity; 1988 sector_div(cylinders, tmp); 1989 } 1990 1991 geom[0] = heads; 1992 geom[1] = sectors; 1993 geom[2] = cylinders; 1994 1995 return 0; 1996 } 1997 1998 static void megasas_aen_polling(struct work_struct *work); 1999 2000 /** 2001 * megasas_service_aen - Processes an event notification 2002 * @instance: Adapter soft state 2003 * @cmd: AEN command completed by the ISR 2004 * 2005 * For AEN, driver sends a command down to FW that is held by the FW till an 2006 * event occurs. When an event of interest occurs, FW completes the command 2007 * that it was previously holding. 2008 * 2009 * This routines sends SIGIO signal to processes that have registered with the 2010 * driver for AEN. 2011 */ 2012 static void 2013 megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd) 2014 { 2015 unsigned long flags; 2016 /* 2017 * Don't signal app if it is just an aborted previously registered aen 2018 */ 2019 if ((!cmd->abort_aen) && (instance->unload == 0)) { 2020 spin_lock_irqsave(&poll_aen_lock, flags); 2021 megasas_poll_wait_aen = 1; 2022 spin_unlock_irqrestore(&poll_aen_lock, flags); 2023 wake_up(&megasas_poll_wait); 2024 kill_fasync(&megasas_async_queue, SIGIO, POLL_IN); 2025 } 2026 else 2027 cmd->abort_aen = 0; 2028 2029 instance->aen_cmd = NULL; 2030 megasas_return_cmd(instance, cmd); 2031 2032 if ((instance->unload == 0) && 2033 ((instance->issuepend_done == 1))) { 2034 struct megasas_aen_event *ev; 2035 ev = kzalloc(sizeof(*ev), GFP_ATOMIC); 2036 if (!ev) { 2037 printk(KERN_ERR "megasas_service_aen: out of memory\n"); 2038 } else { 2039 ev->instance = instance; 2040 instance->ev = ev; 2041 INIT_WORK(&ev->hotplug_work, megasas_aen_polling); 2042 schedule_delayed_work( 2043 (struct delayed_work *)&ev->hotplug_work, 0); 2044 } 2045 } 2046 } 2047 2048 /* 2049 * Scsi host template for megaraid_sas driver 2050 */ 2051 static struct scsi_host_template megasas_template = { 2052 2053 .module = THIS_MODULE, 2054 .name = "LSI SAS based MegaRAID driver", 2055 .proc_name = "megaraid_sas", 2056 .slave_configure = megasas_slave_configure, 2057 .slave_alloc = megasas_slave_alloc, 2058 .queuecommand = megasas_queue_command, 2059 .eh_device_reset_handler = megasas_reset_device, 2060 .eh_bus_reset_handler = megasas_reset_bus_host, 2061 .eh_host_reset_handler = megasas_reset_bus_host, 2062 .eh_timed_out = megasas_reset_timer, 2063 .bios_param = megasas_bios_param, 2064 .use_clustering = ENABLE_CLUSTERING, 2065 }; 2066 2067 /** 2068 * megasas_complete_int_cmd - Completes an internal command 2069 * @instance: Adapter soft state 2070 * @cmd: Command to be completed 2071 * 2072 * The megasas_issue_blocked_cmd() function waits for a command to complete 2073 * after it issues a command. This function wakes up that waiting routine by 2074 * calling wake_up() on the wait queue. 2075 */ 2076 static void 2077 megasas_complete_int_cmd(struct megasas_instance *instance, 2078 struct megasas_cmd *cmd) 2079 { 2080 cmd->cmd_status = cmd->frame->io.cmd_status; 2081 2082 if (cmd->cmd_status == ENODATA) { 2083 cmd->cmd_status = 0; 2084 } 2085 wake_up(&instance->int_cmd_wait_q); 2086 } 2087 2088 /** 2089 * megasas_complete_abort - Completes aborting a command 2090 * @instance: Adapter soft state 2091 * @cmd: Cmd that was issued to abort another cmd 2092 * 2093 * The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q 2094 * after it issues an abort on a previously issued command. This function 2095 * wakes up all functions waiting on the same wait queue. 2096 */ 2097 static void 2098 megasas_complete_abort(struct megasas_instance *instance, 2099 struct megasas_cmd *cmd) 2100 { 2101 if (cmd->sync_cmd) { 2102 cmd->sync_cmd = 0; 2103 cmd->cmd_status = 0; 2104 wake_up(&instance->abort_cmd_wait_q); 2105 } 2106 2107 return; 2108 } 2109 2110 /** 2111 * megasas_complete_cmd - Completes a command 2112 * @instance: Adapter soft state 2113 * @cmd: Command to be completed 2114 * @alt_status: If non-zero, use this value as status to 2115 * SCSI mid-layer instead of the value returned 2116 * by the FW. This should be used if caller wants 2117 * an alternate status (as in the case of aborted 2118 * commands) 2119 */ 2120 void 2121 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd, 2122 u8 alt_status) 2123 { 2124 int exception = 0; 2125 struct megasas_header *hdr = &cmd->frame->hdr; 2126 unsigned long flags; 2127 struct fusion_context *fusion = instance->ctrl_context; 2128 2129 /* flag for the retry reset */ 2130 cmd->retry_for_fw_reset = 0; 2131 2132 if (cmd->scmd) 2133 cmd->scmd->SCp.ptr = NULL; 2134 2135 switch (hdr->cmd) { 2136 2137 case MFI_CMD_PD_SCSI_IO: 2138 case MFI_CMD_LD_SCSI_IO: 2139 2140 /* 2141 * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been 2142 * issued either through an IO path or an IOCTL path. If it 2143 * was via IOCTL, we will send it to internal completion. 2144 */ 2145 if (cmd->sync_cmd) { 2146 cmd->sync_cmd = 0; 2147 megasas_complete_int_cmd(instance, cmd); 2148 break; 2149 } 2150 2151 case MFI_CMD_LD_READ: 2152 case MFI_CMD_LD_WRITE: 2153 2154 if (alt_status) { 2155 cmd->scmd->result = alt_status << 16; 2156 exception = 1; 2157 } 2158 2159 if (exception) { 2160 2161 atomic_dec(&instance->fw_outstanding); 2162 2163 scsi_dma_unmap(cmd->scmd); 2164 cmd->scmd->scsi_done(cmd->scmd); 2165 megasas_return_cmd(instance, cmd); 2166 2167 break; 2168 } 2169 2170 switch (hdr->cmd_status) { 2171 2172 case MFI_STAT_OK: 2173 cmd->scmd->result = DID_OK << 16; 2174 break; 2175 2176 case MFI_STAT_SCSI_IO_FAILED: 2177 case MFI_STAT_LD_INIT_IN_PROGRESS: 2178 cmd->scmd->result = 2179 (DID_ERROR << 16) | hdr->scsi_status; 2180 break; 2181 2182 case MFI_STAT_SCSI_DONE_WITH_ERROR: 2183 2184 cmd->scmd->result = (DID_OK << 16) | hdr->scsi_status; 2185 2186 if (hdr->scsi_status == SAM_STAT_CHECK_CONDITION) { 2187 memset(cmd->scmd->sense_buffer, 0, 2188 SCSI_SENSE_BUFFERSIZE); 2189 memcpy(cmd->scmd->sense_buffer, cmd->sense, 2190 hdr->sense_len); 2191 2192 cmd->scmd->result |= DRIVER_SENSE << 24; 2193 } 2194 2195 break; 2196 2197 case MFI_STAT_LD_OFFLINE: 2198 case MFI_STAT_DEVICE_NOT_FOUND: 2199 cmd->scmd->result = DID_BAD_TARGET << 16; 2200 break; 2201 2202 default: 2203 printk(KERN_DEBUG "megasas: MFI FW status %#x\n", 2204 hdr->cmd_status); 2205 cmd->scmd->result = DID_ERROR << 16; 2206 break; 2207 } 2208 2209 atomic_dec(&instance->fw_outstanding); 2210 2211 scsi_dma_unmap(cmd->scmd); 2212 cmd->scmd->scsi_done(cmd->scmd); 2213 megasas_return_cmd(instance, cmd); 2214 2215 break; 2216 2217 case MFI_CMD_SMP: 2218 case MFI_CMD_STP: 2219 case MFI_CMD_DCMD: 2220 /* Check for LD map update */ 2221 if ((cmd->frame->dcmd.opcode == MR_DCMD_LD_MAP_GET_INFO) && 2222 (cmd->frame->dcmd.mbox.b[1] == 1)) { 2223 spin_lock_irqsave(instance->host->host_lock, flags); 2224 if (cmd->frame->hdr.cmd_status != 0) { 2225 if (cmd->frame->hdr.cmd_status != 2226 MFI_STAT_NOT_FOUND) 2227 printk(KERN_WARNING "megasas: map sync" 2228 "failed, status = 0x%x.\n", 2229 cmd->frame->hdr.cmd_status); 2230 else { 2231 megasas_return_cmd(instance, cmd); 2232 spin_unlock_irqrestore( 2233 instance->host->host_lock, 2234 flags); 2235 break; 2236 } 2237 } else 2238 instance->map_id++; 2239 megasas_return_cmd(instance, cmd); 2240 if (MR_ValidateMapInfo( 2241 fusion->ld_map[(instance->map_id & 1)], 2242 fusion->load_balance_info)) 2243 fusion->fast_path_io = 1; 2244 else 2245 fusion->fast_path_io = 0; 2246 megasas_sync_map_info(instance); 2247 spin_unlock_irqrestore(instance->host->host_lock, 2248 flags); 2249 break; 2250 } 2251 if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET_INFO || 2252 cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET) { 2253 spin_lock_irqsave(&poll_aen_lock, flags); 2254 megasas_poll_wait_aen = 0; 2255 spin_unlock_irqrestore(&poll_aen_lock, flags); 2256 } 2257 2258 /* 2259 * See if got an event notification 2260 */ 2261 if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_WAIT) 2262 megasas_service_aen(instance, cmd); 2263 else 2264 megasas_complete_int_cmd(instance, cmd); 2265 2266 break; 2267 2268 case MFI_CMD_ABORT: 2269 /* 2270 * Cmd issued to abort another cmd returned 2271 */ 2272 megasas_complete_abort(instance, cmd); 2273 break; 2274 2275 default: 2276 printk("megasas: Unknown command completed! [0x%X]\n", 2277 hdr->cmd); 2278 break; 2279 } 2280 } 2281 2282 /** 2283 * megasas_issue_pending_cmds_again - issue all pending cmds 2284 * in FW again because of the fw reset 2285 * @instance: Adapter soft state 2286 */ 2287 static inline void 2288 megasas_issue_pending_cmds_again(struct megasas_instance *instance) 2289 { 2290 struct megasas_cmd *cmd; 2291 struct list_head clist_local; 2292 union megasas_evt_class_locale class_locale; 2293 unsigned long flags; 2294 u32 seq_num; 2295 2296 INIT_LIST_HEAD(&clist_local); 2297 spin_lock_irqsave(&instance->hba_lock, flags); 2298 list_splice_init(&instance->internal_reset_pending_q, &clist_local); 2299 spin_unlock_irqrestore(&instance->hba_lock, flags); 2300 2301 while (!list_empty(&clist_local)) { 2302 cmd = list_entry((&clist_local)->next, 2303 struct megasas_cmd, list); 2304 list_del_init(&cmd->list); 2305 2306 if (cmd->sync_cmd || cmd->scmd) { 2307 printk(KERN_NOTICE "megaraid_sas: command %p, %p:%d" 2308 "detected to be pending while HBA reset.\n", 2309 cmd, cmd->scmd, cmd->sync_cmd); 2310 2311 cmd->retry_for_fw_reset++; 2312 2313 if (cmd->retry_for_fw_reset == 3) { 2314 printk(KERN_NOTICE "megaraid_sas: cmd %p, %p:%d" 2315 "was tried multiple times during reset." 2316 "Shutting down the HBA\n", 2317 cmd, cmd->scmd, cmd->sync_cmd); 2318 megaraid_sas_kill_hba(instance); 2319 2320 instance->adprecovery = 2321 MEGASAS_HW_CRITICAL_ERROR; 2322 return; 2323 } 2324 } 2325 2326 if (cmd->sync_cmd == 1) { 2327 if (cmd->scmd) { 2328 printk(KERN_NOTICE "megaraid_sas: unexpected" 2329 "cmd attached to internal command!\n"); 2330 } 2331 printk(KERN_NOTICE "megasas: %p synchronous cmd" 2332 "on the internal reset queue," 2333 "issue it again.\n", cmd); 2334 cmd->cmd_status = ENODATA; 2335 instance->instancet->fire_cmd(instance, 2336 cmd->frame_phys_addr , 2337 0, instance->reg_set); 2338 } else if (cmd->scmd) { 2339 printk(KERN_NOTICE "megasas: %p scsi cmd [%02x],%#lx" 2340 "detected on the internal queue, issue again.\n", 2341 cmd, cmd->scmd->cmnd[0], cmd->scmd->serial_number); 2342 2343 atomic_inc(&instance->fw_outstanding); 2344 instance->instancet->fire_cmd(instance, 2345 cmd->frame_phys_addr, 2346 cmd->frame_count-1, instance->reg_set); 2347 } else { 2348 printk(KERN_NOTICE "megasas: %p unexpected cmd on the" 2349 "internal reset defer list while re-issue!!\n", 2350 cmd); 2351 } 2352 } 2353 2354 if (instance->aen_cmd) { 2355 printk(KERN_NOTICE "megaraid_sas: aen_cmd in def process\n"); 2356 megasas_return_cmd(instance, instance->aen_cmd); 2357 2358 instance->aen_cmd = NULL; 2359 } 2360 2361 /* 2362 * Initiate AEN (Asynchronous Event Notification) 2363 */ 2364 seq_num = instance->last_seq_num; 2365 class_locale.members.reserved = 0; 2366 class_locale.members.locale = MR_EVT_LOCALE_ALL; 2367 class_locale.members.class = MR_EVT_CLASS_DEBUG; 2368 2369 megasas_register_aen(instance, seq_num, class_locale.word); 2370 } 2371 2372 /** 2373 * Move the internal reset pending commands to a deferred queue. 2374 * 2375 * We move the commands pending at internal reset time to a 2376 * pending queue. This queue would be flushed after successful 2377 * completion of the internal reset sequence. if the internal reset 2378 * did not complete in time, the kernel reset handler would flush 2379 * these commands. 2380 **/ 2381 static void 2382 megasas_internal_reset_defer_cmds(struct megasas_instance *instance) 2383 { 2384 struct megasas_cmd *cmd; 2385 int i; 2386 u32 max_cmd = instance->max_fw_cmds; 2387 u32 defer_index; 2388 unsigned long flags; 2389 2390 defer_index = 0; 2391 spin_lock_irqsave(&instance->cmd_pool_lock, flags); 2392 for (i = 0; i < max_cmd; i++) { 2393 cmd = instance->cmd_list[i]; 2394 if (cmd->sync_cmd == 1 || cmd->scmd) { 2395 printk(KERN_NOTICE "megasas: moving cmd[%d]:%p:%d:%p" 2396 "on the defer queue as internal\n", 2397 defer_index, cmd, cmd->sync_cmd, cmd->scmd); 2398 2399 if (!list_empty(&cmd->list)) { 2400 printk(KERN_NOTICE "megaraid_sas: ERROR while" 2401 " moving this cmd:%p, %d %p, it was" 2402 "discovered on some list?\n", 2403 cmd, cmd->sync_cmd, cmd->scmd); 2404 2405 list_del_init(&cmd->list); 2406 } 2407 defer_index++; 2408 list_add_tail(&cmd->list, 2409 &instance->internal_reset_pending_q); 2410 } 2411 } 2412 spin_unlock_irqrestore(&instance->cmd_pool_lock, flags); 2413 } 2414 2415 2416 static void 2417 process_fw_state_change_wq(struct work_struct *work) 2418 { 2419 struct megasas_instance *instance = 2420 container_of(work, struct megasas_instance, work_init); 2421 u32 wait; 2422 unsigned long flags; 2423 2424 if (instance->adprecovery != MEGASAS_ADPRESET_SM_INFAULT) { 2425 printk(KERN_NOTICE "megaraid_sas: error, recovery st %x \n", 2426 instance->adprecovery); 2427 return ; 2428 } 2429 2430 if (instance->adprecovery == MEGASAS_ADPRESET_SM_INFAULT) { 2431 printk(KERN_NOTICE "megaraid_sas: FW detected to be in fault" 2432 "state, restarting it...\n"); 2433 2434 instance->instancet->disable_intr(instance->reg_set); 2435 atomic_set(&instance->fw_outstanding, 0); 2436 2437 atomic_set(&instance->fw_reset_no_pci_access, 1); 2438 instance->instancet->adp_reset(instance, instance->reg_set); 2439 atomic_set(&instance->fw_reset_no_pci_access, 0 ); 2440 2441 printk(KERN_NOTICE "megaraid_sas: FW restarted successfully," 2442 "initiating next stage...\n"); 2443 2444 printk(KERN_NOTICE "megaraid_sas: HBA recovery state machine," 2445 "state 2 starting...\n"); 2446 2447 /*waitting for about 20 second before start the second init*/ 2448 for (wait = 0; wait < 30; wait++) { 2449 msleep(1000); 2450 } 2451 2452 if (megasas_transition_to_ready(instance)) { 2453 printk(KERN_NOTICE "megaraid_sas:adapter not ready\n"); 2454 2455 megaraid_sas_kill_hba(instance); 2456 instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR; 2457 return ; 2458 } 2459 2460 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) || 2461 (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) || 2462 (instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR) 2463 ) { 2464 *instance->consumer = *instance->producer; 2465 } else { 2466 *instance->consumer = 0; 2467 *instance->producer = 0; 2468 } 2469 2470 megasas_issue_init_mfi(instance); 2471 2472 spin_lock_irqsave(&instance->hba_lock, flags); 2473 instance->adprecovery = MEGASAS_HBA_OPERATIONAL; 2474 spin_unlock_irqrestore(&instance->hba_lock, flags); 2475 instance->instancet->enable_intr(instance->reg_set); 2476 2477 megasas_issue_pending_cmds_again(instance); 2478 instance->issuepend_done = 1; 2479 } 2480 return ; 2481 } 2482 2483 /** 2484 * megasas_deplete_reply_queue - Processes all completed commands 2485 * @instance: Adapter soft state 2486 * @alt_status: Alternate status to be returned to 2487 * SCSI mid-layer instead of the status 2488 * returned by the FW 2489 * Note: this must be called with hba lock held 2490 */ 2491 static int 2492 megasas_deplete_reply_queue(struct megasas_instance *instance, 2493 u8 alt_status) 2494 { 2495 u32 mfiStatus; 2496 u32 fw_state; 2497 2498 if ((mfiStatus = instance->instancet->check_reset(instance, 2499 instance->reg_set)) == 1) { 2500 return IRQ_HANDLED; 2501 } 2502 2503 if ((mfiStatus = instance->instancet->clear_intr( 2504 instance->reg_set) 2505 ) == 0) { 2506 return IRQ_NONE; 2507 } 2508 2509 instance->mfiStatus = mfiStatus; 2510 2511 if ((mfiStatus & MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE)) { 2512 fw_state = instance->instancet->read_fw_status_reg( 2513 instance->reg_set) & MFI_STATE_MASK; 2514 2515 if (fw_state != MFI_STATE_FAULT) { 2516 printk(KERN_NOTICE "megaraid_sas: fw state:%x\n", 2517 fw_state); 2518 } 2519 2520 if ((fw_state == MFI_STATE_FAULT) && 2521 (instance->disableOnlineCtrlReset == 0)) { 2522 printk(KERN_NOTICE "megaraid_sas: wait adp restart\n"); 2523 2524 if ((instance->pdev->device == 2525 PCI_DEVICE_ID_LSI_SAS1064R) || 2526 (instance->pdev->device == 2527 PCI_DEVICE_ID_DELL_PERC5) || 2528 (instance->pdev->device == 2529 PCI_DEVICE_ID_LSI_VERDE_ZCR)) { 2530 2531 *instance->consumer = 2532 MEGASAS_ADPRESET_INPROG_SIGN; 2533 } 2534 2535 2536 instance->instancet->disable_intr(instance->reg_set); 2537 instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT; 2538 instance->issuepend_done = 0; 2539 2540 atomic_set(&instance->fw_outstanding, 0); 2541 megasas_internal_reset_defer_cmds(instance); 2542 2543 printk(KERN_NOTICE "megasas: fwState=%x, stage:%d\n", 2544 fw_state, instance->adprecovery); 2545 2546 schedule_work(&instance->work_init); 2547 return IRQ_HANDLED; 2548 2549 } else { 2550 printk(KERN_NOTICE "megasas: fwstate:%x, dis_OCR=%x\n", 2551 fw_state, instance->disableOnlineCtrlReset); 2552 } 2553 } 2554 2555 tasklet_schedule(&instance->isr_tasklet); 2556 return IRQ_HANDLED; 2557 } 2558 /** 2559 * megasas_isr - isr entry point 2560 */ 2561 static irqreturn_t megasas_isr(int irq, void *devp) 2562 { 2563 struct megasas_instance *instance; 2564 unsigned long flags; 2565 irqreturn_t rc; 2566 2567 if (atomic_read( 2568 &(((struct megasas_instance *)devp)->fw_reset_no_pci_access))) 2569 return IRQ_HANDLED; 2570 2571 instance = (struct megasas_instance *)devp; 2572 2573 spin_lock_irqsave(&instance->hba_lock, flags); 2574 rc = megasas_deplete_reply_queue(instance, DID_OK); 2575 spin_unlock_irqrestore(&instance->hba_lock, flags); 2576 2577 return rc; 2578 } 2579 2580 /** 2581 * megasas_transition_to_ready - Move the FW to READY state 2582 * @instance: Adapter soft state 2583 * 2584 * During the initialization, FW passes can potentially be in any one of 2585 * several possible states. If the FW in operational, waiting-for-handshake 2586 * states, driver must take steps to bring it to ready state. Otherwise, it 2587 * has to wait for the ready state. 2588 */ 2589 int 2590 megasas_transition_to_ready(struct megasas_instance* instance) 2591 { 2592 int i; 2593 u8 max_wait; 2594 u32 fw_state; 2595 u32 cur_state; 2596 u32 abs_state, curr_abs_state; 2597 2598 fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) & MFI_STATE_MASK; 2599 2600 if (fw_state != MFI_STATE_READY) 2601 printk(KERN_INFO "megasas: Waiting for FW to come to ready" 2602 " state\n"); 2603 2604 while (fw_state != MFI_STATE_READY) { 2605 2606 abs_state = 2607 instance->instancet->read_fw_status_reg(instance->reg_set); 2608 2609 switch (fw_state) { 2610 2611 case MFI_STATE_FAULT: 2612 2613 printk(KERN_DEBUG "megasas: FW in FAULT state!!\n"); 2614 return -ENODEV; 2615 2616 case MFI_STATE_WAIT_HANDSHAKE: 2617 /* 2618 * Set the CLR bit in inbound doorbell 2619 */ 2620 if ((instance->pdev->device == 2621 PCI_DEVICE_ID_LSI_SAS0073SKINNY) || 2622 (instance->pdev->device == 2623 PCI_DEVICE_ID_LSI_SAS0071SKINNY) || 2624 (instance->pdev->device == 2625 PCI_DEVICE_ID_LSI_FUSION)) { 2626 writel( 2627 MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG, 2628 &instance->reg_set->doorbell); 2629 } else { 2630 writel( 2631 MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG, 2632 &instance->reg_set->inbound_doorbell); 2633 } 2634 2635 max_wait = MEGASAS_RESET_WAIT_TIME; 2636 cur_state = MFI_STATE_WAIT_HANDSHAKE; 2637 break; 2638 2639 case MFI_STATE_BOOT_MESSAGE_PENDING: 2640 if ((instance->pdev->device == 2641 PCI_DEVICE_ID_LSI_SAS0073SKINNY) || 2642 (instance->pdev->device == 2643 PCI_DEVICE_ID_LSI_SAS0071SKINNY) || 2644 (instance->pdev->device == 2645 PCI_DEVICE_ID_LSI_FUSION)) { 2646 writel(MFI_INIT_HOTPLUG, 2647 &instance->reg_set->doorbell); 2648 } else 2649 writel(MFI_INIT_HOTPLUG, 2650 &instance->reg_set->inbound_doorbell); 2651 2652 max_wait = MEGASAS_RESET_WAIT_TIME; 2653 cur_state = MFI_STATE_BOOT_MESSAGE_PENDING; 2654 break; 2655 2656 case MFI_STATE_OPERATIONAL: 2657 /* 2658 * Bring it to READY state; assuming max wait 10 secs 2659 */ 2660 instance->instancet->disable_intr(instance->reg_set); 2661 if ((instance->pdev->device == 2662 PCI_DEVICE_ID_LSI_SAS0073SKINNY) || 2663 (instance->pdev->device == 2664 PCI_DEVICE_ID_LSI_SAS0071SKINNY) || 2665 (instance->pdev->device 2666 == PCI_DEVICE_ID_LSI_FUSION)) { 2667 writel(MFI_RESET_FLAGS, 2668 &instance->reg_set->doorbell); 2669 if (instance->pdev->device == 2670 PCI_DEVICE_ID_LSI_FUSION) { 2671 for (i = 0; i < (10 * 1000); i += 20) { 2672 if (readl( 2673 &instance-> 2674 reg_set-> 2675 doorbell) & 1) 2676 msleep(20); 2677 else 2678 break; 2679 } 2680 } 2681 } else 2682 writel(MFI_RESET_FLAGS, 2683 &instance->reg_set->inbound_doorbell); 2684 2685 max_wait = MEGASAS_RESET_WAIT_TIME; 2686 cur_state = MFI_STATE_OPERATIONAL; 2687 break; 2688 2689 case MFI_STATE_UNDEFINED: 2690 /* 2691 * This state should not last for more than 2 seconds 2692 */ 2693 max_wait = MEGASAS_RESET_WAIT_TIME; 2694 cur_state = MFI_STATE_UNDEFINED; 2695 break; 2696 2697 case MFI_STATE_BB_INIT: 2698 max_wait = MEGASAS_RESET_WAIT_TIME; 2699 cur_state = MFI_STATE_BB_INIT; 2700 break; 2701 2702 case MFI_STATE_FW_INIT: 2703 max_wait = MEGASAS_RESET_WAIT_TIME; 2704 cur_state = MFI_STATE_FW_INIT; 2705 break; 2706 2707 case MFI_STATE_FW_INIT_2: 2708 max_wait = MEGASAS_RESET_WAIT_TIME; 2709 cur_state = MFI_STATE_FW_INIT_2; 2710 break; 2711 2712 case MFI_STATE_DEVICE_SCAN: 2713 max_wait = MEGASAS_RESET_WAIT_TIME; 2714 cur_state = MFI_STATE_DEVICE_SCAN; 2715 break; 2716 2717 case MFI_STATE_FLUSH_CACHE: 2718 max_wait = MEGASAS_RESET_WAIT_TIME; 2719 cur_state = MFI_STATE_FLUSH_CACHE; 2720 break; 2721 2722 default: 2723 printk(KERN_DEBUG "megasas: Unknown state 0x%x\n", 2724 fw_state); 2725 return -ENODEV; 2726 } 2727 2728 /* 2729 * The cur_state should not last for more than max_wait secs 2730 */ 2731 for (i = 0; i < (max_wait * 1000); i++) { 2732 fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) & 2733 MFI_STATE_MASK ; 2734 curr_abs_state = 2735 instance->instancet->read_fw_status_reg(instance->reg_set); 2736 2737 if (abs_state == curr_abs_state) { 2738 msleep(1); 2739 } else 2740 break; 2741 } 2742 2743 /* 2744 * Return error if fw_state hasn't changed after max_wait 2745 */ 2746 if (curr_abs_state == abs_state) { 2747 printk(KERN_DEBUG "FW state [%d] hasn't changed " 2748 "in %d secs\n", fw_state, max_wait); 2749 return -ENODEV; 2750 } 2751 } 2752 printk(KERN_INFO "megasas: FW now in Ready state\n"); 2753 2754 return 0; 2755 } 2756 2757 /** 2758 * megasas_teardown_frame_pool - Destroy the cmd frame DMA pool 2759 * @instance: Adapter soft state 2760 */ 2761 static void megasas_teardown_frame_pool(struct megasas_instance *instance) 2762 { 2763 int i; 2764 u32 max_cmd = instance->max_mfi_cmds; 2765 struct megasas_cmd *cmd; 2766 2767 if (!instance->frame_dma_pool) 2768 return; 2769 2770 /* 2771 * Return all frames to pool 2772 */ 2773 for (i = 0; i < max_cmd; i++) { 2774 2775 cmd = instance->cmd_list[i]; 2776 2777 if (cmd->frame) 2778 pci_pool_free(instance->frame_dma_pool, cmd->frame, 2779 cmd->frame_phys_addr); 2780 2781 if (cmd->sense) 2782 pci_pool_free(instance->sense_dma_pool, cmd->sense, 2783 cmd->sense_phys_addr); 2784 } 2785 2786 /* 2787 * Now destroy the pool itself 2788 */ 2789 pci_pool_destroy(instance->frame_dma_pool); 2790 pci_pool_destroy(instance->sense_dma_pool); 2791 2792 instance->frame_dma_pool = NULL; 2793 instance->sense_dma_pool = NULL; 2794 } 2795 2796 /** 2797 * megasas_create_frame_pool - Creates DMA pool for cmd frames 2798 * @instance: Adapter soft state 2799 * 2800 * Each command packet has an embedded DMA memory buffer that is used for 2801 * filling MFI frame and the SG list that immediately follows the frame. This 2802 * function creates those DMA memory buffers for each command packet by using 2803 * PCI pool facility. 2804 */ 2805 static int megasas_create_frame_pool(struct megasas_instance *instance) 2806 { 2807 int i; 2808 u32 max_cmd; 2809 u32 sge_sz; 2810 u32 sgl_sz; 2811 u32 total_sz; 2812 u32 frame_count; 2813 struct megasas_cmd *cmd; 2814 2815 max_cmd = instance->max_mfi_cmds; 2816 2817 /* 2818 * Size of our frame is 64 bytes for MFI frame, followed by max SG 2819 * elements and finally SCSI_SENSE_BUFFERSIZE bytes for sense buffer 2820 */ 2821 sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) : 2822 sizeof(struct megasas_sge32); 2823 2824 if (instance->flag_ieee) { 2825 sge_sz = sizeof(struct megasas_sge_skinny); 2826 } 2827 2828 /* 2829 * Calculated the number of 64byte frames required for SGL 2830 */ 2831 sgl_sz = sge_sz * instance->max_num_sge; 2832 frame_count = (sgl_sz + MEGAMFI_FRAME_SIZE - 1) / MEGAMFI_FRAME_SIZE; 2833 frame_count = 15; 2834 2835 /* 2836 * We need one extra frame for the MFI command 2837 */ 2838 frame_count++; 2839 2840 total_sz = MEGAMFI_FRAME_SIZE * frame_count; 2841 /* 2842 * Use DMA pool facility provided by PCI layer 2843 */ 2844 instance->frame_dma_pool = pci_pool_create("megasas frame pool", 2845 instance->pdev, total_sz, 64, 2846 0); 2847 2848 if (!instance->frame_dma_pool) { 2849 printk(KERN_DEBUG "megasas: failed to setup frame pool\n"); 2850 return -ENOMEM; 2851 } 2852 2853 instance->sense_dma_pool = pci_pool_create("megasas sense pool", 2854 instance->pdev, 128, 4, 0); 2855 2856 if (!instance->sense_dma_pool) { 2857 printk(KERN_DEBUG "megasas: failed to setup sense pool\n"); 2858 2859 pci_pool_destroy(instance->frame_dma_pool); 2860 instance->frame_dma_pool = NULL; 2861 2862 return -ENOMEM; 2863 } 2864 2865 /* 2866 * Allocate and attach a frame to each of the commands in cmd_list. 2867 * By making cmd->index as the context instead of the &cmd, we can 2868 * always use 32bit context regardless of the architecture 2869 */ 2870 for (i = 0; i < max_cmd; i++) { 2871 2872 cmd = instance->cmd_list[i]; 2873 2874 cmd->frame = pci_pool_alloc(instance->frame_dma_pool, 2875 GFP_KERNEL, &cmd->frame_phys_addr); 2876 2877 cmd->sense = pci_pool_alloc(instance->sense_dma_pool, 2878 GFP_KERNEL, &cmd->sense_phys_addr); 2879 2880 /* 2881 * megasas_teardown_frame_pool() takes care of freeing 2882 * whatever has been allocated 2883 */ 2884 if (!cmd->frame || !cmd->sense) { 2885 printk(KERN_DEBUG "megasas: pci_pool_alloc failed \n"); 2886 megasas_teardown_frame_pool(instance); 2887 return -ENOMEM; 2888 } 2889 2890 memset(cmd->frame, 0, total_sz); 2891 cmd->frame->io.context = cmd->index; 2892 cmd->frame->io.pad_0 = 0; 2893 } 2894 2895 return 0; 2896 } 2897 2898 /** 2899 * megasas_free_cmds - Free all the cmds in the free cmd pool 2900 * @instance: Adapter soft state 2901 */ 2902 void megasas_free_cmds(struct megasas_instance *instance) 2903 { 2904 int i; 2905 /* First free the MFI frame pool */ 2906 megasas_teardown_frame_pool(instance); 2907 2908 /* Free all the commands in the cmd_list */ 2909 for (i = 0; i < instance->max_mfi_cmds; i++) 2910 2911 kfree(instance->cmd_list[i]); 2912 2913 /* Free the cmd_list buffer itself */ 2914 kfree(instance->cmd_list); 2915 instance->cmd_list = NULL; 2916 2917 INIT_LIST_HEAD(&instance->cmd_pool); 2918 } 2919 2920 /** 2921 * megasas_alloc_cmds - Allocates the command packets 2922 * @instance: Adapter soft state 2923 * 2924 * Each command that is issued to the FW, whether IO commands from the OS or 2925 * internal commands like IOCTLs, are wrapped in local data structure called 2926 * megasas_cmd. The frame embedded in this megasas_cmd is actually issued to 2927 * the FW. 2928 * 2929 * Each frame has a 32-bit field called context (tag). This context is used 2930 * to get back the megasas_cmd from the frame when a frame gets completed in 2931 * the ISR. Typically the address of the megasas_cmd itself would be used as 2932 * the context. But we wanted to keep the differences between 32 and 64 bit 2933 * systems to the mininum. We always use 32 bit integers for the context. In 2934 * this driver, the 32 bit values are the indices into an array cmd_list. 2935 * This array is used only to look up the megasas_cmd given the context. The 2936 * free commands themselves are maintained in a linked list called cmd_pool. 2937 */ 2938 int megasas_alloc_cmds(struct megasas_instance *instance) 2939 { 2940 int i; 2941 int j; 2942 u32 max_cmd; 2943 struct megasas_cmd *cmd; 2944 2945 max_cmd = instance->max_mfi_cmds; 2946 2947 /* 2948 * instance->cmd_list is an array of struct megasas_cmd pointers. 2949 * Allocate the dynamic array first and then allocate individual 2950 * commands. 2951 */ 2952 instance->cmd_list = kcalloc(max_cmd, sizeof(struct megasas_cmd*), GFP_KERNEL); 2953 2954 if (!instance->cmd_list) { 2955 printk(KERN_DEBUG "megasas: out of memory\n"); 2956 return -ENOMEM; 2957 } 2958 2959 memset(instance->cmd_list, 0, sizeof(struct megasas_cmd *) *max_cmd); 2960 2961 for (i = 0; i < max_cmd; i++) { 2962 instance->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd), 2963 GFP_KERNEL); 2964 2965 if (!instance->cmd_list[i]) { 2966 2967 for (j = 0; j < i; j++) 2968 kfree(instance->cmd_list[j]); 2969 2970 kfree(instance->cmd_list); 2971 instance->cmd_list = NULL; 2972 2973 return -ENOMEM; 2974 } 2975 } 2976 2977 /* 2978 * Add all the commands to command pool (instance->cmd_pool) 2979 */ 2980 for (i = 0; i < max_cmd; i++) { 2981 cmd = instance->cmd_list[i]; 2982 memset(cmd, 0, sizeof(struct megasas_cmd)); 2983 cmd->index = i; 2984 cmd->scmd = NULL; 2985 cmd->instance = instance; 2986 2987 list_add_tail(&cmd->list, &instance->cmd_pool); 2988 } 2989 2990 /* 2991 * Create a frame pool and assign one frame to each cmd 2992 */ 2993 if (megasas_create_frame_pool(instance)) { 2994 printk(KERN_DEBUG "megasas: Error creating frame DMA pool\n"); 2995 megasas_free_cmds(instance); 2996 } 2997 2998 return 0; 2999 } 3000 3001 /* 3002 * megasas_get_pd_list_info - Returns FW's pd_list structure 3003 * @instance: Adapter soft state 3004 * @pd_list: pd_list structure 3005 * 3006 * Issues an internal command (DCMD) to get the FW's controller PD 3007 * list structure. This information is mainly used to find out SYSTEM 3008 * supported by the FW. 3009 */ 3010 static int 3011 megasas_get_pd_list(struct megasas_instance *instance) 3012 { 3013 int ret = 0, pd_index = 0; 3014 struct megasas_cmd *cmd; 3015 struct megasas_dcmd_frame *dcmd; 3016 struct MR_PD_LIST *ci; 3017 struct MR_PD_ADDRESS *pd_addr; 3018 dma_addr_t ci_h = 0; 3019 3020 cmd = megasas_get_cmd(instance); 3021 3022 if (!cmd) { 3023 printk(KERN_DEBUG "megasas (get_pd_list): Failed to get cmd\n"); 3024 return -ENOMEM; 3025 } 3026 3027 dcmd = &cmd->frame->dcmd; 3028 3029 ci = pci_alloc_consistent(instance->pdev, 3030 MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST), &ci_h); 3031 3032 if (!ci) { 3033 printk(KERN_DEBUG "Failed to alloc mem for pd_list\n"); 3034 megasas_return_cmd(instance, cmd); 3035 return -ENOMEM; 3036 } 3037 3038 memset(ci, 0, sizeof(*ci)); 3039 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 3040 3041 dcmd->mbox.b[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST; 3042 dcmd->mbox.b[1] = 0; 3043 dcmd->cmd = MFI_CMD_DCMD; 3044 dcmd->cmd_status = 0xFF; 3045 dcmd->sge_count = 1; 3046 dcmd->flags = MFI_FRAME_DIR_READ; 3047 dcmd->timeout = 0; 3048 dcmd->pad_0 = 0; 3049 dcmd->data_xfer_len = MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST); 3050 dcmd->opcode = MR_DCMD_PD_LIST_QUERY; 3051 dcmd->sgl.sge32[0].phys_addr = ci_h; 3052 dcmd->sgl.sge32[0].length = MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST); 3053 3054 if (!megasas_issue_polled(instance, cmd)) { 3055 ret = 0; 3056 } else { 3057 ret = -1; 3058 } 3059 3060 /* 3061 * the following function will get the instance PD LIST. 3062 */ 3063 3064 pd_addr = ci->addr; 3065 3066 if ( ret == 0 && 3067 (ci->count < 3068 (MEGASAS_MAX_PD_CHANNELS * MEGASAS_MAX_DEV_PER_CHANNEL))) { 3069 3070 memset(instance->pd_list, 0, 3071 MEGASAS_MAX_PD * sizeof(struct megasas_pd_list)); 3072 3073 for (pd_index = 0; pd_index < ci->count; pd_index++) { 3074 3075 instance->pd_list[pd_addr->deviceId].tid = 3076 pd_addr->deviceId; 3077 instance->pd_list[pd_addr->deviceId].driveType = 3078 pd_addr->scsiDevType; 3079 instance->pd_list[pd_addr->deviceId].driveState = 3080 MR_PD_STATE_SYSTEM; 3081 pd_addr++; 3082 } 3083 } 3084 3085 pci_free_consistent(instance->pdev, 3086 MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST), 3087 ci, ci_h); 3088 megasas_return_cmd(instance, cmd); 3089 3090 return ret; 3091 } 3092 3093 /* 3094 * megasas_get_ld_list_info - Returns FW's ld_list structure 3095 * @instance: Adapter soft state 3096 * @ld_list: ld_list structure 3097 * 3098 * Issues an internal command (DCMD) to get the FW's controller PD 3099 * list structure. This information is mainly used to find out SYSTEM 3100 * supported by the FW. 3101 */ 3102 static int 3103 megasas_get_ld_list(struct megasas_instance *instance) 3104 { 3105 int ret = 0, ld_index = 0, ids = 0; 3106 struct megasas_cmd *cmd; 3107 struct megasas_dcmd_frame *dcmd; 3108 struct MR_LD_LIST *ci; 3109 dma_addr_t ci_h = 0; 3110 3111 cmd = megasas_get_cmd(instance); 3112 3113 if (!cmd) { 3114 printk(KERN_DEBUG "megasas_get_ld_list: Failed to get cmd\n"); 3115 return -ENOMEM; 3116 } 3117 3118 dcmd = &cmd->frame->dcmd; 3119 3120 ci = pci_alloc_consistent(instance->pdev, 3121 sizeof(struct MR_LD_LIST), 3122 &ci_h); 3123 3124 if (!ci) { 3125 printk(KERN_DEBUG "Failed to alloc mem in get_ld_list\n"); 3126 megasas_return_cmd(instance, cmd); 3127 return -ENOMEM; 3128 } 3129 3130 memset(ci, 0, sizeof(*ci)); 3131 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 3132 3133 dcmd->cmd = MFI_CMD_DCMD; 3134 dcmd->cmd_status = 0xFF; 3135 dcmd->sge_count = 1; 3136 dcmd->flags = MFI_FRAME_DIR_READ; 3137 dcmd->timeout = 0; 3138 dcmd->data_xfer_len = sizeof(struct MR_LD_LIST); 3139 dcmd->opcode = MR_DCMD_LD_GET_LIST; 3140 dcmd->sgl.sge32[0].phys_addr = ci_h; 3141 dcmd->sgl.sge32[0].length = sizeof(struct MR_LD_LIST); 3142 dcmd->pad_0 = 0; 3143 3144 if (!megasas_issue_polled(instance, cmd)) { 3145 ret = 0; 3146 } else { 3147 ret = -1; 3148 } 3149 3150 /* the following function will get the instance PD LIST */ 3151 3152 if ((ret == 0) && (ci->ldCount <= MAX_LOGICAL_DRIVES)) { 3153 memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS); 3154 3155 for (ld_index = 0; ld_index < ci->ldCount; ld_index++) { 3156 if (ci->ldList[ld_index].state != 0) { 3157 ids = ci->ldList[ld_index].ref.targetId; 3158 instance->ld_ids[ids] = 3159 ci->ldList[ld_index].ref.targetId; 3160 } 3161 } 3162 } 3163 3164 pci_free_consistent(instance->pdev, 3165 sizeof(struct MR_LD_LIST), 3166 ci, 3167 ci_h); 3168 3169 megasas_return_cmd(instance, cmd); 3170 return ret; 3171 } 3172 3173 /** 3174 * megasas_get_controller_info - Returns FW's controller structure 3175 * @instance: Adapter soft state 3176 * @ctrl_info: Controller information structure 3177 * 3178 * Issues an internal command (DCMD) to get the FW's controller structure. 3179 * This information is mainly used to find out the maximum IO transfer per 3180 * command supported by the FW. 3181 */ 3182 static int 3183 megasas_get_ctrl_info(struct megasas_instance *instance, 3184 struct megasas_ctrl_info *ctrl_info) 3185 { 3186 int ret = 0; 3187 struct megasas_cmd *cmd; 3188 struct megasas_dcmd_frame *dcmd; 3189 struct megasas_ctrl_info *ci; 3190 dma_addr_t ci_h = 0; 3191 3192 cmd = megasas_get_cmd(instance); 3193 3194 if (!cmd) { 3195 printk(KERN_DEBUG "megasas: Failed to get a free cmd\n"); 3196 return -ENOMEM; 3197 } 3198 3199 dcmd = &cmd->frame->dcmd; 3200 3201 ci = pci_alloc_consistent(instance->pdev, 3202 sizeof(struct megasas_ctrl_info), &ci_h); 3203 3204 if (!ci) { 3205 printk(KERN_DEBUG "Failed to alloc mem for ctrl info\n"); 3206 megasas_return_cmd(instance, cmd); 3207 return -ENOMEM; 3208 } 3209 3210 memset(ci, 0, sizeof(*ci)); 3211 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 3212 3213 dcmd->cmd = MFI_CMD_DCMD; 3214 dcmd->cmd_status = 0xFF; 3215 dcmd->sge_count = 1; 3216 dcmd->flags = MFI_FRAME_DIR_READ; 3217 dcmd->timeout = 0; 3218 dcmd->pad_0 = 0; 3219 dcmd->data_xfer_len = sizeof(struct megasas_ctrl_info); 3220 dcmd->opcode = MR_DCMD_CTRL_GET_INFO; 3221 dcmd->sgl.sge32[0].phys_addr = ci_h; 3222 dcmd->sgl.sge32[0].length = sizeof(struct megasas_ctrl_info); 3223 3224 if (!megasas_issue_polled(instance, cmd)) { 3225 ret = 0; 3226 memcpy(ctrl_info, ci, sizeof(struct megasas_ctrl_info)); 3227 } else { 3228 ret = -1; 3229 } 3230 3231 pci_free_consistent(instance->pdev, sizeof(struct megasas_ctrl_info), 3232 ci, ci_h); 3233 3234 megasas_return_cmd(instance, cmd); 3235 return ret; 3236 } 3237 3238 /** 3239 * megasas_issue_init_mfi - Initializes the FW 3240 * @instance: Adapter soft state 3241 * 3242 * Issues the INIT MFI cmd 3243 */ 3244 static int 3245 megasas_issue_init_mfi(struct megasas_instance *instance) 3246 { 3247 u32 context; 3248 3249 struct megasas_cmd *cmd; 3250 3251 struct megasas_init_frame *init_frame; 3252 struct megasas_init_queue_info *initq_info; 3253 dma_addr_t init_frame_h; 3254 dma_addr_t initq_info_h; 3255 3256 /* 3257 * Prepare a init frame. Note the init frame points to queue info 3258 * structure. Each frame has SGL allocated after first 64 bytes. For 3259 * this frame - since we don't need any SGL - we use SGL's space as 3260 * queue info structure 3261 * 3262 * We will not get a NULL command below. We just created the pool. 3263 */ 3264 cmd = megasas_get_cmd(instance); 3265 3266 init_frame = (struct megasas_init_frame *)cmd->frame; 3267 initq_info = (struct megasas_init_queue_info *) 3268 ((unsigned long)init_frame + 64); 3269 3270 init_frame_h = cmd->frame_phys_addr; 3271 initq_info_h = init_frame_h + 64; 3272 3273 context = init_frame->context; 3274 memset(init_frame, 0, MEGAMFI_FRAME_SIZE); 3275 memset(initq_info, 0, sizeof(struct megasas_init_queue_info)); 3276 init_frame->context = context; 3277 3278 initq_info->reply_queue_entries = instance->max_fw_cmds + 1; 3279 initq_info->reply_queue_start_phys_addr_lo = instance->reply_queue_h; 3280 3281 initq_info->producer_index_phys_addr_lo = instance->producer_h; 3282 initq_info->consumer_index_phys_addr_lo = instance->consumer_h; 3283 3284 init_frame->cmd = MFI_CMD_INIT; 3285 init_frame->cmd_status = 0xFF; 3286 init_frame->queue_info_new_phys_addr_lo = initq_info_h; 3287 3288 init_frame->data_xfer_len = sizeof(struct megasas_init_queue_info); 3289 3290 /* 3291 * disable the intr before firing the init frame to FW 3292 */ 3293 instance->instancet->disable_intr(instance->reg_set); 3294 3295 /* 3296 * Issue the init frame in polled mode 3297 */ 3298 3299 if (megasas_issue_polled(instance, cmd)) { 3300 printk(KERN_ERR "megasas: Failed to init firmware\n"); 3301 megasas_return_cmd(instance, cmd); 3302 goto fail_fw_init; 3303 } 3304 3305 megasas_return_cmd(instance, cmd); 3306 3307 return 0; 3308 3309 fail_fw_init: 3310 return -EINVAL; 3311 } 3312 3313 /** 3314 * megasas_start_timer - Initializes a timer object 3315 * @instance: Adapter soft state 3316 * @timer: timer object to be initialized 3317 * @fn: timer function 3318 * @interval: time interval between timer function call 3319 */ 3320 static inline void 3321 megasas_start_timer(struct megasas_instance *instance, 3322 struct timer_list *timer, 3323 void *fn, unsigned long interval) 3324 { 3325 init_timer(timer); 3326 timer->expires = jiffies + interval; 3327 timer->data = (unsigned long)instance; 3328 timer->function = fn; 3329 add_timer(timer); 3330 } 3331 3332 /** 3333 * megasas_io_completion_timer - Timer fn 3334 * @instance_addr: Address of adapter soft state 3335 * 3336 * Schedules tasklet for cmd completion 3337 * if poll_mode_io is set 3338 */ 3339 static void 3340 megasas_io_completion_timer(unsigned long instance_addr) 3341 { 3342 struct megasas_instance *instance = 3343 (struct megasas_instance *)instance_addr; 3344 3345 if (atomic_read(&instance->fw_outstanding)) 3346 tasklet_schedule(&instance->isr_tasklet); 3347 3348 /* Restart timer */ 3349 if (poll_mode_io) 3350 mod_timer(&instance->io_completion_timer, 3351 jiffies + MEGASAS_COMPLETION_TIMER_INTERVAL); 3352 } 3353 3354 static u32 3355 megasas_init_adapter_mfi(struct megasas_instance *instance) 3356 { 3357 struct megasas_register_set __iomem *reg_set; 3358 u32 context_sz; 3359 u32 reply_q_sz; 3360 3361 reg_set = instance->reg_set; 3362 3363 /* 3364 * Get various operational parameters from status register 3365 */ 3366 instance->max_fw_cmds = instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF; 3367 /* 3368 * Reduce the max supported cmds by 1. This is to ensure that the 3369 * reply_q_sz (1 more than the max cmd that driver may send) 3370 * does not exceed max cmds that the FW can support 3371 */ 3372 instance->max_fw_cmds = instance->max_fw_cmds-1; 3373 instance->max_mfi_cmds = instance->max_fw_cmds; 3374 instance->max_num_sge = (instance->instancet->read_fw_status_reg(reg_set) & 0xFF0000) >> 3375 0x10; 3376 /* 3377 * Create a pool of commands 3378 */ 3379 if (megasas_alloc_cmds(instance)) 3380 goto fail_alloc_cmds; 3381 3382 /* 3383 * Allocate memory for reply queue. Length of reply queue should 3384 * be _one_ more than the maximum commands handled by the firmware. 3385 * 3386 * Note: When FW completes commands, it places corresponding contex 3387 * values in this circular reply queue. This circular queue is a fairly 3388 * typical producer-consumer queue. FW is the producer (of completed 3389 * commands) and the driver is the consumer. 3390 */ 3391 context_sz = sizeof(u32); 3392 reply_q_sz = context_sz * (instance->max_fw_cmds + 1); 3393 3394 instance->reply_queue = pci_alloc_consistent(instance->pdev, 3395 reply_q_sz, 3396 &instance->reply_queue_h); 3397 3398 if (!instance->reply_queue) { 3399 printk(KERN_DEBUG "megasas: Out of DMA mem for reply queue\n"); 3400 goto fail_reply_queue; 3401 } 3402 3403 if (megasas_issue_init_mfi(instance)) 3404 goto fail_fw_init; 3405 3406 instance->fw_support_ieee = 0; 3407 instance->fw_support_ieee = 3408 (instance->instancet->read_fw_status_reg(reg_set) & 3409 0x04000000); 3410 3411 printk(KERN_NOTICE "megasas_init_mfi: fw_support_ieee=%d", 3412 instance->fw_support_ieee); 3413 3414 if (instance->fw_support_ieee) 3415 instance->flag_ieee = 1; 3416 3417 return 0; 3418 3419 fail_fw_init: 3420 3421 pci_free_consistent(instance->pdev, reply_q_sz, 3422 instance->reply_queue, instance->reply_queue_h); 3423 fail_reply_queue: 3424 megasas_free_cmds(instance); 3425 3426 fail_alloc_cmds: 3427 iounmap(instance->reg_set); 3428 return 1; 3429 } 3430 3431 /** 3432 * megasas_init_fw - Initializes the FW 3433 * @instance: Adapter soft state 3434 * 3435 * This is the main function for initializing firmware 3436 */ 3437 3438 static int megasas_init_fw(struct megasas_instance *instance) 3439 { 3440 u32 max_sectors_1; 3441 u32 max_sectors_2; 3442 u32 tmp_sectors; 3443 struct megasas_register_set __iomem *reg_set; 3444 struct megasas_ctrl_info *ctrl_info; 3445 unsigned long bar_list; 3446 3447 /* Find first memory bar */ 3448 bar_list = pci_select_bars(instance->pdev, IORESOURCE_MEM); 3449 instance->bar = find_first_bit(&bar_list, sizeof(unsigned long)); 3450 instance->base_addr = pci_resource_start(instance->pdev, instance->bar); 3451 if (pci_request_selected_regions(instance->pdev, instance->bar, 3452 "megasas: LSI")) { 3453 printk(KERN_DEBUG "megasas: IO memory region busy!\n"); 3454 return -EBUSY; 3455 } 3456 3457 instance->reg_set = ioremap_nocache(instance->base_addr, 8192); 3458 3459 if (!instance->reg_set) { 3460 printk(KERN_DEBUG "megasas: Failed to map IO mem\n"); 3461 goto fail_ioremap; 3462 } 3463 3464 reg_set = instance->reg_set; 3465 3466 switch (instance->pdev->device) { 3467 case PCI_DEVICE_ID_LSI_FUSION: 3468 instance->instancet = &megasas_instance_template_fusion; 3469 break; 3470 case PCI_DEVICE_ID_LSI_SAS1078R: 3471 case PCI_DEVICE_ID_LSI_SAS1078DE: 3472 instance->instancet = &megasas_instance_template_ppc; 3473 break; 3474 case PCI_DEVICE_ID_LSI_SAS1078GEN2: 3475 case PCI_DEVICE_ID_LSI_SAS0079GEN2: 3476 instance->instancet = &megasas_instance_template_gen2; 3477 break; 3478 case PCI_DEVICE_ID_LSI_SAS0073SKINNY: 3479 case PCI_DEVICE_ID_LSI_SAS0071SKINNY: 3480 instance->instancet = &megasas_instance_template_skinny; 3481 break; 3482 case PCI_DEVICE_ID_LSI_SAS1064R: 3483 case PCI_DEVICE_ID_DELL_PERC5: 3484 default: 3485 instance->instancet = &megasas_instance_template_xscale; 3486 break; 3487 } 3488 3489 /* 3490 * We expect the FW state to be READY 3491 */ 3492 if (megasas_transition_to_ready(instance)) 3493 goto fail_ready_state; 3494 3495 /* Get operational params, sge flags, send init cmd to controller */ 3496 if (instance->instancet->init_adapter(instance)) 3497 return -ENODEV; 3498 3499 printk(KERN_ERR "megasas: INIT adapter done\n"); 3500 3501 /** for passthrough 3502 * the following function will get the PD LIST. 3503 */ 3504 3505 memset(instance->pd_list, 0 , 3506 (MEGASAS_MAX_PD * sizeof(struct megasas_pd_list))); 3507 megasas_get_pd_list(instance); 3508 3509 memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS); 3510 megasas_get_ld_list(instance); 3511 3512 ctrl_info = kmalloc(sizeof(struct megasas_ctrl_info), GFP_KERNEL); 3513 3514 /* 3515 * Compute the max allowed sectors per IO: The controller info has two 3516 * limits on max sectors. Driver should use the minimum of these two. 3517 * 3518 * 1 << stripe_sz_ops.min = max sectors per strip 3519 * 3520 * Note that older firmwares ( < FW ver 30) didn't report information 3521 * to calculate max_sectors_1. So the number ended up as zero always. 3522 */ 3523 tmp_sectors = 0; 3524 if (ctrl_info && !megasas_get_ctrl_info(instance, ctrl_info)) { 3525 3526 max_sectors_1 = (1 << ctrl_info->stripe_sz_ops.min) * 3527 ctrl_info->max_strips_per_io; 3528 max_sectors_2 = ctrl_info->max_request_size; 3529 3530 tmp_sectors = min_t(u32, max_sectors_1 , max_sectors_2); 3531 instance->disableOnlineCtrlReset = 3532 ctrl_info->properties.OnOffProperties.disableOnlineCtrlReset; 3533 } 3534 3535 instance->max_sectors_per_req = instance->max_num_sge * 3536 PAGE_SIZE / 512; 3537 if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors)) 3538 instance->max_sectors_per_req = tmp_sectors; 3539 3540 kfree(ctrl_info); 3541 3542 /* 3543 * Setup tasklet for cmd completion 3544 */ 3545 3546 tasklet_init(&instance->isr_tasklet, megasas_complete_cmd_dpc, 3547 (unsigned long)instance); 3548 3549 /* Initialize the cmd completion timer */ 3550 if (poll_mode_io) 3551 megasas_start_timer(instance, &instance->io_completion_timer, 3552 megasas_io_completion_timer, 3553 MEGASAS_COMPLETION_TIMER_INTERVAL); 3554 return 0; 3555 3556 fail_ready_state: 3557 iounmap(instance->reg_set); 3558 3559 fail_ioremap: 3560 pci_release_selected_regions(instance->pdev, instance->bar); 3561 3562 return -EINVAL; 3563 } 3564 3565 /** 3566 * megasas_release_mfi - Reverses the FW initialization 3567 * @intance: Adapter soft state 3568 */ 3569 static void megasas_release_mfi(struct megasas_instance *instance) 3570 { 3571 u32 reply_q_sz = sizeof(u32) *(instance->max_mfi_cmds + 1); 3572 3573 if (instance->reply_queue) 3574 pci_free_consistent(instance->pdev, reply_q_sz, 3575 instance->reply_queue, instance->reply_queue_h); 3576 3577 megasas_free_cmds(instance); 3578 3579 iounmap(instance->reg_set); 3580 3581 pci_release_selected_regions(instance->pdev, instance->bar); 3582 } 3583 3584 /** 3585 * megasas_get_seq_num - Gets latest event sequence numbers 3586 * @instance: Adapter soft state 3587 * @eli: FW event log sequence numbers information 3588 * 3589 * FW maintains a log of all events in a non-volatile area. Upper layers would 3590 * usually find out the latest sequence number of the events, the seq number at 3591 * the boot etc. They would "read" all the events below the latest seq number 3592 * by issuing a direct fw cmd (DCMD). For the future events (beyond latest seq 3593 * number), they would subsribe to AEN (asynchronous event notification) and 3594 * wait for the events to happen. 3595 */ 3596 static int 3597 megasas_get_seq_num(struct megasas_instance *instance, 3598 struct megasas_evt_log_info *eli) 3599 { 3600 struct megasas_cmd *cmd; 3601 struct megasas_dcmd_frame *dcmd; 3602 struct megasas_evt_log_info *el_info; 3603 dma_addr_t el_info_h = 0; 3604 3605 cmd = megasas_get_cmd(instance); 3606 3607 if (!cmd) { 3608 return -ENOMEM; 3609 } 3610 3611 dcmd = &cmd->frame->dcmd; 3612 el_info = pci_alloc_consistent(instance->pdev, 3613 sizeof(struct megasas_evt_log_info), 3614 &el_info_h); 3615 3616 if (!el_info) { 3617 megasas_return_cmd(instance, cmd); 3618 return -ENOMEM; 3619 } 3620 3621 memset(el_info, 0, sizeof(*el_info)); 3622 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 3623 3624 dcmd->cmd = MFI_CMD_DCMD; 3625 dcmd->cmd_status = 0x0; 3626 dcmd->sge_count = 1; 3627 dcmd->flags = MFI_FRAME_DIR_READ; 3628 dcmd->timeout = 0; 3629 dcmd->pad_0 = 0; 3630 dcmd->data_xfer_len = sizeof(struct megasas_evt_log_info); 3631 dcmd->opcode = MR_DCMD_CTRL_EVENT_GET_INFO; 3632 dcmd->sgl.sge32[0].phys_addr = el_info_h; 3633 dcmd->sgl.sge32[0].length = sizeof(struct megasas_evt_log_info); 3634 3635 megasas_issue_blocked_cmd(instance, cmd); 3636 3637 /* 3638 * Copy the data back into callers buffer 3639 */ 3640 memcpy(eli, el_info, sizeof(struct megasas_evt_log_info)); 3641 3642 pci_free_consistent(instance->pdev, sizeof(struct megasas_evt_log_info), 3643 el_info, el_info_h); 3644 3645 megasas_return_cmd(instance, cmd); 3646 3647 return 0; 3648 } 3649 3650 /** 3651 * megasas_register_aen - Registers for asynchronous event notification 3652 * @instance: Adapter soft state 3653 * @seq_num: The starting sequence number 3654 * @class_locale: Class of the event 3655 * 3656 * This function subscribes for AEN for events beyond the @seq_num. It requests 3657 * to be notified if and only if the event is of type @class_locale 3658 */ 3659 static int 3660 megasas_register_aen(struct megasas_instance *instance, u32 seq_num, 3661 u32 class_locale_word) 3662 { 3663 int ret_val; 3664 struct megasas_cmd *cmd; 3665 struct megasas_dcmd_frame *dcmd; 3666 union megasas_evt_class_locale curr_aen; 3667 union megasas_evt_class_locale prev_aen; 3668 3669 /* 3670 * If there an AEN pending already (aen_cmd), check if the 3671 * class_locale of that pending AEN is inclusive of the new 3672 * AEN request we currently have. If it is, then we don't have 3673 * to do anything. In other words, whichever events the current 3674 * AEN request is subscribing to, have already been subscribed 3675 * to. 3676 * 3677 * If the old_cmd is _not_ inclusive, then we have to abort 3678 * that command, form a class_locale that is superset of both 3679 * old and current and re-issue to the FW 3680 */ 3681 3682 curr_aen.word = class_locale_word; 3683 3684 if (instance->aen_cmd) { 3685 3686 prev_aen.word = instance->aen_cmd->frame->dcmd.mbox.w[1]; 3687 3688 /* 3689 * A class whose enum value is smaller is inclusive of all 3690 * higher values. If a PROGRESS (= -1) was previously 3691 * registered, then a new registration requests for higher 3692 * classes need not be sent to FW. They are automatically 3693 * included. 3694 * 3695 * Locale numbers don't have such hierarchy. They are bitmap 3696 * values 3697 */ 3698 if ((prev_aen.members.class <= curr_aen.members.class) && 3699 !((prev_aen.members.locale & curr_aen.members.locale) ^ 3700 curr_aen.members.locale)) { 3701 /* 3702 * Previously issued event registration includes 3703 * current request. Nothing to do. 3704 */ 3705 return 0; 3706 } else { 3707 curr_aen.members.locale |= prev_aen.members.locale; 3708 3709 if (prev_aen.members.class < curr_aen.members.class) 3710 curr_aen.members.class = prev_aen.members.class; 3711 3712 instance->aen_cmd->abort_aen = 1; 3713 ret_val = megasas_issue_blocked_abort_cmd(instance, 3714 instance-> 3715 aen_cmd); 3716 3717 if (ret_val) { 3718 printk(KERN_DEBUG "megasas: Failed to abort " 3719 "previous AEN command\n"); 3720 return ret_val; 3721 } 3722 } 3723 } 3724 3725 cmd = megasas_get_cmd(instance); 3726 3727 if (!cmd) 3728 return -ENOMEM; 3729 3730 dcmd = &cmd->frame->dcmd; 3731 3732 memset(instance->evt_detail, 0, sizeof(struct megasas_evt_detail)); 3733 3734 /* 3735 * Prepare DCMD for aen registration 3736 */ 3737 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 3738 3739 dcmd->cmd = MFI_CMD_DCMD; 3740 dcmd->cmd_status = 0x0; 3741 dcmd->sge_count = 1; 3742 dcmd->flags = MFI_FRAME_DIR_READ; 3743 dcmd->timeout = 0; 3744 dcmd->pad_0 = 0; 3745 instance->last_seq_num = seq_num; 3746 dcmd->data_xfer_len = sizeof(struct megasas_evt_detail); 3747 dcmd->opcode = MR_DCMD_CTRL_EVENT_WAIT; 3748 dcmd->mbox.w[0] = seq_num; 3749 dcmd->mbox.w[1] = curr_aen.word; 3750 dcmd->sgl.sge32[0].phys_addr = (u32) instance->evt_detail_h; 3751 dcmd->sgl.sge32[0].length = sizeof(struct megasas_evt_detail); 3752 3753 if (instance->aen_cmd != NULL) { 3754 megasas_return_cmd(instance, cmd); 3755 return 0; 3756 } 3757 3758 /* 3759 * Store reference to the cmd used to register for AEN. When an 3760 * application wants us to register for AEN, we have to abort this 3761 * cmd and re-register with a new EVENT LOCALE supplied by that app 3762 */ 3763 instance->aen_cmd = cmd; 3764 3765 /* 3766 * Issue the aen registration frame 3767 */ 3768 instance->instancet->issue_dcmd(instance, cmd); 3769 3770 return 0; 3771 } 3772 3773 /** 3774 * megasas_start_aen - Subscribes to AEN during driver load time 3775 * @instance: Adapter soft state 3776 */ 3777 static int megasas_start_aen(struct megasas_instance *instance) 3778 { 3779 struct megasas_evt_log_info eli; 3780 union megasas_evt_class_locale class_locale; 3781 3782 /* 3783 * Get the latest sequence number from FW 3784 */ 3785 memset(&eli, 0, sizeof(eli)); 3786 3787 if (megasas_get_seq_num(instance, &eli)) 3788 return -1; 3789 3790 /* 3791 * Register AEN with FW for latest sequence number plus 1 3792 */ 3793 class_locale.members.reserved = 0; 3794 class_locale.members.locale = MR_EVT_LOCALE_ALL; 3795 class_locale.members.class = MR_EVT_CLASS_DEBUG; 3796 3797 return megasas_register_aen(instance, eli.newest_seq_num + 1, 3798 class_locale.word); 3799 } 3800 3801 /** 3802 * megasas_io_attach - Attaches this driver to SCSI mid-layer 3803 * @instance: Adapter soft state 3804 */ 3805 static int megasas_io_attach(struct megasas_instance *instance) 3806 { 3807 struct Scsi_Host *host = instance->host; 3808 3809 /* 3810 * Export parameters required by SCSI mid-layer 3811 */ 3812 host->irq = instance->pdev->irq; 3813 host->unique_id = instance->unique_id; 3814 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) || 3815 (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) { 3816 host->can_queue = 3817 instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS; 3818 } else 3819 host->can_queue = 3820 instance->max_fw_cmds - MEGASAS_INT_CMDS; 3821 host->this_id = instance->init_id; 3822 host->sg_tablesize = instance->max_num_sge; 3823 /* 3824 * Check if the module parameter value for max_sectors can be used 3825 */ 3826 if (max_sectors && max_sectors < instance->max_sectors_per_req) 3827 instance->max_sectors_per_req = max_sectors; 3828 else { 3829 if (max_sectors) { 3830 if (((instance->pdev->device == 3831 PCI_DEVICE_ID_LSI_SAS1078GEN2) || 3832 (instance->pdev->device == 3833 PCI_DEVICE_ID_LSI_SAS0079GEN2)) && 3834 (max_sectors <= MEGASAS_MAX_SECTORS)) { 3835 instance->max_sectors_per_req = max_sectors; 3836 } else { 3837 printk(KERN_INFO "megasas: max_sectors should be > 0" 3838 "and <= %d (or < 1MB for GEN2 controller)\n", 3839 instance->max_sectors_per_req); 3840 } 3841 } 3842 } 3843 3844 host->max_sectors = instance->max_sectors_per_req; 3845 host->cmd_per_lun = MEGASAS_DEFAULT_CMD_PER_LUN; 3846 host->max_channel = MEGASAS_MAX_CHANNELS - 1; 3847 host->max_id = MEGASAS_MAX_DEV_PER_CHANNEL; 3848 host->max_lun = MEGASAS_MAX_LUN; 3849 host->max_cmd_len = 16; 3850 3851 /* Fusion only supports host reset */ 3852 if (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) { 3853 host->hostt->eh_device_reset_handler = NULL; 3854 host->hostt->eh_bus_reset_handler = NULL; 3855 } 3856 3857 /* 3858 * Notify the mid-layer about the new controller 3859 */ 3860 if (scsi_add_host(host, &instance->pdev->dev)) { 3861 printk(KERN_DEBUG "megasas: scsi_add_host failed\n"); 3862 return -ENODEV; 3863 } 3864 3865 /* 3866 * Trigger SCSI to scan our drives 3867 */ 3868 scsi_scan_host(host); 3869 return 0; 3870 } 3871 3872 static int 3873 megasas_set_dma_mask(struct pci_dev *pdev) 3874 { 3875 /* 3876 * All our contollers are capable of performing 64-bit DMA 3877 */ 3878 if (IS_DMA64) { 3879 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0) { 3880 3881 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0) 3882 goto fail_set_dma_mask; 3883 } 3884 } else { 3885 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0) 3886 goto fail_set_dma_mask; 3887 } 3888 return 0; 3889 3890 fail_set_dma_mask: 3891 return 1; 3892 } 3893 3894 /** 3895 * megasas_probe_one - PCI hotplug entry point 3896 * @pdev: PCI device structure 3897 * @id: PCI ids of supported hotplugged adapter 3898 */ 3899 static int __devinit 3900 megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) 3901 { 3902 int rval; 3903 struct Scsi_Host *host; 3904 struct megasas_instance *instance; 3905 3906 /* 3907 * Announce PCI information 3908 */ 3909 printk(KERN_INFO "megasas: %#4.04x:%#4.04x:%#4.04x:%#4.04x: ", 3910 pdev->vendor, pdev->device, pdev->subsystem_vendor, 3911 pdev->subsystem_device); 3912 3913 printk("bus %d:slot %d:func %d\n", 3914 pdev->bus->number, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn)); 3915 3916 /* 3917 * PCI prepping: enable device set bus mastering and dma mask 3918 */ 3919 rval = pci_enable_device_mem(pdev); 3920 3921 if (rval) { 3922 return rval; 3923 } 3924 3925 pci_set_master(pdev); 3926 3927 if (megasas_set_dma_mask(pdev)) 3928 goto fail_set_dma_mask; 3929 3930 host = scsi_host_alloc(&megasas_template, 3931 sizeof(struct megasas_instance)); 3932 3933 if (!host) { 3934 printk(KERN_DEBUG "megasas: scsi_host_alloc failed\n"); 3935 goto fail_alloc_instance; 3936 } 3937 3938 instance = (struct megasas_instance *)host->hostdata; 3939 memset(instance, 0, sizeof(*instance)); 3940 atomic_set( &instance->fw_reset_no_pci_access, 0 ); 3941 instance->pdev = pdev; 3942 3943 switch (instance->pdev->device) { 3944 case PCI_DEVICE_ID_LSI_FUSION: 3945 { 3946 struct fusion_context *fusion; 3947 3948 instance->ctrl_context = 3949 kzalloc(sizeof(struct fusion_context), GFP_KERNEL); 3950 if (!instance->ctrl_context) { 3951 printk(KERN_DEBUG "megasas: Failed to allocate " 3952 "memory for Fusion context info\n"); 3953 goto fail_alloc_dma_buf; 3954 } 3955 fusion = instance->ctrl_context; 3956 INIT_LIST_HEAD(&fusion->cmd_pool); 3957 spin_lock_init(&fusion->cmd_pool_lock); 3958 } 3959 break; 3960 default: /* For all other supported controllers */ 3961 3962 instance->producer = 3963 pci_alloc_consistent(pdev, sizeof(u32), 3964 &instance->producer_h); 3965 instance->consumer = 3966 pci_alloc_consistent(pdev, sizeof(u32), 3967 &instance->consumer_h); 3968 3969 if (!instance->producer || !instance->consumer) { 3970 printk(KERN_DEBUG "megasas: Failed to allocate" 3971 "memory for producer, consumer\n"); 3972 goto fail_alloc_dma_buf; 3973 } 3974 3975 *instance->producer = 0; 3976 *instance->consumer = 0; 3977 break; 3978 } 3979 3980 megasas_poll_wait_aen = 0; 3981 instance->flag_ieee = 0; 3982 instance->ev = NULL; 3983 instance->issuepend_done = 1; 3984 instance->adprecovery = MEGASAS_HBA_OPERATIONAL; 3985 megasas_poll_wait_aen = 0; 3986 3987 instance->evt_detail = pci_alloc_consistent(pdev, 3988 sizeof(struct 3989 megasas_evt_detail), 3990 &instance->evt_detail_h); 3991 3992 if (!instance->evt_detail) { 3993 printk(KERN_DEBUG "megasas: Failed to allocate memory for " 3994 "event detail structure\n"); 3995 goto fail_alloc_dma_buf; 3996 } 3997 3998 /* 3999 * Initialize locks and queues 4000 */ 4001 INIT_LIST_HEAD(&instance->cmd_pool); 4002 INIT_LIST_HEAD(&instance->internal_reset_pending_q); 4003 4004 atomic_set(&instance->fw_outstanding,0); 4005 4006 init_waitqueue_head(&instance->int_cmd_wait_q); 4007 init_waitqueue_head(&instance->abort_cmd_wait_q); 4008 4009 spin_lock_init(&instance->cmd_pool_lock); 4010 spin_lock_init(&instance->hba_lock); 4011 spin_lock_init(&instance->completion_lock); 4012 spin_lock_init(&poll_aen_lock); 4013 4014 mutex_init(&instance->aen_mutex); 4015 mutex_init(&instance->reset_mutex); 4016 4017 /* 4018 * Initialize PCI related and misc parameters 4019 */ 4020 instance->host = host; 4021 instance->unique_id = pdev->bus->number << 8 | pdev->devfn; 4022 instance->init_id = MEGASAS_DEFAULT_INIT_ID; 4023 4024 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) || 4025 (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) { 4026 instance->flag_ieee = 1; 4027 sema_init(&instance->ioctl_sem, MEGASAS_SKINNY_INT_CMDS); 4028 } else 4029 sema_init(&instance->ioctl_sem, MEGASAS_INT_CMDS); 4030 4031 megasas_dbg_lvl = 0; 4032 instance->flag = 0; 4033 instance->unload = 1; 4034 instance->last_time = 0; 4035 instance->disableOnlineCtrlReset = 1; 4036 4037 if (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) 4038 INIT_WORK(&instance->work_init, megasas_fusion_ocr_wq); 4039 else 4040 INIT_WORK(&instance->work_init, process_fw_state_change_wq); 4041 4042 /* 4043 * Initialize MFI Firmware 4044 */ 4045 if (megasas_init_fw(instance)) 4046 goto fail_init_mfi; 4047 4048 /* Try to enable MSI-X */ 4049 if ((instance->pdev->device != PCI_DEVICE_ID_LSI_SAS1078R) && 4050 (instance->pdev->device != PCI_DEVICE_ID_LSI_SAS1078DE) && 4051 (instance->pdev->device != PCI_DEVICE_ID_LSI_VERDE_ZCR) && 4052 !msix_disable && !pci_enable_msix(instance->pdev, 4053 &instance->msixentry, 1)) 4054 instance->msi_flag = 1; 4055 4056 /* 4057 * Register IRQ 4058 */ 4059 if (request_irq(instance->msi_flag ? instance->msixentry.vector : 4060 pdev->irq, instance->instancet->service_isr, 4061 IRQF_SHARED, "megasas", instance)) { 4062 printk(KERN_DEBUG "megasas: Failed to register IRQ\n"); 4063 goto fail_irq; 4064 } 4065 4066 instance->instancet->enable_intr(instance->reg_set); 4067 4068 /* 4069 * Store instance in PCI softstate 4070 */ 4071 pci_set_drvdata(pdev, instance); 4072 4073 /* 4074 * Add this controller to megasas_mgmt_info structure so that it 4075 * can be exported to management applications 4076 */ 4077 megasas_mgmt_info.count++; 4078 megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = instance; 4079 megasas_mgmt_info.max_index++; 4080 4081 /* 4082 * Initiate AEN (Asynchronous Event Notification) 4083 */ 4084 if (megasas_start_aen(instance)) { 4085 printk(KERN_DEBUG "megasas: start aen failed\n"); 4086 goto fail_start_aen; 4087 } 4088 4089 /* 4090 * Register with SCSI mid-layer 4091 */ 4092 if (megasas_io_attach(instance)) 4093 goto fail_io_attach; 4094 4095 instance->unload = 0; 4096 return 0; 4097 4098 fail_start_aen: 4099 fail_io_attach: 4100 megasas_mgmt_info.count--; 4101 megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL; 4102 megasas_mgmt_info.max_index--; 4103 4104 pci_set_drvdata(pdev, NULL); 4105 instance->instancet->disable_intr(instance->reg_set); 4106 free_irq(instance->msi_flag ? instance->msixentry.vector : 4107 instance->pdev->irq, instance); 4108 if (instance->msi_flag) 4109 pci_disable_msix(instance->pdev); 4110 4111 fail_irq: 4112 fail_init_mfi: 4113 fail_alloc_dma_buf: 4114 if (instance->evt_detail) 4115 pci_free_consistent(pdev, sizeof(struct megasas_evt_detail), 4116 instance->evt_detail, 4117 instance->evt_detail_h); 4118 4119 if (instance->producer) { 4120 pci_free_consistent(pdev, sizeof(u32), instance->producer, 4121 instance->producer_h); 4122 megasas_release_mfi(instance); 4123 } else { 4124 megasas_release_fusion(instance); 4125 } 4126 if (instance->consumer) 4127 pci_free_consistent(pdev, sizeof(u32), instance->consumer, 4128 instance->consumer_h); 4129 scsi_host_put(host); 4130 4131 fail_alloc_instance: 4132 fail_set_dma_mask: 4133 pci_disable_device(pdev); 4134 4135 return -ENODEV; 4136 } 4137 4138 /** 4139 * megasas_flush_cache - Requests FW to flush all its caches 4140 * @instance: Adapter soft state 4141 */ 4142 static void megasas_flush_cache(struct megasas_instance *instance) 4143 { 4144 struct megasas_cmd *cmd; 4145 struct megasas_dcmd_frame *dcmd; 4146 4147 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) 4148 return; 4149 4150 cmd = megasas_get_cmd(instance); 4151 4152 if (!cmd) 4153 return; 4154 4155 dcmd = &cmd->frame->dcmd; 4156 4157 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 4158 4159 dcmd->cmd = MFI_CMD_DCMD; 4160 dcmd->cmd_status = 0x0; 4161 dcmd->sge_count = 0; 4162 dcmd->flags = MFI_FRAME_DIR_NONE; 4163 dcmd->timeout = 0; 4164 dcmd->pad_0 = 0; 4165 dcmd->data_xfer_len = 0; 4166 dcmd->opcode = MR_DCMD_CTRL_CACHE_FLUSH; 4167 dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE; 4168 4169 megasas_issue_blocked_cmd(instance, cmd); 4170 4171 megasas_return_cmd(instance, cmd); 4172 4173 return; 4174 } 4175 4176 /** 4177 * megasas_shutdown_controller - Instructs FW to shutdown the controller 4178 * @instance: Adapter soft state 4179 * @opcode: Shutdown/Hibernate 4180 */ 4181 static void megasas_shutdown_controller(struct megasas_instance *instance, 4182 u32 opcode) 4183 { 4184 struct megasas_cmd *cmd; 4185 struct megasas_dcmd_frame *dcmd; 4186 4187 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) 4188 return; 4189 4190 cmd = megasas_get_cmd(instance); 4191 4192 if (!cmd) 4193 return; 4194 4195 if (instance->aen_cmd) 4196 megasas_issue_blocked_abort_cmd(instance, instance->aen_cmd); 4197 if (instance->map_update_cmd) 4198 megasas_issue_blocked_abort_cmd(instance, 4199 instance->map_update_cmd); 4200 dcmd = &cmd->frame->dcmd; 4201 4202 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 4203 4204 dcmd->cmd = MFI_CMD_DCMD; 4205 dcmd->cmd_status = 0x0; 4206 dcmd->sge_count = 0; 4207 dcmd->flags = MFI_FRAME_DIR_NONE; 4208 dcmd->timeout = 0; 4209 dcmd->pad_0 = 0; 4210 dcmd->data_xfer_len = 0; 4211 dcmd->opcode = opcode; 4212 4213 megasas_issue_blocked_cmd(instance, cmd); 4214 4215 megasas_return_cmd(instance, cmd); 4216 4217 return; 4218 } 4219 4220 #ifdef CONFIG_PM 4221 /** 4222 * megasas_suspend - driver suspend entry point 4223 * @pdev: PCI device structure 4224 * @state: PCI power state to suspend routine 4225 */ 4226 static int 4227 megasas_suspend(struct pci_dev *pdev, pm_message_t state) 4228 { 4229 struct Scsi_Host *host; 4230 struct megasas_instance *instance; 4231 4232 instance = pci_get_drvdata(pdev); 4233 host = instance->host; 4234 instance->unload = 1; 4235 4236 if (poll_mode_io) 4237 del_timer_sync(&instance->io_completion_timer); 4238 4239 megasas_flush_cache(instance); 4240 megasas_shutdown_controller(instance, MR_DCMD_HIBERNATE_SHUTDOWN); 4241 4242 /* cancel the delayed work if this work still in queue */ 4243 if (instance->ev != NULL) { 4244 struct megasas_aen_event *ev = instance->ev; 4245 cancel_delayed_work( 4246 (struct delayed_work *)&ev->hotplug_work); 4247 flush_scheduled_work(); 4248 instance->ev = NULL; 4249 } 4250 4251 tasklet_kill(&instance->isr_tasklet); 4252 4253 pci_set_drvdata(instance->pdev, instance); 4254 instance->instancet->disable_intr(instance->reg_set); 4255 free_irq(instance->msi_flag ? instance->msixentry.vector : 4256 instance->pdev->irq, instance); 4257 if (instance->msi_flag) 4258 pci_disable_msix(instance->pdev); 4259 4260 pci_save_state(pdev); 4261 pci_disable_device(pdev); 4262 4263 pci_set_power_state(pdev, pci_choose_state(pdev, state)); 4264 4265 return 0; 4266 } 4267 4268 /** 4269 * megasas_resume- driver resume entry point 4270 * @pdev: PCI device structure 4271 */ 4272 static int 4273 megasas_resume(struct pci_dev *pdev) 4274 { 4275 int rval; 4276 struct Scsi_Host *host; 4277 struct megasas_instance *instance; 4278 4279 instance = pci_get_drvdata(pdev); 4280 host = instance->host; 4281 pci_set_power_state(pdev, PCI_D0); 4282 pci_enable_wake(pdev, PCI_D0, 0); 4283 pci_restore_state(pdev); 4284 4285 /* 4286 * PCI prepping: enable device set bus mastering and dma mask 4287 */ 4288 rval = pci_enable_device_mem(pdev); 4289 4290 if (rval) { 4291 printk(KERN_ERR "megasas: Enable device failed\n"); 4292 return rval; 4293 } 4294 4295 pci_set_master(pdev); 4296 4297 if (megasas_set_dma_mask(pdev)) 4298 goto fail_set_dma_mask; 4299 4300 /* 4301 * Initialize MFI Firmware 4302 */ 4303 4304 atomic_set(&instance->fw_outstanding, 0); 4305 4306 /* 4307 * We expect the FW state to be READY 4308 */ 4309 if (megasas_transition_to_ready(instance)) 4310 goto fail_ready_state; 4311 4312 switch (instance->pdev->device) { 4313 case PCI_DEVICE_ID_LSI_FUSION: 4314 { 4315 megasas_reset_reply_desc(instance); 4316 if (megasas_ioc_init_fusion(instance)) { 4317 megasas_free_cmds(instance); 4318 megasas_free_cmds_fusion(instance); 4319 goto fail_init_mfi; 4320 } 4321 if (!megasas_get_map_info(instance)) 4322 megasas_sync_map_info(instance); 4323 } 4324 break; 4325 default: 4326 *instance->producer = 0; 4327 *instance->consumer = 0; 4328 if (megasas_issue_init_mfi(instance)) 4329 goto fail_init_mfi; 4330 break; 4331 } 4332 4333 tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet, 4334 (unsigned long)instance); 4335 4336 /* Now re-enable MSI-X */ 4337 if (instance->msi_flag) 4338 pci_enable_msix(instance->pdev, &instance->msixentry, 1); 4339 4340 /* 4341 * Register IRQ 4342 */ 4343 if (request_irq(instance->msi_flag ? instance->msixentry.vector : 4344 pdev->irq, instance->instancet->service_isr, 4345 IRQF_SHARED, "megasas", instance)) { 4346 printk(KERN_ERR "megasas: Failed to register IRQ\n"); 4347 goto fail_irq; 4348 } 4349 4350 instance->instancet->enable_intr(instance->reg_set); 4351 4352 /* 4353 * Initiate AEN (Asynchronous Event Notification) 4354 */ 4355 if (megasas_start_aen(instance)) 4356 printk(KERN_ERR "megasas: Start AEN failed\n"); 4357 4358 /* Initialize the cmd completion timer */ 4359 if (poll_mode_io) 4360 megasas_start_timer(instance, &instance->io_completion_timer, 4361 megasas_io_completion_timer, 4362 MEGASAS_COMPLETION_TIMER_INTERVAL); 4363 instance->unload = 0; 4364 4365 return 0; 4366 4367 fail_irq: 4368 fail_init_mfi: 4369 if (instance->evt_detail) 4370 pci_free_consistent(pdev, sizeof(struct megasas_evt_detail), 4371 instance->evt_detail, 4372 instance->evt_detail_h); 4373 4374 if (instance->producer) 4375 pci_free_consistent(pdev, sizeof(u32), instance->producer, 4376 instance->producer_h); 4377 if (instance->consumer) 4378 pci_free_consistent(pdev, sizeof(u32), instance->consumer, 4379 instance->consumer_h); 4380 scsi_host_put(host); 4381 4382 fail_set_dma_mask: 4383 fail_ready_state: 4384 4385 pci_disable_device(pdev); 4386 4387 return -ENODEV; 4388 } 4389 #else 4390 #define megasas_suspend NULL 4391 #define megasas_resume NULL 4392 #endif 4393 4394 /** 4395 * megasas_detach_one - PCI hot"un"plug entry point 4396 * @pdev: PCI device structure 4397 */ 4398 static void __devexit megasas_detach_one(struct pci_dev *pdev) 4399 { 4400 int i; 4401 struct Scsi_Host *host; 4402 struct megasas_instance *instance; 4403 struct fusion_context *fusion; 4404 4405 instance = pci_get_drvdata(pdev); 4406 instance->unload = 1; 4407 host = instance->host; 4408 fusion = instance->ctrl_context; 4409 4410 if (poll_mode_io) 4411 del_timer_sync(&instance->io_completion_timer); 4412 4413 scsi_remove_host(instance->host); 4414 megasas_flush_cache(instance); 4415 megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN); 4416 4417 /* cancel the delayed work if this work still in queue*/ 4418 if (instance->ev != NULL) { 4419 struct megasas_aen_event *ev = instance->ev; 4420 cancel_delayed_work( 4421 (struct delayed_work *)&ev->hotplug_work); 4422 flush_scheduled_work(); 4423 instance->ev = NULL; 4424 } 4425 4426 tasklet_kill(&instance->isr_tasklet); 4427 4428 /* 4429 * Take the instance off the instance array. Note that we will not 4430 * decrement the max_index. We let this array be sparse array 4431 */ 4432 for (i = 0; i < megasas_mgmt_info.max_index; i++) { 4433 if (megasas_mgmt_info.instance[i] == instance) { 4434 megasas_mgmt_info.count--; 4435 megasas_mgmt_info.instance[i] = NULL; 4436 4437 break; 4438 } 4439 } 4440 4441 pci_set_drvdata(instance->pdev, NULL); 4442 4443 instance->instancet->disable_intr(instance->reg_set); 4444 4445 free_irq(instance->msi_flag ? instance->msixentry.vector : 4446 instance->pdev->irq, instance); 4447 if (instance->msi_flag) 4448 pci_disable_msix(instance->pdev); 4449 4450 switch (instance->pdev->device) { 4451 case PCI_DEVICE_ID_LSI_FUSION: 4452 megasas_release_fusion(instance); 4453 for (i = 0; i < 2 ; i++) 4454 if (fusion->ld_map[i]) 4455 dma_free_coherent(&instance->pdev->dev, 4456 fusion->map_sz, 4457 fusion->ld_map[i], 4458 fusion-> 4459 ld_map_phys[i]); 4460 kfree(instance->ctrl_context); 4461 break; 4462 default: 4463 megasas_release_mfi(instance); 4464 pci_free_consistent(pdev, 4465 sizeof(struct megasas_evt_detail), 4466 instance->evt_detail, 4467 instance->evt_detail_h); 4468 pci_free_consistent(pdev, sizeof(u32), 4469 instance->producer, 4470 instance->producer_h); 4471 pci_free_consistent(pdev, sizeof(u32), 4472 instance->consumer, 4473 instance->consumer_h); 4474 break; 4475 } 4476 4477 scsi_host_put(host); 4478 4479 pci_set_drvdata(pdev, NULL); 4480 4481 pci_disable_device(pdev); 4482 4483 return; 4484 } 4485 4486 /** 4487 * megasas_shutdown - Shutdown entry point 4488 * @device: Generic device structure 4489 */ 4490 static void megasas_shutdown(struct pci_dev *pdev) 4491 { 4492 struct megasas_instance *instance = pci_get_drvdata(pdev); 4493 instance->unload = 1; 4494 megasas_flush_cache(instance); 4495 megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN); 4496 } 4497 4498 /** 4499 * megasas_mgmt_open - char node "open" entry point 4500 */ 4501 static int megasas_mgmt_open(struct inode *inode, struct file *filep) 4502 { 4503 /* 4504 * Allow only those users with admin rights 4505 */ 4506 if (!capable(CAP_SYS_ADMIN)) 4507 return -EACCES; 4508 4509 return 0; 4510 } 4511 4512 /** 4513 * megasas_mgmt_fasync - Async notifier registration from applications 4514 * 4515 * This function adds the calling process to a driver global queue. When an 4516 * event occurs, SIGIO will be sent to all processes in this queue. 4517 */ 4518 static int megasas_mgmt_fasync(int fd, struct file *filep, int mode) 4519 { 4520 int rc; 4521 4522 mutex_lock(&megasas_async_queue_mutex); 4523 4524 rc = fasync_helper(fd, filep, mode, &megasas_async_queue); 4525 4526 mutex_unlock(&megasas_async_queue_mutex); 4527 4528 if (rc >= 0) { 4529 /* For sanity check when we get ioctl */ 4530 filep->private_data = filep; 4531 return 0; 4532 } 4533 4534 printk(KERN_DEBUG "megasas: fasync_helper failed [%d]\n", rc); 4535 4536 return rc; 4537 } 4538 4539 /** 4540 * megasas_mgmt_poll - char node "poll" entry point 4541 * */ 4542 static unsigned int megasas_mgmt_poll(struct file *file, poll_table *wait) 4543 { 4544 unsigned int mask; 4545 unsigned long flags; 4546 poll_wait(file, &megasas_poll_wait, wait); 4547 spin_lock_irqsave(&poll_aen_lock, flags); 4548 if (megasas_poll_wait_aen) 4549 mask = (POLLIN | POLLRDNORM); 4550 else 4551 mask = 0; 4552 spin_unlock_irqrestore(&poll_aen_lock, flags); 4553 return mask; 4554 } 4555 4556 /** 4557 * megasas_mgmt_fw_ioctl - Issues management ioctls to FW 4558 * @instance: Adapter soft state 4559 * @argp: User's ioctl packet 4560 */ 4561 static int 4562 megasas_mgmt_fw_ioctl(struct megasas_instance *instance, 4563 struct megasas_iocpacket __user * user_ioc, 4564 struct megasas_iocpacket *ioc) 4565 { 4566 struct megasas_sge32 *kern_sge32; 4567 struct megasas_cmd *cmd; 4568 void *kbuff_arr[MAX_IOCTL_SGE]; 4569 dma_addr_t buf_handle = 0; 4570 int error = 0, i; 4571 void *sense = NULL; 4572 dma_addr_t sense_handle; 4573 unsigned long *sense_ptr; 4574 4575 memset(kbuff_arr, 0, sizeof(kbuff_arr)); 4576 4577 if (ioc->sge_count > MAX_IOCTL_SGE) { 4578 printk(KERN_DEBUG "megasas: SGE count [%d] > max limit [%d]\n", 4579 ioc->sge_count, MAX_IOCTL_SGE); 4580 return -EINVAL; 4581 } 4582 4583 cmd = megasas_get_cmd(instance); 4584 if (!cmd) { 4585 printk(KERN_DEBUG "megasas: Failed to get a cmd packet\n"); 4586 return -ENOMEM; 4587 } 4588 4589 /* 4590 * User's IOCTL packet has 2 frames (maximum). Copy those two 4591 * frames into our cmd's frames. cmd->frame's context will get 4592 * overwritten when we copy from user's frames. So set that value 4593 * alone separately 4594 */ 4595 memcpy(cmd->frame, ioc->frame.raw, 2 * MEGAMFI_FRAME_SIZE); 4596 cmd->frame->hdr.context = cmd->index; 4597 cmd->frame->hdr.pad_0 = 0; 4598 4599 /* 4600 * The management interface between applications and the fw uses 4601 * MFI frames. E.g, RAID configuration changes, LD property changes 4602 * etc are accomplishes through different kinds of MFI frames. The 4603 * driver needs to care only about substituting user buffers with 4604 * kernel buffers in SGLs. The location of SGL is embedded in the 4605 * struct iocpacket itself. 4606 */ 4607 kern_sge32 = (struct megasas_sge32 *) 4608 ((unsigned long)cmd->frame + ioc->sgl_off); 4609 4610 /* 4611 * For each user buffer, create a mirror buffer and copy in 4612 */ 4613 for (i = 0; i < ioc->sge_count; i++) { 4614 kbuff_arr[i] = dma_alloc_coherent(&instance->pdev->dev, 4615 ioc->sgl[i].iov_len, 4616 &buf_handle, GFP_KERNEL); 4617 if (!kbuff_arr[i]) { 4618 printk(KERN_DEBUG "megasas: Failed to alloc " 4619 "kernel SGL buffer for IOCTL \n"); 4620 error = -ENOMEM; 4621 goto out; 4622 } 4623 4624 /* 4625 * We don't change the dma_coherent_mask, so 4626 * pci_alloc_consistent only returns 32bit addresses 4627 */ 4628 kern_sge32[i].phys_addr = (u32) buf_handle; 4629 kern_sge32[i].length = ioc->sgl[i].iov_len; 4630 4631 /* 4632 * We created a kernel buffer corresponding to the 4633 * user buffer. Now copy in from the user buffer 4634 */ 4635 if (copy_from_user(kbuff_arr[i], ioc->sgl[i].iov_base, 4636 (u32) (ioc->sgl[i].iov_len))) { 4637 error = -EFAULT; 4638 goto out; 4639 } 4640 } 4641 4642 if (ioc->sense_len) { 4643 sense = dma_alloc_coherent(&instance->pdev->dev, ioc->sense_len, 4644 &sense_handle, GFP_KERNEL); 4645 if (!sense) { 4646 error = -ENOMEM; 4647 goto out; 4648 } 4649 4650 sense_ptr = 4651 (unsigned long *) ((unsigned long)cmd->frame + ioc->sense_off); 4652 *sense_ptr = sense_handle; 4653 } 4654 4655 /* 4656 * Set the sync_cmd flag so that the ISR knows not to complete this 4657 * cmd to the SCSI mid-layer 4658 */ 4659 cmd->sync_cmd = 1; 4660 megasas_issue_blocked_cmd(instance, cmd); 4661 cmd->sync_cmd = 0; 4662 4663 /* 4664 * copy out the kernel buffers to user buffers 4665 */ 4666 for (i = 0; i < ioc->sge_count; i++) { 4667 if (copy_to_user(ioc->sgl[i].iov_base, kbuff_arr[i], 4668 ioc->sgl[i].iov_len)) { 4669 error = -EFAULT; 4670 goto out; 4671 } 4672 } 4673 4674 /* 4675 * copy out the sense 4676 */ 4677 if (ioc->sense_len) { 4678 /* 4679 * sense_ptr points to the location that has the user 4680 * sense buffer address 4681 */ 4682 sense_ptr = (unsigned long *) ((unsigned long)ioc->frame.raw + 4683 ioc->sense_off); 4684 4685 if (copy_to_user((void __user *)((unsigned long)(*sense_ptr)), 4686 sense, ioc->sense_len)) { 4687 printk(KERN_ERR "megasas: Failed to copy out to user " 4688 "sense data\n"); 4689 error = -EFAULT; 4690 goto out; 4691 } 4692 } 4693 4694 /* 4695 * copy the status codes returned by the fw 4696 */ 4697 if (copy_to_user(&user_ioc->frame.hdr.cmd_status, 4698 &cmd->frame->hdr.cmd_status, sizeof(u8))) { 4699 printk(KERN_DEBUG "megasas: Error copying out cmd_status\n"); 4700 error = -EFAULT; 4701 } 4702 4703 out: 4704 if (sense) { 4705 dma_free_coherent(&instance->pdev->dev, ioc->sense_len, 4706 sense, sense_handle); 4707 } 4708 4709 for (i = 0; i < ioc->sge_count && kbuff_arr[i]; i++) { 4710 dma_free_coherent(&instance->pdev->dev, 4711 kern_sge32[i].length, 4712 kbuff_arr[i], kern_sge32[i].phys_addr); 4713 } 4714 4715 megasas_return_cmd(instance, cmd); 4716 return error; 4717 } 4718 4719 static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg) 4720 { 4721 struct megasas_iocpacket __user *user_ioc = 4722 (struct megasas_iocpacket __user *)arg; 4723 struct megasas_iocpacket *ioc; 4724 struct megasas_instance *instance; 4725 int error; 4726 int i; 4727 unsigned long flags; 4728 u32 wait_time = MEGASAS_RESET_WAIT_TIME; 4729 4730 ioc = kmalloc(sizeof(*ioc), GFP_KERNEL); 4731 if (!ioc) 4732 return -ENOMEM; 4733 4734 if (copy_from_user(ioc, user_ioc, sizeof(*ioc))) { 4735 error = -EFAULT; 4736 goto out_kfree_ioc; 4737 } 4738 4739 instance = megasas_lookup_instance(ioc->host_no); 4740 if (!instance) { 4741 error = -ENODEV; 4742 goto out_kfree_ioc; 4743 } 4744 4745 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) { 4746 printk(KERN_ERR "Controller in crit error\n"); 4747 error = -ENODEV; 4748 goto out_kfree_ioc; 4749 } 4750 4751 if (instance->unload == 1) { 4752 error = -ENODEV; 4753 goto out_kfree_ioc; 4754 } 4755 4756 /* 4757 * We will allow only MEGASAS_INT_CMDS number of parallel ioctl cmds 4758 */ 4759 if (down_interruptible(&instance->ioctl_sem)) { 4760 error = -ERESTARTSYS; 4761 goto out_kfree_ioc; 4762 } 4763 4764 for (i = 0; i < wait_time; i++) { 4765 4766 spin_lock_irqsave(&instance->hba_lock, flags); 4767 if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) { 4768 spin_unlock_irqrestore(&instance->hba_lock, flags); 4769 break; 4770 } 4771 spin_unlock_irqrestore(&instance->hba_lock, flags); 4772 4773 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) { 4774 printk(KERN_NOTICE "megasas: waiting" 4775 "for controller reset to finish\n"); 4776 } 4777 4778 msleep(1000); 4779 } 4780 4781 spin_lock_irqsave(&instance->hba_lock, flags); 4782 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) { 4783 spin_unlock_irqrestore(&instance->hba_lock, flags); 4784 4785 printk(KERN_ERR "megaraid_sas: timed out while" 4786 "waiting for HBA to recover\n"); 4787 error = -ENODEV; 4788 goto out_kfree_ioc; 4789 } 4790 spin_unlock_irqrestore(&instance->hba_lock, flags); 4791 4792 error = megasas_mgmt_fw_ioctl(instance, user_ioc, ioc); 4793 up(&instance->ioctl_sem); 4794 4795 out_kfree_ioc: 4796 kfree(ioc); 4797 return error; 4798 } 4799 4800 static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg) 4801 { 4802 struct megasas_instance *instance; 4803 struct megasas_aen aen; 4804 int error; 4805 int i; 4806 unsigned long flags; 4807 u32 wait_time = MEGASAS_RESET_WAIT_TIME; 4808 4809 if (file->private_data != file) { 4810 printk(KERN_DEBUG "megasas: fasync_helper was not " 4811 "called first\n"); 4812 return -EINVAL; 4813 } 4814 4815 if (copy_from_user(&aen, (void __user *)arg, sizeof(aen))) 4816 return -EFAULT; 4817 4818 instance = megasas_lookup_instance(aen.host_no); 4819 4820 if (!instance) 4821 return -ENODEV; 4822 4823 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) { 4824 return -ENODEV; 4825 } 4826 4827 if (instance->unload == 1) { 4828 return -ENODEV; 4829 } 4830 4831 for (i = 0; i < wait_time; i++) { 4832 4833 spin_lock_irqsave(&instance->hba_lock, flags); 4834 if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) { 4835 spin_unlock_irqrestore(&instance->hba_lock, 4836 flags); 4837 break; 4838 } 4839 4840 spin_unlock_irqrestore(&instance->hba_lock, flags); 4841 4842 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) { 4843 printk(KERN_NOTICE "megasas: waiting for" 4844 "controller reset to finish\n"); 4845 } 4846 4847 msleep(1000); 4848 } 4849 4850 spin_lock_irqsave(&instance->hba_lock, flags); 4851 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) { 4852 spin_unlock_irqrestore(&instance->hba_lock, flags); 4853 printk(KERN_ERR "megaraid_sas: timed out while waiting" 4854 "for HBA to recover.\n"); 4855 return -ENODEV; 4856 } 4857 spin_unlock_irqrestore(&instance->hba_lock, flags); 4858 4859 mutex_lock(&instance->aen_mutex); 4860 error = megasas_register_aen(instance, aen.seq_num, 4861 aen.class_locale_word); 4862 mutex_unlock(&instance->aen_mutex); 4863 return error; 4864 } 4865 4866 /** 4867 * megasas_mgmt_ioctl - char node ioctl entry point 4868 */ 4869 static long 4870 megasas_mgmt_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 4871 { 4872 switch (cmd) { 4873 case MEGASAS_IOC_FIRMWARE: 4874 return megasas_mgmt_ioctl_fw(file, arg); 4875 4876 case MEGASAS_IOC_GET_AEN: 4877 return megasas_mgmt_ioctl_aen(file, arg); 4878 } 4879 4880 return -ENOTTY; 4881 } 4882 4883 #ifdef CONFIG_COMPAT 4884 static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg) 4885 { 4886 struct compat_megasas_iocpacket __user *cioc = 4887 (struct compat_megasas_iocpacket __user *)arg; 4888 struct megasas_iocpacket __user *ioc = 4889 compat_alloc_user_space(sizeof(struct megasas_iocpacket)); 4890 int i; 4891 int error = 0; 4892 compat_uptr_t ptr; 4893 4894 if (clear_user(ioc, sizeof(*ioc))) 4895 return -EFAULT; 4896 4897 if (copy_in_user(&ioc->host_no, &cioc->host_no, sizeof(u16)) || 4898 copy_in_user(&ioc->sgl_off, &cioc->sgl_off, sizeof(u32)) || 4899 copy_in_user(&ioc->sense_off, &cioc->sense_off, sizeof(u32)) || 4900 copy_in_user(&ioc->sense_len, &cioc->sense_len, sizeof(u32)) || 4901 copy_in_user(ioc->frame.raw, cioc->frame.raw, 128) || 4902 copy_in_user(&ioc->sge_count, &cioc->sge_count, sizeof(u32))) 4903 return -EFAULT; 4904 4905 /* 4906 * The sense_ptr is used in megasas_mgmt_fw_ioctl only when 4907 * sense_len is not null, so prepare the 64bit value under 4908 * the same condition. 4909 */ 4910 if (ioc->sense_len) { 4911 void __user **sense_ioc_ptr = 4912 (void __user **)(ioc->frame.raw + ioc->sense_off); 4913 compat_uptr_t *sense_cioc_ptr = 4914 (compat_uptr_t *)(cioc->frame.raw + cioc->sense_off); 4915 if (get_user(ptr, sense_cioc_ptr) || 4916 put_user(compat_ptr(ptr), sense_ioc_ptr)) 4917 return -EFAULT; 4918 } 4919 4920 for (i = 0; i < MAX_IOCTL_SGE; i++) { 4921 if (get_user(ptr, &cioc->sgl[i].iov_base) || 4922 put_user(compat_ptr(ptr), &ioc->sgl[i].iov_base) || 4923 copy_in_user(&ioc->sgl[i].iov_len, 4924 &cioc->sgl[i].iov_len, sizeof(compat_size_t))) 4925 return -EFAULT; 4926 } 4927 4928 error = megasas_mgmt_ioctl_fw(file, (unsigned long)ioc); 4929 4930 if (copy_in_user(&cioc->frame.hdr.cmd_status, 4931 &ioc->frame.hdr.cmd_status, sizeof(u8))) { 4932 printk(KERN_DEBUG "megasas: error copy_in_user cmd_status\n"); 4933 return -EFAULT; 4934 } 4935 return error; 4936 } 4937 4938 static long 4939 megasas_mgmt_compat_ioctl(struct file *file, unsigned int cmd, 4940 unsigned long arg) 4941 { 4942 switch (cmd) { 4943 case MEGASAS_IOC_FIRMWARE32: 4944 return megasas_mgmt_compat_ioctl_fw(file, arg); 4945 case MEGASAS_IOC_GET_AEN: 4946 return megasas_mgmt_ioctl_aen(file, arg); 4947 } 4948 4949 return -ENOTTY; 4950 } 4951 #endif 4952 4953 /* 4954 * File operations structure for management interface 4955 */ 4956 static const struct file_operations megasas_mgmt_fops = { 4957 .owner = THIS_MODULE, 4958 .open = megasas_mgmt_open, 4959 .fasync = megasas_mgmt_fasync, 4960 .unlocked_ioctl = megasas_mgmt_ioctl, 4961 .poll = megasas_mgmt_poll, 4962 #ifdef CONFIG_COMPAT 4963 .compat_ioctl = megasas_mgmt_compat_ioctl, 4964 #endif 4965 .llseek = noop_llseek, 4966 }; 4967 4968 /* 4969 * PCI hotplug support registration structure 4970 */ 4971 static struct pci_driver megasas_pci_driver = { 4972 4973 .name = "megaraid_sas", 4974 .id_table = megasas_pci_table, 4975 .probe = megasas_probe_one, 4976 .remove = __devexit_p(megasas_detach_one), 4977 .suspend = megasas_suspend, 4978 .resume = megasas_resume, 4979 .shutdown = megasas_shutdown, 4980 }; 4981 4982 /* 4983 * Sysfs driver attributes 4984 */ 4985 static ssize_t megasas_sysfs_show_version(struct device_driver *dd, char *buf) 4986 { 4987 return snprintf(buf, strlen(MEGASAS_VERSION) + 2, "%s\n", 4988 MEGASAS_VERSION); 4989 } 4990 4991 static DRIVER_ATTR(version, S_IRUGO, megasas_sysfs_show_version, NULL); 4992 4993 static ssize_t 4994 megasas_sysfs_show_release_date(struct device_driver *dd, char *buf) 4995 { 4996 return snprintf(buf, strlen(MEGASAS_RELDATE) + 2, "%s\n", 4997 MEGASAS_RELDATE); 4998 } 4999 5000 static DRIVER_ATTR(release_date, S_IRUGO, megasas_sysfs_show_release_date, 5001 NULL); 5002 5003 static ssize_t 5004 megasas_sysfs_show_support_poll_for_event(struct device_driver *dd, char *buf) 5005 { 5006 return sprintf(buf, "%u\n", support_poll_for_event); 5007 } 5008 5009 static DRIVER_ATTR(support_poll_for_event, S_IRUGO, 5010 megasas_sysfs_show_support_poll_for_event, NULL); 5011 5012 static ssize_t 5013 megasas_sysfs_show_support_device_change(struct device_driver *dd, char *buf) 5014 { 5015 return sprintf(buf, "%u\n", support_device_change); 5016 } 5017 5018 static DRIVER_ATTR(support_device_change, S_IRUGO, 5019 megasas_sysfs_show_support_device_change, NULL); 5020 5021 static ssize_t 5022 megasas_sysfs_show_dbg_lvl(struct device_driver *dd, char *buf) 5023 { 5024 return sprintf(buf, "%u\n", megasas_dbg_lvl); 5025 } 5026 5027 static ssize_t 5028 megasas_sysfs_set_dbg_lvl(struct device_driver *dd, const char *buf, size_t count) 5029 { 5030 int retval = count; 5031 if(sscanf(buf,"%u",&megasas_dbg_lvl)<1){ 5032 printk(KERN_ERR "megasas: could not set dbg_lvl\n"); 5033 retval = -EINVAL; 5034 } 5035 return retval; 5036 } 5037 5038 static DRIVER_ATTR(dbg_lvl, S_IRUGO|S_IWUSR, megasas_sysfs_show_dbg_lvl, 5039 megasas_sysfs_set_dbg_lvl); 5040 5041 static ssize_t 5042 megasas_sysfs_show_poll_mode_io(struct device_driver *dd, char *buf) 5043 { 5044 return sprintf(buf, "%u\n", poll_mode_io); 5045 } 5046 5047 static ssize_t 5048 megasas_sysfs_set_poll_mode_io(struct device_driver *dd, 5049 const char *buf, size_t count) 5050 { 5051 int retval = count; 5052 int tmp = poll_mode_io; 5053 int i; 5054 struct megasas_instance *instance; 5055 5056 if (sscanf(buf, "%u", &poll_mode_io) < 1) { 5057 printk(KERN_ERR "megasas: could not set poll_mode_io\n"); 5058 retval = -EINVAL; 5059 } 5060 5061 /* 5062 * Check if poll_mode_io is already set or is same as previous value 5063 */ 5064 if ((tmp && poll_mode_io) || (tmp == poll_mode_io)) 5065 goto out; 5066 5067 if (poll_mode_io) { 5068 /* 5069 * Start timers for all adapters 5070 */ 5071 for (i = 0; i < megasas_mgmt_info.max_index; i++) { 5072 instance = megasas_mgmt_info.instance[i]; 5073 if (instance) { 5074 megasas_start_timer(instance, 5075 &instance->io_completion_timer, 5076 megasas_io_completion_timer, 5077 MEGASAS_COMPLETION_TIMER_INTERVAL); 5078 } 5079 } 5080 } else { 5081 /* 5082 * Delete timers for all adapters 5083 */ 5084 for (i = 0; i < megasas_mgmt_info.max_index; i++) { 5085 instance = megasas_mgmt_info.instance[i]; 5086 if (instance) 5087 del_timer_sync(&instance->io_completion_timer); 5088 } 5089 } 5090 5091 out: 5092 return retval; 5093 } 5094 5095 static void 5096 megasas_aen_polling(struct work_struct *work) 5097 { 5098 struct megasas_aen_event *ev = 5099 container_of(work, struct megasas_aen_event, hotplug_work); 5100 struct megasas_instance *instance = ev->instance; 5101 union megasas_evt_class_locale class_locale; 5102 struct Scsi_Host *host; 5103 struct scsi_device *sdev1; 5104 u16 pd_index = 0; 5105 u16 ld_index = 0; 5106 int i, j, doscan = 0; 5107 u32 seq_num; 5108 int error; 5109 5110 if (!instance) { 5111 printk(KERN_ERR "invalid instance!\n"); 5112 kfree(ev); 5113 return; 5114 } 5115 instance->ev = NULL; 5116 host = instance->host; 5117 if (instance->evt_detail) { 5118 5119 switch (instance->evt_detail->code) { 5120 case MR_EVT_PD_INSERTED: 5121 if (megasas_get_pd_list(instance) == 0) { 5122 for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) { 5123 for (j = 0; 5124 j < MEGASAS_MAX_DEV_PER_CHANNEL; 5125 j++) { 5126 5127 pd_index = 5128 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j; 5129 5130 sdev1 = 5131 scsi_device_lookup(host, i, j, 0); 5132 5133 if (instance->pd_list[pd_index].driveState 5134 == MR_PD_STATE_SYSTEM) { 5135 if (!sdev1) { 5136 scsi_add_device(host, i, j, 0); 5137 } 5138 5139 if (sdev1) 5140 scsi_device_put(sdev1); 5141 } 5142 } 5143 } 5144 } 5145 doscan = 0; 5146 break; 5147 5148 case MR_EVT_PD_REMOVED: 5149 if (megasas_get_pd_list(instance) == 0) { 5150 megasas_get_pd_list(instance); 5151 for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) { 5152 for (j = 0; 5153 j < MEGASAS_MAX_DEV_PER_CHANNEL; 5154 j++) { 5155 5156 pd_index = 5157 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j; 5158 5159 sdev1 = 5160 scsi_device_lookup(host, i, j, 0); 5161 5162 if (instance->pd_list[pd_index].driveState 5163 == MR_PD_STATE_SYSTEM) { 5164 if (sdev1) { 5165 scsi_device_put(sdev1); 5166 } 5167 } else { 5168 if (sdev1) { 5169 scsi_remove_device(sdev1); 5170 scsi_device_put(sdev1); 5171 } 5172 } 5173 } 5174 } 5175 } 5176 doscan = 0; 5177 break; 5178 5179 case MR_EVT_LD_OFFLINE: 5180 case MR_EVT_LD_DELETED: 5181 megasas_get_ld_list(instance); 5182 for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) { 5183 for (j = 0; 5184 j < MEGASAS_MAX_DEV_PER_CHANNEL; 5185 j++) { 5186 5187 ld_index = 5188 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j; 5189 5190 sdev1 = scsi_device_lookup(host, 5191 i + MEGASAS_MAX_LD_CHANNELS, 5192 j, 5193 0); 5194 5195 if (instance->ld_ids[ld_index] != 0xff) { 5196 if (sdev1) { 5197 scsi_device_put(sdev1); 5198 } 5199 } else { 5200 if (sdev1) { 5201 scsi_remove_device(sdev1); 5202 scsi_device_put(sdev1); 5203 } 5204 } 5205 } 5206 } 5207 doscan = 0; 5208 break; 5209 case MR_EVT_LD_CREATED: 5210 megasas_get_ld_list(instance); 5211 for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) { 5212 for (j = 0; 5213 j < MEGASAS_MAX_DEV_PER_CHANNEL; 5214 j++) { 5215 ld_index = 5216 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j; 5217 5218 sdev1 = scsi_device_lookup(host, 5219 i+MEGASAS_MAX_LD_CHANNELS, 5220 j, 0); 5221 5222 if (instance->ld_ids[ld_index] != 5223 0xff) { 5224 if (!sdev1) { 5225 scsi_add_device(host, 5226 i + 2, 5227 j, 0); 5228 } 5229 } 5230 if (sdev1) { 5231 scsi_device_put(sdev1); 5232 } 5233 } 5234 } 5235 doscan = 0; 5236 break; 5237 case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED: 5238 case MR_EVT_FOREIGN_CFG_IMPORTED: 5239 case MR_EVT_LD_STATE_CHANGE: 5240 doscan = 1; 5241 break; 5242 default: 5243 doscan = 0; 5244 break; 5245 } 5246 } else { 5247 printk(KERN_ERR "invalid evt_detail!\n"); 5248 kfree(ev); 5249 return; 5250 } 5251 5252 if (doscan) { 5253 printk(KERN_INFO "scanning ...\n"); 5254 megasas_get_pd_list(instance); 5255 for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) { 5256 for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) { 5257 pd_index = i*MEGASAS_MAX_DEV_PER_CHANNEL + j; 5258 sdev1 = scsi_device_lookup(host, i, j, 0); 5259 if (instance->pd_list[pd_index].driveState == 5260 MR_PD_STATE_SYSTEM) { 5261 if (!sdev1) { 5262 scsi_add_device(host, i, j, 0); 5263 } 5264 if (sdev1) 5265 scsi_device_put(sdev1); 5266 } else { 5267 if (sdev1) { 5268 scsi_remove_device(sdev1); 5269 scsi_device_put(sdev1); 5270 } 5271 } 5272 } 5273 } 5274 5275 megasas_get_ld_list(instance); 5276 for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) { 5277 for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) { 5278 ld_index = 5279 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j; 5280 5281 sdev1 = scsi_device_lookup(host, 5282 i+MEGASAS_MAX_LD_CHANNELS, j, 0); 5283 if (instance->ld_ids[ld_index] != 0xff) { 5284 if (!sdev1) { 5285 scsi_add_device(host, 5286 i+2, 5287 j, 0); 5288 } else { 5289 scsi_device_put(sdev1); 5290 } 5291 } else { 5292 if (sdev1) { 5293 scsi_remove_device(sdev1); 5294 scsi_device_put(sdev1); 5295 } 5296 } 5297 } 5298 } 5299 } 5300 5301 if ( instance->aen_cmd != NULL ) { 5302 kfree(ev); 5303 return ; 5304 } 5305 5306 seq_num = instance->evt_detail->seq_num + 1; 5307 5308 /* Register AEN with FW for latest sequence number plus 1 */ 5309 class_locale.members.reserved = 0; 5310 class_locale.members.locale = MR_EVT_LOCALE_ALL; 5311 class_locale.members.class = MR_EVT_CLASS_DEBUG; 5312 mutex_lock(&instance->aen_mutex); 5313 error = megasas_register_aen(instance, seq_num, 5314 class_locale.word); 5315 mutex_unlock(&instance->aen_mutex); 5316 5317 if (error) 5318 printk(KERN_ERR "register aen failed error %x\n", error); 5319 5320 kfree(ev); 5321 } 5322 5323 5324 static DRIVER_ATTR(poll_mode_io, S_IRUGO|S_IWUSR, 5325 megasas_sysfs_show_poll_mode_io, 5326 megasas_sysfs_set_poll_mode_io); 5327 5328 /** 5329 * megasas_init - Driver load entry point 5330 */ 5331 static int __init megasas_init(void) 5332 { 5333 int rval; 5334 5335 /* 5336 * Announce driver version and other information 5337 */ 5338 printk(KERN_INFO "megasas: %s %s\n", MEGASAS_VERSION, 5339 MEGASAS_EXT_VERSION); 5340 5341 support_poll_for_event = 2; 5342 support_device_change = 1; 5343 5344 memset(&megasas_mgmt_info, 0, sizeof(megasas_mgmt_info)); 5345 5346 /* 5347 * Register character device node 5348 */ 5349 rval = register_chrdev(0, "megaraid_sas_ioctl", &megasas_mgmt_fops); 5350 5351 if (rval < 0) { 5352 printk(KERN_DEBUG "megasas: failed to open device node\n"); 5353 return rval; 5354 } 5355 5356 megasas_mgmt_majorno = rval; 5357 5358 /* 5359 * Register ourselves as PCI hotplug module 5360 */ 5361 rval = pci_register_driver(&megasas_pci_driver); 5362 5363 if (rval) { 5364 printk(KERN_DEBUG "megasas: PCI hotplug regisration failed \n"); 5365 goto err_pcidrv; 5366 } 5367 5368 rval = driver_create_file(&megasas_pci_driver.driver, 5369 &driver_attr_version); 5370 if (rval) 5371 goto err_dcf_attr_ver; 5372 rval = driver_create_file(&megasas_pci_driver.driver, 5373 &driver_attr_release_date); 5374 if (rval) 5375 goto err_dcf_rel_date; 5376 5377 rval = driver_create_file(&megasas_pci_driver.driver, 5378 &driver_attr_support_poll_for_event); 5379 if (rval) 5380 goto err_dcf_support_poll_for_event; 5381 5382 rval = driver_create_file(&megasas_pci_driver.driver, 5383 &driver_attr_dbg_lvl); 5384 if (rval) 5385 goto err_dcf_dbg_lvl; 5386 rval = driver_create_file(&megasas_pci_driver.driver, 5387 &driver_attr_poll_mode_io); 5388 if (rval) 5389 goto err_dcf_poll_mode_io; 5390 5391 rval = driver_create_file(&megasas_pci_driver.driver, 5392 &driver_attr_support_device_change); 5393 if (rval) 5394 goto err_dcf_support_device_change; 5395 5396 return rval; 5397 5398 err_dcf_support_device_change: 5399 driver_remove_file(&megasas_pci_driver.driver, 5400 &driver_attr_poll_mode_io); 5401 5402 err_dcf_poll_mode_io: 5403 driver_remove_file(&megasas_pci_driver.driver, 5404 &driver_attr_dbg_lvl); 5405 err_dcf_dbg_lvl: 5406 driver_remove_file(&megasas_pci_driver.driver, 5407 &driver_attr_support_poll_for_event); 5408 5409 err_dcf_support_poll_for_event: 5410 driver_remove_file(&megasas_pci_driver.driver, 5411 &driver_attr_release_date); 5412 5413 err_dcf_rel_date: 5414 driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version); 5415 err_dcf_attr_ver: 5416 pci_unregister_driver(&megasas_pci_driver); 5417 err_pcidrv: 5418 unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl"); 5419 return rval; 5420 } 5421 5422 /** 5423 * megasas_exit - Driver unload entry point 5424 */ 5425 static void __exit megasas_exit(void) 5426 { 5427 driver_remove_file(&megasas_pci_driver.driver, 5428 &driver_attr_poll_mode_io); 5429 driver_remove_file(&megasas_pci_driver.driver, 5430 &driver_attr_dbg_lvl); 5431 driver_remove_file(&megasas_pci_driver.driver, 5432 &driver_attr_support_poll_for_event); 5433 driver_remove_file(&megasas_pci_driver.driver, 5434 &driver_attr_support_device_change); 5435 driver_remove_file(&megasas_pci_driver.driver, 5436 &driver_attr_release_date); 5437 driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version); 5438 5439 pci_unregister_driver(&megasas_pci_driver); 5440 unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl"); 5441 } 5442 5443 module_init(megasas_init); 5444 module_exit(megasas_exit); 5445